From a1a4d48f19da879b56130adc2405188f3ecf9be9 Mon Sep 17 00:00:00 2001 From: Kyle Leaders Date: Tue, 4 Apr 2023 14:36:04 -0700 Subject: [PATCH 1/9] clippy fixes and cargo fmt --- src/matchspec.rs | 93 +++++++++++++++++++++++++----------------------- 1 file changed, 48 insertions(+), 45 deletions(-) diff --git a/src/matchspec.rs b/src/matchspec.rs index e8aaf47..10e3064 100644 --- a/src/matchspec.rs +++ b/src/matchspec.rs @@ -1,21 +1,21 @@ -use crate::parsers::*; -use crate::package_candidate::*; +use crate::error::MatchSpecError; use crate::input_table::*; +use crate::package_candidate::*; +use crate::parsers::*; use nom::branch::alt; use nom::error::Error as NomError; use nom::Finish; use std::fmt::Debug; use std::str::FromStr; use version_compare::{compare_to, Cmp}; -use crate::error::MatchSpecError; /// Matches a string with a string (possibly) containing globs fn is_match_glob_str(glob_str: &str, match_str: &str) -> bool { let mut index: Option = Some(0); - let mut it = glob_str.split("*").peekable(); + let mut it = glob_str.split('*').peekable(); while let Some(part) = it.next() { index = match_str.get(index.unwrap()..).and_then(|s| s.find(part)); - if index == None || (it.peek().is_none() && !match_str.ends_with(part)) { + if index.is_none() || (it.peek().is_none() && !match_str.ends_with(part)) { return false; } } @@ -34,8 +34,8 @@ pub enum Selector { } impl From for Selector - where - S: AsRef, +where + S: AsRef, { fn from(value: S) -> Self { match value.as_ref() { @@ -88,8 +88,8 @@ impl Selector { /// ``` #[derive(Clone, Debug, PartialEq, Eq)] pub enum CompoundSelector - where - S: Into + AsRef, +where + S: Into + AsRef, { Single { selector: Selector, @@ -129,9 +129,9 @@ impl Default for CompoundSelector { /// }); /// ``` impl From<(S, V)> for CompoundSelector - where - S: Into, - V: Into, +where + S: Into, + V: Into, { fn from(input: (S, V)) -> Self { CompoundSelector::Single { @@ -141,11 +141,10 @@ impl From<(S, V)> for CompoundSelector } } - impl From<((S, V), char, (S, V))> for CompoundSelector - where - S: Into, - V: Into, +where + S: Into, + V: Into, { fn from((one, boolean, two): ((S, V), char, (S, V))) -> Self { match boolean { @@ -156,10 +155,9 @@ impl From<((S, V), char, (S, V))> for CompoundSelector } } - impl CompoundSelector - where - S: AsRef + PartialEq + Into, +where + S: AsRef + PartialEq + Into, { /// This takes a versions and tests that it falls within the constraints of this CompoundSelector /// ``` @@ -240,9 +238,9 @@ impl CompoundSelector /// }); /// ``` impl From<(S, V, V, S, V)> for CompoundSelector - where - S: Into, - V: Into + AsRef + PartialEq + std::fmt::Display, +where + S: Into, + V: Into + AsRef + PartialEq + std::fmt::Display, { fn from( (first_selector, first_version, joiner, second_selector, second_version): (S, V, V, S, V), @@ -284,8 +282,8 @@ impl From<(S, V, V, S, V)> for CompoundSelector /// and [here](https://conda.io/projects/conda-build/en/latest/resources/package-spec.html#build-version-spec) in the spec #[derive(Debug, Clone, Eq)] pub struct MatchSpec - where - S: AsRef + PartialEq + PartialOrd + Into, +where + S: AsRef + PartialEq + PartialOrd + Into, { pub channel: Option, pub subdir: Option, @@ -300,8 +298,8 @@ pub struct MatchSpec /// If we don't know how to understand it, we should ignore the key value for the purpose of struct /// equality. Makes it simpler to handle potentially unknown future additions to the spec. impl PartialEq for MatchSpec - where - S: AsRef + PartialEq + PartialOrd + Into, +where + S: AsRef + PartialEq + PartialOrd + Into, { fn eq(&self, other: &Self) -> bool { self.channel == other.channel @@ -333,14 +331,16 @@ impl FromStr for MatchSpec { fn from_str(s: &str) -> Result { match alt((implicit_matchspec_parser, full_matchspec_parser))(s).finish() { Ok((_, ms)) => Ok(ms), - Err(NomError { input, code: _ }) => Err(MatchSpecError { message: String::from(input) }), + Err(NomError { input, code: _ }) => Err(MatchSpecError { + message: String::from(input), + }), } } } impl From<(S, Option, Option)> for MatchSpec - where - S: AsRef + Into, +where + S: AsRef + Into, { fn from((package, version, build): (S, Option, Option)) -> Self { MatchSpec { @@ -348,7 +348,10 @@ impl From<(S, Option, Option)> for MatchSpec subdir: None, namespace: None, package: package.into(), - version: version.map(|s| CompoundSelector::Single { selector: Selector::EqualTo, version: s.into() }), + version: version.map(|s| CompoundSelector::Single { + selector: Selector::EqualTo, + version: s.into(), + }), build: build.map(|s| s.into()), key_value_pairs: Vec::new(), } @@ -356,16 +359,16 @@ impl From<(S, Option, Option)> for MatchSpec } impl -From<( - Option, - Option, - Option, - S, - Option>, - Option>, -)> for MatchSpec - where - S: Into + AsRef + PartialEq + std::fmt::Display, + From<( + Option, + Option, + Option, + S, + Option>, + Option>, + )> for MatchSpec +where + S: Into + AsRef + PartialEq + std::fmt::Display, { fn from( (channel, subdir, ns, package, cs, keys): ( @@ -433,7 +436,6 @@ From<( } } - impl + PartialOrd + PartialEq + Into> MatchSpec { /// Matches package names. The matchspec package may contain globs /// ``` @@ -455,7 +457,10 @@ impl + PartialOrd + PartialEq + Into> MatchSpec { /// assert!(ms.is_version_match(&"1.1.1r")); /// ``` pub fn is_version_match + PartialEq>(&self, version: &V) -> bool { - self.version.as_ref().map(|v| v.is_match(version)).unwrap_or(true) + self.version + .as_ref() + .map(|v| v.is_match(version)) + .unwrap_or(true) } pub fn is_package_version_match + PartialEq>( @@ -471,9 +476,7 @@ impl + PartialOrd + PartialEq + Into> MatchSpec { impl MatchSpec { pub fn is_match(&self, pc: &PackageCandidate) -> bool { - self.is_package_version_match( - &pc.name, - &pc.version.as_ref().unwrap_or(&String::new())) + self.is_package_version_match(&pc.name, pc.version.as_ref().unwrap_or(&String::new())) && (self.subdir.is_none() || self.subdir == pc.subdir) && (self.build.is_none() || self.build == pc.build) } From aac1520d6375edb2a30cecbfb459883d134d862e Mon Sep 17 00:00:00 2001 From: Kyle Leaders Date: Tue, 4 Apr 2023 14:36:50 -0700 Subject: [PATCH 2/9] Flatten python module heirarchy * rust_matchspec is now a toplevel module, no need to do `import rust_matchspec.rust_matchspec.*` * version bump to `0.2.0` due to the above import change --- .gitignore | 3 ++- Cargo.toml | 2 +- pyproject.toml | 2 +- python/rust_matchspec/__init__.py | 6 +++--- 4 files changed, 7 insertions(+), 6 deletions(-) diff --git a/.gitignore b/.gitignore index a58a673..468d438 100644 --- a/.gitignore +++ b/.gitignore @@ -3,4 +3,5 @@ .idea/* pvenv/* python/* -main.py \ No newline at end of file +main.py +venv/* diff --git a/Cargo.toml b/Cargo.toml index dad68c9..5242a0a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "matchspec" -version = "0.1.1" +version = "0.2.0" edition = "2021" [lib] diff --git a/pyproject.toml b/pyproject.toml index d75a90d..c1354fa 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ requires = ["maturin>=0.14,<0.15"] [project] name = "rust_matchspec" -version = "0.1.1" +version = "0.2.0" description = "A conda matchspec written in Rust" requires-python = ">=3.7" diff --git a/python/rust_matchspec/__init__.py b/python/rust_matchspec/__init__.py index 3e2ab54..61fb28e 100644 --- a/python/rust_matchspec/__init__.py +++ b/python/rust_matchspec/__init__.py @@ -1,4 +1,4 @@ -from rust_matchspec import rust_matchspec +from .rust_matchspec import * -__name__="rust_matchspec" -__version__="0.1.0" +__name__ = "rust_matchspec" +__version__ = "0.2.0" From f11b946b99e762a0993ed499ce9a06f880fa2ce8 Mon Sep 17 00:00:00 2001 From: Kyle Leaders Date: Wed, 5 Apr 2023 15:08:51 -0700 Subject: [PATCH 3/9] Dropping MatchSpec in favor of Matchspec * MatchSpec no longer uses a type parameter. This is necessary to allow for usage in Python since pyo3 can't share parameterized types. Also makes it quite a bit easier to use. * Adds `filter_package_list` using new MatchSpec --- benches/parsing.rs | 8 +-- src/error.rs | 1 - src/matchspec.rs | 151 ++++++++++++++++++--------------------- src/package_candidate.rs | 102 ++++++++++++++++++++++---- src/parsers.rs | 87 +++++++++++----------- src/python.rs | 57 +++++++++++++-- 6 files changed, 257 insertions(+), 149 deletions(-) diff --git a/benches/parsing.rs b/benches/parsing.rs index 01d8a48..820b60f 100644 --- a/benches/parsing.rs +++ b/benches/parsing.rs @@ -7,20 +7,20 @@ fn criterion_benchmark(c: &mut Criterion) { c.bench_function("Package name only", |b| { b.iter(|| { // This is a complex but not unlikely matchspec - black_box("tzdata").parse::>() + black_box("tzdata").parse::() }) }); c.bench_function("Package name and version", |b| { b.iter(|| { // This is a complex but not unlikely matchspec - black_box("openssl>1.1.1g").parse::>() + black_box("openssl>1.1.1g").parse::() }) }); c.bench_function("All possible matchers", |b| { b.iter(|| { // This is a complex but not unlikely matchspec black_box("conda-forge/linux-64:NAMESPACE:tensorflow>=1.9.2[license=\"GPL\", subdir=\"linux-64\"]") - .parse::>() + .parse::() }) }); @@ -37,7 +37,7 @@ fn criterion_benchmark(c: &mut Criterion) { .collect(); b.iter(|| { for d in &depends { - d.parse::>().unwrap(); + d.parse::().unwrap(); } }) }); diff --git a/src/error.rs b/src/error.rs index 974ddea..a8cad76 100644 --- a/src/error.rs +++ b/src/error.rs @@ -12,4 +12,3 @@ impl Display for MatchSpecError { write!(f, "{}", self.message) } } - diff --git a/src/matchspec.rs b/src/matchspec.rs index 10e3064..7ebb5ee 100644 --- a/src/matchspec.rs +++ b/src/matchspec.rs @@ -5,6 +5,7 @@ use crate::parsers::*; use nom::branch::alt; use nom::error::Error as NomError; use nom::Finish; +use pyo3::prelude::*; use std::fmt::Debug; use std::str::FromStr; use version_compare::{compare_to, Cmp}; @@ -198,10 +199,10 @@ where /// assert!(!or.is_match(&"1.1.1")); /// assert!(!or.is_match(&"1.1.7")); /// ``` - pub fn is_match + PartialEq>(&self, other: &V) -> bool { + pub fn is_match(&self, other: &str) -> bool { match self { CompoundSelector::Single { selector, version } => { - selector.boolean_operator()(other.as_ref(), version.as_ref()) + selector.boolean_operator()(other, version.as_ref()) } CompoundSelector::And { first_selector, @@ -209,8 +210,8 @@ where second_selector, second_version, } => { - first_selector.boolean_operator()(other.as_ref(), first_version.as_ref()) - && second_selector.boolean_operator()(other.as_ref(), second_version.as_ref()) + first_selector.boolean_operator()(other, first_version.as_ref()) + && second_selector.boolean_operator()(other, second_version.as_ref()) } CompoundSelector::Or { first_selector, @@ -218,8 +219,8 @@ where second_selector, second_version, } => { - first_selector.boolean_operator()(other.as_ref(), first_version.as_ref()) - || second_selector.boolean_operator()(other.as_ref(), second_version.as_ref()) + first_selector.boolean_operator()(other, first_version.as_ref()) + || second_selector.boolean_operator()(other, second_version.as_ref()) } } } @@ -280,27 +281,22 @@ where /// ``` /// Full MatchSpec documentation is found in the code [here](https://github.com/conda/conda/blob/main/conda/models/match_spec.py) /// and [here](https://conda.io/projects/conda-build/en/latest/resources/package-spec.html#build-version-spec) in the spec +#[pyclass] #[derive(Debug, Clone, Eq)] -pub struct MatchSpec -where - S: AsRef + PartialEq + PartialOrd + Into, -{ - pub channel: Option, - pub subdir: Option, - pub namespace: Option, - pub package: S, - pub version: Option>, - pub build: Option, - pub key_value_pairs: Vec<(S, Selector, S)>, +pub struct MatchSpec { + pub channel: Option, + pub subdir: Option, + pub namespace: Option, + pub package: String, + pub version: Option>, + pub build: Option, + pub key_value_pairs: Vec<(String, Selector, String)>, } /// Custom implementation to make sure that we don't compare key_value_pairs /// If we don't know how to understand it, we should ignore the key value for the purpose of struct /// equality. Makes it simpler to handle potentially unknown future additions to the spec. -impl PartialEq for MatchSpec -where - S: AsRef + PartialEq + PartialOrd + Into, -{ +impl PartialEq for MatchSpec { fn eq(&self, other: &Self) -> bool { self.channel == other.channel && self.subdir == other.subdir @@ -311,7 +307,7 @@ where } } -impl Default for MatchSpec { +impl Default for MatchSpec { fn default() -> Self { MatchSpec { channel: None, @@ -326,7 +322,7 @@ impl Default for MatchSpec { } /// This is where we actually do the parsing -impl FromStr for MatchSpec { +impl FromStr for MatchSpec { type Err = MatchSpecError; fn from_str(s: &str) -> Result { match alt((implicit_matchspec_parser, full_matchspec_parser))(s).finish() { @@ -338,11 +334,8 @@ impl FromStr for MatchSpec { } } -impl From<(S, Option, Option)> for MatchSpec -where - S: AsRef + Into, -{ - fn from((package, version, build): (S, Option, Option)) -> Self { +impl From<(&str, Option<&str>, Option<&str>)> for MatchSpec { + fn from((package, version, build): (&str, Option<&str>, Option<&str>)) -> Self { MatchSpec { channel: None, subdir: None, @@ -358,39 +351,37 @@ where } } -impl +impl From<( - Option, - Option, - Option, - S, + Option<&str>, + Option<&str>, + Option<&str>, + &str, Option>, - Option>, - )> for MatchSpec -where - S: Into + AsRef + PartialEq + std::fmt::Display, + Option>, + )> for MatchSpec { fn from( (channel, subdir, ns, package, cs, keys): ( - Option, - Option, - Option, - S, + Option<&str>, + Option<&str>, + Option<&str>, + &str, Option>, - Option>, + Option>, ), ) -> Self { // Convert the key_value_pairs into (S, Selector, S) tuples. // I'm not sure its possible to have the full selector set, but this models it in a // pretty good way. let key_value_pairs: Vec<(String, Selector, String)> = keys - .map(|vec: Vec<(S, S, S)>| { + .map(|vec: Vec<(&str, &str, &str)>| { vec.iter() .map(|(key, selector, value)| { ( - key.as_ref().to_string(), + String::from(*key), Selector::from(selector), - value.as_ref().to_string(), + String::from(*value), ) }) .collect() @@ -398,7 +389,7 @@ where .unwrap_or_default(); let namespace = if let Some(a) = ns { - if a.as_ref().is_empty() { + if a.is_empty() { None } else { Some(a.to_string()) @@ -436,16 +427,16 @@ where } } -impl + PartialOrd + PartialEq + Into> MatchSpec { +impl MatchSpec { /// Matches package names. The matchspec package may contain globs /// ``` /// use rust_matchspec::matchspec::*; /// - /// let ms: MatchSpec = "openssl>1.1.1a".parse().unwrap(); + /// let ms: MatchSpec = "openssl>1.1.1a".parse().unwrap(); /// assert!(ms.is_package_match("openssl".to_string())); /// ``` - pub fn is_package_match(&self, package: S) -> bool { - package.as_ref().chars().all(is_alphanumeric_with_dashes) + pub fn is_package_match(&self, package: String) -> bool { + package.chars().all(is_alphanumeric_with_dashes) && is_match_glob_str(self.package.as_ref(), package.as_ref()) } @@ -453,28 +444,24 @@ impl + PartialOrd + PartialEq + Into> MatchSpec { /// ``` /// use rust_matchspec::matchspec::*; /// - /// let ms: MatchSpec = "openssl>1.1.1a".parse().unwrap(); + /// let ms: MatchSpec = "openssl>1.1.1a".parse().unwrap(); /// assert!(ms.is_version_match(&"1.1.1r")); /// ``` - pub fn is_version_match + PartialEq>(&self, version: &V) -> bool { + pub fn is_version_match(&self, version: &str) -> bool { self.version .as_ref() .map(|v| v.is_match(version)) .unwrap_or(true) } - pub fn is_package_version_match + PartialEq>( - &self, - package: &V, - version: &V, - ) -> bool { - package.as_ref().chars().all(is_alphanumeric_with_dashes) - && is_match_glob_str(self.package.as_ref(), package.as_ref()) + pub fn is_package_version_match(&self, package: &str, version: &str) -> bool { + package.chars().all(is_alphanumeric_with_dashes) + && is_match_glob_str(self.package.as_ref(), package) && self.is_version_match(version) } } -impl MatchSpec { +impl MatchSpec { pub fn is_match(&self, pc: &PackageCandidate) -> bool { self.is_package_version_match(&pc.name, pc.version.as_ref().unwrap_or(&String::new())) && (self.subdir.is_none() || self.subdir == pc.subdir) @@ -490,7 +477,7 @@ mod test { #[test] fn package_only() { - let mut ms: MatchSpec = "tensorflow".parse().unwrap(); + let mut ms: MatchSpec = "tensorflow".parse().unwrap(); assert!(ms.is_package_match("tensorflow".to_string())); assert!(!ms.is_package_match("pytorch".to_string())); @@ -513,10 +500,10 @@ mod test { #[test] fn package_and_version_only() { - let ms: MatchSpec = "tensorflow>1.9.2".parse().unwrap(); + let ms: MatchSpec = "tensorflow>1.9.2".parse().unwrap(); - assert!(ms.is_package_version_match(&"tensorflow", &"1.9.3")); - assert!(!ms.is_package_version_match(&"tensorflow", &"1.9.0")); + assert!(ms.is_package_version_match("tensorflow", "1.9.3")); + assert!(!ms.is_package_version_match("tensorflow", "1.9.0")); } #[test] @@ -526,10 +513,10 @@ mod test { version: "1.1.1", }; - assert!(single.is_match(&"1.2.1")); - assert!(single.is_match(&"3.0.0")); - assert!(!single.is_match(&"1.1.1")); - assert!(!single.is_match(&"0.1.1")); + assert!(single.is_match("1.2.1")); + assert!(single.is_match("3.0.0")); + assert!(!single.is_match("1.1.1")); + assert!(!single.is_match("0.1.1")); let and = CompoundSelector::And { first_selector: Selector::GreaterThan, @@ -538,10 +525,10 @@ mod test { second_version: "1.2.1", }; - assert!(and.is_match(&"1.2.1")); - assert!(and.is_match(&"1.1.7")); - assert!(!and.is_match(&"1.2.2")); - assert!(!and.is_match(&"0.1.1")); + assert!(and.is_match("1.2.1")); + assert!(and.is_match("1.1.7")); + assert!(!and.is_match("1.2.2")); + assert!(!and.is_match("0.1.1")); let or = CompoundSelector::Or { first_selector: Selector::LessThan, @@ -550,20 +537,20 @@ mod test { second_version: "1.2.1", }; - assert!(or.is_match(&"3.0.0")); - assert!(or.is_match(&"0.1.1")); - assert!(!or.is_match(&"1.2.1")); - assert!(!or.is_match(&"1.1.1")); - assert!(!or.is_match(&"1.1.7")); + assert!(or.is_match("3.0.0")); + assert!(or.is_match("0.1.1")); + assert!(!or.is_match("1.2.1")); + assert!(!or.is_match("1.1.1")); + assert!(!or.is_match("1.1.7")); } #[test] fn test_version_compare() { - let ms: MatchSpec = "python>3.6".parse().unwrap(); - assert!(!ms.is_package_version_match(&"python", &"3.5")); - assert!(ms.is_package_version_match(&"python", &"3.8")); - assert!(ms.is_package_version_match(&"python", &"3.9")); - assert!(ms.is_package_version_match(&"python", &"3.10")); + let ms: MatchSpec = "python>3.6".parse().unwrap(); + assert!(!ms.is_package_version_match("python", "3.5")); + assert!(ms.is_package_version_match("python", "3.8")); + assert!(ms.is_package_version_match("python", "3.9")); + assert!(ms.is_package_version_match("python", "3.10")); } } } diff --git a/src/package_candidate.rs b/src/package_candidate.rs index 22230de..581cdbb 100644 --- a/src/package_candidate.rs +++ b/src/package_candidate.rs @@ -1,8 +1,11 @@ -use serde::{Serialize, Deserialize}; -use std::fmt::Debug; use crate::matchspec::*; +use pyo3::prelude::*; +use pyo3::types::{PyAny, PyDict}; +use serde::{Deserialize, Serialize}; +use std::fmt::Debug; -#[derive(Serialize, Deserialize, Debug, Default)] +#[pyclass] +#[derive(Serialize, Deserialize, Debug, Default, Clone)] pub struct PackageCandidate { pub name: String, pub version: Option, @@ -18,20 +21,95 @@ pub struct PackageCandidate { pub timestamp: Option, } -impl From for PackageCandidate - where - S: AsRef, -{ - fn from(s: S) -> Self { - let package_candidate: PackageCandidate = serde_json::from_str(s.as_ref()).unwrap(); +impl From<&str> for PackageCandidate { + fn from(s: &str) -> Self { + let package_candidate: PackageCandidate = serde_json::from_str(s).unwrap(); package_candidate } } +#[pymethods] impl PackageCandidate { - pub fn is_match(&self, ms: &MatchSpec) -> bool { + #[new] + pub fn new( + name: String, + version: Option, + build: Option, + build_number: Option, + depends: Option>, + license: Option, + md5: Option, + sha256: Option, + size: Option, + subdir: Option, + timestamp: Option, + ) -> Self { + PackageCandidate { + name, + version, + build, + build_number, + license, + md5, + sha256, + size, + subdir, + timestamp, + depends: depends.unwrap_or_default(), + } + } + + pub fn is_match(&self, ms: &MatchSpec) -> bool { ms.is_match(self) } + + pub fn __repr__(&self) -> String { + match (&self.name, &self.version, &self.build, &self.build_number) { + (name, Some(version), Some(build), Some(build_number)) => { + format!( + "PackageCandidate(name={}, version={}, build={}, build_number={})", + name, version, build, build_number + ) + } + (name, Some(version), None, None) => { + format!("PackageCandidate(name={}, version={})", name, version) + } + _ => format!("PackageCandidate(name={})", self.name), + } + } + + #[staticmethod] + pub fn from_dict(dict: &PyDict) -> Result { + let any: &PyAny = dict.as_ref(); + let name: String = any.get_item("name")?.to_string(); + + let get = |x: &str, dict: &PyDict| -> Option { + dict.get_item(x).and_then(|i| PyAny::extract(i).ok()) + }; + + Ok(PackageCandidate { + name, + version: get("version", dict), + build: get("version", dict), + build_number: dict + .get_item("build_number") + .and_then(|i| PyAny::extract(i).ok()), + depends: dict + .get_item("build_number") + .and_then(|i| PyAny::extract::>(i).ok()) + .unwrap_or_default(), + license: get("version", dict), + md5: get("version", dict), + sha256: get("version", dict), + size: dict + .get_item("build_number") + .and_then(|i| PyAny::extract(i).ok()), + subdir: get("version", dict), + timestamp: dict + .get_item("build_number") + .and_then(|i| PyAny::extract(i).ok()), + }) + } } #[cfg(test)] @@ -53,11 +131,11 @@ mod test { "timestamp": 1534356589107, "version": "3.10.4" }"#; - let ms: MatchSpec = "main/linux-64::python>3.10".parse().unwrap(); + let ms: MatchSpec = "main/linux-64::python>3.10".parse().unwrap(); let candidate = PackageCandidate::from(payload); assert!(ms.is_match(&candidate)); - let ms: MatchSpec = "main/linux-64::python<3.10".parse().unwrap(); + let ms: MatchSpec = "main/linux-64::python<3.10".parse().unwrap(); assert!(!candidate.is_match(&ms)) } } diff --git a/src/parsers.rs b/src/parsers.rs index ebe9668..df0cf05 100644 --- a/src/parsers.rs +++ b/src/parsers.rs @@ -1,16 +1,18 @@ -use crate::matchspec::*; use crate::input_table::*; +use crate::matchspec::*; use nom::error::{Error as NomError, ErrorKind}; use nom::{ branch::alt, bytes::complete::{tag, take_while, take_while1}, - character::complete::{alphanumeric0, alphanumeric1, satisfy, multispace0, multispace1, one_of}, + character::complete::{ + alphanumeric0, alphanumeric1, multispace0, multispace1, one_of, satisfy, + }, combinator::{complete, eof, opt, peek}, multi::separated_list0, sequence::{delimited, terminated, tuple}, IResult, }; -use version_compare::{Version}; +use version_compare::Version; /// Parses a version selector. Possible values: /// | Selector | Function | @@ -52,13 +54,11 @@ pub(crate) fn name_parser(s: &str) -> IResult<&str, &str> { pub(crate) fn version_parser(s: &str) -> IResult<&str, &str> { let (remainder, version) = take_while1(is_any_valid_str_with_glob)(s)?; match Version::from(version) { - Some(_) => { Ok((remainder, version)) } - None => { - Err(nom::Err::Failure(NomError { - code: ErrorKind::Fail, - input: "Version parse failed", - })) - } + Some(_) => Ok((remainder, version)), + None => Err(nom::Err::Failure(NomError { + code: ErrorKind::Fail, + input: "Version parse failed", + })), } } @@ -76,12 +76,10 @@ pub(crate) fn compound_selector_parser(s: &str) -> IResult<&str, CompoundSelecto // If we can parse via the more exhaustive parser, return that. match result { Ok((remainder, parsed)) => Ok((remainder, parsed.into())), - Err(_) => { - match version_and_selector_parser(s) { - Ok((remainder, parsed)) => Ok((remainder, parsed.into())), - Err(err) => Err(err), - } - } + Err(_) => match version_and_selector_parser(s) { + Ok((remainder, parsed)) => Ok((remainder, parsed.into())), + Err(err) => Err(err), + }, } } @@ -115,7 +113,7 @@ pub(crate) fn key_value_pair_parser(s: &str) -> IResult<&str, (&str, &str, &str) /// _libgcc_mutex 0.1 main /// backports_abc 0.5 py27h7b3c97b_0 /// ``` -pub(crate) fn implicit_matchspec_parser(s: &str) -> IResult<&str, MatchSpec> { +pub(crate) fn implicit_matchspec_parser(s: &str) -> IResult<&str, MatchSpec> { let (remainder, t) = tuple(( take_while1(is_alphanumeric_with_dashes_or_period), opt(delimited(multispace1, version_parser, multispace0)), @@ -131,7 +129,7 @@ pub(crate) fn implicit_matchspec_parser(s: &str) -> IResult<&str, MatchSpec IResult<&str, MatchSpec, NomError<&str>> { +pub(crate) fn full_matchspec_parser(s: &str) -> IResult<&str, MatchSpec, NomError<&str>> { // Eats `/subdir` let subdir_parser = delimited( satisfy(is_forward_slash), @@ -149,7 +147,6 @@ pub(crate) fn full_matchspec_parser(s: &str) -> IResult<&str, MatchSpec, satisfy(is_right_bracket), ); - // Put all the parsers together let (remainder, t) = complete(tuple(( opt(channel_parser), @@ -167,7 +164,7 @@ pub(crate) fn full_matchspec_parser(s: &str) -> IResult<&str, MatchSpec, mod test { mod component_parsers { use crate::parsers::*; - use nom::error::{ErrorKind}; + use nom::error::ErrorKind; #[test] fn test_channel_parser() { @@ -231,11 +228,13 @@ mod test { version_parser("2.9.1[subdir=linux]"), Ok(("[subdir=linux]", "2.9.1")) ); - assert_eq!(version_parser("not-correct-version"), - Err(nom::Err::Failure(NomError { - code: ErrorKind::Fail, - input: "Version parse failed", - }))); + assert_eq!( + version_parser("not-correct-version"), + Err(nom::Err::Failure(NomError { + code: ErrorKind::Fail, + input: "Version parse failed", + })) + ); } #[test] @@ -330,7 +329,7 @@ mod test { #[test] fn simple_package_and_version() { - let base: MatchSpec = MatchSpec::default(); + let base: MatchSpec = MatchSpec::default(); let expected = MatchSpec { package: "tensorflow".to_string(), version: Some(CompoundSelector::Single { @@ -340,14 +339,14 @@ mod test { ..base }; - let ms: MatchSpec = "tensorflow>=2.9.1".parse().unwrap(); + let ms: MatchSpec = "tensorflow>=2.9.1".parse().unwrap(); assert_eq!(ms, expected); } #[test] fn package_only() { - let result: Result, MatchSpecError> = "tensorflow".parse(); + let result: Result = "tensorflow".parse(); let ms = result.unwrap(); assert_eq!(ms.subdir, None); @@ -362,7 +361,7 @@ mod test { /// is the implicit: `tensorflow 2.9.1`. Both are supported, and they are equivalent. #[test] fn package_and_version_only() { - let base: MatchSpec = MatchSpec::default(); + let base: MatchSpec = MatchSpec::default(); // Our output should look like this let expected = MatchSpec { @@ -375,11 +374,11 @@ mod test { }; // Test the explicit matcher first - let explicit: MatchSpec = "tensorflow==2.9.1".parse().unwrap(); + let explicit: MatchSpec = "tensorflow==2.9.1".parse().unwrap(); assert_eq!(explicit, expected); // Test the implicit matcher second - let implicit: MatchSpec = "tensorflow 2.9.1".parse().unwrap(); + let implicit: MatchSpec = "tensorflow 2.9.1".parse().unwrap(); assert_eq!(implicit, expected); // They should both be equal @@ -406,7 +405,7 @@ mod test { }; // Test the explicit matcher first - let explicit: MatchSpec = "tensorflow==2.9.1[build=\"mkl_py39hb9fcb14_0\"]" + let explicit: MatchSpec = "tensorflow==2.9.1[build=\"mkl_py39hb9fcb14_0\"]" .parse() .unwrap(); @@ -414,8 +413,7 @@ mod test { assert_eq!(expected, explicit); // Test the implicit matcher second - let implicit: MatchSpec = - "tensorflow 2.9.1 mkl_py39hb9fcb14_0".parse().unwrap(); + let implicit: MatchSpec = "tensorflow 2.9.1 mkl_py39hb9fcb14_0".parse().unwrap(); // Test against expected assert_eq!(expected, explicit); @@ -426,8 +424,7 @@ mod test { #[test] fn package_and_version_with_key_values() { - let result: Result, MatchSpecError> = - "tensorflow>1[subdir!=win-64]".parse(); + let result: Result = "tensorflow>1[subdir!=win-64]".parse(); let ms = result.unwrap(); assert_eq!(ms.subdir, None); @@ -453,8 +450,7 @@ mod test { #[test] fn package_only_with_key_values() { - let result: Result, MatchSpecError> = - "tensorflow[subdir=win-64]".parse(); + let result: Result = "tensorflow[subdir=win-64]".parse(); let ms = result.unwrap(); assert_eq!(ms.subdir, Some("win-64".to_string())); @@ -474,7 +470,7 @@ mod test { #[test] fn everything_except_namespace() { - let ms: MatchSpec = "main/linux-64::pytorch>1.10.2".parse().unwrap(); + let ms: MatchSpec = "main/linux-64::pytorch>1.10.2".parse().unwrap(); let expected = MatchSpec { channel: Some("main".to_string()), @@ -509,7 +505,7 @@ mod test { key_value_pairs: Vec::new(), }; - let ms: MatchSpec = + let ms: MatchSpec = "conda-forge/linux-64:UNUSED:tensorflow>2.9.1,<3.0.0[license=GPL, subdir=linux-64]" .parse() .unwrap(); @@ -519,8 +515,13 @@ mod test { #[test] fn fail_on_wrong_semver_version() { - let ms: Result, MatchSpecError> = "python=wrong".parse(); - assert_eq!(ms, Err(MatchSpecError { message: "Version parse failed".to_string() })) + let ms: Result = "python=wrong".parse(); + assert_eq!( + ms, + Err(MatchSpecError { + message: "Version parse failed".to_string() + }) + ) } } @@ -551,7 +552,7 @@ mod test { .collect(); for line in depends { - let _parsed: MatchSpec = line + let _parsed: MatchSpec = line .parse() .unwrap_or_else(|_| panic!("Failed to parse: {}", line)); } diff --git a/src/python.rs b/src/python.rs index 43f06bd..11bef06 100644 --- a/src/python.rs +++ b/src/python.rs @@ -1,17 +1,60 @@ +use crate::matchspec::MatchSpec; +use crate::package_candidate::PackageCandidate; use pyo3::prelude::*; -use pyo3::wrap_pyfunction; -use crate::matchspec::*; +use pyo3::types::{PyDict, PyList}; +use pyo3::{create_exception, exceptions::PyException, wrap_pyfunction}; + +create_exception!(rust_matchspec, MatchSpecParsingError, PyException); + +#[pymodule] +fn rust_matchspec(_py: Python, m: &PyModule) -> PyResult<()> { + m.add_function(wrap_pyfunction!(match_against_matchspec, m)?)?; + m.add_function(wrap_pyfunction!(filter_package_list, m)?)?; + m.add_class::()?; + m.add_class::()?; + Ok(()) +} /// This function matches matchspec string against package name and version #[pyfunction] #[pyo3(signature = (matchspec, package, version))] fn match_against_matchspec(matchspec: String, package: String, version: String) -> bool { - let ms: MatchSpec = matchspec.parse().unwrap(); + let ms: MatchSpec = matchspec.parse().unwrap(); ms.is_package_version_match(&package, &version) } -#[pymodule] -fn rust_matchspec(_py: Python, m: &PyModule) -> PyResult<()> { - m.add_function(wrap_pyfunction!(match_against_matchspec, m)?)?; - Ok(()) +/// Take a list of dicts returning a filtered list that matches the given matchspec. +#[pyfunction] +#[pyo3(signature = (matchspec, package_list))] +fn filter_package_list( + py: Python, + matchspec: String, + package_list: &PyList, +) -> Result, PyErr> { + // This will be used later to abort if the list given doesn't have a proper dict + let mut err = Ok(()); + let ms: MatchSpec = matchspec.parse().unwrap(); + + // Loop through the pylist and create a Vec + let filtered: Vec = package_list + .iter() + .map(|i| i.downcast::()) + // If we encounter any invalid dicts we'll assign it to the accumalator and fail + .scan(&mut err, |err, res| match res { + Ok(o) => Some(o), + Err(e) => { + **err = Err(e); + None + } + }) + .flat_map(PackageCandidate::from_dict) + .filter(|pc| pc.is_match(&ms)) + .collect(); + + let pylist = PyList::new(py, filtered.iter().map(|pc| pc.clone().into_py(py))); + + // Looks weird, but lets raise the error + err?; + + Ok(pylist.into()) } From 3caf316ddc671f16740efad5737b2e3b7604a879 Mon Sep 17 00:00:00 2001 From: Kyle Leaders Date: Wed, 5 Apr 2023 15:11:43 -0700 Subject: [PATCH 4/9] Making pyo3 the default feature --- Cargo.toml | 2 +- pyproject.toml | 5 +++++ src/lib.rs | 7 +++---- 3 files changed, 9 insertions(+), 5 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 5242a0a..4fbf135 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -20,7 +20,7 @@ version-compare = "0.1" criterion = "0.3" [features] -default = [] +default = ["python"] python = ["pyo3/extension-module"] [[bench]] diff --git a/pyproject.toml b/pyproject.toml index c1354fa..51eb740 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -7,6 +7,11 @@ name = "rust_matchspec" version = "0.2.0" description = "A conda matchspec written in Rust" requires-python = ">=3.7" +classifiers = [ + "Programming Language :: Rust", + "Programming Language :: Python :: Implementation :: CPython", + "Programming Language :: Python :: Implementation :: PyPy", +] [tool.maturin] features = ["python"] diff --git a/src/lib.rs b/src/lib.rs index 49b9415..887029d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,11 +1,10 @@ #![doc = include_str ! ("../README.md")] -pub mod matchspec; +pub mod error; mod input_table; -mod parsers; +pub mod matchspec; pub mod package_candidate; -pub mod error; -#[cfg(feature = "python")] +mod parsers; pub mod python; pub use crate::matchspec::*; From 1f4df7231793ba9377884b8549766c794330e8f6 Mon Sep 17 00:00:00 2001 From: Kyle Leaders Date: Wed, 5 Apr 2023 15:30:08 -0700 Subject: [PATCH 5/9] Adding python api docs to README --- README.md | 45 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 44 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 154c6e2..019bc20 100644 --- a/README.md +++ b/README.md @@ -2,6 +2,49 @@ A Conda MatchSpec implementation in pure Rust. This allows you to parse a matchspec and validate it against a package to see if it matches. +# Python Library + +## Example + +This library exposes a few simple functions: + +## `match_against_matchspec()` + +Takes a `matchspec` as a `str` and matches it against a `package_name` and `version` (both `str`). Returns a `bool`. + +``` python +import rust_matchspec +rust_matchspec.match_against_matchspec('python>=3.0', 'python', '3.10.1') # returns True +``` + +## `filter_package_list()` + +Takes a `list` of `dicts` and returns all the dicts inside that match a given matchspec. The `dicts` must have a `name` key with a `str` value, but all other fields are optional. + +```python +import rust_matchspec +list = [{'name': 'tensorflow', 'version': '2.10.0'}, {'name': 'pytorch', 'version': '2.0.0'}, {'name': 'pytorch', 'version': '1.11.1'}] +rust_matchspec.filter_package_list('pytorch>1.12', list) # returns [PackageCandidate(name=pytorch)] +``` + +Possible keys: + +| Key | Expected Type | Required? | +|--------------|---------------|-----------| +| name | str | yes | +| version | str | | +| build | str | | +| build_number | u32 | | +| depends | [str] | | +| license | str | | +| md5 | str | | +| sha256 | str | | +| size | u64 | | +| subdir | str | | +| timestamp | u64 | | + +# Rust Library + ## Example The way you instantiate a MatchSpec is by parsing a string into the type: @@ -10,7 +53,7 @@ The way you instantiate a MatchSpec is by parsing a string into the type: use rust_matchspec::{CompoundSelector, MatchSpec, Selector}; // Create the MatchSpec by parsing a String or &str -let matchspec: MatchSpec = "main/linux-64::pytorch>1.10.2".parse().unwrap(); +let matchspec: MatchSpec = "main/linux-64::pytorch>1.10.2".parse().unwrap(); // You then have the data accessible inside the MatchSpec struct if you want it // Package name is the only mandatory field in a matchspec From 194762e4d227b11d384f109abe0536c7e3bd0b3d Mon Sep 17 00:00:00 2001 From: Kyle Leaders Date: Wed, 5 Apr 2023 15:32:35 -0700 Subject: [PATCH 6/9] Formatting cleanup on README --- README.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 019bc20..abd853d 100644 --- a/README.md +++ b/README.md @@ -4,8 +4,6 @@ A Conda MatchSpec implementation in pure Rust. This allows you to parse a matchs # Python Library -## Example - This library exposes a few simple functions: ## `match_against_matchspec()` @@ -23,7 +21,10 @@ Takes a `list` of `dicts` and returns all the dicts inside that match a given ma ```python import rust_matchspec -list = [{'name': 'tensorflow', 'version': '2.10.0'}, {'name': 'pytorch', 'version': '2.0.0'}, {'name': 'pytorch', 'version': '1.11.1'}] +list = [{'name': 'tensorflow', 'version': '2.10.0'}, + {'name': 'pytorch', 'version': '2.0.0'}, + {'name': 'pytorch', 'version': '1.11.1'}] + rust_matchspec.filter_package_list('pytorch>1.12', list) # returns [PackageCandidate(name=pytorch)] ``` From 27d56bff7921858bfc6e22d7b63da9257d8a97b2 Mon Sep 17 00:00:00 2001 From: Kyle Leaders Date: Thu, 6 Apr 2023 14:06:38 -0700 Subject: [PATCH 7/9] Python benchmarks --- README.md | 26 +- benches/test_python.py | 84 + environment.yml | 8 + test_data/repodata-linux-64.json | 1309454 +++++++++++++++++++++++++++ 4 files changed, 1309570 insertions(+), 2 deletions(-) create mode 100644 benches/test_python.py create mode 100644 environment.yml create mode 100644 test_data/repodata-linux-64.json diff --git a/README.md b/README.md index abd853d..1869258 100644 --- a/README.md +++ b/README.md @@ -79,9 +79,31 @@ assert!(matchspec.is_package_version_match(&"pytorch", &"1.11.0")) This library contains benchmarks aimed at checking the speed of our implementation against other languages and ensure speed doesn't regress. This is a pure Rust benchmark so you'll need to view it with some skepticism if you want to compare this implementation against others. Benchmark harnesses and the data all need to be identical for a benchmark to really provide value. -### Running the benchmarks -These benchmarks use [Criterion.rs](https://bheisler.github.io/criterion.rs/book/criterion_rs.html) to provide the benchmarking framework. Its pretty easy to run the benchmarks on stable rust: +### Python + +The Python benchmarks use [pytest-benchmark](https://pytest-benchmark.readthedocs.io/en/stable/). + +Steps to run the benchmarks: + +```bash +# Setup the conda env +conda env create -f ./environment.yml +conda activate rust_matchspec + +# Build an optimized wheel +maturin build --release + +# install it +pip install ./target/rust_matchspec*.whl + +# Finally, run the benchmark +pytest +``` + +### Rust + +The Rust benchmarks use [Criterion.rs](https://bheisler.github.io/criterion.rs/book/criterion_rs.html) to provide the benchmarking framework. Its pretty easy to run the benchmarks on stable rust: ```bash cargo bench diff --git a/benches/test_python.py b/benches/test_python.py new file mode 100644 index 0000000..a9fb864 --- /dev/null +++ b/benches/test_python.py @@ -0,0 +1,84 @@ +from conda.models.match_spec import MatchSpec +from pathlib import Path +import rust_matchspec +import json + +test_data = Path('./test_data') +depends_file = test_data / 'linux_64-depends.txt' +repodata_file = test_data / 'repodata-linux-64.json' + + +def bench_match_against_matchspec(list: [str]): + """ Takes the list of matchspecs and matches against python 3.9.1 """ + for item in list: + rust_matchspec.match_against_matchspec(item, 'python', '3.9.1') + + +def test_rust_matchspec_on_repodata_depends(benchmark): + """ + Test the rust_matchspec.match_against_matchspec using the + linux_64-depends.txt file. + """ + with open(depends_file) as f: + depends = f.readlines() + + benchmark(bench_match_against_matchspec, list=depends) + + +def bench_conda_against_repodata_depends(list: [str]): + """ + Runs a list of matchspecs against a static package, this is a little + contrived, but it is meant to compare the instantiation and filtering speed + of MatchSpec + """ + for item in list: + ms = MatchSpec(item) + ms.match({'name': 'python', 'version': '3.9.1', + 'build': 'hbdb9e5c_0', 'build_number': 0}) + + +def test_conda_matchspec_on_repodata_depends(benchmark): + """ + Test Conda's MatchSpec against the linux_64-depends.txt file + """ + with open(depends_file) as f: + depends = f.readlines() + + benchmark(bench_conda_against_repodata_depends, list=depends) + + +def bench_rust_matchspec_filter_package_list(list: [dict[str, str]]): + """ + Runs rust_matchspec.filter_package_list() against a list of packages + """ + _matches = rust_matchspec.filter_package_list('python>=3.9.1', list) + + +def test_rust_matchspec_filter_package_list(benchmark): + """ + Test rust_matchspec's filter_package_list() against the full linux-64 + repodata.json from Anaconda's defaults. + """ + with open(repodata_file) as f: + repodata = list(json.load(f)['packages'].values()) + + benchmark(bench_rust_matchspec_filter_package_list, list=repodata) + + +def bench_conda_filter_package_list(list: [dict[str, str]]): + """ + Runs uses MatchSpec against a list of packages to filter out non-matches + """ + ms = MatchSpec('python>=3.9.1') + _matches = [p for p in list if ms.match(p)] + + +def test_conda_filter_package_list(benchmark): + """ + Benchmark conda MatchSpec filtering all of the linux-64 repodata from + Anaconda's defaults + """ + with open(repodata_file) as f: + repodata = list(json.load(f)['packages'].values()) + + benchmark(bench_conda_filter_package_list, list=repodata) diff --git a/environment.yml b/environment.yml new file mode 100644 index 0000000..d622e94 --- /dev/null +++ b/environment.yml @@ -0,0 +1,8 @@ +--- +name: rust_matchspec +channels: + - defaults +dependencies: + - conda + - pytest + - pytest-benchmark diff --git a/test_data/repodata-linux-64.json b/test_data/repodata-linux-64.json new file mode 100644 index 0000000..e797120 --- /dev/null +++ b/test_data/repodata-linux-64.json @@ -0,0 +1,1309454 @@ +{ + "info": { + "subdir": "linux-64" + }, + "packages": { + "_anaconda_depends-2018.12-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.os", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "funcsigs", + "functools32", + "future", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "linecache2", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traceback2", + "traitlets", + "typing", + "unicodecsv", + "unittest2", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "199037865cc19536a1ae07b115e5a5c2", + "name": "_anaconda_depends", + "sha256": "cbaa2e02de8389a04f42ef98d92e11fb319a66dcd86834bdb434dd008525c593", + "size": 5598, + "subdir": "linux-64", + "timestamp": 1562173890182, + "version": "2018.12" + }, + "_anaconda_depends-2018.12-py36h44efdcc_0.tar.bz2": { + "build": "py36h44efdcc_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backcall", + "backports", + "backports.os", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "conda", + "conda-build", + "conda-env", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.6.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typed-ast", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "45bb6fb1035c22e45cd38e9bd9c9bd9c", + "name": "_anaconda_depends", + "sha256": "c6e774560d0e571f90e9142e1738e1c80770ec07048c879d55d472db85e32c63", + "size": 5521, + "subdir": "linux-64", + "timestamp": 1562173908400, + "version": "2018.12" + }, + "_anaconda_depends-2018.12-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backcall", + "backports", + "backports.os", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.7.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "b7031cd97e19e24d67b31d8419960a74", + "name": "_anaconda_depends", + "sha256": "25f488b222ddf45367a547787837805d1cb762eba182a65d055b4e72d3e0490f", + "size": 5465, + "subdir": "linux-64", + "timestamp": 1562173919149, + "version": "2018.12" + }, + "_anaconda_depends-2019.03-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.os", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "fontconfig", + "freetype", + "fribidi", + "funcsigs", + "functools32", + "future", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "linecache2", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traceback2", + "traitlets", + "typing", + "unicodecsv", + "unittest2", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "5019561464537c5677064c3622fba5d7", + "name": "_anaconda_depends", + "sha256": "73ec5ec0b6d1ee83d3cb7b7c0cad289461465177bf060dc8bb90969c77a8516c", + "size": 5574, + "subdir": "linux-64", + "timestamp": 1562173936297, + "version": "2019.03" + }, + "_anaconda_depends-2019.03-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backcall", + "backports", + "backports.os", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "flask", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.6.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typed-ast", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "4b3a0529f8fb36306bf7ac8f70a1b1a5", + "name": "_anaconda_depends", + "sha256": "ead9728c3f38b594d38e905dbfc6241f8b15a7a0452199aa9fecdc63920e14ce", + "size": 5420, + "subdir": "linux-64", + "timestamp": 1562173951982, + "version": "2019.03" + }, + "_anaconda_depends-2019.03-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backcall", + "backports", + "backports.os", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.7.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "6a81ee6ba3f9667adb4749688c63147f", + "name": "_anaconda_depends", + "sha256": "b31facd02a6e3aae9bf53491f4e997411cd07eb30d534bd4b417cc6a62156956", + "size": 5454, + "subdir": "linux-64", + "timestamp": 1562173963130, + "version": "2019.03" + }, + "_anaconda_depends-2019.07-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.os", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "fontconfig", + "freetype", + "fribidi", + "funcsigs", + "functools32", + "future", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "linecache2", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traceback2", + "traitlets", + "typing", + "unicodecsv", + "unittest2", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "84429984bbe097b244bc038aad93d893", + "name": "_anaconda_depends", + "sha256": "294869ffed3eda318a3864fb1ae9db91bab373a5fa338b4481cbc7e2a4e795d3", + "size": 5440, + "subdir": "linux-64", + "timestamp": 1587065885251, + "version": "2019.07" + }, + "_anaconda_depends-2019.07-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backcall", + "backports", + "backports.os", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.6.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typed-ast", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "3c42f6c344b1841f2ba77522fc9fbfc9", + "name": "_anaconda_depends", + "sha256": "41162f6fbe9bfa7008c259280667f10870ed1b7d81cbf085b1e73d4fbba54804", + "size": 5419, + "subdir": "linux-64", + "timestamp": 1587065921282, + "version": "2019.07" + }, + "_anaconda_depends-2019.07-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backcall", + "backports", + "backports.os", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.7.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "323f3187456a9ef9efc1ce03955f4efe", + "name": "_anaconda_depends", + "sha256": "d495238361636254e3ec49d7d0fd43826e94c89730ed6751ee75350dab98d6f5", + "size": 5408, + "subdir": "linux-64", + "timestamp": 1587065951532, + "version": "2019.07" + }, + "_anaconda_depends-2019.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.os", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "fontconfig", + "freetype", + "fribidi", + "funcsigs", + "functools32", + "future", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "linecache2", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "ripgrep", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tbb", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traceback2", + "traitlets", + "typing", + "unicodecsv", + "unittest2", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "0187b08e6efc9fac5828587b646a4f23", + "name": "_anaconda_depends", + "sha256": "d129e47efc7b15b4f20d9803ddd2242801972b8c5d102a34db2a1e4366933a51", + "size": 5453, + "subdir": "linux-64", + "timestamp": 1587065992450, + "version": "2019.10" + }, + "_anaconda_depends-2019.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backcall", + "backports", + "backports.os", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "fontconfig", + "freetype", + "fribidi", + "fsspec", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.6.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "ripgrep", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typed-ast", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "ffbecb7f4007f614cc0155dda16da6c1", + "name": "_anaconda_depends", + "sha256": "538179d858fec5f2fe41841580f8a30531356da5f17f733129711f8d853a1881", + "size": 5435, + "subdir": "linux-64", + "timestamp": 1587066029397, + "version": "2019.10" + }, + "_anaconda_depends-2019.10-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backcall", + "backports", + "backports.os", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "fontconfig", + "freetype", + "fribidi", + "fsspec", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.7.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "ripgrep", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "5c6226bde05e288f1fc74d467f8db753", + "name": "_anaconda_depends", + "sha256": "ca1093ddc693dac2b79340334842392a496ce86c8f9e8b5e2a8c29449fd3f377", + "size": 5415, + "subdir": "linux-64", + "timestamp": 1587066059915, + "version": "2019.10" + }, + "_anaconda_depends-2020.02-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "argh", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "autopep8", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flake8", + "flask", + "fontconfig", + "freetype", + "fribidi", + "fsspec", + "future", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hypothesis", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "ld_impl_linux-64", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "matplotlib-base", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path", + "path.py", + "pathlib2", + "pathtools", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pydocstyle", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-astropy-header", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.6.*", + "python-dateutil", + "python-jsonrpc-server", + "python-language-server", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "ripgrep", + "rope", + "rtree", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typed-ast", + "ujson", + "unicodecsv", + "unixodbc", + "urllib3", + "watchdog", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "yapf", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "ced399270ec624be8d40961168e075c3", + "name": "_anaconda_depends", + "sha256": "4c09a141f388aa8682c4a92baa550f322167c968dbf142834a4c5cdf36e31cdb", + "size": 5676, + "subdir": "linux-64", + "timestamp": 1587066097370, + "version": "2020.02" + }, + "_anaconda_depends-2020.02-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "argh", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "autopep8", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flake8", + "flask", + "fontconfig", + "freetype", + "fribidi", + "fsspec", + "future", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hypothesis", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "ld_impl_linux-64", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "matplotlib-base", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path", + "path.py", + "pathlib2", + "pathtools", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pydocstyle", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-astropy-header", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.7.*", + "python-dateutil", + "python-jsonrpc-server", + "python-language-server", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "ripgrep", + "rope", + "rtree", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "ujson", + "unicodecsv", + "unixodbc", + "urllib3", + "watchdog", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "yapf", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "6fe739f513e114cf0d68f4f562fe373b", + "name": "_anaconda_depends", + "sha256": "45041ee083ae5aac8932b9ae3fee9358f8c909a42cfcc8a4fa680e96945f5e3d", + "size": 5655, + "subdir": "linux-64", + "timestamp": 1587066130431, + "version": "2020.02" + }, + "_anaconda_depends-2020.02-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "argh", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "autopep8", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flake8", + "flask", + "fontconfig", + "freetype", + "fribidi", + "fsspec", + "future", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hypothesis", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "ld_impl_linux-64", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "matplotlib-base", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path", + "path.py", + "pathlib2", + "pathtools", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycurl", + "pydocstyle", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-astropy-header", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.8.*", + "python-dateutil", + "python-jsonrpc-server", + "python-language-server", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "ripgrep", + "rope", + "rtree", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "ujson", + "unicodecsv", + "unixodbc", + "urllib3", + "watchdog", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "yapf", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "f0d934533f8e742099d79200c801d15f", + "name": "_anaconda_depends", + "sha256": "53d2c7676335164014c2588c36d7952c754e8d91df395ebbd622e563dcb58736", + "size": 5645, + "subdir": "linux-64", + "timestamp": 1587066147200, + "version": "2020.02" + }, + "_anaconda_depends-2020.07-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "argh", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "autopep8", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "brotlipy", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "contextvars", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flake8", + "flask", + "fontconfig", + "freetype", + "fribidi", + "fsspec", + "future", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "immutables", + "importlib-metadata", + "importlib_metadata", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "lcms2", + "ld_impl_linux-64", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libllvm9", + "libpng", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "matplotlib-base", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path", + "path.py", + "pathlib2", + "pathtools", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt-toolkit", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pydocstyle", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 3.6.*", + "python-dateutil", + "python-jsonrpc-server", + "python-language-server", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "regex", + "requests", + "ripgrep", + "rope", + "rtree", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tblib", + "terminado", + "testpath", + "threadpoolctl", + "tk", + "toml", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typed-ast", + "typing_extensions", + "ujson", + "unicodecsv", + "unixodbc", + "urllib3", + "watchdog", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "yapf", + "zeromq", + "zict", + "zipp", + "zlib", + "zope", + "zope.event", + "zope.interface", + "zstd" + ], + "license": "BSD", + "md5": "fbd9aef47911f3a63d9a9209a2b05e79", + "name": "_anaconda_depends", + "sha256": "1cf95408637ecd670153f59a236af7ca2060944ecfaedc4c771d9706e6fe9c71", + "size": 5707, + "subdir": "linux-64", + "timestamp": 1595561605727, + "version": "2020.07" + }, + "_anaconda_depends-2020.07-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "argh", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "autopep8", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "brotlipy", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flake8", + "flask", + "fontconfig", + "freetype", + "fribidi", + "fsspec", + "future", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib-metadata", + "importlib_metadata", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "lcms2", + "ld_impl_linux-64", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libllvm9", + "libpng", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "matplotlib-base", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path", + "path.py", + "pathlib2", + "pathtools", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt-toolkit", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pydocstyle", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 3.7.*", + "python-dateutil", + "python-jsonrpc-server", + "python-language-server", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "regex", + "requests", + "ripgrep", + "rope", + "rtree", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tblib", + "terminado", + "testpath", + "threadpoolctl", + "tk", + "toml", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typed-ast", + "typing_extensions", + "ujson", + "unicodecsv", + "unixodbc", + "urllib3", + "watchdog", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "yapf", + "zeromq", + "zict", + "zipp", + "zlib", + "zope", + "zope.event", + "zope.interface", + "zstd" + ], + "license": "BSD", + "md5": "a1f548255d2ad05002918c09579f56ef", + "name": "_anaconda_depends", + "sha256": "29c855cf44d1d40bd9ce3ccff0f0e4f678e6fc2355a73bf99a16e56f1b4f8fcd", + "size": 5677, + "subdir": "linux-64", + "timestamp": 1595561753272, + "version": "2020.07" + }, + "_anaconda_depends-2020.07-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "argh", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "autopep8", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "brotlipy", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flake8", + "flask", + "fontconfig", + "freetype", + "fribidi", + "fsspec", + "future", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib-metadata", + "importlib_metadata", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "lcms2", + "ld_impl_linux-64", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libllvm9", + "libpng", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "matplotlib-base", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path", + "path.py", + "pathlib2", + "pathtools", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt-toolkit", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycurl", + "pydocstyle", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 3.8.*", + "python-dateutil", + "python-jsonrpc-server", + "python-language-server", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "regex", + "requests", + "ripgrep", + "rope", + "rtree", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tblib", + "terminado", + "testpath", + "threadpoolctl", + "tk", + "toml", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typing_extensions", + "ujson", + "unicodecsv", + "unixodbc", + "urllib3", + "watchdog", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "yapf", + "zeromq", + "zict", + "zipp", + "zlib", + "zope", + "zope.event", + "zope.interface", + "zstd" + ], + "license": "BSD", + "md5": "8432fc053d211697cfd580bb8711048d", + "name": "_anaconda_depends", + "sha256": "2fee4d7858daf742a0eee5fe832dcf3aa6aa43c0de584611415d163d992395b5", + "size": 5653, + "subdir": "linux-64", + "timestamp": 1595561529079, + "version": "2020.07" + }, + "_anaconda_depends-2021.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "_openmp_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "anyio", + "appdirs", + "argcomplete", + "argh", + "argon2-cffi", + "arrow", + "asn1crypto", + "astroid", + "astropy", + "async_generator", + "atomicwrites", + "attrs", + "autopep8", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "binaryornot", + "bitarray", + "bkcharts", + "black", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "brotli", + "brotlipy", + "brunsli", + "bzip2", + "c-ares", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "cfitsio", + "chardet", + "charls", + "charset-normalizer", + "click", + "cloudpickle", + "clyent", + "colorama", + "conda-content-trust", + "conda-token", + "contextlib2", + "cookiecutter", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "daal4py", + "dal", + "dask", + "dask-core", + "dataclasses", + "dbus", + "debugpy", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flake8", + "flask", + "fontconfig", + "fonttools", + "freetype", + "fribidi", + "fsspec", + "get_terminal_size", + "gevent", + "giflib", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imagecodecs", + "imageio", + "imagesize", + "importlib-metadata", + "importlib_metadata", + "inflection", + "iniconfig", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jinja2-time", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyter_server", + "jupyterlab", + "jupyterlab_pygments", + "jupyterlab_server", + "jupyterlab_widgets", + "jxrlib", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "lcms2", + "ld_impl_linux-64", + "lerc", + "libaec", + "libarchive", + "libcurl", + "libdeflate", + "libedit", + "libev", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libgfortran4", + "libgomp", + "liblief", + "libllvm11", + "libnghttp2", + "libpng", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libuv", + "libwebp", + "libwebp-base", + "libxcb", + "libxml2", + "libxslt", + "libzopfli", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "matplotlib-base", + "matplotlib-inline", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpi", + "mpich", + "mpmath", + "msgpack-python", + "multipledispatch", + "munkres", + "mypy_extensions", + "nbclassic", + "nbclient", + "nbconvert", + "nbformat", + "ncurses", + "nest-asyncio", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openjpeg", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path", + "path.py", + "pathlib2", + "pathspec", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "poyo", + "prometheus_client", + "prompt-toolkit", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pydocstyle", + "pyerfa", + "pyflakes", + "pygments", + "pylint", + "pyls-spyder", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 3.7.*", + "python-dateutil", + "python-libarchive-c", + "python-lsp-black", + "python-lsp-jsonrpc", + "python-lsp-server", + "python-slugify", + "pytz", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qstylizer", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "regex", + "requests", + "ripgrep", + "rope", + "rtree", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "sniffio", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tbb4py", + "tblib", + "terminado", + "testpath", + "text-unidecode", + "textdistance", + "threadpoolctl", + "three-merge", + "tifffile", + "tinycss", + "tk", + "toml", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typed-ast", + "typing-extensions", + "typing_extensions", + "ujson", + "unicodecsv", + "unidecode", + "unixodbc", + "urllib3", + "watchdog", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "whichcraft", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "yapf", + "zeromq", + "zfp", + "zict", + "zipp", + "zlib", + "zope", + "zope.event", + "zope.interface", + "zstd" + ], + "license": "BSD", + "md5": "aff785dd94521f6507da440de2f72774", + "name": "_anaconda_depends", + "sha256": "d4d5f4c25d2d0e58ddb47438aa29a45b3e86da1d7fbe53a2172a5d0d180835a3", + "size": 6184, + "subdir": "linux-64", + "timestamp": 1636994981070, + "version": "2021.11" + }, + "_anaconda_depends-2021.11-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "_openmp_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "anyio", + "appdirs", + "argh", + "argon2-cffi", + "arrow", + "asn1crypto", + "astroid", + "astropy", + "async_generator", + "atomicwrites", + "attrs", + "autopep8", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "binaryornot", + "bitarray", + "bkcharts", + "black", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "brotli", + "brotlipy", + "brunsli", + "bzip2", + "c-ares", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "cfitsio", + "chardet", + "charls", + "charset-normalizer", + "click", + "cloudpickle", + "clyent", + "colorama", + "conda-content-trust", + "conda-token", + "contextlib2", + "cookiecutter", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "daal4py", + "dal", + "dask", + "dask-core", + "dataclasses", + "dbus", + "debugpy", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flake8", + "flask", + "fontconfig", + "fonttools", + "freetype", + "fribidi", + "fsspec", + "get_terminal_size", + "gevent", + "giflib", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imagecodecs", + "imageio", + "imagesize", + "importlib-metadata", + "importlib_metadata", + "inflection", + "iniconfig", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jinja2-time", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyter_server", + "jupyterlab", + "jupyterlab_pygments", + "jupyterlab_server", + "jupyterlab_widgets", + "jxrlib", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "lcms2", + "ld_impl_linux-64", + "lerc", + "libaec", + "libarchive", + "libcurl", + "libdeflate", + "libedit", + "libev", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libgfortran4", + "libgomp", + "liblief", + "libllvm11", + "libnghttp2", + "libpng", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libuv", + "libwebp", + "libwebp-base", + "libxcb", + "libxml2", + "libxslt", + "libzopfli", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "matplotlib-base", + "matplotlib-inline", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpi", + "mpich", + "mpmath", + "msgpack-python", + "multipledispatch", + "munkres", + "mypy_extensions", + "nbclassic", + "nbclient", + "nbconvert", + "nbformat", + "ncurses", + "nest-asyncio", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openjpeg", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path", + "path.py", + "pathlib2", + "pathspec", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "poyo", + "prometheus_client", + "prompt-toolkit", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycurl", + "pydocstyle", + "pyerfa", + "pyflakes", + "pygments", + "pylint", + "pyls-spyder", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 3.8.*", + "python-dateutil", + "python-libarchive-c", + "python-lsp-black", + "python-lsp-jsonrpc", + "python-lsp-server", + "python-slugify", + "pytz", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qstylizer", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "regex", + "requests", + "ripgrep", + "rope", + "rtree", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "sniffio", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tbb4py", + "tblib", + "terminado", + "testpath", + "text-unidecode", + "textdistance", + "threadpoolctl", + "three-merge", + "tifffile", + "tinycss", + "tk", + "toml", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typed-ast", + "typing_extensions", + "ujson", + "unicodecsv", + "unidecode", + "unixodbc", + "urllib3", + "watchdog", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "whichcraft", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "yapf", + "zeromq", + "zfp", + "zict", + "zipp", + "zlib", + "zope", + "zope.event", + "zope.interface", + "zstd" + ], + "license": "BSD", + "md5": "07d9bf022a308819268641ad0ce1c877", + "name": "_anaconda_depends", + "sha256": "f4a806dd9e8ba113ab998e0979895f279be85cd809f43b40a2a55487aad9e9f8", + "size": 6170, + "subdir": "linux-64", + "timestamp": 1636994991327, + "version": "2021.11" + }, + "_anaconda_depends-2021.11-py39_0.tar.bz2": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "_openmp_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "anyio", + "appdirs", + "argh", + "argon2-cffi", + "arrow", + "asn1crypto", + "astroid", + "astropy", + "async_generator", + "atomicwrites", + "attrs", + "autopep8", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "binaryornot", + "bitarray", + "bkcharts", + "black", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "brotli", + "brotlipy", + "brunsli", + "bzip2", + "c-ares", + "ca-certificates", + "cached-property", + "cairo", + "certifi", + "cffi", + "cfitsio", + "chardet", + "charls", + "charset-normalizer", + "click", + "cloudpickle", + "clyent", + "colorama", + "conda-content-trust", + "conda-token", + "contextlib2", + "cookiecutter", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "daal4py", + "dal", + "dask", + "dask-core", + "dataclasses", + "dbus", + "debugpy", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flake8", + "flask", + "fontconfig", + "fonttools", + "freetype", + "fribidi", + "fsspec", + "get_terminal_size", + "gevent", + "giflib", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imagecodecs", + "imageio", + "imagesize", + "importlib-metadata", + "importlib_metadata", + "inflection", + "iniconfig", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jinja2-time", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyter_server", + "jupyterlab", + "jupyterlab_pygments", + "jupyterlab_server", + "jupyterlab_widgets", + "jxrlib", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "lcms2", + "ld_impl_linux-64", + "lerc", + "libaec", + "libarchive", + "libcurl", + "libdeflate", + "libedit", + "libev", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libgfortran4", + "libgomp", + "liblief", + "libllvm11", + "libnghttp2", + "libpng", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libuv", + "libwebp", + "libwebp-base", + "libxcb", + "libxml2", + "libxslt", + "libzopfli", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "matplotlib-base", + "matplotlib-inline", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpi", + "mpich", + "mpmath", + "msgpack-python", + "multipledispatch", + "munkres", + "mypy_extensions", + "nbclassic", + "nbclient", + "nbconvert", + "nbformat", + "ncurses", + "nest-asyncio", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openjpeg", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path", + "path.py", + "pathlib2", + "pathspec", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "poyo", + "prometheus_client", + "prompt-toolkit", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycurl", + "pydocstyle", + "pyerfa", + "pyflakes", + "pygments", + "pylint", + "pyls-spyder", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 3.9.*", + "python-dateutil", + "python-libarchive-c", + "python-lsp-black", + "python-lsp-jsonrpc", + "python-lsp-server", + "python-slugify", + "pytz", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qstylizer", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "regex", + "requests", + "ripgrep", + "rope", + "rtree", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "sniffio", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tbb4py", + "tblib", + "terminado", + "testpath", + "text-unidecode", + "textdistance", + "threadpoolctl", + "three-merge", + "tifffile", + "tinycss", + "tk", + "toml", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typed-ast", + "typing_extensions", + "tzdata", + "ujson", + "unicodecsv", + "unidecode", + "unixodbc", + "urllib3", + "watchdog", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "whichcraft", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "yapf", + "zeromq", + "zfp", + "zict", + "zipp", + "zlib", + "zope", + "zope.event", + "zope.interface", + "zstd" + ], + "license": "BSD", + "md5": "3bed9ec5509358310790d09886d84326", + "name": "_anaconda_depends", + "sha256": "30d68ec691ddda90bf230d74bb2a749c68a8aca0856fefa603dbac27d9302537", + "size": 6183, + "subdir": "linux-64", + "timestamp": 1636994998469, + "version": "2021.11" + }, + "_anaconda_depends-2022.05-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "_openmp_mutex", + "aiohttp", + "aiosignal", + "alabaster", + "anaconda-client", + "anaconda-project", + "anyio", + "appdirs", + "argon2-cffi", + "argon2-cffi-bindings", + "arrow", + "astroid", + "astropy", + "async-timeout", + "asynctest", + "atomicwrites", + "attrs", + "automat", + "autopep8", + "babel", + "backcall", + "backports", + "backports.functools_lru_cache", + "backports.tempfile", + "backports.weakref", + "bcrypt", + "beautifulsoup4", + "binaryornot", + "bitarray", + "bkcharts", + "black", + "blas", + "bleach", + "blosc", + "bokeh", + "boto3", + "botocore", + "bottleneck", + "brotli", + "brotlipy", + "brunsli", + "bzip2", + "c-ares", + "ca-certificates", + "cachetools", + "certifi", + "cffi", + "cfitsio", + "chardet", + "charls", + "charset-normalizer", + "click", + "cloudpickle", + "clyent", + "colorama", + "colorcet", + "conda-content-trust", + "conda-token", + "constantly", + "cookiecutter", + "cryptography", + "cssselect", + "curl", + "cycler", + "cython", + "cytoolz", + "daal4py", + "dal", + "dask", + "dask-core", + "dataclasses", + "datashader", + "datashape", + "dbus", + "debugpy", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "filelock", + "flake8", + "flask", + "fontconfig", + "fonttools", + "freetype", + "frozenlist", + "fsspec", + "future", + "gensim", + "giflib", + "glib", + "glob2", + "gmp", + "gmpy2", + "google-api-core", + "google-auth", + "google-cloud-core", + "google-cloud-storage", + "google-crc32c", + "google-resumable-media", + "googleapis-common-protos", + "greenlet", + "grpcio", + "gst-plugins-base", + "gstreamer", + "h5py", + "hdf5", + "heapdict", + "holoviews", + "hvplot", + "hyperlink", + "icu", + "idna", + "imagecodecs", + "imageio", + "imagesize", + "importlib-metadata", + "importlib_metadata", + "importlib_resources", + "incremental", + "inflection", + "iniconfig", + "intake", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itemadapter", + "itemloaders", + "itsdangerous", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jinja2-time", + "jmespath", + "joblib", + "jpeg", + "jq", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyter_server", + "jupyterlab", + "jupyterlab_pygments", + "jupyterlab_server", + "jupyterlab_widgets", + "jxrlib", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "lcms2", + "ld_impl_linux-64", + "lerc", + "libaec", + "libarchive", + "libcrc32c", + "libcurl", + "libdeflate", + "libedit", + "libev", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libgfortran4", + "libgomp", + "libidn2", + "liblief", + "libllvm11", + "libnghttp2", + "libpng", + "libprotobuf", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libunistring", + "libuuid", + "libwebp", + "libwebp-base", + "libxcb", + "libxml2", + "libxslt", + "libzopfli", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markdown", + "markupsafe", + "matplotlib", + "matplotlib-base", + "matplotlib-inline", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "mpc", + "mpfr", + "mpi", + "mpich", + "mpmath", + "msgpack-python", + "multidict", + "multipledispatch", + "munkres", + "mypy_extensions", + "nbclassic", + "nbclient", + "nbconvert", + "nbformat", + "ncurses", + "nest-asyncio", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "oniguruma", + "openjpeg", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "panel", + "param", + "parsel", + "parso", + "partd", + "patchelf", + "pathspec", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pkginfo", + "plotly", + "pluggy", + "poyo", + "prometheus_client", + "prompt-toolkit", + "prompt_toolkit", + "protego", + "protobuf", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pyasn1", + "pyasn1-modules", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pyct", + "pycurl", + "pydispatcher", + "pydocstyle", + "pyerfa", + "pyflakes", + "pygments", + "pyhamcrest", + "pylint", + "pyls-spyder", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 3.7.*", + "python-dateutil", + "python-fastjsonschema", + "python-libarchive-c", + "python-lsp-black", + "python-lsp-jsonrpc", + "python-lsp-server", + "python-slugify", + "python-snappy", + "pytz", + "pyviz_comms", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qstylizer", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "queuelib", + "readline", + "regex", + "requests", + "requests-file", + "ripgrep", + "rope", + "rsa", + "rtree", + "ruamel_yaml", + "s3transfer", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "secretstorage", + "send2trash", + "service_identity", + "setuptools", + "sip", + "six", + "smart_open", + "snappy", + "sniffio", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tabulate", + "tbb", + "tbb4py", + "tblib", + "tenacity", + "terminado", + "testpath", + "text-unidecode", + "textdistance", + "threadpoolctl", + "three-merge", + "tifffile", + "tinycss", + "tk", + "tldextract", + "toml", + "tomli", + "toolz", + "tornado", + "tqdm", + "traitlets", + "twisted", + "typed-ast", + "typing-extensions", + "typing_extensions", + "ujson", + "unidecode", + "unixodbc", + "urllib3", + "w3lib", + "watchdog", + "wcwidth", + "webencodings", + "websocket-client", + "werkzeug", + "wget", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xarray", + "xlrd", + "xlsxwriter", + "xz", + "yaml", + "yapf", + "yarl", + "zeromq", + "zfp", + "zict", + "zipp", + "zlib", + "zope", + "zope.interface", + "zstd" + ], + "license": "BSD", + "md5": "9009d186075580ba7c692314cb877060", + "name": "_anaconda_depends", + "sha256": "48341acf42ed2bee6dbaa45f8add7701c502607bb4ba584216ba84509afd3310", + "size": 6762, + "subdir": "linux-64", + "timestamp": 1651788387896, + "version": "2022.05" + }, + "_anaconda_depends-2022.05-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "_openmp_mutex", + "aiohttp", + "aiosignal", + "alabaster", + "anaconda-client", + "anaconda-project", + "anyio", + "appdirs", + "argon2-cffi", + "argon2-cffi-bindings", + "arrow", + "astroid", + "astropy", + "asttokens", + "async-timeout", + "atomicwrites", + "attrs", + "automat", + "autopep8", + "babel", + "backcall", + "backports", + "backports.functools_lru_cache", + "backports.tempfile", + "backports.weakref", + "bcrypt", + "beautifulsoup4", + "binaryornot", + "bitarray", + "bkcharts", + "black", + "blas", + "bleach", + "blosc", + "bokeh", + "boto3", + "botocore", + "bottleneck", + "brotli", + "brotlipy", + "brunsli", + "bzip2", + "c-ares", + "ca-certificates", + "cachetools", + "certifi", + "cffi", + "cfitsio", + "chardet", + "charls", + "charset-normalizer", + "click", + "cloudpickle", + "clyent", + "colorama", + "colorcet", + "conda-content-trust", + "conda-token", + "constantly", + "cookiecutter", + "cryptography", + "cssselect", + "curl", + "cycler", + "cython", + "cytoolz", + "daal4py", + "dal", + "dask", + "dask-core", + "dataclasses", + "datashader", + "datashape", + "dbus", + "debugpy", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "executing", + "expat", + "filelock", + "flake8", + "flask", + "fontconfig", + "fonttools", + "freetype", + "frozenlist", + "fsspec", + "future", + "gensim", + "giflib", + "glib", + "glob2", + "gmp", + "gmpy2", + "google-api-core", + "google-auth", + "google-cloud-core", + "google-cloud-storage", + "google-crc32c", + "google-resumable-media", + "googleapis-common-protos", + "greenlet", + "grpcio", + "gst-plugins-base", + "gstreamer", + "h5py", + "hdf5", + "heapdict", + "holoviews", + "hvplot", + "hyperlink", + "icu", + "idna", + "imagecodecs", + "imageio", + "imagesize", + "importlib-metadata", + "importlib_metadata", + "importlib_resources", + "incremental", + "inflection", + "iniconfig", + "intake", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itemadapter", + "itemloaders", + "itsdangerous", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jinja2-time", + "jmespath", + "joblib", + "jpeg", + "jq", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyter_server", + "jupyterlab", + "jupyterlab_pygments", + "jupyterlab_server", + "jupyterlab_widgets", + "jxrlib", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "lcms2", + "ld_impl_linux-64", + "lerc", + "libaec", + "libarchive", + "libcrc32c", + "libcurl", + "libdeflate", + "libedit", + "libev", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libgfortran4", + "libgomp", + "libidn2", + "liblief", + "libllvm11", + "libnghttp2", + "libpng", + "libprotobuf", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libunistring", + "libuuid", + "libwebp", + "libwebp-base", + "libxcb", + "libxml2", + "libxslt", + "libzopfli", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markdown", + "markupsafe", + "matplotlib", + "matplotlib-base", + "matplotlib-inline", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "mpc", + "mpfr", + "mpi", + "mpich", + "mpmath", + "msgpack-python", + "multidict", + "multipledispatch", + "munkres", + "mypy_extensions", + "nbclassic", + "nbclient", + "nbconvert", + "nbformat", + "ncurses", + "nest-asyncio", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "oniguruma", + "openjpeg", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "panel", + "param", + "parsel", + "parso", + "partd", + "patchelf", + "pathspec", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pkginfo", + "plotly", + "pluggy", + "poyo", + "prometheus_client", + "prompt-toolkit", + "prompt_toolkit", + "protego", + "protobuf", + "psutil", + "ptyprocess", + "pure_eval", + "py", + "py-lief", + "pyasn1", + "pyasn1-modules", + "pycodestyle", + "pycosat", + "pycparser", + "pyct", + "pycurl", + "pydispatcher", + "pydocstyle", + "pyerfa", + "pyflakes", + "pygments", + "pyhamcrest", + "pylint", + "pyls-spyder", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 3.8.*", + "python-dateutil", + "python-fastjsonschema", + "python-libarchive-c", + "python-lsp-black", + "python-lsp-jsonrpc", + "python-lsp-server", + "python-slugify", + "python-snappy", + "pytz", + "pyviz_comms", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qstylizer", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "queuelib", + "readline", + "regex", + "requests", + "requests-file", + "ripgrep", + "rope", + "rsa", + "rtree", + "ruamel_yaml", + "s3transfer", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "secretstorage", + "send2trash", + "service_identity", + "setuptools", + "sip", + "six", + "smart_open", + "snappy", + "sniffio", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "stack_data", + "statsmodels", + "sympy", + "tabulate", + "tbb", + "tbb4py", + "tblib", + "tenacity", + "terminado", + "testpath", + "text-unidecode", + "textdistance", + "threadpoolctl", + "three-merge", + "tifffile", + "tinycss", + "tk", + "tldextract", + "toml", + "tomli", + "toolz", + "tornado", + "tqdm", + "traitlets", + "twisted", + "typed-ast", + "typing-extensions", + "typing_extensions", + "ujson", + "unidecode", + "unixodbc", + "urllib3", + "w3lib", + "watchdog", + "wcwidth", + "webencodings", + "websocket-client", + "werkzeug", + "wget", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xarray", + "xlrd", + "xlsxwriter", + "xz", + "yaml", + "yapf", + "yarl", + "zeromq", + "zfp", + "zict", + "zipp", + "zlib", + "zope", + "zope.interface", + "zstd" + ], + "license": "BSD", + "md5": "979c45923536830123856ac8c2351b1c", + "name": "_anaconda_depends", + "sha256": "62f3af2a9e1a566736236ac757a2d32ca29d4cde7fa4c1254b93607f38f24f22", + "size": 6783, + "subdir": "linux-64", + "timestamp": 1651788399085, + "version": "2022.05" + }, + "_anaconda_depends-2022.05-py39_0.tar.bz2": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "_openmp_mutex", + "aiohttp", + "aiosignal", + "alabaster", + "anaconda-client", + "anaconda-project", + "anyio", + "appdirs", + "argon2-cffi", + "argon2-cffi-bindings", + "arrow", + "astroid", + "astropy", + "asttokens", + "async-timeout", + "atomicwrites", + "attrs", + "automat", + "autopep8", + "babel", + "backcall", + "backports", + "backports.functools_lru_cache", + "backports.tempfile", + "backports.weakref", + "bcrypt", + "beautifulsoup4", + "binaryornot", + "bitarray", + "bkcharts", + "black", + "blas", + "bleach", + "blosc", + "bokeh", + "boto3", + "botocore", + "bottleneck", + "brotli", + "brotlipy", + "brunsli", + "bzip2", + "c-ares", + "ca-certificates", + "cachetools", + "certifi", + "cffi", + "cfitsio", + "chardet", + "charls", + "charset-normalizer", + "click", + "cloudpickle", + "clyent", + "colorama", + "colorcet", + "conda-content-trust", + "conda-token", + "constantly", + "cookiecutter", + "cryptography", + "cssselect", + "curl", + "cycler", + "cython", + "cytoolz", + "daal4py", + "dal", + "dask", + "dask-core", + "dataclasses", + "datashader", + "datashape", + "dbus", + "debugpy", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "executing", + "expat", + "filelock", + "flake8", + "flask", + "fontconfig", + "fonttools", + "freetype", + "frozenlist", + "fsspec", + "future", + "gensim", + "giflib", + "glib", + "glob2", + "gmp", + "gmpy2", + "google-api-core", + "google-auth", + "google-cloud-core", + "google-cloud-storage", + "google-crc32c", + "google-resumable-media", + "googleapis-common-protos", + "greenlet", + "grpcio", + "gst-plugins-base", + "gstreamer", + "h5py", + "hdf5", + "heapdict", + "holoviews", + "hvplot", + "hyperlink", + "icu", + "idna", + "imagecodecs", + "imageio", + "imagesize", + "importlib-metadata", + "importlib_metadata", + "incremental", + "inflection", + "iniconfig", + "intake", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itemadapter", + "itemloaders", + "itsdangerous", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jinja2-time", + "jmespath", + "joblib", + "jpeg", + "jq", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyter_server", + "jupyterlab", + "jupyterlab_pygments", + "jupyterlab_server", + "jupyterlab_widgets", + "jxrlib", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "lcms2", + "ld_impl_linux-64", + "lerc", + "libaec", + "libarchive", + "libcrc32c", + "libcurl", + "libdeflate", + "libedit", + "libev", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libgfortran4", + "libgomp", + "libidn2", + "liblief", + "libllvm11", + "libnghttp2", + "libpng", + "libprotobuf", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libunistring", + "libuuid", + "libwebp", + "libwebp-base", + "libxcb", + "libxml2", + "libxslt", + "libzopfli", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markdown", + "markupsafe", + "matplotlib", + "matplotlib-base", + "matplotlib-inline", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "mpc", + "mpfr", + "mpi", + "mpich", + "mpmath", + "msgpack-python", + "multidict", + "multipledispatch", + "munkres", + "mypy_extensions", + "nbclassic", + "nbclient", + "nbconvert", + "nbformat", + "ncurses", + "nest-asyncio", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "oniguruma", + "openjpeg", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "panel", + "param", + "parsel", + "parso", + "partd", + "patchelf", + "pathspec", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pkginfo", + "plotly", + "pluggy", + "poyo", + "prometheus_client", + "prompt-toolkit", + "prompt_toolkit", + "protego", + "protobuf", + "psutil", + "ptyprocess", + "pure_eval", + "py", + "py-lief", + "pyasn1", + "pyasn1-modules", + "pycodestyle", + "pycosat", + "pycparser", + "pyct", + "pycurl", + "pydispatcher", + "pydocstyle", + "pyerfa", + "pyflakes", + "pygments", + "pyhamcrest", + "pylint", + "pyls-spyder", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 3.9.*", + "python-dateutil", + "python-fastjsonschema", + "python-libarchive-c", + "python-lsp-black", + "python-lsp-jsonrpc", + "python-lsp-server", + "python-slugify", + "python-snappy", + "pytz", + "pyviz_comms", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qstylizer", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "queuelib", + "readline", + "regex", + "requests", + "requests-file", + "ripgrep", + "rope", + "rsa", + "rtree", + "ruamel_yaml", + "s3transfer", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "secretstorage", + "send2trash", + "service_identity", + "setuptools", + "sip", + "six", + "smart_open", + "snappy", + "sniffio", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "stack_data", + "statsmodels", + "sympy", + "tabulate", + "tbb", + "tbb4py", + "tblib", + "tenacity", + "terminado", + "testpath", + "text-unidecode", + "textdistance", + "threadpoolctl", + "three-merge", + "tifffile", + "tinycss", + "tk", + "tldextract", + "toml", + "tomli", + "toolz", + "tornado", + "tqdm", + "traitlets", + "twisted", + "typed-ast", + "typing-extensions", + "typing_extensions", + "tzdata", + "ujson", + "unidecode", + "unixodbc", + "urllib3", + "w3lib", + "watchdog", + "wcwidth", + "webencodings", + "websocket-client", + "werkzeug", + "wget", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xarray", + "xlrd", + "xlsxwriter", + "xz", + "yaml", + "yapf", + "yarl", + "zeromq", + "zfp", + "zict", + "zipp", + "zlib", + "zope", + "zope.interface", + "zstd" + ], + "license": "BSD", + "md5": "7ca867bc59d120dc1c89a8dcf6e1ac03", + "name": "_anaconda_depends", + "sha256": "6ac41f100da17c590435d3b40b44cf94897132ec0b628fd5531cbdd5d57411e7", + "size": 6782, + "subdir": "linux-64", + "timestamp": 1651788407958, + "version": "2022.05" + }, + "_anaconda_depends-2022.10-py310_2.tar.bz2": { + "build": "py310_2", + "build_number": 2, + "depends": [ + "alabaster", + "astroid", + "astropy", + "babel", + "backports", + "beautifulsoup4", + "bitarray", + "bkcharts", + "bleach", + "bokeh", + "boto3", + "bottleneck", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dal", + "dask", + "datashader", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "flask", + "fontconfig", + "freetype", + "gensim", + "glib", + "gst-plugins-base", + "gstreamer", + "h5py", + "hdf5", + "heapdict", + "holoviews", + "hvplot", + "icu", + "idna", + "imagesize", + "intake", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jq", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "lazy-object-proxy", + "libffi", + "libpng", + "libsodium", + "libssh2", + "libtiff", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "markupsafe", + "matplotlib", + "mistune", + "mkl", + "mkl-service", + "mpmath", + "msgpack-python", + "nbconvert", + "nbformat", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "panel", + "partd", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "plotly", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pytables", + "pytest", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "setuptools", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tabulate", + "tbb4py", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "unixodbc", + "wcwidth", + "wget", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a59a7384886f7aa2d504e40c14bab9e", + "name": "_anaconda_depends", + "sha256": "8a3632c934a2a3b938f9441a102a6ebaf37683977fc2164052c9d2d196805a9b", + "size": 55046, + "subdir": "linux-64", + "timestamp": 1674079928443, + "version": "2022.10" + }, + "_anaconda_depends-2022.10-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "alabaster", + "astroid", + "astropy", + "babel", + "backports", + "beautifulsoup4", + "bitarray", + "bkcharts", + "bleach", + "bokeh", + "boto3", + "bottleneck", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dal", + "dask", + "datashader", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "flask", + "fontconfig", + "freetype", + "gensim", + "glib", + "gst-plugins-base", + "gstreamer", + "h5py", + "hdf5", + "heapdict", + "holoviews", + "hvplot", + "icu", + "idna", + "imagesize", + "intake", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jq", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "lazy-object-proxy", + "libffi", + "libpng", + "libsodium", + "libssh2", + "libtiff", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "markupsafe", + "matplotlib", + "mistune", + "mkl", + "mkl-service", + "mpmath", + "msgpack-python", + "nbconvert", + "nbformat", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "panel", + "partd", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "plotly", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pytables", + "pytest", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "setuptools", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tabulate", + "tbb4py", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "unixodbc", + "wcwidth", + "wget", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e656d5b235d7d8e98277997218f6fd4e", + "name": "_anaconda_depends", + "sha256": "42ea173b94600056d330c976cfd8dba610ee3e78c559d5d9706fe25ff27a59ec", + "size": 55033, + "subdir": "linux-64", + "timestamp": 1674079934110, + "version": "2022.10" + }, + "_anaconda_depends-2022.10-py38_2.tar.bz2": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "alabaster", + "astroid", + "astropy", + "babel", + "backports", + "beautifulsoup4", + "bitarray", + "bkcharts", + "bleach", + "bokeh", + "boto3", + "bottleneck", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dal", + "dask", + "datashader", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "flask", + "fontconfig", + "freetype", + "gensim", + "glib", + "gst-plugins-base", + "gstreamer", + "h5py", + "hdf5", + "heapdict", + "holoviews", + "hvplot", + "icu", + "idna", + "imagesize", + "intake", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jq", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "lazy-object-proxy", + "libffi", + "libpng", + "libsodium", + "libssh2", + "libtiff", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "markupsafe", + "matplotlib", + "mistune", + "mkl", + "mkl-service", + "mpmath", + "msgpack-python", + "nbconvert", + "nbformat", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "panel", + "partd", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "plotly", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pytables", + "pytest", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "setuptools", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tabulate", + "tbb4py", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "unixodbc", + "wcwidth", + "wget", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "15f617098b451b160e255af6637ef4c7", + "name": "_anaconda_depends", + "sha256": "5e9c540d502ee36bcae4a2d00bba03f7e699350adb6f659fa34f29fdb207a55c", + "size": 55055, + "subdir": "linux-64", + "timestamp": 1674079922312, + "version": "2022.10" + }, + "_anaconda_depends-2022.10-py39_2.tar.bz2": { + "build": "py39_2", + "build_number": 2, + "depends": [ + "alabaster", + "astroid", + "astropy", + "babel", + "backports", + "beautifulsoup4", + "bitarray", + "bkcharts", + "bleach", + "bokeh", + "boto3", + "bottleneck", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dal", + "dask", + "datashader", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "flask", + "fontconfig", + "freetype", + "gensim", + "glib", + "gst-plugins-base", + "gstreamer", + "h5py", + "hdf5", + "heapdict", + "holoviews", + "hvplot", + "icu", + "idna", + "imagesize", + "intake", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jq", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "lazy-object-proxy", + "libffi", + "libpng", + "libsodium", + "libssh2", + "libtiff", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "markupsafe", + "matplotlib", + "mistune", + "mkl", + "mkl-service", + "mpmath", + "msgpack-python", + "nbconvert", + "nbformat", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "panel", + "partd", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "plotly", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pytables", + "pytest", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "setuptools", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tabulate", + "tbb4py", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "unixodbc", + "wcwidth", + "wget", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2a0bd8617eb11a50b0a7bb83d2ab9227", + "name": "_anaconda_depends", + "sha256": "5b1a5183b664b126c96911afa0f61c588b7efc62825a6609c1da0dd94cafa544", + "size": 55080, + "subdir": "linux-64", + "timestamp": 1674079916768, + "version": "2022.10" + }, + "_anaconda_depends-2023.03-py310_0.tar.bz2": { + "build": "py310_0", + "build_number": 0, + "depends": [ + "astropy", + "beautifulsoup4", + "bokeh", + "curl", + "daal4py", + "dal", + "dask", + "datashader", + "flask", + "gensim", + "h5py", + "holoviews", + "hvplot", + "imbalanced-learn", + "intake", + "intel-openmp", + "ipython", + "jq", + "jupyter", + "jupyterlab", + "matplotlib", + "mkl", + "mkl-service", + "nbconvert", + "networkx", + "nltk", + "notebook", + "numba", + "numpy", + "openpyxl", + "pandas", + "panel", + "pep8", + "pillow", + "pip", + "plotly", + "pycurl", + "pyflakes", + "pylint", + "pyodbc", + "pytables", + "pytest", + "python >=3.10,<3.11.0a0", + "pywavelets", + "requests", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "setuptools", + "snowballstemmer", + "spyder", + "sqlalchemy", + "statsmodels", + "sympy", + "tabulate", + "tbb4py", + "transformers", + "unixodbc", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "37b50e56a219c9efee2f4cfb923883cd", + "name": "_anaconda_depends", + "sha256": "c62b3b7103948e0d83808282913ebb546ae542c7e807cec11bc54a4003891459", + "size": 53318, + "subdir": "linux-64", + "timestamp": 1678132252313, + "version": "2023.03" + }, + "_anaconda_depends-2023.03-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "astropy", + "beautifulsoup4", + "bokeh", + "curl", + "daal4py", + "dal", + "dask", + "datashader", + "flask", + "gensim", + "h5py", + "holoviews", + "hvplot", + "imbalanced-learn", + "intake", + "intel-openmp", + "ipython", + "jq", + "jupyter", + "jupyterlab", + "matplotlib", + "mkl", + "mkl-service", + "nbconvert", + "networkx", + "nltk", + "notebook", + "numba", + "numpy", + "openpyxl", + "pandas", + "panel", + "pep8", + "pillow", + "pip", + "plotly", + "pycurl", + "pyflakes", + "pylint", + "pyodbc", + "pytables", + "pytest", + "python >=3.8,<3.9.0a0", + "pywavelets", + "requests", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "setuptools", + "snowballstemmer", + "spyder", + "sqlalchemy", + "statsmodels", + "sympy", + "tabulate", + "tbb4py", + "transformers", + "unixodbc", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eaf2fdbf911f0234db4b718a17a942d9", + "name": "_anaconda_depends", + "sha256": "a0ebb53bc761afb47290c858e7698b4b750ddaf6691972e807a45513ef2a760f", + "size": 53261, + "subdir": "linux-64", + "timestamp": 1678132263899, + "version": "2023.03" + }, + "_anaconda_depends-2023.03-py39_0.tar.bz2": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "astropy", + "beautifulsoup4", + "bokeh", + "curl", + "daal4py", + "dal", + "dask", + "datashader", + "flask", + "gensim", + "h5py", + "holoviews", + "hvplot", + "imbalanced-learn", + "intake", + "intel-openmp", + "ipython", + "jq", + "jupyter", + "jupyterlab", + "matplotlib", + "mkl", + "mkl-service", + "nbconvert", + "networkx", + "nltk", + "notebook", + "numba", + "numpy", + "openpyxl", + "pandas", + "panel", + "pep8", + "pillow", + "pip", + "plotly", + "pycurl", + "pyflakes", + "pylint", + "pyodbc", + "pytables", + "pytest", + "python >=3.9,<3.10.0a0", + "pywavelets", + "requests", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "setuptools", + "snowballstemmer", + "spyder", + "sqlalchemy", + "statsmodels", + "sympy", + "tabulate", + "tbb4py", + "transformers", + "unixodbc", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b0601a8a899cf6e36582b7b75458a72c", + "name": "_anaconda_depends", + "sha256": "209003ef1da60b01dd8d624d268a0102a136b0c53188f7f991c4b1f28e62ce37", + "size": 53258, + "subdir": "linux-64", + "timestamp": 1678132258283, + "version": "2023.03" + }, + "_anaconda_depends-5.0.0-py27he0e5e41_0.tar.bz2": { + "build": "py27he0e5e41_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "funcsigs", + "functools32", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "f5093090a077ea0b1a5ebb589f8e5d1f", + "name": "_anaconda_depends", + "sha256": "f0b39b3e8ab30446ec3c2a3cfcfe48604c76b23a7a937068bfa6a666c206dc93", + "size": 5283, + "subdir": "linux-64", + "timestamp": 1562174055449, + "version": "5.0.0" + }, + "_anaconda_depends-5.0.0-py35h81e3b35_0.tar.bz2": { + "build": "py35h81e3b35_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.5.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "17ac667e5ec71510dc5d94799d186651", + "name": "_anaconda_depends", + "sha256": "ab6ad4e67bba7123e143d02fd70119b61e0de819ba78d972621394f94dcaaf3a", + "size": 5133, + "subdir": "linux-64", + "timestamp": 1562174066309, + "version": "5.0.0" + }, + "_anaconda_depends-5.0.0-py36h06de3c5_0.tar.bz2": { + "build": "py36h06de3c5_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.6.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "e9a9276719edcdc53f776cfbf0d8f025", + "name": "_anaconda_depends", + "sha256": "0023abd2b926887c0a6dcee7832999568108f7144417796d328644809f3d38da", + "size": 5118, + "subdir": "linux-64", + "timestamp": 1562174078347, + "version": "5.0.0" + }, + "_anaconda_depends-5.0.0.1-py27h1e3bc52_1.tar.bz2": { + "build": "py27h1e3bc52_1", + "build_number": 1, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "funcsigs", + "functools32", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "67adda0ca4cdc5c7db181bbaf79e471d", + "name": "_anaconda_depends", + "sha256": "9678dc69e9add8fe9485b2a688039a17146c357ee887a9bbd541ecc67a3361e3", + "size": 5314, + "subdir": "linux-64", + "timestamp": 1562173977964, + "version": "5.0.0.1" + }, + "_anaconda_depends-5.0.0.1-py27hfd10420_0.tar.bz2": { + "build": "py27hfd10420_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "funcsigs", + "functools32", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "09f016d4097ecb4570d1830f8de5dd18", + "name": "_anaconda_depends", + "sha256": "37821f82c94d2a165d4bd070b71ba406b0d9cf10af611977c00422c958cb2d7e", + "size": 5285, + "subdir": "linux-64", + "timestamp": 1562173992756, + "version": "5.0.0.1" + }, + "_anaconda_depends-5.0.0.1-py35h1ed3d8c_0.tar.bz2": { + "build": "py35h1ed3d8c_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.5.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "1d87c9478630b9a479f8df8d36fea650", + "name": "_anaconda_depends", + "sha256": "e38d5158e82d5d7635d8176e66d33891504af881dd1afa1ae12bf0804406d03b", + "size": 5129, + "subdir": "linux-64", + "timestamp": 1562174003282, + "version": "5.0.0.1" + }, + "_anaconda_depends-5.0.0.1-py35h6d98c0b_1.tar.bz2": { + "build": "py35h6d98c0b_1", + "build_number": 1, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.5.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "3d99e3cb24311a7ebce55bd107308c58", + "name": "_anaconda_depends", + "sha256": "23baa4de51200325ce8872ee8397b4afd2fef3cb15dea1a083b7892cdb92a571", + "size": 5118, + "subdir": "linux-64", + "timestamp": 1562174015006, + "version": "5.0.0.1" + }, + "_anaconda_depends-5.0.0.1-py36h6c6c83f_0.tar.bz2": { + "build": "py36h6c6c83f_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.6.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "c40e1224b833fe2858d1bcd138c74e93", + "name": "_anaconda_depends", + "sha256": "db30af573df44b26bbfe86d574821f33d2556d80a1921aa181c6b587c2d783c5", + "size": 5122, + "subdir": "linux-64", + "timestamp": 1562174027781, + "version": "5.0.0.1" + }, + "_anaconda_depends-5.0.0.1-py36hfb0b618_1.tar.bz2": { + "build": "py36hfb0b618_1", + "build_number": 1, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.6.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "e7c7235e58f3dc89f474e211e711a4e0", + "name": "_anaconda_depends", + "sha256": "de361ad61f1655a25f2aca0f7c1f08e88e3c8530141d9a6d19d4cbc32cb5bc10", + "size": 5120, + "subdir": "linux-64", + "timestamp": 1562174040487, + "version": "5.0.0.1" + }, + "_anaconda_depends-5.0.1-py27hd9359a7_1.tar.bz2": { + "build": "py27hd9359a7_1", + "build_number": 1, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "funcsigs", + "functools32", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "07132a5a703fb3e515e4cbc33a06add0", + "name": "_anaconda_depends", + "sha256": "cf0d23473da6f1f4521c8ae445fa19e9ad8257db01831336a7a7e9d3157549e7", + "size": 5295, + "subdir": "linux-64", + "timestamp": 1562174094094, + "version": "5.0.1" + }, + "_anaconda_depends-5.0.1-py35h6f6dcbc_1.tar.bz2": { + "build": "py35h6f6dcbc_1", + "build_number": 1, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.5.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "e2488de0c46c57979c4dc8103a0387f0", + "name": "_anaconda_depends", + "sha256": "bd33349341273f57b8178c28aebf017df845a0a39eaa25cdeae4ceb4a459fc13", + "size": 5114, + "subdir": "linux-64", + "timestamp": 1562174105402, + "version": "5.0.1" + }, + "_anaconda_depends-5.0.1-py36hd30a520_1.tar.bz2": { + "build": "py36hd30a520_1", + "build_number": 1, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.6.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "4cddc683f82ae39560e5216dc7f8f2c4", + "name": "_anaconda_depends", + "sha256": "5460a6112fb75f893827625016010929e540ce8971dd7584966940c24593dfd4", + "size": 5129, + "subdir": "linux-64", + "timestamp": 1562174117633, + "version": "5.0.1" + }, + "_anaconda_depends-5.1.0-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "attrs", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "funcsigs", + "functools32", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "a123ba3848329f747d21944b0c4697c2", + "name": "_anaconda_depends", + "sha256": "455189b0c28696993476fb1922bb547acf47f744aaaaf1b2b3140349052913dd", + "size": 5355, + "subdir": "linux-64", + "timestamp": 1562174132746, + "version": "5.1.0" + }, + "_anaconda_depends-5.1.0-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "attrs", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.5.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "22abc849d9d8cf4ac0733881a915bc5d", + "name": "_anaconda_depends", + "sha256": "824e94ce147283848cc4d31293c793b95f4db6c3917666537179e196c34eaec2", + "size": 5176, + "subdir": "linux-64", + "timestamp": 1562174142418, + "version": "5.1.0" + }, + "_anaconda_depends-5.1.0-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "attrs", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.6.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "110fe901c71c6a432d3a102a76d7ba64", + "name": "_anaconda_depends", + "sha256": "20f92f7a8f83b87ed18bf790b0f2378a89a5a5994f91316cbf15a5d72382f469", + "size": 5184, + "subdir": "linux-64", + "timestamp": 1562174154716, + "version": "5.1.0" + }, + "_anaconda_depends-5.2.0-py27_3.tar.bz2": { + "build": "py27_3", + "build_number": 3, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "attrs", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "funcsigs", + "functools32", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "bb83e3ef76e7f5f93d193164047241a1", + "name": "_anaconda_depends", + "sha256": "72e47ae0e11a01ce5c0035666e9f9a7468ec5a110e2a1722a4ab5ec5e84a51d1", + "size": 5352, + "subdir": "linux-64", + "timestamp": 1562174170539, + "version": "5.2.0" + }, + "_anaconda_depends-5.2.0-py35_3.tar.bz2": { + "build": "py35_3", + "build_number": 3, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "attrs", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.5.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "facf81d3f909387b28338380a46086b6", + "name": "_anaconda_depends", + "sha256": "9c1a92144878f6fcad81ecff87abb3a1654b173bbfb66c6c8ab59be856391e8a", + "size": 5247, + "subdir": "linux-64", + "timestamp": 1562174180775, + "version": "5.2.0" + }, + "_anaconda_depends-5.2.0-py36_3.tar.bz2": { + "build": "py36_3", + "build_number": 3, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "attrs", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.6.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "e8bcb933dc544c0b0fb443d555288171", + "name": "_anaconda_depends", + "sha256": "6508055cbde9206ef2a82b2ef5bc9173f0a8af991c8ae09b3d125d4c36b54465", + "size": 5249, + "subdir": "linux-64", + "timestamp": 1562174193565, + "version": "5.2.0" + }, + "_anaconda_depends-5.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "appdirs", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "automat", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "constantly", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "funcsigs", + "functools32", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hyperlink", + "icu", + "idna", + "imageio", + "imagesize", + "incremental", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "linecache2", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pyasn1", + "pyasn1-modules", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "service_identity", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traceback2", + "traitlets", + "twisted", + "typing", + "unicodecsv", + "unittest2", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zope", + "zope.interface" + ], + "license": "BSD", + "md5": "30e55b40e13a394f3d6011b26d3a06f0", + "name": "_anaconda_depends", + "sha256": "ed8ee0317f25101b88bc561c7907d1e77ff1f59ae2542b42aa7921be3dd4a101", + "size": 5611, + "subdir": "linux-64", + "timestamp": 1562174211249, + "version": "5.3.0" + }, + "_anaconda_depends-5.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "appdirs", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "automat", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "constantly", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hyperlink", + "icu", + "idna", + "imageio", + "imagesize", + "incremental", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "keyring", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pyasn1", + "pyasn1-modules", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.6.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "service_identity", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "twisted", + "typed-ast", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zope", + "zope.interface" + ], + "license": "BSD", + "md5": "1d5a411b61fbda76fada90426240eeb1", + "name": "_anaconda_depends", + "sha256": "d3d82b9a8b82a8ccfce85c08dc8fd9703280475877b466141731e3ecfa53bc8c", + "size": 5517, + "subdir": "linux-64", + "timestamp": 1562174224865, + "version": "5.3.0" + }, + "_anaconda_depends-5.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "appdirs", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "automat", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "constantly", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hyperlink", + "icu", + "idna", + "imageio", + "imagesize", + "incremental", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "keyring", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pyasn1", + "pyasn1-modules", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "service_identity", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "twisted", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zope", + "zope.interface" + ], + "license": "BSD", + "md5": "532af2ef14abd25b0452331b61b5ada9", + "name": "_anaconda_depends", + "sha256": "927bc99cdba69f4e6cac6b33fafc70b8cbcf577fdb4abac1fc6a51179285fdca", + "size": 5489, + "subdir": "linux-64", + "timestamp": 1562174233624, + "version": "5.3.0" + }, + "_anaconda_depends-5.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "appdirs", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "automat", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "constantly", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "funcsigs", + "functools32", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hyperlink", + "icu", + "idna", + "imageio", + "imagesize", + "incremental", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "linecache2", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pyasn1", + "pyasn1-modules", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "service_identity", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traceback2", + "traitlets", + "twisted", + "typing", + "unicodecsv", + "unittest2", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zope", + "zope.interface" + ], + "license": "BSD", + "md5": "cfdd7a886ba2203733686e5ecf2d091d", + "name": "_anaconda_depends", + "sha256": "3df4eda81d0ea80399c52790f58ecb4d437fe69ed27f04adea47fa7477f4f7aa", + "size": 5607, + "subdir": "linux-64", + "timestamp": 1562174249652, + "version": "5.3.1" + }, + "_anaconda_depends-5.3.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "appdirs", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "automat", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "constantly", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "funcsigs", + "functools32", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hyperlink", + "icu", + "idna", + "imageio", + "imagesize", + "incremental", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "linecache2", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pyasn1", + "pyasn1-modules", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "service_identity", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traceback2", + "traitlets", + "twisted", + "typing", + "unicodecsv", + "unittest2", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zope", + "zope.interface" + ], + "license": "BSD", + "md5": "1b89d453b22e3c5547da42f3315d8fcb", + "name": "_anaconda_depends", + "sha256": "7e17cfbe57c5533fd54554b7a34998f7f39a91d96f5fd47dde639c858779d508", + "size": 5597, + "subdir": "linux-64", + "timestamp": 1562174265857, + "version": "5.3.1" + }, + "_anaconda_depends-5.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "appdirs", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "automat", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "constantly", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hyperlink", + "icu", + "idna", + "imageio", + "imagesize", + "incremental", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "keyring", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pyasn1", + "pyasn1-modules", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "service_identity", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "twisted", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zope", + "zope.interface" + ], + "license": "BSD", + "md5": "42ee8a8be641cc7d7d8e7a85795f9273", + "name": "_anaconda_depends", + "sha256": "146f8ca809f856f91ded0af9ef505f0790deb99ba1ae22ad568248a1c26b6721", + "size": 5483, + "subdir": "linux-64", + "timestamp": 1562174274613, + "version": "5.3.1" + }, + "_anaconda_depends-5.3.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "appdirs", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "automat", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "constantly", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hyperlink", + "icu", + "idna", + "imageio", + "imagesize", + "incremental", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "keyring", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pyasn1", + "pyasn1-modules", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "service_identity", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "twisted", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zope", + "zope.interface" + ], + "license": "BSD", + "md5": "28c30ed1ea5e81c25f087f8d598aaa6b", + "name": "_anaconda_depends", + "sha256": "180d18ecc64bf8935081ffbb8712cadf96b483ed572e2e79190b6bd764ecdbd9", + "size": 5491, + "subdir": "linux-64", + "timestamp": 1562174283455, + "version": "5.3.1" + }, + "_go_select-2.1.0-precompiled.tar.bz2": { + "build": "precompiled", + "build_number": 0, + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "56913cc5dfe2307afd26b05c370c3657", + "name": "_go_select", + "sha256": "8c5d08195733647656c2fa9489bd8ebdd4a8f81a6c0aa0d1b4bf175b786b533c", + "size": 7188, + "subdir": "linux-64", + "timestamp": 1623378331023, + "version": "2.1.0" + }, + "_go_select-2.2.0-nocgo.tar.bz2": { + "build": "nocgo", + "build_number": 0, + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ad171d8654d2bf31a1ca4cf2e1055c5e", + "name": "_go_select", + "sha256": "bfd64510a00181d0411bb269d2596439b9ce26571ce069decabd81a6f45a5355", + "size": 7187, + "subdir": "linux-64", + "timestamp": 1623377704294, + "version": "2.2.0" + }, + "_go_select-2.3.0-cgo.tar.bz2": { + "build": "cgo", + "build_number": 0, + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4fab1f3bec2e53f997175b862a9af0fa", + "name": "_go_select", + "sha256": "1416adbfdca9b657eafd3f01bf5041437854a17c0cc3c8691382bce9ff091388", + "size": 7192, + "subdir": "linux-64", + "timestamp": 1623378326334, + "version": "2.3.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=2.7,<2.8.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "d67908f8a3ad64f1dd6f507ee42b3875", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "2259b199e6f200b157fc6f47f1bac0718455e9fdf0214a455225c1abf0240c11", + "size": 3762, + "subdir": "linux-64", + "timestamp": 1530735062325, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py27h08a7f0c_0.tar.bz2": { + "build": "py27h08a7f0c_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=2.7,<2.8.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "c19ed449c7c97c9e59dc9d36ff2b4422", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "2f87aee4ff29f9903321955a1e090f2b225d5e0632cd15c90b7b25ba56a876f1", + "size": 4151, + "subdir": "linux-64", + "timestamp": 1505722768904, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.10,<3.11.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "9f5757e0dcd44da834d837e1c65fc703", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "200a3b7b74f4e35dab6339c1829ec4d0540beda1598e6437968369eb7584efdc", + "size": 4450, + "subdir": "linux-64", + "timestamp": 1641918112240, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.10,<3.11.0a0", + "widgetsnbextension" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8dab307ad0cea33cc67c5fa5bff87933", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "4ea3e917cc8bde278f86a73864cf850a9c5f65a1e3dd03845b3fdaeebce30829", + "size": 4211, + "subdir": "linux-64", + "timestamp": 1649860682597, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.11,<3.12.0a0", + "widgetsnbextension" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5aedd51e0b51d7085e0b9d1d9feacb2a", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "b108651cb24a3bc218aa3770b17d30002b3d5e3c9e0ab203d235fed90ba0e763", + "size": 4295, + "subdir": "linux-64", + "timestamp": 1679340223752, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.5,<3.6.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "9b9a050eea013dfb02e32ce3e3960e27", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "d6228aa6e1e00506d8aaaff8d5fc84b70a7223894054e59cf703e0d6d292ef9c", + "size": 3804, + "subdir": "linux-64", + "timestamp": 1534351776132, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py35h02fa31e_0.tar.bz2": { + "build": "py35h02fa31e_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.5,<3.6.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "e1b5bb5eaaf614ba941a436ceff27a2d", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "e764f63513e08592fc2769b1670e60de754d59e55d9f351ba67bafca14c54fed", + "size": 3939, + "subdir": "linux-64", + "timestamp": 1505691121049, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.6,<3.7.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "3c5297adf8c731e3a4b3be8898791f03", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "539933f80e77054c0f09155cce44e6f2bcbac18c59eb3463450dfe8172390004", + "size": 3637, + "subdir": "linux-64", + "timestamp": 1530735015948, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py36he11e457_0.tar.bz2": { + "build": "py36he11e457_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.6,<3.7.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "9a9f06f81cbc16fab1724eca02022a19", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "2ed28e17e355df7db6ec1f06a913fc8cdffa5d340ce33529bacd0c4e755fffa7", + "size": 3948, + "subdir": "linux-64", + "timestamp": 1505691138983, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.7,<3.8.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "de8f33a64b7a425cb62f34567f796a0b", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "4e153d942c71db69861112bf461ed7d6a40b03d02ca0c3eefb498da1a9de76fd", + "size": 3649, + "subdir": "linux-64", + "timestamp": 1530735099589, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.7,<3.8.0a0", + "widgetsnbextension" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d1972333f146d0fd704fc95244713ec2", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "9d65b2b02d063bfc113d5fde559c7240c2fecd1fa34ecbba7af1df8e23d00c5f", + "size": 4169, + "subdir": "linux-64", + "timestamp": 1649860621854, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.8,<3.9.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "94b08bb96eacd6ca83c699ffd0e2e41f", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "c38e08737e881c7aeb2fca37c3879dffb586e5553a38b5f096229ad7bb95faa6", + "size": 173507, + "subdir": "linux-64", + "timestamp": 1593558066359, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.8,<3.9.0a0", + "widgetsnbextension" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "691d438b1897712fd260eee600b960da", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "86fe61f8cfb5fe0ce8b40f27f1e76af794b918fd2d84c2ef4ddaa816a2bfb139", + "size": 4175, + "subdir": "linux-64", + "timestamp": 1649860731265, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.9,<3.10.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "560a32e59079601d75a05f06c3c929ec", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "28e6bea2b7828bede522040c1861183bdea5e441e460d03677b555223dcc8466", + "size": 203340, + "subdir": "linux-64", + "timestamp": 1608230120597, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.9,<3.10.0a0", + "widgetsnbextension" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bdf90ae8e0e94a33bd3393cab0842f79", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "7694e01034b1960c48b61044f34f4b53d77e8f8731a23f5025323028fea65fe4", + "size": 4164, + "subdir": "linux-64", + "timestamp": 1649860571444, + "version": "0.1.0" + }, + "_libarchive_static_for_cph-3.3.3-hf8de549_0.tar.bz2": { + "build": "hf8de549_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "md5": "ebd8748f8d1f6f825b2db545a5dee06e", + "name": "_libarchive_static_for_cph", + "sha256": "097c1b5f965758492cb0b954c1c366dda12e84026da42d155d4d34529ebc467a", + "size": 1278745, + "subdir": "linux-64", + "timestamp": 1568316050596, + "version": "3.3.3" + }, + "_libarchive_static_for_cph-3.4.3-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "md5": "8a6b9eb7264c446a96cc3dc04f16fd59", + "name": "_libarchive_static_for_cph", + "sha256": "52c5e0d56ca39630c52cee84f7928626887fb515acca5b9d29ea049eccf6bc0f", + "size": 1398361, + "subdir": "linux-64", + "timestamp": 1602685890983, + "version": "3.4.3" + }, + "_libarchive_static_for_cph-3.4.3-h14c3975_2.tar.bz2": { + "build": "h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "md5": "02a5740869cff9f58c860c592dc9816b", + "name": "_libarchive_static_for_cph", + "sha256": "1dc5f87e70c0f44f7463f303fe13181d74ca007e8aa35bec22d5fdcb4d3729c9", + "size": 1405124, + "subdir": "linux-64", + "timestamp": 1602831181297, + "version": "3.4.3" + }, + "_libarchive_static_for_cph-3.4.3-hf8de549_0.tar.bz2": { + "build": "hf8de549_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "md5": "1f94445c87bbc1b7b67a3a2609e7f47b", + "name": "_libarchive_static_for_cph", + "sha256": "cce072a424ddbdb259b8c05ca8934540961ae957d7ef2b43f2ffbf99ad93310a", + "size": 1585162, + "subdir": "linux-64", + "timestamp": 1602685785944, + "version": "3.4.3" + }, + "_libarchive_static_for_cph-3.4.3-hf8de549_2.tar.bz2": { + "build": "hf8de549_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "md5": "4c4e45a6c02df52e4fe0efb56265c584", + "name": "_libarchive_static_for_cph", + "sha256": "ebf5d417bf448418a1b6ff0819a540cb3e6da086f33da4333d529c65239f4aef", + "size": 1590437, + "subdir": "linux-64", + "timestamp": 1602831121800, + "version": "3.4.3" + }, + "_libarchive_static_for_cph-3.6.1-h6926279_0.tar.bz2": { + "build": "h6926279_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "da8ac95a7dd288f5d2c54bb842f23fbb", + "name": "_libarchive_static_for_cph", + "sha256": "40f62ef46cfe14a5a4a74409e8425d503077c520617218c52abfc9bd998ae8fe", + "size": 1307551, + "subdir": "linux-64", + "timestamp": 1666855795487, + "version": "3.6.1" + }, + "_libgcc_mutex-0.1-main.tar.bz2": { + "build": "main", + "build_number": 0, + "depends": [], + "md5": "013d3f22cd3b87f71224bd936765bcad", + "name": "_libgcc_mutex", + "sha256": "bd36a740479053a94d9c2a92bc55333a7a1a3e63ec0341d4cde6b7825bae0ee3", + "size": 3121, + "subdir": "linux-64", + "timestamp": 1562011674792, + "version": "0.1" + }, + "_low_priority-1.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "md5": "167553048136fe2bea6f6990d0c566d6", + "name": "_low_priority", + "sha256": "3e069f878b95649c4100f5ac846045c184ce4f521422b687b5874efe3fbb290d", + "size": 142332, + "subdir": "linux-64", + "timestamp": 1563307428325, + "track_features": "_low_priority", + "version": "1.0" + }, + "_mutex_mxnet-0.0.10-gpu_openblas.tar.bz2": { + "build": "gpu_openblas", + "build_number": 0, + "depends": [], + "md5": "5f50bf12ff7b3adec32b5ac2ca2ee85a", + "name": "_mutex_mxnet", + "sha256": "3299079a07a1373633c1d59bcaf93188b5f81a883dfaab1bdba0ece560cb581f", + "size": 2149, + "subdir": "linux-64", + "timestamp": 1533361949863, + "version": "0.0.10" + }, + "_mutex_mxnet-0.0.20-gpu_mkl.tar.bz2": { + "build": "gpu_mkl", + "build_number": 0, + "depends": [], + "md5": "36a7bf1f3211f30c1d2c71ddc09a9219", + "name": "_mutex_mxnet", + "sha256": "2d54ba908e23b2df40780e174a3b55fba765e2b88f6bfeaf711ce955131c6c17", + "size": 2149, + "subdir": "linux-64", + "timestamp": 1533361947999, + "version": "0.0.20" + }, + "_mutex_mxnet-0.0.30-mkl.tar.bz2": { + "build": "mkl", + "build_number": 0, + "depends": [], + "md5": "8fba3ea359b970f38a838db51f3a97a2", + "name": "_mutex_mxnet", + "sha256": "7072d5163d5a238485f1dc82dd2339f453b61806dcbde4b7f84e1e71f97a2e23", + "size": 2160, + "subdir": "linux-64", + "timestamp": 1633948420983, + "version": "0.0.30" + }, + "_mutex_mxnet-0.0.30-openblas.tar.bz2": { + "build": "openblas", + "build_number": 0, + "depends": [], + "md5": "879d792f20dff27587b83a85a05508d0", + "name": "_mutex_mxnet", + "sha256": "c1ef7e9f026affa8369abc04c63e43018efcab7fc50f117c4683b69825c17656", + "size": 2149, + "subdir": "linux-64", + "timestamp": 1533361950617, + "version": "0.0.30" + }, + "_mutex_mxnet-0.0.40-mkl.tar.bz2": { + "build": "mkl", + "build_number": 0, + "depends": [], + "md5": "fc4504e72ec3cebd150f920ddccc3138", + "name": "_mutex_mxnet", + "sha256": "1f91414372c9c73d39f4649e6cc18023f1ff78f6a6e73c6e63715bae3a03682d", + "size": 2141, + "subdir": "linux-64", + "timestamp": 1533361949118, + "version": "0.0.40" + }, + "_mutex_mxnet-0.0.40-openblas.tar.bz2": { + "build": "openblas", + "build_number": 0, + "depends": [], + "md5": "b52fc98bbaa7406e006f1c91320fd27e", + "name": "_mutex_mxnet", + "sha256": "ba0a7c2d5a3826ec1ea2506dee674eae50019f8f7eabcbacb540deeb4b06e362", + "size": 2149, + "subdir": "linux-64", + "timestamp": 1633948426128, + "version": "0.0.40" + }, + "_mutex_mxnet-0.0.50-openblas.tar.bz2": { + "build": "openblas", + "build_number": 0, + "depends": [], + "md5": "8bc47944a70eeddec7ea9c5c003e0b3b", + "name": "_mutex_mxnet", + "sha256": "da42c170a5fbb9fa51f429040aa786b88ff403fe1e5945782c10b30af4ff8ceb", + "size": 9795, + "subdir": "linux-64", + "timestamp": 1665585850437, + "version": "0.0.50" + }, + "_openmp_mutex-4.5-1_gnu.tar.bz2": { + "build": "1_gnu", + "build_number": 17, + "constrains": [ + "openmp_impl 9999" + ], + "depends": [ + "_libgcc_mutex 0.1 main", + "libgomp >=7.5.0" + ], + "license": "BSD-3-Clause", + "md5": "84414b0edb0a36bd7e25fc4936c1abb5", + "name": "_openmp_mutex", + "sha256": "2c269ff2e33d3c158b4744485b7fe11ee132814c55a70b33b3e68d588375d465", + "size": 22165, + "subdir": "linux-64", + "timestamp": 1612961522265, + "version": "4.5" + }, + "_openmp_mutex-5.1-1_gnu.tar.bz2": { + "build": "1_gnu", + "build_number": 0, + "constrains": [ + "openmp_impl 9999" + ], + "depends": [ + "_libgcc_mutex 0.1 main", + "libgomp >=7.5.0" + ], + "license": "BSD-3-Clause", + "md5": "613805add1c05b538ff06d217252feb7", + "name": "_openmp_mutex", + "sha256": "9e1391519971e7ce527b3f268900d079bedf0eff3fb70cdb4844cd0f64dfe086", + "size": 20810, + "subdir": "linux-64", + "timestamp": 1652859733309, + "version": "5.1" + }, + "_py-xgboost-mutex-1.0-gpu_0.tar.bz2": { + "build": "gpu_0", + "build_number": 0, + "depends": [], + "md5": "ff89a268abe0e306e1248e22a26c78a5", + "name": "_py-xgboost-mutex", + "sha256": "9b286c6c96997cd49ecd0470640aa92dd1b05e32c9f96db0777a2fb5643d9c60", + "size": 7432, + "subdir": "linux-64", + "timestamp": 1530223592998, + "version": "1.0" + }, + "_py-xgboost-mutex-2.0-cpu_0.tar.bz2": { + "build": "cpu_0", + "build_number": 0, + "depends": [], + "md5": "aa526d343b0110d578353ece3f8520c5", + "name": "_py-xgboost-mutex", + "sha256": "be96b81519eb5cc3da624069dba5a45084d21c0527f6a0886d56e130feecf252", + "size": 8747, + "subdir": "linux-64", + "timestamp": 1530218242088, + "version": "2.0" + }, + "_pytorch_select-0.1-cpu_0.tar.bz2": { + "build": "cpu_0", + "build_number": 0, + "depends": [], + "md5": "ac7dfcfc0e676effd3217e2e1f58b212", + "name": "_pytorch_select", + "sha256": "58ce84225789504b45bd5be10554f06f50c643560c8c86d1e005df601cb6d485", + "size": 2207, + "subdir": "linux-64", + "timestamp": 1566845455257, + "track_features": "pytorch_cpuonly", + "version": "0.1" + }, + "_pytorch_select-0.2-gpu_0.tar.bz2": { + "build": "gpu_0", + "build_number": 0, + "depends": [], + "md5": "1456bc91498b1ade2b0c9fa3a6e19be5", + "name": "_pytorch_select", + "sha256": "c6bb56b058a306577f3056acaf688c231fb8bb1029e9780a7bcc0803b1477d52", + "size": 2205, + "subdir": "linux-64", + "timestamp": 1566845453862, + "version": "0.2" + }, + "_r-xgboost-mutex-2.0-cpu_0.tar.bz2": { + "build": "cpu_0", + "build_number": 0, + "depends": [], + "license": "Apache-2.0", + "md5": "1a526645c13f8c4ee4d2ae2c5137e826", + "name": "_r-xgboost-mutex", + "sha256": "9e60850813e2e6f1db5b74dd383aef5039ca3f40625bb70ac8c0f6318a12d4b2", + "size": 14789, + "subdir": "linux-64", + "timestamp": 1659549251616, + "version": "2.0" + }, + "_tflow_1100_select-0.0.1-gpu.tar.bz2": { + "build": "gpu", + "build_number": 0, + "depends": [], + "md5": "a633e92303405796f99de1e092e2f5a2", + "name": "_tflow_1100_select", + "sha256": "3333c5df0262f1cd187aa6fbf6016e34d65a7dbedc3ef873baec27733d765b9e", + "size": 2044, + "subdir": "linux-64", + "timestamp": 1534870922091, + "version": "0.0.1" + }, + "_tflow_1100_select-0.0.2-eigen.tar.bz2": { + "build": "eigen", + "build_number": 0, + "depends": [], + "md5": "522b20c5eae22868cf9e59a55549b423", + "name": "_tflow_1100_select", + "sha256": "3ae9cc80e2df4975ce2b9258de562a1c46991b06821c3ea0dc2273404067eef5", + "size": 2045, + "subdir": "linux-64", + "timestamp": 1534870923651, + "version": "0.0.2" + }, + "_tflow_1100_select-0.0.3-mkl.tar.bz2": { + "build": "mkl", + "build_number": 0, + "depends": [], + "md5": "7bc96b04b4fc443138bfba8c93c7be4a", + "name": "_tflow_1100_select", + "sha256": "1aa94406dc634219a72ff6fc90c7fa33bed5cc342e1b652772f963c7e4eb4807", + "size": 2037, + "subdir": "linux-64", + "timestamp": 1534870925081, + "version": "0.0.3" + }, + "_tflow_180_select-1.0-gpu.tar.bz2": { + "build": "gpu", + "build_number": 0, + "depends": [], + "md5": "91cff2b92e3d8d35bfb03f0cf77cd0cc", + "name": "_tflow_180_select", + "sha256": "f0cee90894843859463195fb970c074b4b6a38615a36d47016d4c7afff33da72", + "size": 2510, + "subdir": "linux-64", + "timestamp": 1527093815212, + "version": "1.0" + }, + "_tflow_180_select-2.0-mkl.tar.bz2": { + "build": "mkl", + "build_number": 0, + "depends": [], + "md5": "88bc830c7f45f0ce302f3331b04e15a4", + "name": "_tflow_180_select", + "sha256": "6be4e591ff64f80c3328811cda7fd6a6e2e0645a30e82de8eaf54bc770bf5d4b", + "size": 2495, + "subdir": "linux-64", + "timestamp": 1527093812314, + "version": "2.0" + }, + "_tflow_180_select-3.0-eigen.tar.bz2": { + "build": "eigen", + "build_number": 0, + "depends": [], + "md5": "5d16a93b9cf60e5281aa53cda6271c7d", + "name": "_tflow_180_select", + "sha256": "bcb354bd0961b94f9f4c77191a8954cd05496237a6f2584b6a7c11242b0a4f76", + "size": 2512, + "subdir": "linux-64", + "timestamp": 1527093815183, + "version": "3.0" + }, + "_tflow_190_select-0.0.1-gpu.tar.bz2": { + "build": "gpu", + "build_number": 0, + "depends": [], + "md5": "5f904ea568bb122c4a20c8f9760409af", + "name": "_tflow_190_select", + "sha256": "46790e0a9f99548f47ebdd05924b02f9f226371f6d021fda351d588fce0a3fd8", + "size": 2016, + "subdir": "linux-64", + "timestamp": 1532469780564, + "version": "0.0.1" + }, + "_tflow_190_select-0.0.2-eigen.tar.bz2": { + "build": "eigen", + "build_number": 0, + "depends": [], + "md5": "5664299a81fd5ac288c48ef53eb5df10", + "name": "_tflow_190_select", + "sha256": "ec4839b88fe5f605e1ca46f1eee2812d285a25d258d8b4a7fe4912d11a3ef21b", + "size": 2031, + "subdir": "linux-64", + "timestamp": 1532469783493, + "version": "0.0.2" + }, + "_tflow_190_select-0.0.3-mkl.tar.bz2": { + "build": "mkl", + "build_number": 0, + "depends": [], + "md5": "01a6d9a215fb56078f005d76095b5b38", + "name": "_tflow_190_select", + "sha256": "243ae2449a3ea9a13e503cabf5b5cac0ff564a456188b6e2786774d47529a310", + "size": 2020, + "subdir": "linux-64", + "timestamp": 1532469781990, + "version": "0.0.3" + }, + "_tflow_select-1.1.0-gpu.tar.bz2": { + "build": "gpu", + "build_number": 0, + "depends": [], + "md5": "070841e23f0f89f4d617407ea110763e", + "name": "_tflow_select", + "sha256": "d7a7e8c44a69eb69379d0e085475e04a8db4575ded8fcff6b97c6e9972f8c86c", + "size": 2052, + "subdir": "linux-64", + "timestamp": 1538592487387, + "version": "1.1.0" + }, + "_tflow_select-1.2.0-mkl.tar.bz2": { + "build": "mkl", + "build_number": 0, + "depends": [], + "md5": "9a315791374c8b01833373c051dd85a2", + "name": "_tflow_select", + "sha256": "c04dd1c25ac0c67f8247c3298d5466e30a4dd08476bf99db7f0ce4544e57ba8c", + "size": 2056, + "subdir": "linux-64", + "timestamp": 1538592488112, + "version": "1.2.0" + }, + "_tflow_select-1.3.0-eigen.tar.bz2": { + "build": "eigen", + "build_number": 0, + "depends": [], + "md5": "d284c9572da4bb944cf254ce647215d5", + "name": "_tflow_select", + "sha256": "3eac1b022b7974d4c3a01bd7d706efaaa9c51d2d12d59d763c1ff9dacbade96c", + "size": 2054, + "subdir": "linux-64", + "timestamp": 1538592490308, + "version": "1.3.0" + }, + "_tflow_select-2.1.0-gpu.tar.bz2": { + "build": "gpu", + "build_number": 0, + "depends": [], + "md5": "8bb6a6c12d996abb7e662db33e90d0af", + "name": "_tflow_select", + "sha256": "b48334d4455929c895d94344454a75e0b0910b50597bf4fc96dac9d93db7c29b", + "size": 2054, + "subdir": "linux-64", + "timestamp": 1538592489581, + "version": "2.1.0" + }, + "_tflow_select-2.2.0-eigen.tar.bz2": { + "build": "eigen", + "build_number": 0, + "depends": [], + "md5": "b67826c9a9bb6f81f8c9b97c0380d9cc", + "name": "_tflow_select", + "sha256": "e4d8c80156c5aa5140ae82e9d2d4fcf7e6632b3259e859a6f802f431871a8c66", + "size": 2057, + "subdir": "linux-64", + "timestamp": 1538592488840, + "version": "2.2.0" + }, + "_tflow_select-2.3.0-eigen.tar.bz2": { + "build": "eigen", + "build_number": 0, + "depends": [], + "md5": "42b4a7e7ec3ce8bee995ac9eb849b952", + "name": "_tflow_select", + "sha256": "186af0bbf0338604d749351f0531458e21cdf3fed7a7aa32718316f99ac06a44", + "size": 2182, + "subdir": "linux-64", + "timestamp": 1604315720983, + "version": "2.3.0" + }, + "_tflow_select-2.3.0-mkl.tar.bz2": { + "build": "mkl", + "build_number": 0, + "depends": [], + "md5": "5770354f88091e1944a2d1bd7257e4d0", + "name": "_tflow_select", + "sha256": "f51493d1f78786b6ccbc1f3d8aaad96a2ff13c95c097e64a059737d2f2cfa2ce", + "size": 2049, + "subdir": "linux-64", + "timestamp": 1538592486542, + "version": "2.3.0" + }, + "abseil-cpp-20200225.2-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e1cef10fc74caf455e0ca03491e49f01", + "name": "abseil-cpp", + "sha256": "f20d83330cb2ba897e70bd95eca8863bac571cdb967ed3966db1c13b78d17bb5", + "size": 945004, + "subdir": "linux-64", + "timestamp": 1607137388014, + "version": "20200225.2" + }, + "abseil-cpp-20200923.2-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6e6e49979bb0d6769eef329a38756900", + "name": "abseil-cpp", + "sha256": "d7efb15ba4496911211eceffd5fa97b1fa0611aa8d391defc08a5641c1777518", + "size": 1013509, + "subdir": "linux-64", + "timestamp": 1607091227580, + "version": "20200923.2" + }, + "abseil-cpp-20200923.3-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0d1277345d6545b5b19b04d7dabbe051", + "name": "abseil-cpp", + "sha256": "f7ad89fd0112259225e153325be5bb314c64e47dd90765a034f52f0bf59735bd", + "size": 1003375, + "subdir": "linux-64", + "timestamp": 1611167716798, + "version": "20200923.3" + }, + "abseil-cpp-20210324.2-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f1c4f336301201e74bfd43e9c616aa4a", + "name": "abseil-cpp", + "sha256": "db68491cc6599f0ac6ca24fcc3951d09086431875a8fb2c1610d0ddef56af02c", + "size": 1062941, + "subdir": "linux-64", + "timestamp": 1622571748956, + "version": "20210324.2" + }, + "abseil-cpp-20211102.0-hd4dd3e8_0.tar.bz2": { + "build": "hd4dd3e8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=8.4.0", + "libstdcxx-ng >=8.4.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c3707fcd2efa582afc5c7e1986c6ce48", + "name": "abseil-cpp", + "sha256": "8762f481244fb151a200f01dd70e69c77171a3ee0f7f4c130e8e95b6a1626a68", + "size": 1135866, + "subdir": "linux-64", + "timestamp": 1652382888447, + "version": "20211102.0" + }, + "absl-py-0.1.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7fcf5099320454a53bbfcdb5d7cf08e9", + "name": "absl-py", + "sha256": "5a1bbc3d862f1056f0d613a472f8cc7e2688d6300b5818f7e49f79cd6d92107f", + "size": 128948, + "subdir": "linux-64", + "timestamp": 1517610163929, + "version": "0.1.10" + }, + "absl-py-0.1.10-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0c5ff97bf880e006f20670ad4d5e7ca7", + "name": "absl-py", + "sha256": "7cc5e6f72340c825dc64459b04cc3b1ec7fab95406875b01991272990c4b5ce2", + "size": 132469, + "subdir": "linux-64", + "timestamp": 1517610182895, + "version": "0.1.10" + }, + "absl-py-0.1.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e2c6e3e4d659eb39137dbd086cab5e87", + "name": "absl-py", + "sha256": "8ba90053be1d7aa15d4729a29281685b5887605bddefcadd1ba8c2f9fa179bc3", + "size": 132150, + "subdir": "linux-64", + "timestamp": 1517610182992, + "version": "0.1.10" + }, + "absl-py-0.1.13-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9bd8b9424ccac9a6623840de126d6c62", + "name": "absl-py", + "sha256": "2d03bafee58960eb0b79aa64cbf1e68ebd37b7ea62f963e0b4d8262a818cbe41", + "size": 129908, + "subdir": "linux-64", + "timestamp": 1523902724946, + "version": "0.1.13" + }, + "absl-py-0.1.13-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3426283f250482750da728c7de1efa8d", + "name": "absl-py", + "sha256": "74534734533940af316570b57e3f8248cfece6edb33057d911a90e460cc102ec", + "size": 133413, + "subdir": "linux-64", + "timestamp": 1523902774758, + "version": "0.1.13" + }, + "absl-py-0.1.13-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5bf6d4242b81dedf353284643b9472af", + "name": "absl-py", + "sha256": "cec764b8a62bfcddc3458cb7f24955fedd5573ab61cdbc4bd535d9e0f791b981", + "size": 132928, + "subdir": "linux-64", + "timestamp": 1523902774784, + "version": "0.1.13" + }, + "absl-py-0.10.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "74a27d76e850e9cd246c71f1836d60d7", + "name": "absl-py", + "sha256": "6b5362e8e3338b35574a31964a12a48bda4e8f3703cf8760c85cb6f8714811e4", + "size": 172496, + "subdir": "linux-64", + "timestamp": 1600297543935, + "version": "0.10.0" + }, + "absl-py-0.10.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8b42a3a565fa366ac0057eb24afaa592", + "name": "absl-py", + "sha256": "2325d0d914119c24a5617faa344665d525d8c4642fcfc149e48d4f78d6338494", + "size": 172903, + "subdir": "linux-64", + "timestamp": 1600297556287, + "version": "0.10.0" + }, + "absl-py-0.10.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7976fdded7dedc92b64b3d085d14bca0", + "name": "absl-py", + "sha256": "36e780d858d6bd41a3342645500ed316da8f2314cf4b3a25821ee0fc9097a366", + "size": 173669, + "subdir": "linux-64", + "timestamp": 1600297549477, + "version": "0.10.0" + }, + "absl-py-0.11.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9b9659e9fbf5332924f4e36eebfba903", + "name": "absl-py", + "sha256": "a745004198d19e2cc68e235e77bbe9b99e6638c9287dafddf52830077bf8786d", + "size": 173101, + "subdir": "linux-64", + "timestamp": 1603893156544, + "version": "0.11.0" + }, + "absl-py-0.11.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3c6e7f4c38a6bad38c2d2eca59229039", + "name": "absl-py", + "sha256": "26d9368b0ee142a7ebf132dc04cc856981477632152513cb740daa363de0a2cd", + "size": 173401, + "subdir": "linux-64", + "timestamp": 1603893166339, + "version": "0.11.0" + }, + "absl-py-0.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a71c0776af521a394336009b430e849a", + "name": "absl-py", + "sha256": "114f6ebfd4db26b3f08934d9fb82021e62b17207ea1f5fc80cbe8f20860b6426", + "size": 174155, + "subdir": "linux-64", + "timestamp": 1603893134597, + "version": "0.11.0" + }, + "absl-py-0.12.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8692889e78652acfc6003aaf70219d15", + "name": "absl-py", + "sha256": "b4ea910470e2af4f92259eb1b2c7c2eca3e535387e4877522488832986e705ac", + "size": 178141, + "subdir": "linux-64", + "timestamp": 1642495509143, + "version": "0.12.0" + }, + "absl-py-0.12.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8b8d9de7978bde3379c40aba8af50d6b", + "name": "absl-py", + "sha256": "806fd01f9b842e0fbf0897a17efff4835ff6ea434f3bc820aad22d2503a3b063", + "size": 175412, + "subdir": "linux-64", + "timestamp": 1615411231364, + "version": "0.12.0" + }, + "absl-py-0.12.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3c2934d4a02c41b003f2250c452bf5a8", + "name": "absl-py", + "sha256": "c2920d8850b11fc78220fbf81afdc5f13349140b88e463fc13e0ef32b361e431", + "size": 175679, + "subdir": "linux-64", + "timestamp": 1615411238537, + "version": "0.12.0" + }, + "absl-py-0.12.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d237fc088ab11aa6ed716f72bdbdbb27", + "name": "absl-py", + "sha256": "0bc5ee2a3f6a85bf1b781ab7df948f58e215d0fa2f893f12617068b7dec3f3bf", + "size": 176626, + "subdir": "linux-64", + "timestamp": 1615411237821, + "version": "0.12.0" + }, + "absl-py-0.12.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e835ac9e82110d4aec00110bb8040fd8", + "name": "absl-py", + "sha256": "77f19c3c05daf8b52904fcde8972dd2d113b9b6b1348a830e0b4552c0818ce1c", + "size": 176858, + "subdir": "linux-64", + "timestamp": 1615410702925, + "version": "0.12.0" + }, + "absl-py-0.13.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "49b678e5070cbd822797b8902f91df8a", + "name": "absl-py", + "sha256": "177708c61353224735f0aa24b81d96138075246001f03c24e97bac2ae973cf41", + "size": 177874, + "subdir": "linux-64", + "timestamp": 1623867088033, + "version": "0.13.0" + }, + "absl-py-0.13.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cc38c456b37fb1179b63e7163f6dc3bc", + "name": "absl-py", + "sha256": "067d44f7c23e42ac38e997761f5924826dae9d726dd3e1bed8cd628f85a3425b", + "size": 178192, + "subdir": "linux-64", + "timestamp": 1623861431925, + "version": "0.13.0" + }, + "absl-py-0.13.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "692e53e531f4f720318c820f785077d3", + "name": "absl-py", + "sha256": "8ebe73a6a556d61ea97f96f17bd199557ccdc3c4caa04f7de02bea80529d9c07", + "size": 178579, + "subdir": "linux-64", + "timestamp": 1623867255364, + "version": "0.13.0" + }, + "absl-py-0.13.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1ff5d334b01a6d64cd956cff11ab4e36", + "name": "absl-py", + "sha256": "465c702073b48747bbe85d948ac13f3856310ef79956e88361f812ead80b4e58", + "size": 179236, + "subdir": "linux-64", + "timestamp": 1623867269514, + "version": "0.13.0" + }, + "absl-py-0.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "04ba30a9eb9fcf57ef8c7a2651a0c704", + "name": "absl-py", + "sha256": "3bd57823f72b9f1f34cdf33ef35dce9838288663cdca11d3dbdc7cbc3cae4128", + "size": 135001, + "subdir": "linux-64", + "timestamp": 1524512668988, + "version": "0.2.0" + }, + "absl-py-0.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "310c163e9ab2c68d36065878ea407c1f", + "name": "absl-py", + "sha256": "278a62fd426158ecb72f36d16717d7756f14b69d55560572432dff20f565b106", + "size": 138516, + "subdir": "linux-64", + "timestamp": 1524512677080, + "version": "0.2.0" + }, + "absl-py-0.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "75b27759c0534b1ed572dd1242d1b9ff", + "name": "absl-py", + "sha256": "45d6a962f1b8696332764259df633e5c2df7b79d7c152b82461d1092656e54c5", + "size": 138051, + "subdir": "linux-64", + "timestamp": 1524512676165, + "version": "0.2.0" + }, + "absl-py-0.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c8201aba042240788bfdeac6e4022d0e", + "name": "absl-py", + "sha256": "8edfec2a6f95c923e6c33e11aebbb4572660aa7a3e04c62ec9ffa4fbb8087c2e", + "size": 135386, + "subdir": "linux-64", + "timestamp": 1526931332258, + "version": "0.2.1" + }, + "absl-py-0.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8c747a303e46b65c2cb031e3312f8d6e", + "name": "absl-py", + "sha256": "71c04cfa2b178e41f71e227b0698cb847334b3a04058c41406d6e08c0b2b5150", + "size": 138958, + "subdir": "linux-64", + "timestamp": 1526931343118, + "version": "0.2.1" + }, + "absl-py-0.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f634a125a1674829f254eeb318f873a8", + "name": "absl-py", + "sha256": "77763b1f3e50ffafa0c0a87119c497eebb8f994d60db24a1fba9e1ae431384ac", + "size": 138633, + "subdir": "linux-64", + "timestamp": 1526931309606, + "version": "0.2.1" + }, + "absl-py-0.2.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "efa121b8aadf955729d93bfca6c18a92", + "name": "absl-py", + "sha256": "e29cacfb6aca56266b7e6954e16b199fe71506ad9ef307c96adf292fa3b94075", + "size": 135436, + "subdir": "linux-64", + "timestamp": 1527631426805, + "version": "0.2.2" + }, + "absl-py-0.2.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "38f344bc7454ac5846da2f7fff947d35", + "name": "absl-py", + "sha256": "ce595981e7c2f930b4568781369a4a8b9f934a5ce4981149052152ed59c3fd11", + "size": 139017, + "subdir": "linux-64", + "timestamp": 1527631612527, + "version": "0.2.2" + }, + "absl-py-0.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "af5651b46835c5088da92dbd243d7891", + "name": "absl-py", + "sha256": "704dfb44c44979c5b5e550694570c172abe1d5935963e07986a799b04f2e5b17", + "size": 138607, + "subdir": "linux-64", + "timestamp": 1527631590997, + "version": "0.2.2" + }, + "absl-py-0.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3435ae249acd7326a3f381d4940d06b8", + "name": "absl-py", + "sha256": "a235a4fcbba6ddb7bba6b6c1f6a45154997535560089cadffac5c2bb9ffbb347", + "size": 138729, + "subdir": "linux-64", + "timestamp": 1530735418283, + "version": "0.2.2" + }, + "absl-py-0.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d271b25afbbb8072d393d33d523f5392", + "name": "absl-py", + "sha256": "7b029d42acdd6c79d7090f4108c07b88bfc303bac535d10a19ebc0ba6ee00d0a", + "size": 136890, + "subdir": "linux-64", + "timestamp": 1532554034071, + "version": "0.3.0" + }, + "absl-py-0.3.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b18681221a8e7392b9d1f33858604800", + "name": "absl-py", + "sha256": "e787e77c012f0419c181e9fac2e00c77aa1b44c25b850ecd58fd0fea39dddf9f", + "size": 136879, + "subdir": "linux-64", + "timestamp": 1534351910968, + "version": "0.3.0" + }, + "absl-py-0.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "62c9f30c291cc7508d35bec5a1ce9627", + "name": "absl-py", + "sha256": "0bd090b291e1d626232b882589f1c219fe5ac2bf5a5873e35e1e62329c7a3d56", + "size": 140477, + "subdir": "linux-64", + "timestamp": 1532554055802, + "version": "0.3.0" + }, + "absl-py-0.3.0-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ff0aa878fd2c143b1e4cbae10b10da26", + "name": "absl-py", + "sha256": "fcdba1e715af3b660db2946117f958abbd639dcaebae8e92f51c463c40538e84", + "size": 140324, + "subdir": "linux-64", + "timestamp": 1534351934157, + "version": "0.3.0" + }, + "absl-py-0.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9d10276e592fa1c8f3658926e26dc275", + "name": "absl-py", + "sha256": "4693c8070187bf6ea3b8d2764fc509660d754ff18036d870bc196fdfc0a77992", + "size": 139967, + "subdir": "linux-64", + "timestamp": 1532554003878, + "version": "0.3.0" + }, + "absl-py-0.3.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3216b8cb525dd5fb81e307863f1ef44c", + "name": "absl-py", + "sha256": "8e3caf25b92302798b130829d9ae5ed0ebe57af230f593fa0d51461b2814b7ac", + "size": 139997, + "subdir": "linux-64", + "timestamp": 1534351958094, + "version": "0.3.0" + }, + "absl-py-0.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "618a44eef4a076944988d05635dc751d", + "name": "absl-py", + "sha256": "46978a59ab7314ffb23d0657d6ea041c75f980ad9c09fb97ab733481e2d37114", + "size": 140274, + "subdir": "linux-64", + "timestamp": 1532553968138, + "version": "0.3.0" + }, + "absl-py-0.3.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1ef01f37d9bf722a9e6432b22152ff4d", + "name": "absl-py", + "sha256": "f1732ba78a73a941729fc1425fb794966ac76c1210b81df711d960b7c8521f0d", + "size": 140261, + "subdir": "linux-64", + "timestamp": 1534351888574, + "version": "0.3.0" + }, + "absl-py-0.4.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "008b1021474c5dfc19dc23d677a89dcb", + "name": "absl-py", + "sha256": "74041ffc6deacd11a0bf5461fa16e870390917bffb91a39f0593b6c798a5dab6", + "size": 143362, + "subdir": "linux-64", + "timestamp": 1534793387737, + "version": "0.4.0" + }, + "absl-py-0.4.0-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7e21ce31df59ba2ebfcebc091a7624b0", + "name": "absl-py", + "sha256": "ce14a9b749af843c192da440d9a1da0487982880e5b420c983911b620680be09", + "size": 147189, + "subdir": "linux-64", + "timestamp": 1534793449693, + "version": "0.4.0" + }, + "absl-py-0.4.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "54892f61fad4a46a8606b9aeecd54b3e", + "name": "absl-py", + "sha256": "83a670fbe8ae2601b45e43d1350a40a431f1a6b3730ea3b2f95499e612ea30c4", + "size": 146749, + "subdir": "linux-64", + "timestamp": 1534793364072, + "version": "0.4.0" + }, + "absl-py-0.4.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "290ec99ee90c970d3c0a96424a4e2b70", + "name": "absl-py", + "sha256": "ca97367b726ed6bff806007038e5a980190ea4e6dafc99d8299fc688c6519a12", + "size": 146982, + "subdir": "linux-64", + "timestamp": 1534793470303, + "version": "0.4.0" + }, + "absl-py-0.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5bff646ab96cc07ee184249b2be868bd", + "name": "absl-py", + "sha256": "cd9bcc752c92b9d8982ad4a766e636afc7753cae8e682339b32cfe97a1a0b3ea", + "size": 144115, + "subdir": "linux-64", + "timestamp": 1536102596908, + "version": "0.4.1" + }, + "absl-py-0.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9ef14dbab202ac090d734ab38301e439", + "name": "absl-py", + "sha256": "72d552b36f86edda313c69385018990a907766b2c81b23d914bb45b23e17d775", + "size": 147703, + "subdir": "linux-64", + "timestamp": 1536102605750, + "version": "0.4.1" + }, + "absl-py-0.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d168fa57836973a25078a1f99d174277", + "name": "absl-py", + "sha256": "bd9a96de40c5a2030a7ca63b33cae52af8d94f5bd2147a58c63eabed800264e1", + "size": 147397, + "subdir": "linux-64", + "timestamp": 1536102555868, + "version": "0.4.1" + }, + "absl-py-0.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "250bdf10ecf8b3c6b6c6fb0f87fee68a", + "name": "absl-py", + "sha256": "19a094e65cad9d4e3afd1d9baa29320d337ca2a88b674a668561dfc5a57ec3ac", + "size": 147538, + "subdir": "linux-64", + "timestamp": 1536102643902, + "version": "0.4.1" + }, + "absl-py-0.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2be7c7ba9f85a9b39c72abf166a2a13e", + "name": "absl-py", + "sha256": "b667998b38a2ef4c18ad262ab93ee5d3ab296787e2e113b650bbd4a67d333aed", + "size": 145863, + "subdir": "linux-64", + "timestamp": 1538176252869, + "version": "0.5.0" + }, + "absl-py-0.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "74b9fc076a4aa434e8f3bb935574724e", + "name": "absl-py", + "sha256": "f0b58422e6aa5fc6aff908322fdc29f6b9b5f7aab8023ebfd0ee05381de8648b", + "size": 149255, + "subdir": "linux-64", + "timestamp": 1538176277723, + "version": "0.5.0" + }, + "absl-py-0.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c96c2782af5f03d852219fe5616d6143", + "name": "absl-py", + "sha256": "05709fbd7806379c18772173ae48a5eafa780c0a66edca65ef33196ffadc5e10", + "size": 149337, + "subdir": "linux-64", + "timestamp": 1538176263609, + "version": "0.5.0" + }, + "absl-py-0.6.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8056d18839e19923e84ed4502cbd2883", + "name": "absl-py", + "sha256": "cd04bde655cc42a30021bdbf86f08c477ee0e508679d12916794a27c893dfbd1", + "size": 151808, + "subdir": "linux-64", + "timestamp": 1540955260491, + "version": "0.6.1" + }, + "absl-py-0.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ea5ff2320d64d417b536437a2347d99b", + "name": "absl-py", + "sha256": "f5ee936043001ce5ad3958e2f89947944d824bb1e0b796e7c0b31d70958aed48", + "size": 155259, + "subdir": "linux-64", + "timestamp": 1540955331425, + "version": "0.6.1" + }, + "absl-py-0.6.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f940d7fc9109a8f6fa3841ff86b7c2e6", + "name": "absl-py", + "sha256": "2b03b2f49db2f1ef3deac16c4085222ecc4951dae6afd4dd09524e1e0e61be79", + "size": 155416, + "subdir": "linux-64", + "timestamp": 1540955317795, + "version": "0.6.1" + }, + "absl-py-0.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "246c25a7bee759700ea1733090965789", + "name": "absl-py", + "sha256": "719d00789d8e1eeed65d59034c19af2b736c8a4cb5934731ba0022a507f8688d", + "size": 156584, + "subdir": "linux-64", + "timestamp": 1547744445261, + "version": "0.7.0" + }, + "absl-py-0.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3bbb924c61993c2b67ba14c18ce65861", + "name": "absl-py", + "sha256": "4fccb3e547f0d507b69e48654d9d0e93df28292a515fed4d3cf1a2867719c102", + "size": 160162, + "subdir": "linux-64", + "timestamp": 1547744495640, + "version": "0.7.0" + }, + "absl-py-0.7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a70b124505c8a5b40988f49f55ce11b6", + "name": "absl-py", + "sha256": "42d92884dfbf473229063aead90b686e8fa29a804b23af154c73a99af82730c1", + "size": 160482, + "subdir": "linux-64", + "timestamp": 1547744492366, + "version": "0.7.0" + }, + "absl-py-0.7.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3e8ca8606e31b354ef23263fb57d4d31", + "name": "absl-py", + "sha256": "8267a04f59427d5a4632f3f29acbce9613d76fc650cd4afa62a3c5620a7367d4", + "size": 157302, + "subdir": "linux-64", + "timestamp": 1556061050792, + "version": "0.7.1" + }, + "absl-py-0.7.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "69d823502f557d3cab4ce2a85027992a", + "name": "absl-py", + "sha256": "b87c88fa3863b52d3e105dbcf30ab43e48aa5f392bfb243a8f3206f26a97ad33", + "size": 161042, + "subdir": "linux-64", + "timestamp": 1556061208650, + "version": "0.7.1" + }, + "absl-py-0.7.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "21715866ed4a2be84892e53955c94fd0", + "name": "absl-py", + "sha256": "f56f127096ff27b0eff402e0e95bf9e4ab71f18080330cbfe6567e66e309abe3", + "size": 161216, + "subdir": "linux-64", + "timestamp": 1556061174938, + "version": "0.7.1" + }, + "absl-py-0.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "465c6eb30ce25468b8b2588036fded9a", + "name": "absl-py", + "sha256": "c65dec456bca38b91b9663ba1d25af81ee2805ae43f71945467e658f98b709f1", + "size": 160672, + "subdir": "linux-64", + "timestamp": 1569267547648, + "version": "0.8.0" + }, + "absl-py-0.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d56b536010b57688d95dc632c9c2bc3f", + "name": "absl-py", + "sha256": "e2a222c0982ddc0911e6f83d70496d6984c791e201db1127e9a1c189e4927a87", + "size": 164497, + "subdir": "linux-64", + "timestamp": 1569267548539, + "version": "0.8.0" + }, + "absl-py-0.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "eb2ba460ba18d33c4f639d1eba8b3a90", + "name": "absl-py", + "sha256": "8840616070e21780350573cd6678ab6e41efc61f31473e9eb99730b7c961e211", + "size": 164658, + "subdir": "linux-64", + "timestamp": 1569267546992, + "version": "0.8.0" + }, + "absl-py-0.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "09fe899bf9703db96f8c371ec86b3c22", + "name": "absl-py", + "sha256": "f2e32493acfb5b07fec79f6933dc5f2369424a06fa2d312e62d7b7aa166c07b8", + "size": 161419, + "subdir": "linux-64", + "timestamp": 1573224863087, + "version": "0.8.1" + }, + "absl-py-0.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4385b575246ba708571c516501697df8", + "name": "absl-py", + "sha256": "6f2b8706900df626c23542d14cfbc362c3cea9ef11d99e3e4031937f980400f0", + "size": 165100, + "subdir": "linux-64", + "timestamp": 1573224871696, + "version": "0.8.1" + }, + "absl-py-0.8.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "41922072174ecc5289bd2ce40defd7bb", + "name": "absl-py", + "sha256": "15a54536c3b03b139b2e27f31b8959936b880d00754ce054a826c86fd5e61f4e", + "size": 165194, + "subdir": "linux-64", + "timestamp": 1573224871352, + "version": "0.8.1" + }, + "absl-py-0.8.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2c6fd5af2b9a806bebca83cdc9d9799e", + "name": "absl-py", + "sha256": "18051bf96879e7ec95077ccbb5f975e24391f90cc69ba4df79be994e37720873", + "size": 165995, + "subdir": "linux-64", + "timestamp": 1573224879094, + "version": "0.8.1" + }, + "absl-py-0.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b32b2a29eb941eb4419d6ba655c2134e", + "name": "absl-py", + "sha256": "760e53f16f91d3b870d39e1b67e65a496ec47d3322e63491b8aa9de12e819d8b", + "size": 169194, + "subdir": "linux-64", + "timestamp": 1581610019179, + "version": "0.9.0" + }, + "absl-py-0.9.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "135f9f532df913ed1fdaf60b8239f38c", + "name": "absl-py", + "sha256": "a3ffba7be5560fcdf3bdd59379881815bd0921c01326022695fb1fea30d6b3bf", + "size": 169458, + "subdir": "linux-64", + "timestamp": 1581610014431, + "version": "0.9.0" + }, + "absl-py-0.9.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "232143022ed76ece1b156d43e0fa115e", + "name": "absl-py", + "sha256": "1cd75a92c86331eb61264ac05cc41ec4d22d3db666dc179572dabcfcccee4fd1", + "size": 169686, + "subdir": "linux-64", + "timestamp": 1581610028581, + "version": "0.9.0" + }, + "absl-py-1.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f7192a45deef49972d84fb41415cfadd", + "name": "absl-py", + "sha256": "e79d5782c62536ecbb8f5805c1e6b48f268b5a7864d44b073536048b68505aeb", + "size": 173375, + "subdir": "linux-64", + "timestamp": 1666362970875, + "version": "1.3.0" + }, + "absl-py-1.3.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "712c9280b53ebf25a68e2f1247e5d53c", + "name": "absl-py", + "sha256": "fb1f13a408ec7f1509d89a2b4bebe4ccc14f04223fa80e5942d57b79554e9685", + "size": 227343, + "subdir": "linux-64", + "timestamp": 1676838943500, + "version": "1.3.0" + }, + "absl-py-1.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b5c2841b9532cdf739d5becba5905920", + "name": "absl-py", + "sha256": "29fd457c99ab5236c1ce91687d4217524147733b0cf26b48f006adb333aa0d10", + "size": 170746, + "subdir": "linux-64", + "timestamp": 1666362997020, + "version": "1.3.0" + }, + "absl-py-1.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "57925d70aa192057f45a5db446e71148", + "name": "absl-py", + "sha256": "17db264bbef34a94ea694f3222fe1b167c5c3070c5f1f3ab9e09e64bd36d349f", + "size": 171854, + "subdir": "linux-64", + "timestamp": 1666363048677, + "version": "1.3.0" + }, + "absl-py-1.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b0e30df78742b30c9a7108b9a1721921", + "name": "absl-py", + "sha256": "032e95b10e5a73013bde920b0e85ef67bad10e7095909c55c0d0088e5a01f1a6", + "size": 171741, + "subdir": "linux-64", + "timestamp": 1666363023028, + "version": "1.3.0" + }, + "adtk-0.6.2-py310h2f386ee_0.tar.bz2": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=17.0", + "pandas >=0.23", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.20", + "statsmodels >=0.9", + "tabulate >=0.8" + ], + "license": "MPL-2.0", + "license_family": "MOZILLA", + "md5": "32fbaab5e76512e2f4a975e9f5fac13a", + "name": "adtk", + "sha256": "a81fdac915766af24b8e3d4991048dbcc9f6f112e80215e8087b6c841549176a", + "size": 92494, + "subdir": "linux-64", + "timestamp": 1677843572621, + "version": "0.6.2" + }, + "adtk-0.6.2-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=17.0", + "pandas >=0.23", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.20", + "statsmodels >=0.9", + "tabulate >=0.8" + ], + "license": "MPL-2.0", + "license_family": "MOZILLA", + "md5": "dfc00c827f45c206b0d376e848dd43ff", + "name": "adtk", + "sha256": "e8211cb960c7ec9931bd1162f95f0dea2172c625e061796e194610dbd70e8d8d", + "size": 91364, + "subdir": "linux-64", + "timestamp": 1677843523504, + "version": "0.6.2" + }, + "adtk-0.6.2-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=17.0", + "pandas >=0.23", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.20", + "statsmodels >=0.9", + "tabulate >=0.8" + ], + "license": "MPL-2.0", + "license_family": "MOZILLA", + "md5": "d23e4f2c7bb66c9b9dc11e41219f2c3f", + "name": "adtk", + "sha256": "0b52b7849967fc39f934d08a1c9820475cb27bc28f699ffd4c97e8f451860150", + "size": 91351, + "subdir": "linux-64", + "timestamp": 1677843620649, + "version": "0.6.2" + }, + "aenum-2.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5d9302414e2cd4a7f910f1729af87b7e", + "name": "aenum", + "sha256": "4e70b7addf3c74bfcf739edc179c88efa304a6f15c7f1b228e800178247d78e4", + "size": 129727, + "subdir": "linux-64", + "timestamp": 1521779698394, + "version": "2.1.0" + }, + "aenum-2.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "710ce339ab819ce0a3a116ed74e4b70b", + "name": "aenum", + "sha256": "c59cbc64f5ddc305dcc89ce4070241e61bd4fe62003c204503bde8613296370f", + "size": 143801, + "subdir": "linux-64", + "timestamp": 1521779718693, + "version": "2.1.0" + }, + "aenum-2.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6f951f22968a56af513e3e4e95d7bd0f", + "name": "aenum", + "sha256": "62c3b603ac202b520b222d5957b4312bf4ecf14d176d261c89e654a38016c784", + "size": 143397, + "subdir": "linux-64", + "timestamp": 1521779720175, + "version": "2.1.0" + }, + "aenum-2.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "43f3471c3125b28e8154f15283605db9", + "name": "aenum", + "sha256": "a53acc773081cffbfb9dd176d3b50c3bbe1ba1ffd2df06446c9f065df5acb5f7", + "size": 134006, + "subdir": "linux-64", + "timestamp": 1526942954855, + "version": "2.1.2" + }, + "aenum-2.1.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "78e0de0d7222b03d72519cd70a55e67c", + "name": "aenum", + "sha256": "b60832743bdc80af2e13a57b97b6963bb1bb9b764e03b64b4c46ce04c35faa05", + "size": 149257, + "subdir": "linux-64", + "timestamp": 1526942971003, + "version": "2.1.2" + }, + "aenum-2.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d889b26755e41ada717133017804ab2c", + "name": "aenum", + "sha256": "84530fc8cc4ed65e7029a531974f907dc03de7136b21de3948b0dd1950a7b4b0", + "size": 148853, + "subdir": "linux-64", + "timestamp": 1526942974950, + "version": "2.1.2" + }, + "aenum-2.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b463fefcdbe72567f2ac88572a8f44de", + "name": "aenum", + "sha256": "b4eb2c6b50d40bd0dcf7ea6454f7dc5dbe3b35e0c11a8962c681ada65489b2eb", + "size": 147150, + "subdir": "linux-64", + "timestamp": 1530735440335, + "version": "2.1.2" + }, + "aenum-2.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dd114a8676e07f0f59caeebbd0e98e36", + "name": "aenum", + "sha256": "7ebdd953acea315ac3bd200ceb8ec10ed07ff7269136f2c4226adcb5430cad28", + "size": 143032, + "subdir": "linux-64", + "timestamp": 1564763496963, + "version": "2.2.1" + }, + "aenum-2.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "76f1f44612f9f9f4c11d20bd006a3b67", + "name": "aenum", + "sha256": "4dacd8bcb31feccf6dae7e16f6914d5f47fd9be7df3a8ae9ab76af6ad2f7302f", + "size": 159407, + "subdir": "linux-64", + "timestamp": 1564763150156, + "version": "2.2.1" + }, + "aenum-2.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a1f064d541469c98e1a97f3a165fcfb0", + "name": "aenum", + "sha256": "5bdc17fa9f7fe73bc04dd2e537462037be2320823d933cf2b06edc399356a088", + "size": 157478, + "subdir": "linux-64", + "timestamp": 1564763404229, + "version": "2.2.1" + }, + "aenum-2.2.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "83b82f95bb32883bef9159492dc8ac3a", + "name": "aenum", + "sha256": "1ab9596d0464cd40028915949d384c2905cb5009ea2da99b13ccd5364bd58a50", + "size": 157501, + "subdir": "linux-64", + "timestamp": 1572437488025, + "version": "2.2.1" + }, + "aenum-2.2.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1ccc1369de5e25507e9ce50d92c774ca", + "name": "aenum", + "sha256": "384f4ac149eb58d0aa4e9edc4dc6738959513d18e8ccbe36f4362d8d6ae2c772", + "size": 164975, + "subdir": "linux-64", + "timestamp": 1600297579287, + "version": "2.2.4" + }, + "aenum-2.2.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b7468648a792a1f557da5c35292ffd74", + "name": "aenum", + "sha256": "45e79ece6f889ddc08b040a47e80bd327056ff17e4bf21bb7ae85b87d400d104", + "size": 162840, + "subdir": "linux-64", + "timestamp": 1600297580607, + "version": "2.2.4" + }, + "aenum-2.2.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "750aee8a290070c91918787eae0e322c", + "name": "aenum", + "sha256": "b010d6987f7df5732899fffd2d7a6a0711c79371e1e5e352c3cb4e1a88f1cd8b", + "size": 163641, + "subdir": "linux-64", + "timestamp": 1600297569228, + "version": "2.2.4" + }, + "aenum-2.2.6-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ad6f3afa6313a555f92fd9b4a85a98df", + "name": "aenum", + "sha256": "6c96248b938a197e27e5a159c0a8c86d074233612523de8a0678cb943b32a38a", + "size": 177038, + "subdir": "linux-64", + "timestamp": 1607533542514, + "version": "2.2.6" + }, + "aenum-2.2.6-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "55422dc2a80cd58442d7126371b65a92", + "name": "aenum", + "sha256": "c7c57ffd6169f75806724ce881e06ba7ab276a6cb06c1a7fb8e0b932db883532", + "size": 173913, + "subdir": "linux-64", + "timestamp": 1607533555479, + "version": "2.2.6" + }, + "aenum-2.2.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "13419cfee0abd22509475cbbccaba958", + "name": "aenum", + "sha256": "e6f4b47c459151580afd1f52c3b1aa8115cb36f2605b5903a7b372ba771fd8d3", + "size": 172226, + "subdir": "linux-64", + "timestamp": 1607533554216, + "version": "2.2.6" + }, + "aenum-2.2.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bfaebfc216029ff42325eb150eb99477", + "name": "aenum", + "sha256": "b0134d63ede649453f2ae19b9430bab0d01dec91f3a88397f1efa918393de80a", + "size": 173285, + "subdir": "linux-64", + "timestamp": 1607533564797, + "version": "2.2.6" + }, + "aenum-3.0.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a20d9f553cfe1fc700ea400d82183f1b", + "name": "aenum", + "sha256": "fc35892ee5bacdf27225a977a67e4146eb4d7b2228908f050e470daba8a56fca", + "size": 185875, + "subdir": "linux-64", + "timestamp": 1611690173117, + "version": "3.0.0" + }, + "aenum-3.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8541e3473e78deebb8540e684090cc15", + "name": "aenum", + "sha256": "86a0b3b429f175474ad3c677f61cfb86d5ab80dc8d16cb8cb609ca44b9dd0221", + "size": 184478, + "subdir": "linux-64", + "timestamp": 1611690179147, + "version": "3.0.0" + }, + "aenum-3.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ac1775a49bf023e0d98019b14f162012", + "name": "aenum", + "sha256": "f43b4f46ad50d074376536a33de01bd6b2e38961508e09b96e4d332b739aeced", + "size": 184630, + "subdir": "linux-64", + "timestamp": 1611690179125, + "version": "3.0.0" + }, + "aenum-3.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d2bf568a5b3dc8f8fffd5f2f0fc7b4df", + "name": "aenum", + "sha256": "15d55498efc1ecb9b8f6e7b5cd923fd3fa7cdd85cb571184b7e86803fd7d1b9e", + "size": 185593, + "subdir": "linux-64", + "timestamp": 1611689780619, + "version": "3.0.0" + }, + "aenum-3.1.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5999ebe134370f5b28ee19e7498c1a83", + "name": "aenum", + "sha256": "32ba0cfb26ed0d7c2d8272e15fe40d401ada6ed8fa182ebdb067ab0d55a043c2", + "size": 193581, + "subdir": "linux-64", + "timestamp": 1622112375027, + "version": "3.1.0" + }, + "aenum-3.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bc97bf22b1738b9e0764ed18b894818a", + "name": "aenum", + "sha256": "b93e829c4ae5ef131c649558d6ebb21b4ffa1ef5d0b9b4d11f0402ec05effed2", + "size": 188398, + "subdir": "linux-64", + "timestamp": 1622112366442, + "version": "3.1.0" + }, + "aenum-3.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "68293155da58684dfb46c351f696a2f3", + "name": "aenum", + "sha256": "95c08d245d1ac21547317151845458732df5748b87efca67d96035035743975b", + "size": 189598, + "subdir": "linux-64", + "timestamp": 1622111602646, + "version": "3.1.0" + }, + "aenum-3.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e920370e16f4ba1553e1a22aafee5113", + "name": "aenum", + "sha256": "64bc3f1d1ca3bcfac350ccdb89e6f11062cd6c181c249a79ce3af88c09298bd6", + "size": 190863, + "subdir": "linux-64", + "timestamp": 1622107393321, + "version": "3.1.0" + }, + "aenum-3.1.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c7ec35bd735dca948bb88f7f287d95f7", + "name": "aenum", + "sha256": "f45ef86b9adcc8181d4c8335c99f5f5e3e208791e33627d0e17924771dd31bce", + "size": 201747, + "subdir": "linux-64", + "timestamp": 1640788069315, + "version": "3.1.5" + }, + "aenum-3.1.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "538224161f556aedb72a49552fcafc68", + "name": "aenum", + "sha256": "d9ded28fc3565c69b307d528d5278cb9a025005ba1a6d156c3d404d8345e13d8", + "size": 270975, + "subdir": "linux-64", + "timestamp": 1676846680211, + "version": "3.1.5" + }, + "aenum-3.1.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a33a96ad7f056b7f0e66410c60940ef5", + "name": "aenum", + "sha256": "ddbb8f30f17c02273d9a746c8dbe5067a5b751ea6e261b8f0f5242b3a73fb8b8", + "size": 195284, + "subdir": "linux-64", + "timestamp": 1638535092632, + "version": "3.1.5" + }, + "aenum-3.1.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1143e009258c21ae9f2154d354c5b616", + "name": "aenum", + "sha256": "1ee8f2e87b19fb4d15bbc2baf9768eb470b3a24d846f7f314bfd3f56da37a16c", + "size": 197070, + "subdir": "linux-64", + "timestamp": 1638521819600, + "version": "3.1.5" + }, + "aenum-3.1.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ec2fbaf4554d52259fe228e2fc4b7131", + "name": "aenum", + "sha256": "681b087a47df0db78209d72f5a4956c0d74b1dd17ffacf5306ef16c545e4bd48", + "size": 201555, + "subdir": "linux-64", + "timestamp": 1638535094158, + "version": "3.1.5" + }, + "affine-2.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5a4a914a98a280e65a7aba5bf2404319", + "name": "affine", + "sha256": "2f0ad72db6c98c4ed0e948077e23662fd637f3ab95c1542d22b7a9c612c42769", + "size": 26128, + "subdir": "linux-64", + "timestamp": 1522080606210, + "version": "2.2.0" + }, + "affine-2.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a55df331260830ee639a5d863237c7f6", + "name": "affine", + "sha256": "0dc6f3c661bd7194861a1222ad396cb55191e36719cc6356872e0040b03106f7", + "size": 27153, + "subdir": "linux-64", + "timestamp": 1522080637107, + "version": "2.2.0" + }, + "affine-2.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "21dcb1390e478a6dcc0718a1eaa2e9e7", + "name": "affine", + "sha256": "55b363c7b33f5ff83173e5e65f3373f7b0eddfa2f14cf1fa721d0e5f6b47e154", + "size": 27053, + "subdir": "linux-64", + "timestamp": 1522080638358, + "version": "2.2.0" + }, + "affine-2.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ba90ad0b1293fb1302f56c0596f69d66", + "name": "affine", + "sha256": "4c323cb323481a6769dda6856c706054911492faa29c2586eaa4d12dcef34371", + "size": 26752, + "subdir": "linux-64", + "timestamp": 1528984040931, + "version": "2.2.1" + }, + "affine-2.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bb3a9b40c385f94f1428f61c285c445f", + "name": "affine", + "sha256": "7dd664ff73cdaff6b592b2bb5b3d873b51e2c2bfb5144d8cc8bcca0723f5fec3", + "size": 27814, + "subdir": "linux-64", + "timestamp": 1528984096777, + "version": "2.2.1" + }, + "affine-2.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f86af9c61887b51da5ed4194405a4bac", + "name": "affine", + "sha256": "9c5f8853238640e71e13be4eb8cd37b8810c26d80dfc3c121beb1b2c82610d72", + "size": 27718, + "subdir": "linux-64", + "timestamp": 1528983947135, + "version": "2.2.1" + }, + "affine-2.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3eecd6cde4248385477135051c35aad9", + "name": "affine", + "sha256": "44fcbb1777424aa423218c43253203eebb93c47e936707feaf9ddfafa63b2e91", + "size": 27498, + "subdir": "linux-64", + "timestamp": 1530735462767, + "version": "2.2.1" + }, + "affine-2.2.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c461ab9ee3d21ae8692f91b0eaacb129", + "name": "affine", + "sha256": "8d3c529a2311f78666fbf09d0274cc79e20eb195919fa0907b89e8b981195897", + "size": 29820, + "subdir": "linux-64", + "timestamp": 1547221308441, + "version": "2.2.2" + }, + "affine-2.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9a92d1e2c5f4e1834c054e9f0f64828b", + "name": "affine", + "sha256": "847fe4bcbbf5cbc6a1c9f6bc8e173fadcc2f6360293958a606d640b89fa284af", + "size": 30880, + "subdir": "linux-64", + "timestamp": 1547221373396, + "version": "2.2.2" + }, + "affine-2.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aa12b65d874c90b83885fe2dcc734643", + "name": "affine", + "sha256": "90d420aa49afee253da6df3914222907430d4619f021003bc8216ebc3ea257a2", + "size": 30660, + "subdir": "linux-64", + "timestamp": 1547221374363, + "version": "2.2.2" + }, + "agate-1.6.0-py27hb771d64_2.tar.bz2": { + "build": "py27hb771d64_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=2.7,<2.8.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "d29239218e174b56481296faa162f450", + "name": "agate", + "sha256": "7ed04d37b276850a4d64403c28edcec4ddc6925c5f4fb674fb09382bf5c6f994", + "size": 96657, + "subdir": "linux-64", + "timestamp": 1508623366090, + "version": "1.6.0" + }, + "agate-1.6.0-py35h2a67053_2.tar.bz2": { + "build": "py35h2a67053_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.5,<3.6.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "0865f31cc0aec29793877d2cbc7b2bb9", + "name": "agate", + "sha256": "9c92ebb4ff797f6c40971b50af8c8786f1cd41201147a01da809df84c3bd147e", + "size": 99498, + "subdir": "linux-64", + "timestamp": 1508623370971, + "version": "1.6.0" + }, + "agate-1.6.0-py36h1b42258_2.tar.bz2": { + "build": "py36h1b42258_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.6,<3.7.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "410dbf860bdbaff547308448cc7619cc", + "name": "agate", + "sha256": "3f03dc795022f1d799f500d7f49d6b8977143a686a8b7f00e7258db103b56db3", + "size": 99216, + "subdir": "linux-64", + "timestamp": 1508623356978, + "version": "1.6.0" + }, + "agate-1.6.1-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=2.7,<2.8.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "ccddd5d814ea43d2a1601167c8449f0d", + "name": "agate", + "sha256": "005fcdaf20e4f22d55a86145f54845017cfaef3cf44a3bd925ab45dbd5379b0a", + "size": 96432, + "subdir": "linux-64", + "timestamp": 1520969373125, + "version": "1.6.1" + }, + "agate-1.6.1-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.10,<3.11.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "c65507eee49ec744f6c4d755e454b311", + "name": "agate", + "sha256": "845fda2d307436a02bb5b07e75df2486cd07cfeb72e22e2e16ea84778627e571", + "size": 99669, + "subdir": "linux-64", + "timestamp": 1640803305417, + "version": "1.6.1" + }, + "agate-1.6.1-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.5,<3.6.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "1054c91508d0958efd660daab4dc06f7", + "name": "agate", + "sha256": "9777b9ee0e4f86bb2db688c07e9035332cc7d9d760f14f13aa9a517f96cadbd8", + "size": 99250, + "subdir": "linux-64", + "timestamp": 1520969526224, + "version": "1.6.1" + }, + "agate-1.6.1-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.6,<3.7.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "b49393d0cfff877a26964d8df30c9daf", + "name": "agate", + "sha256": "78bcf0bdb11e446afd85e2293851fec463cc91427cf113c2b22ec7f7710a8977", + "size": 98829, + "subdir": "linux-64", + "timestamp": 1520969364209, + "version": "1.6.1" + }, + "agate-1.6.1-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.6,<3.7.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "a2fa2a75ab83cbb75ed5b73b99101ba5", + "name": "agate", + "sha256": "e0718c43c85e60b48a1289e3dc9d449413a585c4d0cfccb6051a16fee0585ca0", + "size": 100422, + "subdir": "linux-64", + "timestamp": 1614002827662, + "version": "1.6.1" + }, + "agate-1.6.1-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.7,<3.8.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "9441004b800c66313d11c300791e1244", + "name": "agate", + "sha256": "a393afeab8311eef7f27c8531a1e01a9d7547a32cc58d4c7598d917e9d289471", + "size": 98820, + "subdir": "linux-64", + "timestamp": 1530735770212, + "version": "1.6.1" + }, + "agate-1.6.1-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.7,<3.8.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "e34f34bfdeccf2cc5c8154cd901279b8", + "name": "agate", + "sha256": "3d591aada574d7e3f3f123247ae890fe994183ab3e7019949e3302b68716307c", + "size": 100524, + "subdir": "linux-64", + "timestamp": 1614002826990, + "version": "1.6.1" + }, + "agate-1.6.1-py38_2.tar.bz2": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.8,<3.9.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "8ac0f3ac920d998cfa230bcb33aa20b5", + "name": "agate", + "sha256": "276fe3e4252a1798191e597db8063801575532f299c6b52bdd07f090fcebc316", + "size": 99352, + "subdir": "linux-64", + "timestamp": 1574097675373, + "version": "1.6.1" + }, + "agate-1.6.1-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.8,<3.9.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "95502862da0aa403bb67bf05e74a1f8b", + "name": "agate", + "sha256": "6b5d8712ba697c3b9987843192059bca5c57314a2f29a7808be3dad71df652e9", + "size": 100424, + "subdir": "linux-64", + "timestamp": 1614002830515, + "version": "1.6.1" + }, + "agate-1.6.1-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.9,<3.10.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "62decf86527bfa4ecf5d99d10a90fbc1", + "name": "agate", + "sha256": "8c7a1038a051caef1ac618a6a896cf7616af0bebf874a7ac814012b027b980b4", + "size": 100429, + "subdir": "linux-64", + "timestamp": 1614002831529, + "version": "1.6.1" + }, + "agate-1.6.2-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.6,<3.7.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "0c12de69c0afea35a88b3326a5643f94", + "name": "agate", + "sha256": "8bcb82036907edcc316a9689297cd905dcf14184499f1a83931ea7ab1aec0d67", + "size": 100384, + "subdir": "linux-64", + "timestamp": 1615487454859, + "version": "1.6.2" + }, + "agate-1.6.2-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.7,<3.8.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "7f8d15a0d03382b40b1196d4ea11491e", + "name": "agate", + "sha256": "853b45ade60c149202fbe6021c38acd41b65255b60c1219a16c3bbcd28b10988", + "size": 100643, + "subdir": "linux-64", + "timestamp": 1615487453199, + "version": "1.6.2" + }, + "agate-1.6.2-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.8,<3.9.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "a47fc386d4de89105de61c5112abe046", + "name": "agate", + "sha256": "466a686b8abb4ea88578c05e217c589180aa00e02bbee83b23dc87c04db97e6a", + "size": 100642, + "subdir": "linux-64", + "timestamp": 1615485833021, + "version": "1.6.2" + }, + "agate-1.6.2-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.9,<3.10.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "208e56033c705be3780b5af5e8b083b8", + "name": "agate", + "sha256": "7fa463eafb2163e167872ead515ff723183a79a59d9bfcb3f86a8509bd252f82", + "size": 100530, + "subdir": "linux-64", + "timestamp": 1615487462335, + "version": "1.6.2" + }, + "agate-1.7.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1,!=2.5", + "python >=3.10,<3.11.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9d1c223d001f339f23f953b6d10ea40", + "name": "agate", + "sha256": "19bcfb46002b0a89d16a9124bb2fbd2ec198188aed0642c10a1f5cbab8531955", + "size": 105601, + "subdir": "linux-64", + "timestamp": 1674846298185, + "version": "1.7.1" + }, + "agate-1.7.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1,!=2.5", + "python >=3.11,<3.12.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc67e48e034701b8212809db149466c5", + "name": "agate", + "sha256": "5f68f14aa43224fffade8f5f94df4364401273d048ee6f7f78254c744532bffd", + "size": 134386, + "subdir": "linux-64", + "timestamp": 1676838958400, + "version": "1.7.1" + }, + "agate-1.7.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1,!=2.5", + "python >=3.7,<3.8.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "03f69b2538abc36645ebad79a41a5f6c", + "name": "agate", + "sha256": "da4c85e0a9f87581c039d8afe3e8fdb68959795d4377204f66c1bd57c282d211", + "size": 104698, + "subdir": "linux-64", + "timestamp": 1674846354165, + "version": "1.7.1" + }, + "agate-1.7.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1,!=2.5", + "python >=3.8,<3.9.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a58f95fe8a48fbb6134fb3bb64045107", + "name": "agate", + "sha256": "364f40560d3decb0e06d3600f657bec806f42c0ebf25dfbc443fe7ea3a7c1fd3", + "size": 104673, + "subdir": "linux-64", + "timestamp": 1674846326076, + "version": "1.7.1" + }, + "agate-1.7.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1,!=2.5", + "python >=3.9,<3.10.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "450dac5394ac46167b46b1e3d7241f43", + "name": "agate", + "sha256": "85bbde75fb11cb450e2a94359e56eafc117548c423cb44053e8914991e947b90", + "size": 104816, + "subdir": "linux-64", + "timestamp": 1674846269665, + "version": "1.7.1" + }, + "agate-dbf-0.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "dbfread >=2.0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a35eb66d6193804d5567611400a3a8dd", + "name": "agate-dbf", + "sha256": "a893153208334371ccabd2975b0a820cad722a20937f7728d3f3be24d90f78cf", + "size": 5799, + "subdir": "linux-64", + "timestamp": 1530735883156, + "version": "0.2.0" + }, + "agate-dbf-0.2.0-py27h9ce99ee_0.tar.bz2": { + "build": "py27h9ce99ee_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "dbfread >=2.0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4015d3bf55913ea17da56bf0f310f2de", + "name": "agate-dbf", + "sha256": "28c8ae089b03ff769e4fdb0f866e8695c88b93d692165327e128a50c05077093", + "size": 6651, + "subdir": "linux-64", + "timestamp": 1508625648960, + "version": "0.2.0" + }, + "agate-dbf-0.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "dbfread >=2.0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4c385bd8e4e82e8dd1fee6d278ff6715", + "name": "agate-dbf", + "sha256": "f5991e5829e9488b78ace8d40e72a68e6f7a84edcdbc39a53e86fe0dde1004c6", + "size": 5783, + "subdir": "linux-64", + "timestamp": 1534352093152, + "version": "0.2.0" + }, + "agate-dbf-0.2.0-py35h575f34e_0.tar.bz2": { + "build": "py35h575f34e_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "dbfread >=2.0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d40efb37e316cf1089df7a5c4d5610be", + "name": "agate-dbf", + "sha256": "c3f7e500f04a9eb50a26e9ae76b8d572b33f16a2afe1ada5dd051734103e55a4", + "size": 6735, + "subdir": "linux-64", + "timestamp": 1508625654228, + "version": "0.2.0" + }, + "agate-dbf-0.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "dbfread >=2.0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1175bf1bc719a9e3231188bcdb65d75", + "name": "agate-dbf", + "sha256": "7de4eca7e5260aa5805fdb5fed4b8a6bee77a0508719b0790a7680d09424faa5", + "size": 5827, + "subdir": "linux-64", + "timestamp": 1530735858002, + "version": "0.2.0" + }, + "agate-dbf-0.2.0-py36hacfe2c2_0.tar.bz2": { + "build": "py36hacfe2c2_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "dbfread >=2.0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21a7000c1f53275f62e8edff3bd78a08", + "name": "agate-dbf", + "sha256": "c3a05319f776ede85291952eaba24106fec1052f6137d541d40f19a822226ac0", + "size": 6690, + "subdir": "linux-64", + "timestamp": 1508625648439, + "version": "0.2.0" + }, + "agate-dbf-0.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "dbfread >=2.0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "44710d905cebb108e1d9e072fb67de30", + "name": "agate-dbf", + "sha256": "7bc1fd685cbf3fd1c2abf521dfc527fb36a396f2186741b53508a3df1bade742", + "size": 5826, + "subdir": "linux-64", + "timestamp": 1530735909210, + "version": "0.2.0" + }, + "agate-excel-0.2.1-py27h3c51f3f_0.tar.bz2": { + "build": "py27h3c51f3f_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "openpyxl >=2.3.0", + "python >=2.7,<2.8.0a0", + "xlrd >=0.9.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b97df43ffde484d485307108195a4d81", + "name": "agate-excel", + "sha256": "4c4f660c0d8416d937397bbefc4267dded3beaf8acae9e79e265ce9b58f82a50", + "size": 10428, + "subdir": "linux-64", + "timestamp": 1508624734697, + "version": "0.2.1" + }, + "agate-excel-0.2.1-py35h3f91c98_0.tar.bz2": { + "build": "py35h3f91c98_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "openpyxl >=2.3.0", + "python >=3.5,<3.6.0a0", + "xlrd >=0.9.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d33ee552649ccaaa1ff9c57f78610ee6", + "name": "agate-excel", + "sha256": "9cb0d22131ab5669c716df2aade79ea02a4168f04d19911fc7242aaf3c7761bb", + "size": 10674, + "subdir": "linux-64", + "timestamp": 1508624778521, + "version": "0.2.1" + }, + "agate-excel-0.2.1-py36h4cc37e8_0.tar.bz2": { + "build": "py36h4cc37e8_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "openpyxl >=2.3.0", + "python >=3.6,<3.7.0a0", + "xlrd >=0.9.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "922e89a8d09b777fc57e2c58e5aad248", + "name": "agate-excel", + "sha256": "b97261b84c3f694f8d09dc7de0f83562148163dab179a14b654dc265997619e5", + "size": 10551, + "subdir": "linux-64", + "timestamp": 1508624777093, + "version": "0.2.1" + }, + "agate-excel-0.2.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "openpyxl >=2.3.0", + "python >=2.7,<2.8.0a0", + "xlrd >=0.9.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "969e6bb94c841d037e1f73a3717b6916", + "name": "agate-excel", + "sha256": "582a6dfbddd69fc9212f7af099cd3711aa32018d64d0a64dcdeeff0e3eb8b74e", + "size": 10420, + "subdir": "linux-64", + "timestamp": 1520969734062, + "version": "0.2.2" + }, + "agate-excel-0.2.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "openpyxl >=2.3.0", + "python >=3.5,<3.6.0a0", + "xlrd >=0.9.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01de7ea5c151c9f1abb081aa7f454a9f", + "name": "agate-excel", + "sha256": "3b81454acc02115ed058c729f22fd48684a35ba0209201685dc84a423bacafe2", + "size": 10602, + "subdir": "linux-64", + "timestamp": 1520969878190, + "version": "0.2.2" + }, + "agate-excel-0.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "openpyxl >=2.3.0", + "python >=3.6,<3.7.0a0", + "xlrd >=0.9.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "752d0aaac391cd29ee56ae33e66ef59b", + "name": "agate-excel", + "sha256": "934d6cc21ba346a5099716a34e318d13ba64611b5cd61d0028d5052988b2a34d", + "size": 10547, + "subdir": "linux-64", + "timestamp": 1520969576403, + "version": "0.2.2" + }, + "agate-excel-0.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "openpyxl >=2.3.0", + "python >=3.7,<3.8.0a0", + "xlrd >=0.9.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8fc37a81b2474f14248c221e74e42b4", + "name": "agate-excel", + "sha256": "9928f25e919c04676d0367a5149b96547878306b610160c550ce1365af232fa9", + "size": 10425, + "subdir": "linux-64", + "timestamp": 1530736116668, + "version": "0.2.2" + }, + "agate-sql-0.5.2-py27habb94be_0.tar.bz2": { + "build": "py27habb94be_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "python >=2.7,<2.8.0a0", + "sqlalchemy >=1.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a399ec09a4b5580077ba7d872b4e2963", + "name": "agate-sql", + "sha256": "552e63acef7f57c3a5c88cabd2c07ddc84aaa406f4a59c57b380757b7eb444d9", + "size": 11329, + "subdir": "linux-64", + "timestamp": 1508624045026, + "version": "0.5.2" + }, + "agate-sql-0.5.2-py35h2ac6a9e_0.tar.bz2": { + "build": "py35h2ac6a9e_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "python >=3.5,<3.6.0a0", + "sqlalchemy >=1.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "247cb3485a36ce005f056ab1aa181504", + "name": "agate-sql", + "sha256": "e9586625bf655425b2bff998c5fd67d2f963f34ac1b7aed247adcfc8cc4d2557", + "size": 11464, + "subdir": "linux-64", + "timestamp": 1508623985459, + "version": "0.5.2" + }, + "agate-sql-0.5.2-py36h44b7e2c_0.tar.bz2": { + "build": "py36h44b7e2c_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "python >=3.6,<3.7.0a0", + "sqlalchemy >=1.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6be94bc9941deeb59b4a86eb3543e7c1", + "name": "agate-sql", + "sha256": "654bc7f4f6367ba305676c357712142bce5db560923707499b96bd09dd83a3d2", + "size": 11432, + "subdir": "linux-64", + "timestamp": 1508624060850, + "version": "0.5.2" + }, + "agate-sql-0.5.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "python >=2.7,<2.8.0a0", + "sqlalchemy >=1.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c00281b64154a6ae400ff8136a57cda9", + "name": "agate-sql", + "sha256": "bfda23c9382519faca27e04550eac4ce8acb2bb82b43dc0fdcc9edb5a25851f2", + "size": 11820, + "subdir": "linux-64", + "timestamp": 1520969743340, + "version": "0.5.3" + }, + "agate-sql-0.5.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "python >=3.5,<3.6.0a0", + "sqlalchemy >=1.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17115288de06b95f587794e1fe52b059", + "name": "agate-sql", + "sha256": "03830642da2fda5b06937cefb82457916329fcd3835d511d730b64547c3dcba1", + "size": 11957, + "subdir": "linux-64", + "timestamp": 1520969847408, + "version": "0.5.3" + }, + "agate-sql-0.5.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "python >=3.6,<3.7.0a0", + "sqlalchemy >=1.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "175d24ae4949518cd6154c110707fd01", + "name": "agate-sql", + "sha256": "dc9852d84568d55a9e5153c460889c18c0478d1a4172dbb826d364409a7b70bd", + "size": 11888, + "subdir": "linux-64", + "timestamp": 1520969574639, + "version": "0.5.3" + }, + "agate-sql-0.5.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "python >=3.7,<3.8.0a0", + "sqlalchemy >=1.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "547ce9cd13d57906a25e188bbeedce25", + "name": "agate-sql", + "sha256": "d18050e2ba2f40290e569197a10f2d4c16e7cbc093502d2ce71832b535742d75", + "size": 11759, + "subdir": "linux-64", + "timestamp": 1530736420417, + "version": "0.5.3" + }, + "aiobotocore-0.10.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "botocore >=1.12.49,<1.12.50", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "b6f842d2a9239a50dd1e70ced3eb6eef", + "name": "aiobotocore", + "sha256": "591fbac00d2d27a8fba507f48f30ac2fced9b19e5a15ac57e93439f455f62a75", + "size": 36625, + "subdir": "linux-64", + "timestamp": 1545162239367, + "version": "0.10.0" + }, + "aiobotocore-0.10.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "botocore >=1.12.49,<1.12.50", + "python >=3.7,<3.8.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "068f35947beb1fd5eaa4699c2675b464", + "name": "aiobotocore", + "sha256": "c80c99972a8148a5f4389c3d5d7f51462fd889a1670ce2f8e26acbb0c3f32f27", + "size": 36650, + "subdir": "linux-64", + "timestamp": 1545162213453, + "version": "0.10.0" + }, + "aiobotocore-0.10.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "async_generator >=1.10", + "botocore >=1.12.49,<1.12.50", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "947cc1ea372d6c53a47dc548b13a1483", + "name": "aiobotocore", + "sha256": "2447ab9a154d2581fb9dfa8bbe9238ede93b12538c55b4e304b900460472350e", + "size": 40020, + "subdir": "linux-64", + "timestamp": 1550266978306, + "version": "0.10.2" + }, + "aiobotocore-0.10.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "async_generator >=1.10", + "botocore >=1.12.49,<1.12.50", + "python >=3.7,<3.8.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "e3700d7be5f33aa012a8d1a7c165d663", + "name": "aiobotocore", + "sha256": "1960aef331fce01cc1a1ec63d6188f5e03ec36655fb89a45701f4d088507551a", + "size": 40111, + "subdir": "linux-64", + "timestamp": 1550266831648, + "version": "0.10.2" + }, + "aiobotocore-0.4.3-py35h8f5c47f_0.tar.bz2": { + "build": "py35h8f5c47f_0", + "build_number": 0, + "depends": [ + "aiohttp >=2.0.4,<=2.3.0", + "botocore >=1.5.71,<=1.5.78", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.5,<3.6.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "1cee7ae3dfc2acd09fde1fbce1ed0fa5", + "name": "aiobotocore", + "sha256": "4b609cf89eec66d88a7c696053dfcfed8dfd62f0ce8ccd04b3d7c73e8db33074", + "size": 31763, + "subdir": "linux-64", + "timestamp": 1507658798173, + "version": "0.4.3" + }, + "aiobotocore-0.4.3-py36ha4832ae_0.tar.bz2": { + "build": "py36ha4832ae_0", + "build_number": 0, + "depends": [ + "aiohttp >=2.0.4,<=2.3.0", + "botocore >=1.5.71,<=1.5.78", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "ccec1ac6dd0fcd148fd6502c7e512551", + "name": "aiobotocore", + "sha256": "aebbc4321993be59642372d2d3b1267451632fce725c30ea577f64edd5ebd898", + "size": 31532, + "subdir": "linux-64", + "timestamp": 1507658802537, + "version": "0.4.3" + }, + "aiobotocore-0.4.5-py35h86c1b7f_0.tar.bz2": { + "build": "py35h86c1b7f_0", + "build_number": 0, + "depends": [ + "aiohttp >=2.0.4,<=2.3.0", + "botocore >=1.7.4,<=1.7.5", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.5,<3.6.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "42c96fea9b488af7ca910ee08200c82e", + "name": "aiobotocore", + "sha256": "2481a768f96c041dfc7a0ccc50a0e1b52097130cc5376c522838958d0b2957a5", + "size": 32771, + "subdir": "linux-64", + "timestamp": 1507654541823, + "version": "0.4.5" + }, + "aiobotocore-0.4.5-py36h52af316_0.tar.bz2": { + "build": "py36h52af316_0", + "build_number": 0, + "depends": [ + "aiohttp >=2.0.4,<=2.3.0", + "botocore >=1.7.4,<=1.7.5", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "cb023cc81b08ba98a78ad80e6c79ff1f", + "name": "aiobotocore", + "sha256": "228ac320b9072560ea4a262a0ca8e6c6cd6d5c440bb4f75b05ec6c4dc4b0d171", + "size": 32558, + "subdir": "linux-64", + "timestamp": 1507654547385, + "version": "0.4.5" + }, + "aiobotocore-0.5.1-py35h7f75d60_0.tar.bz2": { + "build": "py35h7f75d60_0", + "build_number": 0, + "depends": [ + "aiohttp >=2.3.0,<3.0.0", + "botocore >=1.7.28,<=1.7.40", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.5,<3.6.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "594bec0f7b86ae28d08e796addb464d2", + "name": "aiobotocore", + "sha256": "947db8ab4695d8686f3c29d45620934d67902eb35f8522155b7b9c715a8be4db", + "size": 32200, + "subdir": "linux-64", + "timestamp": 1511928450617, + "version": "0.5.1" + }, + "aiobotocore-0.5.1-py36h9454989_0.tar.bz2": { + "build": "py36h9454989_0", + "build_number": 0, + "depends": [ + "aiohttp >=2.3.0,<3.0.0", + "botocore >=1.7.28,<=1.7.40", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "0019d7744d70fe8565d6009dc799c22c", + "name": "aiobotocore", + "sha256": "d5469f00ceda7d269720289f9b4acc734c2a739a53a2e76a580803055f275fa3", + "size": 31967, + "subdir": "linux-64", + "timestamp": 1511928460060, + "version": "0.5.1" + }, + "aiobotocore-0.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.0.0", + "botocore >=1.8.0,<=1.8.21", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.5,<3.6.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "08bb641957fafd7b78676ecc01320d7b", + "name": "aiobotocore", + "sha256": "780df30f32de584fdf4281c9630b752ccb7b9f3a0e6089b735ac24c63ea99a4d", + "size": 33116, + "subdir": "linux-64", + "timestamp": 1520922009871, + "version": "0.6.0" + }, + "aiobotocore-0.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.0.0", + "botocore >=1.8.0,<=1.8.21", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "b525f172e39231f5e4640f196b1f4e35", + "name": "aiobotocore", + "sha256": "69dade5e1f653718fafa02ab69d770d7f1f1fdaf0e51cc63739152a3288ac49d", + "size": 32977, + "subdir": "linux-64", + "timestamp": 1520921986597, + "version": "0.6.0" + }, + "aiobotocore-0.8.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.1.0,<3.2.0", + "botocore >=1.10.12,<=1.10.13", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.5,<3.6.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "3c36b317c1dcbf9a43ae454ef69ed5bc", + "name": "aiobotocore", + "sha256": "ec67e5427bcdad9a50a94c329d2e33b3eae1149ce31be3b512b02c5b00cb06db", + "size": 33717, + "subdir": "linux-64", + "timestamp": 1527700992015, + "version": "0.8.0" + }, + "aiobotocore-0.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.1.0,<3.2.0", + "botocore >=1.10.12,<=1.10.13", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "d69c2fe718c91b3edc9fc792b55e35f4", + "name": "aiobotocore", + "sha256": "f42c760353205e39407c49fd68005642ef484bedb8e19b4f74170940912ce2e5", + "size": 33599, + "subdir": "linux-64", + "timestamp": 1527700946882, + "version": "0.8.0" + }, + "aiobotocore-0.9.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.0", + "botocore >=1.10.12,<1.10.13", + "python >=3.5,<3.6.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "60fe3538920bb79d104274dfeea982af", + "name": "aiobotocore", + "sha256": "d51af4f8eb635448b3e803d831ce9b8bbd0923d5e0b0ac3aaaec962a0aca414e", + "size": 32485, + "subdir": "linux-64", + "timestamp": 1528210048749, + "version": "0.9.1" + }, + "aiobotocore-0.9.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.0", + "botocore >=1.10.12,<1.10.13", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "3d36d389e7f68519341ab0d710c312e1", + "name": "aiobotocore", + "sha256": "89039a0dedba37a06ec03d24aee88d3b7a53d8a11b9befed7e5f7cbb2b80ab34", + "size": 32332, + "subdir": "linux-64", + "timestamp": 1528210001250, + "version": "0.9.1" + }, + "aiobotocore-0.9.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.0", + "botocore >=1.10.12,<1.10.13", + "python >=3.5,<3.6.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "b1b4131e4018bfa94f1366e458501485", + "name": "aiobotocore", + "sha256": "d4ce5f53a94f7c0b1d944cbb240d117cd784afdc326ef30e2ce2cb9f548ffaea", + "size": 32523, + "subdir": "linux-64", + "timestamp": 1529322630981, + "version": "0.9.2" + }, + "aiobotocore-0.9.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.0", + "botocore >=1.10.12,<1.10.13", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "2b25cb4a09577e075d12d1e873de74e2", + "name": "aiobotocore", + "sha256": "53b4d8c8be630b7c76209b6f75c66c099ada5ca501aa74194eec89bdde2a2b85", + "size": 32371, + "subdir": "linux-64", + "timestamp": 1529322642410, + "version": "0.9.2" + }, + "aiobotocore-0.9.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.0", + "botocore >=1.10.12,<1.10.13", + "python >=3.7,<3.8.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "772e797bb7bb304857b6cb26db252236", + "name": "aiobotocore", + "sha256": "48b5829a87e94c1c7dc970acfceec730aeb9f7c37d474f29c7c75d2ed1213c63", + "size": 32417, + "subdir": "linux-64", + "timestamp": 1530736959539, + "version": "0.9.2" + }, + "aiobotocore-0.9.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "botocore >=1.10.58,<1.10.59", + "python >=3.5,<3.6.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "928e095032635a895a65f245a7f61ed8", + "name": "aiobotocore", + "sha256": "65352c81c363d021d6fbb1778ab7e6a8a456c38afaa0c04096f7cda6ef5ac017", + "size": 35091, + "subdir": "linux-64", + "timestamp": 1536117999593, + "version": "0.9.3" + }, + "aiobotocore-0.9.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "botocore >=1.10.58,<1.10.59", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "fdec6c7073e333344f6fa49ad47bfa5c", + "name": "aiobotocore", + "sha256": "f4ce15abdf26923751634523b5907cee5a616a2d9dec0ad4baf591400c4b740e", + "size": 34926, + "subdir": "linux-64", + "timestamp": 1536117933843, + "version": "0.9.3" + }, + "aiobotocore-0.9.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "botocore >=1.10.58,<1.10.59", + "python >=3.7,<3.8.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "2522d5395f3e4686ed812e177f86ae84", + "name": "aiobotocore", + "sha256": "f7493149849e11c9d2ba892eb0fc175ff21a748877ff8760f43221c6e8384f90", + "size": 34991, + "subdir": "linux-64", + "timestamp": 1536118021192, + "version": "0.9.3" + }, + "aiobotocore-0.9.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "botocore >=1.10.58,<1.10.59", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "85f576213f32f4979eb9241e0c52ab02", + "name": "aiobotocore", + "sha256": "51eade028d0dbe80ac220371a71c48a4b19be811c876667fbe40a9080bf8d7f0", + "size": 35052, + "subdir": "linux-64", + "timestamp": 1538171576435, + "version": "0.9.4" + }, + "aiobotocore-0.9.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "botocore >=1.10.58,<1.10.59", + "python >=3.7,<3.8.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "3ba18326c11247b5bc28e88ca57883bc", + "name": "aiobotocore", + "sha256": "20eb25c8dad4eed00938732082dd2cc525ff48d34a009ae090ea938d24e300aa", + "size": 35089, + "subdir": "linux-64", + "timestamp": 1538171517861, + "version": "0.9.4" + }, + "aiobotocore-2.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.27.59,<1.27.60", + "python >=3.10,<3.11.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d78351bff5e4523463f3ccef6b64382b", + "name": "aiobotocore", + "sha256": "94c32e9a6534f99d86512677e6d254d5284118eccb6961f22ff1788499d096d8", + "size": 95904, + "subdir": "linux-64", + "timestamp": 1667504214605, + "version": "2.4.0" + }, + "aiobotocore-2.4.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.27.59,<1.27.60", + "python >=3.11,<3.12.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4a6d37dccbcdf0c051f0718039d675da", + "name": "aiobotocore", + "sha256": "38891888148d4df3a269cddd013de94f79b8d85cd99662b4f64b1a3d3419343c", + "size": 123919, + "subdir": "linux-64", + "timestamp": 1676843165754, + "version": "2.4.0" + }, + "aiobotocore-2.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.27.59,<1.27.60", + "python >=3.7,<3.8.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c257f6f6cf7d868cfad46fd2471f8eb7", + "name": "aiobotocore", + "sha256": "b8c7a902c4b65cfc3b29bfb17f3db4a31ba7517937dc13018f89dde171a3cee6", + "size": 94469, + "subdir": "linux-64", + "timestamp": 1667504243156, + "version": "2.4.0" + }, + "aiobotocore-2.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.27.59,<1.27.60", + "python >=3.8,<3.9.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "93a1383605fd3a0e3b7aa6a4f4fb614d", + "name": "aiobotocore", + "sha256": "a618f7f8077927f1e0419379421af7fb920000806ef3f847928cfa879dd2c16c", + "size": 95121, + "subdir": "linux-64", + "timestamp": 1667504184234, + "version": "2.4.0" + }, + "aiobotocore-2.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.27.59,<1.27.60", + "python >=3.9,<3.10.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2b6764a2932896647e239383e4a5425a", + "name": "aiobotocore", + "sha256": "48b68383dab5d158a9c97a0692a1c8e38937d437414ed9c822f6b424887609c0", + "size": 95187, + "subdir": "linux-64", + "timestamp": 1667504271329, + "version": "2.4.0" + }, + "aiobotocore-2.4.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.27.59,<1.27.60", + "python >=3.10,<3.11.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fda1f6dcd661302984a7169865369c0d", + "name": "aiobotocore", + "sha256": "79b126df0994f5ce85149a7f34b86502c098d3f51405f987506517df15c3909e", + "size": 97833, + "subdir": "linux-64", + "timestamp": 1680004359011, + "version": "2.4.2" + }, + "aiobotocore-2.4.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.27.59,<1.27.60", + "python >=3.11,<3.12.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "542abfd04719c08815c2c6b63389ed5f", + "name": "aiobotocore", + "sha256": "ad3829626ef9f88ca5b783a9fc10ee6618bb79ffa2af606763c399488dd87ef7", + "size": 125601, + "subdir": "linux-64", + "timestamp": 1680004386704, + "version": "2.4.2" + }, + "aiobotocore-2.4.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.27.59,<1.27.60", + "python >=3.8,<3.9.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f119c1bb82f35e562b3c182f3971f541", + "name": "aiobotocore", + "sha256": "610f5e32fee5464d085e9711bf2d942ad0b832b07a4948387626a91e9e94c0d8", + "size": 96837, + "subdir": "linux-64", + "timestamp": 1680004330963, + "version": "2.4.2" + }, + "aiobotocore-2.4.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.27.59,<1.27.60", + "python >=3.9,<3.10.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c39265ea13c9e772244b1c5584479d79", + "name": "aiobotocore", + "sha256": "2017e0f439cb4ac09087a5683154ca1796b6240dce1a193669ee544f8170aa8a", + "size": 96941, + "subdir": "linux-64", + "timestamp": 1680004303624, + "version": "2.4.2" + }, + "aiofiles-0.3.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8fe22fda2a907c420dbdb369da9442de", + "name": "aiofiles", + "sha256": "3ca5c58091c0343f362c5e45093d078b162cc7f2e8a075bd56a80652925f6bdb", + "size": 16318, + "subdir": "linux-64", + "timestamp": 1522782325751, + "version": "0.3.2" + }, + "aiofiles-0.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4f2e0baf77eb8f593e61a707d3324d8d", + "name": "aiofiles", + "sha256": "b05359ed9f438a4596ca769026a8d8790b36c313d6271ab2bb2478a498a6de9b", + "size": 16324, + "subdir": "linux-64", + "timestamp": 1522782326129, + "version": "0.3.2" + }, + "aiofiles-0.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bc1e18a75c31d2b6dad4aecff762c38e", + "name": "aiofiles", + "sha256": "ad0936281d35eb514d854731b9583627bb70171a97181ebaef9a3617e8bc37b8", + "size": 16258, + "subdir": "linux-64", + "timestamp": 1530736984461, + "version": "0.3.2" + }, + "aiofiles-0.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2a8d17c06fee14ace19af4aecdf1ac07", + "name": "aiofiles", + "sha256": "5c52e002357269a9c6f143a9a71f9068d8ef73c2a2365fdeede26a55fe4f46f9", + "size": 15473, + "subdir": "linux-64", + "timestamp": 1535422416146, + "version": "0.4.0" + }, + "aiofiles-0.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f3c255a40ed6e057b6b1824b4427eaa6", + "name": "aiofiles", + "sha256": "6cb4ae564a9f0b073bcd3bbb6702b697a05386f14d09097ba439d5d9e9b834ee", + "size": 15441, + "subdir": "linux-64", + "timestamp": 1535422401170, + "version": "0.4.0" + }, + "aiofiles-0.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7c1ba7dd6ab45a3b88e7cc838c685702", + "name": "aiofiles", + "sha256": "06c3d4cb77f8bafb0f37edde0fe4581c8dc36e207f87aa09593e5970a59c02f3", + "size": 15492, + "subdir": "linux-64", + "timestamp": 1535422432138, + "version": "0.4.0" + }, + "aiofiles-0.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7bc1957b1badb1441101c21d0bfbb52b", + "name": "aiofiles", + "sha256": "9c13e3d535a3ef97a6b9843c6ab4215dadc25f37648bc36748b87fbc9c92f644", + "size": 15930, + "subdir": "linux-64", + "timestamp": 1572437545106, + "version": "0.4.0" + }, + "aiofiles-0.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7da099ac7974b9af31a67d4c09ca460b", + "name": "aiofiles", + "sha256": "72d60d4c575cc22d5c8287af7933a32b0a307236a52f60c0ae4e57e734073513", + "size": 16819, + "subdir": "linux-64", + "timestamp": 1598642675750, + "version": "0.5.0" + }, + "aiofiles-0.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "517341932c9e4aed3ff41263b723da41", + "name": "aiofiles", + "sha256": "d7a8de84484256d4b443200f0ae7e01b5c47431a42c9e3864ec7d858da5c95bb", + "size": 16821, + "subdir": "linux-64", + "timestamp": 1598642692632, + "version": "0.5.0" + }, + "aiofiles-0.5.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8d83dabc2a8238086ff7907adcbd856e", + "name": "aiofiles", + "sha256": "65be84a7ef0643e1a1d0917e8b9767256e1cd65d5b2fb9d964486b9f39da0cc8", + "size": 16903, + "subdir": "linux-64", + "timestamp": 1598642697336, + "version": "0.5.0" + }, + "aiofiles-0.6.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "55f718c7dc7a43499fb1723b9604ae34", + "name": "aiofiles", + "sha256": "eddb19a770a80f2a2b65f9b7ee432466ddc50a348982707b02aca73ae936bde5", + "size": 16121, + "subdir": "linux-64", + "timestamp": 1603893211704, + "version": "0.6.0" + }, + "aiofiles-0.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "040f31e7118fb7f2c7fdb4ff84092b40", + "name": "aiofiles", + "sha256": "ba3e0471d35f6a290407ea35a855b3c9d2d8daaebf3399ccc40c5db6d3451023", + "size": 16138, + "subdir": "linux-64", + "timestamp": 1603893194988, + "version": "0.6.0" + }, + "aiofiles-0.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "22aa2c1ea5f4e2bce116362d2d152fa6", + "name": "aiofiles", + "sha256": "01732f6e0333ddf7e62b659961c0057f390a04f67399287a2372093637b21e6c", + "size": 16246, + "subdir": "linux-64", + "timestamp": 1603893219597, + "version": "0.6.0" + }, + "aiofiles-0.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c0d687761b26eb113702f4ccfebe4be6", + "name": "aiofiles", + "sha256": "5389a01ced6affc6c029d0ce15786e27304767f3f029f17885d416eb6a417973", + "size": 17222, + "subdir": "linux-64", + "timestamp": 1611675314164, + "version": "0.6.0" + }, + "aiofiles-0.7.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "671b4d19ed85bed34e100aef4d2a59eb", + "name": "aiofiles", + "sha256": "7bca3ee11358fc450c4e53d84af425d17aa85f56c576eaedc6b389bf42cb70b0", + "size": 19956, + "subdir": "linux-64", + "timestamp": 1621258542990, + "version": "0.7.0" + }, + "aiofiles-0.7.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bc621094822924a6e91a23d5ca259f4b", + "name": "aiofiles", + "sha256": "42e14388c70794360684a98fb4346f5ffd48cb99edd46286b0a2459e3cb536b4", + "size": 19950, + "subdir": "linux-64", + "timestamp": 1621258446322, + "version": "0.7.0" + }, + "aiofiles-0.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "101ef53d9f49ff61afbc3fd991e9922b", + "name": "aiofiles", + "sha256": "290b61997ec4e62f73badc24f6c3ab07d085676f6ac5e4942e0c6847da2d30d6", + "size": 20090, + "subdir": "linux-64", + "timestamp": 1621258540065, + "version": "0.7.0" + }, + "aiofiles-0.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5294538f959f2b92f5a60d1b9b4736f7", + "name": "aiofiles", + "sha256": "84cf682065631dc5f4cbd2d4ec7ec30b0009b4a443bf69369b1b7b375bfa399a", + "size": 20108, + "subdir": "linux-64", + "timestamp": 1621253989644, + "version": "0.7.0" + }, + "aiohttp-2.2.5-py35h8d7d2b0_0.tar.bz2": { + "build": "py35h8d7d2b0_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2.0", + "chardet", + "multidict >=2.1.4", + "python >=3.5,<3.6.0a0", + "yarl >=0.11" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3d3e77a7e26716779158293145020c21", + "name": "aiohttp", + "sha256": "33fd31eba8994fdc29edc7caebd8ec369e13115017838f83fd49832fd314e7e0", + "size": 267630, + "subdir": "linux-64", + "timestamp": 1507573394484, + "version": "2.2.5" + }, + "aiohttp-2.2.5-py36h3a1b670_0.tar.bz2": { + "build": "py36h3a1b670_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2.0", + "chardet", + "multidict >=2.1.4", + "python >=3.6,<3.7.0a0", + "yarl >=0.11" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "34abb0fc0597402bd0eadb2508e4af32", + "name": "aiohttp", + "sha256": "c58b0bc8eb7bb75f33d7b45cd5da6c74399b07ec9c6aac76adaa2a6cbaccc07c", + "size": 265837, + "subdir": "linux-64", + "timestamp": 1507573400930, + "version": "2.2.5" + }, + "aiohttp-2.3.3-py35h1b2d56f_0.tar.bz2": { + "build": "py35h1b2d56f_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2.0", + "chardet", + "multidict >=3.0.0", + "python >=3.5,<3.6.0a0", + "yarl >=0.11" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d63c96ebbf8a0c1ee8fca52f8ca71c91", + "name": "aiohttp", + "sha256": "7278ae21ab4ee38332a414fca5ef5f9c0d8c31d5c62b7325dda797827934207e", + "size": 309880, + "subdir": "linux-64", + "timestamp": 1511844479300, + "version": "2.3.3" + }, + "aiohttp-2.3.3-py36h90e93d8_0.tar.bz2": { + "build": "py36h90e93d8_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2.0", + "chardet", + "multidict >=3.0.0", + "python >=3.6,<3.7.0a0", + "yarl >=0.11" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "275e0357bea943f77f5012bc8c3d75fa", + "name": "aiohttp", + "sha256": "440eff49a7382dd361db0fa84d82bb20cfcbe732f97d2d2dabfbafa971cabd4e", + "size": 302324, + "subdir": "linux-64", + "timestamp": 1511844477244, + "version": "2.3.3" + }, + "aiohttp-2.3.9-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2.0", + "chardet", + "multidict >=3.0.0", + "python >=3.5,<3.6.0a0", + "yarl >=0.11" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f75bff40a9e0305a3eabab579b1b778b", + "name": "aiohttp", + "sha256": "9de181fdf9920cec21337434148b2edabdbc07b93b2d93901e75bcb2c1edd66b", + "size": 309970, + "subdir": "linux-64", + "timestamp": 1516979140787, + "version": "2.3.9" + }, + "aiohttp-2.3.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2.0", + "chardet", + "multidict >=3.0.0", + "python >=3.6,<3.7.0a0", + "yarl >=0.11" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7347350f607c272868fe2ee0be6bfe40", + "name": "aiohttp", + "sha256": "39380b2e5f8bb4c0815fafab68b4d8da5248b10d1879bfc67d5b84b1930818cc", + "size": 303165, + "subdir": "linux-64", + "timestamp": 1516979141409, + "version": "2.3.9" + }, + "aiohttp-3.0.7-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2,<3.0", + "attrs >=17.4.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.5,<3.6.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dab8ad02aca584e4b0678527acb5772f", + "name": "aiohttp", + "sha256": "6137fc6a9f6bb60743049522a0f90fda71399b6bf610a81762ba74043778941a", + "size": 408599, + "subdir": "linux-64", + "timestamp": 1520921439340, + "version": "3.0.7" + }, + "aiohttp-3.0.7-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2,<3.0", + "attrs >=17.4.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "317ae05f1e5fbb64fdaa46e872096206", + "name": "aiohttp", + "sha256": "65f00063af6d69c961f2622c3fd3fc61079e441a5218103db0331fa3a48b24b6", + "size": 408450, + "subdir": "linux-64", + "timestamp": 1520921424205, + "version": "3.0.7" + }, + "aiohttp-3.1.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2,<3.0", + "attrs >=17.4.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.5,<3.6.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cb5ee5207da143e8e96a53c78e7ba1c9", + "name": "aiohttp", + "sha256": "9500c432efc45d665bff5883a7c54f02dc0bce3e1121268a46ae07b799af8e38", + "size": 416762, + "subdir": "linux-64", + "timestamp": 1522190567280, + "version": "3.1.0" + }, + "aiohttp-3.1.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2,<3.0", + "attrs >=17.4.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6884ef573b7c0e084b2721e957edfa71", + "name": "aiohttp", + "sha256": "6ffc5e90fe80f6be6ab979239048deffed209c71bbf4e7eaf864c83a5902decc", + "size": 416172, + "subdir": "linux-64", + "timestamp": 1522190616262, + "version": "3.1.0" + }, + "aiohttp-3.1.1-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2,<3.0", + "attrs >=17.4.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.5,<3.6.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b292bb8ff47bf313a757010b39d36dcc", + "name": "aiohttp", + "sha256": "66cc451ad7b5ed44efbbd68252c4848ee90116802c24da9bd9604c4981fede88", + "size": 418033, + "subdir": "linux-64", + "timestamp": 1522715085600, + "version": "3.1.1" + }, + "aiohttp-3.1.1-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2,<3.0", + "attrs >=17.4.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5dd18cfc1eb886002e30b4f2753454ba", + "name": "aiohttp", + "sha256": "a26551a5c16c2c9f32d83fda11b9a09ce0fee7166103da455e63da46023ec0d2", + "size": 416984, + "subdir": "linux-64", + "timestamp": 1522715081688, + "version": "3.1.1" + }, + "aiohttp-3.1.3-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2,<3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.5,<3.6.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f1b6736d4b458981db71b48974af9b9e", + "name": "aiohttp", + "sha256": "2db9348472fc4e29622faa8d41e4bebd0c13d9d666971bfc42c815885247e585", + "size": 419742, + "subdir": "linux-64", + "timestamp": 1524002676127, + "version": "3.1.3" + }, + "aiohttp-3.1.3-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2,<3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5afe2f77ecf6fcac2243e0f6a1bc9820", + "name": "aiohttp", + "sha256": "70a3bc88ae598649afa695664fd060c37efaedfdb8b713732e7c3fee009e936f", + "size": 419105, + "subdir": "linux-64", + "timestamp": 1524001823621, + "version": "3.1.3" + }, + "aiohttp-3.2.1-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.5,<3.6.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "65c14d24d5f4025eb5035640325c7644", + "name": "aiohttp", + "sha256": "1a14ff097379aed616fa23cfd505e24b98fe0a224b46e71c244a523f52ca1a50", + "size": 451954, + "subdir": "linux-64", + "timestamp": 1526921044031, + "version": "3.2.1" + }, + "aiohttp-3.2.1-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7e806b89073134a40d4fc6b12457109d", + "name": "aiohttp", + "sha256": "b079a4e5ca5bfc27100c909f891600e70c9bdf78363157d1553cd21e83d5d21b", + "size": 452747, + "subdir": "linux-64", + "timestamp": 1526921007509, + "version": "3.2.1" + }, + "aiohttp-3.3.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.5,<3.6.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "13f61607457bda508378694f4f7d39ae", + "name": "aiohttp", + "sha256": "e7db72ad3d14a7e6dfc91aea337cda13d53d2a18456c6d353affe7e0bb872852", + "size": 337181, + "subdir": "linux-64", + "timestamp": 1528209781006, + "version": "3.3.0" + }, + "aiohttp-3.3.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5cfe05d0507573203ccfa7fad3d79342", + "name": "aiohttp", + "sha256": "29cc35074cde04b9dcbb1a5bbed4faf635a4de5b2d38468a28a9709498a7adc4", + "size": 331401, + "subdir": "linux-64", + "timestamp": 1528209688726, + "version": "3.3.0" + }, + "aiohttp-3.3.2-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.5,<3.6.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9a21d730cfc31dfc26af21561e8bc736", + "name": "aiohttp", + "sha256": "d23376a4cac4190808f7ef3b1f986d3ec96e4e0caca1a071d784b747b4a92f00", + "size": 483591, + "subdir": "linux-64", + "timestamp": 1529417688706, + "version": "3.3.2" + }, + "aiohttp-3.3.2-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "645d1e408356106b651b6b000ab858b1", + "name": "aiohttp", + "sha256": "4e8e830180823828e1263f6f29c0f58fba435ed2e54316b164eca59790df330f", + "size": 480718, + "subdir": "linux-64", + "timestamp": 1529417674668, + "version": "3.3.2" + }, + "aiohttp-3.3.2-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.7,<3.8.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "38f0be6017c6b348e2ba767020f24fb9", + "name": "aiohttp", + "sha256": "86fa0b5d637a27c58840922a80bcf9901792c54681a4fe847b0dd5344ae45396", + "size": 480457, + "subdir": "linux-64", + "timestamp": 1530736572948, + "version": "3.3.2" + }, + "aiohttp-3.4.2-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.5,<3.6.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9f5bb400e4f5764146c41277c24e79a2", + "name": "aiohttp", + "sha256": "73d1483a5b668f944bb1aa4895db2a931c43f53a815b5c3a7a04589df415a101", + "size": 584543, + "subdir": "linux-64", + "timestamp": 1536103454616, + "version": "3.4.2" + }, + "aiohttp-3.4.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "50a71258f5f627b4ec1b7207058acdd9", + "name": "aiohttp", + "sha256": "52792588dd45e16ae9202ef5e83abfec52d4c5dea5186a1b3a9d4e4d851980ac", + "size": 585234, + "subdir": "linux-64", + "timestamp": 1536103356588, + "version": "3.4.2" + }, + "aiohttp-3.4.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.7,<3.8.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d2a927db4602a1273d1fadf7d9ec6a9f", + "name": "aiohttp", + "sha256": "1dc91104162bb5167c75ba37b2970908bd02f432514833e8027d545c863e9330", + "size": 585256, + "subdir": "linux-64", + "timestamp": 1536103419576, + "version": "3.4.2" + }, + "aiohttp-3.4.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "56ef1dc391bebf3351170c509362dac4", + "name": "aiohttp", + "sha256": "8b653aca302a28bebddc8460150931d4237bccfc594dd56e03020e0d72898391", + "size": 585557, + "subdir": "linux-64", + "timestamp": 1538181025693, + "version": "3.4.3" + }, + "aiohttp-3.4.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.7,<3.8.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c66bc94433b2f91351dc34901ad4b16c", + "name": "aiohttp", + "sha256": "df5b308c0337f5c860987abbd57b4450f84f0942c7f77524c153b33961e38bef", + "size": 584968, + "subdir": "linux-64", + "timestamp": 1538180984810, + "version": "3.4.3" + }, + "aiohttp-3.4.4-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "97708e10942eb4897c9fe7e4515cce37", + "name": "aiohttp", + "sha256": "cbfa969ab6f3b0d0b467854dd9426c855f4e06d1115fa467db755a30f1f982df", + "size": 585715, + "subdir": "linux-64", + "timestamp": 1539465947367, + "version": "3.4.4" + }, + "aiohttp-3.4.4-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.7,<3.8.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d9cecfda321cf1e26aec0109ac7aa9cf", + "name": "aiohttp", + "sha256": "1135c5d5489b5cdcfc891d53eef45c0fa1d46a9f1f5505d8459e98af38d27d66", + "size": 585640, + "subdir": "linux-64", + "timestamp": 1539465957589, + "version": "3.4.4" + }, + "aiohttp-3.5.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "adb0bc62000e7e98c2254586ecd5d5f3", + "name": "aiohttp", + "sha256": "4117a8b7dc16fc212f1151fe3887a4c7aafd4be67f7f50af7f3a5221200fd8e8", + "size": 612329, + "subdir": "linux-64", + "timestamp": 1547221851760, + "version": "3.5.1" + }, + "aiohttp-3.5.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.7,<3.8.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "91f94a701440d1d29b485be289f5cb86", + "name": "aiohttp", + "sha256": "f54d3d9808d6429baee2e4e06e25b9219c327696cf6226d6d5466620afb76065", + "size": 636267, + "subdir": "linux-64", + "timestamp": 1547221886429, + "version": "3.5.1" + }, + "aiohttp-3.5.4-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cf43d899182964e8e3251a5a655ab394", + "name": "aiohttp", + "sha256": "daf1acc13730d2f02149ca2f90ffcbb0754eb173a9477be6cb8a21f75b09e75f", + "size": 622359, + "subdir": "linux-64", + "timestamp": 1547745168854, + "version": "3.5.4" + }, + "aiohttp-3.5.4-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.7,<3.8.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8a4b4cc8043f78ddb95c730c7fe8b138", + "name": "aiohttp", + "sha256": "7f2ea765c395d0061bc2e2c0dde22b35c1110989714f7a3dd34c5a405c143561", + "size": 636998, + "subdir": "linux-64", + "timestamp": 1547745189964, + "version": "3.5.4" + }, + "aiohttp-3.6.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.6,<3.7.0a0", + "typing_extensions >=3.6.5", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "57a68cb722e31d7a1b2ec8797c3d6afd", + "name": "aiohttp", + "sha256": "98b0b4cbea25ca38f7d3b338000da9baf3155ffb227d46d8145343070feee87d", + "size": 631037, + "subdir": "linux-64", + "timestamp": 1569354725753, + "version": "3.6.1" + }, + "aiohttp-3.6.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.7,<3.8.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "115dd7b25bb70c8e8f2c7b3409da3a01", + "name": "aiohttp", + "sha256": "dd966bdb0bf634c373abebae5148b8a9e1a7bffc214c3cd8e744f04ab02cf077", + "size": 638656, + "subdir": "linux-64", + "timestamp": 1569351515515, + "version": "3.6.1" + }, + "aiohttp-3.6.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.8,<3.9.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fb5d989576a67a138eaa686f7297bd23", + "name": "aiohttp", + "sha256": "1b66179779aa1cc30fb0110e96800c4afa486068cf9186d552ca6e8752922c90", + "size": 647394, + "subdir": "linux-64", + "timestamp": 1574097774981, + "version": "3.6.1" + }, + "aiohttp-3.6.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.6,<3.7.0a0", + "typing_extensions >=3.6.5", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "75ae077876fc017f59e5b8921609da1c", + "name": "aiohttp", + "sha256": "f7e42d7659eb0bee976511079b5839c7edd0581fd53c3d477aa90c99c82b7f52", + "size": 635805, + "subdir": "linux-64", + "timestamp": 1574366164673, + "version": "3.6.2" + }, + "aiohttp-3.6.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.7,<3.8.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "76cc1889d02ce1e9b670b71e3c743d70", + "name": "aiohttp", + "sha256": "d85f2703cebef78b5ffaa10226460ab56ac8dc89ca9c8637daf377cc2bf7f849", + "size": 636665, + "subdir": "linux-64", + "timestamp": 1574366172846, + "version": "3.6.2" + }, + "aiohttp-3.6.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.8,<3.9.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "28938ec7b8ad22701dd6dcc5e608e8cf", + "name": "aiohttp", + "sha256": "f53b995b1432ad5325a9b9c903827fbf40e17bb0c82f798d4f708608bbb70481", + "size": 640473, + "subdir": "linux-64", + "timestamp": 1591133496059, + "version": "3.6.2" + }, + "aiohttp-3.6.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.6,<3.7.0a0", + "typing_extensions >=3.6.5", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b0f711e8a50bbd9f341f9a10b774579e", + "name": "aiohttp", + "sha256": "aff5d19dc3321b8c220c6433e4a2d6b518ca4d86debf0b03e8e4d084a7fd3faa", + "size": 626833, + "subdir": "linux-64", + "timestamp": 1602530332630, + "version": "3.6.3" + }, + "aiohttp-3.6.3-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.6,<3.7.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<1.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0946f7787f46791bd9fab2e0da96b3ff", + "name": "aiohttp", + "sha256": "398b8955daae6b5edb6a4d44b369c1a43e892017100614f7e08a5fcdc050acef", + "size": 644022, + "subdir": "linux-64", + "timestamp": 1603204991544, + "version": "3.6.3" + }, + "aiohttp-3.6.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.7,<3.8.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b54df5544e2bd10da4a4af038d3556e9", + "name": "aiohttp", + "sha256": "9067c63e6e084f9c256460f471aaa4187a311f271bda1bcde9f11e5b0141854a", + "size": 641233, + "subdir": "linux-64", + "timestamp": 1602530363812, + "version": "3.6.3" + }, + "aiohttp-3.6.3-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<1.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d630bd6930f302d4375bf7b6707e231a", + "name": "aiohttp", + "sha256": "567be9b1640deb2da47fc8a6dbddac5afd9110d59a07878c9407d42fb6f59c3b", + "size": 636981, + "subdir": "linux-64", + "timestamp": 1603204989518, + "version": "3.6.3" + }, + "aiohttp-3.6.3-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.8,<3.9.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4d282e3a704ac479009c4365eb60a4c1", + "name": "aiohttp", + "sha256": "f548f6ffbbffd180aa657038355cbfdd63b8e47ea2ae976ddbbb7bad56678b42", + "size": 636784, + "subdir": "linux-64", + "timestamp": 1602530351863, + "version": "3.6.3" + }, + "aiohttp-3.6.3-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<1.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "78fee1bcde65babc7e775c883333ed95", + "name": "aiohttp", + "sha256": "4065406ee27394f6a2ce40486d95f096c18473caa8d4941283384ca5b14b095b", + "size": 646652, + "subdir": "linux-64", + "timestamp": 1603204994987, + "version": "3.6.3" + }, + "aiohttp-3.7.2-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.6,<3.7.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<1.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "95919cd862a5a930123cee589e3ed7d5", + "name": "aiohttp", + "sha256": "08a9b5623e83017a40e0f037c903ccfcaad7b6d3a0268687759354d9c57efe2f", + "size": 628440, + "subdir": "linux-64", + "timestamp": 1603893315388, + "version": "3.7.2" + }, + "aiohttp-3.7.2-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<1.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "88288e559bd464ffbb104c3e3b7cc06e", + "name": "aiohttp", + "sha256": "2bde4a1f4e3d81a51b7e0a7bf104581eaa19bf205fb771196384dee776a9f29a", + "size": 622524, + "subdir": "linux-64", + "timestamp": 1603893288200, + "version": "3.7.2" + }, + "aiohttp-3.7.2-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<1.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1ac0445190b4f11e9bb85f3936b06074", + "name": "aiohttp", + "sha256": "9691935040392edfac09165586bc9bd1c288a87a6cf4f630737c5821d23874ea", + "size": 628115, + "subdir": "linux-64", + "timestamp": 1603893291931, + "version": "3.7.2" + }, + "aiohttp-3.7.3-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.6,<3.7.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<1.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6ef51bce58e9dd728e8d6426096cb43a", + "name": "aiohttp", + "sha256": "37c007f14783a189f4338b40a9a74f2ca268caa5ebbf77344eb0052910f1e931", + "size": 640200, + "subdir": "linux-64", + "timestamp": 1607109698065, + "version": "3.7.3" + }, + "aiohttp-3.7.3-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<1.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cc6832051956aadbfa73debf435d73c3", + "name": "aiohttp", + "sha256": "a97e249178e4feb32737ddf16add545ddd98401ae40baf0f5e9ea3831284f5ac", + "size": 630191, + "subdir": "linux-64", + "timestamp": 1607109682805, + "version": "3.7.3" + }, + "aiohttp-3.7.3-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<1.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bec8230bcb11f32e5e3249b26f6e06fb", + "name": "aiohttp", + "sha256": "be2662d9b563160bd6707658bc277494d144dff109d76d600d5e644bfff18550", + "size": 649313, + "subdir": "linux-64", + "timestamp": 1607109665015, + "version": "3.7.3" + }, + "aiohttp-3.7.3-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<7.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9636d145155a91d9e300b4253277a572", + "name": "aiohttp", + "sha256": "29f56dec95d2ce93599362b57c4febf2b11ba4f31de69ff42090d224ad915cff", + "size": 643054, + "subdir": "linux-64", + "timestamp": 1613390632412, + "version": "3.7.3" + }, + "aiohttp-3.7.4-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<7.0", + "python >=3.6,<3.7.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3e8b97d3283f943c8ca5fb4b7a638443", + "name": "aiohttp", + "sha256": "8d59e74d7e6f0dff663225a14eec40bb986e8b855624d5462f6eb7be46273c2c", + "size": 623725, + "subdir": "linux-64", + "timestamp": 1614361065144, + "version": "3.7.4" + }, + "aiohttp-3.7.4-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<7.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ab3038f52eeb061c1d2c560a9ec4962a", + "name": "aiohttp", + "sha256": "77e3c1269b9fd810e21026ce626c246944251cf9e01aaa3b0cdf133f28db9268", + "size": 633317, + "subdir": "linux-64", + "timestamp": 1614361051112, + "version": "3.7.4" + }, + "aiohttp-3.7.4-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<7.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "84bb0fb3da0dbfd982b04e550de75bc6", + "name": "aiohttp", + "sha256": "ae260486950151591de55fbccf8876439b60f91025206c04849c45948dafaee0", + "size": 630954, + "subdir": "linux-64", + "timestamp": 1614361065092, + "version": "3.7.4" + }, + "aiohttp-3.7.4-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<7.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bc9512da3f9fbe965556b71a441ba7b7", + "name": "aiohttp", + "sha256": "78a28a289506d26ef0ee2d41b2b7d35c82e77eaabda57ef8c52c91bc16872864", + "size": 640433, + "subdir": "linux-64", + "timestamp": 1614361043162, + "version": "3.7.4" + }, + "aiohttp-3.7.4.post0-py310h7f8727e_2.tar.bz2": { + "build": "py310h7f8727e_2", + "build_number": 2, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<5.0", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.10,<3.11.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0518ffb51288fda1f69ce14762d322d7", + "name": "aiohttp", + "sha256": "72a2151fd4a666079c518d73028dade6c1eeeeb6f5607b652e878579966e6fe4", + "size": 1188924, + "subdir": "linux-64", + "timestamp": 1640811543714, + "version": "3.7.4.post0" + }, + "aiohttp-3.7.4.post0-py36h7f8727e_2.tar.bz2": { + "build": "py36h7f8727e_2", + "build_number": 2, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<5.0", + "idna_ssl >=1.0", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.6,<3.7.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "650828938338065907bfde6e702392fe", + "name": "aiohttp", + "sha256": "254c98765cfe395ea118787fa5bcc36abe68025de8149b02f9497f329fb55544", + "size": 652941, + "subdir": "linux-64", + "timestamp": 1632748137770, + "version": "3.7.4.post0" + }, + "aiohttp-3.7.4.post0-py37h7f8727e_2.tar.bz2": { + "build": "py37h7f8727e_2", + "build_number": 2, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<5.0", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "46065d79915ff5808e37ea73fc5d28a3", + "name": "aiohttp", + "sha256": "c9629ae1531a6fe441e64eb1b5caf83e14540567048fe66421fda73148ea70e7", + "size": 651002, + "subdir": "linux-64", + "timestamp": 1632748484944, + "version": "3.7.4.post0" + }, + "aiohttp-3.7.4.post0-py38h7f8727e_2.tar.bz2": { + "build": "py38h7f8727e_2", + "build_number": 2, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<5.0", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e4a65a9ca7277bd1f2b130cddbb5bff6", + "name": "aiohttp", + "sha256": "10cdc4432c61cef91e3697b17dc544b2624814828242444dc3453ca1e4f65b36", + "size": 652076, + "subdir": "linux-64", + "timestamp": 1632748471029, + "version": "3.7.4.post0" + }, + "aiohttp-3.7.4.post0-py39h7f8727e_2.tar.bz2": { + "build": "py39h7f8727e_2", + "build_number": 2, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<5.0", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5e6c99b1d9a4ed4a7651bdd3e85b77e4", + "name": "aiohttp", + "sha256": "634b91c366acbc9c8d00e375d757b4dbd6c19f111fd056a1d0292a09077156ef", + "size": 646957, + "subdir": "linux-64", + "timestamp": 1632748481730, + "version": "3.7.4.post0" + }, + "aiohttp-3.8.1-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.10,<3.11.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cc0af5c9ca000d0db33985b175488eef", + "name": "aiohttp", + "sha256": "14fa4ec9905c3d2a8ba17223be954a4c2b2110e183d60b76206a0965cb75b042", + "size": 1117137, + "subdir": "linux-64", + "timestamp": 1646806430383, + "version": "3.8.1" + }, + "aiohttp-3.8.1-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "asynctest 0.13.0.*", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "80fc3c0807f2dacc240b0eca80f1cb93", + "name": "aiohttp", + "sha256": "af6a922ddc47ce9becd9bf24cad6e3588521e0cd1b5e849bf13c31630f1781d0", + "size": 567563, + "subdir": "linux-64", + "timestamp": 1637857146913, + "version": "3.8.1" + }, + "aiohttp-3.8.1-py37h7f8727e_1.tar.bz2": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "asynctest 0.13.0.*", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "523f04d1335459f13960e4b184bd36a3", + "name": "aiohttp", + "sha256": "ddc3a7ae53ef90fbb7e35c586f02402bf128ec845fd657a54af7ccb6ac7929d9", + "size": 594863, + "subdir": "linux-64", + "timestamp": 1646788290611, + "version": "3.8.1" + }, + "aiohttp-3.8.1-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.8,<3.9.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "da715d1959c178ca0afaa2de6d6fb05b", + "name": "aiohttp", + "sha256": "62f4fe8b208513d8968ec0826d743bdd5a4f118766a509609f235febb42402c1", + "size": 595445, + "subdir": "linux-64", + "timestamp": 1637844213877, + "version": "3.8.1" + }, + "aiohttp-3.8.1-py38h7f8727e_1.tar.bz2": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.8,<3.9.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "27e8f6af27bffb51cec79a177293dab8", + "name": "aiohttp", + "sha256": "565a1249a12b5a7bd97b55597da9e6b542dc456480c415a1fe38f05f5d80ff40", + "size": 586556, + "subdir": "linux-64", + "timestamp": 1646806416719, + "version": "3.8.1" + }, + "aiohttp-3.8.1-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.9,<3.10.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e073578fddf3ddfbc948141b7bb5c672", + "name": "aiohttp", + "sha256": "07e756e5d2007a9698e13f28972769c35ab081fb19462371ffc7c74fef030f8b", + "size": 594203, + "subdir": "linux-64", + "timestamp": 1637856948637, + "version": "3.8.1" + }, + "aiohttp-3.8.1-py39h7f8727e_1.tar.bz2": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.9,<3.10.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "371d5a9514830bd15ddb3a0d72066d70", + "name": "aiohttp", + "sha256": "c9bd89828322905ab8ca293888b881ec92e537c422b70b2a25ca1c9d01aeb942", + "size": 593950, + "subdir": "linux-64", + "timestamp": 1646806413651, + "version": "3.8.1" + }, + "aiohttp-3.8.3-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=11.2.0", + "multidict >=4.5,<7.0", + "python >=3.10,<3.11.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "82f0f8d99c5d15a3828c7c87f2e48ba0", + "name": "aiohttp", + "sha256": "7e047fcef1a0c20c1eec61fd8497e1a59af430fdce83d8ba7f63f2430ab29062", + "size": 459588, + "subdir": "linux-64", + "timestamp": 1670009644981, + "version": "3.8.3" + }, + "aiohttp-3.8.3-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=11.2.0", + "multidict >=4.5,<7.0", + "python >=3.11,<3.12.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5460f99e14a5901a6ca9e252f37153b6", + "name": "aiohttp", + "sha256": "114a50d2f5383be5eba8e477f185c77589321874ab66704324708b23014900fb", + "size": 567347, + "subdir": "linux-64", + "timestamp": 1676827647590, + "version": "3.8.3" + }, + "aiohttp-3.8.3-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "asynctest 0.13.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=11.2.0", + "multidict >=4.5,<7.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "59ea9441a1d8e41a5f89edf0ac7eb8f8", + "name": "aiohttp", + "sha256": "acea88f375e5cde90f64379f2114d9c27916d4415ba8856748e0aac2bb07098c", + "size": 448992, + "subdir": "linux-64", + "timestamp": 1670009606141, + "version": "3.8.3" + }, + "aiohttp-3.8.3-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=11.2.0", + "multidict >=4.5,<7.0", + "python >=3.8,<3.9.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cf2267c05a5ccdf21acd70db95778fc9", + "name": "aiohttp", + "sha256": "d83ca069e82b3defa95c6aa851f760aac76d6892ca96bb4d7919586d7c79e42e", + "size": 457800, + "subdir": "linux-64", + "timestamp": 1670009721104, + "version": "3.8.3" + }, + "aiohttp-3.8.3-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=11.2.0", + "multidict >=4.5,<7.0", + "python >=3.9,<3.10.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b65ef2b07101482f0b999a3992fd4ca2", + "name": "aiohttp", + "sha256": "06abb39e87c6a4601964e3752d9819cb80efdc9c8a8a461fac81c3dd51463e28", + "size": 457114, + "subdir": "linux-64", + "timestamp": 1670009682967, + "version": "3.8.3" + }, + "aiopg-1.3.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<5.0", + "psycopg2 >=2.8.4", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e3d5e6d0bb7d61127664d168d2a8dfe1", + "name": "aiopg", + "sha256": "c8fb5dd1af634ec83248c48be83b62708be2e2e64f16088850715c510acd0de6", + "size": 59435, + "subdir": "linux-64", + "timestamp": 1663356775079, + "version": "1.3.4" + }, + "aiopg-1.3.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<5.0", + "psycopg2 >=2.8.4", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "43c75a6a801059a596fcc5128882d2f7", + "name": "aiopg", + "sha256": "2884533c26c12ec08361c585f1944d5a378f6d42e89d38d0e382d518f083d0b6", + "size": 75864, + "subdir": "linux-64", + "timestamp": 1679340077473, + "version": "1.3.4" + }, + "aiopg-1.3.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<5.0", + "psycopg2 >=2.8.4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9949186ab8737fd9ee2968c73cc88e87", + "name": "aiopg", + "sha256": "8f4f35ce85939f525facfdd88ea2d5263998eef7e219d8c9e8e5803eed9a1f2a", + "size": 57709, + "subdir": "linux-64", + "timestamp": 1663356856201, + "version": "1.3.4" + }, + "aiopg-1.3.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<5.0", + "psycopg2 >=2.8.4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ce3fbd1e7d5f06c7493bed59c0798f2c", + "name": "aiopg", + "sha256": "499b1070af45c9542c69d2fee85bbad9f45b1170de30ac065392a3dc6cfd9484", + "size": 58276, + "subdir": "linux-64", + "timestamp": 1663356801538, + "version": "1.3.4" + }, + "aiopg-1.3.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<5.0", + "psycopg2 >=2.8.4", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "1b4750cfc23658c09bdeaca65b125cb2", + "name": "aiopg", + "sha256": "e58f583bbb6a5a223092dc35525aba37887da6a9046ca27f7139a2e73182ade0", + "size": 58392, + "subdir": "linux-64", + "timestamp": 1663356829126, + "version": "1.3.4" + }, + "aiorwlock-1.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "232fa5dce7647eafb8ee829b127a6d44", + "name": "aiorwlock", + "sha256": "5917fffba5a354a6ef2d267ccb2fce762b2ec527d687bc900f12ea39bafa21d8", + "size": 17619, + "subdir": "linux-64", + "timestamp": 1677738263770, + "version": "1.3.0" + }, + "aiorwlock-1.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "092d9472dbc588e2f1b7a6c76c324f10", + "name": "aiorwlock", + "sha256": "fc1f0c2b7811bea5ca4995a9cb9ac2eb7267ca0f74ccdeb79f53704f5a78527d", + "size": 17522, + "subdir": "linux-64", + "timestamp": 1677738215264, + "version": "1.3.0" + }, + "aiorwlock-1.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8873a6bb29cebfbaad8cb20c8c193169", + "name": "aiorwlock", + "sha256": "8afa8cbae47768b16ad8dbe11a9469709cbabd0f88cf20f934f4c425de7ada0e", + "size": 17528, + "subdir": "linux-64", + "timestamp": 1677738239438, + "version": "1.3.0" + }, + "airflow-1.10.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alembic >=1.0,<2.0", + "argcomplete >=1.10.0", + "attrs >=19.3,<19.4", + "cached-property >=1.5.0,<1.6.0", + "cattrs >=0.9", + "colorlog >=4.0.2", + "configparser >=3.5.0", + "croniter >=0.3.17,<0.4", + "dill >=0.2.2,<0.4", + "flask >=1.1.0,<2.0", + "flask-admin 1.5.4", + "flask-appbuilder >=2.2,<2.3", + "flask-caching >=1.3.3", + "flask-login >=0.3,<0.5", + "flask-swagger 0.2.13", + "flask-wtf >=0.14.2,<0.15", + "funcsigs >=1.0.0,<2.0.0", + "future >=0.16.0,<0.19", + "gunicorn >=19.5.0", + "iso8601 >=0.1.12", + "jinja2 >=2.10.1", + "json-merge-patch 0.2", + "jsonschema >=3.0.0,<3.1.0", + "lazy-object-proxy >=1.3.0", + "markdown >=2.5.2", + "pandas >=0.17.1", + "pendulum 1.4.4", + "psutil >=4.2.0,<6.0.0", + "pygments >=2.0.1,<3.0", + "python >=3.6,<3.7.0a0", + "python-daemon >=2.1.1", + "python-dateutil >=2.3,<3", + "python-graphviz >=0.12", + "pytzdata >=2018.3", + "requests >=2.20.0,<3", + "setproctitle >=1.1.8,<2", + "sqlalchemy >=1.3.0,<1.4.0", + "sqlalchemy-jsonfield >=0.9.0,<0.10.0", + "tabulate >=0.7.5,<0.9", + "tenacity", + "termcolor >=1.1.0", + "text-unidecode >=1.2,<2.0", + "thrift >=0.9.2", + "typing_extensions >=3.7.4", + "tzlocal >=1.4", + "unicodecsv >=0.14.1", + "werkzeug", + "zope.deprecation >=4.0,<5.0" + ], + "license": "Apache 2.0", + "md5": "8dc6b03055daa57dedbf405e84ab453f", + "name": "airflow", + "sha256": "fe551fb03599ac27a3833634f185e82cb3e01af4185db0a13df6f850e56d88ac", + "size": 3430171, + "subdir": "linux-64", + "timestamp": 1593114339987, + "version": "1.10.10" + }, + "airflow-1.10.10-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alembic >=1.0,<2.0", + "argcomplete >=1.10.0", + "attrs >=19.3,<19.4", + "cached-property >=1.5.0,<1.6.0", + "cattrs >=0.9", + "colorlog >=4.0.2", + "configparser >=3.5.0", + "croniter >=0.3.17,<0.4", + "dill >=0.2.2,<0.4", + "flask >=1.1.0,<2.0", + "flask-admin 1.5.4", + "flask-appbuilder >=2.2,<2.3", + "flask-caching >=1.3.3", + "flask-login >=0.3,<0.5", + "flask-swagger 0.2.13", + "flask-wtf >=0.14.2,<0.15", + "funcsigs >=1.0.0,<2.0.0", + "future >=0.16.0,<0.19", + "gunicorn >=19.5.0", + "iso8601 >=0.1.12", + "jinja2 >=2.10.1", + "json-merge-patch 0.2", + "jsonschema >=3.0.0,<3.1.0", + "lazy-object-proxy >=1.3.0", + "markdown >=2.5.2", + "pandas >=0.17.1", + "pendulum 1.4.4", + "psutil >=4.2.0,<6.0.0", + "pygments >=2.0.1,<3.0", + "python >=3.7,<3.8.0a0", + "python-daemon >=2.1.1", + "python-dateutil >=2.3,<3", + "python-graphviz >=0.12", + "pytzdata >=2018.3", + "requests >=2.20.0,<3", + "setproctitle >=1.1.8,<2", + "sqlalchemy >=1.3.0,<1.4.0", + "sqlalchemy-jsonfield >=0.9.0,<0.10.0", + "tabulate >=0.7.5,<0.9", + "tenacity", + "termcolor >=1.1.0", + "text-unidecode >=1.2,<2.0", + "thrift >=0.9.2", + "typing_extensions >=3.7.4", + "tzlocal >=1.4", + "unicodecsv >=0.14.1", + "werkzeug", + "zope.deprecation >=4.0,<5.0" + ], + "license": "Apache 2.0", + "md5": "a2ac2a58bd71b31e7c122bf76ad058dd", + "name": "airflow", + "sha256": "6916eba3f98d7e24ca32da5ce8e7e9ab9b7527e6fab5467453da169e912621fa", + "size": 3417957, + "subdir": "linux-64", + "timestamp": 1593114363616, + "version": "1.10.10" + }, + "airflow-1.10.10-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "alembic >=1.0,<2.0", + "argcomplete >=1.10.0", + "attrs >=19.3,<19.4", + "cached-property >=1.5.0,<1.6.0", + "cattrs >=1.0,<1.1.0", + "colorlog >=4.0.2", + "configparser >=3.5.0", + "croniter >=0.3.17,<0.4", + "dill >=0.2.2,<0.4", + "flask >=1.1.0,<2.0", + "flask-admin 1.5.4", + "flask-appbuilder >=2.2,<2.3", + "flask-caching >=1.3.3", + "flask-login >=0.3,<0.5", + "flask-swagger 0.2.13", + "flask-wtf >=0.14.2,<0.15", + "funcsigs >=1.0.0,<2.0.0", + "future >=0.16.0,<0.19", + "gunicorn >=19.5.0", + "iso8601 >=0.1.12", + "jinja2 >=2.10.1", + "json-merge-patch 0.2", + "jsonschema >=3.1.0", + "lazy-object-proxy >=1.3.0", + "markdown >=2.5.2", + "pandas >=0.17.1", + "pendulum 1.4.4", + "psutil >=4.2.0,<6.0.0", + "pygments >=2.0.1,<3.0", + "python >=3.8,<3.9.0a0", + "python-daemon >=2.1.1", + "python-dateutil >=2.3,<3", + "python-graphviz >=0.12", + "pytzdata >=2018.3", + "requests >=2.20.0,<3", + "setproctitle >=1.1.8,<2", + "sqlalchemy >=1.3.0,<1.4.0", + "sqlalchemy-jsonfield >=0.9.0,<0.10.0", + "tabulate >=0.7.5,<0.9", + "tenacity", + "termcolor >=1.1.0", + "text-unidecode >=1.2,<2.0", + "thrift >=0.9.2", + "typing_extensions >=3.7.4", + "tzlocal >=1.4", + "unicodecsv >=0.14.1", + "werkzeug", + "zope.deprecation >=4.0,<5.0" + ], + "license": "Apache 2.0", + "md5": "29d128fa02783549544f0227383d49f4", + "name": "airflow", + "sha256": "38efbe7e97f09b9c917373cf89a09f8ce0015f89feb3abbb00d202a5e5410f80", + "size": 3459804, + "subdir": "linux-64", + "timestamp": 1593114387504, + "version": "1.10.10" + }, + "airflow-1.10.12-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.0,<2.0", + "argcomplete >=1.10.0", + "attrs >=19.3,<19.4", + "cached-property >=1.5.0,<1.6.0", + "cattrs >=1.0,<1.1.0", + "colorlog >=4.0.2", + "configparser >=3.5.0", + "croniter >=0.3.17,<0.4", + "dill >=0.2.2,<0.4", + "flask >=1.1.0,<2.0", + "flask-admin 1.5.4", + "flask-appbuilder >=2.2,<2.3", + "flask-caching >=1.3.3", + "flask-login >=0.3,<0.5", + "flask-swagger 0.2.13", + "flask-wtf >=0.14.2,<0.15", + "funcsigs >=1.0.0,<2.0.0", + "future >=0.16.0,<0.19", + "gunicorn >=19.5.0", + "iso8601 >=0.1.12", + "jinja2 >=2.10.1", + "json-merge-patch 0.2", + "jsonschema >=3.1.0", + "lazy-object-proxy >=1.3.0", + "markdown >=2.5.2", + "pandas >=0.17.1", + "pendulum 1.4.4", + "psutil >=4.2.0,<6.0.0", + "pygments >=2.0.1,<3.0", + "python >=3.10,<3.11.0a0", + "python-daemon >=2.1.1", + "python-dateutil >=2.3,<3", + "python-graphviz >=0.12", + "requests >=2.20.0,<3", + "setproctitle >=1.1.8,<2", + "sqlalchemy >=1.3.0,<1.4.0", + "sqlalchemy-jsonfield >=0.9.0,<0.10.0", + "tabulate >=0.7.5,<0.9", + "tenacity", + "termcolor >=1.1.0", + "text-unidecode >=1.2,<2.0", + "thrift >=0.9.2", + "typing_extensions >=3.7.4", + "tzlocal >=1.4", + "unicodecsv >=0.14.1", + "werkzeug", + "zope.deprecation >=4.0,<5.0" + ], + "license": "Apache 2.0", + "md5": "ad3c9c2888d2b1e95ca392c767137c19", + "name": "airflow", + "sha256": "447eadb36664353f38dfa300af575d85484e0dc7c177d8660c63f20b989903d1", + "size": 3629340, + "subdir": "linux-64", + "timestamp": 1640811623023, + "version": "1.10.12" + }, + "airflow-1.10.12-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.0,<2.0", + "argcomplete >=1.10.0", + "attrs >=19.3,<19.4", + "cached-property >=1.5.0,<1.6.0", + "cattrs >=0.9,<0.10.0", + "colorlog >=4.0.2", + "configparser >=3.5.0", + "croniter >=0.3.17,<0.4", + "dill >=0.2.2,<0.4", + "flask >=1.1.0,<2.0", + "flask-admin 1.5.4", + "flask-appbuilder >=2.2,<2.3", + "flask-caching >=1.3.3", + "flask-login >=0.3,<0.5", + "flask-swagger 0.2.13", + "flask-wtf >=0.14.2,<0.15", + "funcsigs >=1.0.0,<2.0.0", + "future >=0.16.0,<0.19", + "gunicorn >=19.5.0", + "iso8601 >=0.1.12", + "jinja2 >=2.10.1", + "json-merge-patch 0.2", + "jsonschema >=3.0.0,<3.1.0", + "lazy-object-proxy >=1.3.0", + "markdown >=2.5.2", + "pandas >=0.17.1", + "pendulum 1.4.4", + "psutil >=4.2.0,<6.0.0", + "pygments >=2.0.1,<3.0", + "python >=3.6,<3.7.0a0", + "python-daemon >=2.1.1", + "python-dateutil >=2.3,<3", + "python-graphviz >=0.12", + "requests >=2.20.0,<3", + "setproctitle >=1.1.8,<2", + "sqlalchemy >=1.3.0,<1.4.0", + "sqlalchemy-jsonfield >=0.9.0,<0.10.0", + "tabulate >=0.7.5,<0.9", + "tenacity", + "termcolor >=1.1.0", + "text-unidecode >=1.2,<2.0", + "thrift >=0.9.2", + "typing_extensions >=3.7.4", + "tzlocal >=1.4", + "unicodecsv >=0.14.1", + "werkzeug", + "zope.deprecation >=4.0,<5.0" + ], + "license": "Apache 2.0", + "md5": "94275ec44be7ab3991fd9eec947a584f", + "name": "airflow", + "sha256": "1a914ead15385c49ce69bbaaea75d56674a5919f970b759ffb5143521a0ade64", + "size": 3558600, + "subdir": "linux-64", + "timestamp": 1605878117413, + "version": "1.10.12" + }, + "airflow-1.10.12-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.0,<2.0", + "argcomplete >=1.10.0", + "attrs >=19.3,<19.4", + "cached-property >=1.5.0,<1.6.0", + "cattrs >=0.9,<0.10.0", + "colorlog >=4.0.2", + "configparser >=3.5.0", + "croniter >=0.3.17,<0.4", + "dill >=0.2.2,<0.4", + "flask >=1.1.0,<2.0", + "flask-admin 1.5.4", + "flask-appbuilder >=2.2,<2.3", + "flask-caching >=1.3.3", + "flask-login >=0.3,<0.5", + "flask-swagger 0.2.13", + "flask-wtf >=0.14.2,<0.15", + "funcsigs >=1.0.0,<2.0.0", + "future >=0.16.0,<0.19", + "gunicorn >=19.5.0", + "iso8601 >=0.1.12", + "jinja2 >=2.10.1", + "json-merge-patch 0.2", + "jsonschema >=3.0.0,<3.1.0", + "lazy-object-proxy >=1.3.0", + "markdown >=2.5.2", + "pandas >=0.17.1", + "pendulum 1.4.4", + "psutil >=4.2.0,<6.0.0", + "pygments >=2.0.1,<3.0", + "python >=3.7,<3.8.0a0", + "python-daemon >=2.1.1", + "python-dateutil >=2.3,<3", + "python-graphviz >=0.12", + "requests >=2.20.0,<3", + "setproctitle >=1.1.8,<2", + "sqlalchemy >=1.3.0,<1.4.0", + "sqlalchemy-jsonfield >=0.9.0,<0.10.0", + "tabulate >=0.7.5,<0.9", + "tenacity", + "termcolor >=1.1.0", + "text-unidecode >=1.2,<2.0", + "thrift >=0.9.2", + "typing_extensions >=3.7.4", + "tzlocal >=1.4", + "unicodecsv >=0.14.1", + "werkzeug", + "zope.deprecation >=4.0,<5.0" + ], + "license": "Apache 2.0", + "md5": "b766d5395bce131617b7470d62ee609c", + "name": "airflow", + "sha256": "d1d9323880ac2ac59ee8637e5fd4da2a7a4be37ba57478f76f4eb2510b50ff83", + "size": 3556313, + "subdir": "linux-64", + "timestamp": 1605878068062, + "version": "1.10.12" + }, + "airflow-1.10.12-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.0,<2.0", + "argcomplete >=1.10.0", + "attrs >=19.3,<19.4", + "cached-property >=1.5.0,<1.6.0", + "cattrs >=1.0,<1.1.0", + "colorlog >=4.0.2", + "configparser >=3.5.0", + "croniter >=0.3.17,<0.4", + "dill >=0.2.2,<0.4", + "flask >=1.1.0,<2.0", + "flask-admin 1.5.4", + "flask-appbuilder >=2.2,<2.3", + "flask-caching >=1.3.3", + "flask-login >=0.3,<0.5", + "flask-swagger 0.2.13", + "flask-wtf >=0.14.2,<0.15", + "funcsigs >=1.0.0,<2.0.0", + "future >=0.16.0,<0.19", + "gunicorn >=19.5.0", + "iso8601 >=0.1.12", + "jinja2 >=2.10.1", + "json-merge-patch 0.2", + "jsonschema >=3.1.0", + "lazy-object-proxy >=1.3.0", + "markdown >=2.5.2", + "pandas >=0.17.1", + "pendulum 1.4.4", + "psutil >=4.2.0,<6.0.0", + "pygments >=2.0.1,<3.0", + "python >=3.8,<3.9.0a0", + "python-daemon >=2.1.1", + "python-dateutil >=2.3,<3", + "python-graphviz >=0.12", + "requests >=2.20.0,<3", + "setproctitle >=1.1.8,<2", + "sqlalchemy >=1.3.0,<1.4.0", + "sqlalchemy-jsonfield >=0.9.0,<0.10.0", + "tabulate >=0.7.5,<0.9", + "tenacity", + "termcolor >=1.1.0", + "text-unidecode >=1.2,<2.0", + "thrift >=0.9.2", + "typing_extensions >=3.7.4", + "tzlocal >=1.4", + "unicodecsv >=0.14.1", + "werkzeug", + "zope.deprecation >=4.0,<5.0" + ], + "license": "Apache 2.0", + "md5": "ddcefb35e8ce4e90081691212b782c22", + "name": "airflow", + "sha256": "d439eb27742829463185ee7667f1746c6a34ce64809b63caf461e9849f72b3d9", + "size": 3566565, + "subdir": "linux-64", + "timestamp": 1605878092698, + "version": "1.10.12" + }, + "airflow-1.10.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alembic >=1.0,<2.0", + "argcomplete >=1.10.0,<1.11.0", + "backports", + "cached-property >=1.5.0,<1.6.0", + "cattrs >=0.9,<0.10.0", + "colorlog 4.0.2", + "configparser >=3.5.0,<3.6.0", + "croniter >=0.3.17,<0.4", + "dill >=0.2.2,<0.4", + "flask >=1.1.0,<2.0", + "flask-admin 1.5.3", + "flask-appbuilder >=1.12.5,<2.0.0", + "flask-caching >=1.3.3,<1.4.0", + "flask-login >=0.3,<0.5", + "flask-swagger 0.2.13", + "flask-wtf >=0.14.2,<0.15", + "funcsigs >=1.0.2,<2.0.0", + "future >=0.16.0,<0.17", + "gunicorn >=19.5.0,<20.0", + "iso8601 >=0.1.12", + "jinja2 >=2.10.1,<2.11.0", + "json-merge-patch 0.2", + "jsonschema >=3.0.0,<4.0.0", + "lazy-object-proxy >=1.3.0,<1.4.0", + "markdown >=2.5.2,<3.0", + "pandas >=0.17.1,<1.0.0", + "pendulum 1.4.4", + "psutil >=4.2.0,<6.0.0", + "pygments >=2.0.1,<3.0", + "python >=3.6,<3.7.0a0", + "python-daemon >=2.1.1,<2.2", + "python-dateutil >=2.3,<3", + "python-graphviz >=0.12", + "requests >=2.20.0,<3", + "setproctitle >=1.1.8,<2", + "sqlalchemy >=1.3.0,<1.4.0", + "sqlalchemy-jsonfield >=0.9.0,<0.10.0", + "tabulate >=0.7.5,<0.9", + "tenacity 4.12.0", + "termcolor 1.1.0", + "text-unidecode 1.2", + "thrift >=0.9.2", + "typing_extensions >=3.7.4", + "tzlocal >=1.4,<2.0.0", + "unicodecsv >=0.14.1", + "zope.deprecation >=4.0,<5.0" + ], + "license": "Apache 2.0", + "md5": "b7dbcc44df61f4f94e8c0b0065e903c2", + "name": "airflow", + "sha256": "2030851f38d45e7cceeeec5492364cb9d43d7fb707c60b310e635281b6db8a3f", + "size": 3326030, + "subdir": "linux-64", + "timestamp": 1579721342751, + "version": "1.10.7" + }, + "airflow-1.10.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alembic >=1.0,<2.0", + "argcomplete >=1.10.0,<1.11.0", + "backports", + "cached-property >=1.5.0,<1.6.0", + "cattrs >=0.9,<0.10.0", + "colorlog 4.0.2", + "configparser >=3.5.0,<3.6.0", + "croniter >=0.3.17,<0.4", + "dill >=0.2.2,<0.4", + "flask >=1.1.0,<2.0", + "flask-admin 1.5.3", + "flask-appbuilder >=1.12.5,<2.0.0", + "flask-caching >=1.3.3,<1.4.0", + "flask-login >=0.3,<0.5", + "flask-swagger 0.2.13", + "flask-wtf >=0.14.2,<0.15", + "funcsigs >=1.0.2,<2.0.0", + "future >=0.16.0,<0.17", + "gunicorn >=19.5.0,<20.0", + "iso8601 >=0.1.12", + "jinja2 >=2.10.1,<2.11.0", + "json-merge-patch 0.2", + "jsonschema >=3.0.0,<4.0.0", + "lazy-object-proxy >=1.3.0,<1.4.0", + "markdown >=2.5.2,<3.0", + "pandas >=0.17.1,<1.0.0", + "pendulum 1.4.4", + "psutil >=4.2.0,<6.0.0", + "pygments >=2.0.1,<3.0", + "python >=3.7,<3.8.0a0", + "python-daemon >=2.1.1,<2.2", + "python-dateutil >=2.3,<3", + "python-graphviz >=0.12", + "requests >=2.20.0,<3", + "setproctitle >=1.1.8,<2", + "sqlalchemy >=1.3.0,<1.4.0", + "sqlalchemy-jsonfield >=0.9.0,<0.10.0", + "tabulate >=0.7.5,<0.9", + "tenacity 4.12.0", + "termcolor 1.1.0", + "text-unidecode 1.2", + "thrift >=0.9.2", + "typing_extensions >=3.7.4", + "tzlocal >=1.4,<2.0.0", + "unicodecsv >=0.14.1", + "zope.deprecation >=4.0,<5.0" + ], + "license": "Apache 2.0", + "md5": "c66fa62f5ca098fbde7d2e324924504a", + "name": "airflow", + "sha256": "d76743af91a6fcb2190286970a740cb2adfd1f98274a36d934422e6b55f95e6a", + "size": 3442871, + "subdir": "linux-64", + "timestamp": 1579721367255, + "version": "1.10.7" + }, + "airflow-2.3.3-py310h02b9991_0.tar.bz2": { + "build": "py310h02b9991_0", + "build_number": 0, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=20.0,<21.0", + "blinker", + "cattrs >=1.1,<2,!=1.7.*", + "colorlog >=4.0.2,<5.0", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=1.0.4,<3", + "flask >=2.0", + "flask-appbuilder 4.1.2.*", + "flask-caching >=1.5.0", + "flask-login >=0.5", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=19.5.0", + "httpx", + "itsdangerous >=0.24", + "itsdangerous >=2.0", + "jinja2 >=2.10.1", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1q,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.10,<3.11.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=3.7.4", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "md5": "0c3f7c1054a1fb6afe6b2a2f884b4982", + "name": "airflow", + "sha256": "30632e17ae0265125b1ce680b2ae538918b9fba1a851807a237a2c4f6acae432", + "size": 4902501, + "subdir": "linux-64", + "timestamp": 1659883887663, + "version": "2.3.3" + }, + "airflow-2.3.3-py310h02b9991_1.tar.bz2": { + "build": "py310h02b9991_1", + "build_number": 1, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=20.0,<21.0", + "blinker", + "cattrs >=1.1,<2,!=1.7.*", + "colorlog >=4.0.2,<5.0", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=1.0.4,<3", + "flask >=2.0", + "flask-appbuilder 4.1.2.*", + "flask-caching >=1.5.0", + "flask-login >=0.5", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=19.5.0", + "httpx", + "itsdangerous >=0.24", + "itsdangerous >=2.0", + "jinja2 >=2.10.1", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1q,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.10,<3.11.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=3.7.4", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "md5": "11de0cad45636d02ab6b0f952e7cc22c", + "name": "airflow", + "sha256": "808e58f5832af203691b512581373460b7ee245fbdec2851aba03dfa5658c41d", + "size": 4910966, + "subdir": "linux-64", + "timestamp": 1659934742234, + "version": "2.3.3" + }, + "airflow-2.3.3-py37h02b9991_0.tar.bz2": { + "build": "py37h02b9991_0", + "build_number": 0, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=20.0,<21.0", + "blinker", + "cached-property >=1.5", + "cattrs >=1.1,<2,!=1.7.*", + "colorlog >=4.0.2,<5.0", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=1.0.4,<3", + "flask >=2.0", + "flask-appbuilder 4.1.2.*", + "flask-caching >=1.5.0", + "flask-login >=0.5", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=19.5.0", + "httpx", + "importlib_metadata >=1.7", + "importlib_resources >=5.2", + "itsdangerous >=0.24", + "itsdangerous >=2.0", + "jinja2 >=2.10.1", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1q,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.7,<3.8.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=3.7.4", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "md5": "718c72bfa54d252ca4753c50dea89cb1", + "name": "airflow", + "sha256": "780ae96eab954c01e64e79baecc83a3714213baee15e47bf4b0d54144b925dfe", + "size": 4874560, + "subdir": "linux-64", + "timestamp": 1659883681842, + "version": "2.3.3" + }, + "airflow-2.3.3-py37h02b9991_1.tar.bz2": { + "build": "py37h02b9991_1", + "build_number": 1, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=20.0,<21.0", + "blinker", + "cached-property >=1.5", + "cattrs >=1.1,<2,!=1.7.*", + "colorlog >=4.0.2,<5.0", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=1.0.4,<3", + "flask >=2.0", + "flask-appbuilder 4.1.2.*", + "flask-caching >=1.5.0", + "flask-login >=0.5", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=19.5.0", + "httpx", + "importlib_metadata >=1.7", + "importlib_resources >=5.2", + "itsdangerous >=0.24", + "itsdangerous >=2.0", + "jinja2 >=2.10.1", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1q,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.7,<3.8.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=3.7.4", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "md5": "863a4188ca9433c0d8d3bae39ebf24ef", + "name": "airflow", + "sha256": "38024409841dc2d2965ef4b1beb7db9a36ab9bfe40526d0206e73b0622b99733", + "size": 4889995, + "subdir": "linux-64", + "timestamp": 1659934601899, + "version": "2.3.3" + }, + "airflow-2.3.3-py38h02b9991_0.tar.bz2": { + "build": "py38h02b9991_0", + "build_number": 0, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=20.0,<21.0", + "blinker", + "cattrs >=1.1,<2,!=1.7.*", + "colorlog >=4.0.2,<5.0", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=1.0.4,<3", + "flask >=2.0", + "flask-appbuilder 4.1.2.*", + "flask-caching >=1.5.0", + "flask-login >=0.5", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=19.5.0", + "httpx", + "importlib_metadata >=1.7", + "importlib_resources >=5.2", + "itsdangerous >=0.24", + "itsdangerous >=2.0", + "jinja2 >=2.10.1", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1q,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.8,<3.9.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=3.7.4", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "md5": "6dc6b40b98c1bcb9f237340966cef2f1", + "name": "airflow", + "sha256": "147e2c4bcc4b5e8b844079587914ab8331b06d46fae139674f7cd014185e4feb", + "size": 4874563, + "subdir": "linux-64", + "timestamp": 1659883746797, + "version": "2.3.3" + }, + "airflow-2.3.3-py38h02b9991_1.tar.bz2": { + "build": "py38h02b9991_1", + "build_number": 1, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=20.0,<21.0", + "blinker", + "cattrs >=1.1,<2,!=1.7.*", + "colorlog >=4.0.2,<5.0", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=1.0.4,<3", + "flask >=2.0", + "flask-appbuilder 4.1.2.*", + "flask-caching >=1.5.0", + "flask-login >=0.5", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=19.5.0", + "httpx", + "importlib_metadata >=1.7", + "importlib_resources >=5.2", + "itsdangerous >=0.24", + "itsdangerous >=2.0", + "jinja2 >=2.10.1", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1q,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.8,<3.9.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=3.7.4", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "md5": "c64d3740e8f5844b901cd6bc82903cfd", + "name": "airflow", + "sha256": "3247ccf389b9fb76058d089b4c138482af9d72b084fe1e247a1a51927a84ee0b", + "size": 4895473, + "subdir": "linux-64", + "timestamp": 1659934809407, + "version": "2.3.3" + }, + "airflow-2.3.3-py39h02b9991_0.tar.bz2": { + "build": "py39h02b9991_0", + "build_number": 0, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=20.0,<21.0", + "blinker", + "cattrs >=1.1,<2,!=1.7.*", + "colorlog >=4.0.2,<5.0", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=1.0.4,<3", + "flask >=2.0", + "flask-appbuilder 4.1.2.*", + "flask-caching >=1.5.0", + "flask-login >=0.5", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=19.5.0", + "httpx", + "itsdangerous >=0.24", + "itsdangerous >=2.0", + "jinja2 >=2.10.1", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1q,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.9,<3.10.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=3.7.4", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "md5": "5cd610708a70ec6894ec75883aca87e4", + "name": "airflow", + "sha256": "fd9a2a4ade922287705a3632de1cd829abe49beec0b2b10c58dbfb128eaca042", + "size": 4881420, + "subdir": "linux-64", + "timestamp": 1659883819307, + "version": "2.3.3" + }, + "airflow-2.3.3-py39h02b9991_1.tar.bz2": { + "build": "py39h02b9991_1", + "build_number": 1, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=20.0,<21.0", + "blinker", + "cattrs >=1.1,<2,!=1.7.*", + "colorlog >=4.0.2,<5.0", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=1.0.4,<3", + "flask >=2.0", + "flask-appbuilder 4.1.2.*", + "flask-caching >=1.5.0", + "flask-login >=0.5", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=19.5.0", + "httpx", + "itsdangerous >=0.24", + "itsdangerous >=2.0", + "jinja2 >=2.10.1", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1q,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.9,<3.10.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=3.7.4", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "md5": "8e7dbf02424cfb5dbc918a4d6adcb998", + "name": "airflow", + "sha256": "4c43773af45ef89a4e33cc35e0ab993d9df90273622e722ddd7cec6b459c62da", + "size": 4908821, + "subdir": "linux-64", + "timestamp": 1659934674503, + "version": "2.3.3" + }, + "airflow-2.4.3-py310h02b9991_0.tar.bz2": { + "build": "py310h02b9991_0", + "build_number": 0, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-common-sql", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=22.1.0", + "blinker", + "cattrs >=22.1.0", + "colorlog >=4.0.2,<5.0", + "configupdater >=3.1.1", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=2.2,<2.3", + "flask-appbuilder 4.1.4.*", + "flask-caching >=1.5.0", + "flask-login >=0.6.2", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=20.1.0", + "httpx", + "itsdangerous >=2.0", + "jinja2 >=3.0.0", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1s,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.10,<3.11.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=4.0.0", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1a3d92b0dc83410e60825964fbd8675b", + "name": "airflow", + "sha256": "9911f7fcc83c078864a692fb3fdf973c185177bf66b06daceca8aa77aef62a16", + "size": 5944299, + "subdir": "linux-64", + "timestamp": 1671226906064, + "version": "2.4.3" + }, + "airflow-2.4.3-py37h02b9991_0.tar.bz2": { + "build": "py37h02b9991_0", + "build_number": 0, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-common-sql", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=22.1.0", + "blinker", + "cached-property >=1.5.0", + "cattrs >=22.1.0", + "colorlog >=4.0.2,<5.0", + "configupdater >=3.1.1", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=2.2,<2.3", + "flask-appbuilder 4.1.4.*", + "flask-caching >=1.5.0", + "flask-login >=0.6.2", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=20.1.0", + "httpx", + "importlib_metadata >=1.7", + "importlib_resources >=5.2", + "itsdangerous >=2.0", + "jinja2 >=3.0.0", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1s,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.7,<3.8.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=4.0.0", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0cf8ad83272d8f64747fa7de27cd0fd2", + "name": "airflow", + "sha256": "2eb872c4f7ccc2ebcf3adf2a72fcdd0570e36133cba1ecce5624ed0ed1344d76", + "size": 5937490, + "subdir": "linux-64", + "timestamp": 1671226732680, + "version": "2.4.3" + }, + "airflow-2.4.3-py38h02b9991_0.tar.bz2": { + "build": "py38h02b9991_0", + "build_number": 0, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-common-sql", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=22.1.0", + "blinker", + "cattrs >=22.1.0", + "colorlog >=4.0.2,<5.0", + "configupdater >=3.1.1", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=2.2,<2.3", + "flask-appbuilder 4.1.4.*", + "flask-caching >=1.5.0", + "flask-login >=0.6.2", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=20.1.0", + "httpx", + "importlib_metadata >=1.7", + "importlib_resources >=5.2", + "itsdangerous >=2.0", + "jinja2 >=3.0.0", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1s,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.8,<3.9.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=4.0.0", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "41e51bcd4486277de2105d58c3fb83a6", + "name": "airflow", + "sha256": "faff2150db2c1ac1cfff80d9be0d2c98ac7b265142e736bc22919322131922c5", + "size": 5945288, + "subdir": "linux-64", + "timestamp": 1671226991456, + "version": "2.4.3" + }, + "airflow-2.4.3-py39h02b9991_0.tar.bz2": { + "build": "py39h02b9991_0", + "build_number": 0, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-common-sql", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=22.1.0", + "blinker", + "cattrs >=22.1.0", + "colorlog >=4.0.2,<5.0", + "configupdater >=3.1.1", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=2.2,<2.3", + "flask-appbuilder 4.1.4.*", + "flask-caching >=1.5.0", + "flask-login >=0.6.2", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=20.1.0", + "httpx", + "itsdangerous >=2.0", + "jinja2 >=3.0.0", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1s,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.9,<3.10.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=4.0.0", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5c2dfff6b35395f48cf871597a9721db", + "name": "airflow", + "sha256": "d3184905886fe509e67904c820160f6853ee1989f218812e9f8b74fe435c52e5", + "size": 5946991, + "subdir": "linux-64", + "timestamp": 1671226820019, + "version": "2.4.3" + }, + "airflow-with-apache-atlas-2.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "atlasclient >=0.1.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "b3380afec4ec4431a401e561aaed892c", + "name": "airflow-with-apache-atlas", + "sha256": "1879786ebaf42b6c9f4db01c17620a99b3e81bdeb74b2141a9fc4e91617a5a47", + "size": 12382, + "subdir": "linux-64", + "timestamp": 1659883914928, + "version": "2.3.3" + }, + "airflow-with-apache-atlas-2.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "atlasclient >=0.1.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "03896a046f7d609cbb98d6e48decaded", + "name": "airflow-with-apache-atlas", + "sha256": "639e544c5a806942a94058697ecc43c00db49330899e16385841a9b0a4938961", + "size": 12361, + "subdir": "linux-64", + "timestamp": 1659934831559, + "version": "2.3.3" + }, + "airflow-with-apache-atlas-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "atlasclient >=0.1.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "a65a445a1c6e78dec590301ae59a29be", + "name": "airflow-with-apache-atlas", + "sha256": "3e7b08165d9e1b8403fb3ad3076da0196dc1bdceb25d40d7b9cbe4eda6951e1c", + "size": 12377, + "subdir": "linux-64", + "timestamp": 1659883898463, + "version": "2.3.3" + }, + "airflow-with-apache-atlas-2.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "atlasclient >=0.1.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "eddd93b3b2e2030166245e0725bdce8b", + "name": "airflow-with-apache-atlas", + "sha256": "60b4da052fc66b78a75a1ee507dc33d246dc86cdd46cc1ac6be6a4295d51430a", + "size": 12361, + "subdir": "linux-64", + "timestamp": 1659934820265, + "version": "2.3.3" + }, + "airflow-with-apache-atlas-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "atlasclient >=0.1.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "b6b7bee169ca2c56c531f61c2e1dd732", + "name": "airflow-with-apache-atlas", + "sha256": "dc5bd963853ee0ccbcb218770861a5fdac442be61a80e9fd0e91ec5eb627b134", + "size": 12363, + "subdir": "linux-64", + "timestamp": 1659883903723, + "version": "2.3.3" + }, + "airflow-with-apache-atlas-2.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "atlasclient >=0.1.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "7d561c46408ba845d37883b2516cac99", + "name": "airflow-with-apache-atlas", + "sha256": "034b7ef0cb732f7a218c37576a625088831309b2bdec49cfc34f849d4df90ab7", + "size": 12342, + "subdir": "linux-64", + "timestamp": 1659934836977, + "version": "2.3.3" + }, + "airflow-with-apache-atlas-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "atlasclient >=0.1.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "bca4e6d0ba7f50f65f4b7527d6d25b5b", + "name": "airflow-with-apache-atlas", + "sha256": "5cb6e50da89088be623720b04f83bb1cca561465771a5252c2349cad802c673e", + "size": 12364, + "subdir": "linux-64", + "timestamp": 1659883909245, + "version": "2.3.3" + }, + "airflow-with-apache-atlas-2.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "atlasclient >=0.1.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "8d3236db5d57cde01668a838bfa6a3e8", + "name": "airflow-with-apache-atlas", + "sha256": "02c98163768442a2203fde4681530958af411022b658bf0e1ecb8a47e925abf8", + "size": 12359, + "subdir": "linux-64", + "timestamp": 1659934825848, + "version": "2.3.3" + }, + "airflow-with-apache-atlas-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "atlasclient >=0.1.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e459b872b0354a7da9da7e4186441c2a", + "name": "airflow-with-apache-atlas", + "sha256": "c48ecf693e12dc62e0024c592ccd101cd8e602f031e2786a84ec362cd2d48be3", + "size": 12381, + "subdir": "linux-64", + "timestamp": 1671227014261, + "version": "2.4.3" + }, + "airflow-with-apache-atlas-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "atlasclient >=0.1.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a4a38854f5f917f1f3c9d975c7db9241", + "name": "airflow-with-apache-atlas", + "sha256": "73bd1d7165e640bde6b6e15faa3fab35514cffb3af179a845175d2e96ee1ad3e", + "size": 12380, + "subdir": "linux-64", + "timestamp": 1671227002720, + "version": "2.4.3" + }, + "airflow-with-apache-atlas-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "atlasclient >=0.1.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cba3a3ece740bb05ccd7e15c050ddb81", + "name": "airflow-with-apache-atlas", + "sha256": "96ef0cf625f9a39285f87d3432ba5665a3570776d5a3bdf8b17159a2eb7b315e", + "size": 12369, + "subdir": "linux-64", + "timestamp": 1671227019837, + "version": "2.4.3" + }, + "airflow-with-apache-atlas-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "atlasclient >=0.1.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "be8d66a73d7910f808904b19789aebfe", + "name": "airflow-with-apache-atlas", + "sha256": "987a7153850ad9c8a30d3430f329d05c7613783603813814d264d1d21d09a7a9", + "size": 12369, + "subdir": "linux-64", + "timestamp": 1671227008338, + "version": "2.4.3" + }, + "airflow-with-apache-webhdfs-2.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "apache-airflow-providers-apache-hdfs", + "python >=3.10,<3.11.0a0", + "python-hdfs >=2.0.4" + ], + "license": "Apache-2.0", + "md5": "af0dbf3e9bfa5353d4c6e1d671e98aa3", + "name": "airflow-with-apache-webhdfs", + "sha256": "c78df88a9dd37aed127b23d7ff69e4cf292d522da4708eec96b7a7a085eba155", + "size": 12382, + "subdir": "linux-64", + "timestamp": 1659934853396, + "version": "2.3.3" + }, + "airflow-with-apache-webhdfs-2.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "apache-airflow-providers-apache-hdfs", + "python >=3.7,<3.8.0a0", + "python-hdfs >=2.0.4" + ], + "license": "Apache-2.0", + "md5": "354ac2953ab1396d902f4afd55915b92", + "name": "airflow-with-apache-webhdfs", + "sha256": "f04bd8087d05cd287ff2d99e42e464e10747aaf8ea855c68f54ed7df671ac9ca", + "size": 12364, + "subdir": "linux-64", + "timestamp": 1659934842249, + "version": "2.3.3" + }, + "airflow-with-apache-webhdfs-2.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "apache-airflow-providers-apache-hdfs", + "python >=3.8,<3.9.0a0", + "python-hdfs >=2.0.4" + ], + "license": "Apache-2.0", + "md5": "80f21d81f2bba69fbbdbf1704db350a6", + "name": "airflow-with-apache-webhdfs", + "sha256": "cf90f5bb68d2f3746e7bb95a27b03f487614a584773fc6687dfcb2d4ccde678f", + "size": 12357, + "subdir": "linux-64", + "timestamp": 1659934858763, + "version": "2.3.3" + }, + "airflow-with-apache-webhdfs-2.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "apache-airflow-providers-apache-hdfs", + "python >=3.9,<3.10.0a0", + "python-hdfs >=2.0.4" + ], + "license": "Apache-2.0", + "md5": "6ab59a4bc53fc022206713001913dd55", + "name": "airflow-with-apache-webhdfs", + "sha256": "a1d158e98fc29a47a70cbe2736a458a9ef09cf0f9643d94a749c1e054107a6ea", + "size": 12378, + "subdir": "linux-64", + "timestamp": 1659934847664, + "version": "2.3.3" + }, + "airflow-with-apache-webhdfs-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "apache-airflow-providers-apache-hdfs", + "python >=3.10,<3.11.0a0", + "python-hdfs >=2.0.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "95be8de82ba5afb10b54b084f78f2961", + "name": "airflow-with-apache-webhdfs", + "sha256": "8098d31edba9210843981cbaf14a5028f6b2510b688220784c212d20100b5385", + "size": 12399, + "subdir": "linux-64", + "timestamp": 1671227036958, + "version": "2.4.3" + }, + "airflow-with-apache-webhdfs-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "apache-airflow-providers-apache-hdfs", + "python >=3.7,<3.8.0a0", + "python-hdfs >=2.0.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4d8f1ad5811ab750e50f527422fcfdc5", + "name": "airflow-with-apache-webhdfs", + "sha256": "ee5ddfb2ac123320bda7bc9b692ffe40c28676fec124e841630205c889bff5ce", + "size": 12382, + "subdir": "linux-64", + "timestamp": 1671227025383, + "version": "2.4.3" + }, + "airflow-with-apache-webhdfs-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "apache-airflow-providers-apache-hdfs", + "python >=3.8,<3.9.0a0", + "python-hdfs >=2.0.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ba63210cfda870aafd1ab896b25a58e0", + "name": "airflow-with-apache-webhdfs", + "sha256": "3ae3b28b72888b33fbee2d37f096e9948f0399330082f7ab3e8b2de4dbfef70c", + "size": 12399, + "subdir": "linux-64", + "timestamp": 1671227042547, + "version": "2.4.3" + }, + "airflow-with-apache-webhdfs-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "apache-airflow-providers-apache-hdfs", + "python >=3.9,<3.10.0a0", + "python-hdfs >=2.0.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "229c39345bc0800f2dfd4d0bd1a7d208", + "name": "airflow-with-apache-webhdfs", + "sha256": "60bfa4016d8748f6c5638fb3239593c9a81228f322adfe333cb01915a4f87a57", + "size": 12382, + "subdir": "linux-64", + "timestamp": 1671227031135, + "version": "2.4.3" + }, + "airflow-with-async-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9" + ], + "license": "Apache 2.0", + "md5": "44c4e869de1a35afe47cd280aa7f9d00", + "name": "airflow-with-async", + "sha256": "4ac912c451daef63576a907d3bd4902f3813bdb4be5d015e5f47ac959fb49828", + "size": 19565, + "subdir": "linux-64", + "timestamp": 1605878122113, + "version": "1.10.12" + }, + "airflow-with-async-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9" + ], + "license": "Apache 2.0", + "md5": "7e376947ba46535cc2c5ef5356a9f58c", + "name": "airflow-with-async", + "sha256": "41b4b26f32af4c90ca204041fb4cad41c701ed7da243ea8fd13497ee96dd7fc4", + "size": 17978, + "subdir": "linux-64", + "timestamp": 1579721373022, + "version": "1.10.7" + }, + "airflow-with-async-2.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "dnspython >=2", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "6565e6ff3c056fa0b7a08c200f97ade3", + "name": "airflow-with-async", + "sha256": "bba4b97dfdd929f6acf9b3571efec51e66666cf087738e2c6edd1311024bed7e", + "size": 12397, + "subdir": "linux-64", + "timestamp": 1659883936870, + "version": "2.3.3" + }, + "airflow-with-async-2.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "dnspython >=2", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "0b0be32320b2757ee46f65aa2d9e3f98", + "name": "airflow-with-async", + "sha256": "ac1b4d9113a09984c575e93cb4d1fcfc4f3013304d9d5d0c1a79d9f96a825c22", + "size": 12388, + "subdir": "linux-64", + "timestamp": 1659934875385, + "version": "2.3.3" + }, + "airflow-with-async-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "dnspython >=2", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "a61bb5423bc2c430670d8a3d20d1cc49", + "name": "airflow-with-async", + "sha256": "e17f6e5d2df02725e86208493d025cf95d03ba7e338a7c0c9f19a398c361b877", + "size": 12375, + "subdir": "linux-64", + "timestamp": 1659883920252, + "version": "2.3.3" + }, + "airflow-with-async-2.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "dnspython >=2", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "17790615140beaea8f5f4ef284e32c9f", + "name": "airflow-with-async", + "sha256": "36cde3a4a5a230076329e83e432b5a415aca1eb245faa782b41193f210e8b267", + "size": 12360, + "subdir": "linux-64", + "timestamp": 1659934864104, + "version": "2.3.3" + }, + "airflow-with-async-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "dnspython >=2", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "f09e7b308d9e4533dbfc3bb477b39dfe", + "name": "airflow-with-async", + "sha256": "2dd98205c8012d39999f54b62cc5d9be7d4a2a7361bde73f739e4ea2c38185cb", + "size": 12380, + "subdir": "linux-64", + "timestamp": 1659883925604, + "version": "2.3.3" + }, + "airflow-with-async-2.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "dnspython >=2", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "c79878b1a0454541843ef96915630461", + "name": "airflow-with-async", + "sha256": "dd4d452e0a537766c299bb2eb3fa7dc8e2e07640052cb9e33d1bd67ce08c7479", + "size": 12363, + "subdir": "linux-64", + "timestamp": 1659934880811, + "version": "2.3.3" + }, + "airflow-with-async-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "dnspython >=2", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "7df0f5c5021db03369d0ac7d743fba23", + "name": "airflow-with-async", + "sha256": "5bbdf7c85157d4c259175f537e32aa235e0d4084a0a174cf574697b5bb5beff2", + "size": 12367, + "subdir": "linux-64", + "timestamp": 1659883931194, + "version": "2.3.3" + }, + "airflow-with-async-2.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "dnspython >=2", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "7c29006981dafa9160c22fa36b15784e", + "name": "airflow-with-async", + "sha256": "b8160c7cc2cedaff009dfd52f589f2484cfd928fb6c7be564231eb1972138938", + "size": 12375, + "subdir": "linux-64", + "timestamp": 1659934869635, + "version": "2.3.3" + }, + "airflow-with-async-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1ff3a1094c6f300d991744e7e3189c20", + "name": "airflow-with-async", + "sha256": "b139697a1865b6d54c85ee8ca6f3b4232f4115e665c25459bc180d3edff49820", + "size": 12424, + "subdir": "linux-64", + "timestamp": 1671227059824, + "version": "2.4.3" + }, + "airflow-with-async-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "119c788946ab1fd2eb298110a1d1d0df", + "name": "airflow-with-async", + "sha256": "955432e7dd587b63114908d6f87750aecb9879cf6a6b97ec9f006ab7f36c18a0", + "size": 12410, + "subdir": "linux-64", + "timestamp": 1671227048105, + "version": "2.4.3" + }, + "airflow-with-async-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c37e1868b0f69fbcd5140d9fc154b8a0", + "name": "airflow-with-async", + "sha256": "84dae86fb89bc3325f46bde55e038debccf13e5962f014f0419411366afa5249", + "size": 12399, + "subdir": "linux-64", + "timestamp": 1671227065320, + "version": "2.4.3" + }, + "airflow-with-async-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "139c4c429786bb04c166e31e50e2876a", + "name": "airflow-with-async", + "sha256": "12231a6c0c9d0b8bc277924b414bedc4b2a2b7f60eba3b85fc32f781e61e8dd2", + "size": 12387, + "subdir": "linux-64", + "timestamp": 1671227053874, + "version": "2.4.3" + }, + "airflow-with-azure-mgmt-containerinstance-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "azure-mgmt-containerinstance >=1.5.0" + ], + "license": "Apache 2.0", + "md5": "78642f0959dddaaa20afbbb38bdc8add", + "name": "airflow-with-azure-mgmt-containerinstance", + "sha256": "36133e4485b869accf596ac4ee8f603986df289eae9aaa4cdee8ce688bd8eb3b", + "size": 19548, + "subdir": "linux-64", + "timestamp": 1605878123115, + "version": "1.10.12" + }, + "airflow-with-azure-mgmt-containerinstance-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "azure-mgmt-containerinstance >=1.5.0" + ], + "license": "Apache 2.0", + "md5": "d71ebd0ba6e9297f0ee090dd00d70be7", + "name": "airflow-with-azure-mgmt-containerinstance", + "sha256": "f87ee991229f82b926df63c68f2215d532aa4f6c3d2e51b2b1d1ce5f13022232", + "size": 17969, + "subdir": "linux-64", + "timestamp": 1579721374654, + "version": "1.10.7" + }, + "airflow-with-azure_blob_storage-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "azure-storage >=0.34.0", + "azure-storage-blob <12.0" + ], + "license": "Apache 2.0", + "md5": "ea09ccd22ff4138af22056834fdfc255", + "name": "airflow-with-azure_blob_storage", + "sha256": "b11043fb41bfbae2cf47d76f82df26de1fa739df228ad230c3c93ecac6f77591", + "size": 19588, + "subdir": "linux-64", + "timestamp": 1605878124098, + "version": "1.10.12" + }, + "airflow-with-azure_blob_storage-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "azure-storage >=0.34.0", + "azure-storage-blob <12.0" + ], + "license": "Apache 2.0", + "md5": "dc67989b1efe0298d8733ca58e75f6a7", + "name": "airflow-with-azure_blob_storage", + "sha256": "af226d0c7c463f6bc31a373485ffb50aaecbb34ec6b7dc5e4dcd8e966f0e1807", + "size": 17952, + "subdir": "linux-64", + "timestamp": 1579721376228, + "version": "1.10.7" + }, + "airflow-with-azure_cosmos-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "azure-cosmos >=3.0.1" + ], + "license": "Apache 2.0", + "md5": "3ab84d2de6059b597ac7d52cdcd551c6", + "name": "airflow-with-azure_cosmos", + "sha256": "bb47cc4aec461e5f9c98bc160ba0855a2484ce82f38306938d158b60e3da38f7", + "size": 19545, + "subdir": "linux-64", + "timestamp": 1605878125099, + "version": "1.10.12" + }, + "airflow-with-azure_cosmos-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "azure-cosmos >=3.0.1" + ], + "license": "Apache 2.0", + "md5": "bd0e0d12f7798311e8f8df2bf8e8a769", + "name": "airflow-with-azure_cosmos", + "sha256": "f43316221554acadb0fe4ad58598b8e56c727ff8657ba5ca695e1bd15ba62a29", + "size": 17967, + "subdir": "linux-64", + "timestamp": 1579721377851, + "version": "1.10.7" + }, + "airflow-with-cassandra-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "cassandra-driver >=3.13.0,<3.21.0" + ], + "license": "Apache 2.0", + "md5": "c825f081a454d64367dda0cf59b78011", + "name": "airflow-with-cassandra", + "sha256": "9e38e149f1d0f2ccc7b39d114bf24e932c343d3b2a4dd131c484717c19625a72", + "size": 19550, + "subdir": "linux-64", + "timestamp": 1605878126134, + "version": "1.10.12" + }, + "airflow-with-cassandra-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "cassandra-driver >=3.13.0" + ], + "license": "Apache 2.0", + "md5": "b026578f9f0a885a4f9f939032f651df", + "name": "airflow-with-cassandra", + "sha256": "9444267878d9273ccecc95d6cdbf574f572d9387435e8f66c2676880c1e98ce1", + "size": 17957, + "subdir": "linux-64", + "timestamp": 1579721379465, + "version": "1.10.7" + }, + "airflow-with-celery-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "celery >=4.3.0,<4.4.0", + "flower >=0.7.3,<1.0", + "tornado >=4.2.0" + ], + "license": "Apache 2.0", + "md5": "60e10d8230f343de35686a81e45638c6", + "name": "airflow-with-celery", + "sha256": "3e52149ee425dcaf534ff1b45e901dc16f78d15b8667acc8ab41ab66594709e9", + "size": 19540, + "subdir": "linux-64", + "timestamp": 1605878127163, + "version": "1.10.12" + }, + "airflow-with-celery-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "celery >=4.3.0,<4.4.0", + "flower >=0.7.3,<1.0", + "kombu 4.6.3", + "tornado >=4.2.0,<6.0" + ], + "license": "Apache 2.0", + "md5": "54c653cfc20111a7be0f03c211c49633", + "name": "airflow-with-celery", + "sha256": "858b9679c9d517fb141a5cc4b56db34292898800f70558eb0f579ac8f0d14db3", + "size": 18001, + "subdir": "linux-64", + "timestamp": 1579721381068, + "version": "1.10.7" + }, + "airflow-with-cgroups-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "cgroupspy >=0.1.4" + ], + "license": "Apache 2.0", + "md5": "3bfa2f5d4ae363032196d269a97c8d1e", + "name": "airflow-with-cgroups", + "sha256": "bf35053c74c9ae3ad7733d878cd670d2b787480380b00fa8a3b5a5e7f604c15b", + "size": 19547, + "subdir": "linux-64", + "timestamp": 1605878128167, + "version": "1.10.12" + }, + "airflow-with-cgroups-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "cgroupspy >=0.1.4" + ], + "license": "Apache 2.0", + "md5": "de98e39fe6559096a3ac4975b1f296b8", + "name": "airflow-with-cgroups", + "sha256": "ef5ed37b10d7e041a2a73b4166a39ce3a1e368d3f3adf8bd820c63842bf0f9b4", + "size": 17966, + "subdir": "linux-64", + "timestamp": 1579721382690, + "version": "1.10.7" + }, + "airflow-with-cgroups-2.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "3b69bb15b91e3b2b64e3640f00372799", + "name": "airflow-with-cgroups", + "sha256": "6865366d60c7054fc9ca38caecbecb7f0abb2076bda75bf35c353f4a5adcef09", + "size": 12389, + "subdir": "linux-64", + "timestamp": 1659883958648, + "version": "2.3.3" + }, + "airflow-with-cgroups-2.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "d015d8bc58bef1a13fa4dfef17095ed4", + "name": "airflow-with-cgroups", + "sha256": "42d968f5a9791c99dba22284b8db290e410a914f9826682cdf9bb6c30cdef198", + "size": 12375, + "subdir": "linux-64", + "timestamp": 1659934897338, + "version": "2.3.3" + }, + "airflow-with-cgroups-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "3aa3a9d0a345ef00a55540715e7adb80", + "name": "airflow-with-cgroups", + "sha256": "fa1bb60c7219a4fe2c13b9dfe9d4461ea2263c0080990c2c682a1b6fb12a4a08", + "size": 12382, + "subdir": "linux-64", + "timestamp": 1659883942161, + "version": "2.3.3" + }, + "airflow-with-cgroups-2.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "09c1dee7734103eb140340373c1de876", + "name": "airflow-with-cgroups", + "sha256": "a02e02884b6e969b6d61435ee0b156bf9c66e6e8dee1b5b94e1a6b376a8a16ff", + "size": 12360, + "subdir": "linux-64", + "timestamp": 1659934886163, + "version": "2.3.3" + }, + "airflow-with-cgroups-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "064455a894f4fee6adde80e48a7061b4", + "name": "airflow-with-cgroups", + "sha256": "867d784c8fcab7576852558503c42b801439b83891819de15d4b557ba7ae4c17", + "size": 12401, + "subdir": "linux-64", + "timestamp": 1659883947485, + "version": "2.3.3" + }, + "airflow-with-cgroups-2.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "0829d0d5e9452c5ee862e915a57053c5", + "name": "airflow-with-cgroups", + "sha256": "cbf44384e550edc0da527b7517d5ad2e8edad588f20c501bd130b295fad16a5d", + "size": 12366, + "subdir": "linux-64", + "timestamp": 1659934902748, + "version": "2.3.3" + }, + "airflow-with-cgroups-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "0ccc696506b2bd9cd00a2466c999155b", + "name": "airflow-with-cgroups", + "sha256": "e226b12ea3c93e837638cb62f0cd3b2d03d76ac0d4056ad8341c758b09ba9cae", + "size": 12378, + "subdir": "linux-64", + "timestamp": 1659883952985, + "version": "2.3.3" + }, + "airflow-with-cgroups-2.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "725546c3cf73a26b2ff82fcbdb9ee215", + "name": "airflow-with-cgroups", + "sha256": "3c029f209cf0dec8d9426eb67452cc95da72e6943a9e9706e70ec25cc86434b8", + "size": 12371, + "subdir": "linux-64", + "timestamp": 1659934891772, + "version": "2.3.3" + }, + "airflow-with-cgroups-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fdcd7d6e739297257af4902de28878aa", + "name": "airflow-with-cgroups", + "sha256": "19be9372acd2352f06aaaa9d574edda83e79228a358a29233223a418041f252f", + "size": 12385, + "subdir": "linux-64", + "timestamp": 1671227082652, + "version": "2.4.3" + }, + "airflow-with-cgroups-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "72e1aa2409ca9c243c85c671664b86b7", + "name": "airflow-with-cgroups", + "sha256": "4cee0809f9da04e40c1578f1e561e70ac33db14c976a0b5a51975a7ea4aafe16", + "size": 12382, + "subdir": "linux-64", + "timestamp": 1671227070888, + "version": "2.4.3" + }, + "airflow-with-cgroups-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "51a43c487fc8aa46815fa19075b9929c", + "name": "airflow-with-cgroups", + "sha256": "a03a173ce5f0c6b60b5fe7e8bbf3c09835c21bb0ec567580efe1791f53a8c18b", + "size": 12369, + "subdir": "linux-64", + "timestamp": 1671227088114, + "version": "2.4.3" + }, + "airflow-with-cgroups-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ada498e5762d4f1fe5278575ff47f2e4", + "name": "airflow-with-cgroups", + "sha256": "d3379fab15d4be7218faf2a2b9f4e7b9151ad8b06a6c5af266496db0a0ff32f8", + "size": 12382, + "subdir": "linux-64", + "timestamp": 1671227076675, + "version": "2.4.3" + }, + "airflow-with-cloudant-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "cloudant >=2.0" + ], + "license": "Apache 2.0", + "md5": "8b656b54c9160d0c1a1d28421d647787", + "name": "airflow-with-cloudant", + "sha256": "13cf67c23c47d28759f5dcdc0306b6c84dae1f64d79ff8d02085f20c64252b81", + "size": 19580, + "subdir": "linux-64", + "timestamp": 1605878129166, + "version": "1.10.12" + }, + "airflow-with-cloudant-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "cloudant >=2.0" + ], + "license": "Apache 2.0", + "md5": "81eb3a36b937beaf922cc74782fc8304", + "name": "airflow-with-cloudant", + "sha256": "f852dc62ee8db889c9ff45872b1523b9ff6ee29c62fa2860ab33a1fc06378aa2", + "size": 17946, + "subdir": "linux-64", + "timestamp": 1579721384351, + "version": "1.10.7" + }, + "airflow-with-cncf-kubernetes-2.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cryptography >=2.0.0", + "python >=3.10,<3.11.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "md5": "b9c993169265d634b7fde0fbffc173c8", + "name": "airflow-with-cncf-kubernetes", + "sha256": "4b91b465ad5254e13cdd9c59525883e2f486d15bcc70ceac94610f26e6635815", + "size": 12362, + "subdir": "linux-64", + "timestamp": 1659883980320, + "version": "2.3.3" + }, + "airflow-with-cncf-kubernetes-2.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cryptography >=2.0.0", + "python >=3.10,<3.11.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "md5": "2a8338dfb64a7101710e7e22cc84e982", + "name": "airflow-with-cncf-kubernetes", + "sha256": "f079f6f596ab8fe9e9b9e6f248d604ac12baca2ac533fac7931b68ea54a1a3c5", + "size": 12366, + "subdir": "linux-64", + "timestamp": 1659934919483, + "version": "2.3.3" + }, + "airflow-with-cncf-kubernetes-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cryptography >=2.0.0", + "python >=3.7,<3.8.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "md5": "0b0c2bdee1ff220fa951c5f04fa03166", + "name": "airflow-with-cncf-kubernetes", + "sha256": "89016485120189c85664ee662154924bb67ee04429413c2c265b58ba934ad4c4", + "size": 12331, + "subdir": "linux-64", + "timestamp": 1659883963949, + "version": "2.3.3" + }, + "airflow-with-cncf-kubernetes-2.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cryptography >=2.0.0", + "python >=3.7,<3.8.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "md5": "019ee93ea53f1e715ee119ab096a7046", + "name": "airflow-with-cncf-kubernetes", + "sha256": "76515f023c2bf650856f602fcc2391a9e13230866bc7954abedad273ee4872c3", + "size": 12330, + "subdir": "linux-64", + "timestamp": 1659934908111, + "version": "2.3.3" + }, + "airflow-with-cncf-kubernetes-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cryptography >=2.0.0", + "python >=3.8,<3.9.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "md5": "474992c7d3b38ded3e9298c8788ffc42", + "name": "airflow-with-cncf-kubernetes", + "sha256": "6ea469cc20483bb069d97d3eb15121caaa92382d8a29e4ba4afd09b1a44b0c05", + "size": 12338, + "subdir": "linux-64", + "timestamp": 1659883969166, + "version": "2.3.3" + }, + "airflow-with-cncf-kubernetes-2.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cryptography >=2.0.0", + "python >=3.8,<3.9.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "md5": "5bc55f1cad88c62421c0bf9c95edec25", + "name": "airflow-with-cncf-kubernetes", + "sha256": "52e53791375139e790a8ff3401b01d0b025ef9c3bfd7de9c1ecf89c8771c0ea1", + "size": 12335, + "subdir": "linux-64", + "timestamp": 1659934924856, + "version": "2.3.3" + }, + "airflow-with-cncf-kubernetes-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cryptography >=2.0.0", + "python >=3.9,<3.10.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "md5": "e46ca16fb74a81d6e083fab00d5c12e1", + "name": "airflow-with-cncf-kubernetes", + "sha256": "c4f1a094f9d4e6a2c6eff119d7d8be6a296a32cda74782983bc9f5a3e93ca874", + "size": 12333, + "subdir": "linux-64", + "timestamp": 1659883974663, + "version": "2.3.3" + }, + "airflow-with-cncf-kubernetes-2.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cryptography >=2.0.0", + "python >=3.9,<3.10.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "md5": "95d9563f8e617692ab72b4d0bafc84c3", + "name": "airflow-with-cncf-kubernetes", + "sha256": "0da26b4c0fe0a4cb4f59188faca80caeedd26e43160bc050a0fadb6a23de12dc", + "size": 12334, + "subdir": "linux-64", + "timestamp": 1659934913708, + "version": "2.3.3" + }, + "airflow-with-cncf-kubernetes-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cryptography >=2.0.0", + "python >=3.10,<3.11.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "408ce843637924b78365d0d9cad52e86", + "name": "airflow-with-cncf-kubernetes", + "sha256": "bedb3640644e2b3734626bf736c7363bf6793d0e4815bef9e6ef53a9148df5ad", + "size": 12376, + "subdir": "linux-64", + "timestamp": 1671227105420, + "version": "2.4.3" + }, + "airflow-with-cncf-kubernetes-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cryptography >=2.0.0", + "python >=3.7,<3.8.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "affca2ab74229a30bc177e4bf64a837a", + "name": "airflow-with-cncf-kubernetes", + "sha256": "1bdaef847b690beaa12abe97f78da9a7869cc26074bb73071aba455aec1602d2", + "size": 12380, + "subdir": "linux-64", + "timestamp": 1671227093674, + "version": "2.4.3" + }, + "airflow-with-cncf-kubernetes-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cryptography >=2.0.0", + "python >=3.8,<3.9.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "35a54a05e2135ad202fd4c15ad15e2e5", + "name": "airflow-with-cncf-kubernetes", + "sha256": "c0da36d47d810b2998f8ba53231ca3ec4423ae366b0b6f77194f80b77c9f7306", + "size": 12349, + "subdir": "linux-64", + "timestamp": 1671227111014, + "version": "2.4.3" + }, + "airflow-with-cncf-kubernetes-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cryptography >=2.0.0", + "python >=3.9,<3.10.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "66e56d29337ea29bb296f3597385968c", + "name": "airflow-with-cncf-kubernetes", + "sha256": "1f0a58eb88c28ba9fc16777c78831155aced1929ef390111809c73d1d5e28e3b", + "size": 12379, + "subdir": "linux-64", + "timestamp": 1671227099464, + "version": "2.4.3" + }, + "airflow-with-crypto-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "cryptography >=0.9.3" + ], + "license": "Apache 2.0", + "md5": "fdb2b4263de554065966a086eae8d1e9", + "name": "airflow-with-crypto", + "sha256": "084269dd7927eeda18e005421a77e5477b4882f89c44f561d2cfb812001d2b04", + "size": 19610, + "subdir": "linux-64", + "timestamp": 1605878130184, + "version": "1.10.12" + }, + "airflow-with-crypto-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "cryptography >=0.9.3" + ], + "license": "Apache 2.0", + "md5": "e9210de0e8749973229c2a542d54d360", + "name": "airflow-with-crypto", + "sha256": "f0698e9796cd136bde7dc11f83341cc8d2063f7c35ece8ef079a574ce093d74e", + "size": 17951, + "subdir": "linux-64", + "timestamp": 1579721386044, + "version": "1.10.7" + }, + "airflow-with-dask-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "distributed >=1.17.1" + ], + "license": "Apache 2.0", + "md5": "90f91830ee774f2167d1ab2e71b5e7a9", + "name": "airflow-with-dask", + "sha256": "d0a6de813b12589f09ec614c9f46beffb3050589bc0ececff283c0612e54a953", + "size": 19582, + "subdir": "linux-64", + "timestamp": 1605878131206, + "version": "1.10.12" + }, + "airflow-with-dask-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "distributed >=1.17.1,<2" + ], + "license": "Apache 2.0", + "md5": "f306f17566ab27aca1b6069538b8859e", + "name": "airflow-with-dask", + "sha256": "b779398535c10f065c211690cb32dcfa213b1bbdee15e25033393ddfe6571509", + "size": 17965, + "subdir": "linux-64", + "timestamp": 1579721387698, + "version": "1.10.7" + }, + "airflow-with-dask-2.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "5a322b515802cdd66772d46b16d5e1c6", + "name": "airflow-with-dask", + "sha256": "56027200b01938bf394133bed407c1b0d7981a9f944036e9db7ba92def1b8cfa", + "size": 12400, + "subdir": "linux-64", + "timestamp": 1659884002406, + "version": "2.3.3" + }, + "airflow-with-dask-2.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "afdc56ec30c1fdb648e1120655f4408d", + "name": "airflow-with-dask", + "sha256": "be76506f0f33bdd076282635e1c5f85670ff880a4618b69d3745061111423055", + "size": 12396, + "subdir": "linux-64", + "timestamp": 1659934941520, + "version": "2.3.3" + }, + "airflow-with-dask-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "28b2e78ec2b92aac9dcacc78290be41f", + "name": "airflow-with-dask", + "sha256": "6312c205380d5ba0623ef8f8e1c3f17fa3d6e5f3a75e01287ba1877f5c48529f", + "size": 12381, + "subdir": "linux-64", + "timestamp": 1659883985688, + "version": "2.3.3" + }, + "airflow-with-dask-2.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "d2684c1b3e85a4ab8a35117a6a0b6e78", + "name": "airflow-with-dask", + "sha256": "78f59e67c98fa3d72b196ca1dade5eb091b32c15039a209c5dc9b25d7df7dc0e", + "size": 12378, + "subdir": "linux-64", + "timestamp": 1659934930211, + "version": "2.3.3" + }, + "airflow-with-dask-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "6168e019fc0b16e08e406c4b99c7148d", + "name": "airflow-with-dask", + "sha256": "147f5eb0945be955fb714fc474212810f25c4ba5b125cf4de9cdc52f4f97e24a", + "size": 12380, + "subdir": "linux-64", + "timestamp": 1659883991081, + "version": "2.3.3" + }, + "airflow-with-dask-2.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "c9a006460a35d56930694be956c99dc8", + "name": "airflow-with-dask", + "sha256": "f0af07f75d9ee6eb2adcbfc3f21771ac01cb8ab20edbb58ca3580f35d067260e", + "size": 12375, + "subdir": "linux-64", + "timestamp": 1659934946982, + "version": "2.3.3" + }, + "airflow-with-dask-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "7d11dfb17dae4e7d6fb6675e23f5557d", + "name": "airflow-with-dask", + "sha256": "769522f85bdc1a71d7e92b8e93c6fffb9c0d6e6b89e732dcba07d3aecad13094", + "size": 12383, + "subdir": "linux-64", + "timestamp": 1659883996642, + "version": "2.3.3" + }, + "airflow-with-dask-2.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "e634381971aa26681a1e94bf5f9ecf28", + "name": "airflow-with-dask", + "sha256": "9335a5a1efecce4e1a3a6867dfa96c5a730f070fe8c892390c0665aa144db00e", + "size": 12377, + "subdir": "linux-64", + "timestamp": 1659934935797, + "version": "2.3.3" + }, + "airflow-with-dask-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "34b4bfcb1f34172898c13c4fbda7d07e", + "name": "airflow-with-dask", + "sha256": "a75977ffad913a26309efef4b47b209f1c5b26a1dfefe5ca342469f2a52ba0f9", + "size": 12403, + "subdir": "linux-64", + "timestamp": 1671227128143, + "version": "2.4.3" + }, + "airflow-with-dask-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8a87f1d5ae295555578b88ddcccc0cc9", + "name": "airflow-with-dask", + "sha256": "95a37f1b094345ecfed74f719c4ab9450abe8e951e9c0ff8e374cfe9921c2e66", + "size": 12379, + "subdir": "linux-64", + "timestamp": 1671227116455, + "version": "2.4.3" + }, + "airflow-with-dask-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a3cff23ff356568bd81668afead11b44", + "name": "airflow-with-dask", + "sha256": "17dea003a7f0e554fdc9360297631af2ddf481f949e149ca24f92d700eefb0ee", + "size": 12384, + "subdir": "linux-64", + "timestamp": 1671227133735, + "version": "2.4.3" + }, + "airflow-with-dask-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f69f7157fce114eb07990844b15048b0", + "name": "airflow-with-dask", + "sha256": "a83aed825314a8b54554274bc2e778890e05b6de526eb3e3c460cc23b340b08e", + "size": 12406, + "subdir": "linux-64", + "timestamp": 1671227122223, + "version": "2.4.3" + }, + "airflow-with-databricks-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache 2.0", + "md5": "7a90a7d4eb8a906c29e85cf5f326133b", + "name": "airflow-with-databricks", + "sha256": "39939dbbc254108d6b04293706e736cc9dae47cb6b42d42bc366ad5ddcb238ec", + "size": 19585, + "subdir": "linux-64", + "timestamp": 1605878132239, + "version": "1.10.12" + }, + "airflow-with-databricks-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache 2.0", + "md5": "c00f631fa5887f921f84ed434efe6c2d", + "name": "airflow-with-databricks", + "sha256": "9361e2a3c9db9e6a134d311d1e235703206ac7e6e21449acbe313fb609629bf7", + "size": 17967, + "subdir": "linux-64", + "timestamp": 1579721389323, + "version": "1.10.7" + }, + "airflow-with-datadog-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "datadog >=0.14.0" + ], + "license": "Apache 2.0", + "md5": "b214f4d89f4a41ce453d9cb3cd0624fd", + "name": "airflow-with-datadog", + "sha256": "4e8d43c94d8cbcfe900ad190d4a64655832e1ab4525d4cb14d61129171f8beac", + "size": 19520, + "subdir": "linux-64", + "timestamp": 1605878133310, + "version": "1.10.12" + }, + "airflow-with-datadog-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "datadog >=0.14.0" + ], + "license": "Apache 2.0", + "md5": "0cf35525281694a5085e7fa2acc7ebef", + "name": "airflow-with-datadog", + "sha256": "c5d16349fdc2d12fd3466857b33647a923eab0becd941dfe69c6917a3894ce7e", + "size": 17961, + "subdir": "linux-64", + "timestamp": 1579721390958, + "version": "1.10.7" + }, + "airflow-with-deprecated-api-2.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.10,<3.11.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "md5": "39c226735a89c786f2391803564c7bf4", + "name": "airflow-with-deprecated-api", + "sha256": "56a8516e9be5b45bee34d8c78ebc77bd55fa751b7e6488f4aadd890008ceed9e", + "size": 12346, + "subdir": "linux-64", + "timestamp": 1659884024307, + "version": "2.3.3" + }, + "airflow-with-deprecated-api-2.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.10,<3.11.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "md5": "8163e43aca84a37ea0cb474377fd66de", + "name": "airflow-with-deprecated-api", + "sha256": "8d3954be1f527c7d777454bd8f26030ecae9902d5bb2ccd62eca0ad657424e9e", + "size": 12326, + "subdir": "linux-64", + "timestamp": 1659934963467, + "version": "2.3.3" + }, + "airflow-with-deprecated-api-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.7,<3.8.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "md5": "cd28a29614dcd03e175ac6ccb20fe9f2", + "name": "airflow-with-deprecated-api", + "sha256": "ef3586623b96e77c3f45e470d2a58416da62dbb21e3d0503a8e49214f64a7e2b", + "size": 12305, + "subdir": "linux-64", + "timestamp": 1659884007759, + "version": "2.3.3" + }, + "airflow-with-deprecated-api-2.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.7,<3.8.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "md5": "ce9c03111087173f595c6f329e0fa99b", + "name": "airflow-with-deprecated-api", + "sha256": "aa27e7f3930f1e98f167cb553490349260185e8441a1e4babe1ae4a2ce70f9e3", + "size": 12332, + "subdir": "linux-64", + "timestamp": 1659934952145, + "version": "2.3.3" + }, + "airflow-with-deprecated-api-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.8,<3.9.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "md5": "9980f610373d1aede6785f1033a43016", + "name": "airflow-with-deprecated-api", + "sha256": "e5f34d09b953fcdc04f67ef23ecc6df5a857af915b8afc067cfa722ab8421a78", + "size": 12327, + "subdir": "linux-64", + "timestamp": 1659884013025, + "version": "2.3.3" + }, + "airflow-with-deprecated-api-2.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.8,<3.9.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "md5": "0871c8d281122716e3c16ed24a47c1ab", + "name": "airflow-with-deprecated-api", + "sha256": "c66089a03d242ce717ce07a7fdc6c5c8e0a371a64d18f11adac6b9db7c0b521f", + "size": 12337, + "subdir": "linux-64", + "timestamp": 1659934968905, + "version": "2.3.3" + }, + "airflow-with-deprecated-api-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.9,<3.10.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "md5": "171195e2ffe9e2e7a3c31497415c8406", + "name": "airflow-with-deprecated-api", + "sha256": "d20cb305124d80ce04148d148784775bf1fa34486b44822942247b1261dd071b", + "size": 12327, + "subdir": "linux-64", + "timestamp": 1659884018731, + "version": "2.3.3" + }, + "airflow-with-deprecated-api-2.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.9,<3.10.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "md5": "0615f197558c7fac96336235308287f8", + "name": "airflow-with-deprecated-api", + "sha256": "987e7a8192f599dfe43b07fb5d37e4b366171f75969c45e6203c21b72351ffbf", + "size": 12318, + "subdir": "linux-64", + "timestamp": 1659934957747, + "version": "2.3.3" + }, + "airflow-with-deprecated-api-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.10,<3.11.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e829bb6613ac4509585aae593ccbca82", + "name": "airflow-with-deprecated-api", + "sha256": "1c4b77a389fc23e69030a680dd4925aaa4e0894a0ebea41d32a1bf17f2113e8e", + "size": 12394, + "subdir": "linux-64", + "timestamp": 1671227150857, + "version": "2.4.3" + }, + "airflow-with-deprecated-api-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.7,<3.8.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "77533fef908b3687466e74e64bf223d8", + "name": "airflow-with-deprecated-api", + "sha256": "9805425b548de2d3ae4ed6b9257055ece85ddea37189bcc44ba13557377be132", + "size": 12362, + "subdir": "linux-64", + "timestamp": 1671227139154, + "version": "2.4.3" + }, + "airflow-with-deprecated-api-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.8,<3.9.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "994b396398189986b456d422b5dc9018", + "name": "airflow-with-deprecated-api", + "sha256": "4da7cdc70caf4f1917269b27588cfad8c0b97e666130c6fb419e0145adcca94e", + "size": 12350, + "subdir": "linux-64", + "timestamp": 1671227156449, + "version": "2.4.3" + }, + "airflow-with-deprecated-api-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.9,<3.10.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "37071fed538b72a6c60cddf3459b16ff", + "name": "airflow-with-deprecated-api", + "sha256": "639bc501f7653f0fb56ea34d166f8e9df8d91b747da05d34c949e6809267bf62", + "size": 12363, + "subdir": "linux-64", + "timestamp": 1671227144908, + "version": "2.4.3" + }, + "airflow-with-docker-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "docker-py >=3.0.0" + ], + "license": "Apache 2.0", + "md5": "5513662904edfd797b208a3b586546c4", + "name": "airflow-with-docker", + "sha256": "b3374159007adab2cf42e6323746df269803ff6f53eb3cd50060318181a80fba", + "size": 19505, + "subdir": "linux-64", + "timestamp": 1605878134327, + "version": "1.10.12" + }, + "airflow-with-docker-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "docker-py >=3.0.0,<3.1.0" + ], + "license": "Apache 2.0", + "md5": "bc2527e191720042923dc17bed0b40dc", + "name": "airflow-with-docker", + "sha256": "f0f8c6eaf27b02c325ecd6d9c0aa2c3eb4ee0f0acdd37c32148af100f6201d3b", + "size": 18006, + "subdir": "linux-64", + "timestamp": 1579721392656, + "version": "1.10.7" + }, + "airflow-with-druid-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "pydruid >=0.4.1,<=0.5.8" + ], + "license": "Apache 2.0", + "md5": "5ec50fa156990b161f629c3b40ceaaf9", + "name": "airflow-with-druid", + "sha256": "95613eb9b6b2e26bb79c778f94f6dd2709ff2f8db48d8ed7810ed04aa5af6867", + "size": 19532, + "subdir": "linux-64", + "timestamp": 1605878135342, + "version": "1.10.12" + }, + "airflow-with-druid-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "pydruid >=0.4.1" + ], + "license": "Apache 2.0", + "md5": "d8adcf572a372f2336e86361be32c337", + "name": "airflow-with-druid", + "sha256": "29393746232eaacc28264cfb26b6b58ca1a9dfcc6fe1db8ced5f0ec4e0637513", + "size": 17968, + "subdir": "linux-64", + "timestamp": 1579721394459, + "version": "1.10.7" + }, + "airflow-with-elasticsearch-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "elasticsearch >=5.0.0", + "elasticsearch-dsl >=5.0.0" + ], + "license": "Apache 2.0", + "md5": "1b71756ce90cc69364fedb72d0c89475", + "name": "airflow-with-elasticsearch", + "sha256": "7bc2ebe8ad7655869339af3aa640a93f60f2a294fdc738ea3fc6bc2489b8cb87", + "size": 19552, + "subdir": "linux-64", + "timestamp": 1605878136402, + "version": "1.10.12" + }, + "airflow-with-elasticsearch-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "elasticsearch >=5.0.0,<6.0.0", + "elasticsearch-dsl >=5.0.0,<6.0.0" + ], + "license": "Apache 2.0", + "md5": "cca6231d6d4b58091d8833dabe17aa8d", + "name": "airflow-with-elasticsearch", + "sha256": "381af6f442c99b95af3c16680c5e3b9b0d4bc255ebc07d672f7bbba909c3b86a", + "size": 17985, + "subdir": "linux-64", + "timestamp": 1579721396133, + "version": "1.10.7" + }, + "airflow-with-emr-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "boto3 >=1.0.0" + ], + "license": "Apache 2.0", + "md5": "c255da9f401f680ad872344809192f15", + "name": "airflow-with-emr", + "sha256": "d53f138b3a373c725f0f6e8f2f20c620c92ca3dff2ad0c9d0541597138e4a358", + "size": 19571, + "subdir": "linux-64", + "timestamp": 1605878137427, + "version": "1.10.12" + }, + "airflow-with-emr-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "boto3 >=1.0.0,<1.8.0" + ], + "license": "Apache 2.0", + "md5": "d5cbe9346d4ae999c69c5e53a0cab537", + "name": "airflow-with-emr", + "sha256": "c89fc8fc4a2986a1d64423434d4472d6560ce619771b93e1db7a5d68c7c2e3dd", + "size": 17961, + "subdir": "linux-64", + "timestamp": 1579721397901, + "version": "1.10.7" + }, + "airflow-with-github_enterprise-2.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "adca5724dea42a48b3bb58ff246f27fd", + "name": "airflow-with-github_enterprise", + "sha256": "9012c685d68ad97562a39cfe7a35f4e0307b33e949c580694eabb0c35424a41e", + "size": 12384, + "subdir": "linux-64", + "timestamp": 1659884046459, + "version": "2.3.3" + }, + "airflow-with-github_enterprise-2.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "fa4f6df4fb2065e2c810311c4329a65d", + "name": "airflow-with-github_enterprise", + "sha256": "dccbdfee8bedd41a62ab98cb8b9e7713267ec5f8de38bc9fa8f163d48fb18424", + "size": 12372, + "subdir": "linux-64", + "timestamp": 1659934985675, + "version": "2.3.3" + }, + "airflow-with-github_enterprise-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "c524a825f8c50572d9043a0b45d9987b", + "name": "airflow-with-github_enterprise", + "sha256": "2ff2217dd45215e9ba73e64251b041cd3d564d0dc8dd1544671d9219ef6c2970", + "size": 12361, + "subdir": "linux-64", + "timestamp": 1659884029711, + "version": "2.3.3" + }, + "airflow-with-github_enterprise-2.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "b876e8680e0a4e9727fc828768b92775", + "name": "airflow-with-github_enterprise", + "sha256": "4816097b0291e8606d12e3dc80904a98f28397782066d2a2cba41180009e26c2", + "size": 12367, + "subdir": "linux-64", + "timestamp": 1659934974325, + "version": "2.3.3" + }, + "airflow-with-github_enterprise-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "c4431e17bb6e619e8a313b91b3da8b88", + "name": "airflow-with-github_enterprise", + "sha256": "729380fd586d140100619a087d9eba8fd49d184ddb073d6fa40cb92d4f0e9af6", + "size": 12356, + "subdir": "linux-64", + "timestamp": 1659884035096, + "version": "2.3.3" + }, + "airflow-with-github_enterprise-2.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "cf5fce608c3c6aff4d0d1a5d196a691e", + "name": "airflow-with-github_enterprise", + "sha256": "7aba4f7d30d947a16134f285d9b1bb744c4b3834789c68edc2f9e1029a63e537", + "size": 12347, + "subdir": "linux-64", + "timestamp": 1659934991081, + "version": "2.3.3" + }, + "airflow-with-github_enterprise-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "21ca2ed36bcf225a0f4c9da34f428aab", + "name": "airflow-with-github_enterprise", + "sha256": "8bb1b5f93be611a9b5e357de0abb3042671f6fbdcf738db3b86af8114e652724", + "size": 12353, + "subdir": "linux-64", + "timestamp": 1659884040722, + "version": "2.3.3" + }, + "airflow-with-github_enterprise-2.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "ec2d08bf43ab43ad2abe13cb9dbbcb86", + "name": "airflow-with-github_enterprise", + "sha256": "ba2ad83ba94b024aece87ecd53c475393519bc96b654f39bbd96fae46af9be02", + "size": 12336, + "subdir": "linux-64", + "timestamp": 1659934979899, + "version": "2.3.3" + }, + "airflow-with-github_enterprise-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "08edd110193e7961425fc871b757b88d", + "name": "airflow-with-github_enterprise", + "sha256": "8bb8e2150b0da69cbe5b0085acc50d54aadd7b9d28529d728b535f82912d038d", + "size": 12397, + "subdir": "linux-64", + "timestamp": 1671227173643, + "version": "2.4.3" + }, + "airflow-with-github_enterprise-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ed27394dcb3605d1dfbf2a82dcc68e5e", + "name": "airflow-with-github_enterprise", + "sha256": "6f267e719e77c66ef05f24c3af7a784b3694f3b7428e8f76b3a811eefc5dd7be", + "size": 12375, + "subdir": "linux-64", + "timestamp": 1671227161889, + "version": "2.4.3" + }, + "airflow-with-github_enterprise-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "25b91e84ecac5272abd6da5774c00dc5", + "name": "airflow-with-github_enterprise", + "sha256": "821f19f88d45823bdbabeafe696f951da721e2042dfbe96b96e942999d92300b", + "size": 12376, + "subdir": "linux-64", + "timestamp": 1671227179253, + "version": "2.4.3" + }, + "airflow-with-github_enterprise-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "af8d3b28d4c81750a78e5fa8cc6f473b", + "name": "airflow-with-github_enterprise", + "sha256": "856ca69b7ff5e2fddb7283bbfe6325d8860ad2e73403f984bcf8936412d2a288", + "size": 12404, + "subdir": "linux-64", + "timestamp": 1671227167690, + "version": "2.4.3" + }, + "airflow-with-google_auth-2.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "77b36c3e348a19dd65054efd1c6a7279", + "name": "airflow-with-google_auth", + "sha256": "32c0633cf3422cda16a50e2e0d89bb85f07c634424826c1bdb06771d00d00022", + "size": 12380, + "subdir": "linux-64", + "timestamp": 1659884068631, + "version": "2.3.3" + }, + "airflow-with-google_auth-2.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "d38a1b5a21e32e60c4d67073ce88f56c", + "name": "airflow-with-google_auth", + "sha256": "2f9e0f891ef1e402227b3b569d36a741295e74106acd4104704f0b82a96b7995", + "size": 12387, + "subdir": "linux-64", + "timestamp": 1659935007815, + "version": "2.3.3" + }, + "airflow-with-google_auth-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "8a39d84e827700895c7eb291a1bb7cb0", + "name": "airflow-with-google_auth", + "sha256": "3b3d340b7a4fa8286b1878584a6bbdc0032a8c883bd13ad8030bc78fe7f18109", + "size": 12357, + "subdir": "linux-64", + "timestamp": 1659884051795, + "version": "2.3.3" + }, + "airflow-with-google_auth-2.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "bc814799faddfeeb4caf107aff8abcf3", + "name": "airflow-with-google_auth", + "sha256": "983b435dd0d5f059c334b61f0eafd9dcb1792f1b4753940343876699aab242c0", + "size": 12338, + "subdir": "linux-64", + "timestamp": 1659934996473, + "version": "2.3.3" + }, + "airflow-with-google_auth-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "f4c87258f2851cb67288648ce16a765c", + "name": "airflow-with-google_auth", + "sha256": "f55927ad821f6bfbe3ef700c0570c2b172170721a80f6980c9a7407bda686732", + "size": 12360, + "subdir": "linux-64", + "timestamp": 1659884057255, + "version": "2.3.3" + }, + "airflow-with-google_auth-2.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "f315363b48a212b90c57be9726eb261a", + "name": "airflow-with-google_auth", + "sha256": "eee7b7fb48c5034b88546ac0b0957ae02148335c04a1da2d537ec8a38320de7b", + "size": 12355, + "subdir": "linux-64", + "timestamp": 1659935013162, + "version": "2.3.3" + }, + "airflow-with-google_auth-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "4c33d0cc2a4569f1293ea6468649de86", + "name": "airflow-with-google_auth", + "sha256": "8bc6ee31e18849102926230aee1e6fc46208c8f76634c945ec7c13e228dfc9ae", + "size": 12353, + "subdir": "linux-64", + "timestamp": 1659884062887, + "version": "2.3.3" + }, + "airflow-with-google_auth-2.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "b4e408144611542e597cee5c05146210", + "name": "airflow-with-google_auth", + "sha256": "2ebdacf3407ba2b5736db13303b2ed0dc20c2bb09a4023d11c2c48a6d9a39400", + "size": 12335, + "subdir": "linux-64", + "timestamp": 1659935001974, + "version": "2.3.3" + }, + "airflow-with-google_auth-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a4bf957a26112d20fe9f33cad3a65e0f", + "name": "airflow-with-google_auth", + "sha256": "30ca068397bf0c5bcd18de206f7499e4014913bf4d635f1d27bba35caafe9c0a", + "size": 12402, + "subdir": "linux-64", + "timestamp": 1671227196463, + "version": "2.4.3" + }, + "airflow-with-google_auth-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0270de118d389143bfe4f4eaaf0d2e2c", + "name": "airflow-with-google_auth", + "sha256": "73dca433363bffd0481e89b7b984b3bd1aa1bf73b76d5274b414119a164ff571", + "size": 12366, + "subdir": "linux-64", + "timestamp": 1671227184681, + "version": "2.4.3" + }, + "airflow-with-google_auth-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7b2c5315f7d51cd69561bfd08e8c45db", + "name": "airflow-with-google_auth", + "sha256": "945aeef13112135be2e358b694d2a1daca575fd09014006fc627352a0678eece", + "size": 12370, + "subdir": "linux-64", + "timestamp": 1671227202061, + "version": "2.4.3" + }, + "airflow-with-google_auth-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7f66c1534513a59cdd3a837ba6b6aed3", + "name": "airflow-with-google_auth", + "sha256": "5e70204b3f8a9d8282b2837146b7c44cfb9138675e3fe5a9e62dcefa4a9b7c5a", + "size": 12392, + "subdir": "linux-64", + "timestamp": 1671227190501, + "version": "2.4.3" + }, + "airflow-with-hdfs-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "snakebite >=2.7.8" + ], + "license": "Apache 2.0", + "md5": "e815a22a95597a514b4c324ca6563402", + "name": "airflow-with-hdfs", + "sha256": "70f6d2c30bd8cd5348802a991d45f41e4f43c78f58b1a54bb6cd61a19ea7c499", + "size": 19571, + "subdir": "linux-64", + "timestamp": 1605878138462, + "version": "1.10.12" + }, + "airflow-with-hdfs-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "snakebite >=2.7.8" + ], + "license": "Apache 2.0", + "md5": "3f261e4633d2cf6bf42e9b11ebfb6ce3", + "name": "airflow-with-hdfs", + "sha256": "8419b017bb4c56898c8de3371fd346dbbf4096cc8daed9d2d45796b028981e14", + "size": 17960, + "subdir": "linux-64", + "timestamp": 1579721399728, + "version": "1.10.7" + }, + "airflow-with-jdbc-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "jaydebeapi >=1.1.1" + ], + "license": "Apache 2.0", + "md5": "2ecb5724b3cecb7c2cda946a8b6ece5d", + "name": "airflow-with-jdbc", + "sha256": "1f04f3c6b630334e81858346de9e52f9e7ca254804a5c5f714a1e21fe64b5afd", + "size": 19582, + "subdir": "linux-64", + "timestamp": 1605878139482, + "version": "1.10.12" + }, + "airflow-with-jdbc-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "jaydebeapi >=1.1.1" + ], + "license": "Apache 2.0", + "md5": "3f8e297357ac0a558794b6985b4f3cb3", + "name": "airflow-with-jdbc", + "sha256": "29977a5df7da92a2b41652deff29561029fe54e2738d165bec9985a0cd70d507", + "size": 17976, + "subdir": "linux-64", + "timestamp": 1579721401583, + "version": "1.10.7" + }, + "airflow-with-jenkins-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "python-jenkins >=1.0.0" + ], + "license": "Apache 2.0", + "md5": "9cabe886bd4113b9848b216d23df9a21", + "name": "airflow-with-jenkins", + "sha256": "a8310f0c51db75d8704d15c555b3ae2ce0d54b2a61663fbe7f88080812372cdb", + "size": 19605, + "subdir": "linux-64", + "timestamp": 1605878140505, + "version": "1.10.12" + }, + "airflow-with-jenkins-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "python-jenkins >=1.0.0" + ], + "license": "Apache 2.0", + "md5": "a7b20ee1a7adc85a5ad9cedbe6ffd9fc", + "name": "airflow-with-jenkins", + "sha256": "c2af09bf4ea6540706feb06f1640fa18fcff26e4b100210a062a3d9c02dfb3fb", + "size": 17963, + "subdir": "linux-64", + "timestamp": 1579721403292, + "version": "1.10.7" + }, + "airflow-with-jira-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "jira >=1.0.7" + ], + "license": "Apache 2.0", + "md5": "56dc4c97a35d54be02152b24c740704d", + "name": "airflow-with-jira", + "sha256": "2dad383c687846502d8866711c9ccc95e82968b5ebe2d4f3819217fe29044b6a", + "size": 19587, + "subdir": "linux-64", + "timestamp": 1605878141537, + "version": "1.10.12" + }, + "airflow-with-jira-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "jira >=1.0.7" + ], + "license": "Apache 2.0", + "md5": "38a61f1db12a4c8030016dd26e10558e", + "name": "airflow-with-jira", + "sha256": "0710b15501c1a3e4e2135796244635cf8b7b130f7442fc5f12f3927da037c764", + "size": 17961, + "subdir": "linux-64", + "timestamp": 1579721405020, + "version": "1.10.7" + }, + "airflow-with-kerberos-2.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.10,<3.11.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "md5": "9b5a9a08d9636401729d6216475a5675", + "name": "airflow-with-kerberos", + "sha256": "3a18c95919096e5cc1cabb618716cf3a9e84fc4adb7bd3d6f61ac005f9282580", + "size": 12425, + "subdir": "linux-64", + "timestamp": 1659884090843, + "version": "2.3.3" + }, + "airflow-with-kerberos-2.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.10,<3.11.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "md5": "b4d0c77b03822feada83c39796ae76d8", + "name": "airflow-with-kerberos", + "sha256": "8b4e5ffaad9688a80ebf1d06424fddbd48bdcab6c4614029c23c8dc9abf753ad", + "size": 12412, + "subdir": "linux-64", + "timestamp": 1659935029913, + "version": "2.3.3" + }, + "airflow-with-kerberos-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.7,<3.8.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "md5": "47c41e5a27697308fccf14b1521ae706", + "name": "airflow-with-kerberos", + "sha256": "58c558c9ffaa1d217c3feaba760b506f257e1a3f7bfd28d79609b193fd62980c", + "size": 12400, + "subdir": "linux-64", + "timestamp": 1659884074037, + "version": "2.3.3" + }, + "airflow-with-kerberos-2.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.7,<3.8.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "md5": "c6d7722fa0c82c24038ea85f713a92c8", + "name": "airflow-with-kerberos", + "sha256": "6c70e93f05befcf0ae0454c839e711e787643f39de5cff133bed52f6d0244b5a", + "size": 12408, + "subdir": "linux-64", + "timestamp": 1659935018545, + "version": "2.3.3" + }, + "airflow-with-kerberos-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.8,<3.9.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "md5": "9d22ab17b82a3b1b09a2ed9ce2d892f2", + "name": "airflow-with-kerberos", + "sha256": "f7e555b1aa2d8a61fd0f3eb64b6258994e2377a6f1a4b500eb4c8b7fa2c3246e", + "size": 12395, + "subdir": "linux-64", + "timestamp": 1659884079425, + "version": "2.3.3" + }, + "airflow-with-kerberos-2.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.8,<3.9.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "md5": "c2dfe4ce06706d101ff9dcd0e51335f0", + "name": "airflow-with-kerberos", + "sha256": "4007178a9f86e26f5341bca7e3024e55000223c0d808cdd02c728932510cda46", + "size": 12386, + "subdir": "linux-64", + "timestamp": 1659935035337, + "version": "2.3.3" + }, + "airflow-with-kerberos-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.9,<3.10.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "md5": "e7aac86256328cc6d6026154169e3e25", + "name": "airflow-with-kerberos", + "sha256": "30f746799274a667920a44f5097d39b61264330dbf1f51d1a612b7b48cdf70f3", + "size": 12405, + "subdir": "linux-64", + "timestamp": 1659884085025, + "version": "2.3.3" + }, + "airflow-with-kerberos-2.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.9,<3.10.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "md5": "064c6688069b5aa2b6fccedddc96fa2e", + "name": "airflow-with-kerberos", + "sha256": "723963e8674a136873aa9e0701f26ea850b02b07193b746ed69f6a84f3fa6e7d", + "size": 12393, + "subdir": "linux-64", + "timestamp": 1659935024138, + "version": "2.3.3" + }, + "airflow-with-kerberos-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.10,<3.11.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4ee33d3f7d9a98f25fb1b6df454eb121", + "name": "airflow-with-kerberos", + "sha256": "3f6e7240727596a6345862f584a26aeeaacc7296ab9e3adfb580c0e287f7c1a9", + "size": 12439, + "subdir": "linux-64", + "timestamp": 1671227219289, + "version": "2.4.3" + }, + "airflow-with-kerberos-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.7,<3.8.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "37ed9c6a7e6a92725e5ccb0dc9444b79", + "name": "airflow-with-kerberos", + "sha256": "abfa0bf1f4c5cd58f3f561bf95c4bea4a2251c9a48afa08cc0b3dd5677e8eb7b", + "size": 12419, + "subdir": "linux-64", + "timestamp": 1671227207517, + "version": "2.4.3" + }, + "airflow-with-kerberos-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.8,<3.9.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8edf6231c718fc064ee0affe41f1aece", + "name": "airflow-with-kerberos", + "sha256": "8b8ce59cb02a8762f3aaa11ccb8a12b28969e33785882dd6d00a8a6a2f1cef66", + "size": 12417, + "subdir": "linux-64", + "timestamp": 1671227224901, + "version": "2.4.3" + }, + "airflow-with-kerberos-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.9,<3.10.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "45cfe8209ad4746179081a9d501808bb", + "name": "airflow-with-kerberos", + "sha256": "58e3d3e7c79e8e5ae9c5d7b4ba66d1cbe4b36eabf1339283a0098e3742c59e2b", + "size": 12419, + "subdir": "linux-64", + "timestamp": 1671227213321, + "version": "2.4.3" + }, + "airflow-with-kubernetes-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "cryptography >=2.0.0", + "python-kubernetes >=3.0.0" + ], + "license": "Apache 2.0", + "md5": "9025bdd973083e8e98af08d784498c3d", + "name": "airflow-with-kubernetes", + "sha256": "5de9ca2e470ef07611b3f79aa451ad44b912b6ee35f2bded9228018e7a35e37a", + "size": 19606, + "subdir": "linux-64", + "timestamp": 1605878142570, + "version": "1.10.12" + }, + "airflow-with-kubernetes-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "cryptography >=2.0.0", + "python-kubernetes >=3.0.0" + ], + "license": "Apache 2.0", + "md5": "e8d6d27f15b735f28bb7881a10453b33", + "name": "airflow-with-kubernetes", + "sha256": "67486ea01e1a5bd72698ac84c961db94828a85155de35d2a18e9fb6825b19a6c", + "size": 17971, + "subdir": "linux-64", + "timestamp": 1579721406717, + "version": "1.10.7" + }, + "airflow-with-ldap-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "ldap3 >=2.5.1" + ], + "license": "Apache 2.0", + "md5": "a7f21c12269659783c6660286c2a349f", + "name": "airflow-with-ldap", + "sha256": "43dd780a075cc3c8ec795bbb288f993c9328182b0dfea8b0b30ae62783206e08", + "size": 19518, + "subdir": "linux-64", + "timestamp": 1605878143600, + "version": "1.10.12" + }, + "airflow-with-ldap-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "ldap3 >=2.5.1" + ], + "license": "Apache 2.0", + "md5": "3e1ce68163c10687e5fe0447c0854faf", + "name": "airflow-with-ldap", + "sha256": "7651d77ee6c2daaf2796ed3001d78255d48a015cc30015184f07c382caa1d22e", + "size": 17956, + "subdir": "linux-64", + "timestamp": 1579721408409, + "version": "1.10.7" + }, + "airflow-with-ldap-2.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "ldap3 >=2.5.1", + "python >=3.10,<3.11.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "md5": "e7dca2644f2ca048186c514df9c8ca69", + "name": "airflow-with-ldap", + "sha256": "fa304967be5ca5c6d5d7b33802394dcddc733c7290bf4083e3753e1a2fdc0a70", + "size": 12364, + "subdir": "linux-64", + "timestamp": 1659884112900, + "version": "2.3.3" + }, + "airflow-with-ldap-2.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "ldap3 >=2.5.1", + "python >=3.10,<3.11.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "md5": "ca00a091c84799989415c9930e338f73", + "name": "airflow-with-ldap", + "sha256": "03c2778b9ac896c9b1230d98e57e664280228d7c0b74f9ce43a17eccdf04bdf2", + "size": 12366, + "subdir": "linux-64", + "timestamp": 1659935052161, + "version": "2.3.3" + }, + "airflow-with-ldap-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "ldap3 >=2.5.1", + "python >=3.7,<3.8.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "md5": "48ebcb8b0b6f204572772fd9763ce340", + "name": "airflow-with-ldap", + "sha256": "ad669a1c035776ab0fb503adf6520dcf3bf876fe21583f233dd2d1aa4f3c78f8", + "size": 12354, + "subdir": "linux-64", + "timestamp": 1659884096228, + "version": "2.3.3" + }, + "airflow-with-ldap-2.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "ldap3 >=2.5.1", + "python >=3.7,<3.8.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "md5": "9871417c65ffec59bf6736b271340041", + "name": "airflow-with-ldap", + "sha256": "751b73e985cfea9bceb93cca493d23b0e4616a5b779a585608a9900617b47767", + "size": 12340, + "subdir": "linux-64", + "timestamp": 1659935040760, + "version": "2.3.3" + }, + "airflow-with-ldap-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "ldap3 >=2.5.1", + "python >=3.8,<3.9.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "md5": "410e77c790da3728c26eae8cf5dcbe13", + "name": "airflow-with-ldap", + "sha256": "09f2d4c25f0346792477603d73b62f982899e1fcba7ec2d1efadbc524da709fe", + "size": 12335, + "subdir": "linux-64", + "timestamp": 1659884101554, + "version": "2.3.3" + }, + "airflow-with-ldap-2.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "ldap3 >=2.5.1", + "python >=3.8,<3.9.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "md5": "bf11e7800b3379e401e1ec9e7aa86011", + "name": "airflow-with-ldap", + "sha256": "03ffbc9a73136367a172b95bc672cf58a4bf9b331a24214adb499a75ffc46fc6", + "size": 12342, + "subdir": "linux-64", + "timestamp": 1659935057616, + "version": "2.3.3" + }, + "airflow-with-ldap-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "ldap3 >=2.5.1", + "python >=3.9,<3.10.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "md5": "83a411d4e046ecaaec11611bc59a6e61", + "name": "airflow-with-ldap", + "sha256": "18afbd87a038456c4363be1c4b57f0a37ea63d475400bd4a92aec0f154acc9f2", + "size": 12348, + "subdir": "linux-64", + "timestamp": 1659884107123, + "version": "2.3.3" + }, + "airflow-with-ldap-2.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "ldap3 >=2.5.1", + "python >=3.9,<3.10.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "md5": "08a8128ab19761b0b97e7ba62073000d", + "name": "airflow-with-ldap", + "sha256": "78cf24e25a62f6f249eeb93df33e7d749a4342b7a0a36cfdf5d15be7e5a1e54c", + "size": 12336, + "subdir": "linux-64", + "timestamp": 1659935046394, + "version": "2.3.3" + }, + "airflow-with-ldap-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "ldap3 >=2.5.1", + "python >=3.10,<3.11.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fcd422d8780a266a8c6f3b44266be3f1", + "name": "airflow-with-ldap", + "sha256": "57841e2b678e7bdcfc786d48bb3f1dd499b42d996cdee1daa3eae34bcec1a19f", + "size": 12389, + "subdir": "linux-64", + "timestamp": 1671227242106, + "version": "2.4.3" + }, + "airflow-with-ldap-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "ldap3 >=2.5.1", + "python >=3.7,<3.8.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9099caf332216a63ada47a958b1fd08b", + "name": "airflow-with-ldap", + "sha256": "7375b9ceaf314b40099fc8e9a18d8cab7ef5047c9e2907257832fcba4c3ac881", + "size": 12359, + "subdir": "linux-64", + "timestamp": 1671227230343, + "version": "2.4.3" + }, + "airflow-with-ldap-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "ldap3 >=2.5.1", + "python >=3.8,<3.9.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "65e9b04fc772272d3f1c735a82a693c2", + "name": "airflow-with-ldap", + "sha256": "a2bff552cb288d710df1383619b19799c605595f0c1c124e0f077c7f9397ec3c", + "size": 12354, + "subdir": "linux-64", + "timestamp": 1671227247726, + "version": "2.4.3" + }, + "airflow-with-ldap-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "ldap3 >=2.5.1", + "python >=3.9,<3.10.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9694cf51194b4ee80a8b1459babae20f", + "name": "airflow-with-ldap", + "sha256": "b2b94b6af4f46c0f19d41cc113d5169c18f4e9295ead42d8a87567a2621e24e3", + "size": 12368, + "subdir": "linux-64", + "timestamp": 1671227236136, + "version": "2.4.3" + }, + "airflow-with-leveldb-2.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "plyvel", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "6aa8ec8f85f24770a95d528e1da64fc0", + "name": "airflow-with-leveldb", + "sha256": "3bb1464b8e40c3585e1f60b9b161388b3d1047943531d5d35146ab7fb3d24d8b", + "size": 12381, + "subdir": "linux-64", + "timestamp": 1659884135038, + "version": "2.3.3" + }, + "airflow-with-leveldb-2.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "plyvel", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "01c7c2d275f9c827a606ee5c7f70a79a", + "name": "airflow-with-leveldb", + "sha256": "777e0718191ec410862d0272d4600204b2470fe553859143738e6ff79f6a20a4", + "size": 12368, + "subdir": "linux-64", + "timestamp": 1659935074243, + "version": "2.3.3" + }, + "airflow-with-leveldb-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "plyvel", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "ec4b620e7116611ddc4f65716aa7f631", + "name": "airflow-with-leveldb", + "sha256": "59debf9741bf3ff96b8f0d3d7838a8b4652bb5b9f49aa5565a4e85a176bfad6e", + "size": 12349, + "subdir": "linux-64", + "timestamp": 1659884118275, + "version": "2.3.3" + }, + "airflow-with-leveldb-2.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "plyvel", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "51c8d7abc4320946dbd494d42eaf3671", + "name": "airflow-with-leveldb", + "sha256": "608915a31f47dd4c754d06ddc49bdbf06f4011c9f0682a1a693c7333998ebe7e", + "size": 12359, + "subdir": "linux-64", + "timestamp": 1659935062975, + "version": "2.3.3" + }, + "airflow-with-leveldb-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "plyvel", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "dddf1fddbfed328ccb3b0515e0b0e796", + "name": "airflow-with-leveldb", + "sha256": "c179057f85f6c9d74a9e1b374e56c0549110b27b04da8d4e7ca7f26394c48b76", + "size": 12347, + "subdir": "linux-64", + "timestamp": 1659884123657, + "version": "2.3.3" + }, + "airflow-with-leveldb-2.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "plyvel", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "fbacd5c39dfc4b05bcb9d6cacbcd9035", + "name": "airflow-with-leveldb", + "sha256": "3e96730c39efdd58e69ed9e23a60d0e1eb09043b18130a658ca074998f893115", + "size": 12345, + "subdir": "linux-64", + "timestamp": 1659935079702, + "version": "2.3.3" + }, + "airflow-with-leveldb-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "plyvel", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "7453942c648eda526223d3a53e3b12d3", + "name": "airflow-with-leveldb", + "sha256": "fd062b927640dbd0a612e19e8441bd632d650c2b20436803f334d8b2a2a6af39", + "size": 12341, + "subdir": "linux-64", + "timestamp": 1659884129234, + "version": "2.3.3" + }, + "airflow-with-leveldb-2.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "plyvel", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "3618a1cf9664380590417d9d3135837a", + "name": "airflow-with-leveldb", + "sha256": "b76c78a5dd83a0bfc6ea8bfd07a4d129af2fcc933160b9b026bde14926bb0c4a", + "size": 12341, + "subdir": "linux-64", + "timestamp": 1659935068603, + "version": "2.3.3" + }, + "airflow-with-leveldb-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "plyvel", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bba123ebd33d504235c5c30c2988695b", + "name": "airflow-with-leveldb", + "sha256": "fd9ba829db1e2058bdf77f7ec2cccd8010752bc441f02ebb16522797b76fd181", + "size": 12391, + "subdir": "linux-64", + "timestamp": 1671227264987, + "version": "2.4.3" + }, + "airflow-with-leveldb-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "plyvel", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5723cda50aba3e4e4862be487bef72d9", + "name": "airflow-with-leveldb", + "sha256": "e3f14b98a5493f86bcdc6ba55978a73ccdd0c2f611587d66f13f0b3a0993bca3", + "size": 12382, + "subdir": "linux-64", + "timestamp": 1671227253319, + "version": "2.4.3" + }, + "airflow-with-leveldb-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "plyvel", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bee84e80f2608b284c869d465ff7d333", + "name": "airflow-with-leveldb", + "sha256": "4d5a52b28a8d1bce5c576bad5cbf09da1684696b1d2afebba7519b8dd1103f46", + "size": 12359, + "subdir": "linux-64", + "timestamp": 1671227270658, + "version": "2.4.3" + }, + "airflow-with-leveldb-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "plyvel", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "250b7ccb977fbdbfcaa65e547a386b66", + "name": "airflow-with-leveldb", + "sha256": "872606194c428ee6cc8a92395bdad78eae4c08492ac432f5e8875a2e3241acda", + "size": 12377, + "subdir": "linux-64", + "timestamp": 1671227259009, + "version": "2.4.3" + }, + "airflow-with-mongo-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "dnspython >=1.13.0,<2.0.0", + "pymongo >=3.6.0" + ], + "license": "Apache 2.0", + "md5": "cb049991d8f451dfb1b859e1a1303a26", + "name": "airflow-with-mongo", + "sha256": "69d610c9a9d79395f63a57dfc7299c55349bf874e123adb025031c6d6dfee559", + "size": 19598, + "subdir": "linux-64", + "timestamp": 1605878144600, + "version": "1.10.12" + }, + "airflow-with-mongo-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "dnspython >=1.13.0,<2.0.0", + "pymongo >=3.6.0" + ], + "license": "Apache 2.0", + "md5": "829bcd3b57737ede2b6d3fde00c56c7a", + "name": "airflow-with-mongo", + "sha256": "373867ea3191a93ca7396b07a0e5be6e25f7d6fea0ad808adb68dd9e0bb75f27", + "size": 17977, + "subdir": "linux-64", + "timestamp": 1579721410046, + "version": "1.10.7" + }, + "airflow-with-mssql-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "pymssql >=2.1.1,<2.2.0" + ], + "license": "Apache 2.0", + "md5": "1005454f32489563ac3388b099568549", + "name": "airflow-with-mssql", + "sha256": "79f2f616a65ddbd8e098c7480784bddad0e738a44400a8492d20f0e54131f8e3", + "size": 19528, + "subdir": "linux-64", + "timestamp": 1605878145614, + "version": "1.10.12" + }, + "airflow-with-mssql-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "pymssql >=2.1.1,<2.2.0" + ], + "license": "Apache 2.0", + "md5": "82438921fae53bdedcacf4fb00221e65", + "name": "airflow-with-mssql", + "sha256": "ed1e8c5bb217d068e0a62c4184d89329b0036c086e194a8ae76f2561b609ad4c", + "size": 17959, + "subdir": "linux-64", + "timestamp": 1579721411744, + "version": "1.10.7" + }, + "airflow-with-mysql-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "mysqlclient >=1.3.6" + ], + "license": "Apache 2.0", + "md5": "82de1a2664018bfdc039648e049f1d50", + "name": "airflow-with-mysql", + "sha256": "51af4e6ea68596f7faef2a9df5fe6fdb8c19c10a7f84f2885b0d9916184cc656", + "size": 19541, + "subdir": "linux-64", + "timestamp": 1605878146639, + "version": "1.10.12" + }, + "airflow-with-mysql-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "mysqlclient >=1.3.6,<1.4" + ], + "license": "Apache 2.0", + "md5": "994d7875a4885e419b2401e7634068ec", + "name": "airflow-with-mysql", + "sha256": "60899db3f0bbae5c91c995bd5f4253f354437ed4807daf7a2cc9c6a9dc25caad", + "size": 17968, + "subdir": "linux-64", + "timestamp": 1579721413444, + "version": "1.10.7" + }, + "airflow-with-pandas-2.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pandas >=0.17.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "383f5de60a8fbc4f469ced350e6d85cc", + "name": "airflow-with-pandas", + "sha256": "2b9fe301685a6e87e35da692ab82d1fd86002dc07c1e204253fbbf4fbfec847d", + "size": 12380, + "subdir": "linux-64", + "timestamp": 1659884157277, + "version": "2.3.3" + }, + "airflow-with-pandas-2.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pandas >=0.17.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "d0196b0d38b344d51f5824e2b7738fd8", + "name": "airflow-with-pandas", + "sha256": "9818f0ccae97b8f21174528173dd5ed0a8bfdcb73f181674685fa1ea8c342e64", + "size": 12374, + "subdir": "linux-64", + "timestamp": 1659935096517, + "version": "2.3.3" + }, + "airflow-with-pandas-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pandas >=0.17.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "0bbf7e87fafb8bdcfa2f75d5c52b2a97", + "name": "airflow-with-pandas", + "sha256": "e34029d5512226c98e9af77ce843dc517bcd796d4c6f637c5eecf2de12bfbd2c", + "size": 12343, + "subdir": "linux-64", + "timestamp": 1659884140443, + "version": "2.3.3" + }, + "airflow-with-pandas-2.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pandas >=0.17.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "00b4a9ccd69823fa00d6edaa40f58a8d", + "name": "airflow-with-pandas", + "sha256": "7dc37b62a68d107e5d56f0793bc3da7aadb513b121238784ff9e687c4a407bef", + "size": 12352, + "subdir": "linux-64", + "timestamp": 1659935085075, + "version": "2.3.3" + }, + "airflow-with-pandas-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pandas >=0.17.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "6fc9d320a05fdc8676510166955a89e0", + "name": "airflow-with-pandas", + "sha256": "a11b69cf349c818f969eff90658a7f503fc8b59f9c87f8960c75a72b376d2f26", + "size": 12356, + "subdir": "linux-64", + "timestamp": 1659884145925, + "version": "2.3.3" + }, + "airflow-with-pandas-2.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pandas >=0.17.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "64c1ef93ec7af4d43dfe54c38ae5e9cb", + "name": "airflow-with-pandas", + "sha256": "20ef74da4d89e55cd51e046f490a3927a379faa5692deff5c7b528c9cf1d765a", + "size": 12344, + "subdir": "linux-64", + "timestamp": 1659935102005, + "version": "2.3.3" + }, + "airflow-with-pandas-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pandas >=0.17.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "954e08e7cb7a80a2e17894002efa6bc6", + "name": "airflow-with-pandas", + "sha256": "7e4d62c29c13c092713ed185b18e3569abe642705ba30f26e6ec99f46ab31b2e", + "size": 12337, + "subdir": "linux-64", + "timestamp": 1659884151398, + "version": "2.3.3" + }, + "airflow-with-pandas-2.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pandas >=0.17.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "85664d6e4aeb4000c0d3f3d705df1249", + "name": "airflow-with-pandas", + "sha256": "c4b7d8b589bc8fbe8f0eeef8e3e35955d6fe00efdedb785f6a74a56b64c0a344", + "size": 12336, + "subdir": "linux-64", + "timestamp": 1659935090658, + "version": "2.3.3" + }, + "airflow-with-pandas-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "pandas >=0.17.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "59b33296c3b7931d6f265ea04c8fd6d0", + "name": "airflow-with-pandas", + "sha256": "85eced06b5fdb027065c559f41e8fcefcf4ca2990cbcb3f08fd952acb9591ea7", + "size": 12388, + "subdir": "linux-64", + "timestamp": 1671227287999, + "version": "2.4.3" + }, + "airflow-with-pandas-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "pandas >=0.17.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e791b85be74c759d287855461e62805c", + "name": "airflow-with-pandas", + "sha256": "3a96026af8830e16ac7d594508f8068c8dc1de51760c50a65c3c61b7e9e7a9ac", + "size": 12373, + "subdir": "linux-64", + "timestamp": 1671227276289, + "version": "2.4.3" + }, + "airflow-with-pandas-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "pandas >=0.17.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "86d368ab50d1aa3d10db929e0281fa6d", + "name": "airflow-with-pandas", + "sha256": "56334dab87beaaa8ae8dd1cf17d60135b13a95c654114cc625295279e2439674", + "size": 12358, + "subdir": "linux-64", + "timestamp": 1671227293637, + "version": "2.4.3" + }, + "airflow-with-pandas-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "pandas >=0.17.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "05db19ba20b648294f1c85c9e6899fd9", + "name": "airflow-with-pandas", + "sha256": "b0ddab486b403dd9ec12938a29d1441771a4c911b2d2ac2a8e4b13eee358756f", + "size": 12368, + "subdir": "linux-64", + "timestamp": 1671227282129, + "version": "2.4.3" + }, + "airflow-with-password-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1" + ], + "license": "Apache 2.0", + "md5": "4a9d820e952112b4c9fdf848da712dfe", + "name": "airflow-with-password", + "sha256": "d9269b64233f0847ef2bb392e2cb8d0964e40bd1dfa3cd4f7039af1bdaccd83a", + "size": 19536, + "subdir": "linux-64", + "timestamp": 1605878147668, + "version": "1.10.12" + }, + "airflow-with-password-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1" + ], + "license": "Apache 2.0", + "md5": "49eb482fb71595d7e98e84a7df5d67a6", + "name": "airflow-with-password", + "sha256": "2428e7b05e26a18164c2bfd42f641fc8043f168643055a6c9dd63db393767d31", + "size": 17963, + "subdir": "linux-64", + "timestamp": 1579721415038, + "version": "1.10.7" + }, + "airflow-with-password-2.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "74b9fd58d6f9ba6913ff026ed0da3550", + "name": "airflow-with-password", + "sha256": "e0170168f55a9255824170cf10f387f68644c2c2511a43e87371a15c005d7a72", + "size": 12376, + "subdir": "linux-64", + "timestamp": 1659884179346, + "version": "2.3.3" + }, + "airflow-with-password-2.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "ce69e81830a0f7666b2753e684edcc1e", + "name": "airflow-with-password", + "sha256": "915aba73f63e4f947223d1ed8688951ee44b6b4d6683d31cf0416911ad300bf7", + "size": 12376, + "subdir": "linux-64", + "timestamp": 1659935118836, + "version": "2.3.3" + }, + "airflow-with-password-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "bb0a8ef335184e6a6d12c69bdc427af1", + "name": "airflow-with-password", + "sha256": "2bd683c599bb9042f79e4f08c437b2b10e2651ff5053738d9c8c4e45931be927", + "size": 12363, + "subdir": "linux-64", + "timestamp": 1659884162552, + "version": "2.3.3" + }, + "airflow-with-password-2.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "a44094ffa30fa745cd5f83eeff56c821", + "name": "airflow-with-password", + "sha256": "3515992dcfc6c8cdf012bd8db91be569675aadec1fa041e1895bd52219bca877", + "size": 12336, + "subdir": "linux-64", + "timestamp": 1659935107394, + "version": "2.3.3" + }, + "airflow-with-password-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "9f181b15cad6102375ff7bf787ae7b0c", + "name": "airflow-with-password", + "sha256": "70ae883abb6e63e4f851630e67d50a7b93ab2813b835fa138e006cbd76078e47", + "size": 12370, + "subdir": "linux-64", + "timestamp": 1659884167944, + "version": "2.3.3" + }, + "airflow-with-password-2.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "f0af6f242dea7f44330f7ecbee8a7c68", + "name": "airflow-with-password", + "sha256": "0bcf7c42f0afd43bb70355f02e5ea9b02248b3d615566d9cf1e808da2276e5cc", + "size": 12346, + "subdir": "linux-64", + "timestamp": 1659935124284, + "version": "2.3.3" + }, + "airflow-with-password-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "bff3111157154603c30fa1024bd8b96c", + "name": "airflow-with-password", + "sha256": "52f327a7cdca4c6b19ab310492bdc8476386a428097121d6a56902f513456221", + "size": 12371, + "subdir": "linux-64", + "timestamp": 1659884173573, + "version": "2.3.3" + }, + "airflow-with-password-2.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "0d5791aef48ebe06231927e2726971df", + "name": "airflow-with-password", + "sha256": "1406993f9945b66f6ee0f0c011cb5f6a15ef360198c60a24edb5b0fdb89e67a9", + "size": 12347, + "subdir": "linux-64", + "timestamp": 1659935112999, + "version": "2.3.3" + }, + "airflow-with-password-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2d166d15dd707cc6367ac4ace877ae33", + "name": "airflow-with-password", + "sha256": "c6cbbe0208c2bda7ddc2dfd51d63e8a863bd8834da6356e76462fd4990c7ea75", + "size": 12390, + "subdir": "linux-64", + "timestamp": 1671227310953, + "version": "2.4.3" + }, + "airflow-with-password-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "849cd571142ed6a1344d5c948a835379", + "name": "airflow-with-password", + "sha256": "aab9697ba9c47ee4f8749cba51f425c5cb88f0b98aa4536433239935fe60813c", + "size": 12376, + "subdir": "linux-64", + "timestamp": 1671227299250, + "version": "2.4.3" + }, + "airflow-with-password-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e50aa238fbed7ac3cb8abe503986ad87", + "name": "airflow-with-password", + "sha256": "7f174d435efbcd0298b3fb61e6cd21fdfc18a2ed966a12cfb92671f4ad5f9cde", + "size": 12366, + "subdir": "linux-64", + "timestamp": 1671227316589, + "version": "2.4.3" + }, + "airflow-with-password-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "548f07c26f794edd30bc1bdf2720844a", + "name": "airflow-with-password", + "sha256": "391100886b93ae3c9bda5c5461cf4d75c8ee36f3ef581ad5c48424a0ad143ac8", + "size": 12394, + "subdir": "linux-64", + "timestamp": 1671227305081, + "version": "2.4.3" + }, + "airflow-with-postgres-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "psycopg2 >=2.7.4" + ], + "license": "Apache 2.0", + "md5": "598d3c90eb18defb741bffc0f6b9d8bf", + "name": "airflow-with-postgres", + "sha256": "b3bc2ad87c9088336ca57b8bbb71774f0a7c9a1f8f57bac0005c76e7e2671853", + "size": 19569, + "subdir": "linux-64", + "timestamp": 1605878148717, + "version": "1.10.12" + }, + "airflow-with-postgres-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "psycopg2 >=2.7.4" + ], + "license": "Apache 2.0", + "md5": "93275fdd510328434338f7804b4ac8df", + "name": "airflow-with-postgres", + "sha256": "1bbfaacb345b9bc01945e556c2e80cd669f9d5791c89d6ea5a996b46f5428e4f", + "size": 17960, + "subdir": "linux-64", + "timestamp": 1579721416709, + "version": "1.10.7" + }, + "airflow-with-qds-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "qds-sdk >=1.10.4" + ], + "license": "Apache 2.0", + "md5": "fc6b8e785832b386f3ea0cbb1051ef39", + "name": "airflow-with-qds", + "sha256": "fd7daf44f4254c476f737b0907f83d0991a24e55cbe5f1bb98fcfded0cd1c90f", + "size": 19593, + "subdir": "linux-64", + "timestamp": 1605878149756, + "version": "1.10.12" + }, + "airflow-with-qds-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "qds-sdk >=1.10.4" + ], + "license": "Apache 2.0", + "md5": "037aa9f7b0652bc33ed424b875025c78", + "name": "airflow-with-qds", + "sha256": "f784e6ab5e5bb6b9d30a23a017e9d6d75bfa39d4fa8cd4bc8c7a0eb30d41350b", + "size": 17981, + "subdir": "linux-64", + "timestamp": 1579721418353, + "version": "1.10.7" + }, + "airflow-with-rabbitmq-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "librabbitmq >=1.6.1" + ], + "license": "Apache 2.0", + "md5": "705224f8c4241b2ab4002af55a708525", + "name": "airflow-with-rabbitmq", + "sha256": "845c80d01d25d33f2a88654e9ffffa7ea62e740b2a773139c3064d9004b76517", + "size": 19571, + "subdir": "linux-64", + "timestamp": 1605878150776, + "version": "1.10.12" + }, + "airflow-with-rabbitmq-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "librabbitmq >=1.6.1" + ], + "license": "Apache 2.0", + "md5": "0d5eeee68e3ad25b08735e39c7555538", + "name": "airflow-with-rabbitmq", + "sha256": "820f1312937e912f6bde0ad2e46cb8609201c5289f2eb47815d4bdbb12b4c44f", + "size": 17963, + "subdir": "linux-64", + "timestamp": 1579721420187, + "version": "1.10.7" + }, + "airflow-with-rabbitmq-2.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "amqp", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "6be431779d289f3265acf517a2d1ee6f", + "name": "airflow-with-rabbitmq", + "sha256": "4a51f10c11735b15d152e0d5e7afcef893fea341c108c13023f3385d2f7121c0", + "size": 12367, + "subdir": "linux-64", + "timestamp": 1659884201443, + "version": "2.3.3" + }, + "airflow-with-rabbitmq-2.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "amqp", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "702fc1e80b42085d34b6ccd506a5afde", + "name": "airflow-with-rabbitmq", + "sha256": "9bd58154895ff88bd1f9ca09eeb3eb074e52dc5cdb9153630151bfdc5ef0b590", + "size": 12355, + "subdir": "linux-64", + "timestamp": 1659935140926, + "version": "2.3.3" + }, + "airflow-with-rabbitmq-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "amqp", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "ba685e2c8dbba2dcb67e20d34bb26838", + "name": "airflow-with-rabbitmq", + "sha256": "460198dcad524081a5b78472228db4c587821281719730045107bcc4615186a4", + "size": 12331, + "subdir": "linux-64", + "timestamp": 1659884184747, + "version": "2.3.3" + }, + "airflow-with-rabbitmq-2.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "amqp", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "4c31310ce7d5ca84826a81dd88b8f3ee", + "name": "airflow-with-rabbitmq", + "sha256": "4c2170742bb315a65e709a963abb96f1fa2f6f2806212259dfe654e5d11ca03f", + "size": 12351, + "subdir": "linux-64", + "timestamp": 1659935129547, + "version": "2.3.3" + }, + "airflow-with-rabbitmq-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "amqp", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "999f7fc0c53cb466257ba1ce41b8861f", + "name": "airflow-with-rabbitmq", + "sha256": "6f5d899549c3658b3bce8435adb68496735e2e72a7511c2c49e4ca818204c0c9", + "size": 12335, + "subdir": "linux-64", + "timestamp": 1659884190171, + "version": "2.3.3" + }, + "airflow-with-rabbitmq-2.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "amqp", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "72e603706d33abd55bcffc70074c89a3", + "name": "airflow-with-rabbitmq", + "sha256": "cc1d6034d95309a224ae3f37aef397aa36412a28026847b55ee57a84f55b3147", + "size": 12308, + "subdir": "linux-64", + "timestamp": 1659935146440, + "version": "2.3.3" + }, + "airflow-with-rabbitmq-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "amqp", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "c03e703542c25417875a9a46cde41898", + "name": "airflow-with-rabbitmq", + "sha256": "ab08226a79b15c406bb23f3d7fa0af27e57d6189e24f416d239236ccf1cede59", + "size": 12346, + "subdir": "linux-64", + "timestamp": 1659884195752, + "version": "2.3.3" + }, + "airflow-with-rabbitmq-2.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "amqp", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "0fce257c5e52dcd8fd0e3cce412322d2", + "name": "airflow-with-rabbitmq", + "sha256": "72796f3fb5ff600ea3e6af9fbf0ce6ec7b9f212033fe7fda61f768b416e7616f", + "size": 12338, + "subdir": "linux-64", + "timestamp": 1659935135175, + "version": "2.3.3" + }, + "airflow-with-rabbitmq-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "amqp", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9607e2156c3ca5a9dd7f9302dcbad0ed", + "name": "airflow-with-rabbitmq", + "sha256": "d4477981a91b84d79aa5cf2067ec93c390f878729df7a48103e570ec919c29eb", + "size": 12402, + "subdir": "linux-64", + "timestamp": 1671227333921, + "version": "2.4.3" + }, + "airflow-with-rabbitmq-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "amqp", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9e69d1159949b5658b45d88ea0b69d26", + "name": "airflow-with-rabbitmq", + "sha256": "72480cf11f6e8d572aa7e5b66b82abdded47f957515cb52fb8a03996a1bf9997", + "size": 12378, + "subdir": "linux-64", + "timestamp": 1671227322210, + "version": "2.4.3" + }, + "airflow-with-rabbitmq-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "amqp", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "813abc986e0bd57951d7b208c3b2eaca", + "name": "airflow-with-rabbitmq", + "sha256": "cff960bdc3ba8f5793b9743a64fff938887e52286c768815a726c28938ead23c", + "size": 12361, + "subdir": "linux-64", + "timestamp": 1671227339542, + "version": "2.4.3" + }, + "airflow-with-rabbitmq-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "amqp", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e2f71cf26675c37eff062d493d7fe1c1", + "name": "airflow-with-rabbitmq", + "sha256": "2933a60a799b7d1ae848667bebc58c67b4ea45f330350f504c33466179d60101", + "size": 12356, + "subdir": "linux-64", + "timestamp": 1671227328046, + "version": "2.4.3" + }, + "airflow-with-redis-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "redis-py >=3.2.0" + ], + "license": "Apache 2.0", + "md5": "84b5e0fb28d8c567db5d3afe8595ca7a", + "name": "airflow-with-redis", + "sha256": "793d11c0f519ffb4fa24a5da19a41881f873f6021ab429a6c6fbbda8418423f1", + "size": 19592, + "subdir": "linux-64", + "timestamp": 1605878151857, + "version": "1.10.12" + }, + "airflow-with-redis-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "redis-py >=3.2.0,<3.3.0" + ], + "license": "Apache 2.0", + "md5": "8cd46f251870e013d3335c798f0d13f4", + "name": "airflow-with-redis", + "sha256": "9fe7fb6ee7f218d1cbc32efee539a1a2f8ab174118de052c1af149509c9089da", + "size": 17969, + "subdir": "linux-64", + "timestamp": 1579721421882, + "version": "1.10.7" + }, + "airflow-with-salesforce-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "simple-salesforce >=0.72" + ], + "license": "Apache 2.0", + "md5": "b1b4a9f0aa31ba6ba1e6790913916aa8", + "name": "airflow-with-salesforce", + "sha256": "32f446142773913a02cb6514fffc711caecc698c9822a71963e409ea689c425a", + "size": 19605, + "subdir": "linux-64", + "timestamp": 1605878152895, + "version": "1.10.12" + }, + "airflow-with-salesforce-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "simple-salesforce >=0.72" + ], + "license": "Apache 2.0", + "md5": "4da3726f6961cf4398c04439d26b2786", + "name": "airflow-with-salesforce", + "sha256": "aadc7d855dd994d0d863c6fa70f44f7efbd6ec48ea24c72986782994cdd820a8", + "size": 17960, + "subdir": "linux-64", + "timestamp": 1579721423564, + "version": "1.10.7" + }, + "airflow-with-samba-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "pysmbclient >=0.1.3" + ], + "license": "Apache 2.0", + "md5": "a1d8631a72c16e82fa0728c25d0c64fc", + "name": "airflow-with-samba", + "sha256": "c04fb6e003e8f3bc61787db8527179e5775b63dbe6d26a8747330c718a5c74c9", + "size": 19594, + "subdir": "linux-64", + "timestamp": 1605878153928, + "version": "1.10.12" + }, + "airflow-with-samba-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "pysmbclient >=0.1.3" + ], + "license": "Apache 2.0", + "md5": "fb5f5cbb136da9c490c6ef014ad65404", + "name": "airflow-with-samba", + "sha256": "936ea81a2c222d2688284492dbb34af807c5da913561dc9c53d37656df6d1b8e", + "size": 17953, + "subdir": "linux-64", + "timestamp": 1579721425260, + "version": "1.10.7" + }, + "airflow-with-sendgrid-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "sendgrid >=6.0.0" + ], + "license": "Apache 2.0", + "md5": "92e56cb78fd8e758cf6e985eed505f4c", + "name": "airflow-with-sendgrid", + "sha256": "160763772864b76c6de050f8fdb1b29006fd25fbd679e68259b82715ade6fb2e", + "size": 19559, + "subdir": "linux-64", + "timestamp": 1605878154940, + "version": "1.10.12" + }, + "airflow-with-sendgrid-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "sendgrid >=6.0.0,<7" + ], + "license": "Apache 2.0", + "md5": "02622461b09352cce842110fa5fa1f9a", + "name": "airflow-with-sendgrid", + "sha256": "825db3e1eae93d853a60f25ae7c522f3754b215b9392aaca34f848cb83b855cf", + "size": 17973, + "subdir": "linux-64", + "timestamp": 1579721426969, + "version": "1.10.7" + }, + "airflow-with-sentry-2.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "blinker >=1.1", + "python >=3.10,<3.11.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "md5": "d853d9a1cd52320500508af4204de754", + "name": "airflow-with-sentry", + "sha256": "6b4d1e408f88e19c7482bf65d311ea4d63c91cbd0ff13d4265c7ba6286df5f33", + "size": 12391, + "subdir": "linux-64", + "timestamp": 1659884223661, + "version": "2.3.3" + }, + "airflow-with-sentry-2.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "blinker >=1.1", + "python >=3.10,<3.11.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "md5": "671514854b74826deeb325a0eb9f251d", + "name": "airflow-with-sentry", + "sha256": "f3af9bd223d44ecb570f2962734421c9fb69deb27bb039957aef257b92605dd7", + "size": 12384, + "subdir": "linux-64", + "timestamp": 1659935163323, + "version": "2.3.3" + }, + "airflow-with-sentry-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "blinker >=1.1", + "python >=3.7,<3.8.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "md5": "b63df9ba40959e97e4318d4c8cde158f", + "name": "airflow-with-sentry", + "sha256": "2c9c644aa0b265af8da64b9371d19f96b968bcdeeabd9c0fd1d1b2a9d53b9769", + "size": 12364, + "subdir": "linux-64", + "timestamp": 1659884206856, + "version": "2.3.3" + }, + "airflow-with-sentry-2.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "blinker >=1.1", + "python >=3.7,<3.8.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "md5": "b075f63ce44237afc9f3c4d43f7e34d1", + "name": "airflow-with-sentry", + "sha256": "fa5f50e9d42f35bee453cc361b39f8f99d0d9b24be366b30df41b07dd58b065e", + "size": 12370, + "subdir": "linux-64", + "timestamp": 1659935151861, + "version": "2.3.3" + }, + "airflow-with-sentry-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "blinker >=1.1", + "python >=3.8,<3.9.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "md5": "5a685403e50920195beadb6180e91a7b", + "name": "airflow-with-sentry", + "sha256": "518ddc7df9292cf0e1e3ce0c179cc1e54bb4997d7a314de045cc44bcba63e915", + "size": 12375, + "subdir": "linux-64", + "timestamp": 1659884212293, + "version": "2.3.3" + }, + "airflow-with-sentry-2.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "blinker >=1.1", + "python >=3.8,<3.9.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "md5": "cf75992d6b5122e9de4991b05543a86c", + "name": "airflow-with-sentry", + "sha256": "17b9aeae6082c0452ca45290eb410dd4abe76130063fa420a10f0a001b1d9b85", + "size": 12357, + "subdir": "linux-64", + "timestamp": 1659935168816, + "version": "2.3.3" + }, + "airflow-with-sentry-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "blinker >=1.1", + "python >=3.9,<3.10.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "md5": "b899f4289505eed7ced779e211074236", + "name": "airflow-with-sentry", + "sha256": "50ddc2775ec623632b576e04f7756cfb1b62887121f6cb2efa7d63a0121c90a9", + "size": 12380, + "subdir": "linux-64", + "timestamp": 1659884217909, + "version": "2.3.3" + }, + "airflow-with-sentry-2.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "blinker >=1.1", + "python >=3.9,<3.10.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "md5": "14ad9d7bc5657da753d2dbf059ec92af", + "name": "airflow-with-sentry", + "sha256": "aa7f68bb473cc6ad998c68a06e412cfa06daf7e2bb69a3445567dec78a11e251", + "size": 12378, + "subdir": "linux-64", + "timestamp": 1659935157485, + "version": "2.3.3" + }, + "airflow-with-sentry-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "blinker >=1.1", + "python >=3.10,<3.11.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "28e0f9c27723e643c8947eaafde412a4", + "name": "airflow-with-sentry", + "sha256": "4c0ae1f01be89946daf953bfb7de76e88526f0bf1be2073f0ebbef53acaff912", + "size": 12401, + "subdir": "linux-64", + "timestamp": 1671227356840, + "version": "2.4.3" + }, + "airflow-with-sentry-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "blinker >=1.1", + "python >=3.7,<3.8.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eab89723d81127db57287e23ec33dd8b", + "name": "airflow-with-sentry", + "sha256": "c75c3c40e9f839050dfba5b315d71425f3b820bfe594a6333d405c55c466ba02", + "size": 12390, + "subdir": "linux-64", + "timestamp": 1671227345179, + "version": "2.4.3" + }, + "airflow-with-sentry-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "blinker >=1.1", + "python >=3.8,<3.9.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1cca2ea0645a5f96f0200345d205af40", + "name": "airflow-with-sentry", + "sha256": "30741d1156b3f29b2bbea2fd6f1879da3dc0e9543fcff188dae7527d7378752b", + "size": 12388, + "subdir": "linux-64", + "timestamp": 1671227362496, + "version": "2.4.3" + }, + "airflow-with-sentry-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "blinker >=1.1", + "python >=3.9,<3.10.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "99c6abb6cd176e7ad6cf6a8ba67471fb", + "name": "airflow-with-sentry", + "sha256": "377a5155624365ba67647ad3e5d54539ee0b5f4441e54d6b4224d2510a090735", + "size": 12375, + "subdir": "linux-64", + "timestamp": 1671227351013, + "version": "2.4.3" + }, + "airflow-with-slack-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "slackclient >=1.0.0,<2.0.0" + ], + "license": "Apache 2.0", + "md5": "066addf29d2008decc07c9d1153c3de0", + "name": "airflow-with-slack", + "sha256": "4d6ed3c470836abe23034f3dfb5bb7d867bea563b59e4543efdeaf3ab4eb37d8", + "size": 19604, + "subdir": "linux-64", + "timestamp": 1605878155985, + "version": "1.10.12" + }, + "airflow-with-slack-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "slackclient >=1.0.0,<2.0.0" + ], + "license": "Apache 2.0", + "md5": "dea9f3ac5fdeab101af0aa3efed74aae", + "name": "airflow-with-slack", + "sha256": "318551f2f85b1f466b2765f05466a9fe94f9e8602268e51fe7f72c49d4c4671e", + "size": 17970, + "subdir": "linux-64", + "timestamp": 1579721428904, + "version": "1.10.7" + }, + "airflow-with-ssh-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "paramiko >=2.1.1", + "pysftp >=0.2.9", + "sshtunnel >=0.1.4,<0.2" + ], + "license": "Apache 2.0", + "md5": "f25d3f2225e023a0e7329e6b5b7d0d57", + "name": "airflow-with-ssh", + "sha256": "a37537c25cd159da6d804b2e25215d1cae1df157b0684ec0df98dfb84a7dbe4c", + "size": 19552, + "subdir": "linux-64", + "timestamp": 1605878157136, + "version": "1.10.12" + }, + "airflow-with-ssh-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "paramiko >=2.1.1", + "pysftp >=0.2.9", + "sshtunnel >=0.1.4,<0.2" + ], + "license": "Apache 2.0", + "md5": "3e1c14a8ec65fd987f0b2ebbcc745c51", + "name": "airflow-with-ssh", + "sha256": "174baf0fe1b53848501c51a343995560ee5320cab3423a0066108fa309e1ee30", + "size": 17978, + "subdir": "linux-64", + "timestamp": 1579721430759, + "version": "1.10.7" + }, + "airflow-with-statsd-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "statsd >=3.3.0,<4.0" + ], + "license": "Apache 2.0", + "md5": "f2ebf1cf614599ca390d8870ebfc733d", + "name": "airflow-with-statsd", + "sha256": "baca07b97c1f8823138ede433a72c5b86954f89b73f6a40c691526cc53224ef4", + "size": 19601, + "subdir": "linux-64", + "timestamp": 1605878158174, + "version": "1.10.12" + }, + "airflow-with-statsd-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "statsd >=3.3.0,<4.0" + ], + "license": "Apache 2.0", + "md5": "d9d95dee406da41a498ec096f4929b23", + "name": "airflow-with-statsd", + "sha256": "7e1119ff2e7bb24ea8ccd55cab5416009ee9d13760812e8f3c640c062512c84e", + "size": 17976, + "subdir": "linux-64", + "timestamp": 1579721432593, + "version": "1.10.7" + }, + "airflow-with-statsd-2.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.10,<3.11.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "md5": "595f12d7f905f3c3126747cd0fb843ad", + "name": "airflow-with-statsd", + "sha256": "7692be5250ba749270ed87bcf759b20b0c1af990425bde47489ddbd2016bf109", + "size": 12380, + "subdir": "linux-64", + "timestamp": 1659884245843, + "version": "2.3.3" + }, + "airflow-with-statsd-2.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.10,<3.11.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "md5": "6878f689b865a41007201fc3b637815e", + "name": "airflow-with-statsd", + "sha256": "e3cf256936a132e79d540170670bf1b15bc3782361ff2de80528abed2843bdc0", + "size": 12359, + "subdir": "linux-64", + "timestamp": 1659935185681, + "version": "2.3.3" + }, + "airflow-with-statsd-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.7,<3.8.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "md5": "2566fcc02c8e9c7a0339e544fa8e00f4", + "name": "airflow-with-statsd", + "sha256": "8f4fc1700d8cee4b837ca041ccad51772cf545e35c368429e83f5ac930143cf6", + "size": 12339, + "subdir": "linux-64", + "timestamp": 1659884229041, + "version": "2.3.3" + }, + "airflow-with-statsd-2.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.7,<3.8.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "md5": "74ee9c9e91ca552fa46786471a3a36c3", + "name": "airflow-with-statsd", + "sha256": "ca3c79e7c7bbb86d12621e9051a2194b71186921484359f234e199125ea71864", + "size": 12337, + "subdir": "linux-64", + "timestamp": 1659935174309, + "version": "2.3.3" + }, + "airflow-with-statsd-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.8,<3.9.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "md5": "681882eded8d37272d67e38b7e9ec5b7", + "name": "airflow-with-statsd", + "sha256": "5ae7335d48d2d2f7a5d76ba4996043c64c6b06d7058075b253b7889a5f0e5012", + "size": 12324, + "subdir": "linux-64", + "timestamp": 1659884234445, + "version": "2.3.3" + }, + "airflow-with-statsd-2.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.8,<3.9.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "md5": "aa26f48f338fa37abd1e117cbfb47e5a", + "name": "airflow-with-statsd", + "sha256": "ec56c76fb8c2b5b82635d7a03dd70f6aae163d833ae271c33c9a91b93acafb2e", + "size": 12334, + "subdir": "linux-64", + "timestamp": 1659935191152, + "version": "2.3.3" + }, + "airflow-with-statsd-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.9,<3.10.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "md5": "daa6b2815291a630be37c839506681db", + "name": "airflow-with-statsd", + "sha256": "25f6841fe813acd19507a6e9338fc4942f2777e6895fc160369fa85f52328c3b", + "size": 12344, + "subdir": "linux-64", + "timestamp": 1659884240076, + "version": "2.3.3" + }, + "airflow-with-statsd-2.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.9,<3.10.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "md5": "59a1ef1dd7c3e880dc2bacbbca2647aa", + "name": "airflow-with-statsd", + "sha256": "5285eb5a14e6bf5bd692322345db9a75cc1d73bc253884e3a6a72dd75396230c", + "size": 12341, + "subdir": "linux-64", + "timestamp": 1659935179962, + "version": "2.3.3" + }, + "airflow-with-statsd-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.10,<3.11.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aa03abf86ff9d8252d11e357411a6c87", + "name": "airflow-with-statsd", + "sha256": "24208de5dfd6df455135f0df82d36f07a549c3d15250557939a25a69ef9cc2d6", + "size": 12392, + "subdir": "linux-64", + "timestamp": 1671227379788, + "version": "2.4.3" + }, + "airflow-with-statsd-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.7,<3.8.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e6b24dc5a89b02f80a0a8da2608ece88", + "name": "airflow-with-statsd", + "sha256": "e367c83073248e02d741400602acf2ed13a8ae06cce989abdabb76fc6c6084c5", + "size": 12363, + "subdir": "linux-64", + "timestamp": 1671227368108, + "version": "2.4.3" + }, + "airflow-with-statsd-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.8,<3.9.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d5711f0d0dac6a9d569df7d77eeb6878", + "name": "airflow-with-statsd", + "sha256": "d6186f7c8a3e1431cf9a1f8f267041d610b7119bfce009c99c3b751fd9143ee6", + "size": 12359, + "subdir": "linux-64", + "timestamp": 1671227385459, + "version": "2.4.3" + }, + "airflow-with-statsd-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.9,<3.10.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "77b277931c73fad99ca06ff08d495dc0", + "name": "airflow-with-statsd", + "sha256": "99d68fa3388542425b49d9266c757baec1775a8061963c5fcfc3cd7aefd8e8ce", + "size": 12371, + "subdir": "linux-64", + "timestamp": 1671227373913, + "version": "2.4.3" + }, + "airflow-with-vertica-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "vertica-python >=0.5.1" + ], + "license": "Apache 2.0", + "md5": "18821473352f400354d275a83ed36c3d", + "name": "airflow-with-vertica", + "sha256": "c31d8dee37ccca41b303a66e44acbbbe2de91c119ada064a6dd9ce199e62758d", + "size": 19511, + "subdir": "linux-64", + "timestamp": 1605878159206, + "version": "1.10.12" + }, + "airflow-with-vertica-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "vertica-python >=0.5.1" + ], + "license": "Apache 2.0", + "md5": "16f04948f17c467b44416a5c4954fa91", + "name": "airflow-with-vertica", + "sha256": "16ea056b025f8d1e532e4d49560b25245c331370e9ada7135fbccaf1188651a1", + "size": 17974, + "subdir": "linux-64", + "timestamp": 1579721434275, + "version": "1.10.7" + }, + "airflow-with-virtualenv-2.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.10,<3.11.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "md5": "838b0def9acb8b8364f45daa5a5363ed", + "name": "airflow-with-virtualenv", + "sha256": "a9a1ebf7abe7d3b08eddb78ebef25e61dffbd340ff0ea76d850629fdd7584b0c", + "size": 12362, + "subdir": "linux-64", + "timestamp": 1659884268023, + "version": "2.3.3" + }, + "airflow-with-virtualenv-2.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.10,<3.11.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "md5": "5b0f6f46e9911ba3c171f8da711fbb58", + "name": "airflow-with-virtualenv", + "sha256": "d999192e323ded2318f5a5551cd4776875970b7482d923717a747b423fd266d6", + "size": 12350, + "subdir": "linux-64", + "timestamp": 1659935207997, + "version": "2.3.3" + }, + "airflow-with-virtualenv-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.7,<3.8.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "md5": "90fb94e1d35778e897a242984c457b5e", + "name": "airflow-with-virtualenv", + "sha256": "a239da791d848dc675cb52a7aaa9d2993a8bf91186ca71149ebce800be756369", + "size": 12330, + "subdir": "linux-64", + "timestamp": 1659884251255, + "version": "2.3.3" + }, + "airflow-with-virtualenv-2.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.7,<3.8.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "md5": "9ca68bb55e7066b65f5a74c6e46bcade", + "name": "airflow-with-virtualenv", + "sha256": "9633078685f0d7d90e4342a62492b756f47baea4fa90481c2bcb6c982d839c55", + "size": 12337, + "subdir": "linux-64", + "timestamp": 1659935196533, + "version": "2.3.3" + }, + "airflow-with-virtualenv-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.8,<3.9.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "md5": "836d4cf9772a9ebe2456c9b862ba82b7", + "name": "airflow-with-virtualenv", + "sha256": "55aa2f5cb05290cf7bfe3d262fcdc7bc739cd993df93d4e8b03af1ad3ecbbf26", + "size": 12338, + "subdir": "linux-64", + "timestamp": 1659884256732, + "version": "2.3.3" + }, + "airflow-with-virtualenv-2.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.8,<3.9.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "md5": "f9f0c0874ceeac9ca35b201d05f525a6", + "name": "airflow-with-virtualenv", + "sha256": "5b7e3403515c1890a5cbc0fc3900839736b4750bf210feb7d7f917d4f252547f", + "size": 12331, + "subdir": "linux-64", + "timestamp": 1659935213486, + "version": "2.3.3" + }, + "airflow-with-virtualenv-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.9,<3.10.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "md5": "2371a16a06ebc2a11ec3ce4cc9ead7f6", + "name": "airflow-with-virtualenv", + "sha256": "ca0d21d9f5a0d615584ccacc532d5e05d90bda7de86d06fcdcefe97964730138", + "size": 12333, + "subdir": "linux-64", + "timestamp": 1659884262225, + "version": "2.3.3" + }, + "airflow-with-virtualenv-2.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.9,<3.10.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "md5": "4bb188360a107b2865d4ba46b7342457", + "name": "airflow-with-virtualenv", + "sha256": "f8d90f9f5369fb60a2f2acf2679bd0134d780bdaa43667775773b9b539915159", + "size": 12330, + "subdir": "linux-64", + "timestamp": 1659935202231, + "version": "2.3.3" + }, + "airflow-with-virtualenv-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.10,<3.11.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3877051b7e1795aa23fa65126e3186df", + "name": "airflow-with-virtualenv", + "sha256": "12d4436a4719dc3e63a167805a98bf8ee9ab891fd920f29f31527e59529ae883", + "size": 12389, + "subdir": "linux-64", + "timestamp": 1671227402954, + "version": "2.4.3" + }, + "airflow-with-virtualenv-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.7,<3.8.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a0389e63a591d54179cf4e63056a77f3", + "name": "airflow-with-virtualenv", + "sha256": "fbdaa7d34b44c4c8ba8a72019922da4528376581078c6354220ab2d38e4240bd", + "size": 12363, + "subdir": "linux-64", + "timestamp": 1671227391105, + "version": "2.4.3" + }, + "airflow-with-virtualenv-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.8,<3.9.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7c34dab8f1c9dac3b143a1f0bbd323f9", + "name": "airflow-with-virtualenv", + "sha256": "71ab0ddcac9079f253547c3311f0739a51c979d0efa1619196ae6ca741f35950", + "size": 12367, + "subdir": "linux-64", + "timestamp": 1671227408471, + "version": "2.4.3" + }, + "airflow-with-virtualenv-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.9,<3.10.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "de7ce8c058f6ea889c4a848fcd0627ed", + "name": "airflow-with-virtualenv", + "sha256": "d62325270b0a6f8f43c315e6ff6dd1b36d7f6e58f4cbfa8f88166ded6968e754", + "size": 12356, + "subdir": "linux-64", + "timestamp": 1671227396958, + "version": "2.4.3" + }, + "airflow-with-webhdfs-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "python-hdfs >=0.5.1" + ], + "license": "Apache 2.0", + "md5": "ebfd81fb71afe845c460d1cdcf0cf247", + "name": "airflow-with-webhdfs", + "sha256": "ef873c55c279133e0e6a229092c989a89708e670040df37d02b1dd9627d69edf", + "size": 19600, + "subdir": "linux-64", + "timestamp": 1605878160246, + "version": "1.10.12" + }, + "airflow-with-webhdfs-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "python-hdfs >=0.5.1" + ], + "license": "Apache 2.0", + "md5": "4ca87fd55497e5a8b2fb855bd84fe7d7", + "name": "airflow-with-webhdfs", + "sha256": "8898f266d2aac2d352f9e9712961988275e49bc88ce1ff9b8d2a2f08c45af0c5", + "size": 17956, + "subdir": "linux-64", + "timestamp": 1579721436174, + "version": "1.10.7" + }, + "airflow-with-winrm-1.10.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "pywinrm >=0.4.0,<0.5.0" + ], + "license": "Apache 2.0", + "md5": "609e952f399d4856979f44f19af6cdf1", + "name": "airflow-with-winrm", + "sha256": "9f1facdc3cc7a12eb33cc21563267b766a19b909fc6b47f63c7a3396af13515f", + "size": 19584, + "subdir": "linux-64", + "timestamp": 1605878161291, + "version": "1.10.12" + }, + "airflow-with-winrm-1.10.7-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "pywinrm >=0.4.0,<0.5.0" + ], + "license": "Apache 2.0", + "md5": "f62ebc616cff31a2636024dd919c2b02", + "name": "airflow-with-winrm", + "sha256": "c1a75f7d58335e8dd70d51e4bec80765d9367aee48a8649c7009547d867c97c1", + "size": 17976, + "subdir": "linux-64", + "timestamp": 1579721437899, + "version": "1.10.7" + }, + "alabaster-0.7.10-py27he5a193a_0.tar.bz2": { + "build": "py27he5a193a_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "82249285b3cfd55cec90947b16f767af", + "name": "alabaster", + "sha256": "e14c2066209288d7523b0ef53bea8ee47c4e53de6576622d18abd102f3488271", + "size": 14782, + "subdir": "linux-64", + "timestamp": 1505691153490, + "version": "0.7.10" + }, + "alabaster-0.7.10-py35h6fb19ab_0.tar.bz2": { + "build": "py35h6fb19ab_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d92cea1a62bcc0e3c03bb8cfa966a042", + "name": "alabaster", + "sha256": "28949d52bc2f56680ffcc912a1e78dd79ae854517c31aad9526ebcbc6dd9dda2", + "size": 14869, + "subdir": "linux-64", + "timestamp": 1505691164612, + "version": "0.7.10" + }, + "alabaster-0.7.10-py36h306e16b_0.tar.bz2": { + "build": "py36h306e16b_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "95b2539fb7de4d01e2395d85082cb0fb", + "name": "alabaster", + "sha256": "96951b0ceeb3851e944b2779570c53c9fbe701679d256c811465547b147f465c", + "size": 14910, + "subdir": "linux-64", + "timestamp": 1505691175753, + "version": "0.7.10" + }, + "alabaster-0.7.11-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "46ca1451c07a2a65640cf28d7fb44994", + "name": "alabaster", + "sha256": "4522369bbdbebb8e9c9d5512badcf32f353b78421b35b603ef0cd01aea51ecbf", + "size": 16812, + "subdir": "linux-64", + "timestamp": 1529940183940, + "version": "0.7.11" + }, + "alabaster-0.7.11-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9a013b92bee61b3697dab90c5b79e301", + "name": "alabaster", + "sha256": "f3bd34be1bca5e32e477dd0a709c898ad62934b60a82efde8548e8831caf3633", + "size": 16846, + "subdir": "linux-64", + "timestamp": 1529940257160, + "version": "0.7.11" + }, + "alabaster-0.7.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "10c94d2b4cf9bcdd76cc66ed97bc5d94", + "name": "alabaster", + "sha256": "8c1a607dd2c4e2d34445ce993f54c78025bb3bb0720d1932eb04ffd1ef396f13", + "size": 16932, + "subdir": "linux-64", + "timestamp": 1529940165125, + "version": "0.7.11" + }, + "alabaster-0.7.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0ede762c4f151476041189b5e5eeb5c4", + "name": "alabaster", + "sha256": "5f0375266df92c37210672b49062c2f9ea3662cfeeec72d7adb09b4b8adf11df", + "size": 16904, + "subdir": "linux-64", + "timestamp": 1530695334007, + "version": "0.7.11" + }, + "alabaster-0.7.12-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "08ad1d00dec9c3074e186f055ae9cee9", + "name": "alabaster", + "sha256": "799b91b120092665e20b786c69f48c47f806335d16ddf3393e598aa8792dcc98", + "size": 17344, + "subdir": "linux-64", + "timestamp": 1539023474930, + "version": "0.7.12" + }, + "alabaster-0.7.12-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b687af42ff2f44b1f934f5ac7d5e2c3a", + "name": "alabaster", + "sha256": "f8bd32d25c2d5cd1cd0d73f42429fb7290a5771b90bdb23b9f3ff59a49116238", + "size": 17433, + "subdir": "linux-64", + "timestamp": 1539023484485, + "version": "0.7.12" + }, + "alabaster-0.7.12-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "20033a8667ea2162ffd720271c6c725c", + "name": "alabaster", + "sha256": "948f91fc77362d09a5dadcd672a0c2bf474fad1b8c646630c4c3950688fcb9c1", + "size": 17435, + "subdir": "linux-64", + "timestamp": 1539023442571, + "version": "0.7.12" + }, + "alembic-0.9.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e2a1f7a17267a6f69c045cef7eb015e4", + "name": "alembic", + "sha256": "d1b4c1a9204d1dd02567d676787908facb7d3289319f898a365809318442d682", + "size": 219944, + "subdir": "linux-64", + "timestamp": 1530593104099, + "version": "0.9.10" + }, + "alembic-0.9.10-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e090b96ebd56162399cda86dc399576e", + "name": "alembic", + "sha256": "748fc80484a4b8cfe62339555af14b70427ba66030815e1dc449cefc79d6f13c", + "size": 224729, + "subdir": "linux-64", + "timestamp": 1530593136543, + "version": "0.9.10" + }, + "alembic-0.9.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c51bb393689391caec9f5cc5544f27c9", + "name": "alembic", + "sha256": "7d39f45433a00befcd6422ce26e70ae8340f7996ac656564654112c3fe02dc93", + "size": 227097, + "subdir": "linux-64", + "timestamp": 1530593124216, + "version": "0.9.10" + }, + "alembic-0.9.10-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d28bd258eafb87e34e1b30e18f936d7", + "name": "alembic", + "sha256": "d5c32c21cfb7a23a913dc1cf52977b412f9a4fef8ea340849020fe83d2858a74", + "size": 227314, + "subdir": "linux-64", + "timestamp": 1530737144841, + "version": "0.9.10" + }, + "alembic-0.9.5-py27h0668a64_0.tar.bz2": { + "build": "py27h0668a64_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2828b4d5c46faec71c45013b6d82412", + "name": "alembic", + "sha256": "ff80448c8d863fd068fe842121a634cb5cc0f07ed8d9439ed0b1d12a39b05176", + "size": 214193, + "subdir": "linux-64", + "timestamp": 1505691467247, + "version": "0.9.5" + }, + "alembic-0.9.5-py35h387e2dd_0.tar.bz2": { + "build": "py35h387e2dd_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c6870f90209df02ca8f169765f9e6e6b", + "name": "alembic", + "sha256": "6379fe9859b3883bc979f7b37044a6eac9eeaa3b3ea2adb65c3b2429526f5002", + "size": 221476, + "subdir": "linux-64", + "timestamp": 1505691483011, + "version": "0.9.5" + }, + "alembic-0.9.5-py36h968a0d3_0.tar.bz2": { + "build": "py36h968a0d3_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c0fb6162e82ba47e1e8f684975d3640", + "name": "alembic", + "sha256": "afec7f553866966f1bc081df42f85daea3bb121f223427994c2348ab111d092c", + "size": 219611, + "subdir": "linux-64", + "timestamp": 1505691499009, + "version": "0.9.5" + }, + "alembic-0.9.6-py27he2127cc_0.tar.bz2": { + "build": "py27he2127cc_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92bed54931767b6225f63ae2d3ff7c67", + "name": "alembic", + "sha256": "2af9605a4d4360e714a49549492999de7af2456b112e09915fb7eae688c80055", + "size": 219002, + "subdir": "linux-64", + "timestamp": 1511837739079, + "version": "0.9.6" + }, + "alembic-0.9.6-py35h2ca1cdd_0.tar.bz2": { + "build": "py35h2ca1cdd_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f4a9603be4fe03a4e85503cc45ecab4", + "name": "alembic", + "sha256": "cf4b7626e4818073412d4af049d4686966d99968abb75320d13e0d3715011542", + "size": 223683, + "subdir": "linux-64", + "timestamp": 1511837777294, + "version": "0.9.6" + }, + "alembic-0.9.6-py36h01b5dd9_0.tar.bz2": { + "build": "py36h01b5dd9_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b342baecad21ff9fc35a8e9e0df09c94", + "name": "alembic", + "sha256": "a07769f7bd91fc7b87cb230a03cfa4f5364ebe948d7d221d8d40d137d52199e8", + "size": 225055, + "subdir": "linux-64", + "timestamp": 1511837776582, + "version": "0.9.6" + }, + "alembic-0.9.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "193d4196e3d855e8d354e9ff97573812", + "name": "alembic", + "sha256": "6b818a723908e83efee005258c7beb4b7849ef72e95a746b0a970becf57d58cd", + "size": 220424, + "subdir": "linux-64", + "timestamp": 1522084443633, + "version": "0.9.9" + }, + "alembic-0.9.9-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3463909c319218d24a04b0dee4b675e", + "name": "alembic", + "sha256": "a04ec7567cef3d4b5c6d4a3dcf5441d34dfff301817a4a889c88976a78bc9496", + "size": 224972, + "subdir": "linux-64", + "timestamp": 1522084331091, + "version": "0.9.9" + }, + "alembic-0.9.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dfe567b850fb8c793ab7f570eaa62078", + "name": "alembic", + "sha256": "ca44606ef559fa099e1d1096921721686bf4530d8ff0beb29fcab475109617f7", + "size": 226645, + "subdir": "linux-64", + "timestamp": 1522084467176, + "version": "0.9.9" + }, + "alembic-1.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d1303727e0c60bba5b92f171702b5bf", + "name": "alembic", + "sha256": "bafc8cc2689f5dff13195b545fe906a67ea805eda25ade0f27a91a5eddd2fd19", + "size": 219327, + "subdir": "linux-64", + "timestamp": 1535498805316, + "version": "1.0.0" + }, + "alembic-1.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "46e8633d294fb88ae5a9d3f6dd345024", + "name": "alembic", + "sha256": "fa56e95a8599d9a4313d8340223cfaabba62c94c3c25c478188b0c8f1a32e2ea", + "size": 223855, + "subdir": "linux-64", + "timestamp": 1535498819562, + "version": "1.0.0" + }, + "alembic-1.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1178b428d7325b16c5ec04e4ee3a9ef1", + "name": "alembic", + "sha256": "25e06ec6cc88d117b98d86ebed7160c91cd50641d41cc17391df51be8f87954a", + "size": 226077, + "subdir": "linux-64", + "timestamp": 1535498792032, + "version": "1.0.0" + }, + "alembic-1.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd747ef965a92c9b58f457e35e495324", + "name": "alembic", + "sha256": "693e8384ddadb5890f62226f5c2b749909c170342ae3f96d1c492122574c3bd2", + "size": 226641, + "subdir": "linux-64", + "timestamp": 1535498827972, + "version": "1.0.0" + }, + "alembic-1.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f02e117e880a25504ce57868c2a3246f", + "name": "alembic", + "sha256": "8d66d7a58095605aa4493a0292bd552c04c3ba4ed29820cf292a39a54b4a8c7f", + "size": 228393, + "subdir": "linux-64", + "timestamp": 1540955663531, + "version": "1.0.1" + }, + "alembic-1.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "365748a109a27f6e96aee8e116fabeee", + "name": "alembic", + "sha256": "2fa47189f5e5d0bd74b057d052514413e1b171ee16eddde26363bb86be584231", + "size": 233905, + "subdir": "linux-64", + "timestamp": 1540955741397, + "version": "1.0.1" + }, + "alembic-1.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb270afdee0bbe749c73429ca377ff09", + "name": "alembic", + "sha256": "4b88e4509d150460cb5b39bc1f0476b78464e52b023befff68e94e5dd8f8d239", + "size": 234329, + "subdir": "linux-64", + "timestamp": 1540955723847, + "version": "1.0.1" + }, + "alembic-1.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9856ff5f8223ec25f3e000fb4eeceedd", + "name": "alembic", + "sha256": "74045971bd8dcaea3e5ca3e80c3558b6ea75edc68fad30b72b68b5177bd3b616", + "size": 228861, + "subdir": "linux-64", + "timestamp": 1541134517150, + "version": "1.0.2" + }, + "alembic-1.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21f412a32460c957d552e3b05f980749", + "name": "alembic", + "sha256": "b2b087bcf0281ba5ffdb962a7e224d11b8910f109a1600d2fb233cde7df77247", + "size": 234012, + "subdir": "linux-64", + "timestamp": 1541134545219, + "version": "1.0.2" + }, + "alembic-1.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "10a5ab1ee6e1584dae79e6999c0e46f3", + "name": "alembic", + "sha256": "4cdbdd1b9a0f93780cfab95ce33e8c448503587ba516dad4752e34168f453a7b", + "size": 230603, + "subdir": "linux-64", + "timestamp": 1541134511613, + "version": "1.0.2" + }, + "alembic-1.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56ce67d2935c6e34863a96b98d8aea17", + "name": "alembic", + "sha256": "2bca369928339def1081e90baa351f401b550203982aa0af0a3ba5bd251d20f0", + "size": 228854, + "subdir": "linux-64", + "timestamp": 1542384908984, + "version": "1.0.3" + }, + "alembic-1.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "69441137d3bca9cf0702edcdd13c25b2", + "name": "alembic", + "sha256": "438f6ba62054d62845b5f6a73961aacc0756e893c932968e4dc1bb0ade554fce", + "size": 234156, + "subdir": "linux-64", + "timestamp": 1542384929872, + "version": "1.0.3" + }, + "alembic-1.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e1ca5802cdc00fb444d800159cdb54d", + "name": "alembic", + "sha256": "d92c25bdd2b4ff2e9395960c5773d32f233e26a303b0584e5f25bd88317936f6", + "size": 231536, + "subdir": "linux-64", + "timestamp": 1542385021150, + "version": "1.0.3" + }, + "alembic-1.0.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "10d80d90fc5b993e4f51f249107921ab", + "name": "alembic", + "sha256": "e6f6c7e004e3c2b6644c8349cc8896dc9577a2f956e5443725f2532f943805f0", + "size": 234213, + "subdir": "linux-64", + "timestamp": 1543447473746, + "version": "1.0.5" + }, + "alembic-1.0.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8cf59a155d467c0eeb95da2f9d070c54", + "name": "alembic", + "sha256": "2e272acc45a55864642d4c60b14289f11126cdd863dc70bda6bfc3ed8a13183f", + "size": 238706, + "subdir": "linux-64", + "timestamp": 1543447486330, + "version": "1.0.5" + }, + "alembic-1.0.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "70566a37a86e3d88f711feaa722afae4", + "name": "alembic", + "sha256": "16a0e7902cba9d6e7aaa86a6654b3de4fd78bf5b67c3118d77819f5641acd52a", + "size": 240158, + "subdir": "linux-64", + "timestamp": 1543447469664, + "version": "1.0.5" + }, + "alembic-1.0.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "777a7701ca25b4fad19170a32b892bef", + "name": "alembic", + "sha256": "2e87d6ed02336ff35eb34906b7498e218a264ba1734ff3fc45b38c3cd660d80b", + "size": 241337, + "subdir": "linux-64", + "timestamp": 1547746784785, + "version": "1.0.6" + }, + "alembic-1.0.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b17fbc79482828bc05f240365855e4a", + "name": "alembic", + "sha256": "549fbe295a10f651af5d6e2595a474df94244d2bffe04703f5fbd938d3e488f3", + "size": 245489, + "subdir": "linux-64", + "timestamp": 1547746879191, + "version": "1.0.6" + }, + "alembic-1.0.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b32d70bb7606d8f6dc57317004fb1f3a", + "name": "alembic", + "sha256": "c3bd52af41cd4c2a102c3437b95aed8f779f5eda5a73807477e85969480d2441", + "size": 245780, + "subdir": "linux-64", + "timestamp": 1547746844533, + "version": "1.0.6" + }, + "alembic-1.0.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c8be4497e81aad00477da13bdfe3dab", + "name": "alembic", + "sha256": "33f8957eef4389f5e7b70ca74bfc24d275c5e77354ff9aaa0c046434a2ddaaf9", + "size": 240980, + "subdir": "linux-64", + "timestamp": 1550266237506, + "version": "1.0.7" + }, + "alembic-1.0.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3390a8f89d683aef60261255ff68124", + "name": "alembic", + "sha256": "d0d68b4ec858de11e3788006d776984966a75203346c2d1c5f4d8ad67cee03eb", + "size": 241646, + "subdir": "linux-64", + "timestamp": 1550266249719, + "version": "1.0.7" + }, + "alembic-1.0.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a49579bfee52a7079be25ace0f951b3c", + "name": "alembic", + "sha256": "fb14fd7fcee0bfa0c5cf5b2696bd2fb08165593e866f82975aeb977252081ad6", + "size": 241723, + "subdir": "linux-64", + "timestamp": 1550266171298, + "version": "1.0.7" + }, + "alembic-1.0.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "acd54e1ddaff943ece93f90b262dce6d", + "name": "alembic", + "sha256": "bb35645c7db6a02a7fa732a25013017a3b860ca899d9b5ed71673b7f71d99d97", + "size": 245767, + "subdir": "linux-64", + "timestamp": 1556061898947, + "version": "1.0.9" + }, + "alembic-1.0.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eee1197d2fefdf4587987306ca97c277", + "name": "alembic", + "sha256": "51eba524012124c99addb406e1de3f46d85857dad115e2eb73953a66f8e23edb", + "size": 250697, + "subdir": "linux-64", + "timestamp": 1556061765476, + "version": "1.0.9" + }, + "alembic-1.0.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "27d323c326605d2e8fd9ed51585d671e", + "name": "alembic", + "sha256": "1bfadf770010af7c4378e4fa495290af06872056975bced2f11ffd919b9d168e", + "size": 251303, + "subdir": "linux-64", + "timestamp": 1556061885231, + "version": "1.0.9" + }, + "alembic-1.8.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "sqlalchemy >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b839900b30f51363b5d34bc81b620841", + "name": "alembic", + "sha256": "e0c1671444b11396430f3adf31c8032037c2df3a31d195637ccb839f82b35568", + "size": 314005, + "subdir": "linux-64", + "timestamp": 1666725262585, + "version": "1.8.1" + }, + "alembic-1.8.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.11,<3.12.0a0", + "python-dateutil", + "sqlalchemy >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d15d6e32573ee639237eca6af07da50b", + "name": "alembic", + "sha256": "11bce290b3d877475743a43750a5df92165ed14a5b38304982d2c0390be4201e", + "size": 399151, + "subdir": "linux-64", + "timestamp": 1676828949480, + "version": "1.8.1" + }, + "alembic-1.8.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "importlib_resources", + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "sqlalchemy >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9198f586a35f39c79e9f5cc2e630eb74", + "name": "alembic", + "sha256": "b44b5a63a97672949a0bb8e594075c209ae338b26befd3b7d6e8f3eefa9e8586", + "size": 306411, + "subdir": "linux-64", + "timestamp": 1666725317651, + "version": "1.8.1" + }, + "alembic-1.8.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "importlib_resources", + "mako", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "sqlalchemy >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d2477bea606bf15f4733b0df42f74cd", + "name": "alembic", + "sha256": "048e327f696598097bbea4935bcf1ed4b11d5befbca86adaf26f9e506a6e60a4", + "size": 309237, + "subdir": "linux-64", + "timestamp": 1666725289571, + "version": "1.8.1" + }, + "alembic-1.8.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "sqlalchemy >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be5ed0b68c3ac123f2d5b7af0d804ff0", + "name": "alembic", + "sha256": "95cf0f78bb71cf269b3058d3352f2bf8db77f24b8b48fce19e7e3812a9c701c3", + "size": 309025, + "subdir": "linux-64", + "timestamp": 1666725345159, + "version": "1.8.1" + }, + "altair-3.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jinja2", + "jsonschema", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "six", + "toolz", + "typing >=3.6" + ], + "license": "BSD-3-Clause", + "md5": "eb8ff4e50151c010a9bef1b9263f94d6", + "name": "altair", + "sha256": "e86484786c6a07715f0c702f89dd94dc43960042cb892cae82bdfee92fbb4610", + "size": 933249, + "subdir": "linux-64", + "timestamp": 1567626337409, + "version": "3.2.0" + }, + "altair-3.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jinja2", + "jsonschema", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "six", + "toolz" + ], + "license": "BSD-3-Clause", + "md5": "e8c8adb956df2acf09b6972c11ae2822", + "name": "altair", + "sha256": "ed1644e8a6d813a3a63e1c5afb3d2b335147059ab8250c371378ce242d9b9b5a", + "size": 915050, + "subdir": "linux-64", + "timestamp": 1567626343741, + "version": "3.2.0" + }, + "altair-3.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jinja2", + "jsonschema", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "six", + "toolz" + ], + "license": "BSD-3-Clause", + "md5": "aab5160a5c98babfbd106ad52f4d3f82", + "name": "altair", + "sha256": "4b46324f4c46420b318c7385cc92b8125d2ace94e1ff8f918487523d775dc497", + "size": 929491, + "subdir": "linux-64", + "timestamp": 1567626396103, + "version": "3.2.0" + }, + "altair-3.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jinja2", + "jsonschema", + "numpy", + "pandas", + "python >=3.8,<3.9.0a0", + "six", + "toolz" + ], + "license": "BSD-3-Clause", + "md5": "241740520b2b87abb4c1c11ac21f1149", + "name": "altair", + "sha256": "4262b5d28a8915106dbbe570bb0a70100b911294639a25e389f1a221f3068e15", + "size": 782294, + "subdir": "linux-64", + "timestamp": 1574412817810, + "version": "3.2.0" + }, + "altgraph-0.17.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f968627352887ba1f5669e6cb5fe6e03", + "name": "altgraph", + "sha256": "7de15070aa741988cc652489a37d9ac9ecd1ff1ce426dc8395b76d588625e99a", + "size": 34729, + "subdir": "linux-64", + "timestamp": 1670426131517, + "version": "0.17.3" + }, + "altgraph-0.17.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e0250a7d58b5156f3735d338c692512", + "name": "altgraph", + "sha256": "d7217f853f97cb40d8162f7005e4cd393be712f0511c45ab80b89ce4d9046df3", + "size": 42992, + "subdir": "linux-64", + "timestamp": 1676828963834, + "version": "0.17.3" + }, + "altgraph-0.17.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c262986d6f79e86e21583c3690041f6d", + "name": "altgraph", + "sha256": "caf4c3add5ac52afa458f15963b087e3175c2dbc217ca1c64e1f4ce7b6ceae58", + "size": 34450, + "subdir": "linux-64", + "timestamp": 1670426156483, + "version": "0.17.3" + }, + "altgraph-0.17.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f4bb930db188ccf952c126823fb6ee78", + "name": "altgraph", + "sha256": "1d4f96514a4aa525bd87cfa1851c481fedfce6ba08eab607174d09efe3f5abc4", + "size": 34376, + "subdir": "linux-64", + "timestamp": 1670426180927, + "version": "0.17.3" + }, + "altgraph-0.17.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b59f5502d58ed46e0dbc4601b261c7af", + "name": "altgraph", + "sha256": "f3eb2d7283dd416c64d8fd22069c6c6abf8a9a7cd1ef75a8ae912fcdc706d1f3", + "size": 34378, + "subdir": "linux-64", + "timestamp": 1670426106548, + "version": "0.17.3" + }, + "ampl-mp-3.1.0-hf726d26_1005.tar.bz2": { + "build": "hf726d26_1005", + "build_number": 1005, + "depends": [ + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "HPND", + "md5": "bc2b95e9f5c39749a253ab6a640c063f", + "name": "ampl-mp", + "sha256": "bed8a989e7273b80fe8c156d2e8670fbe74c6d516aa4d728f3bddfbdc8013ef3", + "size": 1100801, + "subdir": "linux-64", + "timestamp": 1632752000990, + "version": "3.1.0" + }, + "anaconda-2018.12-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.12 py27_0", + "anaconda-client 1.7.2 py27_0", + "anaconda-project 0.8.2 py27_0", + "asn1crypto 0.24.0 py27_0", + "astroid 1.6.5 py27_0", + "astropy 2.0.9 py27hdd07704_0", + "atomicwrites 1.2.1 py27_0", + "attrs 18.2.0 py27h28b3542_0", + "babel 2.6.0 py27_0", + "backports 1.0 py27_1", + "backports.functools_lru_cache 1.5 py27_1", + "backports.os 0.1.1 py27_0", + "backports.shutil_get_terminal_size 1.0.0 py27_2", + "backports_abc 0.5 py27h7b3c97b_0", + "beautifulsoup4 4.6.3 py27_0", + "bitarray 0.8.3 py27h14c3975_0", + "bkcharts 0.2 py27h241ae91_0", + "blas 1.0 mkl", + "blaze 0.11.3 py27_0", + "bleach 3.0.2 py27_0", + "blosc 1.14.4 hdbcaa40_0", + "bokeh 1.0.2 py27_0", + "boto 2.49.0 py27_0", + "bottleneck 1.2.1 py27h035aef0_1", + "bzip2 1.0.6 h14c3975_5", + "ca-certificates 2018.03.07 0", + "cairo 1.14.12 h8948797_3", + "cdecimal 2.3 py27h14c3975_3", + "certifi 2018.11.29 py27_0", + "cffi 1.11.5 py27he75722e_1", + "chardet 3.0.4 py27_1", + "click 7.0 py27_0", + "cloudpickle 0.6.1 py27_0", + "clyent 1.2.2 py27_1", + "colorama 0.4.1 py27_0", + "configparser 3.5.0 py27h5117587_0", + "contextlib2 0.5.5 py27hbf4c468_0", + "cryptography 2.4.2 py27h1ba5d50_0", + "curl 7.63.0 hbc83047_1000", + "cycler 0.10.0 py27hc7354d3_0", + "cython 0.29.2 py27he6710b0_0", + "cytoolz 0.9.0.1 py27h14c3975_1", + "dask 1.0.0 py27_0", + "dask-core 1.0.0 py27_0", + "datashape 0.5.4 py27_1", + "dbus 1.13.2 h714fa37_1", + "decorator 4.3.0 py27_0", + "defusedxml 0.5.0 py27_1", + "distributed 1.25.1 py27_0", + "docutils 0.14 py27hae222c1_0", + "entrypoints 0.2.3 py27_2", + "enum34 1.1.6 py27_1", + "et_xmlfile 1.0.1 py27h75840f5_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.0.2 py27h14c3975_2", + "filelock 3.0.10 py27_0", + "flask 1.0.2 py27_1", + "flask-cors 3.0.7 py27_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "funcsigs 1.0.2 py27h83f16ab_0", + "functools32 3.2.3.2 py27_1", + "future 0.17.1 py27_0", + "futures 3.2.0 py27_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.3.7 py27h7b6447c_1", + "glib 2.56.2 hd408876_0", + "glob2 0.6 py27_1", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py27h10f8cd9_2", + "graphite2 1.3.12 h23475e2_2", + "greenlet 0.4.15 py27h7b6447c_0", + "grin 1.2.1 py27_4", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.8.0 py27h989c5e5_3", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.2 hba1933b_1", + "heapdict 1.0.0 py27_2", + "html5lib 1.0.1 py27_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py27_0", + "imageio 2.4.1 py27_0", + "imagesize 1.1.0 py27_0", + "importlib_metadata 0.6 py27_0", + "intel-openmp 2019.1 144", + "ipaddress 1.0.22 py27_0", + "ipykernel 4.10.0 py27_0", + "ipython 5.8.0 py27_0", + "ipython_genutils 0.2.0 py27h89fb69b_0", + "ipywidgets 7.4.2 py27_0", + "isort 4.3.4 py27_0", + "itsdangerous 1.1.0 py27_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4 py27_0", + "jedi 0.13.2 py27_0", + "jinja2 2.10 py27_0", + "jpeg 9b h024ee3a_2", + "jsonschema 2.6.0 py27h7ed5aa4_0", + "jupyter 1.0.0 py27_7", + "jupyter_client 5.2.4 py27_0", + "jupyter_console 5.2.0 py27_1", + "jupyter_core 4.4.0 py27_0", + "jupyterlab 0.33.11 py27_0", + "jupyterlab_launcher 0.11.2 py27h28b3542_0", + "kiwisolver 1.0.1 py27hf484d3e_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.3.1 py27h14c3975_2", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.63.0 h20c2e04_1000", + "libedit 3.1.20170329 h6b74fdf_2", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 8.2.0 hdf63c60_1", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_1", + "libpng 1.6.35 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.0 h1ba5d50_4", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "libtiff 4.0.9 he85c1e1_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.8 h26e45fe_1", + "libxslt 1.1.32 h1312cb7_0", + "linecache2 1.0.0 py27_0", + "llvmlite 0.26.0 py27hd408876_0", + "locket 0.2.0 py27h73929a2_1", + "lxml 4.2.5 py27hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.0 py27h7b6447c_0", + "matplotlib 2.2.3 py27hb69df0a_0", + "mccabe 0.6.1 py27_1", + "mistune 0.8.4 py27h7b6447c_0", + "mkl 2019.1 144", + "mkl-service 1.1.2 py27he904b0f_5", + "mkl_fft 1.0.6 py27hd81dba3_0", + "mkl_random 1.0.2 py27hd81dba3_0", + "more-itertools 4.3.0 py27_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py27_0", + "msgpack-python 0.5.6 py27h6bb024c_1", + "multipledispatch 0.6.0 py27_0", + "nbconvert 5.4.0 py27_1", + "nbformat 4.4.0 py27hed7f2b2_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.2 py27_1", + "nltk 3.4 py27_1", + "nose 1.3.7 py27_2", + "notebook 5.7.4 py27_0", + "numba 0.41.0 py27h962f231_0", + "numexpr 2.6.8 py27h9e4a6bb_0", + "numpy 1.15.4 py27h7e9f1db_0", + "numpy-base 1.15.4 py27hde5b4d6_0", + "numpydoc 0.8.0 py27_0", + "odo 0.5.1 py27h9170de3_0", + "olefile 0.46 py27_0", + "openpyxl 2.5.12 py27_0", + "openssl 1.1.1a h7b6447c_0", + "packaging 18.0 py27_0", + "pandas 0.23.4 py27h04863e7_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py27_1", + "pango 1.42.4 h049681c_0", + "parso 0.3.1 py27_0", + "partd 0.3.9 py27_0", + "patchelf 0.9 he6710b0_3", + "path.py 11.5.0 py27_0", + "pathlib2 2.3.3 py27_0", + "patsy 0.5.1 py27_0", + "pcre 8.42 h439df22_0", + "pep8 1.7.1 py27_0", + "pexpect 4.6.0 py27_0", + "pickleshare 0.7.5 py27_0", + "pillow 5.3.0 py27h34e0f95_0", + "pip 18.1 py27_0", + "pixman 0.34.0 hceecf20_3", + "pkginfo 1.4.2 py27_1", + "pluggy 0.8.0 py27_0", + "ply 3.11 py27_0", + "prometheus_client 0.5.0 py27_0", + "prompt_toolkit 1.0.15 py27h1b593e1_0", + "psutil 5.4.8 py27h7b6447c_0", + "ptyprocess 0.6.0 py27_0", + "py 1.7.0 py27_0", + "py-lief 0.9.0 py27h7725739_1", + "pycairo 1.18.0 py27h2a1e443_0", + "pycodestyle 2.4.0 py27_0", + "pycosat 0.6.3 py27h14c3975_0", + "pycparser 2.19 py27_0", + "pycrypto 2.6.1 py27h14c3975_9", + "pycurl 7.43.0.2 py27h1ba5d50_0", + "pyflakes 2.0.0 py27_0", + "pygments 2.3.1 py27_0", + "pylint 1.9.2 py27_0", + "pyodbc 4.0.25 py27he6710b0_0", + "pyopenssl 18.0.0 py27_0", + "pyparsing 2.3.0 py27_0", + "pyqt 5.9.2 py27h05f1152_2", + "pysocks 1.6.8 py27_0", + "pytables 3.4.4 py27ha205bf6_0", + "pytest 4.0.2 py27_0", + "python 2.7.15 h9bab390_6", + "python-dateutil 2.7.5 py27_0", + "python-libarchive-c 2.8 py27_6", + "pytz 2018.7 py27_0", + "pywavelets 1.0.1 py27hdd07704_0", + "pyyaml 3.13 py27h14c3975_0", + "pyzmq 17.1.2 py27h14c3975_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.5.3 py27_0", + "qtconsole 4.4.3 py27_0", + "qtpy 1.5.2 py27_0", + "readline 7.0 h7b6447c_5", + "requests 2.21.0 py27_0", + "rope 0.11.0 py27_0", + "ruamel_yaml 0.15.46 py27h14c3975_0", + "scandir 1.9.0 py27h14c3975_0", + "scikit-image 0.14.1 py27he6710b0_0", + "scikit-learn 0.20.1 py27hd81dba3_0", + "scipy 1.1.0 py27h7c811a0_2", + "seaborn 0.9.0 py27_0", + "send2trash 1.5.0 py27_0", + "setuptools 40.6.3 py27_0", + "simplegeneric 0.8.1 py27_2", + "singledispatch 3.4.0.3 py27h9bcb476_0", + "sip 4.19.8 py27hf484d3e_0", + "six 1.12.0 py27_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 1.2.1 py27h44e2768_0", + "sortedcollections 1.0.1 py27_0", + "sortedcontainers 2.1.0 py27_0", + "sphinx 1.8.2 py27_0", + "sphinxcontrib 1.0 py27_1", + "sphinxcontrib-websupport 1.1.0 py27_1", + "spyder 3.3.2 py27_0", + "spyder-kernels 0.3.0 py27_0", + "sqlalchemy 1.2.15 py27h7b6447c_0", + "sqlite 3.26.0 h7b6447c_0", + "ssl_match_hostname 3.5.0.1 py27_2", + "statsmodels 0.9.0 py27h035aef0_0", + "subprocess32 3.5.3 py27h7b6447c_0", + "sympy 1.3 py27_0", + "tblib 1.3.2 py27h51fe5ba_0", + "terminado 0.8.1 py27_1", + "testpath 0.4.2 py27_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.9.0 py27_0", + "tornado 5.1.1 py27h7b6447c_0", + "tqdm 4.28.1 py27h28b3542_0", + "traceback2 1.4.0 py27_0", + "traitlets 4.3.2 py27hd6ce930_0", + "typing 3.6.6 py27_0", + "unicodecsv 0.14.1 py27h5062da9_0", + "unittest2 1.1.0 py27_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.1 py27_0", + "wcwidth 0.1.7 py27h9e3e1ab_0", + "webencodings 0.5.1 py27_1", + "werkzeug 0.14.1 py27_0", + "wheel 0.32.3 py27_0", + "widgetsnbextension 3.4.2 py27_0", + "wrapt 1.10.11 py27h14c3975_2", + "wurlitzer 1.0.2 py27_0", + "xlrd 1.2.0 py27_0", + "xlsxwriter 1.1.2 py27_0", + "xlwt 1.3.0 py27h3d85d97_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.2.5 hf484d3e_1", + "zict 0.1.3 py27_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "ca258951a6b465cd8c3a33654af3b76e", + "name": "anaconda", + "namespace": "python", + "sha256": "406c31e4b6112c6d3caf17509544f2cf2d9c709d1733d4389988d105317b2936", + "size": 11629, + "subdir": "linux-64", + "timestamp": 1545284932245, + "version": "2018.12" + }, + "anaconda-2018.12-py36h44efdcc_0.tar.bz2": { + "build": "py36h44efdcc_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "ca-certificates 2018.03.07 0", + "conda-env 2.6.0 1", + "intel-openmp 2019.1 144", + "libgcc-ng 8.2.0 hdf63c60_1", + "libgfortran-ng 7.3.0 hdf63c60_0", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "bzip2 1.0.6 h14c3975_5", + "expat 2.2.6 he6710b0_0", + "fribidi 1.0.5 h7b6447c_0", + "gmp 6.1.2 h6c8ec71_1", + "graphite2 1.3.12 h23475e2_2", + "icu 58.2 h9c2bf20_1", + "jbig 2.1 hdba287a_0", + "jpeg 9b h024ee3a_2", + "libffi 3.2.1 hd88cf55_4", + "liblief 0.9.0 h7725739_1", + "libsodium 1.0.16 h1bed415_0", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "mkl 2019.1 144", + "ncurses 6.1 he6710b0_1", + "openssl 1.1.1a h7b6447c_0", + "patchelf 0.9 he6710b0_3", + "pcre 8.42 h439df22_0", + "pixman 0.34.0 hceecf20_3", + "snappy 1.1.7 hbae5bb6_3", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zlib 1.2.11 h7b6447c_3", + "blosc 1.14.4 hdbcaa40_0", + "glib 2.56.2 hd408876_0", + "hdf5 1.10.2 hba1933b_1", + "libedit 3.1.20170329 h6b74fdf_2", + "libpng 1.6.35 hbc83047_0", + "libssh2 1.8.0 h1ba5d50_4", + "libtiff 4.0.9 he85c1e1_2", + "libxml2 2.9.8 h26e45fe_1", + "mpfr 4.0.1 hdf1c602_3", + "pandoc 1.19.2.1 hea2e7c5_1", + "readline 7.0 h7b6447c_5", + "tk 8.6.8 hbc83047_0", + "zeromq 4.2.5 hf484d3e_1", + "zstd 1.3.7 h0b5b093_0", + "dbus 1.13.2 h714fa37_1", + "freetype 2.9.1 h8a8886c_1", + "gstreamer 1.14.0 hb453b48_1", + "krb5 1.16.1 h173b8e3_7", + "libarchive 3.3.3 h5d8350f_5", + "libxslt 1.1.32 h1312cb7_0", + "mpc 1.1.0 h10f8cd9_1", + "sqlite 3.26.0 h7b6447c_0", + "unixodbc 2.3.7 h14c3975_0", + "fontconfig 2.13.0 h9420a91_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "libcurl 7.63.0 h20c2e04_1000", + "python 3.6.7 h0371630_0", + "alabaster 0.7.12 py36_0", + "asn1crypto 0.24.0 py36_0", + "atomicwrites 1.2.1 py36_0", + "attrs 18.2.0 py36h28b3542_0", + "backcall 0.1.0 py36_0", + "backports 1.0 py36_1", + "beautifulsoup4 4.6.3 py36_0", + "bitarray 0.8.3 py36h14c3975_0", + "boto 2.49.0 py36_0", + "cairo 1.14.12 h8948797_3", + "certifi 2018.11.29 py36_0", + "chardet 3.0.4 py36_1", + "click 7.0 py36_0", + "cloudpickle 0.6.1 py36_0", + "colorama 0.4.1 py36_0", + "contextlib2 0.5.5 py36h6c84a62_0", + "curl 7.63.0 hbc83047_1000", + "dask-core 1.0.0 py36_0", + "decorator 4.3.0 py36_0", + "defusedxml 0.5.0 py36_1", + "docutils 0.14 py36hb0f60f5_0", + "entrypoints 0.2.3 py36_2", + "et_xmlfile 1.0.1 py36hd6bccc3_0", + "fastcache 1.0.2 py36h14c3975_2", + "filelock 3.0.10 py36_0", + "glob2 0.6 py36_1", + "gmpy2 2.0.8 py36h10f8cd9_2", + "greenlet 0.4.15 py36h7b6447c_0", + "heapdict 1.0.0 py36_2", + "idna 2.8 py36_0", + "imagesize 1.1.0 py36_0", + "importlib_metadata 0.6 py36_0", + "ipython_genutils 0.2.0 py36hb52b0d5_0", + "itsdangerous 1.1.0 py36_0", + "jdcal 1.4 py36_0", + "jeepney 0.4 py36_0", + "kiwisolver 1.0.1 py36hf484d3e_0", + "lazy-object-proxy 1.3.1 py36h14c3975_2", + "llvmlite 0.26.0 py36hd408876_0", + "locket 0.2.0 py36h787c0ad_1", + "lxml 4.2.5 py36hefd8a0e_0", + "markupsafe 1.1.0 py36h7b6447c_0", + "mccabe 0.6.1 py36_1", + "mistune 0.8.4 py36h7b6447c_0", + "mkl-service 1.1.2 py36he904b0f_5", + "mpmath 1.1.0 py36_0", + "msgpack-python 0.5.6 py36h6bb024c_1", + "numpy-base 1.15.4 py36hde5b4d6_0", + "olefile 0.46 py36_0", + "pandocfilters 1.4.2 py36_1", + "parso 0.3.1 py36_0", + "pep8 1.7.1 py36_0", + "pickleshare 0.7.5 py36_0", + "pkginfo 1.4.2 py36_1", + "pluggy 0.8.0 py36_0", + "ply 3.11 py36_0", + "prometheus_client 0.5.0 py36_0", + "psutil 5.4.8 py36h7b6447c_0", + "ptyprocess 0.6.0 py36_0", + "py 1.7.0 py36_0", + "py-lief 0.9.0 py36h7725739_1", + "pycodestyle 2.4.0 py36_0", + "pycosat 0.6.3 py36h14c3975_0", + "pycparser 2.19 py36_0", + "pycrypto 2.6.1 py36h14c3975_9", + "pycurl 7.43.0.2 py36h1ba5d50_0", + "pyflakes 2.0.0 py36_0", + "pyodbc 4.0.25 py36he6710b0_0", + "pyparsing 2.3.0 py36_0", + "pysocks 1.6.8 py36_0", + "python-libarchive-c 2.8 py36_6", + "pytz 2018.7 py36_0", + "pyyaml 3.13 py36h14c3975_0", + "pyzmq 17.1.2 py36h14c3975_0", + "qt 5.9.7 h5867ecd_1", + "qtpy 1.5.2 py36_0", + "rope 0.11.0 py36_0", + "ruamel_yaml 0.15.46 py36h14c3975_0", + "send2trash 1.5.0 py36_0", + "simplegeneric 0.8.1 py36_2", + "sip 4.19.8 py36hf484d3e_0", + "six 1.12.0 py36_0", + "snowballstemmer 1.2.1 py36h6febd40_0", + "sortedcontainers 2.1.0 py36_0", + "sphinxcontrib 1.0 py36_1", + "sqlalchemy 1.2.15 py36h7b6447c_0", + "tblib 1.3.2 py36h34cf8b6_0", + "testpath 0.4.2 py36_0", + "toolz 0.9.0 py36_0", + "tornado 5.1.1 py36h7b6447c_0", + "tqdm 4.28.1 py36h28b3542_0", + "typed-ast 1.1.0 py36h14c3975_0", + "unicodecsv 0.14.1 py36ha668878_0", + "wcwidth 0.1.7 py36hdf4376a_0", + "webencodings 0.5.1 py36_1", + "werkzeug 0.14.1 py36_0", + "wrapt 1.10.11 py36h14c3975_2", + "wurlitzer 1.0.2 py36_0", + "xlrd 1.2.0 py36_0", + "xlsxwriter 1.1.2 py36_0", + "xlwt 1.3.0 py36h7b00a1f_0", + "astroid 2.1.0 py36_0", + "babel 2.6.0 py36_0", + "backports.os 0.1.1 py36_0", + "backports.shutil_get_terminal_size 1.0.0 py36_2", + "cffi 1.11.5 py36he75722e_1", + "cycler 0.10.0 py36h93f1223_0", + "cytoolz 0.9.0.1 py36h14c3975_1", + "harfbuzz 1.8.8 hffaf4a1_0", + "html5lib 1.0.1 py36_0", + "jedi 0.13.2 py36_0", + "mkl_fft 1.0.6 py36hd81dba3_0", + "mkl_random 1.0.2 py36hd81dba3_0", + "more-itertools 4.3.0 py36_0", + "multipledispatch 0.6.0 py36_0", + "nltk 3.4 py36_1", + "openpyxl 2.5.12 py36_0", + "packaging 18.0 py36_0", + "partd 0.3.9 py36_0", + "pathlib2 2.3.3 py36_0", + "pexpect 4.6.0 py36_0", + "pillow 5.3.0 py36h34e0f95_0", + "pyqt 5.9.2 py36h05f1152_2", + "python-dateutil 2.7.5 py36_0", + "qtawesome 0.5.3 py36_0", + "setuptools 40.6.3 py36_0", + "singledispatch 3.4.0.3 py36h7a266c3_0", + "sortedcollections 1.0.1 py36_0", + "sphinxcontrib-websupport 1.1.0 py36_1", + "sympy 1.3 py36_0", + "terminado 0.8.1 py36_1", + "traitlets 4.3.2 py36h674d592_0", + "zict 0.1.3 py36_0", + "bleach 3.0.2 py36_0", + "clyent 1.2.2 py36_1", + "cryptography 2.4.2 py36h1ba5d50_0", + "cython 0.29.2 py36he6710b0_0", + "distributed 1.25.1 py36_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.3.7 py36h7b6447c_1", + "isort 4.3.4 py36_0", + "jinja2 2.10 py36_0", + "jsonschema 2.6.0 py36h006f8b5_0", + "jupyter_core 4.4.0 py36_0", + "networkx 2.2 py36_1", + "nose 1.3.7 py36_2", + "numpy 1.15.4 py36h7e9f1db_0", + "pango 1.42.4 h049681c_0", + "path.py 11.5.0 py36_0", + "pygments 2.3.1 py36_0", + "pytest 4.0.2 py36_0", + "wheel 0.32.3 py36_0", + "bokeh 1.0.2 py36_0", + "bottleneck 1.2.1 py36h035aef0_1", + "datashape 0.5.4 py36_1", + "flask 1.0.2 py36_1", + "h5py 2.8.0 py36h989c5e5_3", + "imageio 2.4.1 py36_0", + "jupyter_client 5.2.4 py36_0", + "matplotlib 3.0.2 py36h5429711_0", + "nbformat 4.4.0 py36h31c9010_0", + "numba 0.41.0 py36h962f231_0", + "numexpr 2.6.8 py36h9e4a6bb_0", + "pandas 0.23.4 py36h04863e7_0", + "pip 18.1 py36_0", + "prompt_toolkit 2.0.7 py36_0", + "pylint 2.2.2 py36_0", + "pyopenssl 18.0.0 py36_0", + "pytest-arraydiff 0.3 py36h39e3cac_0", + "pytest-doctestplus 0.2.0 py36_0", + "pytest-openfiles 0.3.1 py36_0", + "pytest-remotedata 0.3.1 py36_0", + "pywavelets 1.0.1 py36hdd07704_0", + "scipy 1.1.0 py36h7c811a0_2", + "secretstorage 3.1.0 py36_0", + "bkcharts 0.2 py36h735825a_0", + "dask 1.0.0 py36_0", + "flask-cors 3.0.7 py36_0", + "ipython 7.2.0 py36h39e3cac_0", + "keyring 17.0.0 py36_0", + "nbconvert 5.4.0 py36_1", + "patsy 0.5.1 py36_0", + "pytables 3.4.4 py36ha205bf6_0", + "pytest-astropy 0.5.0 py36_0", + "scikit-image 0.14.1 py36he6710b0_0", + "scikit-learn 0.20.1 py36hd81dba3_0", + "urllib3 1.24.1 py36_0", + "astropy 3.1 py36h7b6447c_0", + "ipykernel 5.1.0 py36h39e3cac_0", + "odo 0.5.1 py36h90ed295_0", + "requests 2.21.0 py36_0", + "statsmodels 0.9.0 py36h035aef0_0", + "anaconda-client 1.7.2 py36_0", + "blaze 0.11.3 py36_0", + "jupyter_console 6.0.0 py36_0", + "notebook 5.7.4 py36_0", + "qtconsole 4.4.3 py36_0", + "seaborn 0.9.0 py36_0", + "sphinx 1.8.2 py36_0", + "spyder-kernels 0.3.0 py36_0", + "anaconda-project 0.8.2 py36_0", + "jupyterlab_server 0.2.0 py36_0", + "numpydoc 0.8.0 py36_0", + "widgetsnbextension 3.4.2 py36_0", + "ipywidgets 7.4.2 py36_0", + "jupyterlab 0.35.3 py36_0", + "spyder 3.3.2 py36_0", + "jupyter 1.0.0 py36_7", + "conda 4.5.12 py36_0", + "conda-build 3.17.6 py36_0" + ], + "license": "BSD", + "md5": "b2fb9f8d9f5ad92b033db440b68906f0", + "name": "anaconda", + "namespace": "python", + "sha256": "c1d1357da05409d374a80560851ec031ec56b9ebe3a3de1b6ed5b84200f9444b", + "size": 52367, + "subdir": "linux-64", + "timestamp": 1545401296310, + "version": "2018.12" + }, + "anaconda-2018.12-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.12 py37_0", + "anaconda-client 1.7.2 py37_0", + "anaconda-project 0.8.2 py37_0", + "asn1crypto 0.24.0 py37_0", + "astroid 2.1.0 py37_0", + "astropy 3.1 py37h7b6447c_0", + "atomicwrites 1.2.1 py37_0", + "attrs 18.2.0 py37h28b3542_0", + "babel 2.6.0 py37_0", + "backcall 0.1.0 py37_0", + "backports 1.0 py37_1", + "backports.os 0.1.1 py37_0", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "beautifulsoup4 4.6.3 py37_0", + "bitarray 0.8.3 py37h14c3975_0", + "bkcharts 0.2 py37_0", + "blas 1.0 mkl", + "blaze 0.11.3 py37_0", + "bleach 3.0.2 py37_0", + "blosc 1.14.4 hdbcaa40_0", + "bokeh 1.0.2 py37_0", + "boto 2.49.0 py37_0", + "bottleneck 1.2.1 py37h035aef0_1", + "bzip2 1.0.6 h14c3975_5", + "ca-certificates 2018.03.07 0", + "cairo 1.14.12 h8948797_3", + "certifi 2018.11.29 py37_0", + "cffi 1.11.5 py37he75722e_1", + "chardet 3.0.4 py37_1", + "click 7.0 py37_0", + "cloudpickle 0.6.1 py37_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.1 py37_0", + "contextlib2 0.5.5 py37_0", + "cryptography 2.4.2 py37h1ba5d50_0", + "curl 7.63.0 hbc83047_1000", + "cycler 0.10.0 py37_0", + "cython 0.29.2 py37he6710b0_0", + "cytoolz 0.9.0.1 py37h14c3975_1", + "dask 1.0.0 py37_0", + "dask-core 1.0.0 py37_0", + "datashape 0.5.4 py37_1", + "dbus 1.13.2 h714fa37_1", + "decorator 4.3.0 py37_0", + "defusedxml 0.5.0 py37_1", + "distributed 1.25.1 py37_0", + "docutils 0.14 py37_0", + "entrypoints 0.2.3 py37_2", + "et_xmlfile 1.0.1 py37_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.0.2 py37h14c3975_2", + "filelock 3.0.10 py37_0", + "flask 1.0.2 py37_1", + "flask-cors 3.0.7 py37_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.3.7 py37h7b6447c_1", + "glib 2.56.2 hd408876_0", + "glob2 0.6 py37_1", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.12 h23475e2_2", + "greenlet 0.4.15 py37h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.8.0 py37h989c5e5_3", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.2 hba1933b_1", + "heapdict 1.0.0 py37_2", + "html5lib 1.0.1 py37_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py37_0", + "imageio 2.4.1 py37_0", + "imagesize 1.1.0 py37_0", + "importlib_metadata 0.6 py37_0", + "intel-openmp 2019.1 144", + "ipykernel 5.1.0 py37h39e3cac_0", + "ipython 7.2.0 py37h39e3cac_0", + "ipython_genutils 0.2.0 py37_0", + "ipywidgets 7.4.2 py37_0", + "isort 4.3.4 py37_0", + "itsdangerous 1.1.0 py37_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4 py37_0", + "jedi 0.13.2 py37_0", + "jeepney 0.4 py37_0", + "jinja2 2.10 py37_0", + "jpeg 9b h024ee3a_2", + "jsonschema 2.6.0 py37_0", + "jupyter 1.0.0 py37_7", + "jupyter_client 5.2.4 py37_0", + "jupyter_console 6.0.0 py37_0", + "jupyter_core 4.4.0 py37_0", + "jupyterlab 0.35.3 py37_0", + "jupyterlab_server 0.2.0 py37_0", + "keyring 17.0.0 py37_0", + "kiwisolver 1.0.1 py37hf484d3e_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.3.1 py37h14c3975_2", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.63.0 h20c2e04_1000", + "libedit 3.1.20170329 h6b74fdf_2", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 8.2.0 hdf63c60_1", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_1", + "libpng 1.6.35 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.0 h1ba5d50_4", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "libtiff 4.0.9 he85c1e1_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.8 h26e45fe_1", + "libxslt 1.1.32 h1312cb7_0", + "llvmlite 0.26.0 py37hd408876_0", + "locket 0.2.0 py37_1", + "lxml 4.2.5 py37hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.0 py37h7b6447c_0", + "matplotlib 3.0.2 py37h5429711_0", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h7b6447c_0", + "mkl 2019.1 144", + "mkl-service 1.1.2 py37he904b0f_5", + "mkl_fft 1.0.6 py37hd81dba3_0", + "mkl_random 1.0.2 py37hd81dba3_0", + "more-itertools 4.3.0 py37_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py37_0", + "msgpack-python 0.5.6 py37h6bb024c_1", + "multipledispatch 0.6.0 py37_0", + "nbconvert 5.4.0 py37_1", + "nbformat 4.4.0 py37_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.2 py37_1", + "nltk 3.4 py37_1", + "nose 1.3.7 py37_2", + "notebook 5.7.4 py37_0", + "numba 0.41.0 py37h962f231_0", + "numexpr 2.6.8 py37h9e4a6bb_0", + "numpy 1.15.4 py37h7e9f1db_0", + "numpy-base 1.15.4 py37hde5b4d6_0", + "numpydoc 0.8.0 py37_0", + "odo 0.5.1 py37_0", + "olefile 0.46 py37_0", + "openpyxl 2.5.12 py37_0", + "openssl 1.1.1a h7b6447c_0", + "packaging 18.0 py37_0", + "pandas 0.23.4 py37h04863e7_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py37_1", + "pango 1.42.4 h049681c_0", + "parso 0.3.1 py37_0", + "partd 0.3.9 py37_0", + "patchelf 0.9 he6710b0_3", + "path.py 11.5.0 py37_0", + "pathlib2 2.3.3 py37_0", + "patsy 0.5.1 py37_0", + "pcre 8.42 h439df22_0", + "pep8 1.7.1 py37_0", + "pexpect 4.6.0 py37_0", + "pickleshare 0.7.5 py37_0", + "pillow 5.3.0 py37h34e0f95_0", + "pip 18.1 py37_0", + "pixman 0.34.0 hceecf20_3", + "pkginfo 1.4.2 py37_1", + "pluggy 0.8.0 py37_0", + "ply 3.11 py37_0", + "prometheus_client 0.5.0 py37_0", + "prompt_toolkit 2.0.7 py37_0", + "psutil 5.4.8 py37h7b6447c_0", + "ptyprocess 0.6.0 py37_0", + "py 1.7.0 py37_0", + "py-lief 0.9.0 py37h7725739_1", + "pycodestyle 2.4.0 py37_0", + "pycosat 0.6.3 py37h14c3975_0", + "pycparser 2.19 py37_0", + "pycrypto 2.6.1 py37h14c3975_9", + "pycurl 7.43.0.2 py37h1ba5d50_0", + "pyflakes 2.0.0 py37_0", + "pygments 2.3.1 py37_0", + "pylint 2.2.2 py37_0", + "pyodbc 4.0.25 py37he6710b0_0", + "pyopenssl 18.0.0 py37_0", + "pyparsing 2.3.0 py37_0", + "pyqt 5.9.2 py37h05f1152_2", + "pysocks 1.6.8 py37_0", + "pytables 3.4.4 py37ha205bf6_0", + "pytest 4.0.2 py37_0", + "pytest-arraydiff 0.3 py37h39e3cac_0", + "pytest-astropy 0.5.0 py37_0", + "pytest-doctestplus 0.2.0 py37_0", + "pytest-openfiles 0.3.1 py37_0", + "pytest-remotedata 0.3.1 py37_0", + "python 3.7.1 h0371630_7", + "python-dateutil 2.7.5 py37_0", + "python-libarchive-c 2.8 py37_6", + "pytz 2018.7 py37_0", + "pywavelets 1.0.1 py37hdd07704_0", + "pyyaml 3.13 py37h14c3975_0", + "pyzmq 17.1.2 py37h14c3975_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.5.3 py37_0", + "qtconsole 4.4.3 py37_0", + "qtpy 1.5.2 py37_0", + "readline 7.0 h7b6447c_5", + "requests 2.21.0 py37_0", + "rope 0.11.0 py37_0", + "ruamel_yaml 0.15.46 py37h14c3975_0", + "scikit-image 0.14.1 py37he6710b0_0", + "scikit-learn 0.20.1 py37hd81dba3_0", + "scipy 1.1.0 py37h7c811a0_2", + "seaborn 0.9.0 py37_0", + "secretstorage 3.1.0 py37_0", + "send2trash 1.5.0 py37_0", + "setuptools 40.6.3 py37_0", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.4.0.3 py37_0", + "sip 4.19.8 py37hf484d3e_0", + "six 1.12.0 py37_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 1.2.1 py37_0", + "sortedcollections 1.0.1 py37_0", + "sortedcontainers 2.1.0 py37_0", + "sphinx 1.8.2 py37_0", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-websupport 1.1.0 py37_1", + "spyder 3.3.2 py37_0", + "spyder-kernels 0.3.0 py37_0", + "sqlalchemy 1.2.15 py37h7b6447c_0", + "sqlite 3.26.0 h7b6447c_0", + "statsmodels 0.9.0 py37h035aef0_0", + "sympy 1.3 py37_0", + "tblib 1.3.2 py37_0", + "terminado 0.8.1 py37_1", + "testpath 0.4.2 py37_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.9.0 py37_0", + "tornado 5.1.1 py37h7b6447c_0", + "tqdm 4.28.1 py37h28b3542_0", + "traitlets 4.3.2 py37_0", + "unicodecsv 0.14.1 py37_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.1 py37_0", + "wcwidth 0.1.7 py37_0", + "webencodings 0.5.1 py37_1", + "werkzeug 0.14.1 py37_0", + "wheel 0.32.3 py37_0", + "widgetsnbextension 3.4.2 py37_0", + "wrapt 1.10.11 py37h14c3975_2", + "wurlitzer 1.0.2 py37_0", + "xlrd 1.2.0 py37_0", + "xlsxwriter 1.1.2 py37_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.2.5 hf484d3e_1", + "zict 0.1.3 py37_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "6e227989aa0e9ba22ee30be212cba0b1", + "name": "anaconda", + "namespace": "python", + "sha256": "2117dc9c7aec51d92d509d45dbb6d0138d523fe36c73442bba75a3f8ab079fe0", + "size": 11046, + "subdir": "linux-64", + "timestamp": 1545285186418, + "version": "2018.12" + }, + "anaconda-2019.03-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.12 py27_0", + "anaconda-client 1.7.2 py27_0", + "anaconda-project 0.8.2 py27_0", + "asn1crypto 0.24.0 py27_0", + "astroid 1.6.5 py27_0", + "astropy 2.0.9 py27hdd07704_0", + "atomicwrites 1.3.0 py27_1", + "attrs 19.1.0 py27_1", + "babel 2.6.0 py27_0", + "backports 1.0 py27_1", + "backports.functools_lru_cache 1.5 py27_1", + "backports.os 0.1.1 py27_0", + "backports.shutil_get_terminal_size 1.0.0 py27_2", + "backports_abc 0.5 py27h7b3c97b_0", + "beautifulsoup4 4.7.1 py27_1", + "bitarray 0.8.3 py27h14c3975_0", + "bkcharts 0.2 py27h241ae91_0", + "blas 1.0 mkl", + "bleach 3.1.0 py27_0", + "blosc 1.15.0 hd408876_0", + "bokeh 1.0.4 py27_0", + "boto 2.49.0 py27_0", + "bottleneck 1.2.1 py27h035aef0_1", + "bzip2 1.0.6 h14c3975_5", + "ca-certificates 2019.1.23 0", + "cairo 1.14.12 h8948797_3", + "cdecimal 2.3 py27h14c3975_3", + "certifi 2019.3.9 py27_0", + "cffi 1.12.2 py27h2e261b9_1", + "chardet 3.0.4 py27_1", + "click 7.0 py27_0", + "cloudpickle 0.8.0 py27_0", + "clyent 1.2.2 py27_1", + "colorama 0.4.1 py27_0", + "configparser 3.7.3 py27_1", + "contextlib2 0.5.5 py27hbf4c468_0", + "cryptography 2.6.1 py27h1ba5d50_0", + "curl 7.64.0 hbc83047_2", + "cycler 0.10.0 py27hc7354d3_0", + "cython 0.29.6 py27he6710b0_0", + "cytoolz 0.9.0.1 py27h14c3975_1", + "dask 1.1.4 py27_1", + "dask-core 1.1.4 py27_1", + "dbus 1.13.6 h746ee38_0", + "decorator 4.4.0 py27_1", + "defusedxml 0.5.0 py27_1", + "distributed 1.26.0 py27_1", + "docutils 0.14 py27hae222c1_0", + "entrypoints 0.3 py27_0", + "enum34 1.1.6 py27_1", + "et_xmlfile 1.0.1 py27h75840f5_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.0.2 py27h14c3975_2", + "filelock 3.0.10 py27_0", + "flask 1.0.2 py27_1", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "funcsigs 1.0.2 py27h83f16ab_0", + "functools32 3.2.3.2 py27_1", + "future 0.17.1 py27_0", + "futures 3.2.0 py27_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py27h7b6447c_0", + "glib 2.56.2 hd408876_0", + "glob2 0.6 py27_1", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py27h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py27h7b6447c_0", + "grin 1.2.1 py27_4", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.9.0 py27h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.0 py27_2", + "html5lib 1.0.1 py27_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py27_0", + "imageio 2.5.0 py27_0", + "imagesize 1.1.0 py27_0", + "importlib_metadata 0.8 py27_0", + "intel-openmp 2019.3 199", + "ipaddress 1.0.22 py27_0", + "ipykernel 4.10.0 py27_0", + "ipython 5.8.0 py27_0", + "ipython_genutils 0.2.0 py27h89fb69b_0", + "ipywidgets 7.4.2 py27_0", + "isort 4.3.16 py27_0", + "itsdangerous 1.1.0 py27_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4 py27_0", + "jedi 0.13.3 py27_0", + "jinja2 2.10 py27_0", + "jpeg 9b h024ee3a_2", + "jsonschema 3.0.1 py27_0", + "jupyter 1.0.0 py27_7", + "jupyter_client 5.2.4 py27_0", + "jupyter_console 5.2.0 py27_1", + "jupyter_core 4.4.0 py27_0", + "jupyterlab 0.33.11 py27_0", + "jupyterlab_launcher 0.11.2 py27h28b3542_0", + "kiwisolver 1.0.1 py27hf484d3e_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.3.1 py27h14c3975_2", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.64.0 h20c2e04_2", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 8.2.0 hdf63c60_1", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.36 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.0 h1ba5d50_4", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "libtiff 4.0.10 h2733197_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 he19cac6_0", + "libxslt 1.1.33 h7d1a2b0_0", + "linecache2 1.0.0 py27_0", + "llvmlite 0.28.0 py27hd408876_0", + "locket 0.2.0 py27h73929a2_1", + "lxml 4.3.2 py27hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py27h7b6447c_0", + "matplotlib 2.2.3 py27hb69df0a_0", + "mccabe 0.6.1 py27_1", + "mistune 0.8.4 py27h7b6447c_0", + "mkl 2019.3 199", + "mkl-service 1.1.2 py27he904b0f_5", + "mkl_fft 1.0.10 py27ha843d7b_0", + "mkl_random 1.0.2 py27hd81dba3_0", + "more-itertools 5.0.0 py27_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py27_0", + "msgpack-python 0.6.1 py27hfd86e86_1", + "multipledispatch 0.6.0 py27_0", + "nbconvert 5.4.1 py27_3", + "nbformat 4.4.0 py27hed7f2b2_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.2 py27_1", + "nltk 3.4 py27_1", + "nose 1.3.7 py27_2", + "notebook 5.7.8 py27_0", + "numba 0.43.1 py27h962f231_0", + "numexpr 2.6.9 py27h9e4a6bb_0", + "numpy 1.16.2 py27h7e9f1db_0", + "numpy-base 1.16.2 py27hde5b4d6_0", + "numpydoc 0.8.0 py27_0", + "olefile 0.46 py27_0", + "openpyxl 2.6.1 py27_1", + "openssl 1.1.1b h7b6447c_1", + "packaging 19.0 py27_0", + "pandas 0.24.2 py27he6710b0_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py27_1", + "pango 1.42.4 h049681c_0", + "parso 0.3.4 py27_0", + "partd 0.3.10 py27_1", + "patchelf 0.9 he6710b0_3", + "path.py 11.5.0 py27_0", + "pathlib2 2.3.3 py27_0", + "patsy 0.5.1 py27_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py27_0", + "pexpect 4.6.0 py27_0", + "pickleshare 0.7.5 py27_0", + "pillow 5.4.1 py27h34e0f95_0", + "pip 19.0.3 py27_0", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py27_0", + "pluggy 0.9.0 py27_0", + "ply 3.11 py27_0", + "prometheus_client 0.6.0 py27_0", + "prompt_toolkit 1.0.15 py27h1b593e1_0", + "psutil 5.6.1 py27h7b6447c_0", + "ptyprocess 0.6.0 py27_0", + "py 1.8.0 py27_0", + "py-lief 0.9.0 py27h7725739_2", + "pycairo 1.18.0 py27h2a1e443_0", + "pycodestyle 2.5.0 py27_0", + "pycosat 0.6.3 py27h14c3975_0", + "pycparser 2.19 py27_0", + "pycrypto 2.6.1 py27h14c3975_9", + "pycurl 7.43.0.2 py27h1ba5d50_0", + "pyflakes 2.1.1 py27_0", + "pygments 2.3.1 py27_0", + "pylint 1.9.2 py27_0", + "pyodbc 4.0.26 py27he6710b0_0", + "pyopenssl 19.0.0 py27_0", + "pyparsing 2.3.1 py27_0", + "pyqt 5.9.2 py27h05f1152_2", + "pyrsistent 0.14.11 py27h7b6447c_0", + "pysocks 1.6.8 py27_0", + "pytables 3.5.1 py27h71ec239_0", + "pytest 4.3.1 py27_0", + "python 2.7.16 h9bab390_0", + "python-dateutil 2.8.0 py27_0", + "python-libarchive-c 2.8 py27_6", + "pytz 2018.9 py27_0", + "pywavelets 1.0.2 py27hdd07704_0", + "pyyaml 5.1 py27h7b6447c_0", + "pyzmq 18.0.0 py27he6710b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.5.7 py27_1", + "qtconsole 4.4.3 py27_0", + "qtpy 1.7.0 py27_1", + "readline 7.0 h7b6447c_5", + "requests 2.21.0 py27_0", + "rope 0.12.0 py27_0", + "ruamel_yaml 0.15.46 py27h14c3975_0", + "scandir 1.10.0 py27h7b6447c_0", + "scikit-image 0.14.2 py27he6710b0_0", + "scikit-learn 0.20.3 py27hd81dba3_0", + "scipy 1.2.1 py27h7c811a0_0", + "seaborn 0.9.0 py27_0", + "send2trash 1.5.0 py27_0", + "setuptools 40.8.0 py27_0", + "simplegeneric 0.8.1 py27_2", + "singledispatch 3.4.0.3 py27h9bcb476_0", + "sip 4.19.8 py27hf484d3e_0", + "six 1.12.0 py27_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 1.2.1 py27h44e2768_0", + "sortedcollections 1.1.2 py27_0", + "sortedcontainers 2.1.0 py27_0", + "soupsieve 1.8 py27_0", + "sphinx 1.8.5 py27_0", + "sphinxcontrib 1.0 py27_1", + "sphinxcontrib-websupport 1.1.0 py27_1", + "spyder 3.3.3 py27_0", + "spyder-kernels 0.4.2 py27_0", + "sqlalchemy 1.3.1 py27h7b6447c_0", + "sqlite 3.27.2 h7b6447c_0", + "ssl_match_hostname 3.7.0.1 py27_0", + "statsmodels 0.9.0 py27h035aef0_0", + "subprocess32 3.5.3 py27h7b6447c_0", + "sympy 1.3 py27_0", + "tblib 1.3.2 py27h51fe5ba_0", + "terminado 0.8.1 py27_1", + "testpath 0.4.2 py27_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.9.0 py27_0", + "tornado 5.1.1 py27h7b6447c_0", + "tqdm 4.31.1 py27_1", + "traceback2 1.4.0 py27_0", + "traitlets 4.3.2 py27hd6ce930_0", + "typing 3.6.6 py27_0", + "unicodecsv 0.14.1 py27h5062da9_0", + "unittest2 1.1.0 py27_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.1 py27_0", + "wcwidth 0.1.7 py27h9e3e1ab_0", + "webencodings 0.5.1 py27_1", + "werkzeug 0.14.1 py27_0", + "wheel 0.33.1 py27_0", + "widgetsnbextension 3.4.2 py27_0", + "wrapt 1.11.1 py27h7b6447c_0", + "wurlitzer 1.0.2 py27_0", + "xlrd 1.2.0 py27_0", + "xlsxwriter 1.1.5 py27_0", + "xlwt 1.3.0 py27h3d85d97_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.3.1 he6710b0_3", + "zict 0.1.4 py27_0", + "zipp 0.3.3 py27_1", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "dfd9c0ea1c8ff5d148b6597076c8dd77", + "name": "anaconda", + "namespace": "python", + "sha256": "7f8bf619797ca81b2e6dcc379e5846ec2d8794b828ac716158f277238ba56c97", + "size": 11482, + "subdir": "linux-64", + "timestamp": 1554398667125, + "version": "2019.03" + }, + "anaconda-2019.03-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "ca-certificates 2019.1.23 0", + "intel-openmp 2019.3 199", + "libgcc-ng 8.2.0 hdf63c60_1", + "libgfortran-ng 7.3.0 hdf63c60_0", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "bzip2 1.0.6 h14c3975_5", + "expat 2.2.6 he6710b0_0", + "fribidi 1.0.5 h7b6447c_0", + "gmp 6.1.2 h6c8ec71_1", + "graphite2 1.3.13 h23475e2_0", + "icu 58.2 h9c2bf20_1", + "jbig 2.1 hdba287a_0", + "jpeg 9b h024ee3a_2", + "libffi 3.2.1 hd88cf55_4", + "libsodium 1.0.16 h1bed415_0", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "lzo 2.10 h49e0be7_2", + "mkl 2019.3 199", + "ncurses 6.1 he6710b0_1", + "openssl 1.1.1b h7b6447c_1", + "pcre 8.43 he6710b0_0", + "pixman 0.38.0 h7b6447c_0", + "snappy 1.1.7 hbae5bb6_3", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zlib 1.2.11 h7b6447c_3", + "blosc 1.15.0 hd408876_0", + "glib 2.56.2 hd408876_0", + "hdf5 1.10.4 hb1b8bf9_0", + "libedit 3.1.20181209 hc058e9b_0", + "libpng 1.6.36 hbc83047_0", + "libssh2 1.8.0 h1ba5d50_4", + "libxml2 2.9.9 he19cac6_0", + "mpfr 4.0.1 hdf1c602_3", + "pandoc 2.2.3.2 0", + "readline 7.0 h7b6447c_5", + "tk 8.6.8 hbc83047_0", + "zeromq 4.3.1 he6710b0_3", + "zstd 1.3.7 h0b5b093_0", + "dbus 1.13.6 h746ee38_0", + "freetype 2.9.1 h8a8886c_1", + "gstreamer 1.14.0 hb453b48_1", + "krb5 1.16.1 h173b8e3_7", + "libtiff 4.0.10 h2733197_2", + "libxslt 1.1.33 h7d1a2b0_0", + "mpc 1.1.0 h10f8cd9_1", + "sqlite 3.27.2 h7b6447c_0", + "unixodbc 2.3.7 h14c3975_0", + "fontconfig 2.13.0 h9420a91_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "libcurl 7.64.0 h20c2e04_2", + "python 3.6.8 h0371630_0", + "alabaster 0.7.12 py36_0", + "asn1crypto 0.24.0 py36_0", + "atomicwrites 1.3.0 py36_1", + "attrs 19.1.0 py36_1", + "backcall 0.1.0 py36_0", + "backports 1.0 py36_1", + "bitarray 0.8.3 py36h14c3975_0", + "boto 2.49.0 py36_0", + "cairo 1.14.12 h8948797_3", + "certifi 2019.3.9 py36_0", + "chardet 3.0.4 py36_1", + "click 7.0 py36_0", + "cloudpickle 0.8.0 py36_0", + "colorama 0.4.1 py36_0", + "contextlib2 0.5.5 py36h6c84a62_0", + "curl 7.64.0 hbc83047_2", + "dask-core 1.1.4 py36_1", + "decorator 4.4.0 py36_1", + "defusedxml 0.5.0 py36_1", + "docutils 0.14 py36hb0f60f5_0", + "entrypoints 0.3 py36_0", + "et_xmlfile 1.0.1 py36hd6bccc3_0", + "fastcache 1.0.2 py36h14c3975_2", + "gmpy2 2.0.8 py36h10f8cd9_2", + "greenlet 0.4.15 py36h7b6447c_0", + "heapdict 1.0.0 py36_2", + "idna 2.8 py36_0", + "imagesize 1.1.0 py36_0", + "ipython_genutils 0.2.0 py36hb52b0d5_0", + "itsdangerous 1.1.0 py36_0", + "jdcal 1.4 py36_0", + "jeepney 0.4 py36_0", + "kiwisolver 1.0.1 py36hf484d3e_0", + "lazy-object-proxy 1.3.1 py36h14c3975_2", + "llvmlite 0.28.0 py36hd408876_0", + "locket 0.2.0 py36h787c0ad_1", + "lxml 4.3.2 py36hefd8a0e_0", + "markupsafe 1.1.1 py36h7b6447c_0", + "mccabe 0.6.1 py36_1", + "mistune 0.8.4 py36h7b6447c_0", + "mkl-service 1.1.2 py36he904b0f_5", + "more-itertools 6.0.0 py36_0", + "mpmath 1.1.0 py36_0", + "msgpack-python 0.6.1 py36hfd86e86_1", + "numpy-base 1.16.2 py36hde5b4d6_0", + "olefile 0.46 py36_0", + "pandocfilters 1.4.2 py36_1", + "parso 0.3.4 py36_0", + "pep8 1.7.1 py36_0", + "pickleshare 0.7.5 py36_0", + "pluggy 0.9.0 py36_0", + "ply 3.11 py36_0", + "prometheus_client 0.6.0 py36_0", + "psutil 5.6.1 py36h7b6447c_0", + "ptyprocess 0.6.0 py36_0", + "py 1.8.0 py36_0", + "pycodestyle 2.5.0 py36_0", + "pycosat 0.6.3 py36h14c3975_0", + "pycparser 2.19 py36_0", + "pycrypto 2.6.1 py36h14c3975_9", + "pycurl 7.43.0.2 py36h1ba5d50_0", + "pyflakes 2.1.1 py36_0", + "pyodbc 4.0.26 py36he6710b0_0", + "pyparsing 2.3.1 py36_0", + "pysocks 1.6.8 py36_0", + "pytz 2018.9 py36_0", + "pyyaml 5.1 py36h7b6447c_0", + "pyzmq 18.0.0 py36he6710b0_0", + "qt 5.9.7 h5867ecd_1", + "qtpy 1.7.0 py36_1", + "rope 0.12.0 py36_0", + "ruamel_yaml 0.15.46 py36h14c3975_0", + "send2trash 1.5.0 py36_0", + "simplegeneric 0.8.1 py36_2", + "sip 4.19.8 py36hf484d3e_0", + "six 1.12.0 py36_0", + "snowballstemmer 1.2.1 py36h6febd40_0", + "sortedcontainers 2.1.0 py36_0", + "soupsieve 1.8 py36_0", + "sphinxcontrib 1.0 py36_1", + "sqlalchemy 1.3.1 py36h7b6447c_0", + "tblib 1.3.2 py36h34cf8b6_0", + "testpath 0.4.2 py36_0", + "toolz 0.9.0 py36_0", + "tornado 6.0.2 py36h7b6447c_0", + "typed-ast 1.3.1 py36h7b6447c_0", + "unicodecsv 0.14.1 py36ha668878_0", + "wcwidth 0.1.7 py36hdf4376a_0", + "webencodings 0.5.1 py36_1", + "werkzeug 0.14.1 py36_0", + "wrapt 1.11.1 py36h7b6447c_0", + "wurlitzer 1.0.2 py36_0", + "xlrd 1.2.0 py36_0", + "xlsxwriter 1.1.5 py36_0", + "xlwt 1.3.0 py36h7b00a1f_0", + "zipp 0.3.3 py36_1", + "babel 2.6.0 py36_0", + "backports.os 0.1.1 py36_0", + "backports.shutil_get_terminal_size 1.0.0 py36_2", + "beautifulsoup4 4.7.1 py36_1", + "cffi 1.12.2 py36h2e261b9_1", + "cycler 0.10.0 py36h93f1223_0", + "cytoolz 0.9.0.1 py36h14c3975_1", + "harfbuzz 1.8.8 hffaf4a1_0", + "html5lib 1.0.1 py36_0", + "importlib_metadata 0.8 py36_0", + "jedi 0.13.3 py36_0", + "mkl_random 1.0.2 py36hd81dba3_0", + "multipledispatch 0.6.0 py36_0", + "nltk 3.4 py36_1", + "openpyxl 2.6.1 py36_1", + "packaging 19.0 py36_0", + "partd 0.3.10 py36_1", + "pathlib2 2.3.3 py36_0", + "pexpect 4.6.0 py36_0", + "pillow 5.4.1 py36h34e0f95_0", + "pyqt 5.9.2 py36h05f1152_2", + "pyrsistent 0.14.11 py36h7b6447c_0", + "python-dateutil 2.8.0 py36_0", + "qtawesome 0.5.7 py36_1", + "setuptools 40.8.0 py36_0", + "singledispatch 3.4.0.3 py36h7a266c3_0", + "sortedcollections 1.1.2 py36_0", + "sphinxcontrib-websupport 1.1.0 py36_1", + "sympy 1.3 py36_0", + "terminado 0.8.1 py36_1", + "traitlets 4.3.2 py36h674d592_0", + "zict 0.1.4 py36_0", + "astroid 2.2.5 py36_0", + "bleach 3.1.0 py36_0", + "clyent 1.2.2 py36_1", + "cryptography 2.6.1 py36h1ba5d50_0", + "cython 0.29.6 py36he6710b0_0", + "distributed 1.26.0 py36_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py36h7b6447c_0", + "isort 4.3.16 py36_0", + "jinja2 2.10 py36_0", + "jsonschema 3.0.1 py36_0", + "jupyter_core 4.4.0 py36_0", + "networkx 2.2 py36_1", + "nose 1.3.7 py36_2", + "pango 1.42.4 h049681c_0", + "path.py 11.5.0 py36_0", + "pygments 2.3.1 py36_0", + "pytest 4.3.1 py36_0", + "wheel 0.33.1 py36_0", + "flask 1.0.2 py36_1", + "jupyter_client 5.2.4 py36_0", + "nbformat 4.4.0 py36h31c9010_0", + "pip 19.0.3 py36_0", + "prompt_toolkit 2.0.9 py36_0", + "pylint 2.3.1 py36_0", + "pyopenssl 19.0.0 py36_0", + "pytest-openfiles 0.3.2 py36_0", + "pytest-remotedata 0.3.1 py36_0", + "secretstorage 3.1.1 py36_0", + "ipython 7.4.0 py36h39e3cac_0", + "keyring 18.0.0 py36_0", + "nbconvert 5.4.1 py36_3", + "urllib3 1.24.1 py36_0", + "ipykernel 5.1.0 py36h39e3cac_0", + "requests 2.21.0 py36_0", + "anaconda-client 1.7.2 py36_0", + "jupyter_console 6.0.0 py36_0", + "notebook 5.7.8 py36_0", + "qtconsole 4.4.3 py36_0", + "sphinx 1.8.5 py36_0", + "spyder-kernels 0.4.2 py36_0", + "anaconda-project 0.8.2 py36_0", + "jupyterlab_server 0.2.0 py36_0", + "numpydoc 0.8.0 py36_0", + "widgetsnbextension 3.4.2 py36_0", + "ipywidgets 7.4.2 py36_0", + "jupyterlab 0.35.4 py36hf63ae98_0", + "spyder 3.3.3 py36_0", + "jupyter 1.0.0 py36_7", + "bokeh 1.0.4 py36_0", + "bottleneck 1.2.1 py36h035aef0_1", + "h5py 2.9.0 py36h7918eee_0", + "imageio 2.5.0 py36_0", + "matplotlib 3.0.3 py36h5429711_0", + "mkl_fft 1.0.10 py36ha843d7b_0", + "numpy 1.16.2 py36h7e9f1db_0", + "numba 0.43.1 py36h962f231_0", + "numexpr 2.6.9 py36h9e4a6bb_0", + "pandas 0.24.2 py36he6710b0_0", + "pytest-arraydiff 0.3 py36h39e3cac_0", + "pytest-doctestplus 0.3.0 py36_0", + "pywavelets 1.0.2 py36hdd07704_0", + "scipy 1.2.1 py36h7c811a0_0", + "bkcharts 0.2 py36h735825a_0", + "dask 1.1.4 py36_1", + "patsy 0.5.1 py36_0", + "pytables 3.5.1 py36h71ec239_0", + "pytest-astropy 0.5.0 py36_0", + "scikit-image 0.14.2 py36he6710b0_0", + "scikit-learn 0.20.3 py36hd81dba3_0", + "astropy 3.1.2 py36h7b6447c_0", + "statsmodels 0.9.0 py36h035aef0_0", + "seaborn 0.9.0 py36_0" + ], + "license": "BSD", + "md5": "fcaf623e8803edc0277d35357e0f1c6a", + "name": "anaconda", + "namespace": "python", + "sha256": "1d4454628c40a7991357b32544d2e58f77e4e69ce5b0c2f41a04d3f44ec73c5f", + "size": 54000, + "subdir": "linux-64", + "timestamp": 1554420441441, + "version": "2019.03" + }, + "anaconda-2019.03-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.12 py37_0", + "anaconda-client 1.7.2 py37_0", + "anaconda-project 0.8.2 py37_0", + "asn1crypto 0.24.0 py37_0", + "astroid 2.2.5 py37_0", + "astropy 3.1.2 py37h7b6447c_0", + "atomicwrites 1.3.0 py37_1", + "attrs 19.1.0 py37_1", + "babel 2.6.0 py37_0", + "backcall 0.1.0 py37_0", + "backports 1.0 py37_1", + "backports.os 0.1.1 py37_0", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "beautifulsoup4 4.7.1 py37_1", + "bitarray 0.8.3 py37h14c3975_0", + "bkcharts 0.2 py37_0", + "blas 1.0 mkl", + "bleach 3.1.0 py37_0", + "blosc 1.15.0 hd408876_0", + "bokeh 1.0.4 py37_0", + "boto 2.49.0 py37_0", + "bottleneck 1.2.1 py37h035aef0_1", + "bzip2 1.0.6 h14c3975_5", + "ca-certificates 2019.1.23 0", + "cairo 1.14.12 h8948797_3", + "certifi 2019.3.9 py37_0", + "cffi 1.12.2 py37h2e261b9_1", + "chardet 3.0.4 py37_1", + "click 7.0 py37_0", + "cloudpickle 0.8.0 py37_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.1 py37_0", + "contextlib2 0.5.5 py37_0", + "cryptography 2.6.1 py37h1ba5d50_0", + "curl 7.64.0 hbc83047_2", + "cycler 0.10.0 py37_0", + "cython 0.29.6 py37he6710b0_0", + "cytoolz 0.9.0.1 py37h14c3975_1", + "dask 1.1.4 py37_1", + "dask-core 1.1.4 py37_1", + "dbus 1.13.6 h746ee38_0", + "decorator 4.4.0 py37_1", + "defusedxml 0.5.0 py37_1", + "distributed 1.26.0 py37_1", + "docutils 0.14 py37_0", + "entrypoints 0.3 py37_0", + "et_xmlfile 1.0.1 py37_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.0.2 py37h14c3975_2", + "filelock 3.0.10 py37_0", + "flask 1.0.2 py37_1", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py37h7b6447c_0", + "glib 2.56.2 hd408876_0", + "glob2 0.6 py37_1", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py37h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.9.0 py37h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.0 py37_2", + "html5lib 1.0.1 py37_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py37_0", + "imageio 2.5.0 py37_0", + "imagesize 1.1.0 py37_0", + "importlib_metadata 0.8 py37_0", + "intel-openmp 2019.3 199", + "ipykernel 5.1.0 py37h39e3cac_0", + "ipython 7.4.0 py37h39e3cac_0", + "ipython_genutils 0.2.0 py37_0", + "ipywidgets 7.4.2 py37_0", + "isort 4.3.16 py37_0", + "itsdangerous 1.1.0 py37_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4 py37_0", + "jedi 0.13.3 py37_0", + "jeepney 0.4 py37_0", + "jinja2 2.10 py37_0", + "jpeg 9b h024ee3a_2", + "jsonschema 3.0.1 py37_0", + "jupyter 1.0.0 py37_7", + "jupyter_client 5.2.4 py37_0", + "jupyter_console 6.0.0 py37_0", + "jupyter_core 4.4.0 py37_0", + "jupyterlab 0.35.4 py37hf63ae98_0", + "jupyterlab_server 0.2.0 py37_0", + "keyring 18.0.0 py37_0", + "kiwisolver 1.0.1 py37hf484d3e_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.3.1 py37h14c3975_2", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.64.0 h20c2e04_2", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 8.2.0 hdf63c60_1", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.36 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.0 h1ba5d50_4", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "libtiff 4.0.10 h2733197_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 he19cac6_0", + "libxslt 1.1.33 h7d1a2b0_0", + "llvmlite 0.28.0 py37hd408876_0", + "locket 0.2.0 py37_1", + "lxml 4.3.2 py37hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py37h7b6447c_0", + "matplotlib 3.0.3 py37h5429711_0", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h7b6447c_0", + "mkl 2019.3 199", + "mkl-service 1.1.2 py37he904b0f_5", + "mkl_fft 1.0.10 py37ha843d7b_0", + "mkl_random 1.0.2 py37hd81dba3_0", + "more-itertools 6.0.0 py37_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py37_0", + "msgpack-python 0.6.1 py37hfd86e86_1", + "multipledispatch 0.6.0 py37_0", + "nbconvert 5.4.1 py37_3", + "nbformat 4.4.0 py37_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.2 py37_1", + "nltk 3.4 py37_1", + "nose 1.3.7 py37_2", + "notebook 5.7.8 py37_0", + "numba 0.43.1 py37h962f231_0", + "numexpr 2.6.9 py37h9e4a6bb_0", + "numpy 1.16.2 py37h7e9f1db_0", + "numpy-base 1.16.2 py37hde5b4d6_0", + "numpydoc 0.8.0 py37_0", + "olefile 0.46 py37_0", + "openpyxl 2.6.1 py37_1", + "openssl 1.1.1b h7b6447c_1", + "packaging 19.0 py37_0", + "pandas 0.24.2 py37he6710b0_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py37_1", + "pango 1.42.4 h049681c_0", + "parso 0.3.4 py37_0", + "partd 0.3.10 py37_1", + "patchelf 0.9 he6710b0_3", + "path.py 11.5.0 py37_0", + "pathlib2 2.3.3 py37_0", + "patsy 0.5.1 py37_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py37_0", + "pexpect 4.6.0 py37_0", + "pickleshare 0.7.5 py37_0", + "pillow 5.4.1 py37h34e0f95_0", + "pip 19.0.3 py37_0", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py37_0", + "pluggy 0.9.0 py37_0", + "ply 3.11 py37_0", + "prometheus_client 0.6.0 py37_0", + "prompt_toolkit 2.0.9 py37_0", + "psutil 5.6.1 py37h7b6447c_0", + "ptyprocess 0.6.0 py37_0", + "py 1.8.0 py37_0", + "py-lief 0.9.0 py37h7725739_2", + "pycodestyle 2.5.0 py37_0", + "pycosat 0.6.3 py37h14c3975_0", + "pycparser 2.19 py37_0", + "pycrypto 2.6.1 py37h14c3975_9", + "pycurl 7.43.0.2 py37h1ba5d50_0", + "pyflakes 2.1.1 py37_0", + "pygments 2.3.1 py37_0", + "pylint 2.3.1 py37_0", + "pyodbc 4.0.26 py37he6710b0_0", + "pyopenssl 19.0.0 py37_0", + "pyparsing 2.3.1 py37_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.14.11 py37h7b6447c_0", + "pysocks 1.6.8 py37_0", + "pytables 3.5.1 py37h71ec239_0", + "pytest 4.3.1 py37_0", + "pytest-arraydiff 0.3 py37h39e3cac_0", + "pytest-astropy 0.5.0 py37_0", + "pytest-doctestplus 0.3.0 py37_0", + "pytest-openfiles 0.3.2 py37_0", + "pytest-remotedata 0.3.1 py37_0", + "python 3.7.3 h0371630_0", + "python-dateutil 2.8.0 py37_0", + "python-libarchive-c 2.8 py37_6", + "pytz 2018.9 py37_0", + "pywavelets 1.0.2 py37hdd07704_0", + "pyyaml 5.1 py37h7b6447c_0", + "pyzmq 18.0.0 py37he6710b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.5.7 py37_1", + "qtconsole 4.4.3 py37_0", + "qtpy 1.7.0 py37_1", + "readline 7.0 h7b6447c_5", + "requests 2.21.0 py37_0", + "rope 0.12.0 py37_0", + "ruamel_yaml 0.15.46 py37h14c3975_0", + "scikit-image 0.14.2 py37he6710b0_0", + "scikit-learn 0.20.3 py37hd81dba3_0", + "scipy 1.2.1 py37h7c811a0_0", + "seaborn 0.9.0 py37_0", + "secretstorage 3.1.1 py37_0", + "send2trash 1.5.0 py37_0", + "setuptools 40.8.0 py37_0", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.4.0.3 py37_0", + "sip 4.19.8 py37hf484d3e_0", + "six 1.12.0 py37_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 1.2.1 py37_0", + "sortedcollections 1.1.2 py37_0", + "sortedcontainers 2.1.0 py37_0", + "soupsieve 1.8 py37_0", + "sphinx 1.8.5 py37_0", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-websupport 1.1.0 py37_1", + "spyder 3.3.3 py37_0", + "spyder-kernels 0.4.2 py37_0", + "sqlalchemy 1.3.1 py37h7b6447c_0", + "sqlite 3.27.2 h7b6447c_0", + "statsmodels 0.9.0 py37h035aef0_0", + "sympy 1.3 py37_0", + "tblib 1.3.2 py37_0", + "terminado 0.8.1 py37_1", + "testpath 0.4.2 py37_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.9.0 py37_0", + "tornado 6.0.2 py37h7b6447c_0", + "tqdm 4.31.1 py37_1", + "traitlets 4.3.2 py37_0", + "unicodecsv 0.14.1 py37_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.1 py37_0", + "wcwidth 0.1.7 py37_0", + "webencodings 0.5.1 py37_1", + "werkzeug 0.14.1 py37_0", + "wheel 0.33.1 py37_0", + "widgetsnbextension 3.4.2 py37_0", + "wrapt 1.11.1 py37h7b6447c_0", + "wurlitzer 1.0.2 py37_0", + "xlrd 1.2.0 py37_0", + "xlsxwriter 1.1.5 py37_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.3.1 he6710b0_3", + "zict 0.1.4 py37_0", + "zipp 0.3.3 py37_1", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "9deb9574032a3afc8d9014ef8108953d", + "name": "anaconda", + "namespace": "python", + "sha256": "9366ade6616213f045391f64d384ff8ba7c39403e39d67b903b79466002c1b21", + "size": 10957, + "subdir": "linux-64", + "timestamp": 1554399120759, + "version": "2019.03" + }, + "anaconda-2019.07-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py27_0", + "anaconda-client 1.7.2 py27_0", + "anaconda-project 0.8.3 py_0", + "asn1crypto 0.24.0 py27_0", + "astroid 1.6.5 py27_0", + "astropy 2.0.9 py27hdd07704_0", + "atomicwrites 1.3.0 py27_1", + "attrs 19.1.0 py27_1", + "babel 2.7.0 py_0", + "backports 1.0 py_2", + "backports.functools_lru_cache 1.5 py_2", + "backports.os 0.1.1 py27_0", + "backports.shutil_get_terminal_size 1.0.0 py27_2", + "backports_abc 0.5 py27_0", + "beautifulsoup4 4.7.1 py27_1", + "bitarray 0.9.3 py27h7b6447c_0", + "bkcharts 0.2 py27_0", + "blas 1.0 mkl", + "bleach 3.1.0 py27_0", + "blosc 1.16.3 hd408876_0", + "bokeh 1.2.0 py27_0", + "boto 2.49.0 py27_0", + "bottleneck 1.2.1 py27h035aef0_1", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2019.5.15 0", + "cairo 1.14.12 h8948797_3", + "cdecimal 2.3 py27h14c3975_3", + "certifi 2019.6.16 py27_0", + "cffi 1.12.3 py27h2e261b9_0", + "chardet 3.0.4 py27_1", + "click 7.0 py27_0", + "cloudpickle 1.2.1 py_0", + "clyent 1.2.2 py27_1", + "colorama 0.4.1 py27_0", + "configparser 3.7.4 py27_0", + "contextlib2 0.5.5 py27_0", + "cryptography 2.7 py27h1ba5d50_0", + "curl 7.65.2 hbc83047_0", + "cycler 0.10.0 py27_0", + "cython 0.29.12 py27he6710b0_0", + "cytoolz 0.10.0 py27h7b6447c_0", + "dask 1.2.2 py_0", + "dask-core 1.2.2 py_0", + "dbus 1.13.6 h746ee38_0", + "decorator 4.4.0 py27_1", + "defusedxml 0.6.0 py_0", + "distributed 1.28.1 py27_0", + "docutils 0.14 py27_0", + "entrypoints 0.3 py27_0", + "enum34 1.1.6 py27_1", + "et_xmlfile 1.0.1 py27_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.1.0 py27h7b6447c_0", + "filelock 3.0.12 py_0", + "flask 1.1.1 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "funcsigs 1.0.2 py27_0", + "functools32 3.2.3.2 py27_1", + "future 0.17.1 py27_0", + "futures 3.3.0 py27_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py27h7b6447c_0", + "glib 2.56.2 hd408876_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py27h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py27h7b6447c_0", + "grin 1.2.1 py27_4", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.9.0 py27h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.0 py27_2", + "html5lib 1.0.1 py27_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py27_0", + "imageio 2.5.0 py27_0", + "imagesize 1.1.0 py27_0", + "importlib_metadata 0.17 py27_1", + "intel-openmp 2019.4 243", + "ipaddress 1.0.22 py27_0", + "ipykernel 4.10.0 py27_0", + "ipython 5.8.0 py27_0", + "ipython_genutils 0.2.0 py27_0", + "ipywidgets 7.5.0 py_0", + "isort 4.3.21 py27_0", + "itsdangerous 1.1.0 py27_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.13.3 py27_0", + "jinja2 2.10.1 py27_0", + "jpeg 9b h024ee3a_2", + "jsonschema 3.0.1 py27_0", + "jupyter 1.0.0 py27_7", + "jupyter_client 5.3.1 py_0", + "jupyter_console 5.2.0 py27_1", + "jupyter_core 4.5.0 py_0", + "jupyterlab 0.33.11 py27_0", + "jupyterlab_launcher 0.11.2 py27h28b3542_0", + "kiwisolver 1.1.0 py27he6710b0_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.4.1 py27h7b6447c_0", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.65.2 h20c2e04_0", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.2 h1ba5d50_0", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.0.10 h2733197_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 hea5a465_1", + "libxslt 1.1.33 h7d1a2b0_0", + "linecache2 1.0.0 py27_0", + "llvmlite 0.29.0 py27hd408876_0", + "locket 0.2.0 py27_1", + "lxml 4.3.4 py27hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py27h7b6447c_0", + "matplotlib 2.2.3 py27hb69df0a_0", + "mccabe 0.6.1 py27_1", + "mistune 0.8.4 py27h7b6447c_0", + "mkl 2019.4 243", + "mkl-service 2.0.2 py27h7b6447c_0", + "mkl_fft 1.0.12 py27ha843d7b_0", + "mkl_random 1.0.2 py27hd81dba3_0", + "mock 3.0.5 py27_0", + "more-itertools 5.0.0 py27_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py27_0", + "msgpack-python 0.6.1 py27hfd86e86_1", + "multipledispatch 0.6.0 py27_0", + "nbconvert 5.5.0 py_0", + "nbformat 4.4.0 py27_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.2 py27_1", + "nltk 3.4.4 py27_0", + "nose 1.3.7 py27_2", + "notebook 5.7.8 py27_0", + "numba 0.44.1 py27h962f231_0", + "numexpr 2.6.9 py27h9e4a6bb_0", + "numpy 1.16.4 py27h7e9f1db_0", + "numpy-base 1.16.4 py27hde5b4d6_0", + "numpydoc 0.9.1 py_0", + "olefile 0.46 py27_0", + "openpyxl 2.6.2 py_0", + "openssl 1.1.1c h7b6447c_1", + "packaging 19.0 py27_0", + "pandas 0.24.2 py27he6710b0_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py27_1", + "pango 1.42.4 h049681c_0", + "parso 0.5.0 py_0", + "partd 1.0.0 py_0", + "patchelf 0.9 he6710b0_3", + "path.py 11.5.0 py27_0", + "pathlib2 2.3.4 py27_0", + "patsy 0.5.1 py27_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py27_0", + "pexpect 4.7.0 py27_0", + "pickleshare 0.7.5 py27_0", + "pillow 6.1.0 py27h34e0f95_0", + "pip 19.1.1 py27_0", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py27_0", + "pluggy 0.12.0 py_0", + "ply 3.11 py27_0", + "prometheus_client 0.7.1 py_0", + "prompt_toolkit 1.0.15 py27_0", + "psutil 5.6.3 py27h7b6447c_0", + "ptyprocess 0.6.0 py27_0", + "py 1.8.0 py27_0", + "py-lief 0.9.0 py27h7725739_2", + "pycairo 1.18.1 py27h2a1e443_0", + "pycodestyle 2.5.0 py27_0", + "pycosat 0.6.3 py27h14c3975_0", + "pycparser 2.19 py27_0", + "pycrypto 2.6.1 py27h14c3975_9", + "pycurl 7.43.0.3 py27h1ba5d50_0", + "pyflakes 2.1.1 py27_0", + "pygments 2.4.2 py_0", + "pylint 1.9.2 py27_0", + "pyodbc 4.0.26 py27he6710b0_0", + "pyopenssl 19.0.0 py27_0", + "pyparsing 2.4.0 py_0", + "pyqt 5.9.2 py27h05f1152_2", + "pyrsistent 0.14.11 py27h7b6447c_0", + "pysocks 1.7.0 py27_0", + "pytables 3.5.2 py27h71ec239_1", + "pytest 4.6.2 py27_0", + "python 2.7.16 h9bab390_0", + "python-dateutil 2.8.0 py27_0", + "python-libarchive-c 2.8 py27_11", + "pytz 2019.1 py_0", + "pywavelets 1.0.3 py27hdd07704_1", + "pyyaml 5.1.1 py27h7b6447c_0", + "pyzmq 18.0.0 py27he6710b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.5.7 py27_1", + "qtconsole 4.5.1 py_0", + "qtpy 1.8.0 py_0", + "readline 7.0 h7b6447c_5", + "requests 2.22.0 py27_0", + "rope 0.14.0 py_0", + "ruamel_yaml 0.15.46 py27h14c3975_0", + "scandir 1.10.0 py27h7b6447c_0", + "scikit-image 0.14.2 py27he6710b0_0", + "scikit-learn 0.20.3 py27hd81dba3_0", + "scipy 1.2.1 py27h7c811a0_0", + "seaborn 0.9.0 py27_0", + "send2trash 1.5.0 py27_0", + "setuptools 41.0.1 py27_0", + "simplegeneric 0.8.1 py27_2", + "singledispatch 3.4.0.3 py27_0", + "sip 4.19.8 py27hf484d3e_0", + "six 1.12.0 py27_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 1.9.0 py_0", + "sortedcollections 1.1.2 py27_0", + "sortedcontainers 2.1.0 py27_0", + "soupsieve 1.8 py27_0", + "sphinx 1.8.5 py27_0", + "sphinxcontrib 1.0 py27_1", + "sphinxcontrib-websupport 1.1.2 py_0", + "spyder 3.3.6 py27_0", + "spyder-kernels 0.5.1 py27_0", + "sqlalchemy 1.3.5 py27h7b6447c_0", + "sqlite 3.29.0 h7b6447c_0", + "ssl_match_hostname 3.7.0.1 py27_0", + "statsmodels 0.10.0 py27hdd07704_0", + "subprocess32 3.5.4 py27h7b6447c_0", + "sympy 1.4 py27_0", + "tblib 1.4.0 py_0", + "terminado 0.8.2 py27_0", + "testpath 0.4.2 py27_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.10.0 py_0", + "tornado 5.1.1 py27h7b6447c_0", + "tqdm 4.32.1 py_0", + "traceback2 1.4.0 py27_0", + "traitlets 4.3.2 py27_0", + "typing 3.7.4 py27_0", + "unicodecsv 0.14.1 py27_0", + "unittest2 1.1.0 py27_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.2 py27_0", + "wcwidth 0.1.7 py27_0", + "webencodings 0.5.1 py27_1", + "werkzeug 0.15.4 py_0", + "wheel 0.33.4 py27_0", + "widgetsnbextension 3.5.0 py27_0", + "wrapt 1.11.2 py27h7b6447c_0", + "wurlitzer 1.0.2 py27_0", + "xlrd 1.2.0 py27_0", + "xlsxwriter 1.1.8 py_0", + "xlwt 1.3.0 py27_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.3.1 he6710b0_3", + "zict 1.0.0 py_0", + "zipp 0.5.1 py_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "c452bd732c434b0898e28dd6a9a8031b", + "name": "anaconda", + "namespace": "python", + "sha256": "b5611b292f30a3953c295ee58c84cd4d83212d9c3a047ab619dad7e1b11248b0", + "size": 11438, + "subdir": "linux-64", + "timestamp": 1563737544632, + "version": "2019.07" + }, + "anaconda-2019.07-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py36_0", + "anaconda-client 1.7.2 py36_0", + "anaconda-project 0.8.3 py_0", + "asn1crypto 0.24.0 py36_0", + "astroid 2.2.5 py36_0", + "astropy 3.2.1 py36h7b6447c_0", + "atomicwrites 1.3.0 py36_1", + "attrs 19.1.0 py36_1", + "babel 2.7.0 py_0", + "backcall 0.1.0 py36_0", + "backports 1.0 py_2", + "backports.os 0.1.1 py36_0", + "backports.shutil_get_terminal_size 1.0.0 py36_2", + "beautifulsoup4 4.7.1 py36_1", + "bitarray 0.9.3 py36h7b6447c_0", + "bkcharts 0.2 py36_0", + "blas 1.0 mkl", + "bleach 3.1.0 py36_0", + "blosc 1.16.3 hd408876_0", + "bokeh 1.2.0 py36_0", + "boto 2.49.0 py36_0", + "bottleneck 1.2.1 py36h035aef0_1", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2019.5.15 0", + "cairo 1.14.12 h8948797_3", + "certifi 2019.6.16 py36_0", + "cffi 1.12.3 py36h2e261b9_0", + "chardet 3.0.4 py36_1", + "click 7.0 py36_0", + "cloudpickle 1.2.1 py_0", + "clyent 1.2.2 py36_1", + "colorama 0.4.1 py36_0", + "contextlib2 0.5.5 py36_0", + "cryptography 2.7 py36h1ba5d50_0", + "curl 7.65.2 hbc83047_0", + "cycler 0.10.0 py36_0", + "cython 0.29.12 py36he6710b0_0", + "cytoolz 0.10.0 py36h7b6447c_0", + "dask 2.1.0 py_0", + "dask-core 2.1.0 py_0", + "dbus 1.13.6 h746ee38_0", + "decorator 4.4.0 py36_1", + "defusedxml 0.6.0 py_0", + "distributed 2.1.0 py_0", + "docutils 0.14 py36_0", + "entrypoints 0.3 py36_0", + "et_xmlfile 1.0.1 py36_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.1.0 py36h7b6447c_0", + "filelock 3.0.12 py_0", + "flask 1.1.1 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py36h7b6447c_0", + "glib 2.56.2 hd408876_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py36h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py36h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.9.0 py36h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.0 py36_2", + "html5lib 1.0.1 py36_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py36_0", + "imageio 2.5.0 py36_0", + "imagesize 1.1.0 py36_0", + "importlib_metadata 0.17 py36_1", + "intel-openmp 2019.4 243", + "ipykernel 5.1.1 py36h39e3cac_0", + "ipython 7.6.1 py36h39e3cac_0", + "ipython_genutils 0.2.0 py36_0", + "ipywidgets 7.5.0 py_0", + "isort 4.3.21 py36_0", + "itsdangerous 1.1.0 py36_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.13.3 py36_0", + "jeepney 0.4 py36_0", + "jinja2 2.10.1 py36_0", + "joblib 0.13.2 py36_0", + "jpeg 9b h024ee3a_2", + "json5 0.8.4 py_0", + "jsonschema 3.0.1 py36_0", + "jupyter 1.0.0 py36_7", + "jupyter_client 5.3.1 py_0", + "jupyter_console 6.0.0 py36_0", + "jupyter_core 4.5.0 py_0", + "jupyterlab 1.0.2 py36hf63ae98_0", + "jupyterlab_server 1.0.0 py_0", + "keyring 18.0.0 py36_0", + "kiwisolver 1.1.0 py36he6710b0_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.4.1 py36h7b6447c_0", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.65.2 h20c2e04_0", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.2 h1ba5d50_0", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.0.10 h2733197_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 hea5a465_1", + "libxslt 1.1.33 h7d1a2b0_0", + "llvmlite 0.29.0 py36hd408876_0", + "locket 0.2.0 py36_1", + "lxml 4.3.4 py36hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py36h7b6447c_0", + "matplotlib 3.1.0 py36h5429711_0", + "mccabe 0.6.1 py36_1", + "mistune 0.8.4 py36h7b6447c_0", + "mkl 2019.4 243", + "mkl-service 2.0.2 py36h7b6447c_0", + "mkl_fft 1.0.12 py36ha843d7b_0", + "mkl_random 1.0.2 py36hd81dba3_0", + "mock 3.0.5 py36_0", + "more-itertools 7.0.0 py36_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py36_0", + "msgpack-python 0.6.1 py36hfd86e86_1", + "multipledispatch 0.6.0 py36_0", + "nbconvert 5.5.0 py_0", + "nbformat 4.4.0 py36_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.3 py_0", + "nltk 3.4.4 py36_0", + "nose 1.3.7 py36_2", + "notebook 6.0.0 py36_0", + "numba 0.45.0 py36h962f231_0", + "numexpr 2.6.9 py36h9e4a6bb_0", + "numpy 1.16.4 py36h7e9f1db_0", + "numpy-base 1.16.4 py36hde5b4d6_0", + "numpydoc 0.9.1 py_0", + "olefile 0.46 py36_0", + "openpyxl 2.6.2 py_0", + "openssl 1.1.1c h7b6447c_1", + "packaging 19.0 py36_0", + "pandas 0.24.2 py36he6710b0_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py36_1", + "pango 1.42.4 h049681c_0", + "parso 0.5.0 py_0", + "partd 1.0.0 py_0", + "patchelf 0.9 he6710b0_3", + "path.py 12.0.1 py_0", + "pathlib2 2.3.4 py36_0", + "patsy 0.5.1 py36_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py36_0", + "pexpect 4.7.0 py36_0", + "pickleshare 0.7.5 py36_0", + "pillow 6.1.0 py36h34e0f95_0", + "pip 19.1.1 py36_0", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py36_0", + "pluggy 0.12.0 py_0", + "ply 3.11 py36_0", + "prometheus_client 0.7.1 py_0", + "prompt_toolkit 2.0.9 py36_0", + "psutil 5.6.3 py36h7b6447c_0", + "ptyprocess 0.6.0 py36_0", + "py 1.8.0 py36_0", + "py-lief 0.9.0 py36h7725739_2", + "pycodestyle 2.5.0 py36_0", + "pycosat 0.6.3 py36h14c3975_0", + "pycparser 2.19 py36_0", + "pycrypto 2.6.1 py36h14c3975_9", + "pycurl 7.43.0.3 py36h1ba5d50_0", + "pyflakes 2.1.1 py36_0", + "pygments 2.4.2 py_0", + "pylint 2.3.1 py36_0", + "pyodbc 4.0.26 py36he6710b0_0", + "pyopenssl 19.0.0 py36_0", + "pyparsing 2.4.0 py_0", + "pyqt 5.9.2 py36h05f1152_2", + "pyrsistent 0.14.11 py36h7b6447c_0", + "pysocks 1.7.0 py36_0", + "pytables 3.5.2 py36h71ec239_1", + "pytest 5.0.1 py36_0", + "pytest-arraydiff 0.3 py36h39e3cac_0", + "pytest-astropy 0.5.0 py36_0", + "pytest-doctestplus 0.3.0 py36_0", + "pytest-openfiles 0.3.2 py36_0", + "pytest-remotedata 0.3.1 py36_0", + "python 3.6.8 h0371630_0", + "python-dateutil 2.8.0 py36_0", + "python-libarchive-c 2.8 py36_11", + "pytz 2019.1 py_0", + "pywavelets 1.0.3 py36hdd07704_1", + "pyyaml 5.1.1 py36h7b6447c_0", + "pyzmq 18.0.0 py36he6710b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.5.7 py36_1", + "qtconsole 4.5.1 py_0", + "qtpy 1.8.0 py_0", + "readline 7.0 h7b6447c_5", + "requests 2.22.0 py36_0", + "rope 0.14.0 py_0", + "ruamel_yaml 0.15.46 py36h14c3975_0", + "scikit-image 0.15.0 py36he6710b0_0", + "scikit-learn 0.21.2 py36hd81dba3_0", + "scipy 1.3.0 py36h7c811a0_0", + "seaborn 0.9.0 py36_0", + "secretstorage 3.1.1 py36_0", + "send2trash 1.5.0 py36_0", + "setuptools 41.0.1 py36_0", + "simplegeneric 0.8.1 py36_2", + "singledispatch 3.4.0.3 py36_0", + "sip 4.19.8 py36hf484d3e_0", + "six 1.12.0 py36_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 1.9.0 py_0", + "sortedcollections 1.1.2 py36_0", + "sortedcontainers 2.1.0 py36_0", + "soupsieve 1.8 py36_0", + "sphinx 2.1.2 py_0", + "sphinxcontrib 1.0 py36_1", + "sphinxcontrib-applehelp 1.0.1 py_0", + "sphinxcontrib-devhelp 1.0.1 py_0", + "sphinxcontrib-htmlhelp 1.0.2 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.2 py_0", + "sphinxcontrib-serializinghtml 1.1.3 py_0", + "sphinxcontrib-websupport 1.1.2 py_0", + "spyder 3.3.6 py36_0", + "spyder-kernels 0.5.1 py36_0", + "sqlalchemy 1.3.5 py36h7b6447c_0", + "sqlite 3.29.0 h7b6447c_0", + "statsmodels 0.10.0 py36hdd07704_0", + "sympy 1.4 py36_0", + "tblib 1.4.0 py_0", + "terminado 0.8.2 py36_0", + "testpath 0.4.2 py36_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.10.0 py_0", + "tornado 6.0.3 py36h7b6447c_0", + "tqdm 4.32.1 py_0", + "traitlets 4.3.2 py36_0", + "typed-ast 1.3.4 py36h7b6447c_0", + "unicodecsv 0.14.1 py36_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.2 py36_0", + "wcwidth 0.1.7 py36_0", + "webencodings 0.5.1 py36_1", + "werkzeug 0.15.4 py_0", + "wheel 0.33.4 py36_0", + "widgetsnbextension 3.5.0 py36_0", + "wrapt 1.11.2 py36h7b6447c_0", + "wurlitzer 1.0.2 py36_0", + "xlrd 1.2.0 py36_0", + "xlsxwriter 1.1.8 py_0", + "xlwt 1.3.0 py36_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.3.1 he6710b0_3", + "zict 1.0.0 py_0", + "zipp 0.5.1 py_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "8113907407bac90c2a18e9a429326c41", + "name": "anaconda", + "namespace": "python", + "sha256": "f6a756207ac91cfae2f3175819a480dde8656622666816c923f9484630fb7127", + "size": 11347, + "subdir": "linux-64", + "timestamp": 1563823219641, + "version": "2019.07" + }, + "anaconda-2019.07-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.7.2 py37_0", + "anaconda-project 0.8.3 py_0", + "asn1crypto 0.24.0 py37_0", + "astroid 2.2.5 py37_0", + "astropy 3.2.1 py37h7b6447c_0", + "atomicwrites 1.3.0 py37_1", + "attrs 19.1.0 py37_1", + "babel 2.7.0 py_0", + "backcall 0.1.0 py37_0", + "backports 1.0 py_2", + "backports.os 0.1.1 py37_0", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "beautifulsoup4 4.7.1 py37_1", + "bitarray 0.9.3 py37h7b6447c_0", + "bkcharts 0.2 py37_0", + "blas 1.0 mkl", + "bleach 3.1.0 py37_0", + "blosc 1.16.3 hd408876_0", + "bokeh 1.2.0 py37_0", + "boto 2.49.0 py37_0", + "bottleneck 1.2.1 py37h035aef0_1", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2019.5.15 0", + "cairo 1.14.12 h8948797_3", + "certifi 2019.6.16 py37_0", + "cffi 1.12.3 py37h2e261b9_0", + "chardet 3.0.4 py37_1", + "click 7.0 py37_0", + "cloudpickle 1.2.1 py_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.1 py37_0", + "contextlib2 0.5.5 py37_0", + "cryptography 2.7 py37h1ba5d50_0", + "curl 7.65.2 hbc83047_0", + "cycler 0.10.0 py37_0", + "cython 0.29.12 py37he6710b0_0", + "cytoolz 0.10.0 py37h7b6447c_0", + "dask 2.1.0 py_0", + "dask-core 2.1.0 py_0", + "dbus 1.13.6 h746ee38_0", + "decorator 4.4.0 py37_1", + "defusedxml 0.6.0 py_0", + "distributed 2.1.0 py_0", + "docutils 0.14 py37_0", + "entrypoints 0.3 py37_0", + "et_xmlfile 1.0.1 py37_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.1.0 py37h7b6447c_0", + "filelock 3.0.12 py_0", + "flask 1.1.1 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py37h7b6447c_0", + "glib 2.56.2 hd408876_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py37h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.9.0 py37h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.0 py37_2", + "html5lib 1.0.1 py37_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py37_0", + "imageio 2.5.0 py37_0", + "imagesize 1.1.0 py37_0", + "importlib_metadata 0.17 py37_1", + "intel-openmp 2019.4 243", + "ipykernel 5.1.1 py37h39e3cac_0", + "ipython 7.6.1 py37h39e3cac_0", + "ipython_genutils 0.2.0 py37_0", + "ipywidgets 7.5.0 py_0", + "isort 4.3.21 py37_0", + "itsdangerous 1.1.0 py37_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.13.3 py37_0", + "jeepney 0.4 py37_0", + "jinja2 2.10.1 py37_0", + "joblib 0.13.2 py37_0", + "jpeg 9b h024ee3a_2", + "json5 0.8.4 py_0", + "jsonschema 3.0.1 py37_0", + "jupyter 1.0.0 py37_7", + "jupyter_client 5.3.1 py_0", + "jupyter_console 6.0.0 py37_0", + "jupyter_core 4.5.0 py_0", + "jupyterlab 1.0.2 py37hf63ae98_0", + "jupyterlab_server 1.0.0 py_0", + "keyring 18.0.0 py37_0", + "kiwisolver 1.1.0 py37he6710b0_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.4.1 py37h7b6447c_0", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.65.2 h20c2e04_0", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.2 h1ba5d50_0", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.0.10 h2733197_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 hea5a465_1", + "libxslt 1.1.33 h7d1a2b0_0", + "llvmlite 0.29.0 py37hd408876_0", + "locket 0.2.0 py37_1", + "lxml 4.3.4 py37hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py37h7b6447c_0", + "matplotlib 3.1.0 py37h5429711_0", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h7b6447c_0", + "mkl 2019.4 243", + "mkl-service 2.0.2 py37h7b6447c_0", + "mkl_fft 1.0.12 py37ha843d7b_0", + "mkl_random 1.0.2 py37hd81dba3_0", + "mock 3.0.5 py37_0", + "more-itertools 7.0.0 py37_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py37_0", + "msgpack-python 0.6.1 py37hfd86e86_1", + "multipledispatch 0.6.0 py37_0", + "nbconvert 5.5.0 py_0", + "nbformat 4.4.0 py37_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.3 py_0", + "nltk 3.4.4 py37_0", + "nose 1.3.7 py37_2", + "notebook 6.0.0 py37_0", + "numba 0.44.1 py37h962f231_0", + "numexpr 2.6.9 py37h9e4a6bb_0", + "numpy 1.16.4 py37h7e9f1db_0", + "numpy-base 1.16.4 py37hde5b4d6_0", + "numpydoc 0.9.1 py_0", + "olefile 0.46 py37_0", + "openpyxl 2.6.2 py_0", + "openssl 1.1.1c h7b6447c_1", + "packaging 19.0 py37_0", + "pandas 0.24.2 py37he6710b0_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py37_1", + "pango 1.42.4 h049681c_0", + "parso 0.5.0 py_0", + "partd 1.0.0 py_0", + "patchelf 0.9 he6710b0_3", + "path.py 12.0.1 py_0", + "pathlib2 2.3.4 py37_0", + "patsy 0.5.1 py37_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py37_0", + "pexpect 4.7.0 py37_0", + "pickleshare 0.7.5 py37_0", + "pillow 6.1.0 py37h34e0f95_0", + "pip 19.1.1 py37_0", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py37_0", + "pluggy 0.12.0 py_0", + "ply 3.11 py37_0", + "prometheus_client 0.7.1 py_0", + "prompt_toolkit 2.0.9 py37_0", + "psutil 5.6.3 py37h7b6447c_0", + "ptyprocess 0.6.0 py37_0", + "py 1.8.0 py37_0", + "py-lief 0.9.0 py37h7725739_2", + "pycodestyle 2.5.0 py37_0", + "pycosat 0.6.3 py37h14c3975_0", + "pycparser 2.19 py37_0", + "pycrypto 2.6.1 py37h14c3975_9", + "pycurl 7.43.0.3 py37h1ba5d50_0", + "pyflakes 2.1.1 py37_0", + "pygments 2.4.2 py_0", + "pylint 2.3.1 py37_0", + "pyodbc 4.0.26 py37he6710b0_0", + "pyopenssl 19.0.0 py37_0", + "pyparsing 2.4.0 py_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.14.11 py37h7b6447c_0", + "pysocks 1.7.0 py37_0", + "pytables 3.5.2 py37h71ec239_1", + "pytest 5.0.1 py37_0", + "pytest-arraydiff 0.3 py37h39e3cac_0", + "pytest-astropy 0.5.0 py37_0", + "pytest-doctestplus 0.3.0 py37_0", + "pytest-openfiles 0.3.2 py37_0", + "pytest-remotedata 0.3.1 py37_0", + "python 3.7.3 h0371630_0", + "python-dateutil 2.8.0 py37_0", + "python-libarchive-c 2.8 py37_11", + "pytz 2019.1 py_0", + "pywavelets 1.0.3 py37hdd07704_1", + "pyyaml 5.1.1 py37h7b6447c_0", + "pyzmq 18.0.0 py37he6710b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.5.7 py37_1", + "qtconsole 4.5.1 py_0", + "qtpy 1.8.0 py_0", + "readline 7.0 h7b6447c_5", + "requests 2.22.0 py37_0", + "rope 0.14.0 py_0", + "ruamel_yaml 0.15.46 py37h14c3975_0", + "scikit-image 0.15.0 py37he6710b0_0", + "scikit-learn 0.21.2 py37hd81dba3_0", + "scipy 1.3.0 py37h7c811a0_0", + "seaborn 0.9.0 py37_0", + "secretstorage 3.1.1 py37_0", + "send2trash 1.5.0 py37_0", + "setuptools 41.0.1 py37_0", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.4.0.3 py37_0", + "sip 4.19.8 py37hf484d3e_0", + "six 1.12.0 py37_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 1.9.0 py_0", + "sortedcollections 1.1.2 py37_0", + "sortedcontainers 2.1.0 py37_0", + "soupsieve 1.8 py37_0", + "sphinx 2.1.2 py_0", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-applehelp 1.0.1 py_0", + "sphinxcontrib-devhelp 1.0.1 py_0", + "sphinxcontrib-htmlhelp 1.0.2 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.2 py_0", + "sphinxcontrib-serializinghtml 1.1.3 py_0", + "sphinxcontrib-websupport 1.1.2 py_0", + "spyder 3.3.6 py37_0", + "spyder-kernels 0.5.1 py37_0", + "sqlalchemy 1.3.5 py37h7b6447c_0", + "sqlite 3.29.0 h7b6447c_0", + "statsmodels 0.10.0 py37hdd07704_0", + "sympy 1.4 py37_0", + "tblib 1.4.0 py_0", + "terminado 0.8.2 py37_0", + "testpath 0.4.2 py37_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.10.0 py_0", + "tornado 6.0.3 py37h7b6447c_0", + "tqdm 4.32.1 py_0", + "traitlets 4.3.2 py37_0", + "unicodecsv 0.14.1 py37_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.2 py37_0", + "wcwidth 0.1.7 py37_0", + "webencodings 0.5.1 py37_1", + "werkzeug 0.15.4 py_0", + "wheel 0.33.4 py37_0", + "widgetsnbextension 3.5.0 py37_0", + "wrapt 1.11.2 py37h7b6447c_0", + "wurlitzer 1.0.2 py37_0", + "xlrd 1.2.0 py37_0", + "xlsxwriter 1.1.8 py_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.3.1 he6710b0_3", + "zict 1.0.0 py_0", + "zipp 0.5.1 py_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "1a4e87894405487f7eea6dea88310e14", + "name": "anaconda", + "namespace": "python", + "sha256": "1fb67bc2748f4996afcc931562a655db2aa5833bde2d56d499688e2e0cc02c08", + "size": 11247, + "subdir": "linux-64", + "timestamp": 1563737521446, + "version": "2019.07" + }, + "anaconda-2019.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py27_0", + "anaconda-client 1.7.2 py27_0", + "anaconda-project 0.8.3 py_0", + "asn1crypto 1.0.1 py27_0", + "astroid 1.6.5 py27_0", + "astropy 2.0.9 py27hdd07704_0", + "atomicwrites 1.3.0 py27_1", + "attrs 19.2.0 py_0", + "babel 2.7.0 py_0", + "backports 1.0 py_2", + "backports.functools_lru_cache 1.5 py_2", + "backports.os 0.1.1 py27_0", + "backports.shutil_get_terminal_size 1.0.0 py27_2", + "backports_abc 0.5 py27_0", + "beautifulsoup4 4.8.0 py27_0", + "bitarray 1.0.1 py27h7b6447c_0", + "bkcharts 0.2 py27_0", + "blas 1.0 mkl", + "bleach 3.1.0 py27_0", + "blosc 1.16.3 hd408876_0", + "bokeh 1.3.4 py27_0", + "boto 2.49.0 py27_0", + "bottleneck 1.2.1 py27h035aef0_1", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2019.8.28 0", + "cairo 1.14.12 h8948797_3", + "cdecimal 2.3 py27h14c3975_3", + "certifi 2019.9.11 py27_0", + "cffi 1.12.3 py27h2e261b9_0", + "chardet 3.0.4 py27_1003", + "click 7.0 py27_0", + "cloudpickle 1.2.2 py_0", + "clyent 1.2.2 py27_1", + "colorama 0.4.1 py27_0", + "configparser 4.0.2 py27_0", + "contextlib2 0.6.0 py_0", + "cryptography 2.7 py27h1ba5d50_0", + "curl 7.65.3 hbc83047_0", + "cycler 0.10.0 py27_0", + "cython 0.29.13 py27he6710b0_0", + "cytoolz 0.10.0 py27h7b6447c_0", + "dask 1.2.2 py_0", + "dask-core 1.2.2 py_0", + "dbus 1.13.6 h746ee38_0", + "decorator 4.4.0 py27_1", + "defusedxml 0.6.0 py_0", + "distributed 1.28.1 py27_0", + "docutils 0.15.2 py27_0", + "entrypoints 0.3 py27_0", + "enum34 1.1.6 py27_1", + "et_xmlfile 1.0.1 py27_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.1.0 py27h7b6447c_0", + "filelock 3.0.12 py_0", + "flask 1.1.1 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "funcsigs 1.0.2 py27_0", + "functools32 3.2.3.2 py27_1", + "future 0.17.1 py27_0", + "futures 3.3.0 py27_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py27h7b6447c_0", + "glib 2.56.2 hd408876_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py27h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py27h7b6447c_0", + "grin 1.2.1 py27_4", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.9.0 py27h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.0.1 py27_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py27_0", + "imageio 2.6.0 py27_0", + "imagesize 1.1.0 py27_0", + "importlib_metadata 0.23 py27_0", + "intel-openmp 2019.4 243", + "ipaddress 1.0.22 py27_0", + "ipykernel 4.10.0 py27_0", + "ipython 5.8.0 py27_0", + "ipython_genutils 0.2.0 py27_0", + "ipywidgets 7.5.1 py_0", + "isort 4.3.21 py27_0", + "itsdangerous 1.1.0 py27_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.15.1 py27_0", + "jinja2 2.10.3 py_0", + "jpeg 9b h024ee3a_2", + "jsonschema 3.0.2 py27_0", + "jupyter 1.0.0 py27_7", + "jupyter_client 5.3.3 py27_1", + "jupyter_console 5.2.0 py27_1", + "jupyter_core 4.5.0 py_0", + "jupyterlab 0.33.11 py27_0", + "jupyterlab_launcher 0.11.2 py27h28b3542_0", + "kiwisolver 1.1.0 py27he6710b0_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.4.2 py27h7b6447c_0", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.65.3 h20c2e04_0", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.2 h1ba5d50_0", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.0.10 h2733197_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 hea5a465_1", + "libxslt 1.1.33 h7d1a2b0_0", + "linecache2 1.0.0 py27_0", + "llvmlite 0.29.0 py27hd408876_0", + "locket 0.2.0 py27_1", + "lxml 4.4.1 py27hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py27h7b6447c_0", + "matplotlib 2.2.3 py27hb69df0a_0", + "mccabe 0.6.1 py27_1", + "mistune 0.8.4 py27h7b6447c_0", + "mkl 2019.4 243", + "mkl-service 2.3.0 py27he904b0f_0", + "mkl_fft 1.0.14 py27ha843d7b_0", + "mkl_random 1.1.0 py27hd6b4f25_0", + "mock 3.0.5 py27_0", + "more-itertools 5.0.0 py27_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py27_0", + "msgpack-python 0.6.1 py27hfd86e86_1", + "multipledispatch 0.6.0 py27_0", + "nbconvert 5.6.0 py27_1", + "nbformat 4.4.0 py27_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.2 py27_1", + "nltk 3.4.5 py27_0", + "nose 1.3.7 py27_2", + "notebook 5.7.8 py27_0", + "numba 0.45.1 py27h962f231_0", + "numexpr 2.7.0 py27h9e4a6bb_0", + "numpy 1.16.5 py27h7e9f1db_0", + "numpy-base 1.16.5 py27hde5b4d6_0", + "numpydoc 0.9.1 py_0", + "olefile 0.46 py27_0", + "openpyxl 2.6.3 py_0", + "openssl 1.1.1d h7b6447c_2", + "packaging 19.2 py_0", + "pandas 0.24.2 py27he6710b0_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py27_1", + "pango 1.42.4 h049681c_0", + "parso 0.5.1 py_0", + "partd 1.0.0 py_0", + "patchelf 0.9 he6710b0_3", + "path.py 11.5.0 py27_0", + "pathlib2 2.3.5 py27_0", + "patsy 0.5.1 py27_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py27_0", + "pexpect 4.7.0 py27_0", + "pickleshare 0.7.5 py27_0", + "pillow 6.2.0 py27h34e0f95_0", + "pip 19.2.3 py27_0", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py27_0", + "pluggy 0.13.0 py27_0", + "ply 3.11 py27_0", + "prometheus_client 0.7.1 py_0", + "prompt_toolkit 1.0.15 py27_0", + "psutil 5.6.3 py27h7b6447c_0", + "ptyprocess 0.6.0 py27_0", + "py 1.8.0 py27_0", + "py-lief 0.9.0 py27h7725739_2", + "pycairo 1.18.1 py27h2a1e443_0", + "pycodestyle 2.5.0 py27_0", + "pycosat 0.6.3 py27h14c3975_0", + "pycparser 2.19 py27_0", + "pycrypto 2.6.1 py27h14c3975_9", + "pycurl 7.43.0.3 py27h1ba5d50_0", + "pyflakes 2.1.1 py27_0", + "pygments 2.4.2 py_0", + "pylint 1.9.2 py27_0", + "pyodbc 4.0.27 py27he6710b0_0", + "pyopenssl 19.0.0 py27_0", + "pyparsing 2.4.2 py_0", + "pyqt 5.9.2 py27h05f1152_2", + "pyrsistent 0.15.4 py27h7b6447c_0", + "pysocks 1.7.1 py27_0", + "pytables 3.5.2 py27h71ec239_1", + "pytest 4.6.2 py27_0", + "python 2.7.16 h9bab390_7", + "python-dateutil 2.8.0 py27_0", + "python-libarchive-c 2.8 py27_13", + "pytz 2019.3 py_0", + "pywavelets 1.0.3 py27hdd07704_1", + "pyyaml 5.1.2 py27h7b6447c_0", + "pyzmq 18.1.0 py27he6710b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.6.0 py_0", + "qtconsole 4.5.5 py_0", + "qtpy 1.9.0 py_0", + "readline 7.0 h7b6447c_5", + "requests 2.22.0 py27_0", + "ripgrep 0.10.0 hc07d326_0", + "rope 0.14.0 py_0", + "ruamel_yaml 0.15.46 py27h14c3975_0", + "scandir 1.10.0 py27h7b6447c_0", + "scikit-image 0.14.2 py27he6710b0_0", + "scikit-learn 0.20.3 py27hd81dba3_0", + "scipy 1.2.1 py27h7c811a0_0", + "seaborn 0.9.0 py27_0", + "send2trash 1.5.0 py27_0", + "setuptools 41.4.0 py27_0", + "simplegeneric 0.8.1 py27_2", + "singledispatch 3.4.0.3 py27_0", + "sip 4.19.8 py27hf484d3e_0", + "six 1.12.0 py27_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.1.2 py27_0", + "sortedcontainers 2.1.0 py27_0", + "soupsieve 1.9.3 py27_0", + "sphinx 1.8.5 py27_0", + "sphinxcontrib 1.0 py27_1", + "sphinxcontrib-websupport 1.1.2 py_0", + "spyder 3.3.6 py27_0", + "spyder-kernels 0.5.2 py27_0", + "sqlalchemy 1.3.9 py27h7b6447c_0", + "sqlite 3.30.0 h7b6447c_0", + "ssl_match_hostname 3.7.0.1 py27_0", + "statsmodels 0.10.1 py27hdd07704_0", + "subprocess32 3.5.4 py27h7b6447c_0", + "sympy 1.4 py27_0", + "tbb 2019.4 hfd86e86_0", + "tblib 1.4.0 py_0", + "terminado 0.8.2 py27_0", + "testpath 0.4.2 py27_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.10.0 py_0", + "tornado 5.1.1 py27h7b6447c_0", + "tqdm 4.36.1 py_0", + "traceback2 1.4.0 py27_0", + "traitlets 4.3.3 py27_0", + "typing 3.7.4.1 py27_0", + "unicodecsv 0.14.1 py27_0", + "unittest2 1.1.0 py27_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.2 py27_0", + "wcwidth 0.1.7 py27_0", + "webencodings 0.5.1 py27_1", + "werkzeug 0.16.0 py_0", + "wheel 0.33.6 py27_0", + "widgetsnbextension 3.5.1 py27_0", + "wrapt 1.11.2 py27h7b6447c_0", + "wurlitzer 1.0.3 py27_0", + "xlrd 1.2.0 py27_0", + "xlsxwriter 1.2.1 py_0", + "xlwt 1.3.0 py27_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.3.1 he6710b0_3", + "zict 1.0.0 py_0", + "zipp 0.6.0 py_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "6aa966ba11d96fde0d4403746d51f639", + "name": "anaconda", + "namespace": "python", + "sha256": "41d0559a8523e99897134e9736452e9ad4666409d31ca339f2f743d26d310aa4", + "size": 11460, + "subdir": "linux-64", + "timestamp": 1570553783701, + "version": "2019.10" + }, + "anaconda-2019.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py36_0", + "anaconda-client 1.7.2 py36_0", + "anaconda-project 0.8.3 py_0", + "asn1crypto 1.0.1 py36_0", + "astroid 2.3.1 py36_0", + "astropy 3.2.1 py36h7b6447c_0", + "atomicwrites 1.3.0 py36_1", + "attrs 19.2.0 py_0", + "babel 2.7.0 py_0", + "backcall 0.1.0 py36_0", + "backports 1.0 py_2", + "backports.os 0.1.1 py36_0", + "backports.shutil_get_terminal_size 1.0.0 py36_2", + "beautifulsoup4 4.8.0 py36_0", + "bitarray 1.0.1 py36h7b6447c_0", + "bkcharts 0.2 py36_0", + "blas 1.0 mkl", + "bleach 3.1.0 py36_0", + "blosc 1.16.3 hd408876_0", + "bokeh 1.3.4 py36_0", + "boto 2.49.0 py36_0", + "bottleneck 1.2.1 py36h035aef0_1", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2019.8.28 0", + "cairo 1.14.12 h8948797_3", + "certifi 2019.9.11 py36_0", + "cffi 1.12.3 py36h2e261b9_0", + "chardet 3.0.4 py36_1003", + "click 7.0 py36_0", + "cloudpickle 1.2.2 py_0", + "clyent 1.2.2 py36_1", + "colorama 0.4.1 py36_0", + "contextlib2 0.6.0 py_0", + "cryptography 2.7 py36h1ba5d50_0", + "curl 7.65.3 hbc83047_0", + "cycler 0.10.0 py36_0", + "cython 0.29.13 py36he6710b0_0", + "cytoolz 0.10.0 py36h7b6447c_0", + "dask 2.5.2 py_0", + "dask-core 2.5.2 py_0", + "dbus 1.13.6 h746ee38_0", + "decorator 4.4.0 py36_1", + "defusedxml 0.6.0 py_0", + "distributed 2.5.2 py_0", + "docutils 0.15.2 py36_0", + "entrypoints 0.3 py36_0", + "et_xmlfile 1.0.1 py36_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.1.0 py36h7b6447c_0", + "filelock 3.0.12 py_0", + "flask 1.1.1 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "fsspec 0.5.2 py_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py36h7b6447c_0", + "glib 2.56.2 hd408876_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py36h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py36h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.9.0 py36h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.0.1 py36_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py36_0", + "imageio 2.6.0 py36_0", + "imagesize 1.1.0 py36_0", + "importlib_metadata 0.23 py36_0", + "intel-openmp 2019.4 243", + "ipykernel 5.1.2 py36h39e3cac_0", + "ipython 7.8.0 py36h39e3cac_0", + "ipython_genutils 0.2.0 py36_0", + "ipywidgets 7.5.1 py_0", + "isort 4.3.21 py36_0", + "itsdangerous 1.1.0 py36_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.15.1 py36_0", + "jeepney 0.4.1 py_0", + "jinja2 2.10.3 py_0", + "joblib 0.13.2 py36_0", + "jpeg 9b h024ee3a_2", + "json5 0.8.5 py_0", + "jsonschema 3.0.2 py36_0", + "jupyter 1.0.0 py36_7", + "jupyter_client 5.3.3 py36_1", + "jupyter_console 6.0.0 py36_0", + "jupyter_core 4.5.0 py_0", + "jupyterlab 1.1.4 pyhf63ae98_0", + "jupyterlab_server 1.0.6 py_0", + "keyring 18.0.0 py36_0", + "kiwisolver 1.1.0 py36he6710b0_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.4.2 py36h7b6447c_0", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.65.3 h20c2e04_0", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.2 h1ba5d50_0", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.0.10 h2733197_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 hea5a465_1", + "libxslt 1.1.33 h7d1a2b0_0", + "llvmlite 0.29.0 py36hd408876_0", + "locket 0.2.0 py36_1", + "lxml 4.4.1 py36hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py36h7b6447c_0", + "matplotlib 3.1.1 py36h5429711_0", + "mccabe 0.6.1 py36_1", + "mistune 0.8.4 py36h7b6447c_0", + "mkl 2019.4 243", + "mkl-service 2.3.0 py36he904b0f_0", + "mkl_fft 1.0.14 py36ha843d7b_0", + "mkl_random 1.1.0 py36hd6b4f25_0", + "mock 3.0.5 py36_0", + "more-itertools 7.2.0 py36_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py36_0", + "msgpack-python 0.6.1 py36hfd86e86_1", + "multipledispatch 0.6.0 py36_0", + "nbconvert 5.6.0 py36_1", + "nbformat 4.4.0 py36_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.3 py_0", + "nltk 3.4.5 py36_0", + "nose 1.3.7 py36_2", + "notebook 6.0.1 py36_0", + "numba 0.45.1 py36h962f231_0", + "numexpr 2.7.0 py36h9e4a6bb_0", + "numpy 1.17.2 py36haad9e8e_0", + "numpy-base 1.17.2 py36hde5b4d6_0", + "numpydoc 0.9.1 py_0", + "olefile 0.46 py36_0", + "openpyxl 3.0.0 py_0", + "openssl 1.1.1d h7b6447c_2", + "packaging 19.2 py_0", + "pandas 0.25.1 py36he6710b0_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py36_1", + "pango 1.42.4 h049681c_0", + "parso 0.5.1 py_0", + "partd 1.0.0 py_0", + "patchelf 0.9 he6710b0_3", + "path.py 12.0.1 py_0", + "pathlib2 2.3.5 py36_0", + "patsy 0.5.1 py36_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py36_0", + "pexpect 4.7.0 py36_0", + "pickleshare 0.7.5 py36_0", + "pillow 6.2.0 py36h34e0f95_0", + "pip 19.2.3 py36_0", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py36_0", + "pluggy 0.13.0 py36_0", + "ply 3.11 py36_0", + "prometheus_client 0.7.1 py_0", + "prompt_toolkit 2.0.10 py_0", + "psutil 5.6.3 py36h7b6447c_0", + "ptyprocess 0.6.0 py36_0", + "py 1.8.0 py36_0", + "py-lief 0.9.0 py36h7725739_2", + "pycodestyle 2.5.0 py36_0", + "pycosat 0.6.3 py36h14c3975_0", + "pycparser 2.19 py36_0", + "pycrypto 2.6.1 py36h14c3975_9", + "pycurl 7.43.0.3 py36h1ba5d50_0", + "pyflakes 2.1.1 py36_0", + "pygments 2.4.2 py_0", + "pylint 2.4.2 py36_0", + "pyodbc 4.0.27 py36he6710b0_0", + "pyopenssl 19.0.0 py36_0", + "pyparsing 2.4.2 py_0", + "pyqt 5.9.2 py36h05f1152_2", + "pyrsistent 0.15.4 py36h7b6447c_0", + "pysocks 1.7.1 py36_0", + "pytables 3.5.2 py36h71ec239_1", + "pytest 5.2.1 py36_0", + "pytest-arraydiff 0.3 py36h39e3cac_0", + "pytest-astropy 0.5.0 py36_0", + "pytest-doctestplus 0.4.0 py_0", + "pytest-openfiles 0.4.0 py_0", + "pytest-remotedata 0.3.2 py36_0", + "python 3.6.9 h265db76_0", + "python-dateutil 2.8.0 py36_0", + "python-libarchive-c 2.8 py36_13", + "pytz 2019.3 py_0", + "pywavelets 1.0.3 py36hdd07704_1", + "pyyaml 5.1.2 py36h7b6447c_0", + "pyzmq 18.1.0 py36he6710b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.6.0 py_0", + "qtconsole 4.5.5 py_0", + "qtpy 1.9.0 py_0", + "readline 7.0 h7b6447c_5", + "requests 2.22.0 py36_0", + "ripgrep 0.10.0 hc07d326_0", + "rope 0.14.0 py_0", + "ruamel_yaml 0.15.46 py36h14c3975_0", + "scikit-image 0.15.0 py36he6710b0_0", + "scikit-learn 0.21.3 py36hd81dba3_0", + "scipy 1.3.1 py36h7c811a0_0", + "seaborn 0.9.0 py36_0", + "secretstorage 3.1.1 py36_0", + "send2trash 1.5.0 py36_0", + "setuptools 41.4.0 py36_0", + "simplegeneric 0.8.1 py36_2", + "singledispatch 3.4.0.3 py36_0", + "sip 4.19.8 py36hf484d3e_0", + "six 1.12.0 py36_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.1.2 py36_0", + "sortedcontainers 2.1.0 py36_0", + "soupsieve 1.9.3 py36_0", + "sphinx 2.2.0 py_0", + "sphinxcontrib 1.0 py36_1", + "sphinxcontrib-applehelp 1.0.1 py_0", + "sphinxcontrib-devhelp 1.0.1 py_0", + "sphinxcontrib-htmlhelp 1.0.2 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.2 py_0", + "sphinxcontrib-serializinghtml 1.1.3 py_0", + "sphinxcontrib-websupport 1.1.2 py_0", + "spyder 3.3.6 py36_0", + "spyder-kernels 0.5.2 py36_0", + "sqlalchemy 1.3.9 py36h7b6447c_0", + "sqlite 3.30.0 h7b6447c_0", + "statsmodels 0.10.1 py36hdd07704_0", + "sympy 1.4 py36_0", + "tbb 2019.4 hfd86e86_0", + "tblib 1.4.0 py_0", + "terminado 0.8.2 py36_0", + "testpath 0.4.2 py36_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.10.0 py_0", + "tornado 6.0.3 py36h7b6447c_0", + "tqdm 4.36.1 py_0", + "traitlets 4.3.3 py36_0", + "typed-ast 1.4.0 py36h7b6447c_0", + "unicodecsv 0.14.1 py36_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.2 py36_0", + "wcwidth 0.1.7 py36_0", + "webencodings 0.5.1 py36_1", + "werkzeug 0.16.0 py_0", + "wheel 0.33.6 py36_0", + "widgetsnbextension 3.5.1 py36_0", + "wrapt 1.11.2 py36h7b6447c_0", + "wurlitzer 1.0.3 py36_0", + "xlrd 1.2.0 py36_0", + "xlsxwriter 1.2.1 py_0", + "xlwt 1.3.0 py36_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.3.1 he6710b0_3", + "zict 1.0.0 py_0", + "zipp 0.6.0 py_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "3ef6f2bf820d28d7b9646e5c2010c18d", + "name": "anaconda", + "namespace": "python", + "sha256": "06362d5921bb11cef6f3cdfe68b52f415c2e5603f3225784051fab0dff665ce6", + "size": 11409, + "subdir": "linux-64", + "timestamp": 1570484044367, + "version": "2019.10" + }, + "anaconda-2019.10-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.7.2 py37_0", + "anaconda-project 0.8.3 py_0", + "asn1crypto 1.0.1 py37_0", + "astroid 2.3.1 py37_0", + "astropy 3.2.2 py37h7b6447c_0", + "atomicwrites 1.3.0 py37_1", + "attrs 19.2.0 py_0", + "babel 2.7.0 py_0", + "backcall 0.1.0 py37_0", + "backports 1.0 py_2", + "backports.os 0.1.1 py37_0", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "beautifulsoup4 4.8.0 py37_0", + "bitarray 1.0.1 py37h7b6447c_0", + "bkcharts 0.2 py37_0", + "blas 1.0 mkl", + "bleach 3.1.0 py37_0", + "blosc 1.16.3 hd408876_0", + "bokeh 1.3.4 py37_0", + "boto 2.49.0 py37_0", + "bottleneck 1.2.1 py37h035aef0_1", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2019.8.28 0", + "cairo 1.14.12 h8948797_3", + "certifi 2019.9.11 py37_0", + "cffi 1.12.3 py37h2e261b9_0", + "chardet 3.0.4 py37_1003", + "click 7.0 py37_0", + "cloudpickle 1.2.2 py_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.1 py37_0", + "contextlib2 0.6.0 py_0", + "cryptography 2.7 py37h1ba5d50_0", + "curl 7.65.3 hbc83047_0", + "cycler 0.10.0 py37_0", + "cython 0.29.13 py37he6710b0_0", + "cytoolz 0.10.0 py37h7b6447c_0", + "dask 2.5.2 py_0", + "dask-core 2.5.2 py_0", + "dbus 1.13.6 h746ee38_0", + "decorator 4.4.0 py37_1", + "defusedxml 0.6.0 py_0", + "distributed 2.5.2 py_0", + "docutils 0.15.2 py37_0", + "entrypoints 0.3 py37_0", + "et_xmlfile 1.0.1 py37_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.1.0 py37h7b6447c_0", + "filelock 3.0.12 py_0", + "flask 1.1.1 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "fsspec 0.5.2 py_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py37h7b6447c_0", + "glib 2.56.2 hd408876_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py37h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.9.0 py37h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.0.1 py37_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py37_0", + "imageio 2.6.0 py37_0", + "imagesize 1.1.0 py37_0", + "importlib_metadata 0.23 py37_0", + "intel-openmp 2019.4 243", + "ipykernel 5.1.2 py37h39e3cac_0", + "ipython 7.8.0 py37h39e3cac_0", + "ipython_genutils 0.2.0 py37_0", + "ipywidgets 7.5.1 py_0", + "isort 4.3.21 py37_0", + "itsdangerous 1.1.0 py37_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.15.1 py37_0", + "jeepney 0.4.1 py_0", + "jinja2 2.10.3 py_0", + "joblib 0.13.2 py37_0", + "jpeg 9b h024ee3a_2", + "json5 0.8.5 py_0", + "jsonschema 3.0.2 py37_0", + "jupyter 1.0.0 py37_7", + "jupyter_client 5.3.3 py37_1", + "jupyter_console 6.0.0 py37_0", + "jupyter_core 4.5.0 py_0", + "jupyterlab 1.1.4 pyhf63ae98_0", + "jupyterlab_server 1.0.6 py_0", + "keyring 18.0.0 py37_0", + "kiwisolver 1.1.0 py37he6710b0_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.4.2 py37h7b6447c_0", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.65.3 h20c2e04_0", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.2 h1ba5d50_0", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.0.10 h2733197_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 hea5a465_1", + "libxslt 1.1.33 h7d1a2b0_0", + "llvmlite 0.29.0 py37hd408876_0", + "locket 0.2.0 py37_1", + "lxml 4.4.1 py37hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py37h7b6447c_0", + "matplotlib 3.1.1 py37h5429711_0", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h7b6447c_0", + "mkl 2019.4 243", + "mkl-service 2.3.0 py37he904b0f_0", + "mkl_fft 1.0.14 py37ha843d7b_0", + "mkl_random 1.1.0 py37hd6b4f25_0", + "mock 3.0.5 py37_0", + "more-itertools 7.2.0 py37_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py37_0", + "msgpack-python 0.6.1 py37hfd86e86_1", + "multipledispatch 0.6.0 py37_0", + "nbconvert 5.6.0 py37_1", + "nbformat 4.4.0 py37_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.3 py_0", + "nltk 3.4.5 py37_0", + "nose 1.3.7 py37_2", + "notebook 6.0.1 py37_0", + "numba 0.45.1 py37h962f231_0", + "numexpr 2.7.0 py37h9e4a6bb_0", + "numpy 1.17.2 py37haad9e8e_0", + "numpy-base 1.17.2 py37hde5b4d6_0", + "numpydoc 0.9.1 py_0", + "olefile 0.46 py37_0", + "openpyxl 3.0.0 py_0", + "openssl 1.1.1d h7b6447c_2", + "packaging 19.2 py_0", + "pandas 0.25.1 py37he6710b0_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py37_1", + "pango 1.42.4 h049681c_0", + "parso 0.5.1 py_0", + "partd 1.0.0 py_0", + "patchelf 0.9 he6710b0_3", + "path.py 12.0.1 py_0", + "pathlib2 2.3.5 py37_0", + "patsy 0.5.1 py37_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py37_0", + "pexpect 4.7.0 py37_0", + "pickleshare 0.7.5 py37_0", + "pillow 6.2.0 py37h34e0f95_0", + "pip 19.2.3 py37_0", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py37_0", + "pluggy 0.13.0 py37_0", + "ply 3.11 py37_0", + "prometheus_client 0.7.1 py_0", + "prompt_toolkit 2.0.10 py_0", + "psutil 5.6.3 py37h7b6447c_0", + "ptyprocess 0.6.0 py37_0", + "py 1.8.0 py37_0", + "py-lief 0.9.0 py37h7725739_2", + "pycodestyle 2.5.0 py37_0", + "pycosat 0.6.3 py37h14c3975_0", + "pycparser 2.19 py37_0", + "pycrypto 2.6.1 py37h14c3975_9", + "pycurl 7.43.0.3 py37h1ba5d50_0", + "pyflakes 2.1.1 py37_0", + "pygments 2.4.2 py_0", + "pylint 2.4.2 py37_0", + "pyodbc 4.0.27 py37he6710b0_0", + "pyopenssl 19.0.0 py37_0", + "pyparsing 2.4.2 py_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.15.4 py37h7b6447c_0", + "pysocks 1.7.1 py37_0", + "pytables 3.5.2 py37h71ec239_1", + "pytest 5.2.1 py37_0", + "pytest-arraydiff 0.3 py37h39e3cac_0", + "pytest-astropy 0.5.0 py37_0", + "pytest-doctestplus 0.4.0 py_0", + "pytest-openfiles 0.4.0 py_0", + "pytest-remotedata 0.3.2 py37_0", + "python 3.7.4 h265db76_1", + "python-dateutil 2.8.0 py37_0", + "python-libarchive-c 2.8 py37_13", + "pytz 2019.3 py_0", + "pywavelets 1.0.3 py37hdd07704_1", + "pyyaml 5.1.2 py37h7b6447c_0", + "pyzmq 18.1.0 py37he6710b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.6.0 py_0", + "qtconsole 4.5.5 py_0", + "qtpy 1.9.0 py_0", + "readline 7.0 h7b6447c_5", + "requests 2.22.0 py37_0", + "ripgrep 0.10.0 hc07d326_0", + "rope 0.14.0 py_0", + "ruamel_yaml 0.15.46 py37h14c3975_0", + "scikit-image 0.15.0 py37he6710b0_0", + "scikit-learn 0.21.3 py37hd81dba3_0", + "scipy 1.3.1 py37h7c811a0_0", + "seaborn 0.9.0 py37_0", + "secretstorage 3.1.1 py37_0", + "send2trash 1.5.0 py37_0", + "setuptools 41.4.0 py37_0", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.4.0.3 py37_0", + "sip 4.19.8 py37hf484d3e_0", + "six 1.12.0 py37_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.1.2 py37_0", + "sortedcontainers 2.1.0 py37_0", + "soupsieve 1.9.3 py37_0", + "sphinx 2.2.0 py_0", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-applehelp 1.0.1 py_0", + "sphinxcontrib-devhelp 1.0.1 py_0", + "sphinxcontrib-htmlhelp 1.0.2 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.2 py_0", + "sphinxcontrib-serializinghtml 1.1.3 py_0", + "sphinxcontrib-websupport 1.1.2 py_0", + "spyder 3.3.6 py37_0", + "spyder-kernels 0.5.2 py37_0", + "sqlalchemy 1.3.9 py37h7b6447c_0", + "sqlite 3.30.0 h7b6447c_0", + "statsmodels 0.10.1 py37hdd07704_0", + "sympy 1.4 py37_0", + "tbb 2019.4 hfd86e86_0", + "tblib 1.4.0 py_0", + "terminado 0.8.2 py37_0", + "testpath 0.4.2 py37_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.10.0 py_0", + "tornado 6.0.3 py37h7b6447c_0", + "tqdm 4.36.1 py_0", + "traitlets 4.3.3 py37_0", + "unicodecsv 0.14.1 py37_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.2 py37_0", + "wcwidth 0.1.7 py37_0", + "webencodings 0.5.1 py37_1", + "werkzeug 0.16.0 py_0", + "wheel 0.33.6 py37_0", + "widgetsnbextension 3.5.1 py37_0", + "wrapt 1.11.2 py37h7b6447c_0", + "wurlitzer 1.0.3 py37_0", + "xlrd 1.2.0 py37_0", + "xlsxwriter 1.2.1 py_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.3.1 he6710b0_3", + "zict 1.0.0 py_0", + "zipp 0.6.0 py_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "89d761024380358d4a28486263ea2460", + "name": "anaconda", + "namespace": "python", + "sha256": "158159df64ebbc81e2baf44cea74fec30dbe483da3f68ba3d9cb5edd588e4674", + "size": 11339, + "subdir": "linux-64", + "timestamp": 1570553776012, + "version": "2019.10" + }, + "anaconda-2020.02-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py36_0", + "anaconda-client 1.7.2 py36_0", + "anaconda-project 0.8.4 py_0", + "argh 0.26.2 py36_0", + "asn1crypto 1.3.0 py36_0", + "astroid 2.3.3 py36_0", + "astropy 4.0 py36h7b6447c_0", + "atomicwrites 1.3.0 py36_1", + "attrs 19.3.0 py_0", + "autopep8 1.4.4 py_0", + "babel 2.8.0 py_0", + "backcall 0.1.0 py36_0", + "backports 1.0 py_2", + "backports.shutil_get_terminal_size 1.0.0 py36_2", + "beautifulsoup4 4.8.2 py36_0", + "bitarray 1.2.1 py36h7b6447c_0", + "bkcharts 0.2 py36_0", + "blas 1.0 mkl", + "bleach 3.1.0 py36_0", + "blosc 1.16.3 hd408876_0", + "bokeh 1.4.0 py36_0", + "boto 2.49.0 py36_0", + "bottleneck 1.3.2 py36heb32a55_0", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2020.1.1 0", + "cairo 1.14.12 h8948797_3", + "certifi 2019.11.28 py36_0", + "cffi 1.14.0 py36h2e261b9_0", + "chardet 3.0.4 py36_1003", + "click 7.0 py36_0", + "cloudpickle 1.3.0 py_0", + "clyent 1.2.2 py36_1", + "colorama 0.4.3 py_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 2.8 py36h1ba5d50_0", + "curl 7.68.0 hbc83047_0", + "cycler 0.10.0 py36_0", + "cython 0.29.15 py36he6710b0_0", + "cytoolz 0.10.1 py36h7b6447c_0", + "dask 2.11.0 py_0", + "dask-core 2.11.0 py_0", + "dbus 1.13.12 h746ee38_0", + "decorator 4.4.1 py_0", + "defusedxml 0.6.0 py_0", + "diff-match-patch 20181111 py_0", + "distributed 2.11.0 py36_0", + "docutils 0.16 py36_0", + "entrypoints 0.3 py36_0", + "et_xmlfile 1.0.1 py36_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.1.0 py36h7b6447c_0", + "filelock 3.0.12 py_0", + "flake8 3.7.9 py36_0", + "flask 1.1.1 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "fsspec 0.6.2 py_0", + "future 0.18.2 py36_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py36h7b6447c_0", + "glib 2.63.1 h5a9c865_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py36h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py36h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.10.0 py36h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.0.1 py36_0", + "hypothesis 5.5.4 py_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py36_0", + "imageio 2.6.1 py36_0", + "imagesize 1.2.0 py_0", + "importlib_metadata 1.5.0 py36_0", + "intel-openmp 2020.0 166", + "intervaltree 3.0.2 py_0", + "ipykernel 5.1.4 py36h39e3cac_0", + "ipython 7.12.0 py36h5ca1d4c_0", + "ipython_genutils 0.2.0 py36_0", + "ipywidgets 7.5.1 py_0", + "isort 4.3.21 py36_0", + "itsdangerous 1.1.0 py36_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.14.1 py36_0", + "jeepney 0.4.2 py_0", + "jinja2 2.11.1 py_0", + "joblib 0.14.1 py_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.1 py_0", + "jsonschema 3.2.0 py36_0", + "jupyter 1.0.0 py36_7", + "jupyter_client 5.3.4 py36_0", + "jupyter_console 6.1.0 py_0", + "jupyter_core 4.6.1 py36_0", + "jupyterlab 1.2.6 pyhf63ae98_0", + "jupyterlab_server 1.0.6 py_0", + "keyring 21.1.0 py36_0", + "kiwisolver 1.1.0 py36he6710b0_0", + "krb5 1.17.1 h173b8e3_0", + "lazy-object-proxy 1.4.3 py36h7b6447c_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.68.0 h20c2e04_0", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libspatialindex 1.9.3 he6710b0_0", + "libssh2 1.8.2 h1ba5d50_0", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_0", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 hea5a465_1", + "libxslt 1.1.33 h7d1a2b0_0", + "llvmlite 0.31.0 py36hd408876_0", + "locket 0.2.0 py36_1", + "lxml 4.5.0 py36hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py36h7b6447c_0", + "matplotlib 3.1.3 py36_0", + "matplotlib-base 3.1.3 py36hef1b27d_0", + "mccabe 0.6.1 py36_1", + "mistune 0.8.4 py36h7b6447c_0", + "mkl 2020.0 166", + "mkl-service 2.3.0 py36he904b0f_0", + "mkl_fft 1.0.15 py36ha843d7b_0", + "mkl_random 1.1.0 py36hd6b4f25_0", + "mock 4.0.1 py_0", + "more-itertools 8.2.0 py_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py36_0", + "msgpack-python 0.6.1 py36hfd86e86_1", + "multipledispatch 0.6.0 py36_0", + "nbconvert 5.6.1 py36_0", + "nbformat 5.0.4 py_0", + "ncurses 6.2 he6710b0_0", + "networkx 2.4 py_0", + "nltk 3.4.5 py36_0", + "nose 1.3.7 py36_2", + "notebook 6.0.3 py36_0", + "numba 0.48.0 py36h0573a6f_0", + "numexpr 2.7.1 py36h423224d_0", + "numpy 1.18.1 py36h4f9e942_0", + "numpy-base 1.18.1 py36hde5b4d6_1", + "numpydoc 0.9.2 py_0", + "olefile 0.46 py36_0", + "openpyxl 3.0.3 py_0", + "openssl 1.1.1d h7b6447c_4", + "packaging 20.1 py_0", + "pandas 1.0.1 py36h0573a6f_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py36_1", + "pango 1.42.4 h049681c_0", + "parso 0.5.2 py_0", + "partd 1.1.0 py_0", + "patchelf 0.10 he6710b0_0", + "path 13.1.0 py36_0", + "path.py 12.4.0 0", + "pathlib2 2.3.5 py36_0", + "pathtools 0.1.2 py_1", + "patsy 0.5.1 py36_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py36_0", + "pexpect 4.8.0 py36_0", + "pickleshare 0.7.5 py36_0", + "pillow 7.0.0 py36hb39fc2d_0", + "pip 20.0.2 py36_1", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py36_0", + "pluggy 0.13.1 py36_0", + "ply 3.11 py36_0", + "prometheus_client 0.7.1 py_0", + "prompt_toolkit 3.0.3 py_0", + "psutil 5.6.7 py36h7b6447c_0", + "ptyprocess 0.6.0 py36_0", + "py 1.8.1 py_0", + "py-lief 0.9.0 py36h7725739_2", + "pycodestyle 2.5.0 py36_0", + "pycosat 0.6.3 py36h7b6447c_0", + "pycparser 2.19 py36_0", + "pycrypto 2.6.1 py36h14c3975_9", + "pycurl 7.43.0.5 py36h1ba5d50_0", + "pydocstyle 4.0.1 py_0", + "pyflakes 2.1.1 py36_0", + "pygments 2.5.2 py_0", + "pylint 2.4.4 py36_0", + "pyodbc 4.0.30 py36he6710b0_0", + "pyopenssl 19.1.0 py36_0", + "pyparsing 2.4.6 py_0", + "pyqt 5.9.2 py36h05f1152_2", + "pyrsistent 0.15.7 py36h7b6447c_0", + "pysocks 1.7.1 py36_0", + "pytables 3.6.1 py36h71ec239_0", + "pytest 5.3.5 py36_0", + "pytest-arraydiff 0.3 py36h39e3cac_0", + "pytest-astropy 0.8.0 py_0", + "pytest-astropy-header 0.1.2 py_0", + "pytest-doctestplus 0.5.0 py_0", + "pytest-openfiles 0.4.0 py_0", + "pytest-remotedata 0.3.2 py36_0", + "python 3.6.10 h0371630_0", + "python-dateutil 2.8.1 py_0", + "python-jsonrpc-server 0.3.4 py_0", + "python-language-server 0.31.7 py36_0", + "python-libarchive-c 2.8 py36_13", + "pytz 2019.3 py_0", + "pywavelets 1.1.1 py36h7b6447c_0", + "pyxdg 0.26 py_0", + "pyyaml 5.3 py36h7b6447c_0", + "pyzmq 18.1.1 py36he6710b0_0", + "qdarkstyle 2.8 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.6.1 py_0", + "qtconsole 4.6.0 py_1", + "qtpy 1.9.0 py_0", + "readline 7.0 h7b6447c_5", + "requests 2.22.0 py36_1", + "ripgrep 11.0.2 he32d670_0", + "rope 0.16.0 py_0", + "rtree 0.9.3 py36_0", + "ruamel_yaml 0.15.87 py36h7b6447c_0", + "scikit-image 0.16.2 py36h0573a6f_0", + "scikit-learn 0.22.1 py36hd81dba3_0", + "scipy 1.4.1 py36h0b6359f_0", + "seaborn 0.10.0 py_0", + "secretstorage 3.1.2 py36_0", + "send2trash 1.5.0 py36_0", + "setuptools 45.2.0 py36_0", + "simplegeneric 0.8.1 py36_2", + "singledispatch 3.4.0.3 py36_0", + "sip 4.19.8 py36hf484d3e_0", + "six 1.14.0 py36_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.1.2 py36_0", + "sortedcontainers 2.1.0 py36_0", + "soupsieve 1.9.5 py36_0", + "sphinx 2.4.0 py_0", + "sphinxcontrib 1.0 py36_1", + "sphinxcontrib-applehelp 1.0.1 py_0", + "sphinxcontrib-devhelp 1.0.1 py_0", + "sphinxcontrib-htmlhelp 1.0.2 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.2 py_0", + "sphinxcontrib-serializinghtml 1.1.3 py_0", + "sphinxcontrib-websupport 1.2.0 py_0", + "spyder 4.0.1 py36_0", + "spyder-kernels 1.8.1 py36_0", + "sqlalchemy 1.3.13 py36h7b6447c_0", + "sqlite 3.31.1 h7b6447c_0", + "statsmodels 0.11.0 py36h7b6447c_0", + "sympy 1.5.1 py36_0", + "tbb 2020.0 hfd86e86_0", + "tblib 1.6.0 py_0", + "terminado 0.8.3 py36_0", + "testpath 0.4.4 py_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.10.0 py_0", + "tornado 6.0.3 py36h7b6447c_3", + "tqdm 4.42.1 py_0", + "traitlets 4.3.3 py36_0", + "typed-ast 1.4.1 py36h7b6447c_0", + "ujson 1.35 py36h14c3975_0", + "unicodecsv 0.14.1 py36_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.25.8 py36_0", + "watchdog 0.10.2 py36_0", + "wcwidth 0.1.8 py_0", + "webencodings 0.5.1 py36_1", + "werkzeug 1.0.0 py_0", + "wheel 0.34.2 py36_0", + "widgetsnbextension 3.5.1 py36_0", + "wrapt 1.11.2 py36h7b6447c_0", + "wurlitzer 2.0.0 py36_0", + "xlrd 1.2.0 py36_0", + "xlsxwriter 1.2.7 py_0", + "xlwt 1.3.0 py36_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "yapf 0.28.0 py_0", + "zeromq 4.3.1 he6710b0_3", + "zict 1.0.0 py_0", + "zipp 2.2.0 py_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "6d444df7366ccc13d9cf83d50c8a497a", + "name": "anaconda", + "namespace": "python", + "sha256": "3574ddeed9652a1b4eb6b04f9c3b736c67569119abac9df830cc0a1716f6ce86", + "size": 14004, + "subdir": "linux-64", + "timestamp": 1583251729803, + "version": "2020.02" + }, + "anaconda-2020.02-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.7.2 py37_0", + "anaconda-project 0.8.4 py_0", + "argh 0.26.2 py37_0", + "asn1crypto 1.3.0 py37_0", + "astroid 2.3.3 py37_0", + "astropy 4.0 py37h7b6447c_0", + "atomicwrites 1.3.0 py37_1", + "attrs 19.3.0 py_0", + "autopep8 1.4.4 py_0", + "babel 2.8.0 py_0", + "backcall 0.1.0 py37_0", + "backports 1.0 py_2", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "beautifulsoup4 4.8.2 py37_0", + "bitarray 1.2.1 py37h7b6447c_0", + "bkcharts 0.2 py37_0", + "blas 1.0 mkl", + "bleach 3.1.0 py37_0", + "blosc 1.16.3 hd408876_0", + "bokeh 1.4.0 py37_0", + "boto 2.49.0 py37_0", + "bottleneck 1.3.2 py37heb32a55_0", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2020.1.1 0", + "cairo 1.14.12 h8948797_3", + "certifi 2019.11.28 py37_0", + "cffi 1.14.0 py37h2e261b9_0", + "chardet 3.0.4 py37_1003", + "click 7.0 py37_0", + "cloudpickle 1.3.0 py_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.3 py_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 2.8 py37h1ba5d50_0", + "curl 7.68.0 hbc83047_0", + "cycler 0.10.0 py37_0", + "cython 0.29.15 py37he6710b0_0", + "cytoolz 0.10.1 py37h7b6447c_0", + "dask 2.11.0 py_0", + "dask-core 2.11.0 py_0", + "dbus 1.13.12 h746ee38_0", + "decorator 4.4.1 py_0", + "defusedxml 0.6.0 py_0", + "diff-match-patch 20181111 py_0", + "distributed 2.11.0 py37_0", + "docutils 0.16 py37_0", + "entrypoints 0.3 py37_0", + "et_xmlfile 1.0.1 py37_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.1.0 py37h7b6447c_0", + "filelock 3.0.12 py_0", + "flake8 3.7.9 py37_0", + "flask 1.1.1 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "fsspec 0.6.2 py_0", + "future 0.18.2 py37_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py37h7b6447c_0", + "glib 2.63.1 h5a9c865_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py37h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.10.0 py37h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.0.1 py37_0", + "hypothesis 5.5.4 py_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py37_0", + "imageio 2.6.1 py37_0", + "imagesize 1.2.0 py_0", + "importlib_metadata 1.5.0 py37_0", + "intel-openmp 2020.0 166", + "intervaltree 3.0.2 py_0", + "ipykernel 5.1.4 py37h39e3cac_0", + "ipython 7.12.0 py37h5ca1d4c_0", + "ipython_genutils 0.2.0 py37_0", + "ipywidgets 7.5.1 py_0", + "isort 4.3.21 py37_0", + "itsdangerous 1.1.0 py37_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.14.1 py37_0", + "jeepney 0.4.2 py_0", + "jinja2 2.11.1 py_0", + "joblib 0.14.1 py_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.1 py_0", + "jsonschema 3.2.0 py37_0", + "jupyter 1.0.0 py37_7", + "jupyter_client 5.3.4 py37_0", + "jupyter_console 6.1.0 py_0", + "jupyter_core 4.6.1 py37_0", + "jupyterlab 1.2.6 pyhf63ae98_0", + "jupyterlab_server 1.0.6 py_0", + "keyring 21.1.0 py37_0", + "kiwisolver 1.1.0 py37he6710b0_0", + "krb5 1.17.1 h173b8e3_0", + "lazy-object-proxy 1.4.3 py37h7b6447c_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.68.0 h20c2e04_0", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libspatialindex 1.9.3 he6710b0_0", + "libssh2 1.8.2 h1ba5d50_0", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_0", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 hea5a465_1", + "libxslt 1.1.33 h7d1a2b0_0", + "llvmlite 0.31.0 py37hd408876_0", + "locket 0.2.0 py37_1", + "lxml 4.5.0 py37hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py37h7b6447c_0", + "matplotlib 3.1.3 py37_0", + "matplotlib-base 3.1.3 py37hef1b27d_0", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h7b6447c_0", + "mkl 2020.0 166", + "mkl-service 2.3.0 py37he904b0f_0", + "mkl_fft 1.0.15 py37ha843d7b_0", + "mkl_random 1.1.0 py37hd6b4f25_0", + "mock 4.0.1 py_0", + "more-itertools 8.2.0 py_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py37_0", + "msgpack-python 0.6.1 py37hfd86e86_1", + "multipledispatch 0.6.0 py37_0", + "nbconvert 5.6.1 py37_0", + "nbformat 5.0.4 py_0", + "ncurses 6.2 he6710b0_0", + "networkx 2.4 py_0", + "nltk 3.4.5 py37_0", + "nose 1.3.7 py37_2", + "notebook 6.0.3 py37_0", + "numba 0.48.0 py37h0573a6f_0", + "numexpr 2.7.1 py37h423224d_0", + "numpy 1.18.1 py37h4f9e942_0", + "numpy-base 1.18.1 py37hde5b4d6_1", + "numpydoc 0.9.2 py_0", + "olefile 0.46 py37_0", + "openpyxl 3.0.3 py_0", + "openssl 1.1.1d h7b6447c_4", + "packaging 20.1 py_0", + "pandas 1.0.1 py37h0573a6f_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py37_1", + "pango 1.42.4 h049681c_0", + "parso 0.5.2 py_0", + "partd 1.1.0 py_0", + "patchelf 0.10 he6710b0_0", + "path 13.1.0 py37_0", + "path.py 12.4.0 0", + "pathlib2 2.3.5 py37_0", + "pathtools 0.1.2 py_1", + "patsy 0.5.1 py37_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py37_0", + "pexpect 4.8.0 py37_0", + "pickleshare 0.7.5 py37_0", + "pillow 7.0.0 py37hb39fc2d_0", + "pip 20.0.2 py37_1", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py37_0", + "pluggy 0.13.1 py37_0", + "ply 3.11 py37_0", + "prometheus_client 0.7.1 py_0", + "prompt_toolkit 3.0.3 py_0", + "psutil 5.6.7 py37h7b6447c_0", + "ptyprocess 0.6.0 py37_0", + "py 1.8.1 py_0", + "py-lief 0.9.0 py37h7725739_2", + "pycodestyle 2.5.0 py37_0", + "pycosat 0.6.3 py37h7b6447c_0", + "pycparser 2.19 py37_0", + "pycrypto 2.6.1 py37h14c3975_9", + "pycurl 7.43.0.5 py37h1ba5d50_0", + "pydocstyle 4.0.1 py_0", + "pyflakes 2.1.1 py37_0", + "pygments 2.5.2 py_0", + "pylint 2.4.4 py37_0", + "pyodbc 4.0.30 py37he6710b0_0", + "pyopenssl 19.1.0 py37_0", + "pyparsing 2.4.6 py_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.15.7 py37h7b6447c_0", + "pysocks 1.7.1 py37_0", + "pytables 3.6.1 py37h71ec239_0", + "pytest 5.3.5 py37_0", + "pytest-arraydiff 0.3 py37h39e3cac_0", + "pytest-astropy 0.8.0 py_0", + "pytest-astropy-header 0.1.2 py_0", + "pytest-doctestplus 0.5.0 py_0", + "pytest-openfiles 0.4.0 py_0", + "pytest-remotedata 0.3.2 py37_0", + "python 3.7.6 h0371630_2", + "python-dateutil 2.8.1 py_0", + "python-jsonrpc-server 0.3.4 py_0", + "python-language-server 0.31.7 py37_0", + "python-libarchive-c 2.8 py37_13", + "pytz 2019.3 py_0", + "pywavelets 1.1.1 py37h7b6447c_0", + "pyxdg 0.26 py_0", + "pyyaml 5.3 py37h7b6447c_0", + "pyzmq 18.1.1 py37he6710b0_0", + "qdarkstyle 2.8 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.6.1 py_0", + "qtconsole 4.6.0 py_1", + "qtpy 1.9.0 py_0", + "readline 7.0 h7b6447c_5", + "requests 2.22.0 py37_1", + "ripgrep 11.0.2 he32d670_0", + "rope 0.16.0 py_0", + "rtree 0.9.3 py37_0", + "ruamel_yaml 0.15.87 py37h7b6447c_0", + "scikit-image 0.16.2 py37h0573a6f_0", + "scikit-learn 0.22.1 py37hd81dba3_0", + "scipy 1.4.1 py37h0b6359f_0", + "seaborn 0.10.0 py_0", + "secretstorage 3.1.2 py37_0", + "send2trash 1.5.0 py37_0", + "setuptools 45.2.0 py37_0", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.4.0.3 py37_0", + "sip 4.19.8 py37hf484d3e_0", + "six 1.14.0 py37_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.1.2 py37_0", + "sortedcontainers 2.1.0 py37_0", + "soupsieve 1.9.5 py37_0", + "sphinx 2.4.0 py_0", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-applehelp 1.0.1 py_0", + "sphinxcontrib-devhelp 1.0.1 py_0", + "sphinxcontrib-htmlhelp 1.0.2 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.2 py_0", + "sphinxcontrib-serializinghtml 1.1.3 py_0", + "sphinxcontrib-websupport 1.2.0 py_0", + "spyder 4.0.1 py37_0", + "spyder-kernels 1.8.1 py37_0", + "sqlalchemy 1.3.13 py37h7b6447c_0", + "sqlite 3.31.1 h7b6447c_0", + "statsmodels 0.11.0 py37h7b6447c_0", + "sympy 1.5.1 py37_0", + "tbb 2020.0 hfd86e86_0", + "tblib 1.6.0 py_0", + "terminado 0.8.3 py37_0", + "testpath 0.4.4 py_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.10.0 py_0", + "tornado 6.0.3 py37h7b6447c_3", + "tqdm 4.42.1 py_0", + "traitlets 4.3.3 py37_0", + "ujson 1.35 py37h14c3975_0", + "unicodecsv 0.14.1 py37_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.25.8 py37_0", + "watchdog 0.10.2 py37_0", + "wcwidth 0.1.8 py_0", + "webencodings 0.5.1 py37_1", + "werkzeug 1.0.0 py_0", + "wheel 0.34.2 py37_0", + "widgetsnbextension 3.5.1 py37_0", + "wrapt 1.11.2 py37h7b6447c_0", + "wurlitzer 2.0.0 py37_0", + "xlrd 1.2.0 py37_0", + "xlsxwriter 1.2.7 py_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "yapf 0.28.0 py_0", + "zeromq 4.3.1 he6710b0_3", + "zict 1.0.0 py_0", + "zipp 2.2.0 py_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "608d88bc1a9d27588b949832361d3cad", + "name": "anaconda", + "namespace": "python", + "sha256": "f364dfbf664dfc87fa318a63087a80ea20c30722877502767478acd3ba15828d", + "size": 13918, + "subdir": "linux-64", + "timestamp": 1583202226185, + "version": "2020.02" + }, + "anaconda-2020.02-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py_0", + "anaconda-client 1.7.2 py38_0", + "anaconda-project 0.8.4 py_0", + "argh 0.26.2 py38_0", + "asn1crypto 1.3.0 py38_0", + "astroid 2.3.3 py38_0", + "astropy 4.0 py38h7b6447c_0", + "atomicwrites 1.3.0 py_0", + "attrs 19.3.0 py_0", + "autopep8 1.4.4 py_0", + "babel 2.8.0 py_0", + "backcall 0.1.0 py38_0", + "backports 1.0 py_2", + "backports.shutil_get_terminal_size 1.0.0 py38_2", + "beautifulsoup4 4.8.2 py38_0", + "bitarray 1.2.1 py38h7b6447c_0", + "bkcharts 0.2 py38_0", + "blas 1.0 mkl", + "bleach 3.1.0 py_0", + "blosc 1.16.3 hd408876_0", + "bokeh 1.4.0 py38_0", + "boto 2.49.0 py38_0", + "bottleneck 1.3.2 py38heb32a55_0", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2020.1.1 0", + "cairo 1.14.12 h8948797_3", + "certifi 2019.11.28 py38_0", + "cffi 1.14.0 py38h2e261b9_0", + "chardet 3.0.4 py38_1003", + "click 7.0 py_0", + "cloudpickle 1.3.0 py_0", + "clyent 1.2.2 py38_1", + "colorama 0.4.3 py_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 2.8 py38h1ba5d50_0", + "curl 7.68.0 hbc83047_0", + "cycler 0.10.0 py38_0", + "cython 0.29.15 py38he6710b0_0", + "cytoolz 0.10.1 py38h7b6447c_0", + "dask 2.11.0 py_0", + "dask-core 2.11.0 py_0", + "dbus 1.13.12 h746ee38_0", + "decorator 4.4.1 py_0", + "defusedxml 0.6.0 py_0", + "diff-match-patch 20181111 py_0", + "distributed 2.11.0 py38_0", + "docutils 0.16 py38_0", + "entrypoints 0.3 py38_0", + "et_xmlfile 1.0.1 py38_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.1.0 py38h7b6447c_0", + "filelock 3.0.12 py_0", + "flake8 3.7.9 py38_0", + "flask 1.1.1 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "fsspec 0.6.2 py_0", + "future 0.18.2 py38_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.3.7 py38h7b6447c_1", + "glib 2.63.1 h5a9c865_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py38hd5f6e3b_3", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py38h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.10.0 py38h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.0.1 py_0", + "hypothesis 5.5.4 py_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py38_1000", + "imageio 2.6.1 py38_0", + "imagesize 1.2.0 py_0", + "importlib_metadata 1.5.0 py38_0", + "intel-openmp 2020.0 166", + "intervaltree 3.0.2 py_0", + "ipykernel 5.1.4 py38h39e3cac_0", + "ipython 7.12.0 py38h5ca1d4c_0", + "ipython_genutils 0.2.0 py38_0", + "ipywidgets 7.5.1 py_0", + "isort 4.3.21 py38_0", + "itsdangerous 1.1.0 py_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.14.1 py38_0", + "jeepney 0.4.2 py_0", + "jinja2 2.11.1 py_0", + "joblib 0.14.1 py_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.1 py_0", + "jsonschema 3.2.0 py38_0", + "jupyter 1.0.0 py38_7", + "jupyter_client 5.3.4 py38_0", + "jupyter_console 6.1.0 py_0", + "jupyter_core 4.6.1 py38_0", + "jupyterlab 1.2.6 pyhf63ae98_0", + "jupyterlab_server 1.0.6 py_0", + "keyring 21.1.0 py38_0", + "kiwisolver 1.0.1 py38he6710b0_0", + "krb5 1.17.1 h173b8e3_0", + "lazy-object-proxy 1.4.3 py38h7b6447c_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.68.0 h20c2e04_0", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libspatialindex 1.9.3 he6710b0_0", + "libssh2 1.8.2 h1ba5d50_0", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_0", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 hea5a465_1", + "libxslt 1.1.33 h7d1a2b0_0", + "llvmlite 0.31.0 py38hd408876_0", + "locket 0.2.0 py38_1", + "lxml 4.5.0 py38hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py38h7b6447c_0", + "matplotlib 3.1.3 py38_0", + "matplotlib-base 3.1.3 py38hef1b27d_0", + "mccabe 0.6.1 py38_1", + "mistune 0.8.4 py38h7b6447c_1000", + "mkl 2020.0 166", + "mkl-service 2.3.0 py38he904b0f_0", + "mkl_fft 1.0.15 py38ha843d7b_0", + "mkl_random 1.1.0 py38h962f231_0", + "mock 4.0.1 py_0", + "more-itertools 8.2.0 py_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py38_0", + "msgpack-python 0.6.1 py38hfd86e86_1", + "multipledispatch 0.6.0 py38_0", + "nbconvert 5.6.1 py38_0", + "nbformat 5.0.4 py_0", + "ncurses 6.2 he6710b0_0", + "networkx 2.4 py_0", + "nltk 3.4.5 py38_0", + "nose 1.3.7 py38_2", + "notebook 6.0.3 py38_0", + "numba 0.48.0 py38h0573a6f_0", + "numexpr 2.7.1 py38h423224d_0", + "numpy 1.18.1 py38h4f9e942_0", + "numpy-base 1.18.1 py38hde5b4d6_1", + "numpydoc 0.9.2 py_0", + "olefile 0.46 py_0", + "openpyxl 3.0.3 py_0", + "openssl 1.1.1d h7b6447c_4", + "packaging 20.1 py_0", + "pandas 1.0.1 py38h0573a6f_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py38_1", + "pango 1.42.4 h049681c_0", + "parso 0.5.2 py_0", + "partd 1.1.0 py_0", + "patchelf 0.10 he6710b0_0", + "path 13.1.0 py38_0", + "path.py 12.4.0 0", + "pathlib2 2.3.5 py38_0", + "pathtools 0.1.2 py_1", + "patsy 0.5.1 py38_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py38_0", + "pexpect 4.8.0 py38_0", + "pickleshare 0.7.5 py38_1000", + "pillow 7.0.0 py38hb39fc2d_0", + "pip 20.0.2 py38_1", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py38_0", + "pluggy 0.13.1 py38_0", + "ply 3.11 py38_0", + "prometheus_client 0.7.1 py_0", + "prompt_toolkit 3.0.3 py_0", + "psutil 5.6.7 py38h7b6447c_0", + "ptyprocess 0.6.0 py38_0", + "py 1.8.1 py_0", + "pycodestyle 2.5.0 py38_0", + "pycosat 0.6.3 py38h7b6447c_0", + "pycparser 2.19 py_0", + "pycurl 7.43.0.5 py38h1ba5d50_0", + "pydocstyle 4.0.1 py_0", + "pyflakes 2.1.1 py38_0", + "pygments 2.5.2 py_0", + "pylint 2.4.4 py38_0", + "pyodbc 4.0.30 py38he6710b0_0", + "pyopenssl 19.1.0 py38_0", + "pyparsing 2.4.6 py_0", + "pyqt 5.9.2 py38h05f1152_4", + "pyrsistent 0.15.7 py38h7b6447c_0", + "pysocks 1.7.1 py38_0", + "pytables 3.6.1 py38h9fd0a39_0", + "pytest 5.3.5 py38_0", + "pytest-arraydiff 0.2 py38h39e3cac_0", + "pytest-astropy 0.8.0 py_0", + "pytest-astropy-header 0.1.2 py_0", + "pytest-doctestplus 0.5.0 py_0", + "pytest-openfiles 0.4.0 py_0", + "pytest-remotedata 0.3.2 py38_0", + "python 3.8.1 h0371630_1", + "python-dateutil 2.8.1 py_0", + "python-jsonrpc-server 0.3.4 py_0", + "python-language-server 0.31.7 py38_0", + "python-libarchive-c 2.8 py38_7", + "pytz 2019.3 py_0", + "pywavelets 1.1.1 py38h7b6447c_0", + "pyxdg 0.26 py_0", + "pyyaml 5.3 py38h7b6447c_0", + "pyzmq 18.1.1 py38he6710b0_0", + "qdarkstyle 2.8 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.6.1 py_0", + "qtconsole 4.6.0 py_1", + "qtpy 1.9.0 py_0", + "readline 7.0 h7b6447c_5", + "requests 2.22.0 py38_1", + "ripgrep 11.0.2 he32d670_0", + "rope 0.16.0 py_0", + "rtree 0.9.3 py38_0", + "ruamel_yaml 0.15.87 py38h7b6447c_0", + "scikit-image 0.16.2 py38h0573a6f_0", + "scikit-learn 0.22.1 py38hd81dba3_0", + "scipy 1.4.1 py38h0b6359f_0", + "seaborn 0.10.0 py_0", + "secretstorage 3.1.2 py38_0", + "send2trash 1.5.0 py38_0", + "setuptools 45.2.0 py38_0", + "simplegeneric 0.8.1 py38_2", + "singledispatch 3.4.0.3 py38_0", + "sip 4.19.13 py38he6710b0_0", + "six 1.14.0 py38_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.1.1 py_0", + "sortedcontainers 2.1.0 py38_0", + "soupsieve 1.9.5 py38_0", + "sphinx 2.4.0 py_0", + "sphinxcontrib 1.0 py38_1", + "sphinxcontrib-applehelp 1.0.1 py_0", + "sphinxcontrib-devhelp 1.0.1 py_0", + "sphinxcontrib-htmlhelp 1.0.2 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.2 py_0", + "sphinxcontrib-serializinghtml 1.1.3 py_0", + "sphinxcontrib-websupport 1.2.0 py_0", + "spyder 4.0.1 py38_0", + "spyder-kernels 1.8.1 py38_0", + "sqlalchemy 1.3.13 py38h7b6447c_0", + "sqlite 3.31.1 h7b6447c_0", + "statsmodels 0.11.0 py38h7b6447c_0", + "sympy 1.5.1 py38_0", + "tbb 2020.0 hfd86e86_0", + "tblib 1.6.0 py_0", + "terminado 0.8.3 py38_0", + "testpath 0.4.4 py_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.10.0 py_0", + "tornado 6.0.3 py38h7b6447c_3", + "tqdm 4.42.1 py_0", + "traitlets 4.3.3 py38_0", + "ujson 1.35 py38h7b6447c_0", + "unicodecsv 0.14.1 py38_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.25.8 py38_0", + "watchdog 0.10.2 py38_0", + "wcwidth 0.1.8 py_0", + "webencodings 0.5.1 py38_1", + "werkzeug 1.0.0 py_0", + "wheel 0.34.2 py38_0", + "widgetsnbextension 3.5.1 py38_0", + "wrapt 1.11.2 py38h7b6447c_0", + "wurlitzer 2.0.0 py38_0", + "xlrd 1.2.0 py_0", + "xlsxwriter 1.2.7 py_0", + "xlwt 1.3.0 py38_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "yapf 0.28.0 py_0", + "zeromq 4.3.1 he6710b0_3", + "zict 1.0.0 py_0", + "zipp 2.2.0 py_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "85b2f5867c0e616710262cd6ac75175d", + "name": "anaconda", + "namespace": "python", + "sha256": "6198bd4c529ab22268196e9d60901e8c6bc2e6458dfaad8de8ab1a28b23cf816", + "size": 13968, + "subdir": "linux-64", + "timestamp": 1583202304295, + "version": "2020.02" + }, + "anaconda-2020.07-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py36_0", + "anaconda-client 1.7.2 py36_0", + "anaconda-project 0.8.4 py_0", + "argh 0.26.2 py36_0", + "asn1crypto 1.3.0 py36_0", + "astroid 2.4.2 py36_0", + "astropy 4.0.1.post1 py36h7b6447c_1", + "atomicwrites 1.4.0 py_0", + "attrs 19.3.0 py_0", + "autopep8 1.5.3 py_0", + "babel 2.8.0 py_0", + "backcall 0.2.0 py_0", + "backports 1.0 py_2", + "backports.shutil_get_terminal_size 1.0.0 py36_2", + "beautifulsoup4 4.9.1 py36_0", + "bitarray 1.4.0 py36h7b6447c_0", + "bkcharts 0.2 py36_0", + "blas 1.0 mkl", + "bleach 3.1.5 py_0", + "blosc 1.19.0 hd408876_0", + "bokeh 2.1.1 py36_0", + "boto 2.49.0 py36_0", + "bottleneck 1.3.2 py36heb32a55_1", + "brotlipy 0.7.0 py36h7b6447c_1000", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2020.6.24 0", + "cairo 1.14.12 h8948797_3", + "certifi 2020.6.20 py36_0", + "cffi 1.14.0 py36he30daa8_1", + "chardet 3.0.4 py36_1003", + "click 7.1.2 py_0", + "cloudpickle 1.5.0 py_0", + "clyent 1.2.2 py36_1", + "colorama 0.4.3 py_0", + "contextlib2 0.6.0.post1 py_0", + "contextvars 2.4 py_0", + "cryptography 2.9.2 py36h1ba5d50_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py36_0", + "cython 0.29.21 py36he6710b0_0", + "cytoolz 0.10.1 py36h7b6447c_0", + "dask 2.20.0 py_0", + "dask-core 2.20.0 py_0", + "dbus 1.13.16 hb2f20db_0", + "decorator 4.4.2 py_0", + "defusedxml 0.6.0 py_0", + "diff-match-patch 20200713 py_0", + "distributed 2.20.0 py36_0", + "docutils 0.16 py36_1", + "entrypoints 0.3 py36_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.2.9 he6710b0_2", + "fastcache 1.1.0 py36h7b6447c_0", + "filelock 3.0.12 py_0", + "flake8 3.8.3 py_0", + "flask 1.1.2 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.10.2 h5ab3b9f_0", + "fribidi 1.0.9 h7b6447c_0", + "fsspec 0.7.4 py_0", + "future 0.18.2 py36_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 20.6.2 py36h7b6447c_0", + "glib 2.65.0 h3eb4bd4_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py36h10f8cd9_2", + "graphite2 1.3.14 h23475e2_0", + "greenlet 0.4.16 py36h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb31296c_0", + "h5py 2.10.0 py36h7918eee_0", + "harfbuzz 2.4.0 hca77d97_1", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 py_0", + "imageio 2.9.0 py_0", + "imagesize 1.2.0 py_0", + "immutables 0.14 py36h7b6447c_0", + "importlib-metadata 1.7.0 py36_0", + "importlib_metadata 1.7.0 0", + "intel-openmp 2020.1 217", + "intervaltree 3.0.2 py_1", + "ipykernel 5.3.2 py36h5ca1d4c_0", + "ipython 7.16.1 py36h5ca1d4c_0", + "ipython_genutils 0.2.0 py36_0", + "ipywidgets 7.5.1 py_0", + "isort 4.3.21 py36_0", + "itsdangerous 1.1.0 py36_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.1 py36_0", + "jeepney 0.4.3 py_0", + "jinja2 2.11.2 py_0", + "joblib 0.16.0 py_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py36_0", + "jupyter 1.0.0 py36_7", + "jupyter_client 6.1.6 py_0", + "jupyter_console 6.1.0 py_0", + "jupyter_core 4.6.3 py36_0", + "jupyterlab 2.1.5 py_0", + "jupyterlab_server 1.2.0 py_0", + "keyring 21.2.1 py36_0", + "kiwisolver 1.2.0 py36hfd86e86_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.4.3 py36h7b6447c_0", + "lcms2 2.11 h396b838_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libedit 3.1.20191231 h14c3975_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 he6710b0_0", + "libllvm9 9.0.1 h4a3c616_1", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 he6710b0_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_1", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 he19cac6_1", + "libxslt 1.1.34 hc22bd24_0", + "llvmlite 0.33.0 py36hc6ec683_1", + "locket 0.2.0 py36_1", + "lxml 4.5.2 py36hefd8a0e_0", + "lz4-c 1.9.2 he6710b0_0", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py36h7b6447c_0", + "matplotlib 3.2.2 0", + "matplotlib-base 3.2.2 py36hef1b27d_0", + "mccabe 0.6.1 py36_1", + "mistune 0.8.4 py36h7b6447c_0", + "mkl 2020.1 217", + "mkl-service 2.3.0 py36he904b0f_0", + "mkl_fft 1.1.0 py36h23d657b_0", + "mkl_random 1.1.1 py36h0573a6f_0", + "mock 4.0.2 py_0", + "more-itertools 8.4.0 py_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.1.0 py36_0", + "msgpack-python 1.0.0 py36hfd86e86_1", + "multipledispatch 0.6.0 py36_0", + "nbconvert 5.6.1 py36_0", + "nbformat 5.0.7 py_0", + "ncurses 6.2 he6710b0_1", + "networkx 2.4 py_1", + "nltk 3.5 py_0", + "nose 1.3.7 py36_2", + "notebook 6.0.3 py36_0", + "numba 0.50.1 py36h0573a6f_1", + "numexpr 2.7.1 py36h423224d_0", + "numpy 1.18.5 py36ha1c710e_0", + "numpy-base 1.18.5 py36hde5b4d6_0", + "numpydoc 1.1.0 py_0", + "olefile 0.46 py36_0", + "openpyxl 3.0.4 py_0", + "openssl 1.1.1g h7b6447c_0", + "packaging 20.4 py_0", + "pandas 1.0.5 py36h0573a6f_0", + "pandoc 2.10 0", + "pandocfilters 1.4.2 py36_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.1.0 py_0", + "patchelf 0.11 he6710b0_0", + "path 13.1.0 py36_0", + "path.py 12.4.0 0", + "pathlib2 2.3.5 py36_0", + "pathtools 0.1.2 py_1", + "patsy 0.5.1 py36_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py36_0", + "pexpect 4.8.0 py36_0", + "pickleshare 0.7.5 py36_0", + "pillow 7.2.0 py36hb39fc2d_0", + "pip 20.1.1 py36_1", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.5.0.1 py36_0", + "pluggy 0.13.1 py36_0", + "ply 3.11 py36_0", + "prometheus_client 0.8.0 py_0", + "prompt-toolkit 3.0.5 py_0", + "prompt_toolkit 3.0.5 0", + "psutil 5.7.0 py36h7b6447c_0", + "ptyprocess 0.6.0 py36_0", + "py 1.9.0 py_0", + "py-lief 0.10.1 py36h403a769_0", + "pycodestyle 2.6.0 py_0", + "pycosat 0.6.3 py36h7b6447c_0", + "pycparser 2.20 py_2", + "pycrypto 2.6.1 py36h7b6447c_10", + "pycurl 7.43.0.5 py36h1ba5d50_0", + "pydocstyle 5.0.2 py_0", + "pyflakes 2.2.0 py_0", + "pygments 2.6.1 py_0", + "pylint 2.5.3 py36_0", + "pyodbc 4.0.30 py36he6710b0_0", + "pyopenssl 19.1.0 py_1", + "pyparsing 2.4.7 py_0", + "pyqt 5.9.2 py36h05f1152_2", + "pyrsistent 0.16.0 py36h7b6447c_0", + "pysocks 1.7.1 py36_0", + "pytables 3.6.1 py36h71ec239_0", + "pytest 5.4.3 py36_0", + "python 3.6.10 h7579374_2", + "python-dateutil 2.8.1 py_0", + "python-jsonrpc-server 0.3.4 py_1", + "python-language-server 0.34.1 py36_0", + "python-libarchive-c 2.9 py_0", + "pytz 2020.1 py_0", + "pywavelets 1.1.1 py36h7b6447c_0", + "pyxdg 0.26 py_0", + "pyyaml 5.3.1 py36h7b6447c_1", + "pyzmq 19.0.1 py36he6710b0_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.7.2 py_0", + "qtconsole 4.7.5 py_0", + "qtpy 1.9.0 py_0", + "readline 8.0 h7b6447c_0", + "regex 2020.6.8 py36h7b6447c_0", + "requests 2.24.0 py_0", + "ripgrep 11.0.2 he32d670_0", + "rope 0.17.0 py_0", + "rtree 0.9.4 py36_1", + "ruamel_yaml 0.15.87 py36h7b6447c_1", + "scikit-image 0.16.2 py36h0573a6f_0", + "scikit-learn 0.23.1 py36h423224d_0", + "scipy 1.5.0 py36h0b6359f_0", + "seaborn 0.10.1 py_0", + "secretstorage 3.1.2 py36_0", + "send2trash 1.5.0 py36_0", + "setuptools 49.2.0 py36_0", + "simplegeneric 0.8.1 py36_2", + "singledispatch 3.4.0.3 py36_0", + "sip 4.19.8 py36hf484d3e_0", + "six 1.15.0 py_0", + "snappy 1.1.8 he6710b0_0", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.2.1 py_0", + "sortedcontainers 2.2.2 py_0", + "soupsieve 2.0.1 py_0", + "sphinx 3.1.2 py_0", + "sphinxcontrib 1.0 py36_1", + "sphinxcontrib-applehelp 1.0.2 py_0", + "sphinxcontrib-devhelp 1.0.2 py_0", + "sphinxcontrib-htmlhelp 1.0.3 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.3 py_0", + "sphinxcontrib-serializinghtml 1.1.4 py_0", + "sphinxcontrib-websupport 1.2.3 py_0", + "spyder 4.1.4 py36_0", + "spyder-kernels 1.9.2 py36_0", + "sqlalchemy 1.3.18 py36h7b6447c_0", + "sqlite 3.32.3 h62c20be_0", + "statsmodels 0.11.1 py36h7b6447c_0", + "sympy 1.6.1 py36_0", + "tbb 2020.0 hfd86e86_0", + "tblib 1.6.0 py_0", + "terminado 0.8.3 py36_0", + "testpath 0.4.4 py_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "tk 8.6.10 hbc83047_0", + "toml 0.10.1 py_0", + "toolz 0.10.0 py_0", + "tornado 6.0.4 py36h7b6447c_1", + "tqdm 4.47.0 py_0", + "traitlets 4.3.3 py36_0", + "typed-ast 1.4.1 py36h7b6447c_0", + "typing_extensions 3.7.4.2 py_0", + "ujson 1.35 py36h14c3975_0", + "unicodecsv 0.14.1 py36_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.25.9 py_0", + "watchdog 0.10.3 py36_0", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py36_1", + "werkzeug 1.0.1 py_0", + "wheel 0.34.2 py36_0", + "widgetsnbextension 3.5.1 py36_0", + "wrapt 1.11.2 py36h7b6447c_0", + "wurlitzer 2.0.1 py36_0", + "xlrd 1.2.0 py36_0", + "xlsxwriter 1.2.9 py_0", + "xlwt 1.3.0 py36_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.30.0 py_0", + "zeromq 4.3.2 he6710b0_2", + "zict 2.0.0 py_0", + "zipp 3.1.0 py_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py36_1", + "zope.event 4.4 py36_0", + "zope.interface 4.7.1 py36h7b6447c_0", + "zstd 1.4.5 h0b5b093_0" + ], + "license": "BSD", + "md5": "9883132e9d0e70afa0812bcd1b4b0ca2", + "name": "anaconda", + "namespace": "python", + "sha256": "9e70853a1787b968e8589348b32878c65286f59231faec0ad6fedaef2b08b10f", + "size": 14244, + "subdir": "linux-64", + "timestamp": 1595029547527, + "version": "2020.07" + }, + "anaconda-2020.07-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.7.2 py37_0", + "anaconda-project 0.8.4 py_0", + "argh 0.26.2 py37_0", + "asn1crypto 1.3.0 py37_1", + "astroid 2.4.2 py37_0", + "astropy 4.0.1.post1 py37h7b6447c_1", + "atomicwrites 1.4.0 py_0", + "attrs 19.3.0 py_0", + "autopep8 1.5.3 py_0", + "babel 2.8.0 py_0", + "backcall 0.2.0 py_0", + "backports 1.0 py_2", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "beautifulsoup4 4.9.1 py37_0", + "bitarray 1.4.0 py37h7b6447c_0", + "bkcharts 0.2 py37_0", + "blas 1.0 mkl", + "bleach 3.1.5 py_0", + "blosc 1.19.0 hd408876_0", + "bokeh 2.1.1 py37_0", + "boto 2.49.0 py37_0", + "bottleneck 1.3.2 py37heb32a55_1", + "brotlipy 0.7.0 py37h7b6447c_1000", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2020.6.24 0", + "cairo 1.14.12 h8948797_3", + "certifi 2020.6.20 py37_0", + "cffi 1.14.0 py37he30daa8_1", + "chardet 3.0.4 py37_1003", + "click 7.1.2 py_0", + "cloudpickle 1.5.0 py_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.3 py_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 2.9.2 py37h1ba5d50_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py37_0", + "cython 0.29.21 py37he6710b0_0", + "cytoolz 0.10.1 py37h7b6447c_0", + "dask 2.20.0 py_0", + "dask-core 2.20.0 py_0", + "dbus 1.13.16 hb2f20db_0", + "decorator 4.4.2 py_0", + "defusedxml 0.6.0 py_0", + "diff-match-patch 20200713 py_0", + "distributed 2.20.0 py37_0", + "docutils 0.16 py37_1", + "entrypoints 0.3 py37_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.2.9 he6710b0_2", + "fastcache 1.1.0 py37h7b6447c_0", + "filelock 3.0.12 py_0", + "flake8 3.8.3 py_0", + "flask 1.1.2 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.10.2 h5ab3b9f_0", + "fribidi 1.0.9 h7b6447c_0", + "fsspec 0.7.4 py_0", + "future 0.18.2 py37_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 20.6.2 py37h7b6447c_0", + "glib 2.65.0 h3eb4bd4_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.14 h23475e2_0", + "greenlet 0.4.16 py37h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb31296c_0", + "h5py 2.10.0 py37h7918eee_0", + "harfbuzz 2.4.0 hca77d97_1", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 py_0", + "imageio 2.9.0 py_0", + "imagesize 1.2.0 py_0", + "importlib-metadata 1.7.0 py37_0", + "importlib_metadata 1.7.0 0", + "intel-openmp 2020.1 217", + "intervaltree 3.0.2 py_1", + "ipykernel 5.3.2 py37h5ca1d4c_0", + "ipython 7.16.1 py37h5ca1d4c_0", + "ipython_genutils 0.2.0 py37_0", + "ipywidgets 7.5.1 py_0", + "isort 4.3.21 py37_0", + "itsdangerous 1.1.0 py37_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.1 py37_0", + "jeepney 0.4.3 py_0", + "jinja2 2.11.2 py_0", + "joblib 0.16.0 py_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py37_1", + "jupyter 1.0.0 py37_7", + "jupyter_client 6.1.6 py_0", + "jupyter_console 6.1.0 py_0", + "jupyter_core 4.6.3 py37_0", + "jupyterlab 2.1.5 py_0", + "jupyterlab_server 1.2.0 py_0", + "keyring 21.2.1 py37_0", + "kiwisolver 1.2.0 py37hfd86e86_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.4.3 py37h7b6447c_0", + "lcms2 2.11 h396b838_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libedit 3.1.20191231 h14c3975_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 he6710b0_0", + "libllvm9 9.0.1 h4a3c616_1", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 he6710b0_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_1", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 he19cac6_1", + "libxslt 1.1.34 hc22bd24_0", + "llvmlite 0.33.0 py37hc6ec683_1", + "locket 0.2.0 py37_1", + "lxml 4.5.2 py37hefd8a0e_0", + "lz4-c 1.9.2 he6710b0_0", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py37h14c3975_1", + "matplotlib 3.2.2 0", + "matplotlib-base 3.2.2 py37hef1b27d_0", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h14c3975_1001", + "mkl 2020.1 217", + "mkl-service 2.3.0 py37he904b0f_0", + "mkl_fft 1.1.0 py37h23d657b_0", + "mkl_random 1.1.1 py37h0573a6f_0", + "mock 4.0.2 py_0", + "more-itertools 8.4.0 py_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.1.0 py37_0", + "msgpack-python 1.0.0 py37hfd86e86_1", + "multipledispatch 0.6.0 py37_0", + "nbconvert 5.6.1 py37_1", + "nbformat 5.0.7 py_0", + "ncurses 6.2 he6710b0_1", + "networkx 2.4 py_1", + "nltk 3.5 py_0", + "nose 1.3.7 py37_1004", + "notebook 6.0.3 py37_0", + "numba 0.50.1 py37h0573a6f_1", + "numexpr 2.7.1 py37h423224d_0", + "numpy 1.18.5 py37ha1c710e_0", + "numpy-base 1.18.5 py37hde5b4d6_0", + "numpydoc 1.1.0 py_0", + "olefile 0.46 py37_0", + "openpyxl 3.0.4 py_0", + "openssl 1.1.1g h7b6447c_0", + "packaging 20.4 py_0", + "pandas 1.0.5 py37h0573a6f_0", + "pandoc 2.10 0", + "pandocfilters 1.4.2 py37_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.1.0 py_0", + "patchelf 0.11 he6710b0_0", + "path 13.1.0 py37_0", + "path.py 12.4.0 0", + "pathlib2 2.3.5 py37_1", + "pathtools 0.1.2 py_1", + "patsy 0.5.1 py37_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py37_0", + "pexpect 4.8.0 py37_1", + "pickleshare 0.7.5 py37_1001", + "pillow 7.2.0 py37hb39fc2d_0", + "pip 20.1.1 py37_1", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.5.0.1 py37_0", + "pluggy 0.13.1 py37_0", + "ply 3.11 py37_0", + "prometheus_client 0.8.0 py_0", + "prompt-toolkit 3.0.5 py_0", + "prompt_toolkit 3.0.5 0", + "psutil 5.7.0 py37h7b6447c_0", + "ptyprocess 0.6.0 py37_0", + "py 1.9.0 py_0", + "py-lief 0.10.1 py37h403a769_0", + "pycodestyle 2.6.0 py_0", + "pycosat 0.6.3 py37h7b6447c_0", + "pycparser 2.20 py_2", + "pycrypto 2.6.1 py37h7b6447c_10", + "pycurl 7.43.0.5 py37h1ba5d50_0", + "pydocstyle 5.0.2 py_0", + "pyflakes 2.2.0 py_0", + "pygments 2.6.1 py_0", + "pylint 2.5.3 py37_0", + "pyodbc 4.0.30 py37he6710b0_0", + "pyopenssl 19.1.0 py_1", + "pyparsing 2.4.7 py_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.16.0 py37h7b6447c_0", + "pysocks 1.7.1 py37_1", + "pytables 3.6.1 py37h71ec239_0", + "pytest 5.4.3 py37_0", + "python 3.7.7 hcff3b4d_5", + "python-dateutil 2.8.1 py_0", + "python-jsonrpc-server 0.3.4 py_1", + "python-language-server 0.34.1 py37_0", + "python-libarchive-c 2.9 py_0", + "pytz 2020.1 py_0", + "pywavelets 1.1.1 py37h7b6447c_0", + "pyxdg 0.26 py_0", + "pyyaml 5.3.1 py37h7b6447c_1", + "pyzmq 19.0.1 py37he6710b0_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.7.2 py_0", + "qtconsole 4.7.5 py_0", + "qtpy 1.9.0 py_0", + "readline 8.0 h7b6447c_0", + "regex 2020.6.8 py37h7b6447c_0", + "requests 2.24.0 py_0", + "ripgrep 11.0.2 he32d670_0", + "rope 0.17.0 py_0", + "rtree 0.9.4 py37_1", + "ruamel_yaml 0.15.87 py37h7b6447c_1", + "scikit-image 0.16.2 py37h0573a6f_0", + "scikit-learn 0.23.1 py37h423224d_0", + "scipy 1.5.0 py37h0b6359f_0", + "seaborn 0.10.1 py_0", + "secretstorage 3.1.2 py37_1", + "send2trash 1.5.0 py37_0", + "setuptools 49.2.0 py37_0", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.4.0.3 py37_0", + "sip 4.19.8 py37hf484d3e_0", + "six 1.15.0 py_0", + "snappy 1.1.8 he6710b0_0", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.2.1 py_0", + "sortedcontainers 2.2.2 py_0", + "soupsieve 2.0.1 py_0", + "sphinx 3.1.2 py_0", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-applehelp 1.0.2 py_0", + "sphinxcontrib-devhelp 1.0.2 py_0", + "sphinxcontrib-htmlhelp 1.0.3 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.3 py_0", + "sphinxcontrib-serializinghtml 1.1.4 py_0", + "sphinxcontrib-websupport 1.2.3 py_0", + "spyder 4.1.4 py37_0", + "spyder-kernels 1.9.2 py37_0", + "sqlalchemy 1.3.18 py37h7b6447c_0", + "sqlite 3.32.3 h62c20be_0", + "statsmodels 0.11.1 py37h7b6447c_0", + "sympy 1.6.1 py37_0", + "tbb 2020.0 hfd86e86_0", + "tblib 1.6.0 py_0", + "terminado 0.8.3 py37_0", + "testpath 0.4.4 py_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "tk 8.6.10 hbc83047_0", + "toml 0.10.1 py_0", + "toolz 0.10.0 py_0", + "tornado 6.0.4 py37h7b6447c_1", + "tqdm 4.47.0 py_0", + "traitlets 4.3.3 py37_0", + "typed-ast 1.4.1 py37h7b6447c_0", + "typing_extensions 3.7.4.2 py_0", + "ujson 1.35 py37h14c3975_0", + "unicodecsv 0.14.1 py37_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.25.9 py_0", + "watchdog 0.10.3 py37_0", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py37_1", + "werkzeug 1.0.1 py_0", + "wheel 0.34.2 py37_0", + "widgetsnbextension 3.5.1 py37_0", + "wrapt 1.11.2 py37h7b6447c_0", + "wurlitzer 2.0.1 py37_0", + "xlrd 1.2.0 py37_0", + "xlsxwriter 1.2.9 py_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.30.0 py_0", + "zeromq 4.3.2 he6710b0_2", + "zict 2.0.0 py_0", + "zipp 3.1.0 py_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py37_1", + "zope.event 4.4 py37_0", + "zope.interface 4.7.1 py37h7b6447c_0", + "zstd 1.4.5 h0b5b093_0" + ], + "license": "BSD", + "md5": "d21cb2779b5237362c8ebaf195e6f825", + "name": "anaconda", + "namespace": "python", + "sha256": "a37ef93d734f34c38bac61a2c6b3fe39cf754cbea68b617ee46d60be1c51db91", + "size": 14167, + "subdir": "linux-64", + "timestamp": 1595029546784, + "version": "2020.07" + }, + "anaconda-2020.07-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py_0", + "anaconda-client 1.7.2 py38_0", + "anaconda-project 0.8.4 py_0", + "argh 0.26.2 py38_0", + "asn1crypto 1.3.0 py38_0", + "astroid 2.4.2 py38_0", + "astropy 4.0.1.post1 py38h7b6447c_1", + "atomicwrites 1.4.0 py_0", + "attrs 19.3.0 py_0", + "autopep8 1.5.3 py_0", + "babel 2.8.0 py_0", + "backcall 0.2.0 py_0", + "backports 1.0 py_2", + "backports.shutil_get_terminal_size 1.0.0 py38_2", + "beautifulsoup4 4.9.1 py38_0", + "bitarray 1.4.0 py38h7b6447c_0", + "bkcharts 0.2 py38_0", + "blas 1.0 mkl", + "bleach 3.1.5 py_0", + "blosc 1.19.0 hd408876_0", + "bokeh 2.1.1 py38_0", + "boto 2.49.0 py38_0", + "bottleneck 1.3.2 py38heb32a55_1", + "brotlipy 0.7.0 py38h7b6447c_1000", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2020.6.24 0", + "cairo 1.14.12 h8948797_3", + "certifi 2020.6.20 py38_0", + "cffi 1.14.0 py38he30daa8_1", + "chardet 3.0.4 py38_1003", + "click 7.1.2 py_0", + "cloudpickle 1.5.0 py_0", + "clyent 1.2.2 py38_1", + "colorama 0.4.3 py_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 2.9.2 py38h1ba5d50_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py38_0", + "cython 0.29.21 py38he6710b0_0", + "cytoolz 0.10.1 py38h7b6447c_0", + "dask 2.20.0 py_0", + "dask-core 2.20.0 py_0", + "dbus 1.13.16 hb2f20db_0", + "decorator 4.4.2 py_0", + "defusedxml 0.6.0 py_0", + "diff-match-patch 20200713 py_0", + "distributed 2.20.0 py38_0", + "docutils 0.16 py38_1", + "entrypoints 0.3 py38_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.2.9 he6710b0_2", + "fastcache 1.1.0 py38h7b6447c_0", + "filelock 3.0.12 py_0", + "flake8 3.8.3 py_0", + "flask 1.1.2 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.10.2 h5ab3b9f_0", + "fribidi 1.0.9 h7b6447c_0", + "fsspec 0.7.4 py_0", + "future 0.18.2 py38_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 20.6.2 py38h7b6447c_0", + "glib 2.65.0 h3eb4bd4_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py38hd5f6e3b_3", + "graphite2 1.3.14 h23475e2_0", + "greenlet 0.4.16 py38h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb31296c_0", + "h5py 2.10.0 py38h7918eee_0", + "harfbuzz 2.4.0 hca77d97_1", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 py_0", + "imageio 2.9.0 py_0", + "imagesize 1.2.0 py_0", + "importlib-metadata 1.7.0 py38_0", + "importlib_metadata 1.7.0 0", + "intel-openmp 2020.1 217", + "intervaltree 3.0.2 py_1", + "ipykernel 5.3.2 py38h5ca1d4c_0", + "ipython 7.16.1 py38h5ca1d4c_0", + "ipython_genutils 0.2.0 py38_0", + "ipywidgets 7.5.1 py_0", + "isort 4.3.21 py38_0", + "itsdangerous 1.1.0 py_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.1 py38_0", + "jeepney 0.4.3 py_0", + "jinja2 2.11.2 py_0", + "joblib 0.16.0 py_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py38_0", + "jupyter 1.0.0 py38_7", + "jupyter_client 6.1.6 py_0", + "jupyter_console 6.1.0 py_0", + "jupyter_core 4.6.3 py38_0", + "jupyterlab 2.1.5 py_0", + "jupyterlab_server 1.2.0 py_0", + "keyring 21.2.1 py38_0", + "kiwisolver 1.2.0 py38hfd86e86_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.4.3 py38h7b6447c_0", + "lcms2 2.11 h396b838_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libedit 3.1.20191231 h14c3975_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 he6710b0_0", + "libllvm9 9.0.1 h4a3c616_1", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 he6710b0_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_1", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 he19cac6_1", + "libxslt 1.1.34 hc22bd24_0", + "llvmlite 0.33.0 py38hc6ec683_1", + "locket 0.2.0 py38_1", + "lxml 4.5.2 py38hefd8a0e_0", + "lz4-c 1.9.2 he6710b0_0", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py38h7b6447c_0", + "matplotlib 3.2.2 0", + "matplotlib-base 3.2.2 py38hef1b27d_0", + "mccabe 0.6.1 py38_1", + "mistune 0.8.4 py38h7b6447c_1000", + "mkl 2020.1 217", + "mkl-service 2.3.0 py38he904b0f_0", + "mkl_fft 1.1.0 py38h23d657b_0", + "mkl_random 1.1.1 py38h0573a6f_0", + "mock 4.0.2 py_0", + "more-itertools 8.4.0 py_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.1.0 py38_0", + "msgpack-python 1.0.0 py38hfd86e86_1", + "multipledispatch 0.6.0 py38_0", + "nbconvert 5.6.1 py38_0", + "nbformat 5.0.7 py_0", + "ncurses 6.2 he6710b0_1", + "networkx 2.4 py_1", + "nltk 3.5 py_0", + "nose 1.3.7 py38_2", + "notebook 6.0.3 py38_0", + "numba 0.50.1 py38h0573a6f_1", + "numexpr 2.7.1 py38h423224d_0", + "numpy 1.18.5 py38ha1c710e_0", + "numpy-base 1.18.5 py38hde5b4d6_0", + "numpydoc 1.1.0 py_0", + "olefile 0.46 py_0", + "openpyxl 3.0.4 py_0", + "openssl 1.1.1g h7b6447c_0", + "packaging 20.4 py_0", + "pandas 1.0.5 py38h0573a6f_0", + "pandoc 2.10 0", + "pandocfilters 1.4.2 py38_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.1.0 py_0", + "patchelf 0.11 he6710b0_0", + "path 13.1.0 py38_0", + "path.py 12.4.0 0", + "pathlib2 2.3.5 py38_0", + "pathtools 0.1.2 py_1", + "patsy 0.5.1 py38_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py38_0", + "pexpect 4.8.0 py38_0", + "pickleshare 0.7.5 py38_1000", + "pillow 7.2.0 py38hb39fc2d_0", + "pip 20.1.1 py38_1", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.5.0.1 py38_0", + "pluggy 0.13.1 py38_0", + "ply 3.11 py38_0", + "prometheus_client 0.8.0 py_0", + "prompt-toolkit 3.0.5 py_0", + "prompt_toolkit 3.0.5 0", + "psutil 5.7.0 py38h7b6447c_0", + "ptyprocess 0.6.0 py38_0", + "py 1.9.0 py_0", + "py-lief 0.10.1 py38h403a769_0", + "pycodestyle 2.6.0 py_0", + "pycosat 0.6.3 py38h7b6447c_1", + "pycparser 2.20 py_2", + "pycurl 7.43.0.5 py38h1ba5d50_0", + "pydocstyle 5.0.2 py_0", + "pyflakes 2.2.0 py_0", + "pygments 2.6.1 py_0", + "pylint 2.5.3 py38_0", + "pyodbc 4.0.30 py38he6710b0_0", + "pyopenssl 19.1.0 py_1", + "pyparsing 2.4.7 py_0", + "pyqt 5.9.2 py38h05f1152_4", + "pyrsistent 0.16.0 py38h7b6447c_0", + "pysocks 1.7.1 py38_0", + "pytables 3.6.1 py38h9fd0a39_0", + "pytest 5.4.3 py38_0", + "python 3.8.3 hcff3b4d_2", + "python-dateutil 2.8.1 py_0", + "python-jsonrpc-server 0.3.4 py_1", + "python-language-server 0.34.1 py38_0", + "python-libarchive-c 2.9 py_0", + "pytz 2020.1 py_0", + "pywavelets 1.1.1 py38h7b6447c_0", + "pyxdg 0.26 py_0", + "pyyaml 5.3.1 py38h7b6447c_1", + "pyzmq 19.0.1 py38he6710b0_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.7.2 py_0", + "qtconsole 4.7.5 py_0", + "qtpy 1.9.0 py_0", + "readline 8.0 h7b6447c_0", + "regex 2020.6.8 py38h7b6447c_0", + "requests 2.24.0 py_0", + "ripgrep 11.0.2 he32d670_0", + "rope 0.17.0 py_0", + "rtree 0.9.4 py38_1", + "ruamel_yaml 0.15.87 py38h7b6447c_1", + "scikit-image 0.16.2 py38h0573a6f_0", + "scikit-learn 0.23.1 py38h423224d_0", + "scipy 1.5.0 py38h0b6359f_0", + "seaborn 0.10.1 py_0", + "secretstorage 3.1.2 py38_0", + "send2trash 1.5.0 py38_0", + "setuptools 49.2.0 py38_0", + "simplegeneric 0.8.1 py38_2", + "singledispatch 3.4.0.3 py38_0", + "sip 4.19.13 py38he6710b0_0", + "six 1.15.0 py_0", + "snappy 1.1.8 he6710b0_0", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.2.1 py_0", + "sortedcontainers 2.2.2 py_0", + "soupsieve 2.0.1 py_0", + "sphinx 3.1.2 py_0", + "sphinxcontrib 1.0 py38_1", + "sphinxcontrib-applehelp 1.0.2 py_0", + "sphinxcontrib-devhelp 1.0.2 py_0", + "sphinxcontrib-htmlhelp 1.0.3 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.3 py_0", + "sphinxcontrib-serializinghtml 1.1.4 py_0", + "sphinxcontrib-websupport 1.2.3 py_0", + "spyder 4.1.4 py38_0", + "spyder-kernels 1.9.2 py38_0", + "sqlalchemy 1.3.18 py38h7b6447c_0", + "sqlite 3.32.3 h62c20be_0", + "statsmodels 0.11.1 py38h7b6447c_0", + "sympy 1.6.1 py38_0", + "tbb 2020.0 hfd86e86_0", + "tblib 1.6.0 py_0", + "terminado 0.8.3 py38_0", + "testpath 0.4.4 py_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "tk 8.6.10 hbc83047_0", + "toml 0.10.1 py_0", + "toolz 0.10.0 py_0", + "tornado 6.0.4 py38h7b6447c_1", + "tqdm 4.47.0 py_0", + "traitlets 4.3.3 py38_0", + "typing_extensions 3.7.4.2 py_0", + "ujson 1.35 py38h7b6447c_0", + "unicodecsv 0.14.1 py38_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.25.9 py_0", + "watchdog 0.10.3 py38_0", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py38_1", + "werkzeug 1.0.1 py_0", + "wheel 0.34.2 py38_0", + "widgetsnbextension 3.5.1 py38_0", + "wrapt 1.11.2 py38h7b6447c_0", + "wurlitzer 2.0.1 py38_0", + "xlrd 1.2.0 py_0", + "xlsxwriter 1.2.9 py_0", + "xlwt 1.3.0 py38_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.30.0 py_0", + "zeromq 4.3.2 he6710b0_2", + "zict 2.0.0 py_0", + "zipp 3.1.0 py_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py38_1", + "zope.event 4.4 py38_0", + "zope.interface 4.7.1 py38h7b6447c_0", + "zstd 1.4.5 h0b5b093_0" + ], + "license": "BSD", + "md5": "b528ef39d1cd77065355afbe35c99303", + "name": "anaconda", + "namespace": "python", + "sha256": "4efbbb0175189795d018a523b1fe483cb61deba8890d8c9df4db285eeea4c621", + "size": 14152, + "subdir": "linux-64", + "timestamp": 1595029540792, + "version": "2020.07" + }, + "anaconda-2020.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.7.2 py37_0", + "anaconda-project 0.8.4 py_0", + "argh 0.26.2 py37_0", + "argon2-cffi 20.1.0 py37h7b6447c_1", + "asn1crypto 1.4.0 py_0", + "astroid 2.4.2 py37_0", + "astropy 4.0.2 py37h7b6447c_0", + "async_generator 1.10 py37h28b3542_0", + "atomicwrites 1.4.0 py_0", + "attrs 20.3.0 pyhd3eb1b0_0", + "autopep8 1.5.4 py_0", + "babel 2.8.1 pyhd3eb1b0_0", + "backcall 0.2.0 py_0", + "backports 1.0 py_2", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "beautifulsoup4 4.9.3 pyhb0f4dca_0", + "bitarray 1.6.1 py37h27cfd23_0", + "bkcharts 0.2 py37_0", + "blas 1.0 mkl", + "bleach 3.2.1 py_0", + "blosc 1.20.1 hd408876_0", + "bokeh 2.2.3 py37_0", + "boto 2.49.0 py37_0", + "bottleneck 1.3.2 py37heb32a55_1", + "brotlipy 0.7.0 py37h7b6447c_1000", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2020.10.14 0", + "cairo 1.14.12 h8948797_3", + "certifi 2020.6.20 pyhd3eb1b0_3", + "cffi 1.14.3 py37he30daa8_0", + "chardet 3.0.4 py37_1003", + "click 7.1.2 py_0", + "cloudpickle 1.6.0 py_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.4 py_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 3.1.1 py37h1ba5d50_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py37_0", + "cython 0.29.21 py37he6710b0_0", + "cytoolz 0.11.0 py37h7b6447c_0", + "dask 2.30.0 py_0", + "dask-core 2.30.0 py_0", + "dbus 1.13.18 hb2f20db_0", + "decorator 4.4.2 py_0", + "defusedxml 0.6.0 py_0", + "diff-match-patch 20200713 py_0", + "distributed 2.30.1 py37h06a4308_0", + "docutils 0.16 py37_1", + "entrypoints 0.3 py37_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.2.10 he6710b0_2", + "fastcache 1.1.0 py37h7b6447c_0", + "filelock 3.0.12 py_0", + "flake8 3.8.4 py_0", + "flask 1.1.2 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 0.8.3 py_0", + "future 0.18.2 py37_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 20.9.0 py37h7b6447c_0", + "glib 2.66.1 h92f7085_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.14 h23475e2_0", + "greenlet 0.4.17 py37h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb31296c_0", + "h5py 2.10.0 py37h7918eee_0", + "harfbuzz 2.4.0 hca77d97_1", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 py_0", + "imageio 2.9.0 py_0", + "imagesize 1.2.0 py_0", + "importlib-metadata 2.0.0 py_1", + "importlib_metadata 2.0.0 1", + "iniconfig 1.1.1 py_0", + "intel-openmp 2020.2 254", + "intervaltree 3.1.0 py_0", + "ipykernel 5.3.4 py37h5ca1d4c_0", + "ipython 7.19.0 py37hb070fc8_0", + "ipython_genutils 0.2.0 py37_0", + "ipywidgets 7.5.1 py_1", + "isort 5.6.4 py_0", + "itsdangerous 1.1.0 py37_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.1 py37_0", + "jeepney 0.5.0 pyhd3eb1b0_0", + "jinja2 2.11.2 py_0", + "joblib 0.17.0 py_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py_2", + "jupyter 1.0.0 py37_7", + "jupyter_client 6.1.7 py_0", + "jupyter_console 6.2.0 py_0", + "jupyter_core 4.6.3 py37_0", + "jupyterlab 2.2.6 py_0", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 1.2.0 py_0", + "keyring 21.4.0 py37_1", + "kiwisolver 1.3.0 py37h2531618_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.4.3 py37h7b6447c_0", + "lcms2 2.11 h396b838_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libedit 3.1.20191231 h14c3975_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 he6710b0_0", + "libllvm10 10.0.1 hbcb73fb_5", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 he6710b0_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_1", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 hb55368b_3", + "libxslt 1.1.34 hc22bd24_0", + "llvmlite 0.34.0 py37h269e1b5_4", + "locket 0.2.0 py37_1", + "lxml 4.6.1 py37hefd8a0e_0", + "lz4-c 1.9.2 heb0550a_3", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py37h14c3975_1", + "matplotlib 3.3.2 0", + "matplotlib-base 3.3.2 py37h817c723_0", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h14c3975_1001", + "mkl 2020.2 256", + "mkl-service 2.3.0 py37he904b0f_0", + "mkl_fft 1.2.0 py37h23d657b_0", + "mkl_random 1.1.1 py37h0573a6f_0", + "mock 4.0.2 py_0", + "more-itertools 8.6.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.1.0 py37_0", + "msgpack-python 1.0.0 py37hfd86e86_1", + "multipledispatch 0.6.0 py37_0", + "nbclient 0.5.1 py_0", + "nbconvert 6.0.7 py37_0", + "nbformat 5.0.8 py_0", + "ncurses 6.2 he6710b0_1", + "nest-asyncio 1.4.2 pyhd3eb1b0_0", + "networkx 2.5 py_0", + "nltk 3.5 py_0", + "nose 1.3.7 py37_1004", + "notebook 6.1.4 py37_0", + "numba 0.51.2 py37h04863e7_1", + "numexpr 2.7.1 py37h423224d_0", + "numpy 1.19.2 py37h54aff64_0", + "numpy-base 1.19.2 py37hfa32c7d_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 py37_0", + "openpyxl 3.0.5 py_0", + "openssl 1.1.1h h7b6447c_0", + "packaging 20.4 py_0", + "pandas 1.1.3 py37he6710b0_0", + "pandoc 2.11 hb0f4dca_0", + "pandocfilters 1.4.3 py37h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.1.0 py_0", + "patchelf 0.12 he6710b0_0", + "path 15.0.0 py37_0", + "path.py 12.5.0 0", + "pathlib2 2.3.5 py37_1", + "pathtools 0.1.2 py_1", + "patsy 0.5.1 py37_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py37_0", + "pexpect 4.8.0 py37_1", + "pickleshare 0.7.5 py37_1001", + "pillow 8.0.1 py37he98fc37_0", + "pip 20.2.4 py37h06a4308_0", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.6.1 py37h06a4308_0", + "pluggy 0.13.1 py37_0", + "ply 3.11 py37_0", + "prometheus_client 0.8.0 py_0", + "prompt-toolkit 3.0.8 py_0", + "prompt_toolkit 3.0.8 0", + "psutil 5.7.2 py37h7b6447c_0", + "ptyprocess 0.6.0 py37_0", + "py 1.9.0 py_0", + "py-lief 0.10.1 py37h403a769_0", + "pycodestyle 2.6.0 py_0", + "pycosat 0.6.3 py37h7b6447c_0", + "pycparser 2.20 py_2", + "pycrypto 2.6.1 py37h7b6447c_10", + "pycurl 7.43.0.6 py37h1ba5d50_0", + "pydocstyle 5.1.1 py_0", + "pyflakes 2.2.0 py_0", + "pygments 2.7.2 pyhd3eb1b0_0", + "pylint 2.6.0 py37_0", + "pyodbc 4.0.30 py37he6710b0_0", + "pyopenssl 19.1.0 py_1", + "pyparsing 2.4.7 py_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.17.3 py37h7b6447c_0", + "pysocks 1.7.1 py37_1", + "pytables 3.6.1 py37h71ec239_0", + "pytest 6.1.1 py37_0", + "python 3.7.9 h7579374_0", + "python-dateutil 2.8.1 py_0", + "python-jsonrpc-server 0.4.0 py_0", + "python-language-server 0.35.1 py_0", + "python-libarchive-c 2.9 py_0", + "pytz 2020.1 py_0", + "pywavelets 1.1.1 py37h7b6447c_2", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 5.3.1 py37h7b6447c_1", + "pyzmq 19.0.2 py37he6710b0_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.1 py_0", + "qtconsole 4.7.7 py_0", + "qtpy 1.9.0 py_0", + "readline 8.0 h7b6447c_0", + "regex 2020.10.15 py37h7b6447c_0", + "requests 2.24.0 py_0", + "ripgrep 12.1.1 0", + "rope 0.18.0 py_0", + "rtree 0.9.4 py37_1", + "ruamel_yaml 0.15.87 py37h7b6447c_1", + "scikit-image 0.17.2 py37hdf5156a_0", + "scikit-learn 0.23.2 py37h0573a6f_0", + "scipy 1.5.2 py37h0b6359f_0", + "seaborn 0.11.0 py_0", + "secretstorage 3.1.2 py37_1", + "send2trash 1.5.0 py37_0", + "setuptools 50.3.1 py37h06a4308_1", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.4.0.3 py_1001", + "sip 4.19.8 py37hf484d3e_0", + "six 1.15.0 py37h06a4308_0", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.2.1 py_0", + "sortedcontainers 2.2.2 py_0", + "soupsieve 2.0.1 py_0", + "sphinx 3.2.1 py_0", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-applehelp 1.0.2 py_0", + "sphinxcontrib-devhelp 1.0.2 py_0", + "sphinxcontrib-htmlhelp 1.0.3 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.3 py_0", + "sphinxcontrib-serializinghtml 1.1.4 py_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 4.1.5 py37_0", + "spyder-kernels 1.9.4 py37_0", + "sqlalchemy 1.3.20 py37h27cfd23_0", + "sqlite 3.33.0 h62c20be_0", + "statsmodels 0.12.0 py37h7b6447c_0", + "sympy 1.6.2 py37h06a4308_1", + "tbb 2020.3 hfd86e86_0", + "tblib 1.7.0 py_0", + "terminado 0.9.1 py37_0", + "testpath 0.4.4 py_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "tifffile 2020.10.1 py37hdd07704_2", + "tk 8.6.10 hbc83047_0", + "toml 0.10.1 py_0", + "toolz 0.11.1 py_0", + "tornado 6.0.4 py37h7b6447c_1", + "tqdm 4.50.2 py_0", + "traitlets 5.0.5 py_0", + "typed-ast 1.4.1 py37h7b6447c_0", + "typing_extensions 3.7.4.3 py_0", + "ujson 4.0.1 py37he6710b0_0", + "unicodecsv 0.14.1 py37_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.25.11 py_0", + "watchdog 0.10.3 py37_0", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py37_1", + "werkzeug 1.0.1 py_0", + "wheel 0.35.1 py_0", + "widgetsnbextension 3.5.1 py37_0", + "wrapt 1.11.2 py37h7b6447c_0", + "wurlitzer 2.0.1 py37_0", + "xlrd 1.2.0 py37_0", + "xlsxwriter 1.3.7 py_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.30.0 py_0", + "zeromq 4.3.3 he6710b0_3", + "zict 2.0.0 py_0", + "zipp 3.4.0 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py37_1", + "zope.event 4.5.0 py37_0", + "zope.interface 5.1.2 py37h7b6447c_0", + "zstd 1.4.5 h9ceee32_0" + ], + "license": "BSD", + "md5": "9d6ebd5393d8b5ae28b19f87fde590b1", + "name": "anaconda", + "namespace": "python", + "sha256": "7264cf5ae3602e3c9f27ca64660661ce112e9ee35b770af8310fff3556824193", + "size": 14561, + "subdir": "linux-64", + "timestamp": 1605289428528, + "version": "2020.11" + }, + "anaconda-2020.11-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py_0", + "anaconda-client 1.7.2 py38_0", + "anaconda-project 0.8.4 py_0", + "argh 0.26.2 py38_0", + "argon2-cffi 20.1.0 py38h7b6447c_1", + "asn1crypto 1.4.0 py_0", + "astroid 2.4.2 py38_0", + "astropy 4.0.2 py38h7b6447c_0", + "async_generator 1.10 py_0", + "atomicwrites 1.4.0 py_0", + "attrs 20.3.0 pyhd3eb1b0_0", + "autopep8 1.5.4 py_0", + "babel 2.8.1 pyhd3eb1b0_0", + "backcall 0.2.0 py_0", + "backports 1.0 py_2", + "backports.shutil_get_terminal_size 1.0.0 py38_2", + "beautifulsoup4 4.9.3 pyhb0f4dca_0", + "bitarray 1.6.1 py38h27cfd23_0", + "bkcharts 0.2 py38_0", + "blas 1.0 mkl", + "bleach 3.2.1 py_0", + "blosc 1.20.1 hd408876_0", + "bokeh 2.2.3 py38_0", + "boto 2.49.0 py38_0", + "bottleneck 1.3.2 py38heb32a55_1", + "brotlipy 0.7.0 py38h7b6447c_1000", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2020.10.14 0", + "cairo 1.14.12 h8948797_3", + "certifi 2020.6.20 pyhd3eb1b0_3", + "cffi 1.14.3 py38he30daa8_0", + "chardet 3.0.4 py38_1003", + "click 7.1.2 py_0", + "cloudpickle 1.6.0 py_0", + "clyent 1.2.2 py38_1", + "colorama 0.4.4 py_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 3.1.1 py38h1ba5d50_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py38_0", + "cython 0.29.21 py38he6710b0_0", + "cytoolz 0.11.0 py38h7b6447c_0", + "dask 2.30.0 py_0", + "dask-core 2.30.0 py_0", + "dbus 1.13.18 hb2f20db_0", + "decorator 4.4.2 py_0", + "defusedxml 0.6.0 py_0", + "diff-match-patch 20200713 py_0", + "distributed 2.30.1 py38h06a4308_0", + "docutils 0.16 py38_1", + "entrypoints 0.3 py38_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.2.10 he6710b0_2", + "fastcache 1.1.0 py38h7b6447c_0", + "filelock 3.0.12 py_0", + "flake8 3.8.4 py_0", + "flask 1.1.2 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 0.8.3 py_0", + "future 0.18.2 py38_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 20.9.0 py38h7b6447c_0", + "glib 2.66.1 h92f7085_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py38hd5f6e3b_3", + "graphite2 1.3.14 h23475e2_0", + "greenlet 0.4.17 py38h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb31296c_0", + "h5py 2.10.0 py38h7918eee_0", + "harfbuzz 2.4.0 hca77d97_1", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 py_0", + "imageio 2.9.0 py_0", + "imagesize 1.2.0 py_0", + "importlib-metadata 2.0.0 py_1", + "importlib_metadata 2.0.0 1", + "iniconfig 1.1.1 py_0", + "intel-openmp 2020.2 254", + "intervaltree 3.1.0 py_0", + "ipykernel 5.3.4 py38h5ca1d4c_0", + "ipython 7.19.0 py38hb070fc8_0", + "ipython_genutils 0.2.0 py38_0", + "ipywidgets 7.5.1 py_1", + "isort 5.6.4 py_0", + "itsdangerous 1.1.0 py_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.1 py38_0", + "jeepney 0.5.0 pyhd3eb1b0_0", + "jinja2 2.11.2 py_0", + "joblib 0.17.0 py_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py_2", + "jupyter 1.0.0 py38_7", + "jupyter_client 6.1.7 py_0", + "jupyter_console 6.2.0 py_0", + "jupyter_core 4.6.3 py38_0", + "jupyterlab 2.2.6 py_0", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 1.2.0 py_0", + "keyring 21.4.0 py38_1", + "kiwisolver 1.3.0 py38h2531618_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.4.3 py38h7b6447c_0", + "lcms2 2.11 h396b838_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libedit 3.1.20191231 h14c3975_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 he6710b0_0", + "libllvm10 10.0.1 hbcb73fb_5", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 he6710b0_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_1", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 hb55368b_3", + "libxslt 1.1.34 hc22bd24_0", + "llvmlite 0.34.0 py38h269e1b5_4", + "locket 0.2.0 py38_1", + "lxml 4.6.1 py38hefd8a0e_0", + "lz4-c 1.9.2 heb0550a_3", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py38h7b6447c_0", + "matplotlib 3.3.2 0", + "matplotlib-base 3.3.2 py38h817c723_0", + "mccabe 0.6.1 py38_1", + "mistune 0.8.4 py38h7b6447c_1000", + "mkl 2020.2 256", + "mkl-service 2.3.0 py38he904b0f_0", + "mkl_fft 1.2.0 py38h23d657b_0", + "mkl_random 1.1.1 py38h0573a6f_0", + "mock 4.0.2 py_0", + "more-itertools 8.6.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.1.0 py38_0", + "msgpack-python 1.0.0 py38hfd86e86_1", + "multipledispatch 0.6.0 py38_0", + "nbclient 0.5.1 py_0", + "nbconvert 6.0.7 py38_0", + "nbformat 5.0.8 py_0", + "ncurses 6.2 he6710b0_1", + "nest-asyncio 1.4.2 pyhd3eb1b0_0", + "networkx 2.5 py_0", + "nltk 3.5 py_0", + "nose 1.3.7 py38_2", + "notebook 6.1.4 py38_0", + "numba 0.51.2 py38h0573a6f_1", + "numexpr 2.7.1 py38h423224d_0", + "numpy 1.19.2 py38h54aff64_0", + "numpy-base 1.19.2 py38hfa32c7d_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 py_0", + "openpyxl 3.0.5 py_0", + "openssl 1.1.1h h7b6447c_0", + "packaging 20.4 py_0", + "pandas 1.1.3 py38he6710b0_0", + "pandoc 2.11 hb0f4dca_0", + "pandocfilters 1.4.3 py38h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.1.0 py_0", + "patchelf 0.12 he6710b0_0", + "path 15.0.0 py38_0", + "path.py 12.5.0 0", + "pathlib2 2.3.5 py38_0", + "pathtools 0.1.2 py_1", + "patsy 0.5.1 py38_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py38_0", + "pexpect 4.8.0 py38_0", + "pickleshare 0.7.5 py38_1000", + "pillow 8.0.1 py38he98fc37_0", + "pip 20.2.4 py38h06a4308_0", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.6.1 py38h06a4308_0", + "pluggy 0.13.1 py38_0", + "ply 3.11 py38_0", + "prometheus_client 0.8.0 py_0", + "prompt-toolkit 3.0.8 py_0", + "prompt_toolkit 3.0.8 0", + "psutil 5.7.2 py38h7b6447c_0", + "ptyprocess 0.6.0 py38_0", + "py 1.9.0 py_0", + "py-lief 0.10.1 py38h403a769_0", + "pycodestyle 2.6.0 py_0", + "pycosat 0.6.3 py38h7b6447c_1", + "pycparser 2.20 py_2", + "pycurl 7.43.0.6 py38h1ba5d50_0", + "pydocstyle 5.1.1 py_0", + "pyflakes 2.2.0 py_0", + "pygments 2.7.2 pyhd3eb1b0_0", + "pylint 2.6.0 py38_0", + "pyodbc 4.0.30 py38he6710b0_0", + "pyopenssl 19.1.0 py_1", + "pyparsing 2.4.7 py_0", + "pyqt 5.9.2 py38h05f1152_4", + "pyrsistent 0.17.3 py38h7b6447c_0", + "pysocks 1.7.1 py38_0", + "pytables 3.6.1 py38h9fd0a39_0", + "pytest 6.1.1 py38_0", + "python 3.8.5 h7579374_1", + "python-dateutil 2.8.1 py_0", + "python-jsonrpc-server 0.4.0 py_0", + "python-language-server 0.35.1 py_0", + "python-libarchive-c 2.9 py_0", + "pytz 2020.1 py_0", + "pywavelets 1.1.1 py38h7b6447c_2", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 5.3.1 py38h7b6447c_1", + "pyzmq 19.0.2 py38he6710b0_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.1 py_0", + "qtconsole 4.7.7 py_0", + "qtpy 1.9.0 py_0", + "readline 8.0 h7b6447c_0", + "regex 2020.10.15 py38h7b6447c_0", + "requests 2.24.0 py_0", + "ripgrep 12.1.1 0", + "rope 0.18.0 py_0", + "rtree 0.9.4 py38_1", + "ruamel_yaml 0.15.87 py38h7b6447c_1", + "scikit-image 0.17.2 py38hdf5156a_0", + "scikit-learn 0.23.2 py38h0573a6f_0", + "scipy 1.5.2 py38h0b6359f_0", + "seaborn 0.11.0 py_0", + "secretstorage 3.1.2 py38_0", + "send2trash 1.5.0 py38_0", + "setuptools 50.3.1 py38h06a4308_1", + "simplegeneric 0.8.1 py38_2", + "singledispatch 3.4.0.3 py_1001", + "sip 4.19.13 py38he6710b0_0", + "six 1.15.0 py38h06a4308_0", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.2.1 py_0", + "sortedcontainers 2.2.2 py_0", + "soupsieve 2.0.1 py_0", + "sphinx 3.2.1 py_0", + "sphinxcontrib 1.0 py38_1", + "sphinxcontrib-applehelp 1.0.2 py_0", + "sphinxcontrib-devhelp 1.0.2 py_0", + "sphinxcontrib-htmlhelp 1.0.3 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.3 py_0", + "sphinxcontrib-serializinghtml 1.1.4 py_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 4.1.5 py38_0", + "spyder-kernels 1.9.4 py38_0", + "sqlalchemy 1.3.20 py38h7b6447c_0", + "sqlite 3.33.0 h62c20be_0", + "statsmodels 0.12.0 py38h7b6447c_0", + "sympy 1.6.2 py38h06a4308_1", + "tbb 2020.3 hfd86e86_0", + "tblib 1.7.0 py_0", + "terminado 0.9.1 py38_0", + "testpath 0.4.4 py_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "tifffile 2020.10.1 py38hdd07704_2", + "tk 8.6.10 hbc83047_0", + "toml 0.10.1 py_0", + "toolz 0.11.1 py_0", + "tornado 6.0.4 py38h7b6447c_1", + "tqdm 4.50.2 py_0", + "traitlets 5.0.5 py_0", + "typing_extensions 3.7.4.3 py_0", + "ujson 4.0.1 py38he6710b0_0", + "unicodecsv 0.14.1 py38_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.25.11 py_0", + "watchdog 0.10.3 py38_0", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py38_1", + "werkzeug 1.0.1 py_0", + "wheel 0.35.1 py_0", + "widgetsnbextension 3.5.1 py38_0", + "wrapt 1.11.2 py38h7b6447c_0", + "wurlitzer 2.0.1 py38_0", + "xlrd 1.2.0 py_0", + "xlsxwriter 1.3.7 py_0", + "xlwt 1.3.0 py38_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.30.0 py_0", + "zeromq 4.3.3 he6710b0_3", + "zict 2.0.0 py_0", + "zipp 3.4.0 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py38_1", + "zope.event 4.5.0 py38_0", + "zope.interface 5.1.2 py38h7b6447c_0", + "zstd 1.4.5 h9ceee32_0" + ], + "license": "BSD", + "md5": "a151557b4af2362c5fde9ebaa5167629", + "name": "anaconda", + "namespace": "python", + "sha256": "0701098e2c0b6511609cabf4f74e85d15ff9addbb3621ce32987ab40ebf308b3", + "size": 14494, + "subdir": "linux-64", + "timestamp": 1605289363851, + "version": "2020.11" + }, + "anaconda-2021.04-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.7.2 py37_0", + "anaconda-project 0.9.1 pyhd3eb1b0_1", + "anyio 2.2.0 py37h06a4308_1", + "appdirs 1.4.4 py_0", + "argh 0.26.2 py37_0", + "argon2-cffi 20.1.0 py37h27cfd23_1", + "asn1crypto 1.4.0 py_0", + "astroid 2.5 py37h06a4308_1", + "astropy 4.2.1 py37h27cfd23_1", + "async_generator 1.10 py37h28b3542_0", + "atomicwrites 1.4.0 py_0", + "attrs 20.3.0 pyhd3eb1b0_0", + "autopep8 1.5.6 pyhd3eb1b0_0", + "babel 2.9.0 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.0 pyhd3eb1b0_2", + "backports.shutil_get_terminal_size 1.0.0 pyhd3eb1b0_3", + "beautifulsoup4 4.9.3 pyha847dfd_0", + "bitarray 1.9.2 py37h27cfd23_1", + "bkcharts 0.2 py37_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 3.3.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.3.1 py37h06a4308_0", + "boto 2.49.0 py37_0", + "bottleneck 1.3.2 py37heb32a55_1", + "brotlipy 0.7.0 py37h27cfd23_1003", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.17.1 h27cfd23_0", + "ca-certificates 2021.4.13 h06a4308_1", + "cairo 1.16.0 hf32fb01_1", + "certifi 2020.12.5 py37h06a4308_0", + "cffi 1.14.5 py37h261ae71_0", + "chardet 4.0.0 py37h06a4308_1003", + "click 7.1.2 pyhd3eb1b0_0", + "cloudpickle 1.6.0 py_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 3.4.7 py37hd23ed53_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py37_0", + "cython 0.29.23 py37h2531618_0", + "cytoolz 0.11.0 py37h7b6447c_0", + "dask 2021.4.0 pyhd3eb1b0_0", + "dask-core 2021.4.0 pyhd3eb1b0_0", + "dbus 1.13.18 hb2f20db_0", + "decorator 5.0.6 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 py_0", + "distributed 2021.4.0 py37h06a4308_0", + "docutils 0.17 py37h06a4308_1", + "entrypoints 0.3 py37_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.3.0 h2531618_2", + "fastcache 1.1.0 py37h7b6447c_0", + "filelock 3.0.12 pyhd3eb1b0_1", + "flake8 3.9.0 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 0.9.0 pyhd3eb1b0_0", + "future 0.18.2 py37_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 21.1.2 py37h27cfd23_1", + "glib 2.68.1 h36276a3_0", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.14 h23475e2_0", + "greenlet 1.0.0 py37h2531618_2", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py37h7918eee_0", + "harfbuzz 2.8.0 h6f93f22_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 pyhd3eb1b0_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.2.0 pyhd3eb1b0_0", + "importlib-metadata 3.10.0 py37h06a4308_0", + "importlib_metadata 3.10.0 hd3eb1b0_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intel-openmp 2021.2.0 h06a4308_610", + "intervaltree 3.1.0 py_0", + "ipykernel 5.3.4 py37h5ca1d4c_0", + "ipython 7.22.0 py37hb070fc8_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.3 pyhd3eb1b0_1", + "isort 5.8.0 pyhd3eb1b0_0", + "itsdangerous 1.1.0 py37_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.2 py37h06a4308_1", + "jeepney 0.6.0 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "joblib 1.0.1 pyhd3eb1b0_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py_2", + "jupyter 1.0.0 py37_7", + "jupyter-packaging 0.7.12 pyhd3eb1b0_0", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.7.1 py37h06a4308_0", + "jupyter_server 1.4.1 py37h06a4308_0", + "jupyterlab 3.0.14 pyhd3eb1b0_1", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.4.0 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "keyring 22.3.0 py37h06a4308_0", + "kiwisolver 1.3.1 py37h2531618_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.6.0 py37h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libedit 3.1.20210216 h27cfd23_1", + "libev 4.33 h7b6447c_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 he6710b0_0", + "libllvm10 10.0.1 hbcb73fb_5", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.2.0 h85742a9_0", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h1bed415_2", + "libuv 1.40.0 h7b6447c_0", + "libwebp-base 1.2.0 h27cfd23_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 hb55368b_3", + "libxslt 1.1.34 hc22bd24_0", + "llvmlite 0.36.0 py37h612dafd_4", + "locket 0.2.1 py37h06a4308_1", + "lxml 4.6.3 py37h9120a33_0", + "lz4-c 1.9.3 h2531618_0", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py37h14c3975_1", + "matplotlib 3.3.4 py37h06a4308_0", + "matplotlib-base 3.3.4 py37h62a2d02_0", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h14c3975_1001", + "mkl 2021.2.0 h06a4308_296", + "mkl-service 2.3.0 py37h27cfd23_1", + "mkl_fft 1.3.0 py37h42c9631_2", + "mkl_random 1.2.1 py37ha9443f7_2", + "mock 4.0.3 pyhd3eb1b0_0", + "more-itertools 8.7.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.2.1 py37h06a4308_0", + "msgpack-python 1.0.2 py37hff7bd54_1", + "multipledispatch 0.6.0 py37_0", + "mypy_extensions 0.4.3 py37_0", + "nbclassic 0.2.6 pyhd3eb1b0_0", + "nbclient 0.5.3 pyhd3eb1b0_0", + "nbconvert 6.0.7 py37_0", + "nbformat 5.1.3 pyhd3eb1b0_0", + "ncurses 6.2 he6710b0_1", + "nest-asyncio 1.5.1 pyhd3eb1b0_0", + "networkx 2.5 py_0", + "nltk 3.6.1 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1006", + "notebook 6.3.0 py37h06a4308_0", + "numexpr 2.7.3 py37h22e1b3c_1", + "numpy 1.20.1 py37h93e21f0_0", + "numpy-base 1.20.1 py37h7d8b39e_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 py37_0", + "openpyxl 3.0.7 pyhd3eb1b0_0", + "openssl 1.1.1k h27cfd23_0", + "packaging 20.9 pyhd3eb1b0_0", + "pandas 1.2.4 py37h2531618_0", + "pandoc 2.12 h06a4308_0", + "pandocfilters 1.4.3 py37h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.2.0 pyhd3eb1b0_0", + "patchelf 0.12 h2531618_1", + "path 15.1.2 py37h06a4308_0", + "path.py 12.5.0 0", + "pathlib2 2.3.5 py37h06a4308_2", + "pathspec 0.7.0 py_0", + "patsy 0.5.1 py37_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py37_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 8.2.0 py37he98fc37_0", + "pip 21.0.1 py37h06a4308_0", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.7.0 py37h06a4308_0", + "pluggy 0.13.1 py37h06a4308_0", + "ply 3.11 py37_0", + "prometheus_client 0.10.1 pyhd3eb1b0_0", + "prompt-toolkit 3.0.17 pyh06a4308_0", + "prompt_toolkit 3.0.17 hd3eb1b0_0", + "psutil 5.8.0 py37h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.10.0 pyhd3eb1b0_0", + "py-lief 0.10.1 py37h403a769_0", + "pycodestyle 2.6.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py37h27cfd23_0", + "pycparser 2.20 py_2", + "pycrypto 2.6.1 py37h7b6447c_10", + "pycurl 7.43.0.6 py37h1ba5d50_0", + "pydocstyle 6.0.0 pyhd3eb1b0_0", + "pyerfa 1.7.3 py37h27cfd23_0", + "pyflakes 2.2.0 pyhd3eb1b0_0", + "pygments 2.8.1 pyhd3eb1b0_0", + "pylint 2.7.4 py37h06a4308_1", + "pyls-black 0.4.6 hd3eb1b0_0", + "pyls-spyder 0.3.2 pyhd3eb1b0_0", + "pyodbc 4.0.30 py37he6710b0_0", + "pyopenssl 20.0.1 pyhd3eb1b0_1", + "pyparsing 2.4.7 pyhd3eb1b0_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.17.3 py37h7b6447c_0", + "pysocks 1.7.1 py37_1", + "pytables 3.6.1 py37h71ec239_0", + "pytest 6.2.3 py37h06a4308_2", + "python 3.7.10 hdb3f193_0", + "python-dateutil 2.8.1 pyhd3eb1b0_0", + "python-jsonrpc-server 0.4.0 py_0", + "python-language-server 0.36.2 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "pytz 2021.1 pyhd3eb1b0_0", + "pywavelets 1.1.1 py37h7b6447c_2", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 5.4.1 py37h27cfd23_1", + "pyzmq 20.0.0 py37h2531618_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.2 pyhd3eb1b0_0", + "qtconsole 5.0.3 pyhd3eb1b0_0", + "qtpy 1.9.0 py_0", + "readline 8.1 h27cfd23_0", + "regex 2021.4.4 py37h27cfd23_0", + "requests 2.25.1 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.18.0 py_0", + "rtree 0.9.7 py37h06a4308_1", + "ruamel_yaml 0.15.100 py37h27cfd23_0", + "scikit-image 0.18.1 py37ha9443f7_0", + "scikit-learn 0.24.1 py37ha9443f7_0", + "scipy 1.6.2 py37had2a1c9_1", + "seaborn 0.11.1 pyhd3eb1b0_0", + "secretstorage 3.3.1 py37h06a4308_0", + "send2trash 1.5.0 pyhd3eb1b0_1", + "setuptools 52.0.0 py37h06a4308_0", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.6.1 pyhd3eb1b0_1001", + "sip 4.19.8 py37hf484d3e_0", + "six 1.15.0 py37h06a4308_0", + "sniffio 1.2.0 py37h06a4308_1", + "snowballstemmer 2.1.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.3.0 pyhd3eb1b0_0", + "soupsieve 2.2.1 pyhd3eb1b0_0", + "sphinx 3.5.3 pyhd3eb1b0_0", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.4 pyhd3eb1b0_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 4.2.5 py37h06a4308_0", + "spyder-kernels 1.10.2 py37h06a4308_0", + "sqlalchemy 1.4.7 py37h27cfd23_0", + "sqlite 3.35.4 hdfb4753_0", + "statsmodels 0.12.2 py37h27cfd23_0", + "sympy 1.8 py37h06a4308_0", + "tblib 1.7.0 py_0", + "terminado 0.9.4 py37h06a4308_0", + "testpath 0.4.4 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2020.10.1 py37hdd07704_2", + "tk 8.6.10 hbc83047_0", + "toml 0.10.2 pyhd3eb1b0_0", + "toolz 0.11.1 pyhd3eb1b0_0", + "tornado 6.1 py37h27cfd23_0", + "tqdm 4.59.0 pyhd3eb1b0_1", + "traitlets 5.0.5 pyhd3eb1b0_0", + "typed-ast 1.4.2 py37h27cfd23_1", + "typing_extensions 3.7.4.3 pyha847dfd_0", + "ujson 4.0.2 py37h2531618_0", + "unicodecsv 0.14.1 py37_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.4 pyhd3eb1b0_0", + "watchdog 1.0.2 py37h06a4308_1", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py37_1", + "werkzeug 1.0.1 pyhd3eb1b0_0", + "wheel 0.36.2 pyhd3eb1b0_0", + "widgetsnbextension 3.5.1 py37_0", + "wrapt 1.12.1 py37h7b6447c_1", + "wurlitzer 2.1.0 py37h06a4308_0", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 1.3.8 pyhd3eb1b0_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.4.1 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py37_1", + "zope.event 4.5.0 py37_0", + "zope.interface 5.3.0 py37h27cfd23_0", + "zstd 1.4.5 h9ceee32_0" + ], + "license": "BSD", + "md5": "00ab977546993bd64d2e09017a5511e4", + "name": "anaconda", + "namespace": "python", + "sha256": "8a1b002652be6bfba994d7a0f55f88bf44b0c323f3f4871f5a1de0383cff8d38", + "size": 14213, + "subdir": "linux-64", + "timestamp": 1620769972566, + "version": "2021.04" + }, + "anaconda-2021.04-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.7.2 py38_0", + "anaconda-project 0.9.1 pyhd3eb1b0_1", + "anyio 2.2.0 py38h06a4308_1", + "appdirs 1.4.4 py_0", + "argh 0.26.2 py38_0", + "argon2-cffi 20.1.0 py38h27cfd23_1", + "asn1crypto 1.4.0 py_0", + "astroid 2.5 py38h06a4308_1", + "astropy 4.2.1 py38h27cfd23_1", + "async_generator 1.10 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 20.3.0 pyhd3eb1b0_0", + "autopep8 1.5.6 pyhd3eb1b0_0", + "babel 2.9.0 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.0 pyhd3eb1b0_2", + "backports.shutil_get_terminal_size 1.0.0 pyhd3eb1b0_3", + "beautifulsoup4 4.9.3 pyha847dfd_0", + "bitarray 1.9.2 py38h27cfd23_1", + "bkcharts 0.2 py38_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 3.3.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.3.1 py38h06a4308_0", + "boto 2.49.0 py38_0", + "bottleneck 1.3.2 py38heb32a55_1", + "brotlipy 0.7.0 py38h27cfd23_1003", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.17.1 h27cfd23_0", + "ca-certificates 2021.4.13 h06a4308_1", + "cairo 1.16.0 hf32fb01_1", + "certifi 2020.12.5 py38h06a4308_0", + "cffi 1.14.5 py38h261ae71_0", + "chardet 4.0.0 py38h06a4308_1003", + "click 7.1.2 pyhd3eb1b0_0", + "cloudpickle 1.6.0 py_0", + "clyent 1.2.2 py38_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 3.4.7 py38hd23ed53_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py38_0", + "cython 0.29.23 py38h2531618_0", + "cytoolz 0.11.0 py38h7b6447c_0", + "dask 2021.4.0 pyhd3eb1b0_0", + "dask-core 2021.4.0 pyhd3eb1b0_0", + "dbus 1.13.18 hb2f20db_0", + "decorator 5.0.6 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 py_0", + "distributed 2021.4.0 py38h06a4308_0", + "docutils 0.17 py38h06a4308_1", + "entrypoints 0.3 py38_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.3.0 h2531618_2", + "fastcache 1.1.0 py38h7b6447c_0", + "filelock 3.0.12 pyhd3eb1b0_1", + "flake8 3.9.0 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 0.9.0 pyhd3eb1b0_0", + "future 0.18.2 py38_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 21.1.2 py38h27cfd23_1", + "glib 2.68.1 h36276a3_0", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.0.8 py38hd5f6e3b_3", + "graphite2 1.3.14 h23475e2_0", + "greenlet 1.0.0 py38h2531618_2", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py38h7918eee_0", + "harfbuzz 2.8.0 h6f93f22_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 pyhd3eb1b0_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.2.0 pyhd3eb1b0_0", + "importlib-metadata 3.10.0 py38h06a4308_0", + "importlib_metadata 3.10.0 hd3eb1b0_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intel-openmp 2021.2.0 h06a4308_610", + "intervaltree 3.1.0 py_0", + "ipykernel 5.3.4 py38h5ca1d4c_0", + "ipython 7.22.0 py38hb070fc8_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.3 pyhd3eb1b0_1", + "isort 5.8.0 pyhd3eb1b0_0", + "itsdangerous 1.1.0 pyhd3eb1b0_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.2 py38h06a4308_1", + "jeepney 0.6.0 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "joblib 1.0.1 pyhd3eb1b0_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py_2", + "jupyter 1.0.0 py38_7", + "jupyter-packaging 0.7.12 pyhd3eb1b0_0", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.7.1 py38h06a4308_0", + "jupyter_server 1.4.1 py38h06a4308_0", + "jupyterlab 3.0.14 pyhd3eb1b0_1", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.4.0 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "keyring 22.3.0 py38h06a4308_0", + "kiwisolver 1.3.1 py38h2531618_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.6.0 py38h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libedit 3.1.20210216 h27cfd23_1", + "libev 4.33 h7b6447c_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 he6710b0_0", + "libllvm10 10.0.1 hbcb73fb_5", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.2.0 h85742a9_0", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h1bed415_2", + "libuv 1.40.0 h7b6447c_0", + "libwebp-base 1.2.0 h27cfd23_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 hb55368b_3", + "libxslt 1.1.34 hc22bd24_0", + "llvmlite 0.36.0 py38h612dafd_4", + "locket 0.2.1 py38h06a4308_1", + "lxml 4.6.3 py38h9120a33_0", + "lz4-c 1.9.3 h2531618_0", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py38h7b6447c_0", + "matplotlib 3.3.4 py38h06a4308_0", + "matplotlib-base 3.3.4 py38h62a2d02_0", + "mccabe 0.6.1 py38_1", + "mistune 0.8.4 py38h7b6447c_1000", + "mkl 2021.2.0 h06a4308_296", + "mkl-service 2.3.0 py38h27cfd23_1", + "mkl_fft 1.3.0 py38h42c9631_2", + "mkl_random 1.2.1 py38ha9443f7_2", + "mock 4.0.3 pyhd3eb1b0_0", + "more-itertools 8.7.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.2.1 py38h06a4308_0", + "msgpack-python 1.0.2 py38hff7bd54_1", + "multipledispatch 0.6.0 py38_0", + "mypy_extensions 0.4.3 py38_0", + "nbclassic 0.2.6 pyhd3eb1b0_0", + "nbclient 0.5.3 pyhd3eb1b0_0", + "nbconvert 6.0.7 py38_0", + "nbformat 5.1.3 pyhd3eb1b0_0", + "ncurses 6.2 he6710b0_1", + "nest-asyncio 1.5.1 pyhd3eb1b0_0", + "networkx 2.5 py_0", + "nltk 3.6.1 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1006", + "notebook 6.3.0 py38h06a4308_0", + "numexpr 2.7.3 py38h22e1b3c_1", + "numpy 1.20.1 py38h93e21f0_0", + "numpy-base 1.20.1 py38h7d8b39e_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 py_0", + "openpyxl 3.0.7 pyhd3eb1b0_0", + "openssl 1.1.1k h27cfd23_0", + "packaging 20.9 pyhd3eb1b0_0", + "pandas 1.2.4 py38h2531618_0", + "pandoc 2.12 h06a4308_0", + "pandocfilters 1.4.3 py38h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.2.0 pyhd3eb1b0_0", + "patchelf 0.12 h2531618_1", + "path 15.1.2 py38h06a4308_0", + "path.py 12.5.0 0", + "pathlib2 2.3.5 py38h06a4308_2", + "pathspec 0.7.0 py_0", + "patsy 0.5.1 py38_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py38_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 8.2.0 py38he98fc37_0", + "pip 21.0.1 py38h06a4308_0", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.7.0 py38h06a4308_0", + "pluggy 0.13.1 py38h06a4308_0", + "ply 3.11 py38_0", + "prometheus_client 0.10.1 pyhd3eb1b0_0", + "prompt-toolkit 3.0.17 pyh06a4308_0", + "prompt_toolkit 3.0.17 hd3eb1b0_0", + "psutil 5.8.0 py38h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.10.0 pyhd3eb1b0_0", + "py-lief 0.10.1 py38h403a769_0", + "pycodestyle 2.6.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py38h7b6447c_1", + "pycparser 2.20 py_2", + "pycurl 7.43.0.6 py38h1ba5d50_0", + "pydocstyle 6.0.0 pyhd3eb1b0_0", + "pyerfa 1.7.3 py38h27cfd23_0", + "pyflakes 2.2.0 pyhd3eb1b0_0", + "pygments 2.8.1 pyhd3eb1b0_0", + "pylint 2.7.4 py38h06a4308_1", + "pyls-black 0.4.6 hd3eb1b0_0", + "pyls-spyder 0.3.2 pyhd3eb1b0_0", + "pyodbc 4.0.30 py38he6710b0_0", + "pyopenssl 20.0.1 pyhd3eb1b0_1", + "pyparsing 2.4.7 pyhd3eb1b0_0", + "pyqt 5.9.2 py38h05f1152_4", + "pyrsistent 0.17.3 py38h7b6447c_0", + "pysocks 1.7.1 py38h06a4308_0", + "pytables 3.6.1 py38h9fd0a39_0", + "pytest 6.2.3 py38h06a4308_2", + "python 3.8.8 hdb3f193_5", + "python-dateutil 2.8.1 pyhd3eb1b0_0", + "python-jsonrpc-server 0.4.0 py_0", + "python-language-server 0.36.2 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "pytz 2021.1 pyhd3eb1b0_0", + "pywavelets 1.1.1 py38h7b6447c_2", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 5.4.1 py38h27cfd23_1", + "pyzmq 20.0.0 py38h2531618_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.2 pyhd3eb1b0_0", + "qtconsole 5.0.3 pyhd3eb1b0_0", + "qtpy 1.9.0 py_0", + "readline 8.1 h27cfd23_0", + "regex 2021.4.4 py38h27cfd23_0", + "requests 2.25.1 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.18.0 py_0", + "rtree 0.9.7 py38h06a4308_1", + "ruamel_yaml 0.15.100 py38h27cfd23_0", + "scikit-image 0.18.1 py38ha9443f7_0", + "scikit-learn 0.24.1 py38ha9443f7_0", + "scipy 1.6.2 py38had2a1c9_1", + "seaborn 0.11.1 pyhd3eb1b0_0", + "secretstorage 3.3.1 py38h06a4308_0", + "send2trash 1.5.0 pyhd3eb1b0_1", + "setuptools 52.0.0 py38h06a4308_0", + "simplegeneric 0.8.1 py38_2", + "singledispatch 3.6.1 pyhd3eb1b0_1001", + "sip 4.19.13 py38he6710b0_0", + "six 1.15.0 py38h06a4308_0", + "sniffio 1.2.0 py38h06a4308_1", + "snowballstemmer 2.1.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.3.0 pyhd3eb1b0_0", + "soupsieve 2.2.1 pyhd3eb1b0_0", + "sphinx 3.5.3 pyhd3eb1b0_0", + "sphinxcontrib 1.0 py38_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.4 pyhd3eb1b0_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 4.2.5 py38h06a4308_0", + "spyder-kernels 1.10.2 py38h06a4308_0", + "sqlalchemy 1.4.7 py38h27cfd23_0", + "sqlite 3.35.4 hdfb4753_0", + "statsmodels 0.12.2 py38h27cfd23_0", + "sympy 1.8 py38h06a4308_0", + "tblib 1.7.0 py_0", + "terminado 0.9.4 py38h06a4308_0", + "testpath 0.4.4 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2020.10.1 py38hdd07704_2", + "tk 8.6.10 hbc83047_0", + "toml 0.10.2 pyhd3eb1b0_0", + "toolz 0.11.1 pyhd3eb1b0_0", + "tornado 6.1 py38h27cfd23_0", + "tqdm 4.59.0 pyhd3eb1b0_1", + "traitlets 5.0.5 pyhd3eb1b0_0", + "typed-ast 1.4.2 py38h27cfd23_1", + "typing_extensions 3.7.4.3 pyha847dfd_0", + "ujson 4.0.2 py38h2531618_0", + "unicodecsv 0.14.1 py38_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.4 pyhd3eb1b0_0", + "watchdog 1.0.2 py38h06a4308_1", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py38_1", + "werkzeug 1.0.1 pyhd3eb1b0_0", + "wheel 0.36.2 pyhd3eb1b0_0", + "widgetsnbextension 3.5.1 py38_0", + "wrapt 1.12.1 py38h7b6447c_1", + "wurlitzer 2.1.0 py38h06a4308_0", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 1.3.8 pyhd3eb1b0_0", + "xlwt 1.3.0 py38_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.4.1 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py38_1", + "zope.event 4.5.0 py38_0", + "zope.interface 5.3.0 py38h27cfd23_0", + "zstd 1.4.5 h9ceee32_0" + ], + "license": "BSD", + "md5": "1dbec41a4bdba1689bec6e94de08f469", + "name": "anaconda", + "namespace": "python", + "sha256": "9a9ea365387e5c90950e66d5302295310be8f2ca0e36b26ac091f0ba0757d75a", + "size": 14192, + "subdir": "linux-64", + "timestamp": 1620769962374, + "version": "2021.04" + }, + "anaconda-2021.04-py39_0.tar.bz2": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.7.2 py39h06a4308_0", + "anaconda-project 0.9.1 pyhd3eb1b0_1", + "anyio 2.2.0 py39h06a4308_1", + "appdirs 1.4.4 py_0", + "argh 0.26.2 py39h06a4308_0", + "argon2-cffi 20.1.0 py39h27cfd23_1", + "asn1crypto 1.4.0 py_0", + "astroid 2.5 py39h06a4308_1", + "astropy 4.2.1 py39h27cfd23_1", + "async_generator 1.10 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 20.3.0 pyhd3eb1b0_0", + "autopep8 1.5.6 pyhd3eb1b0_0", + "babel 2.9.0 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.0 pyhd3eb1b0_2", + "backports.shutil_get_terminal_size 1.0.0 pyhd3eb1b0_3", + "beautifulsoup4 4.9.3 pyha847dfd_0", + "bitarray 1.9.2 py39h27cfd23_1", + "bkcharts 0.2 py39h06a4308_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 3.3.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.3.1 py39h06a4308_0", + "boto 2.49.0 py39h06a4308_0", + "bottleneck 1.3.2 py39hdd57654_1", + "brotli 1.0.9 he6710b0_2", + "brotlipy 0.7.0 py39h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.17.1 h27cfd23_0", + "ca-certificates 2021.4.13 h06a4308_1", + "cairo 1.16.0 hf32fb01_1", + "certifi 2020.12.5 py39h06a4308_0", + "cffi 1.14.5 py39h261ae71_0", + "chardet 4.0.0 py39h06a4308_1003", + "charls 2.2.0 h2531618_0", + "click 7.1.2 pyhd3eb1b0_0", + "cloudpickle 1.6.0 py_0", + "clyent 1.2.2 py39h06a4308_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 3.4.7 py39hd23ed53_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py39h06a4308_0", + "cython 0.29.23 py39h2531618_0", + "cytoolz 0.11.0 py39h27cfd23_0", + "dask 2021.4.0 pyhd3eb1b0_0", + "dask-core 2021.4.0 pyhd3eb1b0_0", + "dbus 1.13.18 hb2f20db_0", + "decorator 5.0.6 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 py_0", + "distributed 2021.4.0 py39h06a4308_0", + "docutils 0.17 py39h06a4308_1", + "entrypoints 0.3 py39h06a4308_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.3.0 h2531618_2", + "fastcache 1.1.0 py39he8ac12f_0", + "filelock 3.0.12 pyhd3eb1b0_1", + "flake8 3.9.0 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 0.9.0 pyhd3eb1b0_0", + "future 0.18.2 py39h06a4308_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 21.1.2 py39h27cfd23_1", + "giflib 5.1.4 h14c3975_1", + "glib 2.68.1 h36276a3_0", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.0.8 py39h8083e48_3", + "graphite2 1.3.14 h23475e2_0", + "greenlet 1.0.0 py39h2531618_2", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py39hec9cf62_0", + "harfbuzz 2.8.0 h6f93f22_0", + "hdf5 1.10.6 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 pyhd3eb1b0_0", + "imagecodecs 2021.3.31 py39h581e88b_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.2.0 pyhd3eb1b0_0", + "importlib-metadata 3.10.0 py39h06a4308_0", + "importlib_metadata 3.10.0 hd3eb1b0_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intel-openmp 2021.2.0 h06a4308_610", + "intervaltree 3.1.0 py_0", + "ipykernel 5.3.4 py39hb070fc8_0", + "ipython 7.22.0 py39hb070fc8_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.3 pyhd3eb1b0_1", + "isort 5.8.0 pyhd3eb1b0_0", + "itsdangerous 1.1.0 pyhd3eb1b0_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.2 py39h06a4308_1", + "jeepney 0.6.0 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "joblib 1.0.1 pyhd3eb1b0_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py_2", + "jupyter 1.0.0 py39h06a4308_7", + "jupyter-packaging 0.7.12 pyhd3eb1b0_0", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.7.1 py39h06a4308_0", + "jupyter_server 1.4.1 py39h06a4308_0", + "jupyterlab 3.0.14 pyhd3eb1b0_1", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.4.0 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 22.3.0 py39h06a4308_0", + "kiwisolver 1.3.1 py39h2531618_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.6.0 py39h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "lerc 2.2.1 h2531618_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libdeflate 1.7 h27cfd23_5", + "libedit 3.1.20210216 h27cfd23_1", + "libev 4.33 h7b6447c_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 h2531618_1", + "libllvm10 10.0.1 hbcb73fb_5", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_1", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h1bed415_2", + "libuv 1.40.0 h7b6447c_0", + "libwebp 1.0.1 h8e7db2f_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 hb55368b_3", + "libxslt 1.1.34 hc22bd24_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.36.0 py39h612dafd_4", + "locket 0.2.1 py39h06a4308_1", + "lxml 4.6.3 py39h9120a33_0", + "lz4-c 1.9.3 h2531618_0", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py39h27cfd23_0", + "matplotlib 3.3.4 py39h06a4308_0", + "matplotlib-base 3.3.4 py39h62a2d02_0", + "mccabe 0.6.1 py39h06a4308_1", + "mistune 0.8.4 py39h27cfd23_1000", + "mkl 2021.2.0 h06a4308_296", + "mkl-service 2.3.0 py39h27cfd23_1", + "mkl_fft 1.3.0 py39h42c9631_2", + "mkl_random 1.2.1 py39ha9443f7_2", + "mock 4.0.3 pyhd3eb1b0_0", + "more-itertools 8.7.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.2.1 py39h06a4308_0", + "msgpack-python 1.0.2 py39hff7bd54_1", + "multipledispatch 0.6.0 py39h06a4308_0", + "mypy_extensions 0.4.1 py39h06a4308_0", + "nbclassic 0.2.6 pyhd3eb1b0_0", + "nbclient 0.5.3 pyhd3eb1b0_0", + "nbconvert 6.0.7 py39h06a4308_0", + "nbformat 5.1.3 pyhd3eb1b0_0", + "ncurses 6.2 he6710b0_1", + "nest-asyncio 1.5.1 pyhd3eb1b0_0", + "networkx 2.5 py_0", + "nltk 3.6.1 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1006", + "notebook 6.3.0 py39h06a4308_0", + "numexpr 2.7.3 py39h22e1b3c_1", + "numpy 1.20.1 py39h93e21f0_0", + "numpy-base 1.20.1 py39h7d8b39e_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 py_0", + "openjpeg 2.3.0 h05c96fa_1", + "openpyxl 3.0.7 pyhd3eb1b0_0", + "openssl 1.1.1k h27cfd23_0", + "packaging 20.9 pyhd3eb1b0_0", + "pandas 1.2.4 py39h2531618_0", + "pandoc 2.12 h06a4308_0", + "pandocfilters 1.4.3 py39h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.2.0 pyhd3eb1b0_0", + "patchelf 0.12 h2531618_1", + "path 15.1.2 py39h06a4308_0", + "path.py 12.5.0 0", + "pathlib2 2.3.5 py39h06a4308_2", + "pathspec 0.7.0 py_0", + "patsy 0.5.1 py39h06a4308_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py39h06a4308_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 8.2.0 py39he98fc37_0", + "pip 21.0.1 py39h06a4308_0", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.7.0 py39h06a4308_0", + "pluggy 0.13.1 py39h06a4308_0", + "ply 3.11 py39h06a4308_0", + "prometheus_client 0.10.1 pyhd3eb1b0_0", + "prompt-toolkit 3.0.17 pyh06a4308_0", + "prompt_toolkit 3.0.17 hd3eb1b0_0", + "psutil 5.8.0 py39h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.10.0 pyhd3eb1b0_0", + "py-lief 0.10.1 py39h2531618_1", + "pycodestyle 2.6.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py39h27cfd23_0", + "pycparser 2.20 py_2", + "pycurl 7.43.0.6 py39h8b3b800_0", + "pydocstyle 6.0.0 pyhd3eb1b0_0", + "pyerfa 1.7.3 py39h27cfd23_0", + "pyflakes 2.2.0 pyhd3eb1b0_0", + "pygments 2.8.1 pyhd3eb1b0_0", + "pylint 2.7.4 py39h06a4308_1", + "pyls-black 0.4.6 hd3eb1b0_0", + "pyls-spyder 0.3.2 pyhd3eb1b0_0", + "pyodbc 4.0.30 py39h66f3464_0", + "pyopenssl 20.0.1 pyhd3eb1b0_1", + "pyparsing 2.4.7 pyhd3eb1b0_0", + "pyqt 5.9.2 py39h2531618_6", + "pyrsistent 0.17.3 py39h27cfd23_0", + "pysocks 1.7.1 py39h06a4308_0", + "pytables 3.6.1 py39h77479fe_1", + "pytest 6.2.3 py39h06a4308_2", + "python 3.9.4 hdb3f193_0", + "python-dateutil 2.8.1 pyhd3eb1b0_0", + "python-jsonrpc-server 0.4.0 py_0", + "python-language-server 0.36.2 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "pytz 2021.1 pyhd3eb1b0_0", + "pywavelets 1.1.1 py39h6323ea4_4", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 5.4.1 py39h27cfd23_1", + "pyzmq 20.0.0 py39h2531618_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.2 pyhd3eb1b0_0", + "qtconsole 5.0.3 pyhd3eb1b0_0", + "qtpy 1.9.0 py_0", + "readline 8.1 h27cfd23_0", + "regex 2021.4.4 py39h27cfd23_0", + "requests 2.25.1 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.18.0 py_0", + "rtree 0.9.7 py39h06a4308_1", + "ruamel_yaml 0.15.100 py39h27cfd23_0", + "scikit-image 0.18.1 py39ha9443f7_0", + "scikit-learn 0.24.1 py39ha9443f7_0", + "scipy 1.6.2 py39had2a1c9_1", + "seaborn 0.11.1 pyhd3eb1b0_0", + "secretstorage 3.3.1 py39h06a4308_0", + "send2trash 1.5.0 pyhd3eb1b0_1", + "setuptools 52.0.0 py39h06a4308_0", + "simplegeneric 0.8.1 py39h06a4308_2", + "singledispatch 3.6.1 pyhd3eb1b0_1001", + "sip 4.19.13 py39h2531618_0", + "six 1.15.0 py39h06a4308_0", + "snappy 1.1.8 he6710b0_0", + "sniffio 1.2.0 py39h06a4308_1", + "snowballstemmer 2.1.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.3.0 pyhd3eb1b0_0", + "soupsieve 2.2.1 pyhd3eb1b0_0", + "sphinx 3.5.3 pyhd3eb1b0_0", + "sphinxcontrib 1.0 py39h06a4308_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.4 pyhd3eb1b0_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 4.2.5 py39h06a4308_0", + "spyder-kernels 1.10.2 py39h06a4308_0", + "sqlalchemy 1.4.7 py39h27cfd23_0", + "sqlite 3.35.4 hdfb4753_0", + "statsmodels 0.12.2 py39h27cfd23_0", + "sympy 1.8 py39h06a4308_0", + "tblib 1.7.0 py_0", + "terminado 0.9.4 py39h06a4308_0", + "testpath 0.4.4 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.4.8 pyhd3eb1b0_2", + "tk 8.6.10 hbc83047_0", + "toml 0.10.2 pyhd3eb1b0_0", + "toolz 0.11.1 pyhd3eb1b0_0", + "tornado 6.1 py39h27cfd23_0", + "tqdm 4.59.0 pyhd3eb1b0_1", + "traitlets 5.0.5 pyhd3eb1b0_0", + "typed-ast 1.4.2 py39h27cfd23_1", + "typing_extensions 3.7.4.3 pyha847dfd_0", + "tzdata 2020f h52ac0ba_0", + "ujson 4.0.2 py39h2531618_0", + "unicodecsv 0.14.1 py39h06a4308_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.4 pyhd3eb1b0_0", + "watchdog 1.0.2 py39h06a4308_1", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py39h06a4308_1", + "werkzeug 1.0.1 pyhd3eb1b0_0", + "wheel 0.36.2 pyhd3eb1b0_0", + "widgetsnbextension 3.5.1 py39h06a4308_0", + "wrapt 1.12.1 py39he8ac12f_1", + "wurlitzer 2.1.0 py39h06a4308_0", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 1.3.8 pyhd3eb1b0_0", + "xlwt 1.3.0 py39h06a4308_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h2531618_6", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.4.1 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py39h06a4308_1", + "zope.event 4.5.0 py39h06a4308_0", + "zope.interface 5.3.0 py39h27cfd23_0", + "zstd 1.4.5 h9ceee32_0" + ], + "license": "BSD", + "md5": "41f01e91df453ffd9c54303e98e8ddd5", + "name": "anaconda", + "namespace": "python", + "sha256": "b2ca64ad23ff35d2aa75eecf165030f027f9c7c67adde1602f3225299ad7ac61", + "size": 14479, + "subdir": "linux-64", + "timestamp": 1620769939078, + "version": "2021.04" + }, + "anaconda-2021.05-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.7.2 py37_0", + "anaconda-project 0.9.1 pyhd3eb1b0_1", + "anyio 2.2.0 py37h06a4308_1", + "appdirs 1.4.4 py_0", + "argh 0.26.2 py37_0", + "argon2-cffi 20.1.0 py37h27cfd23_1", + "asn1crypto 1.4.0 py_0", + "astroid 2.5 py37h06a4308_1", + "astropy 4.2.1 py37h27cfd23_1", + "async_generator 1.10 py37h28b3542_0", + "atomicwrites 1.4.0 py_0", + "attrs 20.3.0 pyhd3eb1b0_0", + "autopep8 1.5.6 pyhd3eb1b0_0", + "babel 2.9.0 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.0 pyhd3eb1b0_2", + "backports.shutil_get_terminal_size 1.0.0 pyhd3eb1b0_3", + "beautifulsoup4 4.9.3 pyha847dfd_0", + "bitarray 2.1.0 py37h27cfd23_1", + "bkcharts 0.2 py37_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 3.3.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.3.2 py37h06a4308_0", + "boto 2.49.0 py37_0", + "bottleneck 1.3.2 py37heb32a55_1", + "brotlipy 0.7.0 py37h27cfd23_1003", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.17.1 h27cfd23_0", + "ca-certificates 2021.4.13 h06a4308_1", + "cairo 1.16.0 hf32fb01_1", + "certifi 2020.12.5 py37h06a4308_0", + "cffi 1.14.5 py37h261ae71_0", + "chardet 4.0.0 py37h06a4308_1003", + "click 7.1.2 pyhd3eb1b0_0", + "cloudpickle 1.6.0 py_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 3.4.7 py37hd23ed53_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py37_0", + "cython 0.29.23 py37h2531618_0", + "cytoolz 0.11.0 py37h7b6447c_0", + "dask 2021.4.0 pyhd3eb1b0_0", + "dask-core 2021.4.0 pyhd3eb1b0_0", + "dbus 1.13.18 hb2f20db_0", + "decorator 5.0.6 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 py_0", + "distributed 2021.4.1 py37h06a4308_0", + "docutils 0.17.1 py37h06a4308_1", + "entrypoints 0.3 py37_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.3.0 h2531618_2", + "fastcache 1.1.0 py37h7b6447c_0", + "filelock 3.0.12 pyhd3eb1b0_1", + "flake8 3.9.0 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 0.9.0 pyhd3eb1b0_0", + "future 0.18.2 py37_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 21.1.2 py37h27cfd23_1", + "glib 2.68.1 h36276a3_0", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.14 h23475e2_0", + "greenlet 1.0.0 py37h2531618_2", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py37h7918eee_0", + "harfbuzz 2.8.0 h6f93f22_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 pyhd3eb1b0_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.2.0 pyhd3eb1b0_0", + "importlib-metadata 3.10.0 py37h06a4308_0", + "importlib_metadata 3.10.0 hd3eb1b0_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intel-openmp 2021.2.0 h06a4308_610", + "intervaltree 3.1.0 py_0", + "ipykernel 5.3.4 py37h5ca1d4c_0", + "ipython 7.22.0 py37hb070fc8_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.3 pyhd3eb1b0_1", + "isort 5.8.0 pyhd3eb1b0_0", + "itsdangerous 1.1.0 py37_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.2 py37h06a4308_1", + "jeepney 0.6.0 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "joblib 1.0.1 pyhd3eb1b0_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py_2", + "jupyter 1.0.0 py37_7", + "jupyter-packaging 0.7.12 pyhd3eb1b0_0", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.7.1 py37h06a4308_0", + "jupyter_server 1.4.1 py37h06a4308_0", + "jupyterlab 3.0.14 pyhd3eb1b0_1", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.4.0 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "keyring 22.3.0 py37h06a4308_0", + "kiwisolver 1.3.1 py37h2531618_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.6.0 py37h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libedit 3.1.20210216 h27cfd23_1", + "libev 4.33 h7b6447c_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 he6710b0_0", + "libllvm10 10.0.1 hbcb73fb_5", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.2.0 h85742a9_0", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h1bed415_2", + "libuv 1.40.0 h7b6447c_0", + "libwebp-base 1.2.0 h27cfd23_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 hb55368b_3", + "libxslt 1.1.34 hc22bd24_0", + "llvmlite 0.36.0 py37h612dafd_4", + "locket 0.2.1 py37h06a4308_1", + "lxml 4.6.3 py37h9120a33_0", + "lz4-c 1.9.3 h2531618_0", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py37h14c3975_1", + "matplotlib 3.3.4 py37h06a4308_0", + "matplotlib-base 3.3.4 py37h62a2d02_0", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h14c3975_1001", + "mkl 2021.2.0 h06a4308_296", + "mkl-service 2.3.0 py37h27cfd23_1", + "mkl_fft 1.3.0 py37h42c9631_2", + "mkl_random 1.2.1 py37ha9443f7_2", + "mock 4.0.3 pyhd3eb1b0_0", + "more-itertools 8.7.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.2.1 py37h06a4308_0", + "msgpack-python 1.0.2 py37hff7bd54_1", + "multipledispatch 0.6.0 py37_0", + "mypy_extensions 0.4.3 py37_0", + "nbclassic 0.2.6 pyhd3eb1b0_0", + "nbclient 0.5.3 pyhd3eb1b0_0", + "nbconvert 6.0.7 py37_0", + "nbformat 5.1.3 pyhd3eb1b0_0", + "ncurses 6.2 he6710b0_1", + "nest-asyncio 1.5.1 pyhd3eb1b0_0", + "networkx 2.5 py_0", + "nltk 3.6.1 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1006", + "notebook 6.3.0 py37h06a4308_0", + "numba 0.53.1 py37ha9443f7_0", + "numexpr 2.7.3 py37h22e1b3c_1", + "numpy 1.20.1 py37h93e21f0_0", + "numpy-base 1.20.1 py37h7d8b39e_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 py37_0", + "openpyxl 3.0.7 pyhd3eb1b0_0", + "openssl 1.1.1k h27cfd23_0", + "packaging 20.9 pyhd3eb1b0_0", + "pandas 1.2.4 py37h2531618_0", + "pandoc 2.12 h06a4308_0", + "pandocfilters 1.4.3 py37h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.2.0 pyhd3eb1b0_0", + "patchelf 0.12 h2531618_1", + "path 15.1.2 py37h06a4308_0", + "path.py 12.5.0 0", + "pathlib2 2.3.5 py37h06a4308_2", + "pathspec 0.7.0 py_0", + "patsy 0.5.1 py37_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py37_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 8.2.0 py37he98fc37_0", + "pip 21.0.1 py37h06a4308_0", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.7.0 py37h06a4308_0", + "pluggy 0.13.1 py37h06a4308_0", + "ply 3.11 py37_0", + "prometheus_client 0.10.1 pyhd3eb1b0_0", + "prompt-toolkit 3.0.17 pyh06a4308_0", + "prompt_toolkit 3.0.17 hd3eb1b0_0", + "psutil 5.8.0 py37h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.10.0 pyhd3eb1b0_0", + "py-lief 0.10.1 py37h403a769_0", + "pycodestyle 2.6.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py37h27cfd23_0", + "pycparser 2.20 py_2", + "pycrypto 2.6.1 py37h7b6447c_10", + "pycurl 7.43.0.6 py37h1ba5d50_0", + "pydocstyle 6.0.0 pyhd3eb1b0_0", + "pyerfa 1.7.3 py37h27cfd23_0", + "pyflakes 2.2.0 pyhd3eb1b0_0", + "pygments 2.8.1 pyhd3eb1b0_0", + "pylint 2.7.4 py37h06a4308_1", + "pyls-black 0.4.6 hd3eb1b0_0", + "pyls-spyder 0.3.2 pyhd3eb1b0_0", + "pyodbc 4.0.30 py37he6710b0_0", + "pyopenssl 20.0.1 pyhd3eb1b0_1", + "pyparsing 2.4.7 pyhd3eb1b0_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.17.3 py37h7b6447c_0", + "pysocks 1.7.1 py37_1", + "pytables 3.6.1 py37h71ec239_0", + "pytest 6.2.3 py37h06a4308_2", + "python 3.7.10 hdb3f193_0", + "python-dateutil 2.8.1 pyhd3eb1b0_0", + "python-jsonrpc-server 0.4.0 py_0", + "python-language-server 0.36.2 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "pytz 2021.1 pyhd3eb1b0_0", + "pywavelets 1.1.1 py37h7b6447c_2", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 5.4.1 py37h27cfd23_1", + "pyzmq 20.0.0 py37h2531618_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.2 pyhd3eb1b0_0", + "qtconsole 5.0.3 pyhd3eb1b0_0", + "qtpy 1.9.0 py_0", + "readline 8.1 h27cfd23_0", + "regex 2021.4.4 py37h27cfd23_0", + "requests 2.25.1 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.18.0 py_0", + "rtree 0.9.7 py37h06a4308_1", + "ruamel_yaml 0.15.100 py37h27cfd23_0", + "scikit-image 0.18.1 py37ha9443f7_0", + "scikit-learn 0.24.1 py37ha9443f7_0", + "scipy 1.6.2 py37had2a1c9_1", + "seaborn 0.11.1 pyhd3eb1b0_0", + "secretstorage 3.3.1 py37h06a4308_0", + "send2trash 1.5.0 pyhd3eb1b0_1", + "setuptools 52.0.0 py37h06a4308_0", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.6.1 pyhd3eb1b0_1001", + "sip 4.19.8 py37hf484d3e_0", + "six 1.15.0 py37h06a4308_0", + "sniffio 1.2.0 py37h06a4308_1", + "snowballstemmer 2.1.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.3.0 pyhd3eb1b0_0", + "soupsieve 2.2.1 pyhd3eb1b0_0", + "sphinx 4.0.1 pyhd3eb1b0_0", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.4 pyhd3eb1b0_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 4.2.5 py37h06a4308_0", + "spyder-kernels 1.10.2 py37h06a4308_0", + "sqlalchemy 1.4.15 py37h27cfd23_0", + "sqlite 3.35.4 hdfb4753_0", + "statsmodels 0.12.2 py37h27cfd23_0", + "sympy 1.8 py37h06a4308_0", + "tbb 2020.3 hfd86e86_0", + "tblib 1.7.0 py_0", + "terminado 0.9.4 py37h06a4308_0", + "testpath 0.4.4 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2020.10.1 py37hdd07704_2", + "tk 8.6.10 hbc83047_0", + "toml 0.10.2 pyhd3eb1b0_0", + "toolz 0.11.1 pyhd3eb1b0_0", + "tornado 6.1 py37h27cfd23_0", + "tqdm 4.59.0 pyhd3eb1b0_1", + "traitlets 5.0.5 pyhd3eb1b0_0", + "typed-ast 1.4.2 py37h27cfd23_1", + "typing_extensions 3.7.4.3 pyha847dfd_0", + "ujson 4.0.2 py37h2531618_0", + "unicodecsv 0.14.1 py37_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.4 pyhd3eb1b0_0", + "watchdog 1.0.2 py37h06a4308_1", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py37_1", + "werkzeug 1.0.1 pyhd3eb1b0_0", + "wheel 0.36.2 pyhd3eb1b0_0", + "widgetsnbextension 3.5.1 py37_0", + "wrapt 1.12.1 py37h7b6447c_1", + "wurlitzer 2.1.0 py37h06a4308_0", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 1.3.8 pyhd3eb1b0_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.4.1 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py37_1", + "zope.event 4.5.0 py37_0", + "zope.interface 5.3.0 py37h27cfd23_0", + "zstd 1.4.5 h9ceee32_0" + ], + "license": "BSD", + "md5": "3f2992d26dbd7e7b9caf94f1bca479f3", + "name": "anaconda", + "namespace": "python", + "sha256": "8be48233dd45e3e1376bcb18c44a56a28a78b8d0ddc06c54068834ec075550e4", + "size": 14297, + "subdir": "linux-64", + "timestamp": 1620924558991, + "version": "2021.05" + }, + "anaconda-2021.05-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.7.2 py38_0", + "anaconda-project 0.9.1 pyhd3eb1b0_1", + "anyio 2.2.0 py38h06a4308_1", + "appdirs 1.4.4 py_0", + "argh 0.26.2 py38_0", + "argon2-cffi 20.1.0 py38h27cfd23_1", + "asn1crypto 1.4.0 py_0", + "astroid 2.5 py38h06a4308_1", + "astropy 4.2.1 py38h27cfd23_1", + "async_generator 1.10 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 20.3.0 pyhd3eb1b0_0", + "autopep8 1.5.6 pyhd3eb1b0_0", + "babel 2.9.0 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.0 pyhd3eb1b0_2", + "backports.shutil_get_terminal_size 1.0.0 pyhd3eb1b0_3", + "beautifulsoup4 4.9.3 pyha847dfd_0", + "bitarray 2.1.0 py38h27cfd23_1", + "bkcharts 0.2 py38_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 3.3.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.3.2 py38h06a4308_0", + "boto 2.49.0 py38_0", + "bottleneck 1.3.2 py38heb32a55_1", + "brotlipy 0.7.0 py38h27cfd23_1003", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.17.1 h27cfd23_0", + "ca-certificates 2021.4.13 h06a4308_1", + "cairo 1.16.0 hf32fb01_1", + "certifi 2020.12.5 py38h06a4308_0", + "cffi 1.14.5 py38h261ae71_0", + "chardet 4.0.0 py38h06a4308_1003", + "click 7.1.2 pyhd3eb1b0_0", + "cloudpickle 1.6.0 py_0", + "clyent 1.2.2 py38_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 3.4.7 py38hd23ed53_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py38_0", + "cython 0.29.23 py38h2531618_0", + "cytoolz 0.11.0 py38h7b6447c_0", + "dask 2021.4.0 pyhd3eb1b0_0", + "dask-core 2021.4.0 pyhd3eb1b0_0", + "dbus 1.13.18 hb2f20db_0", + "decorator 5.0.6 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 py_0", + "distributed 2021.4.1 py38h06a4308_0", + "docutils 0.17.1 py38h06a4308_1", + "entrypoints 0.3 py38_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.3.0 h2531618_2", + "fastcache 1.1.0 py38h7b6447c_0", + "filelock 3.0.12 pyhd3eb1b0_1", + "flake8 3.9.0 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 0.9.0 pyhd3eb1b0_0", + "future 0.18.2 py38_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 21.1.2 py38h27cfd23_1", + "glib 2.68.1 h36276a3_0", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.0.8 py38hd5f6e3b_3", + "graphite2 1.3.14 h23475e2_0", + "greenlet 1.0.0 py38h2531618_2", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py38h7918eee_0", + "harfbuzz 2.8.0 h6f93f22_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 pyhd3eb1b0_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.2.0 pyhd3eb1b0_0", + "importlib-metadata 3.10.0 py38h06a4308_0", + "importlib_metadata 3.10.0 hd3eb1b0_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intel-openmp 2021.2.0 h06a4308_610", + "intervaltree 3.1.0 py_0", + "ipykernel 5.3.4 py38h5ca1d4c_0", + "ipython 7.22.0 py38hb070fc8_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.3 pyhd3eb1b0_1", + "isort 5.8.0 pyhd3eb1b0_0", + "itsdangerous 1.1.0 pyhd3eb1b0_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.2 py38h06a4308_1", + "jeepney 0.6.0 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "joblib 1.0.1 pyhd3eb1b0_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py_2", + "jupyter 1.0.0 py38_7", + "jupyter-packaging 0.7.12 pyhd3eb1b0_0", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.7.1 py38h06a4308_0", + "jupyter_server 1.4.1 py38h06a4308_0", + "jupyterlab 3.0.14 pyhd3eb1b0_1", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.4.0 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "keyring 22.3.0 py38h06a4308_0", + "kiwisolver 1.3.1 py38h2531618_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.6.0 py38h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libedit 3.1.20210216 h27cfd23_1", + "libev 4.33 h7b6447c_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 he6710b0_0", + "libllvm10 10.0.1 hbcb73fb_5", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.2.0 h85742a9_0", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h1bed415_2", + "libuv 1.40.0 h7b6447c_0", + "libwebp-base 1.2.0 h27cfd23_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 hb55368b_3", + "libxslt 1.1.34 hc22bd24_0", + "llvmlite 0.36.0 py38h612dafd_4", + "locket 0.2.1 py38h06a4308_1", + "lxml 4.6.3 py38h9120a33_0", + "lz4-c 1.9.3 h2531618_0", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py38h7b6447c_0", + "matplotlib 3.3.4 py38h06a4308_0", + "matplotlib-base 3.3.4 py38h62a2d02_0", + "mccabe 0.6.1 py38_1", + "mistune 0.8.4 py38h7b6447c_1000", + "mkl 2021.2.0 h06a4308_296", + "mkl-service 2.3.0 py38h27cfd23_1", + "mkl_fft 1.3.0 py38h42c9631_2", + "mkl_random 1.2.1 py38ha9443f7_2", + "mock 4.0.3 pyhd3eb1b0_0", + "more-itertools 8.7.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.2.1 py38h06a4308_0", + "msgpack-python 1.0.2 py38hff7bd54_1", + "multipledispatch 0.6.0 py38_0", + "mypy_extensions 0.4.3 py38_0", + "nbclassic 0.2.6 pyhd3eb1b0_0", + "nbclient 0.5.3 pyhd3eb1b0_0", + "nbconvert 6.0.7 py38_0", + "nbformat 5.1.3 pyhd3eb1b0_0", + "ncurses 6.2 he6710b0_1", + "nest-asyncio 1.5.1 pyhd3eb1b0_0", + "networkx 2.5 py_0", + "nltk 3.6.1 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1006", + "notebook 6.3.0 py38h06a4308_0", + "numba 0.53.1 py38ha9443f7_0", + "numexpr 2.7.3 py38h22e1b3c_1", + "numpy 1.20.1 py38h93e21f0_0", + "numpy-base 1.20.1 py38h7d8b39e_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 py_0", + "openpyxl 3.0.7 pyhd3eb1b0_0", + "openssl 1.1.1k h27cfd23_0", + "packaging 20.9 pyhd3eb1b0_0", + "pandas 1.2.4 py38h2531618_0", + "pandoc 2.12 h06a4308_0", + "pandocfilters 1.4.3 py38h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.2.0 pyhd3eb1b0_0", + "patchelf 0.12 h2531618_1", + "path 15.1.2 py38h06a4308_0", + "path.py 12.5.0 0", + "pathlib2 2.3.5 py38h06a4308_2", + "pathspec 0.7.0 py_0", + "patsy 0.5.1 py38_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py38_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 8.2.0 py38he98fc37_0", + "pip 21.0.1 py38h06a4308_0", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.7.0 py38h06a4308_0", + "pluggy 0.13.1 py38h06a4308_0", + "ply 3.11 py38_0", + "prometheus_client 0.10.1 pyhd3eb1b0_0", + "prompt-toolkit 3.0.17 pyh06a4308_0", + "prompt_toolkit 3.0.17 hd3eb1b0_0", + "psutil 5.8.0 py38h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.10.0 pyhd3eb1b0_0", + "py-lief 0.10.1 py38h403a769_0", + "pycodestyle 2.6.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py38h7b6447c_1", + "pycparser 2.20 py_2", + "pycurl 7.43.0.6 py38h1ba5d50_0", + "pydocstyle 6.0.0 pyhd3eb1b0_0", + "pyerfa 1.7.3 py38h27cfd23_0", + "pyflakes 2.2.0 pyhd3eb1b0_0", + "pygments 2.8.1 pyhd3eb1b0_0", + "pylint 2.7.4 py38h06a4308_1", + "pyls-black 0.4.6 hd3eb1b0_0", + "pyls-spyder 0.3.2 pyhd3eb1b0_0", + "pyodbc 4.0.30 py38he6710b0_0", + "pyopenssl 20.0.1 pyhd3eb1b0_1", + "pyparsing 2.4.7 pyhd3eb1b0_0", + "pyqt 5.9.2 py38h05f1152_4", + "pyrsistent 0.17.3 py38h7b6447c_0", + "pysocks 1.7.1 py38h06a4308_0", + "pytables 3.6.1 py38h9fd0a39_0", + "pytest 6.2.3 py38h06a4308_2", + "python 3.8.8 hdb3f193_5", + "python-dateutil 2.8.1 pyhd3eb1b0_0", + "python-jsonrpc-server 0.4.0 py_0", + "python-language-server 0.36.2 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "pytz 2021.1 pyhd3eb1b0_0", + "pywavelets 1.1.1 py38h7b6447c_2", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 5.4.1 py38h27cfd23_1", + "pyzmq 20.0.0 py38h2531618_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.2 pyhd3eb1b0_0", + "qtconsole 5.0.3 pyhd3eb1b0_0", + "qtpy 1.9.0 py_0", + "readline 8.1 h27cfd23_0", + "regex 2021.4.4 py38h27cfd23_0", + "requests 2.25.1 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.18.0 py_0", + "rtree 0.9.7 py38h06a4308_1", + "ruamel_yaml 0.15.100 py38h27cfd23_0", + "scikit-image 0.18.1 py38ha9443f7_0", + "scikit-learn 0.24.1 py38ha9443f7_0", + "scipy 1.6.2 py38had2a1c9_1", + "seaborn 0.11.1 pyhd3eb1b0_0", + "secretstorage 3.3.1 py38h06a4308_0", + "send2trash 1.5.0 pyhd3eb1b0_1", + "setuptools 52.0.0 py38h06a4308_0", + "simplegeneric 0.8.1 py38_2", + "singledispatch 3.6.1 pyhd3eb1b0_1001", + "sip 4.19.13 py38he6710b0_0", + "six 1.15.0 py38h06a4308_0", + "sniffio 1.2.0 py38h06a4308_1", + "snowballstemmer 2.1.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.3.0 pyhd3eb1b0_0", + "soupsieve 2.2.1 pyhd3eb1b0_0", + "sphinx 4.0.1 pyhd3eb1b0_0", + "sphinxcontrib 1.0 py38_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.4 pyhd3eb1b0_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 4.2.5 py38h06a4308_0", + "spyder-kernels 1.10.2 py38h06a4308_0", + "sqlalchemy 1.4.15 py38h27cfd23_0", + "sqlite 3.35.4 hdfb4753_0", + "statsmodels 0.12.2 py38h27cfd23_0", + "sympy 1.8 py38h06a4308_0", + "tbb 2020.3 hfd86e86_0", + "tblib 1.7.0 py_0", + "terminado 0.9.4 py38h06a4308_0", + "testpath 0.4.4 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2020.10.1 py38hdd07704_2", + "tk 8.6.10 hbc83047_0", + "toml 0.10.2 pyhd3eb1b0_0", + "toolz 0.11.1 pyhd3eb1b0_0", + "tornado 6.1 py38h27cfd23_0", + "tqdm 4.59.0 pyhd3eb1b0_1", + "traitlets 5.0.5 pyhd3eb1b0_0", + "typed-ast 1.4.2 py38h27cfd23_1", + "typing_extensions 3.7.4.3 pyha847dfd_0", + "ujson 4.0.2 py38h2531618_0", + "unicodecsv 0.14.1 py38_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.4 pyhd3eb1b0_0", + "watchdog 1.0.2 py38h06a4308_1", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py38_1", + "werkzeug 1.0.1 pyhd3eb1b0_0", + "wheel 0.36.2 pyhd3eb1b0_0", + "widgetsnbextension 3.5.1 py38_0", + "wrapt 1.12.1 py38h7b6447c_1", + "wurlitzer 2.1.0 py38h06a4308_0", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 1.3.8 pyhd3eb1b0_0", + "xlwt 1.3.0 py38_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.4.1 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py38_1", + "zope.event 4.5.0 py38_0", + "zope.interface 5.3.0 py38h27cfd23_0", + "zstd 1.4.5 h9ceee32_0" + ], + "license": "BSD", + "md5": "abe63d4a7425755cd2a984919d6fd384", + "name": "anaconda", + "namespace": "python", + "sha256": "c6b9ec7a19fa05fa5022ab4cdb82a177e54cc89dac8635c67d63252953c7dd08", + "size": 14247, + "subdir": "linux-64", + "timestamp": 1620924351236, + "version": "2021.05" + }, + "anaconda-2021.05-py39_0.tar.bz2": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.7.2 py39h06a4308_0", + "anaconda-project 0.9.1 pyhd3eb1b0_1", + "anyio 2.2.0 py39h06a4308_1", + "appdirs 1.4.4 py_0", + "argh 0.26.2 py39h06a4308_0", + "argon2-cffi 20.1.0 py39h27cfd23_1", + "asn1crypto 1.4.0 py_0", + "astroid 2.5 py39h06a4308_1", + "astropy 4.2.1 py39h27cfd23_1", + "async_generator 1.10 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 20.3.0 pyhd3eb1b0_0", + "autopep8 1.5.6 pyhd3eb1b0_0", + "babel 2.9.0 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.0 pyhd3eb1b0_2", + "backports.shutil_get_terminal_size 1.0.0 pyhd3eb1b0_3", + "beautifulsoup4 4.9.3 pyha847dfd_0", + "bitarray 2.1.0 py39h27cfd23_1", + "bkcharts 0.2 py39h06a4308_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 3.3.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.3.2 py39h06a4308_0", + "boto 2.49.0 py39h06a4308_0", + "bottleneck 1.3.2 py39hdd57654_1", + "brotli 1.0.9 he6710b0_2", + "brotlipy 0.7.0 py39h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.17.1 h27cfd23_0", + "ca-certificates 2021.4.13 h06a4308_1", + "cairo 1.16.0 hf32fb01_1", + "certifi 2020.12.5 py39h06a4308_0", + "cffi 1.14.5 py39h261ae71_0", + "chardet 4.0.0 py39h06a4308_1003", + "charls 2.2.0 h2531618_0", + "click 7.1.2 pyhd3eb1b0_0", + "cloudpickle 1.6.0 py_0", + "clyent 1.2.2 py39h06a4308_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 3.4.7 py39hd23ed53_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py39h06a4308_0", + "cython 0.29.23 py39h2531618_0", + "cytoolz 0.11.0 py39h27cfd23_0", + "dask 2021.4.0 pyhd3eb1b0_0", + "dask-core 2021.4.0 pyhd3eb1b0_0", + "dbus 1.13.18 hb2f20db_0", + "decorator 5.0.6 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 py_0", + "distributed 2021.4.1 py39h06a4308_0", + "docutils 0.17.1 py39h06a4308_1", + "entrypoints 0.3 py39h06a4308_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.3.0 h2531618_2", + "fastcache 1.1.0 py39he8ac12f_0", + "filelock 3.0.12 pyhd3eb1b0_1", + "flake8 3.9.0 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 0.9.0 pyhd3eb1b0_0", + "future 0.18.2 py39h06a4308_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 21.1.2 py39h27cfd23_1", + "giflib 5.1.4 h14c3975_1", + "glib 2.68.1 h36276a3_0", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.0.8 py39h8083e48_3", + "graphite2 1.3.14 h23475e2_0", + "greenlet 1.0.0 py39h2531618_2", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py39hec9cf62_0", + "harfbuzz 2.8.0 h6f93f22_0", + "hdf5 1.10.6 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 pyhd3eb1b0_0", + "imagecodecs 2021.3.31 py39h581e88b_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.2.0 pyhd3eb1b0_0", + "importlib-metadata 3.10.0 py39h06a4308_0", + "importlib_metadata 3.10.0 hd3eb1b0_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intel-openmp 2021.2.0 h06a4308_610", + "intervaltree 3.1.0 py_0", + "ipykernel 5.3.4 py39hb070fc8_0", + "ipython 7.22.0 py39hb070fc8_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.3 pyhd3eb1b0_1", + "isort 5.8.0 pyhd3eb1b0_0", + "itsdangerous 1.1.0 pyhd3eb1b0_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.2 py39h06a4308_1", + "jeepney 0.6.0 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "joblib 1.0.1 pyhd3eb1b0_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py_2", + "jupyter 1.0.0 py39h06a4308_7", + "jupyter-packaging 0.7.12 pyhd3eb1b0_0", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.7.1 py39h06a4308_0", + "jupyter_server 1.4.1 py39h06a4308_0", + "jupyterlab 3.0.14 pyhd3eb1b0_1", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.4.0 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 22.3.0 py39h06a4308_0", + "kiwisolver 1.3.1 py39h2531618_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.6.0 py39h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "lerc 2.2.1 h2531618_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libdeflate 1.7 h27cfd23_5", + "libedit 3.1.20210216 h27cfd23_1", + "libev 4.33 h7b6447c_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 h2531618_1", + "libllvm10 10.0.1 hbcb73fb_5", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_1", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h1bed415_2", + "libuv 1.40.0 h7b6447c_0", + "libwebp 1.0.1 h8e7db2f_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 hb55368b_3", + "libxslt 1.1.34 hc22bd24_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.36.0 py39h612dafd_4", + "locket 0.2.1 py39h06a4308_1", + "lxml 4.6.3 py39h9120a33_0", + "lz4-c 1.9.3 h2531618_0", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py39h27cfd23_0", + "matplotlib 3.3.4 py39h06a4308_0", + "matplotlib-base 3.3.4 py39h62a2d02_0", + "mccabe 0.6.1 py39h06a4308_1", + "mistune 0.8.4 py39h27cfd23_1000", + "mkl 2021.2.0 h06a4308_296", + "mkl-service 2.3.0 py39h27cfd23_1", + "mkl_fft 1.3.0 py39h42c9631_2", + "mkl_random 1.2.1 py39ha9443f7_2", + "mock 4.0.3 pyhd3eb1b0_0", + "more-itertools 8.7.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.2.1 py39h06a4308_0", + "msgpack-python 1.0.2 py39hff7bd54_1", + "multipledispatch 0.6.0 py39h06a4308_0", + "mypy_extensions 0.4.1 py39h06a4308_0", + "nbclassic 0.2.6 pyhd3eb1b0_0", + "nbclient 0.5.3 pyhd3eb1b0_0", + "nbconvert 6.0.7 py39h06a4308_0", + "nbformat 5.1.3 pyhd3eb1b0_0", + "ncurses 6.2 he6710b0_1", + "nest-asyncio 1.5.1 pyhd3eb1b0_0", + "networkx 2.5 py_0", + "nltk 3.6.1 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1006", + "notebook 6.3.0 py39h06a4308_0", + "numba 0.53.1 py39ha9443f7_0", + "numexpr 2.7.3 py39h22e1b3c_1", + "numpy 1.20.1 py39h93e21f0_0", + "numpy-base 1.20.1 py39h7d8b39e_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 py_0", + "openjpeg 2.3.0 h05c96fa_1", + "openpyxl 3.0.7 pyhd3eb1b0_0", + "openssl 1.1.1k h27cfd23_0", + "packaging 20.9 pyhd3eb1b0_0", + "pandas 1.2.4 py39h2531618_0", + "pandoc 2.12 h06a4308_0", + "pandocfilters 1.4.3 py39h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.2.0 pyhd3eb1b0_0", + "patchelf 0.12 h2531618_1", + "path 15.1.2 py39h06a4308_0", + "path.py 12.5.0 0", + "pathlib2 2.3.5 py39h06a4308_2", + "pathspec 0.7.0 py_0", + "patsy 0.5.1 py39h06a4308_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py39h06a4308_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 8.2.0 py39he98fc37_0", + "pip 21.0.1 py39h06a4308_0", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.7.0 py39h06a4308_0", + "pluggy 0.13.1 py39h06a4308_0", + "ply 3.11 py39h06a4308_0", + "prometheus_client 0.10.1 pyhd3eb1b0_0", + "prompt-toolkit 3.0.17 pyh06a4308_0", + "prompt_toolkit 3.0.17 hd3eb1b0_0", + "psutil 5.8.0 py39h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.10.0 pyhd3eb1b0_0", + "py-lief 0.10.1 py39h2531618_1", + "pycodestyle 2.6.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py39h27cfd23_0", + "pycparser 2.20 py_2", + "pycurl 7.43.0.6 py39h8b3b800_0", + "pydocstyle 6.0.0 pyhd3eb1b0_0", + "pyerfa 1.7.3 py39h27cfd23_0", + "pyflakes 2.2.0 pyhd3eb1b0_0", + "pygments 2.8.1 pyhd3eb1b0_0", + "pylint 2.7.4 py39h06a4308_1", + "pyls-black 0.4.6 hd3eb1b0_0", + "pyls-spyder 0.3.2 pyhd3eb1b0_0", + "pyodbc 4.0.30 py39h66f3464_0", + "pyopenssl 20.0.1 pyhd3eb1b0_1", + "pyparsing 2.4.7 pyhd3eb1b0_0", + "pyqt 5.9.2 py39h2531618_6", + "pyrsistent 0.17.3 py39h27cfd23_0", + "pysocks 1.7.1 py39h06a4308_0", + "pytables 3.6.1 py39h77479fe_1", + "pytest 6.2.3 py39h06a4308_2", + "python 3.9.4 hdb3f193_0", + "python-dateutil 2.8.1 pyhd3eb1b0_0", + "python-jsonrpc-server 0.4.0 py_0", + "python-language-server 0.36.2 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "pytz 2021.1 pyhd3eb1b0_0", + "pywavelets 1.1.1 py39h6323ea4_4", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 5.4.1 py39h27cfd23_1", + "pyzmq 20.0.0 py39h2531618_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.2 pyhd3eb1b0_0", + "qtconsole 5.0.3 pyhd3eb1b0_0", + "qtpy 1.9.0 py_0", + "readline 8.1 h27cfd23_0", + "regex 2021.4.4 py39h27cfd23_0", + "requests 2.25.1 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.18.0 py_0", + "rtree 0.9.7 py39h06a4308_1", + "ruamel_yaml 0.15.100 py39h27cfd23_0", + "scikit-image 0.18.1 py39ha9443f7_0", + "scikit-learn 0.24.1 py39ha9443f7_0", + "scipy 1.6.2 py39had2a1c9_1", + "seaborn 0.11.1 pyhd3eb1b0_0", + "secretstorage 3.3.1 py39h06a4308_0", + "send2trash 1.5.0 pyhd3eb1b0_1", + "setuptools 52.0.0 py39h06a4308_0", + "simplegeneric 0.8.1 py39h06a4308_2", + "singledispatch 3.6.1 pyhd3eb1b0_1001", + "sip 4.19.13 py39h2531618_0", + "six 1.15.0 py39h06a4308_0", + "snappy 1.1.8 he6710b0_0", + "sniffio 1.2.0 py39h06a4308_1", + "snowballstemmer 2.1.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.3.0 pyhd3eb1b0_0", + "soupsieve 2.2.1 pyhd3eb1b0_0", + "sphinx 4.0.1 pyhd3eb1b0_0", + "sphinxcontrib 1.0 py39h06a4308_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.4 pyhd3eb1b0_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 4.2.5 py39h06a4308_0", + "spyder-kernels 1.10.2 py39h06a4308_0", + "sqlalchemy 1.4.15 py39h27cfd23_0", + "sqlite 3.35.4 hdfb4753_0", + "statsmodels 0.12.2 py39h27cfd23_0", + "sympy 1.8 py39h06a4308_0", + "tbb 2020.3 hfd86e86_0", + "tblib 1.7.0 py_0", + "terminado 0.9.4 py39h06a4308_0", + "testpath 0.4.4 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.4.8 pyhd3eb1b0_2", + "tk 8.6.10 hbc83047_0", + "toml 0.10.2 pyhd3eb1b0_0", + "toolz 0.11.1 pyhd3eb1b0_0", + "tornado 6.1 py39h27cfd23_0", + "tqdm 4.59.0 pyhd3eb1b0_1", + "traitlets 5.0.5 pyhd3eb1b0_0", + "typed-ast 1.4.2 py39h27cfd23_1", + "typing_extensions 3.7.4.3 pyha847dfd_0", + "tzdata 2020f h52ac0ba_0", + "ujson 4.0.2 py39h2531618_0", + "unicodecsv 0.14.1 py39h06a4308_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.4 pyhd3eb1b0_0", + "watchdog 1.0.2 py39h06a4308_1", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py39h06a4308_1", + "werkzeug 1.0.1 pyhd3eb1b0_0", + "wheel 0.36.2 pyhd3eb1b0_0", + "widgetsnbextension 3.5.1 py39h06a4308_0", + "wrapt 1.12.1 py39he8ac12f_1", + "wurlitzer 2.1.0 py39h06a4308_0", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 1.3.8 pyhd3eb1b0_0", + "xlwt 1.3.0 py39h06a4308_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h2531618_6", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.4.1 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py39h06a4308_1", + "zope.event 4.5.0 py39h06a4308_0", + "zope.interface 5.3.0 py39h27cfd23_0", + "zstd 1.4.5 h9ceee32_0" + ], + "license": "BSD", + "md5": "a17c59c191436f564204b8d80604ba33", + "name": "anaconda", + "namespace": "python", + "sha256": "3614f0d0adf7743872d279f433760e1e1f27d8db28875b37aff5df9fb7bbfc22", + "size": 14561, + "subdir": "linux-64", + "timestamp": 1620924553671, + "version": "2021.05" + }, + "anaconda-2021.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 4.5 1_gnu", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.9.0 py37h06a4308_0", + "anaconda-project 0.10.1 pyhd3eb1b0_0", + "anyio 2.2.0 py37h06a4308_1", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argcomplete 1.12.3 pyhd3eb1b0_0", + "argh 0.26.2 py37_0", + "argon2-cffi 20.1.0 py37h27cfd23_1", + "arrow 0.13.1 py37_0", + "asn1crypto 1.4.0 py_0", + "astroid 2.6.6 py37h06a4308_0", + "astropy 4.3.1 py37h09021b7_0", + "async_generator 1.10 py37h28b3542_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.2.0 pyhd3eb1b0_0", + "autopep8 1.5.7 pyhd3eb1b0_0", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.0 pyhd3eb1b0_2", + "backports.shutil_get_terminal_size 1.0.0 pyhd3eb1b0_3", + "beautifulsoup4 4.10.0 pyh06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.3.0 py37h7f8727e_1", + "bkcharts 0.2 py37_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 4.0.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.4.1 py37h06a4308_0", + "boto 2.49.0 py37_0", + "bottleneck 1.3.2 py37heb32a55_1", + "brotli 1.0.9 he6710b0_2", + "brotlipy 0.7.0 py37h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.17.1 h27cfd23_0", + "ca-certificates 2021.10.26 h06a4308_2", + "cairo 1.16.0 hf32fb01_1", + "certifi 2021.10.8 py37h06a4308_0", + "cffi 1.14.6 py37h400218f_0", + "cfitsio 3.470 hf0d0db6_6", + "chardet 4.0.0 py37h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.3 pyhd3eb1b0_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "conda-content-trust 0.1.1 pyhd3eb1b0_0", + "conda-token 0.3.0 pyhd3eb1b0_0", + "contextlib2 0.6.0.post1 pyhd3eb1b0_0", + "cookiecutter 1.7.2 pyhd3eb1b0_0", + "cryptography 3.4.8 py37hd23ed53_0", + "curl 7.78.0 h1ccaba5_0", + "cycler 0.10.0 py37_0", + "cython 0.29.24 py37hdbfa776_0", + "cytoolz 0.11.0 py37h7b6447c_0", + "daal4py 2021.3.0 py37hae6d005_0", + "dal 2021.3.0 h06a4308_557", + "dask 2021.10.0 pyhd3eb1b0_0", + "dask-core 2021.10.0 pyhd3eb1b0_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.4.1 py37h295c915_0", + "decorator 5.1.0 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "distributed 2021.10.0 py37h06a4308_0", + "docutils 0.17.1 py37h06a4308_1", + "entrypoints 0.3 py37_0", + "et_xmlfile 1.1.0 py37h06a4308_0", + "expat 2.4.1 h2531618_2", + "fastcache 1.1.0 py37h7b6447c_0", + "filelock 3.3.1 pyhd3eb1b0_1", + "flake8 3.9.2 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 2021.8.1 pyhd3eb1b0_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 21.8.0 py37h7f8727e_1", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h5202010_0", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.14 h23475e2_0", + "greenlet 1.1.1 py37h295c915_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py37h7918eee_0", + "harfbuzz 2.8.1 h6f93f22_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "html5lib 1.1 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.2 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py37h4cda21f_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.2.0 pyhd3eb1b0_0", + "importlib-metadata 4.8.1 py37h06a4308_0", + "importlib_metadata 4.8.1 hd3eb1b0_0", + "inflection 0.5.1 py37h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.4.1 py37h06a4308_1", + "ipython 7.29.0 py37hb070fc8_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.0 py37h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_2", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9d h7f8727e_0", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 3.2.0 pyhd3eb1b0_2", + "jupyter 1.0.0 py37_7", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.8.1 py37h06a4308_0", + "jupyter_server 1.4.1 py37h06a4308_0", + "jupyterlab 3.2.1 pyhd3eb1b0_1", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.8.2 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.1.0 py37h06a4308_0", + "kiwisolver 1.3.1 py37h2531618_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py37h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.35.1 h7274673_9", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.78.0 h0b77cf5_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.3.0 h5101ec6_17", + "libgfortran-ng 7.5.0 ha8ba4b0_17", + "libgfortran4 7.5.0 ha8ba4b0_17", + "libgomp 9.3.0 h5101ec6_17", + "liblief 0.10.1 he6710b0_0", + "libllvm11 11.1.0 h3826bc1_0", + "libnghttp2 1.41.0 hf8bcb03_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.3.0 hd4cf53a_17", + "libtiff 4.2.0 h85742a9_0", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h7f8727e_2", + "libuv 1.40.0 h7b6447c_0", + "libwebp 1.2.0 h89dd481_0", + "libwebp-base 1.2.0 h27cfd23_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.12 h03d6c58_0", + "libxslt 1.1.34 hc22bd24_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.37.0 py37h295c915_1", + "locket 0.2.1 py37h06a4308_1", + "lxml 4.6.3 py37h9120a33_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py37h14c3975_1", + "matplotlib 3.4.3 py37h06a4308_0", + "matplotlib-base 3.4.3 py37hbbc1b5f_0", + "matplotlib-inline 0.1.2 pyhd3eb1b0_2", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h14c3975_1001", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py37h7f8727e_0", + "mkl_fft 1.3.1 py37hd3c417c_0", + "mkl_random 1.2.2 py37h51133e4_0", + "mock 4.0.3 pyhd3eb1b0_0", + "more-itertools 8.10.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 hc856adb_0", + "mpmath 1.2.1 py37h06a4308_0", + "msgpack-python 1.0.2 py37hff7bd54_1", + "multipledispatch 0.6.0 py37_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py37_0", + "nbclassic 0.2.6 pyhd3eb1b0_0", + "nbclient 0.5.3 pyhd3eb1b0_0", + "nbconvert 6.1.0 py37h06a4308_0", + "nbformat 5.1.3 pyhd3eb1b0_0", + "ncurses 6.3 heee7806_1", + "nest-asyncio 1.5.1 pyhd3eb1b0_0", + "networkx 2.6.3 pyhd3eb1b0_0", + "nltk 3.6.5 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1006", + "notebook 6.4.5 py37h06a4308_0", + "numba 0.54.1 py37h51133e4_0", + "numexpr 2.7.3 py37h22e1b3c_1", + "numpy 1.20.3 py37hf144106_0", + "numpy-base 1.20.3 py37h74d4b33_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 py37_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.9 pyhd3eb1b0_0", + "openssl 1.1.1l h7f8727e_0", + "packaging 21.0 pyhd3eb1b0_0", + "pandas 1.3.4 py37h8c16a72_0", + "pandocfilters 1.4.3 py37h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.8.2 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_0", + "patchelf 0.13 h295c915_0", + "path 16.0.0 py37h06a4308_0", + "path.py 12.5.0 hd3eb1b0_0", + "pathlib2 2.3.6 py37h06a4308_2", + "pathspec 0.7.0 py_0", + "patsy 0.5.2 py37h06a4308_0", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py37_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 8.4.0 py37h5aabda8_0", + "pip 21.2.2 py37h06a4308_0", + "pixman 0.40.0 h7f8727e_1", + "pkginfo 1.7.1 py37h06a4308_0", + "pluggy 0.13.1 py37h06a4308_0", + "ply 3.11 py37_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.11.0 pyhd3eb1b0_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "psutil 5.8.0 py37h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.10.0 pyhd3eb1b0_0", + "py-lief 0.10.1 py37h403a769_0", + "pycodestyle 2.7.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py37h27cfd23_0", + "pycparser 2.20 py_2", + "pycrypto 2.6.1 py37h7b6447c_10", + "pycurl 7.44.1 py37h8f2d780_1", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py37h27cfd23_0", + "pyflakes 2.3.1 pyhd3eb1b0_0", + "pygments 2.10.0 pyhd3eb1b0_0", + "pylint 2.9.6 py37h06a4308_1", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.31 py37h295c915_0", + "pyopenssl 21.0.0 pyhd3eb1b0_1", + "pyparsing 3.0.4 pyhd3eb1b0_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.18.0 py37heee7806_0", + "pysocks 1.7.1 py37_1", + "pytables 3.6.1 py37h71ec239_0", + "pytest 6.2.4 py37h06a4308_2", + "python 3.7.11 h12debd9_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.0.0 pyhd3eb1b0_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.2.4 pyhd3eb1b0_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "pytz 2021.3 pyhd3eb1b0_0", + "pywavelets 1.1.1 py37h7b6447c_2", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py37h7f8727e_1", + "pyzmq 22.2.1 py37h295c915_1", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.2 pyhd3eb1b0_0", + "qtconsole 5.1.1 pyhd3eb1b0_0", + "qtpy 1.10.0 pyhd3eb1b0_0", + "readline 8.1 h27cfd23_0", + "regex 2021.8.3 py37h7f8727e_0", + "requests 2.26.0 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.19.0 pyhd3eb1b0_0", + "rtree 0.9.7 py37h06a4308_1", + "ruamel_yaml 0.15.100 py37h27cfd23_0", + "scikit-image 0.18.3 py37h51133e4_0", + "scikit-learn 0.24.2 py37ha9443f7_0", + "scikit-learn-intelex 2021.3.0 py37h06a4308_0", + "scipy 1.7.1 py37h292c36d_2", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py37h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "setuptools 58.0.4 py37h06a4308_0", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.7.0 pyhd3eb1b0_1001", + "sip 4.19.8 py37hf484d3e_0", + "six 1.16.0 pyhd3eb1b0_0", + "snappy 1.1.8 he6710b0_0", + "sniffio 1.2.0 py37h06a4308_1", + "snowballstemmer 2.1.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.2.1 pyhd3eb1b0_0", + "sphinx 4.2.0 pyhd3eb1b0_1", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 5.1.5 py37h06a4308_1", + "spyder-kernels 2.1.3 py37h06a4308_0", + "sqlalchemy 1.4.22 py37h7f8727e_0", + "sqlite 3.36.0 hc218d9a_0", + "statsmodels 0.12.2 py37h27cfd23_0", + "sympy 1.9 py37h06a4308_0", + "tbb 2021.4.0 hd09550d_0", + "tbb4py 2021.4.0 py37hd09550d_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "terminado 0.9.4 py37h06a4308_0", + "testpath 0.5.0 pyhd3eb1b0_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.11 h1ccaba5_0", + "toml 0.10.2 pyhd3eb1b0_0", + "toolz 0.11.1 pyhd3eb1b0_0", + "tornado 6.1 py37h27cfd23_0", + "tqdm 4.62.3 pyhd3eb1b0_1", + "traitlets 5.1.0 pyhd3eb1b0_0", + "typed-ast 1.4.3 py37h7f8727e_1", + "typing-extensions 3.10.0.2 hd3eb1b0_0", + "typing_extensions 3.10.0.2 pyh06a4308_0", + "ujson 4.0.2 py37h2531618_0", + "unicodecsv 0.14.1 py37_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.7 pyhd3eb1b0_0", + "watchdog 2.1.3 py37h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py37_1", + "werkzeug 2.0.2 pyhd3eb1b0_0", + "wheel 0.37.0 pyhd3eb1b0_1", + "whichcraft 0.6.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.1 py37_0", + "wrapt 1.12.1 py37h7b6447c_1", + "wurlitzer 2.1.1 py37h06a4308_0", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.1 pyhd3eb1b0_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h2531618_6", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.6.0 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py37_1", + "zope.event 4.5.0 py37_0", + "zope.interface 5.4.0 py37h7f8727e_0", + "zstd 1.4.9 haebb681_0" + ], + "license": "BSD", + "md5": "7cf3a66dc89b6b634631a92c6db63e82", + "name": "anaconda", + "namespace": "python", + "sha256": "cb33ddd1ea8e6cb8a488eeba6e38561dbe672ef80f9625b68eb8f4b9d11ff7e6", + "size": 15495, + "subdir": "linux-64", + "timestamp": 1636485500907, + "version": "2021.11" + }, + "anaconda-2021.11-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 4.5 1_gnu", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.9.0 py38h06a4308_0", + "anaconda-project 0.10.1 pyhd3eb1b0_0", + "anyio 2.2.0 py38h06a4308_1", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argh 0.26.2 py38_0", + "argon2-cffi 20.1.0 py38h27cfd23_1", + "arrow 0.13.1 py38_0", + "asn1crypto 1.4.0 py_0", + "astroid 2.6.6 py38h06a4308_0", + "astropy 4.3.1 py38h09021b7_0", + "async_generator 1.10 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.2.0 pyhd3eb1b0_0", + "autopep8 1.5.7 pyhd3eb1b0_0", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.0 pyhd3eb1b0_2", + "backports.shutil_get_terminal_size 1.0.0 pyhd3eb1b0_3", + "beautifulsoup4 4.10.0 pyh06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.3.0 py38h7f8727e_1", + "bkcharts 0.2 py38_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 4.0.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.4.1 py38h06a4308_0", + "boto 2.49.0 py38_0", + "bottleneck 1.3.2 py38heb32a55_1", + "brotli 1.0.9 he6710b0_2", + "brotlipy 0.7.0 py38h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.17.1 h27cfd23_0", + "ca-certificates 2021.10.26 h06a4308_2", + "cairo 1.16.0 hf32fb01_1", + "certifi 2021.10.8 py38h06a4308_0", + "cffi 1.14.6 py38h400218f_0", + "cfitsio 3.470 hf0d0db6_6", + "chardet 4.0.0 py38h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.3 pyhd3eb1b0_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py38_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "conda-content-trust 0.1.1 pyhd3eb1b0_0", + "conda-token 0.3.0 pyhd3eb1b0_0", + "contextlib2 0.6.0.post1 pyhd3eb1b0_0", + "cookiecutter 1.7.2 pyhd3eb1b0_0", + "cryptography 3.4.8 py38hd23ed53_0", + "curl 7.78.0 h1ccaba5_0", + "cycler 0.10.0 py38_0", + "cython 0.29.24 py38hdbfa776_0", + "cytoolz 0.11.0 py38h7b6447c_0", + "daal4py 2021.3.0 py38hae6d005_0", + "dal 2021.3.0 h06a4308_557", + "dask 2021.10.0 pyhd3eb1b0_0", + "dask-core 2021.10.0 pyhd3eb1b0_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.4.1 py38h295c915_0", + "decorator 5.1.0 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "distributed 2021.10.0 py38h06a4308_0", + "docutils 0.17.1 py38h06a4308_1", + "entrypoints 0.3 py38_0", + "et_xmlfile 1.1.0 py38h06a4308_0", + "expat 2.4.1 h2531618_2", + "fastcache 1.1.0 py38h7b6447c_0", + "filelock 3.3.1 pyhd3eb1b0_1", + "flake8 3.9.2 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 2021.8.1 pyhd3eb1b0_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 21.8.0 py38h7f8727e_1", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h5202010_0", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.0.8 py38hd5f6e3b_3", + "graphite2 1.3.14 h23475e2_0", + "greenlet 1.1.1 py38h295c915_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py38h7918eee_0", + "harfbuzz 2.8.1 h6f93f22_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "html5lib 1.1 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.2 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py38h4cda21f_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.2.0 pyhd3eb1b0_0", + "importlib-metadata 4.8.1 py38h06a4308_0", + "importlib_metadata 4.8.1 hd3eb1b0_0", + "inflection 0.5.1 py38h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.4.1 py38h06a4308_1", + "ipython 7.29.0 py38hb070fc8_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.0 py38h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_2", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9d h7f8727e_0", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 3.2.0 pyhd3eb1b0_2", + "jupyter 1.0.0 py38_7", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.8.1 py38h06a4308_0", + "jupyter_server 1.4.1 py38h06a4308_0", + "jupyterlab 3.2.1 pyhd3eb1b0_1", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.8.2 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.1.0 py38h06a4308_0", + "kiwisolver 1.3.1 py38h2531618_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py38h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.35.1 h7274673_9", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.78.0 h0b77cf5_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.3.0 h5101ec6_17", + "libgfortran-ng 7.5.0 ha8ba4b0_17", + "libgfortran4 7.5.0 ha8ba4b0_17", + "libgomp 9.3.0 h5101ec6_17", + "liblief 0.10.1 he6710b0_0", + "libllvm11 11.1.0 h3826bc1_0", + "libnghttp2 1.41.0 hf8bcb03_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.3.0 hd4cf53a_17", + "libtiff 4.2.0 h85742a9_0", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h7f8727e_2", + "libuv 1.40.0 h7b6447c_0", + "libwebp 1.2.0 h89dd481_0", + "libwebp-base 1.2.0 h27cfd23_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.12 h03d6c58_0", + "libxslt 1.1.34 hc22bd24_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.37.0 py38h295c915_1", + "locket 0.2.1 py38h06a4308_1", + "lxml 4.6.3 py38h9120a33_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py38h7b6447c_0", + "matplotlib 3.4.3 py38h06a4308_0", + "matplotlib-base 3.4.3 py38hbbc1b5f_0", + "matplotlib-inline 0.1.2 pyhd3eb1b0_2", + "mccabe 0.6.1 py38_1", + "mistune 0.8.4 py38h7b6447c_1000", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py38h7f8727e_0", + "mkl_fft 1.3.1 py38hd3c417c_0", + "mkl_random 1.2.2 py38h51133e4_0", + "mock 4.0.3 pyhd3eb1b0_0", + "more-itertools 8.10.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 hc856adb_0", + "mpmath 1.2.1 py38h06a4308_0", + "msgpack-python 1.0.2 py38hff7bd54_1", + "multipledispatch 0.6.0 py38_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py38_0", + "nbclassic 0.2.6 pyhd3eb1b0_0", + "nbclient 0.5.3 pyhd3eb1b0_0", + "nbconvert 6.1.0 py38h06a4308_0", + "nbformat 5.1.3 pyhd3eb1b0_0", + "ncurses 6.3 heee7806_1", + "nest-asyncio 1.5.1 pyhd3eb1b0_0", + "networkx 2.6.3 pyhd3eb1b0_0", + "nltk 3.6.5 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1006", + "notebook 6.4.5 py38h06a4308_0", + "numba 0.54.1 py38h51133e4_0", + "numexpr 2.7.3 py38h22e1b3c_1", + "numpy 1.20.3 py38hf144106_0", + "numpy-base 1.20.3 py38h74d4b33_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 pyhd3eb1b0_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.9 pyhd3eb1b0_0", + "openssl 1.1.1l h7f8727e_0", + "packaging 21.0 pyhd3eb1b0_0", + "pandas 1.3.4 py38h8c16a72_0", + "pandocfilters 1.4.3 py38h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.8.2 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_0", + "patchelf 0.13 h295c915_0", + "path 16.0.0 py38h06a4308_0", + "path.py 12.5.0 hd3eb1b0_0", + "pathlib2 2.3.6 py38h06a4308_2", + "pathspec 0.7.0 py_0", + "patsy 0.5.2 py38h06a4308_0", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py38_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 8.4.0 py38h5aabda8_0", + "pip 21.2.4 py38h06a4308_0", + "pixman 0.40.0 h7f8727e_1", + "pkginfo 1.7.1 py38h06a4308_0", + "pluggy 0.13.1 py38h06a4308_0", + "ply 3.11 py38_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.11.0 pyhd3eb1b0_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "psutil 5.8.0 py38h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.10.0 pyhd3eb1b0_0", + "py-lief 0.10.1 py38h403a769_0", + "pycodestyle 2.7.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py38h7b6447c_1", + "pycparser 2.20 py_2", + "pycurl 7.44.1 py38h8f2d780_1", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py38h27cfd23_0", + "pyflakes 2.3.1 pyhd3eb1b0_0", + "pygments 2.10.0 pyhd3eb1b0_0", + "pylint 2.9.6 py38h06a4308_1", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.31 py38h295c915_0", + "pyopenssl 21.0.0 pyhd3eb1b0_1", + "pyparsing 3.0.4 pyhd3eb1b0_0", + "pyqt 5.9.2 py38h05f1152_4", + "pyrsistent 0.18.0 py38heee7806_0", + "pysocks 1.7.1 py38h06a4308_0", + "pytables 3.6.1 py38h9fd0a39_0", + "pytest 6.2.4 py38h06a4308_2", + "python 3.8.12 h12debd9_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.0.0 pyhd3eb1b0_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.2.4 pyhd3eb1b0_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "pytz 2021.3 pyhd3eb1b0_0", + "pywavelets 1.1.1 py38h7b6447c_2", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py38h7f8727e_1", + "pyzmq 22.2.1 py38h295c915_1", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.2 pyhd3eb1b0_0", + "qtconsole 5.1.1 pyhd3eb1b0_0", + "qtpy 1.10.0 pyhd3eb1b0_0", + "readline 8.1 h27cfd23_0", + "regex 2021.8.3 py38h7f8727e_0", + "requests 2.26.0 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.19.0 pyhd3eb1b0_0", + "rtree 0.9.7 py38h06a4308_1", + "ruamel_yaml 0.15.100 py38h27cfd23_0", + "scikit-image 0.18.3 py38h51133e4_0", + "scikit-learn 0.24.2 py38ha9443f7_0", + "scikit-learn-intelex 2021.3.0 py38h06a4308_0", + "scipy 1.7.1 py38h292c36d_2", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py38h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "setuptools 58.0.4 py38h06a4308_0", + "simplegeneric 0.8.1 py38_2", + "singledispatch 3.7.0 pyhd3eb1b0_1001", + "sip 4.19.13 py38he6710b0_0", + "six 1.16.0 pyhd3eb1b0_0", + "snappy 1.1.8 he6710b0_0", + "sniffio 1.2.0 py38h06a4308_1", + "snowballstemmer 2.1.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.2.1 pyhd3eb1b0_0", + "sphinx 4.2.0 pyhd3eb1b0_1", + "sphinxcontrib 1.0 py38_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 5.1.5 py38h06a4308_1", + "spyder-kernels 2.1.3 py38h06a4308_0", + "sqlalchemy 1.4.22 py38h7f8727e_0", + "sqlite 3.36.0 hc218d9a_0", + "statsmodels 0.12.2 py38h27cfd23_0", + "sympy 1.9 py38h06a4308_0", + "tbb 2021.4.0 hd09550d_0", + "tbb4py 2021.4.0 py38hd09550d_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "terminado 0.9.4 py38h06a4308_0", + "testpath 0.5.0 pyhd3eb1b0_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.11 h1ccaba5_0", + "toml 0.10.2 pyhd3eb1b0_0", + "toolz 0.11.1 pyhd3eb1b0_0", + "tornado 6.1 py38h27cfd23_0", + "tqdm 4.62.3 pyhd3eb1b0_1", + "traitlets 5.1.0 pyhd3eb1b0_0", + "typed-ast 1.4.3 py38h7f8727e_1", + "typing_extensions 3.10.0.2 pyh06a4308_0", + "ujson 4.0.2 py38h2531618_0", + "unicodecsv 0.14.1 py38_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.7 pyhd3eb1b0_0", + "watchdog 2.1.3 py38h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py38_1", + "werkzeug 2.0.2 pyhd3eb1b0_0", + "wheel 0.37.0 pyhd3eb1b0_1", + "whichcraft 0.6.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.1 py38_0", + "wrapt 1.12.1 py38h7b6447c_1", + "wurlitzer 2.1.1 py38h06a4308_0", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.1 pyhd3eb1b0_0", + "xlwt 1.3.0 py38_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h2531618_6", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.6.0 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py38_1", + "zope.event 4.5.0 py38_0", + "zope.interface 5.4.0 py38h7f8727e_0", + "zstd 1.4.9 haebb681_0" + ], + "license": "BSD", + "md5": "ade790e65c35ceb2dd6e42b2807ff1c0", + "name": "anaconda", + "namespace": "python", + "sha256": "085e03f8506549bb86fd3a480efb5169d992844dc07ff915b95885aafb03c2b8", + "size": 15401, + "subdir": "linux-64", + "timestamp": 1636485274528, + "version": "2021.11" + }, + "anaconda-2021.11-py39_0.tar.bz2": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 4.5 1_gnu", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.9.0 py39h06a4308_0", + "anaconda-project 0.10.1 pyhd3eb1b0_0", + "anyio 2.2.0 py39h06a4308_1", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argh 0.26.2 py39h06a4308_0", + "argon2-cffi 20.1.0 py39h27cfd23_1", + "arrow 0.13.1 py39h06a4308_0", + "asn1crypto 1.4.0 py_0", + "astroid 2.6.6 py39h06a4308_0", + "astropy 4.3.1 py39h09021b7_0", + "async_generator 1.10 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.2.0 pyhd3eb1b0_0", + "autopep8 1.5.7 pyhd3eb1b0_0", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.0 pyhd3eb1b0_2", + "backports.shutil_get_terminal_size 1.0.0 pyhd3eb1b0_3", + "beautifulsoup4 4.10.0 pyh06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.3.0 py39h7f8727e_1", + "bkcharts 0.2 py39h06a4308_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 4.0.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.4.1 py39h06a4308_0", + "boto 2.49.0 py39h06a4308_0", + "bottleneck 1.3.2 py39hdd57654_1", + "brotli 1.0.9 he6710b0_2", + "brotlipy 0.7.0 py39h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.17.1 h27cfd23_0", + "ca-certificates 2021.10.26 h06a4308_2", + "cached-property 1.5.2 py_0", + "cairo 1.16.0 hf32fb01_1", + "certifi 2021.10.8 py39h06a4308_0", + "cffi 1.14.6 py39h400218f_0", + "cfitsio 3.470 hf0d0db6_6", + "chardet 4.0.0 py39h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.3 pyhd3eb1b0_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py39h06a4308_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "conda-content-trust 0.1.1 pyhd3eb1b0_0", + "conda-token 0.3.0 pyhd3eb1b0_0", + "contextlib2 0.6.0.post1 pyhd3eb1b0_0", + "cookiecutter 1.7.2 pyhd3eb1b0_0", + "cryptography 3.4.8 py39hd23ed53_0", + "curl 7.78.0 h1ccaba5_0", + "cycler 0.10.0 py39h06a4308_0", + "cython 0.29.24 py39hdbfa776_0", + "cytoolz 0.11.0 py39h27cfd23_0", + "daal4py 2021.3.0 py39hae6d005_0", + "dal 2021.3.0 h06a4308_557", + "dask 2021.10.0 pyhd3eb1b0_0", + "dask-core 2021.10.0 pyhd3eb1b0_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.4.1 py39h295c915_0", + "decorator 5.1.0 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "distributed 2021.10.0 py39h06a4308_0", + "docutils 0.17.1 py39h06a4308_1", + "entrypoints 0.3 py39h06a4308_0", + "et_xmlfile 1.1.0 py39h06a4308_0", + "expat 2.4.1 h2531618_2", + "fastcache 1.1.0 py39he8ac12f_0", + "filelock 3.3.1 pyhd3eb1b0_1", + "flake8 3.9.2 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 2021.8.1 pyhd3eb1b0_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 21.8.0 py39h7f8727e_1", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h5202010_0", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.0.8 py39h8083e48_3", + "graphite2 1.3.14 h23475e2_0", + "greenlet 1.1.1 py39h295c915_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 3.3.0 py39h930cdd6_0", + "harfbuzz 2.8.1 h6f93f22_0", + "hdf5 1.10.6 hb1b8bf9_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "html5lib 1.1 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.2 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py39h4cda21f_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.2.0 pyhd3eb1b0_0", + "importlib-metadata 4.8.1 py39h06a4308_0", + "importlib_metadata 4.8.1 hd3eb1b0_0", + "inflection 0.5.1 py39h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.4.1 py39h06a4308_1", + "ipython 7.29.0 py39hb070fc8_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.0 py39h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_2", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9d h7f8727e_0", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 3.2.0 pyhd3eb1b0_2", + "jupyter 1.0.0 py39h06a4308_7", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.8.1 py39h06a4308_0", + "jupyter_server 1.4.1 py39h06a4308_0", + "jupyterlab 3.2.1 pyhd3eb1b0_1", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.8.2 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.1.0 py39h06a4308_0", + "kiwisolver 1.3.1 py39h2531618_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py39h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.35.1 h7274673_9", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.78.0 h0b77cf5_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.3.0 h5101ec6_17", + "libgfortran-ng 7.5.0 ha8ba4b0_17", + "libgfortran4 7.5.0 ha8ba4b0_17", + "libgomp 9.3.0 h5101ec6_17", + "liblief 0.10.1 h2531618_1", + "libllvm11 11.1.0 h3826bc1_0", + "libnghttp2 1.41.0 hf8bcb03_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.3.0 hd4cf53a_17", + "libtiff 4.2.0 h85742a9_0", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h7f8727e_2", + "libuv 1.40.0 h7b6447c_0", + "libwebp 1.2.0 h89dd481_0", + "libwebp-base 1.2.0 h27cfd23_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.12 h03d6c58_0", + "libxslt 1.1.34 hc22bd24_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.37.0 py39h295c915_1", + "locket 0.2.1 py39h06a4308_1", + "lxml 4.6.3 py39h9120a33_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py39h27cfd23_0", + "matplotlib 3.4.3 py39h06a4308_0", + "matplotlib-base 3.4.3 py39hbbc1b5f_0", + "matplotlib-inline 0.1.2 pyhd3eb1b0_2", + "mccabe 0.6.1 py39h06a4308_1", + "mistune 0.8.4 py39h27cfd23_1000", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py39h7f8727e_0", + "mkl_fft 1.3.1 py39hd3c417c_0", + "mkl_random 1.2.2 py39h51133e4_0", + "mock 4.0.3 pyhd3eb1b0_0", + "more-itertools 8.10.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 hc856adb_0", + "mpmath 1.2.1 py39h06a4308_0", + "msgpack-python 1.0.2 py39hff7bd54_1", + "multipledispatch 0.6.0 py39h06a4308_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py39h06a4308_0", + "nbclassic 0.2.6 pyhd3eb1b0_0", + "nbclient 0.5.3 pyhd3eb1b0_0", + "nbconvert 6.1.0 py39h06a4308_0", + "nbformat 5.1.3 pyhd3eb1b0_0", + "ncurses 6.3 heee7806_1", + "nest-asyncio 1.5.1 pyhd3eb1b0_0", + "networkx 2.6.3 pyhd3eb1b0_0", + "nltk 3.6.5 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1006", + "notebook 6.4.5 py39h06a4308_0", + "numba 0.54.1 py39h51133e4_0", + "numexpr 2.7.3 py39h22e1b3c_1", + "numpy 1.20.3 py39hf144106_0", + "numpy-base 1.20.3 py39h74d4b33_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 pyhd3eb1b0_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.9 pyhd3eb1b0_0", + "openssl 1.1.1l h7f8727e_0", + "packaging 21.0 pyhd3eb1b0_0", + "pandas 1.3.4 py39h8c16a72_0", + "pandocfilters 1.4.3 py39h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.8.2 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_0", + "patchelf 0.13 h295c915_0", + "path 16.0.0 py39h06a4308_0", + "path.py 12.5.0 hd3eb1b0_0", + "pathlib2 2.3.6 py39h06a4308_2", + "pathspec 0.7.0 py_0", + "patsy 0.5.2 py39h06a4308_0", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py39h06a4308_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 8.4.0 py39h5aabda8_0", + "pip 21.2.4 py39h06a4308_0", + "pixman 0.40.0 h7f8727e_1", + "pkginfo 1.7.1 py39h06a4308_0", + "pluggy 0.13.1 py39h06a4308_0", + "ply 3.11 py39h06a4308_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.11.0 pyhd3eb1b0_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "psutil 5.8.0 py39h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.10.0 pyhd3eb1b0_0", + "py-lief 0.10.1 py39h2531618_1", + "pycodestyle 2.7.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py39h27cfd23_0", + "pycparser 2.20 py_2", + "pycurl 7.44.1 py39h8f2d780_1", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py39h27cfd23_0", + "pyflakes 2.3.1 pyhd3eb1b0_0", + "pygments 2.10.0 pyhd3eb1b0_0", + "pylint 2.9.6 py39h06a4308_1", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.31 py39h295c915_0", + "pyopenssl 21.0.0 pyhd3eb1b0_1", + "pyparsing 3.0.4 pyhd3eb1b0_0", + "pyqt 5.9.2 py39h2531618_6", + "pyrsistent 0.18.0 py39heee7806_0", + "pysocks 1.7.1 py39h06a4308_0", + "pytables 3.6.1 py39h77479fe_1", + "pytest 6.2.4 py39h06a4308_2", + "python 3.9.7 h12debd9_1", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.0.0 pyhd3eb1b0_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.2.4 pyhd3eb1b0_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "pytz 2021.3 pyhd3eb1b0_0", + "pywavelets 1.1.1 py39h6323ea4_4", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py39h7f8727e_1", + "pyzmq 22.2.1 py39h295c915_1", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.2 pyhd3eb1b0_0", + "qtconsole 5.1.1 pyhd3eb1b0_0", + "qtpy 1.10.0 pyhd3eb1b0_0", + "readline 8.1 h27cfd23_0", + "regex 2021.8.3 py39h7f8727e_0", + "requests 2.26.0 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.19.0 pyhd3eb1b0_0", + "rtree 0.9.7 py39h06a4308_1", + "ruamel_yaml 0.15.100 py39h27cfd23_0", + "scikit-image 0.18.3 py39h51133e4_0", + "scikit-learn 0.24.2 py39ha9443f7_0", + "scikit-learn-intelex 2021.3.0 py39h06a4308_0", + "scipy 1.7.1 py39h292c36d_2", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py39h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "setuptools 58.0.4 py39h06a4308_0", + "simplegeneric 0.8.1 py39h06a4308_2", + "singledispatch 3.7.0 pyhd3eb1b0_1001", + "sip 4.19.13 py39h2531618_0", + "six 1.16.0 pyhd3eb1b0_0", + "snappy 1.1.8 he6710b0_0", + "sniffio 1.2.0 py39h06a4308_1", + "snowballstemmer 2.1.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.2.1 pyhd3eb1b0_0", + "sphinx 4.2.0 pyhd3eb1b0_1", + "sphinxcontrib 1.0 py39h06a4308_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 5.1.5 py39h06a4308_1", + "spyder-kernels 2.1.3 py39h06a4308_0", + "sqlalchemy 1.4.22 py39h7f8727e_0", + "sqlite 3.36.0 hc218d9a_0", + "statsmodels 0.12.2 py39h27cfd23_0", + "sympy 1.9 py39h06a4308_0", + "tbb 2021.4.0 hd09550d_0", + "tbb4py 2021.4.0 py39hd09550d_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "terminado 0.9.4 py39h06a4308_0", + "testpath 0.5.0 pyhd3eb1b0_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.11 h1ccaba5_0", + "toml 0.10.2 pyhd3eb1b0_0", + "toolz 0.11.1 pyhd3eb1b0_0", + "tornado 6.1 py39h27cfd23_0", + "tqdm 4.62.3 pyhd3eb1b0_1", + "traitlets 5.1.0 pyhd3eb1b0_0", + "typed-ast 1.4.3 py39h7f8727e_1", + "typing_extensions 3.10.0.2 pyh06a4308_0", + "tzdata 2021e hda174b7_0", + "ujson 4.0.2 py39h2531618_0", + "unicodecsv 0.14.1 py39h06a4308_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.7 pyhd3eb1b0_0", + "watchdog 2.1.3 py39h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py39h06a4308_1", + "werkzeug 2.0.2 pyhd3eb1b0_0", + "wheel 0.37.0 pyhd3eb1b0_1", + "whichcraft 0.6.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.1 py39h06a4308_0", + "wrapt 1.12.1 py39he8ac12f_1", + "wurlitzer 2.1.1 py39h06a4308_0", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.1 pyhd3eb1b0_0", + "xlwt 1.3.0 py39h06a4308_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h2531618_6", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.6.0 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py39h06a4308_1", + "zope.event 4.5.0 py39h06a4308_0", + "zope.interface 5.4.0 py39h7f8727e_0", + "zstd 1.4.9 haebb681_0" + ], + "license": "BSD", + "md5": "f52829c705800b1ee7f2d475ff5ab16a", + "name": "anaconda", + "namespace": "python", + "sha256": "2ce6c8f01ef2c201c6ff24a2efac6adc42bcd3a16a974b314036b88bcde24a4d", + "size": 15417, + "subdir": "linux-64", + "timestamp": 1636485484252, + "version": "2021.11" + }, + "anaconda-2022.05-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 4.5 1_gnu", + "aiohttp 3.8.1 py37h7f8727e_1", + "aiosignal 1.2.0 pyhd3eb1b0_0", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.9.0 py37h06a4308_0", + "anaconda-project 0.10.2 pyhd3eb1b0_0", + "anyio 3.5.0 py37h06a4308_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "argon2-cffi-bindings 21.2.0 py37h7f8727e_0", + "arrow 1.2.2 pyhd3eb1b0_0", + "astroid 2.6.6 py37h06a4308_0", + "astropy 4.3.1 py37h09021b7_0", + "async-timeout 4.0.1 pyhd3eb1b0_0", + "asynctest 0.13.0 py_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.4.0 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_0", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.1 pyhd3eb1b0_0", + "backports.functools_lru_cache 1.6.4 pyhd3eb1b0_0", + "backports.tempfile 1.0 pyhd3eb1b0_1", + "backports.weakref 1.0.post1 py_1", + "bcrypt 3.2.0 py37h7b6447c_0", + "beautifulsoup4 4.11.1 py37h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.4.1 py37h7f8727e_0", + "bkcharts 0.2 py37_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 4.1.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.4.2 py37h06a4308_0", + "boto3 1.21.32 pyhd3eb1b0_0", + "botocore 1.24.32 pyhd3eb1b0_0", + "bottleneck 1.3.4 py37hce1f21e_0", + "brotli 1.0.9 he6710b0_2", + "brotlipy 0.7.0 py37h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "ca-certificates 2022.3.29 h06a4308_1", + "cachetools 4.2.2 pyhd3eb1b0_0", + "certifi 2021.10.8 py37h06a4308_2", + "cffi 1.15.0 py37hd667e15_1", + "cfitsio 3.470 hf0d0db6_6", + "chardet 4.0.0 py37h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py37h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "colorcet 2.0.6 pyhd3eb1b0_0", + "conda-content-trust 0.1.1 pyhd3eb1b0_0", + "conda-token 0.3.0 pyhd3eb1b0_0", + "constantly 15.1.0 py37h28b3542_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "cryptography 3.4.8 py37hd23ed53_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.82.0 h7f8727e_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "cython 0.29.28 py37h295c915_0", + "cytoolz 0.11.0 py37h7b6447c_0", + "daal4py 2021.5.0 py37h78b71dc_0", + "dal 2021.5.1 h06a4308_803", + "dask 2021.10.0 pyhd3eb1b0_0", + "dask-core 2021.10.0 pyhd3eb1b0_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "datashader 0.13.0 pyhd3eb1b0_1", + "datashape 0.5.4 py37h06a4308_1", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.5.1 py37h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "distributed 2021.10.0 py37h06a4308_0", + "docutils 0.17.1 py37h06a4308_1", + "entrypoints 0.4 py37h06a4308_0", + "et_xmlfile 1.1.0 py37h06a4308_0", + "expat 2.4.4 h295c915_0", + "filelock 3.6.0 pyhd3eb1b0_0", + "flake8 3.9.2 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.11.0 h70c0345_0", + "frozenlist 1.2.0 py37h7f8727e_0", + "fsspec 2022.2.0 pyhd3eb1b0_0", + "future 0.18.2 py37_1", + "gensim 4.1.2 py37h295c915_0", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h4ff587b_1", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.1.2 py37heeb90bb_0", + "google-api-core 1.25.1 pyhd3eb1b0_0", + "google-auth 1.33.0 pyhd3eb1b0_0", + "google-cloud-core 1.7.1 pyhd3eb1b0_0", + "google-cloud-storage 1.41.0 pyhd3eb1b0_0", + "google-crc32c 1.1.2 py37h27cfd23_0", + "google-resumable-media 1.3.1 pyhd3eb1b0_1", + "googleapis-common-protos 1.53.0 py37h06a4308_0", + "greenlet 1.1.1 py37h295c915_0", + "grpcio 1.42.0 py37hce63b2e_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py37h7918eee_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "holoviews 1.14.8 pyhd3eb1b0_0", + "hvplot 0.7.3 pyhd3eb1b0_1", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.3 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py37h4cda21f_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.3.0 pyhd3eb1b0_0", + "importlib-metadata 4.11.3 py37h06a4308_0", + "importlib_metadata 4.11.3 hd3eb1b0_0", + "importlib_resources 5.2.0 pyhd3eb1b0_1", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py37h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intake 0.6.5 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.9.1 py37h06a4308_0", + "ipython 7.31.1 py37h06a4308_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.1 py37h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9e h7f8727e_0", + "jq 1.6 h27cfd23_1000", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 4.4.0 py37h06a4308_0", + "jupyter 1.0.0 py37_7", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.9.2 py37h06a4308_0", + "jupyter_server 1.13.5 pyhd3eb1b0_0", + "jupyterlab 3.3.2 pyhd3eb1b0_0", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.10.3 pyhd3eb1b0_1", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.4.0 py37h06a4308_0", + "kiwisolver 1.3.2 py37h295c915_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py37h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.35.1 h7274673_9", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.4.2 h62408e4_0", + "libcrc32c 1.1.1 he6710b0_2", + "libcurl 7.82.0 h0b77cf5_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.3.0 h5101ec6_17", + "libgfortran-ng 7.5.0 ha8ba4b0_17", + "libgfortran4 7.5.0 ha8ba4b0_17", + "libgomp 9.3.0 h5101ec6_17", + "libidn2 2.3.2 h7f8727e_0", + "liblief 0.11.5 h295c915_1", + "libllvm11 11.1.0 h3826bc1_1", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.37 hbc83047_0", + "libprotobuf 3.19.1 h4ff587b_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.10.0 h8f2d780_0", + "libstdcxx-ng 9.3.0 hd4cf53a_17", + "libtiff 4.2.0 h85742a9_0", + "libunistring 0.9.10 h27cfd23_0", + "libuuid 1.0.3 h7f8727e_2", + "libwebp 1.2.2 h55f646e_0", + "libwebp-base 1.2.2 h7f8727e_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.12 h03d6c58_0", + "libxslt 1.1.34 hc22bd24_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.38.0 py37h4ff587b_0", + "locket 0.2.1 py37h06a4308_2", + "lxml 4.8.0 py37h1f438cf_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markdown 3.3.4 py37h06a4308_0", + "markupsafe 2.0.1 py37h27cfd23_0", + "matplotlib 3.5.1 py37h06a4308_1", + "matplotlib-base 3.5.1 py37ha18d171_1", + "matplotlib-inline 0.1.2 pyhd3eb1b0_2", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h14c3975_1001", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py37h7f8727e_0", + "mkl_fft 1.3.1 py37hd3c417c_0", + "mkl_random 1.2.2 py37h51133e4_0", + "mock 4.0.3 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 hc856adb_0", + "mpmath 1.2.1 py37h06a4308_0", + "msgpack-python 1.0.2 py37hff7bd54_1", + "multidict 5.2.0 py37h7f8727e_2", + "multipledispatch 0.6.0 py37_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py37h06a4308_1", + "nbclassic 0.3.5 pyhd3eb1b0_0", + "nbclient 0.5.13 py37h06a4308_0", + "nbconvert 6.4.4 py37h06a4308_0", + "nbformat 5.3.0 py37h06a4308_0", + "ncurses 6.3 h7f8727e_2", + "nest-asyncio 1.5.5 py37h06a4308_0", + "networkx 2.6.3 pyhd3eb1b0_0", + "nltk 3.7 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1008", + "notebook 6.4.8 py37h06a4308_0", + "numba 0.55.1 py37h51133e4_0", + "numexpr 2.8.1 py37h6abb31d_0", + "numpy 1.21.5 py37he7a7128_1", + "numpy-base 1.21.5 py37hf524024_1", + "numpydoc 1.2 pyhd3eb1b0_0", + "olefile 0.46 py37_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.9 pyhd3eb1b0_0", + "openssl 1.1.1n h7f8727e_0", + "packaging 21.3 pyhd3eb1b0_0", + "pandas 1.3.5 py37h8c16a72_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "panel 0.13.0 py37h06a4308_0", + "param 1.12.0 pyhd3eb1b0_0", + "parsel 1.6.0 py37h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_1", + "patchelf 0.13 h295c915_0", + "pathspec 0.7.0 py_0", + "patsy 0.5.2 py37h06a4308_1", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py37_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.0.1 py37h22f2fdc_0", + "pip 21.2.2 py37h06a4308_0", + "pkginfo 1.8.2 pyhd3eb1b0_0", + "plotly 5.6.0 pyhd3eb1b0_0", + "pluggy 1.0.0 py37h06a4308_1", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.13.1 pyhd3eb1b0_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "protego 0.1.16 py_0", + "protobuf 3.19.1 py37h295c915_0", + "psutil 5.8.0 py37h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.11.0 pyhd3eb1b0_0", + "py-lief 0.11.5 py37h295c915_1", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pyasn1-modules 0.2.8 py_0", + "pycodestyle 2.7.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py37h27cfd23_0", + "pycparser 2.21 pyhd3eb1b0_0", + "pycrypto 2.6.1 py37h7b6447c_10", + "pyct 0.4.8 py37_0", + "pycurl 7.44.1 py37h8f2d780_1", + "pydispatcher 2.0.5 py37h06a4308_2", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py37h27cfd23_0", + "pyflakes 2.3.1 pyhd3eb1b0_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pylint 2.9.6 py37h06a4308_1", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.32 py37h295c915_1", + "pyopenssl 21.0.0 pyhd3eb1b0_1", + "pyparsing 3.0.4 pyhd3eb1b0_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.18.0 py37heee7806_0", + "pysocks 1.7.1 py37_1", + "pytables 3.6.1 py37h71ec239_0", + "pytest 7.1.1 py37h06a4308_0", + "python 3.7.13 h12debd9_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-fastjsonschema 2.15.1 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.0.0 pyhd3eb1b0_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.2.4 pyhd3eb1b0_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "python-snappy 0.6.0 py37h2531618_3", + "pytz 2021.3 pyhd3eb1b0_0", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "pywavelets 1.3.0 py37h7f8727e_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py37h7f8727e_1", + "pyzmq 22.3.0 py37h295c915_2", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.3 pyhd3eb1b0_0", + "qtconsole 5.3.0 pyhd3eb1b0_0", + "qtpy 2.0.1 pyhd3eb1b0_0", + "queuelib 1.5.0 py37h06a4308_0", + "readline 8.1.2 h7f8727e_1", + "regex 2022.3.15 py37h7f8727e_0", + "requests 2.27.1 pyhd3eb1b0_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.22.0 pyhd3eb1b0_0", + "rsa 4.7.2 pyhd3eb1b0_1", + "rtree 0.9.7 py37h06a4308_1", + "ruamel_yaml 0.15.100 py37h27cfd23_0", + "s3transfer 0.5.0 pyhd3eb1b0_0", + "scikit-image 0.19.2 py37h51133e4_0", + "scikit-learn 1.0.2 py37h51133e4_1", + "scikit-learn-intelex 2021.5.0 py37h06a4308_0", + "scipy 1.7.3 py37hc147768_0", + "scrapy 2.6.1 py37h06a4308_0", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py37h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "service_identity 18.1.0 pyhd3eb1b0_1", + "setuptools 61.2.0 py37h06a4308_0", + "sip 4.19.8 py37hf484d3e_0", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.1.0 pyhd3eb1b0_0", + "snappy 1.1.9 h295c915_0", + "sniffio 1.2.0 py37h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.1 pyhd3eb1b0_0", + "sphinx 4.4.0 pyhd3eb1b0_0", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "spyder 5.1.5 py37h06a4308_1", + "spyder-kernels 2.1.3 py37h06a4308_0", + "sqlalchemy 1.4.32 py37h7f8727e_0", + "sqlite 3.38.2 hc218d9a_0", + "statsmodels 0.13.2 py37h7f8727e_0", + "sympy 1.10.1 py37h06a4308_0", + "tabulate 0.8.9 py37h06a4308_0", + "tbb 2021.5.0 hd09550d_0", + "tbb4py 2021.5.0 py37hd09550d_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py37h06a4308_0", + "terminado 0.13.1 py37h06a4308_0", + "testpath 0.5.0 pyhd3eb1b0_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.11 h1ccaba5_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 1.2.2 pyhd3eb1b0_0", + "toolz 0.11.2 pyhd3eb1b0_0", + "tornado 6.1 py37h27cfd23_0", + "tqdm 4.64.0 py37h06a4308_0", + "traitlets 5.1.1 pyhd3eb1b0_0", + "twisted 22.2.0 py37h7f8727e_0", + "typed-ast 1.4.3 py37h7f8727e_1", + "typing-extensions 4.1.1 hd3eb1b0_0", + "typing_extensions 4.1.1 pyh06a4308_0", + "ujson 5.1.0 py37h295c915_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.9 py37h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py37h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py37_1", + "websocket-client 0.58.0 py37h06a4308_4", + "werkzeug 2.0.3 pyhd3eb1b0_0", + "wget 1.21.3 h0b77cf5_0", + "wheel 0.37.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.2 py37h06a4308_0", + "wrapt 1.12.1 py37h7b6447c_1", + "wurlitzer 3.0.2 py37h06a4308_0", + "xarray 0.20.1 pyhd3eb1b0_1", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.3 pyhd3eb1b0_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "yarl 1.5.1 py37h7b6447c_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h295c915_6", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.7.0 pyhd3eb1b0_0", + "zlib 1.2.12 h7f8727e_2", + "zope 1.0 py37_1", + "zope.interface 5.4.0 py37h7f8727e_0", + "zstd 1.4.9 haebb681_0" + ], + "license": "BSD", + "md5": "d78c17b4f8da02fdee4bc9f983fc010c", + "name": "anaconda", + "namespace": "python", + "sha256": "2a9118a2a9d7f0ad383279dcbb78f560b49d950bbd5a38093674d37b73fcca3e", + "size": 16299, + "subdir": "linux-64", + "timestamp": 1651177267633, + "version": "2022.05" + }, + "anaconda-2022.05-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 4.5 1_gnu", + "aiohttp 3.8.1 py38h7f8727e_1", + "aiosignal 1.2.0 pyhd3eb1b0_0", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.9.0 py38h06a4308_0", + "anaconda-project 0.10.2 pyhd3eb1b0_0", + "anyio 3.5.0 py38h06a4308_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "argon2-cffi-bindings 21.2.0 py38h7f8727e_0", + "arrow 1.2.2 pyhd3eb1b0_0", + "astroid 2.6.6 py38h06a4308_0", + "astropy 5.0.4 py38hce1f21e_0", + "asttokens 2.0.5 pyhd3eb1b0_0", + "async-timeout 4.0.1 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.4.0 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_0", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.1 pyhd3eb1b0_0", + "backports.functools_lru_cache 1.6.4 pyhd3eb1b0_0", + "backports.tempfile 1.0 pyhd3eb1b0_1", + "backports.weakref 1.0.post1 py_1", + "bcrypt 3.2.0 py38h7b6447c_0", + "beautifulsoup4 4.11.1 py38h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.4.1 py38h7f8727e_0", + "bkcharts 0.2 py38_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 4.1.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.4.2 py38h06a4308_0", + "boto3 1.21.32 pyhd3eb1b0_0", + "botocore 1.24.32 pyhd3eb1b0_0", + "bottleneck 1.3.4 py38hce1f21e_0", + "brotli 1.0.9 he6710b0_2", + "brotlipy 0.7.0 py38h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "ca-certificates 2022.3.29 h06a4308_1", + "cachetools 4.2.2 pyhd3eb1b0_0", + "certifi 2021.10.8 py38h06a4308_2", + "cffi 1.15.0 py38hd667e15_1", + "cfitsio 3.470 hf0d0db6_6", + "chardet 4.0.0 py38h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py38h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py38_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "colorcet 2.0.6 pyhd3eb1b0_0", + "conda-content-trust 0.1.1 pyhd3eb1b0_0", + "conda-token 0.3.0 pyhd3eb1b0_0", + "constantly 15.1.0 pyh2b92418_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "cryptography 3.4.8 py38hd23ed53_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.82.0 h7f8727e_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "cython 0.29.28 py38h295c915_0", + "cytoolz 0.11.0 py38h7b6447c_0", + "daal4py 2021.5.0 py38h78b71dc_0", + "dal 2021.5.1 h06a4308_803", + "dask 2022.2.1 pyhd3eb1b0_0", + "dask-core 2022.2.1 pyhd3eb1b0_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "datashader 0.13.0 pyhd3eb1b0_1", + "datashape 0.5.4 py38h06a4308_1", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.5.1 py38h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "distributed 2022.2.1 pyhd3eb1b0_0", + "docutils 0.17.1 py38h06a4308_1", + "entrypoints 0.4 py38h06a4308_0", + "et_xmlfile 1.1.0 py38h06a4308_0", + "executing 0.8.3 pyhd3eb1b0_0", + "expat 2.4.4 h295c915_0", + "filelock 3.6.0 pyhd3eb1b0_0", + "flake8 3.9.2 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.11.0 h70c0345_0", + "frozenlist 1.2.0 py38h7f8727e_0", + "fsspec 2022.2.0 pyhd3eb1b0_0", + "future 0.18.2 py38_1", + "gensim 4.1.2 py38h295c915_0", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h4ff587b_1", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.1.2 py38heeb90bb_0", + "google-api-core 1.25.1 pyhd3eb1b0_0", + "google-auth 1.33.0 pyhd3eb1b0_0", + "google-cloud-core 1.7.1 pyhd3eb1b0_0", + "google-cloud-storage 1.41.0 pyhd3eb1b0_0", + "google-crc32c 1.1.2 py38h27cfd23_0", + "google-resumable-media 1.3.1 pyhd3eb1b0_1", + "googleapis-common-protos 1.53.0 py38h06a4308_0", + "greenlet 1.1.1 py38h295c915_0", + "grpcio 1.42.0 py38hce63b2e_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py38h7918eee_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "holoviews 1.14.8 pyhd3eb1b0_0", + "hvplot 0.7.3 pyhd3eb1b0_1", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.3 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py38h4cda21f_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.3.0 pyhd3eb1b0_0", + "importlib-metadata 4.11.3 py38h06a4308_0", + "importlib_metadata 4.11.3 hd3eb1b0_0", + "importlib_resources 5.2.0 pyhd3eb1b0_1", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py38h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intake 0.6.5 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.9.1 py38h06a4308_0", + "ipython 8.2.0 py38h06a4308_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.1 py38h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9e h7f8727e_0", + "jq 1.6 h27cfd23_1000", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 4.4.0 py38h06a4308_0", + "jupyter 1.0.0 py38_7", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.9.2 py38h06a4308_0", + "jupyter_server 1.13.5 pyhd3eb1b0_0", + "jupyterlab 3.3.2 pyhd3eb1b0_0", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.10.3 pyhd3eb1b0_1", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.4.0 py38h06a4308_0", + "kiwisolver 1.3.2 py38h295c915_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py38h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.35.1 h7274673_9", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.4.2 h62408e4_0", + "libcrc32c 1.1.1 he6710b0_2", + "libcurl 7.82.0 h0b77cf5_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.3.0 h5101ec6_17", + "libgfortran-ng 7.5.0 ha8ba4b0_17", + "libgfortran4 7.5.0 ha8ba4b0_17", + "libgomp 9.3.0 h5101ec6_17", + "libidn2 2.3.2 h7f8727e_0", + "liblief 0.11.5 h295c915_1", + "libllvm11 11.1.0 h3826bc1_1", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.37 hbc83047_0", + "libprotobuf 3.19.1 h4ff587b_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.10.0 h8f2d780_0", + "libstdcxx-ng 9.3.0 hd4cf53a_17", + "libtiff 4.2.0 h85742a9_0", + "libunistring 0.9.10 h27cfd23_0", + "libuuid 1.0.3 h7f8727e_2", + "libwebp 1.2.2 h55f646e_0", + "libwebp-base 1.2.2 h7f8727e_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.12 h03d6c58_0", + "libxslt 1.1.34 hc22bd24_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.38.0 py38h4ff587b_0", + "locket 0.2.1 py38h06a4308_2", + "lxml 4.8.0 py38h1f438cf_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markdown 3.3.4 py38h06a4308_0", + "markupsafe 2.0.1 py38h27cfd23_0", + "matplotlib 3.5.1 py38h06a4308_1", + "matplotlib-base 3.5.1 py38ha18d171_1", + "matplotlib-inline 0.1.2 pyhd3eb1b0_2", + "mccabe 0.6.1 py38_1", + "mistune 0.8.4 py38h7b6447c_1000", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py38h7f8727e_0", + "mkl_fft 1.3.1 py38hd3c417c_0", + "mkl_random 1.2.2 py38h51133e4_0", + "mock 4.0.3 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 hc856adb_0", + "mpmath 1.2.1 py38h06a4308_0", + "msgpack-python 1.0.2 py38hff7bd54_1", + "multidict 5.2.0 py38h7f8727e_2", + "multipledispatch 0.6.0 py38_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py38h06a4308_1", + "nbclassic 0.3.5 pyhd3eb1b0_0", + "nbclient 0.5.13 py38h06a4308_0", + "nbconvert 6.4.4 py38h06a4308_0", + "nbformat 5.3.0 py38h06a4308_0", + "ncurses 6.3 h7f8727e_2", + "nest-asyncio 1.5.5 py38h06a4308_0", + "networkx 2.7.1 pyhd3eb1b0_0", + "nltk 3.7 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1008", + "notebook 6.4.8 py38h06a4308_0", + "numba 0.55.1 py38h51133e4_0", + "numexpr 2.8.1 py38h6abb31d_0", + "numpy 1.21.5 py38he7a7128_1", + "numpy-base 1.21.5 py38hf524024_1", + "numpydoc 1.2 pyhd3eb1b0_0", + "olefile 0.46 pyhd3eb1b0_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.9 pyhd3eb1b0_0", + "openssl 1.1.1n h7f8727e_0", + "packaging 21.3 pyhd3eb1b0_0", + "pandas 1.4.2 py38h295c915_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "panel 0.13.0 py38h06a4308_0", + "param 1.12.0 pyhd3eb1b0_0", + "parsel 1.6.0 py38h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_1", + "patchelf 0.13 h295c915_0", + "pathspec 0.7.0 py_0", + "patsy 0.5.2 py38h06a4308_1", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py38_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.0.1 py38h22f2fdc_0", + "pip 21.2.4 py38h06a4308_0", + "pkginfo 1.8.2 pyhd3eb1b0_0", + "plotly 5.6.0 pyhd3eb1b0_0", + "pluggy 1.0.0 py38h06a4308_1", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.13.1 pyhd3eb1b0_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "protego 0.1.16 py_0", + "protobuf 3.19.1 py38h295c915_0", + "psutil 5.8.0 py38h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "pure_eval 0.2.2 pyhd3eb1b0_0", + "py 1.11.0 pyhd3eb1b0_0", + "py-lief 0.11.5 py38h295c915_1", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pyasn1-modules 0.2.8 py_0", + "pycodestyle 2.7.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py38h7b6447c_1", + "pycparser 2.21 pyhd3eb1b0_0", + "pyct 0.4.8 py38_0", + "pycurl 7.44.1 py38h8f2d780_1", + "pydispatcher 2.0.5 py38h06a4308_2", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py38h27cfd23_0", + "pyflakes 2.3.1 pyhd3eb1b0_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pylint 2.9.6 py38h06a4308_1", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.32 py38h295c915_1", + "pyopenssl 21.0.0 pyhd3eb1b0_1", + "pyparsing 3.0.4 pyhd3eb1b0_0", + "pyqt 5.9.2 py38h05f1152_4", + "pyrsistent 0.18.0 py38heee7806_0", + "pysocks 1.7.1 py38h06a4308_0", + "pytables 3.6.1 py38h9fd0a39_0", + "pytest 7.1.1 py38h06a4308_0", + "python 3.8.13 h12debd9_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-fastjsonschema 2.15.1 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.0.0 pyhd3eb1b0_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.2.4 pyhd3eb1b0_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "python-snappy 0.6.0 py38h2531618_3", + "pytz 2021.3 pyhd3eb1b0_0", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "pywavelets 1.3.0 py38h7f8727e_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py38h7f8727e_1", + "pyzmq 22.3.0 py38h295c915_2", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.3 pyhd3eb1b0_0", + "qtconsole 5.3.0 pyhd3eb1b0_0", + "qtpy 2.0.1 pyhd3eb1b0_0", + "queuelib 1.5.0 py38h06a4308_0", + "readline 8.1.2 h7f8727e_1", + "regex 2022.3.15 py38h7f8727e_0", + "requests 2.27.1 pyhd3eb1b0_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.22.0 pyhd3eb1b0_0", + "rsa 4.7.2 pyhd3eb1b0_1", + "rtree 0.9.7 py38h06a4308_1", + "ruamel_yaml 0.15.100 py38h27cfd23_0", + "s3transfer 0.5.0 pyhd3eb1b0_0", + "scikit-image 0.19.2 py38h51133e4_0", + "scikit-learn 1.0.2 py38h51133e4_1", + "scikit-learn-intelex 2021.5.0 py38h06a4308_0", + "scipy 1.7.3 py38hc147768_0", + "scrapy 2.6.1 py38h06a4308_0", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py38h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "service_identity 18.1.0 pyhd3eb1b0_1", + "setuptools 61.2.0 py38h06a4308_0", + "sip 4.19.13 py38h295c915_0", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.1.0 pyhd3eb1b0_0", + "snappy 1.1.9 h295c915_0", + "sniffio 1.2.0 py38h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.1 pyhd3eb1b0_0", + "sphinx 4.4.0 pyhd3eb1b0_0", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "spyder 5.1.5 py38h06a4308_1", + "spyder-kernels 2.1.3 py38h06a4308_0", + "sqlalchemy 1.4.32 py38h7f8727e_0", + "sqlite 3.38.2 hc218d9a_0", + "stack_data 0.2.0 pyhd3eb1b0_0", + "statsmodels 0.13.2 py38h7f8727e_0", + "sympy 1.10.1 py38h06a4308_0", + "tabulate 0.8.9 py38h06a4308_0", + "tbb 2021.5.0 hd09550d_0", + "tbb4py 2021.5.0 py38hd09550d_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py38h06a4308_0", + "terminado 0.13.1 py38h06a4308_0", + "testpath 0.5.0 pyhd3eb1b0_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.11 h1ccaba5_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 1.2.2 pyhd3eb1b0_0", + "toolz 0.11.2 pyhd3eb1b0_0", + "tornado 6.1 py38h27cfd23_0", + "tqdm 4.64.0 py38h06a4308_0", + "traitlets 5.1.1 pyhd3eb1b0_0", + "twisted 22.2.0 py38h7f8727e_0", + "typed-ast 1.4.3 py38h7f8727e_1", + "typing-extensions 4.1.1 hd3eb1b0_0", + "typing_extensions 4.1.1 pyh06a4308_0", + "ujson 5.1.0 py38h295c915_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.9 py38h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py38h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py38_1", + "websocket-client 0.58.0 py38h06a4308_4", + "werkzeug 2.0.3 pyhd3eb1b0_0", + "wget 1.21.3 h0b77cf5_0", + "wheel 0.37.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.2 py38h06a4308_0", + "wrapt 1.12.1 py38h7b6447c_1", + "wurlitzer 3.0.2 py38h06a4308_0", + "xarray 0.20.1 pyhd3eb1b0_1", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.3 pyhd3eb1b0_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "yarl 1.5.1 py38h7b6447c_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h295c915_6", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.7.0 pyhd3eb1b0_0", + "zlib 1.2.12 h7f8727e_2", + "zope 1.0 py38_1", + "zope.interface 5.4.0 py38h7f8727e_0", + "zstd 1.4.9 haebb681_0" + ], + "license": "BSD", + "md5": "aa9a205381c0990194c23a454ceae2cf", + "name": "anaconda", + "namespace": "python", + "sha256": "91fad24b4c657c9e8e082d9996f4b39210550655a83a97b55d6d1a7ea8abece8", + "size": 16288, + "subdir": "linux-64", + "timestamp": 1651176352469, + "version": "2022.05" + }, + "anaconda-2022.05-py39_0.tar.bz2": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 4.5 1_gnu", + "aiohttp 3.8.1 py39h7f8727e_1", + "aiosignal 1.2.0 pyhd3eb1b0_0", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.9.0 py39h06a4308_0", + "anaconda-project 0.10.2 pyhd3eb1b0_0", + "anyio 3.5.0 py39h06a4308_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "argon2-cffi-bindings 21.2.0 py39h7f8727e_0", + "arrow 1.2.2 pyhd3eb1b0_0", + "astroid 2.6.6 py39h06a4308_0", + "astropy 5.0.4 py39hce1f21e_0", + "asttokens 2.0.5 pyhd3eb1b0_0", + "async-timeout 4.0.1 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.4.0 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_0", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.1 pyhd3eb1b0_0", + "backports.functools_lru_cache 1.6.4 pyhd3eb1b0_0", + "backports.tempfile 1.0 pyhd3eb1b0_1", + "backports.weakref 1.0.post1 py_1", + "bcrypt 3.2.0 py39he8ac12f_0", + "beautifulsoup4 4.11.1 py39h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.4.1 py39h7f8727e_0", + "bkcharts 0.2 py39h06a4308_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 4.1.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.4.2 py39h06a4308_0", + "boto3 1.21.32 pyhd3eb1b0_0", + "botocore 1.24.32 pyhd3eb1b0_0", + "bottleneck 1.3.4 py39hce1f21e_0", + "brotli 1.0.9 he6710b0_2", + "brotlipy 0.7.0 py39h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "ca-certificates 2022.3.29 h06a4308_1", + "cachetools 4.2.2 pyhd3eb1b0_0", + "certifi 2021.10.8 py39h06a4308_2", + "cffi 1.15.0 py39hd667e15_1", + "cfitsio 3.470 hf0d0db6_6", + "chardet 4.0.0 py39h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py39h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py39h06a4308_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "colorcet 2.0.6 pyhd3eb1b0_0", + "conda-content-trust 0.1.1 pyhd3eb1b0_0", + "conda-token 0.3.0 pyhd3eb1b0_0", + "constantly 15.1.0 pyh2b92418_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "cryptography 3.4.8 py39hd23ed53_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.82.0 h7f8727e_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "cython 0.29.28 py39h295c915_0", + "cytoolz 0.11.0 py39h27cfd23_0", + "daal4py 2021.5.0 py39h78b71dc_0", + "dal 2021.5.1 h06a4308_803", + "dask 2022.2.1 pyhd3eb1b0_0", + "dask-core 2022.2.1 pyhd3eb1b0_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "datashader 0.13.0 pyhd3eb1b0_1", + "datashape 0.5.4 py39h06a4308_1", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.5.1 py39h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "distributed 2022.2.1 pyhd3eb1b0_0", + "docutils 0.17.1 py39h06a4308_1", + "entrypoints 0.4 py39h06a4308_0", + "et_xmlfile 1.1.0 py39h06a4308_0", + "executing 0.8.3 pyhd3eb1b0_0", + "expat 2.4.4 h295c915_0", + "filelock 3.6.0 pyhd3eb1b0_0", + "flake8 3.9.2 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.11.0 h70c0345_0", + "frozenlist 1.2.0 py39h7f8727e_0", + "fsspec 2022.2.0 pyhd3eb1b0_0", + "future 0.18.2 py39h06a4308_1", + "gensim 4.1.2 py39h295c915_0", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h4ff587b_1", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.1.2 py39heeb90bb_0", + "google-api-core 1.25.1 pyhd3eb1b0_0", + "google-auth 1.33.0 pyhd3eb1b0_0", + "google-cloud-core 1.7.1 pyhd3eb1b0_0", + "google-cloud-storage 1.31.0 py_0", + "google-crc32c 1.1.2 py39h27cfd23_0", + "google-resumable-media 1.3.1 pyhd3eb1b0_1", + "googleapis-common-protos 1.53.0 py39h06a4308_0", + "greenlet 1.1.1 py39h295c915_0", + "grpcio 1.42.0 py39hce63b2e_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 3.6.0 py39ha0f2276_0", + "hdf5 1.10.6 hb1b8bf9_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "holoviews 1.14.8 pyhd3eb1b0_0", + "hvplot 0.7.3 pyhd3eb1b0_1", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.3 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py39h4cda21f_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.3.0 pyhd3eb1b0_0", + "importlib-metadata 4.11.3 py39h06a4308_0", + "importlib_metadata 4.11.3 hd3eb1b0_0", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py39h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intake 0.6.5 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.9.1 py39h06a4308_0", + "ipython 8.2.0 py39h06a4308_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.1 py39h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9e h7f8727e_0", + "jq 1.6 h27cfd23_1000", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 4.4.0 py39h06a4308_0", + "jupyter 1.0.0 py39h06a4308_7", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.9.2 py39h06a4308_0", + "jupyter_server 1.13.5 pyhd3eb1b0_0", + "jupyterlab 3.3.2 pyhd3eb1b0_0", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.10.3 pyhd3eb1b0_1", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.4.0 py39h06a4308_0", + "kiwisolver 1.3.2 py39h295c915_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py39h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.35.1 h7274673_9", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.4.2 h62408e4_0", + "libcrc32c 1.1.1 he6710b0_2", + "libcurl 7.82.0 h0b77cf5_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.3.0 h5101ec6_17", + "libgfortran-ng 7.5.0 ha8ba4b0_17", + "libgfortran4 7.5.0 ha8ba4b0_17", + "libgomp 9.3.0 h5101ec6_17", + "libidn2 2.3.2 h7f8727e_0", + "liblief 0.11.5 h295c915_1", + "libllvm11 11.1.0 h3826bc1_1", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.37 hbc83047_0", + "libprotobuf 3.19.1 h4ff587b_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.10.0 h8f2d780_0", + "libstdcxx-ng 9.3.0 hd4cf53a_17", + "libtiff 4.2.0 h85742a9_0", + "libunistring 0.9.10 h27cfd23_0", + "libuuid 1.0.3 h7f8727e_2", + "libwebp 1.2.2 h55f646e_0", + "libwebp-base 1.2.2 h7f8727e_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.12 h03d6c58_0", + "libxslt 1.1.34 hc22bd24_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.38.0 py39h4ff587b_0", + "locket 0.2.1 py39h06a4308_2", + "lxml 4.8.0 py39h1f438cf_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markdown 3.3.4 py39h06a4308_0", + "markupsafe 2.0.1 py39h27cfd23_0", + "matplotlib 3.5.1 py39h06a4308_1", + "matplotlib-base 3.5.1 py39ha18d171_1", + "matplotlib-inline 0.1.2 pyhd3eb1b0_2", + "mccabe 0.6.1 py39h06a4308_1", + "mistune 0.8.4 py39h27cfd23_1000", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py39h7f8727e_0", + "mkl_fft 1.3.1 py39hd3c417c_0", + "mkl_random 1.2.2 py39h51133e4_0", + "mock 4.0.3 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 hc856adb_0", + "mpmath 1.2.1 py39h06a4308_0", + "msgpack-python 1.0.2 py39hff7bd54_1", + "multidict 5.2.0 py39h7f8727e_2", + "multipledispatch 0.6.0 py39h06a4308_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py39h06a4308_1", + "nbclassic 0.3.5 pyhd3eb1b0_0", + "nbclient 0.5.13 py39h06a4308_0", + "nbconvert 6.4.4 py39h06a4308_0", + "nbformat 5.3.0 py39h06a4308_0", + "ncurses 6.3 h7f8727e_2", + "nest-asyncio 1.5.5 py39h06a4308_0", + "networkx 2.7.1 pyhd3eb1b0_0", + "nltk 3.7 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1008", + "notebook 6.4.8 py39h06a4308_0", + "numba 0.55.1 py39h51133e4_0", + "numexpr 2.8.1 py39h6abb31d_0", + "numpy 1.21.5 py39he7a7128_1", + "numpy-base 1.21.5 py39hf524024_1", + "numpydoc 1.2 pyhd3eb1b0_0", + "olefile 0.46 pyhd3eb1b0_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.9 pyhd3eb1b0_0", + "openssl 1.1.1n h7f8727e_0", + "packaging 21.3 pyhd3eb1b0_0", + "pandas 1.4.2 py39h295c915_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "panel 0.13.0 py39h06a4308_0", + "param 1.12.0 pyhd3eb1b0_0", + "parsel 1.6.0 py39h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_1", + "patchelf 0.13 h295c915_0", + "pathspec 0.7.0 py_0", + "patsy 0.5.2 py39h06a4308_1", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py39h06a4308_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.0.1 py39h22f2fdc_0", + "pip 21.2.4 py39h06a4308_0", + "pkginfo 1.8.2 pyhd3eb1b0_0", + "plotly 5.6.0 pyhd3eb1b0_0", + "pluggy 1.0.0 py39h06a4308_1", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.13.1 pyhd3eb1b0_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "protego 0.1.16 py_0", + "protobuf 3.19.1 py39h295c915_0", + "psutil 5.8.0 py39h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "pure_eval 0.2.2 pyhd3eb1b0_0", + "py 1.11.0 pyhd3eb1b0_0", + "py-lief 0.11.5 py39h295c915_1", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pyasn1-modules 0.2.8 py_0", + "pycodestyle 2.7.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py39h27cfd23_0", + "pycparser 2.21 pyhd3eb1b0_0", + "pyct 0.4.6 py39h06a4308_0", + "pycurl 7.44.1 py39h8f2d780_1", + "pydispatcher 2.0.5 py39h06a4308_2", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py39h27cfd23_0", + "pyflakes 2.3.1 pyhd3eb1b0_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pylint 2.9.6 py39h06a4308_1", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.32 py39h295c915_1", + "pyopenssl 21.0.0 pyhd3eb1b0_1", + "pyparsing 3.0.4 pyhd3eb1b0_0", + "pyqt 5.9.2 py39h2531618_6", + "pyrsistent 0.18.0 py39heee7806_0", + "pysocks 1.7.1 py39h06a4308_0", + "pytables 3.6.1 py39h77479fe_1", + "pytest 7.1.1 py39h06a4308_0", + "python 3.9.12 h12debd9_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-fastjsonschema 2.15.1 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.0.0 pyhd3eb1b0_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.2.4 pyhd3eb1b0_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "python-snappy 0.6.0 py39h2531618_3", + "pytz 2021.3 pyhd3eb1b0_0", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "pywavelets 1.3.0 py39h7f8727e_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py39h7f8727e_1", + "pyzmq 22.3.0 py39h295c915_2", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.3 pyhd3eb1b0_0", + "qtconsole 5.3.0 pyhd3eb1b0_0", + "qtpy 2.0.1 pyhd3eb1b0_0", + "queuelib 1.5.0 py39h06a4308_0", + "readline 8.1.2 h7f8727e_1", + "regex 2022.3.15 py39h7f8727e_0", + "requests 2.27.1 pyhd3eb1b0_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.22.0 pyhd3eb1b0_0", + "rsa 4.7.2 pyhd3eb1b0_1", + "rtree 0.9.7 py39h06a4308_1", + "ruamel_yaml 0.15.100 py39h27cfd23_0", + "s3transfer 0.5.0 pyhd3eb1b0_0", + "scikit-image 0.19.2 py39h51133e4_0", + "scikit-learn 1.0.2 py39h51133e4_1", + "scikit-learn-intelex 2021.5.0 py39h06a4308_0", + "scipy 1.7.3 py39hc147768_0", + "scrapy 2.6.1 py39h06a4308_0", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py39h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "service_identity 18.1.0 pyhd3eb1b0_1", + "setuptools 61.2.0 py39h06a4308_0", + "sip 4.19.13 py39h295c915_0", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.1.0 pyhd3eb1b0_0", + "snappy 1.1.9 h295c915_0", + "sniffio 1.2.0 py39h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.1 pyhd3eb1b0_0", + "sphinx 4.4.0 pyhd3eb1b0_0", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "spyder 5.1.5 py39h06a4308_1", + "spyder-kernels 2.1.3 py39h06a4308_0", + "sqlalchemy 1.4.32 py39h7f8727e_0", + "sqlite 3.38.2 hc218d9a_0", + "stack_data 0.2.0 pyhd3eb1b0_0", + "statsmodels 0.13.2 py39h7f8727e_0", + "sympy 1.10.1 py39h06a4308_0", + "tabulate 0.8.9 py39h06a4308_0", + "tbb 2021.5.0 hd09550d_0", + "tbb4py 2021.5.0 py39hd09550d_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py39h06a4308_0", + "terminado 0.13.1 py39h06a4308_0", + "testpath 0.5.0 pyhd3eb1b0_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.11 h1ccaba5_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 1.2.2 pyhd3eb1b0_0", + "toolz 0.11.2 pyhd3eb1b0_0", + "tornado 6.1 py39h27cfd23_0", + "tqdm 4.64.0 py39h06a4308_0", + "traitlets 5.1.1 pyhd3eb1b0_0", + "twisted 22.2.0 py39h7f8727e_0", + "typed-ast 1.4.3 py39h7f8727e_1", + "typing-extensions 4.1.1 hd3eb1b0_0", + "typing_extensions 4.1.1 pyh06a4308_0", + "tzdata 2022a hda174b7_0", + "ujson 5.1.0 py39h295c915_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.9 py39h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py39h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py39h06a4308_1", + "websocket-client 0.58.0 py39h06a4308_4", + "werkzeug 2.0.3 pyhd3eb1b0_0", + "wget 1.21.3 h0b77cf5_0", + "wheel 0.37.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.2 py39h06a4308_0", + "wrapt 1.12.1 py39he8ac12f_1", + "wurlitzer 3.0.2 py39h06a4308_0", + "xarray 0.20.1 pyhd3eb1b0_1", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.3 pyhd3eb1b0_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "yarl 1.6.3 py39h27cfd23_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h295c915_6", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.7.0 pyhd3eb1b0_0", + "zlib 1.2.12 h7f8727e_2", + "zope 1.0 py39h06a4308_1", + "zope.interface 5.4.0 py39h7f8727e_0", + "zstd 1.4.9 haebb681_0" + ], + "license": "BSD", + "md5": "f591d7beeed68cc86fe68e4f5e79660b", + "name": "anaconda", + "namespace": "python", + "sha256": "d0e36171fca95816463129cb2d0d66dcb044fe001cd5fe6a4fa81af3c4eb4773", + "size": 16254, + "subdir": "linux-64", + "timestamp": 1651176341931, + "version": "2022.05" + }, + "anaconda-2022.10-py310_0.tar.bz2": { + "build": "py310_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 5.1 1_gnu", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.11.0 py310h06a4308_0", + "anaconda-project 0.11.1 py310h06a4308_0", + "anyio 3.5.0 py310h06a4308_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "argon2-cffi-bindings 21.2.0 py310h7f8727e_0", + "arrow 1.2.2 pyhd3eb1b0_0", + "astroid 2.11.7 py310h06a4308_0", + "astropy 5.1 py310ha9d4c09_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.4.0 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_1", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.1 pyhd3eb1b0_0", + "backports.functools_lru_cache 1.6.4 pyhd3eb1b0_0", + "backports.tempfile 1.0 pyhd3eb1b0_1", + "backports.weakref 1.0.post1 py_1", + "bcrypt 3.2.0 py310h5eee18b_1", + "beautifulsoup4 4.11.1 py310h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.5.1 py310h5eee18b_0", + "bkcharts 0.2 py310h06a4308_1", + "black 22.6.0 py310h06a4308_0", + "blas 1.0 mkl", + "bleach 4.1.0 pyhd3eb1b0_0", + "blosc 1.21.0 h4ff587b_1", + "bokeh 2.4.3 py310h06a4308_0", + "boto3 1.24.28 py310h06a4308_0", + "botocore 1.27.28 py310h06a4308_0", + "bottleneck 1.3.5 py310ha9d4c09_0", + "brotli 1.0.9 h5eee18b_7", + "brotli-bin 1.0.9 h5eee18b_7", + "brotlipy 0.7.0 py310h7f8727e_1002", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "ca-certificates 2022.07.19 h06a4308_0", + "certifi 2022.9.14 py310h06a4308_0", + "cffi 1.15.1 py310h74dc2b5_0", + "cfitsio 3.470 h5893167_7", + "chardet 4.0.0 py310h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py310h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py310h06a4308_1", + "colorama 0.4.5 py310h06a4308_0", + "colorcet 3.0.0 py310h06a4308_0", + "conda-content-trust 0.1.3 py310h06a4308_0", + "conda-token 0.4.0 pyhd3eb1b0_0", + "constantly 15.1.0 py310h06a4308_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "cryptography 37.0.1 py310h9ce1e76_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.84.0 h5eee18b_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "cython 0.29.32 py310h6a678d5_0", + "cytoolz 0.11.0 py310h7f8727e_0", + "daal4py 2021.6.0 py310h3c18c91_1", + "dal 2021.6.0 hdb19cb5_916", + "dask 2022.7.0 py310h06a4308_0", + "dask-core 2022.7.0 py310h06a4308_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "datashader 0.14.1 py310h06a4308_0", + "datashape 0.5.4 py310h06a4308_1", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.5.1 py310h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "dill 0.3.4 pyhd3eb1b0_0", + "distributed 2022.7.0 py310h06a4308_0", + "docutils 0.18.1 py310h06a4308_3", + "entrypoints 0.4 py310h06a4308_0", + "et_xmlfile 1.1.0 py310h06a4308_0", + "expat 2.4.9 h6a678d5_0", + "fftw 3.3.9 h27cfd23_1", + "filelock 3.6.0 pyhd3eb1b0_0", + "flake8 4.0.1 pyhd3eb1b0_1", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.11.0 h70c0345_0", + "fsspec 2022.7.1 py310h06a4308_0", + "future 0.18.2 py310h06a4308_1", + "gensim 4.1.2 py310h295c915_0", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h4ff587b_1", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h295c915_3", + "gmpy2 2.1.2 py310heeb90bb_0", + "greenlet 1.1.1 py310h295c915_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 3.7.0 py310he06866b_0", + "hdf5 1.10.6 h3ffc7dd_1", + "heapdict 1.0.1 pyhd3eb1b0_0", + "holoviews 1.15.0 py310h06a4308_0", + "hvplot 0.8.0 py310h06a4308_0", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.3 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py310hecf7e94_1", + "imageio 2.19.3 py310h06a4308_0", + "imagesize 1.4.1 py310h06a4308_0", + "importlib-metadata 4.11.3 py310h06a4308_0", + "importlib_metadata 4.11.3 hd3eb1b0_0", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py310h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intake 0.6.5 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.15.2 py310h06a4308_0", + "ipython 7.31.1 py310h06a4308_1", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.1 py310h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jellyfish 0.9.0 py310h7f8727e_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9e h7f8727e_0", + "jq 1.6 h27cfd23_1000", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 4.16.0 py310h06a4308_0", + "jupyter 1.0.0 py310h06a4308_8", + "jupyter_client 7.3.4 py310h06a4308_0", + "jupyter_console 6.4.3 pyhd3eb1b0_0", + "jupyter_core 4.11.1 py310h06a4308_0", + "jupyter_server 1.18.1 py310h06a4308_0", + "jupyterlab 3.4.4 py310h06a4308_0", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.10.3 pyhd3eb1b0_1", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.4.0 py310h06a4308_0", + "kiwisolver 1.4.2 py310h295c915_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py310h7f8727e_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.38 h1181459_1", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.6.1 hab531cd_0", + "libbrotlicommon 1.0.9 h5eee18b_7", + "libbrotlidec 1.0.9 h5eee18b_7", + "libbrotlienc 1.0.9 h5eee18b_7", + "libclang 10.0.1 default_hb85057a_2", + "libcurl 7.84.0 h91b91d3_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libevent 2.1.12 h8f2d780_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 11.2.0 h1234567_1", + "libgfortran-ng 11.2.0 h00389a5_1", + "libgfortran5 11.2.0 h1234567_1", + "libgomp 11.2.0 h1234567_1", + "libidn2 2.3.2 h7f8727e_0", + "liblief 0.11.5 h295c915_1", + "libllvm10 10.0.1 hbcb73fb_5", + "libllvm11 11.1.0 h9e868ea_5", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.37 hbc83047_0", + "libpq 12.9 h16c4e8d_3", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.10.0 h8f2d780_0", + "libstdcxx-ng 11.2.0 h1234567_1", + "libtiff 4.4.0 hecacb30_0", + "libunistring 0.9.10 h27cfd23_0", + "libuuid 1.0.3 h7f8727e_2", + "libwebp 1.2.2 h55f646e_0", + "libwebp-base 1.2.2 h7f8727e_0", + "libxcb 1.15 h7f8727e_0", + "libxkbcommon 1.0.1 hfa300c1_0", + "libxml2 2.9.14 h74e7548_0", + "libxslt 1.1.35 h4e12654_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.38.0 py310h4ff587b_0", + "locket 1.0.0 py310h06a4308_0", + "lxml 4.9.1 py310h1edc446_0", + "lz4 3.1.3 py310h7f8727e_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markdown 3.3.4 py310h06a4308_0", + "markupsafe 2.0.1 py310h7f8727e_0", + "matplotlib 3.5.2 py310h06a4308_0", + "matplotlib-base 3.5.2 py310hf590b9c_0", + "matplotlib-inline 0.1.6 py310h06a4308_0", + "mccabe 0.7.0 pyhd3eb1b0_0", + "mistune 0.8.4 py310h7f8727e_1000", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py310h7f8727e_0", + "mkl_fft 1.3.1 py310hd6ae3a3_0", + "mkl_random 1.2.2 py310h00e6091_0", + "mock 4.0.3 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 external_0", + "mpmath 1.2.1 py310h06a4308_0", + "msgpack-python 1.0.3 py310hd09550d_0", + "multipledispatch 0.6.0 py310h06a4308_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py310h06a4308_0", + "nbclassic 0.3.5 pyhd3eb1b0_0", + "nbclient 0.5.13 py310h06a4308_0", + "nbconvert 6.4.4 py310h06a4308_0", + "nbformat 5.5.0 py310h06a4308_0", + "ncurses 6.3 h5eee18b_3", + "nest-asyncio 1.5.5 py310h06a4308_0", + "networkx 2.8.4 py310h06a4308_0", + "nltk 3.7 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1008", + "notebook 6.4.12 py310h06a4308_0", + "nspr 4.33 h295c915_0", + "nss 3.74 h0370c37_0", + "numba 0.55.1 py310h00e6091_0", + "numexpr 2.8.3 py310hcea2de6_0", + "numpy 1.21.5 py310h1794996_3", + "numpy-base 1.21.5 py310hcba007f_3", + "numpydoc 1.4.0 py310h06a4308_0", + "olefile 0.46 pyhd3eb1b0_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.10 py310h5eee18b_0", + "openssl 1.1.1q h7f8727e_0", + "packaging 21.3 pyhd3eb1b0_0", + "pandas 1.4.4 py310h6a678d5_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "panel 0.13.1 py310h06a4308_0", + "param 1.12.0 pyhd3eb1b0_0", + "parsel 1.6.0 py310h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_1", + "patch 2.7.6 h7b6447c_1001", + "patchelf 0.13 h295c915_0", + "pathspec 0.9.0 py310h06a4308_0", + "patsy 0.5.2 py310h06a4308_1", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py310h06a4308_1", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.2.0 py310hace64e9_1", + "pip 22.2.2 py310h06a4308_0", + "pkginfo 1.8.2 pyhd3eb1b0_0", + "platformdirs 2.5.2 py310h06a4308_0", + "plotly 5.9.0 py310h06a4308_0", + "pluggy 1.0.0 py310h06a4308_1", + "ply 3.11 py310h06a4308_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.14.1 py310h06a4308_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "protego 0.1.16 py_0", + "psutil 5.9.0 py310h5eee18b_0", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.11.0 pyhd3eb1b0_0", + "py-lief 0.11.5 py310h295c915_1", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pyasn1-modules 0.2.8 py_0", + "pycodestyle 2.8.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py310h7f8727e_0", + "pycparser 2.21 pyhd3eb1b0_0", + "pyct 0.4.8 py310h06a4308_1", + "pycurl 7.45.1 py310h8f2d780_0", + "pydispatcher 2.0.5 py310h06a4308_2", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py310h7f8727e_0", + "pyflakes 2.4.0 pyhd3eb1b0_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pylint 2.14.5 py310h06a4308_0", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.34 py310h6a678d5_0", + "pyopenssl 22.0.0 pyhd3eb1b0_0", + "pyparsing 3.0.9 py310h06a4308_0", + "pyqt 5.15.7 py310h6a678d5_1", + "pyqt5-sip 12.11.0 py310h6a678d5_1", + "pyqtwebengine 5.15.7 py310h6a678d5_1", + "pyrsistent 0.18.0 py310h7f8727e_0", + "pysocks 1.7.1 py310h06a4308_0", + "pytables 3.6.1 py310hadd16c1_1", + "pytest 7.1.2 py310h06a4308_0", + "python 3.10.4 h12debd9_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-fastjsonschema 2.16.2 py310h06a4308_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.2.1 py310h06a4308_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.5.0 py310h06a4308_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "python-snappy 0.6.0 py310h295c915_0", + "pytz 2022.1 py310h06a4308_0", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "pywavelets 1.3.0 py310h7f8727e_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py310h7f8727e_0", + "pyzmq 23.2.0 py310h6a678d5_0", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.15.9 h06a4308_0", + "qt-main 5.15.2 h327a75a_7", + "qt-webengine 5.15.9 hd2b0992_4", + "qtawesome 1.0.3 pyhd3eb1b0_0", + "qtconsole 5.3.2 py310h06a4308_0", + "qtpy 2.2.0 py310h06a4308_0", + "qtwebkit 5.212 h4eab89a_4", + "queuelib 1.5.0 py310h06a4308_0", + "readline 8.1.2 h7f8727e_1", + "regex 2022.7.9 py310h5eee18b_0", + "requests 2.28.1 py310h06a4308_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "ripgrep 13.0.0 hbdeaff8_0", + "rope 0.22.0 pyhd3eb1b0_0", + "rtree 0.9.7 py310h06a4308_1", + "ruamel_yaml 0.15.100 py310h7f8727e_0", + "s3transfer 0.6.0 py310h06a4308_0", + "scikit-image 0.19.2 py310h00e6091_0", + "scikit-learn 1.0.1 py310h00e6091_0", + "scikit-learn-intelex 2021.6.0 py310h06a4308_0", + "scipy 1.9.1 py310hd5efca6_0", + "scrapy 2.6.2 py310h06a4308_0", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py310h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "service_identity 18.1.0 pyhd3eb1b0_1", + "setuptools 63.4.1 py310h06a4308_0", + "sip 6.6.2 py310h6a678d5_0", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.2.1 py310h06a4308_0", + "snappy 1.1.9 h295c915_0", + "sniffio 1.2.0 py310h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.1 pyhd3eb1b0_0", + "sphinx 5.0.2 py310h06a4308_0", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "spyder 5.3.3 py310h06a4308_0", + "spyder-kernels 2.3.3 py310h06a4308_0", + "sqlalchemy 1.4.39 py310h5eee18b_0", + "sqlite 3.39.3 h5082296_0", + "statsmodels 0.13.2 py310h7f8727e_0", + "sympy 1.10.1 py310h06a4308_0", + "tabulate 0.8.10 py310h06a4308_0", + "tbb 2021.6.0 hdb19cb5_0", + "tbb4py 2021.6.0 py310hdb19cb5_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py310h06a4308_1", + "terminado 0.13.1 py310h06a4308_0", + "testpath 0.6.0 py310h06a4308_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.12 h1ccaba5_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 2.0.1 py310h06a4308_0", + "tomlkit 0.11.1 py310h06a4308_0", + "toolz 0.11.2 pyhd3eb1b0_0", + "tornado 6.1 py310h7f8727e_0", + "tqdm 4.64.1 py310h06a4308_0", + "traitlets 5.1.1 pyhd3eb1b0_0", + "twisted 22.2.0 py310h5eee18b_1", + "typing-extensions 4.3.0 py310h06a4308_0", + "typing_extensions 4.3.0 py310h06a4308_0", + "tzdata 2022c h04d1e81_0", + "ujson 5.4.0 py310h6a678d5_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.11 h5eee18b_0", + "urllib3 1.26.11 py310h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py310h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py310h06a4308_1", + "websocket-client 0.58.0 py310h06a4308_4", + "werkzeug 2.0.3 pyhd3eb1b0_0", + "wget 1.21.3 h0b77cf5_0", + "whatthepatch 1.0.2 py310h06a4308_0", + "wheel 0.37.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.2 py310h06a4308_0", + "wrapt 1.14.1 py310h5eee18b_0", + "wurlitzer 3.0.2 py310h06a4308_0", + "xarray 0.20.1 pyhd3eb1b0_1", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.3 pyhd3eb1b0_0", + "xz 5.2.6 h5eee18b_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h295c915_6", + "zict 2.1.0 py310h06a4308_0", + "zipp 3.8.0 py310h06a4308_0", + "zlib 1.2.12 h5eee18b_3", + "zope 1.0 py310h06a4308_1", + "zope.interface 5.4.0 py310h7f8727e_0", + "zstd 1.5.2 ha4553b6_0" + ], + "license": "BSD", + "md5": "9ef8021b1491eab4322a7e7968122329", + "name": "anaconda", + "namespace": "python", + "sha256": "3aa4c165a7072e45d3b4e441139d9a0f13c09ded06efcf4f1c617d223d7c56b8", + "size": 16284, + "subdir": "linux-64", + "timestamp": 1665077665890, + "version": "2022.10" + }, + "anaconda-2022.10-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 5.1 1_gnu", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.11.0 py37h06a4308_0", + "anaconda-project 0.11.1 py37h06a4308_0", + "anyio 3.5.0 py37h06a4308_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "argon2-cffi-bindings 21.2.0 py37h7f8727e_0", + "arrow 1.2.2 pyhd3eb1b0_0", + "astroid 2.11.7 py37h06a4308_0", + "astropy 4.3.1 py37h09021b7_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.4.0 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_1", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.1 pyhd3eb1b0_0", + "backports.functools_lru_cache 1.6.4 pyhd3eb1b0_0", + "backports.tempfile 1.0 pyhd3eb1b0_1", + "backports.weakref 1.0.post1 py_1", + "bcrypt 3.2.0 py37h5eee18b_1", + "beautifulsoup4 4.11.1 py37h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.5.1 py37h5eee18b_0", + "bkcharts 0.2 py37h06a4308_1", + "black 22.6.0 py37h06a4308_0", + "blas 1.0 mkl", + "bleach 4.1.0 pyhd3eb1b0_0", + "blosc 1.21.0 h4ff587b_1", + "bokeh 2.4.3 py37h06a4308_0", + "boto3 1.24.28 py37h06a4308_0", + "botocore 1.27.28 py37h06a4308_0", + "bottleneck 1.3.5 py37h7deecbd_0", + "brotli 1.0.9 h5eee18b_7", + "brotli-bin 1.0.9 h5eee18b_7", + "brotlipy 0.7.0 py37h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "ca-certificates 2022.07.19 h06a4308_0", + "certifi 2022.9.14 py37h06a4308_0", + "cffi 1.15.1 py37h74dc2b5_0", + "cfitsio 3.470 hf0d0db6_6", + "chardet 4.0.0 py37h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py37h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.5 py37h06a4308_0", + "colorcet 3.0.0 py37h06a4308_0", + "conda-content-trust 0.1.3 py37h06a4308_0", + "conda-token 0.4.0 pyhd3eb1b0_0", + "constantly 15.1.0 py37h28b3542_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "cryptography 37.0.1 py37h9ce1e76_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.84.0 h5eee18b_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "cython 0.29.32 py37h6a678d5_0", + "cytoolz 0.11.0 py37h7b6447c_0", + "daal4py 2021.6.0 py37h79cecc1_1", + "dal 2021.6.0 hdb19cb5_916", + "dask 2021.10.0 pyhd3eb1b0_0", + "dask-core 2021.10.0 pyhd3eb1b0_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "datashader 0.14.1 py37h06a4308_0", + "datashape 0.5.4 py37h06a4308_1", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.5.1 py37h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "dill 0.3.4 pyhd3eb1b0_0", + "distributed 2021.10.0 py37h06a4308_0", + "docutils 0.17.1 py37h06a4308_1", + "entrypoints 0.4 py37h06a4308_0", + "et_xmlfile 1.1.0 py37h06a4308_0", + "expat 2.4.9 h6a678d5_0", + "filelock 3.6.0 pyhd3eb1b0_0", + "flake8 4.0.1 pyhd3eb1b0_1", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.11.0 h70c0345_0", + "fsspec 2022.7.1 py37h06a4308_0", + "future 0.18.2 py37_1", + "gensim 4.1.2 py37h295c915_0", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h4ff587b_1", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h295c915_3", + "gmpy2 2.1.2 py37heeb90bb_0", + "greenlet 1.1.1 py37h295c915_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py37h7918eee_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "holoviews 1.15.0 py37h06a4308_0", + "hvplot 0.8.0 py37h06a4308_0", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.3 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py37hf0132c2_1", + "imageio 2.19.3 py37h06a4308_0", + "imagesize 1.4.1 py37h06a4308_0", + "importlib-metadata 3.10.0 py37h06a4308_0", + "importlib_metadata 3.10.0 hd3eb1b0_0", + "importlib_resources 5.2.0 pyhd3eb1b0_1", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py37h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intake 0.6.5 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.15.2 py37h06a4308_0", + "ipython 7.31.1 py37h06a4308_1", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.1 py37h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jellyfish 0.9.0 py37h7f8727e_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9e h7f8727e_0", + "jq 1.6 h27cfd23_1000", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 4.16.0 py37h06a4308_0", + "jupyter 1.0.0 py37h06a4308_8", + "jupyter_client 7.3.5 py37h06a4308_0", + "jupyter_console 6.4.3 pyhd3eb1b0_0", + "jupyter_core 4.11.1 py37h06a4308_0", + "jupyter_server 1.18.1 py37h06a4308_0", + "jupyterlab 3.4.4 py37h06a4308_0", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.10.3 pyhd3eb1b0_1", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.4.0 py37h06a4308_0", + "kiwisolver 1.4.2 py37h295c915_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py37h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.38 h1181459_1", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.6.1 hab531cd_0", + "libbrotlicommon 1.0.9 h5eee18b_7", + "libbrotlidec 1.0.9 h5eee18b_7", + "libbrotlienc 1.0.9 h5eee18b_7", + "libclang 10.0.1 default_hb85057a_2", + "libcurl 7.84.0 h91b91d3_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libevent 2.1.12 h8f2d780_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 11.2.0 h1234567_1", + "libgfortran-ng 7.5.0 ha8ba4b0_17", + "libgfortran4 7.5.0 ha8ba4b0_17", + "libgomp 11.2.0 h1234567_1", + "libidn2 2.3.2 h7f8727e_0", + "liblief 0.11.5 h295c915_1", + "libllvm10 10.0.1 hbcb73fb_5", + "libllvm11 11.1.0 h9e868ea_5", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.37 hbc83047_0", + "libpq 12.9 h16c4e8d_3", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.10.0 h8f2d780_0", + "libstdcxx-ng 11.2.0 h1234567_1", + "libtiff 4.4.0 hecacb30_0", + "libunistring 0.9.10 h27cfd23_0", + "libuuid 1.0.3 h7f8727e_2", + "libwebp 1.2.2 h55f646e_0", + "libwebp-base 1.2.2 h7f8727e_0", + "libxcb 1.15 h7f8727e_0", + "libxkbcommon 1.0.1 hfa300c1_0", + "libxml2 2.9.14 h74e7548_0", + "libxslt 1.1.35 h4e12654_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.38.0 py37h4ff587b_0", + "locket 1.0.0 py37h06a4308_0", + "lxml 4.9.1 py37h1edc446_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markdown 3.3.4 py37h06a4308_0", + "markupsafe 2.0.1 py37h27cfd23_0", + "matplotlib 3.5.2 py37h06a4308_0", + "matplotlib-base 3.5.2 py37hf590b9c_0", + "matplotlib-inline 0.1.6 py37h06a4308_0", + "mccabe 0.7.0 pyhd3eb1b0_0", + "mistune 0.8.4 py37h14c3975_1001", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py37h7f8727e_0", + "mkl_fft 1.3.1 py37hd3c417c_0", + "mkl_random 1.2.2 py37h51133e4_0", + "mock 4.0.3 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 hc856adb_0", + "mpmath 1.2.1 py37h06a4308_0", + "msgpack-python 1.0.3 py37hd09550d_0", + "multipledispatch 0.6.0 py37_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py37h06a4308_1", + "nbclassic 0.3.5 pyhd3eb1b0_0", + "nbclient 0.5.13 py37h06a4308_0", + "nbconvert 6.4.4 py37h06a4308_0", + "nbformat 5.5.0 py37h06a4308_0", + "ncurses 6.3 h5eee18b_3", + "nest-asyncio 1.5.5 py37h06a4308_0", + "networkx 2.6.3 pyhd3eb1b0_0", + "nltk 3.7 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1008", + "notebook 6.4.12 py37h06a4308_0", + "nspr 4.33 h295c915_0", + "nss 3.74 h0370c37_0", + "numba 0.55.1 py37h51133e4_0", + "numexpr 2.8.3 py37h807cd23_0", + "numpy 1.21.5 py37h6c91a56_3", + "numpy-base 1.21.5 py37ha15fc14_3", + "numpydoc 1.4.0 py37h06a4308_0", + "olefile 0.46 py37_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.10 py37h5eee18b_0", + "openssl 1.1.1q h7f8727e_0", + "packaging 21.3 pyhd3eb1b0_0", + "pandas 1.3.5 py37h8c16a72_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "panel 0.13.1 py37h06a4308_0", + "param 1.12.0 pyhd3eb1b0_0", + "parsel 1.6.0 py37h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_1", + "patch 2.7.6 h7b6447c_1001", + "patchelf 0.13 h295c915_0", + "pathspec 0.9.0 py37h06a4308_0", + "patsy 0.5.2 py37h06a4308_1", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py37h06a4308_1", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.2.0 py37hace64e9_1", + "pip 22.2.2 py37h06a4308_0", + "pkginfo 1.8.2 pyhd3eb1b0_0", + "pkgutil-resolve-name 1.3.10 py37h06a4308_0", + "platformdirs 2.5.2 py37h06a4308_0", + "plotly 5.9.0 py37h06a4308_0", + "pluggy 1.0.0 py37h06a4308_1", + "ply 3.11 py37_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.14.1 py37h06a4308_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "protego 0.1.16 py_0", + "psutil 5.9.0 py37h5eee18b_0", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.11.0 pyhd3eb1b0_0", + "py-lief 0.11.5 py37h295c915_1", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pyasn1-modules 0.2.8 py_0", + "pycodestyle 2.8.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py37h27cfd23_0", + "pycparser 2.21 pyhd3eb1b0_0", + "pycrypto 2.6.1 py37h7b6447c_10", + "pyct 0.4.8 py37h06a4308_1", + "pycurl 7.45.1 py37h8f2d780_0", + "pydispatcher 2.0.5 py37h06a4308_2", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py37h27cfd23_0", + "pyflakes 2.4.0 pyhd3eb1b0_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pylint 2.14.5 py37h06a4308_0", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.34 py37h6a678d5_0", + "pyopenssl 22.0.0 pyhd3eb1b0_0", + "pyparsing 3.0.9 py37h06a4308_0", + "pyqt 5.15.7 py37h6a678d5_1", + "pyqt5-sip 12.11.0 py37h6a678d5_1", + "pyqtwebengine 5.15.7 py37h6a678d5_1", + "pyrsistent 0.18.0 py37heee7806_0", + "pysocks 1.7.1 py37_1", + "pytables 3.6.1 py37h71ec239_0", + "pytest 7.1.2 py37h06a4308_0", + "python 3.7.13 h12debd9_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-fastjsonschema 2.16.2 py37h06a4308_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.2.1 py37h06a4308_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.5.0 py37h06a4308_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "python-snappy 0.6.0 py37h2531618_3", + "pytz 2022.1 py37h06a4308_0", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "pywavelets 1.3.0 py37h7f8727e_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py37h7f8727e_1", + "pyzmq 23.2.0 py37h6a678d5_0", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.15.9 h06a4308_0", + "qt-main 5.15.2 h327a75a_7", + "qt-webengine 5.15.9 hd2b0992_4", + "qtawesome 1.0.3 pyhd3eb1b0_0", + "qtconsole 5.3.2 py37h06a4308_0", + "qtpy 2.2.0 py37h06a4308_0", + "qtwebkit 5.212 h4eab89a_4", + "queuelib 1.5.0 py37h06a4308_0", + "readline 8.1.2 h7f8727e_1", + "regex 2022.7.9 py37h5eee18b_0", + "requests 2.28.1 py37h06a4308_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "ripgrep 13.0.0 hbdeaff8_0", + "rope 0.22.0 pyhd3eb1b0_0", + "rtree 0.9.7 py37h06a4308_1", + "ruamel_yaml 0.15.100 py37h27cfd23_0", + "s3transfer 0.6.0 py37h06a4308_0", + "scikit-image 0.19.2 py37h51133e4_0", + "scikit-learn 1.0.2 py37h51133e4_1", + "scikit-learn-intelex 2021.6.0 py37h06a4308_0", + "scipy 1.7.3 py37hc147768_0", + "scrapy 2.6.2 py37h06a4308_0", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py37h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "service_identity 18.1.0 pyhd3eb1b0_1", + "setuptools 63.4.1 py37h06a4308_0", + "sip 6.6.2 py37h6a678d5_0", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.2.1 py37h06a4308_0", + "snappy 1.1.9 h295c915_0", + "sniffio 1.2.0 py37h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.1 pyhd3eb1b0_0", + "sphinx 4.2.0 pyhd3eb1b0_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "spyder 5.3.3 py37h06a4308_0", + "spyder-kernels 2.3.3 py37h06a4308_0", + "sqlalchemy 1.4.39 py37h5eee18b_0", + "sqlite 3.39.3 h5082296_0", + "statsmodels 0.13.2 py37h7f8727e_0", + "sympy 1.10.1 py37h06a4308_0", + "tabulate 0.8.10 py37h06a4308_0", + "tbb 2021.6.0 hdb19cb5_0", + "tbb4py 2021.6.0 py37hdb19cb5_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py37h06a4308_1", + "terminado 0.13.1 py37h06a4308_0", + "testpath 0.6.0 py37h06a4308_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.12 h1ccaba5_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 2.0.1 py37h06a4308_0", + "tomlkit 0.11.1 py37h06a4308_0", + "toolz 0.11.2 pyhd3eb1b0_0", + "tornado 6.2 py37h5eee18b_0", + "tqdm 4.64.1 py37h06a4308_0", + "traitlets 5.1.1 pyhd3eb1b0_0", + "twisted 22.2.0 py37h5eee18b_1", + "typed-ast 1.4.3 py37h7f8727e_1", + "typing-extensions 4.3.0 py37h06a4308_0", + "typing_extensions 4.3.0 py37h06a4308_0", + "ujson 5.4.0 py37h6a678d5_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.11 h5eee18b_0", + "urllib3 1.26.11 py37h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py37h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py37_1", + "websocket-client 0.58.0 py37h06a4308_4", + "werkzeug 2.0.3 pyhd3eb1b0_0", + "wget 1.21.3 h0b77cf5_0", + "whatthepatch 1.0.2 py37h06a4308_0", + "wheel 0.37.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.2 py37h06a4308_0", + "wrapt 1.14.1 py37h5eee18b_0", + "wurlitzer 3.0.2 py37h06a4308_0", + "xarray 0.20.1 pyhd3eb1b0_1", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.3 pyhd3eb1b0_0", + "xz 5.2.6 h5eee18b_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h295c915_6", + "zict 2.1.0 py37h06a4308_0", + "zipp 3.8.0 py37h06a4308_0", + "zlib 1.2.12 h5eee18b_3", + "zope 1.0 py37_1", + "zope.interface 5.4.0 py37h7f8727e_0", + "zstd 1.5.2 ha4553b6_0" + ], + "license": "BSD", + "md5": "9c30672b6eed0ce9cd855bdfd88f454b", + "name": "anaconda", + "namespace": "python", + "sha256": "600b9e0d174cf97ecb115b37d26cf2fc6343399ea4a3282f61ee6eeffb1362a6", + "size": 16380, + "subdir": "linux-64", + "timestamp": 1665076072933, + "version": "2022.10" + }, + "anaconda-2022.10-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 5.1 1_gnu", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.11.0 py38h06a4308_0", + "anaconda-project 0.11.1 py38h06a4308_0", + "anyio 3.5.0 py38h06a4308_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "argon2-cffi-bindings 21.2.0 py38h7f8727e_0", + "arrow 1.2.2 pyhd3eb1b0_0", + "astroid 2.11.7 py38h06a4308_0", + "astropy 5.1 py38h7deecbd_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.4.0 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_1", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.1 pyhd3eb1b0_0", + "backports.functools_lru_cache 1.6.4 pyhd3eb1b0_0", + "backports.tempfile 1.0 pyhd3eb1b0_1", + "backports.weakref 1.0.post1 py_1", + "bcrypt 3.2.0 py38h5eee18b_1", + "beautifulsoup4 4.11.1 py38h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.5.1 py38h5eee18b_0", + "bkcharts 0.2 py38h06a4308_1", + "black 22.6.0 py38h06a4308_0", + "blas 1.0 mkl", + "bleach 4.1.0 pyhd3eb1b0_0", + "blosc 1.21.0 h4ff587b_1", + "bokeh 2.4.3 py38h06a4308_0", + "boto3 1.24.28 py38h06a4308_0", + "botocore 1.27.28 py38h06a4308_0", + "bottleneck 1.3.5 py38h7deecbd_0", + "brotli 1.0.9 h5eee18b_7", + "brotli-bin 1.0.9 h5eee18b_7", + "brotlipy 0.7.0 py38h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "ca-certificates 2022.07.19 h06a4308_0", + "certifi 2022.9.14 py38h06a4308_0", + "cffi 1.15.1 py38h74dc2b5_0", + "cfitsio 3.470 hf0d0db6_6", + "chardet 4.0.0 py38h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py38h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py38_1", + "colorama 0.4.5 py38h06a4308_0", + "colorcet 3.0.0 py38h06a4308_0", + "conda-content-trust 0.1.3 py38h06a4308_0", + "conda-token 0.4.0 pyhd3eb1b0_0", + "constantly 15.1.0 pyh2b92418_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "cryptography 37.0.1 py38h9ce1e76_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.84.0 h5eee18b_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "cython 0.29.32 py38h6a678d5_0", + "cytoolz 0.11.0 py38h7b6447c_0", + "daal4py 2021.6.0 py38h79cecc1_1", + "dal 2021.6.0 hdb19cb5_916", + "dask 2022.7.0 py38h06a4308_0", + "dask-core 2022.7.0 py38h06a4308_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "datashader 0.14.1 py38h06a4308_0", + "datashape 0.5.4 py38h06a4308_1", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.5.1 py38h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "dill 0.3.4 pyhd3eb1b0_0", + "distributed 2022.7.0 py38h06a4308_0", + "docutils 0.18.1 py38h06a4308_3", + "entrypoints 0.4 py38h06a4308_0", + "et_xmlfile 1.1.0 py38h06a4308_0", + "expat 2.4.9 h6a678d5_0", + "filelock 3.6.0 pyhd3eb1b0_0", + "flake8 4.0.1 pyhd3eb1b0_1", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.11.0 h70c0345_0", + "fsspec 2022.7.1 py38h06a4308_0", + "future 0.18.2 py38_1", + "gensim 4.1.2 py38h295c915_0", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h4ff587b_1", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h295c915_3", + "gmpy2 2.1.2 py38heeb90bb_0", + "greenlet 1.1.1 py38h295c915_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py38h7918eee_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "holoviews 1.15.0 py38h06a4308_0", + "hvplot 0.8.0 py38h06a4308_0", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.3 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py38hf0132c2_1", + "imageio 2.19.3 py38h06a4308_0", + "imagesize 1.4.1 py38h06a4308_0", + "importlib-metadata 4.11.3 py38h06a4308_0", + "importlib_metadata 4.11.3 hd3eb1b0_0", + "importlib_resources 5.2.0 pyhd3eb1b0_1", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py38h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intake 0.6.5 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.15.2 py38h06a4308_0", + "ipython 7.31.1 py38h06a4308_1", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.1 py38h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jellyfish 0.9.0 py38h7f8727e_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9e h7f8727e_0", + "jq 1.6 h27cfd23_1000", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 4.16.0 py38h06a4308_0", + "jupyter 1.0.0 py38h06a4308_8", + "jupyter_client 7.3.4 py38h06a4308_0", + "jupyter_console 6.4.3 pyhd3eb1b0_0", + "jupyter_core 4.11.1 py38h06a4308_0", + "jupyter_server 1.18.1 py38h06a4308_0", + "jupyterlab 3.4.4 py38h06a4308_0", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.10.3 pyhd3eb1b0_1", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.4.0 py38h06a4308_0", + "kiwisolver 1.4.2 py38h295c915_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py38h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.38 h1181459_1", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.6.1 hab531cd_0", + "libbrotlicommon 1.0.9 h5eee18b_7", + "libbrotlidec 1.0.9 h5eee18b_7", + "libbrotlienc 1.0.9 h5eee18b_7", + "libclang 10.0.1 default_hb85057a_2", + "libcurl 7.84.0 h91b91d3_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libevent 2.1.12 h8f2d780_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 11.2.0 h1234567_1", + "libgfortran-ng 7.5.0 ha8ba4b0_17", + "libgfortran4 7.5.0 ha8ba4b0_17", + "libgomp 11.2.0 h1234567_1", + "libidn2 2.3.2 h7f8727e_0", + "liblief 0.11.5 h295c915_1", + "libllvm10 10.0.1 hbcb73fb_5", + "libllvm11 11.1.0 h9e868ea_5", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.37 hbc83047_0", + "libpq 12.9 h16c4e8d_3", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.10.0 h8f2d780_0", + "libstdcxx-ng 11.2.0 h1234567_1", + "libtiff 4.4.0 hecacb30_0", + "libunistring 0.9.10 h27cfd23_0", + "libuuid 1.0.3 h7f8727e_2", + "libwebp 1.2.2 h55f646e_0", + "libwebp-base 1.2.2 h7f8727e_0", + "libxcb 1.15 h7f8727e_0", + "libxkbcommon 1.0.1 hfa300c1_0", + "libxml2 2.9.14 h74e7548_0", + "libxslt 1.1.35 h4e12654_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.38.0 py38h4ff587b_0", + "locket 1.0.0 py38h06a4308_0", + "lxml 4.9.1 py38h1edc446_0", + "lz4 3.1.3 py38h27cfd23_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markdown 3.3.4 py38h06a4308_0", + "markupsafe 2.0.1 py38h27cfd23_0", + "matplotlib 3.5.2 py38h06a4308_0", + "matplotlib-base 3.5.2 py38hf590b9c_0", + "matplotlib-inline 0.1.6 py38h06a4308_0", + "mccabe 0.7.0 pyhd3eb1b0_0", + "mistune 0.8.4 py38h7b6447c_1000", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py38h7f8727e_0", + "mkl_fft 1.3.1 py38hd3c417c_0", + "mkl_random 1.2.2 py38h51133e4_0", + "mock 4.0.3 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 hc856adb_0", + "mpmath 1.2.1 py38h06a4308_0", + "msgpack-python 1.0.3 py38hd09550d_0", + "multipledispatch 0.6.0 py38_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py38h06a4308_1", + "nbclassic 0.3.5 pyhd3eb1b0_0", + "nbclient 0.5.13 py38h06a4308_0", + "nbconvert 6.4.4 py38h06a4308_0", + "nbformat 5.5.0 py38h06a4308_0", + "ncurses 6.3 h5eee18b_3", + "nest-asyncio 1.5.5 py38h06a4308_0", + "networkx 2.8.4 py38h06a4308_0", + "nltk 3.7 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1008", + "notebook 6.4.12 py38h06a4308_0", + "nspr 4.33 h295c915_0", + "nss 3.74 h0370c37_0", + "numba 0.55.1 py38h51133e4_0", + "numexpr 2.8.3 py38h807cd23_0", + "numpy 1.21.5 py38h6c91a56_3", + "numpy-base 1.21.5 py38ha15fc14_3", + "numpydoc 1.4.0 py38h06a4308_0", + "olefile 0.46 pyhd3eb1b0_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.10 py38h5eee18b_0", + "openssl 1.1.1q h7f8727e_0", + "packaging 21.3 pyhd3eb1b0_0", + "pandas 1.4.4 py38h6a678d5_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "panel 0.13.1 py38h06a4308_0", + "param 1.12.0 pyhd3eb1b0_0", + "parsel 1.6.0 py38h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_1", + "patch 2.7.6 h7b6447c_1001", + "patchelf 0.13 h295c915_0", + "pathspec 0.9.0 py38h06a4308_0", + "patsy 0.5.2 py38h06a4308_1", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py38h06a4308_1", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.2.0 py38hace64e9_1", + "pip 22.2.2 py38h06a4308_0", + "pkginfo 1.8.2 pyhd3eb1b0_0", + "pkgutil-resolve-name 1.3.10 py38h06a4308_0", + "platformdirs 2.5.2 py38h06a4308_0", + "plotly 5.9.0 py38h06a4308_0", + "pluggy 1.0.0 py38h06a4308_1", + "ply 3.11 py38_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.14.1 py38h06a4308_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "protego 0.1.16 py_0", + "psutil 5.9.0 py38h5eee18b_0", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.11.0 pyhd3eb1b0_0", + "py-lief 0.11.5 py38h295c915_1", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pyasn1-modules 0.2.8 py_0", + "pycodestyle 2.8.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py38h7b6447c_1", + "pycparser 2.21 pyhd3eb1b0_0", + "pyct 0.4.8 py38h06a4308_1", + "pycurl 7.45.1 py38h8f2d780_0", + "pydispatcher 2.0.5 py38h06a4308_2", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py38h27cfd23_0", + "pyflakes 2.4.0 pyhd3eb1b0_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pylint 2.14.5 py38h06a4308_0", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.34 py38h6a678d5_0", + "pyopenssl 22.0.0 pyhd3eb1b0_0", + "pyparsing 3.0.9 py38h06a4308_0", + "pyqt 5.15.7 py38h6a678d5_1", + "pyqt5-sip 12.11.0 py38h6a678d5_1", + "pyqtwebengine 5.15.7 py38h6a678d5_1", + "pyrsistent 0.18.0 py38heee7806_0", + "pysocks 1.7.1 py38h06a4308_0", + "pytables 3.6.1 py38h9fd0a39_0", + "pytest 7.1.2 py38h06a4308_0", + "python 3.8.13 h12debd9_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-fastjsonschema 2.16.2 py38h06a4308_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.2.1 py38h06a4308_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.5.0 py38h06a4308_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "python-snappy 0.6.0 py38h2531618_3", + "pytz 2022.1 py38h06a4308_0", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "pywavelets 1.3.0 py38h7f8727e_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py38h7f8727e_1", + "pyzmq 23.2.0 py38h6a678d5_0", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.15.9 h06a4308_0", + "qt-main 5.15.2 h327a75a_7", + "qt-webengine 5.15.9 hd2b0992_4", + "qtawesome 1.0.3 pyhd3eb1b0_0", + "qtconsole 5.3.2 py38h06a4308_0", + "qtpy 2.2.0 py38h06a4308_0", + "qtwebkit 5.212 h4eab89a_4", + "queuelib 1.5.0 py38h06a4308_0", + "readline 8.1.2 h7f8727e_1", + "regex 2022.7.9 py38h5eee18b_0", + "requests 2.28.1 py38h06a4308_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "ripgrep 13.0.0 hbdeaff8_0", + "rope 0.22.0 pyhd3eb1b0_0", + "rtree 0.9.7 py38h06a4308_1", + "ruamel_yaml 0.15.100 py38h27cfd23_0", + "s3transfer 0.6.0 py38h06a4308_0", + "scikit-image 0.19.2 py38h51133e4_0", + "scikit-learn 1.0.2 py38h51133e4_1", + "scikit-learn-intelex 2021.6.0 py38h06a4308_0", + "scipy 1.7.3 py38hc147768_0", + "scrapy 2.6.2 py38h06a4308_0", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py38h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "service_identity 18.1.0 pyhd3eb1b0_1", + "setuptools 63.4.1 py38h06a4308_0", + "sip 6.6.2 py38h6a678d5_0", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.2.1 py38h06a4308_0", + "snappy 1.1.9 h295c915_0", + "sniffio 1.2.0 py38h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.1 pyhd3eb1b0_0", + "sphinx 5.0.2 py38h06a4308_0", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "spyder 5.3.3 py38h06a4308_0", + "spyder-kernels 2.3.3 py38h06a4308_0", + "sqlalchemy 1.4.39 py38h5eee18b_0", + "sqlite 3.39.3 h5082296_0", + "statsmodels 0.13.2 py38h7f8727e_0", + "sympy 1.10.1 py38h06a4308_0", + "tabulate 0.8.10 py38h06a4308_0", + "tbb 2021.6.0 hdb19cb5_0", + "tbb4py 2021.6.0 py38hdb19cb5_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py38h06a4308_1", + "terminado 0.13.1 py38h06a4308_0", + "testpath 0.6.0 py38h06a4308_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.12 h1ccaba5_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 2.0.1 py38h06a4308_0", + "tomlkit 0.11.1 py38h06a4308_0", + "toolz 0.11.2 pyhd3eb1b0_0", + "tornado 6.1 py38h27cfd23_0", + "tqdm 4.64.1 py38h06a4308_0", + "traitlets 5.1.1 pyhd3eb1b0_0", + "twisted 22.2.0 py38h5eee18b_1", + "typing-extensions 4.3.0 py38h06a4308_0", + "typing_extensions 4.3.0 py38h06a4308_0", + "ujson 5.4.0 py38h6a678d5_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.11 h5eee18b_0", + "urllib3 1.26.11 py38h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py38h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py38_1", + "websocket-client 0.58.0 py38h06a4308_4", + "werkzeug 2.0.3 pyhd3eb1b0_0", + "wget 1.21.3 h0b77cf5_0", + "whatthepatch 1.0.2 py38h06a4308_0", + "wheel 0.37.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.2 py38h06a4308_0", + "wrapt 1.14.1 py38h5eee18b_0", + "wurlitzer 3.0.2 py38h06a4308_0", + "xarray 0.20.1 pyhd3eb1b0_1", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.3 pyhd3eb1b0_0", + "xz 5.2.6 h5eee18b_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h295c915_6", + "zict 2.1.0 py38h06a4308_0", + "zipp 3.8.0 py38h06a4308_0", + "zlib 1.2.12 h5eee18b_3", + "zope 1.0 py38_1", + "zope.interface 5.4.0 py38h7f8727e_0", + "zstd 1.5.2 ha4553b6_0" + ], + "license": "BSD", + "md5": "4fc81fcb9028ded804ed6a634ca13b44", + "name": "anaconda", + "namespace": "python", + "sha256": "179182d49eda08ebf9f4dad67951cfb305872590aedb517a7559c5a467eb897f", + "size": 16336, + "subdir": "linux-64", + "timestamp": 1665077601773, + "version": "2022.10" + }, + "anaconda-2022.10-py39_0.tar.bz2": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 5.1 1_gnu", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.11.0 py39h06a4308_0", + "anaconda-project 0.11.1 py39h06a4308_0", + "anyio 3.5.0 py39h06a4308_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "argon2-cffi-bindings 21.2.0 py39h7f8727e_0", + "arrow 1.2.2 pyhd3eb1b0_0", + "astroid 2.11.7 py39h06a4308_0", + "astropy 5.1 py39h7deecbd_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.4.0 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_1", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.1 pyhd3eb1b0_0", + "backports.functools_lru_cache 1.6.4 pyhd3eb1b0_0", + "backports.tempfile 1.0 pyhd3eb1b0_1", + "backports.weakref 1.0.post1 py_1", + "bcrypt 3.2.0 py39h5eee18b_1", + "beautifulsoup4 4.11.1 py39h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.5.1 py39h5eee18b_0", + "bkcharts 0.2 py39h06a4308_1", + "black 22.6.0 py39h06a4308_0", + "blas 1.0 mkl", + "bleach 4.1.0 pyhd3eb1b0_0", + "blosc 1.21.0 h4ff587b_1", + "bokeh 2.4.3 py39h06a4308_0", + "boto3 1.24.28 py39h06a4308_0", + "botocore 1.27.28 py39h06a4308_0", + "bottleneck 1.3.5 py39h7deecbd_0", + "brotli 1.0.9 h5eee18b_7", + "brotli-bin 1.0.9 h5eee18b_7", + "brotlipy 0.7.0 py39h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "ca-certificates 2022.07.19 h06a4308_0", + "certifi 2022.9.14 py39h06a4308_0", + "cffi 1.15.1 py39h74dc2b5_0", + "cfitsio 3.470 h5893167_7", + "chardet 4.0.0 py39h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py39h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py39h06a4308_1", + "colorama 0.4.5 py39h06a4308_0", + "colorcet 3.0.0 py39h06a4308_0", + "conda-content-trust 0.1.3 py39h06a4308_0", + "conda-token 0.4.0 pyhd3eb1b0_0", + "constantly 15.1.0 pyh2b92418_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "cryptography 37.0.1 py39h9ce1e76_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.84.0 h5eee18b_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "cython 0.29.32 py39h6a678d5_0", + "cytoolz 0.11.0 py39h27cfd23_0", + "daal4py 2021.6.0 py39h79cecc1_1", + "dal 2021.6.0 hdb19cb5_916", + "dask 2022.7.0 py39h06a4308_0", + "dask-core 2022.7.0 py39h06a4308_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "datashader 0.14.1 py39h06a4308_0", + "datashape 0.5.4 py39h06a4308_1", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.5.1 py39h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "dill 0.3.4 pyhd3eb1b0_0", + "distributed 2022.7.0 py39h06a4308_0", + "docutils 0.18.1 py39h06a4308_3", + "entrypoints 0.4 py39h06a4308_0", + "et_xmlfile 1.1.0 py39h06a4308_0", + "expat 2.4.9 h6a678d5_0", + "fftw 3.3.9 h27cfd23_1", + "filelock 3.6.0 pyhd3eb1b0_0", + "flake8 4.0.1 pyhd3eb1b0_1", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.11.0 h70c0345_0", + "fsspec 2022.7.1 py39h06a4308_0", + "future 0.18.2 py39h06a4308_1", + "gensim 4.1.2 py39h295c915_0", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h4ff587b_1", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h295c915_3", + "gmpy2 2.1.2 py39heeb90bb_0", + "greenlet 1.1.1 py39h295c915_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 3.7.0 py39h737f45e_0", + "hdf5 1.10.6 h3ffc7dd_1", + "heapdict 1.0.1 pyhd3eb1b0_0", + "holoviews 1.15.0 py39h06a4308_0", + "hvplot 0.8.0 py39h06a4308_0", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.3 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py39hf0132c2_1", + "imageio 2.19.3 py39h06a4308_0", + "imagesize 1.4.1 py39h06a4308_0", + "importlib-metadata 4.11.3 py39h06a4308_0", + "importlib_metadata 4.11.3 hd3eb1b0_0", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py39h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intake 0.6.5 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.15.2 py39h06a4308_0", + "ipython 7.31.1 py39h06a4308_1", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.1 py39h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jellyfish 0.9.0 py39h7f8727e_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9e h7f8727e_0", + "jq 1.6 h27cfd23_1000", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 4.16.0 py39h06a4308_0", + "jupyter 1.0.0 py39h06a4308_8", + "jupyter_client 7.3.4 py39h06a4308_0", + "jupyter_console 6.4.3 pyhd3eb1b0_0", + "jupyter_core 4.11.1 py39h06a4308_0", + "jupyter_server 1.18.1 py39h06a4308_0", + "jupyterlab 3.4.4 py39h06a4308_0", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.10.3 pyhd3eb1b0_1", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.4.0 py39h06a4308_0", + "kiwisolver 1.4.2 py39h295c915_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py39h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.38 h1181459_1", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.6.1 hab531cd_0", + "libbrotlicommon 1.0.9 h5eee18b_7", + "libbrotlidec 1.0.9 h5eee18b_7", + "libbrotlienc 1.0.9 h5eee18b_7", + "libclang 10.0.1 default_hb85057a_2", + "libcurl 7.84.0 h91b91d3_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libevent 2.1.12 h8f2d780_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 11.2.0 h1234567_1", + "libgfortran-ng 11.2.0 h00389a5_1", + "libgfortran5 11.2.0 h1234567_1", + "libgomp 11.2.0 h1234567_1", + "libidn2 2.3.2 h7f8727e_0", + "liblief 0.11.5 h295c915_1", + "libllvm10 10.0.1 hbcb73fb_5", + "libllvm11 11.1.0 h9e868ea_5", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.37 hbc83047_0", + "libpq 12.9 h16c4e8d_3", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.10.0 h8f2d780_0", + "libstdcxx-ng 11.2.0 h1234567_1", + "libtiff 4.4.0 hecacb30_0", + "libunistring 0.9.10 h27cfd23_0", + "libuuid 1.0.3 h7f8727e_2", + "libwebp 1.2.2 h55f646e_0", + "libwebp-base 1.2.2 h7f8727e_0", + "libxcb 1.15 h7f8727e_0", + "libxkbcommon 1.0.1 hfa300c1_0", + "libxml2 2.9.14 h74e7548_0", + "libxslt 1.1.35 h4e12654_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.38.0 py39h4ff587b_0", + "locket 1.0.0 py39h06a4308_0", + "lxml 4.9.1 py39h1edc446_0", + "lz4 3.1.3 py39h27cfd23_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markdown 3.3.4 py39h06a4308_0", + "markupsafe 2.0.1 py39h27cfd23_0", + "matplotlib 3.5.2 py39h06a4308_0", + "matplotlib-base 3.5.2 py39hf590b9c_0", + "matplotlib-inline 0.1.6 py39h06a4308_0", + "mccabe 0.7.0 pyhd3eb1b0_0", + "mistune 0.8.4 py39h27cfd23_1000", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py39h7f8727e_0", + "mkl_fft 1.3.1 py39hd3c417c_0", + "mkl_random 1.2.2 py39h51133e4_0", + "mock 4.0.3 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 external_0", + "mpmath 1.2.1 py39h06a4308_0", + "msgpack-python 1.0.3 py39hd09550d_0", + "multipledispatch 0.6.0 py39h06a4308_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py39h06a4308_1", + "nbclassic 0.3.5 pyhd3eb1b0_0", + "nbclient 0.5.13 py39h06a4308_0", + "nbconvert 6.4.4 py39h06a4308_0", + "nbformat 5.5.0 py39h06a4308_0", + "ncurses 6.3 h5eee18b_3", + "nest-asyncio 1.5.5 py39h06a4308_0", + "networkx 2.8.4 py39h06a4308_0", + "nltk 3.7 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1008", + "notebook 6.4.12 py39h06a4308_0", + "nspr 4.33 h295c915_0", + "nss 3.74 h0370c37_0", + "numba 0.55.1 py39h51133e4_0", + "numexpr 2.8.3 py39h807cd23_0", + "numpy 1.21.5 py39h6c91a56_3", + "numpy-base 1.21.5 py39ha15fc14_3", + "numpydoc 1.4.0 py39h06a4308_0", + "olefile 0.46 pyhd3eb1b0_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.10 py39h5eee18b_0", + "openssl 1.1.1q h7f8727e_0", + "packaging 21.3 pyhd3eb1b0_0", + "pandas 1.4.4 py39h6a678d5_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "panel 0.13.1 py39h06a4308_0", + "param 1.12.0 pyhd3eb1b0_0", + "parsel 1.6.0 py39h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_1", + "patch 2.7.6 h7b6447c_1001", + "patchelf 0.13 h295c915_0", + "pathspec 0.9.0 py39h06a4308_0", + "patsy 0.5.2 py39h06a4308_1", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py39h06a4308_1", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.2.0 py39hace64e9_1", + "pip 22.2.2 py39h06a4308_0", + "pkginfo 1.8.2 pyhd3eb1b0_0", + "platformdirs 2.5.2 py39h06a4308_0", + "plotly 5.9.0 py39h06a4308_0", + "pluggy 1.0.0 py39h06a4308_1", + "ply 3.11 py39h06a4308_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.14.1 py39h06a4308_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "protego 0.1.16 py_0", + "psutil 5.9.0 py39h5eee18b_0", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.11.0 pyhd3eb1b0_0", + "py-lief 0.11.5 py39h295c915_1", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pyasn1-modules 0.2.8 py_0", + "pycodestyle 2.8.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py39h27cfd23_0", + "pycparser 2.21 pyhd3eb1b0_0", + "pyct 0.4.8 py39h06a4308_1", + "pycurl 7.45.1 py39h8f2d780_0", + "pydispatcher 2.0.5 py39h06a4308_2", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py39h27cfd23_0", + "pyflakes 2.4.0 pyhd3eb1b0_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pylint 2.14.5 py39h06a4308_0", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.34 py39h6a678d5_0", + "pyopenssl 22.0.0 pyhd3eb1b0_0", + "pyparsing 3.0.9 py39h06a4308_0", + "pyqt 5.15.7 py39h6a678d5_1", + "pyqt5-sip 12.11.0 py39h6a678d5_1", + "pyqtwebengine 5.15.7 py39h6a678d5_1", + "pyrsistent 0.18.0 py39heee7806_0", + "pysocks 1.7.1 py39h06a4308_0", + "pytables 3.6.1 py39h77479fe_1", + "pytest 7.1.2 py39h06a4308_0", + "python 3.9.13 haa1d7c7_1", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-fastjsonschema 2.16.2 py39h06a4308_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.2.1 py39h06a4308_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.5.0 py39h06a4308_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "python-snappy 0.6.0 py39h2531618_3", + "pytz 2022.1 py39h06a4308_0", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "pywavelets 1.3.0 py39h7f8727e_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py39h7f8727e_1", + "pyzmq 23.2.0 py39h6a678d5_0", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.15.9 h06a4308_0", + "qt-main 5.15.2 h327a75a_7", + "qt-webengine 5.15.9 hd2b0992_4", + "qtawesome 1.0.3 pyhd3eb1b0_0", + "qtconsole 5.3.2 py39h06a4308_0", + "qtpy 2.2.0 py39h06a4308_0", + "qtwebkit 5.212 h4eab89a_4", + "queuelib 1.5.0 py39h06a4308_0", + "readline 8.1.2 h7f8727e_1", + "regex 2022.7.9 py39h5eee18b_0", + "requests 2.28.1 py39h06a4308_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "ripgrep 13.0.0 hbdeaff8_0", + "rope 0.22.0 pyhd3eb1b0_0", + "rtree 0.9.7 py39h06a4308_1", + "ruamel_yaml 0.15.100 py39h27cfd23_0", + "s3transfer 0.6.0 py39h06a4308_0", + "scikit-image 0.19.2 py39h51133e4_0", + "scikit-learn 1.0.2 py39h51133e4_1", + "scikit-learn-intelex 2021.6.0 py39h06a4308_0", + "scipy 1.9.1 py39h14f4228_0", + "scrapy 2.6.2 py39h06a4308_0", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py39h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "service_identity 18.1.0 pyhd3eb1b0_1", + "setuptools 63.4.1 py39h06a4308_0", + "sip 6.6.2 py39h6a678d5_0", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.2.1 py39h06a4308_0", + "snappy 1.1.9 h295c915_0", + "sniffio 1.2.0 py39h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.1 pyhd3eb1b0_0", + "sphinx 5.0.2 py39h06a4308_0", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "spyder 5.3.3 py39h06a4308_0", + "spyder-kernels 2.3.3 py39h06a4308_0", + "sqlalchemy 1.4.39 py39h5eee18b_0", + "sqlite 3.39.3 h5082296_0", + "statsmodels 0.13.2 py39h7f8727e_0", + "sympy 1.10.1 py39h06a4308_0", + "tabulate 0.8.10 py39h06a4308_0", + "tbb 2021.6.0 hdb19cb5_0", + "tbb4py 2021.6.0 py39hdb19cb5_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py39h06a4308_1", + "terminado 0.13.1 py39h06a4308_0", + "testpath 0.6.0 py39h06a4308_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.12 h1ccaba5_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 2.0.1 py39h06a4308_0", + "tomlkit 0.11.1 py39h06a4308_0", + "toolz 0.11.2 pyhd3eb1b0_0", + "tornado 6.1 py39h27cfd23_0", + "tqdm 4.64.1 py39h06a4308_0", + "traitlets 5.1.1 pyhd3eb1b0_0", + "twisted 22.2.0 py39h5eee18b_1", + "typing-extensions 4.3.0 py39h06a4308_0", + "typing_extensions 4.3.0 py39h06a4308_0", + "tzdata 2022c h04d1e81_0", + "ujson 5.4.0 py39h6a678d5_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.11 h5eee18b_0", + "urllib3 1.26.11 py39h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py39h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py39h06a4308_1", + "websocket-client 0.58.0 py39h06a4308_4", + "werkzeug 2.0.3 pyhd3eb1b0_0", + "wget 1.21.3 h0b77cf5_0", + "whatthepatch 1.0.2 py39h06a4308_0", + "wheel 0.37.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.2 py39h06a4308_0", + "wrapt 1.14.1 py39h5eee18b_0", + "wurlitzer 3.0.2 py39h06a4308_0", + "xarray 0.20.1 pyhd3eb1b0_1", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.3 pyhd3eb1b0_0", + "xz 5.2.6 h5eee18b_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h295c915_6", + "zict 2.1.0 py39h06a4308_0", + "zipp 3.8.0 py39h06a4308_0", + "zlib 1.2.12 h5eee18b_3", + "zope 1.0 py39h06a4308_1", + "zope.interface 5.4.0 py39h7f8727e_0", + "zstd 1.5.2 ha4553b6_0" + ], + "license": "BSD", + "md5": "8e3aa6b724af8717660966ae1e69a40f", + "name": "anaconda", + "namespace": "python", + "sha256": "8604fa4712fe33ac8e07420f900e15ac891e7d45745b8e9835cf4f0c609e9929", + "size": 16311, + "subdir": "linux-64", + "timestamp": 1665057949251, + "version": "2022.10" + }, + "anaconda-2023.03-py310_0.tar.bz2": { + "build": "py310_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "blas 1.0 mkl", + "ca-certificates 2023.01.10 h06a4308_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "ld_impl_linux-64 2.38 h1181459_1", + "libgfortran5 11.2.0 h1234567_1", + "libstdcxx-ng 11.2.0 h1234567_1", + "mpi 1.0 mpich", + "tzdata 2022g h04d1e81_0", + "libgfortran-ng 11.2.0 h00389a5_1", + "libgomp 11.2.0 h1234567_1", + "mkl 2021.4.0 h06a4308_640", + "mpich 3.3.2 external_0", + "_openmp_mutex 5.1 1_gnu", + "libgcc-ng 11.2.0 h1234567_1", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "charls 2.2.0 h2531618_0", + "expat 2.4.9 h6a678d5_0", + "giflib 5.2.1 h5eee18b_3", + "gmp 6.2.1 h295c915_3", + "icu 58.2 he6710b0_3", + "jpeg 9e h5eee18b_1", + "jxrlib 1.1 h7b6447c_2", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libbrotlicommon 1.0.9 h5eee18b_7", + "libdeflate 1.17 h5eee18b_0", + "libev 4.33 h7f8727e_1", + "libffi 3.4.2 h6a678d5_6", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libuuid 1.41.5 h5eee18b_0", + "libwebp-base 1.2.4 h5eee18b_1", + "libxcb 1.15 h7f8727e_0", + "libzopfli 1.0.3 he6710b0_0", + "lz4-c 1.9.4 h6a678d5_0", + "lzo 2.10 h7b6447c_2", + "ncurses 6.4 h6a678d5_0", + "ninja-base 1.10.2 hd09550d_5", + "nspr 4.33 h295c915_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openssl 1.1.1t h7f8727e_0", + "pcre 8.45 h295c915_0", + "snappy 1.1.9 h295c915_0", + "tbb 2021.7.0 hdb19cb5_0", + "xz 5.2.10 h5eee18b_1", + "yaml 0.2.5 h7b6447c_0", + "zfp 0.5.5 h295c915_6", + "zlib 1.2.13 h5eee18b_0", + "dal 2023.0.1 hdb19cb5_26647", + "glib 2.69.1 he621ea3_2", + "hdf5 1.10.6 h3ffc7dd_1", + "jq 1.6 h27cfd23_1000", + "libbrotlidec 1.0.9 h5eee18b_7", + "libbrotlienc 1.0.9 h5eee18b_7", + "libedit 3.1.20221030 h5eee18b_0", + "libevent 2.1.12 h8f2d780_0", + "libllvm10 10.0.1 hbcb73fb_5", + "libllvm11 11.1.0 h9e868ea_6", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.39 h5eee18b_0", + "libprotobuf 3.20.3 he621ea3_0", + "libssh2 1.10.0 h8f2d780_0", + "libxml2 2.9.14 h74e7548_0", + "mpfr 4.0.2 hb69a4c5_1", + "readline 8.2 h5eee18b_0", + "tk 8.6.12 h1ccaba5_0", + "zeromq 4.3.4 h2531618_0", + "zstd 1.5.2 ha4553b6_0", + "blosc 1.21.3 h6a678d5_0", + "brotli-bin 1.0.9 h5eee18b_7", + "dbus 1.13.18 hb2f20db_0", + "freetype 2.12.1 h4a9f257_0", + "gstreamer 1.14.1 h5eee18b_1", + "krb5 1.19.4 h568e23c_0", + "libclang 10.0.1 default_hb85057a_2", + "libtiff 4.5.0 h6a678d5_2", + "libxkbcommon 1.0.1 hfa300c1_0", + "libxslt 1.1.35 h4e12654_0", + "mpc 1.1.0 h10f8cd9_1", + "sqlite 3.40.1 h5082296_0", + "unixodbc 2.3.11 h5eee18b_0", + "brotli 1.0.9 h5eee18b_7", + "fontconfig 2.14.1 h52c9d5c_1", + "gst-plugins-base 1.14.1 h6a678d5_1", + "lcms2 2.12 h3be6417_0", + "libcurl 7.87.0 h91b91d3_0", + "libpq 12.9 h16c4e8d_3", + "libwebp 1.2.4 h11a3e52_1", + "nss 3.74 h0370c37_0", + "openjpeg 2.4.0 h3ad879b_0", + "python 3.10.9 h7a1cb2a_1", + "alabaster 0.7.12 pyhd3eb1b0_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 22.1.0 py310h06a4308_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "brunsli 0.1 h2531618_0", + "certifi 2022.12.7 py310h06a4308_0", + "cfitsio 3.470 h5893167_7", + "chardet 4.0.0 py310h06a4308_1003", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py310h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "colorama 0.4.6 py310h06a4308_0", + "constantly 15.1.0 py310h06a4308_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.87.0 h5eee18b_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "debugpy 1.5.1 py310h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "dill 0.3.6 py310h06a4308_0", + "docstring-to-markdown 0.11 py310h06a4308_0", + "docutils 0.18.1 py310h06a4308_3", + "entrypoints 0.4 py310h06a4308_0", + "et_xmlfile 1.1.0 py310h06a4308_0", + "executing 0.8.3 pyhd3eb1b0_0", + "filelock 3.9.0 py310h06a4308_0", + "flit-core 3.6.0 pyhd3eb1b0_0", + "fsspec 2022.11.0 py310h06a4308_0", + "future 0.18.3 py310h06a4308_0", + "gmpy2 2.1.2 py310heeb90bb_0", + "greenlet 2.0.1 py310h6a678d5_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "idna 3.4 py310h06a4308_0", + "imagesize 1.4.1 py310h06a4308_0", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py310h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jellyfish 0.9.0 py310h7f8727e_0", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.1 py310h06a4308_0", + "json5 0.9.6 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "kiwisolver 1.4.4 py310h6a678d5_0", + "lazy-object-proxy 1.6.0 py310h7f8727e_0", + "llvmlite 0.39.1 py310he621ea3_0", + "locket 1.0.0 py310h06a4308_0", + "lxml 4.9.1 py310h1edc446_0", + "lz4 3.1.3 py310h7f8727e_0", + "markdown 3.4.1 py310h06a4308_0", + "markupsafe 2.1.1 py310h7f8727e_0", + "mccabe 0.7.0 pyhd3eb1b0_0", + "mistune 0.8.4 py310h7f8727e_1000", + "mock 4.0.3 pyhd3eb1b0_0", + "mpmath 1.2.1 py310h06a4308_0", + "msgpack-python 1.0.3 py310hd09550d_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py310h06a4308_0", + "nest-asyncio 1.5.6 py310h06a4308_0", + "networkx 2.8.4 py310h06a4308_0", + "ninja 1.10.2 h06a4308_5", + "packaging 22.0 py310h06a4308_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "param 1.12.3 py310h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "pathspec 0.10.3 py310h06a4308_0", + "pep8 1.7.1 py310h06a4308_1", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.4.0 py310h6a678d5_0", + "platformdirs 2.5.2 py310h06a4308_0", + "pluggy 1.0.0 py310h06a4308_1", + "ply 3.11 py310h06a4308_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.14.1 py310h06a4308_0", + "psutil 5.9.0 py310h5eee18b_0", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "pure_eval 0.2.2 pyhd3eb1b0_0", + "py 1.11.0 pyhd3eb1b0_0", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pycodestyle 2.10.0 py310h06a4308_0", + "pycparser 2.21 pyhd3eb1b0_0", + "pycurl 7.45.1 py310h8f2d780_0", + "pydispatcher 2.0.5 py310h06a4308_2", + "pyflakes 3.0.1 py310h06a4308_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pylint-venv 2.3.0 py310h06a4308_0", + "pyodbc 4.0.34 py310h6a678d5_0", + "pyparsing 3.0.9 py310h06a4308_0", + "pyrsistent 0.18.0 py310h7f8727e_0", + "pysocks 1.7.1 py310h06a4308_0", + "python-fastjsonschema 2.16.2 py310h06a4308_0", + "python-snappy 0.6.1 py310h6a678d5_0", + "pytz 2022.7 py310h06a4308_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py310h5eee18b_1", + "pyzmq 23.2.0 py310h6a678d5_0", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qt-main 5.15.2 h327a75a_7", + "queuelib 1.5.0 py310h06a4308_0", + "regex 2022.7.9 py310h5eee18b_0", + "rtree 1.0.1 py310h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.2.1 py310h06a4308_0", + "sniffio 1.2.0 py310h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.2.post1 py310h06a4308_0", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "tabulate 0.8.10 py310h06a4308_0", + "tbb4py 2021.7.0 py310hdb19cb5_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py310h06a4308_1", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "tokenizers 0.11.4 py310h3dcd8bd_1", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 2.0.1 py310h06a4308_0", + "tomlkit 0.11.1 py310h06a4308_0", + "toolz 0.12.0 py310h06a4308_0", + "tornado 6.1 py310h7f8727e_0", + "tqdm 4.64.1 py310h06a4308_0", + "traitlets 5.7.1 py310h06a4308_0", + "ujson 5.4.0 py310h6a678d5_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py310h06a4308_1", + "whatthepatch 1.0.2 py310h06a4308_0", + "wheel 0.38.4 py310h06a4308_0", + "wrapt 1.14.1 py310h5eee18b_0", + "wurlitzer 3.0.2 py310h06a4308_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zipp 3.11.0 py310h06a4308_0", + "zope 1.0 py310h06a4308_1", + "anyio 3.5.0 py310h06a4308_0", + "asttokens 2.0.5 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_1", + "babel 2.11.0 py310h06a4308_0", + "beautifulsoup4 4.11.1 py310h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "black 22.6.0 py310h06a4308_0", + "bleach 4.1.0 pyhd3eb1b0_0", + "cffi 1.15.1 py310h5eee18b_3", + "comm 0.1.2 py310h06a4308_0", + "cytoolz 0.12.0 py310h5eee18b_0", + "flake8 6.0.0 py310h06a4308_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "importlib-metadata 4.11.3 py310h06a4308_0", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "jedi 0.18.1 py310h06a4308_1", + "jinja2 3.1.2 py310h06a4308_0", + "jsonschema 4.17.3 py310h06a4308_0", + "jupyter_core 5.2.0 py310h06a4308_0", + "jupyterlab_pygments 0.1.2 py_0", + "matplotlib-inline 0.1.6 py310h06a4308_0", + "mkl-service 2.4.0 py310h7f8727e_0", + "multipledispatch 0.6.0 py310h06a4308_0", + "nltk 3.7 pyhd3eb1b0_0", + "openpyxl 3.0.10 py310h5eee18b_0", + "partd 1.2.0 pyhd3eb1b0_1", + "pexpect 4.8.0 pyhd3eb1b0_3", + "plotly 5.9.0 py310h06a4308_0", + "prompt-toolkit 3.0.36 py310h06a4308_0", + "protego 0.1.16 py_0", + "pyasn1-modules 0.2.8 py_0", + "pydocstyle 6.3.0 py310h06a4308_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pytest 7.1.2 py310h06a4308_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "pytoolconfig 1.2.5 py310h06a4308_1", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "qt-webengine 5.15.9 hd2b0992_4", + "qtpy 2.2.0 py310h06a4308_0", + "setuptools 65.6.3 py310h06a4308_0", + "sip 6.6.2 py310h6a678d5_0", + "sqlalchemy 1.4.39 py310h5eee18b_0", + "sympy 1.11.1 py310h06a4308_0", + "terminado 0.17.1 py310h06a4308_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tinycss2 1.2.1 py310h06a4308_0", + "typing_extensions 4.4.0 py310h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py310h06a4308_0", + "websocket-client 0.58.0 py310h06a4308_4", + "werkzeug 2.2.2 py310h06a4308_0", + "zict 2.1.0 py310h06a4308_0", + "argon2-cffi-bindings 21.2.0 py310h7f8727e_0", + "arrow 1.2.3 py310h06a4308_1", + "brotlipy 0.7.0 py310h7f8727e_1002", + "cryptography 39.0.1 py310h9ce1e76_0", + "dask-core 2022.7.0 py310h06a4308_0", + "flask 2.2.2 py310h06a4308_0", + "importlib_metadata 4.11.3 hd3eb1b0_0", + "jupyter_client 7.3.4 py310h06a4308_0", + "nbformat 5.7.0 py310h06a4308_0", + "numpy-base 1.23.5 py310h8e6c178_0", + "parsel 1.6.0 py310h06a4308_0", + "pip 22.3.1 py310h06a4308_0", + "prompt_toolkit 3.0.36 hd3eb1b0_0", + "pyqt5-sip 12.11.0 py310h6a678d5_1", + "qstylizer 0.2.2 py310h06a4308_0", + "qtawesome 1.2.2 py310h06a4308_0", + "qtwebkit 5.212 h4eab89a_4", + "rope 1.7.0 py310h06a4308_0", + "stack_data 0.2.0 pyhd3eb1b0_0", + "typing-extensions 4.4.0 py310h06a4308_0", + "zope.interface 5.4.0 py310h7f8727e_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "astroid 2.14.2 py310h06a4308_0", + "bcrypt 3.2.0 py310h5eee18b_1", + "ipython 8.10.0 py310h06a4308_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "nbclient 0.5.13 py310h06a4308_0", + "pyopenssl 23.0.0 py310h06a4308_0", + "pyqt 5.15.7 py310h6a678d5_1", + "secretstorage 3.3.1 py310h06a4308_0", + "service_identity 18.1.0 pyhd3eb1b0_1", + "ipykernel 6.19.2 py310h2f386ee_0", + "keyring 23.4.0 py310h06a4308_0", + "nbconvert 6.5.4 py310h06a4308_0", + "pylint 2.16.2 py310h06a4308_0", + "pyqtwebengine 5.15.7 py310h6a678d5_1", + "twisted 22.2.0 py310h5eee18b_1", + "urllib3 1.26.14 py310h06a4308_0", + "distributed 2022.7.0 py310h06a4308_0", + "jupyter_console 6.6.2 py310h06a4308_0", + "jupyter_server 1.23.4 py310h06a4308_0", + "python-lsp-server 1.7.1 py310h06a4308_0", + "qtconsole 5.4.0 py310h06a4308_0", + "requests 2.28.1 py310h06a4308_0", + "spyder-kernels 2.4.1 py310h06a4308_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "huggingface_hub 0.10.1 py310h06a4308_0", + "jupyterlab_server 2.19.0 py310h06a4308_0", + "notebook-shim 0.2.2 py310h06a4308_0", + "pooch 1.4.0 pyhd3eb1b0_0", + "pyct 0.5.0 py310h06a4308_0", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "python-lsp-black 1.2.1 py310h06a4308_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "sphinx 5.0.2 py310h06a4308_0", + "colorcet 3.0.1 py310h06a4308_0", + "nbclassic 0.5.2 py310h06a4308_0", + "numpydoc 1.5.0 py310h06a4308_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "notebook 6.5.2 py310h06a4308_0", + "scrapy 2.8.0 py310h06a4308_0", + "spyder 5.4.1 py310h06a4308_0", + "jupyterlab 3.5.3 py310h06a4308_0", + "widgetsnbextension 3.5.2 py310h06a4308_0", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "jupyter 1.0.0 py310h06a4308_8", + "bokeh 2.4.3 py310h06a4308_0", + "panel 0.14.3 py310h06a4308_0", + "bottleneck 1.3.5 py310ha9d4c09_0", + "contourpy 1.0.5 py310hdb19cb5_0", + "daal4py 2023.0.2 py310h3c18c91_0", + "datashape 0.5.4 py310h06a4308_1", + "h5py 3.7.0 py310he06866b_0", + "imagecodecs 2021.8.26 py310h46e8fbd_2", + "imageio 2.26.0 py310h06a4308_0", + "intake 0.6.7 py310h06a4308_0", + "matplotlib 3.7.0 py310h06a4308_0", + "matplotlib-base 3.7.0 py310h1128e8f_0", + "mkl_fft 1.3.1 py310hd6ae3a3_0", + "mkl_random 1.2.2 py310h00e6091_0", + "numpy 1.23.5 py310hd5efca6_0", + "numba 0.56.4 py310h1128e8f_0", + "numexpr 2.8.4 py310h8879344_0", + "patsy 0.5.3 py310h06a4308_0", + "pyerfa 2.0.0 py310h7f8727e_0", + "pytorch 1.12.1 cpu_py310hb1f1ab4_1", + "pywavelets 1.4.1 py310h5eee18b_0", + "scipy 1.10.0 py310hd5efca6_1", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "astropy 5.1 py310ha9d4c09_0", + "gensim 4.3.0 py310h1128e8f_0", + "pandas 1.5.3 py310h1128e8f_0", + "pytables 3.7.0 py310hf19a122_1", + "scikit-image 0.19.3 py310h6a678d5_1", + "scikit-learn 1.2.1 py310h6a678d5_0", + "transformers 4.24.0 py310h06a4308_0", + "dask 2022.7.0 py310h06a4308_0", + "holoviews 1.15.4 py310h06a4308_0", + "imbalanced-learn 0.10.1 py310h06a4308_0", + "scikit-learn-intelex 2023.0.2 py310h06a4308_0", + "seaborn 0.12.2 py310h06a4308_0", + "statsmodels 0.13.5 py310ha9d4c09_1", + "xarray 2022.11.0 py310h06a4308_0", + "datashader 0.14.4 py310h06a4308_0", + "hvplot 0.8.2 py310h06a4308_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "03c957c89bd39ba4cdb833fba5885e99", + "name": "anaconda", + "namespace": "python", + "sha256": "86204f8bbef03538e2342b2f94986d0eaa4b6a8d23da070b470e139ff6affd6d", + "size": 61301, + "subdir": "linux-64", + "timestamp": 1678132269861, + "version": "2023.03" + }, + "anaconda-2023.03-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "blas 1.0 mkl", + "ca-certificates 2023.01.10 h06a4308_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "ld_impl_linux-64 2.38 h1181459_1", + "libgfortran5 11.2.0 h1234567_1", + "libstdcxx-ng 11.2.0 h1234567_1", + "mpi 1.0 mpich", + "libgfortran-ng 11.2.0 h00389a5_1", + "libgomp 11.2.0 h1234567_1", + "mkl 2021.4.0 h06a4308_640", + "mpich 3.3.2 external_0", + "_openmp_mutex 5.1 1_gnu", + "libgcc-ng 11.2.0 h1234567_1", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "charls 2.2.0 h2531618_0", + "expat 2.4.9 h6a678d5_0", + "giflib 5.2.1 h5eee18b_3", + "gmp 6.2.1 h295c915_3", + "icu 58.2 he6710b0_3", + "jpeg 9e h5eee18b_1", + "jxrlib 1.1 h7b6447c_2", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libbrotlicommon 1.0.9 h5eee18b_7", + "libdeflate 1.17 h5eee18b_0", + "libev 4.33 h7f8727e_1", + "libffi 3.4.2 h6a678d5_6", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libuuid 1.41.5 h5eee18b_0", + "libwebp-base 1.2.4 h5eee18b_1", + "libxcb 1.15 h7f8727e_0", + "libzopfli 1.0.3 he6710b0_0", + "lz4-c 1.9.4 h6a678d5_0", + "lzo 2.10 h7b6447c_2", + "ncurses 6.4 h6a678d5_0", + "ninja-base 1.10.2 hd09550d_5", + "nspr 4.33 h295c915_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openssl 1.1.1t h7f8727e_0", + "pcre 8.45 h295c915_0", + "snappy 1.1.9 h295c915_0", + "tbb 2021.7.0 hdb19cb5_0", + "xz 5.2.10 h5eee18b_1", + "yaml 0.2.5 h7b6447c_0", + "zfp 0.5.5 h295c915_6", + "zlib 1.2.13 h5eee18b_0", + "dal 2023.0.1 hdb19cb5_26647", + "glib 2.69.1 he621ea3_2", + "hdf5 1.10.6 h3ffc7dd_1", + "jq 1.6 h27cfd23_1000", + "libbrotlidec 1.0.9 h5eee18b_7", + "libbrotlienc 1.0.9 h5eee18b_7", + "libedit 3.1.20221030 h5eee18b_0", + "libevent 2.1.12 h8f2d780_0", + "libllvm10 10.0.1 hbcb73fb_5", + "libllvm11 11.1.0 h9e868ea_6", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.39 h5eee18b_0", + "libprotobuf 3.20.3 he621ea3_0", + "libssh2 1.10.0 h8f2d780_0", + "libxml2 2.9.14 h74e7548_0", + "mpfr 4.0.2 hb69a4c5_1", + "readline 8.2 h5eee18b_0", + "tk 8.6.12 h1ccaba5_0", + "zeromq 4.3.4 h2531618_0", + "zstd 1.5.2 ha4553b6_0", + "blosc 1.21.3 h6a678d5_0", + "brotli-bin 1.0.9 h5eee18b_7", + "dbus 1.13.18 hb2f20db_0", + "freetype 2.12.1 h4a9f257_0", + "gstreamer 1.14.1 h5eee18b_1", + "krb5 1.19.4 h568e23c_0", + "libclang 10.0.1 default_hb85057a_2", + "libtiff 4.5.0 h6a678d5_2", + "libxkbcommon 1.0.1 hfa300c1_0", + "libxslt 1.1.35 h4e12654_0", + "mpc 1.1.0 h10f8cd9_1", + "sqlite 3.40.1 h5082296_0", + "unixodbc 2.3.11 h5eee18b_0", + "brotli 1.0.9 h5eee18b_7", + "fontconfig 2.14.1 h52c9d5c_1", + "gst-plugins-base 1.14.1 h6a678d5_1", + "lcms2 2.12 h3be6417_0", + "libcurl 7.87.0 h91b91d3_0", + "libpq 12.9 h16c4e8d_3", + "libwebp 1.2.4 h11a3e52_1", + "nss 3.74 h0370c37_0", + "openjpeg 2.4.0 h3ad879b_0", + "python 3.8.16 h7a1cb2a_3", + "alabaster 0.7.12 pyhd3eb1b0_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 22.1.0 py38h06a4308_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "brunsli 0.1 h2531618_0", + "certifi 2022.12.7 py38h06a4308_0", + "cfitsio 3.470 h5893167_7", + "chardet 4.0.0 py38h06a4308_1003", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py38h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "colorama 0.4.6 py38h06a4308_0", + "constantly 15.1.0 pyh2b92418_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.87.0 h5eee18b_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "debugpy 1.5.1 py38h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "dill 0.3.6 py38h06a4308_0", + "docstring-to-markdown 0.11 py38h06a4308_0", + "docutils 0.18.1 py38h06a4308_3", + "entrypoints 0.4 py38h06a4308_0", + "et_xmlfile 1.1.0 py38h06a4308_0", + "executing 0.8.3 pyhd3eb1b0_0", + "filelock 3.9.0 py38h06a4308_0", + "flit-core 3.6.0 pyhd3eb1b0_0", + "fsspec 2022.11.0 py38h06a4308_0", + "future 0.18.3 py38h06a4308_0", + "gmpy2 2.1.2 py38heeb90bb_0", + "greenlet 2.0.1 py38h6a678d5_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "idna 3.4 py38h06a4308_0", + "imagesize 1.4.1 py38h06a4308_0", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py38h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jellyfish 0.9.0 py38h7f8727e_0", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.1 py38h06a4308_0", + "json5 0.9.6 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "kiwisolver 1.4.4 py38h6a678d5_0", + "lazy-object-proxy 1.6.0 py38h27cfd23_0", + "llvmlite 0.39.1 py38he621ea3_0", + "locket 1.0.0 py38h06a4308_0", + "lxml 4.9.1 py38h1edc446_0", + "lz4 3.1.3 py38h27cfd23_0", + "markupsafe 2.1.1 py38h7f8727e_0", + "mccabe 0.7.0 pyhd3eb1b0_0", + "mistune 0.8.4 py38h7b6447c_1000", + "mock 4.0.3 pyhd3eb1b0_0", + "mpmath 1.2.1 py38h06a4308_0", + "msgpack-python 1.0.3 py38hd09550d_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py38h06a4308_1", + "nest-asyncio 1.5.6 py38h06a4308_0", + "networkx 2.8.4 py38h06a4308_0", + "ninja 1.10.2 h06a4308_5", + "packaging 22.0 py38h06a4308_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "param 1.12.3 py38h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "pathspec 0.10.3 py38h06a4308_0", + "pep8 1.7.1 py38h06a4308_1", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.4.0 py38h6a678d5_0", + "pkgutil-resolve-name 1.3.10 py38h06a4308_0", + "platformdirs 2.5.2 py38h06a4308_0", + "pluggy 1.0.0 py38h06a4308_1", + "ply 3.11 py38_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.14.1 py38h06a4308_0", + "psutil 5.9.0 py38h5eee18b_0", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "pure_eval 0.2.2 pyhd3eb1b0_0", + "py 1.11.0 pyhd3eb1b0_0", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pycodestyle 2.10.0 py38h06a4308_0", + "pycparser 2.21 pyhd3eb1b0_0", + "pycurl 7.45.1 py38h8f2d780_0", + "pydispatcher 2.0.5 py38h06a4308_2", + "pyflakes 3.0.1 py38h06a4308_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pylint-venv 2.3.0 py38h06a4308_0", + "pyodbc 4.0.34 py38h6a678d5_0", + "pyparsing 3.0.9 py38h06a4308_0", + "pyrsistent 0.18.0 py38heee7806_0", + "pysocks 1.7.1 py38h06a4308_0", + "python-fastjsonschema 2.16.2 py38h06a4308_0", + "python-snappy 0.6.1 py38h6a678d5_0", + "pytz 2022.7 py38h06a4308_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py38h5eee18b_1", + "pyzmq 23.2.0 py38h6a678d5_0", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qt-main 5.15.2 h327a75a_7", + "queuelib 1.5.0 py38h06a4308_0", + "regex 2022.7.9 py38h5eee18b_0", + "rtree 1.0.1 py38h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.2.1 py38h06a4308_0", + "sniffio 1.2.0 py38h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.2.post1 py38h06a4308_0", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "tabulate 0.8.10 py38h06a4308_0", + "tbb4py 2021.7.0 py38hdb19cb5_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py38h06a4308_1", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "tokenizers 0.11.4 py38h3dcd8bd_1", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 2.0.1 py38h06a4308_0", + "tomlkit 0.11.1 py38h06a4308_0", + "toolz 0.12.0 py38h06a4308_0", + "tornado 6.1 py38h27cfd23_0", + "tqdm 4.64.1 py38h06a4308_0", + "traitlets 5.7.1 py38h06a4308_0", + "ujson 5.4.0 py38h6a678d5_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py38_1", + "whatthepatch 1.0.2 py38h06a4308_0", + "wheel 0.38.4 py38h06a4308_0", + "wrapt 1.14.1 py38h5eee18b_0", + "wurlitzer 3.0.2 py38h06a4308_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zipp 3.11.0 py38h06a4308_0", + "zope 1.0 py38_1", + "anyio 3.5.0 py38h06a4308_0", + "asttokens 2.0.5 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_1", + "babel 2.11.0 py38h06a4308_0", + "beautifulsoup4 4.11.1 py38h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bleach 4.1.0 pyhd3eb1b0_0", + "cffi 1.15.1 py38h5eee18b_3", + "comm 0.1.2 py38h06a4308_0", + "cytoolz 0.12.0 py38h5eee18b_0", + "flake8 6.0.0 py38h06a4308_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "importlib-metadata 4.11.3 py38h06a4308_0", + "importlib_resources 5.2.0 pyhd3eb1b0_1", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "jedi 0.18.1 py38h06a4308_1", + "jinja2 3.1.2 py38h06a4308_0", + "jupyter_core 5.2.0 py38h06a4308_0", + "jupyterlab_pygments 0.1.2 py_0", + "matplotlib-inline 0.1.6 py38h06a4308_0", + "mkl-service 2.4.0 py38h7f8727e_0", + "multipledispatch 0.6.0 py38_0", + "nltk 3.7 pyhd3eb1b0_0", + "openpyxl 3.0.10 py38h5eee18b_0", + "partd 1.2.0 pyhd3eb1b0_1", + "pexpect 4.8.0 pyhd3eb1b0_3", + "plotly 5.9.0 py38h06a4308_0", + "prompt-toolkit 3.0.36 py38h06a4308_0", + "protego 0.1.16 py_0", + "pyasn1-modules 0.2.8 py_0", + "pydocstyle 6.3.0 py38h06a4308_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pytest 7.1.2 py38h06a4308_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "pytoolconfig 1.2.5 py38h06a4308_1", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "qt-webengine 5.15.9 hd2b0992_4", + "qtpy 2.2.0 py38h06a4308_0", + "setuptools 65.6.3 py38h06a4308_0", + "sip 6.6.2 py38h6a678d5_0", + "sqlalchemy 1.4.39 py38h5eee18b_0", + "sympy 1.11.1 py38h06a4308_0", + "terminado 0.17.1 py38h06a4308_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tinycss2 1.2.1 py38h06a4308_0", + "typing_extensions 4.4.0 py38h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py38h06a4308_0", + "websocket-client 0.58.0 py38h06a4308_4", + "werkzeug 2.2.2 py38h06a4308_0", + "zict 2.1.0 py38h06a4308_0", + "argon2-cffi-bindings 21.2.0 py38h7f8727e_0", + "arrow 1.2.3 py38h06a4308_1", + "black 22.6.0 py38h06a4308_0", + "brotlipy 0.7.0 py38h27cfd23_1003", + "cryptography 39.0.1 py38h9ce1e76_0", + "dask-core 2022.7.0 py38h06a4308_0", + "flask 2.2.2 py38h06a4308_0", + "importlib_metadata 4.11.3 hd3eb1b0_0", + "jsonschema 4.17.3 py38h06a4308_0", + "jupyter_client 7.3.4 py38h06a4308_0", + "markdown 3.4.1 py38h06a4308_0", + "numpy-base 1.23.5 py38h31eccc5_0", + "parsel 1.6.0 py38h06a4308_0", + "pip 22.3.1 py38h06a4308_0", + "prompt_toolkit 3.0.36 hd3eb1b0_0", + "pyqt5-sip 12.11.0 py38h6a678d5_1", + "qstylizer 0.2.2 py38h06a4308_0", + "qtawesome 1.2.2 py38h06a4308_0", + "qtwebkit 5.212 h4eab89a_4", + "rope 1.7.0 py38h06a4308_0", + "stack_data 0.2.0 pyhd3eb1b0_0", + "typing-extensions 4.4.0 py38h06a4308_0", + "zope.interface 5.4.0 py38h7f8727e_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "astroid 2.14.2 py38h06a4308_0", + "bcrypt 3.2.0 py38h5eee18b_1", + "ipython 8.10.0 py38h06a4308_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "nbformat 5.7.0 py38h06a4308_0", + "pyopenssl 23.0.0 py38h06a4308_0", + "pyqt 5.15.7 py38h6a678d5_1", + "secretstorage 3.3.1 py38h06a4308_0", + "service_identity 18.1.0 pyhd3eb1b0_1", + "ipykernel 6.19.2 py38hb070fc8_0", + "keyring 23.4.0 py38h06a4308_0", + "nbclient 0.5.13 py38h06a4308_0", + "pylint 2.16.2 py38h06a4308_0", + "pyqtwebengine 5.15.7 py38h6a678d5_1", + "twisted 22.2.0 py38h5eee18b_1", + "urllib3 1.26.14 py38h06a4308_0", + "distributed 2022.7.0 py38h06a4308_0", + "jupyter_console 6.6.2 py38h06a4308_0", + "nbconvert 6.5.4 py38h06a4308_0", + "python-lsp-server 1.7.1 py38h06a4308_0", + "qtconsole 5.4.0 py38h06a4308_0", + "requests 2.28.1 py38h06a4308_0", + "spyder-kernels 2.4.1 py38h06a4308_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "huggingface_hub 0.10.1 py38h06a4308_0", + "jupyter_server 1.23.4 py38h06a4308_0", + "pooch 1.4.0 pyhd3eb1b0_0", + "pyct 0.5.0 py38h06a4308_0", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "python-lsp-black 1.2.1 py38h06a4308_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "sphinx 5.0.2 py38h06a4308_0", + "colorcet 3.0.1 py38h06a4308_0", + "jupyterlab_server 2.19.0 py38h06a4308_0", + "notebook-shim 0.2.2 py38h06a4308_0", + "numpydoc 1.5.0 py38h06a4308_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "nbclassic 0.5.2 py38h06a4308_0", + "scrapy 2.8.0 py38h06a4308_0", + "spyder 5.4.1 py38h06a4308_0", + "notebook 6.5.2 py38h06a4308_0", + "jupyterlab 3.5.3 py38h06a4308_0", + "widgetsnbextension 3.5.2 py38h06a4308_0", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "jupyter 1.0.0 py38h06a4308_8", + "bokeh 2.4.3 py38h06a4308_0", + "panel 0.14.3 py38h06a4308_0", + "bottleneck 1.3.5 py38h7deecbd_0", + "contourpy 1.0.5 py38hdb19cb5_0", + "daal4py 2023.0.2 py38h79cecc1_0", + "datashape 0.5.4 py38h06a4308_1", + "h5py 3.7.0 py38h737f45e_0", + "imagecodecs 2021.8.26 py38hfcb8610_2", + "imageio 2.26.0 py38h06a4308_0", + "intake 0.6.7 py38h06a4308_0", + "matplotlib 3.7.0 py38h06a4308_0", + "matplotlib-base 3.7.0 py38h417a72b_0", + "mkl_fft 1.3.1 py38hd3c417c_0", + "mkl_random 1.2.2 py38h51133e4_0", + "numpy 1.23.5 py38h14f4228_0", + "numba 0.56.4 py38h417a72b_0", + "numexpr 2.8.4 py38he184ba9_0", + "patsy 0.5.3 py38h06a4308_0", + "pyerfa 2.0.0 py38h27cfd23_0", + "pytorch 1.12.1 cpu_py38hb1f1ab4_1", + "pywavelets 1.4.1 py38h5eee18b_0", + "scipy 1.10.0 py38h14f4228_1", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "astropy 5.1 py38h7deecbd_0", + "gensim 4.3.0 py38h6a678d5_0", + "pandas 1.5.3 py38h417a72b_0", + "pytables 3.7.0 py38hf19a122_1", + "scikit-image 0.19.3 py38h6a678d5_1", + "scikit-learn 1.2.1 py38h6a678d5_0", + "transformers 4.24.0 py38h06a4308_0", + "dask 2022.7.0 py38h06a4308_0", + "holoviews 1.15.4 py38h06a4308_0", + "imbalanced-learn 0.10.1 py38h06a4308_0", + "scikit-learn-intelex 2023.0.2 py38h06a4308_0", + "seaborn 0.12.2 py38h06a4308_0", + "statsmodels 0.13.5 py38h7deecbd_1", + "xarray 2022.11.0 py38h06a4308_0", + "datashader 0.14.4 py38h06a4308_0", + "hvplot 0.8.2 py38h06a4308_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f4e34fcc4ca1404414f3d77132d8a798", + "name": "anaconda", + "namespace": "python", + "sha256": "c9f31b8965a87ceefb722ea11a0e3f0e20b073141dcc35ee73aeaee955f39ce6", + "size": 61379, + "subdir": "linux-64", + "timestamp": 1678132281417, + "version": "2023.03" + }, + "anaconda-2023.03-py39_0.tar.bz2": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "blas 1.0 mkl", + "ca-certificates 2023.01.10 h06a4308_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "ld_impl_linux-64 2.38 h1181459_1", + "libgfortran5 11.2.0 h1234567_1", + "libstdcxx-ng 11.2.0 h1234567_1", + "mpi 1.0 mpich", + "tzdata 2022g h04d1e81_0", + "libgfortran-ng 11.2.0 h00389a5_1", + "libgomp 11.2.0 h1234567_1", + "mkl 2021.4.0 h06a4308_640", + "mpich 3.3.2 external_0", + "_openmp_mutex 5.1 1_gnu", + "libgcc-ng 11.2.0 h1234567_1", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "charls 2.2.0 h2531618_0", + "expat 2.4.9 h6a678d5_0", + "giflib 5.2.1 h5eee18b_3", + "gmp 6.2.1 h295c915_3", + "icu 58.2 he6710b0_3", + "jpeg 9e h5eee18b_1", + "jxrlib 1.1 h7b6447c_2", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libbrotlicommon 1.0.9 h5eee18b_7", + "libdeflate 1.17 h5eee18b_0", + "libev 4.33 h7f8727e_1", + "libffi 3.4.2 h6a678d5_6", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libuuid 1.41.5 h5eee18b_0", + "libwebp-base 1.2.4 h5eee18b_1", + "libxcb 1.15 h7f8727e_0", + "libzopfli 1.0.3 he6710b0_0", + "lz4-c 1.9.4 h6a678d5_0", + "lzo 2.10 h7b6447c_2", + "ncurses 6.4 h6a678d5_0", + "ninja-base 1.10.2 hd09550d_5", + "nspr 4.33 h295c915_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openssl 1.1.1t h7f8727e_0", + "pcre 8.45 h295c915_0", + "snappy 1.1.9 h295c915_0", + "tbb 2021.7.0 hdb19cb5_0", + "xz 5.2.10 h5eee18b_1", + "yaml 0.2.5 h7b6447c_0", + "zfp 0.5.5 h295c915_6", + "zlib 1.2.13 h5eee18b_0", + "dal 2023.0.1 hdb19cb5_26647", + "glib 2.69.1 he621ea3_2", + "hdf5 1.10.6 h3ffc7dd_1", + "jq 1.6 h27cfd23_1000", + "libbrotlidec 1.0.9 h5eee18b_7", + "libbrotlienc 1.0.9 h5eee18b_7", + "libedit 3.1.20221030 h5eee18b_0", + "libevent 2.1.12 h8f2d780_0", + "libllvm10 10.0.1 hbcb73fb_5", + "libllvm11 11.1.0 h9e868ea_6", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.39 h5eee18b_0", + "libprotobuf 3.20.3 he621ea3_0", + "libssh2 1.10.0 h8f2d780_0", + "libxml2 2.9.14 h74e7548_0", + "mpfr 4.0.2 hb69a4c5_1", + "readline 8.2 h5eee18b_0", + "tk 8.6.12 h1ccaba5_0", + "zeromq 4.3.4 h2531618_0", + "zstd 1.5.2 ha4553b6_0", + "blosc 1.21.3 h6a678d5_0", + "brotli-bin 1.0.9 h5eee18b_7", + "dbus 1.13.18 hb2f20db_0", + "freetype 2.12.1 h4a9f257_0", + "gstreamer 1.14.1 h5eee18b_1", + "krb5 1.19.4 h568e23c_0", + "libclang 10.0.1 default_hb85057a_2", + "libtiff 4.5.0 h6a678d5_2", + "libxkbcommon 1.0.1 hfa300c1_0", + "libxslt 1.1.35 h4e12654_0", + "mpc 1.1.0 h10f8cd9_1", + "sqlite 3.40.1 h5082296_0", + "unixodbc 2.3.11 h5eee18b_0", + "brotli 1.0.9 h5eee18b_7", + "fontconfig 2.14.1 h52c9d5c_1", + "gst-plugins-base 1.14.1 h6a678d5_1", + "lcms2 2.12 h3be6417_0", + "libcurl 7.87.0 h91b91d3_0", + "libpq 12.9 h16c4e8d_3", + "libwebp 1.2.4 h11a3e52_1", + "nss 3.74 h0370c37_0", + "openjpeg 2.4.0 h3ad879b_0", + "python 3.9.16 h7a1cb2a_1", + "alabaster 0.7.12 pyhd3eb1b0_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 22.1.0 py39h06a4308_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "brunsli 0.1 h2531618_0", + "certifi 2022.12.7 py39h06a4308_0", + "cfitsio 3.470 h5893167_7", + "chardet 4.0.0 py39h06a4308_1003", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py39h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "colorama 0.4.6 py39h06a4308_0", + "constantly 15.1.0 pyh2b92418_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.87.0 h5eee18b_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "debugpy 1.5.1 py39h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "dill 0.3.6 py39h06a4308_0", + "docstring-to-markdown 0.11 py39h06a4308_0", + "docutils 0.18.1 py39h06a4308_3", + "entrypoints 0.4 py39h06a4308_0", + "et_xmlfile 1.1.0 py39h06a4308_0", + "executing 0.8.3 pyhd3eb1b0_0", + "filelock 3.9.0 py39h06a4308_0", + "flit-core 3.6.0 pyhd3eb1b0_0", + "fsspec 2022.11.0 py39h06a4308_0", + "future 0.18.3 py39h06a4308_0", + "gmpy2 2.1.2 py39heeb90bb_0", + "greenlet 2.0.1 py39h6a678d5_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "idna 3.4 py39h06a4308_0", + "imagesize 1.4.1 py39h06a4308_0", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py39h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jellyfish 0.9.0 py39h7f8727e_0", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.1 py39h06a4308_0", + "json5 0.9.6 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "kiwisolver 1.4.4 py39h6a678d5_0", + "lazy-object-proxy 1.6.0 py39h27cfd23_0", + "llvmlite 0.39.1 py39he621ea3_0", + "locket 1.0.0 py39h06a4308_0", + "lxml 4.9.1 py39h1edc446_0", + "lz4 3.1.3 py39h27cfd23_0", + "markupsafe 2.1.1 py39h7f8727e_0", + "mccabe 0.7.0 pyhd3eb1b0_0", + "mistune 0.8.4 py39h27cfd23_1000", + "mock 4.0.3 pyhd3eb1b0_0", + "mpmath 1.2.1 py39h06a4308_0", + "msgpack-python 1.0.3 py39hd09550d_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py39h06a4308_1", + "nest-asyncio 1.5.6 py39h06a4308_0", + "networkx 2.8.4 py39h06a4308_0", + "ninja 1.10.2 h06a4308_5", + "packaging 22.0 py39h06a4308_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "param 1.12.3 py39h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "pathspec 0.10.3 py39h06a4308_0", + "pep8 1.7.1 py39h06a4308_1", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.4.0 py39h6a678d5_0", + "platformdirs 2.5.2 py39h06a4308_0", + "pluggy 1.0.0 py39h06a4308_1", + "ply 3.11 py39h06a4308_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.14.1 py39h06a4308_0", + "psutil 5.9.0 py39h5eee18b_0", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "pure_eval 0.2.2 pyhd3eb1b0_0", + "py 1.11.0 pyhd3eb1b0_0", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pycodestyle 2.10.0 py39h06a4308_0", + "pycparser 2.21 pyhd3eb1b0_0", + "pycurl 7.45.1 py39h8f2d780_0", + "pydispatcher 2.0.5 py39h06a4308_2", + "pyflakes 3.0.1 py39h06a4308_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pylint-venv 2.3.0 py39h06a4308_0", + "pyodbc 4.0.34 py39h6a678d5_0", + "pyparsing 3.0.9 py39h06a4308_0", + "pyrsistent 0.18.0 py39heee7806_0", + "pysocks 1.7.1 py39h06a4308_0", + "python-fastjsonschema 2.16.2 py39h06a4308_0", + "python-snappy 0.6.1 py39h6a678d5_0", + "pytz 2022.7 py39h06a4308_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py39h5eee18b_1", + "pyzmq 23.2.0 py39h6a678d5_0", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qt-main 5.15.2 h327a75a_7", + "queuelib 1.5.0 py39h06a4308_0", + "regex 2022.7.9 py39h5eee18b_0", + "rtree 1.0.1 py39h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.2.1 py39h06a4308_0", + "sniffio 1.2.0 py39h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.2.post1 py39h06a4308_0", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "tabulate 0.8.10 py39h06a4308_0", + "tbb4py 2021.7.0 py39hdb19cb5_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py39h06a4308_1", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "tokenizers 0.11.4 py39h3dcd8bd_1", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 2.0.1 py39h06a4308_0", + "tomlkit 0.11.1 py39h06a4308_0", + "toolz 0.12.0 py39h06a4308_0", + "tornado 6.1 py39h27cfd23_0", + "tqdm 4.64.1 py39h06a4308_0", + "traitlets 5.7.1 py39h06a4308_0", + "ujson 5.4.0 py39h6a678d5_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py39h06a4308_1", + "whatthepatch 1.0.2 py39h06a4308_0", + "wheel 0.38.4 py39h06a4308_0", + "wrapt 1.14.1 py39h5eee18b_0", + "wurlitzer 3.0.2 py39h06a4308_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zipp 3.11.0 py39h06a4308_0", + "zope 1.0 py39h06a4308_1", + "anyio 3.5.0 py39h06a4308_0", + "asttokens 2.0.5 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_1", + "babel 2.11.0 py39h06a4308_0", + "beautifulsoup4 4.11.1 py39h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bleach 4.1.0 pyhd3eb1b0_0", + "cffi 1.15.1 py39h5eee18b_3", + "comm 0.1.2 py39h06a4308_0", + "cytoolz 0.12.0 py39h5eee18b_0", + "flake8 6.0.0 py39h06a4308_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "importlib-metadata 4.11.3 py39h06a4308_0", + "importlib_resources 5.2.0 pyhd3eb1b0_1", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "jedi 0.18.1 py39h06a4308_1", + "jinja2 3.1.2 py39h06a4308_0", + "jsonschema 4.17.3 py39h06a4308_0", + "jupyter_core 5.2.0 py39h06a4308_0", + "jupyterlab_pygments 0.1.2 py_0", + "matplotlib-inline 0.1.6 py39h06a4308_0", + "mkl-service 2.4.0 py39h7f8727e_0", + "multipledispatch 0.6.0 py39h06a4308_0", + "nltk 3.7 pyhd3eb1b0_0", + "openpyxl 3.0.10 py39h5eee18b_0", + "partd 1.2.0 pyhd3eb1b0_1", + "pexpect 4.8.0 pyhd3eb1b0_3", + "plotly 5.9.0 py39h06a4308_0", + "prompt-toolkit 3.0.36 py39h06a4308_0", + "protego 0.1.16 py_0", + "pyasn1-modules 0.2.8 py_0", + "pydocstyle 6.3.0 py39h06a4308_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pytest 7.1.2 py39h06a4308_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "pytoolconfig 1.2.5 py39h06a4308_1", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "qt-webengine 5.15.9 hd2b0992_4", + "qtpy 2.2.0 py39h06a4308_0", + "setuptools 65.6.3 py39h06a4308_0", + "sip 6.6.2 py39h6a678d5_0", + "sqlalchemy 1.4.39 py39h5eee18b_0", + "sympy 1.11.1 py39h06a4308_0", + "terminado 0.17.1 py39h06a4308_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tinycss2 1.2.1 py39h06a4308_0", + "typing_extensions 4.4.0 py39h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py39h06a4308_0", + "websocket-client 0.58.0 py39h06a4308_4", + "werkzeug 2.2.2 py39h06a4308_0", + "zict 2.1.0 py39h06a4308_0", + "argon2-cffi-bindings 21.2.0 py39h7f8727e_0", + "arrow 1.2.3 py39h06a4308_1", + "black 22.6.0 py39h06a4308_0", + "brotlipy 0.7.0 py39h27cfd23_1003", + "cryptography 39.0.1 py39h9ce1e76_0", + "dask-core 2022.7.0 py39h06a4308_0", + "flask 2.2.2 py39h06a4308_0", + "importlib_metadata 4.11.3 hd3eb1b0_0", + "jupyter_client 7.3.4 py39h06a4308_0", + "markdown 3.4.1 py39h06a4308_0", + "nbformat 5.7.0 py39h06a4308_0", + "numpy-base 1.23.5 py39h31eccc5_0", + "parsel 1.6.0 py39h06a4308_0", + "pip 22.3.1 py39h06a4308_0", + "prompt_toolkit 3.0.36 hd3eb1b0_0", + "pyqt5-sip 12.11.0 py39h6a678d5_1", + "qstylizer 0.2.2 py39h06a4308_0", + "qtawesome 1.2.2 py39h06a4308_0", + "qtwebkit 5.212 h4eab89a_4", + "rope 1.7.0 py39h06a4308_0", + "stack_data 0.2.0 pyhd3eb1b0_0", + "typing-extensions 4.4.0 py39h06a4308_0", + "zope.interface 5.4.0 py39h7f8727e_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "astroid 2.14.2 py39h06a4308_0", + "bcrypt 3.2.0 py39h5eee18b_1", + "ipython 8.10.0 py39h06a4308_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "nbclient 0.5.13 py39h06a4308_0", + "pyopenssl 23.0.0 py39h06a4308_0", + "pyqt 5.15.7 py39h6a678d5_1", + "secretstorage 3.3.1 py39h06a4308_0", + "service_identity 18.1.0 pyhd3eb1b0_1", + "ipykernel 6.19.2 py39hb070fc8_0", + "keyring 23.4.0 py39h06a4308_0", + "nbconvert 6.5.4 py39h06a4308_0", + "pylint 2.16.2 py39h06a4308_0", + "pyqtwebengine 5.15.7 py39h6a678d5_1", + "twisted 22.2.0 py39h5eee18b_1", + "urllib3 1.26.14 py39h06a4308_0", + "distributed 2022.7.0 py39h06a4308_0", + "jupyter_console 6.6.2 py39h06a4308_0", + "jupyter_server 1.23.4 py39h06a4308_0", + "python-lsp-server 1.7.1 py39h06a4308_0", + "qtconsole 5.4.0 py39h06a4308_0", + "requests 2.28.1 py39h06a4308_0", + "spyder-kernels 2.4.1 py39h06a4308_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "huggingface_hub 0.10.1 py39h06a4308_0", + "jupyterlab_server 2.19.0 py39h06a4308_0", + "notebook-shim 0.2.2 py39h06a4308_0", + "pooch 1.4.0 pyhd3eb1b0_0", + "pyct 0.5.0 py39h06a4308_0", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "python-lsp-black 1.2.1 py39h06a4308_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "sphinx 5.0.2 py39h06a4308_0", + "colorcet 3.0.1 py39h06a4308_0", + "nbclassic 0.5.2 py39h06a4308_0", + "numpydoc 1.5.0 py39h06a4308_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "notebook 6.5.2 py39h06a4308_0", + "scrapy 2.8.0 py39h06a4308_0", + "spyder 5.4.1 py39h06a4308_0", + "jupyterlab 3.5.3 py39h06a4308_0", + "widgetsnbextension 3.5.2 py39h06a4308_0", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "jupyter 1.0.0 py39h06a4308_8", + "bokeh 2.4.3 py39h06a4308_0", + "panel 0.14.3 py39h06a4308_0", + "bottleneck 1.3.5 py39h7deecbd_0", + "contourpy 1.0.5 py39hdb19cb5_0", + "daal4py 2023.0.2 py39h79cecc1_0", + "datashape 0.5.4 py39h06a4308_1", + "h5py 3.7.0 py39h737f45e_0", + "imagecodecs 2021.8.26 py39hfcb8610_2", + "imageio 2.26.0 py39h06a4308_0", + "intake 0.6.7 py39h06a4308_0", + "matplotlib 3.7.0 py39h06a4308_0", + "matplotlib-base 3.7.0 py39h417a72b_0", + "mkl_fft 1.3.1 py39hd3c417c_0", + "mkl_random 1.2.2 py39h51133e4_0", + "numpy 1.23.5 py39h14f4228_0", + "numba 0.56.4 py39h417a72b_0", + "numexpr 2.8.4 py39he184ba9_0", + "patsy 0.5.3 py39h06a4308_0", + "pyerfa 2.0.0 py39h27cfd23_0", + "pytorch 1.12.1 cpu_py39hb1f1ab4_1", + "pywavelets 1.4.1 py39h5eee18b_0", + "scipy 1.10.0 py39h14f4228_1", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "astropy 5.1 py39h7deecbd_0", + "gensim 4.3.0 py39h6a678d5_0", + "pandas 1.5.3 py39h417a72b_0", + "pytables 3.7.0 py39hf19a122_1", + "scikit-image 0.19.3 py39h6a678d5_1", + "scikit-learn 1.2.1 py39h6a678d5_0", + "transformers 4.24.0 py39h06a4308_0", + "dask 2022.7.0 py39h06a4308_0", + "holoviews 1.15.4 py39h06a4308_0", + "imbalanced-learn 0.10.1 py39h06a4308_0", + "scikit-learn-intelex 2023.0.2 py39h06a4308_0", + "seaborn 0.12.2 py39h06a4308_0", + "statsmodels 0.13.5 py39h7deecbd_1", + "xarray 2022.11.0 py39h06a4308_0", + "datashader 0.14.4 py39h06a4308_0", + "hvplot 0.8.2 py39h06a4308_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8540efc2d7a67b15622837a6187b43fe", + "name": "anaconda", + "namespace": "python", + "sha256": "32a2b1faa5a0513fc14a3533a369a4dfb947167586fcb6e00dceb27629a03e45", + "size": 61425, + "subdir": "linux-64", + "timestamp": 1678132275650, + "version": "2023.03" + }, + "anaconda-5.0.0-py27he0e5e41_0.tar.bz2": { + "build": "py27he0e5e41_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.10 py27he5a193a_0", + "anaconda-client 1.6.5 py27hc8169bf_0", + "anaconda-navigator 1.6.8 py27h2ea4365_0", + "anaconda-project 0.8.0 py27hd7a9a97_0", + "asn1crypto 0.22.0 py27h94ebe91_1", + "astroid 1.5.3 py27h8f8f47c_0", + "astropy 2.0.2 py27h57072c0_4", + "babel 2.5.0 py27h20693cd_0", + "backports 1.0 py27h63c9359_1", + "backports.functools_lru_cache 1.4 py27he8db605_1", + "backports.shutil_get_terminal_size 1.0.0 py27h5bc021e_2", + "backports_abc 0.5 py27h7b3c97b_0", + "beautifulsoup4 4.6.0 py27h3f86ba9_1", + "bitarray 0.8.1 py27h304d4c6_0", + "bkcharts 0.2 py27h241ae91_0", + "blaze 0.11.3 py27h5f341da_0", + "bleach 2.0.0 py27h3a0dcc8_0", + "bokeh 0.12.7 py27he0197c9_1", + "boto 2.48.0 py27h9556ac2_1", + "bottleneck 1.2.1 py27h21b16a3_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 h58b644b_4", + "cdecimal 2.3 py27h4e63abe_1", + "certifi 2017.7.27.1 py27h9ceb091_0", + "cffi 1.10.0 py27hf1aaaf4_1", + "chardet 3.0.4 py27hfa10054_1", + "click 6.7 py27h4225b90_0", + "cloudpickle 0.4.0 py27ha64365b_0", + "clyent 1.2.2 py27h7276e6c_1", + "colorama 0.3.9 py27h5cde069_0", + "configparser 3.5.0 py27h5117587_0", + "contextlib2 0.5.5 py27hbf4c468_0", + "cryptography 2.0.3 py27hea39389_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py27hc7354d3_0", + "cython 0.26.1 py27hdbcff32_0", + "cytoolz 0.8.2 py27hf14aec9_0", + "dask 0.15.2 py27h7693082_0", + "dask-core 0.15.2 py27heedc4a4_0", + "datashape 0.5.4 py27hf507385_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py27h1544723_0", + "distributed 1.18.3 py27h5e7c565_0", + "docutils 0.14 py27hae222c1_0", + "entrypoints 0.2.3 py27h502b47d_2", + "enum34 1.1.6 py27h99a27e9_1", + "et_xmlfile 1.0.1 py27h75840f5_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py27h4cb8e01_0", + "filelock 2.0.12 py27h38fa839_0", + "flask 0.12.2 py27h6d5c1cd_0", + "flask-cors 3.0.3 py27h1a8a27f_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "funcsigs 1.0.2 py27h83f16ab_0", + "functools32 3.2.3.2 py27h4ead58f_1", + "futures 3.1.1 py27hdbc8cbb_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py27h475ea6a_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py27hd3b7d1f_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py27hc856308_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py27hac09c53_0", + "grin 1.2.1 py27h54abee7_1", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py27h71d1790_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py27h33770af_0", + "html5lib 0.999999999 py27hdf15f34_0", + "icu 58.2 h211956c_0", + "idna 2.6 py27h5722d68_1", + "imageio 2.2.0 py27hf108a7f_0", + "imagesize 0.7.1 py27hd17bf80_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipaddress 1.0.18 py27h337fd85_0", + "ipykernel 4.6.1 py27hc93e584_0", + "ipython 5.4.1 py27h36c99b6_1", + "ipython_genutils 0.2.0 py27h89fb69b_0", + "ipywidgets 7.0.0 py27h4fda95d_0", + "isort 4.2.15 py27hcfa4749_0", + "itsdangerous 0.24 py27hb8295c1_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py27h2cc5433_0", + "jedi 0.10.2 py27h8af4e35_0", + "jinja2 2.9.6 py27h82327ae_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py27h7ed5aa4_0", + "jupyter 1.0.0 py27h505fd4b_0", + "jupyter_client 5.1.0 py27hbee1118_0", + "jupyter_console 5.2.0 py27hc6bee7e_1", + "jupyter_core 4.3.0 py27hcd9ae3a_0", + "jupyterlab 0.27.0 py27h42ebfef_2", + "jupyterlab_launcher 0.4.0 py27h0e16d15_0", + "lazy-object-proxy 1.3.1 py27h682c727_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 hcbc56d2_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h24385c6_1", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 he6ee5dd_2", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py27_0", + "locket 0.2.0 py27h73929a2_1", + "lxml 3.8.0 py27hb3ac1f5_0", + "lzo 2.10 hc0eb8fc_0", + "markupsafe 1.0 py27h97b2822_1", + "matplotlib 2.0.2 py27h334a7c2_1", + "mccabe 0.6.1 py27h0e7c7be_1", + "mistune 0.7.4 py27h6da7e90_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py27hb2d42c5_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py27h4bb41bd_2", + "msgpack-python 0.4.8 py27hc2fa789_0", + "multipledispatch 0.4.9 py27h9b5f95a_0", + "navigator-updater 0.1.0 py27h0f9cd39_0", + "nbconvert 5.3.1 py27he041f76_0", + "nbformat 4.4.0 py27hed7f2b2_0", + "ncurses 6.0 h06874d7_1", + "networkx 1.11 py27h7358325_0", + "nltk 3.2.4 py27h41293c3_0", + "nose 1.3.7 py27heec2199_2", + "notebook 5.0.0 py27h3661c2b_2", + "numba 0.35.0 np113py27_10", + "numexpr 2.6.2 py27he5efce1_1", + "numpy 1.13.1 py27hd1b6e02_2", + "numpydoc 0.7.0 py27h9647a75_0", + "odo 0.5.1 py27h9170de3_0", + "olefile 0.44 py27h4bd3e3c_0", + "openpyxl 2.4.8 py27h9f0c937_1", + "openssl 1.0.2l h9d1a558_3", + "packaging 16.8 py27h5e07c7c_1", + "pandas 0.20.3 py27h820b67f_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py27h428e1e5_1", + "pango 1.40.11 hedb6d6b_0", + "partd 0.3.8 py27h4e55004_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py27hc258cac_0", + "pathlib2 2.3.0 py27h6e9d198_0", + "patsy 0.4.1 py27hd1cf8c0_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py27h444351c_0", + "pexpect 4.2.1 py27hcf82287_0", + "pickleshare 0.7.4 py27h09770e1_0", + "pillow 4.2.1 py27h7cd2321_0", + "pip 9.0.1 py27h4c18a59_2", + "pixman 0.34.0 ha72d70b_1", + "pkginfo 1.4.1 py27hee1a9ad_1", + "ply 3.10 py27hd6d9ae5_0", + "prompt_toolkit 1.0.15 py27h1b593e1_0", + "psutil 5.2.2 py27h9b5ba61_0", + "ptyprocess 0.5.2 py27h4ccb14c_0", + "py 1.4.34 py27he5894e4_1", + "pycairo 1.13.3 py27hea6d626_0", + "pycodestyle 2.3.1 py27h904819d_0", + "pycosat 0.6.2 py27h1cf261c_1", + "pycparser 2.18 py27hefa08c5_1", + "pycrypto 2.6.1 py27h9abbf5c_1", + "pycurl 7.43.0 py27hcf8ebea_3", + "pyflakes 1.5.0 py27hfba2528_1", + "pygments 2.2.0 py27h4a8b6f5_0", + "pylint 1.7.2 py27h77e98c6_0", + "pyodbc 4.0.17 py27h7f7627d_0", + "pyopenssl 17.2.0 py27h189ff3b_0", + "pyparsing 2.2.0 py27hf1513f8_1", + "pyqt 5.6.0 py27h4b1e83c_5", + "pysocks 1.6.7 py27he2db6d2_1", + "pytables 3.4.2 py27ha79ee23_1", + "pytest 3.2.1 py27h98000ae_1", + "python 2.7.13 hfff3488_13", + "python-dateutil 2.6.1 py27h4ca5741_1", + "pytz 2017.2 py27hcac29fa_1", + "pywavelets 0.5.2 py27hecda097_0", + "pyyaml 3.12 py27h2d70dd7_1", + "pyzmq 16.0.2 py27h297844f_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py27hd7914c3_0", + "qtconsole 4.3.1 py27hc444b0d_0", + "qtpy 1.3.1 py27h63d3751_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py27hc5b0589_1", + "rope 0.10.5 py27hcb0a616_0", + "ruamel_yaml 0.11.14 py27h672d447_2", + "scandir 1.5 py27h1c9e1f8_1", + "scikit-image 0.13.0 py27h06cb35d_1", + "scikit-learn 0.19.0 py27hd893acb_2", + "scipy 0.19.1 py27h1edc525_3", + "seaborn 0.8.0 py27h9d2aaa1_0", + "setuptools 36.5.0 py27h68b189e_0", + "simplegeneric 0.8.1 py27h19e43cd_0", + "singledispatch 3.4.0.3 py27h9bcb476_0", + "sip 4.18.1 py27he9ba0ab_2", + "six 1.10.0 py27hdcd7534_1", + "snowballstemmer 1.2.1 py27h44e2768_0", + "sortedcollections 0.5.3 py27h135218e_0", + "sortedcontainers 1.5.7 py27he59936f_0", + "sphinx 1.6.3 py27hf9b1778_0", + "sphinxcontrib 1.0 py27h1512b58_1", + "sphinxcontrib-websupport 1.0.1 py27hf906f22_1", + "spyder 3.2.3 py27hbf281d3_1", + "sqlalchemy 1.1.13 py27hb0a01da_0", + "sqlite 3.20.1 h6d8b0f3_1", + "ssl_match_hostname 3.5.0.1 py27h4ec10b9_2", + "statsmodels 0.8.0 py27hc87d62d_0", + "subprocess32 3.2.7 py27h373dbce_0", + "sympy 1.1.1 py27hc28188a_0", + "tblib 1.3.2 py27h51fe5ba_0", + "terminado 0.6 py27h4be8df9_0", + "testpath 0.3.1 py27hc38d2c4_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py27hd3b1e7e_0", + "tornado 4.5.2 py27h97b179f_0", + "traitlets 4.3.2 py27hd6ce930_0", + "typing 3.6.2 py27h66f49e2_0", + "unicodecsv 0.14.1 py27h5062da9_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py27ha55213b_0", + "wcwidth 0.1.7 py27h9e3e1ab_0", + "webencodings 0.5.1 py27hff10b21_1", + "werkzeug 0.12.2 py27hbf75dff_0", + "wheel 0.29.0 py27h411dd7b_1", + "widgetsnbextension 3.0.2 py27hcb77dec_1", + "wrapt 1.10.11 py27h04f6869_0", + "xlrd 1.1.0 py27ha77178f_1", + "xlsxwriter 0.9.8 py27h260ecd4_0", + "xlwt 1.3.0 py27h3d85d97_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.2 py27hd58a209_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "a9b4fd446f9d25e8a0c120c52653fb8f", + "name": "anaconda", + "namespace": "python", + "sha256": "5d8629c0e0b6b89af6b8c2d61bdaf8c0c6d17e6e5ad910d1b2a41355a2e68059", + "size": 13505, + "subdir": "linux-64", + "timestamp": 1506443355790, + "version": "5.0.0" + }, + "anaconda-5.0.0-py35h81e3b35_0.tar.bz2": { + "build": "py35h81e3b35_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.10 py35h6fb19ab_0", + "anaconda-client 1.6.5 py35hd900ed1_0", + "anaconda-navigator 1.6.8 py35haed54dd_0", + "anaconda-project 0.8.0 py35hb597f32_0", + "asn1crypto 0.22.0 py35h0d675fe_1", + "astroid 1.5.3 py35h1d0c565_0", + "astropy 2.0.2 py35h2d2a8a6_4", + "babel 2.5.0 py35ha5fc564_0", + "backports 1.0 py35hd471ac7_1", + "backports.shutil_get_terminal_size 1.0.0 py35h40844db_2", + "beautifulsoup4 4.6.0 py35h442a8c9_1", + "bitarray 0.8.1 py35h7540340_0", + "bkcharts 0.2 py35he4f7e30_0", + "blaze 0.11.3 py35ha2c9137_0", + "bleach 2.0.0 py35h055c768_0", + "bokeh 0.12.7 py35h4751c18_1", + "boto 2.48.0 py35h2cfd601_1", + "bottleneck 1.2.1 py35he1b16f1_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 h58b644b_4", + "certifi 2017.7.27.1 py35h19f42a1_0", + "cffi 1.10.0 py35h796c292_1", + "chardet 3.0.4 py35hb6e9ddf_1", + "click 6.7 py35h353a69f_0", + "cloudpickle 0.4.0 py35h10376d1_0", + "clyent 1.2.2 py35h491ffcb_1", + "colorama 0.3.9 py35h81e2b6c_0", + "contextlib2 0.5.5 py35h6690dba_0", + "cryptography 2.0.3 py35hef72dfd_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py35hc4d5149_0", + "cython 0.26.1 py35h636ebcb_0", + "cytoolz 0.8.2 py35ha53021f_0", + "dask 0.15.2 py35h08b2748_0", + "dask-core 0.15.2 py35h79caba8_0", + "datashape 0.5.4 py35h5b068ae_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py35h3a268aa_0", + "distributed 1.18.3 py35h076cbad_0", + "docutils 0.14 py35hd11081d_0", + "entrypoints 0.2.3 py35h48174a2_2", + "et_xmlfile 1.0.1 py35hde8d43e_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py35hec2bbaa_0", + "filelock 2.0.12 py35h7855d60_0", + "flask 0.12.2 py35h679e90e_0", + "flask-cors 3.0.3 py35h9b2065d_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py35he064abf_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py35h98a1f2a_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py35h89a7545_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py35h2547b41_0", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py35h41d5d6e_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py35h51e6c10_0", + "html5lib 0.999999999 py35h0543385_0", + "icu 58.2 h211956c_0", + "idna 2.6 py35h8605a33_1", + "imageio 2.2.0 py35hd0a6de2_0", + "imagesize 0.7.1 py35hf008fae_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipykernel 4.6.1 py35h29d130c_0", + "ipython 6.1.0 py35h1b71439_1", + "ipython_genutils 0.2.0 py35hc9e07d0_0", + "ipywidgets 7.0.0 py35h8ebd919_0", + "isort 4.2.15 py35h44a00d2_0", + "itsdangerous 0.24 py35h7c46880_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py35hf1f7175_0", + "jedi 0.10.2 py35hc33c70f_0", + "jinja2 2.9.6 py35h90b8645_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py35h4395190_0", + "jupyter 1.0.0 py35hd38625c_0", + "jupyter_client 5.1.0 py35h2bff583_0", + "jupyter_console 5.2.0 py35h4044a63_1", + "jupyter_core 4.3.0 py35he2f7985_0", + "jupyterlab 0.27.0 py35h29561ed_2", + "jupyterlab_launcher 0.4.0 py35ha4e430f_0", + "lazy-object-proxy 1.3.1 py35h4c720c6_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 hcbc56d2_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h24385c6_1", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 he6ee5dd_2", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py35_0", + "locket 0.2.0 py35h170bc82_1", + "lxml 3.8.0 py35h4935ab9_0", + "lzo 2.10 hc0eb8fc_0", + "markupsafe 1.0 py35h4f4fcf6_1", + "matplotlib 2.0.2 py35hdbc49ba_1", + "mccabe 0.6.1 py35hd8c1f23_1", + "mistune 0.7.4 py35hfd0f961_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py35h0fc7090_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py35h5a16178_2", + "msgpack-python 0.4.8 py35h783f4c8_0", + "multipledispatch 0.4.9 py35h2ff591a_0", + "navigator-updater 0.1.0 py35h2ff6758_0", + "nbconvert 5.3.1 py35hc5194e3_0", + "nbformat 4.4.0 py35h12e6e07_0", + "ncurses 6.0 h06874d7_1", + "networkx 1.11 py35hf333c83_0", + "nltk 3.2.4 py35h7ba7875_0", + "nose 1.3.7 py35hdc64897_2", + "notebook 5.0.0 py35h65c930e_2", + "numba 0.35.0 np113py35_10", + "numexpr 2.6.2 py35h5f89caa_1", + "numpy 1.13.1 py35h8926d81_2", + "numpydoc 0.7.0 py35he089a57_0", + "odo 0.5.1 py35h102315f_0", + "olefile 0.44 py35h2c86149_0", + "openpyxl 2.4.8 py35hd6c89d3_1", + "openssl 1.0.2l h9d1a558_3", + "packaging 16.8 py35h2260b46_1", + "pandas 0.20.3 py35h85c2c75_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py35h1565a15_1", + "pango 1.40.11 hedb6d6b_0", + "partd 0.3.8 py35h68187f2_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py35hb82cfee_0", + "pathlib2 2.3.0 py35hd637de4_0", + "patsy 0.4.1 py35h51b66d5_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py35hee76f29_0", + "pexpect 4.2.1 py35h8b56cb4_0", + "pickleshare 0.7.4 py35hd57304d_0", + "pillow 4.2.1 py35h03abc04_0", + "pip 9.0.1 py35he1b8d41_2", + "pixman 0.34.0 ha72d70b_1", + "pkginfo 1.4.1 py35hb526c55_1", + "ply 3.10 py35h459f1a0_0", + "prompt_toolkit 1.0.15 py35hc09de7a_0", + "psutil 5.2.2 py35h75e6a48_0", + "ptyprocess 0.5.2 py35h38ce0a3_0", + "py 1.4.34 py35hd71111f_1", + "pycodestyle 2.3.1 py35h8d2105a_0", + "pycosat 0.6.2 py35h9693557_1", + "pycparser 2.18 py35h61b3040_1", + "pycrypto 2.6.1 py35h9852db7_1", + "pycurl 7.43.0 py35h7a9665c_3", + "pyflakes 1.5.0 py35h06f3f26_1", + "pygments 2.2.0 py35h0f41973_0", + "pylint 1.7.2 py35hc802fb1_0", + "pyodbc 4.0.17 py35h89a430b_0", + "pyopenssl 17.2.0 py35h1d2a76c_0", + "pyparsing 2.2.0 py35h041ed72_1", + "pyqt 5.6.0 py35h0e41ada_5", + "pysocks 1.6.7 py35h6aefbb0_1", + "pytables 3.4.2 py35hc74b6c3_1", + "pytest 3.2.1 py35hc97c719_1", + "python 3.5.4 h2170f06_12", + "python-dateutil 2.6.1 py35h90d5b31_1", + "pytz 2017.2 py35h9225bff_1", + "pywavelets 0.5.2 py35h53ec731_0", + "pyyaml 3.12 py35h46ef4ae_1", + "pyzmq 16.0.2 py35h4be1f71_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py35hd68ff89_0", + "qtconsole 4.3.1 py35h4626a06_0", + "qtpy 1.3.1 py35h881af26_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py35hb9e6ad1_1", + "rope 0.10.5 py35h31d6b7c_0", + "ruamel_yaml 0.11.14 py35h8e2c16b_2", + "scikit-image 0.13.0 py35h3573165_1", + "scikit-learn 0.19.0 py35h25e8076_2", + "scipy 0.19.1 py35ha8f041b_3", + "seaborn 0.8.0 py35h15a2772_0", + "setuptools 36.5.0 py35ha8c1747_0", + "simplegeneric 0.8.1 py35h2ec4104_0", + "singledispatch 3.4.0.3 py35h0cd4ec3_0", + "sip 4.18.1 py35h9eaea60_2", + "six 1.10.0 py35h5312c1b_1", + "snowballstemmer 1.2.1 py35h5435977_0", + "sortedcollections 0.5.3 py35hb2f60ff_0", + "sortedcontainers 1.5.7 py35h683703c_0", + "sphinx 1.6.3 py35hea25a1c_0", + "sphinxcontrib 1.0 py35hcb7efd2_1", + "sphinxcontrib-websupport 1.0.1 py35h3537809_1", + "spyder 3.2.3 py35h49e6fe2_1", + "sqlalchemy 1.1.13 py35h4911131_0", + "sqlite 3.20.1 h6d8b0f3_1", + "statsmodels 0.8.0 py35haa9d50b_0", + "sympy 1.1.1 py35h919b29a_0", + "tblib 1.3.2 py35hf1eb0b4_0", + "terminado 0.6 py35hce234ed_0", + "testpath 0.3.1 py35had42eaf_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py35h90f1797_0", + "tornado 4.5.2 py35hf879e1d_0", + "traitlets 4.3.2 py35ha522a97_0", + "typing 3.6.2 py35hcadae7e_0", + "unicodecsv 0.14.1 py35h4805c0c_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py35h2ab6e29_0", + "wcwidth 0.1.7 py35hcd08066_0", + "webencodings 0.5.1 py35hb6cf162_1", + "werkzeug 0.12.2 py35hbfc1ea6_0", + "wheel 0.29.0 py35h601ca99_1", + "widgetsnbextension 3.0.2 py35h0be620c_1", + "wrapt 1.10.11 py35hfdafd39_0", + "xlrd 1.1.0 py35h45a0a2a_1", + "xlsxwriter 0.9.8 py35hc9d400f_0", + "xlwt 1.3.0 py35h884a0cf_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.2 py35h00a3a39_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "7ee191f234b9a2a2050a919d1902b321", + "name": "anaconda", + "namespace": "python", + "sha256": "c3df0464ec30463dd7a486bf989e8aaa9c7bcca4ad0d49ed56d884fd291e80f3", + "size": 12971, + "subdir": "linux-64", + "timestamp": 1506428953055, + "version": "5.0.0" + }, + "anaconda-5.0.0-py36h06de3c5_0.tar.bz2": { + "build": "py36h06de3c5_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.10 py36h306e16b_0", + "anaconda-client 1.6.5 py36h19c0dcd_0", + "anaconda-navigator 1.6.8 py36h672ccc7_0", + "anaconda-project 0.8.0 py36h29abdf5_0", + "asn1crypto 0.22.0 py36h265ca7c_1", + "astroid 1.5.3 py36hbdb9df2_0", + "astropy 2.0.2 py36ha51211e_4", + "babel 2.5.0 py36h7d14adf_0", + "backports 1.0 py36hfa02d7e_1", + "backports.shutil_get_terminal_size 1.0.0 py36hfea85ff_2", + "beautifulsoup4 4.6.0 py36h49b8c8c_1", + "bitarray 0.8.1 py36h5834eb8_0", + "bkcharts 0.2 py36h735825a_0", + "blaze 0.11.3 py36h4e06776_0", + "bleach 2.0.0 py36h688b259_0", + "bokeh 0.12.7 py36h169c5fd_1", + "boto 2.48.0 py36h6e4cd66_1", + "bottleneck 1.2.1 py36haac1ea0_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 h58b644b_4", + "certifi 2017.7.27.1 py36h8b7b77e_0", + "cffi 1.10.0 py36had8d393_1", + "chardet 3.0.4 py36h0f667ec_1", + "click 6.7 py36h5253387_0", + "cloudpickle 0.4.0 py36h30f8c20_0", + "clyent 1.2.2 py36h7e57e65_1", + "colorama 0.3.9 py36h489cec4_0", + "contextlib2 0.5.5 py36h6c84a62_0", + "cryptography 2.0.3 py36ha225213_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py36h93f1223_0", + "cython 0.26.1 py36h21c49d0_0", + "cytoolz 0.8.2 py36h708bfd4_0", + "dask 0.15.2 py36h9b48dc4_0", + "dask-core 0.15.2 py36h0f988a8_0", + "datashape 0.5.4 py36h3ad6b5c_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py36hd076ac8_0", + "distributed 1.18.3 py36h73cd4ae_0", + "docutils 0.14 py36hb0f60f5_0", + "entrypoints 0.2.3 py36h1aec115_2", + "et_xmlfile 1.0.1 py36hd6bccc3_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py36h5b0c431_0", + "filelock 2.0.12 py36hacfa1f5_0", + "flask 0.12.2 py36hb24657c_0", + "flask-cors 3.0.3 py36h2d857d3_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py36h2fe25dc_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py36h2c1b292_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py36h55090d7_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py36h2d503a6_0", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py36he81ebca_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py36h79797d7_0", + "html5lib 0.999999999 py36h2cfc398_0", + "icu 58.2 h211956c_0", + "idna 2.6 py36h82fb2a8_1", + "imageio 2.2.0 py36he555465_0", + "imagesize 0.7.1 py36h52d8127_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipykernel 4.6.1 py36hbf841aa_0", + "ipython 6.1.0 py36hc72a948_1", + "ipython_genutils 0.2.0 py36hb52b0d5_0", + "ipywidgets 7.0.0 py36h7b55c3a_0", + "isort 4.2.15 py36had401c0_0", + "itsdangerous 0.24 py36h93cc618_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py36h4c697fb_0", + "jedi 0.10.2 py36h552def0_0", + "jinja2 2.9.6 py36h489bce4_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py36h006f8b5_0", + "jupyter 1.0.0 py36h9896ce5_0", + "jupyter_client 5.1.0 py36h614e9ea_0", + "jupyter_console 5.2.0 py36he59e554_1", + "jupyter_core 4.3.0 py36h357a921_0", + "jupyterlab 0.27.0 py36h86377d0_2", + "jupyterlab_launcher 0.4.0 py36h4d8058d_0", + "lazy-object-proxy 1.3.1 py36h10fcdad_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 hcbc56d2_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h24385c6_1", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 he6ee5dd_2", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py36_0", + "locket 0.2.0 py36h787c0ad_1", + "lxml 3.8.0 py36h6c6e760_0", + "lzo 2.10 hc0eb8fc_0", + "markupsafe 1.0 py36hd9260cd_1", + "matplotlib 2.0.2 py36h2acb4ad_1", + "mccabe 0.6.1 py36h5ad9710_1", + "mistune 0.7.4 py36hbab8784_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py36h17a0993_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py36h8cc018b_2", + "msgpack-python 0.4.8 py36hec4c5d1_0", + "multipledispatch 0.4.9 py36h41da3fb_0", + "navigator-updater 0.1.0 py36h14770f7_0", + "nbconvert 5.3.1 py36hb41ffb7_0", + "nbformat 4.4.0 py36h31c9010_0", + "ncurses 6.0 h06874d7_1", + "networkx 1.11 py36hfb3574a_0", + "nltk 3.2.4 py36h1a0979f_0", + "nose 1.3.7 py36hcdf7029_2", + "notebook 5.0.0 py36h0b20546_2", + "numba 0.35.0 np113py36_10", + "numexpr 2.6.2 py36hdd3393f_1", + "numpy 1.13.1 py36h5bc529a_2", + "numpydoc 0.7.0 py36h18f165f_0", + "odo 0.5.1 py36h90ed295_0", + "olefile 0.44 py36h79f9f78_0", + "openpyxl 2.4.8 py36h41dd2a8_1", + "openssl 1.0.2l h9d1a558_3", + "packaging 16.8 py36ha668100_1", + "pandas 0.20.3 py36h842e28d_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py36ha6701b7_1", + "pango 1.40.11 hedb6d6b_0", + "partd 0.3.8 py36h36fd896_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py36he0c6f6d_0", + "pathlib2 2.3.0 py36h49efa8e_0", + "patsy 0.4.1 py36ha3be15e_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py36h26ade29_0", + "pexpect 4.2.1 py36h3b9d41b_0", + "pickleshare 0.7.4 py36h63277f8_0", + "pillow 4.2.1 py36h9119f52_0", + "pip 9.0.1 py36h30f8307_2", + "pixman 0.34.0 ha72d70b_1", + "pkginfo 1.4.1 py36h215d178_1", + "ply 3.10 py36hed35086_0", + "prompt_toolkit 1.0.15 py36h17d85b1_0", + "psutil 5.2.2 py36h74c8701_0", + "ptyprocess 0.5.2 py36h69acd42_0", + "py 1.4.34 py36h0712aa3_1", + "pycodestyle 2.3.1 py36hf609f19_0", + "pycosat 0.6.2 py36h1a0ea17_1", + "pycparser 2.18 py36hf9f622e_1", + "pycrypto 2.6.1 py36h6998063_1", + "pycurl 7.43.0 py36h5e72054_3", + "pyflakes 1.5.0 py36h5510808_1", + "pygments 2.2.0 py36h0d3125c_0", + "pylint 1.7.2 py36h484ab97_0", + "pyodbc 4.0.17 py36h999153c_0", + "pyopenssl 17.2.0 py36h5cc804b_0", + "pyparsing 2.2.0 py36hee85983_1", + "pyqt 5.6.0 py36h0386399_5", + "pysocks 1.6.7 py36hd97a5b1_1", + "pytables 3.4.2 py36hdce54c9_1", + "pytest 3.2.1 py36h11ad3bb_1", + "python 3.6.2 h02fb82a_12", + "python-dateutil 2.6.1 py36h88d3b88_1", + "pytz 2017.2 py36hc2ccc2a_1", + "pywavelets 0.5.2 py36he602eb0_0", + "pyyaml 3.12 py36hafb9ca4_1", + "pyzmq 16.0.2 py36h3b0cf96_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py36h609ed8c_0", + "qtconsole 4.3.1 py36h8f73b5b_0", + "qtpy 1.3.1 py36h3691cc8_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py36he2e5f8d_1", + "rope 0.10.5 py36h1f8c17e_0", + "ruamel_yaml 0.11.14 py36ha2fb22d_2", + "scikit-image 0.13.0 py36had3c07a_1", + "scikit-learn 0.19.0 py36h97ac459_2", + "scipy 0.19.1 py36h9976243_3", + "seaborn 0.8.0 py36h197244f_0", + "setuptools 36.5.0 py36he42e2e1_0", + "simplegeneric 0.8.1 py36h2cb9092_0", + "singledispatch 3.4.0.3 py36h7a266c3_0", + "sip 4.18.1 py36h51ed4ed_2", + "six 1.10.0 py36hcac75e4_1", + "snowballstemmer 1.2.1 py36h6febd40_0", + "sortedcollections 0.5.3 py36h3c761f9_0", + "sortedcontainers 1.5.7 py36hdf89491_0", + "sphinx 1.6.3 py36he5f0bdb_0", + "sphinxcontrib 1.0 py36h6d0f590_1", + "sphinxcontrib-websupport 1.0.1 py36hb5cb234_1", + "spyder 3.2.3 py36he38cbf7_1", + "sqlalchemy 1.1.13 py36hfb5efd7_0", + "sqlite 3.20.1 h6d8b0f3_1", + "statsmodels 0.8.0 py36h8533d0b_0", + "sympy 1.1.1 py36hc6d1c1c_0", + "tblib 1.3.2 py36h34cf8b6_0", + "terminado 0.6 py36ha25a19f_0", + "testpath 0.3.1 py36h8cadb63_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py36h81f2dff_0", + "tornado 4.5.2 py36h1283b2a_0", + "traitlets 4.3.2 py36h674d592_0", + "typing 3.6.2 py36h7da032a_0", + "unicodecsv 0.14.1 py36ha668878_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py36hbe7ace6_0", + "wcwidth 0.1.7 py36hdf4376a_0", + "webencodings 0.5.1 py36h800622e_1", + "werkzeug 0.12.2 py36hc703753_0", + "wheel 0.29.0 py36he7f4e38_1", + "widgetsnbextension 3.0.2 py36hd01bb71_1", + "wrapt 1.10.11 py36h28b7045_0", + "xlrd 1.1.0 py36h1db9f0c_1", + "xlsxwriter 0.9.8 py36hf41c223_0", + "xlwt 1.3.0 py36h7b00a1f_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.2 py36ha0d441b_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "ea1d04f131316f7fa4a1fdaf1757eb3e", + "name": "anaconda", + "namespace": "python", + "sha256": "3b6b27ecec41ae6bc8ed01d677686f69eab431286e251d5896223b8cdb285d1e", + "size": 12847, + "subdir": "linux-64", + "timestamp": 1506429096109, + "version": "5.0.0" + }, + "anaconda-5.0.0.1-py27h1e3bc52_1.tar.bz2": { + "build": "py27h1e3bc52_1", + "build_number": 1, + "depends": [ + "alabaster 0.7.10 py27he5a193a_0", + "anaconda-client 1.6.5 py27hc8169bf_0", + "anaconda-navigator 1.6.8 py27h2ea4365_0", + "anaconda-project 0.8.0 py27hd7a9a97_0", + "asn1crypto 0.22.0 py27h94ebe91_1", + "astroid 1.5.3 py27h8f8f47c_0", + "astropy 2.0.2 py27h57072c0_4", + "babel 2.5.0 py27h20693cd_0", + "backports 1.0 py27h63c9359_1", + "backports.functools_lru_cache 1.4 py27he8db605_1", + "backports.shutil_get_terminal_size 1.0.0 py27h5bc021e_2", + "backports_abc 0.5 py27h7b3c97b_0", + "beautifulsoup4 4.6.0 py27h3f86ba9_1", + "bitarray 0.8.1 py27h304d4c6_0", + "bkcharts 0.2 py27h241ae91_0", + "blaze 0.11.3 py27h5f341da_0", + "bleach 2.0.0 py27h3a0dcc8_0", + "bokeh 0.12.7 py27he0197c9_1", + "boto 2.48.0 py27h9556ac2_1", + "bottleneck 1.2.1 py27h21b16a3_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 h58b644b_4", + "cdecimal 2.3 py27h4e63abe_1", + "certifi 2017.7.27.1 py27h9ceb091_0", + "cffi 1.10.0 py27hf1aaaf4_1", + "chardet 3.0.4 py27hfa10054_1", + "click 6.7 py27h4225b90_0", + "cloudpickle 0.4.0 py27ha64365b_0", + "clyent 1.2.2 py27h7276e6c_1", + "colorama 0.3.9 py27h5cde069_0", + "configparser 3.5.0 py27h5117587_0", + "contextlib2 0.5.5 py27hbf4c468_0", + "cryptography 2.0.3 py27hea39389_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py27hc7354d3_0", + "cython 0.26.1 py27hdbcff32_0", + "cytoolz 0.8.2 py27hf14aec9_0", + "dask 0.15.2 py27h7693082_0", + "dask-core 0.15.2 py27heedc4a4_0", + "datashape 0.5.4 py27hf507385_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py27h1544723_0", + "distributed 1.18.3 py27h5e7c565_0", + "docutils 0.14 py27hae222c1_0", + "entrypoints 0.2.3 py27h502b47d_2", + "enum34 1.1.6 py27h99a27e9_1", + "et_xmlfile 1.0.1 py27h75840f5_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py27h4cb8e01_0", + "filelock 2.0.12 py27h38fa839_0", + "flask 0.12.2 py27h6d5c1cd_0", + "flask-cors 3.0.3 py27h1a8a27f_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "funcsigs 1.0.2 py27h83f16ab_0", + "functools32 3.2.3.2 py27h4ead58f_1", + "futures 3.1.1 py27hdbc8cbb_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py27h475ea6a_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py27hd3b7d1f_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py27hc856308_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py27hac09c53_0", + "grin 1.2.1 py27h54abee7_1", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py27h71d1790_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py27h33770af_0", + "html5lib 0.999999999 py27hdf15f34_0", + "icu 58.2 h211956c_0", + "idna 2.6 py27h5722d68_1", + "imageio 2.2.0 py27hf108a7f_0", + "imagesize 0.7.1 py27hd17bf80_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipaddress 1.0.18 py27h337fd85_0", + "ipykernel 4.6.1 py27hc93e584_0", + "ipython 5.4.1 py27h36c99b6_1", + "ipython_genutils 0.2.0 py27h89fb69b_0", + "ipywidgets 7.0.0 py27h4fda95d_0", + "isort 4.2.15 py27hcfa4749_0", + "itsdangerous 0.24 py27hb8295c1_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py27h2cc5433_0", + "jedi 0.10.2 py27h8af4e35_0", + "jinja2 2.9.6 py27h82327ae_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py27h7ed5aa4_0", + "jupyter 1.0.0 py27h505fd4b_0", + "jupyter_client 5.1.0 py27hbee1118_0", + "jupyter_console 5.2.0 py27hc6bee7e_1", + "jupyter_core 4.3.0 py27hcd9ae3a_0", + "jupyterlab 0.27.0 py27h42ebfef_2", + "jupyterlab_launcher 0.4.0 py27h0e16d15_0", + "lazy-object-proxy 1.3.1 py27h682c727_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 hcbc56d2_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h24385c6_1", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 he6ee5dd_2", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py27_0", + "locket 0.2.0 py27h73929a2_1", + "lxml 3.8.0 py27hb3ac1f5_0", + "lzo 2.10 hc0eb8fc_0", + "markupsafe 1.0 py27h97b2822_1", + "matplotlib 2.0.2 py27h334a7c2_1", + "mccabe 0.6.1 py27h0e7c7be_1", + "mistune 0.7.4 py27h6da7e90_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py27hb2d42c5_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py27h4bb41bd_2", + "msgpack-python 0.4.8 py27hc2fa789_0", + "multipledispatch 0.4.9 py27h9b5f95a_0", + "navigator-updater 0.1.0 py27h0f9cd39_0", + "nbconvert 5.3.1 py27he041f76_0", + "nbformat 4.4.0 py27hed7f2b2_0", + "ncurses 6.0 h06874d7_1", + "networkx 1.11 py27h7358325_0", + "nltk 3.2.4 py27h41293c3_0", + "nose 1.3.7 py27heec2199_2", + "notebook 5.0.0 py27h3661c2b_2", + "numba 0.35.0 np113py27_10", + "numexpr 2.6.2 py27he5efce1_1", + "numpy 1.13.1 py27hd1b6e02_2", + "numpydoc 0.7.0 py27h9647a75_0", + "odo 0.5.1 py27h9170de3_0", + "olefile 0.44 py27h4bd3e3c_0", + "openpyxl 2.4.8 py27h9f0c937_1", + "openssl 1.0.2l h9d1a558_3", + "packaging 16.8 py27h5e07c7c_1", + "pandas 0.20.3 py27h820b67f_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py27h428e1e5_1", + "pango 1.40.11 hedb6d6b_0", + "partd 0.3.8 py27h4e55004_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py27hc258cac_0", + "pathlib2 2.3.0 py27h6e9d198_0", + "patsy 0.4.1 py27hd1cf8c0_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py27h444351c_0", + "pexpect 4.2.1 py27hcf82287_0", + "pickleshare 0.7.4 py27h09770e1_0", + "pillow 4.2.1 py27h7cd2321_0", + "pip 9.0.1 py27h4c18a59_2", + "pixman 0.34.0 ha72d70b_1", + "pkginfo 1.4.1 py27hee1a9ad_1", + "ply 3.10 py27hd6d9ae5_0", + "prompt_toolkit 1.0.15 py27h1b593e1_0", + "psutil 5.2.2 py27h9b5ba61_0", + "ptyprocess 0.5.2 py27h4ccb14c_0", + "py 1.4.34 py27he5894e4_1", + "pycairo 1.13.3 py27hea6d626_0", + "pycodestyle 2.3.1 py27h904819d_0", + "pycosat 0.6.2 py27h1cf261c_1", + "pycparser 2.18 py27hefa08c5_1", + "pycrypto 2.6.1 py27h9abbf5c_1", + "pycurl 7.43.0 py27hcf8ebea_3", + "pyflakes 1.5.0 py27hfba2528_1", + "pygments 2.2.0 py27h4a8b6f5_0", + "pylint 1.7.2 py27h77e98c6_0", + "pyodbc 4.0.17 py27h7f7627d_0", + "pyopenssl 17.2.0 py27h189ff3b_0", + "pyparsing 2.2.0 py27hf1513f8_1", + "pyqt 5.6.0 py27h4b1e83c_5", + "pysocks 1.6.7 py27he2db6d2_1", + "pytables 3.4.2 py27ha79ee23_1", + "pytest 3.2.1 py27h98000ae_1", + "python 2.7.13 heccc3f1_16", + "python-dateutil 2.6.1 py27h4ca5741_1", + "pytz 2017.2 py27hcac29fa_1", + "pywavelets 0.5.2 py27hecda097_0", + "pyyaml 3.12 py27h2d70dd7_1", + "pyzmq 16.0.2 py27h297844f_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py27hd7914c3_0", + "qtconsole 4.3.1 py27hc444b0d_0", + "qtpy 1.3.1 py27h63d3751_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py27hc5b0589_1", + "rope 0.10.5 py27hcb0a616_0", + "ruamel_yaml 0.11.14 py27h672d447_2", + "scandir 1.5 py27h1c9e1f8_1", + "scikit-image 0.13.0 py27h06cb35d_1", + "scikit-learn 0.19.0 py27hd893acb_2", + "scipy 0.19.1 py27h1edc525_3", + "seaborn 0.8.0 py27h9d2aaa1_0", + "setuptools 36.5.0 py27h68b189e_0", + "simplegeneric 0.8.1 py27h19e43cd_0", + "singledispatch 3.4.0.3 py27h9bcb476_0", + "sip 4.18.1 py27he9ba0ab_2", + "six 1.10.0 py27hdcd7534_1", + "snowballstemmer 1.2.1 py27h44e2768_0", + "sortedcollections 0.5.3 py27h135218e_0", + "sortedcontainers 1.5.7 py27he59936f_0", + "sphinx 1.6.3 py27hf9b1778_0", + "sphinxcontrib 1.0 py27h1512b58_1", + "sphinxcontrib-websupport 1.0.1 py27hf906f22_1", + "spyder 3.2.3 py27hbf281d3_1", + "sqlalchemy 1.1.13 py27hb0a01da_0", + "sqlite 3.20.1 h6d8b0f3_1", + "ssl_match_hostname 3.5.0.1 py27h4ec10b9_2", + "statsmodels 0.8.0 py27hc87d62d_0", + "subprocess32 3.2.7 py27h373dbce_0", + "sympy 1.1.1 py27hc28188a_0", + "tblib 1.3.2 py27h51fe5ba_0", + "terminado 0.6 py27h4be8df9_0", + "testpath 0.3.1 py27hc38d2c4_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py27hd3b1e7e_0", + "tornado 4.5.2 py27h97b179f_0", + "traitlets 4.3.2 py27hd6ce930_0", + "typing 3.6.2 py27h66f49e2_0", + "unicodecsv 0.14.1 py27h5062da9_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py27ha55213b_0", + "wcwidth 0.1.7 py27h9e3e1ab_0", + "webencodings 0.5.1 py27hff10b21_1", + "werkzeug 0.12.2 py27hbf75dff_0", + "wheel 0.29.0 py27h411dd7b_1", + "widgetsnbextension 3.0.2 py27hcb77dec_1", + "wrapt 1.10.11 py27h04f6869_0", + "xlrd 1.1.0 py27ha77178f_1", + "xlsxwriter 0.9.8 py27h260ecd4_0", + "xlwt 1.3.0 py27h3d85d97_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.2 py27hd58a209_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "7e94eb85b4b805215870f35b63a6537b", + "name": "anaconda", + "namespace": "python", + "sha256": "05332414acd9cda39e77e426c71c20c3fb79baa58180b4da48fc2c62e9b5ec7a", + "size": 13515, + "subdir": "linux-64", + "timestamp": 1506833783638, + "version": "5.0.0.1" + }, + "anaconda-5.0.0.1-py27hfd10420_0.tar.bz2": { + "build": "py27hfd10420_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.10 py27he5a193a_0", + "anaconda-client 1.6.5 py27hc8169bf_0", + "anaconda-navigator 1.6.8 py27h2ea4365_0", + "anaconda-project 0.8.0 py27hd7a9a97_0", + "asn1crypto 0.22.0 py27h94ebe91_1", + "astroid 1.5.3 py27h8f8f47c_0", + "astropy 2.0.2 py27h57072c0_4", + "babel 2.5.0 py27h20693cd_0", + "backports 1.0 py27h63c9359_1", + "backports.functools_lru_cache 1.4 py27he8db605_1", + "backports.shutil_get_terminal_size 1.0.0 py27h5bc021e_2", + "backports_abc 0.5 py27h7b3c97b_0", + "beautifulsoup4 4.6.0 py27h3f86ba9_1", + "bitarray 0.8.1 py27h304d4c6_0", + "bkcharts 0.2 py27h241ae91_0", + "blaze 0.11.3 py27h5f341da_0", + "bleach 2.0.0 py27h3a0dcc8_0", + "bokeh 0.12.7 py27he0197c9_1", + "boto 2.48.0 py27h9556ac2_1", + "bottleneck 1.2.1 py27h21b16a3_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 h58b644b_4", + "cdecimal 2.3 py27h4e63abe_1", + "certifi 2017.7.27.1 py27h9ceb091_0", + "cffi 1.10.0 py27hf1aaaf4_1", + "chardet 3.0.4 py27hfa10054_1", + "click 6.7 py27h4225b90_0", + "cloudpickle 0.4.0 py27ha64365b_0", + "clyent 1.2.2 py27h7276e6c_1", + "colorama 0.3.9 py27h5cde069_0", + "configparser 3.5.0 py27h5117587_0", + "contextlib2 0.5.5 py27hbf4c468_0", + "cryptography 2.0.3 py27hea39389_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py27hc7354d3_0", + "cython 0.26.1 py27hdbcff32_0", + "cytoolz 0.8.2 py27hf14aec9_0", + "dask 0.15.2 py27h7693082_0", + "dask-core 0.15.2 py27heedc4a4_0", + "datashape 0.5.4 py27hf507385_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py27h1544723_0", + "distributed 1.18.3 py27h5e7c565_0", + "docutils 0.14 py27hae222c1_0", + "entrypoints 0.2.3 py27h502b47d_2", + "enum34 1.1.6 py27h99a27e9_1", + "et_xmlfile 1.0.1 py27h75840f5_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py27h4cb8e01_0", + "filelock 2.0.12 py27h38fa839_0", + "flask 0.12.2 py27h6d5c1cd_0", + "flask-cors 3.0.3 py27h1a8a27f_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "funcsigs 1.0.2 py27h83f16ab_0", + "functools32 3.2.3.2 py27h4ead58f_1", + "futures 3.1.1 py27hdbc8cbb_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py27h475ea6a_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py27hd3b7d1f_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py27hc856308_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py27hac09c53_0", + "grin 1.2.1 py27h54abee7_1", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py27h71d1790_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py27h33770af_0", + "html5lib 0.999999999 py27hdf15f34_0", + "icu 58.2 h211956c_0", + "idna 2.6 py27h5722d68_1", + "imageio 2.2.0 py27hf108a7f_0", + "imagesize 0.7.1 py27hd17bf80_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipaddress 1.0.18 py27h337fd85_0", + "ipykernel 4.6.1 py27hc93e584_0", + "ipython 5.4.1 py27h36c99b6_1", + "ipython_genutils 0.2.0 py27h89fb69b_0", + "ipywidgets 7.0.0 py27h4fda95d_0", + "isort 4.2.15 py27hcfa4749_0", + "itsdangerous 0.24 py27hb8295c1_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py27h2cc5433_0", + "jedi 0.10.2 py27h8af4e35_0", + "jinja2 2.9.6 py27h82327ae_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py27h7ed5aa4_0", + "jupyter 1.0.0 py27h505fd4b_0", + "jupyter_client 5.1.0 py27hbee1118_0", + "jupyter_console 5.2.0 py27hc6bee7e_1", + "jupyter_core 4.3.0 py27hcd9ae3a_0", + "jupyterlab 0.27.0 py27h42ebfef_2", + "jupyterlab_launcher 0.4.0 py27h0e16d15_0", + "lazy-object-proxy 1.3.1 py27h682c727_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 hcbc56d2_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h24385c6_1", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 he6ee5dd_2", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py27_0", + "locket 0.2.0 py27h73929a2_1", + "lxml 3.8.0 py27hb3ac1f5_0", + "lzo 2.10 hc0eb8fc_0", + "markupsafe 1.0 py27h97b2822_1", + "matplotlib 2.0.2 py27h334a7c2_1", + "mccabe 0.6.1 py27h0e7c7be_1", + "mistune 0.7.4 py27h6da7e90_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py27hb2d42c5_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py27h4bb41bd_2", + "msgpack-python 0.4.8 py27hc2fa789_0", + "multipledispatch 0.4.9 py27h9b5f95a_0", + "navigator-updater 0.1.0 py27h0f9cd39_0", + "nbconvert 5.3.1 py27he041f76_0", + "nbformat 4.4.0 py27hed7f2b2_0", + "ncurses 6.0 h06874d7_1", + "networkx 1.11 py27h7358325_0", + "nltk 3.2.4 py27h41293c3_0", + "nose 1.3.7 py27heec2199_2", + "notebook 5.0.0 py27h3661c2b_2", + "numba 0.35.0 np113py27_10", + "numexpr 2.6.2 py27he5efce1_1", + "numpy 1.13.1 py27hd1b6e02_2", + "numpydoc 0.7.0 py27h9647a75_0", + "odo 0.5.1 py27h9170de3_0", + "olefile 0.44 py27h4bd3e3c_0", + "openpyxl 2.4.8 py27h9f0c937_1", + "openssl 1.0.2l h9d1a558_3", + "packaging 16.8 py27h5e07c7c_1", + "pandas 0.20.3 py27h820b67f_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py27h428e1e5_1", + "pango 1.40.11 hedb6d6b_0", + "partd 0.3.8 py27h4e55004_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py27hc258cac_0", + "pathlib2 2.3.0 py27h6e9d198_0", + "patsy 0.4.1 py27hd1cf8c0_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py27h444351c_0", + "pexpect 4.2.1 py27hcf82287_0", + "pickleshare 0.7.4 py27h09770e1_0", + "pillow 4.2.1 py27h7cd2321_0", + "pip 9.0.1 py27h4c18a59_2", + "pixman 0.34.0 ha72d70b_1", + "pkginfo 1.4.1 py27hee1a9ad_1", + "ply 3.10 py27hd6d9ae5_0", + "prompt_toolkit 1.0.15 py27h1b593e1_0", + "psutil 5.2.2 py27h9b5ba61_0", + "ptyprocess 0.5.2 py27h4ccb14c_0", + "py 1.4.34 py27he5894e4_1", + "pycairo 1.13.3 py27hea6d626_0", + "pycodestyle 2.3.1 py27h904819d_0", + "pycosat 0.6.2 py27h1cf261c_1", + "pycparser 2.18 py27hefa08c5_1", + "pycrypto 2.6.1 py27h9abbf5c_1", + "pycurl 7.43.0 py27hcf8ebea_3", + "pyflakes 1.5.0 py27hfba2528_1", + "pygments 2.2.0 py27h4a8b6f5_0", + "pylint 1.7.2 py27h77e98c6_0", + "pyodbc 4.0.17 py27h7f7627d_0", + "pyopenssl 17.2.0 py27h189ff3b_0", + "pyparsing 2.2.0 py27hf1513f8_1", + "pyqt 5.6.0 py27h4b1e83c_5", + "pysocks 1.6.7 py27he2db6d2_1", + "pytables 3.4.2 py27ha79ee23_1", + "pytest 3.2.1 py27h98000ae_1", + "python 2.7.13 hac47a24_15", + "python-dateutil 2.6.1 py27h4ca5741_1", + "pytz 2017.2 py27hcac29fa_1", + "pywavelets 0.5.2 py27hecda097_0", + "pyyaml 3.12 py27h2d70dd7_1", + "pyzmq 16.0.2 py27h297844f_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py27hd7914c3_0", + "qtconsole 4.3.1 py27hc444b0d_0", + "qtpy 1.3.1 py27h63d3751_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py27hc5b0589_1", + "rope 0.10.5 py27hcb0a616_0", + "ruamel_yaml 0.11.14 py27h672d447_2", + "scandir 1.5 py27h1c9e1f8_1", + "scikit-image 0.13.0 py27h06cb35d_1", + "scikit-learn 0.19.0 py27hd893acb_2", + "scipy 0.19.1 py27h1edc525_3", + "seaborn 0.8.0 py27h9d2aaa1_0", + "setuptools 36.5.0 py27h68b189e_0", + "simplegeneric 0.8.1 py27h19e43cd_0", + "singledispatch 3.4.0.3 py27h9bcb476_0", + "sip 4.18.1 py27he9ba0ab_2", + "six 1.10.0 py27hdcd7534_1", + "snowballstemmer 1.2.1 py27h44e2768_0", + "sortedcollections 0.5.3 py27h135218e_0", + "sortedcontainers 1.5.7 py27he59936f_0", + "sphinx 1.6.3 py27hf9b1778_0", + "sphinxcontrib 1.0 py27h1512b58_1", + "sphinxcontrib-websupport 1.0.1 py27hf906f22_1", + "spyder 3.2.3 py27hbf281d3_1", + "sqlalchemy 1.1.13 py27hb0a01da_0", + "sqlite 3.20.1 h6d8b0f3_1", + "ssl_match_hostname 3.5.0.1 py27h4ec10b9_2", + "statsmodels 0.8.0 py27hc87d62d_0", + "subprocess32 3.2.7 py27h373dbce_0", + "sympy 1.1.1 py27hc28188a_0", + "tblib 1.3.2 py27h51fe5ba_0", + "terminado 0.6 py27h4be8df9_0", + "testpath 0.3.1 py27hc38d2c4_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py27hd3b1e7e_0", + "tornado 4.5.2 py27h97b179f_0", + "traitlets 4.3.2 py27hd6ce930_0", + "typing 3.6.2 py27h66f49e2_0", + "unicodecsv 0.14.1 py27h5062da9_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py27ha55213b_0", + "wcwidth 0.1.7 py27h9e3e1ab_0", + "webencodings 0.5.1 py27hff10b21_1", + "werkzeug 0.12.2 py27hbf75dff_0", + "wheel 0.29.0 py27h411dd7b_1", + "widgetsnbextension 3.0.2 py27hcb77dec_1", + "wrapt 1.10.11 py27h04f6869_0", + "xlrd 1.1.0 py27ha77178f_1", + "xlsxwriter 0.9.8 py27h260ecd4_0", + "xlwt 1.3.0 py27h3d85d97_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.2 py27hd58a209_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "4fed3515c12305289bfd3f83339eba61", + "name": "anaconda", + "namespace": "python", + "sha256": "4b2b9e19a43ba50d780273f604a64ebc29e9a9844589245fae6997516c058415", + "size": 13490, + "subdir": "linux-64", + "timestamp": 1506715108696, + "version": "5.0.0.1" + }, + "anaconda-5.0.0.1-py35h1ed3d8c_0.tar.bz2": { + "build": "py35h1ed3d8c_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.10 py35h6fb19ab_0", + "anaconda-client 1.6.5 py35hd900ed1_0", + "anaconda-navigator 1.6.8 py35haed54dd_0", + "anaconda-project 0.8.0 py35hb597f32_0", + "asn1crypto 0.22.0 py35h0d675fe_1", + "astroid 1.5.3 py35h1d0c565_0", + "astropy 2.0.2 py35h2d2a8a6_4", + "babel 2.5.0 py35ha5fc564_0", + "backports 1.0 py35hd471ac7_1", + "backports.shutil_get_terminal_size 1.0.0 py35h40844db_2", + "beautifulsoup4 4.6.0 py35h442a8c9_1", + "bitarray 0.8.1 py35h7540340_0", + "bkcharts 0.2 py35he4f7e30_0", + "blaze 0.11.3 py35ha2c9137_0", + "bleach 2.0.0 py35h055c768_0", + "bokeh 0.12.7 py35h4751c18_1", + "boto 2.48.0 py35h2cfd601_1", + "bottleneck 1.2.1 py35he1b16f1_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 h58b644b_4", + "certifi 2017.7.27.1 py35h19f42a1_0", + "cffi 1.10.0 py35h796c292_1", + "chardet 3.0.4 py35hb6e9ddf_1", + "click 6.7 py35h353a69f_0", + "cloudpickle 0.4.0 py35h10376d1_0", + "clyent 1.2.2 py35h491ffcb_1", + "colorama 0.3.9 py35h81e2b6c_0", + "contextlib2 0.5.5 py35h6690dba_0", + "cryptography 2.0.3 py35hef72dfd_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py35hc4d5149_0", + "cython 0.26.1 py35h636ebcb_0", + "cytoolz 0.8.2 py35ha53021f_0", + "dask 0.15.2 py35h08b2748_0", + "dask-core 0.15.2 py35h79caba8_0", + "datashape 0.5.4 py35h5b068ae_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py35h3a268aa_0", + "distributed 1.18.3 py35h076cbad_0", + "docutils 0.14 py35hd11081d_0", + "entrypoints 0.2.3 py35h48174a2_2", + "et_xmlfile 1.0.1 py35hde8d43e_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py35hec2bbaa_0", + "filelock 2.0.12 py35h7855d60_0", + "flask 0.12.2 py35h679e90e_0", + "flask-cors 3.0.3 py35h9b2065d_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py35he064abf_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py35h98a1f2a_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py35h89a7545_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py35h2547b41_0", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py35h41d5d6e_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py35h51e6c10_0", + "html5lib 0.999999999 py35h0543385_0", + "icu 58.2 h211956c_0", + "idna 2.6 py35h8605a33_1", + "imageio 2.2.0 py35hd0a6de2_0", + "imagesize 0.7.1 py35hf008fae_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipykernel 4.6.1 py35h29d130c_0", + "ipython 6.1.0 py35h1b71439_1", + "ipython_genutils 0.2.0 py35hc9e07d0_0", + "ipywidgets 7.0.0 py35h8ebd919_0", + "isort 4.2.15 py35h44a00d2_0", + "itsdangerous 0.24 py35h7c46880_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py35hf1f7175_0", + "jedi 0.10.2 py35hc33c70f_0", + "jinja2 2.9.6 py35h90b8645_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py35h4395190_0", + "jupyter 1.0.0 py35hd38625c_0", + "jupyter_client 5.1.0 py35h2bff583_0", + "jupyter_console 5.2.0 py35h4044a63_1", + "jupyter_core 4.3.0 py35he2f7985_0", + "jupyterlab 0.27.0 py35h29561ed_2", + "jupyterlab_launcher 0.4.0 py35ha4e430f_0", + "lazy-object-proxy 1.3.1 py35h4c720c6_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 hcbc56d2_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h24385c6_1", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 he6ee5dd_2", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py35_0", + "locket 0.2.0 py35h170bc82_1", + "lxml 3.8.0 py35h4935ab9_0", + "lzo 2.10 hc0eb8fc_0", + "markupsafe 1.0 py35h4f4fcf6_1", + "matplotlib 2.0.2 py35hdbc49ba_1", + "mccabe 0.6.1 py35hd8c1f23_1", + "mistune 0.7.4 py35hfd0f961_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py35h0fc7090_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py35h5a16178_2", + "msgpack-python 0.4.8 py35h783f4c8_0", + "multipledispatch 0.4.9 py35h2ff591a_0", + "navigator-updater 0.1.0 py35h2ff6758_0", + "nbconvert 5.3.1 py35hc5194e3_0", + "nbformat 4.4.0 py35h12e6e07_0", + "ncurses 6.0 h06874d7_1", + "networkx 1.11 py35hf333c83_0", + "nltk 3.2.4 py35h7ba7875_0", + "nose 1.3.7 py35hdc64897_2", + "notebook 5.0.0 py35h65c930e_2", + "numba 0.35.0 np113py35_10", + "numexpr 2.6.2 py35h5f89caa_1", + "numpy 1.13.1 py35h8926d81_2", + "numpydoc 0.7.0 py35he089a57_0", + "odo 0.5.1 py35h102315f_0", + "olefile 0.44 py35h2c86149_0", + "openpyxl 2.4.8 py35hd6c89d3_1", + "openssl 1.0.2l h9d1a558_3", + "packaging 16.8 py35h2260b46_1", + "pandas 0.20.3 py35h85c2c75_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py35h1565a15_1", + "pango 1.40.11 hedb6d6b_0", + "partd 0.3.8 py35h68187f2_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py35hb82cfee_0", + "pathlib2 2.3.0 py35hd637de4_0", + "patsy 0.4.1 py35h51b66d5_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py35hee76f29_0", + "pexpect 4.2.1 py35h8b56cb4_0", + "pickleshare 0.7.4 py35hd57304d_0", + "pillow 4.2.1 py35h03abc04_0", + "pip 9.0.1 py35he1b8d41_2", + "pixman 0.34.0 ha72d70b_1", + "pkginfo 1.4.1 py35hb526c55_1", + "ply 3.10 py35h459f1a0_0", + "prompt_toolkit 1.0.15 py35hc09de7a_0", + "psutil 5.2.2 py35h75e6a48_0", + "ptyprocess 0.5.2 py35h38ce0a3_0", + "py 1.4.34 py35hd71111f_1", + "pycodestyle 2.3.1 py35h8d2105a_0", + "pycosat 0.6.2 py35h9693557_1", + "pycparser 2.18 py35h61b3040_1", + "pycrypto 2.6.1 py35h9852db7_1", + "pycurl 7.43.0 py35h7a9665c_3", + "pyflakes 1.5.0 py35h06f3f26_1", + "pygments 2.2.0 py35h0f41973_0", + "pylint 1.7.2 py35hc802fb1_0", + "pyodbc 4.0.17 py35h89a430b_0", + "pyopenssl 17.2.0 py35h1d2a76c_0", + "pyparsing 2.2.0 py35h041ed72_1", + "pyqt 5.6.0 py35h0e41ada_5", + "pysocks 1.6.7 py35h6aefbb0_1", + "pytables 3.4.2 py35hc74b6c3_1", + "pytest 3.2.1 py35hc97c719_1", + "python 3.5.4 hc053d89_14", + "python-dateutil 2.6.1 py35h90d5b31_1", + "pytz 2017.2 py35h9225bff_1", + "pywavelets 0.5.2 py35h53ec731_0", + "pyyaml 3.12 py35h46ef4ae_1", + "pyzmq 16.0.2 py35h4be1f71_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py35hd68ff89_0", + "qtconsole 4.3.1 py35h4626a06_0", + "qtpy 1.3.1 py35h881af26_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py35hb9e6ad1_1", + "rope 0.10.5 py35h31d6b7c_0", + "ruamel_yaml 0.11.14 py35h8e2c16b_2", + "scikit-image 0.13.0 py35h3573165_1", + "scikit-learn 0.19.0 py35h25e8076_2", + "scipy 0.19.1 py35ha8f041b_3", + "seaborn 0.8.0 py35h15a2772_0", + "setuptools 36.5.0 py35ha8c1747_0", + "simplegeneric 0.8.1 py35h2ec4104_0", + "singledispatch 3.4.0.3 py35h0cd4ec3_0", + "sip 4.18.1 py35h9eaea60_2", + "six 1.10.0 py35h5312c1b_1", + "snowballstemmer 1.2.1 py35h5435977_0", + "sortedcollections 0.5.3 py35hb2f60ff_0", + "sortedcontainers 1.5.7 py35h683703c_0", + "sphinx 1.6.3 py35hea25a1c_0", + "sphinxcontrib 1.0 py35hcb7efd2_1", + "sphinxcontrib-websupport 1.0.1 py35h3537809_1", + "spyder 3.2.3 py35h49e6fe2_1", + "sqlalchemy 1.1.13 py35h4911131_0", + "sqlite 3.20.1 h6d8b0f3_1", + "statsmodels 0.8.0 py35haa9d50b_0", + "sympy 1.1.1 py35h919b29a_0", + "tblib 1.3.2 py35hf1eb0b4_0", + "terminado 0.6 py35hce234ed_0", + "testpath 0.3.1 py35had42eaf_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py35h90f1797_0", + "tornado 4.5.2 py35hf879e1d_0", + "traitlets 4.3.2 py35ha522a97_0", + "typing 3.6.2 py35hcadae7e_0", + "unicodecsv 0.14.1 py35h4805c0c_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py35h2ab6e29_0", + "wcwidth 0.1.7 py35hcd08066_0", + "webencodings 0.5.1 py35hb6cf162_1", + "werkzeug 0.12.2 py35hbfc1ea6_0", + "wheel 0.29.0 py35h601ca99_1", + "widgetsnbextension 3.0.2 py35h0be620c_1", + "wrapt 1.10.11 py35hfdafd39_0", + "xlrd 1.1.0 py35h45a0a2a_1", + "xlsxwriter 0.9.8 py35hc9d400f_0", + "xlwt 1.3.0 py35h884a0cf_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.2 py35h00a3a39_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "8f29a0a2ea8c751be78985d6d7a59e0f", + "name": "anaconda", + "namespace": "python", + "sha256": "046e931fd8c87ec1406bc027888c6ec19c28f16e8ffb5d7c6367e4fb1126e684", + "size": 12966, + "subdir": "linux-64", + "timestamp": 1506752668772, + "version": "5.0.0.1" + }, + "anaconda-5.0.0.1-py35h6d98c0b_1.tar.bz2": { + "build": "py35h6d98c0b_1", + "build_number": 1, + "depends": [ + "alabaster 0.7.10 py35h6fb19ab_0", + "anaconda-client 1.6.5 py35hd900ed1_0", + "anaconda-navigator 1.6.8 py35haed54dd_0", + "anaconda-project 0.8.0 py35hb597f32_0", + "asn1crypto 0.22.0 py35h0d675fe_1", + "astroid 1.5.3 py35h1d0c565_0", + "astropy 2.0.2 py35h2d2a8a6_4", + "babel 2.5.0 py35ha5fc564_0", + "backports 1.0 py35hd471ac7_1", + "backports.shutil_get_terminal_size 1.0.0 py35h40844db_2", + "beautifulsoup4 4.6.0 py35h442a8c9_1", + "bitarray 0.8.1 py35h7540340_0", + "bkcharts 0.2 py35he4f7e30_0", + "blaze 0.11.3 py35ha2c9137_0", + "bleach 2.0.0 py35h055c768_0", + "bokeh 0.12.7 py35h4751c18_1", + "boto 2.48.0 py35h2cfd601_1", + "bottleneck 1.2.1 py35he1b16f1_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 h58b644b_4", + "certifi 2017.7.27.1 py35h19f42a1_0", + "cffi 1.10.0 py35h796c292_1", + "chardet 3.0.4 py35hb6e9ddf_1", + "click 6.7 py35h353a69f_0", + "cloudpickle 0.4.0 py35h10376d1_0", + "clyent 1.2.2 py35h491ffcb_1", + "colorama 0.3.9 py35h81e2b6c_0", + "contextlib2 0.5.5 py35h6690dba_0", + "cryptography 2.0.3 py35hef72dfd_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py35hc4d5149_0", + "cython 0.26.1 py35h636ebcb_0", + "cytoolz 0.8.2 py35ha53021f_0", + "dask 0.15.2 py35h08b2748_0", + "dask-core 0.15.2 py35h79caba8_0", + "datashape 0.5.4 py35h5b068ae_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py35h3a268aa_0", + "distributed 1.18.3 py35h076cbad_0", + "docutils 0.14 py35hd11081d_0", + "entrypoints 0.2.3 py35h48174a2_2", + "et_xmlfile 1.0.1 py35hde8d43e_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py35hec2bbaa_0", + "filelock 2.0.12 py35h7855d60_0", + "flask 0.12.2 py35h679e90e_0", + "flask-cors 3.0.3 py35h9b2065d_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py35he064abf_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py35h98a1f2a_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py35h89a7545_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py35h2547b41_0", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py35h41d5d6e_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py35h51e6c10_0", + "html5lib 0.999999999 py35h0543385_0", + "icu 58.2 h211956c_0", + "idna 2.6 py35h8605a33_1", + "imageio 2.2.0 py35hd0a6de2_0", + "imagesize 0.7.1 py35hf008fae_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipykernel 4.6.1 py35h29d130c_0", + "ipython 6.1.0 py35h1b71439_1", + "ipython_genutils 0.2.0 py35hc9e07d0_0", + "ipywidgets 7.0.0 py35h8ebd919_0", + "isort 4.2.15 py35h44a00d2_0", + "itsdangerous 0.24 py35h7c46880_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py35hf1f7175_0", + "jedi 0.10.2 py35hc33c70f_0", + "jinja2 2.9.6 py35h90b8645_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py35h4395190_0", + "jupyter 1.0.0 py35hd38625c_0", + "jupyter_client 5.1.0 py35h2bff583_0", + "jupyter_console 5.2.0 py35h4044a63_1", + "jupyter_core 4.3.0 py35he2f7985_0", + "jupyterlab 0.27.0 py35h29561ed_2", + "jupyterlab_launcher 0.4.0 py35ha4e430f_0", + "lazy-object-proxy 1.3.1 py35h4c720c6_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 hcbc56d2_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h24385c6_1", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 he6ee5dd_2", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py35_0", + "locket 0.2.0 py35h170bc82_1", + "lxml 3.8.0 py35h4935ab9_0", + "lzo 2.10 hc0eb8fc_0", + "markupsafe 1.0 py35h4f4fcf6_1", + "matplotlib 2.0.2 py35hdbc49ba_1", + "mccabe 0.6.1 py35hd8c1f23_1", + "mistune 0.7.4 py35hfd0f961_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py35h0fc7090_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py35h5a16178_2", + "msgpack-python 0.4.8 py35h783f4c8_0", + "multipledispatch 0.4.9 py35h2ff591a_0", + "navigator-updater 0.1.0 py35h2ff6758_0", + "nbconvert 5.3.1 py35hc5194e3_0", + "nbformat 4.4.0 py35h12e6e07_0", + "ncurses 6.0 h06874d7_1", + "networkx 1.11 py35hf333c83_0", + "nltk 3.2.4 py35h7ba7875_0", + "nose 1.3.7 py35hdc64897_2", + "notebook 5.0.0 py35h65c930e_2", + "numba 0.35.0 np113py35_10", + "numexpr 2.6.2 py35h5f89caa_1", + "numpy 1.13.1 py35h8926d81_2", + "numpydoc 0.7.0 py35he089a57_0", + "odo 0.5.1 py35h102315f_0", + "olefile 0.44 py35h2c86149_0", + "openpyxl 2.4.8 py35hd6c89d3_1", + "openssl 1.0.2l h9d1a558_3", + "packaging 16.8 py35h2260b46_1", + "pandas 0.20.3 py35h85c2c75_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py35h1565a15_1", + "pango 1.40.11 hedb6d6b_0", + "partd 0.3.8 py35h68187f2_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py35hb82cfee_0", + "pathlib2 2.3.0 py35hd637de4_0", + "patsy 0.4.1 py35h51b66d5_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py35hee76f29_0", + "pexpect 4.2.1 py35h8b56cb4_0", + "pickleshare 0.7.4 py35hd57304d_0", + "pillow 4.2.1 py35h03abc04_0", + "pip 9.0.1 py35he1b8d41_2", + "pixman 0.34.0 ha72d70b_1", + "pkginfo 1.4.1 py35hb526c55_1", + "ply 3.10 py35h459f1a0_0", + "prompt_toolkit 1.0.15 py35hc09de7a_0", + "psutil 5.2.2 py35h75e6a48_0", + "ptyprocess 0.5.2 py35h38ce0a3_0", + "py 1.4.34 py35hd71111f_1", + "pycodestyle 2.3.1 py35h8d2105a_0", + "pycosat 0.6.2 py35h9693557_1", + "pycparser 2.18 py35h61b3040_1", + "pycrypto 2.6.1 py35h9852db7_1", + "pycurl 7.43.0 py35h7a9665c_3", + "pyflakes 1.5.0 py35h06f3f26_1", + "pygments 2.2.0 py35h0f41973_0", + "pylint 1.7.2 py35hc802fb1_0", + "pyodbc 4.0.17 py35h89a430b_0", + "pyopenssl 17.2.0 py35h1d2a76c_0", + "pyparsing 2.2.0 py35h041ed72_1", + "pyqt 5.6.0 py35h0e41ada_5", + "pysocks 1.6.7 py35h6aefbb0_1", + "pytables 3.4.2 py35hc74b6c3_1", + "pytest 3.2.1 py35hc97c719_1", + "python 3.5.4 h72f0b78_15", + "python-dateutil 2.6.1 py35h90d5b31_1", + "pytz 2017.2 py35h9225bff_1", + "pywavelets 0.5.2 py35h53ec731_0", + "pyyaml 3.12 py35h46ef4ae_1", + "pyzmq 16.0.2 py35h4be1f71_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py35hd68ff89_0", + "qtconsole 4.3.1 py35h4626a06_0", + "qtpy 1.3.1 py35h881af26_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py35hb9e6ad1_1", + "rope 0.10.5 py35h31d6b7c_0", + "ruamel_yaml 0.11.14 py35h8e2c16b_2", + "scikit-image 0.13.0 py35h3573165_1", + "scikit-learn 0.19.0 py35h25e8076_2", + "scipy 0.19.1 py35ha8f041b_3", + "seaborn 0.8.0 py35h15a2772_0", + "setuptools 36.5.0 py35ha8c1747_0", + "simplegeneric 0.8.1 py35h2ec4104_0", + "singledispatch 3.4.0.3 py35h0cd4ec3_0", + "sip 4.18.1 py35h9eaea60_2", + "six 1.10.0 py35h5312c1b_1", + "snowballstemmer 1.2.1 py35h5435977_0", + "sortedcollections 0.5.3 py35hb2f60ff_0", + "sortedcontainers 1.5.7 py35h683703c_0", + "sphinx 1.6.3 py35hea25a1c_0", + "sphinxcontrib 1.0 py35hcb7efd2_1", + "sphinxcontrib-websupport 1.0.1 py35h3537809_1", + "spyder 3.2.3 py35h49e6fe2_1", + "sqlalchemy 1.1.13 py35h4911131_0", + "sqlite 3.20.1 h6d8b0f3_1", + "statsmodels 0.8.0 py35haa9d50b_0", + "sympy 1.1.1 py35h919b29a_0", + "tblib 1.3.2 py35hf1eb0b4_0", + "terminado 0.6 py35hce234ed_0", + "testpath 0.3.1 py35had42eaf_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py35h90f1797_0", + "tornado 4.5.2 py35hf879e1d_0", + "traitlets 4.3.2 py35ha522a97_0", + "typing 3.6.2 py35hcadae7e_0", + "unicodecsv 0.14.1 py35h4805c0c_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py35h2ab6e29_0", + "wcwidth 0.1.7 py35hcd08066_0", + "webencodings 0.5.1 py35hb6cf162_1", + "werkzeug 0.12.2 py35hbfc1ea6_0", + "wheel 0.29.0 py35h601ca99_1", + "widgetsnbextension 3.0.2 py35h0be620c_1", + "wrapt 1.10.11 py35hfdafd39_0", + "xlrd 1.1.0 py35h45a0a2a_1", + "xlsxwriter 0.9.8 py35hc9d400f_0", + "xlwt 1.3.0 py35h884a0cf_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.2 py35h00a3a39_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "db3f7bfd7cad2a60f9e95d14fbe8f0e7", + "name": "anaconda", + "namespace": "python", + "sha256": "99bda6033dc58292eb066d84ae3bdef766d4be2ceb0200748bf508ab51453cb8", + "size": 12983, + "subdir": "linux-64", + "timestamp": 1506833951274, + "version": "5.0.0.1" + }, + "anaconda-5.0.0.1-py36h6c6c83f_0.tar.bz2": { + "build": "py36h6c6c83f_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.10 py36h306e16b_0", + "anaconda-client 1.6.5 py36h19c0dcd_0", + "anaconda-navigator 1.6.8 py36h672ccc7_0", + "anaconda-project 0.8.0 py36h29abdf5_0", + "asn1crypto 0.22.0 py36h265ca7c_1", + "astroid 1.5.3 py36hbdb9df2_0", + "astropy 2.0.2 py36ha51211e_4", + "babel 2.5.0 py36h7d14adf_0", + "backports 1.0 py36hfa02d7e_1", + "backports.shutil_get_terminal_size 1.0.0 py36hfea85ff_2", + "beautifulsoup4 4.6.0 py36h49b8c8c_1", + "bitarray 0.8.1 py36h5834eb8_0", + "bkcharts 0.2 py36h735825a_0", + "blaze 0.11.3 py36h4e06776_0", + "bleach 2.0.0 py36h688b259_0", + "bokeh 0.12.7 py36h169c5fd_1", + "boto 2.48.0 py36h6e4cd66_1", + "bottleneck 1.2.1 py36haac1ea0_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 h58b644b_4", + "certifi 2017.7.27.1 py36h8b7b77e_0", + "cffi 1.10.0 py36had8d393_1", + "chardet 3.0.4 py36h0f667ec_1", + "click 6.7 py36h5253387_0", + "cloudpickle 0.4.0 py36h30f8c20_0", + "clyent 1.2.2 py36h7e57e65_1", + "colorama 0.3.9 py36h489cec4_0", + "contextlib2 0.5.5 py36h6c84a62_0", + "cryptography 2.0.3 py36ha225213_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py36h93f1223_0", + "cython 0.26.1 py36h21c49d0_0", + "cytoolz 0.8.2 py36h708bfd4_0", + "dask 0.15.2 py36h9b48dc4_0", + "dask-core 0.15.2 py36h0f988a8_0", + "datashape 0.5.4 py36h3ad6b5c_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py36hd076ac8_0", + "distributed 1.18.3 py36h73cd4ae_0", + "docutils 0.14 py36hb0f60f5_0", + "entrypoints 0.2.3 py36h1aec115_2", + "et_xmlfile 1.0.1 py36hd6bccc3_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py36h5b0c431_0", + "filelock 2.0.12 py36hacfa1f5_0", + "flask 0.12.2 py36hb24657c_0", + "flask-cors 3.0.3 py36h2d857d3_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py36h2fe25dc_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py36h2c1b292_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py36h55090d7_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py36h2d503a6_0", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py36he81ebca_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py36h79797d7_0", + "html5lib 0.999999999 py36h2cfc398_0", + "icu 58.2 h211956c_0", + "idna 2.6 py36h82fb2a8_1", + "imageio 2.2.0 py36he555465_0", + "imagesize 0.7.1 py36h52d8127_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipykernel 4.6.1 py36hbf841aa_0", + "ipython 6.1.0 py36hc72a948_1", + "ipython_genutils 0.2.0 py36hb52b0d5_0", + "ipywidgets 7.0.0 py36h7b55c3a_0", + "isort 4.2.15 py36had401c0_0", + "itsdangerous 0.24 py36h93cc618_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py36h4c697fb_0", + "jedi 0.10.2 py36h552def0_0", + "jinja2 2.9.6 py36h489bce4_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py36h006f8b5_0", + "jupyter 1.0.0 py36h9896ce5_0", + "jupyter_client 5.1.0 py36h614e9ea_0", + "jupyter_console 5.2.0 py36he59e554_1", + "jupyter_core 4.3.0 py36h357a921_0", + "jupyterlab 0.27.0 py36h86377d0_2", + "jupyterlab_launcher 0.4.0 py36h4d8058d_0", + "lazy-object-proxy 1.3.1 py36h10fcdad_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 hcbc56d2_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h24385c6_1", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 he6ee5dd_2", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py36_0", + "locket 0.2.0 py36h787c0ad_1", + "lxml 3.8.0 py36h6c6e760_0", + "lzo 2.10 hc0eb8fc_0", + "markupsafe 1.0 py36hd9260cd_1", + "matplotlib 2.0.2 py36h2acb4ad_1", + "mccabe 0.6.1 py36h5ad9710_1", + "mistune 0.7.4 py36hbab8784_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py36h17a0993_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py36h8cc018b_2", + "msgpack-python 0.4.8 py36hec4c5d1_0", + "multipledispatch 0.4.9 py36h41da3fb_0", + "navigator-updater 0.1.0 py36h14770f7_0", + "nbconvert 5.3.1 py36hb41ffb7_0", + "nbformat 4.4.0 py36h31c9010_0", + "ncurses 6.0 h06874d7_1", + "networkx 1.11 py36hfb3574a_0", + "nltk 3.2.4 py36h1a0979f_0", + "nose 1.3.7 py36hcdf7029_2", + "notebook 5.0.0 py36h0b20546_2", + "numba 0.35.0 np113py36_10", + "numexpr 2.6.2 py36hdd3393f_1", + "numpy 1.13.1 py36h5bc529a_2", + "numpydoc 0.7.0 py36h18f165f_0", + "odo 0.5.1 py36h90ed295_0", + "olefile 0.44 py36h79f9f78_0", + "openpyxl 2.4.8 py36h41dd2a8_1", + "openssl 1.0.2l h9d1a558_3", + "packaging 16.8 py36ha668100_1", + "pandas 0.20.3 py36h842e28d_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py36ha6701b7_1", + "pango 1.40.11 hedb6d6b_0", + "partd 0.3.8 py36h36fd896_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py36he0c6f6d_0", + "pathlib2 2.3.0 py36h49efa8e_0", + "patsy 0.4.1 py36ha3be15e_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py36h26ade29_0", + "pexpect 4.2.1 py36h3b9d41b_0", + "pickleshare 0.7.4 py36h63277f8_0", + "pillow 4.2.1 py36h9119f52_0", + "pip 9.0.1 py36h30f8307_2", + "pixman 0.34.0 ha72d70b_1", + "pkginfo 1.4.1 py36h215d178_1", + "ply 3.10 py36hed35086_0", + "prompt_toolkit 1.0.15 py36h17d85b1_0", + "psutil 5.2.2 py36h74c8701_0", + "ptyprocess 0.5.2 py36h69acd42_0", + "py 1.4.34 py36h0712aa3_1", + "pycodestyle 2.3.1 py36hf609f19_0", + "pycosat 0.6.2 py36h1a0ea17_1", + "pycparser 2.18 py36hf9f622e_1", + "pycrypto 2.6.1 py36h6998063_1", + "pycurl 7.43.0 py36h5e72054_3", + "pyflakes 1.5.0 py36h5510808_1", + "pygments 2.2.0 py36h0d3125c_0", + "pylint 1.7.2 py36h484ab97_0", + "pyodbc 4.0.17 py36h999153c_0", + "pyopenssl 17.2.0 py36h5cc804b_0", + "pyparsing 2.2.0 py36hee85983_1", + "pyqt 5.6.0 py36h0386399_5", + "pysocks 1.6.7 py36hd97a5b1_1", + "pytables 3.4.2 py36hdce54c9_1", + "pytest 3.2.1 py36h11ad3bb_1", + "python 3.6.2 h0b30769_14", + "python-dateutil 2.6.1 py36h88d3b88_1", + "pytz 2017.2 py36hc2ccc2a_1", + "pywavelets 0.5.2 py36he602eb0_0", + "pyyaml 3.12 py36hafb9ca4_1", + "pyzmq 16.0.2 py36h3b0cf96_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py36h609ed8c_0", + "qtconsole 4.3.1 py36h8f73b5b_0", + "qtpy 1.3.1 py36h3691cc8_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py36he2e5f8d_1", + "rope 0.10.5 py36h1f8c17e_0", + "ruamel_yaml 0.11.14 py36ha2fb22d_2", + "scikit-image 0.13.0 py36had3c07a_1", + "scikit-learn 0.19.0 py36h97ac459_2", + "scipy 0.19.1 py36h9976243_3", + "seaborn 0.8.0 py36h197244f_0", + "setuptools 36.5.0 py36he42e2e1_0", + "simplegeneric 0.8.1 py36h2cb9092_0", + "singledispatch 3.4.0.3 py36h7a266c3_0", + "sip 4.18.1 py36h51ed4ed_2", + "six 1.10.0 py36hcac75e4_1", + "snowballstemmer 1.2.1 py36h6febd40_0", + "sortedcollections 0.5.3 py36h3c761f9_0", + "sortedcontainers 1.5.7 py36hdf89491_0", + "sphinx 1.6.3 py36he5f0bdb_0", + "sphinxcontrib 1.0 py36h6d0f590_1", + "sphinxcontrib-websupport 1.0.1 py36hb5cb234_1", + "spyder 3.2.3 py36he38cbf7_1", + "sqlalchemy 1.1.13 py36hfb5efd7_0", + "sqlite 3.20.1 h6d8b0f3_1", + "statsmodels 0.8.0 py36h8533d0b_0", + "sympy 1.1.1 py36hc6d1c1c_0", + "tblib 1.3.2 py36h34cf8b6_0", + "terminado 0.6 py36ha25a19f_0", + "testpath 0.3.1 py36h8cadb63_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py36h81f2dff_0", + "tornado 4.5.2 py36h1283b2a_0", + "traitlets 4.3.2 py36h674d592_0", + "typing 3.6.2 py36h7da032a_0", + "unicodecsv 0.14.1 py36ha668878_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py36hbe7ace6_0", + "wcwidth 0.1.7 py36hdf4376a_0", + "webencodings 0.5.1 py36h800622e_1", + "werkzeug 0.12.2 py36hc703753_0", + "wheel 0.29.0 py36he7f4e38_1", + "widgetsnbextension 3.0.2 py36hd01bb71_1", + "wrapt 1.10.11 py36h28b7045_0", + "xlrd 1.1.0 py36h1db9f0c_1", + "xlsxwriter 0.9.8 py36hf41c223_0", + "xlwt 1.3.0 py36h7b00a1f_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.2 py36ha0d441b_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "af661854c366ceb3d6b30f2079575807", + "name": "anaconda", + "namespace": "python", + "sha256": "ae3731e8d3e5e2859bbf87cb47d8de5acc46223de7045ec5f8c384f84619775c", + "size": 12819, + "subdir": "linux-64", + "timestamp": 1506790331786, + "version": "5.0.0.1" + }, + "anaconda-5.0.0.1-py36hfb0b618_1.tar.bz2": { + "build": "py36hfb0b618_1", + "build_number": 1, + "depends": [ + "alabaster 0.7.10 py36h306e16b_0", + "anaconda-client 1.6.5 py36h19c0dcd_0", + "anaconda-navigator 1.6.8 py36h672ccc7_0", + "anaconda-project 0.8.0 py36h29abdf5_0", + "asn1crypto 0.22.0 py36h265ca7c_1", + "astroid 1.5.3 py36hbdb9df2_0", + "astropy 2.0.2 py36ha51211e_4", + "babel 2.5.0 py36h7d14adf_0", + "backports 1.0 py36hfa02d7e_1", + "backports.shutil_get_terminal_size 1.0.0 py36hfea85ff_2", + "beautifulsoup4 4.6.0 py36h49b8c8c_1", + "bitarray 0.8.1 py36h5834eb8_0", + "bkcharts 0.2 py36h735825a_0", + "blaze 0.11.3 py36h4e06776_0", + "bleach 2.0.0 py36h688b259_0", + "bokeh 0.12.7 py36h169c5fd_1", + "boto 2.48.0 py36h6e4cd66_1", + "bottleneck 1.2.1 py36haac1ea0_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 h58b644b_4", + "certifi 2017.7.27.1 py36h8b7b77e_0", + "cffi 1.10.0 py36had8d393_1", + "chardet 3.0.4 py36h0f667ec_1", + "click 6.7 py36h5253387_0", + "cloudpickle 0.4.0 py36h30f8c20_0", + "clyent 1.2.2 py36h7e57e65_1", + "colorama 0.3.9 py36h489cec4_0", + "contextlib2 0.5.5 py36h6c84a62_0", + "cryptography 2.0.3 py36ha225213_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py36h93f1223_0", + "cython 0.26.1 py36h21c49d0_0", + "cytoolz 0.8.2 py36h708bfd4_0", + "dask 0.15.2 py36h9b48dc4_0", + "dask-core 0.15.2 py36h0f988a8_0", + "datashape 0.5.4 py36h3ad6b5c_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py36hd076ac8_0", + "distributed 1.18.3 py36h73cd4ae_0", + "docutils 0.14 py36hb0f60f5_0", + "entrypoints 0.2.3 py36h1aec115_2", + "et_xmlfile 1.0.1 py36hd6bccc3_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py36h5b0c431_0", + "filelock 2.0.12 py36hacfa1f5_0", + "flask 0.12.2 py36hb24657c_0", + "flask-cors 3.0.3 py36h2d857d3_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py36h2fe25dc_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py36h2c1b292_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py36h55090d7_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py36h2d503a6_0", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py36he81ebca_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py36h79797d7_0", + "html5lib 0.999999999 py36h2cfc398_0", + "icu 58.2 h211956c_0", + "idna 2.6 py36h82fb2a8_1", + "imageio 2.2.0 py36he555465_0", + "imagesize 0.7.1 py36h52d8127_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipykernel 4.6.1 py36hbf841aa_0", + "ipython 6.1.0 py36hc72a948_1", + "ipython_genutils 0.2.0 py36hb52b0d5_0", + "ipywidgets 7.0.0 py36h7b55c3a_0", + "isort 4.2.15 py36had401c0_0", + "itsdangerous 0.24 py36h93cc618_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py36h4c697fb_0", + "jedi 0.10.2 py36h552def0_0", + "jinja2 2.9.6 py36h489bce4_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py36h006f8b5_0", + "jupyter 1.0.0 py36h9896ce5_0", + "jupyter_client 5.1.0 py36h614e9ea_0", + "jupyter_console 5.2.0 py36he59e554_1", + "jupyter_core 4.3.0 py36h357a921_0", + "jupyterlab 0.27.0 py36h86377d0_2", + "jupyterlab_launcher 0.4.0 py36h4d8058d_0", + "lazy-object-proxy 1.3.1 py36h10fcdad_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 hcbc56d2_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h24385c6_1", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 he6ee5dd_2", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py36_0", + "locket 0.2.0 py36h787c0ad_1", + "lxml 3.8.0 py36h6c6e760_0", + "lzo 2.10 hc0eb8fc_0", + "markupsafe 1.0 py36hd9260cd_1", + "matplotlib 2.0.2 py36h2acb4ad_1", + "mccabe 0.6.1 py36h5ad9710_1", + "mistune 0.7.4 py36hbab8784_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py36h17a0993_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py36h8cc018b_2", + "msgpack-python 0.4.8 py36hec4c5d1_0", + "multipledispatch 0.4.9 py36h41da3fb_0", + "navigator-updater 0.1.0 py36h14770f7_0", + "nbconvert 5.3.1 py36hb41ffb7_0", + "nbformat 4.4.0 py36h31c9010_0", + "ncurses 6.0 h06874d7_1", + "networkx 1.11 py36hfb3574a_0", + "nltk 3.2.4 py36h1a0979f_0", + "nose 1.3.7 py36hcdf7029_2", + "notebook 5.0.0 py36h0b20546_2", + "numba 0.35.0 np113py36_10", + "numexpr 2.6.2 py36hdd3393f_1", + "numpy 1.13.1 py36h5bc529a_2", + "numpydoc 0.7.0 py36h18f165f_0", + "odo 0.5.1 py36h90ed295_0", + "olefile 0.44 py36h79f9f78_0", + "openpyxl 2.4.8 py36h41dd2a8_1", + "openssl 1.0.2l h9d1a558_3", + "packaging 16.8 py36ha668100_1", + "pandas 0.20.3 py36h842e28d_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py36ha6701b7_1", + "pango 1.40.11 hedb6d6b_0", + "partd 0.3.8 py36h36fd896_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py36he0c6f6d_0", + "pathlib2 2.3.0 py36h49efa8e_0", + "patsy 0.4.1 py36ha3be15e_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py36h26ade29_0", + "pexpect 4.2.1 py36h3b9d41b_0", + "pickleshare 0.7.4 py36h63277f8_0", + "pillow 4.2.1 py36h9119f52_0", + "pip 9.0.1 py36h30f8307_2", + "pixman 0.34.0 ha72d70b_1", + "pkginfo 1.4.1 py36h215d178_1", + "ply 3.10 py36hed35086_0", + "prompt_toolkit 1.0.15 py36h17d85b1_0", + "psutil 5.2.2 py36h74c8701_0", + "ptyprocess 0.5.2 py36h69acd42_0", + "py 1.4.34 py36h0712aa3_1", + "pycodestyle 2.3.1 py36hf609f19_0", + "pycosat 0.6.2 py36h1a0ea17_1", + "pycparser 2.18 py36hf9f622e_1", + "pycrypto 2.6.1 py36h6998063_1", + "pycurl 7.43.0 py36h5e72054_3", + "pyflakes 1.5.0 py36h5510808_1", + "pygments 2.2.0 py36h0d3125c_0", + "pylint 1.7.2 py36h484ab97_0", + "pyodbc 4.0.17 py36h999153c_0", + "pyopenssl 17.2.0 py36h5cc804b_0", + "pyparsing 2.2.0 py36hee85983_1", + "pyqt 5.6.0 py36h0386399_5", + "pysocks 1.6.7 py36hd97a5b1_1", + "pytables 3.4.2 py36hdce54c9_1", + "pytest 3.2.1 py36h11ad3bb_1", + "python 3.6.2 hdfe5801_15", + "python-dateutil 2.6.1 py36h88d3b88_1", + "pytz 2017.2 py36hc2ccc2a_1", + "pywavelets 0.5.2 py36he602eb0_0", + "pyyaml 3.12 py36hafb9ca4_1", + "pyzmq 16.0.2 py36h3b0cf96_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py36h609ed8c_0", + "qtconsole 4.3.1 py36h8f73b5b_0", + "qtpy 1.3.1 py36h3691cc8_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py36he2e5f8d_1", + "rope 0.10.5 py36h1f8c17e_0", + "ruamel_yaml 0.11.14 py36ha2fb22d_2", + "scikit-image 0.13.0 py36had3c07a_1", + "scikit-learn 0.19.0 py36h97ac459_2", + "scipy 0.19.1 py36h9976243_3", + "seaborn 0.8.0 py36h197244f_0", + "setuptools 36.5.0 py36he42e2e1_0", + "simplegeneric 0.8.1 py36h2cb9092_0", + "singledispatch 3.4.0.3 py36h7a266c3_0", + "sip 4.18.1 py36h51ed4ed_2", + "six 1.10.0 py36hcac75e4_1", + "snowballstemmer 1.2.1 py36h6febd40_0", + "sortedcollections 0.5.3 py36h3c761f9_0", + "sortedcontainers 1.5.7 py36hdf89491_0", + "sphinx 1.6.3 py36he5f0bdb_0", + "sphinxcontrib 1.0 py36h6d0f590_1", + "sphinxcontrib-websupport 1.0.1 py36hb5cb234_1", + "spyder 3.2.3 py36he38cbf7_1", + "sqlalchemy 1.1.13 py36hfb5efd7_0", + "sqlite 3.20.1 h6d8b0f3_1", + "statsmodels 0.8.0 py36h8533d0b_0", + "sympy 1.1.1 py36hc6d1c1c_0", + "tblib 1.3.2 py36h34cf8b6_0", + "terminado 0.6 py36ha25a19f_0", + "testpath 0.3.1 py36h8cadb63_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py36h81f2dff_0", + "tornado 4.5.2 py36h1283b2a_0", + "traitlets 4.3.2 py36h674d592_0", + "typing 3.6.2 py36h7da032a_0", + "unicodecsv 0.14.1 py36ha668878_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py36hbe7ace6_0", + "wcwidth 0.1.7 py36hdf4376a_0", + "webencodings 0.5.1 py36h800622e_1", + "werkzeug 0.12.2 py36hc703753_0", + "wheel 0.29.0 py36he7f4e38_1", + "widgetsnbextension 3.0.2 py36hd01bb71_1", + "wrapt 1.10.11 py36h28b7045_0", + "xlrd 1.1.0 py36h1db9f0c_1", + "xlsxwriter 0.9.8 py36hf41c223_0", + "xlwt 1.3.0 py36h7b00a1f_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.2 py36ha0d441b_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "7f0d9182f762028b2f2214dd7e5cd9f9", + "name": "anaconda", + "namespace": "python", + "sha256": "b28ff7bf65b08f90cd86c067888a70a6abdaca645e145a2bbdeadf9846522df3", + "size": 12829, + "subdir": "linux-64", + "timestamp": 1506842869773, + "version": "5.0.0.1" + }, + "anaconda-5.0.1-py27hd9359a7_1.tar.bz2": { + "build": "py27hd9359a7_1", + "build_number": 1, + "depends": [ + "alabaster 0.7.10 py27he5a193a_0", + "anaconda-client 1.6.5 py27hc8169bf_0", + "anaconda-navigator 1.6.9 py27hfbc306d_0", + "anaconda-project 0.8.0 py27hd7a9a97_0", + "asn1crypto 0.22.0 py27h94ebe91_1", + "astroid 1.5.3 py27h8f8f47c_0", + "astropy 2.0.2 py27h57072c0_4", + "babel 2.5.0 py27h20693cd_0", + "backports 1.0 py27h63c9359_1", + "backports.functools_lru_cache 1.4 py27he8db605_1", + "backports.shutil_get_terminal_size 1.0.0 py27h5bc021e_2", + "backports_abc 0.5 py27h7b3c97b_0", + "beautifulsoup4 4.6.0 py27h3f86ba9_1", + "bitarray 0.8.1 py27h304d4c6_0", + "bkcharts 0.2 py27h241ae91_0", + "blaze 0.11.3 py27h5f341da_0", + "bleach 2.0.0 py27h3a0dcc8_0", + "bokeh 0.12.10 py27he46cc6b_0", + "boto 2.48.0 py27h9556ac2_1", + "bottleneck 1.2.1 py27h21b16a3_0", + "bzip2 1.0.6 h0376d23_1", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 haa5651f_5", + "cdecimal 2.3 py27h4e63abe_1", + "certifi 2017.7.27.1 py27h9ceb091_0", + "cffi 1.10.0 py27hf1aaaf4_1", + "chardet 3.0.4 py27hfa10054_1", + "click 6.7 py27h4225b90_0", + "cloudpickle 0.4.0 py27ha64365b_0", + "clyent 1.2.2 py27h7276e6c_1", + "colorama 0.3.9 py27h5cde069_0", + "configparser 3.5.0 py27h5117587_0", + "contextlib2 0.5.5 py27hbf4c468_0", + "cryptography 2.0.3 py27hea39389_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py27hc7354d3_0", + "cython 0.26.1 py27hdbcff32_0", + "cytoolz 0.8.2 py27hf14aec9_0", + "dask 0.15.3 py27hb94b45f_0", + "dask-core 0.15.3 py27h53a7ee6_0", + "datashape 0.5.4 py27hf507385_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py27h1544723_0", + "distributed 1.19.1 py27h38c4a05_0", + "docutils 0.14 py27hae222c1_0", + "entrypoints 0.2.3 py27h502b47d_2", + "enum34 1.1.6 py27h99a27e9_1", + "et_xmlfile 1.0.1 py27h75840f5_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py27h4cb8e01_0", + "filelock 2.0.12 py27h38fa839_0", + "flask 0.12.2 py27h6d5c1cd_0", + "flask-cors 3.0.3 py27h1a8a27f_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "funcsigs 1.0.2 py27h83f16ab_0", + "functools32 3.2.3.2 py27h4ead58f_1", + "futures 3.1.1 py27hdbc8cbb_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py27h475ea6a_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py27hd3b7d1f_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py27hc856308_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py27hac09c53_0", + "grin 1.2.1 py27h54abee7_1", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py27h71d1790_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py27h33770af_0", + "html5lib 0.999999999 py27hdf15f34_0", + "icu 58.2 h211956c_0", + "idna 2.6 py27h5722d68_1", + "imageio 2.2.0 py27hf108a7f_0", + "imagesize 0.7.1 py27hd17bf80_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipaddress 1.0.18 py27h337fd85_0", + "ipykernel 4.6.1 py27hc93e584_0", + "ipython 5.4.1 py27h36c99b6_1", + "ipython_genutils 0.2.0 py27h89fb69b_0", + "ipywidgets 7.0.0 py27h4fda95d_0", + "isort 4.2.15 py27hcfa4749_0", + "itsdangerous 0.24 py27hb8295c1_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py27h2cc5433_0", + "jedi 0.10.2 py27h8af4e35_0", + "jinja2 2.9.6 py27h82327ae_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py27h7ed5aa4_0", + "jupyter 1.0.0 py27h505fd4b_0", + "jupyter_client 5.1.0 py27hbee1118_0", + "jupyter_console 5.2.0 py27hc6bee7e_1", + "jupyter_core 4.3.0 py27hcd9ae3a_0", + "jupyterlab 0.27.0 py27h42ebfef_2", + "jupyterlab_launcher 0.4.0 py27h0e16d15_0", + "lazy-object-proxy 1.3.1 py27h682c727_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 h7cc24e2_2", + "libgfortran-ng 7.2.0 h9f7466a_2", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h7a57d05_2", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 h84ff03f_3", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py27_0", + "locket 0.2.0 py27h73929a2_1", + "lxml 4.1.0 py27hb025457_0", + "lzo 2.10 h1bfc0ba_1", + "markupsafe 1.0 py27h97b2822_1", + "matplotlib 2.1.0 py27h09aba24_0", + "mccabe 0.6.1 py27h0e7c7be_1", + "mistune 0.7.4 py27h6da7e90_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py27hb2d42c5_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py27h4bb41bd_2", + "msgpack-python 0.4.8 py27hc2fa789_0", + "multipledispatch 0.4.9 py27h9b5f95a_0", + "navigator-updater 0.1.0 py27h0f9cd39_0", + "nbconvert 5.3.1 py27he041f76_0", + "nbformat 4.4.0 py27hed7f2b2_0", + "ncurses 6.0 h06874d7_1", + "networkx 2.0 py27hfc23926_0", + "nltk 3.2.4 py27h41293c3_0", + "nose 1.3.7 py27heec2199_2", + "notebook 5.0.0 py27h3661c2b_2", + "numba 0.35.0 np113py27_10", + "numexpr 2.6.2 py27he5efce1_1", + "numpy 1.13.3 py27hbcc08e0_0", + "numpydoc 0.7.0 py27h9647a75_0", + "odo 0.5.1 py27h9170de3_0", + "olefile 0.44 py27h4bd3e3c_0", + "openpyxl 2.4.8 py27h9f0c937_1", + "openssl 1.0.2l h077ae2c_5", + "packaging 16.8 py27h5e07c7c_1", + "pandas 0.20.3 py27h820b67f_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py27h428e1e5_1", + "pango 1.40.11 h8191d47_0", + "partd 0.3.8 py27h4e55004_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py27hc258cac_0", + "pathlib2 2.3.0 py27h6e9d198_0", + "patsy 0.4.1 py27hd1cf8c0_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py27h444351c_0", + "pexpect 4.2.1 py27hcf82287_0", + "pickleshare 0.7.4 py27h09770e1_0", + "pillow 4.2.1 py27h7cd2321_0", + "pip 9.0.1 py27hbf658b2_3", + "pixman 0.34.0 h83dc358_2", + "pkginfo 1.4.1 py27hee1a9ad_1", + "ply 3.10 py27hd6d9ae5_0", + "prompt_toolkit 1.0.15 py27h1b593e1_0", + "psutil 5.4.0 py27h7da3062_0", + "ptyprocess 0.5.2 py27h4ccb14c_0", + "py 1.4.34 py27he5894e4_1", + "pycairo 1.13.3 py27hea6d626_0", + "pycodestyle 2.3.1 py27h904819d_0", + "pycosat 0.6.2 py27h1cf261c_1", + "pycparser 2.18 py27hefa08c5_1", + "pycrypto 2.6.1 py27h9abbf5c_1", + "pycurl 7.43.0 py27hcf8ebea_3", + "pyflakes 1.6.0 py27h904a57d_0", + "pygments 2.2.0 py27h4a8b6f5_0", + "pylint 1.7.4 py27h6bc7935_0", + "pyodbc 4.0.17 py27h7f7627d_0", + "pyopenssl 17.2.0 py27h189ff3b_0", + "pyparsing 2.2.0 py27hf1513f8_1", + "pyqt 5.6.0 py27h4b1e83c_5", + "pysocks 1.6.7 py27he2db6d2_1", + "pytables 3.4.2 py27h1f7bffc_2", + "pytest 3.2.1 py27h98000ae_1", + "python 2.7.14 hc2b0042_21", + "python-dateutil 2.6.1 py27h4ca5741_1", + "pytz 2017.2 py27hcac29fa_1", + "pywavelets 0.5.2 py27hecda097_0", + "pyyaml 3.12 py27h2d70dd7_1", + "pyzmq 16.0.2 py27h297844f_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py27hd7914c3_0", + "qtconsole 4.3.1 py27hc444b0d_0", + "qtpy 1.3.1 py27h63d3751_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py27hc5b0589_1", + "rope 0.10.5 py27hcb0a616_0", + "ruamel_yaml 0.11.14 py27h672d447_2", + "scandir 1.6 py27hf7388dc_0", + "scikit-image 0.13.0 py27h06cb35d_1", + "scikit-learn 0.19.1 py27h445a80a_0", + "scipy 0.19.1 py27h1edc525_3", + "seaborn 0.8.0 py27h9d2aaa1_0", + "setuptools 36.5.0 py27h68b189e_0", + "simplegeneric 0.8.1 py27h19e43cd_0", + "singledispatch 3.4.0.3 py27h9bcb476_0", + "sip 4.18.1 py27he9ba0ab_2", + "six 1.11.0 py27h5f960f1_1", + "snowballstemmer 1.2.1 py27h44e2768_0", + "sortedcollections 0.5.3 py27h135218e_0", + "sortedcontainers 1.5.7 py27he59936f_0", + "sphinx 1.6.3 py27hf9b1778_0", + "sphinxcontrib 1.0 py27h1512b58_1", + "sphinxcontrib-websupport 1.0.1 py27hf906f22_1", + "spyder 3.2.4 py27h04a3490_0", + "sqlalchemy 1.1.13 py27hb0a01da_0", + "sqlite 3.20.1 h6d8b0f3_1", + "ssl_match_hostname 3.5.0.1 py27h4ec10b9_2", + "statsmodels 0.8.0 py27hc87d62d_0", + "subprocess32 3.2.7 py27h373dbce_0", + "sympy 1.1.1 py27hc28188a_0", + "tblib 1.3.2 py27h51fe5ba_0", + "terminado 0.6 py27h4be8df9_0", + "testpath 0.3.1 py27hc38d2c4_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py27hd3b1e7e_0", + "tornado 4.5.2 py27h97b179f_0", + "traitlets 4.3.2 py27hd6ce930_0", + "typing 3.6.2 py27h66f49e2_0", + "unicodecsv 0.14.1 py27h5062da9_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py27ha55213b_0", + "wcwidth 0.1.7 py27h9e3e1ab_0", + "webencodings 0.5.1 py27hff10b21_1", + "werkzeug 0.12.2 py27hbf75dff_0", + "wheel 0.29.0 py27h411dd7b_1", + "widgetsnbextension 3.0.2 py27hcb77dec_1", + "wrapt 1.10.11 py27h04f6869_0", + "xlrd 1.1.0 py27ha77178f_1", + "xlsxwriter 1.0.2 py27h12cbc6b_0", + "xlwt 1.3.0 py27h3d85d97_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.3 py27h12c336c_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "1a83cd47e9379020eec968afbe19a188", + "name": "anaconda", + "namespace": "python", + "sha256": "c22ab7719c16d29f3fc50337ac3aeafb602cb182d92957207a1ff2f4b9079322", + "size": 13684, + "subdir": "linux-64", + "timestamp": 1508799416292, + "version": "5.0.1" + }, + "anaconda-5.0.1-py35h6f6dcbc_1.tar.bz2": { + "build": "py35h6f6dcbc_1", + "build_number": 1, + "depends": [ + "alabaster 0.7.10 py35h6fb19ab_0", + "anaconda-client 1.6.5 py35hd900ed1_0", + "anaconda-navigator 1.6.9 py35h5f5ee00_0", + "anaconda-project 0.8.0 py35hb597f32_0", + "asn1crypto 0.22.0 py35h0d675fe_1", + "astroid 1.5.3 py35h1d0c565_0", + "astropy 2.0.2 py35h2d2a8a6_4", + "babel 2.5.0 py35ha5fc564_0", + "backports 1.0 py35hd471ac7_1", + "backports.shutil_get_terminal_size 1.0.0 py35h40844db_2", + "beautifulsoup4 4.6.0 py35h442a8c9_1", + "bitarray 0.8.1 py35h7540340_0", + "bkcharts 0.2 py35he4f7e30_0", + "blaze 0.11.3 py35ha2c9137_0", + "bleach 2.0.0 py35h055c768_0", + "bokeh 0.12.10 py35hfdb0b1d_0", + "boto 2.48.0 py35h2cfd601_1", + "bottleneck 1.2.1 py35he1b16f1_0", + "bzip2 1.0.6 h0376d23_1", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 haa5651f_5", + "certifi 2017.7.27.1 py35h19f42a1_0", + "cffi 1.10.0 py35h796c292_1", + "chardet 3.0.4 py35hb6e9ddf_1", + "click 6.7 py35h353a69f_0", + "cloudpickle 0.4.0 py35h10376d1_0", + "clyent 1.2.2 py35h491ffcb_1", + "colorama 0.3.9 py35h81e2b6c_0", + "contextlib2 0.5.5 py35h6690dba_0", + "cryptography 2.0.3 py35hef72dfd_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py35hc4d5149_0", + "cython 0.26.1 py35h636ebcb_0", + "cytoolz 0.8.2 py35ha53021f_0", + "dask 0.15.3 py35h52d6c43_0", + "dask-core 0.15.3 py35hdf4792c_0", + "datashape 0.5.4 py35h5b068ae_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py35h3a268aa_0", + "distributed 1.19.1 py35h399b246_0", + "docutils 0.14 py35hd11081d_0", + "entrypoints 0.2.3 py35h48174a2_2", + "et_xmlfile 1.0.1 py35hde8d43e_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py35hec2bbaa_0", + "filelock 2.0.12 py35h7855d60_0", + "flask 0.12.2 py35h679e90e_0", + "flask-cors 3.0.3 py35h9b2065d_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py35he064abf_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py35h98a1f2a_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py35h89a7545_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py35h2547b41_0", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py35h41d5d6e_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py35h51e6c10_0", + "html5lib 0.999999999 py35h0543385_0", + "icu 58.2 h211956c_0", + "idna 2.6 py35h8605a33_1", + "imageio 2.2.0 py35hd0a6de2_0", + "imagesize 0.7.1 py35hf008fae_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipykernel 4.6.1 py35h29d130c_0", + "ipython 6.1.0 py35h1b71439_1", + "ipython_genutils 0.2.0 py35hc9e07d0_0", + "ipywidgets 7.0.0 py35h8ebd919_0", + "isort 4.2.15 py35h44a00d2_0", + "itsdangerous 0.24 py35h7c46880_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py35hf1f7175_0", + "jedi 0.10.2 py35hc33c70f_0", + "jinja2 2.9.6 py35h90b8645_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py35h4395190_0", + "jupyter 1.0.0 py35hd38625c_0", + "jupyter_client 5.1.0 py35h2bff583_0", + "jupyter_console 5.2.0 py35h4044a63_1", + "jupyter_core 4.3.0 py35he2f7985_0", + "jupyterlab 0.27.0 py35h29561ed_2", + "jupyterlab_launcher 0.4.0 py35ha4e430f_0", + "lazy-object-proxy 1.3.1 py35h4c720c6_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 h7cc24e2_2", + "libgfortran-ng 7.2.0 h9f7466a_2", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h7a57d05_2", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 h84ff03f_3", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py35_0", + "locket 0.2.0 py35h170bc82_1", + "lxml 4.1.0 py35ha401a81_0", + "lzo 2.10 h1bfc0ba_1", + "markupsafe 1.0 py35h4f4fcf6_1", + "matplotlib 2.1.0 py35h2cbf27e_0", + "mccabe 0.6.1 py35hd8c1f23_1", + "mistune 0.7.4 py35hfd0f961_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py35h0fc7090_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py35h5a16178_2", + "msgpack-python 0.4.8 py35h783f4c8_0", + "multipledispatch 0.4.9 py35h2ff591a_0", + "navigator-updater 0.1.0 py35h2ff6758_0", + "nbconvert 5.3.1 py35hc5194e3_0", + "nbformat 4.4.0 py35h12e6e07_0", + "ncurses 6.0 h06874d7_1", + "networkx 2.0 py35hc690e10_0", + "nltk 3.2.4 py35h7ba7875_0", + "nose 1.3.7 py35hdc64897_2", + "notebook 5.0.0 py35h65c930e_2", + "numba 0.35.0 np113py35_10", + "numexpr 2.6.2 py35h5f89caa_1", + "numpy 1.13.3 py35hd829ed6_0", + "numpydoc 0.7.0 py35he089a57_0", + "odo 0.5.1 py35h102315f_0", + "olefile 0.44 py35h2c86149_0", + "openpyxl 2.4.8 py35hd6c89d3_1", + "openssl 1.0.2l h077ae2c_5", + "packaging 16.8 py35h2260b46_1", + "pandas 0.20.3 py35h85c2c75_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py35h1565a15_1", + "pango 1.40.11 h8191d47_0", + "partd 0.3.8 py35h68187f2_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py35hb82cfee_0", + "pathlib2 2.3.0 py35hd637de4_0", + "patsy 0.4.1 py35h51b66d5_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py35hee76f29_0", + "pexpect 4.2.1 py35h8b56cb4_0", + "pickleshare 0.7.4 py35hd57304d_0", + "pillow 4.2.1 py35h03abc04_0", + "pip 9.0.1 py35haa8ec2a_3", + "pixman 0.34.0 h83dc358_2", + "pkginfo 1.4.1 py35hb526c55_1", + "ply 3.10 py35h459f1a0_0", + "prompt_toolkit 1.0.15 py35hc09de7a_0", + "psutil 5.4.0 py35ha5baf80_0", + "ptyprocess 0.5.2 py35h38ce0a3_0", + "py 1.4.34 py35hd71111f_1", + "pycodestyle 2.3.1 py35h8d2105a_0", + "pycosat 0.6.2 py35h9693557_1", + "pycparser 2.18 py35h61b3040_1", + "pycrypto 2.6.1 py35h9852db7_1", + "pycurl 7.43.0 py35h7a9665c_3", + "pyflakes 1.6.0 py35hd1da72e_0", + "pygments 2.2.0 py35h0f41973_0", + "pylint 1.7.4 py35h319e60b_0", + "pyodbc 4.0.17 py35h89a430b_0", + "pyopenssl 17.2.0 py35h1d2a76c_0", + "pyparsing 2.2.0 py35h041ed72_1", + "pyqt 5.6.0 py35h0e41ada_5", + "pysocks 1.6.7 py35h6aefbb0_1", + "pytables 3.4.2 py35hfa98db7_2", + "pytest 3.2.1 py35hc97c719_1", + "python 3.5.4 he2c66cf_20", + "python-dateutil 2.6.1 py35h90d5b31_1", + "pytz 2017.2 py35h9225bff_1", + "pywavelets 0.5.2 py35h53ec731_0", + "pyyaml 3.12 py35h46ef4ae_1", + "pyzmq 16.0.2 py35h4be1f71_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py35hd68ff89_0", + "qtconsole 4.3.1 py35h4626a06_0", + "qtpy 1.3.1 py35h881af26_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py35hb9e6ad1_1", + "rope 0.10.5 py35h31d6b7c_0", + "ruamel_yaml 0.11.14 py35h8e2c16b_2", + "scikit-image 0.13.0 py35h3573165_1", + "scikit-learn 0.19.1 py35hbf1f462_0", + "scipy 0.19.1 py35ha8f041b_3", + "seaborn 0.8.0 py35h15a2772_0", + "setuptools 36.5.0 py35ha8c1747_0", + "simplegeneric 0.8.1 py35h2ec4104_0", + "singledispatch 3.4.0.3 py35h0cd4ec3_0", + "sip 4.18.1 py35h9eaea60_2", + "six 1.11.0 py35h423b573_1", + "snowballstemmer 1.2.1 py35h5435977_0", + "sortedcollections 0.5.3 py35hb2f60ff_0", + "sortedcontainers 1.5.7 py35h683703c_0", + "sphinx 1.6.3 py35hea25a1c_0", + "sphinxcontrib 1.0 py35hcb7efd2_1", + "sphinxcontrib-websupport 1.0.1 py35h3537809_1", + "spyder 3.2.4 py35h27cea69_0", + "sqlalchemy 1.1.13 py35h4911131_0", + "sqlite 3.20.1 h6d8b0f3_1", + "statsmodels 0.8.0 py35haa9d50b_0", + "sympy 1.1.1 py35h919b29a_0", + "tblib 1.3.2 py35hf1eb0b4_0", + "terminado 0.6 py35hce234ed_0", + "testpath 0.3.1 py35had42eaf_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py35h90f1797_0", + "tornado 4.5.2 py35hf879e1d_0", + "traitlets 4.3.2 py35ha522a97_0", + "typing 3.6.2 py35hcadae7e_0", + "unicodecsv 0.14.1 py35h4805c0c_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py35h2ab6e29_0", + "wcwidth 0.1.7 py35hcd08066_0", + "webencodings 0.5.1 py35hb6cf162_1", + "werkzeug 0.12.2 py35hbfc1ea6_0", + "wheel 0.29.0 py35h601ca99_1", + "widgetsnbextension 3.0.2 py35h0be620c_1", + "wrapt 1.10.11 py35hfdafd39_0", + "xlrd 1.1.0 py35h45a0a2a_1", + "xlsxwriter 1.0.2 py35h8ee9321_0", + "xlwt 1.3.0 py35h884a0cf_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.3 py35h29275ca_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "f63722d78e93d9b8587395479a953140", + "name": "anaconda", + "namespace": "python", + "sha256": "c048b9e3cae79aa5091dea15792377e8b6254dfca8b20b5309b53eabbf654530", + "size": 13224, + "subdir": "linux-64", + "timestamp": 1508799451658, + "version": "5.0.1" + }, + "anaconda-5.0.1-py36hd30a520_1.tar.bz2": { + "build": "py36hd30a520_1", + "build_number": 1, + "depends": [ + "alabaster 0.7.10 py36h306e16b_0", + "anaconda-client 1.6.5 py36h19c0dcd_0", + "anaconda-navigator 1.6.9 py36h11ddaaa_0", + "anaconda-project 0.8.0 py36h29abdf5_0", + "asn1crypto 0.22.0 py36h265ca7c_1", + "astroid 1.5.3 py36hbdb9df2_0", + "astropy 2.0.2 py36ha51211e_4", + "babel 2.5.0 py36h7d14adf_0", + "backports 1.0 py36hfa02d7e_1", + "backports.shutil_get_terminal_size 1.0.0 py36hfea85ff_2", + "beautifulsoup4 4.6.0 py36h49b8c8c_1", + "bitarray 0.8.1 py36h5834eb8_0", + "bkcharts 0.2 py36h735825a_0", + "blaze 0.11.3 py36h4e06776_0", + "bleach 2.0.0 py36h688b259_0", + "bokeh 0.12.10 py36hbb0e44a_0", + "boto 2.48.0 py36h6e4cd66_1", + "bottleneck 1.2.1 py36haac1ea0_0", + "bzip2 1.0.6 h0376d23_1", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 haa5651f_5", + "certifi 2017.7.27.1 py36h8b7b77e_0", + "cffi 1.10.0 py36had8d393_1", + "chardet 3.0.4 py36h0f667ec_1", + "click 6.7 py36h5253387_0", + "cloudpickle 0.4.0 py36h30f8c20_0", + "clyent 1.2.2 py36h7e57e65_1", + "colorama 0.3.9 py36h489cec4_0", + "contextlib2 0.5.5 py36h6c84a62_0", + "cryptography 2.0.3 py36ha225213_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py36h93f1223_0", + "cython 0.26.1 py36h21c49d0_0", + "cytoolz 0.8.2 py36h708bfd4_0", + "dask 0.15.3 py36hdc2c8aa_0", + "dask-core 0.15.3 py36h10e6167_0", + "datashape 0.5.4 py36h3ad6b5c_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py36hd076ac8_0", + "distributed 1.19.1 py36h25f3894_0", + "docutils 0.14 py36hb0f60f5_0", + "entrypoints 0.2.3 py36h1aec115_2", + "et_xmlfile 1.0.1 py36hd6bccc3_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py36h5b0c431_0", + "filelock 2.0.12 py36hacfa1f5_0", + "flask 0.12.2 py36hb24657c_0", + "flask-cors 3.0.3 py36h2d857d3_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py36h2fe25dc_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py36h2c1b292_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py36h55090d7_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py36h2d503a6_0", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py36he81ebca_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py36h79797d7_0", + "html5lib 0.999999999 py36h2cfc398_0", + "icu 58.2 h211956c_0", + "idna 2.6 py36h82fb2a8_1", + "imageio 2.2.0 py36he555465_0", + "imagesize 0.7.1 py36h52d8127_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipykernel 4.6.1 py36hbf841aa_0", + "ipython 6.1.0 py36hc72a948_1", + "ipython_genutils 0.2.0 py36hb52b0d5_0", + "ipywidgets 7.0.0 py36h7b55c3a_0", + "isort 4.2.15 py36had401c0_0", + "itsdangerous 0.24 py36h93cc618_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py36h4c697fb_0", + "jedi 0.10.2 py36h552def0_0", + "jinja2 2.9.6 py36h489bce4_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py36h006f8b5_0", + "jupyter 1.0.0 py36h9896ce5_0", + "jupyter_client 5.1.0 py36h614e9ea_0", + "jupyter_console 5.2.0 py36he59e554_1", + "jupyter_core 4.3.0 py36h357a921_0", + "jupyterlab 0.27.0 py36h86377d0_2", + "jupyterlab_launcher 0.4.0 py36h4d8058d_0", + "lazy-object-proxy 1.3.1 py36h10fcdad_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 h7cc24e2_2", + "libgfortran-ng 7.2.0 h9f7466a_2", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h7a57d05_2", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 h84ff03f_3", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py36_0", + "locket 0.2.0 py36h787c0ad_1", + "lxml 4.1.0 py36h5b66e50_0", + "lzo 2.10 h1bfc0ba_1", + "markupsafe 1.0 py36hd9260cd_1", + "matplotlib 2.1.0 py36hba5de38_0", + "mccabe 0.6.1 py36h5ad9710_1", + "mistune 0.7.4 py36hbab8784_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py36h17a0993_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py36h8cc018b_2", + "msgpack-python 0.4.8 py36hec4c5d1_0", + "multipledispatch 0.4.9 py36h41da3fb_0", + "navigator-updater 0.1.0 py36h14770f7_0", + "nbconvert 5.3.1 py36hb41ffb7_0", + "nbformat 4.4.0 py36h31c9010_0", + "ncurses 6.0 h06874d7_1", + "networkx 2.0 py36h7e96fb8_0", + "nltk 3.2.4 py36h1a0979f_0", + "nose 1.3.7 py36hcdf7029_2", + "notebook 5.0.0 py36h0b20546_2", + "numba 0.35.0 np113py36_10", + "numexpr 2.6.2 py36hdd3393f_1", + "numpy 1.13.3 py36ha12f23b_0", + "numpydoc 0.7.0 py36h18f165f_0", + "odo 0.5.1 py36h90ed295_0", + "olefile 0.44 py36h79f9f78_0", + "openpyxl 2.4.8 py36h41dd2a8_1", + "openssl 1.0.2l h077ae2c_5", + "packaging 16.8 py36ha668100_1", + "pandas 0.20.3 py36h842e28d_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py36ha6701b7_1", + "pango 1.40.11 h8191d47_0", + "partd 0.3.8 py36h36fd896_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py36he0c6f6d_0", + "pathlib2 2.3.0 py36h49efa8e_0", + "patsy 0.4.1 py36ha3be15e_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py36h26ade29_0", + "pexpect 4.2.1 py36h3b9d41b_0", + "pickleshare 0.7.4 py36h63277f8_0", + "pillow 4.2.1 py36h9119f52_0", + "pip 9.0.1 py36h8ec8b28_3", + "pixman 0.34.0 h83dc358_2", + "pkginfo 1.4.1 py36h215d178_1", + "ply 3.10 py36hed35086_0", + "prompt_toolkit 1.0.15 py36h17d85b1_0", + "psutil 5.4.0 py36h84c53db_0", + "ptyprocess 0.5.2 py36h69acd42_0", + "py 1.4.34 py36h0712aa3_1", + "pycodestyle 2.3.1 py36hf609f19_0", + "pycosat 0.6.2 py36h1a0ea17_1", + "pycparser 2.18 py36hf9f622e_1", + "pycrypto 2.6.1 py36h6998063_1", + "pycurl 7.43.0 py36h5e72054_3", + "pyflakes 1.6.0 py36h7bd6a15_0", + "pygments 2.2.0 py36h0d3125c_0", + "pylint 1.7.4 py36hb9d4533_0", + "pyodbc 4.0.17 py36h999153c_0", + "pyopenssl 17.2.0 py36h5cc804b_0", + "pyparsing 2.2.0 py36hee85983_1", + "pyqt 5.6.0 py36h0386399_5", + "pysocks 1.6.7 py36hd97a5b1_1", + "pytables 3.4.2 py36h3b5282a_2", + "pytest 3.2.1 py36h11ad3bb_1", + "python 3.6.3 hc9025b9_1", + "python-dateutil 2.6.1 py36h88d3b88_1", + "pytz 2017.2 py36hc2ccc2a_1", + "pywavelets 0.5.2 py36he602eb0_0", + "pyyaml 3.12 py36hafb9ca4_1", + "pyzmq 16.0.2 py36h3b0cf96_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py36h609ed8c_0", + "qtconsole 4.3.1 py36h8f73b5b_0", + "qtpy 1.3.1 py36h3691cc8_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py36he2e5f8d_1", + "rope 0.10.5 py36h1f8c17e_0", + "ruamel_yaml 0.11.14 py36ha2fb22d_2", + "scikit-image 0.13.0 py36had3c07a_1", + "scikit-learn 0.19.1 py36h7aa7ec6_0", + "scipy 0.19.1 py36h9976243_3", + "seaborn 0.8.0 py36h197244f_0", + "setuptools 36.5.0 py36he42e2e1_0", + "simplegeneric 0.8.1 py36h2cb9092_0", + "singledispatch 3.4.0.3 py36h7a266c3_0", + "sip 4.18.1 py36h51ed4ed_2", + "six 1.11.0 py36h372c433_1", + "snowballstemmer 1.2.1 py36h6febd40_0", + "sortedcollections 0.5.3 py36h3c761f9_0", + "sortedcontainers 1.5.7 py36hdf89491_0", + "sphinx 1.6.3 py36he5f0bdb_0", + "sphinxcontrib 1.0 py36h6d0f590_1", + "sphinxcontrib-websupport 1.0.1 py36hb5cb234_1", + "spyder 3.2.4 py36hbe6152b_0", + "sqlalchemy 1.1.13 py36hfb5efd7_0", + "sqlite 3.20.1 h6d8b0f3_1", + "statsmodels 0.8.0 py36h8533d0b_0", + "sympy 1.1.1 py36hc6d1c1c_0", + "tblib 1.3.2 py36h34cf8b6_0", + "terminado 0.6 py36ha25a19f_0", + "testpath 0.3.1 py36h8cadb63_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py36h81f2dff_0", + "tornado 4.5.2 py36h1283b2a_0", + "traitlets 4.3.2 py36h674d592_0", + "typing 3.6.2 py36h7da032a_0", + "unicodecsv 0.14.1 py36ha668878_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py36hbe7ace6_0", + "wcwidth 0.1.7 py36hdf4376a_0", + "webencodings 0.5.1 py36h800622e_1", + "werkzeug 0.12.2 py36hc703753_0", + "wheel 0.29.0 py36he7f4e38_1", + "widgetsnbextension 3.0.2 py36hd01bb71_1", + "wrapt 1.10.11 py36h28b7045_0", + "xlrd 1.1.0 py36h1db9f0c_1", + "xlsxwriter 1.0.2 py36h3de1aca_0", + "xlwt 1.3.0 py36h7b00a1f_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.3 py36h3a3bf81_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "4d20be236e8a7212f4b11437c3483394", + "name": "anaconda", + "namespace": "python", + "sha256": "e3a42020579b119817c010f568716b9af16cd9ea58fe9be6fecb266bb7d4eaae", + "size": 13086, + "subdir": "linux-64", + "timestamp": 1508799487342, + "version": "5.0.1" + }, + "anaconda-5.1.0-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "et_xmlfile 1.0.1 py27h75840f5_0", + "jbig 2.1 hdba287a_0", + "qt 5.6.2 h974d657_12", + "expat 2.2.5 he0dffb1_0", + "sqlite 3.22.0 h1bed415_0", + "simplegeneric 0.8.1 py27_2", + "ptyprocess 0.5.2 py27h4ccb14c_0", + "pytz 2017.3 py27h001bace_0", + "jinja2 2.10 py27h4114e70_0", + "libedit 3.1 heed3624_0", + "rope 0.10.7 py27hfe459b0_0", + "gst-plugins-base 1.12.4 h33fb286_0", + "boto 2.48.0 py27h9556ac2_1", + "pixman >=0.34.0,<1.0a0", + "libxml2 >=2.9.7,<2.10.0a0", + "pandas 0.22.0 py27hf484d3e_0", + "qtconsole 4.3.1 py27hc444b0d_0", + "gstreamer >=1.12.4,<1.13.0a0", + "seaborn 0.8.1 py27h633ea1e_0", + "flask 0.12.2 py27h6d5c1cd_0", + "pysocks 1.6.7 py27he2db6d2_1", + "backports 1.0 py27h63c9359_1", + "pytest 3.3.2 py27_0", + "distributed 1.20.2 py27_0", + "pyzmq 16.0.3 py27hc579512_0", + "xlrd 1.1.0 py27ha77178f_1", + "pathlib2 2.3.0 py27h6e9d198_0", + "flask-cors 3.0.3 py27h1a8a27f_0", + "pyodbc 4.0.22 py27hf484d3e_0", + "matplotlib 2.1.2 py27h0e671d2_0", + "ncurses >=6.0,<7.0a0", + "zlib >=1.2.11,<1.3.0a0", + "mccabe 0.6.1 py27h0e7c7be_1", + "entrypoints 0.2.3 py27h502b47d_2", + "ssl_match_hostname 3.5.0.1 py27h4ec10b9_2", + "ruamel_yaml 0.15.35 py27h14c3975_1", + "lzo >=2.10,<3.0a0", + "certifi 2018.1.18 py27_0", + "freetype 2.8 hab7d2ae_1", + "openssl 1.0.2n hb7f436b_0", + "prompt_toolkit 1.0.15 py27h1b593e1_0", + "pycodestyle 2.3.1 py27h904819d_0", + "jpeg 9b h024ee3a_2", + "dask 0.16.1 py27_0", + "pluggy 0.6.0 py27h1f4f128_0", + "xz >=5.2.3,<6.0a0", + "libpng >=1.6.34,<1.7.0a0", + "h5py 2.7.1 py27h2697762_0", + "gmp 6.1.2 h6c8ec71_1", + "libtiff >=4.0.9,<5.0a0", + "libpng 1.6.34 hb9fc6fc_0", + "datashape 0.5.4 py27hf507385_0", + "jdcal 1.3 py27h2cc5433_0", + "graphite2 1.3.10 hf63cedd_1", + "python 2.7.14 h1571d57_29", + "functools32 3.2.3.2 py27h4ead58f_1", + "wheel 0.30.0 py27h2bc6bb2_1", + "cdecimal 2.3 py27h14c3975_3", + "scandir 1.6 py27hf7388dc_0", + "urllib3 1.22 py27ha55213b_0", + "jupyter_core 4.4.0 py27h345911c_0", + "pyqt 5.6.0 py27h4b1e83c_5", + "bzip2 1.0.6 h9a117a8_4", + "pylint 1.8.2 py27_0", + "expat >=2.2.5,<3.0a0", + "bottleneck 1.2.1 py27h21b16a3_0", + "bzip2 >=1.0.6,<2.0a0", + "pycurl 7.43.0.1 py27hb7f436b_0", + "libssh2 >=1.8.0,<2.0a0", + "mpmath 1.0.0 py27h9669132_2", + "beautifulsoup4 4.6.0 py27h3f86ba9_1", + "glib 2.53.6 h5d9569c_2", + "readline 7.0 ha6073c6_4", + "ipykernel 4.8.0 py27_0", + "ipython 5.4.1 py27_2", + "clyent 1.2.2 py27h7276e6c_1", + "isort 4.2.15 py27hcfa4749_0", + "packaging 16.8 py27h5e07c7c_1", + "traitlets 4.3.2 py27hd6ce930_0", + "tornado 4.5.3 py27_0", + "olefile 0.45.1 py27_0", + "pillow 5.0.0 py27h3deb7b8_0", + "greenlet 0.4.12 py27hac09c53_0", + "itsdangerous 0.24 py27hb8295c1_1", + "scikit-image 0.13.1 py27h14c3975_1", + "psutil 5.4.3 py27h14c3975_0", + "dbus 1.12.2 hc3f9b76_1", + "idna 2.6 py27h5722d68_1", + "yaml 0.1.7 had09818_2", + "scikit-learn 0.19.1 py27h445a80a_0", + "pycparser 2.18 py27hefa08c5_1", + "ply 3.10 py27hd6d9ae5_0", + "snowballstemmer 1.2.1 py27h44e2768_0", + "xlwt 1.3.0 py27h3d85d97_0", + "bkcharts 0.2 py27h241ae91_0", + "lzo 2.10 h49e0be7_2", + "pip 9.0.1 py27ha730c48_4", + "jsonschema 2.6.0 py27h7ed5aa4_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "toolz 0.9.0 py27_0", + "pyflakes 1.6.0 py27h904a57d_0", + "bleach 2.1.2 py27_0", + "six 1.11.0 py27h5f960f1_1", + "zict 0.1.3 py27h12c336c_0", + "openssl >=1.0.2n,<1.0.3a", + "markupsafe 1.0 py27h97b2822_1", + "jupyter_client 5.2.2 py27_0", + "bitarray 0.8.1 py27h14c3975_1", + "sympy 1.1.1 py27hc28188a_0", + "sphinxcontrib-websupport 1.0.1 py27hf906f22_1", + "libstdcxx-ng 7.2.0 h7a57d05_2", + "libffi >=3.2.1,<3.3a0", + "notebook 5.4.0 py27_0", + "testpath 0.3.1 py27hc38d2c4_0", + "harfbuzz >=1.7.4,<2.0a0", + "babel 2.5.3 py27_0", + "wcwidth 0.1.7 py27h9e3e1ab_0", + "xlsxwriter 1.0.2 py27h12cbc6b_0", + "cairo >=1.14.12,<2.0a0", + "mistune 0.8.3 py27_0", + "networkx 2.1 py27_0", + "pickleshare 0.7.4 py27h09770e1_0", + "unixodbc 2.3.4 hc36303a_1", + "pywavelets 0.5.2 py27hecda097_0", + "futures 3.2.0 py27h7b459c0_0", + "numpy 1.14.0 py27h3dfced4_1", + "nose 1.3.7 py27heec2199_2", + "zeromq 4.2.2 hbedb6e5_2", + "setuptools 38.4.0 py27_0", + "patsy 0.5.0 py27_0", + "fontconfig 2.12.4 h88586e7_1", + "gevent 1.2.2 py27h475ea6a_0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "colorama 0.3.9 py27h5cde069_0", + "jpeg >=9b,<10a", + "libxcb >=1.12,<2.0a0", + "python-dateutil 2.6.1 py27h4ca5741_1", + "nltk 3.2.5 py27hec5f4de_0", + "bokeh 0.12.13 py27h5233db4_0", + "sphinx 1.6.6 py27_0", + "llvmlite 0.21.0 py27h6dad3f9_0", + "asn1crypto 0.24.0 py27_0", + "qtpy 1.3.1 py27h63d3751_0", + "pkginfo 1.4.1 py27hee1a9ad_1", + "heapdict 1.0.0 py27_2", + "cairo 1.14.12 h77bcde2_0", + "cytoolz 0.9.0 py27h14c3975_0", + "wrapt 1.10.11 py27h04f6869_0", + "chardet 3.0.4 py27hfa10054_1", + "blaze 0.11.3 py27h5f341da_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "libffi 3.2.1 hd88cf55_4", + "decorator 4.2.1 py27_0", + "libcurl 7.58.0 h1ad7b7a_0", + "grin 1.2.1 py27_4", + "pyyaml 3.12 py27h2d70dd7_1", + "gmpy2 2.0.8 py27h4cf3fa8_2", + "intel-openmp 2018.0.0 hc7b2577_8", + "pycairo 1.15.4 py27h1b9232e_1", + "harfbuzz 1.7.4 hc5b324e_0", + "tblib 1.3.2 py27h51fe5ba_0", + "ncurses 6.0 h9df7e31_2", + "py 1.5.2 py27h203d672_0", + "pango >=1.41.0,<2.0a0", + "gstreamer 1.12.4 hb53b477_0", + "spyder 3.2.6 py27_0", + "openpyxl 2.4.10 py27_0", + "pep8 1.7.1 py27_0", + "icu 58.2 h9c2bf20_1", + "cython 0.27.3 py27hc56b35e_0", + "mpfr 3.1.5 h11a74b3_2", + "libxslt 1.1.32 h1312cb7_0", + "dbus >=1.12.2,<2.0a0", + "numba 0.36.2 np114py27he2868da_0", + "odo 0.5.1 py27h9170de3_0", + "docutils 0.14 py27hae222c1_0", + "terminado 0.8.1 py27_1", + "msgpack-python 0.5.1 py27h6bb024c_0", + "backports.shutil_get_terminal_size 1.0.0 py27h5bc021e_2", + "fontconfig >=2.12.4,<3.0a0", + "jupyter 1.0.0 py27_4", + "sortedcontainers 1.5.9 py27_0", + "backports.functools_lru_cache 1.4 py27he8db605_1", + "pcre 8.41 hc27e229_1", + "mpc 1.0.3 hec55b23_5", + "tk 8.6.7 hc745277_3", + "lxml 4.1.1 py27hf71bdeb_1", + "freetype >=2.8,<2.9.0a0", + "tk >=8.6.7,<8.7.0a0", + "ipython_genutils 0.2.0 py27h89fb69b_0", + "pycosat 0.6.3 py27ha4109ae_0", + "pexpect 4.3.1 py27_0", + "anaconda-client 1.6.9 py27_0", + "imageio 2.2.0 py27hf108a7f_0", + "send2trash 1.4.2 py27_0", + "nbformat 4.4.0 py27hed7f2b2_0", + "numexpr 2.6.4 py27hd318778_0", + "enum34 1.1.6 py27h99a27e9_1", + "ipaddress 1.0.19 py27_0", + "libxslt >=1.1.32,<2.0a0", + "multipledispatch 0.4.9 py27h9b5f95a_0", + "yaml >=0.1.7,<0.2.0a0", + "pandocfilters 1.4.2 py27h428e1e5_1", + "contextlib2 0.5.5 py27hbf4c468_0", + "pygments 2.2.0 py27h4a8b6f5_0", + "click 6.7 py27h4225b90_0", + "nbconvert 5.3.1 py27he041f76_0", + "jupyter_console 5.2.0 py27hc6bee7e_1", + "cffi 1.11.4 py27h9745a5d_0", + "pyparsing 2.2.0 py27hf1513f8_1", + "subprocess32 3.2.7 py27h373dbce_0", + "sortedcollections 0.5.3 py27h135218e_0", + "anaconda-project 0.8.2 py27h236b58a_0", + "lazy-object-proxy 1.3.1 py27h682c727_0", + "libgcc-ng 7.2.0 h7cc24e2_2", + "html5lib 1.0.1 py27h5233db4_0", + "curl 7.58.0 h84994c4_0", + "filelock 2.0.13 py27h61a9c69_0", + "libtiff 4.0.9 h28f6b97_0", + "sphinxcontrib 1.0 py27h1512b58_1", + "pyopenssl 17.5.0 py27hcee3be0_0", + "pycrypto 2.6.1 py27h14c3975_7", + "cycler 0.10.0 py27hc7354d3_0", + "mkl-service 1.1.2 py27hb2d42c5_4", + "dask-core 0.16.1 py27_0", + "sqlite >=3.22.0,<4.0a0", + "cloudpickle 0.5.2 py27_1", + "cryptography 2.1.4 py27h6697b16_0", + "sqlalchemy 1.2.1 py27h14c3975_0", + "qtawesome 0.4.4 py27hd7914c3_0", + "libsodium 1.0.15 hf101ebd_0", + "parso 0.1.1 py27h718acc2_0", + "libxml2 2.9.7 h26e45fe_0", + "astropy 2.0.3 py27h14c3975_0", + "scipy 1.0.0 py27hf5f0f52_0", + "astroid 1.6.1 py27_0", + "fastcache 1.0.2 py27h14c3975_2", + "pango 1.41.0 hd475d92_0", + "partd 0.3.8 py27h4e55004_0", + "pytables 3.4.2 py27h1f7bffc_2", + "graphite2 >=1.3.10,<2.0a0", + "singledispatch 3.4.0.3 py27h9bcb476_0", + "attrs 17.4.0 py27_0", + "glob2 0.6 py27hcea9cbd_0", + "locket 0.2.0 py27h73929a2_1", + "patchelf 0.9 hf79760b_2", + "werkzeug 0.14.1 py27_0", + "numpydoc 0.7.0 py27h9647a75_0", + "libxcb 1.12 hcd93eb1_4", + "libssh2 1.8.0 h9cfc8f7_4", + "zlib 1.2.11 ha838bed_2", + "requests 2.18.4 py27hc5b0589_1", + "typing 3.6.2 py27h66f49e2_0", + "mkl 2018.0.1 h19d6760_4", + "imagesize 0.7.1 py27hd17bf80_0", + "pixman 0.34.0 hceecf20_3", + "gmp >=6.1.2", + "sip 4.18.1 py27he9ba0ab_2", + "icu >=58.2,<59.0a0", + "jupyterlab 0.31.5 py27_0", + "webencodings 0.5.1 py27hff10b21_1", + "path.py 10.5 py27hefe4bee_0", + "libcurl >=7.58.0,<8.0a0", + "alabaster 0.7.10 py27he5a193a_0", + "configparser 3.5.0 py27h5117587_0", + "glib >=2.53.6,<3.0a0", + "get_terminal_size 1.0.0 haa9412d_0", + "gst-plugins-base >=1.12.4,<1.13.0a0", + "libgfortran-ng 7.2.0 h9f7466a_2", + "libtool 2.4.6 h544aabb_3", + "xz 5.2.3 h55aa19d_2", + "hdf5 1.10.1 h9caa474_1", + "jedi 0.11.1 py27_0", + "unicodecsv 0.14.1 py27h5062da9_0", + "widgetsnbextension 3.1.0 py27_0", + "funcsigs 1.0.2 py27h83f16ab_0", + "jupyterlab_launcher 0.10.2 py27_0", + "readline >=7.0,<8.0a0", + "backports_abc 0.5 py27h7b3c97b_0", + "ipywidgets 7.1.1 py27_0", + "statsmodels 0.8.0 py27hc87d62d_0" + ], + "license": "BSD", + "md5": "efac53847b74879f5f51d9262e229221", + "name": "anaconda", + "namespace": "python", + "sha256": "89e22945c1d4609ea37e115cee69403850585f8d3ac4c1828a780a83954750ca", + "size": 13049, + "subdir": "linux-64", + "timestamp": 1518523519130, + "version": "5.1.0" + }, + "anaconda-5.1.0-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "lxml 4.1.1 py35hf71bdeb_1", + "patchelf 0.9 hf79760b_2", + "bitarray 0.8.1 py35h14c3975_1", + "libpng 1.6.34 hb9fc6fc_0", + "gmp 6.1.2 h6c8ec71_1", + "libtiff >=4.0.9,<5.0a0", + "qtawesome 0.4.4 py35hd68ff89_0", + "pango >=1.41.0,<2.0a0", + "blaze 0.11.3 py35ha2c9137_0", + "pygments 2.2.0 py35h0f41973_0", + "gstreamer >=1.12.4,<1.13.0a0", + "statsmodels 0.8.0 py35haa9d50b_0", + "jupyter 1.0.0 py35_4", + "jbig 2.1 hdba287a_0", + "libxcb >=1.12,<2.0a0", + "pylint 1.8.2 py35_0", + "pandas 0.22.0 py35hf484d3e_0", + "pip 9.0.1 py35h7e7da9d_4", + "libxcb 1.12 hcd93eb1_4", + "h5py 2.7.1 py35h8d53cdc_0", + "requests 2.18.4 py35hb9e6ad1_1", + "jpeg 9b h024ee3a_2", + "libssh2 1.8.0 h9cfc8f7_4", + "ply 3.10 py35h459f1a0_0", + "sympy 1.1.1 py35h919b29a_0", + "freetype 2.8 hab7d2ae_1", + "jupyter_console 5.2.0 py35h4044a63_1", + "boto 2.48.0 py35h2cfd601_1", + "lazy-object-proxy 1.3.1 py35h4c720c6_0", + "pyopenssl 17.5.0 py35h4f8b8c8_0", + "xz 5.2.3 h55aa19d_2", + "bleach 2.1.2 py35_0", + "pluggy 0.6.0 py35hb428803_0", + "pycparser 2.18 py35h61b3040_1", + "toolz 0.9.0 py35_0", + "contextlib2 0.5.5 py35h6690dba_0", + "dask 0.16.1 py35_0", + "libstdcxx-ng 7.2.0 h7a57d05_2", + "expat >=2.2.5,<3.0a0", + "packaging 16.8 py35h2260b46_1", + "qtconsole 4.3.1 py35h4626a06_0", + "mistune 0.8.3 py35_0", + "libxml2 >=2.9.7,<2.10.0a0", + "gmpy2 2.0.8 py35hd0a1c9a_2", + "harfbuzz 1.7.4 hc5b324e_0", + "fontconfig >=2.12.4,<3.0a0", + "bzip2 1.0.6 h9a117a8_4", + "jupyterlab_launcher 0.10.2 py35_0", + "six 1.11.0 py35h423b573_1", + "cycler 0.10.0 py35hc4d5149_0", + "idna 2.6 py35h8605a33_1", + "mpmath 1.0.0 py35h7ce6e34_2", + "sip 4.18.1 py35h9eaea60_2", + "gevent 1.2.2 py35he064abf_0", + "libffi >=3.2.1,<3.3a0", + "numpy 1.14.0 py35h3dfced4_1", + "python-dateutil 2.6.1 py35h90d5b31_1", + "pango 1.41.0 hd475d92_0", + "wheel 0.30.0 py35hd3883cf_1", + "unicodecsv 0.14.1 py35h4805c0c_0", + "zlib 1.2.11 ha838bed_2", + "pycodestyle 2.3.1 py35h8d2105a_0", + "et_xmlfile 1.0.1 py35hde8d43e_0", + "html5lib 1.0.1 py35h2f9c1c0_0", + "markupsafe 1.0 py35h4f4fcf6_1", + "decorator 4.2.1 py35_0", + "wrapt 1.10.11 py35hfdafd39_0", + "numba 0.36.2 np114py35ha126a20_0", + "parso 0.1.1 py35h1b200a3_0", + "ptyprocess 0.5.2 py35h38ce0a3_0", + "glib >=2.53.6,<3.0a0", + "xlrd 1.1.0 py35h45a0a2a_1", + "glib 2.53.6 h5d9569c_2", + "sqlite 3.22.0 h1bed415_0", + "tk >=8.6.7,<8.7.0a0", + "python 3.5.4 h417fded_24", + "pyflakes 1.6.0 py35hd1da72e_0", + "zict 0.1.3 py35h29275ca_0", + "prompt_toolkit 1.0.15 py35hc09de7a_0", + "pywavelets 0.5.2 py35h53ec731_0", + "astroid 1.6.1 py35_0", + "ipython_genutils 0.2.0 py35hc9e07d0_0", + "jpeg >=9b,<10a", + "certifi 2018.1.18 py35_0", + "asn1crypto 0.24.0 py35_0", + "cython 0.27.3 py35h6cdc64b_0", + "zlib >=1.2.11,<1.3.0a0", + "colorama 0.3.9 py35h81e2b6c_0", + "bkcharts 0.2 py35he4f7e30_0", + "hdf5 1.10.1 h9caa474_1", + "distributed 1.20.2 py35_0", + "libffi 3.2.1 hd88cf55_4", + "nbformat 4.4.0 py35h12e6e07_0", + "partd 0.3.8 py35h68187f2_0", + "chardet 3.0.4 py35hb6e9ddf_1", + "pycurl 7.43.0.1 py35hb7f436b_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "imageio 2.2.0 py35hd0a6de2_0", + "gst-plugins-base 1.12.4 h33fb286_0", + "curl 7.58.0 h84994c4_0", + "sphinxcontrib 1.0 py35hcb7efd2_1", + "cloudpickle 0.5.2 py35_1", + "anaconda-project 0.8.2 py35h7d62c80_0", + "cryptography 2.1.4 py35hbeb2da1_0", + "lzo >=2.10,<3.0a0", + "sqlalchemy 1.2.1 py35h14c3975_0", + "freetype >=2.8,<2.9.0a0", + "libgfortran-ng 7.2.0 h9f7466a_2", + "attrs 17.4.0 py35_0", + "networkx 2.1 py35_0", + "isort 4.2.15 py35h44a00d2_0", + "snowballstemmer 1.2.1 py35h5435977_0", + "nose 1.3.7 py35hdc64897_2", + "filelock 2.0.13 py35h4160c53_0", + "simplegeneric 0.8.1 py35_2", + "expat 2.2.5 he0dffb1_0", + "rope 0.10.7 py35h986144c_0", + "lzo 2.10 h49e0be7_2", + "dbus >=1.12.2,<2.0a0", + "jsonschema 2.6.0 py35h4395190_0", + "mkl-service 1.1.2 py35h0fc7090_4", + "backports.shutil_get_terminal_size 1.0.0 py35h40844db_2", + "py 1.5.2 py35hfe8c5ce_0", + "openssl >=1.0.2n,<1.0.3a", + "flask-cors 3.0.3 py35h9b2065d_0", + "bokeh 0.12.13 py35h2f9c1c0_0", + "pixman 0.34.0 hceecf20_3", + "seaborn 0.8.1 py35h04cba02_0", + "itsdangerous 0.24 py35h7c46880_1", + "dask-core 0.16.1 py35_0", + "send2trash 1.4.2 py35_0", + "pathlib2 2.3.0 py35hd637de4_0", + "heapdict 1.0.0 py35_2", + "odo 0.5.1 py35h102315f_0", + "pycrypto 2.6.1 py35h14c3975_7", + "yaml >=0.1.7,<0.2.0a0", + "graphite2 >=1.3.10,<2.0a0", + "bottleneck 1.2.1 py35he1b16f1_0", + "pcre 8.41 hc27e229_1", + "pandoc 1.19.2.1 hea2e7c5_1", + "ipywidgets 7.1.1 py35_0", + "ruamel_yaml 0.15.35 py35h14c3975_1", + "multipledispatch 0.4.9 py35h2ff591a_0", + "pyparsing 2.2.0 py35h041ed72_1", + "clyent 1.2.2 py35h491ffcb_1", + "libpng >=1.6.34,<1.7.0a0", + "typing 3.6.2 py35hcadae7e_0", + "mpfr 3.1.5 h11a74b3_2", + "get_terminal_size 1.0.0 haa9412d_0", + "libxml2 2.9.7 h26e45fe_0", + "libtool 2.4.6 h544aabb_3", + "glob2 0.6 py35hff66265_0", + "numexpr 2.6.4 py35h119f745_0", + "greenlet 0.4.12 py35h2547b41_0", + "testpath 0.3.1 py35had42eaf_0", + "traitlets 4.3.2 py35ha522a97_0", + "openpyxl 2.4.10 py35_0", + "mpc 1.0.3 hec55b23_5", + "cairo >=1.14.12,<2.0a0", + "pyodbc 4.0.22 py35hf484d3e_0", + "werkzeug 0.14.1 py35_0", + "ncurses >=6.0,<7.0a0", + "click 6.7 py35h353a69f_0", + "pandocfilters 1.4.2 py35h1565a15_1", + "pyzmq 16.0.3 py35ha889422_0", + "singledispatch 3.4.0.3 py35h0cd4ec3_0", + "pycosat 0.6.3 py35h6b6bb97_0", + "graphite2 1.3.10 hf63cedd_1", + "intel-openmp 2018.0.0 hc7b2577_8", + "scikit-image 0.13.1 py35h14c3975_1", + "libssh2 >=1.8.0,<2.0a0", + "setuptools 38.4.0 py35_0", + "jupyterlab 0.31.5 py35_0", + "fontconfig 2.12.4 h88586e7_1", + "qtpy 1.3.1 py35h881af26_0", + "readline 7.0 ha6073c6_4", + "libxslt 1.1.32 h1312cb7_0", + "dbus 1.12.2 hc3f9b76_1", + "cytoolz 0.9.0 py35h14c3975_0", + "numpydoc 0.7.0 py35he089a57_0", + "astropy 2.0.3 py35h14c3975_0", + "ipykernel 4.8.0 py35_0", + "imagesize 0.7.1 py35hf008fae_0", + "psutil 5.4.3 py35h14c3975_0", + "pytables 3.4.2 py35hfa98db7_2", + "spyder 3.2.6 py35_0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "datashape 0.5.4 py35h5b068ae_0", + "babel 2.5.3 py35_0", + "anaconda-client 1.6.9 py35_0", + "pickleshare 0.7.4 py35hd57304d_0", + "path.py 10.5 py35h39c98c1_0", + "xz >=5.2.3,<6.0a0", + "tblib 1.3.2 py35hf1eb0b4_0", + "libcurl 7.58.0 h1ad7b7a_0", + "pillow 5.0.0 py35h3deb7b8_0", + "urllib3 1.22 py35h2ab6e29_0", + "icu >=58.2,<59.0a0", + "libsodium 1.0.15 hf101ebd_0", + "nbconvert 5.3.1 py35hc5194e3_0", + "patsy 0.5.0 py35_0", + "pixman >=0.34.0,<1.0a0", + "readline >=7.0,<8.0a0", + "openssl 1.0.2n hb7f436b_0", + "harfbuzz >=1.7.4,<2.0a0", + "pytz 2017.3 py35hb13c558_0", + "pep8 1.7.1 py35_0", + "jupyter_core 4.4.0 py35ha89e94b_0", + "mccabe 0.6.1 py35hd8c1f23_1", + "cairo 1.14.12 h77bcde2_0", + "pytest 3.3.2 py35_0", + "beautifulsoup4 4.6.0 py35h442a8c9_1", + "jinja2 2.10 py35h480ab6d_0", + "flask 0.12.2 py35h679e90e_0", + "pkginfo 1.4.1 py35hb526c55_1", + "notebook 5.4.0 py35_0", + "msgpack-python 0.5.1 py35h6bb024c_0", + "gst-plugins-base >=1.12.4,<1.13.0a0", + "cffi 1.11.4 py35h9745a5d_0", + "scipy 1.0.0 py35hcbbe4a2_0", + "bzip2 >=1.0.6,<2.0a0", + "sortedcollections 0.5.3 py35hb2f60ff_0", + "fastcache 1.0.2 py35h14c3975_2", + "matplotlib 2.1.2 py35h0e671d2_0", + "tk 8.6.7 hc745277_3", + "terminado 0.8.1 py35_1", + "ncurses 6.0 h9df7e31_2", + "gstreamer 1.12.4 hb53b477_0", + "unixodbc 2.3.4 hc36303a_1", + "webencodings 0.5.1 py35hb6cf162_1", + "nltk 3.2.5 py35h09ad193_0", + "sqlite >=3.22.0,<4.0a0", + "libxslt >=1.1.32,<2.0a0", + "jupyter_client 5.2.2 py35_0", + "gmp >=6.1.2", + "icu 58.2 h9c2bf20_1", + "scikit-learn 0.19.1 py35hbf1f462_0", + "sphinxcontrib-websupport 1.0.1 py35h3537809_1", + "libcurl >=7.58.0,<8.0a0", + "locket 0.2.0 py35h170bc82_1", + "mkl 2018.0.1 h19d6760_4", + "jdcal 1.3 py35hf1f7175_0", + "entrypoints 0.2.3 py35h48174a2_2", + "xlsxwriter 1.0.2 py35h8ee9321_0", + "sortedcontainers 1.5.9 py35_0", + "ipython 6.2.1 py35hd850d2a_1", + "widgetsnbextension 3.1.0 py35_0", + "pyyaml 3.12 py35h46ef4ae_1", + "backports 1.0 py35hd471ac7_1", + "pexpect 4.3.1 py35_0", + "xlwt 1.3.0 py35h884a0cf_0", + "yaml 0.1.7 had09818_2", + "qt 5.6.2 h974d657_12", + "pyqt 5.6.0 py35h0e41ada_5", + "olefile 0.45.1 py35_0", + "llvmlite 0.21.0 py35hcfd7307_0", + "wcwidth 0.1.7 py35hcd08066_0", + "docutils 0.14 py35hd11081d_0", + "libedit 3.1 heed3624_0", + "tornado 4.5.3 py35_0", + "sphinx 1.6.6 py35_0", + "alabaster 0.7.10 py35h6fb19ab_0", + "libgcc-ng 7.2.0 h7cc24e2_2", + "pysocks 1.6.7 py35h6aefbb0_1", + "zeromq 4.2.2 hbedb6e5_2", + "jedi 0.11.1 py35_0", + "libtiff 4.0.9 h28f6b97_0" + ], + "license": "BSD", + "md5": "b81761648df68110c72ba116e938bed6", + "name": "anaconda", + "namespace": "python", + "sha256": "e6f636366ee4f1ae34a8dd7e94fd6a4e6d2407d33e4082cf5b76d937a90f13ae", + "size": 12645, + "subdir": "linux-64", + "timestamp": 1518523630663, + "version": "5.1.0" + }, + "anaconda-5.1.0-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "jupyterlab_launcher 0.10.2 py36_0", + "mccabe 0.6.1 py36h5ad9710_1", + "bottleneck 1.2.1 py36haac1ea0_0", + "spyder 3.2.6 py36_0", + "numexpr 2.6.4 py36hc4a3f9a_0", + "pep8 1.7.1 py36_0", + "flask 0.12.2 py36hb24657c_0", + "beautifulsoup4 4.6.0 py36h49b8c8c_1", + "cryptography 2.1.4 py36hd09be54_0", + "pixman >=0.34.0,<1.0a0", + "expat 2.2.5 he0dffb1_0", + "qtconsole 4.3.1 py36h8f73b5b_0", + "libtool 2.4.6 h544aabb_3", + "dask 0.16.1 py36_0", + "libcurl >=7.58.0,<8.0a0", + "jupyter_core 4.4.0 py36h7c827e3_0", + "pyzmq 16.0.3 py36he2533c7_0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "send2trash 1.4.2 py36_0", + "sortedcollections 0.5.3 py36h3c761f9_0", + "glob2 0.6 py36he249c77_0", + "py 1.5.2 py36h29bf505_0", + "pluggy 0.6.0 py36hb689045_0", + "fontconfig >=2.12.4,<3.0a0", + "qtpy 1.3.1 py36h3691cc8_0", + "sqlite >=3.22.0,<4.0a0", + "locket 0.2.0 py36h787c0ad_1", + "scikit-learn 0.19.1 py36h7aa7ec6_0", + "lazy-object-proxy 1.3.1 py36h10fcdad_0", + "html5lib 1.0.1 py36h2f9c1c0_0", + "gmpy2 2.0.8 py36hc8893dd_2", + "cython 0.27.3 py36h1860423_0", + "bkcharts 0.2 py36h735825a_0", + "msgpack-python 0.5.1 py36h6bb024c_0", + "backports.shutil_get_terminal_size 1.0.0 py36hfea85ff_2", + "pixman 0.34.0 hceecf20_3", + "pango >=1.41.0,<2.0a0", + "partd 0.3.8 py36h36fd896_0", + "harfbuzz 1.7.4 hc5b324e_0", + "python-dateutil 2.6.1 py36h88d3b88_1", + "pip 9.0.1 py36h6c6f9ce_4", + "networkx 2.1 py36_0", + "libxslt 1.1.32 h1312cb7_0", + "tk 8.6.7 hc745277_3", + "scikit-image 0.13.1 py36h14c3975_1", + "bzip2 1.0.6 h9a117a8_4", + "pylint 1.8.2 py36_0", + "tk >=8.6.7,<8.7.0a0", + "wcwidth 0.1.7 py36hdf4376a_0", + "pywavelets 0.5.2 py36he602eb0_0", + "docutils 0.14 py36hb0f60f5_0", + "colorama 0.3.9 py36h489cec4_0", + "cycler 0.10.0 py36h93f1223_0", + "parso 0.1.1 py36h35f843b_0", + "cytoolz 0.9.0 py36h14c3975_0", + "gst-plugins-base >=1.12.4,<1.13.0a0", + "odo 0.5.1 py36h90ed295_0", + "contextlib2 0.5.5 py36h6c84a62_0", + "testpath 0.3.1 py36h8cadb63_0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "pycosat 0.6.3 py36h0a5515d_0", + "ply 3.10 py36hed35086_0", + "mpfr 3.1.5 h11a74b3_2", + "wrapt 1.10.11 py36h28b7045_0", + "xz 5.2.3 h55aa19d_2", + "markupsafe 1.0 py36hd9260cd_1", + "graphite2 1.3.10 hf63cedd_1", + "heapdict 1.0.0 py36_2", + "prompt_toolkit 1.0.15 py36h17d85b1_0", + "scipy 1.0.0 py36hbf646e7_0", + "numpydoc 0.7.0 py36h18f165f_0", + "certifi 2018.1.18 py36_0", + "bzip2 >=1.0.6,<2.0a0", + "ruamel_yaml 0.15.35 py36h14c3975_1", + "attrs 17.4.0 py36_0", + "cairo >=1.14.12,<2.0a0", + "jdcal 1.3 py36h4c697fb_0", + "mpmath 1.0.0 py36hfeacd6b_2", + "curl 7.58.0 h84994c4_0", + "expat >=2.2.5,<3.0a0", + "xlsxwriter 1.0.2 py36h3de1aca_0", + "zlib 1.2.11 ha838bed_2", + "imagesize 0.7.1 py36h52d8127_0", + "anaconda-project 0.8.2 py36h44fb852_0", + "libxml2 2.9.7 h26e45fe_0", + "nltk 3.2.5 py36h7532b22_0", + "terminado 0.8.1 py36_1", + "qt 5.6.2 h974d657_12", + "pickleshare 0.7.4 py36h63277f8_0", + "lxml 4.1.1 py36hf71bdeb_1", + "typing 3.6.2 py36h7da032a_0", + "mkl 2018.0.1 h19d6760_4", + "graphite2 >=1.3.10,<2.0a0", + "freetype >=2.8,<2.9.0a0", + "click 6.7 py36h5253387_0", + "libffi 3.2.1 hd88cf55_4", + "libtiff >=4.0.9,<5.0a0", + "distributed 1.20.2 py36_0", + "jupyter_console 5.2.0 py36he59e554_1", + "webencodings 0.5.1 py36h800622e_1", + "llvmlite 0.21.0 py36ha241eea_0", + "gmp >=6.1.2", + "libsodium 1.0.15 hf101ebd_0", + "pyopenssl 17.5.0 py36h20ba746_0", + "toolz 0.9.0 py36_0", + "zlib >=1.2.11,<1.3.0a0", + "widgetsnbextension 3.1.0 py36_0", + "pyyaml 3.12 py36hafb9ca4_1", + "multipledispatch 0.4.9 py36h41da3fb_0", + "matplotlib 2.1.2 py36h0e671d2_0", + "unicodecsv 0.14.1 py36ha668878_0", + "flask-cors 3.0.3 py36h2d857d3_0", + "sphinxcontrib-websupport 1.0.1 py36hb5cb234_1", + "dbus 1.12.2 hc3f9b76_1", + "jpeg 9b h024ee3a_2", + "lzo 2.10 h49e0be7_2", + "libedit 3.1 heed3624_0", + "notebook 5.4.0 py36_0", + "pycrypto 2.6.1 py36h14c3975_7", + "pathlib2 2.3.0 py36h49efa8e_0", + "dbus >=1.12.2,<2.0a0", + "harfbuzz >=1.7.4,<2.0a0", + "ipykernel 4.8.0 py36_0", + "bleach 2.1.2 py36_0", + "libcurl 7.58.0 h1ad7b7a_0", + "xlwt 1.3.0 py36h7b00a1f_0", + "pexpect 4.3.1 py36_0", + "tblib 1.3.2 py36h34cf8b6_0", + "cloudpickle 0.5.2 py36_1", + "wheel 0.30.0 py36hfd4bba0_1", + "astropy 2.0.3 py36h14c3975_0", + "patsy 0.5.0 py36_0", + "gstreamer >=1.12.4,<1.13.0a0", + "jupyterlab 0.31.5 py36_0", + "sympy 1.1.1 py36hc6d1c1c_0", + "filelock 2.0.13 py36h646ffb5_0", + "python 3.6.4 hc3d631a_1", + "libssh2 >=1.8.0,<2.0a0", + "ipywidgets 7.1.1 py36_0", + "jupyter_client 5.2.2 py36_0", + "numba 0.36.2 np114py36hc6662d5_0", + "boto 2.48.0 py36h6e4cd66_1", + "statsmodels 0.8.0 py36h8533d0b_0", + "glib >=2.53.6,<3.0a0", + "pyflakes 1.6.0 py36h7bd6a15_0", + "pytz 2017.3 py36h63b9c63_0", + "pycurl 7.43.0.1 py36hb7f436b_0", + "traitlets 4.3.2 py36h674d592_0", + "cffi 1.11.4 py36h9745a5d_0", + "simplegeneric 0.8.1 py36_2", + "libffi >=3.2.1,<3.3a0", + "pandocfilters 1.4.2 py36ha6701b7_1", + "mkl-service 1.1.2 py36h17a0993_4", + "bokeh 0.12.13 py36h2f9c1c0_0", + "imageio 2.2.0 py36he555465_0", + "pytest 3.3.2 py36_0", + "numpy 1.14.0 py36h3dfced4_1", + "pandoc 1.19.2.1 hea2e7c5_1", + "libstdcxx-ng 7.2.0 h7a57d05_2", + "babel 2.5.3 py36_0", + "pillow 5.0.0 py36h3deb7b8_0", + "nose 1.3.7 py36hcdf7029_2", + "icu 58.2 h9c2bf20_1", + "yaml 0.1.7 had09818_2", + "libtiff 4.0.9 h28f6b97_0", + "openssl >=1.0.2n,<1.0.3a", + "mpc 1.0.3 hec55b23_5", + "pygments 2.2.0 py36h0d3125c_0", + "gmp 6.1.2 h6c8ec71_1", + "six 1.11.0 py36h372c433_1", + "sphinx 1.6.6 py36_0", + "readline 7.0 ha6073c6_4", + "jsonschema 2.6.0 py36h006f8b5_0", + "sortedcontainers 1.5.9 py36_0", + "libgfortran-ng 7.2.0 h9f7466a_2", + "glib 2.53.6 h5d9569c_2", + "werkzeug 0.14.1 py36_0", + "blaze 0.11.3 py36h4e06776_0", + "gevent 1.2.2 py36h2fe25dc_0", + "unixodbc 2.3.4 hc36303a_1", + "intel-openmp 2018.0.0 hc7b2577_8", + "nbformat 4.4.0 py36h31c9010_0", + "jedi 0.11.1 py36_0", + "readline >=7.0,<8.0a0", + "pkginfo 1.4.1 py36h215d178_1", + "backports 1.0 py36hfa02d7e_1", + "sqlite 3.22.0 h1bed415_0", + "zeromq 4.2.2 hbedb6e5_2", + "urllib3 1.22 py36hbe7ace6_0", + "libssh2 1.8.0 h9cfc8f7_4", + "dask-core 0.16.1 py36_0", + "pyparsing 2.2.0 py36hee85983_1", + "openssl 1.0.2n hb7f436b_0", + "qtawesome 0.4.4 py36h609ed8c_0", + "chardet 3.0.4 py36h0f667ec_1", + "sqlalchemy 1.2.1 py36h14c3975_0", + "libxslt >=1.1.32,<2.0a0", + "libpng 1.6.34 hb9fc6fc_0", + "patchelf 0.9 hf79760b_2", + "clyent 1.2.2 py36h7e57e65_1", + "ipython 6.2.1 py36h88c514a_1", + "sip 4.18.1 py36h51ed4ed_2", + "ncurses >=6.0,<7.0a0", + "cairo 1.14.12 h77bcde2_0", + "ipython_genutils 0.2.0 py36hb52b0d5_0", + "libpng >=1.6.34,<1.7.0a0", + "libxcb >=1.12,<2.0a0", + "xz >=5.2.3,<6.0a0", + "fastcache 1.0.2 py36h14c3975_2", + "sphinxcontrib 1.0 py36h6d0f590_1", + "asn1crypto 0.24.0 py36_0", + "ptyprocess 0.5.2 py36h69acd42_0", + "gstreamer 1.12.4 hb53b477_0", + "olefile 0.45.1 py36_0", + "fontconfig 2.12.4 h88586e7_1", + "get_terminal_size 1.0.0 haa9412d_0", + "pandas 0.22.0 py36hf484d3e_0", + "libxml2 >=2.9.7,<2.10.0a0", + "pango 1.41.0 hd475d92_0", + "entrypoints 0.2.3 py36h1aec115_2", + "jinja2 2.10 py36ha16c418_0", + "nbconvert 5.3.1 py36hb41ffb7_0", + "pcre 8.41 hc27e229_1", + "bitarray 0.8.1 py36h14c3975_1", + "isort 4.2.15 py36had401c0_0", + "libgcc-ng 7.2.0 h7cc24e2_2", + "anaconda-client 1.6.9 py36_0", + "jupyter 1.0.0 py36_4", + "itsdangerous 0.24 py36h93cc618_1", + "pyodbc 4.0.22 py36hf484d3e_0", + "ncurses 6.0 h9df7e31_2", + "mistune 0.8.3 py36_0", + "packaging 16.8 py36ha668100_1", + "singledispatch 3.4.0.3 py36h7a266c3_0", + "decorator 4.2.1 py36_0", + "pycodestyle 2.3.1 py36hf609f19_0", + "hdf5 1.10.1 h9caa474_1", + "seaborn 0.8.1 py36hfad7ec4_0", + "et_xmlfile 1.0.1 py36hd6bccc3_0", + "zict 0.1.3 py36h3a3bf81_0", + "tornado 4.5.3 py36_0", + "lzo >=2.10,<3.0a0", + "rope 0.10.7 py36h147e2ec_0", + "requests 2.18.4 py36he2e5f8d_1", + "libxcb 1.12 hcd93eb1_4", + "yaml >=0.1.7,<0.2.0a0", + "path.py 10.5 py36h55ceabb_0", + "datashape 0.5.4 py36h3ad6b5c_0", + "astroid 1.6.1 py36_0", + "freetype 2.8 hab7d2ae_1", + "h5py 2.7.1 py36h3585f63_0", + "jbig 2.1 hdba287a_0", + "snowballstemmer 1.2.1 py36h6febd40_0", + "gst-plugins-base 1.12.4 h33fb286_0", + "greenlet 0.4.12 py36h2d503a6_0", + "pycparser 2.18 py36hf9f622e_1", + "ca-certificates 2017.08.26 h1d4fec5_0", + "alabaster 0.7.10 py36h306e16b_0", + "psutil 5.4.3 py36h14c3975_0", + "pyqt 5.6.0 py36h0386399_5", + "openpyxl 2.4.10 py36_0", + "pysocks 1.6.7 py36hd97a5b1_1", + "idna 2.6 py36h82fb2a8_1", + "xlrd 1.1.0 py36h1db9f0c_1", + "setuptools 38.4.0 py36_0", + "pytables 3.4.2 py36h3b5282a_2" + ], + "license": "BSD", + "md5": "52dced2715eb73f8677e4491c255dcd4", + "name": "anaconda", + "namespace": "python", + "sha256": "70772a0cc9a2b86d416e2aafc66e354b03fbfcf35f71ceadc98d1467cfe66fb1", + "size": 12361, + "subdir": "linux-64", + "timestamp": 1518523732355, + "version": "5.1.0" + }, + "anaconda-5.2.0-py27_3.tar.bz2": { + "build": "py27_3", + "build_number": 3, + "depends": [ + "olefile 0.45.1 py27_0", + "ca-certificates 2018.03.07 0", + "docutils 0.14 py27hae222c1_0", + "pycrypto 2.6.1 py27h14c3975_8", + "setuptools 39.1.0 py27_0", + "terminado 0.8.1 py27_1", + "odo 0.5.1 py27h9170de3_0", + "flask 1.0.2 py27_1", + "mpc 1.0.3 hec55b23_5", + "blosc 1.14.3 hdbcaa40_0", + "typing 3.6.4 py27_0", + "libffi 3.2.1 hd88cf55_4", + "chardet 3.0.4 py27hfa10054_1", + "jedi 0.12.0 py27_1", + "libpng 1.6.34 hb9fc6fc_0", + "dask-core 0.17.5 py27_0", + "parso 0.2.0 py27_0", + "boto 2.48.0 py27h9556ac2_1", + "blas 1.0 mkl", + "yaml 0.1.7 had09818_2", + "ipython_genutils 0.2.0 py27h89fb69b_0", + "libstdcxx-ng 7.2.0 hdf63c60_3", + "libssh2 1.8.0 h9cfc8f7_4", + "tk 8.6.7 hc745277_3", + "zict 0.1.3 py27h12c336c_0", + "webencodings 0.5.1 py27hff10b21_1", + "ipython 5.7.0 py27_0", + "filelock 3.0.4 py27_0", + "xlrd 1.1.0 py27ha77178f_1", + "nltk 3.3.0 py27_0", + "jupyter_client 5.2.3 py27_0", + "psutil 5.4.5 py27h14c3975_0", + "wheel 0.31.1 py27_0", + "lazy-object-proxy 1.3.1 py27h682c727_0", + "jupyter_core 4.4.0 py27h345911c_0", + "pillow 5.1.0 py27h3deb7b8_0", + "seaborn 0.8.1 py27h633ea1e_0", + "sphinxcontrib-websupport 1.0.1 py27hf906f22_1", + "werkzeug 0.14.1 py27_0", + "bokeh 0.12.16 py27_0", + "ipykernel 4.8.2 py27_0", + "mkl_random 1.0.1 py27h629b387_0", + "libxml2 2.9.8 h26e45fe_1", + "ncurses 6.1 hf484d3e_0", + "xlsxwriter 1.0.4 py27_0", + "fastcache 1.0.2 py27h14c3975_2", + "freetype 2.8 hab7d2ae_1", + "libcurl 7.60.0 h1ad7b7a_0", + "mistune 0.8.3 py27h14c3975_1", + "pandas 0.23.0 py27h637b7d7_0", + "pluggy 0.6.0 py27h1f4f128_0", + "configparser 3.5.0 py27h5117587_0", + "jupyterlab 0.32.1 py27_0", + "pygments 2.2.0 py27h4a8b6f5_0", + "pylint 1.8.4 py27_0", + "jpeg 9b h024ee3a_2", + "qtawesome 0.4.4 py27hd7914c3_0", + "qtconsole 4.3.1 py27hc444b0d_0", + "sqlite 3.23.1 he433501_0", + "traitlets 4.3.2 py27hd6ce930_0", + "scikit-image 0.13.1 py27h14c3975_1", + "qt 5.9.5 h7e424d6_0", + "astroid 1.6.3 py27_0", + "path.py 11.0.1 py27_0", + "pyparsing 2.2.0 py27hf1513f8_1", + "jupyter_console 5.2.0 py27hc6bee7e_1", + "scandir 1.7 py27h14c3975_0", + "mccabe 0.6.1 py27h0e7c7be_1", + "backports.functools_lru_cache 1.5 py27_1", + "expat 2.2.5 he0dffb1_0", + "sip 4.19.8 py27hf484d3e_0", + "msgpack-python 0.5.6 py27h6bb024c_0", + "ipywidgets 7.2.1 py27_0", + "decorator 4.3.0 py27_0", + "imagesize 1.0.0 py27_0", + "matplotlib 2.2.2 py27h0e671d2_1", + "locket 0.2.0 py27h73929a2_1", + "pycparser 2.18 py27hefa08c5_1", + "numpy 1.14.3 py27hcd700cb_1", + "dask 0.17.5 py27_0", + "contextlib2 0.5.5 py27hbf4c468_0", + "pickleshare 0.7.4 py27h09770e1_0", + "openpyxl 2.5.3 py27_0", + "functools32 3.2.3.2 py27h4ead58f_1", + "pcre 8.42 h439df22_0", + "alabaster 0.7.10 py27he5a193a_0", + "xz 5.2.4 h14c3975_4", + "hdf5 1.10.2 hba1933b_1", + "mkl_fft 1.0.1 py27h3010b51_0", + "patsy 0.5.0 py27_0", + "icu 58.2 h9c2bf20_1", + "jsonschema 2.6.0 py27h7ed5aa4_0", + "tblib 1.3.2 py27h51fe5ba_0", + "harfbuzz 1.7.6 h5f0a787_1", + "cython 0.28.2 py27h14c3975_0", + "gmpy2 2.0.8 py27h4cf3fa8_2", + "babel 2.5.3 py27_0", + "jdcal 1.4 py27_0", + "asn1crypto 0.24.0 py27_0", + "six 1.11.0 py27h5f960f1_1", + "pyyaml 3.12 py27h2d70dd7_1", + "gstreamer 1.14.0 hb453b48_1", + "itsdangerous 0.24 py27hb8295c1_1", + "pyopenssl 18.0.0 py27_0", + "clyent 1.2.2 py27h7276e6c_1", + "imageio 2.3.0 py27_0", + "statsmodels 0.9.0 py27h3010b51_0", + "pytables 3.4.3 py27h02b9ad4_2", + "intel-openmp 2018.0.0 8", + "pkginfo 1.4.2 py27_1", + "cytoolz 0.9.0.1 py27h14c3975_0", + "jbig 2.1 hdba287a_0", + "sqlalchemy 1.2.7 py27h6b74fdf_0", + "backports.shutil_get_terminal_size 1.0.0 py27h5bc021e_2", + "h5py 2.7.1 py27ha1f6525_2", + "bleach 2.1.3 py27_0", + "partd 0.3.8 py27h4e55004_0", + "mkl-service 1.1.2 py27hb2d42c5_4", + "wcwidth 0.1.7 py27h9e3e1ab_0", + "blaze 0.11.3 py27h5f341da_0", + "certifi 2018.4.16 py27_0", + "markupsafe 1.0 py27h97b2822_1", + "requests 2.18.4 py27hc5b0589_1", + "rope 0.10.7 py27hfe459b0_0", + "pycurl 7.43.0.1 py27hb7f436b_0", + "spyder 3.2.8 py27_0", + "dbus 1.13.2 h714fa37_1", + "cffi 1.11.5 py27h9745a5d_0", + "get_terminal_size 1.0.0 haa9412d_0", + "snowballstemmer 1.2.1 py27h44e2768_0", + "send2trash 1.5.0 py27_0", + "sympy 1.1.1 py27hc28188a_0", + "lxml 4.2.1 py27h23eabaa_0", + "gevent 1.3.0 py27h14c3975_0", + "openssl 1.0.2o h20670df_0", + "distributed 1.21.8 py27_0", + "pywavelets 0.5.2 py27hecda097_0", + "sphinxcontrib 1.0 py27h1512b58_1", + "widgetsnbextension 3.2.1 py27_0", + "jinja2 2.10 py27h4114e70_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "greenlet 0.4.13 py27h14c3975_0", + "bottleneck 1.2.1 py27h21b16a3_0", + "bzip2 1.0.6 h14c3975_5", + "cairo 1.14.12 h7636065_2", + "pyflakes 1.6.0 py27h904a57d_0", + "scipy 1.1.0 py27hfc37229_0", + "backports_abc 0.5 py27h7b3c97b_0", + "libxcb 1.13 h1bed415_1", + "libsodium 1.0.16 h1bed415_0", + "notebook 5.5.0 py27_0", + "libedit 3.1.20170329 h6b74fdf_2", + "python 2.7.15 h1571d57_0", + "pycosat 0.6.3 py27ha4109ae_0", + "nbformat 4.4.0 py27hed7f2b2_0", + "datashape 0.5.4 py27hf507385_0", + "packaging 17.1 py27_0", + "python-dateutil 2.7.3 py27_0", + "ipaddress 1.0.22 py27_0", + "flask-cors 3.0.4 py27_0", + "gmp 6.1.2 h6c8ec71_1", + "more-itertools 4.1.0 py27_0", + "mpmath 1.0.0 py27h9669132_2", + "cdecimal 2.3 py27h14c3975_3", + "attrs 18.1.0 py27_0", + "pycodestyle 2.4.0 py27_0", + "py 1.5.3 py27_0", + "ptyprocess 0.5.2 py27h4ccb14c_0", + "anaconda-project 0.8.2 py27h236b58a_0", + "mkl 2018.0.2 1", + "pycairo 1.15.4 py27h1b9232e_1", + "astropy 2.0.6 py27h3010b51_1", + "libgcc-ng 7.2.0 hdf63c60_3", + "nose 1.3.7 py27heec2199_2", + "futures 3.2.0 py27h7b459c0_0", + "pexpect 4.5.0 py27_0", + "ply 3.11 py27_0", + "singledispatch 3.4.0.3 py27h9bcb476_0", + "idna 2.6 py27h5722d68_1", + "glib 2.56.1 h000015b_0", + "html5lib 1.0.1 py27h5233db4_0", + "jupyter 1.0.0 py27_4", + "sortedcontainers 1.5.10 py27_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "lzo 2.10 h49e0be7_2", + "zlib 1.2.11 ha838bed_2", + "bkcharts 0.2 py27h241ae91_0", + "numexpr 2.6.5 py27h7bf3b9c_0", + "bitarray 0.8.1 py27h14c3975_1", + "pytz 2018.4 py27_0", + "libtool 2.4.6 h544aabb_3", + "wrapt 1.10.11 py27h04f6869_0", + "colorama 0.3.9 py27h5cde069_0", + "networkx 2.1 py27_0", + "pytest 3.5.1 py27_0", + "ssl_match_hostname 3.5.0.1 py27h4ec10b9_2", + "patchelf 0.9 hf79760b_2", + "subprocess32 3.5.0 py27h14c3975_0", + "fontconfig 2.12.6 h49f89f6_0", + "urllib3 1.22 py27ha55213b_0", + "zeromq 4.2.5 h439df22_0", + "prompt_toolkit 1.0.15 py27h1b593e1_0", + "llvmlite 0.23.1 py27hdbcaa40_0", + "unixodbc 2.3.6 h1bed415_0", + "pyqt 5.9.2 py27h751905a_0", + "numpy-base 1.14.3 py27h9be14a7_1", + "testpath 0.3.1 py27hc38d2c4_0", + "multipledispatch 0.5.0 py27_0", + "click 6.7 py27h4225b90_0", + "snappy 1.1.7 hbae5bb6_3", + "libgfortran-ng 7.2.0 hdf63c60_3", + "unicodecsv 0.14.1 py27h5062da9_0", + "funcsigs 1.0.2 py27h83f16ab_0", + "pyodbc 4.0.23 py27hf484d3e_0", + "pyzmq 17.0.0 py27h14c3975_1", + "cryptography 2.2.2 py27h14c3975_0", + "scikit-learn 0.19.1 py27h445a80a_0", + "xlwt 1.3.0 py27h3d85d97_0", + "libtiff 4.0.9 he85c1e1_1", + "mpfr 3.1.5 h11a74b3_2", + "pysocks 1.6.8 py27_0", + "toolz 0.9.0 py27_0", + "graphite2 1.3.11 h16798f4_2", + "anaconda-client 1.6.14 py27_0", + "jupyterlab_launcher 0.10.5 py27_0", + "kiwisolver 1.0.1 py27hc15e7b5_0", + "curl 7.60.0 h84994c4_0", + "pixman 0.34.0 hceecf20_3", + "beautifulsoup4 4.6.0 py27h3f86ba9_1", + "ruamel_yaml 0.15.35 py27h14c3975_1", + "nbconvert 5.3.1 py27he041f76_0", + "cycler 0.10.0 py27hc7354d3_0", + "enum34 1.1.6 py27h99a27e9_1", + "glob2 0.6 py27hcea9cbd_0", + "numba 0.38.0 py27h637b7d7_0", + "numpydoc 0.8.0 py27_0", + "pango 1.41.0 hd475d92_0", + "tornado 5.0.2 py27_0", + "backports 1.0 py27h63c9359_1", + "cloudpickle 0.5.3 py27_0", + "pathlib2 2.3.2 py27_0", + "isort 4.3.4 py27_0", + "pandocfilters 1.4.2 py27h428e1e5_1", + "pep8 1.7.1 py27_0", + "pip 10.0.1 py27_0", + "readline 7.0 ha6073c6_4", + "simplegeneric 0.8.1 py27_2", + "heapdict 1.0.0 py27_2", + "libxslt 1.1.32 h1312cb7_0", + "et_xmlfile 1.0.1 py27h75840f5_0", + "entrypoints 0.2.3 py27h502b47d_2", + "grin 1.2.1 py27_4", + "qtpy 1.4.1 py27_0", + "sortedcollections 0.6.1 py27_0", + "sphinx 1.7.4 py27_0" + ], + "license": "BSD", + "md5": "ec03ebaaca92baf87367024f76a244b3", + "name": "anaconda", + "namespace": "python", + "sha256": "b0f617539f1cbb7faaf2a45c741a54100be7f85f8941c7fcba178ad0f4728914", + "size": 12089, + "subdir": "linux-64", + "timestamp": 1527224280569, + "version": "5.2.0" + }, + "anaconda-5.2.0-py35_3.tar.bz2": { + "build": "py35_3", + "build_number": 3, + "depends": [ + "cython 0.28.2 py35h14c3975_0", + "astropy 3.0.2 py35h3010b51_1", + "fastcache 1.0.2 py35h14c3975_2", + "statsmodels 0.9.0 py35h3010b51_0", + "pytables 3.4.3 py35h02b9ad4_2", + "anaconda-client 1.6.14 py35_0", + "hdf5 1.10.2 hba1933b_1", + "setuptools 39.1.0 py35_0", + "urllib3 1.22 py35h2ab6e29_0", + "zict 0.1.3 py35h29275ca_0", + "partd 0.3.8 py35h68187f2_0", + "jupyter_console 5.2.0 py35h4044a63_1", + "jupyterlab 0.32.1 py35_0", + "psutil 5.4.5 py35h14c3975_0", + "colorama 0.3.9 py35h81e2b6c_0", + "jupyter_core 4.4.0 py35ha89e94b_0", + "more-itertools 4.1.0 py35_0", + "typing 3.6.4 py35_0", + "boto 2.48.0 py35h2cfd601_1", + "greenlet 0.4.13 py35h14c3975_0", + "qtconsole 4.3.1 py35h4626a06_0", + "unixodbc 2.3.6 h1bed415_0", + "pycrypto 2.6.1 py35h14c3975_8", + "certifi 2018.4.16 py35_0", + "scipy 1.1.0 py35hfc37229_0", + "lxml 4.2.1 py35h23eabaa_0", + "pycparser 2.18 py35h61b3040_1", + "cffi 1.11.5 py35h9745a5d_0", + "pathlib2 2.3.2 py35_0", + "sortedcollections 0.6.1 py35_0", + "jedi 0.12.0 py35_1", + "multipledispatch 0.5.0 py35_0", + "unicodecsv 0.14.1 py35h4805c0c_0", + "harfbuzz 1.7.6 h5f0a787_1", + "pep8 1.7.1 py35_0", + "flask-cors 3.0.4 py35_0", + "jdcal 1.4 py35_0", + "backports.shutil_get_terminal_size 1.0.0 py35h40844db_2", + "flask 1.0.2 py35_1", + "numexpr 2.6.5 py35h7bf3b9c_0", + "packaging 17.1 py35_0", + "xlsxwriter 1.0.4 py35_0", + "pillow 5.1.0 py35h3deb7b8_0", + "pytest 3.5.1 py35_0", + "astroid 1.6.3 py35_0", + "cloudpickle 0.5.3 py35_0", + "pandas 0.23.0 py35h637b7d7_0", + "pytest-astropy 0.3.0 py35_0", + "cairo 1.14.12 h7636065_2", + "click 6.7 py35h353a69f_0", + "parso 0.2.0 py35_0", + "chardet 3.0.4 py35hb6e9ddf_1", + "backports 1.0 py35hd471ac7_1", + "pango 1.41.0 hd475d92_0", + "jupyter 1.0.0 py35_4", + "pywavelets 0.5.2 py35h53ec731_0", + "readline 7.0 ha6073c6_4", + "pysocks 1.6.8 py35_0", + "lazy-object-proxy 1.3.1 py35h4c720c6_0", + "markupsafe 1.0 py35h4f4fcf6_1", + "rope 0.10.7 py35h986144c_0", + "cryptography 2.2.2 py35h14c3975_0", + "ca-certificates 2018.03.07 0", + "h5py 2.7.1 py35ha1f6525_2", + "terminado 0.8.1 py35_1", + "libxcb 1.13 h1bed415_1", + "ptyprocess 0.5.2 py35h38ce0a3_0", + "libgfortran-ng 7.2.0 hdf63c60_3", + "nltk 3.3.0 py35_0", + "six 1.11.0 py35h423b573_1", + "openssl 1.0.2o h20670df_0", + "et_xmlfile 1.0.1 py35hde8d43e_0", + "pycodestyle 2.4.0 py35_0", + "beautifulsoup4 4.6.0 py35h442a8c9_1", + "olefile 0.45.1 py35_0", + "py 1.5.3 py35_0", + "llvmlite 0.23.1 py35hdbcaa40_0", + "imageio 2.3.0 py35_0", + "sqlite 3.23.1 he433501_0", + "python 3.5.5 hc3d631a_4", + "pandoc 1.19.2.1 hea2e7c5_1", + "cycler 0.10.0 py35hc4d5149_0", + "gmpy2 2.0.8 py35hd0a1c9a_2", + "anaconda-project 0.8.2 py35h7d62c80_0", + "pytz 2018.4 py35_0", + "pandocfilters 1.4.2 py35h1565a15_1", + "python-dateutil 2.7.3 py35_0", + "sip 4.19.8 py35hf484d3e_0", + "pickleshare 0.7.4 py35hd57304d_0", + "fontconfig 2.12.6 h49f89f6_0", + "qtawesome 0.4.4 py35hd68ff89_0", + "ipykernel 4.8.2 py35_0", + "itsdangerous 0.24 py35h7c46880_1", + "locket 0.2.0 py35h170bc82_1", + "pyflakes 1.6.0 py35hd1da72e_0", + "icu 58.2 h9c2bf20_1", + "ply 3.11 py35_0", + "numpy-base 1.14.3 py35h9be14a7_1", + "pluggy 0.6.0 py35hb428803_0", + "ipywidgets 7.2.1 py35_0", + "pylint 1.8.4 py35_0", + "pyopenssl 18.0.0 py35_0", + "mkl-service 1.1.2 py35h0fc7090_4", + "libxml2 2.9.8 h26e45fe_1", + "numba 0.38.0 py35h637b7d7_0", + "gstreamer 1.14.0 hb453b48_1", + "wrapt 1.10.11 py35hfdafd39_0", + "bkcharts 0.2 py35he4f7e30_0", + "sphinxcontrib-websupport 1.0.1 py35h3537809_1", + "webencodings 0.5.1 py35hb6cf162_1", + "mpfr 3.1.5 h11a74b3_2", + "nose 1.3.7 py35hdc64897_2", + "pyyaml 3.12 py35h46ef4ae_1", + "pycurl 7.43.0.1 py35hb7f436b_0", + "nbformat 4.4.0 py35h12e6e07_0", + "expat 2.2.5 he0dffb1_0", + "pcre 8.42 h439df22_0", + "dbus 1.13.2 h714fa37_1", + "libgcc-ng 7.2.0 hdf63c60_3", + "qt 5.9.5 h7e424d6_0", + "libcurl 7.60.0 h1ad7b7a_0", + "prompt_toolkit 1.0.15 py35hc09de7a_0", + "libffi 3.2.1 hd88cf55_4", + "mpc 1.0.3 hec55b23_5", + "datashape 0.5.4 py35h5b068ae_0", + "kiwisolver 1.0.1 py35hcb1117a_0", + "qtpy 1.4.1 py35_0", + "mkl 2018.0.2 1", + "singledispatch 3.4.0.3 py35h0cd4ec3_0", + "toolz 0.9.0 py35_0", + "heapdict 1.0.0 py35_2", + "mkl_random 1.0.1 py35h629b387_0", + "distributed 1.21.8 py35_0", + "imagesize 1.0.0 py35_0", + "clyent 1.2.2 py35h491ffcb_1", + "mpmath 1.0.0 py35h7ce6e34_2", + "requests 2.18.4 py35hb9e6ad1_1", + "odo 0.5.1 py35h102315f_0", + "libpng 1.6.34 hb9fc6fc_0", + "simplegeneric 0.8.1 py35_2", + "msgpack-python 0.5.6 py35h6bb024c_0", + "werkzeug 0.14.1 py35_0", + "sphinxcontrib 1.0 py35hcb7efd2_1", + "xz 5.2.4 h14c3975_4", + "pytest-openfiles 0.3.0 py35_0", + "get_terminal_size 1.0.0 haa9412d_0", + "pytest-remotedata 0.2.1 py35_0", + "gevent 1.3.0 py35h14c3975_0", + "libsodium 1.0.16 h1bed415_0", + "pkginfo 1.4.2 py35_1", + "pip 10.0.1 py35_0", + "mccabe 0.6.1 py35hd8c1f23_1", + "intel-openmp 2018.0.0 8", + "jinja2 2.10 py35h480ab6d_0", + "ncurses 6.1 hf484d3e_0", + "asn1crypto 0.24.0 py35_0", + "sortedcontainers 1.5.10 py35_0", + "snappy 1.1.7 hbae5bb6_3", + "spyder 3.2.8 py35_0", + "mkl_fft 1.0.1 py35h3010b51_0", + "pyqt 5.9.2 py35h751905a_0", + "bottleneck 1.2.1 py35he1b16f1_0", + "ipython 6.4.0 py35_0", + "pyparsing 2.2.0 py35h041ed72_1", + "pexpect 4.5.0 py35_0", + "libstdcxx-ng 7.2.0 hdf63c60_3", + "isort 4.3.4 py35_0", + "cytoolz 0.9.0.1 py35h14c3975_0", + "gmp 6.1.2 h6c8ec71_1", + "tornado 5.0.2 py35_0", + "pyzmq 17.0.0 py35h14c3975_0", + "glob2 0.6 py35hff66265_0", + "patchelf 0.9 hf79760b_2", + "blosc 1.14.3 hdbcaa40_0", + "tk 8.6.7 hc745277_3", + "patsy 0.5.0 py35_0", + "contextlib2 0.5.5 py35h6690dba_0", + "jupyter_client 5.2.3 py35_0", + "snowballstemmer 1.2.1 py35h5435977_0", + "bitarray 0.8.1 py35h14c3975_1", + "xlwt 1.3.0 py35h884a0cf_0", + "lzo 2.10 h49e0be7_2", + "html5lib 1.0.1 py35h2f9c1c0_0", + "pyodbc 4.0.23 py35hf484d3e_0", + "libtool 2.4.6 h544aabb_3", + "pytest-doctestplus 0.1.3 py35_0", + "nbconvert 5.3.1 py35hc5194e3_0", + "jbig 2.1 hdba287a_0", + "ruamel_yaml 0.15.35 py35h14c3975_1", + "ipython_genutils 0.2.0 py35hc9e07d0_0", + "pixman 0.34.0 hceecf20_3", + "pycosat 0.6.3 py35h6b6bb97_0", + "alabaster 0.7.10 py35h6fb19ab_0", + "yaml 0.1.7 had09818_2", + "seaborn 0.8.1 py35h04cba02_0", + "jsonschema 2.6.0 py35h4395190_0", + "networkx 2.1 py35_0", + "libxslt 1.1.32 h1312cb7_0", + "graphite2 1.3.11 h16798f4_2", + "attrs 18.1.0 py35_0", + "backcall 0.1.0 py35_0", + "dask 0.17.5 py35_0", + "curl 7.60.0 h84994c4_0", + "path.py 11.0.1 py35_0", + "sqlalchemy 1.2.7 py35h6b74fdf_0", + "zeromq 4.2.5 h439df22_0", + "pygments 2.2.0 py35h0f41973_0", + "traitlets 4.3.2 py35ha522a97_0", + "jpeg 9b h024ee3a_2", + "jupyterlab_launcher 0.10.5 py35_0", + "widgetsnbextension 3.2.1 py35_0", + "libssh2 1.8.0 h9cfc8f7_4", + "entrypoints 0.2.3 py35h48174a2_2", + "matplotlib 2.2.2 py35h0e671d2_1", + "xlrd 1.1.0 py35h45a0a2a_1", + "pytest-arraydiff 0.2 py35_0", + "babel 2.5.3 py35_0", + "freetype 2.8 hab7d2ae_1", + "wheel 0.31.1 py35_0", + "mistune 0.8.3 py35h14c3975_1", + "blas 1.0 mkl", + "scikit-image 0.13.1 py35h14c3975_1", + "numpydoc 0.8.0 py35_0", + "zlib 1.2.11 ha838bed_2", + "libedit 3.1.20170329 h6b74fdf_2", + "bokeh 0.12.16 py35_0", + "notebook 5.5.0 py35_0", + "filelock 3.0.4 py35_0", + "numpy 1.14.3 py35hcd700cb_1", + "openpyxl 2.5.3 py35_0", + "send2trash 1.5.0 py35_0", + "docutils 0.14 py35hd11081d_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "dask-core 0.17.5 py35_0", + "bzip2 1.0.6 h14c3975_5", + "sympy 1.1.1 py35h919b29a_0", + "glib 2.56.1 h000015b_0", + "sphinx 1.7.4 py35_0", + "wcwidth 0.1.7 py35hcd08066_0", + "blaze 0.11.3 py35ha2c9137_0", + "tblib 1.3.2 py35hf1eb0b4_0", + "scikit-learn 0.19.1 py35hbf1f462_0", + "idna 2.6 py35h8605a33_1", + "bleach 2.1.3 py35_0", + "decorator 4.3.0 py35_0", + "libtiff 4.0.9 he85c1e1_1", + "testpath 0.3.1 py35had42eaf_0" + ], + "license": "BSD", + "md5": "42a314f44a7705bb70844d7e7b81f4dd", + "name": "anaconda", + "namespace": "python", + "sha256": "432293568e9f370bb3f23f88b8a63a7349796662db64c3543f73be6a701421f5", + "size": 11813, + "subdir": "linux-64", + "timestamp": 1527224567217, + "version": "5.2.0" + }, + "anaconda-5.2.0-py36_3.tar.bz2": { + "build": "py36_3", + "build_number": 3, + "depends": [ + "zlib 1.2.11 ha838bed_2", + "astroid 1.6.3 py36_0", + "statsmodels 0.9.0 py36h3010b51_0", + "asn1crypto 0.24.0 py36_0", + "click 6.7 py36h5253387_0", + "pyyaml 3.12 py36hafb9ca4_1", + "pytest-remotedata 0.2.1 py36_0", + "qtpy 1.4.1 py36_0", + "pandocfilters 1.4.2 py36ha6701b7_1", + "curl 7.60.0 h84994c4_0", + "alabaster 0.7.10 py36h306e16b_0", + "filelock 3.0.4 py36_0", + "pexpect 4.5.0 py36_0", + "jupyter 1.0.0 py36_4", + "sphinx 1.7.4 py36_0", + "bitarray 0.8.1 py36h14c3975_1", + "partd 0.3.8 py36h36fd896_0", + "pycodestyle 2.4.0 py36_0", + "bottleneck 1.2.1 py36haac1ea0_0", + "tblib 1.3.2 py36h34cf8b6_0", + "mccabe 0.6.1 py36h5ad9710_1", + "certifi 2018.4.16 py36_0", + "nltk 3.3.0 py36_0", + "xz 5.2.4 h14c3975_4", + "et_xmlfile 1.0.1 py36hd6bccc3_0", + "msgpack-python 0.5.6 py36h6bb024c_0", + "cytoolz 0.9.0.1 py36h14c3975_0", + "libssh2 1.8.0 h9cfc8f7_4", + "pycosat 0.6.3 py36h0a5515d_0", + "lazy-object-proxy 1.3.1 py36h10fcdad_0", + "xlwt 1.3.0 py36h7b00a1f_0", + "lzo 2.10 h49e0be7_2", + "fontconfig 2.12.6 h49f89f6_0", + "nbformat 4.4.0 py36h31c9010_0", + "mkl_random 1.0.1 py36h629b387_0", + "pillow 5.1.0 py36h3deb7b8_0", + "qtconsole 4.3.1 py36h8f73b5b_0", + "scipy 1.1.0 py36hfc37229_0", + "hdf5 1.10.2 hba1933b_1", + "olefile 0.45.1 py36_0", + "patsy 0.5.0 py36_0", + "libxslt 1.1.32 h1312cb7_0", + "pytest 3.5.1 py36_0", + "kiwisolver 1.0.1 py36h764f252_0", + "glib 2.56.1 h000015b_0", + "ncurses 6.1 hf484d3e_0", + "libgcc-ng 7.2.0 hdf63c60_3", + "flask-cors 3.0.4 py36_0", + "multipledispatch 0.5.0 py36_0", + "contextlib2 0.5.5 py36h6c84a62_0", + "libtiff 4.0.9 he85c1e1_1", + "more-itertools 4.1.0 py36_0", + "sortedcontainers 1.5.10 py36_0", + "traitlets 4.3.2 py36h674d592_0", + "bzip2 1.0.6 h14c3975_5", + "scikit-image 0.13.1 py36h14c3975_1", + "zeromq 4.2.5 h439df22_0", + "mistune 0.8.3 py36h14c3975_1", + "pip 10.0.1 py36_0", + "pcre 8.42 h439df22_0", + "jinja2 2.10 py36ha16c418_0", + "ptyprocess 0.5.2 py36h69acd42_0", + "locket 0.2.0 py36h787c0ad_1", + "psutil 5.4.5 py36h14c3975_0", + "ply 3.11 py36_0", + "itsdangerous 0.24 py36h93cc618_1", + "libpng 1.6.34 hb9fc6fc_0", + "py 1.5.3 py36_0", + "backports 1.0 py36hfa02d7e_1", + "ipython 6.4.0 py36_0", + "pysocks 1.6.8 py36_0", + "zict 0.1.3 py36h3a3bf81_0", + "python 3.6.5 hc3d631a_2", + "jupyterlab 0.32.1 py36_0", + "xlsxwriter 1.0.4 py36_0", + "libxml2 2.9.8 h26e45fe_1", + "odo 0.5.1 py36h90ed295_0", + "dask-core 0.17.5 py36_0", + "datashape 0.5.4 py36h3ad6b5c_0", + "mkl 2018.0.2 1", + "gevent 1.3.0 py36h14c3975_0", + "pandas 0.23.0 py36h637b7d7_0", + "lxml 4.2.1 py36h23eabaa_0", + "cloudpickle 0.5.3 py36_0", + "libffi 3.2.1 hd88cf55_4", + "libstdcxx-ng 7.2.0 hdf63c60_3", + "pyzmq 17.0.0 py36h14c3975_0", + "qt 5.9.5 h7e424d6_0", + "distributed 1.21.8 py36_0", + "llvmlite 0.23.1 py36hdbcaa40_0", + "flask 1.0.2 py36_1", + "blaze 0.11.3 py36h4e06776_0", + "entrypoints 0.2.3 py36h1aec115_2", + "tk 8.6.7 hc745277_3", + "attrs 18.1.0 py36_0", + "unixodbc 2.3.6 h1bed415_0", + "pyflakes 1.6.0 py36h7bd6a15_0", + "pkginfo 1.4.2 py36_1", + "gstreamer 1.14.0 hb453b48_1", + "mpc 1.0.3 hec55b23_5", + "pathlib2 2.3.2 py36_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "unicodecsv 0.14.1 py36ha668878_0", + "python-dateutil 2.7.3 py36_0", + "seaborn 0.8.1 py36hfad7ec4_0", + "html5lib 1.0.1 py36h2f9c1c0_0", + "werkzeug 0.14.1 py36_0", + "isort 4.3.4 py36_0", + "pylint 1.8.4 py36_0", + "testpath 0.3.1 py36h8cadb63_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "expat 2.2.5 he0dffb1_0", + "get_terminal_size 1.0.0 haa9412d_0", + "six 1.11.0 py36h372c433_1", + "nbconvert 5.3.1 py36hb41ffb7_0", + "pytest-openfiles 0.3.0 py36_0", + "jedi 0.12.0 py36_1", + "pywavelets 0.5.2 py36he602eb0_0", + "markupsafe 1.0 py36hd9260cd_1", + "sphinxcontrib 1.0 py36h6d0f590_1", + "pytables 3.4.3 py36h02b9ad4_2", + "rope 0.10.7 py36h147e2ec_0", + "packaging 17.1 py36_0", + "numpy 1.14.3 py36hcd700cb_1", + "libcurl 7.60.0 h1ad7b7a_0", + "pyodbc 4.0.23 py36hf484d3e_0", + "requests 2.18.4 py36he2e5f8d_1", + "sphinxcontrib-websupport 1.0.1 py36hb5cb234_1", + "pycparser 2.18 py36hf9f622e_1", + "webencodings 0.5.1 py36h800622e_1", + "blosc 1.14.3 hdbcaa40_0", + "ipython_genutils 0.2.0 py36hb52b0d5_0", + "bkcharts 0.2 py36h735825a_0", + "pytest-astropy 0.3.0 py36_0", + "pickleshare 0.7.4 py36h63277f8_0", + "pygments 2.2.0 py36h0d3125c_0", + "babel 2.5.3 py36_0", + "singledispatch 3.4.0.3 py36h7a266c3_0", + "yaml 0.1.7 had09818_2", + "notebook 5.5.0 py36_0", + "pep8 1.7.1 py36_0", + "tornado 5.0.2 py36_0", + "pyopenssl 18.0.0 py36_0", + "urllib3 1.22 py36hbe7ace6_0", + "patchelf 0.9 hf79760b_2", + "icu 58.2 h9c2bf20_1", + "nose 1.3.7 py36hcdf7029_2", + "heapdict 1.0.0 py36_2", + "jpeg 9b h024ee3a_2", + "mkl_fft 1.0.1 py36h3010b51_0", + "networkx 2.1 py36_0", + "snowballstemmer 1.2.1 py36h6febd40_0", + "numba 0.38.0 py36h637b7d7_0", + "pyqt 5.9.2 py36h751905a_0", + "clyent 1.2.2 py36h7e57e65_1", + "backports.shutil_get_terminal_size 1.0.0 py36hfea85ff_2", + "anaconda-project 0.8.2 py36h44fb852_0", + "pyparsing 2.2.0 py36hee85983_1", + "docutils 0.14 py36hb0f60f5_0", + "send2trash 1.5.0 py36_0", + "mpmath 1.0.0 py36hfeacd6b_2", + "libxcb 1.13 h1bed415_1", + "mkl-service 1.1.2 py36h17a0993_4", + "graphite2 1.3.11 h16798f4_2", + "widgetsnbextension 3.2.1 py36_0", + "matplotlib 2.2.2 py36h0e671d2_1", + "pixman 0.34.0 hceecf20_3", + "qtawesome 0.4.4 py36h609ed8c_0", + "ca-certificates 2018.03.07 0", + "idna 2.6 py36h82fb2a8_1", + "libedit 3.1.20170329 h6b74fdf_2", + "pytest-doctestplus 0.1.3 py36_0", + "beautifulsoup4 4.6.0 py36h49b8c8c_1", + "gmpy2 2.0.8 py36hc8893dd_2", + "greenlet 0.4.13 py36h14c3975_0", + "pycurl 7.43.0.1 py36hb7f436b_0", + "bleach 2.1.3 py36_0", + "fastcache 1.0.2 py36h14c3975_2", + "h5py 2.7.1 py36ha1f6525_2", + "mpfr 3.1.5 h11a74b3_2", + "imageio 2.3.0 py36_0", + "ruamel_yaml 0.15.35 py36h14c3975_1", + "simplegeneric 0.8.1 py36_2", + "wcwidth 0.1.7 py36hdf4376a_0", + "jupyter_core 4.4.0 py36h7c827e3_0", + "readline 7.0 ha6073c6_4", + "pytz 2018.4 py36_0", + "imagesize 1.0.0 py36_0", + "jupyter_client 5.2.3 py36_0", + "terminado 0.8.1 py36_1", + "cycler 0.10.0 py36h93f1223_0", + "cryptography 2.2.2 py36h14c3975_0", + "pango 1.41.0 hd475d92_0", + "prompt_toolkit 1.0.15 py36h17d85b1_0", + "sqlalchemy 1.2.7 py36h6b74fdf_0", + "dbus 1.13.2 h714fa37_1", + "cffi 1.11.5 py36h9745a5d_0", + "typing 3.6.4 py36_0", + "freetype 2.8 hab7d2ae_1", + "jbig 2.1 hdba287a_0", + "sympy 1.1.1 py36hc6d1c1c_0", + "cython 0.28.2 py36h14c3975_0", + "openpyxl 2.5.3 py36_0", + "pytest-arraydiff 0.2 py36_0", + "snappy 1.1.7 hbae5bb6_3", + "pycrypto 2.6.1 py36h14c3975_8", + "chardet 3.0.4 py36h0f667ec_1", + "libsodium 1.0.16 h1bed415_0", + "parso 0.2.0 py36_0", + "jupyter_console 5.2.0 py36he59e554_1", + "harfbuzz 1.7.6 h5f0a787_1", + "astropy 3.0.2 py36h3010b51_1", + "pluggy 0.6.0 py36hb689045_0", + "setuptools 39.1.0 py36_0", + "libtool 2.4.6 h544aabb_3", + "jdcal 1.4 py36_0", + "numexpr 2.6.5 py36h7bf3b9c_0", + "jsonschema 2.6.0 py36h006f8b5_0", + "gmp 6.1.2 h6c8ec71_1", + "ipywidgets 7.2.1 py36_0", + "dask 0.17.5 py36_0", + "spyder 3.2.8 py36_0", + "backcall 0.1.0 py36_0", + "libgfortran-ng 7.2.0 hdf63c60_3", + "xlrd 1.1.0 py36h1db9f0c_1", + "sip 4.19.8 py36hf484d3e_0", + "intel-openmp 2018.0.0 8", + "decorator 4.3.0 py36_0", + "blas 1.0 mkl", + "glob2 0.6 py36he249c77_0", + "ipykernel 4.8.2 py36_0", + "scikit-learn 0.19.1 py36h7aa7ec6_0", + "cairo 1.14.12 h7636065_2", + "openssl 1.0.2o h20670df_0", + "sortedcollections 0.6.1 py36_0", + "sqlite 3.23.1 he433501_0", + "wheel 0.31.1 py36_0", + "colorama 0.3.9 py36h489cec4_0", + "wrapt 1.10.11 py36h28b7045_0", + "toolz 0.9.0 py36_0", + "anaconda-client 1.6.14 py36_0", + "path.py 11.0.1 py36_0", + "boto 2.48.0 py36h6e4cd66_1", + "bokeh 0.12.16 py36_0", + "jupyterlab_launcher 0.10.5 py36_0", + "numpydoc 0.8.0 py36_0", + "numpy-base 1.14.3 py36h9be14a7_1" + ], + "license": "BSD", + "md5": "4d1cb8eaedb6f5238cef8fc99a5bdbda", + "name": "anaconda", + "namespace": "python", + "sha256": "474bf3b454b373372a2a2ada0a6d95a08110fcea48f59488e6c5eb8833f8b698", + "size": 11708, + "subdir": "linux-64", + "timestamp": 1527224860738, + "version": "5.2.0" + }, + "anaconda-5.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "scandir 1.9.0 py27h14c3975_0", + "pickleshare 0.7.4 py27_0", + "scikit-learn 0.19.2 py27h4989274_0", + "cloudpickle 0.5.5 py27_0", + "markupsafe 1.0 py27h14c3975_1", + "enum34 1.1.6 py27_1", + "bleach 2.1.4 py27_0", + "ipywidgets 7.4.1 py27_0", + "mkl_random 1.0.1 py27h4414c95_1", + "h5py 2.8.0 py27h989c5e5_3", + "appdirs 1.4.3 py27h28b3542_0", + "greenlet 0.4.15 py27h7b6447c_0", + "et_xmlfile 1.0.1 py27_0", + "boto 2.49.0 py27_0", + "cdecimal 2.3 py27h14c3975_3", + "ssl_match_hostname 3.5.0.1 py27_2", + "xz 5.2.4 h14c3975_4", + "ptyprocess 0.6.0 py27_0", + "prompt_toolkit 1.0.15 py27_0", + "alabaster 0.7.11 py27_0", + "pylint 1.9.2 py27_0", + "mistune 0.8.3 py27h14c3975_1", + "datashape 0.5.4 py27_1", + "pcre 8.42 h439df22_0", + "packaging 17.1 py27_0", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "pycrypto 2.6.1 py27h14c3975_9", + "python-dateutil 2.7.3 py27_0", + "libuuid 1.0.3 h1bed415_2", + "jpeg 9b h024ee3a_2", + "networkx 2.1 py27_0", + "readline 7.0 h7b6447c_5", + "fribidi 1.0.5 h7b6447c_0", + "pyzmq 17.1.2 py27h14c3975_0", + "pywavelets 1.0.0 py27hdd07704_0", + "mccabe 0.6.1 py27_1", + "expat 2.2.6 he6710b0_0", + "odo 0.5.1 py27_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "pyasn1-modules 0.2.2 py27_0", + "pandocfilters 1.4.2 py27_1", + "ipython_genutils 0.2.0 py27_0", + "grin 1.2.1 py27_4", + "jupyterlab 0.33.11 py27_0", + "hdf5 1.10.2 hba1933b_1", + "openssl 1.0.2p h14c3975_0", + "widgetsnbextension 3.4.1 py27_0", + "funcsigs 1.0.2 py27_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "pathlib2 2.3.2 py27_0", + "gmp 6.1.2 h6c8ec71_1", + "libxslt 1.1.32 h1312cb7_0", + "sphinx 1.7.9 py27_0", + "html5lib 1.0.1 py27_0", + "docutils 0.14 py27_0", + "parso 0.3.1 py27_0", + "babel 2.6.0 py27_0", + "pycosat 0.6.3 py27h14c3975_0", + "pycparser 2.18 py27_1", + "libcurl 7.61.0 h1ad7b7a_0", + "anaconda-client 1.7.2 py27_0", + "patchelf 0.9 hf484d3e_2", + "numexpr 2.6.8 py27hd89afb7_0", + "blaze 0.11.3 py27_0", + "pango 1.42.4 h049681c_0", + "libgcc-ng 8.2.0 hdf63c60_1", + "blas 1.0 mkl", + "dask-core 0.19.1 py27_0", + "xlwt 1.3.0 py27_0", + "zope 1.0 py27_1", + "icu 58.2 h9c2bf20_1", + "qt 5.9.6 h8703b6f_2", + "typing 3.6.6 py27_0", + "idna 2.7 py27_0", + "pyyaml 3.13 py27h14c3975_0", + "cython 0.28.5 py27hf484d3e_0", + "backports_abc 0.5 py27_0", + "python 2.7.15 h1571d57_0", + "lazy-object-proxy 1.3.1 py27h14c3975_2", + "pillow 5.2.0 py27heded4f4_0", + "jsonschema 2.6.0 py27_0", + "pycurl 7.43.0.2 py27hb7f436b_0", + "pep8 1.7.1 py27_0", + "graphite2 1.3.12 h23475e2_2", + "asn1crypto 0.24.0 py27_0", + "libxml2 2.9.8 h26e45fe_1", + "glob2 0.6 py27_0", + "ply 3.11 py27_0", + "distributed 1.23.1 py27_0", + "libtiff 4.0.9 he85c1e1_2", + "astropy 2.0.8 py27h035aef0_0", + "wcwidth 0.1.7 py27_0", + "astroid 1.6.5 py27_0", + "yaml 0.1.7 had09818_2", + "beautifulsoup4 4.6.3 py27_0", + "decorator 4.3.0 py27_0", + "spyder 3.3.1 py27_1", + "pysocks 1.6.8 py27_0", + "backports 1.0 py27_1", + "psutil 5.4.7 py27h14c3975_0", + "ncurses 6.1 hf484d3e_0", + "sip 4.19.8 py27hf484d3e_0", + "freetype 2.9.1 h8a8886c_1", + "jupyter_core 4.4.0 py27_0", + "nbconvert 5.4.0 py27_1", + "ruamel_yaml 0.15.46 py27h14c3975_0", + "ca-certificates 2018.03.07 0", + "filelock 3.0.8 py27_0", + "pytest 3.8.0 py27_0", + "ipykernel 4.9.0 py27_1", + "webencodings 0.5.1 py27_1", + "libsodium 1.0.16 h1bed415_0", + "pexpect 4.6.0 py27_0", + "notebook 5.6.0 py27_0", + "terminado 0.8.1 py27_1", + "cffi 1.11.5 py27he75722e_1", + "blosc 1.14.4 hdbcaa40_0", + "pixman 0.34.0 hceecf20_3", + "sqlite 3.24.0 h84994c4_0", + "py 1.6.0 py27_0", + "clyent 1.2.2 py27_1", + "llvmlite 0.24.0 py27hdbcaa40_0", + "snappy 1.1.7 hbae5bb6_3", + "spyder-kernels 0.2.6 py27_0", + "pytz 2018.5 py27_0", + "sortedcontainers 2.0.5 py27_0", + "jupyter_console 5.2.0 py27_1", + "gstreamer 1.14.0 hb453b48_1", + "jbig 2.1 hdba287a_0", + "heapdict 1.0.0 py27_2", + "pip 10.0.1 py27_0", + "zope.interface 4.5.0 py27h14c3975_0", + "testpath 0.3.1 py27_0", + "mkl_fft 1.0.4 py27h4414c95_1", + "send2trash 1.5.0 py27_0", + "sqlalchemy 1.2.11 py27h7b6447c_0", + "colorama 0.3.9 py27_0", + "sphinxcontrib-websupport 1.1.0 py27_1", + "futures 3.2.0 py27_0", + "jupyter_client 5.2.3 py27_0", + "mpmath 1.0.0 py27_2", + "dask 0.19.1 py27_0", + "pyodbc 4.0.24 py27he6710b0_0", + "fastcache 1.0.2 py27h14c3975_2", + "libedit 3.1.20170329 h6b74fdf_2", + "kiwisolver 1.0.1 py27hf484d3e_0", + "more-itertools 4.3.0 py27_0", + "cryptography 2.3.1 py27hc365091_0", + "partd 0.3.8 py27_0", + "libpng 1.6.34 hb9fc6fc_0", + "attrs 18.2.0 py27h28b3542_0", + "mpfr 4.0.1 hdf1c602_3", + "bottleneck 1.2.1 py27h035aef0_1", + "jupyter 1.0.0 py27_7", + "imageio 2.4.1 py27_0", + "certifi 2018.8.24 py27_1", + "dbus 1.13.2 h714fa37_1", + "numpy 1.15.1 py27h1d66e8a_0", + "backports.functools_lru_cache 1.5 py27_1", + "cytoolz 0.9.0.1 py27h14c3975_1", + "qtawesome 0.4.4 py27_0", + "locket 0.2.0 py27_1", + "jinja2 2.10 py27_0", + "wheel 0.31.1 py27_0", + "cairo 1.14.12 h8948797_3", + "bzip2 1.0.6 h14c3975_5", + "nose 1.3.7 py27_2", + "defusedxml 0.5.0 py27_1", + "zict 0.1.3 py27_0", + "setuptools 40.2.0 py27_0", + "nltk 3.3.0 py27_0", + "matplotlib 2.2.3 py27hb69df0a_0", + "incremental 17.5.0 py27_0", + "snowballstemmer 1.2.1 py27_0", + "olefile 0.46 py27_0", + "atomicwrites 1.2.1 py27_0", + "linecache2 1.0.0 py27_0", + "fontconfig 2.13.0 h9420a91_0", + "ipython 5.8.0 py27_0", + "gevent 1.3.6 py27h7b6447c_0", + "multipledispatch 0.6.0 py27_0", + "singledispatch 3.4.0.3 py27_0", + "urllib3 1.23 py27_0", + "functools32 3.2.3.2 py27_1", + "msgpack-python 0.5.6 py27h6bb024c_1", + "isort 4.3.4 py27_0", + "bkcharts 0.2 py27_0", + "twisted 18.7.0 py27h14c3975_1", + "chardet 3.0.4 py27_1", + "automat 0.7.0 py27_0", + "itsdangerous 0.24 py27_1", + "glib 2.56.2 hd408876_0", + "curl 7.61.0 h84994c4_0", + "pygments 2.2.0 py27_0", + "requests 2.19.1 py27_0", + "unixodbc 2.3.7 h14c3975_0", + "imagesize 1.1.0 py27_0", + "gmpy2 2.0.8 py27h10f8cd9_2", + "cycler 0.10.0 py27_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "pyflakes 2.0.0 py27_0", + "zlib 1.2.11 ha838bed_2", + "toolz 0.9.0 py27_0", + "pycairo 1.17.1 py27h2a1e443_0", + "xlrd 1.1.0 py27_1", + "sortedcollections 1.0.1 py27_0", + "numba 0.39.0 py27h04863e7_0", + "pkginfo 1.4.2 py27_1", + "patsy 0.5.0 py27_0", + "contextlib2 0.5.5 py27_0", + "path.py 11.1.0 py27_0", + "entrypoints 0.2.3 py27_2", + "pandas 0.23.4 py27h04863e7_0", + "sphinxcontrib 1.0 py27_1", + "zeromq 4.2.5 hf484d3e_1", + "libffi 3.2.1 hd88cf55_4", + "intel-openmp 2019.0 118", + "bitarray 0.8.3 py27h14c3975_0", + "mkl-service 1.1.2 py27h90e4bf4_5", + "lxml 4.2.5 py27hefd8a0e_0", + "qtpy 1.5.0 py27_0", + "scikit-image 0.14.0 py27hf484d3e_1", + "simplegeneric 0.8.1 py27_2", + "lzo 2.10 h49e0be7_2", + "wrapt 1.10.11 py27h14c3975_2", + "libssh2 1.8.0 h9cfc8f7_4", + "traceback2 1.4.0 py27_0", + "anaconda-project 0.8.2 py27_0", + "rope 0.11.0 py27_0", + "werkzeug 0.14.1 py27_0", + "unicodecsv 0.14.1 py27_0", + "scipy 1.1.0 py27hfa4b5c9_1", + "backports.shutil_get_terminal_size 1.0.0 py27_2", + "unittest2 1.1.0 py27_0", + "flask-cors 3.0.6 py27_0", + "prometheus_client 0.3.1 py27h28b3542_0", + "pluggy 0.7.1 py27h28b3542_0", + "openpyxl 2.5.6 py27_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "jupyterlab_launcher 0.11.2 py27h28b3542_0", + "libxcb 1.13 h1bed415_1", + "pyasn1 0.4.4 py27h28b3542_0", + "mpc 1.1.0 h10f8cd9_1", + "jdcal 1.4 py27_0", + "service_identity 17.0.0 py27h28b3542_0", + "configparser 3.5.0 py27_0", + "nbformat 4.4.0 py27_0", + "constantly 15.1.0 py27h28b3542_0", + "get_terminal_size 1.0.0 haa9412d_0", + "seaborn 0.9.0 py27_0", + "tblib 1.3.2 py27_0", + "bokeh 0.13.0 py27_0", + "hyperlink 18.0.0 py27_0", + "ipaddress 1.0.22 py27_0", + "numpydoc 0.8.0 py27_0", + "libtool 2.4.6 h544aabb_3", + "statsmodels 0.9.0 py27h035aef0_0", + "pyparsing 2.2.0 py27_1", + "six 1.11.0 py27_1", + "pyopenssl 18.0.0 py27_0", + "subprocess32 3.5.2 py27h14c3975_0", + "tornado 5.1 py27h14c3975_0", + "tqdm 4.26.0 py27h28b3542_0", + "flask 1.0.2 py27_1", + "pyqt 5.9.2 py27h05f1152_2", + "numpy-base 1.15.1 py27h81de0dd_0", + "pytables 3.4.4 py27ha205bf6_0", + "traitlets 4.3.2 py27_0", + "jedi 0.12.1 py27_0", + "qtconsole 4.4.1 py27_0", + "xlsxwriter 1.1.0 py27_0", + "sympy 1.2 py27_0", + "click 6.7 py27_0", + "pycodestyle 2.4.0 py27_0", + "tk 8.6.8 hbc83047_0", + "mkl 2018.0.3 1" + ], + "license": "BSD", + "md5": "851bb1754dbc8a80ed67671896dd7e4a", + "name": "anaconda", + "namespace": "python", + "sha256": "b292de4cac707222b637e3edea5c7e9a532e13c59ad1c91fc01d3caf34e94a75", + "size": 11683, + "subdir": "linux-64", + "timestamp": 1537855543424, + "version": "5.3.0" + }, + "anaconda-5.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "requests 2.19.1 py36_0", + "appdirs 1.4.3 py36h28b3542_0", + "h5py 2.8.0 py36h989c5e5_3", + "send2trash 1.5.0 py36_0", + "psutil 5.4.7 py36h14c3975_0", + "backports.shutil_get_terminal_size 1.0.0 py36_2", + "qtpy 1.5.0 py36_0", + "jupyter_client 5.2.3 py36_0", + "filelock 3.0.8 py36_0", + "pycodestyle 2.4.0 py36_0", + "multipledispatch 0.6.0 py36_0", + "cryptography 2.3.1 py36hc365091_0", + "pytables 3.4.4 py36ha205bf6_0", + "curl 7.61.0 h84994c4_0", + "et_xmlfile 1.0.1 py36_0", + "pycosat 0.6.3 py36h14c3975_0", + "tblib 1.3.2 py36_0", + "spyder-kernels 0.2.6 py36_0", + "blosc 1.14.4 hdbcaa40_0", + "pkginfo 1.4.2 py36_1", + "unicodecsv 0.14.1 py36_0", + "babel 2.6.0 py36_0", + "sqlite 3.24.0 h84994c4_0", + "colorama 0.3.9 py36_0", + "dask-core 0.19.1 py36_0", + "pango 1.42.4 h049681c_0", + "nbconvert 5.4.0 py36_1", + "cytoolz 0.9.0.1 py36h14c3975_1", + "twisted 18.7.0 py36h14c3975_1", + "automat 0.7.0 py36_0", + "llvmlite 0.24.0 py36hdbcaa40_0", + "openssl 1.0.2p h14c3975_0", + "toolz 0.9.0 py36_0", + "gevent 1.3.6 py36h7b6447c_0", + "entrypoints 0.2.3 py36_2", + "pytest-openfiles 0.3.0 py36_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "prometheus_client 0.3.1 py36h28b3542_0", + "jeepney 0.3.1 py36_0", + "nltk 3.3.0 py36_0", + "ipython_genutils 0.2.0 py36_0", + "zlib 1.2.11 ha838bed_2", + "pywavelets 1.0.0 py36hdd07704_0", + "mccabe 0.6.1 py36_1", + "certifi 2018.8.24 py36_1", + "numexpr 2.6.8 py36hd89afb7_0", + "backports 1.0 py36_1", + "mkl_fft 1.0.4 py36h4414c95_1", + "glib 2.56.2 hd408876_0", + "tornado 5.1 py36h14c3975_0", + "zeromq 4.2.5 hf484d3e_1", + "notebook 5.6.0 py36_0", + "datashape 0.5.4 py36_1", + "bitarray 0.8.3 py36h14c3975_0", + "icu 58.2 h9c2bf20_1", + "six 1.11.0 py36_1", + "jupyter_core 4.4.0 py36_0", + "libtool 2.4.6 h544aabb_3", + "ipython 6.5.0 py36_0", + "fastcache 1.0.2 py36h14c3975_2", + "greenlet 0.4.15 py36h7b6447c_0", + "werkzeug 0.14.1 py36_0", + "flask-cors 3.0.6 py36_0", + "matplotlib 2.2.3 py36hb69df0a_0", + "snowballstemmer 1.2.1 py36_0", + "qtawesome 0.4.4 py36_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py36h10f8cd9_2", + "pygments 2.2.0 py36_0", + "pyparsing 2.2.0 py36_1", + "freetype 2.9.1 h8a8886c_1", + "astroid 2.0.4 py36_0", + "pyasn1-modules 0.2.2 py36_0", + "sip 4.19.8 py36hf484d3e_0", + "service_identity 17.0.0 py36h28b3542_0", + "dbus 1.13.2 h714fa37_1", + "pytest-remotedata 0.3.0 py36_0", + "statsmodels 0.9.0 py36h035aef0_0", + "pillow 5.2.0 py36heded4f4_0", + "jinja2 2.10 py36_0", + "sqlalchemy 1.2.11 py36h7b6447c_0", + "wrapt 1.10.11 py36h14c3975_2", + "qt 5.9.6 h8703b6f_2", + "path.py 11.1.0 py36_0", + "dask 0.19.1 py36_0", + "pexpect 4.6.0 py36_0", + "jupyter 1.0.0 py36_7", + "odo 0.5.1 py36_0", + "pycparser 2.18 py36_1", + "snappy 1.1.7 hbae5bb6_3", + "parso 0.3.1 py36_0", + "html5lib 1.0.1 py36_0", + "itsdangerous 0.24 py36_1", + "libpng 1.6.34 hb9fc6fc_0", + "nose 1.3.7 py36_2", + "numba 0.39.0 py36h04863e7_0", + "packaging 17.1 py36_0", + "pyflakes 2.0.0 py36_0", + "mkl-service 1.1.2 py36h90e4bf4_5", + "nbformat 4.4.0 py36_0", + "sphinxcontrib-websupport 1.1.0 py36_1", + "cython 0.28.5 py36hf484d3e_0", + "lzo 2.10 h49e0be7_2", + "wheel 0.31.1 py36_0", + "python-dateutil 2.7.3 py36_0", + "patsy 0.5.0 py36_0", + "graphite2 1.3.12 h23475e2_2", + "pip 10.0.1 py36_0", + "webencodings 0.5.1 py36_1", + "gstreamer 1.14.0 hb453b48_1", + "python 3.6.6 hc3d631a_0", + "libgcc-ng 8.2.0 hdf63c60_1", + "secretstorage 3.1.0 py36_0", + "spyder 3.3.1 py36_1", + "heapdict 1.0.0 py36_2", + "idna 2.7 py36_0", + "libtiff 4.0.9 he85c1e1_2", + "more-itertools 4.3.0 py36_0", + "mpc 1.1.0 h10f8cd9_1", + "distributed 1.23.1 py36_0", + "constantly 15.1.0 py36h28b3542_0", + "fribidi 1.0.5 h7b6447c_0", + "clyent 1.2.2 py36_1", + "libxcb 1.13 h1bed415_1", + "pyasn1 0.4.4 py36h28b3542_0", + "ca-certificates 2018.03.07 0", + "bkcharts 0.2 py36_0", + "jdcal 1.4 py36_0", + "tk 8.6.8 hbc83047_0", + "docutils 0.14 py36_0", + "imageio 2.4.1 py36_0", + "boto 2.49.0 py36_0", + "libxslt 1.1.32 h1312cb7_0", + "imagesize 1.1.0 py36_0", + "click 6.7 py36_0", + "pytest-arraydiff 0.2 py36h39e3cac_0", + "asn1crypto 0.24.0 py36_0", + "markupsafe 1.0 py36h14c3975_1", + "scikit-learn 0.19.2 py36h4989274_0", + "scikit-image 0.14.0 py36hf484d3e_1", + "pickleshare 0.7.4 py36_0", + "libuuid 1.0.3 h1bed415_2", + "hyperlink 18.0.0 py36_0", + "glob2 0.6 py36_0", + "olefile 0.46 py36_0", + "lxml 4.2.5 py36hefd8a0e_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "numpy-base 1.15.1 py36h81de0dd_0", + "seaborn 0.9.0 py36_0", + "backcall 0.1.0 py36_0", + "mpmath 1.0.0 py36_2", + "sortedcollections 1.0.1 py36_0", + "sphinx 1.7.9 py36_0", + "yaml 0.1.7 had09818_2", + "blas 1.0 mkl", + "testpath 0.3.1 py36_0", + "lazy-object-proxy 1.3.1 py36h14c3975_2", + "astropy 3.0.4 py36h14c3975_0", + "ipykernel 4.9.0 py36_1", + "cffi 1.11.5 py36he75722e_1", + "sympy 1.2 py36_0", + "expat 2.2.6 he6710b0_0", + "networkx 2.1 py36_0", + "zope.interface 4.5.0 py36h14c3975_0", + "xz 5.2.4 h14c3975_4", + "pytest-astropy 0.4.0 py36_0", + "traitlets 4.3.2 py36_0", + "bzip2 1.0.6 h14c3975_5", + "py 1.6.0 py36_0", + "ncurses 6.1 hf484d3e_0", + "zict 0.1.3 py36_0", + "terminado 0.8.1 py36_1", + "jupyter_console 5.2.0 py36_1", + "numpy 1.15.1 py36h1d66e8a_0", + "jupyterlab_launcher 0.13.1 py36_0", + "libsodium 1.0.16 h1bed415_0", + "libedit 3.1.20170329 h6b74fdf_2", + "jsonschema 2.6.0 py36_0", + "pysocks 1.6.8 py36_0", + "bokeh 0.13.0 py36_0", + "typed-ast 1.1.0 py36h14c3975_0", + "jbig 2.1 hdba287a_0", + "kiwisolver 1.0.1 py36hf484d3e_0", + "cloudpickle 0.5.5 py36_0", + "libxml2 2.9.8 h26e45fe_1", + "pcre 8.42 h439df22_0", + "qtconsole 4.4.1 py36_0", + "zope 1.0 py36_1", + "simplegeneric 0.8.1 py36_2", + "widgetsnbextension 3.4.1 py36_0", + "cycler 0.10.0 py36_0", + "xlwt 1.3.0 py36_0", + "pytz 2018.5 py36_0", + "numpydoc 0.8.0 py36_0", + "sphinxcontrib 1.0 py36_1", + "pixman 0.34.0 hceecf20_3", + "prompt_toolkit 1.0.15 py36_0", + "pyopenssl 18.0.0 py36_0", + "ptyprocess 0.6.0 py36_0", + "xlrd 1.1.0 py36_1", + "ruamel_yaml 0.15.46 py36h14c3975_0", + "jupyterlab 0.34.9 py36_0", + "openpyxl 2.5.6 py36_0", + "tqdm 4.26.0 py36h28b3542_0", + "decorator 4.3.0 py36_0", + "incremental 17.5.0 py36_0", + "urllib3 1.23 py36_0", + "ipywidgets 7.4.1 py36_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "ply 3.11 py36_0", + "alabaster 0.7.11 py36_0", + "partd 0.3.8 py36_0", + "pylint 2.1.1 py36_0", + "anaconda-project 0.8.2 py36_0", + "hdf5 1.10.2 hba1933b_1", + "pandas 0.23.4 py36h04863e7_0", + "blaze 0.11.3 py36_0", + "pyodbc 4.0.24 py36he6710b0_0", + "wcwidth 0.1.7 py36_0", + "locket 0.2.0 py36_1", + "intel-openmp 2019.0 118", + "pyqt 5.9.2 py36h05f1152_2", + "pytest 3.8.0 py36_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "pyzmq 17.1.2 py36h14c3975_0", + "flask 1.0.2 py36_1", + "sortedcontainers 2.0.5 py36_0", + "unixodbc 2.3.7 h14c3975_0", + "rope 0.11.0 py36_0", + "pep8 1.7.1 py36_0", + "pyyaml 3.13 py36h14c3975_0", + "patchelf 0.9 hf484d3e_2", + "mpfr 4.0.1 hdf1c602_3", + "contextlib2 0.5.5 py36_0", + "defusedxml 0.5.0 py36_1", + "keyring 13.2.1 py36_0", + "jpeg 9b h024ee3a_2", + "mkl_random 1.0.1 py36h4414c95_1", + "fontconfig 2.13.0 h9420a91_0", + "libffi 3.2.1 hd88cf55_4", + "pandocfilters 1.4.2 py36_1", + "singledispatch 3.4.0.3 py36_0", + "libcurl 7.61.0 h1ad7b7a_0", + "pluggy 0.7.1 py36h28b3542_0", + "mistune 0.8.3 py36h14c3975_1", + "xlsxwriter 1.1.0 py36_0", + "attrs 18.2.0 py36h28b3542_0", + "pycurl 7.43.0.2 py36hb7f436b_0", + "pathlib2 2.3.2 py36_0", + "get_terminal_size 1.0.0 haa9412d_0", + "pycrypto 2.6.1 py36h14c3975_9", + "pytest-doctestplus 0.1.3 py36_0", + "jedi 0.12.1 py36_0", + "cairo 1.14.12 h8948797_3", + "scipy 1.1.0 py36hfa4b5c9_1", + "anaconda-client 1.7.2 py36_0", + "bottleneck 1.2.1 py36h035aef0_1", + "libssh2 1.8.0 h9cfc8f7_4", + "beautifulsoup4 4.6.3 py36_0", + "msgpack-python 0.5.6 py36h6bb024c_1", + "readline 7.0 h7b6447c_5", + "isort 4.3.4 py36_0", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "chardet 3.0.4 py36_1", + "bleach 2.1.4 py36_0", + "setuptools 40.2.0 py36_0", + "atomicwrites 1.2.1 py36_0", + "mkl 2018.0.3 1" + ], + "license": "BSD", + "md5": "5c26a49477e06dbec58a83b89cede505", + "name": "anaconda", + "namespace": "python", + "sha256": "7ae114f4553997beafcac0efbfd016eb34137d57a17226f0ce2e8a06504ec963", + "size": 11443, + "subdir": "linux-64", + "timestamp": 1538077226235, + "version": "5.3.0" + }, + "anaconda-5.3.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "requests 2.19.1 py36_0", + "appdirs 1.4.3 py36h28b3542_0", + "h5py 2.8.0 py36h989c5e5_3", + "send2trash 1.5.0 py36_0", + "psutil 5.4.7 py36h14c3975_0", + "backports.shutil_get_terminal_size 1.0.0 py36_2", + "qtpy 1.5.0 py36_0", + "jupyter_client 5.2.3 py36_0", + "filelock 3.0.8 py36_0", + "pycodestyle 2.4.0 py36_0", + "multipledispatch 0.6.0 py36_0", + "cryptography 2.3.1 py36hc365091_0", + "pytables 3.4.4 py36ha205bf6_0", + "curl 7.61.0 h84994c4_0", + "et_xmlfile 1.0.1 py36_0", + "pycosat 0.6.3 py36h14c3975_0", + "tblib 1.3.2 py36_0", + "spyder-kernels 0.2.6 py36_0", + "blosc 1.14.4 hdbcaa40_0", + "pkginfo 1.4.2 py36_1", + "unicodecsv 0.14.1 py36_0", + "babel 2.6.0 py36_0", + "sqlite 3.24.0 h84994c4_0", + "colorama 0.3.9 py36_0", + "dask-core 0.19.1 py36_0", + "pango 1.42.4 h049681c_0", + "nbconvert 5.4.0 py36_1", + "cytoolz 0.9.0.1 py36h14c3975_1", + "twisted 18.7.0 py36h14c3975_1", + "automat 0.7.0 py36_0", + "llvmlite 0.24.0 py36hdbcaa40_0", + "openssl 1.0.2p h14c3975_0", + "toolz 0.9.0 py36_0", + "gevent 1.3.6 py36h7b6447c_0", + "entrypoints 0.2.3 py36_2", + "pytest-openfiles 0.3.0 py36_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "prometheus_client 0.3.1 py36h28b3542_0", + "jeepney 0.3.1 py36_0", + "nltk 3.3.0 py36_0", + "ipython_genutils 0.2.0 py36_0", + "zlib 1.2.11 ha838bed_2", + "pywavelets 1.0.0 py36hdd07704_0", + "mccabe 0.6.1 py36_1", + "certifi 2018.8.24 py36_1", + "numexpr 2.6.8 py36hd89afb7_0", + "backports 1.0 py36_1", + "mkl_fft 1.0.4 py36h4414c95_1", + "glib 2.56.2 hd408876_0", + "tornado 5.1 py36h14c3975_0", + "zeromq 4.2.5 hf484d3e_1", + "notebook 5.6.0 py36_0", + "datashape 0.5.4 py36_1", + "bitarray 0.8.3 py36h14c3975_0", + "icu 58.2 h9c2bf20_1", + "six 1.11.0 py36_1", + "jupyter_core 4.4.0 py36_0", + "libtool 2.4.6 h544aabb_3", + "ipython 6.5.0 py36_0", + "fastcache 1.0.2 py36h14c3975_2", + "greenlet 0.4.15 py36h7b6447c_0", + "werkzeug 0.14.1 py36_0", + "flask-cors 3.0.6 py36_0", + "matplotlib 2.2.3 py36hb69df0a_0", + "snowballstemmer 1.2.1 py36_0", + "qtawesome 0.4.4 py36_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py36h10f8cd9_2", + "pygments 2.2.0 py36_0", + "pyparsing 2.2.0 py36_1", + "freetype 2.9.1 h8a8886c_1", + "astroid 2.0.4 py36_0", + "pyasn1-modules 0.2.2 py36_0", + "sip 4.19.8 py36hf484d3e_0", + "service_identity 17.0.0 py36h28b3542_0", + "dbus 1.13.2 h714fa37_1", + "pytest-remotedata 0.3.0 py36_0", + "statsmodels 0.9.0 py36h035aef0_0", + "pillow 5.2.0 py36heded4f4_0", + "jinja2 2.10 py36_0", + "sqlalchemy 1.2.11 py36h7b6447c_0", + "wrapt 1.10.11 py36h14c3975_2", + "qt 5.9.6 h8703b6f_2", + "path.py 11.1.0 py36_0", + "dask 0.19.1 py36_0", + "pexpect 4.6.0 py36_0", + "jupyter 1.0.0 py36_7", + "odo 0.5.1 py36_0", + "pycparser 2.18 py36_1", + "snappy 1.1.7 hbae5bb6_3", + "parso 0.3.1 py36_0", + "html5lib 1.0.1 py36_0", + "itsdangerous 0.24 py36_1", + "libpng 1.6.34 hb9fc6fc_0", + "nose 1.3.7 py36_2", + "numba 0.39.0 py36h04863e7_0", + "packaging 17.1 py36_0", + "pyflakes 2.0.0 py36_0", + "mkl-service 1.1.2 py36h90e4bf4_5", + "nbformat 4.4.0 py36_0", + "sphinxcontrib-websupport 1.1.0 py36_1", + "cython 0.28.5 py36hf484d3e_0", + "lzo 2.10 h49e0be7_2", + "wheel 0.31.1 py36_0", + "python-dateutil 2.7.3 py36_0", + "patsy 0.5.0 py36_0", + "graphite2 1.3.12 h23475e2_2", + "pip 10.0.1 py36_0", + "webencodings 0.5.1 py36_1", + "gstreamer 1.14.0 hb453b48_1", + "python 3.6.6 hc3d631a_0", + "libgcc-ng 8.2.0 hdf63c60_1", + "secretstorage 3.1.0 py36_0", + "spyder 3.3.1 py36_1", + "heapdict 1.0.0 py36_2", + "idna 2.7 py36_0", + "libtiff 4.0.9 he85c1e1_2", + "more-itertools 4.3.0 py36_0", + "mpc 1.1.0 h10f8cd9_1", + "distributed 1.23.1 py36_0", + "constantly 15.1.0 py36h28b3542_0", + "fribidi 1.0.5 h7b6447c_0", + "clyent 1.2.2 py36_1", + "libxcb 1.13 h1bed415_1", + "pyasn1 0.4.4 py36h28b3542_0", + "ca-certificates 2018.03.07 0", + "bkcharts 0.2 py36_0", + "jdcal 1.4 py36_0", + "tk 8.6.8 hbc83047_0", + "docutils 0.14 py36_0", + "imageio 2.4.1 py36_0", + "boto 2.49.0 py36_0", + "libxslt 1.1.32 h1312cb7_0", + "imagesize 1.1.0 py36_0", + "click 6.7 py36_0", + "pytest-arraydiff 0.2 py36h39e3cac_0", + "asn1crypto 0.24.0 py36_0", + "markupsafe 1.0 py36h14c3975_1", + "scikit-learn 0.19.2 py36h4989274_0", + "scikit-image 0.14.0 py36hf484d3e_1", + "pickleshare 0.7.4 py36_0", + "libuuid 1.0.3 h1bed415_2", + "hyperlink 18.0.0 py36_0", + "glob2 0.6 py36_0", + "olefile 0.46 py36_0", + "lxml 4.2.5 py36hefd8a0e_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "numpy-base 1.15.1 py36h81de0dd_0", + "seaborn 0.9.0 py36_0", + "backcall 0.1.0 py36_0", + "mpmath 1.0.0 py36_2", + "sortedcollections 1.0.1 py36_0", + "sphinx 1.7.9 py36_0", + "yaml 0.1.7 had09818_2", + "blas 1.0 mkl", + "testpath 0.3.1 py36_0", + "lazy-object-proxy 1.3.1 py36h14c3975_2", + "astropy 3.0.4 py36h14c3975_0", + "ipykernel 4.9.0 py36_1", + "cffi 1.11.5 py36he75722e_1", + "sympy 1.2 py36_0", + "expat 2.2.6 he6710b0_0", + "networkx 2.1 py36_0", + "zope.interface 4.5.0 py36h14c3975_0", + "xz 5.2.4 h14c3975_4", + "pytest-astropy 0.4.0 py36_0", + "traitlets 4.3.2 py36_0", + "bzip2 1.0.6 h14c3975_5", + "py 1.6.0 py36_0", + "ncurses 6.1 hf484d3e_0", + "zict 0.1.3 py36_0", + "terminado 0.8.1 py36_1", + "jupyter_console 5.2.0 py36_1", + "numpy 1.15.1 py36h3b04361_0", + "jupyterlab_launcher 0.13.1 py36_0", + "libsodium 1.0.16 h1bed415_0", + "libedit 3.1.20170329 h6b74fdf_2", + "jsonschema 2.6.0 py36_0", + "pysocks 1.6.8 py36_0", + "bokeh 0.13.0 py36_0", + "typed-ast 1.1.0 py36h14c3975_0", + "jbig 2.1 hdba287a_0", + "kiwisolver 1.0.1 py36hf484d3e_0", + "cloudpickle 0.5.5 py36_0", + "libxml2 2.9.8 h26e45fe_1", + "pcre 8.42 h439df22_0", + "qtconsole 4.4.1 py36_0", + "zope 1.0 py36_1", + "simplegeneric 0.8.1 py36_2", + "widgetsnbextension 3.4.1 py36_0", + "cycler 0.10.0 py36_0", + "xlwt 1.3.0 py36_0", + "pytz 2018.5 py36_0", + "numpydoc 0.8.0 py36_0", + "sphinxcontrib 1.0 py36_1", + "pixman 0.34.0 hceecf20_3", + "prompt_toolkit 1.0.15 py36_0", + "pyopenssl 18.0.0 py36_0", + "ptyprocess 0.6.0 py36_0", + "xlrd 1.1.0 py36_1", + "ruamel_yaml 0.15.46 py36h14c3975_0", + "jupyterlab 0.34.9 py36_0", + "openpyxl 2.5.6 py36_0", + "tqdm 4.26.0 py36h28b3542_0", + "decorator 4.3.0 py36_0", + "incremental 17.5.0 py36_0", + "urllib3 1.23 py36_0", + "ipywidgets 7.4.1 py36_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "ply 3.11 py36_0", + "alabaster 0.7.11 py36_0", + "partd 0.3.8 py36_0", + "pylint 2.1.1 py36_0", + "anaconda-project 0.8.2 py36_0", + "hdf5 1.10.2 hba1933b_1", + "pandas 0.23.4 py36h04863e7_0", + "blaze 0.11.3 py36_0", + "pyodbc 4.0.24 py36he6710b0_0", + "wcwidth 0.1.7 py36_0", + "locket 0.2.0 py36_1", + "intel-openmp 2019.0 118", + "pyqt 5.9.2 py36h05f1152_2", + "pytest 3.8.0 py36_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "pyzmq 17.1.2 py36h14c3975_0", + "flask 1.0.2 py36_1", + "sortedcontainers 2.0.5 py36_0", + "unixodbc 2.3.7 h14c3975_0", + "rope 0.11.0 py36_0", + "pep8 1.7.1 py36_0", + "pyyaml 3.13 py36h14c3975_0", + "patchelf 0.9 hf484d3e_2", + "mpfr 4.0.1 hdf1c602_3", + "contextlib2 0.5.5 py36_0", + "defusedxml 0.5.0 py36_1", + "keyring 13.2.1 py36_0", + "jpeg 9b h024ee3a_2", + "mkl_random 1.0.1 py36h4414c95_1", + "fontconfig 2.13.0 h9420a91_0", + "libffi 3.2.1 hd88cf55_4", + "pandocfilters 1.4.2 py36_1", + "singledispatch 3.4.0.3 py36_0", + "libcurl 7.61.0 h1ad7b7a_0", + "pluggy 0.7.1 py36h28b3542_0", + "mistune 0.8.3 py36h14c3975_1", + "xlsxwriter 1.1.0 py36_0", + "attrs 18.2.0 py36h28b3542_0", + "pycurl 7.43.0.2 py36hb7f436b_0", + "pathlib2 2.3.2 py36_0", + "mkl 2018.0.3 1", + "get_terminal_size 1.0.0 haa9412d_0", + "pycrypto 2.6.1 py36h14c3975_9", + "pytest-doctestplus 0.1.3 py36_0", + "jedi 0.12.1 py36_0", + "cairo 1.14.12 h8948797_3", + "scipy 1.1.0 py36hfa4b5c9_1", + "anaconda-client 1.7.2 py36_0", + "bottleneck 1.2.1 py36h035aef0_1", + "libssh2 1.8.0 h9cfc8f7_4", + "beautifulsoup4 4.6.3 py36_0", + "msgpack-python 0.5.6 py36h6bb024c_1", + "readline 7.0 h7b6447c_5", + "isort 4.3.4 py36_0", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "chardet 3.0.4 py36_1", + "bleach 2.1.4 py36_0", + "setuptools 40.2.0 py36_0", + "atomicwrites 1.2.1 py36_0" + ], + "license": "BSD", + "md5": "58eea87bb80f2b2e5f61d49a48e0e964", + "name": "anaconda", + "namespace": "python", + "sha256": "2b6220fe43ef15be5597bedc24cff80224fced5187333768024135daffd517f5", + "size": 11490, + "subdir": "linux-64", + "timestamp": 1538077226235, + "version": "5.3.0" + }, + "anaconda-5.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python-dateutil 2.7.3 py37_0", + "clyent 1.2.2 py37_1", + "alabaster 0.7.11 py37_0", + "numba 0.39.0 py37h04863e7_0", + "jpeg 9b h024ee3a_2", + "mpmath 1.0.0 py37_2", + "click 6.7 py37_0", + "fastcache 1.0.2 py37h14c3975_2", + "pycodestyle 2.4.0 py37_0", + "astropy 3.0.4 py37h14c3975_0", + "automat 0.7.0 py37_0", + "fribidi 1.0.5 h7b6447c_0", + "xlrd 1.1.0 py37_1", + "pytest 3.8.0 py37_0", + "parso 0.3.1 py37_0", + "isort 4.3.4 py37_0", + "pango 1.42.4 h049681c_0", + "libpng 1.6.34 hb9fc6fc_0", + "nltk 3.3.0 py37_0", + "pytest-astropy 0.4.0 py37_0", + "secretstorage 3.1.0 py37_0", + "incremental 17.5.0 py37_0", + "qtconsole 4.4.1 py37_0", + "jinja2 2.10 py37_0", + "prompt_toolkit 1.0.15 py37_0", + "appdirs 1.4.3 py37h28b3542_0", + "olefile 0.46 py37_0", + "setuptools 40.2.0 py37_0", + "msgpack-python 0.5.6 py37h6bb024c_1", + "qtawesome 0.4.4 py37_0", + "zeromq 4.2.5 hf484d3e_1", + "beautifulsoup4 4.6.3 py37_0", + "get_terminal_size 1.0.0 haa9412d_0", + "colorama 0.3.9 py37_0", + "six 1.11.0 py37_1", + "spyder-kernels 0.2.6 py37_0", + "ca-certificates 2018.03.07 0", + "gevent 1.3.6 py37h7b6447c_0", + "numpy 1.15.1 py37h1d66e8a_0", + "pytest-arraydiff 0.2 py37h39e3cac_0", + "pyflakes 2.0.0 py37_0", + "hyperlink 18.0.0 py37_0", + "pyzmq 17.1.2 py37h14c3975_0", + "tk 8.6.8 hbc83047_0", + "statsmodels 0.9.0 py37h035aef0_0", + "flask 1.0.2 py37_1", + "cloudpickle 0.5.5 py37_0", + "pexpect 4.6.0 py37_0", + "jupyter_core 4.4.0 py37_0", + "wheel 0.31.1 py37_0", + "ipykernel 4.9.0 py37_1", + "werkzeug 0.14.1 py37_0", + "numexpr 2.6.8 py37hd89afb7_0", + "pickleshare 0.7.4 py37_0", + "libxslt 1.1.32 h1312cb7_0", + "xlwt 1.3.0 py37_0", + "cytoolz 0.9.0.1 py37h14c3975_1", + "imagesize 1.1.0 py37_0", + "pygments 2.2.0 py37_0", + "dbus 1.13.2 h714fa37_1", + "pytz 2018.5 py37_0", + "hdf5 1.10.2 hba1933b_1", + "webencodings 0.5.1 py37_1", + "ipywidgets 7.4.1 py37_0", + "nose 1.3.7 py37_2", + "openssl 1.0.2p h14c3975_0", + "py 1.6.0 py37_0", + "pytest-doctestplus 0.1.3 py37_0", + "bkcharts 0.2 py37_0", + "jupyterlab_launcher 0.13.1 py37_0", + "libtool 2.4.6 h544aabb_3", + "pytest-openfiles 0.3.0 py37_0", + "send2trash 1.5.0 py37_0", + "pathlib2 2.3.2 py37_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "qtpy 1.5.0 py37_0", + "locket 0.2.0 py37_1", + "ipython 6.5.0 py37_0", + "yaml 0.1.7 had09818_2", + "greenlet 0.4.15 py37h7b6447c_0", + "backcall 0.1.0 py37_0", + "dask 0.19.1 py37_0", + "toolz 0.9.0 py37_0", + "xlsxwriter 1.1.0 py37_0", + "gmpy2 2.0.8 py37h10f8cd9_2", + "cython 0.28.5 py37hf484d3e_0", + "nbconvert 5.4.0 py37_1", + "pillow 5.2.0 py37heded4f4_0", + "sphinxcontrib-websupport 1.1.0 py37_1", + "zope.interface 4.5.0 py37h14c3975_0", + "mpc 1.1.0 h10f8cd9_1", + "wcwidth 0.1.7 py37_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "itsdangerous 0.24 py37_1", + "pyparsing 2.2.0 py37_1", + "odo 0.5.1 py37_0", + "sortedcontainers 2.0.5 py37_0", + "libxml2 2.9.8 h26e45fe_1", + "ply 3.11 py37_0", + "ptyprocess 0.6.0 py37_0", + "python 3.7.0 hc3d631a_0", + "cffi 1.11.5 py37he75722e_1", + "et_xmlfile 1.0.1 py37_0", + "expat 2.2.6 he6710b0_0", + "cycler 0.10.0 py37_0", + "ncurses 6.1 hf484d3e_0", + "simplegeneric 0.8.1 py37_2", + "numpy-base 1.15.1 py37h81de0dd_0", + "mkl-service 1.1.2 py37h90e4bf4_5", + "asn1crypto 0.24.0 py37_0", + "bleach 2.1.4 py37_0", + "service_identity 17.0.0 py37h28b3542_0", + "pyqt 5.9.2 py37h05f1152_2", + "blaze 0.11.3 py37_0", + "jdcal 1.4 py37_0", + "path.py 11.1.0 py37_0", + "widgetsnbextension 3.4.1 py37_0", + "idna 2.7 py37_0", + "lazy-object-proxy 1.3.1 py37h14c3975_2", + "markupsafe 1.0 py37h14c3975_1", + "glob2 0.6 py37_0", + "ruamel_yaml 0.15.46 py37h14c3975_0", + "snappy 1.1.7 hbae5bb6_3", + "sympy 1.2 py37_0", + "libgcc-ng 8.2.0 hdf63c60_1", + "jupyter 1.0.0 py37_7", + "decorator 4.3.0 py37_0", + "libsodium 1.0.16 h1bed415_0", + "mccabe 0.6.1 py37_1", + "zlib 1.2.11 ha838bed_2", + "harfbuzz 1.8.8 hffaf4a1_0", + "prometheus_client 0.3.1 py37h28b3542_0", + "intel-openmp 2019.0 118", + "patchelf 0.9 hf484d3e_2", + "testpath 0.3.1 py37_0", + "cairo 1.14.12 h8948797_3", + "constantly 15.1.0 py37h28b3542_0", + "mpfr 4.0.1 hdf1c602_3", + "twisted 18.7.0 py37h14c3975_1", + "cryptography 2.3.1 py37hc365091_0", + "jbig 2.1 hdba287a_0", + "bottleneck 1.2.1 py37h035aef0_1", + "backports 1.0 py37_1", + "pluggy 0.7.1 py37h28b3542_0", + "patsy 0.5.0 py37_0", + "spyder 3.3.1 py37_1", + "pycrypto 2.6.1 py37h14c3975_9", + "sqlalchemy 1.2.11 py37h7b6447c_0", + "matplotlib 2.2.3 py37hb69df0a_0", + "sip 4.19.8 py37hf484d3e_0", + "pylint 2.1.1 py37_0", + "pywavelets 1.0.0 py37hdd07704_0", + "tqdm 4.26.0 py37h28b3542_0", + "qt 5.9.6 h8703b6f_2", + "networkx 2.1 py37_0", + "zict 0.1.3 py37_0", + "defusedxml 0.5.0 py37_1", + "libffi 3.2.1 hd88cf55_4", + "distributed 1.23.1 py37_0", + "more-itertools 4.3.0 py37_0", + "bzip2 1.0.6 h14c3975_5", + "jupyter_console 5.2.0 py37_1", + "numpydoc 0.8.0 py37_0", + "urllib3 1.23 py37_0", + "pyodbc 4.0.24 py37he6710b0_0", + "pyasn1 0.4.4 py37h28b3542_0", + "babel 2.6.0 py37_0", + "anaconda-project 0.8.2 py37_0", + "sqlite 3.24.0 h84994c4_0", + "tornado 5.1 py37h14c3975_0", + "requests 2.19.1 py37_0", + "libcurl 7.61.0 h1ad7b7a_0", + "fontconfig 2.13.0 h9420a91_0", + "gstreamer 1.14.0 hb453b48_1", + "jupyter_client 5.2.3 py37_0", + "pyopenssl 18.0.0 py37_0", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "seaborn 0.9.0 py37_0", + "bitarray 0.8.3 py37h14c3975_0", + "llvmlite 0.24.0 py37hdbcaa40_0", + "tblib 1.3.2 py37_0", + "lxml 4.2.5 py37hefd8a0e_0", + "libxcb 1.13 h1bed415_1", + "icu 58.2 h9c2bf20_1", + "pytables 3.4.4 py37ha205bf6_0", + "attrs 18.2.0 py37h28b3542_0", + "singledispatch 3.4.0.3 py37_0", + "unixodbc 2.3.7 h14c3975_0", + "heapdict 1.0.0 py37_2", + "pycosat 0.6.3 py37h14c3975_0", + "curl 7.61.0 h84994c4_0", + "pandocfilters 1.4.2 py37_1", + "pandoc 1.19.2.1 hea2e7c5_1", + "docutils 0.14 py37_0", + "entrypoints 0.2.3 py37_2", + "jeepney 0.3.1 py37_0", + "lzo 2.10 h49e0be7_2", + "pip 10.0.1 py37_0", + "notebook 5.6.0 py37_0", + "scikit-learn 0.19.2 py37h4989274_0", + "unicodecsv 0.14.1 py37_0", + "mkl_random 1.0.1 py37h4414c95_1", + "partd 0.3.8 py37_0", + "libtiff 4.0.9 he85c1e1_2", + "atomicwrites 1.2.1 py37_0", + "graphite2 1.3.12 h23475e2_2", + "zope 1.0 py37_1", + "flask-cors 3.0.6 py37_0", + "blosc 1.14.4 hdbcaa40_0", + "boto 2.49.0 py37_0", + "multipledispatch 0.6.0 py37_0", + "ipython_genutils 0.2.0 py37_0", + "certifi 2018.8.24 py37_1", + "freetype 2.9.1 h8a8886c_1", + "dask-core 0.19.1 py37_0", + "terminado 0.8.1 py37_1", + "glib 2.56.2 hd408876_0", + "sortedcollections 1.0.1 py37_0", + "anaconda-client 1.7.2 py37_0", + "pysocks 1.6.8 py37_0", + "scikit-image 0.14.0 py37hf484d3e_1", + "bokeh 0.13.0 py37_0", + "pyasn1-modules 0.2.2 py37_0", + "libuuid 1.0.3 h1bed415_2", + "h5py 2.8.0 py37h989c5e5_3", + "pyyaml 3.13 py37h14c3975_0", + "jupyterlab 0.34.9 py37_0", + "packaging 17.1 py37_0", + "readline 7.0 h7b6447c_5", + "libssh2 1.8.0 h9cfc8f7_4", + "pixman 0.34.0 hceecf20_3", + "jsonschema 2.6.0 py37_0", + "contextlib2 0.5.5 py37_0", + "pcre 8.42 h439df22_0", + "wrapt 1.10.11 py37h14c3975_2", + "blas 1.0 mkl", + "rope 0.11.0 py37_0", + "astroid 2.0.4 py37_0", + "pandas 0.23.4 py37h04863e7_0", + "gmp 6.1.2 h6c8ec71_1", + "mkl_fft 1.0.4 py37h4414c95_1", + "jedi 0.12.1 py37_0", + "sphinxcontrib 1.0 py37_1", + "openpyxl 2.5.6 py37_0", + "sphinx 1.7.9 py37_0", + "html5lib 1.0.1 py37_0", + "filelock 3.0.8 py37_0", + "imageio 2.4.1 py37_0", + "chardet 3.0.4 py37_1", + "mistune 0.8.3 py37h14c3975_1", + "pytest-remotedata 0.3.0 py37_0", + "libedit 3.1.20170329 h6b74fdf_2", + "keyring 13.2.1 py37_0", + "kiwisolver 1.0.1 py37hf484d3e_0", + "xz 5.2.4 h14c3975_4", + "pkginfo 1.4.2 py37_1", + "nbformat 4.4.0 py37_0", + "pycurl 7.43.0.2 py37hb7f436b_0", + "traitlets 4.3.2 py37_0", + "datashape 0.5.4 py37_1", + "scipy 1.1.0 py37hfa4b5c9_1", + "pep8 1.7.1 py37_0", + "snowballstemmer 1.2.1 py37_0", + "pycparser 2.18 py37_1", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "psutil 5.4.7 py37h14c3975_0", + "mkl 2018.0.3 1" + ], + "license": "BSD", + "md5": "8027d3f9b3c2b5fdaa1154c9b7b24908", + "name": "anaconda", + "namespace": "python", + "sha256": "4e6ba5358bd0c3ba38643ca51eabf39c4f4b747b54ce034fccb1184c498ed8a2", + "size": 11385, + "subdir": "linux-64", + "timestamp": 1537856603411, + "version": "5.3.0" + }, + "anaconda-5.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bzip2 1.0.6 h14c3975_5", + "jupyter 1.0.0 py27_7", + "snappy 1.1.7 hbae5bb6_3", + "bitarray 0.8.3 py27h14c3975_0", + "qtawesome 0.4.4 py27_0", + "msgpack-python 0.5.6 py27h6bb024c_1", + "clyent 1.2.2 py27_1", + "flask-cors 3.0.6 py27_0", + "gstreamer 1.14.0 hb453b48_1", + "libedit 3.1.20170329 h6b74fdf_2", + "lzo 2.10 h49e0be7_2", + "filelock 3.0.8 py27_0", + "sphinx 1.7.9 py27_0", + "intel-openmp 2019.0 118", + "bkcharts 0.2 py27_0", + "subprocess32 3.5.2 py27h14c3975_0", + "yaml 0.1.7 had09818_2", + "atomicwrites 1.2.1 py27_0", + "pexpect 4.6.0 py27_0", + "funcsigs 1.0.2 py27_0", + "isort 4.3.4 py27_0", + "h5py 2.8.0 py27h989c5e5_3", + "openssl 1.0.2p h14c3975_0", + "pycurl 7.43.0.2 py27hb7f436b_0", + "pyflakes 2.0.0 py27_0", + "astropy 2.0.8 py27h035aef0_0", + "contextlib2 0.5.5 py27_0", + "xlwt 1.3.0 py27_0", + "numpy 1.15.1 py27h1d66e8a_0", + "hyperlink 18.0.0 py27_0", + "backports.functools_lru_cache 1.5 py27_1", + "scikit-image 0.14.0 py27hf484d3e_1", + "beautifulsoup4 4.6.3 py27_0", + "chardet 3.0.4 py27_1", + "get_terminal_size 1.0.0 haa9412d_0", + "xlsxwriter 1.1.0 py27_0", + "alabaster 0.7.11 py27_0", + "mpfr 4.0.1 hdf1c602_3", + "prompt_toolkit 1.0.15 py27_0", + "dask 0.19.1 py27_0", + "pyodbc 4.0.24 py27he6710b0_0", + "pyzmq 17.1.2 py27h14c3975_0", + "ruamel_yaml 0.15.46 py27h14c3975_0", + "partd 0.3.8 py27_0", + "datashape 0.5.4 py27_1", + "greenlet 0.4.15 py27h7b6447c_0", + "more-itertools 4.3.0 py27_0", + "libtiff 4.0.9 he85c1e1_2", + "incremental 17.5.0 py27_0", + "lazy-object-proxy 1.3.1 py27h14c3975_2", + "mpc 1.1.0 h10f8cd9_1", + "ipython_genutils 0.2.0 py27_0", + "scipy 1.1.0 py27hfa4b5c9_1", + "sortedcontainers 2.0.5 py27_0", + "nose 1.3.7 py27_2", + "locket 0.2.0 py27_1", + "imageio 2.4.1 py27_0", + "ca-certificates 2018.03.07 0", + "pytz 2018.5 py27_0", + "twisted 18.7.0 py27h14c3975_1", + "zope 1.0 py27_1", + "jsonschema 2.6.0 py27_0", + "pywavelets 1.0.0 py27hdd07704_0", + "odo 0.5.1 py27_0", + "pycodestyle 2.4.0 py27_0", + "gmp 6.1.2 h6c8ec71_1", + "notebook 5.6.0 py27_0", + "futures 3.2.0 py27_0", + "sphinxcontrib-websupport 1.1.0 py27_1", + "toolz 0.9.0 py27_0", + "pkginfo 1.4.2 py27_1", + "traceback2 1.4.0 py27_0", + "pcre 8.42 h439df22_0", + "numba 0.39.0 py27h04863e7_0", + "libssh2 1.8.0 h9cfc8f7_4", + "bleach 2.1.4 py27_0", + "typing 3.6.6 py27_0", + "markupsafe 1.0 py27h14c3975_1", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "icu 58.2 h9c2bf20_1", + "cloudpickle 0.5.5 py27_0", + "cycler 0.10.0 py27_0", + "nltk 3.3.0 py27_0", + "testpath 0.3.1 py27_0", + "idna 2.7 py27_0", + "unittest2 1.1.0 py27_0", + "glob2 0.6 py27_0", + "pytables 3.4.4 py27ha205bf6_0", + "networkx 2.1 py27_0", + "singledispatch 3.4.0.3 py27_0", + "patsy 0.5.0 py27_0", + "pyyaml 3.13 py27h14c3975_0", + "simplegeneric 0.8.1 py27_2", + "scandir 1.9.0 py27h14c3975_0", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "unicodecsv 0.14.1 py27_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 8.2.0 hdf63c60_1", + "jbig 2.1 hdba287a_0", + "jupyter_client 5.2.3 py27_0", + "astroid 1.6.5 py27_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "parso 0.3.1 py27_0", + "pandocfilters 1.4.2 py27_1", + "terminado 0.8.1 py27_1", + "entrypoints 0.2.3 py27_2", + "widgetsnbextension 3.4.1 py27_0", + "libxslt 1.1.32 h1312cb7_0", + "pyasn1 0.4.4 py27h28b3542_0", + "graphite2 1.3.12 h23475e2_2", + "python 2.7.15 h1571d57_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "colorama 0.3.9 py27_0", + "libpng 1.6.34 hb9fc6fc_0", + "constantly 15.1.0 py27h28b3542_0", + "wheel 0.31.1 py27_0", + "matplotlib 2.2.3 py27hb69df0a_0", + "jpeg 9b h024ee3a_2", + "ncurses 6.1 hf484d3e_0", + "itsdangerous 0.24 py27_1", + "linecache2 1.0.0 py27_0", + "multipledispatch 0.6.0 py27_0", + "sip 4.19.8 py27hf484d3e_0", + "ipython 5.8.0 py27_0", + "defusedxml 0.5.0 py27_1", + "cython 0.28.5 py27hf484d3e_0", + "tornado 5.1 py27h14c3975_0", + "pango 1.42.4 h049681c_0", + "cryptography 2.3.1 py27hc365091_0", + "sqlalchemy 1.2.11 py27h7b6447c_0", + "service_identity 17.0.0 py27h28b3542_0", + "python-dateutil 2.7.3 py27_0", + "sympy 1.2 py27_0", + "requests 2.19.1 py27_0", + "libcurl 7.61.0 h1ad7b7a_0", + "grin 1.2.1 py27_4", + "pylint 1.9.2 py27_0", + "decorator 4.3.0 py27_0", + "xz 5.2.4 h14c3975_4", + "qtconsole 4.4.1 py27_0", + "gmpy2 2.0.8 py27h10f8cd9_2", + "ipaddress 1.0.22 py27_0", + "py 1.6.0 py27_0", + "imagesize 1.1.0 py27_0", + "pluggy 0.7.1 py27h28b3542_0", + "pandas 0.23.4 py27h04863e7_0", + "cffi 1.11.5 py27he75722e_1", + "harfbuzz 1.8.8 hffaf4a1_0", + "pixman 0.34.0 hceecf20_3", + "html5lib 1.0.1 py27_0", + "kiwisolver 1.0.1 py27hf484d3e_0", + "pickleshare 0.7.4 py27_0", + "glib 2.56.2 hd408876_0", + "dbus 1.13.2 h714fa37_1", + "jinja2 2.10 py27_0", + "prometheus_client 0.3.1 py27h28b3542_0", + "jupyter_core 4.4.0 py27_0", + "backports_abc 0.5 py27_0", + "pip 10.0.1 py27_0", + "ipykernel 4.9.0 py27_1", + "jdcal 1.4 py27_0", + "blosc 1.14.4 hdbcaa40_0", + "asn1crypto 0.24.0 py27_0", + "click 6.7 py27_0", + "dask-core 0.19.1 py27_0", + "packaging 17.1 py27_0", + "pycosat 0.6.3 py27h14c3975_0", + "appdirs 1.4.3 py27h28b3542_0", + "curl 7.61.0 h84994c4_0", + "snowballstemmer 1.2.1 py27_0", + "setuptools 40.2.0 py27_0", + "readline 7.0 h7b6447c_5", + "automat 0.7.0 py27_0", + "spyder-kernels 0.2.6 py27_0", + "ipywidgets 7.4.1 py27_0", + "lxml 4.2.5 py27hefd8a0e_0", + "pyopenssl 18.0.0 py27_0", + "seaborn 0.9.0 py27_0", + "jupyter_console 5.2.0 py27_1", + "rope 0.11.0 py27_0", + "olefile 0.46 py27_0", + "numpydoc 0.8.0 py27_0", + "pyparsing 2.2.0 py27_1", + "ptyprocess 0.6.0 py27_0", + "nbformat 4.4.0 py27_0", + "cytoolz 0.9.0.1 py27h14c3975_1", + "webencodings 0.5.1 py27_1", + "libsodium 1.0.16 h1bed415_0", + "functools32 3.2.3.2 py27_1", + "statsmodels 0.9.0 py27h035aef0_0", + "flask 1.0.2 py27_1", + "docutils 0.14 py27_0", + "llvmlite 0.24.0 py27hdbcaa40_0", + "attrs 18.2.0 py27h28b3542_0", + "pygments 2.2.0 py27_0", + "mccabe 0.6.1 py27_1", + "backports.shutil_get_terminal_size 1.0.0 py27_2", + "six 1.11.0 py27_1", + "pytest 3.8.0 py27_0", + "blaze 0.11.3 py27_0", + "et_xmlfile 1.0.1 py27_0", + "spyder 3.3.1 py27_1", + "fastcache 1.0.2 py27h14c3975_2", + "unixodbc 2.3.7 h14c3975_0", + "numexpr 2.6.8 py27hd89afb7_0", + "ply 3.11 py27_0", + "numpy-base 1.15.1 py27h81de0dd_0", + "wrapt 1.10.11 py27h14c3975_2", + "tblib 1.3.2 py27_0", + "freetype 2.9.1 h8a8886c_1", + "qt 5.9.6 h8703b6f_2", + "cairo 1.14.12 h8948797_3", + "pep8 1.7.1 py27_0", + "certifi 2018.8.24 py27_1", + "psutil 5.4.7 py27h14c3975_0", + "heapdict 1.0.0 py27_2", + "mpmath 1.0.0 py27_2", + "ssl_match_hostname 3.5.0.1 py27_2", + "boto 2.49.0 py27_0", + "mistune 0.8.3 py27h14c3975_1", + "babel 2.6.0 py27_0", + "mkl_fft 1.0.4 py27h4414c95_1", + "anaconda-client 1.7.2 py27_0", + "urllib3 1.23 py27_0", + "zlib 1.2.11 ha838bed_2", + "xlrd 1.1.0 py27_1", + "sqlite 3.24.0 h84994c4_0", + "bottleneck 1.2.1 py27h035aef0_1", + "zope.interface 4.5.0 py27h14c3975_0", + "expat 2.2.6 he6710b0_0", + "pysocks 1.6.8 py27_0", + "bokeh 0.13.0 py27_0", + "fribidi 1.0.5 h7b6447c_0", + "pathlib2 2.3.2 py27_0", + "jupyterlab 0.33.11 py27_0", + "enum34 1.1.6 py27_1", + "cdecimal 2.3 py27h14c3975_3", + "configparser 3.5.0 py27_0", + "patchelf 0.9 hf484d3e_2", + "sortedcollections 1.0.1 py27_0", + "nbconvert 5.4.0 py27_1", + "anaconda-project 0.8.2 py27_0", + "libtool 2.4.6 h544aabb_3", + "werkzeug 0.14.1 py27_0", + "fontconfig 2.13.0 h9420a91_0", + "scikit-learn 0.19.2 py27h4989274_0", + "pycparser 2.18 py27_1", + "pycairo 1.17.1 py27h2a1e443_0", + "tk 8.6.8 hbc83047_0", + "jedi 0.12.1 py27_0", + "send2trash 1.5.0 py27_0", + "backports 1.0 py27_1", + "pycrypto 2.6.1 py27h14c3975_9", + "pyqt 5.9.2 py27h05f1152_2", + "qtpy 1.5.0 py27_0", + "libxcb 1.13 h1bed415_1", + "distributed 1.23.1 py27_0", + "pyasn1-modules 0.2.2 py27_0", + "libxml2 2.9.8 h26e45fe_1", + "mkl_random 1.0.1 py27h4414c95_1", + "hdf5 1.10.2 hba1933b_1", + "tqdm 4.26.0 py27h28b3542_0", + "path.py 11.1.0 py27_0", + "jupyterlab_launcher 0.11.2 py27h28b3542_0", + "libuuid 1.0.3 h1bed415_2", + "mkl-service 1.1.2 py27h90e4bf4_5", + "wcwidth 0.1.7 py27_0", + "traitlets 4.3.2 py27_0", + "zict 0.1.3 py27_0", + "zeromq 4.2.5 hf484d3e_1", + "openpyxl 2.5.6 py27_0", + "sphinxcontrib 1.0 py27_1", + "blas 1.0 mkl", + "pillow 5.2.0 py27heded4f4_0", + "gevent 1.3.6 py27h7b6447c_0", + "mkl 2018.0.3 1" + ], + "license": "BSD", + "md5": "83f5ace65ffcb52a212bf7400e272951", + "name": "anaconda", + "namespace": "python", + "sha256": "7547a18911667ba55529159260fe19416ab23053ecf926af9a21302387c92ddf", + "size": 11320, + "subdir": "linux-64", + "timestamp": 1541667463333, + "version": "5.3.1" + }, + "anaconda-5.3.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "bzip2 1.0.6 h14c3975_5", + "jupyter 1.0.0 py27_7", + "snappy 1.1.7 hbae5bb6_3", + "bitarray 0.8.3 py27h14c3975_0", + "mkl 2018.0.3 1", + "qtawesome 0.4.4 py27_0", + "msgpack-python 0.5.6 py27h6bb024c_1", + "clyent 1.2.2 py27_1", + "flask-cors 3.0.6 py27_0", + "gstreamer 1.14.0 hb453b48_1", + "libedit 3.1.20170329 h6b74fdf_2", + "lzo 2.10 h49e0be7_2", + "filelock 3.0.8 py27_0", + "sphinx 1.7.9 py27_0", + "intel-openmp 2019.0 118", + "bkcharts 0.2 py27_0", + "subprocess32 3.5.2 py27h14c3975_0", + "yaml 0.1.7 had09818_2", + "atomicwrites 1.2.1 py27_0", + "pexpect 4.6.0 py27_0", + "funcsigs 1.0.2 py27_0", + "isort 4.3.4 py27_0", + "h5py 2.8.0 py27h989c5e5_3", + "openssl 1.0.2p h14c3975_0", + "pycurl 7.43.0.2 py27hb7f436b_0", + "pyflakes 2.0.0 py27_0", + "astropy 2.0.8 py27h035aef0_0", + "contextlib2 0.5.5 py27_0", + "xlwt 1.3.0 py27_0", + "numpy 1.15.1 py27h3b04361_0", + "hyperlink 18.0.0 py27_0", + "backports.functools_lru_cache 1.5 py27_1", + "scikit-image 0.14.0 py27hf484d3e_1", + "beautifulsoup4 4.6.3 py27_0", + "chardet 3.0.4 py27_1", + "get_terminal_size 1.0.0 haa9412d_0", + "xlsxwriter 1.1.0 py27_0", + "alabaster 0.7.11 py27_0", + "mpfr 4.0.1 hdf1c602_3", + "prompt_toolkit 1.0.15 py27_0", + "dask 0.19.1 py27_0", + "pyodbc 4.0.24 py27he6710b0_0", + "pyzmq 17.1.2 py27h14c3975_0", + "ruamel_yaml 0.15.46 py27h14c3975_0", + "partd 0.3.8 py27_0", + "datashape 0.5.4 py27_1", + "greenlet 0.4.15 py27h7b6447c_0", + "more-itertools 4.3.0 py27_0", + "libtiff 4.0.9 he85c1e1_2", + "incremental 17.5.0 py27_0", + "lazy-object-proxy 1.3.1 py27h14c3975_2", + "mpc 1.1.0 h10f8cd9_1", + "ipython_genutils 0.2.0 py27_0", + "scipy 1.1.0 py27hfa4b5c9_1", + "sortedcontainers 2.0.5 py27_0", + "nose 1.3.7 py27_2", + "locket 0.2.0 py27_1", + "imageio 2.4.1 py27_0", + "ca-certificates 2018.03.07 0", + "pytz 2018.5 py27_0", + "twisted 18.7.0 py27h14c3975_1", + "zope 1.0 py27_1", + "jsonschema 2.6.0 py27_0", + "pywavelets 1.0.0 py27hdd07704_0", + "odo 0.5.1 py27_0", + "pycodestyle 2.4.0 py27_0", + "gmp 6.1.2 h6c8ec71_1", + "notebook 5.6.0 py27_0", + "futures 3.2.0 py27_0", + "sphinxcontrib-websupport 1.1.0 py27_1", + "toolz 0.9.0 py27_0", + "pkginfo 1.4.2 py27_1", + "traceback2 1.4.0 py27_0", + "pcre 8.42 h439df22_0", + "numba 0.39.0 py27h04863e7_0", + "libssh2 1.8.0 h9cfc8f7_4", + "bleach 2.1.4 py27_0", + "typing 3.6.6 py27_0", + "markupsafe 1.0 py27h14c3975_1", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "icu 58.2 h9c2bf20_1", + "cloudpickle 0.5.5 py27_0", + "cycler 0.10.0 py27_0", + "nltk 3.3.0 py27_0", + "testpath 0.3.1 py27_0", + "idna 2.7 py27_0", + "unittest2 1.1.0 py27_0", + "glob2 0.6 py27_0", + "pytables 3.4.4 py27ha205bf6_0", + "networkx 2.1 py27_0", + "singledispatch 3.4.0.3 py27_0", + "patsy 0.5.0 py27_0", + "pyyaml 3.13 py27h14c3975_0", + "simplegeneric 0.8.1 py27_2", + "scandir 1.9.0 py27h14c3975_0", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "unicodecsv 0.14.1 py27_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 8.2.0 hdf63c60_1", + "jbig 2.1 hdba287a_0", + "jupyter_client 5.2.3 py27_0", + "astroid 1.6.5 py27_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "parso 0.3.1 py27_0", + "pandocfilters 1.4.2 py27_1", + "terminado 0.8.1 py27_1", + "entrypoints 0.2.3 py27_2", + "widgetsnbextension 3.4.1 py27_0", + "libxslt 1.1.32 h1312cb7_0", + "pyasn1 0.4.4 py27h28b3542_0", + "graphite2 1.3.12 h23475e2_2", + "python 2.7.15 h1571d57_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "colorama 0.3.9 py27_0", + "libpng 1.6.34 hb9fc6fc_0", + "constantly 15.1.0 py27h28b3542_0", + "wheel 0.31.1 py27_0", + "matplotlib 2.2.3 py27hb69df0a_0", + "jpeg 9b h024ee3a_2", + "ncurses 6.1 hf484d3e_0", + "itsdangerous 0.24 py27_1", + "linecache2 1.0.0 py27_0", + "multipledispatch 0.6.0 py27_0", + "sip 4.19.8 py27hf484d3e_0", + "ipython 5.8.0 py27_0", + "defusedxml 0.5.0 py27_1", + "cython 0.28.5 py27hf484d3e_0", + "tornado 5.1 py27h14c3975_0", + "pango 1.42.4 h049681c_0", + "cryptography 2.3.1 py27hc365091_0", + "sqlalchemy 1.2.11 py27h7b6447c_0", + "service_identity 17.0.0 py27h28b3542_0", + "python-dateutil 2.7.3 py27_0", + "sympy 1.2 py27_0", + "requests 2.19.1 py27_0", + "libcurl 7.61.0 h1ad7b7a_0", + "grin 1.2.1 py27_4", + "pylint 1.9.2 py27_0", + "decorator 4.3.0 py27_0", + "xz 5.2.4 h14c3975_4", + "qtconsole 4.4.1 py27_0", + "gmpy2 2.0.8 py27h10f8cd9_2", + "ipaddress 1.0.22 py27_0", + "py 1.6.0 py27_0", + "imagesize 1.1.0 py27_0", + "pluggy 0.7.1 py27h28b3542_0", + "pandas 0.23.4 py27h04863e7_0", + "cffi 1.11.5 py27he75722e_1", + "harfbuzz 1.8.8 hffaf4a1_0", + "pixman 0.34.0 hceecf20_3", + "html5lib 1.0.1 py27_0", + "kiwisolver 1.0.1 py27hf484d3e_0", + "pickleshare 0.7.4 py27_0", + "glib 2.56.2 hd408876_0", + "dbus 1.13.2 h714fa37_1", + "jinja2 2.10 py27_0", + "prometheus_client 0.3.1 py27h28b3542_0", + "jupyter_core 4.4.0 py27_0", + "backports_abc 0.5 py27_0", + "pip 10.0.1 py27_0", + "ipykernel 4.9.0 py27_1", + "jdcal 1.4 py27_0", + "blosc 1.14.4 hdbcaa40_0", + "asn1crypto 0.24.0 py27_0", + "click 6.7 py27_0", + "dask-core 0.19.1 py27_0", + "packaging 17.1 py27_0", + "pycosat 0.6.3 py27h14c3975_0", + "appdirs 1.4.3 py27h28b3542_0", + "curl 7.61.0 h84994c4_0", + "snowballstemmer 1.2.1 py27_0", + "setuptools 40.2.0 py27_0", + "readline 7.0 h7b6447c_5", + "automat 0.7.0 py27_0", + "spyder-kernels 0.2.6 py27_0", + "ipywidgets 7.4.1 py27_0", + "lxml 4.2.5 py27hefd8a0e_0", + "pyopenssl 18.0.0 py27_0", + "seaborn 0.9.0 py27_0", + "jupyter_console 5.2.0 py27_1", + "rope 0.11.0 py27_0", + "olefile 0.46 py27_0", + "numpydoc 0.8.0 py27_0", + "pyparsing 2.2.0 py27_1", + "ptyprocess 0.6.0 py27_0", + "nbformat 4.4.0 py27_0", + "cytoolz 0.9.0.1 py27h14c3975_1", + "webencodings 0.5.1 py27_1", + "libsodium 1.0.16 h1bed415_0", + "functools32 3.2.3.2 py27_1", + "statsmodels 0.9.0 py27h035aef0_0", + "flask 1.0.2 py27_1", + "docutils 0.14 py27_0", + "llvmlite 0.24.0 py27hdbcaa40_0", + "attrs 18.2.0 py27h28b3542_0", + "pygments 2.2.0 py27_0", + "mccabe 0.6.1 py27_1", + "backports.shutil_get_terminal_size 1.0.0 py27_2", + "six 1.11.0 py27_1", + "pytest 3.8.0 py27_0", + "blaze 0.11.3 py27_0", + "et_xmlfile 1.0.1 py27_0", + "spyder 3.3.1 py27_1", + "fastcache 1.0.2 py27h14c3975_2", + "unixodbc 2.3.7 h14c3975_0", + "numexpr 2.6.8 py27hd89afb7_0", + "ply 3.11 py27_0", + "numpy-base 1.15.1 py27h81de0dd_0", + "wrapt 1.10.11 py27h14c3975_2", + "tblib 1.3.2 py27_0", + "freetype 2.9.1 h8a8886c_1", + "qt 5.9.6 h8703b6f_2", + "cairo 1.14.12 h8948797_3", + "pep8 1.7.1 py27_0", + "certifi 2018.8.24 py27_1", + "psutil 5.4.7 py27h14c3975_0", + "heapdict 1.0.0 py27_2", + "mpmath 1.0.0 py27_2", + "ssl_match_hostname 3.5.0.1 py27_2", + "boto 2.49.0 py27_0", + "mistune 0.8.3 py27h14c3975_1", + "babel 2.6.0 py27_0", + "mkl_fft 1.0.4 py27h4414c95_1", + "anaconda-client 1.7.2 py27_0", + "urllib3 1.23 py27_0", + "zlib 1.2.11 ha838bed_2", + "xlrd 1.1.0 py27_1", + "sqlite 3.24.0 h84994c4_0", + "bottleneck 1.2.1 py27h035aef0_1", + "zope.interface 4.5.0 py27h14c3975_0", + "expat 2.2.6 he6710b0_0", + "pysocks 1.6.8 py27_0", + "bokeh 0.13.0 py27_0", + "fribidi 1.0.5 h7b6447c_0", + "pathlib2 2.3.2 py27_0", + "jupyterlab 0.33.11 py27_0", + "enum34 1.1.6 py27_1", + "cdecimal 2.3 py27h14c3975_3", + "configparser 3.5.0 py27_0", + "patchelf 0.9 hf484d3e_2", + "sortedcollections 1.0.1 py27_0", + "nbconvert 5.4.0 py27_1", + "anaconda-project 0.8.2 py27_0", + "libtool 2.4.6 h544aabb_3", + "werkzeug 0.14.1 py27_0", + "fontconfig 2.13.0 h9420a91_0", + "scikit-learn 0.19.2 py27h4989274_0", + "pycparser 2.18 py27_1", + "pycairo 1.17.1 py27h2a1e443_0", + "tk 8.6.8 hbc83047_0", + "jedi 0.12.1 py27_0", + "send2trash 1.5.0 py27_0", + "backports 1.0 py27_1", + "pycrypto 2.6.1 py27h14c3975_9", + "pyqt 5.9.2 py27h05f1152_2", + "qtpy 1.5.0 py27_0", + "libxcb 1.13 h1bed415_1", + "distributed 1.23.1 py27_0", + "pyasn1-modules 0.2.2 py27_0", + "libxml2 2.9.8 h26e45fe_1", + "mkl_random 1.0.1 py27h4414c95_1", + "hdf5 1.10.2 hba1933b_1", + "tqdm 4.26.0 py27h28b3542_0", + "path.py 11.1.0 py27_0", + "jupyterlab_launcher 0.11.2 py27h28b3542_0", + "libuuid 1.0.3 h1bed415_2", + "mkl-service 1.1.2 py27h90e4bf4_5", + "wcwidth 0.1.7 py27_0", + "traitlets 4.3.2 py27_0", + "zict 0.1.3 py27_0", + "zeromq 4.2.5 hf484d3e_1", + "openpyxl 2.5.6 py27_0", + "sphinxcontrib 1.0 py27_1", + "blas 1.0 mkl", + "pillow 5.2.0 py27heded4f4_0", + "gevent 1.3.6 py27h7b6447c_0" + ], + "license": "BSD", + "md5": "637f34cafd6a3a5988c654845a1c697b", + "name": "anaconda", + "namespace": "python", + "sha256": "765ae5f754ed812e0a347870492d113c4fea0ec4492f4f29c61f89041722a09d", + "size": 11376, + "subdir": "linux-64", + "timestamp": 1541667463333, + "version": "5.3.1" + }, + "anaconda-5.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "intel-openmp 2019.0 118", + "libcurl 7.61.0 h1ad7b7a_0", + "nbconvert 5.4.0 py37_1", + "ncurses 6.1 hf484d3e_0", + "prometheus_client 0.3.1 py37h28b3542_0", + "libtool 2.4.6 h544aabb_3", + "numba 0.39.0 py37h04863e7_0", + "pip 10.0.1 py37_0", + "pyasn1-modules 0.2.2 py37_0", + "astropy 3.0.4 py37h14c3975_0", + "traitlets 4.3.2 py37_0", + "ipython_genutils 0.2.0 py37_0", + "backports 1.0 py37_1", + "colorama 0.3.9 py37_0", + "pygments 2.2.0 py37_0", + "parso 0.3.1 py37_0", + "tk 8.6.8 hbc83047_0", + "pytest-arraydiff 0.2 py37h39e3cac_0", + "jinja2 2.10 py37_0", + "jpeg 9b h024ee3a_2", + "click 6.7 py37_0", + "ca-certificates 2018.03.07 0", + "bitarray 0.8.3 py37h14c3975_0", + "libtiff 4.0.9 he85c1e1_2", + "markupsafe 1.0 py37h14c3975_1", + "simplegeneric 0.8.1 py37_2", + "backcall 0.1.0 py37_0", + "pyodbc 4.0.24 py37he6710b0_0", + "jupyterlab 0.34.9 py37_0", + "path.py 11.1.0 py37_0", + "unicodecsv 0.14.1 py37_0", + "mkl-service 1.1.2 py37h90e4bf4_5", + "alabaster 0.7.11 py37_0", + "olefile 0.46 py37_0", + "chardet 3.0.4 py37_1", + "patsy 0.5.0 py37_0", + "pandocfilters 1.4.2 py37_1", + "entrypoints 0.2.3 py37_2", + "pycparser 2.18 py37_1", + "itsdangerous 0.24 py37_1", + "zlib 1.2.11 ha838bed_2", + "pyopenssl 18.0.0 py37_0", + "secretstorage 3.1.0 py37_0", + "mpmath 1.0.0 py37_2", + "hdf5 1.10.2 hba1933b_1", + "pango 1.42.4 h049681c_0", + "libgcc-ng 8.2.0 hdf63c60_1", + "llvmlite 0.24.0 py37hdbcaa40_0", + "pytest-openfiles 0.3.0 py37_0", + "webencodings 0.5.1 py37_1", + "graphite2 1.3.12 h23475e2_2", + "docutils 0.14 py37_0", + "dask 0.19.1 py37_0", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "get_terminal_size 1.0.0 haa9412d_0", + "pytest 3.8.0 py37_0", + "openpyxl 2.5.6 py37_0", + "jbig 2.1 hdba287a_0", + "fontconfig 2.13.0 h9420a91_0", + "zict 0.1.3 py37_0", + "clyent 1.2.2 py37_1", + "jedi 0.12.1 py37_0", + "xz 5.2.4 h14c3975_4", + "notebook 5.6.0 py37_0", + "snappy 1.1.7 hbae5bb6_3", + "heapdict 1.0.0 py37_2", + "msgpack-python 0.5.6 py37h6bb024c_1", + "bottleneck 1.2.1 py37h035aef0_1", + "six 1.11.0 py37_1", + "h5py 2.8.0 py37h989c5e5_3", + "blas 1.0 mkl", + "pixman 0.34.0 hceecf20_3", + "requests 2.19.1 py37_0", + "sphinxcontrib-websupport 1.1.0 py37_1", + "ipywidgets 7.4.1 py37_0", + "tblib 1.3.2 py37_0", + "anaconda-project 0.8.2 py37_0", + "mkl_fft 1.0.4 py37h4414c95_1", + "packaging 17.1 py37_0", + "glib 2.56.2 hd408876_0", + "fastcache 1.0.2 py37h14c3975_2", + "curl 7.61.0 h84994c4_0", + "pexpect 4.6.0 py37_0", + "zeromq 4.2.5 hf484d3e_1", + "ipykernel 4.9.0 py37_1", + "libxml2 2.9.8 h26e45fe_1", + "sympy 1.2 py37_0", + "certifi 2018.8.24 py37_1", + "cycler 0.10.0 py37_0", + "asn1crypto 0.24.0 py37_0", + "icu 58.2 h9c2bf20_1", + "spyder-kernels 0.2.6 py37_0", + "terminado 0.8.1 py37_1", + "nbformat 4.4.0 py37_0", + "python 3.7.0 hc3d631a_0", + "qtawesome 0.4.4 py37_0", + "gevent 1.3.6 py37h7b6447c_0", + "mccabe 0.6.1 py37_1", + "widgetsnbextension 3.4.1 py37_0", + "fribidi 1.0.5 h7b6447c_0", + "kiwisolver 1.0.1 py37hf484d3e_0", + "patchelf 0.9 hf484d3e_2", + "pycurl 7.43.0.2 py37hb7f436b_0", + "libedit 3.1.20170329 h6b74fdf_2", + "pywavelets 1.0.0 py37hdd07704_0", + "send2trash 1.5.0 py37_0", + "greenlet 0.4.15 py37h7b6447c_0", + "numpy 1.15.1 py37h1d66e8a_0", + "jupyter_core 4.4.0 py37_0", + "pycrypto 2.6.1 py37h14c3975_9", + "bkcharts 0.2 py37_0", + "tornado 5.1 py37h14c3975_0", + "flask 1.0.2 py37_1", + "beautifulsoup4 4.6.3 py37_0", + "py 1.6.0 py37_0", + "pyzmq 17.1.2 py37h14c3975_0", + "pytest-astropy 0.4.0 py37_0", + "ipython 6.5.0 py37_0", + "distributed 1.23.1 py37_0", + "jupyterlab_launcher 0.13.1 py37_0", + "defusedxml 0.5.0 py37_1", + "singledispatch 3.4.0.3 py37_0", + "automat 0.7.0 py37_0", + "pytest-remotedata 0.3.0 py37_0", + "cloudpickle 0.5.5 py37_0", + "bleach 2.1.4 py37_0", + "yaml 0.1.7 had09818_2", + "libssh2 1.8.0 h9cfc8f7_4", + "attrs 18.2.0 py37h28b3542_0", + "xlrd 1.1.0 py37_1", + "statsmodels 0.9.0 py37h035aef0_0", + "dbus 1.13.2 h714fa37_1", + "networkx 2.1 py37_0", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "openssl 1.0.2p h14c3975_0", + "freetype 2.9.1 h8a8886c_1", + "pyflakes 2.0.0 py37_0", + "wheel 0.31.1 py37_0", + "filelock 3.0.8 py37_0", + "matplotlib 2.2.3 py37hb69df0a_0", + "tqdm 4.26.0 py37h28b3542_0", + "prompt_toolkit 1.0.15 py37_0", + "libffi 3.2.1 hd88cf55_4", + "pytz 2018.5 py37_0", + "html5lib 1.0.1 py37_0", + "nltk 3.3.0 py37_0", + "cytoolz 0.9.0.1 py37h14c3975_1", + "ply 3.11 py37_0", + "setuptools 40.2.0 py37_0", + "pytables 3.4.4 py37ha205bf6_0", + "pep8 1.7.1 py37_0", + "sphinxcontrib 1.0 py37_1", + "jdcal 1.4 py37_0", + "libpng 1.6.34 hb9fc6fc_0", + "pkginfo 1.4.2 py37_1", + "zope 1.0 py37_1", + "lxml 4.2.5 py37hefd8a0e_0", + "sphinx 1.7.9 py37_0", + "numpy-base 1.15.1 py37h81de0dd_0", + "scikit-learn 0.19.2 py37h4989274_0", + "jeepney 0.3.1 py37_0", + "cython 0.28.5 py37hf484d3e_0", + "numpydoc 0.8.0 py37_0", + "libxcb 1.13 h1bed415_1", + "ptyprocess 0.6.0 py37_0", + "wcwidth 0.1.7 py37_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "urllib3 1.23 py37_0", + "lazy-object-proxy 1.3.1 py37h14c3975_2", + "libuuid 1.0.3 h1bed415_2", + "sip 4.19.8 py37hf484d3e_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "astroid 2.0.4 py37_0", + "sqlalchemy 1.2.11 py37h7b6447c_0", + "qtconsole 4.4.1 py37_0", + "zope.interface 4.5.0 py37h14c3975_0", + "pyparsing 2.2.0 py37_1", + "unixodbc 2.3.7 h14c3975_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "jupyter_console 5.2.0 py37_1", + "sortedcollections 1.0.1 py37_0", + "pickleshare 0.7.4 py37_0", + "pycodestyle 2.4.0 py37_0", + "psutil 5.4.7 py37h14c3975_0", + "gmpy2 2.0.8 py37h10f8cd9_2", + "numexpr 2.6.8 py37hd89afb7_0", + "service_identity 17.0.0 py37h28b3542_0", + "nose 1.3.7 py37_2", + "wrapt 1.10.11 py37h14c3975_2", + "pillow 5.2.0 py37heded4f4_0", + "cffi 1.11.5 py37he75722e_1", + "werkzeug 0.14.1 py37_0", + "jupyter 1.0.0 py37_7", + "scipy 1.1.0 py37hfa4b5c9_1", + "scikit-image 0.14.0 py37hf484d3e_1", + "sortedcontainers 2.0.5 py37_0", + "flask-cors 3.0.6 py37_0", + "locket 0.2.0 py37_1", + "pyasn1 0.4.4 py37h28b3542_0", + "gmp 6.1.2 h6c8ec71_1", + "partd 0.3.8 py37_0", + "libsodium 1.0.16 h1bed415_0", + "gstreamer 1.14.0 hb453b48_1", + "twisted 18.7.0 py37h14c3975_1", + "pcre 8.42 h439df22_0", + "hyperlink 18.0.0 py37_0", + "qtpy 1.5.0 py37_0", + "pytest-doctestplus 0.1.3 py37_0", + "imageio 2.4.1 py37_0", + "qt 5.9.6 h8703b6f_2", + "xlsxwriter 1.1.0 py37_0", + "snowballstemmer 1.2.1 py37_0", + "pathlib2 2.3.2 py37_0", + "more-itertools 4.3.0 py37_0", + "atomicwrites 1.2.1 py37_0", + "blaze 0.11.3 py37_0", + "mpfr 4.0.1 hdf1c602_3", + "xlwt 1.3.0 py37_0", + "jsonschema 2.6.0 py37_0", + "constantly 15.1.0 py37h28b3542_0", + "mkl_random 1.0.1 py37h4414c95_1", + "spyder 3.3.1 py37_1", + "decorator 4.3.0 py37_0", + "anaconda-client 1.7.2 py37_0", + "pysocks 1.6.8 py37_0", + "pyqt 5.9.2 py37h05f1152_2", + "et_xmlfile 1.0.1 py37_0", + "pandas 0.23.4 py37h04863e7_0", + "sqlite 3.24.0 h84994c4_0", + "toolz 0.9.0 py37_0", + "babel 2.6.0 py37_0", + "mistune 0.8.3 py37h14c3975_1", + "harfbuzz 1.8.8 hffaf4a1_0", + "imagesize 1.1.0 py37_0", + "bzip2 1.0.6 h14c3975_5", + "readline 7.0 h7b6447c_5", + "idna 2.7 py37_0", + "odo 0.5.1 py37_0", + "multipledispatch 0.6.0 py37_0", + "python-dateutil 2.7.3 py37_0", + "rope 0.11.0 py37_0", + "cryptography 2.3.1 py37hc365091_0", + "glob2 0.6 py37_0", + "jupyter_client 5.2.3 py37_0", + "blosc 1.14.4 hdbcaa40_0", + "incremental 17.5.0 py37_0", + "ruamel_yaml 0.15.46 py37h14c3975_0", + "pylint 2.1.1 py37_0", + "dask-core 0.19.1 py37_0", + "datashape 0.5.4 py37_1", + "mpc 1.1.0 h10f8cd9_1", + "pycosat 0.6.3 py37h14c3975_0", + "contextlib2 0.5.5 py37_0", + "bokeh 0.13.0 py37_0", + "boto 2.49.0 py37_0", + "keyring 13.2.1 py37_0", + "seaborn 0.9.0 py37_0", + "expat 2.2.6 he6710b0_0", + "libxslt 1.1.32 h1312cb7_0", + "isort 4.3.4 py37_0", + "testpath 0.3.1 py37_0", + "appdirs 1.4.3 py37h28b3542_0", + "pyyaml 3.13 py37h14c3975_0", + "cairo 1.14.12 h8948797_3", + "pluggy 0.7.1 py37h28b3542_0", + "lzo 2.10 h49e0be7_2", + "mkl 2018.0.3 1" + ], + "license": "BSD", + "md5": "efbda672f1b5fdcc838ed219918a15e8", + "name": "anaconda", + "namespace": "python", + "sha256": "cdbba0ac5fad656b908471c6fa9ecdbe4c1aae55244c1f346179d585eca049c9", + "size": 11070, + "subdir": "linux-64", + "timestamp": 1541668089358, + "version": "5.3.1" + }, + "anaconda-5.3.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "intel-openmp 2019.0 118", + "libcurl 7.61.0 h1ad7b7a_0", + "nbconvert 5.4.0 py37_1", + "ncurses 6.1 hf484d3e_0", + "prometheus_client 0.3.1 py37h28b3542_0", + "libtool 2.4.6 h544aabb_3", + "numba 0.39.0 py37h04863e7_0", + "pip 10.0.1 py37_0", + "pyasn1-modules 0.2.2 py37_0", + "astropy 3.0.4 py37h14c3975_0", + "traitlets 4.3.2 py37_0", + "ipython_genutils 0.2.0 py37_0", + "backports 1.0 py37_1", + "colorama 0.3.9 py37_0", + "pygments 2.2.0 py37_0", + "parso 0.3.1 py37_0", + "tk 8.6.8 hbc83047_0", + "pytest-arraydiff 0.2 py37h39e3cac_0", + "jinja2 2.10 py37_0", + "jpeg 9b h024ee3a_2", + "click 6.7 py37_0", + "ca-certificates 2018.03.07 0", + "bitarray 0.8.3 py37h14c3975_0", + "libtiff 4.0.9 he85c1e1_2", + "markupsafe 1.0 py37h14c3975_1", + "simplegeneric 0.8.1 py37_2", + "backcall 0.1.0 py37_0", + "pyodbc 4.0.24 py37he6710b0_0", + "jupyterlab 0.34.9 py37_0", + "path.py 11.1.0 py37_0", + "mkl 2018.0.3 1", + "unicodecsv 0.14.1 py37_0", + "mkl-service 1.1.2 py37h90e4bf4_5", + "alabaster 0.7.11 py37_0", + "olefile 0.46 py37_0", + "chardet 3.0.4 py37_1", + "patsy 0.5.0 py37_0", + "pandocfilters 1.4.2 py37_1", + "entrypoints 0.2.3 py37_2", + "pycparser 2.18 py37_1", + "itsdangerous 0.24 py37_1", + "zlib 1.2.11 ha838bed_2", + "pyopenssl 18.0.0 py37_0", + "secretstorage 3.1.0 py37_0", + "mpmath 1.0.0 py37_2", + "hdf5 1.10.2 hba1933b_1", + "pango 1.42.4 h049681c_0", + "libgcc-ng 8.2.0 hdf63c60_1", + "llvmlite 0.24.0 py37hdbcaa40_0", + "pytest-openfiles 0.3.0 py37_0", + "webencodings 0.5.1 py37_1", + "graphite2 1.3.12 h23475e2_2", + "docutils 0.14 py37_0", + "dask 0.19.1 py37_0", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "get_terminal_size 1.0.0 haa9412d_0", + "pytest 3.8.0 py37_0", + "openpyxl 2.5.6 py37_0", + "jbig 2.1 hdba287a_0", + "fontconfig 2.13.0 h9420a91_0", + "zict 0.1.3 py37_0", + "clyent 1.2.2 py37_1", + "jedi 0.12.1 py37_0", + "xz 5.2.4 h14c3975_4", + "notebook 5.6.0 py37_0", + "snappy 1.1.7 hbae5bb6_3", + "heapdict 1.0.0 py37_2", + "msgpack-python 0.5.6 py37h6bb024c_1", + "bottleneck 1.2.1 py37h035aef0_1", + "six 1.11.0 py37_1", + "h5py 2.8.0 py37h989c5e5_3", + "blas 1.0 mkl", + "pixman 0.34.0 hceecf20_3", + "requests 2.19.1 py37_0", + "sphinxcontrib-websupport 1.1.0 py37_1", + "ipywidgets 7.4.1 py37_0", + "tblib 1.3.2 py37_0", + "anaconda-project 0.8.2 py37_0", + "mkl_fft 1.0.4 py37h4414c95_1", + "packaging 17.1 py37_0", + "glib 2.56.2 hd408876_0", + "fastcache 1.0.2 py37h14c3975_2", + "curl 7.61.0 h84994c4_0", + "pexpect 4.6.0 py37_0", + "zeromq 4.2.5 hf484d3e_1", + "ipykernel 4.9.0 py37_1", + "libxml2 2.9.8 h26e45fe_1", + "sympy 1.2 py37_0", + "certifi 2018.8.24 py37_1", + "cycler 0.10.0 py37_0", + "asn1crypto 0.24.0 py37_0", + "icu 58.2 h9c2bf20_1", + "spyder-kernels 0.2.6 py37_0", + "terminado 0.8.1 py37_1", + "nbformat 4.4.0 py37_0", + "python 3.7.0 hc3d631a_0", + "qtawesome 0.4.4 py37_0", + "gevent 1.3.6 py37h7b6447c_0", + "mccabe 0.6.1 py37_1", + "widgetsnbextension 3.4.1 py37_0", + "fribidi 1.0.5 h7b6447c_0", + "kiwisolver 1.0.1 py37hf484d3e_0", + "patchelf 0.9 hf484d3e_2", + "pycurl 7.43.0.2 py37hb7f436b_0", + "libedit 3.1.20170329 h6b74fdf_2", + "pywavelets 1.0.0 py37hdd07704_0", + "send2trash 1.5.0 py37_0", + "greenlet 0.4.15 py37h7b6447c_0", + "numpy 1.15.1 py37h3b04361_0", + "jupyter_core 4.4.0 py37_0", + "pycrypto 2.6.1 py37h14c3975_9", + "bkcharts 0.2 py37_0", + "tornado 5.1 py37h14c3975_0", + "flask 1.0.2 py37_1", + "beautifulsoup4 4.6.3 py37_0", + "py 1.6.0 py37_0", + "pyzmq 17.1.2 py37h14c3975_0", + "pytest-astropy 0.4.0 py37_0", + "ipython 6.5.0 py37_0", + "distributed 1.23.1 py37_0", + "jupyterlab_launcher 0.13.1 py37_0", + "defusedxml 0.5.0 py37_1", + "singledispatch 3.4.0.3 py37_0", + "automat 0.7.0 py37_0", + "pytest-remotedata 0.3.0 py37_0", + "cloudpickle 0.5.5 py37_0", + "bleach 2.1.4 py37_0", + "yaml 0.1.7 had09818_2", + "libssh2 1.8.0 h9cfc8f7_4", + "attrs 18.2.0 py37h28b3542_0", + "xlrd 1.1.0 py37_1", + "statsmodels 0.9.0 py37h035aef0_0", + "dbus 1.13.2 h714fa37_1", + "networkx 2.1 py37_0", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "openssl 1.0.2p h14c3975_0", + "freetype 2.9.1 h8a8886c_1", + "pyflakes 2.0.0 py37_0", + "wheel 0.31.1 py37_0", + "filelock 3.0.8 py37_0", + "matplotlib 2.2.3 py37hb69df0a_0", + "tqdm 4.26.0 py37h28b3542_0", + "prompt_toolkit 1.0.15 py37_0", + "libffi 3.2.1 hd88cf55_4", + "pytz 2018.5 py37_0", + "html5lib 1.0.1 py37_0", + "nltk 3.3.0 py37_0", + "cytoolz 0.9.0.1 py37h14c3975_1", + "ply 3.11 py37_0", + "setuptools 40.2.0 py37_0", + "pytables 3.4.4 py37ha205bf6_0", + "pep8 1.7.1 py37_0", + "sphinxcontrib 1.0 py37_1", + "jdcal 1.4 py37_0", + "libpng 1.6.34 hb9fc6fc_0", + "pkginfo 1.4.2 py37_1", + "zope 1.0 py37_1", + "lxml 4.2.5 py37hefd8a0e_0", + "sphinx 1.7.9 py37_0", + "numpy-base 1.15.1 py37h81de0dd_0", + "scikit-learn 0.19.2 py37h4989274_0", + "jeepney 0.3.1 py37_0", + "cython 0.28.5 py37hf484d3e_0", + "numpydoc 0.8.0 py37_0", + "libxcb 1.13 h1bed415_1", + "ptyprocess 0.6.0 py37_0", + "wcwidth 0.1.7 py37_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "urllib3 1.23 py37_0", + "lazy-object-proxy 1.3.1 py37h14c3975_2", + "libuuid 1.0.3 h1bed415_2", + "sip 4.19.8 py37hf484d3e_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "astroid 2.0.4 py37_0", + "sqlalchemy 1.2.11 py37h7b6447c_0", + "qtconsole 4.4.1 py37_0", + "zope.interface 4.5.0 py37h14c3975_0", + "pyparsing 2.2.0 py37_1", + "unixodbc 2.3.7 h14c3975_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "jupyter_console 5.2.0 py37_1", + "sortedcollections 1.0.1 py37_0", + "pickleshare 0.7.4 py37_0", + "pycodestyle 2.4.0 py37_0", + "psutil 5.4.7 py37h14c3975_0", + "gmpy2 2.0.8 py37h10f8cd9_2", + "numexpr 2.6.8 py37hd89afb7_0", + "service_identity 17.0.0 py37h28b3542_0", + "nose 1.3.7 py37_2", + "wrapt 1.10.11 py37h14c3975_2", + "pillow 5.2.0 py37heded4f4_0", + "cffi 1.11.5 py37he75722e_1", + "werkzeug 0.14.1 py37_0", + "jupyter 1.0.0 py37_7", + "scipy 1.1.0 py37hfa4b5c9_1", + "scikit-image 0.14.0 py37hf484d3e_1", + "sortedcontainers 2.0.5 py37_0", + "flask-cors 3.0.6 py37_0", + "locket 0.2.0 py37_1", + "pyasn1 0.4.4 py37h28b3542_0", + "gmp 6.1.2 h6c8ec71_1", + "partd 0.3.8 py37_0", + "libsodium 1.0.16 h1bed415_0", + "gstreamer 1.14.0 hb453b48_1", + "twisted 18.7.0 py37h14c3975_1", + "pcre 8.42 h439df22_0", + "hyperlink 18.0.0 py37_0", + "qtpy 1.5.0 py37_0", + "pytest-doctestplus 0.1.3 py37_0", + "imageio 2.4.1 py37_0", + "qt 5.9.6 h8703b6f_2", + "xlsxwriter 1.1.0 py37_0", + "snowballstemmer 1.2.1 py37_0", + "pathlib2 2.3.2 py37_0", + "more-itertools 4.3.0 py37_0", + "atomicwrites 1.2.1 py37_0", + "blaze 0.11.3 py37_0", + "mpfr 4.0.1 hdf1c602_3", + "xlwt 1.3.0 py37_0", + "jsonschema 2.6.0 py37_0", + "constantly 15.1.0 py37h28b3542_0", + "mkl_random 1.0.1 py37h4414c95_1", + "spyder 3.3.1 py37_1", + "decorator 4.3.0 py37_0", + "anaconda-client 1.7.2 py37_0", + "pysocks 1.6.8 py37_0", + "pyqt 5.9.2 py37h05f1152_2", + "et_xmlfile 1.0.1 py37_0", + "pandas 0.23.4 py37h04863e7_0", + "sqlite 3.24.0 h84994c4_0", + "toolz 0.9.0 py37_0", + "babel 2.6.0 py37_0", + "mistune 0.8.3 py37h14c3975_1", + "harfbuzz 1.8.8 hffaf4a1_0", + "imagesize 1.1.0 py37_0", + "bzip2 1.0.6 h14c3975_5", + "readline 7.0 h7b6447c_5", + "idna 2.7 py37_0", + "odo 0.5.1 py37_0", + "multipledispatch 0.6.0 py37_0", + "python-dateutil 2.7.3 py37_0", + "rope 0.11.0 py37_0", + "cryptography 2.3.1 py37hc365091_0", + "glob2 0.6 py37_0", + "jupyter_client 5.2.3 py37_0", + "blosc 1.14.4 hdbcaa40_0", + "incremental 17.5.0 py37_0", + "ruamel_yaml 0.15.46 py37h14c3975_0", + "pylint 2.1.1 py37_0", + "dask-core 0.19.1 py37_0", + "datashape 0.5.4 py37_1", + "mpc 1.1.0 h10f8cd9_1", + "pycosat 0.6.3 py37h14c3975_0", + "contextlib2 0.5.5 py37_0", + "bokeh 0.13.0 py37_0", + "boto 2.49.0 py37_0", + "keyring 13.2.1 py37_0", + "seaborn 0.9.0 py37_0", + "expat 2.2.6 he6710b0_0", + "libxslt 1.1.32 h1312cb7_0", + "isort 4.3.4 py37_0", + "testpath 0.3.1 py37_0", + "appdirs 1.4.3 py37h28b3542_0", + "pyyaml 3.13 py37h14c3975_0", + "cairo 1.14.12 h8948797_3", + "pluggy 0.7.1 py37h28b3542_0", + "lzo 2.10 h49e0be7_2" + ], + "license": "BSD", + "md5": "c49023f4b5ca94f7bab86eba7e0631b6", + "name": "anaconda", + "namespace": "python", + "sha256": "85771dce0d7ac2bc2e4186f6fc79b8100fb1615611704273baa844897d5bf3bf", + "size": 11112, + "subdir": "linux-64", + "timestamp": 1541668089358, + "version": "5.3.1" + }, + "anaconda-clean-1.1.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "d313c0b4ac77769ae44c8c8d19820431", + "name": "anaconda-clean", + "sha256": "96d29d2376ebe438efd1837de6da319e8bdb55a63069700c34533082e8410e87", + "size": 6977, + "subdir": "linux-64", + "timestamp": 1537209301049, + "version": "1.1.0" + }, + "anaconda-clean-1.1.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "a0ea8c7b1a194a3e364de6f1d73df4a1", + "name": "anaconda-clean", + "sha256": "edfd4217e723b3a42b70f0ebdb6c17d19e6efa520c7484c4e0b302531575ef7d", + "size": 7486, + "subdir": "linux-64", + "timestamp": 1640788087918, + "version": "1.1.0" + }, + "anaconda-clean-1.1.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "dfbefba2829b2eba490dfe0447c14ddd", + "name": "anaconda-clean", + "sha256": "a440456feb653b15e9f9c91aec95bb97f759dde2a87b05a87c61d7c677d473fe", + "size": 7034, + "subdir": "linux-64", + "timestamp": 1537209332330, + "version": "1.1.0" + }, + "anaconda-clean-1.1.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "32c162119cd932c0d73e2ffa57e1d056", + "name": "anaconda-clean", + "sha256": "900e60f94fd506f667dd31656cb8fef4eb3cb337ea06c25bce615100d5ed31f8", + "size": 7039, + "subdir": "linux-64", + "timestamp": 1537209320513, + "version": "1.1.0" + }, + "anaconda-clean-1.1.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "24776ce491f54ce701485415465be383", + "name": "anaconda-clean", + "sha256": "ad5dd708b269afa7897c3c75d7b59113e6d2b70527fe97ff183c2becf317722b", + "size": 226853, + "subdir": "linux-64", + "timestamp": 1614067934327, + "version": "1.1.0" + }, + "anaconda-clean-1.1.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "8669665514e339ebe199ddad83885f83", + "name": "anaconda-clean", + "sha256": "a94585474622a95e7ec27ba8aa11a2ab3ad6c18280f0e15d0479a749de77eaac", + "size": 7052, + "subdir": "linux-64", + "timestamp": 1537209278724, + "version": "1.1.0" + }, + "anaconda-clean-1.1.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "bda253eb75ef13d260c5ea212c31bce6", + "name": "anaconda-clean", + "sha256": "9e6efbdda83122d70aa6f6d95738d5ac182d1cecbef9113aa28a16c92e9cc821", + "size": 226972, + "subdir": "linux-64", + "timestamp": 1614068853208, + "version": "1.1.0" + }, + "anaconda-clean-1.1.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "4a40d1a6469e391b9313d4c285b8e33d", + "name": "anaconda-clean", + "sha256": "ad4c61d0d8230427d45d6355649883243e6738e3517dc123074a89352fac15e2", + "size": 7367, + "subdir": "linux-64", + "timestamp": 1572437622112, + "version": "1.1.0" + }, + "anaconda-clean-1.1.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "0dcfcd60add631cb619c16d390381ef6", + "name": "anaconda-clean", + "sha256": "5daa6badf7c7df3333327a4b6f2a70d5c8eac49b23221bb2df3604e211a7c51d", + "size": 227246, + "subdir": "linux-64", + "timestamp": 1614068776853, + "version": "1.1.0" + }, + "anaconda-clean-1.1.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "c94b5fd8d1888e089c9ff677ad319a88", + "name": "anaconda-clean", + "sha256": "46a559d0e90628f9e05de114319dccc3e4fc73eefd7a45f058a0f80663c2b810", + "size": 7643, + "subdir": "linux-64", + "timestamp": 1607007496712, + "version": "1.1.0" + }, + "anaconda-clean-1.1.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "db7452373ba2c0f418451ddf7d2bb5ac", + "name": "anaconda-clean", + "sha256": "5c78d20075ec29e62dd685b6948729f34cd87c6b90ecd2fc3917a8b72ff042bc", + "size": 8578, + "subdir": "linux-64", + "timestamp": 1652723762856, + "version": "1.1.1" + }, + "anaconda-clean-1.1.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4665792b4a8a13004b0db7b82c425191", + "name": "anaconda-clean", + "sha256": "11a28cb2a995c3bdbbe91de5e0fa2ded663dcd2883987f156e0dd3c1c4929f3e", + "size": 9763, + "subdir": "linux-64", + "timestamp": 1676846710925, + "version": "1.1.1" + }, + "anaconda-clean-1.1.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e5ee2ec910163975037c9ba4b72891b4", + "name": "anaconda-clean", + "sha256": "10c5c00c80b82916292da501936e406b0528edb06962a72a21ef78b31f835ff3", + "size": 8574, + "subdir": "linux-64", + "timestamp": 1652723836933, + "version": "1.1.1" + }, + "anaconda-clean-1.1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "37c166dea33ec3e3efbc3f2fa2ec9961", + "name": "anaconda-clean", + "sha256": "81d3708b988a89bfb1b66d68a461d50b65e3bcab03cd4a2ee33a9c8fc4b2364a", + "size": 8591, + "subdir": "linux-64", + "timestamp": 1652723813231, + "version": "1.1.1" + }, + "anaconda-clean-1.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c8e4dea5af08ae5e0ebc751146ac65d7", + "name": "anaconda-clean", + "sha256": "80196e6681ac9e071d133d129ca8d607dcc50088fb71890a5a619c6f8b05c361", + "size": 8559, + "subdir": "linux-64", + "timestamp": 1652723789616, + "version": "1.1.1" + }, + "anaconda-client-1.10.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "nbformat >=4.4.0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bc66d43bcef444705eaac2351fd5027a", + "name": "anaconda-client", + "sha256": "7db9492ceb72fb31b6cf3966008933c771941afd716528bd2f3b8dbd1cd1128c", + "size": 146584, + "subdir": "linux-64", + "timestamp": 1655307980993, + "version": "1.10.0" + }, + "anaconda-client-1.10.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "nbformat >=4.4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ad9851a743c755701f997e91d55240c", + "name": "anaconda-client", + "sha256": "8d1599bb7618a6a542019224d099ebd7930c0555dc8683f4035ffb8b6ecd8199", + "size": 144507, + "subdir": "linux-64", + "timestamp": 1655307898556, + "version": "1.10.0" + }, + "anaconda-client-1.10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "nbformat >=4.4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4cbfd91a6dcae8647f158f470c7e3c1f", + "name": "anaconda-client", + "sha256": "ea3553215f2643200e75f0c5fc1b0ac41fd8f780af2a018085a78769e5c50ddf", + "size": 145047, + "subdir": "linux-64", + "timestamp": 1655307933286, + "version": "1.10.0" + }, + "anaconda-client-1.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "nbformat >=4.4.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7635e8f84c6847c8f5c855ee0bf02b7f", + "name": "anaconda-client", + "sha256": "c3f35db31494681c6d6713e8fa01c06a57507100e8d93774cd6c4eb13e920b44", + "size": 145312, + "subdir": "linux-64", + "timestamp": 1655308016313, + "version": "1.10.0" + }, + "anaconda-client-1.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "nbformat >=4.4.0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.20.0", + "setuptools >=58.0.4", + "six >=1.15.0", + "tqdm >=4.56.0", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7f141f1b24f934d3004325c85ed0aa8d", + "name": "anaconda-client", + "sha256": "ff034ee2c9144273d2843deaae47b71478b37d5ea0d6f0a40f93e9350a86173b", + "size": 146092, + "subdir": "linux-64", + "timestamp": 1662708425081, + "version": "1.11.0" + }, + "anaconda-client-1.11.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "nbformat >=4.4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.20.0", + "setuptools >=58.0.4", + "six >=1.15.0", + "tqdm >=4.56.0", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4a59ef764dc59f6382b06455c92d2e86", + "name": "anaconda-client", + "sha256": "c5d8b0a181fe39c54ce70a615b44cc561c8a20b73c2a2facb0948c7e5dd8e027", + "size": 144147, + "subdir": "linux-64", + "timestamp": 1662708376827, + "version": "1.11.0" + }, + "anaconda-client-1.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "nbformat >=4.4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.20.0", + "setuptools >=58.0.4", + "six >=1.15.0", + "tqdm >=4.56.0", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1286c88b0d6128629c7578e4963f1339", + "name": "anaconda-client", + "sha256": "d90615fb990eb1f4e835b089850c3f6b9f5177e1823ce81068c95970480ee691", + "size": 144886, + "subdir": "linux-64", + "timestamp": 1662708341199, + "version": "1.11.0" + }, + "anaconda-client-1.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "nbformat >=4.4.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.20.0", + "setuptools >=58.0.4", + "six >=1.15.0", + "tqdm >=4.56.0", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "219cd4c52bf9e1288a41e43d80f9e76e", + "name": "anaconda-client", + "sha256": "d38130d341bc34eea7afa9a5828e59930fb9e62a13ce1c6fa551d3464fc799b4", + "size": 145001, + "subdir": "linux-64", + "timestamp": 1662708458561, + "version": "1.11.0" + }, + "anaconda-client-1.11.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "defusedxml >=0.7.1", + "nbformat >=4.4.0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.6.1", + "pytz >=2021.3", + "pyyaml >=3.12", + "requests >=2.20.0", + "setuptools >=58.0.4", + "six >=1.15.0", + "tqdm >=4.56.0", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2cbe35e76aba73030001ab004d721f1d", + "name": "anaconda-client", + "sha256": "a6b9ed50b32fc112b05d9fb3f18f70f00f0620627ee017e18161c6b93f9d7368", + "size": 128009, + "subdir": "linux-64", + "timestamp": 1678123178096, + "version": "1.11.1" + }, + "anaconda-client-1.11.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "defusedxml >=0.7.1", + "nbformat >=4.4.0", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.6.1", + "pytz >=2021.3", + "pyyaml >=3.12", + "requests >=2.20.0", + "setuptools >=58.0.4", + "six >=1.15.0", + "tqdm >=4.56.0", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a0a4db286a902c1a066871fefb68da1", + "name": "anaconda-client", + "sha256": "51297844efaec3fb2a5d50469bb004b41cc801592c8e409e2d070b0543e871d5", + "size": 173684, + "subdir": "linux-64", + "timestamp": 1679523571141, + "version": "1.11.1" + }, + "anaconda-client-1.11.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "defusedxml >=0.7.1", + "nbformat >=4.4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz >=2021.3", + "pyyaml >=3.12", + "requests >=2.20.0", + "setuptools >=58.0.4", + "six >=1.15.0", + "tqdm >=4.56.0", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "75f7e41e0386175fbf3d1a9adfc59901", + "name": "anaconda-client", + "sha256": "c9aa1b7a60428c27179c296d967f3b4406d910f4dacff277621ee10bd2d0db8b", + "size": 126557, + "subdir": "linux-64", + "timestamp": 1678123216202, + "version": "1.11.1" + }, + "anaconda-client-1.11.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "defusedxml >=0.7.1", + "nbformat >=4.4.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.6.1", + "pytz >=2021.3", + "pyyaml >=3.12", + "requests >=2.20.0", + "setuptools >=58.0.4", + "six >=1.15.0", + "tqdm >=4.56.0", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "611359e2f9ffce1c9b4d4b88a0532e7f", + "name": "anaconda-client", + "sha256": "f2b694443050731f327c1c1cd81cf50ba617e7a347dc52e01dfb1df56bfde9ca", + "size": 126723, + "subdir": "linux-64", + "timestamp": 1678123255009, + "version": "1.11.1" + }, + "anaconda-client-1.6.11-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "515979a124ede926a1ca114e9494e1e2", + "name": "anaconda-client", + "sha256": "b66dae6158fa83a65108a7a6d3ef05189427b28688ce30298d48421f1bdeb060", + "size": 134927, + "subdir": "linux-64", + "timestamp": 1519174369397, + "version": "1.6.11" + }, + "anaconda-client-1.6.11-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "22bfd9d683283668987ecddfef4e29b7", + "name": "anaconda-client", + "sha256": "b9a2fba78449f767a2b6c6c8090cbe00d4846193850653571d20c64a69dcb9a4", + "size": 136821, + "subdir": "linux-64", + "timestamp": 1519174392105, + "version": "1.6.11" + }, + "anaconda-client-1.6.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eff300dac6919b9a0c142efb63fb415e", + "name": "anaconda-client", + "sha256": "bfe0209d2a6339269ba2205b383b52e7ff559562bcd43e54de1f52cb3ab3587a", + "size": 135646, + "subdir": "linux-64", + "timestamp": 1519174355108, + "version": "1.6.11" + }, + "anaconda-client-1.6.12-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4f987939af2c76bd11595e96d450bb25", + "name": "anaconda-client", + "sha256": "8d675b2b927ae45e24778833799dd12d47b935dc6ce2533defb006b9db026b5b", + "size": 135668, + "subdir": "linux-64", + "timestamp": 1520872536733, + "version": "1.6.12" + }, + "anaconda-client-1.6.12-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c02c133e10df361ecced2771a57c75e0", + "name": "anaconda-client", + "sha256": "491399caad0d3406122e58ed5499952a3bad40b3debabaefcdf297979b3b0f99", + "size": 137683, + "subdir": "linux-64", + "timestamp": 1520872582147, + "version": "1.6.12" + }, + "anaconda-client-1.6.12-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7d04f00cf49c8a9b5808ae6e6f8a3303", + "name": "anaconda-client", + "sha256": "5c701bb17d344c6da9fedc05b2af9e79e466b139089dd73862186401ed66468d", + "size": 136585, + "subdir": "linux-64", + "timestamp": 1520872587736, + "version": "1.6.12" + }, + "anaconda-client-1.6.13-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5233e7a7c95e5df670f1ed8e4a67c073", + "name": "anaconda-client", + "sha256": "b8ff6d77ac3d40cdb3698b464d045d370db60d27a663793dd9a0203b188d80be", + "size": 136713, + "subdir": "linux-64", + "timestamp": 1521477746752, + "version": "1.6.13" + }, + "anaconda-client-1.6.13-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "81de6e3a8e5f0caa17adf7bd4ae53eb3", + "name": "anaconda-client", + "sha256": "689300115ae46330f0f2c878174f796ddd2b30e25297e1583309bd66c154b0ba", + "size": 138667, + "subdir": "linux-64", + "timestamp": 1521477804708, + "version": "1.6.13" + }, + "anaconda-client-1.6.13-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "72ac274486297dc1a6a6aab7f31b4d19", + "name": "anaconda-client", + "sha256": "8895126856e659c306792935ad1cd04db86e571aff8c0d8b21a4c50e7af3ca85", + "size": 137425, + "subdir": "linux-64", + "timestamp": 1521477805036, + "version": "1.6.13" + }, + "anaconda-client-1.6.14-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "372d857153aaf594a637a4173a5aecf4", + "name": "anaconda-client", + "sha256": "54905e2fa01b0c2bb18899042b1250083e9d5f14e6c8f34286b0fb0d54e17340", + "size": 136675, + "subdir": "linux-64", + "timestamp": 1521488609449, + "version": "1.6.14" + }, + "anaconda-client-1.6.14-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "928cbdecf1dfc133a65e30d3ee57ec01", + "name": "anaconda-client", + "sha256": "56d8d7054589a10ce298b005a0f7db3b693ba32a9b299d47e6ce453847068965", + "size": 138643, + "subdir": "linux-64", + "timestamp": 1521488582183, + "version": "1.6.14" + }, + "anaconda-client-1.6.14-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "75a3124c14340e604526601ada9e154e", + "name": "anaconda-client", + "sha256": "3d3fdbc728d0c306700606c73f154b8d414219f711187d33a889875ce15a5a99", + "size": 137433, + "subdir": "linux-64", + "timestamp": 1521488635150, + "version": "1.6.14" + }, + "anaconda-client-1.6.14-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d5ce8f8e9aa77d876c71eb262dd15b07", + "name": "anaconda-client", + "sha256": "e9a900f9347f3b7c040950a1cc5ae18d06b32c883c422a9dcc4397736ac3a862", + "size": 142062, + "subdir": "linux-64", + "timestamp": 1530737372183, + "version": "1.6.14" + }, + "anaconda-client-1.6.5-py27hc8169bf_0.tar.bz2": { + "build": "py27hc8169bf_0", + "build_number": 0, + "depends": [ + "clyent", + "nbformat", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f8d239fd46fb7324f1174a8961ea1c90", + "name": "anaconda-client", + "sha256": "e8ccbe12bb0be6968ea5e21a2b8ed9b47be40c82e50af840b7e038546c650869", + "size": 134811, + "subdir": "linux-64", + "timestamp": 1505746003134, + "version": "1.6.5" + }, + "anaconda-client-1.6.5-py35hd900ed1_0.tar.bz2": { + "build": "py35hd900ed1_0", + "build_number": 0, + "depends": [ + "clyent", + "nbformat", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7684fae52a9eed7714a557c0647ede01", + "name": "anaconda-client", + "sha256": "c715c69620ef10c699b532d963c287caa092de80df37b0f76de0092a83fc5839", + "size": 136469, + "subdir": "linux-64", + "timestamp": 1505746027690, + "version": "1.6.5" + }, + "anaconda-client-1.6.5-py36h19c0dcd_0.tar.bz2": { + "build": "py36h19c0dcd_0", + "build_number": 0, + "depends": [ + "clyent", + "nbformat", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "43f6b6146d66adef7c2f352840486b39", + "name": "anaconda-client", + "sha256": "6c55918b24a85cfec37f8c50fe37cdaacf12c568c6156059573edee6c7653de4", + "size": 135416, + "subdir": "linux-64", + "timestamp": 1505746050364, + "version": "1.6.5" + }, + "anaconda-client-1.6.6-py27heac1a27_0.tar.bz2": { + "build": "py27heac1a27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d069cb200082c4368625c09531fc4bdb", + "name": "anaconda-client", + "sha256": "8ddcb9597be010aa4344f9e45c98b63927d2f2351e332f8a296b74a82d516e06", + "size": 136410, + "subdir": "linux-64", + "timestamp": 1512418729750, + "version": "1.6.6" + }, + "anaconda-client-1.6.6-py35h6b90917_0.tar.bz2": { + "build": "py35h6b90917_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b1576e6c29ff8934894794066f26e70e", + "name": "anaconda-client", + "sha256": "03743c56c0a671e966d441bd2e49225e36c550a3bcdf0983d1bbea992bf15132", + "size": 137928, + "subdir": "linux-64", + "timestamp": 1512418662683, + "version": "1.6.6" + }, + "anaconda-client-1.6.6-py36h59e3ba0_0.tar.bz2": { + "build": "py36h59e3ba0_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ab109298e8259b343c42c35839acffed", + "name": "anaconda-client", + "sha256": "7f9f7839dd4eeb05243f6bbf08136b7e4298854016b8738bfb418100c3b8607d", + "size": 136900, + "subdir": "linux-64", + "timestamp": 1512418697686, + "version": "1.6.6" + }, + "anaconda-client-1.6.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "requests >=2.9.1", + "ruamel_yaml <0.15", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5ea3f9f1508e49c2ac188fc506ec9dea", + "name": "anaconda-client", + "sha256": "b570dde747ede30ece8090c2dfdf9794d32147177d5627011ef315423fe41674", + "size": 135502, + "subdir": "linux-64", + "timestamp": 1516725593537, + "version": "1.6.7" + }, + "anaconda-client-1.6.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.6.1", + "pytz", + "requests >=2.9.1", + "ruamel_yaml <0.15", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0d6c5d66910585a2c273fbba871b7657", + "name": "anaconda-client", + "sha256": "a13370813558ebdc783bb5a3c965d0be9eac5f90cec1838ffc4f6b0fbaec7994", + "size": 137519, + "subdir": "linux-64", + "timestamp": 1516725654051, + "version": "1.6.7" + }, + "anaconda-client-1.6.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz", + "requests >=2.9.1", + "ruamel_yaml <0.15", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ad42736a5b2036b42752927cb9ffb921", + "name": "anaconda-client", + "sha256": "ce6aebff6a0befdcc01bb02b39e2365882740b5269dd0d9575241e2463b2d83f", + "size": 136162, + "subdir": "linux-64", + "timestamp": 1516725616174, + "version": "1.6.7" + }, + "anaconda-client-1.6.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "requests >=2.9.1", + "ruamel_yaml >=0.11.14", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cc02485cabcd17ff1026c35d4f51f222", + "name": "anaconda-client", + "sha256": "d527f728a3f87dbf6d08d0ad825165cf4e6642273c875717c91be6c98cd4e10c", + "size": 135313, + "subdir": "linux-64", + "timestamp": 1516814824176, + "version": "1.6.8" + }, + "anaconda-client-1.6.8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.6.1", + "pytz", + "requests >=2.9.1", + "ruamel_yaml >=0.11.14", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "50e3eb752b99ce7a98f873853880245b", + "name": "anaconda-client", + "sha256": "386e0ae51da0e02371f94f4eeebcf4a189059e0819fc273d6799256c25a37e31", + "size": 137559, + "subdir": "linux-64", + "timestamp": 1516814852393, + "version": "1.6.8" + }, + "anaconda-client-1.6.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz", + "requests >=2.9.1", + "ruamel_yaml >=0.11.14", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "33c119faa918cbc72b3690ef6f502cb6", + "name": "anaconda-client", + "sha256": "fb07f1bad2c54d9826732f739572ee604d7ca7e1bba350bcbb611286607d1a18", + "size": 136172, + "subdir": "linux-64", + "timestamp": 1516814850480, + "version": "1.6.8" + }, + "anaconda-client-1.6.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "06abd4a5580361917b43778d459c74bd", + "name": "anaconda-client", + "sha256": "a895d3d56fbefcb9446c902e57f0b8585757a6ce26b2d36627a06e68fe05b0f8", + "size": 135201, + "subdir": "linux-64", + "timestamp": 1517420962081, + "version": "1.6.9" + }, + "anaconda-client-1.6.9-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "636dfe14e12789ebdf112ec48c9e00f3", + "name": "anaconda-client", + "sha256": "58bb504e791c0f12f22b840324e9faae3dad6f963eea9bfe5b23cc66028c9185", + "size": 137032, + "subdir": "linux-64", + "timestamp": 1517420999479, + "version": "1.6.9" + }, + "anaconda-client-1.6.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "452795419da43adb1a76d71794e67458", + "name": "anaconda-client", + "sha256": "32a6107b6a3db4c6f291bbfe8cc692708f70d8d282abb50cb6476bafa981e2a7", + "size": 136194, + "subdir": "linux-64", + "timestamp": 1517420992103, + "version": "1.6.9" + }, + "anaconda-client-1.7.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b90e09a9b82c1c665252834da44dde39", + "name": "anaconda-client", + "sha256": "af0d986f3f95dae88172c9ae7fdad81e9f6578b2d255bd4e07f53503936decad", + "size": 138838, + "subdir": "linux-64", + "timestamp": 1533203937381, + "version": "1.7.1" + }, + "anaconda-client-1.7.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "405cd0a73ea4b0056be55b571a726828", + "name": "anaconda-client", + "sha256": "3fb86a04812b92555396a6bc10b37e0dc92e696b98187162376c3da976705dab", + "size": 140804, + "subdir": "linux-64", + "timestamp": 1533203958617, + "version": "1.7.1" + }, + "anaconda-client-1.7.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dcb1715f7e8361c1418c0b41eaeb25b6", + "name": "anaconda-client", + "sha256": "58e75a7b716e866c070ed2476309ed3b38624ca6c2cbddb488d8758d3cae6721", + "size": 139541, + "subdir": "linux-64", + "timestamp": 1533203894500, + "version": "1.7.1" + }, + "anaconda-client-1.7.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "14a1de9e4a4a6011cf1945bc679bb2f7", + "name": "anaconda-client", + "sha256": "0d7174294222c268fba6bdc4f53ac5fcdbaa1b0b4626300c5ab0e257c9eb751b", + "size": 139300, + "subdir": "linux-64", + "timestamp": 1533203949660, + "version": "1.7.1" + }, + "anaconda-client-1.7.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "32869379cd4f28c4e5e4bdd355d70a2a", + "name": "anaconda-client", + "sha256": "e1f6fc315f53e2606cecb823510964a0c499e871c7d7ebe425a328f865fdd657", + "size": 143259, + "subdir": "linux-64", + "timestamp": 1535570503476, + "version": "1.7.2" + }, + "anaconda-client-1.7.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c3fa65e3dec5990b1eca10b675e9a0d6", + "name": "anaconda-client", + "sha256": "518ec7542a9cee7f5ee997ffa0b5ac2f2d70aa159fa0306fa25f1813f2da929d", + "size": 145267, + "subdir": "linux-64", + "timestamp": 1535570506164, + "version": "1.7.2" + }, + "anaconda-client-1.7.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9e6f5c1790a1716534361dfba5b4ea09", + "name": "anaconda-client", + "sha256": "e3fda64e24ad09f5458703e1538a896c25e9657a3df415e3ea509505b66f2526", + "size": 143994, + "subdir": "linux-64", + "timestamp": 1535570482984, + "version": "1.7.2" + }, + "anaconda-client-1.7.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "30c93176fab642d312a5cd9bb7751869", + "name": "anaconda-client", + "sha256": "48385d79b29f0b6102a77bc41f9930b555f28a05a7841d22b970dd7f46eb1031", + "size": 143581, + "subdir": "linux-64", + "timestamp": 1535570528927, + "version": "1.7.2" + }, + "anaconda-client-1.7.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4ef61d6e67ca43a25a8e0592d4c5f4d0", + "name": "anaconda-client", + "sha256": "fe791b52314dcf14a592d36b2e4681885a3940fa47fb5ee2143397a2697c7ca7", + "size": 153325, + "subdir": "linux-64", + "timestamp": 1580246317117, + "version": "1.7.2" + }, + "anaconda-client-1.7.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cff2cb6d155e7a3240218cb7ed1307cb", + "name": "anaconda-client", + "sha256": "6898c8da8e5b112ca3c3556bb78f11b35036f714c3537284ca4536608a7174ca", + "size": 153841, + "subdir": "linux-64", + "timestamp": 1607980774188, + "version": "1.7.2" + }, + "anaconda-client-1.8.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5e218d2081af9c9ed264492476daa68f", + "name": "anaconda-client", + "sha256": "1a773b915f26cd47ba33ee8024d0913678d5d91519821af2589fd109dd308e65", + "size": 150092, + "subdir": "linux-64", + "timestamp": 1624480211365, + "version": "1.8.0" + }, + "anaconda-client-1.8.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a9b9449c3ecf71a315b1462f72c54305", + "name": "anaconda-client", + "sha256": "fbbafd3bc443b9ef7a9eec864c28a3c560f06c17ba2f6a2de8e24c38cc8adaaa", + "size": 149817, + "subdir": "linux-64", + "timestamp": 1624480121888, + "version": "1.8.0" + }, + "anaconda-client-1.8.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bfa4de05ba1e9579048ac3f45cf5d5d2", + "name": "anaconda-client", + "sha256": "5b16ce2713ffa09459b5e53a9d249fa35fb8dee49e545f8b1a3654b79e71ea8f", + "size": 150508, + "subdir": "linux-64", + "timestamp": 1624474020991, + "version": "1.8.0" + }, + "anaconda-client-1.8.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c3c239ce46d9142ab919fabb33962fb5", + "name": "anaconda-client", + "sha256": "c7e89a7bea178f47e8c07d92ca8aaec90cd82797e6fbec41a2e6c88f63321956", + "size": 150533, + "subdir": "linux-64", + "timestamp": 1624480201370, + "version": "1.8.0" + }, + "anaconda-client-1.9.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1adda693374845c5ee6a6e3dc084d484", + "name": "anaconda-client", + "sha256": "f40e9cd3d0ea891b117ce590ca70e8618710ba86567e53ebba4ed127d1132f75", + "size": 208633, + "subdir": "linux-64", + "timestamp": 1676843180879, + "version": "1.9.0" + }, + "anaconda-client-1.9.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4efea41a7d3f2efa3c8da31e51dd500d", + "name": "anaconda-client", + "sha256": "e3a8f344190c03bdaca0264bf155f67d315586e8da2c005350d9d7f282f9373e", + "size": 152612, + "subdir": "linux-64", + "timestamp": 1635342473670, + "version": "1.9.0" + }, + "anaconda-client-1.9.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2588abadb55188b9178a78bc0ecd06d9", + "name": "anaconda-client", + "sha256": "e7ad057e0f5e88143854b453480a89f4722e8524e652ba5108440c2e71c4fbb8", + "size": 153249, + "subdir": "linux-64", + "timestamp": 1635330928093, + "version": "1.9.0" + }, + "anaconda-client-1.9.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e571e9f34a207251174888efac1fc338", + "name": "anaconda-client", + "sha256": "18b19b7d8953517b726a603d446a78165914ad0ca4fe01cd72be2b8068d7c4d8", + "size": 153067, + "subdir": "linux-64", + "timestamp": 1635342585953, + "version": "1.9.0" + }, + "anaconda-custom-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "_anaconda_depends", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "fcfa1c8453d6a67a70a509e1c155d404", + "name": "anaconda", + "namespace": "python", + "sha256": "ff4e999ddd45fcfa4d61a5d682ce39657642416229076c698b02647fc72e62db", + "size": 2866, + "subdir": "linux-64", + "timestamp": 1562174475944, + "version": "custom" + }, + "anaconda-custom-py27h4a00acb_0.tar.bz2": { + "build": "py27h4a00acb_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "_anaconda_depends" + ], + "license": "BSD", + "md5": "db1c29f2448a04cfb857b86696baca80", + "name": "anaconda", + "namespace": "python", + "sha256": "3f1d6b056992f7c5ae100a881e50d1494776d536815942d97f35f34557a90798", + "size": 5707, + "subdir": "linux-64", + "timestamp": 1508808912627, + "version": "custom" + }, + "anaconda-custom-py310_1.tar.bz2": { + "build": "py310_1", + "build_number": 1, + "depends": [ + "_anaconda_depends", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2a72402502a4fa627264f1de0b2fb9b2", + "name": "anaconda", + "namespace": "python", + "sha256": "383ed25c5a4bc7984fe21f51ce455506801b0412dc11c3325df074a073856be2", + "size": 7978, + "subdir": "linux-64", + "timestamp": 1674154116491, + "version": "custom" + }, + "anaconda-custom-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "_anaconda_depends", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "9c95f62920a5814434444e4a3c9549e3", + "name": "anaconda", + "namespace": "python", + "sha256": "d3ee025daacc7255933f2c729beece938081f0c8b49ca9adf81ed6aa244e2ab9", + "size": 2870, + "subdir": "linux-64", + "timestamp": 1562174447436, + "version": "custom" + }, + "anaconda-custom-py35h104c396_0.tar.bz2": { + "build": "py35h104c396_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "_anaconda_depends" + ], + "license": "BSD", + "md5": "3781f847eef9007f2727b878984b3cad", + "name": "anaconda", + "namespace": "python", + "sha256": "c28fa71ab8e196e57d7e646c0a15711853e2185f4f01b1d94b08567d381888e3", + "size": 5706, + "subdir": "linux-64", + "timestamp": 1508808901528, + "version": "custom" + }, + "anaconda-custom-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "_anaconda_depends", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "394afb7bf9e8a651ddb716ade155cc85", + "name": "anaconda", + "namespace": "python", + "sha256": "23222e0d7c3a2e8c2172c7f6105c5d2eee8b6fffabab89ebc7cfb392fb0f6f21", + "size": 2853, + "subdir": "linux-64", + "timestamp": 1562174457474, + "version": "custom" + }, + "anaconda-custom-py36hbbc8b67_0.tar.bz2": { + "build": "py36hbbc8b67_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "_anaconda_depends" + ], + "license": "BSD", + "md5": "e63450386a4c46f6ded2ff8e855cec3b", + "name": "anaconda", + "namespace": "python", + "sha256": "967c5ba998337396fffaa97901b0a568f8517889a42ada5aa23d5ac4b329688c", + "size": 5716, + "subdir": "linux-64", + "timestamp": 1508808890508, + "version": "custom" + }, + "anaconda-custom-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "_anaconda_depends" + ], + "license": "BSD", + "md5": "460ccdb275b77683ab6fb020597fb214", + "name": "anaconda", + "namespace": "python", + "sha256": "239460bd83ee0f3ace5a06d543125fecc83ffafe1430739f07f90ece97535ca5", + "size": 6166, + "subdir": "linux-64", + "timestamp": 1531513560056, + "version": "custom" + }, + "anaconda-custom-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "_anaconda_depends", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "9a4bb58e460484354119c61516428862", + "name": "anaconda", + "namespace": "python", + "sha256": "e28336177f4f7e0638ba948581e935c0aca93fa7d5cc16fae68616fa2817a25b", + "size": 2855, + "subdir": "linux-64", + "timestamp": 1562174465581, + "version": "custom" + }, + "anaconda-custom-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "_anaconda_depends", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "a138673665d5f3f2fd815aae71ad26eb", + "name": "anaconda", + "namespace": "python", + "sha256": "fe016e603693fc349b2dc2f1e8e8b480a7442ac7976fea7287afc68ac3367a44", + "size": 32642, + "subdir": "linux-64", + "timestamp": 1587071572818, + "version": "custom" + }, + "anaconda-custom-py39_1.tar.bz2": { + "build": "py39_1", + "build_number": 1, + "depends": [ + "_anaconda_depends", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "2384e22a49f19cc188d15617dcc45a34", + "name": "anaconda", + "namespace": "python", + "sha256": "0b86f34308267143b679fe2142b291ff915e260a6674d703cc136c2c6f2040ee", + "size": 3375, + "subdir": "linux-64", + "timestamp": 1636993662746, + "version": "custom" + }, + "anaconda-docs-2.0.18-hb3a96d1_0.tar.bz2": { + "build": "hb3a96d1_0", + "build_number": 0, + "depends": [], + "md5": "d5343b2e67a86d12925b960d19f9cebb", + "name": "anaconda-docs", + "sha256": "c61f80ba7cff731b9389d74243657b9df0cfd61b43ea745f551176a1431d8c18", + "size": 71345570, + "subdir": "linux-64", + "timestamp": 1510870072425, + "version": "2.0.18" + }, + "anaconda-docs-2.0.19-hb3a96d1_0.tar.bz2": { + "build": "hb3a96d1_0", + "build_number": 0, + "depends": [], + "md5": "22d08fcc91fec1702e85b83d68467d98", + "name": "anaconda-docs", + "sha256": "33274c9744266e07147a7ba34f86fe4f9211ce601b51412bfb6f1d8afc0f3fed", + "size": 79443827, + "subdir": "linux-64", + "timestamp": 1512077805825, + "version": "2.0.19" + }, + "anaconda-docs-2.0.20-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "md5": "fb8884737043629cceb991c5ade98bfa", + "name": "anaconda-docs", + "sha256": "a7260b5b4f98e4fe43a5acd79e5d9a1f00650a4bb386607adc517d6c696e695e", + "size": 67707792, + "subdir": "linux-64", + "timestamp": 1513628344280, + "version": "2.0.20" + }, + "anaconda-docs-2.0.21-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "md5": "c6364a1c3913c879b923fc448f2d8308", + "name": "anaconda-docs", + "sha256": "daffeda33ae6ac04de49ca1881e94df8385cf8d5541a9172fc4ec658dadd334b", + "size": 75873701, + "subdir": "linux-64", + "timestamp": 1516911564970, + "version": "2.0.21" + }, + "anaconda-docs-2.0.22-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "md5": "5acfc1aa1890de6c31401fc124c68f80", + "name": "anaconda-docs", + "sha256": "0906bca6bef02152894aa6d4288107dd102ff84ea624c9802eb0dfc37d0ee552", + "size": 75907268, + "subdir": "linux-64", + "timestamp": 1518115447238, + "version": "2.0.22" + }, + "anaconda-docs-2.0.23-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "md5": "4b1d93063062d6d6531f8e638ac5498d", + "name": "anaconda-docs", + "sha256": "8e7c6b4079e70ee4b0b5a041fe45ac4f9ea140f6d9ce21b58a73edc98315424e", + "size": 86985792, + "subdir": "linux-64", + "timestamp": 1520636361902, + "version": "2.0.23" + }, + "anaconda-linter-0.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.10,<3.11.0a0", + "pyyaml", + "ruamel.yaml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "de2cf9872f6d6b3c9e9077339fb822ab", + "name": "anaconda-linter", + "sha256": "54b65ef57a7281a7b16254dd5ff543adea8abd4f0a949f5a24abb74ed675ccb9", + "size": 66845, + "subdir": "linux-64", + "timestamp": 1664274122751, + "version": "0.0.1" + }, + "anaconda-linter-0.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "ruamel.yaml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c31195244dabf5c9a45923248d74c7de", + "name": "anaconda-linter", + "sha256": "7cbbfdf24cc150701040953f51dcd95d64ef6af1b3e64f117e96dfbe121142e2", + "size": 66087, + "subdir": "linux-64", + "timestamp": 1664274204825, + "version": "0.0.1" + }, + "anaconda-linter-0.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "ruamel.yaml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "94ffa1396a5dc7b04eeffb360668098d", + "name": "anaconda-linter", + "sha256": "66a254ffcb7cadb925e456b5bb3a44ae1e0c657fe245bad7bb625752eeaf8ac3", + "size": 66309, + "subdir": "linux-64", + "timestamp": 1664274164964, + "version": "0.0.1" + }, + "anaconda-linter-0.0.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.10,<3.11.0a0", + "pyyaml", + "ruamel.yaml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2f24f51972e4e4dd53ad259543781df5", + "name": "anaconda-linter", + "sha256": "5b436567c9e5a4921e4af58d2b8d94179aff202673c43047e7081c60a61579dd", + "size": 68706, + "subdir": "linux-64", + "timestamp": 1664990462435, + "version": "0.0.2" + }, + "anaconda-linter-0.0.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "ruamel.yaml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "05ea8bc7affa89270b66798f6855c17d", + "name": "anaconda-linter", + "sha256": "472d2c10036e92b9920b2db443ef73c28a5b4bbab25d0c153725bfe081e2416b", + "size": 68218, + "subdir": "linux-64", + "timestamp": 1664990543231, + "version": "0.0.2" + }, + "anaconda-linter-0.0.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "ruamel.yaml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07d48b6590a43bb270ce5640201a8bdf", + "name": "anaconda-linter", + "sha256": "9c7ac5e938e95c29dab566f899ede3a7e2149dd1bca39e807e1841cfd6d75953", + "size": 68291, + "subdir": "linux-64", + "timestamp": 1664990503241, + "version": "0.0.2" + }, + "anaconda-linter-0.0.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "git", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.10,<3.11.0a0", + "pyyaml", + "ruamel.yaml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c49654378ebbdd4e3a5b8c7d15a1d65d", + "name": "anaconda-linter", + "sha256": "08d8abc757062efc1bcdafff7a352a03b6cbdee41bef1665e669ddb0931cefd4", + "size": 70258, + "subdir": "linux-64", + "timestamp": 1666097766665, + "version": "0.0.3" + }, + "anaconda-linter-0.0.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "git", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "ruamel.yaml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eeff768b244669b58b124c9a830cc2dc", + "name": "anaconda-linter", + "sha256": "9599c94db2614a5e776a39d438981e6b1161c29bb4902170fda89ffe841e74d3", + "size": 69628, + "subdir": "linux-64", + "timestamp": 1666097727485, + "version": "0.0.3" + }, + "anaconda-linter-0.0.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "git", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "ruamel.yaml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "78a75714566bfbdbf46b0c0e2d2e20d5", + "name": "anaconda-linter", + "sha256": "460729b2e397377350778314377c9ff348d2260e9ea872a2d7ecf0bfeb5d4aa0", + "size": 69682, + "subdir": "linux-64", + "timestamp": 1666097803222, + "version": "0.0.3" + }, + "anaconda-linter-0.0.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.10,<3.11.0a0", + "requests", + "ruamel.yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5ea5147d2d0ee53b8df456c103ad4e8a", + "name": "anaconda-linter", + "sha256": "9129d607746de339c463e6976f8137f021cebc336019dc236adbb681ca577363", + "size": 79777, + "subdir": "linux-64", + "timestamp": 1673455981833, + "version": "0.0.4" + }, + "anaconda-linter-0.0.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.11,<3.12.0a0", + "requests", + "ruamel.yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ef1082ef0ccb3b0713d9ff11b206f64c", + "name": "anaconda-linter", + "sha256": "3066b7861291e3bf791e11988ef8ebff876d7564f0f40c1e108dfed39db2ed4c", + "size": 103477, + "subdir": "linux-64", + "timestamp": 1676846725731, + "version": "0.0.4" + }, + "anaconda-linter-0.0.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.8,<3.9.0a0", + "requests", + "ruamel.yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e493b75124ff82f333e4708eb6f747f8", + "name": "anaconda-linter", + "sha256": "6464a105c3fb5afc603ee58d4b5f9b2781906d31081728cbdf64382cee7ff17b", + "size": 78852, + "subdir": "linux-64", + "timestamp": 1673456031489, + "version": "0.0.4" + }, + "anaconda-linter-0.0.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.9,<3.10.0a0", + "requests", + "ruamel.yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "909c4ddd58d0accc03b85a36aaacb910", + "name": "anaconda-linter", + "sha256": "dd7f67ceeaa3ea15aa4286eb65f47ef4d04035d4cd6199f7805eb46e48a96799", + "size": 79088, + "subdir": "linux-64", + "timestamp": 1673456081830, + "version": "0.0.4" + }, + "anaconda-navigator-1.10.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "42ef3b33d0766d4cf51f542dbefb2933", + "name": "anaconda-navigator", + "sha256": "cf6afcb242e5c3156a94ecfc6e45f6e46c72660160c674a37537fef907dc5c33", + "size": 5645193, + "subdir": "linux-64", + "timestamp": 1603202715080, + "version": "1.10.0" + }, + "anaconda-navigator-1.10.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "0ee1552e232a91bb2ace800ef3d25270", + "name": "anaconda-navigator", + "sha256": "1cc7fc4dd9296287022238e898cbaa4c5cb5b22840527882d5f9f29f65ee6f4b", + "size": 5663536, + "subdir": "linux-64", + "timestamp": 1603202736877, + "version": "1.10.0" + }, + "anaconda-navigator-1.10.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "973c74fb3010debdc5df8265440e478c", + "name": "anaconda-navigator", + "sha256": "c08c81fd07eff417faf0b4b9e23f2a085c48d1f305cac818836e4297cdee974a", + "size": 5675012, + "subdir": "linux-64", + "timestamp": 1603202740802, + "version": "1.10.0" + }, + "anaconda-navigator-1.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "2614eebe99d23824f76bff12f7e2fe0c", + "name": "anaconda-navigator", + "sha256": "054fa48e2503844634abb6133589b93af9857214d6d72ec26e84d37c47414335", + "size": 5665119, + "subdir": "linux-64", + "timestamp": 1608055386186, + "version": "1.10.0" + }, + "anaconda-navigator-1.6.10-py27h4abd9a3_0.tar.bz2": { + "build": "py27h4abd9a3_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "ce12d821d3d0c25a82954964ab28df2c", + "name": "anaconda-navigator", + "sha256": "e8068ae24d3bd5b7e5a503af5e25c682479e287b8d28e113594bf4ce43577504", + "size": 4193815, + "subdir": "linux-64", + "timestamp": 1512412230550, + "version": "1.6.10" + }, + "anaconda-navigator-1.6.10-py35h6c327bc_0.tar.bz2": { + "build": "py35h6c327bc_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "51a7e9f6ad103a7cc72d6b903de5ee31", + "name": "anaconda-navigator", + "sha256": "8575140e97bd6dbfe012370055c7c3503e329bedf97ac326629b5415b7fb5698", + "size": 4200189, + "subdir": "linux-64", + "timestamp": 1512412286971, + "version": "1.6.10" + }, + "anaconda-navigator-1.6.10-py36hca14bee_0.tar.bz2": { + "build": "py36hca14bee_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "900d1da1bdfeb0fcc784015c2b2d4886", + "name": "anaconda-navigator", + "sha256": "b65ba5f71b398a1e772462f387e875aaeb3b4e1eac0355e36394fbc80874e683", + "size": 4189462, + "subdir": "linux-64", + "timestamp": 1512412379542, + "version": "1.6.10" + }, + "anaconda-navigator-1.6.11-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "bc6a6c690e4ccf679c4126490da76f9a", + "name": "anaconda-navigator", + "sha256": "cd70af09149e955ec441d15b7ca7d5d8d06bfd0239870db099f5f24a485cec9e", + "size": 4193007, + "subdir": "linux-64", + "timestamp": 1514307421088, + "version": "1.6.11" + }, + "anaconda-navigator-1.6.11-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "e56e8f04bdf952c67106f8de36ada23e", + "name": "anaconda-navigator", + "sha256": "de50db6cca6eb4a6d9217535fc10a282d980497e5ff871d408d07a94557cd987", + "size": 4200358, + "subdir": "linux-64", + "timestamp": 1514307535641, + "version": "1.6.11" + }, + "anaconda-navigator-1.6.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "6db3391933551daffb64e1e4ee6d332c", + "name": "anaconda-navigator", + "sha256": "1443433b5134e3402841132d80deb1986fc48e5cab540cb3d7f1edaa1345e540", + "size": 4189569, + "subdir": "linux-64", + "timestamp": 1514307609830, + "version": "1.6.11" + }, + "anaconda-navigator-1.6.12-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "b66ce98f2e8f633ba8c64a1232695644", + "name": "anaconda-navigator", + "sha256": "00c9dca3bf9744aa6c6b0ddd715c155407ac3c86118c7cb33bb9c9825315fe94", + "size": 4192549, + "subdir": "linux-64", + "timestamp": 1515547197712, + "version": "1.6.12" + }, + "anaconda-navigator-1.6.12-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "edd146f83d7b2b4aeb97ac99a90159e0", + "name": "anaconda-navigator", + "sha256": "59295ede508438497c93ba2ab65791774649aba2cb51742afbd920db23a73ea5", + "size": 4200538, + "subdir": "linux-64", + "timestamp": 1515547250027, + "version": "1.6.12" + }, + "anaconda-navigator-1.6.12-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "ab6b34f65c720b864414701a4b14704f", + "name": "anaconda-navigator", + "sha256": "20dd5276d6945580b6ccd7ba554359a38318863b3f670c94e01ee9594a4e1ae6", + "size": 4189878, + "subdir": "linux-64", + "timestamp": 1515547299228, + "version": "1.6.12" + }, + "anaconda-navigator-1.6.8-py27h2ea4365_0.tar.bz2": { + "build": "py27h2ea4365_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "8cb13eb34dbfced0bb5996de368cf143", + "name": "anaconda-navigator", + "sha256": "307d287490814acbfac91910021ce758ea3086f0bf69d375a89f58e2ba9ebd23", + "size": 4160399, + "subdir": "linux-64", + "timestamp": 1506046175072, + "version": "1.6.8" + }, + "anaconda-navigator-1.6.8-py35haed54dd_0.tar.bz2": { + "build": "py35haed54dd_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "34ebfd93d7655df3b4d51813870ba585", + "name": "anaconda-navigator", + "sha256": "28b7318f5385017d2c4c28962dc15a7c9f638a3f39c029462923d58adc510e41", + "size": 4166644, + "subdir": "linux-64", + "timestamp": 1506046205874, + "version": "1.6.8" + }, + "anaconda-navigator-1.6.8-py36h672ccc7_0.tar.bz2": { + "build": "py36h672ccc7_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "24f2f1967a1e8f04b7b116adb3c53ced", + "name": "anaconda-navigator", + "sha256": "b3a40a787e498c6c9b048518872e6770d404ba8e7d18e80a95a80fc4474c3f8e", + "size": 4149884, + "subdir": "linux-64", + "timestamp": 1506046235237, + "version": "1.6.8" + }, + "anaconda-navigator-1.6.9-py27hfbc306d_0.tar.bz2": { + "build": "py27hfbc306d_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "114a6c515f3359631a409bc109f1a1dd", + "name": "anaconda-navigator", + "sha256": "7f86c9e5cd84fae966d3c68f5ef416917797d00304e4744343bc8e5f72139adc", + "size": 4161099, + "subdir": "linux-64", + "timestamp": 1508349050688, + "version": "1.6.9" + }, + "anaconda-navigator-1.6.9-py35h5f5ee00_0.tar.bz2": { + "build": "py35h5f5ee00_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "929b566e654c4b3e4ece3953cab0566a", + "name": "anaconda-navigator", + "sha256": "69b790286068c57edd98b7adabb95bbeb3afe745cd9dc086ef3d14b1038e2917", + "size": 4167881, + "subdir": "linux-64", + "timestamp": 1508348993235, + "version": "1.6.9" + }, + "anaconda-navigator-1.6.9-py36h11ddaaa_0.tar.bz2": { + "build": "py36h11ddaaa_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "60aa49bae61e800272c8c93fa265548f", + "name": "anaconda-navigator", + "sha256": "aae0bf79a374df8be5c787721259dc3f373d75b092cbb4f825b8a2f9b620bcb0", + "size": 4150339, + "subdir": "linux-64", + "timestamp": 1508348933488, + "version": "1.6.9" + }, + "anaconda-navigator-1.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "36ec92147f440efc820d9aab581532d6", + "name": "anaconda-navigator", + "sha256": "599c50453aec1d69c94172dfe45d62b15d53cb5d5c22c178eb29a39bd378c6e0", + "size": 4497105, + "subdir": "linux-64", + "timestamp": 1518512189311, + "version": "1.7.0" + }, + "anaconda-navigator-1.7.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "047786b8b0c9e8b4b83f1dc8fdc48d20", + "name": "anaconda-navigator", + "sha256": "56e71c47c2b7b4d0bef9e4f96bb6934e82082bc67367a2bf42aea207e44efefe", + "size": 4497740, + "subdir": "linux-64", + "timestamp": 1518512240814, + "version": "1.7.0" + }, + "anaconda-navigator-1.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "8f2e9e3fae763d0e1ce4824876febd54", + "name": "anaconda-navigator", + "sha256": "b96894567b0f06b59d2634c5e30aa7a317b707bf6a20a8ee94a148fa3d4dbb01", + "size": 4483962, + "subdir": "linux-64", + "timestamp": 1518512293013, + "version": "1.7.0" + }, + "anaconda-navigator-1.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.12", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "17d2fd2cad43360aa04205d830543317", + "name": "anaconda-navigator", + "sha256": "f8aae9a1c2bbc1017cd3e73ed77dd02650c20f67b97b09b7cd09297f7ff4b5bd", + "size": 4500798, + "subdir": "linux-64", + "timestamp": 1520917799722, + "version": "1.8.1" + }, + "anaconda-navigator-1.8.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.12", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "7d94659c76cf3483108d5df8064a7fce", + "name": "anaconda-navigator", + "sha256": "5b252fafd947d959b422746107c34ce9f864065a83584ca61cc1153397451e90", + "size": 4497837, + "subdir": "linux-64", + "timestamp": 1520917899862, + "version": "1.8.1" + }, + "anaconda-navigator-1.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.12", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "34ea1cc49bbebcd8f5450027ea3de250", + "name": "anaconda-navigator", + "sha256": "6448629c458940951a7b1ed26d98b4f50c8a5ae34b84b4b8ec97007c9273d0f1", + "size": 4485725, + "subdir": "linux-64", + "timestamp": 1520917962183, + "version": "1.8.1" + }, + "anaconda-navigator-1.8.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.12", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "943e7c76608eb3ee1fbc0dcf4090871e", + "name": "anaconda-navigator", + "sha256": "e3f70bafec27049c2846d4c30399224afe3fc7cce5920c09611abd8e8fbeb967", + "size": 4505230, + "subdir": "linux-64", + "timestamp": 1521773110540, + "version": "1.8.2" + }, + "anaconda-navigator-1.8.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.12", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "2db1f652cda477a04f6e2a9de7a40b4b", + "name": "anaconda-navigator", + "sha256": "25da5238c686550084513b80838e739f7753b063e80baeba6d3d1f1860118fc9", + "size": 4499481, + "subdir": "linux-64", + "timestamp": 1521773196024, + "version": "1.8.2" + }, + "anaconda-navigator-1.8.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.12", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "7b332a4ac49b451804fc85c02270c340", + "name": "anaconda-navigator", + "sha256": "b535204a9803e8ed123354aeb5d387820184fd096896186ed7e0e0f6a99a56bd", + "size": 4489893, + "subdir": "linux-64", + "timestamp": 1521773256475, + "version": "1.8.2" + }, + "anaconda-navigator-1.8.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.12", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "3dd9a4d2a9e093b108c7895f9435913d", + "name": "anaconda-navigator", + "sha256": "737beacf1971abf642d7677b88f213ce9877d1cb418c115bac400107dc1985c0", + "size": 4961758, + "subdir": "linux-64", + "timestamp": 1523356559372, + "version": "1.8.3" + }, + "anaconda-navigator-1.8.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.12", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "57000cbbd481f32400ddb043501f4adc", + "name": "anaconda-navigator", + "sha256": "0b9af419a87161cc44e748f7bcb5dd8d2a99bcd4b27c889b4ecf74b4739074d6", + "size": 4946281, + "subdir": "linux-64", + "timestamp": 1523356631642, + "version": "1.8.3" + }, + "anaconda-navigator-1.8.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.12", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "c8910b2d2434f9d039bd9fa0bde927ba", + "name": "anaconda-navigator", + "sha256": "d5416ec96e04fb387a50a4925712e7dbd953b70433d86e773137abf87a1dedd4", + "size": 4947103, + "subdir": "linux-64", + "timestamp": 1523356715104, + "version": "1.8.3" + }, + "anaconda-navigator-1.8.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "anaconda-project", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "4d28a80231ad8cfc935feea781acad50", + "name": "anaconda-navigator", + "sha256": "1a8f6f0f499d91bc9bc8d71cd0d836478c0c2d158b34dcec61cdddf62df418e2", + "size": 4966035, + "subdir": "linux-64", + "timestamp": 1524671459436, + "version": "1.8.4" + }, + "anaconda-navigator-1.8.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "anaconda-project", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "59d3f961b42514317356f3de172d2fec", + "name": "anaconda-navigator", + "sha256": "e913054e89f0a38cd0c9c02940a297da9275022ee062eec9b6c60dc991ecb58a", + "size": 4945616, + "subdir": "linux-64", + "timestamp": 1524671586445, + "version": "1.8.4" + }, + "anaconda-navigator-1.8.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "anaconda-project", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "bf6b89cdc970252a22ade9fdcb45ead5", + "name": "anaconda-navigator", + "sha256": "179d2d8d365727a8ce31a3d27a6c9d2a8d516e77c880f038fe3e1dac0c2117d7", + "size": 4950624, + "subdir": "linux-64", + "timestamp": 1524671650262, + "version": "1.8.4" + }, + "anaconda-navigator-1.8.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "2c937a604a55cbb371cc49ae7ce3c44b", + "name": "anaconda-navigator", + "sha256": "a6df8849bb6c76b28fa2e64d27b1645f4829ae11c53a8527b8b99892d0af4665", + "size": 4967682, + "subdir": "linux-64", + "timestamp": 1525799641170, + "version": "1.8.5" + }, + "anaconda-navigator-1.8.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "062931f04e148340d1a8981f78587964", + "name": "anaconda-navigator", + "sha256": "2505dff1332ecf36af001aa18f317d3b0ad45d13d4a05e03b22e8be3da0f68a2", + "size": 4944420, + "subdir": "linux-64", + "timestamp": 1525799712978, + "version": "1.8.5" + }, + "anaconda-navigator-1.8.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "fa0f69f868c6d91a60fb5659641385e8", + "name": "anaconda-navigator", + "sha256": "179cd667b2fe38240880290f7590b086b3cdd4892e2102caa031d94dac29f938", + "size": 4953319, + "subdir": "linux-64", + "timestamp": 1525799589770, + "version": "1.8.5" + }, + "anaconda-navigator-1.8.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "67a4aa907b6d4281c2824e506bbcf48d", + "name": "anaconda-navigator", + "sha256": "0f5ec7092ab4ce5c47499d963db1177dda70b96cd7e48c862a78c08b1689a1d1", + "size": 4969452, + "subdir": "linux-64", + "timestamp": 1527010709910, + "version": "1.8.7" + }, + "anaconda-navigator-1.8.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "dc5749fb51ba59e3fc9cd3ec387e540d", + "name": "anaconda-navigator", + "sha256": "f5c0e919cb21643a783da8da1841622c1471b6c505a1cf58fa8f0bbd08d585ef", + "size": 4944102, + "subdir": "linux-64", + "timestamp": 1527010914001, + "version": "1.8.7" + }, + "anaconda-navigator-1.8.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "50ad644cd7fe2b1005ef1d6eb8be9093", + "name": "anaconda-navigator", + "sha256": "9bc1404e63f9fa0a14e7d4fb085f654f5051a4302699da7986ebf09b8579ffc7", + "size": 4956979, + "subdir": "linux-64", + "timestamp": 1527010836995, + "version": "1.8.7" + }, + "anaconda-navigator-1.8.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "a9b88fe1c423052a047a1bd2be9a7e41", + "name": "anaconda-navigator", + "sha256": "7c167c6bcaa6ea181529b69498b20c18bb72b9ac2e71785662ee6a35787a9d7f", + "size": 4957918, + "subdir": "linux-64", + "timestamp": 1531442652515, + "version": "1.8.7" + }, + "anaconda-navigator-1.9.12-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "93b58efa84bead4f5bec4008ae13834d", + "name": "anaconda-navigator", + "sha256": "464a0819404c6984b982d4c6a585ca149345ac075d11c7307ecf3e8b921c5f06", + "size": 5080114, + "subdir": "linux-64", + "timestamp": 1582555334041, + "version": "1.9.12" + }, + "anaconda-navigator-1.9.12-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "800676d6c14be238b681b3df30b3dfee", + "name": "anaconda-navigator", + "sha256": "09c7d8be79556799fc46817cc29530b4e81bd217c7ff188060d16220bf70d0e2", + "size": 5125741, + "subdir": "linux-64", + "timestamp": 1583190949954, + "version": "1.9.12" + }, + "anaconda-navigator-1.9.12-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "b08a339904f7f737d9b6b22192c338b8", + "name": "anaconda-navigator", + "sha256": "e7c02b4a1c064d468d4c993f7d74c07b7b6b4cd7e56be6c9f6bd384338b701c0", + "size": 5112583, + "subdir": "linux-64", + "timestamp": 1582555324532, + "version": "1.9.12" + }, + "anaconda-navigator-1.9.12-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "495c7399f8fac87eea0bb06d799ab9c8", + "name": "anaconda-navigator", + "sha256": "ec620b5c196c0ac04cc1db7f680c91033c3a87784d8487152fb38767f6a95af8", + "size": 5163284, + "subdir": "linux-64", + "timestamp": 1583190944530, + "version": "1.9.12" + }, + "anaconda-navigator-1.9.12-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "ba6bc5ef93ae8c68f3b30df5c24b6e16", + "name": "anaconda-navigator", + "sha256": "2fd4009ce5e26156bca49eac8d7acf079de600b7d003096a4ed6f5e0e1a3d77f", + "size": 5146261, + "subdir": "linux-64", + "timestamp": 1582555326892, + "version": "1.9.12" + }, + "anaconda-navigator-1.9.12-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "4f05f7f2897fe25ad81d8b087382efb2", + "name": "anaconda-navigator", + "sha256": "59388d28a40a937c8d2f2ee3b7931e114a5fab957cd8004ecd607b0a46803e6a", + "size": 5127310, + "subdir": "linux-64", + "timestamp": 1583190933696, + "version": "1.9.12" + }, + "anaconda-navigator-1.9.12-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "ec34dd635e9c96204126cd05d38bf03f", + "name": "anaconda-navigator", + "sha256": "33284589787937df17204d66fce3ee90ebde1e43c59ea404d44402d73ff4fd1f", + "size": 5159530, + "subdir": "linux-64", + "timestamp": 1582555327695, + "version": "1.9.12" + }, + "anaconda-navigator-1.9.12-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "55a7c4cc5465fb8d127fcb8cbf0c8d7d", + "name": "anaconda-navigator", + "sha256": "a00f26a7ac6e9a7f33cecf1e657d42c56dd733bad81eb75f08f1f1c2027de8d5", + "size": 5092284, + "subdir": "linux-64", + "timestamp": 1583190951229, + "version": "1.9.12" + }, + "anaconda-navigator-1.9.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "0f0540f82ee497637e106a798c0593ce", + "name": "anaconda-navigator", + "sha256": "f456b61d4e9ad3a0cf89e91b1111470ba6ea16ee55db2d3a4c2ad59064db42fa", + "size": 4987922, + "subdir": "linux-64", + "timestamp": 1537565894569, + "version": "1.9.2" + }, + "anaconda-navigator-1.9.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "dd6e4e989a223ecc60ec662548b308ca", + "name": "anaconda-navigator", + "sha256": "1aa080955dae8e43ad5172802c2adefc5a6fef225311b0ef5598eae8e0c31447", + "size": 5017285, + "subdir": "linux-64", + "timestamp": 1537565896303, + "version": "1.9.2" + }, + "anaconda-navigator-1.9.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "47ac7d757387c8bc5cf06543b6692cdd", + "name": "anaconda-navigator", + "sha256": "6a8629bcc4f1adc6455b30b6e4e6f9a22b763793076776f6dbfca603d6559112", + "size": 4995973, + "subdir": "linux-64", + "timestamp": 1537565903677, + "version": "1.9.2" + }, + "anaconda-navigator-1.9.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "073f68fe21ac9f70a451bd1398a97679", + "name": "anaconda-navigator", + "sha256": "ae2273cdac74981909b4751cc177c7add7f2925194e56fcda69a5b3bb7965c38", + "size": 4997317, + "subdir": "linux-64", + "timestamp": 1537565897442, + "version": "1.9.2" + }, + "anaconda-navigator-1.9.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "ae038c63d7d7ed17bd1962ca63600b4e", + "name": "anaconda-navigator", + "sha256": "9d8ca3208a3fb3dd66aa209a3b6383393cd3a6e6aa519b16f124666b015cd5ee", + "size": 4973200, + "subdir": "linux-64", + "timestamp": 1543860113290, + "version": "1.9.4" + }, + "anaconda-navigator-1.9.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "ca65fa3b68ce329b7285b3ebcfc05a38", + "name": "anaconda-navigator", + "sha256": "95c9a32f9f07ff3430e2dbaafbf32396ad6029c1f82ed656411684f06838ffc1", + "size": 4980028, + "subdir": "linux-64", + "timestamp": 1543860117695, + "version": "1.9.4" + }, + "anaconda-navigator-1.9.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "6f38cedc135aa46ea23c69d59e0dd296", + "name": "anaconda-navigator", + "sha256": "132ddbf753c7226643c4032070efcb8a2bea8076a8c2e6667e9ec281b773246b", + "size": 4961657, + "subdir": "linux-64", + "timestamp": 1543860102357, + "version": "1.9.4" + }, + "anaconda-navigator-1.9.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "a1604351c36e49ccb8ee6ff4ce040483", + "name": "anaconda-navigator", + "sha256": "c00bc60e3192357a42a39f58bd589bdaddf1e51a3bc442ad71e7ad0eb36b6dc5", + "size": 4991001, + "subdir": "linux-64", + "timestamp": 1544841515790, + "version": "1.9.6" + }, + "anaconda-navigator-1.9.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "cb2ce235b7cd384577b13bba3c8ce220", + "name": "anaconda-navigator", + "sha256": "ce70e01eb36c0cf4a9a75479cda83221446e4db4cbc4dca19e140ef2a847aa56", + "size": 4966121, + "subdir": "linux-64", + "timestamp": 1544841528268, + "version": "1.9.6" + }, + "anaconda-navigator-1.9.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "40262e41f759d6b6073c881fc9d2dbb3", + "name": "anaconda-navigator", + "sha256": "4141961db2fdcc9260d70a1e055951a91c82227b971a9e44b0de23cd024852f3", + "size": 4999308, + "subdir": "linux-64", + "timestamp": 1544841607254, + "version": "1.9.6" + }, + "anaconda-navigator-1.9.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "e1d6d7aa44186fe05ab8eb53e391d870", + "name": "anaconda-navigator", + "sha256": "399f44e6f44e966f077b8ecf371ae1cb98c3c517355ee067136f812ee54de7b0", + "size": 4994675, + "subdir": "linux-64", + "timestamp": 1553808090876, + "version": "1.9.7" + }, + "anaconda-navigator-1.9.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "c3bd7a2a50c5da7de9fcb6061c0817dd", + "name": "anaconda-navigator", + "sha256": "556c2c1a622006177218590f956319731b40be32d16798915c6c93517e5527e0", + "size": 4947152, + "subdir": "linux-64", + "timestamp": 1553807898596, + "version": "1.9.7" + }, + "anaconda-navigator-1.9.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "5926c777f5c22a31d8d339aced871cb8", + "name": "anaconda-navigator", + "sha256": "69f07e2c4205908569d5eb6eb27d3bf99c749ebc642d10f427aeb38b50dfbf95", + "size": 4991346, + "subdir": "linux-64", + "timestamp": 1553807946513, + "version": "1.9.7" + }, + "anaconda-navigator-2.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "06736c25b435499895398d0003ae5c22", + "name": "anaconda-navigator", + "sha256": "4583cd420aaf67be9de56a502245a060d94cdf49ac38efc4ace6b6f6bfad76aa", + "size": 5956609, + "subdir": "linux-64", + "timestamp": 1619555576218, + "version": "2.0.1" + }, + "anaconda-navigator-2.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "0fcc07284d9f0163e574052c80c91084", + "name": "anaconda-navigator", + "sha256": "42b153c865d8e71ffe7484fae0de96aea025438aebe7f1297c8a3ba1e9fa2694", + "size": 5979357, + "subdir": "linux-64", + "timestamp": 1619551892953, + "version": "2.0.1" + }, + "anaconda-navigator-2.0.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "f152f9a92968d12ce883066fb198c870", + "name": "anaconda-navigator", + "sha256": "73983e348b79151ee07beeed272fa257196a7b5f90c396d64b9cd7253379edb6", + "size": 5942826, + "subdir": "linux-64", + "timestamp": 1619555584477, + "version": "2.0.1" + }, + "anaconda-navigator-2.0.1-py39_0.tar.bz2": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "0aba441e69da17ef8b7d801605a7ea91", + "name": "anaconda-navigator", + "sha256": "d74892aae07504a8eb0eb7cc92c59ebdabf77c6dee17444af836b63f6a4bd58a", + "size": 5964237, + "subdir": "linux-64", + "timestamp": 1619555575897, + "version": "2.0.1" + }, + "anaconda-navigator-2.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "691f9e1901635372407336af076a0bbf", + "name": "anaconda-navigator", + "sha256": "05b4394a311af07ee6fd7a578eef1aafa6aaa0317d3331c241f762e7e64ce509", + "size": 5962674, + "subdir": "linux-64", + "timestamp": 1620241072957, + "version": "2.0.3" + }, + "anaconda-navigator-2.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "3c6d4dc1807b30ba751e878208e4ae85", + "name": "anaconda-navigator", + "sha256": "9438aa1ff1a37b3a715accb09bddf02a1da7369f3f5fbddcffc3361c39a81e14", + "size": 5960592, + "subdir": "linux-64", + "timestamp": 1620244740967, + "version": "2.0.3" + }, + "anaconda-navigator-2.0.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "161dde7214719d6334b7061cd0a2e397", + "name": "anaconda-navigator", + "sha256": "fbb38e88ab022a0d45c61782c55ef062106f5c4d0a16f0838a2b6379b870dfaf", + "size": 5971794, + "subdir": "linux-64", + "timestamp": 1620245110376, + "version": "2.0.3" + }, + "anaconda-navigator-2.0.3-py39_0.tar.bz2": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "373a08c5b3e614a24ff99d4db4834e76", + "name": "anaconda-navigator", + "sha256": "ade2c3739e20095bafe9fca16ba748239d16de100f1f2f90a94d4f3e7c95654e", + "size": 5970095, + "subdir": "linux-64", + "timestamp": 1620245089868, + "version": "2.0.3" + }, + "anaconda-navigator-2.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "f775f64ace75ddabc0ce2c6334863fda", + "name": "anaconda-navigator", + "sha256": "a44d743c7cd78c76718a55255e693af62d46648fb22b1a9b3f9c27ea05914e13", + "size": 5884416, + "subdir": "linux-64", + "timestamp": 1626167384329, + "version": "2.0.4" + }, + "anaconda-navigator-2.0.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "db97c5868fe24f6468b6ede406474ccd", + "name": "anaconda-navigator", + "sha256": "213bce412308ebed836a14009166a1fb54d3ef3037b7e106b4a1684ccdf7a4da", + "size": 5905361, + "subdir": "linux-64", + "timestamp": 1626167547722, + "version": "2.0.4" + }, + "anaconda-navigator-2.0.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "bd1ea0ad63848c0393cb46f2ba54b976", + "name": "anaconda-navigator", + "sha256": "d92948cd6d39ab9bb0a62e4cc7008a843b23efa5eb29bb14634ea94d7c23a25d", + "size": 5917122, + "subdir": "linux-64", + "timestamp": 1626167545661, + "version": "2.0.4" + }, + "anaconda-navigator-2.0.4-py39_0.tar.bz2": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "776d4198d4fa7683bf5615350a248fed", + "name": "anaconda-navigator", + "sha256": "f48c7b84a1d3f4ee1c15ad6989e0cb97b255f71268c1e1d7c433f3680d470ea2", + "size": 5921833, + "subdir": "linux-64", + "timestamp": 1626167557168, + "version": "2.0.4" + }, + "anaconda-navigator-2.1.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "dc3503f0e9d76d77ed09c05e612370d0", + "name": "anaconda-navigator", + "sha256": "a4dd4dc36de9e8fc9d1ce0af604e098bc03f98be7921f0eac52e2bd8cade0770", + "size": 6109844, + "subdir": "linux-64", + "timestamp": 1632168954719, + "version": "2.1.0" + }, + "anaconda-navigator-2.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "094be3a9350145071f398622d7822537", + "name": "anaconda-navigator", + "sha256": "c0e7b25229ace6704b13a8904806b8a9abbe6e27361e644618f95848c6c21c7d", + "size": 6106927, + "subdir": "linux-64", + "timestamp": 1632158876414, + "version": "2.1.0" + }, + "anaconda-navigator-2.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "4f0e715978bde948542a5b9c9701c738", + "name": "anaconda-navigator", + "sha256": "d7719032b370dc94181244d5dc237f072291523252088f614e8949c44beeca9a", + "size": 6106293, + "subdir": "linux-64", + "timestamp": 1632168933600, + "version": "2.1.0" + }, + "anaconda-navigator-2.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "5c555c3958750b2dd11566a17fc1c747", + "name": "anaconda-navigator", + "sha256": "3294b76038472a6a34f67772daffb2863a82a743de60776d5c600a47de6bae4d", + "size": 6095558, + "subdir": "linux-64", + "timestamp": 1632168935833, + "version": "2.1.0" + }, + "anaconda-navigator-2.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "ujson", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "4b30335a666035e68104de6d9061b309", + "name": "anaconda-navigator", + "sha256": "81e69c69183e30b045f41e2a6223bb6c9b6779353b3b1e0c0d047e7f3671d97c", + "size": 6124173, + "subdir": "linux-64", + "timestamp": 1636985566974, + "version": "2.1.1" + }, + "anaconda-navigator-2.1.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "ujson", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "642f947e428677967a0da0cafd8f08a5", + "name": "anaconda-navigator", + "sha256": "5226b764ccf73b0c8012b8e14ee279ec8a22dbf0a1a06accf0d15c4b93982e24", + "size": 6123961, + "subdir": "linux-64", + "timestamp": 1636973071857, + "version": "2.1.1" + }, + "anaconda-navigator-2.1.1-py39_0.tar.bz2": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "ujson", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "3890cd5b3f2282a8b806db7f0c41d395", + "name": "anaconda-navigator", + "sha256": "976b15d1acd95db633ac80ac6ae2ab36b80c5942dd7a0f7571ab3de872c2b98d", + "size": 6136877, + "subdir": "linux-64", + "timestamp": 1636985570308, + "version": "2.1.1" + }, + "anaconda-navigator-2.1.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.2", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0", + "urllib3 >=1.26.4", + "libxml2 >=2.9.10", + "expat >=2.2.8" + ], + "depends": [ + "anaconda-client >=1.6.14", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "61f3e09c9f394cce456a05031971c953", + "name": "anaconda-navigator", + "sha256": "4069f9c668fc011785ae2241211eca6a91f6c079f28367705a1a417b1879b3dc", + "size": 6047600, + "subdir": "linux-64", + "timestamp": 1645725779508, + "version": "2.1.2" + }, + "anaconda-navigator-2.1.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "libxml2 >=2.9.10", + "cryptography >=3.3.2", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0" + ], + "depends": [ + "anaconda-client >=1.6.14", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "d0fd38fbdaa887bce3e08a647dba883b", + "name": "anaconda-navigator", + "sha256": "388e832b6c56a010c35bbe4780e062e193c381826508876cb4fa31e7ad54ce8e", + "size": 6025917, + "subdir": "linux-64", + "timestamp": 1645707648819, + "version": "2.1.2" + }, + "anaconda-navigator-2.1.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl >=1.1.1k", + "libxml2 >=2.9.10", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "pyopenssl >=17.5.0", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "428812683b7ff7fe545902ab13faccef", + "name": "anaconda-navigator", + "sha256": "3d51b203b0c8c5ec603f4a533c43406afc39576ea8b6560eb769e2a5eb8e109e", + "size": 6061904, + "subdir": "linux-64", + "timestamp": 1645725774874, + "version": "2.1.2" + }, + "anaconda-navigator-2.1.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=17.5.0", + "expat >=2.2.8", + "cryptography >=3.3.2", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "libxml2 >=2.9.10" + ], + "depends": [ + "anaconda-client >=1.6.14", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "0c795a527180b33ec44a414f0f9dfdce", + "name": "anaconda-navigator", + "sha256": "1de5639f76aa08da831172c237aedfba5ad568d9c6e9a606e2ff7395e1851e7a", + "size": 5871286, + "subdir": "linux-64", + "timestamp": 1648477412106, + "version": "2.1.4" + }, + "anaconda-navigator-2.1.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl >=1.1.1k", + "pyopenssl >=17.5.0", + "urllib3 >=1.26.4", + "libxml2 >=2.9.10", + "expat >=2.2.8", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "7ab299fec770a987e38c208408c09978", + "name": "anaconda-navigator", + "sha256": "f79f61f7e47f78399b6cb4f1538daf8dcf207cd10b1169e4c4e5b236e3c192f2", + "size": 5923542, + "subdir": "linux-64", + "timestamp": 1648459548808, + "version": "2.1.4" + }, + "anaconda-navigator-2.1.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "libxml2 >=2.9.10", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0", + "urllib3 >=1.26.4", + "expat >=2.2.8", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "9a773c9d89c930a4680c5401e8360dc0", + "name": "anaconda-navigator", + "sha256": "365bfe5e35bee033e2e72e9c5b2474d9631e6f329b6435a5ec65a4b36fb9647a", + "size": 5842369, + "subdir": "linux-64", + "timestamp": 1648477410209, + "version": "2.1.4" + }, + "anaconda-navigator-2.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.2", + "libxml2 >=2.9.10", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0" + ], + "depends": [ + "anaconda-client >=1.6.14", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "f4c275c3b4930e40a0596c3a2a5a1b1a", + "name": "anaconda-navigator", + "sha256": "8beb7187cdc44315e7ba30a9d792532aeaaa5a12bd9fba6912446f6d9d064001", + "size": 5986198, + "subdir": "linux-64", + "timestamp": 1653376703152, + "version": "2.2.0" + }, + "anaconda-navigator-2.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.2", + "libxml2 >=2.9.10", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0" + ], + "depends": [ + "anaconda-client >=1.6.14", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "0b910a66a73288fc35a5f89e3e3c5428", + "name": "anaconda-navigator", + "sha256": "03bfd22187c350fdadca251b7a32b42d0fc31f180e08cb178539cf70e2932f8c", + "size": 5988484, + "subdir": "linux-64", + "timestamp": 1653376749882, + "version": "2.2.0" + }, + "anaconda-navigator-2.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.2", + "libxml2 >=2.9.10", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0" + ], + "depends": [ + "anaconda-client >=1.6.14", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "554e670a2e15327ab7b7b8ee446767df", + "name": "anaconda-navigator", + "sha256": "47cbf2f4969821fa84d797c42a3e6c4b0922fbf003971fb9583b3ae5744ae335", + "size": 5987686, + "subdir": "linux-64", + "timestamp": 1653376650070, + "version": "2.2.0" + }, + "anaconda-navigator-2.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl >=1.1.1k", + "cryptography >=3.3.2", + "pyopenssl >=17.5.0", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "libxml2 >=2.9.10" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "e4e951dd2254975e7734ff7191cb8e01", + "name": "anaconda-navigator", + "sha256": "4a41b9e38cee37c455581f6658ab730311001668d7b65d346ffb34940038eac2", + "size": 6023995, + "subdir": "linux-64", + "timestamp": 1662652275105, + "version": "2.3.0" + }, + "anaconda-navigator-2.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl >=1.1.1k", + "cryptography >=3.3.2", + "pyopenssl >=17.5.0", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "libxml2 >=2.9.10" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "05932dc5fa069bfb48466b909ccf0d61", + "name": "anaconda-navigator", + "sha256": "5a6d30d85f0366a32706d5a82a914b4e31d4c55040cb56dad8c7d0e7a6c38767", + "size": 6009656, + "subdir": "linux-64", + "timestamp": 1662652374798, + "version": "2.3.0" + }, + "anaconda-navigator-2.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl >=1.1.1k", + "cryptography >=3.3.2", + "pyopenssl >=17.5.0", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "libxml2 >=2.9.10" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "9ebd310c8443962bd3270eb507ff1b42", + "name": "anaconda-navigator", + "sha256": "f63d4a6f62e1d2df8c22dff149b3990f484f75a03df29cfa00c2ed9eff178090", + "size": 6017023, + "subdir": "linux-64", + "timestamp": 1662652324251, + "version": "2.3.0" + }, + "anaconda-navigator-2.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl >=1.1.1k", + "cryptography >=3.3.2", + "pyopenssl >=17.5.0", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "libxml2 >=2.9.10" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "7af82a4b2066afde2ac37d985769a9b6", + "name": "anaconda-navigator", + "sha256": "7b838480b56aaeacf5aebd67345d4b88432dadc575fd412abe96a27968d1e6ae", + "size": 6016091, + "subdir": "linux-64", + "timestamp": 1662652197748, + "version": "2.3.0" + }, + "anaconda-navigator-2.3.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "libxml2 >=2.9.10", + "expat >=2.2.8", + "cryptography >=3.3.2", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "b39f952e2852deb2d0d4c84a46314a81", + "name": "anaconda-navigator", + "sha256": "1eb251ba506d3691db8ca1b4e79b5a36617905f1d750871f624d40d28c36edc8", + "size": 6042814, + "subdir": "linux-64", + "timestamp": 1664460760359, + "version": "2.3.1" + }, + "anaconda-navigator-2.3.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "libxml2 >=2.9.10", + "expat >=2.2.8", + "cryptography >=3.3.2", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "ddd85648ddc80bef88a9013ff1c500fe", + "name": "anaconda-navigator", + "sha256": "2a19a403e08e56b1229c91f84d2f56b2b53599149c7565531efc8bffa0579107", + "size": 6033575, + "subdir": "linux-64", + "timestamp": 1664460811085, + "version": "2.3.1" + }, + "anaconda-navigator-2.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "libxml2 >=2.9.10", + "expat >=2.2.8", + "cryptography >=3.3.2", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "a79734400e7f8e71f33d96d5eff2c3f6", + "name": "anaconda-navigator", + "sha256": "1254b0f15652ffe429d7d5dbe92c37bf981e87561de10fb58d0324b985ec2067", + "size": 6032850, + "subdir": "linux-64", + "timestamp": 1664460901271, + "version": "2.3.1" + }, + "anaconda-navigator-2.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "libxml2 >=2.9.10", + "expat >=2.2.8", + "cryptography >=3.3.2", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "167ba6a4574ba494e22a01a3696a3a74", + "name": "anaconda-navigator", + "sha256": "92a273420bb0188912c8079e2b59e36930f45ff22e9ddbd055055c405d67c4be", + "size": 6033759, + "subdir": "linux-64", + "timestamp": 1664460857519, + "version": "2.3.1" + }, + "anaconda-navigator-2.3.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "expat >=2.2.8", + "pyopenssl >=17.5.0", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "libxml2 >=2.9.10", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "0015af719b19644a7036692d5b538620", + "name": "anaconda-navigator", + "sha256": "4803f7cbc36225beff9576d261f038adfdde51c2bc892f0572f38a5e80a0d70f", + "size": 6020244, + "subdir": "linux-64", + "timestamp": 1665154193033, + "version": "2.3.2" + }, + "anaconda-navigator-2.3.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "expat >=2.2.8", + "pyopenssl >=17.5.0", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "libxml2 >=2.9.10", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "af5ca0ab32615812a53de921e0fbc3c2", + "name": "anaconda-navigator", + "sha256": "613ab5bf045058a790f2e0df627c3b1b596416ff13c7e8c181c0a8bdd5a46fe6", + "size": 6006819, + "subdir": "linux-64", + "timestamp": 1665154241348, + "version": "2.3.2" + }, + "anaconda-navigator-2.3.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "expat >=2.2.8", + "pyopenssl >=17.5.0", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "libxml2 >=2.9.10", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "b129b5409c0bed651a2020976c64d1ad", + "name": "anaconda-navigator", + "sha256": "66998e8ae714af924f7de019b389a4904e26bfa93bf0c8ea71faf91487c5638e", + "size": 6012382, + "subdir": "linux-64", + "timestamp": 1665154287866, + "version": "2.3.2" + }, + "anaconda-navigator-2.3.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "expat >=2.2.8", + "pyopenssl >=17.5.0", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "libxml2 >=2.9.10", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "f284e9683f5e8f2cdcede70b883133a7", + "name": "anaconda-navigator", + "sha256": "67f26497994a3b9da0a1ca953af63b6d59d92c951c37969242bfeee981d64f45", + "size": 6012242, + "subdir": "linux-64", + "timestamp": 1665154126313, + "version": "2.3.2" + }, + "anaconda-navigator-2.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=17.5.0", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "libxml2 >=2.9.10", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda !=22.11.*", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "d1eab61135249782c3cf60814cc32953", + "name": "anaconda-navigator", + "sha256": "5b7f4c1cb1ec82ca2f5699edc8ae799c46268a84de2174e8bdf43ea84f3ab8c7", + "size": 6005448, + "subdir": "linux-64", + "timestamp": 1677517204438, + "version": "2.4.0" + }, + "anaconda-navigator-2.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=17.5.0", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "libxml2 >=2.9.10", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda !=22.11.*", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "b370aba5f19834bb0aa9ac21410ddf1f", + "name": "anaconda-navigator", + "sha256": "b18946ad4764718abdf209d9aab8cd870c146ea986f722d78a5dfa91699d2b6e", + "size": 5997227, + "subdir": "linux-64", + "timestamp": 1677517251279, + "version": "2.4.0" + }, + "anaconda-navigator-2.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=17.5.0", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "libxml2 >=2.9.10", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda !=22.11.*", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "2c85a55bdc6e0c814a07ee2d1aedd4e9", + "name": "anaconda-navigator", + "sha256": "2c158d6ab557cc677f4ae8958297760754916e05f49d2191dbb16c7a8fbaeee3", + "size": 5997737, + "subdir": "linux-64", + "timestamp": 1677517108772, + "version": "2.4.0" + }, + "anaconda-navigator-2.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=17.5.0", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "libxml2 >=2.9.10", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda !=22.11.*", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "c63b354ec3880243a7f4f3f27c5b2466", + "name": "anaconda-navigator", + "sha256": "598334835f15d5555576e7add58b40342b3be9b53f5dd65bc8646e629befef46", + "size": 5997607, + "subdir": "linux-64", + "timestamp": 1677517159436, + "version": "2.4.0" + }, + "anaconda-oss-docs-1.0.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "md5": "584ba2d26adfbc679acf8a98cea63589", + "name": "anaconda-oss-docs", + "sha256": "4e57760001fe09843c7f13daec74c155dead9487e4d5e2a7fc3beb5a453845c1", + "size": 258678854, + "subdir": "linux-64", + "timestamp": 1516913566172, + "version": "1.0.1" + }, + "anaconda-oss-docs-1.0.2-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "md5": "5b7634708736f6bc4a0f4b7e284d99da", + "name": "anaconda-oss-docs", + "sha256": "dec5a16cba3684cb0e68b6640a1310079e924c734e780e4bc8081cdf6fa4fec9", + "size": 299841607, + "subdir": "linux-64", + "timestamp": 1520632294339, + "version": "1.0.2" + }, + "anaconda-project-0.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "conda-pack", + "jinja2", + "python >=3.10,<3.11.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8daaeef52ccc67f9eff1cff996f1de56", + "name": "anaconda-project", + "sha256": "0531791fcea2b31d9bf30c1c316d02fcd2a313e94d694dc5c6d66858235256b4", + "size": 544860, + "subdir": "linux-64", + "timestamp": 1658929530190, + "version": "0.11.0" + }, + "anaconda-project-0.11.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "conda-pack", + "jinja2", + "python >=3.7,<3.8.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a1d2896232af0d416af25011fbd1561", + "name": "anaconda-project", + "sha256": "442b7fe8025d435671c950685c6f8125f8e9b107dc1a96c663e4e76f85aebbb3", + "size": 542510, + "subdir": "linux-64", + "timestamp": 1658929559737, + "version": "0.11.0" + }, + "anaconda-project-0.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "conda-pack", + "jinja2", + "python >=3.8,<3.9.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "782c52b0425dc32f185c00fb26ec6787", + "name": "anaconda-project", + "sha256": "ab29fe62b2e332b0b8de47b0b9e44bcf915e996bd95fa532a2aa33d8ba73bf99", + "size": 543188, + "subdir": "linux-64", + "timestamp": 1658929489276, + "version": "0.11.0" + }, + "anaconda-project-0.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "conda-pack", + "jinja2", + "python >=3.9,<3.10.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1dbbac9c28b6bec0fcc2826c33245ca", + "name": "anaconda-project", + "sha256": "1f22bb26c4f17719b3c532140ae8ce4a996b925b79bc7760d222ce453842dad3", + "size": 540780, + "subdir": "linux-64", + "timestamp": 1658929589824, + "version": "0.11.0" + }, + "anaconda-project-0.11.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "conda-pack", + "jinja2", + "python >=3.10,<3.11.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0ecf538fdbacf826021d0a4b2fa1fa0c", + "name": "anaconda-project", + "sha256": "d8758e6c8849fac83f6292c4cf2987ae016bafe5aeb042bfd1d86004959e156d", + "size": 546620, + "subdir": "linux-64", + "timestamp": 1660340010423, + "version": "0.11.1" + }, + "anaconda-project-0.11.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "conda-pack", + "jinja2", + "python >=3.11,<3.12.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1caf3993c62037a6da2ef7ac8a9b7516", + "name": "anaconda-project", + "sha256": "0baa666d07e817b34dd125e6c51db0b0dc442831bc1fb521212dc9b1d7851c9b", + "size": 729948, + "subdir": "linux-64", + "timestamp": 1676846743376, + "version": "0.11.1" + }, + "anaconda-project-0.11.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "conda-pack", + "jinja2", + "python >=3.7,<3.8.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85464e765add3248a03331f3f485d23e", + "name": "anaconda-project", + "sha256": "fce011ef471049660e1bfe5630ea499f2cb970db3dae53bb44a4257ed27600ad", + "size": 542911, + "subdir": "linux-64", + "timestamp": 1660340044818, + "version": "0.11.1" + }, + "anaconda-project-0.11.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "conda-pack", + "jinja2", + "python >=3.8,<3.9.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6b0c787dc9dfa7e388804388324565f8", + "name": "anaconda-project", + "sha256": "697c8858e553c32cddc67601012a5e33f80e8f8c929e9f5b15b27dc7cbac3844", + "size": 544176, + "subdir": "linux-64", + "timestamp": 1660339965043, + "version": "0.11.1" + }, + "anaconda-project-0.11.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "conda-pack", + "jinja2", + "python >=3.9,<3.10.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "21c3ea99a6ba3b59d08e9e2ba49fcbef", + "name": "anaconda-project", + "sha256": "4c8b6344048b21435d77ef0244fe3ceb71bfc671b360289ac716db8da280d56f", + "size": 541790, + "subdir": "linux-64", + "timestamp": 1660339931462, + "version": "0.11.1" + }, + "anaconda-project-0.8.0-py27hd7a9a97_0.tar.bz2": { + "build": "py27hd7a9a97_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=2.7,<2.8.0a0", + "requests", + "ruamel_yaml", + "tornado" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fce8f5096d9028442f3ce1d815b2b70b", + "name": "anaconda-project", + "sha256": "67574e8a9b05a84871bbf76fa21049acf00e43d598407756f1e95cc7038218ef", + "size": 211807, + "subdir": "linux-64", + "timestamp": 1505852237048, + "version": "0.8.0" + }, + "anaconda-project-0.8.0-py35hb597f32_0.tar.bz2": { + "build": "py35hb597f32_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=3.5,<3.6.0a0", + "requests", + "ruamel_yaml", + "tornado" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "da8cade91e6ba266b76b26f2dc654af8", + "name": "anaconda-project", + "sha256": "096543823617759ff76884c63b5d4a5ba4e77c71c7259ca9c41747401d7010ae", + "size": 215859, + "subdir": "linux-64", + "timestamp": 1505852256583, + "version": "0.8.0" + }, + "anaconda-project-0.8.0-py36h29abdf5_0.tar.bz2": { + "build": "py36h29abdf5_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=3.6,<3.7.0a0", + "requests", + "ruamel_yaml", + "tornado" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f9405dc693979ddb0aff3afce7a08450", + "name": "anaconda-project", + "sha256": "b53cb5b517d84f75bdb36a6d2970963009d0f63ed30020254a5e2dbf81031572", + "size": 213749, + "subdir": "linux-64", + "timestamp": 1505852276338, + "version": "0.8.0" + }, + "anaconda-project-0.8.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=2.7,<2.8.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e6d4ee6f9c1a04af6ac75da7886b6717", + "name": "anaconda-project", + "sha256": "6e19e67f85c69b23f81bcf65df71d62ba49d6930a6e37812b8887034e5034a9a", + "size": 482307, + "subdir": "linux-64", + "timestamp": 1530737483623, + "version": "0.8.2" + }, + "anaconda-project-0.8.2-py27h236b58a_0.tar.bz2": { + "build": "py27h236b58a_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=2.7,<2.8.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c1869385f74938d9fee9679a9916e91a", + "name": "anaconda-project", + "sha256": "e33e9174d20882771ee497cc6276384e5a95ce45ef26413ed2cf9853ae36f2eb", + "size": 482877, + "subdir": "linux-64", + "timestamp": 1511980353055, + "version": "0.8.2" + }, + "anaconda-project-0.8.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=3.5,<3.6.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0f5298cbb5b513036ef119df647a6f5d", + "name": "anaconda-project", + "sha256": "6111d69e5d403f8bba9d00966c670c869abf00f7a9b4d008515502ecc58f2d4c", + "size": 493907, + "subdir": "linux-64", + "timestamp": 1534352711805, + "version": "0.8.2" + }, + "anaconda-project-0.8.2-py35h7d62c80_0.tar.bz2": { + "build": "py35h7d62c80_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=3.5,<3.6.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "689902a51036f53acb0fda229d9bfe00", + "name": "anaconda-project", + "sha256": "b52e721ef13f63e676414ef29d1ff1ceb083090cc9e6dc11ceb07aa217abcf0e", + "size": 494453, + "subdir": "linux-64", + "timestamp": 1511980366712, + "version": "0.8.2" + }, + "anaconda-project-0.8.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=3.6,<3.7.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "71efb5718ab74017db3fcb59559c9fb7", + "name": "anaconda-project", + "sha256": "ee1476f750efc24cccb506d9004a552586dc1ae21234cd807a3c1fb493290941", + "size": 488961, + "subdir": "linux-64", + "timestamp": 1530737448701, + "version": "0.8.2" + }, + "anaconda-project-0.8.2-py36h44fb852_0.tar.bz2": { + "build": "py36h44fb852_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=3.6,<3.7.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3037b1f31d995d03ea67a3f6f693913c", + "name": "anaconda-project", + "sha256": "0b4318c2f74c2a7144f8b3fdaf2116244276dc81be96d21f0d5ab823b67857e6", + "size": 488716, + "subdir": "linux-64", + "timestamp": 1511980346467, + "version": "0.8.2" + }, + "anaconda-project-0.8.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=3.7,<3.8.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "614694b03c463c11ff05bed273d5c0c5", + "name": "anaconda-project", + "sha256": "ca0eb19aa942264db41a191c22986f4191f2bb7e9bc7be9bf43ef2c802a56fe0", + "size": 486775, + "subdir": "linux-64", + "timestamp": 1530737521161, + "version": "0.8.2" + }, + "ansi2html-1.2.0-py27h9a6bcf5_0.tar.bz2": { + "build": "py27h9a6bcf5_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "General Public License v3.0", + "license_family": "GPL3", + "md5": "819b5c83ad93643f7353fa59ed1b064e", + "name": "ansi2html", + "sha256": "596b3762a0e465c94c5c9d0904d072fd30a9f553e900ea50cac42a394273a9ec", + "size": 31137, + "subdir": "linux-64", + "timestamp": 1507576415372, + "version": "1.2.0" + }, + "ansi2html-1.2.0-py35h38623d0_0.tar.bz2": { + "build": "py35h38623d0_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "General Public License v3.0", + "license_family": "GPL3", + "md5": "304fa9d4628fc9e9d92b2638b16ce686", + "name": "ansi2html", + "sha256": "35516bbf260f796b77ef3faa359a3d633333ede20179745350dedefef7f17dfb", + "size": 31537, + "subdir": "linux-64", + "timestamp": 1507576440142, + "version": "1.2.0" + }, + "ansi2html-1.2.0-py36h7be8927_0.tar.bz2": { + "build": "py36h7be8927_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "General Public License v3.0", + "license_family": "GPL3", + "md5": "9986682cf9660180d76e9d55be7ebe2c", + "name": "ansi2html", + "sha256": "7daa4386a7f09c4e8170acd68f2543fdc55889784671851e3bde6a93a35dbac5", + "size": 31465, + "subdir": "linux-64", + "timestamp": 1507576438789, + "version": "1.2.0" + }, + "ansi2html-1.3.0-py27hb02a7bf_0.tar.bz2": { + "build": "py27hb02a7bf_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "376d726e14fea70110e7730f7299088b", + "name": "ansi2html", + "sha256": "518e053322baaa1165e7b86f9bd0be602f3e10bfec966a09b05072f89be910c9", + "size": 33480, + "subdir": "linux-64", + "timestamp": 1512033326674, + "version": "1.3.0" + }, + "ansi2html-1.3.0-py35h81cba0a_0.tar.bz2": { + "build": "py35h81cba0a_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "a492c7b1c20755e33f8e908de549b470", + "name": "ansi2html", + "sha256": "a14034bd103173c0fdd8fcde945c82685a18950291edc83a17693b893f19f312", + "size": 34117, + "subdir": "linux-64", + "timestamp": 1512033327264, + "version": "1.3.0" + }, + "ansi2html-1.3.0-py36haaf8d63_0.tar.bz2": { + "build": "py36haaf8d63_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "ee9852d32325896175302f5d568ad66f", + "name": "ansi2html", + "sha256": "2482789f6cdb7c48030770ebbc59cf4ff01b9c87c6483cdeb23f3c021c90694e", + "size": 34024, + "subdir": "linux-64", + "timestamp": 1512033297870, + "version": "1.3.0" + }, + "ansi2html-1.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "30cb6294716543ecdf8e2d8b9ba8b90a", + "name": "ansi2html", + "sha256": "f8dbc39549c3fb55e45f4d13ce2db62c3eb176efd6b026570355e6834356ec53", + "size": 31427, + "subdir": "linux-64", + "timestamp": 1523944021068, + "version": "1.4.2" + }, + "ansi2html-1.4.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "f1b6259cd2ad34aaa3054efb10ec4b8c", + "name": "ansi2html", + "sha256": "fea7b3090e7185922c6f2f2436ce0ff6a0b0fa646934c7b75a8d9c97ae60c1b0", + "size": 32042, + "subdir": "linux-64", + "timestamp": 1523944004132, + "version": "1.4.2" + }, + "ansi2html-1.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "c0e3b31f8e14cef8c1d4b81a53a9dc13", + "name": "ansi2html", + "sha256": "90fc8ac6a4a4efe83b4cd2506ad944e0ae7897f1b434ea308905fff8ecaea51f", + "size": 31732, + "subdir": "linux-64", + "timestamp": 1523944050920, + "version": "1.4.2" + }, + "ansi2html-1.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "3fb17eb005302036f6f4e7fee4916861", + "name": "ansi2html", + "sha256": "f014271a4cfa09e9ec78b9129a5398be275d6b1d84d981777c796192e7a3f253", + "size": 31473, + "subdir": "linux-64", + "timestamp": 1530737551994, + "version": "1.4.2" + }, + "ansi2html-1.5.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "48db91ffc48ad0c6c3f2c3e0b1b99565", + "name": "ansi2html", + "sha256": "95f23d2c5429f433827ce6dc6c86a63d9fcfe54bc7305fce5aed4ed6f2908b44", + "size": 33083, + "subdir": "linux-64", + "timestamp": 1540956030819, + "version": "1.5.2" + }, + "ansi2html-1.5.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "da36a6650e9160012395941d18ed8c89", + "name": "ansi2html", + "sha256": "107d0c870b1993b3d1cf3c1545c13aa80903f128bcd4a1dfddbbb88bb869e353", + "size": 33576, + "subdir": "linux-64", + "timestamp": 1640788105362, + "version": "1.5.2" + }, + "ansi2html-1.5.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "85aa3b17e7ac74a81b431fbc06327a96", + "name": "ansi2html", + "sha256": "f104c285ddcd955ae56ea2a304c7c065080b8395005496daa50bcc0f7246852b", + "size": 40210, + "subdir": "linux-64", + "timestamp": 1676906868140, + "version": "1.5.2" + }, + "ansi2html-1.5.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "5fc5d500e5b5ed7d75a433ad14300065", + "name": "ansi2html", + "sha256": "cf9972f30ba1e33e6b6fdcb03c6149611f61bb8c30797e754d64e331f4f655cb", + "size": 33690, + "subdir": "linux-64", + "timestamp": 1540956036923, + "version": "1.5.2" + }, + "ansi2html-1.5.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "8c4a3725e8a1f207421c0afd4005ea18", + "name": "ansi2html", + "sha256": "3611847f065796a2d3e5b50bcf3485e654614338f17d77fb6f9416a509258438", + "size": 252841, + "subdir": "linux-64", + "timestamp": 1613036330166, + "version": "1.5.2" + }, + "ansi2html-1.5.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "1140c437d65ae5e3faaad258c5b3f828", + "name": "ansi2html", + "sha256": "85c861735060111fdfa1d295ed2b4edfc43587e83a0edea5746638aa20bb27e3", + "size": 33541, + "subdir": "linux-64", + "timestamp": 1540956031369, + "version": "1.5.2" + }, + "ansi2html-1.5.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "c433f72c91a08673e91c0790e7c7bb8b", + "name": "ansi2html", + "sha256": "8d4823036537d9747ee6405b8e593afb51019d6d1adfd48ed8358c07bfce6113", + "size": 252629, + "subdir": "linux-64", + "timestamp": 1613036317889, + "version": "1.5.2" + }, + "ansi2html-1.5.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "123f210ec8741340d008d3db4e540a63", + "name": "ansi2html", + "sha256": "ecfc979d889bf5bb893d229fdb9ea15665158c71fddd0f566cdce44e5b394e60", + "size": 33538, + "subdir": "linux-64", + "timestamp": 1574097791164, + "version": "1.5.2" + }, + "ansi2html-1.5.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "dba6c9ffba7bb48ca06e7b0a8362f429", + "name": "ansi2html", + "sha256": "b7ce22d42c1c98c560d3d0bdc62c68fad136f07544f1c1217301246cd2a6db75", + "size": 252726, + "subdir": "linux-64", + "timestamp": 1613036318366, + "version": "1.5.2" + }, + "ansi2html-1.5.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "e813d2d21107c2ed2d7855f08e6a4c88", + "name": "ansi2html", + "sha256": "dab29495bda5eca3bfc9e0f86d02d5f25114cd4a588c7a3747491b515b3174c7", + "size": 252409, + "subdir": "linux-64", + "timestamp": 1613035573249, + "version": "1.5.2" + }, + "ansi2html-1.8.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "f3a02a7ab4a5914f4da92b1b8565b67f", + "name": "ansi2html", + "sha256": "7fad8c1916b47858bed2d3673a9cb8cd0fd04b1d3c299bc443e3401d50dc4df8", + "size": 41765, + "subdir": "linux-64", + "timestamp": 1678961260267, + "version": "1.8.0" + }, + "ansi2html-1.8.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "f073deb0a5fd2798373d439d6264302b", + "name": "ansi2html", + "sha256": "3763260d71b7d3ada0832d1c36e7109c52709ae785a045c55d0ef0fa4cc6a1aa", + "size": 49504, + "subdir": "linux-64", + "timestamp": 1678961207688, + "version": "1.8.0" + }, + "ansi2html-1.8.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "85561694ca8f1b9c43ed1c6285063173", + "name": "ansi2html", + "sha256": "640f07562e371c206505b8f24f731cfde0c520e386616b20bca650ba7a77d635", + "size": 41476, + "subdir": "linux-64", + "timestamp": 1678961180675, + "version": "1.8.0" + }, + "ansi2html-1.8.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "2f336489e3f1acb6607829ff8f2dbb35", + "name": "ansi2html", + "sha256": "6bd022c003568467da813e95ee8de5bea990ecc8ac42215b65f9c0f024bc986a", + "size": 41413, + "subdir": "linux-64", + "timestamp": 1678961233272, + "version": "1.8.0" + }, + "ant-1.10.8-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "openjdk" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4749d6e361fde7497eadd544435f1bbd", + "name": "ant", + "sha256": "c89ba145ddea7794a9129e03a53352c818ee40d6b103774d94bf9f0944f0250d", + "size": 2668906, + "subdir": "linux-64", + "timestamp": 1631882736310, + "version": "1.10.8" + }, + "ant-1.9.9-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "openjdk" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e467b0fbf8592f7f1d2d1f48f0de5712", + "name": "ant", + "sha256": "5629dd4be9981c76341bd8090e2e17d0e8ce3b6f5a1acfdd47f829c7c4bcc1d7", + "size": 2143441, + "subdir": "linux-64", + "timestamp": 1516111132973, + "version": "1.9.9" + }, + "anyio-2.0.2-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "constrains": [ + "trio >=0.16", + "curio >=1.4" + ], + "depends": [ + "async_generator", + "dataclasses", + "idna >=2.8", + "python >=3.6,<3.7.0a0", + "sniffio >=1.1", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9bd203e889b11cd739d2878a63ceafe", + "name": "anyio", + "sha256": "2efe81aaa77af138a334f40716614edbb713ae8966697dba6fb6ee43ca1bd17b", + "size": 116024, + "subdir": "linux-64", + "timestamp": 1616017052845, + "version": "2.0.2" + }, + "anyio-2.0.2-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.7,<3.8.0a0", + "sniffio >=1.1", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c8585f5cee1afc16e0675139099cda2", + "name": "anyio", + "sha256": "d192abae8af2cb4342a494f314880f2bf0f44b95745c8cdc5689e3e3a6cfd779", + "size": 116066, + "subdir": "linux-64", + "timestamp": 1616015142117, + "version": "2.0.2" + }, + "anyio-2.0.2-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "constrains": [ + "trio >=0.16", + "curio >=1.4" + ], + "depends": [ + "idna >=2.8", + "python >=3.8,<3.9.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f89f185c0ccb23e67d7fc384d85c817c", + "name": "anyio", + "sha256": "61621f8b0094d81d55846dd64f3063a0f2afeb5e0c1c8803b1a68904d808da19", + "size": 116790, + "subdir": "linux-64", + "timestamp": 1616016581817, + "version": "2.0.2" + }, + "anyio-2.0.2-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "constrains": [ + "trio >=0.16", + "curio >=1.4" + ], + "depends": [ + "idna >=2.8", + "python >=3.9,<3.10.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eadc405a65aac0e85e1413a2dbcc39e3", + "name": "anyio", + "sha256": "3fe5f2cbb00377029fc88588fc81e65b593fe4838d128903de0ca575ca1e8bee", + "size": 117253, + "subdir": "linux-64", + "timestamp": 1616017051405, + "version": "2.0.2" + }, + "anyio-2.1.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "async_generator", + "dataclasses", + "idna >=2.8", + "python >=3.6,<3.7.0a0", + "sniffio >=1.1", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5bc98f8812125a659062dd29a136072b", + "name": "anyio", + "sha256": "ae5959990b81f8cb0780d806501909e036379ef4a2829520c976088ee1195faf", + "size": 115646, + "subdir": "linux-64", + "timestamp": 1616176646585, + "version": "2.1.0" + }, + "anyio-2.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "trio >=0.16", + "curio >=1.4" + ], + "depends": [ + "idna >=2.8", + "python >=3.7,<3.8.0a0", + "sniffio >=1.1", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c404cacd02f049dc4a39e8c342d0d74", + "name": "anyio", + "sha256": "b322b6506909f47ec4a547d7702ce1f9c8a3c95c29484998e7a77df5f5e2cdb2", + "size": 116092, + "subdir": "linux-64", + "timestamp": 1616174653938, + "version": "2.1.0" + }, + "anyio-2.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.8,<3.9.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d1d70064fe0b42fe6147f79b1ad645d", + "name": "anyio", + "sha256": "530537dd0a8f05e15b71ec248d6a9317f6118cf0e1be0f6b12477ac90bd207c7", + "size": 116654, + "subdir": "linux-64", + "timestamp": 1616176645255, + "version": "2.1.0" + }, + "anyio-2.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.9,<3.10.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60f892b696ac13553c8d2c7e1d0130b7", + "name": "anyio", + "sha256": "ba24358240686f004605930bde1482f60b715cefa6718b337870e04c8cd5d9b5", + "size": 116900, + "subdir": "linux-64", + "timestamp": 1616176642548, + "version": "2.1.0" + }, + "anyio-2.2.0-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "constrains": [ + "trio >=0.16", + "curio >=1.4" + ], + "depends": [ + "idna >=2.8", + "python >=3.10,<3.11.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92eaa0767b60fd20219f69e93a278b07", + "name": "anyio", + "sha256": "36ec497afed876bc5362cf881b56eb58e371ba10145d0ea328fbf0559a78a453", + "size": 121941, + "subdir": "linux-64", + "timestamp": 1641551281407, + "version": "2.2.0" + }, + "anyio-2.2.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "trio >=0.16", + "curio >=1.4" + ], + "depends": [ + "async_generator", + "dataclasses", + "idna >=2.8", + "python >=3.6,<3.7.0a0", + "sniffio >=1.1", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "46295b8ab627da2e20beb1e5259dbb92", + "name": "anyio", + "sha256": "51607983c1db860909e9557684c94b18002d45dc2ad5d636b51d0174dd5e30d8", + "size": 117786, + "subdir": "linux-64", + "timestamp": 1616177531626, + "version": "2.2.0" + }, + "anyio-2.2.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "constrains": [ + "trio >=0.16", + "curio >=1.4" + ], + "depends": [ + "async_generator", + "dataclasses", + "idna >=2.8", + "python >=3.6,<3.7.0a0", + "sniffio >=1.1", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8a520ff7535ffd0c9e61939de4d3544", + "name": "anyio", + "sha256": "5607d701ae37b7c1e1d9ff01861cb58fbc77c4916e60e87a3174aa07366375a1", + "size": 122370, + "subdir": "linux-64", + "timestamp": 1617783327676, + "version": "2.2.0" + }, + "anyio-2.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.7,<3.8.0a0", + "sniffio >=1.1", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8dd96b8afa069d20deb1ad410cf5510", + "name": "anyio", + "sha256": "84d5168471d23acb13a66e5e9cc5a9ffd1588d87d7e49ded983cf6d8be2e706a", + "size": 117879, + "subdir": "linux-64", + "timestamp": 1616177799105, + "version": "2.2.0" + }, + "anyio-2.2.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.7,<3.8.0a0", + "sniffio >=1.1", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c9b07efcb89014a9647ec891bc82e62", + "name": "anyio", + "sha256": "9bd61dc617145ac608676442935638ba6b0c18990a463034d7af728eb796e0e2", + "size": 122449, + "subdir": "linux-64", + "timestamp": 1617783315538, + "version": "2.2.0" + }, + "anyio-2.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.8,<3.9.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37ed75aff29cef0d107694922c3c8ea4", + "name": "anyio", + "sha256": "c0a0d87739f2bfa584c76a8cd44d68ee32903e11a1c627812c42c6a6d6a2d7e8", + "size": 118558, + "subdir": "linux-64", + "timestamp": 1616177804582, + "version": "2.2.0" + }, + "anyio-2.2.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.8,<3.9.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c35da68cc5e7b887790abc5afc0297a", + "name": "anyio", + "sha256": "2a285f5dbcfd83a255d95a65ec82e59397548028e0f6fa20759a16879392d811", + "size": 123028, + "subdir": "linux-64", + "timestamp": 1617783319863, + "version": "2.2.0" + }, + "anyio-2.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.9,<3.10.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d83a8a7fdff702eae3363672c5eb60c4", + "name": "anyio", + "sha256": "0b7b429741d34f5b578988c2ab0d63891d60ea739c8560caef8c60bf486087d0", + "size": 119166, + "subdir": "linux-64", + "timestamp": 1616175815468, + "version": "2.2.0" + }, + "anyio-2.2.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.9,<3.10.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96271121c2f50525055baaa7cea92138", + "name": "anyio", + "sha256": "4586ca376c17403c001e3ccbcbd61b0870a857bf334cf689a2d07d4ad4bffd5c", + "size": 123591, + "subdir": "linux-64", + "timestamp": 1617783322568, + "version": "2.2.0" + }, + "anyio-3.5.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.10,<3.11.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "113dcf34ca0d120a07b96997e221c3e2", + "name": "anyio", + "sha256": "1b165b1adae42121fc400da4825e3071cc8b257f4070aefe0bf4a5e8decf5932", + "size": 165033, + "subdir": "linux-64", + "timestamp": 1644481743158, + "version": "3.5.0" + }, + "anyio-3.5.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.11,<3.12.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d809300d798d1da765f92db48cf3c396", + "name": "anyio", + "sha256": "0f1e2a8dc655473a9af5c72da63c22d564b5178269b75b94494ffc6fd0ee1bf7", + "size": 212474, + "subdir": "linux-64", + "timestamp": 1676823785292, + "version": "3.5.0" + }, + "anyio-3.5.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.7,<3.8.0a0", + "sniffio >=1.1", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "075c702e4873dfa8c1a68913294aaf93", + "name": "anyio", + "sha256": "c289c1f43fe76e76fcbeca92b96a342496a347aa4acd303ac300758ed1d5da31", + "size": 160018, + "subdir": "linux-64", + "timestamp": 1644481739584, + "version": "3.5.0" + }, + "anyio-3.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.8,<3.9.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "54aa956eba07f586a9cdf1edd795ff6a", + "name": "anyio", + "sha256": "54481e7be198702a59018dbdcc65cc32cdbc32efd372380cdfc3ef6e2c8637e4", + "size": 161551, + "subdir": "linux-64", + "timestamp": 1644481732835, + "version": "3.5.0" + }, + "anyio-3.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.9,<3.10.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2cf39d906cc321896ffe3e5d33d80c5c", + "name": "anyio", + "sha256": "1e383e4d196ea09008d70acb793217fba86597e0ff44725b3d1e4aad0797d525", + "size": 162166, + "subdir": "linux-64", + "timestamp": 1644463608931, + "version": "3.5.0" + }, + "anyjson-0.3.3-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a0adb4d6ac564132369a861bbd350f44", + "name": "anyjson", + "sha256": "23021981ba241afcf5ce5854c4d09f3e7a34f5acf6d9098f21d4746c250e25f7", + "size": 9437, + "subdir": "linux-64", + "timestamp": 1530737594719, + "version": "0.3.3" + }, + "anyjson-0.3.3-py27hdf0fd94_1.tar.bz2": { + "build": "py27hdf0fd94_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9307198568a1f371eaf461b7a8c9c62a", + "name": "anyjson", + "sha256": "37969bfbef8675c75c97e08dba879dc658dee5466e621dd516486cc33206cfe9", + "size": 9280, + "subdir": "linux-64", + "timestamp": 1505693661176, + "version": "0.3.3" + }, + "anyjson-0.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "1a9590275692c18dbac7a0f225c5a5f6", + "name": "anyjson", + "sha256": "3c16adf15c34926935bf2c42c83efebe635447b756fc1c36bdd50ad16a744fe7", + "size": 9912, + "subdir": "linux-64", + "timestamp": 1641552318774, + "version": "0.3.3" + }, + "anyjson-0.3.3-py310h06a4308_1002.tar.bz2": { + "build": "py310h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "937d742d0dde0871c483fefb6283ecc1", + "name": "anyjson", + "sha256": "d7df8ee5b32f019b7a5d0dbe95acd55e0cbd766e34cb78c69b91c82942359b94", + "size": 12178, + "subdir": "linux-64", + "timestamp": 1659702775213, + "version": "0.3.3" + }, + "anyjson-0.3.3-py311h06a4308_1002.tar.bz2": { + "build": "py311h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "06e60b82f42effd41f65e23f86e5b4ed", + "name": "anyjson", + "sha256": "b848f4e212a9a4e83b7294a90ae6a89f09c65a4f0bcd164fc5681147a9c61d69", + "size": 13249, + "subdir": "linux-64", + "timestamp": 1676826945247, + "version": "0.3.3" + }, + "anyjson-0.3.3-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "be7a01f63d535533d2c544433b46bc47", + "name": "anyjson", + "sha256": "f4614e4988e9cb4a971c170abc7bc1a9b2e7d650734fa67af8ed7741dfc959e1", + "size": 9583, + "subdir": "linux-64", + "timestamp": 1534352749216, + "version": "0.3.3" + }, + "anyjson-0.3.3-py35h3cd284d_1.tar.bz2": { + "build": "py35h3cd284d_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e9d133eea75fedf751b39de338d66bed", + "name": "anyjson", + "sha256": "18fd03959dc284c2a7958a30bd012acc2c0a75b62119cebadf4a6fb1fb441f0f", + "size": 9496, + "subdir": "linux-64", + "timestamp": 1505693672797, + "version": "0.3.3" + }, + "anyjson-0.3.3-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "64ac25c465c2b1903baeefe266d10011", + "name": "anyjson", + "sha256": "f0101e299e800946d0010a9d21a573a523eef39864fe0884fc89551fbf0cfce6", + "size": 9570, + "subdir": "linux-64", + "timestamp": 1530737574415, + "version": "0.3.3" + }, + "anyjson-0.3.3-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "eaf6d168fbf420057c2525116d2f76e3", + "name": "anyjson", + "sha256": "2518dc1a6c8de31cf484e1e550447e43e3faea4a685a627132b593fa28e7954d", + "size": 11050, + "subdir": "linux-64", + "timestamp": 1611675299022, + "version": "0.3.3" + }, + "anyjson-0.3.3-py36hcd494a7_1.tar.bz2": { + "build": "py36hcd494a7_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "abf9974a9b2a37cd0798c6174df098df", + "name": "anyjson", + "sha256": "04a750e35e207d8dce5477508aa5d6dcf4193248175c56a693b44bb08302a5d3", + "size": 9453, + "subdir": "linux-64", + "timestamp": 1505693684597, + "version": "0.3.3" + }, + "anyjson-0.3.3-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "bbfb75f1b41677e5fa74128cfc742fcc", + "name": "anyjson", + "sha256": "b9fc6b2488c2f295c7ecfc11476c7f73dc1e31b655d67d6b1ad6c624038cddb3", + "size": 9571, + "subdir": "linux-64", + "timestamp": 1530737615846, + "version": "0.3.3" + }, + "anyjson-0.3.3-py37_1001.tar.bz2": { + "build": "py37_1001", + "build_number": 1001, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9566a1c3de93b9c70c85c1b61c56d2a8", + "name": "anyjson", + "sha256": "b7ad032e43e7cbbf4d7b3b066e9ff4d267582a7e015aac2526efc2e095e2a10d", + "size": 9246, + "subdir": "linux-64", + "timestamp": 1594337572329, + "version": "0.3.3" + }, + "anyjson-0.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b883dea59cd58d77c0764371cdc05a31", + "name": "anyjson", + "sha256": "6ffe774f9f8f1296fbf2f0f944d50780570236307501c812a814125262abd8fd", + "size": 11021, + "subdir": "linux-64", + "timestamp": 1611675309646, + "version": "0.3.3" + }, + "anyjson-0.3.3-py37h06a4308_1002.tar.bz2": { + "build": "py37h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b104c0fbfb6fc78d8654c1302d843989", + "name": "anyjson", + "sha256": "62a3f6fb14b7d8470a97820895d7ae6395aaa2a681628d4f46387b6647e500ff", + "size": 12160, + "subdir": "linux-64", + "timestamp": 1659702794790, + "version": "0.3.3" + }, + "anyjson-0.3.3-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c20743402e66e05d69dcf4a26aac9085", + "name": "anyjson", + "sha256": "abea6f13a54654c105507c6f06345747e2f2a5fd78737993bbe54433afbcc823", + "size": 10002, + "subdir": "linux-64", + "timestamp": 1572437643987, + "version": "0.3.3" + }, + "anyjson-0.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3b57e2e1516f97329e360f95d3f2d2f2", + "name": "anyjson", + "sha256": "82231d5a27781a6642568eb4e15adc8dbc7e05d909d52fe20f1279cf2a679d53", + "size": 11033, + "subdir": "linux-64", + "timestamp": 1611675362229, + "version": "0.3.3" + }, + "anyjson-0.3.3-py38h06a4308_1002.tar.bz2": { + "build": "py38h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f850a4448ec1d862b56e1fdf2fe5eae0", + "name": "anyjson", + "sha256": "2251539d63b6f0cda33eb77dc47a28d58475188cd20342fbe2394bc0894a1839", + "size": 12162, + "subdir": "linux-64", + "timestamp": 1659702813931, + "version": "0.3.3" + }, + "anyjson-0.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8f3f41797bbccfb72cd9969fff975478", + "name": "anyjson", + "sha256": "b3cf171867ba36089eef49f8abb24c14129933ed139914a40e97b3e24088a741", + "size": 11062, + "subdir": "linux-64", + "timestamp": 1611675307879, + "version": "0.3.3" + }, + "anyjson-0.3.3-py39h06a4308_1002.tar.bz2": { + "build": "py39h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7fbb2a854cbea58b448254263144fd1a", + "name": "anyjson", + "sha256": "490756cf8fe143f975493750a44ccaeeb456e6357090d200ff2400839f2c4847", + "size": 12159, + "subdir": "linux-64", + "timestamp": 1659702745651, + "version": "0.3.3" + }, + "anyqt-0.0.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "624214a786cc75b171efb24704e84b93", + "name": "anyqt", + "sha256": "d957afccab5d66d24c328458098e32771c4255410deb9f2321a60c69ebcc30a2", + "size": 46406, + "subdir": "linux-64", + "timestamp": 1539466176637, + "version": "0.0.10" + }, + "anyqt-0.0.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "310d773ec85eb344ab5bd7f4ebada0f6", + "name": "anyqt", + "sha256": "239f192b613f6769f139f1495769b6af12f52e67651f2fa20eb2b5e94cfe3b95", + "size": 48087, + "subdir": "linux-64", + "timestamp": 1539466202473, + "version": "0.0.10" + }, + "anyqt-0.0.10-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "82e32f0f96e2d2c825584a14124492ad", + "name": "anyqt", + "sha256": "28b94a2de377f7114f450638645b1ab385dc1593cf9f01d2c23e1806b214a754", + "size": 49458, + "subdir": "linux-64", + "timestamp": 1613037522420, + "version": "0.0.10" + }, + "anyqt-0.0.10-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "13d0a2347644c0dfbc02f838d7d328c2", + "name": "anyqt", + "sha256": "c15f6e05696a0c8bfb59961deb24ac0fccb7ec083bed314418dde3e3e469b135", + "size": 48138, + "subdir": "linux-64", + "timestamp": 1539466181246, + "version": "0.0.10" + }, + "anyqt-0.0.10-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "b80f0800227b902252833a71dfef35ca", + "name": "anyqt", + "sha256": "26d2b242b8aa66fcc671332ec53b10a30c81cb542870c647d77b87c99dd4b140", + "size": 49486, + "subdir": "linux-64", + "timestamp": 1613037525579, + "version": "0.0.10" + }, + "anyqt-0.0.10-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "6b1f56a1681748325ba8a0286ece8f11", + "name": "anyqt", + "sha256": "9115dde07f3addcb308bfce6b07c39f127ba9658a066bfc7bf2cece2b7713075", + "size": 48538, + "subdir": "linux-64", + "timestamp": 1574097806978, + "version": "0.0.10" + }, + "anyqt-0.0.10-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "dea3a6c531e8376b20a5f2aebac0aef6", + "name": "anyqt", + "sha256": "c76a20b6da5bacb58b933f5b37e058bd2e24d6c09e48a34f360ec8c53b5ab690", + "size": 49770, + "subdir": "linux-64", + "timestamp": 1613037532417, + "version": "0.0.10" + }, + "anyqt-0.0.10-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "b1139e8e1f85c25acfe87e42b37bb2aa", + "name": "anyqt", + "sha256": "45f9f86afe9b642b3ef4b8e2d21fdb616b97cedf907b99bf4a7c9b5a7a2d21ac", + "size": 48467, + "subdir": "linux-64", + "timestamp": 1613037530537, + "version": "0.0.10" + }, + "anyqt-0.0.13-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.10,<3.11.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "7784e8784b73a3ea39f1badb8765349d", + "name": "anyqt", + "sha256": "3e2b9bb7f7e5d748de485b3e496a1a78a9e25a3ed99e3d639948e36ca4a19338", + "size": 68851, + "subdir": "linux-64", + "timestamp": 1642512735516, + "version": "0.0.13" + }, + "anyqt-0.0.13-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "3d3a99a09fbe833bd69d16a744108eb4", + "name": "anyqt", + "sha256": "49d2f373baf14853837441d198a7fc45d1adcfdcf46f9ae82b8078c51201bad1", + "size": 69776, + "subdir": "linux-64", + "timestamp": 1620315969008, + "version": "0.0.13" + }, + "anyqt-0.0.8-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pyqt", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "5c810cad1aae6a53c53be19bfcd26473", + "name": "anyqt", + "sha256": "724e0b2b3081a550543c900545c44733a52879b4a96647d521ec96502f406eba", + "size": 45097, + "subdir": "linux-64", + "timestamp": 1530902605859, + "version": "0.0.8" + }, + "anyqt-0.0.8-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "pyqt", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "9ec71e76495594627700576a2716c029", + "name": "anyqt", + "sha256": "6fdc26d5c6ef91a93904c48734568be1a4c895fe771febb14b03146322b2c450", + "size": 46887, + "subdir": "linux-64", + "timestamp": 1537856045263, + "version": "0.0.8" + }, + "anyqt-0.0.8-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pyqt", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "0445bf81eaaa4fba0cf98cf9e8044b20", + "name": "anyqt", + "sha256": "8d7c17d93de93e6595f60fc3ed8bb86e5be5cb8a4a14bad1026c61e1590b177b", + "size": 46811, + "subdir": "linux-64", + "timestamp": 1530902573077, + "version": "0.0.8" + }, + "anyqt-0.0.8-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "1c33020c0c27c7961c4c20bc8e14eea3", + "name": "anyqt", + "sha256": "fff4180265959d000d084c99059c949f1321ae3494c8ab7af67c06eeb822f7f2", + "size": 46829, + "subdir": "linux-64", + "timestamp": 1530902537956, + "version": "0.0.8" + }, + "anyqt-0.1.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.10,<3.11.0a0" + ], + "license": "GPL-3.0-or-later", + "md5": "92f1a6a0097cb74ecdba2e54a6b472d9", + "name": "anyqt", + "sha256": "4c25e59845d5292a335e23b60712d71e66d21d87a515d5315a5fac77171ee3f2", + "size": 81405, + "subdir": "linux-64", + "timestamp": 1659334947286, + "version": "0.1.1" + }, + "anyqt-0.1.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.11,<3.12.0a0" + ], + "license": "GPL-3.0-or-later", + "md5": "a9481b69e9ce4df8b78a2a229fbc031a", + "name": "anyqt", + "sha256": "529ba0c20c17ae962c19bbe9caac85adaf93a8206fd656f7814aa9e40e9776b4", + "size": 94510, + "subdir": "linux-64", + "timestamp": 1676838973035, + "version": "0.1.1" + }, + "anyqt-0.1.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0-or-later", + "md5": "07574cc9708c2698bf2e2fc8fbf43f3d", + "name": "anyqt", + "sha256": "1d52dcff0bcb439614fe57b8fc53adc76510e930874f913bca92c722e5151c80", + "size": 82201, + "subdir": "linux-64", + "timestamp": 1659335065976, + "version": "0.1.1" + }, + "anyqt-0.1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0-or-later", + "md5": "0d48ee49ca523f1eba405d7282d4ddcc", + "name": "anyqt", + "sha256": "b8db83770094fb2f8299ad61ee4dc356c779bc7196bcf7f999aeb5890fb2055b", + "size": 82336, + "subdir": "linux-64", + "timestamp": 1659334991194, + "version": "0.1.1" + }, + "anyqt-0.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-3.0-or-later", + "md5": "8a6b1c4aced057419c9aba1f0af0f25f", + "name": "anyqt", + "sha256": "820f61619160032eb4a714e5790e1622b0f55bdde0d93a9f93eddaa197624307", + "size": 81045, + "subdir": "linux-64", + "timestamp": 1659335028502, + "version": "0.1.1" + }, + "apache-airflow-2.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "6aafd8b37ecaa01565bd81ccab18b0cf", + "name": "apache-airflow", + "sha256": "775a35dbede8d44abdff87f0c55a0f7000f66ad0c44884d56c26c5f13beafcde", + "size": 12346, + "subdir": "linux-64", + "timestamp": 1659884290255, + "version": "2.3.3" + }, + "apache-airflow-2.3.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "6e5c3cdcd885d39f90701973a20526fc", + "name": "apache-airflow", + "sha256": "458b7792fac49ed28c43a0f4a6018828c610b6dc6e7ef41cd3f05b2885361e02", + "size": 12351, + "subdir": "linux-64", + "timestamp": 1659935230453, + "version": "2.3.3" + }, + "apache-airflow-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "145f57fb8d4c26490017cf60e7053e01", + "name": "apache-airflow", + "sha256": "393261e44462588d8c70aca1525475e8074daea4af7fda90ac20f6fe9f3316df", + "size": 12321, + "subdir": "linux-64", + "timestamp": 1659884273435, + "version": "2.3.3" + }, + "apache-airflow-2.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "75565a345028effbd6f8ab6af9321b32", + "name": "apache-airflow", + "sha256": "d0481d494e797bfd2c0b6e69c710791826f17257606c239639e7ed4d778367ab", + "size": 12303, + "subdir": "linux-64", + "timestamp": 1659935218923, + "version": "2.3.3" + }, + "apache-airflow-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "09012ca6ee37b0dc4a3f7e52a41f204f", + "name": "apache-airflow", + "sha256": "b72716c2148e0899516b37d4e15c8d035ae20207dbb4c0be78f57e23799a6bab", + "size": 12301, + "subdir": "linux-64", + "timestamp": 1659884278857, + "version": "2.3.3" + }, + "apache-airflow-2.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "4d1a962325af914a9789204b4ff0df4b", + "name": "apache-airflow", + "sha256": "50cf411cd09264490b5ffbb97db20e4f0165129a7bb1f0ca6bce48008477a09e", + "size": 12302, + "subdir": "linux-64", + "timestamp": 1659935235916, + "version": "2.3.3" + }, + "apache-airflow-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "54cd7c04c4d45974a5cbf16ef0cdb7ea", + "name": "apache-airflow", + "sha256": "4d43279c3b01b1159838617f67c363ca1ac18469f3587e02097be05c6b98f7eb", + "size": 12308, + "subdir": "linux-64", + "timestamp": 1659884284508, + "version": "2.3.3" + }, + "apache-airflow-2.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "fdca6cb3a917de16d192c58c37e8ab0d", + "name": "apache-airflow", + "sha256": "0f2bf449712d1d44945b2ebd5974366260de3d184a5ce32e22e71c1819b76010", + "size": 12316, + "subdir": "linux-64", + "timestamp": 1659935224580, + "version": "2.3.3" + }, + "apache-airflow-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b24cfc6c228c182cfaa901b398b1a1ef", + "name": "apache-airflow", + "sha256": "ed12f11ca1ff3b2b88a0ecd94d91703c183a843308c27f08251faec0930d6a23", + "size": 12367, + "subdir": "linux-64", + "timestamp": 1671227425912, + "version": "2.4.3" + }, + "apache-airflow-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "244abd53d373ae447a4f8ba1772eaa5a", + "name": "apache-airflow", + "sha256": "785533eeb707903a3f6bfdc00bdb193120cef7172858b463e8dfbd3bb38ad736", + "size": 12312, + "subdir": "linux-64", + "timestamp": 1671227414097, + "version": "2.4.3" + }, + "apache-airflow-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "869c105099847581df8e5bcb50e6a53e", + "name": "apache-airflow", + "sha256": "b2ac4c98ddad7ca8a567ead4da4c93048641fa17901425df2edefd1454449210", + "size": 12329, + "subdir": "linux-64", + "timestamp": 1671227431597, + "version": "2.4.3" + }, + "apache-airflow-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4b40fc792232195cb47ec2543ef128c3", + "name": "apache-airflow", + "sha256": "9c1eea47e9f8f71757c5f66135f3755de7d156e87d4f581f5bcffb94f515c599", + "size": 12355, + "subdir": "linux-64", + "timestamp": 1671227419928, + "version": "2.4.3" + }, + "apache-airflow-providers-apache-hdfs-3.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "apache-airflow >=2.2.0", + "python >=3.10,<3.11.0a0", + "python-hdfs >=2.0.4", + "snakebite-py3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f5cabbe7fbc76e8d0addb5b03b45be6c", + "name": "apache-airflow-providers-apache-hdfs", + "sha256": "30dc3c18e874e5121ac056a43ce8462a9b9bbd6b73dae840d518574f4a2a7b40", + "size": 25439, + "subdir": "linux-64", + "timestamp": 1659891394161, + "version": "3.0.1" + }, + "apache-airflow-providers-apache-hdfs-3.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "apache-airflow >=2.2.0", + "python >=3.7,<3.8.0a0", + "python-hdfs >=2.0.4", + "snakebite-py3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "89900ca66e08f25e1213f4a13d17a957", + "name": "apache-airflow-providers-apache-hdfs", + "sha256": "b26ed724530f7dbb7ebcb6bb54937e440fbc7226aac0520d6be1c9f4324711fa", + "size": 25174, + "subdir": "linux-64", + "timestamp": 1659891449255, + "version": "3.0.1" + }, + "apache-airflow-providers-apache-hdfs-3.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "apache-airflow >=2.2.0", + "python >=3.8,<3.9.0a0", + "python-hdfs >=2.0.4", + "snakebite-py3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "86f69607c74ebf195de0ba8162544c68", + "name": "apache-airflow-providers-apache-hdfs", + "sha256": "d0fdffb4e00a034f2e8d90578b8fbce24f648323fd64910b41a59c2d115684b2", + "size": 25292, + "subdir": "linux-64", + "timestamp": 1659891258513, + "version": "3.0.1" + }, + "apache-airflow-providers-apache-hdfs-3.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "apache-airflow >=2.2.0", + "python >=3.9,<3.10.0a0", + "python-hdfs >=2.0.4", + "snakebite-py3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e50c3a6b7a1de12e54e46967228bcc19", + "name": "apache-airflow-providers-apache-hdfs", + "sha256": "dd859c5a040c3a6813abc70d23afe563565b8302ad9ab82eba25a31308964ea5", + "size": 25224, + "subdir": "linux-64", + "timestamp": 1659891327815, + "version": "3.0.1" + }, + "apache-airflow-providers-common-sql-1.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "sqlparse >=0.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ef8b220211d09d6a9779497f52ceffbd", + "name": "apache-airflow-providers-common-sql", + "sha256": "c91b4c479725b3fc7c3226b2a10cb522f1e3f27798e6d82e86c10177c09631ca", + "size": 40873, + "subdir": "linux-64", + "timestamp": 1669056807749, + "version": "1.2.0" + }, + "apache-airflow-providers-common-sql-1.2.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "sqlparse >=0.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2e85468ab4cd3edc5ddf1b250f555e00", + "name": "apache-airflow-providers-common-sql", + "sha256": "baaff762c88cfb29d0aea594fa7abe5c3c72ca9ff695647c465b887fc72d1c91", + "size": 50462, + "subdir": "linux-64", + "timestamp": 1676828978987, + "version": "1.2.0" + }, + "apache-airflow-providers-common-sql-1.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "sqlparse >=0.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b0840e1d6230a61278b78ef37127ee62", + "name": "apache-airflow-providers-common-sql", + "sha256": "8fc9a0fecca1d51c8e4d2dcfb8127d3bf5990da1e8f350196eaaca2a760df36c", + "size": 40082, + "subdir": "linux-64", + "timestamp": 1669056720084, + "version": "1.2.0" + }, + "apache-airflow-providers-common-sql-1.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "sqlparse >=0.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "26b54848fccf140b17f604a2551d568e", + "name": "apache-airflow-providers-common-sql", + "sha256": "aec8add26a95722e67d7ab2afa1bacc70ed91c83ca4a2b825f3e2c3d64ad5956", + "size": 40301, + "subdir": "linux-64", + "timestamp": 1669056749948, + "version": "1.2.0" + }, + "apache-airflow-providers-common-sql-1.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "sqlparse >=0.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2b096638520fb864980ce3ada65c6efb", + "name": "apache-airflow-providers-common-sql", + "sha256": "02b85465b3db5a19202252452b0a72e40c0b410e26d1fe2409763122e6739cde", + "size": 40389, + "subdir": "linux-64", + "timestamp": 1669056778506, + "version": "1.2.0" + }, + "apache-airflow-providers-ftp-3.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3552762ffd0c2eca347d26d8308813c9", + "name": "apache-airflow-providers-ftp", + "sha256": "7bf150f52d804e3406a1f1126cecd48324c3df71e79a4004b253d7657549a12c", + "size": 21328, + "subdir": "linux-64", + "timestamp": 1659864383174, + "version": "3.1.0" + }, + "apache-airflow-providers-ftp-3.1.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fb75f421af4e519d0cdbe0420c4dabcb", + "name": "apache-airflow-providers-ftp", + "sha256": "555c32a5584e919f2bcb06cc5e3228596d9e77ea52f5c7cc14378ce22079f1e7", + "size": 24117, + "subdir": "linux-64", + "timestamp": 1676828992859, + "version": "3.1.0" + }, + "apache-airflow-providers-ftp-3.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2bcc33170d8dcfd4f1aa2603da62de37", + "name": "apache-airflow-providers-ftp", + "sha256": "a08e92ca8d10ebfefc016db9c07f64d7aa82a201d9b58865fbf9f2a3b9c691d2", + "size": 21115, + "subdir": "linux-64", + "timestamp": 1659864343458, + "version": "3.1.0" + }, + "apache-airflow-providers-ftp-3.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "71a648847fc033090a149a604994717e", + "name": "apache-airflow-providers-ftp", + "sha256": "97aa5d80d5671e8b64a43897b918457d38e64ecf3f76b22d0e54f61d30322233", + "size": 21236, + "subdir": "linux-64", + "timestamp": 1659864409037, + "version": "3.1.0" + }, + "apache-airflow-providers-ftp-3.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "08b7ed15b1ad981d7ec80df9e8b25246", + "name": "apache-airflow-providers-ftp", + "sha256": "69a15fd49c2d3f590e36811f3737300eb842e59c15ef896f5b17c906554b24ac", + "size": 21165, + "subdir": "linux-64", + "timestamp": 1659864438750, + "version": "3.1.0" + }, + "apache-airflow-providers-http-4.0.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "requests >=2.26.0", + "requests-toolbelt" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2eca231bca414d3fecf5e098a9969d0f", + "name": "apache-airflow-providers-http", + "sha256": "13669fb256528cbf89957780a51bb18ff376e8832d2549fd33d15d36d8ccc342", + "size": 24941, + "subdir": "linux-64", + "timestamp": 1659865202296, + "version": "4.0.0" + }, + "apache-airflow-providers-http-4.0.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "requests >=2.26.0", + "requests-toolbelt" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "90794f2029ee2b9c1364a5ffaba44618", + "name": "apache-airflow-providers-http", + "sha256": "cc9bb1b782b1846abcc4111bc06316168a69be1f3791a7c762f937855c3df828", + "size": 28494, + "subdir": "linux-64", + "timestamp": 1676829006751, + "version": "4.0.0" + }, + "apache-airflow-providers-http-4.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.26.0", + "requests-toolbelt" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "82bde8cf8e8b89fdb9f7d85efdad0e2a", + "name": "apache-airflow-providers-http", + "sha256": "bf76d34dbb00b5c78f52572a569b1a58fd093322a6a82af627294aa941654bc1", + "size": 24596, + "subdir": "linux-64", + "timestamp": 1659865161607, + "version": "4.0.0" + }, + "apache-airflow-providers-http-4.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.26.0", + "requests-toolbelt" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d43ac537c29e388a55f0ded65e34019a", + "name": "apache-airflow-providers-http", + "sha256": "9fcc749fbe2e1eda03c97bf9f4b78a56c4c49bbdff846aedb68c97ad3217d0a3", + "size": 24739, + "subdir": "linux-64", + "timestamp": 1659865229581, + "version": "4.0.0" + }, + "apache-airflow-providers-http-4.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.26.0", + "requests-toolbelt" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3e29d9dbff5c94cc2d4e6dcda81c0987", + "name": "apache-airflow-providers-http", + "sha256": "cbf740ce41f660a544e9776e8e3b2118c127166b7819dd359dcf045080a8615f", + "size": 24748, + "subdir": "linux-64", + "timestamp": 1659865133415, + "version": "4.0.0" + }, + "apache-airflow-providers-imap-3.0.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ce6bc9b8adcf7590a2245dba30cc5c16", + "name": "apache-airflow-providers-imap", + "sha256": "eb55ce2e74abc89c88a974d15953e4d89bf47eca6b49f059a8dbca78ce8a6f2b", + "size": 22642, + "subdir": "linux-64", + "timestamp": 1659865289956, + "version": "3.0.0" + }, + "apache-airflow-providers-imap-3.0.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b276b6c5dd87ed6ee8a8b088643a2101", + "name": "apache-airflow-providers-imap", + "sha256": "a74c84a61c93ced02cf9a6575edeb0b44eccee7cac033a555295428177f23515", + "size": 25902, + "subdir": "linux-64", + "timestamp": 1676829020621, + "version": "3.0.0" + }, + "apache-airflow-providers-imap-3.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "176ab9c5a1b826fc304f4d736c80e13d", + "name": "apache-airflow-providers-imap", + "sha256": "9636b13bba472f93a8edfd68d02a527f6f6a3782e7d16ce5ded074f02857de84", + "size": 22402, + "subdir": "linux-64", + "timestamp": 1659865315798, + "version": "3.0.0" + }, + "apache-airflow-providers-imap-3.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7363efa7ccc6f793c9be4d2f73e8fd6b", + "name": "apache-airflow-providers-imap", + "sha256": "a90f939276ad2da5c0718596da65b77ba494530d2021440a876370e94a5e608a", + "size": 22513, + "subdir": "linux-64", + "timestamp": 1659865251323, + "version": "3.0.0" + }, + "apache-airflow-providers-imap-3.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "39dab4c7b1230a6eb2dcc182d3fcd505", + "name": "apache-airflow-providers-imap", + "sha256": "c2f0642bc811d93556b4218270ed6bc89a0b2c3cd4daf33c596b7e9cfa8ca755", + "size": 22513, + "subdir": "linux-64", + "timestamp": 1659865225889, + "version": "3.0.0" + }, + "apache-airflow-providers-sqlite-3.0.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5c312b1f858092abc07b6a1318843c60", + "name": "apache-airflow-providers-sqlite", + "sha256": "83e98b19dc7bfd868118c5c6b136c3e6fea11c11a0421d1197221f91ac28efee", + "size": 17554, + "subdir": "linux-64", + "timestamp": 1659865501066, + "version": "3.0.0" + }, + "apache-airflow-providers-sqlite-3.0.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b9fafaeea6f5a92f6b9c22edfc9f6bc6", + "name": "apache-airflow-providers-sqlite", + "sha256": "d614ea25b658fd77dbfa95a26396609e007c0c6482cf7d55236fb2192960a5ef", + "size": 19043, + "subdir": "linux-64", + "timestamp": 1676829034522, + "version": "3.0.0" + }, + "apache-airflow-providers-sqlite-3.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "80027408fcf6a69213bade89a4791807", + "name": "apache-airflow-providers-sqlite", + "sha256": "d98d49d76989eda81f5927326a54c5da34d784173b018184e69fbde6fc3768fc", + "size": 17487, + "subdir": "linux-64", + "timestamp": 1659865554230, + "version": "3.0.0" + }, + "apache-airflow-providers-sqlite-3.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4e7525f372dc17b5fa8a7749db69feba", + "name": "apache-airflow-providers-sqlite", + "sha256": "c77660cc549027f4aa66025f2433ae470e29190e2bd4c3e384b9877cf0c2d4ac", + "size": 17516, + "subdir": "linux-64", + "timestamp": 1659865527386, + "version": "3.0.0" + }, + "apache-airflow-providers-sqlite-3.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b5997963536b440286ab10ced2d7c7e3", + "name": "apache-airflow-providers-sqlite", + "sha256": "d6ce77377dd116e360305ea12ba75d8e4626f103aaa27b6bcbb189f367d010f4", + "size": 17514, + "subdir": "linux-64", + "timestamp": 1659865461356, + "version": "3.0.0" + }, + "apache-libcloud-1.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "md5": "50ee3385281e63cd7054d53caa53736a", + "name": "apache-libcloud", + "sha256": "2bb3780f428c5562c5d113298dc3733a49097e97f2059d874a5cbb1d6f09eeac", + "size": 2056558, + "subdir": "linux-64", + "timestamp": 1640788144465, + "version": "1.3.0" + }, + "apache-libcloud-1.3.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache 2.0", + "md5": "dbbec09b8994c2e2b5c70ac59d0ca6d8", + "name": "apache-libcloud", + "sha256": "4248fbff04a8d228ff65f01b77e89a7c2d13580050f8bbe729336e3e5d73f3ae", + "size": 2577598, + "subdir": "linux-64", + "timestamp": 1676846782748, + "version": "1.3.0" + }, + "apache-libcloud-1.3.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "87b8384b8e4149508f80b4ba7fb196d0", + "name": "apache-libcloud", + "sha256": "a4aadf8a84a0c78c2a3141e093cfc45688528d77ef25da6d12b719ce55dd8f23", + "size": 2072358, + "subdir": "linux-64", + "timestamp": 1632751731955, + "version": "1.3.0" + }, + "apache-libcloud-1.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "cebb7691d910901cdaea3e9d2bfeb80b", + "name": "apache-libcloud", + "sha256": "1b5253fdd8427173da24ad4d35600cb9425b6810fe44de44c72f1a0e386769e1", + "size": 2038844, + "subdir": "linux-64", + "timestamp": 1632751720175, + "version": "1.3.0" + }, + "apache-libcloud-1.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "099f6087a6be37bab80376891647ac95", + "name": "apache-libcloud", + "sha256": "da7734c96a6b9f1db34f7796799e9df5b6c1137175a89df07f774326797dca1c", + "size": 2037512, + "subdir": "linux-64", + "timestamp": 1632741357768, + "version": "1.3.0" + }, + "apache-libcloud-1.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "b54ffb396171e732f0e98a24725acfa5", + "name": "apache-libcloud", + "sha256": "563c66309ce317fbcb6f9ce5f659a6ba45e59d8c2365202f6d9c1dc9d304bdd1", + "size": 2043909, + "subdir": "linux-64", + "timestamp": 1632741358315, + "version": "1.3.0" + }, + "apipkg-1.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "63de745097623587db4a1b22fe7deb88", + "name": "apipkg", + "sha256": "573743185193cdec11ed542fe09716bbf57f46803063065e41b9e1171c24f7e9", + "size": 10280, + "subdir": "linux-64", + "timestamp": 1530727837542, + "version": "1.4" + }, + "apipkg-1.4-py27hab8e363_0.tar.bz2": { + "build": "py27hab8e363_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "36d00fab6a922aa16edd87e47e3cec30", + "name": "apipkg", + "sha256": "761ad8229ac864208062111b340b95f7b4dd7e31e5d88f29abddab470dae5c46", + "size": 10667, + "subdir": "linux-64", + "timestamp": 1510986429497, + "version": "1.4" + }, + "apipkg-1.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "639b181efd62dc0e9e794ab072eb2720", + "name": "apipkg", + "sha256": "a01b9476a6378b7eec127ae00c33f479eef9c378071a80cfaa9fd9b5d9068887", + "size": 10454, + "subdir": "linux-64", + "timestamp": 1534347539051, + "version": "1.4" + }, + "apipkg-1.4-py35h53e6e68_0.tar.bz2": { + "build": "py35h53e6e68_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "b0f6eaee74221c15e750e7de64603d0b", + "name": "apipkg", + "sha256": "bd487d29e2c5ec1c037aa3c6f901da8de634de3491833b54250fddd8f69bc657", + "size": 10927, + "subdir": "linux-64", + "timestamp": 1510986448257, + "version": "1.4" + }, + "apipkg-1.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "fc924a7eeb08dbb5222652c509e05b56", + "name": "apipkg", + "sha256": "1e3911c943817fb8b0e522c2efba9e2af4209cd770e5dc9827a1116f2f742033", + "size": 10438, + "subdir": "linux-64", + "timestamp": 1530727877535, + "version": "1.4" + }, + "apipkg-1.4-py36he372753_0.tar.bz2": { + "build": "py36he372753_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b21baf0ef6e377d0b62cad35a6ae0005", + "name": "apipkg", + "sha256": "ff5d4474eb6c4fdf094d936441a4976c224c1cd277743b49b17bbeb7f067f874", + "size": 10827, + "subdir": "linux-64", + "timestamp": 1510986442087, + "version": "1.4" + }, + "apipkg-1.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c71ecdf3eca47f6294e3547cb4f9dd88", + "name": "apipkg", + "sha256": "98658c5f513fa1732065c1ce591cdad9649b1489d0728d1e154d235716e76826", + "size": 10474, + "subdir": "linux-64", + "timestamp": 1530727857359, + "version": "1.4" + }, + "apipkg-1.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "83e496eb69a853eec1fd902aca48a6c7", + "name": "apipkg", + "sha256": "9c07cdecb9e0e4b78da6389f8e8ac7b4d4aee3995fb77ca0237a325d15b0da0f", + "size": 10851, + "subdir": "linux-64", + "timestamp": 1534394710802, + "version": "1.5" + }, + "apipkg-1.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "95c8cb56b22f5ab4ae4c21dab4f37d6f", + "name": "apipkg", + "sha256": "ba9165699f66d1cb31ebe05715befca781546714d25356c80016602e2fafdeb3", + "size": 12260, + "subdir": "linux-64", + "timestamp": 1640788167919, + "version": "1.5" + }, + "apipkg-1.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "b0770ce45e4434e2b3f06b4b3727bbee", + "name": "apipkg", + "sha256": "ac34c55df1269d934aa60e72d8edde931fc851deca48faf5c94d108b5968b292", + "size": 14986, + "subdir": "linux-64", + "timestamp": 1676846802380, + "version": "1.5" + }, + "apipkg-1.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "6768b71c26303b92cb2742bdf0a1576e", + "name": "apipkg", + "sha256": "661f42864990dfded332d509eac571c5d51b25b2647415e17f4127540ca9c31c", + "size": 11103, + "subdir": "linux-64", + "timestamp": 1534394840884, + "version": "1.5" + }, + "apipkg-1.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a1a8bd8f1e7d60c1571b39a17dab4f89", + "name": "apipkg", + "sha256": "cfb380bc53dfb0623fdd29b022bb52eb3a8bfb9baf08df94a1be23eb6b42e7c6", + "size": 11025, + "subdir": "linux-64", + "timestamp": 1534394798150, + "version": "1.5" + }, + "apipkg-1.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7ab205c87875efb336aa6cf35cc29627", + "name": "apipkg", + "sha256": "8cc10fe24104328173c2b1452c96c19eef9e28a261ea7f9951f59a6a3fdbebb7", + "size": 11055, + "subdir": "linux-64", + "timestamp": 1534394734687, + "version": "1.5" + }, + "apipkg-1.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "0f8cd2b3b9b7f31d4af04f3cb64a1d3f", + "name": "apipkg", + "sha256": "f5a8e47a9065b999b8c92dad20cce47ac74f55d90bcfc85fd8a414eb1188ea69", + "size": 12018, + "subdir": "linux-64", + "timestamp": 1572437675640, + "version": "1.5" + }, + "apipkg-1.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "c8f85e5f917e25766495c05206068daf", + "name": "apipkg", + "sha256": "ba68399081ec9a94675b30d46bed77d30ebf4ff911cc20cf11894c116dd485d2", + "size": 13822, + "subdir": "linux-64", + "timestamp": 1607615881767, + "version": "1.5" + }, + "apispec-0.39.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pyyaml >=3.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a778a0ca7224926ab4f16cd8abf8ce5", + "name": "apispec", + "sha256": "8cb43180a6c9f3a95cbb1c6824b656344689810ea5a86c881f24140fdad9538a", + "size": 44281, + "subdir": "linux-64", + "timestamp": 1543147352438, + "version": "0.39.0" + }, + "apispec-0.39.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1313f9dd18e2baad7a602913a32a738d", + "name": "apispec", + "sha256": "09dbe77c756fe498e84f5501a52423b21efc068113a9fd5de47ee1e09a011c8d", + "size": 44941, + "subdir": "linux-64", + "timestamp": 1543147395134, + "version": "0.39.0" + }, + "apispec-0.39.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14b2ddb46a46dce5d3b676da57503fee", + "name": "apispec", + "sha256": "6faccc6b7ee2294602c60f697a430b83bc641fb1320f92e1f7d550c2aad5afe6", + "size": 44978, + "subdir": "linux-64", + "timestamp": 1543147330916, + "version": "0.39.0" + }, + "appdirs-1.4.3-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "226d2b7759bf027433fdff3f1b9b7135", + "name": "appdirs", + "sha256": "443585b9218e2dd153de1a7833fb373438a3812a5a3f48c07a84e1b514ba7136", + "size": 15892, + "subdir": "linux-64", + "timestamp": 1530919483921, + "version": "1.4.3" + }, + "appdirs-1.4.3-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "c17887c2db40d15fabb69f9fc3e45834", + "name": "appdirs", + "sha256": "ffb07dfc6ed1921ebdf83cb5833897c6398b54d8ea279751790fff8ba562b6ed", + "size": 16001, + "subdir": "linux-64", + "timestamp": 1534351155796, + "version": "1.4.3" + }, + "appdirs-1.4.3-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "365a0cdfc09996dd65bb89d1c91d3fb2", + "name": "appdirs", + "sha256": "63008463ce68fc5a1a17d3a4f77930febc9e0f8b4ec88a4f7fb5b09931dcbc4f", + "size": 16057, + "subdir": "linux-64", + "timestamp": 1530919426471, + "version": "1.4.3" + }, + "appdirs-1.4.3-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "412ee204e5eba6deb007749f5c190698", + "name": "appdirs", + "sha256": "2486c7a08a544b8a7b8ba781411f96385bef72824c59c347cfdd6e3004dc4279", + "size": 16074, + "subdir": "linux-64", + "timestamp": 1530919455697, + "version": "1.4.3" + }, + "apptools-4.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configobj", + "pyface", + "python >=2.7,<2.8.0a0", + "traits", + "traitsui" + ], + "license": "BSD 3-clause", + "md5": "07ebe9d721f2da5ec822bac234e44a7a", + "name": "apptools", + "sha256": "82b4caff5558f55529020ddbd6d172d1c337e0a2c606dbfd52ddb2e7c5ac334b", + "size": 406747, + "subdir": "linux-64", + "timestamp": 1530874852706, + "version": "4.4.0" + }, + "apptools-4.4.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "configobj", + "pyface", + "python >=2.7,<2.8.0a0", + "traits", + "traitsui" + ], + "license": "BSD 3-clause", + "md5": "d282c96087946cb57f417e8bbf612508", + "name": "apptools", + "sha256": "7b220eeb831073bb70488289c87decda342b88a80460a06dd9764c34e2de3a4c", + "size": 406929, + "subdir": "linux-64", + "timestamp": 1536253684521, + "version": "4.4.0" + }, + "apptools-4.4.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "configobj", + "pyface", + "python >=3.5,<3.6.0a0", + "traits", + "traitsui" + ], + "license": "BSD 3-clause", + "md5": "581e99fd7659c16dd4c6af8c02283d80", + "name": "apptools", + "sha256": "e6d5348659e6dc479cb19489f8d2916c53b41cafdb2bf2411a16935021ccd182", + "size": 420596, + "subdir": "linux-64", + "timestamp": 1536253883550, + "version": "4.4.0" + }, + "apptools-4.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "configobj", + "pyface", + "python >=3.6,<3.7.0a0", + "traits", + "traitsui" + ], + "license": "BSD 3-clause", + "md5": "ca25e759ea9dfc963becdef34c370d24", + "name": "apptools", + "sha256": "3ea1189ba6a6dbe84073d6abd61836c36ebfbb6e2e21bbdfbac40cf3050ebacc", + "size": 418903, + "subdir": "linux-64", + "timestamp": 1530874752549, + "version": "4.4.0" + }, + "apptools-4.4.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "configobj", + "pyface", + "python >=3.6,<3.7.0a0", + "traits", + "traitsui" + ], + "license": "BSD 3-clause", + "md5": "e8541eec61207586896ecf3608870767", + "name": "apptools", + "sha256": "6442f113a031e1ea6e148b444a2138bd2df9861f135e9fb3ef187b04fa93a47d", + "size": 418903, + "subdir": "linux-64", + "timestamp": 1536253661051, + "version": "4.4.0" + }, + "apptools-4.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "configobj", + "pyface", + "python >=3.7,<3.8.0a0", + "traits", + "traitsui" + ], + "license": "BSD 3-clause", + "md5": "a71e20f13bb2c636114ade63d453b074", + "name": "apptools", + "sha256": "5a11652aac8ce212a01ef20a759c6781f9edc0937beeffdfc814a1a48f48e92c", + "size": 418925, + "subdir": "linux-64", + "timestamp": 1530874809149, + "version": "4.4.0" + }, + "apptools-4.4.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "configobj", + "pyface", + "python >=3.7,<3.8.0a0", + "traits", + "traitsui" + ], + "license": "BSD 3-clause", + "md5": "780d53c45c2913bae8e028549f078d19", + "name": "apptools", + "sha256": "e863536148a17cad3838fc37ce9f5f8a94078d61806b16572b339fcbb7e844d4", + "size": 418957, + "subdir": "linux-64", + "timestamp": 1536253845929, + "version": "4.4.0" + }, + "apptools-4.4.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "configobj", + "pyface", + "python >=3.8,<3.9.0a0", + "traits", + "traitsui" + ], + "license": "BSD 3-clause", + "md5": "ca444c04e14e71d2dbee92abe2434f1c", + "name": "apptools", + "sha256": "f0b2fbe86f6abd975534ff35cd183afe020856b445571790cba60b71317ea302", + "size": 425506, + "subdir": "linux-64", + "timestamp": 1574182135455, + "version": "4.4.0" + }, + "apr-1.6.3-he40df45_0.tar.bz2": { + "build": "he40df45_0", + "build_number": 0, + "depends": [ + "expat >=2.2.5,<3.0a0", + "libgcc-ng >=7.2.0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "c97456fe2d47c56fd6cdc76e45b6cde4", + "name": "apr", + "sha256": "57a450b49119a86de305000e1591dcde19940d2efcfe7e9a762071333a7d43ec", + "size": 1706452, + "subdir": "linux-64", + "timestamp": 1513183900514, + "version": "1.6.3" + }, + "apr-1.7.0-hf178f73_5.tar.bz2": { + "build": "hf178f73_5", + "build_number": 5, + "depends": [ + "libapr", + "libapriconv", + "libaprutil", + "libgcc-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c38f729829d224ec8b689851d574de6c", + "name": "apr", + "sha256": "64a5fd3c6e8e9450bd6e9e3b06e8407610d443e1699b58d5c1bb8fdf82811fef", + "size": 320117, + "subdir": "linux-64", + "timestamp": 1631785384660, + "version": "1.7.0" + }, + "apscheduler-3.6.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "funcsigs", + "futures", + "python >=2.7,<2.8.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "trollius", + "tzlocal >=1.2" + ], + "license": "MIT", + "md5": "297202fb6b66f2052ae37ddcc30fdc8a", + "name": "apscheduler", + "sha256": "b4f24672101bcee67ad88aa6ed8f04a00e6d31cb2e2fd59f022e47b243bc1f15", + "size": 84059, + "subdir": "linux-64", + "timestamp": 1575668867235, + "version": "3.6.3" + }, + "apscheduler-3.6.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=1.2" + ], + "license": "MIT", + "md5": "485653dc3f03708065c38b16c99619de", + "name": "apscheduler", + "sha256": "eb0e300fa7ee448be95b5889f73cadf119f8ffba216aced5aec501fd3af93456", + "size": 86067, + "subdir": "linux-64", + "timestamp": 1575668904710, + "version": "3.6.3" + }, + "apscheduler-3.6.3-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=1.2" + ], + "license": "MIT", + "md5": "cad699f1c0866e76bc79c8ede722b476", + "name": "apscheduler", + "sha256": "c18e80b7bbe8c06ee8fff11b88ae977306efa1a5b6332bee64c9354ff87f1f10", + "size": 86316, + "subdir": "linux-64", + "timestamp": 1590508705154, + "version": "3.6.3" + }, + "apscheduler-3.6.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=1.2" + ], + "license": "MIT", + "md5": "a444518612c07f464ca43a521bfe7e33", + "name": "apscheduler", + "sha256": "37b05e435b99ad7e847e6ef7f9df3e0be6a0b50fd299d814be43af0b3ca5155c", + "size": 85966, + "subdir": "linux-64", + "timestamp": 1575668923941, + "version": "3.6.3" + }, + "apscheduler-3.6.3-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=1.2" + ], + "license": "MIT", + "md5": "bc1f97dfefbc83c94da3c8cd82c34e87", + "name": "apscheduler", + "sha256": "02b557f2ccf69c77cac3160deccc669aa0d3f2d0e1ffdd4a6299995ba0b801e9", + "size": 86264, + "subdir": "linux-64", + "timestamp": 1590508731149, + "version": "3.6.3" + }, + "apscheduler-3.6.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=1.2" + ], + "license": "MIT", + "md5": "a782dd5263760e33d2be9d04d373117b", + "name": "apscheduler", + "sha256": "c3adfa0cfc7a0dce91a85e7e70e165b09582cca606b74764b3be6355fc747a8d", + "size": 86304, + "subdir": "linux-64", + "timestamp": 1575668934296, + "version": "3.6.3" + }, + "apscheduler-3.6.3-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=1.2" + ], + "license": "MIT", + "md5": "44d2689f1b6c83ea96448556b69527fa", + "name": "apscheduler", + "sha256": "ccba19e5674bc31dc20293be0b918e7227d09447acfad6f13e225ed933f04345", + "size": 86609, + "subdir": "linux-64", + "timestamp": 1590508743899, + "version": "3.6.3" + }, + "apscheduler-3.7.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=2.0,<2.1" + ], + "license": "MIT", + "md5": "145efcc81770e24c730a9ef63e3568d1", + "name": "apscheduler", + "sha256": "bbca98677dc40a4726216c980574032cd71c6d45a7455e2004cab8c89fd913f3", + "size": 84630, + "subdir": "linux-64", + "timestamp": 1640803376607, + "version": "3.7.0" + }, + "apscheduler-3.7.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=2.0,<2.1" + ], + "license": "MIT", + "md5": "b74e19a99acc8142874ae01ae250d12e", + "name": "apscheduler", + "sha256": "47d966c591389c5c500b9c7c834422456ec93ff821ff7d692dad0b2318c807f7", + "size": 83454, + "subdir": "linux-64", + "timestamp": 1612239290582, + "version": "3.7.0" + }, + "apscheduler-3.7.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=2.0,<2.1" + ], + "license": "MIT", + "md5": "388e9f288971d2102b99cb9994ad0486", + "name": "apscheduler", + "sha256": "4a873b4af6cd66905830fdbd1d371cbbb080d1ef5a634c2cfe7960353cb0e579", + "size": 83443, + "subdir": "linux-64", + "timestamp": 1612239292113, + "version": "3.7.0" + }, + "apscheduler-3.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=2.0,<2.1" + ], + "license": "MIT", + "md5": "fc99337f9307945d20d0fc39527daa75", + "name": "apscheduler", + "sha256": "e151314161d9a0b993e9e4e9d1415a23aac71e7ae1ea862a0437f2e1626e96f7", + "size": 83757, + "subdir": "linux-64", + "timestamp": 1612239285579, + "version": "3.7.0" + }, + "apscheduler-3.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=2.0,<2.1" + ], + "license": "MIT", + "md5": "3a8677a3412067080bd0967aa0be73e0", + "name": "apscheduler", + "sha256": "420f431bd61e3950c52278680f937c1a6889989e6c5bdec2632217de006cd742", + "size": 83888, + "subdir": "linux-64", + "timestamp": 1613146952111, + "version": "3.7.0" + }, + "apscheduler-3.9.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytz", + "setuptools >=0.7", + "six >=1.4.0", + "tzlocal >=2.0,!=3.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "863b78b263426a9ae5dca881042f839d", + "name": "apscheduler", + "sha256": "a7fb5e4e5a007e537e0dfae2c7e72cd592a907fbfdb0bfa80d72edbdf4785592", + "size": 85194, + "subdir": "linux-64", + "timestamp": 1668633088189, + "version": "3.9.0" + }, + "apscheduler-3.9.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "pytz", + "setuptools >=0.7", + "six >=1.4.0", + "tzlocal >=2.0,!=3.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "38f1096823caa4e827bab0821acddcab", + "name": "apscheduler", + "sha256": "678ac5c51f89e1d7872a38f5be104d89a56dbe0ebd7a4aa810636e028c2b4188", + "size": 114755, + "subdir": "linux-64", + "timestamp": 1676843197486, + "version": "3.9.0" + }, + "apscheduler-3.9.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz", + "setuptools >=0.7", + "six >=1.4.0", + "tzlocal >=2.0,!=3.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ac5402770cb2e1162c116323cd04aafb", + "name": "apscheduler", + "sha256": "bae13285260556d08135c2ef775497d614e21f3e32bddd0f21d683e418fe3f9d", + "size": 83839, + "subdir": "linux-64", + "timestamp": 1668633025910, + "version": "3.9.0" + }, + "apscheduler-3.9.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz", + "setuptools >=0.7", + "six >=1.4.0", + "tzlocal >=2.0,!=3.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b84b1bd73d84e0f738e3d0ca853226b", + "name": "apscheduler", + "sha256": "4047f9c286762ceba238f19e9ea632d39a82d72e037771f1483d011d59623fa4", + "size": 84142, + "subdir": "linux-64", + "timestamp": 1668632993932, + "version": "3.9.0" + }, + "apscheduler-3.9.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytz", + "setuptools >=0.7", + "six >=1.4.0", + "tzlocal >=2.0,!=3.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33acdbdf968700f027d64a2af52277cb", + "name": "apscheduler", + "sha256": "2adf7ef4d8ba2683de536ef6d92261d579cba91e392d817126edb26999bf3fe3", + "size": 84365, + "subdir": "linux-64", + "timestamp": 1668633057116, + "version": "3.9.0" + }, + "aredis-1.1.7-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "contextvars", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee0b106e433d07ae39348b12052b7f78", + "name": "aredis", + "sha256": "f7464588c8b30261afe52443ed2bcef63b8ecbf01b244fa29e4f4b49953111b1", + "size": 302189, + "subdir": "linux-64", + "timestamp": 1585086137748, + "version": "1.1.7" + }, + "aredis-1.1.7-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de4319a07600f811425ee8112be4ade1", + "name": "aredis", + "sha256": "b9dc3cde0c83a9c2bddac5618f4a9ef8ec5a572a974995e9b0304aea786df1b2", + "size": 316476, + "subdir": "linux-64", + "timestamp": 1585086131984, + "version": "1.1.7" + }, + "aredis-1.1.7-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77f65bd93da472649b2ff500bf82d14c", + "name": "aredis", + "sha256": "e5639bf169dc555b6177d24e72a8c50d7789db887ef2831b755140f95bd6788d", + "size": 301484, + "subdir": "linux-64", + "timestamp": 1585086131335, + "version": "1.1.7" + }, + "aredis-1.1.8-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "32016a686c4ac8e3627eb322687a9b1d", + "name": "aredis", + "sha256": "21d5a3862ada61706c6e30e3f278c8fee48a4014e9bc06674f963327d2bfd8c7", + "size": 148762, + "subdir": "linux-64", + "timestamp": 1640788191766, + "version": "1.1.8" + }, + "aredis-1.1.8-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2ff5b11ea722bee44e31fd5a4d66fd6", + "name": "aredis", + "sha256": "33247d084333ffcb7525a13cf3386546b46d47dd30f1e5d60ea1e734a74771da", + "size": 178952, + "subdir": "linux-64", + "timestamp": 1676906886545, + "version": "1.1.8" + }, + "aredis-1.1.8-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "contextvars", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ed8e9b67406ba29edf0024cf12331f28", + "name": "aredis", + "sha256": "eeaf21bb50c186b95a13aad9a4658d8c72a63e47ca5ae4b8677b7031239f3f8b", + "size": 353605, + "subdir": "linux-64", + "timestamp": 1613036344544, + "version": "1.1.8" + }, + "aredis-1.1.8-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "contextvars", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "abc9c7ac64ffd699b380e5bd8a977e50", + "name": "aredis", + "sha256": "a1f5fc6711dd0900f0b3970dd5f270aa68f6def10f8eaaadb946bb60a1b909fe", + "size": 304177, + "subdir": "linux-64", + "timestamp": 1585083627852, + "version": "1.1.8" + }, + "aredis-1.1.8-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "efdf9484d92bf2e5f9b4642132762f8e", + "name": "aredis", + "sha256": "4a89de8ea76fa34d56ebde4b35f55a107b0843d68f084e75e0fe6c22718915b5", + "size": 353870, + "subdir": "linux-64", + "timestamp": 1613036337244, + "version": "1.1.8" + }, + "aredis-1.1.8-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca2367b42a812e3535174a39d01fdfd9", + "name": "aredis", + "sha256": "9ca90e0f9707e200a8632f2bc1f3d17abb0038ca0af857b58b7a11d3ea3fb985", + "size": 316921, + "subdir": "linux-64", + "timestamp": 1585083602002, + "version": "1.1.8" + }, + "aredis-1.1.8-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc7fe56b4ef1d74c056fb1222d9e3d87", + "name": "aredis", + "sha256": "973317a44bd30f8d46c6fa9a20a6ccfa2eec2a0c6c5481f5449320fd43da2ee3", + "size": 354605, + "subdir": "linux-64", + "timestamp": 1613035938433, + "version": "1.1.8" + }, + "aredis-1.1.8-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "969b3d009f6588117bf7edadd1baf2c5", + "name": "aredis", + "sha256": "e3e5523e15dca2684bfcc58772247369ad553b066877e21097277e70ee97abd6", + "size": 305009, + "subdir": "linux-64", + "timestamp": 1585083633896, + "version": "1.1.8" + }, + "aredis-1.1.8-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d4f549be8223ead012f4756405a45b1f", + "name": "aredis", + "sha256": "8f1512983d35e10d1ff41bb2e57f1125cdd89548ca03921bfdc04dd5a61ca4cc", + "size": 370656, + "subdir": "linux-64", + "timestamp": 1613036328438, + "version": "1.1.8" + }, + "argcomplete-1.10.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f6c15b51e77032e84c1d4d31acb20f86", + "name": "argcomplete", + "sha256": "a1eea9fe92c56f3e3aea807bcfc2cd3ac5812ac1c3465e9b8bd707674ebde61b", + "size": 47114, + "subdir": "linux-64", + "timestamp": 1559927327650, + "version": "1.10.0" + }, + "argcomplete-1.10.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "71c6220de04c09ad3a56bfe0fdaf80e8", + "name": "argcomplete", + "sha256": "dd219abd701499961b99b65cccf06b019534ac66df11305e55da0ef4bb2e0af3", + "size": 47802, + "subdir": "linux-64", + "timestamp": 1559927347700, + "version": "1.10.0" + }, + "argcomplete-1.10.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1811e666a7885e9818a1b16d90763940", + "name": "argcomplete", + "sha256": "b3141623dc70946819b38ea1d038ab33a2be82b73677992121f0587b0595f04c", + "size": 47837, + "subdir": "linux-64", + "timestamp": 1559927314245, + "version": "1.10.0" + }, + "argcomplete-1.10.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6278334da468fc6661bd3c12096e4530", + "name": "argcomplete", + "sha256": "38815e7d74525113a146132c1833927993395cde4addb11324d011e62daeef49", + "size": 46589, + "subdir": "linux-64", + "timestamp": 1572437716942, + "version": "1.10.0" + }, + "argcomplete-1.9.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "39224e9308936ed376d14a48ff4ab197", + "name": "argcomplete", + "sha256": "f12bb94dbc6fc5e419308aca25cddf0e169701de246c74fa61465f01e8afaca2", + "size": 44061, + "subdir": "linux-64", + "timestamp": 1516391575589, + "version": "1.9.3" + }, + "argcomplete-1.9.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a7d6cf19dc1cffd89ace993a3e2df0d7", + "name": "argcomplete", + "sha256": "bfbaa36c6178600ac937d9c04b808f48f779df859f47b9f77e48ae6d0704fcf2", + "size": 44816, + "subdir": "linux-64", + "timestamp": 1516391594085, + "version": "1.9.3" + }, + "argcomplete-1.9.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f3433ff5c95d17d6f5936af8f7775bf3", + "name": "argcomplete", + "sha256": "44b38a3abf3f1be853c72f8e69377672d03259fe2a45699155d2d022d28d8c54", + "size": 44605, + "subdir": "linux-64", + "timestamp": 1516391593020, + "version": "1.9.3" + }, + "argcomplete-1.9.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8d5f405d7c3fb1c99aff310841babb75", + "name": "argcomplete", + "sha256": "b1c96c38aac694bc8ea1ef53c89daa7383b5113f1bfa390a223f59ca8517c6ca", + "size": 44633, + "subdir": "linux-64", + "timestamp": 1522705810096, + "version": "1.9.4" + }, + "argcomplete-1.9.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8a9df6a02dc003ac706908f1ee83a7cb", + "name": "argcomplete", + "sha256": "4808209b231e4c7a8ff9ad949d2d1bbf370b3531abd628730c26d40787233b18", + "size": 45552, + "subdir": "linux-64", + "timestamp": 1522704479474, + "version": "1.9.4" + }, + "argcomplete-1.9.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e27aa32081778197649792b377ee1c6b", + "name": "argcomplete", + "sha256": "c14c0c02117a2d9e688f3b6db5ea4da06d8b85b50aed5c018b9003165f482910", + "size": 45411, + "subdir": "linux-64", + "timestamp": 1522703919779, + "version": "1.9.4" + }, + "argcomplete-1.9.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d70e1541e94b81907d2e7555570e6cbe", + "name": "argcomplete", + "sha256": "45392c024adf27934558fafb9dfcf63209ae1cfb3b239a0991b8232f7973c6f3", + "size": 45426, + "subdir": "linux-64", + "timestamp": 1530737639150, + "version": "1.9.4" + }, + "argcomplete-1.9.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a8944f526dce6ba169fd23811632c194", + "name": "argcomplete", + "sha256": "2d44a8fef596f10d07777e41339885112a76bcf272f87adea915cd975b9f938f", + "size": 46199, + "subdir": "linux-64", + "timestamp": 1556062326505, + "version": "1.9.5" + }, + "argcomplete-1.9.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2ae39a1ad8cbcd620af6b36c19b2792c", + "name": "argcomplete", + "sha256": "5e0959d835a806f65f8d171abd340e28ea7bd726e4a9801a7004090d009d3166", + "size": 46877, + "subdir": "linux-64", + "timestamp": 1556062355062, + "version": "1.9.5" + }, + "argcomplete-1.9.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6d805d98ffe5a07efcd5a4047ccffdbd", + "name": "argcomplete", + "sha256": "3e4c5b070a95500f3d98787a81f382cc6679e381c1cdb644fd8c95a524a1ecd8", + "size": 47025, + "subdir": "linux-64", + "timestamp": 1556062168308, + "version": "1.9.5" + }, + "argh-0.26.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 3", + "md5": "ba8142d6ee1ffe11e492a696385f3cef", + "name": "argh", + "sha256": "1f8956b61735df08d54d1b3bd1d2b4bf905b820302bc10ae1109dae87c5898c3", + "size": 36282, + "subdir": "linux-64", + "timestamp": 1575415955533, + "version": "0.26.2" + }, + "argh-0.26.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL 3", + "md5": "a9efe4a0d941e76ecb1e3ec37659fcbe", + "name": "argh", + "sha256": "3bdd82c71f9f33a6f18fccd128375f654d334262ef3d02691c5c85533623bdc4", + "size": 35179, + "subdir": "linux-64", + "timestamp": 1640788209534, + "version": "0.26.2" + }, + "argh-0.26.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL 3", + "md5": "5e6bd1fa2ef144e3038dfe3821d09e0f", + "name": "argh", + "sha256": "b26d0e33087183c922aa7bf9e4112164b96f598d2a93df747bdb0edb218ebc86", + "size": 42715, + "subdir": "linux-64", + "timestamp": 1676846816291, + "version": "0.26.2" + }, + "argh-0.26.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 3", + "md5": "1b253f9dd43c92baca57e9131f118e5e", + "name": "argh", + "sha256": "c09d7deee63db4310d7718497544681b9082cf42d5fbf44f33db0a518a4d6fb3", + "size": 36987, + "subdir": "linux-64", + "timestamp": 1575416058307, + "version": "0.26.2" + }, + "argh-0.26.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 3", + "md5": "13e7dee15da0b619373c00b292b166f5", + "name": "argh", + "sha256": "9f28e4d64993c1018b8ff7f7d1d126e1f40a8639acbf92b022cff875cbcd9a9a", + "size": 36965, + "subdir": "linux-64", + "timestamp": 1575416113205, + "version": "0.26.2" + }, + "argh-0.26.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL 3", + "md5": "95d818b1d7680e4d32f53778c57eb232", + "name": "argh", + "sha256": "5c8f04b8de03485af864aa9dc239a193b3552f23a040d85ddb25314492cc493e", + "size": 36990, + "subdir": "linux-64", + "timestamp": 1575416089430, + "version": "0.26.2" + }, + "argh-0.26.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL 3", + "md5": "304cb5da7e71ef24145763f032168d8b", + "name": "argh", + "sha256": "e0dba9842be53f5b0018f901c20d44ba6b2a041b2464cad5f9d9db8ea5aefdce", + "size": 37089, + "subdir": "linux-64", + "timestamp": 1607464191822, + "version": "0.26.2" + }, + "argon2-cffi-20.1.0-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "constrains": [ + "argon2_cffi ==999" + ], + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "814ac8340a97aa2f861cac5211979b76", + "name": "argon2-cffi", + "sha256": "97a9224fd55b77e61340653a41f86554cff3fd63b3e1d9051c2592e50074d243", + "size": 98748, + "subdir": "linux-64", + "timestamp": 1641902210667, + "version": "20.1.0" + }, + "argon2-cffi-20.1.0-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "constrains": [ + "argon2_cffi ==999" + ], + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "abc6ad1bc54924d53eb730d4f4c86fe5", + "name": "argon2-cffi", + "sha256": "dd4ee4e5247b047ff623b6bf4376426d378163faa156c690ca15db57075c402a", + "size": 50237, + "subdir": "linux-64", + "timestamp": 1613037547824, + "version": "20.1.0" + }, + "argon2-cffi-20.1.0-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "constrains": [ + "argon2_cffi ==999" + ], + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11a3e5b8a54f5afc5b6e0601a132a98f", + "name": "argon2-cffi", + "sha256": "79ff82674e838272b2e848ecdb96f283d5cb24a1c040df992215611a2f4e0feb", + "size": 50012, + "subdir": "linux-64", + "timestamp": 1596828535063, + "version": "20.1.0" + }, + "argon2-cffi-20.1.0-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "constrains": [ + "argon2_cffi ==999" + ], + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "42599b161d980e76c0b5cd17d724f00e", + "name": "argon2-cffi", + "sha256": "7553e377e0f37a38fff85f5799bc86e451e5b4e4190a84c80bc91379a3f26ae6", + "size": 50238, + "subdir": "linux-64", + "timestamp": 1613036689103, + "version": "20.1.0" + }, + "argon2-cffi-20.1.0-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "constrains": [ + "argon2_cffi ==999" + ], + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "09bd308b34448f4b0922be3cf40b6f74", + "name": "argon2-cffi", + "sha256": "6ac397872d3aa1d0a9d793ecc69b063ee06214bfcba0d10b60e92a5c66e63f10", + "size": 50025, + "subdir": "linux-64", + "timestamp": 1596828486772, + "version": "20.1.0" + }, + "argon2-cffi-20.1.0-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "constrains": [ + "argon2_cffi ==999" + ], + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fbc538a3f7744ee8c0c28a4bcb434636", + "name": "argon2-cffi", + "sha256": "b9b8b5adda8372019f125039f7fa2992390e5a14ba19169e8776480d5713f842", + "size": 50414, + "subdir": "linux-64", + "timestamp": 1613037152435, + "version": "20.1.0" + }, + "argon2-cffi-20.1.0-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "constrains": [ + "argon2_cffi ==999" + ], + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be324604dfd1b15dda8d26fa6a03f948", + "name": "argon2-cffi", + "sha256": "bacb9e8e0dbb5c42cbf38e174df38776a87c6befeab8a6739df782ba8b45ebcb", + "size": 50149, + "subdir": "linux-64", + "timestamp": 1596828538063, + "version": "20.1.0" + }, + "argon2-cffi-20.1.0-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "constrains": [ + "argon2_cffi ==999" + ], + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3884aa0d1bfea2f7e3587d5fd3518ade", + "name": "argon2-cffi", + "sha256": "bc8caea883401012097626fced4c5d745146680d5d541d0633c59e48c8e072f2", + "size": 50374, + "subdir": "linux-64", + "timestamp": 1613037556701, + "version": "20.1.0" + }, + "argon2-cffi-20.1.0-py39he8ac12f_1.tar.bz2": { + "build": "py39he8ac12f_1", + "build_number": 1, + "constrains": [ + "argon2_cffi ==999" + ], + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d332577254c696e9f739922e6944905e", + "name": "argon2-cffi", + "sha256": "4697da82f4fb40a05e7e12ef5e37fb481d43f6814427823ffa88527de66e20a5", + "size": 50364, + "subdir": "linux-64", + "timestamp": 1607022511360, + "version": "20.1.0" + }, + "argon2-cffi-bindings-21.2.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.1", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96b990f76f2e61e914f5ad1958f6e7bd", + "name": "argon2-cffi-bindings", + "sha256": "f4d21ee48ca45cc62ae063f6de973c5599505d628e7675e512eb86f73f851410", + "size": 85215, + "subdir": "linux-64", + "timestamp": 1644553401362, + "version": "21.2.0" + }, + "argon2-cffi-bindings-21.2.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.1", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "062acdb0f9ae976c25c2d15d589dc1d6", + "name": "argon2-cffi-bindings", + "sha256": "0d4f5274503916e1c683dcc16e8a7c4186557afa3f62399cd628e4eb535fe77a", + "size": 35809, + "subdir": "linux-64", + "timestamp": 1676823571351, + "version": "21.2.0" + }, + "argon2-cffi-bindings-21.2.0-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.1", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b3e0252833c5a8ae8aa4848174e9ea9d", + "name": "argon2-cffi-bindings", + "sha256": "5bc25283fae2b984c02250a509beccc278030f08231f04490ac9314084d82875", + "size": 35351, + "subdir": "linux-64", + "timestamp": 1644569720887, + "version": "21.2.0" + }, + "argon2-cffi-bindings-21.2.0-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.1", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e785c0744d3ed83d813a42b7bb9b8794", + "name": "argon2-cffi-bindings", + "sha256": "754046398c314772a7d38b7d4c0d488a48db7b1b9c6a421686ef13178e1997b9", + "size": 35378, + "subdir": "linux-64", + "timestamp": 1644569723962, + "version": "21.2.0" + }, + "argon2-cffi-bindings-21.2.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.1", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2972a84e0e22ae3244bbd2f1eebcf536", + "name": "argon2-cffi-bindings", + "sha256": "8e115035314cadb1ce373fd96cdcbc4e14df922d094c8403ea9e80ca35f5873a", + "size": 35352, + "subdir": "linux-64", + "timestamp": 1644569715988, + "version": "21.2.0" + }, + "argon2_cffi-18.1.0-py27h14c3975_2.tar.bz2": { + "build": "py27h14c3975_2", + "build_number": 2, + "depends": [ + "cffi >=1.0.0", + "enum34", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "728860dd44bd9f4cad3e72eb718d43c9", + "name": "argon2_cffi", + "sha256": "f4a48b0beea488ab375b506417086f5856193fe4927a3c8c4a19e04f76319615", + "size": 42010, + "subdir": "linux-64", + "timestamp": 1530736241255, + "version": "18.1.0" + }, + "argon2_cffi-18.1.0-py35h14c3975_2.tar.bz2": { + "build": "py35h14c3975_2", + "build_number": 2, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1691b0fcf4d4a4ffb0b31b7620946c5d", + "name": "argon2_cffi", + "sha256": "ac3aa81e36a289ab229950335a5c40b037110c408964cac98c19917146d1b84e", + "size": 42188, + "subdir": "linux-64", + "timestamp": 1534352230703, + "version": "18.1.0" + }, + "argon2_cffi-18.1.0-py36h14c3975_2.tar.bz2": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "494eb92bda73a5dccba6a7d09ba201bb", + "name": "argon2_cffi", + "sha256": "c47e08d5396fd139089e9bcea1d9ca5d41830ab82a264c5b648f69c92f114c40", + "size": 42205, + "subdir": "linux-64", + "timestamp": 1530736216724, + "version": "18.1.0" + }, + "argon2_cffi-18.1.0-py37h14c3975_2.tar.bz2": { + "build": "py37h14c3975_2", + "build_number": 2, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e32086b9f74583b382e66a64260ab33e", + "name": "argon2_cffi", + "sha256": "c33d36d12b7ea4c96115dc26e9d81c0a80977e7fa854f7aa82fe9573bbb4b518", + "size": 42276, + "subdir": "linux-64", + "timestamp": 1530736265061, + "version": "18.1.0" + }, + "argon2_cffi-18.3.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "enum34", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "94e38ca01aa942e6d536037a1966b641", + "name": "argon2_cffi", + "sha256": "e85e4bb3fb227751d5e018c8e4a428b0689c66a1ad0c6b4662e48d752c863f0d", + "size": 46327, + "subdir": "linux-64", + "timestamp": 1535422627228, + "version": "18.3.0" + }, + "argon2_cffi-18.3.0-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "91ea68a93a990fa54f859e4fb9543c97", + "name": "argon2_cffi", + "sha256": "3893e0d788310aeb34fdc69e6d43a01fa91974f88b9273bc76046867343de1a7", + "size": 46578, + "subdir": "linux-64", + "timestamp": 1535422942699, + "version": "18.3.0" + }, + "argon2_cffi-18.3.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc683a64907419293a9566edc99c8e14", + "name": "argon2_cffi", + "sha256": "75c351f662ec8a4981e93feeb88b3481190bea0866cb979a4819d012b8ca0006", + "size": 46557, + "subdir": "linux-64", + "timestamp": 1535422802102, + "version": "18.3.0" + }, + "argon2_cffi-18.3.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c106bb8644fee91e340365faf187ea1", + "name": "argon2_cffi", + "sha256": "1dacff91fc79a44cc0f472724b73ca1affe4fb69676df4a43c384c25de724fc7", + "size": 46571, + "subdir": "linux-64", + "timestamp": 1535423075430, + "version": "18.3.0" + }, + "argon2_cffi-19.1.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "enum34", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe1f42eaef16e4140ae5bbf9ac6518c7", + "name": "argon2_cffi", + "sha256": "cff999fd6f458ebc5414cbc5c39053c2592569116c67a7fe24c0172daf28de24", + "size": 48404, + "subdir": "linux-64", + "timestamp": 1547746836072, + "version": "19.1.0" + }, + "argon2_cffi-19.1.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8837bfd5be997a0aefe81a4ce73bff78", + "name": "argon2_cffi", + "sha256": "a81daec1c8960d2d00df43dd72a44f9d2ebc86c5199e8e34038ef4293e5c4546", + "size": 48711, + "subdir": "linux-64", + "timestamp": 1547746876470, + "version": "19.1.0" + }, + "argon2_cffi-19.1.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bec4900f413dabab8e9c9f4638aeccd8", + "name": "argon2_cffi", + "sha256": "1e6e8e1dbe6769be96da198b5259d644c682c8239b978d2b81c84d9e99da2713", + "size": 48741, + "subdir": "linux-64", + "timestamp": 1547746954001, + "version": "19.1.0" + }, + "argon2_cffi-19.1.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4a5e6f159e6827282b34cdd84f9f78b8", + "name": "argon2_cffi", + "sha256": "13e174f25763cca1158d14035336a6f6fb368f0b68087d7578c0e2330eb0523a", + "size": 47305, + "subdir": "linux-64", + "timestamp": 1574097565199, + "version": "19.1.0" + }, + "arrow-0.10.0-py27hc811e17_0.tar.bz2": { + "build": "py27hc811e17_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "md5": "97d390d56c61f6d57ed92f6d80ab358b", + "name": "arrow", + "sha256": "095d3181fe457b5dbfa9fc47a948b4584ad99c50bf7b715b88985ee537ff3401", + "size": 68491, + "subdir": "linux-64", + "timestamp": 1505693773499, + "version": "0.10.0" + }, + "arrow-0.10.0-py35h5f21c2d_0.tar.bz2": { + "build": "py35h5f21c2d_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "md5": "99fbf56f30dc7552052ff7464313944e", + "name": "arrow", + "sha256": "5a523e6f270363185ee7ef665bd78d368f89b020a83d7aec2828a8a6f3413de2", + "size": 70526, + "subdir": "linux-64", + "timestamp": 1505693785721, + "version": "0.10.0" + }, + "arrow-0.10.0-py36h012aaaf_0.tar.bz2": { + "build": "py36h012aaaf_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "md5": "d9c66f853ae1f964b97b87997a9f842f", + "name": "arrow", + "sha256": "623d783081e1e2bbd342d4001658655360422242c2418d89ac5133397c781405", + "size": 69864, + "subdir": "linux-64", + "timestamp": 1505693797990, + "version": "0.10.0" + }, + "arrow-0.12.0-py27hc0e3b90_0.tar.bz2": { + "build": "py27hc0e3b90_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "python >=2.7,<2.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b06264f77b68d02acc35051d95409872", + "name": "arrow", + "sha256": "32f660cc7d5aa6ca03c78d1668b351f0f2260c15182095225bd56aedac3e56fa", + "size": 74416, + "subdir": "linux-64", + "timestamp": 1512027609502, + "version": "0.12.0" + }, + "arrow-0.12.0-py35h71c922e_0.tar.bz2": { + "build": "py35h71c922e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6a422bcdfd0bd674256ba822510b62c2", + "name": "arrow", + "sha256": "cb20447e4710214e9a6cc1c1fa6b0de6a0731581e237791537ef8ee9dc4158cf", + "size": 76738, + "subdir": "linux-64", + "timestamp": 1512027610325, + "version": "0.12.0" + }, + "arrow-0.12.0-py36h92fbc78_0.tar.bz2": { + "build": "py36h92fbc78_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3f06b9e34ceff7d1a57430ce536820ff", + "name": "arrow", + "sha256": "9e83d4850b31dd8bfd205d1ab596ebbcdbabdfd4b848bb18142e1adac3ac7f95", + "size": 76000, + "subdir": "linux-64", + "timestamp": 1512027601232, + "version": "0.12.0" + }, + "arrow-0.12.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "backports.functools_lru_cache", + "python >=2.7,<2.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "07ef24475acac20fad342dd2b09adf87", + "name": "arrow", + "sha256": "3a7c828f23984c66cc0629ed6bab66904b8d4cf6b5f63068df39629c913408b8", + "size": 74165, + "subdir": "linux-64", + "timestamp": 1520882477481, + "version": "0.12.1" + }, + "arrow-0.12.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0bc7a33003c1ff35e7e93b129012a837", + "name": "arrow", + "sha256": "3acf12db8a6ddad54ff64f5f7c82715a0160db7e008e221e04a1a1be1b5d1cf5", + "size": 76394, + "subdir": "linux-64", + "timestamp": 1520882507070, + "version": "0.12.1" + }, + "arrow-0.12.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "71f5879f47a980690921721645697d69", + "name": "arrow", + "sha256": "fddf8a83ce3b51b80fecd40485db9a0c3b475d377db972f56c82c20216ace693", + "size": 75737, + "subdir": "linux-64", + "timestamp": 1520905296301, + "version": "0.12.1" + }, + "arrow-0.12.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2adc6a041b251999679b70eb097a5a16", + "name": "arrow", + "sha256": "caeb0d19063652d7923c77e60a0a449e821fd5a72233ae91ccb0bbd79fdade58", + "size": 75433, + "subdir": "linux-64", + "timestamp": 1530737757161, + "version": "0.12.1" + }, + "arrow-0.13.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "python >=2.7,<2.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b48fb070ef0120641b0e4292c3ffeafe", + "name": "arrow", + "sha256": "dd7fe2919abdc7117994e2bacfb8553bcf86cdec3ba96e7322debe36d61ea610", + "size": 82199, + "subdir": "linux-64", + "timestamp": 1550266373138, + "version": "0.13.1" + }, + "arrow-0.13.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "186afce3e7d114b1fe8f49dd666e7552", + "name": "arrow", + "sha256": "be5b6f64aef972f256e53e1404c307f485dd4986f7d83a84a20d5161ed00e06d", + "size": 83446, + "subdir": "linux-64", + "timestamp": 1550266412556, + "version": "0.13.1" + }, + "arrow-0.13.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1c1592a3d0d1ac4e7262cc742d78143e", + "name": "arrow", + "sha256": "c7ce8fa36cd319e3828cf09b2c380bfe1ae88722c87f780045da34fdc28d727f", + "size": 83402, + "subdir": "linux-64", + "timestamp": 1550266335026, + "version": "0.13.1" + }, + "arrow-0.13.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "44282bf6316c87caaaba531c05381dd5", + "name": "arrow", + "sha256": "3a135c5cb99cf18b5a92152b0ada9832d4df592a2f4195676310458d2449f92f", + "size": 81114, + "subdir": "linux-64", + "timestamp": 1574097587346, + "version": "0.13.1" + }, + "arrow-0.13.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "63f8457cd4d2df86d3e5a55eee42248f", + "name": "arrow", + "sha256": "7824d17263ea51bca53fa3c713a46cca55f7143e33fd7f20c59bde33331a8670", + "size": 83816, + "subdir": "linux-64", + "timestamp": 1617737723768, + "version": "0.13.1" + }, + "arrow-0.15.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f454a8cb09c587dba078f0320e08cf96", + "name": "arrow", + "sha256": "8fc564cdba1410d7a3409622849ebfd0bbf11b540e19d42ae535c0bb8c08898a", + "size": 104066, + "subdir": "linux-64", + "timestamp": 1601735553387, + "version": "0.15.6" + }, + "arrow-0.15.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0783f3f85c993cd406a3a4d56b7e9558", + "name": "arrow", + "sha256": "1501ae41fc81cceedd28d8c4b47f87e548fd997a40ae937cbfa8458217ccd26a", + "size": 103859, + "subdir": "linux-64", + "timestamp": 1601735543978, + "version": "0.15.6" + }, + "arrow-0.15.6-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "df0ef417209930b91d17f667c8906c7d", + "name": "arrow", + "sha256": "4e0cb2a1aac88de2df631b7410031328cf0b30821aa2cbdfce077536343b5305", + "size": 104292, + "subdir": "linux-64", + "timestamp": 1591915706854, + "version": "0.15.6" + }, + "arrow-0.15.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c487562a1881fdacfe413bd86c37ebfd", + "name": "arrow", + "sha256": "3950dcfde9658be19b285aed90c9e46a7f1d8c297552ac441a14937641076a8f", + "size": 109856, + "subdir": "linux-64", + "timestamp": 1597097805450, + "version": "0.15.8" + }, + "arrow-0.15.8-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6f851f772e7509e2f3964ed48edecd7d", + "name": "arrow", + "sha256": "9f4cb008f68123d773d6389bcab048375967628d0aeb0115c7b3ed35a87680bf", + "size": 109910, + "subdir": "linux-64", + "timestamp": 1614002840308, + "version": "0.15.8" + }, + "arrow-0.15.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "28245f45823274ddabeaa5cfca5c0a96", + "name": "arrow", + "sha256": "bb06adddb6a15a666775f6f259fbd4d868b4a41a5fcf2cbbb2ec5d37393587c2", + "size": 109725, + "subdir": "linux-64", + "timestamp": 1597085457007, + "version": "0.15.8" + }, + "arrow-0.15.8-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "19546443ba3a23064c719bf124318af2", + "name": "arrow", + "sha256": "ca44242973b0a5ebd67741a9034a3c25053d813961d677a7e98a45bffaae5001", + "size": 109775, + "subdir": "linux-64", + "timestamp": 1614001956698, + "version": "0.15.8" + }, + "arrow-0.15.8-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "532caffcde3f1eb87ccec9c29ffda35b", + "name": "arrow", + "sha256": "74385b4864207e1ca85289d8cc77730bc992f4e38f23f501d10a2db76195395a", + "size": 110513, + "subdir": "linux-64", + "timestamp": 1597097814080, + "version": "0.15.8" + }, + "arrow-0.15.8-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7adc6cfa2e45bf171200cf9708a43082", + "name": "arrow", + "sha256": "a159173f5deec004b17f8445c6b6d91228b09f11c3da3bb13c8e5468e4db531a", + "size": 110580, + "subdir": "linux-64", + "timestamp": 1614002416711, + "version": "0.15.8" + }, + "arrow-0.15.8-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c169927bfdd441cebcd88e118a084a28", + "name": "arrow", + "sha256": "cb3da5eb9b0c5d7aa9b7f718b77151efdb56d0e0b09d63da2f80644e7b2c599f", + "size": 110306, + "subdir": "linux-64", + "timestamp": 1614009238269, + "version": "0.15.8" + }, + "arrow-0.16.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1fda8104ac9927330ed70b502a245fca", + "name": "arrow", + "sha256": "af39ef254abd7bd88dfddbf1233fbed74c5aa5a6c0ce4e71d20386c8a4e05fda", + "size": 111676, + "subdir": "linux-64", + "timestamp": 1599270387420, + "version": "0.16.0" + }, + "arrow-0.16.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "da9c0a9dc02804b168d90b39f7560525", + "name": "arrow", + "sha256": "667b37a6fabc5da9f0607a7b8e00edc1b919191df18718a30e9ca41ddb0dac47", + "size": 111200, + "subdir": "linux-64", + "timestamp": 1599270405948, + "version": "0.16.0" + }, + "arrow-0.16.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ca7c5fa7f097e09e02c0725750ee0cc1", + "name": "arrow", + "sha256": "23d7d31f9464e07a2befc1e2eb3c739bf2f9882f85c472fd632110ce5611b35c", + "size": 112359, + "subdir": "linux-64", + "timestamp": 1599270454152, + "version": "0.16.0" + }, + "arrow-1.0.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c13a60620b76bf1c59172b9b20e660c9", + "name": "arrow", + "sha256": "4fbc735d0224f298fdaa494fc0e98c8fb9d4946311b2a5dab2b6742b929604bb", + "size": 118628, + "subdir": "linux-64", + "timestamp": 1615555990965, + "version": "1.0.3" + }, + "arrow-1.0.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0e4dd6ed450f2c00e3c82c4895617f77", + "name": "arrow", + "sha256": "c7e89fc0a2d392489beb54288c1eefa5732a8ccf508b71240f396f0239f07c3a", + "size": 118762, + "subdir": "linux-64", + "timestamp": 1615555987627, + "version": "1.0.3" + }, + "arrow-1.0.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7e9fe60a4aa549c571235cdd729f781e", + "name": "arrow", + "sha256": "6f885a163cc7cdd01f4f8362b1efb54f705e1f5145f6b6209c61d2c8cf84fa58", + "size": 119664, + "subdir": "linux-64", + "timestamp": 1615555993582, + "version": "1.0.3" + }, + "arrow-1.0.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1d995e9cb42b086f6e951b3f8fa58234", + "name": "arrow", + "sha256": "93a016b26932dba4dc6314d269b0e317faa68087833dac88e1e10c9c257c1e07", + "size": 118909, + "subdir": "linux-64", + "timestamp": 1615555988318, + "version": "1.0.3" + }, + "arrow-1.1.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.7.0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9c328d1534f3699ecc23ba47a2d6a7c4", + "name": "arrow", + "sha256": "77ea98995981c5fac48f5003e799c82c7ad51710ed173856f66be0ab738861e0", + "size": 126417, + "subdir": "linux-64", + "timestamp": 1619685708145, + "version": "1.1.0" + }, + "arrow-1.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e66a926aa0a82fdfb59029f9d040382b", + "name": "arrow", + "sha256": "bbe57258a602e5d4df33436947c08fc8e64d5a065d87bcce18607939eba1983e", + "size": 126496, + "subdir": "linux-64", + "timestamp": 1619685813094, + "version": "1.1.0" + }, + "arrow-1.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e84e65910eeb743f26647ef5d42de81a", + "name": "arrow", + "sha256": "ab5ca7928cb7de5a87f02551bb8ede915420e39dcb0be4cba953ff04ac8ad2b6", + "size": 127516, + "subdir": "linux-64", + "timestamp": 1619685812299, + "version": "1.1.0" + }, + "arrow-1.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "418b33d89a38f8fcfd021f114a39c7f4", + "name": "arrow", + "sha256": "ab19503125c22ae1ae9fbd4394038cb9c25a06d812eda3b75fa5f700e6d810dd", + "size": 126873, + "subdir": "linux-64", + "timestamp": 1619685811420, + "version": "1.1.0" + }, + "arrow-1.1.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ccec4bd11e9f9aba8cf0c00d96b8220e", + "name": "arrow", + "sha256": "7f95091d09d5261f1c49b260dc9be603fc6b43809ab10107858c352982e4a4b6", + "size": 132047, + "subdir": "linux-64", + "timestamp": 1641902016982, + "version": "1.1.1" + }, + "arrow-1.1.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.7.0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "590c69f6d8ab7f16ac2477196e8c6329", + "name": "arrow", + "sha256": "348a9ed3809a45d4c3a0c53668d6591abed12ebf53f9f9c3ff89a3ff1f398f80", + "size": 130681, + "subdir": "linux-64", + "timestamp": 1624645869670, + "version": "1.1.1" + }, + "arrow-1.1.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a5bbc0504d79efea5fb5a1d8061ced50", + "name": "arrow", + "sha256": "4c9c1e072dce8071475d3f2b8f847490a67f94d55066bccafc25a97795df201e", + "size": 130606, + "subdir": "linux-64", + "timestamp": 1624646050579, + "version": "1.1.1" + }, + "arrow-1.1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "367f042e108fa6b6db827e7390fa574b", + "name": "arrow", + "sha256": "7bc015aa7b02724a6b7c5fe52f8c544c7a315bcd7a52a95fd3eeb6a8938f48fd", + "size": 131629, + "subdir": "linux-64", + "timestamp": 1624646019194, + "version": "1.1.1" + }, + "arrow-1.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d147928a5689d4abb7a7e6a48cec6996", + "name": "arrow", + "sha256": "734094dd024b1742fd486bf30d7874c33c0b4e2299fe0da28699490633e89e26", + "size": 131049, + "subdir": "linux-64", + "timestamp": 1624639786282, + "version": "1.1.1" + }, + "arrow-1.2.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "65c77bee75cea3f58696d924120c98e5", + "name": "arrow", + "sha256": "778015bba89363ce5582d53b127adb6d0394dea979fafefbc903b4b9daf06ca4", + "size": 145710, + "subdir": "linux-64", + "timestamp": 1666726982067, + "version": "1.2.3" + }, + "arrow-1.2.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f0d5c74cdbb9b5cef8e25c6b9f370f94", + "name": "arrow", + "sha256": "a54e67829866d77dbfd3a3ac0a96957c061a29356220c688aefafd886ada5f3a", + "size": 145565, + "subdir": "linux-64", + "timestamp": 1676588289228, + "version": "1.2.3" + }, + "arrow-1.2.3-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ab52727d2435436fbac6dd6761dc8522", + "name": "arrow", + "sha256": "7ed6290b6d5cf4a25ef912bd6552c11a87a8408edd7e0beb19f77eb3b5ce365f", + "size": 171186, + "subdir": "linux-64", + "timestamp": 1677696260356, + "version": "1.2.3" + }, + "arrow-1.2.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ebd5dfafa6f7e3d5701443c29b8d1fb0", + "name": "arrow", + "sha256": "d0eda4221052d3a09d2f991a67afcf768325e04e00f342adaf7ed5e2e4fee075", + "size": 144188, + "subdir": "linux-64", + "timestamp": 1666727022943, + "version": "1.2.3" + }, + "arrow-1.2.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "97e2c5196f5a1ea436351ecc1449f051", + "name": "arrow", + "sha256": "3b65f98b2b5d1849f3d7aefe632e9f0095a0abf29dd9dca2ee2388242f33eaa0", + "size": 144205, + "subdir": "linux-64", + "timestamp": 1676588165040, + "version": "1.2.3" + }, + "arrow-1.2.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a4d3a2b7a06f2eace22faefc8759ef86", + "name": "arrow", + "sha256": "d92f9bc1b9581eeb600064f12f8a0e704accfb94890b4013ae8cbcadd9757fc1", + "size": 145222, + "subdir": "linux-64", + "timestamp": 1666726902336, + "version": "1.2.3" + }, + "arrow-1.2.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "41a094b22c91a244423160390fe26298", + "name": "arrow", + "sha256": "a797105f085fb79b2c9969c48cc973948dd1e07da72ddeee8d77937be7d1a727", + "size": 145449, + "subdir": "linux-64", + "timestamp": 1676588248915, + "version": "1.2.3" + }, + "arrow-1.2.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "80eb6582d8df75f1533434f45294e24e", + "name": "arrow", + "sha256": "0a9e5c48fb5fa4e4da57a3bf167e5a5206874a30354ced85d2fd9932c8257919", + "size": 144509, + "subdir": "linux-64", + "timestamp": 1666726941316, + "version": "1.2.3" + }, + "arrow-1.2.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e9ccc6946ab60e1ceec6747c190004e6", + "name": "arrow", + "sha256": "33fe2ba5983dc559cb6065b17549aa1b87db439e2914db5a8251483c9171f73e", + "size": 144347, + "subdir": "linux-64", + "timestamp": 1676588206741, + "version": "1.2.3" + }, + "arrow-cpp-0.11.0-py27h5c3f529_0.tar.bz2": { + "build": "py27h5c3f529_0", + "build_number": 0, + "depends": [ + "glog >=0.3.5,<0.3.6.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "b8e34258f5e72a628d9d4adc2dac4483", + "name": "arrow-cpp", + "sha256": "fb13a3cd84f93204834a2825a38a925b317f086fb7287a64e0ad27a852da8284", + "size": 6991993, + "subdir": "linux-64", + "timestamp": 1539967702856, + "version": "0.11.0" + }, + "arrow-cpp-0.11.0-py36h5c3f529_0.tar.bz2": { + "build": "py36h5c3f529_0", + "build_number": 0, + "depends": [ + "glog >=0.3.5,<0.3.6.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "de8456a017a8e9c01d4c2b2e1d2b8b56", + "name": "arrow-cpp", + "sha256": "4fe31dde8d6fd487dfc1a7f659bae6f844dd95b849557d5543a0591f0b17b4f3", + "size": 7007927, + "subdir": "linux-64", + "timestamp": 1539967743950, + "version": "0.11.0" + }, + "arrow-cpp-0.11.0-py37h5c3f529_0.tar.bz2": { + "build": "py37h5c3f529_0", + "build_number": 0, + "depends": [ + "glog >=0.3.5,<0.3.6.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "05b0b7ee46247a811caededab00c6da1", + "name": "arrow-cpp", + "sha256": "b4db8f5c077cbd7b35a80d9be79579308d7a0eecd5d233a1688d246b591f1db5", + "size": 6950409, + "subdir": "linux-64", + "timestamp": 1539967797477, + "version": "0.11.0" + }, + "arrow-cpp-0.11.1-py27h5c3f529_0.tar.bz2": { + "build": "py27h5c3f529_0", + "build_number": 0, + "depends": [ + "glog >=0.3.5,<0.3.6.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "85331b24b9e0c6a1a988bb2ec890556e", + "name": "arrow-cpp", + "sha256": "51b36902a207004fce19f960ad77f954bb3ee9b74658524af276c12a35a32cf5", + "size": 7002126, + "subdir": "linux-64", + "timestamp": 1540956814333, + "version": "0.11.1" + }, + "arrow-cpp-0.11.1-py27h5c3f529_1.tar.bz2": { + "build": "py27h5c3f529_1", + "build_number": 1, + "depends": [ + "glog >=0.3.5,<0.3.6.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "4b39c6bcdd7ecaafabcf3e7a307a5c4c", + "name": "arrow-cpp", + "sha256": "cd60e64cef666aaf4f8faa70875d88c3ad200795b9323484f9e985e84c91262f", + "size": 7039874, + "subdir": "linux-64", + "timestamp": 1559845998170, + "version": "0.11.1" + }, + "arrow-cpp-0.11.1-py36h5c3f529_0.tar.bz2": { + "build": "py36h5c3f529_0", + "build_number": 0, + "depends": [ + "glog >=0.3.5,<0.3.6.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "e1476f8690ed17be3594b5168b8db191", + "name": "arrow-cpp", + "sha256": "281a24be23db8eada8c493a58d36147cb993904571379aa2c2e031757abca8ac", + "size": 6989520, + "subdir": "linux-64", + "timestamp": 1540956676259, + "version": "0.11.1" + }, + "arrow-cpp-0.11.1-py36h5c3f529_1.tar.bz2": { + "build": "py36h5c3f529_1", + "build_number": 1, + "depends": [ + "glog >=0.3.5,<0.3.6.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "923e92785dc2bd29b6498204746fe309", + "name": "arrow-cpp", + "sha256": "f03fda48d931ced30b4810dad1d1192270359b72735a75dd4d7d02fe8a9a2af5", + "size": 7041902, + "subdir": "linux-64", + "timestamp": 1559846008443, + "version": "0.11.1" + }, + "arrow-cpp-0.11.1-py37h5c3f529_0.tar.bz2": { + "build": "py37h5c3f529_0", + "build_number": 0, + "depends": [ + "glog >=0.3.5,<0.3.6.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "46f9246b1a337c7623223a840a922bac", + "name": "arrow-cpp", + "sha256": "981f9817f517e218ac6bb2c90b9752e9c875e033f5d4c644a2b27906c383cd2e", + "size": 6937216, + "subdir": "linux-64", + "timestamp": 1540956823016, + "version": "0.11.1" + }, + "arrow-cpp-0.11.1-py37h5c3f529_1.tar.bz2": { + "build": "py37h5c3f529_1", + "build_number": 1, + "depends": [ + "glog >=0.3.5,<0.3.6.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "dfc37288aa346ee525ce5bb604b6320d", + "name": "arrow-cpp", + "sha256": "393b918db796146a9f7ab5985cd45b25a460531eac518960af87ad142f9d998d", + "size": 7054396, + "subdir": "linux-64", + "timestamp": 1559845984569, + "version": "0.11.1" + }, + "arrow-cpp-0.13.0-py27h117bdfb_0.tar.bz2": { + "build": "py27h117bdfb_0", + "build_number": 0, + "depends": [ + "brotli", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.14,<2.0a0", + "python >=2.7,<2.8.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "b9986cc7b94d20bb5430f04d974e68cc", + "name": "arrow-cpp", + "sha256": "2c9b8134442c724c9038aa9bf752216fa7162f2b561be60e5d2d5b2e0ee0c9b1", + "size": 3671686, + "subdir": "linux-64", + "timestamp": 1567110131307, + "version": "0.13.0" + }, + "arrow-cpp-0.13.0-py36h117bdfb_0.tar.bz2": { + "build": "py36h117bdfb_0", + "build_number": 0, + "depends": [ + "brotli", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.14,<2.0a0", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "788a8cbafbae6a9c8c0c6fc02d31df32", + "name": "arrow-cpp", + "sha256": "aed904f1f5b4c3a6311579c7d3a22d127f61d2b8576036f86b6ea9a7389ed45b", + "size": 3669646, + "subdir": "linux-64", + "timestamp": 1567110229267, + "version": "0.13.0" + }, + "arrow-cpp-0.13.0-py37h117bdfb_0.tar.bz2": { + "build": "py37h117bdfb_0", + "build_number": 0, + "depends": [ + "brotli", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.14,<2.0a0", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "4029ca51c63f4f1375c00892fbcd02d2", + "name": "arrow-cpp", + "sha256": "e305e14ebaa334cd89a674b33938804aaa14cbe4e3a3d957f5399a1cbbf4ce45", + "size": 3669652, + "subdir": "linux-64", + "timestamp": 1567110371697, + "version": "0.13.0" + }, + "arrow-cpp-0.13.0-py38h117bdfb_0.tar.bz2": { + "build": "py38h117bdfb_0", + "build_number": 0, + "depends": [ + "brotli", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.14,<2.0a0", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "803dddde4b7944a8556605757916732b", + "name": "arrow-cpp", + "sha256": "657eb7b47d39ecd2b999325200cf236cb57cef073994a76d2a6a9da83af0b678", + "size": 3682876, + "subdir": "linux-64", + "timestamp": 1574092470347, + "version": "0.13.0" + }, + "arrow-cpp-0.15.1-py36h248a92f_5.tar.bz2": { + "build": "py36h248a92f_5", + "build_number": 5, + "depends": [ + "boost-cpp", + "brotli", + "bzip2 >=1.0.8,<2.0a0", + "c-ares", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libboost >=1.71.0,<1.71.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11,<2.0a0", + "openssl", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "uriparser", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "9b39b2206a63899410483328fd26e294", + "name": "arrow-cpp", + "sha256": "34785a3f8e59b34929b167f103b0013931358c8e256b3274174c6669739285b9", + "size": 7169977, + "subdir": "linux-64", + "timestamp": 1580504282119, + "version": "0.15.1" + }, + "arrow-cpp-0.15.1-py36h7cd5009_5.tar.bz2": { + "build": "py36h7cd5009_5", + "build_number": 5, + "depends": [ + "boost-cpp", + "brotli", + "bzip2 >=1.0.8,<2.0a0", + "c-ares", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libboost >=1.71.0,<1.71.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11,<2.0a0", + "openssl", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "uriparser", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "68bacb8361885992d9c0854aa11a506f", + "name": "arrow-cpp", + "sha256": "a53516de3bdd692117105538ddb6199affe14c120fcee0aa8458ee42bd7d20d2", + "size": 7187238, + "subdir": "linux-64", + "timestamp": 1582236502057, + "version": "0.15.1" + }, + "arrow-cpp-0.15.1-py36hfa00764_6.tar.bz2": { + "build": "py36hfa00764_6", + "build_number": 6, + "depends": [ + "boost-cpp", + "brotli", + "bzip2 >=1.0.8,<2.0a0", + "c-ares", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11,<2.0a0", + "openssl", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "uriparser", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "d04d8642fe716a16533741c7d844fd3c", + "name": "arrow-cpp", + "sha256": "2700bddd3ab664296ed2bec956d4f0ec71b234ccae9e01d163fee0ef1117ad5c", + "size": 7164637, + "subdir": "linux-64", + "timestamp": 1583165501727, + "version": "0.15.1" + }, + "arrow-cpp-0.15.1-py37h248a92f_5.tar.bz2": { + "build": "py37h248a92f_5", + "build_number": 5, + "depends": [ + "boost-cpp", + "brotli", + "bzip2 >=1.0.8,<2.0a0", + "c-ares", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libboost >=1.71.0,<1.71.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11,<2.0a0", + "openssl", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "uriparser", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "990bf19aef597e120827f6b29c380565", + "name": "arrow-cpp", + "sha256": "b3d6c9d07ff617c5072faae8b88f93edf43c962caf2c6e7ade8fabf0bc4eefba", + "size": 7178588, + "subdir": "linux-64", + "timestamp": 1580504130319, + "version": "0.15.1" + }, + "arrow-cpp-0.15.1-py37h7cd5009_5.tar.bz2": { + "build": "py37h7cd5009_5", + "build_number": 5, + "depends": [ + "boost-cpp", + "brotli", + "bzip2 >=1.0.8,<2.0a0", + "c-ares", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libboost >=1.71.0,<1.71.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11,<2.0a0", + "openssl", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "uriparser", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "1f253349ba6b730306fb93b217fe4544", + "name": "arrow-cpp", + "sha256": "c6c7a64531fa4545ed33f9a40f5e81c7bb71304331f78839eaf8281d026f1532", + "size": 7193860, + "subdir": "linux-64", + "timestamp": 1582236797441, + "version": "0.15.1" + }, + "arrow-cpp-0.15.1-py37hfa00764_6.tar.bz2": { + "build": "py37hfa00764_6", + "build_number": 6, + "depends": [ + "boost-cpp", + "brotli", + "bzip2 >=1.0.8,<2.0a0", + "c-ares", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11,<2.0a0", + "openssl", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "uriparser", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "0073b0885127713014255fca470f157b", + "name": "arrow-cpp", + "sha256": "0a58a2c71557e181c3ee526c7ef79340bd781edb0273e38bf22f66d127ca392d", + "size": 7190214, + "subdir": "linux-64", + "timestamp": 1583165495260, + "version": "0.15.1" + }, + "arrow-cpp-0.15.1-py38h248a92f_5.tar.bz2": { + "build": "py38h248a92f_5", + "build_number": 5, + "depends": [ + "boost-cpp", + "brotli", + "bzip2 >=1.0.8,<2.0a0", + "c-ares", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libboost >=1.71.0,<1.71.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11,<2.0a0", + "openssl", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "uriparser", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "d5f04bb46ebea5c1d56493c9c204eeaa", + "name": "arrow-cpp", + "sha256": "789b4a2fae321a57806a483eebf9409fa666097d175833c702fcfc310bba8233", + "size": 7208513, + "subdir": "linux-64", + "timestamp": 1580504226514, + "version": "0.15.1" + }, + "arrow-cpp-0.15.1-py38h7cd5009_5.tar.bz2": { + "build": "py38h7cd5009_5", + "build_number": 5, + "depends": [ + "boost-cpp", + "brotli", + "bzip2 >=1.0.8,<2.0a0", + "c-ares", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libboost >=1.71.0,<1.71.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11,<2.0a0", + "openssl", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "uriparser", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "148374a6a2a80b3ec52fa82f1df75923", + "name": "arrow-cpp", + "sha256": "f9cc18deb09ebdfa51d285c7eaf9955744a5c38b8cf5116950e28e5339135b03", + "size": 7215151, + "subdir": "linux-64", + "timestamp": 1582236472370, + "version": "0.15.1" + }, + "arrow-cpp-0.15.1-py38hfa00764_6.tar.bz2": { + "build": "py38hfa00764_6", + "build_number": 6, + "depends": [ + "boost-cpp", + "brotli", + "bzip2 >=1.0.8,<2.0a0", + "c-ares", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11,<2.0a0", + "openssl", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "uriparser", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "3e962bf3fafb99df021592db26caaa85", + "name": "arrow-cpp", + "sha256": "5f4d43c24949173b5a43c2b5327cc8f12bed564f5789e433fc929622d286d3b2", + "size": 7208250, + "subdir": "linux-64", + "timestamp": 1583165493860, + "version": "0.15.1" + }, + "arrow-cpp-0.9.0-py27h165c0fa_6.tar.bz2": { + "build": "py27h165c0fa_6", + "build_number": 6, + "depends": [ + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "8b2c1c1cc37255ffc79867035999e738", + "name": "arrow-cpp", + "sha256": "39d9d19dfb98e30652c09e5b0298cb1a0a6ba5a8b8d4ff21e07b24bc0e13c44e", + "size": 5581645, + "subdir": "linux-64", + "timestamp": 1529459519289, + "version": "0.9.0" + }, + "arrow-cpp-0.9.0-py27h165c0fa_7.tar.bz2": { + "build": "py27h165c0fa_7", + "build_number": 7, + "depends": [ + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "eda390c5eb31eaa2328e914cb6a0b476", + "name": "arrow-cpp", + "sha256": "5888a46160b0617c867ebc6599a5a39638983134d85de79d6934fe25fe506af8", + "size": 5631928, + "subdir": "linux-64", + "timestamp": 1529509448786, + "version": "0.9.0" + }, + "arrow-cpp-0.9.0-py35h165c0fa_6.tar.bz2": { + "build": "py35h165c0fa_6", + "build_number": 6, + "depends": [ + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "9fdcbf0ba247b449db029403e7e2eb5a", + "name": "arrow-cpp", + "sha256": "820cf3216fd8f935f201fb5be07fa23b5719bde61c059842ce187db406a676d9", + "size": 5580646, + "subdir": "linux-64", + "timestamp": 1529459307601, + "version": "0.9.0" + }, + "arrow-cpp-0.9.0-py35h165c0fa_7.tar.bz2": { + "build": "py35h165c0fa_7", + "build_number": 7, + "depends": [ + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "f1504bb6e12ee8f31ea712eb23fd9897", + "name": "arrow-cpp", + "sha256": "cc70b52efc7e4985b300b8b215d7c935973b46f2cb2fc3278b79bc26d89be993", + "size": 5631695, + "subdir": "linux-64", + "timestamp": 1529509358071, + "version": "0.9.0" + }, + "arrow-cpp-0.9.0-py36h165c0fa_6.tar.bz2": { + "build": "py36h165c0fa_6", + "build_number": 6, + "depends": [ + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "f8f4bab92975729e99963fec698ef95c", + "name": "arrow-cpp", + "sha256": "db6c97e600e7a331c98bb75d8bad557ce53972b59504ecd4bb7bb9ec32e63aec", + "size": 5578690, + "subdir": "linux-64", + "timestamp": 1529459515154, + "version": "0.9.0" + }, + "arrow-cpp-0.9.0-py36h165c0fa_7.tar.bz2": { + "build": "py36h165c0fa_7", + "build_number": 7, + "depends": [ + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "d7c460f47667bdeca0e0f207a7773438", + "name": "arrow-cpp", + "sha256": "6b722f4575d6b16a6b928252ed6cad30bd6242846bd7fe2e44b7c19ae254765e", + "size": 5630914, + "subdir": "linux-64", + "timestamp": 1529509443411, + "version": "0.9.0" + }, + "arrow-cpp-10.0.1-py310h7516544_0.tar.bz2": { + "build": "py310h7516544_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.5.0,<0.6.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "openssl >=1.1.1t,<1.1.2a", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.10,<3.11.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "12452c4f650fe478890a1dd44c9144b3", + "name": "arrow-cpp", + "sha256": "755f5dc78328131d3b0acc663b167fbfa6bd90bef49b9c8759d0e485f76afca5", + "size": 11424176, + "subdir": "linux-64", + "timestamp": 1680127369757, + "version": "10.0.1" + }, + "arrow-cpp-10.0.1-py311ha0d4687_0.tar.bz2": { + "build": "py311ha0d4687_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.5.0,<0.6.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "openssl >=1.1.1t,<1.1.2a", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.11,<3.12.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "26c3a445b3f9a5f7c0881815b945e168", + "name": "arrow-cpp", + "sha256": "59519eb143a77ca6a0e1a6556c8806b65fb24580a690b5ada5b02529f03c3d86", + "size": 11424174, + "subdir": "linux-64", + "timestamp": 1680128491333, + "version": "10.0.1" + }, + "arrow-cpp-10.0.1-py38h613000e_0.tar.bz2": { + "build": "py38h613000e_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.5.0,<0.6.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "openssl >=1.1.1t,<1.1.2a", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.8,<3.9.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "16f5b2be11f11583bc50b239dd967960", + "name": "arrow-cpp", + "sha256": "13441892e4a27b600f2a6b402b01e83c680bbdf6a095e779c7b30589f6c8fc55", + "size": 11424678, + "subdir": "linux-64", + "timestamp": 1680129618662, + "version": "10.0.1" + }, + "arrow-cpp-10.0.1-py39h613000e_0.tar.bz2": { + "build": "py39h613000e_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.5.0,<0.6.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "openssl >=1.1.1t,<1.1.2a", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.9,<3.10.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "014dcd27cfe0e5e6aab73641fcf2d11d", + "name": "arrow-cpp", + "sha256": "b56ff57146c6a313d5f549b32abacc76a4a882c3c0849c48b72104a2bd8e46ad", + "size": 11424958, + "subdir": "linux-64", + "timestamp": 1680130747308, + "version": "10.0.1" + }, + "arrow-cpp-2.0.0-py36hced866c_0.tar.bz2": { + "build": "py36hced866c_0", + "build_number": 0, + "depends": [ + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "c5beebf262978a97b45b6495f8e44936", + "name": "arrow-cpp", + "sha256": "d89a15dbe676bfa06fb460b8cb9deb82b57a691166dfb53e16aba4eff565670e", + "size": 7843155, + "subdir": "linux-64", + "timestamp": 1612017629716, + "version": "2.0.0" + }, + "arrow-cpp-2.0.0-py37hced866c_0.tar.bz2": { + "build": "py37hced866c_0", + "build_number": 0, + "depends": [ + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "e01e10cfba0693b6283522ae0f4b731a", + "name": "arrow-cpp", + "sha256": "d42a63895d67d8557fb306249efb665f3b658bd974f15ca65c2003129d97e498", + "size": 7813790, + "subdir": "linux-64", + "timestamp": 1612017570014, + "version": "2.0.0" + }, + "arrow-cpp-2.0.0-py38hced866c_0.tar.bz2": { + "build": "py38hced866c_0", + "build_number": 0, + "depends": [ + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "ca57b03d8973d30d722acfc2313b926f", + "name": "arrow-cpp", + "sha256": "26ad2000b8d66257d1554817dad95cc616ae112f5ab8cc2911a5714f095a5f64", + "size": 7819522, + "subdir": "linux-64", + "timestamp": 1612017618265, + "version": "2.0.0" + }, + "arrow-cpp-2.0.0-py39hced866c_0.tar.bz2": { + "build": "py39hced866c_0", + "build_number": 0, + "depends": [ + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.9,<3.10.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "babd165a3aefc94df81ac9c3b778e737", + "name": "arrow-cpp", + "sha256": "039745bc8ee6225efe35b5d9e13e05ad7e847117f6213f9c3cebaf317f33418a", + "size": 7824840, + "subdir": "linux-64", + "timestamp": 1612017551376, + "version": "2.0.0" + }, + "arrow-cpp-3.0.0-py36h6b21186_4.tar.bz2": { + "build": "py36h6b21186_4", + "build_number": 4, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.5.0", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "libthrift >=0.14.2,<0.14.3.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1l,<1.1.2a", + "orc >=1.6.9,<1.6.10.0a0", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "f5aed64735ac4831b68be8f9f29c8eb5", + "name": "arrow-cpp", + "sha256": "330e626ff013770c6246fa00ec831b79de9f7f9ab6627ea2b2eb49918e3a9657", + "size": 8905495, + "subdir": "linux-64", + "timestamp": 1632947201175, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py36hced866c_0.tar.bz2": { + "build": "py36hced866c_0", + "build_number": 0, + "depends": [ + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "261614e23e4f7f97a9ced3269f83711c", + "name": "arrow-cpp", + "sha256": "cc6561bc11a367ea7b3758eba66ecd5756df201918b5dd2463e7ae09046be606", + "size": 8159261, + "subdir": "linux-64", + "timestamp": 1612106232014, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py36hced866c_1.tar.bz2": { + "build": "py36hced866c_1", + "build_number": 1, + "depends": [ + "aws-sdk-cpp >=1.8.133,<1.8.134.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "3fc21bfdb60bdb339292c5dca6c8c46c", + "name": "arrow-cpp", + "sha256": "ac7ab65efe789cff921b5560fb678170503ee4bc6a231af99e0b7d2fb7ca6e12", + "size": 8261026, + "subdir": "linux-64", + "timestamp": 1612957969429, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py36hced866c_2.tar.bz2": { + "build": "py36hced866c_2", + "build_number": 2, + "depends": [ + "aws-sdk-cpp >=1.8.133,<1.8.134.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "290136d1673896913993a9e890ee684d", + "name": "arrow-cpp", + "sha256": "c414001fe58fd62df366cb565466948dea589aa6d8cc8b40a0ec616e556f5dd8", + "size": 8291705, + "subdir": "linux-64", + "timestamp": 1613148162745, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py36hced866c_3.tar.bz2": { + "build": "py36hced866c_3", + "build_number": 3, + "depends": [ + "aws-sdk-cpp >=1.8.156,<1.8.157.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1j,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "f4c09aac9c2dd1cf7feb4171a39757b6", + "name": "arrow-cpp", + "sha256": "c4d69c53011de93e3af2dd0d08c4788cd1c8cf460f4f23410cb989ed4a240c9f", + "size": 8296917, + "subdir": "linux-64", + "timestamp": 1615274475638, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py37h6b21186_4.tar.bz2": { + "build": "py37h6b21186_4", + "build_number": 4, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.5.0", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "libthrift >=0.14.2,<0.14.3.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1l,<1.1.2a", + "orc >=1.6.9,<1.6.10.0a0", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "f4c93ef30e0be1bb7128e265828127ab", + "name": "arrow-cpp", + "sha256": "1191075874f603283b275f2f00f2b1323f5f7de315bebeaf265cb5e1d6297925", + "size": 8908254, + "subdir": "linux-64", + "timestamp": 1632936756667, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py37hced866c_0.tar.bz2": { + "build": "py37hced866c_0", + "build_number": 0, + "depends": [ + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "9ad5d2a16ad8ab3f48a2f85c3145600f", + "name": "arrow-cpp", + "sha256": "7c4686c27921e83f5ae93f60734d69b3c369f1b1b4d8c364fd6aa3aca0edbe6b", + "size": 8148031, + "subdir": "linux-64", + "timestamp": 1612106226070, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py37hced866c_1.tar.bz2": { + "build": "py37hced866c_1", + "build_number": 1, + "depends": [ + "aws-sdk-cpp >=1.8.133,<1.8.134.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "5f33b786d908d6516800f8a6a399bada", + "name": "arrow-cpp", + "sha256": "6a472a8eb9033b07c4f9941d5d06510cd446a9e026cd27eae9102b7ad93c226b", + "size": 8290645, + "subdir": "linux-64", + "timestamp": 1612958256465, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py37hced866c_2.tar.bz2": { + "build": "py37hced866c_2", + "build_number": 2, + "depends": [ + "aws-sdk-cpp >=1.8.133,<1.8.134.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "1c9175f28ffaf01c03506fc30b1dc402", + "name": "arrow-cpp", + "sha256": "9f8296e7c52f4a39cbf4e77490f3321bbc679969ec51c0671cddb289e32e8f2a", + "size": 8269563, + "subdir": "linux-64", + "timestamp": 1613147928025, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py37hced866c_3.tar.bz2": { + "build": "py37hced866c_3", + "build_number": 3, + "depends": [ + "aws-sdk-cpp >=1.8.156,<1.8.157.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1j,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "ea35ee16b152920e608dd926ae5691c3", + "name": "arrow-cpp", + "sha256": "7b4063675afbb839bcc424a73a535f1d563da6625f59db071f85b443ae1486b5", + "size": 8296176, + "subdir": "linux-64", + "timestamp": 1615272907886, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py38h6b21186_4.tar.bz2": { + "build": "py38h6b21186_4", + "build_number": 4, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.5.0", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "libthrift >=0.14.2,<0.14.3.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1l,<1.1.2a", + "orc >=1.6.9,<1.6.10.0a0", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "f0b8462824bfb215580b2cf71cb667fe", + "name": "arrow-cpp", + "sha256": "aec4785d0f2e69279a081ad06edd168e2c5e907a23f3b7bbf531daeef010b1b2", + "size": 8915068, + "subdir": "linux-64", + "timestamp": 1632947199850, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py38hced866c_0.tar.bz2": { + "build": "py38hced866c_0", + "build_number": 0, + "depends": [ + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "33724b2fd98dd45e2eade88ec2e1d846", + "name": "arrow-cpp", + "sha256": "b3414008b88ad3bb5ff7cc67894a9b5b90dc857b4fe69174828aaee05d69495d", + "size": 8145877, + "subdir": "linux-64", + "timestamp": 1612106336112, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py38hced866c_1.tar.bz2": { + "build": "py38hced866c_1", + "build_number": 1, + "depends": [ + "aws-sdk-cpp >=1.8.133,<1.8.134.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "85588b2216d1fbeae2c8ddc7733eb737", + "name": "arrow-cpp", + "sha256": "9f42e95b24e3dc6110655a70167681c93b5c23a8963dfc5367f9d3f9bdbd1d85", + "size": 8303960, + "subdir": "linux-64", + "timestamp": 1612957745121, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py38hced866c_2.tar.bz2": { + "build": "py38hced866c_2", + "build_number": 2, + "depends": [ + "aws-sdk-cpp >=1.8.133,<1.8.134.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "e5e7c32ac573786e169010c223c82742", + "name": "arrow-cpp", + "sha256": "aff0ce28a3396cc0205bce530391a0900d864f532c93bbb2dae8b17e48e68628", + "size": 8291703, + "subdir": "linux-64", + "timestamp": 1613147656598, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py38hced866c_3.tar.bz2": { + "build": "py38hced866c_3", + "build_number": 3, + "depends": [ + "aws-sdk-cpp >=1.8.156,<1.8.157.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1j,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "a787fbf4175ceec20997fbbc32a51077", + "name": "arrow-cpp", + "sha256": "c2e57d84c348baf67ae5f28129b232688570ddd8f9e92623747dc68130d289c1", + "size": 8292688, + "subdir": "linux-64", + "timestamp": 1615274084938, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py39h6b21186_4.tar.bz2": { + "build": "py39h6b21186_4", + "build_number": 4, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.5.0", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "libthrift >=0.14.2,<0.14.3.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1l,<1.1.2a", + "orc >=1.6.9,<1.6.10.0a0", + "python >=3.9,<3.10.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "c2fe922ddce345077c047ce8e6ea3be6", + "name": "arrow-cpp", + "sha256": "de76b2a404059361a5bafa9d155829c88d349a856aec347607e8d41b67c81410", + "size": 8914776, + "subdir": "linux-64", + "timestamp": 1632947238091, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py39hced866c_0.tar.bz2": { + "build": "py39hced866c_0", + "build_number": 0, + "depends": [ + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.9,<3.10.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "2898593184c55af0ff02019cbf1b3b0f", + "name": "arrow-cpp", + "sha256": "cc7db5f05473ddb3f59d0c1f7cf6f1099cdc799227118511fa48f7819bb7256a", + "size": 8167145, + "subdir": "linux-64", + "timestamp": 1612106335127, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py39hced866c_1.tar.bz2": { + "build": "py39hced866c_1", + "build_number": 1, + "depends": [ + "aws-sdk-cpp >=1.8.133,<1.8.134.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.9,<3.10.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "98e5203aaf74d7e91fde2300371a626c", + "name": "arrow-cpp", + "sha256": "3833f201c3edcf68f3542ab03f241f25e3b56bed5008742bd34580f2bd8efd00", + "size": 8303798, + "subdir": "linux-64", + "timestamp": 1612958263853, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py39hced866c_2.tar.bz2": { + "build": "py39hced866c_2", + "build_number": 2, + "depends": [ + "aws-sdk-cpp >=1.8.133,<1.8.134.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.9,<3.10.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "ae4c0c9b26e3b22627b63482ab85ccb6", + "name": "arrow-cpp", + "sha256": "3f720f5622e5927e4f102ce1cfd2e5bafaf96d85f2201e2a294751bc184c2942", + "size": 8286605, + "subdir": "linux-64", + "timestamp": 1613148098530, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py39hced866c_3.tar.bz2": { + "build": "py39hced866c_3", + "build_number": 3, + "depends": [ + "aws-sdk-cpp >=1.8.156,<1.8.157.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1j,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.9,<3.10.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "2de2b7f0498b345aeea8a217b5517cec", + "name": "arrow-cpp", + "sha256": "c22845b46eb6e9af253220d0f46c3881acd76a5e9dcccb726a67770d7f276ebf", + "size": 8279106, + "subdir": "linux-64", + "timestamp": 1615274567424, + "version": "3.0.0" + }, + "arrow-cpp-4.0.1-py36hced866c_3.tar.bz2": { + "build": "py36hced866c_3", + "build_number": 3, + "depends": [ + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1k,<1.1.2a", + "orc >=1.6.7,<1.6.8.0a0", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a338c18a3fbc557deeeabcbf9c0a4488", + "name": "arrow-cpp", + "sha256": "5fbb520e2cd23a8e369861205b0680232f2ad310fca14c9d0a02d60001c48014", + "size": 8712965, + "subdir": "linux-64", + "timestamp": 1622567876795, + "version": "4.0.1" + }, + "arrow-cpp-4.0.1-py37hced866c_3.tar.bz2": { + "build": "py37hced866c_3", + "build_number": 3, + "depends": [ + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1k,<1.1.2a", + "orc >=1.6.7,<1.6.8.0a0", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5bf3a1c09c802613f427e83b959288a9", + "name": "arrow-cpp", + "sha256": "fc42b133634bfd964e07536a29030c0bccbe9374ec6ae27b6dbe3c4bfe3011ae", + "size": 8718569, + "subdir": "linux-64", + "timestamp": 1622568407994, + "version": "4.0.1" + }, + "arrow-cpp-4.0.1-py38hced866c_3.tar.bz2": { + "build": "py38hced866c_3", + "build_number": 3, + "depends": [ + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1k,<1.1.2a", + "orc >=1.6.7,<1.6.8.0a0", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3d0d127e914827662f83ec94c3171ff7", + "name": "arrow-cpp", + "sha256": "ecbaa1c83b0b862d4ed773fe54c0da6ed9405283a251eadfee671c96db00e5b4", + "size": 8738938, + "subdir": "linux-64", + "timestamp": 1622563173502, + "version": "4.0.1" + }, + "arrow-cpp-4.0.1-py39hced866c_3.tar.bz2": { + "build": "py39hced866c_3", + "build_number": 3, + "depends": [ + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1k,<1.1.2a", + "orc >=1.6.7,<1.6.8.0a0", + "python >=3.9,<3.10.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "84f905a0382087dc10f6c2b20f76af00", + "name": "arrow-cpp", + "sha256": "c1c4abd80e522ae40f497b7b1a29e0172015f8b138cfeca6c3f65a3c73be6f8b", + "size": 8736228, + "subdir": "linux-64", + "timestamp": 1622568430312, + "version": "4.0.1" + }, + "arrow-cpp-8.0.0-py310h3098874_0.tar.bz2": { + "build": "py310h3098874_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.10,<3.11.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9ed95731c50d15c1bf8e8f5946d7c3c5", + "name": "arrow-cpp", + "sha256": "a2d73bb25231d85795d9f05fb4f81e6588a56c7b817b9dc78736dce4ddf39e0b", + "size": 12246321, + "subdir": "linux-64", + "timestamp": 1657132836159, + "version": "8.0.0" + }, + "arrow-cpp-8.0.0-py310h3098874_1.tar.bz2": { + "build": "py310h3098874_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.10,<3.11.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zlib", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4ac4fa61762d827fa8fb93932e200041", + "name": "arrow-cpp", + "sha256": "64508a288d38bbcb82f0642f9f3b1adb7fdceca7927e5471d1aa557280ec1b2b", + "size": 12252072, + "subdir": "linux-64", + "timestamp": 1676606956695, + "version": "8.0.0" + }, + "arrow-cpp-8.0.0-py311hf0d91b4_0.tar.bz2": { + "build": "py311hf0d91b4_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.11,<3.12.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "83f21441a253096e3c8fa7a557d2b955", + "name": "arrow-cpp", + "sha256": "1c8310705ff284d457baeed905f1b62cf745a8a97e72430022a1e6b1d743becd", + "size": 12143661, + "subdir": "linux-64", + "timestamp": 1676829996079, + "version": "8.0.0" + }, + "arrow-cpp-8.0.0-py311hf0d91b4_1.tar.bz2": { + "build": "py311hf0d91b4_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.11,<3.12.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zlib", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b5c62961d10dd146eea1d5c7d3e968a7", + "name": "arrow-cpp", + "sha256": "8eb8fe3e52a1ffe746a3702c893e8658ed9d59786841458a762ba25e39a902c5", + "size": 12248789, + "subdir": "linux-64", + "timestamp": 1679335203714, + "version": "8.0.0" + }, + "arrow-cpp-8.0.0-py37h60b952e_0.tar.bz2": { + "build": "py37h60b952e_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.7,<3.8.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f0fa61cf794673ce662d445873dda567", + "name": "arrow-cpp", + "sha256": "a67d3d79a59f08e37586ec149bcdc9d778d8620c7574ea69939d5d11b1c4d943", + "size": 12244611, + "subdir": "linux-64", + "timestamp": 1657133586737, + "version": "8.0.0" + }, + "arrow-cpp-8.0.0-py37h60b952e_1.tar.bz2": { + "build": "py37h60b952e_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.7,<3.8.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zlib", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c53d2f7d775774682d0d02d3ba87ff81", + "name": "arrow-cpp", + "sha256": "d494036cc75ac9ca5c3cc1ee05c640a85bcbb1d5c5ab488beacd7174de7f75ed", + "size": 12251336, + "subdir": "linux-64", + "timestamp": 1676605795255, + "version": "8.0.0" + }, + "arrow-cpp-8.0.0-py38h60b952e_0.tar.bz2": { + "build": "py38h60b952e_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.8,<3.9.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e92982db21353b121aa7c2325066bfaf", + "name": "arrow-cpp", + "sha256": "d13dd228916d133b4e1cb18892783cdd1cfa6cdd3ce3760af79f33d1a8a6ce99", + "size": 12245328, + "subdir": "linux-64", + "timestamp": 1657134336925, + "version": "8.0.0" + }, + "arrow-cpp-8.0.0-py38h60b952e_1.tar.bz2": { + "build": "py38h60b952e_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.8,<3.9.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zlib", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9727ce9f2634ce0645713955b7ee2c6c", + "name": "arrow-cpp", + "sha256": "3d3ea8226d25f8e6a510a8279d4412ae0a8fc2d2a2ca2f2ef4f686e1442deb04", + "size": 12250496, + "subdir": "linux-64", + "timestamp": 1676608116854, + "version": "8.0.0" + }, + "arrow-cpp-8.0.0-py39h60b952e_0.tar.bz2": { + "build": "py39h60b952e_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.9,<3.10.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ffd7d4340f32ea5f34fd4c9a787fb17e", + "name": "arrow-cpp", + "sha256": "905d73097dc23836db4533a4c882b15db067f1672dda3c2fbb60454fc8280d78", + "size": 12245573, + "subdir": "linux-64", + "timestamp": 1657132089745, + "version": "8.0.0" + }, + "arrow-cpp-8.0.0-py39h60b952e_1.tar.bz2": { + "build": "py39h60b952e_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.9,<3.10.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zlib", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "19a39d0fa8e34bae2ef30423ec1d871d", + "name": "arrow-cpp", + "sha256": "f8964fc92c8ea94d1818f9e40212754c6c74c89e86d61352841ff9d25cd9ce75", + "size": 12249752, + "subdir": "linux-64", + "timestamp": 1676604633237, + "version": "8.0.0" + }, + "asgiref-3.5.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20c890deff05dd0782a7fc5c70544f36", + "name": "asgiref", + "sha256": "ee3dfde472c761e8e4588b50e21a4026508659e588d4b4715af599521f5c35ff", + "size": 37254, + "subdir": "linux-64", + "timestamp": 1661287637684, + "version": "3.5.2" + }, + "asgiref-3.5.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c1e3d9e2e9c4f6bac7248ea93ec8f8d1", + "name": "asgiref", + "sha256": "2d291df2c6ff234e579a6b5dead590fd8053f159664103155d4f688767bb9d37", + "size": 47514, + "subdir": "linux-64", + "timestamp": 1676843211900, + "version": "3.5.2" + }, + "asgiref-3.5.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c3a5f44681feb89d2ee01c464d0542df", + "name": "asgiref", + "sha256": "96f98708c5e719d9c7ab60a7252b322e2a2edb2201593c3410e0a827065e1f81", + "size": 36489, + "subdir": "linux-64", + "timestamp": 1661287663867, + "version": "3.5.2" + }, + "asgiref-3.5.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0b717bd335351cc78b84433554f4029c", + "name": "asgiref", + "sha256": "8c02f0cf5649cd7b05b2868db8df9b9f8120c9eb29a36f7273dc2d010c4fda41", + "size": 36613, + "subdir": "linux-64", + "timestamp": 1661287565794, + "version": "3.5.2" + }, + "asgiref-3.5.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6854c5485598d4f2a795c7072a54d763", + "name": "asgiref", + "sha256": "e28e0aeb0304fbd122301360aac0082b0b75a59952ab9877c542b5d066d9ff60", + "size": 36919, + "subdir": "linux-64", + "timestamp": 1661287596785, + "version": "3.5.2" + }, + "asn1crypto-0.22.0-py27h94ebe91_1.tar.bz2": { + "build": "py27h94ebe91_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "baa8b7230f9d4d6f3446c4fd13cd1ebf", + "name": "asn1crypto", + "sha256": "9cd074d719e92e022d2a3cb9d42a496874bdd168d3eb76fb391ee3d3d4e57e40", + "size": 149118, + "subdir": "linux-64", + "timestamp": 1505691748075, + "version": "0.22.0" + }, + "asn1crypto-0.22.0-py35h0d675fe_1.tar.bz2": { + "build": "py35h0d675fe_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "20f8dc3894fb495d4024a61c92e95ce1", + "name": "asn1crypto", + "sha256": "89228de3505ecadb4196f23153201e8ed37a49218584d9a54870e545d1870a44", + "size": 153172, + "subdir": "linux-64", + "timestamp": 1505691760988, + "version": "0.22.0" + }, + "asn1crypto-0.22.0-py36h265ca7c_1.tar.bz2": { + "build": "py36h265ca7c_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d248e43bc478fb3b9bf01f3c67d44a66", + "name": "asn1crypto", + "sha256": "c732f0334a5dcb50194e0ef54a3f9ae02cfde2c95e4a2c1488823ef1eed0f64b", + "size": 152073, + "subdir": "linux-64", + "timestamp": 1505691774144, + "version": "0.22.0" + }, + "asn1crypto-0.23.0-py27h7b0c810_0.tar.bz2": { + "build": "py27h7b0c810_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7b87e6e59688fd21539ec410ac439f95", + "name": "asn1crypto", + "sha256": "f8f6f7b33f9a9104f1c256aa00048fd88e01bfb80a20acaa293c26bb519bec9c", + "size": 153370, + "subdir": "linux-64", + "timestamp": 1511838836126, + "version": "0.23.0" + }, + "asn1crypto-0.23.0-py35h4ab26a5_0.tar.bz2": { + "build": "py35h4ab26a5_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "be13075c829362b9f43c4b78df9b6b30", + "name": "asn1crypto", + "sha256": "49c256e2d2eff424ca5cb6d6205b97fe02bdff143e32055324a4234d29e0fcc1", + "size": 155915, + "subdir": "linux-64", + "timestamp": 1511838842795, + "version": "0.23.0" + }, + "asn1crypto-0.23.0-py36h4639342_0.tar.bz2": { + "build": "py36h4639342_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4473dc475a27dc0bd0bb99e15625c591", + "name": "asn1crypto", + "sha256": "d2ce67319a290846a20c0956d932f7e13889380d4e6da25bf27de4b704655abd", + "size": 154970, + "subdir": "linux-64", + "timestamp": 1511838853469, + "version": "0.23.0" + }, + "asn1crypto-0.24.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f6ba95df21661c0646e251f3403189c3", + "name": "asn1crypto", + "sha256": "a6fd3374086c43816a02d6552ab78bc7b84f96ae1af0a9f31f99f018bbc04b0a", + "size": 158632, + "subdir": "linux-64", + "timestamp": 1515702537268, + "version": "0.24.0" + }, + "asn1crypto-0.24.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "f519351e81c86ca06a4d96203ce4560b", + "name": "asn1crypto", + "sha256": "35fe072ec51029892ae313ae3a4f62b2d2dbad99b57cb437bddc87c0f60202be", + "size": 159332, + "subdir": "linux-64", + "timestamp": 1515702654575, + "version": "0.24.0" + }, + "asn1crypto-0.24.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f65f5436ad8cc3774b684217d93fd9ec", + "name": "asn1crypto", + "sha256": "7c7d6226726604540a62fe609ea0d2cdad7826120f3850ed5320667ee8f202f2", + "size": 158340, + "subdir": "linux-64", + "timestamp": 1515702503934, + "version": "0.24.0" + }, + "asn1crypto-0.24.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ced805eaab8c4a59dd3837bf169d4f56", + "name": "asn1crypto", + "sha256": "83ba0fb920f282e2afc0faa61dbd40ad22770a63bd5a5fdfc6b69176d22ed034", + "size": 158114, + "subdir": "linux-64", + "timestamp": 1530695849202, + "version": "0.24.0" + }, + "asn1crypto-1.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "2db4bca66825a0efcbbc0267c573b56a", + "name": "asn1crypto", + "sha256": "0d0a9818901ec3e65f90221db0eaf95f3be9a259093d8692a7524ebda03fd5c5", + "size": 166706, + "subdir": "linux-64", + "timestamp": 1570463086473, + "version": "1.0.1" + }, + "asn1crypto-1.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "98ce7f6c403d9d38636aceb3aab18620", + "name": "asn1crypto", + "sha256": "957c48b16a7943fc7244f9b9d1641dc93c8443314cb43be88c86e29b14a060d0", + "size": 164680, + "subdir": "linux-64", + "timestamp": 1570463077759, + "version": "1.0.1" + }, + "asn1crypto-1.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b8192206995433ee891f6c8a6a432e08", + "name": "asn1crypto", + "sha256": "16b003c637c8cbf6e52b4d529afa3bee03c8787ae2997f8e8297ed243d974ea3", + "size": 164849, + "subdir": "linux-64", + "timestamp": 1570463088980, + "version": "1.0.1" + }, + "asn1crypto-1.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5b490554b793d2790eff4e0bc0388490", + "name": "asn1crypto", + "sha256": "c1eabc0da943b2be359c9aec78f6ce4bb8c9fcae39e12dde7f0ca34406a42e08", + "size": 167973, + "subdir": "linux-64", + "timestamp": 1571757139897, + "version": "1.2.0" + }, + "asn1crypto-1.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "60e9913456648c9be01d92c94f029982", + "name": "asn1crypto", + "sha256": "2ed3fd9fe4b8852d929a2860a0cc1be5a16c664e867790d502770b96b6589123", + "size": 167032, + "subdir": "linux-64", + "timestamp": 1642498959513, + "version": "1.2.0" + }, + "asn1crypto-1.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1b0be2d5483adc9400bbfd54826c7922", + "name": "asn1crypto", + "sha256": "2db1ac9bdc58384477feae18e408c36c21086c6d3adfadb4bed65f7f33399a1a", + "size": 165616, + "subdir": "linux-64", + "timestamp": 1571757153773, + "version": "1.2.0" + }, + "asn1crypto-1.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e650b32fcdc8dd8dbb6b7f46f9cd02be", + "name": "asn1crypto", + "sha256": "fc2eb3888c32957ba7bc6ac42e9d200e9386b5c57826b3167bac4da37862b97f", + "size": 165751, + "subdir": "linux-64", + "timestamp": 1571757136264, + "version": "1.2.0" + }, + "asn1crypto-1.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "5a0ca166c6f881ce1b73990c34be68e8", + "name": "asn1crypto", + "sha256": "0af6d093a9c980eccf319d8c368bef3c00a7a4344f3695a036ae547ccf5422e7", + "size": 162828, + "subdir": "linux-64", + "timestamp": 1572437739325, + "version": "1.2.0" + }, + "asn1crypto-1.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "045aa3cdc0946d6bec7bb2c2b9f7f98a", + "name": "asn1crypto", + "sha256": "516f11d5901e9d322db3fbf25787bc5458e7deae3b71f097e9831bd11df34fb5", + "size": 168227, + "subdir": "linux-64", + "timestamp": 1578427450649, + "version": "1.3.0" + }, + "asn1crypto-1.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ab947c01fa86dc61b3557c957a361531", + "name": "asn1crypto", + "sha256": "b2b0ff8c53fe1035677f0d30b1bce96947667b89e77a62c81c347f119950da62", + "size": 166474, + "subdir": "linux-64", + "timestamp": 1578427456613, + "version": "1.3.0" + }, + "asn1crypto-1.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ec6a30a2313781b3c71d5561d351b608", + "name": "asn1crypto", + "sha256": "427a82b9010d3878e4cda9ff3f328fbc6c70f45fc1c3dcd5064b49617acd87b2", + "size": 165950, + "subdir": "linux-64", + "timestamp": 1578427420462, + "version": "1.3.0" + }, + "asn1crypto-1.3.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "107d042e5f5cd5ef9e85a264b2d5b5e6", + "name": "asn1crypto", + "sha256": "24b31b947f0fffd30aaf6122ca44fd108e0bafc2c00ce2960c98eb367b5022d3", + "size": 162095, + "subdir": "linux-64", + "timestamp": 1594339154083, + "version": "1.3.0" + }, + "asn1crypto-1.3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "8f0e5f9d0add85fcce865e62c31bf28e", + "name": "asn1crypto", + "sha256": "778558bc80eedea45235d48fd3909f355243cc874eb407026ba97f55a40b1840", + "size": 166596, + "subdir": "linux-64", + "timestamp": 1578427459388, + "version": "1.3.0" + }, + "asn1crypto-1.5.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad32dbd5d54c2452579b971e6f8f2237", + "name": "asn1crypto", + "sha256": "2143aa31e6cb96d8f654d6088c1a385e137a8b5f4890f2447207179019439861", + "size": 168525, + "subdir": "linux-64", + "timestamp": 1652362734721, + "version": "1.5.1" + }, + "asn1crypto-1.5.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6fd7d605172add7a4c575c3363f65a8d", + "name": "asn1crypto", + "sha256": "4a5a859fb2e4c0d8d04c0ddfd8704945e8b006bd0ce444b7831eb037f3ef04e5", + "size": 223782, + "subdir": "linux-64", + "timestamp": 1676838987340, + "version": "1.5.1" + }, + "asn1crypto-1.5.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "700081f7054579c6acf9a772d93b804c", + "name": "asn1crypto", + "sha256": "dfaa1bad34737a4fa5cf114efba7ce152d88cc58247e7714021e5b5333acc4f7", + "size": 164862, + "subdir": "linux-64", + "timestamp": 1652362697562, + "version": "1.5.1" + }, + "asn1crypto-1.5.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be5d6511376ac8dd674bb4dc91ae398e", + "name": "asn1crypto", + "sha256": "1c21ae2d5744bb0ca38c447f1216d17449024f6e71744b1e4d03681bf002cd46", + "size": 165655, + "subdir": "linux-64", + "timestamp": 1652362672251, + "version": "1.5.1" + }, + "asn1crypto-1.5.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c59d54051c975a919fcdbcaed34db7c6", + "name": "asn1crypto", + "sha256": "2118eb2743d7876172a48fe31f8dc7b5ce1b0b413cba5d0fe667c0c8751358e9", + "size": 165881, + "subdir": "linux-64", + "timestamp": 1652362761112, + "version": "1.5.1" + }, + "assimp-5.0.1-h01202fb_6.tar.bz2": { + "build": "h01202fb_6", + "build_number": 6, + "depends": [ + "boost-cpp", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Modified BSD", + "license_family": "BSD", + "md5": "97b8e3f71c1aa237e9ec99d6cf44f28f", + "name": "assimp", + "sha256": "e5bdc6ce4532d7234cff7583d3771e5202449a685a225c86966d0b6df9f88fe0", + "size": 4494459, + "subdir": "linux-64", + "timestamp": 1631694843607, + "version": "5.0.1" + }, + "astor-0.6.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "133ebbfcd60964adb34d758fd863e34c", + "name": "astor", + "sha256": "832e1ea2b3f88c06a36e46815b071427fa93814bb83b2f5802df9a87f43abb67", + "size": 42378, + "subdir": "linux-64", + "timestamp": 1519944910897, + "version": "0.6.2" + }, + "astor-0.6.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "591bdf61e5cfe8cb35b2f9dfdba70549", + "name": "astor", + "sha256": "f34ad63bd4650db72f95c467483edf6012045e73dbf2f20b0afa83c75029af59", + "size": 42837, + "subdir": "linux-64", + "timestamp": 1530737866048, + "version": "0.6.2" + }, + "astor-0.6.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "75eeff523bea7415d325e900eb21efff", + "name": "astor", + "sha256": "45fd52103637afed4555e9541468a6ac12f05ea169074935640b464d5cecbdb3", + "size": 43543, + "subdir": "linux-64", + "timestamp": 1519944897880, + "version": "0.6.2" + }, + "astor-0.6.2-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7de09f78db43984cc9a82e206369303e", + "name": "astor", + "sha256": "6f59d7bdb9a4eaa1aa16e3ede40a11ed2853a93d2f4549417f86e7e69037c98b", + "size": 43922, + "subdir": "linux-64", + "timestamp": 1534352825921, + "version": "0.6.2" + }, + "astor-0.6.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "259f608ece287a467586c08623e59f7c", + "name": "astor", + "sha256": "fe7e122a6568ae94f49504f6c92d4c693e3b627cb1bc4fb31dd21c5c1b9d177b", + "size": 43405, + "subdir": "linux-64", + "timestamp": 1519944924716, + "version": "0.6.2" + }, + "astor-0.6.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d05fe7f0344658aa66af421f49895ec7", + "name": "astor", + "sha256": "1a15da772f41c1810f4fbf03400d4665ba581aae4763598d9938bb2252d91311", + "size": 43821, + "subdir": "linux-64", + "timestamp": 1530737845039, + "version": "0.6.2" + }, + "astor-0.6.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "21fa6dde3fa85e28b655859975832da5", + "name": "astor", + "sha256": "031cf6d3ebcc904fba48df43f8588c7409c0a987021f01a6d7ff1ca7f651d6b0", + "size": 43901, + "subdir": "linux-64", + "timestamp": 1530737887311, + "version": "0.6.2" + }, + "astor-0.7.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "937e2e2d73bcd0bbbee544ea055c9c1c", + "name": "astor", + "sha256": "dc63ab88a8f96b67fe20a17843d55bdf4fa5058f02caeecb2a1b126beee4d5a7", + "size": 43215, + "subdir": "linux-64", + "timestamp": 1532577518214, + "version": "0.7.1" + }, + "astor-0.7.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e108cc97d85aa583d23a5ea2fc8ee196", + "name": "astor", + "sha256": "7b311ec1755311366aa7215beee454109af6269422a0081538ebf4599b1c7808", + "size": 44467, + "subdir": "linux-64", + "timestamp": 1532577564363, + "version": "0.7.1" + }, + "astor-0.7.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b75503f6f6500938920341bcf1cb2125", + "name": "astor", + "sha256": "94821fa46993557b84d342a9765409bdafa4bca7762a0d60e8ed64cb7c1d092f", + "size": 44240, + "subdir": "linux-64", + "timestamp": 1532577486577, + "version": "0.7.1" + }, + "astor-0.7.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a0cec559f624527b295e7cabab1a98a2", + "name": "astor", + "sha256": "8199d27588e092ca92527bd16910c111a147ccf8d0365c834bcbaa959c22ec22", + "size": 44283, + "subdir": "linux-64", + "timestamp": 1532577566420, + "version": "0.7.1" + }, + "astor-0.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3b57835dcb98022e982ecda35418db4f", + "name": "astor", + "sha256": "201e144435bb798479ce2718de12eeb5884c135473cda08d2df6551212db98ca", + "size": 44895, + "subdir": "linux-64", + "timestamp": 1564694743781, + "version": "0.8.0" + }, + "astor-0.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "65037e5398de07983795ae49c0df7179", + "name": "astor", + "sha256": "a23f475f5585641a41ab0d25e04ea7ce7675e64350e1a8738c8380fcd4093b49", + "size": 45910, + "subdir": "linux-64", + "timestamp": 1564694383983, + "version": "0.8.0" + }, + "astor-0.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6f5388fff669934e2bd1b4708be6615b", + "name": "astor", + "sha256": "e9b322a56f3a4a37bb4c60470c98f8649c64a7b0ff4387f7dc7a00d70dcdeaab", + "size": 45932, + "subdir": "linux-64", + "timestamp": 1564694755303, + "version": "0.8.0" + }, + "astor-0.8.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "82d294ce888ce3a33172910b29066d64", + "name": "astor", + "sha256": "4bf1d4f02458df0d100cdbb192e75d107038bf8a036c9e712e05dd0e38dcb709", + "size": 45894, + "subdir": "linux-64", + "timestamp": 1640788313822, + "version": "0.8.1" + }, + "astor-0.8.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e01a575b7c8f58656c830eaeefc22f4c", + "name": "astor", + "sha256": "9f1bd0a946c0cfbe49efc4f6d6360d93d218e121c0a558f7e9b54828061f608d", + "size": 62196, + "subdir": "linux-64", + "timestamp": 1676846829744, + "version": "0.8.1" + }, + "astor-0.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ea97d26fee4ad63b86fb443781fd0445", + "name": "astor", + "sha256": "e44ab9621c6ae0131f3363e56b915d816fa5a7159d710a081a64c63471a13b5f", + "size": 46286, + "subdir": "linux-64", + "timestamp": 1597430670981, + "version": "0.8.1" + }, + "astor-0.8.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "99dc19ff3e381d006ec6308f85bf5271", + "name": "astor", + "sha256": "f41a88da00230151f30bf6cc8c3846c083888514ec0744e9df131374f2681b98", + "size": 46370, + "subdir": "linux-64", + "timestamp": 1611675367996, + "version": "0.8.1" + }, + "astor-0.8.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "386b887298b142aa4fba0a1a2614201c", + "name": "astor", + "sha256": "e7f31b3aa089108d03cc6052808c603650d823fce346a173f137f2dc6c021135", + "size": 46318, + "subdir": "linux-64", + "timestamp": 1597430671659, + "version": "0.8.1" + }, + "astor-0.8.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1de07d38a4ca884413506bcc0f43c611", + "name": "astor", + "sha256": "4dd5332f4d795c45f07f5110764a183386c6f231beccd025e4227079da2286fb", + "size": 46374, + "subdir": "linux-64", + "timestamp": 1611675301760, + "version": "0.8.1" + }, + "astor-0.8.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9c008902f0553e6ed8c62038a57fa5fa", + "name": "astor", + "sha256": "ed6981263c0d5c3a66f49a8313182bc8a313dceb7e472a1d7ee8a6a02030640a", + "size": 46355, + "subdir": "linux-64", + "timestamp": 1597430688759, + "version": "0.8.1" + }, + "astor-0.8.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f626cfcb266ff142a901aa391b88f55b", + "name": "astor", + "sha256": "398caceaa42c34adf5d53353b95901c6e5b15a1575ad166e1c52d7e7fb374b07", + "size": 46456, + "subdir": "linux-64", + "timestamp": 1611674896017, + "version": "0.8.1" + }, + "astor-0.8.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c77504775abdba8705dd2da1592c3c96", + "name": "astor", + "sha256": "678970b26157e2b4e4ca695385d4a8b094881fe59712bcebb45056fb2b69da38", + "size": 46558, + "subdir": "linux-64", + "timestamp": 1611675342284, + "version": "0.8.1" + }, + "astroid-1.5.3-py27h8f8f47c_0.tar.bz2": { + "build": "py27h8f8f47c_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "enum34", + "lazy-object-proxy", + "python >=2.7,<2.8.0a0", + "setuptools", + "singledispatch", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "da8a4ef8e0939c41c133813ae5ef75ed", + "name": "astroid", + "sha256": "34444c4578ef5855c4c63ce705ebad21a3ce432d0c1ec59c4c056a2a657d36ac", + "size": 371988, + "subdir": "linux-64", + "timestamp": 1505693943294, + "version": "1.5.3" + }, + "astroid-1.5.3-py35h1d0c565_0.tar.bz2": { + "build": "py35h1d0c565_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "3fb77f2cf362fe6f219e939148c41523", + "name": "astroid", + "sha256": "df6763e7f6129d6c309a531a4a23555a9b605ef50a1abe170cc0b42c69475e39", + "size": 382085, + "subdir": "linux-64", + "timestamp": 1505693966826, + "version": "1.5.3" + }, + "astroid-1.5.3-py36hbdb9df2_0.tar.bz2": { + "build": "py36hbdb9df2_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "f0eded893d51e036f022cb0a91303674", + "name": "astroid", + "sha256": "3df097cf7bb55d96b575b6b145b6a265870238b79170bdcbaad7173e155e2efc", + "size": 382001, + "subdir": "linux-64", + "timestamp": 1505693990671, + "version": "1.5.3" + }, + "astroid-1.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "enum34", + "lazy-object-proxy", + "python >=2.7,<2.8.0a0", + "setuptools", + "singledispatch", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "51e13dedcef6a9c39086c2639021dbbb", + "name": "astroid", + "sha256": "70b3258795806d8ea6412ef4236a04570066ad65f25de652440ef3f5c7e33f95", + "size": 396908, + "subdir": "linux-64", + "timestamp": 1515702615294, + "version": "1.6.0" + }, + "astroid-1.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "6695cd0e2d3bff96ae5e685c9b83ee8e", + "name": "astroid", + "sha256": "cb72356a95caabc78bdb6ba5c2f79ed115a9ca41f09f64aaf54538b011f50315", + "size": 413734, + "subdir": "linux-64", + "timestamp": 1515702604924, + "version": "1.6.0" + }, + "astroid-1.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "4b54b7e5d8fafc6f7db4f781221af6c1", + "name": "astroid", + "sha256": "09defd21d4e6bcc9757978ea20649da1531784455f4ade7335b8d84dc161dde1", + "size": 412411, + "subdir": "linux-64", + "timestamp": 1515702519415, + "version": "1.6.0" + }, + "astroid-1.6.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "enum34", + "lazy-object-proxy", + "python >=2.7,<2.8.0a0", + "setuptools", + "singledispatch", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "bdedee09e5de83b4cd917202e7cdcdcd", + "name": "astroid", + "sha256": "adb8bcf8ea8ed2dca6a8ba11637849aff65383d8af287e966597afbc225b60d2", + "size": 396639, + "subdir": "linux-64", + "timestamp": 1517330644124, + "version": "1.6.1" + }, + "astroid-1.6.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "9a1245d522423e244cffa1bc9c72c25a", + "name": "astroid", + "sha256": "e57da0537d154d15a49d39678dacb4f664dbbe521222c8b4e3d5f504214b70a1", + "size": 413640, + "subdir": "linux-64", + "timestamp": 1517330571094, + "version": "1.6.1" + }, + "astroid-1.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "836343b68bb3923b38c4a5237c71cab4", + "name": "astroid", + "sha256": "fe2d61d1d1dec6009babe6fee80732f0baf012b0ad00c20e1fdba6c949f798c5", + "size": 412683, + "subdir": "linux-64", + "timestamp": 1517330662366, + "version": "1.6.1" + }, + "astroid-1.6.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "enum34", + "lazy-object-proxy", + "python >=2.7,<2.8.0a0", + "setuptools", + "singledispatch", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "8d5110028e195d7429bcdef9cbecda13", + "name": "astroid", + "sha256": "4ae07ebd6d30b1e10fa9a9e8790c1bdf82f5a6aaf07651296cadca64598e217f", + "size": 403109, + "subdir": "linux-64", + "timestamp": 1521568055947, + "version": "1.6.2" + }, + "astroid-1.6.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "7c087a1810e59d467491e790da72cba7", + "name": "astroid", + "sha256": "b2332f5190e864b95b308b696d25bd0a4b0ef4ebc9cf4d284a4afb5fff3d36e0", + "size": 417676, + "subdir": "linux-64", + "timestamp": 1521568066646, + "version": "1.6.2" + }, + "astroid-1.6.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "96bb2c61f204f2c69b76cc3edf089cbe", + "name": "astroid", + "sha256": "4e888567508615e3d93399081d242193d077f7dc9b27a53c4a3f7a89194dabb1", + "size": 419344, + "subdir": "linux-64", + "timestamp": 1521568062357, + "version": "1.6.2" + }, + "astroid-1.6.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "enum34", + "lazy-object-proxy", + "python >=2.7,<2.8.0a0", + "setuptools", + "singledispatch", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "71409d74d8726766e0dc373c950838b4", + "name": "astroid", + "sha256": "88d532ff86a9bf0daf2ead06aa27c8b5bb8e8777d4e5a9d95a9439442ce00680", + "size": 403760, + "subdir": "linux-64", + "timestamp": 1523291230340, + "version": "1.6.3" + }, + "astroid-1.6.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "983d014afa6ddb18b744317cf5435bcc", + "name": "astroid", + "sha256": "4899b7bf59d75cdcbf87d49f0c8d74552fffce2e3e4d67c6316ce9f47860766d", + "size": 418508, + "subdir": "linux-64", + "timestamp": 1523291249951, + "version": "1.6.3" + }, + "astroid-1.6.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "77543805b56ed9e73207253559c1f0ad", + "name": "astroid", + "sha256": "9842e1dcc5b7b810cc871fc5e50b32d7146f1058b2a3e8c75889b83b60c3435b", + "size": 488132, + "subdir": "linux-64", + "timestamp": 1523291191189, + "version": "1.6.3" + }, + "astroid-1.6.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "enum34", + "lazy-object-proxy", + "python >=2.7,<2.8.0a0", + "setuptools", + "singledispatch", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "85f1638320216b0e688f77b9953a592f", + "name": "astroid", + "sha256": "470cee415de0ce29a20f5bab6b2601ed2899843811c373d1b187a5f8991a228e", + "size": 410976, + "subdir": "linux-64", + "timestamp": 1527828476000, + "version": "1.6.4" + }, + "astroid-1.6.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "f6063e740bfd482e90f558f314fae7ca", + "name": "astroid", + "sha256": "619e96db9fb133f2aefd47d969531a2761200f8f9b2e50bedac09d9c3c1ef445", + "size": 426275, + "subdir": "linux-64", + "timestamp": 1527828498562, + "version": "1.6.4" + }, + "astroid-1.6.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "421ba060c6894cb7a8a8c4b245f8a93f", + "name": "astroid", + "sha256": "51853470ded70e8953969fa959480e36964896072524112f2f6eea204cf75404", + "size": 495998, + "subdir": "linux-64", + "timestamp": 1527828455691, + "version": "1.6.4" + }, + "astroid-1.6.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "enum34", + "lazy-object-proxy", + "python >=2.7,<2.8.0a0", + "setuptools", + "singledispatch", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "e8f84a7aaf457d58b2a15279cd0cd614", + "name": "astroid", + "sha256": "2788a56355fc58287322fc2a6b0011d5013919fc0501876c163e0a4195a29a99", + "size": 411210, + "subdir": "linux-64", + "timestamp": 1528899080081, + "version": "1.6.5" + }, + "astroid-1.6.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "2cb005d69cfdf9ff44c536b006d68650", + "name": "astroid", + "sha256": "2846c235d9135cc32c97aa982ed9086f6f9c3932b94a8e85f8d2ec7b9a58dda3", + "size": 426358, + "subdir": "linux-64", + "timestamp": 1528899122678, + "version": "1.6.5" + }, + "astroid-1.6.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "3d0a3be5c7526f2fe04b44723ecdc0cd", + "name": "astroid", + "sha256": "8e294437d8eeece36d74391216c8db6593e13ce18805d0c6e360bb71e8e436d8", + "size": 496031, + "subdir": "linux-64", + "timestamp": 1528899074078, + "version": "1.6.5" + }, + "astroid-1.6.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "250ac03923341693269a63ac2c888b20", + "name": "astroid", + "sha256": "647c5b8dcb054a58e42f076f4f7f71174e50d99f3f6e80806b68e421ee904a85", + "size": 427292, + "subdir": "linux-64", + "timestamp": 1530737996675, + "version": "1.6.5" + }, + "astroid-2.0.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.5,<3.6.0a0", + "six", + "typed-ast", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "e3659ad1cb19e48ba09b8a66dc40a8ea", + "name": "astroid", + "sha256": "905e47e7a8c94df9c1b5c44a833ef1c8b977fd7a0298f7d4316f2517542916fe", + "size": 253242, + "subdir": "linux-64", + "timestamp": 1533749500246, + "version": "2.0.2" + }, + "astroid-2.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "six", + "typed-ast", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "ffee595479f35a5a544e3ebec2382609", + "name": "astroid", + "sha256": "4ef3cd060551d22064d082e2032c581d0b4dba825556f04a95fa37d2c7efaee5", + "size": 252763, + "subdir": "linux-64", + "timestamp": 1533749521895, + "version": "2.0.2" + }, + "astroid-2.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.7,<3.8.0a0", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "7f42a1889badd0dd695ca239107b82c5", + "name": "astroid", + "sha256": "128cd5ffd5979d92b28ff3f787d9a65949743fe4255c8573742f2890a5b48f13", + "size": 252496, + "subdir": "linux-64", + "timestamp": 1533749550251, + "version": "2.0.2" + }, + "astroid-2.0.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.5,<3.6.0a0", + "six", + "typed-ast", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "d9e8d7bab79298d9f47a2707ffb2020d", + "name": "astroid", + "sha256": "6d320b7934c67e4a5887bd59d73a9ceb3c34aed3a300cca20934d6fbfd566fbd", + "size": 252634, + "subdir": "linux-64", + "timestamp": 1534175352450, + "version": "2.0.4" + }, + "astroid-2.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "six", + "typed-ast", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "7f04fa4ecc51c71e32e30a4c1462862b", + "name": "astroid", + "sha256": "738d9416928f79ad2b86d7cf46a455799b314f08accdf53670669a34590b25f0", + "size": 252935, + "subdir": "linux-64", + "timestamp": 1534175375678, + "version": "2.0.4" + }, + "astroid-2.0.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.7,<3.8.0a0", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "5d3ba0946dda453cbd074b4f5c4a5414", + "name": "astroid", + "sha256": "77298d5c555f92f84d12191225238844f90c8c14902394b7fb07717cb47c7bef", + "size": 252669, + "subdir": "linux-64", + "timestamp": 1534175238280, + "version": "2.0.4" + }, + "astroid-2.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "six", + "typed-ast", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "c1d6e618a1e15f5c77a35b94966c9c67", + "name": "astroid", + "sha256": "7568f572ec8820a3fa80c6ef477282d21d5496318cc24839d069832aee5f6464", + "size": 277434, + "subdir": "linux-64", + "timestamp": 1543517454612, + "version": "2.1.0" + }, + "astroid-2.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.7,<3.8.0a0", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "2bc423b62b6fd8c337a8472ae8585060", + "name": "astroid", + "sha256": "845dab45ec888cfb1e2e1ee4d4d1dab2da9edb6b6ccf27207c90a9861238642e", + "size": 277184, + "subdir": "linux-64", + "timestamp": 1543517424809, + "version": "2.1.0" + }, + "astroid-2.11.7-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.10,<3.11.0a0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "639520fbb2502d88275ed785cfd9447c", + "name": "astroid", + "sha256": "cd49314aae4968f7bd7f7833e3e196d4bf03713444c2c7239cb861038f3126b9", + "size": 370471, + "subdir": "linux-64", + "timestamp": 1659023175933, + "version": "2.11.7" + }, + "astroid-2.11.7-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.4.0,<2.0", + "typing-extensions >=3.10", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "c806aaa1359a9c487a63b048a099df28", + "name": "astroid", + "sha256": "d11314bec4b336000309524988ee2be10d0f1e27f01a7255f0825d260097d3e6", + "size": 366829, + "subdir": "linux-64", + "timestamp": 1659023282162, + "version": "2.11.7" + }, + "astroid-2.11.7-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.10", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "adcb4902a31f2b3f90d5be359d1fcf2f", + "name": "astroid", + "sha256": "bd16e2de8bd382b37b8296b56fe5e44d97521e01568f6ab4e6d6c40104ce87d5", + "size": 372617, + "subdir": "linux-64", + "timestamp": 1659023210887, + "version": "2.11.7" + }, + "astroid-2.11.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.10", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "946b585b927f69ba1acd4a3227c01894", + "name": "astroid", + "sha256": "853b07b2829478cf970f92bb108e5772d27ae48161cdc749022057b85446767f", + "size": 365836, + "subdir": "linux-64", + "timestamp": 1659023246187, + "version": "2.11.7" + }, + "astroid-2.12.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.10,<3.11.0a0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "efe55860d6f069a59689df929facb898", + "name": "astroid", + "sha256": "7726bbadfb3a0680eb023aa6e321f452d5ad612ca3409504f485f04846837c24", + "size": 393987, + "subdir": "linux-64", + "timestamp": 1660081269921, + "version": "2.12.2" + }, + "astroid-2.12.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.4.0,<2.0", + "typing-extensions >=3.10", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "a5b33af980f70da861b5a1ea663a10d4", + "name": "astroid", + "sha256": "55e120d71e9d29feb16d4d402931646f3befa0296c0877b5fb2c0aebe2f06672", + "size": 390679, + "subdir": "linux-64", + "timestamp": 1660081301868, + "version": "2.12.2" + }, + "astroid-2.12.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.10", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "481c6c7ea50ee841b0844d50e7059527", + "name": "astroid", + "sha256": "cf693788e13ee8f6bdf5da7586c57c5a72acd0d7b46c886821a8b71c0d74348a", + "size": 388712, + "subdir": "linux-64", + "timestamp": 1660081332487, + "version": "2.12.2" + }, + "astroid-2.12.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.10", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "edd1b6b3f369efb65b4c361074ed9ce2", + "name": "astroid", + "sha256": "48d07a5f5346cccae42aadb3d0a911ad1533c39bd218a7580924a71e6b25833c", + "size": 387874, + "subdir": "linux-64", + "timestamp": 1660081226293, + "version": "2.12.2" + }, + "astroid-2.13.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.10,<3.11.0a0", + "typing-extensions >=4.0.0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "73b89fddc2fda0c88e282a336cc37244", + "name": "astroid", + "sha256": "f8474e0c1e2169d5c8aaaa4460c2ac59760344d2f5fb432a396a480aaae7d097", + "size": 407332, + "subdir": "linux-64", + "timestamp": 1674746033341, + "version": "2.13.3" + }, + "astroid-2.13.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.11,<3.12.0a0", + "wrapt >=1.14,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "8913e99047c1d2497e8cca2c6457e286", + "name": "astroid", + "sha256": "f9e51d3904c5e88adaecace48885bf4746f21c39f89394734f65e19c11fb968a", + "size": 524144, + "subdir": "linux-64", + "timestamp": 1676827676495, + "version": "2.13.3" + }, + "astroid-2.13.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.4.0,<2.0", + "typing-extensions >=4.0.0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "97def12a0a39bdebd26c79ece7a5f8a0", + "name": "astroid", + "sha256": "f0e20d3afad00d421ab99d146c84dd6f6282545d19c82294581eed19c62ffff7", + "size": 407160, + "subdir": "linux-64", + "timestamp": 1674745951896, + "version": "2.13.3" + }, + "astroid-2.13.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=4.0.0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "80bc51d4b56fe642de26f9a9a9405e05", + "name": "astroid", + "sha256": "6483c29f0ca8f624d41e33778c6aea99e17447bd5b3bc260c3a11d932cd76d78", + "size": 408318, + "subdir": "linux-64", + "timestamp": 1674745978909, + "version": "2.13.3" + }, + "astroid-2.13.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=4.0.0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "eb89131416e42c769cfbea732558ba03", + "name": "astroid", + "sha256": "f5f9fea22297f67cefc15579308b19b6eb2fca4d13b2dfdb9948e90f7e938df8", + "size": 400787, + "subdir": "linux-64", + "timestamp": 1674746006038, + "version": "2.13.3" + }, + "astroid-2.14.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.10,<3.11.0a0", + "typing-extensions >=4.0.0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "ae1a34b148ab4920515961f7a3f8cfa5", + "name": "astroid", + "sha256": "c2ff3690e69dbf607d2e27c166433c92d3a56c0b43654248ed50e29ae6fcd7bf", + "size": 412377, + "subdir": "linux-64", + "timestamp": 1676904351680, + "version": "2.14.2" + }, + "astroid-2.14.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.11,<3.12.0a0", + "wrapt >=1.14,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "1781e4f5ff8aabed1bd8f08aac3e3a4f", + "name": "astroid", + "sha256": "1c47e1c40b40c9d23d1ba9a0d423671f8e2bdc86ac40699b1754fe23ea320f56", + "size": 531233, + "subdir": "linux-64", + "timestamp": 1676920994815, + "version": "2.14.2" + }, + "astroid-2.14.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.4.0,<2.0", + "typing-extensions >=4.0.0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "d75b4018b1dd325557ee577dfa56e2ed", + "name": "astroid", + "sha256": "bc2728e010ffb3f6a0ac7f681213b6656318144e488de0258083c761c01ba194", + "size": 408624, + "subdir": "linux-64", + "timestamp": 1676904377138, + "version": "2.14.2" + }, + "astroid-2.14.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=4.0.0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "ef9f2bf17fedd57657db2cfd36093f53", + "name": "astroid", + "sha256": "b687224f815e9cdb3ed591e2b9a1b9b6aba23a07ea2c00ec9048784fefbc5247", + "size": 406944, + "subdir": "linux-64", + "timestamp": 1676904402481, + "version": "2.14.2" + }, + "astroid-2.14.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=4.0.0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "5469f7189aa74a08baccdb06af20350b", + "name": "astroid", + "sha256": "d3a657e23aa46fc3505c3e91084c94047dff10356a1a750ee4fed69089321fbc", + "size": 406140, + "subdir": "linux-64", + "timestamp": 1676904325876, + "version": "2.14.2" + }, + "astroid-2.2.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "typed-ast >=1.3.0", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "6248360974dba9d7b84f74ad5b9c5dd7", + "name": "astroid", + "sha256": "721fce6338f2ec2f7ed6fdc8ce623633e9bfe3845a01d83767ea60fb3d89e3e1", + "size": 282068, + "subdir": "linux-64", + "timestamp": 1552327580067, + "version": "2.2.5" + }, + "astroid-2.2.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "ecf6aa9d645e330b2dfd2325838b4d7c", + "name": "astroid", + "sha256": "0414a83d405949c4a4c9134d06827dd46a5dfd5c14940ee01b961f8d061e2c06", + "size": 281717, + "subdir": "linux-64", + "timestamp": 1552327512916, + "version": "2.2.5" + }, + "astroid-2.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "typed-ast", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "bfc9cc5a8ce9ef0dcd94bf519eeeb70e", + "name": "astroid", + "sha256": "2cb095ac51a43adddeb213987f079cbf671d617dbd4d4a005afc7cdf94d4c972", + "size": 291882, + "subdir": "linux-64", + "timestamp": 1569854542805, + "version": "2.3.1" + }, + "astroid-2.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "5d7b04fc6f4e5236924811c7cadd1738", + "name": "astroid", + "sha256": "25cd1f588521d02aa4bbc39c216e4155a5a122948c94c0809a5b356d18894f1f", + "size": 295032, + "subdir": "linux-64", + "timestamp": 1569854554228, + "version": "2.3.1" + }, + "astroid-2.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "typed-ast", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "ccd5862150d363c0eaefb54defdf6b3d", + "name": "astroid", + "sha256": "935edd355ad85c2f3fd5e6ed08d13d474578d616c66daf7f3b8c21ed47945ab3", + "size": 290120, + "subdir": "linux-64", + "timestamp": 1571758695069, + "version": "2.3.2" + }, + "astroid-2.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "98d5f4308557803fdbe42b5f696323f7", + "name": "astroid", + "sha256": "b7acfadbd4a0cb234707ea683846d4dcafb2290a60f17155535546f942456178", + "size": 290690, + "subdir": "linux-64", + "timestamp": 1571758690804, + "version": "2.3.2" + }, + "astroid-2.3.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.8,<3.9.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "e912d946174f671f50d7e6240bd0004b", + "name": "astroid", + "sha256": "fe5202d4a4b4c0fe589d84d83f10df0b3b9a802b09b4b6131ed0bd9fbbdcf868", + "size": 289983, + "subdir": "linux-64", + "timestamp": 1574097612292, + "version": "2.3.2" + }, + "astroid-2.3.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "typed-ast", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "a74788405c5c9f6a6ceb6b1a2fdfa65e", + "name": "astroid", + "sha256": "9e72582233eb9958312cdbf363b6c3b86c5ef5c09d57d05e6b82db6e09fa44be", + "size": 298362, + "subdir": "linux-64", + "timestamp": 1573937291952, + "version": "2.3.3" + }, + "astroid-2.3.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "84564ad3a79784f08add37547b67aa9d", + "name": "astroid", + "sha256": "fd0df30a54b37334303970a3bf95a33571c05fc509aaa52a974d84094cc93fda", + "size": 298652, + "subdir": "linux-64", + "timestamp": 1573937268657, + "version": "2.3.3" + }, + "astroid-2.3.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.8,<3.9.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "0df2c159ca13beeed651b96e754358b9", + "name": "astroid", + "sha256": "a5b6e30c95d5885ab01e05ad4e0f3f0fab0444d0f20a05cd166b7fddfdf0b6dd", + "size": 293343, + "subdir": "linux-64", + "timestamp": 1573937315583, + "version": "2.3.3" + }, + "astroid-2.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "4e0a55b12dae2ae4583a615597cdf53a", + "name": "astroid", + "sha256": "a79f72750eacb378cd5067769d37d080b18647b1615b2cc6ce533965fa39362d", + "size": 508617, + "subdir": "linux-64", + "timestamp": 1588203883419, + "version": "2.4.0" + }, + "astroid-2.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "a3d13d798ed952871f124572d62fa15a", + "name": "astroid", + "sha256": "3edbc68380277be9e3e1d7725edaacd2a405d789d14a8dd7d938c25b48d71cee", + "size": 506995, + "subdir": "linux-64", + "timestamp": 1588203883330, + "version": "2.4.0" + }, + "astroid-2.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "38c931e2334eef7c463ec306d15905eb", + "name": "astroid", + "sha256": "019e4375f6ea99fa5f8cff0d81264b676e605ff61e891c974c39e6e0a2cf2893", + "size": 508452, + "subdir": "linux-64", + "timestamp": 1588203888806, + "version": "2.4.0" + }, + "astroid-2.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "65034ba8350b2e29b7f71ea68c3b915c", + "name": "astroid", + "sha256": "c32806b66652c82874f0614d25091bfc306019b4cfd8b9e5b25202d73079c2f9", + "size": 308073, + "subdir": "linux-64", + "timestamp": 1590114513377, + "version": "2.4.1" + }, + "astroid-2.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "976bae7505a20105fd0b126fa2364568", + "name": "astroid", + "sha256": "09fd2985b45dda9dc7a66b1b50304dc0bf013b373f5869e82b0b5f579bc7330d", + "size": 304335, + "subdir": "linux-64", + "timestamp": 1590114539285, + "version": "2.4.1" + }, + "astroid-2.4.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "8e6174994f433eb584873f162b879f7a", + "name": "astroid", + "sha256": "ba8e7264759c126e43b511a82c5fa674f699792c34b29daa0b0edb1b09929a88", + "size": 303867, + "subdir": "linux-64", + "timestamp": 1590114502513, + "version": "2.4.1" + }, + "astroid-2.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "c2d3ae21ee35f28b6f8252eb1e161d06", + "name": "astroid", + "sha256": "471b66c9ae7c59d973f25dd183b7a0cfba011206603f81715b0c38f1830e6d2e", + "size": 306612, + "subdir": "linux-64", + "timestamp": 1592495948230, + "version": "2.4.2" + }, + "astroid-2.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "b58b4ca89689a10f1b1ae4beb0b3db80", + "name": "astroid", + "sha256": "1d6d6b64cd1625efa8289001d51336443e2c82d15ce12b584e21ac0bd3596a92", + "size": 310662, + "subdir": "linux-64", + "timestamp": 1592495911734, + "version": "2.4.2" + }, + "astroid-2.4.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "6bf04eda44d0bbb128dd27db551999a8", + "name": "astroid", + "sha256": "c692086f4c7cb99afb98fc7309c0b5dcd7640229339a2445083d5e3f76c33b7d", + "size": 304151, + "subdir": "linux-64", + "timestamp": 1592495946453, + "version": "2.4.2" + }, + "astroid-2.4.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "5740135598f1173eef18f67f4198b7e3", + "name": "astroid", + "sha256": "1779fbc2e441e35fc10873093b3d69500308ce71aecb6a9ab8a83ec825ed4317", + "size": 307121, + "subdir": "linux-64", + "timestamp": 1607714549670, + "version": "2.4.2" + }, + "astroid-2.5-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "b29afa4f073bdd61d471e24de4c9dbf9", + "name": "astroid", + "sha256": "883d3e28e52bfaa329d4744191a761727001e3a11ea6b8d4d80a8ea72f5d1530", + "size": 307924, + "subdir": "linux-64", + "timestamp": 1613500902885, + "version": "2.5" + }, + "astroid-2.5-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "0746cb7e51968b0d71bc09c632ac4c96", + "name": "astroid", + "sha256": "191b200c097f4333b4ce19db6c40ff9d55d8c0c144f2f7beb425a4a714fd4ca7", + "size": 309702, + "subdir": "linux-64", + "timestamp": 1613500891813, + "version": "2.5" + }, + "astroid-2.5-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "c2ba24c045f340b04f6ad8d9b19bb15a", + "name": "astroid", + "sha256": "f320bd1d526c2a187f294dfcce5569cfe3e3a1489ef29c4224cb89556a8caaac", + "size": 304915, + "subdir": "linux-64", + "timestamp": 1613500893514, + "version": "2.5" + }, + "astroid-2.5-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "6ff5be6435bde4cf9c57162035701244", + "name": "astroid", + "sha256": "d80b33f03e5b592be81819b53de7ad78b4caebd289a4248c612fe4286b99a309", + "size": 304391, + "subdir": "linux-64", + "timestamp": 1613500900672, + "version": "2.5" + }, + "astroid-2.5.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "aca8564927209fd09aa4350961a8da2a", + "name": "astroid", + "sha256": "f5d3107706a2ffd41eb5fda8940be5681738f7c2eff12d0c69ee8b25ba93acc1", + "size": 314057, + "subdir": "linux-64", + "timestamp": 1616532521427, + "version": "2.5.1" + }, + "astroid-2.5.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "373e6ae2c217b6f64a8d80c44ae0065d", + "name": "astroid", + "sha256": "57fc5c63d3ae33f9ead557ab433a67f5268c3e79a981e93594b352071a58abd7", + "size": 315298, + "subdir": "linux-64", + "timestamp": 1616530367658, + "version": "2.5.1" + }, + "astroid-2.5.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "3b1d0ec89e5b659a8f7af7455ed3b119", + "name": "astroid", + "sha256": "2fa01b7ebd49473483f07ad08aa54c1a597047b5073b842f44bf257ac354f2f8", + "size": 317586, + "subdir": "linux-64", + "timestamp": 1616532273080, + "version": "2.5.1" + }, + "astroid-2.5.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "a103c3a05edd60f69d29b10e9596dfde", + "name": "astroid", + "sha256": "8fe73ab9dae7c9463bff4dfd3da70eb81557cdffddf58b3fe54a7fe241a66e2f", + "size": 315387, + "subdir": "linux-64", + "timestamp": 1616532520773, + "version": "2.5.1" + }, + "astroid-2.5.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "9a32a86a9ee63f4a0fb40fa9a6adcfb6", + "name": "astroid", + "sha256": "cbddbbd2d0a131f16c3061fcb2efc3579040e83d6afa821a64e831f85276689f", + "size": 312386, + "subdir": "linux-64", + "timestamp": 1617119300366, + "version": "2.5.2" + }, + "astroid-2.5.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "85152289b799dd04bb33ed1075054a44", + "name": "astroid", + "sha256": "2092e32101d8b4c246de9e8d5e4e1515f7592cf5be4829b47708be3af33cef5e", + "size": 312256, + "subdir": "linux-64", + "timestamp": 1617116835148, + "version": "2.5.2" + }, + "astroid-2.5.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "64a99897e24e2ae3a0ae585b6c0651bb", + "name": "astroid", + "sha256": "bcc1f112b9da1abd11b044968601a6992f34646c8e088edcf785cd32fe613b4f", + "size": 307459, + "subdir": "linux-64", + "timestamp": 1617119291008, + "version": "2.5.2" + }, + "astroid-2.5.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "59ecfd8b5889b2f4fda9d42cb4a40363", + "name": "astroid", + "sha256": "8fbb0f1c4bccf7b0d54db2d34bd771b8b7f1a50def463e2a2d07657bafa118a8", + "size": 313309, + "subdir": "linux-64", + "timestamp": 1617119289988, + "version": "2.5.2" + }, + "astroid-2.5.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "ce1400241ec128919b0b20e7c169f4c1", + "name": "astroid", + "sha256": "aaa554f5e0232a5d668765ac334649a0d844a8186dd77a834fb144dc7771264d", + "size": 309990, + "subdir": "linux-64", + "timestamp": 1618348287791, + "version": "2.5.3" + }, + "astroid-2.5.3-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "29394355fb5a991218544bda8bfc1f53", + "name": "astroid", + "sha256": "98830d43d32d45d13248c8254ce0a38af7f4b389bcc8966ddfdd8bbf10702d65", + "size": 320844, + "subdir": "linux-64", + "timestamp": 1618392814636, + "version": "2.5.3" + }, + "astroid-2.5.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "980c3c3686689273c64abbc7ef692847", + "name": "astroid", + "sha256": "63e3a72b779509362debcfedfc3a93b5bccd6d6cc24dfb042d0d2eede11cd7f2", + "size": 311484, + "subdir": "linux-64", + "timestamp": 1618348280194, + "version": "2.5.3" + }, + "astroid-2.5.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "5acdccdd24164c7d1d1775edd187ce94", + "name": "astroid", + "sha256": "0ff349af77e9cedd4ccf85c8f2a1ae0a5e51af6b22324f51bbf36f35f4f443d1", + "size": 322366, + "subdir": "linux-64", + "timestamp": 1618392813939, + "version": "2.5.3" + }, + "astroid-2.5.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "a8e91647ead4ee63e9e6221fc24ff9ec", + "name": "astroid", + "sha256": "8f78e5ad6b96229fa578676e2218bbb01875fc588a67e197ea37501ca3903401", + "size": 311555, + "subdir": "linux-64", + "timestamp": 1618348286329, + "version": "2.5.3" + }, + "astroid-2.5.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "e0df22259d7eb2c7dfe00caa152eee87", + "name": "astroid", + "sha256": "59e5592fad611255abafcfad569bfa2033033c574727441a651ec12bb4939812", + "size": 315927, + "subdir": "linux-64", + "timestamp": 1618392814666, + "version": "2.5.3" + }, + "astroid-2.5.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "1bbf45c346182a8d018ec0b99fa15770", + "name": "astroid", + "sha256": "23e54a1f0a0356947d8748d2e92cf6029659d270d4f4344745faed7024b7eaec", + "size": 311895, + "subdir": "linux-64", + "timestamp": 1618345204746, + "version": "2.5.3" + }, + "astroid-2.5.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "acca2674293bbb088a1cccedf9e9e6e7", + "name": "astroid", + "sha256": "547f08df76b4d26b6a976650e2ea5ad363c6eb66795fef0ad108070195592bb5", + "size": 324077, + "subdir": "linux-64", + "timestamp": 1618389713111, + "version": "2.5.3" + }, + "astroid-2.5.6-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "6dffd8ae163f2501b7b167afb592997a", + "name": "astroid", + "sha256": "0d94d68d134f03a12358014a2f696402aaa24fed9d19d5b7d1a4a2fe26e8304f", + "size": 309622, + "subdir": "linux-64", + "timestamp": 1620869746373, + "version": "2.5.6" + }, + "astroid-2.5.6-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "7a53682cfa892c5140547890ae010a89", + "name": "astroid", + "sha256": "073a09c815d1100767208e34cda697d4063de3173aa73b75cc4e28db84cecdcb", + "size": 315784, + "subdir": "linux-64", + "timestamp": 1620822947194, + "version": "2.5.6" + }, + "astroid-2.5.6-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "c17b4ab6491ffdb2b8dab99e844416ae", + "name": "astroid", + "sha256": "1ea64bc9c11ee105374c8383f61bef92c8e7fa9f83fbfe5cbbefe95f74d93c88", + "size": 311987, + "subdir": "linux-64", + "timestamp": 1620869668143, + "version": "2.5.6" + }, + "astroid-2.5.6-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "d7168c1c8e6089b90477364091fd45a3", + "name": "astroid", + "sha256": "c7f543ac8a2d09c668bea02eee13f004427b8bcb12478fb92dc1cb28d1285db2", + "size": 315178, + "subdir": "linux-64", + "timestamp": 1620827279090, + "version": "2.5.6" + }, + "astroid-2.5.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "e64c41f6cfc3e5e25fea58cf611f48cb", + "name": "astroid", + "sha256": "8b5736b7e39b3aadbc0768c08533ab83d801640cdbb9dd58a627fe446bfe4907", + "size": 311938, + "subdir": "linux-64", + "timestamp": 1620865400578, + "version": "2.5.6" + }, + "astroid-2.5.6-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "d95e109f56163ac4d7ff32c7080f4e43", + "name": "astroid", + "sha256": "ba8f9d12df987f55cf73f3c065d85288660ad21b93903f3e33fb899c971c514b", + "size": 315166, + "subdir": "linux-64", + "timestamp": 1620827173677, + "version": "2.5.6" + }, + "astroid-2.5.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "879baa5c773291c71a72596eb9e88bec", + "name": "astroid", + "sha256": "beada20991a5f657572630d0cb5a32ab84d284692ba6217fff0bbc24bbb2c0bc", + "size": 311105, + "subdir": "linux-64", + "timestamp": 1620869742691, + "version": "2.5.6" + }, + "astroid-2.5.6-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "4b860af1ed063441b0ee6f2f63856804", + "name": "astroid", + "sha256": "cd7bf03d97db1baf32519fd8dc102af4bfbae3beb9c81e1f79794f7a08f7acf5", + "size": 310650, + "subdir": "linux-64", + "timestamp": 1620827282482, + "version": "2.5.6" + }, + "astroid-2.5.7-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "27453cfe23ec3eecaa9f3754d8560002", + "name": "astroid", + "sha256": "7ba72a0d69cc7a7468f8f37934d8cc32090b2ced565b59d536ef624a2be77e02", + "size": 320318, + "subdir": "linux-64", + "timestamp": 1622551468168, + "version": "2.5.7" + }, + "astroid-2.5.7-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "749da5395c74d29a31a874d307f6689e", + "name": "astroid", + "sha256": "dca7849c4176fd8bf4f5701f8a3ef113b225845302403a37b51590639f54a633", + "size": 322141, + "subdir": "linux-64", + "timestamp": 1622556626935, + "version": "2.5.7" + }, + "astroid-2.5.7-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "fa2b970c1eea3251df9a0da371b9ffc7", + "name": "astroid", + "sha256": "b40af0f815f02847db73e564d049584034707eb21e2fdfe1c994e7213476a284", + "size": 317315, + "subdir": "linux-64", + "timestamp": 1622556676443, + "version": "2.5.7" + }, + "astroid-2.5.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "0bf1ee738b86bbcd8983add886d44cbf", + "name": "astroid", + "sha256": "b9dd04aee5848494ca9887a952a30f38ce19d52d335148231aacbe31678aee91", + "size": 317391, + "subdir": "linux-64", + "timestamp": 1622556657799, + "version": "2.5.7" + }, + "astroid-2.5.8-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "7ac96ff3b56215ee3538aba0e00b1f36", + "name": "astroid", + "sha256": "9c5df7931167cbbedd0b9516a859f1bdf82e613557a52450a60830848f5818d5", + "size": 320754, + "subdir": "linux-64", + "timestamp": 1623156821515, + "version": "2.5.8" + }, + "astroid-2.5.8-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "7df08d6272d74a7756a3dde7d020b77d", + "name": "astroid", + "sha256": "21eb7d8da4fe4a391de3cf6ea8ec7f7e3500ac808eb904e3f21b900d4d77936e", + "size": 327245, + "subdir": "linux-64", + "timestamp": 1623156818335, + "version": "2.5.8" + }, + "astroid-2.5.8-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "dc45bed5c4597477666bdb8d7d3f0ad6", + "name": "astroid", + "sha256": "0f9fa711fbcdbe1f1390af1bfc45900495c57b15bbab92fa79843661f03e1d6e", + "size": 321579, + "subdir": "linux-64", + "timestamp": 1623156827002, + "version": "2.5.8" + }, + "astroid-2.5.8-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "ec679e3fd9c009351862d51777322eac", + "name": "astroid", + "sha256": "12a011b5d7a49d0e081c1738aeebb3569c917ef44e5bd75f7fd748802a3de426", + "size": 320697, + "subdir": "linux-64", + "timestamp": 1623162315545, + "version": "2.5.8" + }, + "astroid-2.6.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "464384d4a8ca942f1e640356f1eaf43d", + "name": "astroid", + "sha256": "340332512a93928df23c44d245f5c0dce014e55b3f1e6cc937f6861978d398be", + "size": 330693, + "subdir": "linux-64", + "timestamp": 1624519696827, + "version": "2.6.0" + }, + "astroid-2.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "9a69c245ffbb40d6da54f116e97e0f15", + "name": "astroid", + "sha256": "bd96987b1df8e1f2063cbac8be2d05078559ac2e7bfc7577bb4e4e9a370a3e57", + "size": 330366, + "subdir": "linux-64", + "timestamp": 1624519646341, + "version": "2.6.0" + }, + "astroid-2.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "da4ceb91df32d760e06debccbf1f1f34", + "name": "astroid", + "sha256": "7b531662a536bc09ee639bfeff56552ca5b9bbb18322c2c12b3022605ba3558a", + "size": 335060, + "subdir": "linux-64", + "timestamp": 1624519678502, + "version": "2.6.0" + }, + "astroid-2.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "f69558b94ca694eb01715f462d88eb82", + "name": "astroid", + "sha256": "6397cb88d15c7d9b4fdf6039bc9aad619aa2d219fa42758bc7893962536f3379", + "size": 333551, + "subdir": "linux-64", + "timestamp": 1624519692344, + "version": "2.6.0" + }, + "astroid-2.6.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "25358b4cb51b9ed6cea6f292045e0d18", + "name": "astroid", + "sha256": "365d81deea3e358590b3b9b955359e09281977c3c00cbfaf9d7af527b995cf99", + "size": 332452, + "subdir": "linux-64", + "timestamp": 1625075616272, + "version": "2.6.2" + }, + "astroid-2.6.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "4d177be8a835c93132c02a1da84c648d", + "name": "astroid", + "sha256": "4cde8a6dfab130ed2e05f9928867181c2cb09ad35e8756c87edc9786bfa36b85", + "size": 321722, + "subdir": "linux-64", + "timestamp": 1625075852359, + "version": "2.6.2" + }, + "astroid-2.6.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "fb031f53aa856f0812a31a2bd2801d9e", + "name": "astroid", + "sha256": "187d6458a4860938ec2289f2b4eff79132679e085b1ff9a39a62cdd646b93af5", + "size": 331477, + "subdir": "linux-64", + "timestamp": 1625075849761, + "version": "2.6.2" + }, + "astroid-2.6.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "0cbc98c86f5c29c78dd7cd513ec41033", + "name": "astroid", + "sha256": "e40725697b8c1ff63636b23d8c2076787c71f522692d9b28870aa0aaf27f13f3", + "size": 335825, + "subdir": "linux-64", + "timestamp": 1625075863650, + "version": "2.6.2" + }, + "astroid-2.6.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.6,<3.7.0a0", + "setuptools >=20.0", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "0bb5b40236cd6a04dffaf8f2442602b0", + "name": "astroid", + "sha256": "577a1d1c09d7ccfa5fe11de3325388d7d0b3b10d2a040f7f12acd51ecc46b36b", + "size": 337470, + "subdir": "linux-64", + "timestamp": 1626766704919, + "version": "2.6.4" + }, + "astroid-2.6.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools >=20.0", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "0ed80d545bf932dc9710dd90131b4d3c", + "name": "astroid", + "sha256": "58717960bfcbbf394516e05ecc9844408320ea19308ffb72cb009413cceb663b", + "size": 325111, + "subdir": "linux-64", + "timestamp": 1626766125085, + "version": "2.6.4" + }, + "astroid-2.6.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools >=20.0", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "adf1de99e75ad31cdc71faab2b6ef784", + "name": "astroid", + "sha256": "db45a008bc9b142f72094737499336955bfaf4b10be63b3566b9cd2d3dd3ed60", + "size": 338506, + "subdir": "linux-64", + "timestamp": 1626766690659, + "version": "2.6.4" + }, + "astroid-2.6.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools >=20.0", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "942e36e104fb8c550fa914337ae82213", + "name": "astroid", + "sha256": "20b5232523f570356a5772ed258082c2ea4de8aebcb154f93cabbb72c2badb56", + "size": 333377, + "subdir": "linux-64", + "timestamp": 1626759376345, + "version": "2.6.4" + }, + "astroid-2.6.5-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.6,<3.7.0a0", + "setuptools >=20.0", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "30e5fb9d8d4206d4e829e7800fb90182", + "name": "astroid", + "sha256": "0d0204861421421809172e1fcaca353d736aba80f68a3fc44b2c2b8d018b2214", + "size": 333000, + "subdir": "linux-64", + "timestamp": 1626943060189, + "version": "2.6.5" + }, + "astroid-2.6.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools >=20.0", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "d2a106d630d7dc8d8090fc0e416cbafe", + "name": "astroid", + "sha256": "3e9b3d7b31f09160b8ec2c4c709f9947ad00a2110e3ef73bfacde511ef7b2a2e", + "size": 335926, + "subdir": "linux-64", + "timestamp": 1626950458991, + "version": "2.6.5" + }, + "astroid-2.6.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools >=20.0", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "2a4f745e9210a87899c1d1dd35c9c203", + "name": "astroid", + "sha256": "56a8233274ba534db43c47f6959ba3cdd212eb257794198b58775c47c3729a54", + "size": 328983, + "subdir": "linux-64", + "timestamp": 1626950455997, + "version": "2.6.5" + }, + "astroid-2.6.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools >=20.0", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "c30da7bbe28026d26fb7f155f5b2628e", + "name": "astroid", + "sha256": "33abfc6ca7a99ae9018510f7754932e8cc27a1d586196c949d660f1cbb20ecbd", + "size": 337579, + "subdir": "linux-64", + "timestamp": 1626950477950, + "version": "2.6.5" + }, + "astroid-2.6.6-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.6,<3.7.0a0", + "setuptools >=20.0", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "60fe483a5c795a7fab6f42ae1170faaf", + "name": "astroid", + "sha256": "1846e0cb1f989e17f791931237fb66005f1e66878c3e606620a81f5984276c11", + "size": 336536, + "subdir": "linux-64", + "timestamp": 1628055210573, + "version": "2.6.6" + }, + "astroid-2.6.6-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools >=20.0", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "cc4340529424719c03eadb0818422092", + "name": "astroid", + "sha256": "a052b61fc0093c0399984aeabd3e421f9138438ff0916b122cbd79a7481c62bd", + "size": 328596, + "subdir": "linux-64", + "timestamp": 1628063095474, + "version": "2.6.6" + }, + "astroid-2.6.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools >=20.0", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "878d6efdc400e0284a0c70a595f2eb9a", + "name": "astroid", + "sha256": "a48258833838ca21c6180904602b804cc5b2f647a1f0e9e83db9ba163bc426e2", + "size": 337782, + "subdir": "linux-64", + "timestamp": 1628063176156, + "version": "2.6.6" + }, + "astroid-2.6.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools >=20.0", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "eb586e8779f909ee78beefc6188ad9eb", + "name": "astroid", + "sha256": "4cf3fc538844946d8d99c73d3cdb3582e8a8d5f481ccac5207bcf92bf20c1e44", + "size": 335022, + "subdir": "linux-64", + "timestamp": 1628063174058, + "version": "2.6.6" + }, + "astroid-2.7.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.6,<3.7.0a0", + "setuptools >=20.0", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "295407846ac606f8fca7868a771a5061", + "name": "astroid", + "sha256": "bd59a175197b4c9ff014c41ce35cb070a41a756dc9cd86f2848e6b82c62b8929", + "size": 341059, + "subdir": "linux-64", + "timestamp": 1629320225149, + "version": "2.7.1" + }, + "astroid-2.7.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools >=20.0", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "4900aeddda6d8125bbcb173f07ce8579", + "name": "astroid", + "sha256": "436d21b9f1e8e3c4921e96d749fbe1c50b489e4a187ba14b45c3426cb078cfdc", + "size": 340782, + "subdir": "linux-64", + "timestamp": 1629320310953, + "version": "2.7.1" + }, + "astroid-2.7.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools >=20.0", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "2a2c538d90952e5f772bdfd64815127c", + "name": "astroid", + "sha256": "23a95745153a407d3734b0defa1cc82f3bda129181d61caf34ff1ebe1bc65fe1", + "size": 342099, + "subdir": "linux-64", + "timestamp": 1629320313072, + "version": "2.7.1" + }, + "astroid-2.7.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools >=20.0", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "595ddc49bed062f0504e1035e94bbf50", + "name": "astroid", + "sha256": "b504f7e48ba154c8a4a4292267802dbc86325642a2bd686bbf71c6732163bb81", + "size": 340387, + "subdir": "linux-64", + "timestamp": 1629311689638, + "version": "2.7.1" + }, + "astroid-2.9.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.10,<3.11.0a0", + "setuptools >=20.0", + "wrapt >=1.11,<1.14" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "b29c8a31b1c6fd7437f2e390ea6df743", + "name": "astroid", + "sha256": "d1c6100f10d377a27a136e2a054b5059ef2d1a4e71e9ff7bea20d5e6e43030ad", + "size": 358407, + "subdir": "linux-64", + "timestamp": 1640803436356, + "version": "2.9.0" + }, + "astroid-2.9.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools >=20.0", + "typed-ast >=1.4.0,<2.0", + "typing-extensions >=3.10", + "wrapt >=1.11,<1.14" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "40dc153024be979861c165846ad77345", + "name": "astroid", + "sha256": "9bb37c4c688d1ec99beff89f9529acbebfe82885da4e023a75ad6caefb80c86a", + "size": 368776, + "subdir": "linux-64", + "timestamp": 1639026138678, + "version": "2.9.0" + }, + "astroid-2.9.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools >=20.0", + "typing-extensions >=3.10", + "wrapt >=1.11,<1.14" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "b698279610fb231a429b6c8cfa03f67f", + "name": "astroid", + "sha256": "d51bd31ea588d75a2ebb8da7ba0f49c9f06d1471fc40d6cbcb4ac03e6e96821c", + "size": 361150, + "subdir": "linux-64", + "timestamp": 1639030713960, + "version": "2.9.0" + }, + "astroid-2.9.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools >=20.0", + "typing-extensions >=3.10", + "wrapt >=1.11,<1.14" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "8ec9e753bced271806ec9a4a2694f832", + "name": "astroid", + "sha256": "4a0b89565743a06288f485de3570e45b3b05c26539436b22693d84de2abbf6eb", + "size": 362288, + "subdir": "linux-64", + "timestamp": 1639044253882, + "version": "2.9.0" + }, + "astropy-2.0.11-py27hdd07704_0.tar.bz2": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest <3.7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "0eca2475841534bf01f2db76f6155e00", + "name": "astropy", + "sha256": "0a9958eb61073fcf3e78650e6c18b2a78746f4e8cb09ae4214dc5bf96461fb09", + "size": 7065108, + "subdir": "linux-64", + "timestamp": 1546570651213, + "version": "2.0.11" + }, + "astropy-2.0.11-py36hdd07704_0.tar.bz2": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest <3.7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "1b933d05d28e6bc680da15c960c974b8", + "name": "astropy", + "sha256": "fcae3bac869b609ed57b706d3637c9b74f126d1e34561e61ce781b8861d72dcc", + "size": 7060151, + "subdir": "linux-64", + "timestamp": 1546570580670, + "version": "2.0.11" + }, + "astropy-2.0.11-py37hdd07704_0.tar.bz2": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest <3.7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "1655b0a731d2feb95ffa062ab43599c8", + "name": "astropy", + "sha256": "313ac3bf5ab91a29cefe1283d9b7299526b2b86f8af2f54f7c0f0e88ac7af8eb", + "size": 7011095, + "subdir": "linux-64", + "timestamp": 1546570652369, + "version": "2.0.11" + }, + "astropy-2.0.12-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.9", + "pytest <3.7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "ba6f0fabdf22e0c19829603dbcf67da9", + "name": "astropy", + "sha256": "891b0238297ff600962472b810314cc00d0708832c905dd22db63c8fdeac33bd", + "size": 7155526, + "subdir": "linux-64", + "timestamp": 1551202000566, + "version": "2.0.12" + }, + "astropy-2.0.12-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11", + "pytest <3.7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "e11f24b244a394b79f11897b3313c47a", + "name": "astropy", + "sha256": "d814b7dc763063163963d95fbc40b292b8ad4b992fe09caca577ecc9fe95ceba", + "size": 7013607, + "subdir": "linux-64", + "timestamp": 1551198524776, + "version": "2.0.12" + }, + "astropy-2.0.12-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14", + "pytest <3.7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "d3b809b47e8b17513f6eb2624a14723f", + "name": "astropy", + "sha256": "65c09527defce8e66519bd3cbc81ff9035e1c59bd8605e07e57f5e79427ca542", + "size": 7046325, + "subdir": "linux-64", + "timestamp": 1551201861659, + "version": "2.0.12" + }, + "astropy-2.0.13-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.9", + "pytest <3.7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "3fc6e2c9a5acb0a156515a11940b1101", + "name": "astropy", + "sha256": "8a7d4c0f6feb96aebbc1916a469316420ba9fb8bd3ea2ce93b2e33419d9d3112", + "size": 7020254, + "subdir": "linux-64", + "timestamp": 1560312619523, + "version": "2.0.13" + }, + "astropy-2.0.13-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11", + "pytest <3.7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "fb458c3f0c3fe944cc9940c84c7bec47", + "name": "astropy", + "sha256": "deb9fbc7bbda57e45b02103b46ef9be953dd9cd73849525181c77f5b2457230d", + "size": 7132186, + "subdir": "linux-64", + "timestamp": 1560312655458, + "version": "2.0.13" + }, + "astropy-2.0.13-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14", + "pytest <3.7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "18e7e9e6d8981471fad7cb353bc4afe4", + "name": "astropy", + "sha256": "ec31801b5aa1c3b86cca27492a53b340ca4ab500214851f6e41344ee474d3eab", + "size": 6999897, + "subdir": "linux-64", + "timestamp": 1560312606571, + "version": "2.0.13" + }, + "astropy-2.0.14-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.9", + "pytest <3.7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "4d08182bcd8390ab8864e23d1e1c8d3d", + "name": "astropy", + "sha256": "c9ff9180d2551da95345ea1bf08bd273a8a9d681c0dcb87658ae13f01cf9fdd4", + "size": 7004664, + "subdir": "linux-64", + "timestamp": 1560671193993, + "version": "2.0.14" + }, + "astropy-2.0.14-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11", + "pytest <3.7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "8a907bc38f0a6062af87611df61c5391", + "name": "astropy", + "sha256": "227c256b9e21bf1a7db596fbd60dc7d1149db498a558a0e67f8fa18c160e2670", + "size": 7131518, + "subdir": "linux-64", + "timestamp": 1560671203964, + "version": "2.0.14" + }, + "astropy-2.0.14-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14", + "pytest <3.7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "7a806048e5f72de23b9b7affe485ff6b", + "name": "astropy", + "sha256": "b5d90459363c40250f07cabcfdabaf1707f8d6d243ee13a49816ab7fee8ba848", + "size": 7088287, + "subdir": "linux-64", + "timestamp": 1560671223765, + "version": "2.0.14" + }, + "astropy-2.0.15-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.9", + "pytest <3.7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "5874bef0bd998fb32eedb55bda1ee7bc", + "name": "astropy", + "sha256": "216ca074d3556a35652a2a1feb5390f7b07b93889b8f593154e382bd8b171eab", + "size": 7073175, + "subdir": "linux-64", + "timestamp": 1570568351653, + "version": "2.0.15" + }, + "astropy-2.0.15-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11", + "pytest <3.7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "adfbdee10fec0c8794a383302c4e0564", + "name": "astropy", + "sha256": "359b3e86c9f9fc47e56871f9066d18ed100ddb46aa2dc9903dcc3f6cd967e6ab", + "size": 7027409, + "subdir": "linux-64", + "timestamp": 1570568350509, + "version": "2.0.15" + }, + "astropy-2.0.15-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14", + "pytest <3.7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "897e9acd89e705e4d41f02d467525043", + "name": "astropy", + "sha256": "5316b8b6645b9f695c77152b8e900b821f67431182f608225cb7b5c3072b953b", + "size": 7036039, + "subdir": "linux-64", + "timestamp": 1570568335682, + "version": "2.0.15" + }, + "astropy-2.0.16-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.9", + "pytest <3.7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "8daab412800fa01313934518d570f609", + "name": "astropy", + "sha256": "0ab55af53ae0f617a492f5aec7425d7d092d26428dfb4a6fdbe598f6a4f6bf28", + "size": 7010565, + "subdir": "linux-64", + "timestamp": 1572991754339, + "version": "2.0.16" + }, + "astropy-2.0.16-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11", + "pytest <3.7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "9319e565f5e01e3902236ac7d28b2347", + "name": "astropy", + "sha256": "f243038e5329abbc85c1d3106d8d8fa684fc4e4cdb35b6363bd29dd5685efb0e", + "size": 7117263, + "subdir": "linux-64", + "timestamp": 1572991813167, + "version": "2.0.16" + }, + "astropy-2.0.16-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14", + "pytest <3.7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "70866ba3f9072adce17b9e8d04fb403b", + "name": "astropy", + "sha256": "5aa44b14aabcb199f200f6a1eb190d33fc16ad5c03ea8f9d0602c9498aebe0c7", + "size": 6995004, + "subdir": "linux-64", + "timestamp": 1572991739693, + "version": "2.0.16" + }, + "astropy-2.0.2-py27h57072c0_4.tar.bz2": { + "build": "py27h57072c0_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "d4bcc20f7aa7a0cbd40bfffc591dcc72", + "name": "astropy", + "sha256": "986af6949ff3d6d3d302f044476c86e315d90389c59608536bcce7860802b883", + "size": 7013510, + "subdir": "linux-64", + "timestamp": 1505723452634, + "version": "2.0.2" + }, + "astropy-2.0.2-py35h2d2a8a6_4.tar.bz2": { + "build": "py35h2d2a8a6_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "6366ed37c458f06af51ab1bb1daa86ff", + "name": "astropy", + "sha256": "26b383414148219a6765fb15b9e0300701a389b4f1e2a8d1effb1327bfb0b090", + "size": 7050617, + "subdir": "linux-64", + "timestamp": 1505723661897, + "version": "2.0.2" + }, + "astropy-2.0.2-py36ha51211e_4.tar.bz2": { + "build": "py36ha51211e_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "247c412c9369f8905b35e6297ffab510", + "name": "astropy", + "sha256": "e3a365dd5432f43a7b4fda4f1b5e1ad4ab41ecc5b4deacc3cd1115c00a1bd08a", + "size": 7205334, + "subdir": "linux-64", + "timestamp": 1505723856865, + "version": "2.0.2" + }, + "astropy-2.0.3-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "334c0e3a894af75c50299bc012c9ae18", + "name": "astropy", + "sha256": "b2b0d8d1fd648115ac48dbd42fa1156bd2bfd30d5af0f66bd0123493639e48dc", + "size": 7050758, + "subdir": "linux-64", + "timestamp": 1513803232772, + "version": "2.0.3" + }, + "astropy-2.0.3-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "8339e892d4e41412a030959485b0229d", + "name": "astropy", + "sha256": "61a7fac72ba5c3f7fcc90e7f7fbb110efb91ad590802963f81c184dbdcdf0d15", + "size": 7111801, + "subdir": "linux-64", + "timestamp": 1513803287166, + "version": "2.0.3" + }, + "astropy-2.0.3-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "63afcee9e81ca26a8458a13ae8baf8a8", + "name": "astropy", + "sha256": "2312445e0e5912017805401d0c8bd9754d88116ac8d89fb08abe3ca8dc31a179", + "size": 7135010, + "subdir": "linux-64", + "timestamp": 1513803293928, + "version": "2.0.3" + }, + "astropy-2.0.4-py27h3010b51_1.tar.bz2": { + "build": "py27h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.14.0,<2.0a0", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "6aeb2b982fcc27872fb178f2cacfe087", + "name": "astropy", + "sha256": "e4a720b7d464821355518a1c2bd0a07a2d92fadf53aa833f4e6172284afd589d", + "size": 7051972, + "subdir": "linux-64", + "timestamp": 1518728641748, + "version": "2.0.4" + }, + "astropy-2.0.4-py35h3010b51_1.tar.bz2": { + "build": "py35h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "7c8c9debeb08cbf3e6b6e213444ba133", + "name": "astropy", + "sha256": "159776b198b74c12b73ad960d04c4e852a81fc15b367b0e20b9dc47295ae0889", + "size": 7114261, + "subdir": "linux-64", + "timestamp": 1518728742895, + "version": "2.0.4" + }, + "astropy-2.0.4-py36h3010b51_1.tar.bz2": { + "build": "py36h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "fca6fde81cc8055e942aa2b0bd6c6ace", + "name": "astropy", + "sha256": "413229357850cd380d923228e7c5d300706728ddcc78213d80032d9303526d55", + "size": 7126143, + "subdir": "linux-64", + "timestamp": 1518728746207, + "version": "2.0.4" + }, + "astropy-2.0.5-py27h3010b51_1.tar.bz2": { + "build": "py27h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.14.1,<2.0a0", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "7194e1deba63ffc0ffe71d381b77441b", + "name": "astropy", + "sha256": "faa9446c7a22854195e5ae991fb447e66c88d7c8ce1452f3d029243d2eca483b", + "size": 7080650, + "subdir": "linux-64", + "timestamp": 1520968102206, + "version": "2.0.5" + }, + "astropy-2.0.5-py27h3010b51_2.tar.bz2": { + "build": "py27h3010b51_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "e80d96b1c3b1bfc3a3aa01cba29e657f", + "name": "astropy", + "sha256": "db6096a148e773d81156333c895878e167784b4f354be4ac1f17a64de4920cfe", + "size": 7081396, + "subdir": "linux-64", + "timestamp": 1521477783284, + "version": "2.0.5" + }, + "astropy-2.0.5-py35h3010b51_1.tar.bz2": { + "build": "py35h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.14.1,<2.0a0", + "pytest", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "2963559bcb4f1c004cd593f9a73620ec", + "name": "astropy", + "sha256": "3cf4bb1ad99c491b5ff5a77261ec1c839e871c237ccb6e1c1459be762419ed2f", + "size": 7128023, + "subdir": "linux-64", + "timestamp": 1520968158099, + "version": "2.0.5" + }, + "astropy-2.0.5-py35h3010b51_2.tar.bz2": { + "build": "py35h3010b51_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "5e71e6d1119ce418f092ceb08e49d7f8", + "name": "astropy", + "sha256": "2074e2eecbffb09f54d7e7d06b275fa320ebfa3edac017def22a403d5394072d", + "size": 7128668, + "subdir": "linux-64", + "timestamp": 1521477905907, + "version": "2.0.5" + }, + "astropy-2.0.5-py36h3010b51_1.tar.bz2": { + "build": "py36h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.14.1,<2.0a0", + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "359cc8f7b72125ba57080fd70facfe5d", + "name": "astropy", + "sha256": "d0810e4061b7d448f828b66a464b001dd8388ceed4c543338d3bdb4c97e44028", + "size": 7121035, + "subdir": "linux-64", + "timestamp": 1520968036456, + "version": "2.0.5" + }, + "astropy-2.0.5-py36h3010b51_2.tar.bz2": { + "build": "py36h3010b51_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "9397c60bd4b2dd9054b5dc7072ac33b8", + "name": "astropy", + "sha256": "86310cd8da56f8afc68fad58fd546c19e4fcb2f20c5ef3fe75a6cdb448cc9add", + "size": 7121455, + "subdir": "linux-64", + "timestamp": 1521477640677, + "version": "2.0.5" + }, + "astropy-2.0.6-py27h3010b51_1.tar.bz2": { + "build": "py27h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "b27fac3e21cbdc731cc485a1e07fd641", + "name": "astropy", + "sha256": "a20ee3b5d4372c1b433eb26b75544e0dcced23d8bdfecf3dc4b359814e566c29", + "size": 7081172, + "subdir": "linux-64", + "timestamp": 1524571321797, + "version": "2.0.6" + }, + "astropy-2.0.6-py35h3010b51_1.tar.bz2": { + "build": "py35h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "57a1521f56fa30a8eb0bbd80696e884b", + "name": "astropy", + "sha256": "8edef9a85451a472fd0349ae69db0e8d298e17820cae6cf25f789afd4de2d341", + "size": 7155843, + "subdir": "linux-64", + "timestamp": 1524571377335, + "version": "2.0.6" + }, + "astropy-2.0.6-py36h3010b51_1.tar.bz2": { + "build": "py36h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "ba4f87d103bbbea356903e0f70fd7214", + "name": "astropy", + "sha256": "f959c7f99a96604dfe71305d08b84e37d52085419bf63f6e73f894cc3f0d7321", + "size": 7146077, + "subdir": "linux-64", + "timestamp": 1524571380518, + "version": "2.0.6" + }, + "astropy-2.0.7-py27h3010b51_1.tar.bz2": { + "build": "py27h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "eba3352cc84ade230d8f6aef065b606f", + "name": "astropy", + "sha256": "a79c02a32e18e5df790391b74dad49e0f82eb17f2338683eafb6ac76795e047d", + "size": 7089425, + "subdir": "linux-64", + "timestamp": 1528031289928, + "version": "2.0.7" + }, + "astropy-2.0.7-py35h3010b51_1.tar.bz2": { + "build": "py35h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "9aa181554b61cd135627892977717852", + "name": "astropy", + "sha256": "62b0cc799b5f5af00dc20d9fe2f3f90ee85720b6c1e273f5acb40ee266880753", + "size": 7181635, + "subdir": "linux-64", + "timestamp": 1528031319662, + "version": "2.0.7" + }, + "astropy-2.0.7-py36h3010b51_1.tar.bz2": { + "build": "py36h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "9368137b337ebd55c1a59a2d431a4892", + "name": "astropy", + "sha256": "2a06c28a8bf7250ef3be0e853f3deecd36e21b1db88169d1c37fcdfd5bfaf93c", + "size": 7152279, + "subdir": "linux-64", + "timestamp": 1528031291431, + "version": "2.0.7" + }, + "astropy-2.0.8-py27h035aef0_0.tar.bz2": { + "build": "py27h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "8f29de8a735fd547f201ae99f47f7517", + "name": "astropy", + "sha256": "506956e2b4a89d08a9f073b288f4e5fc27ea013e2a36b6c71a72406325a51186", + "size": 7115184, + "subdir": "linux-64", + "timestamp": 1533324118493, + "version": "2.0.8" + }, + "astropy-2.0.8-py35h035aef0_0.tar.bz2": { + "build": "py35h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "9b440fd5bb031d57f8432134af0325af", + "name": "astropy", + "sha256": "fefbf1364adaf80b7ecca77a86e34d7874571ecb3491c2572502f045e9b924a6", + "size": 7209051, + "subdir": "linux-64", + "timestamp": 1533323867838, + "version": "2.0.8" + }, + "astropy-2.0.8-py36h035aef0_0.tar.bz2": { + "build": "py36h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "62fbe5965d570d6d9e02435fb28762c5", + "name": "astropy", + "sha256": "66ccfcb0d8f94c9e427c858f87a579f04ee9abbaf685a5ff87577a6c579c72c4", + "size": 7146859, + "subdir": "linux-64", + "timestamp": 1533324153209, + "version": "2.0.8" + }, + "astropy-2.0.8-py37h035aef0_0.tar.bz2": { + "build": "py37h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "f9d86a8b930f01ea73d0b24ac4cfa1b5", + "name": "astropy", + "sha256": "0812fecf0582119f4b480f2e701d7829ff9fea2ccf118ce7771d9aa58f78e269", + "size": 7123109, + "subdir": "linux-64", + "timestamp": 1533324141017, + "version": "2.0.8" + }, + "astropy-2.0.9-py27hdd07704_0.tar.bz2": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "ff3a82e3a9e71b506bc7d423780ca6ec", + "name": "astropy", + "sha256": "565581fb7a6350a9cd5f76f5941cfb9e46c40eede4b8fc9f93c1b228d5366644", + "size": 7182094, + "subdir": "linux-64", + "timestamp": 1539981516627, + "version": "2.0.9" + }, + "astropy-2.0.9-py27hdd07704_1.tar.bz2": { + "build": "py27hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest <3.7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "018c2820ca4e97c597f8559362a936cb", + "name": "astropy", + "sha256": "bd0760abae4ac43b7dbcb3e4e0adfe67cb5c1835501d46dae2fc9ec535945b1f", + "size": 7024904, + "subdir": "linux-64", + "timestamp": 1543593605258, + "version": "2.0.9" + }, + "astropy-2.0.9-py36hdd07704_0.tar.bz2": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "fcd085754c0a5a7fe4cb55c60c7183e0", + "name": "astropy", + "sha256": "4a7224403118f5d1e2a5d9952b1d146308fbbbd1134126e38247148cc2039b3f", + "size": 7168930, + "subdir": "linux-64", + "timestamp": 1539981576840, + "version": "2.0.9" + }, + "astropy-2.0.9-py36hdd07704_1.tar.bz2": { + "build": "py36hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest <3.7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "c56df2db4515cf8d673789973ad17868", + "name": "astropy", + "sha256": "f44858425f341d81bfe6af6c7e0cd1c363e3c66c63ad7650e5fc40b1b54f168b", + "size": 7016188, + "subdir": "linux-64", + "timestamp": 1543593753973, + "version": "2.0.9" + }, + "astropy-2.0.9-py37hdd07704_0.tar.bz2": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "ca3e9454bd5d1ebeeb1de1610bb26c8c", + "name": "astropy", + "sha256": "82985c52c898c5b25ff83fb1871f48945d9e8734be98b42d07381985de0c033b", + "size": 7154676, + "subdir": "linux-64", + "timestamp": 1539981566326, + "version": "2.0.9" + }, + "astropy-2.0.9-py37hdd07704_1.tar.bz2": { + "build": "py37hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest <3.7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "7d9e2135a6b69bd4733d8de62ca04e75", + "name": "astropy", + "sha256": "a49d5f9789ba040748bf1538527fc844fb92e78568265ea4c2037af93887323b", + "size": 7104622, + "subdir": "linux-64", + "timestamp": 1543593660663, + "version": "2.0.9" + }, + "astropy-3.0-py35h3010b51_1.tar.bz2": { + "build": "py35h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.10.4,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "55769fd991ee2c4d4dd1ab064b4ea638", + "name": "astropy", + "sha256": "49495bfe4bd0dbb155feed3468407badea9175915ff92d5331f0c0e2f8070653", + "size": 7133911, + "subdir": "linux-64", + "timestamp": 1518800618490, + "version": "3.0" + }, + "astropy-3.0-py36h3010b51_1.tar.bz2": { + "build": "py36h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "42f90d868d2bdc16a93bce52b4b0f0ea", + "name": "astropy", + "sha256": "a6907a28656b91740a1bed2394e32ef6d33dd3ba37c01b28581468c5c4989caf", + "size": 7106242, + "subdir": "linux-64", + "timestamp": 1518800773617, + "version": "3.0" + }, + "astropy-3.0.1-py35h3010b51_1.tar.bz2": { + "build": "py35h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.10.4,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "905a77ddbf61b6dfa8cb92bcf656b87b", + "name": "astropy", + "sha256": "52ee254dd146b239b73b379175e47139378ca8d950a91390e86ff41fd4997b67", + "size": 7208953, + "subdir": "linux-64", + "timestamp": 1520967809862, + "version": "3.0.1" + }, + "astropy-3.0.1-py36h3010b51_1.tar.bz2": { + "build": "py36h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "af107eddcf56dabe302008d66bf9badd", + "name": "astropy", + "sha256": "c0abb364cc5e8bdc23416be50c0cd2701f0d7c4f83172fda5f6920708007b654", + "size": 7129972, + "subdir": "linux-64", + "timestamp": 1520967837867, + "version": "3.0.1" + }, + "astropy-3.0.2-py35h3010b51_1.tar.bz2": { + "build": "py35h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.10.4,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "89bc6bd7d3202d2cd6c2cc0de893e56c", + "name": "astropy", + "sha256": "6435a3f82c9b7feb7e593b49b8e0e5d2d85b23d6f2763e7e7baac81cccd9f051", + "size": 7266499, + "subdir": "linux-64", + "timestamp": 1524573805927, + "version": "3.0.2" + }, + "astropy-3.0.2-py36h3010b51_1.tar.bz2": { + "build": "py36h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "c2c841a014bfe68f3f93a8dc51403715", + "name": "astropy", + "sha256": "26138ed8b08d6b2703ff853f9ddfbae21404dd81ac370731ae943d889ab4d12f", + "size": 7142495, + "subdir": "linux-64", + "timestamp": 1524573917775, + "version": "3.0.2" + }, + "astropy-3.0.3-py35h14c3975_2.tar.bz2": { + "build": "py35h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.10.4,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "43af2b0ddaea18898106545568ee8417", + "name": "astropy", + "sha256": "3714f01c9b111ced39cc7e7455ffdf6011340644daab59722bf58651002f33b8", + "size": 7297009, + "subdir": "linux-64", + "timestamp": 1528029980737, + "version": "3.0.3" + }, + "astropy-3.0.3-py36h14c3975_2.tar.bz2": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "1e923280f625b0efeb0c0861bfe22093", + "name": "astropy", + "sha256": "5c2fb8e864ad2a9b1c193bf55335e5eb1f40ddf2f734a2ce3034dc7f1d6a678d", + "size": 7141915, + "subdir": "linux-64", + "timestamp": 1528030007674, + "version": "3.0.3" + }, + "astropy-3.0.3-py37h14c3975_2.tar.bz2": { + "build": "py37h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "209d0ffa10941c007c88067e42108d10", + "name": "astropy", + "sha256": "ff3bbc41c8a12ed1f845cbc11b79250fa564524af1ccd6dbd365797417c110d9", + "size": 7128160, + "subdir": "linux-64", + "timestamp": 1530738380024, + "version": "3.0.3" + }, + "astropy-3.0.4-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.10.4,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "1a3c7c1a98e94e0c57190b8c188f04e4", + "name": "astropy", + "sha256": "03eb57013f3bcdffa6e662bf511beeda9bd2c0851a5928b0769d1642855e2414", + "size": 7278749, + "subdir": "linux-64", + "timestamp": 1533315809595, + "version": "3.0.4" + }, + "astropy-3.0.4-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "02edecce7568628b513c8b7aeea1740a", + "name": "astropy", + "sha256": "feeb0bcafabff752f2867abfc5729763ad8e16aeae545438d4a0e652ed8e1fb3", + "size": 7148619, + "subdir": "linux-64", + "timestamp": 1533315871495, + "version": "3.0.4" + }, + "astropy-3.0.4-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "c2768272d5e9f19df1b58c7a22ddc635", + "name": "astropy", + "sha256": "fc71e133a10f9b81713f1e8c2d5d2ef2279e2b5557c49026cebc3e61e5e9d3c5", + "size": 7136988, + "subdir": "linux-64", + "timestamp": 1533315927165, + "version": "3.0.4" + }, + "astropy-3.0.5-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "49fcf98939d1484b24b9e446feca1881", + "name": "astropy", + "sha256": "d5afe98ca494372430242463145cf74fa4a07a91ad1d039d97b1d11df1948594", + "size": 7174517, + "subdir": "linux-64", + "timestamp": 1539975858072, + "version": "3.0.5" + }, + "astropy-3.0.5-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest <4", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "ef88b0ce61932725fc9714200f76b73f", + "name": "astropy", + "sha256": "b3318671b20240fbdc09aa3fc07c620da270682251e1818013e67a798b9f1186", + "size": 7103561, + "subdir": "linux-64", + "timestamp": 1543592253704, + "version": "3.0.5" + }, + "astropy-3.0.5-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "14f98af9126805ba8405d9d52820f9d3", + "name": "astropy", + "sha256": "d692065db85988701ff85f2ed4a89f59097a99f056dd1ec539bde96ede463c8f", + "size": 7164244, + "subdir": "linux-64", + "timestamp": 1539975845778, + "version": "3.0.5" + }, + "astropy-3.0.5-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest <4", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "faa22789dcbc294bfaa434c03246abaa", + "name": "astropy", + "sha256": "003270096d5b30dd5f624a0de597c9323fe4678f54b9cfaea2ea0739ce512463", + "size": 6988410, + "subdir": "linux-64", + "timestamp": 1543592316340, + "version": "3.0.5" + }, + "astropy-3.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "be62d995d091518caefb35f098e3cf7a", + "name": "astropy", + "sha256": "03d2638498cd1cc7ff39a7a765365f3747c89de36461dc166303af3517f59931", + "size": 7498546, + "subdir": "linux-64", + "timestamp": 1544162225493, + "version": "3.1" + }, + "astropy-3.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "5bad1b8f793893c4ae3dae926bf1d4e4", + "name": "astropy", + "sha256": "e7983f1595073f3a2d708de59f6a2a3071f4cee05e847b809486345e8ff74d21", + "size": 7479864, + "subdir": "linux-64", + "timestamp": 1544162152961, + "version": "3.1" + }, + "astropy-3.1.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "6e17608517c20a38bf68ce98d1781a43", + "name": "astropy", + "sha256": "e3ea47fae04f6602b8b3ef5445ebd2f766da3742a0e3fd9410cdad73bdcd7928", + "size": 7317253, + "subdir": "linux-64", + "timestamp": 1546568781483, + "version": "3.1.1" + }, + "astropy-3.1.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "62f29c3e63057a97fc32eb579fee8e3a", + "name": "astropy", + "sha256": "672cd26a9815814e67fdade858391bf67da3ebf8e0029516f3d7ed372cef36a3", + "size": 7280500, + "subdir": "linux-64", + "timestamp": 1546568767483, + "version": "3.1.1" + }, + "astropy-3.1.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "09909b1a787488a4083551809fa5544c", + "name": "astropy", + "sha256": "bf6a393b89a1cc263479e874493948af10ba2084259a750c9318cf4aefdef8e6", + "size": 7290507, + "subdir": "linux-64", + "timestamp": 1551194671945, + "version": "3.1.2" + }, + "astropy-3.1.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "49c33a4bdd4fdbaabbc4fe5b63a31ed3", + "name": "astropy", + "sha256": "d02bd487c34ac8ae295f17da78988a42c6cb723b54d7729f99234ab5f39f22da", + "size": 7317922, + "subdir": "linux-64", + "timestamp": 1551194643643, + "version": "3.1.2" + }, + "astropy-3.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "06a6916ed2561e5c2c04a1179c1b8122", + "name": "astropy", + "sha256": "5c5dcaa1875a36c2bc1886444e9474aa8e037ca75d8b78933d686753eb9526c8", + "size": 7556655, + "subdir": "linux-64", + "timestamp": 1560313999867, + "version": "3.2" + }, + "astropy-3.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "39300f83b596788b6ee31cba5c3fefb6", + "name": "astropy", + "sha256": "9acef8e4d14cf0d0b623be28fb834265290975abd4a61427a662264b2ea69e5c", + "size": 7476386, + "subdir": "linux-64", + "timestamp": 1560313960853, + "version": "3.2" + }, + "astropy-3.2.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "e86fcef104d4c5cddbb3210c6c461d9d", + "name": "astropy", + "sha256": "b03ca742702486235f7c1a46a9f5a5c242ed591cab214f7aa23807ca89f3b796", + "size": 7507347, + "subdir": "linux-64", + "timestamp": 1560691419058, + "version": "3.2.1" + }, + "astropy-3.2.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "2db054dfd5761f736493cecf29ece4c5", + "name": "astropy", + "sha256": "6402b02740df2765936032833bb45558ba737f2497f03f15bdf4af83432d3353", + "size": 7432513, + "subdir": "linux-64", + "timestamp": 1560691418362, + "version": "3.2.1" + }, + "astropy-3.2.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "0fa99edfa4e75a11fc549d713ec1769f", + "name": "astropy", + "sha256": "321a8afd261fa19d314a313fec59f0c2b6d84745cd18162aebd867ad3dd5970e", + "size": 7458285, + "subdir": "linux-64", + "timestamp": 1570543579627, + "version": "3.2.2" + }, + "astropy-3.2.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "ed14a95e3235c4d6a18477eee45719cb", + "name": "astropy", + "sha256": "09ada1f22aeaa141cf10df276f21c93165c46cf9872fe9582536ad478f173520", + "size": 7470184, + "subdir": "linux-64", + "timestamp": 1570543570246, + "version": "3.2.2" + }, + "astropy-3.2.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "36b32caf4fc89195a2e508e9cfafb9c9", + "name": "astropy", + "sha256": "bcc040498f404be63ae72268a6d6b5559c55d79c40b206fe9f8e41832a330cf6", + "size": 7586986, + "subdir": "linux-64", + "timestamp": 1572895768097, + "version": "3.2.3" + }, + "astropy-3.2.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "1671c5f2bb5a234977486f6dd3fd1d50", + "name": "astropy", + "sha256": "a29045910326c5947873dcf17ee2a915b89d294954d948403c7a49fcc8310683", + "size": 7477044, + "subdir": "linux-64", + "timestamp": 1572895738356, + "version": "3.2.3" + }, + "astropy-4.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.5,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "8ba8633d3df2cec94670078bd6ccfcf2", + "name": "astropy", + "sha256": "427102ecf9e0dd432a6788afc57e91e8f0659038ab649dec6acf05cbd87efa46", + "size": 7804771, + "subdir": "linux-64", + "timestamp": 1578326007187, + "version": "4.0" + }, + "astropy-4.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.5,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "c97760cf20f624760babe164d9cf92ba", + "name": "astropy", + "sha256": "bfff43b5c1b55c023c10d55de805e76f93f1a22f80347a1daac77a646ddcf618", + "size": 7781962, + "subdir": "linux-64", + "timestamp": 1578325888236, + "version": "4.0" + }, + "astropy-4.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.4,<2.0a0", + "pytest-astropy", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "md5": "3129db9de18d1bc7de6de1da356e5187", + "name": "astropy", + "sha256": "18cd0e6da980b3db4789107cf0c11cea0da43edb0052ade3536771eccb590e25", + "size": 7785787, + "subdir": "linux-64", + "timestamp": 1580249770818, + "version": "4.0" + }, + "astropy-4.0.1.post1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "dcb9aa9d7535ccbbe7ee291522fc8120", + "name": "astropy", + "sha256": "4fa390cf7d2ed6f3ae7f5c376a8ce5e9d5f78c5d2fea3d185c9a726aea7dce2e", + "size": 7796164, + "subdir": "linux-64", + "timestamp": 1585926100570, + "version": "4.0.1.post1" + }, + "astropy-4.0.1.post1-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "504dd4851281cbc9cb38bb7a2c3b7a10", + "name": "astropy", + "sha256": "2bfc178350c12152b40e85e0d35c93081d45e3cf5835fc5d7cbd04bc7949416d", + "size": 7889636, + "subdir": "linux-64", + "timestamp": 1589296846209, + "version": "4.0.1.post1" + }, + "astropy-4.0.1.post1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "3ddfa815902af264e2001156a07726e7", + "name": "astropy", + "sha256": "acdd2202609851b489fb7cee60f6d1986aef4afd0d979133a69fcf6291ccaf39", + "size": 7782410, + "subdir": "linux-64", + "timestamp": 1585926127322, + "version": "4.0.1.post1" + }, + "astropy-4.0.1.post1-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "0f07253f7cc173cf5c151960dc89b567", + "name": "astropy", + "sha256": "2dc28bfa20615c106b16ce893bcc5cfee2fba95e7e0c099061cfb19b76046cdd", + "size": 7785468, + "subdir": "linux-64", + "timestamp": 1589296659522, + "version": "4.0.1.post1" + }, + "astropy-4.0.1.post1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pytest-astropy", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "5bdbf2d5f019c7a4e3ed9541aef1d2ae", + "name": "astropy", + "sha256": "bd60140f536babfe63e43c9bb3a0445df594b9e96ae914c0e496a29fd7a65851", + "size": 7850071, + "subdir": "linux-64", + "timestamp": 1585926111124, + "version": "4.0.1.post1" + }, + "astropy-4.0.1.post1-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "54dc20ae8e1b3368d151d30daaabd116", + "name": "astropy", + "sha256": "6da267f27ba19516e2fb77c79c0c97e99f7f75bacbc9d855741010cccafa205d", + "size": 7903899, + "subdir": "linux-64", + "timestamp": 1589296846934, + "version": "4.0.1.post1" + }, + "astropy-4.0.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "md5": "c0987c1aca0fd5779c2662d513dc040d", + "name": "astropy", + "sha256": "b5dd3d35350bca5c7c7c45cbf384b13ea8fe2857e293f7bcf0e793034ca460be", + "size": 7888102, + "subdir": "linux-64", + "timestamp": 1602602038096, + "version": "4.0.2" + }, + "astropy-4.0.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "md5": "6bef67c87a92b9c6ef8a30fe5c0ce87b", + "name": "astropy", + "sha256": "24578f1f04cfe132c3bc795771d66d5cbd922a1d4aa69b405da5f7c4f0f1bfb7", + "size": 7924556, + "subdir": "linux-64", + "timestamp": 1602602044236, + "version": "4.0.2" + }, + "astropy-4.0.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "md5": "a55dde8642fce634dc65e2bad33b6803", + "name": "astropy", + "sha256": "fc6be9164f7704ffd98cf67f0f89f0b51e95500e7348249479606e81cb2dee90", + "size": 7924593, + "subdir": "linux-64", + "timestamp": 1602602035881, + "version": "4.0.2" + }, + "astropy-4.2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "pyerfa", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b03aca1034d570a7c41b90a819255cad", + "name": "astropy", + "sha256": "7e81e1d49fa1582201bc4aa5cbbe45075e4d952d27102c4b575ac78d40d9ee0a", + "size": 7776289, + "subdir": "linux-64", + "timestamp": 1606923092313, + "version": "4.2" + }, + "astropy-4.2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "pyerfa", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a56876336655fc92957aacd7e6d582b2", + "name": "astropy", + "sha256": "c867e83fe4f1066949ff71952fee8fe680a5045feae5b0c8a27e4081b2ab084e", + "size": 7769760, + "subdir": "linux-64", + "timestamp": 1606923117320, + "version": "4.2" + }, + "astropy-4.2-py39h6323ea4_1.tar.bz2": { + "build": "py39h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "pyerfa", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b45a5cf33f9bb9b91fafbcbc036e67c9", + "name": "astropy", + "sha256": "4272fd11c4236589e09dbe5ce0b7957383c038fae29125767e5800aaebee4fb6", + "size": 7775434, + "subdir": "linux-64", + "timestamp": 1607713368513, + "version": "4.2" + }, + "astropy-4.2.1-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "matplotlib >=3.0", + "numpy >=1.17", + "pyerfa", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.13", + "scipy >=1.1" + ], + "license": "BSD-3-Clause", + "md5": "f96c544d30e7358a1809aa3aa31cfba6", + "name": "astropy", + "sha256": "84bd730d5935b64fc93c9d804ef691b8aaeaa8413031c278d70912a9bf150d79", + "size": 7757171, + "subdir": "linux-64", + "timestamp": 1617745702214, + "version": "4.2.1" + }, + "astropy-4.2.1-py37h6323ea4_1.tar.bz2": { + "build": "py37h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pyerfa", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ed4dc9929ee66aa7f4344e129732e571", + "name": "astropy", + "sha256": "e9e0387c42164cbd549e974cc316e8849dc92476edfe3e279e37bf8a2aaa5340", + "size": 7903448, + "subdir": "linux-64", + "timestamp": 1617383634746, + "version": "4.2.1" + }, + "astropy-4.2.1-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "matplotlib >=3.0", + "numpy >=1.17", + "pyerfa", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.13", + "scipy >=1.1" + ], + "license": "BSD-3-Clause", + "md5": "b73c783447fc6c3aee28eeb530e5ab9c", + "name": "astropy", + "sha256": "a9a008e070eb37c167ddc5ed7cf41c6fcda5fe77941d9427cddb3fa2bca43640", + "size": 7839961, + "subdir": "linux-64", + "timestamp": 1617745571803, + "version": "4.2.1" + }, + "astropy-4.2.1-py38h6323ea4_1.tar.bz2": { + "build": "py38h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pyerfa", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "edd82b75ac5cdc95eda29c8e9055a2c3", + "name": "astropy", + "sha256": "d3100cf1d59e099bbfdfb549017f4a0a0040cbdd3cf88c882984eaaedc93d58f", + "size": 7890724, + "subdir": "linux-64", + "timestamp": 1617381053189, + "version": "4.2.1" + }, + "astropy-4.2.1-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "matplotlib >=3.0", + "numpy >=1.17", + "pyerfa", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.13", + "scipy >=1.1" + ], + "license": "BSD-3-Clause", + "md5": "b8d98335bc00f0f76f44752e16d91d33", + "name": "astropy", + "sha256": "9ae29b25f05aed4bf19b4444ced1a9d17cd7feb0168cfebebb93d6cb38a7b685", + "size": 7927238, + "subdir": "linux-64", + "timestamp": 1617745729372, + "version": "4.2.1" + }, + "astropy-4.2.1-py39h6323ea4_1.tar.bz2": { + "build": "py39h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pyerfa", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "44cca39304efe00e32401a43805648ae", + "name": "astropy", + "sha256": "808257d8a5a4b477085a460964efb8e97c0350ea7a4f04907718b258b4777d34", + "size": 7818021, + "subdir": "linux-64", + "timestamp": 1617383282845, + "version": "4.2.1" + }, + "astropy-4.3.1-py37h09021b7_0.tar.bz2": { + "build": "py37h09021b7_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "matplotlib >=3.0,!=3.4.0", + "numpy >=1.19.2,<2.0a0", + "pyerfa >=1.7.3", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.13", + "scipy >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7739250f07f116b7a1f388873b080aa0", + "name": "astropy", + "sha256": "51fa4ac859ab4a519805aaa1cd204412f77940aee0a9f26be7bcc4efe4a25b2b", + "size": 8132728, + "subdir": "linux-64", + "timestamp": 1629829452312, + "version": "4.3.1" + }, + "astropy-4.3.1-py38h09021b7_0.tar.bz2": { + "build": "py38h09021b7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "matplotlib >=3.0,!=3.4.0", + "numpy >=1.19.2,<2.0a0", + "pyerfa >=1.7.3", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.13", + "scipy >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "db754b220ded6cb0de1f8e73cbbec156", + "name": "astropy", + "sha256": "8489472b222f1ab8bc4e4d1b5b6d7c516039cb65ec33ed6d4d2b69d9a74593e8", + "size": 8101208, + "subdir": "linux-64", + "timestamp": 1629829421338, + "version": "4.3.1" + }, + "astropy-4.3.1-py39h09021b7_0.tar.bz2": { + "build": "py39h09021b7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "matplotlib >=3.0,!=3.4.0", + "numpy >=1.19.2,<2.0a0", + "pyerfa >=1.7.3", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.13", + "scipy >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4e68e09bfded4ab3531ae873d80caefd", + "name": "astropy", + "sha256": "0f8c5691196d8927cf23ccf18f5be5b71fef0a18698bb0a8f320fecc0e606233", + "size": 8177438, + "subdir": "linux-64", + "timestamp": 1629820543127, + "version": "4.3.1" + }, + "astropy-4.3.post1-py37h7f8727e_1.tar.bz2": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "matplotlib >=3.0", + "numpy >=1.17", + "pyerfa", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.13", + "scipy >=1.1" + ], + "license": "BSD-3-Clause", + "md5": "3a5e4004a10a189bbe8e86bb1663e30d", + "name": "astropy", + "sha256": "fff327acd08c68cae630d5e1060ea2e46d634008923238afba26b5e5d1e0262b", + "size": 8142682, + "subdir": "linux-64", + "timestamp": 1628150410194, + "version": "4.3.post1" + }, + "astropy-4.3.post1-py37hce1f21e_1.tar.bz2": { + "build": "py37hce1f21e_1", + "build_number": 1, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "matplotlib >=3.0,!=3.4.0", + "numpy >=1.16.6,<2.0a0", + "pyerfa >=2.0", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.13", + "scipy >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0d0e2e0ebceafe5bafaf0e7a2d76695f", + "name": "astropy", + "sha256": "926a183d9621901562c3ffe799ffbbb58030bfeb219c83920a1309a16a0d191b", + "size": 8049766, + "subdir": "linux-64", + "timestamp": 1628529188292, + "version": "4.3.post1" + }, + "astropy-4.3.post1-py38h7f8727e_1.tar.bz2": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "matplotlib >=3.0", + "numpy >=1.17", + "pyerfa", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.13", + "scipy >=1.1" + ], + "license": "BSD-3-Clause", + "md5": "e124de65e52fc55e47f05ab73b097ce9", + "name": "astropy", + "sha256": "798c273bec71d0106ae3a888d90770c870eebcefb0166ce9057eda5358b56d60", + "size": 8065799, + "subdir": "linux-64", + "timestamp": 1628150406859, + "version": "4.3.post1" + }, + "astropy-4.3.post1-py38hce1f21e_1.tar.bz2": { + "build": "py38hce1f21e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "matplotlib >=3.0,!=3.4.0", + "numpy >=1.16.6,<2.0a0", + "pyerfa >=2.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.13", + "scipy >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d320b0a6cd99347480c83c6ba01fc6f5", + "name": "astropy", + "sha256": "6a7ce74339cd25b053e470a894c68196d62fc4d20462df03762961bf434c9b34", + "size": 8163625, + "subdir": "linux-64", + "timestamp": 1628520977249, + "version": "4.3.post1" + }, + "astropy-4.3.post1-py39h7f8727e_1.tar.bz2": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "matplotlib >=3.0", + "numpy >=1.17", + "pyerfa", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.13", + "scipy >=1.1" + ], + "license": "BSD-3-Clause", + "md5": "8ff29fe08c297c068b6685cf4c2022e0", + "name": "astropy", + "sha256": "431b9a03176f85ac6c50fa5432da1e3075160fa05d14c3d3a6d72ac7a9d4df09", + "size": 8074017, + "subdir": "linux-64", + "timestamp": 1628150314696, + "version": "4.3.post1" + }, + "astropy-4.3.post1-py39hce1f21e_1.tar.bz2": { + "build": "py39hce1f21e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "matplotlib >=3.0,!=3.4.0", + "numpy >=1.16.6,<2.0a0", + "pyerfa >=2.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.13", + "scipy >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "efcdd88700396e070b2b7c5ebb1188c6", + "name": "astropy", + "sha256": "dc71a8c14521c19ee4e0f6b2d271c086766a4564b020adb08774d66c5334dbd9", + "size": 8191437, + "subdir": "linux-64", + "timestamp": 1628529190152, + "version": "4.3.post1" + }, + "astropy-5.0-py310h9102076_0.tar.bz2": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5b64332be4df6b2f5000ca315fcb939d", + "name": "astropy", + "sha256": "be68989e2b5128bf6e37028bbc57272d503d82852cfd6a05b0df7bbe578df586", + "size": 12031086, + "subdir": "linux-64", + "timestamp": 1640808397416, + "version": "5.0" + }, + "astropy-5.0-py38h09021b7_0.tar.bz2": { + "build": "py38h09021b7_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ba0204b31664d99f9b4dd54cd832cdc0", + "name": "astropy", + "sha256": "1873c1c7d3afe8c7714fef3f2d051d54e416530487eb9f25d0030d4a81c5fd34", + "size": 8504494, + "subdir": "linux-64", + "timestamp": 1638772250226, + "version": "5.0" + }, + "astropy-5.0-py39h09021b7_0.tar.bz2": { + "build": "py39h09021b7_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e6feba52fa4a65ce531ac13288f34aa8", + "name": "astropy", + "sha256": "eee52b7c392b5bab76d1a29d98cd23b03708b101d22d4bdc37ff3fceec0c17c2", + "size": 8435763, + "subdir": "linux-64", + "timestamp": 1638767546928, + "version": "5.0" + }, + "astropy-5.0.2-py310h9102076_0.tar.bz2": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "818da59ff7e4a15e5dc34636787c3743", + "name": "astropy", + "sha256": "655c1d6be4080f5a2ec3e4fc568e8648c06c13508370343acae27adc25df5803", + "size": 11972148, + "subdir": "linux-64", + "timestamp": 1647852356310, + "version": "5.0.2" + }, + "astropy-5.0.2-py38hce1f21e_0.tar.bz2": { + "build": "py38hce1f21e_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2bfb50f807c878469f8e2544b69db095", + "name": "astropy", + "sha256": "7bc2704838e49537d43a027e11bad85bfc21d55f7c420aef0db725b71e49f5a7", + "size": 8574341, + "subdir": "linux-64", + "timestamp": 1647834199484, + "version": "5.0.2" + }, + "astropy-5.0.2-py39hce1f21e_0.tar.bz2": { + "build": "py39hce1f21e_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dd365c6380b74518bfc168a9ad4d7859", + "name": "astropy", + "sha256": "17a22c7daa808203d9c5f245b432c6ba3f69fff430452727de1d15afe33f078b", + "size": 8464976, + "subdir": "linux-64", + "timestamp": 1647834465719, + "version": "5.0.2" + }, + "astropy-5.0.3-py310h9102076_0.tar.bz2": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "426118c9e2f269a215b3ca789691abb9", + "name": "astropy", + "sha256": "0c650e0c3e56d6490b37c9303ea9dc217708b3478bc5158315f8ecaf97b8e742", + "size": 11933462, + "subdir": "linux-64", + "timestamp": 1648712702806, + "version": "5.0.3" + }, + "astropy-5.0.3-py38hce1f21e_0.tar.bz2": { + "build": "py38hce1f21e_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9fad8f687fa8b513ea70ad750be11351", + "name": "astropy", + "sha256": "3025b94f807692aac3daecf1cef9be9577a88f805d28fc556a770a22c21f3cd6", + "size": 8476839, + "subdir": "linux-64", + "timestamp": 1648694562304, + "version": "5.0.3" + }, + "astropy-5.0.3-py39hce1f21e_0.tar.bz2": { + "build": "py39hce1f21e_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb489900a66c9846553cd8484f243d9f", + "name": "astropy", + "sha256": "6d96010826f81cf85c95b93099bfb67c088d18dbcec80742dfb0b8d37524ebb7", + "size": 8495226, + "subdir": "linux-64", + "timestamp": 1648712685357, + "version": "5.0.3" + }, + "astropy-5.0.4-py310h9102076_0.tar.bz2": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "06de6e6d049f4c02384dd7d49a7694ff", + "name": "astropy", + "sha256": "bd00ec5b88d3d34806fc7126492d91082d3f78e31b8846788918b91d0169e2bf", + "size": 11953527, + "subdir": "linux-64", + "timestamp": 1650891651455, + "version": "5.0.4" + }, + "astropy-5.0.4-py311hbed6279_0.tar.bz2": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.11,<3.12.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "119fef75ad88c9d56e8499646a1b9403", + "name": "astropy", + "sha256": "55b16005b7be98a8a7a1e1c3bff38ed9e243075e3770f0f746472aa58c5bf276", + "size": 10208828, + "subdir": "linux-64", + "timestamp": 1676839082776, + "version": "5.0.4" + }, + "astropy-5.0.4-py38hce1f21e_0.tar.bz2": { + "build": "py38hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e88f2cd48f4fe1269592b3964173aaa1", + "name": "astropy", + "sha256": "e56fad057dbcbb083f42bd6b7ca8029b8ff0af2c515245f91f8e7feda0d9ca66", + "size": 8475045, + "subdir": "linux-64", + "timestamp": 1650891439641, + "version": "5.0.4" + }, + "astropy-5.0.4-py39hce1f21e_0.tar.bz2": { + "build": "py39hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c961aefe1a07ee6e9b1ccfd609c5d402", + "name": "astropy", + "sha256": "ae051ecd167cc43bcf096357afb9878f9c9a187898ef20dd4ec658437fe573da", + "size": 8476789, + "subdir": "linux-64", + "timestamp": 1650891246872, + "version": "5.0.4" + }, + "astropy-5.1-py310ha9d4c09_0.tar.bz2": { + "build": "py310ha9d4c09_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5d3c944a8e7e04aa3a5b785500302ec5", + "name": "astropy", + "sha256": "40845980d3a36122db82685eccf5b98751cb86fb4cbd85f4cd2682a78753f956", + "size": 12419878, + "subdir": "linux-64", + "timestamp": 1657786479850, + "version": "5.1" + }, + "astropy-5.1-py311hbed6279_0.tar.bz2": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.11,<3.12.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a15bf814b9e7f6868adbbfb86f6a81e5", + "name": "astropy", + "sha256": "18913dc2c83453adc653ccc6e9ac5925b81fd9e11c5a4e7458e1fda2fa3dde4a", + "size": 10422743, + "subdir": "linux-64", + "timestamp": 1679335324791, + "version": "5.1" + }, + "astropy-5.1-py38h7deecbd_0.tar.bz2": { + "build": "py38h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "642a014e48db2f6fa48d573aca6d096f", + "name": "astropy", + "sha256": "8d0fb565a63d31f488be09cee684eab838134721e13d6c7598c7cdc760331f0f", + "size": 8526031, + "subdir": "linux-64", + "timestamp": 1657786681078, + "version": "5.1" + }, + "astropy-5.1-py39h7deecbd_0.tar.bz2": { + "build": "py39h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0b6b8e60272fd39731294fb5fdbf0652", + "name": "astropy", + "sha256": "3dc1908b4e14abbee0b9a29967dce87647bb44c4c5d0ae98d6d1dc1cb905bc55", + "size": 8523772, + "subdir": "linux-64", + "timestamp": 1657786253878, + "version": "5.1" + }, + "async-timeout-2.0.0-py35h12a94dc_0.tar.bz2": { + "build": "py35h12a94dc_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b73c9ac18a6ddc0c47556df580cc6a44", + "name": "async-timeout", + "sha256": "3f1afe01e9d4c3f7da7ec8a82c0d3b34858bf648370275206c66f21a28aaa416", + "size": 11255, + "subdir": "linux-64", + "timestamp": 1508005818622, + "version": "2.0.0" + }, + "async-timeout-2.0.0-py36h92a791d_0.tar.bz2": { + "build": "py36h92a791d_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "213b0a9cec89f199a41d2a66dd2fbcef", + "name": "async-timeout", + "sha256": "705e97b0f6234d5a2567d026bd4c2beda38cbba9e2f96d17969b6826f2c54dd3", + "size": 11221, + "subdir": "linux-64", + "timestamp": 1508005827209, + "version": "2.0.0" + }, + "async-timeout-2.0.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0cd4419e15cea7d10c64c5e7d5be8f3d", + "name": "async-timeout", + "sha256": "68b210e0b4dcf122e9b4efb71edadf58f0282352c7553a7797917be87954ef2e", + "size": 11246, + "subdir": "linux-64", + "timestamp": 1521603990265, + "version": "2.0.1" + }, + "async-timeout-2.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0f99ee08b3ab82951e6d80d13a269b2e", + "name": "async-timeout", + "sha256": "9a472d872536da5bfa789ef25a8659c86be1a3f1c8828f38548065d572119cd3", + "size": 11243, + "subdir": "linux-64", + "timestamp": 1521604000907, + "version": "2.0.1" + }, + "async-timeout-3.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "786baa23bc0d7eae7f2a32f8708d4b7c", + "name": "async-timeout", + "sha256": "2e5eb161628246fe589881875e2f525f9b51decb497d41558bc0a87cc0a708b4", + "size": 11604, + "subdir": "linux-64", + "timestamp": 1526920910271, + "version": "3.0.0" + }, + "async-timeout-3.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "55edbcc2721d579e31876001ddfcca4f", + "name": "async-timeout", + "sha256": "7a6f9418040daf815ff8de9c83e3f0e635fb9aea65ec87d32961d2b340ce2b8b", + "size": 11614, + "subdir": "linux-64", + "timestamp": 1526920884980, + "version": "3.0.0" + }, + "async-timeout-3.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b6ba4f1a8f5e8f22fbfe0d9378ad8883", + "name": "async-timeout", + "sha256": "bb8a8756110a6c6fb2dbdec8b3c7d36bb4d1249a26f6f9cdf15890fe00fd7ed4", + "size": 11643, + "subdir": "linux-64", + "timestamp": 1530736505104, + "version": "3.0.0" + }, + "async-timeout-3.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bcc17c1ddb49fb59a211052346346693", + "name": "async-timeout", + "sha256": "f10e4fed2effbdc663bf8d4ebfee7f9848b2805b5453c60490fa9ac2c71a3fa6", + "size": 11980, + "subdir": "linux-64", + "timestamp": 1539466795616, + "version": "3.0.1" + }, + "async-timeout-3.0.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "74e064c2a4b64212e4e1dc6540bb0b63", + "name": "async-timeout", + "sha256": "6d1806d2bfe00ffac32ae4ab0bb9aaa287e1c7a31a9b1041356840b5807f96ed", + "size": 13212, + "subdir": "linux-64", + "timestamp": 1611675370971, + "version": "3.0.1" + }, + "async-timeout-3.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7a13a451b9508b3e3ae66e585c06889d", + "name": "async-timeout", + "sha256": "fbb2e7172b2a0dc2d8ce21579ad0e5221a8220358da5e8602514c6f37674f554", + "size": 11985, + "subdir": "linux-64", + "timestamp": 1539466794244, + "version": "3.0.1" + }, + "async-timeout-3.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bb5c64fba1d3ce30660b223705a3c03b", + "name": "async-timeout", + "sha256": "d1bbdc8bbdbfc59b5afab3f0e0c6a50467d9e671ea7d08ac0abc2adfc09e3981", + "size": 13195, + "subdir": "linux-64", + "timestamp": 1611675346486, + "version": "3.0.1" + }, + "async-timeout-3.0.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e924e2ee6e013b4a319c0e718ad35e1b", + "name": "async-timeout", + "sha256": "6c198fbb0245ea3ce9901ad29b77b00a3720a266c706de74336f1666512e20e7", + "size": 12162, + "subdir": "linux-64", + "timestamp": 1572437164699, + "version": "3.0.1" + }, + "async-timeout-3.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5c10054e6edf38c356cf501693d8e0bc", + "name": "async-timeout", + "sha256": "e7bfa75ad308e5c769462141d08aff07a4a9f26e5b44e465d63c40faee7a5d9a", + "size": 13245, + "subdir": "linux-64", + "timestamp": 1611675371571, + "version": "3.0.1" + }, + "async-timeout-3.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b2c2d05970d43179b7469a87f8bc7c53", + "name": "async-timeout", + "sha256": "843bb5d61235b2c03a7483ffe133b1560c9f69dac7006452e2a3d2c8aa83f4a3", + "size": 13254, + "subdir": "linux-64", + "timestamp": 1611675303382, + "version": "3.0.1" + }, + "async-timeout-4.0.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "273716a6c6e9bad8b2668cbd40f1fa81", + "name": "async-timeout", + "sha256": "57ed360faff7b587c90c4d336abb2dc7e5a05c823adc2d83fa7a7ddc6c8f3d25", + "size": 11767, + "subdir": "linux-64", + "timestamp": 1664876431563, + "version": "4.0.2" + }, + "async-timeout-4.0.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ce5efc955468d19fc66131c48206ed62", + "name": "async-timeout", + "sha256": "7bb15be90a7650f7ccaa0e1c05a9b1a17f2a6aa24d09b8f492332c150f4bdc49", + "size": 13523, + "subdir": "linux-64", + "timestamp": 1676826974110, + "version": "4.0.2" + }, + "async-timeout-4.0.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a793b5edd6bf81c64dd20559c1b7ae01", + "name": "async-timeout", + "sha256": "cd3cb99d200ce077d1f2aebd1ff6a648ff4ab486277534252c4ef20ed362b1fd", + "size": 11664, + "subdir": "linux-64", + "timestamp": 1664876455852, + "version": "4.0.2" + }, + "async-timeout-4.0.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "567fef3753a8ba7db9834a33f59e2e2c", + "name": "async-timeout", + "sha256": "1cc77dd9332b440337353e703f2f7f29821530399eebbb7dcdd7bbf5982174d8", + "size": 11701, + "subdir": "linux-64", + "timestamp": 1664876480012, + "version": "4.0.2" + }, + "async-timeout-4.0.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4a415c0e86274f84b1732b2844e7bb5b", + "name": "async-timeout", + "sha256": "fcb0703830623a1802f7d362b882f0f028723d401dbd9dfba49ce299349a8eb7", + "size": 11710, + "subdir": "linux-64", + "timestamp": 1664876394563, + "version": "4.0.2" + }, + "async_generator-1.10-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2199684a3393df34e41ec25ccf4d14f8", + "name": "async_generator", + "sha256": "8a99a4e0959e2e841e901750ef3f83007dc4b3b7ab5132f50733e1a16720ec9b", + "size": 38706, + "subdir": "linux-64", + "timestamp": 1540861518525, + "version": "1.10" + }, + "async_generator-1.10-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cf106f3fc66f85e4b9dd048a83ee7654", + "name": "async_generator", + "sha256": "12e52301240bb3122f9a8642b344bddf813eda8c7cab34eccb6028a4e9298fee", + "size": 38674, + "subdir": "linux-64", + "timestamp": 1540861479372, + "version": "1.10" + }, + "asyncpg-0.12.0-py35hb66dd5d_0.tar.bz2": { + "build": "py35hb66dd5d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e8a52c92698a69bdd922c0e78abc060e", + "name": "asyncpg", + "sha256": "46609fd48d3572e0137198fa33109ff54bf5e8ba5d95a52ee24b7536b609cd68", + "size": 796097, + "subdir": "linux-64", + "timestamp": 1507238629916, + "version": "0.12.0" + }, + "asyncpg-0.12.0-py36hf34a55f_0.tar.bz2": { + "build": "py36hf34a55f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ccaf4d1f32fa5491e0ccd70264219830", + "name": "asyncpg", + "sha256": "a8233ce1f01869af8f75f182b4b86b4c82aba749d3397c1d27fb73e6c61b0848", + "size": 810124, + "subdir": "linux-64", + "timestamp": 1507238630141, + "version": "0.12.0" + }, + "asyncpg-0.13.0-py35ha95cecb_0.tar.bz2": { + "build": "py35ha95cecb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a3b8f03429213fee47e6a2527b0fb710", + "name": "asyncpg", + "sha256": "68396c1ebbc0ba2abc8f051a24b726286187eb1070faa83fe434e2eac5c3ac2f", + "size": 818029, + "subdir": "linux-64", + "timestamp": 1511843181136, + "version": "0.13.0" + }, + "asyncpg-0.13.0-py36h98f7829_0.tar.bz2": { + "build": "py36h98f7829_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3896c50142b06a4f9744f195e458b377", + "name": "asyncpg", + "sha256": "17b7ed84b736fbd80d7d6b64bdb644fe014625e84170391accd45f0cce9920d8", + "size": 831746, + "subdir": "linux-64", + "timestamp": 1511843172973, + "version": "0.13.0" + }, + "asyncpg-0.14.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8fa35e48852b61b8e1f2cce550ab9eb0", + "name": "asyncpg", + "sha256": "54a96e47a32d2a3442298c4db32a1047c8d08ef51c20561d8ab24eb681faea8f", + "size": 838013, + "subdir": "linux-64", + "timestamp": 1519481562311, + "version": "0.14.0" + }, + "asyncpg-0.14.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e8c21eab1581465c8cb81b8dcc2cdc21", + "name": "asyncpg", + "sha256": "e1466d317174dfbf44a55d739746e1488528f13457d390fcf8f13dc808f519dc", + "size": 848979, + "subdir": "linux-64", + "timestamp": 1519481547108, + "version": "0.14.0" + }, + "asyncpg-0.15.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ba7fab73791a3661142d07773e02283b", + "name": "asyncpg", + "sha256": "ca247c74823faeb0d7e5d76ec14ebda05bb69e5ce721ba5dd312af4c8a1024a4", + "size": 838964, + "subdir": "linux-64", + "timestamp": 1519369500853, + "version": "0.15.0" + }, + "asyncpg-0.15.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a903794d2ab6d49d4421fc7faa737fcb", + "name": "asyncpg", + "sha256": "528546169feb4a9c5935037dc3aa7c0de44f04205ef787a024744672e2d582ee", + "size": 850447, + "subdir": "linux-64", + "timestamp": 1519369491808, + "version": "0.15.0" + }, + "asyncpg-0.16.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2869e33df7a1c2513ac2a73c70419e0c", + "name": "asyncpg", + "sha256": "e48683bcd863a9bf16d163a95b083dbe348852ab9443fd1d4816ed42fc184d5a", + "size": 851753, + "subdir": "linux-64", + "timestamp": 1529425277774, + "version": "0.16.0" + }, + "asyncpg-0.16.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "51d1d73f1a8134d27f89109f48df9e02", + "name": "asyncpg", + "sha256": "ba5e0929e1e81bacdf921b69293ef8eb75340acacb3f16e9d7b91d6e9d5cce59", + "size": 866869, + "subdir": "linux-64", + "timestamp": 1529425236222, + "version": "0.16.0" + }, + "asyncpg-0.16.0-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4083bdd7c44e111e733ce86865ede782", + "name": "asyncpg", + "sha256": "5c701886657edade14771397ebc4ef6215f9baafe3be31a84c7f0d4c4c4684ca", + "size": 864751, + "subdir": "linux-64", + "timestamp": 1530738483174, + "version": "0.16.0" + }, + "asyncpg-0.17.0-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "da54a31c1fe6019de26077e8b30ada65", + "name": "asyncpg", + "sha256": "b1d2ee5f79906c8953304a5a02fa7c6b941d04ca16216c47ba94a4b18254e821", + "size": 854745, + "subdir": "linux-64", + "timestamp": 1536170243361, + "version": "0.17.0" + }, + "asyncpg-0.17.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "424b5f5829ed528348a3314b7df83b8a", + "name": "asyncpg", + "sha256": "f533e9da8a7a3e26cb2a990ec5ffe93924a484fe8f134e8c3850fa6846ef054b", + "size": 870187, + "subdir": "linux-64", + "timestamp": 1536170563656, + "version": "0.17.0" + }, + "asyncpg-0.17.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "faf0f99f1531ea11a35e992136b61ef3", + "name": "asyncpg", + "sha256": "a5a61c5802fec822c09bdbf14a542ccd77b79c1eab92a5a411daeb188f672fee", + "size": 867222, + "subdir": "linux-64", + "timestamp": 1536170638790, + "version": "0.17.0" + }, + "asyncpg-0.17.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ff644432f130537c6665c854dd2a092a", + "name": "asyncpg", + "sha256": "5c186a635f454cad606792a4de909791873440272549bb365134135fdda341f3", + "size": 914953, + "subdir": "linux-64", + "timestamp": 1572860800615, + "version": "0.17.0" + }, + "asyncpg-0.18.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e6ebbc3d766d87126ce1c37b72049326", + "name": "asyncpg", + "sha256": "4e9a75107b0bbbcaba05c5fb8ff53952c325d857455b842eab2d6dafe58870f0", + "size": 964229, + "subdir": "linux-64", + "timestamp": 1545163251544, + "version": "0.18.2" + }, + "asyncpg-0.18.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "85a09972c6385d75cdb3ba6aa723b1c9", + "name": "asyncpg", + "sha256": "f4730ca7d0b4002c1e77404368c66ea3f97a3ed6a3909252a4649cab5a0eeb79", + "size": 955105, + "subdir": "linux-64", + "timestamp": 1545163249940, + "version": "0.18.2" + }, + "asyncpg-0.18.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "424772d543d45731d11a28738444cfc4", + "name": "asyncpg", + "sha256": "5926b7cee2b5682d2b6150bfb68a39fb0615e13d8b496af7f44143a382c662d0", + "size": 966684, + "subdir": "linux-64", + "timestamp": 1547222630876, + "version": "0.18.3" + }, + "asyncpg-0.18.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a646e72c7d3523c9451dfa49f18827f7", + "name": "asyncpg", + "sha256": "81ad23953c478b1d93473e30848f9e0bd9d440378e690147306821cb402c6f4e", + "size": 965971, + "subdir": "linux-64", + "timestamp": 1547222630830, + "version": "0.18.3" + }, + "asyncpg-0.20.1-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "30c11bb2d57db0142489f1909749f836", + "name": "asyncpg", + "sha256": "dc7b40f8a348f1f9132a94c87598abd913f064f56750144c106049f445d231f9", + "size": 1094298, + "subdir": "linux-64", + "timestamp": 1611675407880, + "version": "0.20.1" + }, + "asyncpg-0.20.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8a23329dda8a9877ad1e128e9a520133", + "name": "asyncpg", + "sha256": "3f8e4f8c3c96102f43977ac336b499a33cbb12044896fd76e246fea964029102", + "size": 1090606, + "subdir": "linux-64", + "timestamp": 1591917879783, + "version": "0.20.1" + }, + "asyncpg-0.20.1-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "561f946c02d60e8cf32bac09311967a8", + "name": "asyncpg", + "sha256": "a675708ba8e32769eac240653b7b92721dffceddd309b0b79e456db086da2aa6", + "size": 1089644, + "subdir": "linux-64", + "timestamp": 1611674957635, + "version": "0.20.1" + }, + "asyncpg-0.20.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "584d9689bf5ee142ce653c6a5eccd2b6", + "name": "asyncpg", + "sha256": "ffc0ba41f80ff52bd906d24636d7631a66e02949a72d8436a8d39c53ed8f9fd7", + "size": 1086856, + "subdir": "linux-64", + "timestamp": 1591917872286, + "version": "0.20.1" + }, + "asyncpg-0.20.1-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f85c7ed5b778f3641af1b221a201a138", + "name": "asyncpg", + "sha256": "2117580fa432bb021c514fd31353f76b3e82b232c0559e90300e00404560cda3", + "size": 1134134, + "subdir": "linux-64", + "timestamp": 1611674957542, + "version": "0.20.1" + }, + "asyncpg-0.20.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "74462b60208cf7ae600da964ba04c7c1", + "name": "asyncpg", + "sha256": "a53454fd6671433d399faef00239d3a553f9282b8b6cf9379770ef563a7b0064", + "size": 1132626, + "subdir": "linux-64", + "timestamp": 1591917825262, + "version": "0.20.1" + }, + "asyncpg-0.20.1-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "26821d053810fed0658fea3241fb5545", + "name": "asyncpg", + "sha256": "b9b6a943766afe68e2311c087477dbb410d82cb940fea587f271d5af6efa6cbd", + "size": 1130891, + "subdir": "linux-64", + "timestamp": 1611675408848, + "version": "0.20.1" + }, + "asyncpg-0.21.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a8eeb088d265217fba2b1252dc4cea5d", + "name": "asyncpg", + "sha256": "654ff22d9d05d9e0b0a859c1be26c514080d5983d6d3afd5e9145a024802f546", + "size": 1002679, + "subdir": "linux-64", + "timestamp": 1600298307703, + "version": "0.21.0" + }, + "asyncpg-0.21.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "91ff58046420e5a1e281bbc0c4902ca4", + "name": "asyncpg", + "sha256": "63e8d7f51acc7b73a2772323683aa5b24be333880fd75b97e28b040c04de4f02", + "size": 996398, + "subdir": "linux-64", + "timestamp": 1600298295531, + "version": "0.21.0" + }, + "asyncpg-0.21.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "952b5500adaba54327d9e2d8918427a8", + "name": "asyncpg", + "sha256": "e47adc3231a3c3d2cfdd3f7c2e6550ae5e01502606f5149b8864a498bd8fe2b4", + "size": 1056604, + "subdir": "linux-64", + "timestamp": 1600298287151, + "version": "0.21.0" + }, + "asyncpg-0.22.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "typing_extensions" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2b8dd3b3ecf6d90bc77feb1d90103dec", + "name": "asyncpg", + "sha256": "ef8b00db184fadd85f6d912b8062e639b849094e4644e32af3b234e1bee6fd88", + "size": 1046883, + "subdir": "linux-64", + "timestamp": 1613246955002, + "version": "0.22.0" + }, + "asyncpg-0.22.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5a8ce08e398c4d85ed684ece8c66dff4", + "name": "asyncpg", + "sha256": "402b78f5200b97581e9cf5c1567e1b9406dd4042a7c85f5e6e677607fedc9018", + "size": 1044188, + "subdir": "linux-64", + "timestamp": 1613247117003, + "version": "0.22.0" + }, + "asyncpg-0.22.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "typing_extensions" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1b4971a2bdec673688105b34f2823ea4", + "name": "asyncpg", + "sha256": "fcc94727dc596beda6143dc9526b09cd8f6264dfa9ceb191a7e68ad46d00138c", + "size": 1087213, + "subdir": "linux-64", + "timestamp": 1613246606232, + "version": "0.22.0" + }, + "asyncpg-0.22.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "typing_extensions" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a2f52771aa7661ad5be3a9b661eb30e7", + "name": "asyncpg", + "sha256": "93ed14006aba18feed5975ab664ebbed7f643deccfcdd622cdcbb3b30823818d", + "size": 1073538, + "subdir": "linux-64", + "timestamp": 1613247111157, + "version": "0.22.0" + }, + "asyncpg-0.23.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4beb8fce5ab54097baf4123371121c8e", + "name": "asyncpg", + "sha256": "2e74a981e9823f9e0eb686c4beff3d9f22025df23bfde131c1e22f7957cc70ee", + "size": 2707228, + "subdir": "linux-64", + "timestamp": 1640788362236, + "version": "0.23.0" + }, + "asyncpg-0.23.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "typing_extensions >=3.7.4.3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a5b1ef34c96ee1d0df5cebfc58cd0057", + "name": "asyncpg", + "sha256": "b2acd6111e988642a6ce8f7bd037578a6e3a4f277a192d33665799c127c3b190", + "size": 1049469, + "subdir": "linux-64", + "timestamp": 1621368531630, + "version": "0.23.0" + }, + "asyncpg-0.23.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.7.4.3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "05acc243583f278e3cf086145d1d8551", + "name": "asyncpg", + "sha256": "85e4976e087b1e0b35755ee8b896294deebe3059d5464b81dcc6f2af8ea374ea", + "size": 1043615, + "subdir": "linux-64", + "timestamp": 1621368400272, + "version": "0.23.0" + }, + "asyncpg-0.23.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5f33b2615632db4405bb1a691c698c83", + "name": "asyncpg", + "sha256": "ba867661cdba3a191ae9a3730769c118ca6efed6ef23ec6b53cb48312fcb7f1b", + "size": 1076344, + "subdir": "linux-64", + "timestamp": 1621368529426, + "version": "0.23.0" + }, + "asyncpg-0.23.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6929f03fe7fca93d829fddea1fb2e47d", + "name": "asyncpg", + "sha256": "e30f9cc6b49f70597a680cc69f5888e51388a0adc734013cdc0ced72c444ab1b", + "size": 1086157, + "subdir": "linux-64", + "timestamp": 1621368540525, + "version": "0.23.0" + }, + "asyncpg-0.27.0-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "69b0ee4eb119d74d51f2816316f2a3b4", + "name": "asyncpg", + "sha256": "07bdfecc6a6a45a9e7a682f905cc1cc80c8eaf2c68a32a140ebbfad9ef073c71", + "size": 676853, + "subdir": "linux-64", + "timestamp": 1670955811455, + "version": "0.27.0" + }, + "asyncpg-0.27.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f9c563d03d35b40040a8b8d18d89fcba", + "name": "asyncpg", + "sha256": "8be54e751bd8c56dd8c90fb8a40380a550b4ad533206644b1cd866fd87a12973", + "size": 707605, + "subdir": "linux-64", + "timestamp": 1676843250770, + "version": "0.27.0" + }, + "asyncpg-0.27.0-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.7.4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "886e37efe0f4c1f9e580fad74d43db40", + "name": "asyncpg", + "sha256": "5ffaf36bb8e0a766331d812a0f756b310f4b66ff91a765fe15a9ba5327ac746f", + "size": 678278, + "subdir": "linux-64", + "timestamp": 1670955708432, + "version": "0.27.0" + }, + "asyncpg-0.27.0-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "700b3e9c2e694108a1281a67a56aceb1", + "name": "asyncpg", + "sha256": "9565fd08508578efdda17a2663bd19e371b800e40e7b8c3f679e760605c4ab19", + "size": 714665, + "subdir": "linux-64", + "timestamp": 1670955864884, + "version": "0.27.0" + }, + "asyncpg-0.27.0-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "63b8342587899dcedd7a238018c21b16", + "name": "asyncpg", + "sha256": "a9c289b9c97cce2ff1ddde61554b763299d2b4e87e54046e13c3845e17983de6", + "size": 691120, + "subdir": "linux-64", + "timestamp": 1670955760033, + "version": "0.27.0" + }, + "asyncpgsa-0.17.0-py35h9bdfc20_0.tar.bz2": { + "build": "py35h9bdfc20_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.12.0,<0.13", + "python >=3.5,<3.6.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "16ec38903fb4d039d8c5ee5b72ea2ec3", + "name": "asyncpgsa", + "sha256": "91508bb6f8c174cc1630d305cc66d06b212b2df194c4bce34177a8daa8b02e1c", + "size": 23213, + "subdir": "linux-64", + "timestamp": 1507239572244, + "version": "0.17.0" + }, + "asyncpgsa-0.17.0-py36h31b4eaa_0.tar.bz2": { + "build": "py36h31b4eaa_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.12.0,<0.13", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "aa852d5000a14ae6681c0c2f98b5ab27", + "name": "asyncpgsa", + "sha256": "64995d59efe249ae789d753dfb234fd6803d45bf169d3f1a77349fe0cdca5542", + "size": 23179, + "subdir": "linux-64", + "timestamp": 1507239583505, + "version": "0.17.0" + }, + "asyncpgsa-0.18.1-py35h3cb9e5d_0.tar.bz2": { + "build": "py35h3cb9e5d_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.12.0,<0.13", + "python >=3.5,<3.6.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1a4f4c9db5c408e8656343c531543fb6", + "name": "asyncpgsa", + "sha256": "388d71c6f293fc2c4ea1c14a30593351ae0784640f2a00ce0a010f02524854f1", + "size": 22127, + "subdir": "linux-64", + "timestamp": 1511982078424, + "version": "0.18.1" + }, + "asyncpgsa-0.18.1-py36hb35d077_0.tar.bz2": { + "build": "py36hb35d077_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.12.0,<0.13", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "23b3b4d9918184c4950d878a6676fbee", + "name": "asyncpgsa", + "sha256": "d242de2adc9842c1cbb0360471649e142cddd5de0e967cc181fd7f3f638de9da", + "size": 22106, + "subdir": "linux-64", + "timestamp": 1511982082920, + "version": "0.18.1" + }, + "asyncpgsa-0.19.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.14.0,<0.15", + "python >=3.5,<3.6.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "969a82f2525ad9165cba11a7b46516bf", + "name": "asyncpgsa", + "sha256": "83aa96fcbc31b67daf56210030adfef9200120d8fc92eeb2def4ae2cb575cad8", + "size": 22361, + "subdir": "linux-64", + "timestamp": 1519481668306, + "version": "0.19.2" + }, + "asyncpgsa-0.19.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.14.0,<0.15", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1ebac6d0c0d9a360eb25db3962fab62c", + "name": "asyncpgsa", + "sha256": "c590a4fc4a2a45c4e3853b7448a87c0b8c75dc6bc4103ba1e9c4f6ac855d2fb2", + "size": 22364, + "subdir": "linux-64", + "timestamp": 1519481630707, + "version": "0.19.2" + }, + "asyncpgsa-0.22.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.15.0,<0.16", + "python >=3.5,<3.6.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "03d72e093e78e2653339ddf760052eeb", + "name": "asyncpgsa", + "sha256": "d23cfb1732cedb2a33ec403ecf77a239dfeec31f3f145c39620d3680c2c48b73", + "size": 21981, + "subdir": "linux-64", + "timestamp": 1523436488096, + "version": "0.22.0" + }, + "asyncpgsa-0.22.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.15.0,<0.16", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f217799848464d54daf9a4f28207ec0c", + "name": "asyncpgsa", + "sha256": "705957c490fa55859bfce13333c5deba18b2518babfaaa3ed40dbc7219e8cac9", + "size": 21957, + "subdir": "linux-64", + "timestamp": 1523436478694, + "version": "0.22.0" + }, + "asyncpgsa-0.23.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.15.0,<0.16", + "python >=3.5,<3.6.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7f6b2559e76dddbadfff83ddd173cc2e", + "name": "asyncpgsa", + "sha256": "5c3955e5da80f2c85f08290a6d0ff7056a9ca646ffcd1e1019ded8039edd6720", + "size": 21865, + "subdir": "linux-64", + "timestamp": 1526929622961, + "version": "0.23.0" + }, + "asyncpgsa-0.23.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.15.0,<0.16", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "aeaab5171b2e9ebc7c6594a8a6f47414", + "name": "asyncpgsa", + "sha256": "ae859adae53ea436ee14860205470419111ff774d328623ca59a464a1c3d7b42", + "size": 21865, + "subdir": "linux-64", + "timestamp": 1526929590994, + "version": "0.23.0" + }, + "asyncpgsa-0.23.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.15.0,<0.17", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3c164a9d1f6e26c81af6b4f12a74b945", + "name": "asyncpgsa", + "sha256": "7d6d9ac5e87e4f12fa620f3da0cd9d2844482dd91e6ccd1ec91db141502f5f7a", + "size": 21901, + "subdir": "linux-64", + "timestamp": 1530738513732, + "version": "0.23.0" + }, + "asyncpgsa-0.24.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.16.0,<0.17", + "python >=3.5,<3.6.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fa0e43617eb7f63016ebc36fdacac9e8", + "name": "asyncpgsa", + "sha256": "86bb19cb64a41b47b561c1b3959a20c65f48e9ff5e96232ebe0da0470698170f", + "size": 22043, + "subdir": "linux-64", + "timestamp": 1536111084566, + "version": "0.24.0" + }, + "asyncpgsa-0.24.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.16.0,<0.17", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8f16fe0e4e54373771ba17b66f5959ca", + "name": "asyncpgsa", + "sha256": "8e38ebb1405154af2e6a1871af649a9f4114486134ebcde33909e7c86ec73906", + "size": 22067, + "subdir": "linux-64", + "timestamp": 1536111011299, + "version": "0.24.0" + }, + "asyncpgsa-0.24.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.16.0,<0.17", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9ed8dfc47b0e40810d00e72096f67954", + "name": "asyncpgsa", + "sha256": "32b1a92a65193bbe4002753ed5ca71b3d59b8c1c30b3bcc10830ca26d755eadf", + "size": 22038, + "subdir": "linux-64", + "timestamp": 1536111081705, + "version": "0.24.0" + }, + "asyncpgsa-0.25.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.16.0,<0.17", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7a9868bffef96f162c11eeb2e33329e4", + "name": "asyncpgsa", + "sha256": "bb3e5bc877e06c4ace345cf81d042b85b59c4beaea0209c61bf4b553f39fdbdf", + "size": 22277, + "subdir": "linux-64", + "timestamp": 1540957360097, + "version": "0.25.2" + }, + "asyncpgsa-0.25.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.16.0,<0.17", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b2466d21ff20de0e8cf22dbeeb13f825", + "name": "asyncpgsa", + "sha256": "2e67e999c884308a051e8199bbcf5daf7c7104c39a815af63aef5ade6e7c6703", + "size": 22235, + "subdir": "linux-64", + "timestamp": 1540957406995, + "version": "0.25.2" + }, + "asyncpgsa-0.26.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4056aa667824dfbf4f3456f70977ede2", + "name": "asyncpgsa", + "sha256": "e983b4029ea9c4ba38285a5eb1cdcc8b008b922ee46d53f85ccb3fd23a8f36d1", + "size": 25633, + "subdir": "linux-64", + "timestamp": 1552357522635, + "version": "0.26.0" + }, + "asyncpgsa-0.26.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a86ee031f4c7e8ab5a00824030a924be", + "name": "asyncpgsa", + "sha256": "2506223657fd13a497489044fadf1fe32407f0e55c9feedd8b67a512e8071ba8", + "size": 25609, + "subdir": "linux-64", + "timestamp": 1552357436809, + "version": "0.26.0" + }, + "asyncpgsa-0.26.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.8,<3.9.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0d081740105c27c2e2bb4fc12913a56c", + "name": "asyncpgsa", + "sha256": "c000864b583dd0fa8afa07d76cedc0a824d881e4bd84a71d2fd0d9a7ad8e5b13", + "size": 23836, + "subdir": "linux-64", + "timestamp": 1573738145460, + "version": "0.26.0" + }, + "asyncpgsa-0.26.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "61a1dd3052380355b664a6539c430dcc", + "name": "asyncpgsa", + "sha256": "65752001d090d309f923425379d63a42341460b9e1c62b37b0da3b6535569ce3", + "size": 26406, + "subdir": "linux-64", + "timestamp": 1573962150940, + "version": "0.26.1" + }, + "asyncpgsa-0.26.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4cbb0903840fd0fe292c0a5a5c8bf6b3", + "name": "asyncpgsa", + "sha256": "ee647da10ac1768c9866313555e8ce82976cd62cc948c38f1f30eab896874d0f", + "size": 26394, + "subdir": "linux-64", + "timestamp": 1573962165852, + "version": "0.26.1" + }, + "asyncpgsa-0.26.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.8,<3.9.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "336be6bafd2ccaf5dd0d7a9b82c286b8", + "name": "asyncpgsa", + "sha256": "e576679e2ce9bd0364d9802d924f61c1d76589a07143e76f993d1d461fbf9235", + "size": 26518, + "subdir": "linux-64", + "timestamp": 1573962170343, + "version": "0.26.1" + }, + "asyncpgsa-0.26.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f9c17b7eb1cdf21bf94732592e0e5a56", + "name": "asyncpgsa", + "sha256": "20f8971ab1d916be1285abab4f66e4a8a5174ce4ab0de1241c8bf4fcb3b4aff5", + "size": 26424, + "subdir": "linux-64", + "timestamp": 1592209009382, + "version": "0.26.3" + }, + "asyncpgsa-0.26.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ecdd43f9b246b3eaee3c3f655591dff6", + "name": "asyncpgsa", + "sha256": "7e34995a54bcd715a34898545a0436cbbf43800e97acf1c1d48b6d45c37ad157", + "size": 26719, + "subdir": "linux-64", + "timestamp": 1613153888141, + "version": "0.26.3" + }, + "asyncpgsa-0.26.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "47cbdf1b47a8a059378a9b1e1b417c4c", + "name": "asyncpgsa", + "sha256": "7010b3dc3f1ff213f2dbb3850d5d2fd071ce91a1d97ef86c85c423d8b2f5cf8c", + "size": 26407, + "subdir": "linux-64", + "timestamp": 1592209011413, + "version": "0.26.3" + }, + "asyncpgsa-0.26.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b5e32ef72471f6e75232564f2ec26fca", + "name": "asyncpgsa", + "sha256": "4f74f5432057da27f1894b04ba324aab537d1c35e48fbc192fd3c6854f19ba96", + "size": 26697, + "subdir": "linux-64", + "timestamp": 1613154337180, + "version": "0.26.3" + }, + "asyncpgsa-0.26.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.8,<3.9.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "538759863619be4efaa7a2e88f0b4418", + "name": "asyncpgsa", + "sha256": "c6d0cafb944c9ca3ba3adeea70289dea717ddeef3ccc8d51cdfeab5bb80d43cf", + "size": 26541, + "subdir": "linux-64", + "timestamp": 1592209009442, + "version": "0.26.3" + }, + "asyncpgsa-0.26.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.8,<3.9.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "33beaa7b36a69477285e655237d8801d", + "name": "asyncpgsa", + "sha256": "b9aa6b84b5a4f7880953163a7d3a8647b735e59be6b4dd9fdf18e38c5d544f70", + "size": 26820, + "subdir": "linux-64", + "timestamp": 1613154343792, + "version": "0.26.3" + }, + "asyncpgsa-0.26.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.9,<3.10.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f62ae5ee81189950b3e9b8963277db15", + "name": "asyncpgsa", + "sha256": "c390855fa5cb215cbd1d548983062ac9ef6957b7cac5f69d59be39fb64ecd1e3", + "size": 26950, + "subdir": "linux-64", + "timestamp": 1613154336061, + "version": "0.26.3" + }, + "asyncpgsa-0.27.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "793ced0740e4ca7c9e6677be8cdeb5fd", + "name": "asyncpgsa", + "sha256": "ef705f9c8622693e1d7e3bac967e39a391fbae04b15056f15aba5c94258c7b67", + "size": 24155, + "subdir": "linux-64", + "timestamp": 1613245827756, + "version": "0.27.0" + }, + "asyncpgsa-0.27.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fe748e59050e9129736a62b6e99bb08d", + "name": "asyncpgsa", + "sha256": "d62f74e618e956280b0724ee8c62193fd95cc2aa90a60087236cc0cea92ae633", + "size": 24138, + "subdir": "linux-64", + "timestamp": 1613246323012, + "version": "0.27.0" + }, + "asyncpgsa-0.27.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.8,<3.9.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a3b03d93a8dd82af5f53682bda20a213", + "name": "asyncpgsa", + "sha256": "c7adc49b5b2990bf34a9a98306cc1807a365aa64b97f8282c7da5b71b0b02269", + "size": 24288, + "subdir": "linux-64", + "timestamp": 1613246320343, + "version": "0.27.0" + }, + "asyncpgsa-0.27.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.9,<3.10.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d3fb90be2fe4199ac269d6d573b5e14d", + "name": "asyncpgsa", + "sha256": "dc320e58515dfe680700ebd53244cfb0382816e2328a71a439b99917faf359db", + "size": 24371, + "subdir": "linux-64", + "timestamp": 1613246331655, + "version": "0.27.0" + }, + "asyncpgsa-0.27.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.10,<3.11.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e9223ea94b884c32c0f5c6dcd6339893", + "name": "asyncpgsa", + "sha256": "d90b8ee0956fbf0c95e94a2f08e11622f3f55a09694cb4e655664fd08b913613", + "size": 24520, + "subdir": "linux-64", + "timestamp": 1640803462171, + "version": "0.27.1" + }, + "asyncpgsa-0.27.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.11,<3.12.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "01e47309cac3b252061afe13e73e0526", + "name": "asyncpgsa", + "sha256": "780d75b68911a102d70ac1546cecb025a75b5a6aab874a5a6ea5118f9c2de779", + "size": 29491, + "subdir": "linux-64", + "timestamp": 1676846846875, + "version": "0.27.1" + }, + "asyncpgsa-0.27.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a627ebbb53c0db8b653bb1907f27fccd", + "name": "asyncpgsa", + "sha256": "a66e0dc06365449f3a3fecfdac09fd6b7afc88899a16665790cebaa062f221f2", + "size": 24200, + "subdir": "linux-64", + "timestamp": 1614361181049, + "version": "0.27.1" + }, + "asyncpgsa-0.27.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5086e4c7200b520166a4e1d6faed4850", + "name": "asyncpgsa", + "sha256": "ff86a1fcc90ec62ef67a2c9b65cdb7685c7b5262c3d5b929e43fba0f51cd7760", + "size": 24186, + "subdir": "linux-64", + "timestamp": 1614361159178, + "version": "0.27.1" + }, + "asyncpgsa-0.27.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.8,<3.9.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "acc60afa156f73ec888f5ae2b9487611", + "name": "asyncpgsa", + "sha256": "8f53c1bcb9588e371b62a87d494e0b132d6860a6fe04fb1779a52271f81717e8", + "size": 24336, + "subdir": "linux-64", + "timestamp": 1614361161590, + "version": "0.27.1" + }, + "asyncpgsa-0.27.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.9,<3.10.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "73fc28d0cc1b594d842ec82f24ed07f7", + "name": "asyncpgsa", + "sha256": "2e0a707fb7bd752c63caec300f0136175114a168e44d98d2a2d86be329fa49a3", + "size": 24399, + "subdir": "linux-64", + "timestamp": 1614360112003, + "version": "0.27.1" + }, + "asynctest-0.11.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "956451d9c1d89762a35aa9591c781baa", + "name": "asynctest", + "sha256": "65138f6c38a89892f3ae18c0a0b83a5e5b6b5ad8f5840658b77716c6e840f01a", + "size": 37055, + "subdir": "linux-64", + "timestamp": 1543150776895, + "version": "0.11.1" + }, + "asynctest-0.11.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0b68f21e785be5cd8d68fc2195833fca", + "name": "asynctest", + "sha256": "ad4d42c454d4adb6d1eea506df6247bcf2590b7a07846f20d73b44a5554bf9db", + "size": 37012, + "subdir": "linux-64", + "timestamp": 1543150731451, + "version": "0.11.1" + }, + "asynctest-0.12.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f6289d66c2f04f880e103fe8b8d04ed4", + "name": "asynctest", + "sha256": "a377eaf4bf9cfe958cc9b43a84b0c108d85925b7c5120c3ddc50cbae30619bc5", + "size": 44426, + "subdir": "linux-64", + "timestamp": 1543147007418, + "version": "0.12.2" + }, + "asynctest-0.12.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a10bf4c10db19e83a15151e136402212", + "name": "asynctest", + "sha256": "f3422cf915a973cde4f51b9b84dc242f874c1e88138214cedfb42d0aa84d8abd", + "size": 44490, + "subdir": "linux-64", + "timestamp": 1543146987601, + "version": "0.12.2" + }, + "at-spi2-atk-2.34.2-hdb5d850_0.tar.bz2": { + "build": "hdb5d850_0", + "build_number": 0, + "depends": [ + "at-spi2-core >=2.36.0,<2.37.0a0", + "atk-1.0 >=2.36.0", + "dbus >=1.13.18,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=7.5.0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "891ec055725e20f7de64a458094e7c3a", + "name": "at-spi2-atk", + "sha256": "2f36f4ddf1fd58c7e558c0065cd924e4e003a857f64b54aa59cc265dcb6aa77d", + "size": 310358, + "subdir": "linux-64", + "timestamp": 1632416503727, + "version": "2.34.2" + }, + "at-spi2-core-2.36.0-hdb5d850_1.tar.bz2": { + "build": "hdb5d850_1", + "build_number": 1, + "depends": [ + "dbus >=1.13.18,<2.0a0", + "gettext", + "glib >=2.69.1,<3.0a0", + "gobject-introspection", + "libgcc-ng >=7.5.0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "05d2b9584c65761e8acda0cc16595541", + "name": "at-spi2-core", + "sha256": "b0ebd3e9f45d30c33a1fc3e54f27c1a81a1c250f7fced1a21735db5f6e9b5d15", + "size": 510027, + "subdir": "linux-64", + "timestamp": 1632414669897, + "version": "2.36.0" + }, + "atk-1.0-2.36.0-h28cd5cc_0.tar.bz2": { + "build": "h28cd5cc_0", + "build_number": 0, + "constrains": [ + "atk-1.0 2.36.0" + ], + "depends": [ + "glib >=2.65.0,<3.0a0", + "gobject-introspection 1.*", + "libgcc-ng >=7.3.0", + "ninja" + ], + "license": "LGPL-2.0-or-later", + "md5": "e403106108523a94d9f013c072faae7a", + "name": "atk-1.0", + "sha256": "9bb7d48b549db647cc942db7bcbb5150bca0fcbba1e396a608b63e25590173ce", + "size": 535626, + "subdir": "linux-64", + "timestamp": 1596107197873, + "version": "2.36.0" + }, + "atk-1.0-2.36.0-ha1a6a79_0.tar.bz2": { + "build": "ha1a6a79_0", + "build_number": 0, + "constrains": [ + "atk-1.0 2.36.0" + ], + "depends": [ + "glib >=2.69.1,<3.0a0", + "gobject-introspection 1.*", + "libgcc-ng >=7.5.0", + "ninja" + ], + "license": "LGPL-2.0-or-later", + "md5": "387649f0dd6e7540ac4ec9ebb40f89c4", + "name": "atk-1.0", + "sha256": "0b93787f45141849af464f0381bdf2d0d2a153d515d5ed5c9c3b1732ba6648b1", + "size": 550099, + "subdir": "linux-64", + "timestamp": 1631792905282, + "version": "2.36.0" + }, + "atk-2.36.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "atk-1.0 2.36.0.*" + ], + "license": "LGPL-2.0-or-later", + "md5": "88b0ece9d5f60e69225d5391a225845e", + "name": "atk", + "sha256": "2f942525fd089b692b7e19a14892b8053abced861565dee119aa10b5600d8fff", + "size": 17085, + "subdir": "linux-64", + "timestamp": 1596107200505, + "version": "2.36.0" + }, + "atk-2.36.0-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "atk-1.0 2.36.0.*" + ], + "license": "LGPL-2.0-or-later", + "md5": "bbeb10f9f9ba4d9652577411b23f20ba", + "name": "atk", + "sha256": "653c3f7197740e31bc083d3af81cc8190b657a6322713e9828b388ae05a11ef6", + "size": 17557, + "subdir": "linux-64", + "timestamp": 1631792907180, + "version": "2.36.0" + }, + "atlasclient-0.1.7-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.10,<3.11.0a0", + "requests", + "six" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "6a3429d1aeeb523d4bf74a9566790911", + "name": "atlasclient", + "sha256": "759b1a1b3cd975c5c9ebc155d1b966baafec1ec1aefd118eb81995f2474e0d9c", + "size": 46634, + "subdir": "linux-64", + "timestamp": 1659859286964, + "version": "0.1.7" + }, + "atlasclient-0.1.7-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.11,<3.12.0a0", + "requests", + "six" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "f7186f244e538f51a58e7fa198230305", + "name": "atlasclient", + "sha256": "486b193e9b78649d6ba76c38f515713cc342e2f745b2c04d67c07e34152c6062", + "size": 58960, + "subdir": "linux-64", + "timestamp": 1676846861830, + "version": "0.1.7" + }, + "atlasclient-0.1.7-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.7,<3.8.0a0", + "requests", + "six" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "6aa8190635e3cc0e246e2c1a876fc318", + "name": "atlasclient", + "sha256": "0ce45c0964dad10246a07f79dceda74408d59adff451fd9b59fd3d43ee090d75", + "size": 46232, + "subdir": "linux-64", + "timestamp": 1659859244516, + "version": "0.1.7" + }, + "atlasclient-0.1.7-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.8,<3.9.0a0", + "requests", + "six" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "62ee7efaa181b36dda9968e988157bd0", + "name": "atlasclient", + "sha256": "e5d4aedd97599156275e31d7b489e947b67f2e6177b1dcb60b2a986177a39efe", + "size": 46235, + "subdir": "linux-64", + "timestamp": 1659859316291, + "version": "0.1.7" + }, + "atlasclient-0.1.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.9,<3.10.0a0", + "requests", + "six" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "854a5d6aef6c4d8636715de566a0ac37", + "name": "atlasclient", + "sha256": "e4f2eb1ba4263fc65ce194bf4684b5f8fe3af99d019af2a982287edb00ca5d86", + "size": 46235, + "subdir": "linux-64", + "timestamp": 1659859213989, + "version": "0.1.7" + }, + "atom-0.4.0-py27he38824b_0.tar.bz2": { + "build": "py27he38824b_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "2d7a5eb7bcde8d106cfcfafb510a206f", + "name": "atom", + "sha256": "c0e299befe411044d4cfcf35b6c87ed458c008c73ddf3884e3813a5883de1dbb", + "size": 117123, + "subdir": "linux-64", + "timestamp": 1509083692854, + "version": "0.4.0" + }, + "atom-0.4.0-py35h6c17750_0.tar.bz2": { + "build": "py35h6c17750_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "69dc20ae0920e243b4d30506b162c6bc", + "name": "atom", + "sha256": "6c7bd3d6e3aa7aa0e01728f58e6ed9a5a63b8705bbd3e82ad69975d587d72b3d", + "size": 117400, + "subdir": "linux-64", + "timestamp": 1509083729207, + "version": "0.4.0" + }, + "atom-0.4.0-py36hed3e896_0.tar.bz2": { + "build": "py36hed3e896_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "6468a5c571ecf36d130d455e539c45b7", + "name": "atom", + "sha256": "9fbe706d3e6ba0eb858031f26294fc335a5fe8386ee8a4f3b5f0c92ec2755242", + "size": 117375, + "subdir": "linux-64", + "timestamp": 1509083737326, + "version": "0.4.0" + }, + "atom-0.4.1-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "bca9eac990c46922e659cdc20c2923d1", + "name": "atom", + "sha256": "e966661e0b185768a402d76eed4544362f27cb45cb006b0e5ba1da562fe55fa8", + "size": 117741, + "subdir": "linux-64", + "timestamp": 1519174652366, + "version": "0.4.1" + }, + "atom-0.4.1-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "2f444165e260d032826da2426ccd49ed", + "name": "atom", + "sha256": "1097397782ed761070bc78a1634210faeef42cf960db45942dc05dcce486b46e", + "size": 118077, + "subdir": "linux-64", + "timestamp": 1519174669607, + "version": "0.4.1" + }, + "atom-0.4.1-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "5090083e256136e61232b01998dd0a2e", + "name": "atom", + "sha256": "6f190d262331b6ef824443800f331a37fdf7dc42e3fe503f4d36a595b393ec93", + "size": 118133, + "subdir": "linux-64", + "timestamp": 1519174627987, + "version": "0.4.1" + }, + "atom-0.4.1-py37hf484d3e_0.tar.bz2": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "cc2fbe2812371dbcb9cb232b87f47099", + "name": "atom", + "sha256": "bf7d79f749080eb3a149b0e6baff0852415055e56f6a4c30ae1d5b43a03c3536", + "size": 118055, + "subdir": "linux-64", + "timestamp": 1530738558810, + "version": "0.4.1" + }, + "atom-0.4.3-py27hfd86e86_0.tar.bz2": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "5993bb8851614031538654fed08fb706", + "name": "atom", + "sha256": "0bdcb990b29020ad6ce1655afb1d8d24786933b1bdfa21bf2c6e364e1dc64d74", + "size": 127358, + "subdir": "linux-64", + "timestamp": 1552357773033, + "version": "0.4.3" + }, + "atom-0.4.3-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "2ce4605bc9cd73aadc0af6b0f8a2473d", + "name": "atom", + "sha256": "ea9b912e11adba758a87c8320bdce52a7055bee70c0249827af7fa34f3cd6b4c", + "size": 127730, + "subdir": "linux-64", + "timestamp": 1552357837114, + "version": "0.4.3" + }, + "atom-0.4.3-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "2f4afa3697101d7374f05730addbf545", + "name": "atom", + "sha256": "85ee79ed587f24eaace0caf055649c1fb0b9e1b528c6696220309bcc41d82aa6", + "size": 127997, + "subdir": "linux-64", + "timestamp": 1552357787861, + "version": "0.4.3" + }, + "atom-0.4.3-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "5aafea6fef0be17cae626746a97e128f", + "name": "atom", + "sha256": "2cd17edf4e85f139ef15b5229cdcb5b8a908f9c4fefedcfe0e59d0d97fa2ca05", + "size": 141798, + "subdir": "linux-64", + "timestamp": 1573738048341, + "version": "0.4.3" + }, + "atom-0.5.0-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "5ea6ee97ace6eb81d3f2086c38ceb8e3", + "name": "atom", + "sha256": "2d670b6ca6d3a59414635dbd761a96dfeefc74174adb7ab944a21c4a130e1977", + "size": 132224, + "subdir": "linux-64", + "timestamp": 1588478279678, + "version": "0.5.0" + }, + "atom-0.5.0-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "97748e9f7968d9a6abd1542725c52ae8", + "name": "atom", + "sha256": "062765f95de30b040e16242ee6ab6510269179a489abb96ce5f65b130ef367d3", + "size": 131480, + "subdir": "linux-64", + "timestamp": 1588478267172, + "version": "0.5.0" + }, + "atom-0.5.0-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c064eae8ddbbc959927193dbd5a75b49", + "name": "atom", + "sha256": "ff03d994f138e5d3e2605d5a044d2124927bb2eca41c89e5b2a198f5fb9af8ea", + "size": 140332, + "subdir": "linux-64", + "timestamp": 1588478269920, + "version": "0.5.0" + }, + "atom-0.5.1-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c119d20cd82b22d94ff0344566937eec", + "name": "atom", + "sha256": "914ca06b906a2f80e0a47e8e3792d4dbbaffada78d01bd6586a548be663dc69a", + "size": 132892, + "subdir": "linux-64", + "timestamp": 1593440044850, + "version": "0.5.1" + }, + "atom-0.5.1-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b123384a729600aa13c09a2757300e04", + "name": "atom", + "sha256": "edf6ea9c7f3e2bb1c7df5c9ac28cc4a71232da24097f6dcd863ae46cf84086a5", + "size": 132027, + "subdir": "linux-64", + "timestamp": 1593440044881, + "version": "0.5.1" + }, + "atom-0.5.1-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e70350040567a87256ad7b07c427b562", + "name": "atom", + "sha256": "e65eb8ec72a1d1f0e7d405b443e51d1bee8ffd3274fb6d6affdd45eb3822a0a0", + "size": 141104, + "subdir": "linux-64", + "timestamp": 1593440055064, + "version": "0.5.1" + }, + "atom-0.5.2-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7350948d79269c2de7763df066245734", + "name": "atom", + "sha256": "448b1596030777c14882d89046445c92fb8a1fc64424d005deb9b0c8d1ddc0ab", + "size": 131581, + "subdir": "linux-64", + "timestamp": 1600298433142, + "version": "0.5.2" + }, + "atom-0.5.2-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "94e05e6fec1f6be896697d91dda2efd1", + "name": "atom", + "sha256": "2d571916efbf4f1dee5c2e8b6b6fa44da7b0ddcd71fc5e2cc4d642a6a091771b", + "size": 130854, + "subdir": "linux-64", + "timestamp": 1600298389240, + "version": "0.5.2" + }, + "atom-0.5.2-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b896673d26b8d0f6a5936c3a7d435dc1", + "name": "atom", + "sha256": "f8e0ca76d914152ed6a5cf66117fd5c9fbed24a7f8543eb8822b0db5f8b165ee", + "size": 140024, + "subdir": "linux-64", + "timestamp": 1600298373531, + "version": "0.5.2" + }, + "atom-0.6.0-py310hd09550d_0.tar.bz2": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "728f0788017ae1b39a5500470ee1aa81", + "name": "atom", + "sha256": "005fb0a328df1a9af6b970a91a4f7fb62a28bd4408418438d30e788b051bed72", + "size": 1059476, + "subdir": "linux-64", + "timestamp": 1640803508267, + "version": "0.6.0" + }, + "atom-0.6.0-py36hff7bd54_0.tar.bz2": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "36ed29457a5d41e38e12e0555c9098ce", + "name": "atom", + "sha256": "a031c2cda158e1cb6033213ea38e8e0288974d0ef150886e7534fd1d190d7147", + "size": 131483, + "subdir": "linux-64", + "timestamp": 1604765633728, + "version": "0.6.0" + }, + "atom-0.6.0-py37hff7bd54_0.tar.bz2": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ec9c1f7a6b55b2744c37a408084d8ba5", + "name": "atom", + "sha256": "71eefae91fc7c7e9d5f1173bb08e5e93979b84c2088775b6f7ad3403708e7544", + "size": 130488, + "subdir": "linux-64", + "timestamp": 1604765604266, + "version": "0.6.0" + }, + "atom-0.6.0-py38hff7bd54_0.tar.bz2": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b6de6fec3e728fdea4c42d09d5437eda", + "name": "atom", + "sha256": "821dfa271e81a3855241d4e6b9a1bdfffc51ca69a1fbe12c9448f76c9371c12e", + "size": 139761, + "subdir": "linux-64", + "timestamp": 1604765634056, + "version": "0.6.0" + }, + "atom-0.6.0-py39hff7bd54_0.tar.bz2": { + "build": "py39hff7bd54_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2c5f1e0df5c603cdf33c68b10847540a", + "name": "atom", + "sha256": "a7c8d6ce4e615f0632ecd7f6d60deafc2ad6c1d9a22f847b7487fb20ac03c3e3", + "size": 142973, + "subdir": "linux-64", + "timestamp": 1613154383787, + "version": "0.6.0" + }, + "atom-0.8.2-py310hdb19cb5_0.tar.bz2": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "def8a0c6614a1f7086f47d23bfa9eeba", + "name": "atom", + "sha256": "ab5c8d766be34a76934c02897829424c1f6e9889fbde748a1300a8714567867c", + "size": 152416, + "subdir": "linux-64", + "timestamp": 1670614501495, + "version": "0.8.2" + }, + "atom-0.8.2-py311hdb19cb5_0.tar.bz2": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b263a02bd877d19df7bb5019c9766458", + "name": "atom", + "sha256": "d4d984158884a13f50540d2587137cee88ac313082220ba41ecb0622f5c3d476", + "size": 163989, + "subdir": "linux-64", + "timestamp": 1676843280622, + "version": "0.8.2" + }, + "atom-0.8.2-py38hdb19cb5_0.tar.bz2": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "061dd1b636007d171d46d2214f51e1df", + "name": "atom", + "sha256": "a42f447c2a83fdbd3308f81e1047941ad68511f0466a764ec2c7d90523dacf35", + "size": 151026, + "subdir": "linux-64", + "timestamp": 1670614462096, + "version": "0.8.2" + }, + "atom-0.8.2-py39hdb19cb5_0.tar.bz2": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0b0cc7c886adacafddf5d8079470a147", + "name": "atom", + "sha256": "94efce99fbd4a8d1668751188fd6e098d1a736fab8ea59fab5d4f2aa14b26594", + "size": 151311, + "subdir": "linux-64", + "timestamp": 1670614541129, + "version": "0.8.2" + }, + "atom-0.9.0-py310hdb19cb5_0.tar.bz2": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6a3ad8e8d25229e911541b059f816f54", + "name": "atom", + "sha256": "3ab964623643c9e4a4a394dce29a8eeca183c0de420846697d0633c56ba2953f", + "size": 156449, + "subdir": "linux-64", + "timestamp": 1678313705225, + "version": "0.9.0" + }, + "atom-0.9.0-py311hdb19cb5_0.tar.bz2": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e07c6bd6f5f6076e41d00bdf30381fdf", + "name": "atom", + "sha256": "8f6405bb44f195885fc604a97a6e69c17c75ead327c812da130b1232c26ab05e", + "size": 168600, + "subdir": "linux-64", + "timestamp": 1679335377766, + "version": "0.9.0" + }, + "atom-0.9.0-py38hdb19cb5_0.tar.bz2": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8c6f55c1279e8f101586db6d61039cd7", + "name": "atom", + "sha256": "27ace6bce4476f3d9962453619f4106f4e903bf0a0dbde1e2cb3d44ee6ae8262", + "size": 155196, + "subdir": "linux-64", + "timestamp": 1678313746950, + "version": "0.9.0" + }, + "atom-0.9.0-py39hdb19cb5_0.tar.bz2": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1b60b44cd64fc5cf449016a3fe3eed9e", + "name": "atom", + "sha256": "b781a92387b5927a829181fbc62502f863213355fb728b04cdb5df3b44dea09c", + "size": 155339, + "subdir": "linux-64", + "timestamp": 1678313788641, + "version": "0.9.0" + }, + "atomicwrites-1.1.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "168003b1f995d9c397972cc91e0be9e4", + "name": "atomicwrites", + "sha256": "f308cb0402fe7b285c224bce000da17c29659c520a8bf01f755e41c5b3fb9a6e", + "size": 10282, + "subdir": "linux-64", + "timestamp": 1527822258707, + "version": "1.1.5" + }, + "atomicwrites-1.1.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fad3a9dc2aecece6d333013a237cc69b", + "name": "atomicwrites", + "sha256": "e858e45219d43af247a213d49064aeab0af719d7fa81d56e393cc555c5d3a78e", + "size": 10347, + "subdir": "linux-64", + "timestamp": 1527822267829, + "version": "1.1.5" + }, + "atomicwrites-1.1.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ccd17b53a78d0277c919a26f1fac9a9", + "name": "atomicwrites", + "sha256": "d7b1f5b16edcd03c610c51f71edb0cd435b889d6b6e2a51725dfb7446ca96adf", + "size": 10358, + "subdir": "linux-64", + "timestamp": 1527822238826, + "version": "1.1.5" + }, + "atomicwrites-1.1.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "beba2af356933ea2d4f3bc7ad6612d5e", + "name": "atomicwrites", + "sha256": "47ff17a7609d4171fa10d2c646844e9753f5da98242d273446f325c15dcb9f97", + "size": 10396, + "subdir": "linux-64", + "timestamp": 1530693994220, + "version": "1.1.5" + }, + "atomicwrites-1.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a676924514ee9a1ca9be4a9ff3c8088b", + "name": "atomicwrites", + "sha256": "1ffb19668b6dfb4b077dd972ce51710b252dc6e130672a0cfbff00ccf9ffeaec", + "size": 11159, + "subdir": "linux-64", + "timestamp": 1535384578210, + "version": "1.2.0" + }, + "atomicwrites-1.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21d54ae515dece4c6360dc9d6cb88c95", + "name": "atomicwrites", + "sha256": "627fcb574aff07eb3017d46725e48fd1948826fff76bc8d7993af5fadeae267e", + "size": 11241, + "subdir": "linux-64", + "timestamp": 1535384597575, + "version": "1.2.0" + }, + "atomicwrites-1.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d6f6aa71b48eb17e420cd3c2fa5b7b9", + "name": "atomicwrites", + "sha256": "cfd34adc9f151a1df0038d3e27d6c7165e08d9bf4db9d011c04d3437f66ba232", + "size": 11246, + "subdir": "linux-64", + "timestamp": 1535384510133, + "version": "1.2.0" + }, + "atomicwrites-1.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d4d4e889d24ed02706835118e5f2789", + "name": "atomicwrites", + "sha256": "47bf3e6565a07ab2149ca5dd6227857b50d79af17b561ee95e47be7f9ae02a13", + "size": 11275, + "subdir": "linux-64", + "timestamp": 1535384457944, + "version": "1.2.0" + }, + "atomicwrites-1.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64f6dfeaf7ab5a06dbf22bd5ec3bc81d", + "name": "atomicwrites", + "sha256": "a51ff6a6332bdc08506fd94b74c40b6bb06042b71636d5f40dfd31b9f4f93986", + "size": 11118, + "subdir": "linux-64", + "timestamp": 1536085949560, + "version": "1.2.1" + }, + "atomicwrites-1.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ba42164df7cd98504776ea9b84ac8ae", + "name": "atomicwrites", + "sha256": "b6b77d17b9ed18216a0665e3edca1ea802666efe7c261bc667c7548904c87429", + "size": 11212, + "subdir": "linux-64", + "timestamp": 1536085985420, + "version": "1.2.1" + }, + "atomicwrites-1.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be89ff3afb38cb7b097fc16c5f93576f", + "name": "atomicwrites", + "sha256": "5d3a73397c81d2ef6cff51496e729b7768fa88d91f08a2aefdbf8845a54d1cee", + "size": 11220, + "subdir": "linux-64", + "timestamp": 1536085923786, + "version": "1.2.1" + }, + "atomicwrites-1.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d759091c6565077c7c85b62aaae8aac", + "name": "atomicwrites", + "sha256": "d99027ac37dbfb0bf26090bf0a31306256863cd04a78a19bc01be5ea90cadec0", + "size": 11225, + "subdir": "linux-64", + "timestamp": 1536085952529, + "version": "1.2.1" + }, + "atomicwrites-1.3.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d3d1c263ace8370396666d6c05cad50", + "name": "atomicwrites", + "sha256": "3f325e34a517729ad83912b7261a96846642d344064b3a31af5faa271447b734", + "size": 12966, + "subdir": "linux-64", + "timestamp": 1553289194852, + "version": "1.3.0" + }, + "atomicwrites-1.3.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7715d2c446c9eba701f9441673affb72", + "name": "atomicwrites", + "sha256": "253d5f91bbc6ceda9a9e8d1e8aa392be083c025ce41b1e01cfd3cb83169e12a7", + "size": 13050, + "subdir": "linux-64", + "timestamp": 1553289296269, + "version": "1.3.0" + }, + "atomicwrites-1.3.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "61a874c4bc39774e5ffe602ef32d20e5", + "name": "atomicwrites", + "sha256": "208ebd369514ea3ea55afc8e48d655902895ed8eed3ddecc531c1f79da379f7c", + "size": 13075, + "subdir": "linux-64", + "timestamp": 1553289196962, + "version": "1.3.0" + }, + "attrs-17.2.0-py27h25ce645_0.tar.bz2": { + "build": "py27h25ce645_0", + "build_number": 0, + "depends": [ + "hypothesis", + "pympler", + "python >=2.7,<2.8.0a0", + "zope", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4427e29d5a06951791ffce34e888645e", + "name": "attrs", + "sha256": "528fc3cedf69149c59d6bec115042fd72f5e9a1f6e8d0d6e756d3ae94229ab72", + "size": 34202, + "subdir": "linux-64", + "timestamp": 1507745271697, + "version": "17.2.0" + }, + "attrs-17.2.0-py35hde4ea97_0.tar.bz2": { + "build": "py35hde4ea97_0", + "build_number": 0, + "depends": [ + "hypothesis", + "pympler", + "python >=3.5,<3.6.0a0", + "zope", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2780d00c85373ceea3c533fdaed66d1", + "name": "attrs", + "sha256": "6144508053370ec33151c4994e365ff2d63d679e4ab485f9884585c2aed9a900", + "size": 34957, + "subdir": "linux-64", + "timestamp": 1507745282460, + "version": "17.2.0" + }, + "attrs-17.2.0-py36h8d46266_0.tar.bz2": { + "build": "py36h8d46266_0", + "build_number": 0, + "depends": [ + "hypothesis", + "pympler", + "python >=3.6,<3.7.0a0", + "zope", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "deaf50cc9570aad4dceacb73232a12e1", + "name": "attrs", + "sha256": "8fd08d238103487ca79c1f955afd7bb6f00ef3bbb72a63feeccada19c3bada75", + "size": 34795, + "subdir": "linux-64", + "timestamp": 1507745282943, + "version": "17.2.0" + }, + "attrs-17.3.0-py27hf19f258_0.tar.bz2": { + "build": "py27hf19f258_0", + "build_number": 0, + "depends": [ + "hypothesis", + "pympler", + "python >=2.7,<2.8.0a0", + "zope", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a5e889113d7e1c438b82981750a39aaf", + "name": "attrs", + "sha256": "099e445b0d992146306ba8a222956077d50e976a5cd3661c027268cf1cc82fd7", + "size": 39125, + "subdir": "linux-64", + "timestamp": 1511834537314, + "version": "17.3.0" + }, + "attrs-17.3.0-py35h20e33bf_0.tar.bz2": { + "build": "py35h20e33bf_0", + "build_number": 0, + "depends": [ + "hypothesis", + "pympler", + "python >=3.5,<3.6.0a0", + "zope", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "69ff9bbfdedb91e44f988612e3b93e69", + "name": "attrs", + "sha256": "5b24e7fd63dd85437b14f46cb4300f6a469f1b42871647a87f2712dda21ab647", + "size": 40092, + "subdir": "linux-64", + "timestamp": 1511834546950, + "version": "17.3.0" + }, + "attrs-17.3.0-py36h5ab58ff_0.tar.bz2": { + "build": "py36h5ab58ff_0", + "build_number": 0, + "depends": [ + "hypothesis", + "pympler", + "python >=3.6,<3.7.0a0", + "zope", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6092174143e539aac3870d31e2ef67a8", + "name": "attrs", + "sha256": "404de5710500800e2eedc9f732636b2840eef1e9a3b39c19b8a8b7d527227d07", + "size": 39961, + "subdir": "linux-64", + "timestamp": 1511834550234, + "version": "17.3.0" + }, + "attrs-17.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "307732cf9ad2fc0783c5af9d5a16cf6f", + "name": "attrs", + "sha256": "288080af6044da5b723451f80d78b498a4f621232f645440ad9ad892432432b6", + "size": 41432, + "subdir": "linux-64", + "timestamp": 1516977226372, + "version": "17.4.0" + }, + "attrs-17.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "67fa9242aad2e7eda5ab92bc2e413dfd", + "name": "attrs", + "sha256": "e2e21d4f6f3e3998ed1d7639035075ade1294a09b467e6b5c43e0796aaf72f12", + "size": 42441, + "subdir": "linux-64", + "timestamp": 1516977260555, + "version": "17.4.0" + }, + "attrs-17.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c75b22962b744a71306b6a4c5d6c81a7", + "name": "attrs", + "sha256": "420aff43c92d4c50c59cd996bc1007000d438682ff3861b37994a0a7662e8ac1", + "size": 42175, + "subdir": "linux-64", + "timestamp": 1516977256826, + "version": "17.4.0" + }, + "attrs-18.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "762f7aeb46c5574dccc299649e0d0b49", + "name": "attrs", + "sha256": "409a45e46edf2901eaf39f2a2d234ea8ccf404c82ab40f18b79596e6e3cfe300", + "size": 43757, + "subdir": "linux-64", + "timestamp": 1525810155325, + "version": "18.1.0" + }, + "attrs-18.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d23121d02cea32bfa19f68660d326bec", + "name": "attrs", + "sha256": "50ea40647d2e91b8416e68510ce39e74111aa306d685635852f145ab0648c8b8", + "size": 44750, + "subdir": "linux-64", + "timestamp": 1525810189469, + "version": "18.1.0" + }, + "attrs-18.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d47ca81b7eb3c7c26c5e14c90e4ef9a", + "name": "attrs", + "sha256": "fa279abc2d6cb6653813fdbf6b4c96466cbb0435fb054cb914616c59d34146f5", + "size": 44517, + "subdir": "linux-64", + "timestamp": 1525810189528, + "version": "18.1.0" + }, + "attrs-18.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2be4b7bc18a8b150090918f75ffa9e9f", + "name": "attrs", + "sha256": "375550b2c4d622d85457fe059bad972e6e0c4f0620387b29691bbcfd029abc51", + "size": 44363, + "subdir": "linux-64", + "timestamp": 1530693641746, + "version": "18.1.0" + }, + "attrs-18.2.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d9fa19cd5e73424cae489702199e5ea", + "name": "attrs", + "sha256": "c7e34b098b85251b09c80a8b6d8109feff3cf02077036e0fa6a4abc3daa96a44", + "size": 50504, + "subdir": "linux-64", + "timestamp": 1536072296955, + "version": "18.2.0" + }, + "attrs-18.2.0-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1df16a0dff7e3d7284f45d1b9d61f20e", + "name": "attrs", + "sha256": "1ab302368fdcc4ef66d2179ee21bcb08396693a12542167de850b71937e86371", + "size": 51468, + "subdir": "linux-64", + "timestamp": 1536072365713, + "version": "18.2.0" + }, + "attrs-18.2.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aefe97c05f152a5a0cff7583738a83ce", + "name": "attrs", + "sha256": "bf51354d201bd829c07699f41dac7e4129aea9248657c32968feffce1e5ed221", + "size": 51205, + "subdir": "linux-64", + "timestamp": 1536072258249, + "version": "18.2.0" + }, + "attrs-18.2.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ff6c7c963fc54189708b2e12cab8d7c", + "name": "attrs", + "sha256": "75840beaca8cdee93e765ad194675d90ce9b7143fd55eac392d87890b895592c", + "size": 51178, + "subdir": "linux-64", + "timestamp": 1536072427256, + "version": "18.2.0" + }, + "attrs-19.1.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6315c7dcbfcef3809fa4c03e251a012f", + "name": "attrs", + "sha256": "ae9721aefb2e5c13e0e96310565bcae2612878b35f4ccd2b56e3340f26fd2951", + "size": 57052, + "subdir": "linux-64", + "timestamp": 1553289142932, + "version": "19.1.0" + }, + "attrs-19.1.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39b5386a39bbb7692938b13d304eab69", + "name": "attrs", + "sha256": "dc91c54edaece4de47faa555b37b10b646b0bf014caa02bb0254c51188d5aff9", + "size": 57753, + "subdir": "linux-64", + "timestamp": 1553289440204, + "version": "19.1.0" + }, + "attrs-19.1.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5132f1244324de1c146ac74b78b5080a", + "name": "attrs", + "sha256": "fbcd080a27242afbbbfb36fcd3185329abaf2292e829d92fab6af5befd5ab647", + "size": 57763, + "subdir": "linux-64", + "timestamp": 1553290542480, + "version": "19.1.0" + }, + "attrs-22.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "849eab92757e729cf220bfaf82969216", + "name": "attrs", + "sha256": "67466219def325d70f80b9fa47ac681b3fc380e596048778d8243e471958a554", + "size": 82204, + "subdir": "linux-64", + "timestamp": 1668696274924, + "version": "22.1.0" + }, + "attrs-22.1.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "79e4efce5732e586f66942bb89256b1a", + "name": "attrs", + "sha256": "98de0b8aff36606eaef368d654ffa43db5a03c09699e209c4294f26c843783c4", + "size": 101803, + "subdir": "linux-64", + "timestamp": 1676822771018, + "version": "22.1.0" + }, + "attrs-22.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "84157f1fbeec3109b75a57d2e3c16f3d", + "name": "attrs", + "sha256": "8a1659e6aeb9daaa493b91bdf4e9a98fbb112c44a5f98b7944c498075fb705d4", + "size": 81296, + "subdir": "linux-64", + "timestamp": 1668696301528, + "version": "22.1.0" + }, + "attrs-22.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c5f44b2c79fc5e887f478e18c82a543", + "name": "attrs", + "sha256": "8a531933162bc288069ac8978520f01cee215a24ad4f8c919346d314c5c3d15f", + "size": 81821, + "subdir": "linux-64", + "timestamp": 1668696245523, + "version": "22.1.0" + }, + "attrs-22.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c20a6b91281e0f9b7d89c05c7695360f", + "name": "attrs", + "sha256": "0d7f12d0d9b69b0d6b08013aecaa8dda14014da859b381971cd5f4444a14bba8", + "size": 81575, + "subdir": "linux-64", + "timestamp": 1668696216395, + "version": "22.1.0" + }, + "authlib-0.15.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.2", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0b3875b661c79c960bac37076102683d", + "name": "authlib", + "sha256": "66ccfc68915179c4a5ac252b1e38fffbadea5ff29aedc49244430cf3e83908eb", + "size": 255249, + "subdir": "linux-64", + "timestamp": 1659982995344, + "version": "0.15.5" + }, + "authlib-0.15.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.2", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f8a5cd2b42cc8fa2b708e8bb21de16cf", + "name": "authlib", + "sha256": "19386ac38789fe5b4b9e67698cdf78111117010bc9be5b966814de4eb439cb62", + "size": 252628, + "subdir": "linux-64", + "timestamp": 1659982949506, + "version": "0.15.5" + }, + "authlib-0.15.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.2", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b39d3a6dd9a69d53d7cccbaab9c98187", + "name": "authlib", + "sha256": "d0b7aef734051f3ff4e665b250a60e0ef18ffb74ee8f29f537fc02bdf27acad8", + "size": 253776, + "subdir": "linux-64", + "timestamp": 1659982916529, + "version": "0.15.5" + }, + "authlib-0.15.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.2", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6ccda982f230c821af219045b3cabc08", + "name": "authlib", + "sha256": "85b8c4015d304f7927a6567c95eec130b764438eaa5086f2d18c3d6ea1c0f12c", + "size": 251279, + "subdir": "linux-64", + "timestamp": 1659982884221, + "version": "0.15.5" + }, + "authlib-1.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.2", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4b2278fa3d70bd44d1c16650e1b98c0d", + "name": "authlib", + "sha256": "15a53204a262568b835a90447f6a85ec059fe0ec33f269aeb702903e8a7086fd", + "size": 266813, + "subdir": "linux-64", + "timestamp": 1659988161869, + "version": "1.0.1" + }, + "authlib-1.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.2", + "python >=3.11,<3.12.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "47753faf93ed1af5aa25a91123b585e8", + "name": "authlib", + "sha256": "3a4dfc940eaaf2416437c29c1512bfe692df320ce0b7ee57e742afa7be5cccd0", + "size": 333883, + "subdir": "linux-64", + "timestamp": 1676846879489, + "version": "1.0.1" + }, + "authlib-1.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.2", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "818e566a772fa6d10b62f78d869e64f0", + "name": "authlib", + "sha256": "b5fe2b0b5b99cbce4337246ed3d5f8fafa0c4b5b1c8e0d92fbd1c44be9f4cf50", + "size": 264017, + "subdir": "linux-64", + "timestamp": 1659988222470, + "version": "1.0.1" + }, + "authlib-1.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.2", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "56ea7a2ad9eda45af44c0ea43a3fb4e0", + "name": "authlib", + "sha256": "a9b00a820861f57eb284b7fa7e1d339bb24f0e213ad87a2c60f308a71daba6cf", + "size": 264672, + "subdir": "linux-64", + "timestamp": 1659988192102, + "version": "1.0.1" + }, + "authlib-1.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.2", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "26452f1250d224b1804874e801291e7d", + "name": "authlib", + "sha256": "302bf13b746c2db6f25ff0c14e76132d2f47b6e538fa5ed75a69652f26f6ba32", + "size": 263762, + "subdir": "linux-64", + "timestamp": 1659988117573, + "version": "1.0.1" + }, + "autoconf-2.69-pl526hebd4dad_5.tar.bz2": { + "build": "pl526hebd4dad_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0", + "m4", + "perl" + ], + "license": "GPL-3.0", + "md5": "974c92812ce2002c8bad54dcde9d6905", + "name": "autoconf", + "sha256": "e4ca974269c42918c66031acdc61ee7199807c1b33aeb1f8aecb6adfb886a0a1", + "size": 701991, + "subdir": "linux-64", + "timestamp": 1505666339973, + "version": "2.69" + }, + "autoconf-2.71-pl5340h5eee18b_0.tar.bz2": { + "build": "pl5340h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "m4", + "perl 5.*" + ], + "license": "GPL-3.0-or-later WITH Autoconf-exception-3.0", + "license_family": "GPL", + "md5": "8e061fde2054491e62319f001f83a8f2", + "name": "autoconf", + "sha256": "a3a120888343c178b4e7324d659069de559a0ec6e97e73774361819cfec64f39", + "size": 746239, + "subdir": "linux-64", + "timestamp": 1670317070801, + "version": "2.71" + }, + "automake-1.15.1-pl526h7747ae0_0.tar.bz2": { + "build": "pl526h7747ae0_0", + "build_number": 0, + "depends": [ + "autoconf", + "m4", + "perl" + ], + "license": "GPL 3", + "md5": "1c937fd4febc09418f4b18a1adb03c3d", + "name": "automake", + "sha256": "2f67cebb39ca0c684064acdc2a60298a06d92963a71497bf3ae5c7cb719ed775", + "size": 602624, + "subdir": "linux-64", + "timestamp": 1505666355234, + "version": "1.15.1" + }, + "automake-1.16.1-pl526_0.tar.bz2": { + "build": "pl526_0", + "build_number": 0, + "depends": [ + "autoconf", + "m4", + "perl" + ], + "license": "GPL3", + "md5": "b6f6633bcd3e172458551a39a3b5fc03", + "name": "automake", + "sha256": "9aaab2f09b5f39be925321eadb37bc74af7f33f052fe76e9b08b3358798d5957", + "size": 665496, + "subdir": "linux-64", + "timestamp": 1539255799332, + "version": "1.16.1" + }, + "automake-1.16.2-pl526_0.tar.bz2": { + "build": "pl526_0", + "build_number": 0, + "depends": [ + "autoconf", + "m4", + "perl" + ], + "license": "GPL 3", + "md5": "423f6c1293aa9a7afc9979d16e2271a1", + "name": "automake", + "sha256": "9f6e8888aa21cf0edb8ac9de5aa975d94b2dd74531d4b9c9b8c354deb34ee729", + "size": 635458, + "subdir": "linux-64", + "timestamp": 1588537633205, + "version": "1.16.2" + }, + "automake-1.16.5-pl5321h06a4308_0.tar.bz2": { + "build": "pl5321h06a4308_0", + "build_number": 0, + "depends": [ + "autoconf", + "m4", + "perl 5.*" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "1bed5420f36210d08da1ed8e11aa03f7", + "name": "automake", + "sha256": "ffa9df2c72438c5088c767b8ea919fd6f4239bc81a76f6dc23cb6f94018f7d54", + "size": 615813, + "subdir": "linux-64", + "timestamp": 1667595730986, + "version": "1.16.5" + }, + "automake-1.16.5-pl5340h06a4308_1.tar.bz2": { + "build": "pl5340h06a4308_1", + "build_number": 1, + "depends": [ + "autoconf", + "m4", + "perl 5.*" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "74fe4fb20f73fa6025a23b380a5a297d", + "name": "automake", + "sha256": "b9240bfe1721689715e15b98ab29fe3f35e6e2ee5ea63535d8884c979df5e50e", + "size": 646729, + "subdir": "linux-64", + "timestamp": 1670317968752, + "version": "1.16.5" + }, + "automat-0.6.0-py27hfed452d_0.tar.bz2": { + "build": "py27hfed452d_0", + "build_number": 0, + "depends": [ + "attrs", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "689ef3b7628942da5fdd47ced35740d7", + "name": "automat", + "sha256": "6d83beb2719b608d929ca0d4526a444ec72d6444b7fb1b7c17dc03a99ce138e6", + "size": 48486, + "subdir": "linux-64", + "timestamp": 1508093183500, + "version": "0.6.0" + }, + "automat-0.6.0-py35h367829d_0.tar.bz2": { + "build": "py35h367829d_0", + "build_number": 0, + "depends": [ + "attrs", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e73c7ed81635bc3bbbfad2931bfab9ff", + "name": "automat", + "sha256": "1fa89de2819478d8dbc9a29fff8a6db747d18799f2b8c2103c01fa55fafb8b47", + "size": 50489, + "subdir": "linux-64", + "timestamp": 1508093208378, + "version": "0.6.0" + }, + "automat-0.6.0-py36ha140c00_0.tar.bz2": { + "build": "py36ha140c00_0", + "build_number": 0, + "depends": [ + "attrs", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e559e19836184e4512d9d80c88a357be", + "name": "automat", + "sha256": "ddeb0494384459e69b36a60f2ed91e0905c8ea11379cc7d59061f69137d7d51b", + "size": 50324, + "subdir": "linux-64", + "timestamp": 1508093210211, + "version": "0.6.0" + }, + "automat-0.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "587565e66f23a0299436f9c02fb49abc", + "name": "automat", + "sha256": "1c670e9498d23a693c7b8e5a97741536835b390d2be5caf0c1b022cf0bbc9204", + "size": 51544, + "subdir": "linux-64", + "timestamp": 1529431687803, + "version": "0.7.0" + }, + "automat-0.7.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62af09d0c1033c7933f0bc8511dd788c", + "name": "automat", + "sha256": "f58a5a71a0b4ee0fa73d1f673ed2fa7f6309601d8a5cec041def3bd4693cd9c5", + "size": 53758, + "subdir": "linux-64", + "timestamp": 1529431717338, + "version": "0.7.0" + }, + "automat-0.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7a8c277ae6002d1413cf42e3d8c9e1cc", + "name": "automat", + "sha256": "2f2c6fca7a047ffc6a0e7775c776a350903577d3ab9cb3f0221f5cce32788623", + "size": 53579, + "subdir": "linux-64", + "timestamp": 1529431733766, + "version": "0.7.0" + }, + "automat-0.7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fea6d45d888c0401530890983fca02d3", + "name": "automat", + "sha256": "19f83bf56612e25be4d0918ecd1cb8bfa767359ae28c3d2d279ef383226851be", + "size": 53534, + "subdir": "linux-64", + "timestamp": 1530738583742, + "version": "0.7.0" + }, + "automat-0.7.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "attrs", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ce55f33bc89ec27ee711bc334524502", + "name": "automat", + "sha256": "ef8c3ca51f21937ed2f683a61e7db216aee5334eda24728ece4e881006957879", + "size": 54330, + "subdir": "linux-64", + "timestamp": 1573738065140, + "version": "0.7.0" + }, + "autopep8-1.3.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "769e9df5f1452450a2e5eed542df2400", + "name": "autopep8", + "sha256": "77ddac3f677f4cfd2b60aceac2ea0ab7c8349dfbf45e96fb2f47acbd86ee2363", + "size": 65965, + "subdir": "linux-64", + "timestamp": 1536861257811, + "version": "1.3.4" + }, + "autopep8-1.3.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eecef760388435770f1e947f7deb46b0", + "name": "autopep8", + "sha256": "d9dec86e78d0081aa2f02a35c633afed119107cb0043512cab12ce5a59528455", + "size": 67433, + "subdir": "linux-64", + "timestamp": 1536861366443, + "version": "1.3.4" + }, + "autopep8-1.3.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64061d3568c8961d52334edbc9fa4dae", + "name": "autopep8", + "sha256": "2190d845ea93a172b82dc0d5697649f4b76dfbe443135bf7c823fb25ce2a7fc9", + "size": 66802, + "subdir": "linux-64", + "timestamp": 1536861365276, + "version": "1.3.4" + }, + "autopep8-1.3.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad9cade687208c33c9e4f34f22e5fea7", + "name": "autopep8", + "sha256": "81d297114bcee9034c73dfa107e938d900a285f670340bb84464244f85a558f0", + "size": 66685, + "subdir": "linux-64", + "timestamp": 1536861149790, + "version": "1.3.4" + }, + "autopep8-1.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8565f57dc0904a85bc686332afce4ae", + "name": "autopep8", + "sha256": "08db50c4dbd484897403ba51bda891e37f07468705cbb2f7c722c8e03af8a09e", + "size": 67498, + "subdir": "linux-64", + "timestamp": 1538362278422, + "version": "1.4" + }, + "autopep8-1.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d04d8093cd2fa24ae3a94e2fd583591c", + "name": "autopep8", + "sha256": "4750ba361ab75c845e93e11de1efbd39612cb27cb37cb1d816750b61bb8c331e", + "size": 68232, + "subdir": "linux-64", + "timestamp": 1538362300291, + "version": "1.4" + }, + "autopep8-1.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b21e33e940ecdf342dceab88b483cc3e", + "name": "autopep8", + "sha256": "712a030725e9065d8b0c93dacb70eb79ae0b14f19c2a11f1b0ed2fd2e6f5c7e9", + "size": 68225, + "subdir": "linux-64", + "timestamp": 1538362293584, + "version": "1.4" + }, + "autopep8-1.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a5553294a1ccf8e893ac4bcf3353d640", + "name": "autopep8", + "sha256": "b5c82ad98cc005c5728285b217c0aa412bb4e980d38bd1bbc5a44bbaaae33603", + "size": 71295, + "subdir": "linux-64", + "timestamp": 1540957926560, + "version": "1.4.2" + }, + "autopep8-1.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d40d1950fe61f7a02f9191fd5332ca2", + "name": "autopep8", + "sha256": "260b54797ba6569b7b25f18df83c01e7dcc03960ff2f4cd9f4b1d580156afb9f", + "size": 72170, + "subdir": "linux-64", + "timestamp": 1540957962676, + "version": "1.4.2" + }, + "autopep8-1.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5abc27d6f501ce25ae975d8168e7cb4d", + "name": "autopep8", + "sha256": "d1e428a91bd6e2af1385f2c186ef8613b9029eb377d561f43c78759785b3cce7", + "size": 71986, + "subdir": "linux-64", + "timestamp": 1540957899242, + "version": "1.4.2" + }, + "autopep8-1.4.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6673b34c4a89d5e6e567f47c1861d364", + "name": "autopep8", + "sha256": "f1371f410a85f9c7421535d5a763d71718d6e05f84a996747f72e443e787c99f", + "size": 71464, + "subdir": "linux-64", + "timestamp": 1542075859270, + "version": "1.4.3" + }, + "autopep8-1.4.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d49ac98b658d1a6e12a0be35d5701b1", + "name": "autopep8", + "sha256": "f4c793df6b4320aa97561502af022ccd1d67a2e9d72402bec27d622ec6c93113", + "size": 72266, + "subdir": "linux-64", + "timestamp": 1542075886294, + "version": "1.4.3" + }, + "autopep8-1.4.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85abd8fb14055cc679117c95f03efb4d", + "name": "autopep8", + "sha256": "f8d27af4798e9b836383619c54ae091707141420f083decebddd94eb44535a95", + "size": 72155, + "subdir": "linux-64", + "timestamp": 1542075837448, + "version": "1.4.3" + }, + "autovizwidget-0.12.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0c11173a2d3e3db8b29311f4d8669825", + "name": "autovizwidget", + "sha256": "302e80303776117f80ce3f71f379ae5a40ef91b1bca531f765eb372f10d7af2d", + "size": 20538, + "subdir": "linux-64", + "timestamp": 1530738796573, + "version": "0.12.5" + }, + "autovizwidget-0.12.5-py27h255d36a_0.tar.bz2": { + "build": "py27h255d36a_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "731c75c08ec28b30d13eccda6158be90", + "name": "autovizwidget", + "sha256": "0f5f2683e579b886f6d8db7dac48cdd218b50a753b92b955850b4ddfb2825cf8", + "size": 20820, + "subdir": "linux-64", + "timestamp": 1511838190576, + "version": "0.12.5" + }, + "autovizwidget-0.12.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "af9ff536268fdc8e9df4f5ce554c826d", + "name": "autovizwidget", + "sha256": "c702d0f72951ac1e6867712c5de446d81eff70493f1f086dd87072bd182245b6", + "size": 21096, + "subdir": "linux-64", + "timestamp": 1534355244029, + "version": "0.12.5" + }, + "autovizwidget-0.12.5-py35h67041e2_0.tar.bz2": { + "build": "py35h67041e2_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a0c89e08519e7141dd51dae33ab27846", + "name": "autovizwidget", + "sha256": "38427bb1010697e03e2ac481d64bbdef7bdde7100326eca6857ffee5f49ed1af", + "size": 21458, + "subdir": "linux-64", + "timestamp": 1511838206082, + "version": "0.12.5" + }, + "autovizwidget-0.12.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e877f41bc97e2d421dd104fd57ca753c", + "name": "autovizwidget", + "sha256": "7150c6bcbdcd73947818fd65417c2417aef5623708b4f6455e09991ed8578f98", + "size": 21126, + "subdir": "linux-64", + "timestamp": 1530738762062, + "version": "0.12.5" + }, + "autovizwidget-0.12.5-py36hb2c7800_0.tar.bz2": { + "build": "py36hb2c7800_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b6412ac078283ee7416eb670514a37bf", + "name": "autovizwidget", + "sha256": "62e928e509f3c455d5dc6969777bd8b845562b76ffb799d963f3fe623d1ceed7", + "size": 21448, + "subdir": "linux-64", + "timestamp": 1511838205022, + "version": "0.12.5" + }, + "autovizwidget-0.12.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7b8a64f47a22a4a680fe46b79f7898fc", + "name": "autovizwidget", + "sha256": "04c6aae966c153f0fce42fa2b60e619e287e6a88512b5fff8fc29e83df568eec", + "size": 21147, + "subdir": "linux-64", + "timestamp": 1530738836491, + "version": "0.12.5" + }, + "autovizwidget-0.12.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2c8aa5a2797482aab9373f5f45ccbb46", + "name": "autovizwidget", + "sha256": "918240301df79c3df08b833480de66625248bb3a6dd9511b8b13014e258107c1", + "size": 20908, + "subdir": "linux-64", + "timestamp": 1539467289600, + "version": "0.12.6" + }, + "autovizwidget-0.12.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d2f109e20b4d6cae72fcb56828844702", + "name": "autovizwidget", + "sha256": "1a6ed00a13a8e641649213012379f42315e535d442b3019f4a6997e0a7a5eca5", + "size": 21456, + "subdir": "linux-64", + "timestamp": 1539467326133, + "version": "0.12.6" + }, + "autovizwidget-0.12.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0c069681396137ecece585c6131000da", + "name": "autovizwidget", + "sha256": "edb4cc9f78462c264a307fa1f3b4107e19ff2e69f59a853a4f5f9bebceb1f789", + "size": 21461, + "subdir": "linux-64", + "timestamp": 1539467304610, + "version": "0.12.6" + }, + "autovizwidget-0.20.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6", + "ipywidgets >5.0.0", + "notebook >=4.2", + "pandas >=0.20.1", + "plotly >=3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "99238a78ece8072cc565cfb21f2b03f1", + "name": "autovizwidget", + "sha256": "601cf695c7ce09fa8b51346345ba56ce1f5661864ccdcc3a99f3a12a93354433", + "size": 26070, + "subdir": "linux-64", + "timestamp": 1663056656414, + "version": "0.20.0" + }, + "autovizwidget-0.20.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6", + "ipywidgets >5.0.0", + "notebook >=4.2", + "pandas >=0.20.1", + "plotly >=3", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "43c1e8f6e456c29f319ecf3e7a958f08", + "name": "autovizwidget", + "sha256": "05972b24fd105a8e064296fac07758b5bf5c19f083b3cea4e91261b8bb719e7a", + "size": 32657, + "subdir": "linux-64", + "timestamp": 1676843295615, + "version": "0.20.0" + }, + "autovizwidget-0.20.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6", + "ipywidgets >5.0.0", + "notebook >=4.2", + "pandas >=0.20.1", + "plotly >=3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "14988285ff8409c2810c1c6d8a001273", + "name": "autovizwidget", + "sha256": "e6a7c4d7862c2124f2b18ee5416dd1438a31b54b1625bf7f6d9814993bcd7ac6", + "size": 25635, + "subdir": "linux-64", + "timestamp": 1663056722832, + "version": "0.20.0" + }, + "autovizwidget-0.20.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6", + "ipywidgets >5.0.0", + "notebook >=4.2", + "pandas >=0.20.1", + "plotly >=3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "239fc9a244238f0252df975712e355c4", + "name": "autovizwidget", + "sha256": "4c8423e1936d43bead27c367ed3921ab97291eafd84863d869310b555c1b103e", + "size": 25846, + "subdir": "linux-64", + "timestamp": 1663056779490, + "version": "0.20.0" + }, + "autovizwidget-0.20.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6", + "ipywidgets >5.0.0", + "notebook >=4.2", + "pandas >=0.20.1", + "plotly >=3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9ecc7dd0771c6600b459c41d931d1ff4", + "name": "autovizwidget", + "sha256": "e6f6548fddb73b77c034b6c8c7abdff23dae23135f06c0aacb524d960a02ebb5", + "size": 25880, + "subdir": "linux-64", + "timestamp": 1663056838075, + "version": "0.20.0" + }, + "aws-c-common-0.4.57-he6710b0_1.tar.bz2": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e883ae27a33cff702b8a20b5394e9ae0", + "name": "aws-c-common", + "sha256": "bc87abecbc7e34b42b5a7ec3a3470ee284ed82f5f638274f795810fd0aa85496", + "size": 164855, + "subdir": "linux-64", + "timestamp": 1601398346279, + "version": "0.4.57" + }, + "aws-c-common-0.4.58-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "81a71067812c3890c93003b707183e65", + "name": "aws-c-common", + "sha256": "4cf0926ef91f770f23c9bd0bc379f54c0fd22c9755f5b5df72a730c4a258dd71", + "size": 163738, + "subdir": "linux-64", + "timestamp": 1601487531644, + "version": "0.4.58" + }, + "aws-c-common-0.4.59-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c5ed883e32e53aa27e5f1a86ec7ff2af", + "name": "aws-c-common", + "sha256": "d019e2945eaff4070a6ef447b502feb5102f47be9409adbc1a13255df83eaf52", + "size": 163734, + "subdir": "linux-64", + "timestamp": 1601494937544, + "version": "0.4.59" + }, + "aws-c-common-0.4.63-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0dcffc110b5a61113fb4b75478c86934", + "name": "aws-c-common", + "sha256": "39687982a79b1ef4861fa2ba06bc44df1a88db40ffa0bd5ffcdfd02f574df984", + "size": 165011, + "subdir": "linux-64", + "timestamp": 1607533685043, + "version": "0.4.63" + }, + "aws-c-common-0.4.65-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bc5e84a2eca4c8bf25c685ff731f6f10", + "name": "aws-c-common", + "sha256": "02904d2aa45f2e6e25a8e5c71e19a482ec53593608fa275002ba9dad0d15c81b", + "size": 169066, + "subdir": "linux-64", + "timestamp": 1612239590013, + "version": "0.4.65" + }, + "aws-c-common-0.4.67-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9d946590b01bd6b48f5138e1203d68e5", + "name": "aws-c-common", + "sha256": "f70d8ee035804361625982cc0eab48b037914f81507d749eea22d4717fa443d2", + "size": 169036, + "subdir": "linux-64", + "timestamp": 1613246373585, + "version": "0.4.67" + }, + "aws-c-common-0.4.68-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b120e2e8faaf6df6e8a91216a47a51df", + "name": "aws-c-common", + "sha256": "eb630214218faaece300011a55e754c4af27e328ec8e2c0ec20be3864da2a2de", + "size": 168984, + "subdir": "linux-64", + "timestamp": 1613500960907, + "version": "0.4.68" + }, + "aws-c-common-0.5.1-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f50abfa224ac35d00e75426db618ef28", + "name": "aws-c-common", + "sha256": "375ff84e491776cf3096b2c9941af46c9aab94fafd43abc5a89d7c60f0aee5d1", + "size": 170485, + "subdir": "linux-64", + "timestamp": 1614020190484, + "version": "0.5.1" + }, + "aws-c-common-0.5.10-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a8dd2ad4efe0b4b2523bbb0ddc9b2621", + "name": "aws-c-common", + "sha256": "d6b9fcd28349195b1595b51a78c4a601c7ceb4501c5e3c5bf0005655365f7959", + "size": 171213, + "subdir": "linux-64", + "timestamp": 1620169320584, + "version": "0.5.10" + }, + "aws-c-common-0.5.11-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e215642501f07d58e136e8b8cd8fc6a3", + "name": "aws-c-common", + "sha256": "c5e568cc5a211cb707026648239a7e906ea4ad16b9b066bf181dc68750e43ded", + "size": 171108, + "subdir": "linux-64", + "timestamp": 1620309041499, + "version": "0.5.11" + }, + "aws-c-common-0.5.2-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "14b0a6639ccbc513659fb1c7fb677002", + "name": "aws-c-common", + "sha256": "5a8bee90e0bcc7a3b802d430c9160f2f359e8b7e12bd7c0e0f6912efb705fab0", + "size": 170196, + "subdir": "linux-64", + "timestamp": 1614967949195, + "version": "0.5.2" + }, + "aws-c-common-0.5.4-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4f99286791d53d40063f1b6cfecf66fc", + "name": "aws-c-common", + "sha256": "6beab312248490acf00e3bf97d34298a7b1d91365818cc4425962f6ca1d84537", + "size": 170966, + "subdir": "linux-64", + "timestamp": 1617985051193, + "version": "0.5.4" + }, + "aws-c-common-0.5.6-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "14d1c76d6128a64ff87561f8869c3c52", + "name": "aws-c-common", + "sha256": "eaba4ebf34162334e9e25258a4e0dee87a3098b44d0581827580f29ba334774b", + "size": 171285, + "subdir": "linux-64", + "timestamp": 1618693677487, + "version": "0.5.6" + }, + "aws-c-common-0.5.7-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "141e1b3721021312f38b300ed0b9972e", + "name": "aws-c-common", + "sha256": "787f90ea68303f1ba5e01af533db43aaf9c47d52a5ad769a312f3ec8a516190e", + "size": 171863, + "subdir": "linux-64", + "timestamp": 1618953284138, + "version": "0.5.7" + }, + "aws-c-common-0.5.8-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "05174e322e597a1d4ec78791b8ddc7af", + "name": "aws-c-common", + "sha256": "0ead3bb5949bd1a7cde39e6cc56580d55135298074eee62b99a0c637799da770", + "size": 172149, + "subdir": "linux-64", + "timestamp": 1619475184698, + "version": "0.5.8" + }, + "aws-c-common-0.6.1-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e5bcccbf49d237c4484f28fe301e5818", + "name": "aws-c-common", + "sha256": "4456af4bd250d4eb192716613932bb2297bc62da74ece025517a41528fdceecb", + "size": 173271, + "subdir": "linux-64", + "timestamp": 1623317369463, + "version": "0.6.1" + }, + "aws-c-common-0.6.2-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "98c89372f42b2c4b6c574572e54f5845", + "name": "aws-c-common", + "sha256": "a7224a4f1efafbff8b06d1a5392ea4b2cde983a22e9b64e96a3bc72b915acd74", + "size": 173329, + "subdir": "linux-64", + "timestamp": 1623861534141, + "version": "0.6.2" + }, + "aws-c-common-0.6.5-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4a5b510bfc8f8d320920c7eb6245eebb", + "name": "aws-c-common", + "sha256": "a348922e5d8fafced7ec77901a385fe8dc77ea9a980444498191c143b3f8060e", + "size": 173006, + "subdir": "linux-64", + "timestamp": 1625077054778, + "version": "0.6.5" + }, + "aws-c-common-0.6.8-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f471636f2b6e633bac63570ef02f98cd", + "name": "aws-c-common", + "sha256": "386b044511c0eb426fcfaedfc6e333e171c94cfdfbb4bc59b85cf0dc3478d3ef", + "size": 173420, + "subdir": "linux-64", + "timestamp": 1626499836370, + "version": "0.6.8" + }, + "aws-c-event-stream-0.1.6-h2531618_5.tar.bz2": { + "build": "h2531618_5", + "build_number": 5, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-checksums >=0.1.9,<0.1.10.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6b7ceb5ff64fc9f4537bfe7a2d7fe4a0", + "name": "aws-c-event-stream", + "sha256": "4f7d93ed96f6692266a700971029b841dc972a6af39b85ba9525eebe2c40edbb", + "size": 25449, + "subdir": "linux-64", + "timestamp": 1603894551837, + "version": "0.1.6" + }, + "aws-c-event-stream-0.1.6-he6710b0_3.tar.bz2": { + "build": "he6710b0_3", + "build_number": 3, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-checksums >=0.1.9,<0.1.10.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f8da38ce19866e60b65bb6b9c228409e", + "name": "aws-c-event-stream", + "sha256": "6cbca8737407903ace960ec387e5cab5d134f736a610329bd89dfc549593cb7e", + "size": 26618, + "subdir": "linux-64", + "timestamp": 1601398726771, + "version": "0.1.6" + }, + "aws-checksums-0.1.10-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.59,<0.4.60.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "67b00eba8297423aab7ec265effcfbbe", + "name": "aws-checksums", + "sha256": "f416a648b5dc51e0d3b6ce4ebd502dbf21787651f0f2f4032837554b429ce609", + "size": 51373, + "subdir": "linux-64", + "timestamp": 1607110350008, + "version": "0.1.10" + }, + "aws-checksums-0.1.11-h27cfd23_1.tar.bz2": { + "build": "h27cfd23_1", + "build_number": 1, + "depends": [ + "aws-c-common >=0.4.65,<0.4.66.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ea655a49559c3440d25c90937969a630", + "name": "aws-checksums", + "sha256": "faa305761be45ec15b7e6dacf19e62e936ce550dd1c672cecf4c771c55309243", + "size": 51309, + "subdir": "linux-64", + "timestamp": 1613246541923, + "version": "0.1.11" + }, + "aws-checksums-0.1.9-h2531618_2.tar.bz2": { + "build": "h2531618_2", + "build_number": 2, + "depends": [ + "aws-c-common >=0.4.59,<0.4.60.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5c17768fbd1dcf15d4fef35773d1c58a", + "name": "aws-checksums", + "sha256": "e0d675ee4fa23f71e320e307733dd3a8dab360276b367821a3c3c81c6d45449b", + "size": 51357, + "subdir": "linux-64", + "timestamp": 1603894579237, + "version": "0.1.9" + }, + "aws-checksums-0.1.9-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0a7ed2b675a5af15d4979f4ca5c93d39", + "name": "aws-checksums", + "sha256": "17d0e3361698b9a0a9b52836284b658886d25bf349f3a099b765eac23ceb4ebd", + "size": 52520, + "subdir": "linux-64", + "timestamp": 1601398555928, + "version": "0.1.9" + }, + "aws-sam-translator-1.22.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto3 >=1.5,<2.0a0", + "jsonschema >=3.0,<4.0a0", + "python >=3.6,<3.7.0a0", + "six >=1.11,<2.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b49172f512a6b54d49d7b31452012666", + "name": "aws-sam-translator", + "sha256": "4e2ef20be4a9fe1e96030bc2990c24c5f40b5c06f34f45856693ddc67aecd639", + "size": 211012, + "subdir": "linux-64", + "timestamp": 1588567745413, + "version": "1.22.0" + }, + "aws-sam-translator-1.22.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "boto3 >=1.5,<2.0a0", + "jsonschema >=3.0,<4.0a0", + "python >=3.7,<3.8.0a0", + "six >=1.11,<2.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b48f8da2975915745f8f3d033c3f9944", + "name": "aws-sam-translator", + "sha256": "01d8e0d0fc301f029660c5ea0a67996cc8e85bacd2cd91fd9c98d9065ea3dda1", + "size": 217198, + "subdir": "linux-64", + "timestamp": 1588567749755, + "version": "1.22.0" + }, + "aws-sam-translator-1.22.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "boto3 >=1.5,<2.0a0", + "jsonschema >=3.0,<4.0a0", + "python >=3.8,<3.9.0a0", + "six >=1.11,<2.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2957bb4a34f85c716762f3b91206e4ea", + "name": "aws-sam-translator", + "sha256": "2ebb0167467755e3e722235c35764f70191e39260c4d1cac08465d9e0097a6f2", + "size": 213194, + "subdir": "linux-64", + "timestamp": 1588567762245, + "version": "1.22.0" + }, + "aws-sdk-cpp-1.8.127-h9ba82fa_0.tar.bz2": { + "build": "h9ba82fa_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2c39a609a6b7c8947b92530632de8ac7", + "name": "aws-sdk-cpp", + "sha256": "6bd4210c46a8fbe8fa5b73786fcfa8a914374e6026cae4dded83f6da1d209ae4", + "size": 2407848, + "subdir": "linux-64", + "timestamp": 1611188588916, + "version": "1.8.127" + }, + "aws-sdk-cpp-1.8.129-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "99f940e7784779bd6dfeba9f779c6bd5", + "name": "aws-sdk-cpp", + "sha256": "7d008d015f443042594104288733738c52ab87b0f83b7de538431b78cb0b9861", + "size": 2398282, + "subdir": "linux-64", + "timestamp": 1611513718014, + "version": "1.8.129" + }, + "aws-sdk-cpp-1.8.130-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "107665733f8b2a61f695c791eee1a510", + "name": "aws-sdk-cpp", + "sha256": "dbf8c9f45d27a644bfdbfd3be34bc8b6ae087bbdd7786d62f62e5275aa08f20e", + "size": 2400242, + "subdir": "linux-64", + "timestamp": 1611777004405, + "version": "1.8.130" + }, + "aws-sdk-cpp-1.8.131-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eb7b331570d1a6b58ba2a1a325e5e34f", + "name": "aws-sdk-cpp", + "sha256": "b22a6ed28bcde1b7cef57e826a1c8e97c328cafb88efff8b7d36d334dffe12ff", + "size": 2399715, + "subdir": "linux-64", + "timestamp": 1611863590230, + "version": "1.8.131" + }, + "aws-sdk-cpp-1.8.132-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cdfc896ce4c09aa0bd710e4450e54b67", + "name": "aws-sdk-cpp", + "sha256": "f50b2f988bc480f7b95dad56727343f8f7905905edc215c997217076833cb9e6", + "size": 2403547, + "subdir": "linux-64", + "timestamp": 1611949858248, + "version": "1.8.132" + }, + "aws-sdk-cpp-1.8.133-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "210dd524e84e88317f135b753af8866a", + "name": "aws-sdk-cpp", + "sha256": "524d2ca320f9632c193bc17037adb901f262d611259fafc7baa23acc2b62ad70", + "size": 2405032, + "subdir": "linux-64", + "timestamp": 1612239824541, + "version": "1.8.133" + }, + "aws-sdk-cpp-1.8.141-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7bd2da54d17fea1fd7af360a94b8aeba", + "name": "aws-sdk-cpp", + "sha256": "2678833b883a4962b76d5695773541a3c0daaa1f95f3aa6a572178ef3bdbf93d", + "size": 2403773, + "subdir": "linux-64", + "timestamp": 1613246694772, + "version": "1.8.141" + }, + "aws-sdk-cpp-1.8.142-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6ce82cf84f8b40d3bb80bbcaca7f6cf9", + "name": "aws-sdk-cpp", + "sha256": "edc47eba2d6aef287181bce605235a542ec6ca44887acaa677caa71409f36a8c", + "size": 2397283, + "subdir": "linux-64", + "timestamp": 1613501139694, + "version": "1.8.142" + }, + "aws-sdk-cpp-1.8.143-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e18b1480ea0a1c1e9b1ff7626352b516", + "name": "aws-sdk-cpp", + "sha256": "d4b83b33ec2ec9c981be3f830bbd0896a24b99fa2208e70e323558d2ec1d69c7", + "size": 2400053, + "subdir": "linux-64", + "timestamp": 1613587349285, + "version": "1.8.143" + }, + "aws-sdk-cpp-1.8.144-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5a5f7eeb3d41451b87fb05a8ce6f599c", + "name": "aws-sdk-cpp", + "sha256": "0426feaf67d59fc3354bde0a7adca0490a8b85be69459cefbcf8c9e239de5278", + "size": 2399358, + "subdir": "linux-64", + "timestamp": 1613674514053, + "version": "1.8.144" + }, + "aws-sdk-cpp-1.8.145-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cc5d91e004ebb28d8c1efd86384df6c1", + "name": "aws-sdk-cpp", + "sha256": "72f1a742d097defdc57cde628911a3fa253ede0a1428126740c9ebbf163521f5", + "size": 2401381, + "subdir": "linux-64", + "timestamp": 1613761800639, + "version": "1.8.145" + }, + "aws-sdk-cpp-1.8.146-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1b0d4a5b150e01528c572bc6ce395de2", + "name": "aws-sdk-cpp", + "sha256": "cf2762a1345f473ab41ecd6d16fe7349c609d5226b70f4d7e4fb5f1cfea5a525", + "size": 2405664, + "subdir": "linux-64", + "timestamp": 1613847396713, + "version": "1.8.146" + }, + "aws-sdk-cpp-1.8.150-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ac55e4542b42f8d6fdfe48026e6de07a", + "name": "aws-sdk-cpp", + "sha256": "9130e19ee050fb58da87e49d41274af6dc37afe989086d9e87b98e057457a178", + "size": 2395323, + "subdir": "linux-64", + "timestamp": 1614361534872, + "version": "1.8.150" + }, + "aws-sdk-cpp-1.8.151-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0edaf3a86ce3a379456bd2764134088c", + "name": "aws-sdk-cpp", + "sha256": "4068c4bc5f71af58d797b9f211b32b4ef0eadef45b1c53957688a83c692c1987", + "size": 2400646, + "subdir": "linux-64", + "timestamp": 1614614536394, + "version": "1.8.151" + }, + "aws-sdk-cpp-1.8.152-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "35908c9ac099b5ef13352156685a1fb7", + "name": "aws-sdk-cpp", + "sha256": "e3e1c8bead26e6f99c14ff755f8500e84b068d9c2d1e84dba884ea27ff4be4dd", + "size": 2402065, + "subdir": "linux-64", + "timestamp": 1614709161690, + "version": "1.8.152" + }, + "aws-sdk-cpp-1.8.153-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e7eeb3458c69cb35f6515fe1beb54cda", + "name": "aws-sdk-cpp", + "sha256": "0b36fa9fb6d0fd135440c67ae690ee5083f7667e39d7b89af6d31a667ab827a5", + "size": 2401165, + "subdir": "linux-64", + "timestamp": 1614794705382, + "version": "1.8.153" + }, + "aws-sdk-cpp-1.8.154-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5d1f478fc5adbfbc5971466630b6403f", + "name": "aws-sdk-cpp", + "sha256": "7237f83a3b1032286368e0e14691737aabbdeb548974e7a4d3204056e6de92ee", + "size": 2400967, + "subdir": "linux-64", + "timestamp": 1614882586233, + "version": "1.8.154" + }, + "aws-sdk-cpp-1.8.155-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dd9292863646fd5c006d99a12a8f3862", + "name": "aws-sdk-cpp", + "sha256": "3e4470be84d0f90960e8b54d64795b7e9074196934ed3afb16011fa7f6c44124", + "size": 2415479, + "subdir": "linux-64", + "timestamp": 1614968105969, + "version": "1.8.155" + }, + "aws-sdk-cpp-1.8.156-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c0e05ed3ac0b2c90fbfb575f63553f0c", + "name": "aws-sdk-cpp", + "sha256": "b3b4e25d76dbae82b8406e87d3919c1f261a779c4679f140fcaaef2f5c34e16c", + "size": 2401031, + "subdir": "linux-64", + "timestamp": 1615054861731, + "version": "1.8.156" + }, + "aws-sdk-cpp-1.8.157-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1d7917c8ce1fd023b05e3120d2d7b873", + "name": "aws-sdk-cpp", + "sha256": "9a2b3a1eb62ff750c0068dc0c5224bfe9a1eea9d03bd7111ba63570162e87a0e", + "size": 2400665, + "subdir": "linux-64", + "timestamp": 1615314875909, + "version": "1.8.157" + }, + "aws-sdk-cpp-1.8.159-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "471792b7811080d682ac21184c9e5a12", + "name": "aws-sdk-cpp", + "sha256": "2307524b956eb30f4d0a521bfa72904697cc3e3ccaa2d22d10c350e62d3e774e", + "size": 2401886, + "subdir": "linux-64", + "timestamp": 1615411469097, + "version": "1.8.159" + }, + "aws-sdk-cpp-1.8.161-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "de399f62fddc7afa9375a85a30d3207e", + "name": "aws-sdk-cpp", + "sha256": "494b73d6ea12aaa26aea73696cee2af00a95ab658c7281fd98afe5312d1a50b1", + "size": 2413021, + "subdir": "linux-64", + "timestamp": 1615661073307, + "version": "1.8.161" + }, + "aws-sdk-cpp-1.8.162-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d59c5f091a8b157222eefef5ff0bb3ff", + "name": "aws-sdk-cpp", + "sha256": "1fe707ae2aedf36fa9e56abf2a206e3adb16e6fda8710397707d898e142414fc", + "size": 2420086, + "subdir": "linux-64", + "timestamp": 1615920922679, + "version": "1.8.162" + }, + "aws-sdk-cpp-1.8.163-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "09eb3802031821dbd7914f9a692f8614", + "name": "aws-sdk-cpp", + "sha256": "f73432fe18190cfbe9030a735e7de9d74238056bcb6fc378962f489518c93182", + "size": 2407563, + "subdir": "linux-64", + "timestamp": 1616005462218, + "version": "1.8.163" + }, + "aws-sdk-cpp-1.8.164-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c034307a1c0012fc27ff46dfe67956d8", + "name": "aws-sdk-cpp", + "sha256": "6ce40d782a72976fab2d1474ddade3dad7439e277d9215ab859d1c11c8c5761b", + "size": 2423256, + "subdir": "linux-64", + "timestamp": 1616091882324, + "version": "1.8.164" + }, + "aws-sdk-cpp-1.8.165-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dcddc48571f718773be7812bcdf261ae", + "name": "aws-sdk-cpp", + "sha256": "b1bb0ee19cca800ae66e356dabc30fee8f217166b8fea6af7872ed6aabc7a36b", + "size": 2425462, + "subdir": "linux-64", + "timestamp": 1616180530648, + "version": "1.8.165" + }, + "aws-sdk-cpp-1.8.166-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "221794f6dfeb983e57600738835541bb", + "name": "aws-sdk-cpp", + "sha256": "dfdc961c9d84ebd79a39f682cfa7a82de4696c69fad9dbddf5b70709c3e4a129", + "size": 2431496, + "subdir": "linux-64", + "timestamp": 1616268668583, + "version": "1.8.166" + }, + "aws-sdk-cpp-1.8.167-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c4ea66ce1a6fee6903dde8a431ce61ab", + "name": "aws-sdk-cpp", + "sha256": "7d0d42fe6c008e2f2e05d842eeead4eb7974449b163fc576db3b92b39a444acc", + "size": 2427214, + "subdir": "linux-64", + "timestamp": 1616442952944, + "version": "1.8.167" + }, + "aws-sdk-cpp-1.8.168-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "31369e75e1c56d994b04b634bdb99d22", + "name": "aws-sdk-cpp", + "sha256": "f0684db1cf7caa1da0d4b77e09329b928f3d84bae5aaef8950aac8b79c820f22", + "size": 2425330, + "subdir": "linux-64", + "timestamp": 1616527611609, + "version": "1.8.168" + }, + "aws-sdk-cpp-1.8.169-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a3e957e0e8e47d916769ebc9e96956b7", + "name": "aws-sdk-cpp", + "sha256": "1272aadf79954aab1d2fa08efc8bfe213311b6edc7b8334b1f8efc079f1ab277", + "size": 2428597, + "subdir": "linux-64", + "timestamp": 1616614410991, + "version": "1.8.169" + }, + "aws-sdk-cpp-1.8.170-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1adc53ca77b0d01e585bdc9c3f61fdf1", + "name": "aws-sdk-cpp", + "sha256": "e3b1e29d7fa3f62d166263d6902379745191796f5c879cc6aa1fefea826cf808", + "size": 2425368, + "subdir": "linux-64", + "timestamp": 1616700856358, + "version": "1.8.170" + }, + "aws-sdk-cpp-1.8.173-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c4e471298a4b19269e1743f49a55b020", + "name": "aws-sdk-cpp", + "sha256": "e6c1b308f685c5a6c06fa7e7c4e27022d5b9290decb2022b86303f3f1704495b", + "size": 2425281, + "subdir": "linux-64", + "timestamp": 1617117080646, + "version": "1.8.173" + }, + "aws-sdk-cpp-1.8.174-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a3d50f18b0df9e7afd655d18fd3adb65", + "name": "aws-sdk-cpp", + "sha256": "09d172ac95b6aa5ed0bf4ecfafb19308b0a46d03bcc8d44b27f44af4dbca9a65", + "size": 2441672, + "subdir": "linux-64", + "timestamp": 1617133484311, + "version": "1.8.174" + }, + "aws-sdk-cpp-1.8.175-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1bc5be3132e5d18bbccd559ae7416254", + "name": "aws-sdk-cpp", + "sha256": "281c7d9ebde0ee08843e6e39c55ee94b1724d32ec2cd52909055b7d317b2215b", + "size": 2439297, + "subdir": "linux-64", + "timestamp": 1617221600812, + "version": "1.8.175" + }, + "aws-sdk-cpp-1.8.176-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8efcd0430d21cf57d2d37a6ca901ad82", + "name": "aws-sdk-cpp", + "sha256": "b7f0470b8944c2c50b56bb1b57c4ec0a986a0c455eb59562b7e3bed34c57aa8b", + "size": 2440088, + "subdir": "linux-64", + "timestamp": 1617383733578, + "version": "1.8.176" + }, + "aws-sdk-cpp-1.8.177-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8221246b81f937d6107faeb567ebc3ba", + "name": "aws-sdk-cpp", + "sha256": "9c555efe58eadebde530f2079bfa23b7aa84f06f2ea0d80e5ce60a9d3a7a3681", + "size": 2439477, + "subdir": "linux-64", + "timestamp": 1617394251848, + "version": "1.8.177" + }, + "aws-sdk-cpp-1.8.181-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3127b4b0fa8fff41dc46fda21ff1cd45", + "name": "aws-sdk-cpp", + "sha256": "6583f5fbacd2dc7cef7db7cdc82e011d7761f1c3868d06a98ba36338ec5c88ee", + "size": 2436184, + "subdir": "linux-64", + "timestamp": 1617915978251, + "version": "1.8.181" + }, + "aws-sdk-cpp-1.8.182-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "44877dc5100b430537be0444c828d4c6", + "name": "aws-sdk-cpp", + "sha256": "a8323911c3b502ed34fe869827c31cd7c557e7decf729bbc4914efaa35eed11d", + "size": 2440472, + "subdir": "linux-64", + "timestamp": 1618000607417, + "version": "1.8.182" + }, + "aws-sdk-cpp-1.8.183-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5dfaade305b7f08432bb83966775dc4d", + "name": "aws-sdk-cpp", + "sha256": "52557c2a2189ddf1810a38482273d672d70e77f30bcb3d768e030f69a0f96961", + "size": 2428665, + "subdir": "linux-64", + "timestamp": 1618262047782, + "version": "1.8.183" + }, + "aws-sdk-cpp-1.8.184-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "05d8ce253ab8599cc1096946c03cd09e", + "name": "aws-sdk-cpp", + "sha256": "e439d690129dfb93b5755c583845eece870aef46fd811ebb22ab1ebefd64b0f1", + "size": 2442972, + "subdir": "linux-64", + "timestamp": 1618345401900, + "version": "1.8.184" + }, + "aws-sdk-cpp-1.8.185-hce553d0_0.tar.bz2": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5b4e9429338430ef3b71802778ac2184", + "name": "aws-sdk-cpp", + "sha256": "2842aafc907c01ccbe26ca11bddad6c55e9f93d30cf57431e327f5e57666be2c", + "size": 2442091, + "subdir": "linux-64", + "timestamp": 1618434946994, + "version": "1.8.185" + }, + "aws-xray-sdk-2.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "enum34", + "future", + "jsonpickle", + "python >=2.7,<2.8.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "924d6a38462a45765ade771048d48214", + "name": "aws-xray-sdk", + "sha256": "a752ad0c11908960d70ff9b34024d9bbae3ea2bb7deb6e023c927789abfd34a2", + "size": 100311, + "subdir": "linux-64", + "timestamp": 1552375046903, + "version": "2.4.2" + }, + "aws-xray-sdk-2.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "jsonpickle", + "python >=3.6,<3.7.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "f2a005567c1b6ca98f6974a0f5801783", + "name": "aws-xray-sdk", + "sha256": "c88a2b2b908cc1bac7197a5eef16e4fc32935658914d7cff867ad27cea95209f", + "size": 105580, + "subdir": "linux-64", + "timestamp": 1552375124960, + "version": "2.4.2" + }, + "aws-xray-sdk-2.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "jsonpickle", + "python >=3.7,<3.8.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "668524ba260d5a90bb03d2a46f77e96e", + "name": "aws-xray-sdk", + "sha256": "0d3f9451729e2bf2315a2c8e314f982714418aebd7773dd8e8e1b7952fdbfa25", + "size": 105794, + "subdir": "linux-64", + "timestamp": 1552375068425, + "version": "2.4.2" + }, + "aws-xray-sdk-2.4.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "jsonpickle", + "python >=3.8,<3.9.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "164b9e815c652dd54a197800db8e5a0c", + "name": "aws-xray-sdk", + "sha256": "a9632d125a083559d180ca8872ae4143f942b51f12e2d5545164126dfe825cbb", + "size": 111798, + "subdir": "linux-64", + "timestamp": 1574237367538, + "version": "2.4.2" + }, + "aws-xray-sdk-2.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "jsonpickle", + "python >=3.6,<3.7.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "be4aa1833136a36fb4b29e0c077819bc", + "name": "aws-xray-sdk", + "sha256": "724404e766f6e1b5a9ccaf3414d7410b87e585b4f79118061b2ea05d9970300d", + "size": 114908, + "subdir": "linux-64", + "timestamp": 1592209225673, + "version": "2.6.0" + }, + "aws-xray-sdk-2.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "jsonpickle", + "python >=3.7,<3.8.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "a82510288003215a85054f88e550ca67", + "name": "aws-xray-sdk", + "sha256": "0e3bba6b78bb972f04d5dc9196b1d8dde6cb8db56565eb3cd18a020ab7863607", + "size": 114998, + "subdir": "linux-64", + "timestamp": 1592209049898, + "version": "2.6.0" + }, + "aws-xray-sdk-2.6.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "jsonpickle", + "python >=3.8,<3.9.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "bdf367947b2b991193502ab98b76fcdf", + "name": "aws-xray-sdk", + "sha256": "894e91f67eb78aeab23608d3d205b0dd556ccde545ada2fc1b6c3403d619f7f5", + "size": 115517, + "subdir": "linux-64", + "timestamp": 1592209221502, + "version": "2.6.0" + }, + "aws-xray-sdk-2.8.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "python >=3.10,<3.11.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "3abd1092b6945a2c0bb1d02f6cb44eb3", + "name": "aws-xray-sdk", + "sha256": "964ae1f22428bd88c2245d6784d07aefda8311622418670082b0b8f251d1a1c4", + "size": 120740, + "subdir": "linux-64", + "timestamp": 1642519393864, + "version": "2.8.0" + }, + "aws-xray-sdk-2.8.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "python >=3.11,<3.12.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "13339eb1ce2eb6077c9ab55ca2f243f6", + "name": "aws-xray-sdk", + "sha256": "78229f606112789925b4563a8e5655bf0f6293e8572abcd2d53c6bda100b5172", + "size": 152346, + "subdir": "linux-64", + "timestamp": 1676843310393, + "version": "2.8.0" + }, + "aws-xray-sdk-2.8.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "python >=3.6,<3.7.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "08acd12d01a2c74770d3c9d0dc8abf3f", + "name": "aws-xray-sdk", + "sha256": "cd9933c2a79c310cc557cfd4462a74af1b762c06c65e4fc7cbc90204aa52cb7a", + "size": 119266, + "subdir": "linux-64", + "timestamp": 1621941891593, + "version": "2.8.0" + }, + "aws-xray-sdk-2.8.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "python >=3.7,<3.8.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "3f4652985593826c0a64711b7db41ce1", + "name": "aws-xray-sdk", + "sha256": "59e173d5570e60050cae04122f04e7846fb11094b80f05929dd48a77116b4187", + "size": 119600, + "subdir": "linux-64", + "timestamp": 1621946787074, + "version": "2.8.0" + }, + "aws-xray-sdk-2.8.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "python >=3.8,<3.9.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "d1219d996364560c758268852774672a", + "name": "aws-xray-sdk", + "sha256": "b7b72cd82a7fe574946fc0f8e6e48d8709f7c0a08d6a0a481387a4938b813aa2", + "size": 119596, + "subdir": "linux-64", + "timestamp": 1621946537491, + "version": "2.8.0" + }, + "aws-xray-sdk-2.8.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "python >=3.9,<3.10.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "db28897bf7063bd47aa62462c3398106", + "name": "aws-xray-sdk", + "sha256": "bfb3d68c916df93fb993a78a71efc6c66a0cf7452d59d4351a039762bf2e6317", + "size": 120267, + "subdir": "linux-64", + "timestamp": 1621946782048, + "version": "2.8.0" + }, + "azure-1.0.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests", + "setuptools" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "e9ef6ee3b9156187ab6c826696a89842", + "name": "azure", + "sha256": "605dadc89fd66bfdbada0786b03804bcb89f113780962ad03c4d3b76f4818276", + "size": 375248, + "subdir": "linux-64", + "timestamp": 1537285532853, + "version": "1.0.2" + }, + "azure-1.0.2-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests", + "setuptools" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "01e09dbff805ab433e3f54e8a37d182a", + "name": "azure", + "sha256": "bda6ad008b3e98bebb244065ce5043415cfca232ee93c0310d8a7e9f03c7522f", + "size": 379774, + "subdir": "linux-64", + "timestamp": 1537285499354, + "version": "1.0.2" + }, + "azure-1.0.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests", + "setuptools" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "1631a364ffe37eb4296cb818e3476cef", + "name": "azure", + "sha256": "320747a180e434faafa1135ac951c994c305dbd02b4b21c9221b9a5a951949b1", + "size": 376312, + "subdir": "linux-64", + "timestamp": 1537285535402, + "version": "1.0.2" + }, + "babel-2.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytz >=2015.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3e89c64fb56d74e0a91ec741a6661a0d", + "name": "babel", + "sha256": "959a5f86c833ccb6a15d04fde1079ddb4708762b0d90714828adbbc9b9646fc3", + "size": 7102372, + "subdir": "linux-64", + "timestamp": 1671782043176, + "version": "2.11.0" + }, + "babel-2.11.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "pytz >=2015.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d0cde1ca577520a608da5ab86421f9aa", + "name": "babel", + "sha256": "8da2bfb50812660c69643386afa2a2d0ce9f2b0168e9b7a372349901d7d4b2f7", + "size": 7241236, + "subdir": "linux-64", + "timestamp": 1676825038806, + "version": "2.11.0" + }, + "babel-2.11.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz >=2015.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f10113c87db5bb253681bffaf98f70a", + "name": "babel", + "sha256": "d6e751db730f5366101ab2452537065741cb562d6136802a25bf5b9648bc92e0", + "size": 7101214, + "subdir": "linux-64", + "timestamp": 1671781965544, + "version": "2.11.0" + }, + "babel-2.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz >=2015.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa4fbdd1b2b6737f8a8964f51b042b8e", + "name": "babel", + "sha256": "3d67e32268ef35c1a6d0836ac12691702c3282ba342bd235f298856430e91ca7", + "size": 7113272, + "subdir": "linux-64", + "timestamp": 1671782004532, + "version": "2.11.0" + }, + "babel-2.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytz >=2015.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "761b21d8dbba7e567fe80074ad3785d7", + "name": "babel", + "sha256": "d51bf36ec6d2c4e9344d53935782c3c9aac0590215c7b957fcf89a033afcafe9", + "size": 7114765, + "subdir": "linux-64", + "timestamp": 1671782080890, + "version": "2.11.0" + }, + "babel-2.5.0-py27h20693cd_0.tar.bz2": { + "build": "py27h20693cd_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "1ec63554355189152bc497aae8a14a04", + "name": "babel", + "sha256": "024b13d003188504009d67f52de6934429240f75d81fdb3d25beef2a26d27745", + "size": 4883533, + "subdir": "linux-64", + "timestamp": 1505728506605, + "version": "2.5.0" + }, + "babel-2.5.0-py35ha5fc564_0.tar.bz2": { + "build": "py35ha5fc564_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "c00e49013d72101c2c3c74622d030cd8", + "name": "babel", + "sha256": "65e60a4443cb2296c5de2736cc76df9f7e157ea82f151367e1378ab63bd2ffe1", + "size": 4881837, + "subdir": "linux-64", + "timestamp": 1505728533655, + "version": "2.5.0" + }, + "babel-2.5.0-py36h7d14adf_0.tar.bz2": { + "build": "py36h7d14adf_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "aec75498121b86ec5dc9b4f126e65cbc", + "name": "babel", + "sha256": "17a732d7ca9e3c6ae1c7cd8e0777844f81fbf40eebe4300d6e3d93477c5bdd87", + "size": 4885150, + "subdir": "linux-64", + "timestamp": 1505728560805, + "version": "2.5.0" + }, + "babel-2.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "094c0f13cef4f195029013b85a1aa40b", + "name": "babel", + "sha256": "30bc3194c3a8d5d17018665e9907287760c7b18c54116bed9b9b29fbb6e0ec82", + "size": 4885712, + "subdir": "linux-64", + "timestamp": 1515702580954, + "version": "2.5.1" + }, + "babel-2.5.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "f37612736f5b38cf2dfc55ecf7024fff", + "name": "babel", + "sha256": "bfe6d994a6ac562d522cafeb7225ada93cffb47f28edbe0f0664213dd58ff6fd", + "size": 4885019, + "subdir": "linux-64", + "timestamp": 1515702688520, + "version": "2.5.1" + }, + "babel-2.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "91e2f6ca0bf09c0c1aed87534ece38d2", + "name": "babel", + "sha256": "d3f5b1e0768f77152ef43d648b2d1fc874e1bb4a69f1b48814888579ccb5de0f", + "size": 4887352, + "subdir": "linux-64", + "timestamp": 1515702538520, + "version": "2.5.1" + }, + "babel-2.5.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "c2572d080d65051d1bc250b717365f61", + "name": "babel", + "sha256": "63ab40477b0d4bea53b460ce38a4c77dde4298d30073def55ffd1a4abe5748ed", + "size": 4884618, + "subdir": "linux-64", + "timestamp": 1516378719309, + "version": "2.5.3" + }, + "babel-2.5.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "2dd036e93fe28757507c09ea93323a0f", + "name": "babel", + "sha256": "5fb76ab6122b7415c671f3260d9a2fee27be63bee522c06544385302806408e3", + "size": 4884298, + "subdir": "linux-64", + "timestamp": 1516378782330, + "version": "2.5.3" + }, + "babel-2.5.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "34797db113b9bbcec680ad090ab4ac65", + "name": "babel", + "sha256": "c293efddb1d19659bd177a5633495af08a18782e7aa786a2f107bd0cf78b3ae2", + "size": 4885558, + "subdir": "linux-64", + "timestamp": 1516378782334, + "version": "2.5.3" + }, + "babel-2.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "a6e32d93ae7586896829445b1fad19aa", + "name": "babel", + "sha256": "31d87010cf79978134fc4375c07c76c20d2bf83d144cf8bac8cfdeb40c1d53a2", + "size": 5953389, + "subdir": "linux-64", + "timestamp": 1527827831797, + "version": "2.6.0" + }, + "babel-2.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "38fc344d229a98c1ae4fbed959122cf5", + "name": "babel", + "sha256": "db202534776d643dd56a34e12fecb88aba20ca85dbf549c617923593808f3807", + "size": 5962254, + "subdir": "linux-64", + "timestamp": 1527827839450, + "version": "2.6.0" + }, + "babel-2.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "563ea98da70b64f914a8ebaf8297a90a", + "name": "babel", + "sha256": "0b44c0775938c5c15c80df53a04fe51cbf30953883f2918cd4f3025475ace092", + "size": 5960204, + "subdir": "linux-64", + "timestamp": 1527827807195, + "version": "2.6.0" + }, + "babel-2.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "4c53334837d9143bb094f4070d5ccd7f", + "name": "babel", + "sha256": "efa21f17e51186ac1a6a2e5c49cb3a8544dfad4973ea4f3008bdabe7f3d65a70", + "size": 5962696, + "subdir": "linux-64", + "timestamp": 1530695304357, + "version": "2.6.0" + }, + "backcall-0.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "19f49c740098e5420a4ad4ac95df741a", + "name": "backcall", + "sha256": "da2ee195f65122450d83d96c9cb888f2c5314506f95c8d8220a196d7b7a2c084", + "size": 19465, + "subdir": "linux-64", + "timestamp": 1522690904215, + "version": "0.1.0" + }, + "backcall-0.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "720826fe9823d985c03e5193e68fa6d3", + "name": "backcall", + "sha256": "a579b20a68e1abdb68848b9df3ddc65051aa67807f32b820aabe0a8b261926c4", + "size": 19803, + "subdir": "linux-64", + "timestamp": 1522690911313, + "version": "0.1.0" + }, + "backcall-0.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "18766b85a522ca545a80a31d7e5a6534", + "name": "backcall", + "sha256": "659cdcfe5168d167d27898952a6f77706ab9157234bda324f6b8a255f1023f83", + "size": 19686, + "subdir": "linux-64", + "timestamp": 1522690976979, + "version": "0.1.0" + }, + "backcall-0.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7b0a877243f8952fac4d1069b3317f7c", + "name": "backcall", + "sha256": "0264fea1772b794b7843acbf1794502630e337e356d680c4b053c208b95acbe8", + "size": 20019, + "subdir": "linux-64", + "timestamp": 1530733699748, + "version": "0.1.0" + }, + "backcall-0.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "207bb8e9bee4448c8a71522f161b617d", + "name": "backcall", + "sha256": "759410564a2237693cce06fefe71d284fe1f9169bebe2cfd9b25beaaa8d0cd8e", + "size": 20524, + "subdir": "linux-64", + "timestamp": 1572437351326, + "version": "0.1.0" + }, + "backports-1.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "19897f737310a5930fb76541a06fd6ed", + "name": "backports", + "sha256": "cdb65ed147b5f36db21a06add9cb38e2f4ba9c35cabf79d9814267be32e644a4", + "size": 3537, + "subdir": "linux-64", + "timestamp": 1530737800625, + "version": "1.0" + }, + "backports-1.0-py27h63c9359_1.tar.bz2": { + "build": "py27h63c9359_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "f31c243bbcc0961ce4982d11673cc9be", + "name": "backports", + "sha256": "b0429172aba9aedb4662a405cb20553cc8df757dd27676a3781671e84eb22987", + "size": 3359, + "subdir": "linux-64", + "timestamp": 1505956835859, + "version": "1.0" + }, + "backports-1.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "5bfec269d631fd3ac2f81c4f3ef70165", + "name": "backports", + "sha256": "1873c9daf2d90ee4e8979eb2dc2f3d75bcae0d2740733eb7feb051657c024687", + "size": 3511, + "subdir": "linux-64", + "timestamp": 1534352800109, + "version": "1.0" + }, + "backports-1.0-py35hd471ac7_1.tar.bz2": { + "build": "py35hd471ac7_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "b51366efc44379112446a2a645946ae3", + "name": "backports", + "sha256": "79c93943b15075423057b9506be922737391cd28bae51243e40a3a9c93a5b375", + "size": 3412, + "subdir": "linux-64", + "timestamp": 1505956848475, + "version": "1.0" + }, + "backports-1.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "ec7b5b0b3113be046b00d192f63db6c6", + "name": "backports", + "sha256": "f89d6beb03e3c5226a76b0d2a01bac359b1b6b09e74833fdca60e7ba736063ae", + "size": 3577, + "subdir": "linux-64", + "timestamp": 1530737780068, + "version": "1.0" + }, + "backports-1.0-py36hfa02d7e_1.tar.bz2": { + "build": "py36hfa02d7e_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "905fd8cd358b2741316ccc208aa5c3bc", + "name": "backports", + "sha256": "1db8133f08edf72350324dad4a81d2ea98833df032046812612ba0b5ce4fbd52", + "size": 3412, + "subdir": "linux-64", + "timestamp": 1505956861253, + "version": "1.0" + }, + "backports-1.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "e9021aa51c647671352227d339adaf73", + "name": "backports", + "sha256": "fdaaee4b99f1f530e5fcb327a524dc50c28c8f1edc803a5d659284b15941e8b5", + "size": 3582, + "subdir": "linux-64", + "timestamp": 1530737821507, + "version": "1.0" + }, + "backports.functools_lru_cache-1.4-py27he8db605_1.tar.bz2": { + "build": "py27he8db605_1", + "build_number": 1, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31fd3037467df2a4b036ef33d63c55d7", + "name": "backports.functools_lru_cache", + "sha256": "c2c09a469f5917a9fa27291c61f15553ae76c2b9c2e34dcac2d9a015c23f5194", + "size": 8962, + "subdir": "linux-64", + "timestamp": 1505693903100, + "version": "1.4" + }, + "backports.functools_lru_cache-1.5-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "644f6111f99c3aa57a15179e55c76c3d", + "name": "backports.functools_lru_cache", + "sha256": "7fa1050ba5bae630020649e1bb8e9594616260815692c4f2d96b4dbdb94742fb", + "size": 9328, + "subdir": "linux-64", + "timestamp": 1519170609770, + "version": "1.5" + }, + "backports.lzma-0.0.10-py27hfe699d2_0.tar.bz2": { + "build": "py27hfe699d2_0", + "build_number": 0, + "depends": [ + "backports", + "future", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "xz >=5.2.3,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f274a77f41328d63436a5bde78dca7ab", + "name": "backports.lzma", + "sha256": "5635d1af5762e6ab1ea95d62d661494338686d6e69323c540009cba19b49fe4a", + "size": 45211, + "subdir": "linux-64", + "timestamp": 1524584565815, + "version": "0.0.10" + }, + "backports.lzma-0.0.10-py35hfe699d2_0.tar.bz2": { + "build": "py35hfe699d2_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "xz >=5.2.3,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cf9b5b4068677b22cd88e87a1615ee69", + "name": "backports.lzma", + "sha256": "a80ca37d054e5aa77679a0637a3d815651fab81b8d2c71da131ce2b6c761b09b", + "size": 45014, + "subdir": "linux-64", + "timestamp": 1524584565517, + "version": "0.0.10" + }, + "backports.lzma-0.0.10-py36hfe699d2_0.tar.bz2": { + "build": "py36hfe699d2_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "xz >=5.2.3,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "13ddd4f7c482b326d8530625bca01c79", + "name": "backports.lzma", + "sha256": "261b561c5d80fd74c840bfb48ca8486209c79f1f796996cc5b6ae42f2ec6c24a", + "size": 44966, + "subdir": "linux-64", + "timestamp": 1524584565652, + "version": "0.0.10" + }, + "backports.lzma-0.0.11-py27hfe699d2_0.tar.bz2": { + "build": "py27hfe699d2_0", + "build_number": 0, + "depends": [ + "backports", + "future", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cbf6613693d7dde1a819b201e9d09c3e", + "name": "backports.lzma", + "sha256": "7e7eda6a7f549e58def4ad446bee9981f6fdae4a74612e3f6e29cafd5da2cd4d", + "size": 45323, + "subdir": "linux-64", + "timestamp": 1526939800393, + "version": "0.0.11" + }, + "backports.lzma-0.0.11-py35hfe699d2_0.tar.bz2": { + "build": "py35hfe699d2_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e1744286cff22646611c9455dea394b8", + "name": "backports.lzma", + "sha256": "1bb1c997419a42e1f70e319cc4fca5b07b21dfaf5cde4467e81a9cb9d72cdcb6", + "size": 45093, + "subdir": "linux-64", + "timestamp": 1526939957886, + "version": "0.0.11" + }, + "backports.lzma-0.0.11-py36hfe699d2_0.tar.bz2": { + "build": "py36hfe699d2_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "44b2d685109da957c1258b4677633780", + "name": "backports.lzma", + "sha256": "dcead471c4639738c7089d61ad475cbd50e928894fe8cd820c8a291613076a6c", + "size": 45079, + "subdir": "linux-64", + "timestamp": 1526939861240, + "version": "0.0.11" + }, + "backports.lzma-0.0.11-py37hfe699d2_0.tar.bz2": { + "build": "py37hfe699d2_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6ad3cf645b742951fca93ca6d6872add", + "name": "backports.lzma", + "sha256": "549e96d44803b736abd23f1cf585b5973c83e18147faad8b75bbb69703807576", + "size": 45180, + "subdir": "linux-64", + "timestamp": 1530738871755, + "version": "0.0.11" + }, + "backports.lzma-0.0.13-py27hd36a4d9_0.tar.bz2": { + "build": "py27hd36a4d9_0", + "build_number": 0, + "depends": [ + "backports", + "future", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ef954acf20536cbc28f7e39064dd39fb", + "name": "backports.lzma", + "sha256": "f6cac85bdc946ecccab60213380d1d57c8b1768631f32f19a750aa9c78b9ecc5", + "size": 45560, + "subdir": "linux-64", + "timestamp": 1535509512034, + "version": "0.0.13" + }, + "backports.lzma-0.0.13-py35hd36a4d9_0.tar.bz2": { + "build": "py35hd36a4d9_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bed27802fedb6e6f74c30ae565a9885c", + "name": "backports.lzma", + "sha256": "a698f064edf5237109aa1e4f9832f56a123a215395c39d24f0f54fe1cf69aec3", + "size": 45225, + "subdir": "linux-64", + "timestamp": 1535509544196, + "version": "0.0.13" + }, + "backports.lzma-0.0.13-py36hd36a4d9_0.tar.bz2": { + "build": "py36hd36a4d9_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c95f4c3e34d71a0a598e0792f5bdb17f", + "name": "backports.lzma", + "sha256": "759beb986008edc7f206cec7ec1f03ddbf57faa2cf0d33101c213272903d8667", + "size": 45170, + "subdir": "linux-64", + "timestamp": 1535509482926, + "version": "0.0.13" + }, + "backports.lzma-0.0.13-py37hd36a4d9_0.tar.bz2": { + "build": "py37hd36a4d9_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4ff6c45d803198bc91e2d7b1c5c8c23f", + "name": "backports.lzma", + "sha256": "bbc2d1b609fa244d5250d6ed852ace31b363831b4c0cbf7003447ad5d958f9cd", + "size": 45204, + "subdir": "linux-64", + "timestamp": 1535509534553, + "version": "0.0.13" + }, + "backports.lzma-0.0.14-py27hd36a4d9_0.tar.bz2": { + "build": "py27hd36a4d9_0", + "build_number": 0, + "depends": [ + "backports", + "future", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "84e02aa2b80e3c04c0e10e056710c347", + "name": "backports.lzma", + "sha256": "b9cadd662eacc9726040b5c734d53aa3b48eb6668294434b235c973ee3613f2d", + "size": 53137, + "subdir": "linux-64", + "timestamp": 1569508892998, + "version": "0.0.14" + }, + "backports.lzma-0.0.14-py310h5cf449c_0.tar.bz2": { + "build": "py310h5cf449c_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "xz >=5.2.5,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5c8969f2760ce0bf44775406aba353b9", + "name": "backports.lzma", + "sha256": "8ca4fe8bf5def6c1f7a95f9eb6b08e899c500a7a60054dda0effc6cb996f5af8", + "size": 78410, + "subdir": "linux-64", + "timestamp": 1640788393727, + "version": "0.0.14" + }, + "backports.lzma-0.0.14-py36h5905bc5_0.tar.bz2": { + "build": "py36h5905bc5_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "xz >=5.2.5,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d076e2989f01ab0eb80c3e8e4501ca10", + "name": "backports.lzma", + "sha256": "f2fe4932bf031aa607a52fedf0cdfabd3fbb5dfe3643ab4ef7a7799165efd357", + "size": 53013, + "subdir": "linux-64", + "timestamp": 1613153890561, + "version": "0.0.14" + }, + "backports.lzma-0.0.14-py36hd36a4d9_0.tar.bz2": { + "build": "py36hd36a4d9_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f54f8710c006e4c9a8aacdbd416ddd1d", + "name": "backports.lzma", + "sha256": "d6d45dc91918e7d74b269179b82b8c42a2332fb0b143982ca23b3d2d6af92df5", + "size": 52902, + "subdir": "linux-64", + "timestamp": 1569508861261, + "version": "0.0.14" + }, + "backports.lzma-0.0.14-py37h5905bc5_0.tar.bz2": { + "build": "py37h5905bc5_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "xz >=5.2.5,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "63d262ad0b61998b92e0f6290f6452d7", + "name": "backports.lzma", + "sha256": "2d01007febe2d1cb999d1ffd51a5aded001c8a1cb65ad173d5007c6801af2065", + "size": 53021, + "subdir": "linux-64", + "timestamp": 1613154350137, + "version": "0.0.14" + }, + "backports.lzma-0.0.14-py37hd36a4d9_0.tar.bz2": { + "build": "py37hd36a4d9_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c27d5eb20b2516744f649b89df886022", + "name": "backports.lzma", + "sha256": "c6bb0edf07ca65e7366b061742c21502ee6d773b5a429e26a6ffabf994a4fac6", + "size": 52941, + "subdir": "linux-64", + "timestamp": 1569508871582, + "version": "0.0.14" + }, + "backports.lzma-0.0.14-py38h5905bc5_0.tar.bz2": { + "build": "py38h5905bc5_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "xz >=5.2.5,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e7af963ef33f603885a53d88a338166f", + "name": "backports.lzma", + "sha256": "e7c17f3576a2029c5769ea5fb08a893f19eaf088cc4f7b25992615d7b2017011", + "size": 53200, + "subdir": "linux-64", + "timestamp": 1613153532351, + "version": "0.0.14" + }, + "backports.lzma-0.0.14-py38hd36a4d9_0.tar.bz2": { + "build": "py38hd36a4d9_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8869a80ec8625cf710c5b4111eff446e", + "name": "backports.lzma", + "sha256": "3ad1e3d3e1881fb8a46836e01c6a6cc5c1635bb59ad3788284bf17cb78824686", + "size": 56891, + "subdir": "linux-64", + "timestamp": 1573738089071, + "version": "0.0.14" + }, + "backports.lzma-0.0.14-py39h5905bc5_0.tar.bz2": { + "build": "py39h5905bc5_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "xz >=5.2.5,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "47149ba5f7dfe57d80b592c672631937", + "name": "backports.lzma", + "sha256": "2d62aa28844dc940577156d5e5078e28f4d0bf3b38d2ef963bc1830476d97082", + "size": 53169, + "subdir": "linux-64", + "timestamp": 1613154340484, + "version": "0.0.14" + }, + "backports.lzma-0.0.8-py27hfe699d2_2.tar.bz2": { + "build": "py27hfe699d2_2", + "build_number": 2, + "depends": [ + "backports", + "future", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "xz >=5.2.3,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5368ce86b1c0fc15b0bdf279e3ab5479", + "name": "backports.lzma", + "sha256": "489f8ae6d35e82d77f02ce72e3106d9b7458b67ecc14e65786c51456338efefa", + "size": 43994, + "subdir": "linux-64", + "timestamp": 1514119908334, + "version": "0.0.8" + }, + "backports.lzma-0.0.8-py35hfe699d2_2.tar.bz2": { + "build": "py35hfe699d2_2", + "build_number": 2, + "depends": [ + "backports", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "xz >=5.2.3,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "550f9846c95472abed8c55dbe73795bd", + "name": "backports.lzma", + "sha256": "29af50c37c366a7fe0565954d2c8d9549459d1ce1ad128386b208f997191161b", + "size": 43850, + "subdir": "linux-64", + "timestamp": 1514119920290, + "version": "0.0.8" + }, + "backports.lzma-0.0.8-py36hfe699d2_2.tar.bz2": { + "build": "py36hfe699d2_2", + "build_number": 2, + "depends": [ + "backports", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "xz >=5.2.3,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3bdee1c5cc461fede910ed83b1db99f3", + "name": "backports.lzma", + "sha256": "67cd1aa83ae505760d4a1f8decd10e7e96d8a6bd25b0fc9028d479c4f0531751", + "size": 43837, + "subdir": "linux-64", + "timestamp": 1514119920248, + "version": "0.0.8" + }, + "backports.os-0.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports", + "future", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "a6d9eea9cd978faf247bc4b72c686954", + "name": "backports.os", + "sha256": "9bdf2590beb867d152536705eecb00f0cc14e539438335e114f2d9417b78b36a", + "size": 15718, + "subdir": "linux-64", + "timestamp": 1539703281762, + "version": "0.1.1" + }, + "backports.os-0.1.1-py310h06a4308_1002.tar.bz2": { + "build": "py310h06a4308_1002", + "build_number": 1002, + "depends": [ + "backports", + "python >=3.10,<3.11.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "cce85a0199cb2a7d7efef36d385dcb54", + "name": "backports.os", + "sha256": "ed57e1db8f99c9e2f31a04cc9d785880b61a2aa3d119ba6c4e8d068b1f2f5e56", + "size": 15759, + "subdir": "linux-64", + "timestamp": 1642511329373, + "version": "0.1.1" + }, + "backports.os-0.1.1-py311h06a4308_1000.tar.bz2": { + "build": "py311h06a4308_1000", + "build_number": 1000, + "depends": [ + "backports", + "python >=3.11,<3.12.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "775b041da31fe22e616dbd2c0274fd79", + "name": "backports.os", + "sha256": "102beb32d41a99834160938fceb044b0fff44cba90c83466cc0a67baa413e9d9", + "size": 17780, + "subdir": "linux-64", + "timestamp": 1676846894543, + "version": "0.1.1" + }, + "backports.os-0.1.1-py311h06a4308_1002.tar.bz2": { + "build": "py311h06a4308_1002", + "build_number": 1002, + "depends": [ + "backports", + "python >=3.11,<3.12.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "136af36af23d0519e252cfb07345a9c4", + "name": "backports.os", + "sha256": "673ab0e3381e4bc3df10dd1be81af4ed3568a8a37e5224dea03f09ef99f5962e", + "size": 17503, + "subdir": "linux-64", + "timestamp": 1679335401093, + "version": "0.1.1" + }, + "backports.os-0.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "dab1cb9c18bbc936da1d641d28fd564f", + "name": "backports.os", + "sha256": "80e577ac2c8af6c50e1e1c2b992091692881047fb60b58a3ebc3678ffbeece98", + "size": 15727, + "subdir": "linux-64", + "timestamp": 1539703309776, + "version": "0.1.1" + }, + "backports.os-0.1.1-py36h06a4308_1000.tar.bz2": { + "build": "py36h06a4308_1000", + "build_number": 1000, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "c2b1f685c4ab510951ffea07d35172a2", + "name": "backports.os", + "sha256": "1ecf13997e522badf7da883934af2f470751fbd613cc1cc05482f3599a84df75", + "size": 16573, + "subdir": "linux-64", + "timestamp": 1613157576534, + "version": "0.1.1" + }, + "backports.os-0.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "ab72294c4483fd7a93ccf2179c94e38d", + "name": "backports.os", + "sha256": "bbb536ec1ed20d615187d51633dcb1cba0d93f1615dcd7d3c606396b2a915985", + "size": 15714, + "subdir": "linux-64", + "timestamp": 1539703308789, + "version": "0.1.1" + }, + "backports.os-0.1.1-py37_1002.tar.bz2": { + "build": "py37_1002", + "build_number": 1002, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "2384565b40b7f4a6b926ec0e92ced925", + "name": "backports.os", + "sha256": "0c6ebe8050161f8ae8d92b95674a9d09324ed3d432072ca6ee436a63d62538ac", + "size": 15058, + "subdir": "linux-64", + "timestamp": 1594340489856, + "version": "0.1.1" + }, + "backports.os-0.1.1-py37h06a4308_1000.tar.bz2": { + "build": "py37h06a4308_1000", + "build_number": 1000, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "428027b1e6e88083286ec0fe0f9414c9", + "name": "backports.os", + "sha256": "7a193e692daed565663fc7effdc4c00e0a31aca94a2fac27debeeca15b604325", + "size": 16581, + "subdir": "linux-64", + "timestamp": 1613157572542, + "version": "0.1.1" + }, + "backports.os-0.1.1-py38_1000.tar.bz2": { + "build": "py38_1000", + "build_number": 1000, + "depends": [ + "backports", + "python >=3.8,<3.9.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "0ee84c5eb1ec54ec699091e1327267c1", + "name": "backports.os", + "sha256": "95249845fad369e9650948247612b11dc9d42f892f2f4357ada7007f60802f36", + "size": 15927, + "subdir": "linux-64", + "timestamp": 1573738104895, + "version": "0.1.1" + }, + "backports.os-0.1.1-py38h06a4308_1000.tar.bz2": { + "build": "py38h06a4308_1000", + "build_number": 1000, + "depends": [ + "backports", + "python >=3.8,<3.9.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "a203373933b0cd78d8e77d957d20af6e", + "name": "backports.os", + "sha256": "886dc43e6b23a17b9b6d4bcdd1cb90e01c9ae9b128033fdf6a39be995c3bd691", + "size": 16638, + "subdir": "linux-64", + "timestamp": 1613157579626, + "version": "0.1.1" + }, + "backports.os-0.1.1-py39h06a4308_1000.tar.bz2": { + "build": "py39h06a4308_1000", + "build_number": 1000, + "depends": [ + "backports", + "python >=3.9,<3.10.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "d12803901cdb26cfb62d38934e5b73ae", + "name": "backports.os", + "sha256": "764c362c7db68e27b80ebf9796aa977043d431bfd9feb187fc005db190b53342", + "size": 16641, + "subdir": "linux-64", + "timestamp": 1613157569689, + "version": "0.1.1" + }, + "backports.shutil_get_terminal_size-1.0.0-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "63b4c2904c07cacea5b5f265f74dc0a0", + "name": "backports.shutil_get_terminal_size", + "sha256": "0e73ce4f7a70a6842982b4a9c3c12c06807c420627ed20dfbc4d0c57718eac12", + "size": 8027, + "subdir": "linux-64", + "timestamp": 1530738921693, + "version": "1.0.0" + }, + "backports.shutil_get_terminal_size-1.0.0-py27h5bc021e_2.tar.bz2": { + "build": "py27h5bc021e_2", + "build_number": 2, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "be1b5ece34656af0926fc825e9b00425", + "name": "backports.shutil_get_terminal_size", + "sha256": "6c5f71a8dba08cfbb0248e177a217638f14d07f7a1f3dbe8df0d9572376b6ad8", + "size": 7686, + "subdir": "linux-64", + "timestamp": 1505956875861, + "version": "1.0.0" + }, + "backports.shutil_get_terminal_size-1.0.0-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "backports", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "9ddfd593976908a163b61faf9ec36602", + "name": "backports.shutil_get_terminal_size", + "sha256": "32857cd99976cc3bf420febd6c0cd95f25c76ccc4988d1c900b2df2cb3364b81", + "size": 8089, + "subdir": "linux-64", + "timestamp": 1534355311565, + "version": "1.0.0" + }, + "backports.shutil_get_terminal_size-1.0.0-py35h40844db_2.tar.bz2": { + "build": "py35h40844db_2", + "build_number": 2, + "depends": [ + "backports", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "5ec4cd6c85ca5e4aa7d36221df2c0c92", + "name": "backports.shutil_get_terminal_size", + "sha256": "e76f827fcb2c564de106830b927f50e9215e33ce238709af4018edc9dc6cadf0", + "size": 7796, + "subdir": "linux-64", + "timestamp": 1505956890176, + "version": "1.0.0" + }, + "backports.shutil_get_terminal_size-1.0.0-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a677691c2a8816f1ae76555dac0061c7", + "name": "backports.shutil_get_terminal_size", + "sha256": "fe16beb7fbd766cac1be9d975ab60be1388a141446cdb428cc7778bcb4c398a7", + "size": 8109, + "subdir": "linux-64", + "timestamp": 1530738899753, + "version": "1.0.0" + }, + "backports.shutil_get_terminal_size-1.0.0-py36hfea85ff_2.tar.bz2": { + "build": "py36hfea85ff_2", + "build_number": 2, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4a7f4c0063132ded8bffe3195fc2184a", + "name": "backports.shutil_get_terminal_size", + "sha256": "f7d0d79bfed724730a3b37e551d78ff62f9c18204f65c154e9e7234133f04135", + "size": 7736, + "subdir": "linux-64", + "timestamp": 1505956904525, + "version": "1.0.0" + }, + "backports.shutil_get_terminal_size-1.0.0-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ef775703a7b2dffb2e26ec893e4fedb1", + "name": "backports.shutil_get_terminal_size", + "sha256": "c8c6acd964ae935da4f51b0fe505cfa970675589f1493d0f7d0b96f376e32552", + "size": 8112, + "subdir": "linux-64", + "timestamp": 1530738943847, + "version": "1.0.0" + }, + "backports.shutil_get_terminal_size-1.0.0-py38_2.tar.bz2": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "backports", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "e37893a0664e4a5b5797db0b281fd53c", + "name": "backports.shutil_get_terminal_size", + "sha256": "502024449eebe258387d4c39a63525ddfcdb6828e8bac7e036843cb3251172a0", + "size": 8905, + "subdir": "linux-64", + "timestamp": 1573738123335, + "version": "1.0.0" + }, + "backports.shutil_which-3.5.1-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF2 & MIT", + "md5": "21bd9ef21c8cffdf96b16f5f94d4a9e9", + "name": "backports.shutil_which", + "sha256": "cfce33f20d266e5e05d0ebdd56acdb21f150bbd53e7a95aad8e393b8a2c18bae", + "size": 6980, + "subdir": "linux-64", + "timestamp": 1517592920144, + "version": "3.5.1" + }, + "backports.shutil_which-3.5.1-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "backports", + "python >=3.5,<3.6.0a0" + ], + "license": "PSF2 & MIT", + "md5": "cf81d3dc670b4871e9e200d9cefe4d0d", + "name": "backports.shutil_which", + "sha256": "8434bc4f307e0e008c0de055b32765a5d660648bc99d2564b3bda69574bd1211", + "size": 7098, + "subdir": "linux-64", + "timestamp": 1517592920406, + "version": "3.5.1" + }, + "backports.shutil_which-3.5.1-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF2 & MIT", + "md5": "6ec24d5db171e1c953179f3e879b685f", + "name": "backports.shutil_which", + "sha256": "aa25aa5246c496d21e7f74547147e83b1d31e20801cb2681f9ee1d833734a73c", + "size": 7058, + "subdir": "linux-64", + "timestamp": 1517592920348, + "version": "3.5.1" + }, + "backports.shutil_which-3.5.1-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF2 & MIT", + "md5": "38e5faf4b058f41b1f3dbd426b123458", + "name": "backports.shutil_which", + "sha256": "6ba4ac6c1b6ff1a9da74f2282fdc1b641b079841f1c5908e99560fb1b1581d05", + "size": 7312, + "subdir": "linux-64", + "timestamp": 1530738967438, + "version": "3.5.1" + }, + "backports.shutil_which-3.5.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF2 & MIT", + "md5": "912e099ce003909cd768c7b090d90dd8", + "name": "backports.shutil_which", + "sha256": "7dc54bbf14ff1ff7c053751751a6c5862f678f9e5a395bb6fdb596def276b1df", + "size": 7945, + "subdir": "linux-64", + "timestamp": 1542385258333, + "version": "3.5.2" + }, + "backports.shutil_which-3.5.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.10,<3.11.0a0" + ], + "license": "PSF2 & MIT", + "md5": "5c0ffb6fb2b02cf60860767ae1a1452e", + "name": "backports.shutil_which", + "sha256": "214067b3728d5e909fc745fffa32a6b35be2fa41405b85dd97831c5398aebd46", + "size": 8441, + "subdir": "linux-64", + "timestamp": 1640788411608, + "version": "3.5.2" + }, + "backports.shutil_which-3.5.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.11,<3.12.0a0" + ], + "license": "PSF2 & MIT", + "md5": "46038289b321a59f065018066e40c18b", + "name": "backports.shutil_which", + "sha256": "be161120c62d7204b14f21dd3385ec5d9c267ba00faaf622cb24c99f72ec5384", + "size": 9591, + "subdir": "linux-64", + "timestamp": 1676846911013, + "version": "3.5.2" + }, + "backports.shutil_which-3.5.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF2 & MIT", + "md5": "bca031dcf6efc4437cb3df7fb52ddcac", + "name": "backports.shutil_which", + "sha256": "9fc68784993a66e32ed45ccd564cbe68e2d1592e0a6c17f6ab6dd01259479814", + "size": 8077, + "subdir": "linux-64", + "timestamp": 1542385264385, + "version": "3.5.2" + }, + "backports.shutil_which-3.5.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF2 & MIT", + "md5": "f1528c841497ba15a80ac6e19f1b05c8", + "name": "backports.shutil_which", + "sha256": "fd140ab9a7e65e0d1621d749b5a71bc7d81522c7987de610799bb7f19cc7a47d", + "size": 9364, + "subdir": "linux-64", + "timestamp": 1613157452281, + "version": "3.5.2" + }, + "backports.shutil_which-3.5.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF2 & MIT", + "md5": "17734cc55b0aedf90054935cf15748d0", + "name": "backports.shutil_which", + "sha256": "3a069ac56ab911dc194fbf5cd724d182a248ea6a04258e61fc0fb64d8823a8b8", + "size": 8059, + "subdir": "linux-64", + "timestamp": 1542385227034, + "version": "3.5.2" + }, + "backports.shutil_which-3.5.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF2 & MIT", + "md5": "ddd7e71b791b637eb4a933a93b0eb806", + "name": "backports.shutil_which", + "sha256": "e47c029890de99315a3b49c5c30b24c5a22f73c000ad337fe7ebb9a7794c757b", + "size": 9357, + "subdir": "linux-64", + "timestamp": 1613157116283, + "version": "3.5.2" + }, + "backports.shutil_which-3.5.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF2 & MIT", + "md5": "6f12edb58edeabf927e9c41d45352db8", + "name": "backports.shutil_which", + "sha256": "5e754d339eb83bc524a22834ea85495ab72823e1458b3111b2723183169d606a", + "size": 8325, + "subdir": "linux-64", + "timestamp": 1573738136954, + "version": "3.5.2" + }, + "backports.shutil_which-3.5.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF2 & MIT", + "md5": "8963c4dcc49e72771ef40ec74843e396", + "name": "backports.shutil_which", + "sha256": "41b4616b7946d43789c77bd60395e28d4587ec46368f55a3b106efee2d675ebf", + "size": 9390, + "subdir": "linux-64", + "timestamp": 1613157577033, + "version": "3.5.2" + }, + "backports.shutil_which-3.5.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF2 & MIT", + "md5": "b28237acf833ff18de7c090ebae220a9", + "name": "backports.shutil_which", + "sha256": "d13cff4379aaf817823a7b004485ac5280d00e19faa0d76aff0d42ec486599af", + "size": 9399, + "subdir": "linux-64", + "timestamp": 1613157452323, + "version": "3.5.2" + }, + "backports.weakref-1.0.post1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "522c3c8e904a0c08a4262dbdd044fc42", + "name": "backports.weakref", + "sha256": "073001762618d6d19b90c62eabfe2b6210d0ad963c5c6c4c5eb26b38d78e0ce6", + "size": 8081, + "subdir": "linux-64", + "timestamp": 1530739012541, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py27h0df1112_0.tar.bz2": { + "build": "py27h0df1112_0", + "build_number": 0, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "608ba61619a9912256497a05a4d0cde6", + "name": "backports.weakref", + "sha256": "55f8db7f845e04c3195cc896d910eba395f5077e9bfbe5982587e1002589c049", + "size": 8448, + "subdir": "linux-64", + "timestamp": 1509121908904, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.10,<3.11.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "cb2a752076f3d88679f5832030947b53", + "name": "backports.weakref", + "sha256": "42b82fd09d58351a6da6c171ea31ba60e368236e4e9b820893b168577c1b8139", + "size": 8611, + "subdir": "linux-64", + "timestamp": 1642510041164, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.11,<3.12.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "e791a93e927698924963f930f9cf8ee1", + "name": "backports.weakref", + "sha256": "b0d405c20dbb75aedc571c265e95ed1738b381862cae09b15fec5c51ee4ee999", + "size": 10285, + "subdir": "linux-64", + "timestamp": 1676846925488, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "9208daac7dd56c70391d4c2766a9c1a2", + "name": "backports.weakref", + "sha256": "3b71fbd835888b11b8800d2c994a3409b971b11cac0fad2cce332b0f9b2fe681", + "size": 8211, + "subdir": "linux-64", + "timestamp": 1534355342000, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py35h2eecce5_0.tar.bz2": { + "build": "py35h2eecce5_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "2031aa5cc09f7df3af0aa2fa72dfd109", + "name": "backports.weakref", + "sha256": "49d24d7215232c6390f2b2bdf7b526d922b8c65a34255339b7126d62439d572f", + "size": 8641, + "subdir": "linux-64", + "timestamp": 1509121943526, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "5f078c2d5d594e8eb42676bbf8e0af36", + "name": "backports.weakref", + "sha256": "60272dd01ced961c36c109f9de003d3332d81fc2fa7526c84511b5d921fcae12", + "size": 8228, + "subdir": "linux-64", + "timestamp": 1530738990774, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "d632cbcbd0529a8f2d88979735347b7b", + "name": "backports.weakref", + "sha256": "ab51df5f6f1c5287ff8320dbb4ac759d44b16ab61042c66a00778f5acab6794e", + "size": 9366, + "subdir": "linux-64", + "timestamp": 1632738101978, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py36h39d5b32_0.tar.bz2": { + "build": "py36h39d5b32_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "8173d1cd28d30ca5e6cc2cc789be608d", + "name": "backports.weakref", + "sha256": "54158cc8a481df1595652706ff0b9fadd30a160d630fa7d1b94e2c1d795c6480", + "size": 8586, + "subdir": "linux-64", + "timestamp": 1509121973183, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "2e6d5df727e4bfd3061775aaa2112889", + "name": "backports.weakref", + "sha256": "5c62080fb7f160516f85176ff07f1ecf3136fb967e86ea846a9b72ea4321257f", + "size": 8265, + "subdir": "linux-64", + "timestamp": 1530739034545, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "0bd08930f6d8701232ec0f17684a97dd", + "name": "backports.weakref", + "sha256": "d99aa7ed943ad3741a8e1f731af80b9d0e3dc7e2c2bf8e3224ece5bb5c6a7bd7", + "size": 9387, + "subdir": "linux-64", + "timestamp": 1632748454692, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "0b4e74ac0ca3f6e9bd9f41339d1ced99", + "name": "backports.weakref", + "sha256": "f9d933dfdc5e234f92fa8c541e3e3d9074305d61240283b88718b581e57497a5", + "size": 8749, + "subdir": "linux-64", + "timestamp": 1573469550093, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "14f5e59995365b5f2112b243245812ea", + "name": "backports.weakref", + "sha256": "0e8688a824a298ee82b9322d1a662006d32850f5c36f27aeddf5f87083e56312", + "size": 9393, + "subdir": "linux-64", + "timestamp": 1632748447723, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.9,<3.10.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "96333bc475dc34ebb6834c71c22c0293", + "name": "backports.weakref", + "sha256": "29b712e2078e369337e2a7e082cd15641e60b8a6a99c73209e27116ae95f3d1d", + "size": 9422, + "subdir": "linux-64", + "timestamp": 1632748450409, + "version": "1.0.post1" + }, + "backports.zoneinfo-0.2.1-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "tzdata" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6c9ec4773db64a38099ef992dc159ad5", + "name": "backports.zoneinfo", + "sha256": "9c5201410bb74d57ba63b690400f2b05f9d77394cfdf72e92f3bb8fe3a241ce8", + "size": 54473, + "subdir": "linux-64", + "timestamp": 1661287625567, + "version": "0.2.1" + }, + "backports.zoneinfo-0.2.1-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "tzdata" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "254355f9c9a64583b6876d2dbfbad7eb", + "name": "backports.zoneinfo", + "sha256": "92a314ed71240ddd6aa5fc37c44b65855329af546da368c9fe93869399df4d32", + "size": 54582, + "subdir": "linux-64", + "timestamp": 1661287593720, + "version": "0.2.1" + }, + "backports_abc-0.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "f9773a444c5303a970e572057ee81ea9", + "name": "backports_abc", + "sha256": "1da8415ba3469b65d5bb270b719da0fec773366909d83befc93f5e68f66494a6", + "size": 12368, + "subdir": "linux-64", + "timestamp": 1530735311903, + "version": "0.5" + }, + "backports_abc-0.5-py27h7b3c97b_0.tar.bz2": { + "build": "py27h7b3c97b_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "cc58276fdcdba4c15b8a8f8493691e9d", + "name": "backports_abc", + "sha256": "fff61cfe579da8748517fba968dc2c91de01ce2e8da05039b5302e0f54fc4852", + "size": 12231, + "subdir": "linux-64", + "timestamp": 1505690433274, + "version": "0.5" + }, + "backports_abc-0.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "PSF 2", + "md5": "7e9caac60da8319115a8613223ea9418", + "name": "backports_abc", + "sha256": "fc4b0d8020b897569f99c2232a399558a856a85047ec2f40946a2eeaeafb1a72", + "size": 12826, + "subdir": "linux-64", + "timestamp": 1642498996191, + "version": "0.5" + }, + "backports_abc-0.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "PSF 2", + "md5": "00dff62c325ca607492ed04892923e5b", + "name": "backports_abc", + "sha256": "1bb94ea59bf2622fdd38bca8e482e4c6a22fd8286ec1627aff37c2499a5c04a5", + "size": 14642, + "subdir": "linux-64", + "timestamp": 1676846940266, + "version": "0.5" + }, + "backports_abc-0.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "PSF 2", + "md5": "0afac25077bfc886a267c6f9068c122f", + "name": "backports_abc", + "sha256": "e3cc2b8d83ab8636ed30168f63075413376d499b5b7726d1a406f973389e5926", + "size": 12479, + "subdir": "linux-64", + "timestamp": 1534351858877, + "version": "0.5" + }, + "backports_abc-0.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF 2", + "md5": "cd9eb4cd4f1fd570f4352a4d5468cb1f", + "name": "backports_abc", + "sha256": "7c504f5e524fcb3d512fca697e62917468c685b6464f7618563a10e26d9a8808", + "size": 12516, + "subdir": "linux-64", + "timestamp": 1530735292148, + "version": "0.5" + }, + "backports_abc-0.5-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF 2", + "md5": "52dff979e462cdb5c04c9b290e498d76", + "name": "backports_abc", + "sha256": "934e304e001b310343ec4461cac1aa40a6da3fe1ebf12e3e195bac3781f97dda", + "size": 13811, + "subdir": "linux-64", + "timestamp": 1632738098617, + "version": "0.5" + }, + "backports_abc-0.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF 2", + "md5": "b1a52b88af7f5c85fc5810ce49e83fd6", + "name": "backports_abc", + "sha256": "5e79263b89778b931c8326bae2b0d7e98727cc6f71e5a4ad5bbec21f541822d5", + "size": 12542, + "subdir": "linux-64", + "timestamp": 1530735332167, + "version": "0.5" + }, + "backports_abc-0.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF 2", + "md5": "1fc40a0a0aa71205c4144be734290ed7", + "name": "backports_abc", + "sha256": "dae2f6770007e503f1508f279a22edf1f19de3c60d879449b72231edd56ad893", + "size": 13834, + "subdir": "linux-64", + "timestamp": 1632748090739, + "version": "0.5" + }, + "backports_abc-0.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF 2", + "md5": "8e1e228930c8ed9f54abe2670b216946", + "name": "backports_abc", + "sha256": "72b7b88955a1ba566bc6daa5ea0bafd90887fbb65feca5acab7b4d7a431df06c", + "size": 12957, + "subdir": "linux-64", + "timestamp": 1572437398732, + "version": "0.5" + }, + "backports_abc-0.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF 2", + "md5": "07f219e6e965c0872fa795a1e65ce376", + "name": "backports_abc", + "sha256": "36667e369b22d202d225e0942fdccab288449c9e32c67ad740a5b4b594fb9ab1", + "size": 13850, + "subdir": "linux-64", + "timestamp": 1632748438490, + "version": "0.5" + }, + "backports_abc-0.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF 2", + "md5": "5ef73b44259b7272aeeae8f33984eee4", + "name": "backports_abc", + "sha256": "a6158a04feaea05f9e93196a3d4bf1942d5dc7137cb3f2f06d53e1ec4fc2df84", + "size": 13825, + "subdir": "linux-64", + "timestamp": 1632748438517, + "version": "0.5" + }, + "bandersnatch-2.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.5,<3.6.0a0", + "requests", + "setuptools", + "xmlrpc2" + ], + "license": "Academic Free License", + "license_family": "Other", + "md5": "589c6d7fa4d358708de3605383567ac0", + "name": "bandersnatch", + "sha256": "e569722f0d9af44d5ad96708cef95703b05114cd7ab3791d41afaff6082239fb", + "size": 33067, + "subdir": "linux-64", + "timestamp": 1530023291902, + "version": "2.2.1" + }, + "bandersnatch-2.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.6,<3.7.0a0", + "requests", + "setuptools", + "xmlrpc2" + ], + "license": "Academic Free License", + "license_family": "Other", + "md5": "04612b9a29878a999cf311ea19ada5a3", + "name": "bandersnatch", + "sha256": "f2b8664cdd695ab3191ee739eebf4c8f5d1773fffb61585710273d8dcc912c3d", + "size": 33008, + "subdir": "linux-64", + "timestamp": 1530022681382, + "version": "2.2.1" + }, + "bandersnatch-3.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp", + "filelock", + "packaging", + "python >=3.6,<3.7.0a0", + "requests", + "setuptools", + "xmlrpc2" + ], + "license": "Academic Free License", + "license_family": "Other", + "md5": "ffbe1cd56070fa062301c9a1e4b3ee3e", + "name": "bandersnatch", + "sha256": "51d409b0317ffc587c51d58b6f20d663d0d5caf7d4e6133ee9e0bfff4da668ae", + "size": 48094, + "subdir": "linux-64", + "timestamp": 1545163880831, + "version": "3.1.2" + }, + "bandersnatch-3.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiohttp", + "filelock", + "packaging", + "python >=3.7,<3.8.0a0", + "requests", + "setuptools", + "xmlrpc2" + ], + "license": "Academic Free License", + "license_family": "Other", + "md5": "41bfe7a6aecc01513e06412c85262e2b", + "name": "bandersnatch", + "sha256": "d07684d0ef825803bf6d7921aa06013f32413e7b271120dabfcce5c1e44c4f69", + "size": 48148, + "subdir": "linux-64", + "timestamp": 1545235778115, + "version": "3.1.2" + }, + "bandersnatch-3.1.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp", + "filelock", + "packaging", + "python >=3.6,<3.7.0a0", + "requests", + "setuptools", + "xmlrpc2" + ], + "license": "Academic Free License", + "license_family": "Other", + "md5": "ee96bae556d02fa1f1a860fcbd7dece8", + "name": "bandersnatch", + "sha256": "6c72f72fcd793f986d59ac25fcc4b7d1e8595c6d2fe956878afaf8a8d41ca8c6", + "size": 174351, + "subdir": "linux-64", + "timestamp": 1547222959183, + "version": "3.1.3" + }, + "bandersnatch-3.1.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiohttp", + "filelock", + "packaging", + "python >=3.7,<3.8.0a0", + "requests", + "setuptools", + "xmlrpc2" + ], + "license": "Academic Free License", + "license_family": "Other", + "md5": "61f97f9199b7e83c6ff35314b035b984", + "name": "bandersnatch", + "sha256": "8a6868a3f020a07b50e69c50d182a999482e8fe51697b7aefa78a49e08dccab0", + "size": 174425, + "subdir": "linux-64", + "timestamp": 1547222978481, + "version": "3.1.3" + }, + "bandersnatch-3.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp", + "filelock", + "packaging", + "python >=3.6,<3.7.0a0", + "requests", + "setuptools", + "xmlrpc2" + ], + "license": "Academic Free License", + "license_family": "Other", + "md5": "0e069fb1c78666c8ca88a2b446917121", + "name": "bandersnatch", + "sha256": "01b622d94b09a2df92ab40f2864928637a8c7e3b57a63abc69754446f88ecb2d", + "size": 179429, + "subdir": "linux-64", + "timestamp": 1550266673092, + "version": "3.2.0" + }, + "bandersnatch-3.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiohttp", + "filelock", + "packaging", + "python >=3.7,<3.8.0a0", + "requests", + "setuptools", + "xmlrpc2" + ], + "license": "Academic Free License", + "license_family": "Other", + "md5": "7fb504b6e3d50f992f66cb62d1b3e293", + "name": "bandersnatch", + "sha256": "055f0c17971d38d327a388b6804e7770e181457aa35991a86d6be1c0c47d4526", + "size": 179465, + "subdir": "linux-64", + "timestamp": 1550266590553, + "version": "3.2.0" + }, + "basemap-1.2.0-py27h705c2d8_0.tar.bz2": { + "build": "py27h705c2d8_0", + "build_number": 0, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=1.0.0", + "numpy >=1.11.3,<2.0a0", + "pyproj >=1.9.3", + "pyshp >=1.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "4d47b6a67a7f9a0f60849cf30236b52d", + "name": "basemap", + "sha256": "1b8498c37ca252baae5706618f26e1674eb3126ace89330815c2b3ba037a562b", + "size": 15908040, + "subdir": "linux-64", + "timestamp": 1539182469126, + "version": "1.2.0" + }, + "basemap-1.2.0-py36h705c2d8_0.tar.bz2": { + "build": "py36h705c2d8_0", + "build_number": 0, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=1.0.0", + "numpy >=1.11.3,<2.0a0", + "pyproj >=1.9.3", + "pyshp >=1.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "b44e9fa3da3a4a7c4c6b5d27f80319e4", + "name": "basemap", + "sha256": "e9cdfa1590c8cd661b3b55e181bcb450d11d394e5ee4ab7b92061dbb6e52d4e0", + "size": 15925360, + "subdir": "linux-64", + "timestamp": 1539182487464, + "version": "1.2.0" + }, + "basemap-1.2.0-py36h856778e_4.tar.bz2": { + "build": "py36h856778e_4", + "build_number": 4, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=1.0.0", + "numpy >=1.14.6,<2.0a0", + "pyproj >=1.9.3,<2", + "pyshp >=1.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "8d8d1d9eaa55cde23a81d6147e9c87ad", + "name": "basemap", + "sha256": "436b40f1adaba10fce03b68150aa1206bf0a228d77e6bcd71987fb25682e1888", + "size": 15896807, + "subdir": "linux-64", + "timestamp": 1596635593097, + "version": "1.2.0" + }, + "basemap-1.2.0-py37h705c2d8_0.tar.bz2": { + "build": "py37h705c2d8_0", + "build_number": 0, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=1.0.0", + "numpy >=1.11.3,<2.0a0", + "pyproj >=1.9.3", + "pyshp >=1.2.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "3b6c8baa804f52e9d6392c794a56df58", + "name": "basemap", + "sha256": "50d0299e0a8ce6fa2dd746fb6dbb5bdf86b26099fd62c807193e1b266e056ac4", + "size": 15876520, + "subdir": "linux-64", + "timestamp": 1539182483238, + "version": "1.2.0" + }, + "basemap-1.2.0-py37h856778e_4.tar.bz2": { + "build": "py37h856778e_4", + "build_number": 4, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=1.0.0", + "numpy >=1.14.6,<2.0a0", + "pyproj >=1.9.3,<2", + "pyshp >=1.2.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "62a354d96344aa829548b844d6d32ccb", + "name": "basemap", + "sha256": "e8e8051a8d07283b68503b49fbe5b9fbd0966d7d32a5a2d84af409cfa090a8c2", + "size": 15896164, + "subdir": "linux-64", + "timestamp": 1596635582974, + "version": "1.2.0" + }, + "basemap-1.2.0-py38h856778e_4.tar.bz2": { + "build": "py38h856778e_4", + "build_number": 4, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=1.0.0", + "numpy >=1.14.6,<2.0a0", + "pyproj >=1.9.3,<2", + "pyshp >=1.2.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "md5": "10bbbc68726ba1a425b97adef1622450", + "name": "basemap", + "sha256": "17d433a40f126eb01804ca8e80c55b788bc24265a51566c10f8a7e6911b2a7e5", + "size": 15897588, + "subdir": "linux-64", + "timestamp": 1596635583089, + "version": "1.2.0" + }, + "basemap-1.2.2-py37hc66db60_2.tar.bz2": { + "build": "py37hc66db60_2", + "build_number": 2, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.0.0,!=3.0.1", + "numpy >=1.16.6,<2.0a0", + "proj", + "pyproj >=1.9.3", + "pyshp >=1.2.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c8379efdc4a412e1698adfba8b19bfee", + "name": "basemap", + "sha256": "bad77aaeca85a28047e9711103a87af268b5edb69686d0f21586aefd6affc5cf", + "size": 15991514, + "subdir": "linux-64", + "timestamp": 1640155046735, + "version": "1.2.2" + }, + "basemap-1.2.2-py38hc66db60_2.tar.bz2": { + "build": "py38hc66db60_2", + "build_number": 2, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.0.0,!=3.0.1", + "numpy >=1.16.6,<2.0a0", + "proj", + "pyproj >=1.9.3", + "pyshp >=1.2.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2fca69a7acbd387db54fdcd3aab134f", + "name": "basemap", + "sha256": "050b06415a95aa1189bc731a33bfb23a539df241d44e9fd13ba20dedaadef14a", + "size": 15958803, + "subdir": "linux-64", + "timestamp": 1640169161133, + "version": "1.2.2" + }, + "basemap-1.2.2-py39hc66db60_2.tar.bz2": { + "build": "py39hc66db60_2", + "build_number": 2, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.0.0,!=3.0.1", + "numpy >=1.16.6,<2.0a0", + "proj", + "pyproj >=1.9.3", + "pyshp >=1.2.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "61f7cfe93b7ab6af6a3cf3b3e433c068", + "name": "basemap", + "sha256": "6893f4938f7c980f81a31f13a6b17681a64f2b364439eb28bf23eda28a8117bf", + "size": 15989918, + "subdir": "linux-64", + "timestamp": 1640169154374, + "version": "1.2.2" + }, + "basemap-1.3.2-py310hb079758_1.tar.bz2": { + "build": "py310hb079758_1", + "build_number": 1, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "basemap-data >=1.3.2,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geos >=3.8.0,<4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.5,!=3.0.1", + "numpy >=1.21.2,<2.0a0", + "pyproj >=1.9.3,<3.4", + "pyshp >=1.2.0,<2.2", + "python >=3.10,<3.11.0a0", + "six >=1.10,<1.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2b7131d15d272bad85d78c802131f20", + "name": "basemap", + "sha256": "bd91867cb1c4d4921348dfeec9e8d95604a7d3d87db01ba48ba51289c708cad1", + "size": 268154, + "subdir": "linux-64", + "timestamp": 1645455834328, + "version": "1.3.2" + }, + "basemap-1.3.2-py38hb079758_1.tar.bz2": { + "build": "py38hb079758_1", + "build_number": 1, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "basemap-data >=1.3.2,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geos >=3.8.0,<4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.5,!=3.0.1", + "numpy >=1.21.2,<2.0a0", + "pyproj >=1.9.3,<3.4", + "pyshp >=1.2.0,<2.2", + "python >=3.8,<3.9.0a0", + "six >=1.10,<1.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0771ee1f7eb9b44c4a2d2398d652a57e", + "name": "basemap", + "sha256": "dc866128604da57931afc65c87aa87fc6486223de00e293b911a78e2e18e0b5f", + "size": 176616, + "subdir": "linux-64", + "timestamp": 1645455808582, + "version": "1.3.2" + }, + "basemap-1.3.2-py39hb079758_1.tar.bz2": { + "build": "py39hb079758_1", + "build_number": 1, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "basemap-data >=1.3.2,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geos >=3.8.0,<4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.5,!=3.0.1", + "numpy >=1.21.2,<2.0a0", + "pyproj >=1.9.3,<3.4", + "pyshp >=1.2.0,<2.2", + "python >=3.9,<3.10.0a0", + "six >=1.10,<1.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d21b121c2279963843fd55b2de807bbd", + "name": "basemap", + "sha256": "2ac3269557928384d3551ca010fdf9748a1076eb31934965d32afa2bd28e2369", + "size": 174741, + "subdir": "linux-64", + "timestamp": 1645455856256, + "version": "1.3.2" + }, + "basemap-1.3.6-py310h1176785_1.tar.bz2": { + "build": "py310h1176785_1", + "build_number": 1, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geos >=3.8.0,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=1.5,!=3.0.1,<3.7", + "numpy >=1.21.5,<2.0a0", + "pyproj >=1.9.3,<3.5.0", + "pyshp >=1.2.0,<2.4", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a467c54661b6e2a2194f6a3ef37f8a32", + "name": "basemap", + "sha256": "b8c99d72557b663d21cac44635e6dceb0c36af903bfe2c6f71a2b32173720921", + "size": 164167, + "subdir": "linux-64", + "timestamp": 1674758299728, + "version": "1.3.6" + }, + "basemap-1.3.6-py311h1176785_1.tar.bz2": { + "build": "py311h1176785_1", + "build_number": 1, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geos >=3.8.0,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=1.5,!=3.0.1,<3.7", + "numpy >=1.22.3,<2.0a0", + "pyproj >=1.9.3,<3.5.0", + "pyshp >=1.2.0,<2.4", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa66a03a396828370ac71c8fd40de97b", + "name": "basemap", + "sha256": "7edd04c3dcc6a32a7d93c1eb3e2a7ab4ca3b72f6d5f8ee19681911f3d07f8057", + "size": 200554, + "subdir": "linux-64", + "timestamp": 1676843374497, + "version": "1.3.6" + }, + "basemap-1.3.6-py37h1176785_1.tar.bz2": { + "build": "py37h1176785_1", + "build_number": 1, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geos >=3.8.0,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=1.5,!=3.0.1,<3.7", + "numpy >=1.21.5,<2.0a0", + "pyproj >=1.9.3,<3.5.0", + "pyshp >=1.2.0,<2.4", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d0a99d14f9cbedaa723c00c886aa97ea", + "name": "basemap", + "sha256": "c01e55ca9435f04679c23e450e132c92def894cd94e4300f38b87bf4373b9739", + "size": 164221, + "subdir": "linux-64", + "timestamp": 1674758317223, + "version": "1.3.6" + }, + "basemap-1.3.6-py38h1176785_1.tar.bz2": { + "build": "py38h1176785_1", + "build_number": 1, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geos >=3.8.0,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=1.5,!=3.0.1,<3.7", + "numpy >=1.21.5,<2.0a0", + "pyproj >=1.9.3,<3.5.0", + "pyshp >=1.2.0,<2.4", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "61510087322e481b732d730488aeadea", + "name": "basemap", + "sha256": "9eb8df125cdb2ec75b0d8b27215c442abab963e385bb6e6b7dfbae485a0b1850", + "size": 165095, + "subdir": "linux-64", + "timestamp": 1674758334717, + "version": "1.3.6" + }, + "basemap-1.3.6-py39h1176785_1.tar.bz2": { + "build": "py39h1176785_1", + "build_number": 1, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geos >=3.8.0,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=1.5,!=3.0.1,<3.7", + "numpy >=1.21.5,<2.0a0", + "pyproj >=1.9.3,<3.5.0", + "pyshp >=1.2.0,<2.4", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23e29d4253fe1a64faa2b2ce60d725c2", + "name": "basemap", + "sha256": "8a1876915d6656b3f0b1e35e99d5d4ab54f4ab515856ea81a621b9ebf875c551", + "size": 163152, + "subdir": "linux-64", + "timestamp": 1674758281859, + "version": "1.3.6" + }, + "basemap-data-1.3.6-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "97be84bc64b98dbdd6234dcc7c450853", + "name": "basemap-data", + "sha256": "3986b9c4785d79662dc718b011036dae62faeb0dbe1539a02278f6b007516a1f", + "size": 28516472, + "subdir": "linux-64", + "timestamp": 1674758203303, + "version": "1.3.6" + }, + "basemap-data-1.3.6-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "48c2f41f3ab00d7c8bdac9da06a97b49", + "name": "basemap-data", + "sha256": "16b122094486e6334a547bee6dbe36c071a5c4f9fe8f19c9c3f32ea08f8a4b1e", + "size": 28553430, + "subdir": "linux-64", + "timestamp": 1676843349813, + "version": "1.3.6" + }, + "basemap-data-1.3.6-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "b6d7a0458354c52d411ff6dc9494657f", + "name": "basemap-data", + "sha256": "9ce184157c8ab1cda096e6a555f484f09e7b0a5da9d693cd9425d3934ceb74e9", + "size": 28493474, + "subdir": "linux-64", + "timestamp": 1674758225238, + "version": "1.3.6" + }, + "basemap-data-1.3.6-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "3c95374f026502bc403aea5a70399553", + "name": "basemap-data", + "sha256": "8d10ea4405c66d2b48b9695cacb48b0cebaf67377055e6d4e3b8720dfbd5326a", + "size": 28475819, + "subdir": "linux-64", + "timestamp": 1674758247310, + "version": "1.3.6" + }, + "basemap-data-1.3.6-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "74f4dc632bfd7a777f36229642449e71", + "name": "basemap-data", + "sha256": "20b95869dd61f4b94080cfc1df1bfc399e3415c5447022047245228acdb4f538", + "size": 28493142, + "subdir": "linux-64", + "timestamp": 1674758180977, + "version": "1.3.6" + }, + "basemap-data-hires-1.2.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "basemap >1.0.7" + ], + "license": "GPL-2.0", + "md5": "d081ba4625e4dde97ce44f25f0ce94e4", + "name": "basemap-data-hires", + "sha256": "07b4dc36b4af117b19d40d438780e820d02645f754f8f1422ed8fcf0115239d3", + "size": 110469670, + "subdir": "linux-64", + "timestamp": 1539184858018, + "version": "1.2.0" + }, + "basemap-data-hires-1.3.6-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "e146ac8e03784385545a53fda5e3496c", + "name": "basemap-data-hires", + "sha256": "3177db98e3aa01944e09b5f0d6512195a3edff242c1878cadf4b9be222be1c5e", + "size": 97816279, + "subdir": "linux-64", + "timestamp": 1674758409330, + "version": "1.3.6" + }, + "basemap-data-hires-1.3.6-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "64365b9a23637c39aaf9eee73372fa41", + "name": "basemap-data-hires", + "sha256": "e8af69055f947fa15a0fef055ee9bb5d5bc85cca042540bd857d67b98891f1e3", + "size": 97839458, + "subdir": "linux-64", + "timestamp": 1676843392282, + "version": "1.3.6" + }, + "basemap-data-hires-1.3.6-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "511e1971146ee320c9ec7d2ba4d1c4b5", + "name": "basemap-data-hires", + "sha256": "d902924c4a52dbf905e52e87d8c26f9a1c681a64709551fcfed9c5270ade2a60", + "size": 97840053, + "subdir": "linux-64", + "timestamp": 1674758463947, + "version": "1.3.6" + }, + "basemap-data-hires-1.3.6-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "64e3f8633527bed7dcc1e9f2c8f32838", + "name": "basemap-data-hires", + "sha256": "05f9218cc2598421f7a35f5adb835c8ce1e7ccfadea367b844a61a5333249187", + "size": 97817155, + "subdir": "linux-64", + "timestamp": 1674758518221, + "version": "1.3.6" + }, + "basemap-data-hires-1.3.6-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "ef3cddd240bc93e9b3f469f9cc0bc2fd", + "name": "basemap-data-hires", + "sha256": "fde85c3db86d1539a4b85ac23c548977dc9338342e3b5e553b719da6940501b9", + "size": 97820112, + "subdir": "linux-64", + "timestamp": 1674758354336, + "version": "1.3.6" + }, + "bash-5.0.018-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "readline >=8.0,<9.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "bb8061d6bc190afab35490c51e80072d", + "name": "bash", + "sha256": "38a622cd8ffcffb9db9307462064f5fb8e55e9f048c08c94456f37ef1d6d4aa7", + "size": 1962536, + "subdir": "linux-64", + "timestamp": 1600093348344, + "version": "5.0.018" + }, + "bash-5.0.018-hf6cebf6_0.tar.bz2": { + "build": "hf6cebf6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "readline >=8.0,<9.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "54bb74f1a09f3f98c9dbc8359de978fd", + "name": "bash", + "sha256": "f92a20dc21d269256d7f122864cdb0494d1b2aa9a9badc78a554038682c2fc17", + "size": 1966998, + "subdir": "linux-64", + "timestamp": 1600093036752, + "version": "5.0.018" + }, + "bazel-0.11.1-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fa2b0b2d332cb5e59663d314df7810ab", + "name": "bazel", + "sha256": "b1ae05c4c2800410affc6ecff43cd69d1915b7d076438ccf023e3315576b2a99", + "size": 100792633, + "subdir": "linux-64", + "timestamp": 1521222548963, + "version": "0.11.1" + }, + "bazel-0.12.0-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c16c6ff3b8f4fbffdb707154ee299d5c", + "name": "bazel", + "sha256": "26bcfd3789b2dd88c20081105713e3cad8f800757d243feb3aaa7e7e26a2db4f", + "size": 108066739, + "subdir": "linux-64", + "timestamp": 1524779316808, + "version": "0.12.0" + }, + "bazel-0.14.0-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "95bace4175268eb6b02d086d9408d7e5", + "name": "bazel", + "sha256": "354bfb1f4c35b92cb79936a910d3c55edb78815f0f2b69408e590c2ce1d98c71", + "size": 118168418, + "subdir": "linux-64", + "timestamp": 1528051265615, + "version": "0.14.0" + }, + "bazel-0.15.2-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "20b32892d0d5d0bbc13affb17270e80a", + "name": "bazel", + "sha256": "748a18c1a73c1985ba0fd37acf30a3facffe4db0d9e024facac5a56a6a1117fe", + "size": 118276836, + "subdir": "linux-64", + "timestamp": 1532770048926, + "version": "0.15.2" + }, + "bazel-0.16.1-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "825b7f2292b9b362a487f8bc0b9c9384", + "name": "bazel", + "sha256": "ec9686ff0cfb750cbebc4fd5b6a5c2e32b30d9fcecc7c0e6cf785792977690a2", + "size": 124097062, + "subdir": "linux-64", + "timestamp": 1536529851920, + "version": "0.16.1" + }, + "bazel-0.17.2-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f2ed1f1e202f6fc86696c5d2e456a82e", + "name": "bazel", + "sha256": "43c55bb58ce1403ac1faee6bff9e716d8c65387db4b4390e0368666dd216ac22", + "size": 127709994, + "subdir": "linux-64", + "timestamp": 1539499169818, + "version": "0.17.2" + }, + "bazel-0.18.0-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5edc55eadec0fe1e7c73e3412b119c44", + "name": "bazel", + "sha256": "7566cf04c62830d39dc37eed2a3ee8d34221336012f99bf83a909e149b62b62f", + "size": 127890587, + "subdir": "linux-64", + "timestamp": 1540700745611, + "version": "0.18.0" + }, + "bazel-0.20.0-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "073ee264c87f211988af7be0b444cdcc", + "name": "bazel", + "sha256": "d4562850bc998c52720532db77a418ed88e40c7b3c98cba281c9cdedb3d53151", + "size": 132420633, + "subdir": "linux-64", + "timestamp": 1551306162127, + "version": "0.20.0" + }, + "bazel-0.22.0-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4e12f81d0e1ef7a56fd1f2190682a973", + "name": "bazel", + "sha256": "931bdaa4d8ba1d35e22059b6e65e1b01e35851aecdacd5573af7a7e25364676c", + "size": 130177003, + "subdir": "linux-64", + "timestamp": 1550319721199, + "version": "0.22.0" + }, + "bazel-0.24.1-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "eeb212664154064b1cd1a5985bad0641", + "name": "bazel", + "sha256": "a8dc886461deef3023110d58057a17ac9850445c595126836627e3e77dbec646", + "size": 77824881, + "subdir": "linux-64", + "timestamp": 1560980359581, + "version": "0.24.1" + }, + "bazel-0.26.1-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a4078e7b87c104a64387cd6fa27b5600", + "name": "bazel", + "sha256": "6128eb4254826dabafb0a0447b78e1b76931f7309136b4d726a3e4c0dad3ff60", + "size": 39887086, + "subdir": "linux-64", + "timestamp": 1571428987182, + "version": "0.26.1" + }, + "bazel-0.29.1-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "79869c171b855000b031603a161f7faa", + "name": "bazel", + "sha256": "11461f913b9910afd35c4073d0e2ea7ae2e855724fbd4f774d222827813adceb", + "size": 36018758, + "subdir": "linux-64", + "timestamp": 1581955009645, + "version": "0.29.1" + }, + "bazel-0.5.4-hf484d3e_1.tar.bz2": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a5b7ee14b42ebdc6288e423852e6b823", + "name": "bazel", + "sha256": "30cdb254ce0da9d2e802162adee590025334f9603942d37d80aa7fad1e5da54d", + "size": 128821714, + "subdir": "linux-64", + "timestamp": 1516395214083, + "version": "0.5.4" + }, + "bazel-2.0.0-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ead35e364f2bb3ef160eca23aaa2ebf9", + "name": "bazel", + "sha256": "5928f651dfb03cd0bb0629723fc42b689b329c9b63c25642f561f9c0bb0b39b4", + "size": 31223135, + "subdir": "linux-64", + "timestamp": 1589913678600, + "version": "2.0.0" + }, + "bazel-3.1.0-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fa2a708aec63e601e418857c9572e66a", + "name": "bazel", + "sha256": "f3c9cefb6fd5fdcb8e69bb0b718391fb9f064eedfb74e47cd2295874ed0476d0", + "size": 31823707, + "subdir": "linux-64", + "timestamp": 1597657999852, + "version": "3.1.0" + }, + "bazel-3.7.2-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d3d36c186e25e1483a8ec727959dbf4f", + "name": "bazel", + "sha256": "32f7677cb0dc9ddb1844d0969e63336287e81da0f76b11d243e73c66b838ed85", + "size": 33073526, + "subdir": "linux-64", + "timestamp": 1621946165467, + "version": "3.7.2" + }, + "bazel-4.2.2-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "openjdk >=8" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5a4a280c24230dcff7b555b3d1849771", + "name": "bazel", + "sha256": "51bbd7b04cf4654ac3a5c6e0ac09c355eafad560e9ded557c489f2f9a91749d2", + "size": 29050026, + "subdir": "linux-64", + "timestamp": 1657727073757, + "version": "4.2.2" + }, + "bazel-4.2.2-h6a678d5_1.tar.bz2": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "openjdk >=8" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cd4b106c156931ce9fbc26e612b6fd6c", + "name": "bazel", + "sha256": "6f19cbcea1629d78772e3ecccbb339cba419de30b03217ddce3879bc367a5172", + "size": 41255089, + "subdir": "linux-64", + "timestamp": 1658237334221, + "version": "4.2.2" + }, + "bazel-5.2.0-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "openjdk >=8" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9a8d01777ddae6a105ba5fe1b0975dea", + "name": "bazel", + "sha256": "e809c73adebb945007645773b65da15b475902b0c0109e48c1fb9ca46ab96c49", + "size": 42673397, + "subdir": "linux-64", + "timestamp": 1660817280139, + "version": "5.2.0" + }, + "bcj-cffi-0.5.1-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.14.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1", + "md5": "8c2e63dfd91e9d5f4a83eace7271b50a", + "name": "bcj-cffi", + "sha256": "439848d302dfa70c600ad0f639cd038dcd2092c72baf1731d1236417347fac0d", + "size": 41275, + "subdir": "linux-64", + "timestamp": 1640803537941, + "version": "0.5.1" + }, + "bcj-cffi-0.5.1-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "cffi >=1.14.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.1", + "md5": "10f69e971ffd6949432cea8f7998890e", + "name": "bcj-cffi", + "sha256": "8dc802bc170ecf03afba68a9e0ec662319c6d2231a525ba43494e0463824df74", + "size": 28896, + "subdir": "linux-64", + "timestamp": 1676846959934, + "version": "0.5.1" + }, + "bcj-cffi-0.5.1-py36h295c915_0.tar.bz2": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.14.0", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "c32b56dd9020a8878e166e6ab1d89348", + "name": "bcj-cffi", + "sha256": "a899bf3569467ca8a7fac7e7b9bed94ea8828bdf9e57e35cf8fc5d9000ae240b", + "size": 28726, + "subdir": "linux-64", + "timestamp": 1633080167777, + "version": "0.5.1" + }, + "bcj-cffi-0.5.1-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.14.0", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1", + "md5": "e608b900b7293ac54807425f9e1d6a21", + "name": "bcj-cffi", + "sha256": "808500861524ea305e39f7f6f3d7f8f4ee958f2e32e3f3a1f37f644f58b33b37", + "size": 28724, + "subdir": "linux-64", + "timestamp": 1633090680742, + "version": "0.5.1" + }, + "bcj-cffi-0.5.1-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.14.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1", + "md5": "60ec099de693dbe3fec2e7ef64d3a2d9", + "name": "bcj-cffi", + "sha256": "dd3a1ff211eaea95abe83109017c75d0106682a2e221c61c86299ce0017ba87f", + "size": 28735, + "subdir": "linux-64", + "timestamp": 1633090671797, + "version": "0.5.1" + }, + "bcj-cffi-0.5.1-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.14.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1", + "md5": "a6536b4c5f57bfa050d5c9e48a5e6f13", + "name": "bcj-cffi", + "sha256": "87bbfaa1e3378e21f7b683bfc57a81c7c1a60ab474b69fab7edd6af5fc654de9", + "size": 28741, + "subdir": "linux-64", + "timestamp": 1633090541820, + "version": "0.5.1" + }, + "bcolz-1.1.2-py27hde39a96_0.tar.bz2": { + "build": "py27hde39a96_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytables", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "67ed0ef53af6ed531f35e28ebe809440", + "name": "bcolz", + "sha256": "6626bbb07de4c1caf847645eb5eb7a7778c33aa9ff74fa5e04e4f0a845c78683", + "size": 679585, + "subdir": "linux-64", + "timestamp": 1509220450109, + "version": "1.1.2" + }, + "bcolz-1.1.2-py35hcb27967_0.tar.bz2": { + "build": "py35hcb27967_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytables", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f7a47d89b815ede150583252745c8220", + "name": "bcolz", + "sha256": "7e98fb37faa906d139f435dbc85042f11191d55eeba07bc4ab9b497440795a65", + "size": 673236, + "subdir": "linux-64", + "timestamp": 1509220409885, + "version": "1.1.2" + }, + "bcolz-1.1.2-py36h00f5784_0.tar.bz2": { + "build": "py36h00f5784_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytables", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5173b8aa6f31614132ff359e4790699d", + "name": "bcolz", + "sha256": "5db908f56db0da60f55a6da4b7736f98dca3101a0b96105e5db5af35cfd78cf4", + "size": 671759, + "subdir": "linux-64", + "timestamp": 1509220309435, + "version": "1.1.2" + }, + "bcolz-1.2.0-py27h637b7d7_0.tar.bz2": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytables", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7a10a4ed6135749768c549e6ec54de57", + "name": "bcolz", + "sha256": "e4af7336cececa5bd339deb839fc6261a45581a212da86178f3c8e8c7a1ad4ca", + "size": 757170, + "subdir": "linux-64", + "timestamp": 1522705130413, + "version": "1.2.0" + }, + "bcolz-1.2.0-py35h637b7d7_0.tar.bz2": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytables", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c4278ec82d4c91e7784264e1bf8e772", + "name": "bcolz", + "sha256": "63768d6cb4e89f98fa2eec551c867932f080db1179f4b88d0fdbf01a2f6e81d3", + "size": 761189, + "subdir": "linux-64", + "timestamp": 1522705178876, + "version": "1.2.0" + }, + "bcolz-1.2.0-py36h637b7d7_0.tar.bz2": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytables", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d7d2a8479b22182c455976c272e3dee1", + "name": "bcolz", + "sha256": "34c87e7aaad3e33a4a2408de52208c1f7d40ea328ad43c8b7d85f187eed94157", + "size": 773610, + "subdir": "linux-64", + "timestamp": 1522704711877, + "version": "1.2.0" + }, + "bcolz-1.2.1-py27h04863e7_0.tar.bz2": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.11.3,<2.0a0", + "pandas", + "pytables", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8fc21a4d3596f616a8eaff4c18db1529", + "name": "bcolz", + "sha256": "e8c96694e3d771ee93854b20e6301d929a25da09e9c5d9dfb7f82848b6b23bc2", + "size": 776978, + "subdir": "linux-64", + "timestamp": 1530742231552, + "version": "1.2.1" + }, + "bcolz-1.2.1-py27h637b7d7_0.tar.bz2": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytables", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b0af6da68785b94f9efc1be46aeb1c7", + "name": "bcolz", + "sha256": "630d49cad25dfadeafd6a78c618a1f9b36fae67d388efc47476b3c96b8be1e52", + "size": 775714, + "subdir": "linux-64", + "timestamp": 1523992838201, + "version": "1.2.1" + }, + "bcolz-1.2.1-py35h04863e7_0.tar.bz2": { + "build": "py35h04863e7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.11.3,<2.0a0", + "pandas", + "pytables", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c3cf3017c00067556afc0ed64708637", + "name": "bcolz", + "sha256": "a2be2c6c5697ce8dc93d780974c84db676157bccf97f95c78e5094bbc038686b", + "size": 780687, + "subdir": "linux-64", + "timestamp": 1534356711001, + "version": "1.2.1" + }, + "bcolz-1.2.1-py35h637b7d7_0.tar.bz2": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytables", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b196dc7fa2878db344e9d47b2201fed", + "name": "bcolz", + "sha256": "07d02a6fb8abc4e898e5950a341ae15021d18ecc4de561e41f402a57c5ce0e2f", + "size": 783630, + "subdir": "linux-64", + "timestamp": 1523992232979, + "version": "1.2.1" + }, + "bcolz-1.2.1-py36h04863e7_0.tar.bz2": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.11.3,<2.0a0", + "pandas", + "pytables", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7150545e13f319925d1659338ff24bd6", + "name": "bcolz", + "sha256": "5833ddb2bab43c7f014c8c4f713aa58e16785e3bfb16e429569318d5806cc97e", + "size": 789268, + "subdir": "linux-64", + "timestamp": 1530742036156, + "version": "1.2.1" + }, + "bcolz-1.2.1-py36h637b7d7_0.tar.bz2": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytables", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "580c6b8469ffec0842a0e8783468e34d", + "name": "bcolz", + "sha256": "4aaa0706101054e7e1e61298e8d22b8d4c2aa29b7375e886428dd0fbcd455547", + "size": 788885, + "subdir": "linux-64", + "timestamp": 1523992848531, + "version": "1.2.1" + }, + "bcolz-1.2.1-py37h04863e7_0.tar.bz2": { + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.11.3,<2.0a0", + "pandas", + "pytables", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98c754770fa8f49c63d39a28063690fd", + "name": "bcolz", + "sha256": "f2fc3ae5c4fa4fba34b388f942ceee3e592253efc83c223710f2bf9ee1e800ec", + "size": 786892, + "subdir": "linux-64", + "timestamp": 1530742412794, + "version": "1.2.1" + }, + "bcolz-1.2.1-py37h51133e4_1.tar.bz2": { + "build": "py37h51133e4_1", + "build_number": 1, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.5.2", + "numpy >=1.16.6,<2.0a0", + "pandas", + "pytables", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "63f7bfb73b10dae039bfae9cee87ac4a", + "name": "bcolz", + "sha256": "52ce69f6c2d678c655dc2a32c266af930d4df85e9c763ded61b483e445d9ad57", + "size": 810313, + "subdir": "linux-64", + "timestamp": 1639546151131, + "version": "1.2.1" + }, + "bcolz-1.2.1-py38h51133e4_1.tar.bz2": { + "build": "py38h51133e4_1", + "build_number": 1, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.5.2", + "numpy >=1.16.6,<2.0a0", + "pandas", + "pytables", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "0492b233ab9951635b7f1f64e62ffbbf", + "name": "bcolz", + "sha256": "e88bfff3813ae829ef4700c3ff7a4375dd3d3428a0e79ecdf37fa55057e05ce9", + "size": 830477, + "subdir": "linux-64", + "timestamp": 1639550466469, + "version": "1.2.1" + }, + "bcolz-1.2.1-py38h962f231_0.tar.bz2": { + "build": "py38h962f231_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numexpr >=2.5.2", + "numpy >=1.11.3,<2.0a0", + "pandas", + "pytables", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "635ec3054fe269295ff8f1f3c61541de", + "name": "bcolz", + "sha256": "3c99a5f410c4363f78df21d13137ac2bf1277f5338bec1e48702753b3b7e2e04", + "size": 817893, + "subdir": "linux-64", + "timestamp": 1574182281437, + "version": "1.2.1" + }, + "bcrypt-3.1.4-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "3354183e5e63ff3de3d77e3dfa64f7e5", + "name": "bcrypt", + "sha256": "e56c4bbc6c01e2a1e66c7f38a59721c3bfedc14fd6d4bdc06e08e76f3387c6cd", + "size": 41320, + "subdir": "linux-64", + "timestamp": 1530736167577, + "version": "3.1.4" + }, + "bcrypt-3.1.4-py27h8473b39_0.tar.bz2": { + "build": "py27h8473b39_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "1761f4e1feb1bcf0ab2d2d6d772a8b92", + "name": "bcrypt", + "sha256": "ef60604462020a8ba4418cc5ae0b6019454c4ccabaf6fe5a8b8daf20bfc9c1ee", + "size": 41656, + "subdir": "linux-64", + "timestamp": 1508998461925, + "version": "3.1.4" + }, + "bcrypt-3.1.4-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "ac0afd1ac627c6ef45f1e35fce01b8b2", + "name": "bcrypt", + "sha256": "cfeddd31f1cb8acbf0a66ecea4176d83ab88ee2ddf765e8edd0143c9b3e448ab", + "size": 41296, + "subdir": "linux-64", + "timestamp": 1534352194214, + "version": "3.1.4" + }, + "bcrypt-3.1.4-py35ha35c455_0.tar.bz2": { + "build": "py35ha35c455_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "19d01c10f586e2f8d842586b1284c619", + "name": "bcrypt", + "sha256": "f7510f8a9267200ac3d0c5c9779368b99ab63af8ea9573f461c7d5c633dbb891", + "size": 41727, + "subdir": "linux-64", + "timestamp": 1508998464712, + "version": "3.1.4" + }, + "bcrypt-3.1.4-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "d1ca5e6ce001e3eaac94b82b41bcfb7c", + "name": "bcrypt", + "sha256": "367627de9ee03a314f67b5622b11248c2ecf38be634cef9749918cb6be077ab1", + "size": 41371, + "subdir": "linux-64", + "timestamp": 1530736143460, + "version": "3.1.4" + }, + "bcrypt-3.1.4-py36h621fe67_0.tar.bz2": { + "build": "py36h621fe67_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "1bdb3f79c90fc5113cf1eb8021d478b1", + "name": "bcrypt", + "sha256": "ca1eef5450eadc8325999eba1ffe25ab8ede518d414e50f8fb71069c65ea12e7", + "size": 41649, + "subdir": "linux-64", + "timestamp": 1508998405525, + "version": "3.1.4" + }, + "bcrypt-3.1.4-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "3237447cb299900c1204f0ccca870579", + "name": "bcrypt", + "sha256": "cfe376292fee06fe5c7a4d20f9da886096f7080b1769e22a2540cd36895f6a16", + "size": 41371, + "subdir": "linux-64", + "timestamp": 1530736190483, + "version": "3.1.4" + }, + "bcrypt-3.1.5-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "7be28eab58f01b023df16b180a1b11c8", + "name": "bcrypt", + "sha256": "6422a4afdf0a4db8bc743831007ac7711c5ae769baa4fbdfe3ca397bde0419a6", + "size": 42104, + "subdir": "linux-64", + "timestamp": 1545091270205, + "version": "3.1.5" + }, + "bcrypt-3.1.5-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "ca2dd5fcf938d82f851db88846d41875", + "name": "bcrypt", + "sha256": "70c3ae1fa4b25e7320a22c04bce55794bd85d6bbd98839a89764a611c3cf7d51", + "size": 42119, + "subdir": "linux-64", + "timestamp": 1545091262470, + "version": "3.1.5" + }, + "bcrypt-3.1.5-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "a4a8b30cf816166b9939d5777461d92f", + "name": "bcrypt", + "sha256": "2783a69a52599b7668d1fd2d42b002245c441052dd2e92a23c90dc81d319d083", + "size": 42217, + "subdir": "linux-64", + "timestamp": 1545091288236, + "version": "3.1.5" + }, + "bcrypt-3.1.6-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "10252cf1af25a740cc725b2c225446f5", + "name": "bcrypt", + "sha256": "351a4be665927b4b3a158acc9553278c45a00edd435515914e56277a816396af", + "size": 170615, + "subdir": "linux-64", + "timestamp": 1547747204016, + "version": "3.1.6" + }, + "bcrypt-3.1.6-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "1c8a0cf4cb04c976260a82b433d455d3", + "name": "bcrypt", + "sha256": "873e7f40423cae0fea3825a3bf0215bd1f8ea9a4e420793523ec62e93405ca61", + "size": 170383, + "subdir": "linux-64", + "timestamp": 1547747246680, + "version": "3.1.6" + }, + "bcrypt-3.1.6-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "d9894395bf3cdd7e5759a36b0e77a732", + "name": "bcrypt", + "sha256": "a8547e80b6987033a63edb99d4e707275e4b3a31cc6f6b670dc1e36a1e848fa5", + "size": 170693, + "subdir": "linux-64", + "timestamp": 1547747333365, + "version": "3.1.6" + }, + "bcrypt-3.1.7-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9f4a329cde1fd653923059b50e8a1541", + "name": "bcrypt", + "sha256": "5bf5fe6541b39922aa97ef890eba755df2917a8d772725d1c608d949b7adefcb", + "size": 45113, + "subdir": "linux-64", + "timestamp": 1569335757419, + "version": "3.1.7" + }, + "bcrypt-3.1.7-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "39c665f3f784d525c252950e1e120e86", + "name": "bcrypt", + "sha256": "f2cd9d816be7193a671f10bc3be98d5547986e48f92d1b186865bbebacb1656e", + "size": 45185, + "subdir": "linux-64", + "timestamp": 1569335751086, + "version": "3.1.7" + }, + "bcrypt-3.1.7-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "pip", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a1fab45dac9c62aaf6be594757c903a0", + "name": "bcrypt", + "sha256": "b257a40e9dd4d30cc71960871d9b026fe471de01668f71ca4e91f5cde72c8241", + "size": 46535, + "subdir": "linux-64", + "timestamp": 1591779988799, + "version": "3.1.7" + }, + "bcrypt-3.1.7-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8d3e217b879c1727c7b6a3a69bcf1831", + "name": "bcrypt", + "sha256": "461dbaf011c0884ccf458739d8ef3e94e931b4993acae54b640121a6b36e25c3", + "size": 45169, + "subdir": "linux-64", + "timestamp": 1569335757392, + "version": "3.1.7" + }, + "bcrypt-3.1.7-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "pip", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e4d66ad35ad28225b98de694c5790977", + "name": "bcrypt", + "sha256": "1161267b82ca435dee581d488a20610627555e1e881ef7b801018ee0d0a65caf", + "size": 46524, + "subdir": "linux-64", + "timestamp": 1591779976848, + "version": "3.1.7" + }, + "bcrypt-3.1.7-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "601603bd2ca44f1f64da78fe2bd0a54b", + "name": "bcrypt", + "sha256": "e9001cdf2df4e3dd268081776c051e400c0da89ca06081896d78f04cf21b42fb", + "size": 44283, + "subdir": "linux-64", + "timestamp": 1574097639792, + "version": "3.1.7" + }, + "bcrypt-3.1.7-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "pip", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f33699dd3e74c2eff2339f5032cb5fb6", + "name": "bcrypt", + "sha256": "c96812c01ba6ab9884652e6af5a97c685abe0fd3e7e88c08432cc958186fc032", + "size": 46577, + "subdir": "linux-64", + "timestamp": 1591779985418, + "version": "3.1.7" + }, + "bcrypt-3.2.0-py310h5eee18b_1.tar.bz2": { + "build": "py310h5eee18b_1", + "build_number": 1, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=11.2.0", + "pip", + "python >=3.10,<3.11.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0b16a0bb16fceed307e8727acc4bc303", + "name": "bcrypt", + "sha256": "6566f5a656c93347130d583a92ee0ed039818d22c574b41dfab4f477e6110d81", + "size": 75416, + "subdir": "linux-64", + "timestamp": 1659554528313, + "version": "3.2.0" + }, + "bcrypt-3.2.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.5.0", + "pip", + "python >=3.10,<3.11.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "524976c123c7b217bd25d3842d975cf4", + "name": "bcrypt", + "sha256": "4bb549191b2749bce25b66654358577c910428364ed8968ce86c3c64ee92471d", + "size": 73071, + "subdir": "linux-64", + "timestamp": 1640803569515, + "version": "3.2.0" + }, + "bcrypt-3.2.0-py311h5eee18b_1.tar.bz2": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=11.2.0", + "pip", + "python >=3.11,<3.12.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8e3206dde3230fdfaa318606e9da6517", + "name": "bcrypt", + "sha256": "91eb94844b150c8abb6f1dd6de6184111a4ace11cf0d760bceed690efc4b9710", + "size": 46853, + "subdir": "linux-64", + "timestamp": 1676825161053, + "version": "3.2.0" + }, + "bcrypt-3.2.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "pip", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "11c8d5c6efe2b60279da8e6b7ec93fee", + "name": "bcrypt", + "sha256": "0dcce6af3cf82e7bede65d3dd49c9ee92a325e243bb9739216c98171a57b6fc2", + "size": 48166, + "subdir": "linux-64", + "timestamp": 1597936248557, + "version": "3.2.0" + }, + "bcrypt-3.2.0-py37h5eee18b_1.tar.bz2": { + "build": "py37h5eee18b_1", + "build_number": 1, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=11.2.0", + "pip", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "51d66a48d1f74a7f854186f975503263", + "name": "bcrypt", + "sha256": "a0fa177ebbae40325d80fe185265e89b86c87e9f2c75c823bede6f3664c69fae", + "size": 45856, + "subdir": "linux-64", + "timestamp": 1659554471582, + "version": "3.2.0" + }, + "bcrypt-3.2.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "pip", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c7a80c6be8ee2bb586d1f88c3b334ac5", + "name": "bcrypt", + "sha256": "2fc49eaa8e51da0a40663b7d4c174ecead655450fee2bec6568ea8b85293b1ae", + "size": 48073, + "subdir": "linux-64", + "timestamp": 1597936271367, + "version": "3.2.0" + }, + "bcrypt-3.2.0-py38h5eee18b_1.tar.bz2": { + "build": "py38h5eee18b_1", + "build_number": 1, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=11.2.0", + "pip", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "70401ae8594c500692168a71e8ebc632", + "name": "bcrypt", + "sha256": "eeb76362952464674a474af083521f9b958a7dc4bc2444e4f9e8811d271bb369", + "size": 45959, + "subdir": "linux-64", + "timestamp": 1659554390046, + "version": "3.2.0" + }, + "bcrypt-3.2.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "pip", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "228e04cf67c06e9a186276ed27c0f827", + "name": "bcrypt", + "sha256": "e1dc4e1d6e8705ba4ef98a686ab65de9af49ac6aa1c205e89e8ea9adff4871ae", + "size": 48180, + "subdir": "linux-64", + "timestamp": 1597936267082, + "version": "3.2.0" + }, + "bcrypt-3.2.0-py39h5eee18b_1.tar.bz2": { + "build": "py39h5eee18b_1", + "build_number": 1, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=11.2.0", + "pip", + "python >=3.9,<3.10.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e7305caf148ed0bbd0f526bcf22ad9a0", + "name": "bcrypt", + "sha256": "f491756912317af679a17b9ef9de0e3f40a1ce9e7546b3f14c53e0aeceebf2ab", + "size": 45873, + "subdir": "linux-64", + "timestamp": 1659554431121, + "version": "3.2.0" + }, + "bcrypt-3.2.0-py39he8ac12f_0.tar.bz2": { + "build": "py39he8ac12f_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "pip", + "python >=3.9,<3.10.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aa30c1bb3943e31401bd0b4b56f19ae0", + "name": "bcrypt", + "sha256": "d4b34c1c52be6205f2008c42e2c8b4576e9f702a7d839f802eb4e03c11f26ed5", + "size": 47742, + "subdir": "linux-64", + "timestamp": 1607022689227, + "version": "3.2.0" + }, + "beautifulsoup4-4.11.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "53f8cb585b39d6645158a143cff6116b", + "name": "beautifulsoup4", + "sha256": "03b9e21a3599f8c98acf69cfbb9ae0060fc5d6a8633d7f16a7482139425d8e4f", + "size": 189511, + "subdir": "linux-64", + "timestamp": 1650462272428, + "version": "4.11.1" + }, + "beautifulsoup4-4.11.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85c7f7c8238c9271838b3c2658c76a91", + "name": "beautifulsoup4", + "sha256": "4097f65724d5c6652f552c4140033e144cc25cd9dff0e768f7fc107d47f3bb33", + "size": 251044, + "subdir": "linux-64", + "timestamp": 1676823585195, + "version": "4.11.1" + }, + "beautifulsoup4-4.11.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1017b38d5d622ff40bdbf921deff56c0", + "name": "beautifulsoup4", + "sha256": "283155488a42849b4f3753067250407f60669cbe767e42ecc0983cc89770ec54", + "size": 185596, + "subdir": "linux-64", + "timestamp": 1650462305655, + "version": "4.11.1" + }, + "beautifulsoup4-4.11.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31e574b2407c4f094a89dce514f74e7e", + "name": "beautifulsoup4", + "sha256": "f79e051b7bce375fc6a8117020589f06e320e4c7d36304bd152958240b5ac44d", + "size": 186505, + "subdir": "linux-64", + "timestamp": 1650462229973, + "version": "4.11.1" + }, + "beautifulsoup4-4.11.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c68821ab4c31037850b178cbcd5d1e8", + "name": "beautifulsoup4", + "sha256": "f116fe8104c90f5ec95939a2f3ab06b2257d9b2332eeaee4c92242d28b48a462", + "size": 186029, + "subdir": "linux-64", + "timestamp": 1650462197669, + "version": "4.11.1" + }, + "beautifulsoup4-4.12.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "soupsieve >1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e945c659eb50bbdaca28f6f246d1e0a6", + "name": "beautifulsoup4", + "sha256": "2206a6d80e6cbbe49458d774e5a2b5c8d4dee84b703414a06dc66fe1f32bd549", + "size": 191047, + "subdir": "linux-64", + "timestamp": 1680590007316, + "version": "4.12.0" + }, + "beautifulsoup4-4.12.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "soupsieve >1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7de68bb7741b67367da7a8274130ebc2", + "name": "beautifulsoup4", + "sha256": "b1bfe6562f0ae0a4d6eedc75200a3825e759c16b941b941db18a13e389359391", + "size": 251554, + "subdir": "linux-64", + "timestamp": 1680589998073, + "version": "4.12.0" + }, + "beautifulsoup4-4.12.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "soupsieve >1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6cab8ce11c7faa05206cdb32e87dde6", + "name": "beautifulsoup4", + "sha256": "f8dbe31a12be6e74c6176c0fb66189e6225613c839569ba1e8d628399fbb1be1", + "size": 188144, + "subdir": "linux-64", + "timestamp": 1680590025234, + "version": "4.12.0" + }, + "beautifulsoup4-4.12.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "soupsieve >1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "24905b42f2b618503115cc77c646f980", + "name": "beautifulsoup4", + "sha256": "7ef71865746dee38cd2aca738c8a2c714673f8a219a9f9e580766207ae494574", + "size": 187885, + "subdir": "linux-64", + "timestamp": 1680590016327, + "version": "4.12.0" + }, + "beautifulsoup4-4.6.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ab9d0b3c955470f8cb3a9a2b4e7f867", + "name": "beautifulsoup4", + "sha256": "a7caad1cb6ddc8cc7025d1ac9dc4433f23b3b8018c6b1271ae8dd00005bcf6ef", + "size": 132635, + "subdir": "linux-64", + "timestamp": 1530742551705, + "version": "4.6.0" + }, + "beautifulsoup4-4.6.0-py27h3f86ba9_1.tar.bz2": { + "build": "py27h3f86ba9_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bbb5963bcfb57bfb0e081d1d2303d1d5", + "name": "beautifulsoup4", + "sha256": "323f1da45fe0018855f7ecaaeb21721679cd3242547f2276411ad92aa30be3e5", + "size": 132319, + "subdir": "linux-64", + "timestamp": 1505728580658, + "version": "4.6.0" + }, + "beautifulsoup4-4.6.0-py35h442a8c9_1.tar.bz2": { + "build": "py35h442a8c9_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0ff8ada6d68cf0a04de869816301ad3c", + "name": "beautifulsoup4", + "sha256": "ece4725fcb982e25b6225d5c7bf16a6a3299a9fbbcff0554d34436e492d36f46", + "size": 137505, + "subdir": "linux-64", + "timestamp": 1505728596970, + "version": "4.6.0" + }, + "beautifulsoup4-4.6.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87ca42bcaeb46771d6489f2c99b69218", + "name": "beautifulsoup4", + "sha256": "d7d54629fa60153f780a16d05b258798e57ff96fe971e0c9ab20956b3f0afe1f", + "size": 135969, + "subdir": "linux-64", + "timestamp": 1530742529492, + "version": "4.6.0" + }, + "beautifulsoup4-4.6.0-py36h49b8c8c_1.tar.bz2": { + "build": "py36h49b8c8c_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f5f4675ccc372b9a7377bf191fc98c3a", + "name": "beautifulsoup4", + "sha256": "c8663825fa9b96a55f65976196c89c367b54aa031d52365eb6bb3608559ba25c", + "size": 136389, + "subdir": "linux-64", + "timestamp": 1505728613264, + "version": "4.6.0" + }, + "beautifulsoup4-4.6.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de0033dab175bab01ffe2f0733901935", + "name": "beautifulsoup4", + "sha256": "c905f38347e4f27a092363f383b5e215d6a117d7d3f10bdbd03b5c354d413e8e", + "size": 136442, + "subdir": "linux-64", + "timestamp": 1530742579013, + "version": "4.6.0" + }, + "beautifulsoup4-4.6.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec38075a5a1d628a88418db66f53ce3a", + "name": "beautifulsoup4", + "sha256": "f3104c212a8846d1498453769bbb17835e05f2371157809687dd0afb93abb2b6", + "size": 138314, + "subdir": "linux-64", + "timestamp": 1532973305531, + "version": "4.6.1" + }, + "beautifulsoup4-4.6.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "574a6e9de65a187947f25b6a218ae124", + "name": "beautifulsoup4", + "sha256": "d5384fbf10dc0fed5c3e32a7721cee4783b0c801b20596e87ca6127f7fe1310b", + "size": 143142, + "subdir": "linux-64", + "timestamp": 1532973243650, + "version": "4.6.1" + }, + "beautifulsoup4-4.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b053f3de0355fcd3db3771fd7ec43441", + "name": "beautifulsoup4", + "sha256": "f836e4a95be43016bed30507dba4fcf1b0401279ba5281c12c608985a75f1840", + "size": 142276, + "subdir": "linux-64", + "timestamp": 1532973156126, + "version": "4.6.1" + }, + "beautifulsoup4-4.6.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e5e99d50e7483030f6115df10aa6281", + "name": "beautifulsoup4", + "sha256": "52c225f25b46abcf98b8715706afd9400df6a599c68c2773e5dd8cd720bfad8a", + "size": 142047, + "subdir": "linux-64", + "timestamp": 1532973192723, + "version": "4.6.1" + }, + "beautifulsoup4-4.6.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b4e4c3eeb4ceac81cffca419e6ad973", + "name": "beautifulsoup4", + "sha256": "bca8c9a902ff09ce0302750a794876d8d016fe1c13024868b3975e5169e8fae4", + "size": 138193, + "subdir": "linux-64", + "timestamp": 1534176345959, + "version": "4.6.3" + }, + "beautifulsoup4-4.6.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f17241d052b1d5110cfda39a7281339", + "name": "beautifulsoup4", + "sha256": "5332998fa81933f43b8169e773c08a36f49028652012ada28a9bf984d61d32c3", + "size": 143273, + "subdir": "linux-64", + "timestamp": 1534176363905, + "version": "4.6.3" + }, + "beautifulsoup4-4.6.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "783b479c11c8e8aca81332a0e52353e3", + "name": "beautifulsoup4", + "sha256": "4581c6e3caabb3e527d521f5358b0e03fa1aef5aeb294637b36840364d1767e2", + "size": 141619, + "subdir": "linux-64", + "timestamp": 1534176283803, + "version": "4.6.3" + }, + "beautifulsoup4-4.6.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c7dcac1999fbf67b20793019036036c", + "name": "beautifulsoup4", + "sha256": "4f5b8d3ffd981efe19eeba34c71118475d864e65f6f36380ad854185a1012139", + "size": 141584, + "subdir": "linux-64", + "timestamp": 1534176360400, + "version": "4.6.3" + }, + "beautifulsoup4-4.7.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "soupsieve" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff80792a0739a03ed3a31a27f30611af", + "name": "beautifulsoup4", + "sha256": "45f9cfd4eec8851dbf88296237bb068dcaa189734703abb34233ef9a14780031", + "size": 142438, + "subdir": "linux-64", + "timestamp": 1547909423219, + "version": "4.7.1" + }, + "beautifulsoup4-4.7.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "soupsieve" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13a0fddee3eea2e78e62970aed125bef", + "name": "beautifulsoup4", + "sha256": "43c357e594af48290e44738b88d1109396c8c800dd6fd7bbc678bc219090486e", + "size": 146109, + "subdir": "linux-64", + "timestamp": 1547908574740, + "version": "4.7.1" + }, + "beautifulsoup4-4.7.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "soupsieve" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ef7f773eb6edc92c2b23f494c54b0ff", + "name": "beautifulsoup4", + "sha256": "c710dce72828c9a0f5e2aebf5cc79c64c0487ac9fb9e3e2df8a5dcbb1b0c9e5d", + "size": 146061, + "subdir": "linux-64", + "timestamp": 1547909489392, + "version": "4.7.1" + }, + "beautifulsoup4-4.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "soupsieve" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "acac8cfbba082e1287a8000401429e29", + "name": "beautifulsoup4", + "sha256": "deb8f9ed5b35b61d3d804e3222fd5c6c16e9603a698cd6423e42d73119dd09a4", + "size": 146442, + "subdir": "linux-64", + "timestamp": 1565961484122, + "version": "4.8.0" + }, + "beautifulsoup4-4.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "soupsieve" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4c6cbea57707e9a7f61048ec6ccfc044", + "name": "beautifulsoup4", + "sha256": "c7a0275453f723237bed97c5ded00f270252ca3776b3e544dff86562ae2c5bcf", + "size": 150210, + "subdir": "linux-64", + "timestamp": 1565961614075, + "version": "4.8.0" + }, + "beautifulsoup4-4.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "soupsieve" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c690bb3b9edca8b8944627161965fa31", + "name": "beautifulsoup4", + "sha256": "c0a820bde0f1645f3da2052a0bb314907ff505a36cba1355d97ed5ae79d170fe", + "size": 150545, + "subdir": "linux-64", + "timestamp": 1565961695934, + "version": "4.8.0" + }, + "beautifulsoup4-4.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d416a6ffa7d0a0ee908e99187b9e7469", + "name": "beautifulsoup4", + "sha256": "40feed820ac272336d80d5baea8475377c951d64ed5ccd243841ba6874382176", + "size": 152432, + "subdir": "linux-64", + "timestamp": 1571761151596, + "version": "4.8.1" + }, + "beautifulsoup4-4.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cfb6e5e1bd7f3263b70ab2a2026de9ad", + "name": "beautifulsoup4", + "sha256": "9901433aaa6b8c8b7b35eebf240864f6d3be36a9fba32f35e541d9a5dd3002ed", + "size": 156794, + "subdir": "linux-64", + "timestamp": 1571761170567, + "version": "4.8.1" + }, + "beautifulsoup4-4.8.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a8f8168f8a88c7f729b7e77d613ff79", + "name": "beautifulsoup4", + "sha256": "4cdcc993f4eae765d6fde03564febed435d180edeabb1df24beb52ead3d75cb1", + "size": 156594, + "subdir": "linux-64", + "timestamp": 1571761151365, + "version": "4.8.1" + }, + "beautifulsoup4-4.8.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d36245c2322a24dc3f6b6aa0f07a39f4", + "name": "beautifulsoup4", + "sha256": "2195c9f452a37e1438c790788a04a2bec546d6e44a5216b6028a74cdef5deb9c", + "size": 154452, + "subdir": "linux-64", + "timestamp": 1572608998702, + "version": "4.8.1" + }, + "beautifulsoup4-4.8.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3285e4d473ce6bf952f5e8577ca76690", + "name": "beautifulsoup4", + "sha256": "d5d882e9a914b724f4a6c9b5aaeac706919f1294e34f36b9c0db0c64b56e0e95", + "size": 160636, + "subdir": "linux-64", + "timestamp": 1578411539622, + "version": "4.8.2" + }, + "beautifulsoup4-4.8.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ccd3811330a3a305ae16b16b2fdc20c2", + "name": "beautifulsoup4", + "sha256": "94e488c62c0677154113b3fc3032e7bd83f650e05b014a6249ac9756c347736b", + "size": 164901, + "subdir": "linux-64", + "timestamp": 1578411552357, + "version": "4.8.2" + }, + "beautifulsoup4-4.8.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63276b410120ed966be89ab2ba16e2df", + "name": "beautifulsoup4", + "sha256": "5589a6b87aefc341b7e4eafb51ba758bcf03a07457aed9ce66ddca025d3b029e", + "size": 164639, + "subdir": "linux-64", + "timestamp": 1578411508139, + "version": "4.8.2" + }, + "beautifulsoup4-4.8.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b71d4e8a2c2e0aaf0aef871ca886d87b", + "name": "beautifulsoup4", + "sha256": "3e9cdb8a7ba579140b3094273baab9ec209af70eac999a043936f0c939feb0aa", + "size": 165491, + "subdir": "linux-64", + "timestamp": 1578411541192, + "version": "4.8.2" + }, + "beautifulsoup4-4.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a87c30544b5970b377d1eb62eac7e60a", + "name": "beautifulsoup4", + "sha256": "67c6875288f8b02578b5b4b093fe3a1fea2660344803c8e1b5c5024e9f24e927", + "size": 168890, + "subdir": "linux-64", + "timestamp": 1587477917662, + "version": "4.9.0" + }, + "beautifulsoup4-4.9.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "986de9248a784774b14dd1d2af154054", + "name": "beautifulsoup4", + "sha256": "3d7dc58cbba90f22e8545a840ac0cdbc40887baa2f1738bea8ea5351385d320e", + "size": 168781, + "subdir": "linux-64", + "timestamp": 1587477904074, + "version": "4.9.0" + }, + "beautifulsoup4-4.9.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb3b0b242e63be1aebed88efd215adc6", + "name": "beautifulsoup4", + "sha256": "584f907e0169d7eae944fcfd6bc7ecb803ee850e62224a7f19d17046c4566e37", + "size": 169653, + "subdir": "linux-64", + "timestamp": 1587477907162, + "version": "4.9.0" + }, + "beautifulsoup4-4.9.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "573a2de78211e172c0182443e6e7c5c8", + "name": "beautifulsoup4", + "sha256": "841054bb90058639d88f49c652594f13128efc44d66e7e21389052ac0aa90b51", + "size": 171885, + "subdir": "linux-64", + "timestamp": 1591779961460, + "version": "4.9.1" + }, + "beautifulsoup4-4.9.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "795dfac93996a3a655be773d160ef466", + "name": "beautifulsoup4", + "sha256": "a175e064ab90cb76580bf9b22825dc14492aef1decb4e34bd6ec2d96cc233e39", + "size": 172156, + "subdir": "linux-64", + "timestamp": 1605302258590, + "version": "4.9.1" + }, + "beautifulsoup4-4.9.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ada6cb1c1cd9c0ae35eb90dc2ece0af2", + "name": "beautifulsoup4", + "sha256": "06590de08e095c4398a25d56a01e681070c0ea72a1d6642be1e9dcc35224143e", + "size": 166251, + "subdir": "linux-64", + "timestamp": 1590693581365, + "version": "4.9.1" + }, + "beautifulsoup4-4.9.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9bcbc11500a0ff56a0881b96e66652a4", + "name": "beautifulsoup4", + "sha256": "fcb4cf06e44ceb81ddc0349005bf1034ec0c3edff73955c98724aadcb993d994", + "size": 172036, + "subdir": "linux-64", + "timestamp": 1605302295434, + "version": "4.9.1" + }, + "beautifulsoup4-4.9.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "088f0df12818a37657e4bae8389ccb54", + "name": "beautifulsoup4", + "sha256": "867ab0686103c4f3abf4dd572dc3ab91a5e0595494f740212094043492f14beb", + "size": 172548, + "subdir": "linux-64", + "timestamp": 1591779974749, + "version": "4.9.1" + }, + "beautifulsoup4-4.9.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7caf01e0b4ee585416a51f340c52030c", + "name": "beautifulsoup4", + "sha256": "09f39dfd34c6a4bbe8425b28b30c7e86cc645fa9a95ce0b1b2641f34742274ec", + "size": 173041, + "subdir": "linux-64", + "timestamp": 1605302290368, + "version": "4.9.1" + }, + "beautifulsoup4-4.9.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e19e97410ffa79f142554b9321085244", + "name": "beautifulsoup4", + "sha256": "a841c2b08d976bdc1fd802e747c38ed3e1763a7fe519c3c186113e9634f0e173", + "size": 172729, + "subdir": "linux-64", + "timestamp": 1605302277441, + "version": "4.9.1" + }, + "billiard-3.6.0.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d04089a709dbcfab31a233666dcc33f6", + "name": "billiard", + "sha256": "1c26447a727bc4cf48e598ead0126f214e12824a976d4d4edfad6ab66705a356", + "size": 155068, + "subdir": "linux-64", + "timestamp": 1574184925133, + "version": "3.6.0.0" + }, + "billiard-3.6.0.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ac217d9e20da8136e7fe7ae7e8c3314", + "name": "billiard", + "sha256": "a453ab924ffde21f1e6df3325096eb3ca37317bc58eae51d87f645d21728f6ad", + "size": 149399, + "subdir": "linux-64", + "timestamp": 1574184898893, + "version": "3.6.0.0" + }, + "billiard-3.6.0.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "14e2e14a73d39d4c7078e980a5fb4cfa", + "name": "billiard", + "sha256": "e0812f40d3109631bcb7a0ab4c611b4efe148a5cb792559ed4f7b0552c3f197a", + "size": 149478, + "subdir": "linux-64", + "timestamp": 1574184896563, + "version": "3.6.0.0" + }, + "billiard-3.6.0.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "11407c3319d70d35f978ae260db4a2a6", + "name": "billiard", + "sha256": "76c59d4bbf6250beb52401ec430e60e6b2b3d41bd5596e23d754104f5642d34e", + "size": 157574, + "subdir": "linux-64", + "timestamp": 1574184921630, + "version": "3.6.0.0" + }, + "billiard-3.6.2.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1011ee8ce585022b53d362d4775bad3a", + "name": "billiard", + "sha256": "adb6dbdd3bf2c54848830a62fe95d6450615c8a1f501a7a66c97fec674679050", + "size": 150705, + "subdir": "linux-64", + "timestamp": 1582148527531, + "version": "3.6.2.0" + }, + "billiard-3.6.2.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "376bf6a2fd1284b7234f865a291bd496", + "name": "billiard", + "sha256": "c424c27a67e5b48fd7cb5772a8af371668c5ecb0fcd8a9d22adf8fffd6e64dc0", + "size": 150670, + "subdir": "linux-64", + "timestamp": 1582148492524, + "version": "3.6.2.0" + }, + "billiard-3.6.2.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2becce71d52b3d0915159e06fa94c126", + "name": "billiard", + "sha256": "9bf477109d92cbfd51cf14ac055ba461b9c128ba7e29d35259ce6a328da95d36", + "size": 151826, + "subdir": "linux-64", + "timestamp": 1582148529553, + "version": "3.6.2.0" + }, + "billiard-3.6.3.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c2b1b140bc94352df6683c19c4da7c2f", + "name": "billiard", + "sha256": "15d4329f336268362454c76fc21980fae772fad990aa52a073499bde8eb6f191", + "size": 151563, + "subdir": "linux-64", + "timestamp": 1614257642660, + "version": "3.6.3.0" + }, + "billiard-3.6.3.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20fcbc346bb67e4ed0077017d64f9849", + "name": "billiard", + "sha256": "83720c5c44e1ac08e073b734e4883401dc4980ede52b80ae76f4a74439ee616c", + "size": 150780, + "subdir": "linux-64", + "timestamp": 1584971936409, + "version": "3.6.3.0" + }, + "billiard-3.6.3.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "405b22a91610cf3e81d3cd23362a9859", + "name": "billiard", + "sha256": "342632483c4bb72f81a2753d39c72ca1c39918d00382408e6c9fb5abe45d86bb", + "size": 150962, + "subdir": "linux-64", + "timestamp": 1614257639458, + "version": "3.6.3.0" + }, + "billiard-3.6.3.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "95e8430733d0f64347603a57eeb39962", + "name": "billiard", + "sha256": "318eff9b776ee920df09e3e1f5d0ea827270daaad17398e981e09663acfdac40", + "size": 150714, + "subdir": "linux-64", + "timestamp": 1584971900637, + "version": "3.6.3.0" + }, + "billiard-3.6.3.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f44d0152e532924d8357a3d385ae383", + "name": "billiard", + "sha256": "eecdfd23e7aa34c5cd23fcfe5f04de0aa2d4dcd822a34b9303284fed7cebc979", + "size": 152496, + "subdir": "linux-64", + "timestamp": 1614257632836, + "version": "3.6.3.0" + }, + "billiard-3.6.3.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ae0d49584c66277c423b7ddcde29a6a4", + "name": "billiard", + "sha256": "080a0bb49914a24699bbbf547d70d2409b6458c87c97c9ade72f1dd0b6112e9f", + "size": 152200, + "subdir": "linux-64", + "timestamp": 1584971966088, + "version": "3.6.3.0" + }, + "billiard-3.6.3.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4066efe612f49328f9d7477ea720ae99", + "name": "billiard", + "sha256": "2006b5a9bb54b664c83a0ad009ee3803479cb311539ad2f8af0acbb26a471bbe", + "size": 153026, + "subdir": "linux-64", + "timestamp": 1614257644003, + "version": "3.6.3.0" + }, + "billiard-3.6.4.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f3c568e20c4260c97474bd31079fbb0", + "name": "billiard", + "sha256": "251487e109f5b857ea413106416af505f1fd10e0ebdd773c3252fbb1c4365208", + "size": 150702, + "subdir": "linux-64", + "timestamp": 1640788435619, + "version": "3.6.4.0" + }, + "billiard-3.6.4.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "818c4ec2aa242fd349b60199d563441f", + "name": "billiard", + "sha256": "a8b465be3b71d39c12cded38645b2d392c05181ca84039ad75390197aa8207c3", + "size": 207587, + "subdir": "linux-64", + "timestamp": 1676846978084, + "version": "3.6.4.0" + }, + "billiard-3.6.4.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b99bf4550a9a81cb8f18a5ccc56d1acb", + "name": "billiard", + "sha256": "d71298225cbdec3f88fb4816acf9afe27a4c3a28333205bf4773bda872a323fe", + "size": 146625, + "subdir": "linux-64", + "timestamp": 1617383702833, + "version": "3.6.4.0" + }, + "billiard-3.6.4.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c3d2ea9be0beb5b5a30aaf80c600ab8e", + "name": "billiard", + "sha256": "8fe39541046f78d291800a1b8aa159cb32f9b81d2ef9eefea1746df2acf0af88", + "size": 147016, + "subdir": "linux-64", + "timestamp": 1617381120094, + "version": "3.6.4.0" + }, + "billiard-3.6.4.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "165874f69088ecb1cb2e1974bf67e067", + "name": "billiard", + "sha256": "21eaf42e0e0dff258ffa74672d432ec65596acfbd01a5b707a8e82102c37d308", + "size": 148062, + "subdir": "linux-64", + "timestamp": 1617383702482, + "version": "3.6.4.0" + }, + "billiard-3.6.4.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6394b0869370493b4acd2e5dddc795fe", + "name": "billiard", + "sha256": "5b82b94ea09f86ca916e845983f2fd757353e5c56d397a402244de25a328a2f5", + "size": 148621, + "subdir": "linux-64", + "timestamp": 1617383698299, + "version": "3.6.4.0" + }, + "binsort-0.4.1-h7b6447c_1.tar.bz2": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license_family": "BSD", + "md5": "07371dbfdab7e965a60ea732151913c7", + "name": "binsort", + "sha256": "91d7fabe9ec976ebae690973275cda45a7f35572f02939e6b9116ffd9fa1ab39", + "size": 159132, + "subdir": "linux-64", + "timestamp": 1539329724346, + "version": "0.4.1" + }, + "binsort-0.4.1-h7b6447c_2.tar.bz2": { + "build": "h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license_family": "BSD", + "md5": "1c086d3346ea12e028106ff3b48a5fbd", + "name": "binsort", + "sha256": "0e673b093a1b395ba8fec92f1ebc4e1407db62ef78ebcbd99a0324c9b1cfa855", + "size": 159200, + "subdir": "linux-64", + "timestamp": 1539349745535, + "version": "0.4.1" + }, + "binsort-0.4_1-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license_family": "BSD", + "md5": "c93f8c8abf4573cb1ad658fe317fe07c", + "name": "binsort", + "sha256": "0349fde9bc773066e9ba8a850913e8823374e4ff490d3872980157c075544a2f", + "size": 158405, + "subdir": "linux-64", + "timestamp": 1539289443877, + "version": "0.4_1" + }, + "binutils-2.33.1-h53a641e_7.tar.bz2": { + "build": "h53a641e_7", + "build_number": 7, + "depends": [ + "binutils_impl_linux-64 >=2.33.1,<2.33.2.0a0" + ], + "license": "GPL 3", + "md5": "31aa6c40d31866c1438730312e688052", + "name": "binutils", + "sha256": "dc85aaac79337433dd9520a0fb54367141272406d7f22dd9c739968f4fe1e8cb", + "size": 30294, + "subdir": "linux-64", + "timestamp": 1576704292863, + "version": "2.33.1" + }, + "binutils-2.35.1-h9e65a1e_9.tar.bz2": { + "build": "h9e65a1e_9", + "build_number": 9, + "depends": [ + "binutils_impl_linux-64 >=2.35.1,<2.35.2.0a0" + ], + "license": "GPL-3.0-only", + "md5": "72ce0920ba1e8bf7f50e26eca97ecc25", + "name": "binutils", + "sha256": "0439a5af6ee1420e00fa484d3157694a7c4fb4555a5338ffdb26949d13d10855", + "size": 27264, + "subdir": "linux-64", + "timestamp": 1622698570327, + "version": "2.35.1" + }, + "binutils-2.38-h1680402_0.tar.bz2": { + "build": "h1680402_0", + "build_number": 0, + "depends": [ + "binutils_impl_linux-64 >=2.38,<2.39.0a0" + ], + "license": "GPL-3.0-only", + "md5": "cf54c6ff93f9fc1ee7bdfe12146ade7d", + "name": "binutils", + "sha256": "8c54a1cb5546267021abc862943812c9269059204b3ea38055f2c0af77fcc952", + "size": 34146, + "subdir": "linux-64", + "timestamp": 1652588250497, + "version": "2.38" + }, + "binutils-2.38-h1680402_1.tar.bz2": { + "build": "h1680402_1", + "build_number": 1, + "depends": [ + "binutils_impl_linux-64 >=2.38,<2.39.0a0" + ], + "license": "GPL-3.0-only", + "md5": "424e4300f2d9271214d7d8238ca43b5a", + "name": "binutils", + "sha256": "01e20cd8a2ed697a38a8026f4f43599bbc5513b6a5382c50bb9c313feea98d44", + "size": 34671, + "subdir": "linux-64", + "timestamp": 1652971380391, + "version": "2.38" + }, + "binutils_impl_linux-64-2.28.1-h04c84fa_2.tar.bz2": { + "build": "h04c84fa_2", + "build_number": 2, + "depends": [], + "license": "GPL", + "md5": "10db805b93dc1ec59664029f33a5858e", + "name": "binutils_impl_linux-64", + "sha256": "d352fbaf354cd387afc85f042de6068e706fde9aa7416ff8d1af78b640dc2894", + "size": 16793424, + "subdir": "linux-64", + "timestamp": 1507262688378, + "version": "2.28.1" + }, + "binutils_impl_linux-64-2.28.1-had2808c_3.tar.bz2": { + "build": "had2808c_3", + "build_number": 3, + "depends": [], + "license": "GPL", + "md5": "3b6461e837abdb3a66f0b921e21c2653", + "name": "binutils_impl_linux-64", + "sha256": "5b6a995b184f97188adeb3fa70342992a396f2c14a726676033a4fc23f99627c", + "size": 16835483, + "subdir": "linux-64", + "timestamp": 1520534476655, + "version": "2.28.1" + }, + "binutils_impl_linux-64-2.31.1-h6176602_0.tar.bz2": { + "build": "h6176602_0", + "build_number": 0, + "depends": [], + "license": "GPL", + "md5": "5d2e4460eebd061cd8a76b4970b55f04", + "name": "binutils_impl_linux-64", + "sha256": "5158d135f0b9c689024b427215b7d79eb118807d9545ddecf318964b4cebbcba", + "size": 16698165, + "subdir": "linux-64", + "timestamp": 1534628424822, + "version": "2.31.1" + }, + "binutils_impl_linux-64-2.31.1-h6176602_1.tar.bz2": { + "build": "h6176602_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "9c55ea519d5d89ec3306ec5119116fa6", + "name": "binutils_impl_linux-64", + "sha256": "fec3cea7acae40b26a5cc45d8ba8ce8823094d646d340a723a8a4fca5b9193ed", + "size": 17304164, + "subdir": "linux-64", + "timestamp": 1534502899018, + "version": "2.31.1" + }, + "binutils_impl_linux-64-2.33.1-he6710b0_7.tar.bz2": { + "build": "he6710b0_7", + "build_number": 7, + "depends": [ + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL 3", + "md5": "81dc44b5d60cb7213dcd5e4d53332a9d", + "name": "binutils_impl_linux-64", + "sha256": "56e3759ac7de7b3203b5d44f59e63b4afabfd16e2a787c9d1e185447ed6bb5a2", + "size": 9021505, + "subdir": "linux-64", + "timestamp": 1576704272512, + "version": "2.33.1" + }, + "binutils_impl_linux-64-2.35.1-h27ae35d_9.tar.bz2": { + "build": "h27ae35d_9", + "build_number": 9, + "depends": [ + "ld_impl_linux-64 2.35.1 h7274673_9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only", + "md5": "773e904e46d7c40e74e4e939e7736d06", + "name": "binutils_impl_linux-64", + "sha256": "42d0b071d40129056468e360983b7b8f448d56da92a3ea559f7b67b293365b04", + "size": 9947004, + "subdir": "linux-64", + "timestamp": 1622698557758, + "version": "2.35.1" + }, + "binutils_impl_linux-64-2.38-h2a08ee3_0.tar.bz2": { + "build": "h2a08ee3_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64 2.38 h1181459_0", + "libstdcxx-ng >=4.9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only", + "md5": "a9ab7bf4e4e43ac48a7212136f7cda2c", + "name": "binutils_impl_linux-64", + "sha256": "06040b672ea3dea10caaf7c7eb83e62009e12b5f58212e6b7ad8fc0f7235441d", + "size": 11547944, + "subdir": "linux-64", + "timestamp": 1652588237243, + "version": "2.38" + }, + "binutils_impl_linux-64-2.38-h2a08ee3_1.tar.bz2": { + "build": "h2a08ee3_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64 2.38 h1181459_1", + "libstdcxx-ng >=4.9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only", + "md5": "7561521c2e506f1d73566421adaf8770", + "name": "binutils_impl_linux-64", + "sha256": "f13492cb14c4b0456a9403c6379537cbc4ec6bcd343a4ff7640454086c6d6719", + "size": 11632170, + "subdir": "linux-64", + "timestamp": 1652971366937, + "version": "2.38" + }, + "binutils_linux-64-2.28.1-he4fe6c7_1.tar.bz2": { + "build": "he4fe6c7_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "4dc0a2f5859c1d4a0978aa4d265eee03", + "name": "binutils_linux-64", + "sha256": "a1966471985e82a5fb373d9f66787f837bdc79e037f808a8e130404257843615", + "size": 16796746, + "subdir": "linux-64", + "timestamp": 1505665541698, + "version": "2.28.1" + }, + "binutils_linux-64-2.31.1-h6176602_1.tar.bz2": { + "build": "h6176602_1", + "build_number": 1, + "depends": [ + "binutils_impl_linux-64 2.31.1.*" + ], + "license": "GPL", + "md5": "cef5afcc90bf9f0b4e17f493048ab8fc", + "name": "binutils_linux-64", + "sha256": "cffeee461ef5ff22e6e49b0ca947a51148b8e0a61f14d9ed5e7cc85e648b2154", + "size": 9535, + "subdir": "linux-64", + "timestamp": 1534628899031, + "version": "2.31.1" + }, + "binutils_linux-64-2.31.1-h6176602_2.tar.bz2": { + "build": "h6176602_2", + "build_number": 2, + "depends": [ + "binutils_impl_linux-64 2.31.1.*" + ], + "license": "GPL", + "md5": "8a60957955008cb241a341708a5a1ba0", + "name": "binutils_linux-64", + "sha256": "4f9c230530886f3c457b1ca0289cee767b79aba42717186237dddd540630fc3d", + "size": 9442, + "subdir": "linux-64", + "timestamp": 1534794486416, + "version": "2.31.1" + }, + "binutils_linux-64-2.31.1-h6176602_3.tar.bz2": { + "build": "h6176602_3", + "build_number": 3, + "depends": [ + "binutils_impl_linux-64 2.31.1.*" + ], + "license": "GPL", + "md5": "f44055cde540f09c5c73608ac2fcd4e3", + "name": "binutils_linux-64", + "sha256": "a2b94ffd3aa160dddda1da96e4d1e5e6bf9635ad23f5e9c73a12c3a1259b3d33", + "size": 9466, + "subdir": "linux-64", + "timestamp": 1534948636063, + "version": "2.31.1" + }, + "binutils_linux-64-2.31.1-h6176602_6.tar.bz2": { + "build": "h6176602_6", + "build_number": 6, + "depends": [ + "binutils_impl_linux-64 2.31.1.*" + ], + "license": "GPL", + "md5": "48ed95dc4b07b471484ca18300317136", + "name": "binutils_linux-64", + "sha256": "d8d0928a781b94cb633ca97657efa62a7e75c97b2a9df583c426cf48161cf994", + "size": 10314, + "subdir": "linux-64", + "timestamp": 1546883607112, + "version": "2.31.1" + }, + "binutils_linux-64-2.31.1-h6176602_7.tar.bz2": { + "build": "h6176602_7", + "build_number": 7, + "depends": [ + "binutils_impl_linux-64 2.31.1.*" + ], + "license": "GPL", + "md5": "16d714cf78da95bc4391ca4db2cee5e9", + "name": "binutils_linux-64", + "sha256": "932a9ce03d0f25e2fa1653415f8ff90f4dab6ebf78ba2fbda67830a1e39d8f6d", + "size": 9531, + "subdir": "linux-64", + "timestamp": 1556137062358, + "version": "2.31.1" + }, + "binutils_linux-64-2.31.1-h6176602_8.tar.bz2": { + "build": "h6176602_8", + "build_number": 8, + "depends": [ + "binutils_impl_linux-64 2.31.1.*" + ], + "license": "GPL", + "md5": "35b0bca3ac6f76ccf0530b5ea028ac70", + "name": "binutils_linux-64", + "sha256": "80870a6fa68301e227bcd4f0ae9b78fd9c3d89d2ca1379a036f4e15d0c790193", + "size": 151733, + "subdir": "linux-64", + "timestamp": 1565123314418, + "version": "2.31.1" + }, + "binutils_linux-64-2.31.1-h6176602_9.tar.bz2": { + "build": "h6176602_9", + "build_number": 9, + "depends": [ + "binutils_impl_linux-64 2.31.1.*" + ], + "license": "BSD-3-Clause", + "md5": "f2111af80db213f28b25d9f9fab06d76", + "name": "binutils_linux-64", + "sha256": "82e04074690c6e0bc81685d98a841162a7de1346e83c6339ed494e98dc135aa6", + "size": 24787, + "subdir": "linux-64", + "timestamp": 1576689706275, + "version": "2.31.1" + }, + "binutils_linux-64-2.33.1-h9595d00_15.tar.bz2": { + "build": "h9595d00_15", + "build_number": 15, + "depends": [ + "binutils_impl_linux-64 2.33.1.*" + ], + "license": "BSD-3-Clause", + "md5": "7cbe959847f8493dcdf711ff5a88eb25", + "name": "binutils_linux-64", + "sha256": "be39095ce42200b9262b580bdd8d89ea07749517f007833acc4b30465ee29005", + "size": 24815, + "subdir": "linux-64", + "timestamp": 1576707744942, + "version": "2.33.1" + }, + "binutils_linux-64-2.35.1-h454624a_30.tar.bz2": { + "build": "h454624a_30", + "build_number": 30, + "depends": [ + "binutils_impl_linux-64 2.35.1.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "e4fb201355db6092aecd83cf3141e781", + "name": "binutils_linux-64", + "sha256": "0905f6905697eeccc38ff81db72352b923dd6ca000e897d1c44b8929128f80fd", + "size": 22489, + "subdir": "linux-64", + "timestamp": 1623135022525, + "version": "2.35.1" + }, + "binutils_linux-64-2.38.0-hc2dff05_0.tar.bz2": { + "build": "hc2dff05_0", + "build_number": 0, + "depends": [ + "binutils_impl_linux-64 2.38.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "03df80ffb81d3bfa5baad3bfe41bd91c", + "name": "binutils_linux-64", + "sha256": "26d502d30c10da052a945ffba7556a8b36ccccffcbf5d6629dea225b1588080d", + "size": 22823, + "subdir": "linux-64", + "timestamp": 1652867209144, + "version": "2.38.0" + }, + "binutils_linux-64-5.4.0-had2808c_24.tar.bz2": { + "build": "had2808c_24", + "build_number": 24, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "6c66ba92f7938b88d6bb25fcdf477ea9", + "name": "binutils_linux-64", + "sha256": "cdfad7170de1b2bf2414d85795cd403fcb485a1c2cf72850a65f7c7b9bd5f70f", + "size": 8505, + "subdir": "linux-64", + "timestamp": 1520970078674, + "version": "5.4.0" + }, + "binutils_linux-64-7.2.0-19.tar.bz2": { + "build": "19", + "build_number": 19, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "43aea4a381ec295982d56321f97ba0ea", + "name": "binutils_linux-64", + "sha256": "5c9f7f8bcb772210d30f3522ffcf777e369bd88f59ee38613320a5eac419083e", + "size": 5616, + "subdir": "linux-64", + "timestamp": 1513886592695, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-24.tar.bz2": { + "build": "24", + "build_number": 24, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "6856a5aeaf4ac69428a8d06017e8f71c", + "name": "binutils_linux-64", + "sha256": "f6bcbaf898670978d225853f7f45c8062fff8bf81c2b9bebd79ea8ea4f092b93", + "size": 5074, + "subdir": "linux-64", + "timestamp": 1514480887163, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-25.tar.bz2": { + "build": "25", + "build_number": 25, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "25944a871e4eb1962eefea60b771f93a", + "name": "binutils_linux-64", + "sha256": "843e19c4b9e3a635015015e1ba95e1651f11a9b5cbe63eeec1054c5f576aac3c", + "size": 5094, + "subdir": "linux-64", + "timestamp": 1515156399480, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-26.tar.bz2": { + "build": "26", + "build_number": 26, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "6a2b24b7b86c117e6f5bbd351bce51ec", + "name": "binutils_linux-64", + "sha256": "587e4d87ee679f8bb5105b0e422b122c170e9297be120614931785c3b9eb58d6", + "size": 8662, + "subdir": "linux-64", + "timestamp": 1521829422874, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-had2808c_27.tar.bz2": { + "build": "had2808c_27", + "build_number": 27, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "99acaf577084ee28b14c4188c57571d1", + "name": "binutils_linux-64", + "sha256": "674b3d1fef2a0ac67c585d6123d8839ffbd782d26d7b86fccef031d66e949afd", + "size": 8605, + "subdir": "linux-64", + "timestamp": 1526461250603, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_10.tar.bz2": { + "build": "hc67e822_10", + "build_number": 10, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "d3b9d06e8f156bb85aa086629df6ca83", + "name": "binutils_linux-64", + "sha256": "66f425c906914f1e7575fa5e3ac7cec64f97f27043c49205f32da2139e41efe2", + "size": 5088, + "subdir": "linux-64", + "timestamp": 1510244818045, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_11.tar.bz2": { + "build": "hc67e822_11", + "build_number": 11, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "e8d8435460802de6ea858dfcd169f254", + "name": "binutils_linux-64", + "sha256": "5cec550a4817e1de1f4e352885b37e7b18d726843b0506d6027c88507074f354", + "size": 5139, + "subdir": "linux-64", + "timestamp": 1510566119271, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_12.tar.bz2": { + "build": "hc67e822_12", + "build_number": 12, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "3c8341f79ac9d96a8bd18c763957eb71", + "name": "binutils_linux-64", + "sha256": "1df7e40016d14a204ad241821d0b3e94010c2896aa6e9d742ffa455498e76d3c", + "size": 5501, + "subdir": "linux-64", + "timestamp": 1510792708713, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_13.tar.bz2": { + "build": "hc67e822_13", + "build_number": 13, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "4aed35639d4ae71ad1baa06e960dfa18", + "name": "binutils_linux-64", + "sha256": "6543bee0b7a73aaf1227ba227a670e138c2bdfbc70255326848097d36a40873b", + "size": 5143, + "subdir": "linux-64", + "timestamp": 1510925047122, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_14.tar.bz2": { + "build": "hc67e822_14", + "build_number": 14, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "076d099fea2f18fddab5e404447efbbc", + "name": "binutils_linux-64", + "sha256": "61d95fe5508ffc1435c6d5e85ed9a904754742d244968f758cea4fc545cebaab", + "size": 5130, + "subdir": "linux-64", + "timestamp": 1510930963086, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_15.tar.bz2": { + "build": "hc67e822_15", + "build_number": 15, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "be707941ba3b002c9543fd79ae3dc02c", + "name": "binutils_linux-64", + "sha256": "4d1b959ed6725c80fbc43ce29beb61559b2258c18b624ecef58900f8e3279417", + "size": 5148, + "subdir": "linux-64", + "timestamp": 1511640857209, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_2.tar.bz2": { + "build": "hc67e822_2", + "build_number": 2, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "502c6059038cf41f07786d7eb65f5474", + "name": "binutils_linux-64", + "sha256": "188aa89e829464986f229865bd7689339506dac245d666fc14e62237cf56a37b", + "size": 5186, + "subdir": "linux-64", + "timestamp": 1507320096319, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_3.tar.bz2": { + "build": "hc67e822_3", + "build_number": 3, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "81a33281b12a5cbe2995bc0fb2b92440", + "name": "binutils_linux-64", + "sha256": "7e1a72bac7f820d8be04c649f11e464fb15528900e5f95a45dc288aef5e4c0a3", + "size": 5186, + "subdir": "linux-64", + "timestamp": 1507320233202, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_7.tar.bz2": { + "build": "hc67e822_7", + "build_number": 7, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "9a2ecf6ba5371e829765b140351ff09b", + "name": "binutils_linux-64", + "sha256": "ad50113ba4b07775e998639da9ccfe1581a00aee0d1517e22cd5dae53e320396", + "size": 4934, + "subdir": "linux-64", + "timestamp": 1507845399625, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_8.tar.bz2": { + "build": "hc67e822_8", + "build_number": 8, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "d2b0b745fc9db319140a9ff6bc1371fe", + "name": "binutils_linux-64", + "sha256": "8e24855edfb4da2ce64b008d4cb24ed4c8576ec3556371e907fe27c6c09860eb", + "size": 4878, + "subdir": "linux-64", + "timestamp": 1509635177775, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_9.tar.bz2": { + "build": "hc67e822_9", + "build_number": 9, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "660f18b87beaf5c7a263992517c24581", + "name": "binutils_linux-64", + "sha256": "a2858c57fb2652a18eff1e4789f3be893b8a888156a886a345cf26e5a82a98f6", + "size": 5149, + "subdir": "linux-64", + "timestamp": 1509836579647, + "version": "7.2.0" + }, + "binutils_linux-64-7.3.0-h6176602_26.tar.bz2": { + "build": "h6176602_26", + "build_number": 26, + "depends": [ + "binutils_impl_linux-64 2.31.1.*" + ], + "license": "GPL", + "md5": "54f7bb215d5c9863e834bb1f7fc099bf", + "name": "binutils_linux-64", + "sha256": "16e8d175bdf4d417638cc32448e6b27e02a0b50b800d08234ec9638bcf9c7b39", + "size": 8948, + "subdir": "linux-64", + "timestamp": 1534693897217, + "version": "7.3.0" + }, + "binutils_linux-64-8.2.0-h6176602_26.tar.bz2": { + "build": "h6176602_26", + "build_number": 26, + "depends": [ + "binutils_impl_linux-64 2.31.1.*" + ], + "license": "GPL", + "md5": "a629e748a6f088dfe373c0402450c529", + "name": "binutils_linux-64", + "sha256": "7af42654852fd5efa42f8b46eff3a633a2a098aac5099b982c05c45092d867cb", + "size": 8991, + "subdir": "linux-64", + "timestamp": 1534693813493, + "version": "8.2.0" + }, + "biopython-1.70-py27h637b7d7_0.tar.bz2": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.14.1,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "6559f362c963caaca51086b4cbce5a83", + "name": "biopython", + "sha256": "327ca07c548d39f2a771453d5fc2e557b35f6b16b40360d90a9935ae9f92c9ea", + "size": 2454844, + "subdir": "linux-64", + "timestamp": 1519234431708, + "version": "1.70" + }, + "biopython-1.70-py35h637b7d7_0.tar.bz2": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "5c9f585b92ce58072ff7309ba31d662e", + "name": "biopython", + "sha256": "5cda59f0d1ccb98efba4025f9fd5a421818f354e95636732cceb72d2a93510fd", + "size": 2533067, + "subdir": "linux-64", + "timestamp": 1519234481501, + "version": "1.70" + }, + "biopython-1.70-py36h637b7d7_0.tar.bz2": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "2ae076c92acd1c97a96411be8e986cc2", + "name": "biopython", + "sha256": "8875a7d0a7ca7d3fa3846c8aa9f5b7edcce257d0f86eb7a928abce32f801ff3b", + "size": 2514746, + "subdir": "linux-64", + "timestamp": 1519234258645, + "version": "1.70" + }, + "biopython-1.71-py27h04863e7_0.tar.bz2": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "d13ab35ad8cfe0d3613500d637495cd7", + "name": "biopython", + "sha256": "dffc11e18cd77843c7fc07746bbc65627362ac9f1b11bccd0cfe27204838a91b", + "size": 2502616, + "subdir": "linux-64", + "timestamp": 1530742710288, + "version": "1.71" + }, + "biopython-1.71-py27h637b7d7_0.tar.bz2": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "86e4ce86f36d14019427f37106dd675a", + "name": "biopython", + "sha256": "6ed2f22fba2950c25687d27f09abcf0af7467752d56a9a4f32d106bf9aac7efa", + "size": 2500950, + "subdir": "linux-64", + "timestamp": 1523991471899, + "version": "1.71" + }, + "biopython-1.71-py35h637b7d7_0.tar.bz2": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "fc54ff3b0b242405ec55ed3d69adbfac", + "name": "biopython", + "sha256": "58ea3072bda0542b300b5d770439949ce51821c74784e8a28469f8f75de9b3ca", + "size": 2548959, + "subdir": "linux-64", + "timestamp": 1523991906361, + "version": "1.71" + }, + "biopython-1.71-py36h04863e7_0.tar.bz2": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "60a9a9b50cc215518030fb82fd419796", + "name": "biopython", + "sha256": "56186f230a611e69776dfacae558da4ccfceb489c437f8c04d9c5c3c63b2969c", + "size": 2562223, + "subdir": "linux-64", + "timestamp": 1530742648277, + "version": "1.71" + }, + "biopython-1.71-py36h637b7d7_0.tar.bz2": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "62c1717b87d2144d309eb65a83a64010", + "name": "biopython", + "sha256": "0a2d8d544d41afec8636f6d8fbe790aa6c414d9393039a9aaab8d7ab955cb568", + "size": 2559697, + "subdir": "linux-64", + "timestamp": 1523991906970, + "version": "1.71" + }, + "biopython-1.71-py37h04863e7_0.tar.bz2": { + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "626b6ee72dcdf5897e9152e428eeccee", + "name": "biopython", + "sha256": "f9e021aeef655314dcc3221f4e6fcc8a77c12400a2cd589ecefdb0ddc0f47c2e", + "size": 2531029, + "subdir": "linux-64", + "timestamp": 1530770848574, + "version": "1.71" + }, + "biopython-1.72-py27h04863e7_0.tar.bz2": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "1d60d8324a2ddbbbaf5ff1c639e485fd", + "name": "biopython", + "sha256": "211f559932d53d60379baab0ea48d8c16a74ab83bdc879dc5cb489595f40f522", + "size": 2581414, + "subdir": "linux-64", + "timestamp": 1532542364205, + "version": "1.72" + }, + "biopython-1.72-py35h04863e7_0.tar.bz2": { + "build": "py35h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "c6c7bdd86962a712b3f5cd878df7fc08", + "name": "biopython", + "sha256": "6d18eaf29932c2765ea66288e2e718cbb9c1fb8f339a068de23e28db9aa2e450", + "size": 2615480, + "subdir": "linux-64", + "timestamp": 1532542394791, + "version": "1.72" + }, + "biopython-1.72-py36h04863e7_0.tar.bz2": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "a32fea1898a021d33673ec5dc8e21978", + "name": "biopython", + "sha256": "fd8809982aa1749cd4253da80306260b128e597e88bc40f3c297130532e4afd6", + "size": 2617114, + "subdir": "linux-64", + "timestamp": 1532542411893, + "version": "1.72" + }, + "biopython-1.72-py37h04863e7_0.tar.bz2": { + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "47980f871db92239abbd5cd968688e7b", + "name": "biopython", + "sha256": "420a2b7a65e8ab71e2ee492ff88d9dc892c5877d78fba9ad8d73c5337e4c79ce", + "size": 2592429, + "subdir": "linux-64", + "timestamp": 1532542408961, + "version": "1.72" + }, + "biopython-1.73-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "Biopython License Agreement", + "md5": "92fe7fbd7ff454ca60484271b54449b4", + "name": "biopython", + "sha256": "bd2b124c224d69c54b7132c4797ce2745b62c0d6d20c8fc070fff6e96aaba0da", + "size": 2579091, + "subdir": "linux-64", + "timestamp": 1556062547283, + "version": "1.73" + }, + "biopython-1.73-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "md5": "e760b17219dd3d7c9c366bcba5827a38", + "name": "biopython", + "sha256": "a6541a4a22b59a782f8e7058f2b8c84403a17f3cc7f29f5ad49c919aae84c5b4", + "size": 2597812, + "subdir": "linux-64", + "timestamp": 1556062691349, + "version": "1.73" + }, + "biopython-1.73-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Biopython License Agreement", + "md5": "7744e7cec13d1a2bc146ddb64292c216", + "name": "biopython", + "sha256": "129806e2d561e546877273c8589ce4edf1a39310b37946a6a1eca5c2ad4fb33f", + "size": 2574526, + "subdir": "linux-64", + "timestamp": 1556062539816, + "version": "1.73" + }, + "biopython-1.74-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "Biopython License Agreement", + "md5": "7f041844c5815d5fc4d942354c898f43", + "name": "biopython", + "sha256": "ca5346a99ef3134902c0af6cf857eacdfa1503598ec9db30ac661b7508eb93bf", + "size": 2641977, + "subdir": "linux-64", + "timestamp": 1564133769765, + "version": "1.74" + }, + "biopython-1.74-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "md5": "fe5ae5c77b62f84deca3c11e177be556", + "name": "biopython", + "sha256": "49a8f6e87d86dcaae69d966a27f92c79206150047f3c73e2b9a624e52c384d86", + "size": 2655178, + "subdir": "linux-64", + "timestamp": 1564133754490, + "version": "1.74" + }, + "biopython-1.74-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Biopython License Agreement", + "md5": "3d0c312c87fac4f4a13d233824b5ff54", + "name": "biopython", + "sha256": "97c63f100ed1d27619297687a77b0071624b8b96ff43dcf69b1b6c243cad58d3", + "size": 2627167, + "subdir": "linux-64", + "timestamp": 1564133768576, + "version": "1.74" + }, + "biopython-1.74-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "Biopython License Agreement", + "md5": "2f76bc7e0aa478f3a85f9e4ec5cf2ba0", + "name": "biopython", + "sha256": "7f83a04265b8525601c6f84c38aa8f727319b9b91f7e904b2ede24bfa55570d5", + "size": 2627637, + "subdir": "linux-64", + "timestamp": 1573738261593, + "version": "1.74" + }, + "biopython-1.76-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "md5": "690d1559bc8cbd87ae7a25fdbc0b9c13", + "name": "biopython", + "sha256": "110001cc5d7b55261443a116cdd5c6846525dfb409ee553605568349198c8e21", + "size": 2740753, + "subdir": "linux-64", + "timestamp": 1581952481548, + "version": "1.76" + }, + "biopython-1.76-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Biopython License Agreement", + "md5": "fd677f8e63241990847e1a552ef36c00", + "name": "biopython", + "sha256": "7516b2e3f052adfa1be81d75520d9d92ed9c73838cfc32f4d784cbd5e6bcf011", + "size": 2703377, + "subdir": "linux-64", + "timestamp": 1581952536712, + "version": "1.76" + }, + "biopython-1.76-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "Biopython License Agreement", + "md5": "883a66423175d854a976b7a70b8b47c3", + "name": "biopython", + "sha256": "b82fcea20f6352059b808811b4da79f720e89cb80b479dac12e5b241c7428730", + "size": 2710254, + "subdir": "linux-64", + "timestamp": 1581952360642, + "version": "1.76" + }, + "biopython-1.77-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "md5": "b95ec5b40d7832971534891629213c53", + "name": "biopython", + "sha256": "ac645002910ec9d91c35c0d7fce1bae96d53e189eed5f07ff7ab3be3cfa9dd84", + "size": 2805388, + "subdir": "linux-64", + "timestamp": 1613155485809, + "version": "1.77" + }, + "biopython-1.77-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "md5": "2bc4184fa3869a0fd34552e4320c8869", + "name": "biopython", + "sha256": "05879a959e7cc827f81c57b5a36cb52a779978f39c2a451639b14b13377160f3", + "size": 2798237, + "subdir": "linux-64", + "timestamp": 1593539388816, + "version": "1.77" + }, + "biopython-1.77-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Biopython License Agreement", + "md5": "11934e54ee156d77972a74e5d354566c", + "name": "biopython", + "sha256": "905d40bbca925d64f92b06dc699b60976ba9ad28c3fffc89456280232acc3c36", + "size": 2759604, + "subdir": "linux-64", + "timestamp": 1613155480711, + "version": "1.77" + }, + "biopython-1.77-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Biopython License Agreement", + "md5": "24d2e95fb78b55e63e62958b74155c68", + "name": "biopython", + "sha256": "66998ceeb436f5fa679d3300d808290d999a320c6b973c4aa9ab6a9e85241178", + "size": 2751971, + "subdir": "linux-64", + "timestamp": 1593539375308, + "version": "1.77" + }, + "biopython-1.77-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "Biopython License Agreement", + "md5": "0a4b53fe7bfe5d511a93f7ebe1e51c3f", + "name": "biopython", + "sha256": "96458edb720e807f97b8542673687453ffdf8cf3a54ad52caa87872cc6986a1f", + "size": 2763617, + "subdir": "linux-64", + "timestamp": 1613155453063, + "version": "1.77" + }, + "biopython-1.77-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "Biopython License Agreement", + "md5": "4dda12dbff87511bc26da57488bec6de", + "name": "biopython", + "sha256": "d174992f2079a5a2af5a12253ddd29bf66b293b98ee8d93aadd2beaa8fcc97cf", + "size": 2775818, + "subdir": "linux-64", + "timestamp": 1593539397791, + "version": "1.77" + }, + "biopython-1.77-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "Biopython License Agreement", + "md5": "cb732dcd6b8981528203603c36f624c6", + "name": "biopython", + "sha256": "d15f385b26b85195d5ecb499b8137e3074bc8cff33ad656b98070c48960711d6", + "size": 2758243, + "subdir": "linux-64", + "timestamp": 1613155493601, + "version": "1.77" + }, + "biopython-1.78-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy", + "python >=3.10,<3.11.0a0" + ], + "license": "Biopython License Agreement", + "md5": "3693d05f12c0fd70a2327d0cef4485ec", + "name": "biopython", + "sha256": "fa7cb3de9913d7f70647e1c4f136520593fd970878df193fe8671d834d42702f", + "size": 3026409, + "subdir": "linux-64", + "timestamp": 1640788472679, + "version": "1.78" + }, + "biopython-1.78-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy", + "python >=3.11,<3.12.0a0" + ], + "license": "Biopython License Agreement", + "md5": "32c31c38bb76325d61af249e78645c09", + "name": "biopython", + "sha256": "3d1c6cb6b4a522d3f207b60bbab1f5d8eefd19e0ef71b51cb4ccd9cf8e03f3e8", + "size": 3334451, + "subdir": "linux-64", + "timestamp": 1676847008152, + "version": "1.78" + }, + "biopython-1.78-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "md5": "3ecbd8a9107f794c0f8d84cf4840abb8", + "name": "biopython", + "sha256": "e84642544d5715066a25bf6aaec882502d6fdeaf7f7c5a69eccdc108f61c6563", + "size": 2782527, + "subdir": "linux-64", + "timestamp": 1600298950921, + "version": "1.78" + }, + "biopython-1.78-py36h7f8727e_0.tar.bz2": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "md5": "43d1c7c967a0a899c223b6014a39c580", + "name": "biopython", + "sha256": "597313bb040346cc1e1a3785d6390211ffc12f0b66508ba266c7e4d0602cc0ab", + "size": 2783869, + "subdir": "linux-64", + "timestamp": 1632748513007, + "version": "1.78" + }, + "biopython-1.78-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Biopython License Agreement", + "md5": "163e3d19530e1c65db8db7928a969d48", + "name": "biopython", + "sha256": "16d1630d9834050a09d33ffc21ac0a8d4a3192d0ae7ee4b0d34d5e5f21027de5", + "size": 2727289, + "subdir": "linux-64", + "timestamp": 1600298915577, + "version": "1.78" + }, + "biopython-1.78-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Biopython License Agreement", + "md5": "b90d6439d89efee0fd5e32bc01c3b0ba", + "name": "biopython", + "sha256": "779dfda84f8b086160b97458c6c0cfa4b85678c414c31a58ef642dbcab2814c6", + "size": 2739370, + "subdir": "linux-64", + "timestamp": 1632738127026, + "version": "1.78" + }, + "biopython-1.78-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "Biopython License Agreement", + "md5": "241150f0824acd1c270309cb74d79118", + "name": "biopython", + "sha256": "0117cf6e5436b866550bd5b7ab4782aa3abfc69438e71cc725a2e5b429de429e", + "size": 2736183, + "subdir": "linux-64", + "timestamp": 1600351962281, + "version": "1.78" + }, + "biopython-1.78-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "Biopython License Agreement", + "md5": "ea698023d6827883cae399487d99cc44", + "name": "biopython", + "sha256": "1ab23de5c6532cc3ac308af945bb8eac9d58acffc314a9fa78bce29436f41a9f", + "size": 2736632, + "subdir": "linux-64", + "timestamp": 1632748128146, + "version": "1.78" + }, + "biopython-1.78-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "Biopython License Agreement", + "md5": "4534158e9e254b8f0ad4cfe4795a28ba", + "name": "biopython", + "sha256": "873542a368d801968f64c10c1940ae54559557047c2177653a85e277f986d356", + "size": 2745045, + "subdir": "linux-64", + "timestamp": 1632748490860, + "version": "1.78" + }, + "bison-3.0.4-h2db1b24_1.tar.bz2": { + "build": "h2db1b24_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "32ed9f4a6a9fdd56bd2577d89644381a", + "name": "bison", + "sha256": "81451a953fa4622a7a5fcd4950a741586f3a0e0fdf20f31e285265fce8778b6b", + "size": 622148, + "subdir": "linux-64", + "timestamp": 1505728684179, + "version": "3.0.4" + }, + "bison-3.0.4-hf484d3e_2.tar.bz2": { + "build": "hf484d3e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "73514e9c0cc107807e15ef31e98c5f36", + "name": "bison", + "sha256": "2f3fe1e237404434053ec8b02f4d74c9750962932e18f29710ac9360b6a71cc8", + "size": 620859, + "subdir": "linux-64", + "timestamp": 1529348703923, + "version": "3.0.4" + }, + "bison-3.0.5-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "5bb9ffc3fe4bc454842c040dcdcc845d", + "name": "bison", + "sha256": "0ca09112216326e4e00b34a4f778d6947a75262c6184a1f7d3f0e8964955a490", + "size": 644510, + "subdir": "linux-64", + "timestamp": 1529566255098, + "version": "3.0.5" + }, + "bison-3.0.5-hf484d3e_1.tar.bz2": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "261a8bc96066f199116a803a274ca7ea", + "name": "bison", + "sha256": "7112a46619958a7fe5cd3a49ef690debec0dd6bfadcbacd3c81333e89376bc95", + "size": 644561, + "subdir": "linux-64", + "timestamp": 1530648327360, + "version": "3.0.5" + }, + "bison-3.1-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL 3", + "md5": "8d9ea56b6943dd26ed4e637f994e03c9", + "name": "bison", + "sha256": "3d17b15b8557458252b92de46f6e77e794fcdfdd7055738a7bee5503e3cbe0c9", + "size": 650786, + "subdir": "linux-64", + "timestamp": 1539468543978, + "version": "3.1" + }, + "bison-3.4-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0", + "md5": "9859159774fd76d9836d9f6525937940", + "name": "bison", + "sha256": "f130a92e816900d4abcb43cb2cd90659e51098764002490387f51f0d04a0e4a1", + "size": 683927, + "subdir": "linux-64", + "timestamp": 1564614713849, + "version": "3.4" + }, + "bison-3.4-he6710b0_1.tar.bz2": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "flex", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0", + "md5": "ef4b1c970eb96aa855044776c8fb9c06", + "name": "bison", + "sha256": "5f572acfcd6d8307ded0db94ddd835cb3f2a39c0b4f249f0e2de4725319fece3", + "size": 685820, + "subdir": "linux-64", + "timestamp": 1573952797905, + "version": "3.4" + }, + "bison-3.7.2-he6710b0_1.tar.bz2": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "flex", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0", + "md5": "8b208804911e95994074c29a9a768780", + "name": "bison", + "sha256": "a3a76cf352d3ce8b29b589f9e10644a8dd23d5efe4c9d6c6f31bcdd387026454", + "size": 798576, + "subdir": "linux-64", + "timestamp": 1601406052972, + "version": "3.7.2" + }, + "bison-3.7.3-he6710b0_1.tar.bz2": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "flex", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0", + "md5": "76250433e44fcb9cb0d3b46e50c0767a", + "name": "bison", + "sha256": "9badb2139c449951b431a2ab3dda2aeeb47449b5b9d3ee00a439efb7be7b9bff", + "size": 790483, + "subdir": "linux-64", + "timestamp": 1602605985078, + "version": "3.7.3" + }, + "bison-3.7.4-h2531618_1.tar.bz2": { + "build": "h2531618_1", + "build_number": 1, + "depends": [ + "flex", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0", + "md5": "3bfddb6daea6f4dec0c60d30432021b5", + "name": "bison", + "sha256": "7781f8d219357711bcae7663e82fc3417aab41e3c777d4c548f117f288075894", + "size": 802420, + "subdir": "linux-64", + "timestamp": 1607111502162, + "version": "3.7.4" + }, + "bison-3.7.5-h2531618_1.tar.bz2": { + "build": "h2531618_1", + "build_number": 1, + "depends": [ + "flex", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0", + "md5": "6b11a1a8f7e0e71432d677f29e2f6b34", + "name": "bison", + "sha256": "b46ffc67afb8c40f8d3db3e797271cddb590007646afce8831bd4af819e3511d", + "size": 805557, + "subdir": "linux-64", + "timestamp": 1611514570295, + "version": "3.7.5" + }, + "bisonpp-1.21_45-hff7bd54_1002.tar.bz2": { + "build": "hff7bd54_1002", + "build_number": 1002, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "ab18daac8b3bda95fdae8737a70ca6b4", + "name": "bisonpp", + "sha256": "d975520bdd70e8ff679256b0d605f5e4b2edb4adf7ee33d6be864af1214a0128", + "size": 145700, + "subdir": "linux-64", + "timestamp": 1622236637389, + "version": "1.21_45" + }, + "bitarray-0.8.1-py27h14c3975_1.tar.bz2": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "dcf93fa82e1b04e873693e44edd78fdc", + "name": "bitarray", + "sha256": "e0b993d8c71ff0ad723c44f9ec1cfe98fdf8db70a8d36d05bf75800d27a1113c", + "size": 61486, + "subdir": "linux-64", + "timestamp": 1518032537360, + "version": "0.8.1" + }, + "bitarray-0.8.1-py27h304d4c6_0.tar.bz2": { + "build": "py27h304d4c6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "fddf82f0c14b2fbfa49c2c2a6a0e7f66", + "name": "bitarray", + "sha256": "ee5c216d2d7995904e759cd6846e25260180298da61c0f843d6b923a263ab716", + "size": 61063, + "subdir": "linux-64", + "timestamp": 1505728699639, + "version": "0.8.1" + }, + "bitarray-0.8.1-py35h14c3975_1.tar.bz2": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "PSF", + "md5": "eada7dc56d533a290a43555cd51c72f8", + "name": "bitarray", + "sha256": "9120d8f3571be23bc7910fa74b58847d46541d69dcc7cfca985ee7ace7d7e954", + "size": 62243, + "subdir": "linux-64", + "timestamp": 1518030913269, + "version": "0.8.1" + }, + "bitarray-0.8.1-py35h7540340_0.tar.bz2": { + "build": "py35h7540340_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "PSF", + "md5": "33db43fe28faa97f0c48834646678394", + "name": "bitarray", + "sha256": "779217fdb79158ebb3cd59f5436fda78df4db7dd13fc478180dc16d252d8a847", + "size": 61990, + "subdir": "linux-64", + "timestamp": 1505728715854, + "version": "0.8.1" + }, + "bitarray-0.8.1-py36h14c3975_1.tar.bz2": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "fd5aba7bbeefde589a08b8b9141ecb99", + "name": "bitarray", + "sha256": "d2d1a64f9ad45fd11e5c878bd9d88c52ed33aded34ca08b8c246c2ff562e5152", + "size": 61896, + "subdir": "linux-64", + "timestamp": 1518031506246, + "version": "0.8.1" + }, + "bitarray-0.8.1-py36h5834eb8_0.tar.bz2": { + "build": "py36h5834eb8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "e884a6978f8d8a182440c9b030a84333", + "name": "bitarray", + "sha256": "dc2ff9359038b87ee277086760769ac82c7fad9b3540c46fbbd0c6c2ce6008df", + "size": 61669, + "subdir": "linux-64", + "timestamp": 1505728732318, + "version": "0.8.1" + }, + "bitarray-0.8.2-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "27342bf50ec4cf330336095c44552cbe", + "name": "bitarray", + "sha256": "b14cf4291a8405f1efd3cdd6ef3c1429146eb9db09ab848ca18f74cd95635c2e", + "size": 55970, + "subdir": "linux-64", + "timestamp": 1528210442336, + "version": "0.8.2" + }, + "bitarray-0.8.2-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "PSF", + "md5": "50238fb0553a471aa2e21e6cb938f0da", + "name": "bitarray", + "sha256": "a11f2b45613f9037fb692b778ad9dc2de2bb4d4acbc5fd56041534062840c4ad", + "size": 56861, + "subdir": "linux-64", + "timestamp": 1528210515389, + "version": "0.8.2" + }, + "bitarray-0.8.2-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "c3fed685f1c58bead0477000334cc2c1", + "name": "bitarray", + "sha256": "76e0209b1742b208cc3114a5aa5e086e360b44fff80ea92396e1194220240677", + "size": 56548, + "subdir": "linux-64", + "timestamp": 1528210490763, + "version": "0.8.2" + }, + "bitarray-0.8.2-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "cde4f7f52d32d9eaa5a3958b2d64bbbb", + "name": "bitarray", + "sha256": "23bcd324721b6d988c0329a13d9d70d2544deeee7ae24f598eba11f59eebdf97", + "size": 56060, + "subdir": "linux-64", + "timestamp": 1530770880878, + "version": "0.8.2" + }, + "bitarray-0.8.3-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "acd8de0687d94ec7aeacf82e928c779d", + "name": "bitarray", + "sha256": "0b2a090ef2337c3b0a65db2e9a712d35f116c0e2fd8f55efae9ef8400885eeed", + "size": 55826, + "subdir": "linux-64", + "timestamp": 1532525189576, + "version": "0.8.3" + }, + "bitarray-0.8.3-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "PSF", + "md5": "e7a835449f123ef0932e582713d1106b", + "name": "bitarray", + "sha256": "fa9dfb2034ac644059658a27662051cedbb6a555b50fb5c3760519a3ed2c59d0", + "size": 56679, + "subdir": "linux-64", + "timestamp": 1532525186028, + "version": "0.8.3" + }, + "bitarray-0.8.3-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "0d6f75ecb16610d249bbfbb795fead14", + "name": "bitarray", + "sha256": "086378bf0b159d57c282339842151cde7bd47c2cf5c42e587b6839d5c74e69a0", + "size": 56320, + "subdir": "linux-64", + "timestamp": 1532525131596, + "version": "0.8.3" + }, + "bitarray-0.8.3-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "e8dfe21e3e5b892c8f501ad1006d1301", + "name": "bitarray", + "sha256": "02073e7e89f54c91ea7955e470b4f5eb56142d525f0f6cdbe212b611f962a1c3", + "size": 55928, + "subdir": "linux-64", + "timestamp": 1532525193185, + "version": "0.8.3" + }, + "bitarray-0.9.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "75d4dbed45ad2b3308b4523d275e91a8", + "name": "bitarray", + "sha256": "2ec1ed679369560f3b0dbdf5bb52b89db32819d9d28d9247493f38e005e91dd7", + "size": 59146, + "subdir": "linux-64", + "timestamp": 1555954589643, + "version": "0.9.0" + }, + "bitarray-0.9.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "1ea8d3d0d85fb9c0f491a6fe1fe3b0b1", + "name": "bitarray", + "sha256": "338357604d0accf8f5b465fe631a87e7d2a2985921e942c81b8c35be8afa62a5", + "size": 59817, + "subdir": "linux-64", + "timestamp": 1555954747421, + "version": "0.9.0" + }, + "bitarray-0.9.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "0efa0537e81dd5ae4125dc89241aa6b8", + "name": "bitarray", + "sha256": "dfb998c157ec9ad628eaa45024b8479ab31741a42c8adb57e45cf60001d1c42a", + "size": 59386, + "subdir": "linux-64", + "timestamp": 1555954723605, + "version": "0.9.0" + }, + "bitarray-0.9.2-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "aa4e0839246a8df08dfbfcd3846fe388", + "name": "bitarray", + "sha256": "f4c2fa928fb24b761949e51bd1580d913acab4d91e528bda57d27212dc93defa", + "size": 59603, + "subdir": "linux-64", + "timestamp": 1557507385920, + "version": "0.9.2" + }, + "bitarray-0.9.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "82548a2d24990585ab85dda427bfd2f6", + "name": "bitarray", + "sha256": "a34c1cd1456a38e45f057afe70bb8a32d9ccd64fc9a8e5175c8cf4cfa7439123", + "size": 60225, + "subdir": "linux-64", + "timestamp": 1557507404064, + "version": "0.9.2" + }, + "bitarray-0.9.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "9b08e69e7c120cd52650e297dde0f6f8", + "name": "bitarray", + "sha256": "92ec2111c1fc597bf9bcec7d2588363ea3fee3292e250736bb64b0ee24b309c3", + "size": 59880, + "subdir": "linux-64", + "timestamp": 1557507368929, + "version": "0.9.2" + }, + "bitarray-0.9.3-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "1bbd789b03436936a989487db3720041", + "name": "bitarray", + "sha256": "fedc55fa4bb331314db1449ad4f9898c7634ac914f8947af732bf9c888dd2040", + "size": 61155, + "subdir": "linux-64", + "timestamp": 1558553847917, + "version": "0.9.3" + }, + "bitarray-0.9.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "54e338fde1289e21ab6ddba9fd2627f9", + "name": "bitarray", + "sha256": "99f61f6674af85856fbe1e9cc405af1b8ed82db7d935ff8f8c648cecb4ef9f09", + "size": 61820, + "subdir": "linux-64", + "timestamp": 1558553876584, + "version": "0.9.3" + }, + "bitarray-0.9.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "852d6328d8ee39d7dd6227b80402d7bd", + "name": "bitarray", + "sha256": "d345deccdef131590dc42f9a5fb7aecb82301a055e9f4bd67fa8c692e416d9bf", + "size": 61475, + "subdir": "linux-64", + "timestamp": 1558553807689, + "version": "0.9.3" + }, + "bitarray-1.0.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "7ff653ccceeb5a4de65088daa77325e1", + "name": "bitarray", + "sha256": "b62a4acf7e25f99293a207560d3052c8b40ce677a4f35030b2c8910068277dd8", + "size": 61086, + "subdir": "linux-64", + "timestamp": 1565962341213, + "version": "1.0.1" + }, + "bitarray-1.0.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "5b0c4d314a78c8610369762c6c5d4724", + "name": "bitarray", + "sha256": "15e74a621c83843ddb4520d5920634824a3f296d7d3bff04fa5438995c9de23c", + "size": 61776, + "subdir": "linux-64", + "timestamp": 1565962309794, + "version": "1.0.1" + }, + "bitarray-1.0.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "c0947ca638050d86643912cd24a304ac", + "name": "bitarray", + "sha256": "4ba7be4df4da4e07d9327dd51d9a92c89932aa2066b6c696fa06489db8b3ef67", + "size": 61214, + "subdir": "linux-64", + "timestamp": 1565962284646, + "version": "1.0.1" + }, + "bitarray-1.0.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "2c3687e8188974a6adfc5366c2f1e0b3", + "name": "bitarray", + "sha256": "1de884e14a0486a1fd690c997913ffece2577ef9d68a1ca562fe12800f438e01", + "size": 66391, + "subdir": "linux-64", + "timestamp": 1572609073689, + "version": "1.0.1" + }, + "bitarray-1.1.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "79960c74569018c98ee4bbfcf5409caf", + "name": "bitarray", + "sha256": "097a98c6a0a26dd0b3443be995a7c857e369b8d3cb99c3b4f6b05efa8e431234", + "size": 68790, + "subdir": "linux-64", + "timestamp": 1573937671633, + "version": "1.1.0" + }, + "bitarray-1.1.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "ac2669faf942a32bc3e25c78d1a1bec0", + "name": "bitarray", + "sha256": "7117a3a76d8cbfc83419cf1a9501c5c64a8b2b3f39f533cb3edfa2826bb40ee2", + "size": 69626, + "subdir": "linux-64", + "timestamp": 1573937655717, + "version": "1.1.0" + }, + "bitarray-1.1.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "67dedcfa8e1f9d7c12243e02be7b59a9", + "name": "bitarray", + "sha256": "541836d0b21f84f33a43f19139d291e28355846367f94e0172bb68898e903120", + "size": 69091, + "subdir": "linux-64", + "timestamp": 1573937634800, + "version": "1.1.0" + }, + "bitarray-1.1.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "db55eb9fffef4847132938cd2bb6018f", + "name": "bitarray", + "sha256": "94835c5dc2b45f1a4e2148d68e26574cb8a76ba09abfc1502aad6853733d52ab", + "size": 76220, + "subdir": "linux-64", + "timestamp": 1573937687889, + "version": "1.1.0" + }, + "bitarray-1.2.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "807c8da67a806f99c0884eed621a7598", + "name": "bitarray", + "sha256": "6fcbdaeb33db5fca7c753165080dc2e5ef34d0e83c8d304e7d4dff53c28c9c56", + "size": 82738, + "subdir": "linux-64", + "timestamp": 1576537929528, + "version": "1.2.0" + }, + "bitarray-1.2.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "ff36fbd06726f336cc9d779b42ac2459", + "name": "bitarray", + "sha256": "674a9a2544082231855f68108be797582c2db8032451b93d0b6bec4a420d6fb2", + "size": 83648, + "subdir": "linux-64", + "timestamp": 1576537906127, + "version": "1.2.0" + }, + "bitarray-1.2.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "a1e9d8052c6c1b0a0c50acf366eafe3c", + "name": "bitarray", + "sha256": "afa6c8e0e22cfca13b0c05d21118ff338da9fba103f68d89970f3441baa13e40", + "size": 82982, + "subdir": "linux-64", + "timestamp": 1576537932412, + "version": "1.2.0" + }, + "bitarray-1.2.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "bcf2dff34977b8cce2ab8a14a1b1a13c", + "name": "bitarray", + "sha256": "f1c5abf11c0dc34f789cb6480a3c2b54e92249be2dd4de27c22aa4b041e26772", + "size": 90050, + "subdir": "linux-64", + "timestamp": 1576537962705, + "version": "1.2.0" + }, + "bitarray-1.2.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "67dbe9fd0a4be0285611ea92db049186", + "name": "bitarray", + "sha256": "1db7637bcfd357160cfef94ac4cffb497b359606f8ce5572050e65bb9ea6536e", + "size": 83696, + "subdir": "linux-64", + "timestamp": 1580153030553, + "version": "1.2.1" + }, + "bitarray-1.2.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "ce6ba59510b33848071f12c4cf69377c", + "name": "bitarray", + "sha256": "3987071cf184651fcc944757ec48069c92a72a5b7bf8a39e6450f36623d82b12", + "size": 82961, + "subdir": "linux-64", + "timestamp": 1580153141996, + "version": "1.2.1" + }, + "bitarray-1.2.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "3f1928deb6e4cd0e1713f7a0caa9321d", + "name": "bitarray", + "sha256": "930e02ac85c62187d36c2dcead2aa9f0d216913e9dea4b191d596917790ec315", + "size": 83082, + "subdir": "linux-64", + "timestamp": 1580153033390, + "version": "1.2.1" + }, + "bitarray-1.2.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "8151c8da3022308698c78429640f9d5f", + "name": "bitarray", + "sha256": "0ab4b52b443bcaa941cd0a55ce114f83cd3ebf6bdbd9820933f013092420998e", + "size": 84486, + "subdir": "linux-64", + "timestamp": 1591724817528, + "version": "1.2.2" + }, + "bitarray-1.2.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "2f5f1d7e5c11be481c88e3e3c2b5fd9c", + "name": "bitarray", + "sha256": "177f433ed9d88a01266da0be4d3ab2202e49836d0ff2c10e9c6c6e73a62d5f8e", + "size": 83803, + "subdir": "linux-64", + "timestamp": 1591724824789, + "version": "1.2.2" + }, + "bitarray-1.2.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "1acf3fc1f37226f5064597fbd7d64f6e", + "name": "bitarray", + "sha256": "bf6ed4617270fb36953baadff3ef60464c040adf01591b91dc703fa235d53b4e", + "size": 83855, + "subdir": "linux-64", + "timestamp": 1591724823309, + "version": "1.2.2" + }, + "bitarray-1.3.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "e98e906ffc60458199daf2ce40a2a1cd", + "name": "bitarray", + "sha256": "b2f8bc7e160cf05088e75acff0b6ac8a9285af7f2632d1c7c717d200801387bc", + "size": 87405, + "subdir": "linux-64", + "timestamp": 1594237136902, + "version": "1.3.0" + }, + "bitarray-1.3.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "d9354aa7cc5d436eea7e802370fced9b", + "name": "bitarray", + "sha256": "d2cfd2abbb4c75f5bd0f6c6f3960545975ff7d828731953b5c02df63b6165e54", + "size": 86578, + "subdir": "linux-64", + "timestamp": 1594237120475, + "version": "1.3.0" + }, + "bitarray-1.3.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "3a3c8b11e31f916d3da0221dea98f13d", + "name": "bitarray", + "sha256": "75832ad41dc08d6b128d26a2943ba251b15cd7df03b9111e107fbe6994a921f3", + "size": 86656, + "subdir": "linux-64", + "timestamp": 1594237153182, + "version": "1.3.0" + }, + "bitarray-1.4.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "7eda0873cf9fc1f3800156504505d1c0", + "name": "bitarray", + "sha256": "49afd01a7b830ad862884a36f43c26bcff2be0967f9d8e840ff7a6c13503a523", + "size": 89099, + "subdir": "linux-64", + "timestamp": 1594753917320, + "version": "1.4.0" + }, + "bitarray-1.4.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "8253286246629221ec028564c5664747", + "name": "bitarray", + "sha256": "9b4819aa4abca8fc865cc9945ba07973723a586eee6a489f5606964a865f07ed", + "size": 88254, + "subdir": "linux-64", + "timestamp": 1594753964179, + "version": "1.4.0" + }, + "bitarray-1.4.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "3fb77cd5bb88836facf64bd3b310f008", + "name": "bitarray", + "sha256": "6711ef7e532597ce72723445e55ed1d477262630c61df0bfc9502d8e91a6d4b2", + "size": 88342, + "subdir": "linux-64", + "timestamp": 1594753917558, + "version": "1.4.0" + }, + "bitarray-1.4.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "1ad62b64d2196a6269df341d82a7604f", + "name": "bitarray", + "sha256": "261e62287019daa29b9e1993ff36044b3562efb84bc4839910d1336ce07741a3", + "size": 90969, + "subdir": "linux-64", + "timestamp": 1596108569879, + "version": "1.4.2" + }, + "bitarray-1.4.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "92e3d1f6e9f17619d51e0bd00baa5e23", + "name": "bitarray", + "sha256": "19c5bde925c24f28bfd82ff8dec1a33fde15e3d8fb6749b8e1b777f324b01d62", + "size": 90256, + "subdir": "linux-64", + "timestamp": 1596108562750, + "version": "1.4.2" + }, + "bitarray-1.4.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "48f8a7cc035d5ddc60ad365c736af55a", + "name": "bitarray", + "sha256": "d4d4fe42bd95e31d98a78ed97d79d05d69712745fd3dc5739d4092b23a03baf9", + "size": 90214, + "subdir": "linux-64", + "timestamp": 1596108599253, + "version": "1.4.2" + }, + "bitarray-1.5.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "aa53f0997d5aaf7f702a117277badb5a", + "name": "bitarray", + "sha256": "0b0623628e262f1b737867d9ab6f3e46ba18ab5afb749b3fca93de921d0b493f", + "size": 93125, + "subdir": "linux-64", + "timestamp": 1597678783286, + "version": "1.5.2" + }, + "bitarray-1.5.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "9cef972b09ff8b3fe6a669a2e0012193", + "name": "bitarray", + "sha256": "af3c8d409ace2fc1d257ff4303b17272ec575a5d9725e4120129f4b0713f10a6", + "size": 92091, + "subdir": "linux-64", + "timestamp": 1597678804683, + "version": "1.5.2" + }, + "bitarray-1.5.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "c553058f3b362843361b2362abe1ffb6", + "name": "bitarray", + "sha256": "6fe3c780d1f406922dc6d3c06c5dd565c37203852b98c2f8e7368012776e3aff", + "size": 92156, + "subdir": "linux-64", + "timestamp": 1597678783344, + "version": "1.5.2" + }, + "bitarray-1.5.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "6e07b077fce0ff74da721687e0ebfdef", + "name": "bitarray", + "sha256": "78e2b2c4ab004a28564238044751a28d11fc4f8e1781e4b49b9b8224d0ffdc6a", + "size": 94213, + "subdir": "linux-64", + "timestamp": 1598885003484, + "version": "1.5.3" + }, + "bitarray-1.5.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "d98c2ac9a89594d15dea3295d7740156", + "name": "bitarray", + "sha256": "c025a0d5c5e5b2c882e79a4c0ba29d4eba07aeb89f16d3043997f7fa2837d12b", + "size": 93087, + "subdir": "linux-64", + "timestamp": 1598885036711, + "version": "1.5.3" + }, + "bitarray-1.5.3-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "16fccfd1cfa41e36d115b85d0b3a45e5", + "name": "bitarray", + "sha256": "116c91518508ff6f78249b808c6b968bc92b83bbe09793c8a030858dde3c7a1d", + "size": 93101, + "subdir": "linux-64", + "timestamp": 1598884962413, + "version": "1.5.3" + }, + "bitarray-1.6.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "8c90241b7d493cae85e7dc4463e011dd", + "name": "bitarray", + "sha256": "0a47f94711c95826206f8d1a595bc325f25a7bcc21b96524007e7e5eb32e1df9", + "size": 91750, + "subdir": "linux-64", + "timestamp": 1603210389514, + "version": "1.6.0" + }, + "bitarray-1.6.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "9dfe75d344708a8f4ffc1f10ac9ad067", + "name": "bitarray", + "sha256": "f50f510f60ac298f860add8e2f40edc4cfbf5e70b7d045f96f47ece371abb605", + "size": 90814, + "subdir": "linux-64", + "timestamp": 1603210389814, + "version": "1.6.0" + }, + "bitarray-1.6.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "aa5fe62a0d3d3a65612335601d023a86", + "name": "bitarray", + "sha256": "6d65e2d8ddc552ce09c78846b6859a6d1b399cc8b6c8e2b6bf89508b2a0fc678", + "size": 90899, + "subdir": "linux-64", + "timestamp": 1603210421851, + "version": "1.6.0" + }, + "bitarray-1.6.1-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "198cc009bc78b7e8c21bcbdbef8b1a50", + "name": "bitarray", + "sha256": "edbe20123f76aad251ce9c04841d775d7579f342e322e7b5060310d10116b95e", + "size": 91804, + "subdir": "linux-64", + "timestamp": 1605065168405, + "version": "1.6.1" + }, + "bitarray-1.6.1-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "066dfb0b2b00216ce47cd1f7a707f5b4", + "name": "bitarray", + "sha256": "e8fb1472fc53c3f8c64aa68dfd1ce0182405d6560568353097c4f446f2a2bb76", + "size": 90821, + "subdir": "linux-64", + "timestamp": 1605065184417, + "version": "1.6.1" + }, + "bitarray-1.6.1-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "f46d9fa8e37bf33f07c29281cdf186b7", + "name": "bitarray", + "sha256": "d9857dc8118eee05fa1c2c302e3d6710516c93c1d364cb6cefa90092e656c6ea", + "size": 90916, + "subdir": "linux-64", + "timestamp": 1605065149477, + "version": "1.6.1" + }, + "bitarray-1.6.1-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "8067b71a14a1c60f8a7770af4c9598b8", + "name": "bitarray", + "sha256": "c85aa28eecc943d522f1cf28762828cf76a1ec44df5671c1b819165fafae5805", + "size": 90994, + "subdir": "linux-64", + "timestamp": 1605065157725, + "version": "1.6.1" + }, + "bitarray-1.6.3-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "4885898b3af736ed5e496cba6cb0d364", + "name": "bitarray", + "sha256": "c0fc4f26734c7bca5eeabfa53b348e463ec62d41196374441afa1ba43f42a471", + "size": 96319, + "subdir": "linux-64", + "timestamp": 1611254302557, + "version": "1.6.3" + }, + "bitarray-1.6.3-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "b79e2177ebd8c533698f48ed2745f11c", + "name": "bitarray", + "sha256": "444b145aea2576c1180169b640c5df293249edc87bf95b16159c1f658aeba56f", + "size": 95565, + "subdir": "linux-64", + "timestamp": 1611254407815, + "version": "1.6.3" + }, + "bitarray-1.6.3-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "ccec0069737ca3b7f063a2ae01f8e997", + "name": "bitarray", + "sha256": "8fd843749884e585831c8f74ffb1099815f7577a9999fd80287989855f0ada12", + "size": 95492, + "subdir": "linux-64", + "timestamp": 1611254399540, + "version": "1.6.3" + }, + "bitarray-1.6.3-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "90f1237498e05768c01858e998012982", + "name": "bitarray", + "sha256": "d12ace34b9b52962c157aff7d60d12a4f1a32bfa9c911628c2c5c6513453ed4b", + "size": 95539, + "subdir": "linux-64", + "timestamp": 1611254430049, + "version": "1.6.3" + }, + "bitarray-1.7.0-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "f9168234875e8af7879e6542ae488fb9", + "name": "bitarray", + "sha256": "55b6a7866e2205e4dd0f8ab71604198750305863f408cdef73763b993e3efe2b", + "size": 97315, + "subdir": "linux-64", + "timestamp": 1614627880520, + "version": "1.7.0" + }, + "bitarray-1.7.0-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "4d3a064332b41aa996af7cddd1ae8900", + "name": "bitarray", + "sha256": "81c0e87c29a0f3ce1389b7c1f7aa2683a88baa5275e839b52124621d7b97bffa", + "size": 96138, + "subdir": "linux-64", + "timestamp": 1614614612726, + "version": "1.7.0" + }, + "bitarray-1.7.0-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "7f3f152f27f039e9531d77a5b30f0fe7", + "name": "bitarray", + "sha256": "1fdc2b6ff19d91d5008fe2c1156d83c405581dd19994b0e2066afab30fbcfb13", + "size": 96301, + "subdir": "linux-64", + "timestamp": 1614628205158, + "version": "1.7.0" + }, + "bitarray-1.7.0-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "b0405c828bca45c34f6c90ec5f9ec7bc", + "name": "bitarray", + "sha256": "ae508425eeb07c5d7fcce46fff1466f03a923e5164b8e4f6de3662e4a3266019", + "size": 96478, + "subdir": "linux-64", + "timestamp": 1614613977471, + "version": "1.7.0" + }, + "bitarray-1.7.1-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "a1f590c3219827fff577ccf8cd7bf23a", + "name": "bitarray", + "sha256": "caa4b85f6ada2e0bf0ac8008f6eb97210a8f09d76b36a78c3621fe6185c77fd0", + "size": 97034, + "subdir": "linux-64", + "timestamp": 1615661016737, + "version": "1.7.1" + }, + "bitarray-1.7.1-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "9a5f8bb8e9ab9aba353e3aad2d505ec8", + "name": "bitarray", + "sha256": "6680752348233a93c422d127ae1e591171f7eb1047f10a27e7029168d588b13a", + "size": 96081, + "subdir": "linux-64", + "timestamp": 1615660280755, + "version": "1.7.1" + }, + "bitarray-1.7.1-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "88e4ca1155416c8c6ad8fc1450c6ce1a", + "name": "bitarray", + "sha256": "77294fb95414c6242d7e0c91d554f0e0fa67f34fd9aba26cf53798341336e30f", + "size": 96147, + "subdir": "linux-64", + "timestamp": 1615661011517, + "version": "1.7.1" + }, + "bitarray-1.7.1-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "fa135016ee6c7fbe3ebe541b58476974", + "name": "bitarray", + "sha256": "de5fe0fb82f8143d43fc654ee530dd88d260a41a57466ad128bcaadda474cf2b", + "size": 96268, + "subdir": "linux-64", + "timestamp": 1615661017115, + "version": "1.7.1" + }, + "bitarray-1.8.0-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "f0652c1cdc7593a6a15b28edd537dea4", + "name": "bitarray", + "sha256": "239262d03ee2e4cb33466b1b7f4ec485e43eaecb54b3ac04aa039af0ae9d69c1", + "size": 101836, + "subdir": "linux-64", + "timestamp": 1616441486971, + "version": "1.8.0" + }, + "bitarray-1.8.0-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "12cc60388a716f95298af1a42705ad03", + "name": "bitarray", + "sha256": "9236f4b311fb9700ae4e35b0f529ad36819b7f739eb80469729bf22554b24a7f", + "size": 100866, + "subdir": "linux-64", + "timestamp": 1616441336780, + "version": "1.8.0" + }, + "bitarray-1.8.0-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "fa7ddb928952ecff7bdd468da3ced252", + "name": "bitarray", + "sha256": "e28b29369d424bdc354a1bea094a1bc48dcb9a48e458d1b05e6a67158623cca5", + "size": 101023, + "subdir": "linux-64", + "timestamp": 1616441490709, + "version": "1.8.0" + }, + "bitarray-1.8.0-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "7d32bb072702d9ed3b062d279a512d8f", + "name": "bitarray", + "sha256": "eabcc8b0f75f8c6f5afda19efbb51bfd6c716ed253afb03bff4c899bd27e1321", + "size": 101084, + "subdir": "linux-64", + "timestamp": 1616441506797, + "version": "1.8.0" + }, + "bitarray-1.8.2-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "185340dfe46039672f7e9d1899e34d08", + "name": "bitarray", + "sha256": "37a2369c3063f0772d56ba2b529e112bde2918678a0fc84a4864f600bc424012", + "size": 104309, + "subdir": "linux-64", + "timestamp": 1617219400683, + "version": "1.8.2" + }, + "bitarray-1.8.2-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "dc38c750afae800876eb5afb129d04e7", + "name": "bitarray", + "sha256": "6e2bcb0ef45df8113fb359ae7d635604964e408376433c917e8d08a9869b47a0", + "size": 103285, + "subdir": "linux-64", + "timestamp": 1617221904141, + "version": "1.8.2" + }, + "bitarray-1.8.2-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "80458b9d51f84383082aba08ba6b4aa9", + "name": "bitarray", + "sha256": "f852237fd98b0655d4f4db09dc26254ea2bf01a13abf1e1869c3f136a78d789a", + "size": 103375, + "subdir": "linux-64", + "timestamp": 1617221902114, + "version": "1.8.2" + }, + "bitarray-1.8.2-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "c311847e7c85fee924d646d992a0decc", + "name": "bitarray", + "sha256": "c92131da2abf01c89126a0280c515d21f0bea9a15b899b3ab4b8093e949a7225", + "size": 103515, + "subdir": "linux-64", + "timestamp": 1617221903416, + "version": "1.8.2" + }, + "bitarray-1.9.0-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "3c9fbbe9728ed385748599508e41ab89", + "name": "bitarray", + "sha256": "39aa319936b2ec51d434b4d86c504692fe3512462c19ed63f92a0296a753ca78", + "size": 111520, + "subdir": "linux-64", + "timestamp": 1617622055646, + "version": "1.9.0" + }, + "bitarray-1.9.0-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "078e3abd6fd084f564f91f8f7a4f668c", + "name": "bitarray", + "sha256": "1aa1cf1418f6e0940e7a385da18371133aa0a4075e6d85fd7643063b4e8a8adf", + "size": 110451, + "subdir": "linux-64", + "timestamp": 1617624769757, + "version": "1.9.0" + }, + "bitarray-1.9.0-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "f6c09478a76a174b340b7b8fa2fdc803", + "name": "bitarray", + "sha256": "0329080832eaf767ad5daea4d2a7dde4af8e22d73ee06ec6749a4eba4697c34d", + "size": 110432, + "subdir": "linux-64", + "timestamp": 1617481189695, + "version": "1.9.0" + }, + "bitarray-1.9.0-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "8b6e6c04f496964e85b4a031d6f20abe", + "name": "bitarray", + "sha256": "c6c69ad54283f9e67717babdf450eb21f870c1397fd8ec7b9eb1c9a95c20dcf0", + "size": 110776, + "subdir": "linux-64", + "timestamp": 1617481198573, + "version": "1.9.0" + }, + "bitarray-1.9.1-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "16d7ca8bf614e00987599913cf01b083", + "name": "bitarray", + "sha256": "a537f8b8bab5f691cd338027b8d01be99dc9017a6ccf9f2c63525e8183345f65", + "size": 117359, + "subdir": "linux-64", + "timestamp": 1617654724478, + "version": "1.9.1" + }, + "bitarray-1.9.1-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "aa8d25ea6191017b68aefd3c89fe5464", + "name": "bitarray", + "sha256": "390b78aae38a6e1468d0f829586e408e425171472131dde6d1adb86aed38d728", + "size": 116191, + "subdir": "linux-64", + "timestamp": 1617654722457, + "version": "1.9.1" + }, + "bitarray-1.9.1-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "ca4f17a92622387b7c21ee7966d71c70", + "name": "bitarray", + "sha256": "585835e7b1e2559c197d78076b8e2db608313d1c58b69839746ba792a7323f6a", + "size": 116244, + "subdir": "linux-64", + "timestamp": 1617654724820, + "version": "1.9.1" + }, + "bitarray-1.9.1-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "a312f1bbf9985524da9b8fb728a2cbeb", + "name": "bitarray", + "sha256": "10a0c934748b390af0bb83d7171ed68cb69bc1aa7c336f987588b3782d77f6c0", + "size": 116391, + "subdir": "linux-64", + "timestamp": 1617654396983, + "version": "1.9.1" + }, + "bitarray-1.9.2-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "2cd7a6b00890fcf89575d4b0d7c2e0ed", + "name": "bitarray", + "sha256": "0a2052c61585f2f64b2aa0d2b09416ab168d3e52663c217ab4d7034f8099f095", + "size": 117762, + "subdir": "linux-64", + "timestamp": 1618434919599, + "version": "1.9.2" + }, + "bitarray-1.9.2-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "d3859084ac4ca06c38979f37c963b72b", + "name": "bitarray", + "sha256": "aaf4f3532bb26e9134c3c15c6972aca2aa0f7b5c2cd81d16f372006e21826394", + "size": 116675, + "subdir": "linux-64", + "timestamp": 1618434920232, + "version": "1.9.2" + }, + "bitarray-1.9.2-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "80e047542a5af5eb78d9e0453bdfb074", + "name": "bitarray", + "sha256": "179ba2e28c42fb8294a4b8b75bb878f6f034fd50499bb2c80ffe0e6578ab8274", + "size": 116682, + "subdir": "linux-64", + "timestamp": 1618431804744, + "version": "1.9.2" + }, + "bitarray-1.9.2-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "f7698a6dce562bddd737a454610d50b9", + "name": "bitarray", + "sha256": "621271b2438ff1eade99b50d95df9631851d3e278c80592d48faccc6adb37282", + "size": 116758, + "subdir": "linux-64", + "timestamp": 1618434915421, + "version": "1.9.2" + }, + "bitarray-2.1.0-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "4e9b1a6e6cbaf9fd911a8ea6aeaa1fbe", + "name": "bitarray", + "sha256": "e3d0164c2f38000ffe2d7dc72031161729375701f9c59484960a92b055b2d206", + "size": 121328, + "subdir": "linux-64", + "timestamp": 1620823284203, + "version": "2.1.0" + }, + "bitarray-2.1.0-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "7ce66abca6828f5ddce54760dac7a65d", + "name": "bitarray", + "sha256": "1afa3c7e2a9806babefdfe29287ab3b8a1222982834b3496d18f29157f9d6831", + "size": 120106, + "subdir": "linux-64", + "timestamp": 1620827457178, + "version": "2.1.0" + }, + "bitarray-2.1.0-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "98d525371f15fcc65430eb317df12dfd", + "name": "bitarray", + "sha256": "b1e99758cde229e763967fbf603991639a1b8598e56237ee5ac71324d3aeeeef", + "size": 120280, + "subdir": "linux-64", + "timestamp": 1620827598629, + "version": "2.1.0" + }, + "bitarray-2.1.0-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "f776189fa5af6990df694812cfe1a6e1", + "name": "bitarray", + "sha256": "4e053cd49d75a277b2a1307b7bd550894fc3f1bb735e23b51c0b02eb9353a388", + "size": 120362, + "subdir": "linux-64", + "timestamp": 1620827598531, + "version": "2.1.0" + }, + "bitarray-2.2.3-py36h7f8727e_1.tar.bz2": { + "build": "py36h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "4d9be0d2b3ef4136fd461cd01f8be7b0", + "name": "bitarray", + "sha256": "35212369cbcb10d4a68169d7db50828bc434f81500121c797a88171699bf006b", + "size": 128949, + "subdir": "linux-64", + "timestamp": 1627479976196, + "version": "2.2.3" + }, + "bitarray-2.2.3-py37h7f8727e_1.tar.bz2": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "9ebb3f574140a3bb36ee6f88a742aa82", + "name": "bitarray", + "sha256": "0b9993f13c96ab5842dbe5f0114fed2f3493d060a0cb6bd8e38bf8e84178e6cc", + "size": 127831, + "subdir": "linux-64", + "timestamp": 1627480561890, + "version": "2.2.3" + }, + "bitarray-2.2.3-py38h7f8727e_1.tar.bz2": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "492bb797e22d8f9a445e1bbf2b950d2a", + "name": "bitarray", + "sha256": "305c12fc85578ccfab03361bf313f8407246eb1c59f60e79e656402fdd8c9ccf", + "size": 127734, + "subdir": "linux-64", + "timestamp": 1627480563868, + "version": "2.2.3" + }, + "bitarray-2.2.3-py39h7f8727e_1.tar.bz2": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "bc5ace3701c44b2ddb211cd4ea118e0b", + "name": "bitarray", + "sha256": "4b8255477ef3b2753e6f24bd4a7959844c57054ab107f7848b2dbcf9ed02080b", + "size": 127825, + "subdir": "linux-64", + "timestamp": 1627472882689, + "version": "2.2.3" + }, + "bitarray-2.2.5-py36h7f8727e_1.tar.bz2": { + "build": "py36h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "bf7f9cf3eae8ece84703bc3882f623fc", + "name": "bitarray", + "sha256": "1382be97c0305dc2b33cc2469a5777cba2114bfcab819edee720505ba6a92733", + "size": 134018, + "subdir": "linux-64", + "timestamp": 1628540510364, + "version": "2.2.5" + }, + "bitarray-2.2.5-py37h7f8727e_1.tar.bz2": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "7e3e67206a6509e4728a4aed578e1427", + "name": "bitarray", + "sha256": "e2a336e61bbed205fd0735f573f99f23de2ac7cb204dc6a57740440ca7908e7a", + "size": 132444, + "subdir": "linux-64", + "timestamp": 1628540359507, + "version": "2.2.5" + }, + "bitarray-2.2.5-py38h7f8727e_1.tar.bz2": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "464bcbd4e6acff1c3baf852a1eb1fcd8", + "name": "bitarray", + "sha256": "ea40bc5537259d449fa642b3e944cf66a729337809efde11644b01ec419bb678", + "size": 132372, + "subdir": "linux-64", + "timestamp": 1628540490017, + "version": "2.2.5" + }, + "bitarray-2.2.5-py39h7f8727e_1.tar.bz2": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "977aed545b8b0611a8c43d0ea5b01a1b", + "name": "bitarray", + "sha256": "cd29d8c483c2325a9e0742390f97ae87d4ad03f16bf459e6e052a3212bbb97c7", + "size": 132481, + "subdir": "linux-64", + "timestamp": 1628532269490, + "version": "2.2.5" + }, + "bitarray-2.3.0-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "78afe6962894dbef4a307b73a949fa6e", + "name": "bitarray", + "sha256": "383d1344c9b4e53a6e283e62bf42db147be70473c80df6d42c78f3030e483e88", + "size": 219080, + "subdir": "linux-64", + "timestamp": 1640788499308, + "version": "2.3.0" + }, + "bitarray-2.3.0-py36h7f8727e_1.tar.bz2": { + "build": "py36h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "4cf06bef47eea9d949c7010ee291bec7", + "name": "bitarray", + "sha256": "c0e42b7df20ef1a09cbdbff660b563bc73f7375627c9b6d9e806025235374237", + "size": 140738, + "subdir": "linux-64", + "timestamp": 1629132540068, + "version": "2.3.0" + }, + "bitarray-2.3.0-py37h7f8727e_1.tar.bz2": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "65e74446693bdbe002667cf4f7b1b7df", + "name": "bitarray", + "sha256": "f585aa0a15010343a3fe8d953f732dd90657b600dabbe425b9a011471a93ab8f", + "size": 139689, + "subdir": "linux-64", + "timestamp": 1629132898382, + "version": "2.3.0" + }, + "bitarray-2.3.0-py38h7f8727e_1.tar.bz2": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "daf0cf0fbefdd1d82e53e11c0fc70412", + "name": "bitarray", + "sha256": "83bbef1a02c16167e830f27d4f304cffa1559c90acc74caddef50d306d9971fa", + "size": 139645, + "subdir": "linux-64", + "timestamp": 1629132897274, + "version": "2.3.0" + }, + "bitarray-2.3.0-py39h7f8727e_1.tar.bz2": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "db08d3a538482b28428147976c018765", + "name": "bitarray", + "sha256": "b0502d0aa36200d9ae087fb4c1022fdf8e11fd75640c9faf6e3f9f95acdbc62b", + "size": 139304, + "subdir": "linux-64", + "timestamp": 1629132900346, + "version": "2.3.0" + }, + "bitarray-2.3.5-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "14fb95d65850a5a3389785babbd07fe6", + "name": "bitarray", + "sha256": "7c5560a21fa180a7c591de8e1ff8471081c8e74af19f07fb465a06dd94360767", + "size": 148005, + "subdir": "linux-64", + "timestamp": 1641817300354, + "version": "2.3.5" + }, + "bitarray-2.3.5-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "4cda165f70e6bfa1b8c82eeffe98a151", + "name": "bitarray", + "sha256": "f15423e04f008ce1d7734b54645be776b8feedca4546bcde406976c9bc83872e", + "size": 147918, + "subdir": "linux-64", + "timestamp": 1641817297225, + "version": "2.3.5" + }, + "bitarray-2.3.5-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "d2d49b3c767070f53076152e847bf61e", + "name": "bitarray", + "sha256": "29e73cb94c9931085f0e127c58935b0c4d6a75b48784b43d951a340edf3815d1", + "size": 148255, + "subdir": "linux-64", + "timestamp": 1641817297272, + "version": "2.3.5" + }, + "bitarray-2.4.1-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "7fd4bb2df2eac3d79456fdc633ab6d61", + "name": "bitarray", + "sha256": "7fb5daf4d45cf1ce9c1baf31dd0b9950cefa065a4dc45f605118633ea0588dcb", + "size": 230240, + "subdir": "linux-64", + "timestamp": 1648721688428, + "version": "2.4.1" + }, + "bitarray-2.4.1-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "4afa638174e3a148175d7047124b21fe", + "name": "bitarray", + "sha256": "4e7600774fb2be13d7f095d7eaf0ccf0696b47e463d0c5e414bd3f8f2bdb8605", + "size": 149981, + "subdir": "linux-64", + "timestamp": 1648739544627, + "version": "2.4.1" + }, + "bitarray-2.4.1-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "2633191a7dab265e15b86f32f8625aeb", + "name": "bitarray", + "sha256": "bb0d666ca8808dd37efe2a1aa0f41c34c112404c23919fee757fa07c09f2f359", + "size": 150027, + "subdir": "linux-64", + "timestamp": 1648739540078, + "version": "2.4.1" + }, + "bitarray-2.4.1-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "9b8b698373e34c0e32b43d317bc9dbb7", + "name": "bitarray", + "sha256": "415ca5b6b376ae6eb2ce685ef15a639f37631bc164cd325d1863d8efeec3a455", + "size": 150272, + "subdir": "linux-64", + "timestamp": 1648739529000, + "version": "2.4.1" + }, + "bitarray-2.5.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "289107180576d77ab3044ad7814d7baf", + "name": "bitarray", + "sha256": "8f686f47f4df7c811b44dbbd110305966d63ee69a6723c9e9336a8b64e604520", + "size": 235418, + "subdir": "linux-64", + "timestamp": 1652189573686, + "version": "2.5.0" + }, + "bitarray-2.5.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "e22eb53dc0c2caeb8dffa7c78fe46645", + "name": "bitarray", + "sha256": "b5e22dca16e45cf335b0ad434c1db0e35a708a03ff43d4cf81096db7a2598ce1", + "size": 196356, + "subdir": "linux-64", + "timestamp": 1676839113633, + "version": "2.5.0" + }, + "bitarray-2.5.0-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "9c24be83dbd3ebd3a3e1c80d5d14c225", + "name": "bitarray", + "sha256": "c457967dff4aca4fa1151a61c97fe96fe242194bf281a28fb89e87047e181701", + "size": 153349, + "subdir": "linux-64", + "timestamp": 1652189503604, + "version": "2.5.0" + }, + "bitarray-2.5.0-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "9c2920c470e5f2ee163f9bf6d4d7877d", + "name": "bitarray", + "sha256": "c5bf518a94eef048e152021b895e7b90540cb1a794b213766e01e0e134bdce48", + "size": 153258, + "subdir": "linux-64", + "timestamp": 1652189602283, + "version": "2.5.0" + }, + "bitarray-2.5.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "8230193d32ae1d18186d6c3e8a9baf7d", + "name": "bitarray", + "sha256": "bad73e72990fbdcfe6174add6710048da5240ff3d99e4bf6b3c7f6132c6471d4", + "size": 153271, + "subdir": "linux-64", + "timestamp": 1652189533560, + "version": "2.5.0" + }, + "bitarray-2.5.1-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "cfe2ddf5bf2574f7cf80fba2036c66ab", + "name": "bitarray", + "sha256": "12f1c19d55dd1aa0b00a3d893fef5b55675ed815e93df5f11db3d857f73f7667", + "size": 246024, + "subdir": "linux-64", + "timestamp": 1657739768652, + "version": "2.5.1" + }, + "bitarray-2.5.1-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "e1a3f4b99590f706a19408f8991d0f29", + "name": "bitarray", + "sha256": "868246aa25baa8db6ea9fc3d7630d153bee23149c7acb6b87288fcb40c9c7d65", + "size": 196457, + "subdir": "linux-64", + "timestamp": 1679335431387, + "version": "2.5.1" + }, + "bitarray-2.5.1-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "bf2e052b4d4f6ce1867c11346b27f410", + "name": "bitarray", + "sha256": "49a565f9872933fb17ddec369b458282ea901c9b494550836cdc87c44ad70436", + "size": 154150, + "subdir": "linux-64", + "timestamp": 1657739799825, + "version": "2.5.1" + }, + "bitarray-2.5.1-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "8a212da5af78bc170648b1d168f2c088", + "name": "bitarray", + "sha256": "3fd7f6fd340f132e790472fd1bb30b789efe19df1d05bc6aa1388ad0cb0f02f4", + "size": 153629, + "subdir": "linux-64", + "timestamp": 1657739695140, + "version": "2.5.1" + }, + "bitarray-2.5.1-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "ac09a2458c8e407a65ae32aa4afb3a10", + "name": "bitarray", + "sha256": "86a78f79291d64441f6b621e0d65013fae77723ff863ef17d5634bc1c3915852", + "size": 154053, + "subdir": "linux-64", + "timestamp": 1657739725939, + "version": "2.5.1" + }, + "bkcharts-0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=2.7,<2.8.0a0", + "six >=1.5.2" + ], + "license": "BSD 3-Clause", + "md5": "ad5b46c2780299221282bfffb43f9f6f", + "name": "bkcharts", + "sha256": "e0a12677e5513849954e9887869c068bef99da2f28455f775d49c26b4a06e597", + "size": 127235, + "subdir": "linux-64", + "timestamp": 1530770924680, + "version": "0.2" + }, + "bkcharts-0.2-py27h241ae91_0.tar.bz2": { + "build": "py27h241ae91_0", + "build_number": 0, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=2.7,<2.8.0a0", + "six >=1.5.2" + ], + "license": "BSD 3-Clause", + "md5": "48958668161a71b18ad1c5fdef90de0b", + "name": "bkcharts", + "sha256": "121afa1f4c73576435b927bd190664a12fa4b19a6e6f935ed688c79159098bbf", + "size": 126864, + "subdir": "linux-64", + "timestamp": 1505728747105, + "version": "0.2" + }, + "bkcharts-0.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.10,<3.11.0a0", + "six >=1.5.2" + ], + "license": "BSD 3-Clause", + "md5": "ec18c4275fe936b2c270cc0d814586d4", + "name": "bkcharts", + "sha256": "b496156aaf1488288bf9209bd93294977d0ead7a0026c8c24697e6f92efa6249", + "size": 131792, + "subdir": "linux-64", + "timestamp": 1640788516837, + "version": "0.2" + }, + "bkcharts-0.2-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.10,<3.11.0a0", + "six >=1.5.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8082403fc087bc5efc2eaa4b6d771ceb", + "name": "bkcharts", + "sha256": "a6c339f27b45f7443cabda21e088f9e62c4b9fb94f2e36d816de0244ca6b3bbd", + "size": 131925, + "subdir": "linux-64", + "timestamp": 1657175960644, + "version": "0.2" + }, + "bkcharts-0.2-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.11,<3.12.0a0", + "six >=1.5.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0f21b875869ec36baed67f75d9378c96", + "name": "bkcharts", + "sha256": "a0ba6134d245cac1ae78a0ac2094987eb847f38fc9cfdae0770eccc84fd69db8", + "size": 173103, + "subdir": "linux-64", + "timestamp": 1676847028305, + "version": "0.2" + }, + "bkcharts-0.2-py35he4f7e30_0.tar.bz2": { + "build": "py35he4f7e30_0", + "build_number": 0, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.5,<3.6.0a0", + "six >=1.5.2" + ], + "license": "BSD 3-Clause", + "md5": "c9095dcedb053233a60125f7143e000b", + "name": "bkcharts", + "sha256": "e365a081b2e0fe401d0c6431a2989d38770e71681d0173103c393a7ce58d9cba", + "size": 130864, + "subdir": "linux-64", + "timestamp": 1505728757269, + "version": "0.2" + }, + "bkcharts-0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.6,<3.7.0a0", + "six >=1.5.2" + ], + "license": "BSD 3-Clause", + "md5": "18616142d3f9c5a753fb5b8472386c31", + "name": "bkcharts", + "sha256": "9ee04acad1a26149c4a3c4d6d004a6a4c20d8754582ff359ec4bbe04a6788cb3", + "size": 130177, + "subdir": "linux-64", + "timestamp": 1530770943834, + "version": "0.2" + }, + "bkcharts-0.2-py36h735825a_0.tar.bz2": { + "build": "py36h735825a_0", + "build_number": 0, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.6,<3.7.0a0", + "six >=1.5.2" + ], + "license": "BSD 3-Clause", + "md5": "c885f7e74c6caf3d719349ef611e4d92", + "name": "bkcharts", + "sha256": "587d964699268e1d83ec3a8cdb7efe0570778a609a1b771f607ed14cd63b421d", + "size": 129957, + "subdir": "linux-64", + "timestamp": 1505728767491, + "version": "0.2" + }, + "bkcharts-0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.7,<3.8.0a0", + "six >=1.5.2" + ], + "license": "BSD 3-Clause", + "md5": "7837189bf0ed7fcea2ef265258d0bd76", + "name": "bkcharts", + "sha256": "b0fc0bb924cdc252c343905eb943b5df9d74777aced3f47bce5bc1ce3907fdc9", + "size": 130207, + "subdir": "linux-64", + "timestamp": 1530770907422, + "version": "0.2" + }, + "bkcharts-0.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.7,<3.8.0a0", + "six >=1.5.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "abda6d9dc783033306a1b042c7f172fe", + "name": "bkcharts", + "sha256": "fb9a90dfe80f5dd2310a882809981d3f3e6233655d81eeecbb342244c3184bdc", + "size": 130604, + "subdir": "linux-64", + "timestamp": 1657175881002, + "version": "0.2" + }, + "bkcharts-0.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.8,<3.9.0a0", + "six >=1.5.2" + ], + "license": "BSD 3-Clause", + "md5": "7d21c5db4b4420336c396a702055cd7b", + "name": "bkcharts", + "sha256": "36f07e67addb5e99e6bf735765c7ee1d1cacdcf2afd7ca1aa8a419ff6a1db12b", + "size": 131703, + "subdir": "linux-64", + "timestamp": 1580239165886, + "version": "0.2" + }, + "bkcharts-0.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.8,<3.9.0a0", + "six >=1.5.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e20a4d33e702c4fc72da0aeaedae85e0", + "name": "bkcharts", + "sha256": "132b31f1bf13ed91e48fdb939d59ca8f9a64b69e4d359f48eeffa936330e321c", + "size": 131023, + "subdir": "linux-64", + "timestamp": 1657175841883, + "version": "0.2" + }, + "bkcharts-0.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.9,<3.10.0a0", + "six >=1.5.2" + ], + "license": "BSD 3-Clause", + "md5": "f5d44f1c4304b72d732512bcf419a06b", + "name": "bkcharts", + "sha256": "ea9b722024506316556ac5f2dce9a0e00acb923e3e0a2a9079f4b8f2e896fdc9", + "size": 131462, + "subdir": "linux-64", + "timestamp": 1607709584650, + "version": "0.2" + }, + "bkcharts-0.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.9,<3.10.0a0", + "six >=1.5.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9d0b3728c344b6cddf16688113623db9", + "name": "bkcharts", + "sha256": "da0c8d3338899cdd66c38c632551940819308fe89f2055c334d4ce30ef6e5414", + "size": 130712, + "subdir": "linux-64", + "timestamp": 1657175915809, + "version": "0.2" + }, + "black-22.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "uvloop >=0.15.2", + "colorama >=0.4.3", + "aiohttp >=3.7.4" + ], + "depends": [ + "click >=8.0.0", + "mypy_extensions >=0.4.3", + "pathspec >=0.9.0", + "platformdirs >=2", + "python >=3.10,<3.11.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d6c5b982bab969fe66c7643df9e69213", + "name": "black", + "sha256": "622289532cd01d9ee8a5362f525df1cb890ba0295b9bbb5259732864d66bcfd3", + "size": 229190, + "subdir": "linux-64", + "timestamp": 1660237926739, + "version": "22.6.0" + }, + "black-22.6.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "uvloop >=0.15.2", + "aiohttp >=3.7.4", + "colorama >=0.4.3" + ], + "depends": [ + "click >=8.0.0", + "mypy_extensions >=0.4.3", + "pathspec >=0.9.0", + "platformdirs >=2", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d7471a8bfa68c4d3dd67690f941c992", + "name": "black", + "sha256": "f2699e0d3352e2ede53d4c7bb15f3df6084b3746e21b7a3f331a49d666bf6df6", + "size": 309787, + "subdir": "linux-64", + "timestamp": 1676839128413, + "version": "22.6.0" + }, + "black-22.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "uvloop >=0.15.2", + "colorama >=0.4.3", + "aiohttp >=3.7.4" + ], + "depends": [ + "click >=8.0.0", + "mypy_extensions >=0.4.3", + "pathspec >=0.9.0", + "platformdirs >=2", + "python >=3.7,<3.8.0a0", + "tomli >=1.1.0", + "typed-ast >=1.4.2", + "typing_extensions >=3.10.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0278f0512e17bfaadb3af5d1ff54e4ca", + "name": "black", + "sha256": "f7a9396f64563ecde48810641154f0bfbef6e9f1127dd71d3e62f8b7f6833f72", + "size": 225825, + "subdir": "linux-64", + "timestamp": 1660237881530, + "version": "22.6.0" + }, + "black-22.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "uvloop >=0.15.2", + "colorama >=0.4.3", + "aiohttp >=3.7.4" + ], + "depends": [ + "click >=8.0.0", + "mypy_extensions >=0.4.3", + "pathspec >=0.9.0", + "platformdirs >=2", + "python >=3.8,<3.9.0a0", + "tomli >=1.1.0", + "typing_extensions >=3.10.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f3dff8e132679bec0b70126d3adcd59", + "name": "black", + "sha256": "107a6b5c66e66e3a1988886490d6ef58708fe5cc526daa0dfab60756caf7453d", + "size": 226729, + "subdir": "linux-64", + "timestamp": 1660237849477, + "version": "22.6.0" + }, + "black-22.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "uvloop >=0.15.2", + "colorama >=0.4.3", + "aiohttp >=3.7.4" + ], + "depends": [ + "click >=8.0.0", + "mypy_extensions >=0.4.3", + "pathspec >=0.9.0", + "platformdirs >=2", + "python >=3.9,<3.10.0a0", + "tomli >=1.1.0", + "typing_extensions >=3.10.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ac9f9beaa368e55c247496e535d8d79", + "name": "black", + "sha256": "7fc478133be4b5bd1f7649339ce9fd3a388db0d77dff71dc8f43013b52f03ba4", + "size": 227130, + "subdir": "linux-64", + "timestamp": 1660237961998, + "version": "22.6.0" + }, + "black-23.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "aiohttp >=3.7.4", + "colorama >=0.4.3", + "uvloop >=0.15.2" + ], + "depends": [ + "click >=8.0.0", + "mypy_extensions >=0.4.3", + "packaging >=22.0", + "pathspec >=0.9.0", + "platformdirs >=2", + "python >=3.10,<3.11.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ceb354dd5cc6c902913ea43ff8d009d0", + "name": "black", + "sha256": "44c769ac7fd946289568ca64070472ba6a1bdf6ed283ed7fd6ba9cd98f648126", + "size": 247468, + "subdir": "linux-64", + "timestamp": 1680737285835, + "version": "23.3.0" + }, + "black-23.3.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "aiohttp >=3.7.4", + "colorama >=0.4.3", + "uvloop >=0.15.2" + ], + "depends": [ + "click >=8.0.0", + "mypy_extensions >=0.4.3", + "packaging >=22.0", + "pathspec >=0.9.0", + "platformdirs >=2", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7bf6abfad7b629b3c0726ee9c9e6fce6", + "name": "black", + "sha256": "883ee11be2c59dbb63943c57b9d6d2b97488cae6a76335a3ff8434c803bb40f8", + "size": 332586, + "subdir": "linux-64", + "timestamp": 1680737314559, + "version": "23.3.0" + }, + "black-23.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "aiohttp >=3.7.4", + "colorama >=0.4.3", + "uvloop >=0.15.2" + ], + "depends": [ + "click >=8.0.0", + "mypy_extensions >=0.4.3", + "packaging >=22.0", + "pathspec >=0.9.0", + "platformdirs >=2", + "python >=3.8,<3.9.0a0", + "tomli >=1.1.0", + "typing_extensions >=3.10.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b270068394646df06b02a5917e9048f", + "name": "black", + "sha256": "824c9d3715f22f4419d78dfe49d28bbab8948c816d354007a1a6ec16fa77cdce", + "size": 244301, + "subdir": "linux-64", + "timestamp": 1680737370804, + "version": "23.3.0" + }, + "black-23.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "aiohttp >=3.7.4", + "colorama >=0.4.3", + "uvloop >=0.15.2" + ], + "depends": [ + "click >=8.0.0", + "mypy_extensions >=0.4.3", + "packaging >=22.0", + "pathspec >=0.9.0", + "platformdirs >=2", + "python >=3.9,<3.10.0a0", + "tomli >=1.1.0", + "typing_extensions >=3.10.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "726db33d8a8679b3303eb8e0daca96ec", + "name": "black", + "sha256": "901cf93fbe79bd30c077317be9a27ddf400f2e980de849aef8fa3327764738a3", + "size": 244758, + "subdir": "linux-64", + "timestamp": 1680737342173, + "version": "23.3.0" + }, + "blas-1.0-mkl.tar.bz2": { + "build": "mkl", + "build_number": 1, + "depends": [], + "md5": "751c2c5b239a728db05f91374aaac3a1", + "name": "blas", + "sha256": "122379250785e89e0f47bad413928341643360563eb95fde4767c45262939f36", + "size": 5838, + "subdir": "linux-64", + "timestamp": 1528122042945, + "version": "1.0" + }, + "blas-1.0-openblas.tar.bz2": { + "build": "openblas", + "build_number": 7, + "depends": [], + "md5": "671f6e045d03a842f379145e7fc43c0d", + "name": "blas", + "sha256": "ed246aa0bf2809030f911cefd5b16a2c4de0d1b21f75f76e5178122d2213727e", + "size": 49374, + "subdir": "linux-64", + "timestamp": 1528224118045, + "track_features": "nomkl", + "version": "1.0" + }, + "blaze-0.11.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "cytoolz", + "dask", + "datashape >=0.5.3", + "flask >=0.10.1", + "flask-cors", + "h5py", + "numba", + "odo >=0.5.0", + "psutil", + "pytables >=3.0.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "requests", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "670b9cd247132f553bce9f37fd1fb35e", + "name": "blaze", + "sha256": "450b1314286e6f2a876cc3ddb5eb4f2a3b17a92d1ce34199ff8e1f0eda92168c", + "size": 618359, + "subdir": "linux-64", + "timestamp": 1530780942896, + "version": "0.11.3" + }, + "blaze-0.11.3-py27h5f341da_0.tar.bz2": { + "build": "py27h5f341da_0", + "build_number": 0, + "depends": [ + "contextlib2", + "cytoolz", + "dask", + "datashape >=0.5.3", + "flask >=0.10.1", + "flask-cors", + "h5py", + "numba", + "odo >=0.5.0", + "psutil", + "pytables >=3.0.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "requests", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b5e4a2d2c94377c197a0bfce6cfe8643", + "name": "blaze", + "sha256": "42cacd22d41b25423acd4fad0bd91891f5886d972b03bf6c1676ce77d287ad86", + "size": 619558, + "subdir": "linux-64", + "timestamp": 1505740501448, + "version": "0.11.3" + }, + "blaze-0.11.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cytoolz", + "dask", + "datashape >=0.5.3", + "flask >=0.10.1", + "flask-cors", + "h5py", + "numba", + "odo >=0.5.0", + "psutil", + "pytables >=3.0.0", + "python >=3.5,<3.6.0a0", + "pyyaml", + "requests", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "103cb3d0b53fc0181a4369e73fa02f31", + "name": "blaze", + "sha256": "4edc72fdf34a103502906e9caf83ad40a4d2a9fe52a6dbe8c1d849771be425df", + "size": 625690, + "subdir": "linux-64", + "timestamp": 1534899847824, + "version": "0.11.3" + }, + "blaze-0.11.3-py35ha2c9137_0.tar.bz2": { + "build": "py35ha2c9137_0", + "build_number": 0, + "depends": [ + "cytoolz", + "dask", + "datashape >=0.5.3", + "flask >=0.10.1", + "flask-cors", + "h5py", + "numba", + "odo >=0.5.0", + "psutil", + "pytables >=3.0.0", + "python >=3.5,<3.6.0a0", + "pyyaml", + "requests", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "86770fee9f68168e07ed8d51e1c1966f", + "name": "blaze", + "sha256": "8f5b53dc756db4137069ebcabdd16e8ee258db011e002d8f3ca474bb2eab67ea", + "size": 626226, + "subdir": "linux-64", + "timestamp": 1505740543559, + "version": "0.11.3" + }, + "blaze-0.11.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cytoolz", + "dask", + "datashape >=0.5.3", + "flask >=0.10.1", + "flask-cors", + "h5py", + "numba", + "odo >=0.5.0", + "psutil", + "pytables >=3.0.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "requests", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5f23eaade17f6d45fba1a217fbab0368", + "name": "blaze", + "sha256": "a6524836098721cc12ceaa436b9f0002c54709bc88e62c4b728e6cb9975b9b42", + "size": 617249, + "subdir": "linux-64", + "timestamp": 1530781003590, + "version": "0.11.3" + }, + "blaze-0.11.3-py36h4e06776_0.tar.bz2": { + "build": "py36h4e06776_0", + "build_number": 0, + "depends": [ + "cytoolz", + "dask", + "datashape >=0.5.3", + "flask >=0.10.1", + "flask-cors", + "h5py", + "numba", + "odo >=0.5.0", + "psutil", + "pytables >=3.0.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "requests", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b511b378b27105761186be1b3f7eb8b7", + "name": "blaze", + "sha256": "8eb1dda4e388619d3c6455aeaafafd75684d07c54d51315a320fbd39e77ea7c7", + "size": 619609, + "subdir": "linux-64", + "timestamp": 1505740585432, + "version": "0.11.3" + }, + "blaze-0.11.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cytoolz", + "dask", + "datashape >=0.5.3", + "flask >=0.10.1", + "flask-cors", + "h5py", + "numba", + "odo >=0.5.0", + "psutil", + "pytables >=3.0.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "requests", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ae16ef82ae0c8393e6bdf3e687f02345", + "name": "blaze", + "sha256": "3ab3bb1315775b80a7cf24d841cd255e2abab683d1368808e7f160b077a34c04", + "size": 615389, + "subdir": "linux-64", + "timestamp": 1530781054271, + "version": "0.11.3" + }, + "bleach-2.0.0-py27h3a0dcc8_0.tar.bz2": { + "build": "py27h3a0dcc8_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bcf1921db4e440ce55d51bd85538f33d", + "name": "bleach", + "sha256": "1d1610a22ccea71e030eda8bea5adb5900d997306c74c40724bca6decfe6b90c", + "size": 26662, + "subdir": "linux-64", + "timestamp": 1505688758599, + "version": "2.0.0" + }, + "bleach-2.0.0-py35h055c768_0.tar.bz2": { + "build": "py35h055c768_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5ff6ac351bd1096d4390c645909253e6", + "name": "bleach", + "sha256": "4133a0e31d15f6834c57a8485cfcf654e27bd7240bd405d016ab0b7999772306", + "size": 27088, + "subdir": "linux-64", + "timestamp": 1505688771064, + "version": "2.0.0" + }, + "bleach-2.0.0-py36h688b259_0.tar.bz2": { + "build": "py36h688b259_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3082cb3d5250cc06696e1f4edbb1d79f", + "name": "bleach", + "sha256": "4e3a700ed8ed03246280e8540d04d0679f11b8fd0d30be8a6ae271e4e6186af3", + "size": 27071, + "subdir": "linux-64", + "timestamp": 1505688783589, + "version": "2.0.0" + }, + "bleach-2.1.1-py27h655ea9b_0.tar.bz2": { + "build": "py27h655ea9b_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dd2e4b503543351558abfc4d3d23a149", + "name": "bleach", + "sha256": "76d600be583ceea08f0c3caeac8eb3bca350f7c2396de3fe07c33697285cb143", + "size": 31543, + "subdir": "linux-64", + "timestamp": 1512064528809, + "version": "2.1.1" + }, + "bleach-2.1.1-py35hd5e75dd_0.tar.bz2": { + "build": "py35hd5e75dd_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "59cd340b8bb45e578bb7eb0b08a80798", + "name": "bleach", + "sha256": "0aa7b2dd20f484161a4ae3728d1b48bb3b071dcf284014655c133786718fd0d4", + "size": 32033, + "subdir": "linux-64", + "timestamp": 1512064565029, + "version": "2.1.1" + }, + "bleach-2.1.1-py36hd521086_0.tar.bz2": { + "build": "py36hd521086_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9891412e2dc88001430f723c09cfafed", + "name": "bleach", + "sha256": "f755dadafa55d09b184851d14e8fd56b69ecc36576959d56ccb01fc13717980c", + "size": 31976, + "subdir": "linux-64", + "timestamp": 1512064564671, + "version": "2.1.1" + }, + "bleach-2.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e7fb69a3f629c6f271e79e37b6430830", + "name": "bleach", + "sha256": "ac42577f4386f976527fd30db52d086ed250c04fa209eceac11714bacbcf81c5", + "size": 31868, + "subdir": "linux-64", + "timestamp": 1515702634158, + "version": "2.1.2" + }, + "bleach-2.1.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cda9e6b39cd0d3f509ac76e3a37b4900", + "name": "bleach", + "sha256": "01c144818bc4204dabb6c443aaa863a2e057fd3fe174dd22df9652dd813470f2", + "size": 32259, + "subdir": "linux-64", + "timestamp": 1515702673828, + "version": "2.1.2" + }, + "bleach-2.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "74f63cfa6717d2e2d21bea0ce4600dd4", + "name": "bleach", + "sha256": "b204822709c1187657ff441e53c29134c3a441380a55117546dbb36762ef8913", + "size": 32232, + "subdir": "linux-64", + "timestamp": 1515702495118, + "version": "2.1.2" + }, + "bleach-2.1.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cd67aa07be3397a8e2c0e0129b1c6eb4", + "name": "bleach", + "sha256": "5e5c6d51e694359cf3873ac025351481c7e5989d841619e85fd82be2310753e1", + "size": 33007, + "subdir": "linux-64", + "timestamp": 1520367410667, + "version": "2.1.3" + }, + "bleach-2.1.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0e52382e0bd4c04908d81a087fb276fa", + "name": "bleach", + "sha256": "5dfc5d4b0e8ca6376a311390521ef50104d2a05f91f391cad483ad1d817cf1cd", + "size": 33446, + "subdir": "linux-64", + "timestamp": 1520367417266, + "version": "2.1.3" + }, + "bleach-2.1.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "59a1d21189827b2f8b5d5645c732dc65", + "name": "bleach", + "sha256": "85d74cb4c84e585730b50c651b250d146b165dc1705ef362c3d166438b5b05dc", + "size": 33357, + "subdir": "linux-64", + "timestamp": 1520367429044, + "version": "2.1.3" + }, + "bleach-2.1.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6bef652f3882144a13943567dd897157", + "name": "bleach", + "sha256": "0a7bbaaf9fe503228b736c70382004a1ce7f0644266451b1cf00548cac6e8d5b", + "size": 33407, + "subdir": "linux-64", + "timestamp": 1530734219576, + "version": "2.1.3" + }, + "bleach-2.1.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999pre,!=1.0b1,!=1.0b2,!=1.0b3,!=1.0b4,!=1.0b5,!=1.0b6,!=1.0b7,!=1.0b8", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8ab7a6210ee45691f5c7458a64fbb28e", + "name": "bleach", + "sha256": "cc4200542a7e5e330c171530903897fd876d0896f4c3fe9ff5c219d1d977bc66", + "size": 33414, + "subdir": "linux-64", + "timestamp": 1534944575286, + "version": "2.1.4" + }, + "bleach-2.1.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999pre,!=1.0b1,!=1.0b2,!=1.0b3,!=1.0b4,!=1.0b5,!=1.0b6,!=1.0b7,!=1.0b8", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a384376bbd922518935ba48abe06cda3", + "name": "bleach", + "sha256": "5c7c98391d4029aacfaa98a12f9c2283bda091ceeca69d05c9da2092d5999c48", + "size": 33818, + "subdir": "linux-64", + "timestamp": 1534944645634, + "version": "2.1.4" + }, + "bleach-2.1.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999pre,!=1.0b1,!=1.0b2,!=1.0b3,!=1.0b4,!=1.0b5,!=1.0b6,!=1.0b7,!=1.0b8", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7801dc6acd1ba2f1c7c460cfc0f925a3", + "name": "bleach", + "sha256": "4664992307f2dbe74fb3ed2e8129e49fe4fa6a6487fb9e7290689225843a096a", + "size": 33795, + "subdir": "linux-64", + "timestamp": 1534944493180, + "version": "2.1.4" + }, + "bleach-2.1.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999pre,!=1.0b1,!=1.0b2,!=1.0b3,!=1.0b4,!=1.0b5,!=1.0b6,!=1.0b7,!=1.0b8", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2b3d90530384dc563deef1e460c17d7c", + "name": "bleach", + "sha256": "55c8bab8a0a54fca3d5584b6f633e9d000dbbfecca33eb47709ba4c529d3dd7d", + "size": 33847, + "subdir": "linux-64", + "timestamp": 1534944606658, + "version": "2.1.4" + }, + "bleach-3.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "webencodings" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "535285bff52d0743f9e1645bb266dc81", + "name": "bleach", + "sha256": "31012f7dd6117aa5626e404a6f55cfc3b315cfe5f22f1056c28ff39070288f95", + "size": 228251, + "subdir": "linux-64", + "timestamp": 1539024426445, + "version": "3.0.0" + }, + "bleach-3.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "webencodings" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f76d57cedec68969a81bf5e170290594", + "name": "bleach", + "sha256": "9e947cfa463f86a1f2435536f26db2f188a8059adb2dcc2d0cf1cc83999c5be6", + "size": 224844, + "subdir": "linux-64", + "timestamp": 1539024442724, + "version": "3.0.0" + }, + "bleach-3.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "webencodings" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1d67da18a5bf7663b89355b30f70a516", + "name": "bleach", + "sha256": "c7c7e049dfb72abfc2fa9086b793cc4f2ef3bdd8fdc8d63eec4bf9a9ad267ff8", + "size": 223044, + "subdir": "linux-64", + "timestamp": 1539024401251, + "version": "3.0.0" + }, + "bleach-3.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "webencodings" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a4815e237f1072dd0bcb7a46c859aa30", + "name": "bleach", + "sha256": "14edb08eded9ed551e35a4f931309e26f4a316fa12732c5ff18007bcc11637f3", + "size": 228515, + "subdir": "linux-64", + "timestamp": 1539468266778, + "version": "3.0.2" + }, + "bleach-3.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "webencodings" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "55d12cb37d1908ffd84d3945a97ee992", + "name": "bleach", + "sha256": "5efe91eb2f50e6abc0871d075c4e81e893507b0e75ada3f192fcefd13ea5d9c0", + "size": 225267, + "subdir": "linux-64", + "timestamp": 1539468301368, + "version": "3.0.2" + }, + "bleach-3.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "webencodings" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7f76e9425b2a8729044eafac473a4d8a", + "name": "bleach", + "sha256": "0c989947385ab3f221646875b7f3d1e7ac3ab94c61e14d41499b123bcdb6d2df", + "size": 223758, + "subdir": "linux-64", + "timestamp": 1539468289948, + "version": "3.0.2" + }, + "bleach-3.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "webencodings" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d1894309078b535db9b87942340fee60", + "name": "bleach", + "sha256": "ac70123dec3c7d605618c5ba2ba76a441218378dc2d8795b1c80bf43f9ecc955", + "size": 233667, + "subdir": "linux-64", + "timestamp": 1547747374249, + "version": "3.1.0" + }, + "bleach-3.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "webencodings" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d403fd05df006df7b2d95b94c301e3b2", + "name": "bleach", + "sha256": "6cb4017f16bb290638a58367f080b2264fb427df5bc53dbe26d028d6702a2dec", + "size": 231934, + "subdir": "linux-64", + "timestamp": 1547747468102, + "version": "3.1.0" + }, + "bleach-3.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "webencodings" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0722a8b94fbd9ce3ffb276c1f0fbff99", + "name": "bleach", + "sha256": "b365ba0de2b4df36a2a03633d13c0ce4f2252daff4481c956bffdf8a41df6c13", + "size": 229963, + "subdir": "linux-64", + "timestamp": 1547747439520, + "version": "3.1.0" + }, + "blessings-1.7-py310h06a4308_1002.tar.bz2": { + "build": "py310h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d504877771e0fe61c011610978d7c68", + "name": "blessings", + "sha256": "3122b7e4503fba4693ff04bf718b83398ffa27303a936d1cfdff606db51eafb9", + "size": 28716, + "subdir": "linux-64", + "timestamp": 1640788534345, + "version": "1.7" + }, + "blessings-1.7-py311h06a4308_1002.tar.bz2": { + "build": "py311h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6559de4963f981032a0e033db84eb00c", + "name": "blessings", + "sha256": "000d8859bec63c8d5f8399f84cb8d04f2e59eec63ee68bbd5af8196afee9d5f0", + "size": 33720, + "subdir": "linux-64", + "timestamp": 1676839144008, + "version": "1.7" + }, + "blessings-1.7-py36_1002.tar.bz2": { + "build": "py36_1002", + "build_number": 1002, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e7e3d6259d3a1f667cae67622fd255e", + "name": "blessings", + "sha256": "d2da04cc953df8012e8d1eb09b517dc197f475eb77aa34194c4c9fe95921c4f6", + "size": 30579, + "subdir": "linux-64", + "timestamp": 1598661766747, + "version": "1.7" + }, + "blessings-1.7-py36h06a4308_1002.tar.bz2": { + "build": "py36h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b96dac91a4ae57a09741f31a3e0c695", + "name": "blessings", + "sha256": "6058aa62725a08395e1a8a91d6f30d6afa1a33c6d9f2e724a1eb2747600b6690", + "size": 30626, + "subdir": "linux-64", + "timestamp": 1614076480860, + "version": "1.7" + }, + "blessings-1.7-py37_1002.tar.bz2": { + "build": "py37_1002", + "build_number": 1002, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d2e5767dc75f8ad463a0e79b31d6b77", + "name": "blessings", + "sha256": "eccfb4258b33282f35ca77b47b8bc4eeb2c93114988c8ecf3f5f2bb8cb328cbf", + "size": 30622, + "subdir": "linux-64", + "timestamp": 1598661743793, + "version": "1.7" + }, + "blessings-1.7-py37h06a4308_1002.tar.bz2": { + "build": "py37h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc8ff4ddbac7d744876494b19d388eb4", + "name": "blessings", + "sha256": "af2634a2f0020b1bd41a2824b6010c692a80a298a94eb57fa96fc671ffe8da41", + "size": 30676, + "subdir": "linux-64", + "timestamp": 1614076478572, + "version": "1.7" + }, + "blessings-1.7-py38_1002.tar.bz2": { + "build": "py38_1002", + "build_number": 1002, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4d5fd2c85344c0ffcb0efad4ef97297", + "name": "blessings", + "sha256": "64756aaa5840cdb739f558f4a5aec1607d7e3ec7308c9972a894b5f9cf1213f8", + "size": 30698, + "subdir": "linux-64", + "timestamp": 1598661799634, + "version": "1.7" + }, + "blessings-1.7-py38h06a4308_1002.tar.bz2": { + "build": "py38h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "65cfbe6dd28820606e710878c9786869", + "name": "blessings", + "sha256": "a092e43fea9a4680b6d8e78df3d531f19dea15ec98ef81837eee7eafe4f8a090", + "size": 30737, + "subdir": "linux-64", + "timestamp": 1614076475848, + "version": "1.7" + }, + "blessings-1.7-py39h06a4308_1002.tar.bz2": { + "build": "py39h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "996fd6bca5a631472d762d29a3348f38", + "name": "blessings", + "sha256": "b5ee00da6edc1469ce3f7023c3f785d6f604fff4cdb9496fc84d805e8cc8797c", + "size": 30818, + "subdir": "linux-64", + "timestamp": 1614075542803, + "version": "1.7" + }, + "blinker-1.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c39a6b7ba54eebba3a26bc907def736c", + "name": "blinker", + "sha256": "bbd9835511a951edf19e7375b3968ff074d646e14c44793415fd61908d02a726", + "size": 21030, + "subdir": "linux-64", + "timestamp": 1525813093679, + "version": "1.4" + }, + "blinker-1.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "94d142a20a157a816ec9f0bf58f22a29", + "name": "blinker", + "sha256": "f274b3833613c443ab9cd8b789ef1d80cf3e94602b5fc771f5ead40e60072668", + "size": 21793, + "subdir": "linux-64", + "timestamp": 1640788551724, + "version": "1.4" + }, + "blinker-1.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "b5ea9e5ec2c51f5fd0aaa3b2a9d6df8e", + "name": "blinker", + "sha256": "d3721267ec2f9b49f68ee876afc1d6722dc84d5bd405ab7c5abccd9047d966f4", + "size": 26844, + "subdir": "linux-64", + "timestamp": 1676830022360, + "version": "1.4" + }, + "blinker-1.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "53a968d26cfd8137ee2641e9b8c1794c", + "name": "blinker", + "sha256": "8db118805b1898849ab2a5579b8c1050e5457c86c05a9ec147e2a45fd54ee2e4", + "size": 21523, + "subdir": "linux-64", + "timestamp": 1525813132877, + "version": "1.4" + }, + "blinker-1.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4c8f105e980fc40d4e192d5d324a6730", + "name": "blinker", + "sha256": "9a3c0232cf4492ba6361e6f281f22e3eedf1529656b96a22518b0dfb35a4e028", + "size": 21444, + "subdir": "linux-64", + "timestamp": 1525813135425, + "version": "1.4" + }, + "blinker-1.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "962afaa02ff1a4f38a80bd69fbbd3e60", + "name": "blinker", + "sha256": "b2ceecc5626c4a07f14f0e1d9ffb22968a4cde5e80254475a9b479b2226211c1", + "size": 23088, + "subdir": "linux-64", + "timestamp": 1611676518660, + "version": "1.4" + }, + "blinker-1.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "24b0467187358cab2d780032b6ce84d6", + "name": "blinker", + "sha256": "6b1adbf47c64d4d765cefc5a3e3cbe332296c97cbc54d9a62ab691ca695bd848", + "size": 21642, + "subdir": "linux-64", + "timestamp": 1545089085448, + "version": "1.4" + }, + "blinker-1.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4d814d44822081d1181eaf5db3b92f74", + "name": "blinker", + "sha256": "b07e26f6dbe55bdf9bd5b671815393b5a4eb0c5344600da86c351e13903bea8e", + "size": 23150, + "subdir": "linux-64", + "timestamp": 1611676540031, + "version": "1.4" + }, + "blinker-1.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "fc7af2dfce4f8ce9689f7e7d7fff2239", + "name": "blinker", + "sha256": "af7570214285d720327ff116bc4782adcb3423433b57da6906352c1082a11cc1", + "size": 21861, + "subdir": "linux-64", + "timestamp": 1572609087727, + "version": "1.4" + }, + "blinker-1.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "fa7270668da9addbd5c22b6073f5cfc0", + "name": "blinker", + "sha256": "aa2f46b09dbb4a55cad224dcd541e7f37f29463024580a8dbba5f455ee385c3c", + "size": 23186, + "subdir": "linux-64", + "timestamp": 1611676524575, + "version": "1.4" + }, + "blinker-1.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "901c753cee59d88107c394ce07afc0cf", + "name": "blinker", + "sha256": "6b08ee14b7a7de63a6c84f3745c8d7f749b750d4d3276f3280ddf565ced8deed", + "size": 23170, + "subdir": "linux-64", + "timestamp": 1611676456194, + "version": "1.4" + }, + "blist-1.3.6-py27h7b6447c_1.tar.bz2": { + "build": "py27h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "936ec837cdfc848fdd62cf55971d5c69", + "name": "blist", + "sha256": "14d72bc1ee6f41612e6c2de9740276e69e229bdc0a60e4bbaaaa86b3694e8dbf", + "size": 62330, + "subdir": "linux-64", + "timestamp": 1537205236613, + "version": "1.3.6" + }, + "blist-1.3.6-py35h7b6447c_1.tar.bz2": { + "build": "py35h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6cef627064489a98db4afa30eb5ad8c7", + "name": "blist", + "sha256": "cde47b04cb9d7b9a05557d1bb2847f20c71a1e782edd8e081812e65d2d105910", + "size": 61823, + "subdir": "linux-64", + "timestamp": 1537205253760, + "version": "1.3.6" + }, + "blist-1.3.6-py36h27cfd23_2.tar.bz2": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0c5397aca99468cf65a51aff1556e50c", + "name": "blist", + "sha256": "80b6d5138f5e237f28545a71df42c3ef33e287cc8744642699ce9f72f333e6f2", + "size": 148524, + "subdir": "linux-64", + "timestamp": 1613399583575, + "version": "1.3.6" + }, + "blist-1.3.6-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b393fbc674c658ce8266b652b12541d2", + "name": "blist", + "sha256": "aac894eafa21f22832936c42dab9748e23ea5396383670d11b78a43f00a49e1a", + "size": 61656, + "subdir": "linux-64", + "timestamp": 1537205271004, + "version": "1.3.6" + }, + "blist-1.3.6-py37h27cfd23_2.tar.bz2": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5dfe13faee30ae1ccd36b4ec6b80cc5b", + "name": "blist", + "sha256": "176de8130db49909f4734fb870b5b394a08b755c72105c9054a6314db3a5df1a", + "size": 148062, + "subdir": "linux-64", + "timestamp": 1613398923726, + "version": "1.3.6" + }, + "blist-1.3.6-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "aab277fe6da3c4ae67274e5841031f3f", + "name": "blist", + "sha256": "1861dfcff49835287b60544bad92ba8c58142390f19e691f1de7c312a2baaca3", + "size": 61745, + "subdir": "linux-64", + "timestamp": 1537205210130, + "version": "1.3.6" + }, + "blist-1.3.6-py38h27cfd23_2.tar.bz2": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "040ed96f49cbc4bf5c686397f5680896", + "name": "blist", + "sha256": "29991708d9366be846033bfe6abf771b96096602ae091cf7bdb0506145f2b7c5", + "size": 148860, + "subdir": "linux-64", + "timestamp": 1613399594675, + "version": "1.3.6" + }, + "blist-1.3.6-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f783d2c916b39129bd409ccff4c18591", + "name": "blist", + "sha256": "8ed3bcf9efd83f4fcbab1ee80b3643e0908f78ca9d3b554bd185c2d00966e9d0", + "size": 69906, + "subdir": "linux-64", + "timestamp": 1572357260435, + "version": "1.3.6" + }, + "blist-1.3.6-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "71c1f4a11969ab268761e94e34412165", + "name": "blist", + "sha256": "2cdc10a304df4f5a5ee71a4e1d50123bf69871b6374f008325682bd7dd36d6bc", + "size": 62874, + "subdir": "linux-64", + "timestamp": 1607007519916, + "version": "1.3.6" + }, + "blist-1.3.6-py39h27cfd23_2.tar.bz2": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fe100784f5b97f51020ab5f8c6db4cac", + "name": "blist", + "sha256": "b21f56fddaaa66e385c21ffa81433a58721ab77e83d0fff0ba1148bcdcb89927", + "size": 148471, + "subdir": "linux-64", + "timestamp": 1613399584437, + "version": "1.3.6" + }, + "blosc-1.12.0-ha156899_0.tar.bz2": { + "build": "ha156899_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ec58a0febf98eaba7226ea5cf743b864", + "name": "blosc", + "sha256": "d7208ff2867b621121599788a93f02852eb8cd9b4797bee7ecfef9b284105c9c", + "size": 239516, + "subdir": "linux-64", + "timestamp": 1511806287973, + "version": "1.12.0" + }, + "blosc-1.12.0-he42ba99_0.tar.bz2": { + "build": "he42ba99_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "snappy", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "56a039136d6c52e41a2674d26ac3b7e5", + "name": "blosc", + "sha256": "5549f76a722e9b344a280a5afdd05043b048e37f7a018ee7aea4a51d4ad48b9a", + "size": 567467, + "subdir": "linux-64", + "timestamp": 1505740856997, + "version": "1.12.0" + }, + "blosc-1.14.0-hdbcaa40_0.tar.bz2": { + "build": "hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bf28e0fecc164da3941401cecaa657bd", + "name": "blosc", + "sha256": "36df244535e9a6ff3d2418e5e0e2e4fcaaf1097022c76b13b62ee2a4050cd3b5", + "size": 541414, + "subdir": "linux-64", + "timestamp": 1522427056054, + "version": "1.14.0" + }, + "blosc-1.14.2-hdbcaa40_0.tar.bz2": { + "build": "hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5dacb1033a56cff1520d280a61e80c41", + "name": "blosc", + "sha256": "e5d31d4d36c80976143968dba80b6289550f67b5e4733951f42802ae80a688e6", + "size": 539888, + "subdir": "linux-64", + "timestamp": 1522800994854, + "version": "1.14.2" + }, + "blosc-1.14.3-hdbcaa40_0.tar.bz2": { + "build": "hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5872c755977885ff994fdb58e510e191", + "name": "blosc", + "sha256": "0cbaf875bef7a21d4acc04b51f8d001fc2f77aa2f18a7a9d5ffce2f397deb2ea", + "size": 615321, + "subdir": "linux-64", + "timestamp": 1524177690023, + "version": "1.14.3" + }, + "blosc-1.14.4-hdbcaa40_0.tar.bz2": { + "build": "hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "44c9f308e8ce0324351622904ad2f2e4", + "name": "blosc", + "sha256": "a705d8136c712bb3d9fcd01ffdeaaba04fc76f8c61fc44b9cc2e0f9e6b3d0d58", + "size": 615433, + "subdir": "linux-64", + "timestamp": 1534676150270, + "version": "1.14.4" + }, + "blosc-1.15.0-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "63fbd69ed7f4191b883d8ff736ce5ab2", + "name": "blosc", + "sha256": "394c4ed5fb9c2f39acf70d25b7de32cbf0a1acf31b7540d59754789129051b17", + "size": 722317, + "subdir": "linux-64", + "timestamp": 1547757103906, + "version": "1.15.0" + }, + "blosc-1.16.3-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "482aa96b3d914b84aff2c14c0af94bcc", + "name": "blosc", + "sha256": "4dea38a2ba51021e0d7de35f972745c093d427baa8bdc78ec09b1febb1e93044", + "size": 84280, + "subdir": "linux-64", + "timestamp": 1558554355436, + "version": "1.16.3" + }, + "blosc-1.19.0-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.4,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e5b08f5e2b423f0da6f4c030f890f0ad", + "name": "blosc", + "sha256": "8a7ea850174947fc69f55bc654cc85c3dd153c0980845d09b633f5e935f6768c", + "size": 83398, + "subdir": "linux-64", + "timestamp": 1592515136878, + "version": "1.19.0" + }, + "blosc-1.20.0-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "snappy >=1.1.8,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "md5": "af9779d64e59358b5a777cf55b62fddf", + "name": "blosc", + "sha256": "976d29f1aebb6556599d52b642adb78dc8c233983599c640a428e4271c87403e", + "size": 83215, + "subdir": "linux-64", + "timestamp": 1597945777239, + "version": "1.20.0" + }, + "blosc-1.20.1-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e0185a7492d7fac8a4bdd158ae531004", + "name": "blosc", + "sha256": "708dd31e2056258d121e0497079d8d5678c7fef589cad5152b3a368d055c3a99", + "size": 83309, + "subdir": "linux-64", + "timestamp": 1602700193466, + "version": "1.20.1" + }, + "blosc-1.21.0-h4ff587b_1.tar.bz2": { + "build": "h4ff587b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7395b012ca1eeb4311defd9725d7aecd", + "name": "blosc", + "sha256": "bf8c43b2fe25247376d25098fad066f297fc5fd31b6ba88306cf79eec0744c0c", + "size": 69777, + "subdir": "linux-64", + "timestamp": 1653036606205, + "version": "1.21.0" + }, + "blosc-1.21.0-h8c45485_0.tar.bz2": { + "build": "h8c45485_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "md5": "68e0dbfda9f6e170cc01bde2670cf1fb", + "name": "blosc", + "sha256": "9f26088a561896f36e5ff24fd089bb5a2c8b4b6346b6ddab8d415c13fef1a023", + "size": 76015, + "subdir": "linux-64", + "timestamp": 1613249468528, + "version": "1.21.0" + }, + "blosc-1.21.3-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "lz4-c >=1.9.4,<1.10.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "202b4629c225257fc01a4a2180c4e2f7", + "name": "blosc", + "sha256": "10b48986cb0e0c974477ac3a58aaae198270b01f19cbd3e900143c6558fa3424", + "size": 65491, + "subdir": "linux-64", + "timestamp": 1675247642609, + "version": "1.21.3" + }, + "bokeh-0.12.10-py27he46cc6b_0.tar.bz2": { + "build": "py27he46cc6b_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d6146516cc7b9c2ca436f4962eeb3a27", + "name": "bokeh", + "sha256": "c1228ea78606842371b3c3a6868f5b29f925642f1de55216cda36f738b445c24", + "size": 4533304, + "subdir": "linux-64", + "timestamp": 1508263083255, + "version": "0.12.10" + }, + "bokeh-0.12.10-py35hfdb0b1d_0.tar.bz2": { + "build": "py35hfdb0b1d_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e4d3ce3afd75642a9c2efc4522f61c5b", + "name": "bokeh", + "sha256": "aa7025dbcf51592c425660a6dfc577991d9b720c946c7b3c24964f47dae93591", + "size": 4448429, + "subdir": "linux-64", + "timestamp": 1508263108730, + "version": "0.12.10" + }, + "bokeh-0.12.10-py36hbb0e44a_0.tar.bz2": { + "build": "py36hbb0e44a_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7417c88d16fa4710f08992c77927b8e4", + "name": "bokeh", + "sha256": "d96584380ad826379c90c52f7e7aa1687ac9e9a1caee93be5d65351ece2f9a5b", + "size": 4448232, + "subdir": "linux-64", + "timestamp": 1508263109298, + "version": "0.12.10" + }, + "bokeh-0.12.11-py27h8429e54_0.tar.bz2": { + "build": "py27h8429e54_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bda7ad6ff1015b9586a567c5c8ddea2f", + "name": "bokeh", + "sha256": "a82f729d934f168f6ffbb9f4538e9ff20175719bf2baad8d2955128b713cd0da", + "size": 4651706, + "subdir": "linux-64", + "timestamp": 1511894158421, + "version": "0.12.11" + }, + "bokeh-0.12.11-py35hf9fdf3f_0.tar.bz2": { + "build": "py35hf9fdf3f_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fb82ce06919bf517e720d392fae0d615", + "name": "bokeh", + "sha256": "a6aa88153560234355394bfcb65480197446a83ae858a84ffa09f2d6f435b3c2", + "size": 4731066, + "subdir": "linux-64", + "timestamp": 1511894189372, + "version": "0.12.11" + }, + "bokeh-0.12.11-py36hc91ac8f_0.tar.bz2": { + "build": "py36hc91ac8f_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "66714e11c476c74d87aa7612ae4d2825", + "name": "bokeh", + "sha256": "f56a4a136a5366caf0d280a368f5a5c185906b904a11772e211ebca76a25206c", + "size": 4719169, + "subdir": "linux-64", + "timestamp": 1511894201475, + "version": "0.12.11" + }, + "bokeh-0.12.13-py27h5233db4_0.tar.bz2": { + "build": "py27h5233db4_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "61b52fca9955b8d1357da5d1ed20be37", + "name": "bokeh", + "sha256": "f90d3f0c85200097c643f8eb96a4c500fa7921ddc42524e16f97085ac9846b72", + "size": 4275633, + "subdir": "linux-64", + "timestamp": 1513097509467, + "version": "0.12.13" + }, + "bokeh-0.12.13-py35h2f9c1c0_0.tar.bz2": { + "build": "py35h2f9c1c0_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "00cd22a54a086e31dd2445961a0fa763", + "name": "bokeh", + "sha256": "27077eace664e6a31fd10f1bf30262485d4d4f5c819455b66465b1bb7d3788f4", + "size": 4259153, + "subdir": "linux-64", + "timestamp": 1513097549660, + "version": "0.12.13" + }, + "bokeh-0.12.13-py36h2f9c1c0_0.tar.bz2": { + "build": "py36h2f9c1c0_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2e6fba30e8d06c9592a433f0ad6242f8", + "name": "bokeh", + "sha256": "cfdfbbad23c3a1fe1a5b5f4b6023312f19a6841430fe5dbe223e363ef4d4a838", + "size": 4252876, + "subdir": "linux-64", + "timestamp": 1513097592734, + "version": "0.12.13" + }, + "bokeh-0.12.14-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5d2412a14a9028a0bf1e72c00ec300ae", + "name": "bokeh", + "sha256": "6d90e8ace85e7de59a0dd68ca2223f449d700c36ba4dad7b124430520362f8ea", + "size": 4269753, + "subdir": "linux-64", + "timestamp": 1519070341767, + "version": "0.12.14" + }, + "bokeh-0.12.14-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "060bf81f1de0fd13754dde61ca4c7e7f", + "name": "bokeh", + "sha256": "d8ac110a2b0a9b546a04d15540ded3780745141b0582f4eb408aeb12fcf6062d", + "size": 4323551, + "subdir": "linux-64", + "timestamp": 1519070401771, + "version": "0.12.14" + }, + "bokeh-0.12.14-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "432df0a5e953a905b35980c5afb8a56d", + "name": "bokeh", + "sha256": "4a8f72639b8689547ac57cc1103f18e7ef98d0b2154a3cb4628b9f8df5ff12a1", + "size": 4297890, + "subdir": "linux-64", + "timestamp": 1519070402955, + "version": "0.12.14" + }, + "bokeh-0.12.15-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c5b4c43ea697598e70da317add414c7a", + "name": "bokeh", + "sha256": "9f30f0358b7f3ac063daaf215df9890370e50d09bfb9ceeb21a60cd85de17219", + "size": 4336431, + "subdir": "linux-64", + "timestamp": 1522345606685, + "version": "0.12.15" + }, + "bokeh-0.12.15-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d161b83bf63d81ef4ec1ec69e88c7fd0", + "name": "bokeh", + "sha256": "63aa1b954ce470323ff73f69076abdbe290dd9f63dd1096b30c5dd64c42decaa", + "size": 4343319, + "subdir": "linux-64", + "timestamp": 1522345570375, + "version": "0.12.15" + }, + "bokeh-0.12.15-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a5ffa32a0c8d290fd1e6f8984d5bb78b", + "name": "bokeh", + "sha256": "d764870d75cc17f5244833b66ddf1a2a3ee39e5df098286e72973def869c4b1f", + "size": 4348501, + "subdir": "linux-64", + "timestamp": 1522345631596, + "version": "0.12.15" + }, + "bokeh-0.12.16-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cfbc18d0d89c08dae5b9ef70e786a0f7", + "name": "bokeh", + "sha256": "54e6003a4ce167dcf4835e418c3e285668088963c497e351c33f7c0a0df300bf", + "size": 4368108, + "subdir": "linux-64", + "timestamp": 1526329854918, + "version": "0.12.16" + }, + "bokeh-0.12.16-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e6b5bd97d47323a41942b4845e8eb96a", + "name": "bokeh", + "sha256": "2ece6c39c4316d5ca4ab0cf846efe7fa3566ec1a9d5b92f8314f7da4963f8653", + "size": 4358168, + "subdir": "linux-64", + "timestamp": 1526329980731, + "version": "0.12.16" + }, + "bokeh-0.12.16-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "08b4da299e3b85141c96f2a628adc432", + "name": "bokeh", + "sha256": "ffa830e7caf2ef479ac684ee7edd860efe64988f41bfd8e8e3906b83cd8d0125", + "size": 4334737, + "subdir": "linux-64", + "timestamp": 1526329935059, + "version": "0.12.16" + }, + "bokeh-0.12.7-py27he0197c9_1.tar.bz2": { + "build": "py27he0197c9_1", + "build_number": 1, + "depends": [ + "bkcharts >=0.2", + "futures >=3.0.3", + "jinja2 >=2.7", + "matplotlib", + "numpy >=1.7.1", + "pandas", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "requests >=1.2.3", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e6082e98c342333033ec82724d2b9df4", + "name": "bokeh", + "sha256": "3750590a96bac552d548637a52dbe3f97b7ee9c0d9955892538b76b767f80949", + "size": 4383727, + "subdir": "linux-64", + "timestamp": 1505739753633, + "version": "0.12.7" + }, + "bokeh-0.12.7-py35h4751c18_1.tar.bz2": { + "build": "py35h4751c18_1", + "build_number": 1, + "depends": [ + "bkcharts >=0.2", + "jinja2 >=2.7", + "matplotlib", + "numpy >=1.7.1", + "pandas", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "requests >=1.2.3", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c6d1cd3c7e9013500a114c6ce19a5ead", + "name": "bokeh", + "sha256": "f4a3602195fd8fbb2838eae061d48746b5f89b8483c1882bef4439f80b932f23", + "size": 4444049, + "subdir": "linux-64", + "timestamp": 1505739800717, + "version": "0.12.7" + }, + "bokeh-0.12.7-py36h169c5fd_1.tar.bz2": { + "build": "py36h169c5fd_1", + "build_number": 1, + "depends": [ + "bkcharts >=0.2", + "jinja2 >=2.7", + "matplotlib", + "numpy >=1.7.1", + "pandas", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "requests >=1.2.3", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6c00d9f65fa73531217f8ad2663cc756", + "name": "bokeh", + "sha256": "b41887ad998250e79e79673cac2c7be1ce2fb761f3f1294a5758f01324d0c109", + "size": 4469133, + "subdir": "linux-64", + "timestamp": 1505739848870, + "version": "0.12.7" + }, + "bokeh-0.12.9-py27h403a6de_0.tar.bz2": { + "build": "py27h403a6de_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e8e1a7d8ddd42499ce8ef263042a09b0", + "name": "bokeh", + "sha256": "96e6478a20c99aeded01fe9346c263af8e95358df91e8b8a7217d2dd4ce7e860", + "size": 4379879, + "subdir": "linux-64", + "timestamp": 1506621189022, + "version": "0.12.9" + }, + "bokeh-0.12.9-py35hebc9bbc_0.tar.bz2": { + "build": "py35hebc9bbc_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b2ab7f956b6c53a3dc70a6487d132ea8", + "name": "bokeh", + "sha256": "6c97548b5af867f6ddcc12037fe28bac86e8a26fa069d0e5c6aa7ef86b493416", + "size": 4467824, + "subdir": "linux-64", + "timestamp": 1506621211683, + "version": "0.12.9" + }, + "bokeh-0.12.9-py36hca3971f_0.tar.bz2": { + "build": "py36hca3971f_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e65f68c7608782cd61c117d874afe065", + "name": "bokeh", + "sha256": "a3ac82214034372a3f39b1e05018c4cc1c9e0f5f986c5ed0150692cae5a7878d", + "size": 4482060, + "subdir": "linux-64", + "timestamp": 1506621219178, + "version": "0.12.9" + }, + "bokeh-0.13.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "176cd11beea046d3f17814d412a1b60f", + "name": "bokeh", + "sha256": "341d5592ccde3a38f946a062b9bd9887a21bb7c23e532d2be874f769183702cd", + "size": 5310820, + "subdir": "linux-64", + "timestamp": 1529505432491, + "version": "0.13.0" + }, + "bokeh-0.13.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d51b7032ce680296fd316c238a3e1916", + "name": "bokeh", + "sha256": "f6a46b3a04c6b5c8db9180f19e17c4e78126752109e45aae20135b38890ebd8a", + "size": 5305724, + "subdir": "linux-64", + "timestamp": 1529505466272, + "version": "0.13.0" + }, + "bokeh-0.13.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1a5c8bdecdfa250e364fc344d143eed3", + "name": "bokeh", + "sha256": "4a735f3d6f63bc9a333b9016302a9a7f9370c7ae56e69f116836271049f78639", + "size": 5279150, + "subdir": "linux-64", + "timestamp": 1529505448310, + "version": "0.13.0" + }, + "bokeh-0.13.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "db494534bdb0c014c711cbc2cdca2f28", + "name": "bokeh", + "sha256": "a076086d7a9b077a0e517377a4b8a932682c72c923b8add8724fb012e75fba2b", + "size": 5277227, + "subdir": "linux-64", + "timestamp": 1530741904337, + "version": "0.13.0" + }, + "bokeh-1.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "25072ee302062a208c2d6a998213c79d", + "name": "bokeh", + "sha256": "b7901b20ca158dd3445984ccec9b640ddedae1fe0236b0bba324f0ef02f9ba60", + "size": 5507964, + "subdir": "linux-64", + "timestamp": 1540399472457, + "version": "1.0.0" + }, + "bokeh-1.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "50fc37a98f2d665e40ff9911a423c89b", + "name": "bokeh", + "sha256": "b512a059ed23bbe056f7f7b530a4dcbab95364594599816bd1587fcf7d19b008", + "size": 5512754, + "subdir": "linux-64", + "timestamp": 1540399497766, + "version": "1.0.0" + }, + "bokeh-1.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8f30a0587ec816f3298034972e78c0da", + "name": "bokeh", + "sha256": "259a06b5c78ef64a6472474178050e4aaf71389ade1bc4f52cd0afc2e0c3004e", + "size": 5534248, + "subdir": "linux-64", + "timestamp": 1540399512486, + "version": "1.0.0" + }, + "bokeh-1.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "28df643833c0306450b0384635ea3f12", + "name": "bokeh", + "sha256": "d6ea2b29cd2e0b731e967ab79dbafd8622cc55103af5cb7c7d91df93e968106b", + "size": 5524251, + "subdir": "linux-64", + "timestamp": 1541047782301, + "version": "1.0.1" + }, + "bokeh-1.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ce069e51026711442db8be5e099b6736", + "name": "bokeh", + "sha256": "be1a5ada52fe2459a917080791b940030119bbb4e4b6ea7168d0a76cd38070f9", + "size": 5526173, + "subdir": "linux-64", + "timestamp": 1541047787819, + "version": "1.0.1" + }, + "bokeh-1.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e3bfc80fd78eed80ecf6f17ee54a5518", + "name": "bokeh", + "sha256": "58bbf38131fc601e55e868447b91b6015f4301b59849aaace1754ff986df14b3", + "size": 5533652, + "subdir": "linux-64", + "timestamp": 1541047740473, + "version": "1.0.1" + }, + "bokeh-1.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "575bae39102f0ac2daf7f87da9270b7c", + "name": "bokeh", + "sha256": "ddccea9b3c9e4d76d475085aa7d9137306049bfe151478c1a6868366e7dbc8f2", + "size": 5555473, + "subdir": "linux-64", + "timestamp": 1543527825897, + "version": "1.0.2" + }, + "bokeh-1.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9b2f8f6e01a6c8c343eb3c56c1759f5e", + "name": "bokeh", + "sha256": "80adf0a3ae74b349b02deff2668d17c4dbe9a30708149ae3592635bd96f65e73", + "size": 5545014, + "subdir": "linux-64", + "timestamp": 1543527867089, + "version": "1.0.2" + }, + "bokeh-1.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cbf61138da3db2c4d521d898cec48243", + "name": "bokeh", + "sha256": "4664b677114fb8c88e17b60944ab64470661fadcc98c1e1947954da47770d5d2", + "size": 5545131, + "subdir": "linux-64", + "timestamp": 1543527817681, + "version": "1.0.2" + }, + "bokeh-1.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eebbfd5391b518d3a600f3e5ceccdda7", + "name": "bokeh", + "sha256": "c0f4f0055cb5776c962a33c7e5544f9c6af0dc9abcaf2a4468dfca28a6a9dab8", + "size": 5654434, + "subdir": "linux-64", + "timestamp": 1546406186823, + "version": "1.0.3" + }, + "bokeh-1.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7a4e777ab03838583f7797b4720b7e3b", + "name": "bokeh", + "sha256": "e34566fa092f4c38d163cb6638292f0bcee8c1c5d8a8323f7f2423168aa06cf9", + "size": 5641657, + "subdir": "linux-64", + "timestamp": 1546406207062, + "version": "1.0.3" + }, + "bokeh-1.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "630108580c94600a96b4e52dd2833822", + "name": "bokeh", + "sha256": "e129d310ed133371ba50b2e00e80de1d63b79a8de0206841b4ee6a9d7b08efa8", + "size": 5672817, + "subdir": "linux-64", + "timestamp": 1546406207157, + "version": "1.0.3" + }, + "bokeh-1.0.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5bccaeb2bf9c7695bbddec0221f6a449", + "name": "bokeh", + "sha256": "842188211a4f8ea0db2dc99805118c9e3c5c8a9bf6f81828d3b2fce631f87e81", + "size": 5649796, + "subdir": "linux-64", + "timestamp": 1547757249215, + "version": "1.0.4" + }, + "bokeh-1.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c235b4f32fac63f9702fcd28fd38fb6c", + "name": "bokeh", + "sha256": "1083d545f895e21bd0f4d89164fcdcc0ff4f3f58b9c512bf3b3685dcd0bd7fb3", + "size": 5657332, + "subdir": "linux-64", + "timestamp": 1547757251917, + "version": "1.0.4" + }, + "bokeh-1.0.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a50da5e611265ef93fed7d0c8eee4284", + "name": "bokeh", + "sha256": "3068f19b67b005e698e8a1277b661ac44a0a4559b0af069f6e3ea3aa8026c97c", + "size": 5645693, + "subdir": "linux-64", + "timestamp": 1547757216073, + "version": "1.0.4" + }, + "bokeh-1.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e9a907174adaafc6e2aa0de02b1cec57", + "name": "bokeh", + "sha256": "768fd1bc63865b881641b88e05f3ea7aa9fe1be32b580a73a74058cbc299e87f", + "size": 6594764, + "subdir": "linux-64", + "timestamp": 1554927352633, + "version": "1.1.0" + }, + "bokeh-1.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3aa024310060f76745687b33d7dbcb4d", + "name": "bokeh", + "sha256": "ec17a3a6997d51468d4472db3b08c3b1e1d95ba018a141821015596434b0d5c2", + "size": 6554201, + "subdir": "linux-64", + "timestamp": 1554927279375, + "version": "1.1.0" + }, + "bokeh-1.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9d918c283a68dca6e363ffda53a5b2e7", + "name": "bokeh", + "sha256": "3701209ad92db5852ba0c037b6034d9ae89df438053bdb57bb403c9ddee91444", + "size": 6603822, + "subdir": "linux-64", + "timestamp": 1554927362128, + "version": "1.1.0" + }, + "bokeh-1.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "58550168b757e94ea0e424828a666e2f", + "name": "bokeh", + "sha256": "088ca03c9bad3eb7f5e0347c425e3dde86a2460250182237fd36ec712efda780", + "size": 4038518, + "subdir": "linux-64", + "timestamp": 1559140944218, + "version": "1.2.0" + }, + "bokeh-1.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1da75802e957653ee04e6b3300440dc5", + "name": "bokeh", + "sha256": "5b54f3b72712a00493f7c3bcf33f7672ef4005b889455843dee4186a2f5db131", + "size": 4065127, + "subdir": "linux-64", + "timestamp": 1559141330221, + "version": "1.2.0" + }, + "bokeh-1.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bd714cea4e83fa36bb2964a64c7f7d0d", + "name": "bokeh", + "sha256": "1623720477d2bfb0469bcb79999f156880ad1c2044e5fb9d6773644361748cdf", + "size": 4055831, + "subdir": "linux-64", + "timestamp": 1559140933930, + "version": "1.2.0" + }, + "bokeh-1.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "389b679598c113b8d0fc9b9d5a11853f", + "name": "bokeh", + "sha256": "3442c0151921eb5dff198e94944c46852f0b9b62318f1152c2d059142139cc18", + "size": 4230455, + "subdir": "linux-64", + "timestamp": 1563895753628, + "version": "1.3.0" + }, + "bokeh-1.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b84d3dba04f5192545e9ede9325bce13", + "name": "bokeh", + "sha256": "24d0f995847359a5bd660440f53b8f27681ae4d3fe477a7ab7e2d9866ce8e943", + "size": 4227922, + "subdir": "linux-64", + "timestamp": 1563895759970, + "version": "1.3.0" + }, + "bokeh-1.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2658cc5a26f0eff959d01bf1e5a2702e", + "name": "bokeh", + "sha256": "d6dac444397917d3b5f18013afacc96733d4be6c7d3a39cf4e03ce6e1e8d9668", + "size": 4228056, + "subdir": "linux-64", + "timestamp": 1563895757920, + "version": "1.3.0" + }, + "bokeh-1.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0e596389f677a8925046f644135c48c7", + "name": "bokeh", + "sha256": "8912be12650318b9ae1c120a074b3108d2beefa77b19ee4b52b9fc265dcb02d0", + "size": 4230127, + "subdir": "linux-64", + "timestamp": 1564518423051, + "version": "1.3.1" + }, + "bokeh-1.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9c12bd89ea67ba0bd3957fefdb65d0bf", + "name": "bokeh", + "sha256": "df59da163bd49e49cc8be58a53aab4f05945e5d2b7b68c7f1d5f4d9eb272f6c9", + "size": 4234067, + "subdir": "linux-64", + "timestamp": 1564518473337, + "version": "1.3.1" + }, + "bokeh-1.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ed96f699600266d0fa23ade077322862", + "name": "bokeh", + "sha256": "d3103f30c0626cdacbf52f15c932fa7954ece855a0d3a332cf22f67da0ca22c4", + "size": 4230253, + "subdir": "linux-64", + "timestamp": 1564518446681, + "version": "1.3.1" + }, + "bokeh-1.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8406937684de9ad0d213ecdb587f700d", + "name": "bokeh", + "sha256": "cd65fdead3c6c046a4df591a0640a87138cadd7ab818a4ef1c5a6994e9a1c486", + "size": 4239678, + "subdir": "linux-64", + "timestamp": 1565026226978, + "version": "1.3.2" + }, + "bokeh-1.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a1fb7e0048524badba6c9fca984e29bd", + "name": "bokeh", + "sha256": "c55a2978795d9d2cb48fc8bd67e2cad8c861262d5e07ce87d8c73edaaa12e418", + "size": 4228588, + "subdir": "linux-64", + "timestamp": 1565018104201, + "version": "1.3.2" + }, + "bokeh-1.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fce3b4f7d8a92b5c8b707dfe874111e8", + "name": "bokeh", + "sha256": "d7f961e8143e6887b84e4887a6550f9ca5e6cb602c033e2d38867df212e5f22f", + "size": 4217926, + "subdir": "linux-64", + "timestamp": 1565016998073, + "version": "1.3.2" + }, + "bokeh-1.3.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "af706db85ad41a5f6f4cf11dd0aade88", + "name": "bokeh", + "sha256": "325a185ecd951e9f6b7477c469178c4f6a8b9796e6bd652803bf01bf5ca4f401", + "size": 4234922, + "subdir": "linux-64", + "timestamp": 1565187191399, + "version": "1.3.4" + }, + "bokeh-1.3.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e230832f042da9d325634efb1a335ea9", + "name": "bokeh", + "sha256": "7810635636fa509c39dc56c739e3e513e2b232ec96510828ffe460c126058444", + "size": 4233848, + "subdir": "linux-64", + "timestamp": 1565187211496, + "version": "1.3.4" + }, + "bokeh-1.3.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "da00484ec11e45c4448780fcc931c486", + "name": "bokeh", + "sha256": "a2a9fb895e2e9a70177bd478e3d8517a33a0236af3396f66e6c9a85619b9533d", + "size": 4218237, + "subdir": "linux-64", + "timestamp": 1565187201838, + "version": "1.3.4" + }, + "bokeh-1.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "40d98a7e1a6d8ca63693d57c6d9e8ee6", + "name": "bokeh", + "sha256": "fefee0fccd3f29e1aaff08a13ac3e66f5daad54fdc3e49a177c9184126af248c", + "size": 14176272, + "subdir": "linux-64", + "timestamp": 1572890767580, + "version": "1.4.0" + }, + "bokeh-1.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d8620c02881689398110c81737c706fc", + "name": "bokeh", + "sha256": "a7650f9bdfdbd07768c8ed2671c6baed3cff57570a66879be51282660721e125", + "size": 14231916, + "subdir": "linux-64", + "timestamp": 1572890763851, + "version": "1.4.0" + }, + "bokeh-1.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e533758998b06e518f41147c1ee18700", + "name": "bokeh", + "sha256": "e0b34b7e57feed74d179d8350e1ef93e46bdc79651922120b1434dfbcfbdb631", + "size": 14238449, + "subdir": "linux-64", + "timestamp": 1572890744406, + "version": "1.4.0" + }, + "bokeh-1.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "91b2403beb9a7d40a42a9a9d1fa22100", + "name": "bokeh", + "sha256": "f69960635c7dca20520355b503669014db95523619f211c36176b2d115b0a299", + "size": 14238031, + "subdir": "linux-64", + "timestamp": 1580236714426, + "version": "1.4.0" + }, + "bokeh-2.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1ac0a2c8f8f671e92a2bd687fcafefa7", + "name": "bokeh", + "sha256": "6fdeead747b0da7a606bad00aa5a3649e54c98f158c1f329d9f6019721ea0f82", + "size": 7127191, + "subdir": "linux-64", + "timestamp": 1584020889121, + "version": "2.0.0" + }, + "bokeh-2.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "17946ee9e6203dbbee108abfa1bfa62e", + "name": "bokeh", + "sha256": "2d652764d8cdc108c31b98247021d254829a12c6bf4200537ce601fc272af7b3", + "size": 7142317, + "subdir": "linux-64", + "timestamp": 1584020856541, + "version": "2.0.0" + }, + "bokeh-2.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e17b42a5f8a87108268570f3db396aef", + "name": "bokeh", + "sha256": "ebb8b64d4a5e6afd8ea6c2538e6e7c9fe98f06b2cfe2270fb16ba93e300a81ae", + "size": 7139200, + "subdir": "linux-64", + "timestamp": 1584020901756, + "version": "2.0.0" + }, + "bokeh-2.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d4ccf840ad918aefa66f88f31c6c0794", + "name": "bokeh", + "sha256": "72422adce315ee11858197288a546825dd18704473f7595f172a637df4addf09", + "size": 7271197, + "subdir": "linux-64", + "timestamp": 1585589047134, + "version": "2.0.1" + }, + "bokeh-2.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa0fb69cf01c7344db270c6480107e0c", + "name": "bokeh", + "sha256": "0dd4a72aeacab28f6d3e90c1fe025f5f135bc14e2768bb919778af82d2cef680", + "size": 7183119, + "subdir": "linux-64", + "timestamp": 1585589020163, + "version": "2.0.1" + }, + "bokeh-2.0.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9181bfbe672568f61532605d60c97d9d", + "name": "bokeh", + "sha256": "b9c6c63eff1b2be4698bd06957cfc7dc4eb4f25cf3a44a056b09f442f4792b98", + "size": 7283772, + "subdir": "linux-64", + "timestamp": 1585589028176, + "version": "2.0.1" + }, + "bokeh-2.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff5516b26cd8576cf41c645cedc27c71", + "name": "bokeh", + "sha256": "ef096ed177c7f035b31457dab195ff80f83a1fbfa840781326a904b5565f124a", + "size": 7183230, + "subdir": "linux-64", + "timestamp": 1588263382310, + "version": "2.0.2" + }, + "bokeh-2.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9adbf6c547c217ecbdd918d8d5486a0d", + "name": "bokeh", + "sha256": "7bd607c931b802bd58f097f01a58e0bb8fae3d25321e0cd03ca755dd3456a567", + "size": 7170650, + "subdir": "linux-64", + "timestamp": 1588263382709, + "version": "2.0.2" + }, + "bokeh-2.0.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "65d945e245327a69c82157d24a4322d5", + "name": "bokeh", + "sha256": "cc51c6436b0a3e46d27773dcdd905870eedb90dc700819b9fd28e5696b438681", + "size": 7243874, + "subdir": "linux-64", + "timestamp": 1588263399726, + "version": "2.0.2" + }, + "bokeh-2.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "297b9789885ecdccf544bcfe982e5b8f", + "name": "bokeh", + "sha256": "deee7dcba145a6e58494a25d1d2bb5701994c773fd87318e72a316f7813d4822", + "size": 7320702, + "subdir": "linux-64", + "timestamp": 1592319694418, + "version": "2.1.0" + }, + "bokeh-2.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "90264984578347ceef8ddea1a0eed3ec", + "name": "bokeh", + "sha256": "f442b9dc5b30e6c9f3e95cc0f19c517ca02192240f1a8c950d00771ecfdce314", + "size": 7253318, + "subdir": "linux-64", + "timestamp": 1592319703967, + "version": "2.1.0" + }, + "bokeh-2.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "12114bca1ec03797b848af8fc9841ea7", + "name": "bokeh", + "sha256": "72d3600bac848c4ce6c6d0af765f9ac4b375b3d4e818680c047f2bb3efc055e8", + "size": 7377855, + "subdir": "linux-64", + "timestamp": 1592319692861, + "version": "2.1.0" + }, + "bokeh-2.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "69b9006d0527f1f3c7a5393342a24829", + "name": "bokeh", + "sha256": "2af698245e586490198f66e8b3fdf7f5cb3d81f0eb5c793bf2d5cf826c9c0e83", + "size": 7402328, + "subdir": "linux-64", + "timestamp": 1593187650020, + "version": "2.1.1" + }, + "bokeh-2.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1f9b068bef9b0339c08fd968b256e2b6", + "name": "bokeh", + "sha256": "79dc9242d764d1c3afddcbc2f4d22f8f5e6bd0a69fe6ab405ffdd644bc11a079", + "size": 7307062, + "subdir": "linux-64", + "timestamp": 1593187630801, + "version": "2.1.1" + }, + "bokeh-2.1.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1c9f409dc06f3bb16d57853065944f2b", + "name": "bokeh", + "sha256": "f209626c8a6bd241108da57689dec50e761dc28a60309fec3c1247cbe766b92e", + "size": 7288195, + "subdir": "linux-64", + "timestamp": 1593187649634, + "version": "2.1.1" + }, + "bokeh-2.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22a1fc61b2753bf27a2042e135a5062a", + "name": "bokeh", + "sha256": "5bf225e7ca0eaf31c3893bb202dd5bc8c49d0419da972931db52ceed215c2f07", + "size": 7352867, + "subdir": "linux-64", + "timestamp": 1598371092245, + "version": "2.2.0" + }, + "bokeh-2.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8310d8469cb46831f64de994c7b5f8e1", + "name": "bokeh", + "sha256": "3159fc5bb8841fef216c6d1184ae7177441db0063fc237709f140a1e2f3150ea", + "size": 7315308, + "subdir": "linux-64", + "timestamp": 1598293368906, + "version": "2.2.0" + }, + "bokeh-2.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0bf574c02666035d483a1e3dec98ae58", + "name": "bokeh", + "sha256": "2f4b36f7680fdde6d3bb6641c8c962e3ea55a4b8e549e279cf2b9c5c7478f663", + "size": 7445120, + "subdir": "linux-64", + "timestamp": 1598371068490, + "version": "2.2.0" + }, + "bokeh-2.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "784be40ef064b36ee40b271585382664", + "name": "bokeh", + "sha256": "7023cb699c675ff9fe1fa307a89575521ff6dd6192557001b5c0184e26911c0f", + "size": 7360175, + "subdir": "linux-64", + "timestamp": 1598903603131, + "version": "2.2.1" + }, + "bokeh-2.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fab4bc7aa0a1f3cef36fbbcb7e117d61", + "name": "bokeh", + "sha256": "76c6bec8385867598002fda1e509320fae4de518874fc1af69492051aee78204", + "size": 7377186, + "subdir": "linux-64", + "timestamp": 1598903543975, + "version": "2.2.1" + }, + "bokeh-2.2.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "13646a5f15b3703ba1a731888aeb8868", + "name": "bokeh", + "sha256": "b82759e62d42a3761fdc06bc6b8df1e120144dbc7794206829a35c8fbf98c9d3", + "size": 7401626, + "subdir": "linux-64", + "timestamp": 1598903574802, + "version": "2.2.1" + }, + "bokeh-2.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "43c47e7dcd9aebc98cea4c5a050492b0", + "name": "bokeh", + "sha256": "7fd7d9abd0a411ca5a8d1ce0c2d96fda321a3a3ceb0d43d7185e697ae1d6c731", + "size": 7277030, + "subdir": "linux-64", + "timestamp": 1602773489868, + "version": "2.2.2" + }, + "bokeh-2.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f8166f1b1ac520b8e6802f79cb6983a", + "name": "bokeh", + "sha256": "21b6b511b4e2eb28a133240cfe73ba40e4127586b9184f0ae3dd74b5f83c9db5", + "size": 7285298, + "subdir": "linux-64", + "timestamp": 1602773497366, + "version": "2.2.2" + }, + "bokeh-2.2.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9770820de115cddc2dfcb948571ec767", + "name": "bokeh", + "sha256": "9a0dc4dd46e94513b17611d0ac0387dc039d6c16bf802148733d973bd62d01b6", + "size": 7356314, + "subdir": "linux-64", + "timestamp": 1602773501582, + "version": "2.2.2" + }, + "bokeh-2.2.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dbf1b425ce539a039db620d0d7cd4b9f", + "name": "bokeh", + "sha256": "bc7accf3f4881ca6fb84563d608edae5eb53efb4904746ed396f7e7e61bc496b", + "size": 7378606, + "subdir": "linux-64", + "timestamp": 1603297862304, + "version": "2.2.3" + }, + "bokeh-2.2.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "93790817ae838e2ad61ceee744e7a182", + "name": "bokeh", + "sha256": "50a9ffcf775e71cabd52c84cc76d811a2b85a5a392cbb8053c640534562a6527", + "size": 7371268, + "subdir": "linux-64", + "timestamp": 1603297887233, + "version": "2.2.3" + }, + "bokeh-2.2.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5ae9b109327806937a93e775fe5dfbe1", + "name": "bokeh", + "sha256": "db73338f75de70f0f485440210cd9e86370191c68e454e04dbfb8c6ae3b6403c", + "size": 7363846, + "subdir": "linux-64", + "timestamp": 1603297872516, + "version": "2.2.3" + }, + "bokeh-2.2.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a9ba5961fa255499e38e559c74a41bc3", + "name": "bokeh", + "sha256": "56fa9f736655d89f520c8278ffe9263ce33ddcc27602d6678e964d9970b67b8a", + "size": 7314660, + "subdir": "linux-64", + "timestamp": 1607609923036, + "version": "2.2.3" + }, + "bokeh-2.3.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "579a5a524fcf84b3d2477dcd8aad6ccf", + "name": "bokeh", + "sha256": "dfd80012e438aece168d15292f1332ac73e391c2fb5af3fbd90853266e37ef24", + "size": 8678744, + "subdir": "linux-64", + "timestamp": 1614700680186, + "version": "2.3.0" + }, + "bokeh-2.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "80f5695e721c5270d9748c71183fe510", + "name": "bokeh", + "sha256": "dba1eab780a9cfaae0de178d7c65a237f6e9593e42b72a976b2686fba0c65f6b", + "size": 8676633, + "subdir": "linux-64", + "timestamp": 1614699441310, + "version": "2.3.0" + }, + "bokeh-2.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "35db29fc8c48d10e350cb666a89eb178", + "name": "bokeh", + "sha256": "dc558714c77a9e5e439aad93467f6be5ee35644f58b6142e6a79f12d9c95ad29", + "size": 8613553, + "subdir": "linux-64", + "timestamp": 1614700676001, + "version": "2.3.0" + }, + "bokeh-2.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "59db768639a4298c43f0a0c5a9ca0484", + "name": "bokeh", + "sha256": "62e1419a3c7f42267220a86c5c7dbd1193dc0ba7dbd97f6b9c4b234150d14580", + "size": 8615603, + "subdir": "linux-64", + "timestamp": 1614700680235, + "version": "2.3.0" + }, + "bokeh-2.3.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "740d0ee3505555686ae7cde4ce96aba5", + "name": "bokeh", + "sha256": "f8fc9f95bc4e7d80887c157e8116708e9dd29bba4d77566193af5651338210cb", + "size": 8599752, + "subdir": "linux-64", + "timestamp": 1617827408739, + "version": "2.3.1" + }, + "bokeh-2.3.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "51ab1370472f316da7f7f7256a3ae6c3", + "name": "bokeh", + "sha256": "c550e620aa6f096aba93e83bc7cfc01b2f70c377db57ed9a3a410647c4def4ca", + "size": 8577249, + "subdir": "linux-64", + "timestamp": 1617827411766, + "version": "2.3.1" + }, + "bokeh-2.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8ce1991e63f460340b4febe7a415de8b", + "name": "bokeh", + "sha256": "fea48744ef972a891c343142c129db055800f574b07d473226724db80a6dede9", + "size": 8627237, + "subdir": "linux-64", + "timestamp": 1617824600429, + "version": "2.3.1" + }, + "bokeh-2.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b8f45a7e241ef32045fdf950764e84ae", + "name": "bokeh", + "sha256": "9f4c1cf40e2c2c7d204b87c78204aa3ae3787afcc5161957ceb8c2e735c7722f", + "size": 8625497, + "subdir": "linux-64", + "timestamp": 1617826622252, + "version": "2.3.1" + }, + "bokeh-2.3.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c954ac03fecbc00e25ce71824aeeaa43", + "name": "bokeh", + "sha256": "53b49ee66a27c37b9199da5dfba9bf51ffeedea01ab504ad96ddd63f233c1b88", + "size": 8638939, + "subdir": "linux-64", + "timestamp": 1620710103177, + "version": "2.3.2" + }, + "bokeh-2.3.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0eb178229ed19aff308e222375d5467b", + "name": "bokeh", + "sha256": "00c4d7f43c744b55010db8cdda41e05a3f0a3d9138552f283f18b9e9a3c28f1c", + "size": 8611448, + "subdir": "linux-64", + "timestamp": 1620783950233, + "version": "2.3.2" + }, + "bokeh-2.3.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0b8289ccdc8a8742cda92ee0ab0a802e", + "name": "bokeh", + "sha256": "b33fe9ffef457fab1a1fce51af5ed8295870d759f001f94036020e27f582849e", + "size": 8624853, + "subdir": "linux-64", + "timestamp": 1620779653740, + "version": "2.3.2" + }, + "bokeh-2.3.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d96851068296744e855c679967c1498b", + "name": "bokeh", + "sha256": "d6ff45c5cc12c0283f21948dd577b925e90611daf30d946e136c788071467110", + "size": 8703164, + "subdir": "linux-64", + "timestamp": 1620783948095, + "version": "2.3.2" + }, + "bokeh-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "13d330ef093d96bd06f1312c7d27e82c", + "name": "bokeh", + "sha256": "fcda7f154b313090fd563b119c91517dbd47fc557822eb310341aa7dfb1d2adc", + "size": 8633072, + "subdir": "linux-64", + "timestamp": 1625760725077, + "version": "2.3.3" + }, + "bokeh-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "259a031bf81c4dcfd23e8362fc66d82c", + "name": "bokeh", + "sha256": "3bfeca90afe6dfc7d2449c80d399b49a71789194d788a1885bcdffadf7ba4203", + "size": 8626396, + "subdir": "linux-64", + "timestamp": 1625766948987, + "version": "2.3.3" + }, + "bokeh-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d0c0e898049739c075d026891c7de3cf", + "name": "bokeh", + "sha256": "c97515490688900b9afd59dbff8ca2b0d1edae49b9af7c4b1cbddb874b6e0163", + "size": 8690186, + "subdir": "linux-64", + "timestamp": 1625767563920, + "version": "2.3.3" + }, + "bokeh-2.4.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c6f0f517a49048a28bf5037137a8ea78", + "name": "bokeh", + "sha256": "12bb8d13f7f6a49b25ecbcdf4c0d665f6667071eec16603d687371252fbfa426", + "size": 14347558, + "subdir": "linux-64", + "timestamp": 1640803601079, + "version": "2.4.1" + }, + "bokeh-2.4.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7943f48c89fbac5a011887fc77a654d7", + "name": "bokeh", + "sha256": "eadc9f6c6c208463c2b920df76003149b8283646c1d02d02c136421c57738bd4", + "size": 14311109, + "subdir": "linux-64", + "timestamp": 1635324527945, + "version": "2.4.1" + }, + "bokeh-2.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c354b1cd098bdf3b61af9753cccb5597", + "name": "bokeh", + "sha256": "101cc7fa063f90828d33ff5f28a623ce45ef75eba095b93a0743cd003047fb7b", + "size": 14325722, + "subdir": "linux-64", + "timestamp": 1635324513029, + "version": "2.4.1" + }, + "bokeh-2.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3e3e8a0de52b90e8b0686c4059b51e7b", + "name": "bokeh", + "sha256": "8b1a1ff532e1f8d1a90d793a529ac9eaca28532470266a40cdb42b212bb43120", + "size": 14355692, + "subdir": "linux-64", + "timestamp": 1635312856155, + "version": "2.4.1" + }, + "bokeh-2.4.2-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "24fe0fbc8dc16a6b937103bac9fd602f", + "name": "bokeh", + "sha256": "ff9b1e0b5f97557fcc6b4cf586b7b2efe42107fb3b96c3093d515cef1b80e133", + "size": 14384645, + "subdir": "linux-64", + "timestamp": 1652966940960, + "version": "2.4.2" + }, + "bokeh-2.4.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b91de211299d13bfe7ea258fb69d8408", + "name": "bokeh", + "sha256": "cf7a2b82de54a6be240f74053d1f15e1b262e0e27f820a80fe6822fcebc52dc6", + "size": 14363049, + "subdir": "linux-64", + "timestamp": 1638362875270, + "version": "2.4.2" + }, + "bokeh-2.4.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1f187df7d7670cfed5816081ee52c9f9", + "name": "bokeh", + "sha256": "050145e43ad0f90562f43f1f288cacc2cd6c6e7363b4125f98249ccf6abf1259", + "size": 14420542, + "subdir": "linux-64", + "timestamp": 1652967007925, + "version": "2.4.2" + }, + "bokeh-2.4.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b58c79b12780c290625fef73860d7988", + "name": "bokeh", + "sha256": "7fec7e23d24119f8b86afa3fdcb964b632816852b361691f7f458636647f47d0", + "size": 14424946, + "subdir": "linux-64", + "timestamp": 1638349687511, + "version": "2.4.2" + }, + "bokeh-2.4.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb94e2aa57924706757461db389a6512", + "name": "bokeh", + "sha256": "602bc46d79f3722135cceb723072adac55730b71e7d486f2c8c8618758f65e16", + "size": 14377275, + "subdir": "linux-64", + "timestamp": 1652966792810, + "version": "2.4.2" + }, + "bokeh-2.4.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bac70308854ae707617f33ff457224e1", + "name": "bokeh", + "sha256": "c8cea0fca9bfc9f5394c34592e35e3a603b897a96d94679f8268c9352424fd52", + "size": 14302483, + "subdir": "linux-64", + "timestamp": 1638362869859, + "version": "2.4.2" + }, + "bokeh-2.4.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "16616d327e04286c9a391fa8c90eefaf", + "name": "bokeh", + "sha256": "a559b6fd890e7026337b2bc69a5d97dd777f95ad60aff07180a0cb517e781487", + "size": 14416166, + "subdir": "linux-64", + "timestamp": 1652966864360, + "version": "2.4.2" + }, + "bokeh-2.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88353150bcecb679f62737785330e203", + "name": "bokeh", + "sha256": "7933a04f65cd54c879f49409b89fa55906f9ac3cf5919ce7ef9e216960e727dc", + "size": 14453101, + "subdir": "linux-64", + "timestamp": 1658136717996, + "version": "2.4.3" + }, + "bokeh-2.4.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.11,<3.12.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3987a1cb1e1572271c29f3fc6b04e601", + "name": "bokeh", + "sha256": "1145d16110ae55efceee83cbd647c4f5e44a4a6f8c45d9fb6c7853e7ca0e1d90", + "size": 14517795, + "subdir": "linux-64", + "timestamp": 1676830090434, + "version": "2.4.3" + }, + "bokeh-2.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85ef784a3b2d263ad1c938f0902454f0", + "name": "bokeh", + "sha256": "58f6a5bb14089ac0f082ba0adde5841a3c5bdb13b7cd60b8c0aec63dce035846", + "size": 14453325, + "subdir": "linux-64", + "timestamp": 1658136848424, + "version": "2.4.3" + }, + "bokeh-2.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cdb0ee83e9c478d96d12c837716659ee", + "name": "bokeh", + "sha256": "c5ab37760e889de86ff84573af7b2209b522b71a8204aaddcf56aaa9e1ed7a2e", + "size": 14441483, + "subdir": "linux-64", + "timestamp": 1658136913187, + "version": "2.4.3" + }, + "bokeh-2.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ae374a11c789a55555f70b29b9eff1f9", + "name": "bokeh", + "sha256": "2d8e75f31f75ea5eb8b9021b4c21eb2846a254a097e06eb68e66fc36a82e1bed", + "size": 14430294, + "subdir": "linux-64", + "timestamp": 1658136783940, + "version": "2.4.3" + }, + "bokeh-3.0.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f3a843c7e737c910e9170f96df8fe3b3", + "name": "bokeh", + "sha256": "d3759de072170f2fdd3d43c98ceb9d595b36f2245e376d5fe60372eafc3e6e5d", + "size": 12904316, + "subdir": "linux-64", + "timestamp": 1668678923015, + "version": "3.0.2" + }, + "bokeh-3.0.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "28441aaddb6c74cecde58d020f57bf63", + "name": "bokeh", + "sha256": "496d96fddab80ba771b65415dba76c1bd3870163bd0dd4918790bfb8df689c7d", + "size": 12878957, + "subdir": "linux-64", + "timestamp": 1668678850353, + "version": "3.0.2" + }, + "bokeh-3.0.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "63fe1f4ca12f6998d1cb40450a1c69e8", + "name": "bokeh", + "sha256": "6230d05ca1588cc9cabc3ccedade16c17e2d94fa7c097ba2338e6bc3e724d3eb", + "size": 12888142, + "subdir": "linux-64", + "timestamp": 1668678773229, + "version": "3.0.2" + }, + "bokeh-3.0.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2bd315ca0cd82fc6a9c89ad982fdf933", + "name": "bokeh", + "sha256": "e08cfecd2d4783182700adda0496d979062534aa29c81bf4199113e25cbc564a", + "size": 13009233, + "subdir": "linux-64", + "timestamp": 1671781971237, + "version": "3.0.3" + }, + "bokeh-3.0.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.11,<3.12.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0323631475656958a19af31109941c21", + "name": "bokeh", + "sha256": "2f615730e3c85ee95cccec6c5e78e605d06ee02851baa470d1cb42d4caadb93f", + "size": 13137076, + "subdir": "linux-64", + "timestamp": 1676830047435, + "version": "3.0.3" + }, + "bokeh-3.0.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6f53af4999096aac4229da68dc67b62b", + "name": "bokeh", + "sha256": "c32453bbb5dd09242146d29e0ff14e5a3952502fe1bdb501546681974f005dc7", + "size": 12997630, + "subdir": "linux-64", + "timestamp": 1671782042064, + "version": "3.0.3" + }, + "bokeh-3.0.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "964d7661a29cf87cf493e8d2cc3d3367", + "name": "bokeh", + "sha256": "54e7f30942ad65c2bdc92879c8aca9bd160d01a5fc3a1d645ec0a78a2c792101", + "size": 12933628, + "subdir": "linux-64", + "timestamp": 1671782109717, + "version": "3.0.3" + }, + "bokeh-3.1.0-py310h2f386ee_0.tar.bz2": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.21.5,<2.0a0", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "545fd26af9ec7b5527c6a31abd764941", + "name": "bokeh", + "sha256": "594af1b998e213acf088010d19aedd09b9f4ff90998a58b42aed065a8c3489d0", + "size": 6778104, + "subdir": "linux-64", + "timestamp": 1678869962030, + "version": "3.1.0" + }, + "bokeh-3.1.0-py311h6410fe4_0.tar.bz2": { + "build": "py311h6410fe4_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.22.3,<2.0a0", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.11,<3.12.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f7764cd8be7de80e5a3efa64ffd66909", + "name": "bokeh", + "sha256": "eadf7f00723283acab450e926fa54606aa914f37204fd3290b3358a4a9ba059d", + "size": 7019722, + "subdir": "linux-64", + "timestamp": 1679335466362, + "version": "3.1.0" + }, + "bokeh-3.1.0-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.16.6,<2.0a0", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d78e4e2b91be283f0e2e5cf0059135c5", + "name": "bokeh", + "sha256": "5ac6ebb9ba0bbfc307729fb45a1ce2822d060ad59127dcb00be3e942c1798ca5", + "size": 6767920, + "subdir": "linux-64", + "timestamp": 1678870118561, + "version": "3.1.0" + }, + "bokeh-3.1.0-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.16.6,<2.0a0", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4c71475e01535761f517fe27c06e1121", + "name": "bokeh", + "sha256": "6a360c854dba87f3021dbf28c66570b4342762540f2c6499c62b602bd876a5e1", + "size": 6767739, + "subdir": "linux-64", + "timestamp": 1678870037213, + "version": "3.1.0" + }, + "boltons-21.0.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cc16312cc373b7c1c2d85bff1b730619", + "name": "boltons", + "sha256": "27a80eb93ac865c3daaef24785a0e784ee2e4dfb94403591849d318dd878669e", + "size": 428349, + "subdir": "linux-64", + "timestamp": 1674527461213, + "version": "21.0.0" + }, + "boltons-21.0.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "15d737d3b13dc9e0477e8142252c407c", + "name": "boltons", + "sha256": "c073bddc615f8d6426b6f8964244060fa211f353958fb7e23752fc7158b99731", + "size": 424612, + "subdir": "linux-64", + "timestamp": 1674527398794, + "version": "21.0.0" + }, + "boltons-21.0.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3a633b951152588d8b58e9ac37fe94c0", + "name": "boltons", + "sha256": "9e3ff069ea1b99fbf61886fa5cf23d1c63a71b5ed80789e25406617203b3eb1b", + "size": 424885, + "subdir": "linux-64", + "timestamp": 1674527428212, + "version": "21.0.0" + }, + "boltons-21.0.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "886619eef5fee984927cbe8cf5545ee3", + "name": "boltons", + "sha256": "be2a610c1025553b43f3e473211ec6d267d83025f7f000d47779c6e262b1c71c", + "size": 425231, + "subdir": "linux-64", + "timestamp": 1674527490592, + "version": "21.0.0" + }, + "boltons-23.0.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "99a4d1e0a1a8e987d3be965299b53749", + "name": "boltons", + "sha256": "40ac2456b3605abdb8fc2956c1f899d80aea3ba51db833756d0c9ad9e76b0f0d", + "size": 434014, + "subdir": "linux-64", + "timestamp": 1677628810225, + "version": "23.0.0" + }, + "boltons-23.0.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "774ba6348a44a0108ed11016fe33536b", + "name": "boltons", + "sha256": "1e75fac2a70acdf61aa3b51290f857174da4f26b34bf4144005775e7a9451e95", + "size": 522399, + "subdir": "linux-64", + "timestamp": 1677685215859, + "version": "23.0.0" + }, + "boltons-23.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e8e69c0841b0883cf8633974bea50e2f", + "name": "boltons", + "sha256": "95c77b8d1bc0fb914129b23a511333840fd8528c73e7679f830b14afe47809d7", + "size": 430604, + "subdir": "linux-64", + "timestamp": 1677628780937, + "version": "23.0.0" + }, + "boltons-23.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "725cc8acef028a4e0ce169f25fd0f624", + "name": "boltons", + "sha256": "accd0fa547d0d6eb85fcba9b73c1e4c95505b9ee4aadf5a6d702479e890ac4c4", + "size": 430834, + "subdir": "linux-64", + "timestamp": 1677628751883, + "version": "23.0.0" + }, + "boltons-23.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bd9f7b410d2b1721deb9553b2fde1c64", + "name": "boltons", + "sha256": "485be80fd6c36e227e1f45e8cf96277668514be3dff0e7b300c70baece2fe264", + "size": 429781, + "subdir": "linux-64", + "timestamp": 1677628723275, + "version": "23.0.0" + }, + "boolean.py-4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "0c68a662d66b75d99bbbee66b5177e44", + "name": "boolean.py", + "sha256": "45a219411d0d5fafabd779ef608e97b926638d4d6b515f55d92c2bdb013117a5", + "size": 49110, + "subdir": "linux-64", + "timestamp": 1663018505825, + "version": "4.0" + }, + "boolean.py-4.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "cabb5c48b4601b5c2891819006557d51", + "name": "boolean.py", + "sha256": "402204910008bc08e89fef589310e658f38dbfb141da5beb6c352f385a30f57d", + "size": 65761, + "subdir": "linux-64", + "timestamp": 1676839157950, + "version": "4.0" + }, + "boolean.py-4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e4137e57a118cc2b781d23c8fa99dc00", + "name": "boolean.py", + "sha256": "6756b9c86fa78ef22e3f5daa52884290fc603321d1e3ec88772371be6e4d3630", + "size": 48422, + "subdir": "linux-64", + "timestamp": 1663018530852, + "version": "4.0" + }, + "boolean.py-4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "450ac305dabe660c44f3e4bba0d517d3", + "name": "boolean.py", + "sha256": "434b7c123a0e3312b2c69d6d16f22da181347b7163e5e755872b92bbd6517743", + "size": 48702, + "subdir": "linux-64", + "timestamp": 1663018555714, + "version": "4.0" + }, + "boolean.py-4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "26f738a3ed6ccd01af0b55775bc8de3a", + "name": "boolean.py", + "sha256": "1d505b70757444bf6741b3645f2225dadc55da42566055d965e1f1ddb437c77c", + "size": 48587, + "subdir": "linux-64", + "timestamp": 1663018467614, + "version": "4.0" + }, + "boost-1.65.1-py27_4.tar.bz2": { + "build": "py27_4", + "build_number": 4, + "depends": [ + "libboost 1.65.1 habcd387_4", + "py-boost", + "python >=2.7,<2.8.0a0" + ], + "license": "Boost-1.0", + "md5": "d892b4edc6f14894a113a9e550b4e7a3", + "name": "boost", + "namespace": "python", + "sha256": "3c3f98999527ed9650555ac690e26cece72502bfaf0f0f95b8cf5ffb19b84d7d", + "size": 4144, + "subdir": "linux-64", + "timestamp": 1515095691660, + "version": "1.65.1" + }, + "boost-1.65.1-py27h0eb07c9_3.tar.bz2": { + "build": "py27h0eb07c9_3", + "build_number": 3, + "depends": [ + "libboost 1.65.1 h4055789_3", + "py-boost 1.65.1 py27h3b928e7_3", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Boost-1.0", + "md5": "da7a8a5b7a17bb44b4413469ecdd9df2", + "name": "boost", + "namespace": "python", + "sha256": "3ad0a90e0d29b274f1ffc32b539ab3e69367a870a0e37f4370980828f19c689e", + "size": 4222, + "subdir": "linux-64", + "timestamp": 1508786740243, + "version": "1.65.1" + }, + "boost-1.65.1-py35_4.tar.bz2": { + "build": "py35_4", + "build_number": 4, + "depends": [ + "libboost 1.65.1 habcd387_4", + "py-boost", + "python >=3.5,<3.6.0a0" + ], + "license": "Boost-1.0", + "md5": "ff6f383737e9920b55598abd4fff597b", + "name": "boost", + "namespace": "python", + "sha256": "b64c4bc26a2a905c2d08a334b6ae814d454314932935e8df12d1a19154f9288f", + "size": 4152, + "subdir": "linux-64", + "timestamp": 1515095684781, + "version": "1.65.1" + }, + "boost-1.65.1-py35heb9229b_3.tar.bz2": { + "build": "py35heb9229b_3", + "build_number": 3, + "depends": [ + "libboost 1.65.1 h4055789_3", + "py-boost 1.65.1 py35hdf000e1_3", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Boost-1.0", + "md5": "c904c4d79bc3f259237e94a8639de458", + "name": "boost", + "namespace": "python", + "sha256": "3d3cda69baf6ada4ae5e57a29fa81b7fe1e8a278017e22f8d036561029f5d561", + "size": 4239, + "subdir": "linux-64", + "timestamp": 1508786737842, + "version": "1.65.1" + }, + "boost-1.65.1-py36_4.tar.bz2": { + "build": "py36_4", + "build_number": 4, + "depends": [ + "libboost 1.65.1 habcd387_4", + "py-boost", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "95b7fcd9fc9a02c9127d188b23f82cb9", + "name": "boost", + "namespace": "python", + "sha256": "041a54ac2f18efb48358cb9527463103f37a8808b1f91bb658fbe85053ed0d47", + "size": 4124, + "subdir": "linux-64", + "timestamp": 1515095677075, + "version": "1.65.1" + }, + "boost-1.65.1-py36hfaba7b9_3.tar.bz2": { + "build": "py36hfaba7b9_3", + "build_number": 3, + "depends": [ + "libboost 1.65.1 h4055789_3", + "py-boost 1.65.1 py36hff4598c_3", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Boost-1.0", + "md5": "ddca6a04066d9ed21dad0a73fe82d4a3", + "name": "boost", + "namespace": "python", + "sha256": "d2e41657e2d468ed7991d67ade5431a8577846118cc8b67c55cfc7b3c836145d", + "size": 4233, + "subdir": "linux-64", + "timestamp": 1508786742887, + "version": "1.65.1" + }, + "boost-1.67.0-py27_4.tar.bz2": { + "build": "py27_4", + "build_number": 4, + "depends": [ + "libboost 1.67.0 h46d08c1_4", + "py-boost 1.67.0 py27h04863e7_4", + "python >=2.7,<2.8.0a0" + ], + "license": "Boost-1.0", + "md5": "aaad55a104448e51e157d6d4db8cbcc4", + "name": "boost", + "namespace": "python", + "sha256": "da675751188b7f79604f4bf946cbc34b9e8b8d022aa6ce887b3e7bcf948634b6", + "size": 11771, + "subdir": "linux-64", + "timestamp": 1530782276179, + "version": "1.67.0" + }, + "boost-1.67.0-py35_4.tar.bz2": { + "build": "py35_4", + "build_number": 4, + "depends": [ + "libboost 1.67.0 h46d08c1_4", + "py-boost 1.67.0 py35h04863e7_4", + "python >=3.5,<3.6.0a0" + ], + "license": "Boost-1.0", + "md5": "5c626b0052aa2151c331a03c910b84d9", + "name": "boost", + "namespace": "python", + "sha256": "88252f5152ca0251844d42bd9ac5cf5e2fba53fd846ba748f109baa09e20ba5f", + "size": 12907, + "subdir": "linux-64", + "timestamp": 1534944651149, + "version": "1.67.0" + }, + "boost-1.67.0-py36_4.tar.bz2": { + "build": "py36_4", + "build_number": 4, + "depends": [ + "libboost 1.67.0 h46d08c1_4", + "py-boost 1.67.0 py36h04863e7_4", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "9b0552db8736ff42614213ca1a5bd0b1", + "name": "boost", + "namespace": "python", + "sha256": "efe872dfe5eb988131d05e5194ee1457867afed33c370580a3bb713654a32fff", + "size": 11766, + "subdir": "linux-64", + "timestamp": 1530782283623, + "version": "1.67.0" + }, + "boost-1.67.0-py37_4.tar.bz2": { + "build": "py37_4", + "build_number": 4, + "depends": [ + "libboost 1.67.0 h46d08c1_4", + "py-boost 1.67.0 py37h04863e7_4", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "960ffbde8755a8dfb1d6c12030bbc313", + "name": "boost", + "namespace": "python", + "sha256": "d06805e7e99ed2e23faec05c26cd13ea0d9a5d4951bbb1e0ef81f03705015931", + "size": 11768, + "subdir": "linux-64", + "timestamp": 1530782291004, + "version": "1.67.0" + }, + "boost-1.71.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "libboost 1.71.0 haf77d95_0", + "py-boost 1.71.0 py310h00e6091_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Boost-1.0", + "md5": "1865ecf1c207e2cd85e3dbb5ef6237cf", + "name": "boost", + "namespace": "python", + "sha256": "5fa934899b192e9b1063b96f588609b2c8cace313934129571d5474e724a91c3", + "size": 15569, + "subdir": "linux-64", + "timestamp": 1640823530363, + "version": "1.71.0" + }, + "boost-1.71.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "libboost 1.71.0 haf77d95_1", + "py-boost 1.71.0 py310h00e6091_1", + "python >=3.10,<3.11.0a0" + ], + "license": "Boost-1.0", + "md5": "4cb086eb7d7fd77186e5d42f34dcdbf7", + "name": "boost", + "namespace": "python", + "sha256": "8ce2f0dd5d741b0e42e1df28691bc2596447c7f8025aa0528fee51ec5f862a63", + "size": 15902, + "subdir": "linux-64", + "timestamp": 1642425249226, + "version": "1.71.0" + }, + "boost-1.71.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libboost 1.71.0 h97c9712_0", + "py-boost 1.71.0 py36h0573a6f_0", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "6355fcfe8aaacd4b5e4c6fb889f92853", + "name": "boost", + "namespace": "python", + "sha256": "c3e63197265560b26fdb565cb6c1165c3c933e0cea5daef607e18e798601b10c", + "size": 34980, + "subdir": "linux-64", + "timestamp": 1597486065584, + "version": "1.71.0" + }, + "boost-1.71.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libboost 1.71.0 h97c9712_0", + "py-boost 1.71.0 py37h0573a6f_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "d8b872c681321a578a9f2a249837fc52", + "name": "boost", + "namespace": "python", + "sha256": "40e4ad0654c5c788dd80b2c15687292a6a7905ab6a85ec54f76db21a76be1681", + "size": 34994, + "subdir": "linux-64", + "timestamp": 1597486071955, + "version": "1.71.0" + }, + "boost-1.71.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "libboost 1.71.0 haf77d95_1", + "py-boost 1.71.0 py37h51133e4_1", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "9654ad77e2ad21bcfe952f53b8dedff5", + "name": "boost", + "namespace": "python", + "sha256": "81d2cabaca6295dfb41cfa87c26f1f4445ce063d676edb960b2d6de3c643b68d", + "size": 15837, + "subdir": "linux-64", + "timestamp": 1642425237764, + "version": "1.71.0" + }, + "boost-1.71.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "libboost 1.71.0 h97c9712_0", + "py-boost 1.71.0 py38h962f231_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "ede6b0ed392a457a73b29f746ca1dab2", + "name": "boost", + "namespace": "python", + "sha256": "c9fe814393624d594003751f5f48ca4e95531f455e5c4d2dbc7defc11f70a95c", + "size": 13677, + "subdir": "linux-64", + "timestamp": 1572611055949, + "version": "1.71.0" + }, + "boost-1.71.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "libboost 1.71.0 haf77d95_1", + "py-boost 1.71.0 py38h51133e4_1", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "a3bf96aa23ca99dacc16880377b42138", + "name": "boost", + "namespace": "python", + "sha256": "19efd2a41f6dddf0d2bca3fc652f96a691cdb7e931a6067d07b9013ef0b057a4", + "size": 15846, + "subdir": "linux-64", + "timestamp": 1642425254700, + "version": "1.71.0" + }, + "boost-1.71.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "libboost 1.71.0 haf77d95_1", + "py-boost 1.71.0 py39h51133e4_1", + "python >=3.9,<3.10.0a0" + ], + "license": "Boost-1.0", + "md5": "ccf1ca85389322ff86a9038f09da807f", + "name": "boost", + "namespace": "python", + "sha256": "7d6b21428a1c581736442c707579138336a2c3aa787351fd5a5c91d846f1db49", + "size": 15853, + "subdir": "linux-64", + "timestamp": 1642425243380, + "version": "1.71.0" + }, + "boost-1.73.0-py310h06a4308_12.tar.bz2": { + "build": "py310h06a4308_12", + "build_number": 12, + "depends": [ + "libboost 1.73.0 h28710b8_12", + "py-boost 1.73.0 py310h00e6091_12", + "python >=3.10,<3.11.0a0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "029a105bb131f032ca5155f93e1d1680", + "name": "boost", + "namespace": "python", + "sha256": "9e1465b3d32f19e58f213d6d4ab9e27da74f7ec8fb2c4a8b9da900d3c72bc8e9", + "size": 16817, + "subdir": "linux-64", + "timestamp": 1655880137540, + "version": "1.73.0" + }, + "boost-1.73.0-py36_10.tar.bz2": { + "build": "py36_10", + "build_number": 10, + "depends": [ + "libboost 1.73.0 h37e3b65_10", + "py-boost 1.73.0 py36h962f231_10", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "e75801618e46186d73d57ae0613caca4", + "name": "boost", + "namespace": "python", + "sha256": "98fbb66c37cdbb8857cf8bb753c94581c727ebecdc5b6dea51b237d16e2c6c4d", + "size": 29750, + "subdir": "linux-64", + "timestamp": 1601386287546, + "version": "1.73.0" + }, + "boost-1.73.0-py36_11.tar.bz2": { + "build": "py36_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 h37e3b65_11", + "py-boost 1.73.0 py36h962f231_11", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "7cb8d21debc7e5a16476dfbdaa6f802c", + "name": "boost", + "namespace": "python", + "sha256": "be2b621dfa49662fe4c6b40a344346f6eb95807dfc9af11a3e2d78620ed38e55", + "size": 29878, + "subdir": "linux-64", + "timestamp": 1601470809852, + "version": "1.73.0" + }, + "boost-1.73.0-py36h06a4308_11.tar.bz2": { + "build": "py36h06a4308_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 h3ff78a5_11", + "py-boost 1.73.0 py36ha9443f7_11", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "c24968f1bd6012efe2c65d77323bbb76", + "name": "boost", + "namespace": "python", + "sha256": "9ce965f34e0a4f9bd7230490fe322d294c8b773e0ef7bf921b595da2bec8134c", + "size": 24829, + "subdir": "linux-64", + "timestamp": 1611677531747, + "version": "1.73.0" + }, + "boost-1.73.0-py37_10.tar.bz2": { + "build": "py37_10", + "build_number": 10, + "depends": [ + "libboost 1.73.0 h37e3b65_10", + "py-boost 1.73.0 py37h962f231_10", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "8aa5a70bda880e8e165f98e901da26ca", + "name": "boost", + "namespace": "python", + "sha256": "bb37040cdc8c3a9e4b8a22913ae7d108eeb1a0c65c52bc7b5ff15ff72541d2e5", + "size": 29725, + "subdir": "linux-64", + "timestamp": 1601386276547, + "version": "1.73.0" + }, + "boost-1.73.0-py37_11.tar.bz2": { + "build": "py37_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 h37e3b65_11", + "py-boost 1.73.0 py37h962f231_11", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "7508463f7d032800547366b32a4509ff", + "name": "boost", + "namespace": "python", + "sha256": "acd0e51564aecc4e7b6171300d3a84d4a02b00d2956b07b220344ab0f1307836", + "size": 29883, + "subdir": "linux-64", + "timestamp": 1601470821053, + "version": "1.73.0" + }, + "boost-1.73.0-py37h06a4308_11.tar.bz2": { + "build": "py37h06a4308_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 h3ff78a5_11", + "py-boost 1.73.0 py37ha9443f7_11", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "90d272c1efd231ff5dae94fa138a7eed", + "name": "boost", + "namespace": "python", + "sha256": "4283280a5d7d556e19115be387fcfc366f6ab6187da675c355cc475a04d29a46", + "size": 24862, + "subdir": "linux-64", + "timestamp": 1611677510190, + "version": "1.73.0" + }, + "boost-1.73.0-py37h06a4308_12.tar.bz2": { + "build": "py37h06a4308_12", + "build_number": 12, + "depends": [ + "libboost 1.73.0 h28710b8_12", + "py-boost 1.73.0 py37h51133e4_12", + "python >=3.7,<3.8.0a0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "edfa7c6b7f0cfdcb5d5ae5658b49fa6e", + "name": "boost", + "namespace": "python", + "sha256": "dfa3186e26ebe6dc99762a705a1a7e10b4723c4c03886d36ec0cea27f6408e1c", + "size": 16818, + "subdir": "linux-64", + "timestamp": 1655880132198, + "version": "1.73.0" + }, + "boost-1.73.0-py38_10.tar.bz2": { + "build": "py38_10", + "build_number": 10, + "depends": [ + "libboost 1.73.0 h37e3b65_10", + "py-boost 1.73.0 py38h962f231_10", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "2f8698d5f8d4de350fdfef2991ac4026", + "name": "boost", + "namespace": "python", + "sha256": "81b20e3c4a387b39f1ee92a3b7a4c8ddcc8ab014a4a1750312fa04256ea9fafe", + "size": 29750, + "subdir": "linux-64", + "timestamp": 1601386282049, + "version": "1.73.0" + }, + "boost-1.73.0-py38_11.tar.bz2": { + "build": "py38_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 h37e3b65_11", + "py-boost 1.73.0 py38h962f231_11", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "16e8a51038f5bed5c22435751c5d267a", + "name": "boost", + "namespace": "python", + "sha256": "5d934055a0c5b77d5a49863c717bfb24f729209c16b8c0b2eeafdd710f259d24", + "size": 29852, + "subdir": "linux-64", + "timestamp": 1601470815576, + "version": "1.73.0" + }, + "boost-1.73.0-py38h06a4308_11.tar.bz2": { + "build": "py38h06a4308_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 h3ff78a5_11", + "py-boost 1.73.0 py38ha9443f7_11", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "6fa2e35e18e4999bad070c959d5fd5b3", + "name": "boost", + "namespace": "python", + "sha256": "84c00ef67307005f17af1682680a9bb16bff49e9367d2bd8e54657b974fc58cb", + "size": 24840, + "subdir": "linux-64", + "timestamp": 1611677521145, + "version": "1.73.0" + }, + "boost-1.73.0-py38h06a4308_12.tar.bz2": { + "build": "py38h06a4308_12", + "build_number": 12, + "depends": [ + "libboost 1.73.0 h28710b8_12", + "py-boost 1.73.0 py38h51133e4_12", + "python >=3.8,<3.9.0a0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "de30eef05f200240fd84417bc5b93588", + "name": "boost", + "namespace": "python", + "sha256": "e331c4e5755a507fadc1ef3ee7a10bacf7bc3af70ce9413b72b73f45736046e8", + "size": 16811, + "subdir": "linux-64", + "timestamp": 1655880121901, + "version": "1.73.0" + }, + "boost-1.73.0-py39h06a4308_11.tar.bz2": { + "build": "py39h06a4308_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 h3ff78a5_11", + "py-boost 1.73.0 py39ha9443f7_11", + "python >=3.9,<3.10.0a0" + ], + "license": "Boost-1.0", + "md5": "83440675cae40a21ea2be74b5e8068f1", + "name": "boost", + "namespace": "python", + "sha256": "c10223c1c4d10747d4bb4aabf12ff58a280142ff1bdfc021d79cb90dec6c6098", + "size": 24833, + "subdir": "linux-64", + "timestamp": 1611677542448, + "version": "1.73.0" + }, + "boost-1.73.0-py39h06a4308_12.tar.bz2": { + "build": "py39h06a4308_12", + "build_number": 12, + "depends": [ + "libboost 1.73.0 h28710b8_12", + "py-boost 1.73.0 py39h51133e4_12", + "python >=3.9,<3.10.0a0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "67863414bb739c98adbda4393eca95a4", + "name": "boost", + "namespace": "python", + "sha256": "e654449cddd96c7bd3bf5ef223b2f50f554016bb4e33940a13693bfb6ded4f94", + "size": 16818, + "subdir": "linux-64", + "timestamp": 1655880127215, + "version": "1.73.0" + }, + "boost-cpp-1.65.1-h14c3975_4.tar.bz2": { + "build": "h14c3975_4", + "build_number": 4, + "depends": [ + "libboost 1.65.1 habcd387_4", + "libgcc-ng >=7.2.0" + ], + "license": "Boost-1.0", + "md5": "289d1f52d52e62367f5a5631defb6dfa", + "name": "boost-cpp", + "sha256": "68b7a26ada670d930ec0174a0bd9042b59f796382435d7ffc135e457f575b974", + "size": 4064, + "subdir": "linux-64", + "timestamp": 1515095238142, + "version": "1.65.1" + }, + "boost-cpp-1.65.1-h2690925_3.tar.bz2": { + "build": "h2690925_3", + "build_number": 3, + "depends": [ + "libboost 1.65.1 h4055789_3" + ], + "license": "Boost-1.0", + "md5": "3c60c36f023f4b9208cea8b650f67001", + "name": "boost-cpp", + "sha256": "daddf1db9b3bcf2a161be48d0653db72761a51558d07a89da4f733666c96e47a", + "size": 3893, + "subdir": "linux-64", + "timestamp": 1508786615175, + "version": "1.65.1" + }, + "boost-cpp-1.67.0-h14c3975_4.tar.bz2": { + "build": "h14c3975_4", + "build_number": 4, + "depends": [ + "libboost 1.67.0 h46d08c1_4", + "libgcc-ng >=7.2.0" + ], + "license": "Boost-1.0", + "md5": "94f0d544fd1ccc7712b7f46473ea9319", + "name": "boost-cpp", + "sha256": "28151dbccf523bfa2a90b00e9ed5fb02cad44ace7e3491c4bd181b770812c602", + "size": 11720, + "subdir": "linux-64", + "timestamp": 1530782098829, + "version": "1.67.0" + }, + "boost-cpp-1.71.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libboost 1.71.0 h97c9712_0", + "libgcc-ng >=7.3.0" + ], + "license": "Boost-1.0", + "md5": "b2cc443ffe869d7d7c6a4ac400020db1", + "name": "boost-cpp", + "sha256": "f99fb77e69b3cfce67f3df89ec5bf90ff587a1139a390667eb57aeead000fb62", + "size": 13597, + "subdir": "linux-64", + "timestamp": 1572610585349, + "version": "1.71.0" + }, + "boost-cpp-1.71.0-h7f8727e_1.tar.bz2": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libboost 1.71.0 haf77d95_1", + "libgcc-ng >=7.5.0" + ], + "license": "Boost-1.0", + "md5": "44c207b61454497fa3d241b0f40fbaac", + "name": "boost-cpp", + "sha256": "d8d4fa884ee4ab0373d8fe0fe058b30ce761bba71c392303ad7783dbcfa96586", + "size": 15878, + "subdir": "linux-64", + "timestamp": 1642425076791, + "version": "1.71.0" + }, + "boost-cpp-1.73.0-h14c3975_10.tar.bz2": { + "build": "h14c3975_10", + "build_number": 10, + "depends": [ + "libboost 1.73.0 hf484d3e_10", + "libgcc-ng >=7.3.0" + ], + "license": "Boost-1.0", + "md5": "760c9011e4f483715e9d757612a87319", + "name": "boost-cpp", + "sha256": "9bc3fc172340b2bc8b723285dce324426d6762a5fd4ec61b911c00dec4f5f9a4", + "size": 23673, + "subdir": "linux-64", + "timestamp": 1601386811313, + "version": "1.73.0" + }, + "boost-cpp-1.73.0-h14c3975_11.tar.bz2": { + "build": "h14c3975_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 hf484d3e_11", + "libgcc-ng >=7.3.0" + ], + "license": "Boost-1.0", + "md5": "254a7759d301162664312da8fc2be81e", + "name": "boost-cpp", + "sha256": "2bc2f956db17dc166f2fa037c6985ed046fb26b06ec45cfe4123a03b2bc8adb1", + "size": 23738, + "subdir": "linux-64", + "timestamp": 1601471332071, + "version": "1.73.0" + }, + "boost-cpp-1.73.0-h27cfd23_11.tar.bz2": { + "build": "h27cfd23_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 h3ff78a5_11", + "libgcc-ng >=7.3.0" + ], + "license": "Boost-1.0", + "md5": "09641ed5d9055c5fe4e326ae1516b514", + "name": "boost-cpp", + "sha256": "22618c69b5ccb053932032e6ae383043b3f421321f59eadb9fc642ffcb19e4f8", + "size": 24776, + "subdir": "linux-64", + "timestamp": 1611677121434, + "version": "1.73.0" + }, + "boost-cpp-1.73.0-h7b6447c_10.tar.bz2": { + "build": "h7b6447c_10", + "build_number": 10, + "depends": [ + "libboost 1.73.0 h37e3b65_10", + "libgcc-ng >=7.3.0" + ], + "license": "Boost-1.0", + "md5": "dc847f1ee002118df5d4c536354395f1", + "name": "boost-cpp", + "sha256": "cbe2e31cac0f661b8841a68f1b9adc0ed88c5b1565b723af650262f045066df7", + "size": 29732, + "subdir": "linux-64", + "timestamp": 1601386077245, + "version": "1.73.0" + }, + "boost-cpp-1.73.0-h7b6447c_11.tar.bz2": { + "build": "h7b6447c_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 h37e3b65_11", + "libgcc-ng >=7.3.0" + ], + "license": "Boost-1.0", + "md5": "f1a85fd556af4454322af247e5c96410", + "name": "boost-cpp", + "sha256": "32b73903290507f00d4015a0d0fe7b09f2bb260b04a56383d69b4907d2e1edb3", + "size": 29805, + "subdir": "linux-64", + "timestamp": 1601470583445, + "version": "1.73.0" + }, + "boost-cpp-1.73.0-h7f8727e_12.tar.bz2": { + "build": "h7f8727e_12", + "build_number": 12, + "depends": [ + "libboost 1.73.0 h28710b8_12", + "libgcc-ng >=7.5.0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "fd3834554f6e4863871ab9677997fbef", + "name": "boost-cpp", + "sha256": "1239af47b8f5ca5f5f40af1056949c4dfcbdfb690d6f83dacf77d01ebbfe7b4a", + "size": 16854, + "subdir": "linux-64", + "timestamp": 1655879868222, + "version": "1.73.0" + }, + "boost_mp11-1.79.0-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "constrains": [ + "boost-cpp <0a0" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSL-1.0", + "license_family": "Other", + "md5": "eb9a2e7dcbc2ccabf6bbaaae2277e7a3", + "name": "boost_mp11", + "sha256": "8d3d34c180442ac2f00ca25286523a5a86ccada61e0866b6fc20cf01ce65014b", + "size": 25228, + "subdir": "linux-64", + "timestamp": 1659013173912, + "version": "1.79.0" + }, + "boto-2.48.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d1c3bb2f1a06430112f3d394e7b0f86a", + "name": "boto", + "sha256": "bd9fb5cbc00173b44c60839e6beed01f0e466a8e3bdb659ac59744d7ceb94ce7", + "size": 1509277, + "subdir": "linux-64", + "timestamp": 1530781166098, + "version": "2.48.0" + }, + "boto-2.48.0-py27h9556ac2_1.tar.bz2": { + "build": "py27h9556ac2_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b8f81862c10d7ac4d259389f1b876570", + "name": "boto", + "sha256": "bcafb89a9deddeab5b0b3fbb26979a7a82a4fff7488eb914a18ebeef8c63a03d", + "size": 1508641, + "subdir": "linux-64", + "timestamp": 1505740882116, + "version": "2.48.0" + }, + "boto-2.48.0-py35h2cfd601_1.tar.bz2": { + "build": "py35h2cfd601_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "9ea18914d517d79d57d65745b1ae62db", + "name": "boto", + "sha256": "b506c93df365ff13f1347808e6822bf09faf6b9733350f92e344080bac7b602a", + "size": 1579844, + "subdir": "linux-64", + "timestamp": 1505740921493, + "version": "2.48.0" + }, + "boto-2.48.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "81fdc918fe0c4db760e2dcb95708f684", + "name": "boto", + "sha256": "35f75554fe3b6a93e693d8ee83f0a3ebfa8d0c7b4d240d66bb6734e231a28d01", + "size": 1600385, + "subdir": "linux-64", + "timestamp": 1530781214525, + "version": "2.48.0" + }, + "boto-2.48.0-py36h6e4cd66_1.tar.bz2": { + "build": "py36h6e4cd66_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c71a26177d67e10ef24696624d0672bd", + "name": "boto", + "sha256": "eed44fbeb42f3fabc87d31f6fe886de66f6d70752ffdb09a4a299c28745ffd0d", + "size": 1600140, + "subdir": "linux-64", + "timestamp": 1505740960874, + "version": "2.48.0" + }, + "boto-2.48.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4959ed1ccc5d328c2f866aa081eb9f3b", + "name": "boto", + "sha256": "7fd7e0b0259eb4cd24962e18370e9c09ce7c07654a909f1290293cfa3ff42cbd", + "size": 1601942, + "subdir": "linux-64", + "timestamp": 1530781261443, + "version": "2.48.0" + }, + "boto-2.49.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "41455c0d4bd5b2017b58ae4b072f5dda", + "name": "boto", + "sha256": "ef9e68941d5af36c1f0b92dade5f053868bd91ca74ee541d36fd32d9fdb76cab", + "size": 1512423, + "subdir": "linux-64", + "timestamp": 1532524715871, + "version": "2.49.0" + }, + "boto-2.49.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "7699a0e4c923cecb81afd95f907cc8e5", + "name": "boto", + "sha256": "70f846cd7b4cfafde68b1cd05918d8ef2a8e8f5ef9a1f2e2df18403e9707b17a", + "size": 1663508, + "subdir": "linux-64", + "timestamp": 1640788595428, + "version": "2.49.0" + }, + "boto-2.49.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "0257c67f37afbc03f1f3f5f41b363f9e", + "name": "boto", + "sha256": "785f221d2af26f6e87a741123916173b7eecf9e2cf94fb20bba0e0775209892a", + "size": 1972842, + "subdir": "linux-64", + "timestamp": 1676906903510, + "version": "2.49.0" + }, + "boto-2.49.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "d2704ed8f9d0a1b6399dcdb9c06f3a5a", + "name": "boto", + "sha256": "866b09c677db40597623528ade91941accafd5fdd26281660078b9c061122656", + "size": 1584362, + "subdir": "linux-64", + "timestamp": 1532524805640, + "version": "2.49.0" + }, + "boto-2.49.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "740e479378c3f94e41fe080433b6d373", + "name": "boto", + "sha256": "f5afe376e372cec76d8e1ed8a0c0edc204712620e997dc91539f24da36181a98", + "size": 1604669, + "subdir": "linux-64", + "timestamp": 1532524714494, + "version": "2.49.0" + }, + "boto-2.49.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1714cf42b6125c9653cbf833ce2c7037", + "name": "boto", + "sha256": "7d0bdbef77f6c28cc3eeda39daec47d38625c18582e5d79f3c50447f92d1741e", + "size": 1605274, + "subdir": "linux-64", + "timestamp": 1532524881080, + "version": "2.49.0" + }, + "boto-2.49.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "69daacfc24797526adc8300523e58bd8", + "name": "boto", + "sha256": "13a154757209d6a9a5772e60b925ec1a294c7ca538ab573a3d8ad857a4ab3770", + "size": 1645513, + "subdir": "linux-64", + "timestamp": 1572357295863, + "version": "2.49.0" + }, + "boto-2.49.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "f381fe2404b05383e232ba8bc3c8c67b", + "name": "boto", + "sha256": "5bff7f01dae8b9ce59b8ba4b8ada2929541607af6ec508f1ae6976033f6a6b15", + "size": 1645666, + "subdir": "linux-64", + "timestamp": 1607007491079, + "version": "2.49.0" + }, + "boto3-1.24.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.2,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.10,<3.11.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9d822c07332d88d3cbb58179b56b5364", + "name": "boto3", + "sha256": "9d376947d868e2a73832c3d35bb7839b43e2601c661d7c8a9f8082f7780f0a6a", + "size": 133699, + "subdir": "linux-64", + "timestamp": 1654534691194, + "version": "1.24.2" + }, + "boto3-1.24.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.2,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.11,<3.12.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a35afd5e6d603ec62818105f7b086e91", + "name": "boto3", + "sha256": "fedc5d0188a4065ab189f717c63b90cefbd6b50e25e30a0f8d027e2befaf79fc", + "size": 159938, + "subdir": "linux-64", + "timestamp": 1676830122666, + "version": "1.24.2" + }, + "boto3-1.24.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.2,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "82b45c28a0585b6bf5d43a804f0d6825", + "name": "boto3", + "sha256": "ed4a9e076e2bffaed2e70a10d92da35af71885e284dad5985d99deadba34e920", + "size": 129765, + "subdir": "linux-64", + "timestamp": 1654534652033, + "version": "1.24.2" + }, + "boto3-1.24.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.2,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.8,<3.9.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c7ac20a4767c6b549b6065c8f3ffa237", + "name": "boto3", + "sha256": "93d2477d61bfe23bcce2656428ab383847890806c9dc092a68ac7f02f23ceead", + "size": 130300, + "subdir": "linux-64", + "timestamp": 1654534623511, + "version": "1.24.2" + }, + "boto3-1.24.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.2,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.9,<3.10.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6447a015b0dd477069a0d0679f5118d3", + "name": "boto3", + "sha256": "69e6bb05c2a1742ffa3d50ce59f173867bfda573ede8d1595f440d545de2ec07", + "size": 130421, + "subdir": "linux-64", + "timestamp": 1654534720010, + "version": "1.24.2" + }, + "boto3-1.24.28-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.28,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.10,<3.11.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "413256b3adc3a4f35e30df2235151abc", + "name": "boto3", + "sha256": "cc5b9913c7c041ae0ee0a1b7531b358f531dcfdf835b9138c2c5ed39bc95221d", + "size": 130851, + "subdir": "linux-64", + "timestamp": 1657820151872, + "version": "1.24.28" + }, + "boto3-1.24.28-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.28,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.11,<3.12.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8e0d61b6c4f010a1b035ba57f248354d", + "name": "boto3", + "sha256": "4af388c526823d9294e53319769440fd36301475d235eb9f3ae320cf4556e9ad", + "size": 146185, + "subdir": "linux-64", + "timestamp": 1679335497387, + "version": "1.24.28" + }, + "boto3-1.24.28-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.28,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "45bcddba20abd5811ea4cc0d8e617dea", + "name": "boto3", + "sha256": "819784125f12a22c899bf5a1fcda438ab8919feda5d302c803b9ad3377e44039", + "size": 133025, + "subdir": "linux-64", + "timestamp": 1657820238000, + "version": "1.24.28" + }, + "boto3-1.24.28-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.28,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.8,<3.9.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eea597598f91b360740e301e29a91959", + "name": "boto3", + "sha256": "95d4ab4f64eea61fa5244f861a1a7c562bf407f8bdc7622c0c3b09ff72ff35a1", + "size": 130158, + "subdir": "linux-64", + "timestamp": 1657820180517, + "version": "1.24.28" + }, + "boto3-1.24.28-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.28,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.9,<3.10.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "33a155af681e1938c00bb3f3cfecdf84", + "name": "boto3", + "sha256": "11b0d541b31d6ad93a03af5a7fc12ca54a73aae911622009f7aad45e7915b4d1", + "size": 133356, + "subdir": "linux-64", + "timestamp": 1657820209526, + "version": "1.24.28" + }, + "boto3-1.4.7-py27h11b3982_0.tar.bz2": { + "build": "py27h11b3982_0", + "build_number": 0, + "depends": [ + "botocore >=1.7.0,<1.8.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "98513a1dbd2f90b7bcf95c06f03deada", + "name": "boto3", + "sha256": "74f5f656a36b543e6a5d61b6a84bd704a73d95e4a718e876fa84ebd6ae2ae908", + "size": 106354, + "subdir": "linux-64", + "timestamp": 1505957017930, + "version": "1.4.7" + }, + "boto3-1.4.7-py35h2161c00_0.tar.bz2": { + "build": "py35h2161c00_0", + "build_number": 0, + "depends": [ + "botocore >=1.7.0,<1.8.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9b765ef77f30ee3e78d60b4bf86024da", + "name": "boto3", + "sha256": "f532efa9a2594ea1f4f601ff991ff5cd536b6b5ca5531c6926caaf7f385af4fb", + "size": 109349, + "subdir": "linux-64", + "timestamp": 1505957034722, + "version": "1.4.7" + }, + "boto3-1.4.7-py36h4cc92d5_0.tar.bz2": { + "build": "py36h4cc92d5_0", + "build_number": 0, + "depends": [ + "botocore >=1.7.0,<1.8.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6bd1aa261430b7da0129f283808cef4f", + "name": "boto3", + "sha256": "9de50d4f4610a87a9184072e55eee72e8687a8f17fca245d5b9025080c0c0ccb", + "size": 108875, + "subdir": "linux-64", + "timestamp": 1505957051488, + "version": "1.4.7" + }, + "boto3-1.4.8-py27h67bc657_0.tar.bz2": { + "build": "py27h67bc657_0", + "build_number": 0, + "depends": [ + "botocore >=1.8.0,<1.9.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c2e4dd3f3d485e51854269da9e46717a", + "name": "boto3", + "sha256": "5b9a324d2a96da83f55e4a02d02177fd6c0c931942234ab35220617c8b48de9a", + "size": 106867, + "subdir": "linux-64", + "timestamp": 1512061373088, + "version": "1.4.8" + }, + "boto3-1.4.8-py35h4658e5d_0.tar.bz2": { + "build": "py35h4658e5d_0", + "build_number": 0, + "depends": [ + "botocore >=1.8.0,<1.9.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9b16484ddf1659418590ef72eb78fbac", + "name": "boto3", + "sha256": "42de6216e67df28403b7202fd66ee5c4ac190d8203e7738c27d6181ae895c6ba", + "size": 109907, + "subdir": "linux-64", + "timestamp": 1512061379255, + "version": "1.4.8" + }, + "boto3-1.4.8-py36h0bb4d74_0.tar.bz2": { + "build": "py36h0bb4d74_0", + "build_number": 0, + "depends": [ + "botocore >=1.8.0,<1.9.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "771c4532986f9444b23e79eedc1f0706", + "name": "boto3", + "sha256": "97badc69acf7640e4d894d920780b550181f6806444473200ab8117ff5005788", + "size": 109530, + "subdir": "linux-64", + "timestamp": 1512061375880, + "version": "1.4.8" + }, + "boto3-1.5.32-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.8.46,<1.9.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f6b1fc4538315209d7e547c5a913930d", + "name": "boto3", + "sha256": "1bc72f958db8ad89353dd5d1be4e17cc43cdc249cbbf4e71c7faa78c2006f641", + "size": 106631, + "subdir": "linux-64", + "timestamp": 1519189157328, + "version": "1.5.32" + }, + "boto3-1.5.32-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "botocore >=1.8.46,<1.9.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2422eba76b04eed4d45bffc2432a467a", + "name": "boto3", + "sha256": "b36e39dcb1180bd24bf089a3b2510893942ea3e72a54c954ec3d8b9d6b33f3c0", + "size": 109579, + "subdir": "linux-64", + "timestamp": 1519189191788, + "version": "1.5.32" + }, + "boto3-1.5.32-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.8.46,<1.9.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "aebe3d336d73c7dbe0bd742a8a023d81", + "name": "boto3", + "sha256": "c4aa505516bd9a4f3335e70a6cb6af61ad1e35929803fe497c40ade8b2e0c469", + "size": 109186, + "subdir": "linux-64", + "timestamp": 1519189155479, + "version": "1.5.32" + }, + "boto3-1.6.18-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.9.18,<1.10.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "45a1331473ca818e30e949d8cd3fccb8", + "name": "boto3", + "sha256": "ef3593e8f0343b7004aae461ebfdd72c435b22bcd70f6b1686aff32fdcf505c6", + "size": 106745, + "subdir": "linux-64", + "timestamp": 1522277941071, + "version": "1.6.18" + }, + "boto3-1.6.18-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "botocore >=1.9.18,<1.10.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c7c9f922d1bdaaa6fd80e311f28bd7b3", + "name": "boto3", + "sha256": "f99aedc34d259127124c7d730d9bddc92e9be92a5dae889417845655402101ac", + "size": 109693, + "subdir": "linux-64", + "timestamp": 1522278028398, + "version": "1.6.18" + }, + "boto3-1.6.18-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.9.18,<1.10.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "38a45717a99beff3a05da247e3562e3c", + "name": "boto3", + "sha256": "d313e6f48f51f52b914327d18fe912aef71a5c3f9e2fafbc74b50342c71edd22", + "size": 109251, + "subdir": "linux-64", + "timestamp": 1522277961479, + "version": "1.6.18" + }, + "boto3-1.7.24-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.24,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9ecce1b9902d888498a15ed784f2f21b", + "name": "boto3", + "sha256": "076bd451f3cbe03951a05d7ee1961bb04717bce0ac52ac442cbf92644b9a93ee", + "size": 110124, + "subdir": "linux-64", + "timestamp": 1526915374842, + "version": "1.7.24" + }, + "boto3-1.7.24-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.24,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9322907297549df0b9d405ecbfea87ee", + "name": "boto3", + "sha256": "b071928574c418f13f5029e4f655bc6fb7499ba2d3d0cfb66e0915f30fb5f8cb", + "size": 112911, + "subdir": "linux-64", + "timestamp": 1526915468300, + "version": "1.7.24" + }, + "boto3-1.7.24-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.24,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dbddbdd1ef8a33041d00d26ae8c869a3", + "name": "boto3", + "sha256": "e1c9f074ffb04c52ae0851392ae5ba9b00da1cdf745e66e902748ca60d936aac", + "size": 112527, + "subdir": "linux-64", + "timestamp": 1526916099021, + "version": "1.7.24" + }, + "boto3-1.7.32-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.32,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "aea770a5229beaf2fa42eff875a43271", + "name": "boto3", + "sha256": "68d1668941cdd355860292191b8df41b5d9d4b611a9e15652c27e36bed13ab80", + "size": 110163, + "subdir": "linux-64", + "timestamp": 1528209128653, + "version": "1.7.32" + }, + "boto3-1.7.32-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.32,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "faa0e8d7e46d01c22361c46e128aaa9b", + "name": "boto3", + "sha256": "7ae1790d6563d20c2af36d1d0c639213e4d9f14260a37739d4afd919d399f811", + "size": 112962, + "subdir": "linux-64", + "timestamp": 1528209166051, + "version": "1.7.32" + }, + "boto3-1.7.32-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.32,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8e1b6d9f548486933d4f79904ab1cb8f", + "name": "boto3", + "sha256": "c6b0687abc70bc48380222fe2c8a7ce61dd275c025fb8544beb67072b7dd885f", + "size": 112600, + "subdir": "linux-64", + "timestamp": 1528209078931, + "version": "1.7.32" + }, + "boto3-1.7.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.4,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ca32ee059dead4bdb2152c4c7e5b0903", + "name": "boto3", + "sha256": "dc1e700384447b1db7eb010b97c6404dfd84e833a316de94a6b65dc1bf0ab60c", + "size": 106676, + "subdir": "linux-64", + "timestamp": 1523980412013, + "version": "1.7.4" + }, + "boto3-1.7.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.4,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9036f0c5e3b1e5910e115ef28761d94b", + "name": "boto3", + "sha256": "dcd24134cbaa4b21a5f7212ed95732e2b86420711bc0ff4c0304ca1b54e8307a", + "size": 109592, + "subdir": "linux-64", + "timestamp": 1523980518210, + "version": "1.7.4" + }, + "boto3-1.7.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.4,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6bd3e61615a3d38d44f70f6065559abc", + "name": "boto3", + "sha256": "9e63ef80d32398a3e4a67d3a422875e1b80cf7d5ecb46f375b335d82b33be390", + "size": 109153, + "subdir": "linux-64", + "timestamp": 1523980522738, + "version": "1.7.4" + }, + "boto3-1.7.45-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.45,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d6ce3582714cb1f974b53cf3d1dc4f22", + "name": "boto3", + "sha256": "c1774d93e5a05675f66c3cec7eb0f2db4d36b7afa6e19c6722598d4cee0cf37e", + "size": 110363, + "subdir": "linux-64", + "timestamp": 1529947509809, + "version": "1.7.45" + }, + "boto3-1.7.45-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.45,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a12e9dc693ec97e09cbaec559167935b", + "name": "boto3", + "sha256": "8f5c3ceec652502c340b220380b8bca30dda7e295e02930cf9eabd3a56e7ffc6", + "size": 113172, + "subdir": "linux-64", + "timestamp": 1529947631645, + "version": "1.7.45" + }, + "boto3-1.7.45-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.45,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c6afab65fd2b359c4eb3362de5fefe08", + "name": "boto3", + "sha256": "5a963e60815b4d82abb379b2d52e1aaff694484b5a22cfd191287fd160049a3a", + "size": 112801, + "subdir": "linux-64", + "timestamp": 1529947454834, + "version": "1.7.45" + }, + "boto3-1.7.45-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.45,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a8d7d09e6c514d0ba0b3dc8b107c472f", + "name": "boto3", + "sha256": "61800da265357c5c778e7a2443f56dc74b06a1b2ba9fd52ddf8b8b3304e7d84e", + "size": 112918, + "subdir": "linux-64", + "timestamp": 1530888154408, + "version": "1.7.45" + }, + "boto3-1.7.62-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "botocore >=1.10.62,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ebe4cef4be74ab035f216124b1a34f9e", + "name": "boto3", + "sha256": "2a807d01990ae3df02de6410425a5868e0a41f18f9095745a4e2ef2a5f57444e", + "size": 110362, + "subdir": "linux-64", + "timestamp": 1532448324153, + "version": "1.7.62" + }, + "boto3-1.7.62-py27h28b3542_1.tar.bz2": { + "build": "py27h28b3542_1", + "build_number": 1, + "depends": [ + "botocore >=1.10.62,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e25f6e8d83b254a5642a9621f467249e", + "name": "boto3", + "sha256": "b1d974c757ad730219d120ef50d02610dbc3b89714138de2200ed3f2717b7f85", + "size": 110428, + "subdir": "linux-64", + "timestamp": 1534899981853, + "version": "1.7.62" + }, + "boto3-1.7.62-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "botocore >=1.10.62,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c5b0e00727efeb80cbe096be515d2cd0", + "name": "boto3", + "sha256": "7d9220c9d8212af3ba87b7e08e12318fb26ae7cd4123040484b40c7a74bfc784", + "size": 113106, + "subdir": "linux-64", + "timestamp": 1532448365968, + "version": "1.7.62" + }, + "boto3-1.7.62-py35h28b3542_1.tar.bz2": { + "build": "py35h28b3542_1", + "build_number": 1, + "depends": [ + "botocore >=1.10.62,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "00afec2dc3a3f1b05d91adea53538482", + "name": "boto3", + "sha256": "90cdb7f6cb6757ede1c738bb8296a90d99ce0c57df41640eb49531d7a933013a", + "size": 113258, + "subdir": "linux-64", + "timestamp": 1534899929993, + "version": "1.7.62" + }, + "boto3-1.7.62-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "botocore >=1.10.62,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0a2a1a890d32c900a026f3f603fa6fec", + "name": "boto3", + "sha256": "b8624de2f00d82a4fe9540e10db977b908c4283bf9cb2524bf6c58c1d63c0a99", + "size": 112717, + "subdir": "linux-64", + "timestamp": 1532448374367, + "version": "1.7.62" + }, + "boto3-1.7.62-py36h28b3542_1.tar.bz2": { + "build": "py36h28b3542_1", + "build_number": 1, + "depends": [ + "botocore >=1.10.62,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "33437635467597c31b18f1d9052bee58", + "name": "boto3", + "sha256": "6612ab07b03413f3b9918c4b4695f5602414bffd42cd0be63196c1135930ab0d", + "size": 112843, + "subdir": "linux-64", + "timestamp": 1534900008147, + "version": "1.7.62" + }, + "boto3-1.7.62-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "botocore >=1.10.62,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2d061031a5760e9c05bd2b3174aa9dd6", + "name": "boto3", + "sha256": "86b042152fa87e9451a1044642ae3d703310507684a730d9a018c1d6ee959cd4", + "size": 112862, + "subdir": "linux-64", + "timestamp": 1532448462584, + "version": "1.7.62" + }, + "boto3-1.7.62-py37h28b3542_1.tar.bz2": { + "build": "py37h28b3542_1", + "build_number": 1, + "depends": [ + "botocore >=1.10.62,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "318c8bad12dafe59c1ffa826dd014441", + "name": "boto3", + "sha256": "63fa41b575d9b61d89cedec6c44f7a8558eb875ec1070c13bc613a637551459d", + "size": 113001, + "subdir": "linux-64", + "timestamp": 1534899956812, + "version": "1.7.62" + }, + "boto3-1.8.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.2,<1.12.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "276766f031385cf997c1aeb1ae3ee4ee", + "name": "boto3", + "sha256": "85f9f87e0cfe1d51a04cc3308ec957322cdda3a7462ea0f6ccedca338dab795f", + "size": 107366, + "subdir": "linux-64", + "timestamp": 1535493443040, + "version": "1.8.2" + }, + "boto3-1.8.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.2,<1.12.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "edc4ceeadfc754ba313b82467eba691b", + "name": "boto3", + "sha256": "e20a1e79e7e4222fa42de4e87fd8ac5f327a3fcb7e0cc113bccd45a1e5371d8a", + "size": 110198, + "subdir": "linux-64", + "timestamp": 1535493494363, + "version": "1.8.2" + }, + "boto3-1.8.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.2,<1.12.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2a35017930eb4a11235f469d0630cdfe", + "name": "boto3", + "sha256": "5732cb7843381524e0ffa2cd45bcb4205cf6152cff72f309d67cbd0c31f90c31", + "size": 109868, + "subdir": "linux-64", + "timestamp": 1535493496689, + "version": "1.8.2" + }, + "boto3-1.8.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.2,<1.12.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "80b8a07db128785acdae658d32e9cf8d", + "name": "boto3", + "sha256": "f527165293e33f94e8d70ba65906dac1534c7b358181644f60423f1ba30d87c9", + "size": 110044, + "subdir": "linux-64", + "timestamp": 1535493451622, + "version": "1.8.2" + }, + "boto3-1.9.13-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.13,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9f5b7c91447607fef80c433f935f8611", + "name": "boto3", + "sha256": "73e222fb660811e86b374c1021ea651657b552a0ea57b0d2bd2bcd2a8214dcd8", + "size": 107478, + "subdir": "linux-64", + "timestamp": 1538172968610, + "version": "1.9.13" + }, + "boto3-1.9.13-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.13,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4ef90bd523ae778ef3b5ede2ad08aa3d", + "name": "boto3", + "sha256": "7abf7b8b5130b88d2ee9f591b567c0fd8205ad6790736240639fe0ed6ced56ad", + "size": 109995, + "subdir": "linux-64", + "timestamp": 1538173036387, + "version": "1.9.13" + }, + "boto3-1.9.13-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.13,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c7d130d6bbc8e8ac5d568963dfebb23b", + "name": "boto3", + "sha256": "ffd60fd6fa7f01818c978da27d1552a9bf5bba3879dc33b3fe35f9670b82faf2", + "size": 110145, + "subdir": "linux-64", + "timestamp": 1538172966493, + "version": "1.9.13" + }, + "boto3-1.9.21-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.21,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bc97f796f27c6d1fe7c7ba6208456dca", + "name": "boto3", + "sha256": "0a94a7b71619f63dd0e296116ce3a3661a1e7de28fc0943699312112c7b442c9", + "size": 107542, + "subdir": "linux-64", + "timestamp": 1539637016762, + "version": "1.9.21" + }, + "boto3-1.9.21-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.21,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "da114b9ce475d4c4a9ad86b7653d3393", + "name": "boto3", + "sha256": "6f61a890fedd06891167b0877dbde5a688ea02fe63b61101af7bead8ccc0d288", + "size": 110102, + "subdir": "linux-64", + "timestamp": 1539637037756, + "version": "1.9.21" + }, + "boto3-1.9.21-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.21,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9115165ed117611a72da6c1f591cf819", + "name": "boto3", + "sha256": "f3da1bbd514040e44e9b36cc0855e52c7ba9f62910cb0e3f72be9a7c12782089", + "size": 110163, + "subdir": "linux-64", + "timestamp": 1539637031785, + "version": "1.9.21" + }, + "boto3-1.9.35-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.35,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4524f1c15b12bc91ba7430b29a48a162", + "name": "boto3", + "sha256": "40cdd52876b64421a62ce01e62ab64a191d121eaf24d9a982da9553180f16f43", + "size": 117104, + "subdir": "linux-64", + "timestamp": 1541134353635, + "version": "1.9.35" + }, + "boto3-1.9.35-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.35,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "271ac6e7973ec6da61239c9f099dd119", + "name": "boto3", + "sha256": "eb8c7619352bac1acdf25cbe73295d8c6a5eb1a56be207a82d270a030bc4aa49", + "size": 117948, + "subdir": "linux-64", + "timestamp": 1541134439198, + "version": "1.9.35" + }, + "boto3-1.9.35-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.35,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "61d5d65de31a2d6e96378fe6d8c2e73c", + "name": "boto3", + "sha256": "ec70b66d06355247266eaf024f072b2240bec99e646849d952541ee37f7416ef", + "size": 111318, + "subdir": "linux-64", + "timestamp": 1541102824590, + "version": "1.9.35" + }, + "boto3-1.9.66-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.66,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ab89103a65c40e906def58bccff97951", + "name": "boto3", + "sha256": "13088d1444998cf0960617dd253c2200f35352867b65b342229ce127c9804dea", + "size": 117243, + "subdir": "linux-64", + "timestamp": 1545106058969, + "version": "1.9.66" + }, + "boto3-1.9.66-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.66,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cb74ac20f44c2bb4bf9caf77f9075dd8", + "name": "boto3", + "sha256": "1574b419bf5e15ae11c6a9ee0c0117490685a717c06f9a5676c22ff8c2de961a", + "size": 118353, + "subdir": "linux-64", + "timestamp": 1545106050402, + "version": "1.9.66" + }, + "boto3-1.9.66-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.66,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8d78e9eb718f062e66f2b38bb2de5a45", + "name": "boto3", + "sha256": "0e306adae41259cb300f618940e16d8f0be97a144c81d635e90dccdf20d4bc7e", + "size": 111345, + "subdir": "linux-64", + "timestamp": 1545106066876, + "version": "1.9.66" + }, + "boto3-1.9.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.7,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "36a6da61cecf1bd56e5aae810e32046b", + "name": "boto3", + "sha256": "69ba487906606490db4e800bb2fcd21de7be874ccfa18324585ac81710860c84", + "size": 107376, + "subdir": "linux-64", + "timestamp": 1537466511886, + "version": "1.9.7" + }, + "boto3-1.9.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.7,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "88814572731b4ec8500e9b03d0e99df9", + "name": "boto3", + "sha256": "422a312f3721894a741b8d7ab50ab813767d91ec86cd8649515873b24119ed9c", + "size": 110226, + "subdir": "linux-64", + "timestamp": 1537466546956, + "version": "1.9.7" + }, + "boto3-1.9.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.7,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "03459356020490ce2873dcb1d1dbd957", + "name": "boto3", + "sha256": "5b59996b224104f8cc6ea4bfc3e0b44ecd18d1eb903386c0d83c899a933028ca", + "size": 109838, + "subdir": "linux-64", + "timestamp": 1537466585628, + "version": "1.9.7" + }, + "boto3-1.9.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.7,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1c54aa3317ae84c3cb811190b416904a", + "name": "boto3", + "sha256": "c381cf912f707349d4c8828306a53d208746851a0719a6d6bca2b92d22fb0a90", + "size": 110069, + "subdir": "linux-64", + "timestamp": 1537466512452, + "version": "1.9.7" + }, + "botocore-1.10.12-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "23aeb76ca305a3767661eb99fca603b7", + "name": "botocore", + "sha256": "d26348fde1309847fb2fee18661da3c5674d6e403d54cabdd1e6f1f74ddcc7db", + "size": 3105148, + "subdir": "linux-64", + "timestamp": 1527700806086, + "version": "1.10.12" + }, + "botocore-1.10.12-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3299985dcca34fb290cee719cb2acf0e", + "name": "botocore", + "sha256": "9052fb4d956e23ded3a89c67aa17696e4cd10e088a6294a70c1e23ebb8a55554", + "size": 3175742, + "subdir": "linux-64", + "timestamp": 1527700830712, + "version": "1.10.12" + }, + "botocore-1.10.12-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1080d140589c44bab36312fd814d752c", + "name": "botocore", + "sha256": "d1ccec34f0d9581a8290d13df5ccb5c4f51914bb98c3a0c3ee57793de79364f1", + "size": 3171325, + "subdir": "linux-64", + "timestamp": 1527700758900, + "version": "1.10.12" + }, + "botocore-1.10.12-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fd6cf78592e83ded0c338be5857944da", + "name": "botocore", + "sha256": "78453c92f567cbd0679cbf6a98e4f4cae08612a3bc3cc57a148133c05ec1e64e", + "size": 3084687, + "subdir": "linux-64", + "timestamp": 1530736797146, + "version": "1.10.12" + }, + "botocore-1.10.24-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0db06c3fb56be10e23fce063f5c04cd6", + "name": "botocore", + "sha256": "010b2509ac7a3ccc9e1f49cb43ec72b87901e56f3900a9d911a89fd40544e9eb", + "size": 3115819, + "subdir": "linux-64", + "timestamp": 1526915030750, + "version": "1.10.24" + }, + "botocore-1.10.24-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "430d448b2bc93f69e07afb6567144399", + "name": "botocore", + "sha256": "4011430618b0d9af58a5a27a2f1a5ee2fc3592d544e8521d62128bfc3df00d4e", + "size": 3172043, + "subdir": "linux-64", + "timestamp": 1526915031664, + "version": "1.10.24" + }, + "botocore-1.10.24-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b047f7aaebb1b3a5808b611d34627dfe", + "name": "botocore", + "sha256": "21861f757da9f98bfb7fcd686918e4e3e46931a8e0bdc22ac368c382d31470bc", + "size": 3175685, + "subdir": "linux-64", + "timestamp": 1526915002172, + "version": "1.10.24" + }, + "botocore-1.10.32-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3507d0f15ecb325e1e38be256008f006", + "name": "botocore", + "sha256": "5e0aa602f386f47c60e94817f1558229c55820872ae1e412690008f0e8183a35", + "size": 3182638, + "subdir": "linux-64", + "timestamp": 1528208787830, + "version": "1.10.32" + }, + "botocore-1.10.32-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1447d2fbcf9acafa53f383fee73255b3", + "name": "botocore", + "sha256": "0fed86e87d02504daeef9de9e41891aadad692d23437e19ffa5bafc2ba3947f9", + "size": 3245510, + "subdir": "linux-64", + "timestamp": 1528208799920, + "version": "1.10.32" + }, + "botocore-1.10.32-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "77430889612ab10d7097c41712d288c4", + "name": "botocore", + "sha256": "e2d4d754205a8e0e76089ac2a09d2b9605dfb0a593b64869310a8cde6384941f", + "size": 3236179, + "subdir": "linux-64", + "timestamp": 1528208797049, + "version": "1.10.32" + }, + "botocore-1.10.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<2.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5f7580c3d9880a99842c18a04ae08e95", + "name": "botocore", + "sha256": "53315646f976da047a6ad25c88d023b98f038126828cb72fa0ae93a7d76a8d59", + "size": 3097346, + "subdir": "linux-64", + "timestamp": 1523980253360, + "version": "1.10.4" + }, + "botocore-1.10.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<2.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "73fbf7a94d08c48edf6fb6ca700f6f28", + "name": "botocore", + "sha256": "b191be39f75767c1f3458f92099933597bb302efdc94c9a4e4f0431ac662fc86", + "size": 3119630, + "subdir": "linux-64", + "timestamp": 1523980280442, + "version": "1.10.4" + }, + "botocore-1.10.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<2.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "eae6c859c8dad93eb1d557ccd1216a7d", + "name": "botocore", + "sha256": "7c4654f7b77b1981e3f2b8701e6a4fffaaea528453d2f928a88255080d089589", + "size": 3115949, + "subdir": "linux-64", + "timestamp": 1523980309966, + "version": "1.10.4" + }, + "botocore-1.10.45-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2067829e22e15763f4aeeffe0a1e54fe", + "name": "botocore", + "sha256": "5a9a463773d8b3df091e6f09b1d66c9f3ad1328ffdbb33827bb0d6c3b79c785c", + "size": 3195849, + "subdir": "linux-64", + "timestamp": 1529947284826, + "version": "1.10.45" + }, + "botocore-1.10.45-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e4352ace64427318973631e84b757c5f", + "name": "botocore", + "sha256": "0ec2dc5b8944f2dc4a766be1919bbb2a4b5bf585b70a6a30c55d9dff0144f31a", + "size": 3258955, + "subdir": "linux-64", + "timestamp": 1529947321349, + "version": "1.10.45" + }, + "botocore-1.10.45-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2080e840c9faa3f9bfdea521d1328e4a", + "name": "botocore", + "sha256": "ca86a503ca9ed5656c71e373474ee41383a73f23490b49ee118e0d21ca35a05b", + "size": 3258406, + "subdir": "linux-64", + "timestamp": 1529947247654, + "version": "1.10.45" + }, + "botocore-1.10.45-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9a355a9b4ee967586835d8205129fe29", + "name": "botocore", + "sha256": "a4c11c85e99b815bda97ae032b7e655d56b5f4e10a87be2bdf594a96ed2a90a5", + "size": 3187108, + "subdir": "linux-64", + "timestamp": 1530736747615, + "version": "1.10.45" + }, + "botocore-1.10.58-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "98f642d9392d4c78255c127fad44e8e6", + "name": "botocore", + "sha256": "bc52221c863f1643fada20ed35cf40ece74872863869730a9d6cf40c006f1a47", + "size": 3212825, + "subdir": "linux-64", + "timestamp": 1536111452248, + "version": "1.10.58" + }, + "botocore-1.10.58-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "474faee656c283b88b3bbe936f2401bf", + "name": "botocore", + "sha256": "bb97ee0d62f3c1375e21dff50028a2274a1996b58433f25f0f4b81dbf6af88e4", + "size": 3256283, + "subdir": "linux-64", + "timestamp": 1536111488691, + "version": "1.10.58" + }, + "botocore-1.10.58-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "24cac38b014cfa8891c22e72ece41f5d", + "name": "botocore", + "sha256": "744b641a2b7f0f74f5d35e81c42027713345666a957c74399838006c246a4bad", + "size": 3248692, + "subdir": "linux-64", + "timestamp": 1536111450646, + "version": "1.10.58" + }, + "botocore-1.10.58-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a944af03e9be18b50b2cb0db6dac7151", + "name": "botocore", + "sha256": "479069d896ab2dede469f1ef052260f0a184c727a6fddb74b175a92598b6d075", + "size": 3208099, + "subdir": "linux-64", + "timestamp": 1536113143009, + "version": "1.10.58" + }, + "botocore-1.10.62-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7605c1c41d7113aeb64db24abbd950c1", + "name": "botocore", + "sha256": "09ee58f725fc0470843cc582a8d101d4b8c0f71a1756d899853209d6e6207bbc", + "size": 3214446, + "subdir": "linux-64", + "timestamp": 1532448144246, + "version": "1.10.62" + }, + "botocore-1.10.62-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2055982c0b86ab4a38c9150a46c3020e", + "name": "botocore", + "sha256": "d9dd7347d23ecfe41215ff8da0b43d653c9448877af4c51e0d963952c8250441", + "size": 3214150, + "subdir": "linux-64", + "timestamp": 1534352421062, + "version": "1.10.62" + }, + "botocore-1.10.62-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4002d5bacba5bc0bd42e2665ed450feb", + "name": "botocore", + "sha256": "94a00456b01176dbe7d87f0b7e1e057c05f1c7a6f0d4088541ec403387b09688", + "size": 3268832, + "subdir": "linux-64", + "timestamp": 1532448153588, + "version": "1.10.62" + }, + "botocore-1.10.62-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4c721dafe842140a692c67171c06d679", + "name": "botocore", + "sha256": "7f22576071fcbf553a0158596f73cbcc0e3ef5916e6f58c8550bfa2484b78007", + "size": 3270153, + "subdir": "linux-64", + "timestamp": 1534352470318, + "version": "1.10.62" + }, + "botocore-1.10.62-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d2bdfc91e2491a3804c25e54b58f5ecc", + "name": "botocore", + "sha256": "2234db0c764ec8f64acd749a05255e240f8bc72df384bf2e20711699a9d98421", + "size": 3259554, + "subdir": "linux-64", + "timestamp": 1532448108012, + "version": "1.10.62" + }, + "botocore-1.10.62-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "95a02e2d1696e04ce4631a1623a65c4e", + "name": "botocore", + "sha256": "abab01443fc4abbbd13631963c428412be057ca52234f73ef5324f446962290d", + "size": 3265267, + "subdir": "linux-64", + "timestamp": 1534352520978, + "version": "1.10.62" + }, + "botocore-1.10.62-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6018c810762d0650af73435d7d6b13c1", + "name": "botocore", + "sha256": "73fdd93ee54f684fafd05075616322997f262a07971ffb1b3c7bc71a1e18e782", + "size": 3217152, + "subdir": "linux-64", + "timestamp": 1532448208128, + "version": "1.10.62" + }, + "botocore-1.10.62-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4e2993c3be4e6535bf226bbfd8f969bf", + "name": "botocore", + "sha256": "d498d597e78de9e210ff87932b7424b25d52a88c2f1fb239a3ef37ac0ccbf0c7", + "size": 3216188, + "subdir": "linux-64", + "timestamp": 1534352374688, + "version": "1.10.62" + }, + "botocore-1.11.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "045be3b5aef95420fd64796f817ed9cd", + "name": "botocore", + "sha256": "91a1bc2e21b7266d0d3bfd040e25e95aeaad1a1f4beed832f26ce34ad43c044e", + "size": 3283609, + "subdir": "linux-64", + "timestamp": 1535493282567, + "version": "1.11.2" + }, + "botocore-1.11.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "94d0fd47ded77eff90dca4572778eb79", + "name": "botocore", + "sha256": "cbc6ed1e658dc4378d32624c2ca610108b5f0d2831fdc26e19504ea7397b6fca", + "size": 3393736, + "subdir": "linux-64", + "timestamp": 1535493323777, + "version": "1.11.2" + }, + "botocore-1.11.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "34eb90cb35a5924a9207f738a84eaa9b", + "name": "botocore", + "sha256": "49a8ad0665ed857a6f19967315d29fd78a834554bb521d76af8871130493da2c", + "size": 3397709, + "subdir": "linux-64", + "timestamp": 1535493294918, + "version": "1.11.2" + }, + "botocore-1.11.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e518fde6f2cc746be0da78e3ab512656", + "name": "botocore", + "sha256": "49a63293c1712c5c2cd891882fedf30288bc7acaf81fa6969c9cd476be2feb7e", + "size": 3371680, + "subdir": "linux-64", + "timestamp": 1535493292064, + "version": "1.11.2" + }, + "botocore-1.12.14-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bd12e9f1cc437930fe271ae7a4497a1b", + "name": "botocore", + "sha256": "34623682507cac50f49e2f6884ef86ce261322e895378c1c519fe59d4e5b464b", + "size": 3323010, + "subdir": "linux-64", + "timestamp": 1538172860881, + "version": "1.12.14" + }, + "botocore-1.12.14-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8ab50c2bc63b4eaa471bd74e57297f4c", + "name": "botocore", + "sha256": "27f0a0a6ed48adb9df03039af3a2fce6b286d8728b697456f4a97c9eae4f98e3", + "size": 3342471, + "subdir": "linux-64", + "timestamp": 1538172850112, + "version": "1.12.14" + }, + "botocore-1.12.14-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c004204edbb57e41f0f04a2b4abf2fd7", + "name": "botocore", + "sha256": "6112f7ecb0f959c94c01f830eb37b24c488d4ade11d1f371eadf26a12e00a33b", + "size": 3420027, + "subdir": "linux-64", + "timestamp": 1538172822368, + "version": "1.12.14" + }, + "botocore-1.12.23-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f60dfc7b07b4ed43409eb4206ddb8649", + "name": "botocore", + "sha256": "9e56ae82db6ee83bece81f5bc500c90a58b9d27d6fb0b449deff2c153ce71436", + "size": 3343526, + "subdir": "linux-64", + "timestamp": 1539470370195, + "version": "1.12.23" + }, + "botocore-1.12.23-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "12d07cc5577220b89cbc9e250b62c706", + "name": "botocore", + "sha256": "32959690ffb8377ee4158f66382d0f80438f04968bf35c5a580f75c1be3eff41", + "size": 3351285, + "subdir": "linux-64", + "timestamp": 1539470373649, + "version": "1.12.23" + }, + "botocore-1.12.23-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "049b28e17a4cf014d5c80f7a4d185169", + "name": "botocore", + "sha256": "03fc3d3e489fbfc079aed034285db942eccdd2e1b9d15533993fbe078bf7de9d", + "size": 3405496, + "subdir": "linux-64", + "timestamp": 1539470373509, + "version": "1.12.23" + }, + "botocore-1.12.35-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.25" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "280d60484b5bf83266968b9c6b764cac", + "name": "botocore", + "sha256": "521c3c8a56489b93624fdac5a15bcc5d52845237fce3250d9e55d0645a7998c6", + "size": 3360003, + "subdir": "linux-64", + "timestamp": 1541134545527, + "version": "1.12.35" + }, + "botocore-1.12.35-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.25" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0521d7ea9ea58583e945d2afdb00e3ec", + "name": "botocore", + "sha256": "55efd78eb91c7851eacc460b4f7fdc80cc2cb1a98007feee8d577607bd97d7df", + "size": 3367276, + "subdir": "linux-64", + "timestamp": 1541134514085, + "version": "1.12.35" + }, + "botocore-1.12.35-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.25" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3af861dbe17e9113f8574167fc9da657", + "name": "botocore", + "sha256": "0185187a914aa2370613aa332ef727b8b228bf3429cea535f5606b28943f241d", + "size": 3299721, + "subdir": "linux-64", + "timestamp": 1541134401811, + "version": "1.12.35" + }, + "botocore-1.12.49-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.25" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "69da79a62745c4982b55db02cb0506da", + "name": "botocore", + "sha256": "c3c22e7d479b791cf857704814b512cfcdc905f40cbe947acd15bf6bcdfc7c12", + "size": 3421811, + "subdir": "linux-64", + "timestamp": 1545161958654, + "version": "1.12.49" + }, + "botocore-1.12.49-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.25" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "65d8a867578f22bf215a7c7dcdcc13c3", + "name": "botocore", + "sha256": "4dff8a74a7a0228bfbd40cfcf2691ed1bd055a8572a32775b0b43953fa173f48", + "size": 3415325, + "subdir": "linux-64", + "timestamp": 1545161987543, + "version": "1.12.49" + }, + "botocore-1.12.49-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.25" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0ff05a41ca315f86dc78143f8daca166", + "name": "botocore", + "sha256": "0aa314c5c41258d11241a6970a6647404f802c387e754c3f0851205433913878", + "size": 3420396, + "subdir": "linux-64", + "timestamp": 1545161987825, + "version": "1.12.49" + }, + "botocore-1.12.67-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.25" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "eb828ef0909f63bb0a8ba1fcee67d73e", + "name": "botocore", + "sha256": "6543b07fdc55775da0036e0adb901cfe938d19914b36e797686ec9e55ae1af12", + "size": 3604229, + "subdir": "linux-64", + "timestamp": 1545105871995, + "version": "1.12.67" + }, + "botocore-1.12.67-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.25" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0ee611db77776adc7fcbb3aea1a1e7df", + "name": "botocore", + "sha256": "eda1b13aa377521019d9f4da39c80f500f838bb207656236ebf14245317d4e5f", + "size": 3591550, + "subdir": "linux-64", + "timestamp": 1545105873265, + "version": "1.12.67" + }, + "botocore-1.12.67-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.25" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "872a8d918e67432b9ebfdb5463c35516", + "name": "botocore", + "sha256": "8038afa2ae9ad65a0f19a01e1feea4529486e1cda5b849b169143755276c7827", + "size": 3673590, + "subdir": "linux-64", + "timestamp": 1545105880652, + "version": "1.12.67" + }, + "botocore-1.12.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ff9ca32cbd89e197c7edc57f49dc5943", + "name": "botocore", + "sha256": "1892b24ee499c2f684c65c53ff62cc862c18fc0046dad50b9e532559cfda8a27", + "size": 3299934, + "subdir": "linux-64", + "timestamp": 1537466407911, + "version": "1.12.7" + }, + "botocore-1.12.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "997040c178a009860c969177ab93a394", + "name": "botocore", + "sha256": "d9464fc5dd24dcf5e7d7d11b21939dd333ed8d84afa820030e512e6c2d108114", + "size": 3346661, + "subdir": "linux-64", + "timestamp": 1537466412051, + "version": "1.12.7" + }, + "botocore-1.12.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cb7db14d786cf80df35d92d0cd02cb50", + "name": "botocore", + "sha256": "29a09af046b120c02e1cc56aff7affdbe14d9214390febc4d1c02bdb02b4501f", + "size": 3367415, + "subdir": "linux-64", + "timestamp": 1537466396007, + "version": "1.12.7" + }, + "botocore-1.12.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f0c4ab26439d3854f0812ea5b2d142c0", + "name": "botocore", + "sha256": "56a0312b66962ecb57b89dee0fc4fc5bf4ad152f0c173de4530c98a631f974d7", + "size": 3414300, + "subdir": "linux-64", + "timestamp": 1537466408954, + "version": "1.12.7" + }, + "botocore-1.27.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5ac60101c421e5cd3bbb5c9f54d00191", + "name": "botocore", + "sha256": "78eb5bcdc67bb202e52c7a87642d8ed1f87db929c5c79f2e3e9b7926dbc47e8f", + "size": 5929262, + "subdir": "linux-64", + "timestamp": 1654523912261, + "version": "1.27.2" + }, + "botocore-1.27.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fdf6f9af836f5ebb21a376a162a71447", + "name": "botocore", + "sha256": "b66d922a07e103118e22fac271d16c76b5feeb3ad290ea1e328eab690a51a4b8", + "size": 5941241, + "subdir": "linux-64", + "timestamp": 1654523751049, + "version": "1.27.2" + }, + "botocore-1.27.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "62a1ecee10cce89bc4017c88a3848f5c", + "name": "botocore", + "sha256": "0bcf5cdcd7d4c1de62b25720bb82f624ebdb3c041bc2a46d830f604b5ace1e67", + "size": 5930956, + "subdir": "linux-64", + "timestamp": 1654523851287, + "version": "1.27.2" + }, + "botocore-1.27.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1c98ed8d2aeb327cce5d936148e9158c", + "name": "botocore", + "sha256": "bd3d24877630c9daeec19c5da0d644f08af107c1c264fe8911cbfb80b23513c9", + "size": 5932297, + "subdir": "linux-64", + "timestamp": 1654523802138, + "version": "1.27.2" + }, + "botocore-1.27.28-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "611cf408088fc738793d182e16cb603d", + "name": "botocore", + "sha256": "8840fe730f4ae3305f6bd9422a94283c1440738aa38f6f787c7f8b18651835c7", + "size": 6007291, + "subdir": "linux-64", + "timestamp": 1657739695346, + "version": "1.27.28" + }, + "botocore-1.27.28-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2d0228535147cfa86cc2f8472c3156b6", + "name": "botocore", + "sha256": "03f25e817b93be826167a3c09d3173429db8d03f335e49f6c027d55f217419ba", + "size": 6020146, + "subdir": "linux-64", + "timestamp": 1657739630194, + "version": "1.27.28" + }, + "botocore-1.27.28-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "feed35e02336be1ef7ceef8a7e9cf7f4", + "name": "botocore", + "sha256": "605d3132106fcbdbc95dd1596056382c160ed8f4e24281cd0d8d88ac69c31978", + "size": 6000129, + "subdir": "linux-64", + "timestamp": 1657739525662, + "version": "1.27.28" + }, + "botocore-1.27.28-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "45fb7a8a731e2272c060a2bb260e4bfc", + "name": "botocore", + "sha256": "e598a76c642a9085d420a47405cbf938a524799f5d45f8630464faf050390b9d", + "size": 6004223, + "subdir": "linux-64", + "timestamp": 1657739578013, + "version": "1.27.28" + }, + "botocore-1.27.59-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "236733ab8681e4c35790cb3732e8008c", + "name": "botocore", + "sha256": "68c96eb900aa668e3a852768cd635b7bd01f0eb198d6afa2fe21f4a72af61921", + "size": 6094269, + "subdir": "linux-64", + "timestamp": 1667494149317, + "version": "1.27.59" + }, + "botocore-1.27.59-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fbfaaab097b433baa605a1cd399b95b4", + "name": "botocore", + "sha256": "da4d7ed81371c707ae47f05ddb902656a67f102a041c24d6859211c3d27ef64d", + "size": 6272079, + "subdir": "linux-64", + "timestamp": 1676826996328, + "version": "1.27.59" + }, + "botocore-1.27.59-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b991db63000308dd56db3143deb7a02a", + "name": "botocore", + "sha256": "cd609d4684af2bcd96dc09d987db16144cc7eb01b1f1f6fc126faac515cbd437", + "size": 6087971, + "subdir": "linux-64", + "timestamp": 1667494099564, + "version": "1.27.59" + }, + "botocore-1.27.59-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "16b711aaffcfdd11242ad1780708d15e", + "name": "botocore", + "sha256": "5528afd6c2eaf3f7359efe0abc4b437ee5473509e275b03a237eff4349d1a55d", + "size": 6107435, + "subdir": "linux-64", + "timestamp": 1667494046753, + "version": "1.27.59" + }, + "botocore-1.27.59-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fea323b64fca685e8f86d39eac8050be", + "name": "botocore", + "sha256": "b91f7cc27c7247af44284998517032aeb344b6fa38c68104e13ffee542593b7d", + "size": 6104855, + "subdir": "linux-64", + "timestamp": 1667494199151, + "version": "1.27.59" + }, + "botocore-1.5.78-py27hd4e8fcf_0.tar.bz2": { + "build": "py27hd4e8fcf_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "14399d61bd1215664591c2cb637b35eb", + "name": "botocore", + "sha256": "f088ff2cae51ae15686e3c1ef8e9c883b839577bbd160ee5851d88bc041d6fc6", + "size": 2627032, + "subdir": "linux-64", + "timestamp": 1507368009467, + "version": "1.5.78" + }, + "botocore-1.5.78-py35h796d66b_0.tar.bz2": { + "build": "py35h796d66b_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "724e5b84c16f618d556cfc20b2a38118", + "name": "botocore", + "sha256": "65be536ee1ef6c7bab7a665a6ef5c71361755371b9c5940c1be7c3c8861348f2", + "size": 2655072, + "subdir": "linux-64", + "timestamp": 1507368021215, + "version": "1.5.78" + }, + "botocore-1.5.78-py36h2caa6e9_0.tar.bz2": { + "build": "py36h2caa6e9_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7fbde1bee6a581d2499bdcfb0ffc81b1", + "name": "botocore", + "sha256": "9c1e862fabeb549499527c3eebcac409ba89ab5e986fb998119923726898f03b", + "size": 2653897, + "subdir": "linux-64", + "timestamp": 1507368015422, + "version": "1.5.78" + }, + "botocore-1.7.14-py27h48f721b_0.tar.bz2": { + "build": "py27h48f721b_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4b28df9067aedbc828f5892f645bad25", + "name": "botocore", + "sha256": "3e6d1631a26a790deb0a6edc214b3f67c017d797e00e2dac62db5a86f8b2d9a7", + "size": 2692996, + "subdir": "linux-64", + "timestamp": 1505956926449, + "version": "1.7.14" + }, + "botocore-1.7.14-py35h1ea1bdf_0.tar.bz2": { + "build": "py35h1ea1bdf_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0eadb13595cb691e47f7603a52c0ab70", + "name": "botocore", + "sha256": "68818344911a2003cf0eef8d6df7e056f74e6ff465885229f9e8a338fe3dac30", + "size": 2750545, + "subdir": "linux-64", + "timestamp": 1505956959560, + "version": "1.7.14" + }, + "botocore-1.7.14-py36h38b1d61_0.tar.bz2": { + "build": "py36h38b1d61_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "13ff1f1ae3063b338a241a666bdcb65d", + "name": "botocore", + "sha256": "401c22e56c90f59a1b7e2a7638d423c4b05ccb578f845fdbfc8b4adb428a1b70", + "size": 2737140, + "subdir": "linux-64", + "timestamp": 1505956993084, + "version": "1.7.14" + }, + "botocore-1.7.20-py27h89f32a6_0.tar.bz2": { + "build": "py27h89f32a6_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7bbdf1c5b3c18038ba3705a0f9dd683c", + "name": "botocore", + "sha256": "fa28b1dd3b55666608c27d3d4fb3671183a30115f6692d55e78913fb4ae127b8", + "size": 2710541, + "subdir": "linux-64", + "timestamp": 1507364922448, + "version": "1.7.20" + }, + "botocore-1.7.20-py35h627d9b9_0.tar.bz2": { + "build": "py35h627d9b9_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "70c9774e27dab0a96493d8adead435a8", + "name": "botocore", + "sha256": "0f4d806c5ae6ad34129692ace517f845516eba0016f24755972e7e2d1e509175", + "size": 2754708, + "subdir": "linux-64", + "timestamp": 1507364941552, + "version": "1.7.20" + }, + "botocore-1.7.20-py36h085fff1_0.tar.bz2": { + "build": "py36h085fff1_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "93e72f7537be3182b153f07143fa277a", + "name": "botocore", + "sha256": "7d9d247e8d1ed51fc1d5f7dd6aee638aaddb16b8d700bfc4fd84e0fec1ea0a32", + "size": 2742938, + "subdir": "linux-64", + "timestamp": 1507364959402, + "version": "1.7.20" + }, + "botocore-1.7.40-py27h5bcc104_0.tar.bz2": { + "build": "py27h5bcc104_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f677887e5d782e721a60b31915fd58b8", + "name": "botocore", + "sha256": "e2d1a8d759efe91e54d7c4a84258c54d3ef88f9413003de007b3af83479b2941", + "size": 2734770, + "subdir": "linux-64", + "timestamp": 1511928319887, + "version": "1.7.40" + }, + "botocore-1.7.40-py35hd756da5_0.tar.bz2": { + "build": "py35hd756da5_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9e58ad01ebc60c4bfd15e540d6038c13", + "name": "botocore", + "sha256": "1006f7a420f2dc351148578a104daa7d4b100bb5b524a9e67f22f77764178ec3", + "size": 2779812, + "subdir": "linux-64", + "timestamp": 1511928329843, + "version": "1.7.40" + }, + "botocore-1.7.40-py36h1ef979c_0.tar.bz2": { + "build": "py36h1ef979c_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4d8fb79e5f9707a0745f7cbc24808b65", + "name": "botocore", + "sha256": "65a2898e463f7c6c844ca4d34dd563309a174cdf8339d0662b66ba9e0731384d", + "size": 2772276, + "subdir": "linux-64", + "timestamp": 1511928342972, + "version": "1.7.40" + }, + "botocore-1.7.5-py27h902c29d_0.tar.bz2": { + "build": "py27h902c29d_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d5cabfa5b56682c8b78c2d6590d78641", + "name": "botocore", + "sha256": "556e767a3dc5e54c1aed524e4eebf5877a9f10dfb562ab3922de5013b8e0328e", + "size": 2682869, + "subdir": "linux-64", + "timestamp": 1507371777862, + "version": "1.7.5" + }, + "botocore-1.7.5-py35h5941762_0.tar.bz2": { + "build": "py35h5941762_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0404f64b0c7ecc8c9309b84b9538566c", + "name": "botocore", + "sha256": "15be4334c0e761f911bd4bdfa8345981031c7de8d4deae3517a91e828ca0f1ab", + "size": 2729634, + "subdir": "linux-64", + "timestamp": 1507371771755, + "version": "1.7.5" + }, + "botocore-1.7.5-py36ha445209_0.tar.bz2": { + "build": "py36ha445209_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cb03f62080cbb04a873247ba1b3bb49c", + "name": "botocore", + "sha256": "055047e05e14dc97ac550e5b6d50d211e759f4ed5c21132d78719a3cbf7729fc", + "size": 2718431, + "subdir": "linux-64", + "timestamp": 1507371803010, + "version": "1.7.5" + }, + "botocore-1.8.21-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a840814ad110bf2f9a54bbdcddcc0f25", + "name": "botocore", + "sha256": "1fd0164e16372fce9bd7f040f8250864b16d7b780701cfeffd1214cf504335dd", + "size": 2988570, + "subdir": "linux-64", + "timestamp": 1530736883145, + "version": "1.8.21" + }, + "botocore-1.8.21-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "db79ac2caf7a89668ca94de1c5aab5d8", + "name": "botocore", + "sha256": "80865494614cb7ddf7d2230566aa207ea047f61f7d7638a411b25eb23ceaf7f8", + "size": 3044166, + "subdir": "linux-64", + "timestamp": 1534352574639, + "version": "1.8.21" + }, + "botocore-1.8.21-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0d3f6043f74f9d5e621a7bb30cb95b7b", + "name": "botocore", + "sha256": "858ee4560a9215dda1ff1c3cf96aa2692f77001168a69b18e74bd6210bf88b9b", + "size": 3033979, + "subdir": "linux-64", + "timestamp": 1530736842824, + "version": "1.8.21" + }, + "botocore-1.8.21-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "817325504d013c4f068760d1031f5bbb", + "name": "botocore", + "sha256": "0c55f25fb4c423722830f4daa4200b7549103fcbabbbc035afbfed55736ee945", + "size": 2943624, + "subdir": "linux-64", + "timestamp": 1530736926495, + "version": "1.8.21" + }, + "botocore-1.8.46-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "df9080fe55e3ab16420a5ecfcf055e62", + "name": "botocore", + "sha256": "c37024d4f235e2d3dbfc64b62147c9d7518d7a168331695184d4ba8be251e1d6", + "size": 2989558, + "subdir": "linux-64", + "timestamp": 1519157353811, + "version": "1.8.46" + }, + "botocore-1.8.46-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "829d0eb0f9d25f5b44a43bbd2032c687", + "name": "botocore", + "sha256": "b6bdf5d3ce4c4dac02779a34b02f6e8bcf2daf1230a9c0cf8e19f8f3906f1b66", + "size": 3032461, + "subdir": "linux-64", + "timestamp": 1519157373176, + "version": "1.8.46" + }, + "botocore-1.8.46-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3a1e2c682ec35ac708087bd4632f5b22", + "name": "botocore", + "sha256": "ae1183b8d0e0e1e065e2cc099808e100452587f73ee6355cec1301b1ff9d98ab", + "size": 3026558, + "subdir": "linux-64", + "timestamp": 1519157345099, + "version": "1.8.46" + }, + "botocore-1.8.5-py27h60a76c8_0.tar.bz2": { + "build": "py27h60a76c8_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "07e4b4e6868a890e704457ede96d599a", + "name": "botocore", + "sha256": "a6d5ce855c41cb113018f9584f7c953ac0918c42f3f658f559ec1580bea669f7", + "size": 2938164, + "subdir": "linux-64", + "timestamp": 1512024626509, + "version": "1.8.5" + }, + "botocore-1.8.5-py35hbe5d90e_0.tar.bz2": { + "build": "py35hbe5d90e_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5bce79321bdd65abbb2db59d6d5e68e9", + "name": "botocore", + "sha256": "bafd1ba0b5126d3f65f56299de9ed53f8595a414e2ae0176f0549e07fbdd9c74", + "size": 2981653, + "subdir": "linux-64", + "timestamp": 1512024602762, + "version": "1.8.5" + }, + "botocore-1.8.5-py36hac303ac_0.tar.bz2": { + "build": "py36hac303ac_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "131e2f0df60a4227d4004df12e558dea", + "name": "botocore", + "sha256": "2affb61776e5a734ef87ba77c8838f4b6cd3b625d2f94cb3064bffa2da8f46ce", + "size": 2971858, + "subdir": "linux-64", + "timestamp": 1512024647749, + "version": "1.8.5" + }, + "botocore-1.9.18-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<2.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "65c5c7f51c5274fb0b0e788e2e8d641a", + "name": "botocore", + "sha256": "152261385bedb335a4772a1903af97ac292f845010c99fd7c26f818bd55d6bd6", + "size": 3006540, + "subdir": "linux-64", + "timestamp": 1522277694343, + "version": "1.9.18" + }, + "botocore-1.9.18-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<2.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dc0987d420fd5d2a05f99f98ff88b4a7", + "name": "botocore", + "sha256": "24af0b3c4d614da0b9e9eb29f8395dd13fa18c93f8a9616a7e374741db90b761", + "size": 3074630, + "subdir": "linux-64", + "timestamp": 1522277697313, + "version": "1.9.18" + }, + "botocore-1.9.18-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<2.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "afa45833ceb10a61f6d350e1d4480955", + "name": "botocore", + "sha256": "a81879282bcbdffd382da86553015da794e5a2af83568c8a9b51e40c4e412361", + "size": 3066482, + "subdir": "linux-64", + "timestamp": 1522277757370, + "version": "1.9.18" + }, + "bottlechest-0.7.1-py27hdd07704_1.tar.bz2": { + "build": "py27hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "3203fba990e2ae9b32fcdb1e7d51c473", + "name": "bottlechest", + "sha256": "f34a79346374f81ed3795ab9347104f54264e6621fc573fa667b42637484b4a6", + "size": 2167674, + "subdir": "linux-64", + "timestamp": 1537300478330, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py310h9102076_1.tar.bz2": { + "build": "py310h9102076_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "c0092c27a2f2fa3e855a9c85e7e831f5", + "name": "bottlechest", + "sha256": "eafa46a1ecc998bf44761e2818cd636cc2efd58b735ca160d7818c56e0071655", + "size": 9072241, + "subdir": "linux-64", + "timestamp": 1641556019107, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py35hdd07704_1.tar.bz2": { + "build": "py35hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "44c0ffb3152194a54279dffeae12bea9", + "name": "bottlechest", + "sha256": "a5fb05f3e9612b9f83fb47f74bfea63bfae59b64c69ca22b78ef6e7e3b0a4967", + "size": 2037497, + "subdir": "linux-64", + "timestamp": 1537300534838, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py36h6323ea4_1.tar.bz2": { + "build": "py36h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "e3ef5bf5a7aa6239ce2d4006f0e91c4f", + "name": "bottlechest", + "sha256": "62c0be64b7f7d6e97a146e7b507e853ff1c14d814894c265b072ada309e65d9a", + "size": 1990456, + "subdir": "linux-64", + "timestamp": 1614264423808, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py36hdd07704_1.tar.bz2": { + "build": "py36hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "24f250af1de11284054b8754177116b0", + "name": "bottlechest", + "sha256": "f7ff5c6b3de0a846de74787c7b16d2cc3d2f67991461ac3d1dc19106cf3e3cca", + "size": 2042959, + "subdir": "linux-64", + "timestamp": 1537300535374, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py36heb32a55_1.tar.bz2": { + "build": "py36heb32a55_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "f49a1ae24360f9201619b460c1025701", + "name": "bottlechest", + "sha256": "43f95120622306c110997bb0eb12777b71ee794ac867c322a9de41a469fdb1ce", + "size": 2427242, + "subdir": "linux-64", + "timestamp": 1592211866222, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py37h6323ea4_1.tar.bz2": { + "build": "py37h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "4d232b771a46ec2b0cbaeb3560b87d65", + "name": "bottlechest", + "sha256": "d3cc698e152323fe45188466f290a84f577936ad32c3609137a142621c16fa6c", + "size": 2000926, + "subdir": "linux-64", + "timestamp": 1614264438304, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py37hdd07704_1.tar.bz2": { + "build": "py37hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "5edbc0a629930d629ac246f8768bffad", + "name": "bottlechest", + "sha256": "a3e0736bd2bb7ea51a97e3e5f72d7cd5dd3059c8d12445df5c56e80cddc26f44", + "size": 2060275, + "subdir": "linux-64", + "timestamp": 1537300607640, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py37heb32a55_1.tar.bz2": { + "build": "py37heb32a55_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "539d5cbfd27c7ba8cc33fec69bea5685", + "name": "bottlechest", + "sha256": "b2c27816e2a8b27d70e6bb3fdd29ec696b1c28fab238d64c916f6b4a261a1236", + "size": 2428138, + "subdir": "linux-64", + "timestamp": 1592211848085, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py38h6323ea4_1.tar.bz2": { + "build": "py38h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "31956812c0561e1e76a06ef34315bd7b", + "name": "bottlechest", + "sha256": "875e194860e4756ab877573455879510139c730e45ffa76a14a899ca113a0aef", + "size": 2094995, + "subdir": "linux-64", + "timestamp": 1614265465637, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py38hdd07704_1.tar.bz2": { + "build": "py38hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "e375ec33ce849288514a4f36ea54e396", + "name": "bottlechest", + "sha256": "a42459e5f9406ac6081ab2529b4a5305a19dc3e3bc4d107609044726f42e7101", + "size": 2413159, + "subdir": "linux-64", + "timestamp": 1574097910436, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py38heb32a55_1.tar.bz2": { + "build": "py38heb32a55_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "a9d41ff5173f0b35be4e5e06041c3f01", + "name": "bottlechest", + "sha256": "24d0de9e72bff90ed68196906491e1fcf64369cc92697de1cfde31e54ff058fe", + "size": 2580466, + "subdir": "linux-64", + "timestamp": 1592211851628, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py39h6323ea4_1.tar.bz2": { + "build": "py39h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "8b37b895db5ca74061cebd10e34e673d", + "name": "bottlechest", + "sha256": "6f703a88e4fc8e5d25cdc17137be22b3c78938becf80daf9084666e29ff44ba8", + "size": 2121887, + "subdir": "linux-64", + "timestamp": 1614265423527, + "version": "0.7.1" + }, + "bottleneck-1.2.1-py27h035aef0_1.tar.bz2": { + "build": "py27h035aef0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f0cef9fb01b6b1cb21d9d4e32dfd2abe", + "name": "bottleneck", + "sha256": "ad904d3ab27089e18a23b5fcaaae6999e02c957c7eae33eec6ee5fd92c5aa549", + "size": 129630, + "subdir": "linux-64", + "timestamp": 1530781356566, + "version": "1.2.1" + }, + "bottleneck-1.2.1-py27h21b16a3_0.tar.bz2": { + "build": "py27h21b16a3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c7812b98074963a960c5a8fcf1568814", + "name": "bottleneck", + "sha256": "c82a7b5925fd335e1a1b895b0444bf6c7815b5c782c30e41de8172e08d5dce5d", + "size": 129214, + "subdir": "linux-64", + "timestamp": 1505741383374, + "version": "1.2.1" + }, + "bottleneck-1.2.1-py35h035aef0_1.tar.bz2": { + "build": "py35h035aef0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4d11752ba98bf658f46c74a0873e3552", + "name": "bottleneck", + "sha256": "8d55d384f05e72f8a8d2021839a98981f06ef8fef88102479f35b5d3d2474433", + "size": 130633, + "subdir": "linux-64", + "timestamp": 1534900049153, + "version": "1.2.1" + }, + "bottleneck-1.2.1-py35he1b16f1_0.tar.bz2": { + "build": "py35he1b16f1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c52cced6e649ccac1282b300f95a471c", + "name": "bottleneck", + "sha256": "8b44d92f2ab1108ae62abbbb282d53728476704952e027564f7d8d04fe2a4912", + "size": 130037, + "subdir": "linux-64", + "timestamp": 1505741474900, + "version": "1.2.1" + }, + "bottleneck-1.2.1-py36h035aef0_1.tar.bz2": { + "build": "py36h035aef0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3ed1cc2d5b00b8a9c876d4cac6233c52", + "name": "bottleneck", + "sha256": "8756e8fdbd69e2a6ec377bcb32b354b83d519ddb6abef416d92e218b03f11949", + "size": 130303, + "subdir": "linux-64", + "timestamp": 1530781453043, + "version": "1.2.1" + }, + "bottleneck-1.2.1-py36haac1ea0_0.tar.bz2": { + "build": "py36haac1ea0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e4829f10a83513931a11687b20bfe9b0", + "name": "bottleneck", + "sha256": "3cc8a305826ffa6ea7d7a36c73f39df9bb2490752eea7ac2bf2ab53e52c87ea8", + "size": 129935, + "subdir": "linux-64", + "timestamp": 1505741565283, + "version": "1.2.1" + }, + "bottleneck-1.2.1-py37h035aef0_1.tar.bz2": { + "build": "py37h035aef0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f781ff377746280fd8bd10cfbd1b3b58", + "name": "bottleneck", + "sha256": "629a436017509256c38c7c0d28efa8c2c525b9a81baf6bb2df159fd581aad4b4", + "size": 130283, + "subdir": "linux-64", + "timestamp": 1530781554326, + "version": "1.2.1" + }, + "bottleneck-1.2.1-py38hdd07704_1.tar.bz2": { + "build": "py38hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c0462325149329a67102812ac010aebd", + "name": "bottleneck", + "sha256": "18bf074b1304a9755c8480455aa85056599bf722d733d21ff92b9aa6d491bc67", + "size": 138326, + "subdir": "linux-64", + "timestamp": 1573738311599, + "version": "1.2.1" + }, + "bottleneck-1.3.1-py27hdd07704_0.tar.bz2": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "cac8b6da567cda323b333e89d5bff93f", + "name": "bottleneck", + "sha256": "c2758aff29a063610baa717ecf9cdea970c24767a83a995ffe1f6fafd18cefb6", + "size": 134085, + "subdir": "linux-64", + "timestamp": 1574272450049, + "version": "1.3.1" + }, + "bottleneck-1.3.1-py36hdd07704_0.tar.bz2": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c29ab39e21722f31d4852f14138fac7b", + "name": "bottleneck", + "sha256": "678ea8a3091f53d01b15291d67eb683d9c29877811f43c0b1d469b5e3dc0c339", + "size": 139028, + "subdir": "linux-64", + "timestamp": 1574272572014, + "version": "1.3.1" + }, + "bottleneck-1.3.1-py37hdd07704_0.tar.bz2": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d3efc30a20731d0a908d83c03434f9e9", + "name": "bottleneck", + "sha256": "bcb2694f4a9e67028abfcce7886042e9b42c0766cb303d8cd1e1bdf2d992369f", + "size": 139041, + "subdir": "linux-64", + "timestamp": 1574272572236, + "version": "1.3.1" + }, + "bottleneck-1.3.1-py38hdd07704_0.tar.bz2": { + "build": "py38hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "48a34ec38e7103215f8a37675f089b16", + "name": "bottleneck", + "sha256": "7af9ead7cb6535249d1878babbb87ad0316291bd3c4171c9d731bdf62d13712c", + "size": 146382, + "subdir": "linux-64", + "timestamp": 1574272601264, + "version": "1.3.1" + }, + "bottleneck-1.3.2-py310h9102076_1.tar.bz2": { + "build": "py310h9102076_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "aeb71b89bc717f44137c7f5307fea97d", + "name": "bottleneck", + "sha256": "8aa43526a36b5d7dfa96a1b023316ed73da702e39d4cd3845df2a86ca903f3a4", + "size": 343630, + "subdir": "linux-64", + "timestamp": 1640788630779, + "version": "1.3.2" + }, + "bottleneck-1.3.2-py36heb32a55_0.tar.bz2": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "1e9372c2fa4d9f99b02dfc2ab00625b7", + "name": "bottleneck", + "sha256": "1651ec75049575f02100bd4a2f3254709240d51eaa593454258a6fe0bcfaaa7c", + "size": 139113, + "subdir": "linux-64", + "timestamp": 1582558461005, + "version": "1.3.2" + }, + "bottleneck-1.3.2-py36heb32a55_1.tar.bz2": { + "build": "py36heb32a55_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "87d5049a88b576757c578bd716a625b6", + "name": "bottleneck", + "sha256": "6423d5ea7a560fee5dea648b939e306486eec7303190262b86200bc27b1d912f", + "size": 139413, + "subdir": "linux-64", + "timestamp": 1591780002024, + "version": "1.3.2" + }, + "bottleneck-1.3.2-py37heb32a55_0.tar.bz2": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "877385b52276f800af33ff1fdd5d79fe", + "name": "bottleneck", + "sha256": "e2ee4f53fff372f35d29a8e3334e0f72cb7366f958c5ebbfea8a4a087e37427e", + "size": 138946, + "subdir": "linux-64", + "timestamp": 1582558307373, + "version": "1.3.2" + }, + "bottleneck-1.3.2-py37heb32a55_1.tar.bz2": { + "build": "py37heb32a55_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "699391f932a06b74858613735dd5bb70", + "name": "bottleneck", + "sha256": "2fea51e3b86c5e2c8ecb50bf2cc40f7b4fac1fb2207acefdd322cc3fb8aa6cc6", + "size": 139408, + "subdir": "linux-64", + "timestamp": 1591779991402, + "version": "1.3.2" + }, + "bottleneck-1.3.2-py38heb32a55_0.tar.bz2": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b0e331e94b3b70178730a1b7718ff200", + "name": "bottleneck", + "sha256": "1770be0a18fe854fca3019def95f318d02affbff4d02af11a7b2292caf31e697", + "size": 139214, + "subdir": "linux-64", + "timestamp": 1582558513996, + "version": "1.3.2" + }, + "bottleneck-1.3.2-py38heb32a55_1.tar.bz2": { + "build": "py38heb32a55_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "27b8db339a85822e8bcf4447189de5f2", + "name": "bottleneck", + "sha256": "c97caa6c8d2a0bbe248e630a9c76a10aab4324f97c7d1a3768ee7b3fb8dcc45a", + "size": 139576, + "subdir": "linux-64", + "timestamp": 1591780001947, + "version": "1.3.2" + }, + "bottleneck-1.3.2-py39hdd57654_1.tar.bz2": { + "build": "py39hdd57654_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "105658dbda7abd0f62b45e136a6a6aec", + "name": "bottleneck", + "sha256": "47070f067b4b0f426112869763d6986e9707b87924507188dbd5641376c194b0", + "size": 140075, + "subdir": "linux-64", + "timestamp": 1607575194408, + "version": "1.3.2" + }, + "bottleneck-1.3.4-py310h9102076_0.tar.bz2": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "7321ee7373824f289d534d3a9635aeba", + "name": "bottleneck", + "sha256": "df2d57eb8f638e2dff6295dfdade084b9c2521d27cb0dcec5e0b1f69eb2a35b4", + "size": 345385, + "subdir": "linux-64", + "timestamp": 1648010842036, + "version": "1.3.4" + }, + "bottleneck-1.3.4-py37hce1f21e_0.tar.bz2": { + "build": "py37hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "2a90e2bf87290b10731ab8045f0a8e90", + "name": "bottleneck", + "sha256": "1e084cec98e5664212b6980ba0945226fad00dc43603fa6f780fab167a6c1e2e", + "size": 141348, + "subdir": "linux-64", + "timestamp": 1648028959702, + "version": "1.3.4" + }, + "bottleneck-1.3.4-py38hce1f21e_0.tar.bz2": { + "build": "py38hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c70915c3dd28d708301d7f62eceab737", + "name": "bottleneck", + "sha256": "59962f0b66250d8d0e480250f76c6ced092eded23a21789b75504ee467e7b95a", + "size": 141645, + "subdir": "linux-64", + "timestamp": 1648028960341, + "version": "1.3.4" + }, + "bottleneck-1.3.4-py39hce1f21e_0.tar.bz2": { + "build": "py39hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "922555c0435d6b2537cf8ced534b048c", + "name": "bottleneck", + "sha256": "f84f9caa7eb9d489fd9634419fdf766d39293a5df1104b840fa0cdc5823a5c60", + "size": 141903, + "subdir": "linux-64", + "timestamp": 1648028958291, + "version": "1.3.4" + }, + "bottleneck-1.3.5-py310ha9d4c09_0.tar.bz2": { + "build": "py310ha9d4c09_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5b7b73a64821792819ae1a276fdf3148", + "name": "bottleneck", + "sha256": "7f82243c9121e7579a9950eedd40f183627eb089e41eeadc25a75171758edb73", + "size": 346746, + "subdir": "linux-64", + "timestamp": 1657175754974, + "version": "1.3.5" + }, + "bottleneck-1.3.5-py311hbed6279_0.tar.bz2": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "dee2a91fe3fad67648ccba1395da2a33", + "name": "bottleneck", + "sha256": "7bc76cd2ae6a8b9ccc1cea53855a3ad7363cf9b4dd07e703daeb721c9b6639ab", + "size": 147629, + "subdir": "linux-64", + "timestamp": 1676827036328, + "version": "1.3.5" + }, + "bottleneck-1.3.5-py37h7deecbd_0.tar.bz2": { + "build": "py37h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "550d34bb19798abaec5376b04c2f1c8a", + "name": "bottleneck", + "sha256": "08e222fcf61f16c17def8a61a78d443fb339fd4b2274184a8e21237fed29db22", + "size": 128140, + "subdir": "linux-64", + "timestamp": 1657175860628, + "version": "1.3.5" + }, + "bottleneck-1.3.5-py38h7deecbd_0.tar.bz2": { + "build": "py38h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "fc4cee4736e88f88ed571fcbc415a883", + "name": "bottleneck", + "sha256": "844a429ec831cf961ae2f08a829d5be194556d81387f296054cc3c4bd2722d18", + "size": 128336, + "subdir": "linux-64", + "timestamp": 1657175632234, + "version": "1.3.5" + }, + "bottleneck-1.3.5-py39h7deecbd_0.tar.bz2": { + "build": "py39h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "14dc3c2e8eb68b1111a08de9a3ce8a00", + "name": "bottleneck", + "sha256": "20e381c665853131fc5c9a397b1d4b05bb05859a2bdfbb0559e85ec445ee9e7c", + "size": 128656, + "subdir": "linux-64", + "timestamp": 1657175966755, + "version": "1.3.5" + }, + "bpython-0.19-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f00af7a19fa57e62c5a6837d03274520", + "name": "bpython", + "sha256": "e390150d7c4d8a038841b015ce67f734a64c9a2f19a2a041475c1c660b5b3cfe", + "size": 284341, + "subdir": "linux-64", + "timestamp": 1598666112481, + "version": "0.19" + }, + "bpython-0.19-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.7,<3.8.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad55cba2ef5839a6e65cfba2e45b74db", + "name": "bpython", + "sha256": "5ce77284c4367d249adb2825e8203d981e77e2b44b62a44e48a290ee49096961", + "size": 283587, + "subdir": "linux-64", + "timestamp": 1598666072517, + "version": "0.19" + }, + "bpython-0.19-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.8,<3.9.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c2492d8911fc281543e052fadd5574d", + "name": "bpython", + "sha256": "b3df55c17c2804b507cc266b20ae3882751051ab860088b575e545d950f1bca3", + "size": 286934, + "subdir": "linux-64", + "timestamp": 1598666065779, + "version": "0.19" + }, + "bpython-0.20-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "93bd65af7d26083a7feae677c586d693", + "name": "bpython", + "sha256": "73e10c4424c7587d60588234e264970bf9005ce555b0e1ae71b220e18b96c563", + "size": 290743, + "subdir": "linux-64", + "timestamp": 1602685981053, + "version": "0.20" + }, + "bpython-0.20-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.7,<3.8.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb31759d3f2de30782b05a44e9ab8482", + "name": "bpython", + "sha256": "66bce42e8e229eea4d7e5632b7a7ecad212270192219459f217528b4bda37b8f", + "size": 292843, + "subdir": "linux-64", + "timestamp": 1602685993209, + "version": "0.20" + }, + "bpython-0.20-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.8,<3.9.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e3eddb990da2806b335b509f3007fa67", + "name": "bpython", + "sha256": "34fbe0a01482588313cedff2159631984fa7a19544b24fda02754de202b9efca", + "size": 293409, + "subdir": "linux-64", + "timestamp": 1602685972217, + "version": "0.20" + }, + "bpython-0.20.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.10,<3.11.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "819c2bd2d39c9fec27504b0ae5cec2c0", + "name": "bpython", + "sha256": "61a5a611bdc475bd8f4e4d05a69dc1c440aecaa380e5c1440a1a329b74685b66", + "size": 295560, + "subdir": "linux-64", + "timestamp": 1640811684203, + "version": "0.20.1" + }, + "bpython-0.20.1-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.11,<3.12.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4fc405c312481f48a9181c2861cf3f3d", + "name": "bpython", + "sha256": "d4cb57da14b70278a9e44ce20fa17bf9a793ecb908218f2c3fc08fa4956509ec", + "size": 393802, + "subdir": "linux-64", + "timestamp": 1676847062224, + "version": "0.20.1" + }, + "bpython-0.20.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90584c8a1d38413fb8c0f194384e7b1d", + "name": "bpython", + "sha256": "840ceb89a382bf232ff304ffbf3e400bffc676428a1f8ad6688155f0640d407d", + "size": 291609, + "subdir": "linux-64", + "timestamp": 1605061413862, + "version": "0.20.1" + }, + "bpython-0.20.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.7,<3.8.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "065528d69a514b4f122bd3c96de38d38", + "name": "bpython", + "sha256": "435de32e75c7332fc2860d38be6de8fb3f94aef78fb69eaf697a7930dff73aae", + "size": 292068, + "subdir": "linux-64", + "timestamp": 1605061456925, + "version": "0.20.1" + }, + "bpython-0.20.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.8,<3.9.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bec995b6c78b37125d77e8496f85ee92", + "name": "bpython", + "sha256": "53158ec22934c937f50c743b3cba8c9d2f7188bdc3329fe8811ddb066db93945", + "size": 293000, + "subdir": "linux-64", + "timestamp": 1605061442254, + "version": "0.20.1" + }, + "bpython-0.20.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.9,<3.10.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08b381462834241fb31fab65c49fae40", + "name": "bpython", + "sha256": "b4087a2b9012fbedcbc50b9ca58f1b47413d35d597bb1bd6a8e759b1df8c1a29", + "size": 295626, + "subdir": "linux-64", + "timestamp": 1614265244859, + "version": "0.20.1" + }, + "branca-0.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5038c200e2914bd149435a1d9f8f33e4", + "name": "branca", + "sha256": "e7133a8af9d1a23b70c250d6d55434ba70f6be6cb3d34a471e560fde1086ea47", + "size": 42470, + "subdir": "linux-64", + "timestamp": 1675157666140, + "version": "0.6.0" + }, + "branca-0.6.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c9ea30811092c3176d88cbd8a3a2583", + "name": "branca", + "sha256": "68972850391765ea3d78e6dfa5a9250ca3802581f4ac93d6e060c9c4d09087e9", + "size": 53547, + "subdir": "linux-64", + "timestamp": 1676843457111, + "version": "0.6.0" + }, + "branca-0.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a4f88e22cf9bc047e39889a56fd98fdf", + "name": "branca", + "sha256": "42f87f5aa4701f3851da61d33534ec2b8d65e412b1d914c3425093ad1af5c2a5", + "size": 42009, + "subdir": "linux-64", + "timestamp": 1675157639302, + "version": "0.6.0" + }, + "branca-0.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a988f72c736cebe811e041883110d68a", + "name": "branca", + "sha256": "acb11233689be4e3e08e59d81128e8c1a1df187e567a2a419a49a92fe52f6105", + "size": 42267, + "subdir": "linux-64", + "timestamp": 1675157693121, + "version": "0.6.0" + }, + "branca-0.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1577ae6d80e0ce66c1b39c11db75f611", + "name": "branca", + "sha256": "3e934d574ad60704f58161f23f5b9c0507a0a92b75c6171a9230ce5c9bf49699", + "size": 42277, + "subdir": "linux-64", + "timestamp": 1675157720392, + "version": "0.6.0" + }, + "brotli-1.0.3-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "e5336df26a8874ca1269445865804ea0", + "name": "brotli", + "sha256": "adef0da832a855676ce460316ce673a90812ba1eb6727a8f0d2e99a2bb848ac4", + "size": 933151, + "subdir": "linux-64", + "timestamp": 1529361891183, + "version": "1.0.3" + }, + "brotli-1.0.6-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "fa66d03b89642c038bee9687527b6cce", + "name": "brotli", + "sha256": "90b1a9c2a868403594e0d756a32c8557ba04a8a0f4ccc96fd778d7bebcf410fb", + "size": 983951, + "subdir": "linux-64", + "timestamp": 1539470596251, + "version": "1.0.6" + }, + "brotli-1.0.7-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "c682c6a415ac9db2a7ee077e7ce1ee48", + "name": "brotli", + "sha256": "5046e81fb5c0421dd4d4a0e9c175334c370ebabd4a4baf8065fc7421c14d1b56", + "size": 1069234, + "subdir": "linux-64", + "timestamp": 1611773863624, + "version": "1.0.7" + }, + "brotli-1.0.7-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "5318daf1aa1769a99049039c378dd0f0", + "name": "brotli", + "sha256": "b0bc113f9285908e1972a26b7cc2e22dfc409ebd8c609d375c1554613958e1f4", + "size": 1057067, + "subdir": "linux-64", + "timestamp": 1540961274180, + "version": "1.0.7" + }, + "brotli-1.0.9-h5eee18b_7.tar.bz2": { + "build": "h5eee18b_7", + "build_number": 7, + "depends": [ + "brotli-bin 1.0.9 h5eee18b_7", + "libbrotlidec 1.0.9 h5eee18b_7", + "libbrotlienc 1.0.9 h5eee18b_7", + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "md5": "712827b1699cc71e6240626c413408f3", + "name": "brotli", + "sha256": "11df9b719339bb40e4af8eb124a094def217f64e2440af973d7342da19c030b0", + "size": 18907, + "subdir": "linux-64", + "timestamp": 1659616178155, + "version": "1.0.9" + }, + "brotli-1.0.9-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "da07c645e89855c2f9aa0f12c758755b", + "name": "brotli", + "sha256": "63a7d84685a79f6518cd287a3c663e90e702bb0d80b3f2f9f165599e3814207d", + "size": 1104127, + "subdir": "linux-64", + "timestamp": 1600352203181, + "version": "1.0.9" + }, + "brotli-1.0.9-he6710b0_2.tar.bz2": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "bdc971e2a9affb5125b68ad708172dab", + "name": "brotli", + "sha256": "0bbcb6f78eac530c6a084459ffab3238647b266d0c74d695e6e6387dd119cc67", + "size": 411301, + "subdir": "linux-64", + "timestamp": 1602517685375, + "version": "1.0.9" + }, + "brotli-bin-1.0.9-h5eee18b_7.tar.bz2": { + "build": "h5eee18b_7", + "build_number": 7, + "depends": [ + "libbrotlidec 1.0.9 h5eee18b_7", + "libbrotlienc 1.0.9 h5eee18b_7", + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "md5": "d9d570587ccfd7158b66feb823c990c6", + "name": "brotli-bin", + "sha256": "6408b6849347ef01f5ed170f4b35fb4bdfed2d9cf9da4912a4b104a810518a80", + "size": 19933, + "subdir": "linux-64", + "timestamp": 1659616170430, + "version": "1.0.9" + }, + "brotli-python-1.0.9-py310h6a678d5_7.tar.bz2": { + "build": "py310h6a678d5_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "4a6c5a92ad8cf28aef055d3f8fd40421", + "name": "brotli-python", + "sha256": "10e402a8a18e09e78d5697b4e58a21130adb0563e37b113f804f953511a3f490", + "size": 1657927, + "subdir": "linux-64", + "timestamp": 1659616230938, + "version": "1.0.9" + }, + "brotli-python-1.0.9-py311h6a678d5_7.tar.bz2": { + "build": "py311h6a678d5_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "c64bed33690b27399c697e2f0aaae8dc", + "name": "brotli-python", + "sha256": "571346f89ad34b632322adfa4ed159bbf8977ad7308ccd0956c1bdf2c92a4c41", + "size": 360843, + "subdir": "linux-64", + "timestamp": 1676830217115, + "version": "1.0.9" + }, + "brotli-python-1.0.9-py36heb0550a_2.tar.bz2": { + "build": "py36heb0550a_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "82df37c422afb96bad3978c94509095f", + "name": "brotli-python", + "sha256": "fdaef3b24859e54056993ab06bc9a27dc74946cdf781aeda66722eca1517ecd4", + "size": 373098, + "subdir": "linux-64", + "timestamp": 1602517752387, + "version": "1.0.9" + }, + "brotli-python-1.0.9-py37h6a678d5_7.tar.bz2": { + "build": "py37h6a678d5_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6749dcacb4ea5668cad0061b2e3eaa12", + "name": "brotli-python", + "sha256": "3f7ea9dda59fd46d30aadf3377007316caa3b7a7941fd1675bb2f9896b609c7e", + "size": 361060, + "subdir": "linux-64", + "timestamp": 1659616205123, + "version": "1.0.9" + }, + "brotli-python-1.0.9-py37heb0550a_2.tar.bz2": { + "build": "py37heb0550a_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1ea9b2f9f4ab481df43be76152e0ccb5", + "name": "brotli-python", + "sha256": "c6dc06ba81989bfce5d8a3b79db49e861ace95ebb3dc80f7152e427c543dadfe", + "size": 373493, + "subdir": "linux-64", + "timestamp": 1602517718707, + "version": "1.0.9" + }, + "brotli-python-1.0.9-py38h6a678d5_7.tar.bz2": { + "build": "py38h6a678d5_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "8e3d3ad4b7eebde6cdae4a53559e3914", + "name": "brotli-python", + "sha256": "5b54b2ccaab32d1571638280e6634f2c2b42f2cd45182deeefc0bae05365d557", + "size": 360950, + "subdir": "linux-64", + "timestamp": 1659616279024, + "version": "1.0.9" + }, + "brotli-python-1.0.9-py38heb0550a_2.tar.bz2": { + "build": "py38heb0550a_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "5dc04b2ebe30cad3d57f18d761d4028c", + "name": "brotli-python", + "sha256": "48861814b9de24db62eb44c63f5d860f6e8a0394e6a130eeb315aac35386a6ae", + "size": 372816, + "subdir": "linux-64", + "timestamp": 1602517785841, + "version": "1.0.9" + }, + "brotli-python-1.0.9-py39h6a678d5_7.tar.bz2": { + "build": "py39h6a678d5_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "f0204f72bcd9ef836218cc74345e69f2", + "name": "brotli-python", + "sha256": "8507df3357958556aff2dea8788a3f7ddad6172fd9fe5d1bdb6c3afe9686d2f8", + "size": 362180, + "subdir": "linux-64", + "timestamp": 1659616255400, + "version": "1.0.9" + }, + "brotlicffi-1.0.9.2-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "a708a2d9333b44f0e89b038998c6e3f5", + "name": "brotlicffi", + "sha256": "a53c9d7e9f05e3032069f1536c5443f6fab351cded8a336be64f2a32730c8a71", + "size": 1532284, + "subdir": "linux-64", + "timestamp": 1640803742140, + "version": "1.0.9.2" + }, + "brotlicffi-1.0.9.2-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "8e6c59e8b301020c956f3167aa0e238c", + "name": "brotlicffi", + "sha256": "3cca9e3210e91307cc365b6838a0c4efc539a8e5288cb069dad5d4b9bed2f749", + "size": 371720, + "subdir": "linux-64", + "timestamp": 1676847092255, + "version": "1.0.9.2" + }, + "brotlicffi-1.0.9.2-py36h295c915_0.tar.bz2": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "166186773f5991904e737de7bd4939db", + "name": "brotlicffi", + "sha256": "e36a270b682888dba29f2cea26898b44503420b266dcfb92af8cbf366f0ba583", + "size": 378020, + "subdir": "linux-64", + "timestamp": 1633095409517, + "version": "1.0.9.2" + }, + "brotlicffi-1.0.9.2-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e6ed0194355b6fdff5eb507a67d80831", + "name": "brotlicffi", + "sha256": "4e7e5f35381fa8f044f2b58ef4445b8e1d14c4f46613f03df69bb37fcfb51969", + "size": 377654, + "subdir": "linux-64", + "timestamp": 1633095396351, + "version": "1.0.9.2" + }, + "brotlicffi-1.0.9.2-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "eeeb7e50a96a91fbedd5a4341ea1f3ed", + "name": "brotlicffi", + "sha256": "3b13c1810d834f67f40a9e3b19995913e93ef896810c98b292039984b088d1ca", + "size": 377744, + "subdir": "linux-64", + "timestamp": 1633095388364, + "version": "1.0.9.2" + }, + "brotlicffi-1.0.9.2-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "10dbcf4ac42382dea0a656d9e6215713", + "name": "brotlicffi", + "sha256": "96edf887578d829dc567adb94f4ad1cda54dab681f48c43eb75bf0519c33962d", + "size": 378718, + "subdir": "linux-64", + "timestamp": 1633095396381, + "version": "1.0.9.2" + }, + "brotlipy-0.7.0-py310h7f8727e_1002.tar.bz2": { + "build": "py310h7f8727e_1002", + "build_number": 1002, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "681b7a6c60515233e7940082b9983832", + "name": "brotlipy", + "sha256": "1142d98a4a741c3a981a077792c898235662d7e0435219872ceadaf9914ea4f2", + "size": 883596, + "subdir": "linux-64", + "timestamp": 1640803794269, + "version": "0.7.0" + }, + "brotlipy-0.7.0-py311h5eee18b_1002.tar.bz2": { + "build": "py311h5eee18b_1002", + "build_number": 1002, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a10a5d31121de0ff9b333dafca8dc70a", + "name": "brotlipy", + "sha256": "2382aebdc55097c9c8f3d0462f56d04c43eccc854f414cdee6922ee17e341099", + "size": 352437, + "subdir": "linux-64", + "timestamp": 1676822696758, + "version": "0.7.0" + }, + "brotlipy-0.7.0-py36h27cfd23_1003.tar.bz2": { + "build": "py36h27cfd23_1003", + "build_number": 1003, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1e666338a22676747124cec238dd20b", + "name": "brotlipy", + "sha256": "141448d205d0785a0767544db50e9ce66ec5809e9db06c25f238e956f1cfdf82", + "size": 357848, + "subdir": "linux-64", + "timestamp": 1605539571026, + "version": "0.7.0" + }, + "brotlipy-0.7.0-py36h7b6447c_1000.tar.bz2": { + "build": "py36h7b6447c_1000", + "build_number": 1000, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "161ceb0451a476f04e2968bfc0b16586", + "name": "brotlipy", + "sha256": "2bf1e1c1919a8ec588a5c8833f988f6deacc237d7f182ba805aaddba89610ba5", + "size": 356165, + "subdir": "linux-64", + "timestamp": 1591177768833, + "version": "0.7.0" + }, + "brotlipy-0.7.0-py37h27cfd23_1003.tar.bz2": { + "build": "py37h27cfd23_1003", + "build_number": 1003, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b105254043bd931b31a5a1c5d47250ed", + "name": "brotlipy", + "sha256": "c248f5f67d5be322fa3bbbf4a649a4cdf5d832a6fc8071a3f823a4d55ef84787", + "size": 357967, + "subdir": "linux-64", + "timestamp": 1605539573316, + "version": "0.7.0" + }, + "brotlipy-0.7.0-py37h7b6447c_1000.tar.bz2": { + "build": "py37h7b6447c_1000", + "build_number": 1000, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "86ce9efcd0a61aaf294a1824d771143f", + "name": "brotlipy", + "sha256": "d86df9caa7436b97d023c9ff0c67d3b49bc47ae299a46f22f2ae32ab693b5909", + "size": 356106, + "subdir": "linux-64", + "timestamp": 1591177750189, + "version": "0.7.0" + }, + "brotlipy-0.7.0-py38h27cfd23_1003.tar.bz2": { + "build": "py38h27cfd23_1003", + "build_number": 1003, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0991e9285c8b23adeebe815b9597e5f", + "name": "brotlipy", + "sha256": "c8802df0ea1a53b48f7f4e460a4451b726d527d5eedf48b5f304a2d15ddcb24f", + "size": 357877, + "subdir": "linux-64", + "timestamp": 1605539542867, + "version": "0.7.0" + }, + "brotlipy-0.7.0-py38h7b6447c_1000.tar.bz2": { + "build": "py38h7b6447c_1000", + "build_number": 1000, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff8bdccacfd6c78e12ee15bec47ad8d1", + "name": "brotlipy", + "sha256": "14ba80676f5111edbede456458f783c2b30eb1d5b6a991b3cd3a5e7739758773", + "size": 357143, + "subdir": "linux-64", + "timestamp": 1591177769422, + "version": "0.7.0" + }, + "brotlipy-0.7.0-py39h27cfd23_1003.tar.bz2": { + "build": "py39h27cfd23_1003", + "build_number": 1003, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c203ffc7bbba991c7089d4b383cfd92c", + "name": "brotlipy", + "sha256": "8c2071f706c2b445dabb781f7f8f008b23a29957468ec6894f050bfb3a2d5bf4", + "size": 357797, + "subdir": "linux-64", + "timestamp": 1605539534667, + "version": "0.7.0" + }, + "brunsli-0.1-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "brotli >=1.0.9,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc6cf5631ada26a03b237ef19e90cfd6", + "name": "brunsli", + "sha256": "3a2778321f5ef815cd8aa4bf37bb1532b31656c1bf5310738146e7081b177b3e", + "size": 203551, + "subdir": "linux-64", + "timestamp": 1611240485163, + "version": "0.1" + }, + "bsdiff4-1.1.5-py27h7b6447c_1.tar.bz2": { + "build": "py27h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "341011058321e7e3b23c38292edf6bcc", + "name": "bsdiff4", + "sha256": "2bbdf27aab26520a9ad6c9e56551ff289be95accc48d18470a39b90f03dc3020", + "size": 20781, + "subdir": "linux-64", + "timestamp": 1537205910054, + "version": "1.1.5" + }, + "bsdiff4-1.1.5-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "428d709e92d54205b25e88df26328285", + "name": "bsdiff4", + "sha256": "0da839c3d37dca95b2e8f514feac4aa10301b3a119346e4b8eca101c539ab52e", + "size": 38094, + "subdir": "linux-64", + "timestamp": 1640788655826, + "version": "1.1.5" + }, + "bsdiff4-1.1.5-py311h5eee18b_1.tar.bz2": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "md5": "e3d7f99342df624b688060cd16f4d88f", + "name": "bsdiff4", + "sha256": "ff1f322926449ffe48ed8dc2c4e7cda428add8647c36f502c80eceb7f540d999", + "size": 25568, + "subdir": "linux-64", + "timestamp": 1676906926072, + "version": "1.1.5" + }, + "bsdiff4-1.1.5-py35h7b6447c_1.tar.bz2": { + "build": "py35h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "7798c2207231dbc80da974eb9488f2d9", + "name": "bsdiff4", + "sha256": "e2f13cbcd89c870114d597f871b898a3ec56aaaca87458e969fe92955ab1d8e3", + "size": 21162, + "subdir": "linux-64", + "timestamp": 1537205919078, + "version": "1.1.5" + }, + "bsdiff4-1.1.5-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "7457c7c034a2daf1070eb019cbd70c85", + "name": "bsdiff4", + "sha256": "f62f632870044343f1ee669a21a1f96e9523507175fe9ab87ced5cbb65b17a4a", + "size": 238672, + "subdir": "linux-64", + "timestamp": 1613038496631, + "version": "1.1.5" + }, + "bsdiff4-1.1.5-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "b97181f547ec2512be4a0acef76ae3c8", + "name": "bsdiff4", + "sha256": "021ab582b7baa46731222914e8e80e3be3b10fb1828a634e70902ea917b366e0", + "size": 21091, + "subdir": "linux-64", + "timestamp": 1537205947964, + "version": "1.1.5" + }, + "bsdiff4-1.1.5-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "4de94ef9c3e3f4aaaac355ec9dbfaf60", + "name": "bsdiff4", + "sha256": "b206a5bdfc4b2bc9bd3f463ace576ae5d013855f6c45224022a904e3ec64bde3", + "size": 237956, + "subdir": "linux-64", + "timestamp": 1613039262364, + "version": "1.1.5" + }, + "bsdiff4-1.1.5-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "6f5c1fef6a6929187c1c18616882ba12", + "name": "bsdiff4", + "sha256": "9ee883a9a0c5c32c918577b409ac762ae33672fbf14a5953bbe7ac0142cf47d3", + "size": 21033, + "subdir": "linux-64", + "timestamp": 1537205866625, + "version": "1.1.5" + }, + "bsdiff4-1.1.5-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "b9e3cb0757a57e637991bf5ea2755084", + "name": "bsdiff4", + "sha256": "5b096c4f075c7da70fc7841b2009ba1baa324f1c180cb3e027603eaf3db9fc8c", + "size": 238886, + "subdir": "linux-64", + "timestamp": 1613038489926, + "version": "1.1.5" + }, + "bsdiff4-1.1.5-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "7bcbad16b4873e5d086f7bbe3c218a73", + "name": "bsdiff4", + "sha256": "efd3ce96f37491833438d1b8a3464247c04c99f0d86eb9d52c604ce31e751925", + "size": 28216, + "subdir": "linux-64", + "timestamp": 1572357374467, + "version": "1.1.5" + }, + "bsdiff4-1.1.5-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "4edbb1e3a27bd98f1201e14088e11d18", + "name": "bsdiff4", + "sha256": "4089ec505b5f2e1ab64ac9717db450a414ece56db75cfb707f66e582cefc525c", + "size": 21631, + "subdir": "linux-64", + "timestamp": 1607007561215, + "version": "1.1.5" + }, + "btrees-4.5.0-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "persistent >=4.1.0", + "python >=2.7,<2.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "789706933e55d9b84fadda53a18a0fa0", + "name": "btrees", + "sha256": "28175b61e11f711f6ed4ab99e02989356562510fc56c112c6f07a5605c7834c5", + "size": 414891, + "subdir": "linux-64", + "timestamp": 1529983460615, + "version": "4.5.0" + }, + "btrees-4.5.0-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "persistent >=4.1.0", + "python >=3.5,<3.6.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "38b26bfcdf7a487a7aaf204fbc01b83a", + "name": "btrees", + "sha256": "0f02a3340945b7377b0c0aa9a8ca44a0ed37eb5ce9bdd015c878e0c2d61003cf", + "size": 417170, + "subdir": "linux-64", + "timestamp": 1529983486755, + "version": "4.5.0" + }, + "btrees-4.5.0-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "persistent >=4.1.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "710e6ae525866108fe52b382d787fb18", + "name": "btrees", + "sha256": "d7b27fdcc1e25b8ba760676651b4dc4fdaec2eda4a90b6a1a43df7a419ca0d17", + "size": 404565, + "subdir": "linux-64", + "timestamp": 1529983425674, + "version": "4.5.0" + }, + "btrees-4.5.1-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "persistent >=4.1.0", + "python >=2.7,<2.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "9acc7a83361e4f146b26237dc10c9eac", + "name": "btrees", + "sha256": "a606d72d52b6bd616f63d0bc791ce14993724d8505f710e45f78763a939bdc62", + "size": 415066, + "subdir": "linux-64", + "timestamp": 1534660230764, + "version": "4.5.1" + }, + "btrees-4.5.1-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "persistent >=4.1.0", + "python >=3.5,<3.6.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "6c844df739e7fa8e328e2fd9020219c0", + "name": "btrees", + "sha256": "32c99d23c1954c9b583afc3dabcfff546774106303b9134efa66d8db903d240d", + "size": 417354, + "subdir": "linux-64", + "timestamp": 1534660240544, + "version": "4.5.1" + }, + "btrees-4.5.1-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "persistent >=4.1.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "6498bc2b863aa3504b60307357486212", + "name": "btrees", + "sha256": "e75f1128d712438110a16d717a408512bce4d16a4822d1ce03a521e8c722221b", + "size": 404939, + "subdir": "linux-64", + "timestamp": 1534660140346, + "version": "4.5.1" + }, + "btrees-4.5.1-py37hf484d3e_0.tar.bz2": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "persistent >=4.1.0", + "python >=3.7,<3.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "964c8a800a0403afbd90d410769533cd", + "name": "btrees", + "sha256": "934dc27bcf2b51c76c2838dfaa5cccd3233ba87152b20083ad8a508cb3940172", + "size": 403897, + "subdir": "linux-64", + "timestamp": 1534660282780, + "version": "4.5.1" + }, + "btrees-4.6.0-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "persistent >=4.1.0", + "python >=2.7,<2.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "ab70713787423cababc5623bad5e17cb", + "name": "btrees", + "sha256": "4ae952fdfc500cb830d30f363d9dec97d45615ca939f3c9def5b3d942b1cb171", + "size": 577428, + "subdir": "linux-64", + "timestamp": 1569443802551, + "version": "4.6.0" + }, + "btrees-4.6.0-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "persistent >=4.1.0", + "python >=3.10,<3.11.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "8b9951cbebc368aa881a98680042b8ae", + "name": "btrees", + "sha256": "58bbcd59c54b7c5551773469cd5d4c0bbe16c0aaefbf98bf0476a3d211b4d5c1", + "size": 1058404, + "subdir": "linux-64", + "timestamp": 1640813441563, + "version": "4.6.0" + }, + "btrees-4.6.0-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "persistent >=4.1.0", + "python >=3.11,<3.12.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "83db60a4c10cee7b17033cbd23f5c3d1", + "name": "btrees", + "sha256": "d174cf74651de90a628040bd954ea02a142139babeb6b704fad01a1ce32a09ce", + "size": 459643, + "subdir": "linux-64", + "timestamp": 1676906958117, + "version": "4.6.0" + }, + "btrees-4.6.0-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "persistent >=4.1.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "97d2a1b050b26035746d5801d5f40c6e", + "name": "btrees", + "sha256": "1a7e2f660fbd37d0978b0d0154f65d101b7c0872648a3cb42afca29cb7d12d8e", + "size": 659702, + "subdir": "linux-64", + "timestamp": 1613043508000, + "version": "4.6.0" + }, + "btrees-4.6.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "persistent >=4.1.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "26f876f015c3d100d2b4bc783e4e3954", + "name": "btrees", + "sha256": "0a75a0892734aea3ed9c569160bb7ee8c71730e05779c1583b806c4c87e0fb81", + "size": 570302, + "subdir": "linux-64", + "timestamp": 1569443804073, + "version": "4.6.0" + }, + "btrees-4.6.0-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "persistent >=4.1.0", + "python >=3.7,<3.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "d847635bff779e90287610fb0dfe40a2", + "name": "btrees", + "sha256": "fbafb437ae2efad35f9c1e824a099c5628aa413b9bf5d078989ef82bf6e3fafc", + "size": 654919, + "subdir": "linux-64", + "timestamp": 1613043008497, + "version": "4.6.0" + }, + "btrees-4.6.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "persistent >=4.1.0", + "python >=3.7,<3.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "ae7dbae4d1d59fdc6d44795d1e8d0475", + "name": "btrees", + "sha256": "fa53a44f1a7a00f7e82de8560e59dadc38eb27d6f1328cfe74fc26b38b5fd636", + "size": 575834, + "subdir": "linux-64", + "timestamp": 1569443800194, + "version": "4.6.0" + }, + "btrees-4.6.0-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "persistent >=4.1.0", + "python >=3.8,<3.9.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "bf9270298eb8a8b5114a78cdeada701b", + "name": "btrees", + "sha256": "821fcc2892cd7bc5c136737d0a7edc4cabe49f323b1eddf7f25bb054e4a96cbf", + "size": 653486, + "subdir": "linux-64", + "timestamp": 1613043508993, + "version": "4.6.0" + }, + "btrees-4.6.0-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "persistent >=4.1.0", + "python >=3.9,<3.10.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "dd4ee0423f173df185f830c6069c5bce", + "name": "btrees", + "sha256": "59b53350cf6730f2a3d98f6e683eef20503795e09680c280fd75957855f7dc7e", + "size": 652833, + "subdir": "linux-64", + "timestamp": 1613043505724, + "version": "4.6.0" + }, + "bwidget-1.9.11-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "tk" + ], + "license": "Tcl/Tk", + "license_family": "BSD", + "md5": "233942659ff16200a815c88750e39e2d", + "name": "bwidget", + "sha256": "718dacc9c7db1ed7555039c49038d45f708454e7efd135003d5609a48485b68c", + "size": 114673, + "subdir": "linux-64", + "timestamp": 1515593869976, + "version": "1.9.11" + }, + "bwidget-1.9.11-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "tk" + ], + "license": "Tcl/Tk", + "license_family": "BSD", + "md5": "b2558ad07e6960062429366daaaf53ca", + "name": "bwidget", + "sha256": "f4be4b4a46ec7402a8520c3d4902fc905f2c07943f5084c4986700b160ba0d35", + "size": 115322, + "subdir": "linux-64", + "timestamp": 1537997223350, + "version": "1.9.11" + }, + "bytecode-0.14.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f39ff8e861cfa7f404f0dce498089bf", + "name": "bytecode", + "sha256": "27b4e70f90194bb7afb52ebe139ee02bb163b07c6943234a47b7f5a6769c750c", + "size": 63671, + "subdir": "linux-64", + "timestamp": 1678314984864, + "version": "0.14.0" + }, + "bytecode-0.14.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d469a94a95c60a78546751f4bdd8e10", + "name": "bytecode", + "sha256": "c99ba01cc5ecada5070b04fe6717b9e9b3e63db6c3aae1c5aa4361664a085aa2", + "size": 87026, + "subdir": "linux-64", + "timestamp": 1679339995580, + "version": "0.14.0" + }, + "bytecode-0.14.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f05980160c0d717d82f6d61b8364f1d", + "name": "bytecode", + "sha256": "17f702192298b1df493aa7199ab4b39e33dcc2d6152a804d4c74d8927c4fd26d", + "size": 62909, + "subdir": "linux-64", + "timestamp": 1678314957362, + "version": "0.14.0" + }, + "bytecode-0.14.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d1fb572377469ab919166a1a01f99822", + "name": "bytecode", + "sha256": "d4f0c5f7d665f03a2246b88da9b2932d8656f2d1148e17fbb6e95ae3be432c78", + "size": 62737, + "subdir": "linux-64", + "timestamp": 1678314930222, + "version": "0.14.0" + }, + "bz2file-0.98-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "c53bb57a68ff82dee276c9c1e333dd2d", + "name": "bz2file", + "sha256": "88d6632bd41b7257343c09b0e388ccc8c87996591be49b48331e6eb2a364b963", + "size": 13187, + "subdir": "linux-64", + "timestamp": 1530889166182, + "version": "0.98" + }, + "bz2file-0.98-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "4607c41b5d04840df8cfda4c959814eb", + "name": "bz2file", + "sha256": "69fab567ca32f48d7b4f9e1060f6fe44d99c20fc5b1ada9077ef0b47b8add5a8", + "size": 13962, + "subdir": "linux-64", + "timestamp": 1640788673276, + "version": "0.98" + }, + "bz2file-0.98-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "d403bfeb16367f596b8c87db5c15f073", + "name": "bz2file", + "sha256": "a0c27ca78fd5b4e963120c1511edeb48d6c4c13ac20745e14f866e03c8f29bcd", + "size": 17715, + "subdir": "linux-64", + "timestamp": 1676906973704, + "version": "0.98" + }, + "bz2file-0.98-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "faf89aa515475ee371c71aba2ddcc8a1", + "name": "bz2file", + "sha256": "53862ad88149c8634216a75da7c50a443b201a8bbe957459a9075b561baf2e62", + "size": 13553, + "subdir": "linux-64", + "timestamp": 1537808400501, + "version": "0.98" + }, + "bz2file-0.98-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "d4cda3d2bc5f1c70237e15cb33f3c742", + "name": "bz2file", + "sha256": "77b2571d75752c3c6c0b1cde5c1c9f3fffc427f49a991d9e7264ab8213c52976", + "size": 13410, + "subdir": "linux-64", + "timestamp": 1530889204425, + "version": "0.98" + }, + "bz2file-0.98-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "b5064d7a2fdf317569d6a139477479b4", + "name": "bz2file", + "sha256": "7b301d0991cb4f08caf9b5b0dc71492971f889fe001fa6e0f6e2c33054d8f004", + "size": 230315, + "subdir": "linux-64", + "timestamp": 1613038465784, + "version": "0.98" + }, + "bz2file-0.98-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "e93d23c121495f140fb1c4ed3b98db26", + "name": "bz2file", + "sha256": "9b39f0c3314704f8937e5d0de12f8c52da82938489a34007bd6e42a447ca5358", + "size": 13399, + "subdir": "linux-64", + "timestamp": 1530889185069, + "version": "0.98" + }, + "bz2file-0.98-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "3d70ad4f724d5135de2c299a426aca10", + "name": "bz2file", + "sha256": "19fa99ba5be52d915b677ddb568fe65ff0d199767b62b3377f7ac3bb1771b10a", + "size": 229373, + "subdir": "linux-64", + "timestamp": 1613038470925, + "version": "0.98" + }, + "bz2file-0.98-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "3aa593ee7cc86fd00b7be68e53182b38", + "name": "bz2file", + "sha256": "6330dd4d570f09a57cdfcbaa9f0ad4f93c30680dfc72973bf6c169d034f6c54c", + "size": 13871, + "subdir": "linux-64", + "timestamp": 1572357395557, + "version": "0.98" + }, + "bz2file-0.98-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "f6a36daab7d3eff8f6f1f23102f5ed8f", + "name": "bz2file", + "sha256": "2b4e945293beedf310f2f86f2a49a97718ab095142e77d01c8a04e6650f099d5", + "size": 229614, + "subdir": "linux-64", + "timestamp": 1613038473589, + "version": "0.98" + }, + "bz2file-0.98-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "4f4d12d67bd4ec5a2777da070c6b526c", + "name": "bz2file", + "sha256": "b77fc4fd43e0a51cf89f586597ff872e8c1c0aa3396656ccb0337c6b0310a251", + "size": 13987, + "subdir": "linux-64", + "timestamp": 1607007570511, + "version": "0.98" + }, + "bzip2-1.0.6-h0376d23_1.tar.bz2": { + "build": "h0376d23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "bzip2", + "license_family": "BSD", + "md5": "67e953c1987298b6e82e7fff72ba6ef1", + "name": "bzip2", + "sha256": "19600d0ac766d3c9861e76a1eee16fa87750dc204183d54979722cd040a6bf0b", + "size": 423575, + "subdir": "linux-64", + "timestamp": 1505667020622, + "version": "1.0.6" + }, + "bzip2-1.0.6-h14c3975_5.tar.bz2": { + "build": "h14c3975_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "bzip2", + "license_family": "BSD", + "md5": "3ceba9ae1c8505eb03f929fbc1d08be7", + "name": "bzip2", + "sha256": "6d7a4b0686b03cf4273f1f2da62fcfb1834bbf57e151c8f4b9dbdc1621663ac8", + "size": 423960, + "subdir": "linux-64", + "timestamp": 1527013477802, + "version": "1.0.6" + }, + "bzip2-1.0.6-h6d464ef_2.tar.bz2": { + "build": "h6d464ef_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "bzip2", + "license_family": "BSD", + "md5": "8203a911ec6ea539bcd6dcb61f1438b3", + "name": "bzip2", + "sha256": "73f834d9abe47d6a0759931613adc5339d8df229b77e947a77f45b59017daaf2", + "size": 424323, + "subdir": "linux-64", + "timestamp": 1510603142558, + "version": "1.0.6" + }, + "bzip2-1.0.6-h9a117a8_4.tar.bz2": { + "build": "h9a117a8_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "bzip2", + "license_family": "BSD", + "md5": "c17ed82463afec7d286a70a0fc8979a2", + "name": "bzip2", + "sha256": "cb65e71abb445010b36c8e0f87893158cb577dc9e0465f9438e0c0618b696e5d", + "size": 423752, + "subdir": "linux-64", + "timestamp": 1518029681210, + "version": "1.0.6" + }, + "bzip2-1.0.7-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "bzip2", + "license_family": "BSD", + "md5": "a4ecaf9822db81f281b1bd5bd27b4b01", + "name": "bzip2", + "sha256": "1448212011480c095e199a7b63d645d06fff52fb9992e020e94228cec8131386", + "size": 106809, + "subdir": "linux-64", + "timestamp": 1562538098825, + "version": "1.0.7" + }, + "bzip2-1.0.8-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "bzip2", + "license_family": "BSD", + "md5": "f52e60deb7f4c82821be9a868e889348", + "name": "bzip2", + "sha256": "168c2fc4d5899ee70e85fadc998e00827e1b856a6fc4a402ed465cd7c320d19f", + "size": 107105, + "subdir": "linux-64", + "timestamp": 1563219611337, + "version": "1.0.8" + }, + "c-ares-1.15.0-h7b6447c_1.tar.bz2": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ba8838c8f9810fe25a335609da51013", + "name": "c-ares", + "sha256": "9d588a0542b88bfa878b4b65a7456eeffc81d515afc5e759a8657bb17655cf28", + "size": 100750, + "subdir": "linux-64", + "timestamp": 1541523564509, + "version": "1.15.0" + }, + "c-ares-1.15.0-h7b6447c_1001.tar.bz2": { + "build": "h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "20f7974176e6a8a76b92f5d8c943517d", + "name": "c-ares", + "sha256": "3313fd25e5e1a6d9d8957de7230205582fbfc3fba18058099b42f183cd94b54d", + "size": 104769, + "subdir": "linux-64", + "timestamp": 1564157440657, + "version": "1.15.0" + }, + "c-ares-1.16.1-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d59376d059c3d64b82bcc92ad587819", + "name": "c-ares", + "sha256": "28c6522aa9a002a2fbee21dd87c0880f70bc3b41a5606e83848d7d1c38c77f53", + "size": 115102, + "subdir": "linux-64", + "timestamp": 1600467303482, + "version": "1.16.1" + }, + "c-ares-1.17.1-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b3ed342e5071b093c7045d17e4ceaf03", + "name": "c-ares", + "sha256": "e0775e0dc0ac245f2bbe5bbea7d84530856b519045753dce61a14d1e04c913ce", + "size": 116176, + "subdir": "linux-64", + "timestamp": 1605995594332, + "version": "1.17.1" + }, + "c-ares-1.18.1-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62ca289a9704ed465d3324295ef851d9", + "name": "c-ares", + "sha256": "55032f8c149e5515300098ed4133bb92993419b976789b90c8fc3eaf88b3d979", + "size": 121863, + "subdir": "linux-64", + "timestamp": 1641918271715, + "version": "1.18.1" + }, + "c-ares-1.19.0-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d1db3ae66648d0586b55d9c70f204a43", + "name": "c-ares", + "sha256": "458e7921320ac46b46e39ca5ca10493ad030235b62da66b38a82ba50eb5f87db", + "size": 115426, + "subdir": "linux-64", + "timestamp": 1678793752036, + "version": "1.19.0" + }, + "c-ares-static-1.16.1-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "26a32d04720304f9b9b5e3aa3a98fabe", + "name": "c-ares-static", + "sha256": "f4cec7a790803b2bb4c86d57fd64ed7fce17ab1dc3d66a8c7cd7a8982a165c71", + "size": 160070, + "subdir": "linux-64", + "timestamp": 1600467325041, + "version": "1.16.1" + }, + "c-ares-static-1.17.1-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01c56ffdce9a3d772b745c127f307ccd", + "name": "c-ares-static", + "sha256": "323ebb0890212865bd43c42d55d4b10dab3a72402eeb44dec9115cde7cbfe4cc", + "size": 161324, + "subdir": "linux-64", + "timestamp": 1605995620606, + "version": "1.17.1" + }, + "c-ares-static-1.18.1-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d7c584102e8aba07beae3c8f52e9e3b6", + "name": "c-ares-static", + "sha256": "eb4c604da87b0d194dd6643c8eca4a30726acee3427387850961974e30851f1c", + "size": 166950, + "subdir": "linux-64", + "timestamp": 1641918295514, + "version": "1.18.1" + }, + "c-ares-static-1.19.0-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "619f9e4e5b5a5b3b87a352979da54656", + "name": "c-ares-static", + "sha256": "cfa779fa2737a30efbb4b6da2fca0f5b9b8ae21f57e649dfc7ee906c077d29dc", + "size": 158096, + "subdir": "linux-64", + "timestamp": 1678793767671, + "version": "1.19.0" + }, + "ca-certificates-2017.08.26-h1d4fec5_0.tar.bz2": { + "build": "h1d4fec5_0", + "build_number": 0, + "depends": [], + "license": "ISC", + "md5": "6b74b83b6b78ef64838cb8d6b001fa56", + "name": "ca-certificates", + "sha256": "994ab7778364d79b7a031d1f1030c82b6046522702fe8b5383c2531cc737b2d7", + "size": 269673, + "subdir": "linux-64", + "timestamp": 1505666760156, + "version": "2017.08.26" + }, + "ca-certificates-2018.03.07-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "ISC", + "md5": "05ea0fcce559e29de8e0f1cca9174013", + "name": "ca-certificates", + "sha256": "ee3cc734e9bf40ce45304449dfb0bf3e2e11efda0f886cba7aceca59610ebb9f", + "size": 127102, + "subdir": "linux-64", + "timestamp": 1522697436619, + "version": "2018.03.07" + }, + "ca-certificates-2018.12.5-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "ISC", + "md5": "42d37ab77c19a0c7ef66ccb70943b8c4", + "name": "ca-certificates", + "sha256": "4532114e5f91d04dfe1030a48ad4fcd4bcb0240a51816b67e017035d3737ff34", + "size": 126318, + "subdir": "linux-64", + "timestamp": 1547904614146, + "version": "2018.12.5" + }, + "ca-certificates-2019.1.23-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "ISC", + "md5": "68eed18f420722007d6e45758766c1e4", + "name": "ca-certificates", + "sha256": "7ba68f267acc1ba8eee0a6105e70f15f3c2069bf1a0de687b06e87234a8a2717", + "size": 129401, + "subdir": "linux-64", + "timestamp": 1549469958294, + "version": "2019.1.23" + }, + "ca-certificates-2019.10.16-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MPL 2.0", + "md5": "4d10e309420efc0f1b4e157665baee70", + "name": "ca-certificates", + "sha256": "8848b81d008afc6b8dfbe3172412cc4c77a9e3d544cbd90418f0546782bc9d37", + "size": 134498, + "subdir": "linux-64", + "timestamp": 1571667840027, + "version": "2019.10.16" + }, + "ca-certificates-2019.11.27-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MPL 2.0", + "md5": "92d2c78935c63b58e289791eea20773c", + "name": "ca-certificates", + "sha256": "83044205f15974f0da7a43ca6ba01999f893244e3f026ca84c46c7dfeee6a6c4", + "size": 134755, + "subdir": "linux-64", + "timestamp": 1575390278009, + "version": "2019.11.27" + }, + "ca-certificates-2019.5.15-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "ISC", + "md5": "9917c4b947d0ab86ef21d1c12892c801", + "name": "ca-certificates", + "sha256": "f74c890778064573fabf24fe1ba910ff7569978ed316cd4a64f482c5c0c5c520", + "size": 136399, + "subdir": "linux-64", + "timestamp": 1559573053639, + "version": "2019.5.15" + }, + "ca-certificates-2019.5.15-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [], + "license": "MPL 2.0", + "md5": "d45c61adec7d15f6b5c5141cac5b5867", + "name": "ca-certificates", + "sha256": "21c80a12ae9cb8ac4d284a0918b84399a4adc5305d6c0bd2be1ef867f3c949cf", + "size": 136926, + "subdir": "linux-64", + "timestamp": 1565373897594, + "version": "2019.5.15" + }, + "ca-certificates-2019.8.28-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MPL 2.0", + "md5": "d7ad435ac1a0ed809868d41a90f50321", + "name": "ca-certificates", + "sha256": "cacba2c9d46603f63b6e72f170010e3f8d947670f84f51ee1f8bb3613d290e54", + "size": 135632, + "subdir": "linux-64", + "timestamp": 1569263563402, + "version": "2019.8.28" + }, + "ca-certificates-2020.1.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MPL 2.0", + "md5": "5f35b34ec25cf0e7077b84fd343581d1", + "name": "ca-certificates", + "sha256": "50245ae5ef409ba92e56d98beab8838dc049aa26d5a856d085a012b0e8a16e38", + "size": 135675, + "subdir": "linux-64", + "timestamp": 1580397398199, + "version": "2020.1.1" + }, + "ca-certificates-2020.10.14-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MPL 2.0", + "md5": "48642e3fd8fda4a7b17fddecc4b6dbca", + "name": "ca-certificates", + "sha256": "04921acee34d37edd24b917b0e3ede8ad72b73f91176d2a89dbc3c413da8409f", + "size": 130777, + "subdir": "linux-64", + "timestamp": 1602686167355, + "version": "2020.10.14" + }, + "ca-certificates-2020.10.14-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "MPL 2.0", + "md5": "440efd8c18d3de80c6a69bd57c73cd76", + "name": "ca-certificates", + "sha256": "d2d66ef0053faa1eba76accbfb967291c4d634754cefd2009fa1c1b04a33f241", + "size": 134286, + "subdir": "linux-64", + "timestamp": 1615235699903, + "version": "2020.10.14" + }, + "ca-certificates-2020.12.8-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MPL 2.0", + "md5": "cccdebb485aad4fb93d112791f94e5b1", + "name": "ca-certificates", + "sha256": "5bffdd7fcc9d2decbe73e0e14cd28a3dc8b2caacd945195f6929dda031b3a89c", + "size": 130606, + "subdir": "linux-64", + "timestamp": 1607534080645, + "version": "2020.12.8" + }, + "ca-certificates-2020.12.8-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "MPL 2.0", + "md5": "0c183ab8bd43a43d7d135c8df75e1e69", + "name": "ca-certificates", + "sha256": "7dc63c0535db5359cd86b32b0c0d50d85e316cda435299aa5e2d04923467669a", + "size": 134535, + "subdir": "linux-64", + "timestamp": 1615235836155, + "version": "2020.12.8" + }, + "ca-certificates-2020.6.24-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MPL 2.0", + "md5": "f12265ceaed925739b782ff4a60e2241", + "name": "ca-certificates", + "sha256": "3de7818a83e62f75434370ff820174ebc21ce0606a5d412595adb62fa0505b67", + "size": 135743, + "subdir": "linux-64", + "timestamp": 1593447023312, + "version": "2020.6.24" + }, + "ca-certificates-2020.7.22-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MPL 2.0", + "md5": "b54273d6725ea24233dcf1d8df26a718", + "name": "ca-certificates", + "sha256": "989d14081ff558a50cf96f1a54abfefd88ea37aa2e93e657f2049d38377e277f", + "size": 134890, + "subdir": "linux-64", + "timestamp": 1598370614858, + "version": "2020.7.22" + }, + "ca-certificates-2021.1.19-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MPL 2.0", + "md5": "73d7a9d41c4461107f07dea9c53b5c28", + "name": "ca-certificates", + "sha256": "2ffbd455371d647edb0fcf51b58437ff8c869df6f63c1607068b008d087900ca", + "size": 130608, + "subdir": "linux-64", + "timestamp": 1611080983330, + "version": "2021.1.19" + }, + "ca-certificates-2021.1.19-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "MPL 2.0", + "md5": "604f37a892a9abbddde9247a1d640880", + "name": "ca-certificates", + "sha256": "13786455af69e89122a2072bedcf0786bbf12a84356ed8e3a20d4cf74f9f999b", + "size": 128282, + "subdir": "linux-64", + "timestamp": 1615236578251, + "version": "2021.1.19" + }, + "ca-certificates-2021.10.26-h06a4308_2.tar.bz2": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [], + "license": "MPL 2.0", + "md5": "b07e1a7b6ec2e923247ed7481c05b436", + "name": "ca-certificates", + "sha256": "4494123449adfd089ca6c723a208abe20404f6270d567524c2a0a636e13cfc58", + "size": 123845, + "subdir": "linux-64", + "timestamp": 1635220140842, + "version": "2021.10.26" + }, + "ca-certificates-2021.4.13-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "MPL 2.0", + "md5": "ade1bd820ff23260e9697801406cf16e", + "name": "ca-certificates", + "sha256": "54ba8ec0fc5ebc515f82c3cc40bce99f6c07b4269f0fc64bd90d2af02930b114", + "size": 123287, + "subdir": "linux-64", + "timestamp": 1618348422167, + "version": "2021.4.13" + }, + "ca-certificates-2021.5.25-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "MPL 2.0", + "md5": "068ad52c49286e986574ba544d9f4c50", + "name": "ca-certificates", + "sha256": "0350a857d969478805dc68f12af2094bba3e527c1b00e5ab17e36615242fdc13", + "size": 120366, + "subdir": "linux-64", + "timestamp": 1621995548182, + "version": "2021.5.25" + }, + "ca-certificates-2021.7.5-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "MPL 2.0", + "md5": "a5b14ae6530b92eb40e59709e9bd7c8a", + "name": "ca-certificates", + "sha256": "74ebcc5864f7e83ec533b35361d54ee3b1480043b9a80a746b51963ca12c2266", + "size": 121771, + "subdir": "linux-64", + "timestamp": 1625555175911, + "version": "2021.7.5" + }, + "ca-certificates-2021.9.30-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "MPL 2.0", + "md5": "9893c0792e1c29bd0891b3615cca5d00", + "name": "ca-certificates", + "sha256": "1eae2ac18b8ee8f561d08648b56b814a69ddc20df7ba23d5cb50ac31a394386f", + "size": 126102, + "subdir": "linux-64", + "timestamp": 1633726261918, + "version": "2021.9.30" + }, + "ca-certificates-2022.07.19-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "ef4b29ea120fdfa542adbce43d035c95", + "name": "ca-certificates", + "sha256": "19337b434304b6e0adb34896b3d3a8f53ac55ffa0e76fe6e1b09eddccb8c0840", + "size": 133899, + "subdir": "linux-64", + "timestamp": 1658515750713, + "version": "2022.07.19" + }, + "ca-certificates-2022.10.11-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "2aa9b8c9f0e0c83dfa5a28d274e2fdc8", + "name": "ca-certificates", + "sha256": "3b8322ae7419c514c423bfa1e3f1c62cb2b8622c88116c589ac3ea9d663ee0a7", + "size": 134596, + "subdir": "linux-64", + "timestamp": 1666896166290, + "version": "2022.10.11" + }, + "ca-certificates-2022.2.1-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MPL-2.0", + "md5": "6c8a15a964d258645d7d0135ed3c02bd", + "name": "ca-certificates", + "sha256": "011bda60ba944dce6b9ba83af1b3c1216b9d0fe72bbe373337280f4cd93b0d5c", + "size": 127525, + "subdir": "linux-64", + "timestamp": 1646123316724, + "version": "2022.2.1" + }, + "ca-certificates-2022.3.18-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MPL-2.0", + "md5": "6bf533f8f46d2d2ba7c29ad44a690a63", + "name": "ca-certificates", + "sha256": "8023137daca00575099da70236f07eaa2d76ce7ab95ec050f556c989058a5884", + "size": 126449, + "subdir": "linux-64", + "timestamp": 1648041530952, + "version": "2022.3.18" + }, + "ca-certificates-2022.3.29-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MPL-2.0", + "md5": "55745bc328c769134ac26e4e04029e97", + "name": "ca-certificates", + "sha256": "32f7131b42632135ee516e44b51c496faaaccc73a0c8bac3be4ff2eaffba9b3d", + "size": 126475, + "subdir": "linux-64", + "timestamp": 1648715659867, + "version": "2022.3.29" + }, + "ca-certificates-2022.3.29-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "MPL-2.0", + "md5": "67abee5544b706092948d21dc5717ae3", + "name": "ca-certificates", + "sha256": "55d55865dc6c8af81d77c020b97f333121dd78e14c549fa458fc756a55a1dfd4", + "size": 126627, + "subdir": "linux-64", + "timestamp": 1650465431383, + "version": "2022.3.29" + }, + "ca-certificates-2022.4.26-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "6314aa5ba8edad943656943efb941260", + "name": "ca-certificates", + "sha256": "45aa6790c3c1489956eeaa3533a913e7e4eb6ca9d279f7943917f233a4ad9b62", + "size": 134915, + "subdir": "linux-64", + "timestamp": 1651525656359, + "version": "2022.4.26" + }, + "ca-certificates-2023.01.10-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "5cc97953b9c0731a4e4624761f93b255", + "name": "ca-certificates", + "sha256": "f6c2cb1b849ce96efa34839533f135a8030db23fcff7f583270d518bb86e713f", + "size": 129664, + "subdir": "linux-64", + "timestamp": 1674218473994, + "version": "2023.01.10" + }, + "cachecontrol-0.12.11-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1207518904f1fd5d143327f6c50fa008", + "name": "cachecontrol", + "sha256": "66f6aaf32c24e173681e87972ddcdc95484f034911d458c2526a140eb7abc220", + "size": 33089, + "subdir": "linux-64", + "timestamp": 1669763996925, + "version": "0.12.11" + }, + "cachecontrol-0.12.11-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "msgpack-python >=0.5.2", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2be7c1a35731fe3e32ee4b276332e6c4", + "name": "cachecontrol", + "sha256": "7e581eb4e30cdf0889dfaaa6b3b3ac87989e70be2d9438b3396524669a610e65", + "size": 33275, + "subdir": "linux-64", + "timestamp": 1676365779369, + "version": "0.12.11" + }, + "cachecontrol-0.12.11-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "msgpack-python >=0.5.2", + "python >=3.11,<3.12.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "614938da04995263b426422b832aa366", + "name": "cachecontrol", + "sha256": "fefea19d56769e596ac3306406e096eeeb664a3a6fc6844f94f36bd5fa332586", + "size": 42322, + "subdir": "linux-64", + "timestamp": 1676823146481, + "version": "0.12.11" + }, + "cachecontrol-0.12.11-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d0de1e80d399a99140c1009f0bb9057a", + "name": "cachecontrol", + "sha256": "4eb5d1efce5f7b590f1a90c8608aadc966935a2990bd7995effc6f4cb4a55b11", + "size": 32744, + "subdir": "linux-64", + "timestamp": 1669763970943, + "version": "0.12.11" + }, + "cachecontrol-0.12.11-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "msgpack-python >=0.5.2", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5c456bf0419a088f81bcda4d2341d16b", + "name": "cachecontrol", + "sha256": "ee328863df793c82e3176e49a548a5c64dceee2966309b492f02750556946d23", + "size": 32930, + "subdir": "linux-64", + "timestamp": 1676365654469, + "version": "0.12.11" + }, + "cachecontrol-0.12.11-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cac4ca776a677331267f89a16136a9f5", + "name": "cachecontrol", + "sha256": "5d2fc0f401b6e5f1cadbbb0100353d1f3919143c2ac7ca0fde24613382d83aad", + "size": 32914, + "subdir": "linux-64", + "timestamp": 1669764022425, + "version": "0.12.11" + }, + "cachecontrol-0.12.11-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "msgpack-python >=0.5.2", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "820584ec10d43ca86a742c7ec0855222", + "name": "cachecontrol", + "sha256": "5c9d42d14abd3fd8130dc4a9d5466e3bd91b6c8a945cd384ecaf063b133d7378", + "size": 33065, + "subdir": "linux-64", + "timestamp": 1676365717078, + "version": "0.12.11" + }, + "cachecontrol-0.12.11-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dad7701482e87acebebbd4debcd24433", + "name": "cachecontrol", + "sha256": "b60937c0a16f0e369710c2911de862d29f1e11c7910b1aed819e5f99165b1930", + "size": 32868, + "subdir": "linux-64", + "timestamp": 1669764047994, + "version": "0.12.11" + }, + "cachecontrol-0.12.11-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "msgpack-python >=0.5.2", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7d209024cba298beaff1d92b041b82ca", + "name": "cachecontrol", + "sha256": "f5fe267fbe5fbf1eea81ed4a8ddcb4361db532aa144555695016a292ca50d504", + "size": 33049, + "subdir": "linux-64", + "timestamp": 1676365592172, + "version": "0.12.11" + }, + "cachecontrol-0.12.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "msgpack-python", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "30f0d42c9601872868877fe170d9443f", + "name": "cachecontrol", + "sha256": "b9cd39ae694db41bf075fe3584ae5c175fb8eaa342f788f5267abb588e9172c5", + "size": 28188, + "subdir": "linux-64", + "timestamp": 1519226605932, + "version": "0.12.4" + }, + "cachecontrol-0.12.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "msgpack-python", + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "ac9112da4a72a895b1194ceef6c1afb4", + "name": "cachecontrol", + "sha256": "5637ebdb27ea6341d9025bc8b06fd3d07b0d28f576e5edc3192950b0c79abe27", + "size": 28598, + "subdir": "linux-64", + "timestamp": 1519226615491, + "version": "0.12.4" + }, + "cachecontrol-0.12.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "msgpack-python", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "a01533528602b680eeaa27827903bc49", + "name": "cachecontrol", + "sha256": "e46ca237eb0ee8c1428fc240e16872e529d54b7da02a6c52baf9d67e290867a6", + "size": 28412, + "subdir": "linux-64", + "timestamp": 1519226580627, + "version": "0.12.4" + }, + "cachecontrol-0.12.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "msgpack-python", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5fd08a9782ed5488e3d0647d75df0e96", + "name": "cachecontrol", + "sha256": "2f99930cb1d4c6b43d8d3304bc772fd9c58da9fd6a67e4d494b42976ce749e75", + "size": 27804, + "subdir": "linux-64", + "timestamp": 1529417555467, + "version": "0.12.5" + }, + "cachecontrol-0.12.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "msgpack-python", + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3bc29f520a8092d7dfcf4637901f4d85", + "name": "cachecontrol", + "sha256": "1d0e1c1d9ca95c39242c021a1811c2bac774c2064721aba4c3a3d3c71d408f0c", + "size": 28282, + "subdir": "linux-64", + "timestamp": 1529417617404, + "version": "0.12.5" + }, + "cachecontrol-0.12.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "msgpack-python", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d44723d999abb333a1d2c15ca788f759", + "name": "cachecontrol", + "sha256": "b53989723f7439525371795184984ec9167635ee3b7338a04a1337d5b9ef3561", + "size": 28148, + "subdir": "linux-64", + "timestamp": 1529417537312, + "version": "0.12.5" + }, + "cachecontrol-0.12.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "msgpack-python", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c8508699c6b33395446794e6460008c5", + "name": "cachecontrol", + "sha256": "44f66aa98bbf361c0b7a3f311727895692bad84a7fdc016e3645d212f5c578cc", + "size": 28174, + "subdir": "linux-64", + "timestamp": 1530781638386, + "version": "0.12.5" + }, + "cachecontrol-0.12.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "msgpack-python", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "28de1e7e985ec11c938dffab204c5280", + "name": "cachecontrol", + "sha256": "f4489d95ec0230483118e7b584aa8ddf11b3e96c0586a7ef64641b75a2117bb9", + "size": 196256, + "subdir": "linux-64", + "timestamp": 1592211698539, + "version": "0.12.5" + }, + "cachecontrol-with-filecache-0.12.11-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py310h06a4308_1", + "lockfile >=0.9", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8e993750521b3e87687a1d05fd2f3ce3", + "name": "cachecontrol-with-filecache", + "sha256": "46fb5f9c1b5ed00185ab99277dcdccf21806de2a18c45c61606205be321fda2e", + "size": 4261, + "subdir": "linux-64", + "timestamp": 1676365786667, + "version": "0.12.11" + }, + "cachecontrol-with-filecache-0.12.11-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py311h06a4308_1", + "lockfile >=0.9", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3e4879c21e53eb3e79aa87ffb64a85ea", + "name": "cachecontrol-with-filecache", + "sha256": "0fd069f477fd165fc21ef5330d8e420e8cf71257021b3f3c5cefcd97711ccede", + "size": 4270, + "subdir": "linux-64", + "timestamp": 1679517108772, + "version": "0.12.11" + }, + "cachecontrol-with-filecache-0.12.11-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py37h06a4308_1", + "lockfile >=0.9", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fb084bd8b9d2cd1713dbad7ec2ce0d46", + "name": "cachecontrol-with-filecache", + "sha256": "e89b8104fb21efe1ed9ac6e32cb68b56dea151b0773367aa58efe02c8a1d1d00", + "size": 4225, + "subdir": "linux-64", + "timestamp": 1676365661351, + "version": "0.12.11" + }, + "cachecontrol-with-filecache-0.12.11-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py38h06a4308_1", + "lockfile >=0.9", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c840634747d7e830674ea173520055db", + "name": "cachecontrol-with-filecache", + "sha256": "89087881b9667c28b0d304af3a2ece9b04acc30650f93a748303fca362bb095f", + "size": 4237, + "subdir": "linux-64", + "timestamp": 1676365723863, + "version": "0.12.11" + }, + "cachecontrol-with-filecache-0.12.11-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py39h06a4308_1", + "lockfile >=0.9", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "32f963077746433d28507bc4053fccd4", + "name": "cachecontrol-with-filecache", + "sha256": "95b0b8a1977ec57d3b9aa8f4eb60889bbde4fbc817473928ba4e3aa3ec980c72", + "size": 4236, + "subdir": "linux-64", + "timestamp": 1676365599295, + "version": "0.12.11" + }, + "cachecontrol-with-redis-0.12.11-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py310h06a4308_1", + "python >=3.10,<3.11.0a0", + "redis-py >=2.10.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0539c220d5bad24b9f916e145233ef32", + "name": "cachecontrol-with-redis", + "sha256": "ced2fa3b44d38104d4c8eeb5341afcbfe19e97649028aec775cf4df8e07f02ec", + "size": 4257, + "subdir": "linux-64", + "timestamp": 1676365793911, + "version": "0.12.11" + }, + "cachecontrol-with-redis-0.12.11-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py311h06a4308_1", + "python >=3.11,<3.12.0a0", + "redis-py >=2.10.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1206793cd192f6319cead932c541a91e", + "name": "cachecontrol-with-redis", + "sha256": "296f4a17ff376523ecad6966d63ee1c204642d924df6167ca30de3f1ebbc3dc5", + "size": 4280, + "subdir": "linux-64", + "timestamp": 1679517115954, + "version": "0.12.11" + }, + "cachecontrol-with-redis-0.12.11-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py37h06a4308_1", + "python >=3.7,<3.8.0a0", + "redis-py >=2.10.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "10969f8da218ae6abc5690f0754ba0d9", + "name": "cachecontrol-with-redis", + "sha256": "839e83d583b4c2e1dfcc99dd81a60dcfeba3fc8ee20c6614e6d314cdce1bd27b", + "size": 4236, + "subdir": "linux-64", + "timestamp": 1676365668147, + "version": "0.12.11" + }, + "cachecontrol-with-redis-0.12.11-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py38h06a4308_1", + "python >=3.8,<3.9.0a0", + "redis-py >=2.10.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "15449b729011ddc3ee0dde9235d6e6b3", + "name": "cachecontrol-with-redis", + "sha256": "43dffe786e9709e87d847b3c291cd07bd81069bd0779293a834249c1b928ecbf", + "size": 4235, + "subdir": "linux-64", + "timestamp": 1676365730656, + "version": "0.12.11" + }, + "cachecontrol-with-redis-0.12.11-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py39h06a4308_1", + "python >=3.9,<3.10.0a0", + "redis-py >=2.10.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "92d74c634cb17398e101a6ec7e743381", + "name": "cachecontrol-with-redis", + "sha256": "de9651a6f4c7247118d2dba8578cdea0e83a6a4e3fa852ba8adbcbc4e9e23149", + "size": 4237, + "subdir": "linux-64", + "timestamp": 1676365606278, + "version": "0.12.11" + }, + "cached-property-1.3.1-py27h5a28e80_0.tar.bz2": { + "build": "py27h5a28e80_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4f54a3fd8fa700f15a4234dfa77b8292", + "name": "cached-property", + "sha256": "b006d60929d376a360d86f99f2684d37e6e9ac7b53dd2282ef12c6499def3042", + "size": 10358, + "subdir": "linux-64", + "timestamp": 1507578601685, + "version": "1.3.1" + }, + "cached-property-1.3.1-py35hbda3ba5_0.tar.bz2": { + "build": "py35hbda3ba5_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ce8650ddce376e7c3a624cc95e07e016", + "name": "cached-property", + "sha256": "52c5d7f7c19fda1e4763947539fd07b91f8256ca001e57f18c6f5d189a0ee461", + "size": 10554, + "subdir": "linux-64", + "timestamp": 1507578602481, + "version": "1.3.1" + }, + "cached-property-1.3.1-py36h8cf1ab6_0.tar.bz2": { + "build": "py36h8cf1ab6_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2117e04f72111dc609bca6b940c7af3a", + "name": "cached-property", + "sha256": "4a0015d160b0fd1b1b57fa33383af1a21411354df3316541d6cd30be9d6fda95", + "size": 10500, + "subdir": "linux-64", + "timestamp": 1507578622991, + "version": "1.3.1" + }, + "cached-property-1.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f32c060f93d91bc98191c901935cd5ad", + "name": "cached-property", + "sha256": "03d991e31d0ade84fb6e69d4ea8161b7e6140d6dcef4bef5876f9049e25a01a5", + "size": 10820, + "subdir": "linux-64", + "timestamp": 1519671776419, + "version": "1.4.0" + }, + "cached-property-1.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "33142f1bae92694eaafc1a87d7acd98e", + "name": "cached-property", + "sha256": "48370c04f89c5436c3e4c5f04fa028acdab47c22e8d80c5dabcde17285d7fc13", + "size": 11038, + "subdir": "linux-64", + "timestamp": 1519671862783, + "version": "1.4.0" + }, + "cached-property-1.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bcf61d28a46ec162705dbf59948acd64", + "name": "cached-property", + "sha256": "fe9c151a2888d36699f406837249d68dcd9696f7fc690ac396a71d5940d183b2", + "size": 11021, + "subdir": "linux-64", + "timestamp": 1519671894584, + "version": "1.4.0" + }, + "cached-property-1.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b146275a3d5896f4be10e94aa434306e", + "name": "cached-property", + "sha256": "77f8cf3166ffa6272503405b45993309355afa24cc3559e83121f12df7466cdc", + "size": 11006, + "subdir": "linux-64", + "timestamp": 1524002018575, + "version": "1.4.2" + }, + "cached-property-1.4.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50d6031a66d9b3b32b3eca97f758070c", + "name": "cached-property", + "sha256": "67c15190c413f150af90495d135af97c2fa68b5343c59710b582a8e67e4d65d4", + "size": 11209, + "subdir": "linux-64", + "timestamp": 1524001977491, + "version": "1.4.2" + }, + "cached-property-1.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a7ae4860c839db0004f0b8cf60a97ce6", + "name": "cached-property", + "sha256": "e62d0a908f04b3418c8a64cd6dd21a622a1cd9cd4e13f3e160fcb01f1cf3d783", + "size": 11206, + "subdir": "linux-64", + "timestamp": 1524002551290, + "version": "1.4.2" + }, + "cached-property-1.4.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bf96b47bbca6b664f3a0edabe0026f94", + "name": "cached-property", + "sha256": "4c06a3c8db7fc4b3232c60efae6ff5b287b23b928424f07e8462e7c14e4fd4dd", + "size": 10934, + "subdir": "linux-64", + "timestamp": 1529418805430, + "version": "1.4.3" + }, + "cached-property-1.4.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "00afbcba2571e9513f0efb4846783833", + "name": "cached-property", + "sha256": "b3b7461410b6ec9b8c0c09fa4779953395fe704e8d43b5aeaf7ebbec3c3610bb", + "size": 11146, + "subdir": "linux-64", + "timestamp": 1529418840641, + "version": "1.4.3" + }, + "cached-property-1.4.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9b232e31db6d5fba74cce9ea1a407ba8", + "name": "cached-property", + "sha256": "9eb87717ab47b074da0eac7e107ff91d0b4b1024461f8e3ae7e90432de036961", + "size": 11095, + "subdir": "linux-64", + "timestamp": 1529418805036, + "version": "1.4.3" + }, + "cached-property-1.4.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "18f0c9fa0554578fc3d580e2956a5a59", + "name": "cached-property", + "sha256": "d89a7e59d775c10f545f90a8944c5c0f1705c20cb28ad3d7827b4cc160048983", + "size": 11131, + "subdir": "linux-64", + "timestamp": 1530781664320, + "version": "1.4.3" + }, + "cached-property-1.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "346f7e921752fda784a193fc90f313df", + "name": "cached-property", + "sha256": "75c5c305b809af2e856f84575866401abbf1d1c00108862b76fd3ff5d2e49619", + "size": 11266, + "subdir": "linux-64", + "timestamp": 1539470848370, + "version": "1.5.1" + }, + "cached-property-1.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "87c6bba6edf8ef6cf47d46ea1e394f0b", + "name": "cached-property", + "sha256": "3cffbd01c0c50f20ea8cfdae252d74d85e430c42e1e082b51319e9fd1cf6e96e", + "size": 11417, + "subdir": "linux-64", + "timestamp": 1539470867839, + "version": "1.5.1" + }, + "cached-property-1.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "293fbe62f8d497d35e55b4eaf4c3f9b6", + "name": "cached-property", + "sha256": "8d6cd81acd37367d3c913b0ad31a038332ec627525fb992fa081be9544321f59", + "size": 11443, + "subdir": "linux-64", + "timestamp": 1539470869897, + "version": "1.5.1" + }, + "cached-property-1.5.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dce76327962fc738c7c85fca1f43bf09", + "name": "cached-property", + "sha256": "1f517f629af719bc1f0188823d331b9f7591a7500f6ea64881f461647439b574", + "size": 14383, + "subdir": "linux-64", + "timestamp": 1593094918833, + "version": "1.5.1" + }, + "cachelib-0.9.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2b934f74fe5b76b8a2fdead1e82342d2", + "name": "cachelib", + "sha256": "5431672326580fda3ea4afadfd6afb069b54a248654b9831bdfcae3e71e42733", + "size": 28521, + "subdir": "linux-64", + "timestamp": 1659783135203, + "version": "0.9.0" + }, + "cachelib-0.9.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "dbec03866ca84b456d5e7ee2c1e518e4", + "name": "cachelib", + "sha256": "9d42e82168010c7819a2abaa63c6c51de016b45ebc4b786adb978a323dc82f59", + "size": 37338, + "subdir": "linux-64", + "timestamp": 1676827690863, + "version": "0.9.0" + }, + "cachelib-0.9.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7443765abc1ba2484bf4afa327893e8f", + "name": "cachelib", + "sha256": "718c831de9ea43c06e0095dbc876a5d4d5c8c0d840c9920423e3b1b218fec863", + "size": 27982, + "subdir": "linux-64", + "timestamp": 1659783189062, + "version": "0.9.0" + }, + "cachelib-0.9.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7d83d6413c75602487d9424776fc470e", + "name": "cachelib", + "sha256": "0af8f29157f4cd186943becb41ab86c55e2533792ab16ab33779b9ceee8b31e3", + "size": 28171, + "subdir": "linux-64", + "timestamp": 1659783161685, + "version": "0.9.0" + }, + "cachelib-0.9.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "4a47753b03aa687751b4ea085e6a44bb", + "name": "cachelib", + "sha256": "e1629f8690683afbe915d155caf1dd53f7d4448ada43eca10d41e7e06037c5f1", + "size": 28178, + "subdir": "linux-64", + "timestamp": 1659783220196, + "version": "0.9.0" + }, + "caffe-1.0-py27h0c9280d_3.tar.bz2": { + "build": "py27h0c9280d_3", + "build_number": 3, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9a7e97c156ce1fae9604c4c8b2cca5bb", + "name": "caffe", + "sha256": "4f8f57bda07713f56f4f10ec1df9e744b6a118384e8ee87e48ea797cd6d7094b", + "size": 2484487, + "subdir": "linux-64", + "timestamp": 1525318182663, + "version": "1.0" + }, + "caffe-1.0-py27h2a89de5_5.tar.bz2": { + "build": "py27h2a89de5_5", + "build_number": 5, + "depends": [ + "blas * openblas", + "boost", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7ebad8cf4ee90cb2c3404e59012777fc", + "name": "caffe", + "sha256": "c76a01270110ea38ba362fc5a1300d64e73aaad284866bc978181db6029be504", + "size": 5850691, + "subdir": "linux-64", + "timestamp": 1548969146475, + "version": "1.0" + }, + "caffe-1.0-py27h620bdfb_4.tar.bz2": { + "build": "py27h620bdfb_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "14f92d0044de8e583bc22d41f0ca1125", + "name": "caffe", + "sha256": "7a53a2b52ecc15aa6b5b361e31d1a61c59fb2d9bb8aae26354a8910f01b4abb4", + "size": 5807943, + "subdir": "linux-64", + "timestamp": 1537898701678, + "version": "1.0" + }, + "caffe-1.0-py27h69a20d1_2.tar.bz2": { + "build": "py27h69a20d1_2", + "build_number": 2, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9f2c2727c18069d03517f0879675fca8", + "name": "caffe", + "sha256": "36581e22dc3d3ed8e3fa1f8411eb9bc54507cdd04ef2d225b0b3f66ee0d8f82d", + "size": 2453239, + "subdir": "linux-64", + "timestamp": 1515108207217, + "version": "1.0" + }, + "caffe-1.0-py27h7073e3f_4.tar.bz2": { + "build": "py27h7073e3f_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ad8cd96c3921dd402cb9d8a07ed9d952", + "name": "caffe", + "sha256": "49a552f61c4d0aa8ebeeb08f527938c851d77cb443f214bff43b484997864ed9", + "size": 5808552, + "subdir": "linux-64", + "timestamp": 1537898983653, + "version": "1.0" + }, + "caffe-1.0-py27h851f731_2.tar.bz2": { + "build": "py27h851f731_2", + "build_number": 2, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b084e7d94485561b321b01cdd3ef6ab6", + "name": "caffe", + "sha256": "9bd0315240436c6c9bd4c8324e151b5b02a9ec16467310984e69703361b89daf", + "size": 2453170, + "subdir": "linux-64", + "timestamp": 1515110383495, + "version": "1.0" + }, + "caffe-1.0-py27hbab4207_5.tar.bz2": { + "build": "py27hbab4207_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5fe2082b54c4cd25fe522b14ebd206e8", + "name": "caffe", + "sha256": "75461571893702e6e542d3b86fc029bcfef15ee907d8c8dbc3efe7d61fac5a14", + "size": 5848508, + "subdir": "linux-64", + "timestamp": 1548968910815, + "version": "1.0" + }, + "caffe-1.0-py27hdb41b07_3.tar.bz2": { + "build": "py27hdb41b07_3", + "build_number": 3, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "14586db185777acae15bb7ec5b8fd0c2", + "name": "caffe", + "sha256": "01fc364a9e1c926018098a4517b0a64475e2fc7924708efe0d9ce98d98f200dd", + "size": 2484296, + "subdir": "linux-64", + "timestamp": 1525317622520, + "version": "1.0" + }, + "caffe-1.0-py35h0c9280d_3.tar.bz2": { + "build": "py35h0c9280d_3", + "build_number": 3, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "cc83407641e81d5769c8d4c6ea078715", + "name": "caffe", + "sha256": "d9530b9cb7792a2015ac8a9ba192835c60bd3b78261e8442c70bc1c24a4ad4e2", + "size": 2487281, + "subdir": "linux-64", + "timestamp": 1525317957659, + "version": "1.0" + }, + "caffe-1.0-py35h620bdfb_4.tar.bz2": { + "build": "py35h620bdfb_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8ed69e80443b40015cb811d7efece5c8", + "name": "caffe", + "sha256": "0b35c1f48c65b2ac32dc05c9b12d1d92ae417fc23c67f09dea5ae6cae70d3b7a", + "size": 5805131, + "subdir": "linux-64", + "timestamp": 1537899251537, + "version": "1.0" + }, + "caffe-1.0-py35h69a20d1_2.tar.bz2": { + "build": "py35h69a20d1_2", + "build_number": 2, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3bc7a01fe9fdb1ffe759da77d4a73835", + "name": "caffe", + "sha256": "1235a97d9a907f0f2a6d7f95bdaf072a452eebeeebc5f9e4777588a722e188d2", + "size": 2450807, + "subdir": "linux-64", + "timestamp": 1515108537810, + "version": "1.0" + }, + "caffe-1.0-py35h7073e3f_4.tar.bz2": { + "build": "py35h7073e3f_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4fc08d205b9f1bd317b05f0bb5c6f22e", + "name": "caffe", + "sha256": "d6636a28119a312f3ad62ffe67f4373687d3884b1b949667a9029e211933b450", + "size": 5805317, + "subdir": "linux-64", + "timestamp": 1537899470193, + "version": "1.0" + }, + "caffe-1.0-py35h851f731_2.tar.bz2": { + "build": "py35h851f731_2", + "build_number": 2, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.13.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b23081be8f5e4ce4205b8f61b87fc360", + "name": "caffe", + "sha256": "44849cf7bdb1d02646cb44b9c03bb57045c2e52767cd7081d0f683f6d5dadc3e", + "size": 2450938, + "subdir": "linux-64", + "timestamp": 1515108535455, + "version": "1.0" + }, + "caffe-1.0-py35hdb41b07_3.tar.bz2": { + "build": "py35hdb41b07_3", + "build_number": 3, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "37be1535c745887e382d8246524e7592", + "name": "caffe", + "sha256": "6fff56f47a1b7f4697a1ff7f064ba153e3d5f6d3d8b0378120e8d40c7858c3a0", + "size": 2487578, + "subdir": "linux-64", + "timestamp": 1525319248537, + "version": "1.0" + }, + "caffe-1.0-py36h0c9280d_3.tar.bz2": { + "build": "py36h0c9280d_3", + "build_number": 3, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7c6c86a6da7e14cb7c908a78d01baaf6", + "name": "caffe", + "sha256": "7c6c7e7e73ad955f2f275b1d14d237d727aa0d413330b1e0a8cd717a1fb1f726", + "size": 2485039, + "subdir": "linux-64", + "timestamp": 1525318168765, + "version": "1.0" + }, + "caffe-1.0-py36h2a89de5_5.tar.bz2": { + "build": "py36h2a89de5_5", + "build_number": 5, + "depends": [ + "blas * openblas", + "boost", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "0a392390aa9725840eacfc878a5c0058", + "name": "caffe", + "sha256": "34faa70240053d252a1c24e139166853647f24819887866faed424809cbbf08b", + "size": 5849507, + "subdir": "linux-64", + "timestamp": 1548969624107, + "version": "1.0" + }, + "caffe-1.0-py36h620bdfb_4.tar.bz2": { + "build": "py36h620bdfb_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "49d7960b9cb04ea3d31676909e737e09", + "name": "caffe", + "sha256": "880d1a7b662589098e7591deb1ff0fec22e4119487f0c6f4656f5c914686c6e9", + "size": 5796372, + "subdir": "linux-64", + "timestamp": 1537899720366, + "version": "1.0" + }, + "caffe-1.0-py36h69a20d1_2.tar.bz2": { + "build": "py36h69a20d1_2", + "build_number": 2, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "69153590086dd606f13130677d352804", + "name": "caffe", + "sha256": "c0cdcb72533e0aec7206cff31ce1b4d0d8ca29d7ffb4bb608d491f68a949e31d", + "size": 2449172, + "subdir": "linux-64", + "timestamp": 1515110361321, + "version": "1.0" + }, + "caffe-1.0-py36h7073e3f_4.tar.bz2": { + "build": "py36h7073e3f_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "537808a48a8940a6f1309f9de56281a4", + "name": "caffe", + "sha256": "6b59bd2b953079c1164ddd2e9785bf6ba64c3be15581cf714b864f398f1aca0f", + "size": 5797406, + "subdir": "linux-64", + "timestamp": 1537899945757, + "version": "1.0" + }, + "caffe-1.0-py36h851f731_2.tar.bz2": { + "build": "py36h851f731_2", + "build_number": 2, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.13.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d978072d86e3e47a1182747601123563", + "name": "caffe", + "sha256": "8e05ea6f8147eca3b84220905ea83707facfbfc414f144aba51e268dc0e3b0a0", + "size": 2449406, + "subdir": "linux-64", + "timestamp": 1515108536483, + "version": "1.0" + }, + "caffe-1.0-py36hbab4207_5.tar.bz2": { + "build": "py36hbab4207_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "30784c139eab5f7875d44c2e463836cf", + "name": "caffe", + "sha256": "a4774b76bf6eada472c1745720aa49bf9024fa09e17d51b4ddad0958ab6d781d", + "size": 5845685, + "subdir": "linux-64", + "timestamp": 1548969387400, + "version": "1.0" + }, + "caffe-1.0-py36hdb41b07_3.tar.bz2": { + "build": "py36hdb41b07_3", + "build_number": 3, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "55edee60a6b57a1ae61ced0a1cc2287b", + "name": "caffe", + "sha256": "a69c9146559aaced487ad3de6f10c3b3a65a54a52eedf1fb2710ccd0f4a41f2d", + "size": 2483199, + "subdir": "linux-64", + "timestamp": 1525317355483, + "version": "1.0" + }, + "caffe-1.0-py37h2a89de5_5.tar.bz2": { + "build": "py37h2a89de5_5", + "build_number": 5, + "depends": [ + "blas * openblas", + "boost", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ce3b7f3cdc42cdf841abb9467c51a7d3", + "name": "caffe", + "sha256": "73863c7712db4dc61016764509df42d11b0aae7f05ee0d4174b1480795b9b260", + "size": 5850556, + "subdir": "linux-64", + "timestamp": 1548968669209, + "version": "1.0" + }, + "caffe-1.0-py37h620bdfb_4.tar.bz2": { + "build": "py37h620bdfb_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7b2bcc297aa68221c875b2d77627c26c", + "name": "caffe", + "sha256": "0bd22e04a6b332c44d62494fbb07dd6957e9cace128f5c89c68ecfa1a8cf07ad", + "size": 5796960, + "subdir": "linux-64", + "timestamp": 1537900208451, + "version": "1.0" + }, + "caffe-1.0-py37h7073e3f_4.tar.bz2": { + "build": "py37h7073e3f_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5e853e5f401d21accc631f70560cfc0c", + "name": "caffe", + "sha256": "2c02eafa7a8d84e3ddd0836a81eae7f160e81e89da07246d593898c0dcbb5c7e", + "size": 5798360, + "subdir": "linux-64", + "timestamp": 1537900421901, + "version": "1.0" + }, + "caffe-1.0-py37hbab4207_5.tar.bz2": { + "build": "py37hbab4207_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "656f6359c104e723dd30a517e6ce30e8", + "name": "caffe", + "sha256": "5ebb1f4be1da4d73e5a0f3a36e130637eadb063b86fc46d721c53b3be6103d5c", + "size": 5847202, + "subdir": "linux-64", + "timestamp": 1548968397900, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h03f526a_2.tar.bz2": { + "build": "py27h03f526a_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn 6.0.*", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e2b8a952bdcfb5c9a6f5b8f156894cce", + "name": "caffe-gpu", + "sha256": "6a91457a7af38e397359ae3e747261731d6a9660b0a3d511dcbe1cd40c723142", + "size": 4030957, + "subdir": "linux-64", + "timestamp": 1516471394391, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h1450b91_5.tar.bz2": { + "build": "py27h1450b91_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=8.0,<8.1.0a0", + "cudnn >=7.1.3,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "50714a6fd102d0467262e1b4fbd25827", + "name": "caffe-gpu", + "sha256": "4f0111deced6f263f68c07414987c3b94cb9ad3526e11f46b7b1b13a5bc15777", + "size": 5120102, + "subdir": "linux-64", + "timestamp": 1548972055799, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h16099b3_4.tar.bz2": { + "build": "py27h16099b3_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d0d226918218fab38bed64124f60596c", + "name": "caffe-gpu", + "sha256": "f5190bc7efc92a12fb9cc140fba87cf8727d79a612eb47938c713f97ab602cdd", + "size": 5665888, + "subdir": "linux-64", + "timestamp": 1537911142368, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h2b1a04e_4.tar.bz2": { + "build": "py27h2b1a04e_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "96c9470a30628c0591bc0279a8650751", + "name": "caffe-gpu", + "sha256": "9f989d1cfa10630287b10b7d24bd3beeaba022fa6742552647067fe9d1c3c31e", + "size": 5505524, + "subdir": "linux-64", + "timestamp": 1537916475026, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h37b1cb2_3.tar.bz2": { + "build": "py27h37b1cb2_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "1f400e63e5b88c0abcdd34b379336c78", + "name": "caffe-gpu", + "sha256": "6b92d1bcc5e62e29cdb136b1c0ad85727a567daf9f4f892c2fa61d53693f5c58", + "size": 4046885, + "subdir": "linux-64", + "timestamp": 1525808621008, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h4dc7405_3.tar.bz2": { + "build": "py27h4dc7405_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "594943b2f4b27cfc5451123bfe02a8db", + "name": "caffe-gpu", + "sha256": "8beeef939489f1efc92b5f9580f5f5e108970eebe84cfc8a57bd82963135003d", + "size": 4587790, + "subdir": "linux-64", + "timestamp": 1525911729195, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h51fbcb3_4.tar.bz2": { + "build": "py27h51fbcb3_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b284d413f4a301257b9fda3e04247aaa", + "name": "caffe-gpu", + "sha256": "42fac7418f6e8b41e387377a68180bc5dfac1c7cee07dffe2d83341321e89185", + "size": 5506540, + "subdir": "linux-64", + "timestamp": 1537918154342, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h550cbc0_5.tar.bz2": { + "build": "py27h550cbc0_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4c3511d043b121885ac7dfb066f499c2", + "name": "caffe-gpu", + "sha256": "bb5bbe5737edadcc671df6020a38fd6495fcf1e82c228cd0e82e52ae32ec61ef", + "size": 5682810, + "subdir": "linux-64", + "timestamp": 1548975700843, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h62894bf_4.tar.bz2": { + "build": "py27h62894bf_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "46b7f51d58237b9bd664fba042a3800d", + "name": "caffe-gpu", + "sha256": "1c09db63366e1ee46cbf49c1609c0019e5bd1a39a618caebeed2b5b7d3cf2f2a", + "size": 5106890, + "subdir": "linux-64", + "timestamp": 1537914585776, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h749159d_2.tar.bz2": { + "build": "py27h749159d_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn 6.0.*", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e8992fcef2633816db4861582115c7ab", + "name": "caffe-gpu", + "sha256": "c84c39c8f0f49c7c9039cd1bcc75e75032c391cb275f929aaafe5876ab393f94", + "size": 4032830, + "subdir": "linux-64", + "timestamp": 1516473015834, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h7b71608_4.tar.bz2": { + "build": "py27h7b71608_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "846bd1352a4af09c0ac39d04e8c06c91", + "name": "caffe-gpu", + "sha256": "deb5090ebdb5f1e066b379abdfd17550b9a62f3fcae26c369acd23e4b747d4d5", + "size": 5665902, + "subdir": "linux-64", + "timestamp": 1537912640657, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h960b796_3.tar.bz2": { + "build": "py27h960b796_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "2a92b8c52c56ac336511ba8c1322c8d0", + "name": "caffe-gpu", + "sha256": "0df24b07826f3ce5e9235e99ce30212459bc7e0357ac6c64a8e8d8e8c78a7f1d", + "size": 4046285, + "subdir": "linux-64", + "timestamp": 1525808966899, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h999e8d7_5.tar.bz2": { + "build": "py27h999e8d7_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9bb77ef7a65816382e6beb616e03e67f", + "name": "caffe-gpu", + "sha256": "c3975b9b56ea341d80b941daa972984ed237561cae4d4a33d704ae9c49769e36", + "size": 5563325, + "subdir": "linux-64", + "timestamp": 1549043122655, + "version": "1.0" + }, + "caffe-gpu-1.0-py27hdb72b7a_4.tar.bz2": { + "build": "py27hdb72b7a_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "57314302f83ff11cd32e3e66c3da8261", + "name": "caffe-gpu", + "sha256": "a1e45baf19d65a32097a846b4320bfd6c9b3b2a521c0a304129ebeca6ca835df", + "size": 5107122, + "subdir": "linux-64", + "timestamp": 1537916183628, + "version": "1.0" + }, + "caffe-gpu-1.0-py27hdc87d0a_5.tar.bz2": { + "build": "py27hdc87d0a_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ce05a4615c8d3a5605d004b0fbab5695", + "name": "caffe-gpu", + "sha256": "cee7e98d6051ac77c52177301521d8aaecfe55f630fa547fd454b8b01a33aa77", + "size": 5429513, + "subdir": "linux-64", + "timestamp": 1549039664610, + "version": "1.0" + }, + "caffe-gpu-1.0-py27hdfd716b_2.tar.bz2": { + "build": "py27hdfd716b_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "6f85c857eff377fdf368483dc3bb0b93", + "name": "caffe-gpu", + "sha256": "d1b1aa0dc70dc4a43c0dabad81bb166b927be6f2da604bca2275fecef33953e3", + "size": 4031130, + "subdir": "linux-64", + "timestamp": 1516462111582, + "version": "1.0" + }, + "caffe-gpu-1.0-py27he096b04_2.tar.bz2": { + "build": "py27he096b04_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3f28fb31c5c829f41f4bf3c568bc6c97", + "name": "caffe-gpu", + "sha256": "4db5adedacc8300a296fa7995a94c412e0c1c03f8000616d64be5b12847ec3e1", + "size": 4032374, + "subdir": "linux-64", + "timestamp": 1516463216041, + "version": "1.0" + }, + "caffe-gpu-1.0-py27heda4471_3.tar.bz2": { + "build": "py27heda4471_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "bef7d5333f4b6aedd23717110b5c0c8b", + "name": "caffe-gpu", + "sha256": "1c650b3ed18317f13702de5d1dbb7c1b9bb82daa2024b3f18e7962b5b46d78e7", + "size": 4588392, + "subdir": "linux-64", + "timestamp": 1525912059513, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h03f526a_2.tar.bz2": { + "build": "py35h03f526a_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn 6.0.*", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "1b5107adfaf2178103c7d93a02a7a143", + "name": "caffe-gpu", + "sha256": "53c115797a36fda7d4fd9b8ed22ffc021b75dfcab95b47e0fb5ab95c0a5109dc", + "size": 4038285, + "subdir": "linux-64", + "timestamp": 1516474798355, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h16099b3_4.tar.bz2": { + "build": "py35h16099b3_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e939f6547bea4a0e22bb077f0679adaa", + "name": "caffe-gpu", + "sha256": "f27f9c1fdd4054fc20580ca75c863f93d276ca34bcc1310ddd1dc1691b3d3558", + "size": 5666432, + "subdir": "linux-64", + "timestamp": 1537913882161, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h2b1a04e_4.tar.bz2": { + "build": "py35h2b1a04e_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b63fcfcc012e7b305b63d16858620ca7", + "name": "caffe-gpu", + "sha256": "46e7d8323df3ec7d2f4f89d9a2347471882206035c677c56f0027f2e66355529", + "size": 5509774, + "subdir": "linux-64", + "timestamp": 1537920014436, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h37b1cb2_3.tar.bz2": { + "build": "py35h37b1cb2_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e6813ca541922de81ed1896cf6823bdc", + "name": "caffe-gpu", + "sha256": "cbfd589327b0525138aac778b33bdef3a5768a539fd4f3f98c98672e7888034b", + "size": 4044869, + "subdir": "linux-64", + "timestamp": 1525807366361, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h4dc7405_3.tar.bz2": { + "build": "py35h4dc7405_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4ec47346e04482b00101be9883701398", + "name": "caffe-gpu", + "sha256": "44874da85dbccc6a39dfd1faa4cc4115af77dff9eb2c90a8290c8cd649c05b97", + "size": 4584883, + "subdir": "linux-64", + "timestamp": 1525910312849, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h51fbcb3_4.tar.bz2": { + "build": "py35h51fbcb3_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "abc69d39a3d5c1efd56cb4cab39b210b", + "name": "caffe-gpu", + "sha256": "712551924698b4858f60a61d4501b93df4dfcc740ddcbc2d461c4a9ab04fdef8", + "size": 5510127, + "subdir": "linux-64", + "timestamp": 1537921689639, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h62894bf_4.tar.bz2": { + "build": "py35h62894bf_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "50475e6fc19a6ff7cfcffbb9f547b1ef", + "name": "caffe-gpu", + "sha256": "b2df55b97cbada5789d76d1f14eb3b1c0610626b32a7f94e1e3307de81ed8599", + "size": 5106668, + "subdir": "linux-64", + "timestamp": 1537917953120, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h749159d_2.tar.bz2": { + "build": "py35h749159d_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn 6.0.*", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "65b5a8185a7f75b2b1b05d6b013c67f3", + "name": "caffe-gpu", + "sha256": "769a5f1945c364e9532bccde0dd3e0107e04852e27c52b6c32bc4a5b61784dce", + "size": 4038699, + "subdir": "linux-64", + "timestamp": 1516476662103, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h7b71608_4.tar.bz2": { + "build": "py35h7b71608_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "86c7e1bf520449eb054939d8637904b1", + "name": "caffe-gpu", + "sha256": "1c903283902350a7b3521d3041f73080a60d655b588ebdde539b5cb4388a952f", + "size": 5665382, + "subdir": "linux-64", + "timestamp": 1537915448753, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h960b796_3.tar.bz2": { + "build": "py35h960b796_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a1dc6517640730b64bccfb267a9a4a90", + "name": "caffe-gpu", + "sha256": "97679698b100faee364140bc22418e62fb8a409137a2f2afaadf0096cedfe941", + "size": 4044325, + "subdir": "linux-64", + "timestamp": 1525807687971, + "version": "1.0" + }, + "caffe-gpu-1.0-py35hdb72b7a_4.tar.bz2": { + "build": "py35hdb72b7a_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "088e52ed8836ddfb27704d29f124efc0", + "name": "caffe-gpu", + "sha256": "61cd06ddb1509aeab1fdb13f5e9499c16933f393208bce9f80c96409238d0040", + "size": 5108769, + "subdir": "linux-64", + "timestamp": 1537918944060, + "version": "1.0" + }, + "caffe-gpu-1.0-py35hdfd716b_2.tar.bz2": { + "build": "py35hdfd716b_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a0c02fc7088648a82f4d954fa4fde295", + "name": "caffe-gpu", + "sha256": "6d1a99ce3740290c94db4f3d0917186571e00c3ddb4338db375372f9a4401713", + "size": 4038867, + "subdir": "linux-64", + "timestamp": 1516464417042, + "version": "1.0" + }, + "caffe-gpu-1.0-py35he096b04_2.tar.bz2": { + "build": "py35he096b04_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9db2a78843386ae91284d1db7e178016", + "name": "caffe-gpu", + "sha256": "138096283cca3576b8c84d02e61387339670ea19a6d535c89587c1d3e042adde", + "size": 4038740, + "subdir": "linux-64", + "timestamp": 1516465662094, + "version": "1.0" + }, + "caffe-gpu-1.0-py35heda4471_3.tar.bz2": { + "build": "py35heda4471_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "6dd98a99324fb31c36dd99c8ff46b80f", + "name": "caffe-gpu", + "sha256": "9c46f4629c99a7bb9eb9eaf01ab646c8c2cdf8cb6f5f9434e8f55b722c906445", + "size": 4586424, + "subdir": "linux-64", + "timestamp": 1525910747060, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h03f526a_2.tar.bz2": { + "build": "py36h03f526a_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn 6.0.*", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d53cfb67bf77de383e5b6da87de5926f", + "name": "caffe-gpu", + "sha256": "0f1423c74c84bb7aba6658ef7a63ca0fa46d9ce3322aef59710d6a608db849c2", + "size": 4050822, + "subdir": "linux-64", + "timestamp": 1516478711062, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h1450b91_5.tar.bz2": { + "build": "py36h1450b91_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=8.0,<8.1.0a0", + "cudnn >=7.1.3,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "78b643391fbf10cb3778aab0e6560593", + "name": "caffe-gpu", + "sha256": "eb0a63311add7170d969c165afa5b501fd519cfe490482eb297ed7d948ec589b", + "size": 5119836, + "subdir": "linux-64", + "timestamp": 1548972704586, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h16099b3_4.tar.bz2": { + "build": "py36h16099b3_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4faaf2d6754289176e898f4f72210f8b", + "name": "caffe-gpu", + "sha256": "18cc1f5c9fa4f7aa3fa1f0a3674399a05d5239a8fb152102735e4b80cf65e27a", + "size": 5685724, + "subdir": "linux-64", + "timestamp": 1537920067009, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h2b1a04e_4.tar.bz2": { + "build": "py36h2b1a04e_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "dd2f61d516bb7dfc545d306df7ab892d", + "name": "caffe-gpu", + "sha256": "5d3f38155d873890c7753595f209029202a504f62f225d64150bb621135ec87a", + "size": 5524233, + "subdir": "linux-64", + "timestamp": 1537913157589, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h37b1cb2_3.tar.bz2": { + "build": "py36h37b1cb2_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9aad47a0b69aef32a559623da17badb4", + "name": "caffe-gpu", + "sha256": "deb1394b23b04eee1e1472832381b5f298da88aedee945a161bb6b305628c099", + "size": 4047438, + "subdir": "linux-64", + "timestamp": 1525807980648, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h4dc7405_3.tar.bz2": { + "build": "py36h4dc7405_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "afa146a7c5cbfbc16938670daeaa5edc", + "name": "caffe-gpu", + "sha256": "e6f8882856a713447d6dcf3df6731830da64c529dd5359aa03254f9ed61475b8", + "size": 4603722, + "subdir": "linux-64", + "timestamp": 1525911043209, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h51fbcb3_4.tar.bz2": { + "build": "py36h51fbcb3_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "35f75ecc24bd0119097d80dd37cea2d2", + "name": "caffe-gpu", + "sha256": "56d9b477cddab7cd20fa32a2bb2f968e9d0274f805ed37f75ef1abe9ebef509e", + "size": 5525185, + "subdir": "linux-64", + "timestamp": 1537914863584, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h550cbc0_5.tar.bz2": { + "build": "py36h550cbc0_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "419731471f243a3cf842a7027a0c8435", + "name": "caffe-gpu", + "sha256": "405d808dd279a01df69e5b5c09484fbf7f3c1e0dd338a8a66fcb032d90232f9d", + "size": 5682484, + "subdir": "linux-64", + "timestamp": 1548974354567, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h62894bf_4.tar.bz2": { + "build": "py36h62894bf_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d0f50810fffedb675e6484784cd7b3c9", + "name": "caffe-gpu", + "sha256": "2a5478a38cacd77421201a65c5e72b9cededf65ad6712184e18a1ddfbdf2bfe8", + "size": 5123509, + "subdir": "linux-64", + "timestamp": 1537911156749, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h749159d_2.tar.bz2": { + "build": "py36h749159d_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn 6.0.*", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "33748195babbc71c920bbdc45171d695", + "name": "caffe-gpu", + "sha256": "9760a623d828c94d5cf99493b875a347043fafdb0202f9cc6ce1e7ec3f0061ca", + "size": 4052079, + "subdir": "linux-64", + "timestamp": 1516480905629, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h7b71608_4.tar.bz2": { + "build": "py36h7b71608_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "625491fb2906b175eac218e4b97f063b", + "name": "caffe-gpu", + "sha256": "05c63c576f70a5d3ca34fdb2c82a12e8999225aa196ce36210e52567bb918efd", + "size": 5685257, + "subdir": "linux-64", + "timestamp": 1537921915399, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h960b796_3.tar.bz2": { + "build": "py36h960b796_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b49725a09c1e937e848fbb1bd4383864", + "name": "caffe-gpu", + "sha256": "60b9c87c17045d0d9d1c093d3b6e5d24dee676694777a72eebee042876e035fb", + "size": 4048710, + "subdir": "linux-64", + "timestamp": 1525808255320, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h999e8d7_5.tar.bz2": { + "build": "py36h999e8d7_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "15fdeac0bbc92131fb61716cc3a7277f", + "name": "caffe-gpu", + "sha256": "93e23597243dc8a61ea4060ad6254d5d6f738bd15584d13465a6a3644c759f24", + "size": 5563544, + "subdir": "linux-64", + "timestamp": 1549043771851, + "version": "1.0" + }, + "caffe-gpu-1.0-py36hdb72b7a_4.tar.bz2": { + "build": "py36hdb72b7a_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "97ab3f35e16691ee6dd55e0b91c516a6", + "name": "caffe-gpu", + "sha256": "dc3059f1e71c4822eeebeccd6ec07a6c86c582b12df072dcbe14f8924dca5201", + "size": 5123103, + "subdir": "linux-64", + "timestamp": 1537912920112, + "version": "1.0" + }, + "caffe-gpu-1.0-py36hdc87d0a_5.tar.bz2": { + "build": "py36hdc87d0a_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ce11a811ad147e08ee06a0d4877d497b", + "name": "caffe-gpu", + "sha256": "14e7b34c1d19d102bfd841da7876eeab04d91f3fd37e1c8798677378fd8a8644", + "size": 5428640, + "subdir": "linux-64", + "timestamp": 1549039037429, + "version": "1.0" + }, + "caffe-gpu-1.0-py36hdfd716b_2.tar.bz2": { + "build": "py36hdfd716b_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "43b4d55d12f6b422c66dcc427b607a88", + "name": "caffe-gpu", + "sha256": "c0badbb9a4c3f70afe49eeecc2c2ca1dc6757ff5266538dacebb3fbfd2011c08", + "size": 4050751, + "subdir": "linux-64", + "timestamp": 1516467025205, + "version": "1.0" + }, + "caffe-gpu-1.0-py36he096b04_2.tar.bz2": { + "build": "py36he096b04_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "507f7845022dd5ae42d6dc76f4159be8", + "name": "caffe-gpu", + "sha256": "a8209955f242be6b897062055d8fc2b93edb85de92b580ff350a01f89b8b76b5", + "size": 4052106, + "subdir": "linux-64", + "timestamp": 1516468458312, + "version": "1.0" + }, + "caffe-gpu-1.0-py36heda4471_3.tar.bz2": { + "build": "py36heda4471_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "6f26ec0f9f692a86b6e6448c098799cb", + "name": "caffe-gpu", + "sha256": "82166b75d201fdcae9d4e7a5a0c3a95775c4fae9c0fa575b66118730e34649ec", + "size": 4602536, + "subdir": "linux-64", + "timestamp": 1525911334121, + "version": "1.0" + }, + "caffe-gpu-1.0-py37h1450b91_5.tar.bz2": { + "build": "py37h1450b91_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=8.0,<8.1.0a0", + "cudnn >=7.1.3,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7afcf1e22c692c4682ddb77bc934cfde", + "name": "caffe-gpu", + "sha256": "9259728de66908c3be3bb4cd1ae64b9a9d770974c22ecd22e6023a0d109ccc31", + "size": 5121069, + "subdir": "linux-64", + "timestamp": 1548971411101, + "version": "1.0" + }, + "caffe-gpu-1.0-py37h16099b3_4.tar.bz2": { + "build": "py37h16099b3_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "04cb590fd2a44c69b4e33d9f90e0e9c4", + "name": "caffe-gpu", + "sha256": "b9b7ccdba8b58f40287993598c71a0e64d4c46a338556391eb1c727fa896b0bf", + "size": 5686386, + "subdir": "linux-64", + "timestamp": 1537916878497, + "version": "1.0" + }, + "caffe-gpu-1.0-py37h2b1a04e_4.tar.bz2": { + "build": "py37h2b1a04e_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7769e426d622b734ad3a1706168a4a59", + "name": "caffe-gpu", + "sha256": "727000ad11d679536599ac6cab2fbf72be4afaaa0dd6c189b8d03f07c9614ab7", + "size": 5523926, + "subdir": "linux-64", + "timestamp": 1537922360994, + "version": "1.0" + }, + "caffe-gpu-1.0-py37h51fbcb3_4.tar.bz2": { + "build": "py37h51fbcb3_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5f00aa443304d7206e6aba30346126d1", + "name": "caffe-gpu", + "sha256": "4e4fc48df1d8db8b3f332644ee6d850efe502be0d64bf123deab736b1df8b1c2", + "size": 5525254, + "subdir": "linux-64", + "timestamp": 1537922961829, + "version": "1.0" + }, + "caffe-gpu-1.0-py37h550cbc0_5.tar.bz2": { + "build": "py37h550cbc0_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "084bff1a2e256c5585469153050c32bb", + "name": "caffe-gpu", + "sha256": "e34cdbe1ad09b15d54f0163f570e324117ff3bca704734cdbf4aa5a1f12fcc74", + "size": 5682675, + "subdir": "linux-64", + "timestamp": 1548975026670, + "version": "1.0" + }, + "caffe-gpu-1.0-py37h62894bf_4.tar.bz2": { + "build": "py37h62894bf_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "525951eeb135aee6c7295a2b0acea791", + "name": "caffe-gpu", + "sha256": "08d0d3960341be60b5d665b16f7616d98cc90ef48c987648f4e4b51fcbb56a1b", + "size": 5122788, + "subdir": "linux-64", + "timestamp": 1537920293519, + "version": "1.0" + }, + "caffe-gpu-1.0-py37h7b71608_4.tar.bz2": { + "build": "py37h7b71608_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "2ca9afa8f3cc9a8998dbc9079a394cce", + "name": "caffe-gpu", + "sha256": "bdddbc7ef47c45b773845a354997a7e705a456cf7b7b4c333258e0cebc224cb3", + "size": 5686061, + "subdir": "linux-64", + "timestamp": 1537918258878, + "version": "1.0" + }, + "caffe-gpu-1.0-py37h999e8d7_5.tar.bz2": { + "build": "py37h999e8d7_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e9e326e97668681a12ad5c7ddec5afc1", + "name": "caffe-gpu", + "sha256": "2b8e8c2814fd1ac57c1b9ac2a3e477907bcd20cacdd8594b5acceaa310bc63b6", + "size": 5563206, + "subdir": "linux-64", + "timestamp": 1549044412277, + "version": "1.0" + }, + "caffe-gpu-1.0-py37hdb72b7a_4.tar.bz2": { + "build": "py37hdb72b7a_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c419b48c50ac19cf4029024ac485bd0a", + "name": "caffe-gpu", + "sha256": "9e2781576f75376e86e9b0b2f53ca5710501652706bff28106ff5f43f595ec32", + "size": 5123214, + "subdir": "linux-64", + "timestamp": 1537921967489, + "version": "1.0" + }, + "caffe-gpu-1.0-py37hdc87d0a_5.tar.bz2": { + "build": "py37hdc87d0a_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d0b9f414e3381f3289cf1c3d91e66e26", + "name": "caffe-gpu", + "sha256": "023a264aea8a3fcbbf4ac144d9133a527b09a1e8dbe326aff3586f84b485d57a", + "size": 5429547, + "subdir": "linux-64", + "timestamp": 1549040294835, + "version": "1.0" + }, + "cairo-1.14.10-h58b644b_4.tar.bz2": { + "build": "h58b644b_4", + "build_number": 4, + "depends": [ + "fontconfig >=2.12.4,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb", + "pixman 0.34.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL 2.1 or MPL 1.1", + "md5": "3855104b9f3c67bcc2a031ddb8cbe59f", + "name": "cairo", + "sha256": "7dd6c7ab4c68a66c6ed684c6694b8907dff56f7ba415ba6b318593a2692b47a4", + "size": 1429310, + "subdir": "linux-64", + "timestamp": 1505741820132, + "version": "1.14.10" + }, + "cairo-1.14.10-haa5651f_5.tar.bz2": { + "build": "haa5651f_5", + "build_number": 5, + "depends": [ + "fontconfig >=2.12.4,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL 2.1 or MPL 1.1", + "md5": "3f0328ead427c913a5674f7a788e62d6", + "name": "cairo", + "sha256": "1e1337b8aa100c2d5dfda4d3e1c8c69bc7d6e7efedf3bac86855f0a0970c27e6", + "size": 1430830, + "subdir": "linux-64", + "timestamp": 1507907806254, + "version": "1.14.10" + }, + "cairo-1.14.10-hdf128ce_6.tar.bz2": { + "build": "hdf128ce_6", + "build_number": 6, + "depends": [ + "fontconfig >=2.12.4,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.12,<2.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL 2.1 or MPL 1.1", + "md5": "d7f108ca96f36def9c7f0a67d7eac3ed", + "name": "cairo", + "sha256": "82b13179aad507e3949cdf2b80b91e235a6f6601399f0f5ab379b09b0559257b", + "size": 1430134, + "subdir": "linux-64", + "timestamp": 1510603633036, + "version": "1.14.10" + }, + "cairo-1.14.12-h7636065_2.tar.bz2": { + "build": "h7636065_2", + "build_number": 2, + "depends": [ + "fontconfig >=2.12.6,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.56.1,<3.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL 2.1 or MPL 1.1", + "md5": "07604bf06ffb225b3cb3ba1048d33460", + "name": "cairo", + "sha256": "5ce13a40efbf98ac32eed33134a1e9b78222b57488bb9e2ae013c01caae8345b", + "size": 1362260, + "subdir": "linux-64", + "timestamp": 1523667635809, + "version": "1.14.12" + }, + "cairo-1.14.12-h77bcde2_0.tar.bz2": { + "build": "h77bcde2_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.4,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.12,<2.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL 2.1 or MPL 1.1", + "md5": "89890ae1a38b5de827404b959a08cd6c", + "name": "cairo", + "sha256": "65f40d7493dff584501ebe2edcb4e8cab81eb0f8869354fae329e7e6514b9ad8", + "size": 1362671, + "subdir": "linux-64", + "timestamp": 1516745357146, + "version": "1.14.12" + }, + "cairo-1.14.12-h8948797_3.tar.bz2": { + "build": "h8948797_3", + "build_number": 3, + "depends": [ + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.1,<3.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL 2.1 or MPL 1.1", + "md5": "04de85ff90455bc862f551e939dd6fb4", + "name": "cairo", + "sha256": "a13c438bb38edc835c64588ff50d290277d6419a810f6f22833e9116dc909e9b", + "size": 1362804, + "subdir": "linux-64", + "timestamp": 1527255730563, + "version": "1.14.12" + }, + "cairo-1.16.0-h19f5f5c_2.tar.bz2": { + "build": "h19f5f5c_2", + "build_number": 2, + "depends": [ + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libxcb >=1.15,<2.0a0", + "pixman >=0.40.0,<1.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later or MPL-1.1", + "license_family": "LGPL", + "md5": "ec69c918d097c392992a7fbe52d252d3", + "name": "cairo", + "sha256": "053b2284fe86f4adbdf4b39ce4d9d9d0ae0f49b0d3ef966eee96bc17c3f028f9", + "size": 1573265, + "subdir": "linux-64", + "timestamp": 1654193721539, + "version": "1.16.0" + }, + "cairo-1.16.0-hb05425b_3.tar.bz2": { + "build": "hb05425b_3", + "build_number": 3, + "depends": [ + "fontconfig >=2.14.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libxcb >=1.15,<2.0a0", + "pixman >=0.40.0,<1.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later or MPL-1.1", + "license_family": "LGPL", + "md5": "1082322b4aeee680f616f810a029e8ce", + "name": "cairo", + "sha256": "a9fdb370139ca5f0b141f19e3331e5522c2bc34e09feb0d6d9fd41b887f5090c", + "size": 1581992, + "subdir": "linux-64", + "timestamp": 1671102123693, + "version": "1.16.0" + }, + "cairo-1.16.0-hb05425b_4.tar.bz2": { + "build": "hb05425b_4", + "build_number": 4, + "depends": [ + "fontconfig >=2.14.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.39,<1.7.0a0", + "libxcb >=1.15,<2.0a0", + "pixman >=0.40.0,<1.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later or MPL-1.1", + "license_family": "LGPL", + "md5": "19e77f484192293209c63ba21830cfdb", + "name": "cairo", + "sha256": "ab3f5436f77a9edede0a0ed12ed4b8184233bcfab12b8cfc66b95adc622f2f18", + "size": 1580558, + "subdir": "linux-64", + "timestamp": 1678783282904, + "version": "1.16.0" + }, + "cairo-1.16.0-hf32fb01_1.tar.bz2": { + "build": "hf32fb01_1", + "build_number": 1, + "depends": [ + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.67.4,<3.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libxcb >=1.14,<2.0a0", + "pixman >=0.40.0,<1.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL 2.1 or MPL 1.1", + "md5": "4c1adb402948673d3fc537e8a41a14fc", + "name": "cairo", + "sha256": "78014123afaec685735358acd62ca59c37b1cb08b6e31aa7d616afab9b352885", + "size": 1579217, + "subdir": "linux-64", + "timestamp": 1615260566990, + "version": "1.16.0" + }, + "calver-2022.6.26-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "adf23f15bf30d17f4061c44445b153a7", + "name": "calver", + "sha256": "64d3db5829dcefc186a0a1a2d2c3126438061ce30c8cd911cde44a3907a8a982", + "size": 12778, + "subdir": "linux-64", + "timestamp": 1679595815695, + "version": "2022.6.26" + }, + "calver-2022.6.26-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "bb98d61297610660ff638673666e5ac5", + "name": "calver", + "sha256": "d5400ff2bb60f55ed83d114d00c9e780049ea60a0efb95ae235ab8ed03072da8", + "size": 13504, + "subdir": "linux-64", + "timestamp": 1679595866767, + "version": "2022.6.26" + }, + "calver-2022.6.26-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8efbc7b1eb3b5324209ee93626b213de", + "name": "calver", + "sha256": "fb12b7467b2858dd89d9a88a6848221346e42b95f684a93e658fbf4249cb6997", + "size": 12715, + "subdir": "linux-64", + "timestamp": 1679595841062, + "version": "2022.6.26" + }, + "calver-2022.6.26-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "0d7172959f6235b56828b92d38389aa7", + "name": "calver", + "sha256": "369d6861f381699a9689d4f2da0540c839725af7b613775f212399a0c5f3b0ba", + "size": 12701, + "subdir": "linux-64", + "timestamp": 1679595789365, + "version": "2022.6.26" + }, + "capnproto-0.9.1-h4ff587b_0.tar.bz2": { + "build": "h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1m,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "9b1d928e96847ecdc64550e7375228bc", + "name": "capnproto", + "sha256": "e417a4251571d1c5834f8845e5efe5e60f19fd5d5fea8a0b283f46b83141571c", + "size": 4668415, + "subdir": "linux-64", + "timestamp": 1643906202839, + "version": "0.9.1" + }, + "capturer-2.1.1-py27h33f98cf_0.tar.bz2": { + "build": "py27h33f98cf_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d7a3896f9c0223de1dd6fa804ae3ed8e", + "name": "capturer", + "sha256": "cd36a9a8c1b9636519397b576b5e82d9152e28509d8033bb6e20879febf5af60", + "size": 22914, + "subdir": "linux-64", + "timestamp": 1505741836589, + "version": "2.1.1" + }, + "capturer-2.1.1-py35h41e74de_0.tar.bz2": { + "build": "py35h41e74de_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "ff26d0db9cf4c54e3ee9ec82a91c87b5", + "name": "capturer", + "sha256": "280300b466a1ed5c6b4ac752054760abd3506b1ed5652350422566475c7cace0", + "size": 23412, + "subdir": "linux-64", + "timestamp": 1505741848526, + "version": "2.1.1" + }, + "capturer-2.1.1-py36h1fde460_0.tar.bz2": { + "build": "py36h1fde460_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "98275cf4f6a987d038f48a93534a6145", + "name": "capturer", + "sha256": "ceea3fb67515c35491324bed320cdc5af8a19e1548d7957255dccf167c7b1e01", + "size": 23366, + "subdir": "linux-64", + "timestamp": 1505741860549, + "version": "2.1.1" + }, + "capturer-2.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "570cac8b7b9c87f1def17d8b3e032022", + "name": "capturer", + "sha256": "654a62ba37bfde2d8171957ab691fe723ea882e993dad0b205f0cbc9fe7e1b12", + "size": 23895, + "subdir": "linux-64", + "timestamp": 1530811030222, + "version": "2.4" + }, + "capturer-2.4-py27h249d9a3_0.tar.bz2": { + "build": "py27h249d9a3_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "21b29f98e822520b88156d590a4b7e39", + "name": "capturer", + "sha256": "ce8af4cbc675664e5d6b8d8f15421f9cf5cae57c1473a4d68f7802c06d36832b", + "size": 24274, + "subdir": "linux-64", + "timestamp": 1511924992135, + "version": "2.4" + }, + "capturer-2.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "6e42b875938f2240a56425c3fd5e3b4d", + "name": "capturer", + "sha256": "0a0d2fcec00e05bc36eac4812449e9861bf61bb459dd036d8aa9d3b15c7c1d35", + "size": 24869, + "subdir": "linux-64", + "timestamp": 1640803813430, + "version": "2.4" + }, + "capturer-2.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "a4916700b2487963795ba88110b5ba0e", + "name": "capturer", + "sha256": "1f705658a5e0f3637bf776dca275d1e74eb050858389605077c43c74a12e50e1", + "size": 30103, + "subdir": "linux-64", + "timestamp": 1676847107476, + "version": "2.4" + }, + "capturer-2.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "919d761bb9014a571323c81018eae89e", + "name": "capturer", + "sha256": "374b6db1590693d5c13848a2b6519ff78da0c0da3a2b1c379d4de5978a1af543", + "size": 24386, + "subdir": "linux-64", + "timestamp": 1535129591650, + "version": "2.4" + }, + "capturer-2.4-py35h861ddf8_0.tar.bz2": { + "build": "py35h861ddf8_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "5c136472e88495fa06a5ee98abf2f6cc", + "name": "capturer", + "sha256": "384a3caa4f0cc78d83a48192938d4b614e04e91492c7152df163fa9d36af2956", + "size": 24728, + "subdir": "linux-64", + "timestamp": 1511925007516, + "version": "2.4" + }, + "capturer-2.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3c7bc90979cb81fbee03f44db23a0242", + "name": "capturer", + "sha256": "45bf876d40c7677534acf684c863a9fb60d877d856e39fe024a52fbe1235ccaf", + "size": 24309, + "subdir": "linux-64", + "timestamp": 1530811078614, + "version": "2.4" + }, + "capturer-2.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "efc14405c38bad91da8e1905c00d2357", + "name": "capturer", + "sha256": "f4ddedf7ae02020db921d53da4d1b307f06fb6e23c1c1dee111fe414478e23ad", + "size": 25956, + "subdir": "linux-64", + "timestamp": 1614257642712, + "version": "2.4" + }, + "capturer-2.4-py36hed228ed_0.tar.bz2": { + "build": "py36hed228ed_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b6db61a26c808eae2effab39ea9c2411", + "name": "capturer", + "sha256": "ea0ecf6493bc56d0be9fadc561f82bea6b1236a02535976cc95ed712451917ba", + "size": 24645, + "subdir": "linux-64", + "timestamp": 1511925020260, + "version": "2.4" + }, + "capturer-2.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "677cdd3cc5219ccb08c885395891a801", + "name": "capturer", + "sha256": "a9836d5a04399a7359ff0b4d981f1274c48512c8c17f01f628a917792e6a16c9", + "size": 24313, + "subdir": "linux-64", + "timestamp": 1530811054198, + "version": "2.4" + }, + "capturer-2.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3180d47332d13270147b4c7efe802dd4", + "name": "capturer", + "sha256": "c1faca6ffe3cdb663b32d854fa80249de5ed384586588e7f05fde30174ac53c5", + "size": 25951, + "subdir": "linux-64", + "timestamp": 1614257625191, + "version": "2.4" + }, + "capturer-2.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "8a16c341a41c3c93a07e68a83f679ed1", + "name": "capturer", + "sha256": "06fa42d1321e92c68c595f16a02fd51d9ff815c63c17e9cfd6a41b123b685971", + "size": 24794, + "subdir": "linux-64", + "timestamp": 1573738326660, + "version": "2.4" + }, + "capturer-2.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "264fe97fe5089941e0c028470eebc1e0", + "name": "capturer", + "sha256": "e6af3f990155fa9a585b81b81162cd05a5d9f17cbc66977ed68ce7a7a71211a1", + "size": 25995, + "subdir": "linux-64", + "timestamp": 1614257623967, + "version": "2.4" + }, + "capturer-2.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "81d15190297b1f5dda93526115705028", + "name": "capturer", + "sha256": "0246e0104fbabadfd43151abeb66240f32da90275822406a80ea756093b1e377", + "size": 26069, + "subdir": "linux-64", + "timestamp": 1614257626329, + "version": "2.4" + }, + "capturer-3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a9bb6720b6e31a50e5ce052e0247052c", + "name": "capturer", + "sha256": "e2ab31c51247540b869b7420ad23feb5784f4b7b2d5f895de1f7f9d76c7248de", + "size": 24358, + "subdir": "linux-64", + "timestamp": 1601395328798, + "version": "3.0" + }, + "capturer-3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2b42690c3dc22a9c9029c7be6b530972", + "name": "capturer", + "sha256": "014f5ac3f969f0dacafe1d363518a104dae616a9c33067671efd3aae3263dad6", + "size": 24336, + "subdir": "linux-64", + "timestamp": 1601397570968, + "version": "3.0" + }, + "capturer-3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "8c437cb217988c03a78c98ff5a0298f0", + "name": "capturer", + "sha256": "aa444d45ce08ba95e846993d65a1402a115eca233795daf60e498189fc9b082a", + "size": 24351, + "subdir": "linux-64", + "timestamp": 1601395326160, + "version": "3.0" + }, + "cargo-bundle-licenses-0.5.0-h52d8a92_0.tar.bz2": { + "build": "h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT and Apache-2.0", + "license_family": "MIT", + "md5": "fa6b6001647f117c80ae5763b1c5a63f", + "name": "cargo-bundle-licenses", + "sha256": "9845a961ebcc2044860fd3a900a9b72fb4f22fc4ee65b486580ce0e6e5d4a032", + "size": 1211237, + "subdir": "linux-64", + "timestamp": 1667957596970, + "version": "0.5.0" + }, + "cartopy-0.15.1-py27h29bd39c_5.tar.bz2": { + "build": "py27h29bd39c_5", + "build_number": 5, + "depends": [ + "geos", + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "owslib", + "pillow", + "proj4", + "proj4 >=4.9.3,<4.9.4.0a0", + "pyepsg", + "pyshp", + "python >=2.7,<2.8.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "5382489ed7fd44ce13ec1853be419519", + "name": "cartopy", + "sha256": "7bdbbee962899147276dbd7bd82a77dd63571ee384941b1b473515393d5beaf5", + "size": 1798620, + "subdir": "linux-64", + "timestamp": 1511996597261, + "version": "0.15.1" + }, + "cartopy-0.15.1-py35h94dd845_5.tar.bz2": { + "build": "py35h94dd845_5", + "build_number": 5, + "depends": [ + "geos", + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "owslib", + "pillow", + "proj4", + "proj4 >=4.9.3,<4.9.4.0a0", + "pyepsg", + "pyshp", + "python >=3.5,<3.6.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "689861e352d14afd79df01f315be1956", + "name": "cartopy", + "sha256": "dbb5124b4c4e709736f741b1fbff7e874db94d20ee4604c1db495f7bca1a770a", + "size": 1788968, + "subdir": "linux-64", + "timestamp": 1511996621529, + "version": "0.15.1" + }, + "cartopy-0.15.1-py36hab8bdb6_5.tar.bz2": { + "build": "py36hab8bdb6_5", + "build_number": 5, + "depends": [ + "geos", + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "owslib", + "pillow", + "proj4", + "proj4 >=4.9.3,<4.9.4.0a0", + "pyepsg", + "pyshp", + "python >=3.6,<3.7.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "72885ec2ca6bf9eac6038b4d00eac995", + "name": "cartopy", + "sha256": "47fa0b4d3bbe54e371d6923dd9a2c2fa81af04733487e82bedef545cfc0b6f5f", + "size": 1792394, + "subdir": "linux-64", + "timestamp": 1511996475493, + "version": "0.15.1" + }, + "cartopy-0.16.0-py27hf32a85a_0.tar.bz2": { + "build": "py27hf32a85a_0", + "build_number": 0, + "depends": [ + "geos", + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "owslib", + "pillow", + "proj4", + "proj4 >=4.9.3,<4.9.4.0a0", + "pyepsg", + "pyshp", + "python >=2.7,<2.8.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "9881753482b046cd51dc77a7a45e5952", + "name": "cartopy", + "sha256": "b548af0a8fe1cfff49eaba86d1b19e4e8b40bdee17a452b94f9ff4c0547fb5be", + "size": 1798205, + "subdir": "linux-64", + "timestamp": 1519496881617, + "version": "0.16.0" + }, + "cartopy-0.16.0-py27hfa13621_0.tar.bz2": { + "build": "py27hfa13621_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "owslib", + "pillow", + "proj4 >=5.0.1,<5.0.2.0a0", + "pyepsg", + "pyshp", + "python >=2.7,<2.8.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "3dfbe64e35a3dcf2ed769d799ace20f2", + "name": "cartopy", + "sha256": "c56de3756cc97b87aeaea04f3b50e3f7d5e21dd7ae1ee3a595826d52426390cb", + "size": 1810261, + "subdir": "linux-64", + "timestamp": 1530811722611, + "version": "0.16.0" + }, + "cartopy-0.16.0-py35hf32a85a_0.tar.bz2": { + "build": "py35hf32a85a_0", + "build_number": 0, + "depends": [ + "geos", + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "owslib", + "pillow", + "proj4", + "proj4 >=4.9.3,<4.9.4.0a0", + "pyepsg", + "pyshp", + "python >=3.5,<3.6.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "19744361c547e6298ff56df4fe69ae1f", + "name": "cartopy", + "sha256": "4904ef8b4f0c9af868050ce3ff4a36ee3490b59a32305482ff948f07d35cd784", + "size": 1790194, + "subdir": "linux-64", + "timestamp": 1519495364225, + "version": "0.16.0" + }, + "cartopy-0.16.0-py35hfa13621_0.tar.bz2": { + "build": "py35hfa13621_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "owslib", + "pillow", + "proj4 >=5.1.0,<5.1.1.0a0", + "pyepsg", + "pyshp", + "python >=3.5,<3.6.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "523729a8ce1b2f738513b178d2de1a2c", + "name": "cartopy", + "sha256": "5f8b2c8de3772b8168273141c22342441de5999d5d00be03025262fed48a0f97", + "size": 1799597, + "subdir": "linux-64", + "timestamp": 1535129804361, + "version": "0.16.0" + }, + "cartopy-0.16.0-py36hf32a85a_0.tar.bz2": { + "build": "py36hf32a85a_0", + "build_number": 0, + "depends": [ + "geos", + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "owslib", + "pillow", + "proj4", + "proj4 >=4.9.3,<4.9.4.0a0", + "pyepsg", + "pyshp", + "python >=3.6,<3.7.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "4c2356af98780dc021e3abe6a989d0ea", + "name": "cartopy", + "sha256": "b4e70c228ead5403b87a647a8ba1699651b5da77fece6fba5ea086878fcdebd8", + "size": 1795132, + "subdir": "linux-64", + "timestamp": 1519496704139, + "version": "0.16.0" + }, + "cartopy-0.16.0-py36hfa13621_0.tar.bz2": { + "build": "py36hfa13621_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "owslib", + "pillow", + "proj4 >=5.0.1,<5.0.2.0a0", + "pyepsg", + "pyshp", + "python >=3.6,<3.7.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "04ade8d75e1e1c7902b8d8f4685f2561", + "name": "cartopy", + "sha256": "2c5afe6ee8a5ac49579a98896247da6e4bfc1f76f0c03b6d8c5dc88f3edeebcc", + "size": 1807177, + "subdir": "linux-64", + "timestamp": 1530811855609, + "version": "0.16.0" + }, + "cartopy-0.16.0-py37hfa13621_0.tar.bz2": { + "build": "py37hfa13621_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "owslib", + "pillow", + "proj4 >=5.0.1,<5.0.2.0a0", + "pyepsg", + "pyshp", + "python >=3.7,<3.8.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "51235f9adc5120b1e4b74666844def1e", + "name": "cartopy", + "sha256": "7727c1af2241282cdaf2f0701277b4399dc0533f6f62bd9098dc28b7f167705f", + "size": 1801943, + "subdir": "linux-64", + "timestamp": 1530811789382, + "version": "0.16.0" + }, + "cartopy-0.17.0-py27hbb7e04d_1.tar.bz2": { + "build": "py27hbb7e04d_1", + "build_number": 1, + "depends": [ + "geos >=3.7.1,<3.7.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "owslib", + "pillow", + "proj4 >=5.2.0,<5.2.1.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=2.7,<2.8.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "7846b255450bdb99dac34e58e92ec43a", + "name": "cartopy", + "sha256": "286d40f29eec804e550f81c1f5a44220e4d30124b025ae1ebf70912c7547f41e", + "size": 1849148, + "subdir": "linux-64", + "timestamp": 1545322749856, + "version": "0.17.0" + }, + "cartopy-0.17.0-py36h3e2e9bd_1.tar.bz2": { + "build": "py36h3e2e9bd_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.14.6,<2.0a0", + "owslib", + "pillow", + "proj >=7.0.1,<7.0.2.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.6,<3.7.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "b6773d5137441ce04c7280fa3aa34db6", + "name": "cartopy", + "sha256": "20d0a884bc2e80188e0ff57f038fff5064129777df7ed512b77dfcc0ce0cf592", + "size": 1859369, + "subdir": "linux-64", + "timestamp": 1590596247047, + "version": "0.17.0" + }, + "cartopy-0.17.0-py36hbb7e04d_1.tar.bz2": { + "build": "py36hbb7e04d_1", + "build_number": 1, + "depends": [ + "geos >=3.7.1,<3.7.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "owslib", + "pillow", + "proj4 >=5.2.0,<5.2.1.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.6,<3.7.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "8be82e13d9c864d4f9b54c6cbe7a270b", + "name": "cartopy", + "sha256": "d88950c45a6c8bdadbd6a6cb5c36d4402fb0de98b5c177dbb7578f7b3fb4cd68", + "size": 1849955, + "subdir": "linux-64", + "timestamp": 1545322754374, + "version": "0.17.0" + }, + "cartopy-0.17.0-py36hee755e7_1.tar.bz2": { + "build": "py36hee755e7_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.14.6,<2.0a0", + "owslib", + "pillow", + "proj >=6.2.1,<6.2.2.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.6,<3.7.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "0ca1105c6a9d3a5af277279d47797489", + "name": "cartopy", + "sha256": "b9b5dd9cda68a907635c251695288df6354f22c4be8a75fd7cb90c730c794bef", + "size": 1874389, + "subdir": "linux-64", + "timestamp": 1590596220582, + "version": "0.17.0" + }, + "cartopy-0.17.0-py37h3e2e9bd_1.tar.bz2": { + "build": "py37h3e2e9bd_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.14.6,<2.0a0", + "owslib", + "pillow", + "proj >=7.0.1,<7.0.2.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.7,<3.8.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "2037f4691196000bdbce21fb7ffd01cf", + "name": "cartopy", + "sha256": "19c5b3281ea1f7926fcd154192950cc0a0f1d8b13a74d8b3b0eb31e34aa329ac", + "size": 1871023, + "subdir": "linux-64", + "timestamp": 1590596252010, + "version": "0.17.0" + }, + "cartopy-0.17.0-py37hbb7e04d_1.tar.bz2": { + "build": "py37hbb7e04d_1", + "build_number": 1, + "depends": [ + "geos >=3.7.1,<3.7.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "owslib", + "pillow", + "proj4 >=5.2.0,<5.2.1.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.7,<3.8.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "1d46588f1ad37c9689732312fbafcef7", + "name": "cartopy", + "sha256": "e67dce5c1a50c8b03642ace181f0b9a7d3c4a1affe4c77075346a888d87358e2", + "size": 1883831, + "subdir": "linux-64", + "timestamp": 1545322747480, + "version": "0.17.0" + }, + "cartopy-0.17.0-py37hee755e7_1.tar.bz2": { + "build": "py37hee755e7_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.14.6,<2.0a0", + "owslib", + "pillow", + "proj >=6.2.1,<6.2.2.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.7,<3.8.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "eec82afd82e304976a1d7084eafbbc85", + "name": "cartopy", + "sha256": "78d2f0de01b3ebfaa3ca06c0fee9eda220870c95a0798e04ac01f1005519d306", + "size": 1856122, + "subdir": "linux-64", + "timestamp": 1590596185086, + "version": "0.17.0" + }, + "cartopy-0.17.0-py38h3e2e9bd_1.tar.bz2": { + "build": "py38h3e2e9bd_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.14.6,<2.0a0", + "owslib", + "pillow", + "proj >=7.0.1,<7.0.2.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.8,<3.9.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "f88087eaa3cdea17d019da23200c1451", + "name": "cartopy", + "sha256": "c2d9ce1c267a32538fa1bdb1dae44aff3d84f4a1ff819f0a3b5083f8a1c9869e", + "size": 1896366, + "subdir": "linux-64", + "timestamp": 1590596184903, + "version": "0.17.0" + }, + "cartopy-0.17.0-py38hee755e7_1.tar.bz2": { + "build": "py38hee755e7_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.14.6,<2.0a0", + "owslib", + "pillow", + "proj >=6.2.1,<6.2.2.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.8,<3.9.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "a678359c009e02cd359a05ba624eb332", + "name": "cartopy", + "sha256": "67599d4f547e28f771fcdfbb90f2f57a39d582cb1129ba5fe4cb6098b84964d6", + "size": 1886797, + "subdir": "linux-64", + "timestamp": 1590596246402, + "version": "0.17.0" + }, + "cartopy-0.18.0-py310h95ad73f_2.tar.bz2": { + "build": "py310h95ad73f_2", + "build_number": 2, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.5.1", + "numpy >=1.21.2,<2.0a0", + "proj <8.0.0", + "proj >=7.2.0,<7.2.1.0a0", + "pyshp >=1.1.4", + "python >=3.10,<3.11.0a0", + "scipy >=0.10", + "shapely >=1.5.6", + "six >=1.3.0" + ], + "license": "LGPL-3", + "md5": "fbd5fa4b7e686f50df911767245bfd4d", + "name": "cartopy", + "sha256": "2ad5839cb5098996359e407f887265c67dd801cd0680faad1baa09f609f394f1", + "size": 2938695, + "subdir": "linux-64", + "timestamp": 1643105523404, + "version": "0.18.0" + }, + "cartopy-0.18.0-py36h0d9ca2b_1.tar.bz2": { + "build": "py36h0d9ca2b_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=1.5.1", + "numpy >=1.16.6,<2.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "pyshp >=1.1.4", + "python >=3.6,<3.7.0a0", + "scipy >=0.10", + "shapely >=1.5.6", + "six >=1.3.0" + ], + "license": "LGPL-3", + "md5": "d4454636d43a9e0adbd6cd17afb89f72", + "name": "cartopy", + "sha256": "74275ae22a6871cdf5915f51e650c02eed936b4f8b8dba9e6c769863968fdc5e", + "size": 1988266, + "subdir": "linux-64", + "timestamp": 1612289905649, + "version": "0.18.0" + }, + "cartopy-0.18.0-py36hee755e7_0.tar.bz2": { + "build": "py36hee755e7_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.14.6,<2.0a0", + "owslib", + "pillow", + "proj >=6.2.1,<6.2.2.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.6,<3.7.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "0923965c4afc9446b50321de05530191", + "name": "cartopy", + "sha256": "6607d793719244f056ffa52d845e58ae41b6d4b12ae34005f7b51d45ea3355cc", + "size": 1960465, + "subdir": "linux-64", + "timestamp": 1594325513199, + "version": "0.18.0" + }, + "cartopy-0.18.0-py37h0d9ca2b_1.tar.bz2": { + "build": "py37h0d9ca2b_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=1.5.1", + "numpy >=1.16.6,<2.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "pyshp >=1.1.4", + "python >=3.7,<3.8.0a0", + "scipy >=0.10", + "shapely >=1.5.6", + "six >=1.3.0" + ], + "license": "LGPL-3", + "md5": "53be426d16f17c80118c266895d1974e", + "name": "cartopy", + "sha256": "ed195bb400d8267338d083b01c3afa0a91cb600c321af30fced629f0740a0a97", + "size": 1962533, + "subdir": "linux-64", + "timestamp": 1612289899445, + "version": "0.18.0" + }, + "cartopy-0.18.0-py37hc576cba_1.tar.bz2": { + "build": "py37hc576cba_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.5.1", + "numpy >=1.16.6,<2.0a0", + "proj <8.0.0", + "proj >=7.0.1,<7.0.2.0a0", + "pyshp >=1.1.4", + "python >=3.7,<3.8.0a0", + "scipy >=0.10", + "shapely >=1.5.6", + "six >=1.3.0" + ], + "license": "LGPL-3", + "md5": "5722a4096538ad801af9e8790d7505dd", + "name": "cartopy", + "sha256": "02abc0153e7ef9b73b335ff470ea5181478e340d31d266583eceb85b5ef114b5", + "size": 2002979, + "subdir": "linux-64", + "timestamp": 1636039169806, + "version": "0.18.0" + }, + "cartopy-0.18.0-py37hee755e7_0.tar.bz2": { + "build": "py37hee755e7_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.14.6,<2.0a0", + "owslib", + "pillow", + "proj >=6.2.1,<6.2.2.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.7,<3.8.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "6499deacca81fd355a53ad866a5398b4", + "name": "cartopy", + "sha256": "2f0e60c13767e85c278e368484cf42c37234e5ae60d0f81ae91e08e27158b5f2", + "size": 1957701, + "subdir": "linux-64", + "timestamp": 1594325525207, + "version": "0.18.0" + }, + "cartopy-0.18.0-py38h0d9ca2b_1.tar.bz2": { + "build": "py38h0d9ca2b_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=1.5.1", + "numpy >=1.16.6,<2.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "pyshp >=1.1.4", + "python >=3.8,<3.9.0a0", + "scipy >=0.10", + "shapely >=1.5.6", + "six >=1.3.0" + ], + "license": "LGPL-3", + "md5": "230643b4dd9216e446ad2111b40cd927", + "name": "cartopy", + "sha256": "92589e250abbc4bd65e332a91d0729beecad606fc8dbf95698c44e9769e5c1da", + "size": 2000219, + "subdir": "linux-64", + "timestamp": 1612289540164, + "version": "0.18.0" + }, + "cartopy-0.18.0-py38hc576cba_1.tar.bz2": { + "build": "py38hc576cba_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.5.1", + "numpy >=1.16.6,<2.0a0", + "proj <8.0.0", + "proj >=7.0.1,<7.0.2.0a0", + "pyshp >=1.1.4", + "python >=3.8,<3.9.0a0", + "scipy >=0.10", + "shapely >=1.5.6", + "six >=1.3.0" + ], + "license": "LGPL-3", + "md5": "e82d649381460e13ca4c2047690a48ba", + "name": "cartopy", + "sha256": "96a603cf68d1405c75dede0b1efb4c0d679706172138c55ba861c1b11cd31f35", + "size": 2006570, + "subdir": "linux-64", + "timestamp": 1636039142654, + "version": "0.18.0" + }, + "cartopy-0.18.0-py38hee755e7_0.tar.bz2": { + "build": "py38hee755e7_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.14.6,<2.0a0", + "owslib", + "pillow", + "proj >=6.2.1,<6.2.2.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.8,<3.9.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "1c625a6320de19f006ac0dd847bce3ab", + "name": "cartopy", + "sha256": "a70bbdfb89a3e24732cbd5fb3a47f3b57f9dc5e0fda3ed0c105fb76b643bb877", + "size": 1958108, + "subdir": "linux-64", + "timestamp": 1594325513176, + "version": "0.18.0" + }, + "cartopy-0.18.0-py39h0d9ca2b_1.tar.bz2": { + "build": "py39h0d9ca2b_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=1.5.1", + "numpy >=1.16.6,<2.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "pyshp >=1.1.4", + "python >=3.9,<3.10.0a0", + "scipy >=0.10", + "shapely >=1.5.6", + "six >=1.3.0" + ], + "license": "LGPL-3", + "md5": "1cae851a58d2b55c9838ba4cbccefa85", + "name": "cartopy", + "sha256": "090e0ae72581fc1b4907eabb37fd38e96e3d2e52a5ac02ffaf94b4dec3b648d7", + "size": 2014685, + "subdir": "linux-64", + "timestamp": 1613152008142, + "version": "0.18.0" + }, + "cartopy-0.18.0-py39hc576cba_1.tar.bz2": { + "build": "py39hc576cba_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.5.1", + "numpy >=1.16.6,<2.0a0", + "proj <8.0.0", + "proj >=7.0.1,<7.0.2.0a0", + "pyshp >=1.1.4", + "python >=3.9,<3.10.0a0", + "scipy >=0.10", + "shapely >=1.5.6", + "six >=1.3.0" + ], + "license": "LGPL-3", + "md5": "31d7c4c5a112768ac0620214d061caaf", + "name": "cartopy", + "sha256": "ae33fa1f6310098bb7216788ce9c02d1f37a0699102f5f55c9cd0d4d80647ec9", + "size": 2018037, + "subdir": "linux-64", + "timestamp": 1636027144755, + "version": "0.18.0" + }, + "cartopy-0.21.1-py310h1176785_0.tar.bz2": { + "build": "py310h1176785_0", + "build_number": 0, + "constrains": [ + "scipy >=1.3.1" + ], + "depends": [ + "geos >=3.7.2", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=3.1", + "numpy >=1.21.5,<2.0a0", + "pyproj >=3.0.0", + "pyshp >=2.1", + "python >=3.10,<3.11.0a0", + "shapely >=1.6.4" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "5c06bb172330026463e573e675aaee43", + "name": "cartopy", + "sha256": "e0386f8cdc088aea91f3fa10688120f3238318c0bca91670ff5c2e22dec4189b", + "size": 1721500, + "subdir": "linux-64", + "timestamp": 1674677817010, + "version": "0.21.1" + }, + "cartopy-0.21.1-py311h1176785_0.tar.bz2": { + "build": "py311h1176785_0", + "build_number": 0, + "constrains": [ + "scipy >=1.3.1" + ], + "depends": [ + "geos >=3.7.2", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=3.1", + "numpy >=1.23.5,<2.0a0", + "pyproj >=3.0.0", + "pyshp >=2.1", + "python >=3.11,<3.12.0a0", + "shapely >=1.6.4" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "4b0af80567394a17f21b080e98177713", + "name": "cartopy", + "sha256": "a0fa1c4b17d9a1707abd8df323c5faa85f8539f10f0a596a429c8a87e82d18ad", + "size": 1885288, + "subdir": "linux-64", + "timestamp": 1676843481637, + "version": "0.21.1" + }, + "cartopy-0.21.1-py38h1176785_0.tar.bz2": { + "build": "py38h1176785_0", + "build_number": 0, + "constrains": [ + "scipy >=1.3.1" + ], + "depends": [ + "geos >=3.7.2", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=3.1", + "numpy >=1.19.2,<2.0a0", + "pyproj >=3.0.0", + "pyshp >=2.1", + "python >=3.8,<3.9.0a0", + "shapely >=1.6.4" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "a25f70dce364a50dc80e3edc181b0200", + "name": "cartopy", + "sha256": "d115e13f7e8aeb5b8a1399b72222068897a349d26e5983a889e61483661d6005", + "size": 1712422, + "subdir": "linux-64", + "timestamp": 1674677911535, + "version": "0.21.1" + }, + "cartopy-0.21.1-py39h1176785_0.tar.bz2": { + "build": "py39h1176785_0", + "build_number": 0, + "constrains": [ + "scipy >=1.3.1" + ], + "depends": [ + "geos >=3.7.2", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=3.1", + "numpy >=1.19.2,<2.0a0", + "pyproj >=3.0.0", + "pyshp >=2.1", + "python >=3.9,<3.10.0a0", + "shapely >=1.6.4" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "6612c4bb38bd5dfe6c69d28e225a091c", + "name": "cartopy", + "sha256": "fd5d167b98f0ad36ec29ae92b8da3bdf4c6621bda1f841fc2ea68aac6687bbc3", + "size": 1715081, + "subdir": "linux-64", + "timestamp": 1674677999263, + "version": "0.21.1" + }, + "cassandra-driver-3.18.0-py36h27cfd23_2.tar.bz2": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "2ccc900a092af1163254a219d894643d", + "name": "cassandra-driver", + "sha256": "020a8cba857676a3561ddffcfcc3cee3b82954233dbe0f0230bf6b9beb125a40", + "size": 2984972, + "subdir": "linux-64", + "timestamp": 1614177027262, + "version": "3.18.0" + }, + "cassandra-driver-3.18.0-py37h27cfd23_2.tar.bz2": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "936612c6b8871ee776bfe412f6a110ec", + "name": "cassandra-driver", + "sha256": "b4559443501d6e3261b6a189fc7efade242004000e4876264044175146e04afe", + "size": 3004004, + "subdir": "linux-64", + "timestamp": 1614177019761, + "version": "3.18.0" + }, + "cassandra-driver-3.18.0-py38h27cfd23_2.tar.bz2": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "5359c44fe21225ea64cbbd95a39d4500", + "name": "cassandra-driver", + "sha256": "385641209785e1b92fdda6f43f385d266dd8ef267c74a3077855a349955e95be", + "size": 3214866, + "subdir": "linux-64", + "timestamp": 1614177022898, + "version": "3.18.0" + }, + "cassandra-driver-3.18.0-py39h27cfd23_2.tar.bz2": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.9,<3.10.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "d2b82f13ea0e84bb2d37514d47cb5c21", + "name": "cassandra-driver", + "sha256": "78b5b54eb5e9e5f61adf0aa1452b8573eb7a3c8eccb793db68e1d08efd684db3", + "size": 3224417, + "subdir": "linux-64", + "timestamp": 1614175979264, + "version": "3.18.0" + }, + "cassandra-driver-3.24.0-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "b38c18867c94b22cc9ccf9746cf490e0", + "name": "cassandra-driver", + "sha256": "9ae851917a27d87c4613d7b382ea51b5a566b2d9f1c6f7c46587aeda851e8df7", + "size": 3479510, + "subdir": "linux-64", + "timestamp": 1597171160469, + "version": "3.24.0" + }, + "cassandra-driver-3.25.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.5.0", + "numpy", + "python >=3.10,<3.11.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "8c890051f18ebea9575e5a138e1cbbbb", + "name": "cassandra-driver", + "sha256": "f57da95cb3f63b45d9cd9bf8e6c0c5b5f5eab430fa2e1781d324cb6c5a52accb", + "size": 14020723, + "subdir": "linux-64", + "timestamp": 1640788884143, + "version": "3.25.0" + }, + "cassandra-driver-3.25.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=11.2.0", + "numpy", + "python >=3.11,<3.12.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "705e75761760fb3c0762cd1bf412df64", + "name": "cassandra-driver", + "sha256": "37b14636901288f3a5e1225210847a9eed3902f0c24f0c5784ab3f7372ffafc8", + "size": 3735703, + "subdir": "linux-64", + "timestamp": 1676847260590, + "version": "3.25.0" + }, + "cassandra-driver-3.25.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "cf398078cdf55e1930d59f329d320b00", + "name": "cassandra-driver", + "sha256": "830de9594f9f3320e71cf0c074e9d7b81727a8cc83062363550d8681800da81a", + "size": 3534603, + "subdir": "linux-64", + "timestamp": 1616180875876, + "version": "3.25.0" + }, + "cassandra-driver-3.25.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "560b67b5e678052fb07e6bb7c3d44dbf", + "name": "cassandra-driver", + "sha256": "64f0b0f543afcc63eccf922c57e5539accf6e7c220fe08299d7e3b1786802a44", + "size": 3524287, + "subdir": "linux-64", + "timestamp": 1616178885333, + "version": "3.25.0" + }, + "cassandra-driver-3.25.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "16c85b892fbac1f7ed89d4a1072a372b", + "name": "cassandra-driver", + "sha256": "7de1eba3dfede8f15f57886aecf0409c3b21c7bbd3eb64aa87b757e214b50f7e", + "size": 3760985, + "subdir": "linux-64", + "timestamp": 1616180301368, + "version": "3.25.0" + }, + "cassandra-driver-3.25.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.9,<3.10.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "47ca83b70049941dd6db72df021fb4b1", + "name": "cassandra-driver", + "sha256": "ae35cc981e37d392bf3fe1cc5c74bc5b662fbcc47ec5c25b4d003646d723b492", + "size": 3774864, + "subdir": "linux-64", + "timestamp": 1616178876800, + "version": "3.25.0" + }, + "casuarius-1.1-py27he6710b0_2.tar.bz2": { + "build": "py27he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL", + "md5": "dd7d693d588a21552d46ad164c1d6571", + "name": "casuarius", + "sha256": "c477b58607b2bc3b96b8f55254afa03ec00fdddbb92ecb9084121d07bca471c9", + "size": 169378, + "subdir": "linux-64", + "timestamp": 1539203345644, + "version": "1.1" + }, + "catalogue-1.0.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5384491abc789ddda182c449cff89d3c", + "name": "catalogue", + "sha256": "999b84b475dccf1b01a480735ca6129b1bc37402aad368bf572437e64d7b2ac9", + "size": 15253, + "subdir": "linux-64", + "timestamp": 1590154470697, + "version": "1.0.0" + }, + "catalogue-1.0.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8b9d0cc3fc3060c19fe3b6f93d7af06b", + "name": "catalogue", + "sha256": "1600db5a3ec28c873a5f787c25dba08b8b2da8d0dd0abc0e54c59794e3df47ac", + "size": 15283, + "subdir": "linux-64", + "timestamp": 1590154513828, + "version": "1.0.0" + }, + "catalogue-1.0.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c87b5e393ea0d6818a832c75d9d0740", + "name": "catalogue", + "sha256": "f197a00cf7b9cfb5e945844d6fde99ca97d772483f54eab36c3f8d8b9b23bb43", + "size": 15273, + "subdir": "linux-64", + "timestamp": 1590154504705, + "version": "1.0.0" + }, + "catalogue-2.0.0-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e244f7b3970f8e134c7b8d36c4ce869e", + "name": "catalogue", + "sha256": "e8e131b5265d729524d45379421c22920134e29c454a7baeaf9a0b107ed029b6", + "size": 16650, + "subdir": "linux-64", + "timestamp": 1599271379513, + "version": "2.0.0" + }, + "catalogue-2.0.0-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e5101de5634e16614f05833276bdc4a", + "name": "catalogue", + "sha256": "f1349022659e819106f43f5c60829c2e6cf155f32d72e8083d7d31c31686f159", + "size": 13398, + "subdir": "linux-64", + "timestamp": 1594342616857, + "version": "2.0.0" + }, + "catalogue-2.0.0-py38_2.tar.bz2": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3246974bfbb23f87550490dd58ae61e3", + "name": "catalogue", + "sha256": "53bfb29f27449ddfc132789850580dfabed742fab0670d6282ae31a9800294c0", + "size": 16716, + "subdir": "linux-64", + "timestamp": 1599271374064, + "version": "2.0.0" + }, + "catalogue-2.0.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "decf87ea7d5907143df05461cfdcd3b6", + "name": "catalogue", + "sha256": "fac5201ccd2599046a3dee2e9fd2386e5c0805523c92c1d0308d55fc8fc11bc1", + "size": 20306, + "subdir": "linux-64", + "timestamp": 1608234321678, + "version": "2.0.1" + }, + "catalogue-2.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a16eca4d797b335d9768fac6769b4a8f", + "name": "catalogue", + "sha256": "0c3c434ecee57fb66d2033b41bab36fca7135f1e9469ccc78708e2b302d3320b", + "size": 20315, + "subdir": "linux-64", + "timestamp": 1608234324237, + "version": "2.0.1" + }, + "catalogue-2.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31ebef538d7e52697eab7c6f6b6761e2", + "name": "catalogue", + "sha256": "9c91facb8954f5285bbe2766a1ac615015e9608205c2eec0bcd1102f25dc3e47", + "size": 20397, + "subdir": "linux-64", + "timestamp": 1608234344953, + "version": "2.0.1" + }, + "catalogue-2.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "32d854a2bc5f1d37d69e2bdc9ce83d80", + "name": "catalogue", + "sha256": "2f5b105aa3e76874e35bb2618cfbbadd8bc3357f1a2d785e6dac9d9c38184f69", + "size": 20412, + "subdir": "linux-64", + "timestamp": 1608234337396, + "version": "2.0.1" + }, + "catalogue-2.0.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8fb01ab43bb62b7ab43ce8b019a9c7f", + "name": "catalogue", + "sha256": "c82e5fc79d14bc11d8729baa8f4628903496fada4e655c0ed987f84ac73efe0a", + "size": 17746, + "subdir": "linux-64", + "timestamp": 1618348502777, + "version": "2.0.2" + }, + "catalogue-2.0.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aad9c574591616954e7f7159c4387cca", + "name": "catalogue", + "sha256": "da60069716afadba4b9ced005fa5dcb021a0c304b131d01a6e6626eb2b27276d", + "size": 17722, + "subdir": "linux-64", + "timestamp": 1618348496478, + "version": "2.0.2" + }, + "catalogue-2.0.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d3ded3367ee46095057195b3a803233a", + "name": "catalogue", + "sha256": "21bc268f098f9615d16e8ebdeb0c627f806d413c9c9a729d184e467bca0cdb9a", + "size": 17746, + "subdir": "linux-64", + "timestamp": 1618345422186, + "version": "2.0.2" + }, + "catalogue-2.0.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.20,<3.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0fee160378eebfeb69c1c1079b894da5", + "name": "catalogue", + "sha256": "29f4d4c100d0efea642abe7cf81c66bf24999e84da1d9ec7074869076d37ad5f", + "size": 17799, + "subdir": "linux-64", + "timestamp": 1618390218807, + "version": "2.0.2" + }, + "catalogue-2.0.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f466b1c4a55f8a1eae036a4bb46c1a31", + "name": "catalogue", + "sha256": "b5de190cc1f4265f7ab7e5fb6edd5525def32052879fc7f5ed1326253527b2e0", + "size": 30844, + "subdir": "linux-64", + "timestamp": 1618521455476, + "version": "2.0.3" + }, + "catalogue-2.0.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "20cbabf7756787304e737684c8310baf", + "name": "catalogue", + "sha256": "580c8eafe69ad316ea429a4f043cc7955482efa8526fd83014cee8d829ee903a", + "size": 30843, + "subdir": "linux-64", + "timestamp": 1618521367759, + "version": "2.0.3" + }, + "catalogue-2.0.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c00190048632813755c9c74581667a9", + "name": "catalogue", + "sha256": "1476ef5c5c39aa975813dcdfef3a628f25bb67f29ba446128597ba5529513ab1", + "size": 31043, + "subdir": "linux-64", + "timestamp": 1618518296370, + "version": "2.0.3" + }, + "catalogue-2.0.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ac1fd5961d5e4c78aac4d9682a47750c", + "name": "catalogue", + "sha256": "3133c5a2593a7b6c8887cbef16258ddebfb76b7e936b62de4cc06e74f3dbe4bf", + "size": 31194, + "subdir": "linux-64", + "timestamp": 1618601326474, + "version": "2.0.3" + }, + "catalogue-2.0.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a9b9dea1af3661c0aa7e11ef798d159f", + "name": "catalogue", + "sha256": "67f9512a8044d587ff4169ae4f6a04fcbf3a9452d431bd6b45246acff663b442", + "size": 31376, + "subdir": "linux-64", + "timestamp": 1642503940277, + "version": "2.0.4" + }, + "catalogue-2.0.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "typing-extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "406bb2a9087bf5e600ae1d8174615b19", + "name": "catalogue", + "sha256": "e04af90b6616eac79224888df95ddb20e791db627951ebfcabd4534875e42af1", + "size": 33766, + "subdir": "linux-64", + "timestamp": 1632751065615, + "version": "2.0.4" + }, + "catalogue-2.0.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ae5314955b452c37ad625c17d0413f6", + "name": "catalogue", + "sha256": "3dc830d5d379820d48c5c979a2e59c4bbc0fd77b9afc6b3ad857e1cd20bc74cd", + "size": 33753, + "subdir": "linux-64", + "timestamp": 1632751053029, + "version": "2.0.4" + }, + "catalogue-2.0.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b84fab8f7433483a9b8c069c57d16f17", + "name": "catalogue", + "sha256": "12bc3271b5cce8a6fdb1489ead9d19ccac69a7910b6f3976088125234aa33c05", + "size": 33947, + "subdir": "linux-64", + "timestamp": 1632751049991, + "version": "2.0.4" + }, + "catalogue-2.0.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8a392104851edf9aac4562967f9ecb9", + "name": "catalogue", + "sha256": "ca9ba5f5e9c60abaf76a86537ff6fb069c7bccd59ada0049dd3a86da8771dabb", + "size": 31184, + "subdir": "linux-64", + "timestamp": 1619735034393, + "version": "2.0.4" + }, + "catalogue-2.0.6-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0e7c2c26429a8139aced41d5c2752f43", + "name": "catalogue", + "sha256": "d4a8aa60919f607bfdf8f21434724fc643506c631fcea653958f538ef14cf902", + "size": 31170, + "subdir": "linux-64", + "timestamp": 1643444403187, + "version": "2.0.6" + }, + "catalogue-2.0.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "946006f9fc54d01587d40bd749412348", + "name": "catalogue", + "sha256": "d1a2af688c82aa257271db25ea5c980b546569d1b260850a2bcf61cc51c2276f", + "size": 31336, + "subdir": "linux-64", + "timestamp": 1643444380620, + "version": "2.0.6" + }, + "catalogue-2.0.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9f5a16d7f39152898d01ddb721db77d", + "name": "catalogue", + "sha256": "d75b2a7e93772a08c436e4ba6b2ca4ccd69510c664daaee5aac3605bd6b4983a", + "size": 31308, + "subdir": "linux-64", + "timestamp": 1643444431792, + "version": "2.0.6" + }, + "catalogue-2.0.7-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85d9920ad682cd2a063552d4799f0ce0", + "name": "catalogue", + "sha256": "91299c76dea54efeb6d50d4b9b71198d2edeee4284f08d631e7309df25b7aac9", + "size": 31951, + "subdir": "linux-64", + "timestamp": 1651218842323, + "version": "2.0.7" + }, + "catalogue-2.0.7-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f1bff23fca322e54cd4e3a7c9786877", + "name": "catalogue", + "sha256": "408fd9eb2c5f7eb16b3bae2c8f02900bd0849dd05965063b8675952a1cedb020", + "size": 40174, + "subdir": "linux-64", + "timestamp": 1676830233084, + "version": "2.0.7" + }, + "catalogue-2.0.7-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f78043ae832e70b1a973a5a95098ee95", + "name": "catalogue", + "sha256": "7175eec9be60ea171a11b5848bcf696fcc6b8b4c57032e2ddf01f72e8776dbe4", + "size": 31489, + "subdir": "linux-64", + "timestamp": 1651218804423, + "version": "2.0.7" + }, + "catalogue-2.0.7-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0897e29ec7c1fafdd4d1aecceb27a36a", + "name": "catalogue", + "sha256": "c0d7f6aab01269bcf9f3723ef640fdffa7ab46bbac4619b1337b5b08f1267a0a", + "size": 31664, + "subdir": "linux-64", + "timestamp": 1651218867632, + "version": "2.0.7" + }, + "catalogue-2.0.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4340a6fd0f36073c10f50738408e7a1a", + "name": "catalogue", + "sha256": "c7217c3796bfc3f5a78e216ca19355e0516f07222318be3f4144b2f889fc0a5a", + "size": 31646, + "subdir": "linux-64", + "timestamp": 1651218776537, + "version": "2.0.7" + }, + "catboost-0.26.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.0", + "pandas >=0.24.0", + "python >=3.6,<3.7.0a0", + "scipy", + "six" + ], + "license": "Apache-2.0", + "license_family": "MIT", + "md5": "edf9993cd9c172f305ede480652248e9", + "name": "catboost", + "sha256": "79bdfa7808260f050271c73521a458e4876ee61fbcf2bb2e0b4e31b7aa2ceb40", + "size": 55105600, + "subdir": "linux-64", + "timestamp": 1633420395777, + "version": "0.26.1" + }, + "catboost-0.26.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.0", + "pandas >=0.24.0", + "python >=3.7,<3.8.0a0", + "scipy", + "six" + ], + "license": "Apache-2.0", + "license_family": "MIT", + "md5": "af75f6b9c41235b0bcc1ff86761726e5", + "name": "catboost", + "sha256": "ff65b3bfbef598b5f7957a6f574ecf80a7da5d2be4fbb2aa2b7ca9930befdad8", + "size": 55085164, + "subdir": "linux-64", + "timestamp": 1633409729760, + "version": "0.26.1" + }, + "catboost-0.26.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.0", + "pandas >=0.24.0", + "python >=3.8,<3.9.0a0", + "scipy", + "six" + ], + "license": "Apache-2.0", + "license_family": "MIT", + "md5": "2fcc11657f0377944bd0eabd73b133f6", + "name": "catboost", + "sha256": "171e2da737566c1c66d613ee0d52c3952fa970fa54e2a44fe94701a80958eccd", + "size": 55032933, + "subdir": "linux-64", + "timestamp": 1633420419255, + "version": "0.26.1" + }, + "catboost-0.26.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.0", + "pandas >=0.24.0", + "python >=3.9,<3.10.0a0", + "scipy", + "six" + ], + "license": "Apache-2.0", + "license_family": "MIT", + "md5": "0834bcec9de26844016f523ee7ac72ec", + "name": "catboost", + "sha256": "bef54bc40c0f7e959f92d706dff1bb0b689256888598629e5138dc2262351df8", + "size": 55048321, + "subdir": "linux-64", + "timestamp": 1633420405679, + "version": "0.26.1" + }, + "catboost-1.0.6-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base", + "numpy >=1.16.0", + "pandas >=0.24.0", + "plotly", + "python >=3.10,<3.11.0a0", + "python-graphviz", + "scipy", + "six" + ], + "license": "Apache-2.0", + "license_family": "MIT", + "md5": "fd091eaf163d028f3f3736ec2a4cf7bc", + "name": "catboost", + "sha256": "a76555a7671714f29079c4f19769a6aca223833646e7d9a7e350163fefa4774c", + "size": 63472704, + "subdir": "linux-64", + "timestamp": 1659346493976, + "version": "1.0.6" + }, + "catboost-1.0.6-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base", + "numpy >=1.16.0", + "pandas >=0.24.0", + "plotly", + "python >=3.7,<3.8.0a0", + "python-graphviz", + "scipy", + "six" + ], + "license": "Apache-2.0", + "license_family": "MIT", + "md5": "95842755351b29bdfe0e59bc3458a679", + "name": "catboost", + "sha256": "810def0d81bd6a08d326a47e10306feb65729c30f2b80dbcbd135452f72cfa11", + "size": 63449726, + "subdir": "linux-64", + "timestamp": 1659346398317, + "version": "1.0.6" + }, + "catboost-1.0.6-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base", + "numpy >=1.16.0", + "pandas >=0.24.0", + "plotly", + "python >=3.8,<3.9.0a0", + "python-graphviz", + "scipy", + "six" + ], + "license": "Apache-2.0", + "license_family": "MIT", + "md5": "419853ddcc20786e41e88cb4548aa34b", + "name": "catboost", + "sha256": "57d618a5c9b963517a7163cd55c293add60bd94c686f02989c0782655a8b2d1e", + "size": 63430877, + "subdir": "linux-64", + "timestamp": 1659346576135, + "version": "1.0.6" + }, + "catboost-1.0.6-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base", + "numpy >=1.16.0", + "pandas >=0.24.0", + "plotly", + "python >=3.9,<3.10.0a0", + "python-graphviz", + "scipy", + "six" + ], + "license": "Apache-2.0", + "license_family": "MIT", + "md5": "40e1b2d6a94c5edd6991ba97399ddb91", + "name": "catboost", + "sha256": "6a8b4d8e3da04e045193ae0d000521a5c619643bfb8719c1681e3bfa4a9a2de7", + "size": 63473749, + "subdir": "linux-64", + "timestamp": 1659346657673, + "version": "1.0.6" + }, + "category_encoders-2.5.0-py310h2f386ee_0.tar.bz2": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "numpy >=1.21.5,<2.0a0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "926d0b866f8afecd480b5fa82899b062", + "name": "category_encoders", + "sha256": "7cc7c052ef9609d95ca99f4b7e8db61d1556b884761c634644aa6d53ff82bd4a", + "size": 90088, + "subdir": "linux-64", + "timestamp": 1659117878729, + "version": "2.5.0" + }, + "category_encoders-2.5.0-py310h2f386ee_1.tar.bz2": { + "build": "py310h2f386ee_1", + "build_number": 1, + "depends": [ + "numpy >=1.21.5,<2.0a0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "73e2bb64dce3939f332fd8d44ca4d4dc", + "name": "category_encoders", + "sha256": "d918a8ecd94b26178fd411ba83ff959a1cff04c1894b6d7100f7898196319971", + "size": 89340, + "subdir": "linux-64", + "timestamp": 1663430348828, + "version": "2.5.0" + }, + "category_encoders-2.5.0-py37hb070fc8_0.tar.bz2": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.6,<2.0a0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "27f4661a0f960ea2a2eeb67dfb997bbb", + "name": "category_encoders", + "sha256": "43ca8e338dfaa3f1bcfa00025325bb1f7e586c8fd82ae6a4b257f2050fb8019b", + "size": 89500, + "subdir": "linux-64", + "timestamp": 1659117739573, + "version": "2.5.0" + }, + "category_encoders-2.5.0-py37hb070fc8_1.tar.bz2": { + "build": "py37hb070fc8_1", + "build_number": 1, + "depends": [ + "numpy >=1.16.6,<2.0a0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "48b4a03f70614072c41fc095c203ba42", + "name": "category_encoders", + "sha256": "8571a2231adcf98bdf2ec3571e6a0efa577c4054bfce2df7c00aedb86fc5de27", + "size": 88963, + "subdir": "linux-64", + "timestamp": 1663430237199, + "version": "2.5.0" + }, + "category_encoders-2.5.0-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.6,<2.0a0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7d1a80fad0b48d9263d79ee4ea1dbc96", + "name": "category_encoders", + "sha256": "9c4bc6c58909b42a475e831fddd19a67e74f9b622eee5b49f1d5417993d80c5b", + "size": 89608, + "subdir": "linux-64", + "timestamp": 1659117989943, + "version": "2.5.0" + }, + "category_encoders-2.5.0-py38hb070fc8_1.tar.bz2": { + "build": "py38hb070fc8_1", + "build_number": 1, + "depends": [ + "numpy >=1.16.6,<2.0a0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "30c119213ee96f7a30429f02b87319d1", + "name": "category_encoders", + "sha256": "e50e65481407fc9dac0ad691bb33a8cf4cceae6b1f718d6eea058c5b1bf7b45f", + "size": 89006, + "subdir": "linux-64", + "timestamp": 1663430444065, + "version": "2.5.0" + }, + "category_encoders-2.5.0-py39hb070fc8_1.tar.bz2": { + "build": "py39hb070fc8_1", + "build_number": 1, + "depends": [ + "numpy >=1.19.2,<2.0a0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "197b29df5ac44da0d1078c2813307594", + "name": "category_encoders", + "sha256": "e8c81b4abbc7c0f5cf54bbe3d04a26033318b60e4a0be4453e89b22c57e675a7", + "size": 89025, + "subdir": "linux-64", + "timestamp": 1663430139225, + "version": "2.5.0" + }, + "category_encoders-2.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14.0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "48f32a022ba930c787706a8bbced7725", + "name": "category_encoders", + "sha256": "60e588dd3f6e8663de01338ce9f3c93848bf48b3aecdd9732f6936310033be61", + "size": 104010, + "subdir": "linux-64", + "timestamp": 1677012721167, + "version": "2.6.0" + }, + "category_encoders-2.6.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14.0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.11,<3.12.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1a6781eafc48765280fa674865b05734", + "name": "category_encoders", + "sha256": "a561028c51df9feb2f1ec8840c07b139045a3238f7113bc72ea038871d6fb95c", + "size": 128395, + "subdir": "linux-64", + "timestamp": 1676930344034, + "version": "2.6.0" + }, + "category_encoders-2.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14.0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e95243e5ca3d5ea69c6f2841015991f", + "name": "category_encoders", + "sha256": "640e016b91e8df75b5ebd3e442990e30ba5c4a0a77e4371fe2a81c200d36e159", + "size": 103523, + "subdir": "linux-64", + "timestamp": 1677012905152, + "version": "2.6.0" + }, + "category_encoders-2.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14.0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e64ffb17ede3ffea9e8726b448f2c8f1", + "name": "category_encoders", + "sha256": "71e2fd6719fba718481cc21063355c572fb5336e861993f0b6e04d7fe46f9ff0", + "size": 103577, + "subdir": "linux-64", + "timestamp": 1677012998327, + "version": "2.6.0" + }, + "category_encoders-2.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14.0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f3a5c0d84be6759e76bd6121c1cc0da1", + "name": "category_encoders", + "sha256": "7e1c8bd250bdf3ee33f7b865d93d3d5bdeec0cb93014de7c9b525f2c18ebf5be", + "size": 103603, + "subdir": "linux-64", + "timestamp": 1677012817135, + "version": "2.6.0" + }, + "cattrs-22.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=20.1.0", + "exceptiongroup", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ba816c89c4bbb719feeabc663c286ff", + "name": "cattrs", + "sha256": "8ad53a46163f7e25d5b05605e4bd937ed89f021e5fde0b515be7f3574b52b4d7", + "size": 55050, + "subdir": "linux-64", + "timestamp": 1668797341925, + "version": "22.1.0" + }, + "cattrs-22.1.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=20.1.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "173112285b623d10fd50e2506de65c3d", + "name": "cattrs", + "sha256": "5035b659df31d0b8e9221f53e5a98c2497ed4ecbe31ee0b3e909c53b1b25c3cb", + "size": 72682, + "subdir": "linux-64", + "timestamp": 1676830247251, + "version": "22.1.0" + }, + "cattrs-22.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=20.1.0", + "exceptiongroup", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f0135ab83d6a68c7bf7a6e1b66416a8", + "name": "cattrs", + "sha256": "e064eed3302f45b70d634531361c8d162b46cf0d43d3b25739c545cf7906368c", + "size": 54121, + "subdir": "linux-64", + "timestamp": 1668797312972, + "version": "22.1.0" + }, + "cattrs-22.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=20.1.0", + "exceptiongroup", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "81e984d220a7585ef761fe50ebf458b4", + "name": "cattrs", + "sha256": "b87c4f002d76174492f41949c0b7dd15b212e85ccee59c83d8feb725cea40e23", + "size": 54616, + "subdir": "linux-64", + "timestamp": 1668797284319, + "version": "22.1.0" + }, + "cattrs-22.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=20.1.0", + "exceptiongroup", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f47ff18e2b7e0c6fdb881a69fd72ff2", + "name": "cattrs", + "sha256": "d46bb0e43980aa497fc8941408f80ef395e1783b47284080611a7f8a7613b36a", + "size": 54620, + "subdir": "linux-64", + "timestamp": 1668797370411, + "version": "22.1.0" + }, + "ccache-3.7.1-h0b5b093_0.tar.bz2": { + "build": "h0b5b093_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "8c289ee014ee966bb3969380d616be51", + "name": "ccache", + "sha256": "a666f43c1c80a06a346996878da196a717cb52f17825d70891f346c1ef5dc5fa", + "size": 102237, + "subdir": "linux-64", + "timestamp": 1564158593231, + "version": "3.7.1" + }, + "ccache-3.7.9-hfe4627d_0.tar.bz2": { + "build": "hfe4627d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "1698cf2ab6bbfcda9db6ce9c1a66d1f8", + "name": "ccache", + "sha256": "02aeef3ba598df34bc3fbd4ead0842884ebcb314f3ea78c20519742ff84a8b6d", + "size": 108207, + "subdir": "linux-64", + "timestamp": 1588382484110, + "version": "3.7.9" + }, + "cctools-949.0.1-h2b5a052_25.tar.bz2": { + "build": "h2b5a052_25", + "build_number": 25, + "depends": [ + "cctools_linux-64 949.0.1 h4441c4d_25", + "ld64 530 h0c34534_25" + ], + "license": "APSL-2.0", + "license_family": "Other", + "md5": "f58bd4c0ed3a324d243e76faf870bfa7", + "name": "cctools", + "sha256": "04c5271db02a564a2a22fdc030ac12aae45da0ce56e7b43f799c61024006c396", + "size": 17426, + "subdir": "linux-64", + "timestamp": 1662554237741, + "version": "949.0.1" + }, + "cctools_linux-64-949.0.1-h4441c4d_25.tar.bz2": { + "build": "h4441c4d_25", + "build_number": 25, + "constrains": [ + "cctools 949.0.1.*" + ], + "depends": [ + "ld64_linux-64 >=530,<531.0a0", + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0" + ], + "license": "APSL-2.0", + "license_family": "Other", + "md5": "a50be7d67200855dfe0d5329b0f66d42", + "name": "cctools_linux-64", + "sha256": "16eaf787d96f142379d046a5fe35093b92620b9dd704d46ed471aa8fad851c22", + "size": 8573924, + "subdir": "linux-64", + "timestamp": 1662554217006, + "version": "949.0.1" + }, + "cdecimal-2.3-py27h14c3975_3.tar.bz2": { + "build": "py27h14c3975_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f2b44cae53847025e3c2899bd21c56e8", + "name": "cdecimal", + "sha256": "0e392121a9d164272f63bd9f919e94956f48d4dfa33ec04923c30bb4aef7c522", + "size": 144122, + "subdir": "linux-64", + "timestamp": 1518031534982, + "version": "2.3" + }, + "cdecimal-2.3-py27h4e63abe_1.tar.bz2": { + "build": "py27h4e63abe_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "cbeafc3ba70c477bd541015ac5a3c4de", + "name": "cdecimal", + "sha256": "3b36715438af91b22af94dab039885b47381435b22d50137f79a1d686f21eea3", + "size": 143594, + "subdir": "linux-64", + "timestamp": 1505741889808, + "version": "2.3" + }, + "certifi-2017.11.5-py27h71e7faf_0.tar.bz2": { + "build": "py27h71e7faf_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "0c696ec875c6b1eb5432bba45b96fcc7", + "name": "certifi", + "sha256": "0b9e6c7440e9ed7908ea900459f120d845e805f404347cc3356a0c8ce77f17b0", + "size": 200671, + "subdir": "linux-64", + "timestamp": 1511294655335, + "version": "2017.11.5" + }, + "certifi-2017.11.5-py35h9749603_0.tar.bz2": { + "build": "py35h9749603_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "cc25f1ddf2a45cce30fb20185e617c64", + "name": "certifi", + "sha256": "cd61abf5b5f126bd71bcbb407b08fa055082e3938142c278be8fa2e25a8445d4", + "size": 200998, + "subdir": "linux-64", + "timestamp": 1511294731064, + "version": "2017.11.5" + }, + "certifi-2017.11.5-py36hf29ccca_0.tar.bz2": { + "build": "py36hf29ccca_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "4a6ed141e04626b1684122d8e2f727e1", + "name": "certifi", + "sha256": "1ccabcf6d83437a179b44058c3af749032c9ce44d650ff8bb3c24d00553d9dac", + "size": 201011, + "subdir": "linux-64", + "timestamp": 1511294734842, + "version": "2017.11.5" + }, + "certifi-2017.7.27.1-py27h9ceb091_0.tar.bz2": { + "build": "py27h9ceb091_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "0914a222e40dd52b3341a77cb0392ebf", + "name": "certifi", + "sha256": "a571d97fed7b517518d804a6e4202018fc857cbdcd4a1498f9f878e2676dcd3a", + "size": 209549, + "subdir": "linux-64", + "timestamp": 1505671803420, + "version": "2017.7.27.1" + }, + "certifi-2017.7.27.1-py35h19f42a1_0.tar.bz2": { + "build": "py35h19f42a1_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "5256d896206897b45d3f401c3f12017d", + "name": "certifi", + "sha256": "251d7ffc0b13361e87c1c2b3ee13651167a8a205204e3379d40df9869ca5b1f6", + "size": 209827, + "subdir": "linux-64", + "timestamp": 1505671814237, + "version": "2017.7.27.1" + }, + "certifi-2017.7.27.1-py36h8b7b77e_0.tar.bz2": { + "build": "py36h8b7b77e_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "91fac0c7809ab43597bbaf18831375a3", + "name": "certifi", + "sha256": "4224660995cbf67752383ee80c04270c4f26b20b1043a6ca819c1ad3753b4c91", + "size": 209729, + "subdir": "linux-64", + "timestamp": 1505671825111, + "version": "2017.7.27.1" + }, + "certifi-2018.1.18-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "0fb100ccf93f223f7762c5f8bfa30046", + "name": "certifi", + "sha256": "10bb679b8baf9655745ca33bf562df8302c12f797f5202d3f2f762e3a3f40226", + "size": 146672, + "subdir": "linux-64", + "timestamp": 1516980213122, + "version": "2018.1.18" + }, + "certifi-2018.1.18-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "16b2e701a2957d611b048294f04f5c7a", + "name": "certifi", + "sha256": "69a642b908e1834c6e09acbada998a7bede69a9c10b05baa0397b64c9885315f", + "size": 146740, + "subdir": "linux-64", + "timestamp": 1516980230430, + "version": "2018.1.18" + }, + "certifi-2018.1.18-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "95561df6b11183f092cc929bfc065570", + "name": "certifi", + "sha256": "b918789aec98674009fd8f05dc8d6a0411c8893bd8f8f5baace3a1839167fc80", + "size": 147272, + "subdir": "linux-64", + "timestamp": 1516980228329, + "version": "2018.1.18" + }, + "certifi-2018.10.15-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "fea35bdd4b954b00ba625c4854b2ced1", + "name": "certifi", + "sha256": "3a97367909afc0fb0d4213dad1392bcf93a1fe391cd8fa88a610ddf7e2956779", + "size": 142002, + "subdir": "linux-64", + "timestamp": 1539630880376, + "version": "2018.10.15" + }, + "certifi-2018.10.15-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "6890989311f4ff6969541b152df048c1", + "name": "certifi", + "sha256": "1323b89e6694a4c21adacf5a526eda21edeff38ed25ea6e84e121d0b5a5ce1e4", + "size": 141858, + "subdir": "linux-64", + "timestamp": 1539630907448, + "version": "2018.10.15" + }, + "certifi-2018.10.15-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "0d34a187fdb4b1e47edbfaae1b3087a0", + "name": "certifi", + "sha256": "dd5bfec7e7330f9ba78322b5e79ce6434fba55fd378dba59f855052b9c026287", + "size": 141800, + "subdir": "linux-64", + "timestamp": 1539630902508, + "version": "2018.10.15" + }, + "certifi-2018.11.29-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "ff13c68912a5b4891ebe7d98c2b465d9", + "name": "certifi", + "sha256": "4de9936a5b201364c9709c45e9acd16693d38eb8eaf39a3c70b20189a0943db9", + "size": 149234, + "subdir": "linux-64", + "timestamp": 1544460991682, + "version": "2018.11.29" + }, + "certifi-2018.11.29-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "e794c8479315cc9c030bf75f26e2622d", + "name": "certifi", + "sha256": "801b6db0b25acd164795f09ab5ed8bdbb7458a89bdc9a6607f15142076d895a7", + "size": 149084, + "subdir": "linux-64", + "timestamp": 1544461005201, + "version": "2018.11.29" + }, + "certifi-2018.11.29-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "395c38c05a7178a523bed66d78a5289a", + "name": "certifi", + "sha256": "87a38c237f8ac9b5660194d6c48236f8faca17dc54d03cee89cf483bb2949e8c", + "size": 149103, + "subdir": "linux-64", + "timestamp": 1544460981237, + "version": "2018.11.29" + }, + "certifi-2018.4.16-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "f715c3ae52541723417b02b5dc6eda6d", + "name": "certifi", + "sha256": "6e78783dc2a706163f898120ad0c6a6547f8f46a9f50c08e628a6c252cbf7f60", + "size": 145721, + "subdir": "linux-64", + "timestamp": 1524178079027, + "version": "2018.4.16" + }, + "certifi-2018.4.16-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "eb9f69adf79ec5b7437df61b7aebb790", + "name": "certifi", + "sha256": "864a1f370ec891172777799747b3e9a47659dbeed52169842981d6e84e0b831d", + "size": 146133, + "subdir": "linux-64", + "timestamp": 1524178040705, + "version": "2018.4.16" + }, + "certifi-2018.4.16-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "7e2e43077b10de90a33f214f27cb89a0", + "name": "certifi", + "sha256": "50c61ea6fe7f06c9b5edc4292df15fe00113912f3c0c82ba139788050ce9f567", + "size": 145585, + "subdir": "linux-64", + "timestamp": 1524178083336, + "version": "2018.4.16" + }, + "certifi-2018.4.16-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "c535d92609f2d9e92516d08458137875", + "name": "certifi", + "sha256": "8d8c6ae2c6dde6aaa16d77b364fc8f26c25867516abe21a69bf1fce972aa98b0", + "size": 145645, + "subdir": "linux-64", + "timestamp": 1530212464154, + "version": "2018.4.16" + }, + "certifi-2018.8.13-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "ea396bdfe84a3c2d4ff25d82dbfcff94", + "name": "certifi", + "sha256": "2b1b8ef7b2a814077aaa0c73a0f0c239b734aa29c351e20190b5f784c20a9294", + "size": 141873, + "subdir": "linux-64", + "timestamp": 1534172229646, + "version": "2018.8.13" + }, + "certifi-2018.8.13-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "171fda34b1a3866c910e246fee8117c5", + "name": "certifi", + "sha256": "6b4871e2b8bac95330d51948966fa514496e2d39b528da3c12e6296d6d94d779", + "size": 142015, + "subdir": "linux-64", + "timestamp": 1534172260589, + "version": "2018.8.13" + }, + "certifi-2018.8.13-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "1ef868139b94f055bf212046bb7e3540", + "name": "certifi", + "sha256": "477a3a23b5b5b6cb56d954df597cadce7c9f3e1fa2291589c880cf710dc499f5", + "size": 141800, + "subdir": "linux-64", + "timestamp": 1534172212969, + "version": "2018.8.13" + }, + "certifi-2018.8.13-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "9ec0d2287f8effc099a0c5e7022ef564", + "name": "certifi", + "sha256": "93a740905aede2590d612f2330a80faddb865d4429d030c226d4480f2c5723de", + "size": 142069, + "subdir": "linux-64", + "timestamp": 1534172661432, + "version": "2018.8.13" + }, + "certifi-2018.8.24-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "486a05419c4664b345f792f1ec203715", + "name": "certifi", + "sha256": "d2ace63d9ce8b8392e814971fa48ca608eb0c56de7134494edc479358fb53af0", + "size": 142329, + "subdir": "linux-64", + "timestamp": 1535377823170, + "version": "2018.8.24" + }, + "certifi-2018.8.24-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "23d746312321419c70e8e4845d65c01d", + "name": "certifi", + "sha256": "9560d95de09753edc7f642df7ee8b4017fd917d1146a4b1947bea014b80d77a2", + "size": 142706, + "subdir": "linux-64", + "timestamp": 1535377839241, + "version": "2018.8.24" + }, + "certifi-2018.8.24-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "e7fa820d003f17e25e5977404dcd71b1", + "name": "certifi", + "sha256": "c60cb92529212c74f59049ec17c62b8b94b1a2a0106d67cdc7edfdab5dd6b57d", + "size": 142848, + "subdir": "linux-64", + "timestamp": 1535377801428, + "version": "2018.8.24" + }, + "certifi-2018.8.24-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "c58f455ae3a33a71cdff7db6f04d7522", + "name": "certifi", + "sha256": "d7df38b1501775d1c39890b2553b09e27fc529b016d8ce048cee110d3c848053", + "size": 142597, + "subdir": "linux-64", + "timestamp": 1535377830376, + "version": "2018.8.24" + }, + "certifi-2019.11.28-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "bdc58c57e0985a3fe567e822c64f4651", + "name": "certifi", + "sha256": "e73fdba0b410871511b99d3e48a3737537fb8d4147c2aa93d0c6500e5cbeb696", + "size": 159784, + "subdir": "linux-64", + "timestamp": 1575390236154, + "version": "2019.11.28" + }, + "certifi-2019.11.28-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "ef80da728bdadaaab61124f0f306cafa", + "name": "certifi", + "sha256": "8c514f299261406fb0e43b0f2846282da7ee885c252233cce7d17dd3b02d21c4", + "size": 159955, + "subdir": "linux-64", + "timestamp": 1575390251400, + "version": "2019.11.28" + }, + "certifi-2019.11.28-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "445c852374f7e4e8f806dbfa0277ecbb", + "name": "certifi", + "sha256": "c3d1fb89021cad3f49c8a083f127a54d03a89ed83154d6ebe188d58857f75576", + "size": 160419, + "subdir": "linux-64", + "timestamp": 1584971938832, + "version": "2019.11.28" + }, + "certifi-2019.11.28-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "f745ae532410217479464b2b0725e183", + "name": "certifi", + "sha256": "db3426e95bd092fe026e2f811315a8f267f467d5cee5eeddca55fad400be5650", + "size": 159914, + "subdir": "linux-64", + "timestamp": 1575390189519, + "version": "2019.11.28" + }, + "certifi-2019.11.28-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "87a7d5e6dd0eed71c423b8d84f822c40", + "name": "certifi", + "sha256": "3b0147281583ae0a0c6aeb6cab40159d070ff3b171c50c9c599db44e54d83001", + "size": 160251, + "subdir": "linux-64", + "timestamp": 1584971732458, + "version": "2019.11.28" + }, + "certifi-2019.11.28-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "f68da5595664ba933f8cd6c1658b1900", + "name": "certifi", + "sha256": "bc376a7a89282b5159269c53a4d03cc5dc4e3946e411965ce8debe8c41657ce0", + "size": 159894, + "subdir": "linux-64", + "timestamp": 1575390379048, + "version": "2019.11.28" + }, + "certifi-2019.11.28-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "fce3750ef00b23c9cd3dda277d387c5d", + "name": "certifi", + "sha256": "ab5897a255a7502308f22042df385d53cb6970451787ddaff4326f2d021f92c6", + "size": 160483, + "subdir": "linux-64", + "timestamp": 1584972000953, + "version": "2019.11.28" + }, + "certifi-2019.3.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "abe3f6e1f8dd42a9e0228be3431cccdd", + "name": "certifi", + "sha256": "9c3d7a635f61356aba853742a98dc47b51266ca74b703de7d3c536d5efc4b31a", + "size": 158539, + "subdir": "linux-64", + "timestamp": 1552318228443, + "version": "2019.3.9" + }, + "certifi-2019.3.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "c7886b5adee8b0567722bcd4310f781f", + "name": "certifi", + "sha256": "382d9155272dd3a94f4250ba30247504a1c776a90c4c5b5712340c27294063ac", + "size": 158875, + "subdir": "linux-64", + "timestamp": 1552318251063, + "version": "2019.3.9" + }, + "certifi-2019.3.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "28921b59b39bc66578303264677a5232", + "name": "certifi", + "sha256": "9689c6463d8ced2570ea705928a46bef1b902bb8bd0578a7733b73655f0b5ba9", + "size": 158568, + "subdir": "linux-64", + "timestamp": 1552318217480, + "version": "2019.3.9" + }, + "certifi-2019.6.16-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "a438366504119adc463e547ac48e4b50", + "name": "certifi", + "sha256": "1b334b1dd348ca3d598bce965e9a5bc93c7403fb834f3b646ad853f36d9698cc", + "size": 157573, + "subdir": "linux-64", + "timestamp": 1561070541544, + "version": "2019.6.16" + }, + "certifi-2019.6.16-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "0bbb24c724c7ab30fedddbf58d527bc4", + "name": "certifi", + "sha256": "63c6eae0f06f51d0c1b5ad5ee69d68098906bac4a078bc51b87dab7088e9caca", + "size": 159382, + "subdir": "linux-64", + "timestamp": 1564158793063, + "version": "2019.6.16" + }, + "certifi-2019.6.16-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "4075b3129467500cb6288f15c2be8625", + "name": "certifi", + "sha256": "bd59325020efa1725506039676c6ee1c05eed6b2833c309c62e2939060616789", + "size": 157836, + "subdir": "linux-64", + "timestamp": 1561070584249, + "version": "2019.6.16" + }, + "certifi-2019.6.16-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "f59a592e8e4c2442b185bc8dcf43e780", + "name": "certifi", + "sha256": "35e946c8ca34254b535ad09878ead0522fae06bbafad82ee511226b8d8d26281", + "size": 159392, + "subdir": "linux-64", + "timestamp": 1564158793222, + "version": "2019.6.16" + }, + "certifi-2019.6.16-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "1c2c57cdd8db2026c8888f23dcd84c85", + "name": "certifi", + "sha256": "77f921803be9f14c3ca4328a9bb803be62c8b608d7381ba2fd0ce2a6886bd7df", + "size": 157821, + "subdir": "linux-64", + "timestamp": 1561070559881, + "version": "2019.6.16" + }, + "certifi-2019.6.16-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "2c802b096ae72a4f6563f3818aac36ef", + "name": "certifi", + "sha256": "751d5290c039d8673e4a2db75b4a7a52d6dd28e5db440f169c447a1a67f10fa8", + "size": 159404, + "subdir": "linux-64", + "timestamp": 1564158795394, + "version": "2019.6.16" + }, + "certifi-2019.9.11-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "c1c3f7b088064466b72b05826e37d5f3", + "name": "certifi", + "sha256": "f54c6244f4d776a2279d5aacacb1c9cf4b9a7756811d63522aeb9d608270df6b", + "size": 157837, + "subdir": "linux-64", + "timestamp": 1569254339192, + "version": "2019.9.11" + }, + "certifi-2019.9.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "a70ecad2390c01bf7d88c6fe049c48e2", + "name": "certifi", + "sha256": "cd3af97ba21079a15cfe60eb142f2c607ddddff5def536c89f54e56eacbe1d28", + "size": 157933, + "subdir": "linux-64", + "timestamp": 1569254356942, + "version": "2019.9.11" + }, + "certifi-2019.9.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "116087915db80274f6a81bb3e88a51f3", + "name": "certifi", + "sha256": "238c9b5fae1267fe12790c3c5b192c1d72ee164d7f564f90b09adb182cd4df64", + "size": 157961, + "subdir": "linux-64", + "timestamp": 1569254344723, + "version": "2019.9.11" + }, + "certifi-2019.9.11-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "b34b5f3efbabb5575a3b1b22f5db9651", + "name": "certifi", + "sha256": "3848abb778ed83c6d1fdfc4e6ab0a3fc62ab17fc32907a99a367e4b8bd075c7b", + "size": 157983, + "subdir": "linux-64", + "timestamp": 1571953056223, + "version": "2019.9.11" + }, + "certifi-2020.11.8-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "70e82fe81e4cb24f3cc3505e3e1e8ee0", + "name": "certifi", + "sha256": "a3b6a0516ba2acf6f00802d0427e55ad2160fcf539bc20a36458af0bd6192534", + "size": 154047, + "subdir": "linux-64", + "timestamp": 1606143378686, + "version": "2020.11.8" + }, + "certifi-2020.11.8-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "43887bb7f90bc668df2d86c6fd12efc1", + "name": "certifi", + "sha256": "e0d4ca1bd8b32de83948dbf514bc777bcf1a58541e19ae5664e0c4ed1c8aac5c", + "size": 153966, + "subdir": "linux-64", + "timestamp": 1606143381203, + "version": "2020.11.8" + }, + "certifi-2020.11.8-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "601f5882781e67236fce3bf939f609ee", + "name": "certifi", + "sha256": "d8d83637d1706887c939346268908dba3db302a3892c49198c2e6a51329ab319", + "size": 154269, + "subdir": "linux-64", + "timestamp": 1606143374950, + "version": "2020.11.8" + }, + "certifi-2020.11.8-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "md5": "3743b9085b9b1c69e2dd32ee615b67d9", + "name": "certifi", + "sha256": "c5d6d654037477e3e725549e26d7b50132a869c13d4f631190e49fe1d52d2c81", + "size": 154235, + "subdir": "linux-64", + "timestamp": 1606143386176, + "version": "2020.11.8" + }, + "certifi-2020.12.5-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "2b3523375b4c388afc92d3fb625db97d", + "name": "certifi", + "sha256": "d4904d4d058bf9c0a876e184481ffcc188a045944b023eb47b2daa67578dbaba", + "size": 146982, + "subdir": "linux-64", + "timestamp": 1607365724491, + "version": "2020.12.5" + }, + "certifi-2020.12.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "818a585de230d089971236b2078ac9f9", + "name": "certifi", + "sha256": "4a500caeafccefbe497ffccf2948ee9e9427b38eacc02631e794f81f418c6d59", + "size": 146602, + "subdir": "linux-64", + "timestamp": 1607365768496, + "version": "2020.12.5" + }, + "certifi-2020.12.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "e756e50071490addcb191e409946c60e", + "name": "certifi", + "sha256": "8bc42975d91b217d4b710c85f90c0c03f4583fa3bae6b5f9a07d545c67d4c79d", + "size": 146592, + "subdir": "linux-64", + "timestamp": 1607365752742, + "version": "2020.12.5" + }, + "certifi-2020.12.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "md5": "a6d52c703c1a8ba47ec66ba17b49aef0", + "name": "certifi", + "sha256": "950ef0818c738b460ce3bf3248867e82bb762c9ae2ded6aabeef7523fbe8378c", + "size": 146403, + "subdir": "linux-64", + "timestamp": 1607365763827, + "version": "2020.12.5" + }, + "certifi-2020.4.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "9ef1914388109c01fde9d724395d57f9", + "name": "certifi", + "sha256": "f66c8a998649c13cf8ea4fdd4d30a608f19bf03db5f8855217856959409b2698", + "size": 162797, + "subdir": "linux-64", + "timestamp": 1586198631628, + "version": "2020.4.5.1" + }, + "certifi-2020.4.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "27efbaadece8290ed96ee6eea0e1ad8e", + "name": "certifi", + "sha256": "67fef4d50d134d179c2757384b6594a60ec7e8f2bb54fc8b358160db585daa20", + "size": 162777, + "subdir": "linux-64", + "timestamp": 1586198629955, + "version": "2020.4.5.1" + }, + "certifi-2020.4.5.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "9eecc89e84efc8955f7b18733cd38b32", + "name": "certifi", + "sha256": "b02cc14a27065a67416fc4ab67e36dfda8a41ae8044b9dc66f0038c9a068bddf", + "size": 162855, + "subdir": "linux-64", + "timestamp": 1586198646161, + "version": "2020.4.5.1" + }, + "certifi-2020.4.5.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "fb7285d6e4dec89ca196de699576126b", + "name": "certifi", + "sha256": "6142b4c566a579a88b04bd970e745732c4d520973ea5d20e8d3bcdbb9b6b4e7e", + "size": 163985, + "subdir": "linux-64", + "timestamp": 1592250826099, + "version": "2020.4.5.2" + }, + "certifi-2020.4.5.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "1e814ace7fc7defabaac1b3bbce37e7e", + "name": "certifi", + "sha256": "ef33549ad895fd1845bbdc2ec2e972efd0a483318ceac82ad37725e1ae5c5d71", + "size": 164019, + "subdir": "linux-64", + "timestamp": 1592250824309, + "version": "2020.4.5.2" + }, + "certifi-2020.4.5.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "bd3e7ec6792ab379169a240ef18d87c5", + "name": "certifi", + "sha256": "7d7b81c8588ec4039c9f312edbb3497c05f77307120794448cd8b572130fdfac", + "size": 163956, + "subdir": "linux-64", + "timestamp": 1592250824310, + "version": "2020.4.5.2" + }, + "certifi-2020.6.20-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "abf97316466c8769b7772e90d750fa66", + "name": "certifi", + "sha256": "ffeb38c1210517d30dd8065f6701eb526f5c55fd7d855783ef3a4def72b28bf0", + "size": 163361, + "subdir": "linux-64", + "timestamp": 1592841344695, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "0b108150c68a90d8c614598fc89c900c", + "name": "certifi", + "sha256": "dbaa58e54779a2ab480cea01ec3bb8317eec460d8160df7178e0a70e426da9e4", + "size": 163292, + "subdir": "linux-64", + "timestamp": 1604429341748, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "2b7fe3fc1d567c6331cb473cf806785b", + "name": "certifi", + "sha256": "0205edf760e767b20a860ba7c8fc16073993a8819e9e8797b63b4c3536535ae5", + "size": 155464, + "subdir": "linux-64", + "timestamp": 1603840232396, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "032d5214aef490bce4eea2f805f6a4e9", + "name": "certifi", + "sha256": "b99f07859a5a4d75193f4e2cd65a69dc793988236a0438539e86b60d73aa936e", + "size": 163301, + "subdir": "linux-64", + "timestamp": 1592841294400, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "96da7624756508efa177684128c2595b", + "name": "certifi", + "sha256": "9db63fc9950f1ea781e4d5718a2893b32a0e255c6d44b998fb1704881d17a959", + "size": 163312, + "subdir": "linux-64", + "timestamp": 1604429357693, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "e82f6ac613c7a9d4c6453d162783c6f1", + "name": "certifi", + "sha256": "c39e890fd8e352ed27aafb654d8ab08d87c7bc09231d4aee4e0e2abc7b880048", + "size": 154973, + "subdir": "linux-64", + "timestamp": 1603840246934, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "d0aaf0cbc079ed89ef03dad00e02f526", + "name": "certifi", + "sha256": "3a0cf3901a4f750f8b8ea4fc360f6170605eff8fed8b138a1e7fa0823919791c", + "size": 163390, + "subdir": "linux-64", + "timestamp": 1592841307034, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "630fcae37c002348d5173e1b1459d63b", + "name": "certifi", + "sha256": "77fbca3263c049901a42219c2a12cb0b429b7114e9163d9436c116a708197d47", + "size": 163309, + "subdir": "linux-64", + "timestamp": 1604429383407, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "f79c9d7a89414e254cf6c6453ceaab9b", + "name": "certifi", + "sha256": "2759ea12b921570aae64955bd08e8eb382a35dc7e52be4ab5c6d118341b7b7a6", + "size": 155006, + "subdir": "linux-64", + "timestamp": 1603840253164, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "md5": "1ed7fb969462be2082a301de0e8e8ab4", + "name": "certifi", + "sha256": "4478c5fa77d541112108d9f043ac23c8bf4a226cf60d0a9504618abff062ab67", + "size": 163159, + "subdir": "linux-64", + "timestamp": 1604429385138, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "md5": "6066ca7680acc99d9075fe55a0feaa01", + "name": "certifi", + "sha256": "bf4994d24c1aa674ee01a2b4d7c1d6ec466c40472fd38324fa329d52dca7f26d", + "size": 155225, + "subdir": "linux-64", + "timestamp": 1603840204591, + "version": "2020.6.20" + }, + "certifi-2021.10.8-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "53ce22dc29954a689d12ba8c6d53fb86", + "name": "certifi", + "sha256": "29239ecca5705da78f659ced807872aa77d823b305cdd8c63407a001c2f8ef28", + "size": 158082, + "subdir": "linux-64", + "timestamp": 1634050492891, + "version": "2021.10.8" + }, + "certifi-2021.10.8-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0", + "md5": "aac928cff8772429b460557f116db779", + "name": "certifi", + "sha256": "835387976ae9cc9d090aef7a65fa5b6db4e80b37aefd5bea4bb84ab1fabdc2f7", + "size": 159483, + "subdir": "linux-64", + "timestamp": 1641900025688, + "version": "2021.10.8" + }, + "certifi-2021.10.8-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "c485b0c891137fe6ef2d03803abfb520", + "name": "certifi", + "sha256": "f910ee1b52a0546cd37deef51bb2bff8efd05eb655d732024aafb841dc2fddf9", + "size": 158313, + "subdir": "linux-64", + "timestamp": 1634039482254, + "version": "2021.10.8" + }, + "certifi-2021.10.8-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0", + "md5": "114823aa7fe54aa65c198f0a379f6b33", + "name": "certifi", + "sha256": "37ca578eb28244edda651b77bc35deccaf9d2eb43465e0458f1ddbcc7f8d29d6", + "size": 159320, + "subdir": "linux-64", + "timestamp": 1641900025463, + "version": "2021.10.8" + }, + "certifi-2021.10.8-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "md5": "62dd7cc707ec8839bcdf8da740c5b6aa", + "name": "certifi", + "sha256": "ee2af9bcffd85706df4369f62015a32696e4848f587c3571197a0e3fa831f523", + "size": 158323, + "subdir": "linux-64", + "timestamp": 1634050491429, + "version": "2021.10.8" + }, + "certifi-2021.10.8-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0", + "md5": "0bf94d0b0c9da99742ca7b7457cbd580", + "name": "certifi", + "sha256": "0fcb9d14ff1e2ed89f6424697c4045892e1c6828d9b5cbe5e41f9148f15cc03b", + "size": 159407, + "subdir": "linux-64", + "timestamp": 1641885050341, + "version": "2021.10.8" + }, + "certifi-2021.5.30-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0", + "md5": "242f868f0106a30e7218646125601a4d", + "name": "certifi", + "sha256": "b536ab7d09d33555e964c2e2de7fcc55a49f9f80fd337d1996d47d2cca46ff19", + "size": 155226, + "subdir": "linux-64", + "timestamp": 1633015810184, + "version": "2021.5.30" + }, + "certifi-2021.5.30-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPL-2.0", + "md5": "88541e5021f6621894d4d11edc072a2f", + "name": "certifi", + "sha256": "b56ea53c94c317781fdccb404aa07839e8d64ace9b47512f2104ae705c89ffff", + "size": 144789, + "subdir": "linux-64", + "timestamp": 1622567725440, + "version": "2021.5.30" + }, + "certifi-2021.5.30-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0", + "md5": "d4fcc0446974fd5970610fb8af59bdf0", + "name": "certifi", + "sha256": "72cf92cdceae93f506f71c53569c3b33dd48b63510c6cf1326106edb944ea6c0", + "size": 144788, + "subdir": "linux-64", + "timestamp": 1622567245455, + "version": "2021.5.30" + }, + "certifi-2021.5.30-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0", + "md5": "f424e4e896312100fcf14a86c93a8c5c", + "name": "certifi", + "sha256": "d6291fca57a06e2bede5eaa79090fcb7301ffeb6a7d57981a0d316e77ef6e75a", + "size": 144657, + "subdir": "linux-64", + "timestamp": 1622562517906, + "version": "2021.5.30" + }, + "certifi-2021.5.30-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0", + "md5": "cbca47c19fccdfd89cd2908733224750", + "name": "certifi", + "sha256": "4c5b7f885b01f19943423303e51cfabd852e76ffe957a3bad0a5c0af559816d2", + "size": 144707, + "subdir": "linux-64", + "timestamp": 1622562526194, + "version": "2021.5.30" + }, + "certifi-2022.12.7-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "d760ff6d9330e2b2097f018d40dce0a2", + "name": "certifi", + "sha256": "48a23cbf721042262a387d25f428ea2461bfea19d45424761a5adc8820412b0e", + "size": 155112, + "subdir": "linux-64", + "timestamp": 1671487846135, + "version": "2022.12.7" + }, + "certifi-2022.12.7-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "3e4a801098cca60ac963480df3e14901", + "name": "certifi", + "sha256": "b8574c71871505e6041479de91fb6df53bc7a32a3a5e5dd22a63b0349b2fe2c5", + "size": 157024, + "subdir": "linux-64", + "timestamp": 1676822455336, + "version": "2022.12.7" + }, + "certifi-2022.12.7-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "9fa361aca74583af48610040c845b8a9", + "name": "certifi", + "sha256": "00a3c72280bcd2ec3d0e196db02b8804758d52ee9876406693f969873f8b20ed", + "size": 155275, + "subdir": "linux-64", + "timestamp": 1671487798259, + "version": "2022.12.7" + }, + "certifi-2022.12.7-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "efa16e00c105c5968a4ab45ab11a6540", + "name": "certifi", + "sha256": "661feff73aae2a15d0a0791a4fbdc6f5b5e3110f7325c2140b9058942b6f40f4", + "size": 155318, + "subdir": "linux-64", + "timestamp": 1671487821981, + "version": "2022.12.7" + }, + "certifi-2022.12.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "ceb351da30f1d170f7d8d719fc53bbea", + "name": "certifi", + "sha256": "211a18284ec784ca70cc1c8b8683bd37259df6567a1708a1444916916d1ac6b4", + "size": 155537, + "subdir": "linux-64", + "timestamp": 1671487870106, + "version": "2022.12.7" + }, + "certifi-2022.5.18.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "66d4431d4a0bca2c24374a6e3288ef33", + "name": "certifi", + "sha256": "16afd3cf3544774bf3a8184a2971b23e7be8ffc9946aeb532b143348266577a5", + "size": 153750, + "subdir": "linux-64", + "timestamp": 1653078274304, + "version": "2022.5.18.1" + }, + "certifi-2022.5.18.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "403dfe558bcca0a89fec368dabebb0cd", + "name": "certifi", + "sha256": "45188fb6f00f5571a964e85f7ac33c9ef19fccb1056458e3adc82c18aab59465", + "size": 153824, + "subdir": "linux-64", + "timestamp": 1653078324238, + "version": "2022.5.18.1" + }, + "certifi-2022.5.18.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "6d1136ada95f48f278684fe0d773e5a1", + "name": "certifi", + "sha256": "d5b5ad36ed5f26a7f7373bc332141fa43931793bc1c49ed396a52d34c08316cd", + "size": 154359, + "subdir": "linux-64", + "timestamp": 1653078345303, + "version": "2022.5.18.1" + }, + "certifi-2022.5.18.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "19ab5ec5f69e44ca42b274feb58bd7f3", + "name": "certifi", + "sha256": "2266b48759bbc229ff7e08a61104c196898c937c2ac38c86b44399ddbf6917ce", + "size": 154298, + "subdir": "linux-64", + "timestamp": 1653078300808, + "version": "2022.5.18.1" + }, + "certifi-2022.6.15-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "4ca8a82f458ff8f6c31125327852bb93", + "name": "certifi", + "sha256": "a275fa7f02253ec8db034b9d0a5a477db731c7334c88b0875e260cf6e14ea147", + "size": 159714, + "subdir": "linux-64", + "timestamp": 1655968847382, + "version": "2022.6.15" + }, + "certifi-2022.6.15-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "f2a9898382642a74804d185ff52e6a10", + "name": "certifi", + "sha256": "b6247802656ee42084d8bbf600c564505f41c9fc912bca5453f2ac525ff67a25", + "size": 159641, + "subdir": "linux-64", + "timestamp": 1655968895591, + "version": "2022.6.15" + }, + "certifi-2022.6.15-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "9cf38ee6dfce9fdea3822ad6af016018", + "name": "certifi", + "sha256": "f0e2dfa161cb75f2519466ffa2bb7e19417b4c1f64da232339bf355cdccf1dee", + "size": 159929, + "subdir": "linux-64", + "timestamp": 1655968918305, + "version": "2022.6.15" + }, + "certifi-2022.6.15-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "242a8d9e6b3461a6788f602263b2c5f2", + "name": "certifi", + "sha256": "3a288101bacfb7897f9940860750fed172b41dd6a2afdcd50e5167386de6d99e", + "size": 159804, + "subdir": "linux-64", + "timestamp": 1655968870556, + "version": "2022.6.15" + }, + "certifi-2022.9.14-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "5484641ffe6c4dd4e99fecb5c31e1d55", + "name": "certifi", + "sha256": "2fa3fd238564e8d1f80e1b87a0953213273984252dc4914c2be98d1697c3bcdc", + "size": 161889, + "subdir": "linux-64", + "timestamp": 1663615766023, + "version": "2022.9.14" + }, + "certifi-2022.9.14-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "4a558d7d491c2a7d7b6d34bd9070b21d", + "name": "certifi", + "sha256": "1bb39db48ffe9945eb889b6e3f9bf1ed7934675ca358251da8ace2b14e12d11d", + "size": 162243, + "subdir": "linux-64", + "timestamp": 1663615790034, + "version": "2022.9.14" + }, + "certifi-2022.9.14-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "cf8680d75e974dbfc11de218fb50cd0f", + "name": "certifi", + "sha256": "29ee45af32ce011fe7ac57600d6e52608984760f6e7f51aa7b73c6d2d4445833", + "size": 161956, + "subdir": "linux-64", + "timestamp": 1663615729013, + "version": "2022.9.14" + }, + "certifi-2022.9.14-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "fcc798373e6e3de12f5e7044d127cd7c", + "name": "certifi", + "sha256": "24af5a872890a8c8b23a2ab4e3b4b1a737a3b17acc04896135cf0f0bc9a9a586", + "size": 161904, + "subdir": "linux-64", + "timestamp": 1663615704117, + "version": "2022.9.14" + }, + "certifi-2022.9.24-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "0ab0c26f8e1ad92a15ff49c3711731de", + "name": "certifi", + "sha256": "b87d7d7ca4e04a87bef18a0060e7927f6ba85ec71c0e4afdffcbf4278c47de77", + "size": 160813, + "subdir": "linux-64", + "timestamp": 1665076714071, + "version": "2022.9.24" + }, + "certifi-2022.9.24-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "d2bbbb2631bde9f9a00244aec85acd6e", + "name": "certifi", + "sha256": "97e5121aba900907e628ea55f99a35a036f2b0c19595c2c1beb21973d746ea10", + "size": 162276, + "subdir": "linux-64", + "timestamp": 1669749585103, + "version": "2022.9.24" + }, + "certifi-2022.9.24-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "c4b37ef8f4e1903166df91997c6e21da", + "name": "certifi", + "sha256": "acd06317b7b8ce6f6911e637064b2d82035ec969c8d12af19f41deddfa0a8721", + "size": 160671, + "subdir": "linux-64", + "timestamp": 1665076738459, + "version": "2022.9.24" + }, + "certifi-2022.9.24-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "9dfb71a5bee31e1e75313e8c853d8ebf", + "name": "certifi", + "sha256": "37d349c9fe73474558763fad6ff2a153cba7b266f3c9ff47a49ebdfde12b877f", + "size": 160885, + "subdir": "linux-64", + "timestamp": 1665076786045, + "version": "2022.9.24" + }, + "certifi-2022.9.24-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "6d11a1338dc2a2a951de96b541a30662", + "name": "certifi", + "sha256": "5954926fe16921c9332d2a1950c4ffaaff4a8e948c42e4529fd82449546e4b01", + "size": 160567, + "subdir": "linux-64", + "timestamp": 1665076762069, + "version": "2022.9.24" + }, + "cffi-1.10.0-py27hf1aaaf4_1.tar.bz2": { + "build": "py27hf1aaaf4_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "2ee87fdf72a600b132dc79946731e54c", + "name": "cffi", + "sha256": "6f3fc7ea97db769942aaeeb42ac1a944e8e3c8871aaf8ffa3a264ed225ec191b", + "size": 206821, + "subdir": "linux-64", + "timestamp": 1505691660494, + "version": "1.10.0" + }, + "cffi-1.10.0-py35h796c292_1.tar.bz2": { + "build": "py35h796c292_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "71078cb61a846e94ce78670957fd02a9", + "name": "cffi", + "sha256": "f072c451e4db22ae81c835c3ab48188da19132dfa5463dc54d97852eae5d3d82", + "size": 211837, + "subdir": "linux-64", + "timestamp": 1505691679697, + "version": "1.10.0" + }, + "cffi-1.10.0-py36had8d393_1.tar.bz2": { + "build": "py36had8d393_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "76dd0965706dd3cbb3dcd3bb164bdc26", + "name": "cffi", + "sha256": "e0d22b596f62ba16aee44393b7c46768ffd757b2bbc1a6f8e76aab181ffb92f5", + "size": 210690, + "subdir": "linux-64", + "timestamp": 1505691698902, + "version": "1.10.0" + }, + "cffi-1.11.2-py27ha7929c6_0.tar.bz2": { + "build": "py27ha7929c6_0", + "build_number": 0, + "depends": [ + "libffi", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "3cc4115db562b641f0c132750e538d75", + "name": "cffi", + "sha256": "e3d5e34895ea83b45f2216c4e44fc7c29a4a2feed508f3a89fdc328af477b7d2", + "size": 213185, + "subdir": "linux-64", + "timestamp": 1511926624689, + "version": "1.11.2" + }, + "cffi-1.11.2-py35hc7b2db7_0.tar.bz2": { + "build": "py35hc7b2db7_0", + "build_number": 0, + "depends": [ + "libffi", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "7a622afdd9e8f4f76bc2fd8060007116", + "name": "cffi", + "sha256": "be81e3423ec20949afde22a96e245780c62f17dc9e628d2b803867738a894c7e", + "size": 217930, + "subdir": "linux-64", + "timestamp": 1511926661365, + "version": "1.11.2" + }, + "cffi-1.11.2-py36h2825082_0.tar.bz2": { + "build": "py36h2825082_0", + "build_number": 0, + "depends": [ + "libffi", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "244004a880b8a0d13091c0d7322b43cd", + "name": "cffi", + "sha256": "ea26f1a599c3a04d2618b656d6bcae26c4d46205ab943a6357a8d65a2800adcb", + "size": 216954, + "subdir": "linux-64", + "timestamp": 1511926623315, + "version": "1.11.2" + }, + "cffi-1.11.4-py27h9745a5d_0.tar.bz2": { + "build": "py27h9745a5d_0", + "build_number": 0, + "depends": [ + "libffi", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c8793a06c2274f0a2f5d340adb816bdf", + "name": "cffi", + "sha256": "f55d25beaafd7262f6e5551f7428d63b0c7573cdcaa1fb4de212ac1d88273d53", + "size": 213253, + "subdir": "linux-64", + "timestamp": 1516376437583, + "version": "1.11.4" + }, + "cffi-1.11.4-py35h9745a5d_0.tar.bz2": { + "build": "py35h9745a5d_0", + "build_number": 0, + "depends": [ + "libffi", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "70bf1f59f4491b7033e5d9bb60f0bacb", + "name": "cffi", + "sha256": "d714882c93c81a49bc1285c61380b9c69f362cc46ae61447267ca94c4bcdf9f6", + "size": 217795, + "subdir": "linux-64", + "timestamp": 1516376731232, + "version": "1.11.4" + }, + "cffi-1.11.4-py36h9745a5d_0.tar.bz2": { + "build": "py36h9745a5d_0", + "build_number": 0, + "depends": [ + "libffi", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3d3acf9c139350752418a10b660c219d", + "name": "cffi", + "sha256": "e7c146ffc8ceb09cbb85a6aaa7073ef5c58e625c30b502d3e9bf27481e8a9685", + "size": 216726, + "subdir": "linux-64", + "timestamp": 1516376729727, + "version": "1.11.4" + }, + "cffi-1.11.5-py27h9745a5d_0.tar.bz2": { + "build": "py27h9745a5d_0", + "build_number": 0, + "depends": [ + "libffi", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7fd73833a32d6aeca1303700f488ee1e", + "name": "cffi", + "sha256": "b86aac6a75a7465f71005f219bf591a89c1bb2de78e5dd3342bbeac31356bba6", + "size": 213366, + "subdir": "linux-64", + "timestamp": 1520360926669, + "version": "1.11.5" + }, + "cffi-1.11.5-py27he75722e_1.tar.bz2": { + "build": "py27he75722e_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d34f39c241157b0729e73cbb52b1443c", + "name": "cffi", + "sha256": "20942507112c88166dce0000f60a52f194dee050ff8c1179db0b96f2d2176bc3", + "size": 213729, + "subdir": "linux-64", + "timestamp": 1534345160165, + "version": "1.11.5" + }, + "cffi-1.11.5-py35h9745a5d_0.tar.bz2": { + "build": "py35h9745a5d_0", + "build_number": 0, + "depends": [ + "libffi", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "d4b92632263afa479bbe30a0da1f9f8d", + "name": "cffi", + "sha256": "ba1d64b6d5c6bff64ca3d402115fd903e44a7aa39f832fa7b26b5df0115a1ca4", + "size": 218133, + "subdir": "linux-64", + "timestamp": 1520360926837, + "version": "1.11.5" + }, + "cffi-1.11.5-py35he75722e_1.tar.bz2": { + "build": "py35he75722e_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "314512cd83e2561ca201dcd15be65295", + "name": "cffi", + "sha256": "986f767d00458ee45d872fdd55208bfae3c1e3aaca6b8409a33decd77d5e6003", + "size": 218586, + "subdir": "linux-64", + "timestamp": 1534345223944, + "version": "1.11.5" + }, + "cffi-1.11.5-py36h9745a5d_0.tar.bz2": { + "build": "py36h9745a5d_0", + "build_number": 0, + "depends": [ + "libffi", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0c9a1567da72ab770fdfde92013360ce", + "name": "cffi", + "sha256": "dad29f42b08fb607936a97dbef5411637fe4f1eafa067029b8185c1a5bdfb4d8", + "size": 217102, + "subdir": "linux-64", + "timestamp": 1520360727295, + "version": "1.11.5" + }, + "cffi-1.11.5-py36he75722e_1.tar.bz2": { + "build": "py36he75722e_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "79cc59a1413da9e45bf645fb83cafc1f", + "name": "cffi", + "sha256": "cbc8c279e314d658d94ad00d9dadeadb2bef62e1dc0f0636e5bfbd5595d53f59", + "size": 217465, + "subdir": "linux-64", + "timestamp": 1534345191589, + "version": "1.11.5" + }, + "cffi-1.11.5-py37h9745a5d_0.tar.bz2": { + "build": "py37h9745a5d_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "41606f488f8b728670841bc95d2b45de", + "name": "cffi", + "sha256": "1fc2c996326a918d3644552d868da1ecdfca81488dd7b93762c9aa56a365fa9f", + "size": 217543, + "subdir": "linux-64", + "timestamp": 1530694169135, + "version": "1.11.5" + }, + "cffi-1.11.5-py37he75722e_1.tar.bz2": { + "build": "py37he75722e_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "48e4e722bc867d631529a1f80d0b307a", + "name": "cffi", + "sha256": "c208d13703724767f96c75c85e7473a8f0dff74421d5c4e769a7526f4a2f13b4", + "size": 217463, + "subdir": "linux-64", + "timestamp": 1534345255936, + "version": "1.11.5" + }, + "cffi-1.12.1-py27h2e261b9_0.tar.bz2": { + "build": "py27h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "32ab9585062c452d37567d3e8a317cbe", + "name": "cffi", + "sha256": "10a9a5d7bb3022ff8d0a7f0108118c99dda1fe8189a18ed1739788046874dfa3", + "size": 221335, + "subdir": "linux-64", + "timestamp": 1551137423021, + "version": "1.12.1" + }, + "cffi-1.12.1-py36h2e261b9_0.tar.bz2": { + "build": "py36h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7b05d3217b9566f8da9905a10c267edb", + "name": "cffi", + "sha256": "306a46ca8bde2e8708cbe7d93b3f72c9a0247bbe2c4dffd43746ef3636a5f83b", + "size": 225098, + "subdir": "linux-64", + "timestamp": 1551137447149, + "version": "1.12.1" + }, + "cffi-1.12.1-py37h2e261b9_0.tar.bz2": { + "build": "py37h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "91f002e0310de3c49116d49100e7adc4", + "name": "cffi", + "sha256": "ff88d053db086d6410040ee3f674a94913bd80fc7302a92a1d91d716e6b47f08", + "size": 225272, + "subdir": "linux-64", + "timestamp": 1551137419682, + "version": "1.12.1" + }, + "cffi-1.12.2-py27h2e261b9_1.tar.bz2": { + "build": "py27h2e261b9_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5f522d52e47ad19907b7c2029a2a5042", + "name": "cffi", + "sha256": "a87002642e4016e2a3e79c79bbfa910bfdaf28417b15de9294a95e39abac6261", + "size": 223233, + "subdir": "linux-64", + "timestamp": 1552319963035, + "version": "1.12.2" + }, + "cffi-1.12.2-py36h2e261b9_1.tar.bz2": { + "build": "py36h2e261b9_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "81c15c0ab14a8d0127f03d127a30bfdc", + "name": "cffi", + "sha256": "6c2b4f3e1afce5180002eb2be623ed1ae2de1de117be848011dd2cdc35597d3c", + "size": 226848, + "subdir": "linux-64", + "timestamp": 1552320022707, + "version": "1.12.2" + }, + "cffi-1.12.2-py37h2e261b9_1.tar.bz2": { + "build": "py37h2e261b9_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "578b886b0a2bc555000339ad68467f8e", + "name": "cffi", + "sha256": "6228ead30dc78df4422d12172318ec269efc5b02f07d6c9a0c6d872e7d9e1c6c", + "size": 226930, + "subdir": "linux-64", + "timestamp": 1552319931240, + "version": "1.12.2" + }, + "cffi-1.12.3-py27h2e261b9_0.tar.bz2": { + "build": "py27h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e9293dc479183767ba83bbefa64d5e9d", + "name": "cffi", + "sha256": "b8bb2e4653c2b7768414fa753faa4bf03549dac8caa2594b1575d1430c7c1290", + "size": 223633, + "subdir": "linux-64", + "timestamp": 1555948990818, + "version": "1.12.3" + }, + "cffi-1.12.3-py36h2e261b9_0.tar.bz2": { + "build": "py36h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "93ecccfc74996b4b7bfde0ead870fb5c", + "name": "cffi", + "sha256": "f38d6114f35b154e5d425be692f5347319d0cd309b0b002ed50a7c4f90914f63", + "size": 227488, + "subdir": "linux-64", + "timestamp": 1555949007649, + "version": "1.12.3" + }, + "cffi-1.12.3-py37h2e261b9_0.tar.bz2": { + "build": "py37h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6484adbfcda8a1f54d32756c05a3fe59", + "name": "cffi", + "sha256": "365177686e199aa21203835d9af319c1bb2f784f745a848aa0e47f1310a944e8", + "size": 227653, + "subdir": "linux-64", + "timestamp": 1555948976976, + "version": "1.12.3" + }, + "cffi-1.13.0-py27h2e261b9_0.tar.bz2": { + "build": "py27h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "656789cc80a3a1d061fe768879a3ea92", + "name": "cffi", + "sha256": "b91dbc45aae4653945f87453fd90c1fb6febf3c392af9f4bbf71c511181ae753", + "size": 225277, + "subdir": "linux-64", + "timestamp": 1571756504209, + "version": "1.13.0" + }, + "cffi-1.13.0-py36h2e261b9_0.tar.bz2": { + "build": "py36h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9bc4c0b3cf27d1d942b81b61ed848252", + "name": "cffi", + "sha256": "b83b3f64c55c69259c625f5e2cdbaacdd8eabe9cfbf0a5193bd2d0dd3cdc76c5", + "size": 229191, + "subdir": "linux-64", + "timestamp": 1571756515633, + "version": "1.13.0" + }, + "cffi-1.13.0-py37h2e261b9_0.tar.bz2": { + "build": "py37h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f68297f96f91e0d95a4b5be58cab4008", + "name": "cffi", + "sha256": "206df099004644f1650a3374914263bd520c3dd8f1e4b4a82a91e26bf6172d20", + "size": 229238, + "subdir": "linux-64", + "timestamp": 1571756504978, + "version": "1.13.0" + }, + "cffi-1.13.1-py27h2e261b9_0.tar.bz2": { + "build": "py27h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "28d9cd0017a07d61d1946b7aba697bd3", + "name": "cffi", + "sha256": "3e00a42ec1b18aeccc2619e15b269dd201904150354c97fa982313d3a68e6bdb", + "size": 225638, + "subdir": "linux-64", + "timestamp": 1572455338276, + "version": "1.13.1" + }, + "cffi-1.13.1-py36h2e261b9_0.tar.bz2": { + "build": "py36h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3dad1937870bae44165a7445604510b7", + "name": "cffi", + "sha256": "3c6abeb377022037623911ec721761bab2c9ae36a5667ffbe41c1153b9b99ff6", + "size": 229413, + "subdir": "linux-64", + "timestamp": 1572455370751, + "version": "1.13.1" + }, + "cffi-1.13.1-py37h2e261b9_0.tar.bz2": { + "build": "py37h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8475247dea69aef9e17c2fcbd6907b82", + "name": "cffi", + "sha256": "744de029aa353e9052ae0fa323391490b260896c07b4a1d90ac295a3bc9a47e2", + "size": 229486, + "subdir": "linux-64", + "timestamp": 1572455357772, + "version": "1.13.1" + }, + "cffi-1.13.1-py38h2e261b9_0.tar.bz2": { + "build": "py38h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "86208769f58e2096a025d718c4bc7ac6", + "name": "cffi", + "sha256": "b30264472dc787676fc5e18caac856f3ed1aed6f398a64f70678a475d855a6a7", + "size": 235092, + "subdir": "linux-64", + "timestamp": 1573738352852, + "version": "1.13.1" + }, + "cffi-1.13.2-py27h2e261b9_0.tar.bz2": { + "build": "py27h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ab1f53d5560a6b4cda6e980621d13dcf", + "name": "cffi", + "sha256": "dbe5bc9953943bb9142ea0d7341d6752db305ae30d71cb5219ff549299b4ea21", + "size": 225933, + "subdir": "linux-64", + "timestamp": 1573833169634, + "version": "1.13.2" + }, + "cffi-1.13.2-py36h2e261b9_0.tar.bz2": { + "build": "py36h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "72b153d435680c29e790b1c044836240", + "name": "cffi", + "sha256": "1a65bab3ca99d55e1a6f14317adb3960d2d16275b19b8743160cc92d5b20ca77", + "size": 229720, + "subdir": "linux-64", + "timestamp": 1573833198359, + "version": "1.13.2" + }, + "cffi-1.13.2-py37h2e261b9_0.tar.bz2": { + "build": "py37h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "12b17c03586bfda02bdcd39abaf47af9", + "name": "cffi", + "sha256": "68e2c16f493e1e62032332d0a2bf2db32406023e356936a471dc7a9ad4680148", + "size": 230138, + "subdir": "linux-64", + "timestamp": 1573833173761, + "version": "1.13.2" + }, + "cffi-1.13.2-py38h2e261b9_0.tar.bz2": { + "build": "py38h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "f1a41fe10017373c31945460b6616bfc", + "name": "cffi", + "sha256": "871bfd076454bcb216dc34fdc8c6adfe49a66fcfb0b735a265f54929775bbb99", + "size": 238994, + "subdir": "linux-64", + "timestamp": 1573833219570, + "version": "1.13.2" + }, + "cffi-1.14.0-py27he30daa8_1.tar.bz2": { + "build": "py27he30daa8_1", + "build_number": 1, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d49f6e9da265e2a39c49f9cb57734c77", + "name": "cffi", + "sha256": "d653fee0a6f09a74ce69537e8dfeaef8ea270756581ea47ed13c4cc90193ee81", + "size": 227486, + "subdir": "linux-64", + "timestamp": 1589396238714, + "version": "1.14.0" + }, + "cffi-1.14.0-py36h2e261b9_0.tar.bz2": { + "build": "py36h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "46cb24b08df75d758fca400be47044d9", + "name": "cffi", + "sha256": "09b686c1e61f3e6a8ffec5c5f34e7adc3c84c588d48de5c2347ca0dc832110d3", + "size": 230785, + "subdir": "linux-64", + "timestamp": 1581351798636, + "version": "1.14.0" + }, + "cffi-1.14.0-py36he30daa8_1.tar.bz2": { + "build": "py36he30daa8_1", + "build_number": 1, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "51399763a8b4b19401318f1883417763", + "name": "cffi", + "sha256": "37fabc1517e3e7a9f260ee56539155941f9faf5f286a357d7f7a8be726ac8c2f", + "size": 231134, + "subdir": "linux-64", + "timestamp": 1588943529697, + "version": "1.14.0" + }, + "cffi-1.14.0-py37h2e261b9_0.tar.bz2": { + "build": "py37h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2aa3afc7c008b2f0379ad6f9cf2a89a3", + "name": "cffi", + "sha256": "bc22ca13f4cce2cc9072962ae2409bd59db7276eb9637390ce5fb0bf977731d9", + "size": 230816, + "subdir": "linux-64", + "timestamp": 1581351687214, + "version": "1.14.0" + }, + "cffi-1.14.0-py37he30daa8_1.tar.bz2": { + "build": "py37he30daa8_1", + "build_number": 1, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6299ca54e001624cb9ec4a5a4e563e5d", + "name": "cffi", + "sha256": "d3df2804a6fbdb5f56d3201d0185c35e034bb33a99cd87f03e8a4aad7b04ab6a", + "size": 231399, + "subdir": "linux-64", + "timestamp": 1588897787322, + "version": "1.14.0" + }, + "cffi-1.14.0-py38h2e261b9_0.tar.bz2": { + "build": "py38h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "f1c26f1b5f45b8097efdd1f42b026748", + "name": "cffi", + "sha256": "d5cffb3ac528b4f83835fd9da18e06a5d08ac5ee5409c1bad7700e5005669266", + "size": 233069, + "subdir": "linux-64", + "timestamp": 1581351818767, + "version": "1.14.0" + }, + "cffi-1.14.0-py38he30daa8_1.tar.bz2": { + "build": "py38he30daa8_1", + "build_number": 1, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "96955b3f24b258eae84b3916b54c506b", + "name": "cffi", + "sha256": "92070c733dec06ac6c10a8242f3872b72b69036a07d8a2b20d07ca514f7b4d7f", + "size": 233535, + "subdir": "linux-64", + "timestamp": 1588897929886, + "version": "1.14.0" + }, + "cffi-1.14.1-py36he30daa8_0.tar.bz2": { + "build": "py36he30daa8_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "67868911d9ac3836a2ae756492161478", + "name": "cffi", + "sha256": "5a9d03d560be23cf0e2278d23b8d00177d42b414d849c5c385e9292ff2d8fad8", + "size": 232779, + "subdir": "linux-64", + "timestamp": 1596809908559, + "version": "1.14.1" + }, + "cffi-1.14.1-py37he30daa8_0.tar.bz2": { + "build": "py37he30daa8_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "88fe433ec838b23554af4eabec5750e5", + "name": "cffi", + "sha256": "0cda2dc1ad32886b9661f9531af86135753fa9946cd7f18795557dcb748ab2c1", + "size": 232945, + "subdir": "linux-64", + "timestamp": 1596809895216, + "version": "1.14.1" + }, + "cffi-1.14.1-py38he30daa8_0.tar.bz2": { + "build": "py38he30daa8_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "9a15e627c65ff8354d883b778ec9760f", + "name": "cffi", + "sha256": "ce48c2d58b53f78bc31db4cada93e219665bb073ecf843d4344e2780f200bcc8", + "size": 235136, + "subdir": "linux-64", + "timestamp": 1596809891164, + "version": "1.14.1" + }, + "cffi-1.14.2-py36he30daa8_0.tar.bz2": { + "build": "py36he30daa8_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e903d7a14bb4332b59e368653826065f", + "name": "cffi", + "sha256": "a550b63101928f73e5fccd64b3f79064fad719e57633a047f2c714ea18b9d47e", + "size": 233592, + "subdir": "linux-64", + "timestamp": 1598370838618, + "version": "1.14.2" + }, + "cffi-1.14.2-py37he30daa8_0.tar.bz2": { + "build": "py37he30daa8_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "20bcf36b61b80f4c3884ca56be520b86", + "name": "cffi", + "sha256": "b36382dc4085befa5c9f7629e0171f21597cefd7c0eb98a8e3bd36b035cf5266", + "size": 233911, + "subdir": "linux-64", + "timestamp": 1598370857899, + "version": "1.14.2" + }, + "cffi-1.14.2-py38he30daa8_0.tar.bz2": { + "build": "py38he30daa8_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "7e47f5acabbcd49d474183d064b15699", + "name": "cffi", + "sha256": "27230dcb81a8e8898aa8ccf9e97b80c01ecaf5456757caee1d8f457ef74cbbb0", + "size": 236047, + "subdir": "linux-64", + "timestamp": 1598370811016, + "version": "1.14.2" + }, + "cffi-1.14.3-py36h261ae71_2.tar.bz2": { + "build": "py36h261ae71_2", + "build_number": 2, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2ea32296b7d477945ecf61ddbd921fc5", + "name": "cffi", + "sha256": "dfe150c25cc0edac01096d53e8584df1a436603312ea8724a9d3e87282323795", + "size": 234365, + "subdir": "linux-64", + "timestamp": 1605538130011, + "version": "1.14.3" + }, + "cffi-1.14.3-py36he30daa8_0.tar.bz2": { + "build": "py36he30daa8_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "307a16b844d1bb2d49e72a64f5f0ba39", + "name": "cffi", + "sha256": "5ec26ecf0a2c2266d8ac37548d232fd5f5a6e84de991319678148b65a0f2ff3c", + "size": 228902, + "subdir": "linux-64", + "timestamp": 1600699204564, + "version": "1.14.3" + }, + "cffi-1.14.3-py37h261ae71_2.tar.bz2": { + "build": "py37h261ae71_2", + "build_number": 2, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "eef6382f668b381f2770f02eee91fa05", + "name": "cffi", + "sha256": "e8bdf4dc31c2b1c602ec4aa1e6e47a1b305480752505f33a644e394f610d5f1c", + "size": 234636, + "subdir": "linux-64", + "timestamp": 1605538083720, + "version": "1.14.3" + }, + "cffi-1.14.3-py37he30daa8_0.tar.bz2": { + "build": "py37he30daa8_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "39024197b52eaa3a86cc445ba439efc4", + "name": "cffi", + "sha256": "303247c85a5585b441f03f6ad0673de17a5ed8d9d8625eafc456f4001ced462a", + "size": 229234, + "subdir": "linux-64", + "timestamp": 1600699221512, + "version": "1.14.3" + }, + "cffi-1.14.3-py38h261ae71_2.tar.bz2": { + "build": "py38h261ae71_2", + "build_number": 2, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "71bc5d5069f62bd492401877e2b961fd", + "name": "cffi", + "sha256": "db03f225470e20d7bf8037048ff3a0524d8c2f3f5f8d88b01ba38f95c87c24a8", + "size": 236825, + "subdir": "linux-64", + "timestamp": 1605538109665, + "version": "1.14.3" + }, + "cffi-1.14.3-py38he30daa8_0.tar.bz2": { + "build": "py38he30daa8_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "8a249cc6fc565f62b779b3a016740f28", + "name": "cffi", + "sha256": "673e30506a1ab32d3f3eebebbb6d0e4cd24dbe8bfbf764c4ff80609e75f50949", + "size": 231260, + "subdir": "linux-64", + "timestamp": 1600699230784, + "version": "1.14.3" + }, + "cffi-1.14.3-py39h261ae71_2.tar.bz2": { + "build": "py39h261ae71_2", + "build_number": 2, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "f6d3b677eae34a6684a21d05aaf2a894", + "name": "cffi", + "sha256": "06d0aff6c6c975f918a04129dc0127e6b32104975da9d50393d903ab76d73b95", + "size": 237401, + "subdir": "linux-64", + "timestamp": 1605538099397, + "version": "1.14.3" + }, + "cffi-1.14.4-py36h261ae71_0.tar.bz2": { + "build": "py36h261ae71_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "02a617a95c40eebdc03dd2b3f36e89af", + "name": "cffi", + "sha256": "c467557fc94dd6d77fc172a5bef9d852542bc74531fd9fcc6fe3dd5c3e66779c", + "size": 229285, + "subdir": "linux-64", + "timestamp": 1606255140696, + "version": "1.14.4" + }, + "cffi-1.14.4-py37h261ae71_0.tar.bz2": { + "build": "py37h261ae71_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6bc71a686042b7b43d0785f7084f21c7", + "name": "cffi", + "sha256": "ddc69ed95d21b218a6dd839356cb002134e8cabf2b148df9b64fc4fe818155a9", + "size": 229342, + "subdir": "linux-64", + "timestamp": 1606255140718, + "version": "1.14.4" + }, + "cffi-1.14.4-py38h261ae71_0.tar.bz2": { + "build": "py38h261ae71_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "d69bcd75fac3fff24d9988967b118c61", + "name": "cffi", + "sha256": "cef408aed59e47511fbaa158c29b6420a67d1509149815cf1be5336c2014201a", + "size": 231433, + "subdir": "linux-64", + "timestamp": 1606255128630, + "version": "1.14.4" + }, + "cffi-1.14.4-py39h261ae71_0.tar.bz2": { + "build": "py39h261ae71_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "9f7a9eab23c5b3071710c25b05b2f8ad", + "name": "cffi", + "sha256": "f7e38f706e0f3606564b32096447ccac0abc1e45a28cc200b8c192500f55fcd2", + "size": 232141, + "subdir": "linux-64", + "timestamp": 1606255169067, + "version": "1.14.4" + }, + "cffi-1.14.5-py36h261ae71_0.tar.bz2": { + "build": "py36h261ae71_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1aa6de38d6987e03543ad481ef6b78af", + "name": "cffi", + "sha256": "2f453e9b923244a53c04d44e279d8b6d1d0546f2c333f147e8dfb9ec226f4a96", + "size": 229187, + "subdir": "linux-64", + "timestamp": 1613246487719, + "version": "1.14.5" + }, + "cffi-1.14.5-py37h261ae71_0.tar.bz2": { + "build": "py37h261ae71_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "681402e31b6bbe4fdb62c9456c4e44db", + "name": "cffi", + "sha256": "300ac6ab8872ca1c350d81e72e08776b10264cb5e6b6523e03feb789f436e803", + "size": 229462, + "subdir": "linux-64", + "timestamp": 1613246984885, + "version": "1.14.5" + }, + "cffi-1.14.5-py38h261ae71_0.tar.bz2": { + "build": "py38h261ae71_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "ea418e5c97ccc65605d3900aba0044b3", + "name": "cffi", + "sha256": "a6176b6f42f24d92a8398e6449be9d0babf677c836f31f0d2c1d8aa75c6306cd", + "size": 231553, + "subdir": "linux-64", + "timestamp": 1613246996334, + "version": "1.14.5" + }, + "cffi-1.14.5-py39h261ae71_0.tar.bz2": { + "build": "py39h261ae71_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "227c9160144b3c934d796eb4047be270", + "name": "cffi", + "sha256": "f51dfaaaf27796530ed0cb5066be12b43d24e38a0552b3f005cd6c271a7fce75", + "size": 232177, + "subdir": "linux-64", + "timestamp": 1613246999673, + "version": "1.14.5" + }, + "cffi-1.14.6-py36h400218f_0.tar.bz2": { + "build": "py36h400218f_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "292593cbfdd19cfbbac2d5693cd51911", + "name": "cffi", + "sha256": "1a0a53303cb0e240765c0e92c55aa1ff088451c001b6a9d982f435bce5a70009", + "size": 228982, + "subdir": "linux-64", + "timestamp": 1625814764180, + "version": "1.14.6" + }, + "cffi-1.14.6-py37h400218f_0.tar.bz2": { + "build": "py37h400218f_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7c0961e747f815ca5e9cafdca35da63f", + "name": "cffi", + "sha256": "79556e981fe1eb28d472ac939bd8953400c01fd0904bdc24c1b7337bb19794a4", + "size": 229258, + "subdir": "linux-64", + "timestamp": 1625814747956, + "version": "1.14.6" + }, + "cffi-1.14.6-py38h400218f_0.tar.bz2": { + "build": "py38h400218f_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "3f7461f1490b4a49c1be45cceab5886a", + "name": "cffi", + "sha256": "da53e17c3220e9e4130420a6fb7df3af29c280af631d295841a4b0f265ee0369", + "size": 231235, + "subdir": "linux-64", + "timestamp": 1625807894199, + "version": "1.14.6" + }, + "cffi-1.14.6-py39h400218f_0.tar.bz2": { + "build": "py39h400218f_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "c86250c8625c8f3ba61e5e6f8784d66a", + "name": "cffi", + "sha256": "ada49b19cea09beec5d5eba25ea3169bdeed5c5a120746ee3ad04e1ddd7b0ddb", + "size": 232258, + "subdir": "linux-64", + "timestamp": 1625814763237, + "version": "1.14.6" + }, + "cffi-1.15.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "93d0cf7d919b5286f02c0077b27b5420", + "name": "cffi", + "sha256": "3ca4b7b34a45c632ae6555e626065fd8ea43ca2266dc7197e24d4e626de5bcff", + "size": 403389, + "subdir": "linux-64", + "timestamp": 1640788918553, + "version": "1.15.0" + }, + "cffi-1.15.0-py310hd667e15_1.tar.bz2": { + "build": "py310hd667e15_1", + "build_number": 1, + "depends": [ + "libffi >=3.3", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c83b10bcb81d4179f36368771f0d1fa", + "name": "cffi", + "sha256": "d94845e933aa2794857a2addef91366c0ef67a84433f1e1a26e7ff4fb0a938bd", + "size": 416321, + "subdir": "linux-64", + "timestamp": 1642753394042, + "version": "1.15.0" + }, + "cffi-1.15.0-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64ae459ce53a2924275109f034a4545d", + "name": "cffi", + "sha256": "4ebb5c82ee0df8d9ed962ae17dcc2749715b60fbdb4e2cc0b23e34322e8eeac2", + "size": 229361, + "subdir": "linux-64", + "timestamp": 1636541970065, + "version": "1.15.0" + }, + "cffi-1.15.0-py37hd667e15_1.tar.bz2": { + "build": "py37hd667e15_1", + "build_number": 1, + "depends": [ + "libffi >=3.3", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "916bb0c03acca52aefeecffb3953f8cb", + "name": "cffi", + "sha256": "628f8f3f147275cf3c483b36bb253cbabd60446b9cf465ed9d7be2b9f792427d", + "size": 229328, + "subdir": "linux-64", + "timestamp": 1642701175698, + "version": "1.15.0" + }, + "cffi-1.15.0-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a07663a5b893c874a430fa5a7580c599", + "name": "cffi", + "sha256": "1c011803998625d0f0b3624a0960f301538cf3d121142adc194c1fa6e01dd20b", + "size": 231243, + "subdir": "linux-64", + "timestamp": 1636541976524, + "version": "1.15.0" + }, + "cffi-1.15.0-py38hd667e15_1.tar.bz2": { + "build": "py38hd667e15_1", + "build_number": 1, + "depends": [ + "libffi >=3.3", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c7b4ec905e563e91ffbabb11516809f", + "name": "cffi", + "sha256": "b87c8090413b0858c694d1e9e646177529bcffbb211822254174d46856c73914", + "size": 231275, + "subdir": "linux-64", + "timestamp": 1642701149006, + "version": "1.15.0" + }, + "cffi-1.15.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bac3087e1fddad3f339de40da13149bb", + "name": "cffi", + "sha256": "a9bebb7ae70d57e0115dbb5ae37cd836431f6f8f6a2691c139c5f1512c7f6536", + "size": 232084, + "subdir": "linux-64", + "timestamp": 1636529700462, + "version": "1.15.0" + }, + "cffi-1.15.0-py39hd667e15_1.tar.bz2": { + "build": "py39hd667e15_1", + "build_number": 1, + "depends": [ + "libffi >=3.3", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "76ae217198b014b89b267cf41b8251dd", + "name": "cffi", + "sha256": "674707b9c42e65c903c9786ee5a56b4d42aa054f1e75b328db8a2c1bfa368739", + "size": 231920, + "subdir": "linux-64", + "timestamp": 1642701209740, + "version": "1.15.0" + }, + "cffi-1.15.1-py310h5eee18b_2.tar.bz2": { + "build": "py310h5eee18b_2", + "build_number": 2, + "depends": [ + "libffi >=3.4,<3.5", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22c432e7c6356f68e5f1d3cec118eb38", + "name": "cffi", + "sha256": "e7fb65b41fa0843062851acf42289b8daaf79dd1f1a7e342cfd80671e1c4c225", + "size": 242512, + "subdir": "linux-64", + "timestamp": 1669355805636, + "version": "1.15.1" + }, + "cffi-1.15.1-py310h5eee18b_3.tar.bz2": { + "build": "py310h5eee18b_3", + "build_number": 3, + "depends": [ + "libffi >=3.4,<3.5", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e00995da98d9d0dcbc5c50a81145a439", + "name": "cffi", + "sha256": "35ef9d746d4ec9fa549da206e710f4583f4c74f4dcc9411c6028fced7d91d699", + "size": 237145, + "subdir": "linux-64", + "timestamp": 1670423250002, + "version": "1.15.1" + }, + "cffi-1.15.1-py310h74dc2b5_0.tar.bz2": { + "build": "py310h74dc2b5_0", + "build_number": 0, + "depends": [ + "libffi >=3.3", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "005fa5fdea9edd4583bef3b78f77d89d", + "name": "cffi", + "sha256": "f964342f76dbda532fa5523b42486126988508515fb879de6b9babbf20e0aca9", + "size": 450387, + "subdir": "linux-64", + "timestamp": 1659598699171, + "version": "1.15.1" + }, + "cffi-1.15.1-py311h5eee18b_3.tar.bz2": { + "build": "py311h5eee18b_3", + "build_number": 3, + "depends": [ + "libffi >=3.4,<3.5", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc13d51d9d74b85bb383a72f53f88fc9", + "name": "cffi", + "sha256": "2779b4c94443a8afd2d753904f922d4b9b569ffbf3e7ce7a28c264fd10268333", + "size": 300301, + "subdir": "linux-64", + "timestamp": 1676822552354, + "version": "1.15.1" + }, + "cffi-1.15.1-py37h5eee18b_2.tar.bz2": { + "build": "py37h5eee18b_2", + "build_number": 2, + "depends": [ + "libffi >=3.4,<3.5", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d1ec81c0dca167803ac2099f67bde481", + "name": "cffi", + "sha256": "2be3514bf0ce7a5fe041ef6aee913a9d9c0424f1fe2518ac49097b3acaaf9a7b", + "size": 238446, + "subdir": "linux-64", + "timestamp": 1669355800053, + "version": "1.15.1" + }, + "cffi-1.15.1-py37h5eee18b_3.tar.bz2": { + "build": "py37h5eee18b_3", + "build_number": 3, + "depends": [ + "libffi >=3.4,<3.5", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee203e16cd6fbc04d6a415addb8d52f0", + "name": "cffi", + "sha256": "e468a6eab788cf8f6f34304e80af61f49b76e8c17d3919f8a15b2f6a0a7fdeca", + "size": 232835, + "subdir": "linux-64", + "timestamp": 1670423312176, + "version": "1.15.1" + }, + "cffi-1.15.1-py37h74dc2b5_0.tar.bz2": { + "build": "py37h74dc2b5_0", + "build_number": 0, + "depends": [ + "libffi >=3.3", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7eef3f64739a1d53f12f6feb44236f72", + "name": "cffi", + "sha256": "56d0bb0c61d1d2718ca26812fc3feca8980d926ee75b65c1afc85e0dbd085c3d", + "size": 233686, + "subdir": "linux-64", + "timestamp": 1659598775030, + "version": "1.15.1" + }, + "cffi-1.15.1-py38h5eee18b_2.tar.bz2": { + "build": "py38h5eee18b_2", + "build_number": 2, + "depends": [ + "libffi >=3.4,<3.5", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90395d722135cc9da90c60abce4ba39f", + "name": "cffi", + "sha256": "7ff69bd4f5cb8564f2e60e58d3c4842cc5d81894d1b2db657c877601133d731a", + "size": 240127, + "subdir": "linux-64", + "timestamp": 1669355800711, + "version": "1.15.1" + }, + "cffi-1.15.1-py38h5eee18b_3.tar.bz2": { + "build": "py38h5eee18b_3", + "build_number": 3, + "depends": [ + "libffi >=3.4,<3.5", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "26fa9f73bce5ccd0a2f8913a3c159677", + "name": "cffi", + "sha256": "a9ed8c4137fd66ca0fad079ec49ab964a41e549dde9d332f41d75f1b5244dcae", + "size": 234763, + "subdir": "linux-64", + "timestamp": 1670423342840, + "version": "1.15.1" + }, + "cffi-1.15.1-py38h74dc2b5_0.tar.bz2": { + "build": "py38h74dc2b5_0", + "build_number": 0, + "depends": [ + "libffi >=3.3", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "75601aedfb7ba384b1114b55ea2ee425", + "name": "cffi", + "sha256": "f98f082266e3a4a9d146234986871542d101a66a894d03b8996a6b84cc085931", + "size": 235296, + "subdir": "linux-64", + "timestamp": 1659598724314, + "version": "1.15.1" + }, + "cffi-1.15.1-py39h5eee18b_2.tar.bz2": { + "build": "py39h5eee18b_2", + "build_number": 2, + "depends": [ + "libffi >=3.4,<3.5", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aee2ca14931047a03d2c320cf74c592c", + "name": "cffi", + "sha256": "11d67e2d5550da646ca430f4c4505b843a3e71150678e37347caa59f1dcc120a", + "size": 240529, + "subdir": "linux-64", + "timestamp": 1669355794965, + "version": "1.15.1" + }, + "cffi-1.15.1-py39h5eee18b_3.tar.bz2": { + "build": "py39h5eee18b_3", + "build_number": 3, + "depends": [ + "libffi >=3.4,<3.5", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fff69f95079191a10e099b21a5fd4bc3", + "name": "cffi", + "sha256": "e99314f8809d65195dcab68a9783f70fbe990113a66c98c9b0a7ffea01226b71", + "size": 234749, + "subdir": "linux-64", + "timestamp": 1670423281079, + "version": "1.15.1" + }, + "cffi-1.15.1-py39h74dc2b5_0.tar.bz2": { + "build": "py39h74dc2b5_0", + "build_number": 0, + "depends": [ + "libffi >=3.3", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2953f22399cb56381016d7a039d0c5ac", + "name": "cffi", + "sha256": "aa09a2a7cdbf2c1ac84a4fe6e2206ad68c8d3a20fb541bf01ec3aaf92aae3c49", + "size": 235313, + "subdir": "linux-64", + "timestamp": 1659598749654, + "version": "1.15.1" + }, + "cfgv-3.3.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a00b36b53a1bdb62c0d76c2baf7f7f80", + "name": "cfgv", + "sha256": "9af3e45eff615a432406738ada1a3f23acd59a91a624dd550d0ecaa5441aec72", + "size": 16187, + "subdir": "linux-64", + "timestamp": 1663174700493, + "version": "3.3.1" + }, + "cfgv-3.3.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2548d3bf0e1e0a44cd60c2aefc3c5b0", + "name": "cfgv", + "sha256": "72b9a94a23af271c36118dff51059ed0d61f4b02eab81412bea3b051d0af733f", + "size": 20456, + "subdir": "linux-64", + "timestamp": 1676843499073, + "version": "3.3.1" + }, + "cfgv-3.3.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3ffa986fa3a513c76ce4cde06142b04", + "name": "cfgv", + "sha256": "7e4856497462135638ecef860cb2db5f723d6e2f5d176fd4e4f1d90103fa7b23", + "size": 15857, + "subdir": "linux-64", + "timestamp": 1663174750093, + "version": "3.3.1" + }, + "cfgv-3.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7bbea65e15ffdac0363d5f8f975f71fe", + "name": "cfgv", + "sha256": "0eb2c491524c899563b18492921ba9e72d64a6e7baed781a75e2049b0075abc7", + "size": 15927, + "subdir": "linux-64", + "timestamp": 1663174724979, + "version": "3.3.1" + }, + "cfgv-3.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c83f2fd3ac1619ee7f401c6c476a041", + "name": "cfgv", + "sha256": "b67048f13f338d9e7df5b89ed54ec83dac5aa60de1711cf53840fb7f40cadaac", + "size": 16012, + "subdir": "linux-64", + "timestamp": 1663174776084, + "version": "3.3.1" + }, + "cfitsio-3.470-h5893167_7.tar.bz2": { + "build": "h5893167_7", + "build_number": 7, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Other", + "license_family": "Other", + "md5": "65a71d60ece0bd684f1be09b48de8d00", + "name": "cfitsio", + "sha256": "a4a855659e4a52515b940d1b9d8204b626c11395980e99539b24f52d658e1857", + "size": 1384722, + "subdir": "linux-64", + "timestamp": 1655814890848, + "version": "3.470" + }, + "cfitsio-3.470-hb7c8383_2.tar.bz2": { + "build": "hb7c8383_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libcurl >=7.65.3,<8.0a0", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "fitsio", + "md5": "9c885f4f997b9edf56cc9b05b42631ca", + "name": "cfitsio", + "sha256": "dfdea52c99d61808c2902547a697a6cce0520364b09badaf8d80007c2cc72f2c", + "size": 1446492, + "subdir": "linux-64", + "timestamp": 1573142889363, + "version": "3.470" + }, + "cfitsio-3.470-hf0d0db6_5.tar.bz2": { + "build": "hf0d0db6_5", + "build_number": 5, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libcurl >=7.69.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "fitsio", + "md5": "0f48621edff86bf313a31ec29f01c961", + "name": "cfitsio", + "sha256": "af062b4e2e50fc5d1caf730bac528399830dae191eba529cb55c54062e4200bc", + "size": 1358448, + "subdir": "linux-64", + "timestamp": 1591781091219, + "version": "3.470" + }, + "cfitsio-3.470-hf0d0db6_6.tar.bz2": { + "build": "hf0d0db6_6", + "build_number": 6, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "fitsio", + "md5": "7ff507183f61b0613724b63050abb2c2", + "name": "cfitsio", + "sha256": "23552cdff499c81a7558ddfc97bffdfb79e8095917214f8a123f1d33d9e6f267", + "size": 1356419, + "subdir": "linux-64", + "timestamp": 1601308736676, + "version": "3.470" + }, + "cfn-lint-0.24.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "961a08f239b377b160b6d803b846fb6c", + "name": "cfn-lint", + "sha256": "c6b9a029eb85150e1b9f3b205742f3a499a5548821247fb6eb60d3f0bb8e34b5", + "size": 2077483, + "subdir": "linux-64", + "timestamp": 1588569235808, + "version": "0.24.4" + }, + "cfn-lint-0.24.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "5bc45529b76d00024a26417a3c792f8d", + "name": "cfn-lint", + "sha256": "cc5ff122362de29a896aafbcca4f2cbfdb5b53c6413ed9d92f0f71b2827f3c57", + "size": 2076150, + "subdir": "linux-64", + "timestamp": 1588569234018, + "version": "0.24.4" + }, + "cfn-lint-0.24.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "ca3a3753c51f4d82ad95033f2bba2593", + "name": "cfn-lint", + "sha256": "f37c77c23272c97692f0b1f800983899b64b2858f82914b3a2b3aab5311c76eb", + "size": 2079357, + "subdir": "linux-64", + "timestamp": 1588569234163, + "version": "0.24.4" + }, + "cfn-lint-0.36.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "92404fb7d105900b5007bc45ef052af1", + "name": "cfn-lint", + "sha256": "93b764670c5b55b5878d03bd38b10ce2f0b4d2ef753203453e81a5ff8684cbe0", + "size": 3148767, + "subdir": "linux-64", + "timestamp": 1601051505833, + "version": "0.36.1" + }, + "cfn-lint-0.36.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "dbf137ad7f720944be3ba6f7b3daf067", + "name": "cfn-lint", + "sha256": "c6c805591e849aa79888332cb7d3779ae728b93618de2a1edd390664cd274c8e", + "size": 3144240, + "subdir": "linux-64", + "timestamp": 1601051552705, + "version": "0.36.1" + }, + "cfn-lint-0.36.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "b601ad9695e781493225fcd5f22646a4", + "name": "cfn-lint", + "sha256": "db92c6247a84d851b11c961b1d77ee6de479ecffada7ff01a96be401c9145262", + "size": 3145228, + "subdir": "linux-64", + "timestamp": 1601051682504, + "version": "0.36.1" + }, + "cfn-lint-0.37.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "fbfe7ceb374e642281fe493d6e5eb607", + "name": "cfn-lint", + "sha256": "e5238aafe276ea647b4d66aea62839daece1d28cd35eada1fc1c246419d4d0ad", + "size": 3156707, + "subdir": "linux-64", + "timestamp": 1601488370353, + "version": "0.37.0" + }, + "cfn-lint-0.37.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "7b6d35fae7c85cfde32bcba7560809df", + "name": "cfn-lint", + "sha256": "96cd9fdbaf0c2522ae6dceea489f6f03457324f500e16ceb099418502ae0688b", + "size": 3158945, + "subdir": "linux-64", + "timestamp": 1601488342170, + "version": "0.37.0" + }, + "cfn-lint-0.37.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "29ded49a791055eea422bb44538994a4", + "name": "cfn-lint", + "sha256": "004c032881acca6a1afebf033f76c7a1d0e35e0a1e4319ecb259189b619e390d", + "size": 3156739, + "subdir": "linux-64", + "timestamp": 1601488369194, + "version": "0.37.0" + }, + "cfn-lint-0.37.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "1b2438580c36e02edab2c7fba87d1700", + "name": "cfn-lint", + "sha256": "4b150810dc463eaa24387b43c0f06c1b67bc2026f79f793504deb586473ec8eb", + "size": 3177313, + "subdir": "linux-64", + "timestamp": 1602083228792, + "version": "0.37.1" + }, + "cfn-lint-0.37.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "2808e13fac364078b0d9f70a5216b58e", + "name": "cfn-lint", + "sha256": "c6651f053a0067a930fa17f8963e063e0372206615afce3bec6158860ddf14a2", + "size": 3175946, + "subdir": "linux-64", + "timestamp": 1602083275364, + "version": "0.37.1" + }, + "cfn-lint-0.37.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "e6ed34bd092f6572491d3ff3217ee7c6", + "name": "cfn-lint", + "sha256": "353d8f677b2e9cc7b44a0dd191e405f951410c473ff86c4200d742f10e0c255a", + "size": 3174893, + "subdir": "linux-64", + "timestamp": 1602083250608, + "version": "0.37.1" + }, + "cfn-lint-0.38.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "66d5f607e0006558b6b1306f9e131a39", + "name": "cfn-lint", + "sha256": "b705bb28c3a64d670d036421de6f8edff823885a88cadccb463145533cd4d087", + "size": 3194853, + "subdir": "linux-64", + "timestamp": 1602622948523, + "version": "0.38.0" + }, + "cfn-lint-0.38.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "fb4683d6244a5a23e3dee3499f74a57c", + "name": "cfn-lint", + "sha256": "64cc2a92223ab7ac00e0dcbc2341ee1acbfd053f1b835cde69bc7827c41f6750", + "size": 3199242, + "subdir": "linux-64", + "timestamp": 1602622975600, + "version": "0.38.0" + }, + "cfn-lint-0.38.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "699cc6c7f955c91d8682b07aefb8a287", + "name": "cfn-lint", + "sha256": "740ad9b21ff062280520d305107788367c7e487a1053b192d1476d17026cf8bd", + "size": 3195759, + "subdir": "linux-64", + "timestamp": 1602622977759, + "version": "0.38.0" + }, + "cfn-lint-0.39.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "fffedac0367106075b7e29b95725b6e4", + "name": "cfn-lint", + "sha256": "61442e7f8fe5836776a16109c84cf05e33621bfd606f8b5f728f06bee0bc9e48", + "size": 3257510, + "subdir": "linux-64", + "timestamp": 1603896284961, + "version": "0.39.0" + }, + "cfn-lint-0.39.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "f3281a998e94940d1c74033307748d57", + "name": "cfn-lint", + "sha256": "fb458cdb363800fe361c41c6897135fd6d511fbb7dd20d06fde95606f555d945", + "size": 3250433, + "subdir": "linux-64", + "timestamp": 1603896258132, + "version": "0.39.0" + }, + "cfn-lint-0.39.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "ee5f90cb648e391d26536b8b1abf33f2", + "name": "cfn-lint", + "sha256": "9bd70af1f8a13d0afea8c0010db69f46b7d4541183518b9ee324a8f047ba78c7", + "size": 3248956, + "subdir": "linux-64", + "timestamp": 1603896255343, + "version": "0.39.0" + }, + "cfn-lint-0.40.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "5b61ecbd6c00eb316edd7bece58ad44e", + "name": "cfn-lint", + "sha256": "78c4913261b5e3706c1eff79b86ba54df1bd3e70e1abaac16ba83b153f80e5b6", + "size": 3271397, + "subdir": "linux-64", + "timestamp": 1605061847620, + "version": "0.40.0" + }, + "cfn-lint-0.40.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "a66176409ee194004ca526a0c0b0defe", + "name": "cfn-lint", + "sha256": "b98fcc7dc8c2b4c17275e0ef17ebee20f51176422f82174a1df047f28a75a252", + "size": 3263490, + "subdir": "linux-64", + "timestamp": 1605061835301, + "version": "0.40.0" + }, + "cfn-lint-0.40.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "b9a8852ef2c09982aade193f778cb7a1", + "name": "cfn-lint", + "sha256": "dcfc6eb6afca592f942fd88caa0ff5832591b074cff1bf61c39a36b18e6e4268", + "size": 3283262, + "subdir": "linux-64", + "timestamp": 1605061850358, + "version": "0.40.0" + }, + "cfn-lint-0.41.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "b5373f565242b54a0051ebe8d44aa393", + "name": "cfn-lint", + "sha256": "0082654ca345336aef8e2a45fc198f3a064a034e854f9edf42473ab91ff8265d", + "size": 3333870, + "subdir": "linux-64", + "timestamp": 1605995728363, + "version": "0.41.0" + }, + "cfn-lint-0.41.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "b4c0b9cfda2b90df51993dae8f901ec6", + "name": "cfn-lint", + "sha256": "d17bf01da1d6d64eb1c02a04c3d9a3370fc0a82fff3f66fe8557d742db3c8a4a", + "size": 3310645, + "subdir": "linux-64", + "timestamp": 1605995744220, + "version": "0.41.0" + }, + "cfn-lint-0.41.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "f8bc4073ed0deb0692214acb31ba3124", + "name": "cfn-lint", + "sha256": "03313087495e3cb48ea0abff85ac70baef61cd1010c09d698dc88ef76f463a81", + "size": 3315040, + "subdir": "linux-64", + "timestamp": 1605995763162, + "version": "0.41.0" + }, + "cfn-lint-0.42.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "50898052c06f758d3af8582b3ef76d51", + "name": "cfn-lint", + "sha256": "3fb5919c270622694fde056b86f80a8a71b66234f290fbaa85803b9639a8692a", + "size": 3397058, + "subdir": "linux-64", + "timestamp": 1606255233257, + "version": "0.42.0" + }, + "cfn-lint-0.42.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "eba8e7ca7977aefbb1e5461cbba175e3", + "name": "cfn-lint", + "sha256": "a22414c8f6a2f9c01c6f0040091cfb201436d1d8af115e15ede2ac2c7452c359", + "size": 3415660, + "subdir": "linux-64", + "timestamp": 1606255199047, + "version": "0.42.0" + }, + "cfn-lint-0.42.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "cc1482fe18888ed71380b6c19cd62a9f", + "name": "cfn-lint", + "sha256": "1dbc9ef5ba6340bfbe27f78606f63a04467b7ca26e189fd0387116df6bc4edc7", + "size": 3399332, + "subdir": "linux-64", + "timestamp": 1606255202435, + "version": "0.42.0" + }, + "cfn-lint-0.43.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "5f155c3ca532d549a0ccef8c09daffc1", + "name": "cfn-lint", + "sha256": "cbfddcaa07f1b3a596c98d55bd80f43bc1db437f8cc0bcd107357b85e8d5ec9b", + "size": 3435069, + "subdir": "linux-64", + "timestamp": 1607111182417, + "version": "0.43.0" + }, + "cfn-lint-0.43.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "9f4ad97b2afc8fec6e4f8faf154bab4d", + "name": "cfn-lint", + "sha256": "f525c891b6f8370612e8abf67cde3bd87bc51210c5c7f76f80a8c5a11e8eb7aa", + "size": 3425571, + "subdir": "linux-64", + "timestamp": 1607111179496, + "version": "0.43.0" + }, + "cfn-lint-0.43.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "95cbd91922dddf52c07861adfe4a6270", + "name": "cfn-lint", + "sha256": "9b248237ba3aded713eb3a183f341c10ad400319ce581f1eb29a12dbf10619b4", + "size": 3433797, + "subdir": "linux-64", + "timestamp": 1607111192534, + "version": "0.43.0" + }, + "cfn-lint-0.44.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "232f3bcda16cd3d027a677cf7023c80e", + "name": "cfn-lint", + "sha256": "592f591394ddbe1730a736114a091f85ffbc223b5d9d4ef09d2451068315bf3e", + "size": 3427528, + "subdir": "linux-64", + "timestamp": 1608055503276, + "version": "0.44.0" + }, + "cfn-lint-0.44.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "1cd5b52cb4bf89413649c73869aca7e1", + "name": "cfn-lint", + "sha256": "916804ad45b6fed774d359c03840a9a463c331a22356c025e35118edf006a75b", + "size": 3448881, + "subdir": "linux-64", + "timestamp": 1608055509572, + "version": "0.44.0" + }, + "cfn-lint-0.44.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "61e33d819c0ae0bf05b1276b16a1bd3d", + "name": "cfn-lint", + "sha256": "f1c7bae26f594068d3db7a5b8b82e6a7835248d725ace3df54c05f062f159507", + "size": 3431154, + "subdir": "linux-64", + "timestamp": 1608055518667, + "version": "0.44.0" + }, + "cfn-lint-0.44.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "be371a3b2c5e23c45df97b2f89299b43", + "name": "cfn-lint", + "sha256": "a697d296b925d69c0818963cc2bddaa1bb8f27a99a72eb31ed561769c32153b4", + "size": 3573642, + "subdir": "linux-64", + "timestamp": 1609352259006, + "version": "0.44.2" + }, + "cfn-lint-0.44.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "dd1cfaeb20dcc1d92d1a3a77cc45d9cd", + "name": "cfn-lint", + "sha256": "5d9965cddedc1bdbf25d9e1698ec8ccd6b78d8f944e861ff0da3d9dc12c3bf3d", + "size": 3570847, + "subdir": "linux-64", + "timestamp": 1609352234148, + "version": "0.44.2" + }, + "cfn-lint-0.44.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "0b72f099694d0f8d41323e7c10000344", + "name": "cfn-lint", + "sha256": "c1b61e4eb5404edbee1195f6d3860b7ddac755e38b57f74cedf9e5f7245eea16", + "size": 3574437, + "subdir": "linux-64", + "timestamp": 1609352232454, + "version": "0.44.2" + }, + "cfn-lint-0.44.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "cf0001e3c361ddca926e881ac6b1513f", + "name": "cfn-lint", + "sha256": "f307f65217569a6e1ac2d77fd28adff2400090786da18822a08614c8d1577494", + "size": 3615480, + "subdir": "linux-64", + "timestamp": 1610130043675, + "version": "0.44.3" + }, + "cfn-lint-0.44.3-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "af57992959ea9b7f23afd532b1ca4232", + "name": "cfn-lint", + "sha256": "6f2850a616f07a3160d3b796d306380135b08a6ad887b50fb8c0efeb50e357f1", + "size": 3623315, + "subdir": "linux-64", + "timestamp": 1610479855007, + "version": "0.44.3" + }, + "cfn-lint-0.44.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "0063fbb540efc9b218c1b69830c4740f", + "name": "cfn-lint", + "sha256": "597e92618ab82a9965c81da38091491ce07255f7d6c98ff8029adf4427b803b1", + "size": 3629199, + "subdir": "linux-64", + "timestamp": 1610129741443, + "version": "0.44.3" + }, + "cfn-lint-0.44.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "d26cce2715111cc484b91d490d5fd4c8", + "name": "cfn-lint", + "sha256": "2207bc9cb28f987ae3ac771178e34da02d8b0f3ad17f128fc116240ce8438389", + "size": 3633211, + "subdir": "linux-64", + "timestamp": 1610479825456, + "version": "0.44.3" + }, + "cfn-lint-0.44.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "831cbf20970ba08ebeeb6c87ac567cd8", + "name": "cfn-lint", + "sha256": "c80c3621f6aa531dda7d1ec6045b1973177afca35b98d8240101e97243b8e56a", + "size": 3621941, + "subdir": "linux-64", + "timestamp": 1610130038543, + "version": "0.44.3" + }, + "cfn-lint-0.44.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "61d279e2faa5ffd40a216bc4b4723804", + "name": "cfn-lint", + "sha256": "553d94d0157806293838e3d33971bb4b72e4ab2695553b50cba1cab3082cff49", + "size": 3623627, + "subdir": "linux-64", + "timestamp": 1610479814013, + "version": "0.44.3" + }, + "cfn-lint-0.44.5-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "fb2e6bdeffe12814909368db2ac03333", + "name": "cfn-lint", + "sha256": "62d182c8c901032a1e9f068a1bb72a9b6aacd03f47336353679e51443a2ee181", + "size": 3678647, + "subdir": "linux-64", + "timestamp": 1612240296295, + "version": "0.44.5" + }, + "cfn-lint-0.44.5-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "3ab74036326a1757d5ea0d76ab304782", + "name": "cfn-lint", + "sha256": "8b1a1aa0cb3e7b6c6bc47d368e3fc67196724ab23b4e6df6ec0ab5989a8c78f0", + "size": 3682119, + "subdir": "linux-64", + "timestamp": 1612240282965, + "version": "0.44.5" + }, + "cfn-lint-0.44.5-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "0781c5e7684a2a3d0b81a80581b9acac", + "name": "cfn-lint", + "sha256": "e6a6446c88ce202a489d61f13de7fe34d0e68a5b08cb71e039991faf98938252", + "size": 3683470, + "subdir": "linux-64", + "timestamp": 1612240292615, + "version": "0.44.5" + }, + "cfn-lint-0.44.5-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "f27650203298325be23a7ba855cb107c", + "name": "cfn-lint", + "sha256": "83e3f09736e3bce6b9fdb9b7fad454e0b10e9474c90c693bcd2481dd5327185b", + "size": 3676214, + "subdir": "linux-64", + "timestamp": 1613160895665, + "version": "0.44.5" + }, + "cfn-lint-0.44.7-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "5854cf68f57e12c63e5e987b1d22d305", + "name": "cfn-lint", + "sha256": "88add6aae4e2a84f4c81f5cdc68325e67ca0e738ad8585065b0085916c02f7ff", + "size": 3715246, + "subdir": "linux-64", + "timestamp": 1613246895405, + "version": "0.44.7" + }, + "cfn-lint-0.44.7-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "178c1f0e9136a21c81a7c07ce1f544a6", + "name": "cfn-lint", + "sha256": "b965ee007c5186d080ebc81da6f181895708f2ddfe529e5423725e69a9d1708e", + "size": 3715942, + "subdir": "linux-64", + "timestamp": 1613246550194, + "version": "0.44.7" + }, + "cfn-lint-0.44.7-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "6ef51c92e218568844bf3cd734baa201", + "name": "cfn-lint", + "sha256": "cd808d64c2c756b77d913ffccc2c37bd5ffbdf53fc702b84a520d2de29b2c0d9", + "size": 3710882, + "subdir": "linux-64", + "timestamp": 1613247054023, + "version": "0.44.7" + }, + "cfn-lint-0.44.7-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "6cb81782e92ecb125fc440687a3d9335", + "name": "cfn-lint", + "sha256": "92ab602b24e9afd5737377638afe2a767666a5daa3acb56898175e6bc2116895", + "size": 3712342, + "subdir": "linux-64", + "timestamp": 1613246894114, + "version": "0.44.7" + }, + "cfn-lint-0.45.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "650629befcbf7fdff7582cab96bd5abb", + "name": "cfn-lint", + "sha256": "b6ec81bc617812209fd8998f40facca476988b7c3c6a6156dec03efe24937af3", + "size": 4130856, + "subdir": "linux-64", + "timestamp": 1613501254475, + "version": "0.45.0" + }, + "cfn-lint-0.45.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "e613b946959f61263bddfb567d679d3e", + "name": "cfn-lint", + "sha256": "bd42603cd63704eaed3651e8f8db1db535f6e04916b2fd11605b50e41ccbb3cb", + "size": 4132012, + "subdir": "linux-64", + "timestamp": 1613501253139, + "version": "0.45.0" + }, + "cfn-lint-0.45.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "69c81cad5d856c959a4c9e04e7f3a836", + "name": "cfn-lint", + "sha256": "179a89734e6ed8f0c3042a9f10cdb34aaf4d0c2065b2bae4f3d869caed85463e", + "size": 4132405, + "subdir": "linux-64", + "timestamp": 1613500622025, + "version": "0.45.0" + }, + "cfn-lint-0.45.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "f0e1a63e430a52cde8a708a5e8fe7521", + "name": "cfn-lint", + "sha256": "1e0de820e81a175c7077b3ca3728b74a1a5a8ea1cf01ad817ac2a1672da8f9dc", + "size": 4131048, + "subdir": "linux-64", + "timestamp": 1613501269169, + "version": "0.45.0" + }, + "cfn-lint-0.46.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "3f794076906838a0fefcaed66da501a6", + "name": "cfn-lint", + "sha256": "e262c4e4f437abe63b511067d1a30354c27878012378801d9165963fbd99cc24", + "size": 4153881, + "subdir": "linux-64", + "timestamp": 1614361641259, + "version": "0.46.0" + }, + "cfn-lint-0.46.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "6e14cf11deedd53e48200508f37254e0", + "name": "cfn-lint", + "sha256": "b6b5e3d1b9477023ad4f36709a9b4d1261c2702c0389dfe317e543765e40e8f7", + "size": 4155208, + "subdir": "linux-64", + "timestamp": 1614361645901, + "version": "0.46.0" + }, + "cfn-lint-0.46.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "31f8b86a7d38e8715770376fb5f2a26a", + "name": "cfn-lint", + "sha256": "214a08a47efe6c20edb9e2602b430d01cbcd7175a752663cff1567cf2759e663", + "size": 4153213, + "subdir": "linux-64", + "timestamp": 1614361649803, + "version": "0.46.0" + }, + "cfn-lint-0.46.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "a65bb4293de67fafa49d02fbcb5dc610", + "name": "cfn-lint", + "sha256": "3eda7eb355da02b135c993b0d51986c40358ed8ca1f7b12c013c483c42daf580", + "size": 4146564, + "subdir": "linux-64", + "timestamp": 1614361549090, + "version": "0.46.0" + }, + "cfn-lint-0.47.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "93f4f9660bb910c2444a8e6e54c826d1", + "name": "cfn-lint", + "sha256": "f08c0e7b52a6dea0eda22e785fca2d2dd309f90bc30afd03085c5e469a95fcc6", + "size": 4176283, + "subdir": "linux-64", + "timestamp": 1615411597322, + "version": "0.47.0" + }, + "cfn-lint-0.47.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "f24e36e573e98add715980f3b31a107d", + "name": "cfn-lint", + "sha256": "2a928e1e59e2c24dffddd5920315de49943ea7f850aa98376aace9069f341cde", + "size": 4179948, + "subdir": "linux-64", + "timestamp": 1615411597328, + "version": "0.47.0" + }, + "cfn-lint-0.47.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "df458d6b61944909fe91c4f191881267", + "name": "cfn-lint", + "sha256": "31b43ed4d7fa75efc0371b842c7b67b54697e125be845bc011a5067a4052f04e", + "size": 4175860, + "subdir": "linux-64", + "timestamp": 1615411599477, + "version": "0.47.0" + }, + "cfn-lint-0.47.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "78895597dc4466ac3bd8b296c755868e", + "name": "cfn-lint", + "sha256": "c6b4c0eb4585104893af60442b5f3cd82f4d33a282c6f37a9939b91e47c6763c", + "size": 4174596, + "subdir": "linux-64", + "timestamp": 1615411602299, + "version": "0.47.0" + }, + "cfn-lint-0.47.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "85e0ab66815882bf2e1ce691b1e91cc1", + "name": "cfn-lint", + "sha256": "1a140b812eac3c0948c35530a6eca31702f42164902692bddb7a983f74298ef7", + "size": 4274294, + "subdir": "linux-64", + "timestamp": 1615486241644, + "version": "0.47.1" + }, + "cfn-lint-0.47.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "d784e8dea6b94223d9dfecf32b1c74d0", + "name": "cfn-lint", + "sha256": "fb39f2ec9fb85526aab99e29cad37d232d4438bc1016700afe84c86d75d2f875", + "size": 4272452, + "subdir": "linux-64", + "timestamp": 1615487859145, + "version": "0.47.1" + }, + "cfn-lint-0.47.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "5b33b4e9c4eb3f5f8238a12ee96167c0", + "name": "cfn-lint", + "sha256": "1714d00bc02c510531a46f3302aef0e465965acbabbbd8ccb3cf2694ac3115a0", + "size": 4274896, + "subdir": "linux-64", + "timestamp": 1615487866170, + "version": "0.47.1" + }, + "cfn-lint-0.47.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "48cfc12bfe5ddc374b0c9baafa1300d7", + "name": "cfn-lint", + "sha256": "a8ecf0dd683c6e1e736424a1096eb7e990b4d03974cbe4b82b28cff7b0d2b3da", + "size": 4274534, + "subdir": "linux-64", + "timestamp": 1615487878726, + "version": "0.47.1" + }, + "cfn-lint-0.47.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "4bf8455c6b8e521f5403d56328066d3d", + "name": "cfn-lint", + "sha256": "2e196b05ecee291a7c86ca6a65ecad8579332594aaadcdc60ca44ba22b61db3c", + "size": 4290159, + "subdir": "linux-64", + "timestamp": 1615661226310, + "version": "0.47.2" + }, + "cfn-lint-0.47.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "1e70ca2319a6a382203f5a224b600fd8", + "name": "cfn-lint", + "sha256": "d130e595ba597280d98f4f655a01f7edbd3d505e0450291bec574c76ce092996", + "size": 4293429, + "subdir": "linux-64", + "timestamp": 1615659528329, + "version": "0.47.2" + }, + "cfn-lint-0.47.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "4add76c824a082851f35795cb57169e9", + "name": "cfn-lint", + "sha256": "9d7574ef6c90950a3a7b54865bbb6e1aac04091e2045929e2c5086cb48a94ffd", + "size": 4297198, + "subdir": "linux-64", + "timestamp": 1615661233931, + "version": "0.47.2" + }, + "cfn-lint-0.47.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "19de3c9d751a5a1f58214a91107f7a1c", + "name": "cfn-lint", + "sha256": "047de1562de39e02a36fbd3601874a9a4daaca41712786dbeed0a27ef6aa402a", + "size": 4291239, + "subdir": "linux-64", + "timestamp": 1615660467885, + "version": "0.47.2" + }, + "cfn-lint-0.48.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "005aeadfcd8144cf6ebd69ac4ab46123", + "name": "cfn-lint", + "sha256": "6ff5c6da66cb5faf8c6978bab2b2d53ce9c81904d5cf0bf0329cdfc33754e2da", + "size": 4327491, + "subdir": "linux-64", + "timestamp": 1616441645597, + "version": "0.48.0" + }, + "cfn-lint-0.48.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "a5e870e8539187c3f4ecc985be849a2f", + "name": "cfn-lint", + "sha256": "854b2c529324e9baf08fb69d32f3c27eadc89f5cd9b3be79c211e555793fb234", + "size": 4320979, + "subdir": "linux-64", + "timestamp": 1616441638857, + "version": "0.48.0" + }, + "cfn-lint-0.48.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "1a999f8661500d84486e12d509983d9b", + "name": "cfn-lint", + "sha256": "f65dda14bc1c691b92ea8f41728d02098eb51aed6066bffb50719ededc7d06c0", + "size": 4328333, + "subdir": "linux-64", + "timestamp": 1616441475985, + "version": "0.48.0" + }, + "cfn-lint-0.48.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "cac439b426a05a5e81f67adbcbc9da5f", + "name": "cfn-lint", + "sha256": "d0e286b68cb8a36ff8cec87f5fd91f05b6ac45b5a4d81eacbd6084e830cf3584", + "size": 4327542, + "subdir": "linux-64", + "timestamp": 1616441475665, + "version": "0.48.0" + }, + "cfn-lint-0.48.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "b00e307686db5bc9085c0332b445dce2", + "name": "cfn-lint", + "sha256": "2f46530293dc1fcc285fc335da757da69c59198e53d235f0cdda4befe45225db", + "size": 4323837, + "subdir": "linux-64", + "timestamp": 1617119707345, + "version": "0.48.1" + }, + "cfn-lint-0.48.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "27478b8771f6990510d006d3d2a0556d", + "name": "cfn-lint", + "sha256": "5eacffe9489609541b6ce0b501cb64b8dbb79c2cb222198f7d631e2fc5c008b3", + "size": 4322113, + "subdir": "linux-64", + "timestamp": 1617117249297, + "version": "0.48.1" + }, + "cfn-lint-0.48.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "f55126539b31c4e275381ccc7800c1aa", + "name": "cfn-lint", + "sha256": "81f72e33d25783a77000247f47590cf468c042682c16ff56cb455d4707df008f", + "size": 4322675, + "subdir": "linux-64", + "timestamp": 1617119720651, + "version": "0.48.1" + }, + "cfn-lint-0.48.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "6717ae39467d003e724ee6614ea25c93", + "name": "cfn-lint", + "sha256": "b2a02bfdcb572db506840358780cf30df7fb5346bf07eafc9fa829ac66a72850", + "size": 4327115, + "subdir": "linux-64", + "timestamp": 1617119711118, + "version": "0.48.1" + }, + "cfn-lint-0.48.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "725675901f3f95e185f100738199d91a", + "name": "cfn-lint", + "sha256": "f6999d8d55c8e8381e40cf0ef8dd6b1a8c469b7c892867a683d0b8eafc0f1a39", + "size": 4467544, + "subdir": "linux-64", + "timestamp": 1617740770058, + "version": "0.48.2" + }, + "cfn-lint-0.48.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "2b309c69447ab43b9aea6fabb31510fc", + "name": "cfn-lint", + "sha256": "952c65ca6d49e2d741018644527e9ac410cf2beb0668a5819604336e1eb85b8b", + "size": 4463183, + "subdir": "linux-64", + "timestamp": 1617740766954, + "version": "0.48.2" + }, + "cfn-lint-0.48.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "3c32b902af78d437c9547cbadb0f1aff", + "name": "cfn-lint", + "sha256": "860c00cd851a2d22a4d32abd17a0ea0c8919047af48995cfab3fee91ac9b65e3", + "size": 4450071, + "subdir": "linux-64", + "timestamp": 1617740197732, + "version": "0.48.2" + }, + "cfn-lint-0.48.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "0df2537023060dee1529e069359f33a7", + "name": "cfn-lint", + "sha256": "582241ee13ff8140d65eb0898ecc5d8b7ec7afbcf02a21f685f80cf7480129e4", + "size": 4459338, + "subdir": "linux-64", + "timestamp": 1617740767975, + "version": "0.48.2" + }, + "cfn-lint-0.48.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.34.0", + "importlib_resources >=1.4,<4", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "f8a81d9671d2b49ff5dd41fafe8ce477", + "name": "cfn-lint", + "sha256": "c179dae6f3610bc8db2fac55d7b3dff50f1dd4eac8e53d6067b9e51434036ddf", + "size": 4483707, + "subdir": "linux-64", + "timestamp": 1618856211868, + "version": "0.48.3" + }, + "cfn-lint-0.48.3-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "bf2bf7eb408bf52a82c1d685f1b48617", + "name": "cfn-lint", + "sha256": "cee0cb5397b9aa7e6f75fcf7e05ff15a874744a6894a5654a43be0e06f758910", + "size": 4483716, + "subdir": "linux-64", + "timestamp": 1618607863234, + "version": "0.48.3" + }, + "cfn-lint-0.48.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.34.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "bb2f9fa5a46497cb6449ec48b631b56f", + "name": "cfn-lint", + "sha256": "0cd9fe0f1a1f4063cec6cc8a57ef13462a05e914a85c6a979cc95863da09bad4", + "size": 4486587, + "subdir": "linux-64", + "timestamp": 1618856202186, + "version": "0.48.3" + }, + "cfn-lint-0.48.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "1df20cf90c36ceaec6220ffb8ce6f615", + "name": "cfn-lint", + "sha256": "c176d978f9e32c2fafa46f7188deef3729a3ef80792f668112dec926b3273bb6", + "size": 4486099, + "subdir": "linux-64", + "timestamp": 1618607848978, + "version": "0.48.3" + }, + "cfn-lint-0.48.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.34.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "c30a813b528741fa67009ea3099c98ac", + "name": "cfn-lint", + "sha256": "a26b0f7b9d033c40764bd1ed81b65873739dcdd26d58012de5bf468ec50451d3", + "size": 4478805, + "subdir": "linux-64", + "timestamp": 1618855876450, + "version": "0.48.3" + }, + "cfn-lint-0.48.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "882897f496f6dbfcea6553997499f15e", + "name": "cfn-lint", + "sha256": "6e75b3b763bfdf8ec61db79afdb31d212da14b1c5d782b9b6d5807c3ee650aba", + "size": 4495153, + "subdir": "linux-64", + "timestamp": 1618607855166, + "version": "0.48.3" + }, + "cfn-lint-0.48.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.34.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "2b6f48ddf89337a64372f647d55f7be5", + "name": "cfn-lint", + "sha256": "7ac21e1ef1ebb6903f4b9c969312905e80a2d1924830cd7fe38fb113e5e35b08", + "size": 4500902, + "subdir": "linux-64", + "timestamp": 1618856319759, + "version": "0.48.3" + }, + "cfn-lint-0.48.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "35171aa6fad89f2e26771c8f2f0711e2", + "name": "cfn-lint", + "sha256": "f32ebf2d3424847fde3f1d6f8b5b003e58459780d9139b5cfa08453f27b7e039", + "size": 4483344, + "subdir": "linux-64", + "timestamp": 1618607505734, + "version": "0.48.3" + }, + "cfn-lint-0.49.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "importlib_resources >=1.4,<4", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "668c93492a16c51187a02bf579382293", + "name": "cfn-lint", + "sha256": "12dc8d903583960df41be1811871e01f761e48e070d5c6517614ea3b8efaaa83", + "size": 4518708, + "subdir": "linux-64", + "timestamp": 1619605965213, + "version": "0.49.0" + }, + "cfn-lint-0.49.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "5e65c93551ca97bf678a89fb5f6d9d12", + "name": "cfn-lint", + "sha256": "159c03a3eb4b7dcead8ad2e6ad7e721ad8235c577a8e8b725f0bbe807cbeb7fa", + "size": 4515448, + "subdir": "linux-64", + "timestamp": 1619605998263, + "version": "0.49.0" + }, + "cfn-lint-0.49.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "29e25f21ba842dbace02d671fb91dbac", + "name": "cfn-lint", + "sha256": "237d31c49cc74832ad44e9a4478cf0d7694965559c8cddb790c68423b8aeb2db", + "size": 4512251, + "subdir": "linux-64", + "timestamp": 1619606001037, + "version": "0.49.0" + }, + "cfn-lint-0.49.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "be862a5639428411be17baba4f617b87", + "name": "cfn-lint", + "sha256": "81344befd89ba9c0e9d071b8a8e9b084775137684fc02e4c0a7c64febc97d871", + "size": 4524353, + "subdir": "linux-64", + "timestamp": 1619605999315, + "version": "0.49.0" + }, + "cfn-lint-0.49.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "importlib_resources >=1.4,<4", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "a35c19833437f3d74c0b135132866b66", + "name": "cfn-lint", + "sha256": "bc7b100ccc1745e318f5d01a41dbcc28d7028065a2d3712a81719c6d578d15b5", + "size": 4612121, + "subdir": "linux-64", + "timestamp": 1620710207314, + "version": "0.49.1" + }, + "cfn-lint-0.49.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "162c259ff7929aa4b03cbd7e3be0d2e5", + "name": "cfn-lint", + "sha256": "8d429a20f83ba11347a6a39fccc48c6e2c11dfe015a26c7e89f2f93640f718de", + "size": 4613478, + "subdir": "linux-64", + "timestamp": 1620710204881, + "version": "0.49.1" + }, + "cfn-lint-0.49.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "9e6f409392e1605cb8f8ad61e4b09cef", + "name": "cfn-lint", + "sha256": "90b92020e63b0aa5f53d12172418ef6d1c159d8735d138a747aad7c69e60afbd", + "size": 4609716, + "subdir": "linux-64", + "timestamp": 1620710197136, + "version": "0.49.1" + }, + "cfn-lint-0.49.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "7a8b5e08d103137b603839719a0522ce", + "name": "cfn-lint", + "sha256": "ebdafc6e844c08e340ac2bcfe714d1eb49871a01173dc23d19182d1088fdb223", + "size": 4607972, + "subdir": "linux-64", + "timestamp": 1620710121772, + "version": "0.49.1" + }, + "cfn-lint-0.49.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "importlib_resources >=1.4,<4", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "0e464eac74b48950416c4440cf0066ad", + "name": "cfn-lint", + "sha256": "e4230c7000e8e0239741302e634d085b5fa26a3fe9ea8d4accfe6aeeb97f867c", + "size": 4673844, + "subdir": "linux-64", + "timestamp": 1621427026316, + "version": "0.49.2" + }, + "cfn-lint-0.49.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "ada1a9acf627032c38f0172a13ca0342", + "name": "cfn-lint", + "sha256": "ded884872c33fd3b8ca18875c27e17fc2ac0a5706b424b67a12fe2a9835a1dcb", + "size": 4678355, + "subdir": "linux-64", + "timestamp": 1621431664075, + "version": "0.49.2" + }, + "cfn-lint-0.49.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "08108b917965f9bbd2d5078e2790a526", + "name": "cfn-lint", + "sha256": "5aa8650fcf3a5651caa3d6f9f4cd2f0e57a10a39e00815b547d1b4324eda0a3f", + "size": 4683263, + "subdir": "linux-64", + "timestamp": 1621431658198, + "version": "0.49.2" + }, + "cfn-lint-0.49.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "f929f6328461e9e183666ced34452d78", + "name": "cfn-lint", + "sha256": "ba5f6114715f382143f4f8193d536eb9d0bf476b0b840bb9b471272aac8c54d9", + "size": 4682826, + "subdir": "linux-64", + "timestamp": 1621431655141, + "version": "0.49.2" + }, + "cfn-lint-0.50.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "importlib_resources >=1.4,<4", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "d0352e14be71fe62506cf5b806110c6a", + "name": "cfn-lint", + "sha256": "0e325f417b8a8687741dd9def77c7caf099509f5fb55f8f12953595c7eaa77f9", + "size": 4707862, + "subdir": "linux-64", + "timestamp": 1622824518816, + "version": "0.50.0" + }, + "cfn-lint-0.50.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "2c39c2a73f04d92573c434752e5db27c", + "name": "cfn-lint", + "sha256": "c27f05275de1ba81391de8140fdac8c2a8f40dbec823bad40e75d9709fd0b7dd", + "size": 4719171, + "subdir": "linux-64", + "timestamp": 1622825024681, + "version": "0.50.0" + }, + "cfn-lint-0.50.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "b2bc1aec7dc582b4bda09d952f3c5857", + "name": "cfn-lint", + "sha256": "db6d427b4b11140de135fe8255d293728cc20864cd9a75e43bf7b28e1bd56a7a", + "size": 4714705, + "subdir": "linux-64", + "timestamp": 1622819701092, + "version": "0.50.0" + }, + "cfn-lint-0.50.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "760a24832f6b707383c8bb9290816d9e", + "name": "cfn-lint", + "sha256": "3f7aea434ef874fef0c8e8492c5c0ff5c09d22dc441746be78a515c8a31b0e8d", + "size": 4718073, + "subdir": "linux-64", + "timestamp": 1622825018153, + "version": "0.50.0" + }, + "cfn-lint-0.52.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.36.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.10,<3.11.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "0c104fcaae6d03f1d187f061cce7101f", + "name": "cfn-lint", + "sha256": "60041d67df55b9f0b07067ec22706e87811383b3efc6f4b24b1fbc94fa2cffc5", + "size": 4838696, + "subdir": "linux-64", + "timestamp": 1640803855222, + "version": "0.52.0" + }, + "cfn-lint-0.52.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.36.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.11,<3.12.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "7b1e2b14e3d71256eea378da7af1cea4", + "name": "cfn-lint", + "sha256": "fab0da0acd0556373f736218d791f9b669aba68feeae1135eeead8995361b066", + "size": 4933233, + "subdir": "linux-64", + "timestamp": 1676843518024, + "version": "0.52.0" + }, + "cfn-lint-0.52.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.36.0", + "importlib_resources >=1.4,<4", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "ff33007dfcb70f7ba8033c2b44e12235", + "name": "cfn-lint", + "sha256": "34592a2e4a5f2fdcada518086c2434ce20e0520ebed3a367e0a6e4c0ee30387c", + "size": 4838971, + "subdir": "linux-64", + "timestamp": 1625154340520, + "version": "0.52.0" + }, + "cfn-lint-0.52.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.36.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "c25e558c6f03afd490153e07c9c490ed", + "name": "cfn-lint", + "sha256": "14d2f2ede491f61adf876dc0324d924793efacd45d7eba6d161676d9bb857c29", + "size": 4826425, + "subdir": "linux-64", + "timestamp": 1625147807451, + "version": "0.52.0" + }, + "cfn-lint-0.52.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.36.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "5158f29ec28a005a65a68027fdb2ba55", + "name": "cfn-lint", + "sha256": "97e9090ae274e100dea18ab157c4b586bd66b886bdc6ec9e57769cae93156db9", + "size": 4825282, + "subdir": "linux-64", + "timestamp": 1625154312199, + "version": "0.52.0" + }, + "cfn-lint-0.52.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.36.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "4c7a7c2ea5a25171b74afb666d143581", + "name": "cfn-lint", + "sha256": "0e6da95f222b4fed54c367d994277d6a8d350e1cbb334a07d44c23ec5835887b", + "size": 4826749, + "subdir": "linux-64", + "timestamp": 1625154325370, + "version": "0.52.0" + }, + "cftime-1.0.0b1-py27h035aef0_0.tar.bz2": { + "build": "py27h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "81be41a2d7ab6cf110c9cf972590c753", + "name": "cftime", + "sha256": "294cb800b97a70fbc01d18cce7e453aba0278830f24c854cc47a86805d053b5e", + "size": 251205, + "subdir": "linux-64", + "timestamp": 1530901725246, + "version": "1.0.0b1" + }, + "cftime-1.0.0b1-py27h3010b51_0.tar.bz2": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d8ef363a7c0f4e0b41566c953b0ea7be", + "name": "cftime", + "sha256": "de131fbb5c81a7bbb44827121a2116c9cbca08e93b9d86edaac892cf29119e15", + "size": 250625, + "subdir": "linux-64", + "timestamp": 1526227679757, + "version": "1.0.0b1" + }, + "cftime-1.0.0b1-py35h3010b51_0.tar.bz2": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "6066a516081344b470a3660dba37d746", + "name": "cftime", + "sha256": "908d8adf5d50d9ca1c9ffebaf419c4cac8cbdd5c36bfdb6a842a002b6f02f5b5", + "size": 252284, + "subdir": "linux-64", + "timestamp": 1526227678116, + "version": "1.0.0b1" + }, + "cftime-1.0.0b1-py36h035aef0_0.tar.bz2": { + "build": "py36h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e87e54ffb367b053922bdd633d3e9d01", + "name": "cftime", + "sha256": "605bac7415bde59efc20601e3627e0a1e4b3431ec52ae5b3a0322920582881ad", + "size": 266301, + "subdir": "linux-64", + "timestamp": 1530901655774, + "version": "1.0.0b1" + }, + "cftime-1.0.0b1-py36h3010b51_0.tar.bz2": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "55fd0dc7d8f97454d8005d30124fd2e7", + "name": "cftime", + "sha256": "97b2c916932b6e3f688e8421e4da775f0bf38bfec0b77de916cbcca4f394fd7c", + "size": 266441, + "subdir": "linux-64", + "timestamp": 1526227651020, + "version": "1.0.0b1" + }, + "cftime-1.0.0b1-py37h035aef0_0.tar.bz2": { + "build": "py37h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "db6c5c80d8c83c9af9717db0e9bd2fca", + "name": "cftime", + "sha256": "226c7752304dc7775401d08240f89b8f0c0c8be24aa6e6a24285dfd44830984c", + "size": 263988, + "subdir": "linux-64", + "timestamp": 1530901578989, + "version": "1.0.0b1" + }, + "cftime-1.0.2.1-py27hdd07704_0.tar.bz2": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "132ececb054d2edd65d23e9baa8dc2b2", + "name": "cftime", + "sha256": "75871ce9fde58a2674de4bd3c4d89c9e5e930a0f66a6d193e68465cf74602cc9", + "size": 282637, + "subdir": "linux-64", + "timestamp": 1541017009095, + "version": "1.0.2.1" + }, + "cftime-1.0.2.1-py36hdd07704_0.tar.bz2": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1a0fe49d000b2afafe423cb1b4ab3496", + "name": "cftime", + "sha256": "bb6d69f363248e72cba1742693f3a7a09bfe807b775f65f6188c0daad13b7b86", + "size": 305688, + "subdir": "linux-64", + "timestamp": 1541017146693, + "version": "1.0.2.1" + }, + "cftime-1.0.2.1-py37hdd07704_0.tar.bz2": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "749c29f7115c2dfa35e70f6babf478da", + "name": "cftime", + "sha256": "f39fc44597998b16e10a108aa223fbb215746dc0f0732572f0fcc15bb01a468e", + "size": 302515, + "subdir": "linux-64", + "timestamp": 1541016960929, + "version": "1.0.2.1" + }, + "cftime-1.0.3.4-py27hdd07704_0.tar.bz2": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c9f166900aa71eeabb24350c175e0107", + "name": "cftime", + "sha256": "65615afccad607999b2ec106c4c1805b7607cb5932e029893ce5fceba6b9c8fe", + "size": 289162, + "subdir": "linux-64", + "timestamp": 1545080497228, + "version": "1.0.3.4" + }, + "cftime-1.0.3.4-py27hdd07704_1.tar.bz2": { + "build": "py27hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT and GPL", + "md5": "84c90d5304f09b164188ad70e72cd353", + "name": "cftime", + "sha256": "f3ae4921e02de9da7edcbe0f85dfa1ad1659aa4dd37ff69632968adbe8ebc4a0", + "size": 295221, + "subdir": "linux-64", + "timestamp": 1559233539694, + "version": "1.0.3.4" + }, + "cftime-1.0.3.4-py27hdd07704_1001.tar.bz2": { + "build": "py27hdd07704_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT and GPL", + "md5": "b8a4860124fd26140a91049ab474805d", + "name": "cftime", + "sha256": "9ff7b1d325c7cbe34f70ea8d55d00da22eab5a488363e3d374e06338df615290", + "size": 297153, + "subdir": "linux-64", + "timestamp": 1564159297759, + "version": "1.0.3.4" + }, + "cftime-1.0.3.4-py36hdd07704_0.tar.bz2": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8dfe5bb7cba5d4737d1fadc01a26a0c1", + "name": "cftime", + "sha256": "95b107212d8fd245425f53006b123fa4465705519a8592a9ea6086adcdaec653", + "size": 311074, + "subdir": "linux-64", + "timestamp": 1545080479868, + "version": "1.0.3.4" + }, + "cftime-1.0.3.4-py36hdd07704_1.tar.bz2": { + "build": "py36hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT and GPL", + "md5": "fecc68cd8dda00a821e62ddd8c6984e9", + "name": "cftime", + "sha256": "84bc99bb7923b52807e7685298573d63ca433268cbf328fc1389dc2f074acfc4", + "size": 317844, + "subdir": "linux-64", + "timestamp": 1559233520455, + "version": "1.0.3.4" + }, + "cftime-1.0.3.4-py36hdd07704_1001.tar.bz2": { + "build": "py36hdd07704_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT and GPL", + "md5": "245c752196b392afb2b0a6734f26fb36", + "name": "cftime", + "sha256": "c22bf4a08792ae9b7ac2b445b15de03b7dbd9d652d7bc1855446fef4f9bff4a0", + "size": 325126, + "subdir": "linux-64", + "timestamp": 1564159309618, + "version": "1.0.3.4" + }, + "cftime-1.0.3.4-py37hdd07704_0.tar.bz2": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ff9c048483320d92e3a87589eab4bc93", + "name": "cftime", + "sha256": "823821fd5cde72b33c849de1e0ae2b385352d4ef362a51ff8f4c3b5e6a7d6e0b", + "size": 307520, + "subdir": "linux-64", + "timestamp": 1545080547106, + "version": "1.0.3.4" + }, + "cftime-1.0.3.4-py37hdd07704_1.tar.bz2": { + "build": "py37hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT and GPL", + "md5": "578a9fafb8cb594e139c25021cbbc0f0", + "name": "cftime", + "sha256": "aeca98ec03b24ea09ba6f65ce4b96de35b22e653f41816630398e4dcc6117f5a", + "size": 314408, + "subdir": "linux-64", + "timestamp": 1559233482448, + "version": "1.0.3.4" + }, + "cftime-1.0.3.4-py37hdd07704_1001.tar.bz2": { + "build": "py37hdd07704_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT and GPL", + "md5": "75890a67c2eb7e6478f48795a9817f4d", + "name": "cftime", + "sha256": "b00cb54101997531d4bad365562d2174dd7fbc25f1afde17234abc942bd6e82c", + "size": 317851, + "subdir": "linux-64", + "timestamp": 1564159270984, + "version": "1.0.3.4" + }, + "cftime-1.0.4.2-py27hdd07704_0.tar.bz2": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT and GPL", + "md5": "b248f3db077dd6182711fa3fed0ecf73", + "name": "cftime", + "sha256": "39baa13a0d4dcbd39543626088a4d870c0765f30d562b12dd02995d460d25512", + "size": 300217, + "subdir": "linux-64", + "timestamp": 1573081710466, + "version": "1.0.4.2" + }, + "cftime-1.0.4.2-py36hdd07704_0.tar.bz2": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT and GPL", + "md5": "3367601fcd272ffa76bcb74a8e6906b1", + "name": "cftime", + "sha256": "d008d093726f20322539bbaa72319941e7105d269840d96b3e28bc7c6da7d8fc", + "size": 329931, + "subdir": "linux-64", + "timestamp": 1573081275666, + "version": "1.0.4.2" + }, + "cftime-1.0.4.2-py37hdd07704_0.tar.bz2": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT and GPL", + "md5": "65fcb8cb598965b5a9410813f70d1ddb", + "name": "cftime", + "sha256": "2d1d7fe3e5b71e02511b58bfe80b8e01f71c07bacd67cafd82d488bbdbf61bb4", + "size": 321401, + "subdir": "linux-64", + "timestamp": 1573081239601, + "version": "1.0.4.2" + }, + "cftime-1.0.4.2-py38hdd07704_0.tar.bz2": { + "build": "py38hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT and GPL", + "md5": "5e372323abea97af393ca1255d2f0b86", + "name": "cftime", + "sha256": "dc8cdf5999dac069d36a7b7dd5c7f4a9b0797f797de6dd2ecae9fcfb0f5c9f20", + "size": 338950, + "subdir": "linux-64", + "timestamp": 1573081229298, + "version": "1.0.4.2" + }, + "cftime-1.1.1.1-py36heb32a55_0.tar.bz2": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT and GPL-3.0", + "md5": "fb6a6b9ff4a9d127b7ff57475ce59655", + "name": "cftime", + "sha256": "fcf4eef1a1c074bd35f26dafafdf3ecf34bd2bfea7670488c94ea60872d1ef9c", + "size": 335349, + "subdir": "linux-64", + "timestamp": 1585044655316, + "version": "1.1.1.1" + }, + "cftime-1.1.1.1-py37heb32a55_0.tar.bz2": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT and GPL-3.0", + "md5": "becc0137ba287ede343856016218267b", + "name": "cftime", + "sha256": "cec879a562292b4726ae4bcde1bb7e82dabf87baf72f0966233b3bed1456327b", + "size": 328438, + "subdir": "linux-64", + "timestamp": 1585044613102, + "version": "1.1.1.1" + }, + "cftime-1.1.1.1-py38heb32a55_0.tar.bz2": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT and GPL-3.0", + "md5": "8359fee12141cc997815aef5f80f59d4", + "name": "cftime", + "sha256": "70fcd953b220fe0d66c7b8b0811823b0f23ddbde72cf5cfdd28fc0131e80f4f9", + "size": 352828, + "subdir": "linux-64", + "timestamp": 1585044630018, + "version": "1.1.1.1" + }, + "cftime-1.1.1.2-py36h035aef0_0.tar.bz2": { + "build": "py36h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT and GPL-3.0", + "md5": "ef68dc72ebf7018a95488e1634b7bd6c", + "name": "cftime", + "sha256": "ebe6217ec538b5bf4bb84b8107216a4fb0e5401679ac111ccc952f9818320860", + "size": 331197, + "subdir": "linux-64", + "timestamp": 1586838345001, + "version": "1.1.1.2" + }, + "cftime-1.1.2-py36heb32a55_0.tar.bz2": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT and GPL-3.0", + "md5": "f0d46b7003369003eb152f2c503ffbfd", + "name": "cftime", + "sha256": "fc64debbc780e1236748b0b0027484684a738a06c4c5632501c9fbb8ad730bb8", + "size": 324342, + "subdir": "linux-64", + "timestamp": 1588595322459, + "version": "1.1.2" + }, + "cftime-1.1.2-py37heb32a55_0.tar.bz2": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT and GPL-3.0", + "md5": "0e37b0a356f11c660f472ae64f92ed81", + "name": "cftime", + "sha256": "fe68da1e762cb57664d64a96b9799e11be361c3bd6941e1ba8400f7d4d9cd096", + "size": 327172, + "subdir": "linux-64", + "timestamp": 1588595263403, + "version": "1.1.2" + }, + "cftime-1.1.2-py38heb32a55_0.tar.bz2": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT and GPL-3.0", + "md5": "e2aa046dac4eaed9e5eed50649a912d7", + "name": "cftime", + "sha256": "3149952a852955538cf17da2fe1c066570e4b5692aa248c5d13c9025cd51efa3", + "size": 338868, + "subdir": "linux-64", + "timestamp": 1588595239135, + "version": "1.1.2" + }, + "cftime-1.2.1-py36heb32a55_0.tar.bz2": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "8a21bd93e7f0e7486663dce82f97366b", + "name": "cftime", + "sha256": "46b074d179407689178a0175fb9b8fe180b4d236008bd28bdff0b6d1ec1095b5", + "size": 290405, + "subdir": "linux-64", + "timestamp": 1595379809144, + "version": "1.2.1" + }, + "cftime-1.2.1-py37heb32a55_0.tar.bz2": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "50b2ff79380a7a96e922993c55f78984", + "name": "cftime", + "sha256": "85cd0ddd6e1a6b7728a7086c32ece2f3b6899a623438af5ede3dee941a1979c6", + "size": 288825, + "subdir": "linux-64", + "timestamp": 1595379790816, + "version": "1.2.1" + }, + "cftime-1.2.1-py38heb32a55_0.tar.bz2": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "98819d1c563b99acbffa48df20a970af", + "name": "cftime", + "sha256": "48d0bb94cd169d92cf98b4531b5c4cee8bac4a0ec058b076d07099ff21f47ed6", + "size": 313198, + "subdir": "linux-64", + "timestamp": 1595379809750, + "version": "1.2.1" + }, + "cftime-1.3.0-py36h6323ea4_0.tar.bz2": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "57cfda37bbd4a56906a875a6dd865ac4", + "name": "cftime", + "sha256": "3dffa6213ed15a359a4970ee844115d471f5dad7ecb346e866bb8ee6ef894c17", + "size": 296302, + "subdir": "linux-64", + "timestamp": 1605995866554, + "version": "1.3.0" + }, + "cftime-1.3.0-py37h6323ea4_0.tar.bz2": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "4f9fa222638d11402be013a9c546e44f", + "name": "cftime", + "sha256": "0bade76732b178c9c444b5b22040e010d367d014050be8ad6d3a291b8102f3a4", + "size": 297737, + "subdir": "linux-64", + "timestamp": 1605995874870, + "version": "1.3.0" + }, + "cftime-1.3.0-py38h6323ea4_0.tar.bz2": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "cb6d038df3c4d234552d2221578b14bc", + "name": "cftime", + "sha256": "6b4aef95f02fb9f69740e42ae899f5192c8656cdf93c1ba9cbe3c80466534303", + "size": 316458, + "subdir": "linux-64", + "timestamp": 1605995820846, + "version": "1.3.0" + }, + "cftime-1.3.1-py36h6323ea4_0.tar.bz2": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "ebf41c5bedb112b63b204206a83c080c", + "name": "cftime", + "sha256": "20a06489b07c6e65062af5f8efc66071ac6cf0e1a3effd04d8b6ba47a88ecc2a", + "size": 296813, + "subdir": "linux-64", + "timestamp": 1610908485058, + "version": "1.3.1" + }, + "cftime-1.3.1-py37h6323ea4_0.tar.bz2": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "3b70fb7ad9313d59e8b7193598fb3b48", + "name": "cftime", + "sha256": "a02d7c9f8e8e54f91a74d1596df03a883393aba930f9f55de2871b8467f61ff0", + "size": 300522, + "subdir": "linux-64", + "timestamp": 1610907812422, + "version": "1.3.1" + }, + "cftime-1.3.1-py38h6323ea4_0.tar.bz2": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "005824033c26ec25aec2c763cb2976ef", + "name": "cftime", + "sha256": "9f443e517efcd5a71a4a9bfd983fb11e9ca31955c5e944624f6d6e7344f3a265", + "size": 319546, + "subdir": "linux-64", + "timestamp": 1610908496915, + "version": "1.3.1" + }, + "cftime-1.3.1-py39h6323ea4_0.tar.bz2": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "d9a5ff8b8da1a2f085708c7d939b936e", + "name": "cftime", + "sha256": "e9907057134bc134d34f7a42052b6fda76e11877b4ea138fe47ad56050ad1cc9", + "size": 317924, + "subdir": "linux-64", + "timestamp": 1610908507161, + "version": "1.3.1" + }, + "cftime-1.4.1-py36h6323ea4_0.tar.bz2": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9b8ed90dae691da60c8a7fa680797fa6", + "name": "cftime", + "sha256": "c4c1b6b84a778d7eae7268457c6f9672ae056f5cc31349f6212bb8673ad5f0aa", + "size": 283726, + "subdir": "linux-64", + "timestamp": 1613248322706, + "version": "1.4.1" + }, + "cftime-1.4.1-py37h6323ea4_0.tar.bz2": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "0d6f01b3435ee3c95409e53a5f0ded00", + "name": "cftime", + "sha256": "54726210b3f475ed41b2704550b689b18f7f45392514863593a6ecab66bf7c68", + "size": 281015, + "subdir": "linux-64", + "timestamp": 1613248322915, + "version": "1.4.1" + }, + "cftime-1.4.1-py38h6323ea4_0.tar.bz2": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "d963ce357d03541d16ba533eeb84f399", + "name": "cftime", + "sha256": "f640af29f436db91cc19c1cf9a29f53784fa9979e53cbaa0611ce26b08bee250", + "size": 299907, + "subdir": "linux-64", + "timestamp": 1613248325487, + "version": "1.4.1" + }, + "cftime-1.4.1-py39h6323ea4_0.tar.bz2": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "d822b60a9817327c1f4ed269338673b3", + "name": "cftime", + "sha256": "c0612ddb529e303e3db822cc4d41cb1bb628644da111a4108652e8cb51388342", + "size": 300269, + "subdir": "linux-64", + "timestamp": 1613248041365, + "version": "1.4.1" + }, + "cftime-1.5.0-py36h6323ea4_0.tar.bz2": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "cfd31dc070eada27597425f5483557eb", + "name": "cftime", + "sha256": "b6aafc0aa53aad25e42daec997892f2b8109249329f37c3eb18aad1bfb62dbb2", + "size": 204865, + "subdir": "linux-64", + "timestamp": 1621828261633, + "version": "1.5.0" + }, + "cftime-1.5.0-py37h6323ea4_0.tar.bz2": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "23303771fa4a7bfb392d6fb29cb4a75b", + "name": "cftime", + "sha256": "fd6d716bf9e289d0f59652277c6e18b5d787a54d64223591e95a55376ae344b2", + "size": 202983, + "subdir": "linux-64", + "timestamp": 1621823425231, + "version": "1.5.0" + }, + "cftime-1.5.0-py38h6323ea4_0.tar.bz2": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "c8a79d88f208442c72b25a49e3938b44", + "name": "cftime", + "sha256": "edbe5d5e1ac2d2f399de4ee3127843858f4e182b6698a23c613a39654c200d71", + "size": 216113, + "subdir": "linux-64", + "timestamp": 1621828277925, + "version": "1.5.0" + }, + "cftime-1.5.0-py39h6323ea4_0.tar.bz2": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "a797bcc93668a7c1d59da66da840ab75", + "name": "cftime", + "sha256": "12f45022adc05fd48c8b0987cc153518b63e07bd58ea07de36ef6cf6624505a1", + "size": 217146, + "subdir": "linux-64", + "timestamp": 1621823422463, + "version": "1.5.0" + }, + "cftime-1.5.1.1-py310h9102076_0.tar.bz2": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "145f43b0b082c7506ec9033fb2334582", + "name": "cftime", + "sha256": "d225a6ae000055bb16acfc2cc5402dd5bd92509340cd722921c084606cab7f9e", + "size": 783357, + "subdir": "linux-64", + "timestamp": 1640788956666, + "version": "1.5.1.1" + }, + "cftime-1.5.1.1-py311hbed6279_0.tar.bz2": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c95c3347b69f1a9e260f06a054a3a5c", + "name": "cftime", + "sha256": "f1d5dc55b1f1f0635b27858212267e01d4b5b63a2e3aba4d223fb0c05d1e5bf9", + "size": 212794, + "subdir": "linux-64", + "timestamp": 1676830273637, + "version": "1.5.1.1" + }, + "cftime-1.5.1.1-py37hce1f21e_0.tar.bz2": { + "build": "py37hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77f7f38298cabeeb1fa6c691608b16a3", + "name": "cftime", + "sha256": "b6d273f104ea61c56218db79408f1d532e355191fdc3c240f02c652e6bd94d0c", + "size": 208089, + "subdir": "linux-64", + "timestamp": 1638345354687, + "version": "1.5.1.1" + }, + "cftime-1.5.1.1-py38hce1f21e_0.tar.bz2": { + "build": "py38hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b05f4834cc6556cdb21f0046fa24f033", + "name": "cftime", + "sha256": "393f214c11ae1468b3ff1b594a3c89c9ffa02d17d54487dae1ba71e8ab9e77fa", + "size": 221505, + "subdir": "linux-64", + "timestamp": 1638357968908, + "version": "1.5.1.1" + }, + "cftime-1.5.1.1-py39hce1f21e_0.tar.bz2": { + "build": "py39hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "452dc7bf78c0d371902368c2cf9b806f", + "name": "cftime", + "sha256": "4a31ce1fca653ff6ca7710629e4f95a523f639acc0ca6fa8c7c12dc9c53f3f83", + "size": 222434, + "subdir": "linux-64", + "timestamp": 1638358542039, + "version": "1.5.1.1" + }, + "cftime-1.6.2-py310ha9d4c09_0.tar.bz2": { + "build": "py310ha9d4c09_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d5c57533f6d4ee2e9502e5f4a2f1933", + "name": "cftime", + "sha256": "33c64c25ccddc93f7bdb38acf863839a323ac215a3d0a0190ecb2c460905d667", + "size": 248445, + "subdir": "linux-64", + "timestamp": 1678830501437, + "version": "1.6.2" + }, + "cftime-1.6.2-py311hbed6279_0.tar.bz2": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a88a08c5a9bb08c528fd25e84eb8055b", + "name": "cftime", + "sha256": "c9ef620859a8501e4d098dd1454fd521395acc668ceb98a47cdf886132fbebc0", + "size": 252968, + "subdir": "linux-64", + "timestamp": 1679335541002, + "version": "1.6.2" + }, + "cftime-1.6.2-py38h7deecbd_0.tar.bz2": { + "build": "py38h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "59b2084405f6ee70f324a735182f792b", + "name": "cftime", + "sha256": "76dba342f3dd12781ee3b069325de90df2fc2f412d24cb5388376bfbaa727321", + "size": 266539, + "subdir": "linux-64", + "timestamp": 1678830575912, + "version": "1.6.2" + }, + "cftime-1.6.2-py39h7deecbd_0.tar.bz2": { + "build": "py39h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8b3ae47da49d612fec7ac202e31d9815", + "name": "cftime", + "sha256": "2930464506f2aeaae38dbf0197e24b09391986fd01c903a50c0083e260515478", + "size": 258295, + "subdir": "linux-64", + "timestamp": 1678830429451, + "version": "1.6.2" + }, + "cgroupspy-0.2.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d8305ad507a11ea41d9638ce63b8d9c8", + "name": "cgroupspy", + "sha256": "35f3ec7553f77fcf1013d88f9b9d0b6267f106753a99d5dcf9fb4f105f3900d0", + "size": 29859, + "subdir": "linux-64", + "timestamp": 1659858273842, + "version": "0.2.2" + }, + "cgroupspy-0.2.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "edba3e2806ab966c2155e1f11928eff5", + "name": "cgroupspy", + "sha256": "3847a26324ffd69cc53eaf470fc89fcd8d93da42fc4d34adbb6fa58c8677b7d2", + "size": 39299, + "subdir": "linux-64", + "timestamp": 1676847288384, + "version": "0.2.2" + }, + "cgroupspy-0.2.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e3d80715b7957f7a6bfd5ad7925a5ec9", + "name": "cgroupspy", + "sha256": "6f1a1cfc7f755b948679772c0cf7c39fdb269c83bdbbcd97dc23d4dae60fb18c", + "size": 29583, + "subdir": "linux-64", + "timestamp": 1659858299943, + "version": "0.2.2" + }, + "cgroupspy-0.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f98013c9421930e0ce55e3b022056056", + "name": "cgroupspy", + "sha256": "e813f47a621f4d51c758843dee3c6f3323a0a34a6e23ebe5b058eb201ab36f76", + "size": 29568, + "subdir": "linux-64", + "timestamp": 1659858234143, + "version": "0.2.2" + }, + "cgroupspy-0.2.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b5b675a9ddabdd99562456f56b251359", + "name": "cgroupspy", + "sha256": "9d81086f9a6247db668e8e07b712e2f76b011771d66bee19e54b7e051d499b4a", + "size": 29633, + "subdir": "linux-64", + "timestamp": 1659858329359, + "version": "0.2.2" + }, + "chai-1.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2f5d2faa97a9616b6051ca58c77ef3f6", + "name": "chai", + "sha256": "e6bdb29ed3396e1dfe8e242847bef2eed2fd82085ca879a35c4a12fab908b94a", + "size": 37563, + "subdir": "linux-64", + "timestamp": 1530737712703, + "version": "1.1.2" + }, + "chai-1.1.2-py27h6243097_0.tar.bz2": { + "build": "py27h6243097_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "28dadbba4200278c4e96930024aea832", + "name": "chai", + "sha256": "39473e37e8f594cfa002bd800f1573c918f41c47663d280de1f96d352c685aa7", + "size": 37349, + "subdir": "linux-64", + "timestamp": 1505693737803, + "version": "1.1.2" + }, + "chai-1.1.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1523dd8c7ed6c7313700d587af96f4cf", + "name": "chai", + "sha256": "c4822e66377eff9367a88744b62d8b3b05ddde464d36ffae2c7c3fb6564ec26a", + "size": 39387, + "subdir": "linux-64", + "timestamp": 1640788975170, + "version": "1.1.2" + }, + "chai-1.1.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2bf9f9e13fca8479ac07141de063e329", + "name": "chai", + "sha256": "bd3584acb9fce35170ace7061ec143acf28ee6d3eff6ba572e9e44d4d8f1d508", + "size": 50061, + "subdir": "linux-64", + "timestamp": 1676847301930, + "version": "1.1.2" + }, + "chai-1.1.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "44dedd7063efc49cb4fb11b8d2827519", + "name": "chai", + "sha256": "a10eb717e7281ebe87920f98f5c5b6497e32d02f1941aab16643333e2a6902f0", + "size": 38598, + "subdir": "linux-64", + "timestamp": 1534352776004, + "version": "1.1.2" + }, + "chai-1.1.2-py35hb5482d5_0.tar.bz2": { + "build": "py35hb5482d5_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b282851332ad4f942ac86220b8a2a017", + "name": "chai", + "sha256": "c311942f30d38e29338bac6ddc449bafc244c0b1e36ce7ddbd2235b63e0bb3b2", + "size": 38486, + "subdir": "linux-64", + "timestamp": 1505693749584, + "version": "1.1.2" + }, + "chai-1.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a335786cf25c0726905d170da5553aac", + "name": "chai", + "sha256": "d06de27958a99c4e798b557b97495d464b9961f0a371217f8a9bedc0f5e40052", + "size": 38526, + "subdir": "linux-64", + "timestamp": 1530737691878, + "version": "1.1.2" + }, + "chai-1.1.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "220e8f1769d5d0df84269391bd1d3db2", + "name": "chai", + "sha256": "0c5263940344a4d56cd218247c3f4ecd00363d07c853fe9737e9ee43987e56cd", + "size": 40041, + "subdir": "linux-64", + "timestamp": 1611677541915, + "version": "1.1.2" + }, + "chai-1.1.2-py36hf4a44a8_0.tar.bz2": { + "build": "py36hf4a44a8_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1e7f20cfb3e237ac2833078b2b29c6f8", + "name": "chai", + "sha256": "6f97904dd82d7ca9c5bed6800580f786040865691031d4b38cdac9215504eae0", + "size": 38430, + "subdir": "linux-64", + "timestamp": 1505693761636, + "version": "1.1.2" + }, + "chai-1.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3c2d2e07246135c4ee3fe7b976975018", + "name": "chai", + "sha256": "2385d31283492b34660a739b99f59f299c1a0d773e9a175224d152c6c15fa9f6", + "size": 38574, + "subdir": "linux-64", + "timestamp": 1530737733850, + "version": "1.1.2" + }, + "chai-1.1.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "46f165e4893f222f1d1e76516422bbe2", + "name": "chai", + "sha256": "193a90c7365d42522617911e369eea9cac2aba92972d38bc4b550b16ca39dc30", + "size": 40258, + "subdir": "linux-64", + "timestamp": 1611677513721, + "version": "1.1.2" + }, + "chai-1.1.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "589ebdd2618686c360e43512587235fd", + "name": "chai", + "sha256": "7edacea48f4598ce45900c50ea6b1beb9563595768d390dd20bf4115d5822614", + "size": 39276, + "subdir": "linux-64", + "timestamp": 1572621590546, + "version": "1.1.2" + }, + "chai-1.1.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8cd6a4bdacc565da77783a5e8ea7096b", + "name": "chai", + "sha256": "31684491bdf5a5783564fad69f1f7599b1c44ccd668568ac7a56a9cfcd27212b", + "size": 40272, + "subdir": "linux-64", + "timestamp": 1611677542792, + "version": "1.1.2" + }, + "chai-1.1.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5e89f727b324507753cbd798aec45694", + "name": "chai", + "sha256": "b91c3c1fac715c8a852a6725f2d151509070d5af1378994b107fa537ff91b9b5", + "size": 40396, + "subdir": "linux-64", + "timestamp": 1611677519874, + "version": "1.1.2" + }, + "chainer-2.1.0-py27h229789d_0.tar.bz2": { + "build": "py27h229789d_0", + "build_number": 0, + "depends": [ + "filelock", + "mock", + "nose", + "numpy >=1.9.0", + "protobuf >=2.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "13bc328bc06f08bd86539c8f83c9f4b3", + "name": "chainer", + "sha256": "5f89a95077c6eefc53d3d2ecc3f7a0b6b77954c8bff1048c936a0893cb03ef81", + "size": 587914, + "subdir": "linux-64", + "timestamp": 1507580718449, + "version": "2.1.0" + }, + "chainer-2.1.0-py35hca77101_0.tar.bz2": { + "build": "py35hca77101_0", + "build_number": 0, + "depends": [ + "filelock", + "mock", + "nose", + "numpy >=1.9.0", + "protobuf >=2.6.0", + "python >=3.5,<3.6.0a0", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "f1cc1cc7cc59d78694268ca7807cdb86", + "name": "chainer", + "sha256": "ae217ae64d6cfa45ece33d3f25c7ebb22af96c6a116b0e04c56f796085ed6e12", + "size": 593286, + "subdir": "linux-64", + "timestamp": 1507580713032, + "version": "2.1.0" + }, + "chainer-2.1.0-py36hc23aa98_0.tar.bz2": { + "build": "py36hc23aa98_0", + "build_number": 0, + "depends": [ + "filelock", + "mock", + "nose", + "numpy >=1.9.0", + "protobuf >=2.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "1dc7501ae7b7d0a6a15322e2ac4939e1", + "name": "chainer", + "sha256": "241b94d2c197ba9aed040ab1e1cb2f57c7618ec38e928d0e5fe7676de10be124", + "size": 583591, + "subdir": "linux-64", + "timestamp": 1507580739679, + "version": "2.1.0" + }, + "chainer-3.1.0-py27h5d1875a_0.tar.bz2": { + "build": "py27h5d1875a_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "7b4a2edd6fca3d1bb5e24b7333717ab0", + "name": "chainer", + "sha256": "9939a7e3421f3300d8ed392a161e86c2278b5bf422273c974284ad254b61aeb6", + "size": 995396, + "subdir": "linux-64", + "timestamp": 1511676077039, + "version": "3.1.0" + }, + "chainer-3.1.0-py35h1c65560_0.tar.bz2": { + "build": "py35h1c65560_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "88d59fcaa9cd075f9ba355454ba14a69", + "name": "chainer", + "sha256": "7e12fe80c670cbc056770d068de284e1a509d12195b0fc77ca46b71dcb27aff1", + "size": 1003313, + "subdir": "linux-64", + "timestamp": 1511676099859, + "version": "3.1.0" + }, + "chainer-3.1.0-py36h5dba765_0.tar.bz2": { + "build": "py36h5dba765_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "7cde18b8b02d4e57dea0c0751c0daa34", + "name": "chainer", + "sha256": "d309997cea788b1bbf103994eeeb0550524a13662adb7dfefc405861066c309b", + "size": 1002017, + "subdir": "linux-64", + "timestamp": 1511676103326, + "version": "3.1.0" + }, + "chainer-3.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "a5bb45f87b15a27a1acd73cf4884a7d8", + "name": "chainer", + "sha256": "77263b994191c6b962fab663f600a97566107752c0fe942b9b69f51465ef880b", + "size": 654778, + "subdir": "linux-64", + "timestamp": 1519252393527, + "version": "3.4.0" + }, + "chainer-3.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "57038dba173d50ff45c9de4c184a2b27", + "name": "chainer", + "sha256": "cc7b00c8d4424be0a9acb438392870951e09c0c5105b8afc76dcc1354fee337e", + "size": 659658, + "subdir": "linux-64", + "timestamp": 1519252423092, + "version": "3.4.0" + }, + "chainer-3.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "d19e90b2390203ed9d0f4592fa2a544a", + "name": "chainer", + "sha256": "1eac0c730800369ad71c996c7f7aded3205a2c6d129a104f3b2a1228e0a23f55", + "size": 661774, + "subdir": "linux-64", + "timestamp": 1519252396780, + "version": "3.4.0" + }, + "chainer-4.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "7ad5263945fe409d0fc2853eb1f1b6d9", + "name": "chainer", + "sha256": "0a4f8f03b0df61221f95cb83c3dd70ba768096b36857735c3eb0cd86b652dee6", + "size": 746189, + "subdir": "linux-64", + "timestamp": 1524107393914, + "version": "4.0.0" + }, + "chainer-4.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "99d991c1f7138d89a696fc4c85c1d889", + "name": "chainer", + "sha256": "24b9dabed5e00a765a827eeb9aa96e89337bdd21eac12d4ba55a566c1c791726", + "size": 755339, + "subdir": "linux-64", + "timestamp": 1524107558500, + "version": "4.0.0" + }, + "chainer-4.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "bf692ec55801b102f064097b900917e6", + "name": "chainer", + "sha256": "f689b22f5333eb0c4e7ad14e991d59512c9d80f66bbdaba944c8e4e4c104ee4e", + "size": 752759, + "subdir": "linux-64", + "timestamp": 1524107601340, + "version": "4.0.0" + }, + "chainer-4.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "40c9eda64d4dcab90c6d2d6975c1ddc3", + "name": "chainer", + "sha256": "c7ec57704b373b750a2d3835851d797edd6ee87a1a34c7e78e8ec0196574a8e6", + "size": 752279, + "subdir": "linux-64", + "timestamp": 1527697967273, + "version": "4.1.0" + }, + "chainer-4.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "98a96513826c3d6888e681c8044083c2", + "name": "chainer", + "sha256": "45f8bfca755e8e5cf412b0d05b647646d12d2090581b13f943e99209bd9b75ca", + "size": 758172, + "subdir": "linux-64", + "timestamp": 1527697995270, + "version": "4.1.0" + }, + "chainer-4.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "6ac7dcbe99841b4fe607a8604812a04a", + "name": "chainer", + "sha256": "69e8afa042513bb037a885a0dc092777f7b5bed033a284224a4ca387aa4582c4", + "size": 755828, + "subdir": "linux-64", + "timestamp": 1527697953590, + "version": "4.1.0" + }, + "chainer-4.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "7fedf0196bff64c7ccc5ff2f5c62e145", + "name": "chainer", + "sha256": "b1d5d6fa9711f816c202e4ba521af30d466bc1fb34dead11906106d6d4e1c14d", + "size": 757203, + "subdir": "linux-64", + "timestamp": 1529952032145, + "version": "4.2.0" + }, + "chainer-4.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "804b41f6f10ebc6416684ccafbe199be", + "name": "chainer", + "sha256": "e8561f41dec44a89fad30acce78a87b8e88502204b790d33fd764c7abe2f0f1f", + "size": 764796, + "subdir": "linux-64", + "timestamp": 1529952059260, + "version": "4.2.0" + }, + "chainer-4.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "625f15365050b1ccdcacafe77e87e63e", + "name": "chainer", + "sha256": "372aca795a939ceb99545ff26fe25eb20062d08bfc73d35e3819578d5d0f09fb", + "size": 758102, + "subdir": "linux-64", + "timestamp": 1529952041010, + "version": "4.2.0" + }, + "chainer-4.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "a758b3b5b9d0c110cfcca72381c1734a", + "name": "chainer", + "sha256": "1fbfcd1b7e869496aa176514a1169382087630a86033da9d8bd0df9699530d1c", + "size": 758340, + "subdir": "linux-64", + "timestamp": 1530811940933, + "version": "4.2.0" + }, + "chainer-4.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "2e548a63884dfc651cc41a666c09c742", + "name": "chainer", + "sha256": "4a29f528fb1f8a90333493515df5b20a5b3d1bc8e03afb0668438aac15166b43", + "size": 758974, + "subdir": "linux-64", + "timestamp": 1534606454491, + "version": "4.3.1" + }, + "chainer-4.3.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "7b37fb58d2d324a6ebc288d53c78b456", + "name": "chainer", + "sha256": "e1b9ad1411ad7e4faa4fab1b39c2ca8cd1b4ecc41c09ad9d8f2f8d24970e6169", + "size": 766633, + "subdir": "linux-64", + "timestamp": 1534606495521, + "version": "4.3.1" + }, + "chainer-4.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "4bc3856074ec0924f2b206706e93ef67", + "name": "chainer", + "sha256": "7a2db79f90648e8788ce150192642929f280b2c53d91d60ce49034d8359ad329", + "size": 759444, + "subdir": "linux-64", + "timestamp": 1534606448424, + "version": "4.3.1" + }, + "chainer-4.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "ca296f148c3f21b91c4a7bb6c5c28395", + "name": "chainer", + "sha256": "e4f38201c362cb345b64aaf6474e65f6f2c44560cd422fc9df84659c3345231f", + "size": 760953, + "subdir": "linux-64", + "timestamp": 1534606491904, + "version": "4.3.1" + }, + "chainer-4.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "b4bfc7e7aeef4acde7bda3c5cdbe6724", + "name": "chainer", + "sha256": "9ea0069a278104f2659e0fe762fda07055de9e80aef409e903398cabd0490f94", + "size": 760548, + "subdir": "linux-64", + "timestamp": 1536108118241, + "version": "4.4.0" + }, + "chainer-4.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "c70b4d9ad7b85c7c36a1194adaa77551", + "name": "chainer", + "sha256": "833647a739c7700e24eca4fb6249ee203799c9897ebc83e2ac1eff9681ae4309", + "size": 768397, + "subdir": "linux-64", + "timestamp": 1536108131822, + "version": "4.4.0" + }, + "chainer-4.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "35704d926209d72ee58d1a88686ad2e3", + "name": "chainer", + "sha256": "1576a53fd792e206dee01dc1ead4a21df9557a66beb2280c8159b8cce99b21c2", + "size": 759932, + "subdir": "linux-64", + "timestamp": 1536105473880, + "version": "4.4.0" + }, + "chainer-4.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "561980e039a7443242bc611619fabfc5", + "name": "chainer", + "sha256": "541b284fc2136463aa4a90fe27326a6f29cd102d8ff9c9b5530f108af96f675b", + "size": 760911, + "subdir": "linux-64", + "timestamp": 1536105457946, + "version": "4.4.0" + }, + "chainer-4.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "9a6f1ba48e5ceb2f670779a4955245fc", + "name": "chainer", + "sha256": "1ab710549892aa08534841009353929a927fbe0fe9e44f6df67c499be191c5e6", + "size": 761792, + "subdir": "linux-64", + "timestamp": 1539471090873, + "version": "4.5.0" + }, + "chainer-4.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "0a1c37e91e44ccf436b4b1b23d8862b1", + "name": "chainer", + "sha256": "ab521bb86bb895549862f48014df290738d38e33d163d02ed45875e607cb94e3", + "size": 761319, + "subdir": "linux-64", + "timestamp": 1539471142687, + "version": "4.5.0" + }, + "chainer-4.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "4b9758ad7c1deb348c92e18eaa079c88", + "name": "chainer", + "sha256": "34db2251ae24ae969959f7f003fa16082790c63ff41ca13a9b1ef75b506862b9", + "size": 762450, + "subdir": "linux-64", + "timestamp": 1539471139734, + "version": "4.5.0" + }, + "chainer-5.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "b7f4c0a56fbf825efedfb83222f8783c", + "name": "chainer", + "sha256": "3679d5265e37d4a1b35a8341d9f25e6407f43d04a5107021160456758c3fc5b3", + "size": 1013808, + "subdir": "linux-64", + "timestamp": 1545161909972, + "version": "5.1.0" + }, + "chainer-5.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "03ef39535f2fcb61687e259ddfd8323b", + "name": "chainer", + "sha256": "fcafdf5d816e2d44bd895280f14e6cb6c4b160dd7a62e57a0f1a05bb15cc9aed", + "size": 1023156, + "subdir": "linux-64", + "timestamp": 1545161960387, + "version": "5.1.0" + }, + "chainer-5.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "3d60fc168557b5cce634daa5d5ff5a49", + "name": "chainer", + "sha256": "514cc50a714ced4eb253ffffd22b5af4c7cb58a980d3b3c4df278e66d029b8bb", + "size": 1024189, + "subdir": "linux-64", + "timestamp": 1545161964777, + "version": "5.1.0" + }, + "chainer-5.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "ce263803035827123f7f30b75f1aa90d", + "name": "chainer", + "sha256": "5f16f515a5999954280c74f22afbd9b7b51d0bc81e3f8237d666148256f1b50a", + "size": 1162675, + "subdir": "linux-64", + "timestamp": 1550266928787, + "version": "5.2.0" + }, + "chainer-5.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "98fcccb7482f1ebe2ad8366c04f27671", + "name": "chainer", + "sha256": "95667ce7b3f41768f32542304ca2129cf451e7686b78da3d83e2396cab008957", + "size": 1161646, + "subdir": "linux-64", + "timestamp": 1550267005505, + "version": "5.2.0" + }, + "chainer-5.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "7eb4c57aec1b43fe5e0cd929bbccff96", + "name": "chainer", + "sha256": "34d698fa83c7b658e5d618f8dab907066b96a2b3f41fdd6d8e6bcfdc45ce6402", + "size": 1160989, + "subdir": "linux-64", + "timestamp": 1550266883576, + "version": "5.2.0" + }, + "chainer-5.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "1301a5e980d7294e36f5cf3d7dae098a", + "name": "chainer", + "sha256": "0e41a617265a4a7ada99f4429e8abe0c5507e1881a2092dd445cbf46231c05dc", + "size": 1149354, + "subdir": "linux-64", + "timestamp": 1552358438673, + "version": "5.3.0" + }, + "chainer-5.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "00b6ff709d503f05413f38ec305bb2cf", + "name": "chainer", + "sha256": "7777035d2c1257badf5fe0301e26d0b7c2c8790cd6053dc5d6b7c0a9f270a2c9", + "size": 1168956, + "subdir": "linux-64", + "timestamp": 1552358479384, + "version": "5.3.0" + }, + "chainer-5.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "92410f46582a7101c1f80bccd8f9d5e5", + "name": "chainer", + "sha256": "dee6230eb84e957e968afb8e0efedc0ac4b8043a112f6e272e306dd36efa70ae", + "size": 1168455, + "subdir": "linux-64", + "timestamp": 1552358459038, + "version": "5.3.0" + }, + "chameleon-3.2-py27h2e5116c_0.tar.bz2": { + "build": "py27h2e5116c_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "83f6466d694f765c6b26e1e9579a6a75", + "name": "chameleon", + "sha256": "dfa363ea3e2b5f524326c9f6015248550d605c88a017e00136caca796d00de69", + "size": 163221, + "subdir": "linux-64", + "timestamp": 1507582208516, + "version": "3.2" + }, + "chameleon-3.2-py35h85e62d6_0.tar.bz2": { + "build": "py35h85e62d6_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "97766f0f77cd3c00b1f95a30e5df256f", + "name": "chameleon", + "sha256": "77e4a20a9bc0a303aba55f61459c74aee8b6fc9a6b86e2c3d9a2c52f60420f4e", + "size": 166936, + "subdir": "linux-64", + "timestamp": 1507582211232, + "version": "3.2" + }, + "chameleon-3.2-py36hd22e8fc_0.tar.bz2": { + "build": "py36hd22e8fc_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "96ea81111a5199bbed5f2b9c0569707d", + "name": "chameleon", + "sha256": "0cc7c4ded77d8b308867a08377fe459a011de85474a91a8f3bbc31cebb2135c6", + "size": 166121, + "subdir": "linux-64", + "timestamp": 1507582213413, + "version": "3.2" + }, + "chameleon-3.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "4415f618943a531e2bc4c231e98bcb25", + "name": "chameleon", + "sha256": "3dc1d96e09fbb957258945b87976010a9ef3acaefc10efbb920bdb0209148e42", + "size": 163479, + "subdir": "linux-64", + "timestamp": 1527695343832, + "version": "3.3" + }, + "chameleon-3.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "be3e43fe71442cc8394cc07a68e1036b", + "name": "chameleon", + "sha256": "8a86614ffdbbe98166a0ec8f262df1972f6699d36aab18477748fbb35e4ecdcd", + "size": 166868, + "subdir": "linux-64", + "timestamp": 1527695368462, + "version": "3.3" + }, + "chameleon-3.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "6d0421b9beed262a2f55ce5b6ccced81", + "name": "chameleon", + "sha256": "eec765e671deb4fab4722568779acbe21399001f582658217933ad5dcdf10148", + "size": 166224, + "subdir": "linux-64", + "timestamp": 1527695376096, + "version": "3.3" + }, + "chameleon-3.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "31f65287735da07e5a407ec535d3ebaa", + "name": "chameleon", + "sha256": "84cad60ff45c2097552de227536d099204b890ab664d66ffb68191c9d8688c11", + "size": 166310, + "subdir": "linux-64", + "timestamp": 1530811975324, + "version": "3.3" + }, + "chameleon-3.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "96a47f9753507dca901acd0795ffb972", + "name": "chameleon", + "sha256": "e4d05888cda5e7efab10ca38d00f98543503d4b03034090c39b8b151c9478583", + "size": 163768, + "subdir": "linux-64", + "timestamp": 1532873018991, + "version": "3.4" + }, + "chameleon-3.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "5a41e621cff80b75ef67786793265676", + "name": "chameleon", + "sha256": "93f2dee4e448f9c8792b89501a0f57b1f97d509a1f389d3175e67b1fbc5d14dc", + "size": 167185, + "subdir": "linux-64", + "timestamp": 1532873059980, + "version": "3.4" + }, + "chameleon-3.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "5d2887b2f842ad43dd45f924a00b41ae", + "name": "chameleon", + "sha256": "bbc1388c1bc5dafda0d5984e21af31288c81e6247feee376def6c87ca8788d32", + "size": 166622, + "subdir": "linux-64", + "timestamp": 1532872977952, + "version": "3.4" + }, + "chameleon-3.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "6fbe6a4bc6fa94fd620394cfe3b628d7", + "name": "chameleon", + "sha256": "28debb33317b3eac3a6cc7349a28a3ebf877820836ee35c9e358abc7e1260326", + "size": 166619, + "subdir": "linux-64", + "timestamp": 1532873065809, + "version": "3.4" + }, + "chameleon-3.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "f2444af623ee2a2a48a9197cd0f76058", + "name": "chameleon", + "sha256": "241dbf4a20410621471933beb3cadbbd67d7bae4759e0b708dc1a14df975ec98", + "size": 164665, + "subdir": "linux-64", + "timestamp": 1540962184564, + "version": "3.5" + }, + "chameleon-3.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "c9ff70dd786a113f76bd538c3fa74ded", + "name": "chameleon", + "sha256": "ec431187a415b0c85c1a34f46bb15309cbe8ac2b66dec7648b5640e9016f5f8d", + "size": 167645, + "subdir": "linux-64", + "timestamp": 1540962152623, + "version": "3.5" + }, + "chameleon-3.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "67c820111df83538b6e3fcf51b8581ee", + "name": "chameleon", + "sha256": "90daa7a8bb3e63744d348716c86d066fa1cc09f17a71ec4b01559c872bc3d84e", + "size": 167542, + "subdir": "linux-64", + "timestamp": 1540962195170, + "version": "3.5" + }, + "chameleon-3.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "97c36db74e5c1f9775372ad6c1488b8b", + "name": "chameleon", + "sha256": "7e290e314b95daa819c3f4f3e86305157d6061468524102320f97f5896323e29", + "size": 316972, + "subdir": "linux-64", + "timestamp": 1552359114411, + "version": "3.6" + }, + "chameleon-3.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "6c99adf6f56415b848abafc47efdbcb6", + "name": "chameleon", + "sha256": "9fcc1ef2c1f3a286e2d24904cf81539c3d0f74ebe7eaebadf9860b3bd62a85d2", + "size": 320272, + "subdir": "linux-64", + "timestamp": 1552359110550, + "version": "3.6" + }, + "chameleon-3.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "f0f9f744626b85a929b3397425221224", + "name": "chameleon", + "sha256": "9c893b7febec32576a689e2ee6e2b4e3e6421df4208f550dcfa91ad6f9510c61", + "size": 302311, + "subdir": "linux-64", + "timestamp": 1552359092545, + "version": "3.6" + }, + "characteristic-14.3.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "428ad2f3d3786bad27303d0a01f2ddcf", + "name": "characteristic", + "sha256": "9b39042a40bd49c5065ea97d7aaa9989f9cf89353f5eaf45895df82679f305aa", + "size": 26713, + "subdir": "linux-64", + "timestamp": 1540321205081, + "version": "14.3.0" + }, + "characteristic-14.3.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "c52172d22f9cd43a5679839119b22c05", + "name": "characteristic", + "sha256": "ccfa66568a6fa6310e30269c77b4ed0297b4aaf7b542516992a6f3aa196975d1", + "size": 28580, + "subdir": "linux-64", + "timestamp": 1640788992376, + "version": "14.3.0" + }, + "characteristic-14.3.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "316cf4a832f830c320525b3c3bf80259", + "name": "characteristic", + "sha256": "a6e99f5058e06a182e1c6205df0f70e9c54fc9b3422f3015dc4526af7a21110b", + "size": 27772, + "subdir": "linux-64", + "timestamp": 1540321239835, + "version": "14.3.0" + }, + "characteristic-14.3.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "eacb59011d094553b3e213def02bb335", + "name": "characteristic", + "sha256": "58f2b52752fa83086e98f95d0f2f0149bba863b6cb4832daa5553dd9ce8539ac", + "size": 28283, + "subdir": "linux-64", + "timestamp": 1613154992415, + "version": "14.3.0" + }, + "characteristic-14.3.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "54842fe926f9a24ccea3f8c471be042d", + "name": "characteristic", + "sha256": "ebe4951e3f0777b2a2c911692ee24b5aa36ca7ad12f4b1456c7a39585cadd41a", + "size": 27681, + "subdir": "linux-64", + "timestamp": 1540321237486, + "version": "14.3.0" + }, + "characteristic-14.3.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8e03d29d0a50d4ad661d702b061085d4", + "name": "characteristic", + "sha256": "f880fe0ac5c984c5fb6e09ce722233806de5b33810b4f7f4875fabcaab989f5a", + "size": 28172, + "subdir": "linux-64", + "timestamp": 1613155456912, + "version": "14.3.0" + }, + "characteristic-14.3.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "fde2d67a078859add4ff9c250ae4283f", + "name": "characteristic", + "sha256": "e4a20ee749270051a2c57471337fbb06b4416c44060786f4606f9924bec7d6d7", + "size": 28095, + "subdir": "linux-64", + "timestamp": 1572357193248, + "version": "14.3.0" + }, + "characteristic-14.3.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "38a50dbda298ef7165cf4939d1cfc273", + "name": "characteristic", + "sha256": "5c587444bf40ae6154c230d39895ca91cdc2dec2c60e0c11a6f6ec39de856d79", + "size": 28405, + "subdir": "linux-64", + "timestamp": 1613155455049, + "version": "14.3.0" + }, + "characteristic-14.3.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "534fb7be972e4441f0b2116600e47ea8", + "name": "characteristic", + "sha256": "9d36d66f0270f14247519ba535d199e7f220b26e034dd5cf500ad9b3e7ebda3a", + "size": 28483, + "subdir": "linux-64", + "timestamp": 1607007583629, + "version": "14.3.0" + }, + "chardet-3.0.4-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "0ee8a673c47be9ff3aff20ba03738db6", + "name": "chardet", + "sha256": "8349b0b47abd0851d9496277c296af7f9ca6be5f03113ec2f1694e5c04a39d7d", + "size": 184136, + "subdir": "linux-64", + "timestamp": 1530733536657, + "version": "3.0.4" + }, + "chardet-3.0.4-py27_1003.tar.bz2": { + "build": "py27_1003", + "build_number": 1003, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "ba15a34e6c0852c82e1aeb4f860b3060", + "name": "chardet", + "sha256": "a1319bc44df4817591e582b2620fae282e03202ec36d0d0f3ac4c2383223e458", + "size": 190059, + "subdir": "linux-64", + "timestamp": 1564159616672, + "version": "3.0.4" + }, + "chardet-3.0.4-py27hfa10054_1.tar.bz2": { + "build": "py27hfa10054_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "cf1e643f7e88f4d5bc3734ff9ecc9582", + "name": "chardet", + "sha256": "00adb1738dd3e6c9c627f936bafba8500c26bcd47536161fdd8ff2f093ac5b5b", + "size": 184052, + "subdir": "linux-64", + "timestamp": 1505691573037, + "version": "3.0.4" + }, + "chardet-3.0.4-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "752cb77716725214bd158f9a7478b73c", + "name": "chardet", + "sha256": "e680f8c89b789ff0227671f944b96a3dbe877fd9291e7ae48aa45cce6c6936c9", + "size": 195286, + "subdir": "linux-64", + "timestamp": 1534350673281, + "version": "3.0.4" + }, + "chardet-3.0.4-py35hb6e9ddf_1.tar.bz2": { + "build": "py35hb6e9ddf_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "18ff93df029490aaadeca8e69dc055a4", + "name": "chardet", + "sha256": "4bb4b83f0441907f3b8950a619c1ef2a76f7d8ed65518df3814d791af0ea9c83", + "size": 194947, + "subdir": "linux-64", + "timestamp": 1505691587564, + "version": "3.0.4" + }, + "chardet-3.0.4-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "b2761e054bf9228b690ca68f7a8e6a2f", + "name": "chardet", + "sha256": "7c39ee3dced3fa8165974f8cf62346563fa15fd64ab87d40d9e06013cf5f667d", + "size": 193878, + "subdir": "linux-64", + "timestamp": 1530733513654, + "version": "3.0.4" + }, + "chardet-3.0.4-py36_1003.tar.bz2": { + "build": "py36_1003", + "build_number": 1003, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "bb767b94c2d4db2ff14865a281f2716b", + "name": "chardet", + "sha256": "a690f705ea8b5a3012a734b14ff56c08ecfa3ef658dc7b6b66b9fb26be64f2c5", + "size": 201471, + "subdir": "linux-64", + "timestamp": 1564159614223, + "version": "3.0.4" + }, + "chardet-3.0.4-py36h06a4308_1003.tar.bz2": { + "build": "py36h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "ca63d0bb27692887acd85462bcfbaa7c", + "name": "chardet", + "sha256": "6346216ccd0999097e6aef66ada0e31f8ecfc9a06cf12cc49ca72e5d264b4c0c", + "size": 201713, + "subdir": "linux-64", + "timestamp": 1605303211592, + "version": "3.0.4" + }, + "chardet-3.0.4-py36h0f667ec_1.tar.bz2": { + "build": "py36h0f667ec_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "d46061b631f1c77986cc321e0cab3bb4", + "name": "chardet", + "sha256": "df1d2955676b03a8388027ae6639aed5a6a5382897d4f81034f8ca2f15f7d386", + "size": 194419, + "subdir": "linux-64", + "timestamp": 1505691602341, + "version": "3.0.4" + }, + "chardet-3.0.4-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "0093b066ab21b18f8ce9580d559bde38", + "name": "chardet", + "sha256": "be60fddfdd4aaa42964b47a5e5b6fd43205a979d4b7b685f61d207a4d6a17bc8", + "size": 168360, + "subdir": "linux-64", + "timestamp": 1530733560448, + "version": "3.0.4" + }, + "chardet-3.0.4-py37_1003.tar.bz2": { + "build": "py37_1003", + "build_number": 1003, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "4673a0eeb34260a3610c1e808447e6a9", + "name": "chardet", + "sha256": "7e379c7b8a73da9fc349d9e9f896bd8e1ab83002545d2bcc9db609cc1a6959e7", + "size": 177158, + "subdir": "linux-64", + "timestamp": 1564159612371, + "version": "3.0.4" + }, + "chardet-3.0.4-py37h06a4308_1003.tar.bz2": { + "build": "py37h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "a2b4e11d1601b05a0e24e4d9976b64b5", + "name": "chardet", + "sha256": "81188e35db5f12f9f65501bd0c67c54d7aa9e697346d292ee0eef7970ca64d04", + "size": 177082, + "subdir": "linux-64", + "timestamp": 1605303192201, + "version": "3.0.4" + }, + "chardet-3.0.4-py38_1003.tar.bz2": { + "build": "py38_1003", + "build_number": 1003, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "1c05ac6a6eaa00365c2e098e58ee552f", + "name": "chardet", + "sha256": "e3b5200245b0d8beb304e23e4d5f6d940270b4d60737c6fef0a0c738a6ef1c0d", + "size": 174316, + "subdir": "linux-64", + "timestamp": 1573033833227, + "version": "3.0.4" + }, + "chardet-3.0.4-py38h06a4308_1003.tar.bz2": { + "build": "py38h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "b2abcb1f637b78f7b2bf159ecc892cd3", + "name": "chardet", + "sha256": "b4a8041904f3c37db69a180fa339025601e67377a20d5f3a8f73ce9dd55deeb3", + "size": 177311, + "subdir": "linux-64", + "timestamp": 1605303218365, + "version": "3.0.4" + }, + "chardet-3.0.4-py39h06a4308_1003.tar.bz2": { + "build": "py39h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "b9acb0e2f8061bfa4f89381ed83597ca", + "name": "chardet", + "sha256": "c88c9bf3a5e521ce9a445ad1efb46645ef588454a0222303b0832d53a9540ff9", + "size": 177389, + "subdir": "linux-64", + "timestamp": 1605303233050, + "version": "3.0.4" + }, + "chardet-4.0.0-py310h06a4308_1003.tar.bz2": { + "build": "py310h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "1937e4be4c81d450a83d978b269c7521", + "name": "chardet", + "sha256": "b0372e3cb9880eee1d55fd9081602cf116d0215deb2347ea794e35b102df801d", + "size": 222376, + "subdir": "linux-64", + "timestamp": 1640804906675, + "version": "4.0.0" + }, + "chardet-4.0.0-py311h06a4308_1003.tar.bz2": { + "build": "py311h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "c010f8bae0a5851b9c0775d35d4db6e5", + "name": "chardet", + "sha256": "191149d4430db90cac6db752294e5e054a5b56720f893250188bffff858a3386", + "size": 253519, + "subdir": "linux-64", + "timestamp": 1676830288728, + "version": "4.0.0" + }, + "chardet-4.0.0-py36h06a4308_1003.tar.bz2": { + "build": "py36h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "bb8e936d08c9384f5c1125a997d3f7e6", + "name": "chardet", + "sha256": "3fba475aa647cae7e64571f3e2233a13340ced454753b6317d39964d43b77519", + "size": 218616, + "subdir": "linux-64", + "timestamp": 1607706773449, + "version": "4.0.0" + }, + "chardet-4.0.0-py37h06a4308_1003.tar.bz2": { + "build": "py37h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "c1192d1051b39384e6440b69adeab3bf", + "name": "chardet", + "sha256": "476cafeb8f22ec8aedca24a986d8952781d160155ab04cf9fe96171fb103d873", + "size": 209766, + "subdir": "linux-64", + "timestamp": 1607706803691, + "version": "4.0.0" + }, + "chardet-4.0.0-py38h06a4308_1003.tar.bz2": { + "build": "py38h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "493242ed12cce0f1f28242c9cdfcf63e", + "name": "chardet", + "sha256": "02ad66072b47fbf0cd64cc28fb59588f5d081a12f6ef5c72824d3e2b3583c659", + "size": 203530, + "subdir": "linux-64", + "timestamp": 1607706782476, + "version": "4.0.0" + }, + "chardet-4.0.0-py39h06a4308_1003.tar.bz2": { + "build": "py39h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "bf619ce778d01adaef0aef6b7e99972a", + "name": "chardet", + "sha256": "d8f7c5997134528dfdf57095abd046116ce2bb1264082b1959a5da6731ed7f4d", + "size": 203040, + "subdir": "linux-64", + "timestamp": 1607706813216, + "version": "4.0.0" + }, + "charls-2.1.0-he6710b0_2.tar.bz2": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2999e9602416f44775afd1f0d2b5cbfc", + "name": "charls", + "sha256": "761aba1a10a3a6c85e3a711ab0c6781842af5cb92f034eaba745d32e59fd05ea", + "size": 157045, + "subdir": "linux-64", + "timestamp": 1593198212427, + "version": "2.1.0" + }, + "charls-2.2.0-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "310b9390fc05d62245c9f95ac96ac376", + "name": "charls", + "sha256": "ff4a1d243f3ffbcc677b1db7b5c7af06492f2910a0f1eea6664ad0ea3125835c", + "size": 132255, + "subdir": "linux-64", + "timestamp": 1612240399775, + "version": "2.2.0" + }, + "cheetah-2.4.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "markdown >=2.0.1", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "23a2c4a96fa4c6c24ffcbd4bc807dbf7", + "name": "cheetah", + "sha256": "2e64faf443047e2f37c6e43693c99a5b91bfaa234034defb6093b2d6254ce643", + "size": 273875, + "subdir": "linux-64", + "timestamp": 1535823341542, + "version": "2.4.4" + }, + "cheroot-5.10.0-py27hc35b459_0.tar.bz2": { + "build": "py27hc35b459_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dd0f0a2e3870465ce0eeb77d1f3227bb", + "name": "cheroot", + "sha256": "243dd3828c93eef89a278236d25e281a3bab7e399ae2dc380adfd9d93dd4b58a", + "size": 91644, + "subdir": "linux-64", + "timestamp": 1511701582644, + "version": "5.10.0" + }, + "cheroot-5.10.0-py35hcddde38_0.tar.bz2": { + "build": "py35hcddde38_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7772f3420ba4de2d064de6a4161d7b96", + "name": "cheroot", + "sha256": "d84a6e4758813178eb66ebf4865166327bca512c4572ae91679fe8e7e51a893e", + "size": 94006, + "subdir": "linux-64", + "timestamp": 1511701586459, + "version": "5.10.0" + }, + "cheroot-5.10.0-py36h87f841d_0.tar.bz2": { + "build": "py36h87f841d_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2bfbfa6c47028b7301fd41a111e6c068", + "name": "cheroot", + "sha256": "bb650a8a018e594a57891f4335d440645d6d1459bfe00c57af0f28a033b7b508", + "size": 93653, + "subdir": "linux-64", + "timestamp": 1511701588141, + "version": "5.10.0" + }, + "cheroot-5.8.3-py27hc34bea3_0.tar.bz2": { + "build": "py27hc34bea3_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f312700dcde1e6e73d63dc72d24d7bd3", + "name": "cheroot", + "sha256": "2c2b82ee73f13c80b80dae11c2238dd80815daed730a7ee5e7a42c72ac4918c8", + "size": 98558, + "subdir": "linux-64", + "timestamp": 1507584175851, + "version": "5.8.3" + }, + "cheroot-5.8.3-py35h0be0224_0.tar.bz2": { + "build": "py35h0be0224_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6b762110768d82db1f089c41cc9bae9f", + "name": "cheroot", + "sha256": "10ba38ef9a542825046c1ae9f98a213e70bb4c9b485358ecc07ceed6d49d12ad", + "size": 101024, + "subdir": "linux-64", + "timestamp": 1507584186533, + "version": "5.8.3" + }, + "cheroot-5.8.3-py36hbe33c39_0.tar.bz2": { + "build": "py36hbe33c39_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8f7ac8030461b5e4fe9eadaf81c68d86", + "name": "cheroot", + "sha256": "2cbf422d7c81279a74958d353b0e912055f7b8bed07143c4cc58ae2975ad6672", + "size": 100382, + "subdir": "linux-64", + "timestamp": 1507584180964, + "version": "5.8.3" + }, + "cheroot-6.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "65b4d99a291554ec303bb605cbbbac47", + "name": "cheroot", + "sha256": "57e595c66cc672affb38e586c07cbc37c4f3106721abf35b6d2ebb34b1bfb9ad", + "size": 91555, + "subdir": "linux-64", + "timestamp": 1519019251001, + "version": "6.0.0" + }, + "cheroot-6.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.5,<3.6.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d22ac85c8b5ef6ea303fc90aae9b4e78", + "name": "cheroot", + "sha256": "e82a5b8f26993b40f6ec02f851416dddb2d2765f515c0ddac413c6c5980a135b", + "size": 94020, + "subdir": "linux-64", + "timestamp": 1519019267772, + "version": "6.0.0" + }, + "cheroot-6.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2ca678bec4cd3cd6fe116c5d512e2ac1", + "name": "cheroot", + "sha256": "1a596579e7ae5339e53bcc5936624028e7f33fde54c737752336a87452cfa87a", + "size": 93448, + "subdir": "linux-64", + "timestamp": 1519019267864, + "version": "6.0.0" + }, + "cheroot-6.2.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b72867124b044f4780f329ed78aa5b83", + "name": "cheroot", + "sha256": "69473867df6f97031f2210f268e2299a350e875d3ec374b0129de895e9ccc913", + "size": 96058, + "subdir": "linux-64", + "timestamp": 1524082578899, + "version": "6.2.3" + }, + "cheroot-6.2.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.5,<3.6.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "41cac21deab972ae87186f424bb87db3", + "name": "cheroot", + "sha256": "40c0392dc93fe3f3e1b564b95dcaa2fa34e1ab8d48325eef057e46b800c3a775", + "size": 98198, + "subdir": "linux-64", + "timestamp": 1524082566249, + "version": "6.2.3" + }, + "cheroot-6.2.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "20f02de69e0d7d2720abd26fba7f4543", + "name": "cheroot", + "sha256": "746fcd37501497ea7d983c7c49c0a71f2c4b3f307728efb93792828ea6eb5105", + "size": 97704, + "subdir": "linux-64", + "timestamp": 1524082576086, + "version": "6.2.3" + }, + "cheroot-6.2.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "03c53293af28d18da58ccb5fb4ceb49b", + "name": "cheroot", + "sha256": "876ca7d730d5efcc9c08f886d605439cf418302dc9cd4cc102f5a617e7daad34", + "size": 96012, + "subdir": "linux-64", + "timestamp": 1524513705646, + "version": "6.2.4" + }, + "cheroot-6.2.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.5,<3.6.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c7d69c61ab6e49082665592bd4b83091", + "name": "cheroot", + "sha256": "33e4061dca7f6ba9213a5f0cb67ad544bf4a147f8f852c6e22e48adea6a1463f", + "size": 98206, + "subdir": "linux-64", + "timestamp": 1524513725440, + "version": "6.2.4" + }, + "cheroot-6.2.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3dc3e788f1285875a7356faa4ee6663b", + "name": "cheroot", + "sha256": "fec11bf6c4b8c9e1fa9b05b83957d9227e12a37190300c4655cec64b66b460d9", + "size": 97708, + "subdir": "linux-64", + "timestamp": 1524513725540, + "version": "6.2.4" + }, + "cheroot-6.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "66253b48ddbe9534cd350d1d2c751931", + "name": "cheroot", + "sha256": "ae69317cf3606da71c128c00220dd5d599c5848ddd7a79b677d9734e63bb7e59", + "size": 102595, + "subdir": "linux-64", + "timestamp": 1526927023715, + "version": "6.3.0" + }, + "cheroot-6.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.5,<3.6.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "64888715a5e3b912dc99f1ca4ec76c01", + "name": "cheroot", + "sha256": "ed08bb89e646885ff6dacb18309e06379199197a126afccbc32347e00e3f1b18", + "size": 104487, + "subdir": "linux-64", + "timestamp": 1526927063434, + "version": "6.3.0" + }, + "cheroot-6.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d84d5b9aa9a583382de5a2391c09157c", + "name": "cheroot", + "sha256": "1dcd01d932d3dd58c5e8b69954e54776b9210933f9e8a5f38439da0c88c1243e", + "size": 103950, + "subdir": "linux-64", + "timestamp": 1526927014458, + "version": "6.3.0" + }, + "cheroot-6.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f661c18151531cdd2b6030ea683887b3", + "name": "cheroot", + "sha256": "cecbeb5d5f2629abcb58d7dd0f0c98df5bdba0f8359625caaeaee99b7e115877", + "size": 102095, + "subdir": "linux-64", + "timestamp": 1526937290557, + "version": "6.3.1" + }, + "cheroot-6.3.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.5,<3.6.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "89d84cacb1abcdbb14c5323b60d7cc05", + "name": "cheroot", + "sha256": "750cb6dc2eae08f00ef3f78566e94b5ea55ac66d6fd19824cd26e40ae71b2fb5", + "size": 104160, + "subdir": "linux-64", + "timestamp": 1526937311377, + "version": "6.3.1" + }, + "cheroot-6.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0164c3ce0ec07267c061764162b7137c", + "name": "cheroot", + "sha256": "4c0323c1d89901f9b20618897a591b3295d78d4f0cb6b75a430833c8097428e1", + "size": 103527, + "subdir": "linux-64", + "timestamp": 1526937277712, + "version": "6.3.1" + }, + "cheroot-6.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6cc84c5d8c0525a3af0cd937591f8ed3", + "name": "cheroot", + "sha256": "054c7ba8dc4a45d100206b962a31e338cb166eb12ab8a1bdb35ab7094d96c216", + "size": 102395, + "subdir": "linux-64", + "timestamp": 1529437922426, + "version": "6.3.2" + }, + "cheroot-6.3.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.5,<3.6.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ee84038bc9d170219dae0f905f054010", + "name": "cheroot", + "sha256": "ed88fc295fd1849340cf11108c5cb443dbaa230a5f609b0f69c20a0247be6cb7", + "size": 104464, + "subdir": "linux-64", + "timestamp": 1529438198521, + "version": "6.3.2" + }, + "cheroot-6.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2343ae5dcb05fc227814557924b49023", + "name": "cheroot", + "sha256": "5f146f53a7df2470438deaa2497dcd4f94da55186d15a4ed789843de15c263b8", + "size": 103898, + "subdir": "linux-64", + "timestamp": 1529438027574, + "version": "6.3.2" + }, + "cheroot-6.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "397ecb5b8115f2654568b03abf410f7e", + "name": "cheroot", + "sha256": "3e892ea6801419526d73db47fa0edf2aacd0687fc6770409fcf942f16633b856", + "size": 103657, + "subdir": "linux-64", + "timestamp": 1530812033596, + "version": "6.3.2" + }, + "cheroot-6.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a4c3c17f16b35680a2b0b948bdade3b5", + "name": "cheroot", + "sha256": "3a69fcaa61cb15a2dafbc4b3db21c9298778ec7f9ac82c01ce9f1a7132842c0c", + "size": 101634, + "subdir": "linux-64", + "timestamp": 1534395619548, + "version": "6.4.0" + }, + "cheroot-6.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.5,<3.6.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "69c525363a6e63c9e34ee47863259429", + "name": "cheroot", + "sha256": "79db9228cfc50d12489afca6043938931c0f8707e67d7a8f16d41f02b5cfba96", + "size": 103752, + "subdir": "linux-64", + "timestamp": 1534395630028, + "version": "6.4.0" + }, + "cheroot-6.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cdf062cfc96caa68b5aa363dcb650917", + "name": "cheroot", + "sha256": "f94c739835720077dc777725edd89370709a8571156c4590efc3cc26a1f3d9a0", + "size": 103292, + "subdir": "linux-64", + "timestamp": 1534804132881, + "version": "6.4.0" + }, + "cheroot-6.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3c71cd179c0682c5d1372847f96d3401", + "name": "cheroot", + "sha256": "360037c6308ab3576ee535eb5c077c3c160320e38e9ba7e7002dbbec0dee37f9", + "size": 103026, + "subdir": "linux-64", + "timestamp": 1534395631831, + "version": "6.4.0" + }, + "cheroot-6.5.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d30e8c774bbb44763b3a4cf183ec42f7", + "name": "cheroot", + "sha256": "0cb041576e8a8fd0143169ca92e721d532dd511319755ee7e658340505817cf6", + "size": 129737, + "subdir": "linux-64", + "timestamp": 1539471461870, + "version": "6.5.2" + }, + "cheroot-6.5.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "38c90ac77c9b7fd4c84877b91727ed9a", + "name": "cheroot", + "sha256": "f5dcf0942bf674a99abb012ecdf77268a20217498a6a050e6e29bd6e19144d18", + "size": 131252, + "subdir": "linux-64", + "timestamp": 1539471483050, + "version": "6.5.2" + }, + "cheroot-6.5.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4eca18f032f9b3959417e94f23bb5138", + "name": "cheroot", + "sha256": "ab5a3822aa46cb9a4178b5654d2a03d796cf84ea9b058df244191e05823d621c", + "size": 131114, + "subdir": "linux-64", + "timestamp": 1539471477703, + "version": "6.5.2" + }, + "cheroot-6.5.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fbfb281218549d8dbcc0ee4f7a19898d", + "name": "cheroot", + "sha256": "62530045e335060a28637414fbe143e13c1a65c96183e6dab1eeecf942d774b0", + "size": 116805, + "subdir": "linux-64", + "timestamp": 1547224499302, + "version": "6.5.4" + }, + "cheroot-6.5.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bb47387f47f5404aee9ecb852cb909a7", + "name": "cheroot", + "sha256": "2601c26be362e66650108f4d48f464ebfc2aa850c07d042451facbbe1b914a87", + "size": 118302, + "subdir": "linux-64", + "timestamp": 1547224568349, + "version": "6.5.4" + }, + "cheroot-6.5.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "52381aae60e42d623f0733ae70b6adf6", + "name": "cheroot", + "sha256": "e027e6bf03483edfc948b3d03a3bf8dcf06f81451868f6e15c1511c4e6bb3136", + "size": 118114, + "subdir": "linux-64", + "timestamp": 1547224575038, + "version": "6.5.4" + }, + "cheroot-6.5.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "12a323d3f768df6cf2cb7b57013363c1", + "name": "cheroot", + "sha256": "9338a2ec42a579cc15d30d92c603fca69946fb2562ede94eeea5fdfa0d446996", + "size": 118666, + "subdir": "linux-64", + "timestamp": 1558556632793, + "version": "6.5.5" + }, + "cheroot-6.5.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "510186d60f5c726954fbb4cb9ecef03f", + "name": "cheroot", + "sha256": "2f8c7ff8ac52e0fa48143d7cec74ef50984a33dfe59445249a8f5749e1bd44b5", + "size": 120208, + "subdir": "linux-64", + "timestamp": 1558556666478, + "version": "6.5.5" + }, + "cheroot-6.5.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0a91219ebe379b6ad274a76c107cb8f0", + "name": "cheroot", + "sha256": "15ec2801095b7edf0fc7a8797c6aa8e1aa5d73044aec09a7d4082e9a9b37ffbb", + "size": 119895, + "subdir": "linux-64", + "timestamp": 1558556605262, + "version": "6.5.5" + }, + "cheroot-8.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "jaraco.functools", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6ac0c454ed1cb75be00115091b0f8ba9", + "name": "cheroot", + "sha256": "8ae92d58c415d4b99d7279f70ada8090d23133183b9fdaa294f682b3bf634eb0", + "size": 124441, + "subdir": "linux-64", + "timestamp": 1574366453439, + "version": "8.2.1" + }, + "cheroot-8.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "308021ea22303bc2154144084d6a4680", + "name": "cheroot", + "sha256": "99f17fc1bdc63cfaea7545aa51f6cd98b576d42edb3d7a885f1782ac1d7cebfd", + "size": 126375, + "subdir": "linux-64", + "timestamp": 1574366452759, + "version": "8.2.1" + }, + "cheroot-8.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "98f49ef480445523427a9721655573ee", + "name": "cheroot", + "sha256": "179ba8bd1a80d03dc35bc2846ff1905430bfbbfbd6c990e461f22ebbffded13f", + "size": 126145, + "subdir": "linux-64", + "timestamp": 1574366442419, + "version": "8.2.1" + }, + "cheroot-8.2.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.8,<3.9.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9200b537194e1bdb8f1cefe2665c51bb", + "name": "cheroot", + "sha256": "179f4656306a1e2b61ce13e71f2fa90d22a3b3429339d462404ccbb5f66a7e92", + "size": 126738, + "subdir": "linux-64", + "timestamp": 1574366595684, + "version": "8.2.1" + }, + "cheroot-8.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d0ea8a0f88a646d251253e524528f832", + "name": "cheroot", + "sha256": "24c0440c08518e8af97737dd89d8a761339a5cf7c3460235425bf89cdf4e1abe", + "size": 135469, + "subdir": "linux-64", + "timestamp": 1585046518565, + "version": "8.3.0" + }, + "cheroot-8.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0ae5447e8a1a678e353dd65887b84a30", + "name": "cheroot", + "sha256": "d98ba4fd93fa7460385687b3445283e41f3271e5884321e02c55f519105bc2f3", + "size": 135179, + "subdir": "linux-64", + "timestamp": 1585044449596, + "version": "8.3.0" + }, + "cheroot-8.3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.8,<3.9.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e580d05d2c27b80e71f868532017ca91", + "name": "cheroot", + "sha256": "caec54e0a53aece3391fb507d7774ef6a2dba9da4d9023e043016d1677c127e3", + "size": 135902, + "subdir": "linux-64", + "timestamp": 1585044463473, + "version": "8.3.0" + }, + "cheroot-8.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c97e5edb39d71a513970abbb81b565cd", + "name": "cheroot", + "sha256": "0524272202d0ef7a9ec357cd3c76a6e4ab4bb058d8cb2c85f7aa58ada0cd38b5", + "size": 135438, + "subdir": "linux-64", + "timestamp": 1596823968945, + "version": "8.4.2" + }, + "cheroot-8.4.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d3d4e6e7898b83c9f484d2568fc55125", + "name": "cheroot", + "sha256": "23b6206647053e6a8ba5c828fc1a1c18df172ebe05abed3879a44a84b9243b68", + "size": 135715, + "subdir": "linux-64", + "timestamp": 1597684745509, + "version": "8.4.4" + }, + "cheroot-8.4.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e7f424c0effcc417a72c55719a44b2fd", + "name": "cheroot", + "sha256": "e12729f4c48482ea55044eb660618e0b13f11ff29a5a1f31f91a29b3c711d94f", + "size": 139267, + "subdir": "linux-64", + "timestamp": 1601308725463, + "version": "8.4.5" + }, + "cheroot-8.4.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "94f0157da74ed7327d95d879da81e057", + "name": "cheroot", + "sha256": "56d1f013928dd2396e47e0a852f0e797fd1576144567e00b29bdd38177f3644d", + "size": 138989, + "subdir": "linux-64", + "timestamp": 1601308710721, + "version": "8.4.5" + }, + "cheroot-8.4.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.8,<3.9.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a34b8c7caaa0398c1acaa7fc7be47486", + "name": "cheroot", + "sha256": "16a4c1bb2aab7da410f5d98b87ceaca15d6c3bf7621265fa2d733b05f854666b", + "size": 139683, + "subdir": "linux-64", + "timestamp": 1601308716492, + "version": "8.4.5" + }, + "cheroot-8.4.7-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ab44a6b55d03cd7caf91f360c6d10bb9", + "name": "cheroot", + "sha256": "4a180a02ec35a7aaa8e81e4a96776891ab5f6bea23bc24551af4c5a3fb15dbfe", + "size": 139824, + "subdir": "linux-64", + "timestamp": 1605995837362, + "version": "8.4.7" + }, + "cheroot-8.4.7-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "65bc9f5ccf7a8cb6fe843e20bc5dfb44", + "name": "cheroot", + "sha256": "64669b96fc9ac09a5804a362ae8e6d564d45f1a6238b090e8144c5138a9eba28", + "size": 139411, + "subdir": "linux-64", + "timestamp": 1605995870571, + "version": "8.4.7" + }, + "cheroot-8.4.7-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.8,<3.9.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3e9149f86265a764d66f7c50870d6c4f", + "name": "cheroot", + "sha256": "936bdd858a61f0a654cb79005837516d1582b1fd215db6e62115a8e733d14b42", + "size": 140235, + "subdir": "linux-64", + "timestamp": 1605995830364, + "version": "8.4.7" + }, + "cheroot-8.4.8-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a479b1d13b840e7eb1a3927f971ffd8b", + "name": "cheroot", + "sha256": "9b28d9705bae98a0bc35d28f5063671cab3cd3a04d6733b3ae7ac0eedcd21675", + "size": 140569, + "subdir": "linux-64", + "timestamp": 1606255254149, + "version": "8.4.8" + }, + "cheroot-8.4.8-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d49c120adeef7055b11e881f92341bc0", + "name": "cheroot", + "sha256": "d2014fa547f2cd2b77de3638f0fdfd55d7545c6da34e3958e3cce3ed8c10714c", + "size": 140286, + "subdir": "linux-64", + "timestamp": 1606255249696, + "version": "8.4.8" + }, + "cheroot-8.4.8-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.8,<3.9.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b6eb4bde3850abd37905d39ba44ebb6a", + "name": "cheroot", + "sha256": "1c89601093901319f85c9ae128eecd866a434623349ad895478e46611417f082", + "size": 141090, + "subdir": "linux-64", + "timestamp": 1606255281563, + "version": "8.4.8" + }, + "cheroot-8.5.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "10a82b20d2c694bf5486ba1b029667fa", + "name": "cheroot", + "sha256": "c8d6e3b8aff4b87428c19bc65c6ac29dd713326b64b77164afeab95c67218850", + "size": 141192, + "subdir": "linux-64", + "timestamp": 1607365788129, + "version": "8.5.0" + }, + "cheroot-8.5.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "04156169b5e90a9c4884cf4480154391", + "name": "cheroot", + "sha256": "dfde9d246561a3e40787151bbf9851955fc32986c179e956976597be271768cc", + "size": 140840, + "subdir": "linux-64", + "timestamp": 1607365827327, + "version": "8.5.0" + }, + "cheroot-8.5.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.8,<3.9.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5d84b9b122c449300d850e8da4bc9756", + "name": "cheroot", + "sha256": "3c6ec189c4659264b80b091156a9193c4bbd7caffc98c789ea6a627bfe8c3c5f", + "size": 141695, + "subdir": "linux-64", + "timestamp": 1607365843852, + "version": "8.5.0" + }, + "cheroot-8.5.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b9abaf48ec4b28b87fc303c25c46d6fd", + "name": "cheroot", + "sha256": "d6648504ae66320944faa1dd3888196046a292f01e2b47457aa3aae151a81895", + "size": 143823, + "subdir": "linux-64", + "timestamp": 1607969234735, + "version": "8.5.1" + }, + "cheroot-8.5.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bdf803ab1077d368daed3ea532bdf588", + "name": "cheroot", + "sha256": "e62801db4c44d410eee22096598787fcf97c13ced242458cf853a070733853ed", + "size": 143596, + "subdir": "linux-64", + "timestamp": 1607969225021, + "version": "8.5.1" + }, + "cheroot-8.5.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.8,<3.9.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "192aba4dda08751b70bce530ab1f47fc", + "name": "cheroot", + "sha256": "5b439f2db598cec1ccc6b6100d54b2e19607c2b2ac33f48c553133ade06afe16", + "size": 144324, + "subdir": "linux-64", + "timestamp": 1607969157869, + "version": "8.5.1" + }, + "cheroot-8.5.2-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.10,<3.11.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "323a3b70dd5c5e096c59e553e0aaa442", + "name": "cheroot", + "sha256": "b83a7fbe5a7960c0adb32277c0d9c68cd8cc4a455148cb4d8646528072b84027", + "size": 146898, + "subdir": "linux-64", + "timestamp": 1642512773690, + "version": "8.5.2" + }, + "cheroot-8.5.2-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.11,<3.12.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "20c3a7b504acc0428985d12971231f72", + "name": "cheroot", + "sha256": "8e8d34384cb38906c29ab96d40504ce5b29c240585f6e9fcbfc8e026c15a7e5b", + "size": 190480, + "subdir": "linux-64", + "timestamp": 1676843553621, + "version": "8.5.2" + }, + "cheroot-8.5.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "12bc4b0a1839c888526602a06e8a22af", + "name": "cheroot", + "sha256": "e50a620af6b61f183d5a2e403bbdfaf1c89374049a5364999359c52f5506baf4", + "size": 144634, + "subdir": "linux-64", + "timestamp": 1611596681704, + "version": "8.5.2" + }, + "cheroot-8.5.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f514db0bf3a77e609f90283329a8a120", + "name": "cheroot", + "sha256": "159b5f8cb5472c35441d46833d963a9aa6a40eed2e09073e2506aa5a25857178", + "size": 144270, + "subdir": "linux-64", + "timestamp": 1611595855896, + "version": "8.5.2" + }, + "cheroot-8.5.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.8,<3.9.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a97c2f2895d1ac4dfd815300db00f7cf", + "name": "cheroot", + "sha256": "afab19a9163f89dc24210fb47eed533accb33f0c6b8607c0ee8d1af0eb9ba364", + "size": 145135, + "subdir": "linux-64", + "timestamp": 1611596695373, + "version": "8.5.2" + }, + "cheroot-8.5.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.9,<3.10.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "13221ab0b6e74181187f2869fc9dca50", + "name": "cheroot", + "sha256": "8acd6caf47178af51e1e9cab566d810e8f5f275ed2f4bf5cf7e670a8b0524238", + "size": 144937, + "subdir": "linux-64", + "timestamp": 1611596695382, + "version": "8.5.2" + }, + "cherrypy-11.0.0-py27h05564f0_0.tar.bz2": { + "build": "py27h05564f0_0", + "build_number": 0, + "depends": [ + "cheroot >=5.8.3", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "52e5a4974e1af32bc59468483aa1f88a", + "name": "cherrypy", + "sha256": "2bfefb1ed4ed59611b01f70938537474728611fae6b5a4157de2a4a672e79a5d", + "size": 574799, + "subdir": "linux-64", + "timestamp": 1507586943067, + "version": "11.0.0" + }, + "cherrypy-11.0.0-py35hf2b23f5_0.tar.bz2": { + "build": "py35hf2b23f5_0", + "build_number": 0, + "depends": [ + "cheroot >=5.8.3", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e649b351aa5a273dd1c1bcef38721189", + "name": "cherrypy", + "sha256": "80851842f6614378245b8e1482ba75685393f3d0a9330cf53886675a750e1b89", + "size": 586684, + "subdir": "linux-64", + "timestamp": 1507586949445, + "version": "11.0.0" + }, + "cherrypy-11.0.0-py36h0635bd1_0.tar.bz2": { + "build": "py36h0635bd1_0", + "build_number": 0, + "depends": [ + "cheroot >=5.8.3", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "64f8a47ecf9b0d724aebb3307bbd6caa", + "name": "cherrypy", + "sha256": "0343e78a0f3b685a8bd2ef55cf9d1ef715288f61fc03f6515e053409d825de85", + "size": 578817, + "subdir": "linux-64", + "timestamp": 1507586952205, + "version": "11.0.0" + }, + "cherrypy-12.0.1-py27h0f69e9d_0.tar.bz2": { + "build": "py27h0f69e9d_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "jaraco.classes", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "df5db6d71c585cea7ea0a5befd39e1c2", + "name": "cherrypy", + "sha256": "33067720012f700e710742e27a2760d158a6316b33c022e3dcbfeee1ed7d3b08", + "size": 565176, + "subdir": "linux-64", + "timestamp": 1511705282317, + "version": "12.0.1" + }, + "cherrypy-12.0.1-py35h41829b4_0.tar.bz2": { + "build": "py35h41829b4_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "jaraco.classes", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "de92732863af7d5eb424eee30c7fda5c", + "name": "cherrypy", + "sha256": "7af350438b49d2cd05bd2ac3a6e8a9f4db92e78d0662411a0ec966fcc93deb06", + "size": 572986, + "subdir": "linux-64", + "timestamp": 1511705283441, + "version": "12.0.1" + }, + "cherrypy-12.0.1-py36h952b05f_0.tar.bz2": { + "build": "py36h952b05f_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "jaraco.classes", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "169902aecab54c33fe13b19cd1c4d8a2", + "name": "cherrypy", + "sha256": "c64292c0889a3ad5662bdef98bd87d1ddb4800dd8c72c453565bbfaa30c6465f", + "size": 568481, + "subdir": "linux-64", + "timestamp": 1511705288409, + "version": "12.0.1" + }, + "cherrypy-13.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "jaraco.classes", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "092591e9607aab25530b61a6851c4aba", + "name": "cherrypy", + "sha256": "edc98735412dd6d027f2dec0eebcca322a69e9d87a73e02a4113b7b27386802d", + "size": 565911, + "subdir": "linux-64", + "timestamp": 1516981344092, + "version": "13.1.0" + }, + "cherrypy-13.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "jaraco.classes", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d9121a1d305bb6e475a203955a9302c5", + "name": "cherrypy", + "sha256": "b92f25aef281d286b5d0998a9bfc741065192803f65ff0480174f885d975c8d2", + "size": 573710, + "subdir": "linux-64", + "timestamp": 1516981370157, + "version": "13.1.0" + }, + "cherrypy-13.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "jaraco.classes", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "944e8d94ffea95d282c518686f0d4de7", + "name": "cherrypy", + "sha256": "365534857f1580c697728c9f13a4e942f3e3a06855733ba7055729fade2fc4e4", + "size": 569270, + "subdir": "linux-64", + "timestamp": 1516981373255, + "version": "13.1.0" + }, + "cherrypy-14.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "767179168df930d5288f0b60039b6530", + "name": "cherrypy", + "sha256": "017d4869cbb0aecf15bcee5ef783dba18efc9a75c20499fa946d392ddf0663e2", + "size": 565733, + "subdir": "linux-64", + "timestamp": 1519016532665, + "version": "14.0.0" + }, + "cherrypy-14.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5b9fae7857000662f615a67ee987d2bf", + "name": "cherrypy", + "sha256": "24208ded4c81fdc6a7db03db6d81c588a925613da0174cc6a11b5847bea91a9e", + "size": 575773, + "subdir": "linux-64", + "timestamp": 1519016549945, + "version": "14.0.0" + }, + "cherrypy-14.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b13dc0ad074767ea1f13ceb49e2c6ec0", + "name": "cherrypy", + "sha256": "b7ccbd0fe6b3137f766a802167a51b1da6003a9192564e6bcc952f6b0d05bbb0", + "size": 570410, + "subdir": "linux-64", + "timestamp": 1519016548296, + "version": "14.0.0" + }, + "cherrypy-14.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "efd658ba2217913f139e2d665c721d7a", + "name": "cherrypy", + "sha256": "979fd493022480c832e269c98ca49aae0559aa34ed4a68d89e77702c5a6bf6bd", + "size": 566266, + "subdir": "linux-64", + "timestamp": 1522714461833, + "version": "14.0.1" + }, + "cherrypy-14.0.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0ff282db0570bd49298873b098d740aa", + "name": "cherrypy", + "sha256": "58a63bc1d4e528615c2d9e22e0c05a1f552a1a5407a24c6eb1445ee799b832ac", + "size": 574754, + "subdir": "linux-64", + "timestamp": 1522715119957, + "version": "14.0.1" + }, + "cherrypy-14.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1371355b1ca891923d28ca95173bf42e", + "name": "cherrypy", + "sha256": "fd6fb1e2bb4255ac428ad6a8d5ff4c3b9810354ea58c2f17d6dca0984666e429", + "size": 570819, + "subdir": "linux-64", + "timestamp": 1522715119432, + "version": "14.0.1" + }, + "cherrypy-14.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f158ed5121ff50cda04618187b173d32", + "name": "cherrypy", + "sha256": "dbde4a8b6be7b0001eb0481133e4fac27c14d0d0a2a921c414f901f879ef4398", + "size": 566427, + "subdir": "linux-64", + "timestamp": 1524520109920, + "version": "14.2.0" + }, + "cherrypy-14.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ed0dbc88d0899c75591ed8e76fb47517", + "name": "cherrypy", + "sha256": "1449bfccdaaf86fc541716fcfcb9a797678562a3fca0eb530d01c014d690aef2", + "size": 574896, + "subdir": "linux-64", + "timestamp": 1524520264926, + "version": "14.2.0" + }, + "cherrypy-14.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8e061d1090f5be47e5b635af9cc8a0bd", + "name": "cherrypy", + "sha256": "594af02e41e73cf1aff2c166b61a7d5b7c00dc2c14663990edd0d5327fcbdec4", + "size": 571226, + "subdir": "linux-64", + "timestamp": 1524520264927, + "version": "14.2.0" + }, + "cherrypy-15.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d7ce73025be8ed66b7583c536b168170", + "name": "cherrypy", + "sha256": "75566d55f43060e8bf5121209b4d0a95e3e6cea91d33832e98631f69a9c63c99", + "size": 572208, + "subdir": "linux-64", + "timestamp": 1526927170064, + "version": "15.0.0" + }, + "cherrypy-15.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "df116c1f675267abc8970d945ed004ff", + "name": "cherrypy", + "sha256": "efb949255c64dfd3a16a29ac85f75435e31bf3b0c83b30ab17b8647b56b1ac30", + "size": 582217, + "subdir": "linux-64", + "timestamp": 1526927223597, + "version": "15.0.0" + }, + "cherrypy-15.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2852df46a4be247a2ff8412c5a0b99b6", + "name": "cherrypy", + "sha256": "95221ec4116371f76bfa87255188675a387bfa55df4e30d09502011404e0f863", + "size": 577689, + "subdir": "linux-64", + "timestamp": 1526927162214, + "version": "15.0.0" + }, + "cherrypy-16.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "20925dd3dbcd240c17d3b6419a1f4652", + "name": "cherrypy", + "sha256": "bbb511c71bd8ee3d4e7aade3137b7b49fc33000abbe6cf1e3467ba4e7540f759", + "size": 566839, + "subdir": "linux-64", + "timestamp": 1529417897044, + "version": "16.0.2" + }, + "cherrypy-16.0.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0f8586f61bb58cfaf35e6f99d25287ce", + "name": "cherrypy", + "sha256": "993915a3f620eb366f0431cae0cf733e7096c679e321aa251c660f04ddc95db0", + "size": 574598, + "subdir": "linux-64", + "timestamp": 1529417918690, + "version": "16.0.2" + }, + "cherrypy-16.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "620521205671ad7e4e98418946f8d3d0", + "name": "cherrypy", + "sha256": "346b7094445bf42f229c43f9795e53f0f678017a883914bdc618b8d3c3807ba7", + "size": 568608, + "subdir": "linux-64", + "timestamp": 1529417879105, + "version": "16.0.2" + }, + "cherrypy-16.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "27de7587ef9dfed5108933c3855046c6", + "name": "cherrypy", + "sha256": "ff302c6cb7b9004dd107d3b77fa675e30f74896ebfd10e81268b21d211879235", + "size": 569153, + "subdir": "linux-64", + "timestamp": 1530812121706, + "version": "16.0.2" + }, + "cherrypy-17.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c7d23019e2a04e11ff5df155dad69bf6", + "name": "cherrypy", + "sha256": "aece9d86192e7f63df40447eb8fc7dd46a9e3e61e823d72498dd3fa73ff2f9b6", + "size": 566801, + "subdir": "linux-64", + "timestamp": 1533042198115, + "version": "17.0.0" + }, + "cherrypy-17.0.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "244ba064759ffaf68b12f977b543c7ca", + "name": "cherrypy", + "sha256": "260da6b261f5844e8422e7a5e65ba7dc51e4c46a51859f48a5a4ce9e8b6f333c", + "size": 566478, + "subdir": "linux-64", + "timestamp": 1535129906190, + "version": "17.0.0" + }, + "cherrypy-17.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f93183cc8bd9e4b444baf8de55d33fe2", + "name": "cherrypy", + "sha256": "81a65beea78aeab953597f2b3df6007f675bc833c8d8fe4cd48a607c40498605", + "size": 573839, + "subdir": "linux-64", + "timestamp": 1533042217866, + "version": "17.0.0" + }, + "cherrypy-17.0.0-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8f1a41eb3fe75fb7b68165a30afb43ee", + "name": "cherrypy", + "sha256": "7b0cce8912ffb66bade877972cd23ba76d090b091da3e0abbeb60b7050c9247f", + "size": 574321, + "subdir": "linux-64", + "timestamp": 1535129939559, + "version": "17.0.0" + }, + "cherrypy-17.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b30819f08bd405f437b8bf380befe698", + "name": "cherrypy", + "sha256": "e3d6823410edac54555256ddd10d0d8d1a403280474e407daea41eec97174a51", + "size": 569222, + "subdir": "linux-64", + "timestamp": 1533042160581, + "version": "17.0.0" + }, + "cherrypy-17.0.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1878161e8289559c0ddf24560019abf0", + "name": "cherrypy", + "sha256": "755d39a091d74d4d88942841e14af0cdcac3c629ad7a262e55c7de9b3482ad0a", + "size": 569021, + "subdir": "linux-64", + "timestamp": 1535129973763, + "version": "17.0.0" + }, + "cherrypy-17.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "94ccc731dec9a9c251bcbec50740a0c5", + "name": "cherrypy", + "sha256": "838dda755888f1f1a89c0b1eedf98d190afc793399eafa3b96244ddcd291aa50", + "size": 568859, + "subdir": "linux-64", + "timestamp": 1533042238210, + "version": "17.0.0" + }, + "cherrypy-17.0.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "08f2a18a21a75e81b9ad42d7b36f9f72", + "name": "cherrypy", + "sha256": "c4666e0e2d9ccd991745fe611458d3779d01b7778c918eeef9e1de8e17a28c5b", + "size": 569321, + "subdir": "linux-64", + "timestamp": 1535129876050, + "version": "17.0.0" + }, + "cherrypy-17.3.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ad0cdf794b99b4c5472d9754c29a00cd", + "name": "cherrypy", + "sha256": "1fa570dbad34de316d7e286265150276a08d194dee98de5d8e0df26e5e951d50", + "size": 559541, + "subdir": "linux-64", + "timestamp": 1535301197039, + "version": "17.3.0" + }, + "cherrypy-17.3.0-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.5,<3.6.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f84c07853e3482fef4da20fe2724548b", + "name": "cherrypy", + "sha256": "a138831131edd9516c84fc10f1ecb713341536540f559d4e30d8140bd2cf5de1", + "size": 566038, + "subdir": "linux-64", + "timestamp": 1535301241313, + "version": "17.3.0" + }, + "cherrypy-17.3.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "87d0187c5cb9fe9f70b30a85365845b2", + "name": "cherrypy", + "sha256": "73bebc0fa2b33d568dca2da53d1e17844268ae55b99af1ff9b1f87d99448882a", + "size": 561475, + "subdir": "linux-64", + "timestamp": 1535301176024, + "version": "17.3.0" + }, + "cherrypy-17.3.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "99471a09a17ff76bba111597e72bce56", + "name": "cherrypy", + "sha256": "56a5eb6979abd03ca0d8369dca0d41aec7511ca3f2fb1b2f919e1593dc1f1921", + "size": 560253, + "subdir": "linux-64", + "timestamp": 1535301219352, + "version": "17.3.0" + }, + "cherrypy-18.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.5,<3.6.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e7a861f40ef16381f78300f7486d0319", + "name": "cherrypy", + "sha256": "2de97e658001307f43b3447599de4b28c20abe8b70973df4cf2f73956da6d713", + "size": 565552, + "subdir": "linux-64", + "timestamp": 1536109270615, + "version": "18.0.0" + }, + "cherrypy-18.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "460f6adbac94a75f724c901eb5e8061b", + "name": "cherrypy", + "sha256": "d6b37a6b0b54599f4a9137d350d6ed23356f7f07a447ad42349dcd68a1726323", + "size": 560080, + "subdir": "linux-64", + "timestamp": 1536109232616, + "version": "18.0.0" + }, + "cherrypy-18.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2760f5c21ae52838f5158441b7ab48c9", + "name": "cherrypy", + "sha256": "7120c092847ef01a5faf0bd5f3f5ef1677eab99c1fcb46fe0da28dc0bc96a73d", + "size": 560791, + "subdir": "linux-64", + "timestamp": 1536109285532, + "version": "18.0.0" + }, + "cherrypy-18.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e52fa03e02e497ae9fcbf5cb830f6a81", + "name": "cherrypy", + "sha256": "abbdacd6ac783836bacb2c9387a97c56b3a5eaf8b2d2c962ddb581f20fcb799b", + "size": 555699, + "subdir": "linux-64", + "timestamp": 1538175065370, + "version": "18.0.1" + }, + "cherrypy-18.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fd6bf8357fbcb1700e6a4435dd827669", + "name": "cherrypy", + "sha256": "159a23c39bc7d38cc0acd088cc67ac6e7020b3cafaace0b3b4c59bbfddb5808d", + "size": 554079, + "subdir": "linux-64", + "timestamp": 1538175054945, + "version": "18.0.1" + }, + "cherrypy-18.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8d695f7ed5cf6ec889880c742f34e5fd", + "name": "cherrypy", + "sha256": "7ac93702346a39b461a24be87d49d83253efe26043c2313e9aaff686972cb820", + "size": 557504, + "subdir": "linux-64", + "timestamp": 1545103709421, + "version": "18.1.0" + }, + "cherrypy-18.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a6446e07c148b959487b06f3c3a40351", + "name": "cherrypy", + "sha256": "e839121550ae944609ff87b00572240670e0ba121f566790918e431e3c856372", + "size": 581192, + "subdir": "linux-64", + "timestamp": 1545103697506, + "version": "18.1.0" + }, + "cherrypy-18.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ab805c6744c3246c74562cb83dc21f79", + "name": "cherrypy", + "sha256": "36df445058b36c3c9c68b77969dd459e58519cace983d43098d8c21a672763cb", + "size": 579781, + "subdir": "linux-64", + "timestamp": 1556063278934, + "version": "18.1.1" + }, + "cherrypy-18.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "35bd8a70b89047afeaf8c1783b9f6fcf", + "name": "cherrypy", + "sha256": "ccdda2e5244f43dbabf587430dbb0702e4b817bff5a6865c357c1c041070cae7", + "size": 578104, + "subdir": "linux-64", + "timestamp": 1556063376794, + "version": "18.1.1" + }, + "cherrypy-18.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a8dec18d1c0cca92ab258ffd86ddb4b9", + "name": "cherrypy", + "sha256": "96738f694f6b79b487c470ada10d8b1a55bac2ac3ffec3f2a86090371fbe0321", + "size": 575858, + "subdir": "linux-64", + "timestamp": 1569355309673, + "version": "18.2.0" + }, + "cherrypy-18.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c25945f14d8fb2a4b38ceb0a12c315c4", + "name": "cherrypy", + "sha256": "64d06c5a3007349f20d94ea3885d7c7dc46bd8b5b6038e6512d3d6e9bc9ef1aa", + "size": 582335, + "subdir": "linux-64", + "timestamp": 1569355313431, + "version": "18.2.0" + }, + "cherrypy-18.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "955dd2d49199cb7d275f56c357762859", + "name": "cherrypy", + "sha256": "1e66112c30a5c13d609e1a862812645d90c417728558da4af0af171ef2025992", + "size": 564283, + "subdir": "linux-64", + "timestamp": 1574182307880, + "version": "18.2.0" + }, + "cherrypy-18.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4c82fe8c6ce43ea4c396c96dc39df004", + "name": "cherrypy", + "sha256": "a4e62d2c64903776e752f51d01d80e26099e9c16e594a392406f8ad033816cfe", + "size": 587203, + "subdir": "linux-64", + "timestamp": 1574366701685, + "version": "18.4.0" + }, + "cherrypy-18.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e4e1adf1cab910f90a05a3d3e0e99ca7", + "name": "cherrypy", + "sha256": "2b9b4d15b457b4cc780dbe6f7715cf94f46197da241ca0f475926db2ab146a9e", + "size": 594684, + "subdir": "linux-64", + "timestamp": 1574366695145, + "version": "18.4.0" + }, + "cherrypy-18.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ae057d0cab3b7101c51b83f9044c9048", + "name": "cherrypy", + "sha256": "5e963df280385f59a5d581129972a520382b6241c7fb42321dd4c150d49590f6", + "size": 587028, + "subdir": "linux-64", + "timestamp": 1574366807393, + "version": "18.4.0" + }, + "cherrypy-18.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6d012e5a05ea611a3bcd98580f04c414", + "name": "cherrypy", + "sha256": "3dde26c0b40e016bdbd80f12aaea284e2125ca33ccb62b7332cec1c28aea897e", + "size": 590265, + "subdir": "linux-64", + "timestamp": 1585062029167, + "version": "18.5.0" + }, + "cherrypy-18.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "efb5b8155e106ee340b4ff90b2993ba7", + "name": "cherrypy", + "sha256": "f0b3480875f2aed16aa698942642adf2d5760455ca62f3eda79e1b48e4e96593", + "size": 597954, + "subdir": "linux-64", + "timestamp": 1585062034939, + "version": "18.5.0" + }, + "cherrypy-18.5.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "db64ec3c91fbaa91e332340f776cd4ba", + "name": "cherrypy", + "sha256": "41eb8fbe6ccb9c666d33120103a49f8108ac58147c5c74cc67a1bff561fbf8e5", + "size": 595809, + "subdir": "linux-64", + "timestamp": 1585062032195, + "version": "18.5.0" + }, + "cherrypy-18.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.10,<3.11.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e06dea5bfd2599ba8835cf77804ef42b", + "name": "cherrypy", + "sha256": "28478a88bb2a40103796f35acf8e716e34c3027f2d6c14f5a7c73153ac31f0bc", + "size": 585702, + "subdir": "linux-64", + "timestamp": 1640789053832, + "version": "18.6.0" + }, + "cherrypy-18.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "84ca818dd0a040d9e430b9e4b7b987fa", + "name": "cherrypy", + "sha256": "606086f301f7eb9c0ebd5a361c2b7d6e760930309c2ca929ecf3a497f384c10d", + "size": 600043, + "subdir": "linux-64", + "timestamp": 1588080779185, + "version": "18.6.0" + }, + "cherrypy-18.6.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6a758b34b64385721157c922d418782d", + "name": "cherrypy", + "sha256": "971264d378b36891dcb6215ecf4aa3c3d90a688603809b37c17b8dfc122ef4b1", + "size": 590668, + "subdir": "linux-64", + "timestamp": 1614257639375, + "version": "18.6.0" + }, + "cherrypy-18.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7d8cdf04641e1f3dfe2df5bf9a1c0410", + "name": "cherrypy", + "sha256": "0634715980ccbae9fd7c82410f1f4812f428fc2a4a9391e98788730443d1af35", + "size": 585646, + "subdir": "linux-64", + "timestamp": 1588080889281, + "version": "18.6.0" + }, + "cherrypy-18.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "67c096eef5de6578101d2bacbfe9b8be", + "name": "cherrypy", + "sha256": "779ca975683c620febe6034af195828dcd51e75d71eacef38ebac0ecde32d046", + "size": 593305, + "subdir": "linux-64", + "timestamp": 1614257632444, + "version": "18.6.0" + }, + "cherrypy-18.6.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "58c39a8e95d0a94f45fe446e57f4a971", + "name": "cherrypy", + "sha256": "f364f04ae38223a84bf000ace67b97f9cb3cc23013828b3e7deeb62240678e25", + "size": 579426, + "subdir": "linux-64", + "timestamp": 1588080365213, + "version": "18.6.0" + }, + "cherrypy-18.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a78c35301e21c16e63669ea284525d69", + "name": "cherrypy", + "sha256": "1c8aacbab9ecdadd5a347f50e40674cbe51e6eebed26aff7df5d1d6abdf3a059", + "size": 592695, + "subdir": "linux-64", + "timestamp": 1614257619312, + "version": "18.6.0" + }, + "cherrypy-18.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.9,<3.10.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a7b4b5571967bee247c0e3c38a72450e", + "name": "cherrypy", + "sha256": "8ee3d2608a2b45990291fc44e14208454560874785ea22db739be81d470dc107", + "size": 595004, + "subdir": "linux-64", + "timestamp": 1632880794513, + "version": "18.6.0" + }, + "cherrypy-18.8.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.10,<3.11.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b3dd110b3229ce3eb715ecf6d7a6bce3", + "name": "cherrypy", + "sha256": "b53425865fbeeca0be19e9e5f0168815cb4fbe7b96c3f7b9a53285c8cd806a32", + "size": 502819, + "subdir": "linux-64", + "timestamp": 1677013089859, + "version": "18.8.0" + }, + "cherrypy-18.8.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.11,<3.12.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "87fc39d84b213eb47fcaa6c13159090d", + "name": "cherrypy", + "sha256": "fff09e08eed81226574d9f86d835450ca13ce82654fdccf80e579eeab91821bf", + "size": 655359, + "subdir": "linux-64", + "timestamp": 1677014153244, + "version": "18.8.0" + }, + "cherrypy-18.8.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ade970c10ca0c94766355c9e4296a589", + "name": "cherrypy", + "sha256": "6d6c7583dad85c6f109ebb76bd7563cca123ca9f977923688e0c771db1f478b9", + "size": 501854, + "subdir": "linux-64", + "timestamp": 1677013055183, + "version": "18.8.0" + }, + "cherrypy-18.8.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ad450f0f0dc654d3832b2b3abeaf1711", + "name": "cherrypy", + "sha256": "56f191ad5b5f8f592e88efcad5224ef830a56ef4c7759844477a1e7083344d77", + "size": 501932, + "subdir": "linux-64", + "timestamp": 1677013119471, + "version": "18.8.0" + }, + "cherrypy-18.8.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.9,<3.10.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7f61e9f7192b17048e7e927aa52d11b5", + "name": "cherrypy", + "sha256": "2d63d989879bad003eca0917ce1dcf89fa6fa80f8ab9707aab59d48da3bea3bc", + "size": 502181, + "subdir": "linux-64", + "timestamp": 1677013018375, + "version": "18.8.0" + }, + "chest-0.2.3-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "heapdict", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9cea59f1ef41eeb95415a9ed0e0795d7", + "name": "chest", + "sha256": "290c850ed7a7be569a14053825d97744417ef22b0c73e19550a5a9bac85ac362", + "size": 14683, + "subdir": "linux-64", + "timestamp": 1537197814645, + "version": "0.2.3" + }, + "chest-0.2.3-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "heapdict", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d23e2567c03d49e07cc215776bd5f67f", + "name": "chest", + "sha256": "23b0ea081f56d44ded7d17ffbd60fb6dea48d5e7d04405d895177ca92a955b2d", + "size": 15031, + "subdir": "linux-64", + "timestamp": 1537197835075, + "version": "0.2.3" + }, + "chest-0.2.3-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "heapdict", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e150605332e51b24ae195bf740414011", + "name": "chest", + "sha256": "7ca36d6fc4cfa9ec3eb5715d36fa45259c7b179053845d817e1d0ab8dc743655", + "size": 15013, + "subdir": "linux-64", + "timestamp": 1537197837382, + "version": "0.2.3" + }, + "chest-0.2.3-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "heapdict", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4d875d7a2c8e3f6d82365a1a9c1d1ae7", + "name": "chest", + "sha256": "7aa34b6318d4b034dc68930e3b6e98dc831587f73d91b1a6ebe9c8c4042192c9", + "size": 15039, + "subdir": "linux-64", + "timestamp": 1537197789220, + "version": "0.2.3" + }, + "chex-0.1.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.9.0", + "dm-tree >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.21,<2", + "python >=3.10,<3.11.0a0", + "toolz >=0.9.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6d4aabaf3b462aafb2e04d3eaab3bdc7", + "name": "chex", + "sha256": "e080cc42b3537782f539d8a02261d709a167c91594f6a16bc65e42b8de13702f", + "size": 136350, + "subdir": "linux-64", + "timestamp": 1670000795955, + "version": "0.1.5" + }, + "chex-0.1.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.9.0", + "dm-tree >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.21,<2", + "python >=3.11,<3.12.0a0", + "toolz >=0.9.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "daa54780611464b5db198cbd8dee6f4c", + "name": "chex", + "sha256": "5d9b0a4a398e9b60a15834cc86b874bbe392d87cac410387f6ab45a256aa1c6d", + "size": 185993, + "subdir": "linux-64", + "timestamp": 1676843568349, + "version": "0.1.5" + }, + "chex-0.1.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.9.0", + "dm-tree >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.20,<2", + "python >=3.7,<3.8.0a0", + "toolz >=0.9.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "92e717eb31ebce85c7d04b28fbe8e314", + "name": "chex", + "sha256": "4b2727c5aa7ce7441a04fbc7fdb32bd728306d2c55a486bc17db9028785cd1dc", + "size": 132876, + "subdir": "linux-64", + "timestamp": 1670000857248, + "version": "0.1.5" + }, + "chex-0.1.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.9.0", + "dm-tree >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.20,<2", + "python >=3.8,<3.9.0a0", + "toolz >=0.9.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8e26c6e3a28ee238ed2bebaf12eae4a0", + "name": "chex", + "sha256": "dbd82cf7f1ba40644ad94ca3db07d144ce2c7a64c5608fdfe8e36df0b5d78d29", + "size": 134190, + "subdir": "linux-64", + "timestamp": 1670000826879, + "version": "0.1.5" + }, + "chex-0.1.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.9.0", + "dm-tree >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.20,<2", + "python >=3.9,<3.10.0a0", + "toolz >=0.9.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "524428389b6e4cc384287a5ad9de0c98", + "name": "chex", + "sha256": "b745444e1b52be47c922d5999b178cdf061fd397f6fdac82d2702870a2518f9d", + "size": 134962, + "subdir": "linux-64", + "timestamp": 1670000763073, + "version": "0.1.5" + }, + "chromedriver-binary-2.38-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "md5": "4ac57ad5938d1709bf40f697bf073480", + "name": "chromedriver-binary", + "sha256": "bac23c792f9e9fbea6dabe3e28b09f88b92c10699f35796d37edb4b1a8f972db", + "size": 3501195, + "subdir": "linux-64", + "timestamp": 1527559975380, + "version": "2.38" + }, + "ciocheck-0.1.1-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "autopep8", + "coverage", + "flake8", + "isort", + "pydocstyle", + "pylint", + "pytest", + "pytest-cov", + "pytest-json", + "pytest-xdist", + "python >=2.7,<2.8.0a0", + "six", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd0e33cc9c2ae08f7a88bcda014f58c4", + "name": "ciocheck", + "sha256": "0d1672a4b8da69abebbaa62de7a6a17c20082f3a2e3273dc833e04e3bae134ff", + "size": 43759, + "subdir": "linux-64", + "timestamp": 1536869370437, + "version": "0.1.1" + }, + "ciocheck-0.1.1-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "autopep8", + "coverage", + "flake8", + "isort", + "pydocstyle", + "pylint", + "pytest", + "pytest-cov", + "pytest-json", + "pytest-xdist", + "python >=3.5,<3.6.0a0", + "six", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ba13fcf95ce9ead8c97945abb936f26", + "name": "ciocheck", + "sha256": "e53a4652921cbc0720333f687a3ad76c2e5d7b80d1133eae8845397bd830d315", + "size": 44980, + "subdir": "linux-64", + "timestamp": 1536869413211, + "version": "0.1.1" + }, + "ciocheck-0.1.1-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "autopep8", + "coverage", + "flake8", + "isort", + "pydocstyle", + "pylint", + "pytest", + "pytest-cov", + "pytest-json", + "pytest-xdist", + "python >=3.6,<3.7.0a0", + "six", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ea0165ff1b1915cdf61b8c250ce7bdb", + "name": "ciocheck", + "sha256": "c1efea2a977502097b00296181ff72aea5fe4abd8dba1df80b3e99c19b738175", + "size": 44656, + "subdir": "linux-64", + "timestamp": 1536869405309, + "version": "0.1.1" + }, + "ciocheck-0.1.1-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "autopep8", + "coverage", + "flake8", + "isort", + "pydocstyle", + "pylint", + "pytest", + "pytest-cov", + "pytest-json", + "pytest-xdist", + "python >=3.7,<3.8.0a0", + "six", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b14d8f3c07dec5f508a8c9781744bbaf", + "name": "ciocheck", + "sha256": "627c672692eec087bcc43cc9a5cb7e0d9818801b474744f00790c78f7c5e838d", + "size": 44593, + "subdir": "linux-64", + "timestamp": 1536869351846, + "version": "0.1.1" + }, + "clang-10.0.1-default_h658b4fb_2.tar.bz2": { + "build": "default_h658b4fb_2", + "build_number": 2, + "constrains": [ + "clangdev 10.0.1", + "clangxx 10.0.1", + "clang-tools 10.0.1", + "llvm-tools 10.0.1" + ], + "depends": [ + "libclang-cpp10 10.0.1.*", + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "8148281d58fd0384d8f7fea03ea4beb7", + "name": "clang", + "sha256": "91c9848b908b3a360119f99a48fbd663f9a4f92d8b6b1c27c290e9a1b6cb10b4", + "size": 16757847, + "subdir": "linux-64", + "timestamp": 1601485925562, + "version": "10.0.1" + }, + "clang-10.0.1-default_hb85057a_2.tar.bz2": { + "build": "default_hb85057a_2", + "build_number": 2, + "constrains": [ + "clangdev 10.0.1", + "clangxx 10.0.1", + "clang-tools 10.0.1", + "llvm-tools 10.0.1" + ], + "depends": [ + "libclang-cpp10 10.0.1.*", + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "9a20c398b55fb6f636087f20adeadf7e", + "name": "clang", + "sha256": "9da67382c103b2c6b20feb4b0f7939d55a25249f7799ee4cc20c286ebf0b886f", + "size": 16675566, + "subdir": "linux-64", + "timestamp": 1601487856843, + "version": "10.0.1" + }, + "clang-14-14.0.6-default_hc1a23ef_0.tar.bz2": { + "build": "default_hc1a23ef_0", + "build_number": 0, + "constrains": [ + "clang-tools 14.0.6", + "llvm-tools 14.0.6", + "clangxx 14.0.6", + "clangdev 14.0.6" + ], + "depends": [ + "libclang-cpp14 14.0.6 default_hc1a23ef_0", + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "409ef2b1043c8fa89c85f4eb02d5c176", + "name": "clang-14", + "sha256": "fd29dbe7b5c205619c5fe5fa9e97e4acbfd8b73fcbc80054da3ac9cde6d6f740", + "size": 997501, + "subdir": "linux-64", + "timestamp": 1661930327198, + "version": "14.0.6" + }, + "clang-14.0.6-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "clang-14 14.0.6 default_hc1a23ef_0", + "gcc_impl_linux-64" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "d4d4c935caf18158f45bbb1066596fe4", + "name": "clang", + "sha256": "22c16022d6ae56995399b92f9af81d194f8fab81938bb6b3e2899ef393507bab", + "size": 129354, + "subdir": "linux-64", + "timestamp": 1661930354501, + "version": "14.0.6" + }, + "clang-format-14-14.0.6-default_hc1a23ef_0.tar.bz2": { + "build": "default_hc1a23ef_0", + "build_number": 0, + "depends": [ + "libclang-cpp14 >=14.0.6,<14.1.0a0", + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "c6338ec310ed0c95da4fdcd743b7d35e", + "name": "clang-format-14", + "sha256": "eb5a16cc232c8409c8e3ddb8498627b9a98fa114435cece9ec2f997c1b62af32", + "size": 249531, + "subdir": "linux-64", + "timestamp": 1661930430261, + "version": "14.0.6" + }, + "clang-format-14.0.6-default_hc1a23ef_0.tar.bz2": { + "build": "default_hc1a23ef_0", + "build_number": 0, + "depends": [ + "clang-format-14 14.0.6 default_hc1a23ef_0", + "libclang-cpp14 >=14.0.6,<14.1.0a0", + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "89cec803d695f2ca20ca3c4714752b7a", + "name": "clang-format", + "sha256": "7e42f2af7a594c993146b131837a3ea0858d6c2a02492dd2c4ef0120c4692988", + "size": 129756, + "subdir": "linux-64", + "timestamp": 1661930485021, + "version": "14.0.6" + }, + "clang-tools-10.0.1-default_h658b4fb_2.tar.bz2": { + "build": "default_h658b4fb_2", + "build_number": 2, + "constrains": [ + "clangdev 10.0.1" + ], + "depends": [ + "clang 10.0.1 default_h658b4fb_2", + "clangxx 10.0.1 default_h7cdf25a_2", + "libclang 10.0.1.*", + "libclang-cpp10", + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "1cda2097553dd6619563b5e97805db63", + "name": "clang-tools", + "sha256": "ced8de7de77f88a637d9b6e7370cb5509f0d32fb5485af3ab174f43025a60a6d", + "size": 16021730, + "subdir": "linux-64", + "timestamp": 1601486062497, + "version": "10.0.1" + }, + "clang-tools-10.0.1-default_hb85057a_2.tar.bz2": { + "build": "default_hb85057a_2", + "build_number": 2, + "constrains": [ + "clangdev 10.0.1" + ], + "depends": [ + "clang 10.0.1 default_hb85057a_2", + "clangxx 10.0.1 default_hb85057a_2", + "libclang 10.0.1.*", + "libclang-cpp10", + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "da4d705daf47c612b86522096a49d89a", + "name": "clang-tools", + "sha256": "a745019d8d2b9d30e46a08a8071fbceab76a76fa627e83a82030d86e2681816c", + "size": 15842605, + "subdir": "linux-64", + "timestamp": 1601487988256, + "version": "10.0.1" + }, + "clang-tools-14.0.6-default_hc1a23ef_0.tar.bz2": { + "build": "default_hc1a23ef_0", + "build_number": 0, + "constrains": [ + "clangdev 14.0.6" + ], + "depends": [ + "clang-format 14.0.6 default_hc1a23ef_0", + "libclang >=14.0.6,<14.1.0a0", + "libclang-cpp14 >=14.0.6,<14.1.0a0", + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "e713cd4d652aaff4cbaaec5f47474998", + "name": "clang-tools", + "sha256": "2d8ea8a69f4f8c3b93fd13da369c18bbf63340fd298a9ad7c70064b8f08c1af6", + "size": 19105192, + "subdir": "linux-64", + "timestamp": 1661930506777, + "version": "14.0.6" + }, + "clang_win-64-14.0.6-hc402f9b_0.tar.bz2": { + "build": "hc402f9b_0", + "build_number": 0, + "depends": [ + "clangxx 14.0.6.*", + "compiler-rt 14.0.6.*", + "compiler-rt_win-64 14.0.6.*", + "lld 14.0.6.*", + "llvm-tools 14.0.6.*", + "msvc-headers-libs >=14.15.26706,<14.15.26707.0a0", + "winsdk >=10.0.17763.0,<10.0.17764.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ac0a600fbe85a41e9b41091cbcc505d6", + "name": "clang_win-64", + "sha256": "0b5a8de8bd1fefe5030db05cdb0e98d5d7a6af5c2ffeede233121218e9e6bc24", + "size": 23957, + "subdir": "linux-64", + "timestamp": 1668352710185, + "version": "14.0.6" + }, + "clangdev-10.0.1-default_h658b4fb_2.tar.bz2": { + "build": "default_h658b4fb_2", + "build_number": 2, + "depends": [ + "clang 10.0.1 default_h658b4fb_2", + "clang-tools 10.0.1 default_h658b4fb_2", + "clangxx 10.0.1 default_h7cdf25a_2", + "libclang 10.0.1 default_h658b4fb_2", + "libclang-cpp 10.0.1 default_h658b4fb_2", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmdev 10.0.1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "3c20fd31d0e37a892ddc985867864e89", + "name": "clangdev", + "sha256": "6524a4287cb4b887e0cdedbc8921b4cd390bacdd68ba8e85b047836474376ad2", + "size": 55989778, + "subdir": "linux-64", + "timestamp": 1601486108091, + "version": "10.0.1" + }, + "clangdev-10.0.1-default_hb85057a_2.tar.bz2": { + "build": "default_hb85057a_2", + "build_number": 2, + "depends": [ + "clang 10.0.1 default_hb85057a_2", + "clang-tools 10.0.1 default_hb85057a_2", + "clangxx 10.0.1 default_hb85057a_2", + "libclang 10.0.1 default_hb85057a_2", + "libclang-cpp 10.0.1 default_hb85057a_2", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmdev 10.0.1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "87976b1299af8fd30a3f0b812ce87373", + "name": "clangdev", + "sha256": "9f406eed4973b4a74ebe59fffa0c364ef8ce8c85ff9dbdff182c3d807302709b", + "size": 56022651, + "subdir": "linux-64", + "timestamp": 1601488023578, + "version": "10.0.1" + }, + "clangdev-14.0.6-default_hc1a23ef_0.tar.bz2": { + "build": "default_hc1a23ef_0", + "build_number": 0, + "depends": [ + "clang 14.0.6 h06a4308_0", + "clang-tools 14.0.6 default_hc1a23ef_0", + "clangxx 14.0.6 default_hc6dbbc7_0", + "libclang 14.0.6 default_hc1a23ef_0", + "libclang-cpp 14.0.6 default_hc1a23ef_0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "llvmdev 14.0.6", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "66cc236a2c488cb2d784741dd5d10f11", + "name": "clangdev", + "sha256": "992add166f50ccb0f13db6297311753afa9fc24ba616b1fb026768ff1a02c286", + "size": 69462402, + "subdir": "linux-64", + "timestamp": 1661930538906, + "version": "14.0.6" + }, + "clangxx-10.0.1-default_h7cdf25a_2.tar.bz2": { + "build": "default_h7cdf25a_2", + "build_number": 2, + "depends": [ + "clang 10.0.1 default_h658b4fb_2", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "cd8aec3217a1401a69b00cadac43e3af", + "name": "clangxx", + "sha256": "6b88ddbaa39523ede95e6a3101c90675ae80eab2f2bd744c5f7c173cb6880f6f", + "size": 223131, + "subdir": "linux-64", + "timestamp": 1601485988617, + "version": "10.0.1" + }, + "clangxx-10.0.1-default_hb85057a_2.tar.bz2": { + "build": "default_hb85057a_2", + "build_number": 2, + "depends": [ + "clang 10.0.1 default_hb85057a_2", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "3d2c2c7bd86a90e84094e7ec2ceba24f", + "name": "clangxx", + "sha256": "243cf11b5375d1c0e208044a28617c33bddd369b364aa7e73ad1c59272515e1d", + "size": 134675, + "subdir": "linux-64", + "timestamp": 1601487915127, + "version": "10.0.1" + }, + "clangxx-14.0.6-default_hc6dbbc7_0.tar.bz2": { + "build": "default_hc6dbbc7_0", + "build_number": 0, + "depends": [ + "clang 14.0.6 h06a4308_0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "faa54145178822df1567d971afed9db4", + "name": "clangxx", + "sha256": "0d51b71220013ccd955719022609f4548e490c7ba76edcc07fc8e3a004a8829d", + "size": 129213, + "subdir": "linux-64", + "timestamp": 1661930362206, + "version": "14.0.6" + }, + "cleo-2.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "crashtest >=0.4.1,<0.5.0", + "python >=3.10,<3.11.0a0", + "rapidfuzz >=2.2.0,<3.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a2a0dd0ae19f331fba5c833998c89267", + "name": "cleo", + "sha256": "7e29d859ce037889a04bbc6e5feb7459a2ebaf9b5ee84cddad7a8cefb2ccc743", + "size": 121637, + "subdir": "linux-64", + "timestamp": 1679610039500, + "version": "2.0.1" + }, + "cleo-2.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "crashtest >=0.4.1,<0.5.0", + "python >=3.11,<3.12.0a0", + "rapidfuzz >=2.2.0,<3.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea2696324aa45b1e0f060e528bcd8d3e", + "name": "cleo", + "sha256": "966c2da1113398a5e479755805b049a138884cf6110aaab5315f560236fd7de8", + "size": 158764, + "subdir": "linux-64", + "timestamp": 1679610007778, + "version": "2.0.1" + }, + "cleo-2.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "crashtest >=0.4.1,<0.5.0", + "python >=3.8,<3.9.0a0", + "rapidfuzz >=2.2.0,<3.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d5006d927a1ab600f9d56035b52de8b", + "name": "cleo", + "sha256": "137fdf796a9eadccbb25cc012f1f31d50dae905ae7842fb999b3bc219f07b0dc", + "size": 120000, + "subdir": "linux-64", + "timestamp": 1679610069630, + "version": "2.0.1" + }, + "cleo-2.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "crashtest >=0.4.1,<0.5.0", + "python >=3.9,<3.10.0a0", + "rapidfuzz >=2.2.0,<3.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87f5100f3649a69138f0c2b5e14f38e9", + "name": "cleo", + "sha256": "09272c2addc38ba6ff3cef4397d35564c2e51bbde279cd3257a9a48c70576bc0", + "size": 119972, + "subdir": "linux-64", + "timestamp": 1679610099523, + "version": "2.0.1" + }, + "cli11-2.1.2-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e5df39115087d2dcb19901ef6e7f7242", + "name": "cli11", + "sha256": "a01fcf7bc800142c8691cc84c42abaccdbe21eee81c562d8f491843f666423f0", + "size": 69632, + "subdir": "linux-64", + "timestamp": 1646233473772, + "version": "2.1.2" + }, + "click-6.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f80c58f8864b1d0b926701f8cd8af98d", + "name": "click", + "sha256": "4498b82abed302e9f264221c3642461725c2aaf7cc5e0a06d472b0578f6a5cbe", + "size": 105185, + "subdir": "linux-64", + "timestamp": 1530741489137, + "version": "6.7" + }, + "click-6.7-py27h4225b90_0.tar.bz2": { + "build": "py27h4225b90_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0bd26df9e3d536b6bafb0633d93b8b5e", + "name": "click", + "sha256": "cefef80840a3fdb77667ecdae16029c853b5b97932712932d8b45e83d591c16b", + "size": 104975, + "subdir": "linux-64", + "timestamp": 1505733208892, + "version": "6.7" + }, + "click-6.7-py35h353a69f_0.tar.bz2": { + "build": "py35h353a69f_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3cb898b458fe28afb3f955d54e1cb1ef", + "name": "click", + "sha256": "148f54d7b32e206935ac6a80e67d1d92a157538b6c217db8757c022930af136c", + "size": 107406, + "subdir": "linux-64", + "timestamp": 1505733221436, + "version": "6.7" + }, + "click-6.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c039d354c1a546569bb1f7f388d1b27b", + "name": "click", + "sha256": "b5c40400af0c3c82ad3a6094656baaa627566dd587dafb6f203546b383efdc7d", + "size": 107066, + "subdir": "linux-64", + "timestamp": 1530741467249, + "version": "6.7" + }, + "click-6.7-py36h5253387_0.tar.bz2": { + "build": "py36h5253387_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4929a930f8e97eaaf716e00b9c74fef3", + "name": "click", + "sha256": "90af402bc1cd9cb08c9c1bdbd05910671a1779df20534e3c35157865d8f67d60", + "size": 106893, + "subdir": "linux-64", + "timestamp": 1505733234112, + "version": "6.7" + }, + "click-6.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0c2c72d0f9b1fe9e264110ace39210f9", + "name": "click", + "sha256": "2cad4e4548dde94e56c1175655eac3dce16fdb3747dcdb18384c6666070dd285", + "size": 107120, + "subdir": "linux-64", + "timestamp": 1530741512018, + "version": "6.7" + }, + "click-7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ed295294cc1a9f258b4804eaa61ed58d", + "name": "click", + "sha256": "bb42e42a231220c95a0eb9a141694466216765a160056d5daaafdf74ca01e120", + "size": 118904, + "subdir": "linux-64", + "timestamp": 1538599063028, + "version": "7.0" + }, + "click-7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e09908fe5f683c471027f4722a506d7e", + "name": "click", + "sha256": "af55be833fb00dc63bb439d17313417d353ccb9240b97e874362ac621427b0de", + "size": 121045, + "subdir": "linux-64", + "timestamp": 1538599056995, + "version": "7.0" + }, + "click-7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e650ebf60660e6fae0ea24e788ed2281", + "name": "click", + "sha256": "1070961e8e776307869313325a2e091869d70e79de7adfb64b48d489f8ae9113", + "size": 121075, + "subdir": "linux-64", + "timestamp": 1538599032841, + "version": "7.0" + }, + "click-8.0.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "be85892f8ab55ae386e6202f0cee928c", + "name": "click", + "sha256": "2ea857ab39e2b0655d9c1c55dc529cf7535919cd2267c278cda36d18501fb687", + "size": 156168, + "subdir": "linux-64", + "timestamp": 1646056747929, + "version": "8.0.4" + }, + "click-8.0.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2bca88ed078b4969f870954a2ff11429", + "name": "click", + "sha256": "ec279cfb92a30927c1bb4606296c2e66241f4056946a6dc194efbe99403b8757", + "size": 201672, + "subdir": "linux-64", + "timestamp": 1676825175185, + "version": "8.0.4" + }, + "click-8.0.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "95ad323b2f2ef485dad52f9405ef06b0", + "name": "click", + "sha256": "a1a988b1278f2e48d185868f719e07a312da81d89868ab5156e376ac7e37d21d", + "size": 152238, + "subdir": "linux-64", + "timestamp": 1646056620858, + "version": "8.0.4" + }, + "click-8.0.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c7eb37a81b7b5bb04bd2437417f7ee0b", + "name": "click", + "sha256": "4f008a7c5eb74ee2aa3597bfbe63ccb0755063e1cb52aeb1d1e65e22edfd247a", + "size": 153342, + "subdir": "linux-64", + "timestamp": 1646038492813, + "version": "8.0.4" + }, + "click-8.0.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "34726366b02828dd11ec10569ce67676", + "name": "click", + "sha256": "6d7a3b69dd764940f74a00163cbd1c869c5dc6bdba093b381c0cf1e11e7bf5b8", + "size": 153623, + "subdir": "linux-64", + "timestamp": 1646056616713, + "version": "8.0.4" + }, + "click-default-group-1.2.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8355b42ef19a3a7b7855d693d743fad9", + "name": "click-default-group", + "sha256": "172708ac813c1226084295b1c6662b038b67933553f6749d7dddfd392f74cfd1", + "size": 9758, + "subdir": "linux-64", + "timestamp": 1676366363293, + "version": "1.2.2" + }, + "click-default-group-1.2.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee626936d626ddf05f9357b37e03b2c7", + "name": "click-default-group", + "sha256": "4f5fcbdc6c9b2a42f2e2f25b34c6c60ed66c0e3c0350a4c226511690644952bb", + "size": 10927, + "subdir": "linux-64", + "timestamp": 1679339621946, + "version": "1.2.2" + }, + "click-default-group-1.2.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1e00219dca783d9716991da710b75c0", + "name": "click-default-group", + "sha256": "f3c593ffd862d9e9308758df8a09501007ca5b4550fe5a76b7fb7a1a3a2fe7ec", + "size": 9685, + "subdir": "linux-64", + "timestamp": 1676366388789, + "version": "1.2.2" + }, + "click-default-group-1.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fbea73d6488b26bfe939798515a2d4f6", + "name": "click-default-group", + "sha256": "b98701d4508fd0c58875dbd1652780415e83d06e177900a33c18f5445296c873", + "size": 9723, + "subdir": "linux-64", + "timestamp": 1676366414277, + "version": "1.2.2" + }, + "click-default-group-1.2.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7a227b6a2987a34fb19f288b98d4423f", + "name": "click-default-group", + "sha256": "fc7da4ed871589a3c0a4949fd1878aa747b303434d122dd64683c3d6e86c454b", + "size": 9724, + "subdir": "linux-64", + "timestamp": 1676366337872, + "version": "1.2.2" + }, + "click-plugins-1.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5e5092d19537eaf0cbcedf5e35e18ac5", + "name": "click-plugins", + "sha256": "00cf541177cb6f5918e2c566f641e130d6d7bdc1c60ed0011b260749152313eb", + "size": 9877, + "subdir": "linux-64", + "timestamp": 1530812149468, + "version": "1.0.3" + }, + "click-plugins-1.0.3-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "click >=3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9c8c0a4a4774c3aa462f2b527b90dedf", + "name": "click-plugins", + "sha256": "f5690322203e36218617c000942edeb30d1352697dd203d26abadd1dbec60dba", + "size": 9958, + "subdir": "linux-64", + "timestamp": 1536261772021, + "version": "1.0.3" + }, + "click-plugins-1.0.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6a5466d7fc0aaeea095560dc96beb321", + "name": "click-plugins", + "sha256": "ede3c04e5aef0e5aff14ff6110b58250e9281fbe7c6e280e53de5733c35bda8e", + "size": 10047, + "subdir": "linux-64", + "timestamp": 1535130001359, + "version": "1.0.3" + }, + "click-plugins-1.0.3-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "click >=3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a0f2b4d35f3e05a33ca3069a67ed88b6", + "name": "click-plugins", + "sha256": "4109f92e084816c689331112a8d96b8848e24af1ada6765fadd6b20a9c5cecc4", + "size": 10022, + "subdir": "linux-64", + "timestamp": 1536261843766, + "version": "1.0.3" + }, + "click-plugins-1.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "418f33303b9415dcf6de7ee3eee78b9a", + "name": "click-plugins", + "sha256": "4d8b5812dbd09fd694508747072abf821d5be80423583e15e7ca3a2dc19a36ca", + "size": 9959, + "subdir": "linux-64", + "timestamp": 1530812198015, + "version": "1.0.3" + }, + "click-plugins-1.0.3-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "click >=3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "aea50f6441a8fbf9b8988489cc13a0a0", + "name": "click-plugins", + "sha256": "a1a28defea6f0aaf8673babb5689012431c9c9a9d0739f85d7219c40e95755a5", + "size": 10029, + "subdir": "linux-64", + "timestamp": 1536261658956, + "version": "1.0.3" + }, + "click-plugins-1.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b60b4c864f1b355f71e25772ea0e5f42", + "name": "click-plugins", + "sha256": "3f5944d8bd5301c61ce6c4b8807de741efae4039fcf85f5a8d406d8bbd294273", + "size": 9959, + "subdir": "linux-64", + "timestamp": 1530812173192, + "version": "1.0.3" + }, + "click-plugins-1.0.3-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "click >=3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "97049dbd7fff27dc2abe52b1bbd5f11e", + "name": "click-plugins", + "sha256": "9af362cb49901ac4cd8146818f8f1226891e6c745e36d36ef66506f9b5700895", + "size": 10040, + "subdir": "linux-64", + "timestamp": 1536261878556, + "version": "1.0.3" + }, + "click-plugins-1.0.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5216e8b433c769a1343a422fbc373354", + "name": "click-plugins", + "sha256": "9012453bc8084f9e2fc051f52bba2a17010819bbb520a4941001ef598ac8224d", + "size": 10155, + "subdir": "linux-64", + "timestamp": 1539471838852, + "version": "1.0.4" + }, + "click-plugins-1.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "75dc2521b30ac218a8a12c312493d91b", + "name": "click-plugins", + "sha256": "75d81b58e8ad0cc390c0f9fcc7ed999287538be2b3ed6a010929b623f0b1a441", + "size": 10232, + "subdir": "linux-64", + "timestamp": 1539471847673, + "version": "1.0.4" + }, + "click-plugins-1.0.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9b7be33e3dc0b32d241c7bef6aebd243", + "name": "click-plugins", + "sha256": "707580eb8e53c6cacb16cc8972b88d9076a141bcc7e6fc8fb13c5e3643eacc3b", + "size": 10223, + "subdir": "linux-64", + "timestamp": 1539471853897, + "version": "1.0.4" + }, + "clickhouse-cityhash-1.0.2.3-py310h295c915_2.tar.bz2": { + "build": "py310h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9596f6e7a5d67d396f805d2986753f76", + "name": "clickhouse-cityhash", + "sha256": "5b5b6bc53099b055fd95d93dc8f4beb89db27b916ad42a34f31d20585a2179ea", + "size": 83842, + "subdir": "linux-64", + "timestamp": 1640789078822, + "version": "1.0.2.3" + }, + "clickhouse-cityhash-1.0.2.3-py36h2531618_2.tar.bz2": { + "build": "py36h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2838e5b8253868ce0b417f568a269233", + "name": "clickhouse-cityhash", + "sha256": "8dadcadd4c538fba7f49193f7a1e86c37cb98f27a8fe310f9ee6c676b21416d0", + "size": 28733, + "subdir": "linux-64", + "timestamp": 1606150616715, + "version": "1.0.2.3" + }, + "clickhouse-cityhash-1.0.2.3-py37h2531618_2.tar.bz2": { + "build": "py37h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e2691f50165e4caa4d8c8d223939aa86", + "name": "clickhouse-cityhash", + "sha256": "bc7da6c6e2fd880dda544c65138781985f38ff156933637787a093cd02386132", + "size": 28711, + "subdir": "linux-64", + "timestamp": 1606150617265, + "version": "1.0.2.3" + }, + "clickhouse-cityhash-1.0.2.3-py38h2531618_2.tar.bz2": { + "build": "py38h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98c3bf4df0452b146b78f0f9888998bc", + "name": "clickhouse-cityhash", + "sha256": "4beb380aaccc286bc05da3ae9cf7e37cae2e003d035725f2440c18082efb19c7", + "size": 29051, + "subdir": "linux-64", + "timestamp": 1606150623060, + "version": "1.0.2.3" + }, + "clickhouse-cityhash-1.0.2.3-py39h2531618_2.tar.bz2": { + "build": "py39h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34d8334b902d6d37c2bf08b9d8a5dc10", + "name": "clickhouse-cityhash", + "sha256": "20eef797e8e1ab7662055e6cc5f14d3940c10778ff78b1fa32f20797f9c15201", + "size": 28863, + "subdir": "linux-64", + "timestamp": 1606150608041, + "version": "1.0.2.3" + }, + "clickhouse-cityhash-1.0.2.4-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e92f6cdce2feac663eae0a1db71ae0f2", + "name": "clickhouse-cityhash", + "sha256": "4e1e7c43a9d0ac3d89e6be7c09e5d0aa8b87698e51103e4d5a8940c12f3d4b43", + "size": 25881, + "subdir": "linux-64", + "timestamp": 1674745971274, + "version": "1.0.2.4" + }, + "clickhouse-cityhash-1.0.2.4-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6fda26c8d878d139ed5c6a7438e9dd4c", + "name": "clickhouse-cityhash", + "sha256": "77327ffb36ba0e29dc0bd717e266325adf3b0b1296d3b0762e7f14551022a650", + "size": 27039, + "subdir": "linux-64", + "timestamp": 1676851284966, + "version": "1.0.2.4" + }, + "clickhouse-cityhash-1.0.2.4-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ac9350f6ae978eb5124130e58ee0157", + "name": "clickhouse-cityhash", + "sha256": "dd405c057f89971373dc712c1fc4c28660d0193e90587cd6a7ba7a9e3ef73b4f", + "size": 25788, + "subdir": "linux-64", + "timestamp": 1674746061889, + "version": "1.0.2.4" + }, + "clickhouse-cityhash-1.0.2.4-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d96628541e7da60e4b7c2e7cadf7b794", + "name": "clickhouse-cityhash", + "sha256": "5d7cb018219c93f76d61d40b9fe92523cc8dffa1c5e39b7a3ece7c8025b6cc5a", + "size": 26216, + "subdir": "linux-64", + "timestamp": 1674746031364, + "version": "1.0.2.4" + }, + "clickhouse-cityhash-1.0.2.4-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3fdfa59ed7d999931865b348fed6974b", + "name": "clickhouse-cityhash", + "sha256": "0d4a8f3430d5d21ea617f7faa5dd95a2030e317c4b67954c0d67c1d648bb89e9", + "size": 26088, + "subdir": "linux-64", + "timestamp": 1674746001400, + "version": "1.0.2.4" + }, + "clickhouse-driver-0.1.5-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fcb7b4eea9b81e2f10890713c56309b4", + "name": "clickhouse-driver", + "sha256": "d6567fc2716b6320da1612bf9b1ad0d5940ec176fddf9f05d69084a88798a273", + "size": 207355, + "subdir": "linux-64", + "timestamp": 1606150793954, + "version": "0.1.5" + }, + "clickhouse-driver-0.1.5-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "acc38cb8a295bea4e83fd549097ff85c", + "name": "clickhouse-driver", + "sha256": "57469fdbc03e7f576b30f3d14fff65a330a09b3e7ccef66777884ed6523c6715", + "size": 207132, + "subdir": "linux-64", + "timestamp": 1606150815976, + "version": "0.1.5" + }, + "clickhouse-driver-0.1.5-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e07f0e655720c9320e0b4da905344d2", + "name": "clickhouse-driver", + "sha256": "bda77508b2cb1e352dc458d2b8744dba804d4e30597acea12df31ed34751f92b", + "size": 215737, + "subdir": "linux-64", + "timestamp": 1606150811835, + "version": "0.1.5" + }, + "clickhouse-driver-0.2.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc5ef5ebc6a8356fa8314cfd5ac8f027", + "name": "clickhouse-driver", + "sha256": "bd8010cdde4c7e5f25d1c08a7f10f4c7893893fe0cee2ae95472eb5b79eac06a", + "size": 182482, + "subdir": "linux-64", + "timestamp": 1608229092929, + "version": "0.2.0" + }, + "clickhouse-driver-0.2.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d7521e412864a801fb57953f325c9fc0", + "name": "clickhouse-driver", + "sha256": "4ca5b26b59f88c2290498f7d13c3dffab36572e51da3f6f2df1a32c5c79a58ca", + "size": 183029, + "subdir": "linux-64", + "timestamp": 1608229046476, + "version": "0.2.0" + }, + "clickhouse-driver-0.2.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6de489b0a06477aa0241e41bddd6527", + "name": "clickhouse-driver", + "sha256": "05dfaa475043c4bcdb0d328337f7b611afebe83cf2079c06c72649c3cf13ec74", + "size": 192628, + "subdir": "linux-64", + "timestamp": 1608229096167, + "version": "0.2.0" + }, + "clickhouse-driver-0.2.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "59a7c08e65c77acc185ef1d66f14aa64", + "name": "clickhouse-driver", + "sha256": "71e7886989fe79c4c3134ac0ae75eb1378692230fcab12c9385cdc4104f057dc", + "size": 191975, + "subdir": "linux-64", + "timestamp": 1608246516063, + "version": "0.2.0" + }, + "clickhouse-driver-0.2.1-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "pytz", + "six", + "tzlocal <3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e956ec076348e73c06a98cf3f4a6a46", + "name": "clickhouse-driver", + "sha256": "4ae688eeb544b2888a1e1d544ac53f82cd8ecfcff9784f031805ded99fbbe9ed", + "size": 608443, + "subdir": "linux-64", + "timestamp": 1640803906405, + "version": "0.2.1" + }, + "clickhouse-driver-0.2.1-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "pytz", + "six", + "tzlocal <3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eea484ef5603240877bfac230c94acab", + "name": "clickhouse-driver", + "sha256": "f62577bae528530b3c8eef10544fcd2d8e1be860e14dddc4e3a8a3fac784d899", + "size": 248976, + "subdir": "linux-64", + "timestamp": 1676851309143, + "version": "0.2.1" + }, + "clickhouse-driver-0.2.1-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8957c1e90ee3abde221476c8dee8c8fc", + "name": "clickhouse-driver", + "sha256": "ff3d0fad51b571459a1c6d6ec60d6e023f9d4f55d236bef5c112eb08aa0bad8c", + "size": 200645, + "subdir": "linux-64", + "timestamp": 1622753230923, + "version": "0.2.1" + }, + "clickhouse-driver-0.2.1-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d90084490d6c3dd23e7246de3c407127", + "name": "clickhouse-driver", + "sha256": "c43877c157147ea555ab02f274e95d56cc5e65636b349119f03a9e6f651715aa", + "size": 201278, + "subdir": "linux-64", + "timestamp": 1622758518809, + "version": "0.2.1" + }, + "clickhouse-driver-0.2.1-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "feabfacf3b41641892d26e32a0890fe9", + "name": "clickhouse-driver", + "sha256": "a846ed76085fea4b09141ef17a1acb30a6e1b68c8aee3691598b9f681cb844b9", + "size": 212166, + "subdir": "linux-64", + "timestamp": 1622753219217, + "version": "0.2.1" + }, + "clickhouse-driver-0.2.1-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz", + "six", + "tzlocal <3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5106e21867d3f1877943a287f9b61928", + "name": "clickhouse-driver", + "sha256": "2483cf47f4958d263b19357947a21598fe9be40657664facb4fbdb0f02fe562c", + "size": 211551, + "subdir": "linux-64", + "timestamp": 1623054762548, + "version": "0.2.1" + }, + "cligj-0.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0051893b783e86aaef5d721d2d2fbb8a", + "name": "cligj", + "sha256": "6c4fffe43570261fb9c83233733ad11bad975dcc5744527e7d065ead59a4949b", + "size": 14632, + "subdir": "linux-64", + "timestamp": 1530812221968, + "version": "0.4.0" + }, + "cligj-0.4.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "click >=4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "447034c8d611be47c1894783b387a10b", + "name": "cligj", + "sha256": "ff3e66c78822d5a643c44cad316427da25cb1a4e1e1c743fbf5400c41ec79391", + "size": 14736, + "subdir": "linux-64", + "timestamp": 1536261674257, + "version": "0.4.0" + }, + "cligj-0.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "63b3175b4d7d7b2b34d0d81d80e0a481", + "name": "cligj", + "sha256": "d21e836518c8f638f1c9b012b515d016326eab74d01f650c6f57c4f732fe2297", + "size": 14927, + "subdir": "linux-64", + "timestamp": 1535130026653, + "version": "0.4.0" + }, + "cligj-0.4.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "click >=4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dd636e787dab50f564113e3f0f79b325", + "name": "cligj", + "sha256": "4c7661982ca0ac6f63cf652e7f763e5479b7500182ded6cc7516457cb3076ab5", + "size": 14957, + "subdir": "linux-64", + "timestamp": 1536261732927, + "version": "0.4.0" + }, + "cligj-0.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ccfa0b483642f685b57dc06f98f6343d", + "name": "cligj", + "sha256": "7381cbd4bd0c88a7c1fff4ad27360ec5b61ba48647c4f9a7bf29c1e7a8576178", + "size": 14813, + "subdir": "linux-64", + "timestamp": 1530812269796, + "version": "0.4.0" + }, + "cligj-0.4.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "click >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "536a1c141985a8d9621d612db4f862f7", + "name": "cligj", + "sha256": "b3a1fbc8faf8c66eb072fbe96c1def8a4b8b4780f2a88edbe847c513947efdcd", + "size": 14923, + "subdir": "linux-64", + "timestamp": 1536261661043, + "version": "0.4.0" + }, + "cligj-0.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0468fcc44db3712bf3531f9ed7657670", + "name": "cligj", + "sha256": "2f489bdd144b6b6389ee91dbcebb6d35ec38efbb443443d567bca6daeeecebe0", + "size": 14813, + "subdir": "linux-64", + "timestamp": 1530812245512, + "version": "0.4.0" + }, + "cligj-0.4.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "click >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "33824547b9c122391bad947486db40b6", + "name": "cligj", + "sha256": "5c486b1754d39142821b62d1d71440c4453faf37f9a5f107f726ac378f8242bf", + "size": 14905, + "subdir": "linux-64", + "timestamp": 1536261780556, + "version": "0.4.0" + }, + "cligj-0.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a6f7224e4e08a40ac3377affa923b8dd", + "name": "cligj", + "sha256": "bd065c3fecc8503bfb4644d3a9638de470290026ae2bd0c2bfde06894a7f5c90", + "size": 12066, + "subdir": "linux-64", + "timestamp": 1539472064559, + "version": "0.5.0" + }, + "cligj-0.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f980a5b76f98ac408d8e7ca351fa2db9", + "name": "cligj", + "sha256": "1a0eae5a2979d103c4d38b2e88934d129a5fc5616bb2857193906df994387eb0", + "size": 12134, + "subdir": "linux-64", + "timestamp": 1539472095738, + "version": "0.5.0" + }, + "cligj-0.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "54c2acb60225517b9eda79dae6e9fe5a", + "name": "cligj", + "sha256": "f8cd40786a6d75d1734c9052c2788f4e405b0dea40522252dbe5ac2d8bc83448", + "size": 12174, + "subdir": "linux-64", + "timestamp": 1539472104637, + "version": "0.5.0" + }, + "cligj-0.5.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "98e8b3a01aea5ef6dbd89a63fa3f4cca", + "name": "cligj", + "sha256": "16ee26bcf70466cd47c1c8e0e54064ae7fba9e94b78e69e84746ff684d21ca66", + "size": 12340, + "subdir": "linux-64", + "timestamp": 1573741534837, + "version": "0.5.0" + }, + "cligj-0.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "11f272eb43062e6ba3b0b0e26f939bfb", + "name": "cligj", + "sha256": "9c06e21529aa5ef52868695cc4ed9dc05185002b5e5a06ad3d4692d7c11a9890", + "size": 12529, + "subdir": "linux-64", + "timestamp": 1603211118835, + "version": "0.6.0" + }, + "cligj-0.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e456b8368253017a4988dfc7f01b8ada", + "name": "cligj", + "sha256": "fd7f33365167f51f55ac4935ebddf318521dd38f80080c654fe5e2911f21602f", + "size": 12545, + "subdir": "linux-64", + "timestamp": 1603211127700, + "version": "0.6.0" + }, + "cligj-0.6.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "639176e88d1a2773a153f39dd90e0a48", + "name": "cligj", + "sha256": "37cae44471e3d3294325521f1efb48e29ab654b370f402b271c3b004a773a098", + "size": 12559, + "subdir": "linux-64", + "timestamp": 1603211124625, + "version": "0.6.0" + }, + "cligj-0.7.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a93695fbb09fe452489ad6d61079df2a", + "name": "cligj", + "sha256": "3b66a51f98d92cbe6d98ae77371dcfa6274ac9861444b7e921f43589faee1209", + "size": 12870, + "subdir": "linux-64", + "timestamp": 1603821810573, + "version": "0.7.0" + }, + "cligj-0.7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "805ca71b6fc3d3a63f5b7b2ea82a77ac", + "name": "cligj", + "sha256": "ac5384754abf03d269010707a1bfec295defb4f07f202b6a232bc36d53342ae7", + "size": 12804, + "subdir": "linux-64", + "timestamp": 1603487582976, + "version": "0.7.0" + }, + "cligj-0.7.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9ec578e6cc38ff3eeae411ea32780be7", + "name": "cligj", + "sha256": "803c85ffe54b386a093a3604b9690ea8cad827bfef55ae7725d423fbc8217a0f", + "size": 12843, + "subdir": "linux-64", + "timestamp": 1603821848400, + "version": "0.7.0" + }, + "cligj-0.7.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "95274eb7e6060c259341bff82e080027", + "name": "cligj", + "sha256": "f829afc9fb1470796e3acec72baf2cfc7b42de968b1084d63de7369664f3f19b", + "size": 12835, + "subdir": "linux-64", + "timestamp": 1603721945093, + "version": "0.7.0" + }, + "cligj-0.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a51d768a9ff8024e5a2e12183515243b", + "name": "cligj", + "sha256": "08913a9fc81287614aa9eb9fb04ff18cdffef7cfce5f3eb7b6658ecf984109b9", + "size": 12848, + "subdir": "linux-64", + "timestamp": 1603821844890, + "version": "0.7.0" + }, + "cligj-0.7.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fca0ad77589ff51771b219d8ea03ace5", + "name": "cligj", + "sha256": "e4c43178cc67b90363a566d207d5a5b521e647dbb79ca4c906b9d0a6b3e79851", + "size": 12897, + "subdir": "linux-64", + "timestamp": 1605996049981, + "version": "0.7.1" + }, + "cligj-0.7.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4b30a374e7e4e488e1dcf2593447323d", + "name": "cligj", + "sha256": "84cb2d0f227626173be78def725533bee4895894452f374ffe4a62f6da3ca7c1", + "size": 12913, + "subdir": "linux-64", + "timestamp": 1605996074069, + "version": "0.7.1" + }, + "cligj-0.7.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "faa582525b7794bfc116ef5b76dc13e3", + "name": "cligj", + "sha256": "43306bc2f6af04de9a6d9e28e71f451ca65a871e2ff4789e0c044bc01bcf7d81", + "size": 12872, + "subdir": "linux-64", + "timestamp": 1605996053751, + "version": "0.7.1" + }, + "cligj-0.7.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "38e2a79de09f052e137fe3af869af7f8", + "name": "cligj", + "sha256": "910998b8c7360d03108d4934649b66ccea0e3d68413c90cda751b2ad1f271eed", + "size": 12923, + "subdir": "linux-64", + "timestamp": 1605996040272, + "version": "0.7.1" + }, + "cligj-0.7.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "372c7e7f15f42ab1b7211943e9351fb7", + "name": "cligj", + "sha256": "f45b1fae6e00466d9b5a280df1b910e15c79393376f1b69b20e9607ca767230c", + "size": 12894, + "subdir": "linux-64", + "timestamp": 1622490976388, + "version": "0.7.2" + }, + "cligj-0.7.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "72fe0ad02ec22840eb91505a0076d457", + "name": "cligj", + "sha256": "a703e1dc611b778508e682f49407957ba1d41dfd10881336ffe17ac979fc19b1", + "size": 12880, + "subdir": "linux-64", + "timestamp": 1622490977960, + "version": "0.7.2" + }, + "cligj-0.7.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dceea2936bc8b1bfb4b8f56cf4d2aa6d", + "name": "cligj", + "sha256": "659963a0328dd9dfae036ad7543364e3d2c97d125e05d1aee714468f9dd4ff85", + "size": 12895, + "subdir": "linux-64", + "timestamp": 1622485801746, + "version": "0.7.2" + }, + "cligj-0.7.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "29c611e308a992f9f114f41159bbd755", + "name": "cligj", + "sha256": "cc10e598065b4601afd3996f2e52fa9d3f81b9b67494e7850f7fbfb16491b0aa", + "size": 12928, + "subdir": "linux-64", + "timestamp": 1622490985594, + "version": "0.7.2" + }, + "cloog-0.18.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "gmp", + "isl" + ], + "license": null, + "md5": "32e63e74723d6686d0ceb7384e47c2b4", + "name": "cloog", + "sha256": "252735853bd15e9800e087b019cbce2d282fd9a9915e80e41c939aea24c6a33b", + "size": 631488, + "version": "0.18.0" + }, + "cloudpickle-0.4.0-py27ha64365b_0.tar.bz2": { + "build": "py27ha64365b_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "35695ecf84a6025b68f6f66b76cd5090", + "name": "cloudpickle", + "sha256": "37aafd7f47af3f244db1505cfa2cee70f65e20d480117a296f235dc8e89ec901", + "size": 24689, + "subdir": "linux-64", + "timestamp": 1505732853036, + "version": "0.4.0" + }, + "cloudpickle-0.4.0-py35h10376d1_0.tar.bz2": { + "build": "py35h10376d1_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "50862ced9738405cacc83456ad539af2", + "name": "cloudpickle", + "sha256": "f416d50f9c8d43dda696f22eb0ed0f26fa905af4782244c9ad76cd1819854124", + "size": 25059, + "subdir": "linux-64", + "timestamp": 1505732864342, + "version": "0.4.0" + }, + "cloudpickle-0.4.0-py36h30f8c20_0.tar.bz2": { + "build": "py36h30f8c20_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ffd9a6ac4a4b20abc6e7ff03361ad71d", + "name": "cloudpickle", + "sha256": "9fee5b20d84cd3715ecb5702cf57ac897c2900248216b6d95585f51efc6beb5a", + "size": 24983, + "subdir": "linux-64", + "timestamp": 1505732875767, + "version": "0.4.0" + }, + "cloudpickle-0.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "853cea1d459402609d9bcfde37b8795c", + "name": "cloudpickle", + "sha256": "0c931ffbac7a3c1f0f85ecfe7ee5a7b0647087af6bbd7c12dcef45a337fcf094", + "size": 24847, + "subdir": "linux-64", + "timestamp": 1514447156804, + "version": "0.4.2" + }, + "cloudpickle-0.4.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c1c72a44a2db42f87e1132176c1bdfb3", + "name": "cloudpickle", + "sha256": "a5f484654957babe27d9e6a54d5b420ccb19dcb0774dbb6158937d849c065f33", + "size": 25244, + "subdir": "linux-64", + "timestamp": 1514447178940, + "version": "0.4.2" + }, + "cloudpickle-0.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8d31f5349b1938f401a32f848a9b9d11", + "name": "cloudpickle", + "sha256": "80582378836abf8146d0d03a503483f7a647c499699456e9ffc2a3d4be511141", + "size": 25141, + "subdir": "linux-64", + "timestamp": 1514447173289, + "version": "0.4.2" + }, + "cloudpickle-0.5.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dde8121e7f9ebde0fcf42d19307a0893", + "name": "cloudpickle", + "sha256": "3c3f9a0ac112c4a1a1fd3514f4329d98a96ff41c0deb2168e8312fffd496d91f", + "size": 25295, + "subdir": "linux-64", + "timestamp": 1517509743334, + "version": "0.5.2" + }, + "cloudpickle-0.5.2-py27hc3dac03_0.tar.bz2": { + "build": "py27hc3dac03_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a3ec07f30f20245c83a0c195f27507ba", + "name": "cloudpickle", + "sha256": "1b1f317d7bce6b230b86d57a3e94d6adc841ca9fca07417b963b78f0cfc54887", + "size": 25519, + "subdir": "linux-64", + "timestamp": 1511277646816, + "version": "0.5.2" + }, + "cloudpickle-0.5.2-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f296adbc0e3e4a1173855081e799bc56", + "name": "cloudpickle", + "sha256": "48f03c0d33e3132922faa68a1e5be80458cb7891c5b293ef1574fa6866bd484a", + "size": 25680, + "subdir": "linux-64", + "timestamp": 1517509764215, + "version": "0.5.2" + }, + "cloudpickle-0.5.2-py35hbe86bc5_0.tar.bz2": { + "build": "py35hbe86bc5_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dbae4862c9368d27596bb7d8b5b203d7", + "name": "cloudpickle", + "sha256": "933fa4bd4815e1c8206f12b124ed0a620f13855198aa7b2514ee1d7e40d91a88", + "size": 25924, + "subdir": "linux-64", + "timestamp": 1511277647214, + "version": "0.5.2" + }, + "cloudpickle-0.5.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1443a040c127e4c5cd75e4eeac8bd990", + "name": "cloudpickle", + "sha256": "ee046af7db8427c9a9d5eb2cc6047a514d68f2aa854c9744252ad5030bd25848", + "size": 25596, + "subdir": "linux-64", + "timestamp": 1517509753367, + "version": "0.5.2" + }, + "cloudpickle-0.5.2-py36h84cdd9c_0.tar.bz2": { + "build": "py36h84cdd9c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4ab2ee8e4bfda3f8f8b6f3734666d329", + "name": "cloudpickle", + "sha256": "dc67851cef65f9939cb27a9f8ecd7a05621edb8f0f00856cf17c658b0d82f1b3", + "size": 25845, + "subdir": "linux-64", + "timestamp": 1511277647660, + "version": "0.5.2" + }, + "cloudpickle-0.5.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "276e0f345107b3f32c1f6f7c481754bd", + "name": "cloudpickle", + "sha256": "641ee72e927e41a0817ee7e44a042d6a4a53caac18e5cf1f807a61cfbe0a5c5f", + "size": 25854, + "subdir": "linux-64", + "timestamp": 1526402395304, + "version": "0.5.3" + }, + "cloudpickle-0.5.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4050271a56cd890e9d1d83f6c415112d", + "name": "cloudpickle", + "sha256": "9ab1ce3723412d9ba69dcc357f02b3125ef79b05586b535796e84304c0a75be0", + "size": 26245, + "subdir": "linux-64", + "timestamp": 1526402425194, + "version": "0.5.3" + }, + "cloudpickle-0.5.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a531979d31f4134383203f7e0138baa6", + "name": "cloudpickle", + "sha256": "4b64ed9ed8aabe88e42ff22be1c3958e076b5a38b1620be102982048d9ad6850", + "size": 26186, + "subdir": "linux-64", + "timestamp": 1526402358774, + "version": "0.5.3" + }, + "cloudpickle-0.5.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8f3695d7d98ccc7b7863f784aa3e11a9", + "name": "cloudpickle", + "sha256": "0c2d216c0b3ddb7cc4ca90323faab99aed3e2877fecaf7030284424eada5499c", + "size": 26148, + "subdir": "linux-64", + "timestamp": 1530741238482, + "version": "0.5.3" + }, + "cloudpickle-0.5.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "911d2a77f781706a496af29a680321b7", + "name": "cloudpickle", + "sha256": "1aee1168d08b368e64933b8fadeba7c2767e983156af839cda716bf2987d9be5", + "size": 26189, + "subdir": "linux-64", + "timestamp": 1535378791627, + "version": "0.5.5" + }, + "cloudpickle-0.5.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b1bcf6c79737e45380dbadc20e2d68d3", + "name": "cloudpickle", + "sha256": "92f4627b1b02e47d4fae0fd7602b32e6774a85f13e06961d45be10c6482e7e68", + "size": 26617, + "subdir": "linux-64", + "timestamp": 1535378797892, + "version": "0.5.5" + }, + "cloudpickle-0.5.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e76eafc03fcf0729232e205ad446e71e", + "name": "cloudpickle", + "sha256": "659be6f29424b2db3f5525aa0e985d1796af99e687b8bbc2795b2829d7e5b75e", + "size": 26488, + "subdir": "linux-64", + "timestamp": 1535378789908, + "version": "0.5.5" + }, + "cloudpickle-0.5.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6f4e4b2e0736a7f035c144070c62ef9f", + "name": "cloudpickle", + "sha256": "6d5d651564f01601c0f1dc142c6bc7d4ffefe73eaceebe17f4663f0dd080384d", + "size": 26581, + "subdir": "linux-64", + "timestamp": 1535378798702, + "version": "0.5.5" + }, + "cloudpickle-0.5.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d6c46948e35af906b53103b85a8c9217", + "name": "cloudpickle", + "sha256": "2ca9a457610402f766c43fbc6153a7c80a0bc9c459b414ce8773e093fab5b5a1", + "size": 26704, + "subdir": "linux-64", + "timestamp": 1538158374155, + "version": "0.5.6" + }, + "cloudpickle-0.5.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2e173bc8de5263715c54ff04c47fcef5", + "name": "cloudpickle", + "sha256": "b81c8fd515bb54d253e9b925684f2e8b4f454c4a11445915fe876555426a81a7", + "size": 27025, + "subdir": "linux-64", + "timestamp": 1538158381757, + "version": "0.5.6" + }, + "cloudpickle-0.5.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ed9519c7115186050c041ca2606c1622", + "name": "cloudpickle", + "sha256": "9c8c47cbf5a2a3a7e11a7f39dc501479d55b06b1b9fe0cc97450a523aff7a101", + "size": 27084, + "subdir": "linux-64", + "timestamp": 1538158335374, + "version": "0.5.6" + }, + "cloudpickle-0.6.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "904ba97c2d0b5c63afedebc4490f33ee", + "name": "cloudpickle", + "sha256": "c2e2348108022bec90adc4b621cf52920d25af1e9a1ad91745ce7692d7f42e4e", + "size": 27603, + "subdir": "linux-64", + "timestamp": 1539472335877, + "version": "0.6.1" + }, + "cloudpickle-0.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6611d7c44e2691ccd243fcfbe2fdc47e", + "name": "cloudpickle", + "sha256": "836d025c8c02a1ba5a95eb9bc0cf54939829eaffb24f84692edfec5c3355a918", + "size": 27932, + "subdir": "linux-64", + "timestamp": 1539472350456, + "version": "0.6.1" + }, + "cloudpickle-0.6.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c10d37e541104aa26023ddc44093e05d", + "name": "cloudpickle", + "sha256": "46ccf091a40fb9966cf96e3819a19dd46dadcf1b1ead2c5fa94774a031a47118", + "size": 27930, + "subdir": "linux-64", + "timestamp": 1539472357360, + "version": "0.6.1" + }, + "cloudpickle-0.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "44d51dff9f117b43c693c958093a8796", + "name": "cloudpickle", + "sha256": "07225329f0096773a0edfbba6348646628c7a1f66fbaa2da7c1ab4dcb76cbf4d", + "size": 31864, + "subdir": "linux-64", + "timestamp": 1551138027423, + "version": "0.8.0" + }, + "cloudpickle-0.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f006f986be3006a565df647594e57e3a", + "name": "cloudpickle", + "sha256": "9ff0a1f879fe221c2ff78ab3d5208483d364bb368f6ee0420d6998a0fddc9928", + "size": 32227, + "subdir": "linux-64", + "timestamp": 1551138025276, + "version": "0.8.0" + }, + "cloudpickle-0.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dfce27c1e573fa295a06cc5949864f2d", + "name": "cloudpickle", + "sha256": "73e38a1552a640d47793ec521990119a8029cde71f2a7dff39d6dd7a662d4763", + "size": 32318, + "subdir": "linux-64", + "timestamp": 1551137988363, + "version": "0.8.0" + }, + "clr_loader-0.2.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cffi >=1.13", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92067a4ed5a142259c30ea27135f86a1", + "name": "clr_loader", + "sha256": "1dc6af745c4ede7d953e1eb89971266ca8d696fabd5756f6ec9c90eec90637cc", + "size": 72042, + "subdir": "linux-64", + "timestamp": 1675268076894, + "version": "0.2.5" + }, + "clr_loader-0.2.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cffi >=1.13", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8defcf766d8d59d83de64c2e65e7d4f", + "name": "clr_loader", + "sha256": "e322c78c453b0ebfe724bcb4079f8402e2b90bf1226973588b3ebafd933d0bbc", + "size": 82589, + "subdir": "linux-64", + "timestamp": 1676843610450, + "version": "0.2.5" + }, + "clr_loader-0.2.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cffi >=1.13", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b0c20f93130e594dd7ba12417dedc1d2", + "name": "clr_loader", + "sha256": "e701659873046d43a7e01e6acd13f7da5702dfc7af9461df6022ac40b7c11204", + "size": 71270, + "subdir": "linux-64", + "timestamp": 1675268115096, + "version": "0.2.5" + }, + "clr_loader-0.2.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cffi >=1.13", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f314d4b156c2c1b0d334cda5334b91f", + "name": "clr_loader", + "sha256": "85a1083a3f1e3268f6763b364056f43df242a714c5d04153aec702193c3765e3", + "size": 71460, + "subdir": "linux-64", + "timestamp": 1675268190302, + "version": "0.2.5" + }, + "clr_loader-0.2.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cffi >=1.13", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4cbbd003c0ca36bcb8d10011704ba8f8", + "name": "clr_loader", + "sha256": "dad6d51665b2887010bc2610d94352048faf717d961436db3cba9095de9e7aec", + "size": 71529, + "subdir": "linux-64", + "timestamp": 1675268152820, + "version": "0.2.5" + }, + "clyent-1.2.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "05dade0d5ee8d33433ddca9f1ad6111f", + "name": "clyent", + "sha256": "2fbb06dcc35c69bc33b3299ee18b864f7ffb528e63806b4415cb10188906c223", + "size": 18618, + "subdir": "linux-64", + "timestamp": 1530737320590, + "version": "1.2.2" + }, + "clyent-1.2.2-py27h7276e6c_1.tar.bz2": { + "build": "py27h7276e6c_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "524d2541b63eb333b279e90108362611", + "name": "clyent", + "sha256": "b2ce22c69417b63f12f03fbb4063e12a61fcda2aa15834da4966adeab4c543af", + "size": 18449, + "subdir": "linux-64", + "timestamp": 1505741906264, + "version": "1.2.2" + }, + "clyent-1.2.2-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "ead0a6da5eabedfad6899889f4d9fb9e", + "name": "clyent", + "sha256": "87c5b267530a9d3b711d1d3e1007283ce81f2db5adecc4036181d9723f4f32fb", + "size": 19375, + "subdir": "linux-64", + "timestamp": 1640789096647, + "version": "1.2.2" + }, + "clyent-1.2.2-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "9f2e81037ddb7346d2957beb30e8fbf9", + "name": "clyent", + "sha256": "e0ed0d064410b312b488d30c2834329d74c4754635c2b31ae7bcc6222d8ed23d", + "size": 25530, + "subdir": "linux-64", + "timestamp": 1676839171226, + "version": "1.2.2" + }, + "clyent-1.2.2-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "faf212140eebd58213745e637b38b736", + "name": "clyent", + "sha256": "13a804236c3c78dc449fe5cecd8a22266a7ebd663e1701131232d4dfe9aadec3", + "size": 18907, + "subdir": "linux-64", + "timestamp": 1534352672232, + "version": "1.2.2" + }, + "clyent-1.2.2-py35h491ffcb_1.tar.bz2": { + "build": "py35h491ffcb_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "791fcbb42f2d39280bab876ce204357a", + "name": "clyent", + "sha256": "1ab315699080ab34b6532d6a2125cbec5650ba75de1bcdda9504ad6f519ea593", + "size": 18819, + "subdir": "linux-64", + "timestamp": 1505741919060, + "version": "1.2.2" + }, + "clyent-1.2.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "c19f64c49e269d593f413992cd7eea52", + "name": "clyent", + "sha256": "185cafe3f8e91dcad74c72658d3b046ec55b846526445326e3f79e59cf134d56", + "size": 18860, + "subdir": "linux-64", + "timestamp": 1530737299716, + "version": "1.2.2" + }, + "clyent-1.2.2-py36h7e57e65_1.tar.bz2": { + "build": "py36h7e57e65_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "bbb138ca18d9570d230deae62d00aa6b", + "name": "clyent", + "sha256": "d978894afb298c9d599b76228b2a43815d75ac753da5469f430a4e45e7603cac", + "size": 18701, + "subdir": "linux-64", + "timestamp": 1505741931933, + "version": "1.2.2" + }, + "clyent-1.2.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "cfa890dc1326c166445fd77d13666a92", + "name": "clyent", + "sha256": "57a1b91b864f7d7a0f6fb645d84bd55b2ff3ee62ff8f4c7dccc044c14b5607b0", + "size": 18910, + "subdir": "linux-64", + "timestamp": 1530737341908, + "version": "1.2.2" + }, + "clyent-1.2.2-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "4443eaa9b5f7bee6028576c1ce2e7f1b", + "name": "clyent", + "sha256": "622c6ea000a3db56c628812b5474c15e6da0175cdbbacc17f7e8373b29521420", + "size": 19449, + "subdir": "linux-64", + "timestamp": 1574097928918, + "version": "1.2.2" + }, + "clyent-1.2.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "3d765ca367970c5fa0cef3fb2c9bbfee", + "name": "clyent", + "sha256": "a98a67820ac4dcacd5d738f12cc0f3a4eeea89f5fdd1bd9eded13c54c18631f3", + "size": 20618, + "subdir": "linux-64", + "timestamp": 1607025264853, + "version": "1.2.2" + }, + "cmake-3.11.1-h307fef2_1.tar.bz2": { + "build": "h307fef2_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "expat >=2.2.5,<3.0a0", + "libcurl >=7.59.0,<8.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.1,<7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1ffb03feae5913fa6ed19b15fa9bbc5c", + "name": "cmake", + "sha256": "c9d117c177d9278786050fcc0adea22c5cb2681e417211896bdbe54739ebebe2", + "size": 13147364, + "subdir": "linux-64", + "timestamp": 1525871702287, + "version": "3.11.1" + }, + "cmake-3.12.0-h307fef2_0.tar.bz2": { + "build": "h307fef2_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "expat >=2.2.5,<3.0a0", + "libcurl >=7.61.0,<8.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.1,<7.0a0", + "rhash >=1.3.6,<2.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "df69cb17cb27183f02204f888eb4e279", + "name": "cmake", + "sha256": "759d88c9c363a4d55b90bec3fb605552486cd1696714265bb4b8ba6cecad16de", + "size": 10672206, + "subdir": "linux-64", + "timestamp": 1532874097999, + "version": "3.12.0" + }, + "cmake-3.12.2-h52cb24c_0.tar.bz2": { + "build": "h52cb24c_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "expat >=2.2.6,<3.0a0", + "libcurl >=7.61.0,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "rhash >=1.3.6,<2.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "40c0bff97dc4f55cbfd2763af8be01be", + "name": "cmake", + "sha256": "7f9f25b5088ade0b02b4f82c63c6589012b963938f749e1263abd8a1ab7f0257", + "size": 10523526, + "subdir": "linux-64", + "timestamp": 1536508969962, + "version": "3.12.2" + }, + "cmake-3.14.0-h52cb24c_0.tar.bz2": { + "build": "h52cb24c_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "expat >=2.2.6,<3.0a0", + "libcurl >=7.64.0,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "rhash >=1.3.8,<2.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f6cbb4c0faa3dbac007b286047f9a758", + "name": "cmake", + "sha256": "784610a5e32ac9d2244c1794b57664b6b848c35c751819f57bad8a284fb62fe5", + "size": 9990772, + "subdir": "linux-64", + "timestamp": 1553108390531, + "version": "3.14.0" + }, + "cmake-3.18.2-ha30ef3c_0.tar.bz2": { + "build": "ha30ef3c_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "expat >=2.2.9,<3.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libuv >=1.39.0,<2.0a0", + "ncurses >=6.2,<7.0a0", + "rhash >=1.4.0,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1603ec8880384435e15366dc92a38c77", + "name": "cmake", + "sha256": "60b5d9ac2431096fa0783c5be53147b214b4a983f152899332108fc9160f28b4", + "size": 13934714, + "subdir": "linux-64", + "timestamp": 1600446037330, + "version": "3.18.2" + }, + "cmake-3.19.3-h973ab73_0.tar.bz2": { + "build": "h973ab73_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "expat >=2.2.10,<3.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "ncurses >=6.2,<7.0a0", + "rhash >=1.4.1,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1f6fab2354da8998e44b835b49aa11f4", + "name": "cmake", + "sha256": "9feaf86ebb8ffe8d4fcd3a8909a14b70991f6af8ccca1b49a7a484f7d4735c16", + "size": 14410645, + "subdir": "linux-64", + "timestamp": 1611330763643, + "version": "3.19.3" + }, + "cmake-3.19.4-h973ab73_0.tar.bz2": { + "build": "h973ab73_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "expat >=2.2.10,<3.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "ncurses >=6.2,<7.0a0", + "rhash >=1.4.1,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eb128ca73cbad7a9ecf254e88ac9e06e", + "name": "cmake", + "sha256": "1cc8d30ca431483b0604ff7c2d1e3770d14f132554ca105a60152e8d0a0aa3cd", + "size": 14385850, + "subdir": "linux-64", + "timestamp": 1612282542254, + "version": "3.19.4" + }, + "cmake-3.19.6-h973ab73_0.tar.bz2": { + "build": "h973ab73_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "expat >=2.2.10,<3.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "ncurses >=6.2,<7.0a0", + "rhash >=1.4.1,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "094f6abae44845623290890d65cccb18", + "name": "cmake", + "sha256": "5a64b4001ce32f28e1b7e0ca01ccd1aed0b789db59fbe5e89c31462468524431", + "size": 14388467, + "subdir": "linux-64", + "timestamp": 1614679386931, + "version": "3.19.6" + }, + "cmake-3.22.1-h1fce559_0.tar.bz2": { + "build": "h1fce559_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "expat >=2.2.10,<3.0a0", + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "ncurses >=6.3,<7.0a0", + "rhash >=1.4.1,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.5.0,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4188c2b66b3572ca8be6d7cfec20abca", + "name": "cmake", + "sha256": "cd40c7eac1e04cb9b74dc19fa43166d49f4ae01940b70e4c6993ea117f8f2928", + "size": 15660176, + "subdir": "linux-64", + "timestamp": 1641977657928, + "version": "3.22.1" + }, + "cmake-3.9.1-hd1fb129_0.tar.bz2": { + "build": "hd1fb129_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "expat", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libuv", + "ncurses 6.*", + "rhash", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b84e401ca76e14f53679a149362ee930", + "name": "cmake", + "sha256": "200e1a9d0f5e6ec047784db6a83ff2af8d58c0f8d33cb1eb3d34c9ee2ca4f01f", + "size": 12197018, + "subdir": "linux-64", + "timestamp": 1505688081867, + "version": "3.9.1" + }, + "cmake-3.9.3-h61fe106_0.tar.bz2": { + "build": "h61fe106_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "expat", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libuv", + "ncurses 6.*", + "rhash", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d7245718dc67ca1c95419e44e8e0ba3b", + "name": "cmake", + "sha256": "76309aa24715cc013fcdc56d07a27e00466886cdb75479519b1baa6ae409f447", + "size": 12193098, + "subdir": "linux-64", + "timestamp": 1508295453536, + "version": "3.9.3" + }, + "cmake-3.9.4-h142f0e9_0.tar.bz2": { + "build": "h142f0e9_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "expat", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libuv", + "ncurses 6.*", + "rhash", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7bd990e056c492994d82886455f223fc", + "name": "cmake", + "sha256": "7c5084acac33ef7be2224fad5f469639a86d5c2f46e9c42ef7539ab81c8e1ff9", + "size": 12195982, + "subdir": "linux-64", + "timestamp": 1509214369515, + "version": "3.9.4" + }, + "cmake-binary-3.9.1-h2f8e2a0_1.tar.bz2": { + "build": "h2f8e2a0_1", + "build_number": 1, + "depends": [], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "79092290099880fbfb279eee9fac7fd1", + "name": "cmake-binary", + "sha256": "af61d54a90d580ee6b6cb22e672762bb47182aa724d1c8ad9ca867955c1756a7", + "size": 28971630, + "subdir": "linux-64", + "timestamp": 1510244381704, + "version": "3.9.1" + }, + "cmake-binary-3.9.1-h3db6e14_0.tar.bz2": { + "build": "h3db6e14_0", + "build_number": 0, + "depends": [], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4c96ed1fcfbfc5183da8078e7cb5565e", + "name": "cmake-binary", + "sha256": "323b5390acbd46da714d4035deb657c12092618b23c620abe793b2e82aadb6a1", + "size": 29005663, + "subdir": "linux-64", + "timestamp": 1505687617283, + "version": "3.9.1" + }, + "cmake-no-system-3.16.5-h295c915_1.tar.bz2": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7402b76c97a5212356b79dd4f7634c54", + "name": "cmake-no-system", + "sha256": "12dd9bcf16b9a2fd24e72d55ecd7e176196cdfe755ce38e10d9ece10f28a108d", + "size": 11691341, + "subdir": "linux-64", + "timestamp": 1635449577071, + "version": "3.16.5" + }, + "cmake-no-system-3.25.3-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "37c6d52d7ab37012dea46ba9de4372f5", + "name": "cmake-no-system", + "sha256": "eb110d879ee5d151004c796cc25c7746136a28fb9c806890cbee778b98073aed", + "size": 16465300, + "subdir": "linux-64", + "timestamp": 1679924216623, + "version": "3.25.3" + }, + "cmarkgfm-0.4.2-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5a3c8f350629dcbe292cb383de0b6d4e", + "name": "cmarkgfm", + "sha256": "bc11b9ae44c169e15a1e0ea6d406eaa3b8643995d63cd6107623e8491764a50f", + "size": 160066, + "subdir": "linux-64", + "timestamp": 1539899981585, + "version": "0.4.2" + }, + "cmarkgfm-0.4.2-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2cf2a927f276f280844c2ba66ee31e1e", + "name": "cmarkgfm", + "sha256": "c529f33a41f418c7c87662bd030dcf28e602ee62218359fa46c3ed4b03a25b8e", + "size": 447195, + "subdir": "linux-64", + "timestamp": 1640803944970, + "version": "0.4.2" + }, + "cmarkgfm-0.4.2-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "72cf358d880ea4dae5d508b27929f333", + "name": "cmarkgfm", + "sha256": "01e96275c49a7da0462e20224ac869609a1f41c262e317ff707ea6df70ec934f", + "size": 161871, + "subdir": "linux-64", + "timestamp": 1676903901053, + "version": "0.4.2" + }, + "cmarkgfm-0.4.2-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0460bcc4e917de78c3311983355feee8", + "name": "cmarkgfm", + "sha256": "3dea9411572413ee08bd1e099d70fb2cfbf3306d9e8040caca75fc14b2ead3ad", + "size": 383575, + "subdir": "linux-64", + "timestamp": 1613500968049, + "version": "0.4.2" + }, + "cmarkgfm-0.4.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e1f191f939dfbc7187dfafa6ab75b2e", + "name": "cmarkgfm", + "sha256": "393b7403d8b905676d59dcbde66b9279e161a8c7a2ba6fabe6d9ad53859c708b", + "size": 160233, + "subdir": "linux-64", + "timestamp": 1539900015606, + "version": "0.4.2" + }, + "cmarkgfm-0.4.2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49a5a78ba8822922f702e1f61d4c68e3", + "name": "cmarkgfm", + "sha256": "8c2ad1ea101ebc271045f4e32bb5475b72560c80412bad6e4ce21d75db22712e", + "size": 382383, + "subdir": "linux-64", + "timestamp": 1613500810785, + "version": "0.4.2" + }, + "cmarkgfm-0.4.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "09763e6768ca00066755809490026e70", + "name": "cmarkgfm", + "sha256": "878f028d1d397ed1387bf4279af8d989c76e287ae6e4dd0baad31bd8ef8f27e8", + "size": 160305, + "subdir": "linux-64", + "timestamp": 1539900006243, + "version": "0.4.2" + }, + "cmarkgfm-0.4.2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "449f0d5778a0388c5ba84e9e8345331d", + "name": "cmarkgfm", + "sha256": "cd3a97340018d9a3210505140eb4ba2e1548854ed392ca9642bc08548be11647", + "size": 379774, + "subdir": "linux-64", + "timestamp": 1613500329786, + "version": "0.4.2" + }, + "cmarkgfm-0.4.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6236f65b2fdb661de4cc8278a45be516", + "name": "cmarkgfm", + "sha256": "d2d56e7f8c92dd4882bbdab2fe817e70263dea1d929533d211f13e26c5685e06", + "size": 160415, + "subdir": "linux-64", + "timestamp": 1574097959886, + "version": "0.4.2" + }, + "cmarkgfm-0.4.2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "06062bdecf2acf5332b7a96bf997a7d4", + "name": "cmarkgfm", + "sha256": "03800b308502670f31a51ba93d73b981d9ebdf661ee926c57741bd75f50e07da", + "size": 383403, + "subdir": "linux-64", + "timestamp": 1613500960325, + "version": "0.4.2" + }, + "cmyt-1.1.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "colorspacious >=1.1.2", + "matplotlib-base >=3.2.0", + "more-itertools >=8.4", + "numpy >=1.17.4", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d425524538d5682c043b16c2d04e7d34", + "name": "cmyt", + "sha256": "89d630036f4fb00e50184a11cbb1cd231cdd2e980744b3bca64ab620c7cb1d54", + "size": 63997, + "subdir": "linux-64", + "timestamp": 1680641771977, + "version": "1.1.3" + }, + "cmyt-1.1.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "colorspacious >=1.1.2", + "matplotlib-base >=3.2.0", + "more-itertools >=8.4", + "numpy >=1.17.4", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "410b414fda379c181fd898b40240091a", + "name": "cmyt", + "sha256": "b0aee551b905c5953a53a6a99e4c2942bce42c11ae9065adff0ab0d23dc7bc83", + "size": 67448, + "subdir": "linux-64", + "timestamp": 1680641733632, + "version": "1.1.3" + }, + "cmyt-1.1.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "colorspacious >=1.1.2", + "matplotlib-base >=3.2.0", + "more-itertools >=8.4", + "numpy >=1.17.4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1c48ae756737fa1003b4160757142729", + "name": "cmyt", + "sha256": "f9a1dd26651a0b1f0c6df49a65a8a72bc27571ff2f3645c2766552d5050db6d1", + "size": 66821, + "subdir": "linux-64", + "timestamp": 1680641844750, + "version": "1.1.3" + }, + "cmyt-1.1.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "colorspacious >=1.1.2", + "matplotlib-base >=3.2.0", + "more-itertools >=8.4", + "numpy >=1.17.4", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "41158558570ecdbd7e27ae0e55779373", + "name": "cmyt", + "sha256": "8217d652f231e1a8827c0bb82d51e43d702341c826c0a4d65303e25676518c87", + "size": 63904, + "subdir": "linux-64", + "timestamp": 1680641807315, + "version": "1.1.3" + }, + "colander-1.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=2.7,<2.8.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "cd1fa59af5dbc00fd689e73454c3d57a", + "name": "colander", + "sha256": "bf9c063932020a49e6f6a48f4b40fa6cc852cf7bda756d196b6622034bbb1ee8", + "size": 109301, + "subdir": "linux-64", + "timestamp": 1530875884332, + "version": "1.4" + }, + "colander-1.4-py27h37c4d75_0.tar.bz2": { + "build": "py27h37c4d75_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=2.7,<2.8.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "54a8c1636058189f1255a912197feeb4", + "name": "colander", + "sha256": "20e8018f411bd6e250ef7eb47fb9646f97c04480856226866f7ba8206ee86f6e", + "size": 109934, + "subdir": "linux-64", + "timestamp": 1507613925792, + "version": "1.4" + }, + "colander-1.4-py35h9147586_0.tar.bz2": { + "build": "py35h9147586_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.5,<3.6.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "d371dc5c52a5e8a69e75c3db1d625d3d", + "name": "colander", + "sha256": "4eaf7fb2c48dc88dc8bf91cd9b4eab1c269ecb855530cd42aff5da70e5d4f35c", + "size": 114132, + "subdir": "linux-64", + "timestamp": 1507613930803, + "version": "1.4" + }, + "colander-1.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.6,<3.7.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "33f55ef352af5e29fb62e983c0a3e7f2", + "name": "colander", + "sha256": "2c289bc67a8d25ea9019341040151df5bb68703dd8e3487cef9405cddd91add4", + "size": 113558, + "subdir": "linux-64", + "timestamp": 1530875831727, + "version": "1.4" + }, + "colander-1.4-py36h3dcf288_0.tar.bz2": { + "build": "py36h3dcf288_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.6,<3.7.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "dd2b47ff1de9417a45ac152220eb0c77", + "name": "colander", + "sha256": "c1eeedf17ee0d049ec359fea31f7d78ec66d54f80179d6a4ea87458d0c793cff", + "size": 113686, + "subdir": "linux-64", + "timestamp": 1507613915462, + "version": "1.4" + }, + "colander-1.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.7,<3.8.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "dd8ddcf23a1fd3140df2f4be6706efe3", + "name": "colander", + "sha256": "5351669c29320b252acef69ada47d38696a7ddd68c507b60939d8ba06171c06d", + "size": 113635, + "subdir": "linux-64", + "timestamp": 1530875858346, + "version": "1.4" + }, + "colander-1.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "iso8601", + "python >=2.7,<2.8.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "88502683a449abc8d2f641eabbe74ac3", + "name": "colander", + "sha256": "b65ff012edf3ce57516854b3bd305143c0684341fbbf86f2969899b7a520628b", + "size": 112070, + "subdir": "linux-64", + "timestamp": 1539621008878, + "version": "1.5.1" + }, + "colander-1.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.6,<3.7.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "31ca144a2453f6b90c6eb5aa87622ce9", + "name": "colander", + "sha256": "28ef6f72fdb6ba571d6cc85d640a3069085ec20fc9356efd25dd4089ab1cbecc", + "size": 116295, + "subdir": "linux-64", + "timestamp": 1539621044694, + "version": "1.5.1" + }, + "colander-1.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.7,<3.8.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "8e309dee2e1166e34d0aa6f037a18260", + "name": "colander", + "sha256": "4b5f3157a33810496d3190ca9b656c7bde147e1a37df6fde6049e176615b74be", + "size": 116482, + "subdir": "linux-64", + "timestamp": 1539621049116, + "version": "1.5.1" + }, + "colander-1.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "iso8601", + "python >=2.7,<2.8.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "a67d2ece8d16a0d7d4224dc0c588f843", + "name": "colander", + "sha256": "464f6f8ffc179a9ed3e4936b42ea505768bbfc44b97879d9c8cca29ad79ff3dc", + "size": 269743, + "subdir": "linux-64", + "timestamp": 1552359626736, + "version": "1.7.0" + }, + "colander-1.7.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.10,<3.11.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "b13ac4ce77b25a6a4d7115abc7f6674b", + "name": "colander", + "sha256": "a86f51d068a0f3db6808bfb4c4ba0c1ac44390b04da7e6d7a45a1688f3b6be8d", + "size": 121433, + "subdir": "linux-64", + "timestamp": 1640808631291, + "version": "1.7.0" + }, + "colander-1.7.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.11,<3.12.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "668d2c37da1807796cf79546cfcc9e5f", + "name": "colander", + "sha256": "d3b6aadea627faf1a5e51146812c2324896f1fa6cd3679f2111858ae98370b89", + "size": 150917, + "subdir": "linux-64", + "timestamp": 1676906997104, + "version": "1.7.0" + }, + "colander-1.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.6,<3.7.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "f0895dc91e43deec34d70a53fd7cc1f0", + "name": "colander", + "sha256": "5f65fe4360f7c2fefa05672f6e566fd641c35cfd97c7ad42d33b424795512a8a", + "size": 273798, + "subdir": "linux-64", + "timestamp": 1552359648869, + "version": "1.7.0" + }, + "colander-1.7.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.6,<3.7.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "0990740043de22f697b4591adda6ac03", + "name": "colander", + "sha256": "0a5fd4daeeb6c87ca73ce2423a1d628faef398706d022c2899eab5301b6a8b02", + "size": 336160, + "subdir": "linux-64", + "timestamp": 1613568578901, + "version": "1.7.0" + }, + "colander-1.7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.7,<3.8.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "c7d036974febbb490970f0300a16ed1a", + "name": "colander", + "sha256": "e514617cf54a8a9bec73de4b45dcf84050857d54b9741fe0ba8da33e32ccc67b", + "size": 268110, + "subdir": "linux-64", + "timestamp": 1552359556270, + "version": "1.7.0" + }, + "colander-1.7.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.7,<3.8.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "617f39d1efea1f544f373f12e4eed3db", + "name": "colander", + "sha256": "9d6124b5c4113d6eb1bb5d675d249fd4b511efca4e8cc5bf59bd82a4338bbf3d", + "size": 356906, + "subdir": "linux-64", + "timestamp": 1613569009183, + "version": "1.7.0" + }, + "colander-1.7.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.8,<3.9.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "f33d995ed24a008a17c1336cb763735a", + "name": "colander", + "sha256": "920fb1a1d7c33070ae80f4d66bbcb0002d3d1ed318ec8aedb999fce9a34fb4f1", + "size": 120381, + "subdir": "linux-64", + "timestamp": 1573741552028, + "version": "1.7.0" + }, + "colander-1.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.9,<3.10.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "28fc5ce7b13e1f9ab65f00eb804a955b", + "name": "colander", + "sha256": "6ba2dcf4148d44a9c95b4e577e45ee43df8d3361aaac410ece5427e678cc63a6", + "size": 340467, + "subdir": "linux-64", + "timestamp": 1613568347088, + "version": "1.7.0" + }, + "colorama-0.3.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2bcac4f496d8af612587ceda842becb4", + "name": "colorama", + "sha256": "8ba3f7f5dc59368824f3b8d1f2beeecec7893efbccf6c6ecdc9e6a69f10c2c24", + "size": 23357, + "subdir": "linux-64", + "timestamp": 1530693854914, + "version": "0.3.9" + }, + "colorama-0.3.9-py27h5cde069_0.tar.bz2": { + "build": "py27h5cde069_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "002c4a08e8804c3651c2b22535c73607", + "name": "colorama", + "sha256": "0d8bef54d1b9ee1fa8f010b493777af1e494dd1384de40d3b88a45a449dd3261", + "size": 23193, + "subdir": "linux-64", + "timestamp": 1505741945172, + "version": "0.3.9" + }, + "colorama-0.3.9-py35h81e2b6c_0.tar.bz2": { + "build": "py35h81e2b6c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d7ce082b858d6e4d020e3efd6efe7ff0", + "name": "colorama", + "sha256": "721dbbf706ba88d06d436e6136c5b7236968258014291f4db1eebf8ae2d83ec4", + "size": 23604, + "subdir": "linux-64", + "timestamp": 1505741957440, + "version": "0.3.9" + }, + "colorama-0.3.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "aa0a475ff4e7ac7df2b62bb3562863a8", + "name": "colorama", + "sha256": "887925552c4bcba14a24a96207d3a9adca2da78b441e2f008efbd172178d124f", + "size": 23737, + "subdir": "linux-64", + "timestamp": 1530693817961, + "version": "0.3.9" + }, + "colorama-0.3.9-py36h489cec4_0.tar.bz2": { + "build": "py36h489cec4_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8a3372480117f3f7b18413ecc3dba6ac", + "name": "colorama", + "sha256": "174c44ef3f8039aa81aa6876e5df2fee10c6793e8ca5bc6e49b64e3726aa3b2c", + "size": 23584, + "subdir": "linux-64", + "timestamp": 1505741969960, + "version": "0.3.9" + }, + "colorama-0.3.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d16dce3dafe65bc722fa158d2b6a4a88", + "name": "colorama", + "sha256": "3e7c2963930ddc3e7dcc7077f33465724dbb2266139e408c2c1bdc3e37e285e3", + "size": 23780, + "subdir": "linux-64", + "timestamp": 1530693837145, + "version": "0.3.9" + }, + "colorama-0.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3ff8af109504604889a3d78238985d6a", + "name": "colorama", + "sha256": "da650784931268d2b1627c219b8e54f6f953c4296b916566bc4ab5879184abbd", + "size": 23808, + "subdir": "linux-64", + "timestamp": 1539634932996, + "version": "0.4.0" + }, + "colorama-0.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "639992bce5135e0fdb05b0c32b9c02ee", + "name": "colorama", + "sha256": "b70a54af118d93fea16a976a3ef765c26effe739c59b91d3e96c27eeca9e4032", + "size": 24245, + "subdir": "linux-64", + "timestamp": 1539634959615, + "version": "0.4.0" + }, + "colorama-0.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b10f6211a479a9fd24659eb5d5238e15", + "name": "colorama", + "sha256": "e49a64918b8bc6a0ee8e66a1dc7025e2367a3e096b8707459979182ce5b801c5", + "size": 24254, + "subdir": "linux-64", + "timestamp": 1539634949048, + "version": "0.4.0" + }, + "colorama-0.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b3dab0b6575fad68cd6f8a996ab2311e", + "name": "colorama", + "sha256": "f17df9c8259dcb53808653b9cb1a4124f6b91dc887e9747c8330bae6c58c10ee", + "size": 24097, + "subdir": "linux-64", + "timestamp": 1545083895059, + "version": "0.4.1" + }, + "colorama-0.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "483434924f0525c41f07f6c0efa486e7", + "name": "colorama", + "sha256": "eea25d6a1df8e34018ca97b37ee00392e7220eb14079088d78be45194d94730d", + "size": 24552, + "subdir": "linux-64", + "timestamp": 1545083921207, + "version": "0.4.1" + }, + "colorama-0.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "43aa0429e2e0b9d1af3782ae88569a63", + "name": "colorama", + "sha256": "2664546493cf34ea41d5a01f8435876c0588689f9a2ecf1595de32bd483aebd0", + "size": 24594, + "subdir": "linux-64", + "timestamp": 1545083945930, + "version": "0.4.1" + }, + "colorama-0.4.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "57151e6197a78a7b5aee9cf288b777f7", + "name": "colorama", + "sha256": "efcd2c56ce4c33ad41ab1c8ae481d69b7899ef63dd621daeae14f74de8cdf36a", + "size": 27891, + "subdir": "linux-64", + "timestamp": 1657009213022, + "version": "0.4.5" + }, + "colorama-0.4.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3dfd8f404f69a426aa6da0064e749a12", + "name": "colorama", + "sha256": "65b6d5986cc99b9d1731e26fb2403db46146a762447f732959af63ee965c7a1d", + "size": 27542, + "subdir": "linux-64", + "timestamp": 1657009175352, + "version": "0.4.5" + }, + "colorama-0.4.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f9e78470fc47d8642dbab3d4e516caf8", + "name": "colorama", + "sha256": "4286bb54c15a9b871ca51838a00dd59b1a95288cb531587173e867079278ed49", + "size": 27594, + "subdir": "linux-64", + "timestamp": 1657009149122, + "version": "0.4.5" + }, + "colorama-0.4.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dcc5741f65f7be6b271ea5144ae9a438", + "name": "colorama", + "sha256": "5d5649f57dd22b6b1bfd5a93092337181482de082ee45101c1028fb90c4bf7e2", + "size": 27588, + "subdir": "linux-64", + "timestamp": 1657009123127, + "version": "0.4.5" + }, + "colorama-0.4.6-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b95749bf7aeb219a7f6cf9e557c2c60c", + "name": "colorama", + "sha256": "450aec10b005fce5cb11f4255d1f61008148a63740abfa6c226f16900765f9c3", + "size": 29826, + "subdir": "linux-64", + "timestamp": 1672386582651, + "version": "0.4.6" + }, + "colorama-0.4.6-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fb8cfe358ca63295486e569b2345e8ab", + "name": "colorama", + "sha256": "9394a4241ec9e3fdac2050cb7040645241deb88e3c50b2b5ac8ffe157c2fd6b8", + "size": 36076, + "subdir": "linux-64", + "timestamp": 1676827050831, + "version": "0.4.6" + }, + "colorama-0.4.6-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d65c573922514eec2ef07283ccbdf665", + "name": "colorama", + "sha256": "3a9c06ef3e319d93f9460ca9d66f3c1807c6d28de3c31bb568ecd160fcfb659f", + "size": 29561, + "subdir": "linux-64", + "timestamp": 1672386609875, + "version": "0.4.6" + }, + "colorama-0.4.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88d1a4f698f8788175118a03ed6c2dca", + "name": "colorama", + "sha256": "5201ada3078eb5edd24f828fc617236f17bc77aaa579f44a93e540e4545bc8d0", + "size": 29539, + "subdir": "linux-64", + "timestamp": 1672386556566, + "version": "0.4.6" + }, + "colorama-0.4.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bbca3546344623298ab930e4d22be63a", + "name": "colorama", + "sha256": "9e2b370eb30082301dfdd9b15be212fe59bd2516a295be8aa75e8b224fdfbfe1", + "size": 29553, + "subdir": "linux-64", + "timestamp": 1672386636044, + "version": "0.4.6" + }, + "colorcet-1.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "CC-BY-4.0", + "md5": "4703b2308aa28f94a820b8546bf69501", + "name": "colorcet", + "sha256": "62a0e097aefa09288c197c81e66fb574c574ee80b892d56487798abbc7a7967c", + "size": 321622, + "subdir": "linux-64", + "timestamp": 1519145496168, + "version": "1.0.0" + }, + "colorcet-1.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "CC-BY-4.0", + "md5": "7cbba932f590ee26205afcbf8e87d40e", + "name": "colorcet", + "sha256": "4a138a23968e58d74444e6b3b31c6542bacc008bf6f225c04184309b905e00cd", + "size": 322186, + "subdir": "linux-64", + "timestamp": 1519145501571, + "version": "1.0.0" + }, + "colorcet-1.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "CC-BY-4.0", + "md5": "38bf7049a36be90112cb3205ecd93b65", + "name": "colorcet", + "sha256": "8ae9c94e23e3f9ed5a8f80f49e8ab6349c45c6d074651f74a1cbdcab78c7f799", + "size": 311779, + "subdir": "linux-64", + "timestamp": 1519145504598, + "version": "1.0.0" + }, + "colorcet-1.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "CC-BY-4.0", + "md5": "1103c0f0bb93cef65118cb4edd113e85", + "name": "colorcet", + "sha256": "d0635611ad575c91c383508e2c729ae75e51d8751628480e14070a75bf1c2823", + "size": 311614, + "subdir": "linux-64", + "timestamp": 1530812294620, + "version": "1.0.0" + }, + "colorcet-3.0.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "pyct >=0.4.4", + "python >=3.10,<3.11.0a0" + ], + "license": "CC-BY-4.0", + "license_family": "CC", + "md5": "00ad462cfe7319aa60f52acb9cb36a02", + "name": "colorcet", + "sha256": "43c24494d25a819c10cd9b7fe5cc1faa75a6f8dcce14171e657883e62a1d9028", + "size": 1922749, + "subdir": "linux-64", + "timestamp": 1651833376951, + "version": "3.0.0" + }, + "colorcet-3.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "pyct >=0.4.4", + "python >=3.7,<3.8.0a0" + ], + "license": "CC-BY-4.0", + "license_family": "CC", + "md5": "def51ad619b69fbf078c616321861b28", + "name": "colorcet", + "sha256": "756e85b9ed8873062eac3178d5f1f0ee3c0ffea00ae9cd4dfd87e8c0e6d95e05", + "size": 1959614, + "subdir": "linux-64", + "timestamp": 1651833625549, + "version": "3.0.0" + }, + "colorcet-3.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "pyct >=0.4.4", + "python >=3.8,<3.9.0a0" + ], + "license": "CC-BY-4.0", + "license_family": "CC", + "md5": "731214b5adf745f8b7ef2f21aecddbe6", + "name": "colorcet", + "sha256": "78f1eac718ff85f7e717ebd105ebf386fba2d0d9b7d7feeabd553d7122de557f", + "size": 1947927, + "subdir": "linux-64", + "timestamp": 1651851479791, + "version": "3.0.0" + }, + "colorcet-3.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "pyct >=0.4.4", + "python >=3.9,<3.10.0a0" + ], + "license": "CC-BY-4.0", + "license_family": "CC", + "md5": "fc9dbdd08499028f42fb72d3a446124b", + "name": "colorcet", + "sha256": "448f2cc359db60c7766e8f98dc55623add010919aaf7a98fa55d1b8ef77fcdc5", + "size": 1935868, + "subdir": "linux-64", + "timestamp": 1651851479683, + "version": "3.0.0" + }, + "colorcet-3.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pyct >=0.4.4", + "python >=3.10,<3.11.0a0" + ], + "license": "CC-BY-4.0", + "license_family": "CC", + "md5": "2e415f3e186472953ca1abdd872ff076", + "name": "colorcet", + "sha256": "42a75e0216721a4a866e7edc3e81870c8cf8e9f8c3f2cace5318a1bc91d93328", + "size": 1947957, + "subdir": "linux-64", + "timestamp": 1668084644133, + "version": "3.0.1" + }, + "colorcet-3.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pyct >=0.4.4", + "python >=3.11,<3.12.0a0" + ], + "license": "CC-BY-4.0", + "license_family": "CC", + "md5": "b276060ab29889c1055c68be83a31f66", + "name": "colorcet", + "sha256": "6ec0e7033905bcb379a798486abd1962fca23c31f6a07db206ddc5aa78095573", + "size": 1982585, + "subdir": "linux-64", + "timestamp": 1676839188918, + "version": "3.0.1" + }, + "colorcet-3.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pyct >=0.4.4", + "python >=3.7,<3.8.0a0" + ], + "license": "CC-BY-4.0", + "license_family": "CC", + "md5": "ed51c10586c1d5e282e7771758d0169e", + "name": "colorcet", + "sha256": "31c09928952451a2582fd3d42eee5444b812dcd0226539c8ab3273eb943a1c7c", + "size": 1973155, + "subdir": "linux-64", + "timestamp": 1668084611209, + "version": "3.0.1" + }, + "colorcet-3.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pyct >=0.4.4", + "python >=3.8,<3.9.0a0" + ], + "license": "CC-BY-4.0", + "license_family": "CC", + "md5": "442d8300d903dcc9050d9e9b1336cde1", + "name": "colorcet", + "sha256": "8a25abc45d27b1ca16489f03a390ad5f648cf198d4d341437e75e320a1303d0f", + "size": 1974004, + "subdir": "linux-64", + "timestamp": 1668084578291, + "version": "3.0.1" + }, + "colorcet-3.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pyct >=0.4.4", + "python >=3.9,<3.10.0a0" + ], + "license": "CC-BY-4.0", + "license_family": "CC", + "md5": "10bd31b22cd7efc4cff2b9503ef6d3e0", + "name": "colorcet", + "sha256": "c54f2ff08c13471922e8f3043e47898aaec39956373808b3eb053273860fe303", + "size": 1917831, + "subdir": "linux-64", + "timestamp": 1668084545510, + "version": "3.0.1" + }, + "coloredlogs-10.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "6a556ff99f5bc4a1935bbc06aaf1bd93", + "name": "coloredlogs", + "sha256": "2d7c6f823d5107194e297670b2ed7a758536742bcb7d0cfa6d15a96b9b68029c", + "size": 60168, + "subdir": "linux-64", + "timestamp": 1526411758154, + "version": "10.0" + }, + "coloredlogs-10.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "398027a3c5df4ccd11a2fd943483001b", + "name": "coloredlogs", + "sha256": "e1c999189f6df65d8f2117fa623620820910bd64f8b54cc6530d4cd165de555c", + "size": 60943, + "subdir": "linux-64", + "timestamp": 1526411743260, + "version": "10.0" + }, + "coloredlogs-10.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a940896551e4fdcf755942973f8f85c1", + "name": "coloredlogs", + "sha256": "bcb2aa90c7f426fd428614e8c253960f514e3ff7dc97896dae55a98614f250e7", + "size": 60735, + "subdir": "linux-64", + "timestamp": 1526411730051, + "version": "10.0" + }, + "coloredlogs-10.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "733a9aba20c786c663b27a82a5c1ca33", + "name": "coloredlogs", + "sha256": "f4c08a69d24113300683d8f7b757fdcf68fd0a4dae713c8b1742faa4a8cad430", + "size": 60152, + "subdir": "linux-64", + "timestamp": 1530812322273, + "version": "10.0" + }, + "coloredlogs-10.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "6ac105708bd81aa49ef9f0f83f8be9d1", + "name": "coloredlogs", + "sha256": "dd17c485ddb82055910c1af33fe31d583895d2879056eb0ffc763bf7643051b6", + "size": 61057, + "subdir": "linux-64", + "timestamp": 1573741571593, + "version": "10.0" + }, + "coloredlogs-14.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4b8c6e575201920d6a63a6c3a952c61f", + "name": "coloredlogs", + "sha256": "e47ac013cdb25da54272330653b4f92478dadc7c58090e1f4a1d3521f7886e26", + "size": 64036, + "subdir": "linux-64", + "timestamp": 1598402400480, + "version": "14.0" + }, + "coloredlogs-14.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a56853d811200ad49c86220911f0bdbe", + "name": "coloredlogs", + "sha256": "8548c970da4d078cc8dbcff120f794ab60a305cf1d5fef36ae43cce6b2b39fab", + "size": 63707, + "subdir": "linux-64", + "timestamp": 1598402372710, + "version": "14.0" + }, + "coloredlogs-14.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "f5e8f868906b15f4ebfcaf476a8b4aee", + "name": "coloredlogs", + "sha256": "bc7aab231efc9feec02609694602bdb6bdc0ae2a512dd0c50a20a6c413644036", + "size": 63748, + "subdir": "linux-64", + "timestamp": 1598402365865, + "version": "14.0" + }, + "coloredlogs-15.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "766a309608a6364d4c328912cec75320", + "name": "coloredlogs", + "sha256": "9beccb48411ce775d71068f42d15335488de4974f682cde97b14563622a6c867", + "size": 64508, + "subdir": "linux-64", + "timestamp": 1607620761711, + "version": "15.0" + }, + "coloredlogs-15.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4ba0adab666527f19e5045ca2edc0a29", + "name": "coloredlogs", + "sha256": "4dd62e1400ff565b2cfddcfe93e81a5bd0670556dbbddeb88274fc887592d911", + "size": 64062, + "subdir": "linux-64", + "timestamp": 1607620750476, + "version": "15.0" + }, + "coloredlogs-15.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "8652cda95bf4ecb2c6db96a9d2975b74", + "name": "coloredlogs", + "sha256": "869a77cf60bc03b94d41660b3c4bcb99c962a514cbe5e312d18c672e8af988b8", + "size": 64191, + "subdir": "linux-64", + "timestamp": 1607620756949, + "version": "15.0" + }, + "coloredlogs-15.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "8020317801b649f2fa32c009b4852647", + "name": "coloredlogs", + "sha256": "c11f343cc358e380dd22b6afed3e60428ac5f518ffcb40df6eee3a4a6663a77e", + "size": 64308, + "subdir": "linux-64", + "timestamp": 1607620704588, + "version": "15.0" + }, + "coloredlogs-15.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=9.1", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4b677ba908a4064c10d41ad44361be6c", + "name": "coloredlogs", + "sha256": "5e94511ce88233a97365aa9c8a2d077da3a920cc7ba88eb4a16e4a45a9b3372d", + "size": 64950, + "subdir": "linux-64", + "timestamp": 1640808650082, + "version": "15.0.1" + }, + "coloredlogs-15.0.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "humanfriendly >=9.1", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "494e3d8aaec9207a16e19f9c8091180d", + "name": "coloredlogs", + "sha256": "f97b6217fc2b20effdf744bc4e303331c76a3905a2bb82349aed6f64b08c87f7", + "size": 64833, + "subdir": "linux-64", + "timestamp": 1668097846243, + "version": "15.0.1" + }, + "coloredlogs-15.0.1-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "humanfriendly >=9.1", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba72e4e6cd1abbfd01279dbbf0723a27", + "name": "coloredlogs", + "sha256": "0907510e721021d451c9b1567c20aac6eca57c3a2909ce9cb3fc9c10ad64bdda", + "size": 79788, + "subdir": "linux-64", + "timestamp": 1676843626781, + "version": "15.0.1" + }, + "coloredlogs-15.0.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=9.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "884d5472b4efbe93cee5f55bb2f9290c", + "name": "coloredlogs", + "sha256": "3d1c5d298a6b65e7f2015c22dcd7a1dd58fe1198110b45105c94efad03becfae", + "size": 64603, + "subdir": "linux-64", + "timestamp": 1623652097798, + "version": "15.0.1" + }, + "coloredlogs-15.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=9.1", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "57a165473089c821a7586d85115988b7", + "name": "coloredlogs", + "sha256": "2aa4d2122c0a009ea2eb083ecb955801e8b47424644653fa82fd6a437686db58", + "size": 64231, + "subdir": "linux-64", + "timestamp": 1623657678958, + "version": "15.0.1" + }, + "coloredlogs-15.0.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "humanfriendly >=9.1", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f306ac2c65b49ae1f791c01055fd7f4f", + "name": "coloredlogs", + "sha256": "06c46b2da0bd96f25b5455f8c029f59201620e819ee79cfde0b49e5b76e46d0f", + "size": 64366, + "subdir": "linux-64", + "timestamp": 1668097795444, + "version": "15.0.1" + }, + "coloredlogs-15.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=9.1", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d63c556c905aefbca80afaf9c3100035", + "name": "coloredlogs", + "sha256": "9aaed0ed0d337e4619f05a1c1183e1f456947262b30a7fb3481396351e35c14e", + "size": 64335, + "subdir": "linux-64", + "timestamp": 1623657837461, + "version": "15.0.1" + }, + "coloredlogs-15.0.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "humanfriendly >=9.1", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be3caaf99c6743fd686d4e523e3891a9", + "name": "coloredlogs", + "sha256": "3f5e6e3b5b815c7b9409612bf3e224a6dbd16d40935523e4d5042d1e14ec395e", + "size": 64507, + "subdir": "linux-64", + "timestamp": 1668097820634, + "version": "15.0.1" + }, + "coloredlogs-15.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=9.1", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7a05a5dc89479b0acb12d6fca220aae6", + "name": "coloredlogs", + "sha256": "924a9c8c1ed2869de6bbe40ca3999ef93a28263419764a55a412c71d9b9e4649", + "size": 64443, + "subdir": "linux-64", + "timestamp": 1623657861874, + "version": "15.0.1" + }, + "coloredlogs-15.0.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "humanfriendly >=9.1", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47362d05e098b68539a87a4fb14b1e25", + "name": "coloredlogs", + "sha256": "279b843976d8298e5bea9d7bdcf1196303dbec2e0c25a05253c2ec57f56ad172", + "size": 64535, + "subdir": "linux-64", + "timestamp": 1668097871432, + "version": "15.0.1" + }, + "coloredlogs-7.1-py27h929f1d2_0.tar.bz2": { + "build": "py27h929f1d2_0", + "build_number": 0, + "depends": [ + "humanfriendly >=3.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "dec14b1fb14f37cbfb7284e9bb3ea0fe", + "name": "coloredlogs", + "sha256": "f259836ad636b954d1bfe83c7c9c060b97e173d23b8b4c2bf1fde7501040306d", + "size": 45880, + "subdir": "linux-64", + "timestamp": 1505742020128, + "version": "7.1" + }, + "coloredlogs-7.1-py35h5a61da6_0.tar.bz2": { + "build": "py35h5a61da6_0", + "build_number": 0, + "depends": [ + "humanfriendly >=3.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "22d78bbc55951de4b800d2be18514144", + "name": "coloredlogs", + "sha256": "c2091f9cb261907026224cb3c6a929f761dd39897343744130d1ae62d686c114", + "size": 46619, + "subdir": "linux-64", + "timestamp": 1505742032983, + "version": "7.1" + }, + "coloredlogs-7.1-py36h6efce94_0.tar.bz2": { + "build": "py36h6efce94_0", + "build_number": 0, + "depends": [ + "humanfriendly >=3.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f0e6c44d578bd32a4b0e6f938e8964f4", + "name": "coloredlogs", + "sha256": "a8f31d12214731186b0618509e5dd3d7467ec26283c775a7b8f778b0dcae4367", + "size": 46554, + "subdir": "linux-64", + "timestamp": 1505742045841, + "version": "7.1" + }, + "coloredlogs-7.3.1-py27ha28782c_0.tar.bz2": { + "build": "py27ha28782c_0", + "build_number": 0, + "depends": [ + "humanfriendly >=3.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "8e5e49aac492062b3e3f12339fffbf61", + "name": "coloredlogs", + "sha256": "0983c2cb4769a8b68c2d31f733676712bf57a69f2f166440118b5209c2b13b0f", + "size": 46638, + "subdir": "linux-64", + "timestamp": 1511833935054, + "version": "7.3.1" + }, + "coloredlogs-7.3.1-py35hcde8493_0.tar.bz2": { + "build": "py35hcde8493_0", + "build_number": 0, + "depends": [ + "humanfriendly >=3.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "f5ae93a2014d7345f2c7c94c2efb6983", + "name": "coloredlogs", + "sha256": "9ace38528661d1bca7e2cf1efcd4cc061e1eb854ce160ba5e71de7307421afe3", + "size": 47219, + "subdir": "linux-64", + "timestamp": 1511833934162, + "version": "7.3.1" + }, + "coloredlogs-7.3.1-py36h93c201e_0.tar.bz2": { + "build": "py36h93c201e_0", + "build_number": 0, + "depends": [ + "humanfriendly >=3.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6fa9892abe5e242f8ff7d3b63d8a503a", + "name": "coloredlogs", + "sha256": "80e76624aa0c3c69d553b53503e519a7b8bcf06544e718af358aafea305615cd", + "size": 47126, + "subdir": "linux-64", + "timestamp": 1511833935373, + "version": "7.3.1" + }, + "coloredlogs-9.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "20b16778c462d29c547453c00316bda7", + "name": "coloredlogs", + "sha256": "4c4dc72eb58b9a0c8d693d61d5d444fcfa2a10a18b1bc79b7f493e71a4c91566", + "size": 54844, + "subdir": "linux-64", + "timestamp": 1519067891598, + "version": "9.0" + }, + "coloredlogs-9.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "5bfcb229eac071b6f0a99d2d54cfba33", + "name": "coloredlogs", + "sha256": "a3077cc94615b2e5d3dde9738ba46d9b5a18bec3f9f0159c7a9509940d2067ff", + "size": 55508, + "subdir": "linux-64", + "timestamp": 1519067955825, + "version": "9.0" + }, + "coloredlogs-9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "122edf264ef90f1629cfeae1ce712909", + "name": "coloredlogs", + "sha256": "b1ca5dc4ec0ac5a4c648c0efd108333c06b585a36cd272ad61537da86450fdeb", + "size": 55335, + "subdir": "linux-64", + "timestamp": 1519067933353, + "version": "9.0" + }, + "colorlog-4.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f103f10d22c430c82dd9f0699b8f77ee", + "name": "colorlog", + "sha256": "ff47a216b81e0dd9bbcb760de489a0559b58c067fe3e1262b509a1dffb1faca2", + "size": 22392, + "subdir": "linux-64", + "timestamp": 1579610324373, + "version": "4.0.2" + }, + "colorlog-4.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "53f8c01bbe6733f434b17c34ae9c3715", + "name": "colorlog", + "sha256": "cf1a70b68e019ca8f17b9481b9b0187c889c508f604116e5e0fccc78132c1a34", + "size": 22722, + "subdir": "linux-64", + "timestamp": 1579610327632, + "version": "4.0.2" + }, + "colorlog-4.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "0a47e122e33030e13f3970153a0f7fe8", + "name": "colorlog", + "sha256": "31b42ec357aef79618d19229f76238a4a5a16bc7ae19b04f5fa1bd734f1c67e6", + "size": 22670, + "subdir": "linux-64", + "timestamp": 1579610297445, + "version": "4.0.2" + }, + "colorlog-4.0.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "052c8a15abbadfebd2971dfd0f10061a", + "name": "colorlog", + "sha256": "1dd95d2af8fb4ed42398c22a3c6715057e04a383682d2a2c374530a824628363", + "size": 22803, + "subdir": "linux-64", + "timestamp": 1579610328408, + "version": "4.0.2" + }, + "colorlog-4.1.0-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1dc0ca19142f77ef701249f15ee94751", + "name": "colorlog", + "sha256": "3f00861cec9f55e7eb3cfe8047a62caf39597c07f67157e3add5c6e54032fade", + "size": 20004, + "subdir": "linux-64", + "timestamp": 1594344360049, + "version": "4.1.0" + }, + "colorlog-4.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "fd628a462aefd57d4229f26a15408a63", + "name": "colorlog", + "sha256": "8e98f6ab69464bfe1ff27fa0961766c8f9145c3209bf125dd858aed04d428b6c", + "size": 23601, + "subdir": "linux-64", + "timestamp": 1596109906115, + "version": "4.2.1" + }, + "colorlog-4.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d5c74abeac10b04b3636ba19a4030470", + "name": "colorlog", + "sha256": "5ad7f5d466e94214a0738c4d9ba54fb43271d9f91c4398baf8c71880313c59ed", + "size": 23536, + "subdir": "linux-64", + "timestamp": 1596128714439, + "version": "4.2.1" + }, + "colorlog-4.2.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "7b0cddffcc1c4b7c90464b43c41a8969", + "name": "colorlog", + "sha256": "8d3bf81af42c60547e88f323004899e64a1346e3fe9c7611a85aaa72b8fcd0b5", + "size": 23688, + "subdir": "linux-64", + "timestamp": 1596109909721, + "version": "4.2.1" + }, + "colorlog-4.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "37c535a9757bc2d86043c679cf558192", + "name": "colorlog", + "sha256": "44dec63a4bf54eeadb16f95514f84fba0681eb163c0e83449bab5e03e68815e1", + "size": 21016, + "subdir": "linux-64", + "timestamp": 1602256051993, + "version": "4.4.0" + }, + "colorlog-4.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1211361d4c4ef379dccc7b7d2a8b3d0c", + "name": "colorlog", + "sha256": "3d8756ef5107c85d7637c656605aaefe05243678e9264a72615ac4224bb22836", + "size": 20962, + "subdir": "linux-64", + "timestamp": 1602256058298, + "version": "4.4.0" + }, + "colorlog-4.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "1e66835f17c601ae21667efcc0919b65", + "name": "colorlog", + "sha256": "f95c33ebd294f898b7aaa0b8ba336349f0162d671b4a63dceac32b48423b7feb", + "size": 21109, + "subdir": "linux-64", + "timestamp": 1602256061991, + "version": "4.4.0" + }, + "colorlog-4.6.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a9bdee74964023c33931d67c853322db", + "name": "colorlog", + "sha256": "4fec98e5f4c3cf24c7b25d9bf6685e12576e3f62db7057f7ab3686e683fd4127", + "size": 15121, + "subdir": "linux-64", + "timestamp": 1605061878597, + "version": "4.6.2" + }, + "colorlog-4.6.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b10cb5d4b4d93c8be1822721b9623508", + "name": "colorlog", + "sha256": "bf7223a807d107ef0befacc560ea9c64ccf97572ea5291ac0a898412f0f8233b", + "size": 15064, + "subdir": "linux-64", + "timestamp": 1605061909588, + "version": "4.6.2" + }, + "colorlog-4.6.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "5b88c3082eeefa3c5dbd0820a60b813f", + "name": "colorlog", + "sha256": "ab9018f8704845bc4e966a3806cd74100ec5d114b4bb273f7b7fe5a8ba9472e1", + "size": 15137, + "subdir": "linux-64", + "timestamp": 1605061906741, + "version": "4.6.2" + }, + "colorlog-4.6.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "2bac27abdb60d27af08df20fc7319429", + "name": "colorlog", + "sha256": "293bb5cf591092cafd1fd9d777cf15eb5c931bcef3f887c82c77833378dfbbbc", + "size": 15098, + "subdir": "linux-64", + "timestamp": 1605061879582, + "version": "4.6.2" + }, + "colorlog-4.7.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7970b8333c62d87bd5091ccdb0005b77", + "name": "colorlog", + "sha256": "83dc256adf05cfb9897f4fd346ec822b8f5fe218a1c9b68677440f6cab2b07b1", + "size": 15296, + "subdir": "linux-64", + "timestamp": 1610638734062, + "version": "4.7.2" + }, + "colorlog-4.7.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d667bd5dd23aa9dc9c77f492745894b2", + "name": "colorlog", + "sha256": "58a5184648544674e68df3604099929963e275a26c877136909e6030a443c252", + "size": 15279, + "subdir": "linux-64", + "timestamp": 1610638718685, + "version": "4.7.2" + }, + "colorlog-4.7.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "d60a354f062d586c84675dc1dd710152", + "name": "colorlog", + "sha256": "02b2cad127f6d4e2cfd916000fcf41f59e658823586532c144bdd81a3e8b5360", + "size": 15310, + "subdir": "linux-64", + "timestamp": 1610638762014, + "version": "4.7.2" + }, + "colorlog-4.7.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "216ca46793faba889b6b0fee394e2860", + "name": "colorlog", + "sha256": "9614518ab9143e85ee16bd518d0afc9be1d2bb6bd490229e7c38a6e96e33a2db", + "size": 15302, + "subdir": "linux-64", + "timestamp": 1610638731314, + "version": "4.7.2" + }, + "colorlog-4.8.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "6f162076f8efff1f493a6a65d86f4df1", + "name": "colorlog", + "sha256": "8a88fa098bee0c0fde4dcf8ad8fbade5fe8394fdb740b538730eecbfc924acb3", + "size": 15132, + "subdir": "linux-64", + "timestamp": 1659787862390, + "version": "4.8.0" + }, + "colorlog-4.8.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2d0a2d473e8823f343977b53b13733b5", + "name": "colorlog", + "sha256": "b7eb4f34221ff6f1b0c822253bff68c27b9efaf81bfe1e25e64cdf26faf3266e", + "size": 15307, + "subdir": "linux-64", + "timestamp": 1616441703366, + "version": "4.8.0" + }, + "colorlog-4.8.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7a94824b7662e66ddfbc1ac449e0501b", + "name": "colorlog", + "sha256": "c07304c8bbfdd20971086cb5d6626e0f0ae5ea446c4cb7f784b7e8f3118cab37", + "size": 15272, + "subdir": "linux-64", + "timestamp": 1616441690750, + "version": "4.8.0" + }, + "colorlog-4.8.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "1192c4c9bf0407cb0bbb7cf52caf93a7", + "name": "colorlog", + "sha256": "1cae3db2a45d58ef6ed79a1969dfd7d26f445aa190d815db12f15a68ca658405", + "size": 15273, + "subdir": "linux-64", + "timestamp": 1616441701284, + "version": "4.8.0" + }, + "colorlog-4.8.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "8c2bc927a9fbc3b7f763b389c5c2ccf8", + "name": "colorlog", + "sha256": "46cc78195d530e1f9fa8de46b382528cbd5efafbb72f7ca53ee475ee3c2afb54", + "size": 15299, + "subdir": "linux-64", + "timestamp": 1616442749917, + "version": "4.8.0" + }, + "colorlog-5.0.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "136e9a8a79d465e5d595a3458967b6c7", + "name": "colorlog", + "sha256": "e7aeb7e5503e9594562e1d1c8838b643476ff32b7aaa9ba87769e2b7146db5fe", + "size": 15564, + "subdir": "linux-64", + "timestamp": 1640789113782, + "version": "5.0.1" + }, + "colorlog-5.0.1-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "c6204bfe8c1ca52df57ca3b4885e2c90", + "name": "colorlog", + "sha256": "7e6b6fbb314d86dfd7328d43997ab64f3fd48ba40491eb621ede70cb54293777", + "size": 18334, + "subdir": "linux-64", + "timestamp": 1676830303273, + "version": "5.0.1" + }, + "colorlog-5.0.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "542ad448a75efc429478aab57c54cf3b", + "name": "colorlog", + "sha256": "a2234e6afcd0b2c834195417a8d5e2b235da233b31807cf86f2c6d4a2961a676", + "size": 15675, + "subdir": "linux-64", + "timestamp": 1618421517613, + "version": "5.0.1" + }, + "colorlog-5.0.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "9d45277dafb40c925a6f8976499135fd", + "name": "colorlog", + "sha256": "ba4e47c3b5f4741efea6072985ee497421c9740687bad8bc3878fe26950ad16a", + "size": 15636, + "subdir": "linux-64", + "timestamp": 1618424631529, + "version": "5.0.1" + }, + "colorlog-5.0.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "e9ad6072c2a9b3aac19ca09bc40c78f2", + "name": "colorlog", + "sha256": "d42154d2877669f5e2b5617edff542b67e4bfb14736d610edc6c0dba62b96e6f", + "size": 15668, + "subdir": "linux-64", + "timestamp": 1618424636494, + "version": "5.0.1" + }, + "colorlog-5.0.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "83211ce91afb3768e4cc6604c4459675", + "name": "colorlog", + "sha256": "fec88519f167c71273911d401cee2c32ddc5fd0da1717e1677a6c1288db88855", + "size": 15694, + "subdir": "linux-64", + "timestamp": 1618424627858, + "version": "5.0.1" + }, + "colorspacious-1.1.2-py310h2f386ee_0.tar.bz2": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6cb2c269a40352eca2421586ebd90932", + "name": "colorspacious", + "sha256": "c9314bdacb7ff1412c52baef531f469f7dcaad4e870baf2df879a398c872f918", + "size": 61829, + "subdir": "linux-64", + "timestamp": 1680616714545, + "version": "1.1.2" + }, + "colorspacious-1.1.2-py311h92b7b1e_0.tar.bz2": { + "build": "py311h92b7b1e_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "855c7fc0f8b799911210b39bf298f1d3", + "name": "colorspacious", + "sha256": "7b2860b03dc597014662280b079f167db447f94065930a8d51aa25872a496503", + "size": 77877, + "subdir": "linux-64", + "timestamp": 1680616749222, + "version": "1.1.2" + }, + "colorspacious-1.1.2-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "450bb1b8ba21a892adb51e9d1ce1e63d", + "name": "colorspacious", + "sha256": "ad310e25e9c28d250aa2801aa1d28d925a17c3bf0b479f28c381e6f9396f22dd", + "size": 62114, + "subdir": "linux-64", + "timestamp": 1680616784262, + "version": "1.1.2" + }, + "colorspacious-1.1.2-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0090f513f5cf610ed12dfca58f8b4005", + "name": "colorspacious", + "sha256": "febcd851df090a9b6ecdfbf6586c7cbda0542c7670833eb0a0d2d27baa8e97e8", + "size": 61509, + "subdir": "linux-64", + "timestamp": 1680616818907, + "version": "1.1.2" + }, + "colour-0.1.4-py27hfe1fa20_0.tar.bz2": { + "build": "py27hfe1fa20_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b3382aa3475823256e3b033c92e99b7f", + "name": "colour", + "sha256": "4e1084046049eabcd00fd9ecff488698b1a04bbafac1a7cdd3f13779d1b83e50", + "size": 26567, + "subdir": "linux-64", + "timestamp": 1507380363367, + "version": "0.1.4" + }, + "colour-0.1.4-py35h9dd72a6_0.tar.bz2": { + "build": "py35h9dd72a6_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "75745dfefd6c9428deeae9bc0144d97f", + "name": "colour", + "sha256": "18cf99cefb00ed25be6645cf1faf25a8f7741025a6a7ba86f1e0cd74602b6f70", + "size": 27189, + "subdir": "linux-64", + "timestamp": 1507380305267, + "version": "0.1.4" + }, + "colour-0.1.4-py36hc4b9af0_0.tar.bz2": { + "build": "py36hc4b9af0_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "319d29c61c20317a0755f473ed814449", + "name": "colour", + "sha256": "47918811c4fb5ecf0db1eb0f38464d8e25e30ceff2e03c69a392957b508b9f89", + "size": 27456, + "subdir": "linux-64", + "timestamp": 1507380373084, + "version": "0.1.4" + }, + "colour-0.1.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "02fc2066d2c9c5682d5b25d49bd90d60", + "name": "colour", + "sha256": "ed4427703a5125dca6d1f472f5aada98200768672be051cb22b9e27ccc1d1f20", + "size": 26313, + "subdir": "linux-64", + "timestamp": 1530812421995, + "version": "0.1.5" + }, + "colour-0.1.5-py27hc2ab70b_0.tar.bz2": { + "build": "py27hc2ab70b_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a95415233b9a66ecb1a012599597a5d3", + "name": "colour", + "sha256": "bd5e9b6b6c256ead397e6db6621dfca57ac796e75428ef244a1a452c4008eafd", + "size": 26620, + "subdir": "linux-64", + "timestamp": 1511838122845, + "version": "0.1.5" + }, + "colour-0.1.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5b9407a0a4c5d4709f9aba0b53bcab30", + "name": "colour", + "sha256": "d06630d19af083930ee10a8af51835b5e019d8ef2df09fdee04c0708cc3f3aa8", + "size": 27958, + "subdir": "linux-64", + "timestamp": 1642498789456, + "version": "0.1.5" + }, + "colour-0.1.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b6935f3c42bb2bf180ec07238b63bc38", + "name": "colour", + "sha256": "fe12fc80e3791a8f24a4a97e8b9200ae2d343135284f19e2f0bb377b1e559134", + "size": 32690, + "subdir": "linux-64", + "timestamp": 1676827064417, + "version": "0.1.5" + }, + "colour-0.1.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "bbe9e92809aec1231f62185572862ac0", + "name": "colour", + "sha256": "ce7e2019e5080297562034d395a86d6b36c2fdc859aa89b64793271689fb458f", + "size": 26939, + "subdir": "linux-64", + "timestamp": 1535130080582, + "version": "0.1.5" + }, + "colour-0.1.5-py35h628fc48_0.tar.bz2": { + "build": "py35h628fc48_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3ea8d9cdfad4e4989b165ab014d8c423", + "name": "colour", + "sha256": "e66991e704251863a91b109c43223dc63989e7ca7feb26015b1e38347ad312e9", + "size": 27216, + "subdir": "linux-64", + "timestamp": 1511838150145, + "version": "0.1.5" + }, + "colour-0.1.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "1345ebbf953008c9f9f3696bc7c77016", + "name": "colour", + "sha256": "05a0cd3b782687542d553b489d81d4b131c1d132e6fb26213345a45bf0d3b8de", + "size": 27142, + "subdir": "linux-64", + "timestamp": 1530812470200, + "version": "0.1.5" + }, + "colour-0.1.5-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "594299f427d8db3f6a37a98c8c63dec7", + "name": "colour", + "sha256": "a0fa9c0581a9d96e0b36207f25bc46343e7687d3312942ac7f42c5c1735e6bc9", + "size": 27997, + "subdir": "linux-64", + "timestamp": 1611677515338, + "version": "0.1.5" + }, + "colour-0.1.5-py36ha0e6178_0.tar.bz2": { + "build": "py36ha0e6178_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b08e1c9e1da82d9a9de5d20029536673", + "name": "colour", + "sha256": "39ca2aaa7afb7b35b6b73516494aa4c926053793eb999a9fe8b4e1437fe94a19", + "size": 27471, + "subdir": "linux-64", + "timestamp": 1511838159395, + "version": "0.1.5" + }, + "colour-0.1.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4f2a4f8f65f51a510c9fe41e2228976d", + "name": "colour", + "sha256": "55e0c35e9358dd7a2110a318a6a9af91a1c96b039baf7635b79d172715cb0baf", + "size": 26556, + "subdir": "linux-64", + "timestamp": 1530812445891, + "version": "0.1.5" + }, + "colour-0.1.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "54d6819c70cc84d413ac9629bff24e21", + "name": "colour", + "sha256": "5d023f7ad9dc2e130f2cab1decf52d80629a9e4366c9193adfacd8d404f25909", + "size": 27399, + "subdir": "linux-64", + "timestamp": 1611678448752, + "version": "0.1.5" + }, + "colour-0.1.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "337dbaff554131e34b3139446787f472", + "name": "colour", + "sha256": "942d6f4e8220f2b8c86c9c730856c8c4fb12c38158257cbb5bca6c4c0e76973d", + "size": 27147, + "subdir": "linux-64", + "timestamp": 1573033880420, + "version": "0.1.5" + }, + "colour-0.1.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "6b95286589123f3482a584d70e7d3b34", + "name": "colour", + "sha256": "abbddc0d8a8af5ebfe4f1ff3ec6ae06b167329e7307e5e1bd7f5722af6fa65e3", + "size": 27531, + "subdir": "linux-64", + "timestamp": 1611677567509, + "version": "0.1.5" + }, + "colour-0.1.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "2d53a5994cbf99d7eee7af5e75e66482", + "name": "colour", + "sha256": "5d79dcfd6970f2a7e42cb302dc0d77482116a8423a6a518aa88c32d5639557f4", + "size": 27523, + "subdir": "linux-64", + "timestamp": 1611677549843, + "version": "0.1.5" + }, + "comm-0.1.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ccaf333120348af98f94afdfa8363aac", + "name": "comm", + "sha256": "810d05cf52bfc487a64d6c664fc822e10ec307553fe6c0bbc85dbe39487e689f", + "size": 12768, + "subdir": "linux-64", + "timestamp": 1671231151980, + "version": "0.1.2" + }, + "comm-0.1.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e0631ec02ad9afd01a077509fde68b1b", + "name": "comm", + "sha256": "fcd93d0f515f326a67a4967fbf35b3cd916716f4022851c166101c8ba3277a54", + "size": 14821, + "subdir": "linux-64", + "timestamp": 1677709155428, + "version": "0.1.2" + }, + "comm-0.1.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1190472ede3b1c40d0ba47ca86174e34", + "name": "comm", + "sha256": "e42c8956713db7f95676cd6fa3920778e291a2db3c505b10c43a62250e065123", + "size": 12718, + "subdir": "linux-64", + "timestamp": 1671231179439, + "version": "0.1.2" + }, + "comm-0.1.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5944cf6bfa04b7b79479c6b5eec2a856", + "name": "comm", + "sha256": "93e6082d2635e03b9e7d87aea7ec3b4c98e8d40698a29ce01386b0f5cd038f75", + "size": 12695, + "subdir": "linux-64", + "timestamp": 1671231231929, + "version": "0.1.2" + }, + "comm-0.1.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "13702d3b4b744784e5bd559c7050dd6f", + "name": "comm", + "sha256": "9127732de58afa6a03a8c5009d7f918bc7cf0307ba5e1a5afb6f917fe75c2151", + "size": 12719, + "subdir": "linux-64", + "timestamp": 1671231205875, + "version": "0.1.2" + }, + "commonmark-0.7.4-py27h72fa2ff_0.tar.bz2": { + "build": "py27h72fa2ff_0", + "build_number": 0, + "depends": [ + "future", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fe9173e923f561754002ca31a99378b6", + "name": "commonmark", + "sha256": "184f0292a8603828c453607c97aac92d6addd91972df4d92d67e2c9f1beb9965", + "size": 128098, + "subdir": "linux-64", + "timestamp": 1509258327521, + "version": "0.7.4" + }, + "commonmark-0.7.4-py35h6786c5e_0.tar.bz2": { + "build": "py35h6786c5e_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5c3bc22c4c988c72592accc4430dd947", + "name": "commonmark", + "sha256": "c3b3c2561bc3c05115ae69b02a18f407b49f5ce5dcd23cecfef9828a5dc85b53", + "size": 127671, + "subdir": "linux-64", + "timestamp": 1509258340432, + "version": "0.7.4" + }, + "commonmark-0.7.4-py36h4201aee_0.tar.bz2": { + "build": "py36h4201aee_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "12d7e5ba53e9d823d44e5d695abb3ea3", + "name": "commonmark", + "sha256": "8e97eb4980fbb442360936361e7793c055546111d7cb52e55d1fa21b783c5417", + "size": 123039, + "subdir": "linux-64", + "timestamp": 1509258329934, + "version": "0.7.4" + }, + "commonmark-0.7.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "future", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "887c1732c25f1240dcf91412875d47a0", + "name": "commonmark", + "sha256": "249b1defcd101e9c59a89d342c5236829c8dbf383fac5d364be994e909c4fdae", + "size": 128466, + "subdir": "linux-64", + "timestamp": 1522193091440, + "version": "0.7.5" + }, + "commonmark-0.7.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c90452fe23fa19ea95f78e35bc2688a1", + "name": "commonmark", + "sha256": "8308c64437831eef40734397e98feb73f1e2f9d5766aec06e7216de40b44bb11", + "size": 127885, + "subdir": "linux-64", + "timestamp": 1522193123699, + "version": "0.7.5" + }, + "commonmark-0.7.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ea1dcadca57c5a9e6108b27a32b0e7bb", + "name": "commonmark", + "sha256": "7e3c6f6854b68d91d4c29475ef4b96046ef94e9ea8db98c2bae110a61b4c7d17", + "size": 123299, + "subdir": "linux-64", + "timestamp": 1522193118643, + "version": "0.7.5" + }, + "commonmark-0.7.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "788d9a194bfb25e3cbc96a719dabb8cb", + "name": "commonmark", + "sha256": "f334e2ae90053ed9a829f8ff685853e7807e7bdbcf6c10327470ecda4399a640", + "size": 123295, + "subdir": "linux-64", + "timestamp": 1530812730975, + "version": "0.7.5" + }, + "commonmark-0.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "future", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aaca02eac612bbbdb44f9bf7bee8a490", + "name": "commonmark", + "sha256": "8bbf9a1e3ee75e7b3b732dc131a31c073fbb38bca5fe3efa4fb0b2f40f1910e0", + "size": 130166, + "subdir": "linux-64", + "timestamp": 1536272679477, + "version": "0.8.1" + }, + "commonmark-0.8.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b181c2482ad3c7730310fbbb44e62cef", + "name": "commonmark", + "sha256": "1d44dffaa2481954da3b661565fecff089873aefae5541cebf9373aaab01e8f4", + "size": 130279, + "subdir": "linux-64", + "timestamp": 1536272711658, + "version": "0.8.1" + }, + "commonmark-0.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2a4d323cfe184b984efbbc699e0772ae", + "name": "commonmark", + "sha256": "5905cd0127cff7a6c7621c17ab6e78cb788308f34e8cc7f08457ab4924273192", + "size": 125208, + "subdir": "linux-64", + "timestamp": 1536272650309, + "version": "0.8.1" + }, + "commonmark-0.8.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7b9fb568f7ae1f0a2dc9553f0ab4acc8", + "name": "commonmark", + "sha256": "18c23c93e99b32a4515615006261fdc1c4471b815150c0c372d17250f9a45265", + "size": 125677, + "subdir": "linux-64", + "timestamp": 1536272709325, + "version": "0.8.1" + }, + "compiler-rt-14.0.6-hdb19cb5_0.tar.bz2": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "clang 14.0.6.*", + "clangxx 14.0.6.*", + "compiler-rt_linux-64 14.0.6.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "fa51cf4f3c052022d8ea221806906e37", + "name": "compiler-rt", + "sha256": "5c75d48d4a44825b89c3f5c073ff51d74e3397a37f4ff8166bb7afcb53191cc4", + "size": 101178, + "subdir": "linux-64", + "timestamp": 1662620696837, + "version": "14.0.6" + }, + "compiler-rt_linux-64-14.0.6-h2bdc9af_0.tar.bz2": { + "build": "h2bdc9af_0", + "build_number": 0, + "constrains": [ + "compiler-rt 14.0.6" + ], + "depends": [ + "clang 14.0.6.*", + "clangxx 14.0.6.*" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "2ddc97724c2eddc80edab8646da81b7a", + "name": "compiler-rt_linux-64", + "sha256": "737076920898a7b4a4452f4591762b7c8d56e3b71ca937427b94a9ab17cb15be", + "size": 64497793, + "subdir": "linux-64", + "timestamp": 1662620653781, + "version": "14.0.6" + }, + "conda-22.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-libmamba-solver >=22.12.0" + ], + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4a7463d682d711cc6b2fe821df3b6530", + "name": "conda", + "sha256": "c643122f2465a194faaf17e8d98013e32add399cb263a1b553270a35771d545b", + "size": 989912, + "subdir": "linux-64", + "timestamp": 1669901399831, + "version": "22.11.0" + }, + "conda-22.11.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e11a8f1132ade8ec29d35bc3a6c6de5", + "name": "conda", + "sha256": "e111752c70b54a1f6ce01ae5d720c239fc2bc021eb079eebbfcbf54b17759f27", + "size": 987367, + "subdir": "linux-64", + "timestamp": 1669926935220, + "version": "22.11.0" + }, + "conda-22.11.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "011c4b1fede6bfcc7c12a9827f572380", + "name": "conda", + "sha256": "cc9795dd55e2ac59671fc98d9a451e2ebf85617b2928ac6fb08bed0f0244f154", + "size": 974905, + "subdir": "linux-64", + "timestamp": 1669901305611, + "version": "22.11.0" + }, + "conda-22.11.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "064c2e39f610927b3048f2d757a75d63", + "name": "conda", + "sha256": "0075af4eedf2e66b8e0742b70d25ccef9b7b71bc7fdafa8a97936f57732aeab4", + "size": 973748, + "subdir": "linux-64", + "timestamp": 1669927063632, + "version": "22.11.0" + }, + "conda-22.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "110e7a6a669deb12e978cb7cc4e40904", + "name": "conda", + "sha256": "9192fe393a958a8d7478db95b9249ce516676b17b155ff76c05f3a40ef65117c", + "size": 981823, + "subdir": "linux-64", + "timestamp": 1669901258138, + "version": "22.11.0" + }, + "conda-22.11.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d6778b8c255df1ae1aab8ded7906cc3f", + "name": "conda", + "sha256": "8c9f15044c37c624d2390da707e76ce8fe8e98a4fa51467b3814b545e3d200f7", + "size": 978537, + "subdir": "linux-64", + "timestamp": 1669927018283, + "version": "22.11.0" + }, + "conda-22.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "abfd6de8a2d1892399a44d4adaa1bdb3", + "name": "conda", + "sha256": "ea5333f7daed84c502278d45c33a61eda6cc586b6a051a38631fe1beef035793", + "size": 982196, + "subdir": "linux-64", + "timestamp": 1669901353874, + "version": "22.11.0" + }, + "conda-22.11.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "39cc45693648545784204d638868de16", + "name": "conda", + "sha256": "aa55c1c3f47a26b78dcbd41aa8c79489535a0b8f76b34b7916312fec62bab8ae", + "size": 979772, + "subdir": "linux-64", + "timestamp": 1669926974969, + "version": "22.11.0" + }, + "conda-22.11.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "constrains": [ + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-build >=3", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "509a5364fb56cc06dc532fabcdc42d63", + "name": "conda", + "sha256": "cdf1eff35896592a2761a6fbe4e1cb1f8d2a0c8b1409c40b2815c9558ce27653", + "size": 995554, + "subdir": "linux-64", + "timestamp": 1670407562645, + "version": "22.11.1" + }, + "conda-22.11.1-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "constrains": [ + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-env >=2.6", + "conda-build >=3", + "conda-libmamba-solver >=22.12.0" + ], + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7de027f7512ea0557dc86ef0dd6df2a5", + "name": "conda", + "sha256": "cd15bb56c8ae48181ff135c6380a59e662859a051f3d932d9ca51ac2a763fb70", + "size": 992592, + "subdir": "linux-64", + "timestamp": 1670449284179, + "version": "22.11.1" + }, + "conda-22.11.1-py310h06a4308_3.tar.bz2": { + "build": "py310h06a4308_3", + "build_number": 3, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7160174e7476ac19daead85c7969195b", + "name": "conda", + "sha256": "85633a2b632f45443218b8b3eed993a96e17f8797e7f4ee7077132fceaf38839", + "size": 991332, + "subdir": "linux-64", + "timestamp": 1670452086904, + "version": "22.11.1" + }, + "conda-22.11.1-py310h06a4308_4.tar.bz2": { + "build": "py310h06a4308_4", + "build_number": 4, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-libmamba-solver >=22.12.0" + ], + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7702e79a58d494b4735d343e929b3cce", + "name": "conda", + "sha256": "79163868b4b2817e0159e52036d57bc778366d30225c5b3423b6d6b57a8de035", + "size": 989069, + "subdir": "linux-64", + "timestamp": 1671037196475, + "version": "22.11.1" + }, + "conda-22.11.1-py310h06a4308_5.tar.bz2": { + "build": "py310h06a4308_5", + "build_number": 5, + "constrains": [ + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "conda-libmamba-solver >=22.12.0" + ], + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9164755925ae164747b701335c8de173", + "name": "conda", + "sha256": "23a8aed99ec80aba2bdcadd34c1e9000dd27b0f6cd405190e63aa3f28399321d", + "size": 1001848, + "subdir": "linux-64", + "timestamp": 1680642425986, + "version": "22.11.1" + }, + "conda-22.11.1-py311h06a4308_5.tar.bz2": { + "build": "py311h06a4308_5", + "build_number": 5, + "constrains": [ + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.11,<3.12.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aa36072eda40cdcbec5a7dfe17092559", + "name": "conda", + "sha256": "911e0b88890d884674073ddaa5bb2cb88c531431d168aa74a6bffa0c5a4ddeb5", + "size": 1312654, + "subdir": "linux-64", + "timestamp": 1680642376298, + "version": "22.11.1" + }, + "conda-22.11.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-build >=3", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c084d362f964fbcd5b9492da53ad1ef4", + "name": "conda", + "sha256": "5ce68dbe622a796a2b60b7e06bc73a5d3f896c75110983a6ba9d21a0f71257a0", + "size": 976471, + "subdir": "linux-64", + "timestamp": 1670407521352, + "version": "22.11.1" + }, + "conda-22.11.1-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "constrains": [ + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-env >=2.6", + "conda-build >=3", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a9d10ae4d1a8eb51323bc89835718ebc", + "name": "conda", + "sha256": "25991f7168e59daa280e7de00ad28fd7509273df77f423d3f1fe1b6ee2744d1f", + "size": 979794, + "subdir": "linux-64", + "timestamp": 1670449326542, + "version": "22.11.1" + }, + "conda-22.11.1-py37h06a4308_3.tar.bz2": { + "build": "py37h06a4308_3", + "build_number": 3, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "301b706c207fdc4256fcf152e4d91e48", + "name": "conda", + "sha256": "14b83fded8fa54adbe15f7a4ba51d8778e774a058ae4302e635144f984392ba3", + "size": 978402, + "subdir": "linux-64", + "timestamp": 1670452045358, + "version": "22.11.1" + }, + "conda-22.11.1-py37h06a4308_4.tar.bz2": { + "build": "py37h06a4308_4", + "build_number": 4, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9c1123ed79fc5320ab4d684aee3a1a60", + "name": "conda", + "sha256": "712332c0d52ddb03eade637284b08133b288fdf21c7993b79646c0c26aba8225", + "size": 969242, + "subdir": "linux-64", + "timestamp": 1671037153602, + "version": "22.11.1" + }, + "conda-22.11.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-build >=3", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a29de3e8085aced064c5a741fffdcd69", + "name": "conda", + "sha256": "765f55d22d6136d0c9e34846de19198ddec40420090fb3da17436dd18fd66505", + "size": 983733, + "subdir": "linux-64", + "timestamp": 1670407601851, + "version": "22.11.1" + }, + "conda-22.11.1-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "constrains": [ + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-env >=2.6", + "conda-build >=3", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f68a428fa087b0324f76f589fb23310", + "name": "conda", + "sha256": "fb18c8817552af9f32f48398c4da230e89b1a77c79728ee20056f0d7e2f81570", + "size": 982363, + "subdir": "linux-64", + "timestamp": 1670449410623, + "version": "22.11.1" + }, + "conda-22.11.1-py38h06a4308_3.tar.bz2": { + "build": "py38h06a4308_3", + "build_number": 3, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1772c97e7fee7bfd790dbc457ef1f126", + "name": "conda", + "sha256": "286a12c5eff42f0de53e7323effdc4bee64fa048164e11c3310c2d937df51e43", + "size": 980937, + "subdir": "linux-64", + "timestamp": 1670452167935, + "version": "22.11.1" + }, + "conda-22.11.1-py38h06a4308_4.tar.bz2": { + "build": "py38h06a4308_4", + "build_number": 4, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "35778e1a724d5ecb8a02dcbda3bbb25f", + "name": "conda", + "sha256": "896afdb84dcc68363c215c817af0b95e822b6daffc26c71b4a1c02d06c81572e", + "size": 976612, + "subdir": "linux-64", + "timestamp": 1671037238124, + "version": "22.11.1" + }, + "conda-22.11.1-py38h06a4308_5.tar.bz2": { + "build": "py38h06a4308_5", + "build_number": 5, + "constrains": [ + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "058ac9d4ca40097cbb6b8f306ec70dd0", + "name": "conda", + "sha256": "1669ccd4afcf47619c0cfe8edf2d98f139774330300520eee5fe5ed9e6c99cc9", + "size": 991328, + "subdir": "linux-64", + "timestamp": 1680642323658, + "version": "22.11.1" + }, + "conda-22.11.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-build >=3", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "be8c64c0bd4b305d1f5cb68f62fb946f", + "name": "conda", + "sha256": "b6378a103725f5c8af6cb350a07874c4a1aa89b51250d2bf4e983eb50b1315fe", + "size": 986685, + "subdir": "linux-64", + "timestamp": 1670407478425, + "version": "22.11.1" + }, + "conda-22.11.1-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "constrains": [ + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-env >=2.6", + "conda-build >=3", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c215d0b1d35e053bf1ae72b2381ff28e", + "name": "conda", + "sha256": "c0c451371a3def72df1482876e561b57f900998b2b045f438a7ddd308e019f56", + "size": 984187, + "subdir": "linux-64", + "timestamp": 1670449368715, + "version": "22.11.1" + }, + "conda-22.11.1-py39h06a4308_3.tar.bz2": { + "build": "py39h06a4308_3", + "build_number": 3, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d04df89fd86598745bd65d9cbdf909ec", + "name": "conda", + "sha256": "c4a7638127be88c454e185f557bcca2a49f032f2f35d6aa5568fc4cdea4e1cad", + "size": 982853, + "subdir": "linux-64", + "timestamp": 1670452126708, + "version": "22.11.1" + }, + "conda-22.11.1-py39h06a4308_4.tar.bz2": { + "build": "py39h06a4308_4", + "build_number": 4, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "acd391eb410a56c40050dee2f30309a8", + "name": "conda", + "sha256": "fed288db8e3f663ed4a5bce6913df2fcd5f0d521b0bc6f289905cf7b3579d016", + "size": 978251, + "subdir": "linux-64", + "timestamp": 1671037280814, + "version": "22.11.1" + }, + "conda-22.11.1-py39h06a4308_5.tar.bz2": { + "build": "py39h06a4308_5", + "build_number": 5, + "constrains": [ + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d76899caffa4e78fd163d2858d8d3b75", + "name": "conda", + "sha256": "94d5bc7d5953898800f0ddf40008bb7d085265e5c94921a213121a687aed4573", + "size": 992842, + "subdir": "linux-64", + "timestamp": 1680642267542, + "version": "22.11.1" + }, + "conda-22.9.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.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.17", + "setuptools >=31.0.1", + "toolz >=0.8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b7f403c7d91c7245c78b1c15e36b361e", + "name": "conda", + "sha256": "bcfe4ae04ad5db83e09e067ebe7d1cc71f1b687048af105f06bf3964a58ca51e", + "size": 998489, + "subdir": "linux-64", + "timestamp": 1664201248220, + "version": "22.9.0" + }, + "conda-22.9.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.1,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1", + "toolz >=0.8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "58ea53c22aec3275d6fae25690e62f3f", + "name": "conda", + "sha256": "dd68b3d445bb5652ba2e30a497d1d130a949758cb8a5ada1ba9216ea32bcf671", + "size": 981391, + "subdir": "linux-64", + "timestamp": 1664201142672, + "version": "22.9.0" + }, + "conda-22.9.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1", + "toolz >=0.8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f9982e6e3f37cbb533e648da6413c4aa", + "name": "conda", + "sha256": "f6f66f85863b67f05220d81bcce4449fee3274822d7da2bd6e5774814f4b66f6", + "size": 987299, + "subdir": "linux-64", + "timestamp": 1664201188124, + "version": "22.9.0" + }, + "conda-22.9.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1", + "toolz >=0.8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5bf8b7652b735075cc28e52a22fbf72a", + "name": "conda", + "sha256": "5dfe68a8521efaa03dbbcd40e14dddd57c54311696071c7062767cd8e917fdf4", + "size": 988481, + "subdir": "linux-64", + "timestamp": 1664201100594, + "version": "22.9.0" + }, + "conda-23.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-libmamba-solver >=22.12.0", + "conda-env >=2.6", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1" + ], + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aed2ebd185c8cda4a439007c1b8626f2", + "name": "conda", + "sha256": "b55b7c40efeb376852f12759dc5a02ed33a7290c339a6076a19f9f0e87220d1c", + "size": 992030, + "subdir": "linux-64", + "timestamp": 1674574758862, + "version": "23.1.0" + }, + "conda-23.1.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0", + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.11,<3.12.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e37719697c6a00c3e84af857e3ef0da", + "name": "conda", + "sha256": "b7cc33bd43ef585aa9123ee27b22860c2fc199aced3be6f0095ad3f7b3f12cc4", + "size": 1311870, + "subdir": "linux-64", + "timestamp": 1676839209630, + "version": "23.1.0" + }, + "conda-23.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-libmamba-solver >=22.12.0", + "conda-env >=2.6", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2be8b967bea05dce403c3a60533a9538", + "name": "conda", + "sha256": "bbd7f14aac467419000a6a0e261ce053d4c1584b635701286527388275eb8c32", + "size": 977834, + "subdir": "linux-64", + "timestamp": 1674574666076, + "version": "23.1.0" + }, + "conda-23.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-libmamba-solver >=22.12.0", + "conda-env >=2.6", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ecffda15e638f229db99204c0fcb680b", + "name": "conda", + "sha256": "3178e77211f762d346d2a499636e7c669901e59301a70651e0982520edc31c6b", + "size": 981086, + "subdir": "linux-64", + "timestamp": 1674574711525, + "version": "23.1.0" + }, + "conda-23.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-libmamba-solver >=22.12.0", + "conda-env >=2.6", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2c27a691e73b07609fea09b0cbc6342a", + "name": "conda", + "sha256": "579565dcec8326b79e6fc6997c397f1026466874c8c21b056c14495e2a0e7574", + "size": 982078, + "subdir": "linux-64", + "timestamp": 1674574803362, + "version": "23.1.0" + }, + "conda-23.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-build >=3.18.3" + ], + "depends": [ + "boltons >=23.0.0", + "conda-package-handling >=1.3.0", + "packaging", + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f5e4cb02c8231f48472a092aff29c85f", + "name": "conda", + "sha256": "357b210d0b33e6d403878fe11eef518deb7a2405791535e4246403b84084d38e", + "size": 1022066, + "subdir": "linux-64", + "timestamp": 1680020056801, + "version": "23.3.0" + }, + "conda-23.3.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-build >=3.18.3" + ], + "depends": [ + "boltons >=23.0.0", + "conda-package-handling >=1.3.0", + "packaging", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.11,<3.12.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fcc45d7c817fb817c5f83dfc822fd5be", + "name": "conda", + "sha256": "63ee3d424ce81856e0fa3fef286a4410db350b5a4ec67e90b355fa22f09d07f9", + "size": 1336317, + "subdir": "linux-64", + "timestamp": 1680020006591, + "version": "23.3.0" + }, + "conda-23.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-build >=3.18.3" + ], + "depends": [ + "boltons >=23.0.0", + "conda-package-handling >=1.3.0", + "packaging", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "00dbe18452c639c9181e7fbde344bfd0", + "name": "conda", + "sha256": "6b1075661ab9dbb8e60f7fe5f14b571c1a2627b37d161dfce50a4ef02318f9e3", + "size": 1009765, + "subdir": "linux-64", + "timestamp": 1680019953677, + "version": "23.3.0" + }, + "conda-23.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-build >=3.18.3" + ], + "depends": [ + "boltons >=23.0.0", + "conda-package-handling >=1.3.0", + "packaging", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5440bff06d7336ea5c94e6b7ee976ec6", + "name": "conda", + "sha256": "2adca93af1f70a91c109e65423ddaeea47bf8af1af02fbd235a8a96de181c917", + "size": 1012945, + "subdir": "linux-64", + "timestamp": 1680020107154, + "version": "23.3.0" + }, + "conda-23.3.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0", + "conda-build >=3.18.3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "boltons >=23.0.0", + "conda-package-handling >=1.3.0", + "jsonpatch >=1.32", + "packaging", + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e7556ae7469817718a0d6ee77bf80ca6", + "name": "conda", + "sha256": "c891b4cb04f241ccda740477d9dee285e02d6b9772caf3134670c4e3248b9a08", + "size": 1028028, + "subdir": "linux-64", + "timestamp": 1680188212787, + "version": "23.3.1" + }, + "conda-23.3.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0", + "conda-build >=3.18.3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "boltons >=23.0.0", + "conda-package-handling >=1.3.0", + "jsonpatch >=1.32", + "packaging", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.11,<3.12.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5daf354a4ec40c8223c62eb9205ad32b", + "name": "conda", + "sha256": "dd181a40ac57517c4178b37b834909b15f00883f053c3877fd74e4088ceb2089", + "size": 1346665, + "subdir": "linux-64", + "timestamp": 1680188266874, + "version": "23.3.1" + }, + "conda-23.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0", + "conda-build >=3.18.3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "boltons >=23.0.0", + "conda-package-handling >=1.3.0", + "jsonpatch >=1.32", + "packaging", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "792c3aed692685d3d11e54b11092b17b", + "name": "conda", + "sha256": "f551fc898c7ee8dca8a78c3d1d7bf1b7fa51d56503003c29f30e7f9626fbd0fd", + "size": 1019075, + "subdir": "linux-64", + "timestamp": 1680188158834, + "version": "23.3.1" + }, + "conda-23.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0", + "conda-build >=3.18.3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "boltons >=23.0.0", + "conda-package-handling >=1.3.0", + "jsonpatch >=1.32", + "packaging", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e5a001572d1664387c1df16ac02a7d49", + "name": "conda", + "sha256": "c2c294094faa8992a7db85442513cd2b11ef67d4144efca4569dd0176f4dec93", + "size": 1018333, + "subdir": "linux-64", + "timestamp": 1680188315862, + "version": "23.3.1" + }, + "conda-4.10.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-build >=3", + "conda-content-trust >=0.1.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "85949790d02d557d88bf8556207d16ad", + "name": "conda", + "sha256": "cdfb6104b8d5a3be58c105d3b10bcef819d2a7386b0314df724e428f9ac46c44", + "size": 3204743, + "subdir": "linux-64", + "timestamp": 1617139894333, + "version": "4.10.0" + }, + "conda-4.10.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "a00281a7984f7664dcd4ac67401d6090", + "name": "conda", + "sha256": "2948383b8896c55f4767209b3225829d9af263d7e4329d5ad1ffec160c005743", + "size": 3223729, + "subdir": "linux-64", + "timestamp": 1617142368150, + "version": "4.10.0" + }, + "conda-4.10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-env >=2.6", + "conda-build >=3", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "4dc492daa81232076a10917ac9b1a779", + "name": "conda", + "sha256": "b6dda350e0e46227f67843208b408c70e699c0da29d7b677a9bef31163c4e459", + "size": 3238349, + "subdir": "linux-64", + "timestamp": 1617142371162, + "version": "4.10.0" + }, + "conda-4.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "66f7dca136ede7f0374d5d290eaef182", + "name": "conda", + "sha256": "df1ad31621191e5056931b6f78e62786cabc69729ef948cfcf3de83a299b024e", + "size": 3209669, + "subdir": "linux-64", + "timestamp": 1617142264793, + "version": "4.10.0" + }, + "conda-4.10.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "22fd627fee4427bd3344c89b5d925ac5", + "name": "conda", + "sha256": "df5b0438645a696bbb34387bbd05b387c58edd5b7f77703c759f92cb17a0ff7a", + "size": 3204912, + "subdir": "linux-64", + "timestamp": 1618432968113, + "version": "4.10.1" + }, + "conda-4.10.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-build >=3" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "da384d53d94cd63e5222d2b638f96438", + "name": "conda", + "sha256": "7b0902568e41bad3ae1d7bdb5c2d554c2ba03ac6665f42e837ab576b33a3efeb", + "size": 3217223, + "subdir": "linux-64", + "timestamp": 1618432966117, + "version": "4.10.1" + }, + "conda-4.10.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-env >=2.6", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "b777f90bffa30a79ee42d5bdb7364e0e", + "name": "conda", + "sha256": "cf9b6c07b4dd1023787988d5673fba8d80365c6df7e54894018a3ef646595d5c", + "size": 3220480, + "subdir": "linux-64", + "timestamp": 1618432967623, + "version": "4.10.1" + }, + "conda-4.10.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-content-trust >=0.1.1", + "cytoolz >=0.8.1", + "conda-build >=3", + "conda-env >=2.6" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "955b17109e509a8fba25dba59597b3c7", + "name": "conda", + "sha256": "0e9b85c129b361a03f110da167b8baf5a17ac32a589e38a865a7aff03d87c0ac", + "size": 3218287, + "subdir": "linux-64", + "timestamp": 1618429842712, + "version": "4.10.1" + }, + "conda-4.10.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.10,<3.11.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "bb283fb976db6a62ea23bd37fcfde75a", + "name": "conda", + "sha256": "9eabdd7733ecfed4f5b091e8241ac900bba8276e417baf1fae40cefe27d3cdb2", + "size": 3219262, + "subdir": "linux-64", + "timestamp": 1641552181014, + "version": "4.10.3" + }, + "conda-4.10.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "b280bfcaa1b03c11ec8a88039e93ac74", + "name": "conda", + "sha256": "48498622d2440fca53624ddc00395a4f9b94fdbbd8b4e6231857841686412d3a", + "size": 3212752, + "subdir": "linux-64", + "timestamp": 1625030514499, + "version": "4.10.3" + }, + "conda-4.10.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "cytoolz >=0.8.1", + "conda-build >=3", + "conda-env >=2.6", + "conda-content-trust >=0.1.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "11d5b9d16c220557b9255318afa68869", + "name": "conda", + "sha256": "a251ab80e278d5a26e8a12a810e871e5c3a4d927c59ba155337699ff4f296e94", + "size": 3225889, + "subdir": "linux-64", + "timestamp": 1625024046170, + "version": "4.10.3" + }, + "conda-4.10.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "fe1b598c5533cfed883d7b2b09ecbcc9", + "name": "conda", + "sha256": "e8a3d535754f87a7c0f54aff25b0efbf6f43eceebb86e93ed36c1bd893a5cdff", + "size": 3237688, + "subdir": "linux-64", + "timestamp": 1625030488252, + "version": "4.10.3" + }, + "conda-4.10.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-build >=3" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "3ad457f6e19348dc6b6638767f51a3a3", + "name": "conda", + "sha256": "22be023fd87c1e73d1148766a7639736f00fc3af2f2cd8f9e19bf8c1101d3eda", + "size": 3218959, + "subdir": "linux-64", + "timestamp": 1625030433316, + "version": "4.10.3" + }, + "conda-4.11.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-build >=3" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "md5": "b8e2eb5030a858991679304e5aad53ce", + "name": "conda", + "sha256": "a5a52c7209bbaad2330c4564e52dc0d3c4b5a6431d50eaee1d430cc055d3db9d", + "size": 17746384, + "subdir": "linux-64", + "timestamp": 1638994131574, + "version": "4.11.0" + }, + "conda-4.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-content-trust >=0.1.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "md5": "bbf33116f56922ed91dc377cb56f0d36", + "name": "conda", + "sha256": "1584a0b24cb3143933eac5e54b5e545fc1400f3a3ad89748ddc20e352cb0e414", + "size": 17691426, + "subdir": "linux-64", + "timestamp": 1638994117932, + "version": "4.11.0" + }, + "conda-4.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "cytoolz >=0.8.1", + "conda-build >=3", + "conda-content-trust >=0.1.1", + "conda-env >=2.6" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "md5": "61ad9429d86b16262397e56415119b3d", + "name": "conda", + "sha256": "41dce46dc7fea8706d70b992c3978c4316a6afe247477afe38228440479e6b06", + "size": 17650555, + "subdir": "linux-64", + "timestamp": 1638976012244, + "version": "4.11.0" + }, + "conda-4.12.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.10,<3.11.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "md5": "febd1a3cabe26b5c960b4fcb6b953d9b", + "name": "conda", + "sha256": "d9afabf297c6749c8e4c30df24b218f7cf104c706f17d5259dcd1abe184a1dab", + "size": 17760703, + "subdir": "linux-64", + "timestamp": 1647367215594, + "version": "4.12.0" + }, + "conda-4.12.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "cytoolz >=0.8.1", + "conda-build >=3" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "md5": "5b341935563be9b5d75598a2aac47045", + "name": "conda", + "sha256": "960472618a48f2e29116fe50280177923d13aa7b5212239b2b363f8b4d2b68f4", + "size": 17745450, + "subdir": "linux-64", + "timestamp": 1647349076328, + "version": "4.12.0" + }, + "conda-4.12.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "md5": "581c5cc17b038fcec77522f575e53246", + "name": "conda", + "sha256": "81279af9a164cc0948f9d188856d7394afc4bd68a74459f72076ef5f7de06547", + "size": 17719921, + "subdir": "linux-64", + "timestamp": 1647367203770, + "version": "4.12.0" + }, + "conda-4.12.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "cytoolz >=0.8.1", + "conda-build >=3", + "conda-env >=2.6", + "conda-content-trust >=0.1.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "md5": "645f4e3d7c7b6b5032a6a83f89ed5134", + "name": "conda", + "sha256": "07da6aa173fb3c42f763dd23526fd9d1ddd7ceef65d7b5d58a85ff69d4582a19", + "size": 17733066, + "subdir": "linux-64", + "timestamp": 1647349451314, + "version": "4.12.0" + }, + "conda-4.13.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.10,<3.11.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07474a433e71bdd8f52061006a876f40", + "name": "conda", + "sha256": "c99b4471129f8550c219d3dd33dc2c844545ed1f8b86b6eb03a063ba082d5bac", + "size": 1029252, + "subdir": "linux-64", + "timestamp": 1653598337616, + "version": "4.13.0" + }, + "conda-4.13.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f3105b9258db34214f0399a4df0ead8f", + "name": "conda", + "sha256": "10d240f409b1a18ecd1624ff8181d9ae36c0dc4d3b192efe667f30b471311d2c", + "size": 1013520, + "subdir": "linux-64", + "timestamp": 1653598422506, + "version": "4.13.0" + }, + "conda-4.13.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b405bdaf7f3d1a07b509106e4162461e", + "name": "conda", + "sha256": "11e239433bbb58437c96a11385d26be6ef410e0a8e54251e784af6d24fdeed5a", + "size": 1017101, + "subdir": "linux-64", + "timestamp": 1653598464610, + "version": "4.13.0" + }, + "conda-4.13.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e492eb3da821d103fd9fd454c705a0d", + "name": "conda", + "sha256": "daf9766fb25ad63488b618cd06c44d5c6c9005cf04a2969ccb03c7e1e6faf33f", + "size": 1018683, + "subdir": "linux-64", + "timestamp": 1653598379612, + "version": "4.13.0" + }, + "conda-4.14.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-content-trust >=0.1.1", + "conda-env >=2.6" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "cytoolz >=0.8.1", + "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.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7454e03e655fb84a6a0779cecd20cc7a", + "name": "conda", + "sha256": "04c604abeb9e63fa493269f82454c7902b646eb2e967e231420ab27f7a4e771d", + "size": 1042292, + "subdir": "linux-64", + "timestamp": 1661203888116, + "version": "4.14.0" + }, + "conda-4.14.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-content-trust >=0.1.1", + "conda-env >=2.6" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "cytoolz >=0.8.1", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.1,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9c0a7e8f20201bf215656bf19a6e4f4b", + "name": "conda", + "sha256": "65de24a4e344d2bbefc0f8cfd5898d43585edf9559d22b20828dc62cf287e05f", + "size": 1030661, + "subdir": "linux-64", + "timestamp": 1661203726602, + "version": "4.14.0" + }, + "conda-4.14.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-content-trust >=0.1.1", + "conda-env >=2.6" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "cytoolz >=0.8.1", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cd4e790710bdd3abd1be7132e3668c75", + "name": "conda", + "sha256": "cebfcd00748de0a93cb0a8e685248ef6e2bab5a4799c0c6c875403bbf83f9e67", + "size": 1032963, + "subdir": "linux-64", + "timestamp": 1661203773929, + "version": "4.14.0" + }, + "conda-4.14.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-content-trust >=0.1.1", + "conda-env >=2.6" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "cytoolz >=0.8.1", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f2a2aebb83e0480db699ef3cb43705cf", + "name": "conda", + "sha256": "33e1e39445e7266a540d8fc726523c805181ca7f60d97a6147705efb36e210f0", + "size": 1033393, + "subdir": "linux-64", + "timestamp": 1661203822352, + "version": "4.14.0" + }, + "conda-4.3.27-py27hff99c7a_0.tar.bz2": { + "build": "py27hff99c7a_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "enum34", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "fcf31f31ff9c639b176d0cae4d119071", + "name": "conda", + "sha256": "bc03745efb749aee6494d71e9b957d986cb5464de063eca0ce00b899d65e95e9", + "size": 519692, + "subdir": "linux-64", + "timestamp": 1506080072319, + "version": "4.3.27" + }, + "conda-4.3.27-py35h1706b01_0.tar.bz2": { + "build": "py35h1706b01_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "c6339a57edde101313f44ad80732925a", + "name": "conda", + "sha256": "682851fe95adf417830d135233cd869ae9ae4a500d5309456d29ca9fcf7b3c76", + "size": 527710, + "subdir": "linux-64", + "timestamp": 1506080093174, + "version": "4.3.27" + }, + "conda-4.3.27-py36h2866c0b_0.tar.bz2": { + "build": "py36h2866c0b_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "5a51e317f9507e86511bdb472a2ebfad", + "name": "conda", + "sha256": "c012c226812021ccb546881bea6c770ef32654924e7d5274db753678d8ca2c3a", + "size": 523175, + "subdir": "linux-64", + "timestamp": 1506080114791, + "version": "4.3.27" + }, + "conda-4.3.29-py27h13e2077_0.tar.bz2": { + "build": "py27h13e2077_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "enum34", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "08af2e50780fe834bf07053be6c3ea0d", + "name": "conda", + "sha256": "44d23568a241a906d7b6aa7a303a0cd76174a24be151265a7c587ec36725b86b", + "size": 519579, + "subdir": "linux-64", + "timestamp": 1507581131695, + "version": "4.3.29" + }, + "conda-4.3.29-py34h14158f2_0.tar.bz2": { + "build": "py34h14158f2_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.4,<3.5.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "ad42f979d6f83b892fcac14c6d09e32a", + "name": "conda", + "sha256": "53b9435c72cc6d53932254d421510e6a01195adad69945af76aa15ad26fc400f", + "size": 531649, + "subdir": "linux-64", + "timestamp": 1507581148853, + "version": "4.3.29" + }, + "conda-4.3.29-py35h8b93296_0.tar.bz2": { + "build": "py35h8b93296_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "ecb8c264108b6e29f6e2e9baf4971fa4", + "name": "conda", + "sha256": "dd5bf255573c0fe1ad4dd51e1c7bc6bee8cdb4d6965f726abf2ce5530469b2f5", + "size": 528061, + "subdir": "linux-64", + "timestamp": 1507581159664, + "version": "4.3.29" + }, + "conda-4.3.29-py36ha26b0c0_0.tar.bz2": { + "build": "py36ha26b0c0_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "62d4160fd4eb969b990c42bf50b520bc", + "name": "conda", + "sha256": "c94ea25eb44c830cd8ef6c91eac253d6b76062faee05021321684d4e8566aabb", + "size": 523520, + "subdir": "linux-64", + "timestamp": 1507581177439, + "version": "4.3.29" + }, + "conda-4.3.30-py27h6ae6dc7_0.tar.bz2": { + "build": "py27h6ae6dc7_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "enum34", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "cb78a85049bfa4f0cbae25f61b660485", + "name": "conda", + "sha256": "37614392f15289be3a8cc712f7bf70b19b17be99c0b912237f2ee0a00fb1a56b", + "size": 519462, + "subdir": "linux-64", + "timestamp": 1508271588500, + "version": "4.3.30" + }, + "conda-4.3.30-py34h69bfab2_0.tar.bz2": { + "build": "py34h69bfab2_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.4,<3.5.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "1ecfc669916182c451ab2fbe1a77de02", + "name": "conda", + "sha256": "80fa2538fca1263e4b4d8b7ab11a7e9b17ab5b0e461ae0e7530bf0ff1253a767", + "size": 531126, + "subdir": "linux-64", + "timestamp": 1508271577660, + "version": "4.3.30" + }, + "conda-4.3.30-py35hf9359ed_0.tar.bz2": { + "build": "py35hf9359ed_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "081dcf18d1291f82483b7c108e1361f3", + "name": "conda", + "sha256": "1211bfd8770324efb6228a5bcc7a9d00ae048add6efca8462c0c8376365e72d9", + "size": 528857, + "subdir": "linux-64", + "timestamp": 1508271605880, + "version": "4.3.30" + }, + "conda-4.3.30-py36h5d9f9f4_0.tar.bz2": { + "build": "py36h5d9f9f4_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "4074a41829c87c39bcf39c6233de8b42", + "name": "conda", + "sha256": "5d30b1b1f0522eb7f6973a568dd9fd43e2ae92352dd066706280f27eb8d5f596", + "size": 523765, + "subdir": "linux-64", + "timestamp": 1508271608124, + "version": "4.3.30" + }, + "conda-4.3.31-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "enum34", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "02503cb55df77478dfcc89a5529fd42f", + "name": "conda", + "sha256": "0966078b45e0c185f7f8e48564914d14ef2b83b8f870570f37d57eb7f9d6f880", + "size": 520550, + "subdir": "linux-64", + "timestamp": 1513473428958, + "version": "4.3.31" + }, + "conda-4.3.31-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "c9c28bb801a748be556fe0448df942ac", + "name": "conda", + "sha256": "837ebe606d9fdb5b3589d132d0223f5e99f3c1449c47281b8f65abfed4f67832", + "size": 529307, + "subdir": "linux-64", + "timestamp": 1513473460302, + "version": "4.3.31" + }, + "conda-4.3.31-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "a3015b8c790869d18cee13000d57bc09", + "name": "conda", + "sha256": "f2ae7ac3d4dd75c36e88da1a715e0e831e1c33c01552fda3afe29f77128a0429", + "size": 525020, + "subdir": "linux-64", + "timestamp": 1513473472598, + "version": "4.3.31" + }, + "conda-4.3.32-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "enum34", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "4818d2c917dcffab3835626222e9e999", + "name": "conda", + "sha256": "7e3e8dbbc4990fbf34c700618ada4bbd4e519707bda7d52e356b6678924bd1d1", + "size": 520963, + "subdir": "linux-64", + "timestamp": 1515643374244, + "version": "4.3.32" + }, + "conda-4.3.32-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "fb3254b706621608dfcd05b8f33dfdc8", + "name": "conda", + "sha256": "57727cd941b7df1f9102cf3e221307e6fea48b4927ad8e6438328bd0b53abf15", + "size": 529471, + "subdir": "linux-64", + "timestamp": 1515643395340, + "version": "4.3.32" + }, + "conda-4.3.32-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "cd8c9af8866364bdd1adfc4842e42705", + "name": "conda", + "sha256": "64eaebcd3a987c16c39928c21c8fa8a18a96c9c7538300bdee5a045e201b1932", + "size": 525121, + "subdir": "linux-64", + "timestamp": 1515643363956, + "version": "4.3.32" + }, + "conda-4.3.33-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "enum34", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "636fb045d38be8b06b98928a82a4d4c4", + "name": "conda", + "sha256": "2cdaaf202e0bab4887ba5adba5eb2d85e7733828b56233ef3ee9a1f9e056936d", + "size": 520965, + "subdir": "linux-64", + "timestamp": 1516815972650, + "version": "4.3.33" + }, + "conda-4.3.33-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "be3fe754450cb9fbf6d04708d254a71a", + "name": "conda", + "sha256": "7518d127b3a55f282184a8d1cb4e541fbbbde5ca5b8dc53eb83176b40e8c4946", + "size": 530331, + "subdir": "linux-64", + "timestamp": 1516815991836, + "version": "4.3.33" + }, + "conda-4.3.33-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "42f21756a70937cb04fc57c8ec688b3b", + "name": "conda", + "sha256": "6d1db0e19679cd6515d7f452bd85afc6e055eab1e990fc4b8d4380353df0f1e5", + "size": 526122, + "subdir": "linux-64", + "timestamp": 1516815990887, + "version": "4.3.33" + }, + "conda-4.3.34-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "enum34", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "20dceadc0b65dea50ea8bed2cb0789cf", + "name": "conda", + "sha256": "78bcece4ff79293cb3173d386bd460d5ef80f812d36f1a910b63be2678f15c0a", + "size": 520507, + "subdir": "linux-64", + "timestamp": 1518212800884, + "version": "4.3.34" + }, + "conda-4.3.34-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "a70b569c6625f68f1035e299ecadc40b", + "name": "conda", + "sha256": "e21c592d065f80e3d0593c643f74e8725c139a5768f6a711ec528d38736ec799", + "size": 530122, + "subdir": "linux-64", + "timestamp": 1518212819737, + "version": "4.3.34" + }, + "conda-4.3.34-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "6be2dbab5bf1ca1712c362dc1621ad8b", + "name": "conda", + "sha256": "a0fa428ed73a50a6b0539894910bcde441d1e3f16ce829f1c2b6e37bbdd37be5", + "size": 526133, + "subdir": "linux-64", + "timestamp": 1518212819998, + "version": "4.3.34" + }, + "conda-4.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "694cbfb2ae5cf6600638375166fa595c", + "name": "conda", + "sha256": "710e5a76a04ecf478a5edb73d1b07cb78dbbc41676f2c89f5e7d2f79b3d122f0", + "size": 631183, + "subdir": "linux-64", + "timestamp": 1513805553579, + "version": "4.4.0" + }, + "conda-4.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "23582b2b3e7bd249db59090770e09372", + "name": "conda", + "sha256": "50cba214e60af20ec6ba31ad577353fbf72048ec2087c1a09e0116429686ac61", + "size": 635590, + "subdir": "linux-64", + "timestamp": 1513805545251, + "version": "4.4.0" + }, + "conda-4.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "008848f7db94651ce43b94ac824b1840", + "name": "conda", + "sha256": "b9adad7298d0da12c8ec30073f72403ec2b6290a1d4da9b843d695364f9c16bf", + "size": 626614, + "subdir": "linux-64", + "timestamp": 1513805547373, + "version": "4.4.0" + }, + "conda-4.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "6040d44bf6b67ff1104b2997d20fee9c", + "name": "conda", + "sha256": "33edaf5ce86b7c5ac074f99ae52d2f29ad04288e8e145d000973c92660c5f5d2", + "size": 630695, + "subdir": "linux-64", + "timestamp": 1513894888818, + "version": "4.4.1" + }, + "conda-4.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "6e18e838d193a818258d812a12996490", + "name": "conda", + "sha256": "4ddf9151e5043db7a1d28d18af52e01b6c2a57261d91beb85766cdb6519827c2", + "size": 635521, + "subdir": "linux-64", + "timestamp": 1513894906248, + "version": "4.4.1" + }, + "conda-4.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "ac110c621bbbad48936aa36b6fb22272", + "name": "conda", + "sha256": "e9463c9910be6c48c724859e2c678e8130bbbf76fd389571c3e78c1f5eff1993", + "size": 626597, + "subdir": "linux-64", + "timestamp": 1513894873142, + "version": "4.4.1" + }, + "conda-4.4.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "277da46bb87261c3f10895e33a85da91", + "name": "conda", + "sha256": "4bf5ed1311cf67e81655bdd6f96a4cad216be1b1f4b69f2c5fc82c955710ff73", + "size": 953432, + "subdir": "linux-64", + "timestamp": 1518214159606, + "version": "4.4.10" + }, + "conda-4.4.10-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "8f2bddfb21d25b8e76142169d18c4cfd", + "name": "conda", + "sha256": "a7f75deb940acad914e66e82dd57c2d5901cbaf1c1245f0b0e084043bfbc8cdd", + "size": 959995, + "subdir": "linux-64", + "timestamp": 1518214199239, + "version": "4.4.10" + }, + "conda-4.4.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "990922e87f623a9926e6c1bb787b2a24", + "name": "conda", + "sha256": "18d96aee1349150fa2c8a6bd20aa195fec758b7183079e219783ff7092ca5bf9", + "size": 951795, + "subdir": "linux-64", + "timestamp": 1518214199031, + "version": "4.4.10" + }, + "conda-4.4.11-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "580100dd3ee888a2b0ecd851198d2f6b", + "name": "conda", + "sha256": "be9e8c412f718732a5775fe79a63c718f1c4ebfbaa6f27678dfa1cd1df35006a", + "size": 953911, + "subdir": "linux-64", + "timestamp": 1519392559843, + "version": "4.4.11" + }, + "conda-4.4.11-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "8354195296c571a87a44778a5a705140", + "name": "conda", + "sha256": "3766ae98aaf2ba0c443802dcfd1cbc58ef3f86d58c35320d8f20f33dc3390336", + "size": 960343, + "subdir": "linux-64", + "timestamp": 1519392648815, + "version": "4.4.11" + }, + "conda-4.4.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "9f2943a3f290f5cda2d32d66da800ae8", + "name": "conda", + "sha256": "403285a39119bb44f26558f794f0b74e2530de7233fab3c88ced9bbffa97123b", + "size": 952608, + "subdir": "linux-64", + "timestamp": 1519392566975, + "version": "4.4.11" + }, + "conda-4.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "6b6369701c5dbcaaae4c2910c4cc6352", + "name": "conda", + "sha256": "1541b89b0b6f21ead8904fa52ebfaf96e6c7dbfbf240b5f4c4307db8fa174897", + "size": 632413, + "subdir": "linux-64", + "timestamp": 1513927293965, + "version": "4.4.2" + }, + "conda-4.4.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "f611ef54416739bb5e5a8350232bac2f", + "name": "conda", + "sha256": "662fc9ada13ff3ad71e57e78eb35a1b6139efa7c0ed431434bc620ea3bf40370", + "size": 635786, + "subdir": "linux-64", + "timestamp": 1513927323404, + "version": "4.4.2" + }, + "conda-4.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "91052633108a7cb3ad744f3b23ed54f3", + "name": "conda", + "sha256": "0b55c225e0d06ae94bc1aa4c48b319717d61e333b60ac0528a28252e9c8a1542", + "size": 627050, + "subdir": "linux-64", + "timestamp": 1513927322049, + "version": "4.4.2" + }, + "conda-4.4.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "7bd1214c149a7f92bf38634a55761b55", + "name": "conda", + "sha256": "aa5c21d35bb02e8b5b0c6fa6e9a13b9ee22a22fe2c46cd33dd8935cfa0366706", + "size": 633795, + "subdir": "linux-64", + "timestamp": 1513981237801, + "version": "4.4.3" + }, + "conda-4.4.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "cc29b6debdcd68ea59a6d30f6e7041e3", + "name": "conda", + "sha256": "1f61b73d4433312f51a7712c88116eb3095d4dc3159f0df425c3df9b9544056c", + "size": 636186, + "subdir": "linux-64", + "timestamp": 1513981260124, + "version": "4.4.3" + }, + "conda-4.4.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "596cfacbdaf188a4cd38052aee5be172", + "name": "conda", + "sha256": "4f9680a0ca14f063ed4bf70f1f924666f37d0d132397868a9259336f27d0e95a", + "size": 628135, + "subdir": "linux-64", + "timestamp": 1513981267816, + "version": "4.4.3" + }, + "conda-4.4.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "93c2dbe9fc219a39d586ada38df2fb01", + "name": "conda", + "sha256": "ba15d35e6c297531460a60c29a737f447975dc575717c5a14cc442374d762ec1", + "size": 635846, + "subdir": "linux-64", + "timestamp": 1514155527337, + "version": "4.4.4" + }, + "conda-4.4.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "56d00b802884eab2a8a998ef449f19df", + "name": "conda", + "sha256": "b83d22b9bd41cf51e17a38b642659c394f6c00b421847225d50927101049d48e", + "size": 638413, + "subdir": "linux-64", + "timestamp": 1514155548163, + "version": "4.4.4" + }, + "conda-4.4.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "f511d22ca28b8203198c30f02cfd6af7", + "name": "conda", + "sha256": "24c22effbc9ae55acb1cf993ee0077e5b2b004e5c0248108a237b256735c1740", + "size": 629062, + "subdir": "linux-64", + "timestamp": 1514155543474, + "version": "4.4.4" + }, + "conda-4.4.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "07be5860c7d5fc2d3b4caff1127e8676", + "name": "conda", + "sha256": "9e1ec651974d85a1b9083e2b3514cd2a21c8abb236db64981347ee274e307e74", + "size": 947421, + "subdir": "linux-64", + "timestamp": 1514749553694, + "version": "4.4.6" + }, + "conda-4.4.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "96b9dee940fd6b725e5e717fb6a6b1a2", + "name": "conda", + "sha256": "ea8adfc0db80d3800c762e8b4506342b5b25f3d388472aa4971e5b041f16f70d", + "size": 955401, + "subdir": "linux-64", + "timestamp": 1514749567875, + "version": "4.4.6" + }, + "conda-4.4.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "dca27f92a4a4e4d509b9378d28b668cc", + "name": "conda", + "sha256": "58df6499512c30023e8bd34cecadf461124e5204cea62fa9f2901be913cd0946", + "size": 948235, + "subdir": "linux-64", + "timestamp": 1514749576329, + "version": "4.4.6" + }, + "conda-4.4.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "f7b634c0a3fe4b25e7abf964b443768f", + "name": "conda", + "sha256": "6ef84e9b272f32b96eb97f4097bea8551134b2d2935b91e7f9c269ba29769f7a", + "size": 948125, + "subdir": "linux-64", + "timestamp": 1515435700131, + "version": "4.4.7" + }, + "conda-4.4.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "4e9a5b9ea3f1e3ff69341a94ed4d9e91", + "name": "conda", + "sha256": "d1d265d571ab31e6aed0c149e109e5949e61c11534b7732c55a53c933eb724ab", + "size": 956270, + "subdir": "linux-64", + "timestamp": 1515435726029, + "version": "4.4.7" + }, + "conda-4.4.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "2067894a34823af01bf48b0a9618280f", + "name": "conda", + "sha256": "725d7053af58965e9af02a3bf2c8e196442fbf53cd10dd2ea8ff1fe59b839fe3", + "size": 949621, + "subdir": "linux-64", + "timestamp": 1515435737571, + "version": "4.4.7" + }, + "conda-4.4.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "bdf7e97cee56ce6fc0016c5715fe9483", + "name": "conda", + "sha256": "67a9204653502ce945268913f4d21d54f76970f854536b4f2e60f67424c5e36a", + "size": 951517, + "subdir": "linux-64", + "timestamp": 1516977114204, + "version": "4.4.8" + }, + "conda-4.4.8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "3dd68b8337655d6dbf0a2649d59f5de4", + "name": "conda", + "sha256": "7d15089e6d83d08265ea4eaf08ef8c8a70e09d7bcddb3303ff6cbdbfa2c296d8", + "size": 959468, + "subdir": "linux-64", + "timestamp": 1516977128282, + "version": "4.4.8" + }, + "conda-4.4.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "c491d1f2cd6db8d86bc3088889a2f5ab", + "name": "conda", + "sha256": "0552ae00435361a1e389fba2aa7f0cca7a194a9e09fa47ec7f0f1e1606b7e76b", + "size": 954633, + "subdir": "linux-64", + "timestamp": 1516977128407, + "version": "4.4.8" + }, + "conda-4.4.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "de0723f8295ab37e1e33e4d99360ce8b", + "name": "conda", + "sha256": "690504ca5c1d430f0ba004609ed99edabaddd3c9843d83d03bdde3daf6424d29", + "size": 953263, + "subdir": "linux-64", + "timestamp": 1517949728142, + "version": "4.4.9" + }, + "conda-4.4.9-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "76a3441a68f9d4c3ea01651803372deb", + "name": "conda", + "sha256": "494c0f1a8c7e27d921688d2f04e5335e8ac4e8e380b38b211651e7eca6df6a6a", + "size": 959367, + "subdir": "linux-64", + "timestamp": 1517949752376, + "version": "4.4.9" + }, + "conda-4.4.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "272ebb52460e6bad6732f9bc2eeb9448", + "name": "conda", + "sha256": "0f8a3e41562c8da53b2de3cd5a8c47eb28b66c709e8bce2b85945322563c167e", + "size": 951672, + "subdir": "linux-64", + "timestamp": 1517949761552, + "version": "4.4.9" + }, + "conda-4.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "5787e8c3704756d8764ca4fcd92c71d8", + "name": "conda", + "sha256": "4adb5e73ca9515b721de2ee129a1acace0596478c4ad0c7bb54f78302d32dce3", + "size": 1066650, + "subdir": "linux-64", + "timestamp": 1521550345778, + "version": "4.5.0" + }, + "conda-4.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "89916696db2931478b2367fea6232084", + "name": "conda", + "sha256": "9fa9993bc6707c0fd8a741c60ed9a1797cdaa21491414d13ffea78e9fba261e2", + "size": 1067053, + "subdir": "linux-64", + "timestamp": 1521550360889, + "version": "4.5.0" + }, + "conda-4.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "433496305ba6a2e647ba9d54ec132b5a", + "name": "conda", + "sha256": "856a17b4be77e4398e22c804d8ca4ba1ba4e5ed77124c8ae39fdf230dfd630b3", + "size": 1063943, + "subdir": "linux-64", + "timestamp": 1521550366989, + "version": "4.5.0" + }, + "conda-4.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "e4842d4cb94e6cf5adb1780d0aaa6039", + "name": "conda", + "sha256": "655dc18e3e9acd2fbb9210a8f76208796faa89057bfe08ca952c1bada36cfad8", + "size": 1058126, + "subdir": "linux-64", + "timestamp": 1523601378712, + "version": "4.5.1" + }, + "conda-4.5.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "7db1f0dcdbd349e15ba832d9480e3612", + "name": "conda", + "sha256": "f6a5b80f133c2526ad0a417425700e58df78f6c02010e5d0364f0446fff9b154", + "size": 1061571, + "subdir": "linux-64", + "timestamp": 1523601393192, + "version": "4.5.1" + }, + "conda-4.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "7afb0c261a589deb8587b0f7fbfefa4e", + "name": "conda", + "sha256": "2d3c193517e505a202efcc8ca723f11ba7a505207116225cea7725c6c193cd31", + "size": 1057849, + "subdir": "linux-64", + "timestamp": 1523601429609, + "version": "4.5.1" + }, + "conda-4.5.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "33991af6a7400497262482e5d6361550", + "name": "conda", + "sha256": "b4ade3402ec43b877c8df3d958d4369fd45301cbe2aeac57a065913b68c1504f", + "size": 1062936, + "subdir": "linux-64", + "timestamp": 1534186238582, + "version": "4.5.10" + }, + "conda-4.5.10-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "51dd8499c77f57017f3999f6650fda45", + "name": "conda", + "sha256": "7efec086edfe382dec9b8be39df4fe95b71a10be9f28f4a9d733979dbd9fa5fe", + "size": 1067044, + "subdir": "linux-64", + "timestamp": 1534186251677, + "version": "4.5.10" + }, + "conda-4.5.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "489b35fbbfdffeac1670f0fa18a84f23", + "name": "conda", + "sha256": "6e834b4c854aa009945d07a55c01d58e25bc02005e75ce470bdb4099ba9ad8c9", + "size": 1062598, + "subdir": "linux-64", + "timestamp": 1534184231222, + "version": "4.5.10" + }, + "conda-4.5.10-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "982af2920643bc4645574a7736cae875", + "name": "conda", + "sha256": "e4d1ef7b4a7e1e2d545bca904654527df1f96fdcefac108804a503c323c0f7c0", + "size": 1062908, + "subdir": "linux-64", + "timestamp": 1534184299444, + "version": "4.5.10" + }, + "conda-4.5.11-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "89afaceda156f279b3b2d390e1253a16", + "name": "conda", + "sha256": "e08af4adfad524321bad8e8aa585223ec95f744ba9184096641d9f5630e42948", + "size": 1061820, + "subdir": "linux-64", + "timestamp": 1534866800219, + "version": "4.5.11" + }, + "conda-4.5.11-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "e6c2e03db8d1d7df2a6996a2ac416c03", + "name": "conda", + "sha256": "5eb39df2d7f88aa62ce7ef9baa21f05514982910386ebe7987e9db12b2487e81", + "size": 1066496, + "subdir": "linux-64", + "timestamp": 1534866561441, + "version": "4.5.11" + }, + "conda-4.5.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "c85f280459d7aab6e9e4c69bd5934e03", + "name": "conda", + "sha256": "fc5b03d70614538ece1b794f2f89ff40104b451d98ae4b32cb49b8c39777fd6f", + "size": 1062793, + "subdir": "linux-64", + "timestamp": 1534866762236, + "version": "4.5.11" + }, + "conda-4.5.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "c64048a1ad66ec9d05f47bde8d9d07fb", + "name": "conda", + "sha256": "54edaeaf5c62bca5ff92401547a10935283911a005e144522a1d4993c2d1d626", + "size": 1063004, + "subdir": "linux-64", + "timestamp": 1534866843846, + "version": "4.5.11" + }, + "conda-4.5.12-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "701ea322253e790770d1bd31afe13923", + "name": "conda", + "sha256": "8d36ff59302e322078ba6641c2309c92c21d1e8196bd2e646467451f6fd06340", + "size": 1077505, + "subdir": "linux-64", + "timestamp": 1544488020290, + "version": "4.5.12" + }, + "conda-4.5.12-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "b5b545ee444ae4fa594ede90f955bc69", + "name": "conda", + "sha256": "300b2eb178459e3193d2c590a503baf6a3f0fb0d3b18db851e0dc341648e1820", + "size": 1080335, + "subdir": "linux-64", + "timestamp": 1544488049463, + "version": "4.5.12" + }, + "conda-4.5.12-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "efe5121c9ed0365cfab0fc86e9f26b3d", + "name": "conda", + "sha256": "94bfbf122519176a93424553dbaf7e0975ba46aca6b0352f4d103e31a2df4dd2", + "size": 1079096, + "subdir": "linux-64", + "timestamp": 1544488015340, + "version": "4.5.12" + }, + "conda-4.5.13-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "ea7c96502afb38591401e767771e5980", + "name": "conda", + "sha256": "e71464a6fbcde3a655dafa84ae23389c4b3709870b8a2969362bb173fdda9492", + "size": 1083252, + "subdir": "linux-64", + "timestamp": 1548809668528, + "version": "4.5.13" + }, + "conda-4.5.13-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "1fb7fb7e1c63395d5214afb41ffcf3b1", + "name": "conda", + "sha256": "e125285936da8ccc6e509163d9251e4d87b8c84998df407323920c0323dc5bd2", + "size": 1081276, + "subdir": "linux-64", + "timestamp": 1548809678647, + "version": "4.5.13" + }, + "conda-4.5.13-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "fe1b675c33cfd67d01ace90f57abce0b", + "name": "conda", + "sha256": "46bb0751b0d72c6408aae4dc9a468c2de35ceb5aff524b899584d13ec27bcfa2", + "size": 1082195, + "subdir": "linux-64", + "timestamp": 1548809744380, + "version": "4.5.13" + }, + "conda-4.5.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env", + "enum34", + "futures", + "pycosat", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml" + ], + "license": "BSD 3-Clause", + "md5": "fda80b350ffb5b0730633163e53c136c", + "name": "conda", + "sha256": "44661bfb2e2f140390798afdd31fecfe3a2f5f4f3b2023ec18076a08e939917a", + "size": 1056205, + "subdir": "linux-64", + "timestamp": 1524848322387, + "version": "4.5.2" + }, + "conda-4.5.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env", + "pycosat", + "pyopenssl", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml" + ], + "license": "BSD 3-Clause", + "md5": "09204ad93749d6ade0a76a0daa607e6d", + "name": "conda", + "sha256": "4ef59f5b2b68c42e3902fc57ed1c1307dac456cee53b0c6bb67aaa43781caee7", + "size": 1060844, + "subdir": "linux-64", + "timestamp": 1524848342576, + "version": "4.5.2" + }, + "conda-4.5.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env", + "pycosat", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml" + ], + "license": "BSD 3-Clause", + "md5": "3e8d15173b84830f917ba3adba520095", + "name": "conda", + "sha256": "a64b276d919a15e2f7dcf8178e57aabe86a2da278fc68afd6ba4a5e2fcb5a293", + "size": 1056946, + "subdir": "linux-64", + "timestamp": 1524848341661, + "version": "4.5.2" + }, + "conda-4.5.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "30938b56a0c91a9ad21e669f2c4a0e38", + "name": "conda", + "sha256": "7d24ae9ef952ee22be1895c9ffedef305966389f296da8a7f90450841359dda3", + "size": 1056782, + "subdir": "linux-64", + "timestamp": 1525719552511, + "version": "4.5.3" + }, + "conda-4.5.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "af5cc571024fca43863b91104e150760", + "name": "conda", + "sha256": "566b55b8f205d5fed31fd7c6538abb7325223a35ff15bc953ddc8bd328c219ea", + "size": 1061503, + "subdir": "linux-64", + "timestamp": 1525719658067, + "version": "4.5.3" + }, + "conda-4.5.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "55949658120ec2331e7999297c07a7e9", + "name": "conda", + "sha256": "7214026e77facf1c629b742d57c4b66f8ca8314b4056629884353a953d0c7a02", + "size": 1057211, + "subdir": "linux-64", + "timestamp": 1525719581394, + "version": "4.5.3" + }, + "conda-4.5.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "d263ba6a4bcb0d8dd0cbe2b44a3aa7b6", + "name": "conda", + "sha256": "847442d1dc796b1fb32475cb397654728a8fe8a07b1d1fe41bd829a05f26752d", + "size": 1057702, + "subdir": "linux-64", + "timestamp": 1526301722414, + "version": "4.5.4" + }, + "conda-4.5.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "00f681f02dcefa1a4f369ad1454e6cd8", + "name": "conda", + "sha256": "b6320e4ced2be223843eddc3ee913aed2fb0da38e94778fea8d290b4a7533469", + "size": 1061417, + "subdir": "linux-64", + "timestamp": 1526301728570, + "version": "4.5.4" + }, + "conda-4.5.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "1fdcb2ccd858682843b42b4ef35eca6b", + "name": "conda", + "sha256": "95418d771a0a9821c6ef0b0f887ba6ef02e1ab9369e0148d87c83a4f70b3f428", + "size": 1058597, + "subdir": "linux-64", + "timestamp": 1526301698736, + "version": "4.5.4" + }, + "conda-4.5.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "24bacbc3a4ae20438bff425cdae6fa18", + "name": "conda", + "sha256": "99138258472546e43f0ba77221c7b664bedff88ca17a20f61fc5cd7369581b16", + "size": 1059453, + "subdir": "linux-64", + "timestamp": 1530287624556, + "version": "4.5.5" + }, + "conda-4.5.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "5adac723bac58eef0a56422179c5a688", + "name": "conda", + "sha256": "6a1039a4cfb3d144b676099e1301db63cdb91ab3d7df377128bbb4dad4ef3202", + "size": 1063593, + "subdir": "linux-64", + "timestamp": 1530287707793, + "version": "4.5.5" + }, + "conda-4.5.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "f0847c665e0bf028253f80876fb8b042", + "name": "conda", + "sha256": "cf7ab8add7abfa1567b50baa977d0c70f593a37237293cdc9e92422240fb18a8", + "size": 1060776, + "subdir": "linux-64", + "timestamp": 1530287666218, + "version": "4.5.5" + }, + "conda-4.5.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "8867ca740e786815b0d20e00baceece7", + "name": "conda", + "sha256": "ea9253970d36029649f8138f3b36c4bae823cae0146bb7b1af4afc3042c8639b", + "size": 1061589, + "subdir": "linux-64", + "timestamp": 1531233259376, + "version": "4.5.8" + }, + "conda-4.5.8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "7bae6f2536725fe101eb54e8e8d24663", + "name": "conda", + "sha256": "a9a99a57bce1f9aa904bd00e907daafa5544e20217b146d6f3dd168606ba340e", + "size": 1064949, + "subdir": "linux-64", + "timestamp": 1531233339709, + "version": "4.5.8" + }, + "conda-4.5.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "41ca55bec7ec80b80f1aa38c3274a9c7", + "name": "conda", + "sha256": "e9421c001253e577b7c8bf238e316814d224577daff93128b06990a528d0a1b3", + "size": 1062231, + "subdir": "linux-64", + "timestamp": 1531233340587, + "version": "4.5.8" + }, + "conda-4.5.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "f3c26b8fddab2925b598148feed9bf45", + "name": "conda", + "sha256": "30cebf10e8a33ebbd51974c0a071daf9d371cf43fd2d366383533554750b14c2", + "size": 1044670, + "subdir": "linux-64", + "timestamp": 1531255947204, + "version": "4.5.8" + }, + "conda-4.5.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "b3cf973ce655aa71ed215c8ebaea4ae3", + "name": "conda", + "sha256": "3514ae2388b370af1530b72304f63324c899c1cf65cf854a75674c07d38ffb50", + "size": 1061778, + "subdir": "linux-64", + "timestamp": 1532976248465, + "version": "4.5.9" + }, + "conda-4.5.9-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "58d35bd643f0bc06059a0277b29a804a", + "name": "conda", + "sha256": "286064668474663819086267006ebca1176867945be66dad3fc9f30d1bf3415b", + "size": 1066282, + "subdir": "linux-64", + "timestamp": 1532976207113, + "version": "4.5.9" + }, + "conda-4.5.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "faf6b46c79b616e93b1d74666d94c8fe", + "name": "conda", + "sha256": "349535d26db7d503bfc89d233f218635654eece4c1940245899daa52fcab98bd", + "size": 1062451, + "subdir": "linux-64", + "timestamp": 1532976244994, + "version": "4.5.9" + }, + "conda-4.5.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "334cb81008a68b4da395e3d62728303b", + "name": "conda", + "sha256": "32f68b8407d6e390efec5c9c79141c3d9ad09dc88bf467d697073d2d8b6cdea3", + "size": 1062907, + "subdir": "linux-64", + "timestamp": 1532976265906, + "version": "4.5.9" + }, + "conda-4.6.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "5afdc815a5ba4cdbd1a6402420c1b9eb", + "name": "conda", + "sha256": "9238c7524e3c7a4b665fec92db3154a236473cfaba42bc3daaab5b77005ac6bf", + "size": 1732254, + "subdir": "linux-64", + "timestamp": 1548128995986, + "version": "4.6.1" + }, + "conda-4.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "8fc7cb3c57aa292355ffd60e3936a49d", + "name": "conda", + "sha256": "11aac81114e5a75afcc2b4286dfb1dd64eb4edbb7160f2ec72e6015a1abe6956", + "size": 1736061, + "subdir": "linux-64", + "timestamp": 1548129036378, + "version": "4.6.1" + }, + "conda-4.6.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "b2dd7ab16f5d4792da378e8fca0f753a", + "name": "conda", + "sha256": "e480acd0719b0e3d44da816cc30879356577d04a28baaf33464dfc71d84c1e72", + "size": 1732836, + "subdir": "linux-64", + "timestamp": 1548129029327, + "version": "4.6.1" + }, + "conda-4.6.11-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "8f0b91be62a954010bd62ee4b324342d", + "name": "conda", + "sha256": "4e9b7ee6791221bef2e3539a99e54156139bb507a14211b9063fa310852dd333", + "size": 1770900, + "subdir": "linux-64", + "timestamp": 1554393717675, + "version": "4.6.11" + }, + "conda-4.6.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "22ea55ad77a9fba6be28c34a1f33e8c6", + "name": "conda", + "sha256": "73d0fcb8de358beb7bc083db70864e2cea8498850e4f1c59964b9d38811e270e", + "size": 1777376, + "subdir": "linux-64", + "timestamp": 1554393742094, + "version": "4.6.11" + }, + "conda-4.6.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "8ddc679b8eeee93daae9ae152a9cf06f", + "name": "conda", + "sha256": "691996fd2415bafdae578f486c699fe9c938976da467e1ef4702a1364ebb1803", + "size": 1772681, + "subdir": "linux-64", + "timestamp": 1554393737758, + "version": "4.6.11" + }, + "conda-4.6.12-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "e0284497b33afd3572f5e40483d7e921", + "name": "conda", + "sha256": "1b2ee37798cc98b923f7646aaa0ecf7a3488a7f9dce5175e666801b6725fd8f9", + "size": 2188154, + "subdir": "linux-64", + "timestamp": 1555005101890, + "version": "4.6.12" + }, + "conda-4.6.12-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "953ce8995f3e7587f6fa867720ba1197", + "name": "conda", + "sha256": "454bbb44f3a7d3abd4a03ebc98d3e73e1849091be1ff68181ed8d1aa2de9a753", + "size": 2192536, + "subdir": "linux-64", + "timestamp": 1555005111370, + "version": "4.6.12" + }, + "conda-4.6.12-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "2733be52ac1c53727bb36ca9bf294772", + "name": "conda", + "sha256": "66d9ade1fd89fceebd9a334068184d22a2ec552d5b3ffd978d99f52b0f9b5590", + "size": 2202701, + "subdir": "linux-64", + "timestamp": 1555005086845, + "version": "4.6.12" + }, + "conda-4.6.14-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "cbc299a0edb8a08b69f62ac90171c13e", + "name": "conda", + "sha256": "9d2ffd28c39b9208de75025e6f2d4f32c877d9d8b6ee16559d449055ac0e1865", + "size": 2187743, + "subdir": "linux-64", + "timestamp": 1555533509159, + "version": "4.6.14" + }, + "conda-4.6.14-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "a776c0e53153db537c621778cc83540e", + "name": "conda", + "sha256": "0215c4f44f593522fc43f15d718735e11153b3286799495d76a735d2fc8bd7a3", + "size": 2192859, + "subdir": "linux-64", + "timestamp": 1555533655890, + "version": "4.6.14" + }, + "conda-4.6.14-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "64eb3b71d555b4518325f24598158fb8", + "name": "conda", + "sha256": "232450ba67740fbc928e2b145b73f7129965ce68a2e27379a12ca2cbcf75b79e", + "size": 2223010, + "subdir": "linux-64", + "timestamp": 1555533610175, + "version": "4.6.14" + }, + "conda-4.6.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "bf90242c62cb26644a52b26ef72fda7c", + "name": "conda", + "sha256": "2989e2ced38e016812c7c31c82ac7775070902a771ec4cd73faa5401b747eea5", + "size": 1726117, + "subdir": "linux-64", + "timestamp": 1548813703174, + "version": "4.6.2" + }, + "conda-4.6.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "6692770690f1a291c6e192be035b8d4b", + "name": "conda", + "sha256": "6d148f28e38a720bd91b6f365cb303adac063f824c04763e075d71871d61f3ca", + "size": 1730055, + "subdir": "linux-64", + "timestamp": 1548813722240, + "version": "4.6.2" + }, + "conda-4.6.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "b5d069185d50bb278c6a8de5f6fb395f", + "name": "conda", + "sha256": "50715761be7ba2e3d92ecb05db14c2cfd66f38351e78028d370d22b6e15a114f", + "size": 1730384, + "subdir": "linux-64", + "timestamp": 1548813723745, + "version": "4.6.2" + }, + "conda-4.6.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "02c489cc5a1c6b6efde224f10bdcae7f", + "name": "conda", + "sha256": "705b63d55fd876db1636a742144318a54f851edd8e227abff667ba02a6a636ed", + "size": 1721043, + "subdir": "linux-64", + "timestamp": 1549604018496, + "version": "4.6.3" + }, + "conda-4.6.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "7708254cee3efb8e1f4793ac5c56520d", + "name": "conda", + "sha256": "e4b9f48ec8108a35381451475bce62a1c5f3f275f3834992ce43474375adf1b5", + "size": 1733715, + "subdir": "linux-64", + "timestamp": 1549604060738, + "version": "4.6.3" + }, + "conda-4.6.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "41a0b6b20ecd81cd913f804f194c053d", + "name": "conda", + "sha256": "5e7b510738d4b2f86433e7bd92f506f741d41a4f250e1b01fed462051a8828b9", + "size": 1735189, + "subdir": "linux-64", + "timestamp": 1549603971568, + "version": "4.6.3" + }, + "conda-4.6.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "208d99f86107caf25849abde39d40b7c", + "name": "conda", + "sha256": "6c5a9bd50c4c6de63b2852ef89833efc66eabd9af34851639f9d9c11b727328d", + "size": 1730009, + "subdir": "linux-64", + "timestamp": 1550087104197, + "version": "4.6.4" + }, + "conda-4.6.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "bd43727063b11ae43b6bbbeaa81b0a9a", + "name": "conda", + "sha256": "44c83cb86d4ef24ff7522ab1cce56500472494b9790ee78a83341f2e6aa65aa9", + "size": 1730769, + "subdir": "linux-64", + "timestamp": 1550087107769, + "version": "4.6.4" + }, + "conda-4.6.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "0f197565cf0e0b78ab9f710747c10366", + "name": "conda", + "sha256": "a237cea7ff27ed3730997cc0584ac4393f59373deb0246557549a10b4d8082c1", + "size": 1732271, + "subdir": "linux-64", + "timestamp": 1550087037738, + "version": "4.6.4" + }, + "conda-4.6.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "5c4635865c8737fadf1aba7235902793", + "name": "conda", + "sha256": "762b129a93ca5086105ed7fafa67a7b9a7bbf6cfd38bed49f073beea4498aaae", + "size": 1737879, + "subdir": "linux-64", + "timestamp": 1550800422647, + "version": "4.6.7" + }, + "conda-4.6.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "ab6b938ee12c6e39600c0dd578362e18", + "name": "conda", + "sha256": "a8e932db40c95a18653da7ea16b7ab30f39cece47399fb9231b205c37504e561", + "size": 1737711, + "subdir": "linux-64", + "timestamp": 1550800421013, + "version": "4.6.7" + }, + "conda-4.6.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "a06af1137ae00b138ef5ce2350270592", + "name": "conda", + "sha256": "4cbbbde0c396b266e964acf1a6ffb240b9f23c33449a005a110b29382f9edd2f", + "size": 1733381, + "subdir": "linux-64", + "timestamp": 1550800382306, + "version": "4.6.7" + }, + "conda-4.6.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "411dfe458cf44a90fcec7456d5bdd5ec", + "name": "conda", + "sha256": "3cec4dccfaed68b5e37f29c62b71bec2660e9625d97148c0aa45097f251baf71", + "size": 1723438, + "subdir": "linux-64", + "timestamp": 1551930516190, + "version": "4.6.8" + }, + "conda-4.6.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "08dbc52c1ca0e1dd92a7869fb73993f3", + "name": "conda", + "sha256": "535ebd8d1c368d0ef382ed06f13a4a7b68fe7b1140c6f263484b8cfefd45e1c8", + "size": 1731328, + "subdir": "linux-64", + "timestamp": 1551930498590, + "version": "4.6.8" + }, + "conda-4.6.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "99fdb773bea73b9af8de3ab3e7a3b52d", + "name": "conda", + "sha256": "1beaddf79a0230636ce397270cd62e3ed92620435ce7fd8807c6b61310725aa8", + "size": 1736732, + "subdir": "linux-64", + "timestamp": 1551930515604, + "version": "4.6.8" + }, + "conda-4.6.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "bee8f6c5f1e041c036c7d78d05024aaa", + "name": "conda", + "sha256": "2a002583f9e1200ddb64c1a4e2d1a6823a309a1a2c69cf54146f3a722c2b4686", + "size": 1770937, + "subdir": "linux-64", + "timestamp": 1553910093735, + "version": "4.6.9" + }, + "conda-4.6.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "2cee940ec3da82d998c9905478156278", + "name": "conda", + "sha256": "319d3a02e660d06701d52d76313011dee07348f465b14e5b470d5e720ab07c69", + "size": 1776580, + "subdir": "linux-64", + "timestamp": 1553910106036, + "version": "4.6.9" + }, + "conda-4.6.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "a939d9725801afd57f797d8504baa2fd", + "name": "conda", + "sha256": "9fb3b85652ba2d760354e594da8ddef37fce2eef4263b5fd81e49db944535e2c", + "size": 1774965, + "subdir": "linux-64", + "timestamp": 1553910107710, + "version": "4.6.9" + }, + "conda-4.7.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "2ee1aee911d816b9886f634b290d1922", + "name": "conda", + "sha256": "d01a94f5d48761a45e153432c24fdf0da6f2d5c17862a35f2cbbfd0e7cc58551", + "size": 3141430, + "subdir": "linux-64", + "timestamp": 1563566243809, + "version": "4.7.10" + }, + "conda-4.7.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "c95c0d75f8a2a3f27af77aaccc441ca1", + "name": "conda", + "sha256": "19380a5fa3012478c804926d8dc8a5698fc8057b3324645b85bd940966c7cca4", + "size": 3134561, + "subdir": "linux-64", + "timestamp": 1563566230627, + "version": "4.7.10" + }, + "conda-4.7.10-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "72883237e75272727e18aa1e028c3491", + "name": "conda", + "sha256": "7d53b2b060b10c35c23895ec6fb630dc97acd843cb40f18d553024c2fe65efa0", + "size": 3148022, + "subdir": "linux-64", + "timestamp": 1563566210774, + "version": "4.7.10" + }, + "conda-4.7.11-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "e410313bf72ea7453cb13d0077fd7f26", + "name": "conda", + "sha256": "a349cd7d60598e8cb0e0f7b7b023d62fe14da959c06ae8a9497209adf19fe823", + "size": 3150470, + "subdir": "linux-64", + "timestamp": 1565121783266, + "version": "4.7.11" + }, + "conda-4.7.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "791617240ed829008dfd3daf5073b041", + "name": "conda", + "sha256": "f2d0890eeacc1d72bd3d06c25e8e4ebd263bc2703ac8c167be2cafa5b67dee81", + "size": 3152025, + "subdir": "linux-64", + "timestamp": 1565121923236, + "version": "4.7.11" + }, + "conda-4.7.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "8351e77997facfdb87309d70f789ab04", + "name": "conda", + "sha256": "a612ac5bcb5ae1bd8188d056c72db853b451424099f3938db3e37446062b8547", + "size": 3139069, + "subdir": "linux-64", + "timestamp": 1565121200033, + "version": "4.7.11" + }, + "conda-4.7.12-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "64dfeab4a3f4bbb5623be105094d3ae2", + "name": "conda", + "sha256": "5e38f3adcdac3c499a5b49c465c661dbc35957a2a637a1b21856b6cc8dfa3fe6", + "size": 3166699, + "subdir": "linux-64", + "timestamp": 1568310299047, + "version": "4.7.12" + }, + "conda-4.7.12-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "05a53bfd6e1c665818b123900e4b9616", + "name": "conda", + "sha256": "00b7a77da3714217c113fbd0e25ca2ff53075fcf41b2d61a015b47d8639e00c3", + "size": 3160135, + "subdir": "linux-64", + "timestamp": 1568310314336, + "version": "4.7.12" + }, + "conda-4.7.12-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "547ec8f4122f32bb4f3ebacc553f4c62", + "name": "conda", + "sha256": "727b47c1f7f0d2ad868e0ca429979d736daf7764b3465a95423273d7856f5551", + "size": 3133131, + "subdir": "linux-64", + "timestamp": 1568310307400, + "version": "4.7.12" + }, + "conda-4.7.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "4e681c644bf30af553c745440abd7691", + "name": "conda", + "sha256": "40d6b9d7dc007ccf65ce070b8a47776e991ec1d7273ead5eedc529875250d166", + "size": 3146054, + "subdir": "linux-64", + "timestamp": 1561412192588, + "version": "4.7.5" + }, + "conda-4.7.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "3e1f28ebf156323de367ba562ba8d842", + "name": "conda", + "sha256": "39eb230bd049716828dd2124198dfe395e623e537e68a5ca19dfe8645b80a9b8", + "size": 3151265, + "subdir": "linux-64", + "timestamp": 1561412219811, + "version": "4.7.5" + }, + "conda-4.7.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "8e69fe0815af22b1ccc68914a2ec5681", + "name": "conda", + "sha256": "7b3948ceee7bcf91dbbd5b0e07c2d29eaf2281a981aec71ee1af933630f14830", + "size": 3126928, + "subdir": "linux-64", + "timestamp": 1561412180014, + "version": "4.7.5" + }, + "conda-4.7.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "291199bfb189460b9f0759050e9c0783", + "name": "conda", + "sha256": "c05edd803079ae9775b5ed359824ff0a9de23b92fe005c10739f68e35217e406", + "size": 3147664, + "subdir": "linux-64", + "timestamp": 1563398543033, + "version": "4.7.8" + }, + "conda-4.7.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "3c335dc98bd4bd5dc109c480c0435bc7", + "name": "conda", + "sha256": "71baad1089980a50d5bf58dc1a5cf34b9b92dbf954d47f89e59aa7ae6dd305b8", + "size": 3164004, + "subdir": "linux-64", + "timestamp": 1563398558776, + "version": "4.7.8" + }, + "conda-4.7.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "f6333dc82503bcff0a4ca4e4125a7eed", + "name": "conda", + "sha256": "11bdbef9f8fd6025d1301b99ca12e41f50f00ed11c298490549445360f7c5330", + "size": 3134920, + "subdir": "linux-64", + "timestamp": 1563398529351, + "version": "4.7.8" + }, + "conda-4.7.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "df9007eb65005cfbe8174b9acc3d97e2", + "name": "conda", + "sha256": "3931c46fc5ab0dd0427103a5cd98dfa145ce72237d4dc4310845fda28e15fec8", + "size": 3125826, + "subdir": "linux-64", + "timestamp": 1563478137013, + "version": "4.7.9" + }, + "conda-4.7.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "ebe017aadd110260cb143206384458a6", + "name": "conda", + "sha256": "8e63f04fe19f1f9a27ecb644e66b09f9c72b8b79ccc69326f5343ff5a82721e1", + "size": 3148875, + "subdir": "linux-64", + "timestamp": 1563478135332, + "version": "4.7.9" + }, + "conda-4.7.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "a43de6bb5c95b3f50255daaa2873bbe3", + "name": "conda", + "sha256": "88fb0517d1ba6ffe1782fcc790742e4acc8d005ae3111e7b54255cbf67f02c25", + "size": 3151718, + "subdir": "linux-64", + "timestamp": 1563478138590, + "version": "4.7.9" + }, + "conda-4.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "a47ee4543d66a0440b37b515a2b1b17f", + "name": "conda", + "sha256": "4806968d2c12951d1ad9d7f708bcc1cebebcd16579b512e9e7e0ef9115556306", + "size": 3148284, + "subdir": "linux-64", + "timestamp": 1576014409455, + "version": "4.8.0" + }, + "conda-4.8.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "eb34d98e88f80c152aa66db58fca80f7", + "name": "conda", + "sha256": "abf65d53e2185a4ecc2bd85fd83dde8529141c7cae75c2474f17811ac29c7f5a", + "size": 3163546, + "subdir": "linux-64", + "timestamp": 1576518384621, + "version": "4.8.0" + }, + "conda-4.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "0a66321d8321b390b277f0571737a52d", + "name": "conda", + "sha256": "c35f3276fdf228366a2c628ffb9b64874384baceac9b9ce22ed0df84d1233e1f", + "size": 3178737, + "subdir": "linux-64", + "timestamp": 1576014317588, + "version": "4.8.0" + }, + "conda-4.8.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "35aade6b9c3b025433a84a776fae3d9f", + "name": "conda", + "sha256": "93170b01e3809e9895cdca5d05ccef89b896e2068593c063f672861383be4dca", + "size": 3175186, + "subdir": "linux-64", + "timestamp": 1576518364899, + "version": "4.8.0" + }, + "conda-4.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "86e6bf2816239c066da9c65047d1d692", + "name": "conda", + "sha256": "d16c01cce6b33c6f2d63f4bc4758728c5479ea42161f10284802c040ca95e2b9", + "size": 3151937, + "subdir": "linux-64", + "timestamp": 1576014426650, + "version": "4.8.0" + }, + "conda-4.8.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "e4a1e238533ae48e457d893feedfa8de", + "name": "conda", + "sha256": "34c53865d95db120847e26b9cb8bcfdb4b1d92f1feb8f9315b1af2b835d3f9fd", + "size": 3181194, + "subdir": "linux-64", + "timestamp": 1576518373377, + "version": "4.8.0" + }, + "conda-4.8.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "2668060d7994baddcdd06c3b445acdd3", + "name": "conda", + "sha256": "9b58ea9ef6e5abebea7ff6fc05cc9b05fee87730f44451cb8ead30c6431f352a", + "size": 3171096, + "subdir": "linux-64", + "timestamp": 1576518374003, + "version": "4.8.0" + }, + "conda-4.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "3a6ba952b322c24ee6afbe5cd7a0eaf8", + "name": "conda", + "sha256": "e927e995bbb59ae527b3b2ae4608b4e9dc4254bc407a3da7280ba1a39500114e", + "size": 3166420, + "subdir": "linux-64", + "timestamp": 1576798189451, + "version": "4.8.1" + }, + "conda-4.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "1ab1e7e4663229b494f9c9f91c161b59", + "name": "conda", + "sha256": "a36c3f5ebaf17bbca2562132e8834f1b4d47ddeb27ed63f97bda6e5194d3e879", + "size": 3179779, + "subdir": "linux-64", + "timestamp": 1576798197060, + "version": "4.8.1" + }, + "conda-4.8.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "fe8d6ff3660d8341dc002579c08f8984", + "name": "conda", + "sha256": "85871b8d96a5bad447773d9cedc146f5b56c1dc2aff4b490c1c38d615a4444e2", + "size": 3188691, + "subdir": "linux-64", + "timestamp": 1576798200015, + "version": "4.8.1" + }, + "conda-4.8.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "5bbc904c8af704657169f3705aed1348", + "name": "conda", + "sha256": "4e465a6f07481b15d12e80546b4839ebc0528e89d7c0855f332a74a5308316fa", + "size": 3183123, + "subdir": "linux-64", + "timestamp": 1576798226942, + "version": "4.8.1" + }, + "conda-4.8.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "bec95da197639f9694691d5f051ded5f", + "name": "conda", + "sha256": "fad1728fc9db97e3b95b35b39433e5736de5f22ab19399151c938983080833a9", + "size": 3162416, + "subdir": "linux-64", + "timestamp": 1579893287075, + "version": "4.8.2" + }, + "conda-4.8.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "74c03baf00aaff718f123ba206a12fc0", + "name": "conda", + "sha256": "88f785b2001ac2b094352323a9302267b413816a8f1b6110ba854e3e68382029", + "size": 3183325, + "subdir": "linux-64", + "timestamp": 1579892872863, + "version": "4.8.2" + }, + "conda-4.8.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "51ea95b0a75aee0d935ce5c993d982bd", + "name": "conda", + "sha256": "2d86265bc74722bf2642401d5932fad8911df8adae6c1d06ff5a7514d1b374de", + "size": 3169262, + "subdir": "linux-64", + "timestamp": 1579892868224, + "version": "4.8.2" + }, + "conda-4.8.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "a6308eee912a6493dfb8c61952ed44de", + "name": "conda", + "sha256": "ed08e129e39901e5ee5392ddcca2b2e3c894a6342a7478cc5d9d7a5e24be4bff", + "size": 3156083, + "subdir": "linux-64", + "timestamp": 1579892881591, + "version": "4.8.2" + }, + "conda-4.8.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "5e949ee5f5060541d480d1525994b89e", + "name": "conda", + "sha256": "444ce7f00c106e84a45cd8f513a7a81c5e4865fa5838e65bc3c39bc79d68af50", + "size": 3181799, + "subdir": "linux-64", + "timestamp": 1584118806192, + "version": "4.8.3" + }, + "conda-4.8.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "6c884107a632279a6a92f7724ea1f8cf", + "name": "conda", + "sha256": "c4040dab9276bb9583284bb6d070a269515aca133352cdc433ff80ec53ccef78", + "size": 3192858, + "subdir": "linux-64", + "timestamp": 1584118803492, + "version": "4.8.3" + }, + "conda-4.8.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "935a6aeede69cadc3a16484911d7b1f3", + "name": "conda", + "sha256": "7024d35c50fa683a87ccea4c0bc3eac37689d8cf0a59fda5e5909ce68815476f", + "size": 3183453, + "subdir": "linux-64", + "timestamp": 1584118827005, + "version": "4.8.3" + }, + "conda-4.8.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "19bc55cbf6ec9e6afedfe3bf2717ff43", + "name": "conda", + "sha256": "336b1cf24ca204e7fd2a175f99be012d1d3d42fa69f5d49da4b621c6165d9e9f", + "size": 3185688, + "subdir": "linux-64", + "timestamp": 1584118815255, + "version": "4.8.3" + }, + "conda-4.8.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "scandir", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "f59c41ba216fa8aff320a792e7840996", + "name": "conda", + "sha256": "ab76bb6f34cd606a54f4f5494589ae82ed1afd996c70250a6ef87eaee3806205", + "size": 3194506, + "subdir": "linux-64", + "timestamp": 1596806961431, + "version": "4.8.4" + }, + "conda-4.8.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "455f19448d3cc3ede50fb2e243d7efca", + "name": "conda", + "sha256": "5603aea5a9130e50766a07be2b0d0b9e27998dc04c1423b172439958b5fa1b24", + "size": 3196400, + "subdir": "linux-64", + "timestamp": 1596806942726, + "version": "4.8.4" + }, + "conda-4.8.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "a995f3c5e1976e2a30dd32ed38787760", + "name": "conda", + "sha256": "5b64ed884d26a9ddfffabfa6340aa7faaecee8273833638311e6712b08714f9a", + "size": 3194458, + "subdir": "linux-64", + "timestamp": 1596806949701, + "version": "4.8.4" + }, + "conda-4.8.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "38b31ddf114588dbdf2c0db7af4b8cf3", + "name": "conda", + "sha256": "86d1a002c775a580e6f14b9e07ee3d1a9e7290d20d2fbd455fd673a1b541a50f", + "size": 3213615, + "subdir": "linux-64", + "timestamp": 1596806960404, + "version": "4.8.4" + }, + "conda-4.8.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "3b20b23919830873a148e25af9176e1c", + "name": "conda", + "sha256": "f184104a9582e1eac68a01645eb4a49b8c6519a9d844a8701d484c8666f0bfa2", + "size": 3192177, + "subdir": "linux-64", + "timestamp": 1600101159916, + "version": "4.8.5" + }, + "conda-4.8.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "a60894eb09e1ad2107f8f4d987f47de3", + "name": "conda", + "sha256": "67a075b6449adf4b8a62f6f68d524f99b66ee217da6fbeccb5dbb55d93b4ce27", + "size": 3204331, + "subdir": "linux-64", + "timestamp": 1600101130890, + "version": "4.8.5" + }, + "conda-4.8.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "9f3c40c2abe02327e297bc5524ff9e30", + "name": "conda", + "sha256": "43a9c96ac3053f25af44786ada2fa37f4b2acd7503206b379d55f9c4c2a9a43b", + "size": 3194609, + "subdir": "linux-64", + "timestamp": 1600101132847, + "version": "4.8.5" + }, + "conda-4.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "7e4bc961a37199d561909c56202aa604", + "name": "conda", + "sha256": "15940a3aa038324b8285ed4f6d13637903c2f513ea5b8537f810239e43d5bfba", + "size": 3227482, + "subdir": "linux-64", + "timestamp": 1602695677366, + "version": "4.9.0" + }, + "conda-4.9.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "005e701d68901f27aa49282501dc7edf", + "name": "conda", + "sha256": "720038fac55ebfcbb1fe19fd9b4c41891f8d63e2ecc4f46db9e5ebd8a0fa536b", + "size": 3214724, + "subdir": "linux-64", + "timestamp": 1602695672504, + "version": "4.9.0" + }, + "conda-4.9.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "96f823bd55a72a901eaf0dfad7f1e3ca", + "name": "conda", + "sha256": "c8922865d361d9ee30ffcbdc1f30e7fb2ddca87f7e70ae40d844cf5e1bd73c48", + "size": 3235082, + "subdir": "linux-64", + "timestamp": 1602695672853, + "version": "4.9.0" + }, + "conda-4.9.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "559349878b559d30817fc3677047c69e", + "name": "conda", + "sha256": "6fadff72295fb27c5317f538e800e5bf301a69a6fa0f64f4a71216e1839a25e8", + "size": 3206527, + "subdir": "linux-64", + "timestamp": 1603740915199, + "version": "4.9.1" + }, + "conda-4.9.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "59e9dabe3591d8690c9bb1af9242159d", + "name": "conda", + "sha256": "3ad9763c872b13d89fe3587d861ecf2e53af735aaa62ae55c5749dda9ae42278", + "size": 3209147, + "subdir": "linux-64", + "timestamp": 1603738964215, + "version": "4.9.1" + }, + "conda-4.9.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "3c91423c5ad08b352e6b61b26d1db1a2", + "name": "conda", + "sha256": "a1b529778fcff9834f96c7129c9df17a054a20b051c5a714f584df282a407c5a", + "size": 3217067, + "subdir": "linux-64", + "timestamp": 1603738979273, + "version": "4.9.1" + }, + "conda-4.9.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "cc3678b8938212f81fc2ca9faefa1e03", + "name": "conda", + "sha256": "2ffcd496899119a6b4161c1a30325eafc97dc9941db6a07920efd7d4b270b4b6", + "size": 3224560, + "subdir": "linux-64", + "timestamp": 1605067712825, + "version": "4.9.2" + }, + "conda-4.9.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "1584b9675483fc2a86c931afee5001e2", + "name": "conda", + "sha256": "fd064a610b7d99bf8ffb9e677acf223d9ec74a0e8ca2f7e62a1841b91d99428c", + "size": 3200954, + "subdir": "linux-64", + "timestamp": 1605068097561, + "version": "4.9.2" + }, + "conda-4.9.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "f25312fcb29151d2dffaabf70d738330", + "name": "conda", + "sha256": "d3f724462e4294647c31fbfbc54345b9a10d1d1158d3abcba4099e085ca08803", + "size": 3215044, + "subdir": "linux-64", + "timestamp": 1605067666167, + "version": "4.9.2" + }, + "conda-4.9.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "229bf585b8063b85db9bfc7d1bd22636", + "name": "conda", + "sha256": "603b7ecb886e26303a5216bfca617698ca78ce3c92bb88f85ee861b648b9d1f8", + "size": 3216350, + "subdir": "linux-64", + "timestamp": 1607006162985, + "version": "4.9.2" + }, + "conda-audit-0.8.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "conda", + "conda-repo-cli", + "python >=3.10,<3.11.0a0", + "requests", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3a26fa2dc10d86acbdc0f41d9ecd5907", + "name": "conda-audit", + "sha256": "82aabb40aa62f4fd623a3eda9f8fd491cbfe9e8eb2fc61b18d13db972e6de569", + "size": 15380, + "subdir": "linux-64", + "timestamp": 1655392299750, + "version": "0.8.1" + }, + "conda-audit-0.8.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "conda", + "conda-repo-cli", + "python >=3.7,<3.8.0a0", + "requests", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e7624b6b2363235f26035dea96de109b", + "name": "conda-audit", + "sha256": "034068d61faae89ebc2e6bc7d49d8bd9c281bb11220af7f5f77210fde6a0f223", + "size": 15285, + "subdir": "linux-64", + "timestamp": 1655392254734, + "version": "0.8.1" + }, + "conda-audit-0.8.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "conda", + "conda-repo-cli", + "python >=3.8,<3.9.0a0", + "requests", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cb46a9c26f664a5e5c8b26fba53a0e1a", + "name": "conda-audit", + "sha256": "26bb35377427f8eb40bd1a08ad24e911181824d66cb72ecc2723e56fad0a00c4", + "size": 15329, + "subdir": "linux-64", + "timestamp": 1655392184141, + "version": "0.8.1" + }, + "conda-audit-0.8.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "conda", + "conda-repo-cli", + "python >=3.9,<3.10.0a0", + "requests", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "670a79a683e9e387e2d0c8d62ba4bf34", + "name": "conda-audit", + "sha256": "d27a956be0cb237c363be11b96116061e7cf68dec4454959abe89dcfad94e9c7", + "size": 15300, + "subdir": "linux-64", + "timestamp": 1655392221156, + "version": "0.8.1" + }, + "conda-build-3.0.22-py27h62b9468_0.tar.bz2": { + "build": "py27h62b9468_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "797264e0a88e08e6615b65c288433638", + "name": "conda-build", + "sha256": "4026fcfce0db2f9c2eb204566a1bdb604a528ae0d797f323f1730a7672381bad", + "size": 377956, + "subdir": "linux-64", + "timestamp": 1505957115271, + "version": "3.0.22" + }, + "conda-build-3.0.22-py35h43e46ce_0.tar.bz2": { + "build": "py35h43e46ce_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7dff6d02143611b376fb320e4f91674a", + "name": "conda-build", + "sha256": "fde3db5d0162e75185de692e66d6d8a607345d0de695f4cc4e099829c22812b6", + "size": 383366, + "subdir": "linux-64", + "timestamp": 1505957138698, + "version": "3.0.22" + }, + "conda-build-3.0.22-py36ha23cd1e_0.tar.bz2": { + "build": "py36ha23cd1e_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "48d12351be3920d5266bf592f6c9d70c", + "name": "conda-build", + "sha256": "17db2db312e7ebf4e3c490adeb0125f38dc3f6a295ed3ccb4a6a4e64ea279bac", + "size": 380267, + "subdir": "linux-64", + "timestamp": 1505957162933, + "version": "3.0.22" + }, + "conda-build-3.0.23-py27h7bd6724_0.tar.bz2": { + "build": "py27h7bd6724_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "356dbc63b307c21f9108a2a8963f9cd8", + "name": "conda-build", + "sha256": "b3adf56e7dc65262501ec5734c31d4bc8ee9e5ece4b87ef2c75c67f6837493b9", + "size": 379613, + "subdir": "linux-64", + "timestamp": 1506713835808, + "version": "3.0.23" + }, + "conda-build-3.0.23-py35hea4baf8_0.tar.bz2": { + "build": "py35hea4baf8_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cb59f1d4022dd1d4956d3eb2fd76dc2a", + "name": "conda-build", + "sha256": "6c72c14ae02815a15bbaaff20b0beb133dd86a1ea79394522812fe556bb865a9", + "size": 384320, + "subdir": "linux-64", + "timestamp": 1506713848497, + "version": "3.0.23" + }, + "conda-build-3.0.23-py36h1da9bb0_0.tar.bz2": { + "build": "py36h1da9bb0_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0e24ea8e2d3af7eebc7bad3f0064f65f", + "name": "conda-build", + "sha256": "d9a21d56df9b24b20aba242277949fe508d2a481abd44c3e515b4107d514184d", + "size": 380858, + "subdir": "linux-64", + "timestamp": 1506713850026, + "version": "3.0.23" + }, + "conda-build-3.0.25-py27h9e7ea37_0.tar.bz2": { + "build": "py27h9e7ea37_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "04f03f5abe2d079218f566b27a6439aa", + "name": "conda-build", + "sha256": "c35de29adff59cd9aba735e5d39dc36ab2ece8a3fd98b7b3158e5ce95385f84e", + "size": 380406, + "subdir": "linux-64", + "timestamp": 1507323544381, + "version": "3.0.25" + }, + "conda-build-3.0.25-py35h519b4b2_0.tar.bz2": { + "build": "py35h519b4b2_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a3e66e9ad9d5b71030a14efd590d21ed", + "name": "conda-build", + "sha256": "f0559ba424c3686f4fd5d30a03fe55492300c6de8f9383214a814996fd76e49e", + "size": 385861, + "subdir": "linux-64", + "timestamp": 1507323529255, + "version": "3.0.25" + }, + "conda-build-3.0.25-py36hd2c3b30_0.tar.bz2": { + "build": "py36hd2c3b30_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4ae41af73b183965dc921df4ae2bb262", + "name": "conda-build", + "sha256": "643a2263e8a995808727a0878312434f419f1b50eaa1f2ac78d7a5309489c314", + "size": 381869, + "subdir": "linux-64", + "timestamp": 1507323609964, + "version": "3.0.25" + }, + "conda-build-3.0.26-py27h07bdda1_0.tar.bz2": { + "build": "py27h07bdda1_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c1a686dce88b21f39c9d0ece0648df23", + "name": "conda-build", + "sha256": "433bcb5224f155a22e7715a34e1e7dd5f7c5885d372829a6089319a2e65d403b", + "size": 382781, + "subdir": "linux-64", + "timestamp": 1508170500586, + "version": "3.0.26" + }, + "conda-build-3.0.26-py35h4278e0b_0.tar.bz2": { + "build": "py35h4278e0b_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "43334f88734142ab0766be6f17eba53e", + "name": "conda-build", + "sha256": "1860924cca5c9504d978b42637fde1e4ccf8f309533962fd16f2fc5139cafd96", + "size": 388140, + "subdir": "linux-64", + "timestamp": 1508170502021, + "version": "3.0.26" + }, + "conda-build-3.0.26-py36he907c6d_0.tar.bz2": { + "build": "py36he907c6d_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ac72ef1747f361e9b112d76dc34c6795", + "name": "conda-build", + "sha256": "3fa99b6b3a99101a3e2ed7db5fde3e19c0584655b64d8b978c2623a81b3e558e", + "size": 385190, + "subdir": "linux-64", + "timestamp": 1508170527899, + "version": "3.0.26" + }, + "conda-build-3.0.27-py27hff9f855_0.tar.bz2": { + "build": "py27hff9f855_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bafbd7c1942cd7cdc1d084a1df3b18fa", + "name": "conda-build", + "sha256": "e615dd1bd4a01b207b438dfde80f417120bc1be38fba9aea0a38b8b01b889f05", + "size": 382777, + "subdir": "linux-64", + "timestamp": 1508268461537, + "version": "3.0.27" + }, + "conda-build-3.0.27-py35h86d73a5_0.tar.bz2": { + "build": "py35h86d73a5_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5a4ee99fe988ac58c123e7cd32ce415f", + "name": "conda-build", + "sha256": "339c263dcea45a848f10465281a795b91f4d4373cc941f3c1f1b1268d2c815fa", + "size": 388126, + "subdir": "linux-64", + "timestamp": 1508268464038, + "version": "3.0.27" + }, + "conda-build-3.0.27-py36h940a66d_0.tar.bz2": { + "build": "py36h940a66d_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "130e050c035a87ddea62e08e38a5a6d6", + "name": "conda-build", + "sha256": "4cdfacfb9764c38738c4a40fa88d5100934dcff0f4b2fc2c92315f50972ad353", + "size": 385199, + "subdir": "linux-64", + "timestamp": 1508268468009, + "version": "3.0.27" + }, + "conda-build-3.0.28-py27h7ba76ae_0.tar.bz2": { + "build": "py27h7ba76ae_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ff4a6e5c40105ccb6bfd83ac6cdafdf1", + "name": "conda-build", + "sha256": "6d8453affde3e764357b9be7757a0a897f4077257b05bbeba513cebf1daa8555", + "size": 390342, + "subdir": "linux-64", + "timestamp": 1509654249031, + "version": "3.0.28" + }, + "conda-build-3.0.28-py35hf80548c_0.tar.bz2": { + "build": "py35hf80548c_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "275536ee78db20885ad898d69c41050f", + "name": "conda-build", + "sha256": "0b3bcbb13fa27b004d74efd6f5f265077c7ef1e3b3aef2d2266efdffc556b439", + "size": 394681, + "subdir": "linux-64", + "timestamp": 1509654259481, + "version": "3.0.28" + }, + "conda-build-3.0.28-py36h4c1d7b2_0.tar.bz2": { + "build": "py36h4c1d7b2_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "417209fb1bd05a24ea8593c236ce3ce5", + "name": "conda-build", + "sha256": "03f1760a71eae80fe7311d576bf602427907e38008830d3d5cf65852118c52e7", + "size": 392554, + "subdir": "linux-64", + "timestamp": 1509654263871, + "version": "3.0.28" + }, + "conda-build-3.0.29-py27hd1a3dae_0.tar.bz2": { + "build": "py27hd1a3dae_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bbfe53849c9a62f96d930f14cf0b59bf", + "name": "conda-build", + "sha256": "056ab6e956cb75a363ae389291760c838d990c1d8b4ac57db98309795be47fbc", + "size": 400165, + "subdir": "linux-64", + "timestamp": 1510352388336, + "version": "3.0.29" + }, + "conda-build-3.0.29-py35hf44b5de_0.tar.bz2": { + "build": "py35hf44b5de_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "da81e921cdafdce2464aa1cb33f66c78", + "name": "conda-build", + "sha256": "c7ce5153217ac21af162936e612e98028c9d9ae6d8bbbd6b2154696979d5a347", + "size": 404324, + "subdir": "linux-64", + "timestamp": 1510352388661, + "version": "3.0.29" + }, + "conda-build-3.0.29-py36h7319bf4_0.tar.bz2": { + "build": "py36h7319bf4_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "06e2b4dd5b281ab484f056590fb52b10", + "name": "conda-build", + "sha256": "3c89f7999f82ba39ae323b3e6ad4a9f1f0aa34f2cb8deaaf5cd45468cf18044e", + "size": 401577, + "subdir": "linux-64", + "timestamp": 1510352349266, + "version": "3.0.29" + }, + "conda-build-3.0.30-py27h5c0a2bd_0.tar.bz2": { + "build": "py27h5c0a2bd_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c45e12b26e0a4ab4ef69742677c835aa", + "name": "conda-build", + "sha256": "5ad5b8d94095a393258826dbd20d2847f337278061efe7d4cd9212ebbb3e80ce", + "size": 400689, + "subdir": "linux-64", + "timestamp": 1510794545986, + "version": "3.0.30" + }, + "conda-build-3.0.30-py35hd089694_0.tar.bz2": { + "build": "py35hd089694_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7bcc6bb8d3dd7f79fb20a80ca6660de4", + "name": "conda-build", + "sha256": "17f6e035c8c35c0092fe84e40a55b5cde5185ce0e130e621485d0bb7f1223e4d", + "size": 404461, + "subdir": "linux-64", + "timestamp": 1510794555919, + "version": "3.0.30" + }, + "conda-build-3.0.30-py36hc0a0e36_0.tar.bz2": { + "build": "py36hc0a0e36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a01a42f1b5d1553ba598f35b5ac09504", + "name": "conda-build", + "sha256": "6f9abb70e1c927f653e593aa8e88309251f55c9d240447f9189b194926c1f79e", + "size": 402029, + "subdir": "linux-64", + "timestamp": 1510794558562, + "version": "3.0.30" + }, + "conda-build-3.0.31-py27h49342b2_0.tar.bz2": { + "build": "py27h49342b2_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3b9f8ca821b23b17d81d40f350fd82ef", + "name": "conda-build", + "sha256": "b84a5c0f0a208c4487331f2e9079c559cac781821c08a1925e6d62240dec6b42", + "size": 402190, + "subdir": "linux-64", + "timestamp": 1512072485097, + "version": "3.0.31" + }, + "conda-build-3.0.31-py35h9a3bff0_0.tar.bz2": { + "build": "py35h9a3bff0_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bd2ce59495d99a00dd012263bb8090fd", + "name": "conda-build", + "sha256": "a3b7843cee2e67f4c32d8703954b1c102f01b4112be816039b3bc7c3c5d06303", + "size": 406040, + "subdir": "linux-64", + "timestamp": 1512072488385, + "version": "3.0.31" + }, + "conda-build-3.0.31-py36h269c84b_0.tar.bz2": { + "build": "py36h269c84b_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8e79064caaae8bc41385f219e6734384", + "name": "conda-build", + "sha256": "f1571c51dd836f296a51e2d9a8bbc7c879c07efeb9cee76742d2e2d6150b566a", + "size": 403003, + "subdir": "linux-64", + "timestamp": 1512072549760, + "version": "3.0.31" + }, + "conda-build-3.1.0-py27h049eb84_0.tar.bz2": { + "build": "py27h049eb84_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8b6c42a8ad7e97f6f69ba2d17715c808", + "name": "conda-build", + "sha256": "c2852db7527761e9fb6db3bf72cdc1af4341b043c7e2fb7a44bbd9ac11719637", + "size": 401825, + "subdir": "linux-64", + "timestamp": 1512509604602, + "version": "3.1.0" + }, + "conda-build-3.1.0-py35h0f6ab93_0.tar.bz2": { + "build": "py35h0f6ab93_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "936f6ad0bbdafadc545964ea613f8098", + "name": "conda-build", + "sha256": "6fecdf1ace89913c3a6f8b09c07266ee75f61940bd7e85b88cd7601cdedfe6a7", + "size": 407172, + "subdir": "linux-64", + "timestamp": 1512509604903, + "version": "3.1.0" + }, + "conda-build-3.1.0-py36h13c0544_0.tar.bz2": { + "build": "py36h13c0544_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7ba1d9df21b56ebaf34e7e8d1f124ae1", + "name": "conda-build", + "sha256": "92f798cb9a9b8c8a0657af18a9cc8fd48d571908bb19107981cc9693b0d1faf7", + "size": 405028, + "subdir": "linux-64", + "timestamp": 1512509601203, + "version": "3.1.0" + }, + "conda-build-3.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9458ffbe7ecd9a8e7f7bab83183b062c", + "name": "conda-build", + "sha256": "6652bf093ef0449c409288c85553d5ed58de25fc2b6cff7ac287756953b499c1", + "size": 401487, + "subdir": "linux-64", + "timestamp": 1512615345342, + "version": "3.1.1" + }, + "conda-build-3.1.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "78813ed89fea17bd9b234ba19fba29f5", + "name": "conda-build", + "sha256": "0f6e17fdb7c49d1b6c0fbe0af372ab5514f8261df2646d0c4a10400d86a23461", + "size": 407122, + "subdir": "linux-64", + "timestamp": 1512615331100, + "version": "3.1.1" + }, + "conda-build-3.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4c92897babb431ef820a2b36c9f3dc5d", + "name": "conda-build", + "sha256": "ae9826440def98ea0d7be75f4bf1fdb79f8a661795c5ff51a54d8ea5ce9175c9", + "size": 405120, + "subdir": "linux-64", + "timestamp": 1512615374704, + "version": "3.1.1" + }, + "conda-build-3.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f2d779c4660d8876a4fd6bce56c11d4e", + "name": "conda-build", + "sha256": "d520c3681454b25d7d06f20df29c62c266a8c0fa912f9b9d3f0c7ed74ef18aed", + "size": 403095, + "subdir": "linux-64", + "timestamp": 1512873509214, + "version": "3.1.2" + }, + "conda-build-3.1.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "48f16c94c54903a6bd140187f34572fc", + "name": "conda-build", + "sha256": "2dfd7e7f1da36a7747e71c7db8ecbec2d5ca92b6461b5f0b840ba8389b390d6e", + "size": 408176, + "subdir": "linux-64", + "timestamp": 1512873560949, + "version": "3.1.2" + }, + "conda-build-3.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d89a10bbd1024a557d53b9181e0438ca", + "name": "conda-build", + "sha256": "ede96048d16467ce97704ffcf0931e749be7563b3dfd3a6aa0160b6aff6a46e9", + "size": 405039, + "subdir": "linux-64", + "timestamp": 1512873583094, + "version": "3.1.2" + }, + "conda-build-3.1.3-py27h5233db4_0.tar.bz2": { + "build": "py27h5233db4_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5641ef47b8b4dee589759d704baf686b", + "name": "conda-build", + "sha256": "325eee312d7d88158ad9086df8d4db6d91247086ae3f65d6e0833f66be8bdaba", + "size": 403606, + "subdir": "linux-64", + "timestamp": 1513182704168, + "version": "3.1.3" + }, + "conda-build-3.1.3-py35h2f9c1c0_0.tar.bz2": { + "build": "py35h2f9c1c0_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ca14fc7f488c553b26a4347c47f3d3fa", + "name": "conda-build", + "sha256": "61ddea28d28a4f11f1d63f8ec261583284022fc84479a4b65babb2724f299764", + "size": 408938, + "subdir": "linux-64", + "timestamp": 1513182722690, + "version": "3.1.3" + }, + "conda-build-3.1.3-py36h2f9c1c0_0.tar.bz2": { + "build": "py36h2f9c1c0_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "17e605186851e265051bb7b8ab4d0167", + "name": "conda-build", + "sha256": "d49309f606b8579859540bdaea22ecc00b5909c71a2d8e74006621c1ebbc2e2f", + "size": 406724, + "subdir": "linux-64", + "timestamp": 1513182759795, + "version": "3.1.3" + }, + "conda-build-3.1.4-py27h5233db4_0.tar.bz2": { + "build": "py27h5233db4_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b6e9fd057bddb32daf43b16091d91688", + "name": "conda-build", + "sha256": "69cf73ebd6dd6f62eb52348ea5d3da166782e0199f54e8f3c79d202ce4deae82", + "size": 404691, + "subdir": "linux-64", + "timestamp": 1513307105807, + "version": "3.1.4" + }, + "conda-build-3.1.4-py35h2f9c1c0_0.tar.bz2": { + "build": "py35h2f9c1c0_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1b5774ff8f2901680ec751f938ace18a", + "name": "conda-build", + "sha256": "730012fa7d29a87c423930f12d259ee385d8674f0df56752d295c9b09a726c01", + "size": 409766, + "subdir": "linux-64", + "timestamp": 1513307146217, + "version": "3.1.4" + }, + "conda-build-3.1.4-py36h2f9c1c0_0.tar.bz2": { + "build": "py36h2f9c1c0_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "195fe30d90c7b25fe2dab7722933a47c", + "name": "conda-build", + "sha256": "9758c888b8d2778202145d61f046fa30fcd8d2709bbe991ee016fc1b58a75ff4", + "size": 407320, + "subdir": "linux-64", + "timestamp": 1513307159935, + "version": "3.1.4" + }, + "conda-build-3.1.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0932d191fa36aa64bddb1b978abba4ec", + "name": "conda-build", + "sha256": "0a2d27cd55abc60ec1904fd6adc3da1ccb4901b8fba97907f2f527a643aae747", + "size": 404413, + "subdir": "linux-64", + "timestamp": 1513358799189, + "version": "3.1.5" + }, + "conda-build-3.1.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "302d2f9cb732caae55cf1830016d4cd9", + "name": "conda-build", + "sha256": "356590d164f792d6a96e95482f18205a9778817df8e23d95707899a2dbd2abc9", + "size": 410335, + "subdir": "linux-64", + "timestamp": 1513358804677, + "version": "3.1.5" + }, + "conda-build-3.1.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6e382ab6ddd73cde11b6edce0d6c0e4b", + "name": "conda-build", + "sha256": "9e31a1699d4780c215e3e97a034b901859f166f31944ce3d79bd2ca508c8552a", + "size": 407767, + "subdir": "linux-64", + "timestamp": 1513358780636, + "version": "3.1.5" + }, + "conda-build-3.1.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d3c51970ec21e851d07680b37b4de96c", + "name": "conda-build", + "sha256": "f00d1a97209d99565c58826995a6113935ccca30df13d7ad108a395fb735fd1e", + "size": 405100, + "subdir": "linux-64", + "timestamp": 1513378876982, + "version": "3.1.6" + }, + "conda-build-3.1.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a13f58c4f94f6f0a3ef836debfecdfc1", + "name": "conda-build", + "sha256": "35e2cc83bf0798fd7c4c97d5c9180964a6f35e141e03b315841c0dabc6a320e3", + "size": 410083, + "subdir": "linux-64", + "timestamp": 1513378887150, + "version": "3.1.6" + }, + "conda-build-3.1.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fbd28fe72bf4b879f56913eeeab00e73", + "name": "conda-build", + "sha256": "40094211fd019bab2763398ab02a0e56a9c0f9f7f68cacfffb20f5641464f433", + "size": 407373, + "subdir": "linux-64", + "timestamp": 1513378886639, + "version": "3.1.6" + }, + "conda-build-3.10.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ff0b0243dff640455da23946c9863dd0", + "name": "conda-build", + "sha256": "2d08a4d0a7f8c80f385bd787bfde8e692efcfd40b4224194249d7df203b17b90", + "size": 436235, + "subdir": "linux-64", + "timestamp": 1525183655487, + "version": "3.10.0" + }, + "conda-build-3.10.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9ae6fff04d33383a91563310fb9973dd", + "name": "conda-build", + "sha256": "e7381307a63c351c551395f71c5024691cd181c18857a8f6011b9aba15db4b2d", + "size": 440909, + "subdir": "linux-64", + "timestamp": 1525183680844, + "version": "3.10.0" + }, + "conda-build-3.10.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d2206c70146a90827267e5dad63c7142", + "name": "conda-build", + "sha256": "db156046b8fcbe7372d9680a458924c2683854dcf23f1c57709e13354ae7fdd2", + "size": 439667, + "subdir": "linux-64", + "timestamp": 1525183677072, + "version": "3.10.0" + }, + "conda-build-3.10.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b9cd5e26829e41ca3957b68fae2525a8", + "name": "conda-build", + "sha256": "550547e5e95c13f2a2318007f74e48e7c40f84140663e8aa5c9362f720334cff", + "size": 436707, + "subdir": "linux-64", + "timestamp": 1525209201678, + "version": "3.10.1" + }, + "conda-build-3.10.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a6df5ae1367b282dd8ab042d904f8e15", + "name": "conda-build", + "sha256": "21cfed5913878d1cc82dff55a3f0baa8e9ce4c2a4127cdca7c92e416b78f5624", + "size": 440618, + "subdir": "linux-64", + "timestamp": 1525209215113, + "version": "3.10.1" + }, + "conda-build-3.10.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0e1999a9a4fdff4864b23993912daaf7", + "name": "conda-build", + "sha256": "45a113b12c51fef842f5fa1fbdf43e381dc3eaaeef53364b3ed411f2eba0935b", + "size": 439841, + "subdir": "linux-64", + "timestamp": 1525209251831, + "version": "3.10.1" + }, + "conda-build-3.10.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "08fb767d78f04a3e0d1dde1a4cd15a71", + "name": "conda-build", + "sha256": "ccc637015d90c70ac83254c472ffe291f2997849355a37c04f15047b378dc1ee", + "size": 437381, + "subdir": "linux-64", + "timestamp": 1525818018886, + "version": "3.10.2" + }, + "conda-build-3.10.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6df2ac7cef7c18c6a1886b86bdb9913e", + "name": "conda-build", + "sha256": "c37ed7e6f57d00123e1198cad334f2753308c2f536e7823e850e3e9a3d84bdc7", + "size": 441215, + "subdir": "linux-64", + "timestamp": 1525818085109, + "version": "3.10.2" + }, + "conda-build-3.10.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "02ef766a52195345278def1285bde1aa", + "name": "conda-build", + "sha256": "1c1a1e78df24fa373284ce691aae0db6b321d6a5fe174df2a86187633ef816b5", + "size": 440336, + "subdir": "linux-64", + "timestamp": 1525818085489, + "version": "3.10.2" + }, + "conda-build-3.10.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "150cd2d58ba32e04f35dbdf9f373fe49", + "name": "conda-build", + "sha256": "4c79ffd4c72cd799bce3dd9cc86ad8b87ca19a4c8983619b31af27843e6f1dec", + "size": 438168, + "subdir": "linux-64", + "timestamp": 1526584916225, + "version": "3.10.3" + }, + "conda-build-3.10.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d10b00ed6b3b74d1e5863c40be58f422", + "name": "conda-build", + "sha256": "46e44218d808989cdd918ef22eb78087f318dee0951b12caa4916efac5cb0c91", + "size": 441653, + "subdir": "linux-64", + "timestamp": 1526584942406, + "version": "3.10.3" + }, + "conda-build-3.10.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0974cf26066a61bdd8361ea9cda7dc44", + "name": "conda-build", + "sha256": "a502a4af71e4696b3f360960918f1873cde3df27ddce2e0e3e80921a28f8da67", + "size": 441289, + "subdir": "linux-64", + "timestamp": 1526584913108, + "version": "3.10.3" + }, + "conda-build-3.10.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5c58f68dab408bed1ff448e857480708", + "name": "conda-build", + "sha256": "5dc5a9d6526a4ecdd3ef05a596118f0ba71218407a9b26be40bd89c322f021f5", + "size": 438124, + "subdir": "linux-64", + "timestamp": 1526827648866, + "version": "3.10.4" + }, + "conda-build-3.10.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b0a75f1555d729bf6ebb9d6213ef9198", + "name": "conda-build", + "sha256": "45855903adef462e4c2626a71ebfe779a42449a55738a4460219b95436de97f8", + "size": 441753, + "subdir": "linux-64", + "timestamp": 1526827682500, + "version": "3.10.4" + }, + "conda-build-3.10.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fff97745fd28f107ff9ef8debe5c8869", + "name": "conda-build", + "sha256": "7de5d87b0eef1d2dc17667a2f946f23686e66579d2fa06eb3117c3db480365f2", + "size": 441335, + "subdir": "linux-64", + "timestamp": 1526827648501, + "version": "3.10.4" + }, + "conda-build-3.10.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e80d0ae15866316a2db39a93342f42bb", + "name": "conda-build", + "sha256": "7b58e19fbd8def5a6ad2feb2833b7547a2dc0a8a9e581952bc4e341871b77624", + "size": 438406, + "subdir": "linux-64", + "timestamp": 1527098088971, + "version": "3.10.5" + }, + "conda-build-3.10.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "19db2f2cfe8e2c99e2479c6f0db301a9", + "name": "conda-build", + "sha256": "9fbecbc7c94f9a1f77ea09496bf73e25cead882f635e836f3b308191bc37347f", + "size": 442526, + "subdir": "linux-64", + "timestamp": 1527098110400, + "version": "3.10.5" + }, + "conda-build-3.10.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "508bd882103ba1e1618ac5aa7b653f04", + "name": "conda-build", + "sha256": "4695783d3bdf3cf7541a67f70a3007c409fde9c04024be69c1615d337ab2e9a7", + "size": 441430, + "subdir": "linux-64", + "timestamp": 1527098086468, + "version": "3.10.5" + }, + "conda-build-3.10.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a440d4687484f73571ddf9aad488f48c", + "name": "conda-build", + "sha256": "b0d414f4d60f2714fc3b964a97b97626c0a1b4e4a0d104c4133ccdfb71254e78", + "size": 439081, + "subdir": "linux-64", + "timestamp": 1527826079738, + "version": "3.10.6" + }, + "conda-build-3.10.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cf19de9cb22e43ca186beb391cec986c", + "name": "conda-build", + "sha256": "4370b9a9998ff7f73816dc80c0f3c6d81e9ed403576fe592435dad4d199c7210", + "size": 443338, + "subdir": "linux-64", + "timestamp": 1527826121147, + "version": "3.10.6" + }, + "conda-build-3.10.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "32e560dde76fc48265b546d4ebe748fc", + "name": "conda-build", + "sha256": "1545b8b8deb567e01708553671f47cd837cba8d3ef9b18fdb11d5a9e51be6cdf", + "size": 442466, + "subdir": "linux-64", + "timestamp": 1527826076779, + "version": "3.10.6" + }, + "conda-build-3.10.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dee1b9be112f7bee38ce3ac324b9dfed", + "name": "conda-build", + "sha256": "ff8d60694feb870484b65281f15437c790c3b109ed33bec3d5f08132be0fc64e", + "size": 439519, + "subdir": "linux-64", + "timestamp": 1527907070076, + "version": "3.10.7" + }, + "conda-build-3.10.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e547987c3610e4cc0afd8e916ed98901", + "name": "conda-build", + "sha256": "be22e51e52f261f5de36b638ecc64b4687872848d1680e8d05384237d625e06c", + "size": 442957, + "subdir": "linux-64", + "timestamp": 1527907094524, + "version": "3.10.7" + }, + "conda-build-3.10.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c8903479cb7183811a6f883307582234", + "name": "conda-build", + "sha256": "e80f00bf22e1f1c7dffff7ce655f706b63aa2cf874ef4560dae0253372151951", + "size": 442911, + "subdir": "linux-64", + "timestamp": 1527907078069, + "version": "3.10.7" + }, + "conda-build-3.10.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dd4965b549e776cd8efe1987aca31c0f", + "name": "conda-build", + "sha256": "99df1709e35f547e2cebca4f591dee66f83a692abdcb96b6561b2927f97396b0", + "size": 439492, + "subdir": "linux-64", + "timestamp": 1528812761733, + "version": "3.10.8" + }, + "conda-build-3.10.8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6246005fe0adea4c103efa9eab59d710", + "name": "conda-build", + "sha256": "1e59ebf8b1b6a3eddd39eec9d0387a59eb0190f0fd3fb8564c7c7f527ca3bb56", + "size": 443776, + "subdir": "linux-64", + "timestamp": 1528812803858, + "version": "3.10.8" + }, + "conda-build-3.10.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4a2c892e5b3eed839ff63c8f6662cda5", + "name": "conda-build", + "sha256": "40ef537e69021dda1d2b6195cac02a56ad4d48c94e120f1ec7f448e88d2f120c", + "size": 442693, + "subdir": "linux-64", + "timestamp": 1528812744683, + "version": "3.10.8" + }, + "conda-build-3.10.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c0f396f4cc4b9463105b33c80f6ec26c", + "name": "conda-build", + "sha256": "0b64642d83d468f7dd0bc5def68318ae2383b7f02a2f1197262a241fe03a1d23", + "size": 440192, + "subdir": "linux-64", + "timestamp": 1529089652595, + "version": "3.10.9" + }, + "conda-build-3.10.9-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cfeaa6f61460c82c9c585c6ee7848b79", + "name": "conda-build", + "sha256": "4e7d03054bdfbf056d125cdcaf6bd537109e2a98fc091bb7b1e29977d3a6013e", + "size": 443044, + "subdir": "linux-64", + "timestamp": 1529089674706, + "version": "3.10.9" + }, + "conda-build-3.10.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bcf363ea872c9ad7f3ea6458b4629651", + "name": "conda-build", + "sha256": "9dd31f838c31de9af96058dff94c7566a6b1268f0379ddb1ecbfa8d8103a78a9", + "size": 442902, + "subdir": "linux-64", + "timestamp": 1529089660668, + "version": "3.10.9" + }, + "conda-build-3.10.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "52eec92072f62f7961ee4d7d82d4efd1", + "name": "conda-build", + "sha256": "d772dda39de8c10c0283fdfbcb7369aa73ca1a6ade1dcdb731a9c28a28043bee", + "size": 441908, + "subdir": "linux-64", + "timestamp": 1530813751494, + "version": "3.10.9" + }, + "conda-build-3.11.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b15f157a78caef0fe6027bde84d4ec61", + "name": "conda-build", + "sha256": "e82a39509e40a76d8e67107031e2cd7286dd5613ba13ae21f3e5bbe12eb7fc1a", + "size": 441217, + "subdir": "linux-64", + "timestamp": 1532137821471, + "version": "3.11.0" + }, + "conda-build-3.11.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5215ac44e89b60cd37e9c1510b201d69", + "name": "conda-build", + "sha256": "6dcfca26e7ee83bf07255721dc20ddff3631da6a939f1c85d22dee17830f1e9f", + "size": 445384, + "subdir": "linux-64", + "timestamp": 1532137846504, + "version": "3.11.0" + }, + "conda-build-3.11.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c5dfd08339563a3dfad4547eb806ced0", + "name": "conda-build", + "sha256": "d0318c5c993e967a8e1b1034ba0083ec12518a448a30441b7d966be891961482", + "size": 444660, + "subdir": "linux-64", + "timestamp": 1532137774703, + "version": "3.11.0" + }, + "conda-build-3.12.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c12c12b5d84fed0cb179f56215342478", + "name": "conda-build", + "sha256": "750ed3042a0532e2ecde77c9400722be3c8fceb95b0061bb4f7014976172b228", + "size": 441911, + "subdir": "linux-64", + "timestamp": 1532477204233, + "version": "3.12.0" + }, + "conda-build-3.12.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "20ba5fdf43da5626aa5baf99bc16167b", + "name": "conda-build", + "sha256": "c67c1d41811d1f9ffad51689a1d2300cc91bf0815cab47fcf40ab6fa7df8889d", + "size": 446478, + "subdir": "linux-64", + "timestamp": 1532477257075, + "version": "3.12.0" + }, + "conda-build-3.12.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1b7f96df4a6c3b3ad8cb0c61601ceb13", + "name": "conda-build", + "sha256": "a812443ab7db5e3fdfd8ee628f3d48f5f4a7d096f4fd8f9ecb1c009120bb9488", + "size": 445709, + "subdir": "linux-64", + "timestamp": 1532477257894, + "version": "3.12.0" + }, + "conda-build-3.12.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8945d495dd34226b66404f84d17cf8e5", + "name": "conda-build", + "sha256": "ee468bd3389bcd2aa60feb768d1f7e19a4dd288bc53e4c61eafebc9a50e20f49", + "size": 444735, + "subdir": "linux-64", + "timestamp": 1532477266496, + "version": "3.12.0" + }, + "conda-build-3.12.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4076f0299fc554268a51918bdd9ee8ac", + "name": "conda-build", + "sha256": "0f24166a7779416c22f551fd477c54c2804bae4856f87d53cac2b5ea38c061a8", + "size": 442367, + "subdir": "linux-64", + "timestamp": 1533582542454, + "version": "3.12.1" + }, + "conda-build-3.12.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "305195f8dac44efa9968221a0a1286a0", + "name": "conda-build", + "sha256": "ad64d6cfa2bcc45aad76b0b80bd2f943580c8adbd1d8689da2ef5e401def3913", + "size": 446856, + "subdir": "linux-64", + "timestamp": 1533582573378, + "version": "3.12.1" + }, + "conda-build-3.12.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8039edf7027e9e2bb35dc705dc1e848f", + "name": "conda-build", + "sha256": "74e600eeb7b39b4422da294832d954bf8ad1323c7599e3485d6f8622fcb44b8e", + "size": 446095, + "subdir": "linux-64", + "timestamp": 1533582516741, + "version": "3.12.1" + }, + "conda-build-3.12.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d1ae190f166bfd59a66fb8005817827b", + "name": "conda-build", + "sha256": "e49d8800c0cbd1ed681d6d97324ee3dc0e7c871f186da36f30b1698019967408", + "size": 445245, + "subdir": "linux-64", + "timestamp": 1533582575039, + "version": "3.12.1" + }, + "conda-build-3.13.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9d53197f6153b6687fbd05e25587973a", + "name": "conda-build", + "sha256": "1bf78d131ec72131869b817d3048cf52cd3140f8d6690968263a62fb6c9f37b6", + "size": 442964, + "subdir": "linux-64", + "timestamp": 1534804626457, + "version": "3.13.0" + }, + "conda-build-3.13.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e34b7223c621fe5ca0e3883972c6354b", + "name": "conda-build", + "sha256": "d77423f91a0b09ac8934f326d975f0607db270f4b74ace9de9f4902e78442c0c", + "size": 448241, + "subdir": "linux-64", + "timestamp": 1534804699903, + "version": "3.13.0" + }, + "conda-build-3.13.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d5ebff77107a5d6794706f106a5f3ac2", + "name": "conda-build", + "sha256": "b00cf1cbbc987cd58b417095b3be4e036a5cdf21288edc297b15f1ed35fa77ef", + "size": 446727, + "subdir": "linux-64", + "timestamp": 1534804576717, + "version": "3.13.0" + }, + "conda-build-3.13.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d71fc1d981b5c64aeee0a578f2c52e38", + "name": "conda-build", + "sha256": "2fbffe26e7c79ec12ed2a2b809401fc8cd39a84359282d5461c5074a0bed092f", + "size": 446351, + "subdir": "linux-64", + "timestamp": 1534804703569, + "version": "3.13.0" + }, + "conda-build-3.14.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6bb128a896ac6e3b756218d8ac8f0b06", + "name": "conda-build", + "sha256": "4030626e415b996483adcc3edf2f1a05e2d1af41226b513e3522b2decbe48d2a", + "size": 458224, + "subdir": "linux-64", + "timestamp": 1536106586343, + "version": "3.14.0" + }, + "conda-build-3.14.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pytz", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "52010f5f9f4437d6d645c39a5f109706", + "name": "conda-build", + "sha256": "4128b5fc1adf2b7181877ad7e95e0769e9a339c674c178c6d3ee130f4dfb608d", + "size": 463569, + "subdir": "linux-64", + "timestamp": 1536106606734, + "version": "3.14.0" + }, + "conda-build-3.14.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a95a859688df046aa4b011a91dd0b172", + "name": "conda-build", + "sha256": "b92adffae6bfddcb9da30d6c7202af17e2433d0790aceffc4bd80c035e019df6", + "size": 461618, + "subdir": "linux-64", + "timestamp": 1536106562091, + "version": "3.14.0" + }, + "conda-build-3.14.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7253dc61e83bf486cbe57e37ea2bdff6", + "name": "conda-build", + "sha256": "3a013855d78035eec4fc27c6fde2a205182381070deaae2b9173434a8b27dfe4", + "size": 461881, + "subdir": "linux-64", + "timestamp": 1536106615424, + "version": "3.14.0" + }, + "conda-build-3.14.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "602a8fd07ea20c020cfcfb9dab947a4b", + "name": "conda-build", + "sha256": "8218061fbfb380519482bba433246c0bcca9ccea21238cab70a7abd10945603f", + "size": 458798, + "subdir": "linux-64", + "timestamp": 1536257498627, + "version": "3.14.1" + }, + "conda-build-3.14.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pytz", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "edae02176a64c3bbd150fe123b77b416", + "name": "conda-build", + "sha256": "7861afa474c0dae888744b36b833564f07749f42290b261d22a4367351cb4d12", + "size": 463622, + "subdir": "linux-64", + "timestamp": 1536257521282, + "version": "3.14.1" + }, + "conda-build-3.14.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "49f764eb084a4afe62c3cd798ce760cf", + "name": "conda-build", + "sha256": "6f05f88595ad0925c31b3e9b04524fb144c221d68208702882ab4240dcec26d5", + "size": 462420, + "subdir": "linux-64", + "timestamp": 1536257477848, + "version": "3.14.1" + }, + "conda-build-3.14.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "83838e576940df651813760f3ad9710f", + "name": "conda-build", + "sha256": "5e14009ae9f8004e6bab1e6412d1b89d971939f9332759bebc9199c72f6b58ae", + "size": 461565, + "subdir": "linux-64", + "timestamp": 1536257559170, + "version": "3.14.1" + }, + "conda-build-3.14.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c3bea79822c6c43377b1a6479b64fda7", + "name": "conda-build", + "sha256": "e75f7028f6c719a3b2fe01b436b5fad5f574977f652b663407e95803546c9579", + "size": 471718, + "subdir": "linux-64", + "timestamp": 1536358405292, + "version": "3.14.2" + }, + "conda-build-3.14.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pytz", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b7b417317bfe2f9b8813ab6744a558e1", + "name": "conda-build", + "sha256": "82dae88d3930dbcf0fa7ba0ff3a5a3e2e658280d5629f893e78102674fdce95e", + "size": 474284, + "subdir": "linux-64", + "timestamp": 1536358407107, + "version": "3.14.2" + }, + "conda-build-3.14.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aed312624ffffeadb0df1332b8acb38d", + "name": "conda-build", + "sha256": "40001c7e7baa9d6e00e66ffc346dac093872014d945c6b60e134a6d5265d4ca7", + "size": 473916, + "subdir": "linux-64", + "timestamp": 1536358446931, + "version": "3.14.2" + }, + "conda-build-3.14.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7fc19bf743bc5c696545187499cd08fb", + "name": "conda-build", + "sha256": "711000d5a1ee3f92a3d983506f07732de6745d65a83cdb28081c78689a047fa9", + "size": 472280, + "subdir": "linux-64", + "timestamp": 1536358365791, + "version": "3.14.2" + }, + "conda-build-3.14.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8d28b2aec708952274a82a7754c8ad34", + "name": "conda-build", + "sha256": "822ed9b413d0521e1590f0764c8bdc8d846c04d8d4dea140e7e46071aa938c45", + "size": 460937, + "subdir": "linux-64", + "timestamp": 1536688067330, + "version": "3.14.4" + }, + "conda-build-3.14.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4d0e60fa1e43e6bc0b1be84f0881a2ca", + "name": "conda-build", + "sha256": "4842106de2c3076fcbc1baddc14352257cb530145938c7e8d69a7dad307c351a", + "size": 464877, + "subdir": "linux-64", + "timestamp": 1536688097982, + "version": "3.14.4" + }, + "conda-build-3.14.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "66138b57350aed0351bb6ce7a1e79572", + "name": "conda-build", + "sha256": "eed54b48b51f1b6c97cc48f97d0809056af436ea707acb3d9e6c3b89b7799228", + "size": 463572, + "subdir": "linux-64", + "timestamp": 1536688087562, + "version": "3.14.4" + }, + "conda-build-3.14.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8ce78a52921d7e520a90524c70e89b33", + "name": "conda-build", + "sha256": "78784f8542273e0d4fb1ca55bc8e3422abeda847232d9020d60c051b7c33a08c", + "size": 462612, + "subdir": "linux-64", + "timestamp": 1536688047809, + "version": "3.14.4" + }, + "conda-build-3.15.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3cf71925ada5a8328a6c8fb4f82b67f0", + "name": "conda-build", + "sha256": "632e067a5e0480c72418eff63bb5b0e58e815c4044314251403396ef7739a37a", + "size": 468589, + "subdir": "linux-64", + "timestamp": 1537238077061, + "version": "3.15.0" + }, + "conda-build-3.15.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d82ba2fa320f6104388f1b4bae56e01a", + "name": "conda-build", + "sha256": "bf26683fc0ee1a41274e69ebd6745247e92bf96da2c65f65a508b1157b3953d4", + "size": 469326, + "subdir": "linux-64", + "timestamp": 1537238094065, + "version": "3.15.0" + }, + "conda-build-3.15.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "657f5d438c3355b313b974f137701c7d", + "name": "conda-build", + "sha256": "7037b5282e572df22680b4322d3ba15f19b59cd3f9986db2ef5313f287507a9f", + "size": 468153, + "subdir": "linux-64", + "timestamp": 1537238102038, + "version": "3.15.0" + }, + "conda-build-3.15.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3e306e4fead917496cbc9a2d611d9057", + "name": "conda-build", + "sha256": "233cf4bc32036aa77b6c852b92e9717596d02a31335d798959570422dd91c1d9", + "size": 467617, + "subdir": "linux-64", + "timestamp": 1537238063621, + "version": "3.15.0" + }, + "conda-build-3.15.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5a758286daf2457767b7dfc1c42bd524", + "name": "conda-build", + "sha256": "e05d5104d8be46a777f97d7691ab31fa9f3831899943a4791270abf40fcff62d", + "size": 472421, + "subdir": "linux-64", + "timestamp": 1537289922402, + "version": "3.15.1" + }, + "conda-build-3.15.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "30a8a3ff64e420be690794ffb6852a3a", + "name": "conda-build", + "sha256": "0117a069a1ae03c4b84a04939d0c84c3310514bc7624174c254db13215a046be", + "size": 472454, + "subdir": "linux-64", + "timestamp": 1537289946616, + "version": "3.15.1" + }, + "conda-build-3.15.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "20dacfbf12ddb15d9683791c6844e7b5", + "name": "conda-build", + "sha256": "32e1583b86acbc67953c7bf151c1ad0363c46de7e567263a78af24683398b568", + "size": 470472, + "subdir": "linux-64", + "timestamp": 1537289950076, + "version": "3.15.1" + }, + "conda-build-3.15.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "35e00e6a966c4e8c9059ebfb62f1b569", + "name": "conda-build", + "sha256": "02a64defd1695a8e9c71a63e69407871fc04e1a83eaa79f7686f6fb2bf15753c", + "size": 469675, + "subdir": "linux-64", + "timestamp": 1537289907866, + "version": "3.15.1" + }, + "conda-build-3.16.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e5edfaa968d93212ad164191e7f0c208", + "name": "conda-build", + "sha256": "e5c0e5380b8997652c785c4459dc23c61eb67e7cccfd8daab8fff47365037458", + "size": 481874, + "subdir": "linux-64", + "timestamp": 1538760246080, + "version": "3.16.0" + }, + "conda-build-3.16.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fcc5b27881ab5e4fcce63eeeac2e8a12", + "name": "conda-build", + "sha256": "359b7d099b8274747a15280f6b4d010503bbb4d4cc66c642ddacf6cddda17926", + "size": 479812, + "subdir": "linux-64", + "timestamp": 1538760328287, + "version": "3.16.0" + }, + "conda-build-3.16.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "61a29f8204048fbf4d93112ae567d1b6", + "name": "conda-build", + "sha256": "fc9cc0c633a00e89a1a752a2e37d2be1b2e5ceb96b3b0e3235e97912f3f898de", + "size": 478162, + "subdir": "linux-64", + "timestamp": 1538760386964, + "version": "3.16.0" + }, + "conda-build-3.16.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "50f346aa0ce962ea358a2c0a9c378ee9", + "name": "conda-build", + "sha256": "96ab430c0fdf0883ff53cf4ce7bec889c937303577b7f61eb692350975e8847f", + "size": 489474, + "subdir": "linux-64", + "timestamp": 1539369908715, + "version": "3.16.1" + }, + "conda-build-3.16.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4486a1d671d6ea994608ac6d20aa5a3d", + "name": "conda-build", + "sha256": "6cbb1b2a8ca29758a0a84cfe13c09543d6c4f80242e84e704aaab7ab4dc8f2d0", + "size": 484104, + "subdir": "linux-64", + "timestamp": 1539369581775, + "version": "3.16.1" + }, + "conda-build-3.16.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eec258c078e0b4eb172d7522dfab7ab4", + "name": "conda-build", + "sha256": "68f101f10640ed62eda3e692a4edc7cb21e898130e5f6f32fcd4c296c4e968aa", + "size": 485895, + "subdir": "linux-64", + "timestamp": 1539369913621, + "version": "3.16.1" + }, + "conda-build-3.16.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "96e1ab9b78b74747444b2e9d0ea8497c", + "name": "conda-build", + "sha256": "181cc56fe6b4354fcdacfc8199273999a3d7761ed24cd79d5b8904b80f2350cb", + "size": 492044, + "subdir": "linux-64", + "timestamp": 1540853947173, + "version": "3.16.2" + }, + "conda-build-3.16.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8e26d5d33d1e582398b582556c57eb22", + "name": "conda-build", + "sha256": "bb01c167cb44d19a7bf857cc7bbf64606306635a04936ba845449f66ad52936a", + "size": 486339, + "subdir": "linux-64", + "timestamp": 1540854021139, + "version": "3.16.2" + }, + "conda-build-3.16.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f4d5c3adb50eef75c4c198c08339988d", + "name": "conda-build", + "sha256": "9a4649eab7f4b307139fb9689fc07638244a4326c64ee8d6ba3ffc7a5cc7d2e9", + "size": 486205, + "subdir": "linux-64", + "timestamp": 1540853961580, + "version": "3.16.2" + }, + "conda-build-3.16.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "24f8f584552c1af0ba54cc3d2823d3a5", + "name": "conda-build", + "sha256": "dd054d156e118c7c3c5c83f606bffcbcd183e03f99c94b620cc96cb6272edff3", + "size": 487203, + "subdir": "linux-64", + "timestamp": 1542851057581, + "version": "3.16.3" + }, + "conda-build-3.16.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ae20996b98372235021bf4fa1fb24e63", + "name": "conda-build", + "sha256": "87826badce0d7b36d1ac2b573b1a5802b91038d90e0321027383ae41678b96b3", + "size": 487490, + "subdir": "linux-64", + "timestamp": 1542851073148, + "version": "3.16.3" + }, + "conda-build-3.16.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1239f9d375dadd0e5b446ac2ee8cb53c", + "name": "conda-build", + "sha256": "b2c9bcceb29bf9af1c6dddc0f0a9e96fffb315449c1159a6ea27f2006706a87c", + "size": 488542, + "subdir": "linux-64", + "timestamp": 1542851021169, + "version": "3.16.3" + }, + "conda-build-3.17.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d9863e48923cece71a6577484120d4b9", + "name": "conda-build", + "sha256": "c0d7911d27f32b6119774f67d50fecec22a9f10d8aa6bf52710b0a302c1d672b", + "size": 514126, + "subdir": "linux-64", + "timestamp": 1543629277104, + "version": "3.17.0" + }, + "conda-build-3.17.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1ab6c478cf32d839fc863653a7f92df0", + "name": "conda-build", + "sha256": "f53dccabfafed72d479c56f9ba23daf4246af01f62e49ea90400ea38db0db309", + "size": 509374, + "subdir": "linux-64", + "timestamp": 1543629335893, + "version": "3.17.0" + }, + "conda-build-3.17.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "06e3bbaac9754a71825d1dd98af9c1b6", + "name": "conda-build", + "sha256": "da79c81eab4daee445c6bf8759c39b991ead248e8f02254518542c2aebe3ee90", + "size": 510553, + "subdir": "linux-64", + "timestamp": 1543629259179, + "version": "3.17.0" + }, + "conda-build-3.17.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "985790da4cd349164dee468b19c24d88", + "name": "conda-build", + "sha256": "652e6dd489568a335028704083cc8dfa139b513ddff3b94864fac17bf9d11f1d", + "size": 515403, + "subdir": "linux-64", + "timestamp": 1543944593997, + "version": "3.17.1" + }, + "conda-build-3.17.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6aec6b1eeb4412d138b4acf31516b805", + "name": "conda-build", + "sha256": "e96ad1fefa803ec7f3e0239784a50a251881f4fcba8555c90f35f74756ff36c7", + "size": 512592, + "subdir": "linux-64", + "timestamp": 1543944637695, + "version": "3.17.1" + }, + "conda-build-3.17.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c6f011be4a902459b5485de3736cbfd9", + "name": "conda-build", + "sha256": "25f2be92c2790cbcc9357f6235e97606e289b6ad28085bc21abe6ed185631fbf", + "size": 512291, + "subdir": "linux-64", + "timestamp": 1543944601943, + "version": "3.17.1" + }, + "conda-build-3.17.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "03cc11d7ae02edccfbd4763f68f9ff31", + "name": "conda-build", + "sha256": "326ef2121b2fe4d7c9a22cda51dfa4422cce30809a415837030e10ac937bdd6e", + "size": 520413, + "subdir": "linux-64", + "timestamp": 1544565187156, + "version": "3.17.3" + }, + "conda-build-3.17.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a65e9d454b81431102addda7fcc97d29", + "name": "conda-build", + "sha256": "fa79a75a4faec57bf3314db15685edacdbd728a50df6d8ae4b6a42623c16c3d2", + "size": 510667, + "subdir": "linux-64", + "timestamp": 1544565222774, + "version": "3.17.3" + }, + "conda-build-3.17.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4d184626f5b29e66f26a1c7f1fcf8c9c", + "name": "conda-build", + "sha256": "0c500884b1dc3f424fb33a92f9fa9b7c8b3386520ed5a38215d252c32127ce1f", + "size": 509313, + "subdir": "linux-64", + "timestamp": 1544565150647, + "version": "3.17.3" + }, + "conda-build-3.17.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "88e108c20d99267f3ae1d364b9c1709a", + "name": "conda-build", + "sha256": "2d81944e3bedd7bf1968aa2f31e9f247ce1318296cf79e839f62532f63aa7846", + "size": 515602, + "subdir": "linux-64", + "timestamp": 1544668356577, + "version": "3.17.4" + }, + "conda-build-3.17.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4b624a120c743418cf49ee2acc02a828", + "name": "conda-build", + "sha256": "7eb15303769661b79d0e269b895b7297e6a73ec03c349094dd172c931d9bc8c6", + "size": 517998, + "subdir": "linux-64", + "timestamp": 1544668401888, + "version": "3.17.4" + }, + "conda-build-3.17.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "831608d12091b20350265d6128ceaff6", + "name": "conda-build", + "sha256": "9dfd1e002f7f2cd1aaa2b62eaf6abaec89bfbabe523807efe15b445a9f913a01", + "size": 519648, + "subdir": "linux-64", + "timestamp": 1544668354314, + "version": "3.17.4" + }, + "conda-build-3.17.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f1ab35f467920394058e1e888e3fad4b", + "name": "conda-build", + "sha256": "d3b5c686a3fc218086ddff9ea96870076176a9d72090ac10419ecdaabc82000b", + "size": 519565, + "subdir": "linux-64", + "timestamp": 1544807607455, + "version": "3.17.5" + }, + "conda-build-3.17.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4bbcead5f0593f14bebbddd75c564e16", + "name": "conda-build", + "sha256": "0db1ee7ec85309fa7d5a5d2191d8c1577bfe74e32e6ecc2daf40dedce1186a1c", + "size": 512119, + "subdir": "linux-64", + "timestamp": 1544807667128, + "version": "3.17.5" + }, + "conda-build-3.17.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7eedb5cb94f9b94a6f95c6c49679b41d", + "name": "conda-build", + "sha256": "e23b2f6fc6849d07740b2bc4ec168c506ccf45826a663599521745afcffdfddd", + "size": 517223, + "subdir": "linux-64", + "timestamp": 1544807607966, + "version": "3.17.5" + }, + "conda-build-3.17.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "58cdfa589747120098dea16125add9f8", + "name": "conda-build", + "sha256": "2e7f601863b38c668857c8144fd4dc7fd9e25ea9dd6d2d81fb54666e9fe458bc", + "size": 515666, + "subdir": "linux-64", + "timestamp": 1545270081220, + "version": "3.17.6" + }, + "conda-build-3.17.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7cf59c17b574b351de4f1c2285638f71", + "name": "conda-build", + "sha256": "04c714b5f7e001fe1a3cc807b47774bd6003d406b6342f8333dfa426ac5ab476", + "size": 521499, + "subdir": "linux-64", + "timestamp": 1545270104521, + "version": "3.17.6" + }, + "conda-build-3.17.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f91d7e96555d832d11b8c19be5ec62f1", + "name": "conda-build", + "sha256": "421b46c3b01c6d4a3c3a5af614e123c1c4a0bdcac68c97545ab1f866f8134948", + "size": 519931, + "subdir": "linux-64", + "timestamp": 1545270107473, + "version": "3.17.6" + }, + "conda-build-3.17.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9b36f39783206c49372e6a2d8f0af4c4", + "name": "conda-build", + "sha256": "b8bbe25b443e0a3e93aea44de76e25e11a915edb250cb33dd1a8efb14bbc65c9", + "size": 524278, + "subdir": "linux-64", + "timestamp": 1547669070129, + "version": "3.17.7" + }, + "conda-build-3.17.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bf40273f1e29dca99dfb651af4c3725a", + "name": "conda-build", + "sha256": "b4a30433dfe25229d9a26508053ff61c2ad8c097458b42e64522a168ca2ef18e", + "size": 521001, + "subdir": "linux-64", + "timestamp": 1547669145254, + "version": "3.17.7" + }, + "conda-build-3.17.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9762c2d860aea8f4114bc6e7d3b3022b", + "name": "conda-build", + "sha256": "973444f2d108cfb45601c713a0e39df8845f5dca8aec4db56ad3cb985ba1b36a", + "size": 514440, + "subdir": "linux-64", + "timestamp": 1547669138831, + "version": "3.17.7" + }, + "conda-build-3.17.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3fafd241408e130c9459fd6aaef2d0ca", + "name": "conda-build", + "sha256": "b35cc1796c778c5510b07d5cd8c5787becb3c0ac5446ca608ce082754e938f6e", + "size": 524792, + "subdir": "linux-64", + "timestamp": 1548701011604, + "version": "3.17.8" + }, + "conda-build-3.17.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "51e8d4fcfc192f043423b6cf548897fe", + "name": "conda-build", + "sha256": "4d4699d8aab320f0b60c50bc22c47a071fa39e8ec5ad2166e65437bbbb96e947", + "size": 515759, + "subdir": "linux-64", + "timestamp": 1548700999636, + "version": "3.17.8" + }, + "conda-build-3.17.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a804c9f93b789e157fba0aca42388685", + "name": "conda-build", + "sha256": "99b8bf25b4460a2d51e1789389d4c2e4649535b8874f67e71fa105aa40bf0db4", + "size": 517562, + "subdir": "linux-64", + "timestamp": 1548701025033, + "version": "3.17.8" + }, + "conda-build-3.18.10-py27_3.tar.bz2": { + "build": "py27_3", + "build_number": 3, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "ripgrep", + "scandir", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "903a7ef558419d02416c282270df0850", + "name": "conda-build", + "sha256": "fb02770cd385346166deb43eef48783f8f697f49b74565d792dc6fa166261ea0", + "size": 553337, + "subdir": "linux-64", + "timestamp": 1571074614243, + "version": "3.18.10" + }, + "conda-build-3.18.10-py36_3.tar.bz2": { + "build": "py36_3", + "build_number": 3, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e52e61986b6276d96fed4d020763d0cd", + "name": "conda-build", + "sha256": "d88ac03cf004f25f57088d7ce6f314532482bda6b714e3a4f9b67fc0a69ac5e3", + "size": 547265, + "subdir": "linux-64", + "timestamp": 1571074612524, + "version": "3.18.10" + }, + "conda-build-3.18.10-py37_3.tar.bz2": { + "build": "py37_3", + "build_number": 3, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "57abbbcff373aaef2b2c3530caddd07c", + "name": "conda-build", + "sha256": "7d9a98f63b377bdf96cc8875e2f811677cf5085d2683d9a84217129a959e651b", + "size": 546977, + "subdir": "linux-64", + "timestamp": 1571074612052, + "version": "3.18.10" + }, + "conda-build-3.18.11-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "scandir", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "08469d591bd7ffd2855abd40621997f8", + "name": "conda-build", + "sha256": "f688cb169efeb015cc4e8fad4b7426f6682effe740cc6c6951bbf950ba58edbc", + "size": 548347, + "subdir": "linux-64", + "timestamp": 1573068085155, + "version": "3.18.11" + }, + "conda-build-3.18.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5e42ddfedf035f4f5184ce49823532a5", + "name": "conda-build", + "sha256": "d9a11f0d8c65bafd8c7d860aa16e3e1ed64f993a891c6451092cf55533e3fb1a", + "size": 553903, + "subdir": "linux-64", + "timestamp": 1573068101962, + "version": "3.18.11" + }, + "conda-build-3.18.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dd905117fd83985c2c67719c021f7729", + "name": "conda-build", + "sha256": "564119cd0ae13a26e3e055a374118914371b007737c27222712e31319b0681b8", + "size": 538251, + "subdir": "linux-64", + "timestamp": 1573068218878, + "version": "3.18.11" + }, + "conda-build-3.18.11-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "30bfed8845fbda1ecbe54a0ef7047ede", + "name": "conda-build", + "sha256": "061eafe85641a019a0ba8c7abbe7152ce376e7fab96dccc4376b03e44a2836ce", + "size": 543668, + "subdir": "linux-64", + "timestamp": 1589919229680, + "version": "3.18.11" + }, + "conda-build-3.18.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9ed7841c6d2a3044e3b98382e9e4c397", + "name": "conda-build", + "sha256": "038b2839e7b17f2b2d3a22bc9f7a8ec211f554f838ca185ed0c168701f892ab5", + "size": 535965, + "subdir": "linux-64", + "timestamp": 1561496296183, + "version": "3.18.5" + }, + "conda-build-3.18.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fb2ffbab6415e8c176af87bc4d557dc1", + "name": "conda-build", + "sha256": "a6d8d2eb18fba26ae70b6c67e0d8d7e90888d6e5eb697108f8cacb872c306b1c", + "size": 540053, + "subdir": "linux-64", + "timestamp": 1561496330680, + "version": "3.18.5" + }, + "conda-build-3.18.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "80aa67c044fab856bda62235c8ac5427", + "name": "conda-build", + "sha256": "6c759b3b8ee91ba121374f5af2a474204270a604eed05fe0f8dc13351e69b3c3", + "size": 529274, + "subdir": "linux-64", + "timestamp": 1561496288540, + "version": "3.18.5" + }, + "conda-build-3.18.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "48516ed6fde152bda6a4b965e904150e", + "name": "conda-build", + "sha256": "f20bd8b605a1887cf17c90a4095ea413f3bfdaba0c9e69475a055dc2e6e069d2", + "size": 534241, + "subdir": "linux-64", + "timestamp": 1562725154461, + "version": "3.18.7" + }, + "conda-build-3.18.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "39aaa63fd0eb315e1850cb375996edc1", + "name": "conda-build", + "sha256": "8a7d12eda9afd5929f5150845a9bbdbbdca3f92dc3ab9ca8edaa86a73578fb0f", + "size": 533839, + "subdir": "linux-64", + "timestamp": 1562725229304, + "version": "3.18.7" + }, + "conda-build-3.18.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "74832da6fc32b768ae2aeadc0a761725", + "name": "conda-build", + "sha256": "e06f4d6dd28222e1d8f7d06cb145a6a508344adbe5743a7c173603ad7f41f26a", + "size": 534817, + "subdir": "linux-64", + "timestamp": 1562725177360, + "version": "3.18.7" + }, + "conda-build-3.18.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9e99a8682c1f7bdd9dce7e5aeadd7e63", + "name": "conda-build", + "sha256": "33423a5694eecf3a9c4a3ed0cfc683ae8da4f6b88168a51ad646e7f1a2907fa2", + "size": 543754, + "subdir": "linux-64", + "timestamp": 1563464967674, + "version": "3.18.8" + }, + "conda-build-3.18.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "24fe1242a3d4cf0388b14058b2adc73f", + "name": "conda-build", + "sha256": "55fac9d14a5133fdb6bfe5ee63406fef5c674fede93d199d1b67194356c34e16", + "size": 542682, + "subdir": "linux-64", + "timestamp": 1563464983366, + "version": "3.18.8" + }, + "conda-build-3.18.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ec0192c77b49dcc9269d081e3788392e", + "name": "conda-build", + "sha256": "143cd645fa61940aec534858b2c8c29171921b8fd1c9225f29935338818a2fdc", + "size": 525450, + "subdir": "linux-64", + "timestamp": 1563464946994, + "version": "3.18.8" + }, + "conda-build-3.18.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "472bc45e2cfd9c3c8bfad4e9206d0532", + "name": "conda-build", + "sha256": "cbdb77b8f24cd925d28420606a681cd45ba4c6e09cf565047ca35e247c1731d7", + "size": 542375, + "subdir": "linux-64", + "timestamp": 1563905264317, + "version": "3.18.9" + }, + "conda-build-3.18.9-py27_3.tar.bz2": { + "build": "py27_3", + "build_number": 3, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "ripgrep", + "scandir", + "setuptools", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5bbb56ca06450a24439ccc7a2feadf91", + "name": "conda-build", + "sha256": "f021d327d75b81c908e3e403f5a2da485c9b178f18032a453068302bcf75327c", + "size": 545804, + "subdir": "linux-64", + "timestamp": 1565627455082, + "version": "3.18.9" + }, + "conda-build-3.18.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2a1282725047631497c578f2db8072c9", + "name": "conda-build", + "sha256": "c6afe500753c9a4c0783643c254461b304a7354605d22fe690b753f815c3e99e", + "size": 539086, + "subdir": "linux-64", + "timestamp": 1563905270069, + "version": "3.18.9" + }, + "conda-build-3.18.9-py36_3.tar.bz2": { + "build": "py36_3", + "build_number": 3, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "ripgrep", + "setuptools", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fc89affdbaa39f64359d79bc82606894", + "name": "conda-build", + "sha256": "c3356f1038c74f41cc4de60d92404730b553fccf705e62cbf60544c26cb43def", + "size": 539723, + "subdir": "linux-64", + "timestamp": 1565627494711, + "version": "3.18.9" + }, + "conda-build-3.18.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cc327f02c6727eb2ca626c652d651748", + "name": "conda-build", + "sha256": "cf211c4ac6c4523f1777d1691b04b0ea7d2a49d26f54070f84ed2ae1b90d3a9d", + "size": 533905, + "subdir": "linux-64", + "timestamp": 1563905257648, + "version": "3.18.9" + }, + "conda-build-3.18.9-py37_3.tar.bz2": { + "build": "py37_3", + "build_number": 3, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "ripgrep", + "setuptools", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "434abe0081c7597854edeee36ac88571", + "name": "conda-build", + "sha256": "1f442071b3ed12c86ecb59a255c048996769aef0266b3dd6462594a3290a1e36", + "size": 532552, + "subdir": "linux-64", + "timestamp": 1565627330606, + "version": "3.18.9" + }, + "conda-build-3.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1b2f20cc883ecc69df0a50f59ba177cf", + "name": "conda-build", + "sha256": "a044cf27b945f8adabbd74062941622b71e0a811552351fc86f88bbddf686014", + "size": 405556, + "subdir": "linux-64", + "timestamp": 1513870014011, + "version": "3.2.0" + }, + "conda-build-3.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8001a0a9910954f632824199a83bc14d", + "name": "conda-build", + "sha256": "3eee5879276d963b9bfd34427ad2200a94a9b0f926d1a1bd00d74bad877b14d1", + "size": 410811, + "subdir": "linux-64", + "timestamp": 1513870039352, + "version": "3.2.0" + }, + "conda-build-3.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a3e98d345edc6af367e73ad0ab62de70", + "name": "conda-build", + "sha256": "7259cad591f7429740891356107534507970f2304e85b969bcbb93058ebbdb39", + "size": 408559, + "subdir": "linux-64", + "timestamp": 1513870055417, + "version": "3.2.0" + }, + "conda-build-3.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d3a287ecd2e7c5ca442b799afd02ff61", + "name": "conda-build", + "sha256": "132612afbe898e1f357ef236207f5f5e32e6de7d30f25186543800a5d1beabf2", + "size": 406141, + "subdir": "linux-64", + "timestamp": 1514949252983, + "version": "3.2.1" + }, + "conda-build-3.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "92bf3f596a6d444b68917d3747a1b10c", + "name": "conda-build", + "sha256": "da0c833e6613baff3228824690a57d12ba03a09c83c05fe992e8f29c46d60590", + "size": 412336, + "subdir": "linux-64", + "timestamp": 1514949274781, + "version": "3.2.1" + }, + "conda-build-3.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "58f9c4f4d0a4f1e4e8891d4ed0cebc2d", + "name": "conda-build", + "sha256": "77df9af1670f40874653202abd5f5f669eb23a5f99379dc3ab8a8ca9ad5a4577", + "size": 409837, + "subdir": "linux-64", + "timestamp": 1514949274841, + "version": "3.2.1" + }, + "conda-build-3.2.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "254bff5419cf53dfd115a62653049f98", + "name": "conda-build", + "sha256": "f6b9161783d3b6347bb457dc17649eacf6d864989ac1755953bcadec83c8d92d", + "size": 407352, + "subdir": "linux-64", + "timestamp": 1515794424462, + "version": "3.2.2" + }, + "conda-build-3.2.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cf156d61a1a0b72d4ee194d4c22a1f03", + "name": "conda-build", + "sha256": "a72f45df64af8e064180b8bcbd2700655e453f7cf51ae9f6be94b763330e88a5", + "size": 412579, + "subdir": "linux-64", + "timestamp": 1515794153928, + "version": "3.2.2" + }, + "conda-build-3.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "49841fe48b4bd63b09706ec61cf37c4d", + "name": "conda-build", + "sha256": "7c80dbc79dd2704797147c4b41e329d328119d602bbdb73ade07428c82d7c3ba", + "size": 410082, + "subdir": "linux-64", + "timestamp": 1515794146574, + "version": "3.2.2" + }, + "conda-build-3.20.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "21301667f038af4c25f97f93be93c92f", + "name": "conda-build", + "sha256": "b279e02b88564c26539deee73d309b9d7e620abce4c42eee42ce08cf6c79c0d9", + "size": 579111, + "subdir": "linux-64", + "timestamp": 1598592525986, + "version": "3.20.0" + }, + "conda-build-3.20.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9f1c3cadf9455644d5973d0b437680b5", + "name": "conda-build", + "sha256": "6bc6b781088e08352004550baf0b7279292675bad66461214ebaa7ddd60e8f95", + "size": 579848, + "subdir": "linux-64", + "timestamp": 1598592514962, + "version": "3.20.0" + }, + "conda-build-3.20.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "360cb908e6ad5f0183da891d4a5e97b2", + "name": "conda-build", + "sha256": "573145569620c844cb34ed7512439a0a8cdabf394f4bea29085279c069ca7f18", + "size": 583679, + "subdir": "linux-64", + "timestamp": 1598592504123, + "version": "3.20.0" + }, + "conda-build-3.20.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e1cca6da81c4043e48f966469c84ce01", + "name": "conda-build", + "sha256": "112f5160db05dcf8933ad01156f46865da2a54275ee076005d5d854c7457bdad", + "size": 585590, + "subdir": "linux-64", + "timestamp": 1599174383796, + "version": "3.20.1" + }, + "conda-build-3.20.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "128e9431536325e1e6ce641154c5fb8f", + "name": "conda-build", + "sha256": "27c386fd09268d7e38f2b4cf3a53876b604a9829d98df76ac0f44132d4fe02a0", + "size": 583165, + "subdir": "linux-64", + "timestamp": 1599174389388, + "version": "3.20.1" + }, + "conda-build-3.20.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b71ec1fcc3430a18add1f67cb3c65e6e", + "name": "conda-build", + "sha256": "7fe18c100a27d35a7b16b8ed2e5adfbacc4379115de27d5ff17dbbc9fbe0c06d", + "size": 577313, + "subdir": "linux-64", + "timestamp": 1599174406015, + "version": "3.20.1" + }, + "conda-build-3.20.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "90d1225ed857e200d957e58c59613e8f", + "name": "conda-build", + "sha256": "e92ff6cc1c703115c185680ef04dae80046b46aa9a250e42f61a2394e4a35934", + "size": 585727, + "subdir": "linux-64", + "timestamp": 1599595110075, + "version": "3.20.2" + }, + "conda-build-3.20.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f7a87c1d545822d584cc0338c2dbf240", + "name": "conda-build", + "sha256": "4238e21a294e00b6e577d152d05d9bb67f4e025f694915657a1bd803fbde26a8", + "size": 577502, + "subdir": "linux-64", + "timestamp": 1599595079435, + "version": "3.20.2" + }, + "conda-build-3.20.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "938bc63c56f84be9c440f688f63eed4e", + "name": "conda-build", + "sha256": "27a56e0f635a72234d69aa5dc3375015e84664c9f3f5eecc90e6c3e24389a850", + "size": 573505, + "subdir": "linux-64", + "timestamp": 1599595093445, + "version": "3.20.2" + }, + "conda-build-3.20.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c9701f5816b6411c0833743a4528e857", + "name": "conda-build", + "sha256": "52e0b83c51d339a472d88676b66884c6658e67b35403f2dcffb01644effa4db5", + "size": 595679, + "subdir": "linux-64", + "timestamp": 1601412150785, + "version": "3.20.3" + }, + "conda-build-3.20.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3ca9f881f557636e9e91db6463e7a5f4", + "name": "conda-build", + "sha256": "e63d43bb26735f7c2e73728f8d9981f28372a30199d999f4c6b7903665409d65", + "size": 587370, + "subdir": "linux-64", + "timestamp": 1601412189909, + "version": "3.20.3" + }, + "conda-build-3.20.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aa2d4ecaa6550730f1738fbbc5ed306d", + "name": "conda-build", + "sha256": "357a47cda2923458fb9ee4c6b6a77f6b7c2aef3ac6d7a8d3c5425089087f9203", + "size": 595731, + "subdir": "linux-64", + "timestamp": 1601412172118, + "version": "3.20.3" + }, + "conda-build-3.20.4-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "edf9b723c0b842a1fa733b8d0f5db39a", + "name": "conda-build", + "sha256": "1493dfe137933641e2407920a46cdeb79b6f10809b2953e177b2634b4a81947a", + "size": 589965, + "subdir": "linux-64", + "timestamp": 1603213675342, + "version": "3.20.4" + }, + "conda-build-3.20.4-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ec23f9d4e49d085837bb27a509cf094b", + "name": "conda-build", + "sha256": "b4e139b90b679a5541d06b6c9638753e72c4f5861ea24915607ae1c44a5d693b", + "size": 589550, + "subdir": "linux-64", + "timestamp": 1603213666616, + "version": "3.20.4" + }, + "conda-build-3.20.4-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3c5589298587902ebc06652f03f29191", + "name": "conda-build", + "sha256": "9d4be4d9fdcac49b618cdc2d098a3dba226b59ae8d582fa4b0b32f7e16308eed", + "size": 584497, + "subdir": "linux-64", + "timestamp": 1603213700075, + "version": "3.20.4" + }, + "conda-build-3.20.4-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "14c1c21862def89947197207393b1c2c", + "name": "conda-build", + "sha256": "da08ccec05b748ea7e320f0aeb7f24401ec57b77b88054afab39acaed3ca4925", + "size": 592015, + "subdir": "linux-64", + "timestamp": 1607404895886, + "version": "3.20.4" + }, + "conda-build-3.20.5-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "40b213fd19989bac111b60ade5ff98c6", + "name": "conda-build", + "sha256": "5bcbfd1999e4d90633290221272be4f8f688896019fb2cd7a47ad66632b16830", + "size": 582827, + "subdir": "linux-64", + "timestamp": 1603728004542, + "version": "3.20.5" + }, + "conda-build-3.20.5-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a277943b62edfc97c527fe1b0f631ba9", + "name": "conda-build", + "sha256": "b3859049b7b0be47a58dc326d5dd47e145883ddf476f88c61c9be2286581974c", + "size": 595522, + "subdir": "linux-64", + "timestamp": 1603728241269, + "version": "3.20.5" + }, + "conda-build-3.20.5-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "592c4fda460087c681158f37341263dd", + "name": "conda-build", + "sha256": "034034760386db901a5230ff477b4e24fa3ce809e6de886e5f8a7f261b76d13b", + "size": 593430, + "subdir": "linux-64", + "timestamp": 1603727977150, + "version": "3.20.5" + }, + "conda-build-3.20.5-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "82e50c3e997a82be6a3d17da103025bd", + "name": "conda-build", + "sha256": "ccb46f6f2a11e4f70bcfa29bcfcd76671c18d40152afec27857b3e1d17349fd1", + "size": 584802, + "subdir": "linux-64", + "timestamp": 1608506024386, + "version": "3.20.5" + }, + "conda-build-3.21.0-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "edc24b48eb6ab0bc40f5f557fc3c2657", + "name": "conda-build", + "sha256": "0ceb0562cf8c8df1b75127c7e290d4b4705b7b5717b5308d1efd5659445535f5", + "size": 595311, + "subdir": "linux-64", + "timestamp": 1610313608099, + "version": "3.21.0" + }, + "conda-build-3.21.0-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1b9a08109454bf64eabbba3845e871eb", + "name": "conda-build", + "sha256": "62ad136bbdf412e8166355273fffce0eafa6d36c01c80075cc343c754e1e3375", + "size": 588368, + "subdir": "linux-64", + "timestamp": 1610313609166, + "version": "3.21.0" + }, + "conda-build-3.21.0-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2d263bed0aec5a08df9a527dfd7c3238", + "name": "conda-build", + "sha256": "bbde4ac7a185c4073acba92ccc6aa11b58547720bb85c3e6b5140f5cd82701db", + "size": 583374, + "subdir": "linux-64", + "timestamp": 1610313586942, + "version": "3.21.0" + }, + "conda-build-3.21.0-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0f0b623105f04cfc24c0606195b9e7fa", + "name": "conda-build", + "sha256": "5b1a62edb4fefafa80be29fd5c487f84432a1330164153d0c8f140361dd2fa3f", + "size": 598151, + "subdir": "linux-64", + "timestamp": 1610313588601, + "version": "3.21.0" + }, + "conda-build-3.21.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "95438576eaaceed9bbd606d0bfddf5b0", + "name": "conda-build", + "sha256": "caaee861b111e9b98876ee8011d6dbb35156696105d411527d8329aa6807478e", + "size": 586421, + "subdir": "linux-64", + "timestamp": 1610372909384, + "version": "3.21.1" + }, + "conda-build-3.21.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d713780887da1b5eb208bcc1d95267b4", + "name": "conda-build", + "sha256": "363ebca1df02d822b4f87a3ccfab8fab27d7bf0481dd3a143ede13a2a0966f04", + "size": 596685, + "subdir": "linux-64", + "timestamp": 1610372509461, + "version": "3.21.1" + }, + "conda-build-3.21.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "03b0f732c6032d2dcf59e4a0e128c788", + "name": "conda-build", + "sha256": "84f2711c973a25dbb9cb2b61aa3bab45dafefe6e1f0d42e94ee352c8000f9459", + "size": 599546, + "subdir": "linux-64", + "timestamp": 1610372937794, + "version": "3.21.1" + }, + "conda-build-3.21.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0bb3b6368824c1ee81adfa74a76db1a4", + "name": "conda-build", + "sha256": "2ec08d1889b2077384a25029407330cbc7517a023cb6bd98e717ea37ca075f7c", + "size": 599767, + "subdir": "linux-64", + "timestamp": 1610372946406, + "version": "3.21.1" + }, + "conda-build-3.21.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "887b90c39d304a88a9d99554a31df4a5", + "name": "conda-build", + "sha256": "55ccce528ad0ec61020bd9986053fee2d16445638a299b67af5bb5d328d3f5d4", + "size": 582826, + "subdir": "linux-64", + "timestamp": 1610396924914, + "version": "3.21.3" + }, + "conda-build-3.21.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b1dcaf6e855c458063fe696fe03f3696", + "name": "conda-build", + "sha256": "458cc9fde9eeb2ca1a3c3b3be2761428718da8fb441f124042a934f98727a5fb", + "size": 594856, + "subdir": "linux-64", + "timestamp": 1610396926411, + "version": "3.21.3" + }, + "conda-build-3.21.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dad763112db8209ce487557ee9008052", + "name": "conda-build", + "sha256": "920fa7776523e15b604295705caac78f5e16053dd98fb0f03f61e4cd7c36cd18", + "size": 587575, + "subdir": "linux-64", + "timestamp": 1610396924805, + "version": "3.21.3" + }, + "conda-build-3.21.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1f255f862b94da0a54d3c605e99d20f1", + "name": "conda-build", + "sha256": "bae3b90193b03a8c31110e9352bcd455a780301e886e964e0cf410558fc4e61c", + "size": 594493, + "subdir": "linux-64", + "timestamp": 1610396919661, + "version": "3.21.3" + }, + "conda-build-3.21.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0abc582de1201b3f6534f905e065a715", + "name": "conda-build", + "sha256": "414efd4fb21c905cdf115ef73b0b877a15581ec5cd961aa1651a91c65e7e12cb", + "size": 584817, + "subdir": "linux-64", + "timestamp": 1610705903614, + "version": "3.21.4" + }, + "conda-build-3.21.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0e730dd0ccf00bd0da6ff3898e2fb3e2", + "name": "conda-build", + "sha256": "339f26b58a3afacd651a57d92ed6e9e3637be23c578d480fe47fb0d60e27353f", + "size": 591765, + "subdir": "linux-64", + "timestamp": 1610706477633, + "version": "3.21.4" + }, + "conda-build-3.21.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "01d6e7c8813a07e5b315fcc8a47eb5a4", + "name": "conda-build", + "sha256": "6c442a3d36344ff1ae9562c29cace51d722ef51610db75458d287d5690d11dae", + "size": 590193, + "subdir": "linux-64", + "timestamp": 1610706477346, + "version": "3.21.4" + }, + "conda-build-3.21.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7917df3dd93c769b1a46f8bb31ce72c4", + "name": "conda-build", + "sha256": "78e01e198e5421628a0428c0768fb7393b665839682129931f6492b2e94ee05c", + "size": 598832, + "subdir": "linux-64", + "timestamp": 1610706501872, + "version": "3.21.4" + }, + "conda-build-3.21.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b63f206be80aa94205202bd0580667f2", + "name": "conda-build", + "sha256": "f83fefe9c92c4b744c67e2b24244264f90c0451af193e8590d295bf572b6b7f9", + "size": 573726, + "subdir": "linux-64", + "timestamp": 1641552066265, + "version": "3.21.5" + }, + "conda-build-3.21.5-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3c4ea4e0579bfdd2877e889f2e18b1fd", + "name": "conda-build", + "sha256": "e29a6bc3a3d714cace1f2fb3ebafe337ad6e8b4e8ad9856914c945e74142fd41", + "size": 590347, + "subdir": "linux-64", + "timestamp": 1630349073840, + "version": "3.21.5" + }, + "conda-build-3.21.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "beef51c53b2ddfbb0f90f58f4f96f78b", + "name": "conda-build", + "sha256": "13bb836f24dc1fa08f8619d5d29649d2698794beb08807171fda49e30c27c4e5", + "size": 591123, + "subdir": "linux-64", + "timestamp": 1630349056749, + "version": "3.21.5" + }, + "conda-build-3.21.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9a6dde83e00eca2075e77d60f6b311fe", + "name": "conda-build", + "sha256": "a6dfcaa585f22d74dc963e1443c82e7c18ef949ba9c3285c4ba5f187e061b2a9", + "size": 598506, + "subdir": "linux-64", + "timestamp": 1630349054134, + "version": "3.21.5" + }, + "conda-build-3.21.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "62603b156bd6c4009b3aeeaea476f341", + "name": "conda-build", + "sha256": "635673b4485466135b5dd9cbc732137f2d0ad4c7e863bd743b2b7ca155e8e362", + "size": 592728, + "subdir": "linux-64", + "timestamp": 1630348855613, + "version": "3.21.5" + }, + "conda-build-3.21.6-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dbc1385bb792c701c362c4884ff047eb", + "name": "conda-build", + "sha256": "0e6ab9d5a84be2181d15f90771ef90e41df845a63db9edce2994a6cd99c3421e", + "size": 573519, + "subdir": "linux-64", + "timestamp": 1636555500049, + "version": "3.21.6" + }, + "conda-build-3.21.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "92c6714e79181377f64c0eeb5772aa51", + "name": "conda-build", + "sha256": "fa8b21e53515c105f3262fbf6390604f56110dd5e49d2a7a09bf42bb42ead3c9", + "size": 575639, + "subdir": "linux-64", + "timestamp": 1636555463052, + "version": "3.21.6" + }, + "conda-build-3.21.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "60cb0526e69cd86cd7d99a5a66e5037d", + "name": "conda-build", + "sha256": "293aaece805b96d1e6e3accc0d9b6306000aac6860eb7de686b5b3a05894dfb9", + "size": 575544, + "subdir": "linux-64", + "timestamp": 1636555535640, + "version": "3.21.6" + }, + "conda-build-3.21.7-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb906f4cb94688050506435b4eed397d", + "name": "conda-build", + "sha256": "e528ef3c1cae657cfeb4e7f8f27659992a29b15b4bc114f457f1de6a3125a90e", + "size": 571933, + "subdir": "linux-64", + "timestamp": 1638465792107, + "version": "3.21.7" + }, + "conda-build-3.21.7-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d4b5360cbee7de377ddd7165c82940b4", + "name": "conda-build", + "sha256": "5fcde8ef3489afb7a743032b9fc23556967cb4d251806aa08d101b9a86f3543e", + "size": 574303, + "subdir": "linux-64", + "timestamp": 1638465757142, + "version": "3.21.7" + }, + "conda-build-3.21.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ae76beb16f235f0a30ffae6d5cf91eef", + "name": "conda-build", + "sha256": "5be67da19dfe68180d0d6f9864f2dcc718e5168126ceeaa26d860010065d4575", + "size": 574960, + "subdir": "linux-64", + "timestamp": 1638465827520, + "version": "3.21.7" + }, + "conda-build-3.21.8-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b8666d1b096c674f5cb36df44f395ad9", + "name": "conda-build", + "sha256": "20fdade43ebf55c820282c8453c0786c8b14dbdb9eb003274a31f59c668104a1", + "size": 603708, + "subdir": "linux-64", + "timestamp": 1648588119319, + "version": "3.21.8" + }, + "conda-build-3.21.8-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c0451bc225cd8c1988c48f2f0933c4cd", + "name": "conda-build", + "sha256": "78fde0fe086ce3193794c90bece939a1087a475b8f529d330f60f299ae12379a", + "size": 576867, + "subdir": "linux-64", + "timestamp": 1647017307727, + "version": "3.21.8" + }, + "conda-build-3.21.8-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8e735eaeae57c6b06b9ddd5d816de4c6", + "name": "conda-build", + "sha256": "ffd37eb331e7a0963abc41a7882ab9277bcc83963763074b5e1b1a40592e7150", + "size": 599665, + "subdir": "linux-64", + "timestamp": 1648588106608, + "version": "3.21.8" + }, + "conda-build-3.21.8-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0add4bfb9712fffac25a17a21e10bcb9", + "name": "conda-build", + "sha256": "16273faba738eaa8c905c5a7704690b1d412aea89ac208347b9b14a0851e56bf", + "size": 578444, + "subdir": "linux-64", + "timestamp": 1647017156610, + "version": "3.21.8" + }, + "conda-build-3.21.8-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1d0180cf9728f9ec1e62b938307f659b", + "name": "conda-build", + "sha256": "a705c96e8d9ee27261e3d17483ebd0d7db07b70cf50869bc24b5ffcaeef6ba59", + "size": 592042, + "subdir": "linux-64", + "timestamp": 1648588107293, + "version": "3.21.8" + }, + "conda-build-3.21.8-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f29c4326340d7bb159b47b3c7d5dbed0", + "name": "conda-build", + "sha256": "e58e8d5b3c488753996ac5bb2b650deb4bd20bd2c34f9ac2bf51adc85b76ee48", + "size": 579765, + "subdir": "linux-64", + "timestamp": 1647017236719, + "version": "3.21.8" + }, + "conda-build-3.21.8-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c056a22cf5aec0b9d8273b5f59785942", + "name": "conda-build", + "sha256": "e011cc9f2e350bbf412e2555a0ebe75a95416450ea3f51e104e0b5727419c338", + "size": 601489, + "subdir": "linux-64", + "timestamp": 1648569978663, + "version": "3.21.8" + }, + "conda-build-3.21.9-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b4d7ada333bbf9b5c4bfcc9aa8f025de", + "name": "conda-build", + "sha256": "ce97e82cdb1d0bacae07d035085db03cdd34413b2c27dd3f8a1e5a2ed829238e", + "size": 587610, + "subdir": "linux-64", + "timestamp": 1654011569390, + "version": "3.21.9" + }, + "conda-build-3.21.9-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "30f26e8db51d671fe2f101d39fc50379", + "name": "conda-build", + "sha256": "4863268c99215c3524ab7af1bcb124e4e31fcfeea1cf6bb6fed6da14bf8bd152", + "size": 579965, + "subdir": "linux-64", + "timestamp": 1654011522330, + "version": "3.21.9" + }, + "conda-build-3.21.9-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ba38ff6084f0f2a58591c9e3ceef0f07", + "name": "conda-build", + "sha256": "8cf37c2739f6edb040683cce8fc75f50b6a22b9a3f45cfa695f9fc77d3716122", + "size": 580290, + "subdir": "linux-64", + "timestamp": 1654011485803, + "version": "3.21.9" + }, + "conda-build-3.21.9-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bedc913e960b6d6e21bcdc9ff6c7f995", + "name": "conda-build", + "sha256": "5fcbf3a46c2f6986f7e16374944ebbae85df60d58b89653820388a494f127912", + "size": 582634, + "subdir": "linux-64", + "timestamp": 1654011446762, + "version": "3.21.9" + }, + "conda-build-3.22.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7cdf4bc4dcd1bd1aa351fd452c6b0607", + "name": "conda-build", + "sha256": "5b1c427ec6c69dd34448364c02c38013bcddab1c6e210bc780c2b06a05a72581", + "size": 583371, + "subdir": "linux-64", + "timestamp": 1661284142646, + "version": "3.22.0" + }, + "conda-build-3.22.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e902880a51f99a188492a347f5f69ec4", + "name": "conda-build", + "sha256": "21d25b1dfe9040039b297808a4b0156637bc904a0df240cf4269106631295383", + "size": 574997, + "subdir": "linux-64", + "timestamp": 1661284262470, + "version": "3.22.0" + }, + "conda-build-3.22.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4dd4945249799e66de2dde38ce8e5bad", + "name": "conda-build", + "sha256": "5dd4f48b7ae7d4d766dc4ac3b7882cf1ca3128a8a97b2316ab5a9a1e59bde36d", + "size": 577676, + "subdir": "linux-64", + "timestamp": 1661284181519, + "version": "3.22.0" + }, + "conda-build-3.22.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7dd2f1fcaec2a440d9a53b059bcade03", + "name": "conda-build", + "sha256": "ebecfdc442d683955faed410fa4da4aeca8f0576bbafdc4cd900a87295781c50", + "size": 578371, + "subdir": "linux-64", + "timestamp": 1661284222590, + "version": "3.22.0" + }, + "conda-build-3.23.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f732fd03a1443f727b6a19e68564e85", + "name": "conda-build", + "sha256": "a44c1cb4b6f44222b691398cf99fa2b5a8931d19a0fd635d1509ef9d5ab67ae8", + "size": 589407, + "subdir": "linux-64", + "timestamp": 1668696010303, + "version": "3.23.0" + }, + "conda-build-3.23.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d99613120614174a79817f7f0280096e", + "name": "conda-build", + "sha256": "f9357be435152a5a0ecc8587bd1696f396a1e0254b11b7567c80af58ea54f4b9", + "size": 584224, + "subdir": "linux-64", + "timestamp": 1668702291125, + "version": "3.23.0" + }, + "conda-build-3.23.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "13f4d2e443197437e6258455e3749cd5", + "name": "conda-build", + "sha256": "93d1b1ea538fd5e0a32651c69e0d77b85131dd834622fcac68aa1f4f3b9102a9", + "size": 579807, + "subdir": "linux-64", + "timestamp": 1668695969311, + "version": "3.23.0" + }, + "conda-build-3.23.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "af5d4411a7894e164c83a14823952b19", + "name": "conda-build", + "sha256": "39a79130d2ab46eb8d01717e424d318840705df00a6e5a88b753894fa9ab43d3", + "size": 576293, + "subdir": "linux-64", + "timestamp": 1668702252328, + "version": "3.23.0" + }, + "conda-build-3.23.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "35c36cf55ee5d1c580e73f0f0de56720", + "name": "conda-build", + "sha256": "d071bd43c3b54c633b51ec15d275663c5b99feed514bc5a6f892ffa1ab068eaf", + "size": 582850, + "subdir": "linux-64", + "timestamp": 1668696050861, + "version": "3.23.0" + }, + "conda-build-3.23.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6d73ec91fc5df77610dfe80aea07325c", + "name": "conda-build", + "sha256": "85a47417e44bd8178d84d4a98d9f199b427e3e9b44c2352fc99656dddecc7098", + "size": 577946, + "subdir": "linux-64", + "timestamp": 1668702366535, + "version": "3.23.0" + }, + "conda-build-3.23.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3b71c599f833d9bc318f015ffb85e1a1", + "name": "conda-build", + "sha256": "0a4843a796560b0a2f4e05ef74b48e112920435e78ba0d2111872b9ead331774", + "size": 584053, + "subdir": "linux-64", + "timestamp": 1668696089790, + "version": "3.23.0" + }, + "conda-build-3.23.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b6dd9244e06c8c3fa475e62eb5ec368a", + "name": "conda-build", + "sha256": "eb1a9821149ea38eb557dc5953c1d25ba532568ea609d4740c7113afbdc98baf", + "size": 579204, + "subdir": "linux-64", + "timestamp": 1668702329235, + "version": "3.23.0" + }, + "conda-build-3.23.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c403d898ea6045c374f05409d935cc78", + "name": "conda-build", + "sha256": "bad98720138111ba5caedf1ebf9470a5e1990cef5dd46b7c5987a4b8615ddf42", + "size": 588807, + "subdir": "linux-64", + "timestamp": 1668781369259, + "version": "3.23.1" + }, + "conda-build-3.23.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e93b69d2983e6bd67f9ccd95dd439ec8", + "name": "conda-build", + "sha256": "a838b39c18d58fd890f658d6af9de3b863e4891a3846f665254577a9b9579257", + "size": 580580, + "subdir": "linux-64", + "timestamp": 1668781409571, + "version": "3.23.1" + }, + "conda-build-3.23.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "97a615faa937378ed2e3e56c1ef50de6", + "name": "conda-build", + "sha256": "7994308987534f8d302d40f1ec7b6d2d528f0944402fc7bc2902ed58f21b50a8", + "size": 581529, + "subdir": "linux-64", + "timestamp": 1668781449390, + "version": "3.23.1" + }, + "conda-build-3.23.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d922fd437acff19fb59da36d2d5600fe", + "name": "conda-build", + "sha256": "bfe10356e9620243bcbc791b4c4c91eca82085225d6ed74a75bb0bcebdcfa723", + "size": 583585, + "subdir": "linux-64", + "timestamp": 1668781328292, + "version": "3.23.1" + }, + "conda-build-3.23.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c77171f5916dd6af4d401e96aa9f0573", + "name": "conda-build", + "sha256": "d4278cf8b24ab37a45aad39b52638143a4e2109d7f781bbee64d6f8de49ad179", + "size": 588671, + "subdir": "linux-64", + "timestamp": 1669899795673, + "version": "3.23.2" + }, + "conda-build-3.23.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ec0b74f429fdf5a010abef38aa2ce674", + "name": "conda-build", + "sha256": "a2dda9c6922c1c06f8a9bc13f6e1626769641364d9e48755a59ec63680d52728", + "size": 580894, + "subdir": "linux-64", + "timestamp": 1669899759589, + "version": "3.23.2" + }, + "conda-build-3.23.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d26202a465e46d5ed363f9dc8e99f17", + "name": "conda-build", + "sha256": "d1289feda63eefc0dd0e7be8356eabe3b1e1c278535f65c2c07cf3b61d6c68de", + "size": 582966, + "subdir": "linux-64", + "timestamp": 1669899723005, + "version": "3.23.2" + }, + "conda-build-3.23.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "51bcb84a2e61423db7338d6ca2bf63d3", + "name": "conda-build", + "sha256": "755acab665676625e136ea8c7c0cf1f11399e0985d1a1e64fc1082692825cb6f", + "size": 584112, + "subdir": "linux-64", + "timestamp": 1669899687838, + "version": "3.23.2" + }, + "conda-build-3.23.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "77ecf5d0f63c327788a3ebdff54b0cae", + "name": "conda-build", + "sha256": "409c913acf504aa5ebe1340512f7ff036010497fd2e7e652dff3543422c6c7bf", + "size": 581073, + "subdir": "linux-64", + "timestamp": 1670407408424, + "version": "3.23.3" + }, + "conda-build-3.23.3-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.11,<3.12.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c7b8a161a5fb598eee6677da54df0db7", + "name": "conda-build", + "sha256": "d4272b5db44a6cc0168faf4ae82c884c15c0b220cf704d811826d1ecb06a49a9", + "size": 799356, + "subdir": "linux-64", + "timestamp": 1676843642890, + "version": "3.23.3" + }, + "conda-build-3.23.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b6fc8af552ee4c5ceae9182bd7bac61b", + "name": "conda-build", + "sha256": "db6742866359686022e90f776a9541ee9b85fce2986e96ca72f9424d94012858", + "size": 571747, + "subdir": "linux-64", + "timestamp": 1670407443666, + "version": "3.23.3" + }, + "conda-build-3.23.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "12b5d4803b95ab665d74ded78f6b3580", + "name": "conda-build", + "sha256": "37bcf82d8af7d70791a09c32271018c20563030dc9a4d764f448d74f4f890691", + "size": 576101, + "subdir": "linux-64", + "timestamp": 1670407479275, + "version": "3.23.3" + }, + "conda-build-3.23.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "405ab87afab0d7ac3b9916b250ab77b2", + "name": "conda-build", + "sha256": "76f90888fd8340094b38df6fb1026ceb695aea832b6e1927d7e963ce3938fcd8", + "size": 575872, + "subdir": "linux-64", + "timestamp": 1670407374247, + "version": "3.23.3" + }, + "conda-build-3.24.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "packaging", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "six", + "tomli", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9e2d2b65cd13ce5867067c705ad0fe2b", + "name": "conda-build", + "sha256": "be62128c447c1bbf9090920c50614b27cd6770a6d24e2efcb62c49076d8068c9", + "size": 586653, + "subdir": "linux-64", + "timestamp": 1679586285493, + "version": "3.24.0" + }, + "conda-build-3.24.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "packaging", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.11,<3.12.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1594c3433128111e23f4f4427b3ce15e", + "name": "conda-build", + "sha256": "9ac98b28cf65e34cfaae80699b5e84aa572b591c9573d63367afc60e377fedc5", + "size": 802077, + "subdir": "linux-64", + "timestamp": 1679586242679, + "version": "3.24.0" + }, + "conda-build-3.24.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "packaging", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "six", + "tomli", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ad5f205308f263291d24720098fce738", + "name": "conda-build", + "sha256": "89f14ad96cf71646f5e91230acf2c4ecfe6b255f5e9ca586155bfa0646e3c360", + "size": 580218, + "subdir": "linux-64", + "timestamp": 1679586329035, + "version": "3.24.0" + }, + "conda-build-3.24.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "packaging", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "six", + "tomli", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e7d350e2f0c5adfbc75c1de85d682e6", + "name": "conda-build", + "sha256": "662c0f00c4ddbf77eee1973dd30a3112cb19a6b376323d4ac0cb1b37afd5bb87", + "size": 581444, + "subdir": "linux-64", + "timestamp": 1679586370919, + "version": "3.24.0" + }, + "conda-build-3.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7b11434b28a1d362e7edc8a271abb6e6", + "name": "conda-build", + "sha256": "66c8f7ef2f99254fda3faa797f12e19f9727d8d2fffbbb7ab3b8e57d1b98f26c", + "size": 414914, + "subdir": "linux-64", + "timestamp": 1516747442586, + "version": "3.3.0" + }, + "conda-build-3.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7149fdb8eb830d73d0cb3966d9b7f797", + "name": "conda-build", + "sha256": "dab364da8e94c04b2a9e535056620525ef63f461228feba86aecc517722e242a", + "size": 419777, + "subdir": "linux-64", + "timestamp": 1516747468072, + "version": "3.3.0" + }, + "conda-build-3.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "14f4a48f3a075e8540995110f8edc410", + "name": "conda-build", + "sha256": "f7147d5bc0e63abcfc7c3aa9a68047576b364461d66bda0c76852f2fe5bf9a30", + "size": 416164, + "subdir": "linux-64", + "timestamp": 1516747462460, + "version": "3.3.0" + }, + "conda-build-3.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9cfa5f5cbc3d221526ebf7fa63580120", + "name": "conda-build", + "sha256": "651322679da693b1d27e82326f8272861706d416034e70f92325685d100371dc", + "size": 417066, + "subdir": "linux-64", + "timestamp": 1517457129035, + "version": "3.4.0" + }, + "conda-build-3.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ca905cc57ad8741d7b36ceb25a3bb917", + "name": "conda-build", + "sha256": "ad85708b8ad2f228d26dd9fd6a0159540fc0736293989cec1da85f95dff3ceb4", + "size": 421556, + "subdir": "linux-64", + "timestamp": 1517457193650, + "version": "3.4.0" + }, + "conda-build-3.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eb535b7ce5733ea678872ba2f1b80c04", + "name": "conda-build", + "sha256": "9236e829cb1c9a025f76b2deaead4358961f50d8f4d0caa7b69c0918cfe2ac20", + "size": 419902, + "subdir": "linux-64", + "timestamp": 1517457185574, + "version": "3.4.0" + }, + "conda-build-3.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "db07b7af8d75f9cf64708326cad24c99", + "name": "conda-build", + "sha256": "d488305ea0c0cf479a6924b1133be7d306ea5c306517eefc5846b1b4f10fe10a", + "size": 416840, + "subdir": "linux-64", + "timestamp": 1518118480816, + "version": "3.4.1" + }, + "conda-build-3.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dacf74a404b4e3d6971a8af13f9311a9", + "name": "conda-build", + "sha256": "994e3881766a9b9676a0b247a58411214cfb207a7b279ccbd66da48689a4ca18", + "size": 421621, + "subdir": "linux-64", + "timestamp": 1518118500756, + "version": "3.4.1" + }, + "conda-build-3.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a4bcf4f40b3621b7ae86605dc257d4a7", + "name": "conda-build", + "sha256": "2e66a8cba36c17612b6e63be77731a9c06a44c3ee51021e2326fb0870dfea1b2", + "size": 419880, + "subdir": "linux-64", + "timestamp": 1518118508683, + "version": "3.4.1" + }, + "conda-build-3.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "188f43d875c8eb71bd6e64497cb2327d", + "name": "conda-build", + "sha256": "be8f11abf24620cf32fe508bbaa7c83e2e3a25256050c6fe178899f908f4c468", + "size": 418156, + "subdir": "linux-64", + "timestamp": 1518724300284, + "version": "3.4.2" + }, + "conda-build-3.4.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0d198e0ec2c5b9b24558ef1dba8cca53", + "name": "conda-build", + "sha256": "c289cca83a1919d5171e2782470330e60ab4335e10b401ab82d86a5934f183ce", + "size": 422707, + "subdir": "linux-64", + "timestamp": 1518724562944, + "version": "3.4.2" + }, + "conda-build-3.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f5b0b7d5830f8ea14a25c016ceedd9cd", + "name": "conda-build", + "sha256": "d3812f506f0abc877fb801fab9fd614da39afb171b57ce51930d96849dbfb6e3", + "size": 420326, + "subdir": "linux-64", + "timestamp": 1518724365184, + "version": "3.4.2" + }, + "conda-build-3.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4bf79cf2b875898fa97c8179493647fb", + "name": "conda-build", + "sha256": "ad046bffca127b7832dfe0e920458da59a0c78cb33ea6eb7ba76558183aa1659", + "size": 423065, + "subdir": "linux-64", + "timestamp": 1519160839848, + "version": "3.5.0" + }, + "conda-build-3.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7fd53f248bebf059ce9f6610212e8da4", + "name": "conda-build", + "sha256": "98ee4f28e9a07cedd2e9124edd2b72b094c470683a9a23fba23c424d420322bc", + "size": 427990, + "subdir": "linux-64", + "timestamp": 1519160862393, + "version": "3.5.0" + }, + "conda-build-3.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b86a099253020f66db8bcd53422e5eaf", + "name": "conda-build", + "sha256": "dd349c4f3ecd9ad747642573dce2b14669c36c6d3dc9a4d059ca1bcf449675f7", + "size": 425497, + "subdir": "linux-64", + "timestamp": 1519160839399, + "version": "3.5.0" + }, + "conda-build-3.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6308a90e823b2f35e70bac4030e00725", + "name": "conda-build", + "sha256": "2426fefdeed4e96ef5146d19569609c0f268f2629d57b52c4eb9da0a62944d7a", + "size": 425087, + "subdir": "linux-64", + "timestamp": 1519330131261, + "version": "3.5.1" + }, + "conda-build-3.5.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4951f4e63cc8ee097a2679758cd703d7", + "name": "conda-build", + "sha256": "fb4233dc64ba85cd7f01365ae93c5f8419fbfcfb0530bee91df04a39e754d963", + "size": 427771, + "subdir": "linux-64", + "timestamp": 1519330182078, + "version": "3.5.1" + }, + "conda-build-3.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f41d874b70597e5dcddabe4b66e04599", + "name": "conda-build", + "sha256": "e1a2a0728dc663c418e2d7bb7b213b80b385923193fde31b8aab5143c993831a", + "size": 425771, + "subdir": "linux-64", + "timestamp": 1519330118248, + "version": "3.5.1" + }, + "conda-build-3.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0ad896a228d6f875623b39eaedc4724b", + "name": "conda-build", + "sha256": "af0a2973ec2eb16b91b984490b91cc2263481c02bc6c421dd5293601d478f38d", + "size": 427529, + "subdir": "linux-64", + "timestamp": 1519858554742, + "version": "3.6.0" + }, + "conda-build-3.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "adbe6661bb39e7135da8ae7c9cddc9aa", + "name": "conda-build", + "sha256": "9787842146ab3e7231d1611af4574415eae926084785b4782cf3b4a1075d9215", + "size": 433948, + "subdir": "linux-64", + "timestamp": 1519858578301, + "version": "3.6.0" + }, + "conda-build-3.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "48834753c6e6aad956931c2e1b5a3003", + "name": "conda-build", + "sha256": "1c39641607a590200c884a46b43b3b3516ed908f69ef37cf42f54f795fcd108f", + "size": 431880, + "subdir": "linux-64", + "timestamp": 1519858499587, + "version": "3.6.0" + }, + "conda-build-3.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b3ed077b2357e000549b8fbdcbbfc1fa", + "name": "conda-build", + "sha256": "ef3045bb9e3d77d44d9c589386f0b9208e297f3be0f8a4ab49f1dfe891a3f0bb", + "size": 431152, + "subdir": "linux-64", + "timestamp": 1520262267195, + "version": "3.7.0" + }, + "conda-build-3.7.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ca2db32733430f6ce11713806c0c3db1", + "name": "conda-build", + "sha256": "c131a9ef887aa73175a92d423ea8ba1623552ab4ddf21712ee026d0455bdca8e", + "size": 434845, + "subdir": "linux-64", + "timestamp": 1520262308903, + "version": "3.7.0" + }, + "conda-build-3.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "36ba8aa9ea41aa8228f189a08e6ea176", + "name": "conda-build", + "sha256": "bc3a4e41d447ed68842a6cc68b76caad52fff29ee450dea6df82107979f17589", + "size": 432787, + "subdir": "linux-64", + "timestamp": 1520262275898, + "version": "3.7.0" + }, + "conda-build-3.7.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "88b61eb81c644d0918268bd816509d1b", + "name": "conda-build", + "sha256": "7ce4b7990012264b021d5ed65cf2bf66e0480caeb02f281c9a4ddb93221b80bb", + "size": 431040, + "subdir": "linux-64", + "timestamp": 1520545334753, + "version": "3.7.1" + }, + "conda-build-3.7.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "28c1b528b4f5e914584263e98decb8b0", + "name": "conda-build", + "sha256": "d99f2d798ed102446d00613c593b836e74cd62281a10456bd99fa77d92397691", + "size": 435200, + "subdir": "linux-64", + "timestamp": 1520545350462, + "version": "3.7.1" + }, + "conda-build-3.7.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d479ddf87098ac5d39c8b0c2035802c7", + "name": "conda-build", + "sha256": "a63dc18dad0aa21ceb5322c6cb550974371b7dfd1e9685fbc6cf28c81ff970c2", + "size": 433407, + "subdir": "linux-64", + "timestamp": 1520545306318, + "version": "3.7.1" + }, + "conda-build-3.7.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "732a68be6a3c1be67496f33650280dd4", + "name": "conda-build", + "sha256": "350f04141aaf7436d4ebfd782bc89fd4976aa9eeb620fdc76cfa5d1b777babac", + "size": 431798, + "subdir": "linux-64", + "timestamp": 1521746261220, + "version": "3.7.2" + }, + "conda-build-3.7.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dc404e2baae3d6051bfb6c346916e8f4", + "name": "conda-build", + "sha256": "c11bc703f922c08beaa9a4284647e3813d6d287912f7c574f6c502643b5e87f3", + "size": 435810, + "subdir": "linux-64", + "timestamp": 1521746273744, + "version": "3.7.2" + }, + "conda-build-3.7.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "91ce88d06090b7abddd4e6094bb93ebe", + "name": "conda-build", + "sha256": "5345606885e239fe09f585283f71ee0dc455047f64842cdb4f4e529686309c8d", + "size": 433989, + "subdir": "linux-64", + "timestamp": 1521746294883, + "version": "3.7.2" + }, + "conda-build-3.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "56d0733ffa946c827997c0719c7806d2", + "name": "conda-build", + "sha256": "76f2c2bb2811343f9503e5c4c6bbbf1872ab924dd89a312b62c88d0c05da3d6a", + "size": 433741, + "subdir": "linux-64", + "timestamp": 1522428282452, + "version": "3.8.0" + }, + "conda-build-3.8.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d19e29a0f89a0076b56de2e1a6cb8e73", + "name": "conda-build", + "sha256": "b6a1eed814b6ee3528fa0d1d1528e778174f256605862d65e5ba331da7f30b8f", + "size": 436574, + "subdir": "linux-64", + "timestamp": 1522428334170, + "version": "3.8.0" + }, + "conda-build-3.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "71e86a20d9cd88b220a8df2c695a4361", + "name": "conda-build", + "sha256": "b8b2f8541653097bdd415ad43fa73019970052db227be6a060b8ca075678e89c", + "size": 435313, + "subdir": "linux-64", + "timestamp": 1522428293746, + "version": "3.8.0" + }, + "conda-build-3.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fba69037ebfd3590f1338fa4d735dd1f", + "name": "conda-build", + "sha256": "80615cc1471c26dc25089ccaa59abee4c4c3ea720a615328c492368fcc51057f", + "size": 433571, + "subdir": "linux-64", + "timestamp": 1523895532250, + "version": "3.8.1" + }, + "conda-build-3.8.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a907c6ac044aa3fbca526c23b3085dc2", + "name": "conda-build", + "sha256": "bd895791919e905c646f14fae585f9b1f540c17d0f63b3ed11126deabdb72a40", + "size": 439053, + "subdir": "linux-64", + "timestamp": 1523895582703, + "version": "3.8.1" + }, + "conda-build-3.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bca2ed58de42d6ccebc7acfe8d6d3ca5", + "name": "conda-build", + "sha256": "0d440cf162dadd66ea87714084fe4c69901c63527cf3206d68321c533e48535e", + "size": 435732, + "subdir": "linux-64", + "timestamp": 1523895568873, + "version": "3.8.1" + }, + "conda-build-3.9.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3b02dec02d86616b745c16defb31cabe", + "name": "conda-build", + "sha256": "fa83c9bbd12d3d74452337af776344863dc96b0e5a466e87fdd7823f66ad4072", + "size": 437042, + "subdir": "linux-64", + "timestamp": 1524621216211, + "version": "3.9.1" + }, + "conda-build-3.9.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f780be4401c5735309687a449f3a8f94", + "name": "conda-build", + "sha256": "d09be7722578364f585d7511edf520efaea653919a3d6c12ee63cec97f97a820", + "size": 440383, + "subdir": "linux-64", + "timestamp": 1524621254961, + "version": "3.9.1" + }, + "conda-build-3.9.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f5683950bcc6f2115a4f8dd40bfead11", + "name": "conda-build", + "sha256": "b9c415ff2a203341e73ad9fe1356c99ab79136981f5b729ca2626d7e5b610e36", + "size": 439554, + "subdir": "linux-64", + "timestamp": 1524621255611, + "version": "3.9.1" + }, + "conda-build-3.9.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ba8da7924d0cae5c1ed3645c3b6b2cd3", + "name": "conda-build", + "sha256": "646a8a51e8904c53de421cc53115daca9ace1e3b292bf1b5374b1c0d0f63fe7f", + "size": 437366, + "subdir": "linux-64", + "timestamp": 1524862199707, + "version": "3.9.2" + }, + "conda-build-3.9.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "51794be518901d65e7c4accec399029c", + "name": "conda-build", + "sha256": "43425c960cfcd7db627604219500966ce81f9b6aada21beb009710578b742d93", + "size": 441110, + "subdir": "linux-64", + "timestamp": 1524862233179, + "version": "3.9.2" + }, + "conda-build-3.9.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c977a25b4b31a65746c26aa1d91b7569", + "name": "conda-build", + "sha256": "c1cc1a256afa0f22368153954437aa5d9a4d6d1d2aae24f5c2d9f8dd12188827", + "size": 439974, + "subdir": "linux-64", + "timestamp": 1524862233103, + "version": "3.9.2" + }, + "conda-content-trust-0.1.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5d2c7dfa66a2ef5cbfc9d385f7be1af9", + "name": "conda-content-trust", + "sha256": "dca3a0ea6379e0e895aff8e716742fa30cd792e96a3552474f029b5560d6fe18", + "size": 73920, + "subdir": "linux-64", + "timestamp": 1658126442462, + "version": "0.1.3" + }, + "conda-content-trust-0.1.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d44cb07155b39d30f774ee1f78b23002", + "name": "conda-content-trust", + "sha256": "5d0f6aaa3a2d9eda7fd59804cc4b2ab24099f76dfee910916dbebe429701fdc7", + "size": 83488, + "subdir": "linux-64", + "timestamp": 1676851340382, + "version": "0.1.3" + }, + "conda-content-trust-0.1.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0d93f5c6c6919220af02309f278b3b98", + "name": "conda-content-trust", + "sha256": "fefdb0c13cb5e19c32443160bfeafe76b8ff65359f04c38c8709b4df91cfb960", + "size": 73642, + "subdir": "linux-64", + "timestamp": 1658126496891, + "version": "0.1.3" + }, + "conda-content-trust-0.1.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c5a15f148e9fd21ea0e6387e1e37f560", + "name": "conda-content-trust", + "sha256": "7747bf2a4dedf25f73ffa14cb4ba78f1a35823fa0155a39ce72a3e5b44094758", + "size": 73798, + "subdir": "linux-64", + "timestamp": 1658126404256, + "version": "0.1.3" + }, + "conda-content-trust-0.1.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a70b429d31daacc33eb8f1f57d1de4e", + "name": "conda-content-trust", + "sha256": "c6628760eb46e071a8db2837be6ddea8e3cb2c4fee61f2791433a3b77a0a59c3", + "size": 73815, + "subdir": "linux-64", + "timestamp": 1658126469377, + "version": "0.1.3" + }, + "conda-env-2.6.0-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [], + "license": "BSD 3-Clause", + "md5": "f98669af452e8d81a8710f1e7cc932b2", + "name": "conda-env", + "namespace": "python", + "sha256": "84181ff8df8ac13b8c3a0c452a157ae0cf958bd37063705e489f17cc6d7ed6f9", + "size": 2837, + "subdir": "linux-64", + "timestamp": 1530812938329, + "version": "2.6.0" + }, + "conda-env-2.6.0-h36134e3_1.tar.bz2": { + "build": "h36134e3_1", + "build_number": 1, + "depends": [], + "license": "BSD 3-Clause", + "md5": "c1a55e6bb160dd26801df411e7dc1dc4", + "name": "conda-env", + "namespace": "python", + "sha256": "8a6c1e05f974afcaad3c9fe4abcafec6f5ae16202f3845523a1dd1e993f5930f", + "size": 2247, + "subdir": "linux-64", + "timestamp": 1505742067960, + "version": "2.6.0" + }, + "conda-index-0.2.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8", + "conda >=4.12.0", + "conda-package-streaming >=0.7.0", + "filelock", + "jinja2", + "more-itertools", + "python >=3.10,<3.11.0a0", + "pyyaml >=6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b9fd595fb1fd4156ca1409f35e2176fb", + "name": "conda-index", + "sha256": "49b49d640240ca5a92b5290370150f77bc476203812d2957306f80854f3e77e1", + "size": 197966, + "subdir": "linux-64", + "timestamp": 1672127387623, + "version": "0.2.3" + }, + "conda-index-0.2.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8", + "conda >=4.12.0", + "conda-package-streaming >=0.7.0", + "filelock", + "jinja2", + "more-itertools", + "python >=3.11,<3.12.0a0", + "pyyaml >=6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "60ad5489c4b605dfedaaa189df2f17b0", + "name": "conda-index", + "sha256": "52a6980c4facd05fdb6ecbc8d7ff25f8598cad560923833be8873f7f6a1b994b", + "size": 220876, + "subdir": "linux-64", + "timestamp": 1676851356499, + "version": "0.2.3" + }, + "conda-index-0.2.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8", + "conda >=4.12.0", + "conda-package-streaming >=0.7.0", + "filelock", + "jinja2", + "more-itertools", + "python >=3.7,<3.8.0a0", + "pyyaml >=6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "432cd894506f6dadd254478b52ee522d", + "name": "conda-index", + "sha256": "f3051b6881ef3f97c40b53a7591f70afc489bfa68e5450a8667ed4c274b593de", + "size": 197247, + "subdir": "linux-64", + "timestamp": 1672127423190, + "version": "0.2.3" + }, + "conda-index-0.2.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8", + "conda >=4.12.0", + "conda-package-streaming >=0.7.0", + "filelock", + "jinja2", + "more-itertools", + "python >=3.8,<3.9.0a0", + "pyyaml >=6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a7bd15a84fd0a884d9db0c939afb7af", + "name": "conda-index", + "sha256": "cbdd7903faef8b11e3d20fe8463fe87347586b487c7e988468032b4434dc06f6", + "size": 197692, + "subdir": "linux-64", + "timestamp": 1672127470096, + "version": "0.2.3" + }, + "conda-index-0.2.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8", + "conda >=4.12.0", + "conda-package-streaming >=0.7.0", + "filelock", + "jinja2", + "more-itertools", + "python >=3.9,<3.10.0a0", + "pyyaml >=6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2c27c389926da92e8adf39d995a084d1", + "name": "conda-index", + "sha256": "f95e6be9c5e620bd187e9ab256438880043ffae2095a8bc5e05648bcc340970c", + "size": 197760, + "subdir": "linux-64", + "timestamp": 1672127352596, + "version": "0.2.3" + }, + "conda-libmamba-solver-22.12.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=22.11.0,<23.1.0a", + "importlib-metadata", + "libmambapy >=1.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d596700900f04adb7c571b5888a6873d", + "name": "conda-libmamba-solver", + "sha256": "6500bfb098a2ff18d1729b12d960594be40a6d92d491ba3f13dbc47ea82ccc0b", + "size": 61469, + "subdir": "linux-64", + "timestamp": 1669915150570, + "version": "22.12.0" + }, + "conda-libmamba-solver-22.12.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=22.11.0,<23.1.0a", + "importlib-metadata", + "libmambapy >=1.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dd532931ef6642200d422371a540c03d", + "name": "conda-libmamba-solver", + "sha256": "a8ff7def9f2853e7031def25867e8bae80e4a3321be5afe54b0faef9f7c6e85f", + "size": 60866, + "subdir": "linux-64", + "timestamp": 1669915117324, + "version": "22.12.0" + }, + "conda-libmamba-solver-22.12.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=22.11.0,<23.1.0a", + "importlib-metadata", + "libmambapy >=1.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4e4072fbb98c10aa9fa3a4236379caab", + "name": "conda-libmamba-solver", + "sha256": "c54190f3c2b6b9d12c19c953036d335b1314b7bdfdb1ebdd9449983712b35229", + "size": 61039, + "subdir": "linux-64", + "timestamp": 1669915083949, + "version": "22.12.0" + }, + "conda-libmamba-solver-22.12.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=22.11.0,<23.1.0a", + "importlib-metadata", + "libmambapy >=1.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "97caac63225eb7d5e7d6c24e71898b7d", + "name": "conda-libmamba-solver", + "sha256": "dd59ce1c62156eb2bfd7fb325b0b167216daa8b17481fdbbf95b61f887fcf3b6", + "size": 61053, + "subdir": "linux-64", + "timestamp": 1669915183463, + "version": "22.12.0" + }, + "conda-libmamba-solver-22.8.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=4.13,<22.11.0a", + "importlib_metadata", + "libmambapy >=0.23", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1af2b4749d4288fbfa7f8ddf32cf1598", + "name": "conda-libmamba-solver", + "sha256": "0f4e9ec2a89cfa55225dc1b0b8d9515726399131c48af5ed2c80d627467ecefa", + "size": 61848, + "subdir": "linux-64", + "timestamp": 1661888244054, + "version": "22.8.1" + }, + "conda-libmamba-solver-22.8.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=4.13,<22.11.0a", + "importlib_metadata", + "libmambapy >=0.23", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2e5c418c68317d4a9bd72cd00b32b5d6", + "name": "conda-libmamba-solver", + "sha256": "92ccd4662ebe3f2ea9d094021b14dd0561457fd8f89f8952df2f26e8a5e9bff2", + "size": 61282, + "subdir": "linux-64", + "timestamp": 1661888196150, + "version": "22.8.1" + }, + "conda-libmamba-solver-22.8.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=4.13,<22.11.0a", + "importlib_metadata", + "libmambapy >=0.23", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "58a17ef484ed041b438d1c1f2beb692c", + "name": "conda-libmamba-solver", + "sha256": "ed17832419a916ffff88e5571905afd8392f2be4f9284d0f420a6eaa974f0029", + "size": 61352, + "subdir": "linux-64", + "timestamp": 1661888274607, + "version": "22.8.1" + }, + "conda-libmamba-solver-22.8.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=4.13,<22.11.0a", + "importlib_metadata", + "libmambapy >=0.23", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dc3f0ac9213bc4a1469ea81c740a25ee", + "name": "conda-libmamba-solver", + "sha256": "38ff345afad2d382f35beecbf565a4d77a420656d0f76ccde1e18019ce198e10", + "size": 61376, + "subdir": "linux-64", + "timestamp": 1661888309953, + "version": "22.8.1" + }, + "conda-libmamba-solver-23.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=22.11.0,<23.2.0a", + "importlib-metadata", + "libmambapy >=1.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "61469a582b2d931871ccaa5f81725a7c", + "name": "conda-libmamba-solver", + "sha256": "f58bdf3429f0b4e29a9c8e2b9d75a190515fe31e084062f35c77a6a6893143a0", + "size": 61830, + "subdir": "linux-64", + "timestamp": 1676391150802, + "version": "23.1.0" + }, + "conda-libmamba-solver-23.1.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=22.11.0,<23.2.0a", + "importlib-metadata", + "libmambapy >=1.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa8ab77629e8f18809ef927ace5d190a", + "name": "conda-libmamba-solver", + "sha256": "aaee2b02414393eac56b8d8a76e5009c87d4bb3e141cb26b1bc5dcd57f52c86b", + "size": 80063, + "subdir": "linux-64", + "timestamp": 1676851372601, + "version": "23.1.0" + }, + "conda-libmamba-solver-23.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=22.11.0,<23.2.0a", + "importlib-metadata", + "libmambapy >=1.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d84da5751eecca46e3e2762ad4014bf7", + "name": "conda-libmamba-solver", + "sha256": "28c017fc7a6403565a0f4b00e19c6823119390fc2a6083a654282e4dcddc1049", + "size": 61201, + "subdir": "linux-64", + "timestamp": 1676391251173, + "version": "23.1.0" + }, + "conda-libmamba-solver-23.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=22.11.0,<23.2.0a", + "importlib-metadata", + "libmambapy >=1.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9e219625f163df70fa718359d112881a", + "name": "conda-libmamba-solver", + "sha256": "8d19748b5ebd838e1608953bc082de4fd02612e2b69f2703baaf8b5426c8144d", + "size": 61411, + "subdir": "linux-64", + "timestamp": 1676391184564, + "version": "23.1.0" + }, + "conda-libmamba-solver-23.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=22.11.0,<23.2.0a", + "importlib-metadata", + "libmambapy >=1.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "64c689d7b2c7897f706d1ae935697965", + "name": "conda-libmamba-solver", + "sha256": "0c2ee814a8ce3971a30cc28e7d320dc3d9c7067562b7d777cc1d4397cd241781", + "size": 61354, + "subdir": "linux-64", + "timestamp": 1676391217852, + "version": "23.1.0" + }, + "conda-libmamba-solver-23.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "boltons >=23.0.0", + "conda >=23.3.1", + "libmambapy >=1.4.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7472487ecb37b588abb483e43f82551b", + "name": "conda-libmamba-solver", + "sha256": "223ee104b265855ea066acfc90dadaf10afed83f5288ab65ed925cb9b8bb2a4a", + "size": 63458, + "subdir": "linux-64", + "timestamp": 1680589509902, + "version": "23.3.0" + }, + "conda-libmamba-solver-23.3.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "boltons >=23.0.0", + "conda >=23.3.1", + "libmambapy >=1.4.1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cb2f7d93ac46108e8900a44665d2c263", + "name": "conda-libmamba-solver", + "sha256": "94f510e04ae918de5890d3d0717cb226d51889d6961f8cec68af1a90319b00dc", + "size": 81089, + "subdir": "linux-64", + "timestamp": 1680589594402, + "version": "23.3.0" + }, + "conda-libmamba-solver-23.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "boltons >=23.0.0", + "conda >=23.3.1", + "libmambapy >=1.4.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7307965f79652c4fc3f2fabbb38fcfd5", + "name": "conda-libmamba-solver", + "sha256": "e3f4ab118a87d29f7c24856773429bfcd7afe04249aa95ea716a1bcf12babad8", + "size": 62982, + "subdir": "linux-64", + "timestamp": 1680589552470, + "version": "23.3.0" + }, + "conda-libmamba-solver-23.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "boltons >=23.0.0", + "conda >=23.3.1", + "libmambapy >=1.4.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8500ef9c3250c6e1cf9df3e881aec436", + "name": "conda-libmamba-solver", + "sha256": "6706b50bcf73bd6af4a985f7d988db6bcc86df5139d7fa487e4ffa3719c872c9", + "size": 63058, + "subdir": "linux-64", + "timestamp": 1680589468014, + "version": "23.3.0" + }, + "conda-lock-1.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol-with-filecache >=0.12.9", + "cachy >=0.3.0", + "click >=8.0", + "click-default-group", + "clikit >=0.6.2", + "crashtest >=0.3.0", + "ensureconda >=1.3", + "filelock >=3.8.0", + "html5lib >=1.0", + "jinja2", + "keyring >=21.2.0", + "packaging >=20.4", + "pkginfo >=1.4", + "pydantic >=1.8.1", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.1", + "requests >=2.18", + "ruamel.yaml", + "tomli", + "tomlkit >=0.7.0", + "toolz >=0.12.0,<1.0.0", + "typing_extensions", + "virtualenv >=20.0.26" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d90c198171f2841182825a3468fe3cc", + "name": "conda-lock", + "sha256": "70f886c51d945661c633fcda20882b93bc63b9ead24ffb8dc3d6d9c6e0833f9f", + "size": 1924205, + "subdir": "linux-64", + "timestamp": 1676368399126, + "version": "1.4.0" + }, + "conda-lock-1.4.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol-with-filecache >=0.12.9", + "cachy >=0.3.0", + "click >=8.0", + "click-default-group", + "clikit >=0.6.2", + "crashtest >=0.3.0", + "ensureconda >=1.3", + "filelock >=3.8.0", + "html5lib >=1.0", + "jinja2", + "keyring >=21.2.0", + "packaging >=20.4", + "pkginfo >=1.4", + "pydantic >=1.8.1", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.1", + "requests >=2.18", + "ruamel.yaml", + "tomlkit >=0.7.0", + "toolz >=0.12.0,<1.0.0", + "typing_extensions", + "virtualenv >=20.0.26" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ca87d71e868ddff8c6260904e956b7f", + "name": "conda-lock", + "sha256": "e5dfde821a0e305d240084d864f531d7774fd6918f8aa9680e02df84be854050", + "size": 2570647, + "subdir": "linux-64", + "timestamp": 1679517262114, + "version": "1.4.0" + }, + "conda-lock-1.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol-with-filecache >=0.12.9", + "cachy >=0.3.0", + "click >=8.0", + "click-default-group", + "clikit >=0.6.2", + "crashtest >=0.3.0", + "ensureconda >=1.3", + "filelock >=3.8.0", + "html5lib >=1.0", + "importlib-metadata >=1.7.0", + "jinja2", + "keyring >=21.2.0", + "packaging >=20.4", + "pkginfo >=1.4", + "pydantic >=1.8.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "requests >=2.18", + "ruamel.yaml", + "tomli", + "tomlkit >=0.7.0", + "toolz >=0.12.0,<1.0.0", + "typing_extensions", + "virtualenv >=20.0.26" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c7bee44c3cb28b65c803e7579b3bd777", + "name": "conda-lock", + "sha256": "db4a1bac0d61f8676d5fa8fdce2b1733f1ee42aa025399eab4a7e58590984856", + "size": 1900866, + "subdir": "linux-64", + "timestamp": 1676368489269, + "version": "1.4.0" + }, + "conda-lock-1.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol-with-filecache >=0.12.9", + "cachy >=0.3.0", + "click >=8.0", + "click-default-group", + "clikit >=0.6.2", + "crashtest >=0.3.0", + "ensureconda >=1.3", + "filelock >=3.8.0", + "html5lib >=1.0", + "jinja2", + "keyring >=21.2.0", + "packaging >=20.4", + "pkginfo >=1.4", + "pydantic >=1.8.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "requests >=2.18", + "ruamel.yaml", + "tomli", + "tomlkit >=0.7.0", + "toolz >=0.12.0,<1.0.0", + "typing_extensions", + "virtualenv >=20.0.26" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90edfa6ebd698aec07a77e3923eb69b8", + "name": "conda-lock", + "sha256": "663cb5cf743b98b9b6c60b85ff891acae4e6224b2868902653be766cf9e9dde9", + "size": 1903762, + "subdir": "linux-64", + "timestamp": 1676368354154, + "version": "1.4.0" + }, + "conda-lock-1.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol-with-filecache >=0.12.9", + "cachy >=0.3.0", + "click >=8.0", + "click-default-group", + "clikit >=0.6.2", + "crashtest >=0.3.0", + "ensureconda >=1.3", + "filelock >=3.8.0", + "html5lib >=1.0", + "jinja2", + "keyring >=21.2.0", + "packaging >=20.4", + "pkginfo >=1.4", + "pydantic >=1.8.1", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "requests >=2.18", + "ruamel.yaml", + "tomli", + "tomlkit >=0.7.0", + "toolz >=0.12.0,<1.0.0", + "typing_extensions", + "virtualenv >=20.0.26" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5569bc29d9643d074715788e68c37419", + "name": "conda-lock", + "sha256": "c51a000c893f51a7052d565811c6eaa951d713013acd79b0f6a474038c7eeb23", + "size": 1904229, + "subdir": "linux-64", + "timestamp": 1676368443612, + "version": "1.4.0" + }, + "conda-package-handling-1.0.4-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "31bf560944f9f7b42b83b916174debe5", + "name": "conda-package-handling", + "sha256": "b489f150e234fe3e94d8842cc8c85566fa380a5745698bef72af7b96308c0f21", + "size": 254640, + "subdir": "linux-64", + "timestamp": 1555080220688, + "version": "1.0.4" + }, + "conda-package-handling-1.0.4-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4c4a5f062a6d845c8073e99d21ea5ad9", + "name": "conda-package-handling", + "sha256": "15f96fc12722fac7333d925b20cbbbe2ee7fc7a9355624ee14102f1cfb7ca292", + "size": 255258, + "subdir": "linux-64", + "timestamp": 1555080380152, + "version": "1.0.4" + }, + "conda-package-handling-1.0.4-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f9e1d1da12d3069cb8f6acca6712b106", + "name": "conda-package-handling", + "sha256": "5d58e084801a82726ba9bb413d403236d73965b0dd3fb36cebe6325c90f0e2be", + "size": 255193, + "subdir": "linux-64", + "timestamp": 1555080218325, + "version": "1.0.4" + }, + "conda-package-handling-1.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "54704d2c1d7b8335a587c9c59d64e40a", + "name": "conda-package-handling", + "sha256": "2cd094e70d47889eac306c9d0508ff5cded140593b872ea7163d91a3c68b2529", + "size": 254323, + "subdir": "linux-64", + "timestamp": 1557514388864, + "version": "1.1.0" + }, + "conda-package-handling-1.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bae0f10848431c448d8e12a5fd02a23b", + "name": "conda-package-handling", + "sha256": "d5ae93c409e6baad971db320d2c4562feab34ff069ae8005a9635bede1574654", + "size": 254984, + "subdir": "linux-64", + "timestamp": 1557514410810, + "version": "1.1.0" + }, + "conda-package-handling-1.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b342328b2f60dbbd7601f6cbe5cfd255", + "name": "conda-package-handling", + "sha256": "f478decc52760e93b66c4664e568bf2c724d474e6eb5ad565e46659f4e30fbcc", + "size": 254909, + "subdir": "linux-64", + "timestamp": 1557514372669, + "version": "1.1.0" + }, + "conda-package-handling-1.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e327c618966d5917e8523ea91ff7605d", + "name": "conda-package-handling", + "sha256": "6e1f9d7715e410242b5e5d714c19d41d6ae67dbcd06f8f13d2afa0447ac40a46", + "size": 254511, + "subdir": "linux-64", + "timestamp": 1558113604884, + "version": "1.1.1" + }, + "conda-package-handling-1.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "342c40c7799f09529722415e89131d37", + "name": "conda-package-handling", + "sha256": "8e71b3471d6f043266197e540dcd65b4be72129fd9ee7bf68630c435446c7090", + "size": 255063, + "subdir": "linux-64", + "timestamp": 1558113606980, + "version": "1.1.1" + }, + "conda-package-handling-1.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d929aa15db7e1caf7f2c8990e981dc81", + "name": "conda-package-handling", + "sha256": "ec8d1a08c8a2874745bea9a2f0845fcc4a421238127e7199cf812979abd8d868", + "size": 254965, + "subdir": "linux-64", + "timestamp": 1558113471112, + "version": "1.1.1" + }, + "conda-package-handling-1.1.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a4701a636ed63c3e171d98d0d5a875c", + "name": "conda-package-handling", + "sha256": "1607db92ceae9defe2b553848ba0058113775da12dfd666b1dab5aacbb2904b7", + "size": 256939, + "subdir": "linux-64", + "timestamp": 1558467517628, + "version": "1.1.5" + }, + "conda-package-handling-1.1.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "93402fe9b5bff1bbbe49085aa55956e0", + "name": "conda-package-handling", + "sha256": "c1179901d4cef35112c9989507a353262f40231431f622c38cd8d1f6947a0964", + "size": 257422, + "subdir": "linux-64", + "timestamp": 1558467540372, + "version": "1.1.5" + }, + "conda-package-handling-1.1.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a8fdb3cc6560b73f4e32b76e61b06aa1", + "name": "conda-package-handling", + "sha256": "93dc22b92e605991750dbc1b9fd46887dd543483bb1ff25525fa0b9840401a7e", + "size": 257353, + "subdir": "linux-64", + "timestamp": 1558467503260, + "version": "1.1.5" + }, + "conda-package-handling-1.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "94e821d747633c0dbc8ce65ba1c2d6bb", + "name": "conda-package-handling", + "sha256": "a588d54e3106ed27820c58bf3b5cd9b871d017cfc44cb11e5176d3bba34c0bf8", + "size": 258062, + "subdir": "linux-64", + "timestamp": 1560193104523, + "version": "1.3.0" + }, + "conda-package-handling-1.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f88974bb811b39af5b397d47542cf3bc", + "name": "conda-package-handling", + "sha256": "130e17c2d92a3318792a782072b2ba6c749dbe0a147cd26bf22dc3a9fabb5c7f", + "size": 258734, + "subdir": "linux-64", + "timestamp": 1560193118048, + "version": "1.3.0" + }, + "conda-package-handling-1.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "654a0a9b7fbec8e5f45007b4d7f12070", + "name": "conda-package-handling", + "sha256": "8697d44e9b06fecfc25032261112e091dce921cbca4d82ce35404efbe6198c97", + "size": 258532, + "subdir": "linux-64", + "timestamp": 1560193090492, + "version": "1.3.0" + }, + "conda-package-handling-1.3.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d20f59f5c1f8ad0b18e7a89eae773ec", + "name": "conda-package-handling", + "sha256": "273d1d4bfef043cbbdf81ff1ec3c457e434abc50a104467ec85f26869542e5a7", + "size": 265016, + "subdir": "linux-64", + "timestamp": 1561405898197, + "version": "1.3.10" + }, + "conda-package-handling-1.3.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fdd0a47306160938ef4a3966c35cafe8", + "name": "conda-package-handling", + "sha256": "a7bcb1108d90ed390f109d3f5704b672f6744f28d0c49890870bd3f41f52b679", + "size": 265599, + "subdir": "linux-64", + "timestamp": 1561405919974, + "version": "1.3.10" + }, + "conda-package-handling-1.3.10-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bee247d72804e08f69caf1e84201f490", + "name": "conda-package-handling", + "sha256": "5df51e2bf2ddb2a534ae5c8dbd89e5f7e9e36e416500b4285abc3122bf64c335", + "size": 265491, + "subdir": "linux-64", + "timestamp": 1561405880363, + "version": "1.3.10" + }, + "conda-package-handling-1.3.11-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ef3e60855842948924673788284cf228", + "name": "conda-package-handling", + "sha256": "75c942fe5c53c0b3e9d7ea0fcbffa3f7f59b22adf64bd0f07f2d3a9c2047be77", + "size": 266058, + "subdir": "linux-64", + "timestamp": 1562853199859, + "version": "1.3.11" + }, + "conda-package-handling-1.3.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0ab3559621be43c836b4d16903510ac3", + "name": "conda-package-handling", + "sha256": "1d4c0f96090dde7a3582f806232eca5acc0a7f7c6dcd3b7449203ec26df46eb7", + "size": 266574, + "subdir": "linux-64", + "timestamp": 1562853286073, + "version": "1.3.11" + }, + "conda-package-handling-1.3.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7ed5219e2302371fabecf9cecd47bae3", + "name": "conda-package-handling", + "sha256": "9e16c923d70b78c5c5a0447929cbff1335d6c5ee7998def9178217cb421d2101", + "size": 266539, + "subdir": "linux-64", + "timestamp": 1562853266422, + "version": "1.3.11" + }, + "conda-package-handling-1.3.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a3692a7d32f09fd74f52b5ed3cc9c6ab", + "name": "conda-package-handling", + "sha256": "f33ed8bad2b08ca2b3494129a24ece97acf9e4feb61b94557f6f1addfea182b6", + "size": 264714, + "subdir": "linux-64", + "timestamp": 1560362661478, + "version": "1.3.6" + }, + "conda-package-handling-1.3.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "77a528fbb8b80a8c9b4bd39a71d68cf0", + "name": "conda-package-handling", + "sha256": "fd7541d0c1d40a3948b3bba03761f182a253044dd7bb5bca59c31c2446889741", + "size": 265043, + "subdir": "linux-64", + "timestamp": 1560362684905, + "version": "1.3.6" + }, + "conda-package-handling-1.3.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d91466b9965a0eafa6f349a6dee0cb4f", + "name": "conda-package-handling", + "sha256": "f5651987e7b4cf6d8388fab3d48392c5c02f3904dba96a9b0fa24cbac3bd957b", + "size": 265024, + "subdir": "linux-64", + "timestamp": 1560362628844, + "version": "1.3.6" + }, + "conda-package-handling-1.3.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ec2897fa25bd50d2607f3c7e9fb38b05", + "name": "conda-package-handling", + "sha256": "88818f046e4f632a977a35f6d028f1e11fa9d831ec10becaa2a8383bb48857c7", + "size": 264812, + "subdir": "linux-64", + "timestamp": 1560377356826, + "version": "1.3.7" + }, + "conda-package-handling-1.3.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "51c992266dfe929d4bcfc73a55015ab3", + "name": "conda-package-handling", + "sha256": "fff9fbbf5124dad86709cd89eaf05e2676ca22c43a695aab4d35326b2fd1767f", + "size": 265422, + "subdir": "linux-64", + "timestamp": 1560377372426, + "version": "1.3.7" + }, + "conda-package-handling-1.3.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8e7b45f22313487fb6c3ed6363e5ecb7", + "name": "conda-package-handling", + "sha256": "8f102d4affeb06e1785f9cf6e794a3863c83aad0699dda339bd75b5cad0db848", + "size": 265331, + "subdir": "linux-64", + "timestamp": 1560377341115, + "version": "1.3.7" + }, + "conda-package-handling-1.3.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c70bedfd4086478fcc56ba26b414c085", + "name": "conda-package-handling", + "sha256": "3be22a907fa76a79f3c2af06083c8f87c5d7c12701e436e66ac6f23e9abfbce1", + "size": 265014, + "subdir": "linux-64", + "timestamp": 1560550856734, + "version": "1.3.9" + }, + "conda-package-handling-1.3.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f8330ede3a5c8edd74d7eab8b9a6a5fe", + "name": "conda-package-handling", + "sha256": "7f5e1d9d658ba7fe4fd86c0c28cc89f3d9f69913caa44d1171bf57994583ddc4", + "size": 265511, + "subdir": "linux-64", + "timestamp": 1560550867849, + "version": "1.3.9" + }, + "conda-package-handling-1.3.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1a0ee5b06dcbbcdeabad7f66ee63d4be", + "name": "conda-package-handling", + "sha256": "f4fbcd8d25f833808043a9571be17988797f7d31a5d3e881e667c3f7491e02a8", + "size": 265380, + "subdir": "linux-64", + "timestamp": 1560550824583, + "version": "1.3.9" + }, + "conda-package-handling-1.6.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "futures", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "78cf646574300106f0d2d72bbde26ba3", + "name": "conda-package-handling", + "sha256": "ef273aed5e423e60663d7c484b07a6557714276c36c02b7d13e2000c7f6bb3a4", + "size": 886052, + "subdir": "linux-64", + "timestamp": 1569013516602, + "version": "1.6.0" + }, + "conda-package-handling-1.6.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e29ca6d2a9525d8c57278e787ae32bd8", + "name": "conda-package-handling", + "sha256": "0a25bd1565d1e31bcdd8559035c100f57df0d060d2f4e85b356a7eadbc57aed7", + "size": 891622, + "subdir": "linux-64", + "timestamp": 1569013524221, + "version": "1.6.0" + }, + "conda-package-handling-1.6.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cf2c1ef531f9a9222a93ccaa60a42928", + "name": "conda-package-handling", + "sha256": "0c5fe3c0d9627965acffd51df09fcc08201f2842c6ecdd157a0e56b944d7c995", + "size": 893068, + "subdir": "linux-64", + "timestamp": 1569013549041, + "version": "1.6.0" + }, + "conda-package-handling-1.6.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5545a73089c98729ef0ea4882e33ba00", + "name": "conda-package-handling", + "sha256": "3c691d813840fb095fdf08731814f6b14da224ba8fd3061b53e71c3b88a15d06", + "size": 900595, + "subdir": "linux-64", + "timestamp": 1573738178544, + "version": "1.6.0" + }, + "conda-package-handling-1.6.1-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8d8dea107f15ba4529bbe233eea7485c", + "name": "conda-package-handling", + "sha256": "c04d9c63077ecdaedd0a9b43d2095e5f3dc06640025435a2d540ce15a85827b0", + "size": 936076, + "subdir": "linux-64", + "timestamp": 1641560745375, + "version": "1.6.1" + }, + "conda-package-handling-1.6.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2d1745973a59dc7e2d1a0166cfcc08ce", + "name": "conda-package-handling", + "sha256": "479623723796a5f8e94fa7b37c99f7a38c6098ba6f89f289b1f08c9b3abf710d", + "size": 907308, + "subdir": "linux-64", + "timestamp": 1588797872636, + "version": "1.6.1" + }, + "conda-package-handling-1.6.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0955c0e7f7e1742d06699945addd26ab", + "name": "conda-package-handling", + "sha256": "2c8bc39497c2543141b29ef4c51841afda2d4639f63544b442efca87c0b8d7d3", + "size": 907238, + "subdir": "linux-64", + "timestamp": 1588797879755, + "version": "1.6.1" + }, + "conda-package-handling-1.6.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c5d0e5d3fcee0f66b5b22f135227764c", + "name": "conda-package-handling", + "sha256": "b5c0bd349d0192f1e59fc930326bf203125e94aec5bfb25bffe423413647fb55", + "size": 889506, + "subdir": "linux-64", + "timestamp": 1588797905445, + "version": "1.6.1" + }, + "conda-package-handling-1.7.2-py36h03888b9_0.tar.bz2": { + "build": "py36h03888b9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2e3df5b44013ac0abb40a3fa5aa75893", + "name": "conda-package-handling", + "sha256": "d39e97ee3c0c4c312aa7916bc4ad1941b1cbd9d6d4bbe5b63d4f0b59728b9bd4", + "size": 989850, + "subdir": "linux-64", + "timestamp": 1603018179849, + "version": "1.7.2" + }, + "conda-package-handling-1.7.2-py37h03888b9_0.tar.bz2": { + "build": "py37h03888b9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07907c384e991fcfd9c158b2c3c5fb58", + "name": "conda-package-handling", + "sha256": "c55246bf4a94daafc86fe2f996ec9404eb1d47a518e8cc3cb40caae800cb3215", + "size": 1000322, + "subdir": "linux-64", + "timestamp": 1603018174342, + "version": "1.7.2" + }, + "conda-package-handling-1.7.2-py38h03888b9_0.tar.bz2": { + "build": "py38h03888b9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee86048b0afedf65dffe0f256152b4ba", + "name": "conda-package-handling", + "sha256": "cf538f45644a964e08209ec193631b1f765d17a880f4971b7456d4fe4fa1a9bd", + "size": 998631, + "subdir": "linux-64", + "timestamp": 1603018175363, + "version": "1.7.2" + }, + "conda-package-handling-1.7.2-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "086326046c1447d9c586f4224ffe1474", + "name": "conda-package-handling", + "sha256": "763c3701f47db3d6626851bce44e520b2e4fdd93ea71170c09c19f766172cb23", + "size": 998674, + "subdir": "linux-64", + "timestamp": 1605484883832, + "version": "1.7.2" + }, + "conda-package-handling-1.7.3-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8c6c9959561a59a8c96fd15ec5ebd6f4", + "name": "conda-package-handling", + "sha256": "6a825fc40adf6054e35847cf70db0c40de044f4f8914e89c897ec830ec9d317e", + "size": 1019977, + "subdir": "linux-64", + "timestamp": 1641551805944, + "version": "1.7.3" + }, + "conda-package-handling-1.7.3-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "19618d2ad13e6941752dbc1d6c40d01e", + "name": "conda-package-handling", + "sha256": "e1b3b2572e16662fda4dc0c30630f266f1bc4fbbca8dfc9805ae7a39cbfd3504", + "size": 968979, + "subdir": "linux-64", + "timestamp": 1618262209227, + "version": "1.7.3" + }, + "conda-package-handling-1.7.3-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f1176683afc81e951325715d20210106", + "name": "conda-package-handling", + "sha256": "eccb16a8604c13af7dc55931f1a71de3a013ec041e50ee1493f1736ad34274c5", + "size": 985173, + "subdir": "linux-64", + "timestamp": 1618262198695, + "version": "1.7.3" + }, + "conda-package-handling-1.7.3-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c54d57d7abaa1762aec90cce1cde2619", + "name": "conda-package-handling", + "sha256": "23b5e3effaf239362459b4e603eb1e8c933ba7cb5479782be99084ca23551b84", + "size": 988005, + "subdir": "linux-64", + "timestamp": 1618262197070, + "version": "1.7.3" + }, + "conda-package-handling-1.7.3-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1703901c9c5c3f4b602f615cdf51267", + "name": "conda-package-handling", + "sha256": "7ec49c2e1e1e5349026da54e6aa820f090769be86c85b8b40191c70f3b358288", + "size": 990627, + "subdir": "linux-64", + "timestamp": 1618262196863, + "version": "1.7.3" + }, + "conda-package-handling-1.8.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1baf45da1bbd9978229b70c616753c4e", + "name": "conda-package-handling", + "sha256": "b1316304cf20d0efb736f1090c913380986a2698c718d5aa21592d5e834d63f1", + "size": 1020513, + "subdir": "linux-64", + "timestamp": 1647948763841, + "version": "1.8.0" + }, + "conda-package-handling-1.8.0-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bc8557e91dacf8986614f8dcb625ebb5", + "name": "conda-package-handling", + "sha256": "2ec5fcdbbb446b9396b8477c801ec7b38cfd2ef3809a9b6abbaea92d8ad96bad", + "size": 997049, + "subdir": "linux-64", + "timestamp": 1647948828506, + "version": "1.8.0" + }, + "conda-package-handling-1.8.0-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "956c91227843971652c12077d5182ad0", + "name": "conda-package-handling", + "sha256": "9df850e5d3df4eacd2babf5739c32382fb4803fbbb489b59055f8e81665e6ee4", + "size": 996882, + "subdir": "linux-64", + "timestamp": 1647948795799, + "version": "1.8.0" + }, + "conda-package-handling-1.8.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fc217954247b666f2990135f4197f0fe", + "name": "conda-package-handling", + "sha256": "edd59fc73eee75b0b2ec1b891d2b78c50e1775ad198d5c83d2fb1e2ca44b783b", + "size": 997044, + "subdir": "linux-64", + "timestamp": 1647948869367, + "version": "1.8.0" + }, + "conda-package-handling-1.8.1-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "10ad349ffcb183d30d891211eec116c5", + "name": "conda-package-handling", + "sha256": "9a53c6a0a9322b281bdcdbe1fc6c016573a5d8b30348f014ce141cfbe37e1233", + "size": 1024124, + "subdir": "linux-64", + "timestamp": 1649087714922, + "version": "1.8.1" + }, + "conda-package-handling-1.8.1-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c87d342fe0adda720bbc3a61f25907e3", + "name": "conda-package-handling", + "sha256": "da09f9e35c6af93c46c9f8aad5588d4ce12664055cc17fa17f629c2e7e073ef3", + "size": 976384, + "subdir": "linux-64", + "timestamp": 1649105836092, + "version": "1.8.1" + }, + "conda-package-handling-1.8.1-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f588b714ed50a81597cb9ca98b3daf04", + "name": "conda-package-handling", + "sha256": "d5165b00f7c910d929a5019c8a0cdf401e60b1ba917a8d2f53d282f4d298e0db", + "size": 992797, + "subdir": "linux-64", + "timestamp": 1649087967826, + "version": "1.8.1" + }, + "conda-package-handling-1.8.1-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d505075ca709204956d7ddddf7129fdb", + "name": "conda-package-handling", + "sha256": "f1ffbc48a054684428ea475fc59d9c832c18bba181006b41a1f62ef9c5722bc3", + "size": 986346, + "subdir": "linux-64", + "timestamp": 1649105826585, + "version": "1.8.1" + }, + "conda-package-handling-1.9.0-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "be47f6c1b961d659d13252c6a95b71d4", + "name": "conda-package-handling", + "sha256": "1e8c2387b5baa29f7aaff4fc89b3f94482ec12dba4a4fe6029a6a081087385a7", + "size": 1021048, + "subdir": "linux-64", + "timestamp": 1663598536095, + "version": "1.9.0" + }, + "conda-package-handling-1.9.0-py310h5eee18b_1.tar.bz2": { + "build": "py310h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b8b9171edd8174cc396c93c16d1ffb6a", + "name": "conda-package-handling", + "sha256": "6d8474f300f1adf50b9ca7ae8fdd071a288583f413f339f8864de62ab881968a", + "size": 1061030, + "subdir": "linux-64", + "timestamp": 1666940480817, + "version": "1.9.0" + }, + "conda-package-handling-1.9.0-py311h5eee18b_1.tar.bz2": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3b3ae90b6b849e5b59cf4d901b3aab6a", + "name": "conda-package-handling", + "sha256": "7b825dd7820a364da382de48ff27cd0f75beb6dafdada843aafe189300ad2f60", + "size": 1078167, + "subdir": "linux-64", + "timestamp": 1676830322959, + "version": "1.9.0" + }, + "conda-package-handling-1.9.0-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "35f57eb6c2a46dd98b9b276336853828", + "name": "conda-package-handling", + "sha256": "ad835a35d77624794e8ba1094b1f44fb7320e49ec51a707a8681f54caf97524f", + "size": 982409, + "subdir": "linux-64", + "timestamp": 1663598570791, + "version": "1.9.0" + }, + "conda-package-handling-1.9.0-py37h5eee18b_1.tar.bz2": { + "build": "py37h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e2f4b2afa6cf2e17488ddd0c0ecabfaf", + "name": "conda-package-handling", + "sha256": "7d250ca4ff759708e77e74ea52bbfa9c386574a9ad4938c72121f8871ad8f33b", + "size": 1060188, + "subdir": "linux-64", + "timestamp": 1666940515292, + "version": "1.9.0" + }, + "conda-package-handling-1.9.0-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "109ae27f1a35fbb330c8e39c6a7b8008", + "name": "conda-package-handling", + "sha256": "f227b0bf447b8e9c2a49275dc6d7b8760d89a5e950c27d1de81e4d270cb7a108", + "size": 984563, + "subdir": "linux-64", + "timestamp": 1663598640269, + "version": "1.9.0" + }, + "conda-package-handling-1.9.0-py38h5eee18b_1.tar.bz2": { + "build": "py38h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "23ec6eb6afd7d1497ec2e120648b8cd1", + "name": "conda-package-handling", + "sha256": "54c3b6ac94e39b2d3bd6d6db5aba3fca0266c79d9b1f1e776051a6e22ac89bbf", + "size": 1060364, + "subdir": "linux-64", + "timestamp": 1666940446492, + "version": "1.9.0" + }, + "conda-package-handling-1.9.0-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c8d42c1962c7b4da15726bbba9d7bb21", + "name": "conda-package-handling", + "sha256": "35fd29b01bf7e622741cb4f9bdbf9a8fd0032bf2a61e8ab58b178e56cbdad0a9", + "size": 982660, + "subdir": "linux-64", + "timestamp": 1663598606324, + "version": "1.9.0" + }, + "conda-package-handling-1.9.0-py39h5eee18b_1.tar.bz2": { + "build": "py39h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "30c088d7edc063a0c6aa6a09ba757c97", + "name": "conda-package-handling", + "sha256": "7e9cd4820e0255be183a9b5cc052569cf07249ebcd613841bccd14977f51e46a", + "size": 1060524, + "subdir": "linux-64", + "timestamp": 1666940411960, + "version": "1.9.0" + }, + "conda-package-handling-2.0.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "conda-package-streaming >=0.7.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f7afb43d006cbd32033c1c5ef8405442", + "name": "conda-package-handling", + "sha256": "b9ec1e19a983e53b32eecc5e18da3285ec0e538e2c5ecd642ab4ebd5c1a3d0c9", + "size": 275108, + "subdir": "linux-64", + "timestamp": 1672865052883, + "version": "2.0.2" + }, + "conda-package-handling-2.0.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "conda-package-streaming >=0.7.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "56ee0a77ba73fc9cecc44ab83fa08f78", + "name": "conda-package-handling", + "sha256": "bc9d1e09d8b2bc45f2d250287a061d8737cb7a973b0b304f6a0e3b0ff07975d5", + "size": 287663, + "subdir": "linux-64", + "timestamp": 1679335570289, + "version": "2.0.2" + }, + "conda-package-handling-2.0.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "conda-package-streaming >=0.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e9081181f002fcf63bd51cb0753c58cb", + "name": "conda-package-handling", + "sha256": "985f19f46cb4b99c82244c67dc444d05b737125cefb1a662c1f5f2d6da5bdbc4", + "size": 274596, + "subdir": "linux-64", + "timestamp": 1672865090336, + "version": "2.0.2" + }, + "conda-package-handling-2.0.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "conda-package-streaming >=0.7.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e3454241b23b961deb59933ca9fb132b", + "name": "conda-package-handling", + "sha256": "cb569e631409a036cb4dc18cc235f5a80635005826a9a48dfb705be6d7181c32", + "size": 274628, + "subdir": "linux-64", + "timestamp": 1672865164367, + "version": "2.0.2" + }, + "conda-package-handling-2.0.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "conda-package-streaming >=0.7.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ca4ff334125387268528b10765095e6c", + "name": "conda-package-handling", + "sha256": "7d3b242ed58ae6b376669a34a11e6e7184fcf66d46ff61011f2d7052d7351659", + "size": 274831, + "subdir": "linux-64", + "timestamp": 1672865127636, + "version": "2.0.2" + }, + "conda-package-streaming-0.7.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "zstandard >=0.15" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bc0592f05898a182817cbb64b8fa48e2", + "name": "conda-package-streaming", + "sha256": "833357c792cb781bb85cc6f45c2a3758a86be6a9d2d9bfb39594df65c9301b8c", + "size": 25561, + "subdir": "linux-64", + "timestamp": 1670508260420, + "version": "0.7.0" + }, + "conda-package-streaming-0.7.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "zstandard >=0.15" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa53623c1eb49b4ec5a066ed1766f075", + "name": "conda-package-streaming", + "sha256": "80e08de7766f0075b747dd71820b16b2ba0affefe6cab5d929461d09360dfc43", + "size": 31885, + "subdir": "linux-64", + "timestamp": 1676843659332, + "version": "0.7.0" + }, + "conda-package-streaming-0.7.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zstandard >=0.15" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "029d98b06a8541ffdab48b519e0a6e6f", + "name": "conda-package-streaming", + "sha256": "4581adf5f381c0997586771366db2d2eb1f40fea405dc4832306f400b5773dbf", + "size": 25163, + "subdir": "linux-64", + "timestamp": 1670508207799, + "version": "0.7.0" + }, + "conda-package-streaming-0.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zstandard >=0.15" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d3cb7fc86abd9d9f1097a21f18205f5", + "name": "conda-package-streaming", + "sha256": "057cd0facfd703fb6e746de7f738f3ebd07e2a7291bc37810dfa4b6d0a1ddcce", + "size": 25185, + "subdir": "linux-64", + "timestamp": 1670508234071, + "version": "0.7.0" + }, + "conda-package-streaming-0.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "zstandard >=0.15" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "de2ec5e9451de2f63ac849c4c56e7eeb", + "name": "conda-package-streaming", + "sha256": "75d325aaaa1e18ee58223ce6f163cb4500dda08975e23a121851cc143a0466e2", + "size": 25272, + "subdir": "linux-64", + "timestamp": 1670508181398, + "version": "0.7.0" + }, + "conda-repo-cli-1.0.20-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8bfd0caebd9ffe03c95e6cb77de9caa3", + "name": "conda-repo-cli", + "sha256": "02f1e85da65d4f077cfab4505049a8548b0f94798bb26c1e60966e85cc7924ed", + "size": 107998, + "subdir": "linux-64", + "timestamp": 1664263126042, + "version": "1.0.20" + }, + "conda-repo-cli-1.0.20-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "65cff5f7d5a81f06c43b0818970238eb", + "name": "conda-repo-cli", + "sha256": "e1a6c956781e298d2950cbbe42bc062e8905e8e7974d9ac56777268cdc847505", + "size": 106439, + "subdir": "linux-64", + "timestamp": 1664263161637, + "version": "1.0.20" + }, + "conda-repo-cli-1.0.20-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "65051d976a7df3adb3f652b188a37d9d", + "name": "conda-repo-cli", + "sha256": "bdfe51360b4807cec337fdede68c27174fa15e0f6ede089e662a30140bb3cc53", + "size": 107057, + "subdir": "linux-64", + "timestamp": 1664263074171, + "version": "1.0.20" + }, + "conda-repo-cli-1.0.20-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "45ed2f606627b2add361a09d7f7fbe5a", + "name": "conda-repo-cli", + "sha256": "e5741dbc208cc5a287ffda22061b0ef5850bac382c785bdc81346434b915ec7e", + "size": 107380, + "subdir": "linux-64", + "timestamp": 1664263201138, + "version": "1.0.20" + }, + "conda-repo-cli-1.0.24-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "64326608955be11897d0b0aa2be5a45c", + "name": "conda-repo-cli", + "sha256": "3191209848e03547f301ee2c40064b117618db9e01ae310616d809582333d419", + "size": 108186, + "subdir": "linux-64", + "timestamp": 1667407605915, + "version": "1.0.24" + }, + "conda-repo-cli-1.0.24-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "466a5fc587d8f59bfcb95964aab4ba97", + "name": "conda-repo-cli", + "sha256": "e414b4629c7c22e17d8a59a0f384b2cdb99e40e0104a4f44dc624ad0a17588aa", + "size": 108154, + "subdir": "linux-64", + "timestamp": 1673359305549, + "version": "1.0.24" + }, + "conda-repo-cli-1.0.24-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "08c93755b2c358d39e50d65bf6bc7063", + "name": "conda-repo-cli", + "sha256": "0c37c750f4c66fa384c06545353fbbdd7893af0fbe0fdd3ad21031d7cca2e96e", + "size": 106530, + "subdir": "linux-64", + "timestamp": 1667407533608, + "version": "1.0.24" + }, + "conda-repo-cli-1.0.24-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e9c08baac747d595b31bc4c5e76ad645", + "name": "conda-repo-cli", + "sha256": "098ce76479ef175075f08f6f9f2df5ce9a8763a010bf243c7e3b8e0e26870d00", + "size": 106565, + "subdir": "linux-64", + "timestamp": 1673359340978, + "version": "1.0.24" + }, + "conda-repo-cli-1.0.24-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f360e577bd095608ef293b891d08d66e", + "name": "conda-repo-cli", + "sha256": "5fe9cd4f0060677bdc1b346d2eb67056e205685cce65d9bd4e635bc5b3c6f6ae", + "size": 107476, + "subdir": "linux-64", + "timestamp": 1667407496712, + "version": "1.0.24" + }, + "conda-repo-cli-1.0.24-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "edcb55b52f90fedeec0a02a2992964d7", + "name": "conda-repo-cli", + "sha256": "2ec7582df0a381967b54dd7b6a80e160cd897a237400e9de67656657a3589eab", + "size": 107364, + "subdir": "linux-64", + "timestamp": 1673359269024, + "version": "1.0.24" + }, + "conda-repo-cli-1.0.24-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "174cbc61460303105bc052d08766b7d0", + "name": "conda-repo-cli", + "sha256": "6451d0867700b847052b10ac0327c170bca92c4fc8b3f8002acbcbfe6e5b6e42", + "size": 107424, + "subdir": "linux-64", + "timestamp": 1667407570383, + "version": "1.0.24" + }, + "conda-repo-cli-1.0.24-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b834fe8462e47f9c9b7463e2e7f1b9d9", + "name": "conda-repo-cli", + "sha256": "1a24f37d5df483b7b093a78bb08cced3758ac54ea22ac604fdb49679960a6062", + "size": 107365, + "subdir": "linux-64", + "timestamp": 1673359376470, + "version": "1.0.24" + }, + "conda-repo-cli-1.0.27-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bfd257efbee043c271ecce740cbc16d2", + "name": "conda-repo-cli", + "sha256": "67ecc90496f0701b1076f56e59655a408d2dbe428cc38098ac45ea7db1603837", + "size": 109221, + "subdir": "linux-64", + "timestamp": 1673448385579, + "version": "1.0.27" + }, + "conda-repo-cli-1.0.27-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d3ba55c7b3e2a5e027bf3690d578960", + "name": "conda-repo-cli", + "sha256": "3f0f09613fdd9145ef92561c88ebd26cded6e83440771ea12b4b29340543c86b", + "size": 107513, + "subdir": "linux-64", + "timestamp": 1673448503840, + "version": "1.0.27" + }, + "conda-repo-cli-1.0.27-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e9fc39da88cc3e8d5d671d7ff10bb7c8", + "name": "conda-repo-cli", + "sha256": "48859d7761a04412b900fd13abdfb4971bf507f7ed3105e6934c97e0ef7da14b", + "size": 108358, + "subdir": "linux-64", + "timestamp": 1673448463981, + "version": "1.0.27" + }, + "conda-repo-cli-1.0.27-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5e8feea2becbcd2363fc07d363e88177", + "name": "conda-repo-cli", + "sha256": "053e1a5d7c0f7339c8f3d7c0ee5d1d733a89ffc0a1d5bfbbfa671e6edce4a914", + "size": 108414, + "subdir": "linux-64", + "timestamp": 1673448424989, + "version": "1.0.27" + }, + "conda-repo-cli-1.0.41-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "53fb9780d87779c83d6efd7a71325902", + "name": "conda-repo-cli", + "sha256": "37438ba7ee96b82d6ab8f92f06fa88d98a7be6ceae1cedf4428e2fd1e5834089", + "size": 114952, + "subdir": "linux-64", + "timestamp": 1680097362759, + "version": "1.0.41" + }, + "conda-repo-cli-1.0.41-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b9cab1a73708e461c0ae89467983ada5", + "name": "conda-repo-cli", + "sha256": "eb21109d956685b7d8681c9f45ea1e02ca5631f211616687c2a65ae8f77d6dab", + "size": 153203, + "subdir": "linux-64", + "timestamp": 1680097484072, + "version": "1.0.41" + }, + "conda-repo-cli-1.0.41-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "09e07fab8c1951bb2eed6e77874c138c", + "name": "conda-repo-cli", + "sha256": "e0718bd109db1ab68a264599f2a1938402b7bd45fc45a394da3a8436783e75ae", + "size": 114300, + "subdir": "linux-64", + "timestamp": 1680097443244, + "version": "1.0.41" + }, + "conda-repo-cli-1.0.41-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a40f9650a187b09835fe0d6f13f9f02", + "name": "conda-repo-cli", + "sha256": "a7a1ea04ce1ff487c712085cc8c30c0732e12c97bf688824e066f9748a69c499", + "size": 114296, + "subdir": "linux-64", + "timestamp": 1680097402589, + "version": "1.0.41" + }, + "conda-repo-cli-1.0.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.0", + "nbformat >=4.4.0", + "pathlib", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f9c93338c33291f4548ca2a86a163a41", + "name": "conda-repo-cli", + "sha256": "55a9c3b51cc0088a0637ac20d1fe69bc6355ef7d624eab2614b5d37c4a824986", + "size": 105475, + "subdir": "linux-64", + "timestamp": 1658947733446, + "version": "1.0.5" + }, + "conda-repo-cli-1.0.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.0", + "nbformat >=4.4.0", + "pathlib", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20da70a1645cbfcccd2c21a9385be0ab", + "name": "conda-repo-cli", + "sha256": "a0ab5659478cbb05965d0f2e4443177080c83cfc3ae3a1dade3aacb3a9185acd", + "size": 106099, + "subdir": "linux-64", + "timestamp": 1658947765034, + "version": "1.0.5" + }, + "conda-repo-cli-1.0.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.0", + "nbformat >=4.4.0", + "pathlib", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "660a326e189211734c2ded20869a7219", + "name": "conda-repo-cli", + "sha256": "bb238fba734e998e65b5b49cbb2d3e3b578b9d6fcaa9311291585fcc61d24387", + "size": 106347, + "subdir": "linux-64", + "timestamp": 1658947796374, + "version": "1.0.5" + }, + "conda-souschef-2.2.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "ruamel.yaml >=0.15.3", + "ruamel.yaml.jinja2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "34738b0b772b5ef84eed373d9e822c34", + "name": "conda-souschef", + "sha256": "cbedc009fe41e47f2a1abfcbbf13e4e82b7c4803bbdb0d9f92de62204f80a0be", + "size": 28622, + "subdir": "linux-64", + "timestamp": 1676968370202, + "version": "2.2.3" + }, + "conda-souschef-2.2.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "ruamel.yaml >=0.15.3", + "ruamel.yaml.jinja2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b104c817bad5f24c3882f6b7a2345545", + "name": "conda-souschef", + "sha256": "86514790ffc033cc2e990b186c21f4d65e4ce74931800806612c21c47984650d", + "size": 28320, + "subdir": "linux-64", + "timestamp": 1676968395373, + "version": "2.2.3" + }, + "conda-souschef-2.2.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "ruamel.yaml >=0.15.3", + "ruamel.yaml.jinja2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c62532e87de5d500cbc4ae0d1d852519", + "name": "conda-souschef", + "sha256": "6c67f6fdedd07487a9417b80056960ea06c3711355633b8ee246bee179303b09", + "size": 28334, + "subdir": "linux-64", + "timestamp": 1676968420834, + "version": "2.2.3" + }, + "conda-standalone-22.11.1-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "constrains": [ + "constructor >=3.3.1" + ], + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fb12fe1249eb371bd72dfe8de007b0e8", + "name": "conda-standalone", + "sha256": "5ab65213484303c4fbdec18abb7dbe38ab6bf617ba986102d3e8634b5e5eda7c", + "size": 12108914, + "subdir": "linux-64", + "timestamp": 1670890353460, + "version": "22.11.1" + }, + "conda-standalone-22.11.1-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "constrains": [ + "constructor >=3.3.1" + ], + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "314e5ab837682e0e4fc0157a7bbffe8e", + "name": "conda-standalone", + "sha256": "c4fe2e9db641a4c845978ee4696d5e0957be9732239c88ba2dbccbc0d1ffd33c", + "size": 12021976, + "subdir": "linux-64", + "timestamp": 1674500941975, + "version": "22.11.1" + }, + "conda-standalone-4.10.3-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3bd46331244c1156172e475d903f30cd", + "name": "conda-standalone", + "sha256": "663d035c8a963504fe8c60e30261b31a7d970062330b2d334e2463679bf630c8", + "size": 15510391, + "subdir": "linux-64", + "timestamp": 1633109786877, + "version": "4.10.3" + }, + "conda-standalone-4.10.3-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a201443c458289f1053f0d62076d213", + "name": "conda-standalone", + "sha256": "17e7dc421c5a62aeeadea501ef8173e2e8b4c2a04117cfcd8a5a1c9740b16025", + "size": 16041852, + "subdir": "linux-64", + "timestamp": 1636413551481, + "version": "4.10.3" + }, + "conda-standalone-4.7.12-hf0df95a_0.tar.bz2": { + "build": "hf0df95a_0", + "build_number": 0, + "depends": [], + "md5": "d7bcc3d67f4eee4f9a5609242b09d6da", + "name": "conda-standalone", + "sha256": "d2761203293200dec31f357df3bf99afc099f615fda5924160f09ccd1c58d0bb", + "size": 9411289, + "subdir": "linux-64", + "timestamp": 1568651214263, + "version": "4.7.12" + }, + "conda-standalone-4.7.12-hf0df95a_1.tar.bz2": { + "build": "hf0df95a_1", + "build_number": 1, + "depends": [], + "md5": "6fcd665e68d6e9f67bef8f4bf00dbaf2", + "name": "conda-standalone", + "sha256": "a296bdab50915331ebe192ffdc8d00f2bc1402cad1ed320effccac2f3bfde292", + "size": 9717804, + "subdir": "linux-64", + "timestamp": 1568729338995, + "version": "4.7.12" + }, + "conda-standalone-4.7.12-hf0df95a_2.tar.bz2": { + "build": "hf0df95a_2", + "build_number": 2, + "depends": [], + "md5": "d1d4e4b79b0d3b4901b2006ca28ad911", + "name": "conda-standalone", + "sha256": "9dedb06f9f0f6e1ffe57dca112355629e297ae98ee8bb68e73d025ce56a377c6", + "size": 9717300, + "subdir": "linux-64", + "timestamp": 1568769789325, + "version": "4.7.12" + }, + "conda-standalone-4.8.2-h2f914fc_0.tar.bz2": { + "build": "h2f914fc_0", + "build_number": 0, + "depends": [], + "md5": "6617134107a29449fb7e47d036fc7d54", + "name": "conda-standalone", + "sha256": "b7dc5f7728ac5790cc45c29bd70934cc450763d8d26a3e8f1f1f91a7a1f0a7a6", + "size": 9392776, + "subdir": "linux-64", + "timestamp": 1580834950453, + "version": "4.8.2" + }, + "conda-standalone-4.8.2-h2f914fc_1.tar.bz2": { + "build": "h2f914fc_1", + "build_number": 1, + "depends": [], + "md5": "678ca82feb420c8db0e336aa2a78e316", + "name": "conda-standalone", + "sha256": "82c1c34638a369d96f9a0ba02646baf543a889f4a6f229fcaa17b863089d4b11", + "size": 11105390, + "subdir": "linux-64", + "timestamp": 1580839585446, + "version": "4.8.2" + }, + "conda-standalone-4.8.2-h2f914fc_2.tar.bz2": { + "build": "h2f914fc_2", + "build_number": 2, + "depends": [], + "md5": "1840938ba8523a353690ec1f50f7fa8b", + "name": "conda-standalone", + "sha256": "25857f232da7e80b361da8d4f33db56eed6840445b150d5c6926ee80d8be572f", + "size": 11112791, + "subdir": "linux-64", + "timestamp": 1580848493373, + "version": "4.8.2" + }, + "conda-standalone-4.8.3-h18fab7e_0.tar.bz2": { + "build": "h18fab7e_0", + "build_number": 0, + "depends": [], + "md5": "6f804a20bb5c3f20fc2cbbaa62ce4510", + "name": "conda-standalone", + "sha256": "8846f99ef7a6fe7f4fc6d76b1468f26af7fbb5cfcbd9df795b0857cbff6554e6", + "size": 14859035, + "subdir": "linux-64", + "timestamp": 1588803227554, + "version": "4.8.3" + }, + "conda-standalone-4.8.3-h18fab7e_10.tar.bz2": { + "build": "h18fab7e_10", + "build_number": 10, + "depends": [], + "md5": "e47fc3cc2977575b556de9a7ee4e3946", + "name": "conda-standalone", + "sha256": "5943e60889724ce6517dceed78120798b1e888d73e60b60301190dfe9e6d8661", + "size": 14802535, + "subdir": "linux-64", + "timestamp": 1589825456550, + "version": "4.8.3" + }, + "conda-standalone-4.8.3-h18fab7e_11.tar.bz2": { + "build": "h18fab7e_11", + "build_number": 11, + "depends": [], + "md5": "ce27428b6f546709ba1ad74bde9737b6", + "name": "conda-standalone", + "sha256": "93eac3bf58661edc559e4e8254b163665c4d06d4ffd0053d16dadee754551594", + "size": 14817788, + "subdir": "linux-64", + "timestamp": 1589923075650, + "version": "4.8.3" + }, + "conda-standalone-4.8.3-h18fab7e_3.tar.bz2": { + "build": "h18fab7e_3", + "build_number": 3, + "depends": [], + "md5": "24274347df30b8d4b90558e70964bfda", + "name": "conda-standalone", + "sha256": "fbc44c8548159e2a6037b345d650cf4e15e547ec6b2b80c7db9356f8d2f4a6bf", + "size": 14816124, + "subdir": "linux-64", + "timestamp": 1589918334762, + "version": "4.8.3" + }, + "conda-standalone-4.8.3-h18fab7e_4.tar.bz2": { + "build": "h18fab7e_4", + "build_number": 4, + "depends": [], + "md5": "27aeaed36425c36750be960271a4073b", + "name": "conda-standalone", + "sha256": "53c94de6c45dfa5ed0112d9b265d1ffbf42fa809e82e43da77b774676ac8cb27", + "size": 14804759, + "subdir": "linux-64", + "timestamp": 1589384848878, + "version": "4.8.3" + }, + "conda-standalone-4.9.0-h718eed5_1.tar.bz2": { + "build": "h718eed5_1", + "build_number": 1, + "depends": [], + "md5": "b8b22eb4df3667802ce3ba6628f5d759", + "name": "conda-standalone", + "sha256": "2b10affebb3fbb8e0a15f0c388d93247029cb0c1e6b56d1650da5f985f903f8b", + "size": 15240449, + "subdir": "linux-64", + "timestamp": 1603137739878, + "version": "4.9.0" + }, + "conda-standalone-4.9.0-h7965325_0.tar.bz2": { + "build": "h7965325_0", + "build_number": 0, + "depends": [], + "md5": "280f1aa168ed582409188611a43979c7", + "name": "conda-standalone", + "sha256": "775bce0ec8afe28e80bdd8c99c796527fb8dfa815adc71d604852f9a34c37f52", + "size": 15240627, + "subdir": "linux-64", + "timestamp": 1603060614871, + "version": "4.9.0" + }, + "conda-verify-2.0.0-py27hf052a9d_0.tar.bz2": { + "build": "py27hf052a9d_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "23ffd2ffacf56495a3bf9690d54b2e01", + "name": "conda-verify", + "sha256": "02f4527f0caa8c2f0784e0702392579d682bb09b4323fed66831ca289b8c59a6", + "size": 20681, + "subdir": "linux-64", + "timestamp": 1505742312436, + "version": "2.0.0" + }, + "conda-verify-2.0.0-py35he912c7b_0.tar.bz2": { + "build": "py35he912c7b_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "33b6e9269f042c8afd64e4ffbb92db0e", + "name": "conda-verify", + "sha256": "1757b8634b967a02badb17752aae76ea8fee7e4d11e2e8c165fe3844cea1312d", + "size": 21187, + "subdir": "linux-64", + "timestamp": 1505742324402, + "version": "2.0.0" + }, + "conda-verify-2.0.0-py36h98955d8_0.tar.bz2": { + "build": "py36h98955d8_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "93452b121581d392dda5d6afdcf3e378", + "name": "conda-verify", + "sha256": "9e50c6a007c88b4c0c1525d0ebb0625861afc9984e8f02086a58ee30d7410317", + "size": 20955, + "subdir": "linux-64", + "timestamp": 1505742336674, + "version": "2.0.0" + }, + "conda-verify-3.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "click", + "jinja2", + "python >=2.7,<2.8.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "f65b49a783093f8c8cb0ccee7c12b8d4", + "name": "conda-verify", + "sha256": "704ab8d8bf678364659b7fa60b3f2384f086720864a3be0ddcb13b2709aad14e", + "size": 33035, + "subdir": "linux-64", + "timestamp": 1530813512607, + "version": "3.0.0" + }, + "conda-verify-3.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click", + "jinja2", + "python >=3.6,<3.7.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "b7bcda3935b76767ddebf1dbdac4205a", + "name": "conda-verify", + "sha256": "38f76c0a54e5f1ba48d480787fda8a2403fe2d2471273d4b8a19bef2d8e5d722", + "size": 33311, + "subdir": "linux-64", + "timestamp": 1530813538779, + "version": "3.0.0" + }, + "conda-verify-3.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click", + "jinja2", + "python >=3.7,<3.8.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "d5aad0ddf5fdd56bde3552b7310cab58", + "name": "conda-verify", + "sha256": "c17530f7e0dcb1d794ddf12b6c0186dc84a7359ca7ad0db51797574072a4dc1d", + "size": 33148, + "subdir": "linux-64", + "timestamp": 1530813486216, + "version": "3.0.0" + }, + "conda-verify-3.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "click", + "future", + "jinja2", + "python >=2.7,<2.8.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "c76d68f0dd9838fe9ef3ecdfc3e1d1be", + "name": "conda-verify", + "sha256": "bc4ce4507cf077c7b5c7169889ed19ae92ca356294817035f49d41f2ad3a6f45", + "size": 31598, + "subdir": "linux-64", + "timestamp": 1532368520141, + "version": "3.0.2" + }, + "conda-verify-3.0.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click", + "future", + "jinja2", + "python >=3.5,<3.6.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "381b35c33a13b92faa780634b5e665aa", + "name": "conda-verify", + "sha256": "1ee461a310532048b2b9c567d0c8c6a2f07e60a8f3a2b77e1f5149069b8a23f4", + "size": 32063, + "subdir": "linux-64", + "timestamp": 1532368526048, + "version": "3.0.2" + }, + "conda-verify-3.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click", + "future", + "jinja2", + "python >=3.6,<3.7.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "bc614594689c1c76301a08dc9bd0343f", + "name": "conda-verify", + "sha256": "5e4a605c4a2279283e27c43b523807dbb8a889812a6dd5db0596fbbcb90e2012", + "size": 31866, + "subdir": "linux-64", + "timestamp": 1532369331028, + "version": "3.0.2" + }, + "conda-verify-3.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click", + "future", + "jinja2", + "python >=3.7,<3.8.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "cc196f8861af87ec88f14441b5f968a6", + "name": "conda-verify", + "sha256": "a893e2307b945ec468c2752a43eb58ee8a31aa117dca88c1f8f0c471eb06802a", + "size": 31723, + "subdir": "linux-64", + "timestamp": 1532368529921, + "version": "3.0.2" + }, + "conda-verify-3.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3.12.0" + ], + "depends": [ + "backports.functools_lru_cache", + "click", + "future", + "jinja2", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "md5": "c5ca6b522c7f4a042239f723919ed154", + "name": "conda-verify", + "sha256": "5dd727915371f805eb095e99ae670d8df2af8556782064222b8d6ec539edb574", + "size": 32518, + "subdir": "linux-64", + "timestamp": 1532477176019, + "version": "3.1.0" + }, + "conda-verify-3.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=3.12.0" + ], + "depends": [ + "click", + "future", + "jinja2", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "md5": "7a59ae85e4d5efeade4c412a29e64bf2", + "name": "conda-verify", + "sha256": "0a69a3e452035839cb6a441c5c24e6a699af97ece0387b3346a23efcb43cbf5e", + "size": 32947, + "subdir": "linux-64", + "timestamp": 1532477341463, + "version": "3.1.0" + }, + "conda-verify-3.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3.12.0" + ], + "depends": [ + "click", + "future", + "jinja2", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "md5": "4f1c2b9ef8eb665a206a0c64949cfab1", + "name": "conda-verify", + "sha256": "0fafefe7f4b87af7de209fccf093cdb119f595b7cdda1af55a6e071f32449506", + "size": 32677, + "subdir": "linux-64", + "timestamp": 1532477103451, + "version": "3.1.0" + }, + "conda-verify-3.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3.12.0" + ], + "depends": [ + "click", + "future", + "jinja2", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "md5": "a063ebebcf7751b864bc3246721ec3f2", + "name": "conda-verify", + "sha256": "208c8a7ed0cc9be9ac70310f8484225d641851a835216176e7e158e6e11cac6f", + "size": 32602, + "subdir": "linux-64", + "timestamp": 1532477336284, + "version": "3.1.0" + }, + "conda-verify-3.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "click", + "future", + "jinja2", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "md5": "7dc3b166185688f63199d375303b12c7", + "name": "conda-verify", + "sha256": "363b8bf0caf1800e679961e1833b3cc32cad27ce295bbbec60d698194335b855", + "size": 33546, + "subdir": "linux-64", + "timestamp": 1538577299333, + "version": "3.1.1" + }, + "conda-verify-3.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click", + "future", + "jinja2", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "md5": "04cc383c469472ee89cfe3db3a7dcec4", + "name": "conda-verify", + "sha256": "8dbebbd0e18b1cabb48ce44b6df034df5527ffb24e1cd6e94d698e34216ca9da", + "size": 33780, + "subdir": "linux-64", + "timestamp": 1538577323205, + "version": "3.1.1" + }, + "conda-verify-3.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click", + "future", + "jinja2", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "md5": "96942208aef5ae1d9dcc192b9988793d", + "name": "conda-verify", + "sha256": "be5d5c783eab2d1ff1fe253a116cfa2b00804501dd6e9df647a89395535f57cf", + "size": 33675, + "subdir": "linux-64", + "timestamp": 1538577289685, + "version": "3.1.1" + }, + "conda-verify-3.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click", + "conda-package-handling >=1.1", + "future", + "jinja2", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "md5": "11efd1899ed354dc8646b5ced13a54aa", + "name": "conda-verify", + "sha256": "c2d2139625f5be857e3d15a106a2139ef3b45e6bfcbe78a6bb6e6ed9ab3b53eb", + "size": 42057, + "subdir": "linux-64", + "timestamp": 1558494699381, + "version": "3.3.0" + }, + "conda-verify-3.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click", + "conda-package-handling >=1.1", + "future", + "jinja2", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "md5": "4533fb741c7ac8d21f363a0cd4cc0aa0", + "name": "conda-verify", + "sha256": "71ca030b86bb8408a697b24d0ca4c639c5bdadc8221a07d2b14d4e392bea6025", + "size": 41910, + "subdir": "linux-64", + "timestamp": 1558494663395, + "version": "3.3.0" + }, + "configargparse-0.13.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "36a9dc5035cd1b1a4003c343fe545696", + "name": "configargparse", + "sha256": "7ee3b377bc68d1c2bb33c51ec09b9567d167155616ab07be795caae9ff0e1de0", + "size": 27011, + "subdir": "linux-64", + "timestamp": 1519234653753, + "version": "0.13.0" + }, + "configargparse-0.13.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d7df2321f4dd5a4c30a7ad478d02c33", + "name": "configargparse", + "sha256": "f0ce33be56f25b32a20ae63541a6fbda076cc823d918c3814cb5d6e632f65a01", + "size": 27564, + "subdir": "linux-64", + "timestamp": 1519234677274, + "version": "0.13.0" + }, + "configargparse-0.13.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c7aaf156d17142a8134904cc9b04ba4d", + "name": "configargparse", + "sha256": "0dd2e10d81688b9202007ce29ea7286a68853ec9c1e6f3eaa43c3a5e9539be87", + "size": 27465, + "subdir": "linux-64", + "timestamp": 1519234639828, + "version": "0.13.0" + }, + "configargparse-0.13.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6004406e102216f57d947554f1f46e83", + "name": "configargparse", + "sha256": "c33e8a7d17493fd7061aee8fdb333d59ab611566815ed0261df633078069f39e", + "size": 27429, + "subdir": "linux-64", + "timestamp": 1530813884739, + "version": "0.13.0" + }, + "configargparse-0.14.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6714a81e781a3f284a47b0f195a2fc83", + "name": "configargparse", + "sha256": "4e6af22867a70ffa7412ab0b1c98ec32c6aeafea01e82ed4cd0faeb3108261b9", + "size": 27979, + "subdir": "linux-64", + "timestamp": 1547748480072, + "version": "0.14.0" + }, + "configargparse-0.14.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b86b87f372f2a7916da69c6fc8fb607", + "name": "configargparse", + "sha256": "af585dc0d6e3e79bb712ab0834775599704d7f8cc6c8ebfbc4fce67d62637227", + "size": 28437, + "subdir": "linux-64", + "timestamp": 1547748596009, + "version": "0.14.0" + }, + "configargparse-0.14.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f755b25b0ee283f5d292fa0e26da3b1", + "name": "configargparse", + "sha256": "52901bea6cee778423287b014b61f4d7eb47aef470c327024188d99a1c17b551", + "size": 28413, + "subdir": "linux-64", + "timestamp": 1547748530722, + "version": "0.14.0" + }, + "configargparse-0.14.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48fc25b2a90ca53beca9542d86388f24", + "name": "configargparse", + "sha256": "55bca8b48eeab04126b057ce3643ece3d26811c50f28e5c511ba869c1adf26c7", + "size": 27847, + "subdir": "linux-64", + "timestamp": 1573033889842, + "version": "0.14.0" + }, + "configobj-5.0.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "34725be0c48874320dd296e910efd067", + "name": "configobj", + "sha256": "b81ae1133b05c6379dee3dbb1391c3de93d9584148729de8bb5a9a6d26e7bdb7", + "size": 54294, + "subdir": "linux-64", + "timestamp": 1530873786650, + "version": "5.0.6" + }, + "configobj-5.0.6-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "589c26db4dd957d798e003b1a9605270", + "name": "configobj", + "sha256": "e492e05297c9edbbe15d17d0bef7eb15b7b74cb86e9525e69a2230242ec83853", + "size": 54508, + "subdir": "linux-64", + "timestamp": 1536253505757, + "version": "5.0.6" + }, + "configobj-5.0.6-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "30339ab508640373043df18e9dbf9b19", + "name": "configobj", + "sha256": "070e2fb02aff683410c6384520e98ff786cc34356187b67f4e716584f7427338", + "size": 56057, + "subdir": "linux-64", + "timestamp": 1640789131410, + "version": "5.0.6" + }, + "configobj-5.0.6-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "27e5dbba606be94a0d5d7a096940b47f", + "name": "configobj", + "sha256": "5a97a11697a69ba9e0d992989d8a1075b59d3cbc4e7ef81a99c3f980c2be5a24", + "size": 72495, + "subdir": "linux-64", + "timestamp": 1676907020713, + "version": "5.0.6" + }, + "configobj-5.0.6-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "d68ce230f2713a7e2318eb4198b31675", + "name": "configobj", + "sha256": "0a21c2c19b515b36b2a503cf431292c97cea520a018b5f5c947720529fcfd6b3", + "size": 55621, + "subdir": "linux-64", + "timestamp": 1536253608349, + "version": "5.0.6" + }, + "configobj-5.0.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "7fb46ce9c47166914413af2e1359b507", + "name": "configobj", + "sha256": "075905dacf217249f59988530705a55481c41b45835d1ddbd92ec19633acf8bb", + "size": 55367, + "subdir": "linux-64", + "timestamp": 1530873826694, + "version": "5.0.6" + }, + "configobj-5.0.6-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "16cd9cb4fd917307ec673758efd07eb9", + "name": "configobj", + "sha256": "be391074dcf3dc668dbcac9cdec850f5d2972e661140ba82becdf32173793f73", + "size": 55511, + "subdir": "linux-64", + "timestamp": 1536253465708, + "version": "5.0.6" + }, + "configobj-5.0.6-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "8fb5b090aa63583abdb284eafa3645b6", + "name": "configobj", + "sha256": "89e8d0804c10acb8b1fc080b5937be54c277b8d2da37d528ba3c7f2b26051d89", + "size": 284874, + "subdir": "linux-64", + "timestamp": 1613569037550, + "version": "5.0.6" + }, + "configobj-5.0.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "448c158bb186568d6289b1f325f70da5", + "name": "configobj", + "sha256": "553653eb3ced235d66186a8cb25b264eaa2b947614bd1e5acc74362885f7b216", + "size": 55450, + "subdir": "linux-64", + "timestamp": 1530873806285, + "version": "5.0.6" + }, + "configobj-5.0.6-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "74775e239d3b7daf7ab3f5005c469b73", + "name": "configobj", + "sha256": "8a83f19c52cb770030c793c934f2e66238086742048ae634c1cd1f6794db8b42", + "size": 55528, + "subdir": "linux-64", + "timestamp": 1536253561220, + "version": "5.0.6" + }, + "configobj-5.0.6-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "3128445b48c683687d56371ec08a6c57", + "name": "configobj", + "sha256": "1a2f043dc995cab41fdafba449eb859d930943fd1b147694691e79dc3476cb4b", + "size": 274457, + "subdir": "linux-64", + "timestamp": 1613569045423, + "version": "5.0.6" + }, + "configobj-5.0.6-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "899de829f843f5f5365d69fa43950188", + "name": "configobj", + "sha256": "03963d0c5ffdba3b224d58f66d850c8188fb947b02a30dd5aa11ad5c92d72216", + "size": 56061, + "subdir": "linux-64", + "timestamp": 1573741588157, + "version": "5.0.6" + }, + "configobj-5.0.6-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "1627f025f4f2b7567c8b01b5e2a9debb", + "name": "configobj", + "sha256": "af95eac123bb9fba76d95f21600cd76bbd69572c3d9897059690fa088003430d", + "size": 276975, + "subdir": "linux-64", + "timestamp": 1613569044972, + "version": "5.0.6" + }, + "configobj-5.0.6-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "3038f1f304635f6e302e227adb760d1f", + "name": "configobj", + "sha256": "3d84da4a62863ae8b095017e68b662e6598b113f146463a27c4a044cb760a85e", + "size": 274816, + "subdir": "linux-64", + "timestamp": 1613569380078, + "version": "5.0.6" + }, + "configparser-3.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7a00eece50a5dcecc7143665c80840e8", + "name": "configparser", + "sha256": "5319ff5c678f5dbbf4dab380b1a364fbd6d2cce30b94ff23ea970092d5c69303", + "size": 35557, + "subdir": "linux-64", + "timestamp": 1530735395257, + "version": "3.5.0" + }, + "configparser-3.5.0-py27h5117587_0.tar.bz2": { + "build": "py27h5117587_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b7d0caac489b6f689117fcde185f9743", + "name": "configparser", + "sha256": "6bc8e65a13568fa2f62a786399eb45f63d9fe4fff3ebf1425ab47bff8de30f41", + "size": 35360, + "subdir": "linux-64", + "timestamp": 1505689796307, + "version": "3.5.0" + }, + "configparser-3.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0c073a1dd2024b41c1c44913a2bfead1", + "name": "configparser", + "sha256": "26398af78ef89d6af8a3b9bba954073574986ff939baabf215d98891ee48ab94", + "size": 40079, + "subdir": "linux-64", + "timestamp": 1579721071171, + "version": "3.5.0" + }, + "configparser-3.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "73a099f4bde249d7d29ac9da1acdebb4", + "name": "configparser", + "sha256": "d34e4b06e072858cfdb64492d33a0425732648492890920fb6c808f4f4c2c4f3", + "size": 40101, + "subdir": "linux-64", + "timestamp": 1579721036418, + "version": "3.5.0" + }, + "configparser-3.7.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "981efd8a48b53767866006e53b5b82c7", + "name": "configparser", + "sha256": "4073e0fc52e08352b22aa380751ce6ad12d661ffc8d33f97dff2867d60244f6b", + "size": 38639, + "subdir": "linux-64", + "timestamp": 1549648425089, + "version": "3.7.1" + }, + "configparser-3.7.3-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "17b9ac2f3cbbc54f775b2c907bd454f4", + "name": "configparser", + "sha256": "0d653bb0e7c9811c6af9ef4b01832de1cd32c16b983b0c239be43da2e5f22cad", + "size": 42090, + "subdir": "linux-64", + "timestamp": 1552338780932, + "version": "3.7.3" + }, + "configparser-3.7.3-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f8c97f4d5467bf29e7f2c0e76d598be5", + "name": "configparser", + "sha256": "5aeab885059f0242d8c2c78387cafd978a71bdb726999def08b60672ecd518d4", + "size": 42687, + "subdir": "linux-64", + "timestamp": 1552338801017, + "version": "3.7.3" + }, + "configparser-3.7.3-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2b5c228efbbf9c0869df69a7cbdc6263", + "name": "configparser", + "sha256": "55a8fa7fd226de6c0bce137d8e5781fd7c900695ebba07387c5ac92d6e3c6067", + "size": 42694, + "subdir": "linux-64", + "timestamp": 1552338761870, + "version": "3.7.3" + }, + "configparser-3.7.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "1c0f1671dc44b87a6eaf05370d515ae8", + "name": "configparser", + "sha256": "087d072cea05278dfd7ecdd451d73ddb47b515eb76ab634f3193608d7108250c", + "size": 42477, + "subdir": "linux-64", + "timestamp": 1556052027827, + "version": "3.7.4" + }, + "configparser-3.7.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8a08cfd8b1f7f26afcba4b6e6125b875", + "name": "configparser", + "sha256": "b422d4bb7714638f5fa722d29e8dba25f3f8f7ef6050df544678325d21304c29", + "size": 43096, + "subdir": "linux-64", + "timestamp": 1556051918897, + "version": "3.7.4" + }, + "configparser-3.7.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f980d921c4213b3a8ad55c0201722081", + "name": "configparser", + "sha256": "71907678f88fcb7309bf592937f0abd767fddb25024aeea42992cc32279baedd", + "size": 43108, + "subdir": "linux-64", + "timestamp": 1556052012234, + "version": "3.7.4" + }, + "configparser-3.7.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "77d5e851f00090a390bed4f6eaba2914", + "name": "configparser", + "sha256": "f0cb89226c0f582444a763758671dc4eb1d35d7aede55b8f5d078a7ad9e9439b", + "size": 39411, + "subdir": "linux-64", + "timestamp": 1574092505714, + "version": "3.7.4" + }, + "configparser-4.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "fab0d0987afb4a8d629c797cc600c501", + "name": "configparser", + "sha256": "db3eef6462d5408e30e68683caa1590c8f5aac4b3443413f88a315faed2144b2", + "size": 43396, + "subdir": "linux-64", + "timestamp": 1569428663733, + "version": "4.0.2" + }, + "configspace-0.4.19-py310h9102076_0.tar.bz2": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "pyparsing", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a0124b9a29bab79ea679e5558f4b447e", + "name": "configspace", + "sha256": "5e2d82725e921feeaaff9205d3fdc67974364dce1e7555645347024d488566ac", + "size": 3429826, + "subdir": "linux-64", + "timestamp": 1640789200266, + "version": "0.4.19" + }, + "configspace-0.4.19-py311hbed6279_0.tar.bz2": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "pyparsing", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9cadbbdb321a7f579274ae329ab3c781", + "name": "configspace", + "sha256": "7941157cdbf3e032e075b1d1a593a77ad2121bb2224cacc8da6885be762b0450", + "size": 824216, + "subdir": "linux-64", + "timestamp": 1676851436182, + "version": "0.4.19" + }, + "configspace-0.4.19-py37hce1f21e_0.tar.bz2": { + "build": "py37hce1f21e_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "pyparsing", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ed821c2cd50b844a4eba029ea4007cf6", + "name": "configspace", + "sha256": "96d8e95799fc1c7ff9b3bfb9319c30644ab672b1f3743081bebc0d0194a53dc4", + "size": 767954, + "subdir": "linux-64", + "timestamp": 1633556300043, + "version": "0.4.19" + }, + "configspace-0.4.19-py38hce1f21e_0.tar.bz2": { + "build": "py38hce1f21e_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "pyparsing", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f0a62baa0765439da23919317ecca5cd", + "name": "configspace", + "sha256": "e995ec2e4b4d664518dd9a86b92264403efa5426a35c9c87454b46dc0540db56", + "size": 834777, + "subdir": "linux-64", + "timestamp": 1633556308775, + "version": "0.4.19" + }, + "configspace-0.4.19-py39hce1f21e_0.tar.bz2": { + "build": "py39hce1f21e_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "pyparsing", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "80fc0fa1fba474efc5804dfdbf04104e", + "name": "configspace", + "sha256": "19d0e7e984aa3d1140eef48f1a42dcb0a618926e77dce0d77485a13c0ce892ed", + "size": 836392, + "subdir": "linux-64", + "timestamp": 1633556303512, + "version": "0.4.19" + }, + "configupdater-3.1.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ab3ce345b9dedd82e52df728ad64c29", + "name": "configupdater", + "sha256": "7f1dcb71ef440cd013e346f4059998710a663fa6c67e2618299967cd0413f645", + "size": 59481, + "subdir": "linux-64", + "timestamp": 1668698060423, + "version": "3.1.1" + }, + "configupdater-3.1.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5fdece53136b058f0f980a9ea92c66c", + "name": "configupdater", + "sha256": "b2fcca5e5b4069f2cf1287f85d97547230d354e4842e34f15679a726ab395435", + "size": 72332, + "subdir": "linux-64", + "timestamp": 1676830339876, + "version": "3.1.1" + }, + "configupdater-3.1.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f868a75e7064cb33660f6ce014ff328", + "name": "configupdater", + "sha256": "902ea72b3093e44bd78211d3861e1d9ebb57d4059e66767591d6c90f6743f91f", + "size": 58920, + "subdir": "linux-64", + "timestamp": 1668698157539, + "version": "3.1.1" + }, + "configupdater-3.1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bf7147cf4c83bcf5fd9131eea29b187b", + "name": "configupdater", + "sha256": "557d5f952cfde43f75c72a017772ec09605e3ed5e9ca6e8a6d7fc5394fda7d8a", + "size": 59211, + "subdir": "linux-64", + "timestamp": 1668698092450, + "version": "3.1.1" + }, + "configupdater-3.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5aea1b7a616d61c6e07e556e2ac8626", + "name": "configupdater", + "sha256": "cbe506144fa51e540ce546d022062d8e75266d97ffd9b3e26d6bc31885cb3f5b", + "size": 59131, + "subdir": "linux-64", + "timestamp": 1668698124697, + "version": "3.1.1" + }, + "configurable-http-proxy-4.0.1-node14_0.tar.bz2": { + "build": "node14_0", + "build_number": 0, + "depends": [ + "nodejs 14.*" + ], + "license": "BSD 3-Clause", + "md5": "455cfc759f2400b0ada98bff172dd8ec", + "name": "configurable-http-proxy", + "sha256": "bbb8efe4bbe5d87617c763b4ad20bd51977d5cf871fb9b04df1691fb59c83ca7", + "size": 820251, + "subdir": "linux-64", + "timestamp": 1615897252510, + "version": "4.0.1" + }, + "configurable-http-proxy-4.0.1-node6_0.tar.bz2": { + "build": "node6_0", + "build_number": 0, + "depends": [ + "nodejs 6.*" + ], + "license": "BSD 3-Clause", + "md5": "b21f88480b58aaf185b584b1e9f440f7", + "name": "configurable-http-proxy", + "sha256": "019c3033d42204a41c30764a5673d7b972a7ddd161173c02063b5c494537ff3d", + "size": 859219, + "subdir": "linux-64", + "timestamp": 1540825003021, + "version": "4.0.1" + }, + "connexion-2.14.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "clickclick >=1.2,<21", + "flask >=1.0.4,<3", + "importlib-metadata >=1", + "inflection >=0.3.1,<0.6", + "itsdangerous >=0.24", + "jsonschema >=2.5.1,<5", + "packaging >=20", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.1,<7", + "requests >=2.9.1,<3", + "werkzeug >=1.0,<3.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b39f84f6215703ec79ecf62fe2ac14a1", + "name": "connexion", + "sha256": "c19dc300072155bfdc88650db02432fff9e7dddab80e0c704bee66c38515bbc1", + "size": 125558, + "subdir": "linux-64", + "timestamp": 1659800904054, + "version": "2.14.0" + }, + "connexion-2.14.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "clickclick >=1.2,<21", + "flask >=1.0.4,<3", + "importlib-metadata >=1", + "inflection >=0.3.1,<0.6", + "itsdangerous >=0.24", + "jsonschema >=2.5.1,<5", + "packaging >=20", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.1,<7", + "requests >=2.9.1,<3", + "werkzeug >=1.0,<3.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "260e223a6b63c248eaa248a39c0eeaad", + "name": "connexion", + "sha256": "16289d278e6aa181500d73ee2d0af021a7f2aa00f5784ce2a35c8ad853817e1e", + "size": 161748, + "subdir": "linux-64", + "timestamp": 1676830354651, + "version": "2.14.0" + }, + "connexion-2.14.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "clickclick >=1.2,<21", + "flask >=1.0.4,<3", + "importlib-metadata >=1", + "inflection >=0.3.1,<0.6", + "itsdangerous >=0.24", + "jsonschema >=2.5.1,<5", + "packaging >=20", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1,<7", + "requests >=2.9.1,<3", + "werkzeug >=1.0,<3.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "01d4ee202dadc26f87afdd49636b8eec", + "name": "connexion", + "sha256": "403b4987ae03bd50e8d1e2d81351f912a531e1cc4e15b6ab7292c183e9160121", + "size": 123814, + "subdir": "linux-64", + "timestamp": 1659800783936, + "version": "2.14.0" + }, + "connexion-2.14.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "clickclick >=1.2,<21", + "flask >=1.0.4,<3", + "importlib-metadata >=1", + "inflection >=0.3.1,<0.6", + "itsdangerous >=0.24", + "jsonschema >=2.5.1,<5", + "packaging >=20", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1,<7", + "requests >=2.9.1,<3", + "werkzeug >=1.0,<3.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "40b503b4f1aebc512794169a56ad4637", + "name": "connexion", + "sha256": "a410c5a7328086b5984eefca3ab757a48aa871251dea6c6ad13f5f1328ae5443", + "size": 124433, + "subdir": "linux-64", + "timestamp": 1659800857090, + "version": "2.14.0" + }, + "connexion-2.14.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "clickclick >=1.2,<21", + "flask >=1.0.4,<3", + "importlib-metadata >=1", + "inflection >=0.3.1,<0.6", + "itsdangerous >=0.24", + "jsonschema >=2.5.1,<5", + "packaging >=20", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1,<7", + "requests >=2.9.1,<3", + "werkzeug >=1.0,<3.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ae8ef8441fcdd28d086d706341c1ba33", + "name": "connexion", + "sha256": "cad845f0fea78bd74c482ace2febcb95d2ae7a8b0060e89cab17141d8b768a55", + "size": 124414, + "subdir": "linux-64", + "timestamp": 1659800822802, + "version": "2.14.0" + }, + "console_shortcut-0.1.1-3.tar.bz2": { + "build": "3", + "build_number": 3, + "depends": [ + "python" + ], + "license": "BSD", + "md5": "aecbcef5b279ec5e5bfb9e746107c875", + "name": "console_shortcut", + "sha256": "7eefa2803b9c46e856d6f9830021336e4a2f1c15677ff3c1c1bf3bb6112bc665", + "size": 50850, + "subdir": "linux-64", + "timestamp": 1530813902156, + "version": "0.1.1" + }, + "constantly-15.1.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5fff3f13a6c16dd37a1c9b23c2701435", + "name": "constantly", + "sha256": "b0fafdbcfbc897d13cd53672cf2ed20c327d1489dfa85c3f1d1c6b58cb5bebb3", + "size": 13243, + "subdir": "linux-64", + "timestamp": 1530919567946, + "version": "15.1.0" + }, + "constantly-15.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f8f4603e2aabd70f24a926d934d5b88", + "name": "constantly", + "sha256": "62d6b43a4121657f248357238cb06bdce0f9d273b6e014b7487dfd75a000543a", + "size": 16425, + "subdir": "linux-64", + "timestamp": 1642674446154, + "version": "15.1.0" + }, + "constantly-15.1.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f84925a3b7b7aba3f81b5998d9938957", + "name": "constantly", + "sha256": "610403b5452071a92be86549ac9ff21cfac64204cd07fc99e1ce478711181447", + "size": 16208, + "subdir": "linux-64", + "timestamp": 1676839224336, + "version": "15.1.0" + }, + "constantly-15.1.0-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33f6ac5fea29d4541378d2a4ab3cea37", + "name": "constantly", + "sha256": "025fa70017fffc174d617ebc5c72d90925f66a6dfdf7996c8d6dad090078afd7", + "size": 13454, + "subdir": "linux-64", + "timestamp": 1534351178434, + "version": "15.1.0" + }, + "constantly-15.1.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8f694af41c7ad0aa10c2f4e66ad6691", + "name": "constantly", + "sha256": "fdfbee50b2f06d5d2ed0969fa0f9dc4d76b8f3d255ac22f88fdc4525f830e3e8", + "size": 13507, + "subdir": "linux-64", + "timestamp": 1530919512568, + "version": "15.1.0" + }, + "constantly-15.1.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08f8e8410acf767da669c06ba0bbadff", + "name": "constantly", + "sha256": "cc8c3c81ed995a60739274a3cf28c02e9a3445c7fb8501dd711f73e8895ce71d", + "size": 13488, + "subdir": "linux-64", + "timestamp": 1530919540343, + "version": "15.1.0" + }, + "constructor-2.0.0-py27haf0e89a_0.tar.bz2": { + "build": "py27haf0e89a_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=2.7,<2.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6642c6d35c88c8607f198bd8360986e3", + "name": "constructor", + "sha256": "f5a810457ae41316fbec2cf92b8cc82b066fa90958abfa07f2455e8c58883c92", + "size": 62415, + "subdir": "linux-64", + "timestamp": 1509559416724, + "version": "2.0.0" + }, + "constructor-2.0.0-py35ha65c8be_0.tar.bz2": { + "build": "py35ha65c8be_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.5,<3.6.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5a1257b4273d6821164a92715c07b370", + "name": "constructor", + "sha256": "9298edc26414cd039c5f5308a91a94e2843e0137167fb84f685138fb7fd119b2", + "size": 63124, + "subdir": "linux-64", + "timestamp": 1509559394310, + "version": "2.0.0" + }, + "constructor-2.0.0-py36ha402fbe_0.tar.bz2": { + "build": "py36ha402fbe_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.6,<3.7.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c910079f8b25c2c0ba4c12161c323d75", + "name": "constructor", + "sha256": "2066893db4d49407ef9c88e722fba946f09eb38fdebcef496ae1ae3d45602b3b", + "size": 62774, + "subdir": "linux-64", + "timestamp": 1509559422628, + "version": "2.0.0" + }, + "constructor-2.0.1-py27h4bcccf3_0.tar.bz2": { + "build": "py27h4bcccf3_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=2.7,<2.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "240ccecf8f073b1a09e11aee7e825a14", + "name": "constructor", + "sha256": "4648178bb584fd8feb4c41ec32fafb708f90eef96c84bca992fe0a94d836a563", + "size": 64066, + "subdir": "linux-64", + "timestamp": 1510776132861, + "version": "2.0.1" + }, + "constructor-2.0.1-py35h64a88dd_0.tar.bz2": { + "build": "py35h64a88dd_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.5,<3.6.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e74474d691dd996b15db2e0de21fe78f", + "name": "constructor", + "sha256": "4d79864f381a93ac17f52175cc9fae628710ffa064cb786424b05ba5b2ba0bb1", + "size": 64789, + "subdir": "linux-64", + "timestamp": 1510776142709, + "version": "2.0.1" + }, + "constructor-2.0.1-py36hb4fd3a0_0.tar.bz2": { + "build": "py36hb4fd3a0_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.6,<3.7.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "24b244cae17a42da14540fbafc962886", + "name": "constructor", + "sha256": "803d801b239d9875d4d7cc2e453dc8db22829d8a32ebad1ac344f5fbe73bfe42", + "size": 64436, + "subdir": "linux-64", + "timestamp": 1510776138613, + "version": "2.0.1" + }, + "constructor-2.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=2.7,<2.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a64a220d1ed66ce96ff2b2a8f3e68137", + "name": "constructor", + "sha256": "adfceaae231a5922cb2b545340b2b6af7a7fed13bd57956bc5471b541f57c653", + "size": 64275, + "subdir": "linux-64", + "timestamp": 1517439331140, + "version": "2.0.2" + }, + "constructor-2.0.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.5,<3.6.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bc8764f434ddc91562fc4d89538a6f85", + "name": "constructor", + "sha256": "aabd3f003fd15d9655f9dd735158b6a62e56e583addf6a7602d7e7ac671af432", + "size": 65003, + "subdir": "linux-64", + "timestamp": 1517439349720, + "version": "2.0.2" + }, + "constructor-2.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.6,<3.7.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "00f21bd115620049363d07e5818ee790", + "name": "constructor", + "sha256": "4a8f5b943de014a52cf24eb8d2a246c63491d4902a4fd3a4df230313b165c7b5", + "size": 64601, + "subdir": "linux-64", + "timestamp": 1517439349871, + "version": "2.0.2" + }, + "constructor-2.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=2.7,<2.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f10da352ccdee302aaf843b3d8520b3b", + "name": "constructor", + "sha256": "1ef589d5181eab0ae31b666548952d8266fe67b160dd1b56887f89ac7e03d7ce", + "size": 63924, + "subdir": "linux-64", + "timestamp": 1522809945821, + "version": "2.0.3" + }, + "constructor-2.0.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.5,<3.6.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "51876cb78224ba64269c02052b204f51", + "name": "constructor", + "sha256": "2ceb8087fe3bc65784bb9292a9f715aff004b85e7016bea915bf0ec95794ed64", + "size": 64599, + "subdir": "linux-64", + "timestamp": 1522810050745, + "version": "2.0.3" + }, + "constructor-2.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.6,<3.7.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2ca3c17d583ea8e8cd44384528080d5f", + "name": "constructor", + "sha256": "7d0c61e4f2a0589e18a710f06f9e0bea2836e602d7a1a48a503814c581d9ccb3", + "size": 64315, + "subdir": "linux-64", + "timestamp": 1522810070010, + "version": "2.0.3" + }, + "constructor-2.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=2.7,<2.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5dfe5aecae1b2e5351bedcc59d3e621a", + "name": "constructor", + "sha256": "dbb0ab05f6e3ea2b8a236d7f5af3d64afc00c80e94a5e964f93f1c69652379ac", + "size": 65146, + "subdir": "linux-64", + "timestamp": 1528315605194, + "version": "2.1.0" + }, + "constructor-2.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.5,<3.6.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "998b06a217aa118cc1ab2110bf777b7d", + "name": "constructor", + "sha256": "a0541f99a1021ea8776a9879620b294d1e813128929e1f8fb608ad9d4d99b18e", + "size": 65893, + "subdir": "linux-64", + "timestamp": 1528315645744, + "version": "2.1.0" + }, + "constructor-2.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.6,<3.7.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "51e9aebfda87df79c0c08bbf0d68e340", + "name": "constructor", + "sha256": "1e13c0e6fd46fe98a01864bc69eee1571ee5e15167fc61f66c7125b428ef9262", + "size": 65515, + "subdir": "linux-64", + "timestamp": 1528315599463, + "version": "2.1.0" + }, + "constructor-2.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.7,<3.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "50224601295ae75a716d66822ea9283f", + "name": "constructor", + "sha256": "df8472880327e581cac0854acfbbf35dc215ae900f54a9e3be4313dca804d48e", + "size": 65429, + "subdir": "linux-64", + "timestamp": 1530813925250, + "version": "2.1.0" + }, + "constructor-2.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=2.7,<2.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ea407a372b111809702f12ce68c760e1", + "name": "constructor", + "sha256": "4f62d68d9e2a9a8644d1772f6b766cfb52fad6b1c98fe59e0486f313c4c8bf1f", + "size": 65173, + "subdir": "linux-64", + "timestamp": 1531548857486, + "version": "2.1.1" + }, + "constructor-2.1.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.5,<3.6.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "90030e3cb7510687f6f649f1d2183c63", + "name": "constructor", + "sha256": "481e8eb2f66a4a72a2f7d54f67585ddeff6f4f2bab9a26ff3bbd41b5573c8377", + "size": 65889, + "subdir": "linux-64", + "timestamp": 1531548914172, + "version": "2.1.1" + }, + "constructor-2.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.6,<3.7.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a74bf3c51db4e24bfb7986e931bfdc39", + "name": "constructor", + "sha256": "df4ff9fe0b62228b56603696e0104e17c911383addd0bb155f34533ba1ec5120", + "size": 65571, + "subdir": "linux-64", + "timestamp": 1531548914962, + "version": "2.1.1" + }, + "constructor-2.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.7,<3.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "048373c36109a758e6e69d6c1217952e", + "name": "constructor", + "sha256": "530ac12d34eda0c91fa7b5cec8729d012c2190c939fc9a8b9184cb9687460190", + "size": 65520, + "subdir": "linux-64", + "timestamp": 1531548885182, + "version": "2.1.1" + }, + "constructor-2.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda >=4.5", + "python >=2.7,<2.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2adaa7a4ee338fbfffdffc5a2a32e09c", + "name": "constructor", + "sha256": "f5d1af732310b3221f3a58e32207efb645169c21f7513c4e3030198d507d9268", + "size": 65086, + "subdir": "linux-64", + "timestamp": 1538579959870, + "version": "2.2.0" + }, + "constructor-2.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda >=4.5", + "python >=3.6,<3.7.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7a72aa853fadc443ed0632f3cc90f9f5", + "name": "constructor", + "sha256": "6df0acf870a9aa14ac4994a221f90ef18a3e0f94e61833dee7beac1e73c34526", + "size": 65502, + "subdir": "linux-64", + "timestamp": 1538579984058, + "version": "2.2.0" + }, + "constructor-2.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "conda >=4.5", + "python >=3.7,<3.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a3a9e507dc80754e9b9a96b1ee57567f", + "name": "constructor", + "sha256": "e3a7e99a959555073122f44ace0429bc1aac81c7e7cee3c33d8318131aebd214", + "size": 65515, + "subdir": "linux-64", + "timestamp": 1538579945128, + "version": "2.2.0" + }, + "constructor-2.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda >=4.5", + "python >=2.7,<2.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3aba74551f989a0cf40fb06451a366b0", + "name": "constructor", + "sha256": "e6a202a28d60544628f6b29006aaa7df17eff1c3a7ad9f6c47313ae9c1775aaa", + "size": 68535, + "subdir": "linux-64", + "timestamp": 1541804751464, + "version": "2.3.0" + }, + "constructor-2.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda >=4.5", + "python >=3.6,<3.7.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cb1069d14d842a4c11289c75c02aceff", + "name": "constructor", + "sha256": "13b2242dd106a2bcc843e9918001c1fe011cc15b7cf3f089dacf3a056b0973be", + "size": 68766, + "subdir": "linux-64", + "timestamp": 1541804810464, + "version": "2.3.0" + }, + "constructor-2.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "conda >=4.5", + "python >=3.7,<3.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "00bc9855dccc9c34859c0d89533df1bd", + "name": "constructor", + "sha256": "ee64bbf1a62efb5922f24524cdeea7602905a3c78ef80e1e73d791b3022130e9", + "size": 68728, + "subdir": "linux-64", + "timestamp": 1541804766232, + "version": "2.3.0" + }, + "constructor-3.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda >=4.6,<23.1.0a0", + "python >=2.7,<2.8.0a0", + "ruamel_yaml" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "51814a36c15445fd11ca44114337f08f", + "name": "constructor", + "sha256": "f48818da7fe3e80612fa83a984ee6fc78f226fd3b6ea5548232239a75d5b0d48", + "size": 9281437, + "subdir": "linux-64", + "timestamp": 1565473506003, + "version": "3.0.0" + }, + "constructor-3.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda >=4.6,<23.1.0a0", + "python >=3.6,<3.7.0a0", + "ruamel_yaml" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b2775eb3a3fab72f8b4f9ae841242372", + "name": "constructor", + "sha256": "a2ff80c427b297e026911949553c0944673d09018d64dbf4ad86eaf7bafee4d1", + "size": 9295447, + "subdir": "linux-64", + "timestamp": 1565473531433, + "version": "3.0.0" + }, + "constructor-3.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "conda >=4.6,<23.1.0a0", + "python >=3.7,<3.8.0a0", + "ruamel_yaml" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c57e4d1ded0b24e2839426c932a136df", + "name": "constructor", + "sha256": "7983699556946ecade19ff1097abc9d1660827d193d9cd3c60e7a5974eaffd82", + "size": 9295725, + "subdir": "linux-64", + "timestamp": 1565473281401, + "version": "3.0.0" + }, + "constructor-3.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.6,<3.7.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9110d32543a4951983e0a434240a995b", + "name": "constructor", + "sha256": "65137022e5094f98731b8616cb1b3c1bee90398ecef3bf3ad7e6d093f8896e82", + "size": 74889, + "subdir": "linux-64", + "timestamp": 1598031184213, + "version": "3.0.1" + }, + "constructor-3.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.7,<3.8.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "61db7339af92608a9d3468e4d9724cdb", + "name": "constructor", + "sha256": "75d627d13cec101df5a440dfb825a385eefff12a3f8c41fb32ae6ddc04604299", + "size": 74817, + "subdir": "linux-64", + "timestamp": 1598031187103, + "version": "3.0.1" + }, + "constructor-3.0.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.8,<3.9.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "934822f8e0a2068aca75f4cbb2be6297", + "name": "constructor", + "sha256": "62ab04f9f23911df535ed89ff72702e7cf72f405896fa75fe930fc13c6972b99", + "size": 74902, + "subdir": "linux-64", + "timestamp": 1598031127131, + "version": "3.0.1" + }, + "constructor-3.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.6,<3.7.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4075c9b91bb9b310b1536af523c4e457", + "name": "constructor", + "sha256": "e0ae780a8afd358b04772208e0dff25eb47553cc12970d187d6b7bbc0d682a7a", + "size": 77908, + "subdir": "linux-64", + "timestamp": 1598032241975, + "version": "3.0.2" + }, + "constructor-3.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.7,<3.8.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8dc0fb94972d1490e1a5a484a971c8de", + "name": "constructor", + "sha256": "20638861a4a8b423c9f6957dff41d66ecee0188143c2a7baf6879d4368482e4b", + "size": 77834, + "subdir": "linux-64", + "timestamp": 1598032281713, + "version": "3.0.2" + }, + "constructor-3.0.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.8,<3.9.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bad57a2fe994a8d6f9c957ad91ab1207", + "name": "constructor", + "sha256": "50de8952f421b7481ee86973b35b598cda7928a2168182bc8d51c4c8afed6d88", + "size": 77974, + "subdir": "linux-64", + "timestamp": 1598032323293, + "version": "3.0.2" + }, + "constructor-3.2.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.6,<3.7.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5495e324049320e86a4bd3bacb2e433f", + "name": "constructor", + "sha256": "553e58134e7d3f390387023192c72ea7f1c76b0067dc82122a3c600a5e6d9d21", + "size": 169871, + "subdir": "linux-64", + "timestamp": 1616147706516, + "version": "3.2.0" + }, + "constructor-3.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.7,<3.8.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff2b8122af6bd2ecfd1cb6c8093ea9fd", + "name": "constructor", + "sha256": "d765ae1c1822ec806fce64cc0cf43532b3c0235b9cb54a6a51ced55904252507", + "size": 170018, + "subdir": "linux-64", + "timestamp": 1616147694928, + "version": "3.2.0" + }, + "constructor-3.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.8,<3.9.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5aaea2ebea32515bdaf93e379f90cf69", + "name": "constructor", + "sha256": "ba610a25370793a870af1c08fc1bce4a74d39d846fc6a54de7bd5d8d61ce47a3", + "size": 170075, + "subdir": "linux-64", + "timestamp": 1616145745373, + "version": "3.2.0" + }, + "constructor-3.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.9,<3.10.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f9da8bf5e2ba522b0afd9e16b7a1f4d6", + "name": "constructor", + "sha256": "03d8feb9bd39eef678ee0e17da9bfa66c39af4468761cd8910877911795c8865", + "size": 170120, + "subdir": "linux-64", + "timestamp": 1616147698724, + "version": "3.2.0" + }, + "constructor-3.2.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.10,<3.11.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3f304be91616c51fbd7438f655f8e9e3", + "name": "constructor", + "sha256": "d6f45427ec90637a39017bb45488ea4b27a37a38c97cdb620830ea34ada7dfa0", + "size": 170026, + "subdir": "linux-64", + "timestamp": 1643041031940, + "version": "3.2.1" + }, + "constructor-3.2.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.6,<3.7.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a44f7414c629b36e3629095248e20cf7", + "name": "constructor", + "sha256": "77e0f1e53df7c8e481e55dda0efcfcd4de3a75d9b505c6f0453edd404259ee48", + "size": 166263, + "subdir": "linux-64", + "timestamp": 1617222111595, + "version": "3.2.1" + }, + "constructor-3.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.7,<3.8.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a7df25fd827cea5f99a7c1fb8c219e7", + "name": "constructor", + "sha256": "009b9ff0384bf79e3c57c256da1e18f52e0fc8753b7dbfb2ca5741189e38cb92", + "size": 166401, + "subdir": "linux-64", + "timestamp": 1617222097516, + "version": "3.2.1" + }, + "constructor-3.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.8,<3.9.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a61bedf418d484b9372dc5dd380571f7", + "name": "constructor", + "sha256": "b6dc0cf595a7a9615f0d631a73f5895c66f24edb5b5565cc51a5567b3a0bcc80", + "size": 166551, + "subdir": "linux-64", + "timestamp": 1617222101001, + "version": "3.2.1" + }, + "constructor-3.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.9,<3.10.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3ce0f3e8d534e2f0750b107db81400fe", + "name": "constructor", + "sha256": "dfb7ee45808a33e9d06853917c5b5c57edc4d2eba625d11e54d9edfd424829af", + "size": 166588, + "subdir": "linux-64", + "timestamp": 1617222101078, + "version": "3.2.1" + }, + "constructor-3.3.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.10,<3.11.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "949013c3bb05d75c6019f0ca00660e20", + "name": "constructor", + "sha256": "c07ac357d9a7ea36f5c55b9ffe24b64256f87ad0578d17acd9337b4fc8acc1d3", + "size": 169449, + "subdir": "linux-64", + "timestamp": 1647963606490, + "version": "3.3.1" + }, + "constructor-3.3.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.7,<3.8.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "42d1f10e34c90f6af36ca7c49447a3bd", + "name": "constructor", + "sha256": "699300a3f72ef102a536c275c527c58bf5d490c51ad82e6bad1d757fed53a024", + "size": 168331, + "subdir": "linux-64", + "timestamp": 1647963480064, + "version": "3.3.1" + }, + "constructor-3.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.8,<3.9.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5739f8ff5615ea0436d9c132d8aad319", + "name": "constructor", + "sha256": "c45a6f33101887c0cad8aa72751e942673296731097b54c9e7f825112c122481", + "size": 168503, + "subdir": "linux-64", + "timestamp": 1647963807970, + "version": "3.3.1" + }, + "constructor-3.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.9,<3.10.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "80c876dc91631d9e881a17bc2c7ed4a0", + "name": "constructor", + "sha256": "e3aec3cea17a17903e58a869ab3e089d84e908e56b5a8117455428e6b759600f", + "size": 168677, + "subdir": "linux-64", + "timestamp": 1647963709546, + "version": "3.3.1" + }, + "constructor-3.4.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.10,<3.11.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "70174a9a77cf02504c4b6d57846b673d", + "name": "constructor", + "sha256": "93ce215fa9fac63b4bfb9a7190fac319bee1f75e6a39bdef95ced8b978052553", + "size": 205574, + "subdir": "linux-64", + "timestamp": 1674234013351, + "version": "3.4.1" + }, + "constructor-3.4.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.7,<3.8.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "84ac800eba639ded52e53eaf7cd8a5b7", + "name": "constructor", + "sha256": "a276ba1a11df3882f374f60bb84fd5a108ff0d87698203d14ec25a6a0937f6e2", + "size": 204383, + "subdir": "linux-64", + "timestamp": 1674234106041, + "version": "3.4.1" + }, + "constructor-3.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.8,<3.9.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6438016a234e473aa6316906fd58c15b", + "name": "constructor", + "sha256": "2b82e21a61edd0f7f5c8583eb4665bd816d0700b3ce9e05a0db433498f6e4360", + "size": 204715, + "subdir": "linux-64", + "timestamp": 1674234296336, + "version": "3.4.1" + }, + "constructor-3.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.9,<3.10.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fee10d44fce31438a252a26b9da1a162", + "name": "constructor", + "sha256": "03f3498ec2f157492d73c055d9e654cce6c2b8c45198e7a527b0506e7efff44b", + "size": 204731, + "subdir": "linux-64", + "timestamp": 1674234202536, + "version": "3.4.1" + }, + "constructor-3.4.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0", + "conda-standalone", + "python >=3.10,<3.11.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4f8e23897a383a59c510e53d66abf4cc", + "name": "constructor", + "sha256": "cc81a1bb62d2958a133d307c34d4be2bfd9d6f64d6b3d003fa71dd668bdd6c20", + "size": 206199, + "subdir": "linux-64", + "timestamp": 1674747611243, + "version": "3.4.2" + }, + "constructor-3.4.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0", + "conda-standalone", + "python >=3.7,<3.8.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ea5f59528182f7f5c2243918f69a6fd1", + "name": "constructor", + "sha256": "14763a7479dd4fe13ccc80caaff5df13f007ae419d7ef314ee4500354e414ca2", + "size": 204709, + "subdir": "linux-64", + "timestamp": 1674747663093, + "version": "3.4.2" + }, + "constructor-3.4.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0", + "conda-standalone", + "python >=3.8,<3.9.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4ac747e730475a5876a3b19c805a88de", + "name": "constructor", + "sha256": "91c5a63cbba538038a9ddb944351b60df522e14789c2ef67093cd417da21a331", + "size": 204811, + "subdir": "linux-64", + "timestamp": 1674747559677, + "version": "3.4.2" + }, + "constructor-3.4.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0", + "conda-standalone", + "python >=3.9,<3.10.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e630b8c510b7d76edffe2d69ef8be305", + "name": "constructor", + "sha256": "90f8c7928cab13186f681a1045c2b079b668101ef42b132cb8d1a45524fb2ae4", + "size": 205050, + "subdir": "linux-64", + "timestamp": 1674747509811, + "version": "3.4.2" + }, + "constructor-3.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0", + "conda-standalone", + "pillow >=3.1", + "python >=3.10,<3.11.0a0", + "ruamel_yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c871d26d6bb3e00cde88d33fd8bc6dbe", + "name": "constructor", + "sha256": "9a3fe7d56a6f0866b6d949d59f8be00943a84a21009a86d375a5fb4b0aba1c19", + "size": 207473, + "subdir": "linux-64", + "timestamp": 1680792475331, + "version": "3.4.3" + }, + "constructor-3.4.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0", + "conda-standalone", + "pillow >=3.1", + "python >=3.11,<3.12.0a0", + "ruamel_yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0b79ab3fd6b09cb9fde897f25584f677", + "name": "constructor", + "sha256": "385695f54632aef15b5114a16356e24c838eb29ccc2e319aee5eb824848e8f6f", + "size": 239685, + "subdir": "linux-64", + "timestamp": 1680792529931, + "version": "3.4.3" + }, + "constructor-3.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0", + "conda-standalone", + "pillow >=3.1", + "python >=3.8,<3.9.0a0", + "ruamel_yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3b1943dd25878cda88457aa53b8a8614", + "name": "constructor", + "sha256": "7f119f855b32cd597b6a67a9f0026d61e2afff0a72267f3984857d54a221db13", + "size": 206058, + "subdir": "linux-64", + "timestamp": 1680792638384, + "version": "3.4.3" + }, + "constructor-3.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0", + "conda-standalone", + "pillow >=3.1", + "python >=3.9,<3.10.0a0", + "ruamel_yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c86ca52cf7a2f21ec81b477290adf263", + "name": "constructor", + "sha256": "0282fcec98a5e177f0aa1ff11297362022e09fd18e219e353cdc99005b26b588", + "size": 206192, + "subdir": "linux-64", + "timestamp": 1680792583044, + "version": "3.4.3" + }, + "contextlib2-0.5.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "ce5c6f14e53fc6f40a5fa9e278de0bbc", + "name": "contextlib2", + "sha256": "e2c7787bee2b9a0493d1eb39c0e346e182b177accf94d67fadcecdaf514280f0", + "size": 14915, + "subdir": "linux-64", + "timestamp": 1530781086406, + "version": "0.5.5" + }, + "contextlib2-0.5.5-py27hbf4c468_0.tar.bz2": { + "build": "py27hbf4c468_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "b853a68fa6dedff0f652318fe63f506e", + "name": "contextlib2", + "sha256": "3ef0e1d313a03cc6821643dd831263f24b028188ea6698ba7e88950965681a41", + "size": 14755, + "subdir": "linux-64", + "timestamp": 1505740282282, + "version": "0.5.5" + }, + "contextlib2-0.5.5-py35h6690dba_0.tar.bz2": { + "build": "py35h6690dba_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "f2c8d2570012898306f91085a21965ea", + "name": "contextlib2", + "sha256": "8ca47985e78b2ca9638af8c412bd368d7d925dfbde46598c3f7c678ea5489f2b", + "size": 15129, + "subdir": "linux-64", + "timestamp": 1505740294636, + "version": "0.5.5" + }, + "contextlib2-0.5.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "fe2de26efbb69cab342659e493a4bb6c", + "name": "contextlib2", + "sha256": "15a34d5eba576c75c13054f6884f49f2c68d5f0a7c55b6cb57ae25fee833e96f", + "size": 15299, + "subdir": "linux-64", + "timestamp": 1530781108216, + "version": "0.5.5" + }, + "contextlib2-0.5.5-py36h6c84a62_0.tar.bz2": { + "build": "py36h6c84a62_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "8163569d1a9e3fd421e22d42f47a88e7", + "name": "contextlib2", + "sha256": "1a1b9a8177d6b7c78dacdfde47b9d63230f0d9982044a28e6b2c51419c9643a5", + "size": 15140, + "subdir": "linux-64", + "timestamp": 1505740306924, + "version": "0.5.5" + }, + "contextlib2-0.5.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "4aa7421f1daca29e2f5b62dfdf498c5a", + "name": "contextlib2", + "sha256": "d9a1b81aa2a91a5351d9a2b2762fa6f220316a70cdc3cd3aeb232271625238aa", + "size": 15312, + "subdir": "linux-64", + "timestamp": 1530781130349, + "version": "0.5.5" + }, + "contextlib2-21.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "PSF-2.0 AND Apache-2.0", + "license_family": "PSF", + "md5": "5396ca55deb6b8c30874a8ddeb95298f", + "name": "contextlib2", + "sha256": "2c85b2c88b8ad9a7763201d644f788526abe426264efdcdb95214431a9a6dade", + "size": 23300, + "subdir": "linux-64", + "timestamp": 1663665236889, + "version": "21.6.0" + }, + "contextlib2-21.6.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "PSF-2.0 AND Apache-2.0", + "license_family": "PSF", + "md5": "9109acfc3a83980586c440f2988a9463", + "name": "contextlib2", + "sha256": "62cb86baaf51a703216eed40269f456bae0d72dee1f7899221223a38de6d969c", + "size": 27322, + "subdir": "linux-64", + "timestamp": 1679340389734, + "version": "21.6.0" + }, + "contextlib2-21.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0 AND Apache-2.0", + "license_family": "PSF", + "md5": "c30695970d56b73bfc1eedf491ddc17e", + "name": "contextlib2", + "sha256": "d5793cbe1db895153d24685d59a06bd90f50114d9de85e595027c5d9b6f8d795", + "size": 22935, + "subdir": "linux-64", + "timestamp": 1663665261215, + "version": "21.6.0" + }, + "contextlib2-21.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0 AND Apache-2.0", + "license_family": "PSF", + "md5": "3784ae3d9d0bab48ab6088aaf2dcc6a5", + "name": "contextlib2", + "sha256": "df89937fa9350954087cebabbae73c2dfa6f74f4a40604c16d5bf6fdc651c006", + "size": 23129, + "subdir": "linux-64", + "timestamp": 1663665310844, + "version": "21.6.0" + }, + "contextlib2-21.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0 AND Apache-2.0", + "license_family": "PSF", + "md5": "27247122493b77b1e3cd34469ba2feae", + "name": "contextlib2", + "sha256": "0eeb222913bd1695e6c7120cc7f807dd5750e20db2d12d81d5ffa4d5e3e276cb", + "size": 23041, + "subdir": "linux-64", + "timestamp": 1663665286687, + "version": "21.6.0" + }, + "continuum-docs-2.0.17-h215ba9a_0.tar.bz2": { + "build": "h215ba9a_0", + "build_number": 0, + "depends": [], + "md5": "4a54be316ba640a718494ff7d93e8fd1", + "name": "continuum-docs", + "sha256": "527b2755dcd2633543cdda9166b660002a995b9e1a54045d8b8bbe778d01ff27", + "size": 70681121, + "subdir": "linux-64", + "timestamp": 1509658360426, + "version": "2.0.17" + }, + "contourpy-1.0.5-py310hdb19cb5_0.tar.bz2": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7953ef61e9fcd31c02304dc264ce55bc", + "name": "contourpy", + "sha256": "0f816d62ecf83cd23ea2e87dbcb8d1e49bbcd5848e76a5277d6cd10c12469ab2", + "size": 235077, + "subdir": "linux-64", + "timestamp": 1663827593323, + "version": "1.0.5" + }, + "contourpy-1.0.5-py311hdb19cb5_0.tar.bz2": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fda5a72dc91e2bc678236502f6ba786d", + "name": "contourpy", + "sha256": "853f4c231c2632dc89689e3f752879d5ab30976050c0457db913516e5ca316e9", + "size": 249276, + "subdir": "linux-64", + "timestamp": 1676827104466, + "version": "1.0.5" + }, + "contourpy-1.0.5-py37hdb19cb5_0.tar.bz2": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8e5faa867702b0d0932d1d49729275ee", + "name": "contourpy", + "sha256": "e2a02c33e7b09ec1521625311b0b788adb44642048a67560faeadfe5c3f62b44", + "size": 233250, + "subdir": "linux-64", + "timestamp": 1663827529541, + "version": "1.0.5" + }, + "contourpy-1.0.5-py38hdb19cb5_0.tar.bz2": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1fbceb30a5aeb9fb6e296b554d311973", + "name": "contourpy", + "sha256": "1c3fd4d2cbfac81ba9226f4bc61f56199da0633660569a1c4668754e8aaef5b4", + "size": 233599, + "subdir": "linux-64", + "timestamp": 1663827474400, + "version": "1.0.5" + }, + "contourpy-1.0.5-py39hdb19cb5_0.tar.bz2": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a93581f810ef522bd23c148195591157", + "name": "contourpy", + "sha256": "0b1a9a25ddfc6631390c53d6ee95706eaab0805c5a9a8d748c08120a1f421256", + "size": 234846, + "subdir": "linux-64", + "timestamp": 1663827645102, + "version": "1.0.5" + }, + "cookies-2.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "2b1c5704740d591aa2f75c957c704b9c", + "name": "cookies", + "sha256": "4409432b2316a367080c12f64790b77284bfe3b2c944d9a27b16f53e7f3de222", + "size": 68090, + "subdir": "linux-64", + "timestamp": 1530812845216, + "version": "2.2.1" + }, + "cookies-2.2.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9cf7770cf3ad1d672fef927280198336", + "name": "cookies", + "sha256": "9137dc6177eea38ae70ff995fd7f0141f13e447b677210af79bd5b26cad07886", + "size": 68333, + "subdir": "linux-64", + "timestamp": 1539183660688, + "version": "2.2.1" + }, + "cookies-2.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "9739023c46f6ceebe64862d1f0ebc3ca", + "name": "cookies", + "sha256": "b8b3981cb311dde4e1a214c72c31b309ff601cb1c8f0bda36bd6485895589fe1", + "size": 69028, + "subdir": "linux-64", + "timestamp": 1535130192661, + "version": "2.2.1" + }, + "cookies-2.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1ef8821f1cab550415eae0d36a8402ff", + "name": "cookies", + "sha256": "76c67a57436ebcdfc2dfef4d5e466fb41359179805b64766678e0dfe703b928a", + "size": 68879, + "subdir": "linux-64", + "timestamp": 1530812893916, + "version": "2.2.1" + }, + "cookies-2.2.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "52641306da663092e8040b851d190fe7", + "name": "cookies", + "sha256": "4e17f828e8555971e6fe17eb02b20c29f334dc8a0f4b6fd4f289721647dea1fe", + "size": 69113, + "subdir": "linux-64", + "timestamp": 1539183691408, + "version": "2.2.1" + }, + "cookies-2.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "da2e78d9a2685b1a15cb558642ae869e", + "name": "cookies", + "sha256": "a638f052d37c3d0145e6eef8bbefaa658be5ce418edd528d8a479f953507b9c6", + "size": 68307, + "subdir": "linux-64", + "timestamp": 1530812869155, + "version": "2.2.1" + }, + "cookies-2.2.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "be0613a7a8159359520b9f5cb880220a", + "name": "cookies", + "sha256": "d4961181ad4e49f01e8c26657f263ce6f666e59473605ee5788b852629eb0fe7", + "size": 68631, + "subdir": "linux-64", + "timestamp": 1539183677957, + "version": "2.2.1" + }, + "cookies-2.2.1-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "13d7eec53a43b72c6b4e9659eab5845b", + "name": "cookies", + "sha256": "c1441e94d8b08f6159f62d1f1a72925f10b2c4e9dc57ac5bcd1b7ea32a5d4872", + "size": 69038, + "subdir": "linux-64", + "timestamp": 1572357198550, + "version": "2.2.1" + }, + "coremltools-4.1-py310h00e6091_1.tar.bz2": { + "build": "py310h00e6091_1", + "build_number": 1, + "constrains": [ + "pytorch >=1.4,<1.7" + ], + "depends": [ + "attrs", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging", + "protobuf >=3.1.0", + "python >=3.10,<3.11.0a0", + "scipy", + "six >=1.1.0", + "sympy", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d5392dfac31c0227c05ac35617d30c9b", + "name": "coremltools", + "sha256": "556189493e2c00255cd5672effb113182570544fe2cdbac859bba461f9ec4900", + "size": 3790686, + "subdir": "linux-64", + "timestamp": 1640811834063, + "version": "4.1" + }, + "coremltools-4.1-py36h5f574fb_0.tar.bz2": { + "build": "py36h5f574fb_0", + "build_number": 0, + "constrains": [ + "pytorch >=1.4,<1.7" + ], + "depends": [ + "attrs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf >=3.1.0", + "python >=3.6,<3.7.0a0", + "scipy", + "six >=1.1.0", + "sympy", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ce6aedae4084f7b87fc2afda895db9e6", + "name": "coremltools", + "sha256": "d4a488cb97241c10928defd6e5e4834d63a59e08d1a4b3ca9fbfa1e3f17bc438", + "size": 3766091, + "subdir": "linux-64", + "timestamp": 1612969001749, + "version": "4.1" + }, + "coremltools-4.1-py36h5f574fb_1.tar.bz2": { + "build": "py36h5f574fb_1", + "build_number": 1, + "constrains": [ + "pytorch >=1.4,<1.7" + ], + "depends": [ + "attrs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf >=3.1.0", + "python >=3.6,<3.7.0a0", + "scipy", + "six >=1.1.0", + "sympy", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22e6f1d9f8c3d610b461b1fd0a586b5e", + "name": "coremltools", + "sha256": "9d10dc709af7ea59e8ebb7d34e88f1360df03d2bcc80377e123b5df7f5462e10", + "size": 3775022, + "subdir": "linux-64", + "timestamp": 1615414113482, + "version": "4.1" + }, + "coremltools-4.1-py37h5f574fb_0.tar.bz2": { + "build": "py37h5f574fb_0", + "build_number": 0, + "constrains": [ + "pytorch >=1.4,<1.7" + ], + "depends": [ + "attrs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf >=3.1.0", + "python >=3.7,<3.8.0a0", + "scipy", + "six >=1.1.0", + "sympy", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "91c744277e9b5f88a473bcc3068d4096", + "name": "coremltools", + "sha256": "1556b42481fd501443a1165210e7e4306b1ec0529a23043f31166d51e3eb5b5c", + "size": 3747377, + "subdir": "linux-64", + "timestamp": 1612968946413, + "version": "4.1" + }, + "coremltools-4.1-py37h5f574fb_1.tar.bz2": { + "build": "py37h5f574fb_1", + "build_number": 1, + "constrains": [ + "pytorch >=1.4,<1.7" + ], + "depends": [ + "attrs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf >=3.1.0", + "python >=3.7,<3.8.0a0", + "scipy", + "six >=1.1.0", + "sympy", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e3bb9d2edd55888c9f4482997190226", + "name": "coremltools", + "sha256": "d1dba65681c38a3d268840049c7652e62e5d5c345b8fbe785e0b8c7083f2e4f9", + "size": 3766300, + "subdir": "linux-64", + "timestamp": 1615414100368, + "version": "4.1" + }, + "coremltools-4.1-py38h5f574fb_0.tar.bz2": { + "build": "py38h5f574fb_0", + "build_number": 0, + "constrains": [ + "pytorch >=1.4,<1.7" + ], + "depends": [ + "attrs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf >=3.1.0", + "python >=3.8,<3.9.0a0", + "scipy", + "six >=1.1.0", + "sympy", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "23ba1627de04bbee811e056a3627e3e4", + "name": "coremltools", + "sha256": "f71a4ed774060115bb15f0fb8d0375f3fb42efe66efddb0aa642d704ce7e7da4", + "size": 3770267, + "subdir": "linux-64", + "timestamp": 1612969374231, + "version": "4.1" + }, + "coremltools-4.1-py38h5f574fb_1.tar.bz2": { + "build": "py38h5f574fb_1", + "build_number": 1, + "constrains": [ + "pytorch >=1.4,<1.7" + ], + "depends": [ + "attrs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf >=3.1.0", + "python >=3.8,<3.9.0a0", + "scipy", + "six >=1.1.0", + "sympy", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb4fd57ddfd09d50f7412bdab8f50d16", + "name": "coremltools", + "sha256": "cd17b69eecbfad8a3b81967e5fb39d47de22850b824bdae25d5f9b74877bc03c", + "size": 3773178, + "subdir": "linux-64", + "timestamp": 1615414110827, + "version": "4.1" + }, + "coremltools-4.1-py39h5f574fb_0.tar.bz2": { + "build": "py39h5f574fb_0", + "build_number": 0, + "constrains": [ + "pytorch >=1.4,<1.7" + ], + "depends": [ + "attrs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf >=3.1.0", + "python >=3.9,<3.10.0a0", + "scipy", + "six >=1.1.0", + "sympy", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "05ca83a4c6e9c5704de1de889011304d", + "name": "coremltools", + "sha256": "d0821737764c0c016bc7e3e10b84e15aa2a39aa9f36f88f2ce71eb64d0ecf876", + "size": 3764364, + "subdir": "linux-64", + "timestamp": 1612969360580, + "version": "4.1" + }, + "coremltools-4.1-py39h5f574fb_1.tar.bz2": { + "build": "py39h5f574fb_1", + "build_number": 1, + "constrains": [ + "pytorch >=1.4,<1.7" + ], + "depends": [ + "attrs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf >=3.1.0", + "python >=3.9,<3.10.0a0", + "scipy", + "six >=1.1.0", + "sympy", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c0b5dd86fbb49aa569253ff4ffe0092a", + "name": "coremltools", + "sha256": "5b8a2191b3893566397e5565191b6090a001c4db64420533156d03a5790e0426", + "size": 3773054, + "subdir": "linux-64", + "timestamp": 1615413291093, + "version": "4.1" + }, + "coreutils-8.31-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "8fb1d1289a7f3f0f7c5d811312d32150", + "name": "coreutils", + "sha256": "10b8cb028c53c1fd5e1d1f4d463c42b39ce002f39ac3ccd4cf9e0474e7846a8f", + "size": 4022890, + "subdir": "linux-64", + "timestamp": 1588104532312, + "version": "8.31" + }, + "coreutils-8.32-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "7dfbef1c9df6c8862f343b73ce0ff3a5", + "name": "coreutils", + "sha256": "35db2355910de1d60cc8a3f661fa5f7985f3779f24eccfbd0635076ea2487958", + "size": 4095261, + "subdir": "linux-64", + "timestamp": 1598644085483, + "version": "8.32" + }, + "cornice-2.4.0-py27h70b9346_0.tar.bz2": { + "build": "py27h70b9346_0", + "build_number": 0, + "depends": [ + "colander", + "pyramid", + "python >=2.7,<2.8.0a0", + "simplejson", + "venusian", + "webob" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "776aa5995fe9c7891e543e8df4cc0dd3", + "name": "cornice", + "sha256": "120f7e75af1252311fd45438748755d9e394f88ce1b61e9d2621d2b2aa044b49", + "size": 37430, + "subdir": "linux-64", + "timestamp": 1508743569820, + "version": "2.4.0" + }, + "cornice-2.4.0-py35hf69054b_0.tar.bz2": { + "build": "py35hf69054b_0", + "build_number": 0, + "depends": [ + "colander", + "pyramid", + "python >=3.5,<3.6.0a0", + "simplejson", + "venusian", + "webob" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "72e3649f63a5f0afe2aa147cff58d07c", + "name": "cornice", + "sha256": "8b5c83a1ca81cbb3dc8748ec61a00e52df1ee5d1f17f21d5ae9c5ac1fca9a45c", + "size": 38089, + "subdir": "linux-64", + "timestamp": 1508743526825, + "version": "2.4.0" + }, + "cornice-2.4.0-py36had50d1d_0.tar.bz2": { + "build": "py36had50d1d_0", + "build_number": 0, + "depends": [ + "colander", + "pyramid", + "python >=3.6,<3.7.0a0", + "simplejson", + "venusian", + "webob" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "cec0dd8edd7313c14ce0fd9f06ff6a8a", + "name": "cornice", + "sha256": "143562f8503520ce0f62809be0014253d2ae618392dae0388ab3f2c946b608d5", + "size": 37941, + "subdir": "linux-64", + "timestamp": 1508743577195, + "version": "2.4.0" + }, + "cornice-3.0.0-py27h318091b_0.tar.bz2": { + "build": "py27h318091b_0", + "build_number": 0, + "depends": [ + "colander", + "pyramid", + "python >=2.7,<2.8.0a0", + "simplejson", + "venusian", + "webob" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "48d633416e3b842c82f4fee376681780", + "name": "cornice", + "sha256": "09db7d10f4e58e3b96446c2cec95a833d6e2b2d7bfa08ed79e9a89156b81452c", + "size": 37366, + "subdir": "linux-64", + "timestamp": 1511700367658, + "version": "3.0.0" + }, + "cornice-3.0.0-py35hbebb21b_0.tar.bz2": { + "build": "py35hbebb21b_0", + "build_number": 0, + "depends": [ + "colander", + "pyramid", + "python >=3.5,<3.6.0a0", + "simplejson", + "venusian", + "webob" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "f175f857b2cba3f43d292a9757a0ca41", + "name": "cornice", + "sha256": "6cc1117d63e3b289b5a444de3a1ac0dd09f32e97165c61e8d674c1dfa88a20a0", + "size": 37993, + "subdir": "linux-64", + "timestamp": 1511700376262, + "version": "3.0.0" + }, + "cornice-3.0.0-py36h4eba0d1_0.tar.bz2": { + "build": "py36h4eba0d1_0", + "build_number": 0, + "depends": [ + "colander", + "pyramid", + "python >=3.6,<3.7.0a0", + "simplejson", + "venusian", + "webob" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "b8de1f58cccf437891b8fd02a28f29e5", + "name": "cornice", + "sha256": "f329b13a20090999624afac2faf885cb9697e6fd2a480796ea83d9e92dcb50c0", + "size": 37948, + "subdir": "linux-64", + "timestamp": 1511700379695, + "version": "3.0.0" + }, + "cornice-3.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "colander", + "pyramid", + "python >=2.7,<2.8.0a0", + "simplejson", + "six", + "venusian", + "webob" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "26a8e7e7e5fe44112a5db3000fe9c81d", + "name": "cornice", + "sha256": "d74d3863c30cd937eadb8ec4b1d5a1744975cf3642eeb886508f77b8bcadf020", + "size": 37776, + "subdir": "linux-64", + "timestamp": 1519252774392, + "version": "3.1.0" + }, + "cornice-3.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "colander", + "pyramid", + "python >=3.5,<3.6.0a0", + "simplejson", + "six", + "venusian", + "webob" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "7c5a2dfe5a9e99cb5a00221350a8aac7", + "name": "cornice", + "sha256": "5f48a231d5393ee00a8778896bbbfe2379a39c7cfc7a1b1dc884f9aa45f03856", + "size": 38423, + "subdir": "linux-64", + "timestamp": 1519252786019, + "version": "3.1.0" + }, + "cornice-3.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "colander", + "pyramid", + "python >=3.6,<3.7.0a0", + "simplejson", + "six", + "venusian", + "webob" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "f0e68af83b32d5a0c10d4694527137ad", + "name": "cornice", + "sha256": "a2fb3374ce50e8cb1fc63d93a77c5229bd56ca229a918f448b800fbf4b3000a0", + "size": 38379, + "subdir": "linux-64", + "timestamp": 1519252747761, + "version": "3.1.0" + }, + "cornice-3.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=2.7,<2.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "f775472581da12c93287c5264b17adff", + "name": "cornice", + "sha256": "e89e592647e721af8dd77724d8cf5baef8b27d83cdfce667eda127fce4b1bcfd", + "size": 40288, + "subdir": "linux-64", + "timestamp": 1530036373033, + "version": "3.4.0" + }, + "cornice-3.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.5,<3.6.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "9edd5b6a5145a9a1f5738914e8f8d5b1", + "name": "cornice", + "sha256": "a163b1e02496e99d9ff19ed9771d420068eccd2b770ea93a9d8be7979dc35aa3", + "size": 41024, + "subdir": "linux-64", + "timestamp": 1530036409942, + "version": "3.4.0" + }, + "cornice-3.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.6,<3.7.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "05ba6974526caaa3f19df180aac8928b", + "name": "cornice", + "sha256": "034cd6190c760252f52a47e0f5b51fcf1391baa7ae77368029794a46e5b8f8e3", + "size": 40955, + "subdir": "linux-64", + "timestamp": 1530036372259, + "version": "3.4.0" + }, + "cornice-3.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.7,<3.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "844e07b0c069ca294601bc28eeb907fc", + "name": "cornice", + "sha256": "87b882fc6dc9a2087443e7e80f200c1085af7f3adeb5849190b1df6b7e041736", + "size": 40970, + "subdir": "linux-64", + "timestamp": 1530875912077, + "version": "3.4.0" + }, + "cornice-3.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=2.7,<2.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "c35cb2435d328f1ab6298ff5680cae55", + "name": "cornice", + "sha256": "326f23bb368335bdd92b0a755859780e21ab72a6b06163c66f2bf0539a714f3b", + "size": 40937, + "subdir": "linux-64", + "timestamp": 1539473214246, + "version": "3.4.1" + }, + "cornice-3.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.6,<3.7.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "bb702e133ca298a31622fd883a12711a", + "name": "cornice", + "sha256": "40a69e3dda50e841487f99da535b3f284625006635b96b38d68def8cf7dab7ba", + "size": 41709, + "subdir": "linux-64", + "timestamp": 1539473235549, + "version": "3.4.1" + }, + "cornice-3.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.7,<3.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "ee106227e788328cb827e063d5b12520", + "name": "cornice", + "sha256": "61a5a9423a682e4a2628f83bb400552101dac8f127331756e57e7acb9a4dd5f3", + "size": 41583, + "subdir": "linux-64", + "timestamp": 1539473235497, + "version": "3.4.1" + }, + "cornice-3.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=2.7,<2.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "da411f4be7b1503218d0e5cc14a4b6d4", + "name": "cornice", + "sha256": "2611619b857028368d025bbe931eab8f46ecbe4925dbb683c6f653f4b6e7dd7e", + "size": 40914, + "subdir": "linux-64", + "timestamp": 1540962758099, + "version": "3.4.2" + }, + "cornice-3.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.6,<3.7.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "aea3e1f0e381813b599bec1b0e96d594", + "name": "cornice", + "sha256": "1d057938a39628778331a14bbb3b686821d3133fc86df194d20c76157d220403", + "size": 41601, + "subdir": "linux-64", + "timestamp": 1540962773300, + "version": "3.4.2" + }, + "cornice-3.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.7,<3.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "8e42247c9aa74876cd8bbd6814f59667", + "name": "cornice", + "sha256": "883e8b3b06d70a8fb8d26ac906b861e2f9be0ef62aa294f17b405b7b9e68358f", + "size": 41592, + "subdir": "linux-64", + "timestamp": 1540962776694, + "version": "3.4.2" + }, + "cornice-3.4.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=2.7,<2.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "6c317a38982ee7760706b316423df180", + "name": "cornice", + "sha256": "a2782fc9358308e1d071eb2ef075c6715dea54ae676ce626ebfba3b301504ede", + "size": 41165, + "subdir": "linux-64", + "timestamp": 1545114155822, + "version": "3.4.4" + }, + "cornice-3.4.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.6,<3.7.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "abc77023573af913554246fc0543b45e", + "name": "cornice", + "sha256": "33eebdcc43b7cb5e7097768ce26706d7375fbff6e02f8144523d566a8cd1dcd8", + "size": 41742, + "subdir": "linux-64", + "timestamp": 1545114162004, + "version": "3.4.4" + }, + "cornice-3.4.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.7,<3.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "2ab57d266418f0392fd45cc28617b17f", + "name": "cornice", + "sha256": "8d770e469ac17b28e5b08ac540615d4365f4c899b134fdc440de5fa70e672ad0", + "size": 41740, + "subdir": "linux-64", + "timestamp": 1545114196962, + "version": "3.4.4" + }, + "cornice-3.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=2.7,<2.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "6c4e35bb274e39c7f41fd8b577f2069e", + "name": "cornice", + "sha256": "8dec77be86ada8afbaf05a5db9641d4e0dff5404485df1775c28155173a9953f", + "size": 168504, + "subdir": "linux-64", + "timestamp": 1547789187785, + "version": "3.5.0" + }, + "cornice-3.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.6,<3.7.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "2b951160d77ca9a80c58b21d2e89ccdc", + "name": "cornice", + "sha256": "6740a318b9ada7d59a2fb02cf8c5b936c3a46008455d841d531df8a0ab36145a", + "size": 169199, + "subdir": "linux-64", + "timestamp": 1547789321473, + "version": "3.5.0" + }, + "cornice-3.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.7,<3.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "0b6b9ee636cd19e665a7b45bb1259de2", + "name": "cornice", + "sha256": "8b090b4c61f0289c848b38b1f88fc42c1749d8e5bde89da460d076a81e9acae2", + "size": 169247, + "subdir": "linux-64", + "timestamp": 1547789319717, + "version": "3.5.0" + }, + "cornice-3.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=2.7,<2.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "db8519c1f4ee0da0c42222f701a8ec45", + "name": "cornice", + "sha256": "7a7f5e608f2831bea04bf400781f7d4f38bcb2d2138e1035f24adadce64c6a83", + "size": 172947, + "subdir": "linux-64", + "timestamp": 1550267627630, + "version": "3.5.1" + }, + "cornice-3.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.6,<3.7.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "566a44e5577fdf0c163db12250574705", + "name": "cornice", + "sha256": "6eeb3cc9831e76cdcf70fa190a87df37cd28d042bb4b0eff65ce591bd3205b1c", + "size": 173667, + "subdir": "linux-64", + "timestamp": 1550267623154, + "version": "3.5.1" + }, + "cornice-3.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.7,<3.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "0ef746b113079ca5f3a256128efca329", + "name": "cornice", + "sha256": "c7c1de2d0898494bbc3ca9ddc17dda1ca4f151cf115f6fe20bd11f2f44f10c60", + "size": 173671, + "subdir": "linux-64", + "timestamp": 1550267555941, + "version": "3.5.1" + }, + "coverage-4.4.2-py27h86fff8b_0.tar.bz2": { + "build": "py27h86fff8b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "169cdc690fe5a234b2f623af33d7c65f", + "name": "coverage", + "sha256": "0a3f9e4aed3ca647459676211a19328308fa720186c89245c18168f14ec2faac", + "size": 212008, + "subdir": "linux-64", + "timestamp": 1511294533705, + "version": "4.4.2" + }, + "coverage-4.4.2-py35h8fc71f1_0.tar.bz2": { + "build": "py35h8fc71f1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6731ab015e317956711f312b8f04af25", + "name": "coverage", + "sha256": "49a5d841813f8aafa0849affcc564af540537322edb75eeaacb3806ea927c615", + "size": 215177, + "subdir": "linux-64", + "timestamp": 1511294548177, + "version": "4.4.2" + }, + "coverage-4.4.2-py36hca7c4c5_0.tar.bz2": { + "build": "py36hca7c4c5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c4514d3d48def099161a96100c4ba7c3", + "name": "coverage", + "sha256": "13493b0f00553755b180f66d28cea367a7d2a5fbb76f1924a0b4f817d81c9956", + "size": 214502, + "subdir": "linux-64", + "timestamp": 1511294511924, + "version": "4.4.2" + }, + "coverage-4.5.1-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b7fa2a8aa2a349d9332ed49d6ec5ba03", + "name": "coverage", + "sha256": "e5401d75ab00f4509c6ebb784b95542fcfaa099f1c947df9d4273e036845b019", + "size": 213327, + "subdir": "linux-64", + "timestamp": 1519228346818, + "version": "4.5.1" + }, + "coverage-4.5.1-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "16c9af02b33b641b402fc03c68c21031", + "name": "coverage", + "sha256": "3e05a270ce9e9c0a8bc93bc901f9b24e0a8b77dedbf1128cb6b47ec9c310477f", + "size": 216550, + "subdir": "linux-64", + "timestamp": 1519228362150, + "version": "4.5.1" + }, + "coverage-4.5.1-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "936fb7c6ed35b5a73c9a156679c49f94", + "name": "coverage", + "sha256": "435f569cf806860b90fb6428cf25ab4f3c4f5ab7fd2c6c786da9d187988edb6c", + "size": 215778, + "subdir": "linux-64", + "timestamp": 1519228334909, + "version": "4.5.1" + }, + "coverage-4.5.1-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ab267e11f4952aea4ab86a4c2cd916c6", + "name": "coverage", + "sha256": "81a1c70652b9656d32db1d686d345f3c7ac97045c1e51ef7dd40d8ad7557d441", + "size": 215867, + "subdir": "linux-64", + "timestamp": 1530694019690, + "version": "4.5.1" + }, + "coverage-4.5.2-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "002f3c18077e5f0ffbf80d61e11c1a40", + "name": "coverage", + "sha256": "bb4cef2bddf6bc404eae2905864b3123e93d933b60dc4e8c6b017c02331a38cf", + "size": 215644, + "subdir": "linux-64", + "timestamp": 1542385760431, + "version": "4.5.2" + }, + "coverage-4.5.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bc43c69768ca3491c90db670d05f5854", + "name": "coverage", + "sha256": "28eecda9c975fd0d9f1584e3f85d758585920dd34a1f562c35de763ccada58f9", + "size": 218182, + "subdir": "linux-64", + "timestamp": 1542385762289, + "version": "4.5.2" + }, + "coverage-4.5.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7c99f9999ca23d09e17b0e7c436a3be9", + "name": "coverage", + "sha256": "be3bab76201b06aabf528d2ea7ec9d36cb4a39717ffb4c0db0232855f8c93206", + "size": 218532, + "subdir": "linux-64", + "timestamp": 1542385751158, + "version": "4.5.2" + }, + "coverage-4.5.3-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "df4612f4f6d48a9085d3a1dd95d69e70", + "name": "coverage", + "sha256": "6e19d0c49cefd2e1b57edeb208c07eecf5ef0643128bea05fec32b45e533db74", + "size": 219610, + "subdir": "linux-64", + "timestamp": 1552344310108, + "version": "4.5.3" + }, + "coverage-4.5.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "34f6038b12c29688360a79476654c2d7", + "name": "coverage", + "sha256": "3dcd488a788edfe1207003ea007b853bcf7d7acca29f25b49a5a6f5c453299f7", + "size": 222013, + "subdir": "linux-64", + "timestamp": 1552344332561, + "version": "4.5.3" + }, + "coverage-4.5.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8ced7771012bc3aa6eeb55f20c0c4f8c", + "name": "coverage", + "sha256": "2e5636a0163a93ac82120ebfa3f0a3f792ba568b46d5e5973b5cf84fd0183117", + "size": 221755, + "subdir": "linux-64", + "timestamp": 1552344328861, + "version": "4.5.3" + }, + "coverage-4.5.3-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e6d2cbab9fffda00865705487a0b7703", + "name": "coverage", + "sha256": "9859125529fd5fee87388feba4ed95927ed50e04e7956611b35309bb88704ce6", + "size": 226574, + "subdir": "linux-64", + "timestamp": 1573033974013, + "version": "4.5.3" + }, + "coverage-4.5.4-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ad84c9ab9b9f88f084976ff31278657b", + "name": "coverage", + "sha256": "fb61ab88f37dc165be05a4c829d6a7b5fdb79c9c15b216c655c42b85bc926290", + "size": 229218, + "subdir": "linux-64", + "timestamp": 1569349916963, + "version": "4.5.4" + }, + "coverage-4.5.4-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7bde48596cdd3795743352e06a7fa0d6", + "name": "coverage", + "sha256": "67699ce465afb7915cbddef2e6017cb200dfdbf0d1270025d0c502671e1ea162", + "size": 231179, + "subdir": "linux-64", + "timestamp": 1569349918105, + "version": "4.5.4" + }, + "coverage-4.5.4-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1f35ca09b417ab02dc9ae20f0b8ec41e", + "name": "coverage", + "sha256": "d50247fa7791eb3d55e6a925fea47a8a12ec22dd5bd8a5397d1e04664265e8ec", + "size": 231169, + "subdir": "linux-64", + "timestamp": 1569349896713, + "version": "4.5.4" + }, + "coverage-5.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f9e25eb091292eab97209e287576fd5d", + "name": "coverage", + "sha256": "97b0a824211bdcb552294218e848df6c5bfd936343155e285e7c0f094ab1d4d8", + "size": 247850, + "subdir": "linux-64", + "timestamp": 1576871510409, + "version": "5.0" + }, + "coverage-5.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3c9a1349676daf6dc7053a6cc9f9774e", + "name": "coverage", + "sha256": "a23898fd3064cb1104dc9417a90c55c047c182b2ee090fa264204d2830c4eae6", + "size": 260963, + "subdir": "linux-64", + "timestamp": 1576871552777, + "version": "5.0" + }, + "coverage-5.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dce88ffbf96e79e76cd036b4f380c968", + "name": "coverage", + "sha256": "a2cbd4989297119dc98d0046e56a06902c18338dd958645930fd774c850ab8db", + "size": 253854, + "subdir": "linux-64", + "timestamp": 1576871539310, + "version": "5.0" + }, + "coverage-5.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "afe633c72cc0ed8c9dcc8a4765f1ff1d", + "name": "coverage", + "sha256": "86ad24ed4473bb785361fcf4d87a5a001110f79d2266cea65deaf489dc945bc2", + "size": 265075, + "subdir": "linux-64", + "timestamp": 1576871522564, + "version": "5.0" + }, + "coverage-5.0.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8c94f7c9a75931d62b7f0ab8c175392f", + "name": "coverage", + "sha256": "3746858ea3e11bd621b6e3ed7145f356405d4ac1c62edd70a59fc53d6d2895c9", + "size": 254289, + "subdir": "linux-64", + "timestamp": 1597708366939, + "version": "5.0.1" + }, + "coverage-5.0.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "64d8bdd190868969ac5f60f7ca90d9ea", + "name": "coverage", + "sha256": "0dcd8af117242b6770a8b906893c5e7ec407ea4d56e773da5ef6d70ec00279b5", + "size": 261778, + "subdir": "linux-64", + "timestamp": 1597708352414, + "version": "5.0.1" + }, + "coverage-5.0.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2ae243ab6d47538684911fe241715f7d", + "name": "coverage", + "sha256": "397fcae1bfa8e481a61751ea0197824de84691e9fdcc445d6f53eb8b29f4e1a7", + "size": 253873, + "subdir": "linux-64", + "timestamp": 1597708367045, + "version": "5.0.1" + }, + "coverage-5.0.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "75644f903a2e5f7b8e35028acef664b2", + "name": "coverage", + "sha256": "edc55c78598a27a2d1a866a42e573ebcd12cc31b2bb1c0c6d0473f29e38edacf", + "size": 262976, + "subdir": "linux-64", + "timestamp": 1597708900252, + "version": "5.0.2" + }, + "coverage-5.0.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c396cb0e7c9fd91c41b6a84a949586c4", + "name": "coverage", + "sha256": "d6ee098bcbecd3437c796b72a964fa2017882e290da4230c2e7d0abff5659d93", + "size": 263024, + "subdir": "linux-64", + "timestamp": 1597708872307, + "version": "5.0.2" + }, + "coverage-5.0.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a8ee2eb0e3afb52581b49e154ebc1b3a", + "name": "coverage", + "sha256": "bbfc9eda999fddebbcba96053e2480e053a59d948d34c326efc270ee04dded68", + "size": 253064, + "subdir": "linux-64", + "timestamp": 1597708876212, + "version": "5.0.2" + }, + "coverage-5.0.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9895cd6e4fd358762c3b38f7b26ed198", + "name": "coverage", + "sha256": "d43919c5842b9d25bae0c82aedd9f4fce9a8b31a8f3a34a6e6d58c5475a12bb8", + "size": 258208, + "subdir": "linux-64", + "timestamp": 1597709373631, + "version": "5.0.3" + }, + "coverage-5.0.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "87c64693d91d1c8d31290288ba5963e7", + "name": "coverage", + "sha256": "1c119619c3a15cd1468a136585baca4e0fceb3eee96a35492862fbcf5ab57873", + "size": 259829, + "subdir": "linux-64", + "timestamp": 1597709355466, + "version": "5.0.3" + }, + "coverage-5.0.3-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "135e83026bcbff2cf470f4e81e280406", + "name": "coverage", + "sha256": "1df7f60a658f1fbb5253f932db3af39c6ccf5d4240c576ba73d363a67a9dc388", + "size": 253249, + "subdir": "linux-64", + "timestamp": 1597709355506, + "version": "5.0.3" + }, + "coverage-5.0.4-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d8c80e2fc15040164fdbe889b35c358e", + "name": "coverage", + "sha256": "90024cbfd19762e20b0d41f0ec141197c0ccde8483778e6e75efe526bf6ef49e", + "size": 257035, + "subdir": "linux-64", + "timestamp": 1597709693850, + "version": "5.0.4" + }, + "coverage-5.0.4-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e94b302c0741895ba09c792f225a0e7a", + "name": "coverage", + "sha256": "8bd7891afbaf394deb72a1de2bd4cec2c5b495c2ba3086c7b2bcf336bf22a33c", + "size": 255622, + "subdir": "linux-64", + "timestamp": 1597711912863, + "version": "5.0.4" + }, + "coverage-5.0.4-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c5fabd66de426634d62ea23a38d89d46", + "name": "coverage", + "sha256": "2a0ad8cea7e0aad1905cfbbda8448ae2dd81e13ec1a48f2fdb5f97df9ee42460", + "size": 264854, + "subdir": "linux-64", + "timestamp": 1597709713027, + "version": "5.0.4" + }, + "coverage-5.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d7e4e03ce47ff8cc8574e9bf80e13808", + "name": "coverage", + "sha256": "ac3333ffebe7109951cae7f7d59e4ba99102a871cbc60d7c0d06c8c2f5c07c4e", + "size": 258103, + "subdir": "linux-64", + "timestamp": 1597709922277, + "version": "5.1" + }, + "coverage-5.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b1c670081234ccfacdcf62370cf3d8d0", + "name": "coverage", + "sha256": "86d493df523b4d748463b88c975aef2510bda8b02006bcb41309afab8ca9e7fc", + "size": 264667, + "subdir": "linux-64", + "timestamp": 1597709932222, + "version": "5.1" + }, + "coverage-5.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7a801e3a5d2d8485d4b5fcb5178a32a6", + "name": "coverage", + "sha256": "daa188acf0448a6dddbc0388aba5af3bdbb8b50a42585b3edf1eb84330c500ea", + "size": 255341, + "subdir": "linux-64", + "timestamp": 1597709945150, + "version": "5.1" + }, + "coverage-5.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9342c966194e713f1a45b7055958e5de", + "name": "coverage", + "sha256": "21c4369e15349d246f0ee439b8a241b35b81ca5035acb96a2aa8b6dd45fa9877", + "size": 255192, + "subdir": "linux-64", + "timestamp": 1597710103726, + "version": "5.2" + }, + "coverage-5.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "05ed5861d5d94d21287718211ae3ce1e", + "name": "coverage", + "sha256": "4766359bdc041656bf4e6b56c404cb4edafab2af91b571a0c37ca73e431f0651", + "size": 264587, + "subdir": "linux-64", + "timestamp": 1597710066639, + "version": "5.2" + }, + "coverage-5.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f3cc9df6448e27a42ccd0dadcc99ff13", + "name": "coverage", + "sha256": "16453c9bdba8045288982fd3a1d6727825a93f77e8ccd103f8c5835f1614a609", + "size": 258236, + "subdir": "linux-64", + "timestamp": 1597710071788, + "version": "5.2" + }, + "coverage-5.2.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "99d2b6ab352ef1480fadde2644e661ff", + "name": "coverage", + "sha256": "3d4b05f78071b16d164ad0dd122fde6d4bbdefc5ed0b119f8ba591a4d80de095", + "size": 261470, + "subdir": "linux-64", + "timestamp": 1597711755077, + "version": "5.2.1" + }, + "coverage-5.2.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "59037107cb7147a79a88af54c2a2b6d3", + "name": "coverage", + "sha256": "5673f77031dad213a153e84cd10e647d8465697ab70730f8ec32a7d26e441ffa", + "size": 256678, + "subdir": "linux-64", + "timestamp": 1597711783385, + "version": "5.2.1" + }, + "coverage-5.2.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f02636079b779d5e2dff5b161b465d71", + "name": "coverage", + "sha256": "b89fbc6aa86031b0f4ccbf9328d184f53b77cb9121009dd8f3b7f7005e67b11c", + "size": 255725, + "subdir": "linux-64", + "timestamp": 1597711761523, + "version": "5.2.1" + }, + "coverage-5.3-py36h27cfd23_2.tar.bz2": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "1294c69eb684959ea9de286f90965c17", + "name": "coverage", + "sha256": "2068339d9be0a31dd5aa76c477cc555eba86d1e8c63ad9b035900a64cb2f2d56", + "size": 266653, + "subdir": "linux-64", + "timestamp": 1605479797101, + "version": "5.3" + }, + "coverage-5.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "872e3b5ceb2b8e091ce7f9a5b3c2ffec", + "name": "coverage", + "sha256": "8699057a72973c411075f0b9cd3ba08e92b4c78076eca27a80f9d633afca06fb", + "size": 253430, + "subdir": "linux-64", + "timestamp": 1600293243800, + "version": "5.3" + }, + "coverage-5.3-py37h27cfd23_2.tar.bz2": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "619cd51aa2e93f6b589e2d48b4f795f2", + "name": "coverage", + "sha256": "7930b46d81605134ece896f2587d8c749c8b5b76bf19e7a80c6ce370b91f74c5", + "size": 277971, + "subdir": "linux-64", + "timestamp": 1605479767534, + "version": "5.3" + }, + "coverage-5.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a31352e0744faa829fbe9c1290490b31", + "name": "coverage", + "sha256": "29646114b98d9d24da7eeb8ef0a2f7131efa70a670ae9badd4429310ea1691c3", + "size": 260618, + "subdir": "linux-64", + "timestamp": 1600293252126, + "version": "5.3" + }, + "coverage-5.3-py38h27cfd23_2.tar.bz2": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "b75b64bacf59e4bb4cacd27d19c83bde", + "name": "coverage", + "sha256": "3ece94cb818def99fe7c0b525cc820360c6d5ad1283b4e992a2f48cebfc405c0", + "size": 272379, + "subdir": "linux-64", + "timestamp": 1605479808767, + "version": "5.3" + }, + "coverage-5.3-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "817abdcccad7a5b3d6d619835bf51cb4", + "name": "coverage", + "sha256": "04b59b35268b7b26c5caa43c4cba5c5eead17b5cef0c4b0be02507ed8ad14b74", + "size": 257584, + "subdir": "linux-64", + "timestamp": 1600293241538, + "version": "5.3" + }, + "coverage-5.3-py39h27cfd23_2.tar.bz2": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "a447879278202669590e404969f43702", + "name": "coverage", + "sha256": "802df4d35fc8d543515db7791fce17626d01aaa13651cfda2ae088cafbf38c04", + "size": 266154, + "subdir": "linux-64", + "timestamp": 1605479770319, + "version": "5.3" + }, + "coverage-5.3.1-py36h27cfd23_2.tar.bz2": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "0a707e004e8e87352737c9703f568275", + "name": "coverage", + "sha256": "549ed4b37d583e99ed71e56123dce41ab87542a9de78c41252254ed7d62f2fe4", + "size": 276088, + "subdir": "linux-64", + "timestamp": 1608575815738, + "version": "5.3.1" + }, + "coverage-5.3.1-py37h27cfd23_2.tar.bz2": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "ebdb83935d6434a08f4ef194228618b3", + "name": "coverage", + "sha256": "834edbc657aef9bae97a786fe3976edfc052f3f7673cf0d56b69c03f0942efb3", + "size": 271592, + "subdir": "linux-64", + "timestamp": 1608575847822, + "version": "5.3.1" + }, + "coverage-5.3.1-py38h27cfd23_2.tar.bz2": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "70a9b007640eb9479aa63fdb8f184bcc", + "name": "coverage", + "sha256": "ded67a753f6d33ab7ebfc19e4fbc7fcc5543227d4b48eca8c57af406270b855f", + "size": 276728, + "subdir": "linux-64", + "timestamp": 1608575848931, + "version": "5.3.1" + }, + "coverage-5.3.1-py39h27cfd23_2.tar.bz2": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "59089abaa78481bac4e5233feb014693", + "name": "coverage", + "sha256": "217dbd4dd31c01e20fc5c0eddbe78a32519abf955fabe61ef1a452c473704fa2", + "size": 273080, + "subdir": "linux-64", + "timestamp": 1608575855332, + "version": "5.3.1" + }, + "coverage-5.4-py36h27cfd23_2.tar.bz2": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "c563a2affccc09bd113bb1bcb9d3c953", + "name": "coverage", + "sha256": "4178fd4d04f627321d2920faeb48c241535db5f294a5afc7dde3a17a57b3365f", + "size": 262634, + "subdir": "linux-64", + "timestamp": 1611690835782, + "version": "5.4" + }, + "coverage-5.4-py37h27cfd23_2.tar.bz2": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "f4f2557a629c118b2f9bd4f8aea31d97", + "name": "coverage", + "sha256": "d2bd2ca96854279ee1344d8f54ae328fbc37c2792bebb71ecc22df1146cc361a", + "size": 269648, + "subdir": "linux-64", + "timestamp": 1611690859014, + "version": "5.4" + }, + "coverage-5.4-py38h27cfd23_2.tar.bz2": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "c72d2203af32eed535229db66cfd889f", + "name": "coverage", + "sha256": "9c09aa7d2ad14a5cb9164c1b2b7076d438d9edbbeffb3e1cdf2e65f261852876", + "size": 261864, + "subdir": "linux-64", + "timestamp": 1611690863238, + "version": "5.4" + }, + "coverage-5.4-py39h27cfd23_2.tar.bz2": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "e3eb8acc0c6ad07cb244407a9256e4f5", + "name": "coverage", + "sha256": "081f5b5447789aff3b671cd51694a95379d5b2882d8a7ba2872556ae3c5c3421", + "size": 271611, + "subdir": "linux-64", + "timestamp": 1611690396124, + "version": "5.4" + }, + "coverage-5.5-py310h7f8727e_2.tar.bz2": { + "build": "py310h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "md5": "e8f3649a02269dba7fa45c2a2ecca406", + "name": "coverage", + "sha256": "e0fe5b87743ce2f03dfd3e3f1d7e94393f6bae4e5cc7af453c2a3dbd5045ee12", + "size": 307083, + "subdir": "linux-64", + "timestamp": 1640789227122, + "version": "5.5" + }, + "coverage-5.5-py36h27cfd23_2.tar.bz2": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "6ff66c5bc100c271779b46e9633ce8d6", + "name": "coverage", + "sha256": "3dd6500eb920451ca080355f4e3e0b996266ab45d520670bd1869033e441cb96", + "size": 261054, + "subdir": "linux-64", + "timestamp": 1614614249083, + "version": "5.5" + }, + "coverage-5.5-py37h27cfd23_2.tar.bz2": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "fc5aee0151e020130d32315df9f5a8d3", + "name": "coverage", + "sha256": "28264f95edc85de22c18b5ca6aca320ca16cf24939594740c1b4cb81e3689d91", + "size": 271729, + "subdir": "linux-64", + "timestamp": 1614614912831, + "version": "5.5" + }, + "coverage-5.5-py38h27cfd23_2.tar.bz2": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "6b2e624b0a13c3ee7221f068a44ca12b", + "name": "coverage", + "sha256": "2d2b4000da3acc999000ae812d036e9b235dd1879aa1ca6531c3c0fd6ac7b086", + "size": 274227, + "subdir": "linux-64", + "timestamp": 1614613716436, + "version": "5.5" + }, + "coverage-5.5-py39h27cfd23_2.tar.bz2": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "9a5cc2b5d9f239a134a0441953ebd45c", + "name": "coverage", + "sha256": "085c267dc6b01d7c9a9d638d62106fcb3bbb62fbf12f4a01a07b54433eb3b5dc", + "size": 275280, + "subdir": "linux-64", + "timestamp": 1614614909419, + "version": "5.5" + }, + "coverage-6.2-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "10a1677483292ff777a87b6dd2db00f4", + "name": "coverage", + "sha256": "ec694a7fc0d0ccbbb5283c0c7cb657e6a8f8a4c6c7e2e9fc05cc99763e164cb8", + "size": 239254, + "subdir": "linux-64", + "timestamp": 1642021586349, + "version": "6.2" + }, + "coverage-6.2-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "860f16c079214a2d660da37e80948b37", + "name": "coverage", + "sha256": "e568612ff5d823f6e4db9845da7b98d2a7aac1051012410973a060a5d0179eb0", + "size": 241337, + "subdir": "linux-64", + "timestamp": 1642021641889, + "version": "6.2" + }, + "coverage-6.2-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "77f825bfff6d789c4ddf2aa7bd09e9cd", + "name": "coverage", + "sha256": "bec7415cdd9a42d5bebb70d1ce3b745f802e4839f80cbccf3bbf1add1429b799", + "size": 241799, + "subdir": "linux-64", + "timestamp": 1642021615856, + "version": "6.2" + }, + "coverage-6.3.2-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2f56a44bd27e4bc7b420a75a7528ea0e", + "name": "coverage", + "sha256": "51e584c0ac71d6bfcb185e193e7408869f85548362f870332787611e2c4a710f", + "size": 296396, + "subdir": "linux-64", + "timestamp": 1645522335286, + "version": "6.3.2" + }, + "coverage-6.3.2-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "caceee73c50c28bfdaf1ea97066f1b24", + "name": "coverage", + "sha256": "5de0835e9a2beac6aa89b4a18c6e7f38b6a71e4350c7f4df46e150c0f18dce39", + "size": 315321, + "subdir": "linux-64", + "timestamp": 1676827710421, + "version": "6.3.2" + }, + "coverage-6.3.2-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d0ff58462200c714b1e082c610de4cc1", + "name": "coverage", + "sha256": "1d7c47e26ed268ec74728ef044e2afc30f609b1640b0fc8da837810a80c23b08", + "size": 254305, + "subdir": "linux-64", + "timestamp": 1645521024803, + "version": "6.3.2" + }, + "coverage-6.3.2-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a82d4f5e0c72e998b4419beb81240418", + "name": "coverage", + "sha256": "fd8f96f978c5da94ba0eb509d4b53dcc0b13c1a8c8ad5f3e2c62fa2f3e29e19d", + "size": 261448, + "subdir": "linux-64", + "timestamp": 1645539149102, + "version": "6.3.2" + }, + "coverage-6.3.2-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "24c2c7f0548bc8d3dbf977337302206f", + "name": "coverage", + "sha256": "c80d5515e968f9e5cfd7d9bb4c6a12a0bf8c4affca9caf230d74a17606bc5ebe", + "size": 253020, + "subdir": "linux-64", + "timestamp": 1645539150555, + "version": "6.3.2" + }, + "coverage-7.2.2-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "tomli" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0c6af89da43159520053eb43c51b1c61", + "name": "coverage", + "sha256": "17b87dafd021b69362e2983831f9c8d069a0bd3d1ca72d613417b5532fc15657", + "size": 276657, + "subdir": "linux-64", + "timestamp": 1680092846648, + "version": "7.2.2" + }, + "coverage-7.2.2-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9e9f53ce079a0c31404eb6b9c54c6506", + "name": "coverage", + "sha256": "257177e2c7da16828e56ce69f22db4845d69b5fa9453e3cc540aa212c4ebad44", + "size": 357841, + "subdir": "linux-64", + "timestamp": 1680092752358, + "version": "7.2.2" + }, + "coverage-7.2.2-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "tomli" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b2b613f7351321fde224f168c76f376c", + "name": "coverage", + "sha256": "2261c0c1cb67e9cd4d196fc39d1ee38b3e7e29714aec8a6fec68c78d9c77a2c5", + "size": 274774, + "subdir": "linux-64", + "timestamp": 1680092783146, + "version": "7.2.2" + }, + "coverage-7.2.2-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "tomli" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "62cc572bb8db27f433df091fc0eb39a5", + "name": "coverage", + "sha256": "254315e753b818845611622dc55a1b467034d9824c42cd99fdac2eacaf50502c", + "size": 273072, + "subdir": "linux-64", + "timestamp": 1680092814360, + "version": "7.2.2" + }, + "coveralls-1.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=2.7,<2.8.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95f2eb0ddb9ead63f57ba4c04662e89b", + "name": "coveralls", + "sha256": "ed12e8fe38fea2b685ef6c8b15510e082693a42bdf0d8ad2571189d001248eab", + "size": 19625, + "subdir": "linux-64", + "timestamp": 1525269619727, + "version": "1.3.0" + }, + "coveralls-1.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.5,<3.6.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92c6034a6268252e466881b371c72c7a", + "name": "coveralls", + "sha256": "887227bb6a1e81d9a264465c5d9d0d31f666a3b1edecef424d0c07898f8e235f", + "size": 20046, + "subdir": "linux-64", + "timestamp": 1525269652503, + "version": "1.3.0" + }, + "coveralls-1.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "276255d172175425e892f131e89fcbcb", + "name": "coveralls", + "sha256": "34449b32f5ab033c89847e95cd5ea0ec6487704f2db270833efb963dd58617a7", + "size": 20022, + "subdir": "linux-64", + "timestamp": 1525269652165, + "version": "1.3.0" + }, + "coveralls-1.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=2.7,<2.8.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "941df4b77e6bb200dc6f8c8af11f6c9c", + "name": "coveralls", + "sha256": "e28540a3a9e0184980542546cfe6d6b1aa6e1e0f7fe7ba3a7af91decfb22d8be", + "size": 20439, + "subdir": "linux-64", + "timestamp": 1535510803306, + "version": "1.4.0" + }, + "coveralls-1.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.5,<3.6.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33879f81ac71c5ef8d3af0102e57c57c", + "name": "coveralls", + "sha256": "1adda290b9576fcb03875728b4d1f632e39f1e42f5ef581aa5edaf14fbae99fb", + "size": 20807, + "subdir": "linux-64", + "timestamp": 1535510448951, + "version": "1.4.0" + }, + "coveralls-1.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43ffa42fcf33c38c4fdbbfc2ff2d22b8", + "name": "coveralls", + "sha256": "5f3820ee15857e25102abbbcc21ec30a4f6f2ad5d7d9514d8bda86690c656706", + "size": 20748, + "subdir": "linux-64", + "timestamp": 1535510419312, + "version": "1.4.0" + }, + "coveralls-1.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cbe561ed4b7702a4bad9dba84e84224b", + "name": "coveralls", + "sha256": "49f40c1afdc77026c1600babd6d854956d34ed559b244a7df253ee89a1c2f69b", + "size": 20783, + "subdir": "linux-64", + "timestamp": 1535510489646, + "version": "1.4.0" + }, + "coveralls-1.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=2.7,<2.8.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "272492642ab0bc285c18fca7a947f0fa", + "name": "coveralls", + "sha256": "33b2d3964990cb5d95cdde68de08f53bb1e1785247d03cd611c2606dcf3303f5", + "size": 20259, + "subdir": "linux-64", + "timestamp": 1536263542769, + "version": "1.5.0" + }, + "coveralls-1.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.5,<3.6.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a5367d7be8cb0ec82fb1510c59146fd7", + "name": "coveralls", + "sha256": "b8a01d48ca5245c6a0fe9df7684469601f97e4f0e7ed3314e740a19586d54887", + "size": 20628, + "subdir": "linux-64", + "timestamp": 1536263595629, + "version": "1.5.0" + }, + "coveralls-1.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d10e523579f7a3692b98c6c00b55843", + "name": "coveralls", + "sha256": "0047292473756ac7eb181c0a9bfe1323e5cfc1c436bf8cae97a24306a72d6389", + "size": 20568, + "subdir": "linux-64", + "timestamp": 1536263488387, + "version": "1.5.0" + }, + "coveralls-1.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3aaa7bc6c95ee6fe34c5fb6b8ca9bfdb", + "name": "coveralls", + "sha256": "3949f7693a5c2b02694935b2992836da2be796bacec67e2ff9ba563998326bcf", + "size": 20602, + "subdir": "linux-64", + "timestamp": 1536263609510, + "version": "1.5.0" + }, + "coveralls-1.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=2.7,<2.8.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3217126e38ffad7264ead731e4fb694e", + "name": "coveralls", + "sha256": "b132444fb280259e09c3aba705b82a1e92cd11e43ee7314efa0ccc0ba786de58", + "size": 20246, + "subdir": "linux-64", + "timestamp": 1538367567151, + "version": "1.5.1" + }, + "coveralls-1.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "246392f6f115b99d545200cd89362ac8", + "name": "coveralls", + "sha256": "620c1ef042204e1c090a54bbf276e0183a118091ca49dba46857375edad29a10", + "size": 20611, + "subdir": "linux-64", + "timestamp": 1538367600005, + "version": "1.5.1" + }, + "coveralls-1.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f428dd3496a7d88c13726952377eab3", + "name": "coveralls", + "sha256": "29b7e9eb9d3083947013e2f66f1b090251ddffa9b8ce0b4447398439a12067c7", + "size": 20657, + "subdir": "linux-64", + "timestamp": 1538367574651, + "version": "1.5.1" + }, + "cpp-expected-1.0.0-hd09550d_0.tar.bz2": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "3c833cdb39dd6db2fa9be181da7bafe6", + "name": "cpp-expected", + "sha256": "3c48fb5b2aed4c8aced17de844b8c02f8e8ff1377665ab40e658acdef1ab153d", + "size": 120444, + "subdir": "linux-64", + "timestamp": 1651255703555, + "version": "1.0.0" + }, + "cpp-filesystem-1.5.10-hd09550d_0.tar.bz2": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd8315549a1c58cc1b9947cd9f7ed499", + "name": "cpp-filesystem", + "sha256": "eb5214997049b9920d2c06060c11efce21a99cff332e96953602f94c4bdd80cd", + "size": 37603, + "subdir": "linux-64", + "timestamp": 1645571464140, + "version": "1.5.10" + }, + "cppy-1.2.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b3edd3cf25f9ebd7401fefac29774bfa", + "name": "cppy", + "sha256": "5ffe9e028a9c5825e740fbb2492feac8daa5be284ad61156df9ac62dbc884ef7", + "size": 11992, + "subdir": "linux-64", + "timestamp": 1652450068463, + "version": "1.2.1" + }, + "cppy-1.2.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1d44d646f5534288d9adca04abb88c4e", + "name": "cppy", + "sha256": "44546520185a9ab6d06abb7e96d161dbebfa9e049ee1eab7fd020882c664995a", + "size": 13090, + "subdir": "linux-64", + "timestamp": 1676825189406, + "version": "1.2.1" + }, + "cppy-1.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0e0ab4f5b844450b122819cf80116704", + "name": "cppy", + "sha256": "0ee4faf9079159e65622e18b2123cc980777c6a1e082f02b453479c98da4ac01", + "size": 11980, + "subdir": "linux-64", + "timestamp": 1652450006384, + "version": "1.2.1" + }, + "cppy-1.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e8aa5d0a2b266211b044b0ecc7ea90bf", + "name": "cppy", + "sha256": "d61e97fdb626f3c5bda58516b90d0c2d9311300c665af291ea067ca3e64b9535", + "size": 11969, + "subdir": "linux-64", + "timestamp": 1652450031540, + "version": "1.2.1" + }, + "cppy-1.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a0fa10745c873842a50de92bb43d2d90", + "name": "cppy", + "sha256": "cabc1ad45746dbc2a1e3982392719d3c6eea738e1ef66f70d77113aa48cf80ea", + "size": 11980, + "subdir": "linux-64", + "timestamp": 1652449980876, + "version": "1.2.1" + }, + "cram-0.7-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "17646559d5af0e225c63b77b604a23f1", + "name": "cram", + "sha256": "8a3423a9f44c165c6b4cc2981e56cde39609c2c306d7265f32d3b6f1cd0aa132", + "size": 39855, + "subdir": "linux-64", + "timestamp": 1539182904468, + "version": "0.7" + }, + "cram-0.7-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "609e6545899d1d098f4160dd98fbc74d", + "name": "cram", + "sha256": "4b36cb59651f6218449bd71a7d37182f062f545240b502eebed319f77fa54b08", + "size": 40151, + "subdir": "linux-64", + "timestamp": 1539182927005, + "version": "0.7" + }, + "cram-0.7-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "bb94333dbd2348a76c014f81077390e3", + "name": "cram", + "sha256": "0f4256d19efdbac0a3a95f7355018861843208ccb73d8500dfaf9d4d795dac0f", + "size": 40157, + "subdir": "linux-64", + "timestamp": 1539182908399, + "version": "0.7" + }, + "crashtest-0.4.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d438519fe0c9b16941d49b1ba6ac8d2", + "name": "crashtest", + "sha256": "90e92ba119800690675cbfcf473c331e1da5c5f1ca9f46ba594bfe51b2eb9ef7", + "size": 14662, + "subdir": "linux-64", + "timestamp": 1679422478049, + "version": "0.4.1" + }, + "crashtest-0.4.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc067bc031dcd1023af740e6bb0b6c45", + "name": "crashtest", + "sha256": "e553471ccf4d392b6127796e7f5e515f3fe5c834f6ee5e44a6d11ac9c59224be", + "size": 17070, + "subdir": "linux-64", + "timestamp": 1679422403237, + "version": "0.4.1" + }, + "crashtest-0.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ee427540668f1fe8eaece3c3c1d47f1", + "name": "crashtest", + "sha256": "47929ac7d626cc20071675f62225f9cfb3aa2314b19d62bd9157051fea3b1c67", + "size": 14448, + "subdir": "linux-64", + "timestamp": 1679422428423, + "version": "0.4.1" + }, + "crashtest-0.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8845d6af876fcc7e37c3042f699b8f6b", + "name": "crashtest", + "sha256": "2f6ae51af6eed221e1138962e70d001334dfceccfeb78fd6dba4b1e048378b14", + "size": 14483, + "subdir": "linux-64", + "timestamp": 1679422452487, + "version": "0.4.1" + }, + "crender-0.3-ha290191_1.tar.bz2": { + "build": "ha290191_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0" + ], + "license": "MIT", + "md5": "489c18c9399ed47bd313fe53fef651da", + "name": "crender", + "sha256": "eec773c92c53bb558e9e6af7e636ba0a846c754377723266f8a304ffb2235430", + "size": 1228980, + "subdir": "linux-64", + "timestamp": 1644229016381, + "version": "0.3" + }, + "crender-0.4-ha290191_0.tar.bz2": { + "build": "ha290191_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f4278938f3ee003d30d22688f4a9fa6c", + "name": "crender", + "sha256": "2131d00c65df628af2d3ac20def12251b40289e1c94d9f5de136b8bb3d474801", + "size": 1227403, + "subdir": "linux-64", + "timestamp": 1654289728027, + "version": "0.4" + }, + "crender-0.5-ha290191_0.tar.bz2": { + "build": "ha290191_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "558aaa05e27866ddc442904c07d9b50b", + "name": "crender", + "sha256": "8b835aa664bc44526d3b7dcc1d2eadeab06f5b8a583e84656943d0ef25b66626", + "size": 1227819, + "subdir": "linux-64", + "timestamp": 1667935072086, + "version": "0.5" + }, + "cron-descriptor-1.2.24-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "f98a22e02e4c2cdd682adbf6919c92f1", + "name": "cron-descriptor", + "sha256": "da49b0cbb333dc8229191dcf41e09a1e2f302bf1ce4eeb56369e3bd5f4a5e892", + "size": 34458, + "subdir": "linux-64", + "timestamp": 1659858463731, + "version": "1.2.24" + }, + "cron-descriptor-1.2.24-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "5ff9806f65a51a66b44fa6b191caef5d", + "name": "cron-descriptor", + "sha256": "96453d3af01d06f681446ff2babe222b9dc3408c1d6f8016d7bd41b42a979062", + "size": 41671, + "subdir": "linux-64", + "timestamp": 1676830370154, + "version": "1.2.24" + }, + "cron-descriptor-1.2.24-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c3153512d86349e0c8f86bf7ab8d3800", + "name": "cron-descriptor", + "sha256": "428968b43663da56d89f590dcc3151bf25aeae719cbafe851bdb6b71ac4b397e", + "size": 34134, + "subdir": "linux-64", + "timestamp": 1659858547877, + "version": "1.2.24" + }, + "cron-descriptor-1.2.24-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "d14a2071a8e7262d03c1fb4172197800", + "name": "cron-descriptor", + "sha256": "59984d1efb193f304ee0d892c2a692d75d4218b11cfe658890951d24120ae576", + "size": 34280, + "subdir": "linux-64", + "timestamp": 1659858520811, + "version": "1.2.24" + }, + "cron-descriptor-1.2.24-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "3a9a8f8c942c451f3051229d6eb2d59d", + "name": "cron-descriptor", + "sha256": "8451f572451dc3786db19d912d15521c83325437370de856102fc1b488d5b049", + "size": 34278, + "subdir": "linux-64", + "timestamp": 1659858494211, + "version": "1.2.24" + }, + "croniter-1.3.7-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb9408f7467a8f47603c6641fad7415c", + "name": "croniter", + "sha256": "f6186c571a69a1731dc86aa0dbdb6c9bed085586188693211fe04dc29e436182", + "size": 31044, + "subdir": "linux-64", + "timestamp": 1666888102909, + "version": "1.3.7" + }, + "croniter-1.3.7-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2705573a68ccd396ebc63e0d487f6d8e", + "name": "croniter", + "sha256": "25745456edae1ff506694be9e198e0736f9040920bebdd525e7c6b1f33ddd0a1", + "size": 39449, + "subdir": "linux-64", + "timestamp": 1676830384053, + "version": "1.3.7" + }, + "croniter-1.3.7-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33cadaca2cefa5b0b46ecbc8b2c65a7f", + "name": "croniter", + "sha256": "dbc981181d3afa233af3069294cffe21c3c6eeac20715da9979f6c934b38cf72", + "size": 30748, + "subdir": "linux-64", + "timestamp": 1666888178639, + "version": "1.3.7" + }, + "croniter-1.3.7-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ceb8f0134c6997ca67a9845ad0bb74dd", + "name": "croniter", + "sha256": "7ff34f99cd879386fafc6abdd8e48ce7e868905a3dfc654aa4f0936656b83fd7", + "size": 30926, + "subdir": "linux-64", + "timestamp": 1666888128106, + "version": "1.3.7" + }, + "croniter-1.3.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "662cf10b610bdccacf68282828984a7b", + "name": "croniter", + "sha256": "f75f7aa2f6fceb043cfd27a3866414b5f06cd629dbd5e0fef6350705285364b3", + "size": 30941, + "subdir": "linux-64", + "timestamp": 1666888153084, + "version": "1.3.7" + }, + "crosstool-ng-1.23.0.rc2.diorcety.linux_target_2-h1bed415_4.tar.bz2": { + "build": "h1bed415_4", + "build_number": 4, + "depends": [], + "md5": "28cfa097b30945c7e857a14d6fd2a6c9", + "name": "crosstool-ng", + "sha256": "33507cffe2d928378a8fadeb1e9274fc0c96b800a7567051ed7bd23a654a6dd9", + "size": 21008693, + "subdir": "linux-64", + "timestamp": 1520532738497, + "version": "1.23.0.rc2.diorcety.linux_target_2" + }, + "crosstool-ng-1.23.0.rc2.diorcety.linux_target_2-h307460b_3.tar.bz2": { + "build": "h307460b_3", + "build_number": 3, + "depends": [ + "libtool", + "ncurses" + ], + "md5": "96d995b9abf414f038774fbf228aad72", + "name": "crosstool-ng", + "sha256": "146275567bbca8160cacde857e7f3618ae735d7a127d062957e7ce6f0b5df923", + "size": 19037408, + "subdir": "linux-64", + "timestamp": 1505664156306, + "version": "1.23.0.rc2.diorcety.linux_target_2" + }, + "crosstool-ng-1.23.0.rc2.diorcety.linux_target_2-h99d4681_3.tar.bz2": { + "build": "h99d4681_3", + "build_number": 3, + "depends": [ + "libtool", + "ncurses" + ], + "md5": "20c56008280f4de53f5f2df9a2245d0b", + "name": "crosstool-ng", + "sha256": "749a6f67f60abc255e6e60bc702489b4618b7dc9a2c3110c934ea131c7eb7227", + "size": 19038464, + "subdir": "linux-64", + "timestamp": 1507259455014, + "version": "1.23.0.rc2.diorcety.linux_target_2" + }, + "cryptacular-1.4.1-py27h7b6447c_1.tar.bz2": { + "build": "py27h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "pbkdf2", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "8dab78df9e2bd3fd1879a3ae52eddb9e", + "name": "cryptacular", + "sha256": "e1d74996b6160efc576474612bff2fe6fe96a127a8c2e92b9773847eb4e0fcda", + "size": 37155, + "subdir": "linux-64", + "timestamp": 1540442606790, + "version": "1.4.1" + }, + "cryptacular-1.4.1-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "pbkdf2", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "e0703599dd7512fd7398d5c857d3fed0", + "name": "cryptacular", + "sha256": "0e796e7438b6a5783476a506eecfeb7bcdd1daf589d3e964dc514c264449b026", + "size": 64135, + "subdir": "linux-64", + "timestamp": 1640808718287, + "version": "1.4.1" + }, + "cryptacular-1.4.1-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "pbkdf2", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "47b8f5ae81f980828535250c774712b3", + "name": "cryptacular", + "sha256": "eb1365e8b45d88a9ee6472e74c87531aa84f4707fd70beb987f1fcacb4f7df5a", + "size": 261138, + "subdir": "linux-64", + "timestamp": 1614007052275, + "version": "1.4.1" + }, + "cryptacular-1.4.1-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "pbkdf2", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "6d55b8e08326c4763dc16270d2413c15", + "name": "cryptacular", + "sha256": "0ca058b801c26d6dd8797f839632bb37956d4b1a5fa9bde9b19b29ee4223086b", + "size": 37680, + "subdir": "linux-64", + "timestamp": 1540442649746, + "version": "1.4.1" + }, + "cryptacular-1.4.1-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "pbkdf2", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "fd77b2c0f11d6bbce85d77ba8d684372", + "name": "cryptacular", + "sha256": "e7f45caaa0b552516fae13af8d74ebf413cb21092178d277714653effe73eb55", + "size": 259517, + "subdir": "linux-64", + "timestamp": 1614007058459, + "version": "1.4.1" + }, + "cryptacular-1.4.1-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "pbkdf2", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "0cbd3f75b87a78b13c2406630fd71054", + "name": "cryptacular", + "sha256": "f30075877743ae27407e955c70ee3639811efa41548b1dbf20c9f4c932fcaef8", + "size": 37727, + "subdir": "linux-64", + "timestamp": 1540442625042, + "version": "1.4.1" + }, + "cryptacular-1.4.1-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "pbkdf2", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "8d46b269e7c0c5ea782fd8b157c79084", + "name": "cryptacular", + "sha256": "92fe8f9b55b310844a2330f576050b8ee1c00dca817c7bbec18e2a504250e45d", + "size": 259504, + "subdir": "linux-64", + "timestamp": 1614007063035, + "version": "1.4.1" + }, + "cryptacular-1.4.1-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "pbkdf2", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "149d2438b32d61de84122cebc856ada0", + "name": "cryptacular", + "sha256": "179269891942e911f04390b994a762ffacc7c3094ba716db40044d0791de189c", + "size": 44888, + "subdir": "linux-64", + "timestamp": 1574097982401, + "version": "1.4.1" + }, + "cryptacular-1.4.1-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "pbkdf2", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "6e5057a3089ed26cfd5bb17ae0c0a503", + "name": "cryptacular", + "sha256": "86edd5d83681c7e4b57ab1babca4198141beb4da730547ce70617f47834c26b3", + "size": 259318, + "subdir": "linux-64", + "timestamp": 1614007049082, + "version": "1.4.1" + }, + "cryptacular-1.6.2-py36h7f8727e_1.tar.bz2": { + "build": "py36h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "pbkdf2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d16390568de17ea97466bdef80d10865", + "name": "cryptacular", + "sha256": "36c424b2f06a0de2df5ff43bc3341df5ec6637de822fdf93b39396a258cbb7b4", + "size": 36335, + "subdir": "linux-64", + "timestamp": 1629813218557, + "version": "1.6.2" + }, + "cryptacular-1.6.2-py37h7f8727e_1.tar.bz2": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "pbkdf2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b95db76261bd75be9a8079eb9cc2831c", + "name": "cryptacular", + "sha256": "2e2cd9d0800a3719ee4bb2562963e0248d56947e3fbff8a7628999dee31997f1", + "size": 36468, + "subdir": "linux-64", + "timestamp": 1629813194991, + "version": "1.6.2" + }, + "cryptacular-1.6.2-py38h7f8727e_1.tar.bz2": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "pbkdf2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "51cbfc11b309c2f7e759c28e9c42e2ca", + "name": "cryptacular", + "sha256": "9c1242c476ec8dcbd85b6bb456d45ff78b8cabc004ce2b3fc782d2b7f577b84c", + "size": 36518, + "subdir": "linux-64", + "timestamp": 1629813109188, + "version": "1.6.2" + }, + "cryptacular-1.6.2-py39h7f8727e_1.tar.bz2": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "pbkdf2", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "aef1ced0f6b9bb1db61f239dbad9ba14", + "name": "cryptacular", + "sha256": "135a620cec96bf32b51a79e72994336b257866f288d640356e15ae3b8c60f10b", + "size": 36499, + "subdir": "linux-64", + "timestamp": 1629804322276, + "version": "1.6.2" + }, + "cryptography-2.0.3-py27hea39389_1.tar.bz2": { + "build": "py27hea39389_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "f148e7ba6e445cc796392a7be0cdf022", + "name": "cryptography", + "sha256": "8ff5652ca7b6359f2129b0e04d14bffd485a6c5867a398103f521b174266dc20", + "size": 599075, + "subdir": "linux-64", + "timestamp": 1505692156287, + "version": "2.0.3" + }, + "cryptography-2.0.3-py35hef72dfd_1.tar.bz2": { + "build": "py35hef72dfd_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "f06d1a1812d48ec9203a7c1d85397bdc", + "name": "cryptography", + "sha256": "bf102e8f53d6b58546b2dcf99e43f76d01a829b055cd214be082baacd12652c5", + "size": 606987, + "subdir": "linux-64", + "timestamp": 1505692423670, + "version": "2.0.3" + }, + "cryptography-2.0.3-py36ha225213_1.tar.bz2": { + "build": "py36ha225213_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "22cb377a16ef5af133c9920f7e48069d", + "name": "cryptography", + "sha256": "18c7fe48ed19c9fa6f6de4cee0b28853e3b26c0ee5b629b09ffc7e28a7b08b5d", + "size": 605603, + "subdir": "linux-64", + "timestamp": 1505692706043, + "version": "2.0.3" + }, + "cryptography-2.1.3-py27hb02c096_0.tar.bz2": { + "build": "py27hb02c096_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "8d13b042e4131e84bd00f82fc53d1897", + "name": "cryptography", + "sha256": "6f6eef03d3c4202a06f720965aa511d4f59631c696af7df46f19226ddbc0f450", + "size": 610705, + "subdir": "linux-64", + "timestamp": 1511927139218, + "version": "2.1.3" + }, + "cryptography-2.1.3-py35hf0ae51d_0.tar.bz2": { + "build": "py35hf0ae51d_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "902a931c586921087f99644610880fe0", + "name": "cryptography", + "sha256": "77a2db7781c49c2a046d67d5f56a49a3ffcf4a40a3b135adbad795fbcffe68d6", + "size": 616619, + "subdir": "linux-64", + "timestamp": 1511927151113, + "version": "2.1.3" + }, + "cryptography-2.1.3-py36h6e66a57_0.tar.bz2": { + "build": "py36h6e66a57_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "791501a98cb5cb03cee1799a57c02f9e", + "name": "cryptography", + "sha256": "353caa3ed8a746dc43964c3effc7303989c084f793a708ee5b3d032d0999bda5", + "size": 615375, + "subdir": "linux-64", + "timestamp": 1511927270089, + "version": "2.1.3" + }, + "cryptography-2.1.4-py27h6697b16_0.tar.bz2": { + "build": "py27h6697b16_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "d9c78c59a1c6fd92153c171baf7483cc", + "name": "cryptography", + "sha256": "4dbc663fdcaf8d5b89621e90d1b3d0dd92be17a7f0960bc9b91d6d694ff75292", + "size": 610099, + "subdir": "linux-64", + "timestamp": 1512206182299, + "version": "2.1.4" + }, + "cryptography-2.1.4-py35hbeb2da1_0.tar.bz2": { + "build": "py35hbeb2da1_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "ada5795fc4903d468b4aa658dad1b641", + "name": "cryptography", + "sha256": "74fc452e69d67be6e76721ce7b2189b902811dbf9ea48d1b1828b44a2c93f48e", + "size": 616186, + "subdir": "linux-64", + "timestamp": 1512206186404, + "version": "2.1.4" + }, + "cryptography-2.1.4-py36hd09be54_0.tar.bz2": { + "build": "py36hd09be54_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "e7ede35f6822f761fc13fb0cab2a0488", + "name": "cryptography", + "sha256": "18f97746ba2781e59a5098f54df51aa7b3a812310a1f206e1396f023261077ed", + "size": 614745, + "subdir": "linux-64", + "timestamp": 1512206187827, + "version": "2.1.4" + }, + "cryptography-2.2.1-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2n,<1.0.3a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "3fefa86b184bc15786f45b10524cde38", + "name": "cryptography", + "sha256": "ce03d6a7222f7399f9cc83cd472f6fd4869395560cd4a3790c4ff89c919ee373", + "size": 607690, + "subdir": "linux-64", + "timestamp": 1521784801205, + "version": "2.2.1" + }, + "cryptography-2.2.1-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2n,<1.0.3a", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "b253ae6f7d2a8d7b9b6da2382571adee", + "name": "cryptography", + "sha256": "1a9cb6e4289988fe4dc10bc1b2093ac7fec5d640b0af210bfc1afe13253a5948", + "size": 613696, + "subdir": "linux-64", + "timestamp": 1521784907036, + "version": "2.2.1" + }, + "cryptography-2.2.1-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2n,<1.0.3a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "d5abc432e9e82ff38ad2c02415149947", + "name": "cryptography", + "sha256": "5a72a634608e8cda9b2ccad524891e6944fdc5586c6054fc7f4bd87a79c01686", + "size": 613357, + "subdir": "linux-64", + "timestamp": 1521784620488, + "version": "2.2.1" + }, + "cryptography-2.2.2-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2o,<1.0.3a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "285e263209af73c673fa464cd89f9638", + "name": "cryptography", + "sha256": "3e3236e03eab558680c186e7f53ee38b3a86a6fb7fe2d8d3192d15258df61f4e", + "size": 607201, + "subdir": "linux-64", + "timestamp": 1522685523370, + "version": "2.2.2" + }, + "cryptography-2.2.2-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "4074dcce64af4fdc5806ae4abe6636bc", + "name": "cryptography", + "sha256": "6f2274efc795a7aff9874f146efa33955e20400aeb4e630cf8aac2fb3b10cb0d", + "size": 613526, + "subdir": "linux-64", + "timestamp": 1522686225010, + "version": "2.2.2" + }, + "cryptography-2.2.2-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "1d2edf3f08333b5e8f414c1bc3a9124f", + "name": "cryptography", + "sha256": "b4d3cb6fd1572f80af27b62d5c240950e85d375536ea4d98a3e3e8f099f23830", + "size": 613329, + "subdir": "linux-64", + "timestamp": 1522685313430, + "version": "2.2.2" + }, + "cryptography-2.2.2-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "e699afd01186b8a235491f8cf994f47c", + "name": "cryptography", + "sha256": "afd9d2a69f08f76b86ef11747bca3390ecf60adeed469779b59cf1cf1027dc0c", + "size": 613022, + "subdir": "linux-64", + "timestamp": 1530733149138, + "version": "2.2.2" + }, + "cryptography-2.3-py27hb7f436b_0.tar.bz2": { + "build": "py27hb7f436b_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "cryptography-vectors 2.3.*", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "8920f7db23b528662a4789065016c2ce", + "name": "cryptography", + "sha256": "fd9407b9eb49121d843aff5784043cf6544c0f2e56f2a0428c00ab4627dfdf6f", + "size": 590664, + "subdir": "linux-64", + "timestamp": 1532993453599, + "version": "2.3" + }, + "cryptography-2.3-py27hb7f436b_1.tar.bz2": { + "build": "py27hb7f436b_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "cryptography-vectors 2.3.*", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "37932f76424a60420e1ca3de692c42cc", + "name": "cryptography", + "sha256": "7f40737f1dd084b33e1aaec32f57bf72b4d29609eeb69a21bc5f306c465aa529", + "size": 589883, + "subdir": "linux-64", + "timestamp": 1534349625743, + "version": "2.3" + }, + "cryptography-2.3-py35hb7f436b_0.tar.bz2": { + "build": "py35hb7f436b_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "cryptography-vectors 2.3.*", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "65f32b68aa70867572f198bb0c5df05a", + "name": "cryptography", + "sha256": "cf7da215292ce18db23161d18603657471fa957a2289334dce1fdc879637dd2c", + "size": 599879, + "subdir": "linux-64", + "timestamp": 1532991004241, + "version": "2.3" + }, + "cryptography-2.3-py35hb7f436b_1.tar.bz2": { + "build": "py35hb7f436b_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "cryptography-vectors 2.3.*", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "006e44c1d5375b6855ec3d939b8dd762", + "name": "cryptography", + "sha256": "79c80e17dd25254cc139f999e106dddfb21e0080bdb0d9986424094b5b4fe87e", + "size": 598077, + "subdir": "linux-64", + "timestamp": 1534349998681, + "version": "2.3" + }, + "cryptography-2.3-py36hb7f436b_0.tar.bz2": { + "build": "py36hb7f436b_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "cryptography-vectors 2.3.*", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "d015a27c62b911b1286bf211d4b39a63", + "name": "cryptography", + "sha256": "798aeec65bc954a4dfae92b7e01a5fb1925f274776d05dba3d3f2d88abaccec0", + "size": 598888, + "subdir": "linux-64", + "timestamp": 1532990527437, + "version": "2.3" + }, + "cryptography-2.3-py36hb7f436b_1.tar.bz2": { + "build": "py36hb7f436b_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "cryptography-vectors 2.3.*", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "693bbcd98651f84de8891e4916e0e6de", + "name": "cryptography", + "sha256": "610966044bb8b150cda62fd00d0aeef9184dc2a47ba2b553940992318c5cd08e", + "size": 597452, + "subdir": "linux-64", + "timestamp": 1534350351218, + "version": "2.3" + }, + "cryptography-2.3-py37hb7f436b_0.tar.bz2": { + "build": "py37hb7f436b_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "cryptography-vectors 2.3.*", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "637e01deeeb0134efd63c30b7915a859", + "name": "cryptography", + "sha256": "761eac7d6f7578ae1c288b9ecec9539992351922314c3f14144a0cebe6880234", + "size": 598672, + "subdir": "linux-64", + "timestamp": 1532990627280, + "version": "2.3" + }, + "cryptography-2.3-py37hb7f436b_1.tar.bz2": { + "build": "py37hb7f436b_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "cryptography-vectors 2.3.*", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "7847bde4d0d6a03f173912c4a326703e", + "name": "cryptography", + "sha256": "18ced3ee283d00587f52188f75ff3ec0d09d5df8f7b09b1d74f345f43ceee51a", + "size": 597181, + "subdir": "linux-64", + "timestamp": 1534349286938, + "version": "2.3" + }, + "cryptography-2.3.1-py27h1ba5d50_2.tar.bz2": { + "build": "py27h1ba5d50_2", + "build_number": 2, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "d12364a944f1e7f9e52fd7fc13f98f51", + "name": "cryptography", + "sha256": "9aaa05bcf27e9978a3c3ab9ddbcceda7e7f617750dde28e84fcd03e65bd7e758", + "size": 600099, + "subdir": "linux-64", + "timestamp": 1540943752934, + "version": "2.3.1" + }, + "cryptography-2.3.1-py27hc365091_0.tar.bz2": { + "build": "py27hc365091_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "c3bec312747512d971b111f4a01e1e25", + "name": "cryptography", + "sha256": "feedddf85b472a2daedb48ac3d5342a5164a15c891defcfefb1cc1b375148ee8", + "size": 589849, + "subdir": "linux-64", + "timestamp": 1535130005605, + "version": "2.3.1" + }, + "cryptography-2.3.1-py35hc365091_0.tar.bz2": { + "build": "py35hc365091_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "fbd1c2f8eae89be0f4ea501e01470343", + "name": "cryptography", + "sha256": "52910de3d28f62014de8b990daf285124818cff9c84682fdcb3842bce7fa62de", + "size": 598708, + "subdir": "linux-64", + "timestamp": 1535126712495, + "version": "2.3.1" + }, + "cryptography-2.3.1-py36h1ba5d50_2.tar.bz2": { + "build": "py36h1ba5d50_2", + "build_number": 2, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "d596f263c07a454d1bf74c6a0cc00d13", + "name": "cryptography", + "sha256": "26fc913bc56899d43b367aa9bdcf6971222591e36fe1299c92b69b7b11f146b7", + "size": 610229, + "subdir": "linux-64", + "timestamp": 1540943770160, + "version": "2.3.1" + }, + "cryptography-2.3.1-py36hc365091_0.tar.bz2": { + "build": "py36hc365091_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "e108ffb6c1c66758c768eb535cd5863e", + "name": "cryptography", + "sha256": "46b7539d062962d08248b81b1ec50e320128dba41e229b6f9729cfc526091038", + "size": 598775, + "subdir": "linux-64", + "timestamp": 1535129032419, + "version": "2.3.1" + }, + "cryptography-2.3.1-py37h1ba5d50_2.tar.bz2": { + "build": "py37h1ba5d50_2", + "build_number": 2, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "de2f65b8b8e5fb90a8cfe600857e1d67", + "name": "cryptography", + "sha256": "44a860e6a112b995f19184e20edf2ace8d242e13964b1dadd27e954e7f679d48", + "size": 610425, + "subdir": "linux-64", + "timestamp": 1540943787408, + "version": "2.3.1" + }, + "cryptography-2.3.1-py37hc365091_0.tar.bz2": { + "build": "py37hc365091_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "302605b2f80ccbc025f7ad0c4325c772", + "name": "cryptography", + "sha256": "878ff2389fc1846528110113a9a34b9570a0a5f23ec981b004376ed962607cf6", + "size": 599020, + "subdir": "linux-64", + "timestamp": 1535126718521, + "version": "2.3.1" + }, + "cryptography-2.4.1-py27h1ba5d50_0.tar.bz2": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "cf4f6dd192c7ab351b522af9f1af147d", + "name": "cryptography", + "sha256": "aa256481661478ae99651aa26f7402938b84a5fca4cd48a5b6421b674d994115", + "size": 620701, + "subdir": "linux-64", + "timestamp": 1542313386506, + "version": "2.4.1" + }, + "cryptography-2.4.1-py27h1ba5d50_1.tar.bz2": { + "build": "py27h1ba5d50_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "e67757fde518203a9a986c0c5d8d6e1e", + "name": "cryptography", + "sha256": "b1f7c3c24613da48f40f5ad5aae211fc7b20936b203a0da48f0d5509974cf79e", + "size": 621924, + "subdir": "linux-64", + "timestamp": 1544809946456, + "version": "2.4.1" + }, + "cryptography-2.4.1-py36h1ba5d50_0.tar.bz2": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "a61b6ed449ff325dadfbd3aab55adb7b", + "name": "cryptography", + "sha256": "1d9de436586327a7387e9494185f8e4e0b1ec77a7a62dd83ae0aa0f4adb4e436", + "size": 633485, + "subdir": "linux-64", + "timestamp": 1542380950028, + "version": "2.4.1" + }, + "cryptography-2.4.1-py36h1ba5d50_1.tar.bz2": { + "build": "py36h1ba5d50_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "dce2a4ada67789777493de744dae106d", + "name": "cryptography", + "sha256": "751b92c2ef430ab2f5d85dc60936fecda05cbc84a2cfce3ead822916281cd1af", + "size": 630670, + "subdir": "linux-64", + "timestamp": 1544809971014, + "version": "2.4.1" + }, + "cryptography-2.4.1-py37h1ba5d50_0.tar.bz2": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "33f18fd062172e0b3610e611cf346dd5", + "name": "cryptography", + "sha256": "2b5fff5730e1c61b843e3da78996e8be2699a4a46f28778ed88d0f0ea479a972", + "size": 621511, + "subdir": "linux-64", + "timestamp": 1542313358511, + "version": "2.4.1" + }, + "cryptography-2.4.1-py37h1ba5d50_1.tar.bz2": { + "build": "py37h1ba5d50_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "7582eab0ea5ae8162c045a4f527c1bfc", + "name": "cryptography", + "sha256": "baf4f70a8ed5a60f6b306d9fa28c97eda9afd2a5a6e3b2866c5f94e88c04a7d2", + "size": 633860, + "subdir": "linux-64", + "timestamp": 1544809883636, + "version": "2.4.1" + }, + "cryptography-2.4.2-py27h1ba5d50_0.tar.bz2": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "dc2fb74d75c94de626e3629f62c81dff", + "name": "cryptography", + "sha256": "76cca2c4995d758c2e7f0a7e3d2fc30ef58c2fe677569f53f177517fe6e3ba5c", + "size": 619681, + "subdir": "linux-64", + "timestamp": 1545070801909, + "version": "2.4.2" + }, + "cryptography-2.4.2-py36h1ba5d50_0.tar.bz2": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "fd11dd1076419e54f162fa9401193247", + "name": "cryptography", + "sha256": "e5a73ec10b1704f5b22e6eced7ba4491451550efe292e657134bd7eb0f0dad6a", + "size": 632547, + "subdir": "linux-64", + "timestamp": 1545070871266, + "version": "2.4.2" + }, + "cryptography-2.4.2-py37h1ba5d50_0.tar.bz2": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "a740873aeb1e64f1a03979d760992f81", + "name": "cryptography", + "sha256": "278394c1f70316d75abccf935df897a0b8945735f55b7e5102183764f645abb6", + "size": 621073, + "subdir": "linux-64", + "timestamp": 1545070849520, + "version": "2.4.2" + }, + "cryptography-2.5-py27h1ba5d50_0.tar.bz2": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "52a21601e003d83489f01a6bd32a160f", + "name": "cryptography", + "sha256": "bab3835a9944224aa4d9a9ff5f0e053423ae87d5d30ad0d11481f5ede6cfdc4c", + "size": 640781, + "subdir": "linux-64", + "timestamp": 1549646478549, + "version": "2.5" + }, + "cryptography-2.5-py36h1ba5d50_0.tar.bz2": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "7fe927b372701be2e969392401682b55", + "name": "cryptography", + "sha256": "914bf85ceb85dfa3e04c41daea8daf75b9eac5ea1ee76b1cb06b3faee8d70d87", + "size": 658244, + "subdir": "linux-64", + "timestamp": 1549646495097, + "version": "2.5" + }, + "cryptography-2.5-py37h1ba5d50_0.tar.bz2": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "0dba018feead3e83c69ba5ad7abe1617", + "name": "cryptography", + "sha256": "f871351f25a920ae0a8dc58fec6bfc5e087fadfff731164eb5d2f62386420350", + "size": 647531, + "subdir": "linux-64", + "timestamp": 1549646481606, + "version": "2.5" + }, + "cryptography-2.6.1-py27h1ba5d50_0.tar.bz2": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1b,<1.1.2a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "5d8f3065d8c6db314cb411cbf564648e", + "name": "cryptography", + "sha256": "ccb7c920f7a25ea902568470a0e92c54c4015f618f31cce4e637e99a6cae1b1c", + "size": 621941, + "subdir": "linux-64", + "timestamp": 1552319461370, + "version": "2.6.1" + }, + "cryptography-2.6.1-py36h1ba5d50_0.tar.bz2": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1b,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "dbb8b2154f788d2980dc4c27ba4eeeb1", + "name": "cryptography", + "sha256": "5dafcfcc3d2a7c31a0c1d83301a086f5d6e785e4cb1ddc1e43c29d2af04dec10", + "size": 623246, + "subdir": "linux-64", + "timestamp": 1552319483183, + "version": "2.6.1" + }, + "cryptography-2.6.1-py37h1ba5d50_0.tar.bz2": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1b,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "cc56c168b24c113d457a320f13c5c029", + "name": "cryptography", + "sha256": "cd31872a95ee558b1425ae96ca14c24a489ca97f2433edcd16583488260f5702", + "size": 631088, + "subdir": "linux-64", + "timestamp": 1552319401372, + "version": "2.6.1" + }, + "cryptography-2.7-py27h1ba5d50_0.tar.bz2": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1c,<1.1.2a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "6947d7bd72586c145f9ab992a7e2b157", + "name": "cryptography", + "sha256": "f027348e6e66dc24b2a7c628747f508bd01514357ec21518019fe14f448f385b", + "size": 615944, + "subdir": "linux-64", + "timestamp": 1559575608878, + "version": "2.7" + }, + "cryptography-2.7-py36h1ba5d50_0.tar.bz2": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1c,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "6c8496d60a494d9a9b0f0e032b6ed62e", + "name": "cryptography", + "sha256": "2d4eff6d53f436442a4e960a74ae303b05d0adbaee952fa6ed00380c226b3f66", + "size": 631550, + "subdir": "linux-64", + "timestamp": 1559575641293, + "version": "2.7" + }, + "cryptography-2.7-py37h1ba5d50_0.tar.bz2": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1c,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "81d7b8506c5ef5ef27f16b1aabdc8fdc", + "name": "cryptography", + "sha256": "92fb68246d5286ee02c0c853586cf239812b6b98aabc73a5ec1b345d6471944b", + "size": 623018, + "subdir": "linux-64", + "timestamp": 1559575588648, + "version": "2.7" + }, + "cryptography-2.8-py27h1ba5d50_0.tar.bz2": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.8", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "5ac45d87ab55cc03a89bcc6026266712", + "name": "cryptography", + "sha256": "e597328444adcf712242af7a0b5ca90a11da5959b25fb8b6ab777c96fffe0cf8", + "size": 629156, + "subdir": "linux-64", + "timestamp": 1571690224415, + "version": "2.8" + }, + "cryptography-2.8-py36h1ba5d50_0.tar.bz2": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.8", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "acca67d51b2c058d7e4c0e73712335cc", + "name": "cryptography", + "sha256": "3bb1b4207b376b418bd24b24d93c8a7dc51c57a61d42f485363d9e3da6bcf46b", + "size": 635182, + "subdir": "linux-64", + "timestamp": 1571690325240, + "version": "2.8" + }, + "cryptography-2.8-py37h1ba5d50_0.tar.bz2": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.8", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "5bf4ff2e9b2d71e4d3e537b95807b92a", + "name": "cryptography", + "sha256": "5da5b706c4d6f93fab3d68ec0c9b0bb64dd4e2913e4950adce5817abe894276a", + "size": 626475, + "subdir": "linux-64", + "timestamp": 1571690208325, + "version": "2.8" + }, + "cryptography-2.8-py38h1ba5d50_0.tar.bz2": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.8", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "66aebef56eb622f88faf5899e16008b5", + "name": "cryptography", + "sha256": "78da89592fd10819e5309a03540e2ea6757a42406c7c8bea9b2eea46a1ca842a", + "size": 632783, + "subdir": "linux-64", + "timestamp": 1574098022173, + "version": "2.8" + }, + "cryptography-2.9.2-py36h1ba5d50_0.tar.bz2": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "8961ec4d027bc124522f0d469ca437cd", + "name": "cryptography", + "sha256": "f1b53f6e96bc7861d435f6a9301f6b409edfede5b9b26a0807686497f1bf3331", + "size": 641490, + "subdir": "linux-64", + "timestamp": 1588861130915, + "version": "2.9.2" + }, + "cryptography-2.9.2-py37h1ba5d50_0.tar.bz2": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "39fb55ef177bbaf7b3fa672febe9282a", + "name": "cryptography", + "sha256": "7353672b2255c5a08fc97fb60a5e1df3aa6d0649dd014440109fa75ebe692254", + "size": 640872, + "subdir": "linux-64", + "timestamp": 1588861083920, + "version": "2.9.2" + }, + "cryptography-2.9.2-py38h1ba5d50_0.tar.bz2": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "00b0fe3da5beba9a974a7131a1ec6f52", + "name": "cryptography", + "sha256": "6b70a3b459af0d60880e16c2cf8c99cbc27ca339a53af3339c17ba552ba582af", + "size": 644864, + "subdir": "linux-64", + "timestamp": 1588861116459, + "version": "2.9.2" + }, + "cryptography-2.9.2-py39h3c74f83_0.tar.bz2": { + "build": "py39h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "56d866e03bff7104719cb81234ab4c1f", + "name": "cryptography", + "sha256": "831630e5587e25cbb4c4fa5c47903a5920157d29f00f89df041c7a4f699f1788", + "size": 636644, + "subdir": "linux-64", + "timestamp": 1608674166951, + "version": "2.9.2" + }, + "cryptography-3.0-py36h1ba5d50_0.tar.bz2": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "a255b860a3a69f8a651f8df336de7a40", + "name": "cryptography", + "sha256": "46dc30e1205deb805bf6a2ce24259e558269ff08c60ebf0bb94b9fbdd0ba0c0e", + "size": 651829, + "subdir": "linux-64", + "timestamp": 1598371499892, + "version": "3.0" + }, + "cryptography-3.0-py37h1ba5d50_0.tar.bz2": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "1fc4a21d1aae5fe50e4c7861182b39c8", + "name": "cryptography", + "sha256": "5f36ea667124b4c807423519cd73b3d24c613b489cc9e1f030eccb9959f2d589", + "size": 661389, + "subdir": "linux-64", + "timestamp": 1598371489791, + "version": "3.0" + }, + "cryptography-3.0-py38h1ba5d50_0.tar.bz2": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "7ef8ce27cbbd62710166e81d216c2a2d", + "name": "cryptography", + "sha256": "6ba723e0148e744871781f216f4a0831d34a371bd5bd6c1403c758a8af58d492", + "size": 662071, + "subdir": "linux-64", + "timestamp": 1598371459348, + "version": "3.0" + }, + "cryptography-3.1-py36h1ba5d50_0.tar.bz2": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "83763a36de7f82768eb54858efe54fe5", + "name": "cryptography", + "sha256": "8064ce6c2c6129f28d12c0445f7cfa72dda2d71e27e6bca965f31c1476d9ed6c", + "size": 636797, + "subdir": "linux-64", + "timestamp": 1598892109325, + "version": "3.1" + }, + "cryptography-3.1-py37h1ba5d50_0.tar.bz2": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "39c6f1110564c2c7dbdef5f7485505eb", + "name": "cryptography", + "sha256": "94eb435a97ba6faa786ea8b8a33fd4ea051654c3d22310ba9932c61e604604b2", + "size": 633021, + "subdir": "linux-64", + "timestamp": 1598892092822, + "version": "3.1" + }, + "cryptography-3.1-py38h1ba5d50_0.tar.bz2": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "145eacd5e9b643f4f6f398c926fa3c06", + "name": "cryptography", + "sha256": "8bdc630eea5b37dc141048e3c6cf1f51e570bb631985c2db0bc440966b390996", + "size": 635030, + "subdir": "linux-64", + "timestamp": 1598892096360, + "version": "3.1" + }, + "cryptography-3.1.1-py36h1ba5d50_0.tar.bz2": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "7981464f23421766394b4d5924ea5025", + "name": "cryptography", + "sha256": "6d701b68a6f2f4fb3f2a9b3e9749f672f0ef17aaf2fbcddde34e654d5ce59478", + "size": 626738, + "subdir": "linux-64", + "timestamp": 1601047511597, + "version": "3.1.1" + }, + "cryptography-3.1.1-py37h1ba5d50_0.tar.bz2": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "aed43bfc8eccfae8834b731289c1609a", + "name": "cryptography", + "sha256": "dc253cdac73e28f03d6cdf0ac854932e9c125d6f0b4944cfdcc9d0800b254f4b", + "size": 640000, + "subdir": "linux-64", + "timestamp": 1601046870414, + "version": "3.1.1" + }, + "cryptography-3.1.1-py38h1ba5d50_0.tar.bz2": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "3d6a7099497d6c831918739ddbd6eac3", + "name": "cryptography", + "sha256": "53a2b420bde3d72078d00e31739e3e8006e45256db984601924be0a79896a2d1", + "size": 633135, + "subdir": "linux-64", + "timestamp": 1601046867723, + "version": "3.1.1" + }, + "cryptography-3.2.1-py36h3c74f83_1.tar.bz2": { + "build": "py36h3c74f83_1", + "build_number": 1, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "df7fdd3beb5a0591517d7e184a95746c", + "name": "cryptography", + "sha256": "7b86cc1b72b902332a3d8993853d620484fddf3eec2a78a21b15009f3a0a0cc9", + "size": 646411, + "subdir": "linux-64", + "timestamp": 1605544536097, + "version": "3.2.1" + }, + "cryptography-3.2.1-py37h3c74f83_1.tar.bz2": { + "build": "py37h3c74f83_1", + "build_number": 1, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "53f5a0cfbeefe4188f58637e5fb61cef", + "name": "cryptography", + "sha256": "fbb747910388fc4af2146ffa50b747b5818a3bca78b6ea930628ccec32aeca5d", + "size": 646083, + "subdir": "linux-64", + "timestamp": 1605544506648, + "version": "3.2.1" + }, + "cryptography-3.2.1-py38h3c74f83_1.tar.bz2": { + "build": "py38h3c74f83_1", + "build_number": 1, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "64e6565d669e12be91bf52526009e544", + "name": "cryptography", + "sha256": "3c2b2b267c2e2afb78cdaa91e8ad46418ebfbdc2f89ceb66beeb1d24209d05fb", + "size": 655837, + "subdir": "linux-64", + "timestamp": 1605544552873, + "version": "3.2.1" + }, + "cryptography-3.2.1-py39h3c74f83_1.tar.bz2": { + "build": "py39h3c74f83_1", + "build_number": 1, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.9,<3.10.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "42578d3f6d40e9dc160ec2d5fcae37b7", + "name": "cryptography", + "sha256": "5e50660c30b5d1e904e2c210933cf621eeb7cb26190674ffee4c17d45f06024e", + "size": 645639, + "subdir": "linux-64", + "timestamp": 1605544544832, + "version": "3.2.1" + }, + "cryptography-3.3-py36h3c74f83_0.tar.bz2": { + "build": "py36h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "6f317198a170f80b80e47322ceef9dd9", + "name": "cryptography", + "sha256": "393f6d083d98ff2db6d066031c98fa3af7322dfb8a32300ae5337606e1b5fa72", + "size": 640627, + "subdir": "linux-64", + "timestamp": 1607540738699, + "version": "3.3" + }, + "cryptography-3.3-py37h3c74f83_0.tar.bz2": { + "build": "py37h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "17202a97535cb8d3ad3bd8d83e656d0e", + "name": "cryptography", + "sha256": "fa088338e9c9b27d4b4d8ab4bc24c6883b6e8811b0e84a2cad2e5f7d866fa725", + "size": 640698, + "subdir": "linux-64", + "timestamp": 1607540746536, + "version": "3.3" + }, + "cryptography-3.3-py38h3c74f83_0.tar.bz2": { + "build": "py38h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "9fc21da4d6c726732d68617c9a5f032f", + "name": "cryptography", + "sha256": "8ca128394b78c5885259935a0f340a8323ee816c0d5b141942b94fc73f703d45", + "size": 640827, + "subdir": "linux-64", + "timestamp": 1607540772240, + "version": "3.3" + }, + "cryptography-3.3-py39h3c74f83_0.tar.bz2": { + "build": "py39h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.9,<3.10.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "c0a056cf6eb148697c8c8a2272f1c627", + "name": "cryptography", + "sha256": "b31565eda58fa2aea0cc42c5c4d93ed6bd6d320dabfe2e374d79932de65366a1", + "size": 651296, + "subdir": "linux-64", + "timestamp": 1607540754998, + "version": "3.3" + }, + "cryptography-3.3.1-py36h3c74f83_0.tar.bz2": { + "build": "py36h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "5a8339a503d72500931c227157c2b5ae", + "name": "cryptography", + "sha256": "28a1f95129dfb9468fbd4657c171e5bd7674b72e8caeb506d5f107686f96f4de", + "size": 652818, + "subdir": "linux-64", + "timestamp": 1607635361733, + "version": "3.3.1" + }, + "cryptography-3.3.1-py36h3c74f83_1.tar.bz2": { + "build": "py36h3c74f83_1", + "build_number": 1, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "1b1b38d49791ebc589a7e07c90f49364", + "name": "cryptography", + "sha256": "c2d848a2641dcc2a5b61cac7e1d985a3c0b0606953957442fcc059f2d4daa2fb", + "size": 647996, + "subdir": "linux-64", + "timestamp": 1613401458050, + "version": "3.3.1" + }, + "cryptography-3.3.1-py37h3c74f83_0.tar.bz2": { + "build": "py37h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "1fdc0a06b1a30dc731d71ecf6f12490c", + "name": "cryptography", + "sha256": "0b6525ed6683a7792bc4154f843e2ce3631041428df4eb854e3e497b688ff03a", + "size": 639757, + "subdir": "linux-64", + "timestamp": 1607635405608, + "version": "3.3.1" + }, + "cryptography-3.3.1-py37h3c74f83_1.tar.bz2": { + "build": "py37h3c74f83_1", + "build_number": 1, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "d943851a5a5dcda717d28d259bed8d85", + "name": "cryptography", + "sha256": "82c813a17356a89e1d1d453effbae8716b42f164b25dbdb4c34f98a8588a87a2", + "size": 647108, + "subdir": "linux-64", + "timestamp": 1613401505861, + "version": "3.3.1" + }, + "cryptography-3.3.1-py38h3c74f83_0.tar.bz2": { + "build": "py38h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "fa632a48afcda24f7e0abe74f6683bdf", + "name": "cryptography", + "sha256": "112d372f35cfcb7e8aedf10ca29c607e8b71dbe16f547b99116a007f25d9e875", + "size": 652537, + "subdir": "linux-64", + "timestamp": 1607635408007, + "version": "3.3.1" + }, + "cryptography-3.3.1-py38h3c74f83_1.tar.bz2": { + "build": "py38h3c74f83_1", + "build_number": 1, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "339476d1f869b9b05ad925137565c5e7", + "name": "cryptography", + "sha256": "6b417a5ce964557318f48f7c8fd9d5c6d10b21df407efca481835227bb4e078a", + "size": 648170, + "subdir": "linux-64", + "timestamp": 1613400933356, + "version": "3.3.1" + }, + "cryptography-3.3.1-py39h3c74f83_0.tar.bz2": { + "build": "py39h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.9,<3.10.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "7d65ad6d7120b05b441ed9794b5a5422", + "name": "cryptography", + "sha256": "0cd32de916a1e00e4811f7653b1dd461c3849b395f564898b7efba73fcfd1efb", + "size": 644375, + "subdir": "linux-64", + "timestamp": 1607635380932, + "version": "3.3.1" + }, + "cryptography-3.3.1-py39h3c74f83_1.tar.bz2": { + "build": "py39h3c74f83_1", + "build_number": 1, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.9,<3.10.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "e6ec94c0d5d75af82beed19619eca0a0", + "name": "cryptography", + "sha256": "3729aa949aa89126ea08d337ff2e0c4869a79a2b19a0097afc09fb78e78a85fe", + "size": 649695, + "subdir": "linux-64", + "timestamp": 1613401516558, + "version": "3.3.1" + }, + "cryptography-3.3.2-py36h3c74f83_0.tar.bz2": { + "build": "py36h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "3bcec410cb2ff9ab933b5822acafa252", + "name": "cryptography", + "sha256": "cb8630d1821dbe57a9382de310567be02d133b58527ec5122b65d783b7f225b2", + "size": 646425, + "subdir": "linux-64", + "timestamp": 1615505313058, + "version": "3.3.2" + }, + "cryptography-3.3.2-py37h3c74f83_0.tar.bz2": { + "build": "py37h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "40c02a6d3f309c3dcd6f215d60d995cc", + "name": "cryptography", + "sha256": "9f956109d418201735c3e774676ecffee30436ab8d8e9ca0c1147b02be1ceba1", + "size": 649029, + "subdir": "linux-64", + "timestamp": 1615505316217, + "version": "3.3.2" + }, + "cryptography-3.3.2-py38h3c74f83_0.tar.bz2": { + "build": "py38h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "1512276d098bb29d49611ccd573b56b1", + "name": "cryptography", + "sha256": "688faab7420c565752090aae6d8795cc0ba6136b1f6a561a707473ffaac7a0b1", + "size": 651237, + "subdir": "linux-64", + "timestamp": 1615503676542, + "version": "3.3.2" + }, + "cryptography-3.3.2-py39h3c74f83_0.tar.bz2": { + "build": "py39h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.9,<3.10.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "434974b7cac07d8c27b168f8f96d1021", + "name": "cryptography", + "sha256": "8a2f4e7d5baf81f0a32e128bba5d1835888c71b7f95a06bbb24d6f437af29364", + "size": 649335, + "subdir": "linux-64", + "timestamp": 1615505306566, + "version": "3.3.2" + }, + "cryptography-3.4.6-py36hd23ed53_0.tar.bz2": { + "build": "py36hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "adf21818686db913617ceb086f0f4959", + "name": "cryptography", + "sha256": "cd70cd799d29a2d39a10c87b2c917b12a167d68a93583ed1334c96e58b453ca7", + "size": 1060867, + "subdir": "linux-64", + "timestamp": 1615532272933, + "version": "3.4.6" + }, + "cryptography-3.4.6-py37hd23ed53_0.tar.bz2": { + "build": "py37hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "f579daba3e0bd1bae89196376b4a744e", + "name": "cryptography", + "sha256": "3290bc4dc9d692a14d8180d6a029012ef6b4397ae5549fb8894206a82017e1ce", + "size": 1063655, + "subdir": "linux-64", + "timestamp": 1615530943978, + "version": "3.4.6" + }, + "cryptography-3.4.6-py38hd23ed53_0.tar.bz2": { + "build": "py38hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "53adf8f32617e7fe17ea42137af6ecc6", + "name": "cryptography", + "sha256": "3e5f4366105a30d3faea877cb9845a237bd470eaab2356be15aa74d8d70eb31a", + "size": 1059110, + "subdir": "linux-64", + "timestamp": 1615532597178, + "version": "3.4.6" + }, + "cryptography-3.4.6-py39hd23ed53_0.tar.bz2": { + "build": "py39hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "3b6b1917b1b770b2b54ad10d1c990beb", + "name": "cryptography", + "sha256": "fe72bdb8b7fb58c6b02b15a4ac44faa2056cb4f5ba3629f5a76e131fe4415cef", + "size": 1063731, + "subdir": "linux-64", + "timestamp": 1615532601770, + "version": "3.4.6" + }, + "cryptography-3.4.7-py36hd23ed53_0.tar.bz2": { + "build": "py36hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1k,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "03009881ceae485fb341e04b7f3f06f3", + "name": "cryptography", + "sha256": "ae5adbda28e1b727c0c655c8c12a612fed62caa52fa9bdcc64a94e96e5636ed6", + "size": 1055818, + "subdir": "linux-64", + "timestamp": 1616769445889, + "version": "3.4.7" + }, + "cryptography-3.4.7-py37hd23ed53_0.tar.bz2": { + "build": "py37hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1k,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "d9a1a8cda97ef4d11979b60f4b8d9376", + "name": "cryptography", + "sha256": "76debb36322421b18900fc6f4ed8f3616a74578775e07251ec136f81869c4a65", + "size": 1051244, + "subdir": "linux-64", + "timestamp": 1616769355987, + "version": "3.4.7" + }, + "cryptography-3.4.7-py38hd23ed53_0.tar.bz2": { + "build": "py38hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1k,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "6fc4e21841343a19194d106f17aea01d", + "name": "cryptography", + "sha256": "8ca3fea0e1066fbab5b9af594a30173a3d703530125a93580e16e48191052849", + "size": 1061380, + "subdir": "linux-64", + "timestamp": 1616769470690, + "version": "3.4.7" + }, + "cryptography-3.4.7-py39hd23ed53_0.tar.bz2": { + "build": "py39hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1k,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "04c8a1b34174f41818af0185a77cf1e6", + "name": "cryptography", + "sha256": "204063190dffe13c06dbcac394c75b7b778c5a54dfca5f152ce6cacc6d17fdee", + "size": 1064005, + "subdir": "linux-64", + "timestamp": 1616767201071, + "version": "3.4.7" + }, + "cryptography-3.4.8-py37hd23ed53_0.tar.bz2": { + "build": "py37hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "25af09aa37582087374b6d5227ed56a5", + "name": "cryptography", + "sha256": "7bb9211c93fb1e5429cc3659cd156ee183fb8610f0686b50fd57cb32d7110e5f", + "size": 1098656, + "subdir": "linux-64", + "timestamp": 1633521716954, + "version": "3.4.8" + }, + "cryptography-3.4.8-py38hd23ed53_0.tar.bz2": { + "build": "py38hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "6515ed0e3028867351d1a0d1b5190896", + "name": "cryptography", + "sha256": "976d93e4db5277d6c8326f348b47a407873c677c563d66b3ef512b1d0c24fc92", + "size": 1083073, + "subdir": "linux-64", + "timestamp": 1633520558217, + "version": "3.4.8" + }, + "cryptography-3.4.8-py39hd23ed53_0.tar.bz2": { + "build": "py39hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "81c6ab99b502a787daadc7e19d911382", + "name": "cryptography", + "sha256": "a0b454fdc6fb6fcc8448590c43cc78da4088ff8b6c4c0000588e6f34e30a5c31", + "size": 1086932, + "subdir": "linux-64", + "timestamp": 1633520529458, + "version": "3.4.8" + }, + "cryptography-35.0.0-py36hd23ed53_0.tar.bz2": { + "build": "py36hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "2ae4a271cf9a7468975d5eb6a04afe75", + "name": "cryptography", + "sha256": "0a5e7098a8f49bb99e6064e354f5ac5bd6612c1811d222356771263b64c531b0", + "size": 1523752, + "subdir": "linux-64", + "timestamp": 1635366316115, + "version": "35.0.0" + }, + "cryptography-35.0.0-py37hd23ed53_0.tar.bz2": { + "build": "py37hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "b0e7e28ae13c23e65a5761e1342737b2", + "name": "cryptography", + "sha256": "53be39a2c501fb27fa4181ad9c5b63a2b3585f83c14513063638418a75aeb6f6", + "size": 1524116, + "subdir": "linux-64", + "timestamp": 1635355084621, + "version": "35.0.0" + }, + "cryptography-35.0.0-py38hd23ed53_0.tar.bz2": { + "build": "py38hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "942277a14d71834c3eb3d4ddaec18e4d", + "name": "cryptography", + "sha256": "476404db719953f09daf8f4da9463b52a9fef597c88a3453df393f521f3ed66d", + "size": 1542373, + "subdir": "linux-64", + "timestamp": 1635366770742, + "version": "35.0.0" + }, + "cryptography-35.0.0-py39hd23ed53_0.tar.bz2": { + "build": "py39hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "aab947e40c38c7c8e1cc2739f5980f25", + "name": "cryptography", + "sha256": "9a03afc7974c087c0bdeafcb7c4f9a34743a9328e07ad6b62df27125204cf384", + "size": 1525495, + "subdir": "linux-64", + "timestamp": 1635366308162, + "version": "35.0.0" + }, + "cryptography-36.0.0-py310h9ce1e76_0.tar.bz2": { + "build": "py310h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "ccbc153eb689dd5be45a909c93865705", + "name": "cryptography", + "sha256": "43c54964992b987c455d09221b43de6ca29834c710a8a1712be5fcf2756af4da", + "size": 1927390, + "subdir": "linux-64", + "timestamp": 1640808838438, + "version": "36.0.0" + }, + "cryptography-36.0.0-py37h9ce1e76_0.tar.bz2": { + "build": "py37h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "4c9165380e8167cebdfe5a33b028b023", + "name": "cryptography", + "sha256": "153a3c8e28edd8c83cf5fb04131f5bebae9f7057af8e7727022a6ea2df8a52ae", + "size": 1610672, + "subdir": "linux-64", + "timestamp": 1639414779465, + "version": "36.0.0" + }, + "cryptography-36.0.0-py38h9ce1e76_0.tar.bz2": { + "build": "py38h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "d6adc381de8991e1101c444f179afe74", + "name": "cryptography", + "sha256": "75d1c4b21cd9b4c5e82886ede39a47169798bb3a066909ff6c980b7e3d98f903", + "size": 1610981, + "subdir": "linux-64", + "timestamp": 1639401036933, + "version": "36.0.0" + }, + "cryptography-36.0.0-py39h9ce1e76_0.tar.bz2": { + "build": "py39h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "53c75896180c940d63c3d82a6952be8f", + "name": "cryptography", + "sha256": "7bf80c412b2d75eac731f929d239c5fd53bff8c765befb951ff8572868a0dce2", + "size": 1612850, + "subdir": "linux-64", + "timestamp": 1639414790730, + "version": "36.0.0" + }, + "cryptography-37.0.1-py310h9ce1e76_0.tar.bz2": { + "build": "py310h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.10,<3.11.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "4c22e21b19d7473ebff0bf3d16329d28", + "name": "cryptography", + "sha256": "e777c2489d17e3c153bda323a8b93911fa32bcef9381e0fd0b458e20426b2c8c", + "size": 1896730, + "subdir": "linux-64", + "timestamp": 1652101799179, + "version": "37.0.1" + }, + "cryptography-37.0.1-py37h9ce1e76_0.tar.bz2": { + "build": "py37h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.7,<3.8.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "684ed4da9a33119d1ddf202c19143377", + "name": "cryptography", + "sha256": "5a55be8334f11f90eb9cd618f836d8daa36ad5455b77c68341f7b648031c7c3b", + "size": 1543960, + "subdir": "linux-64", + "timestamp": 1652083665624, + "version": "37.0.1" + }, + "cryptography-37.0.1-py38h9ce1e76_0.tar.bz2": { + "build": "py38h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.8,<3.9.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "06f4adadded4fb89c8c990d99c89b51b", + "name": "cryptography", + "sha256": "eea9d81837b4135badc4f677ba5a558d509d91c53e73128399182c5afb6fa890", + "size": 1548541, + "subdir": "linux-64", + "timestamp": 1652083948459, + "version": "37.0.1" + }, + "cryptography-37.0.1-py39h9ce1e76_0.tar.bz2": { + "build": "py39h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.9,<3.10.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "397a6116acd47e93e25c187344293550", + "name": "cryptography", + "sha256": "09e67e7e69226529bcffb0df32cc7cb62fe4764144bb072753b6a56e6c14631b", + "size": 1559690, + "subdir": "linux-64", + "timestamp": 1652101795822, + "version": "37.0.1" + }, + "cryptography-38.0.1-py310h9ce1e76_0.tar.bz2": { + "build": "py310h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.10,<3.11.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "4f55f0a1f242e071ae70e9d61b2c9658", + "name": "cryptography", + "sha256": "8d3d2f930d138de03fddbfd61b0dc692ceca1c8498e0d003169977a2e3bad800", + "size": 1548398, + "subdir": "linux-64", + "timestamp": 1665613295924, + "version": "38.0.1" + }, + "cryptography-38.0.1-py37h9ce1e76_0.tar.bz2": { + "build": "py37h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.7,<3.8.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "f5b3ec809e915d876d1d35c1ef6f8a11", + "name": "cryptography", + "sha256": "e4cb04bb623e56dcdf19978046802e004ce274f9ea330468a23c27afe0299ad3", + "size": 1543873, + "subdir": "linux-64", + "timestamp": 1665612808358, + "version": "38.0.1" + }, + "cryptography-38.0.1-py38h9ce1e76_0.tar.bz2": { + "build": "py38h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.8,<3.9.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "19de9a6dc8c4ab6f4f6a6918b7d9c27c", + "name": "cryptography", + "sha256": "62c67fcd5160b0b67390242dcf96f12fc9846112e303a566ab539dc7eb6312f2", + "size": 1546572, + "subdir": "linux-64", + "timestamp": 1665613054282, + "version": "38.0.1" + }, + "cryptography-38.0.1-py39h9ce1e76_0.tar.bz2": { + "build": "py39h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.9,<3.10.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "d8749621daea18bbea233192e4c44f66", + "name": "cryptography", + "sha256": "a7c7b82e3acbd02d33e74dcc26ab3ed9025edd1c18a71d41ebdfa2620e093014", + "size": 1546283, + "subdir": "linux-64", + "timestamp": 1665613528373, + "version": "38.0.1" + }, + "cryptography-38.0.4-py310h9ce1e76_0.tar.bz2": { + "build": "py310h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.10,<3.11.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "7ffff958b7cfe4022fc5622e1b6eabff", + "name": "cryptography", + "sha256": "512ad1fd935814cf978452bc2b7cf440585fd14181d9b5914573aad969283ea0", + "size": 1573441, + "subdir": "linux-64", + "timestamp": 1673299122438, + "version": "38.0.4" + }, + "cryptography-38.0.4-py311hbdeaff8_0.tar.bz2": { + "build": "py311hbdeaff8_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.11,<3.12.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "14e777e7044d43d80295f983950c06bf", + "name": "cryptography", + "sha256": "0cfc23cb8b3815d81f2095925f1d3f97384f8d17a4471564674861271b312dca", + "size": 1647656, + "subdir": "linux-64", + "timestamp": 1676824509583, + "version": "38.0.4" + }, + "cryptography-38.0.4-py37h9ce1e76_0.tar.bz2": { + "build": "py37h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.7,<3.8.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "ce1caad0936e8dcbd383d1a0f042d082", + "name": "cryptography", + "sha256": "7e2381c7f75765f0225181976544cdc5796bc3917ae0a337641e030a74fb4580", + "size": 1564986, + "subdir": "linux-64", + "timestamp": 1673299343515, + "version": "38.0.4" + }, + "cryptography-38.0.4-py38h9ce1e76_0.tar.bz2": { + "build": "py38h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.8,<3.9.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "09dc7264f82684d6e01df559b3105232", + "name": "cryptography", + "sha256": "f319650861c01dde6849da094cc519ce394f19f5f6a3d41e5eab952f2e73b285", + "size": 1568037, + "subdir": "linux-64", + "timestamp": 1673298903332, + "version": "38.0.4" + }, + "cryptography-38.0.4-py39h9ce1e76_0.tar.bz2": { + "build": "py39h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.9,<3.10.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "1b9059f007d6b58218b86ffb8b3662f2", + "name": "cryptography", + "sha256": "241b360c50246f3aee81ebc7183a39e44ba620e4543799c6a897e9409cb188b5", + "size": 1568138, + "subdir": "linux-64", + "timestamp": 1673299566607, + "version": "38.0.4" + }, + "cryptography-39.0.1-py310h9ce1e76_0.tar.bz2": { + "build": "py310h9ce1e76_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=23.0.0" + ], + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.10,<3.11.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "9125c10ee5ba359537c75c599bb7d5fa", + "name": "cryptography", + "sha256": "889bd75a314e26a57e2f1367d53789097ac97fd6c45e194b645ded91d5baa281", + "size": 1581994, + "subdir": "linux-64", + "timestamp": 1677533240358, + "version": "39.0.1" + }, + "cryptography-39.0.1-py311h9ce1e76_0.tar.bz2": { + "build": "py311h9ce1e76_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=23.0.0" + ], + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.11,<3.12.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "590964d88d7487fc411cc2f825f8e405", + "name": "cryptography", + "sha256": "3ba07a51a35becb07816154ddcdbfa93e5d1d99796830e8bb6dee62ec5cfbf07", + "size": 1655478, + "subdir": "linux-64", + "timestamp": 1679335768469, + "version": "39.0.1" + }, + "cryptography-39.0.1-py37h9ce1e76_0.tar.bz2": { + "build": "py37h9ce1e76_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=23.0.0" + ], + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.7,<3.8.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "9c3e764c2a2821ddcc4301ac1ca1da8c", + "name": "cryptography", + "sha256": "75b4d4664c2ba3f94d9a0753a72b9ec1a6baf11f226e97f5e2de22985c94151a", + "size": 1575681, + "subdir": "linux-64", + "timestamp": 1677533732417, + "version": "39.0.1" + }, + "cryptography-39.0.1-py38h9ce1e76_0.tar.bz2": { + "build": "py38h9ce1e76_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=23.0.0" + ], + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.8,<3.9.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "ca04aa08d85c802742cd74371c0c088e", + "name": "cryptography", + "sha256": "420daee025d4db0556ee5ac96f99caea0dbce9948a1f5c0d372725f05370d9d0", + "size": 1577960, + "subdir": "linux-64", + "timestamp": 1677533986384, + "version": "39.0.1" + }, + "cryptography-39.0.1-py39h9ce1e76_0.tar.bz2": { + "build": "py39h9ce1e76_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=23.0.0" + ], + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.9,<3.10.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "e39889a53b825d16c6791130f66ff8b4", + "name": "cryptography", + "sha256": "18715cdcf48e9769545922e964a01ed6f2f8205df712b2b1233e24a5aa5f2c17", + "size": 1577918, + "subdir": "linux-64", + "timestamp": 1677533487931, + "version": "39.0.1" + }, + "cryptography-vectors-2.0.3-py27h509bbd6_0.tar.bz2": { + "build": "py27h509bbd6_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "cc53b86d309d6d952406741b9e7b1a5d", + "name": "cryptography-vectors", + "sha256": "44ab04aa8e4113e3f18536b3d0603378cd4bb302805fb23b79d46d1fd1a10f4f", + "size": 24703337, + "subdir": "linux-64", + "timestamp": 1505691979504, + "version": "2.0.3" + }, + "cryptography-vectors-2.0.3-py35h4e3a8f9_0.tar.bz2": { + "build": "py35h4e3a8f9_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "6f21c22f7370296f5f0f94aaeb6ec319", + "name": "cryptography-vectors", + "sha256": "11670ff3774d130ba2b4a67107806bb352c3c597e9b8529a25b25ab1e8ea5cc6", + "size": 24705789, + "subdir": "linux-64", + "timestamp": 1505692032452, + "version": "2.0.3" + }, + "cryptography-vectors-2.0.3-py36h2661aa0_0.tar.bz2": { + "build": "py36h2661aa0_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "e8e0ec8a47472f5295149c70c13756b1", + "name": "cryptography-vectors", + "sha256": "2d56c1fda905de107dacdbe88debc322202e50a5f4ce2b262ea2a1afd3265a11", + "size": 24705552, + "subdir": "linux-64", + "timestamp": 1505692084973, + "version": "2.0.3" + }, + "cryptography-vectors-2.1.3-py27hb4fb482_0.tar.bz2": { + "build": "py27hb4fb482_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "ca510e7035df3663d2ded0856e6a1786", + "name": "cryptography-vectors", + "sha256": "82945398804a45f51f8f2b152643508b1d7f41158e53d1a41961d4c1530cc520", + "size": 24717795, + "subdir": "linux-64", + "timestamp": 1511926795394, + "version": "2.1.3" + }, + "cryptography-vectors-2.1.3-py35heb52bce_0.tar.bz2": { + "build": "py35heb52bce_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "02a9f8322e516e8f4416f5750ea41f05", + "name": "cryptography-vectors", + "sha256": "ebcf9a60f85e3bf01e604d12af578bb1d3cd6b439535ce9ba75900e88e9677fa", + "size": 24714479, + "subdir": "linux-64", + "timestamp": 1511926837042, + "version": "2.1.3" + }, + "cryptography-vectors-2.1.3-py36h90764bc_0.tar.bz2": { + "build": "py36h90764bc_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "f1e722523e29a7576b8f43a54ad9dbab", + "name": "cryptography-vectors", + "sha256": "a0498bd7feb59442641db1c9fc10485c827b68b3e908dd39be51938c9d3411e0", + "size": 24716701, + "subdir": "linux-64", + "timestamp": 1511926844448, + "version": "2.1.3" + }, + "cryptography-vectors-2.1.4-py27hae77291_0.tar.bz2": { + "build": "py27hae77291_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "b0b6b3bc063cb0bb2976df8903a78a39", + "name": "cryptography-vectors", + "sha256": "a88e681ad758667ef4ed0de56493e6a6ae0eebe3862e85ef9b1770dfbcf22fb5", + "size": 24714703, + "subdir": "linux-64", + "timestamp": 1512200509100, + "version": "2.1.4" + }, + "cryptography-vectors-2.1.4-py35h7749f18_0.tar.bz2": { + "build": "py35h7749f18_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "d994524c656e57ad33c23c2d0def06ae", + "name": "cryptography-vectors", + "sha256": "777b7de1be3a442b6258bf0c9e68028535b45fc4bb8f05bf009a97ff24c3012d", + "size": 24712697, + "subdir": "linux-64", + "timestamp": 1512200517947, + "version": "2.1.4" + }, + "cryptography-vectors-2.1.4-py36h02259fb_0.tar.bz2": { + "build": "py36h02259fb_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "f76fe612165fcebbcd600576f4afe011", + "name": "cryptography-vectors", + "sha256": "3d989673dd4d56f504823c6ecb233c316c61768e41b80f9d17274b215d4a72c0", + "size": 24712463, + "subdir": "linux-64", + "timestamp": 1512200528807, + "version": "2.1.4" + }, + "cryptography-vectors-2.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "35f2db37e1f502227f2e2cb9eb45c318", + "name": "cryptography-vectors", + "sha256": "9577d518a132f0325f3cf0f618d2e7f138da2c55cf199d0fe87c11f5af09fcc7", + "size": 24716484, + "subdir": "linux-64", + "timestamp": 1521784367161, + "version": "2.2.1" + }, + "cryptography-vectors-2.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "8cfbbfc3fb2911fdf0e7f8bd4dcebe32", + "name": "cryptography-vectors", + "sha256": "f348e1732dd4208350cbd820f1e0392bbfdb005ea3f69eb4dfa05744063de8b6", + "size": 24712394, + "subdir": "linux-64", + "timestamp": 1521784417554, + "version": "2.2.1" + }, + "cryptography-vectors-2.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "6f42c1fd0f651374f6aee38d3fe3d0b4", + "name": "cryptography-vectors", + "sha256": "8787897e3db034048d6701d5e2a80423213a60d31c67a5fa463ef624201f17bc", + "size": 24710502, + "subdir": "linux-64", + "timestamp": 1521784297188, + "version": "2.2.1" + }, + "cryptography-vectors-2.2.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "ef536481132af21809e9b790aa4d7cd5", + "name": "cryptography-vectors", + "sha256": "2d014c06d14a1352f9fdb5760f6f84b477637ff6a149674873a2c16041d37bca", + "size": 24712453, + "subdir": "linux-64", + "timestamp": 1522684624377, + "version": "2.2.2" + }, + "cryptography-vectors-2.2.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "6bebc56ad0a1d2eedc7cf5f9211aa979", + "name": "cryptography-vectors", + "sha256": "8c918105057f80bee19c218e0f6ee380b85baa8be580f4ed70bb96ef51768423", + "size": 24713028, + "subdir": "linux-64", + "timestamp": 1522684778794, + "version": "2.2.2" + }, + "cryptography-vectors-2.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "2a20faa1f276ba5c4fc5e88cc5cde729", + "name": "cryptography-vectors", + "sha256": "51e24c3d4eb9aefaf18ec3e965a8dfb91f6368429b26d3fd8e5064854f6b66e1", + "size": 24713025, + "subdir": "linux-64", + "timestamp": 1522684778776, + "version": "2.2.2" + }, + "cryptography-vectors-2.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "4f5ed4bcd59439ce0ca43cd89f248e28", + "name": "cryptography-vectors", + "sha256": "54522ed55bebd81a34fcd1d99cb8f81440ae2f9b0648bc90873effa08f6eacd6", + "size": 24689674, + "subdir": "linux-64", + "timestamp": 1530733002357, + "version": "2.2.2" + }, + "cryptography-vectors-2.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "4b06f2cadd2b88bd4e9d73cf0b894462", + "name": "cryptography-vectors", + "sha256": "813d8784f7f3b84fb3467fc79e3c079219e7fc21c54d387d912c229bdc1dd0a0", + "size": 31944776, + "subdir": "linux-64", + "timestamp": 1532876137143, + "version": "2.3" + }, + "cryptography-vectors-2.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "bc313eae83482267c7003cdadf36d0d2", + "name": "cryptography-vectors", + "sha256": "9b9c57ee1adc875ef64c1ef95d14651afaf4867447b11cf6d7601866c7483329", + "size": 31940907, + "subdir": "linux-64", + "timestamp": 1532876205372, + "version": "2.3" + }, + "cryptography-vectors-2.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "32d9d31a3a09d292a1adc9138df8e445", + "name": "cryptography-vectors", + "sha256": "e303e48e93cff57e7c0c0258c6e614caaf17c7e8925fa39df1f6cf7a246a1fc7", + "size": 31939091, + "subdir": "linux-64", + "timestamp": 1532876135965, + "version": "2.3" + }, + "cryptography-vectors-2.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "b4b0b822ffd73b3b06c8506cf62d2575", + "name": "cryptography-vectors", + "sha256": "da6cb8840744b6ff902593084b74395fa2ca742f280a93c472fc87cecd34b90f", + "size": 31936754, + "subdir": "linux-64", + "timestamp": 1532876233642, + "version": "2.3" + }, + "cryptography-vectors-2.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "5dec02395c3bc91ece33de0178b4b26e", + "name": "cryptography-vectors", + "sha256": "c02bd30591fdba06b4a62e5a2f0b08bd0296acb31cdfc13e226b5547ad3e3025", + "size": 31942297, + "subdir": "linux-64", + "timestamp": 1535126039546, + "version": "2.3.1" + }, + "cryptography-vectors-2.3.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "70ef918e7b0589effa4c7b5cdca9a686", + "name": "cryptography-vectors", + "sha256": "ea75c65d0a65428353d46f079608b7c0906238615932698edaa04645555f0b41", + "size": 31944449, + "subdir": "linux-64", + "timestamp": 1535126096199, + "version": "2.3.1" + }, + "cryptography-vectors-2.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "c4ad39577036e87ae193dfcc98f83207", + "name": "cryptography-vectors", + "sha256": "47dd06d42094d2d30c9d8e01cd975938d433db5a3f63535262a2453125d67657", + "size": 31940105, + "subdir": "linux-64", + "timestamp": 1535126198010, + "version": "2.3.1" + }, + "cryptography-vectors-2.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "73436bd2f45fabe326f33de1f30ca51f", + "name": "cryptography-vectors", + "sha256": "a3396c4e2b69c7f6429e41cd7e979a532b3f314c140832c4f58fc21f9e2ca292", + "size": 31940314, + "subdir": "linux-64", + "timestamp": 1535126146652, + "version": "2.3.1" + }, + "cryptography-vectors-2.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "1a9babc8b1376d80dc3b2767d109a92b", + "name": "cryptography-vectors", + "sha256": "17c89f40307ed986ff2eb577a4cf11223d72fe8a61f2371c27b3a521529f44f1", + "size": 31976514, + "subdir": "linux-64", + "timestamp": 1542312981280, + "version": "2.4.1" + }, + "cryptography-vectors-2.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "4ebc5fc2bcfab52992c5b27dc455c000", + "name": "cryptography-vectors", + "sha256": "6d146cb1e7a0568b4734ceadc7a76c96f35ff4d5a35ba7e463723310dc1069ec", + "size": 32044930, + "subdir": "linux-64", + "timestamp": 1542312959442, + "version": "2.4.1" + }, + "cryptography-vectors-2.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "fb50f65c8ed0bdb4ce0e42ab78d767c9", + "name": "cryptography-vectors", + "sha256": "e8d8741d26fb25d080eb11485b686185ac8373120c20d556a9ddecd5d402e1e0", + "size": 32024106, + "subdir": "linux-64", + "timestamp": 1542312972430, + "version": "2.4.1" + }, + "cryptography-vectors-2.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "a117aa4482f01918a656cf5a7e76f4a5", + "name": "cryptography-vectors", + "sha256": "ce7156311a4611290e936bc96249c5011f5b04e42bcce3386a48413e99f8fd5c", + "size": 31995766, + "subdir": "linux-64", + "timestamp": 1543519401820, + "version": "2.4.2" + }, + "cryptography-vectors-2.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "07ebc5fa24bae28fec00d268aa82aeec", + "name": "cryptography-vectors", + "sha256": "dba56e4e7b03ee8076722be3e160c4492ebf6e3f7f1e7796d158135ec744ee1f", + "size": 31987496, + "subdir": "linux-64", + "timestamp": 1543519374937, + "version": "2.4.2" + }, + "cryptography-vectors-2.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "9d266d1284b5275038671f0a9bcea920", + "name": "cryptography-vectors", + "sha256": "9020590eec6dcbb01f0781d8d2dbc17a98daccbaf01741dd55ef684f3702be44", + "size": 31987596, + "subdir": "linux-64", + "timestamp": 1543519389147, + "version": "2.4.2" + }, + "cryptography-vectors-38.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "4ec943e3072acfeaab45257f727a8be4", + "name": "cryptography-vectors", + "sha256": "097d42b71889bb2923d05deb8f7d10894d4bb7b5673bdc04d59a9ac127beeabd", + "size": 32265657, + "subdir": "linux-64", + "timestamp": 1665455073629, + "version": "38.0.1" + }, + "cryptography-vectors-38.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "be192d68b5902b4d49efd11d3b371327", + "name": "cryptography-vectors", + "sha256": "f86cba4240c524c124069986437aa0bf8cbb138041bb1b2291b239737cc59ef7", + "size": 32267235, + "subdir": "linux-64", + "timestamp": 1665455260597, + "version": "38.0.1" + }, + "cryptography-vectors-38.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "bc905c23b8ac890c77c07b94f6e350f0", + "name": "cryptography-vectors", + "sha256": "a76e1cc281446b1091b0ea4206ce132b1b3350190f6a585d5ae9de07d17cb1bd", + "size": 32257423, + "subdir": "linux-64", + "timestamp": 1665455135536, + "version": "38.0.1" + }, + "cryptography-vectors-38.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "6aaff20151ed70b367277a81ded96bd6", + "name": "cryptography-vectors", + "sha256": "549a947a0fd8b01fd0d4608d7b2842f4088e535a63036daaeec856cdb8bcfa7c", + "size": 32244960, + "subdir": "linux-64", + "timestamp": 1665455197529, + "version": "38.0.1" + }, + "cryptography-vectors-38.0.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "55f7b8df486305ee9bbfb9be93d402ba", + "name": "cryptography-vectors", + "sha256": "2e9e473bda298a863e54e4998a5a6defb917b64ac9e5735d1e87aea85d9874fa", + "size": 32256140, + "subdir": "linux-64", + "timestamp": 1673034311741, + "version": "38.0.4" + }, + "cryptography-vectors-38.0.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "30303fd5ea3d9318955ea5edf4803702", + "name": "cryptography-vectors", + "sha256": "d2b0bde7f6b612794f59226a16047f959787fa3ab63a26fc7f6f1964ac744b8d", + "size": 32310691, + "subdir": "linux-64", + "timestamp": 1676851499791, + "version": "38.0.4" + }, + "cryptography-vectors-38.0.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "6a07ecf9637f437c5ab198593dec1f45", + "name": "cryptography-vectors", + "sha256": "e8f07ba7f5890eda5dfe6228e250dfdced6a135b3a9f6513bae9fc16e09b29b7", + "size": 32258271, + "subdir": "linux-64", + "timestamp": 1673034438240, + "version": "38.0.4" + }, + "cryptography-vectors-38.0.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "7ec5635258a401261886b1a3920406b3", + "name": "cryptography-vectors", + "sha256": "86a11720363eeafb385a5ddf655e607c0f01ea6559c2b2693145532264aa9e4e", + "size": 32253080, + "subdir": "linux-64", + "timestamp": 1673034501482, + "version": "38.0.4" + }, + "cryptography-vectors-38.0.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "e82e83e26ff65627555115fa644aaef5", + "name": "cryptography-vectors", + "sha256": "a87dd37d41f971aed8e57515d3e9793bbd67306319a917880f9b98531022f795", + "size": 32259922, + "subdir": "linux-64", + "timestamp": 1673034374940, + "version": "38.0.4" + }, + "cryptography-vectors-39.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "c4281a1dadf4858bb8d60f6788324be2", + "name": "cryptography-vectors", + "sha256": "291e9b0c1f3668631d952be82a88455c3e34093e84963f29d28e738f33cd2395", + "size": 32269744, + "subdir": "linux-64", + "timestamp": 1677168664467, + "version": "39.0.1" + }, + "cryptography-vectors-39.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "8d9cdb4e2b521c3ac890e06643e41966", + "name": "cryptography-vectors", + "sha256": "46e7a5c3f8e8273e02ddd7afe6e23b4fdf4c9bc2f179053a0f56d584e071c792", + "size": 32273532, + "subdir": "linux-64", + "timestamp": 1679335807290, + "version": "39.0.1" + }, + "cryptography-vectors-39.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "362a3aa40c6e9d9ed0c2dd2351d4352b", + "name": "cryptography-vectors", + "sha256": "a22fb20551758ed7db631cd9f568e6f497e2724c9d70e6eeb1f05d5cbb3777c4", + "size": 32256711, + "subdir": "linux-64", + "timestamp": 1677168726489, + "version": "39.0.1" + }, + "cryptography-vectors-39.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "71705bf75ada62abbb676d77b1cba289", + "name": "cryptography-vectors", + "sha256": "1c1aa2b575cb1d3b3d9ea431ff219c4c4b9a0b5ce00ffbb370c5ee77586830c0", + "size": 32272496, + "subdir": "linux-64", + "timestamp": 1677168539814, + "version": "39.0.1" + }, + "cryptography-vectors-39.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "4c3aad5d3b477999f963b60a0a18d749", + "name": "cryptography-vectors", + "sha256": "d53d6a9e3867b0afcab2d28cbe4595f671f414f20934da9dc98830ec1b6f1260", + "size": 32264076, + "subdir": "linux-64", + "timestamp": 1677168602037, + "version": "39.0.1" + }, + "cryptominisat-5.6.6-h5d072ba_0.tar.bz2": { + "build": "h5d072ba_0", + "build_number": 0, + "depends": [ + "libboost >=1.67.0,<1.67.1.0a0", + "libcryptominisat 5.6.6 h0e08187_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "78d3cd4eea9bdcd30e31c160fde6e142", + "name": "cryptominisat", + "sha256": "6869d97c3fb3f20e30bd608a171a0ecd9412f1297902c0024d2b9d919fed16ef", + "size": 877682, + "subdir": "linux-64", + "timestamp": 1548447108484, + "version": "5.6.6" + }, + "cryptominisat-5.6.6-hc2b5a8e_0.tar.bz2": { + "build": "hc2b5a8e_0", + "build_number": 0, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0", + "libcryptominisat 5.6.6 hc0fe6c6_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "052655252442abb503f26370fc6f8955", + "name": "cryptominisat", + "sha256": "956c3f2f5871607fb1309b0256d9ba243bc5c8ceef53042c874e1684128306fb", + "size": 868024, + "subdir": "linux-64", + "timestamp": 1611760375913, + "version": "5.6.6" + }, + "cryptominisat-5.6.6-hfbc36fb_1.tar.bz2": { + "build": "hfbc36fb_1", + "build_number": 1, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0", + "libcryptominisat 5.6.6 h9e868ea_1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7df2a1288b3aea955228504f9ba78181", + "name": "cryptominisat", + "sha256": "ffbcfea53087bddd09886c8663bd04c59670b8ecd594fca918b9a74f14d151ba", + "size": 1157647, + "subdir": "linux-64", + "timestamp": 1676725986964, + "version": "5.6.6" + }, + "cryptominisat-5.6.6-hfbc36fb_2.tar.bz2": { + "build": "hfbc36fb_2", + "build_number": 2, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0", + "libcryptominisat 5.6.6 h9e868ea_2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a4e496764bbda1c7d2b1ad3ec9e5a974", + "name": "cryptominisat", + "sha256": "f53d7f25d06fe5ffea9e2b72e17b6d8d3e05be6f2216103c177c54aa4fbc100b", + "size": 1157453, + "subdir": "linux-64", + "timestamp": 1679313472422, + "version": "5.6.6" + }, + "cssselect-1.0.1-py27h1220d86_0.tar.bz2": { + "build": "py27h1220d86_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "eb6cbb8f60f057d8e7504cd1f05c4ee1", + "name": "cssselect", + "sha256": "d8983422a4402688669e22d30c3c0cd7c69feb14bcd748470b7dc740be352653", + "size": 28117, + "subdir": "linux-64", + "timestamp": 1508997790455, + "version": "1.0.1" + }, + "cssselect-1.0.1-py35hfccbc36_0.tar.bz2": { + "build": "py35hfccbc36_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5911794a8533b121217a9f3288658abb", + "name": "cssselect", + "sha256": "9e23fd97d33f251edbbf086e9d55e83bfcd9efc5ad6efdac1de6f542f312c995", + "size": 28897, + "subdir": "linux-64", + "timestamp": 1508997802443, + "version": "1.0.1" + }, + "cssselect-1.0.1-py36he645adf_0.tar.bz2": { + "build": "py36he645adf_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "95d11d158b25a45d3c3162850114e636", + "name": "cssselect", + "sha256": "51ad703bdbf5c9a51daed78b2ab7835202012a2ed801bdac65b479f8ff6e80e5", + "size": 28749, + "subdir": "linux-64", + "timestamp": 1508997797260, + "version": "1.0.1" + }, + "cssselect-1.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ed90891da569e650a72a8af0cb052e62", + "name": "cssselect", + "sha256": "ee2a354924474b5faa46f308724617f86d0fdefc08b2d0d265602c2273d1b8b6", + "size": 27975, + "subdir": "linux-64", + "timestamp": 1516983415275, + "version": "1.0.3" + }, + "cssselect-1.0.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7df1703cc6f8dccd39ec0bdadcc559cf", + "name": "cssselect", + "sha256": "c6572703bb2e547669b8fead253ac9a5efd53dcf3d291a1ff81f6f4f0983ba24", + "size": 28802, + "subdir": "linux-64", + "timestamp": 1516983428148, + "version": "1.0.3" + }, + "cssselect-1.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "334d40880f31a425deba5db3f9e0591d", + "name": "cssselect", + "sha256": "e665b10d2d675b190bd131b49feb6a566d58d16201cc051f45e5bef8538528e1", + "size": 28639, + "subdir": "linux-64", + "timestamp": 1516983429352, + "version": "1.0.3" + }, + "cssselect-1.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "aae0999e159381dc57f38e524c248d7f", + "name": "cssselect", + "sha256": "3f4e6cc8d289410e09a91b680e17f65f5224fea081a004d07001217ac0db6ad8", + "size": 28541, + "subdir": "linux-64", + "timestamp": 1530814319218, + "version": "1.0.3" + }, + "csvkit-1.0.2-py27hab083c5_0.tar.bz2": { + "build": "py27hab083c5_0", + "build_number": 0, + "depends": [ + "agate >=1.6.0", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.1", + "agate-sql >=0.5.2", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ed442542c249e9536a22cef757d32b00", + "name": "csvkit", + "sha256": "f2b5be1710399c64fbb1ba1f7c1c6e7da478b70c2cac0c9766682c0d3a283865", + "size": 55147, + "subdir": "linux-64", + "timestamp": 1508626155096, + "version": "1.0.2" + }, + "csvkit-1.0.2-py35h40534ce_0.tar.bz2": { + "build": "py35h40534ce_0", + "build_number": 0, + "depends": [ + "agate >=1.6.0", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.1", + "agate-sql >=0.5.2", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "edf014bcf2dda13c9f2f4a5b32811f12", + "name": "csvkit", + "sha256": "5ca0c43972788906358ba4e366fabe5f7644324a81531a3c05db69f6c85bdcec", + "size": 56266, + "subdir": "linux-64", + "timestamp": 1508626157602, + "version": "1.0.2" + }, + "csvkit-1.0.2-py36h1b4c739_0.tar.bz2": { + "build": "py36h1b4c739_0", + "build_number": 0, + "depends": [ + "agate >=1.6.0", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.1", + "agate-sql >=0.5.2", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d42829014d3e59146b69dddb93fd7b3b", + "name": "csvkit", + "sha256": "15c0e04732dceee5a7aa04079703ead36126bbe389c72a5b5d913c09a916a173", + "size": 55931, + "subdir": "linux-64", + "timestamp": 1508626165308, + "version": "1.0.2" + }, + "csvkit-1.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "84332e78ea6a25e2f79deb861baec7cc", + "name": "csvkit", + "sha256": "d7d15aa9ff9791c8ed36e2c72f0a3fe91f73ce3029d0e25fb4ad90d22a7728b7", + "size": 56992, + "subdir": "linux-64", + "timestamp": 1520969951817, + "version": "1.0.3" + }, + "csvkit-1.0.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "00e6ae3216094c1d59bb5cd25e0fac8c", + "name": "csvkit", + "sha256": "907b5affbb7ad89a35edb1e8a9a81f471db9038df682b0d496f6edd9496bb84d", + "size": 58275, + "subdir": "linux-64", + "timestamp": 1520970099533, + "version": "1.0.3" + }, + "csvkit-1.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4472275dbe8befc4e091701a2ce5e9d", + "name": "csvkit", + "sha256": "3d1308cddb05d9dc346ba59aec071d1b22efac688d74320e79cd7c10cf80fe99", + "size": 57977, + "subdir": "linux-64", + "timestamp": 1520969853620, + "version": "1.0.3" + }, + "csvkit-1.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b43fc0ff3f119d9083ad43db1ecb4946", + "name": "csvkit", + "sha256": "e6d0b66ea56f1f4b814413910c93fd34369bf06a998d1535d166a99df7eee3f2", + "size": 57941, + "subdir": "linux-64", + "timestamp": 1530814347431, + "version": "1.0.3" + }, + "csvkit-1.0.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "82934b5b9c4be16c33149645ca6c5f7d", + "name": "csvkit", + "sha256": "87c053481c0bfe49dde26d9828159d4811615ecb7c0a647b4f4b602569b363ca", + "size": 61462, + "subdir": "linux-64", + "timestamp": 1556064528129, + "version": "1.0.4" + }, + "csvkit-1.0.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.10,<3.11.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "507292e0e3d272fa2be1a72a1ea46c3e", + "name": "csvkit", + "sha256": "0480421b534734469f725866da9f673c918064c5684f0b7a2766970a267450ae", + "size": 61966, + "subdir": "linux-64", + "timestamp": 1640811857519, + "version": "1.0.4" + }, + "csvkit-1.0.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.11,<3.12.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2fcf0b3c9f7749ad1d1531b0c142b431", + "name": "csvkit", + "sha256": "b26997a818a3a8350c532446720145ecf39c795af3bdf295eeb32b4a6acc453d", + "size": 82079, + "subdir": "linux-64", + "timestamp": 1676851781002, + "version": "1.0.4" + }, + "csvkit-1.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "148ffaa8aeabbd4529c3c000bf978584", + "name": "csvkit", + "sha256": "06a29ea3c582ffcc8666424dc87ca983a178283e84e43bca65429fb4417e5570", + "size": 62355, + "subdir": "linux-64", + "timestamp": 1556064537099, + "version": "1.0.4" + }, + "csvkit-1.0.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f7010103f980dcd02ec6597ea84c626", + "name": "csvkit", + "sha256": "e11166c605b36efbe3f8591fca5902f50ce24417a4872efdbdf4905be43ee60b", + "size": 62648, + "subdir": "linux-64", + "timestamp": 1614082952362, + "version": "1.0.4" + }, + "csvkit-1.0.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eccafcf3121b3d157e1a3a08c7c6fe05", + "name": "csvkit", + "sha256": "85b8276f8c8994be01a214571930e09997c6f366df0e4ad874ba2f8e6f6df5aa", + "size": 62416, + "subdir": "linux-64", + "timestamp": 1556064509839, + "version": "1.0.4" + }, + "csvkit-1.0.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "222342bc54d3618099525ed99d3633fb", + "name": "csvkit", + "sha256": "a6397c35a4b245fba160cb261186d3be7f5dd6f29d605256efec590fd594a024", + "size": 62801, + "subdir": "linux-64", + "timestamp": 1614082366632, + "version": "1.0.4" + }, + "csvkit-1.0.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7df23f55e932dc134cc5863578e4079b", + "name": "csvkit", + "sha256": "b1dd3935ba4f91633b4b24fa0748ec7479fc90d54b1d0a13afa4c7a9e336126f", + "size": 61527, + "subdir": "linux-64", + "timestamp": 1574177681731, + "version": "1.0.4" + }, + "csvkit-1.0.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3aa2f97ab1cce620d6af3db2a02dd63", + "name": "csvkit", + "sha256": "fec240fac1f3a3571bf7ac4920398f5cee9f696639069194eb32fac7889e2497", + "size": 62630, + "subdir": "linux-64", + "timestamp": 1614082953112, + "version": "1.0.4" + }, + "csvkit-1.0.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b919ddea076424b6a0bb80749ec8573c", + "name": "csvkit", + "sha256": "9d0a28f2a26d1d1d463fa87423a339ed7a40b53b0288d363f39adde0ae0c45f8", + "size": 62778, + "subdir": "linux-64", + "timestamp": 1614082030997, + "version": "1.0.4" + }, + "csvkit-1.0.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ed9f873ab2ec9e6354320af8e0e1455", + "name": "csvkit", + "sha256": "03a2c68026b805d2656fc0b62dc015f1d68f7ba15fe921fd2042a9edb1e8d12e", + "size": 61907, + "subdir": "linux-64", + "timestamp": 1600354101162, + "version": "1.0.5" + }, + "csvkit-1.0.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b0e8501f083754f4440405c05be65fc", + "name": "csvkit", + "sha256": "21333d0ea0b01a2d6afd4d2b0bf7d0a2040260c3beb20928caa07d44d14087b9", + "size": 61934, + "subdir": "linux-64", + "timestamp": 1600354092555, + "version": "1.0.5" + }, + "csvkit-1.0.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "347f8d575e644404063a904e7f7f726b", + "name": "csvkit", + "sha256": "b2c5aaa05068db4eceeeb3d930baa73e4292f244080469a0b49ed200eb8ebf93", + "size": 61900, + "subdir": "linux-64", + "timestamp": 1600354130517, + "version": "1.0.5" + }, + "cubes-1.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=2.7,<2.8.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "4650f0aaef4e9d0796d4bc914bd07b27", + "name": "cubes", + "sha256": "f6c26e24bdd7eada13ed0d7a794c2144d7b7bcdadd386db256da77009b23505a", + "size": 218017, + "subdir": "linux-64", + "timestamp": 1537215890730, + "version": "1.1" + }, + "cubes-1.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=3.10,<3.11.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "66b0a51bad7f0b27ec85270e3899b40c", + "name": "cubes", + "sha256": "63d7942318e5118de653d668187487acba82b31b6fe06149080d2c0ab10ccd15", + "size": 223237, + "subdir": "linux-64", + "timestamp": 1640811876618, + "version": "1.1" + }, + "cubes-1.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=3.5,<3.6.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "88403fe19af73d7ad1be1cdeb7a9fe3a", + "name": "cubes", + "sha256": "2e9e854f339b071a89539a9f69585387b9d4aa0ab3d5fbcd1435e17479fa67b3", + "size": 222959, + "subdir": "linux-64", + "timestamp": 1537215912795, + "version": "1.1" + }, + "cubes-1.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "abe54350482cf9e6e6689706cabc33c0", + "name": "cubes", + "sha256": "f1c3101f5e5c92668ad9b3cf6a0e14856d3a6fad325bf1f807114e96bd88d4f5", + "size": 220509, + "subdir": "linux-64", + "timestamp": 1537215914459, + "version": "1.1" + }, + "cubes-1.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "5ef8865af69da1dd16a137f5bc6b5131", + "name": "cubes", + "sha256": "669ee68fc0cb2a388fd7cbbf1523c3e4c34405c9763044bbf2e73751e41c053a", + "size": 443590, + "subdir": "linux-64", + "timestamp": 1614080124050, + "version": "1.1" + }, + "cubes-1.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "6b4673afdfc3167ebecbf3c92d7c9119", + "name": "cubes", + "sha256": "edf990cfa13403b90431850d4ef68996de384290b9a962f6b1ad26d661589b7d", + "size": 220762, + "subdir": "linux-64", + "timestamp": 1537215854760, + "version": "1.1" + }, + "cubes-1.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "8bddbdc0081dd975cdf133f375bea080", + "name": "cubes", + "sha256": "1a848229481f2ce6168d1662ed716b4ef169bd1f4e1bc65ff3dd407b5c4be17a", + "size": 443708, + "subdir": "linux-64", + "timestamp": 1614080105291, + "version": "1.1" + }, + "cubes-1.1-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "04e05507b833cd60f67f9f842925b616", + "name": "cubes", + "sha256": "5a0b334a0287b151900515fecafd090111220f938a89a087e24eb4bfb71f1f4a", + "size": 222924, + "subdir": "linux-64", + "timestamp": 1574177698291, + "version": "1.1" + }, + "cubes-1.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "ec9ba2492f8617c5384211af87edf733", + "name": "cubes", + "sha256": "669530c6dc223552d9f93414f24eeb375c96f034ce2a1b8765b081af1384d01d", + "size": 466901, + "subdir": "linux-64", + "timestamp": 1614080111324, + "version": "1.1" + }, + "cubes-1.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=3.9,<3.10.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "44097469924ed6875df96bbbb546e4b5", + "name": "cubes", + "sha256": "167d462c5c1a8b4fc669f3a4d86f157ff974d916d550658796cdab396897a545", + "size": 466806, + "subdir": "linux-64", + "timestamp": 1614079796338, + "version": "1.1" + }, + "cudatoolkit-10.0.130-0.tar.bz2": { + "build": "0", + "build_number": 0, + "constrains": [ + "__cuda >=10.0" + ], + "depends": [], + "md5": "4388ad6015992501b042eea5197eb447", + "name": "cudatoolkit", + "sha256": "7756117029ac8d69ee350d91ee57ce160a55ff5a8bd3ecfd54c99c913b87d5ff", + "size": 398494037, + "subdir": "linux-64", + "timestamp": 1548259562909, + "version": "10.0.130" + }, + "cudatoolkit-10.1.168-0.tar.bz2": { + "build": "0", + "build_number": 0, + "constrains": [ + "__cuda >=10.1" + ], + "depends": [], + "md5": "43dcf7930d48ef4431e4c766d4b22888", + "name": "cudatoolkit", + "sha256": "2d25f352b264d6408fcb0fdb5621b1dad7be2cc70898e2d327c77026a8b9e33d", + "size": 541090367, + "subdir": "linux-64", + "timestamp": 1559573884225, + "version": "10.1.168" + }, + "cudatoolkit-10.1.243-h6bb024c_0.tar.bz2": { + "build": "h6bb024c_0", + "build_number": 0, + "constrains": [ + "__cuda >=10.1" + ], + "depends": [], + "md5": "0fab1ab5da0a51c6eb907cb5b4e8fc1b", + "name": "cudatoolkit", + "sha256": "6780176757ca55b8d851a40eb27eebf29958ae562f24f7c232253be6a8501c17", + "size": 538138815, + "subdir": "linux-64", + "timestamp": 1572634034749, + "version": "10.1.243" + }, + "cudatoolkit-10.2.89-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "constrains": [ + "__cuda >=10.2" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "md5": "21b256c1e87ce5397d7fb046ec01a3e1", + "name": "cudatoolkit", + "sha256": "828e407a57b218ea211c75a1d267171d57fad7f07434e289b36c4ed6c0dd50c9", + "size": 565544221, + "subdir": "linux-64", + "timestamp": 1576620513184, + "version": "10.2.89" + }, + "cudatoolkit-10.2.89-hfd86e86_1.tar.bz2": { + "build": "hfd86e86_1", + "build_number": 1, + "constrains": [ + "__cuda >=10.2" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "md5": "2471ac0affa977038c5f5619e05814a0", + "name": "cudatoolkit", + "sha256": "bfd9d019ed060a7d063fcc965c59e2bfb52eb34f90c5daf9a740a86cb16bf66a", + "size": 566179631, + "subdir": "linux-64", + "timestamp": 1588169992158, + "version": "10.2.89" + }, + "cudatoolkit-11.0.221-h6bb024c_0.tar.bz2": { + "build": "h6bb024c_0", + "build_number": 0, + "constrains": [ + "__cuda >=11.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "NVIDIA End User License Agreement", + "md5": "cc6d31881a6eac569e48f9f84307dc09", + "name": "cudatoolkit", + "sha256": "5cc9f7ef136288612004e715886ccf413a1f12133dec6de7076034fa3b1d0542", + "size": 998927522, + "subdir": "linux-64", + "timestamp": 1598395571777, + "version": "11.0.221" + }, + "cudatoolkit-11.3.1-h2bc3f7f_2.tar.bz2": { + "build": "h2bc3f7f_2", + "build_number": 2, + "constrains": [ + "__cuda >=11.0" + ], + "depends": [ + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0" + ], + "license": "NVIDIA End User License Agreement", + "md5": "2ef7f9cbd9dc462a7dd324d4a0683a1d", + "name": "cudatoolkit", + "sha256": "b7c1b51a2575e2a13d0342af3c7f007d4d46ca5e2394857d39424d13fbec352a", + "size": 855169462, + "subdir": "linux-64", + "timestamp": 1624974048871, + "version": "11.3.1" + }, + "cudatoolkit-9.0-h13b8566_0.tar.bz2": { + "build": "h13b8566_0", + "build_number": 0, + "constrains": [ + "__cuda >=9.0" + ], + "depends": [], + "md5": "5d0febed868b80a18e74077d5d0f17bc", + "name": "cudatoolkit", + "sha256": "f1036e0972be0567e215a7ae0bb226100579f9e8777b3874aaea665e4d0c5575", + "size": 356949623, + "subdir": "linux-64", + "timestamp": 1515427750026, + "version": "9.0" + }, + "cudatoolkit-9.2-0.tar.bz2": { + "build": "0", + "build_number": 0, + "constrains": [ + "__cuda >=9.2" + ], + "depends": [], + "md5": "f81c96e01ccb9028800101b35e71b844", + "name": "cudatoolkit", + "sha256": "10fe4efb21e29c0476dc36f915342bff9bc85d5724d190781700f469051104e3", + "size": 368063287, + "subdir": "linux-64", + "timestamp": 1534891706146, + "version": "9.2" + }, + "cudnn-7.0.5-cuda8.0_0.tar.bz2": { + "build": "cuda8.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0*" + ], + "license": "Proprietary", + "md5": "eb57df7025cac8d517bb9f67b38eb25b", + "name": "cudnn", + "sha256": "1285993a5dc40d10c01cb2b07e32ff38cd25bd5b51044bf0b96d0fedc0290504", + "size": 261398285, + "subdir": "linux-64", + "timestamp": 1513362701597, + "version": "7.0.5" + }, + "cudnn-7.1.2-cuda9.0_0.tar.bz2": { + "build": "cuda9.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "libgcc-ng", + "libstdcxx-ng" + ], + "license": "Proprietary", + "md5": "4a402b88bb77e6ab2dcf3bfe6522f9cf", + "name": "cudnn", + "sha256": "133788ed372cb9273347561cd18d58ef6c3a6d4d4ea2d0b93c33151f6bb24c93", + "size": 385668782, + "subdir": "linux-64", + "timestamp": 1523281397595, + "version": "7.1.2" + }, + "cudnn-7.1.3-cuda8.0_0.tar.bz2": { + "build": "cuda8.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*" + ], + "license": "Proprietary", + "md5": "883537a185eeee5297aaab2f24f725df", + "name": "cudnn", + "sha256": "55bd536ec76857fb3229b05378eec1a02713b93c28f4b1ebd48e423fa2c23481", + "size": 240740788, + "subdir": "linux-64", + "timestamp": 1533763199150, + "version": "7.1.3" + }, + "cudnn-7.2.1-cuda9.2_0.tar.bz2": { + "build": "cuda9.2_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.2.*" + ], + "license": "Proprietary", + "md5": "6a84069dcf4aca8ba9493d3cb320090e", + "name": "cudnn", + "sha256": "fb1d6b4bd7fe6d3e4eab4fc23a36be2d4d8bdb551a13ff87d657ce88b5cfad50", + "size": 338507229, + "subdir": "linux-64", + "timestamp": 1534891952969, + "version": "7.2.1" + }, + "cudnn-7.3.1-cuda10.0_0.tar.bz2": { + "build": "cuda10.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.0.*" + ], + "license": "Proprietary", + "md5": "d645e4ff34d3b108209a1007c4e46bad", + "name": "cudnn", + "sha256": "d8e754d8eb0915121bcb3cbbda1bbe730ec5fe8338cf01df7ebb77478e961b27", + "size": 403846124, + "subdir": "linux-64", + "timestamp": 1548261121945, + "version": "7.3.1" + }, + "cudnn-7.3.1-cuda9.0_0.tar.bz2": { + "build": "cuda9.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*" + ], + "license": "Proprietary", + "md5": "d5486573f54319b0133eafd68f421f10", + "name": "cudnn", + "sha256": "639e4e6bd99a5a90aa741a8825b0ac80528b3ce773b3f9bba52498223b97f28a", + "size": 347436896, + "subdir": "linux-64", + "timestamp": 1548264434745, + "version": "7.3.1" + }, + "cudnn-7.3.1-cuda9.2_0.tar.bz2": { + "build": "cuda9.2_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.2.*" + ], + "license": "Proprietary", + "md5": "12f17f1c55daef51980c718f5a066220", + "name": "cudnn", + "sha256": "8268504b8f21a401b77644c45147d599fa40f786207e9d623e60de84fd8a472c", + "size": 350871190, + "subdir": "linux-64", + "timestamp": 1548262939538, + "version": "7.3.1" + }, + "cudnn-7.6.0-cuda10.0_0.tar.bz2": { + "build": "cuda10.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0,<10.1" + ], + "license": "Proprietary", + "md5": "ffd33dfe01265551517291f584d5e062", + "name": "cudnn", + "sha256": "c42fe7f57f9a97926c8fc01f082bc84b06b91823022f45459adfb10344cc29ac", + "size": 227137048, + "subdir": "linux-64", + "timestamp": 1559577113681, + "version": "7.6.0" + }, + "cudnn-7.6.0-cuda10.1_0.tar.bz2": { + "build": "cuda10.1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.1,<10.2" + ], + "license": "Proprietary", + "md5": "c68a3c0d957ca564d8a8c77d2a700109", + "name": "cudnn", + "sha256": "55c1e0ecda112bba751e789ecd5ef0ed47ad26264bcb34583a90384942d1862f", + "size": 252607114, + "subdir": "linux-64", + "timestamp": 1559576071032, + "version": "7.6.0" + }, + "cudnn-7.6.0-cuda9.0_0.tar.bz2": { + "build": "cuda9.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1" + ], + "license": "Proprietary", + "md5": "101dab138b6b2e8dadf7c0e74b8f0876", + "name": "cudnn", + "sha256": "4ceaf1f66c0313192b1eb91dfc239764ba85597746dfe3264e8aaa5e00b44d81", + "size": 192527229, + "subdir": "linux-64", + "timestamp": 1559576388391, + "version": "7.6.0" + }, + "cudnn-7.6.0-cuda9.2_0.tar.bz2": { + "build": "cuda9.2_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3" + ], + "license": "Proprietary", + "md5": "3121c2a60064304f8566989a40de00bf", + "name": "cudnn", + "sha256": "22ac670de9c8230a96bd8355698377228959de97438bb8f61387005cee73d20e", + "size": 192197480, + "subdir": "linux-64", + "timestamp": 1559576744678, + "version": "7.6.0" + }, + "cudnn-7.6.4-cuda10.0_0.tar.bz2": { + "build": "cuda10.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0,<10.1" + ], + "license": "Proprietary", + "md5": "c06bd5621d2aaa7e4060909e98ffd2c6", + "name": "cudnn", + "sha256": "d703fec761a9f493bd3e253f63921b8650e5b53d85782d1f6ca14f187eb89a78", + "size": 237601349, + "subdir": "linux-64", + "timestamp": 1572994963804, + "version": "7.6.4" + }, + "cudnn-7.6.4-cuda10.1_0.tar.bz2": { + "build": "cuda10.1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.1,<10.2" + ], + "license": "Proprietary", + "md5": "0444cb16f948486d72237bd3e13dd0d0", + "name": "cudnn", + "sha256": "a9cdd50a52404651c47b4ee7d13e9c2774169f7c0b06a93f4464a604f483cf07", + "size": 263013351, + "subdir": "linux-64", + "timestamp": 1572994968109, + "version": "7.6.4" + }, + "cudnn-7.6.4-cuda9.0_0.tar.bz2": { + "build": "cuda9.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1" + ], + "license": "Proprietary", + "md5": "e50c82a65ffe6b806ed84103983f0d89", + "name": "cudnn", + "sha256": "faf169e86c36de82a47ff07a446127806d88990f45089f33ff2f76dab6da393e", + "size": 202714366, + "subdir": "linux-64", + "timestamp": 1572994948276, + "version": "7.6.4" + }, + "cudnn-7.6.4-cuda9.2_0.tar.bz2": { + "build": "cuda9.2_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3" + ], + "license": "Proprietary", + "md5": "14970c253b73bed1aaf28d61c74c6a69", + "name": "cudnn", + "sha256": "d96917350ab862c2c79f09078790d65bc038c282d0227d5ea9dbb511083e7175", + "size": 202947640, + "subdir": "linux-64", + "timestamp": 1572994954968, + "version": "7.6.4" + }, + "cudnn-7.6.5-cuda10.0_0.tar.bz2": { + "build": "cuda10.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0,<10.1" + ], + "license": "Proprietary", + "md5": "2696c3864ed0741d5914851ae4621b90", + "name": "cudnn", + "sha256": "650301cc954a21a31cf6960da010432d2a7c728e4a7bc5feef9d204120e207a5", + "size": 237424549, + "subdir": "linux-64", + "timestamp": 1576790197647, + "version": "7.6.5" + }, + "cudnn-7.6.5-cuda10.1_0.tar.bz2": { + "build": "cuda10.1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.1,<10.2" + ], + "license": "Proprietary", + "md5": "f26fb613fdb2cc733802c8f2f8682eb0", + "name": "cudnn", + "sha256": "98d0422e4f59511fe9fa82945df23aad963b5ae15eb7c219395c7fbc617f06b4", + "size": 262774453, + "subdir": "linux-64", + "timestamp": 1576790463878, + "version": "7.6.5" + }, + "cudnn-7.6.5-cuda10.2_0.tar.bz2": { + "build": "cuda10.2_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.2,<10.3" + ], + "license": "Proprietary", + "md5": "4d60bac141ca6c514d80fba5534ddd92", + "name": "cudnn", + "sha256": "c969738fb072d5f39bd4dcde449fe7bfc72a345858495df0fef49142bc09e6a6", + "size": 271623157, + "subdir": "linux-64", + "timestamp": 1576790194333, + "version": "7.6.5" + }, + "cudnn-7.6.5-cuda9.0_0.tar.bz2": { + "build": "cuda9.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1" + ], + "license": "Proprietary", + "md5": "448d294a85c4934c35150692325244b6", + "name": "cudnn", + "sha256": "d2cf57d5a6a375b9fab1fde335776830aa1d2f443cf147ec457ec76ab45ec0f4", + "size": 202775760, + "subdir": "linux-64", + "timestamp": 1576790399970, + "version": "7.6.5" + }, + "cudnn-7.6.5-cuda9.2_0.tar.bz2": { + "build": "cuda9.2_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3" + ], + "license": "Proprietary", + "md5": "87251e61cb08e5b6de7bfaf4c2e10ec3", + "name": "cudnn", + "sha256": "be8469039b8eea8a4c178441e656ceee1225d9126dd3360ff6c60d01390b41ce", + "size": 202110532, + "subdir": "linux-64", + "timestamp": 1576790368096, + "version": "7.6.5" + }, + "cudnn-8.2.1-cuda11.3_0.tar.bz2": { + "build": "cuda11.3_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=11.3,<11.4" + ], + "license": "Proprietary", + "md5": "fba0a88ca6175254909dac2b2d801891", + "name": "cudnn", + "sha256": "8130eac5d0629e52a09a4c33d5a95d517171e7cab83a0112db271132ceaa833b", + "size": 1413734582, + "subdir": "linux-64", + "timestamp": 1625057502116, + "version": "8.2.1" + }, + "cunit-2.1.3-h295c915_1002.tar.bz2": { + "build": "h295c915_1002", + "build_number": 1002, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "LGPL-2.0-only", + "md5": "d2f651069d5e51236a2984f6ba78d6a8", + "name": "cunit", + "sha256": "41365d7e9c6b6b9fb8d7f28bb54dfd5a2d02d48ce7053d420d5bc161a86ce6d4", + "size": 675863, + "subdir": "linux-64", + "timestamp": 1655476904224, + "version": "2.1.3" + }, + "cupti-10.0.130-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.0.*" + ], + "license": "proprietary - Nvidia", + "license_family": "Proprietary", + "md5": "27fd50b7510bc0a896db1f58f385b590", + "name": "cupti", + "sha256": "008bdcaa55cdd7f9445a97326774dd89c97ce8c0c139909cc7faa6b81c084c39", + "size": 1839674, + "subdir": "linux-64", + "timestamp": 1548266521078, + "version": "10.0.130" + }, + "cupti-10.1.168-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.1,<10.2" + ], + "license": "proprietary - Nvidia", + "license_family": "Proprietary", + "md5": "db09bf897b37f3537cbfe73a3a1bd5f0", + "name": "cupti", + "sha256": "5170c3eb19584f91a1840c0d093f210c159cb91b3faf6ed5b348a202f59066df", + "size": 1735370, + "subdir": "linux-64", + "timestamp": 1559575616138, + "version": "10.1.168" + }, + "cupti-11.3.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "cudatoolkit >=11.3,<11.4" + ], + "license": "proprietary - Nvidia", + "license_family": "Proprietary", + "md5": "9af97caf073376a5d4635d1992623a30", + "name": "cupti", + "sha256": "3e5c28671a45fbff04dc130a2ba502717c220d3b1ec84a3fd0da0aeaf6930268", + "size": 21750332, + "subdir": "linux-64", + "timestamp": 1626364160946, + "version": "11.3.1" + }, + "cupti-8.0.61-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.*" + ], + "license": "proprietary - Nvidia", + "license_family": "Proprietary", + "md5": "65decf16f49a67c4ea6c163d096e982a", + "name": "cupti", + "sha256": "b45ab65f8cfdaf13dc6b8fc534c9f49a783fa14dadcdd10aff3714a91b0f0795", + "size": 1452329, + "subdir": "linux-64", + "timestamp": 1524240019951, + "version": "8.0.61" + }, + "cupti-9.0.176-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*" + ], + "license": "proprietary - Nvidia", + "license_family": "Proprietary", + "md5": "136df1225d6f78ef2c751a74d2c05eaa", + "name": "cupti", + "sha256": "9147cdb119de305cf0378f20d9b7e91751f717f10f639e46ce1d6196659f6a87", + "size": 1690464, + "subdir": "linux-64", + "timestamp": 1524334373749, + "version": "9.0.176" + }, + "cupti-9.2.148-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.2.*" + ], + "license": "proprietary - Nvidia", + "license_family": "Proprietary", + "md5": "4767ff7d580fbba501946af2ec137258", + "name": "cupti", + "sha256": "5b1a83a106739bb139a79870a7a2bac0261470a5a54f1a7f523bf72dd0b5127f", + "size": 1815872, + "subdir": "linux-64", + "timestamp": 1534892452681, + "version": "9.2.148" + }, + "cupy-4.0.0-py27he3f55b6_0.tar.bz2": { + "build": "py27he3f55b6_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83851e2d85f6cb2b26a05ac8e0998a51", + "name": "cupy", + "sha256": "10fec8002ea41ea4b0797c29cf1a18c4ca1a46c81f89bcc6592b4edbe786126a", + "size": 10643349, + "subdir": "linux-64", + "timestamp": 1524333449391, + "version": "4.0.0" + }, + "cupy-4.0.0-py27hef69808_0.tar.bz2": { + "build": "py27hef69808_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "79bc51cad7014f0624e8341bfe11919d", + "name": "cupy", + "sha256": "b9da5de5b99463bbef4edf386b3c90574183853c186ee3ad3bc6267be5c82260", + "size": 11043832, + "subdir": "linux-64", + "timestamp": 1524330066388, + "version": "4.0.0" + }, + "cupy-4.0.0-py35he3f55b6_0.tar.bz2": { + "build": "py35he3f55b6_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "76e71dad09111e54684b4f386c3d41be", + "name": "cupy", + "sha256": "22ca29e6ab1e9717337b70e2b564054aaaba78746661a8fbc0eeff1c661e457b", + "size": 10637341, + "subdir": "linux-64", + "timestamp": 1524333975724, + "version": "4.0.0" + }, + "cupy-4.0.0-py35hef69808_0.tar.bz2": { + "build": "py35hef69808_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "773e8b570a3c64177abd0f69e6edf0cf", + "name": "cupy", + "sha256": "fd002a553f787fb6c98bfd02e336edf9d74a6a2dfd5f47549ff2fbd97cea0a70", + "size": 11067114, + "subdir": "linux-64", + "timestamp": 1524330692531, + "version": "4.0.0" + }, + "cupy-4.0.0-py36he3f55b6_0.tar.bz2": { + "build": "py36he3f55b6_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f00d6546834a96c22954aee1f95500e", + "name": "cupy", + "sha256": "814b5c749d7f1476ff2bbaf115c2fbc25aebe2b878703c0d3c729e480be76554", + "size": 10695046, + "subdir": "linux-64", + "timestamp": 1524334470441, + "version": "4.0.0" + }, + "cupy-4.0.0-py36hef69808_0.tar.bz2": { + "build": "py36hef69808_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca911a0e204671b28c4dd789ada024e5", + "name": "cupy", + "sha256": "ccabf6041e1e91f93ebff7d70ccd5d4b3a1064483c0ed4bdec7ecdea8713984f", + "size": 11062899, + "subdir": "linux-64", + "timestamp": 1524331225376, + "version": "4.0.0" + }, + "cupy-4.1.0-py27h0ee51e5_0.tar.bz2": { + "build": "py27h0ee51e5_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d89b7fce832b7399d58768c2b45fd36", + "name": "cupy", + "sha256": "869be94740418ef699e1ee9abb7d4dd5972b54a25b18ebd14d1e83bfe14c1b13", + "size": 10641941, + "subdir": "linux-64", + "timestamp": 1529344342225, + "version": "4.1.0" + }, + "cupy-4.1.0-py27had95abb_0.tar.bz2": { + "build": "py27had95abb_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0163ac984a8e43480d58f6d20043661", + "name": "cupy", + "sha256": "cfb0f41284a87894a334d6155c95c7125940f17d41739cd9768580395f069850", + "size": 11040315, + "subdir": "linux-64", + "timestamp": 1529350485275, + "version": "4.1.0" + }, + "cupy-4.1.0-py35h0ee51e5_0.tar.bz2": { + "build": "py35h0ee51e5_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee0735da8fe8a3b782af5eb38f24c4f8", + "name": "cupy", + "sha256": "b6ebbfa2928d52fcc083e70a7d6a535e566b79c2ffa80d0622a6164ee7630e0d", + "size": 10648384, + "subdir": "linux-64", + "timestamp": 1529343754967, + "version": "4.1.0" + }, + "cupy-4.1.0-py35had95abb_0.tar.bz2": { + "build": "py35had95abb_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0fd55cd076919b7a01c75b3082b269fe", + "name": "cupy", + "sha256": "1a8a6e2687ab802f4fcd54a49daa19c144f1bd5c4d57f4e54300bee25d614c4d", + "size": 11064212, + "subdir": "linux-64", + "timestamp": 1529349907735, + "version": "4.1.0" + }, + "cupy-4.1.0-py36h0ee51e5_0.tar.bz2": { + "build": "py36h0ee51e5_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ded3df61398b87ffa8c629cf40d8de5e", + "name": "cupy", + "sha256": "3647cdd05afc0e35eeb47d8a1631db47fb36b859d3069211e05b4e7ef37bcd17", + "size": 10699538, + "subdir": "linux-64", + "timestamp": 1529344849257, + "version": "4.1.0" + }, + "cupy-4.1.0-py36had95abb_0.tar.bz2": { + "build": "py36had95abb_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ec9b847a9aa4f56d317b843d4d72398", + "name": "cupy", + "sha256": "1d401307857de253b7eee707b0c389e2d6f9d04027e3e1d47212e2c640450776", + "size": 11066702, + "subdir": "linux-64", + "timestamp": 1529349228160, + "version": "4.1.0" + }, + "cupy-5.1.0-py27h062aff8_0.tar.bz2": { + "build": "py27h062aff8_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=8.0,<9.0a0", + "cudnn >=7.1.3,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.4,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2ef05211b8c343f9ab1cc676ec13c09", + "name": "cupy", + "sha256": "1a7333c36fe94bfb4207e13be61bd2eb7243634a8efd265122c2c457e5bd7871", + "size": 11361376, + "subdir": "linux-64", + "timestamp": 1548269838134, + "version": "5.1.0" + }, + "cupy-5.1.0-py27h686fdb1_0.tar.bz2": { + "build": "py27h686fdb1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4cec9a58c5db5d8e0585cd069c063445", + "name": "cupy", + "sha256": "095fcd852b747e19d065a249b6e4119124a34a5b3876c6ce98b40bf65c323b8c", + "size": 11007365, + "subdir": "linux-64", + "timestamp": 1548267152672, + "version": "5.1.0" + }, + "cupy-5.1.0-py27hc0ce245_0.tar.bz2": { + "build": "py27hc0ce245_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e2ac6474dd55d7316088c85d40a3c2ac", + "name": "cupy", + "sha256": "5d938a9f7a05fab967c6717a6f6f1975592aff5c8419740f0da61e0e049662c8", + "size": 13362942, + "subdir": "linux-64", + "timestamp": 1548263254994, + "version": "5.1.0" + }, + "cupy-5.1.0-py27hc15394e_0.tar.bz2": { + "build": "py27hc15394e_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e0bdcc86d58121dcacf16d5c5766f61", + "name": "cupy", + "sha256": "1ddf7440f4c7cb0379d07ff0e4465a13476accaad17c3f277c5d97b8e766aa70", + "size": 13311225, + "subdir": "linux-64", + "timestamp": 1548265848133, + "version": "5.1.0" + }, + "cupy-5.1.0-py36h062aff8_0.tar.bz2": { + "build": "py36h062aff8_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=8.0,<9.0a0", + "cudnn >=7.1.3,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.4,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab4a53511a25065368a9e4f78da95d5d", + "name": "cupy", + "sha256": "b462d66f87989c93b12ba3876b40064032e872a8168ad6f58be12491dfae4ee3", + "size": 11656332, + "subdir": "linux-64", + "timestamp": 1548269394435, + "version": "5.1.0" + }, + "cupy-5.1.0-py36h686fdb1_0.tar.bz2": { + "build": "py36h686fdb1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de8be2d82efdd57662f01c6c21bb6670", + "name": "cupy", + "sha256": "51cbf239df8705d7e337031fccc0d511489c8218efe54b1bfca6f39a26e5b745", + "size": 11095933, + "subdir": "linux-64", + "timestamp": 1548268007029, + "version": "5.1.0" + }, + "cupy-5.1.0-py36hc0ce245_0.tar.bz2": { + "build": "py36hc0ce245_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8445fbcc9b3a23b16723e0e8e69582a3", + "name": "cupy", + "sha256": "f99b31247cd8501b897967634baae63530ed8f7f84f67fed45c0129f569411bf", + "size": 13445241, + "subdir": "linux-64", + "timestamp": 1548263763381, + "version": "5.1.0" + }, + "cupy-5.1.0-py36hc15394e_0.tar.bz2": { + "build": "py36hc15394e_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "99e63cf31e8fd18e0b87b928b596861c", + "name": "cupy", + "sha256": "2c8e423eec45f952fae85b571d4b97cd4e49394353a3b1160801365d993d1c78", + "size": 13421822, + "subdir": "linux-64", + "timestamp": 1548266351530, + "version": "5.1.0" + }, + "cupy-5.1.0-py37h062aff8_0.tar.bz2": { + "build": "py37h062aff8_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=8.0,<9.0a0", + "cudnn >=7.1.3,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.4,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90a6c4be015c8ec6b27c5d69eedc35eb", + "name": "cupy", + "sha256": "9f2ae0da018c630227130076da005f4aab778c07d26c60cec323645b4df068a5", + "size": 11658671, + "subdir": "linux-64", + "timestamp": 1548268944292, + "version": "5.1.0" + }, + "cupy-5.1.0-py37h686fdb1_0.tar.bz2": { + "build": "py37h686fdb1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a1b83ccd5eba8dec197affb2f7e55f45", + "name": "cupy", + "sha256": "469fbf66aee987b8def12966411f4f6472c67d33bd7656f9f30dd56521c80b5c", + "size": 11074645, + "subdir": "linux-64", + "timestamp": 1548267567424, + "version": "5.1.0" + }, + "cupy-5.1.0-py37hc0ce245_0.tar.bz2": { + "build": "py37hc0ce245_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "603ffb8ac6d449f7f5aef75fbfe7bd58", + "name": "cupy", + "sha256": "20cfb63be87630f1bf8b911c18131231385275a45db6b57f553ed49e6f57e188", + "size": 13431030, + "subdir": "linux-64", + "timestamp": 1548262748665, + "version": "5.1.0" + }, + "cupy-5.1.0-py37hc15394e_0.tar.bz2": { + "build": "py37hc15394e_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "754de1974bbd2b74f45b37c1d5044e77", + "name": "cupy", + "sha256": "0d3f9c5906dc2bac56ed9ef9fb65cc94755d98bdc1ef6e9a882e5cfe470b0e29", + "size": 13434847, + "subdir": "linux-64", + "timestamp": 1548265341166, + "version": "5.1.0" + }, + "cupy-6.0.0-py27h062aff8_0.tar.bz2": { + "build": "py27h062aff8_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=8.0,<9.0a0", + "cudnn >=7.1.3,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.4,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "425ff9dd164582bb5e2ecc7fd1edb440", + "name": "cupy", + "sha256": "ea1baafe256f1b723457cdbf45368f73f72f2efd56969b8ea095adf152d0f905", + "size": 11914059, + "subdir": "linux-64", + "timestamp": 1559146646483, + "version": "6.0.0" + }, + "cupy-6.0.0-py27h686fdb1_0.tar.bz2": { + "build": "py27h686fdb1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e7b88f53303bbf29fd943a0dc773195e", + "name": "cupy", + "sha256": "560b1ff36f4143c1db456685abdaede4900d818556c2c5947e8e15b37c96c839", + "size": 11612723, + "subdir": "linux-64", + "timestamp": 1559151386662, + "version": "6.0.0" + }, + "cupy-6.0.0-py27hc0ce245_0.tar.bz2": { + "build": "py27hc0ce245_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "68f87c69ad6a5f3a864f91fff1e1ee07", + "name": "cupy", + "sha256": "e8555072174ddd7c11952932ee5a2f575e511cb3d3707d800ff61062a05d4f93", + "size": 15105527, + "subdir": "linux-64", + "timestamp": 1559169047774, + "version": "6.0.0" + }, + "cupy-6.0.0-py27hc15394e_0.tar.bz2": { + "build": "py27hc15394e_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc9459b8fe2d6d53a017d37572edf10b", + "name": "cupy", + "sha256": "c554d553a9d80fd0b39083ae7bc06bd7923a60ec2541b8ba7336faf8c32e8439", + "size": 13840115, + "subdir": "linux-64", + "timestamp": 1559154647818, + "version": "6.0.0" + }, + "cupy-6.0.0-py36h062aff8_0.tar.bz2": { + "build": "py36h062aff8_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=8.0,<9.0a0", + "cudnn >=7.1.3,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.4,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "659d4452d6cc98dc84f78fdb2a258b88", + "name": "cupy", + "sha256": "23ec682362f34ca8b8718af8e831591e3baba7056dd479ddeff3dead627acaa1", + "size": 12198717, + "subdir": "linux-64", + "timestamp": 1559147225984, + "version": "6.0.0" + }, + "cupy-6.0.0-py36h686fdb1_0.tar.bz2": { + "build": "py36h686fdb1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e06f166fb72d0421d7c14e79ecaf1df", + "name": "cupy", + "sha256": "911dfc83d8d16ee25174ab0b7e31f93be1ba36ebf6e39e51d264bd65a235a4ed", + "size": 11720259, + "subdir": "linux-64", + "timestamp": 1559150789800, + "version": "6.0.0" + }, + "cupy-6.0.0-py36hc0ce245_0.tar.bz2": { + "build": "py36hc0ce245_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d8cbdd46b46a0315b1bedf75eb711e8", + "name": "cupy", + "sha256": "36c307ebd31bceb1bca683e9462dc6bbb96a2fbb59425051a309cde66ac947cb", + "size": 15083594, + "subdir": "linux-64", + "timestamp": 1559169844650, + "version": "6.0.0" + }, + "cupy-6.0.0-py36hc15394e_0.tar.bz2": { + "build": "py36hc15394e_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8b7a6b8f9a952eabf9142d67a3b76743", + "name": "cupy", + "sha256": "70103a59d9cf500f4931796be022dc81210b2e4af665834712f23d0af6f3718e", + "size": 13965113, + "subdir": "linux-64", + "timestamp": 1559153138654, + "version": "6.0.0" + }, + "cupy-6.0.0-py37h062aff8_0.tar.bz2": { + "build": "py37h062aff8_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=8.0,<9.0a0", + "cudnn >=7.1.3,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.4,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "091f300ad001734be93eada8d7b70266", + "name": "cupy", + "sha256": "c185260c032a3fc95956fd343fa1f46a4c5bb49eafb5e1e68ef3543d8851c1c2", + "size": 12194689, + "subdir": "linux-64", + "timestamp": 1559147802889, + "version": "6.0.0" + }, + "cupy-6.0.0-py37h686fdb1_0.tar.bz2": { + "build": "py37h686fdb1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1902010e5560634ccebd0d3816156abd", + "name": "cupy", + "sha256": "141726e678971a2b9deac0e5b04c4282f3b1473a9fdce93b48ddfb893486b6d9", + "size": 11705928, + "subdir": "linux-64", + "timestamp": 1559149912534, + "version": "6.0.0" + }, + "cupy-6.0.0-py37hc0ce245_0.tar.bz2": { + "build": "py37hc0ce245_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "acb09b03ce2726f6675c879ebf73fab2", + "name": "cupy", + "sha256": "19a6b60a4307254e1f2b0d70dd536852dae32bb79ad2a31b2f48e25b3fe08c59", + "size": 15078513, + "subdir": "linux-64", + "timestamp": 1559168228540, + "version": "6.0.0" + }, + "cupy-6.0.0-py37hc15394e_0.tar.bz2": { + "build": "py37hc15394e_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e24f957d95ef6d6aaa45d6e32e126b5b", + "name": "cupy", + "sha256": "25bfea585f641864d9c7ae40ca62ae0cd5536f3097ac2002aeefa100c1cae698", + "size": 13987039, + "subdir": "linux-64", + "timestamp": 1559153898766, + "version": "6.0.0" + }, + "cupy-8.3.0-py36h91b26fc_0.tar.bz2": { + "build": "py36h91b26fc_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.0|10.0.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "20a6f741028b621c3a4ee9971bd0d5bf", + "name": "cupy", + "sha256": "54aca5a5fd69ab3257b7ed21bb115aa96c03f76035edc1d624ff3aba5b62afee", + "size": 35073295, + "subdir": "linux-64", + "timestamp": 1610055481005, + "version": "8.3.0" + }, + "cupy-8.3.0-py36hcaf9a05_0.tar.bz2": { + "build": "py36hcaf9a05_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.1|10.1.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "449aa445b6d5515c4b7ccb9000dddd26", + "name": "cupy", + "sha256": "d1cebe4fc601d5fb7ff88bca83f04146abf4b66dadea47b38477aaeeaa26e44f", + "size": 35554004, + "subdir": "linux-64", + "timestamp": 1610062666925, + "version": "8.3.0" + }, + "cupy-8.3.0-py36heaad284_0.tar.bz2": { + "build": "py36heaad284_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.2|9.2.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e68089a7ff13cae221375f10c0b4d4d4", + "name": "cupy", + "sha256": "41c2bf73cca6088b643a2cec5c4af0745a2a690ab04a59e316faf62fbed162ef", + "size": 32373872, + "subdir": "linux-64", + "timestamp": 1610043330245, + "version": "8.3.0" + }, + "cupy-8.3.0-py37h91b26fc_0.tar.bz2": { + "build": "py37h91b26fc_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.0|10.0.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c7e349a31fc63670d4c7ae93a9a097c0", + "name": "cupy", + "sha256": "08442a8956085dbfd9930dd54df4f3aca5a5ff0698f5c8389db0eefe740e3754", + "size": 34978280, + "subdir": "linux-64", + "timestamp": 1610057076676, + "version": "8.3.0" + }, + "cupy-8.3.0-py37hcaf9a05_0.tar.bz2": { + "build": "py37hcaf9a05_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.1|10.1.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b23f0e97739e50ded56d8df85fff09b", + "name": "cupy", + "sha256": "21f8df11053b3960cd1e66d1c5be29b62d3182a055d3e37fa89c88ebb1a42fa0", + "size": 35496144, + "subdir": "linux-64", + "timestamp": 1610064233504, + "version": "8.3.0" + }, + "cupy-8.3.0-py37heaad284_0.tar.bz2": { + "build": "py37heaad284_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.2|9.2.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9d4b26487441a7213bc7fbf56961724", + "name": "cupy", + "sha256": "af80aa586e46d42b3077854615b9bf0c29c10f48a6002627c59851129f129a0c", + "size": 32293056, + "subdir": "linux-64", + "timestamp": 1610044661910, + "version": "8.3.0" + }, + "cupy-8.3.0-py38h91b26fc_0.tar.bz2": { + "build": "py38h91b26fc_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.0|10.0.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "09c4137928a4fcbcd3f1f6016bd8157e", + "name": "cupy", + "sha256": "7abf8bad404fb11f5cf00892403d102d62360c9d792cb49421e58719e7a7da4a", + "size": 35553010, + "subdir": "linux-64", + "timestamp": 1610058430477, + "version": "8.3.0" + }, + "cupy-8.3.0-py38hcaf9a05_0.tar.bz2": { + "build": "py38hcaf9a05_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.1|10.1.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b25ef5d19a488d6e50b42542e884d575", + "name": "cupy", + "sha256": "e99edfb3554fbddd014366e22e14403171d282a6054655eba2533088251586c0", + "size": 35308576, + "subdir": "linux-64", + "timestamp": 1610065881815, + "version": "8.3.0" + }, + "cupy-8.3.0-py38heaad284_0.tar.bz2": { + "build": "py38heaad284_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.2|9.2.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ab5b145ae27b9b6e284f9f2053ad08d", + "name": "cupy", + "sha256": "4956ce6cf8e037021c1737a46df6b2c4490c0c1e172be522a1462f676adc7424", + "size": 32169993, + "subdir": "linux-64", + "timestamp": 1610045959852, + "version": "8.3.0" + }, + "cupy-8.3.0-py39h91b26fc_0.tar.bz2": { + "build": "py39h91b26fc_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.0|10.0.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37eb99c6dfa810967efc71cb416b1749", + "name": "cupy", + "sha256": "59bc5029b11fa71dac6cb76cc83b3c71b8d44e9df13b9f1420e5b014667921d5", + "size": 35004224, + "subdir": "linux-64", + "timestamp": 1610059758394, + "version": "8.3.0" + }, + "cupy-8.3.0-py39hcaf9a05_0.tar.bz2": { + "build": "py39hcaf9a05_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.1|10.1.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a5001dbcef23406de63cf4f4be9ddef", + "name": "cupy", + "sha256": "fe950479fa92bf368c53ee5e6decbf6aee9e1f7804717c26f25f2f590097a708", + "size": 35831957, + "subdir": "linux-64", + "timestamp": 1610067224656, + "version": "8.3.0" + }, + "cupy-8.3.0-py39heaad284_0.tar.bz2": { + "build": "py39heaad284_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.2|9.2.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c8bb6f461d17f5258dc3891d9309181", + "name": "cupy", + "sha256": "9a967f6305faaa0b844e6f87878471aff1419611e784180940f6e9b8b38dc9ff", + "size": 32196650, + "subdir": "linux-64", + "timestamp": 1610051324612, + "version": "8.3.0" + }, + "curl-7.55.1-h78862de_4.tar.bz2": { + "build": "h78862de_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libssh2 1.*", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "22d077c538768a53642c341178132112", + "name": "curl", + "sha256": "d8ad71234f8cf40b8b4e1a4c086888268e2b9f402046ff4007dd22ce6097b600", + "size": 641802, + "subdir": "linux-64", + "timestamp": 1510603346884, + "version": "7.55.1" + }, + "curl-7.55.1-hcb0b314_2.tar.bz2": { + "build": "hcb0b314_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libssh2 1.*", + "openssl 1.0.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "0fd7bde148a1ee633b9327e4329fdacf", + "name": "curl", + "sha256": "8234f5c72a8bddcb4d34421ff3de425cd9734d78b96b1e181afb0204879d1805", + "size": 640860, + "subdir": "linux-64", + "timestamp": 1505687736238, + "version": "7.55.1" + }, + "curl-7.57.0-h84994c4_0.tar.bz2": { + "build": "h84994c4_0", + "build_number": 0, + "depends": [ + "libcurl 7.57.0 h1ad7b7a_0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "82ff6b6e52f4e937b03f046c930c97fc", + "name": "curl", + "sha256": "d2f7aceca495da50e779032200c00bfd21065942dbdcc205b87819e660e5b09f", + "size": 139167, + "subdir": "linux-64", + "timestamp": 1516812887930, + "version": "7.57.0" + }, + "curl-7.58.0-h84994c4_0.tar.bz2": { + "build": "h84994c4_0", + "build_number": 0, + "depends": [ + "libcurl 7.58.0 h1ad7b7a_0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "ebd6b4278a8a5c944f0a4b18b8e27f1d", + "name": "curl", + "sha256": "534a2b60745ba078a6d603367d7154ee92a1989aa4ac2014fa7177386b5fc638", + "size": 140536, + "subdir": "linux-64", + "timestamp": 1517284621373, + "version": "7.58.0" + }, + "curl-7.59.0-h84994c4_0.tar.bz2": { + "build": "h84994c4_0", + "build_number": 0, + "depends": [ + "libcurl 7.59.0 h1ad7b7a_0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "b4bd69f07ed15d54983a6a2f6dd2e003", + "name": "curl", + "sha256": "7eac58f5a226b06da55092885bdd30ef2e9adbf4320692d44ce8d9e09610a7ec", + "size": 142872, + "subdir": "linux-64", + "timestamp": 1522272211662, + "version": "7.59.0" + }, + "curl-7.60.0-h84994c4_0.tar.bz2": { + "build": "h84994c4_0", + "build_number": 0, + "depends": [ + "libcurl 7.60.0 h1ad7b7a_0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "6a44b75ae0e349c4efe4b2d36d7c3635", + "name": "curl", + "sha256": "8d86dbc082ea00b4aa75844e76228936dc06cb4de3b1693dc06e62bfb243ce0f", + "size": 143622, + "subdir": "linux-64", + "timestamp": 1527109707199, + "version": "7.60.0" + }, + "curl-7.61.0-h84994c4_0.tar.bz2": { + "build": "h84994c4_0", + "build_number": 0, + "depends": [ + "libcurl 7.61.0 h1ad7b7a_0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "922a1933cfe8b23f4025b9aeec54ff2c", + "name": "curl", + "sha256": "b3de17e67d9e00befe475f3e17c783f176d1c1a0da12131b36802c0687cb5fcd", + "size": 144725, + "subdir": "linux-64", + "timestamp": 1532525690875, + "version": "7.61.0" + }, + "curl-7.61.1-hbc83047_0.tar.bz2": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "libcurl 7.61.1 h20c2e04_0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "b7c9eaa15860a5f96c275b1df9bc7e87", + "name": "curl", + "sha256": "2589e4b490defcfc1d47ec8bf2cbbe5c31d336dbb200d3b10f92358dab88e7ea", + "size": 149258, + "subdir": "linux-64", + "timestamp": 1539968321625, + "version": "7.61.1" + }, + "curl-7.62.0-hbc83047_0.tar.bz2": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "libcurl 7.62.0 h20c2e04_0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "639608e9f44c03efbeb31622794b4382", + "name": "curl", + "sha256": "fa7ab11b879f9c956de025f5c3892b29afc001b36b623a1f8d72636eb36deb33", + "size": 146189, + "subdir": "linux-64", + "timestamp": 1541435356254, + "version": "7.62.0" + }, + "curl-7.63.0-hbc83047_0.tar.bz2": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libcurl 7.63.0 h20c2e04_0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.0,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "c3257bdb39a9d38e7f78bda0c856a4d3", + "name": "curl", + "sha256": "2a8d92ab7b73230936a7a3d4f9551ded43426722d46a6b1c4e483e836c04677c", + "size": 154510, + "subdir": "linux-64", + "timestamp": 1547225810222, + "version": "7.63.0" + }, + "curl-7.63.0-hbc83047_1000.tar.bz2": { + "build": "hbc83047_1000", + "build_number": 1000, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libcurl 7.63.0 h20c2e04_1000", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.0,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "b67dd21e6e1856c845215281d7c32f04", + "name": "curl", + "sha256": "cf68638f57a7376beb4cce172023646b013551fcd96d49c7eb8919260bfd3ae2", + "size": 148513, + "subdir": "linux-64", + "timestamp": 1545106038460, + "version": "7.63.0" + }, + "curl-7.64.0-hbc83047_2.tar.bz2": { + "build": "hbc83047_2", + "build_number": 2, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libcurl 7.64.0 h20c2e04_2", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.0,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "f063e0d2178d8f6f23f6021dd2a7b404", + "name": "curl", + "sha256": "9839a2df5eb864ef8dc279b0509903a3b113340d13a905bcced3924a3dde4ddf", + "size": 155708, + "subdir": "linux-64", + "timestamp": 1552411764756, + "version": "7.64.0" + }, + "curl-7.64.1-hbc83047_0.tar.bz2": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libcurl 7.64.1 h20c2e04_0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "0939b759f845a9ae652b9ce16e739f05", + "name": "curl", + "sha256": "34b5af4888617ca8aa695a1acd6ef383b9068e954a4af29b3266c6f8944aeb14", + "size": 140858, + "subdir": "linux-64", + "timestamp": 1556031965527, + "version": "7.64.1" + }, + "curl-7.65.2-hbc83047_0.tar.bz2": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libcurl 7.65.2 h20c2e04_0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "c02809cef155778fafb0910fb82668d7", + "name": "curl", + "sha256": "3949bd2aedaf23de390d1514c3a650f25fcbb3bc35017a045b3983e039414c92", + "size": 144465, + "subdir": "linux-64", + "timestamp": 1563398725979, + "version": "7.65.2" + }, + "curl-7.65.3-hbc83047_0.tar.bz2": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libcurl 7.65.3 h20c2e04_0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "2c1dbe7f877cddfe530107d613af8eee", + "name": "curl", + "sha256": "e3f94d793db0f827aa5ba76c4ad1f15e77c70362e5ffee4f70a02436d9f7602a", + "size": 144717, + "subdir": "linux-64", + "timestamp": 1566828859652, + "version": "7.65.3" + }, + "curl-7.67.0-hbc83047_0.tar.bz2": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libcurl 7.67.0 h20c2e04_0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "d0c144879461c524c98200df3ccbe05b", + "name": "curl", + "sha256": "af90b39e746c7e28744f5ef307faf4bf309da6b97d501d5e6bed82953a0a85ac", + "size": 148197, + "subdir": "linux-64", + "timestamp": 1574273454929, + "version": "7.67.0" + }, + "curl-7.68.0-hbc83047_0.tar.bz2": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "krb5 >=1.17.1,<1.18.0a0", + "libcurl 7.68.0 h20c2e04_0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "316495e18d6e6e0275d66dcf771ac10d", + "name": "curl", + "sha256": "4f8d715a34bd49f80d15f73a64e0fd588e50a1c03ecd75dbf27bd73848d51d05", + "size": 149843, + "subdir": "linux-64", + "timestamp": 1580837350356, + "version": "7.68.0" + }, + "curl-7.69.1-hbc83047_0.tar.bz2": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "krb5 >=1.17.1,<1.18.0a0", + "libcurl 7.69.1 h20c2e04_0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.9.0,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "06d86d36a0281aa534ad419bccba44a7", + "name": "curl", + "sha256": "cf0b3622c8a703a8da2a2578f50d15929e27f7f408d4c0b8e41588d36010d7fa", + "size": 151344, + "subdir": "linux-64", + "timestamp": 1584460908322, + "version": "7.69.1" + }, + "curl-7.71.0-hbc83047_0.tar.bz2": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libcurl 7.71.0 h20c2e04_0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.9.0,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "841a7337786b47d7e7bfffce63b5915f", + "name": "curl", + "sha256": "30f8e5b11a1237945ac149a76b5b404ba6ea944be6ac5da7c98b1afd822c1e62", + "size": 153794, + "subdir": "linux-64", + "timestamp": 1593438205057, + "version": "7.71.0" + }, + "curl-7.71.1-h8f29fe8_2.tar.bz2": { + "build": "h8f29fe8_2", + "build_number": 2, + "depends": [ + "libcurl 7.71.1 h303737a_2", + "libgcc-ng >=7.3.0", + "libssh2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "de1c1587cd99e26241247a6a24431af6", + "name": "curl", + "sha256": "cc33a294d9fba72b666213da21ae7ff8a63628aa28ab1bdb5d908f4599480f89", + "size": 154731, + "subdir": "linux-64", + "timestamp": 1621648770299, + "version": "7.71.1" + }, + "curl-7.71.1-hbc83047_1.tar.bz2": { + "build": "hbc83047_1", + "build_number": 1, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libcurl 7.71.1 h20c2e04_1", + "libgcc-ng >=7.3.0", + "libssh2 >=1.9.0,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "db4659eb6f9ba5db58170a9445bd22ee", + "name": "curl", + "sha256": "3fc03f639e79ea01b358a9c6a8773fd0df0f571977ed5209b9ee309bb6b264d0", + "size": 154633, + "subdir": "linux-64", + "timestamp": 1594834910415, + "version": "7.71.1" + }, + "curl-7.78.0-h1ccaba5_0.tar.bz2": { + "build": "h1ccaba5_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libcurl 7.78.0 h0b77cf5_0", + "libgcc-ng >=7.5.0", + "libssh2 >=1.9.0,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "4669b892662d383d8732b1e49fa234d7", + "name": "curl", + "sha256": "2acdd35f1f556489029e31e5f8769e6077832a549b927db6c4c209b60aaa40c2", + "size": 100731, + "subdir": "linux-64", + "timestamp": 1628797021055, + "version": "7.78.0" + }, + "curl-7.80.0-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libcurl 7.80.0 h0b77cf5_0", + "libgcc-ng >=7.5.0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "53a1c8f5c8dd014b1920d1a86f0e8155", + "name": "curl", + "sha256": "ee573dd8fcfbe6b5aed34c4ff73b4d58aa885097c21e6782b53636145d8e5558", + "size": 101757, + "subdir": "linux-64", + "timestamp": 1639143833802, + "version": "7.80.0" + }, + "curl-7.82.0-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libcurl 7.82.0 h0b77cf5_0", + "libgcc-ng >=7.5.0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "412fb1f9d310969821ce52adffaf80c7", + "name": "curl", + "sha256": "f86745816a0abd3f9918777e3dd25e212b808cb21f1f769dbe1a417fdd34c294", + "size": 102483, + "subdir": "linux-64", + "timestamp": 1649731358187, + "version": "7.82.0" + }, + "curl-7.83.0-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libcurl 7.83.0 h0b77cf5_0", + "libgcc-ng >=7.5.0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "6f5308121830f8df0bf7292c167f36fc", + "name": "curl", + "sha256": "441237d4cab4c76235c1dc91eb1eef56ebdbd32c84faee8fd8b51283345189f4", + "size": 90884, + "subdir": "linux-64", + "timestamp": 1652189680921, + "version": "7.83.0" + }, + "curl-7.84.0-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libcurl 7.84.0 h91b91d3_0", + "libgcc-ng >=11.2.0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "8e227be6ade98ae6572c9f23d7b34f35", + "name": "curl", + "sha256": "28b7930de8e7dfbc2d8897306b2ffc83b613a3d6b9272b32d39b75f5c058e0f6", + "size": 85170, + "subdir": "linux-64", + "timestamp": 1659041696676, + "version": "7.84.0" + }, + "curl-7.85.0-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libcurl 7.85.0 h91b91d3_0", + "libgcc-ng >=11.2.0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "1c157288c63c280073e3c8e38df70a97", + "name": "curl", + "sha256": "a90ea1fa285231d2d7d3ab805656fa73d79e62017213f99208ecb2aee2f0c212", + "size": 84817, + "subdir": "linux-64", + "timestamp": 1666683424268, + "version": "7.85.0" + }, + "curl-7.86.0-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libcurl 7.86.0 h91b91d3_0", + "libgcc-ng >=11.2.0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "71609e9ef3df7c3e3fbb607991070c09", + "name": "curl", + "sha256": "57758e68ca9d774831b2df6990ce179d6ac031f2ade3f8fdc5cd101ab51eeb6c", + "size": 84892, + "subdir": "linux-64", + "timestamp": 1669738519087, + "version": "7.86.0" + }, + "curl-7.87.0-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libcurl 7.87.0 h91b91d3_0", + "libgcc-ng >=11.2.0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "5ad4785aac77b82d125a484da8b87d13", + "name": "curl", + "sha256": "e6f0793b429156f2c54c7a9fdfdcbe5166ac7d0bcf7fea611f257b5afd7eef0c", + "size": 85435, + "subdir": "linux-64", + "timestamp": 1674234310318, + "version": "7.87.0" + }, + "curl-7.88.1-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libcurl 7.88.1 h91b91d3_0", + "libgcc-ng >=11.2.0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "846188cf20f81418c8e8bde5baebb750", + "name": "curl", + "sha256": "c80682d3ecbbce98d5ee3168e95916b68f887f5f5b55a60921380813296a8d78", + "size": 86013, + "subdir": "linux-64", + "timestamp": 1678377847425, + "version": "7.88.1" + }, + "curtsies-0.3.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "blessings >=1.5", + "python >=3.10,<3.11.0a0", + "wcwidth >=0.1.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa50240d551b2cec0181cf63f5be4879", + "name": "curtsies", + "sha256": "272a2d16c8481e929cdd0ca2bac25f672087e133908d8e414fb92793a61848f3", + "size": 61747, + "subdir": "linux-64", + "timestamp": 1640808892361, + "version": "0.3.4" + }, + "curtsies-0.3.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "blessings >=1.5", + "python >=3.11,<3.12.0a0", + "wcwidth >=0.1.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c9909cd8ea0af04fcbe8a17650545d3", + "name": "curtsies", + "sha256": "11b851a42e5d5217a9eca582260b239746a42e50e9b4b4e29ff1ff58f0011ffe", + "size": 83003, + "subdir": "linux-64", + "timestamp": 1676843687740, + "version": "0.3.4" + }, + "curtsies-0.3.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "blessings >=1.5", + "python >=3.6,<3.7.0a0", + "wcwidth >=0.1.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ab1061e3beb973825d4c2f77e642e6f", + "name": "curtsies", + "sha256": "7260e732c1dfcd294a1978959f54bbb387384af7374f970e3fb20ad8974c7a53", + "size": 63435, + "subdir": "linux-64", + "timestamp": 1598664644537, + "version": "0.3.4" + }, + "curtsies-0.3.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "blessings >=1.5", + "python >=3.6,<3.7.0a0", + "wcwidth >=0.1.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c468910f20e4cd96499b34bbd3f4acdb", + "name": "curtsies", + "sha256": "892b148f94517d5b4a6f600bfb536e7d40db852e6e6d666242b10612ecd310b1", + "size": 63492, + "subdir": "linux-64", + "timestamp": 1614257628123, + "version": "0.3.4" + }, + "curtsies-0.3.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "blessings >=1.5", + "python >=3.7,<3.8.0a0", + "wcwidth >=0.1.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab0b45472515a3a55b91ddafa607b30c", + "name": "curtsies", + "sha256": "90c06354a2eef11961b2211820a69168c41c3d12a8e4d0418227ff4a3becac67", + "size": 63060, + "subdir": "linux-64", + "timestamp": 1598664641802, + "version": "0.3.4" + }, + "curtsies-0.3.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "blessings >=1.5", + "python >=3.7,<3.8.0a0", + "wcwidth >=0.1.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2909da1128ea943f26d15e540c502916", + "name": "curtsies", + "sha256": "6f88e9a13e6d12c6749cf4d5805b506691044883cc5980e65a43698ac3ef1ad6", + "size": 63122, + "subdir": "linux-64", + "timestamp": 1614257625390, + "version": "0.3.4" + }, + "curtsies-0.3.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "blessings >=1.5", + "python >=3.8,<3.9.0a0", + "wcwidth >=0.1.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5cfcbcc5e5778d9b5f8ca9d111f51312", + "name": "curtsies", + "sha256": "ebae7c8421a570fc9f5ed22dbe0af5d25adf06f3cb4df0255b15921f5447325f", + "size": 63161, + "subdir": "linux-64", + "timestamp": 1598664685187, + "version": "0.3.4" + }, + "curtsies-0.3.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "blessings >=1.5", + "python >=3.8,<3.9.0a0", + "wcwidth >=0.1.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49da2c0aeb0381d0ca1d57dfb83612f3", + "name": "curtsies", + "sha256": "acc30afcbe0fa0fcecd0cb6b6eaa7ec21a1506e9398e92c70671b2caac7518da", + "size": 63234, + "subdir": "linux-64", + "timestamp": 1614256625377, + "version": "0.3.4" + }, + "curtsies-0.3.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "blessings >=1.5", + "python >=3.9,<3.10.0a0", + "wcwidth >=0.1.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e64785220d07faea2474c57340e2fbba", + "name": "curtsies", + "sha256": "222150ca053c594e0c7c9769cb786e0c869dc67c99f2fc0abe87482eb96b0206", + "size": 63003, + "subdir": "linux-64", + "timestamp": 1614257640156, + "version": "0.3.4" + }, + "cvxcanon-0.1.1-py27h04863e7_0.tar.bz2": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "f4d907e32d4b822b39060c62aa87b4ab", + "name": "cvxcanon", + "sha256": "915724783e49ce120df670eb7e83ed8a0174a7a5cc4d0c03a17e94b2d2731e36", + "size": 215433, + "subdir": "linux-64", + "timestamp": 1530814434842, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py27h91e6341_0.tar.bz2": { + "build": "py27h91e6341_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "e6a287a678e375196152f0cc893e97d1", + "name": "cvxcanon", + "sha256": "946c1bfc643af547e532befbe6d71dfc21143747682171d646386746e2e6d943", + "size": 216429, + "subdir": "linux-64", + "timestamp": 1507617127900, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py310h00e6091_0.tar.bz2": { + "build": "py310h00e6091_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy", + "python >=3.10,<3.11.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "a3fd47c07bba82763463e756f471b747", + "name": "cvxcanon", + "sha256": "194cb1a1e75b7d7211028761b2a3ff891ac37e8e3bf22b608a2ad63f96971bf2", + "size": 1605028, + "subdir": "linux-64", + "timestamp": 1640808933873, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py311hba01205_0.tar.bz2": { + "build": "py311hba01205_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.11,<3.12.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "6c586bf16f84e9a47a1931a44397c420", + "name": "cvxcanon", + "sha256": "6708ac53d70ed750d972772c257339a6928bc0a888f93be27cf085c230a2c7f3", + "size": 226468, + "subdir": "linux-64", + "timestamp": 1676907089019, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py35h04863e7_0.tar.bz2": { + "build": "py35h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "fbe4f0c75baa87823999d13747837b5e", + "name": "cvxcanon", + "sha256": "10cff3067964d669eaf481b96cc300c70a776e48f186ab39bfe25ea428fa6c2f", + "size": 220013, + "subdir": "linux-64", + "timestamp": 1535130324236, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py35h9a30ffc_0.tar.bz2": { + "build": "py35h9a30ffc_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "46c9e988062f5f10589a6ed2e530ed9c", + "name": "cvxcanon", + "sha256": "1f2b6f30fbb19e99cccf347f3efa7b1d03f84f5acb8175f3203612c200a2185d", + "size": 216947, + "subdir": "linux-64", + "timestamp": 1507617409597, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py36h04863e7_0.tar.bz2": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "01eda22e97d7400842af7b3e8ce9e9e7", + "name": "cvxcanon", + "sha256": "f8008c36ef944bca32455dd2b80a9fedb649b7ac94a9e4e6999a667ba9a64626", + "size": 215785, + "subdir": "linux-64", + "timestamp": 1530814535713, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "4a0ee7c1d800c2817510984cdb65af2f", + "name": "cvxcanon", + "sha256": "9b60c0d914202e0961950c30751f8ceb2a6974672ede7204ec19fe2def03291a", + "size": 391822, + "subdir": "linux-64", + "timestamp": 1592214891729, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py36h7353a8a_0.tar.bz2": { + "build": "py36h7353a8a_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "fa97bf14ddd8b8b3a9b9806577513044", + "name": "cvxcanon", + "sha256": "183226ee4bd4f859b437afbfd63efad4f85814531a31bf53ac21cf0cfb842fdb", + "size": 216812, + "subdir": "linux-64", + "timestamp": 1507617482779, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py36ha9443f7_0.tar.bz2": { + "build": "py36ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "ade50560b61a6377c5c178fb13d9234f", + "name": "cvxcanon", + "sha256": "990b8163afeca87bbea936fab3cf01ef741a652c76e85ef410b3694018fe4d24", + "size": 449643, + "subdir": "linux-64", + "timestamp": 1614265298725, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py37h04863e7_0.tar.bz2": { + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "bab901a8b1a42c8612e1c665c18a9526", + "name": "cvxcanon", + "sha256": "da610db4627c1fb2012c65c64c6b3a22d430eb3fd12ee716b288dfeca88457a3", + "size": 215770, + "subdir": "linux-64", + "timestamp": 1530814484783, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "df4f6effc2dfc1d0edac833349884c12", + "name": "cvxcanon", + "sha256": "756c7ce342dc280d22bddc64056c52947f465420db22b6fd73a8b5be0007e552", + "size": 391787, + "subdir": "linux-64", + "timestamp": 1592214867939, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py37ha9443f7_0.tar.bz2": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "7d9d6aa3b0fdd13bcf38085e8b09a0be", + "name": "cvxcanon", + "sha256": "b2b4e66427ae47862fbd1c00d0970d5e92a8ce9963ebe802312eff38c3b550f8", + "size": 449690, + "subdir": "linux-64", + "timestamp": 1614265270454, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "d309eadda03b6a5f5ec428dbc639dbdf", + "name": "cvxcanon", + "sha256": "6e436217a5dfc8af6664811dc21e64a2f9881ed4558dc9320f3b79cf854c592b", + "size": 393967, + "subdir": "linux-64", + "timestamp": 1592214691530, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py38ha9443f7_0.tar.bz2": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "16fbdafc0699a967d6b4c4b6936491a7", + "name": "cvxcanon", + "sha256": "95d537f180dfb7339ab38dab6c1c8e387349dcc2b7df51ac0f7a8981720cf5aa", + "size": 443247, + "subdir": "linux-64", + "timestamp": 1614265027423, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py39ha9443f7_0.tar.bz2": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.9,<3.10.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "bd8a680ef770c93beac8dbc6316cab3a", + "name": "cvxcanon", + "sha256": "151953300ec579774b00e9c02f7d54343f58c4d54cf443b2a986b3c08ce09f17", + "size": 443890, + "subdir": "linux-64", + "timestamp": 1614265278475, + "version": "0.1.1" + }, + "cvxopt-1.2.0-py27h2c4e229_0.tar.bz2": { + "build": "py27h2c4e229_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "fftw >=3.3.8,<4.0a0", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "2dd176c6b73c4f43a9cbfc5ca4a7eedf", + "name": "cvxopt", + "sha256": "2f98b4b3f9a24f863d7f99e37a477d19a81fda479dd7f21880898ed22f6277bf", + "size": 546383, + "subdir": "linux-64", + "timestamp": 1528997805128, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py27h75fe3a5_0.tar.bz2": { + "build": "py27h75fe3a5_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.8,<3.4.0a0", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "a09c5fa171b674f2b55cde1f27d7590b", + "name": "cvxopt", + "sha256": "ab227529565473048da4917f9e520ba638348eb28dbba63e31d1eb76e1f5751a", + "size": 548699, + "subdir": "linux-64", + "timestamp": 1550695564878, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py27h9e0dedd_0.tar.bz2": { + "build": "py27h9e0dedd_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "3f50eb29efaf4ea551d27676c6828fd1", + "name": "cvxopt", + "sha256": "f27d9e9cf0416cd56c5674987499ac1aa3f281e47820c8477403eed6c27b4cee", + "size": 546460, + "subdir": "linux-64", + "timestamp": 1528997861621, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py27hfa32c7d_0.tar.bz2": { + "build": "py27hfa32c7d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "34990369b75b251d07f3615be75e000d", + "name": "cvxopt", + "sha256": "d3463a03b4dc023999c30b77925827b7dfb65132136bf86e610d22a4af35f089", + "size": 552551, + "subdir": "linux-64", + "timestamp": 1550695674832, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py35h2c4e229_0.tar.bz2": { + "build": "py35h2c4e229_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "fftw >=3.3.8,<4.0a0", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "ec1cf9474a6bb6378008b55441a7948b", + "name": "cvxopt", + "sha256": "9a608b352dac495e82fbe84cd55d314937c83f8df38fe8dc209524aeedc1a9c3", + "size": 550623, + "subdir": "linux-64", + "timestamp": 1528997796153, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py35h9e0dedd_0.tar.bz2": { + "build": "py35h9e0dedd_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "b40e3d42d57b4a7c78616dcff891bfe5", + "name": "cvxopt", + "sha256": "5a66d5a7dfcc467619b34ceaedaac19f3f7c413827795d072ae975e41d780550", + "size": 550682, + "subdir": "linux-64", + "timestamp": 1528997794733, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py36h2c4e229_0.tar.bz2": { + "build": "py36h2c4e229_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "fftw >=3.3.8,<4.0a0", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "17601297442075294934c0cabb7b4d1f", + "name": "cvxopt", + "sha256": "c1cdc8d2b7d5536d1700684dcb3f2cee19901f27defd5bef36ef26936588afd5", + "size": 551644, + "subdir": "linux-64", + "timestamp": 1528997706614, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py36h75fe3a5_0.tar.bz2": { + "build": "py36h75fe3a5_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.8,<3.4.0a0", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "6776b8f7da4b5e5cdee9bf4cd2b44fce", + "name": "cvxopt", + "sha256": "a6dd8889352244ba0ba1e79e27a589f240956c55fae2d9f496dcfa736bdd158e", + "size": 559657, + "subdir": "linux-64", + "timestamp": 1550695610377, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py36h9e0dedd_0.tar.bz2": { + "build": "py36h9e0dedd_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "ee32739317a41536ce7cbfbb8210e508", + "name": "cvxopt", + "sha256": "8c412ed810f7e8e06238f2bc7e03fbffc0494ae00b13a8e7cc35d0dc5dd02d14", + "size": 550274, + "subdir": "linux-64", + "timestamp": 1528997415906, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py36ha87f1a5_0.tar.bz2": { + "build": "py36ha87f1a5_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "ea313e42a754d27b534caeb107cc1ab6", + "name": "cvxopt", + "sha256": "bf5c87cccaed3bacaf81238b7f558002fbfd17b77f2bfa6bf873b6c6d9596043", + "size": 557095, + "subdir": "linux-64", + "timestamp": 1614267875686, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py36hfa32c7d_0.tar.bz2": { + "build": "py36hfa32c7d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "8cea30eecbb49a4efbb01972cf5e719b", + "name": "cvxopt", + "sha256": "8a9c1a2c8bea0c335f30f3ea3c5a531749429c57532b02386df730652e1e8df9", + "size": 547268, + "subdir": "linux-64", + "timestamp": 1550695714448, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py37h75fe3a5_0.tar.bz2": { + "build": "py37h75fe3a5_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.8,<3.4.0a0", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "8cf0772c6fdffa1e6f7d0dd68d57bab9", + "name": "cvxopt", + "sha256": "fdf42f10a96e333565c1beafae944b311859078bbcb405497e3777960ec2a39e", + "size": 543615, + "subdir": "linux-64", + "timestamp": 1550699270665, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py37ha87f1a5_0.tar.bz2": { + "build": "py37ha87f1a5_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "0b7fed6ccdda7e64f5bd105f72aa52b8", + "name": "cvxopt", + "sha256": "88a1958b27be4a5cea08a65d495a240a8c353de4d32bb62f09648d97b54de7ae", + "size": 542483, + "subdir": "linux-64", + "timestamp": 1614266845022, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py37hfa32c7d_0.tar.bz2": { + "build": "py37hfa32c7d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "8e8c3071b49549544dfd6d887dedf52b", + "name": "cvxopt", + "sha256": "069221b2aee2be09334af9ec8c1bf6a177d432511e72746ed088b31b737622de", + "size": 537449, + "subdir": "linux-64", + "timestamp": 1550695709172, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py38h75fe3a5_0.tar.bz2": { + "build": "py38h75fe3a5_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.8,<3.4.0a0", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "bc912ddbf3477ae93ec78c6a6bff03b8", + "name": "cvxopt", + "sha256": "2fdf933aa0a4f7088a5e958e44ad7f2fdac2cdc476cdd1330b175ed57fb1eff9", + "size": 563281, + "subdir": "linux-64", + "timestamp": 1573730140632, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py38ha87f1a5_0.tar.bz2": { + "build": "py38ha87f1a5_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "8760338c64ab1071e7b5bf4f265ca32e", + "name": "cvxopt", + "sha256": "e0dc69c09595c98dd897303a9f43d9b83e286418623536929f60acaa51f89e3a", + "size": 534176, + "subdir": "linux-64", + "timestamp": 1614267877834, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py38hfa32c7d_0.tar.bz2": { + "build": "py38hfa32c7d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "2b9e5a752d9bf4a5e2511013e8121103", + "name": "cvxopt", + "sha256": "d1814b5c3688c81c32f53125d3c463832e83dea1c902e2662fadcb9d3648f2da", + "size": 564051, + "subdir": "linux-64", + "timestamp": 1573730215363, + "version": "1.2.0" + }, + "cvxopt-1.2.6-py310h4077e5c_1.tar.bz2": { + "build": "py310h4077e5c_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "4e7fbb2ea5d00add12e701dbbea35e02", + "name": "cvxopt", + "sha256": "4fc96ff002167a58a08e7776ddb48d8221275e9d027344ef0adddd1bb1ca7f8a", + "size": 939092, + "subdir": "linux-64", + "timestamp": 1656076931100, + "version": "1.2.6" + }, + "cvxopt-1.2.6-py310h7aab8bc_1.tar.bz2": { + "build": "py310h7aab8bc_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.10,<3.11.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "a10711c84b687689c3716c1ec8d9fe80", + "name": "cvxopt", + "sha256": "e2e1eb60c53783e42ee1eb3b4a46b70d0d598ebf5127f4ff3d9792a992137853", + "size": 939052, + "subdir": "linux-64", + "timestamp": 1656077129942, + "version": "1.2.6" + }, + "cvxopt-1.2.6-py310he715372_0.tar.bz2": { + "build": "py310he715372_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.10,<3.11.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "a5b0591b6daf51f965a1ef2df8274ebc", + "name": "cvxopt", + "sha256": "871b187a4939890c835133c8c171e23c247387319e70ea8b6bfbc0cfd508d1c1", + "size": 882592, + "subdir": "linux-64", + "timestamp": 1641894686585, + "version": "1.2.6" + }, + "cvxopt-1.2.6-py311h7aab8bc_0.tar.bz2": { + "build": "py311h7aab8bc_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.11,<3.12.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "5438ae5cdc6e522160f74491a7cf9e39", + "name": "cvxopt", + "sha256": "f1e975081ea51a76fa3a73932ebdb72ab6fd2761b6bf8522fc8d28597dd1fe3d", + "size": 608484, + "subdir": "linux-64", + "timestamp": 1677034706748, + "version": "1.2.6" + }, + "cvxopt-1.2.6-py37h4077e5c_1.tar.bz2": { + "build": "py37h4077e5c_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "94df85f75ed8c31cefd00f683ac3eb77", + "name": "cvxopt", + "sha256": "d76df8e0eb5a59130bcb6ba94c21aebd89b86a1952849275a55e5780e798aaf8", + "size": 536498, + "subdir": "linux-64", + "timestamp": 1656076873547, + "version": "1.2.6" + }, + "cvxopt-1.2.6-py37h7aab8bc_1.tar.bz2": { + "build": "py37h7aab8bc_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.7,<3.8.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "d57cbea239484139c686cf500629c162", + "name": "cvxopt", + "sha256": "9b44a1c70aeae7428c4526a42417b4801a4ab67a5019cb6529d8d532794077cf", + "size": 536661, + "subdir": "linux-64", + "timestamp": 1656077076763, + "version": "1.2.6" + }, + "cvxopt-1.2.6-py38h4077e5c_1.tar.bz2": { + "build": "py38h4077e5c_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "1c3888745cb32c246611a9c24d569c49", + "name": "cvxopt", + "sha256": "51948635bba9a886eb1d9dd6033428c698bd607622de234e3f6126aebcaec12e", + "size": 538430, + "subdir": "linux-64", + "timestamp": 1656076976380, + "version": "1.2.6" + }, + "cvxopt-1.2.6-py38h7aab8bc_1.tar.bz2": { + "build": "py38h7aab8bc_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.8,<3.9.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "ae572631eb7f2d941ad00c33571c114f", + "name": "cvxopt", + "sha256": "4de1274143ee4baf5f0106d80ffe6876e0f0937f2e3e5ee18567bd147e2e45a6", + "size": 538422, + "subdir": "linux-64", + "timestamp": 1656077184392, + "version": "1.2.6" + }, + "cvxopt-1.2.6-py39h4077e5c_1.tar.bz2": { + "build": "py39h4077e5c_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "482bc9f6fc497d47b1555c369add71c4", + "name": "cvxopt", + "sha256": "4e43f5427f86c96576b68a2022c9534da7ca45dff50d53bea28bd0026fdea478", + "size": 537471, + "subdir": "linux-64", + "timestamp": 1656077031143, + "version": "1.2.6" + }, + "cvxopt-1.2.6-py39h7aab8bc_1.tar.bz2": { + "build": "py39h7aab8bc_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.9,<3.10.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "ec10d9409138bc0de0673bc2964de12b", + "name": "cvxopt", + "sha256": "5f645466d6d0adb3acb2724727015f2c9d64aa9407e9bc7fa5f9c9c5f0d9c080", + "size": 537352, + "subdir": "linux-64", + "timestamp": 1656077229397, + "version": "1.2.6" + }, + "cvxopt-1.3.0-py310h7aab8bc_0.tar.bz2": { + "build": "py310h7aab8bc_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.10,<3.11.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "482985849fcafed4cd3a1038a93ec368", + "name": "cvxopt", + "sha256": "d652d43843ff7863ddc51360967bb880c407da86e3c81f8535ed510362d52089", + "size": 567721, + "subdir": "linux-64", + "timestamp": 1677700998831, + "version": "1.3.0" + }, + "cvxopt-1.3.0-py311h7aab8bc_0.tar.bz2": { + "build": "py311h7aab8bc_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.11,<3.12.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "c797d985d1057b78451da1ced31e64aa", + "name": "cvxopt", + "sha256": "3cdb36019fcb9341d8da472d95d8a052f3ad0e3fa023b09dee77a92253dd264a", + "size": 616596, + "subdir": "linux-64", + "timestamp": 1677271547787, + "version": "1.3.0" + }, + "cvxopt-1.3.0-py38h7aab8bc_0.tar.bz2": { + "build": "py38h7aab8bc_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.8,<3.9.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "31f0c45e319b33a26d55d5b6dc37e660", + "name": "cvxopt", + "sha256": "a5bab0315d36fad86c2db8d642038695c6e8737408eab11131c139449c7349c6", + "size": 566167, + "subdir": "linux-64", + "timestamp": 1677701050385, + "version": "1.3.0" + }, + "cvxopt-1.3.0-py39h7aab8bc_0.tar.bz2": { + "build": "py39h7aab8bc_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.9,<3.10.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "a40a7f98391697435f20d31ff7a9ecb7", + "name": "cvxopt", + "sha256": "58276f59ff1740b2835ca23a04d08605464440115758ba4cddfff620469b2a50", + "size": 556473, + "subdir": "linux-64", + "timestamp": 1677700947275, + "version": "1.3.0" + }, + "cx_oracle-6.0.3-py27hc82e58e_0.tar.bz2": { + "build": "py27hc82e58e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "a4055bfd1d87b4515e308acd60e6da2a", + "name": "cx_oracle", + "sha256": "6ad0dac5f6b5715e64816b72a2beee8809cf8cc50569616b03f164da9b9e81ba", + "size": 137248, + "subdir": "linux-64", + "timestamp": 1511813842245, + "version": "6.0.3" + }, + "cx_oracle-6.0.3-py35h7bef0a5_0.tar.bz2": { + "build": "py35h7bef0a5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "64f03f6bf0e150ee8aa9ac7cf82f2ff7", + "name": "cx_oracle", + "sha256": "3708febda3c83291955bbad4d774ddbedd11234fe35b69c4dfd5ab3998ec7788", + "size": 137222, + "subdir": "linux-64", + "timestamp": 1511813920437, + "version": "6.0.3" + }, + "cx_oracle-6.0.3-py36h16aab10_0.tar.bz2": { + "build": "py36h16aab10_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "4004444baa06944aa633cae998b6aa68", + "name": "cx_oracle", + "sha256": "4d09afd986838d2f2a06309d7c5fd77e9f558b12de196c59e210c5b4cc7efaab", + "size": 137186, + "subdir": "linux-64", + "timestamp": 1511813927226, + "version": "6.0.3" + }, + "cx_oracle-6.1-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "84405d888c30338cf0b17f55f44ff6b4", + "name": "cx_oracle", + "sha256": "bbd3f00fd026bd4da6fa6c951b446c6b492e9442956d8795012ce584f5add487", + "size": 143255, + "subdir": "linux-64", + "timestamp": 1519148355667, + "version": "6.1" + }, + "cx_oracle-6.1-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "8510ffefe8807d29f1e7aaf53b05f684", + "name": "cx_oracle", + "sha256": "6e4b7eb3a394f575e9376b130637175ec0f2ffe33eb6e90ae9a61b91fb15c6e0", + "size": 143285, + "subdir": "linux-64", + "timestamp": 1519148369455, + "version": "6.1" + }, + "cx_oracle-6.1-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "2037e8e6e3cd7cd3e54c451062e1e30a", + "name": "cx_oracle", + "sha256": "2557be8673baac6ee49406e27d4ee95b33418a531033fff658c77441de422eb9", + "size": 143245, + "subdir": "linux-64", + "timestamp": 1519148371061, + "version": "6.1" + }, + "cx_oracle-6.2.1-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "8d94489edb1d1116a925e78289f24c2b", + "name": "cx_oracle", + "sha256": "ba363c3e42ff6c7ad8c12768a424724d416e510b7ec2c3d956001a8da506ecb6", + "size": 144014, + "subdir": "linux-64", + "timestamp": 1524495337478, + "version": "6.2.1" + }, + "cx_oracle-6.2.1-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "f6e0245bf1732105eb33e8247718b122", + "name": "cx_oracle", + "sha256": "020a0b8c1d1c66763c97418a305e4fb2f84223733e3957e9d301baac538bdb81", + "size": 144095, + "subdir": "linux-64", + "timestamp": 1524495453461, + "version": "6.2.1" + }, + "cx_oracle-6.2.1-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "a6b8675e57ed788e6559e932dc549f52", + "name": "cx_oracle", + "sha256": "2c429a6084d35e85d10441388030d1243e21e9d7f237b626277d5ebd19f11e7c", + "size": 144070, + "subdir": "linux-64", + "timestamp": 1524495340159, + "version": "6.2.1" + }, + "cx_oracle-6.3.1-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "9549b4969b4fff84b170a7cf571fc5ab", + "name": "cx_oracle", + "sha256": "97f627e9e2ab93d828ebf87439f139898270b4f9cad9e2453e8be6b494caec0a", + "size": 145311, + "subdir": "linux-64", + "timestamp": 1529240780393, + "version": "6.3.1" + }, + "cx_oracle-6.3.1-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "f23faf5ea3d53145ead3075ed974d91e", + "name": "cx_oracle", + "sha256": "f729a549e9b61c073e29ea62d2e2b9dd39b36ed9a05a986f20108a6f7d72a35f", + "size": 145348, + "subdir": "linux-64", + "timestamp": 1529240789099, + "version": "6.3.1" + }, + "cx_oracle-6.3.1-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "614c643feb7512c9d29e073f67728644", + "name": "cx_oracle", + "sha256": "7fd7260f9e33b1bccaf9c84eabeeb2ca82a7c7bebddf40379430c861a43153a0", + "size": 145296, + "subdir": "linux-64", + "timestamp": 1529240762984, + "version": "6.3.1" + }, + "cx_oracle-6.3.1-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "624e3ea3d0e90c090e199b8291ba95ad", + "name": "cx_oracle", + "sha256": "5240b0e1b7f04c5156d14c2e287b6336fb5d1998dff354850088252d32c946bd", + "size": 145260, + "subdir": "linux-64", + "timestamp": 1530814576724, + "version": "6.3.1" + }, + "cx_oracle-6.4.1-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "56e965083bf76933064ba3cb80f9f270", + "name": "cx_oracle", + "sha256": "d065db9364089e47586e39257c11345e2c13b87c63186d2aa984f3591e78f809", + "size": 147772, + "subdir": "linux-64", + "timestamp": 1532799502659, + "version": "6.4.1" + }, + "cx_oracle-6.4.1-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "6cdb6bd0d8b98acca0fc9b80430422e8", + "name": "cx_oracle", + "sha256": "d3e348f637f14db1ac36c59adcd5e2a0fcd30e4f35dc7ab61289f48494138234", + "size": 147729, + "subdir": "linux-64", + "timestamp": 1532799612934, + "version": "6.4.1" + }, + "cx_oracle-6.4.1-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "4e4100a58fd87b1686bd1f045a949f69", + "name": "cx_oracle", + "sha256": "a39cd678b7e31752e328ca1bbf683b58cf98705c03f0e5be4b8f6d3395bc648a", + "size": 147713, + "subdir": "linux-64", + "timestamp": 1532799474330, + "version": "6.4.1" + }, + "cx_oracle-6.4.1-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "e855593cbcee0a1006dbeb7163e9830b", + "name": "cx_oracle", + "sha256": "8161966a1f00a12ebc3ac7a3fcaa3c030a918e0affe36145cfebd6d6c9018006", + "size": 147720, + "subdir": "linux-64", + "timestamp": 1532799613011, + "version": "6.4.1" + }, + "cx_oracle-7.0.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "e44b85fec00d0fcdcdb0e0fe3d8a0778", + "name": "cx_oracle", + "sha256": "77d0d11dc9f672a7dcda03c92375be4ba21d464a001301c27bbb2797cf9e2ce6", + "size": 170690, + "subdir": "linux-64", + "timestamp": 1540060183587, + "version": "7.0.0" + }, + "cx_oracle-7.0.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "8e70e7abb0b9843924fc3707101b3435", + "name": "cx_oracle", + "sha256": "f756b70b491d8d30ecbecf6f4b84cc003421a4e8643f7e93ab89a574cb443dd9", + "size": 170720, + "subdir": "linux-64", + "timestamp": 1540060236427, + "version": "7.0.0" + }, + "cx_oracle-7.0.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "0ffb231d4d01234db814de588df5be86", + "name": "cx_oracle", + "sha256": "436420ccc599d7a9b8a54bd68eb6cae30de0b912c40d4272bd608f3a3817c3c0", + "size": 170757, + "subdir": "linux-64", + "timestamp": 1540060203929, + "version": "7.0.0" + }, + "cx_oracle-7.2.2-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "026fa2ff0723ee90820ae8700672ef00", + "name": "cx_oracle", + "sha256": "56c53ce24d4605209ee84dd57d0acc7892957b68d94043f591a87c5009ac0e7d", + "size": 185582, + "subdir": "linux-64", + "timestamp": 1569432348301, + "version": "7.2.2" + }, + "cx_oracle-7.2.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "95e5e138a09e1c288b33030cf7fa93fb", + "name": "cx_oracle", + "sha256": "35f6e3833ef37206fad3982a3c8dd07a05b35d7e596fa48c8f567eadc048fe29", + "size": 185537, + "subdir": "linux-64", + "timestamp": 1569432365537, + "version": "7.2.2" + }, + "cx_oracle-7.2.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "09c04e7ba4e2b51ce670e47fe4f97957", + "name": "cx_oracle", + "sha256": "fdacd6effe5613f5abb9cf5d5c8e20a0d0dea91854d111ebbdfb99687a9b34de", + "size": 185469, + "subdir": "linux-64", + "timestamp": 1569432355937, + "version": "7.2.2" + }, + "cx_oracle-7.2.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f7755fc25126a5b20bc515184fc90ba1", + "name": "cx_oracle", + "sha256": "887ff11569411055ac45896ec639e0d8e80c5611de4412e693c158f66d27fd67", + "size": 192579, + "subdir": "linux-64", + "timestamp": 1573034067429, + "version": "7.2.2" + }, + "cx_oracle-7.2.3-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ccb8b5f24e845e4e71dec5d458a30ffa", + "name": "cx_oracle", + "sha256": "cd069b7024dd810106b337b403367fd4ac758226da356ea88dc960c3b14308fc", + "size": 185989, + "subdir": "linux-64", + "timestamp": 1574367654503, + "version": "7.2.3" + }, + "cx_oracle-7.2.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "90e9d93b12276c8cbec0ea8bf268a6f2", + "name": "cx_oracle", + "sha256": "7302f6f9e0fbb89d460366a740451961b8256ee9cd0e41516c3bc669d2d0e906", + "size": 186005, + "subdir": "linux-64", + "timestamp": 1574367662634, + "version": "7.2.3" + }, + "cx_oracle-7.2.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "53d25ef677aeac2e0432edeb29a2f7d1", + "name": "cx_oracle", + "sha256": "3686350730044e87dbd775e5f72d060bfeb0f16bb934e57699cbba3a2290d920", + "size": 185953, + "subdir": "linux-64", + "timestamp": 1574367699368, + "version": "7.2.3" + }, + "cx_oracle-7.2.3-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c59bd088c0b972276f016344df69df87", + "name": "cx_oracle", + "sha256": "baf943e8511fc410810925916dc326c17bda1bb63de683e5de7c8a6e0f87aad3", + "size": 195959, + "subdir": "linux-64", + "timestamp": 1574367703668, + "version": "7.2.3" + }, + "cx_oracle-8.0.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0b55c0cd3f42b0e244c3bb141ddfc8b5", + "name": "cx_oracle", + "sha256": "7f008396506ae4e954f13c075e04a0e50100da6b804267803d848036e2fa93e4", + "size": 190846, + "subdir": "linux-64", + "timestamp": 1600355102499, + "version": "8.0.1" + }, + "cx_oracle-8.0.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c3fe5922d74e029307b094da0d3fbfd0", + "name": "cx_oracle", + "sha256": "95fd0fa802b795f4d2fae3813216b094cda453e091077447a73a18f81427c18e", + "size": 190854, + "subdir": "linux-64", + "timestamp": 1600355141837, + "version": "8.0.1" + }, + "cx_oracle-8.0.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ad01a30f7d1bd5d8341cc95e8e632da5", + "name": "cx_oracle", + "sha256": "17e4ba62b9b86e8d47527ac98fb40c8df021d27d2613a698f055b2255864eab5", + "size": 193463, + "subdir": "linux-64", + "timestamp": 1600355122846, + "version": "8.0.1" + }, + "cx_oracle-8.1.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8740395d54bac792fbacbac0688cc2b4", + "name": "cx_oracle", + "sha256": "52acedbde31a20fbb1ba7f77cacc5b5740717cad811a2fd78bd3aafe38770e36", + "size": 198355, + "subdir": "linux-64", + "timestamp": 1607534427939, + "version": "8.1.0" + }, + "cx_oracle-8.1.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "912a37ee013eec5dfa9f6647460d1b04", + "name": "cx_oracle", + "sha256": "e30da8e9459e5dee6b59f5dbf254210d636b40bdca56672a39e08fe5257421ce", + "size": 198455, + "subdir": "linux-64", + "timestamp": 1607534459777, + "version": "8.1.0" + }, + "cx_oracle-8.1.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f40d6f5dcb5d9364c1dd4fb0c8a58f7d", + "name": "cx_oracle", + "sha256": "5e37455db7ba4ae58f574edd7d47763448406c3737b2547f39c8743ab6d379bf", + "size": 201017, + "subdir": "linux-64", + "timestamp": 1607534456848, + "version": "8.1.0" + }, + "cx_oracle-8.1.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6e5c1e9df78a4d3dffc0ffcb94030c3b", + "name": "cx_oracle", + "sha256": "4ac69ca08a77c592d9d62c4b0309b5158fcf7badf5d284f48b3bb4816dbf5f6c", + "size": 200559, + "subdir": "linux-64", + "timestamp": 1607534472409, + "version": "8.1.0" + }, + "cx_oracle-8.2.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d4c3989c2c24e827d080afcb7176807c", + "name": "cx_oracle", + "sha256": "09d88b90cbe8d9a3d020740d6aaef67a1f554584b94314d99d006a8d3513e0c4", + "size": 203516, + "subdir": "linux-64", + "timestamp": 1621431799230, + "version": "8.2.0" + }, + "cx_oracle-8.2.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "92334436bda74a14de3ed5c6833436b5", + "name": "cx_oracle", + "sha256": "c939f3b3028c0425ead34133fbe71aae3dcef3033661ed6a51a4a4776492c62a", + "size": 203553, + "subdir": "linux-64", + "timestamp": 1621431804459, + "version": "8.2.0" + }, + "cx_oracle-8.2.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9e955fd694133393ac77311eb6b32ce3", + "name": "cx_oracle", + "sha256": "c7d80ba45c21307bece62b413fb75202692a23304284b2e823c01d88fe37ed7b", + "size": 205986, + "subdir": "linux-64", + "timestamp": 1621431817532, + "version": "8.2.0" + }, + "cx_oracle-8.2.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8cc33d837375a67f379b5fb366398878", + "name": "cx_oracle", + "sha256": "e355fbe87ba7aa924250a63ea79695a13f562150ddd0b8fcb9e68d80fdb65d15", + "size": 207128, + "subdir": "linux-64", + "timestamp": 1621431803087, + "version": "8.2.0" + }, + "cx_oracle-8.2.1-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "414582c5f0d337b85ed4532e84c51082", + "name": "cx_oracle", + "sha256": "f9ab460f973c0b3000d11ad6ddc267be0ed9293c302f66dc3dafe066ae234a46", + "size": 203851, + "subdir": "linux-64", + "timestamp": 1622745366851, + "version": "8.2.1" + }, + "cx_oracle-8.2.1-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c0caa01074ee3d4c0fc455c54a28a865", + "name": "cx_oracle", + "sha256": "3851de666c05158053d246130c4d3a6dd49aade6b0592fcbc385e5ea70d9a433", + "size": 203905, + "subdir": "linux-64", + "timestamp": 1622750649587, + "version": "8.2.1" + }, + "cx_oracle-8.2.1-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e68420cb8abc109bbed48cf977c63ec", + "name": "cx_oracle", + "sha256": "fa7408688c8889256cadd58cbc67906143f9bf56b1549fdc43e865419fb4ad8e", + "size": 206116, + "subdir": "linux-64", + "timestamp": 1622750209571, + "version": "8.2.1" + }, + "cx_oracle-8.2.1-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "45166e6ce466ad419c473bdd1864a54f", + "name": "cx_oracle", + "sha256": "ada668b1062b9555fb713641f9042d8a6ad49ee5e04beb649158d779b61d94d4", + "size": 206092, + "subdir": "linux-64", + "timestamp": 1622750668056, + "version": "8.2.1" + }, + "cx_oracle-8.3.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff287cce3f163e64b50add218b81257c", + "name": "cx_oracle", + "sha256": "dbe12cde13d0bfd42770f295878b36697bb38cc2a5473492cac18173905d935a", + "size": 740371, + "subdir": "linux-64", + "timestamp": 1640789293673, + "version": "8.3.0" + }, + "cx_oracle-8.3.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5d2b8ce15504ad32bc5372ddbc2b329a", + "name": "cx_oracle", + "sha256": "0fdb8e641169303f97581501c2aaf9f23b5d96c5bc073e0771e30e7183bf854c", + "size": 209905, + "subdir": "linux-64", + "timestamp": 1676851825734, + "version": "8.3.0" + }, + "cx_oracle-8.3.0-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "810bf845cea482455ee0ae0d70d2e316", + "name": "cx_oracle", + "sha256": "fa89acca4c348bf62f521853898ce3b1fba69481243efaaefca631b70582d0b3", + "size": 203865, + "subdir": "linux-64", + "timestamp": 1638439859780, + "version": "8.3.0" + }, + "cx_oracle-8.3.0-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a19a97a52ecc31692f0159d9d84838e8", + "name": "cx_oracle", + "sha256": "5da699e5ff4c1845793159e7aa0352348f9b6e175911cb8d3ecf5fed8a56e2e7", + "size": 206528, + "subdir": "linux-64", + "timestamp": 1638453097779, + "version": "8.3.0" + }, + "cx_oracle-8.3.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "40de8474d29a46a1dca5500c8d7ffb5d", + "name": "cx_oracle", + "sha256": "2df2cc3dfbc6c26e4fa09eccf044b29f39a262a1fee8c07180777cc8e62fbc4d", + "size": 206692, + "subdir": "linux-64", + "timestamp": 1638452974512, + "version": "8.3.0" + }, + "cycler-0.10.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "61307258f7e423a66bb3d3acea899e4e", + "name": "cycler", + "sha256": "e170eab2c4b1afe199f50b4d088959997f0e087851fd9cc0bb435dd016c1cb52", + "size": 13448, + "subdir": "linux-64", + "timestamp": 1530793306166, + "version": "0.10.0" + }, + "cycler-0.10.0-py27hc7354d3_0.tar.bz2": { + "build": "py27hc7354d3_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "ec8bb17195fcee3e9172934dffce97a1", + "name": "cycler", + "sha256": "75ed7e0e52ab345568e9b1a6538b1b0979924028529ea60a39079f046875a72e", + "size": 13255, + "subdir": "linux-64", + "timestamp": 1505733625213, + "version": "0.10.0" + }, + "cycler-0.10.0-py35hc4d5149_0.tar.bz2": { + "build": "py35hc4d5149_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "c46c36026b97638c3a53fb530519080b", + "name": "cycler", + "sha256": "8acd267b0a595bcafecec2e34435a75d0b296aa797326e4a5d3a5a3fc1b20d64", + "size": 13582, + "subdir": "linux-64", + "timestamp": 1505733636578, + "version": "0.10.0" + }, + "cycler-0.10.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "85e318e9f28e4ae53096c6f925357602", + "name": "cycler", + "sha256": "770ef029c36dca1d03e0208a9c14d80c7a2915e80ad929ff85a2284a71a7fd94", + "size": 13696, + "subdir": "linux-64", + "timestamp": 1530793330550, + "version": "0.10.0" + }, + "cycler-0.10.0-py36h93f1223_0.tar.bz2": { + "build": "py36h93f1223_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "0a9791db782eec74b4018ac12b825048", + "name": "cycler", + "sha256": "eeb801784593fbb769b10cef543302394c0ffeccab055d1ef45beed72d4ea01b", + "size": 13531, + "subdir": "linux-64", + "timestamp": 1505733648132, + "version": "0.10.0" + }, + "cycler-0.10.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "0c9d4b221c5e6bd4cd851218a89fc909", + "name": "cycler", + "sha256": "51ae18cd252cd88def6f0d6a04c061fda5b3e4ffcea0b4055dc98736cf6362ae", + "size": 13694, + "subdir": "linux-64", + "timestamp": 1530793355515, + "version": "0.10.0" + }, + "cycler-0.10.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "a19b7c7c595fe562ec22f2455e910486", + "name": "cycler", + "sha256": "dcc75557f17c85634d6567f221eee96e66ab4c2fc54965181d055ec5458589d0", + "size": 14188, + "subdir": "linux-64", + "timestamp": 1573741605355, + "version": "0.10.0" + }, + "cycler-0.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "88ec4d444cbee5d55f6788e03d159e27", + "name": "cycler", + "sha256": "82bbf60dbb00c2bdad06ca3e3d7e7c40a87abfd096c2b6096c8b4dd6206c1f0e", + "size": 16393, + "subdir": "linux-64", + "timestamp": 1607025525121, + "version": "0.10.0" + }, + "cymem-1.31.2-py27h6bb024c_0.tar.bz2": { + "build": "py27h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "46da48f31f2422b4631c09344bade2c2", + "name": "cymem", + "sha256": "03df8ab33c397a7551230f2f05911b695ba705bf6994ed533b43a43ac0ef7566", + "size": 26725, + "subdir": "linux-64", + "timestamp": 1530814606969, + "version": "1.31.2" + }, + "cymem-1.31.2-py35h6bb024c_0.tar.bz2": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "b289bf0500bf5828a3e123f5f076e781", + "name": "cymem", + "sha256": "ad7b1a1887126383c3832ce24fcdb2f0a6f6cc138bca68d84b253e17f8d7c2a4", + "size": 26621, + "subdir": "linux-64", + "timestamp": 1535130360011, + "version": "1.31.2" + }, + "cymem-1.31.2-py36h6bb024c_0.tar.bz2": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "41fabc5a56e1b11d75c331b3a2c786d4", + "name": "cymem", + "sha256": "10f2fabafb66ad2fbd719089a8a69de09242d5f3ec0be7fd9de58bd036c1ac33", + "size": 26585, + "subdir": "linux-64", + "timestamp": 1530814662317, + "version": "1.31.2" + }, + "cymem-1.31.2-py37h6bb024c_0.tar.bz2": { + "build": "py37h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2c34eea31cca5851b4039ddd3976f636", + "name": "cymem", + "sha256": "eac5fc27dbf1bb55aa09571710a86d5d2feeb1e2e95bea8621296a6aca07378e", + "size": 26576, + "subdir": "linux-64", + "timestamp": 1530814634441, + "version": "1.31.2" + }, + "cymem-2.0.2-py27hfd86e86_0.tar.bz2": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "54d093c59c73514ce99b7e7057da6dc6", + "name": "cymem", + "sha256": "7f6db582d7a52a8b2cac2d3c839305962f7f5a26f07fbccc1b8e0af273398bb4", + "size": 38000, + "subdir": "linux-64", + "timestamp": 1539715086687, + "version": "2.0.2" + }, + "cymem-2.0.2-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8148676f3a196a01fe38e8675ccb941e", + "name": "cymem", + "sha256": "eeb2f6d2323cea3bd03280ba9c97f12fa8fc539c49351b52368e1b739aa1cfb8", + "size": 39806, + "subdir": "linux-64", + "timestamp": 1539715088321, + "version": "2.0.2" + }, + "cymem-2.0.2-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f06a69b96ee55f32b07cb765fbaa7c44", + "name": "cymem", + "sha256": "9e9d9266655eecebfe7b039b740e39e1d171d3618d5d76107a79e1aee6dbf4ff", + "size": 39712, + "subdir": "linux-64", + "timestamp": 1539715073686, + "version": "2.0.2" + }, + "cymem-2.0.2-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "5e23dfe9577de94e34cc6d1b8408ed29", + "name": "cymem", + "sha256": "b9adf1cee5a5e217a09d7bd0f6c5abf4badc38aa9788c3cdf7a07bb84584eba6", + "size": 47959, + "subdir": "linux-64", + "timestamp": 1573658085965, + "version": "2.0.2" + }, + "cymem-2.0.3-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9495e1932557f7e039b102d78d2f1d15", + "name": "cymem", + "sha256": "47698128360da4ccdc7b09fa1fafa3b6e09bf2b832119fd05446a8baa7d9c729", + "size": 43309, + "subdir": "linux-64", + "timestamp": 1592215213715, + "version": "2.0.3" + }, + "cymem-2.0.3-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f310c6e5e99aeaad44374cff1ed12d54", + "name": "cymem", + "sha256": "a83edd4df25852a16e5d95490dc49406d712b28d0a05b5527c4ddf6d61ce5691", + "size": 43229, + "subdir": "linux-64", + "timestamp": 1592215219099, + "version": "2.0.3" + }, + "cymem-2.0.3-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "ffc80ef20792197fcb1f906d8eae6b43", + "name": "cymem", + "sha256": "800db66c46ebee1a2c3dde127a26d93ce1353d6f2adcd79f3c6aa137c8ac9b6c", + "size": 44228, + "subdir": "linux-64", + "timestamp": 1592215218391, + "version": "2.0.3" + }, + "cymem-2.0.4-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a3e78d17dc351a6ebecdabd782d52d1c", + "name": "cymem", + "sha256": "05a2875086fbbfbe5e425b17af1b0bee40fcedc7926e21f009347f018b63be75", + "size": 42767, + "subdir": "linux-64", + "timestamp": 1605062316221, + "version": "2.0.4" + }, + "cymem-2.0.4-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "9525d3633909c1906d555fd8273ac128", + "name": "cymem", + "sha256": "c875f4cd65c2362aa469069db585af6ba38b16f865f7cb20a9179dc241ad3501", + "size": 42649, + "subdir": "linux-64", + "timestamp": 1605062306210, + "version": "2.0.4" + }, + "cymem-2.0.4-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "d749914734553239fcc27d89b1a3dc72", + "name": "cymem", + "sha256": "113b29794ef2e6230cbdef3da8f8797f1266e47a0b0298f65a1b68f04bf4f4e2", + "size": 43215, + "subdir": "linux-64", + "timestamp": 1605062322984, + "version": "2.0.4" + }, + "cymem-2.0.4-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "974402d126cefd25f57affbc24139488", + "name": "cymem", + "sha256": "ea8e9da9c8e2c817a069b9875e272c64a5534c405b53c829b81419804e07a9ee", + "size": 43396, + "subdir": "linux-64", + "timestamp": 1608232731200, + "version": "2.0.4" + }, + "cymem-2.0.5-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "444f63f1fb6fe40275e465126d9695d3", + "name": "cymem", + "sha256": "640a3333f10741df2c97395ce16be9acb8f1b4469e52c7bfdd50048a6a9b97d4", + "size": 132151, + "subdir": "linux-64", + "timestamp": 1640789321641, + "version": "2.0.5" + }, + "cymem-2.0.5-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8681423c6f2fe147b430d1d7edd275b2", + "name": "cymem", + "sha256": "f25a1c90937b9b6a1ec26fb1c433f2e36ae4787b457d241b1da5bb075e562a5e", + "size": 42813, + "subdir": "linux-64", + "timestamp": 1613319308402, + "version": "2.0.5" + }, + "cymem-2.0.5-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "9fbfdfaaf5d06e580b07f309815ccfc7", + "name": "cymem", + "sha256": "5b7b5227c95d7ae106c10d21de1447e3a13b316c837704ba32c0d402eb04c663", + "size": 42668, + "subdir": "linux-64", + "timestamp": 1613319304424, + "version": "2.0.5" + }, + "cymem-2.0.5-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "f3ab167a29be4238a1eb70f4f6442332", + "name": "cymem", + "sha256": "f453b8851b6c6dee24c5daa89be91e45e7816258a483493744b4dbeda43e8d5d", + "size": 43193, + "subdir": "linux-64", + "timestamp": 1613319309884, + "version": "2.0.5" + }, + "cymem-2.0.5-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "2c4110888e4965ffb6f30a9b0734dd38", + "name": "cymem", + "sha256": "8182613e26bcd9359fb4f4afed292fcaf38f49f0fbb2f3edf128e423b4c87558", + "size": 42300, + "subdir": "linux-64", + "timestamp": 1613318777669, + "version": "2.0.5" + }, + "cymem-2.0.6-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f613b9381c10852fb8da4cd29d686667", + "name": "cymem", + "sha256": "6fe42af49d6e53d417fb2cf08255a4cfb9346e36260bdb257edf69795faf5669", + "size": 132249, + "subdir": "linux-64", + "timestamp": 1651237323534, + "version": "2.0.6" + }, + "cymem-2.0.6-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c9450d57f3ce7a2650e3cd226bc8770", + "name": "cymem", + "sha256": "c935c4e3731f227e45f33cba4512a438594117e3df11d0efdca51bda0b5a76ee", + "size": 42059, + "subdir": "linux-64", + "timestamp": 1676830403508, + "version": "2.0.6" + }, + "cymem-2.0.6-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f3747f4977238fd8c58ea7ec1379cc9", + "name": "cymem", + "sha256": "dbce20ceb53c1878a3aec6ef0e4149332cd6e74eebbf09af6a41c5e47f3dc82d", + "size": 42803, + "subdir": "linux-64", + "timestamp": 1651237385544, + "version": "2.0.6" + }, + "cymem-2.0.6-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a01dd87a3c7128b80c2c21783f5dd2f", + "name": "cymem", + "sha256": "e0877180ec2dc60c1ca6425f639e0bacb383c66d5d429f1f0009cef7e425906e", + "size": 43362, + "subdir": "linux-64", + "timestamp": 1651237354398, + "version": "2.0.6" + }, + "cymem-2.0.6-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "70bd4d03db2a162f81be04d8a8b75d05", + "name": "cymem", + "sha256": "550fccee96d8d696b5f5953dfce3d8adadd5b98cfd83e87b1adbbd7d72565215", + "size": 42546, + "subdir": "linux-64", + "timestamp": 1651237417638, + "version": "2.0.6" + }, + "cyrus-sasl-2.1.26-h1dd3434_1.tar.bz2": { + "build": "h1dd3434_1", + "build_number": 1, + "depends": [ + "krb5 1.14.*", + "libgcc-ng >=7.2.0", + "libntlm", + "openssl 1.0.*", + "openssl >=1.0.2l,<1.0.3a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "be3063a914c402b716d82301af031a04", + "name": "cyrus-sasl", + "sha256": "c11c253cbb91a264aa0ed0ed1dd7ff484006ee2477fa6054cb3a0d2ad4a58cde", + "size": 240700, + "subdir": "linux-64", + "timestamp": 1508757791220, + "version": "2.1.26" + }, + "cyrus-sasl-2.1.26-h20670df_2.tar.bz2": { + "build": "h20670df_2", + "build_number": 2, + "depends": [ + "krb5 >=1.16,<1.17.0a0", + "libgcc-ng >=7.2.0", + "libntlm >=1.4,<2.0a0", + "openssl >=1.0.2o,<1.0.3a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "36bc7b0e7426a53adf2dc997d6ca2de5", + "name": "cyrus-sasl", + "sha256": "ea099ed18b949bcf240ca054f87ce49eabf393312bbb0b8ff905df855e7bc8ab", + "size": 241040, + "subdir": "linux-64", + "timestamp": 1527024230133, + "version": "2.1.26" + }, + "cyrus-sasl-2.1.26-h20670df_3.tar.bz2": { + "build": "h20670df_3", + "build_number": 3, + "depends": [ + "krb5 >=1.16,<1.17.0a0", + "libgcc-ng >=7.2.0", + "libntlm >=1.4,<2.0a0", + "openssl >=1.0.2o,<1.0.3a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "14dc2e415531cc089f02a45aa5a3e01c", + "name": "cyrus-sasl", + "sha256": "a3193b317036245e244821b233cd60cca31d4eef07703e16e5f303cdf203d720", + "size": 247943, + "subdir": "linux-64", + "timestamp": 1527080498731, + "version": "2.1.26" + }, + "cyrus-sasl-2.1.26-h82bf5a1_4.tar.bz2": { + "build": "h82bf5a1_4", + "build_number": 4, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libdb >=6.1.26,<6.2.0a0", + "libgcc-ng >=7.3.0", + "libntlm >=1.4,<2.0a0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "725c4dc28ceea4ca3c91fb900396d0b3", + "name": "cyrus-sasl", + "sha256": "7af35d88688f5bae2a6ddcf6193434d873e50e4a07ecf53188846f4e3892a56e", + "size": 286038, + "subdir": "linux-64", + "timestamp": 1540928130125, + "version": "2.1.26" + }, + "cyrus-sasl-2.1.26-hf938e8d_3.tar.bz2": { + "build": "hf938e8d_3", + "build_number": 3, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libdb >=6.1.26,<6.2.0a0", + "libgcc-ng >=7.3.0", + "libntlm >=1.4,<2.0a0", + "openssl >=1.0.2p,<1.0.3a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "f0ef3013c4b8e4e7b2971e6e719448b4", + "name": "cyrus-sasl", + "sha256": "5876538d6ec46aab4c69201d18322fc712e8c5d6330896a0b456635345320874", + "size": 288860, + "subdir": "linux-64", + "timestamp": 1537820851034, + "version": "2.1.26" + }, + "cyrus-sasl-2.1.27-h27ad19a_7.tar.bz2": { + "build": "h27ad19a_7", + "build_number": 7, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libdb >=6.1.26,<6.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "ef707cc6b6b76fbd0af699b083d962de", + "name": "cyrus-sasl", + "sha256": "425e37ecdacfa3cb51f3ca2a5c7b87147cdf5879b25ee9f062842ea6f51b50b7", + "size": 344733, + "subdir": "linux-64", + "timestamp": 1600980700459, + "version": "2.1.27" + }, + "cyrus-sasl-2.1.27-h758a394_8.tar.bz2": { + "build": "h758a394_8", + "build_number": 8, + "depends": [ + "krb5 >=1.19.1,<1.20.0a0", + "libdb >=6.2.32,<6.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "ee171120ef9662d683aee7d57ac5373b", + "name": "cyrus-sasl", + "sha256": "4956ebc9fcc46f76df1100030757162bd0a3d473b90d1a470e2665a6d01f015e", + "size": 305611, + "subdir": "linux-64", + "timestamp": 1622292960748, + "version": "2.1.27" + }, + "cyrus-sasl-2.1.27-h9c0eb46_0.tar.bz2": { + "build": "h9c0eb46_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libntlm", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1o,<1.1.2a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "840bf284b99c4d590c73ba63a4623ed3", + "name": "cyrus-sasl", + "sha256": "787914e703227a664d4c33d4f18c0c7df2837758d3d2460a76fdf7cdd5950852", + "size": 234521, + "subdir": "linux-64", + "timestamp": 1656338245549, + "version": "2.1.27" + }, + "cyrus-sasl-2.1.27-h9c0eb46_10.tar.bz2": { + "build": "h9c0eb46_10", + "build_number": 10, + "depends": [ + "krb5 >=1.19.4,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libntlm >=1.5,<2.0a0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "58221e144edebd994e80ef109d88d512", + "name": "cyrus-sasl", + "sha256": "a2da06ba75c502cb9caff1deef8c9f6cadf59387e1f4821e5d92d56a3c24015a", + "size": 234799, + "subdir": "linux-64", + "timestamp": 1678959656304, + "version": "2.1.27" + }, + "cyrus-sasl-2.1.27-h9c0eb46_9.tar.bz2": { + "build": "h9c0eb46_9", + "build_number": 9, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libntlm", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1o,<1.1.2a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "672882701377059f2a1e350aee9846d3", + "name": "cyrus-sasl", + "sha256": "96db24934c076c304fed8e5cad35e59985385e92f3e1f31da9827e53afb4a6fe", + "size": 234483, + "subdir": "linux-64", + "timestamp": 1656338742293, + "version": "2.1.27" + }, + "cyrus-sasl-2.1.27-hf484d3e_7.tar.bz2": { + "build": "hf484d3e_7", + "build_number": 7, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libdb >=6.1.26,<6.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "91ba4acaf77fc16a64260c044b03a12e", + "name": "cyrus-sasl", + "sha256": "f6d98c711195fccd2cb22caa236d83c5bbaed4436a087e55861e9d3508cc655c", + "size": 315759, + "subdir": "linux-64", + "timestamp": 1600980811007, + "version": "2.1.27" + }, + "cython-0.26.1-py27hdbcff32_0.tar.bz2": { + "build": "py27hdbcff32_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "80dc8e057cc63945785b1f9ed212f299", + "name": "cython", + "sha256": "b739a450952990b3c8f37ad9065e9b5db35e14566dee137c193bd2b890cf3472", + "size": 2910903, + "subdir": "linux-64", + "timestamp": 1505693241957, + "version": "0.26.1" + }, + "cython-0.26.1-py35h636ebcb_0.tar.bz2": { + "build": "py35h636ebcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "17ba654fb5508ef7c5a228688135da4e", + "name": "cython", + "sha256": "35b3e7610b5774a113eedb703b9fee9ff73358c1ec58834b7f2747bbb5397acf", + "size": 3117437, + "subdir": "linux-64", + "timestamp": 1505693395206, + "version": "0.26.1" + }, + "cython-0.26.1-py36h21c49d0_0.tar.bz2": { + "build": "py36h21c49d0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "2c6d0b9dc9e1b7e2594b8e2ccd67fd67", + "name": "cython", + "sha256": "5f39c5f5ba6877678d7aa05b513a4779d194a7a05860ac8a3e5ec5235f13055e", + "size": 3172953, + "subdir": "linux-64", + "timestamp": 1505693555932, + "version": "0.26.1" + }, + "cython-0.27.3-py27hc56b35e_0.tar.bz2": { + "build": "py27hc56b35e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "67eb102ff7c4c71c439a9124b83c38a7", + "name": "cython", + "sha256": "28078ed555c59a82a7f12577daf2ec5257f090f6749663eece389f865cdde93a", + "size": 3010306, + "subdir": "linux-64", + "timestamp": 1512030431483, + "version": "0.27.3" + }, + "cython-0.27.3-py35h6cdc64b_0.tar.bz2": { + "build": "py35h6cdc64b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "b35c3251a846dfbdafc09aae7f461479", + "name": "cython", + "sha256": "15b6aa10a0cafe79ea8e81f855136beda33cdb4fbbd1644e02e23e135249c5dc", + "size": 3205691, + "subdir": "linux-64", + "timestamp": 1512030439103, + "version": "0.27.3" + }, + "cython-0.27.3-py36h1860423_0.tar.bz2": { + "build": "py36h1860423_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "7067368d70b8d88315e383e73288430d", + "name": "cython", + "sha256": "2c614918d32710c916d6aac043618f5c6a47e4e75aa131ec2ef04547d2cc170d", + "size": 3252951, + "subdir": "linux-64", + "timestamp": 1512030347046, + "version": "0.27.3" + }, + "cython-0.28.1-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "394fc39385ee5baa9cd87966e3f67e96", + "name": "cython", + "sha256": "870fb91d7ff7abb253c1384a94075235e1581a3d96b991ca2f7ef17a9465bbdb", + "size": 3412371, + "subdir": "linux-64", + "timestamp": 1522180809321, + "version": "0.28.1" + }, + "cython-0.28.1-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "a7f60ad6d6905b7fc7bdc74f269f2f43", + "name": "cython", + "sha256": "cfbaca0cbc278e5b4108832cc356b3f9bebc1639112791a6a8a49667b494737a", + "size": 3469282, + "subdir": "linux-64", + "timestamp": 1522180812803, + "version": "0.28.1" + }, + "cython-0.28.1-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "753f2b0bd8089884c4c5438ece134d4f", + "name": "cython", + "sha256": "bb8103bd8bdff34d38716bf2c4fc891103e194a219ffa791cc9c8a4711048443", + "size": 3518928, + "subdir": "linux-64", + "timestamp": 1522180389408, + "version": "0.28.1" + }, + "cython-0.28.2-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "ce59492ab83a381bf68b883f125ae237", + "name": "cython", + "sha256": "4331aa2b3408853515d39d5c777dbdef4af7800bbf21864080c1ed63a780afbe", + "size": 3413618, + "subdir": "linux-64", + "timestamp": 1523905135177, + "version": "0.28.2" + }, + "cython-0.28.2-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "8f8144548f7056e368b013a642b6c930", + "name": "cython", + "sha256": "3b3c00473d6b9340e16f76da2979d4cc8a7a6a7cacc6d6f931e3b1e5128404ce", + "size": 3470149, + "subdir": "linux-64", + "timestamp": 1523905075381, + "version": "0.28.2" + }, + "cython-0.28.2-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "57bde052b383ca4459bc0b1f19292635", + "name": "cython", + "sha256": "c76e424f4cb548aef073e64491976c728ee0b828b762cf090f7f8f4b15e1e05b", + "size": 3519869, + "subdir": "linux-64", + "timestamp": 1523905143096, + "version": "0.28.2" + }, + "cython-0.28.3-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "ebb1735cf9c745ccf9562e00b5f3c028", + "name": "cython", + "sha256": "1f9181be7cda90c3dd3c248cd08c1888753deb0fe75070821d665acd510a520f", + "size": 3415109, + "subdir": "linux-64", + "timestamp": 1527796675856, + "version": "0.28.3" + }, + "cython-0.28.3-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "8fc5a71d62ca10f9474a0b8173929e4f", + "name": "cython", + "sha256": "3820808c160ab621d521d96cdfd384ce8c023b9f899e9dc1b9c11ea56aaeb674", + "size": 3465801, + "subdir": "linux-64", + "timestamp": 1527796935917, + "version": "0.28.3" + }, + "cython-0.28.3-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "e8485056265c7c7e1c9b81f985fcdaac", + "name": "cython", + "sha256": "0fc8124bac82439d6731b4f72bb7482fa8885a3ce6a3e537563ca4367e263ace", + "size": 3535840, + "subdir": "linux-64", + "timestamp": 1527796656827, + "version": "0.28.3" + }, + "cython-0.28.3-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "26d80d2595b587c683134e29961d4d4b", + "name": "cython", + "sha256": "e73021338507a9340ba36e726ea554ddf4fecf220bf54faf0abac526be3f2972", + "size": 3524327, + "subdir": "linux-64", + "timestamp": 1530695822561, + "version": "0.28.3" + }, + "cython-0.28.4-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "f0dab3bc7604ea84be6a43d2dafad3cf", + "name": "cython", + "sha256": "6e9881536ac6bf3f87d30e033e4a57b95ffc990f305730aecd03b0cc03d9f877", + "size": 3417169, + "subdir": "linux-64", + "timestamp": 1532449675881, + "version": "0.28.4" + }, + "cython-0.28.4-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "934285759c5813ab616c07d39f6a3992", + "name": "cython", + "sha256": "0793f9dd0f1f8af756c4f5cf5e13899d2a94666fb15ca00721dcc90671959b90", + "size": 3470016, + "subdir": "linux-64", + "timestamp": 1532449052512, + "version": "0.28.4" + }, + "cython-0.28.4-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "fc3a978d1b5840deaa789552d8c0b19e", + "name": "cython", + "sha256": "31e182047d0d2910ebb8b9e5c502622b20ef74fba4cadae9a5c9e0c3f39d5bc2", + "size": 3539550, + "subdir": "linux-64", + "timestamp": 1532449666421, + "version": "0.28.4" + }, + "cython-0.28.4-py37hf484d3e_0.tar.bz2": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "16cc90cca491dd404859647c1b682ec0", + "name": "cython", + "sha256": "2215547a89313edc17582247aad222697b8777f3e62499c13f30917acdfdca64", + "size": 3526855, + "subdir": "linux-64", + "timestamp": 1532449719161, + "version": "0.28.4" + }, + "cython-0.28.4-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "4ef161ab7f8f317f5690fa75675ef519", + "name": "cython", + "sha256": "e5b21c7538a45f6536627dab30b15492789cbe9fc774834c31d93196267975a6", + "size": 3553346, + "subdir": "linux-64", + "timestamp": 1572860692437, + "version": "0.28.4" + }, + "cython-0.28.5-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "a8f450d5f85ece99f57b3e9af6fdfc99", + "name": "cython", + "sha256": "8685d4c19862ba68acf8fbd9b9d68f35f1aa593aa1a8840847ad7e2ba9002039", + "size": 3386251, + "subdir": "linux-64", + "timestamp": 1533739421124, + "version": "0.28.5" + }, + "cython-0.28.5-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "4ac4d25e33d7189b6c7e1c7bfbdeb217", + "name": "cython", + "sha256": "9d7e0b674961135068c67b2851c45c5eb8f3e2b697f4077665060639cc1373d1", + "size": 3440639, + "subdir": "linux-64", + "timestamp": 1533739693481, + "version": "0.28.5" + }, + "cython-0.28.5-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "9f50bef5a7880d57e6cd1b0878f53166", + "name": "cython", + "sha256": "7b90bdf543901da46d5c2ce7b0981c0c945cadbc7bcbd4b5bcb2fdd7275e19e0", + "size": 3492259, + "subdir": "linux-64", + "timestamp": 1533739634381, + "version": "0.28.5" + }, + "cython-0.28.5-py37hf484d3e_0.tar.bz2": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "4a86d0ffb2d93a19484ae7b6d5741887", + "name": "cython", + "sha256": "be9a9d2226b0a02f1d17069c9d82e2dc8b6409484b1ab25b3ea7cde25c2dcb80", + "size": 3485027, + "subdir": "linux-64", + "timestamp": 1533739697742, + "version": "0.28.5" + }, + "cython-0.29-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "10eb2717863d66cdb1a38d71bb75fd5b", + "name": "cython", + "sha256": "a66ed4118a8e37137ab4d073036d73f3428f0d65b0b35652ef76052d6d1ce8db", + "size": 2298287, + "subdir": "linux-64", + "timestamp": 1539636488894, + "version": "0.29" + }, + "cython-0.29-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "2a6e17575e2b15dce5421fb59d50fca4", + "name": "cython", + "sha256": "9d0bc7905420250051a09588929c281c37df4b1664b3f11c2224ae7c58fdb42d", + "size": 2378607, + "subdir": "linux-64", + "timestamp": 1539636482516, + "version": "0.29" + }, + "cython-0.29-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "abfea567b367844473bc4adf2607c464", + "name": "cython", + "sha256": "e3c328af25906a5c54c478e9f051df790e5a4c806a162610da9f0f65e2c6c768", + "size": 2371704, + "subdir": "linux-64", + "timestamp": 1539636510341, + "version": "0.29" + }, + "cython-0.29.10-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "8ea6041ac696639f760499e7f5fe0ce9", + "name": "cython", + "sha256": "dcede03c5734059df9e7aebde66e028236014ab31dfc3e8a187ad508af9a9ab6", + "size": 2246647, + "subdir": "linux-64", + "timestamp": 1559769854847, + "version": "0.29.10" + }, + "cython-0.29.10-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "c15a263e0f79cef63115929918393455", + "name": "cython", + "sha256": "8dc6119796ab9ec4dfcc8cf32f81e04b1d59b7244e2223debc03400cd18f3edd", + "size": 2296604, + "subdir": "linux-64", + "timestamp": 1559769838362, + "version": "0.29.10" + }, + "cython-0.29.10-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "0ade87473f96c93cb422f9290fc23f48", + "name": "cython", + "sha256": "aaaeb01c4e93e6ab1fba58fac69ed1edce0a1a5d3bf5ddf133812159215e6792", + "size": 2300089, + "subdir": "linux-64", + "timestamp": 1559770164793, + "version": "0.29.10" + }, + "cython-0.29.11-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "61953113796df9bbfe6d7c2a02e9ddd7", + "name": "cython", + "sha256": "fe4f4a4b5c4a0f55d99f16426b50a0c0269beb6ae6e11bf8902628cf52d2065a", + "size": 2235634, + "subdir": "linux-64", + "timestamp": 1562081886543, + "version": "0.29.11" + }, + "cython-0.29.11-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "aec50f0bac296685671503bfa1203b28", + "name": "cython", + "sha256": "7a8171e7c4085348d178684d2c2b0d5383b53d2ebe9643fd86cd9f3a606058f0", + "size": 2306031, + "subdir": "linux-64", + "timestamp": 1562081888649, + "version": "0.29.11" + }, + "cython-0.29.11-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "42a0d500e5dd929b3a398cfd9291fd25", + "name": "cython", + "sha256": "eaa2796fe85096e137e1c2d0fa7e258d64060020678d05768e5ea44416f9f723", + "size": 2307682, + "subdir": "linux-64", + "timestamp": 1562081960676, + "version": "0.29.11" + }, + "cython-0.29.12-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "ca022fc76851a9ac1edda2e6e3fbd268", + "name": "cython", + "sha256": "c642c2c376a976f5f6de38922d844dae1903eb3e976db7adb5a8d61a78859663", + "size": 2256559, + "subdir": "linux-64", + "timestamp": 1563207240847, + "version": "0.29.12" + }, + "cython-0.29.12-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "796052d451396cf681e1747547a16128", + "name": "cython", + "sha256": "67541ff395c4005f0ef773cc73923f78b3f4cb8a9cf4ed2c199f5ca4e2bd4151", + "size": 2325168, + "subdir": "linux-64", + "timestamp": 1563207263781, + "version": "0.29.12" + }, + "cython-0.29.12-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "d795c141d9b94181ec5f01781465b7e7", + "name": "cython", + "sha256": "14690af8e20395e0164b12aaafc04ed9bb34839e536b08307ba67c47483c8d9c", + "size": 2322655, + "subdir": "linux-64", + "timestamp": 1563207245706, + "version": "0.29.12" + }, + "cython-0.29.13-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "8e8f494f71e8dffbdee859227a8390dc", + "name": "cython", + "sha256": "c2c445ac090f534184afdeecfe1112997e20646f648ac9938cd4c30e9966fd77", + "size": 2267158, + "subdir": "linux-64", + "timestamp": 1565959775345, + "version": "0.29.13" + }, + "cython-0.29.13-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "6c82274389a304796397a60e9e3fee13", + "name": "cython", + "sha256": "8631c17c1e3e1673226a49b6d3cd072f57b50b4d12f908c1873ea19f8650eea4", + "size": 2325052, + "subdir": "linux-64", + "timestamp": 1565959656768, + "version": "0.29.13" + }, + "cython-0.29.13-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "932cfff8e2990ce9517addd22e0225b0", + "name": "cython", + "sha256": "720987e9083f22993f994df84bd8eb0de88ce880cdb0ccd08e67dfaa368bf145", + "size": 2309039, + "subdir": "linux-64", + "timestamp": 1565959875992, + "version": "0.29.13" + }, + "cython-0.29.13-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "f2483331c51f76fd534761a983751d8c", + "name": "cython", + "sha256": "f832fbbecee56a18d28da20ae87e305fa92c1c5f292dca7fbc429fff6934753b", + "size": 2366101, + "subdir": "linux-64", + "timestamp": 1572437128292, + "version": "0.29.13" + }, + "cython-0.29.14-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "8785998f2816e48b4a299c90ad3974b9", + "name": "cython", + "sha256": "65b5acef129b2f77206eec1133dc0660945473fec8a1131d531e74479bcb1c35", + "size": 2256350, + "subdir": "linux-64", + "timestamp": 1574271369331, + "version": "0.29.14" + }, + "cython-0.29.14-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "ce499c349c0a90ac474113030ffce573", + "name": "cython", + "sha256": "f15f1c6a9ff6c6a1c16573dc557860a907ee893703510114db9fcdd225841993", + "size": 2314294, + "subdir": "linux-64", + "timestamp": 1574271377336, + "version": "0.29.14" + }, + "cython-0.29.14-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "0f7439a67d7468885bddba833ce27fd2", + "name": "cython", + "sha256": "9ca9c20a762b964274bc7e5708d7639e9f9a6503abc68a22ed6bbe3ac420d69e", + "size": 2319686, + "subdir": "linux-64", + "timestamp": 1574271241757, + "version": "0.29.14" + }, + "cython-0.29.14-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "9b4be64e71e386479f117c70ea11a170", + "name": "cython", + "sha256": "ced12052e23ee68c26a83fe697e54051d1bd6dda45db1ba7b95ac23262d3b5fd", + "size": 2381895, + "subdir": "linux-64", + "timestamp": 1574271357426, + "version": "0.29.14" + }, + "cython-0.29.15-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "df6cdb5281910a8eadb94d7ba16d8cf5", + "name": "cython", + "sha256": "c6ec83fd0ec89f177cb9c107a3547b4ef37924b742b2cb413559cff0dcd603c1", + "size": 2314078, + "subdir": "linux-64", + "timestamp": 1581353624198, + "version": "0.29.15" + }, + "cython-0.29.15-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "db0cbf706a44130f48c67764caf7a5ab", + "name": "cython", + "sha256": "d2d8516f1a1f49704bcf725847ba462db8fdd403ff4dcbe81063f80d1873f7b6", + "size": 2306683, + "subdir": "linux-64", + "timestamp": 1581353554962, + "version": "0.29.15" + }, + "cython-0.29.15-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "0b0b1b1955e8bb02bebb71164877ebfd", + "name": "cython", + "sha256": "9fb6ba2368306028f8c4cb27aab15e2217c9362c0783f0bd7ccd70b41903069b", + "size": 2367668, + "subdir": "linux-64", + "timestamp": 1581353520151, + "version": "0.29.15" + }, + "cython-0.29.17-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "d46ba7530368c81a3d9ae9b94e4ec25a", + "name": "cython", + "sha256": "0f78e9d201cb4c4bcc60c19611ffbc7da55dcf88b2e5ef8a2e98e99326814510", + "size": 2305809, + "subdir": "linux-64", + "timestamp": 1588172834210, + "version": "0.29.17" + }, + "cython-0.29.17-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "d9245d016e5958f227c93574b5555b66", + "name": "cython", + "sha256": "8038b1fd05d44bd24b446794c8a579ebeca90934362022d7381924e4272cbf15", + "size": 2316941, + "subdir": "linux-64", + "timestamp": 1588172822397, + "version": "0.29.17" + }, + "cython-0.29.17-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "e6ed5c38b08416bca75451db497be3a1", + "name": "cython", + "sha256": "b3e1f23aa328f96d9ef2caf22e3220df9331e2142b305ffac250eb101a449d08", + "size": 2387484, + "subdir": "linux-64", + "timestamp": 1588172811523, + "version": "0.29.17" + }, + "cython-0.29.2-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "45acc3a40bde5c002366e2bb05387d35", + "name": "cython", + "sha256": "a7f61590fdb8e537c35e3e906f0c8c02b72025845239bad7817962c43dc3c1fa", + "size": 2224439, + "subdir": "linux-64", + "timestamp": 1545074265535, + "version": "0.29.2" + }, + "cython-0.29.2-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "caeabd86c9db4916c95b844c68db56cf", + "name": "cython", + "sha256": "5f601426f07a5de53b3c9fb8ea36abd5bb47100a04bd473be11ccc759450146b", + "size": 2299474, + "subdir": "linux-64", + "timestamp": 1545074326716, + "version": "0.29.2" + }, + "cython-0.29.2-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "f4941cf7f0204dcd89d69c9663a488bb", + "name": "cython", + "sha256": "5d508719f54c6ac9e7f44a7c4b34071ce3b5212ed9db5aacc1eee0f67e3aa696", + "size": 2286961, + "subdir": "linux-64", + "timestamp": 1545074322215, + "version": "0.29.2" + }, + "cython-0.29.20-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "53d2dbdd0370bcf82ccc3bb082a324b1", + "name": "cython", + "sha256": "311f130bdbe4fca732e5e151c377399229bbee1b443c7aa37014719deb52f186", + "size": 2182450, + "subdir": "linux-64", + "timestamp": 1592330450476, + "version": "0.29.20" + }, + "cython-0.29.20-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "3a4d528e4632719749c1f4c5aea1d7e5", + "name": "cython", + "sha256": "9a312cea3a8309dadd0cf4a83c7aa1d32286fd49b69690e2a630181525cc9d6d", + "size": 2190680, + "subdir": "linux-64", + "timestamp": 1592330439562, + "version": "0.29.20" + }, + "cython-0.29.20-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "0b10c391186a6a6c9edab9952f1253a9", + "name": "cython", + "sha256": "a965b9a1fd7f4379fbb5520968561bb4df3fac8ab3ff9287053f11e0edbf6f4b", + "size": 2248122, + "subdir": "linux-64", + "timestamp": 1592330446320, + "version": "0.29.20" + }, + "cython-0.29.21-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "0712cac69d4a8bcb4f14c4a1359098d9", + "name": "cython", + "sha256": "7c8c96adac215c60d3bf39ed808f07668a7ad73f52a6f004913deccc28e51129", + "size": 2193284, + "subdir": "linux-64", + "timestamp": 1605457745540, + "version": "0.29.21" + }, + "cython-0.29.21-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "bdd438442111bd1428e94b5caa0f44da", + "name": "cython", + "sha256": "9c8ee967d43b6285655b85852f80c8eef3aeb8da2cebae4b5275d969ba1f4631", + "size": 2177233, + "subdir": "linux-64", + "timestamp": 1594831673199, + "version": "0.29.21" + }, + "cython-0.29.21-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "3020da092dc4c61c48baaa84263e2999", + "name": "cython", + "sha256": "104f5932c8baff9bd37e1fb866eebafb20ae6f781a55c3f3091356507e418e8d", + "size": 2184436, + "subdir": "linux-64", + "timestamp": 1605457709717, + "version": "0.29.21" + }, + "cython-0.29.21-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "1f66464c22a68805634def9caed0cac6", + "name": "cython", + "sha256": "2fafc7ad79eab025d9be26ea3a1f96ca4a56809ca816643bb2a8b003ed7b9c90", + "size": 2186579, + "subdir": "linux-64", + "timestamp": 1594831669266, + "version": "0.29.21" + }, + "cython-0.29.21-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "38aaea665e71f912f2adf7efa6f70ebc", + "name": "cython", + "sha256": "0aa9b9b176af11d697514e9e14d1154643e5dfd3d7db924e96bbef6062a2aec2", + "size": 2242599, + "subdir": "linux-64", + "timestamp": 1605457745356, + "version": "0.29.21" + }, + "cython-0.29.21-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "848ea7f2bf6991c7743988db47e8fe65", + "name": "cython", + "sha256": "45d4c528ca915c1ab8b209c1c57e55bfc017f862456d3f961484cc1d68792a19", + "size": 2245233, + "subdir": "linux-64", + "timestamp": 1594831669553, + "version": "0.29.21" + }, + "cython-0.29.21-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "4730cd14747ab3c49a8f3d6769fd2777", + "name": "cython", + "sha256": "e4555916b40dff47599dbdb19ddff799a9c0d6ed9722a14e1449ab5f683fc27b", + "size": 2229177, + "subdir": "linux-64", + "timestamp": 1605457745033, + "version": "0.29.21" + }, + "cython-0.29.22-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "763a0a47ee77cb7a979ae1745607b70d", + "name": "cython", + "sha256": "25a03f429035fee4eb947e5c5dfa8bcd854d7efb6f2067c918597bd9a3c7b1cc", + "size": 2185292, + "subdir": "linux-64", + "timestamp": 1614014950713, + "version": "0.29.22" + }, + "cython-0.29.22-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "015f4dbd26fdb9509b951533a401d0fe", + "name": "cython", + "sha256": "1afe88c733e7044051b63e7986ccef64c48fda00fe8e170a9402ad9d14c75908", + "size": 2180097, + "subdir": "linux-64", + "timestamp": 1614014950618, + "version": "0.29.22" + }, + "cython-0.29.22-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "6e12417b3b3141889132e2f9e50e5362", + "name": "cython", + "sha256": "ff3bedc10f592e99d5d40647772b60043f133a9e2ac9b5ddbb35741b0b376530", + "size": 2241041, + "subdir": "linux-64", + "timestamp": 1614014948272, + "version": "0.29.22" + }, + "cython-0.29.22-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "939b33aa780110ac321314479461ae61", + "name": "cython", + "sha256": "875930665d88d91186f491d93c8089891b90053e6f105aaf1074d06f7ebf6a38", + "size": 2246829, + "subdir": "linux-64", + "timestamp": 1614014431627, + "version": "0.29.22" + }, + "cython-0.29.23-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "99c85c7a519ae4532db9ada6bed368d6", + "name": "cython", + "sha256": "c61163f6cd8e27fab9902cdec92b2367eb39ff19c19631a04cbe688a053b2e11", + "size": 2177713, + "subdir": "linux-64", + "timestamp": 1618435280709, + "version": "0.29.23" + }, + "cython-0.29.23-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "d709e1191533e4da974c2d8138320859", + "name": "cython", + "sha256": "b41b41453cce8cc460e388edabe33ce31a875ce1301a9907e94952992f191936", + "size": 2174419, + "subdir": "linux-64", + "timestamp": 1618432151539, + "version": "0.29.23" + }, + "cython-0.29.23-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "06adf136f037eaa67253981d3350f6d9", + "name": "cython", + "sha256": "b0e58b819e8b71bf68f3db271d45d504c7930dff9f73509758f9d22f6048bcd8", + "size": 2226553, + "subdir": "linux-64", + "timestamp": 1618435275487, + "version": "0.29.23" + }, + "cython-0.29.23-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "c1acdff56f8322936904b8f931b8d236", + "name": "cython", + "sha256": "0f5f7bdb8c2afb7fd31d6ef8735ad5dfcf03f3525bc462e54adf194d2fe5cf30", + "size": 2237199, + "subdir": "linux-64", + "timestamp": 1618435265950, + "version": "0.29.23" + }, + "cython-0.29.24-py36h295c915_0.tar.bz2": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0fe500890d59d141aa3f49e105350ca9", + "name": "cython", + "sha256": "5f329fecc489d3dbe02940bf8b876c04ab6b45ec2bd7f295f9294ce84bc770b1", + "size": 2173377, + "subdir": "linux-64", + "timestamp": 1626256722260, + "version": "0.29.24" + }, + "cython-0.29.24-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "48b67f6e575648ad9ea6304269f52942", + "name": "cython", + "sha256": "add087b16f4bc60e69ebf03ff37485371a726482d74a1de53b9c06b3974e992d", + "size": 2174608, + "subdir": "linux-64", + "timestamp": 1626250003391, + "version": "0.29.24" + }, + "cython-0.29.24-py37hdbfa776_0.tar.bz2": { + "build": "py37hdbfa776_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2894e9c9af994c5cf6dfe20b4500f21f", + "name": "cython", + "sha256": "eefe465453f318bdb5379e792fd73ead12faf10f502f8a9f4244a56804914a4e", + "size": 2183753, + "subdir": "linux-64", + "timestamp": 1636023897717, + "version": "0.29.24" + }, + "cython-0.29.24-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "14385c3a504a18f284cf5c03b6030cd7", + "name": "cython", + "sha256": "59209c08262ac3e032015b9e8f8e1e68e96e8b7392ef9ad2e19e8de9d3109d07", + "size": 2242364, + "subdir": "linux-64", + "timestamp": 1626257062703, + "version": "0.29.24" + }, + "cython-0.29.24-py38hdbfa776_0.tar.bz2": { + "build": "py38hdbfa776_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "06b166e25f079d5069213dded57c5b42", + "name": "cython", + "sha256": "97141683ac5bea6f0001f5557da102b16c2bbecb6208826e96e16b93e03d07ff", + "size": 2250878, + "subdir": "linux-64", + "timestamp": 1636035886270, + "version": "0.29.24" + }, + "cython-0.29.24-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5a34f1eb22e74df3273c13319870b742", + "name": "cython", + "sha256": "1f22dbb63627d61224c098e25b2ce8bd8713d97a8fa64d7412381693dc072c5b", + "size": 2244943, + "subdir": "linux-64", + "timestamp": 1626257080163, + "version": "0.29.24" + }, + "cython-0.29.24-py39hdbfa776_0.tar.bz2": { + "build": "py39hdbfa776_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "52d886d72dc4d2cb19dbbf9bbf6e20e6", + "name": "cython", + "sha256": "3b38b1d7acfcca1f12d3046cf876e140a4b5ec37d7fdf8b48c4970d4d376694f", + "size": 2255684, + "subdir": "linux-64", + "timestamp": 1636035258270, + "version": "0.29.24" + }, + "cython-0.29.25-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "9ad8b6f73fceca0c29fd1ee252eb9581", + "name": "cython", + "sha256": "4c7610381df93e35e201b3d4ef5a307e0a3a25902f29ad5860cffd7c971ad0d8", + "size": 4963257, + "subdir": "linux-64", + "timestamp": 1640004554193, + "version": "0.29.25" + }, + "cython-0.29.25-py310hdbfa776_0.tar.bz2": { + "build": "py310hdbfa776_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "f68386089dc6062ad92e6f1c11773320", + "name": "cython", + "sha256": "19cac33eeabed8815a76ba23b55283d4c7749f08661488ae4ef2ec002e34e02b", + "size": 4981501, + "subdir": "linux-64", + "timestamp": 1639474695333, + "version": "0.29.25" + }, + "cython-0.29.25-py37hdbfa776_0.tar.bz2": { + "build": "py37hdbfa776_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "559460a17ac520e7dbd1780d2e41eac8", + "name": "cython", + "sha256": "9462029a7a676a0b18afce223a3f6af772881d0332db47c1907c49f8dcd64976", + "size": 2195254, + "subdir": "linux-64", + "timestamp": 1639474670346, + "version": "0.29.25" + }, + "cython-0.29.25-py38hdbfa776_0.tar.bz2": { + "build": "py38hdbfa776_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "ee6a03c19fcba3b34267b4125d2d54f8", + "name": "cython", + "sha256": "ddbcfca05c141c84a1174159c1f17900f60628bbc84b8ca7c4c8b41ae3108b78", + "size": 2247933, + "subdir": "linux-64", + "timestamp": 1639474670220, + "version": "0.29.25" + }, + "cython-0.29.25-py39hdbfa776_0.tar.bz2": { + "build": "py39hdbfa776_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "e6eb60993fbeda9189d4fb196ec4d0ef", + "name": "cython", + "sha256": "06bd8a9b05fd63605030da2bc6f431b43acbe01a66e1c39ecaeddc9ebf8568b5", + "size": 2247616, + "subdir": "linux-64", + "timestamp": 1639456553547, + "version": "0.29.25" + }, + "cython-0.29.28-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b132aea5539bd6d9504f5864149d553b", + "name": "cython", + "sha256": "4fcef0c14a13725a0b55604d117e528320a86aec8cb27a2943c65b30d141e03b", + "size": 4991457, + "subdir": "linux-64", + "timestamp": 1647832335641, + "version": "0.29.28" + }, + "cython-0.29.28-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fe907dc38be7737c8566ee41b5500023", + "name": "cython", + "sha256": "11e83dbe5ae0e437b324a2b1d340ec638d5f3a654c4a30ef4b39a9af0020f5b7", + "size": 2197820, + "subdir": "linux-64", + "timestamp": 1647850444065, + "version": "0.29.28" + }, + "cython-0.29.28-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "50f10d5399f8df70d9c00deac69ccf99", + "name": "cython", + "sha256": "9c2676e99963cc8b2d91091f4087fb159a5cc1439949e2f82b7019dc72a4fbaf", + "size": 2258631, + "subdir": "linux-64", + "timestamp": 1647832571349, + "version": "0.29.28" + }, + "cython-0.29.28-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "53edb0ddcdfcbda78c54a985095abc4c", + "name": "cython", + "sha256": "22b01c970c6caac7f3d99fe04b1c0d614ed448d27fd96cc8fa0100ae7f89c7c1", + "size": 2252284, + "subdir": "linux-64", + "timestamp": 1647850444141, + "version": "0.29.28" + }, + "cython-0.29.30-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "05935a341e1b70bfa742912ef1110f6f", + "name": "cython", + "sha256": "5dd40cf279e819ea02419144aeb32d1bc8f52a239aa5472b1c1ae85171c839ab", + "size": 5231989, + "subdir": "linux-64", + "timestamp": 1656942152977, + "version": "0.29.30" + }, + "cython-0.29.30-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6c2ef4cbeb236de789aea984008cce38", + "name": "cython", + "sha256": "271bd7887c591876bb638d926b0592a77303aacc4b7ad4d89856adc4495d74c1", + "size": 2181244, + "subdir": "linux-64", + "timestamp": 1656942326989, + "version": "0.29.30" + }, + "cython-0.29.30-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dc0e103af282c9438b773f940ec38a56", + "name": "cython", + "sha256": "2688ebcb6cc0bbc5f31250e77a214e4826c9e221d5f3ef4ce83833dab7a9f2e9", + "size": 2236994, + "subdir": "linux-64", + "timestamp": 1656942238380, + "version": "0.29.30" + }, + "cython-0.29.30-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "104be4db84dc0e98c7e4ffa83a6955c4", + "name": "cython", + "sha256": "554fdd129d71ec14f5de36c380ed6cf5702f6c0ec4831dcd33aa6c64ca6381ed", + "size": 2206567, + "subdir": "linux-64", + "timestamp": 1656942050866, + "version": "0.29.30" + }, + "cython-0.29.32-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6899abc49955fe33116b4223341fbc67", + "name": "cython", + "sha256": "6dabdb98b8e96ae0b13e243930e53647683800d254c4e69c3971bb58b8a3dc5a", + "size": 5235063, + "subdir": "linux-64", + "timestamp": 1663693020183, + "version": "0.29.32" + }, + "cython-0.29.32-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2d94dfdd29e51cffd83393e5c43d369c", + "name": "cython", + "sha256": "b70832b6fd94123fd39383420079d8669690e5aa3786e93e5e807010e6f29417", + "size": 2634605, + "subdir": "linux-64", + "timestamp": 1676904355646, + "version": "0.29.32" + }, + "cython-0.29.32-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "13bdab3d07efce5d702399e75c34cef8", + "name": "cython", + "sha256": "0391f5ac42117d68de7185a88c7c522906b03f1b82f0ada5e6780256310e0a9d", + "size": 2183366, + "subdir": "linux-64", + "timestamp": 1663693096269, + "version": "0.29.32" + }, + "cython-0.29.32-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e216e2befe62798f2e30d4274aa1acb7", + "name": "cython", + "sha256": "f8b2d82e6c57940aaf68f708679a78b58f4e2d9881924eab99f6e58e2225322b", + "size": 2243357, + "subdir": "linux-64", + "timestamp": 1663692929100, + "version": "0.29.32" + }, + "cython-0.29.32-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c769470757748f1d09e6c33c4ea7fe8c", + "name": "cython", + "sha256": "ae62b7114de67b41b8d553fc753ecca1d9881ae2056aff40d5e66f817c8130f6", + "size": 2207417, + "subdir": "linux-64", + "timestamp": 1663692857742, + "version": "0.29.32" + }, + "cython-0.29.33-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "256ce3a2752da34e1786982f238bb135", + "name": "cython", + "sha256": "e7411cc08e6faa2dde22206048c3ec77199c92c3f2243f4028032b5839cc43d7", + "size": 2191348, + "subdir": "linux-64", + "timestamp": 1676568322193, + "version": "0.29.33" + }, + "cython-0.29.33-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "01f3c6fd7f5b74d0b8ba9a512df57254", + "name": "cython", + "sha256": "a78c559f42efac1a97ccedeae083b51be361c71ff893a348a3f1c4d82d07ff17", + "size": 2626432, + "subdir": "linux-64", + "timestamp": 1676822959420, + "version": "0.29.33" + }, + "cython-0.29.33-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dc3089f4e9b6e8ecfe7e22f1d05fb277", + "name": "cython", + "sha256": "335b600ccb91db7ed8c2c37ac8497a51c2777f6f3388bb6df77eaeb34f02e083", + "size": 2172200, + "subdir": "linux-64", + "timestamp": 1676568110775, + "version": "0.29.33" + }, + "cython-0.29.33-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f88a795e25b4a9da3b1e165713acadae", + "name": "cython", + "sha256": "d09d72e9c05b9fe72285f0e53def89e1dcaa7ba33d2d5229c4c916fcab8c0f5b", + "size": 2230950, + "subdir": "linux-64", + "timestamp": 1676568253077, + "version": "0.29.33" + }, + "cython-0.29.33-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b0bb2634bc3be9e0423dda78a588bbb1", + "name": "cython", + "sha256": "164f1f1678002cb4b342b83031f1b5990969480097b9afd8dd43990693312b1f", + "size": 2199785, + "subdir": "linux-64", + "timestamp": 1676568180444, + "version": "0.29.33" + }, + "cython-0.29.4-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "008aeb33a2634305bc65ca05ecb67fc7", + "name": "cython", + "sha256": "4fd61e21dfb31db35b3860f55198df837a234c3d3a611cab4b72f20a27037ea0", + "size": 2230750, + "subdir": "linux-64", + "timestamp": 1549325636863, + "version": "0.29.4" + }, + "cython-0.29.4-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "58df218a0eec1c80689821ac14fa10a0", + "name": "cython", + "sha256": "10f7300d59e761070fcacd57e30050e64ca5aeeea6ed996e42950d89170d631b", + "size": 2306365, + "subdir": "linux-64", + "timestamp": 1549325608965, + "version": "0.29.4" + }, + "cython-0.29.4-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "c2fa6db181e1728d0db86af932343a97", + "name": "cython", + "sha256": "51f1ae162903dc44aa2dc04b1710fe98d0bbd4653db08c2a03479fcc6e2376de", + "size": 2295441, + "subdir": "linux-64", + "timestamp": 1549325564532, + "version": "0.29.4" + }, + "cython-0.29.5-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "76518d236f55433c3ee398a586716943", + "name": "cython", + "sha256": "8268cb78b20fdf1e929c78145cea0874eeba3d94a95e57e431b941717ddea42c", + "size": 2233508, + "subdir": "linux-64", + "timestamp": 1550268010041, + "version": "0.29.5" + }, + "cython-0.29.5-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "1fd811f9d1396a65bb3771a89ebd5675", + "name": "cython", + "sha256": "5ae5929a252b98d8c66a99e085c5883ce2e2dbc5250a7d7d672b0be42263bd35", + "size": 2308020, + "subdir": "linux-64", + "timestamp": 1550268079570, + "version": "0.29.5" + }, + "cython-0.29.5-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "31a2233a90e89c9633bd7568cc959f0f", + "name": "cython", + "sha256": "4de81951f177504e8571f18de03e1ce0b90e7dabac7d78ac8e8c38c66dc67dc4", + "size": 2293421, + "subdir": "linux-64", + "timestamp": 1550268026025, + "version": "0.29.5" + }, + "cython-0.29.6-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "cfef30b4907feff06ca0b8e3a45a5280", + "name": "cython", + "sha256": "c002d6131b5dc3e77af0ed69dbe1360f932f04c80ea295419130c19a630e0636", + "size": 2232245, + "subdir": "linux-64", + "timestamp": 1552326333502, + "version": "0.29.6" + }, + "cython-0.29.6-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "ec68f5a597f267f18556bde81cfaea63", + "name": "cython", + "sha256": "69aa574336100d9c9beb6737a19e169e41cdcb0de5f0428ca75cebb6383dd8ee", + "size": 2291184, + "subdir": "linux-64", + "timestamp": 1552326201435, + "version": "0.29.6" + }, + "cython-0.29.6-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "467a56645951f1e3f12cf13fce60a50e", + "name": "cython", + "sha256": "6b9ef190e157405e38f9b7b2e9529a477c723bbe965967206448c0ceca9323ad", + "size": 2303632, + "subdir": "linux-64", + "timestamp": 1552326161333, + "version": "0.29.6" + }, + "cython-0.29.7-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "80f7889264b81afc2745969ac77484f0", + "name": "cython", + "sha256": "898a61822c8baf7374c03f3295e39a17963ecc6dee8aad11052115cb3a468ffa", + "size": 2239652, + "subdir": "linux-64", + "timestamp": 1555427804492, + "version": "0.29.7" + }, + "cython-0.29.7-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "392cc94511feeaada00a88f4a8faaa6c", + "name": "cython", + "sha256": "3bb5a21569e8d7b1be2810e77b3d35a880667497f954f49191734520377e3829", + "size": 2306894, + "subdir": "linux-64", + "timestamp": 1555427828787, + "version": "0.29.7" + }, + "cython-0.29.7-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "bfd123e30126fba05c01a8a04daaf1bd", + "name": "cython", + "sha256": "0f00272fd082bfb1adeaf30e6198791330327e0cff4d80859c6e5713d0168a17", + "size": 2295753, + "subdir": "linux-64", + "timestamp": 1555427714543, + "version": "0.29.7" + }, + "cython-0.29.8-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "0ae5bcf897fc08c8f4a59fa0d7e2b343", + "name": "cython", + "sha256": "cf831085899bee1f35a73fa8ca02f6294f2a4717eed599deec6f9ccd06cf1841", + "size": 2241684, + "subdir": "linux-64", + "timestamp": 1559140804587, + "version": "0.29.8" + }, + "cython-0.29.8-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "44dc75643b868158c994e85ce3c825bf", + "name": "cython", + "sha256": "21815d671b47036702c37c975863e5e88ea0fdea55dff4a2c4dd814681675fc6", + "size": 2297916, + "subdir": "linux-64", + "timestamp": 1559140741435, + "version": "0.29.8" + }, + "cython-0.29.8-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "64000a88591b2f727275b98221e224f1", + "name": "cython", + "sha256": "9ff1aee219a427ce11cfb13fc6bc7a5fba825cee3b4997b2d92ff14bc2d080c9", + "size": 2302375, + "subdir": "linux-64", + "timestamp": 1559140576647, + "version": "0.29.8" + }, + "cython-blis-0.4.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "87e53286cdcb20ec06f31b3fcdb1918f", + "name": "cython-blis", + "sha256": "2cc411e07254c47e811598ae753ca7ea014206075c7c03c18ca62ee20efe8c17", + "size": 4473313, + "subdir": "linux-64", + "timestamp": 1590154876002, + "version": "0.4.1" + }, + "cython-blis-0.4.1-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5eabe9de57b477ddbf4eeabf59a3cfa2", + "name": "cython-blis", + "sha256": "5704466c0419bfb9f8badfc752d58150468fef290ec24f9369a7c6fbe8d9dd2f", + "size": 4475901, + "subdir": "linux-64", + "timestamp": 1594247180446, + "version": "0.4.1" + }, + "cython-blis-0.4.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2cf48b57c1b6990bbfb5561193e68ea6", + "name": "cython-blis", + "sha256": "6fc3fc0f4d8c33a747039191110a857ddcb2b853fc717b4ba7cfbb6d258cacf1", + "size": 4473910, + "subdir": "linux-64", + "timestamp": 1590154867378, + "version": "0.4.1" + }, + "cython-blis-0.4.1-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "efff38e461b9ca86bdbc4b72ac545eab", + "name": "cython-blis", + "sha256": "42c04536cca805dbaf339d0875d58dc92605a5ff071ed399eb8b98be5a1694ba", + "size": 4464192, + "subdir": "linux-64", + "timestamp": 1594247204608, + "version": "0.4.1" + }, + "cython-blis-0.4.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eb46f99ced4138645c599c20cc913301", + "name": "cython-blis", + "sha256": "c0ebd5e3475e1abb1cf0d9cf6669b73a5548e745da2c3fe37b923b0524bd63aa", + "size": 4484399, + "subdir": "linux-64", + "timestamp": 1590154880633, + "version": "0.4.1" + }, + "cython-blis-0.4.1-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2893c583ad53135b9e82df6b430008aa", + "name": "cython-blis", + "sha256": "f9b5a146bcd6a96272c07001f94e91a8b7916bc653734a614b907a6ef07c48b0", + "size": 4478769, + "subdir": "linux-64", + "timestamp": 1594247283343, + "version": "0.4.1" + }, + "cython-blis-0.4.1-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "489240ce215b6bbac58f53c14efbb0ce", + "name": "cython-blis", + "sha256": "b820b090965b538ab98bc9ce50ebcf34decf06e55e0b4cca7909a768d533c933", + "size": 4478984, + "subdir": "linux-64", + "timestamp": 1608234067304, + "version": "0.4.1" + }, + "cython-blis-0.7.4-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "535d9b6baa3bd32468d1a1f7ea5fecbf", + "name": "cython-blis", + "sha256": "5f427c7b4ef09270a1ec5c2fc8b53903a4ce5f46400fe3390ca3f9acc3cfce07", + "size": 3808164, + "subdir": "linux-64", + "timestamp": 1613319993403, + "version": "0.7.4" + }, + "cython-blis-0.7.4-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "532cd66411471bd3b8f0b72d07456cdf", + "name": "cython-blis", + "sha256": "b9dd34ee095d6c0a0fdbe06f38e88ad3abd3e71c7089b57681fe3fdedb3afe23", + "size": 3812445, + "subdir": "linux-64", + "timestamp": 1613319974658, + "version": "0.7.4" + }, + "cython-blis-0.7.4-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "14ffff531b8236c885e365d9152f544e", + "name": "cython-blis", + "sha256": "b84e202b003539bde00677fac345f3f5d97593d036f679de6ac0830d44020f5f", + "size": 3818153, + "subdir": "linux-64", + "timestamp": 1613320009819, + "version": "0.7.4" + }, + "cython-blis-0.7.4-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d59a6f2880076ca2787481eef06ec32", + "name": "cython-blis", + "sha256": "463f0449deb4caf3ef751a34575081eaffc07b4163a2c756feff14fcc34c35eb", + "size": 3816175, + "subdir": "linux-64", + "timestamp": 1613319170304, + "version": "0.7.4" + }, + "cython-blis-0.7.7-py310h9102076_0.tar.bz2": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f8d8b9d50190d4b804db91cc781c8f0", + "name": "cython-blis", + "sha256": "e4cb0fbd9fb709f15cf3fcb712319edd08d05f728ff40f4fbd23faed2e327f24", + "size": 4383243, + "subdir": "linux-64", + "timestamp": 1651220784169, + "version": "0.7.7" + }, + "cython-blis-0.7.7-py311hbed6279_0.tar.bz2": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d0b3d3923b59440ffeafa49c70d7bde6", + "name": "cython-blis", + "sha256": "0180283734193fa4d567449c760ea170a7c119df2895dadb035bd3b2f634eac9", + "size": 4411135, + "subdir": "linux-64", + "timestamp": 1676839688748, + "version": "0.7.7" + }, + "cython-blis-0.7.7-py37hce1f21e_0.tar.bz2": { + "build": "py37hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee101db9af3fb81734fb3109babfdf1b", + "name": "cython-blis", + "sha256": "27b87d3232fa68605f252c367f102d767142f3850a2d962c06853e24d8a70bc7", + "size": 3741438, + "subdir": "linux-64", + "timestamp": 1651220288651, + "version": "0.7.7" + }, + "cython-blis-0.7.7-py38hce1f21e_0.tar.bz2": { + "build": "py38hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f0cad5a8bf066589439dca021c71f3f", + "name": "cython-blis", + "sha256": "8d58c23710b8df2995f71d5ed7cd742489d61cb45224ae31bfbc5f8e8d8a4b90", + "size": 3743391, + "subdir": "linux-64", + "timestamp": 1651221265740, + "version": "0.7.7" + }, + "cython-blis-0.7.7-py39hce1f21e_0.tar.bz2": { + "build": "py39hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "49da12c85213d560b25b2dc7d102658d", + "name": "cython-blis", + "sha256": "88f5e55141e5cd7674da53bd4e424f412be8c99fa04467d3e3c32a5becfe8c66", + "size": 3744394, + "subdir": "linux-64", + "timestamp": 1651221749591, + "version": "0.7.7" + }, + "cytoolz-0.10.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "895bc3ab6f17fef8327a031d118dfe8a", + "name": "cytoolz", + "sha256": "e32f8890134f0daf3b4596d91cd4bf514b60a8ef194e5aa2d9606c7de8170ca1", + "size": 432097, + "subdir": "linux-64", + "timestamp": 1563285785610, + "version": "0.10.0" + }, + "cytoolz-0.10.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "07904e14b5f7679400e7eeaab50e012b", + "name": "cytoolz", + "sha256": "2518505ea20043dfea4be19688ad171dca307b91fc9ed38e2b70c6fd2c5d13aa", + "size": 450012, + "subdir": "linux-64", + "timestamp": 1563285784033, + "version": "0.10.0" + }, + "cytoolz-0.10.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "80a798a76b6ca97bf88a4aabcaa679e5", + "name": "cytoolz", + "sha256": "281bd141e67194dd591785b9722643a7d12147e781efbf5f0467833b908c6a9d", + "size": 435187, + "subdir": "linux-64", + "timestamp": 1563285780647, + "version": "0.10.0" + }, + "cytoolz-0.10.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "62fe96ad0f142c12e6caba4f5cff09b1", + "name": "cytoolz", + "sha256": "315ab14cc3e52e9613ad04f0cda4e4db1a4eb1e9a37bfb3f69e56759144dd48f", + "size": 436881, + "subdir": "linux-64", + "timestamp": 1573938366714, + "version": "0.10.1" + }, + "cytoolz-0.10.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "6ff48e08953ef409bf2d3a558947035e", + "name": "cytoolz", + "sha256": "a0b7a475ba161d76a5027a0b54c836a8d8919f1da45b09089c95b472980a76a1", + "size": 447984, + "subdir": "linux-64", + "timestamp": 1573938360278, + "version": "0.10.1" + }, + "cytoolz-0.10.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "471957c3531ba24c5d64c5c07d21b322", + "name": "cytoolz", + "sha256": "1854b0e99fd536f7a5e7d84f7777e7b3e2bb0f436e695debab044d5e9e7fc9fc", + "size": 447558, + "subdir": "linux-64", + "timestamp": 1573938360323, + "version": "0.10.1" + }, + "cytoolz-0.10.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "91c70c313ac771acbb54673fd7d48ed3", + "name": "cytoolz", + "sha256": "653f9d8c1aa8ef3d427950dcf32f2b46d33a4be79a35370ebce2cc6e34accb3e", + "size": 466974, + "subdir": "linux-64", + "timestamp": 1573938384226, + "version": "0.10.1" + }, + "cytoolz-0.10.1-py39he8ac12f_0.tar.bz2": { + "build": "py39he8ac12f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "67e48fbad6d473e1e43c3e980f3eb634", + "name": "cytoolz", + "sha256": "ed6e9b69adfe04906eed0256f7e9a17c36aee8d7d14651b7a50975f88bf3977d", + "size": 402630, + "subdir": "linux-64", + "timestamp": 1607025606657, + "version": "0.10.1" + }, + "cytoolz-0.11.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "c14527ffd1632bbd980221fa5dfb6136", + "name": "cytoolz", + "sha256": "5fcc7836a0cff33699e2c971a61163935e12cd5f616e4c09304a759732855082", + "size": 1422624, + "subdir": "linux-64", + "timestamp": 1640789408417, + "version": "0.11.0" + }, + "cytoolz-0.11.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "9d6d56bd22c3c6f68196d4d809c2fb00", + "name": "cytoolz", + "sha256": "b5c1ee89757b5105fb5bf06d7c0f56895b24a72754f71699fc6ac8307225f556", + "size": 384786, + "subdir": "linux-64", + "timestamp": 1600959022284, + "version": "0.11.0" + }, + "cytoolz-0.11.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "007c076796ba6b388b27c7d3879e2b09", + "name": "cytoolz", + "sha256": "03c2edf26bf122bb992f29788e799ca83cab3c2912daf965c2abfce71be36546", + "size": 376156, + "subdir": "linux-64", + "timestamp": 1600959048771, + "version": "0.11.0" + }, + "cytoolz-0.11.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "dcb18da6963d56ec55b36d092c18b137", + "name": "cytoolz", + "sha256": "551546153fbda8d618783ffe22c825e9f0ed09ee14c713cf2254c24b6a4795d0", + "size": 399499, + "subdir": "linux-64", + "timestamp": 1600959049930, + "version": "0.11.0" + }, + "cytoolz-0.11.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "b39f97a973f18978b5e87a187adb0898", + "name": "cytoolz", + "sha256": "b656bfa2cf7672b0b42fd27c17de82dbdbcf4bda623ab685a1ec50c3f995367b", + "size": 410934, + "subdir": "linux-64", + "timestamp": 1608061872700, + "version": "0.11.0" + }, + "cytoolz-0.12.0-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a6933cb7d67a97644f53d8db6603258", + "name": "cytoolz", + "sha256": "2ba64fe52a329b8c66259d68aa701464e3089cf46f7a80d3e68ee512e2897678", + "size": 390372, + "subdir": "linux-64", + "timestamp": 1667465990428, + "version": "0.12.0" + }, + "cytoolz-0.12.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8c3d312709322972d3d4a0c43d579e72", + "name": "cytoolz", + "sha256": "a850e18906723665232700e87ffa8d82ac939508f6cdc0fe66b442c4bca9b791", + "size": 414035, + "subdir": "linux-64", + "timestamp": 1676830435501, + "version": "0.12.0" + }, + "cytoolz-0.12.0-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "09ad5b35787cd3c53dd3919e3b27a99b", + "name": "cytoolz", + "sha256": "2fd3bea690863cb4d4a87e6f5b387ff852f8b6f50db5659178bef0ef2939eb79", + "size": 396229, + "subdir": "linux-64", + "timestamp": 1667466137592, + "version": "0.12.0" + }, + "cytoolz-0.12.0-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fcafb7c3b067c209c3569f254df6cd45", + "name": "cytoolz", + "sha256": "f7be3c1853a73b14dd43f1f9a9a777758f84aea4bb273f0ea330dae79f41f4e3", + "size": 403384, + "subdir": "linux-64", + "timestamp": 1667466087220, + "version": "0.12.0" + }, + "cytoolz-0.12.0-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4c34345079d18b1203746067dcd15042", + "name": "cytoolz", + "sha256": "aac94702b3d4e4767f0bbbe3f1acfa811e18a2abb66f3afac74a51ddc3d046d9", + "size": 394960, + "subdir": "linux-64", + "timestamp": 1667466037849, + "version": "0.12.0" + }, + "cytoolz-0.8.2-py27hf14aec9_0.tar.bz2": { + "build": "py27hf14aec9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "1f7ebd7de2101e63109e6917596b05ce", + "name": "cytoolz", + "sha256": "be571d710f26baae923bb4c9a5bc9be3acb7485b86d9272fd9299df86b3dbb7b", + "size": 365962, + "subdir": "linux-64", + "timestamp": 1505740196014, + "version": "0.8.2" + }, + "cytoolz-0.8.2-py35ha53021f_0.tar.bz2": { + "build": "py35ha53021f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "55d4f6a4fc2a934f8c808e061dbaf081", + "name": "cytoolz", + "sha256": "325791eb49aa72ebdbcbe2dca6d193f4c4a93b34aa7f85ed6b6d65a54a94eef4", + "size": 368960, + "subdir": "linux-64", + "timestamp": 1505740231317, + "version": "0.8.2" + }, + "cytoolz-0.8.2-py36h708bfd4_0.tar.bz2": { + "build": "py36h708bfd4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "92977087dc2a463e99a1d993f81f40dd", + "name": "cytoolz", + "sha256": "ab77acd49239414febafaf186c86c9e7c9e95ddc671ce7800966b65ae15735f3", + "size": 372473, + "subdir": "linux-64", + "timestamp": 1505740267776, + "version": "0.8.2" + }, + "cytoolz-0.9.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "6a9cf232e7f88c0162b528a2000319f0", + "name": "cytoolz", + "sha256": "0da21fbc2d64b5b42de5e4be847a3edf01ad386866dcede87e545d7ce910fe7b", + "size": 419962, + "subdir": "linux-64", + "timestamp": 1515794222549, + "version": "0.9.0" + }, + "cytoolz-0.9.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "78a584072ce03c27ac7bddc663d88787", + "name": "cytoolz", + "sha256": "d95a88be9ec56debff01f831a4958ee467f3a84cd1b7ec789fd78e1189ec06e8", + "size": 423813, + "subdir": "linux-64", + "timestamp": 1515794234739, + "version": "0.9.0" + }, + "cytoolz-0.9.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "779cae8eda221eb1352adfa7e57acbbe", + "name": "cytoolz", + "sha256": "3d388c72616cb640254bde405456e95e7137d23f97c5d864152feeaa0fc9f2de", + "size": 429351, + "subdir": "linux-64", + "timestamp": 1515794401867, + "version": "0.9.0" + }, + "cytoolz-0.9.0.1-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "4930c998e5a3ff0581759f2b2719b67a", + "name": "cytoolz", + "sha256": "69332826a4fec7bcc71517ed836861161d5de25802dc4ed45feaf9f429c5cc8a", + "size": 419852, + "subdir": "linux-64", + "timestamp": 1520374050863, + "version": "0.9.0.1" + }, + "cytoolz-0.9.0.1-py27h14c3975_1.tar.bz2": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "acef8f0b236dfbe6712a1143370ef044", + "name": "cytoolz", + "sha256": "e40ffbf6ab4c1054927a44eca59b3641a8638f30950fb4093cc0023da4573119", + "size": 419744, + "subdir": "linux-64", + "timestamp": 1530741613002, + "version": "0.9.0.1" + }, + "cytoolz-0.9.0.1-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "3f9453d8fa8c2608b6261654cd8f8e52", + "name": "cytoolz", + "sha256": "ba272bf7a8572e19137dbea0092bb9ecb9e67d62500b4c1232cb47d860a49f29", + "size": 423313, + "subdir": "linux-64", + "timestamp": 1520374373870, + "version": "0.9.0.1" + }, + "cytoolz-0.9.0.1-py35h14c3975_1.tar.bz2": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "1a563b8915106d64c48aef84f10b8387", + "name": "cytoolz", + "sha256": "78854881cf33182140deb0f9c8c8a0c8670c0680ec8c07352754707323732f5e", + "size": 423273, + "subdir": "linux-64", + "timestamp": 1534356589107, + "version": "0.9.0.1" + }, + "cytoolz-0.9.0.1-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "37dded47d90729fabb1d89030e87706e", + "name": "cytoolz", + "sha256": "2b54b43a43d0a3498d264a0fa3e0c61dd30cb4a3c6346fad02f61357f3c8a883", + "size": 428571, + "subdir": "linux-64", + "timestamp": 1520374393487, + "version": "0.9.0.1" + }, + "cytoolz-0.9.0.1-py36h14c3975_1.tar.bz2": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "47b8d87b5edb1acb8a25c7015fc5f360", + "name": "cytoolz", + "sha256": "7d69d75c31c7ad5e62672a94fdef636f89f968fb77a1232702ad784ec909ad17", + "size": 428620, + "subdir": "linux-64", + "timestamp": 1530741564377, + "version": "0.9.0.1" + }, + "cytoolz-0.9.0.1-py37h14c3975_1.tar.bz2": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "1a1ea96f3a083e3fd65ea2f1d626dd18", + "name": "cytoolz", + "sha256": "51c3faf23b64193560e8fa858211216162db383c19162c47a89387a48e310ea5", + "size": 427850, + "subdir": "linux-64", + "timestamp": 1530741663494, + "version": "0.9.0.1" + }, + "d2to1-0.2.12-py27ha563d29_0.tar.bz2": { + "build": "py27ha563d29_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c944e8333a523ee95ab594dc1891fce0", + "name": "d2to1", + "sha256": "17d9842fd714466da3f28e139421d4cfdae8249fc712ae13ce3c1b5c8926c9a6", + "size": 42305, + "subdir": "linux-64", + "timestamp": 1507376117241, + "version": "0.2.12" + }, + "d2to1-0.2.12-py35h68503a4_0.tar.bz2": { + "build": "py35h68503a4_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c44057e01004487b9ff65ff7eec50fc9", + "name": "d2to1", + "sha256": "8a768da724ce7fcf4af230bfd7e23e1e534aaa7f218c48e65d3383638435c689", + "size": 42857, + "subdir": "linux-64", + "timestamp": 1507376118675, + "version": "0.2.12" + }, + "d2to1-0.2.12-py36h2e3980f_0.tar.bz2": { + "build": "py36h2e3980f_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ae8a4d833d49f30309e9c9106ad6a9e8", + "name": "d2to1", + "sha256": "f6f8ccdc5841ce0ec4aa9490c3705172154c6c1852311152450222414a9c03d9", + "size": 42743, + "subdir": "linux-64", + "timestamp": 1507376126151, + "version": "0.2.12" + }, + "d2to1-0.2.12.post1-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d74b57b16e0be8c7b3e3ee20828ac5ec", + "name": "d2to1", + "sha256": "5b8e90d0f00b4e45f5135c5b1a43e6bb436a5bce066639138feb32ef8d8da2d9", + "size": 42057, + "subdir": "linux-64", + "timestamp": 1530812347919, + "version": "0.2.12.post1" + }, + "d2to1-0.2.12.post1-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1542cd69f5e095b920630800db985d68", + "name": "d2to1", + "sha256": "5204d25603e5b6faba84c630425c57a1f5998bd4b84a07131d380bc92e2ecc4f", + "size": 42686, + "subdir": "linux-64", + "timestamp": 1535130055326, + "version": "0.2.12.post1" + }, + "d2to1-0.2.12.post1-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7bfdfb56e54e14a36340755cbca0da4f", + "name": "d2to1", + "sha256": "02cd9ab6d0d30d4fac5284edf30c0532f0a6e15e11b49d1d8fe5372b24322f76", + "size": 42522, + "subdir": "linux-64", + "timestamp": 1530812397648, + "version": "0.2.12.post1" + }, + "d2to1-0.2.12.post1-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9b81949115d7858007cc12758572d9b6", + "name": "d2to1", + "sha256": "503d65fea7a4e76453366a0f7cbc5b9551bb19d59c4155650aa05e4e2b1403ec", + "size": 42499, + "subdir": "linux-64", + "timestamp": 1530812372303, + "version": "0.2.12.post1" + }, + "daal-2019.3-199.tar.bz2": { + "build": "199", + "build_number": 199, + "depends": [ + "tbb 2019.*" + ], + "md5": "bbeaaa659918bfc238ac5d34a2a8b3e3", + "name": "daal", + "sha256": "6d87fd92322289219bcdf44fe89e6be9acd86580b3d5520e1b3f76f516f28ab5", + "size": 64722339, + "subdir": "linux-64", + "timestamp": 1557261142178, + "version": "2019.3" + }, + "daal-2019.4-243.tar.bz2": { + "build": "243", + "build_number": 243, + "depends": [ + "tbb 2019.*" + ], + "md5": "7e251c42e2d2b89b966a330e00158ad2", + "name": "daal", + "sha256": "ffcef58c2236848fee31937c05bcb51da500ce7e9a44f1e2c2cba6af0612117a", + "size": 65954998, + "subdir": "linux-64", + "timestamp": 1559526392080, + "version": "2019.4" + }, + "daal-2020.0-166.tar.bz2": { + "build": "166", + "build_number": 166, + "depends": [ + "tbb 2020.*" + ], + "md5": "9a8e1551717529c567e4db1f5d83450c", + "name": "daal", + "sha256": "ce75f6682556f182fce6a6453a99d8312f0baa9d97c8554f889aaebbfe42a72f", + "size": 74926104, + "subdir": "linux-64", + "timestamp": 1580943817372, + "version": "2020.0" + }, + "daal-2020.1-217.tar.bz2": { + "build": "217", + "build_number": 217, + "depends": [ + "tbb 2020.*" + ], + "md5": "2acfd175c7691b1badc3ebc2eb9590d3", + "name": "daal", + "sha256": "cd1225bf6294cc4172d928c9a2e6f41f6fad98006f6decc7482004c013dfbb2b", + "size": 69413939, + "subdir": "linux-64", + "timestamp": 1589162126410, + "version": "2020.1" + }, + "daal-2020.2-256.tar.bz2": { + "build": "256", + "build_number": 256, + "depends": [ + "tbb 2020.*" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "1bb606a032e87a61a58c83737d92fd11", + "name": "daal", + "sha256": "c2416975039a2d1951ef428a256156207966e503f215c4ac40a83774a2e3c825", + "size": 70801074, + "subdir": "linux-64", + "timestamp": 1598384110431, + "version": "2020.2" + }, + "daal-2021.2.2-h06a4308_389.tar.bz2": { + "build": "h06a4308_389", + "build_number": 389, + "depends": [ + "dal >=2021.2.2,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "63fccb24298c5da676e31ca756c3319f", + "name": "daal", + "sha256": "e744636a1c519bcc979ca6b27bfae2ce76fb922bb1373ad649470f97cd559860", + "size": 15527, + "subdir": "linux-64", + "timestamp": 1619450726499, + "version": "2021.2.2" + }, + "daal-2021.3.0-h06a4308_557.tar.bz2": { + "build": "h06a4308_557", + "build_number": 557, + "depends": [ + "dal >=2021.3.0,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "be17f218488909c9121df4f1cf8f1506", + "name": "daal", + "sha256": "6499b5c8e6c60c538a4cff822e53f47095e8109ddee1d1d795fcddfdbd57f746", + "size": 15541, + "subdir": "linux-64", + "timestamp": 1626182304223, + "version": "2021.3.0" + }, + "daal-2021.4.0-h06a4308_729.tar.bz2": { + "build": "h06a4308_729", + "build_number": 729, + "depends": [ + "dal >=2021.4.0,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "37d4b75b48339cd222775b9827e60d41", + "name": "daal", + "sha256": "78995c49ab5e32d7da3d71b5cb9ad886ca62698bea999dfadfa5192b9a05d969", + "size": 19064, + "subdir": "linux-64", + "timestamp": 1634546773301, + "version": "2021.4.0" + }, + "daal-2021.5.1-h06a4308_803.tar.bz2": { + "build": "h06a4308_803", + "build_number": 803, + "depends": [ + "dal >=2021.5.1,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "437bb1368d32291cc1e12af0570be86d", + "name": "daal", + "sha256": "b46533858c127e0fc05f87118e9a10bd947ef66a37af2f2b8497fd2f12916639", + "size": 19506, + "subdir": "linux-64", + "timestamp": 1642705453107, + "version": "2021.5.1" + }, + "daal-2021.5.3-h06a4308_832.tar.bz2": { + "build": "h06a4308_832", + "build_number": 832, + "depends": [ + "dal >=2021.6.0,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "f8343b2143e1cf775e1c32f684219314", + "name": "daal", + "sha256": "899104201bccd97fd8b10551b8ba0a56a9f53b2ff99ed7954c7bb939b89f9506", + "size": 17754, + "subdir": "linux-64", + "timestamp": 1662087972574, + "version": "2021.5.3" + }, + "daal-2021.5.3-h06a4308_833.tar.bz2": { + "build": "h06a4308_833", + "build_number": 833, + "depends": [ + "dal >=2021.6.0,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "acab0f5870a65078c69ceccabc9e06ca", + "name": "daal", + "sha256": "0bad4fb5767a812b50cd66bd60f41341309e826d51b69fbf75f4673d22c0b5e1", + "size": 17831, + "subdir": "linux-64", + "timestamp": 1662497675506, + "version": "2021.5.3" + }, + "daal-devel-2019.3-199.tar.bz2": { + "build": "199", + "build_number": 199, + "depends": [ + "daal 2019.3 199", + "daal-include 2019.3 199" + ], + "md5": "29efe487b9f79734c7018a2f295547b4", + "name": "daal-devel", + "sha256": "55386f05275342eb0eb2f9807f451177172ce3a69c6e43296f919853008a83ed", + "size": 13037445, + "subdir": "linux-64", + "timestamp": 1557261294897, + "version": "2019.3" + }, + "daal-devel-2019.4-243.tar.bz2": { + "build": "243", + "build_number": 243, + "depends": [ + "daal 2019.4 243", + "daal-include 2019.4 243" + ], + "md5": "0443a2614f87ff2603d74a2e2df8080d", + "name": "daal-devel", + "sha256": "45b51446b78a2e356edcb3e5f9852f80c42b40469ad42ee16d9dc5aee7c1a65b", + "size": 13030419, + "subdir": "linux-64", + "timestamp": 1559526517475, + "version": "2019.4" + }, + "daal-devel-2020.0-166.tar.bz2": { + "build": "166", + "build_number": 166, + "depends": [ + "daal 2020.0 166", + "daal-include 2020.0 166" + ], + "md5": "173c785209adf486c6ca4bee08b9e489", + "name": "daal-devel", + "sha256": "678eece39dbeb03283919a6113e7f62e22fef85f16f0ea5cf4cf57085b769651", + "size": 13144265, + "subdir": "linux-64", + "timestamp": 1580943982397, + "version": "2020.0" + }, + "daal-devel-2020.1-217.tar.bz2": { + "build": "217", + "build_number": 217, + "depends": [ + "daal 2020.1 217", + "daal-include 2020.1 217" + ], + "md5": "fd06e46717bced7b2abc354f58d90f7f", + "name": "daal-devel", + "sha256": "4c7b25df0e712c506d51b55c1224da02d8359e79759374ea7eff042f6e1f341a", + "size": 13137474, + "subdir": "linux-64", + "timestamp": 1589162252866, + "version": "2020.1" + }, + "daal-devel-2020.2-256.tar.bz2": { + "build": "256", + "build_number": 256, + "depends": [ + "daal 2020.2 256", + "daal-include 2020.2 256" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "aa3be87a88f4c592c3e840d437740795", + "name": "daal-devel", + "sha256": "94591d51fe90fc31bf2b0840a5ef13b1b0859ad640fa82541afcbe524f80362d", + "size": 13156759, + "subdir": "linux-64", + "timestamp": 1598384201847, + "version": "2020.2" + }, + "daal-devel-2021.2.2-h06a4308_389.tar.bz2": { + "build": "h06a4308_389", + "build_number": 389, + "depends": [ + "dal-devel >=2021.2.2,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "e89ba34cdc84f705e3c2ec80c426fd24", + "name": "daal-devel", + "sha256": "c607fd180ef9f75a5197bafbfb728e94a7793cc063112d8dcf9fe69d9815ebe8", + "size": 15559, + "subdir": "linux-64", + "timestamp": 1619451486495, + "version": "2021.2.2" + }, + "daal-devel-2021.3.0-h06a4308_557.tar.bz2": { + "build": "h06a4308_557", + "build_number": 557, + "depends": [ + "dal-devel >=2021.3.0,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "5e5d5ca1d7e16aaa56d176180fb980f6", + "name": "daal-devel", + "sha256": "f55e7e0cea1f6d4861ca3ee41783ce8cca84b9a7329e1a245a7b197e84fde029", + "size": 15551, + "subdir": "linux-64", + "timestamp": 1626182866757, + "version": "2021.3.0" + }, + "daal-devel-2021.4.0-h06a4308_729.tar.bz2": { + "build": "h06a4308_729", + "build_number": 729, + "depends": [ + "dal-devel >=2021.4.0,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "f6acc1b4d231d8f8dfc3c4cd53a82b0f", + "name": "daal-devel", + "sha256": "bc04c46e1239215c1a1875b60fb196894258eb32e80339bc6410d380d0cf7e57", + "size": 19080, + "subdir": "linux-64", + "timestamp": 1634547335430, + "version": "2021.4.0" + }, + "daal-devel-2021.5.1-h06a4308_803.tar.bz2": { + "build": "h06a4308_803", + "build_number": 803, + "depends": [ + "dal-devel >=2021.5.1,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "7624a552a1b6ec3ff1f7008a39018b9a", + "name": "daal-devel", + "sha256": "c63e843e46ec95af9c6f2a0eb66582db23b3abd11df719c40cfd5f750c29b1f3", + "size": 19557, + "subdir": "linux-64", + "timestamp": 1642705972152, + "version": "2021.5.1" + }, + "daal-devel-2021.5.3-h06a4308_832.tar.bz2": { + "build": "h06a4308_832", + "build_number": 832, + "depends": [ + "dal-devel >=2021.6.0,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "c713f04495093c2e1a1e8590fc95633a", + "name": "daal-devel", + "sha256": "dfe913ccdb5a348577de139f352d8a71f262802ccbe5ab7f81a8523fc0a3a5de", + "size": 17774, + "subdir": "linux-64", + "timestamp": 1662088271186, + "version": "2021.5.3" + }, + "daal-devel-2021.5.3-h06a4308_833.tar.bz2": { + "build": "h06a4308_833", + "build_number": 833, + "depends": [ + "dal-devel >=2021.6.0,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "a9f6be0766f8658054247cc09eaf5c1d", + "name": "daal-devel", + "sha256": "f8e8d6b8203cd3413643e5e045242b22947fa1f71da1931d891f41970bade9b4", + "size": 17860, + "subdir": "linux-64", + "timestamp": 1662498032811, + "version": "2021.5.3" + }, + "daal-include-2019.3-199.tar.bz2": { + "build": "199", + "build_number": 199, + "depends": [], + "md5": "534f7be19a89068ffbcffb33298c9090", + "name": "daal-include", + "sha256": "bad1a634967b31efff043a0b9f739756097dc4883ae39f0a13a378fd929b9600", + "size": 324863, + "subdir": "linux-64", + "timestamp": 1557261289722, + "version": "2019.3" + }, + "daal-include-2019.4-243.tar.bz2": { + "build": "243", + "build_number": 243, + "depends": [], + "md5": "186e60731b87b6380e4cee23810e6f62", + "name": "daal-include", + "sha256": "cf38450a89d77279e5c90c4a95ff7af9ac7ba844fa22e0580584f1bb7ca32cae", + "size": 326133, + "subdir": "linux-64", + "timestamp": 1559526503951, + "version": "2019.4" + }, + "daal-include-2020.0-166.tar.bz2": { + "build": "166", + "build_number": 166, + "depends": [], + "md5": "bc5bd44d5873b6a715ecd52f4582cb28", + "name": "daal-include", + "sha256": "cf3c7b68548f05f3d75fefaffd98066aca1ef8b3e4eae8696b25588dded8a5dc", + "size": 363204, + "subdir": "linux-64", + "timestamp": 1580943967224, + "version": "2020.0" + }, + "daal-include-2020.1-217.tar.bz2": { + "build": "217", + "build_number": 217, + "depends": [], + "md5": "ee7df9c847696a83f85928479a964e2f", + "name": "daal-include", + "sha256": "4f90a34c977ec28aeff77acdbbba01f5de5fb292330c91a1ed01258398a29706", + "size": 367991, + "subdir": "linux-64", + "timestamp": 1589162236314, + "version": "2020.1" + }, + "daal-include-2020.2-256.tar.bz2": { + "build": "256", + "build_number": 256, + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "1fbd9999844f60ac5cd372fc5579c266", + "name": "daal-include", + "sha256": "c7562ed485ee368a321c8efb7dc5a0964553e1f1bd4ff901d5bdbee6cf009569", + "size": 370834, + "subdir": "linux-64", + "timestamp": 1598384188504, + "version": "2020.2" + }, + "daal-include-2021.2.2-h06a4308_389.tar.bz2": { + "build": "h06a4308_389", + "build_number": 389, + "depends": [ + "dal-include >=2021.2.2,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "bb40437ccacaa8e03f9dafb9c6f7e791", + "name": "daal-include", + "sha256": "ca6ff4a749033c3d18c7482b37f63c30e427615ab77f1b705fb39dd8f19543ba", + "size": 15561, + "subdir": "linux-64", + "timestamp": 1619450727630, + "version": "2021.2.2" + }, + "daal-include-2021.3.0-h06a4308_557.tar.bz2": { + "build": "h06a4308_557", + "build_number": 557, + "depends": [ + "dal-include >=2021.3.0,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "bcbcf322ffcd44cdce2e0a99afecbc3e", + "name": "daal-include", + "sha256": "c0768b1cdb334432bb99344fba00a07b9eadf03791c821ccc6ac9b0d2db2eb88", + "size": 15564, + "subdir": "linux-64", + "timestamp": 1626182305140, + "version": "2021.3.0" + }, + "daal-include-2021.4.0-h06a4308_729.tar.bz2": { + "build": "h06a4308_729", + "build_number": 729, + "depends": [ + "dal-include >=2021.4.0,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "5de45330c70da7fc54e17f7bb3805533", + "name": "daal-include", + "sha256": "78c4b1955769440e3330732cdaf991f8fea8d1f7fcc1ec0fbf4957bfafab7b77", + "size": 19094, + "subdir": "linux-64", + "timestamp": 1634546774158, + "version": "2021.4.0" + }, + "daal-include-2021.5.1-h06a4308_803.tar.bz2": { + "build": "h06a4308_803", + "build_number": 803, + "depends": [ + "dal-include >=2021.5.1,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "c1e890e38cdfc231cc2413317464761b", + "name": "daal-include", + "sha256": "9620987bbba338e6abc61513f52826e4a5a085e43a88dcd4b6cb901dca28902d", + "size": 19529, + "subdir": "linux-64", + "timestamp": 1642705454026, + "version": "2021.5.1" + }, + "daal-include-2021.5.3-h06a4308_832.tar.bz2": { + "build": "h06a4308_832", + "build_number": 832, + "depends": [ + "dal-include >=2021.6.0,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "37d4e3715d9ac8b5ab29205fa6a7b36e", + "name": "daal-include", + "sha256": "c0c5e3ddce5ea60d17b0579b23cd0b5120decfea45608913206db9b12847d90c", + "size": 17746, + "subdir": "linux-64", + "timestamp": 1662087973399, + "version": "2021.5.3" + }, + "daal-include-2021.5.3-h06a4308_833.tar.bz2": { + "build": "h06a4308_833", + "build_number": 833, + "depends": [ + "dal-include >=2021.6.0,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "800f4987a53fc9c847bbd2d62a1ee5cd", + "name": "daal-include", + "sha256": "6c84a25510157c1e3192450cfda1c782cd8a5d850e42a5d6d5cc94b2310d751e", + "size": 17826, + "subdir": "linux-64", + "timestamp": 1662497676411, + "version": "2021.5.3" + }, + "daal-static-2019.3-199.tar.bz2": { + "build": "199", + "build_number": 199, + "depends": [ + "daal-include 2019.3 199", + "tbb 2019.*" + ], + "md5": "81d60e9af5a5481c26c063caf9ec0092", + "name": "daal-static", + "sha256": "d84a08ea9fb1902fea7e15e78ab3dea17c86245333c4c404fba4fa336ccfca58", + "size": 124941158, + "subdir": "linux-64", + "timestamp": 1557261392744, + "version": "2019.3" + }, + "daal-static-2019.4-243.tar.bz2": { + "build": "243", + "build_number": 243, + "depends": [ + "daal-include 2019.4 243", + "tbb 2019.*" + ], + "md5": "809804b9c6f935712020e37f8d41e3b2", + "name": "daal-static", + "sha256": "78d6db23a1443dfacd5d5aca00f0a837771fd2ef7e2dacd6200a9cac40c7d795", + "size": 128000988, + "subdir": "linux-64", + "timestamp": 1559526587932, + "version": "2019.4" + }, + "daal-static-2020.0-166.tar.bz2": { + "build": "166", + "build_number": 166, + "depends": [ + "daal-include 2020.0 166", + "tbb 2020.*" + ], + "md5": "0e8a60116e929449f135c254f63309da", + "name": "daal-static", + "sha256": "f8426696943755c7113532f30ef7f729c0133fc72a51a5357476ad4bc5b5e009", + "size": 131822019, + "subdir": "linux-64", + "timestamp": 1580944071083, + "version": "2020.0" + }, + "daal-static-2020.1-217.tar.bz2": { + "build": "217", + "build_number": 217, + "depends": [ + "daal-include 2020.1 217", + "tbb 2020.*" + ], + "md5": "382eb12acbb3bfdd1647043a1e294c11", + "name": "daal-static", + "sha256": "49c3ee61f5e54a4e1c6b6bb3e5df8d233ed09c6e812b8e41a4e0ed49220f6985", + "size": 145266335, + "subdir": "linux-64", + "timestamp": 1589162346112, + "version": "2020.1" + }, + "daal-static-2020.2-256.tar.bz2": { + "build": "256", + "build_number": 256, + "depends": [ + "daal-include 2020.2 256", + "tbb 2020.*" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "721cd168c8904b5cba7875bf8ca17018", + "name": "daal-static", + "sha256": "4011902a889963ad5a82a8a06ba059a64cee1d65024e107d4fe580ad1ec17771", + "size": 149586621, + "subdir": "linux-64", + "timestamp": 1598384307842, + "version": "2020.2" + }, + "daal-static-2021.2.2-h06a4308_389.tar.bz2": { + "build": "h06a4308_389", + "build_number": 389, + "depends": [ + "dal-static >=2021.2.2,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "009680a2983be6d1e445fb9d9ef26e62", + "name": "daal-static", + "sha256": "736f638fe921a34306cd5a88228dfc8d1aeed698381594f97462d590b580b18d", + "size": 15558, + "subdir": "linux-64", + "timestamp": 1619451487731, + "version": "2021.2.2" + }, + "daal-static-2021.3.0-h06a4308_557.tar.bz2": { + "build": "h06a4308_557", + "build_number": 557, + "depends": [ + "dal-static >=2021.3.0,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "710c5bc4b979bf8991e767ec44ab0889", + "name": "daal-static", + "sha256": "fa97685a30ee3983388b52c5b5255404e390087dd4d5166f16f79878ca23528b", + "size": 15553, + "subdir": "linux-64", + "timestamp": 1626182867666, + "version": "2021.3.0" + }, + "daal-static-2021.4.0-h06a4308_729.tar.bz2": { + "build": "h06a4308_729", + "build_number": 729, + "depends": [ + "dal-static >=2021.4.0,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "4570a2b747c34925b1bfb1cb6ac6e4c3", + "name": "daal-static", + "sha256": "507f1fe5c12f261b4e1ab82dfc663f59761406eb7a6deea74457763cc30dd889", + "size": 19055, + "subdir": "linux-64", + "timestamp": 1634547336292, + "version": "2021.4.0" + }, + "daal-static-2021.5.1-h06a4308_803.tar.bz2": { + "build": "h06a4308_803", + "build_number": 803, + "depends": [ + "dal-static >=2021.5.1,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "8e9c19c4705d05276e51f20c784e3f89", + "name": "daal-static", + "sha256": "262569cf90ec9efd3be81e3bc257801bf78566d65cd832f9720924db1befdae3", + "size": 19514, + "subdir": "linux-64", + "timestamp": 1642705973048, + "version": "2021.5.1" + }, + "daal-static-2021.5.3-h06a4308_832.tar.bz2": { + "build": "h06a4308_832", + "build_number": 832, + "depends": [ + "dal-static >=2021.6.0,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "a30e20020713ee953596cf178b69badd", + "name": "daal-static", + "sha256": "b5652a759ed1cd166b76cc7e39da1eb29f69c9933c5228d476adeb323caaab5e", + "size": 17748, + "subdir": "linux-64", + "timestamp": 1662088272014, + "version": "2021.5.3" + }, + "daal-static-2021.5.3-h06a4308_833.tar.bz2": { + "build": "h06a4308_833", + "build_number": 833, + "depends": [ + "dal-static >=2021.6.0,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "49b339e5712ba4fb11d551bff4cb7396", + "name": "daal-static", + "sha256": "c94451ebbcae232e88de4facde61b6ca085a02b3649813731f1b09fb675c2a33", + "size": 17847, + "subdir": "linux-64", + "timestamp": 1662498033717, + "version": "2021.5.3" + }, + "daal4py-2021.2.2-py36ha9443f7_0.tar.bz2": { + "build": "py36ha9443f7_0", + "build_number": 0, + "depends": [ + "dal >=2021.2.2,<2021.2.3.0a0", + "dal >=2021.2.2,<2022.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "981e7d32c71ff847b6d9e9541bf22800", + "name": "daal4py", + "sha256": "6cc259a2093408d8bf9d36847b1ac924fbff4c3d4f6cc95ec20796b458860912", + "size": 12901188, + "subdir": "linux-64", + "timestamp": 1619794968395, + "version": "2021.2.2" + }, + "daal4py-2021.2.2-py37ha9443f7_0.tar.bz2": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "dal >=2021.2.2,<2021.2.3.0a0", + "dal >=2021.2.2,<2022.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "e42ec951bf065184d8e4f6b02f0208c4", + "name": "daal4py", + "sha256": "87a6d782b367bea39201de14b6297546674be98dde84feb1bbf4f96606b8f2a2", + "size": 12864361, + "subdir": "linux-64", + "timestamp": 1619794950600, + "version": "2021.2.2" + }, + "daal4py-2021.2.2-py38ha9443f7_0.tar.bz2": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "dal >=2021.2.2,<2021.2.3.0a0", + "dal >=2021.2.2,<2022.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "3604982c038199980dd7f6423440249a", + "name": "daal4py", + "sha256": "a9d65b057bafb64f9d693f888bc717e994606c416ad73335a08f08be7081b907", + "size": 12885338, + "subdir": "linux-64", + "timestamp": 1619794977069, + "version": "2021.2.2" + }, + "daal4py-2021.2.2-py39ha9443f7_0.tar.bz2": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "dal >=2021.2.2,<2021.2.3.0a0", + "dal >=2021.2.2,<2022.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "627d1b05160c726e4ea02a934075e5db", + "name": "daal4py", + "sha256": "efec904d6df507674118e5110246683a2ba71e12bf2d14bd232c6e40847c2a90", + "size": 12985750, + "subdir": "linux-64", + "timestamp": 1619791204527, + "version": "2021.2.2" + }, + "daal4py-2021.3.0-py36hae6d005_0.tar.bz2": { + "build": "py36hae6d005_0", + "build_number": 0, + "depends": [ + "dal >=2021.3.0,<2021.3.1.0a0", + "dal >=2021.3.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "43c78accf939ad34b8ada70965c68c9b", + "name": "daal4py", + "sha256": "c9b17ede64376669e020a7246cf70636417bb7fdfe1ae9f429954423ef337267", + "size": 13085779, + "subdir": "linux-64", + "timestamp": 1626272868402, + "version": "2021.3.0" + }, + "daal4py-2021.3.0-py37hae6d005_0.tar.bz2": { + "build": "py37hae6d005_0", + "build_number": 0, + "depends": [ + "dal >=2021.3.0,<2021.3.1.0a0", + "dal >=2021.3.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "2fc23d3ad2752a20dccd3c3371381dad", + "name": "daal4py", + "sha256": "69d18b0a082fa6d83d40fd3ef6cbe621aaadeb5b6f49a647673b7520d7277d29", + "size": 13087677, + "subdir": "linux-64", + "timestamp": 1626272844358, + "version": "2021.3.0" + }, + "daal4py-2021.3.0-py38hae6d005_0.tar.bz2": { + "build": "py38hae6d005_0", + "build_number": 0, + "depends": [ + "dal >=2021.3.0,<2021.3.1.0a0", + "dal >=2021.3.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "1790509fc2865b43949595a181016a05", + "name": "daal4py", + "sha256": "f12546101facf8b00916828989ae773f1ab2aa466f66d77d1cde54029d94a6e8", + "size": 13108900, + "subdir": "linux-64", + "timestamp": 1626272457850, + "version": "2021.3.0" + }, + "daal4py-2021.3.0-py39hae6d005_0.tar.bz2": { + "build": "py39hae6d005_0", + "build_number": 0, + "depends": [ + "dal >=2021.3.0,<2021.3.1.0a0", + "dal >=2021.3.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "71a58ebd04bdeb877f028ef9c89d7f50", + "name": "daal4py", + "sha256": "ca59c7c830421e5a5f02df80b256679cfa41b64c2eea3c5ae9e72b4bb267c246", + "size": 13098292, + "subdir": "linux-64", + "timestamp": 1626272853486, + "version": "2021.3.0" + }, + "daal4py-2021.4.0-py310h00b725a_0.tar.bz2": { + "build": "py310h00b725a_0", + "build_number": 0, + "depends": [ + "dal 2021.4.0.*", + "dal >=2021.4.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "467a06b8a7d1812f8d2229e244cfdd8f", + "name": "daal4py", + "sha256": "9727c40da9d2d86be7a00734399b42214eed909b86d45fa95c1ef904dce56662", + "size": 23830825, + "subdir": "linux-64", + "timestamp": 1640805351352, + "version": "2021.4.0" + }, + "daal4py-2021.4.0-py37h78b71dc_0.tar.bz2": { + "build": "py37h78b71dc_0", + "build_number": 0, + "depends": [ + "dal 2021.4.0.*", + "dal >=2021.4.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "84e4566707adfb0fd0a0ce438dec0b28", + "name": "daal4py", + "sha256": "df54fe9d0609e3b48af6b48060afa9b8a792a5e33276d8cb4f348b6c7fa5ed36", + "size": 13244570, + "subdir": "linux-64", + "timestamp": 1638306307426, + "version": "2021.4.0" + }, + "daal4py-2021.4.0-py38h78b71dc_0.tar.bz2": { + "build": "py38h78b71dc_0", + "build_number": 0, + "depends": [ + "dal 2021.4.0.*", + "dal >=2021.4.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "e1d6292cefaaf2f3964e1ac81b66ebca", + "name": "daal4py", + "sha256": "ff966cce4a13b49ae9acb7b2db12ca8b4ca0c6364cbfe5050175654b55f9c44f", + "size": 13360279, + "subdir": "linux-64", + "timestamp": 1638306197776, + "version": "2021.4.0" + }, + "daal4py-2021.4.0-py39h78b71dc_0.tar.bz2": { + "build": "py39h78b71dc_0", + "build_number": 0, + "depends": [ + "dal 2021.4.0.*", + "dal >=2021.4.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "ab54b365a3083e0377da70a14a6a9d48", + "name": "daal4py", + "sha256": "63f475c598f11387a93cdeca4e26f535e623d57c01912dd954d563f042bdb702", + "size": 13275654, + "subdir": "linux-64", + "timestamp": 1638306274736, + "version": "2021.4.0" + }, + "daal4py-2021.5.0-py37h78b71dc_0.tar.bz2": { + "build": "py37h78b71dc_0", + "build_number": 0, + "depends": [ + "dal 2021.5.1.*", + "dal >=2021.5.1,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "af445cae04f924bdfe1f7707532acc84", + "name": "daal4py", + "sha256": "57c4194f786a5d1ff38de89d0a442b1b25c59dfdce89048f0df6d6e7fc97cc51", + "size": 13325111, + "subdir": "linux-64", + "timestamp": 1644854009330, + "version": "2021.5.0" + }, + "daal4py-2021.5.0-py38h78b71dc_0.tar.bz2": { + "build": "py38h78b71dc_0", + "build_number": 0, + "depends": [ + "dal 2021.5.1.*", + "dal >=2021.5.1,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "21bbcd7c4d845637f74a99676a710718", + "name": "daal4py", + "sha256": "e59d9f6f5ec660df17914163e41abca4e31c46ebcb5682acc30719d3d08816c2", + "size": 13385044, + "subdir": "linux-64", + "timestamp": 1644835864053, + "version": "2021.5.0" + }, + "daal4py-2021.5.0-py39h78b71dc_0.tar.bz2": { + "build": "py39h78b71dc_0", + "build_number": 0, + "depends": [ + "dal 2021.5.1.*", + "dal >=2021.5.1,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "7520b70c2d77794c7734e4c13c2789ac", + "name": "daal4py", + "sha256": "33f513714c4aa4efadc9e506a9e236eb6b84f7de8868c30d0a22792f4e3da2e2", + "size": 13436843, + "subdir": "linux-64", + "timestamp": 1644853994003, + "version": "2021.5.0" + }, + "daal4py-2021.6.0-py310h3c18c91_0.tar.bz2": { + "build": "py310h3c18c91_0", + "build_number": 0, + "depends": [ + "dal ==2021.6.0 hdb19cb5_916", + "dal >=2021.6.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "77b75709c0cc70d961e65a614ce9b83f", + "name": "daal4py", + "sha256": "fac3aa7dc0bb6c342611f5f4d9bc76d77a8b50323698ff4b9122c827db9f7388", + "size": 26633850, + "subdir": "linux-64", + "timestamp": 1664228496522, + "version": "2021.6.0" + }, + "daal4py-2021.6.0-py310h3c18c91_1.tar.bz2": { + "build": "py310h3c18c91_1", + "build_number": 1, + "depends": [ + "dal ==2021.6.0 hdb19cb5_916", + "dal >=2021.6.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d56fee2785a7f1769330ea1064223178", + "name": "daal4py", + "sha256": "548bd6979fe6ac8102ab0b9ab051004cb3e9b1a61d83a89f3455464229d7a439", + "size": 26638808, + "subdir": "linux-64", + "timestamp": 1664830724086, + "version": "2021.6.0" + }, + "daal4py-2021.6.0-py37h79cecc1_0.tar.bz2": { + "build": "py37h79cecc1_0", + "build_number": 0, + "depends": [ + "dal ==2021.6.0 hdb19cb5_916", + "dal >=2021.6.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "157f8a1b3d4d68a76bd4cc2f0ff42906", + "name": "daal4py", + "sha256": "24598225886bbd57665c0c630d89b4f932e0f090278817f66ddfe278b64e353b", + "size": 13557457, + "subdir": "linux-64", + "timestamp": 1664227899693, + "version": "2021.6.0" + }, + "daal4py-2021.6.0-py37h79cecc1_1.tar.bz2": { + "build": "py37h79cecc1_1", + "build_number": 1, + "depends": [ + "dal ==2021.6.0 hdb19cb5_916", + "dal >=2021.6.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e9c7918bad3d52abb40ef2f1e6e1ff7d", + "name": "daal4py", + "sha256": "9b66584f7dafdaf40084823300aac193b1c9413554046fb21a93168ed920335a", + "size": 13864984, + "subdir": "linux-64", + "timestamp": 1664830131169, + "version": "2021.6.0" + }, + "daal4py-2021.6.0-py38h79cecc1_0.tar.bz2": { + "build": "py38h79cecc1_0", + "build_number": 0, + "depends": [ + "dal ==2021.6.0 hdb19cb5_916", + "dal >=2021.6.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b98055380967c3313c54d70579bd21cd", + "name": "daal4py", + "sha256": "5e54f3ef7644a945beada0201a8cd0022db2a069da672604dcd7699af269bc71", + "size": 13588788, + "subdir": "linux-64", + "timestamp": 1664228187239, + "version": "2021.6.0" + }, + "daal4py-2021.6.0-py38h79cecc1_1.tar.bz2": { + "build": "py38h79cecc1_1", + "build_number": 1, + "depends": [ + "dal ==2021.6.0 hdb19cb5_916", + "dal >=2021.6.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c79fd96c68fff17b6eb09ffe4a489c5d", + "name": "daal4py", + "sha256": "c67c53a40642528b526ba18490f58ee937a902a5a409b3c222b21f04e5948b26", + "size": 13885491, + "subdir": "linux-64", + "timestamp": 1664829825882, + "version": "2021.6.0" + }, + "daal4py-2021.6.0-py39h79cecc1_0.tar.bz2": { + "build": "py39h79cecc1_0", + "build_number": 0, + "depends": [ + "dal ==2021.6.0 hdb19cb5_916", + "dal >=2021.6.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1f81dac6a4440f72ea22ffb2b0138682", + "name": "daal4py", + "sha256": "623d28da3b6eb38942064fcac5d26754db9bad26538d665edcc5957c6a1cb3e6", + "size": 13876337, + "subdir": "linux-64", + "timestamp": 1664227579133, + "version": "2021.6.0" + }, + "daal4py-2021.6.0-py39h79cecc1_1.tar.bz2": { + "build": "py39h79cecc1_1", + "build_number": 1, + "depends": [ + "dal ==2021.6.0 hdb19cb5_916", + "dal >=2021.6.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "69a33a5dfc7ea6f21ec35c8981726879", + "name": "daal4py", + "sha256": "02fe501f56ced1a0376e898a09f8b7d99851ae34b8a33f6ad712289ff08d9a40", + "size": 13878321, + "subdir": "linux-64", + "timestamp": 1664830402894, + "version": "2021.6.0" + }, + "daal4py-2023.0.2-py310h3c18c91_0.tar.bz2": { + "build": "py310h3c18c91_0", + "build_number": 0, + "depends": [ + "dal 2023.0.1.*", + "dal >=2023.0.1,<2024.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "574b75fbe086f4550dc14bbf8efc55f7", + "name": "daal4py", + "sha256": "5e88e2ef8559008e78c90b8ff52bc171c00a6124196266b061cb6818d2ccf234", + "size": 13932802, + "subdir": "linux-64", + "timestamp": 1677604431121, + "version": "2023.0.2" + }, + "daal4py-2023.0.2-py311heed92f4_0.tar.bz2": { + "build": "py311heed92f4_0", + "build_number": 0, + "depends": [ + "dal 2023.0.1.*", + "dal >=2023.0.1,<2024.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9648e9fb7cb11d524d204a9683ec6b2b", + "name": "daal4py", + "sha256": "104324a0d04d064ad4c7fbbb2df7eb9f5ca1693336056153828fc2a19864316e", + "size": 14004195, + "subdir": "linux-64", + "timestamp": 1678300835045, + "version": "2023.0.2" + }, + "daal4py-2023.0.2-py38h79cecc1_0.tar.bz2": { + "build": "py38h79cecc1_0", + "build_number": 0, + "depends": [ + "dal 2023.0.1.*", + "dal >=2023.0.1,<2024.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0d8f2f2c8ddb0f8190ec4a4243e8b959", + "name": "daal4py", + "sha256": "1acb3dfebce99b325f293cb689444756b3624ce9a9eb5f8a308e09bede56bc3b", + "size": 13947778, + "subdir": "linux-64", + "timestamp": 1677604916664, + "version": "2023.0.2" + }, + "daal4py-2023.0.2-py39h79cecc1_0.tar.bz2": { + "build": "py39h79cecc1_0", + "build_number": 0, + "depends": [ + "dal 2023.0.1.*", + "dal >=2023.0.1,<2024.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c7d5a583da7fab7fe168f8563944a687", + "name": "daal4py", + "sha256": "15daed3d27287f77173d683fd52940ecc11672efc7e00f87ad6972bc3e58d23d", + "size": 13937824, + "subdir": "linux-64", + "timestamp": 1677605429450, + "version": "2023.0.2" + }, + "dal-2021.2.2-h06a4308_389.tar.bz2": { + "build": "h06a4308_389", + "build_number": 389, + "depends": [ + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "b213530d64bf2bf2b68a8a86b7ecc166", + "name": "dal", + "sha256": "9cbb1345d7efc75c1c3166bdf5bd3926fc1f405bd97ee84a3285745fb0ff5347", + "size": 79714213, + "subdir": "linux-64", + "timestamp": 1619450593041, + "version": "2021.2.2" + }, + "dal-2021.3.0-h06a4308_557.tar.bz2": { + "build": "h06a4308_557", + "build_number": 557, + "depends": [ + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "179370bb3f63f30cea95fffe59ad9c44", + "name": "dal", + "sha256": "420deb76e9e2984db034a56973f54a17a7a712d6cb98c770b1eda37c72adb115", + "size": 74103828, + "subdir": "linux-64", + "timestamp": 1626182192769, + "version": "2021.3.0" + }, + "dal-2021.4.0-h06a4308_729.tar.bz2": { + "build": "h06a4308_729", + "build_number": 729, + "depends": [ + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "af746bd64d0758d5222f36b8d8e12a38", + "name": "dal", + "sha256": "80e51d01bb0a7ac1c52c2e2a3e6eed6e5890e87f25a1f582c43b55c92b75b044", + "size": 74171839, + "subdir": "linux-64", + "timestamp": 1634546657748, + "version": "2021.4.0" + }, + "dal-2021.5.1-h06a4308_803.tar.bz2": { + "build": "h06a4308_803", + "build_number": 803, + "depends": [ + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "ac187998c6648cf13a850d2ade34d7d5", + "name": "dal", + "sha256": "72baf4a02a0e18d5b58ad779d0f967495a834a497cad0fcc34a8cf572a4b1eac", + "size": 69164336, + "subdir": "linux-64", + "timestamp": 1642705328174, + "version": "2021.5.1" + }, + "dal-2021.6.0-hdb19cb5_915.tar.bz2": { + "build": "hdb19cb5_915", + "build_number": 915, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "4c19adc1a6adf107e2dffcda1af57c3a", + "name": "dal", + "sha256": "82e71c282ee674d16ad9906dc8241e8340034ad56c7ed0b79430b71fcce1bd41", + "size": 66573382, + "subdir": "linux-64", + "timestamp": 1662087883995, + "version": "2021.6.0" + }, + "dal-2021.6.0-hdb19cb5_916.tar.bz2": { + "build": "hdb19cb5_916", + "build_number": 916, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "e6abab87acdd8d11db3f1ec01405685e", + "name": "dal", + "sha256": "7f2f40d5b3afdb8d1987e1c9e596f89f9a707d5d79a6bdb9f69cd13cb51904d5", + "size": 66642018, + "subdir": "linux-64", + "timestamp": 1662497571830, + "version": "2021.6.0" + }, + "dal-2023.0.1-hdb19cb5_26647.tar.bz2": { + "build": "hdb19cb5_26647", + "build_number": 26647, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "fb050b727f3caee40f16f68763622e72", + "name": "dal", + "sha256": "6dd2b3e917feeced70fa5e30dd1bf5dce73d86e5bb124434cd4a0ee958a4ca88", + "size": 62086238, + "subdir": "linux-64", + "timestamp": 1677516427897, + "version": "2023.0.1" + }, + "dal-devel-2021.2.2-h06a4308_389.tar.bz2": { + "build": "h06a4308_389", + "build_number": 389, + "depends": [ + "dal 2021.2.2 h06a4308_389", + "dal-include 2021.2.2 h06a4308_389" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "7c83091996ac7edc87503bf1d096a347", + "name": "dal-devel", + "sha256": "bb4c802810915a6a9da120edfb36f6183fde1d613e2cd2e47962a15a72e105dd", + "size": 18239, + "subdir": "linux-64", + "timestamp": 1619450730892, + "version": "2021.2.2" + }, + "dal-devel-2021.3.0-h06a4308_557.tar.bz2": { + "build": "h06a4308_557", + "build_number": 557, + "depends": [ + "dal 2021.3.0 h06a4308_557", + "dal-include 2021.3.0 h06a4308_557" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "7104208d47bf1e6dfe6e96f36ed40f59", + "name": "dal-devel", + "sha256": "565ceb2499df93855bdb9495f9915944b230b03d39f984e4d3c9061043d5bf2b", + "size": 10268939, + "subdir": "linux-64", + "timestamp": 1626182308121, + "version": "2021.3.0" + }, + "dal-devel-2021.4.0-h06a4308_729.tar.bz2": { + "build": "h06a4308_729", + "build_number": 729, + "depends": [ + "dal 2021.4.0 h06a4308_729", + "dal-include 2021.4.0 h06a4308_729" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "ea412e1a52b981cbbaf76569116c028d", + "name": "dal-devel", + "sha256": "b2564e391af7e9b66163e3dc3f236a6981d2a1aedc8822f5d00e0cdf2e327dcd", + "size": 10863474, + "subdir": "linux-64", + "timestamp": 1634546777134, + "version": "2021.4.0" + }, + "dal-devel-2021.5.1-h06a4308_803.tar.bz2": { + "build": "h06a4308_803", + "build_number": 803, + "depends": [ + "dal 2021.5.1 h06a4308_803", + "dal-include 2021.5.1 h06a4308_803" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "ec8fb5ad04950e71054524210bb595cc", + "name": "dal-devel", + "sha256": "d8d82c22f53e91ab56b54ca5023a85c422a7d989eb6f4fd7df4d0c2e331850af", + "size": 11211104, + "subdir": "linux-64", + "timestamp": 1642705457040, + "version": "2021.5.1" + }, + "dal-devel-2021.6.0-hdb19cb5_915.tar.bz2": { + "build": "hdb19cb5_915", + "build_number": 915, + "depends": [ + "dal 2021.6.0 hdb19cb5_915", + "dal-include 2021.6.0 h06a4308_915", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "686a2b7f74da76990c7fd6bd1cbe8ba0", + "name": "dal-devel", + "sha256": "aca434d8a78de621814402e3d5d06331b2961f99ff66d03dde98a10c306e665f", + "size": 19182076, + "subdir": "linux-64", + "timestamp": 1662087980287, + "version": "2021.6.0" + }, + "dal-devel-2021.6.0-hdb19cb5_916.tar.bz2": { + "build": "hdb19cb5_916", + "build_number": 916, + "depends": [ + "dal 2021.6.0 hdb19cb5_916", + "dal-include 2021.6.0 h06a4308_916", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "c130b27b09d344c4565490627f110c2e", + "name": "dal-devel", + "sha256": "00e4cf32a74c63b2a047ab83272bbbdc0c415abd78b26ca660e0aee5be73850c", + "size": 19153292, + "subdir": "linux-64", + "timestamp": 1662497683321, + "version": "2021.6.0" + }, + "dal-devel-2023.0.1-hdb19cb5_26647.tar.bz2": { + "build": "hdb19cb5_26647", + "build_number": 26647, + "depends": [ + "dal 2023.0.1 hdb19cb5_26647", + "dal-include 2023.0.1 h06a4308_26647", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "7ced1929e0221e71c3415cfefa283982", + "name": "dal-devel", + "sha256": "2fdb5d20f39df198ff46faa8ef52cea45d0c015246da61cd5b7332c1d900ebcd", + "size": 8817231, + "subdir": "linux-64", + "timestamp": 1677516529341, + "version": "2023.0.1" + }, + "dal-include-2021.2.2-h06a4308_389.tar.bz2": { + "build": "h06a4308_389", + "build_number": 389, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "5e14c489c1a4db3a713854e2cc93ffe8", + "name": "dal-include", + "sha256": "863359ae3e0877e1a08dbd423e69f7a497fdcb46a450c40343dbdc6ec52f634d", + "size": 398564, + "subdir": "linux-64", + "timestamp": 1619450713265, + "version": "2021.2.2" + }, + "dal-include-2021.3.0-h06a4308_557.tar.bz2": { + "build": "h06a4308_557", + "build_number": 557, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "6880c912650b9934b5c5d7feeac37f0e", + "name": "dal-include", + "sha256": "d3159cf63e8dc3cca36d1004f1f824a23099f1f92a9c50067bc205d625c1c730", + "size": 418613, + "subdir": "linux-64", + "timestamp": 1626182291438, + "version": "2021.3.0" + }, + "dal-include-2021.4.0-h06a4308_729.tar.bz2": { + "build": "h06a4308_729", + "build_number": 729, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "0d8852542adb283f41bd0eb0ea037a89", + "name": "dal-include", + "sha256": "f1b39f7f3aa8e77e631d29c294a6cc94448a82480999316a2c97fc0f4d17418b", + "size": 423268, + "subdir": "linux-64", + "timestamp": 1634546755565, + "version": "2021.4.0" + }, + "dal-include-2021.5.1-h06a4308_803.tar.bz2": { + "build": "h06a4308_803", + "build_number": 803, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "887748f7f020ebd119011340e337d267", + "name": "dal-include", + "sha256": "62449cbb8f72c86090e93e1d8834f3fabff76c283e88929fc0c3c5af14def9ce", + "size": 431736, + "subdir": "linux-64", + "timestamp": 1642705434991, + "version": "2021.5.1" + }, + "dal-include-2021.6.0-h06a4308_915.tar.bz2": { + "build": "h06a4308_915", + "build_number": 915, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "02ab7fde351d2843517414ba3d6d38e3", + "name": "dal-include", + "sha256": "d2d924a39a8fcb2c6c62cf97ceeddb31d29bb24d328981ddb39b67b20391098d", + "size": 431876, + "subdir": "linux-64", + "timestamp": 1662087953807, + "version": "2021.6.0" + }, + "dal-include-2021.6.0-h06a4308_916.tar.bz2": { + "build": "h06a4308_916", + "build_number": 916, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "ca19e9228af0f17256dba304f1b9cd20", + "name": "dal-include", + "sha256": "c15058a27abd72b1de461024673042d755ab674810e8d9a44fb7fd9e7911a01d", + "size": 431824, + "subdir": "linux-64", + "timestamp": 1662497655070, + "version": "2021.6.0" + }, + "dal-include-2023.0.1-h06a4308_26647.tar.bz2": { + "build": "h06a4308_26647", + "build_number": 26647, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "61f8a1106117cec8d7aaf16fca66fd73", + "name": "dal-include", + "sha256": "b00bc44b0795c929b543bc07b11e514cf294f24e853861f489379359e90b847c", + "size": 431197, + "subdir": "linux-64", + "timestamp": 1677516497343, + "version": "2023.0.1" + }, + "dal-static-2021.2.2-h06a4308_389.tar.bz2": { + "build": "h06a4308_389", + "build_number": 389, + "depends": [ + "dal-include 2021.2.2 h06a4308_389", + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "80c263c4ce31b1edd8282da664f7a378", + "name": "dal-static", + "sha256": "81dc557a6c6f9a0e7873086dcaabb1f41371e89c00a995a0495f2f6c260222a3", + "size": 221315331, + "subdir": "linux-64", + "timestamp": 1619450736494, + "version": "2021.2.2" + }, + "dal-static-2021.3.0-h06a4308_557.tar.bz2": { + "build": "h06a4308_557", + "build_number": 557, + "depends": [ + "dal-include 2021.3.0 h06a4308_557", + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "700c86db4984a7c3eaeecc7fceb3ac5f", + "name": "dal-static", + "sha256": "0c850ec65f4c1a340ca653ee10aae4f9e92147d947ebc48c66795b8247888b2c", + "size": 222771287, + "subdir": "linux-64", + "timestamp": 1626182332261, + "version": "2021.3.0" + }, + "dal-static-2021.4.0-h06a4308_729.tar.bz2": { + "build": "h06a4308_729", + "build_number": 729, + "depends": [ + "dal-include 2021.4.0 h06a4308_729", + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "2b08a945a948afd3f4475aa79f1a9326", + "name": "dal-static", + "sha256": "57e8eb99c36896bf3f73c79ff9c7c7b9c49b8b8da780022bb46fc61fdc0963c0", + "size": 192821391, + "subdir": "linux-64", + "timestamp": 1634546801991, + "version": "2021.4.0" + }, + "dal-static-2021.5.1-h06a4308_803.tar.bz2": { + "build": "h06a4308_803", + "build_number": 803, + "depends": [ + "dal-include 2021.5.1 h06a4308_803", + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "e9956418110703aa3d15a00dbef22ab4", + "name": "dal-static", + "sha256": "0e9bb4b4f01612ead0f846ea4c801ba1d6075111ff8a2e940dbcb0f264065ba9", + "size": 180321286, + "subdir": "linux-64", + "timestamp": 1642705490332, + "version": "2021.5.1" + }, + "dal-static-2021.6.0-hdb19cb5_915.tar.bz2": { + "build": "hdb19cb5_915", + "build_number": 915, + "depends": [ + "dal-include 2021.6.0 h06a4308_915", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "b911e121780bbeb7d4221e8b8887b77b", + "name": "dal-static", + "sha256": "cb6cee7a80a0da1a292d3b33ed40079b3c11c7550bd39673c965abd1089c7283", + "size": 181469025, + "subdir": "linux-64", + "timestamp": 1662088009779, + "version": "2021.6.0" + }, + "dal-static-2021.6.0-hdb19cb5_916.tar.bz2": { + "build": "hdb19cb5_916", + "build_number": 916, + "depends": [ + "dal-include 2021.6.0 h06a4308_916", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "77a986561d71d591144036faa5d63722", + "name": "dal-static", + "sha256": "b68c5821d0fefb45181a9083a93b528f5622ff3ba44a497213688a86eb576b21", + "size": 181570606, + "subdir": "linux-64", + "timestamp": 1662497717343, + "version": "2021.6.0" + }, + "dal-static-2023.0.1-hdb19cb5_26647.tar.bz2": { + "build": "hdb19cb5_26647", + "build_number": 26647, + "depends": [ + "dal-include 2023.0.1 h06a4308_26647", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "c0f63d2be85791a77448dd47281a8fd9", + "name": "dal-static", + "sha256": "184128f21cbbb6319694a1d516fec54f9669379b2aae794adb7f595bc36cb92d", + "size": 147431197, + "subdir": "linux-64", + "timestamp": 1677516545106, + "version": "2023.0.1" + }, + "dash-2.7.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "dash-table ==5.0.0", + "dash-core-components ==2.0.0", + "dash-html-components ==2.0.0" + ], + "depends": [ + "flask >=1.0.4", + "flask-compress", + "plotly >=5.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c7e4516a7c72bb3c9d35afd4fcf215b", + "name": "dash", + "sha256": "59b5497b4338cdf29ac3a75c8aa27a3dfed53d9f7d12a0b739c7ae6d2a640b32", + "size": 8286928, + "subdir": "linux-64", + "timestamp": 1669048547333, + "version": "2.7.0" + }, + "dash-2.7.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "dash-html-components ==2.0.0", + "dash-table ==5.0.0", + "dash-core-components ==2.0.0" + ], + "depends": [ + "flask >=1.0.4", + "flask-compress", + "plotly >=5.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "001754a3f53f0cd06c2538da1bc05dba", + "name": "dash", + "sha256": "104b31781b2351961c6913966846f9ddfc1d301b3f1da9bce67b8374547dd206", + "size": 8389653, + "subdir": "linux-64", + "timestamp": 1676843923383, + "version": "2.7.0" + }, + "dash-2.7.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "dash-table ==5.0.0", + "dash-core-components ==2.0.0", + "dash-html-components ==2.0.0" + ], + "depends": [ + "flask >=1.0.4", + "flask-compress", + "plotly >=5.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e32472b50f9c06f35913aa3ee120b79", + "name": "dash", + "sha256": "92cba4df0e0a6b389e3ce756aa0e875955b8150256ae5715b06ddad566601b7f", + "size": 8289499, + "subdir": "linux-64", + "timestamp": 1669048481676, + "version": "2.7.0" + }, + "dash-2.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "dash-table ==5.0.0", + "dash-core-components ==2.0.0", + "dash-html-components ==2.0.0" + ], + "depends": [ + "flask >=1.0.4", + "flask-compress", + "plotly >=5.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d7abfce462bb9ceec2c3560790ad9901", + "name": "dash", + "sha256": "f289255714fbf432245ba974c8d9fd3fe2d963aa55675d73f64392d463eb0649", + "size": 8291806, + "subdir": "linux-64", + "timestamp": 1669048611665, + "version": "2.7.0" + }, + "dash-2.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "dash-table ==5.0.0", + "dash-core-components ==2.0.0", + "dash-html-components ==2.0.0" + ], + "depends": [ + "flask >=1.0.4", + "flask-compress", + "plotly >=5.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "36ba1d7ce404ad516c8bc592a9d8ed8d", + "name": "dash", + "sha256": "74e7e784d3818c561320fb93de2b9ac8b5b6a7ac4d79892ed553d9e13dd775f4", + "size": 8290045, + "subdir": "linux-64", + "timestamp": 1669048418711, + "version": "2.7.0" + }, + "dash-bio-0.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "dash >=1.0.0", + "pandas", + "plotly", + "python >=2.7,<2.8.0a0", + "scikit-learn >=0.20.1", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2143e4a7ac878591d981babfb3c9789e", + "name": "dash-bio", + "sha256": "ef8a8ca7560745d1e489f1983ea11ce7765931b18e85b555e61d98fd4c51bee1", + "size": 1304223, + "subdir": "linux-64", + "timestamp": 1576596552557, + "version": "0.2.0" + }, + "dash-bio-0.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dash >=1.0.0", + "pandas", + "plotly", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.20.1", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "65f4d02e068b76e2062ccc8437aef172", + "name": "dash-bio", + "sha256": "e74f040754a02c5efdd2ffc569bdcd51f40e27018b33c72f52d75ef5b3f315e6", + "size": 1312233, + "subdir": "linux-64", + "timestamp": 1640811896406, + "version": "0.2.0" + }, + "dash-bio-0.2.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "dash >=1.0.0", + "pandas", + "plotly", + "python >=3.11,<3.12.0a0", + "scikit-learn >=0.20.1", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d7450b6cc3a454920bf1a629b439ef9f", + "name": "dash-bio", + "sha256": "ee096fbbe8c74120ded275df17bed8ce33760eec3808c4a6111dc1af55d6dc85", + "size": 1317031, + "subdir": "linux-64", + "timestamp": 1676851840888, + "version": "0.2.0" + }, + "dash-bio-0.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "dash >=1.0.0", + "pandas", + "plotly", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.20.1", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a19152894c9dd5d9dff019b5ecef812a", + "name": "dash-bio", + "sha256": "aaff7fae0f3322fcb19f666dce533d647531b18e3e306709b86829a41b576eb8", + "size": 1304646, + "subdir": "linux-64", + "timestamp": 1576597017900, + "version": "0.2.0" + }, + "dash-bio-0.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dash >=1.0.0", + "pandas", + "plotly", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.20.1", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbf8d4ba02bd98f10256352a6490e8a2", + "name": "dash-bio", + "sha256": "ec52fb969b8ca55480ca284dffe69e04b6382672fbdccd3206cbdfff01644568", + "size": 1304593, + "subdir": "linux-64", + "timestamp": 1576596884936, + "version": "0.2.0" + }, + "dash-bio-0.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "dash >=1.0.0", + "pandas", + "plotly", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.20.1", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa7efe79598301174e8138f2eff818d4", + "name": "dash-bio", + "sha256": "4871cac39489437311dedfde172bacfc0f04a5702d234aa166fc9db83068aeeb", + "size": 1305633, + "subdir": "linux-64", + "timestamp": 1576597139470, + "version": "0.2.0" + }, + "dask-0.15.2-py27h7693082_0.tar.bz2": { + "build": "py27h7693082_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.15.2.*", + "distributed >=1.16.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "982f29b30742460290ce0ffa6a82773c", + "name": "dask", + "sha256": "d7612f962d812e93b39e2eade64c19fe256337250d50b14ce443b6a8e88c5480", + "size": 3126, + "subdir": "linux-64", + "timestamp": 1505739872390, + "version": "0.15.2" + }, + "dask-0.15.2-py35h08b2748_0.tar.bz2": { + "build": "py35h08b2748_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.15.2.*", + "distributed >=1.16.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "329380664f4f70823789a32832904280", + "name": "dask", + "sha256": "84dd84615f5147a3e35a369a80d841aedf276715663ab87af9b4ec57b09a1a34", + "size": 3149, + "subdir": "linux-64", + "timestamp": 1505739883742, + "version": "0.15.2" + }, + "dask-0.15.2-py36h9b48dc4_0.tar.bz2": { + "build": "py36h9b48dc4_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.15.2.*", + "distributed >=1.16.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "5c3ea67092579f516fb5c19fd3e855d9", + "name": "dask", + "sha256": "eababaed6b69e14d9f08e7f6f2e218e564453a757f19f4e4aff4bdb18cebac4c", + "size": 3147, + "subdir": "linux-64", + "timestamp": 1505739895239, + "version": "0.15.2" + }, + "dask-0.15.3-py27hb94b45f_0.tar.bz2": { + "build": "py27hb94b45f_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.15.3.*", + "distributed >=1.19.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "c6a317c1e6396991e701ed7f9173556c", + "name": "dask", + "sha256": "865e6962b3db8ab38e8fcf5e1339f2b01bd747e30710847978addc64269ed48b", + "size": 3573, + "subdir": "linux-64", + "timestamp": 1506624173873, + "version": "0.15.3" + }, + "dask-0.15.3-py35h52d6c43_0.tar.bz2": { + "build": "py35h52d6c43_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.15.3.*", + "distributed >=1.19.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "5c1256b080280febf8b58d7c6bb69847", + "name": "dask", + "sha256": "63839936df4ee9227556ddf85ed9da603b35dcbd8c5b42d20cefde44ba9f9e2a", + "size": 3594, + "subdir": "linux-64", + "timestamp": 1506624241516, + "version": "0.15.3" + }, + "dask-0.15.3-py36hdc2c8aa_0.tar.bz2": { + "build": "py36hdc2c8aa_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.15.3.*", + "distributed >=1.19.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "467f00be7f62206fbed370218745c93f", + "name": "dask", + "sha256": "250d7a399eb78e27f39b208589503562a20da419077f7bd00e98e1bd62b3635d", + "size": 3571, + "subdir": "linux-64", + "timestamp": 1506624227053, + "version": "0.15.3" + }, + "dask-0.15.4-py27hd41a479_0.tar.bz2": { + "build": "py27hd41a479_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.15.4.*", + "distributed >=1.19.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "a03ce6d14aade14e0ce3348c3111e7f7", + "name": "dask", + "sha256": "416e9b48621b74c118a44934812d1bd32b4a11fbccc381c036b653e8094a14ca", + "size": 3641, + "subdir": "linux-64", + "timestamp": 1510006299615, + "version": "0.15.4" + }, + "dask-0.15.4-py35h401027e_0.tar.bz2": { + "build": "py35h401027e_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.15.4.*", + "distributed >=1.19.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "7a382dc02785475a63c4c81a0ae8333c", + "name": "dask", + "sha256": "b199cead29b23286afa0c7c60b8cd714434b355ea693d2a2ef832ac20957d40b", + "size": 3669, + "subdir": "linux-64", + "timestamp": 1510006310379, + "version": "0.15.4" + }, + "dask-0.15.4-py36h31fc154_0.tar.bz2": { + "build": "py36h31fc154_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.15.4.*", + "distributed >=1.19.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "97855c4709ace341668e9a73ca19e91c", + "name": "dask", + "sha256": "26b2377781c8b9e702a97e50adada5438263e26dd1ddaee7f2dbf794f3e4641c", + "size": 3657, + "subdir": "linux-64", + "timestamp": 1510006308934, + "version": "0.15.4" + }, + "dask-0.16.0-py27h8aa6184_0.tar.bz2": { + "build": "py27h8aa6184_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.16.0.*", + "distributed >=1.20.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "e3404f5ae07241c539c373ad75104270", + "name": "dask", + "sha256": "31346cb1ff5cd707dd856dc0e426e90b2276265b76d83efe15c3efc2ac8101a8", + "size": 3665, + "subdir": "linux-64", + "timestamp": 1511196088249, + "version": "0.16.0" + }, + "dask-0.16.0-py35hcb8ecc8_0.tar.bz2": { + "build": "py35hcb8ecc8_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.16.0.*", + "distributed >=1.20.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "aa7c58e63aa5bf6d17b7993afe2c445e", + "name": "dask", + "sha256": "7aad29e2b5172d4c395dbab0723b390bd4443f28040da71a3477e224cb749c29", + "size": 3681, + "subdir": "linux-64", + "timestamp": 1511196156049, + "version": "0.16.0" + }, + "dask-0.16.0-py36h73d177f_0.tar.bz2": { + "build": "py36h73d177f_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.16.0.*", + "distributed >=1.20.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "b329ea45a5e037a222ad54c5c5479298", + "name": "dask", + "sha256": "d5596c712111f28850b36b33fd17545cd5499cf7cbbc171a0dfa24458056ae41", + "size": 3677, + "subdir": "linux-64", + "timestamp": 1511196168252, + "version": "0.16.0" + }, + "dask-0.16.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.16.1.*", + "distributed >=1.20.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "b302c3e0c7e3a2e8fe1f7e40b5dc8e52", + "name": "dask", + "sha256": "1a82589dad4eb7228ac98be889e3e513f4286f7786954635962d5dd351526a4c", + "size": 3497, + "subdir": "linux-64", + "timestamp": 1515704584020, + "version": "0.16.1" + }, + "dask-0.16.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.16.1.*", + "distributed >=1.20.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "6191f7444ed4214418f5b0ac196683a6", + "name": "dask", + "sha256": "cdf4db169c366896954de804d5a268e300cd525676434b1dba35114f41f18acf", + "size": 3513, + "subdir": "linux-64", + "timestamp": 1515704922831, + "version": "0.16.1" + }, + "dask-0.16.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.16.1.*", + "distributed >=1.20.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "e45f824992d02beb854e969e62fd8e08", + "name": "dask", + "sha256": "12601a1fcb46d0fd8d431404f83a7fc407ddfd4b8bbf8afb1c40aae891035212", + "size": 3501, + "subdir": "linux-64", + "timestamp": 1515704657685, + "version": "0.16.1" + }, + "dask-0.17.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.17.0.*", + "distributed >=1.21.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "7b66cf8907849b1ad8552d00dcf2aa54", + "name": "dask", + "sha256": "ec03afdcfa419090c3647582e80b36176ec4e24dc586ecfcba6519881d4ab27d", + "size": 3513, + "subdir": "linux-64", + "timestamp": 1518524603759, + "version": "0.17.0" + }, + "dask-0.17.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.17.0.*", + "distributed >=1.21.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "5a78f08e1c6a34175b2fbc50c40a0b41", + "name": "dask", + "sha256": "2b6f25671ed134725d80b6ff9aa45a075cd5697205401237e97fb99856668090", + "size": 3520, + "subdir": "linux-64", + "timestamp": 1518524704909, + "version": "0.17.0" + }, + "dask-0.17.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.17.0.*", + "distributed >=1.21.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "2cb4b2dbc46ed1ee6efbe2fd2ef09df8", + "name": "dask", + "sha256": "626646fb04eb61bdf8e4aeab6a9b1ceccc7bf1c2380d668a331c3eb11de09f3c", + "size": 3502, + "subdir": "linux-64", + "timestamp": 1518524646862, + "version": "0.17.0" + }, + "dask-0.17.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.17.1.*", + "distributed >=1.21.1", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "8899714b14a6e42c8ae047be6a3dfdfb", + "name": "dask", + "sha256": "9f0a03107e0c6b05f826a5f3415cff76b34310f9defed8897985ea84850c083b", + "size": 3477, + "subdir": "linux-64", + "timestamp": 1519397947180, + "version": "0.17.1" + }, + "dask-0.17.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.17.1.*", + "distributed >=1.21.1", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "f00453e8a8c44dfbf48ded960c2a7770", + "name": "dask", + "sha256": "3208d9bc6c06b47998c7e42f94be9308cd5c8b15f076903d245387efdebada67", + "size": 3477, + "subdir": "linux-64", + "timestamp": 1519397998413, + "version": "0.17.1" + }, + "dask-0.17.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.17.1.*", + "distributed >=1.21.1", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "d525ca15f8cc9d7ca37dc87529370a8b", + "name": "dask", + "sha256": "532f6a08f52867edd319bd6b743c466aa0e52ea8aa66621ee149000ff7f4af4e", + "size": 3476, + "subdir": "linux-64", + "timestamp": 1519397912385, + "version": "0.17.1" + }, + "dask-0.17.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.2.*", + "distributed >=1.21.0", + "numpy >=1.10.4", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "632085c70f0a74a91d661edec79ca53f", + "name": "dask", + "sha256": "a528d15ad562e87dffd78a6be8ec86fc5743f498b81542400cc585d1e9e477cb", + "size": 3560, + "subdir": "linux-64", + "timestamp": 1521650426715, + "version": "0.17.2" + }, + "dask-0.17.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.2.*", + "distributed >=1.21.0", + "numpy >=1.10.4", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "948e6dee73b9bdb1e8549d9fd5066b5e", + "name": "dask", + "sha256": "8c060b0d0d51365c3ae54d119f2d5ba50d2f399dcbc5cc462c160b40d95f2981", + "size": 3569, + "subdir": "linux-64", + "timestamp": 1521650514370, + "version": "0.17.2" + }, + "dask-0.17.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.2.*", + "distributed >=1.21.0", + "numpy >=1.10.4", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "6c60b87e96829e2bc583ecd0970343d8", + "name": "dask", + "sha256": "a3ea6f74842755e3543c7b376542c6e59bcb742aea6d9f68eb81c525df87dc67", + "size": 3554, + "subdir": "linux-64", + "timestamp": 1521650430536, + "version": "0.17.2" + }, + "dask-0.17.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.3.*", + "distributed >=1.21.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "15b6c7ab712b404c2b5af0079731d1d9", + "name": "dask", + "sha256": "8c8016124b6bce292bfbcc9adb3be1abc307cdc46641ebb403a23f8c75dca112", + "size": 3535, + "subdir": "linux-64", + "timestamp": 1525292512747, + "version": "0.17.3" + }, + "dask-0.17.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.3.*", + "distributed >=1.21.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "1de3c8b930312e631e3348bf550e09bb", + "name": "dask", + "sha256": "95c520b1a707c4cd8e604f66d6651b437096e3e4c95d85f45b05d31dcd76543b", + "size": 3532, + "subdir": "linux-64", + "timestamp": 1525292793163, + "version": "0.17.3" + }, + "dask-0.17.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.3.*", + "distributed >=1.21.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "a0a6f044c7373162d012f2b526899792", + "name": "dask", + "sha256": "81d599347effa77e6f9a150fea75583379c73bb38e30bb046dfca76fd8b99013", + "size": 3526, + "subdir": "linux-64", + "timestamp": 1525292518713, + "version": "0.17.3" + }, + "dask-0.17.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.4.*", + "distributed >=1.21.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "9eb8f8055c0691865a1cad6073c8d0fe", + "name": "dask", + "sha256": "fac668dc277ef146412d993c7f55a84da6a144eec2924a9e8d9c113c899027e8", + "size": 3562, + "subdir": "linux-64", + "timestamp": 1525471117824, + "version": "0.17.4" + }, + "dask-0.17.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.4.*", + "distributed >=1.21.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "37b996687279762a8fc75b6ebea5f0c9", + "name": "dask", + "sha256": "8ef63c6f50487c9cea07459004e4a59a62117fb87dc7eff5fc5c468fcc7bfe6f", + "size": 3576, + "subdir": "linux-64", + "timestamp": 1525471122323, + "version": "0.17.4" + }, + "dask-0.17.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.4.*", + "distributed >=1.21.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "46e90cb6c981b5b2013c11bd1f784e16", + "name": "dask", + "sha256": "68a628ab7a3d2be5dff20ba4e96d129d55f9236ff609aa65d34c0f8e95a57882", + "size": 3575, + "subdir": "linux-64", + "timestamp": 1525471084452, + "version": "0.17.4" + }, + "dask-0.17.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.5.*", + "distributed >=1.21.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "82b9f9932396c580c70d65e5aaa5b283", + "name": "dask", + "sha256": "89bba9033e277831fe1e914ea39f238a8dde01584330e2bb5112933713400fac", + "size": 3534, + "subdir": "linux-64", + "timestamp": 1526527459308, + "version": "0.17.5" + }, + "dask-0.17.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.5.*", + "distributed >=1.21.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "9fbaf560123105a1bc6d3c4bc9a9827f", + "name": "dask", + "sha256": "adcc9b412bfe043a5d791920d0d7aa127c68ae9a68d059fad5cf8e6f326be159", + "size": 3524, + "subdir": "linux-64", + "timestamp": 1526527408027, + "version": "0.17.5" + }, + "dask-0.17.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.5.*", + "distributed >=1.21.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "64d2a3588e1767f81c42b17466c026e0", + "name": "dask", + "sha256": "13d5704ef3b8585636b089536a8cec2d8fa9b6c63c7788f1c20d11ba60eb45a3", + "size": 3530, + "subdir": "linux-64", + "timestamp": 1526527397946, + "version": "0.17.5" + }, + "dask-0.18.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.0.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "50ff92db25180f5613ece1d6ca9369c9", + "name": "dask", + "sha256": "8d7591f240cee5fcb84d7ab4a9f559571ae112b9800d0ca830b4db6f2b0ae009", + "size": 3427, + "subdir": "linux-64", + "timestamp": 1529078269341, + "version": "0.18.0" + }, + "dask-0.18.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.0.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "2d6a9618c6bb8c9f56341a22f853aacd", + "name": "dask", + "sha256": "4c61eee53825d6f5437f0ad7f526bcfeb1ea97a18a9b8d9c32785a894c240162", + "size": 3425, + "subdir": "linux-64", + "timestamp": 1529077757476, + "version": "0.18.0" + }, + "dask-0.18.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.0.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "df470d5004d2b564f5a1503f92921c7d", + "name": "dask", + "sha256": "c04067c79adf3da28c7ec63f6c61611d19c7dc1312e5ca8af62b85dcc86ddc64", + "size": 3427, + "subdir": "linux-64", + "timestamp": 1529077964493, + "version": "0.18.0" + }, + "dask-0.18.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.1.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "c17c5a5c54b3d6d670227a9cbc897390", + "name": "dask", + "sha256": "d996879587ed4bd336d694508fe4614a7f7656393891c09ea3fc7f55e0018851", + "size": 3447, + "subdir": "linux-64", + "timestamp": 1529768255877, + "version": "0.18.1" + }, + "dask-0.18.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.1.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "18cdc2a957a9814857512d8859fe57c9", + "name": "dask", + "sha256": "fd6ce10f3b492461b8f5da1580bf72f968113ce7f3b20f53d69e65feb3d84b51", + "size": 3435, + "subdir": "linux-64", + "timestamp": 1529768328172, + "version": "0.18.1" + }, + "dask-0.18.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.1.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "5d17cf5e957158ec1221758902654bcd", + "name": "dask", + "sha256": "50e5578d3d9576a3f154fee2bfab25b261f12283be07d4bb7ab97a1ee1bedbb0", + "size": 3435, + "subdir": "linux-64", + "timestamp": 1529934488671, + "version": "0.18.1" + }, + "dask-0.18.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.1.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "f5983668bf3fa8243941e98aa9074b9b", + "name": "dask", + "sha256": "586208afbe90fe50a380cd610a8096371758650db1ad63e9df7acd9e0f13e31b", + "size": 3417, + "subdir": "linux-64", + "timestamp": 1530741942844, + "version": "0.18.1" + }, + "dask-0.18.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.2.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "e2f36145ea0bc1bd8802e2effc0305ef", + "name": "dask", + "sha256": "6899b2d60d2e98d2d61b8b5fddc23015e17ad2b15cfc6c5a1d12d12a9bfcdc63", + "size": 3309, + "subdir": "linux-64", + "timestamp": 1532441661706, + "version": "0.18.2" + }, + "dask-0.18.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.2.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "341d1ecbefcae672950674a14848c614", + "name": "dask", + "sha256": "04b10ef585969c00a7193f236d031d567d47ebaf6044203931a9255ba8f5afb0", + "size": 3336, + "subdir": "linux-64", + "timestamp": 1532441803693, + "version": "0.18.2" + }, + "dask-0.18.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.2.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "305ec5f955be90cb6a301cba732a1ac1", + "name": "dask", + "sha256": "351885de8afc5abc03d1634f2fc99108043edbb906a43b6a66a2348294224b49", + "size": 3320, + "subdir": "linux-64", + "timestamp": 1532441476643, + "version": "0.18.2" + }, + "dask-0.18.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.2.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "9fa99a81c8025b3d07e9a45ac6079eb6", + "name": "dask", + "sha256": "8ee65a03ef126ddc7c787e1db9f839d31b0cfae0a49064b4451fba44a64a3777", + "size": 3326, + "subdir": "linux-64", + "timestamp": 1532441537380, + "version": "0.18.2" + }, + "dask-0.19.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.0.*", + "distributed >=1.23.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "edbbb52eb0aae126ced17b5f9b5948b3", + "name": "dask", + "sha256": "34d2f4355df1817b5f231169543b7e751ae7f975fb62680cccf5dc81a7ac0577", + "size": 3542, + "subdir": "linux-64", + "timestamp": 1535659109589, + "version": "0.19.0" + }, + "dask-0.19.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.0.*", + "distributed >=1.23.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "1123bec1ef60c6b4eef651bebd4ce3e3", + "name": "dask", + "sha256": "a322678b698ab06459d12fd2fe4c526c760ee657b62f05516bd7caf20ff059cb", + "size": 3544, + "subdir": "linux-64", + "timestamp": 1535659197140, + "version": "0.19.0" + }, + "dask-0.19.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.0.*", + "distributed >=1.23.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "2792c2f5dbfbdb6ceac0788191b56ca0", + "name": "dask", + "sha256": "955e6fa3d009eeb99d04e286a26499e6a5d2426a5f2332ffc240911c58cd64b8", + "size": 3557, + "subdir": "linux-64", + "timestamp": 1535659104152, + "version": "0.19.0" + }, + "dask-0.19.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.0.*", + "distributed >=1.23.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "8b67fca771ba8decaccd6992c0ec8fc0", + "name": "dask", + "sha256": "89bac49c33c5481056d0487ea280f104b42d865c1a4b126d583f0df82057096c", + "size": 3537, + "subdir": "linux-64", + "timestamp": 1535659192256, + "version": "0.19.0" + }, + "dask-0.19.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.1.*", + "distributed >=1.23.1", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "23be54346937606c973b38d561fbf6bd", + "name": "dask", + "sha256": "dccbf47d66e7b87d7752df47484ab6691189439899a8895dca51516bf59726e9", + "size": 3527, + "subdir": "linux-64", + "timestamp": 1536250329401, + "version": "0.19.1" + }, + "dask-0.19.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.1.*", + "distributed >=1.23.1", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "acfc259dbc8071e90cc30ba0d506335c", + "name": "dask", + "sha256": "229f62a04dea6c070434aadaee27dcb1fe02f2122c82be297fb106e92467d420", + "size": 3531, + "subdir": "linux-64", + "timestamp": 1536248991100, + "version": "0.19.1" + }, + "dask-0.19.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.1.*", + "distributed >=1.23.1", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "3dab6c9ffca553b209c468edf5062614", + "name": "dask", + "sha256": "d477e283dee0d3d75f9f3c4ca9475de28a6425f739aa0fcfa506b54e151496f1", + "size": 3536, + "subdir": "linux-64", + "timestamp": 1536248953295, + "version": "0.19.1" + }, + "dask-0.19.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.1.*", + "distributed >=1.23.1", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "e4344303f25a5118b33dbcb032c1c6cc", + "name": "dask", + "sha256": "ff287f4352e7c9ee4ae8aa7fce673dbde5822d587d04f0089aa0ef26ab222464", + "size": 3529, + "subdir": "linux-64", + "timestamp": 1536249003353, + "version": "0.19.1" + }, + "dask-0.19.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.2.*", + "distributed >=1.23.2", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "82663f6f484cc8501c3746e1d836be26", + "name": "dask", + "sha256": "06d2d18ce8ee7d66e5332ec881dbf002a650fb4f54aaa0ade53ebdf75971c922", + "size": 3615, + "subdir": "linux-64", + "timestamp": 1538069293767, + "version": "0.19.2" + }, + "dask-0.19.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.2.*", + "distributed >=1.23.2", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "e5b6cf91f61fc6fc9b92fd75199740bf", + "name": "dask", + "sha256": "20d48bc96f630aefe830de839026b3d2cf260fec4cf0bcf9b1a533bab33ba584", + "size": 3616, + "subdir": "linux-64", + "timestamp": 1538069380126, + "version": "0.19.2" + }, + "dask-0.19.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.2.*", + "distributed >=1.23.2", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "63640a5852869034b57df8fe047053f2", + "name": "dask", + "sha256": "1bb2ca39aa103ad40ac292194131f7103080883f567046059be0b7be3104eb90", + "size": 3614, + "subdir": "linux-64", + "timestamp": 1538069350989, + "version": "0.19.2" + }, + "dask-0.19.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.2.*", + "distributed >=1.23.2", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "84874104fe1a93505090333f95143d97", + "name": "dask", + "sha256": "e5621a5badf9628caefbc24914d31433196620ecf0c5aad0fb075f72bbc932d2", + "size": 3617, + "subdir": "linux-64", + "timestamp": 1538069243620, + "version": "0.19.2" + }, + "dask-0.19.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.3.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "5c61945ab45808c880090f67e938c3ae", + "name": "dask", + "sha256": "6088a40a845769573a59b3e770b8f9a9341999c777404d31274cb0482a3cc79d", + "size": 3683, + "subdir": "linux-64", + "timestamp": 1539017136512, + "version": "0.19.3" + }, + "dask-0.19.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.3.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "e388828e15d87b6203c45908ca3dfe65", + "name": "dask", + "sha256": "797e0d58974db6660eb115c9830d41dedd06769e760a6239c16e246d3e86b4ce", + "size": 3690, + "subdir": "linux-64", + "timestamp": 1539017213285, + "version": "0.19.3" + }, + "dask-0.19.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.3.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "b00088942ac6a0fb9859b31e12b17876", + "name": "dask", + "sha256": "dc5fff67ed221f0e01f8bb0cc580411f7c7be3053dc87047d2ed964275303fbe", + "size": 3692, + "subdir": "linux-64", + "timestamp": 1539017112614, + "version": "0.19.3" + }, + "dask-0.19.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.4.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "58771bb157eaddc7e084709a99dd48b1", + "name": "dask", + "sha256": "478515e71e78f29f84988348a60fcc475ff4dce19d08a4ba543d758828fa74f2", + "size": 3695, + "subdir": "linux-64", + "timestamp": 1539632869828, + "version": "0.19.4" + }, + "dask-0.19.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.4.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "273882c3614fcc10c5870bed8ccfcbec", + "name": "dask", + "sha256": "47ff78893673e4a06c85e1cc684780263e6036314278bbfc90ca419380241ef9", + "size": 3683, + "subdir": "linux-64", + "timestamp": 1539632883834, + "version": "0.19.4" + }, + "dask-0.19.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.4.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "6e7ae7b17e891b384dd6bdeb0a0b732c", + "name": "dask", + "sha256": "eb417b7115583c4c187ae192a515bc25c1a7caa9be208f69671cda52b1808a6b", + "size": 3683, + "subdir": "linux-64", + "timestamp": 1539632882282, + "version": "0.19.4" + }, + "dask-0.20.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.20.0.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "6bc2fa61324a58f36383833511b1c9f2", + "name": "dask", + "sha256": "3f34fd394b15ff77358f2516d8f3434210d5ae4959b95b320b0cbc2a25745a5f", + "size": 3700, + "subdir": "linux-64", + "timestamp": 1540830896518, + "version": "0.20.0" + }, + "dask-0.20.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.20.0.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "12bbcbf5685a1c4ea4f8b686382c0c3a", + "name": "dask", + "sha256": "adc0c85a91c241b3c5b5dcbd76b215d8534225f47ce42f6678e142a9337de420", + "size": 3695, + "subdir": "linux-64", + "timestamp": 1540830925057, + "version": "0.20.0" + }, + "dask-0.20.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.20.0.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "a8e8f64175d4684d319e38956f9664c9", + "name": "dask", + "sha256": "ab07acc4be1291524c02a88e5386f61c6ca1b468db207f7d41131f8253c10266", + "size": 3697, + "subdir": "linux-64", + "timestamp": 1540830955581, + "version": "0.20.0" + }, + "dask-0.20.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.20.1.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "8e0d7e6f6e38e70471b8607776eb879a", + "name": "dask", + "sha256": "16de971c44ed4a333b532dfa0d8779fab2c9182c74de8a73781b55da6f02dac9", + "size": 3657, + "subdir": "linux-64", + "timestamp": 1542077695070, + "version": "0.20.1" + }, + "dask-0.20.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.20.1.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "4963cf6f244313a122945b3b9e6a3232", + "name": "dask", + "sha256": "61da56368bfc95e874df7fdee172f1d9a4d3a3c24a8446762984a982a2b528ed", + "size": 3656, + "subdir": "linux-64", + "timestamp": 1542077820054, + "version": "0.20.1" + }, + "dask-0.20.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.20.1.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "d2e001f0810521c0466bf109972d3e60", + "name": "dask", + "sha256": "8e90a2464e35bb865869dbe53701d4eac2653bf2ff29608cc6d1084b36397fa3", + "size": 3651, + "subdir": "linux-64", + "timestamp": 1542077759712, + "version": "0.20.1" + }, + "dask-0.20.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.20.2.*", + "distributed >=1.24.2", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "904b21cee389fc75efeb0a400f0fc6c1", + "name": "dask", + "sha256": "c568586dfc75d688152efb2507a1641da6ce5ce8935826e62992a1449e9805c4", + "size": 3660, + "subdir": "linux-64", + "timestamp": 1542386627620, + "version": "0.20.2" + }, + "dask-0.20.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.20.2.*", + "distributed >=1.24.2", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "0597714affe2d61c1e42d41057cfaf74", + "name": "dask", + "sha256": "031333e8cc60ea09c5157bbe29e06f103b85af9fe10ef784078172924f5f38be", + "size": 3672, + "subdir": "linux-64", + "timestamp": 1542386681982, + "version": "0.20.2" + }, + "dask-0.20.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.20.2.*", + "distributed >=1.24.2", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "69d63ee384ca33ac33fc3d622055f1f4", + "name": "dask", + "sha256": "5e6598c1978e4de46ccde8dadcb3d155775628996196deb603410ea83407a715", + "size": 3653, + "subdir": "linux-64", + "timestamp": 1542386623203, + "version": "0.20.2" + }, + "dask-1.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 1.0.0.*", + "distributed >=1.25.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "669343b06f3b3831cbb0100a70637757", + "name": "dask", + "sha256": "681e941bc9b716584ca4de77d4b3d3ec4ebd0e8ccfdcb24dc36b1e0ff0b59a71", + "size": 3692, + "subdir": "linux-64", + "timestamp": 1543504200478, + "version": "1.0.0" + }, + "dask-1.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 1.0.0.*", + "distributed >=1.25.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "8d52b774b6d135d6a043b9e75be78e22", + "name": "dask", + "sha256": "e0b41200ba3b1e7093a41365e77251b72dbfd12d38ba77f73fc901b08116ecbf", + "size": 3700, + "subdir": "linux-64", + "timestamp": 1543504325126, + "version": "1.0.0" + }, + "dask-1.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 1.0.0.*", + "distributed >=1.25.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "7574b38237f0f8047f70a28f47b7e556", + "name": "dask", + "sha256": "a11b2f5950f88fcf6c82d7f7b3e2cb4f8d893a18aca6ff9c1ba34dd8e59395e4", + "size": 3705, + "subdir": "linux-64", + "timestamp": 1543504219943, + "version": "1.0.0" + }, + "dask-1.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 1.1.2.*", + "distributed >=1.25.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "d7269415aa8d1cd85da2ad2bcd8836dc", + "name": "dask", + "sha256": "ff56852821fed5ee5bcc7980d9ee818e2fbe54467ca674f23f25769103f126ff", + "size": 10585, + "subdir": "linux-64", + "timestamp": 1551138544223, + "version": "1.1.2" + }, + "dask-1.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 1.1.2.*", + "distributed >=1.25.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "becfe528425631126577b8afa935b23b", + "name": "dask", + "sha256": "319981690c3867beff6236cf3524268b1dc755bbf96dff4459eeed3281591869", + "size": 10589, + "subdir": "linux-64", + "timestamp": 1551138595105, + "version": "1.1.2" + }, + "dask-1.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 1.1.2.*", + "distributed >=1.25.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "7a9474360928f2911193492e14b31870", + "name": "dask", + "sha256": "1989ac465cea1350bb41af31296bd7155785ed2dc2379721239db77edb0d894f", + "size": 10585, + "subdir": "linux-64", + "timestamp": 1551195931863, + "version": "1.1.2" + }, + "dask-1.1.4-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 1.1.4.*", + "distributed >=1.26.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "4c746bbaf11d6dfcfaa3a75f0b0347e4", + "name": "dask", + "sha256": "6035fec81b4fabd21d6f8e75268c06462da70af1dc437ddb64896615105a88c6", + "size": 10868, + "subdir": "linux-64", + "timestamp": 1553289470806, + "version": "1.1.4" + }, + "dask-1.1.4-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 1.1.4.*", + "distributed >=1.26.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "42ad9139fae6cac126400927efd81e35", + "name": "dask", + "sha256": "6baa663b279646322a75e30d06c3c3e5da94260b035fd764979cc5f5fba10253", + "size": 10877, + "subdir": "linux-64", + "timestamp": 1553289520710, + "version": "1.1.4" + }, + "dask-1.1.4-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 1.1.4.*", + "distributed >=1.26.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "cf77a3b090a37da972353c82d60431f9", + "name": "dask", + "sha256": "e59cf909bb34ddd09a788397fdc6cbebf04d49d6d03d66fac52bc8f63252d52f", + "size": 10893, + "subdir": "linux-64", + "timestamp": 1553290686219, + "version": "1.1.4" + }, + "dask-2022.5.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "cytoolz >=0.8.2", + "dask-core 2022.5.0.*", + "distributed 2022.5.0.*", + "jinja2", + "lz4", + "numpy >=1.18", + "pandas >=1.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b241adcdfee8ec9a6c14d0332c59261b", + "name": "dask", + "sha256": "8f382f7563aa26048a8eb10fabd3d1469859ef2810b8c1d0b59d82847bf087f9", + "size": 4786, + "subdir": "linux-64", + "timestamp": 1653409189481, + "version": "2022.5.0" + }, + "dask-2022.5.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "cytoolz >=0.8.2", + "dask-core 2022.5.0.*", + "distributed 2022.5.0.*", + "jinja2", + "lz4", + "numpy >=1.18", + "pandas >=1.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1a1e2047fce542125b77fe9c568fed62", + "name": "dask", + "sha256": "12bf07f08c5e2d07d53521c2219296aaeb25808f1a54898d626ce26a7b1100dc", + "size": 5068, + "subdir": "linux-64", + "timestamp": 1676843943309, + "version": "2022.5.0" + }, + "dask-2022.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "cytoolz >=0.8.2", + "dask-core 2022.5.0.*", + "distributed 2022.5.0.*", + "jinja2", + "lz4", + "numpy >=1.18", + "pandas >=1.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fc106e7e4c81eedd0a14e709563c3a32", + "name": "dask", + "sha256": "0d42231eb4f4b57afa90e2df38312115613ac2d5b5cdd8dae986270696d5c489", + "size": 4760, + "subdir": "linux-64", + "timestamp": 1653409259494, + "version": "2022.5.0" + }, + "dask-2022.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "cytoolz >=0.8.2", + "dask-core 2022.5.0.*", + "distributed 2022.5.0.*", + "jinja2", + "lz4", + "numpy >=1.18", + "pandas >=1.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a6e49eb7cefe656e72857b2615ecdb01", + "name": "dask", + "sha256": "846e4166359597b6eaf5e80b4f9ca88784531039cb044f9480f79261f821f66c", + "size": 4771, + "subdir": "linux-64", + "timestamp": 1653409226556, + "version": "2022.5.0" + }, + "dask-2022.7.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "cytoolz >=0.8.2", + "dask-core 2022.7.0.*", + "distributed 2022.7.0.*", + "jinja2", + "lz4", + "numpy >=1.18", + "pandas >=1.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c76ab1491d52a73004f2b8bc2e98270a", + "name": "dask", + "sha256": "b9935af3610ddceac4e3ee66f473e7aa7337aa0e4c63b8b6be6bdb56083a79cc", + "size": 5529, + "subdir": "linux-64", + "timestamp": 1658527043409, + "version": "2022.7.0" + }, + "dask-2022.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "cytoolz >=0.8.2", + "dask-core 2022.7.0.*", + "distributed 2022.7.0.*", + "jinja2", + "lz4", + "numpy >=1.18", + "pandas >=1.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "000dcd40b5a7909a7e3b747885e82414", + "name": "dask", + "sha256": "0a00b334d23caf76ab07750c5a124f186e4762f1172257015e66a6f9501f5234", + "size": 5487, + "subdir": "linux-64", + "timestamp": 1658527002815, + "version": "2022.7.0" + }, + "dask-2022.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "cytoolz >=0.8.2", + "dask-core 2022.7.0.*", + "distributed 2022.7.0.*", + "jinja2", + "lz4", + "numpy >=1.18", + "pandas >=1.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6fd05feff069837876fadb766a522cda", + "name": "dask", + "sha256": "38a6d0236c2d63cf72f3b6c361a1c51916b30c0a02b618d9a706bda980e667d3", + "size": 5503, + "subdir": "linux-64", + "timestamp": 1658526967823, + "version": "2022.7.0" + }, + "dask-2023.3.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "click >=7.0", + "cloudpickle >=1.1.1", + "cytoolz >=0.8.2", + "dask-core 2023.3.2.*", + "distributed 2023.3.2.*", + "fsspec >=0.6.0", + "importlib-metadata >=4.13.0", + "jinja2 >=2.10.3", + "lz4", + "numpy >=1.21", + "packaging >=20.0", + "pandas >=1.3", + "partd >=1.2.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.3.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "63bbd4f862e4f429dfe524b4842535a9", + "name": "dask", + "sha256": "59f10b0a11f45d426ffe50a3c5197e71d72751a87a6973f04f5cd5755e16d341", + "size": 5108, + "subdir": "linux-64", + "timestamp": 1680108500827, + "version": "2023.3.2" + }, + "dask-2023.3.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "click >=7.0", + "cloudpickle >=1.1.1", + "cytoolz >=0.8.2", + "dask-core 2023.3.2.*", + "distributed 2023.3.2.*", + "fsspec >=0.6.0", + "importlib-metadata >=4.13.0", + "jinja2 >=2.10.3", + "lz4", + "numpy >=1.21", + "packaging >=20.0", + "pandas >=1.3", + "partd >=1.2.0", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.3.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ecfd796ed6121daaf229a77a1eca9906", + "name": "dask", + "sha256": "3736aef191f42c13699c071434bf33508df6cb87d506717d4582b11e91c737eb", + "size": 5082, + "subdir": "linux-64", + "timestamp": 1680108537420, + "version": "2023.3.2" + }, + "dask-2023.3.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "click >=7.0", + "cloudpickle >=1.1.1", + "cytoolz >=0.8.2", + "dask-core 2023.3.2.*", + "distributed 2023.3.2.*", + "fsspec >=0.6.0", + "importlib-metadata >=4.13.0", + "jinja2 >=2.10.3", + "lz4", + "numpy >=1.21", + "packaging >=20.0", + "pandas >=1.3", + "partd >=1.2.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.3.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f00d31b4ec691759e5eede9e2b834163", + "name": "dask", + "sha256": "26776dbda08693cdf1aeda9b9370d0a4b15cf75f39b1dc6289a7eb773cb89c1f", + "size": 5066, + "subdir": "linux-64", + "timestamp": 1680108462140, + "version": "2023.3.2" + }, + "dask-2023.3.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "click >=7.0", + "cloudpickle >=1.1.1", + "cytoolz >=0.8.2", + "dask-core 2023.3.2.*", + "distributed 2023.3.2.*", + "fsspec >=0.6.0", + "importlib-metadata >=4.13.0", + "jinja2 >=2.10.3", + "lz4", + "numpy >=1.21", + "packaging >=20.0", + "pandas >=1.3", + "partd >=1.2.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.3.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "18fa43bc94720fbc430c70f5dfdf68a1", + "name": "dask", + "sha256": "2552542c2e744b4d0e4ad5d800e21c802bcd642752c6c4ff12012ed589ae21f9", + "size": 5073, + "subdir": "linux-64", + "timestamp": 1680108420325, + "version": "2023.3.2" + }, + "dask-core-0.15.2-py27heedc4a4_0.tar.bz2": { + "build": "py27heedc4a4_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ccb070fe2a85a87a6f82cd8860341826", + "name": "dask-core", + "sha256": "b695ce88531972f60b4db9a176f8e8a2d0772830e9567a0eba3d2a595f809da3", + "size": 905181, + "subdir": "linux-64", + "timestamp": 1505733002745, + "version": "0.15.2" + }, + "dask-core-0.15.2-py35h79caba8_0.tar.bz2": { + "build": "py35h79caba8_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d0ea85245993c797394a946e0570700e", + "name": "dask-core", + "sha256": "4c13f7cac0a64c38a0dbaa576a6e4bec88c697fb9e1814d4f21d72d398385517", + "size": 920303, + "subdir": "linux-64", + "timestamp": 1505733025395, + "version": "0.15.2" + }, + "dask-core-0.15.2-py36h0f988a8_0.tar.bz2": { + "build": "py36h0f988a8_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c25bcb7846e1def7722df6eaea0db63e", + "name": "dask-core", + "sha256": "2a1d1f6009f3a0916d4d3ec9a0b63795e54d04ccc78d5acc4afb1ff3db8ce847", + "size": 914157, + "subdir": "linux-64", + "timestamp": 1505733048226, + "version": "0.15.2" + }, + "dask-core-0.15.3-py27h53a7ee6_0.tar.bz2": { + "build": "py27h53a7ee6_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4dd41471c72105eb1a18a7a15bbd65b4", + "name": "dask-core", + "sha256": "97b736e762f8f7cc1eb54219db3ee9fc61dfa43fcc693fd90da728f54cb0320e", + "size": 933132, + "subdir": "linux-64", + "timestamp": 1506623913203, + "version": "0.15.3" + }, + "dask-core-0.15.3-py35hdf4792c_0.tar.bz2": { + "build": "py35hdf4792c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fc4366d6677ce5581808a47e5be36173", + "name": "dask-core", + "sha256": "ebc7fbbf536fef914fed69551d9da19645b97a30800a1381f908af10321acfd0", + "size": 945545, + "subdir": "linux-64", + "timestamp": 1506623946353, + "version": "0.15.3" + }, + "dask-core-0.15.3-py36h10e6167_0.tar.bz2": { + "build": "py36h10e6167_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "05544b56fc55827a8b5249e3626f141d", + "name": "dask-core", + "sha256": "d04e69ca11de1aafa2224d6be20616fdc236393c1b0c458708158537a3226408", + "size": 941847, + "subdir": "linux-64", + "timestamp": 1506623961580, + "version": "0.15.3" + }, + "dask-core-0.15.4-py27h539238a_0.tar.bz2": { + "build": "py27h539238a_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f5568e73df7ea0d79d88a3378aafa701", + "name": "dask-core", + "sha256": "e2ef920df443b8dd9e67ee70a476261ef7b36ee73e509cf17ce8b1029991dbba", + "size": 936632, + "subdir": "linux-64", + "timestamp": 1510006209683, + "version": "0.15.4" + }, + "dask-core-0.15.4-py35hb07b8c3_0.tar.bz2": { + "build": "py35hb07b8c3_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b7187de33cb26142a97a72e141f7c6e5", + "name": "dask-core", + "sha256": "739fd1b3a3d0c85cf6f87db89071558aae34931413c73429f77ffa63c4995a64", + "size": 948879, + "subdir": "linux-64", + "timestamp": 1510006221838, + "version": "0.15.4" + }, + "dask-core-0.15.4-py36h7045e13_0.tar.bz2": { + "build": "py36h7045e13_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "34347e09120e1e4ff4163b588d00dc54", + "name": "dask-core", + "sha256": "bd47bdf4772e7090d41b2ad8d8c637dee85e57e1e57b73d4fc88ec142c6d3ca0", + "size": 945354, + "subdir": "linux-64", + "timestamp": 1510006216295, + "version": "0.15.4" + }, + "dask-core-0.16.0-py27he98c51e_0.tar.bz2": { + "build": "py27he98c51e_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8be5920b0b603aabfaf95b4a788d2032", + "name": "dask-core", + "sha256": "38bd4160f4501a9832ff739837a3eda1fedfbfb5966fba216bcf5e63e6a83d70", + "size": 964791, + "subdir": "linux-64", + "timestamp": 1511195884663, + "version": "0.16.0" + }, + "dask-core-0.16.0-py35hfc66869_0.tar.bz2": { + "build": "py35hfc66869_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6e17e07c30d975e1b61cd41e608a2041", + "name": "dask-core", + "sha256": "faa16b66c14fef871015589c6495ec00eb08f4a0d1b0f09f1afa9de2a78f5f07", + "size": 973443, + "subdir": "linux-64", + "timestamp": 1511195895537, + "version": "0.16.0" + }, + "dask-core-0.16.0-py36ha827fd6_0.tar.bz2": { + "build": "py36ha827fd6_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a55bdd575c02a671294e8802bd82b349", + "name": "dask-core", + "sha256": "9e85c0e58c7bd05f77b1a6761c936c4441e02c8e4eb51df2c72b3009ffec76d2", + "size": 964425, + "subdir": "linux-64", + "timestamp": 1511195926338, + "version": "0.16.0" + }, + "dask-core-0.16.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f32038aebd0bd3e0c78f36effeece19e", + "name": "dask-core", + "sha256": "bb66c9a234fce2608d01511ec717e34fee3e9ce02547cdcaea1b6d5a091cfeb1", + "size": 997738, + "subdir": "linux-64", + "timestamp": 1515704356145, + "version": "0.16.1" + }, + "dask-core-0.16.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c0da847f75ca990fbf45301a2a0f5a84", + "name": "dask-core", + "sha256": "f652f572034dd50614daec81e040b7704219d1d907af5d5f279bc6f2bd703c37", + "size": 1005526, + "subdir": "linux-64", + "timestamp": 1515704455676, + "version": "0.16.1" + }, + "dask-core-0.16.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a4d5a594fb14a735fde90495db990823", + "name": "dask-core", + "sha256": "05ba3a76a9efe2c715fdb122d5357fc71405dba85d7a97f1f565ef5b517b6262", + "size": 998150, + "subdir": "linux-64", + "timestamp": 1515704170446, + "version": "0.16.1" + }, + "dask-core-0.17.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "119138127d6f6e3e6e98190543203b4b", + "name": "dask-core", + "sha256": "cc32d5f9dd22c873602586cad68f722539ee646dea79380b9bf4c1773167444c", + "size": 1018584, + "subdir": "linux-64", + "timestamp": 1518524262612, + "version": "0.17.0" + }, + "dask-core-0.17.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7a16790f2f3a92755a22c2399838d7af", + "name": "dask-core", + "sha256": "2befd08d2986a231e5bd910cb2925c3ef95fb3597dfea4bbe70272c77f1fe760", + "size": 1035273, + "subdir": "linux-64", + "timestamp": 1518524311696, + "version": "0.17.0" + }, + "dask-core-0.17.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5b33764210d64d1f9f34b236e35e4948", + "name": "dask-core", + "sha256": "3b86713882de6e3edc2134c41b4b8d8fe824e738047f1e4e30e2abd0c690603d", + "size": 1020908, + "subdir": "linux-64", + "timestamp": 1518524311953, + "version": "0.17.0" + }, + "dask-core-0.17.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d1cbea77f69d29c21b623fe06d16008c", + "name": "dask-core", + "sha256": "834725d8d475f2ad4b3ffc847bbae0d45c5baabe779a4d908b7a782640fa4d0e", + "size": 1031154, + "subdir": "linux-64", + "timestamp": 1519397632435, + "version": "0.17.1" + }, + "dask-core-0.17.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "417090395a0719dd259670b8aaff326a", + "name": "dask-core", + "sha256": "dd82d326bb901198d88c5794fd5dc0b8ac63fbc7dd3d99b22abf7bd781896317", + "size": 1052847, + "subdir": "linux-64", + "timestamp": 1519397647505, + "version": "0.17.1" + }, + "dask-core-0.17.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c61300a6bb61eab594881121b19e50f1", + "name": "dask-core", + "sha256": "85859e71ed00d35334b0f8f3d4eff4c42247a2e842f144406803fe5c9c3b01a5", + "size": 1031200, + "subdir": "linux-64", + "timestamp": 1519397610092, + "version": "0.17.1" + }, + "dask-core-0.17.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c6c03e3213c31e5cf4840a2f541c3dae", + "name": "dask-core", + "sha256": "242a3349c7f6faf8fa2a143a7620dc5bbd4ca2ed6e6112525763ef042d55f461", + "size": 1040672, + "subdir": "linux-64", + "timestamp": 1521650088111, + "version": "0.17.2" + }, + "dask-core-0.17.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c1f328ef9f18d6f75b36dc1421ad7d7f", + "name": "dask-core", + "sha256": "999aaa622128cb502d27550e382237a14cd15afd72f51dd20d2d1edb087b2128", + "size": 1064486, + "subdir": "linux-64", + "timestamp": 1521650127658, + "version": "0.17.2" + }, + "dask-core-0.17.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "55446090ece87a3e26eba3b960aa85ca", + "name": "dask-core", + "sha256": "f352e78c96d1e43e55447816f5cadcdceda2b99758797205546563b9ed2ece1e", + "size": 1040268, + "subdir": "linux-64", + "timestamp": 1521650089321, + "version": "0.17.2" + }, + "dask-core-0.17.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f40748a4444de50fc8b0dd213bff2c2b", + "name": "dask-core", + "sha256": "c826bfd084185f79e15b582e6638648e49c1b41ac0869a28b11a9ee6789d3915", + "size": 1079545, + "subdir": "linux-64", + "timestamp": 1525289042483, + "version": "0.17.3" + }, + "dask-core-0.17.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bc8f58750a15bee57b1ee6230708b17a", + "name": "dask-core", + "sha256": "96c67ab28a848f117bd10d5c5a84ad5607a5e76c9e3463827255534a41b7a6ef", + "size": 1093423, + "subdir": "linux-64", + "timestamp": 1525289186011, + "version": "0.17.3" + }, + "dask-core-0.17.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6286407a1a4baa083ea75099a56c589d", + "name": "dask-core", + "sha256": "9bf2162071a62fc4a07a66764e1b04ea9254a5447bd1eb5e1e68e396649d2449", + "size": 1081758, + "subdir": "linux-64", + "timestamp": 1525289186904, + "version": "0.17.3" + }, + "dask-core-0.17.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a8cedad13a7a97d22072201d06d3a4a6", + "name": "dask-core", + "sha256": "656ca566b9da2f3ef6eb7af2c300b53ca2a477a937c83886f0ed7ce4cd2c4bde", + "size": 1079893, + "subdir": "linux-64", + "timestamp": 1525470734188, + "version": "0.17.4" + }, + "dask-core-0.17.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b7b913cb15018cebef647ca4ad83b8af", + "name": "dask-core", + "sha256": "a18bfca6b7388e6a66d5b6cff7a417fc56a59eb7e03acdfd3305842295c7f19e", + "size": 1094536, + "subdir": "linux-64", + "timestamp": 1525470766780, + "version": "0.17.4" + }, + "dask-core-0.17.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ff89042bb98b837659841223cbf0d3c0", + "name": "dask-core", + "sha256": "e5acd4dc723f597cadcec99ba57f4e9bec76520b4d0d48ef16f2d38bec437da9", + "size": 1082414, + "subdir": "linux-64", + "timestamp": 1525470682552, + "version": "0.17.4" + }, + "dask-core-0.17.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f5005a3d4fbda34dc904fa392f74a135", + "name": "dask-core", + "sha256": "2c332bfa444185011e96ad206a5dc91dbfe81a26d2174ac97857c1b9f33037ac", + "size": 1083064, + "subdir": "linux-64", + "timestamp": 1526527295232, + "version": "0.17.5" + }, + "dask-core-0.17.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5d1d6e3569c2e55174d7655c7d2c1a79", + "name": "dask-core", + "sha256": "022ac434873686e19fbb0e9f84c6a2d0ced5f0e058f5dc6f3587e6aed462faa1", + "size": 1097066, + "subdir": "linux-64", + "timestamp": 1526527275068, + "version": "0.17.5" + }, + "dask-core-0.17.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "63365b6e9ea015bde08b6aa6f1e566df", + "name": "dask-core", + "sha256": "1b66f114da9c2200e0163a3cf8cf484a316626aabc4d9f09b740f4af92a72116", + "size": 1085093, + "subdir": "linux-64", + "timestamp": 1526527279625, + "version": "0.17.5" + }, + "dask-core-0.18.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6f360e943aa85113381556535062ecf1", + "name": "dask-core", + "sha256": "6f337998ae6ee7418366ab71afbfe15f2cd3047951f44c9f9b8c15cb06508bd8", + "size": 1128400, + "subdir": "linux-64", + "timestamp": 1529076322740, + "version": "0.18.0" + }, + "dask-core-0.18.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a1d086a217f57726c48f11e1c88636d2", + "name": "dask-core", + "sha256": "28c874f2e100d0642ece027de0c50c2cd64865e6c8535b6a0ea0e4f2ab419638", + "size": 1155445, + "subdir": "linux-64", + "timestamp": 1529076389406, + "version": "0.18.0" + }, + "dask-core-0.18.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "26aa4a31c839dc2b6eb769936f47dadb", + "name": "dask-core", + "sha256": "1babe560793f37ec0bc7a65b28de511aa826b6c5cb0a9ad182ad4f7b7abdf48a", + "size": 1133742, + "subdir": "linux-64", + "timestamp": 1529076283730, + "version": "0.18.0" + }, + "dask-core-0.18.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "53494210696e9dc9c0011d2d2364dbd9", + "name": "dask-core", + "sha256": "035d302479b2e0b2afcdb614d6585e7068289fb4db3e56986a7fa07afa35009d", + "size": 1137450, + "subdir": "linux-64", + "timestamp": 1529768094770, + "version": "0.18.1" + }, + "dask-core-0.18.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "975a4d220e4a7dee4a0c39d35816d97a", + "name": "dask-core", + "sha256": "47ee03f9522f2f63e14017f4bdd6044845bbfbca30d32d4cdd4cf2a58cf0ca74", + "size": 1169209, + "subdir": "linux-64", + "timestamp": 1529768114344, + "version": "0.18.1" + }, + "dask-core-0.18.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8a6818cd5b75a0e13a41bfd48b63b17a", + "name": "dask-core", + "sha256": "d8935f1ed1c1646a3464b00e5e07ab01e05acef41b922fe1268602dff9dd23d9", + "size": 1149766, + "subdir": "linux-64", + "timestamp": 1529768238843, + "version": "0.18.1" + }, + "dask-core-0.18.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b588b82ed4234bc1a2cd9a903a162c80", + "name": "dask-core", + "sha256": "e917ebd9f33ec97685923a1754d7523e27cee03669f9c1644dd173adab58b701", + "size": 1140718, + "subdir": "linux-64", + "timestamp": 1530741212854, + "version": "0.18.1" + }, + "dask-core-0.18.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c5f0237c20abe0bd4a07516783444563", + "name": "dask-core", + "sha256": "cf13dd410104ddb5106c84ee01666c3f1888f654a688d416e00950d39711892d", + "size": 1158325, + "subdir": "linux-64", + "timestamp": 1532441219062, + "version": "0.18.2" + }, + "dask-core-0.18.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "af7e605cba1afbfc26e6c36a4265b6ef", + "name": "dask-core", + "sha256": "e7833eb62022a12cafad4acb9c3e9eca129e8a6fc76d298adf6009efd9a102ed", + "size": 1188908, + "subdir": "linux-64", + "timestamp": 1532441260108, + "version": "0.18.2" + }, + "dask-core-0.18.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "40cdddcd1e27ab28644b66acb6c832a4", + "name": "dask-core", + "sha256": "728ce4b13e96dedd424a440304519903745744b9b4af5747ec52e1b2973d2808", + "size": 1180218, + "subdir": "linux-64", + "timestamp": 1532441205887, + "version": "0.18.2" + }, + "dask-core-0.18.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a1854b9979b217f1e2ac5f3f7ec52153", + "name": "dask-core", + "sha256": "770ff6a74cfd055158557d01fced466df768eda4593e257aa4f09c16f415acbe", + "size": 1175564, + "subdir": "linux-64", + "timestamp": 1532441228915, + "version": "0.18.2" + }, + "dask-core-0.19.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f79b1b8e560ca9e5b973637fcd8b0508", + "name": "dask-core", + "sha256": "c19343b2a3222139957dd99381c251b521752cc3a4178cb2a6b14d8dec1621fb", + "size": 1170345, + "subdir": "linux-64", + "timestamp": 1535658877256, + "version": "0.19.0" + }, + "dask-core-0.19.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5122cbfd74a01f46dc9728f430c19a0f", + "name": "dask-core", + "sha256": "68cd047d842dc3355125d9e14781a3f4c92a1790489270075c6c656291f4a9aa", + "size": 1182865, + "subdir": "linux-64", + "timestamp": 1535658891039, + "version": "0.19.0" + }, + "dask-core-0.19.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cebd8b0c1b7d5822591ced98937ce497", + "name": "dask-core", + "sha256": "ac97f9b1a07de75ce636a7febecb7ac6cadbec941531d522b6cad8046d334c5d", + "size": 1175460, + "subdir": "linux-64", + "timestamp": 1535658867426, + "version": "0.19.0" + }, + "dask-core-0.19.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d505bf8ec570ffd24b5b7ec871235689", + "name": "dask-core", + "sha256": "9dd405426e25d4682c8f3a955c34ac3e26f5e33cb6c778afd7d99fd7eef65cf2", + "size": 1168815, + "subdir": "linux-64", + "timestamp": 1535658875766, + "version": "0.19.0" + }, + "dask-core-0.19.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c3268029e80b709b02c0e803baee5b69", + "name": "dask-core", + "sha256": "6d42cd7035e240f13f13e366a80b167c52e7117b299633a29ca320f8ce68167a", + "size": 1183654, + "subdir": "linux-64", + "timestamp": 1536247992260, + "version": "0.19.1" + }, + "dask-core-0.19.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d01d5cbc7a52c4069b3dfdbe11f890e0", + "name": "dask-core", + "sha256": "f911ad085caece2100d42ccce95004b730a2f7a66731b6d3db7b5c191aed2e70", + "size": 1195900, + "subdir": "linux-64", + "timestamp": 1536248050360, + "version": "0.19.1" + }, + "dask-core-0.19.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "461315aac59d7cfc057ce8919362370a", + "name": "dask-core", + "sha256": "fe94296bdcda1b82508456417505bf603f949e235f8d5b30f20745b0a530b538", + "size": 1188509, + "subdir": "linux-64", + "timestamp": 1536247978010, + "version": "0.19.1" + }, + "dask-core-0.19.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2ebb3cd21e92a2c3824f8ec960a640d2", + "name": "dask-core", + "sha256": "b2539cc88db830e86614144f85f8b05cf61b2ca7c1924bd0a88ec8f3ccb8d6dc", + "size": 1181207, + "subdir": "linux-64", + "timestamp": 1536248085221, + "version": "0.19.1" + }, + "dask-core-0.19.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "eacdb796bd63a83a8d553a18bd8aaff3", + "name": "dask-core", + "sha256": "8ce7c8c2ac6315915b2aafb6f37ad11d4dfdb0360860c2c167fd2bc011767495", + "size": 1187357, + "subdir": "linux-64", + "timestamp": 1538069037064, + "version": "0.19.2" + }, + "dask-core-0.19.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "654d84a608bd7f3c995da776a9023c66", + "name": "dask-core", + "sha256": "ba496f9e98af956944feb49f6545ce786b89baa1c4284ab7e75ea56830b2e342", + "size": 1197888, + "subdir": "linux-64", + "timestamp": 1538069035812, + "version": "0.19.2" + }, + "dask-core-0.19.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f1b109ca0d00fa407d3bca9d7caafa8c", + "name": "dask-core", + "sha256": "bc5e96fea26d80b3e2c86c614e4c38a631b40abb7fdce71a74974443ec2faf39", + "size": 1189916, + "subdir": "linux-64", + "timestamp": 1538069044631, + "version": "0.19.2" + }, + "dask-core-0.19.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b37b8e2ce3d3c61ed87b581a3cf78b20", + "name": "dask-core", + "sha256": "8984e7ecc392f6f6ca515781bdbe2c7234b436470a2e11d6b7f062f9faae03b3", + "size": 1181616, + "subdir": "linux-64", + "timestamp": 1538069005665, + "version": "0.19.2" + }, + "dask-core-0.19.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ef2d39f92d3bb7058747d77928305334", + "name": "dask-core", + "sha256": "80a7f6840bf356909859b3afb1052278a30ecd8ab70aed1663dcbc5ef5aca79a", + "size": 1209795, + "subdir": "linux-64", + "timestamp": 1539016952415, + "version": "0.19.3" + }, + "dask-core-0.19.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6c067531b1e7d9e22e6e8ae7a26659ef", + "name": "dask-core", + "sha256": "da66523e2e533b4b404ada155d3262eff6ac04f240e0fd18d68e1c19b3af4dee", + "size": 1213309, + "subdir": "linux-64", + "timestamp": 1539016975625, + "version": "0.19.3" + }, + "dask-core-0.19.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "04ec6c6354c46da3fc0edd7b45343ee4", + "name": "dask-core", + "sha256": "cc81e55ba3bfdfd6a478d130aa00b3aaf304ba9862f33e0e8d3be9814cfa2345", + "size": 1204270, + "subdir": "linux-64", + "timestamp": 1539016953211, + "version": "0.19.3" + }, + "dask-core-0.19.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a61c6b578ff1d09e33f833b382e12f65", + "name": "dask-core", + "sha256": "87961331fdc219b0713c866d05125dccf5afa0c82df0c40efb2ddc5a687228f0", + "size": 1223582, + "subdir": "linux-64", + "timestamp": 1539473878214, + "version": "0.19.4" + }, + "dask-core-0.19.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "35028f0f1df3caf6743f828c396ada0d", + "name": "dask-core", + "sha256": "bb956c26edb36542ebc24ec741d57fd727554b4a7e250c6a36c031d94c9a9e96", + "size": 1224641, + "subdir": "linux-64", + "timestamp": 1539473895115, + "version": "0.19.4" + }, + "dask-core-0.19.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "90d6c3112e866bdfc177fa26f44595c1", + "name": "dask-core", + "sha256": "a5df02b8967406a975417abf5ef6c9f14eb84d900069266fefff2bc4e50a6c98", + "size": 1216423, + "subdir": "linux-64", + "timestamp": 1539473901642, + "version": "0.19.4" + }, + "dask-core-0.20.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7aa5415bcfcfaac00f3a514a4688db0d", + "name": "dask-core", + "sha256": "4cf4e1eb0c62f85a62d7722e094c7af72653f631b242704845246b32741c0638", + "size": 1230875, + "subdir": "linux-64", + "timestamp": 1540830594298, + "version": "0.20.0" + }, + "dask-core-0.20.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0bc0a80e67fe847196a31e45c4828742", + "name": "dask-core", + "sha256": "3db941f5af3fe4996539e881e3a0b536e0801cc6acd9879b58b3de230b2e0435", + "size": 1241097, + "subdir": "linux-64", + "timestamp": 1540830666301, + "version": "0.20.0" + }, + "dask-core-0.20.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6f5e4284ff33ba53d3bd0a233ce837d5", + "name": "dask-core", + "sha256": "01fa25f778a7a2d5045c52ea6848bb59c30cf62b585f18ce136c102d8170d3cb", + "size": 1232325, + "subdir": "linux-64", + "timestamp": 1540830662585, + "version": "0.20.0" + }, + "dask-core-0.20.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "768a61ada770ed506a74fec6b13882da", + "name": "dask-core", + "sha256": "d92f5513a6cdce49c6877264c9c2a715bdcc709f1c856eea2902ffb795f15cdb", + "size": 1266750, + "subdir": "linux-64", + "timestamp": 1542077389304, + "version": "0.20.1" + }, + "dask-core-0.20.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "99813e1270c8f03ef550f50321dae47e", + "name": "dask-core", + "sha256": "fd0dd139bd27eb454b2a3ffac16c23fcccfb662eb6eb03c18441c83e5bba9ec6", + "size": 1261579, + "subdir": "linux-64", + "timestamp": 1542077488028, + "version": "0.20.1" + }, + "dask-core-0.20.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0fec90133bc75674037848c2b45361ce", + "name": "dask-core", + "sha256": "e69cc29f14befdd3def21528bb94004ee9291f9a5f20c899fc76a5912c31efda", + "size": 1259146, + "subdir": "linux-64", + "timestamp": 1542077390435, + "version": "0.20.1" + }, + "dask-core-0.20.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "be425bb02b67bba765a83a0408e45ee4", + "name": "dask-core", + "sha256": "13db1e8c1575ce66a8efc80726d3c76bdeb90d6d354650856fa695e8a6715f70", + "size": 1266084, + "subdir": "linux-64", + "timestamp": 1542386428139, + "version": "0.20.2" + }, + "dask-core-0.20.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f14c8c0a09e01ce442c80a03531ead11", + "name": "dask-core", + "sha256": "ed42934158a18873dd049568bf1dcd1209aef5549cf0f7f564b2ccdfcd3bf1a2", + "size": 1264905, + "subdir": "linux-64", + "timestamp": 1542386438645, + "version": "0.20.2" + }, + "dask-core-0.20.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "aa6366149e83ec8725dc5fe57d140a84", + "name": "dask-core", + "sha256": "604e34d01d6ae686ec9519abb0ac7788d96344a224c7326ca430dd71f21a9293", + "size": 1256832, + "subdir": "linux-64", + "timestamp": 1542386427430, + "version": "0.20.2" + }, + "dask-core-1.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "241b709c62bbaca165e4704921124f8e", + "name": "dask-core", + "sha256": "0b16063cb2307ca889b0e60ea067df35afccaddbc48773966418db21aab5a154", + "size": 1235206, + "subdir": "linux-64", + "timestamp": 1543503953579, + "version": "1.0.0" + }, + "dask-core-1.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a905fd94ffd787cd5d9d3fde054b4dd5", + "name": "dask-core", + "sha256": "3597f33916887d3660fcaca7e80dd037bccf02bcd591560bc227927a95002320", + "size": 1242716, + "subdir": "linux-64", + "timestamp": 1543503958205, + "version": "1.0.0" + }, + "dask-core-1.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "64c2a44d83076382cf6bd6446ac56bc2", + "name": "dask-core", + "sha256": "807f446499df649aaea8861ed3e1c2405fa7dfdfbea4f4e32df8e1be5936cd6e", + "size": 1234773, + "subdir": "linux-64", + "timestamp": 1543503946475, + "version": "1.0.0" + }, + "dask-core-1.1.4-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0cdfc9c4a88f4ea2ca6a60adbd0e82e1", + "name": "dask-core", + "sha256": "c73bd95b723899eeba22a9066411f1f51f795f0941239bfd025103b6463ad3e4", + "size": 1294879, + "subdir": "linux-64", + "timestamp": 1553289261066, + "version": "1.1.4" + }, + "dask-core-1.1.4-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5ab1be09bb8d637021b9ddc83dabc055", + "name": "dask-core", + "sha256": "f9401e54c7018546256ad047270b0e4e17e45bde10fc10b181d1802479a3e1f2", + "size": 1294444, + "subdir": "linux-64", + "timestamp": 1553289398919, + "version": "1.1.4" + }, + "dask-core-1.1.4-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9c8fe15d715994c0e81412bbc7b3fc93", + "name": "dask-core", + "sha256": "c8bc5ded16ef0ab4734fcb7dc8966d9c2630c79f11a40eb552e5b44405743b7e", + "size": 1287170, + "subdir": "linux-64", + "timestamp": 1553290469269, + "version": "1.1.4" + }, + "dask-core-2022.5.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "packaging >=20.0", + "partd >=0.3.10", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cf7b75ca14dd026487396eafcae166fe", + "name": "dask-core", + "sha256": "7230a219326e9c49372bd29e6cbc2049470c13cd928c6608092aed474a145c96", + "size": 1965939, + "subdir": "linux-64", + "timestamp": 1653082150114, + "version": "2022.5.0" + }, + "dask-core-2022.5.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "packaging >=20.0", + "partd >=0.3.10", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c3f5b197a0c0e83e6cba915a49664f5a", + "name": "dask-core", + "sha256": "aa215c22c44a57ee19485574a841ef816f2b748f37c3f490269539a73dc56503", + "size": 2715446, + "subdir": "linux-64", + "timestamp": 1676830456388, + "version": "2022.5.0" + }, + "dask-core-2022.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "packaging >=20.0", + "partd >=0.3.10", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "35d94edeac2bff9c5c93884ac54f3e9f", + "name": "dask-core", + "sha256": "4f34bef31f72c541f1f6511318e687113f371ce4dc56c04f1f06af04644ceabc", + "size": 1951971, + "subdir": "linux-64", + "timestamp": 1653082182985, + "version": "2022.5.0" + }, + "dask-core-2022.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "packaging >=20.0", + "partd >=0.3.10", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e12fb7a1312c3e6e75b4f35dcfb41a0f", + "name": "dask-core", + "sha256": "b3a154cc4a23d51af90f1779377271ef62625c0a13c2e97bc1675f8ac92dd1ff", + "size": 1947133, + "subdir": "linux-64", + "timestamp": 1653082218001, + "version": "2022.5.0" + }, + "dask-core-2022.7.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "packaging >=20.0", + "partd >=0.3.10", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3ac199e0e09d15405ba23790e385e824", + "name": "dask-core", + "sha256": "1379791fcd78387b69564db43258b0a9fa6e248aae20c2319739a627bcef01d1", + "size": 2018070, + "subdir": "linux-64", + "timestamp": 1658513320718, + "version": "2022.7.0" + }, + "dask-core-2022.7.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "packaging >=20.0", + "partd >=0.3.10", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "782b2d29b4ed5836a86512e1c7dc9b03", + "name": "dask-core", + "sha256": "0b71b49ca453b1439817d30e212365bdf5efc64eabc4be51a901969b31db1a32", + "size": 2791276, + "subdir": "linux-64", + "timestamp": 1679335874349, + "version": "2022.7.0" + }, + "dask-core-2022.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "packaging >=20.0", + "partd >=0.3.10", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e6c2292569543bf3e756c5d2c7900ccb", + "name": "dask-core", + "sha256": "c0fa4a868c3d61a38fdaa9608d1f8d17614f58ceff66b520403e9bc1ce4e32bd", + "size": 2004024, + "subdir": "linux-64", + "timestamp": 1658513277567, + "version": "2022.7.0" + }, + "dask-core-2022.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "packaging >=20.0", + "partd >=0.3.10", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "504af48c3e25553f1dff3183bd10bf96", + "name": "dask-core", + "sha256": "9124737c50b757a68afcefddd5a96ef514d3b040233939d56561c07c7cb05def", + "size": 2001973, + "subdir": "linux-64", + "timestamp": 1658513245185, + "version": "2022.7.0" + }, + "dask-core-2023.3.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.0", + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "importlib-metadata >=4.13.0", + "packaging >=20.0", + "partd >=1.2.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a503259bf3f2c411da29c1111e42caee", + "name": "dask-core", + "sha256": "660e37b60bc14092f46fb6fe6ead333910b45db115f2af955ae524dbb5031a0f", + "size": 2127453, + "subdir": "linux-64", + "timestamp": 1680090611186, + "version": "2023.3.2" + }, + "dask-core-2023.3.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.0", + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "importlib-metadata >=4.13.0", + "packaging >=20.0", + "partd >=1.2.0", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9c6c6311aee1cf33f98eff9ad90ad3d8", + "name": "dask-core", + "sha256": "2c443ec052b61773ccef57c8ae947dd4b03aa295dd09c16831a89abc7c7ee78f", + "size": 2935696, + "subdir": "linux-64", + "timestamp": 1680090540232, + "version": "2023.3.2" + }, + "dask-core-2023.3.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.0", + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "importlib-metadata >=4.13.0", + "packaging >=20.0", + "partd >=1.2.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2384b4a181e248736addf36c7096221e", + "name": "dask-core", + "sha256": "455caef4c265b2962e3ee253054671938a290f1e91699a2ffde95986ea80c6c9", + "size": 2111991, + "subdir": "linux-64", + "timestamp": 1680090645829, + "version": "2023.3.2" + }, + "dask-core-2023.3.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.0", + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "importlib-metadata >=4.13.0", + "packaging >=20.0", + "partd >=1.2.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "58ac265a53ac6c98c5685846d74547c8", + "name": "dask-core", + "sha256": "9e6f85820e82b8a99f953379b4cf9af08084b8409b6c42f8a32fdfac0449a509", + "size": 2108568, + "subdir": "linux-64", + "timestamp": 1680090574965, + "version": "2023.3.2" + }, + "dask-glm-0.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=2.7,<2.8.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b3ca9a885604896f24bdc1922b26afd8", + "name": "dask-glm", + "sha256": "0790b6153abf22f6703b830a9da062d57d27ba5fe60a389149edd075582d0837", + "size": 23859, + "subdir": "linux-64", + "timestamp": 1530842711639, + "version": "0.1.0" + }, + "dask-glm-0.1.0-py27h0d5619a_0.tar.bz2": { + "build": "py27h0d5619a_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=2.7,<2.8.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e28e6b68ee175f234d09494405f46303", + "name": "dask-glm", + "sha256": "712d793d18703ab62a98434c01441598433a2dcd4cbe6ceff7a5b73dcb1df0c0", + "size": 24248, + "subdir": "linux-64", + "timestamp": 1511217833354, + "version": "0.1.0" + }, + "dask-glm-0.1.0-py35h984da01_0.tar.bz2": { + "build": "py35h984da01_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=3.5,<3.6.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9fa0522907c67ef4329e499ec8a43447", + "name": "dask-glm", + "sha256": "0f0399f7dc2121860077f586265e42f9b30cbedc149049d00225d98794dee62e", + "size": 24914, + "subdir": "linux-64", + "timestamp": 1511217906248, + "version": "0.1.0" + }, + "dask-glm-0.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88f47384043347b3b61dac862961f676", + "name": "dask-glm", + "sha256": "1af03d86000fdef159e3896396afd3d16e099b5c2f3ae5bf744b871cef9041ff", + "size": 24471, + "subdir": "linux-64", + "timestamp": 1530842742257, + "version": "0.1.0" + }, + "dask-glm-0.1.0-py36h1ff08bd_0.tar.bz2": { + "build": "py36h1ff08bd_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2209b08006bb35c2f1356dba51667b07", + "name": "dask-glm", + "sha256": "29ef78b020fded5dd15a01942d8176b0a231a14266e3487daad4d6fa9d5f2a8e", + "size": 24836, + "subdir": "linux-64", + "timestamp": 1511217841338, + "version": "0.1.0" + }, + "dask-glm-0.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0d3b663cc7ef09fd629848dfb57c99af", + "name": "dask-glm", + "sha256": "91d2fc334e724ea3c2345d8971727928c990bde47e039e2f7c78ec5afc6a4647", + "size": 24531, + "subdir": "linux-64", + "timestamp": 1530842681903, + "version": "0.1.0" + }, + "dask-glm-0.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=2.7,<2.8.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "883f9409f563607a21545f3f1cbb397b", + "name": "dask-glm", + "sha256": "1c043e100116d61915b942fcb3420ea8c4d057e94586cd11b17523089bc59968", + "size": 24176, + "subdir": "linux-64", + "timestamp": 1540963173751, + "version": "0.2.0" + }, + "dask-glm-0.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cb2fcdeacebb8079feb881b47243c961", + "name": "dask-glm", + "sha256": "b10d48c5f03696aba5f55f255227ff18b862957995341243a85a70da328ca4d2", + "size": 25197, + "subdir": "linux-64", + "timestamp": 1642517256876, + "version": "0.2.0" + }, + "dask-glm-0.2.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=3.11,<3.12.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5afa50e15ab3342acc286ee33bedd04b", + "name": "dask-glm", + "sha256": "a2a30786fd5278219ec898dcd2998afb6b71f9f983d972fd6872b2242823e501", + "size": 32597, + "subdir": "linux-64", + "timestamp": 1676851856499, + "version": "0.2.0" + }, + "dask-glm-0.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1c8caf3b55ab0a2f5c321ee6db1a031b", + "name": "dask-glm", + "sha256": "62f59407089dafebc1b581a0aef4a755c29b4c645ccea571624332e461f2b9c0", + "size": 24751, + "subdir": "linux-64", + "timestamp": 1540963196507, + "version": "0.2.0" + }, + "dask-glm-0.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "61caae644f6fef044cf761e4b297fe29", + "name": "dask-glm", + "sha256": "e687138a4c3a04464022c84b02e90272bcdf4f8b5940989c73e2e3ed5b0a6730", + "size": 24859, + "subdir": "linux-64", + "timestamp": 1540963181258, + "version": "0.2.0" + }, + "dask-glm-0.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85624690fc48269337bdb738e5ad5c7b", + "name": "dask-glm", + "sha256": "fa64c42e8f69166bbde17bb52212e0801450c7fe65f3c16f88bc61579169cb69", + "size": 25268, + "subdir": "linux-64", + "timestamp": 1574235675962, + "version": "0.2.0" + }, + "dask-ml-0.10.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "08a3d54762fdd4e4fdda938002c51c78", + "name": "dask-ml", + "sha256": "1032a991061127dabdcf4b3442a4e56b173134384f12dc12ac79cdffa91a0e8f", + "size": 137124, + "subdir": "linux-64", + "timestamp": 1538172041983, + "version": "0.10.0" + }, + "dask-ml-0.10.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50950f0b8da451e6c1acb5d6e193127f", + "name": "dask-ml", + "sha256": "3291dacc59eb5dd8b83db8d863bf0631ba3d2b70f88b5c04e13bf32ff1ce1aa8", + "size": 138984, + "subdir": "linux-64", + "timestamp": 1538172071259, + "version": "0.10.0" + }, + "dask-ml-0.10.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "653640cfab848db81e86704e3cfeb241", + "name": "dask-ml", + "sha256": "0bf94ff6c12a974b9c922cd17c185e0413bca4238bbbd8c52c414f63bf11975b", + "size": 139105, + "subdir": "linux-64", + "timestamp": 1538172047625, + "version": "0.10.0" + }, + "dask-ml-0.11.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=2.7,<2.8.0a0", + "scikit-learn >=0.20.0", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ccb1b552d9fc655fcb624798f02aeb40", + "name": "dask-ml", + "sha256": "bb37f8c3cf17be46f39169711f0b972c931e424d06640d8ba349395a58054315", + "size": 145940, + "subdir": "linux-64", + "timestamp": 1540963772729, + "version": "0.11.0" + }, + "dask-ml-0.11.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.20.0", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "08935474998665426cddb883dd803c16", + "name": "dask-ml", + "sha256": "97cefd588e15b0912c79334fe18086a713fe7e69df7333f41d2eddaec4a4db58", + "size": 147962, + "subdir": "linux-64", + "timestamp": 1540963836429, + "version": "0.11.0" + }, + "dask-ml-0.11.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.20.0", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50661d4918a77d6b868e96c6a937a379", + "name": "dask-ml", + "sha256": "d832f3443c498877bcb8a2fa4d8dcfb16cb1016eb23abf01fab1f95adf4dbd96", + "size": 148213, + "subdir": "linux-64", + "timestamp": 1540963783242, + "version": "0.11.0" + }, + "dask-ml-0.3.2-py27h2dd1506_0.tar.bz2": { + "build": "py27h2dd1506_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d51189e573478912e22f5cc7a0642f7f", + "name": "dask-ml", + "sha256": "3956061a9f68a0faab508b91dd30d07a4693a631efec9f471fbc177c886cdf4a", + "size": 147066, + "subdir": "linux-64", + "timestamp": 1511218792413, + "version": "0.3.2" + }, + "dask-ml-0.3.2-py35hf347010_0.tar.bz2": { + "build": "py35hf347010_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "94c8d0943f9e39531baaa57e053a6d18", + "name": "dask-ml", + "sha256": "b17f418b90817ceafb98114c6217f7a3bdf2b0d173f3785bc925154ca04c8043", + "size": 141952, + "subdir": "linux-64", + "timestamp": 1511218910374, + "version": "0.3.2" + }, + "dask-ml-0.3.2-py36h51e09e3_0.tar.bz2": { + "build": "py36h51e09e3_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "780ab4af737ff4889f92b01ecdd3a28b", + "name": "dask-ml", + "sha256": "813574bada6d0135ddbbc68f0752dc7deaadaf7ac432c36cc4ee5111f6689b72", + "size": 142636, + "subdir": "linux-64", + "timestamp": 1511218911865, + "version": "0.3.2" + }, + "dask-ml-0.4.1-py27h3010b51_0.tar.bz2": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0ea79b6dd15a1d362f555a4dbb7ae9f2", + "name": "dask-ml", + "sha256": "81af0c1f212c9cf2ce68fcd3590d842237c3b58ef80148181636975d2ad08158", + "size": 162606, + "subdir": "linux-64", + "timestamp": 1519495484756, + "version": "0.4.1" + }, + "dask-ml-0.4.1-py35h3010b51_0.tar.bz2": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1ef5eb387f7217d36c884c403fa3b530", + "name": "dask-ml", + "sha256": "cce53475ba29a82178196c2e2998da5cd2d615cd2ea1f18ec377bef4ec390cae", + "size": 157735, + "subdir": "linux-64", + "timestamp": 1519496624631, + "version": "0.4.1" + }, + "dask-ml-0.4.1-py36h3010b51_0.tar.bz2": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a96e9b2ed99d26319cefebaf318984fd", + "name": "dask-ml", + "sha256": "4735b200cac8a297f213a4781a8d2ae25ec4f913cbf53753a30bba6b8f8c5f5c", + "size": 158474, + "subdir": "linux-64", + "timestamp": 1519494998311, + "version": "0.4.1" + }, + "dask-ml-0.6.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7958456407926cccedbfd6073826a052", + "name": "dask-ml", + "sha256": "591bb17e818c9ddca28c8b867d3534b0681a91cbc88f1f1a6f1634ba5c13e80e", + "size": 178719, + "subdir": "linux-64", + "timestamp": 1529443076307, + "version": "0.6.0" + }, + "dask-ml-0.6.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e04bdd0737f8ffae04bb9ef69581b9dd", + "name": "dask-ml", + "sha256": "e7a4ffe68bd479325161e540613f5fc8f9088eb02c9020518db38879a4322465", + "size": 174070, + "subdir": "linux-64", + "timestamp": 1529443103569, + "version": "0.6.0" + }, + "dask-ml-0.6.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "12ba701c3c1f541a6db6117ebb461888", + "name": "dask-ml", + "sha256": "4456ddc620e10db8294066e785bccf8df2a5a4882eabb7f045d420dfe49c3199", + "size": 174489, + "subdir": "linux-64", + "timestamp": 1529443320632, + "version": "0.6.0" + }, + "dask-ml-0.6.0-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1a6e8874560471936b08333b42cc1fc3", + "name": "dask-ml", + "sha256": "a3daf3cc34f5eefe3b3975beffdb84601213d0fd7a3a9bd26d29b0c9d254f8b0", + "size": 174689, + "subdir": "linux-64", + "timestamp": 1530842889224, + "version": "0.6.0" + }, + "dask-ml-0.7.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ab02c91b59f3e9e5a30dbb3c2779f7c0", + "name": "dask-ml", + "sha256": "c8a2e9fd565a4943a546b8c8fa7f0d93ea29201c157c01ed23bd5ebaa6482f6f", + "size": 213577, + "subdir": "linux-64", + "timestamp": 1532555180999, + "version": "0.7.0" + }, + "dask-ml-0.7.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22b07e46314d7d39120d6db4851f05e9", + "name": "dask-ml", + "sha256": "765af3c0afa38948f7a1a088b646627d8f4ed5c6958cab0ead13b88f2f3fc65a", + "size": 210163, + "subdir": "linux-64", + "timestamp": 1532555182227, + "version": "0.7.0" + }, + "dask-ml-0.7.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e74565e5a63dedf716b227134d5a2a5e", + "name": "dask-ml", + "sha256": "87da96c95e45e30180e59fa9fd3d5f9b9c49267f2c5b01ee06b166111bc05ef1", + "size": 209786, + "subdir": "linux-64", + "timestamp": 1532555083258, + "version": "0.7.0" + }, + "dask-ml-0.7.0-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e387ad0d7c8af8b311352be2fc096561", + "name": "dask-ml", + "sha256": "a7cd3965db805d6f1ba1cd1545cebe9d8153ff7208793a9c4f44be9b69db835f", + "size": 209663, + "subdir": "linux-64", + "timestamp": 1532555158952, + "version": "0.7.0" + }, + "dask-ml-0.8.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "packaging", + "pandas", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6f8dd41b64cfa363df27e6ff4be1ef1f", + "name": "dask-ml", + "sha256": "f45b1fcecb5aef78fc2f21927ef6447260f175817f6b9975cc8045565b0fb3fe", + "size": 223391, + "subdir": "linux-64", + "timestamp": 1534426732820, + "version": "0.8.0" + }, + "dask-ml-0.8.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "packaging", + "pandas", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a255f973bca4bec7fc2f59ccd9e648d3", + "name": "dask-ml", + "sha256": "1a3d0789f84e2baadd9d079bd7e21bbd4fdf3848d6e95478c9360ac5cc369216", + "size": 220493, + "subdir": "linux-64", + "timestamp": 1534426900644, + "version": "0.8.0" + }, + "dask-ml-0.8.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "packaging", + "pandas", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "566c25505ffe321bdc1c4ec19a4ba9ed", + "name": "dask-ml", + "sha256": "db48bef018e11d4797c24bb3d968b603984ea48e2daedb53863352a936e62294", + "size": 220021, + "subdir": "linux-64", + "timestamp": 1534426677426, + "version": "0.8.0" + }, + "dask-ml-0.8.0-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "packaging", + "pandas", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d73ee967274f8bfd895f3220b2d58096", + "name": "dask-ml", + "sha256": "8ebb79fb48bfdb722ae7f0644789d5dff33720dd9d450618f975c93bd69d2a50", + "size": 219846, + "subdir": "linux-64", + "timestamp": 1534426807012, + "version": "0.8.0" + }, + "dask-ml-0.9.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "10f24210e3ab29b1ef8515e3e8c45d31", + "name": "dask-ml", + "sha256": "5f97252455b18062f563356c3b48b31c148603b7153fb4661ceffedb6cb12b74", + "size": 125128, + "subdir": "linux-64", + "timestamp": 1535636912531, + "version": "0.9.0" + }, + "dask-ml-0.9.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eb4913f1fed702a65896bb333f1d3a3e", + "name": "dask-ml", + "sha256": "0e0b000e8712346c5726cfaf5e55a44eb0981c1f198c0bf7f74f971becdf451e", + "size": 127889, + "subdir": "linux-64", + "timestamp": 1535636909000, + "version": "0.9.0" + }, + "dask-ml-0.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dc36ca27ac4332ddaca2cd19cb69edab", + "name": "dask-ml", + "sha256": "be09d4f7b9614634dd510e35cd97c7d42bca40d8a43e67f60f83892939350acd", + "size": 127158, + "subdir": "linux-64", + "timestamp": 1535636880197, + "version": "0.9.0" + }, + "dask-ml-0.9.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cab8edcedf081b9e365b639918bd96ad", + "name": "dask-ml", + "sha256": "65a87061c8b67f5ac4879790f5ddb75025e16185f5527d66f8dd41ba3259f3d6", + "size": 127408, + "subdir": "linux-64", + "timestamp": 1535636951756, + "version": "0.9.0" + }, + "dask-ml-2022.5.27-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.4.0", + "dask-glm >=0.2.0", + "distributed >=2.4.0", + "multipledispatch >=0.4.9", + "numba >=0.51.0", + "numpy >=1.20.0", + "packaging", + "pandas >=0.24.2", + "python >=3.10,<3.11.0a0", + "scikit-learn >=1.0.0", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "80b9aae2240519bab3188822c0064a53", + "name": "dask-ml", + "sha256": "4b2561ae929c5cc2c69c801fc36b282837a5c1aaf80f1ce34fbe702bd8c2fd00", + "size": 211079, + "subdir": "linux-64", + "timestamp": 1672127756481, + "version": "2022.5.27" + }, + "dask-ml-2022.5.27-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.4.0", + "dask-glm >=0.2.0", + "distributed >=2.4.0", + "multipledispatch >=0.4.9", + "numba >=0.51.0", + "numpy >=1.20.0", + "packaging", + "pandas >=0.24.2", + "python >=3.7,<3.8.0a0", + "scikit-learn >=1.0.0", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "af8a6138c343b766f0e677afa84de63c", + "name": "dask-ml", + "sha256": "65366360e83d7e010a3da23fe4eae751d386a864fe2a07881a1aa0ffa3f21792", + "size": 207117, + "subdir": "linux-64", + "timestamp": 1672127655515, + "version": "2022.5.27" + }, + "dask-ml-2022.5.27-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.4.0", + "dask-glm >=0.2.0", + "distributed >=2.4.0", + "multipledispatch >=0.4.9", + "numba >=0.51.0", + "numpy >=1.20.0", + "packaging", + "pandas >=0.24.2", + "python >=3.8,<3.9.0a0", + "scikit-learn >=1.0.0", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6311dd5db51e6a320fd2c1df7cb7949c", + "name": "dask-ml", + "sha256": "4affcf81b4e49b1ad988bcf48de20f80b911b992c994acf64bcf0aa8a97a8c55", + "size": 208348, + "subdir": "linux-64", + "timestamp": 1672127707877, + "version": "2022.5.27" + }, + "dask-ml-2022.5.27-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.4.0", + "dask-glm >=0.2.0", + "distributed >=2.4.0", + "multipledispatch >=0.4.9", + "numba >=0.51.0", + "numpy >=1.20.0", + "packaging", + "pandas >=0.24.2", + "python >=3.9,<3.10.0a0", + "scikit-learn >=1.0.0", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d896b24b475557c3b6d3f3bccebeefc6", + "name": "dask-ml", + "sha256": "f427309d7f66fa9465ed211fcb6ad59bb589863c69e359e643ed1630177ba5ef", + "size": 208314, + "subdir": "linux-64", + "timestamp": 1672127806612, + "version": "2022.5.27" + }, + "dask-searchcv-0.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "dask >=0.14.0", + "numpy >=1.8.0", + "python >=2.7,<2.8.0a0", + "scikit-learn >=0.18.0", + "scipy >=0.13.0", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "397743039f1f14f6d0c93f2a510f98f0", + "name": "dask-searchcv", + "sha256": "2fdd83193386d0ab2f4ca48fd2e64860ecf3cab4459a237d8a8d4d7866a5853d", + "size": 69865, + "subdir": "linux-64", + "timestamp": 1530842807485, + "version": "0.2.0" + }, + "dask-searchcv-0.2.0-py27h5e106ca_0.tar.bz2": { + "build": "py27h5e106ca_0", + "build_number": 0, + "depends": [ + "dask >=0.14.0", + "numpy >=1.8.0", + "python >=2.7,<2.8.0a0", + "scikit-learn >=0.18.0", + "scipy >=0.13.0", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3c35d685a227dd00e79da88eb4b52eed", + "name": "dask-searchcv", + "sha256": "86aa57b220aeaeb518e6a6906df3c0538ca5490412a49f74c2d5c742fb7a4a98", + "size": 70149, + "subdir": "linux-64", + "timestamp": 1511217841659, + "version": "0.2.0" + }, + "dask-searchcv-0.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=0.14.0", + "numpy >=1.8.0", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.18.0", + "scipy >=0.13.0", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "13dabf59c15b7b95cd818730fbb96120", + "name": "dask-searchcv", + "sha256": "6bea99033b052158ff1f0234cf6f76d5bdd3a38fcb304f67ddd93748fc8107b4", + "size": 71880, + "subdir": "linux-64", + "timestamp": 1640811916097, + "version": "0.2.0" + }, + "dask-searchcv-0.2.0-py35h2cd24c2_0.tar.bz2": { + "build": "py35h2cd24c2_0", + "build_number": 0, + "depends": [ + "dask >=0.14.0", + "numpy >=1.8.0", + "python >=3.5,<3.6.0a0", + "scikit-learn >=0.18.0", + "scipy >=0.13.0", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e45b3d2a9b6ff5fb093e29e29fb9b74a", + "name": "dask-searchcv", + "sha256": "b16c536d2cfc5e8ceae55d2f5839631efba3b6b34ca9108a002d40f7b411c55f", + "size": 71353, + "subdir": "linux-64", + "timestamp": 1511217869648, + "version": "0.2.0" + }, + "dask-searchcv-0.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "dask >=0.14.0", + "numpy >=1.8.0", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.18.0", + "scipy >=0.13.0", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88ac7e7dae6ecae050b082810c7ea4b3", + "name": "dask-searchcv", + "sha256": "1b2a8faa550dc64b6a26f2a93f99277f0cfad9aa21da6767877df384e5e2791d", + "size": 70640, + "subdir": "linux-64", + "timestamp": 1530842838700, + "version": "0.2.0" + }, + "dask-searchcv-0.2.0-py36hae2c3c3_0.tar.bz2": { + "build": "py36hae2c3c3_0", + "build_number": 0, + "depends": [ + "dask >=0.14.0", + "numpy >=1.8.0", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.18.0", + "scipy >=0.13.0", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "186909d6de34551a9105d906157ebf41", + "name": "dask-searchcv", + "sha256": "718a6f1215c640d85d74f4e18c2890b8e3ab088930f6f9913b31902b6c649a4b", + "size": 70947, + "subdir": "linux-64", + "timestamp": 1511217906306, + "version": "0.2.0" + }, + "dask-searchcv-0.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dask >=0.14.0", + "numpy >=1.8.0", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.18.0", + "scipy >=0.13.0", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0d14b1c781490a571b5cf876716c1ee2", + "name": "dask-searchcv", + "sha256": "b7a8d10c4f1bcf94aab46306b6849ec8bee313bb50d705dda3f3dab785bc5226", + "size": 70660, + "subdir": "linux-64", + "timestamp": 1530842778271, + "version": "0.2.0" + }, + "dask-searchcv-0.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "dask >=0.14.0", + "numpy >=1.8.0", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.18.0", + "scipy >=0.13.0", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5faa3b145f8ba0b4c40f7d1b789c5b18", + "name": "dask-searchcv", + "sha256": "1330fa4fae402470966868f0f32dc3f02a619334da20cdcf2fab2585780920e0", + "size": 71572, + "subdir": "linux-64", + "timestamp": 1574235694589, + "version": "0.2.0" + }, + "dataclasses-0.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "88d77cd027341946f392f5df8d29ff5e", + "name": "dataclasses", + "sha256": "c4330cb1287c6ee489854ac0a27ae2abdfdfcc9c1cd0f097d3dc7c165fd78dbb", + "size": 31290, + "subdir": "linux-64", + "timestamp": 1582149830248, + "version": "0.7" + }, + "dataclasses-0.7-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "442794bb9e2e95fddfb6ad1d3cab5d4d", + "name": "dataclasses", + "sha256": "101afef233e5d2ccf6feb5ad69427d434ec3ef98ccfe066b816b0490ede52114", + "size": 31600, + "subdir": "linux-64", + "timestamp": 1614076478266, + "version": "0.7" + }, + "dataclasses-0.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "54999ec5363d03b0046f6db3d08cb0f2", + "name": "dataclasses", + "sha256": "96024b6547258a80dbf55037d9dca5e5daf1dc7896d3aeaf4f28478fd88f5220", + "size": 8646, + "subdir": "linux-64", + "timestamp": 1582149612209, + "version": "0.7" + }, + "dataclasses-0.7-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "9073015874f29c53911a3dff44e5303b", + "name": "dataclasses", + "sha256": "048217e4a3edee819daa07d65543696fe899f7c6ebe2b02eb05808957054b5b8", + "size": 8650, + "subdir": "linux-64", + "timestamp": 1614076480587, + "version": "0.7" + }, + "dataclasses-0.7-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "19f160d36f7a84c30f3adb2ea5a95814", + "name": "dataclasses", + "sha256": "131e1a307ef05582b3b2785545a5b447e4d7eaba98586350f6f9f6dc306d75a1", + "size": 8644, + "subdir": "linux-64", + "timestamp": 1582149808479, + "version": "0.7" + }, + "dataclasses-0.7-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "058e8a31cad2e4ed7fee4fb627a45609", + "name": "dataclasses", + "sha256": "79543dc9a1f03fa5a1b5a958142f5dc005d2e0956b2b76d85e1af491bec2b77f", + "size": 8647, + "subdir": "linux-64", + "timestamp": 1614076476338, + "version": "0.7" + }, + "dataclasses-0.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "b5e66958e0f2c7fb398f92502bbd8b2d", + "name": "dataclasses", + "sha256": "d9e57311932e7a4ec12ddc7d51ac69f4ce422095d2b1e97c5bbd83337f96f3c5", + "size": 8679, + "subdir": "linux-64", + "timestamp": 1614076040175, + "version": "0.7" + }, + "datasets-2.10.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "dill <0.3.7", + "fsspec >=2021.11.1", + "huggingface_hub >=0.2.0,<1.0.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "pyarrow >=6.0.0", + "python >=3.10,<3.11.0a0", + "python-xxhash", + "pyyaml >=5.1", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ac3832502a32dc34da13baa7a09951a2", + "name": "datasets", + "sha256": "864f8af5f9b2e79cf647c58c5fda730ab164274f1f35430fdfd36c4cc328aea0", + "size": 716159, + "subdir": "linux-64", + "timestamp": 1679487100841, + "version": "2.10.1" + }, + "datasets-2.10.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "dill <0.3.7", + "fsspec >=2021.11.1", + "huggingface_hub >=0.2.0,<1.0.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "pyarrow >=6.0.0", + "python >=3.11,<3.12.0a0", + "python-xxhash", + "pyyaml >=5.1", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1cca58fe5cf2bacbb23c3c87d65f2557", + "name": "datasets", + "sha256": "3945cd85b50fb66bc1323968869a36f4927e4558970c9636b0e5c51205cc4028", + "size": 946041, + "subdir": "linux-64", + "timestamp": 1679487052874, + "version": "2.10.1" + }, + "datasets-2.10.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "dill <0.3.7", + "fsspec >=2021.11.1", + "huggingface_hub >=0.2.0,<1.0.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "pyarrow >=6.0.0", + "python >=3.8,<3.9.0a0", + "python-xxhash", + "pyyaml >=5.1", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e2d4f1bf66562e9afbfcfc793c648832", + "name": "datasets", + "sha256": "4096c47a2b468557d03131b0de1d7b72ef9c3828c792deb8cf968891f05a1454", + "size": 706349, + "subdir": "linux-64", + "timestamp": 1679487004344, + "version": "2.10.1" + }, + "datasets-2.10.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "dill <0.3.7", + "fsspec >=2021.11.1", + "huggingface_hub >=0.2.0,<1.0.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "pyarrow >=6.0.0", + "python >=3.9,<3.10.0a0", + "python-xxhash", + "pyyaml >=5.1", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ac10b8d4bff560a70760907cc1cdd5ca", + "name": "datasets", + "sha256": "a7ed3ce0485d3355afb872b1509193835ce0162428fc7a38045001260b4386bc", + "size": 708616, + "subdir": "linux-64", + "timestamp": 1679486948054, + "version": "2.10.1" + }, + "datasets-2.6.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "dill <0.3.7", + "fsspec >=2021.11.1", + "huggingface_hub >=0.2.0,<1.0.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "pyarrow >=6.0.0", + "python >=3.10,<3.11.0a0", + "python-xxhash", + "pyyaml >=5.1", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1a709c24e072ec70689c23eb825130b4", + "name": "datasets", + "sha256": "85c8ba5f6c9b700009ba14a02000907bc99a689157f8c842efb7e0d4b64a80dc", + "size": 672176, + "subdir": "linux-64", + "timestamp": 1668181601248, + "version": "2.6.1" + }, + "datasets-2.6.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "dill <0.3.7", + "fsspec >=2021.11.1", + "huggingface_hub >=0.2.0,<1.0.0", + "importlib-metadata", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "pyarrow >=6.0.0", + "python >=3.7,<3.8.0a0", + "python-xxhash", + "pyyaml >=5.1", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e9582d6060a760a66541b11efe58c9b4", + "name": "datasets", + "sha256": "38b70b35ee86dfd640f6a036df4293357bb8b02ab1c10bf68a05f212c85cb8e7", + "size": 661497, + "subdir": "linux-64", + "timestamp": 1668181548087, + "version": "2.6.1" + }, + "datasets-2.6.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "dill <0.3.7", + "fsspec >=2021.11.1", + "huggingface_hub >=0.2.0,<1.0.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "pyarrow >=6.0.0", + "python >=3.8,<3.9.0a0", + "python-xxhash", + "pyyaml >=5.1", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a9dabdc08df27553e53164c73f14d754", + "name": "datasets", + "sha256": "41dd3ffda52f7c1aef348f95087d644d8c53cb9811e36477ac8558fde548ca74", + "size": 664589, + "subdir": "linux-64", + "timestamp": 1668181693424, + "version": "2.6.1" + }, + "datasets-2.6.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "dill <0.3.7", + "fsspec >=2021.11.1", + "huggingface_hub >=0.2.0,<1.0.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "pyarrow >=6.0.0", + "python >=3.9,<3.10.0a0", + "python-xxhash", + "pyyaml >=5.1", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "42a85b5e1c50f6a3ff6c565db3b0f938", + "name": "datasets", + "sha256": "fd3d21145cf82d4202a5ead33ac88b013afd9077b39b674e2eb408f6a5602a7c", + "size": 664559, + "subdir": "linux-64", + "timestamp": 1668181647403, + "version": "2.6.1" + }, + "datashader-0.14.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "numpy >=1.18,<1.22" + ], + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.18.0", + "datashape >=0.5.1", + "numba >=0.51", + "numpy >=1.7", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.10,<3.11.0a0", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8359b53d26377dacf0ab7c624c326193", + "name": "datashader", + "sha256": "e76707089a8fc22ec33df371e8766fa55433f343a5bfe10e2e19341859caf335", + "size": 17646078, + "subdir": "linux-64", + "timestamp": 1659349172234, + "version": "0.14.1" + }, + "datashader-0.14.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "bokeh <3.0.0", + "colorcet >=0.9.0", + "dask >=0.18.0", + "datashape >=0.5.1", + "numba >=0.51", + "numpy >=1.18,!=1.22.0,!=1.22.1,!=1.22.2,<1.23", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.10,<3.11.0a0", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9496cfddfffd898c3fb70f9765674adf", + "name": "datashader", + "sha256": "90a61ec478fd6b63d9ca6f8b8600740f26366561ea51010c672767cbd2b1262c", + "size": 17613610, + "subdir": "linux-64", + "timestamp": 1668502678594, + "version": "0.14.1" + }, + "datashader-0.14.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "numpy >=1.18,<1.22" + ], + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.18.0", + "datashape >=0.5.1", + "numba >=0.51", + "numpy >=1.7", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.7,<3.8.0a0", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9dcffc4962f1fbc3fa2323ff52203e85", + "name": "datashader", + "sha256": "0e925d8ae97adc85e8589371114541e8fd8c7e08311583d293f0205872f2ac89", + "size": 17646974, + "subdir": "linux-64", + "timestamp": 1659349348419, + "version": "0.14.1" + }, + "datashader-0.14.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "bokeh <3.0.0", + "colorcet >=0.9.0", + "dask >=0.18.0", + "datashape >=0.5.1", + "numba >=0.51", + "numpy >=1.18,!=1.22.0,!=1.22.1,!=1.22.2,<1.23", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.7,<3.8.0a0", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "137a0d6ae206eea940f8eda29ef1f5af", + "name": "datashader", + "sha256": "1b565892e567a0513126e368cf4efe321271c5363abfed22d42c3346752e91e3", + "size": 17607457, + "subdir": "linux-64", + "timestamp": 1668502460158, + "version": "0.14.1" + }, + "datashader-0.14.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "numpy >=1.18,<1.22" + ], + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.18.0", + "datashape >=0.5.1", + "numba >=0.51", + "numpy >=1.7", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.8,<3.9.0a0", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "41f652370a1559ad718a975b6354c0ae", + "name": "datashader", + "sha256": "76a28a099c191667f7d86f462275a8ddfd1f790767957748f1eeb8ebda04b68f", + "size": 17643363, + "subdir": "linux-64", + "timestamp": 1659349257883, + "version": "0.14.1" + }, + "datashader-0.14.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "bokeh <3.0.0", + "colorcet >=0.9.0", + "dask >=0.18.0", + "datashape >=0.5.1", + "numba >=0.51", + "numpy >=1.18,!=1.22.0,!=1.22.1,!=1.22.2,<1.23", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.8,<3.9.0a0", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c2aef5e87a5fb1356cf10614f3242d25", + "name": "datashader", + "sha256": "998e1fce517349c65b8927074b1f74782d0e960714cafc09360c9bade862fdcd", + "size": 17611412, + "subdir": "linux-64", + "timestamp": 1668502341945, + "version": "0.14.1" + }, + "datashader-0.14.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "numpy >=1.18,<1.22" + ], + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.18.0", + "datashape >=0.5.1", + "numba >=0.51", + "numpy >=1.7", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.9,<3.10.0a0", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a0ad5da57264ef4e51a487222e1607c0", + "name": "datashader", + "sha256": "0f2523d5721ddd01533f8152ec062254db64f370018b7217da6726cf277d1fdf", + "size": 17647043, + "subdir": "linux-64", + "timestamp": 1659349073339, + "version": "0.14.1" + }, + "datashader-0.14.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "bokeh <3.0.0", + "colorcet >=0.9.0", + "dask >=0.18.0", + "datashape >=0.5.1", + "numba >=0.51", + "numpy >=1.18,!=1.22.0,!=1.22.1,!=1.22.2,<1.23", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.9,<3.10.0a0", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dd45ad7557e8afd8d1d622bf678ca29c", + "name": "datashader", + "sha256": "a98f36fc484fb390f47e59f546c38ffe1eefd5569e2ef998c6415c71437c9e4c", + "size": 17607918, + "subdir": "linux-64", + "timestamp": 1668502571280, + "version": "0.14.1" + }, + "datashader-0.14.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask-core", + "datashape >=0.5.1", + "numba >=0.51", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.10,<3.11.0a0", + "requests", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d87bcf86236d65603742a5cebeecc20b", + "name": "datashader", + "sha256": "6c040ecd4a5a9b87ad57242c9ba521b350e94a79511610720fb9f89c534c3c2c", + "size": 17633067, + "subdir": "linux-64", + "timestamp": 1668506653180, + "version": "0.14.2" + }, + "datashader-0.14.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask-core", + "datashape >=0.5.1", + "numba >=0.51", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.7,<3.8.0a0", + "requests", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee9a7b3c0a3c46735afa20658f70c281", + "name": "datashader", + "sha256": "cc59fb8245145289619ad97a2781120d983455488cea3cd68ecefc37b720130d", + "size": 17631788, + "subdir": "linux-64", + "timestamp": 1668506425569, + "version": "0.14.2" + }, + "datashader-0.14.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask-core", + "datashape >=0.5.1", + "numba >=0.51", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.8,<3.9.0a0", + "requests", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4a5f0be6349f44d21b22581b6e823c31", + "name": "datashader", + "sha256": "8afa83541d3a85ab233328dd27043673768c9314a10aa7cc9dd0bc68c5aa164a", + "size": 17631965, + "subdir": "linux-64", + "timestamp": 1668506546400, + "version": "0.14.2" + }, + "datashader-0.14.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask-core", + "datashape >=0.5.1", + "numba >=0.51", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.9,<3.10.0a0", + "requests", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "10dca7854a495d9935fdc5e66d22110a", + "name": "datashader", + "sha256": "f04c2834f31a07a835c0dc3f73cc3fcf0a821173e41d7d9b725c35028ac43b8e", + "size": 17629337, + "subdir": "linux-64", + "timestamp": 1668506758641, + "version": "0.14.2" + }, + "datashader-0.14.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet", + "dask-core", + "datashape", + "numba >=0.51", + "numpy >=1.19,<2.0a", + "pandas", + "param", + "pillow", + "pyct", + "python >=3.10,<3.11.0a0", + "requests", + "scipy", + "toolz", + "xarray" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "106954dba579ef074b1ec30f79795cb5", + "name": "datashader", + "sha256": "aae4903a6067cf2dee74a63adfa51180404074bde791063d98b4fa9bf8ca22ca", + "size": 17631913, + "subdir": "linux-64", + "timestamp": 1670842171370, + "version": "0.14.3" + }, + "datashader-0.14.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet", + "dask-core", + "datashape", + "numba >=0.51", + "numpy >=1.19,<2.0a", + "pandas", + "param", + "pillow", + "pyct", + "python >=3.7,<3.8.0a0", + "requests", + "scipy", + "toolz", + "xarray" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d3af7536d352842441b6884536189f41", + "name": "datashader", + "sha256": "dfa77b5e92747606c4c956dccf3dcdd4ad90180789dd2b9b3b08938f464ab8eb", + "size": 17629574, + "subdir": "linux-64", + "timestamp": 1670841943015, + "version": "0.14.3" + }, + "datashader-0.14.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet", + "dask-core", + "datashape", + "numba >=0.51", + "numpy >=1.19,<2.0a", + "pandas", + "param", + "pillow", + "pyct", + "python >=3.8,<3.9.0a0", + "requests", + "scipy", + "toolz", + "xarray" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7959e156d6926bf76a3ce74fe17d960f", + "name": "datashader", + "sha256": "5afeebd6ed406983a5ff6c9e4236fd6fb4b818f57993d6c9dfb443481626db87", + "size": 17629345, + "subdir": "linux-64", + "timestamp": 1670842061652, + "version": "0.14.3" + }, + "datashader-0.14.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet", + "dask-core", + "datashape", + "numba >=0.51", + "numpy >=1.19,<2.0a", + "pandas", + "param", + "pillow", + "pyct", + "python >=3.9,<3.10.0a0", + "requests", + "scipy", + "toolz", + "xarray" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "978e0e9b45337ae1a02c8fbaeb566225", + "name": "datashader", + "sha256": "b4156e365b6ba7d3dbd408f5005e8294808176e13fa63652456de21ef7eaacb4", + "size": 17626289, + "subdir": "linux-64", + "timestamp": 1670842278491, + "version": "0.14.3" + }, + "datashader-0.14.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet", + "dask-core", + "datashape", + "numba >=0.51", + "numpy >=1.19,<2.0a", + "pandas", + "param", + "pillow", + "pyct", + "python >=3.10,<3.11.0a0", + "requests", + "scipy", + "toolz", + "xarray" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f1eb5d2a5b95290a1a92629edae23486", + "name": "datashader", + "sha256": "a6e120876ab328169a79a5be9cbd2dcdc1103de97a92c8d70df30548a6b93a6a", + "size": 17632511, + "subdir": "linux-64", + "timestamp": 1676023044233, + "version": "0.14.4" + }, + "datashader-0.14.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet", + "dask-core", + "datashape", + "numba >=0.51", + "numpy >=1.19,<2.0a", + "pandas", + "param", + "pillow", + "pyct", + "python >=3.7,<3.8.0a0", + "requests", + "scipy", + "toolz", + "xarray" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9ebc6433e9cb7bccf67c5d7fa36d54ea", + "name": "datashader", + "sha256": "62e2a7d584ff5509eea455c3f4a56f826d7421d47cf875be68f5aa1e863f7fb2", + "size": 17635569, + "subdir": "linux-64", + "timestamp": 1676022930963, + "version": "0.14.4" + }, + "datashader-0.14.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet", + "dask-core", + "datashape", + "numba >=0.51", + "numpy >=1.19,<2.0a", + "pandas", + "param", + "pillow", + "pyct", + "python >=3.8,<3.9.0a0", + "requests", + "scipy", + "toolz", + "xarray" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4ed1026cdf8559439320ad385bcabb28", + "name": "datashader", + "sha256": "b55a4f7011956f8842521b59580a06f76fe5bfca47790308117ff04d85228846", + "size": 17630206, + "subdir": "linux-64", + "timestamp": 1676023148951, + "version": "0.14.4" + }, + "datashader-0.14.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet", + "dask-core", + "datashape", + "numba >=0.51", + "numpy >=1.19,<2.0a", + "pandas", + "param", + "pillow", + "pyct", + "python >=3.9,<3.10.0a0", + "requests", + "scipy", + "toolz", + "xarray" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3ef7f56e875eb4a57dd35ac5d5e69b00", + "name": "datashader", + "sha256": "63f463095bab8cf81e0d2261102d954f5aa1b1cf80cb1e68ec3c482c468e118b", + "size": 17627757, + "subdir": "linux-64", + "timestamp": 1676023255777, + "version": "0.14.4" + }, + "datashader-0.6.2-py27h2029064_0.tar.bz2": { + "build": "py27h2029064_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask >=0.7.6", + "datashape >=0.5.1", + "numba >=0.35.0", + "numpy >=1.7", + "pandas >=0.15.0,<0.21", + "param >=1.5.0,<2.0", + "pillow >=3.1.1", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "e129f62fbf2e4a0c098c0d7671e97f2d", + "name": "datashader", + "sha256": "06847ba4924a018f1621d4c7ccc5f9cb02f27eb5f2d5f22f42d3342f3c59b9b2", + "size": 653915, + "subdir": "linux-64", + "timestamp": 1510005029674, + "version": "0.6.2" + }, + "datashader-0.6.2-py35h03bc0cf_0.tar.bz2": { + "build": "py35h03bc0cf_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask >=0.7.6", + "datashape >=0.5.1", + "numba >=0.35.0", + "numpy >=1.7", + "pandas >=0.15.0,<0.21", + "param >=1.5.0,<2.0", + "pillow >=3.1.1", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "d360730cd269f3d625917bb60490e94d", + "name": "datashader", + "sha256": "22fe6fffd6393b16571699b3473f05c5155bb5cff5783ac22d20a770ff074ee2", + "size": 656614, + "subdir": "linux-64", + "timestamp": 1510005035878, + "version": "0.6.2" + }, + "datashader-0.6.2-py36h21a1380_0.tar.bz2": { + "build": "py36h21a1380_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask >=0.7.6", + "datashape >=0.5.1", + "numba >=0.35.0", + "numpy >=1.7", + "pandas >=0.15.0,<0.21", + "param >=1.5.0,<2.0", + "pillow >=3.1.1", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "bd80dae0f64ec8d7009acb160d634f6f", + "name": "datashader", + "sha256": "3053e96c4c64592292819a18fc307f69c19e0e26017faed9713deb0d4cc5922f", + "size": 654377, + "subdir": "linux-64", + "timestamp": 1510005038260, + "version": "0.6.2" + }, + "datashader-0.6.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask >=0.15.4", + "datashape >=0.5.1", + "numba >=0.35.0", + "numpy >=1.7", + "pandas >=0.20.3", + "param >=1.5.0,<2.0", + "pillow >=3.1.1", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "155452dff92427a59172ced92880868d", + "name": "datashader", + "sha256": "ff4428a01d34f29e807a0c909bc73e41b074c5b999264683068f918305ae5756", + "size": 693145, + "subdir": "linux-64", + "timestamp": 1520379302349, + "version": "0.6.5" + }, + "datashader-0.6.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask >=0.15.4", + "datashape >=0.5.1", + "numba >=0.35.0", + "numpy >=1.7", + "pandas >=0.20.3", + "param >=1.5.0,<2.0", + "pillow >=3.1.1", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "879da77f10cce079623deaf01603059a", + "name": "datashader", + "sha256": "287b8835da1ad79d6bbfb3b1a28f07dd4dd5414514215a06165b703c1b71a39f", + "size": 692392, + "subdir": "linux-64", + "timestamp": 1520964850499, + "version": "0.6.5" + }, + "datashader-0.6.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask >=0.15.4", + "datashape >=0.5.1", + "numba >=0.35.0", + "numpy >=1.7", + "pandas >=0.20.3", + "param >=1.5.0,<2.0", + "pillow >=3.1.1", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "9ad275d1a75d436e88fbd2abefbe4bee", + "name": "datashader", + "sha256": "522de735409bb1c90d5b2c931ef32d3fc61fa30c9ae1b2037d23e0e811bf37d3", + "size": 685284, + "subdir": "linux-64", + "timestamp": 1520964730468, + "version": "0.6.5" + }, + "datashader-0.6.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.15.4", + "datashape >=0.5.1", + "numba >=0.37.0", + "numpy >=1.7", + "pandas >=0.20.3", + "param >=1.6.0", + "pillow >=3.1.1", + "pyct", + "python >=2.7,<2.8.0a0", + "scikit-image", + "scipy", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "1022102897715f992a87de65ba7119e9", + "name": "datashader", + "sha256": "31f4c86c8b34e1975e9b9cc55eeb6566eb408dab68c0eaf7987c9e570c5eddca", + "size": 9917721, + "subdir": "linux-64", + "timestamp": 1527636467514, + "version": "0.6.6" + }, + "datashader-0.6.6-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.15.4", + "datashape >=0.5.1", + "numba >=0.37.0", + "numpy >=1.7", + "pandas >=0.20.3", + "param >=1.6.0", + "pillow >=3.1.1", + "pyct", + "python >=2.7,<2.8.0a0", + "scikit-image", + "scipy", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "8e324689d63cd94bd17db6159cf6345d", + "name": "datashader", + "sha256": "3ecda8fa6541c7515503fbb78ddfeda2cd489d7577d09473f95fdf6f18fb078c", + "size": 9926232, + "subdir": "linux-64", + "timestamp": 1527882713420, + "version": "0.6.6" + }, + "datashader-0.6.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.15.4", + "datashape >=0.5.1", + "numba >=0.37.0", + "numpy >=1.7", + "pandas >=0.20.3", + "param >=1.6.0", + "pillow >=3.1.1", + "pyct", + "python >=3.5,<3.6.0a0", + "scikit-image", + "scipy", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "0a590af3da3b2759d0526b3aad48570a", + "name": "datashader", + "sha256": "d80ecfd5a65f1f80b13c52d756fc708bea4f675b0f4c765e94978c9d7f19a7d9", + "size": 9917777, + "subdir": "linux-64", + "timestamp": 1527636407612, + "version": "0.6.6" + }, + "datashader-0.6.6-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.15.4", + "datashape >=0.5.1", + "numba >=0.37.0", + "numpy >=1.7", + "pandas >=0.20.3", + "param >=1.6.0", + "pillow >=3.1.1", + "pyct", + "python >=3.5,<3.6.0a0", + "scikit-image", + "scipy", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "1bb845472e0fc1ceb259f328018ec8b0", + "name": "datashader", + "sha256": "4f87f8b9710a0b4259af8529f6b250c5e2d9d1df6479825cc166b943f2658216", + "size": 9925190, + "subdir": "linux-64", + "timestamp": 1527882766242, + "version": "0.6.6" + }, + "datashader-0.6.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.15.4", + "datashape >=0.5.1", + "numba >=0.37.0", + "numpy >=1.7", + "pandas >=0.20.3", + "param >=1.6.0", + "pillow >=3.1.1", + "pyct", + "python >=3.6,<3.7.0a0", + "scikit-image", + "scipy", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "1ae31fafb74d68ef090e2d808289ae6e", + "name": "datashader", + "sha256": "b6aad884703fc372f86aa87a206063e5a04ab82b4fcd2c6be72d87be0f43c8dc", + "size": 9911241, + "subdir": "linux-64", + "timestamp": 1527636353981, + "version": "0.6.6" + }, + "datashader-0.6.6-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.15.4", + "datashape >=0.5.1", + "numba >=0.37.0", + "numpy >=1.7", + "pandas >=0.20.3", + "param >=1.6.0", + "pillow >=3.1.1", + "pyct", + "python >=3.6,<3.7.0a0", + "scikit-image", + "scipy", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "2bc837132bf7b2378154e4f6165b244c", + "name": "datashader", + "sha256": "f7076c1b014351e40b54a6dc5ab15c45e6b6b1bd9899803f45bc9f22b72b6c48", + "size": 9918942, + "subdir": "linux-64", + "timestamp": 1527882660610, + "version": "0.6.6" + }, + "datashape-0.5.4-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=2.7,<2.8.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e5b8533db6dadde25c6a91eeaf488f43", + "name": "datashape", + "sha256": "da541f8d61eb8c6f72d48534600bc5d93cab5ac52a802a7c0218a05a3b8695a1", + "size": 99574, + "subdir": "linux-64", + "timestamp": 1530771877780, + "version": "0.5.4" + }, + "datashape-0.5.4-py27hf507385_0.tar.bz2": { + "build": "py27hf507385_0", + "build_number": 0, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=2.7,<2.8.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "2875f7867ade2abc9f34dd9aa657f392", + "name": "datashape", + "sha256": "1d719814c9690d87e5bf0e38f5cb76f632c5ced8c10edd35123ce7d649c41af4", + "size": 98643, + "subdir": "linux-64", + "timestamp": 1505739949333, + "version": "0.5.4" + }, + "datashape-0.5.4-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.10,<3.11.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "091e596b0565d13b12bf261aaad3cde7", + "name": "datashape", + "sha256": "c33f7bed0d5df9b603477cfab6687d3390110320a5e8cc02d981fff81f4ab799", + "size": 103863, + "subdir": "linux-64", + "timestamp": 1640808953510, + "version": "0.5.4" + }, + "datashape-0.5.4-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.11,<3.12.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d0ee2e12e8b9a4779ec45a6afbde0c5e", + "name": "datashape", + "sha256": "0fb5d1bc4f23635df22d87384ca0b8f07ad4bde45732834fdb660fac21276d0d", + "size": 140408, + "subdir": "linux-64", + "timestamp": 1676843976720, + "version": "0.5.4" + }, + "datashape-0.5.4-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.5,<3.6.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5b1794c0bf848233e725cb6444264684", + "name": "datashape", + "sha256": "8fff2dd95345acde97db05d3bd63b4aae7c115c4a13b71425851cc6bafe5374b", + "size": 102727, + "subdir": "linux-64", + "timestamp": 1534804411607, + "version": "0.5.4" + }, + "datashape-0.5.4-py35h5b068ae_0.tar.bz2": { + "build": "py35h5b068ae_0", + "build_number": 0, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.5,<3.6.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "caada9fdd43a4c154456d6d53b7319f5", + "name": "datashape", + "sha256": "9aeb797ca74c0d1c19ab95a63d8f816c099c8a21c4351a7109975fc4c59dc1d3", + "size": 101692, + "subdir": "linux-64", + "timestamp": 1505739965907, + "version": "0.5.4" + }, + "datashape-0.5.4-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "aa17905b378f9407e5dd7dd3d28fe60f", + "name": "datashape", + "sha256": "4a24e7adee5ec9ea596bbc962aba5f3829a6e4b6bf42ae1bee504d4a1a55c583", + "size": 102208, + "subdir": "linux-64", + "timestamp": 1530771905449, + "version": "0.5.4" + }, + "datashape-0.5.4-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "235357d69093f9c257b9d442bad4c30d", + "name": "datashape", + "sha256": "1e3e12a9dfed366e9bf2c5d46fbcbb43b95dbe51b8ae496e13e9aced4ce93c44", + "size": 103359, + "subdir": "linux-64", + "timestamp": 1613389671273, + "version": "0.5.4" + }, + "datashape-0.5.4-py36h3ad6b5c_0.tar.bz2": { + "build": "py36h3ad6b5c_0", + "build_number": 0, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e6afea091eba2edfc47f2279ead26128", + "name": "datashape", + "sha256": "ca6db593665ba87eaaad53385957a761721e0b51e938ea888778c6f14abad215", + "size": 101123, + "subdir": "linux-64", + "timestamp": 1505739982334, + "version": "0.5.4" + }, + "datashape-0.5.4-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f1f17d7ac67fe763a8ca864f3f08a0ce", + "name": "datashape", + "sha256": "1fdf1317d2884356de5ea620ccea6a7aaa08ab5453ce8c336a11c4f3e505b2fc", + "size": 102006, + "subdir": "linux-64", + "timestamp": 1530771851361, + "version": "0.5.4" + }, + "datashape-0.5.4-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "99c0a778e393d4f874e9c1f18d8599cd", + "name": "datashape", + "sha256": "07cba8c791d3d41cbba461f74e536d6db4f07a3a506959a5a757462a5c774eda", + "size": 103155, + "subdir": "linux-64", + "timestamp": 1613389650903, + "version": "0.5.4" + }, + "datashape-0.5.4-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c97b8c9693b6e5a1542795790c0b6a6a", + "name": "datashape", + "sha256": "b3ed34582bb696c3f7e4cd40f2567b06d49a3555935780181b425c06f2cd8378", + "size": 103387, + "subdir": "linux-64", + "timestamp": 1574251109949, + "version": "0.5.4" + }, + "datashape-0.5.4-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "53492f02a308427dab7a204dcc2f343f", + "name": "datashape", + "sha256": "823bbb3c8951739e8ff5fbf9470cf4ca06c790fe4646388922bf29800b02acad", + "size": 104159, + "subdir": "linux-64", + "timestamp": 1613390257727, + "version": "0.5.4" + }, + "datashape-0.5.4-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.9,<3.10.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "686db307602cbbdc30ca7d62b765578b", + "name": "datashape", + "sha256": "80188a9729a26e36b027e673f5f30395798eb68f9fe4721f3f33b4d4d2e58285", + "size": 103488, + "subdir": "linux-64", + "timestamp": 1613390248313, + "version": "0.5.4" + }, + "dateparser-1.1.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27,<2022.3.15", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f9d92ca6355201e68b9a0a7623bd81e", + "name": "dateparser", + "sha256": "a8f5c4e11fae7ebc17b5a1be5ab3aac798be5e31c12935f3b30c1df97012bfed", + "size": 350488, + "subdir": "linux-64", + "timestamp": 1671074962799, + "version": "1.1.3" + }, + "dateparser-1.1.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27,<2022.3.15", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bc61c4add93b1d3647bf8020fefaf3eb", + "name": "dateparser", + "sha256": "a82fec5c1c130f17c2df890ed897adcd0256caeca343ef3fae495f02bcaeb94b", + "size": 331495, + "subdir": "linux-64", + "timestamp": 1671075012572, + "version": "1.1.3" + }, + "dateparser-1.1.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27,<2022.3.15", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cf20a7e8a24f3cdcb98157070e319883", + "name": "dateparser", + "sha256": "b5882e16378e6af9482c509b275ebaf39daa8da032a932cd872b53bc9fae4247", + "size": 334032, + "subdir": "linux-64", + "timestamp": 1671074987533, + "version": "1.1.3" + }, + "dateparser-1.1.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27,<2022.3.15", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ae154cbe12ce860bfdf08b7d4595f6d9", + "name": "dateparser", + "sha256": "1d60d61ee661adf2aa410abfa2e412d14f1c3a594340a29ddfb2e5fa7a1c5c5d", + "size": 330938, + "subdir": "linux-64", + "timestamp": 1671075037741, + "version": "1.1.3" + }, + "dateparser-1.1.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27,<2022.3.15", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "af0e4eaf11831dc34a82392c0a72a0f5", + "name": "dateparser", + "sha256": "b503340bb14d4aa98aa293b13554eef7e9185c1d092b151bfb30639d4774cd8e", + "size": 350480, + "subdir": "linux-64", + "timestamp": 1671081600448, + "version": "1.1.4" + }, + "dateparser-1.1.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27,<2022.3.15", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c5163d0b9c8aea579ddf1da8b365eb72", + "name": "dateparser", + "sha256": "8d0bec400e39fe1be2d989175de897dcdc4d17b3efc42796e30631df3653b65f", + "size": 329532, + "subdir": "linux-64", + "timestamp": 1671081625190, + "version": "1.1.4" + }, + "dateparser-1.1.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27,<2022.3.15", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ea66c94193f4d6a5ec4328d448575b20", + "name": "dateparser", + "sha256": "be3c52065556e428be47994b487fcd0cc194a2ad376d4725e56a6f0cc725f911", + "size": 333396, + "subdir": "linux-64", + "timestamp": 1671081649573, + "version": "1.1.4" + }, + "dateparser-1.1.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27,<2022.3.15", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "70f0c383a4db31839e608c743bbb6e9f", + "name": "dateparser", + "sha256": "23c321db68e8696e40a23d1a490d3c53f44c5a024a42a93a93ea0285215c02c6", + "size": 332045, + "subdir": "linux-64", + "timestamp": 1671081674426, + "version": "1.1.4" + }, + "dateparser-1.1.8-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f7f4cfb050e84bab2ad4c7f7aca3a7d1", + "name": "dateparser", + "sha256": "0321c5abe3fdd0e85f142b02c248ab21e055c812bcf00577944f05d5174aba09", + "size": 351386, + "subdir": "linux-64", + "timestamp": 1679666229924, + "version": "1.1.8" + }, + "dateparser-1.1.8-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "33ad6c618752dbcfe6cea8307e1ebdd5", + "name": "dateparser", + "sha256": "4dc69326a411cb4d0d23e3cff071f3a84432a0488622ca490b18ddcdfce38d03", + "size": 427394, + "subdir": "linux-64", + "timestamp": 1679666144348, + "version": "1.1.8" + }, + "dateparser-1.1.8-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dd322b4fbd5f08fd3f26928cfe5ef9ea", + "name": "dateparser", + "sha256": "3f741e43c06a28bc4b7952e60ba7ae06d32cc360e9037e7fc0d1235c5a46201e", + "size": 334260, + "subdir": "linux-64", + "timestamp": 1679666200817, + "version": "1.1.8" + }, + "dateparser-1.1.8-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ef7e536f26d874eb64680c3a4b69c12a", + "name": "dateparser", + "sha256": "3e639433fa6bbc3f5b0aaf62db27c9ba2fd06dd779dfdb56d793cb9b89b44c5e", + "size": 332566, + "subdir": "linux-64", + "timestamp": 1679666172166, + "version": "1.1.8" + }, + "datrie-0.7.1-py27h7b6447c_1.tar.bz2": { + "build": "py27h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "aefb6d39c215e92691f8ea9e2640a791", + "name": "datrie", + "sha256": "4d8962087fec0f6815260da27fa9eb4621ce233fc7da39e5d8c6b9767cbf1f19", + "size": 152197, + "subdir": "linux-64", + "timestamp": 1537292011984, + "version": "0.7.1" + }, + "datrie-0.7.1-py35h7b6447c_1.tar.bz2": { + "build": "py35h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "0c70b67ba008c606b5df3574f849136a", + "name": "datrie", + "sha256": "78a5d4247bfd14a1d251564a7725150667a2aed45469e4f3a3bc7fe5dd75ce57", + "size": 154973, + "subdir": "linux-64", + "timestamp": 1537292051707, + "version": "0.7.1" + }, + "datrie-0.7.1-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "b1eaa18a4a7824e88be83f3ad4febd48", + "name": "datrie", + "sha256": "3111dceb164cbfdf41e55c7f8ca0ae06736d832d8e2456055a776650fa257cfb", + "size": 157458, + "subdir": "linux-64", + "timestamp": 1537292048628, + "version": "0.7.1" + }, + "datrie-0.7.1-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "f1d22891abaff233db335bec8c91b360", + "name": "datrie", + "sha256": "5050f240d1443d951032e275b5865cc82f288e1e8a72d908d78aa92a32537688", + "size": 156412, + "subdir": "linux-64", + "timestamp": 1537291987069, + "version": "0.7.1" + }, + "datrie-0.8-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "5fb54e3528335dd16467846bff811bd1", + "name": "datrie", + "sha256": "7f856666aa45036c7fc97f0b216db91cdc8226396598f363ccdcce34b3d210f7", + "size": 154964, + "subdir": "linux-64", + "timestamp": 1569433465876, + "version": "0.8" + }, + "datrie-0.8-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "c56eeeb46abd5d51ba8ab8c6b8b01211", + "name": "datrie", + "sha256": "6416d7b7418c8476641f5e40701ca02c263507fe8ceea4cc5a1e0334a54ca474", + "size": 164417, + "subdir": "linux-64", + "timestamp": 1569433468549, + "version": "0.8" + }, + "datrie-0.8-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "2648fd29a928ca922af18705982a7f55", + "name": "datrie", + "sha256": "b09c781a006d8b0e50489117e7a06f6bdfe71f982ad3b783d25164a29a248678", + "size": 164426, + "subdir": "linux-64", + "timestamp": 1569433482841, + "version": "0.8" + }, + "datrie-0.8.2-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "6ccb5b67a7b9b99a4130e5d2208e157b", + "name": "datrie", + "sha256": "3fceccb11b95eb476865f1be87c876640cc9044cc4c9be9633b49b885afbadee", + "size": 561602, + "subdir": "linux-64", + "timestamp": 1640816681038, + "version": "0.8.2" + }, + "datrie-0.8.2-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "38a0c7028af61701df4e35d0a4502004", + "name": "datrie", + "sha256": "e756348e8121a09fa46d7f1f7a7abd13dee2f1546fdbb516d234c1c84c9e6529", + "size": 148170, + "subdir": "linux-64", + "timestamp": 1676851909935, + "version": "0.8.2" + }, + "datrie-0.8.2-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "4b8f121b880f1dc03aab458d20e20dc8", + "name": "datrie", + "sha256": "9d5639af77aae1681dda12aa56f0400f547776af8ae35e7036182df4cddf6d87", + "size": 145885, + "subdir": "linux-64", + "timestamp": 1611677550293, + "version": "0.8.2" + }, + "datrie-0.8.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "ea70070a4712aaf50aac9e172541355b", + "name": "datrie", + "sha256": "4ab0eaccc4082c2592d679dc7d900a9a94f5d99a22c53da93d6e76972a63eb01", + "size": 162388, + "subdir": "linux-64", + "timestamp": 1588475717472, + "version": "0.8.2" + }, + "datrie-0.8.2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "04e99949899404f3b5660e0a4a61b229", + "name": "datrie", + "sha256": "2f3a44423e4b224d971cf75efc2de085b5d513a0fbc2445fb86ba99946ff82d0", + "size": 144659, + "subdir": "linux-64", + "timestamp": 1611677578962, + "version": "0.8.2" + }, + "datrie-0.8.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "9651e3f453277a96a7285ff22c0410ff", + "name": "datrie", + "sha256": "8c4700e496254c55654463ae9dcfa1af3b6fb2c2dd3c69f987241957835d9862", + "size": 161912, + "subdir": "linux-64", + "timestamp": 1588475736617, + "version": "0.8.2" + }, + "datrie-0.8.2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "4c881389d4dbfa5dc4bb0d605e8d7f33", + "name": "datrie", + "sha256": "a79131481a71db58fd4074753c0e53170471a7337808aed87dafc8ab24b2b6d6", + "size": 151290, + "subdir": "linux-64", + "timestamp": 1611677594656, + "version": "0.8.2" + }, + "datrie-0.8.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "1f78d0b08f56c897cf86cef2d90f352c", + "name": "datrie", + "sha256": "227bdb24496ab4ed9ee5fbbf7b30ce90c43703534ca60a7f0ad86c7af7fb07ef", + "size": 168131, + "subdir": "linux-64", + "timestamp": 1588475742767, + "version": "0.8.2" + }, + "datrie-0.8.2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "b3b3d553f0be4bc2b3690d36bb20db5c", + "name": "datrie", + "sha256": "9099537d045cc8c98235a5c670ec09f7bbd5ffa0e645959d2d9f216e025978d3", + "size": 151758, + "subdir": "linux-64", + "timestamp": 1611677571829, + "version": "0.8.2" + }, + "db-6.1.26-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libdb 6.1.26 he6710b0_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "AGPL-3.0", + "md5": "d0af1aea159bb7743a5367e471addd24", + "name": "db", + "sha256": "f70595d1eb51d93385efac596cd74e646ff5f1764cdf816c20b334b8125ad81f", + "size": 19593, + "subdir": "linux-64", + "timestamp": 1537818034748, + "version": "6.1.26" + }, + "db-6.2.32-h6a678d5_1.tar.bz2": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "libdb 6.2.32 h6a678d5_1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "AGPL-3.0-only", + "md5": "ddbab6de784395dac2ff66f1761b473d", + "name": "db", + "sha256": "a2532bb5d015943d70d46878e93cae363141ad2e30f283e11fb234e4b7ec208b", + "size": 18084, + "subdir": "linux-64", + "timestamp": 1656332159344, + "version": "6.2.32" + }, + "db-6.2.32-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libdb 6.2.32 he6710b0_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "AGPL-3.0-only", + "md5": "06a53015549834c4c53bc0166fb90ec6", + "name": "db", + "sha256": "377ca39b3baed583b167b15f831251a24ffc7aa181daeee255335169c8a7c648", + "size": 26510, + "subdir": "linux-64", + "timestamp": 1601249400928, + "version": "6.2.32" + }, + "db-6.2.32-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libdb 6.2.32 hf484d3e_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "AGPL-3.0-only", + "md5": "0f4f10332b7e9ecf691a01c77e1eeb97", + "name": "db", + "sha256": "747c755802bd0f78b30a3a2fbebdf119ea73c0a53b45eb97272632b55e7f1cfa", + "size": 23294, + "subdir": "linux-64", + "timestamp": 1601249492835, + "version": "6.2.32" + }, + "dbf-0.96.8-py27h6f65a25_0.tar.bz2": { + "build": "py27h6f65a25_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c83c4a3c6de08dd72bd7a54491c5ab6d", + "name": "dbf", + "sha256": "4caf8a1e2014795ff196be6cfd884fedfaec125236e3510b69e71417d31d40ca", + "size": 281239, + "subdir": "linux-64", + "timestamp": 1509053667558, + "version": "0.96.8" + }, + "dbf-0.96.8-py35h1fafa07_0.tar.bz2": { + "build": "py35h1fafa07_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7dcb109713f90c8efa67f7d919e9e548", + "name": "dbf", + "sha256": "8b4243ac4bb25840aa2905556b52dd56ce70a93a6ce45ba04d8f9f08f18683c1", + "size": 216113, + "subdir": "linux-64", + "timestamp": 1509053675867, + "version": "0.96.8" + }, + "dbf-0.96.8-py36hcbe1359_0.tar.bz2": { + "build": "py36hcbe1359_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c833f753c109d9f25ff5b65d0bfa275b", + "name": "dbf", + "sha256": "7ad71bb640c796812e9d1cab2e279a7513d3f0bc98f686e2af6dfef027150bb8", + "size": 221930, + "subdir": "linux-64", + "timestamp": 1509053703931, + "version": "0.96.8" + }, + "dbf-0.97.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5b9408cf344eab9a9847a989833a5891", + "name": "dbf", + "sha256": "f98d4c8c4e6c996a702a259ea5bd9e451499773c13309637b6cdc57f4ace6918", + "size": 189511, + "subdir": "linux-64", + "timestamp": 1528218458344, + "version": "0.97.10" + }, + "dbf-0.97.10-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b1ea57825e5614e870e9a51473e3aa68", + "name": "dbf", + "sha256": "ed76fa5e84c3582fb10564875a7229501f46d8e714319a318d909b6c18c31639", + "size": 193743, + "subdir": "linux-64", + "timestamp": 1528218486931, + "version": "0.97.10" + }, + "dbf-0.97.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ba47fd7452159f64da2f76d3ffafddfa", + "name": "dbf", + "sha256": "9b3762111adfaa76efc07a0c96364b66f9dee73fdff540112a1d2c0ea6558e4b", + "size": 188821, + "subdir": "linux-64", + "timestamp": 1528218443153, + "version": "0.97.10" + }, + "dbf-0.97.11-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "11d8d60f502916c74b2710e13f69328a", + "name": "dbf", + "sha256": "a78d713337771590d2e141fff81b4ccfbdaf7585d40a37b4cfad6d813dcac492", + "size": 189252, + "subdir": "linux-64", + "timestamp": 1529424033380, + "version": "0.97.11" + }, + "dbf-0.97.11-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "67b0a1ca764a2851ed014a25e435f8bd", + "name": "dbf", + "sha256": "69c2a1b9892261d2a8726e1eda42a00cc63b41ea4c4bd8892c16a1ddd30a0099", + "size": 193369, + "subdir": "linux-64", + "timestamp": 1529423986258, + "version": "0.97.11" + }, + "dbf-0.97.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2cf9be29cf99f0a48f6c77e303924e72", + "name": "dbf", + "sha256": "dfdc2b1eac00b1eeee2f515215a4f04b976ed9044fb3c9c0572f276edecc257c", + "size": 188931, + "subdir": "linux-64", + "timestamp": 1529423959090, + "version": "0.97.11" + }, + "dbf-0.97.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c38560e7e1724b6cd0a1fa9d5d7fd0a6", + "name": "dbf", + "sha256": "9cd40167df56aad28f43d9d747b872b9a56a99a24e1e30bd99460af294c135a6", + "size": 187655, + "subdir": "linux-64", + "timestamp": 1530873024757, + "version": "0.97.11" + }, + "dbf-0.97.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b6f6fa141a79a986f1bf2f2bd6f0d841", + "name": "dbf", + "sha256": "c0c5f09b6cc2fdae7d290ba022300e001ee43a780847cf3996698c024b980039", + "size": 181605, + "subdir": "linux-64", + "timestamp": 1521779872596, + "version": "0.97.2" + }, + "dbf-0.97.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "deffada669420918cf1eea5efb9a2fe5", + "name": "dbf", + "sha256": "20a23e10e71132337f78a1b188a47a30870788052b50694add14ecc27582b455", + "size": 185301, + "subdir": "linux-64", + "timestamp": 1521779919538, + "version": "0.97.2" + }, + "dbf-0.97.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "611178d4b8266647cffd13840cf07ca1", + "name": "dbf", + "sha256": "8549429a833ee714b0499a64218dde4e6a15d3b01f60d24be98738d628734d9f", + "size": 180785, + "subdir": "linux-64", + "timestamp": 1521779924379, + "version": "0.97.2" + }, + "dbf-0.97.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d41ff1a4b98fbc41499424e9cc673a79", + "name": "dbf", + "sha256": "5db0f84f9bea4895a556e5d7a50f87caf46d5f203feba90e99691ee773b591e0", + "size": 182827, + "subdir": "linux-64", + "timestamp": 1526928658855, + "version": "0.97.4" + }, + "dbf-0.97.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a3052f363b0074f0550a1ae887e63996", + "name": "dbf", + "sha256": "adabee93572db1c37247d74bb1974947394a400bd71d05316f2366cef8d69801", + "size": 186246, + "subdir": "linux-64", + "timestamp": 1526928680779, + "version": "0.97.4" + }, + "dbf-0.97.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3ea3fefcd296b94d8e368983916858d4", + "name": "dbf", + "sha256": "3562295f340a030ed89db57b197dcd83cde98eb92a71356ec072f835f4cf7455", + "size": 181466, + "subdir": "linux-64", + "timestamp": 1526928641079, + "version": "0.97.4" + }, + "dbf-0.97.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6621d00da73ce1f8b2ab2d9c4c10f313", + "name": "dbf", + "sha256": "f0c208b12c017f0652b4d21a76e49693bada5d464d75d6b0f04e2a415933c030", + "size": 188132, + "subdir": "linux-64", + "timestamp": 1527642801582, + "version": "0.97.8" + }, + "dbf-0.97.8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c8268eae15de01f022e8721ddf2d5629", + "name": "dbf", + "sha256": "429a54c4b0783cff89cdbc41d7f061c9fb5b2a83a74bd21995f7189299a562e6", + "size": 191773, + "subdir": "linux-64", + "timestamp": 1527642822558, + "version": "0.97.8" + }, + "dbf-0.97.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "24344303172e2d399c5a27978082f9f6", + "name": "dbf", + "sha256": "69d9b2b055d64149f48f011bd6b73c7c62797f8c5663552771577dfc32f07d5b", + "size": 186925, + "subdir": "linux-64", + "timestamp": 1527642788097, + "version": "0.97.8" + }, + "dbfread-2.0.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8103eaba1bf3b143e6f6211761a7cfb", + "name": "dbfread", + "sha256": "f2a109be8295770c9ee8f280682bdc50ca0d8e4f284f1132ff2ff9bb03fbfe32", + "size": 30527, + "subdir": "linux-64", + "timestamp": 1530735814923, + "version": "2.0.7" + }, + "dbfread-2.0.7-py27h8f214bf_0.tar.bz2": { + "build": "py27h8f214bf_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4afdbc7f4c4e402a9421e343a9c42f42", + "name": "dbfread", + "sha256": "fa8b90f5cfd495fb3dca06ee29170a3759401412ce6d26bb322dc874fa25f5d2", + "size": 30839, + "subdir": "linux-64", + "timestamp": 1508625329549, + "version": "2.0.7" + }, + "dbfread-2.0.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ec5236f0c7dffc0ed5d6257172f1795", + "name": "dbfread", + "sha256": "855bafc18b4c22323260025c115fe5159467196ea31d79caf299c0eaaaaf1162", + "size": 31045, + "subdir": "linux-64", + "timestamp": 1534352068817, + "version": "2.0.7" + }, + "dbfread-2.0.7-py35he5e2644_0.tar.bz2": { + "build": "py35he5e2644_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe7a15f9e2cb078fa98d5510e60c86c0", + "name": "dbfread", + "sha256": "b009e9487b704e6a16b3106609e5d4a498ff9fb0748af29b8ff21bcc44982d77", + "size": 31490, + "subdir": "linux-64", + "timestamp": 1508625335987, + "version": "2.0.7" + }, + "dbfread-2.0.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37cd3ca4d25998e92f9f9b4dc7d4575f", + "name": "dbfread", + "sha256": "0bf30ac4098c8eb80fcd9ef1ed2921c67976fc6211a22d7ea7dbe3f178809c80", + "size": 30862, + "subdir": "linux-64", + "timestamp": 1530735794561, + "version": "2.0.7" + }, + "dbfread-2.0.7-py36ha5008bc_0.tar.bz2": { + "build": "py36ha5008bc_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "50daec74ae94a2afeab8bd2cd6661d25", + "name": "dbfread", + "sha256": "e889717051f6703df7555beede6254003871166aa0e8133051c3931686e9163b", + "size": 31153, + "subdir": "linux-64", + "timestamp": 1508625333419, + "version": "2.0.7" + }, + "dbfread-2.0.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22c1c7bee309bb7419c853031c84714c", + "name": "dbfread", + "sha256": "ca4e87e902ce2379c04c6a1a7b226a1f7098b5e821a95fbbeb454d67149806c4", + "size": 30613, + "subdir": "linux-64", + "timestamp": 1530735835962, + "version": "2.0.7" + }, + "dbfread-2.0.7-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d92b7944a4379b39df54c6e009cc5d74", + "name": "dbfread", + "sha256": "8169768afb26fa6085e76d6f2f9087f8a2cb940403343b9c2f1dfedccdff0652", + "size": 31122, + "subdir": "linux-64", + "timestamp": 1572434918739, + "version": "2.0.7" + }, + "dbus-1.10.22-h3b5a359_0.tar.bz2": { + "build": "h3b5a359_0", + "build_number": 0, + "depends": [ + "expat", + "glib >=2.53.6,<3.0a0", + "libgcc-ng >=7.2.0" + ], + "license": "GPL2", + "md5": "dcccf9e4873f2e99c6c866d71d1c08f4", + "name": "dbus", + "sha256": "f4b90f94b5c97b41e359313acfc69fe4bdd3fcb3cf3addb5dc3ab2acf6e24506", + "size": 557416, + "subdir": "linux-64", + "timestamp": 1505735510995, + "version": "1.10.22" + }, + "dbus-1.12.12-h746ee38_0.tar.bz2": { + "build": "h746ee38_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "glib >=2.56.2,<3.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "GPL2", + "md5": "31cb869fc0a4e34c843e68b9933e0c62", + "name": "dbus", + "sha256": "acf9fafdf19035477f84667dcbec3e4d56dbcba68d8e2b3fd051d488d141d5d8", + "size": 592134, + "subdir": "linux-64", + "timestamp": 1547226354431, + "version": "1.12.12" + }, + "dbus-1.12.2-hc3f9b76_1.tar.bz2": { + "build": "hc3f9b76_1", + "build_number": 1, + "depends": [ + "expat", + "expat >=2.2.5,<3.0a0", + "glib >=2.53.6,<3.0a0", + "libgcc-ng >=7.2.0" + ], + "license": "GPL2", + "md5": "c55fed6135ba0bae2ebf08fc6967a917", + "name": "dbus", + "sha256": "3afb8d198e52a1734b8c5526712e44a717dc1182bc13dacfea5429b3f5bf7303", + "size": 565121, + "subdir": "linux-64", + "timestamp": 1518199455973, + "version": "1.12.2" + }, + "dbus-1.12.2-hd3e2b69_0.tar.bz2": { + "build": "hd3e2b69_0", + "build_number": 0, + "depends": [ + "expat", + "expat >=2.2.5,<3.0a0", + "glib >=2.53.6,<3.0a0", + "libgcc-ng >=7.2.0" + ], + "license": "GPL2", + "md5": "e0d4aa5872cf28728a9e40a98c2b98f4", + "name": "dbus", + "sha256": "e0762a1bd80b6202cde84ce9cff909b8955cd5c41da0054aac2f3b554f648a8b", + "size": 564565, + "subdir": "linux-64", + "timestamp": 1516812561051, + "version": "1.12.2" + }, + "dbus-1.13.12-h746ee38_0.tar.bz2": { + "build": "h746ee38_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "glib >=2.56.2,<3.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "GPL2", + "md5": "cb8832c2e3e60f657c99bde6b0d8ae60", + "name": "dbus", + "sha256": "b5ee84507517483301059dd941e98e7955e74fe00a64210ffeaf7ba48b757132", + "size": 625785, + "subdir": "linux-64", + "timestamp": 1571950327744, + "version": "1.13.12" + }, + "dbus-1.13.14-hb2f20db_0.tar.bz2": { + "build": "hb2f20db_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "glib >=2.63.1,<3.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "GPL2", + "md5": "5071c9fcf92c0fb457e164515a99df4f", + "name": "dbus", + "sha256": "60b14035a6861d141d23e3513ceeb05eda70c41ea3ecae8add7095315c503124", + "size": 604635, + "subdir": "linux-64", + "timestamp": 1588560187466, + "version": "1.13.14" + }, + "dbus-1.13.16-hb2f20db_0.tar.bz2": { + "build": "hb2f20db_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "glib >=2.63.1,<3.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "GPL2", + "md5": "094cacb65bec5e7fe21285c804cb35f2", + "name": "dbus", + "sha256": "b973504c9f4764a34b2e7082364e0135b854fdb125988c4b2ad5662d89a5a47a", + "size": 602680, + "subdir": "linux-64", + "timestamp": 1593111218352, + "version": "1.13.16" + }, + "dbus-1.13.18-hb2f20db_0.tar.bz2": { + "build": "hb2f20db_0", + "build_number": 0, + "depends": [ + "expat >=2.2.10,<3.0a0", + "glib", + "libgcc-ng >=7.3.0" + ], + "license": "GPL2", + "md5": "498d0788982ec4c5d13a44359b9c7afb", + "name": "dbus", + "sha256": "469debfa966d24b8372aaf909ecbe27dc6fde186f6f0d5b9e0a8427e38053364", + "size": 600218, + "subdir": "linux-64", + "timestamp": 1602701107852, + "version": "1.13.18" + }, + "dbus-1.13.2-h714fa37_1.tar.bz2": { + "build": "h714fa37_1", + "build_number": 1, + "depends": [ + "expat", + "expat >=2.2.5,<3.0a0", + "glib >=2.56.1,<3.0a0", + "libgcc-ng >=7.2.0" + ], + "license": "GPL2", + "md5": "7d69b398b73303e5844ca4e4c3650150", + "name": "dbus", + "sha256": "ebcc1c4738f9eb4559aee72866e3a89dccfc94c1a3769d03574907a290faf160", + "size": 567746, + "subdir": "linux-64", + "timestamp": 1523700685718, + "version": "1.13.2" + }, + "dbus-1.13.2-hc3f9b76_0.tar.bz2": { + "build": "hc3f9b76_0", + "build_number": 0, + "depends": [ + "expat", + "expat >=2.2.5,<3.0a0", + "glib >=2.53.6,<3.0a0", + "libgcc-ng >=7.2.0" + ], + "license": "GPL2", + "md5": "d9a8dff4072e5595188802abd773e4b8", + "name": "dbus", + "sha256": "dc11a651966809662f51022a440a807600cb5190dd1c4d76e9cea05ae7c55559", + "size": 567335, + "subdir": "linux-64", + "timestamp": 1522686405896, + "version": "1.13.2" + }, + "dbus-1.13.6-h746ee38_0.tar.bz2": { + "build": "h746ee38_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "glib >=2.56.2,<3.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "GPL2", + "md5": "fbcb82abc13e3f7fe72fb63994a4c774", + "name": "dbus", + "sha256": "d95488707ae9bf3f944d929b7629e3fcc2dda99cfee24eafa99db24bcb7ff248", + "size": 600883, + "subdir": "linux-64", + "timestamp": 1547912302374, + "version": "1.13.6" + }, + "dbus-1.13.6-hb2f20db_0.tar.bz2": { + "build": "hb2f20db_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "glib >=2.63.1,<3.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "GPL2", + "md5": "e7c077f382f5f9e7f46329f52344903b", + "name": "dbus", + "sha256": "09d7bc481d944b259f7f7db52f4ccaa61a5c01d04e7e77f2cd16e8911aafd0e5", + "size": 616125, + "subdir": "linux-64", + "timestamp": 1588550285006, + "version": "1.13.6" + }, + "dbus-python-1.2.18-py310hfc3c560_0.tar.bz2": { + "build": "py310hfc3c560_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.18,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe3469192ddd58c1c3b59f67f1ad1ed9", + "name": "dbus-python", + "sha256": "4d883278c6aebb918a4bc30d0c1d698bfbea163d7acbb48662f5f709189f0a46", + "size": 125075, + "subdir": "linux-64", + "timestamp": 1659032266936, + "version": "1.2.18" + }, + "dbus-python-1.2.18-py311hfc3c560_0.tar.bz2": { + "build": "py311hfc3c560_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.18,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48a6107117c7cd50ca2ba6059a3bbe80", + "name": "dbus-python", + "sha256": "5ef46cd7a04a85c8159e5cc8105596d9665eb7e2648e9e507b4c884031e104b6", + "size": 140848, + "subdir": "linux-64", + "timestamp": 1676825218385, + "version": "1.2.18" + }, + "dbus-python-1.2.18-py37hfc3c560_0.tar.bz2": { + "build": "py37hfc3c560_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.18,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0e84d53829c1bf6a426fe211d9f857f8", + "name": "dbus-python", + "sha256": "c96d810029fa948e8573a3d71560709f211fb2053367041e67fdf59b018ec5c3", + "size": 123811, + "subdir": "linux-64", + "timestamp": 1659032090614, + "version": "1.2.18" + }, + "dbus-python-1.2.18-py38hfc3c560_0.tar.bz2": { + "build": "py38hfc3c560_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.18,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3756b9678c4d4b82bd14a410fc845f3", + "name": "dbus-python", + "sha256": "1f00b4507201d8fad72161e6b16d9e8f84154f92e5aa81ab5df39cac90d12f17", + "size": 124745, + "subdir": "linux-64", + "timestamp": 1659032144124, + "version": "1.2.18" + }, + "dbus-python-1.2.18-py39hfc3c560_0.tar.bz2": { + "build": "py39hfc3c560_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.18,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f8d74c9da437ca032076bf5876bbc84", + "name": "dbus-python", + "sha256": "7f9ee291190599bcc7831df70c2d254aac607292e1b7bd9738854d61fd6db2dd", + "size": 124846, + "subdir": "linux-64", + "timestamp": 1659032197240, + "version": "1.2.18" + }, + "debugpy-1.4.1-py36h295c915_0.tar.bz2": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "edec94ca2a1cd1828a3bf6af75e3af45", + "name": "debugpy", + "sha256": "6139c144e45c0e6bf0140468461fb0ba12882410361684d9d6aa6784772f4ce1", + "size": 2059572, + "subdir": "linux-64", + "timestamp": 1629222796668, + "version": "1.4.1" + }, + "debugpy-1.4.1-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7acc6bdd81288bd92aa189418c4ce1e0", + "name": "debugpy", + "sha256": "55853cc5f9d0e222c2b2225aac979486693561ac4492c0ea867d5f1df7b7f78f", + "size": 2067348, + "subdir": "linux-64", + "timestamp": 1629222507853, + "version": "1.4.1" + }, + "debugpy-1.4.1-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8658037bfb26da540a17b600d9891c34", + "name": "debugpy", + "sha256": "38cffbe82d58970e1ec6be5e709fea11c498d05d2a5d0a5ce4cf79b2caaaf0bc", + "size": 2097297, + "subdir": "linux-64", + "timestamp": 1629222774574, + "version": "1.4.1" + }, + "debugpy-1.4.1-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a6d78e7bc900204273134814edbddce6", + "name": "debugpy", + "sha256": "f57f799cc183494403f9566c34a72b9e10c1ca13f87d0e6bc9a12253e80512f4", + "size": 2097074, + "subdir": "linux-64", + "timestamp": 1629214203781, + "version": "1.4.1" + }, + "debugpy-1.5.1-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa967d228c67e44ca5c6142535b04c87", + "name": "debugpy", + "sha256": "8a4e935d3f3dbe68dd81d084f0ae09f6e1cf22b1ccb2ae7479ccba16307e1157", + "size": 2108292, + "subdir": "linux-64", + "timestamp": 1640789547774, + "version": "1.5.1" + }, + "debugpy-1.5.1-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b38664fc65a1bb8a134e08623e9391b", + "name": "debugpy", + "sha256": "7cb4d73ca58c184a09635569b28c3c3b0daa4217b25954cd7f4017189552d887", + "size": 2334351, + "subdir": "linux-64", + "timestamp": 1676824922722, + "version": "1.5.1" + }, + "debugpy-1.5.1-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "574ddf7ad0317c124aa7632ef84a0e8d", + "name": "debugpy", + "sha256": "8c434b0d487bf1dd248c993d60517b019a0ff82436bc5c39f2ad3e54e5dd5e8e", + "size": 2090868, + "subdir": "linux-64", + "timestamp": 1637091495391, + "version": "1.5.1" + }, + "debugpy-1.5.1-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "637c8337c96bc1125bebf2809ecd0ff7", + "name": "debugpy", + "sha256": "2e4214d51aa2a634a46fde19b92644798d92c450d055f1a3a62bc162a4b39cd6", + "size": 2099690, + "subdir": "linux-64", + "timestamp": 1637091855055, + "version": "1.5.1" + }, + "debugpy-1.5.1-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0524ffca60f845eb392bbb56d56f0ce5", + "name": "debugpy", + "sha256": "3a39a2d6f161080c706292e3bf480f62d2444b1d6d67b3d7db50458202ee31f1", + "size": 2094615, + "subdir": "linux-64", + "timestamp": 1637091869922, + "version": "1.5.1" + }, + "decorator-4.1.2-py27h1544723_0.tar.bz2": { + "build": "py27h1544723_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3bd387cdcfa780916c3bd2bdc02942c5", + "name": "decorator", + "sha256": "24168d8beb83ee03c6ca5dd521bc8a6aaff3dc28bbedde43ce8bb24d0aeaac84", + "size": 15060, + "subdir": "linux-64", + "timestamp": 1505671998830, + "version": "4.1.2" + }, + "decorator-4.1.2-py35h3a268aa_0.tar.bz2": { + "build": "py35h3a268aa_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f0460b9c573d5f598bf4322c643a9759", + "name": "decorator", + "sha256": "2fe12dcb7a57a18e21bf6ec89616e0f2981af81d0b4f078e0a8ea5814d6f80c6", + "size": 15351, + "subdir": "linux-64", + "timestamp": 1505672010649, + "version": "4.1.2" + }, + "decorator-4.1.2-py36hd076ac8_0.tar.bz2": { + "build": "py36hd076ac8_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1c88f6447de6cbbdeb706c7b6e5ebf8d", + "name": "decorator", + "sha256": "595aecb3077becc424f4e5402cb4d394234659f5f1ca3b5174155487c56dfe86", + "size": 15267, + "subdir": "linux-64", + "timestamp": 1505672022605, + "version": "4.1.2" + }, + "decorator-4.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0ebe0cb0d62eae6cd237444ba8fded66", + "name": "decorator", + "sha256": "b5f77880181b37fb2e180766869da6242648aaec5bdd6de89296d9dacd764c14", + "size": 15638, + "subdir": "linux-64", + "timestamp": 1516376429792, + "version": "4.2.1" + }, + "decorator-4.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "af7dfe5fc77146ee55c19065112d1939", + "name": "decorator", + "sha256": "f768ece9db3eaf013959b21c97f444a3fe06b1e621d154506bb15ce945f113e4", + "size": 15956, + "subdir": "linux-64", + "timestamp": 1516376670489, + "version": "4.2.1" + }, + "decorator-4.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "43ef128656d8bf6a29dedc2131c794d8", + "name": "decorator", + "sha256": "532ec3dc8d9e7a4f311e03135bcb8fc4f2c6ab637361dffca68f556e89050804", + "size": 15836, + "subdir": "linux-64", + "timestamp": 1516376671963, + "version": "4.2.1" + }, + "decorator-4.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "66df11ef884b89643b2f77454d06cabf", + "name": "decorator", + "sha256": "a0874c095949fe8d514b6b3870e7d82ea5556fed1a8cb881bbcc2daf7506150d", + "size": 15529, + "subdir": "linux-64", + "timestamp": 1523903612790, + "version": "4.3.0" + }, + "decorator-4.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fbfe171cc7770da2b8350c904727c93a", + "name": "decorator", + "sha256": "d40a30d2b0b1cbed63fe52d964a9f63b6ea6f5623e05bd5665988a3d74da0a0f", + "size": 15802, + "subdir": "linux-64", + "timestamp": 1523903623007, + "version": "4.3.0" + }, + "decorator-4.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9b400daee8656c3fc49326d7924047c7", + "name": "decorator", + "sha256": "37229134bdb134efd825a15cbb4eda95ac55c53d2b3108654e41729816f21252", + "size": 15685, + "subdir": "linux-64", + "timestamp": 1523903566479, + "version": "4.3.0" + }, + "decorator-4.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b0b408b0b5310461467b364cab85c886", + "name": "decorator", + "sha256": "368739158f169990a1e49c3c3aa06a62e57b4352c8c75ce84e6856805751be63", + "size": 15819, + "subdir": "linux-64", + "timestamp": 1530694332680, + "version": "4.3.0" + }, + "decorator-4.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d50ea145a4df4881bce86e682029a3b0", + "name": "decorator", + "sha256": "58443f9200a30abb4a960e5d208597e02631881f0383558d615cf42c64e583ed", + "size": 17038, + "subdir": "linux-64", + "timestamp": 1549321235404, + "version": "4.3.2" + }, + "decorator-4.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4c234a873b86832a34db1e11d2b04219", + "name": "decorator", + "sha256": "e25a3ab45fe42bf87d77a243a9f80c25ac4f15081238d1b10f0abd270a69f073", + "size": 17232, + "subdir": "linux-64", + "timestamp": 1549321244926, + "version": "4.3.2" + }, + "decorator-4.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8f3c330debbd0f7fccd1c6a601e26e91", + "name": "decorator", + "sha256": "ff474d2cdf1bf396bf972cb3edf4184b035ada156bc752563f670720c3de0405", + "size": 17237, + "subdir": "linux-64", + "timestamp": 1549321208912, + "version": "4.3.2" + }, + "decorator-4.4.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "057581758a10af5d5513a3ce500f1133", + "name": "decorator", + "sha256": "8b8f62a5c6a4fe746c96cce1ed3ef3df7d7cb661cf54eff50b955fce4eb25785", + "size": 18513, + "subdir": "linux-64", + "timestamp": 1553289502403, + "version": "4.4.0" + }, + "decorator-4.4.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dc0a3d5a05d1bd62d1813b967469e85e", + "name": "decorator", + "sha256": "b77106d0b181c44e61392411969c2e03648bec16ab2002d41a4141c8214623b9", + "size": 18708, + "subdir": "linux-64", + "timestamp": 1553289438478, + "version": "4.4.0" + }, + "decorator-4.4.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0c41581e4a332e8f2496592c9177ad0a", + "name": "decorator", + "sha256": "58cc26ee9e7e5d9f48f39e8a7c98473442de1b48e1733c9842952a552df35f59", + "size": 18736, + "subdir": "linux-64", + "timestamp": 1553289538176, + "version": "4.4.0" + }, + "defusedxml-0.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "d7dd545e6f6e46e751fac2aa42567a16", + "name": "defusedxml", + "sha256": "240343e74a843f1e7f74f6d9a3f182258d74048fa27f2a26d6eac732dcb91f4b", + "size": 42447, + "subdir": "linux-64", + "timestamp": 1530919284140, + "version": "0.5.0" + }, + "defusedxml-0.5.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "c77151a5b686d137f6de49f9aa63da45", + "name": "defusedxml", + "sha256": "1db1368aa71613657331d8f2f990260fd8b42bd275358d71629879e96c0f8df5", + "size": 29733, + "subdir": "linux-64", + "timestamp": 1536782398039, + "version": "0.5.0" + }, + "defusedxml-0.5.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "bb6cd46a8934914fe180d03f68bc66ef", + "name": "defusedxml", + "sha256": "ad54e7fde299db7be12c910a78a658f37b9474f8538892cbd741ad9a49493bea", + "size": 30082, + "subdir": "linux-64", + "timestamp": 1536782427823, + "version": "0.5.0" + }, + "defusedxml-0.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "1353e4183b881383553503f1a8717303", + "name": "defusedxml", + "sha256": "56f44d9b236b64fe96de12b65280e41a11747d5d9c4c16fa5b50c90e656552b6", + "size": 42100, + "subdir": "linux-64", + "timestamp": 1530919229009, + "version": "0.5.0" + }, + "defusedxml-0.5.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "119cb6c81dcedab19ae2424eea04edec", + "name": "defusedxml", + "sha256": "7febde4b2d492305c5079ccd0f97634f2e2c706e03c3b4eb491f5c255aec0c7e", + "size": 30103, + "subdir": "linux-64", + "timestamp": 1536782434374, + "version": "0.5.0" + }, + "defusedxml-0.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "0fabc608d7640fc0edc90a46f213df50", + "name": "defusedxml", + "sha256": "03fb5707ab7517d36f06194260048c238564bbd6f5a6bcd8e531f52f172b62bd", + "size": 42125, + "subdir": "linux-64", + "timestamp": 1530919256967, + "version": "0.5.0" + }, + "defusedxml-0.5.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "4c54cad1db0ecf0bc38ca72fa8366be1", + "name": "defusedxml", + "sha256": "74c1be2343b5590b8b23114db56051845ab90c336b91e136f3ee4f812c6a1bad", + "size": 30073, + "subdir": "linux-64", + "timestamp": 1536782373215, + "version": "0.5.0" + }, + "deprecated-1.2.13-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "wrapt >=1.10,<2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d765ab849c91ab6b5a0ca5ed2fda58d0", + "name": "deprecated", + "sha256": "97ab56e82cc030b801eefd4cb4bc71729dc244bf45bfcbf49021b27eb52406d0", + "size": 15989, + "subdir": "linux-64", + "timestamp": 1659726507026, + "version": "1.2.13" + }, + "deprecated-1.2.13-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "wrapt >=1.10,<2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "28420217ae88e61a23a3817706016427", + "name": "deprecated", + "sha256": "433f2bb27e5584038c8ef576aaa77dbb209d4a018d6f1196389adac62e4aa3cb", + "size": 18755, + "subdir": "linux-64", + "timestamp": 1676830473529, + "version": "1.2.13" + }, + "deprecated-1.2.13-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "wrapt >=1.10,<2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "530964da986ebd30cd3a91d7dbf81253", + "name": "deprecated", + "sha256": "24c932b93f7c60d31c0b33d36912826a0210bda3be85046446d9560cfa49bb5c", + "size": 15886, + "subdir": "linux-64", + "timestamp": 1659726561168, + "version": "1.2.13" + }, + "deprecated-1.2.13-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "wrapt >=1.10,<2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "53c02a73ca51b4da7eec933132df8984", + "name": "deprecated", + "sha256": "8a70ee4a68852cbf2b867b2c7ccf4e69be560f63699b6a154761f38b2a1bbc5a", + "size": 15910, + "subdir": "linux-64", + "timestamp": 1659726532850, + "version": "1.2.13" + }, + "deprecated-1.2.13-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "wrapt >=1.10,<2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45f053e805db4bf5c6cb523ea5881791", + "name": "deprecated", + "sha256": "613c4e88a33cc9f9fff2dda8bbbd308b403bca871c7f87c65dfac66fd484f709", + "size": 15921, + "subdir": "linux-64", + "timestamp": 1659726467857, + "version": "1.2.13" + }, + "descartes-1.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "matplotlib", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "fd7462272242467a1dcf028c813acefd", + "name": "descartes", + "sha256": "17985a293a1bec0bf47df28a58e0c7e7d3c18e5dff7e937c3588fbf9abd6719c", + "size": 8832, + "subdir": "linux-64", + "timestamp": 1530873052345, + "version": "1.1.0" + }, + "descartes-1.1.0-py27h5233db4_0.tar.bz2": { + "build": "py27h5233db4_0", + "build_number": 0, + "depends": [ + "matplotlib", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "8b5e26a7d933260718fe54f43370c1be", + "name": "descartes", + "sha256": "90de8806e07768b970f456e4c687458b3122719714983b8a18e9bc3bef9c4425", + "size": 9029, + "subdir": "linux-64", + "timestamp": 1513268607706, + "version": "1.1.0" + }, + "descartes-1.1.0-py35h2f9c1c0_0.tar.bz2": { + "build": "py35h2f9c1c0_0", + "build_number": 0, + "depends": [ + "matplotlib", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "549aff026ee94fe2d2b0655d8ebf1777", + "name": "descartes", + "sha256": "f55e0ea04bb16b90198966feeb103412a44c0cb6c253c72ac3297425d8ec71ab", + "size": 9361, + "subdir": "linux-64", + "timestamp": 1513268662693, + "version": "1.1.0" + }, + "descartes-1.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "matplotlib", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "221d563a44d058f35308d9694e32158c", + "name": "descartes", + "sha256": "47fd2bdfea4e361ab9a0327b65ce365d495f0f1e495fcf7f7669080816d11b41", + "size": 9123, + "subdir": "linux-64", + "timestamp": 1530873114196, + "version": "1.1.0" + }, + "descartes-1.1.0-py36h2f9c1c0_0.tar.bz2": { + "build": "py36h2f9c1c0_0", + "build_number": 0, + "depends": [ + "matplotlib", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "24bd0d485e0724aaf4db915eb86f97c6", + "name": "descartes", + "sha256": "21efdc4f2a57e00558d147b12e89f7a760c9f4aab3b7a1eadd88c941ac1998c2", + "size": 9311, + "subdir": "linux-64", + "timestamp": 1513268674408, + "version": "1.1.0" + }, + "descartes-1.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "matplotlib", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "dfcb15391f41017bf12b2f35942ddcba", + "name": "descartes", + "sha256": "2efef3ee5b0c685a8dced0266e9b849eac0fb095c403e62aa8a20a4ecae4d366", + "size": 9140, + "subdir": "linux-64", + "timestamp": 1530873083247, + "version": "1.1.0" + }, + "descartes-1.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "matplotlib", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "2343a04a4d8f5c861b5b3dab9db3d180", + "name": "descartes", + "sha256": "7c6619ef1ccf34b880a33fd8e6fa626bc87c8e7710f5e9e5962d076e55bf209c", + "size": 9602, + "subdir": "linux-64", + "timestamp": 1574448306954, + "version": "1.1.0" + }, + "devil-1.8.0-hfdbbce5_0.tar.bz2": { + "build": "hfdbbce5_0", + "build_number": 0, + "depends": [ + "jasper >=2.0.14,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "zlib" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "4c67a6fda2251b525e562e5f17ab05e3", + "name": "devil", + "sha256": "a2bc7abf709d5fb6747d210797f89ca5ea93b354fb9557a5b64f18f77f9b48d5", + "size": 310945, + "subdir": "linux-64", + "timestamp": 1651749256008, + "version": "1.8.0" + }, + "dicttoxml-1.7.4-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "e3e0b3a2cbb6efb91b4e0f28a7f00826", + "name": "dicttoxml", + "sha256": "008cc82344f4aa3a37cb835505a4e851ea4497ace27ad9262024968a33151f25", + "size": 24979, + "subdir": "linux-64", + "timestamp": 1543382318301, + "version": "1.7.4" + }, + "dicttoxml-1.7.4-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "b600983a156f14d27c33ca9c2c897d91", + "name": "dicttoxml", + "sha256": "c23d40b180317ab2d689621987f4acd27ddef5af169966b98472994d49076bbd", + "size": 24851, + "subdir": "linux-64", + "timestamp": 1640789567413, + "version": "1.7.4" + }, + "dicttoxml-1.7.4-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "31018d2eb74725ac759a4a54aae64032", + "name": "dicttoxml", + "sha256": "a5fddfec8e2bd06121e66674be15687b5d910b19730a9a25e6b911cadf19d548", + "size": 28630, + "subdir": "linux-64", + "timestamp": 1676851924791, + "version": "1.7.4" + }, + "dicttoxml-1.7.4-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "b0571aebb74cf43468b55b8ba3060758", + "name": "dicttoxml", + "sha256": "a7a2de21ef048ee732657d3e1e6884b78512b50e7a761cb791da50fef1cb0425", + "size": 25116, + "subdir": "linux-64", + "timestamp": 1543382337085, + "version": "1.7.4" + }, + "dicttoxml-1.7.4-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "56deb02f0bb4d166a164a1876dd0bf65", + "name": "dicttoxml", + "sha256": "7760c6eeb5006f74d23ff3778708183ce941751ce463679e656e6d4329adc3ac", + "size": 25711, + "subdir": "linux-64", + "timestamp": 1611677538584, + "version": "1.7.4" + }, + "dicttoxml-1.7.4-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "fbebe2cfb8b8eef810932aeb306d0692", + "name": "dicttoxml", + "sha256": "d1f4f92ce505ad965f44ed810a70d464d6d59e05ea8982deb0df1ec9d871579e", + "size": 25132, + "subdir": "linux-64", + "timestamp": 1543382277194, + "version": "1.7.4" + }, + "dicttoxml-1.7.4-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "acd94d109ceda78a5f60e99691f58e91", + "name": "dicttoxml", + "sha256": "bf29a80aaae304acc11f8248f1a7e2f1b7136062f7e0dd1c58c1ac86e31c9528", + "size": 25730, + "subdir": "linux-64", + "timestamp": 1611677561069, + "version": "1.7.4" + }, + "dicttoxml-1.7.4-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "6aff9c2d6d6a3f0a8533f40395495bbb", + "name": "dicttoxml", + "sha256": "70737bd403d69ea552cee1651c50bdbe4344cc79c624fab8a9f9ecb657e989e9", + "size": 24755, + "subdir": "linux-64", + "timestamp": 1572434950434, + "version": "1.7.4" + }, + "dicttoxml-1.7.4-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "5223567dd5aa1b2decf28bc15a42d39e", + "name": "dicttoxml", + "sha256": "6ca7bb857e4f1603f126f1f8fccf31fa593b77f9e96844d1c2ecd7c7db1662d4", + "size": 25783, + "subdir": "linux-64", + "timestamp": 1611677577856, + "version": "1.7.4" + }, + "dicttoxml-1.7.4-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "4329347fcc20844594419056037dce9e", + "name": "dicttoxml", + "sha256": "25151588a302ff45daacd6c7e33f15c67bc2d41ffa9fb995f776abefa3a836e0", + "size": 25771, + "subdir": "linux-64", + "timestamp": 1611677563416, + "version": "1.7.4" + }, + "diffusers-0.11.0-py310h2f386ee_0.tar.bz2": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "diffusers-torch 0.11.0 py310h2f386ee_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bf1bfa212562afe231094e840e941e33", + "name": "diffusers", + "sha256": "3dd5f165e07fb857d3335fab47d700de143434557fcfc0e6944e989c8cc76f0d", + "size": 3228152, + "subdir": "linux-64", + "timestamp": 1671578845016, + "version": "0.11.0" + }, + "diffusers-0.11.0-py37hb070fc8_0.tar.bz2": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "diffusers-torch 0.11.0 py37hb070fc8_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "54349a95935a8aa12057307813f43445", + "name": "diffusers", + "sha256": "898fc51a2459f92d642b9bc9118b5b8cf6974d5dbd7e7fd569ab0de72982c670", + "size": 3089755, + "subdir": "linux-64", + "timestamp": 1671578869411, + "version": "0.11.0" + }, + "diffusers-0.11.0-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "diffusers-torch 0.11.0 py38hb070fc8_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2fb0feb410236a4ee5b33cb98addb254", + "name": "diffusers", + "sha256": "0b7d3da4666c91bdb3b82df00711b546517b1b629c6a67becc945953b6b297a3", + "size": 3215190, + "subdir": "linux-64", + "timestamp": 1671578893889, + "version": "0.11.0" + }, + "diffusers-0.11.0-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "diffusers-torch 0.11.0 py39hb070fc8_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c0f9d84532206d77016a684a712686c3", + "name": "diffusers", + "sha256": "51647f6f9828fd9bb8164159ea1a67f46b60b7b618181c731ae0d997c817ff0f", + "size": 3185681, + "subdir": "linux-64", + "timestamp": 1671578918739, + "version": "0.11.0" + }, + "diffusers-base-0.11.0-py310h2f386ee_0.tar.bz2": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.10.0", + "importlib-metadata", + "numpy", + "pillow", + "python >=3.10,<3.11.0a0", + "regex !=2019.12.17", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "42a39974e2878d0383824335f04705c6", + "name": "diffusers-base", + "sha256": "34eb5557ba107d09f5f67748e296b70874e06e9d01c2de45b54796d0fa8b0e75", + "size": 3228736, + "subdir": "linux-64", + "timestamp": 1671578666611, + "version": "0.11.0" + }, + "diffusers-base-0.11.0-py37hb070fc8_0.tar.bz2": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.10.0", + "importlib-metadata", + "numpy", + "pillow", + "python >=3.7,<3.8.0a0", + "regex !=2019.12.17", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5ed8733ee2c2f20da7d5b64de2d6d400", + "name": "diffusers-base", + "sha256": "9feb4850a7e8e856dc8b16f2c3a6ffe7903bf9892d49d08676d64d0fce5d9fd4", + "size": 3089851, + "subdir": "linux-64", + "timestamp": 1671578688319, + "version": "0.11.0" + }, + "diffusers-base-0.11.0-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.10.0", + "importlib-metadata", + "numpy", + "pillow", + "python >=3.8,<3.9.0a0", + "regex !=2019.12.17", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4bc161abf42ef10f1470d42ac2af5440", + "name": "diffusers-base", + "sha256": "18dfcd6fc951ba569af013d349d98d71f1bc1d2da13e7dc6b8eba5d273d4c1a7", + "size": 3214692, + "subdir": "linux-64", + "timestamp": 1671578710063, + "version": "0.11.0" + }, + "diffusers-base-0.11.0-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.10.0", + "importlib-metadata", + "numpy", + "pillow", + "python >=3.9,<3.10.0a0", + "regex !=2019.12.17", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "da4df35224fe99efca01504152ee5f92", + "name": "diffusers-base", + "sha256": "e8e5dfc3bfcac9d5f0a6ceec587ebb6009f58a0d4248ce056eae400db41088a2", + "size": 3186361, + "subdir": "linux-64", + "timestamp": 1671578732056, + "version": "0.11.0" + }, + "diffusers-torch-0.11.0-py310h2f386ee_0.tar.bz2": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "diffusers-base 0.11.0 py310h2f386ee_0", + "huggingface_accelerate >=0.11.0", + "python >=3.10,<3.11.0a0", + "pytorch >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f9b4be42e20d307bb1e62c5c71039d72", + "name": "diffusers-torch", + "sha256": "3c8737c2fe14271bd43043a46555597994a2e56f5a11af84d3e4174de39ed420", + "size": 3229215, + "subdir": "linux-64", + "timestamp": 1671578753643, + "version": "0.11.0" + }, + "diffusers-torch-0.11.0-py37hb070fc8_0.tar.bz2": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "diffusers-base 0.11.0 py37hb070fc8_0", + "huggingface_accelerate >=0.11.0", + "python >=3.7,<3.8.0a0", + "pytorch >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4956efaeb093739270e0cd21a2b944ce", + "name": "diffusers-torch", + "sha256": "d81ce2c62a2588601ce272083ac9d6bb3892b60e05d854027516a5a4fed934f9", + "size": 3090029, + "subdir": "linux-64", + "timestamp": 1671578776239, + "version": "0.11.0" + }, + "diffusers-torch-0.11.0-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "diffusers-base 0.11.0 py38hb070fc8_0", + "huggingface_accelerate >=0.11.0", + "python >=3.8,<3.9.0a0", + "pytorch >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0a186ee58bdfefcf91392fe3a32ce810", + "name": "diffusers-torch", + "sha256": "5bf215a59385e6a11de6f3cd42a3166924b96b0c41a13d0f45e4634493c3ae70", + "size": 3215488, + "subdir": "linux-64", + "timestamp": 1671578799021, + "version": "0.11.0" + }, + "diffusers-torch-0.11.0-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "diffusers-base 0.11.0 py39hb070fc8_0", + "huggingface_accelerate >=0.11.0", + "python >=3.9,<3.10.0a0", + "pytorch >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "087715ab8462394595daf6bed2a0b973", + "name": "diffusers-torch", + "sha256": "49bb45825b3d4528cbde0e1d357fb29b21fdb2d03d43e205e7cc89840a1af6eb", + "size": 3185622, + "subdir": "linux-64", + "timestamp": 1671578821920, + "version": "0.11.0" + }, + "dill-0.2.7.1-py27h28bf823_0.tar.bz2": { + "build": "py27h28bf823_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7c13a2ea82caa8cee7f5320dc3878ebf", + "name": "dill", + "sha256": "058a5a31509d556f54902d857b5ec0e2c3673b9c37431f93024dfb85c71533cf", + "size": 83436, + "subdir": "linux-64", + "timestamp": 1507667955478, + "version": "0.2.7.1" + }, + "dill-0.2.7.1-py35h51ed871_0.tar.bz2": { + "build": "py35h51ed871_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "069207c83a9948a7d4d236288a23b338", + "name": "dill", + "sha256": "a6153d18f18276c32f95b694fbad24e9b9edf13367ed30a4c7cea9cf50706d0f", + "size": 84545, + "subdir": "linux-64", + "timestamp": 1507667984668, + "version": "0.2.7.1" + }, + "dill-0.2.7.1-py36h644ae93_0.tar.bz2": { + "build": "py36h644ae93_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "99fd217c7bb406cf444ccf64dc801fdc", + "name": "dill", + "sha256": "580b05e42d43ee957433fe6609395f59930f44960906e776cc48ecb3dc7b0adb", + "size": 84293, + "subdir": "linux-64", + "timestamp": 1507667987192, + "version": "0.2.7.1" + }, + "dill-0.2.8.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f331fac3d82d3df7e7845674643ab593", + "name": "dill", + "sha256": "cdd60c2649bd201237d3e4ed2a1701d7dbc3db2a92a31c2955d5ee6e817dcb69", + "size": 113034, + "subdir": "linux-64", + "timestamp": 1529948446908, + "version": "0.2.8.2" + }, + "dill-0.2.8.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0a9b8aebe22640081d6de4f5d576c627", + "name": "dill", + "sha256": "3471f8d3ecdc534dce52b4971e1d3c28551599a6c411739674dacd7eee3576c6", + "size": 115132, + "subdir": "linux-64", + "timestamp": 1529948469911, + "version": "0.2.8.2" + }, + "dill-0.2.8.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "be807f756ed1a4e4071dee8c2eeb7350", + "name": "dill", + "sha256": "986d6a29218cdb7dfb0bfa5a3b6a057175e96f459de98f15e1346ecfc74e51bb", + "size": 114369, + "subdir": "linux-64", + "timestamp": 1529948379203, + "version": "0.2.8.2" + }, + "dill-0.2.8.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ea41cfe2f2a69100728a220d1e8192e3", + "name": "dill", + "sha256": "a865ca4cd5b5cda6974850d37f3d1d9ae38c9170de16f9f776a7aed098444e36", + "size": 114365, + "subdir": "linux-64", + "timestamp": 1531055475071, + "version": "0.2.8.2" + }, + "dill-0.2.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b7f91d97633df07d2bb6c758b9c19aaa", + "name": "dill", + "sha256": "015913e0e2488359b7ef1af3dcaff6fc25ec55585f1ef81bee831ce45e2ec47f", + "size": 117657, + "subdir": "linux-64", + "timestamp": 1552344487798, + "version": "0.2.9" + }, + "dill-0.2.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "99776c2ccf3e3764256fa0621bd44b9f", + "name": "dill", + "sha256": "de5baebcfa873beadd26dc6e14c36c68b52bacaba9942d9ee4f8b10ff4370083", + "size": 118558, + "subdir": "linux-64", + "timestamp": 1552344483098, + "version": "0.2.9" + }, + "dill-0.2.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "61a144bb1773ab836dc6a7e8507535e3", + "name": "dill", + "sha256": "82f0a2f41d603852db52fbbe42556af2bac163d220e1a194dedba1469919e5b8", + "size": 118830, + "subdir": "linux-64", + "timestamp": 1552344457252, + "version": "0.2.9" + }, + "dill-0.2.9-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f190fa86e4b6a3b25e2cce02ba77fd03", + "name": "dill", + "sha256": "93035790b792be8065d088606275788c4a510e6a1a227c8ef9ed4b3ad730f856", + "size": 116455, + "subdir": "linux-64", + "timestamp": 1572435016852, + "version": "0.2.9" + }, + "dill-0.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b2bfb6f2c7ad62fcb14fd1ac5dacc978", + "name": "dill", + "sha256": "7e113d871b3f0c11d3a18d70548fa72efb8e65b2cdb402405ba691286d0df47b", + "size": 118089, + "subdir": "linux-64", + "timestamp": 1564161844133, + "version": "0.3.0" + }, + "dill-0.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "437396a71992ce8707aec5327a23dcc3", + "name": "dill", + "sha256": "98c7e64ec076425256e5303d6112497a3b19e9ee5fdd6c0d3f9aca2552ac62e7", + "size": 118956, + "subdir": "linux-64", + "timestamp": 1564161833605, + "version": "0.3.0" + }, + "dill-0.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b76dee814e489254696b9d211f6c2714", + "name": "dill", + "sha256": "21c7ecaa5f5c8913b523724a3d064bba499c35b48de2c1bdf892a843a7c11d21", + "size": 119246, + "subdir": "linux-64", + "timestamp": 1564161830621, + "version": "0.3.0" + }, + "dill-0.3.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a300e21bdb9a809dfd87edcd5a047a5", + "name": "dill", + "sha256": "c92b7986f5dfe8de082141a108c7aba2840a67cea69e24b7d02cdcd138f310fe", + "size": 120987, + "subdir": "linux-64", + "timestamp": 1573225287802, + "version": "0.3.1.1" + }, + "dill-0.3.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "954a24cb602d5b30f38084c1e7b4d132", + "name": "dill", + "sha256": "2a3df59719698a339ff000af701b3e18d994812de207d870de55e42bc34cf966", + "size": 121830, + "subdir": "linux-64", + "timestamp": 1573225289895, + "version": "0.3.1.1" + }, + "dill-0.3.1.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1387cf245c8ab3c5fa668071d8bb4f1", + "name": "dill", + "sha256": "b1c67aa4c84c20690e79a12f3b6da5e2b2fa7d3070f5da37cb37b8fdf94b6616", + "size": 122549, + "subdir": "linux-64", + "timestamp": 1591795853205, + "version": "0.3.1.1" + }, + "dill-0.3.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "08961a7f8fb7d6b6d69097c5690d1eda", + "name": "dill", + "sha256": "dd556e9061d354c28e0b174474e56be6a0c2fc82383e2ed4bf9ea120b7d3a4b3", + "size": 122297, + "subdir": "linux-64", + "timestamp": 1573225271141, + "version": "0.3.1.1" + }, + "dill-0.3.1.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff89a4c593ded062392ba9968a57b01f", + "name": "dill", + "sha256": "2262c9ca4b7f9c2081375e4014a13742281868b06f03b92c3648d78986465bb2", + "size": 122548, + "subdir": "linux-64", + "timestamp": 1591789185087, + "version": "0.3.1.1" + }, + "dill-0.3.1.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cc8c955b0a462ddfcec9bbb0ac464505", + "name": "dill", + "sha256": "007ae6a240d8a9304070bbcb22a75549a4f5d00ccb8cb05793dc9da4083f5e71", + "size": 122520, + "subdir": "linux-64", + "timestamp": 1573225302229, + "version": "0.3.1.1" + }, + "dill-0.3.1.1-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6d7a830ace6fe8f0721acdbb13330933", + "name": "dill", + "sha256": "afb4933dd347ddb7a683718d4696cdcc107fffd1eec44b2267b2587998c41608", + "size": 122806, + "subdir": "linux-64", + "timestamp": 1591789206731, + "version": "0.3.1.1" + }, + "dill-0.3.6-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "19465f71f8182ee8b74ec12f855f8a85", + "name": "dill", + "sha256": "b10fec353cf4b3bc10e592be3f26dbc1ffaff869bf5629314dc8f43f96cbc6d3", + "size": 161383, + "subdir": "linux-64", + "timestamp": 1667919622818, + "version": "0.3.6" + }, + "dill-0.3.6-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20146dd8c995fb288fab952aa7432b06", + "name": "dill", + "sha256": "ef19a4012010624319626512972761db6b62ad6b2b9f0029f781e5232c37cc99", + "size": 214649, + "subdir": "linux-64", + "timestamp": 1676827725133, + "version": "0.3.6" + }, + "dill-0.3.6-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3901e2317446aff52a913bf0bddd21b5", + "name": "dill", + "sha256": "8088c71b0d3f178c406aad38d95359c3c0e34c6a2171c2fd2c12670f8a135344", + "size": 160384, + "subdir": "linux-64", + "timestamp": 1667919673864, + "version": "0.3.6" + }, + "dill-0.3.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e56e9d8518bb92bf980a0987e105298c", + "name": "dill", + "sha256": "1f46845af7291458e1720a4a336363d49889263a0da2f9ae92fda75db61c4bd9", + "size": 160388, + "subdir": "linux-64", + "timestamp": 1667919648125, + "version": "0.3.6" + }, + "dill-0.3.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "63d00571d1894eaf764297d848460c80", + "name": "dill", + "sha256": "fc85b1dd504fff5a0f47b21a0233aedc1ae1aaff01a569f54a074fa5e223ce35", + "size": 160137, + "subdir": "linux-64", + "timestamp": 1667919699601, + "version": "0.3.6" + }, + "dis3-0.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e917844dec5dc09d7d4827fa8065d6f", + "name": "dis3", + "sha256": "247ee820ce310f51f6f7aedc4f9e91f52a23b86a15c4bbdf808736b72d7175f4", + "size": 15798, + "subdir": "linux-64", + "timestamp": 1561613167935, + "version": "0.1.2" + }, + "dis3-0.1.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a065c2f8d1cae34b8b71ca1d96598562", + "name": "dis3", + "sha256": "9b18c9ba803917dc16cefe2e9911961b293e88820c14c0d9013afba7bc070274", + "size": 20870, + "subdir": "linux-64", + "timestamp": 1569435647222, + "version": "0.1.3" + }, + "distconfig3-1.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "556540acc0456a03e6bcb7beda5a0eba", + "name": "distconfig3", + "sha256": "bc3fcff25461194a0265419a29368daf52612f012b1dff2a5f27e5906c99c093", + "size": 31695, + "subdir": "linux-64", + "timestamp": 1668611891293, + "version": "1.0.1" + }, + "distconfig3-1.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "44ef449dfe58e6ca04d6473a15c1ca79", + "name": "distconfig3", + "sha256": "f016b677d036d084e285f1b5d91e2eff6d2c17aaa868249937ceb234505e90ef", + "size": 39258, + "subdir": "linux-64", + "timestamp": 1676843991242, + "version": "1.0.1" + }, + "distconfig3-1.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d47f0f37eb2e2d24b0db315017aada1f", + "name": "distconfig3", + "sha256": "ffa6a546bccc0da66de82876c726445147316cd323fb1b332cbcd1364378b037", + "size": 31169, + "subdir": "linux-64", + "timestamp": 1668611945160, + "version": "1.0.1" + }, + "distconfig3-1.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fa29d881e2a76bc1affab7f4534eae18", + "name": "distconfig3", + "sha256": "d3e7df74bda028e5f7b3384acc99c1719ff211532e758ea3952fd3c0a89702c1", + "size": 31304, + "subdir": "linux-64", + "timestamp": 1668611864504, + "version": "1.0.1" + }, + "distconfig3-1.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4d3dd6dd27543ba36eb67a9a0ffdc6d0", + "name": "distconfig3", + "sha256": "6633bd05e93ed87ff1ce3ca82986fb8b02794d8519986a4671e7d7674f78591d", + "size": 31359, + "subdir": "linux-64", + "timestamp": 1668611917928, + "version": "1.0.1" + }, + "distlib-0.2.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "fcb994a461fa50750e5b32c65b47322b", + "name": "distlib", + "sha256": "a3a7351f22ab2eae668d7a827695453982ff894f605a3aa008f64826ca5b8190", + "size": 368067, + "subdir": "linux-64", + "timestamp": 1519832811537, + "version": "0.2.6" + }, + "distlib-0.2.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "cc4177566e2bc989f7f672a5e6eabb2f", + "name": "distlib", + "sha256": "1312809c1d8ecf746da8b99db50a5be0cc6fd71c3edf96eb5c9cb3e8fb498408", + "size": 391032, + "subdir": "linux-64", + "timestamp": 1519832836940, + "version": "0.2.6" + }, + "distlib-0.2.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "58472a09ad4c3a94ef50b3eabe2366d3", + "name": "distlib", + "sha256": "a654c2b05948d9f28348aad599428132fff1756810773be823dd09b8dee0ace4", + "size": 388653, + "subdir": "linux-64", + "timestamp": 1519832796613, + "version": "0.2.6" + }, + "distlib-0.2.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "cff9a53d481ffff604231887442dca68", + "name": "distlib", + "sha256": "41c06e3f093e5c8b82f1fae0fecfc14829ba4a6567f4450868a3bbebbe6d7639", + "size": 367418, + "subdir": "linux-64", + "timestamp": 1524497712517, + "version": "0.2.7" + }, + "distlib-0.2.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "da8a014442eb86e1759622cd0a911101", + "name": "distlib", + "sha256": "72ae4597d4985c06fdf44e2ff8f100be8f0ab6931cb385c4c449a411d79d8ad7", + "size": 391606, + "subdir": "linux-64", + "timestamp": 1524497645775, + "version": "0.2.7" + }, + "distlib-0.2.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "03a4e2658fd3366c153773a8b6c81ce0", + "name": "distlib", + "sha256": "fa65251dcea0150489d891bbbbe73a81a5ec166bef8112afa197eeffef68c9a4", + "size": 389093, + "subdir": "linux-64", + "timestamp": 1524497719519, + "version": "0.2.7" + }, + "distlib-0.2.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "809b056eb33493f14680da7689b0f53e", + "name": "distlib", + "sha256": "6c687b25228696a058031c9cf4ccf7981586a5ef54369d9a4f93ba5d7747856a", + "size": 388869, + "subdir": "linux-64", + "timestamp": 1530873175503, + "version": "0.2.7" + }, + "distlib-0.2.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "0336e27f1cb858e8ab04b3b60c0fa1d9", + "name": "distlib", + "sha256": "a60c9764650a9c2f653124f608b4ad34fdbb70654ba5e1d6aace20422c1a0b55", + "size": 367459, + "subdir": "linux-64", + "timestamp": 1539474355370, + "version": "0.2.8" + }, + "distlib-0.2.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "8482cd10280d4d47fe757dcaf17c316c", + "name": "distlib", + "sha256": "8c877392e55f9264af8aa2b891dda388a86383aa996357136bf95c7988e9d6a9", + "size": 390060, + "subdir": "linux-64", + "timestamp": 1539474363724, + "version": "0.2.8" + }, + "distlib-0.2.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "60ddcc4952465b2350a0ae3cfa205434", + "name": "distlib", + "sha256": "192f73ee7afba500bc6f2fb611c4cced6121b955c7c74c61848c6db8bd4c93eb", + "size": 389468, + "subdir": "linux-64", + "timestamp": 1539474365860, + "version": "0.2.8" + }, + "distlib-0.2.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "b9a8b46924857cb00e70fd6f842bbfd2", + "name": "distlib", + "sha256": "f1470b9c1b4585b976a521a0a6e3d150749c12563b82c4094f9bd583f23e3efd", + "size": 515353, + "subdir": "linux-64", + "timestamp": 1569508525799, + "version": "0.2.9" + }, + "distlib-0.2.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "cf49cd931f81df10a9fb4c77d05cc03f", + "name": "distlib", + "sha256": "c51317ea6a424896ed3179c052b7d26d05778f2851c63bf8a7d77dcf7b2c82a1", + "size": 534504, + "subdir": "linux-64", + "timestamp": 1569508532527, + "version": "0.2.9" + }, + "distlib-0.2.9-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "15a7adf1688518a470a9fbf90c2fb8fc", + "name": "distlib", + "sha256": "d0dd08adb6799134260bfbbe43098285d4be729b148f270ec27486fc171d5649", + "size": 591943, + "subdir": "linux-64", + "timestamp": 1611674069017, + "version": "0.2.9" + }, + "distlib-0.2.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "acf766dbf1593f0cb0f95e682da908ed", + "name": "distlib", + "sha256": "9ead1df55c69317609bac3ec9c33f65fe6dc91c7991e9cbdee9b1d8d5f447ede", + "size": 536921, + "subdir": "linux-64", + "timestamp": 1569508525250, + "version": "0.2.9" + }, + "distlib-0.2.9-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "69827a4f44ea211976fc1d7071900aff", + "name": "distlib", + "sha256": "70c740170c51c731be62797ef805eaa52588f567a602e69c50a30f86aa6f2532", + "size": 620981, + "subdir": "linux-64", + "timestamp": 1611674423203, + "version": "0.2.9" + }, + "distlib-0.2.9-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "1088cb7d64c0e322a9596175ad7f2dad", + "name": "distlib", + "sha256": "832e11293139be4145b9a7e846843d529469b091f6ac5e432e9b67700942d117", + "size": 381939, + "subdir": "linux-64", + "timestamp": 1572357197603, + "version": "0.2.9" + }, + "distlib-0.2.9-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "bdb3934a5f18d201fdc89017485dea2a", + "name": "distlib", + "sha256": "a2871de1308b40cd0a43550608fa1ee6c8d663685d48a475660b4dd2dca7337e", + "size": 577940, + "subdir": "linux-64", + "timestamp": 1611674437463, + "version": "0.2.9" + }, + "distlib-0.2.9-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "dfd06bf8aa8568f044c4185c5eaff8c6", + "name": "distlib", + "sha256": "e04e96c16721ca758923a87ef7d7196ed46cb1c510034c6f8d29828ac1ebf5e7", + "size": 383379, + "subdir": "linux-64", + "timestamp": 1607007495131, + "version": "0.2.9" + }, + "distlib-0.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "982374a1387cc8d798be7ad1fabca872", + "name": "distlib", + "sha256": "e0e2163193c441c7b6c2a1ae5b679cfdb5d970549f850c071443c8450c0707c9", + "size": 559729, + "subdir": "linux-64", + "timestamp": 1600715973822, + "version": "0.3.1" + }, + "distlib-0.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "bfeaca043019f7d7f6c182e69330fc94", + "name": "distlib", + "sha256": "2ad1cdd4011cbce9db52fa04cfe70779a43a0c658ab4c31a916ce121851e43b1", + "size": 565446, + "subdir": "linux-64", + "timestamp": 1600715938708, + "version": "0.3.1" + }, + "distlib-0.3.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "d20bd0c1384ca6778ea0e158d6ed561e", + "name": "distlib", + "sha256": "fdfe85968fb6a3d641333018dac3564af7fce3dfef753b77e19e2e2d35c928da", + "size": 578226, + "subdir": "linux-64", + "timestamp": 1600715984847, + "version": "0.3.1" + }, + "distlib-0.3.6-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "a54abc50913966a8e19732c0a6d2e7a1", + "name": "distlib", + "sha256": "76cfc8fdee52d09e79861ccfa56c9f08233936374b18cd82ff76af8aad9ba28b", + "size": 456909, + "subdir": "linux-64", + "timestamp": 1673477588738, + "version": "0.3.6" + }, + "distlib-0.3.6-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "ce530482926999f1e3cdb197b0a7c4b7", + "name": "distlib", + "sha256": "79e68eb3e1f932cb640b79e926a5d54d2db6b97783dea1cc5cddeaa72b586f15", + "size": 494630, + "subdir": "linux-64", + "timestamp": 1678983694630, + "version": "0.3.6" + }, + "distlib-0.3.6-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "6434ca9e57e0f5ccb9774540716bb858", + "name": "distlib", + "sha256": "b5454027b9acdd17ad2ec062c8df3d31809569dfa1c66ba2ba5c1cbf90154d28", + "size": 449903, + "subdir": "linux-64", + "timestamp": 1673477615672, + "version": "0.3.6" + }, + "distlib-0.3.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "ee051ba8d572515b80db75d7d56fdeba", + "name": "distlib", + "sha256": "9583a1477c4453cbc2225048231db85c917b44ea68f4548ae2f8db6ad5925173", + "size": 451215, + "subdir": "linux-64", + "timestamp": 1673477641906, + "version": "0.3.6" + }, + "distlib-0.3.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "ee90407e6f11df4f722787943e98a569", + "name": "distlib", + "sha256": "d173780695cfa578548d2c46f3ef8d8708ed94cc23a0a6fa7b926cffe2b57d99", + "size": 451245, + "subdir": "linux-64", + "timestamp": 1673477561804, + "version": "0.3.6" + }, + "distributed-1.18.3-py27h5e7c565_0.tar.bz2": { + "build": "py27h5e7c565_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.15.2", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "91a2b1cc68074d39651af6ca0b2747c5", + "name": "distributed", + "sha256": "56554e674e2798013bc431bb21468157537785e6f06b3e37a445d85852f747a3", + "size": 654932, + "subdir": "linux-64", + "timestamp": 1505733266067, + "version": "1.18.3" + }, + "distributed-1.18.3-py35h076cbad_0.tar.bz2": { + "build": "py35h076cbad_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.15.2", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "871e11c2fd04c8b05335c5bbe6250c0f", + "name": "distributed", + "sha256": "2bc8531eb2a93eb5c6837712ffb30c78e7db1ae3c06c74bce6d4abe5c07a7a9e", + "size": 674851, + "subdir": "linux-64", + "timestamp": 1505733290512, + "version": "1.18.3" + }, + "distributed-1.18.3-py36h73cd4ae_0.tar.bz2": { + "build": "py36h73cd4ae_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.15.2", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fb0e5b4b63f11b253e1fc5ab40fcae44", + "name": "distributed", + "sha256": "bd126cf3835f7ae6427c8ada881c21ca01fee971cbd64f499d9b34c1f8cc618e", + "size": 661776, + "subdir": "linux-64", + "timestamp": 1505733315334, + "version": "1.18.3" + }, + "distributed-1.19.1-py27h38c4a05_0.tar.bz2": { + "build": "py27h38c4a05_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.15.2", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c502516ad58ca4462f5fb953651bbbae", + "name": "distributed", + "sha256": "2faed20307238676c57f3a1a34f6208d968905b2f7ec546ade630f4518c3179b", + "size": 679122, + "subdir": "linux-64", + "timestamp": 1506624063608, + "version": "1.19.1" + }, + "distributed-1.19.1-py35h399b246_0.tar.bz2": { + "build": "py35h399b246_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.15.2", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2927f95a07d1417ff34ce6952e719394", + "name": "distributed", + "sha256": "7a4fadcd0debc232ce6c72a5a5dc473ebe8825fadb62b033878e3d9690a5e78c", + "size": 695759, + "subdir": "linux-64", + "timestamp": 1506624102722, + "version": "1.19.1" + }, + "distributed-1.19.1-py36h25f3894_0.tar.bz2": { + "build": "py36h25f3894_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.15.2", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b2208614455fca5b938ee7bb3fdc4dad", + "name": "distributed", + "sha256": "a8ab0b5f80c5f5d409fbbe8c15cd775c956aa7481f8b7df10636dc4f9aba79d0", + "size": 688272, + "subdir": "linux-64", + "timestamp": 1506624079800, + "version": "1.19.1" + }, + "distributed-1.20.0-py27hfe4ef5f_0.tar.bz2": { + "build": "py27hfe4ef5f_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.16.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2cc337248895feee0155ba55ce51b791", + "name": "distributed", + "sha256": "1a0f71e17f96095dcb9ffaec58598fe67095316b555f94b22c4717bc871d1cb6", + "size": 690980, + "subdir": "linux-64", + "timestamp": 1511195990161, + "version": "1.20.0" + }, + "distributed-1.20.0-py35h5ba6bfe_0.tar.bz2": { + "build": "py35h5ba6bfe_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.16.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "60e4a791ea69bff4913bd677dc81ab22", + "name": "distributed", + "sha256": "7b01b43addc8a972d9274ede3cb3118dc5489968e1582495655e9047a682f895", + "size": 707729, + "subdir": "linux-64", + "timestamp": 1511196007800, + "version": "1.20.0" + }, + "distributed-1.20.0-py36h1c9f478_0.tar.bz2": { + "build": "py36h1c9f478_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.16.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "526c6c8918f300d9fcf11f3b7c43d416", + "name": "distributed", + "sha256": "72482c31a7d76fc8d0aadcfc702e2467effe2948ba183cde852bf4cfb8f6bb5a", + "size": 697016, + "subdir": "linux-64", + "timestamp": 1511196026645, + "version": "1.20.0" + }, + "distributed-1.20.1-py27h41405a2_0.tar.bz2": { + "build": "py27h41405a2_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.16.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d5a9e66b7cafbb86b0894f7100edc430", + "name": "distributed", + "sha256": "45ecec3c32e5d0c2eea78cc7279d603ce44542a7110c2e2aac1df405c13761c3", + "size": 703925, + "subdir": "linux-64", + "timestamp": 1511885260441, + "version": "1.20.1" + }, + "distributed-1.20.1-py35h8354bac_0.tar.bz2": { + "build": "py35h8354bac_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.16.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e783667a4a6dd35b4bbdaf39c3338058", + "name": "distributed", + "sha256": "e4676d0c26da5d29f1d844f4d51ff0be9ea789355f31de654a0e2a240777781a", + "size": 723058, + "subdir": "linux-64", + "timestamp": 1511885282869, + "version": "1.20.1" + }, + "distributed-1.20.1-py36h5b7e16d_0.tar.bz2": { + "build": "py36h5b7e16d_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.16.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a923595ec442deeda6f683bc3750c3f6", + "name": "distributed", + "sha256": "7075b6fd66d23ecf22b36d5fc1ef8ebbdf180b45c5af75e88e848e835b19f265", + "size": 711548, + "subdir": "linux-64", + "timestamp": 1511885292006, + "version": "1.20.1" + }, + "distributed-1.20.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.16.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2b487425aa6a64aea7673bbcfa0ade79", + "name": "distributed", + "sha256": "d453c21a0c0a02a71cf93972642cd48c877d29baeccf5634544521381c8ea277", + "size": 705267, + "subdir": "linux-64", + "timestamp": 1512751311780, + "version": "1.20.2" + }, + "distributed-1.20.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.16.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "394d7eb32d5eaf0413c8391ac10a8d78", + "name": "distributed", + "sha256": "38ea574daa9102213f0bcd7f5580683ab00918dabe803e2521fb571941fe9074", + "size": 723583, + "subdir": "linux-64", + "timestamp": 1512751322289, + "version": "1.20.2" + }, + "distributed-1.20.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.16.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c3f2798617054843bbb4b2d8354903b9", + "name": "distributed", + "sha256": "b566b8e3c808ef3f0bc893a8e0b1719e6ed15db443e826e45944c96a9ea80fde", + "size": 710340, + "subdir": "linux-64", + "timestamp": 1512751325256, + "version": "1.20.2" + }, + "distributed-1.21.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.17.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9b6a6df3135ac62032e3781deca8a324", + "name": "distributed", + "sha256": "614fdbab1e8ec3a60dfde2799b2494506f7f96ef7ddac90714e6dd623762c22f", + "size": 727931, + "subdir": "linux-64", + "timestamp": 1518524447911, + "version": "1.21.0" + }, + "distributed-1.21.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8e8ad2c3cddd45e4c8d3a9d366f943b9", + "name": "distributed", + "sha256": "7ed78f1a3fc6c9d5ac24f31a5be2ff6430ce336f96f1db3b796da674736ec7be", + "size": 749967, + "subdir": "linux-64", + "timestamp": 1518524500983, + "version": "1.21.0" + }, + "distributed-1.21.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dc11b17536a979005347431ee22252f8", + "name": "distributed", + "sha256": "c731b03b89a21cf0a7585ddf1584f4927fbeb8e7bf9a200090ef7d1e4921e853", + "size": 745412, + "subdir": "linux-64", + "timestamp": 1518524484876, + "version": "1.21.0" + }, + "distributed-1.21.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.17.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "871804f10c0114b2e86edc8224e86fbc", + "name": "distributed", + "sha256": "a464b67bcbd1ce619ec48cdd7752920b2315997e952efa3d724c1b76a4be4baf", + "size": 735648, + "subdir": "linux-64", + "timestamp": 1519397801363, + "version": "1.21.1" + }, + "distributed-1.21.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "26aa75a3573e45234248e5ec8933b599", + "name": "distributed", + "sha256": "1adda0d0f037acc5b76696391568c2732816dcc0282ab24f666b63d0e71b14af", + "size": 760892, + "subdir": "linux-64", + "timestamp": 1519397840655, + "version": "1.21.1" + }, + "distributed-1.21.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "09565f9ff3fe02d0746cadfd7063de99", + "name": "distributed", + "sha256": "64de0ec8521f3ec8ed6a68bfdff148f8166497236db82712e08d2e899f31cacb", + "size": 760297, + "subdir": "linux-64", + "timestamp": 1519397767584, + "version": "1.21.1" + }, + "distributed-1.21.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.17.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "44de08ee23b1d5089f011c0d1c443382", + "name": "distributed", + "sha256": "7b57fbac97ca53f936864042a8b506e8d6ed2652df0d70e177b643b3c67772b5", + "size": 740629, + "subdir": "linux-64", + "timestamp": 1520367506444, + "version": "1.21.2" + }, + "distributed-1.21.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "36af63c82e6e618ece17975675ff8411", + "name": "distributed", + "sha256": "9586d7cc983aebf8fb9eb6868af224aaf871fbf0131c0071801d79a95d51d6d0", + "size": 769574, + "subdir": "linux-64", + "timestamp": 1520367521794, + "version": "1.21.2" + }, + "distributed-1.21.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b42e289daf1056225d352de335ca0af9", + "name": "distributed", + "sha256": "16fd77ab554fb19cf58f006f2481956bae5abce079c878516ba0a0796eec788a", + "size": 768883, + "subdir": "linux-64", + "timestamp": 1520367547034, + "version": "1.21.2" + }, + "distributed-1.21.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "06404192f384c4c8cb313cd5c1971fd8", + "name": "distributed", + "sha256": "3c8d59092689ca636a13b51779128f3c2090db09be3af5ca9e921e0e0e081770", + "size": 745156, + "subdir": "linux-64", + "timestamp": 1520972212793, + "version": "1.21.3" + }, + "distributed-1.21.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ffc23d924fc02773be87e66a2f329979", + "name": "distributed", + "sha256": "df3fd327cdada5893c2b0f92f5e6ae7fab74f8e1d43dd53f9bff113971e9a5d8", + "size": 775671, + "subdir": "linux-64", + "timestamp": 1520972218689, + "version": "1.21.3" + }, + "distributed-1.21.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "74566963b77b4d528a5c1eb9a2ab04a9", + "name": "distributed", + "sha256": "32426f7c4fec242c10207d148fedfe486e8d7c08b1a5b420eb6f4a148a876353", + "size": 775018, + "subdir": "linux-64", + "timestamp": 1520972239105, + "version": "1.21.3" + }, + "distributed-1.21.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "213a77f7a05031e514881b004d6ed1e1", + "name": "distributed", + "sha256": "f070325fc4a15b442b6832f67c78c240ff016ad7001cd201f66caef5223c156b", + "size": 746661, + "subdir": "linux-64", + "timestamp": 1521650233567, + "version": "1.21.4" + }, + "distributed-1.21.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "be588ecf71bebc7877fb42cfc95714d0", + "name": "distributed", + "sha256": "5eb8c0955a1249a581e03bf2392b37710c2fd9e45070be58c7edbb5d10923e84", + "size": 777466, + "subdir": "linux-64", + "timestamp": 1521650291364, + "version": "1.21.4" + }, + "distributed-1.21.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e6d8ba4faf267be8f5579c283871c7f6", + "name": "distributed", + "sha256": "7cb0b143f404365f07b296d4957c3d7a4bc33fc92ef7f8606b02bb868487a552", + "size": 776912, + "subdir": "linux-64", + "timestamp": 1521650243033, + "version": "1.21.4" + }, + "distributed-1.21.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a99af29e37c4ea591151cc50e1b68698", + "name": "distributed", + "sha256": "a2db2a231af77c2b995913e116d05825fd833efafca73651f06e608ab996ca4f", + "size": 749569, + "subdir": "linux-64", + "timestamp": 1522683658825, + "version": "1.21.5" + }, + "distributed-1.21.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "90c84842e3f4edcc1495bcab673f1363", + "name": "distributed", + "sha256": "763af006abe2055325bf19f00bd4db270d0ac59dfdf22dfe352b5d12e42b1ad6", + "size": 780387, + "subdir": "linux-64", + "timestamp": 1522683754951, + "version": "1.21.5" + }, + "distributed-1.21.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "350aa0a162b7421a8f86149c696b5fda", + "name": "distributed", + "sha256": "3ce4e22ce2e9b0f4696b751b0bd2fcf5ef473b1924cc27c2e102da81f911a7f8", + "size": 779889, + "subdir": "linux-64", + "timestamp": 1522683682727, + "version": "1.21.5" + }, + "distributed-1.21.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c760bd2afcc9f8f448376803f077526b", + "name": "distributed", + "sha256": "b5f0db12f956f5edb4ffc821cd6cf6725401e83b1942b5e4a72e1198db78342e", + "size": 751994, + "subdir": "linux-64", + "timestamp": 1523051695940, + "version": "1.21.6" + }, + "distributed-1.21.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ae1a342497d855ffec4c3cafb5c92640", + "name": "distributed", + "sha256": "e2f7087eb19b5fe035633e64f989473af48e71e457ce02190871aca829f7a8dc", + "size": 781609, + "subdir": "linux-64", + "timestamp": 1523051789469, + "version": "1.21.6" + }, + "distributed-1.21.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "16f23410a51dff572131d0ee210b2c42", + "name": "distributed", + "sha256": "eb12a6473fd3112d68339829a3c70f3dd0aebe285479000753a19aee9691fc5e", + "size": 780310, + "subdir": "linux-64", + "timestamp": 1523051788432, + "version": "1.21.6" + }, + "distributed-1.21.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "832141e719824c72915e863a436b1fa3", + "name": "distributed", + "sha256": "1070d84fdddb1f6417bd497b18857022deffeb9204f12f138e9293d10eb810f0", + "size": 765594, + "subdir": "linux-64", + "timestamp": 1525470945554, + "version": "1.21.8" + }, + "distributed-1.21.8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3c8bf1d82548bd309e0bc1dfcebc6f5c", + "name": "distributed", + "sha256": "f5cebf0350415f666be868789905a1b50fd0445cfcfcc0dde80c7249c12eef76", + "size": 794345, + "subdir": "linux-64", + "timestamp": 1525470962842, + "version": "1.21.8" + }, + "distributed-1.21.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "27c9a9cbcea39b96cfefc0233f071e49", + "name": "distributed", + "sha256": "f73e169ccb7739dc9e22cd8125635c003bbb2eca408225f42bb265532a62d997", + "size": 795474, + "subdir": "linux-64", + "timestamp": 1525470872510, + "version": "1.21.8" + }, + "distributed-1.22.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1e73b7014cffea992216e15bf714fb81", + "name": "distributed", + "sha256": "36764f5318dc34485638d6ec4ec92edb6954b75b3035e59ec7bd262ed8426542", + "size": 786423, + "subdir": "linux-64", + "timestamp": 1529077046370, + "version": "1.22.0" + }, + "distributed-1.22.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9a9894ac85a69d03d4732182b54f85c4", + "name": "distributed", + "sha256": "7ecd12bb7b758e84d473fef5e37451d91694cd3e0edde863e79789b5acbe59e5", + "size": 807913, + "subdir": "linux-64", + "timestamp": 1529077060991, + "version": "1.22.0" + }, + "distributed-1.22.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "59411206f95370a2cd0d83e9595eeada", + "name": "distributed", + "sha256": "6db23b04e4b7cab0b8f898c857e3c3975ba4285284a0c13b832e0af8410840c0", + "size": 806937, + "subdir": "linux-64", + "timestamp": 1529076976736, + "version": "1.22.0" + }, + "distributed-1.22.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "661bbbbc734f285db26d1c54507be9ce", + "name": "distributed", + "sha256": "a73d938ad55dd1f6b2c5639f483be7709ac50b8df04ac9efd6efa12fa06d2aa1", + "size": 810573, + "subdir": "linux-64", + "timestamp": 1530741704736, + "version": "1.22.0" + }, + "distributed-1.22.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "23ab751ecdf81744d97eed37b1633264", + "name": "distributed", + "sha256": "59628b91207201075b1e4e51ffb995621ebb875635e8af817339723a13fedb74", + "size": 786943, + "subdir": "linux-64", + "timestamp": 1533655834125, + "version": "1.22.1" + }, + "distributed-1.22.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b9b37226450a5e6f998b9468c3a30676", + "name": "distributed", + "sha256": "6bcf036fb383c3348db6c21a1af38a9d8fb8897c4c318abe712f31d099dad820", + "size": 812207, + "subdir": "linux-64", + "timestamp": 1533655865113, + "version": "1.22.1" + }, + "distributed-1.22.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dcf7a3126142cbfff7fcf0e5436833fc", + "name": "distributed", + "sha256": "0ff56460ff6302fa8907e37a90f03fa586ad1376264d6651c6226c49399e70e0", + "size": 809829, + "subdir": "linux-64", + "timestamp": 1533655762096, + "version": "1.22.1" + }, + "distributed-1.22.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1361e195ed4bdcfbfe1027667e7918c7", + "name": "distributed", + "sha256": "fb4204d4e23819f3d9cc365d3c3b1cab00587b86f74bc93ab5a0150b5d38374b", + "size": 809595, + "subdir": "linux-64", + "timestamp": 1533655860891, + "version": "1.22.1" + }, + "distributed-1.23.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c8f6aff0f2a55868554ae87925a86433", + "name": "distributed", + "sha256": "6205492aa5425e3bdffe31a87fed03ab24bf431b918087eae0c9c09890460917", + "size": 826659, + "subdir": "linux-64", + "timestamp": 1535658991718, + "version": "1.23.0" + }, + "distributed-1.23.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "28934049b98af1159fa1152133924be3", + "name": "distributed", + "sha256": "0e6df12bcf5f14b21f7e164f8b5d4d97243d498e1d4a4df23a417d0450a6f04b", + "size": 844904, + "subdir": "linux-64", + "timestamp": 1535659061094, + "version": "1.23.0" + }, + "distributed-1.23.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5abce4a0538b6e0807f4e3519ca14586", + "name": "distributed", + "sha256": "3e64e510a439511e053dfc96953f65dcee201561a0a9cb2e45a1ec1c943ba550", + "size": 837113, + "subdir": "linux-64", + "timestamp": 1535659007381, + "version": "1.23.0" + }, + "distributed-1.23.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a654a075b3870f5025fac343203353f8", + "name": "distributed", + "sha256": "a97cc0e1fa72fe82ee91600ee364e75b328a7d05c699f922315bdabbe459cc1d", + "size": 836762, + "subdir": "linux-64", + "timestamp": 1535659027958, + "version": "1.23.0" + }, + "distributed-1.23.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "99fb42ab4441c3ef2a6ad41c18011445", + "name": "distributed", + "sha256": "0b4edf35d1c5e081e4dd06124db79ad5c285b813aa28cdb344adae67a42b8ae0", + "size": 838728, + "subdir": "linux-64", + "timestamp": 1536248112246, + "version": "1.23.1" + }, + "distributed-1.23.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a580a2029a0ea5e8293b7affe851b3b6", + "name": "distributed", + "sha256": "52837889ba0ff2c22d90fbe32556914dc2f8b44dd446154825ae1f89b51483f8", + "size": 856160, + "subdir": "linux-64", + "timestamp": 1536248309025, + "version": "1.23.1" + }, + "distributed-1.23.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "65f0f6f5034cc103b01f610a142bf8ec", + "name": "distributed", + "sha256": "33d9234318f65c22e0394366ed070988d2936a95fc4307303fd15ab9fd11d29c", + "size": 848474, + "subdir": "linux-64", + "timestamp": 1536248080138, + "version": "1.23.1" + }, + "distributed-1.23.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7002723906f3b2b15af56a7a785e1eda", + "name": "distributed", + "sha256": "cb07b938065f25aa7fe3e72b3196f88686aaf6960f0929ed6efffb7ade83f20d", + "size": 848056, + "subdir": "linux-64", + "timestamp": 1536248276244, + "version": "1.23.1" + }, + "distributed-1.23.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4ff012eec16af40e8de135fc21d5e9a8", + "name": "distributed", + "sha256": "786049a4222ee727d11165aac5e3d591bc2a8da688fd33cd0181223fff905896", + "size": 842378, + "subdir": "linux-64", + "timestamp": 1538069147402, + "version": "1.23.2" + }, + "distributed-1.23.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "550c8c5104794ce370c359d6a8792540", + "name": "distributed", + "sha256": "ea43637089c3343b061fa5beace04b07ff98e8b43c9ab9581fe8d4dabcbd4227", + "size": 857502, + "subdir": "linux-64", + "timestamp": 1538069221053, + "version": "1.23.2" + }, + "distributed-1.23.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5885bff6c85fadb99811b21fd439aede", + "name": "distributed", + "sha256": "35b762d2c01b8b1924d09a084bb354ef7f5d0516ee79b1736621af1a26ff1d98", + "size": 851363, + "subdir": "linux-64", + "timestamp": 1538069173967, + "version": "1.23.2" + }, + "distributed-1.23.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7cfd7afd1ca6f5bfe6575692fb89f2ad", + "name": "distributed", + "sha256": "b1d001fdead914258b045f761113427e002ae2042c6231fbedadb4311c55269d", + "size": 849220, + "subdir": "linux-64", + "timestamp": 1538069149226, + "version": "1.23.2" + }, + "distributed-1.23.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cabd41080e2a6f374997d901738ad5ca", + "name": "distributed", + "sha256": "6527ae9a5fdb59f8d85e87cdac3726a088e944c37aff476d6f2343937896b7a9", + "size": 830135, + "subdir": "linux-64", + "timestamp": 1539017046402, + "version": "1.23.3" + }, + "distributed-1.23.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9648c36341a3d833fee22cb8b1a6f384", + "name": "distributed", + "sha256": "df5535d3a52f1c403ce4b6fe2fca8d60a6fac92555e1e9795ace7a362e63b49f", + "size": 839617, + "subdir": "linux-64", + "timestamp": 1539017103206, + "version": "1.23.3" + }, + "distributed-1.23.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6ae096093a50cfa395e3c6688cfca2a4", + "name": "distributed", + "sha256": "c7e0681c497b591eb900bf52a36cff9144930a8015c25cd670ac60b4ec3ff587", + "size": 839092, + "subdir": "linux-64", + "timestamp": 1539017039280, + "version": "1.23.3" + }, + "distributed-1.24.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "334ea89623eb7071349907a5c00e789c", + "name": "distributed", + "sha256": "9cf336d4921c06c5c2cfe2b4915199ee8d83af24c0b2cf20c295503f530cf13d", + "size": 820912, + "subdir": "linux-64", + "timestamp": 1540830739969, + "version": "1.24.0" + }, + "distributed-1.24.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e5e8aca381a863990b6f96fb476d9199", + "name": "distributed", + "sha256": "c21f38958c94d4ca9e3ff00a143499be3cdc9c7ab7499892988085fd2af98913", + "size": 833730, + "subdir": "linux-64", + "timestamp": 1540830801685, + "version": "1.24.0" + }, + "distributed-1.24.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5060156afc92215401c5578dc8e7931b", + "name": "distributed", + "sha256": "0af2e87b8d82b3f226dce9be9043c3a10b0448fb251006ac478ef65780ede2ac", + "size": 832387, + "subdir": "linux-64", + "timestamp": 1540830810745, + "version": "1.24.0" + }, + "distributed-1.24.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e380d176dd715b7bbe4b8e434b069a9c", + "name": "distributed", + "sha256": "c321c3e48f60536000e094309f7c55baf514dd63b4ceef7ee48ee27cd8ca3e7b", + "size": 822889, + "subdir": "linux-64", + "timestamp": 1542077555327, + "version": "1.24.1" + }, + "distributed-1.24.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2baeafcc01da5b06367ee6c786015a65", + "name": "distributed", + "sha256": "65f0573335404effd69cda683fef1e13b0658ea94cfe5e0db4f494300bdf23c2", + "size": 827491, + "subdir": "linux-64", + "timestamp": 1542077665894, + "version": "1.24.1" + }, + "distributed-1.24.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ee660b42d521d0382b38f6280ea5da24", + "name": "distributed", + "sha256": "73575b2192530c28ebfca54ea69d4f5befd0f7c05c6cd1ab60e48ecee7233a06", + "size": 828007, + "subdir": "linux-64", + "timestamp": 1542077601180, + "version": "1.24.1" + }, + "distributed-1.24.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6cb14de3875ec19da605cb1148ad1b4d", + "name": "distributed", + "sha256": "d6b8f82d04e8f9b6989639f4f7a75d92f62b1c89598f64a6863f5ceb41bac701", + "size": 822116, + "subdir": "linux-64", + "timestamp": 1542386532035, + "version": "1.24.2" + }, + "distributed-1.24.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "92d49ec177f9d41db0fbf265e1e60d84", + "name": "distributed", + "sha256": "7a5a4fb09a51c4c526c09e2c284110897aa180c50e7a00c9a9d3ee98c81ea268", + "size": 832815, + "subdir": "linux-64", + "timestamp": 1542386567339, + "version": "1.24.2" + }, + "distributed-1.24.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d75ad4ee49324d73ef4713926ed9e760", + "name": "distributed", + "sha256": "762d89ef48f0c98c7328e616aff5684d2998526864756108b01b534c71a7549e", + "size": 832185, + "subdir": "linux-64", + "timestamp": 1542386525823, + "version": "1.24.2" + }, + "distributed-1.25.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f8762e106be180d896e682f665292553", + "name": "distributed", + "sha256": "b8f967644b9326eb4a2da721752b34d667501e947b3bb750d3dd9f9e8004521c", + "size": 824355, + "subdir": "linux-64", + "timestamp": 1543504087292, + "version": "1.25.0" + }, + "distributed-1.25.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bce72b2b7cb5dab430bdffc69d8c131b", + "name": "distributed", + "sha256": "f40a99306918b31e83bbd8c7d15e36b865bddee0cc846c5c990c843dffb671a7", + "size": 836891, + "subdir": "linux-64", + "timestamp": 1543504155168, + "version": "1.25.0" + }, + "distributed-1.25.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "940b9c2cc7200bed11e8cef1d3373139", + "name": "distributed", + "sha256": "dbf58a1474b3ddb0e16031f892e29707657bbef4312e45039a1b9f83ca26c1e0", + "size": 835586, + "subdir": "linux-64", + "timestamp": 1543504083553, + "version": "1.25.0" + }, + "distributed-1.25.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "955df044ad5f34d3154e81fa2068b968", + "name": "distributed", + "sha256": "30bcdd8a380ac2af95c9ffecb105de1b3b173dc27964b41ddcb761f980ba0003", + "size": 827906, + "subdir": "linux-64", + "timestamp": 1545074805453, + "version": "1.25.1" + }, + "distributed-1.25.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c32b392b3b4d1b6334343ed041a5cfcd", + "name": "distributed", + "sha256": "c040151ff7f63705de2bf1d1da34d60bc8cc43f85dd3f3f97bd8ecd15dd7fcf5", + "size": 841695, + "subdir": "linux-64", + "timestamp": 1545074835603, + "version": "1.25.1" + }, + "distributed-1.25.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "174803827fb38a52da31dfeee544dd62", + "name": "distributed", + "sha256": "8dcf2857279f5018e1a023df7dee30b7446d6d2be1fe95742ba652f4c2ab8989", + "size": 838476, + "subdir": "linux-64", + "timestamp": 1545074827283, + "version": "1.25.1" + }, + "distributed-1.25.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7401687a370b8f6876a92781ffe91b3d", + "name": "distributed", + "sha256": "1b7747a6ae61526bae26b7261af3e7d9658023d0a8b03ed2330b3dde4a746644", + "size": 845924, + "subdir": "linux-64", + "timestamp": 1547226528510, + "version": "1.25.2" + }, + "distributed-1.25.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9befb88950294cdfb8a55f69e9784d60", + "name": "distributed", + "sha256": "468546cf3e588c2f53c70da4dbed618e92a093bd9224e2eda210fa41652bdb10", + "size": 849094, + "subdir": "linux-64", + "timestamp": 1547226547340, + "version": "1.25.2" + }, + "distributed-1.25.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "74806ad2a0aff7c15759f7ca1b852bfe", + "name": "distributed", + "sha256": "a078af1182244c868ac89f5784e2c10245674d970e417314c873ad0f79c62e85", + "size": 845558, + "subdir": "linux-64", + "timestamp": 1547226521695, + "version": "1.25.2" + }, + "distributed-1.25.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "732c275528acd55d6b8e5e2d2472133e", + "name": "distributed", + "sha256": "7e6382faa967fde039f08e53652afe816db1f876564c40f13333404d43f96ba9", + "size": 834323, + "subdir": "linux-64", + "timestamp": 1549338021050, + "version": "1.25.3" + }, + "distributed-1.25.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "94b426de6533f63f226585ebbdc6d07f", + "name": "distributed", + "sha256": "3a97def3b8391179bdb64e14d3b4ad1501cbd9aebcd9e82d21b4d186ac36a1ad", + "size": 844532, + "subdir": "linux-64", + "timestamp": 1549327059101, + "version": "1.25.3" + }, + "distributed-1.25.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2d2235429232a26b31ecc479b2b17461", + "name": "distributed", + "sha256": "ccca7c4a1f4fa916ac1eff77d0884db0b5e3e98b68a0f9e804893041ee63aa3c", + "size": 843912, + "subdir": "linux-64", + "timestamp": 1549327009240, + "version": "1.25.3" + }, + "distributed-1.26.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ad8984bfe68d047a3eca04ad01f914e7", + "name": "distributed", + "sha256": "cdd3d1e69f3dcb2cc6a7f860b4a2c0022416c90b29dab99d7d653cb3ab51ca08", + "size": 852698, + "subdir": "linux-64", + "timestamp": 1551127373319, + "version": "1.26.0" + }, + "distributed-1.26.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6074a269d80fd8ac8b4f071c65e17c92", + "name": "distributed", + "sha256": "b3371eb0a2bf26c62d1c0acfaefe55388a8e48ea59237d5b08ecdd95edbd9554", + "size": 844731, + "subdir": "linux-64", + "timestamp": 1551971088530, + "version": "1.26.0" + }, + "distributed-1.26.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f0edec1a4244c87f18ef214c3cea0e5a", + "name": "distributed", + "sha256": "e7049f592d6983dbc5ddc3c9d1ce6c6fec11b9c4ec6a4a8a87c9acd7bc5b10b1", + "size": 852184, + "subdir": "linux-64", + "timestamp": 1551127387176, + "version": "1.26.0" + }, + "distributed-1.26.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7c42edd20b15afce9aafacb146c205f9", + "name": "distributed", + "sha256": "f76ea4889c5337925fa7898412d0c2edacb0e1548e174a0e63162fb7aa7ebdac", + "size": 857325, + "subdir": "linux-64", + "timestamp": 1551971119429, + "version": "1.26.0" + }, + "distributed-1.26.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8f0488466b0e63027af3203b28630d9a", + "name": "distributed", + "sha256": "d80c02cce0340f8b0e011cfa7926362ed28f23c89683aedb3e8dc88d723260dc", + "size": 855059, + "subdir": "linux-64", + "timestamp": 1551127330219, + "version": "1.26.0" + }, + "distributed-1.26.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6bff92acdba2a0ceeeaa78063949b036", + "name": "distributed", + "sha256": "6e834aecf1731d330ac089449a4301c4852d82b79547ff92c8d8c18649c99ebc", + "size": 850656, + "subdir": "linux-64", + "timestamp": 1551971074571, + "version": "1.26.0" + }, + "distributed-1.26.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a3996cdd5ca0e6ab087a83495426a913", + "name": "distributed", + "sha256": "2aeee3b853be510552d2f1faa71e1d76c3c70874c11306653fec43245d9ab599", + "size": 854522, + "subdir": "linux-64", + "timestamp": 1554925546144, + "version": "1.26.1" + }, + "distributed-1.26.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dc8c7330709c3c15c430b39801e54f4d", + "name": "distributed", + "sha256": "3ea85d7524197ea938f57f470d35eada578fd579a27562e764b66192848bf7da", + "size": 853905, + "subdir": "linux-64", + "timestamp": 1554925573350, + "version": "1.26.1" + }, + "distributed-1.26.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "56c783d704d63274692149ba4e03ef47", + "name": "distributed", + "sha256": "baf5b8a74e7b51b8ff4db7a8d7933a9154bd327bd180be15a7bed51badfa27e0", + "size": 860706, + "subdir": "linux-64", + "timestamp": 1554925595852, + "version": "1.26.1" + }, + "distributed-1.27.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f903d79ba4e279c139127e7f8fc8fc49", + "name": "distributed", + "sha256": "c172719a2700d26b77fd22bdb7a96a9e3990f77643b015b23576c797d766f96b", + "size": 859717, + "subdir": "linux-64", + "timestamp": 1555424758686, + "version": "1.27.0" + }, + "distributed-1.27.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "881058313ddf559c1c9e9b95d3d1fd81", + "name": "distributed", + "sha256": "43aab0873521016494b89daa6a70596b4a4bbc3a7caf304a2c03a1467e335ed4", + "size": 862969, + "subdir": "linux-64", + "timestamp": 1555424655708, + "version": "1.27.0" + }, + "distributed-1.27.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a0d48393f966b00d67f464d4c1d45f16", + "name": "distributed", + "sha256": "a987cbe51e1bca4cd1da44cd16b81272abb75f7709f078f38d7d0657a643cc2b", + "size": 862471, + "subdir": "linux-64", + "timestamp": 1555424749461, + "version": "1.27.0" + }, + "distributed-1.27.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "df90458a9b61721776e778dd30fd9db7", + "name": "distributed", + "sha256": "0760273d00b32cbd9c0df57e791a7f53713f3ea4ddac076d0b7aae2c452d072f", + "size": 868203, + "subdir": "linux-64", + "timestamp": 1556558475053, + "version": "1.27.1" + }, + "distributed-1.27.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b17b4956d17dc3a91ded96f7bb62cf00", + "name": "distributed", + "sha256": "526ff8f02087b1419fe5d1ca77c0addd91bfc1dabc96c40820311991b1588290", + "size": 869618, + "subdir": "linux-64", + "timestamp": 1556558517227, + "version": "1.27.1" + }, + "distributed-1.27.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "510bb9c9d61c4cf7c6e3e748a0e486f2", + "name": "distributed", + "sha256": "3ddf47e14b8fb6c6ea192ce210c3db683502665387a1fd43f26032894739d093", + "size": 873911, + "subdir": "linux-64", + "timestamp": 1556558474914, + "version": "1.27.1" + }, + "distributed-1.28.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7428c1126fae1bdcdaad1b841e241673", + "name": "distributed", + "sha256": "cdb11b612ad667d122633efc7b2d0b233cedf28a36834a8868c88a9f698aa2c5", + "size": 879209, + "subdir": "linux-64", + "timestamp": 1557501828309, + "version": "1.28.0" + }, + "distributed-1.28.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dc2687f0d5fab96fdb9e4750eed8552e", + "name": "distributed", + "sha256": "ca7b2c410f4605810209961ba99417ebed46119ba8d1def2366b715553468115", + "size": 885122, + "subdir": "linux-64", + "timestamp": 1557501819268, + "version": "1.28.0" + }, + "distributed-1.28.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f8296b874d6ff6e5ed42a2ed1ee93ae7", + "name": "distributed", + "sha256": "b60ee02b7d4242bd104c06c77b0287ce8a66ff590603476721a717d304d9dd77", + "size": 877157, + "subdir": "linux-64", + "timestamp": 1557501775651, + "version": "1.28.0" + }, + "distributed-1.28.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1ad1040e9e951c081cf64202c52e05ff", + "name": "distributed", + "sha256": "bb8edd68ccc8633c171fd3c96ad6e09024e69f0c73437ef2b5c4526199fe95b1", + "size": 872067, + "subdir": "linux-64", + "timestamp": 1557855466742, + "version": "1.28.1" + }, + "distributed-1.28.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5f17edff9a19d52328c548f8f4f879ad", + "name": "distributed", + "sha256": "8af5587e4acab3e712ac937941f84df8fb9473662c929f9872c89144e33f2690", + "size": 880924, + "subdir": "linux-64", + "timestamp": 1557855526755, + "version": "1.28.1" + }, + "distributed-1.28.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f27975e4aa604b8417178bcd9525e1aa", + "name": "distributed", + "sha256": "7b81c83e1f910eb5b1c20ae26ea82b67d40659d620e915066f07202ae1ac2598", + "size": 881782, + "subdir": "linux-64", + "timestamp": 1557855419574, + "version": "1.28.1" + }, + "distributed-2.11.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "29a58d506431eb1126fdc92b74dc6f97", + "name": "distributed", + "sha256": "934ece7f50c6b10976e1b45f9688e78d1831157ae6d2877ddfcf203e51f8f200", + "size": 1019140, + "subdir": "linux-64", + "timestamp": 1582558602274, + "version": "2.11.0" + }, + "distributed-2.11.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3805c6c3dd8252aee3dac9b7f4b55989", + "name": "distributed", + "sha256": "89db06cb74372ee912efd4fac0284df31bbc9e0a36be39515dc785ed20226d5f", + "size": 1019030, + "subdir": "linux-64", + "timestamp": 1582558364368, + "version": "2.11.0" + }, + "distributed-2.11.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.7.4", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "876f1152f8b137e28ad6ba73e43c67c2", + "name": "distributed", + "sha256": "8dc49967896609b0019f7a88c2cda63b842fda6b64615e6ca4cb05c6ec4182cd", + "size": 1025169, + "subdir": "linux-64", + "timestamp": 1582558546094, + "version": "2.11.0" + }, + "distributed-2.12.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bcd7ff62b1beef82fa071cbf6acfc28f", + "name": "distributed", + "sha256": "bb9776f86604c5447f36cd565ec67ee80573c28329899d9eb1710b4d06ae642b", + "size": 1027013, + "subdir": "linux-64", + "timestamp": 1584021686984, + "version": "2.12.0" + }, + "distributed-2.12.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b92957c4c251ff40be087e7648dac152", + "name": "distributed", + "sha256": "1da9df26acb50a688a1945e1dc18b515d9af48537ee38f84e6b5fe2af75c2cc7", + "size": 1027443, + "subdir": "linux-64", + "timestamp": 1584021685053, + "version": "2.12.0" + }, + "distributed-2.12.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.7.4", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e3f660adcdf4b173cd203bb8a0a886ff", + "name": "distributed", + "sha256": "731c3c82c13320c674e07e92815d2689f5489c008d99a615bef34142342cd0e7", + "size": 1030708, + "subdir": "linux-64", + "timestamp": 1584021773172, + "version": "2.12.0" + }, + "distributed-2.13.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "openssl !=1.1.1e", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9098cd7ff0e64fff7adee6a09560e776", + "name": "distributed", + "sha256": "f2f110636857544e1e5732ebc2839e2720c3a9551de6a9364892adf5ad325b74", + "size": 1032417, + "subdir": "linux-64", + "timestamp": 1585232624778, + "version": "2.13.0" + }, + "distributed-2.13.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "openssl !=1.1.1e", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1fc3f6309d1558954841dfb6d20aa8cd", + "name": "distributed", + "sha256": "55ce717624a07f8d7115e38d67b92ce746559ee8c8f374ba35be47a793d0b9eb", + "size": 1030252, + "subdir": "linux-64", + "timestamp": 1585232643952, + "version": "2.13.0" + }, + "distributed-2.13.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "openssl !=1.1.1e", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0560e393d7edfe1f9df67cf32c9f7766", + "name": "distributed", + "sha256": "634e6c0d9134ae88a00b6998890d7397e95ba3541def63dd7237f282a45afae6", + "size": 1036341, + "subdir": "linux-64", + "timestamp": 1585232670254, + "version": "2.13.0" + }, + "distributed-2.14.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e23368ad7a6cb7e5affa8faf7220cc7a", + "name": "distributed", + "sha256": "75a3ce45fa0ecdf5c8af8f983b32cfac082bea3c88258c76826423740fb7d29b", + "size": 1042951, + "subdir": "linux-64", + "timestamp": 1586199035531, + "version": "2.14.0" + }, + "distributed-2.14.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f3bbf65fe971310dd93bae71b5625639", + "name": "distributed", + "sha256": "4616b134ae7aa573325ac9c2183cfd9500c198a01f3118b2efee8835b468bba8", + "size": 1040287, + "subdir": "linux-64", + "timestamp": 1586198939479, + "version": "2.14.0" + }, + "distributed-2.14.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0b6a71a7c8e3e30fe97a4f3dc7d18348", + "name": "distributed", + "sha256": "de56d258a18d9c51ca87ef6655f4ceb7898341013706c57ddfd9b4a87e504650", + "size": 1043899, + "subdir": "linux-64", + "timestamp": 1586199018765, + "version": "2.14.0" + }, + "distributed-2.15.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a5668d2ede7bb9384c9c5c9bf2341125", + "name": "distributed", + "sha256": "aedee55521262d895f1ad00b48501fc23c3b0fd7bc0c0d6a406997b069f6f7fe", + "size": 1059614, + "subdir": "linux-64", + "timestamp": 1588006856573, + "version": "2.15.0" + }, + "distributed-2.15.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9b46803717d60a6dd45a9cfe113c5a80", + "name": "distributed", + "sha256": "529f341a2d3606987b564bec82ad5b8ff5efced5cc2c30b6198741b762b77d46", + "size": 1057369, + "subdir": "linux-64", + "timestamp": 1588006837448, + "version": "2.15.0" + }, + "distributed-2.15.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "26fa3112e78c38ee4fd3e65ef94ae72c", + "name": "distributed", + "sha256": "541117f6b7a1696db45d71d87cfd0d4b2ceb06ef4febe07bfff7c3c8ca9e1983", + "size": 1061279, + "subdir": "linux-64", + "timestamp": 1588006856500, + "version": "2.15.0" + }, + "distributed-2.15.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "34d826ae8c2e3d6d99e3e967193659d2", + "name": "distributed", + "sha256": "336c623c93b89b1b4b49598f9dd842652990c7c7d70b8e5f96522a5511ce5820", + "size": 1059328, + "subdir": "linux-64", + "timestamp": 1588604865348, + "version": "2.15.2" + }, + "distributed-2.15.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20f211983c9f0c525d909931bc971245", + "name": "distributed", + "sha256": "60cb7fa7d29388639781780ca46a3c9fb1f243f329e2c331f6a4f950acba26c1", + "size": 1059957, + "subdir": "linux-64", + "timestamp": 1588604861294, + "version": "2.15.2" + }, + "distributed-2.15.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "52f815d517638ac818f3acee2dad5e96", + "name": "distributed", + "sha256": "c510f33f87a33e7a4a94be0c6fd0b45f7562409c46da9593f20ea25045f85245", + "size": 1061301, + "subdir": "linux-64", + "timestamp": 1588604863921, + "version": "2.15.2" + }, + "distributed-2.16.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "29d4ad2d17fb06bf4924082b523872b6", + "name": "distributed", + "sha256": "40a90fb61942a530c9b7f9340835b2fe9539b03f5f0b0ce30aa1a27e2035079a", + "size": 1067926, + "subdir": "linux-64", + "timestamp": 1589207147770, + "version": "2.16.0" + }, + "distributed-2.16.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "802b6e95fba0d5fd4415e5fc972ad6d1", + "name": "distributed", + "sha256": "5bc5a0eea10a947176626bd6ed6a4263744c47433a4471ac360e4b566d6f749d", + "size": 1063554, + "subdir": "linux-64", + "timestamp": 1589207139381, + "version": "2.16.0" + }, + "distributed-2.16.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "08727a4b12632d4d90998899837e33fa", + "name": "distributed", + "sha256": "2aa59f93883236533d556397aafe25f9641bef9b1f888e505fce1b3df01213c8", + "size": 1072185, + "subdir": "linux-64", + "timestamp": 1589207164345, + "version": "2.16.0" + }, + "distributed-2.17.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ad046bc56ea401b98d4fb88fc11329a0", + "name": "distributed", + "sha256": "7dba657d33ef77d97379061f1f4b7ae350dd69d5f71434d244835e81c89bc971", + "size": 1081219, + "subdir": "linux-64", + "timestamp": 1590590939248, + "version": "2.17.0" + }, + "distributed-2.17.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b61a42b32484ca29bd505e6ae5b0a69c", + "name": "distributed", + "sha256": "6211947c3016181927e85bb4f55fbc8d798225cbcd0aee4bc2e170db8fa57342", + "size": 1079412, + "subdir": "linux-64", + "timestamp": 1590590938549, + "version": "2.17.0" + }, + "distributed-2.17.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f94bc5e7da1bb89d9f92cbb7cee0f52", + "name": "distributed", + "sha256": "e3ee7d1c2f59de2f8b83145df200cad5a718a6b00c9101e50bd3626dac1f2733", + "size": 1083190, + "subdir": "linux-64", + "timestamp": 1590590941270, + "version": "2.17.0" + }, + "distributed-2.18.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "daba02e4e7d646d27dee8284c70eef90", + "name": "distributed", + "sha256": "1cb9c778a2ed73d44282f86b5f5276ac288a58f7cf8937d994d271e00eebec5d", + "size": 1085505, + "subdir": "linux-64", + "timestamp": 1592250873110, + "version": "2.18.0" + }, + "distributed-2.18.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c4f98b46782134c33c595a03b5b6ed25", + "name": "distributed", + "sha256": "c94c6d9ab7cb016885cbc92d0966031876d7522f7096753fa6600b342c70f9a9", + "size": 1085011, + "subdir": "linux-64", + "timestamp": 1592250880539, + "version": "2.18.0" + }, + "distributed-2.18.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e253cb3d19d67c94d9a9aa37f6503cec", + "name": "distributed", + "sha256": "d7bde6dd8c8b6f4336b0e55390faf411990d52f2a0ea1eb80ae68e41b704ec83", + "size": 1091015, + "subdir": "linux-64", + "timestamp": 1592250871622, + "version": "2.18.0" + }, + "distributed-2.19.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "928d0f2a6bc1d025127007322cdcbf5a", + "name": "distributed", + "sha256": "28306fdee823e691c27def6591747e77437ceeccbcb2f8de07bf41622b6b67c3", + "size": 1090884, + "subdir": "linux-64", + "timestamp": 1592842516328, + "version": "2.19.0" + }, + "distributed-2.19.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "37f2ad6706a10cb4edf48cd485dd230e", + "name": "distributed", + "sha256": "e319738353b864558e6e3dee798d9e7fa602d6c0267083be9d04dc174c24a082", + "size": 1090656, + "subdir": "linux-64", + "timestamp": 1592842499787, + "version": "2.19.0" + }, + "distributed-2.19.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fb6e3976905b017c4b9f4f475504aa4c", + "name": "distributed", + "sha256": "a48c282a4ebbb7dccd89b42480b338754378f4878eb3b03c5f20f70492fb3dc5", + "size": 1098718, + "subdir": "linux-64", + "timestamp": 1592842497627, + "version": "2.19.0" + }, + "distributed-2.20.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a04b12fc958eb2914f0ea1e160d6633", + "name": "distributed", + "sha256": "031ac5ec0c7d0428ef57960596fdfa86b8298da041683cc533c10e21d5fa6aba", + "size": 1091574, + "subdir": "linux-64", + "timestamp": 1594750325613, + "version": "2.20.0" + }, + "distributed-2.20.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b8bb2f2df60e58c8f62ffe9121bac2a7", + "name": "distributed", + "sha256": "853c8f2a893ac40c9330f1a7b178d983c56b734ea2069fa3801e7e7d92593e99", + "size": 1077854, + "subdir": "linux-64", + "timestamp": 1594350139179, + "version": "2.20.0" + }, + "distributed-2.20.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0ceb4a203d53910b98668b51f218dfa6", + "name": "distributed", + "sha256": "18713d6d3960ef5c8ad0c8706d97460772ed383796cc84e169ab49072c47ca71", + "size": 1094883, + "subdir": "linux-64", + "timestamp": 1594750325716, + "version": "2.20.0" + }, + "distributed-2.22.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cb94a60dfafd47451f487837dcb47c29", + "name": "distributed", + "sha256": "b28d0e8c83d0c69e5c568646d5a46c89a8e39424c9e3ebef3dbef230074bfa99", + "size": 1096799, + "subdir": "linux-64", + "timestamp": 1598652694324, + "version": "2.22.0" + }, + "distributed-2.22.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a5597eb24d220fb5a940249b4604bf46", + "name": "distributed", + "sha256": "f0b812e994c0fc8975e717d65419e125d158cc438176d69f2f9adf989082164f", + "size": 1082768, + "subdir": "linux-64", + "timestamp": 1596832096867, + "version": "2.22.0" + }, + "distributed-2.22.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b87e98ee770fa189c1bd80757cae0b34", + "name": "distributed", + "sha256": "2e8237fe8c51a178b3d0868becd342b82ceb1498989a9ba1a84c1ee5d427cca7", + "size": 1104081, + "subdir": "linux-64", + "timestamp": 1598652642895, + "version": "2.22.0" + }, + "distributed-2.23.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "44ef301a5334d3fed7f259527542c580", + "name": "distributed", + "sha256": "cac476a6fec183618d2bd0ae3ccdd49b7936ae3a303d7a85e5a5cea5f08b26ce", + "size": 1104652, + "subdir": "linux-64", + "timestamp": 1598651237489, + "version": "2.23.0" + }, + "distributed-2.23.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9461f8b07b908804b8cc5ad19f999d85", + "name": "distributed", + "sha256": "fa2b6fbed9726d00f0be36e48e2be6322f3fd5d4eb242eb37fc6a0a8bb30a555", + "size": 1087603, + "subdir": "linux-64", + "timestamp": 1597595945458, + "version": "2.23.0" + }, + "distributed-2.23.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f95494a66014d2bb1892dd5afeca75c", + "name": "distributed", + "sha256": "2810ce1ff5163e991fe74ae9d742b7472f9fb42ac9b08ff12017448ea8d049a1", + "size": 1107620, + "subdir": "linux-64", + "timestamp": 1598651217501, + "version": "2.23.0" + }, + "distributed-2.24.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6a5c23123a101989bc909d4c0bd2f594", + "name": "distributed", + "sha256": "63dcbcf9a57f7a5e10cdb2091f284f9b05a539b34dec6acada1ef68914643c1c", + "size": 1104651, + "subdir": "linux-64", + "timestamp": 1598623846582, + "version": "2.24.0" + }, + "distributed-2.24.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a65e9347a0d1d7293b490d624c5819db", + "name": "distributed", + "sha256": "8c6e9b0fc6ff442d7f2be3f9937589bc02495c71d1bfbd2b5f72be9c40f02bf8", + "size": 1093197, + "subdir": "linux-64", + "timestamp": 1598198406438, + "version": "2.24.0" + }, + "distributed-2.24.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3a55deba892e59fbf803ca81ff84b211", + "name": "distributed", + "sha256": "abfff062c9dcef923768ef4fd00213da1fc38c0676367658c327dd49588d6808", + "size": 1109309, + "subdir": "linux-64", + "timestamp": 1598623841590, + "version": "2.24.0" + }, + "distributed-2.25.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ad138447d4395fa8d5ad5c1d10f59cc4", + "name": "distributed", + "sha256": "c382640d2f41408101716190c02bd33bdf663820df513b4300a29d76e7864d35", + "size": 1107272, + "subdir": "linux-64", + "timestamp": 1598883562539, + "version": "2.25.0" + }, + "distributed-2.25.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1e528a606540f5493caac14b9235f9d", + "name": "distributed", + "sha256": "dc308398cdbc1128847e910911a0ded9c6c18c8ddda2551224a196709b92c72a", + "size": 1107263, + "subdir": "linux-64", + "timestamp": 1598883559995, + "version": "2.25.0" + }, + "distributed-2.25.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4c293f5379f4984b7d614a17cbfc651f", + "name": "distributed", + "sha256": "e6da2ae667c61d7b8168babb489e9d17547c3ed447e57dc58967c4741c4d7633", + "size": 1114660, + "subdir": "linux-64", + "timestamp": 1598883566531, + "version": "2.25.0" + }, + "distributed-2.26.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0524a3f5def5c6ef43c264e76e039927", + "name": "distributed", + "sha256": "b81844e545285831604bc11b0728fe31fbe3a6c969cab1ac4212d9b74eb701c1", + "size": 1093464, + "subdir": "linux-64", + "timestamp": 1600136919687, + "version": "2.26.0" + }, + "distributed-2.26.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f20b5c03f2f28c5fa6443b5b613a8510", + "name": "distributed", + "sha256": "ed96df809b67c51ba2b322ae6bf1ad7809b5c28bcfb06d292a3c3b2763a2e0b4", + "size": 1092532, + "subdir": "linux-64", + "timestamp": 1600136906521, + "version": "2.26.0" + }, + "distributed-2.26.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aee26dab38ce500fe4e0319e0b1c810d", + "name": "distributed", + "sha256": "9f451264eb23ef3ec14ed6454d3e4c8c52efea91e312c84d42d4cee008649923", + "size": 1098301, + "subdir": "linux-64", + "timestamp": 1600136897660, + "version": "2.26.0" + }, + "distributed-2.27.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a15bce97567a291f0913a7ece366fde5", + "name": "distributed", + "sha256": "546f84938ae4be957d29ccd5a0d084ee08a68acba1873946dd36ef8487d97414", + "size": 1096801, + "subdir": "linux-64", + "timestamp": 1600699890595, + "version": "2.27.0" + }, + "distributed-2.27.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d5f7643f384c2ddaea713da56325461", + "name": "distributed", + "sha256": "704bb7f386e646d250900d089c3226d73e538e3ecb58a02ba3e639828118b053", + "size": 1094957, + "subdir": "linux-64", + "timestamp": 1600699884840, + "version": "2.27.0" + }, + "distributed-2.27.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e9f0e11f55408029a7541d471466f02", + "name": "distributed", + "sha256": "bacd6dda66c8d04e1b791c60a7338a44e311c23b59a8a012752b1ecaca22e919", + "size": 1098991, + "subdir": "linux-64", + "timestamp": 1600699881759, + "version": "2.27.0" + }, + "distributed-2.28.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88127bc4799c8f1c8b5230f304d62746", + "name": "distributed", + "sha256": "da0d6eb4d31207a5e9280ed2f73bb12574982b10d9337659c36197979640b174", + "size": 1096425, + "subdir": "linux-64", + "timestamp": 1601309259342, + "version": "2.28.0" + }, + "distributed-2.28.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2665897003445dfe21beecb908f167ad", + "name": "distributed", + "sha256": "51c1bf809a96d967c70d77983105af5c6793f1a9c37c785f75897a3748498615", + "size": 1094544, + "subdir": "linux-64", + "timestamp": 1601309267008, + "version": "2.28.0" + }, + "distributed-2.28.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e7bf32fe6c7c4c0ca7eee712e9e18233", + "name": "distributed", + "sha256": "3031df037ec78987d1afa14794bdaa77c7807e91aa7e8f888ac899c24b3ec199", + "size": 1101770, + "subdir": "linux-64", + "timestamp": 1601309273300, + "version": "2.28.0" + }, + "distributed-2.29.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee51410b7e9fea399393df322733c9aa", + "name": "distributed", + "sha256": "5c518587b3f9b360428c0b4b1db6b6e618c6323486e3c5f4cd3f959d58deae44", + "size": 1098757, + "subdir": "linux-64", + "timestamp": 1601910817541, + "version": "2.29.0" + }, + "distributed-2.29.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c9c67358675a51f574ec5b8426347845", + "name": "distributed", + "sha256": "2ae804d20c52f16de754475844738302c5a9919800f0bc813eee71ac7b8d54c1", + "size": 1095014, + "subdir": "linux-64", + "timestamp": 1601910822015, + "version": "2.29.0" + }, + "distributed-2.29.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a545a482feb2290e5949219df8919b99", + "name": "distributed", + "sha256": "63621f78bd4d5fa8d9548d736f24c98d30f8e73164d31789e745df2cbe4d3f93", + "size": 1102014, + "subdir": "linux-64", + "timestamp": 1601910819078, + "version": "2.29.0" + }, + "distributed-2.30.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85dd18d5ca509fe3f2c7abe58b95edc2", + "name": "distributed", + "sha256": "8999a54d11ffb4ea6c52692aab7a7e790d77ae852501ff5ec34cc4e81f89060b", + "size": 1098492, + "subdir": "linux-64", + "timestamp": 1602083954608, + "version": "2.30.0" + }, + "distributed-2.30.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5a919acead7ecbec9b077d5a9e3deb6e", + "name": "distributed", + "sha256": "8479fcdab56fcd0a7fac174de2302803824231ce206293b5fae0ec559a5a58ff", + "size": 1102410, + "subdir": "linux-64", + "timestamp": 1602083938612, + "version": "2.30.0" + }, + "distributed-2.30.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "37dc6bb64cebe023a8c8b8f8356b590a", + "name": "distributed", + "sha256": "a39cf072f6a47a6dcd5fd36798c2652ea0157c827401d1b976cbc92dd21d0b31", + "size": 1103523, + "subdir": "linux-64", + "timestamp": 1602083918686, + "version": "2.30.0" + }, + "distributed-2.30.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dbbf97f61825f8fedc505a1db999beaa", + "name": "distributed", + "sha256": "5adc5238aa4bc56f614f08af7733dede06b5d5543b182faa55e6a48a7e181743", + "size": 1100695, + "subdir": "linux-64", + "timestamp": 1605066540496, + "version": "2.30.1" + }, + "distributed-2.30.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "91c0170fbf21cddc9ea3dd7570f11249", + "name": "distributed", + "sha256": "a30daf0c8d21499ab22f5df1da4f99aaf59af138a5a9013e546fce15b4e9142c", + "size": 1101559, + "subdir": "linux-64", + "timestamp": 1605066554840, + "version": "2.30.1" + }, + "distributed-2.30.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "053a1a3d214bcc1c95405c30331d9652", + "name": "distributed", + "sha256": "a931cd3bcc60d6609f0f951f82ab8e9c78bdc57eef789b999d9c31f03f072837", + "size": 1105808, + "subdir": "linux-64", + "timestamp": 1605066559613, + "version": "2.30.1" + }, + "distributed-2020.12.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ce102168f753c43c04871cb965e12b92", + "name": "distributed", + "sha256": "bc6fcacfcd95a8ce95d1f15db18cc5f6473f53ab2e201860fc79ac739637d5bc", + "size": 1128012, + "subdir": "linux-64", + "timestamp": 1607714086742, + "version": "2020.12.0" + }, + "distributed-2020.12.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c23e10ca65e31390f6351594090b407d", + "name": "distributed", + "sha256": "b4372aa34a4f5e830b94646c411eab21beb248e2130c2ac535514b770878126c", + "size": 1123000, + "subdir": "linux-64", + "timestamp": 1607714052090, + "version": "2020.12.0" + }, + "distributed-2020.12.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "948c49cda1bb14b556a8430d7c966e48", + "name": "distributed", + "sha256": "76d785c59b8c73849093b46914d9d84bb77c601b28b022c354f12b3274b28a6f", + "size": 1130551, + "subdir": "linux-64", + "timestamp": 1607714091687, + "version": "2020.12.0" + }, + "distributed-2020.12.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9ab3e2b9c3d80b57e215ec18da29c651", + "name": "distributed", + "sha256": "f9651b58d59a4544bb42fc5f6ea8e19bc0300ad676977cb4b7ece0539c07b9a6", + "size": 1129889, + "subdir": "linux-64", + "timestamp": 1607714074903, + "version": "2020.12.0" + }, + "distributed-2021.1.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "03753195cb101f498b6a9f48fdcb1dce", + "name": "distributed", + "sha256": "4296eca589dbf8f0a30dd8bfc09c3f1824351a48981fd046160068b31d006e66", + "size": 1127791, + "subdir": "linux-64", + "timestamp": 1610822595600, + "version": "2021.1.0" + }, + "distributed-2021.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6b28ee2142f3fa53b242f0d34bfdc923", + "name": "distributed", + "sha256": "da9cd72668edc08a92f428906ef501eb3df3ea969f69dacba4d39a5243712bf1", + "size": 1126537, + "subdir": "linux-64", + "timestamp": 1610822584358, + "version": "2021.1.0" + }, + "distributed-2021.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "294bd220ad5b3ce5dc764bff75e126b7", + "name": "distributed", + "sha256": "df895ffa7e05b48f667d568b46c04471f883efdf0c88897872438962b55083f1", + "size": 1131674, + "subdir": "linux-64", + "timestamp": 1610822597566, + "version": "2021.1.0" + }, + "distributed-2021.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7ae95df5199d059ffc5ff844940c76bd", + "name": "distributed", + "sha256": "b2bb87234cb542808b1079e06ab5e2c0e2cd78f065779514804a919296f2bda2", + "size": 1135293, + "subdir": "linux-64", + "timestamp": 1610821930725, + "version": "2021.1.0" + }, + "distributed-2021.1.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cad0f72b2743d385cd4dc9b1e765c564", + "name": "distributed", + "sha256": "3ef0996c7cb4b012610ea5fe7f44c2e5bdd3e1d89157cc4da6d39bdf4bd0d71c", + "size": 1129912, + "subdir": "linux-64", + "timestamp": 1611587309927, + "version": "2021.1.1" + }, + "distributed-2021.1.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "735032974b0ba866dcbec97eaf48f82d", + "name": "distributed", + "sha256": "65930a6648e9b6537fd9227570e9d73e7146d9f80c3bdee9c6376c08a847e1ed", + "size": 1129273, + "subdir": "linux-64", + "timestamp": 1611341472088, + "version": "2021.1.1" + }, + "distributed-2021.1.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "52773f9f8960587f71d7854aa8dc6518", + "name": "distributed", + "sha256": "60967f658956a0d49c6ad49530896e2e209cba1f0b053c652fdfae7b215b734b", + "size": 1128044, + "subdir": "linux-64", + "timestamp": 1611587022949, + "version": "2021.1.1" + }, + "distributed-2021.1.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "367aa74515f7fdac78184a8bba1dac15", + "name": "distributed", + "sha256": "c0021de932e19a7abd16771812663326819b594fb20896ba1462cccd2ee34871", + "size": 1126024, + "subdir": "linux-64", + "timestamp": 1611341517545, + "version": "2021.1.1" + }, + "distributed-2021.1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "51cfa5541ca1c320fde3a666901d94e9", + "name": "distributed", + "sha256": "917d4a99e4e9eec67a72acacaa148a4045046d7a3765b816617b934a3955a521", + "size": 1134441, + "subdir": "linux-64", + "timestamp": 1611587329266, + "version": "2021.1.1" + }, + "distributed-2021.1.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f8f687c7ea1202ca7b82235b61df1be9", + "name": "distributed", + "sha256": "ade1d51e4a28b9fae20c614782e16f330be03b7ba3d8b8ae7cd96a847a816023", + "size": 1134063, + "subdir": "linux-64", + "timestamp": 1611341497107, + "version": "2021.1.1" + }, + "distributed-2021.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "62e307fc7dc84ad0576ec1e92de68c0a", + "name": "distributed", + "sha256": "fe6cf225f7ac7bfaba3c24f642f41ebc269eab145f621ad34bd7d38bedc5990d", + "size": 1133472, + "subdir": "linux-64", + "timestamp": 1611587333278, + "version": "2021.1.1" + }, + "distributed-2021.1.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "744b38539055137d70c0c7c252579732", + "name": "distributed", + "sha256": "eb6169a9ec82c7c1c93186efce9acae2c856238a64837ab2916a8574d7b3ea95", + "size": 1138347, + "subdir": "linux-64", + "timestamp": 1611341515538, + "version": "2021.1.1" + }, + "distributed-2021.10.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.10.0.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.10,<3.11.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "54e3dc22a3a95973155268e4b4cf5f42", + "name": "distributed", + "sha256": "1a7a3ca500d15232f607a52054e9b4dbe722f631e85c5c7aec559d5689e15481", + "size": 1119557, + "subdir": "linux-64", + "timestamp": 1642512829673, + "version": "2021.10.0" + }, + "distributed-2021.10.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.10.0.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "98a5e776ca61235df36c64bb0913ea3d", + "name": "distributed", + "sha256": "86a5bdd6cb30297a15eaafc13700c0a8607c12e15d0bdc6aabafbd4837a088d3", + "size": 1114420, + "subdir": "linux-64", + "timestamp": 1635968235028, + "version": "2021.10.0" + }, + "distributed-2021.10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.10.0.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88a5a1e59a29df1e4f51c4810453c860", + "name": "distributed", + "sha256": "6302f38efee38870ea538d474353e6b60fbe43c8eb2ca7e10d0ca349197112bc", + "size": 1128129, + "subdir": "linux-64", + "timestamp": 1635968239447, + "version": "2021.10.0" + }, + "distributed-2021.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.10.0.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a05c018384cade3eb6039dc4fec7bf16", + "name": "distributed", + "sha256": "0ae74591f30f18f151d9d9436e0faa7ace3448b58edcced70ff434deaae247ed", + "size": 1127248, + "subdir": "linux-64", + "timestamp": 1635956256132, + "version": "2021.10.0" + }, + "distributed-2021.2.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4f768589f6f446663a21dfa61ebce03c", + "name": "distributed", + "sha256": "5c6d0e9da0ff7a9db364e0d70153b2ba8f77cf4636a05e4d222a49a6b8cd8dcd", + "size": 1137030, + "subdir": "linux-64", + "timestamp": 1613253514854, + "version": "2021.2.0" + }, + "distributed-2021.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aedb349c82804c38aad2ea3e55ccea64", + "name": "distributed", + "sha256": "2f8a9b9797a85802676bfdf2d5ba1f0d380e4d403c39c860384195f3a5657cc6", + "size": 1134432, + "subdir": "linux-64", + "timestamp": 1613253515853, + "version": "2021.2.0" + }, + "distributed-2021.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0f7d20104969842714c375fee1e59cfd", + "name": "distributed", + "sha256": "148403ed07323c95b13826d6eb75b37804044b7400248c429b7303b26c927902", + "size": 1138032, + "subdir": "linux-64", + "timestamp": 1613253520408, + "version": "2021.2.0" + }, + "distributed-2021.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "56d31521bb2b31b1bc38f26117c2b3a3", + "name": "distributed", + "sha256": "832402bdcb3061344909d381a1a15855f0e4859d337fbf48beea0a829cbd54d6", + "size": 1142180, + "subdir": "linux-64", + "timestamp": 1613253522120, + "version": "2021.2.0" + }, + "distributed-2021.3.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c27c8a41355c1d4885f8a6640de9138c", + "name": "distributed", + "sha256": "42e253243106685977e1428af2921f9df8fa7926c046f1fe7e24612e1c79cdb7", + "size": 1133615, + "subdir": "linux-64", + "timestamp": 1615054637026, + "version": "2021.3.0" + }, + "distributed-2021.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c2a9d86e31a6086efe466f1eac09f806", + "name": "distributed", + "sha256": "b0a07a91eb6192f14d73346210705f3d36481c68e8a05a14d5b36c2355a36b72", + "size": 1133867, + "subdir": "linux-64", + "timestamp": 1615055324628, + "version": "2021.3.0" + }, + "distributed-2021.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cd013438787a9233ead9a73fc19074e9", + "name": "distributed", + "sha256": "314ad665f254fa3b230fc2ca1588434ac2b989085186d3b81214266061292e4c", + "size": 1138645, + "subdir": "linux-64", + "timestamp": 1615055334373, + "version": "2021.3.0" + }, + "distributed-2021.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c3344164648267242b2be4349cd461b3", + "name": "distributed", + "sha256": "297a574b20b053650b4ed61f09d2d62769daff00a05112cc20110186de9376e2", + "size": 1139310, + "subdir": "linux-64", + "timestamp": 1615055338438, + "version": "2021.3.0" + }, + "distributed-2021.3.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fbbaf6d3ab7749dd108abca77a939827", + "name": "distributed", + "sha256": "9e6159b3c108d6b4f9133eb561f20f468da6ac150781a374fd947b7191d524f5", + "size": 1141332, + "subdir": "linux-64", + "timestamp": 1617220292322, + "version": "2021.3.1" + }, + "distributed-2021.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1ef9c4168aea73aebc4b774e51369b27", + "name": "distributed", + "sha256": "849ea07890bcbab70eef5e31a4ac59e6a8496e5549d6267dcd76aa8361a7a7c2", + "size": 1145970, + "subdir": "linux-64", + "timestamp": 1617220286548, + "version": "2021.3.1" + }, + "distributed-2021.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e2b8f5d408f9355c8b8b1c3f3bd8dee5", + "name": "distributed", + "sha256": "d433ce1ad1107f743f2089dec05a6f4dbd99e75b51414df5461f1f7382d13136", + "size": 1147062, + "subdir": "linux-64", + "timestamp": 1617220109840, + "version": "2021.3.1" + }, + "distributed-2021.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e67cae793be2b478bc23b01a0f5c6b04", + "name": "distributed", + "sha256": "b71045aab5654cb6c9a5ab552cc2b2178ef4f9053adfc087a5f85bbcab3bf41a", + "size": 1148290, + "subdir": "linux-64", + "timestamp": 1617383733549, + "version": "2021.4.0" + }, + "distributed-2021.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b484339ad8ffce38fc9a870b4aaffc54", + "name": "distributed", + "sha256": "b160b62996fb9810ddec533b203c803ecb58afb86a1e495af031ca85be04edb8", + "size": 1152674, + "subdir": "linux-64", + "timestamp": 1617381543839, + "version": "2021.4.0" + }, + "distributed-2021.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7522158c5e7e829718bfcad6316126da", + "name": "distributed", + "sha256": "40f78c6c940e791f6b4933f46245baf51c00e458c49009a0459735f8976f8c9c", + "size": 1151032, + "subdir": "linux-64", + "timestamp": 1617384123905, + "version": "2021.4.0" + }, + "distributed-2021.4.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2021.3.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4b25d51218ad6ec6718f9f5999421c7b", + "name": "distributed", + "sha256": "198f1e2983d02929ca072d5397bd27a2b4fd9e042ca9ccceb30c77b4c281c504", + "size": 1165932, + "subdir": "linux-64", + "timestamp": 1620906724179, + "version": "2021.4.1" + }, + "distributed-2021.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2021.3.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "960f067e459499ebe4e8d189cfb6d06a", + "name": "distributed", + "sha256": "7eef770aba4aeb461a13aa7f564f81d258de8ea200c8d6cc7ccdf2e3d5777f74", + "size": 1169679, + "subdir": "linux-64", + "timestamp": 1620902880236, + "version": "2021.4.1" + }, + "distributed-2021.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2021.3.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b1de8827f46a7e75bf9a5aa4fd43c5c5", + "name": "distributed", + "sha256": "88628c48376a069f63397f16f4cdc5317f049c82ae7b81084ca309096027b4bd", + "size": 1169454, + "subdir": "linux-64", + "timestamp": 1620907237140, + "version": "2021.4.1" + }, + "distributed-2021.5.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.5.0.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dc4b850a5dc2872749adb6b239bc531c", + "name": "distributed", + "sha256": "4ac51250c4b9c01fb60862d5cb3d0befb23febc971e5bb5bc74ed29e4a7e7f79", + "size": 1172009, + "subdir": "linux-64", + "timestamp": 1621290234256, + "version": "2021.5.0" + }, + "distributed-2021.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.5.0.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1cd8b502221f0fbca221cc4579b4d21a", + "name": "distributed", + "sha256": "6587b78bd4cc5b807874505d162229d97e9c64ecdccb5fa3665a53f300602b16", + "size": 1174533, + "subdir": "linux-64", + "timestamp": 1621290228328, + "version": "2021.5.0" + }, + "distributed-2021.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.5.0.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c2615bfb479378eab2609aa0eb23b520", + "name": "distributed", + "sha256": "c1193ec8555efb3a70185bfce889abbf86bbe77a4a5d4b505f7e217179e6c530", + "size": 1177643, + "subdir": "linux-64", + "timestamp": 1621290228848, + "version": "2021.5.0" + }, + "distributed-2021.5.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.5.1.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e87f883067e38128a6d02544b87ff343", + "name": "distributed", + "sha256": "e35a37c3c4b6c9f09f8bb85fa7a4564576c8104b82e2aac042a46b0bb71decaa", + "size": 1181044, + "subdir": "linux-64", + "timestamp": 1622643061589, + "version": "2021.5.1" + }, + "distributed-2021.5.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.5.1.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e2585b156d9b6280b1d212676cd92a1", + "name": "distributed", + "sha256": "aa69ac183ac0b883f1e6d83ee2396448d37f28d4667404a88e52f3f97add3cbc", + "size": 1185258, + "subdir": "linux-64", + "timestamp": 1622643766398, + "version": "2021.5.1" + }, + "distributed-2021.5.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.5.1.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "57f6ff338b6921b62425220ebfdc8bf2", + "name": "distributed", + "sha256": "5b893493c1cbe6f724585a65124e58fa2230805f8e515633d7455660660a3e3c", + "size": 1186948, + "subdir": "linux-64", + "timestamp": 1622643769768, + "version": "2021.5.1" + }, + "distributed-2021.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.6.0.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cf00e46ca2f7b7816f44b91e89f20e5a", + "name": "distributed", + "sha256": "2a692744d37320111b33db359d58e1f72ea86047d4628a59e929f9975297b277", + "size": 1192764, + "subdir": "linux-64", + "timestamp": 1623168940195, + "version": "2021.6.0" + }, + "distributed-2021.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.6.0.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "297153e1f228f1430ffd1df23f9892cc", + "name": "distributed", + "sha256": "74aa4f475fecb46c186964a2bd885f075878741ae52eb061249cc59735b73165", + "size": 1198166, + "subdir": "linux-64", + "timestamp": 1623174445285, + "version": "2021.6.0" + }, + "distributed-2021.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.6.0.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "970069a00016d846d8689836de7d5612", + "name": "distributed", + "sha256": "9a89d4a7177ada42a587a644bf962aad902851e0d03444baeb2180f8d2307d6f", + "size": 1198325, + "subdir": "linux-64", + "timestamp": 1623174444800, + "version": "2021.6.0" + }, + "distributed-2021.6.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.6.1.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c2a4dec0a040712cb0da195fead6a8eb", + "name": "distributed", + "sha256": "fb477f0e54b5aa8042f1d4949029d5d2e38030c47dad0cf6ac7b2489bcd6dd9f", + "size": 1201356, + "subdir": "linux-64", + "timestamp": 1624558438391, + "version": "2021.6.1" + }, + "distributed-2021.6.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.6.1.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e6bee38b144d04d7d591d34083697028", + "name": "distributed", + "sha256": "04a3aec9125c745d517334861eac6beae51c480c1e14ce14919d948bf972bf53", + "size": 1208349, + "subdir": "linux-64", + "timestamp": 1624557709620, + "version": "2021.6.1" + }, + "distributed-2021.6.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.6.1.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ffe34f4f44fa2f94515bf56715aab46c", + "name": "distributed", + "sha256": "45607cc8244fb130b86a0ca0f2d2922636791a58d48e542c0c72fd7799f25c69", + "size": 1211644, + "subdir": "linux-64", + "timestamp": 1624558436159, + "version": "2021.6.1" + }, + "distributed-2021.6.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.6.2.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b99ff14a3ec7aeb96176ca922206f583", + "name": "distributed", + "sha256": "a421aaf25291ac6a4783793c41b400a80079bc8061b202b2157ce22c5a0c94c7", + "size": 1208761, + "subdir": "linux-64", + "timestamp": 1624589165337, + "version": "2021.6.2" + }, + "distributed-2021.6.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.6.2.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "593dba8e142fdc0f9d8eaa22553450a5", + "name": "distributed", + "sha256": "3ffe1cee6327025f326a0eed925562feb3c2f853eae8e0ef96452e436f2d1740", + "size": 1205606, + "subdir": "linux-64", + "timestamp": 1624589295317, + "version": "2021.6.2" + }, + "distributed-2021.6.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.6.2.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "231c80b6de18eb5c478fd650e9a5d2ac", + "name": "distributed", + "sha256": "d6619cf00451bf348cb1ad56cba5ea44a546e72a3994603c2ddf54452a4cf7a5", + "size": 1208497, + "subdir": "linux-64", + "timestamp": 1624583038800, + "version": "2021.6.2" + }, + "distributed-2021.7.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.7.0.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d0cc5c345cc948ef451057a39297c1d", + "name": "distributed", + "sha256": "bf4bea27ae518446ad2f7607c1518ca0c12474f9cc4ee08d5a9d54eb9c68225c", + "size": 1569223, + "subdir": "linux-64", + "timestamp": 1626113028846, + "version": "2021.7.0" + }, + "distributed-2021.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.7.0.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e9ca21f1668d1e787e5ce62c660d0f0c", + "name": "distributed", + "sha256": "fd90929e1e0d744c40f93f61e67d95ed0820ac0d8a37bc446949ffea15c66d11", + "size": 1573386, + "subdir": "linux-64", + "timestamp": 1626113027982, + "version": "2021.7.0" + }, + "distributed-2021.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.7.0.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e2c93ccb86df47b83464a70ffb2a14b6", + "name": "distributed", + "sha256": "db0544a69c1eaf59c7800d504d5396aacc4da10e6840f52d4d7ec5724eeea710", + "size": 1579169, + "subdir": "linux-64", + "timestamp": 1626112664278, + "version": "2021.7.0" + }, + "distributed-2021.7.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.7.2.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a414d827d6c205c0bd92fb093c4f116", + "name": "distributed", + "sha256": "7979097fd77c78204ed7b32249f5501ed4595fd717b96178f0694247e5894145", + "size": 1068053, + "subdir": "linux-64", + "timestamp": 1628001522135, + "version": "2021.7.2" + }, + "distributed-2021.7.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.7.2.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f8c78df1bad0a727ba51ea7c378e92d9", + "name": "distributed", + "sha256": "93950a6b62d3ee2fdb8fc83469f5ba4c635b938446b9f3ad6873c420b7162779", + "size": 1082445, + "subdir": "linux-64", + "timestamp": 1628001552572, + "version": "2021.7.2" + }, + "distributed-2021.7.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.7.2.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b205e4275f8bc389081cff78a6a46ba8", + "name": "distributed", + "sha256": "b8b1f92d18305ab22ba3848f690136d3d7e3951e147dfdba97883ff16b277496", + "size": 1078662, + "subdir": "linux-64", + "timestamp": 1628001122817, + "version": "2021.7.2" + }, + "distributed-2021.8.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.8.0.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "974ae8bf39c7a61a2c7795407d2cc66d", + "name": "distributed", + "sha256": "1e42698b3608d4a40cbfacbd1dd29705cc702c1f4dd35a78d8c3efbc91ea75d0", + "size": 1082020, + "subdir": "linux-64", + "timestamp": 1629141747422, + "version": "2021.8.0" + }, + "distributed-2021.8.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.8.0.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "120767525583f39980d8b9f5cac094d7", + "name": "distributed", + "sha256": "d462fc9de63d8ddaeaf6d74ed0f2551e6da278995b085371182035521850a7f4", + "size": 1073466, + "subdir": "linux-64", + "timestamp": 1629141746441, + "version": "2021.8.0" + }, + "distributed-2021.8.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.8.0.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "11ba006f56cb104ca473475b4464a10f", + "name": "distributed", + "sha256": "b2135af6c96b332d13294ee61779efce26eec6c9afdeca16480f6767c2370d01", + "size": 1077163, + "subdir": "linux-64", + "timestamp": 1629141750261, + "version": "2021.8.0" + }, + "distributed-2021.8.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.8.1.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "30c5d5777a1760cbaa83727ee2f59d8a", + "name": "distributed", + "sha256": "febd5435a3168061aa62bf692195a4e12455864414b0b9245638eb13ee21c10d", + "size": 1102486, + "subdir": "linux-64", + "timestamp": 1630620021670, + "version": "2021.8.1" + }, + "distributed-2021.8.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.8.1.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "af288c531720a8abd98c6fe1d95d6a55", + "name": "distributed", + "sha256": "a0fa3c8706d33fb9b7d9267db49bf2872d98086b8c872297c8feb06c61418bbb", + "size": 1104980, + "subdir": "linux-64", + "timestamp": 1630629301789, + "version": "2021.8.1" + }, + "distributed-2021.8.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.8.1.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "41a171ccff17d223299ffb9173db8d02", + "name": "distributed", + "sha256": "cad121237e2924caf8bf926c137ec798249d72eb9aa0671794e242277632887e", + "size": 1104696, + "subdir": "linux-64", + "timestamp": 1630629004353, + "version": "2021.8.1" + }, + "distributed-2021.9.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.9.1.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0f32414b56be6b7d4886128d033ea8d5", + "name": "distributed", + "sha256": "89f004a1e3b73935eb75713c0e940f0e1e48f3f0d5ff1fe12fe15e223e74658f", + "size": 1112794, + "subdir": "linux-64", + "timestamp": 1634741471435, + "version": "2021.9.1" + }, + "distributed-2021.9.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.9.1.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6857f091b5bf4c19fe2472134943b283", + "name": "distributed", + "sha256": "c049cbde273b4cba67176abcb280ab1b2de10872d180cf5c00493a0f1ef1bc26", + "size": 1107094, + "subdir": "linux-64", + "timestamp": 1634730106507, + "version": "2021.9.1" + }, + "distributed-2021.9.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.9.1.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "198a950942a9eca96672b46444928289", + "name": "distributed", + "sha256": "cd25a05af68707a7314fd8fc6c62d87e363d58969095cd1dd96375b292b9212a", + "size": 1116020, + "subdir": "linux-64", + "timestamp": 1634741468527, + "version": "2021.9.1" + }, + "distributed-2022.5.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "dask-core 2022.5.0.*", + "jinja2", + "locket >=1.0.0", + "msgpack-python >=0.6.0", + "packaging >=20.0", + "psutil >=5.0", + "python >=3.10,<3.11.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "urllib3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6e22c9cf6e8ca87ddb0e57b7b28a4527", + "name": "distributed", + "sha256": "10edc79bb9c1cb7f897870033724b57a39c7213322786a4f554ed257f9fc177b", + "size": 1203422, + "subdir": "linux-64", + "timestamp": 1653401806837, + "version": "2022.5.0" + }, + "distributed-2022.5.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "dask-core 2022.5.0.*", + "jinja2", + "locket >=1.0.0", + "msgpack-python >=0.6.0", + "packaging >=20.0", + "psutil >=5.0", + "python >=3.11,<3.12.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "urllib3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "24719cdbac855990aedc0d4adcac1efb", + "name": "distributed", + "sha256": "f104aa9e1afa9ee74d7ef4968d1c4e8859e0ee8c6037a8c9d134cfa35938cc9f", + "size": 1483620, + "subdir": "linux-64", + "timestamp": 1676839711274, + "version": "2022.5.0" + }, + "distributed-2022.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "dask-core 2022.5.0.*", + "jinja2", + "locket >=1.0.0", + "msgpack-python >=0.6.0", + "packaging >=20.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "urllib3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d4faba3a18c3e73af438c60ba6c942d6", + "name": "distributed", + "sha256": "98fd5f2fc4524dc963bcfcc501685f7d4e014fe4e8bd7421b6d6534e4f35d9ca", + "size": 1191384, + "subdir": "linux-64", + "timestamp": 1653401843242, + "version": "2022.5.0" + }, + "distributed-2022.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "dask-core 2022.5.0.*", + "jinja2", + "locket >=1.0.0", + "msgpack-python >=0.6.0", + "packaging >=20.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "urllib3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4e2dd3f598f8ad53d1b397503d2e14c5", + "name": "distributed", + "sha256": "06d5d4ee3832c2b7d3162d8730b038e244b9c759100d4a4ccb231806061b0b70", + "size": 1193931, + "subdir": "linux-64", + "timestamp": 1653401880449, + "version": "2022.5.0" + }, + "distributed-2022.7.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "dask-core 2022.7.0.*", + "jinja2", + "locket >=1.0.0", + "msgpack-python >=0.6.0", + "packaging >=20.0", + "psutil >=5.0", + "python >=3.10,<3.11.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3,<6.2", + "urllib3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "833e0b230645bfb13d504d37ad5ca157", + "name": "distributed", + "sha256": "bc5f2d3c7e40aa5b4f0090cab6d5cb0f025768d0a0b980e8c5736ca17640179a", + "size": 1234281, + "subdir": "linux-64", + "timestamp": 1658520862470, + "version": "2022.7.0" + }, + "distributed-2022.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "dask-core 2022.7.0.*", + "jinja2", + "locket >=1.0.0", + "msgpack-python >=0.6.0", + "packaging >=20.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3,<6.2", + "urllib3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "108104ac13752655fd30a05663cc20bb", + "name": "distributed", + "sha256": "69269ae94237b7a6f7eb00b1fb8929324ef99700b441f537f9512eee9431f186", + "size": 1222580, + "subdir": "linux-64", + "timestamp": 1658520781694, + "version": "2022.7.0" + }, + "distributed-2022.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "dask-core 2022.7.0.*", + "jinja2", + "locket >=1.0.0", + "msgpack-python >=0.6.0", + "packaging >=20.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3,<6.2", + "urllib3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2568b450792bc69472966e413b44437c", + "name": "distributed", + "sha256": "0e1c9aa6c59497929b910a929b68e6c9d7bcf629d5a6959c89c37a617c669ede", + "size": 1223953, + "subdir": "linux-64", + "timestamp": 1658520817278, + "version": "2022.7.0" + }, + "distributed-2023.3.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=8.0", + "cloudpickle >=1.5.0", + "dask-core 2023.3.2.*", + "jinja2 >=2.10.3", + "locket >=1.0.0", + "msgpack-python >=1.0.0", + "packaging >=20.0", + "psutil >=5.7.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.3.1", + "sortedcontainers >=2.0.5", + "tblib >=1.6.0", + "toolz >=0.10.0", + "tornado >=6.0.3", + "urllib3 >=1.24.3", + "zict >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0f8ccb33389a99624c1f0563943d09a9", + "name": "distributed", + "sha256": "3e186800e520a39ee2b67eec727be9b24fa15a7c8de8fb62005188d3c0d81df9", + "size": 1369721, + "subdir": "linux-64", + "timestamp": 1680104491233, + "version": "2023.3.2" + }, + "distributed-2023.3.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=8.0", + "cloudpickle >=1.5.0", + "dask-core 2023.3.2.*", + "jinja2 >=2.10.3", + "locket >=1.0.0", + "msgpack-python >=1.0.0", + "packaging >=20.0", + "psutil >=5.7.0", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.3.1", + "sortedcontainers >=2.0.5", + "tblib >=1.6.0", + "toolz >=0.10.0", + "tornado >=6.0.3", + "urllib3 >=1.24.3", + "zict >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1612ab067607300b5434cbc8fdea5680", + "name": "distributed", + "sha256": "34ac48c9808c7af34e4f60fc8ec5d8866807115acd8a3e811343335c12ee59a0", + "size": 1685969, + "subdir": "linux-64", + "timestamp": 1680104413719, + "version": "2023.3.2" + }, + "distributed-2023.3.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=8.0", + "cloudpickle >=1.5.0", + "dask-core 2023.3.2.*", + "jinja2 >=2.10.3", + "locket >=1.0.0", + "msgpack-python >=1.0.0", + "packaging >=20.0", + "psutil >=5.7.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.3.1", + "sortedcontainers >=2.0.5", + "tblib >=1.6.0", + "toolz >=0.10.0", + "tornado >=6.0.3", + "urllib3 >=1.24.3", + "zict >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ecf9736a53e399d48037e1a86d43eb16", + "name": "distributed", + "sha256": "9ae209cee677136ac369f75bccbabaee80739d207f48f4beb06d9f90813d89d8", + "size": 1353819, + "subdir": "linux-64", + "timestamp": 1680104530237, + "version": "2023.3.2" + }, + "distributed-2023.3.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=8.0", + "cloudpickle >=1.5.0", + "dask-core 2023.3.2.*", + "jinja2 >=2.10.3", + "locket >=1.0.0", + "msgpack-python >=1.0.0", + "packaging >=20.0", + "psutil >=5.7.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.3.1", + "sortedcontainers >=2.0.5", + "tblib >=1.6.0", + "toolz >=0.10.0", + "tornado >=6.0.3", + "urllib3 >=1.24.3", + "zict >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a0a9986cb9191cbb70d8a1d0861a0a41", + "name": "distributed", + "sha256": "038d9d0b58477f923932a051b80e0898b8eb3d8029c33e2fdb7967c92e83f7b7", + "size": 1355842, + "subdir": "linux-64", + "timestamp": 1680104451788, + "version": "2023.3.2" + }, + "django-1.11.10-py27hd476221_0.tar.bz2": { + "build": "py27hd476221_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "9d5dc264eb7eea5b1090c67c13ee169a", + "name": "django", + "sha256": "2af514dd85fc8445b34ea061c353bdc0a1c2838498801478d32e7ca725bfbc2b", + "size": 4793701, + "subdir": "linux-64", + "timestamp": 1519060827525, + "version": "1.11.10" + }, + "django-1.11.10-py35hd476221_0.tar.bz2": { + "build": "py35hd476221_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "8213aa8ffc8818906a4f0189a0cbacaa", + "name": "django", + "sha256": "0ab8ecc83be78a202a64b7f063e7fb94b4d6253d5eb04d6dd31821e3e3a46e00", + "size": 4844059, + "subdir": "linux-64", + "timestamp": 1519060864484, + "version": "1.11.10" + }, + "django-1.11.10-py36hd476221_0.tar.bz2": { + "build": "py36hd476221_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "bd6384bc9135b33dee0e9fe0f2fee341", + "name": "django", + "sha256": "2b26f3cc3947be958f1b1ffbd84a938a60d5d0436c990a702cafd16267a7315d", + "size": 4843658, + "subdir": "linux-64", + "timestamp": 1519060880465, + "version": "1.11.10" + }, + "django-1.11.8-py27hd476221_0.tar.bz2": { + "build": "py27hd476221_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "a2be5b5d4d469ea524f44dfe7fc538a8", + "name": "django", + "sha256": "4c86df3df3bd8b7793d79370f6ff7fec025c1eb9b864380c6a7d423f8dfcab47", + "size": 4792102, + "subdir": "linux-64", + "timestamp": 1512622372331, + "version": "1.11.8" + }, + "django-1.11.8-py35hd476221_0.tar.bz2": { + "build": "py35hd476221_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "a746a49bd5421bd74c71faf7a458c3e7", + "name": "django", + "sha256": "d7122f6917b87c6bbe5c980c8e76bce2f4a0ab01bcbbeabfc0a0fbd1f90a0443", + "size": 4846382, + "subdir": "linux-64", + "timestamp": 1512622421913, + "version": "1.11.8" + }, + "django-1.11.8-py36hd476221_0.tar.bz2": { + "build": "py36hd476221_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "af6a4722f305e0c8e6bb3029bb2b17db", + "name": "django", + "sha256": "2deae4a89951281b608f2fbb565122f2d39b651a7ca8351eef0ff27a02985706", + "size": 4842574, + "subdir": "linux-64", + "timestamp": 1512622430154, + "version": "1.11.8" + }, + "django-2.0.2-py35hd476221_0.tar.bz2": { + "build": "py35hd476221_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "6ce532ca2eea99b72a9d5b2d449dac62", + "name": "django", + "sha256": "3b30f1f0f0d8c85b5bd3218e892f75b7f0df202f23e08563d0b547eed3f10fa4", + "size": 4895306, + "subdir": "linux-64", + "timestamp": 1519065539898, + "version": "2.0.2" + }, + "django-2.0.2-py36hd476221_0.tar.bz2": { + "build": "py36hd476221_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "a85545d445b09363bf21d78b16ef9fff", + "name": "django", + "sha256": "98eb0f09b5125612d1e8d18385c073fb7b993819a84554102bb9901338af7531", + "size": 4886198, + "subdir": "linux-64", + "timestamp": 1519065537135, + "version": "2.0.2" + }, + "django-2.0.5-py35hd476221_0.tar.bz2": { + "build": "py35hd476221_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "a2caeeec2771ca9ae7e3d24293228d30", + "name": "django", + "sha256": "11789f7aed09504e44295feda6a4e5d0b9fba0f5062085d9e783dddd5168e502", + "size": 4901960, + "subdir": "linux-64", + "timestamp": 1526134119445, + "version": "2.0.5" + }, + "django-2.0.5-py36hd476221_0.tar.bz2": { + "build": "py36hd476221_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "3e8f307aa76d52513fc2c74179940f5d", + "name": "django", + "sha256": "0cda91c052a017f463887f97c2cb79fbb5ac5ce1ff99c2c37e2f24226196bf42", + "size": 4888747, + "subdir": "linux-64", + "timestamp": 1526134042776, + "version": "2.0.5" + }, + "django-2.0.5-py37hd476221_0.tar.bz2": { + "build": "py37hd476221_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "6c5b92cd79b47cb5eb978e5ae9cb0139", + "name": "django", + "sha256": "b35607aab825e5a4b1fd3e5074f653f97ddffa49c126e4a3910c3fc265688221", + "size": 4887374, + "subdir": "linux-64", + "timestamp": 1530873331375, + "version": "2.0.5" + }, + "django-2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "93bb3ae1b8f813592135d48ef04e7a0b", + "name": "django", + "sha256": "9cb2d6337f34dc4c6765533197f685c9c0909b807424f2082139b5d65a1b46de", + "size": 5050028, + "subdir": "linux-64", + "timestamp": 1534392770985, + "version": "2.1" + }, + "django-2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "7efb6b6fffbf77b86feff907288aa5cf", + "name": "django", + "sha256": "c055b37f3012963f5caf7926ea9b7291ffbe95e9abe97f2b379acc5d5e3e975f", + "size": 5043851, + "subdir": "linux-64", + "timestamp": 1534392493185, + "version": "2.1" + }, + "django-2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "34bdd2f2834ee25031312a84b65e54d3", + "name": "django", + "sha256": "e00f721dcf32b735e5e1ad270f29bde25bfd0c2308839ab1a98d4b67ceb16bf9", + "size": 5044148, + "subdir": "linux-64", + "timestamp": 1534392512940, + "version": "2.1" + }, + "django-2.1.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "686954d9d2a88638fcf46bc0a0022a08", + "name": "django", + "sha256": "dfec00852f11fc99765a3ecef68fff41344a2d4bf6d0b675a7bb4dec73e2568c", + "size": 5051329, + "subdir": "linux-64", + "timestamp": 1536528853747, + "version": "2.1.1" + }, + "django-2.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "3a6e13b48ffbe589082208dc9e5fe29c", + "name": "django", + "sha256": "2536173c7d233386ab6ef6516ecb3ec32ad6b1fe5cf80ab7a1cba831321ad902", + "size": 5045220, + "subdir": "linux-64", + "timestamp": 1536528896296, + "version": "2.1.1" + }, + "django-2.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "0cb6b92922e7b4631ae16f31cb636e12", + "name": "django", + "sha256": "f3c7cfa0b7210a6e6d05812da398ee464973f812ec19fc059c4eb1a3a76764a2", + "size": 5045176, + "subdir": "linux-64", + "timestamp": 1536528805364, + "version": "2.1.1" + }, + "django-2.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "5d04b0310fdc81cf68b2e332c52e0d58", + "name": "django", + "sha256": "69854c656f087b7035f2b264b162bc15a75a24cf1bdc3f24b49f6a6bdbf9099b", + "size": 5064632, + "subdir": "linux-64", + "timestamp": 1539474674331, + "version": "2.1.2" + }, + "django-2.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "bc92441e3b8574f204e4457e890372ce", + "name": "django", + "sha256": "8dd2c6590067ea019c060433e857c3c523acb030515bc90e58323d5f24b611fc", + "size": 5064862, + "subdir": "linux-64", + "timestamp": 1539474702840, + "version": "2.1.2" + }, + "django-2.1.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "936fa7adcb3f482a91f2db0c8b93622b", + "name": "django", + "sha256": "57bbe01c038fc5ad5f9f1ce815323a5ac6103637e4bf59919459a80c8567a157", + "size": 4599880, + "subdir": "linux-64", + "timestamp": 1545092380357, + "version": "2.1.4" + }, + "django-2.1.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "52f1fea794da6ab8d01b4ef45c658f29", + "name": "django", + "sha256": "904188509e538a9484bf0e7cccee7716e403b14e5c60411e745f98bb3032ef13", + "size": 4584644, + "subdir": "linux-64", + "timestamp": 1545092402480, + "version": "2.1.4" + }, + "django-2.1.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "8c617115ea1640138a3062853e3eaf8a", + "name": "django", + "sha256": "7e9cd34a3ab4240aecd53e5f56dbdd9a26bdf8b8464f785703705b322152b585", + "size": 4614675, + "subdir": "linux-64", + "timestamp": 1547227052732, + "version": "2.1.5" + }, + "django-2.1.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "fb7eb7b5edf56216fa264b370586ba14", + "name": "django", + "sha256": "86e8108d3ce85324e3134c1f7356a8733dddee7e346abaceb3f8b991d2257bb5", + "size": 4589916, + "subdir": "linux-64", + "timestamp": 1547227053379, + "version": "2.1.5" + }, + "django-2.1.7-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "301505153ec49bf520edca4b834dcc7a", + "name": "django", + "sha256": "7dbb3d96b5f5580f007258d586a30778c13284fc97d088f6401ba6f3663f933e", + "size": 4649529, + "subdir": "linux-64", + "timestamp": 1643016715330, + "version": "2.1.7" + }, + "django-2.1.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "a2f5149196d536a3cf59432e14db24b4", + "name": "django", + "sha256": "8dab214606e46b8f143250bbb314b6c46d9090fca7040a290ffc81e298d97f26", + "size": 4622324, + "subdir": "linux-64", + "timestamp": 1550269207413, + "version": "2.1.7" + }, + "django-2.1.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "d11695c36484f7f4490853f254bea623", + "name": "django", + "sha256": "c98b6a97f94a501ec72a6258614bb51a93b80f1df29c4c15e97d00b07d888d74", + "size": 4604894, + "subdir": "linux-64", + "timestamp": 1550269208239, + "version": "2.1.7" + }, + "django-2.1.7-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "b856b5783c2d768463aa596e39408447", + "name": "django", + "sha256": "61e8a4fce8deb549d98b42c26e092da1a06b257ecdd398302cfc02df91a3709b", + "size": 4609963, + "subdir": "linux-64", + "timestamp": 1636038994499, + "version": "2.1.7" + }, + "django-2.1.7-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "f546f1ff3225abc5d2290910cdf2b521", + "name": "django", + "sha256": "2b151168ec733e2485027520a96734407f0963e4ac0b2eca2208cee2f1bc0bf4", + "size": 4600058, + "subdir": "linux-64", + "timestamp": 1636039111532, + "version": "2.1.7" + }, + "django-2.1.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "95c68de56395e6f4ab04595aca71ed9c", + "name": "django", + "sha256": "4284e1d41ab378a11aa37848220804ad8e7f54eb254a2b072944769390409b87", + "size": 4605147, + "subdir": "linux-64", + "timestamp": 1636039111694, + "version": "2.1.7" + }, + "django-2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "c5d3e36efd4b750cd91f7365f897a3b7", + "name": "django", + "sha256": "ac3319cf8b2e750182d336c7338101865ebe9829da4dbc545f5e96425cef1801", + "size": 4840453, + "subdir": "linux-64", + "timestamp": 1556065071716, + "version": "2.2" + }, + "django-2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "f8c57dcffa64e7637de63f5ddd198d85", + "name": "django", + "sha256": "0e6eec7fb305b8aec021a5754e6a4e091858e248d8fc7a78ecbed81bfc1f3fa1", + "size": 4852802, + "subdir": "linux-64", + "timestamp": 1556064909334, + "version": "2.2" + }, + "django-2.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "8e59a7048ec4c940202b3497466ed1ad", + "name": "django", + "sha256": "f7499f3a77e88cfcb084845fb73b5a75e18f9dc60e14eb7851e58719433ffd95", + "size": 4868411, + "subdir": "linux-64", + "timestamp": 1559141050239, + "version": "2.2.1" + }, + "django-2.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "b71a1440b625f01bbc7ab61d3e0d4058", + "name": "django", + "sha256": "87f87c5553f6337ae743d6564979dc3ceef286fcbf412faaffdf79c2e46fdf27", + "size": 4884594, + "subdir": "linux-64", + "timestamp": 1559140863009, + "version": "2.2.1" + }, + "django-2.2.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "3e8fcc791a0464593769baf6c6b915e4", + "name": "django", + "sha256": "f177d0321feec797d78e66132749a1a573231ce3e35d3acdf4be4da575e0f252", + "size": 4899399, + "subdir": "linux-64", + "timestamp": 1569343485048, + "version": "2.2.5" + }, + "django-2.2.5-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "sqlparse" + ], + "license": "BSD 3-Clause", + "md5": "0666b99cd71c4f3c1de37a032753b6c7", + "name": "django", + "sha256": "6e087e3a16cd6b2b7bebd89cc62e621c4cbb0753668b9de58d4367756c37124f", + "size": 4900377, + "subdir": "linux-64", + "timestamp": 1569445764636, + "version": "2.2.5" + }, + "django-2.2.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "fb44b404a9253701e7e7309dfb0a7c34", + "name": "django", + "sha256": "73dc582b567201eb3a8c42d1dc2b659601df1a1be20c0185a881c690dc9a034f", + "size": 4873250, + "subdir": "linux-64", + "timestamp": 1569343469508, + "version": "2.2.5" + }, + "django-2.2.5-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz", + "sqlparse" + ], + "license": "BSD 3-Clause", + "md5": "b2a298bec6d6111aa8ef1e54f5d956ff", + "name": "django", + "sha256": "63daabb88cadcc5b10ac338a153520b134bd1959e879e03fec8926edc8811faf", + "size": 4862303, + "subdir": "linux-64", + "timestamp": 1569445790216, + "version": "2.2.5" + }, + "django-2.2.5-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz", + "sqlparse" + ], + "license": "BSD 3-Clause", + "md5": "fbfba18e8997f66cc94c1b7f1b479a26", + "name": "django", + "sha256": "5528f02e677417efedfcf0466c4c1172e069aa9bbc644965af539bf0779c875d", + "size": 4873323, + "subdir": "linux-64", + "timestamp": 1573741654987, + "version": "2.2.5" + }, + "django-3.2.15-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.3.2,<4", + "psycopg2", + "python >=3.10,<3.11.0a0", + "pytz", + "sqlparse >=0.2.2" + ], + "license": "BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "c6267dd7fbe7c6446b2999f31a0d9b7f", + "name": "django", + "sha256": "e9f031bb6dceb2d64420076db1ed7f58e3ed3ec9933d1c020b32244f1d3d7d89", + "size": 5216270, + "subdir": "linux-64", + "timestamp": 1661284412514, + "version": "3.2.15" + }, + "django-3.2.15-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.3.2,<4", + "psycopg2", + "python >=3.7,<3.8.0a0", + "pytz", + "sqlparse >=0.2.2" + ], + "license": "BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "99a079becdc5e45b0ce09c3b33cceaf3", + "name": "django", + "sha256": "d25360baf03eaf670d8bd07058f755e1e32379c812facf4caa33ae9398060074", + "size": 5174706, + "subdir": "linux-64", + "timestamp": 1661284339889, + "version": "3.2.15" + }, + "django-3.2.15-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.3.2,<4", + "psycopg2", + "python >=3.8,<3.9.0a0", + "pytz", + "sqlparse >=0.2.2" + ], + "license": "BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "fe86d4181ae0212e5a8391b9d8c925f0", + "name": "django", + "sha256": "dbaf135e028e176c3eb63ae59f16d96139f48df19ff24045bb05a273bcd7538d", + "size": 5186888, + "subdir": "linux-64", + "timestamp": 1661284282561, + "version": "3.2.15" + }, + "django-3.2.15-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.3.2,<4", + "psycopg2", + "python >=3.9,<3.10.0a0", + "pytz", + "sqlparse >=0.2.2" + ], + "license": "BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "cb6018034071e4e41444b19d569575f9", + "name": "django", + "sha256": "8a98326583c0c599f88692824747285bbc456e27c48a36eb024a91f6c837aa88", + "size": 5189937, + "subdir": "linux-64", + "timestamp": 1661284473426, + "version": "3.2.15" + }, + "django-4.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.5.2,<4", + "python >=3.10,<3.11.0a0", + "sqlparse >=0.2.2" + ], + "license": "BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "5b63b572a0504e776f62cea0487de3b0", + "name": "django", + "sha256": "1e8a323e7c036bba45ce52006e9b2108abf1b212a41645a16540f23895d39c9e", + "size": 5360715, + "subdir": "linux-64", + "timestamp": 1661296507042, + "version": "4.1" + }, + "django-4.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.5.2,<4", + "python >=3.11,<3.12.0a0", + "sqlparse >=0.2.2" + ], + "license": "BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "8e3ca6409b1d4540f47a91f01b501136", + "name": "django", + "sha256": "b0038efbf4ec3741b721e3012a8e88f3e4d73cea9a487327172a432accc0e6e3", + "size": 6113485, + "subdir": "linux-64", + "timestamp": 1676851960213, + "version": "4.1" + }, + "django-4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.5.2,<4", + "backports.zoneinfo", + "python >=3.8,<3.9.0a0", + "sqlparse >=0.2.2" + ], + "license": "BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "4816bfc8fb4109906b1e9e0f891356be", + "name": "django", + "sha256": "112d700610afd79720f57c3729b858da67abc4c6daa67dec5bf2dab33e02c12c", + "size": 5330546, + "subdir": "linux-64", + "timestamp": 1661296433754, + "version": "4.1" + }, + "django-4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.5.2,<4", + "python >=3.9,<3.10.0a0", + "sqlparse >=0.2.2" + ], + "license": "BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "945ecfb1d4a206c879a340a0550f28f3", + "name": "django", + "sha256": "3069b08308ab4664a5d70330a0857f83bbd238de72d005e6cb07cb657c4abd12", + "size": 5345740, + "subdir": "linux-64", + "timestamp": 1661296566572, + "version": "4.1" + }, + "dlpack-0.3-he6710b0_1.tar.bz2": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0510f1efb448528d23d2ed28677909ca", + "name": "dlpack", + "sha256": "36322f3c2fdf421a9c59b5f5cc6745bfcad917a2ab7a93fd76271387aabdc0e7", + "size": 1165081, + "subdir": "linux-64", + "timestamp": 1600691800051, + "version": "0.3" + }, + "dm-tree-0.1.5-py310h00e6091_2.tar.bz2": { + "build": "py310h00e6091_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "six >=1.12.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6eecdbc968c8068277dad54cead7b855", + "name": "dm-tree", + "sha256": "8aef967d7d9842c83f9b9872200e04810649e9dc690ed3ee3c83d85e63479bd9", + "size": 110540, + "subdir": "linux-64", + "timestamp": 1640789606166, + "version": "0.1.5" + }, + "dm-tree-0.1.5-py36h51133e4_0.tar.bz2": { + "build": "py36h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "six >=1.12.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b41b39e20d4529718a3d673a9a3031f6", + "name": "dm-tree", + "sha256": "9be2106287d32a8e780b5f7e37f410be7aa17592b0f016d1b11f5a6c33e875cb", + "size": 111880, + "subdir": "linux-64", + "timestamp": 1633012179579, + "version": "0.1.5" + }, + "dm-tree-0.1.5-py37h51133e4_0.tar.bz2": { + "build": "py37h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "six >=1.12.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d5d537e1bcc4a58f7706b7395517ec5e", + "name": "dm-tree", + "sha256": "7948bf7f2404f9beec8d2417ff298cc079d7da3d1293c2ed60c999c1513df9db", + "size": 111495, + "subdir": "linux-64", + "timestamp": 1633001684175, + "version": "0.1.5" + }, + "dm-tree-0.1.5-py38h51133e4_0.tar.bz2": { + "build": "py38h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "six >=1.12.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "97bcf2e0fe6c5ed7866ffe70534dc5c8", + "name": "dm-tree", + "sha256": "b9bdd185711439cc0a831d7614fe5b84eaac61255627a1aa45f95cc785b501f6", + "size": 111804, + "subdir": "linux-64", + "timestamp": 1633012155009, + "version": "0.1.5" + }, + "dm-tree-0.1.5-py39h51133e4_0.tar.bz2": { + "build": "py39h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "six >=1.12.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e2353481d322c8d1f559c18374891e91", + "name": "dm-tree", + "sha256": "e624184e0db9cd51471d09c33505a68ac27341a720a1ee79ec0ac5119078fc4f", + "size": 111862, + "subdir": "linux-64", + "timestamp": 1633012155467, + "version": "0.1.5" + }, + "dm-tree-0.1.7-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "22308539b8845f33172d49c522c4dbba", + "name": "dm-tree", + "sha256": "f1995f4746d75e108eb0784c21eeb672f7cd8975c6d56882c4609cda58fa4f9e", + "size": 153647, + "subdir": "linux-64", + "timestamp": 1669819840455, + "version": "0.1.7" + }, + "dm-tree-0.1.7-py310h6a678d5_1.tar.bz2": { + "build": "py310h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8673bc43d8c6c00de861764f0ceee73b", + "name": "dm-tree", + "sha256": "1c988fc6f0cfb2674217944cf9bc289b709dc81022fb6f13aac3c6203be6f5a2", + "size": 160091, + "subdir": "linux-64", + "timestamp": 1671027591718, + "version": "0.1.7" + }, + "dm-tree-0.1.7-py311h6a678d5_1.tar.bz2": { + "build": "py311h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0acd39155aa1c93c96d7f291479eeb16", + "name": "dm-tree", + "sha256": "3065f9d24cca534bde360c983713f6107b77cd490d13df815289f7729882d37c", + "size": 174940, + "subdir": "linux-64", + "timestamp": 1676839767491, + "version": "0.1.7" + }, + "dm-tree-0.1.7-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fe1898e3748fd4d92c1631eef594b292", + "name": "dm-tree", + "sha256": "cbfd6b8cb757c95298c5981395cd8f63ab2d612749fbc4ea0625b57d3d20d730", + "size": 153276, + "subdir": "linux-64", + "timestamp": 1669819762699, + "version": "0.1.7" + }, + "dm-tree-0.1.7-py37h6a678d5_1.tar.bz2": { + "build": "py37h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0d80dc2e69c96403c2880ac71e0fef77", + "name": "dm-tree", + "sha256": "33096da5c377b2d3d2710d85c2697a1e415294de6665c2e8f821394b54ec9464", + "size": 161080, + "subdir": "linux-64", + "timestamp": 1671027515947, + "version": "0.1.7" + }, + "dm-tree-0.1.7-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b75de21a57f57de9d6e8a379e049612b", + "name": "dm-tree", + "sha256": "719960b8dd1752674adab671274505f0b092e77a384c3f965bf64e4dad4b6198", + "size": 153291, + "subdir": "linux-64", + "timestamp": 1669819986023, + "version": "0.1.7" + }, + "dm-tree-0.1.7-py38h6a678d5_1.tar.bz2": { + "build": "py38h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cf53d42c7f94facc303cc7b9e7754583", + "name": "dm-tree", + "sha256": "84ea3269eee3e522467d882f88f7066eb657704e2af43f99887517c2a1bb396e", + "size": 159843, + "subdir": "linux-64", + "timestamp": 1671027665000, + "version": "0.1.7" + }, + "dm-tree-0.1.7-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7ecc9f11ed16b2abe63ee804f2ddc4ed", + "name": "dm-tree", + "sha256": "39ebc5c6024fbd046ca1b755a0cbcd1d7b8dc43b8079c3d59b7b93adff84e6c9", + "size": 153663, + "subdir": "linux-64", + "timestamp": 1669819913001, + "version": "0.1.7" + }, + "dm-tree-0.1.7-py39h6a678d5_1.tar.bz2": { + "build": "py39h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "89594264aef7981622597e48a1d48845", + "name": "dm-tree", + "sha256": "4c76a9db483a3cb128446919d29fd9e09693a78b1c58e45a771e1e908ede16e9", + "size": 160050, + "subdir": "linux-64", + "timestamp": 1671027736286, + "version": "0.1.7" + }, + "dnspython-1.15.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "a02c376b1b1715c214e92b0e3ddbc984", + "name": "dnspython", + "sha256": "a4f9c10dceae4d877727d8d2cd1cae146315aecc7bb8323fc360c5ee0d038292", + "size": 178393, + "subdir": "linux-64", + "timestamp": 1530873383534, + "version": "1.15.0" + }, + "dnspython-1.15.0-py27h8b108a9_0.tar.bz2": { + "build": "py27h8b108a9_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "26995cdd85119cfac84bb45d306ba6b5", + "name": "dnspython", + "sha256": "fa317e4ef0ed5592fde7ec8783fb27c69d085f595c5410886d2140d9a78b67e4", + "size": 178499, + "subdir": "linux-64", + "timestamp": 1507930516067, + "version": "1.15.0" + }, + "dnspython-1.15.0-py35h312e5ef_0.tar.bz2": { + "build": "py35h312e5ef_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "e2e7dc9af9ea6aff2efee236267020fb", + "name": "dnspython", + "sha256": "2dbbb5fa2b26ece7d7b8762dc81f92965e04cfd9983a322fe05f4e3d2c7246ca", + "size": 181425, + "subdir": "linux-64", + "timestamp": 1507930526818, + "version": "1.15.0" + }, + "dnspython-1.15.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "956f0ae43375454407f0c39eea61beb4", + "name": "dnspython", + "sha256": "a3103668e01556fb8103dcac9136b6f86769440e55a5e0cfac3f821f9c0c16d6", + "size": 178110, + "subdir": "linux-64", + "timestamp": 1530873446943, + "version": "1.15.0" + }, + "dnspython-1.15.0-py36h3d718be_0.tar.bz2": { + "build": "py36h3d718be_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "65bc09b43ce97b91b5d0ac3c121f858f", + "name": "dnspython", + "sha256": "701dfba326d85156a731577d795acee654053ca8fdf2a3eca8d5ec6e6a987ad2", + "size": 178387, + "subdir": "linux-64", + "timestamp": 1507930522450, + "version": "1.15.0" + }, + "dnspython-1.15.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "3a8d786a9b6ef02c504ce15ffa03300b", + "name": "dnspython", + "sha256": "10afc550c65c062837063f0a4a21abe14aa1c1f757fe62c8f9e12637c2e10842", + "size": 178590, + "subdir": "linux-64", + "timestamp": 1530873414487, + "version": "1.15.0" + }, + "dnspython-1.16.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "c0c5e56b9b513980c124766aab179c5a", + "name": "dnspython", + "sha256": "1d1f6b02717307af829c471869855e49225d2f9553460be1b4be3115cea91551", + "size": 190936, + "subdir": "linux-64", + "timestamp": 1545108849100, + "version": "1.16.0" + }, + "dnspython-1.16.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "14e3056212457eea67830da5a849cb0d", + "name": "dnspython", + "sha256": "d0f77923fdf3e0abda679b7b30b42a84ff9af14744ba056057d373962a603884", + "size": 190333, + "subdir": "linux-64", + "timestamp": 1640789625020, + "version": "1.16.0" + }, + "dnspython-1.16.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "279a85e8fbd44796cd0babab3b15afc4", + "name": "dnspython", + "sha256": "6087dd22b531129ab35d53b15d7733a30a60b44eb87f5def57dc25262ae70984", + "size": 189904, + "subdir": "linux-64", + "timestamp": 1545108880429, + "version": "1.16.0" + }, + "dnspython-1.16.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "c8c364a490f24f9fb3be5f5f4e8a0b48", + "name": "dnspython", + "sha256": "3b52a9042a8bd456738b18d008ac6b044a0ffe79bb2c48179b60d2e4617cdf6c", + "size": 190152, + "subdir": "linux-64", + "timestamp": 1545108882971, + "version": "1.16.0" + }, + "dnspython-1.16.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "ae01a4c6be103f3da73004422cddae7c", + "name": "dnspython", + "sha256": "6df7c2dcc9792d5a24acf565a2db1866d95ab549366d595ba011620e7d1adf87", + "size": 188254, + "subdir": "linux-64", + "timestamp": 1572357222416, + "version": "1.16.0" + }, + "dnspython-1.16.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "01251fac0dd5bd8c90dce41cd5b454d8", + "name": "dnspython", + "sha256": "76e78f7a7eb06e941151d7138ae11f8ce46bec04c7a4014c295c8917fcf838ed", + "size": 190305, + "subdir": "linux-64", + "timestamp": 1607007510972, + "version": "1.16.0" + }, + "dnspython-2.2.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6", + "idna >=2.1", + "python >=3.10,<3.11.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "8db922ba0a0c28e29404b7b92eead178", + "name": "dnspython", + "sha256": "8e8ff310df675bdfc9d03bd04928037359116cc741181e13aa5f501a310ee47f", + "size": 305391, + "subdir": "linux-64", + "timestamp": 1659712703431, + "version": "2.2.1" + }, + "dnspython-2.2.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6", + "idna >=2.1", + "python >=3.11,<3.12.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "be996dcd0c8ee30e05ab1538f1404ae8", + "name": "dnspython", + "sha256": "c2fa6d98d3f791e0f1b0e8cf84c394c09f7201eb204d82fe59287c3157f87a89", + "size": 392421, + "subdir": "linux-64", + "timestamp": 1676903920576, + "version": "2.2.1" + }, + "dnspython-2.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6", + "idna >=2.1", + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "60167031556af2278f0a7a0fd59e1e8a", + "name": "dnspython", + "sha256": "e6c8a6d28aa07e16bdf1d6786854879b8c69036c50f4a4485dadf5c8b5d89589", + "size": 299683, + "subdir": "linux-64", + "timestamp": 1659712760311, + "version": "2.2.1" + }, + "dnspython-2.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6", + "idna >=2.1", + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "4d4241423a69c6eba38c07d219ca224e", + "name": "dnspython", + "sha256": "4fc3102787db8c0634fdaaef4617f6d709caebdcf5f5589edb9e3eebb1ae46a0", + "size": 300874, + "subdir": "linux-64", + "timestamp": 1659712665340, + "version": "2.2.1" + }, + "dnspython-2.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6", + "idna >=2.1", + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "2ee4e11fdfeb770202cc62c291f38ef9", + "name": "dnspython", + "sha256": "0ba266582975fc353ff23f86329425bc1f2bc2cbd5101ef94c188e1be82593c3", + "size": 300667, + "subdir": "linux-64", + "timestamp": 1659712731261, + "version": "2.2.1" + }, + "docker-py-3.5.1-py27_1001.tar.bz2": { + "build": "py27_1001", + "build_number": 1001, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "enum34 >=1.1.6", + "idna >=2.5", + "ipaddress >=1.0.18", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "ssl_match_hostname >=3.5", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "952e220e1e6da5a65fd42e06bb200f20", + "name": "docker-py", + "sha256": "df4f0a6139e9e48260ff6a55e8eb55906f04e89d70f52f5a429c0c212c4ac8f3", + "size": 157620, + "subdir": "linux-64", + "timestamp": 1545410038433, + "version": "3.5.1" + }, + "docker-py-3.5.1-py36_1001.tar.bz2": { + "build": "py36_1001", + "build_number": 1001, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "d5b3544ccb59a4abe89b768e6ab13d89", + "name": "docker-py", + "sha256": "71c1b23cc55990a7a28d6ea6325ae5bca38d095b947035d734b7fba323671481", + "size": 160361, + "subdir": "linux-64", + "timestamp": 1545410089858, + "version": "3.5.1" + }, + "docker-py-3.5.1-py37_1001.tar.bz2": { + "build": "py37_1001", + "build_number": 1001, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "4a7d542b7a14ac5dcea082df904cfc8c", + "name": "docker-py", + "sha256": "404dd2a934c45efa8cac33a6347e66a3b248d80b567c977d05ec76602b7d3772", + "size": 160543, + "subdir": "linux-64", + "timestamp": 1545410492704, + "version": "3.5.1" + }, + "docker-py-4.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "enum34 >=1.1.6", + "idna >=2.5", + "ipaddress >=1.0.18", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "ssl_match_hostname >=3.5", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "7f20db2e686895567ff520177efe0ec3", + "name": "docker-py", + "sha256": "a152cd48ef52372a0cf0c7d1aa49e57607e9970ecb1cb1e261a2e5681fc3c160", + "size": 182581, + "subdir": "linux-64", + "timestamp": 1558586739340, + "version": "4.0.1" + }, + "docker-py-4.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "14a9a0df9e99ef231d2e5f5a0f1f592a", + "name": "docker-py", + "sha256": "f0af31766cce85e4d7ab232c594eed69ecf4622fea7e3a759b96f27f6b477b16", + "size": 174917, + "subdir": "linux-64", + "timestamp": 1558586766913, + "version": "4.0.1" + }, + "docker-py-4.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "9041211abc3969bf0b7b508eae78b7bf", + "name": "docker-py", + "sha256": "9a30afe2efc8981280d95e243db216078ada3123ae925f2492afed4bdf8fac23", + "size": 175117, + "subdir": "linux-64", + "timestamp": 1558586716513, + "version": "4.0.1" + }, + "docker-py-4.0.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "fa199f7f3337ff71f35553a239301e5b", + "name": "docker-py", + "sha256": "29ca883889a57cee841fb335d52635d136d8059b7adae7e7cbd2812ceb7ca7f4", + "size": 171907, + "subdir": "linux-64", + "timestamp": 1574238527586, + "version": "4.0.1" + }, + "docker-py-4.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "enum34 >=1.1.6", + "idna >=2.5", + "ipaddress >=1.0.18", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "ssl_match_hostname >=3.5", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "c5e895bdf3f408a5fd6c603480cd075d", + "name": "docker-py", + "sha256": "e00407d3ee7383faf7b1dc84174e0082a187c1b6c5573b804c75200b994c7ae4", + "size": 184160, + "subdir": "linux-64", + "timestamp": 1564162208438, + "version": "4.0.2" + }, + "docker-py-4.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "8fe235d7d019d9ad7ae95340f6dea298", + "name": "docker-py", + "sha256": "d78824be399372b334cb40ffb66a124bf3d724f1b2d1a0b2bc783f7b9d6631db", + "size": 175783, + "subdir": "linux-64", + "timestamp": 1564162214690, + "version": "4.0.2" + }, + "docker-py-4.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "040a62501e9db3c8ee781dd9fbe04ca9", + "name": "docker-py", + "sha256": "a50e021ce4ef6707c443e632273fb82ce06c392775bd7b480ea0c3eacff4ad9c", + "size": 175537, + "subdir": "linux-64", + "timestamp": 1564162205989, + "version": "4.0.2" + }, + "docker-py-4.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "06cf3934178ecaf0696efb666cc7ad78", + "name": "docker-py", + "sha256": "3aa53c979c46e94e537732ce10f79307b523475da1a4a56673e4545e254bf695", + "size": 184265, + "subdir": "linux-64", + "timestamp": 1585132641633, + "version": "4.2.0" + }, + "docker-py-4.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "2319e235af616848fe04a396ec202d45", + "name": "docker-py", + "sha256": "b94a0653464e1434ce831cec6ae82fe36cbc4d85969c1e786d6507bf7c6627d5", + "size": 192711, + "subdir": "linux-64", + "timestamp": 1585132634165, + "version": "4.2.0" + }, + "docker-py-4.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "025d3308504862b6c45511c752855b35", + "name": "docker-py", + "sha256": "9311f80b7e1aec2ed9b8ea696129709fddf74e59743a5f572da2f3a19794625e", + "size": 191252, + "subdir": "linux-64", + "timestamp": 1585132635864, + "version": "4.2.0" + }, + "docker-py-4.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "de3ce048d4dc39ae54ac249e6cd3494d", + "name": "docker-py", + "sha256": "7f117c214d1ef09ca72c139edc91aec3e8c48664c6aa4bc9e1bf603e1f8b1d03", + "size": 184840, + "subdir": "linux-64", + "timestamp": 1591789200110, + "version": "4.2.1" + }, + "docker-py-4.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "e2de87402a098d50855b4649e606fa68", + "name": "docker-py", + "sha256": "46c68b2a2131b14e5aa214a3a1e58776639c4513b04e585a4422fd50ddeaa64a", + "size": 193067, + "subdir": "linux-64", + "timestamp": 1591789195055, + "version": "4.2.1" + }, + "docker-py-4.2.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "c095cf9db265937e9b8a62a3e23ce303", + "name": "docker-py", + "sha256": "44a2d641a7415adcb8693ea9992b36068072e273cf175190d8549a286bd3d7eb", + "size": 191454, + "subdir": "linux-64", + "timestamp": 1591795855621, + "version": "4.2.1" + }, + "docker-py-4.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "3736bb4d817ad9cef4c0969e5a9a0dc9", + "name": "docker-py", + "sha256": "acf282948953c46840d21e7e07ab28ba96f0645a4997212f758cd775783c2d8a", + "size": 184300, + "subdir": "linux-64", + "timestamp": 1594350560469, + "version": "4.2.2" + }, + "docker-py-4.3.1-py36_4.tar.bz2": { + "build": "py36_4", + "build_number": 4, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "e87c7eebf3a8b3f740b88c2e361f82ab", + "name": "docker-py", + "sha256": "eb8a75e15526106986f59ef220d4e4c7a99250512462cbac67cfa63125dffb40", + "size": 197690, + "subdir": "linux-64", + "timestamp": 1599337685614, + "version": "4.3.1" + }, + "docker-py-4.3.1-py37_4.tar.bz2": { + "build": "py37_4", + "build_number": 4, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "3fc92bc2e349df3a269f4b5f936a1c93", + "name": "docker-py", + "sha256": "028bade07643fb0f79001f4f2cc93901c567f2dbb4e40ff13d6bc5989ecf2901", + "size": 199660, + "subdir": "linux-64", + "timestamp": 1599337700897, + "version": "4.3.1" + }, + "docker-py-4.3.1-py38_4.tar.bz2": { + "build": "py38_4", + "build_number": 4, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "8ae4751d03b87c41ca9e90e65f60d352", + "name": "docker-py", + "sha256": "8ddfd841523ebdfac44bc0201f31fe0aaa5a9d64b38a0e75d74509ad5cb18d6e", + "size": 200456, + "subdir": "linux-64", + "timestamp": 1599337688523, + "version": "4.3.1" + }, + "docker-py-4.4.0-py36h06a4308_4.tar.bz2": { + "build": "py36h06a4308_4", + "build_number": 4, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "ed399f1c77c6eef4e0fd5f933f380ad3", + "name": "docker-py", + "sha256": "385c97bfa66e346400196634c336306cb3dbab8bc8b6115b0baa825ca5822d93", + "size": 194056, + "subdir": "linux-64", + "timestamp": 1606144620655, + "version": "4.4.0" + }, + "docker-py-4.4.0-py37h06a4308_4.tar.bz2": { + "build": "py37h06a4308_4", + "build_number": 4, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "da97eb5d66c3a0fdc2c3352828f43086", + "name": "docker-py", + "sha256": "a3a4711c26a5316aac8abbab439ff90c8b4450336d40d33ee999c68f9ac8ed72", + "size": 192583, + "subdir": "linux-64", + "timestamp": 1606144634157, + "version": "4.4.0" + }, + "docker-py-4.4.0-py38h06a4308_4.tar.bz2": { + "build": "py38h06a4308_4", + "build_number": 4, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "69b2013b626cb11bada19ae60e75555e", + "name": "docker-py", + "sha256": "ced30bac4b9d002e7dcd53346164ed31307a780e1d5123bcbbb021b098492175", + "size": 194013, + "subdir": "linux-64", + "timestamp": 1606144637723, + "version": "4.4.0" + }, + "docker-py-4.4.1-py310h06a4308_5.tar.bz2": { + "build": "py310h06a4308_5", + "build_number": 5, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.10,<3.11.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "25fa2785a52404af768c004904ec0dfe", + "name": "docker-py", + "sha256": "e122180db73e2add5bdd8fadf476e167010a15876811efad7a90c0ee9678f895", + "size": 194485, + "subdir": "linux-64", + "timestamp": 1640811935219, + "version": "4.4.1" + }, + "docker-py-4.4.1-py311h06a4308_5.tar.bz2": { + "build": "py311h06a4308_5", + "build_number": 5, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.11,<3.12.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "1011a1363a4b8b29670818025528d5f0", + "name": "docker-py", + "sha256": "32c09b71b053bc67132834889eb225cbd3f320f992eca6466c3d2e87ebb030e5", + "size": 252189, + "subdir": "linux-64", + "timestamp": 1676844006193, + "version": "4.4.1" + }, + "docker-py-4.4.1-py36h06a4308_4.tar.bz2": { + "build": "py36h06a4308_4", + "build_number": 4, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "b107ca3f0c6ae93068ff11d55f6ef190", + "name": "docker-py", + "sha256": "1159a23c7e86a6b475f9da4c44aefdce0dc8423aa84ba766aba9b03bf4005d9c", + "size": 193654, + "subdir": "linux-64", + "timestamp": 1608758669823, + "version": "4.4.1" + }, + "docker-py-4.4.1-py36h06a4308_5.tar.bz2": { + "build": "py36h06a4308_5", + "build_number": 5, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "d05a66ce012a7af9d45a94f83e963ceb", + "name": "docker-py", + "sha256": "686ab0add9dfdf7fd2ca6386f7f55d6ed87beb05f227d3859314726e52e9a98a", + "size": 193406, + "subdir": "linux-64", + "timestamp": 1610480127783, + "version": "4.4.1" + }, + "docker-py-4.4.1-py37h06a4308_4.tar.bz2": { + "build": "py37h06a4308_4", + "build_number": 4, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "413de7d128103cc08d79072ef9a0114e", + "name": "docker-py", + "sha256": "800c127155c34da4a1f41714bdcd2748568817aa08b5fb74c7006f55eb5f4b94", + "size": 191546, + "subdir": "linux-64", + "timestamp": 1608758671791, + "version": "4.4.1" + }, + "docker-py-4.4.1-py37h06a4308_5.tar.bz2": { + "build": "py37h06a4308_5", + "build_number": 5, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "ee0bfc10ce8105854ca536b76c7a2ff2", + "name": "docker-py", + "sha256": "638e9e97b5b5b7fb2a575a904ae7f4476d3c481cb9d9f639a7f6a820e27b2ce6", + "size": 203902, + "subdir": "linux-64", + "timestamp": 1610480127473, + "version": "4.4.1" + }, + "docker-py-4.4.1-py38h06a4308_4.tar.bz2": { + "build": "py38h06a4308_4", + "build_number": 4, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "fdf1587a6d0277cde85cf06d42acd710", + "name": "docker-py", + "sha256": "4bfd97ec9c0725da7849212c369b14968adcc6eadae06989d531da34b7731121", + "size": 194302, + "subdir": "linux-64", + "timestamp": 1608758649951, + "version": "4.4.1" + }, + "docker-py-4.4.1-py38h06a4308_5.tar.bz2": { + "build": "py38h06a4308_5", + "build_number": 5, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "bea13a3935fe52ec5f264ae90e011032", + "name": "docker-py", + "sha256": "75be52cb8f61d50548e097a1f0e9e05e641ac1227e010b1fb5c294bf9b25a533", + "size": 206373, + "subdir": "linux-64", + "timestamp": 1610480106484, + "version": "4.4.1" + }, + "docker-py-4.4.1-py39h06a4308_5.tar.bz2": { + "build": "py39h06a4308_5", + "build_number": 5, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "1d35b9b58e71762c40d7abbf60f86764", + "name": "docker-py", + "sha256": "4a82bef67e1a1b9e86720581d86814cff554e2e42766583a8fcced8c7cb9f7e8", + "size": 205841, + "subdir": "linux-64", + "timestamp": 1614172017794, + "version": "4.4.1" + }, + "docopt-0.6.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "dd56352afdf166bb91f8db4e5fda35d1", + "name": "docopt", + "sha256": "5b57bec5d112528ff65a5a61d13ffabe70650780d97160581909c5f7853d8e4f", + "size": 21651, + "subdir": "linux-64", + "timestamp": 1525269585638, + "version": "0.6.2" + }, + "docopt-0.6.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "f61a6c02b96ccbc9de9a1d8f8c0ee736", + "name": "docopt", + "sha256": "d45b3a64929b4aa359ebf05b326f2aa3bce4497726168bb35fc232ba73bac2de", + "size": 22540, + "subdir": "linux-64", + "timestamp": 1640789642686, + "version": "0.6.2" + }, + "docopt-0.6.2-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "534d05f43f094089ceb9aaca78dfba51", + "name": "docopt", + "sha256": "347de8f2c6cb5aff5f06b8da12e914cd6df2dd5d0203e97717325239d4ece817", + "size": 24372, + "subdir": "linux-64", + "timestamp": 1663662506455, + "version": "0.6.2" + }, + "docopt-0.6.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "92c2aa3c60b7581cd6e1c5dae10fc44f", + "name": "docopt", + "sha256": "5d02541fef7d6706489d95d3a169176ffc82d1ac142be9ab30500baaf34e9d1c", + "size": 29084, + "subdir": "linux-64", + "timestamp": 1676839782278, + "version": "0.6.2" + }, + "docopt-0.6.2-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5629c9db4547fc544b69301aebc3e671", + "name": "docopt", + "sha256": "c57ca26c1ce6fdbbc95243414f8a392b5d7d7542f1621b1b00eb31e8a3d02e2f", + "size": 30700, + "subdir": "linux-64", + "timestamp": 1679335926250, + "version": "0.6.2" + }, + "docopt-0.6.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "dcd1566d745537845ab96e85e5bac670", + "name": "docopt", + "sha256": "b7ac5de749871f32f5aeaea1253bd11e22fe7b5bd36d58a25ffdb21ffaed3ffa", + "size": 22260, + "subdir": "linux-64", + "timestamp": 1525269636381, + "version": "0.6.2" + }, + "docopt-0.6.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1faa47bc40ce749e1aa8f8aa1346bd80", + "name": "docopt", + "sha256": "23c1850d7a3d6fbf60465864672dd66598bdbaffc797f4dc5578d931d4f616b0", + "size": 22186, + "subdir": "linux-64", + "timestamp": 1525269638315, + "version": "0.6.2" + }, + "docopt-0.6.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3080a51ead8669a01f472a0d466dd848", + "name": "docopt", + "sha256": "4c41ad983e2513980f3c19f0b3bcd2e9e884dbbc22dbdec9df98dbfe18d357bb", + "size": 23732, + "subdir": "linux-64", + "timestamp": 1611678708521, + "version": "0.6.2" + }, + "docopt-0.6.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "cdc3dcb3e5b777f3988e12800ae07a56", + "name": "docopt", + "sha256": "7b1ba0130f01bbe9a7afddcbe7a6bd928385ffa3e2b0236cba92edcd6599d750", + "size": 22061, + "subdir": "linux-64", + "timestamp": 1530922690073, + "version": "0.6.2" + }, + "docopt-0.6.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b900bec5b5ad5be5cf5f3c9651b21d9b", + "name": "docopt", + "sha256": "ecd0e11a879c2b2147eb331d8e6783b49e8af47a1e00744dd8207005a520d495", + "size": 23749, + "subdir": "linux-64", + "timestamp": 1611677549613, + "version": "0.6.2" + }, + "docopt-0.6.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90c6c3a6148e3ae5f0974a8d1b595a5f", + "name": "docopt", + "sha256": "7f07b8a1ba472961c1c47db6ca0d2da9047e65fda6350247eb6ba73b08ec9b0a", + "size": 24044, + "subdir": "linux-64", + "timestamp": 1663662469525, + "version": "0.6.2" + }, + "docopt-0.6.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "1bf8a244b80ba2789f0a259950b98adc", + "name": "docopt", + "sha256": "8c688f003b1b296dd9db8c136522f06a4273caf2542c12f7c6ec5a854c1396e9", + "size": 22520, + "subdir": "linux-64", + "timestamp": 1572435037754, + "version": "0.6.2" + }, + "docopt-0.6.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "eaffe40fc8464fb052552b360701e1fa", + "name": "docopt", + "sha256": "0719bbd843da3f37be8418e6977c3fc07764f2f2de905dab9761955364f3fc69", + "size": 23839, + "subdir": "linux-64", + "timestamp": 1611677526240, + "version": "0.6.2" + }, + "docopt-0.6.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "acb89546ef8c6ce1bb36beb13ef53cfb", + "name": "docopt", + "sha256": "32254856652317519fadd3f4ee0d3c1158180fe4530230f6cb012ca72505ff44", + "size": 24117, + "subdir": "linux-64", + "timestamp": 1663662530475, + "version": "0.6.2" + }, + "docopt-0.6.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "7e30f78ab2484e17f7b2512c4a62d5ce", + "name": "docopt", + "sha256": "3a8a557085917463c5a7d46d6ec6466ece0f15623cb0b644974965e79d004be3", + "size": 23782, + "subdir": "linux-64", + "timestamp": 1611677526883, + "version": "0.6.2" + }, + "docopt-0.6.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8998b0f79eaadb20bae150ce588bc6ad", + "name": "docopt", + "sha256": "15ef3348127c0dede17ba4acfe98506d3facc1a4e47fe24906696e3bac20c3de", + "size": 24104, + "subdir": "linux-64", + "timestamp": 1663662445070, + "version": "0.6.2" + }, + "docstring-to-markdown-0.11-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "abbc458d0517b13da8b955b3601ea92e", + "name": "docstring-to-markdown", + "sha256": "0aa47b479ee0072350ca12a61209d47ca11f62e1e304354e643cde7cbbab546f", + "size": 31773, + "subdir": "linux-64", + "timestamp": 1673447722014, + "version": "0.11" + }, + "docstring-to-markdown-0.11-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "af392de5265aa45c82bc21957ae361a0", + "name": "docstring-to-markdown", + "sha256": "d094e42cb284218472c1eeaa7de55c427359eb1cc0adc2209c0f36f1e6184d89", + "size": 37843, + "subdir": "linux-64", + "timestamp": 1676851986949, + "version": "0.11" + }, + "docstring-to-markdown-0.11-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "5e8bdab8c130ac0dc289a2e59cac35a7", + "name": "docstring-to-markdown", + "sha256": "e86fc12bdfea6ecc884a2b68f4a745b36ced85d4ec3d31fee59c3f28d70eb165", + "size": 31462, + "subdir": "linux-64", + "timestamp": 1673447747889, + "version": "0.11" + }, + "docstring-to-markdown-0.11-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "3939b6fe49cd62416dce754f94cf2cd4", + "name": "docstring-to-markdown", + "sha256": "c550c3ecd075e20a7eb026c018fe6c532d3ecb2c715b8355f12e29f88ed310da", + "size": 31617, + "subdir": "linux-64", + "timestamp": 1673447669554, + "version": "0.11" + }, + "docstring-to-markdown-0.11-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "beeecd02310f639ff787cd602dbf6e63", + "name": "docstring-to-markdown", + "sha256": "5c5fb5fdac4046783ae2c231656c0fae6770d85002b43e219d5b22c964898dbe", + "size": 31670, + "subdir": "linux-64", + "timestamp": 1673447695587, + "version": "0.11" + }, + "docutils-0.14-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "4b84ef5bf0d3572a66dca25161c0853c", + "name": "docutils", + "sha256": "6fdc5acc1b09233f06f6f701e2c42890eb010147a7193cdb61dd6e0fc7f3d909", + "size": 713475, + "subdir": "linux-64", + "timestamp": 1530695222343, + "version": "0.14" + }, + "docutils-0.14-py27hae222c1_0.tar.bz2": { + "build": "py27hae222c1_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "c4f57a590e4dbc832ad62ab8dd5ec3ac", + "name": "docutils", + "sha256": "974f62d49a3f4bc00087ef2f6ebdebeab2a5bb9e4b1e74a7745c95bfaec60749", + "size": 713493, + "subdir": "linux-64", + "timestamp": 1505741024841, + "version": "0.14" + }, + "docutils-0.14-py35hd11081d_0.tar.bz2": { + "build": "py35hd11081d_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "a0b43d4aac0b0d9e433cf28a424b3d5e", + "name": "docutils", + "sha256": "a10f507e799cd5f33460a65a9866e0db57513285f4365a9232e811bd62a1de75", + "size": 718775, + "subdir": "linux-64", + "timestamp": 1505741103169, + "version": "0.14" + }, + "docutils-0.14-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "1f245a6b7906b65960e62ee08e3cf790", + "name": "docutils", + "sha256": "7e0c5691e6a622a43cdc7c80fcaafe5259b9e2203002a39f1422583127d2d25d", + "size": 705502, + "subdir": "linux-64", + "timestamp": 1530695120404, + "version": "0.14" + }, + "docutils-0.14-py36hb0f60f5_0.tar.bz2": { + "build": "py36hb0f60f5_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "68d59617d31e9cde0e16b3c1862e3388", + "name": "docutils", + "sha256": "1cc004bc06230ff063cb0d7805730b58b514897d1664c183974be5d86f3963ca", + "size": 705022, + "subdir": "linux-64", + "timestamp": 1505741175245, + "version": "0.14" + }, + "docutils-0.14-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "b10a4cd47f42028389dbb4b778671339", + "name": "docutils", + "sha256": "bc48ed0049e2d74818574181259251af340d429dc210944a2f813c46e3036879", + "size": 704820, + "subdir": "linux-64", + "timestamp": 1530695197140, + "version": "0.14" + }, + "docutils-0.15.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "9f7da55d21bfb7714413e2189f3fead2", + "name": "docutils", + "sha256": "7b2e13f8fef07659dd4d97b5ba579257f0db5e8bb13d0c7ccb72cf17817c082b", + "size": 760717, + "subdir": "linux-64", + "timestamp": 1564162601364, + "version": "0.15.1" + }, + "docutils-0.15.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "76e49a263d7eef990775fac2c20f4d98", + "name": "docutils", + "sha256": "7cc05dea6a2edabe3e2dbfa12a680e345370d4e54815319397e47f09e0678e5f", + "size": 754760, + "subdir": "linux-64", + "timestamp": 1564162683057, + "version": "0.15.1" + }, + "docutils-0.15.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "80d838ceeed721b34311f90b6e64d5d0", + "name": "docutils", + "sha256": "15dfbabaa008cd87765bcef06e78658d1fcbe87b201be0008f1dd8526823c761", + "size": 759750, + "subdir": "linux-64", + "timestamp": 1565958413254, + "version": "0.15.2" + }, + "docutils-0.15.2-py310h06a4308_4.tar.bz2": { + "build": "py310h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "31278bc9396983a7f22cefab1a263914", + "name": "docutils", + "sha256": "5097442e4539eb4dce284d2a6c1817d97e7d3efd14775c51a0bdc3a4da56f558", + "size": 808222, + "subdir": "linux-64", + "timestamp": 1659506382491, + "version": "0.15.2" + }, + "docutils-0.15.2-py310h06a4308_5.tar.bz2": { + "build": "py310h06a4308_5", + "build_number": 5, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "3b17d44752a64856fa143f9930dcea9f", + "name": "docutils", + "sha256": "5c7dcec0f2fb55a2553f6a06683b215d41db001a4c6e504682426b7f0b74044d", + "size": 780604, + "subdir": "linux-64", + "timestamp": 1660852624235, + "version": "0.15.2" + }, + "docutils-0.15.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "11349ae9cd866e25ab9950637409b493", + "name": "docutils", + "sha256": "8be4425b67819304df406017e23a9acc9c54c8efeb493d95c2f0ac1e0c4b5f9a", + "size": 759815, + "subdir": "linux-64", + "timestamp": 1565959668887, + "version": "0.15.2" + }, + "docutils-0.15.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "ec8700549b80f8c5671e4d43aef2d47c", + "name": "docutils", + "sha256": "df640b29df2c97b3ce328aa4bd95ae096e17aadc5d93e77cb7d9c3d5e1875611", + "size": 761999, + "subdir": "linux-64", + "timestamp": 1613157743625, + "version": "0.15.2" + }, + "docutils-0.15.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "4a20a33d06ff1168603c4a3067ee7235", + "name": "docutils", + "sha256": "1936371cd1e96977e907edd0085e5e24d43abbe32872ab6b1648d7da7689a7e0", + "size": 753723, + "subdir": "linux-64", + "timestamp": 1565958736602, + "version": "0.15.2" + }, + "docutils-0.15.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "c6e8817899493e47b9119ebbaae41f33", + "name": "docutils", + "sha256": "af9ea3fa77b37814944d986686920d4f4f8a25ed60cad4a815e8970e609cf91c", + "size": 756447, + "subdir": "linux-64", + "timestamp": 1613157742131, + "version": "0.15.2" + }, + "docutils-0.15.2-py37h06a4308_4.tar.bz2": { + "build": "py37h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "2056643df1d1080e5f02fd02872c6cc2", + "name": "docutils", + "sha256": "8a23fc3dafd2590fa5eb7c482aacee3af81ba81716278ff9a33201344d926661", + "size": 780336, + "subdir": "linux-64", + "timestamp": 1659506613691, + "version": "0.15.2" + }, + "docutils-0.15.2-py37h06a4308_5.tar.bz2": { + "build": "py37h06a4308_5", + "build_number": 5, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "e3de8414d985957b0d295f2a2ed293b7", + "name": "docutils", + "sha256": "1e3c9adcbc2d22aba99feb7cc96bb39cab893629e42194bfffdc1096f5bf4587", + "size": 755627, + "subdir": "linux-64", + "timestamp": 1660852553745, + "version": "0.15.2" + }, + "docutils-0.15.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "75d0bfc5b540ce551469069980f6cab7", + "name": "docutils", + "sha256": "32f73cbcd37bab38bdbf3b0aa7784130a609e2e39b545567201d5b5a61524593", + "size": 757753, + "subdir": "linux-64", + "timestamp": 1572435113893, + "version": "0.15.2" + }, + "docutils-0.15.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "2dfca3905e7da914603ad87ff26b90b5", + "name": "docutils", + "sha256": "c2ba37b83a38eaba927e5e8f3b4ba75ac081d6097d861408432c9d43ca4dca8e", + "size": 758304, + "subdir": "linux-64", + "timestamp": 1613157750048, + "version": "0.15.2" + }, + "docutils-0.15.2-py38h06a4308_4.tar.bz2": { + "build": "py38h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "a03ac05550c17cb5d4a38f646a9d3a80", + "name": "docutils", + "sha256": "3ba6222534259bd541abb8ff1cfd138ad19f159a5fc6dddd915c0e46a980e2f1", + "size": 785492, + "subdir": "linux-64", + "timestamp": 1659506459224, + "version": "0.15.2" + }, + "docutils-0.15.2-py38h06a4308_5.tar.bz2": { + "build": "py38h06a4308_5", + "build_number": 5, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "d20753c933a4efc86f01a900b09b5792", + "name": "docutils", + "sha256": "d9b74553e99a4907b24ce5bb11d8ad5394a1aeb71b1151f36da6637aa069f4cc", + "size": 756714, + "subdir": "linux-64", + "timestamp": 1660852684443, + "version": "0.15.2" + }, + "docutils-0.15.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "de238bd6c8d7e2f0d9488031977c5631", + "name": "docutils", + "sha256": "ba572a205024da90d98f78235cfdf7a09270ea017747a2e71c1b2466adff28b6", + "size": 758826, + "subdir": "linux-64", + "timestamp": 1613157744629, + "version": "0.15.2" + }, + "docutils-0.15.2-py39h06a4308_4.tar.bz2": { + "build": "py39h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "fcec224c89fac50afabc67b068d40df3", + "name": "docutils", + "sha256": "dc0773e90d0c2d549cff76e0a50d13709aeb817807ccecb0d8ec2335f328c82b", + "size": 785479, + "subdir": "linux-64", + "timestamp": 1659506534632, + "version": "0.15.2" + }, + "docutils-0.15.2-py39h06a4308_5.tar.bz2": { + "build": "py39h06a4308_5", + "build_number": 5, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "42a3b126e967e7ef12c0602b896824d4", + "name": "docutils", + "sha256": "75262fb16fc5841c046133413dd6e2001667882aeec846ac2e604432233eb882", + "size": 756406, + "subdir": "linux-64", + "timestamp": 1660852743778, + "version": "0.15.2" + }, + "docutils-0.16-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "640bdbb62c3e689a01e519a294dfeec3", + "name": "docutils", + "sha256": "55bbc5ac07dc58ec8e930bc90d6cd5211ae5a085188f9f8c23a84054d70516b0", + "size": 754545, + "subdir": "linux-64", + "timestamp": 1580151448049, + "version": "0.16" + }, + "docutils-0.16-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "4e41a2cf753f3edc554ca437d0d58bcf", + "name": "docutils", + "sha256": "3840ad717cae5e694ee9ccfff6e5fc8a27861e253b9ebf6472173f8b600f2212", + "size": 757583, + "subdir": "linux-64", + "timestamp": 1591789170785, + "version": "0.16" + }, + "docutils-0.16-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "0fd80f98b2e6cb5408c4d3510c9b9c61", + "name": "docutils", + "sha256": "6b1abab90a97713daf88589acaae3c0bea531009e525684e8dceaa4d62888a8f", + "size": 756100, + "subdir": "linux-64", + "timestamp": 1580151526093, + "version": "0.16" + }, + "docutils-0.16-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "aa83b2485a96774add59abe9d8b39054", + "name": "docutils", + "sha256": "2630a1d9c79d390787d88548c648e1a648528c37d3527e92a1b7dd4f141e59cc", + "size": 754172, + "subdir": "linux-64", + "timestamp": 1591789194977, + "version": "0.16" + }, + "docutils-0.16-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "ae1e46f43459f48f9bc4ed9cdd3fb574", + "name": "docutils", + "sha256": "1d3a35238ecc7e121620aca3156df73a84d5b80da261d95627737702529038ca", + "size": 759562, + "subdir": "linux-64", + "timestamp": 1580151453742, + "version": "0.16" + }, + "docutils-0.16-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "307cf1ce852c7097c406ae60231c03cd", + "name": "docutils", + "sha256": "04b7dc9de45afa0fa7762dfd2513e9b6238b0e99a18e57b91c37eb410b13de16", + "size": 759413, + "subdir": "linux-64", + "timestamp": 1591789164516, + "version": "0.16" + }, + "docutils-0.16-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "187ee90884cb681580eb5cf05c675cda", + "name": "docutils", + "sha256": "7cbbf514f8d80f2d3da8fd07d3e19b022ca3ec42935cb0bf8cab9dbbe791b7ed", + "size": 762309, + "subdir": "linux-64", + "timestamp": 1607039218774, + "version": "0.16" + }, + "docutils-0.17-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "a17d15fce41d477b739afcbae1680630", + "name": "docutils", + "sha256": "a2abdf35c9255f47c6a71d8f7fedc86635533402d3bb64fb8856bf2f74357e13", + "size": 777384, + "subdir": "linux-64", + "timestamp": 1617481486010, + "version": "0.17" + }, + "docutils-0.17-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "7efe01cfeb07aab63a6b70e1bb5f2a10", + "name": "docutils", + "sha256": "1d09f082d52001e11502619c4825430aff23b8d49b26ba16fe1e160c211eaa46", + "size": 777358, + "subdir": "linux-64", + "timestamp": 1617624699118, + "version": "0.17" + }, + "docutils-0.17-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "af06df5ef0a3a595bc7824b20de0301e", + "name": "docutils", + "sha256": "4025ee418a2b5a2f75609d330b41933222a9689a13790ee69dc8741cde3dab8b", + "size": 783110, + "subdir": "linux-64", + "timestamp": 1617624696296, + "version": "0.17" + }, + "docutils-0.17-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "6d2c7d2d2335cff0abb6cd81b99814c6", + "name": "docutils", + "sha256": "b07ddb6ca14d7a0092dce4cd93c275db1f0ac077e1749929cf004195b4e790c9", + "size": 780343, + "subdir": "linux-64", + "timestamp": 1617481463926, + "version": "0.17" + }, + "docutils-0.17.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "cdb11ef781ee3fa4a0772283d7433eb3", + "name": "docutils", + "sha256": "52baf627c2568c7b8670e933f1cfdbee20164eef8b1ff01cad9fe407939effa0", + "size": 780535, + "subdir": "linux-64", + "timestamp": 1620828019498, + "version": "0.17.1" + }, + "docutils-0.17.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "f69e58e19cc0ebb87ccc0c96865ccb27", + "name": "docutils", + "sha256": "40c2ff2e82417c13033bd83a4c9da06adc792f7b82abd3f712dd821e3ea837c4", + "size": 779747, + "subdir": "linux-64", + "timestamp": 1620828018248, + "version": "0.17.1" + }, + "docutils-0.17.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "8431313b3e83fa6a522ac7e26b03e47d", + "name": "docutils", + "sha256": "d9bb8097891e9d8aef4448470411c68a6b4dee6727579ae1c5b86a403422c689", + "size": 781563, + "subdir": "linux-64", + "timestamp": 1620828023842, + "version": "0.17.1" + }, + "docutils-0.17.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "9c9572b21ad8915b4e817c61e1f68648", + "name": "docutils", + "sha256": "ea10123326836d8b14c9869d406eb728c9b126acd169e091bf11145c82c6f14a", + "size": 781893, + "subdir": "linux-64", + "timestamp": 1620828017440, + "version": "0.17.1" + }, + "docutils-0.18.1-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "md5": "9a5c656b223eac56d8bcee7d0a2910a9", + "name": "docutils", + "sha256": "63e91f69ddc3e9f1dfc812e3df908dd303ae86fca0f2f31855af113411abf4a1", + "size": 778643, + "subdir": "linux-64", + "timestamp": 1640789663378, + "version": "0.18.1" + }, + "docutils-0.18.1-py310h06a4308_3.tar.bz2": { + "build": "py310h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "license_family": "Other", + "md5": "1ceaf09490a0b2d27c49109479abbdd4", + "name": "docutils", + "sha256": "73745e5fd6a42944b0ba63e0238ddbb77149f08e988b02b3acf77db547d7b6c3", + "size": 774632, + "subdir": "linux-64", + "timestamp": 1657175571617, + "version": "0.18.1" + }, + "docutils-0.18.1-py311h06a4308_3.tar.bz2": { + "build": "py311h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "license_family": "Other", + "md5": "9fb2da15f2a2ee674a023d0b83b6c415", + "name": "docutils", + "sha256": "a3a3d651101b07b30a1bcd8dce978d26887a279432897cdc5a04c9de8cb3d2b5", + "size": 988439, + "subdir": "linux-64", + "timestamp": 1676822788314, + "version": "0.18.1" + }, + "docutils-0.18.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "md5": "0d7dc4c725c2267b6224a4a1e5592ca5", + "name": "docutils", + "sha256": "271b3f3a4d020313fae274829adbe0bde5475394f1d9a41171b54e2dd00dd0a1", + "size": 754243, + "subdir": "linux-64", + "timestamp": 1638364318636, + "version": "0.18.1" + }, + "docutils-0.18.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "1bf1c70241cca597a08aa4c1bccd70d3", + "name": "docutils", + "sha256": "591f1f246740ddb245dc9ec0332053b93ed337ee16eaa49404051f33fa23428e", + "size": 749990, + "subdir": "linux-64", + "timestamp": 1638363579636, + "version": "0.18.1" + }, + "docutils-0.18.1-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "md5": "44b2b36a62b75283f5ead7e2425b494e", + "name": "docutils", + "sha256": "cb07474932e173e11d08274beb6a3f3c55b6cbbb94327e002a5b57f213029410", + "size": 757761, + "subdir": "linux-64", + "timestamp": 1638527881989, + "version": "0.18.1" + }, + "docutils-0.18.1-py37h06a4308_3.tar.bz2": { + "build": "py37h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "license_family": "Other", + "md5": "59ccdc620fdc1209aaecde2c584202a1", + "name": "docutils", + "sha256": "d68888fc4218cef6e5a0accca9480c510b0e009e2c07f10557869fcb3a9d4be3", + "size": 749557, + "subdir": "linux-64", + "timestamp": 1657175527107, + "version": "0.18.1" + }, + "docutils-0.18.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "md5": "dee64478ac745f62588d80e3813923ea", + "name": "docutils", + "sha256": "50d4933e32adee818dbcb225851fbb63122ca818a91a443a557ff85e4c729d5f", + "size": 756009, + "subdir": "linux-64", + "timestamp": 1638364317043, + "version": "0.18.1" + }, + "docutils-0.18.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "9e31d304af67c5da891250ac83f8acdd", + "name": "docutils", + "sha256": "b63a64684a9f36ddd4eb9bf20689ba59c433326c55ac8e9412a4b726d791e7ec", + "size": 759005, + "subdir": "linux-64", + "timestamp": 1638357019773, + "version": "0.18.1" + }, + "docutils-0.18.1-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "md5": "2af7934b02ab8054c98d2165085ed80d", + "name": "docutils", + "sha256": "8cd8bcc7ab043ef3d24ea51793babf97f4df3351a75faf41a04738443cfac3dd", + "size": 761048, + "subdir": "linux-64", + "timestamp": 1638528514737, + "version": "0.18.1" + }, + "docutils-0.18.1-py38h06a4308_3.tar.bz2": { + "build": "py38h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "license_family": "Other", + "md5": "4f8e81783c19ce33b549d9fc768572a1", + "name": "docutils", + "sha256": "9e0e85310945a11d5cfba1452f2f46f8c1c4843b4ea3febafb2c05661bba6f17", + "size": 755969, + "subdir": "linux-64", + "timestamp": 1657175462743, + "version": "0.18.1" + }, + "docutils-0.18.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "md5": "48919ab382fdd3e4877626b9bb90834c", + "name": "docutils", + "sha256": "472b1d1fb770c4ee1bf9e0dc82bf7b7faf0f579cc9aa49187fefcf3cf3a7df9d", + "size": 751511, + "subdir": "linux-64", + "timestamp": 1638363871233, + "version": "0.18.1" + }, + "docutils-0.18.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "5a8ee69a801476fbeeaa6df244840dd6", + "name": "docutils", + "sha256": "8b11bbf1d11b333c42cccb909b109aabf4af57fe18a06fd59efbc2ade677e4be", + "size": 756753, + "subdir": "linux-64", + "timestamp": 1638344299876, + "version": "0.18.1" + }, + "docutils-0.18.1-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "md5": "0355df450a1c9facbd1a5e1fadbfc4f7", + "name": "docutils", + "sha256": "723b5f266ede7efedc2025b517b25b9f38bb7135003b50f379af221319bc81dd", + "size": 759709, + "subdir": "linux-64", + "timestamp": 1638528514172, + "version": "0.18.1" + }, + "docutils-0.18.1-py39h06a4308_3.tar.bz2": { + "build": "py39h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "license_family": "Other", + "md5": "6ffda6e9d0519f34b259f7805193078b", + "name": "docutils", + "sha256": "3ecf172f64d19406f81fb3e92ff42614545b1810a2f182008701e63f638d0726", + "size": 754291, + "subdir": "linux-64", + "timestamp": 1657175495392, + "version": "0.18.1" + }, + "doit-0.29.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "configparser", + "pyinotify", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "00859ab634e6c2d221c1234bb0371835", + "name": "doit", + "sha256": "357a22400368953e1e79d26308e5227ca0bd4c618e4a2d0e2383eaa7be5045dc", + "size": 110464, + "subdir": "linux-64", + "timestamp": 1523046083229, + "version": "0.29.0" + }, + "doit-0.29.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b32c791c3a55a5942ecb96f0e8b9feb", + "name": "doit", + "sha256": "de6f949097094f72d4b85d999c9351959734f31ac433b71a5180fec1afae94ef", + "size": 112761, + "subdir": "linux-64", + "timestamp": 1523046108921, + "version": "0.29.0" + }, + "doit-0.29.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f71ce56d0d3a569ef6649d4b5d8d79d1", + "name": "doit", + "sha256": "79898c4f6bc7902284fcab262d877d0326933253a2cfc160eb8b45253cea2a77", + "size": 112477, + "subdir": "linux-64", + "timestamp": 1523046106375, + "version": "0.29.0" + }, + "doit-0.31.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4427cf9acaa38bd796b80662a1043272", + "name": "doit", + "sha256": "9c2767d58bb7481759eac84eeb573aad4417298c04c35bd67da370ec1c6b4a44", + "size": 115399, + "subdir": "linux-64", + "timestamp": 1523040481312, + "version": "0.31.1" + }, + "doit-0.31.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d7d1b1e9ff3acdd6f2ac59a41650f7d2", + "name": "doit", + "sha256": "7832aff064efae175be3d33540f4122d9dd2795282a16abb0db3e09dc97a7ea5", + "size": 115126, + "subdir": "linux-64", + "timestamp": 1523040553907, + "version": "0.31.1" + }, + "doit-0.31.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58f27f55167e91bb9f91ba797ae2cc88", + "name": "doit", + "sha256": "c36cbc55790a2946a9d54528e83061503aa86181df25d587f132c7bb49ea19fc", + "size": 114790, + "subdir": "linux-64", + "timestamp": 1530873502470, + "version": "0.31.1" + }, + "doit-0.31.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "526e50ff12151c77e114b842bf2467af", + "name": "doit", + "sha256": "587b7e195f77daa4de575b65afb897e99a4a8ac2da7aae756ceaf88df0517129", + "size": 115421, + "subdir": "linux-64", + "timestamp": 1573741675915, + "version": "0.31.1" + }, + "doit-0.32.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad6580bb0f59ec69df4b8761d4fc9c15", + "name": "doit", + "sha256": "8b4d99c8fdf5519c793d9b20288cb7aa7bfa5ab7ae8dc6a73e811e1028290039", + "size": 121117, + "subdir": "linux-64", + "timestamp": 1588595359684, + "version": "0.32.0" + }, + "doit-0.32.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c4f5a226af44396b259c15d5edfe305", + "name": "doit", + "sha256": "ac37b278f7f6b9bc7ea31e63658d284246caf2ddb4383995a5f1b8528683659d", + "size": 120635, + "subdir": "linux-64", + "timestamp": 1588595322334, + "version": "0.32.0" + }, + "doit-0.32.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "61aefddff562895ea8026e4b8db1560a", + "name": "doit", + "sha256": "94262804c1e9f305dea62233388d72d573e1b88cdeb48b283c88fac6165f3b77", + "size": 120926, + "subdir": "linux-64", + "timestamp": 1588595401532, + "version": "0.32.0" + }, + "doit-0.33.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ddbab3cd05654b6d9003f004d2465826", + "name": "doit", + "sha256": "083d28046233c84fccd8c4992fdbb5f826a583ccb6aa120cf388ad77e89c65f2", + "size": 121315, + "subdir": "linux-64", + "timestamp": 1640808972454, + "version": "0.33.1" + }, + "doit-0.33.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "10d63e02dd31619d49374d72d1750e13", + "name": "doit", + "sha256": "ac9a4685c7eb21d0b9a8c59a15f469f5c40d9f1600317047a773a1577b8efbd4", + "size": 157712, + "subdir": "linux-64", + "timestamp": 1676852001024, + "version": "0.33.1" + }, + "doit-0.33.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f3be1283eb3f34dd215ab2ecc70bda5", + "name": "doit", + "sha256": "63f8330a5d5f7b19e92601612361145a8f5a702bcfa6feff340640fc376cfddf", + "size": 120036, + "subdir": "linux-64", + "timestamp": 1603926337092, + "version": "0.33.1" + }, + "doit-0.33.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f658ae6c73abc3bfbcdab53b41aac4e2", + "name": "doit", + "sha256": "401d6e00ba4b5c5626eeb67df08da5304cc613e67af42366de6ede6e21e64e08", + "size": 120303, + "subdir": "linux-64", + "timestamp": 1603926313804, + "version": "0.33.1" + }, + "doit-0.33.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "592dfde1df4166bf342fcca5959772bd", + "name": "doit", + "sha256": "1e93f842c18a03e0de7e8c89eeda55dd5bb5aa38a3bfd648a39978330a5db6d1", + "size": 120143, + "subdir": "linux-64", + "timestamp": 1603926335591, + "version": "0.33.1" + }, + "doit-0.33.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c94b3b2c1c7e51ddbc7bcdc30cdaa13", + "name": "doit", + "sha256": "5608de776a84f5538969fa243e0f65c05dac40715a7a93731ee1be9fd784475e", + "size": 120998, + "subdir": "linux-64", + "timestamp": 1614246298319, + "version": "0.33.1" + }, + "dos2unix-7.4.2-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f44dfdef469ad602881d5b99d55ecd35", + "name": "dos2unix", + "sha256": "592930cbb132c239d87e8021a3ffad868e5d540ff70989a30e99ca369b56d851", + "size": 329727, + "subdir": "linux-64", + "timestamp": 1642592499322, + "version": "7.4.2" + }, + "double-conversion-3.1.5-he6710b0_1.tar.bz2": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d58335091a21fb84be6017f879a9cec9", + "name": "double-conversion", + "sha256": "636ed92de3d236204a971cacd93c731fa5142c52940a37411fef8ab23243ebde", + "size": 239084, + "subdir": "linux-64", + "timestamp": 1567108307419, + "version": "3.1.5" + }, + "dpcpp-cpp-rt-2021.3.0-h06a4308_3350.tar.bz2": { + "build": "h06a4308_3350", + "build_number": 3350, + "depends": [ + "intel-cmplr-lib-rt 2021.3.0 h06a4308_3350", + "intel-cmplr-lic-rt 2021.3.0 h06a4308_3350", + "intel-opencl-rt 2021.3.0 h06a4308_3350", + "intel-openmp 2021.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "1f020c7e25acdb312749e5f95e358380", + "name": "dpcpp-cpp-rt", + "sha256": "84693e6510e2ad8eabad8c589cc24e703e7c853b9f7e40f83b6c73afea63c5b6", + "size": 1368024, + "subdir": "linux-64", + "timestamp": 1626976237193, + "version": "2021.3.0" + }, + "dpcpp-cpp-rt-2021.4.0-h06a4308_3561.tar.bz2": { + "build": "h06a4308_3561", + "build_number": 3561, + "depends": [ + "intel-cmplr-lib-rt 2021.4.0 h06a4308_3561", + "intel-cmplr-lic-rt 2021.4.0 h06a4308_3561", + "intel-opencl-rt 2021.4.0 h06a4308_3561", + "intel-openmp 2021.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "86ebad2d1573f137a75c6515b2dd792f", + "name": "dpcpp-cpp-rt", + "sha256": "9edd3a53034c53d1d6023a0ff292e18365c54ed6bdcfcfe5319acb6d4a6cbb90", + "size": 1367657, + "subdir": "linux-64", + "timestamp": 1641816140942, + "version": "2021.4.0" + }, + "dpcpp-cpp-rt-2022.0.1-h06a4308_3633.tar.bz2": { + "build": "h06a4308_3633", + "build_number": 3633, + "depends": [ + "intel-cmplr-lib-rt 2022.0.1 h06a4308_3633", + "intel-cmplr-lic-rt 2022.0.1 h06a4308_3633", + "intel-opencl-rt 2022.0.1 h06a4308_3633", + "intel-openmp 2022.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "fcf0950f4ea85b213e9bf1261fb3971f", + "name": "dpcpp-cpp-rt", + "sha256": "db42fae4b78ed3a9950868da5e3a5495159af041e2269992c2037304b4f86e3f", + "size": 1376996, + "subdir": "linux-64", + "timestamp": 1642778772238, + "version": "2022.0.1" + }, + "dpcpp-cpp-rt-2022.1.0-h06a4308_3768.tar.bz2": { + "build": "h06a4308_3768", + "build_number": 3768, + "depends": [ + "intel-cmplr-lib-rt 2022.1.0 h06a4308_3768", + "intel-cmplr-lic-rt 2022.1.0 h06a4308_3768", + "intel-opencl-rt 2022.1.0 h06a4308_3768", + "intel-openmp 2022.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "8698c00e2f7afe8305661aab7bbdd2ce", + "name": "dpcpp-cpp-rt", + "sha256": "336f4769a66e934ba06f4fd6464507598059b24bf8594a0cf03243565419517c", + "size": 1576371, + "subdir": "linux-64", + "timestamp": 1667585162588, + "version": "2022.1.0" + }, + "dpcpp-cpp-rt-2023.0.0-h06a4308_25370.tar.bz2": { + "build": "h06a4308_25370", + "build_number": 25370, + "depends": [ + "intel-cmplr-lib-rt 2023.0.0 h06a4308_25370", + "intel-cmplr-lic-rt 2023.0.0 h06a4308_25370", + "intel-opencl-rt 2023.0.0 h06a4308_25370", + "intel-openmp 2023.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "faa1099ee7d80aabf282c8a8f0866c8b", + "name": "dpcpp-cpp-rt", + "sha256": "8b42e9f4a93987d5ae236b903e262eff0572e6ce5afab8548b090bccf69ac573", + "size": 1516178, + "subdir": "linux-64", + "timestamp": 1679615106681, + "version": "2023.0.0" + }, + "dpcpp_impl_linux-64-2021.3.0-h06a4308_3350.tar.bz2": { + "build": "h06a4308_3350", + "build_number": 3350, + "depends": [ + "dpcpp-cpp-rt 2021.3.0 h06a4308_3350" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "6894fb417de246cf06a36ed8cdbd6709", + "name": "dpcpp_impl_linux-64", + "sha256": "fecd54f2940454c34357dad0b444092ddd2e99d59728e97d9dca0e0dea2cf8b2", + "size": 208982120, + "subdir": "linux-64", + "timestamp": 1626976374632, + "version": "2021.3.0" + }, + "dpcpp_impl_linux-64-2021.4.0-h06a4308_3561.tar.bz2": { + "build": "h06a4308_3561", + "build_number": 3561, + "depends": [ + "dpcpp-cpp-rt 2021.4.0 h06a4308_3561", + "dpl-include" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "ec6a8c0dccf5fac534b0226f0bbeefcc", + "name": "dpcpp_impl_linux-64", + "sha256": "d3d00e40fe1ee1193cf4d68c971e67782e4ce8c02a7361964e3661def5aacb03", + "size": 216533102, + "subdir": "linux-64", + "timestamp": 1641816197129, + "version": "2021.4.0" + }, + "dpcpp_impl_linux-64-2022.0.1-h06a4308_3633.tar.bz2": { + "build": "h06a4308_3633", + "build_number": 3633, + "depends": [ + "dpcpp-cpp-rt 2022.0.1 h06a4308_3633" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "7634c5d862eb9d756c2574826e067079", + "name": "dpcpp_impl_linux-64", + "sha256": "de9e28a6acfc42b274db1e3ada87dec4c0d45188116368d4ecd80e4a8a7c58bb", + "size": 305828469, + "subdir": "linux-64", + "timestamp": 1642779040672, + "version": "2022.0.1" + }, + "dpcpp_impl_linux-64-2022.1.0-h6a678d5_3768.tar.bz2": { + "build": "h6a678d5_3768", + "build_number": 3768, + "depends": [ + "dpcpp-cpp-rt 2022.1.0 h06a4308_3768", + "gcc_impl_linux-64", + "gxx_impl_linux-64", + "sysroot_linux-64" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "855f7ae822720143bf8491288abb7b0e", + "name": "dpcpp_impl_linux-64", + "sha256": "e5ee61d81e7bf9b437871b110e86a062e2ec99b6a42075654966d0d340e4e07e", + "size": 334466590, + "subdir": "linux-64", + "timestamp": 1667585195855, + "version": "2022.1.0" + }, + "dpcpp_impl_linux-64-2023.0.0-h6a678d5_25370.tar.bz2": { + "build": "h6a678d5_25370", + "build_number": 25370, + "depends": [ + "dpcpp-cpp-rt 2023.0.0 h06a4308_25370", + "gcc_impl_linux-64", + "gxx_impl_linux-64", + "sysroot_linux-64" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "685ecc44b11fdfd459d513fc49b92961", + "name": "dpcpp_impl_linux-64", + "sha256": "3f38670618df364cc47ec0dcb33bc2c58b0114db0d18c3b55e2e3d81443e7388", + "size": 444268032, + "subdir": "linux-64", + "timestamp": 1679615139912, + "version": "2023.0.0" + }, + "dpcpp_linux-64-2021.3.0-h06a4308_3350.tar.bz2": { + "build": "h06a4308_3350", + "build_number": 3350, + "depends": [ + "dpcpp_impl_linux-64 2021.3.0 h06a4308_3350" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "d186c2d7d7c01d92b9e3c5dbe3f983d1", + "name": "dpcpp_linux-64", + "sha256": "1025fada01a9470dcd4055bed617f4eae1b7923f80f3b47a152ca588b51ae597", + "size": 28927, + "subdir": "linux-64", + "timestamp": 1626976548351, + "version": "2021.3.0" + }, + "dpcpp_linux-64-2021.4.0-h06a4308_3561.tar.bz2": { + "build": "h06a4308_3561", + "build_number": 3561, + "depends": [ + "dpcpp_impl_linux-64 2021.4.0 h06a4308_3561" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "42b8f085d4586c4b7a9415a100eb52f6", + "name": "dpcpp_linux-64", + "sha256": "f05ba05bf0b6bb7df23d15e043971dd0ae8f0adaa46441896fd5ef6d1164f9f1", + "size": 29346, + "subdir": "linux-64", + "timestamp": 1641816357605, + "version": "2021.4.0" + }, + "dpcpp_linux-64-2022.0.1-h06a4308_3633.tar.bz2": { + "build": "h06a4308_3633", + "build_number": 3633, + "depends": [ + "dpcpp_impl_linux-64 2022.0.1 h06a4308_3633" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "f051d1962ec1adaf1d5cb53409df44d3", + "name": "dpcpp_linux-64", + "sha256": "70bae1a57b9cd4a17789e868fc9d567786e0ffa8b91e8b47f0f00e68d4864a2e", + "size": 27497, + "subdir": "linux-64", + "timestamp": 1642779284378, + "version": "2022.0.1" + }, + "dpcpp_linux-64-2022.1.0-h3a05717_3768.tar.bz2": { + "build": "h3a05717_3768", + "build_number": 3768, + "depends": [ + "dpcpp_impl_linux-64 2022.1.0 h6a678d5_3768" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "c3bb7219cab796f0c592c6cfabbb56ef", + "name": "dpcpp_linux-64", + "sha256": "915c9d0db5a4796f9d87aa510d607c491a0746ab9d4398397ccdd2be1b0d8fa0", + "size": 31508, + "subdir": "linux-64", + "timestamp": 1667585634408, + "version": "2022.1.0" + }, + "dpcpp_linux-64-2023.0.0-h3a05717_25370.tar.bz2": { + "build": "h3a05717_25370", + "build_number": 25370, + "depends": [ + "dpcpp_impl_linux-64 2023.0.0 h6a678d5_25370" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "ce11fea9111be1e271422bfaf7a94c58", + "name": "dpcpp_linux-64", + "sha256": "fe0c145d6858383e59f35778d4ba286ea7fee3faf5a008850c8ce061568e11d7", + "size": 31889, + "subdir": "linux-64", + "timestamp": 1679615666052, + "version": "2023.0.0" + }, + "dpctl-0.11.4-py37h93b75d6_0.tar.bz2": { + "build": "py37h93b75d6_0", + "build_number": 0, + "depends": [ + "dpcpp-cpp-rt >=2021.3", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "87598128f8ab376dde74ce3baba9c1b8", + "name": "dpctl", + "sha256": "508ca426e3ddafcb187d3c7e2d6419a4bf4a6c1e426e11cffb99c21d924ad63e", + "size": 1036490, + "subdir": "linux-64", + "timestamp": 1646239175074, + "version": "0.11.4" + }, + "dpctl-0.11.4-py38h93b75d6_0.tar.bz2": { + "build": "py38h93b75d6_0", + "build_number": 0, + "depends": [ + "dpcpp-cpp-rt >=2021.3", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "58e5d3c5e0cbe20a2665158670ac5c1f", + "name": "dpctl", + "sha256": "10200e97447fcf87ef49339771737399113e08d8a74ec2ae1518501b138a7cea", + "size": 1075119, + "subdir": "linux-64", + "timestamp": 1646239350619, + "version": "0.11.4" + }, + "dpctl-0.11.4-py39h93b75d6_0.tar.bz2": { + "build": "py39h93b75d6_0", + "build_number": 0, + "depends": [ + "dpcpp-cpp-rt >=2021.3", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c08e1650a8c0da96f23a9a6f8bab83ee", + "name": "dpctl", + "sha256": "d0088802a8bca430c770addb8bf8ed3ef9934703b049e8e364c18ed0ba96cf62", + "size": 1078617, + "subdir": "linux-64", + "timestamp": 1646239261715, + "version": "0.11.4" + }, + "dpctl-0.13.0-py310h6244886_0.tar.bz2": { + "build": "py310h6244886_0", + "build_number": 0, + "depends": [ + "dpcpp-cpp-rt >=2022.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bc05da62391cedc8809031e7c765fa20", + "name": "dpctl", + "sha256": "1bf0d56572225522513a23daac8ce52dcf69bcf5b15dc3168a16a9d4a04a3b0e", + "size": 2260946, + "subdir": "linux-64", + "timestamp": 1667591849313, + "version": "0.13.0" + }, + "dpctl-0.13.0-py38h6244886_0.tar.bz2": { + "build": "py38h6244886_0", + "build_number": 0, + "depends": [ + "dpcpp-cpp-rt >=2022.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d02216bd7a8da2c0a6d6f42c66d5323f", + "name": "dpctl", + "sha256": "eb8de710f99a348c82917ee7fdbda1783b7eeff4a2514955a8abbacd429efcf1", + "size": 2274423, + "subdir": "linux-64", + "timestamp": 1667592313127, + "version": "0.13.0" + }, + "dpctl-0.13.0-py39h6244886_0.tar.bz2": { + "build": "py39h6244886_0", + "build_number": 0, + "depends": [ + "dpcpp-cpp-rt >=2022.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f3222df6d9b1ce4b619e80152faf9cd8", + "name": "dpctl", + "sha256": "fb6e3dee4c83bbdbbf35e385691862f4566b250d8632d036093f45a57ded31f5", + "size": 2293695, + "subdir": "linux-64", + "timestamp": 1667592781330, + "version": "0.13.0" + }, + "dpl-include-2021.4.0-h06a4308_3561.tar.bz2": { + "build": "h06a4308_3561", + "build_number": 3561, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "8906d2ec8cd13abbf1ac84e056a9beae", + "name": "dpl-include", + "sha256": "a026b82b899de88cdec474ac6152da865cfc809c2cf5e007ccd02aab56ee7b8e", + "size": 207263, + "subdir": "linux-64", + "timestamp": 1641815988237, + "version": "2021.4.0" + }, + "dpnp-0.9.0-py37hfe064f0_0.tar.bz2": { + "build": "py37hfe064f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "dpcpp-cpp-rt >=2021.3", + "dpctl >=0.10", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.3", + "mkl-dpcpp >=2021.3", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.20.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "bf79a0a9e9cc16dc51fae0c688707c97", + "name": "dpnp", + "sha256": "26240e302eb17e7f0f4cab3a5a42ab574921572ad11fa23b7aff9067828dd59f", + "size": 2231064, + "subdir": "linux-64", + "timestamp": 1646240247364, + "version": "0.9.0" + }, + "dpnp-0.9.0-py38hfe064f0_0.tar.bz2": { + "build": "py38hfe064f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "dpcpp-cpp-rt >=2021.3", + "dpctl >=0.10", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.3", + "mkl-dpcpp >=2021.3", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.20.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a1c2422123a3cb53e6efc774134b182d", + "name": "dpnp", + "sha256": "ba6ba356dfaa56205a697f2482178f0dff7aa76f1e6a7d016acac1c3b33c1cec", + "size": 2263828, + "subdir": "linux-64", + "timestamp": 1646239912211, + "version": "0.9.0" + }, + "dpnp-0.9.0-py39hfe064f0_0.tar.bz2": { + "build": "py39hfe064f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "dpcpp-cpp-rt >=2021.3", + "dpctl >=0.10", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.3", + "mkl-dpcpp >=2021.3", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.20.3,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f80ad7a4094ebe711e49cd6f0f919231", + "name": "dpnp", + "sha256": "affdb66ce91cf2f9714e7891e93bcb124a3bf1a1305a0d3d4f50e6ea3099d4fe", + "size": 2264473, + "subdir": "linux-64", + "timestamp": 1646240573381, + "version": "0.9.0" + }, + "drmaa-0.7.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "6ae99e99b32d09f3da051e6939f9d70d", + "name": "drmaa", + "sha256": "2f2edbd16aeec9dd321f1ac3961f344708e65962eab368a6e2390157c33a4926", + "size": 29247, + "subdir": "linux-64", + "timestamp": 1522880564339, + "version": "0.7.8" + }, + "drmaa-0.7.8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "2e703a83885855a81a71e3ff6a3f4c79", + "name": "drmaa", + "sha256": "83c16b17a58f9c078b5e3b4125b42fadbaa0ea79a5c50770123c8ce7ad0e391e", + "size": 29627, + "subdir": "linux-64", + "timestamp": 1522880575881, + "version": "0.7.8" + }, + "drmaa-0.7.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "e28bc0ec275049c3546d3d926fbf8fa4", + "name": "drmaa", + "sha256": "33e4fe69524c0e5380e4101f3710b0130aa6518997625ab45dc7eb9687ef8dfe", + "size": 29689, + "subdir": "linux-64", + "timestamp": 1522880538273, + "version": "0.7.8" + }, + "drmaa-0.7.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "b7f189b1a0a496a196ac0005f561c549", + "name": "drmaa", + "sha256": "de179f4f2adc4b9bcb934b2a42b9f833c2e8f6ae181127fb890478ecc78f3700", + "size": 30027, + "subdir": "linux-64", + "timestamp": 1530873530594, + "version": "0.7.8" + }, + "drmaa-0.7.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "9c0a2b4ea1e599de90b3f9a9e09bfb51", + "name": "drmaa", + "sha256": "2ca3bcabd8bf594705f30d85e8488d213b85737fda6f4636ca57c61b4f1d4305", + "size": 30160, + "subdir": "linux-64", + "timestamp": 1542077531566, + "version": "0.7.9" + }, + "drmaa-0.7.9-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "0154e63a583034a665c50f8163570555", + "name": "drmaa", + "sha256": "1bfc27738c1537606378248c0916a64441addb6d892d932ecf753faf21e6876d", + "size": 31028, + "subdir": "linux-64", + "timestamp": 1640789681371, + "version": "0.7.9" + }, + "drmaa-0.7.9-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "md5": "86947c36778feae177a97a06b7ec75df", + "name": "drmaa", + "sha256": "0358e487cf452b547930004143e027e2057163f08ea5fdb0ffab9b4eee3b6df4", + "size": 37934, + "subdir": "linux-64", + "timestamp": 1676852017387, + "version": "0.7.9" + }, + "drmaa-0.7.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "3ce02d36472df0a7e936f44a3f07b0af", + "name": "drmaa", + "sha256": "924174205612ef4907e873d5c97e07a0b22944dd0bcbaf436e3bcd664c25fc80", + "size": 30614, + "subdir": "linux-64", + "timestamp": 1542077525877, + "version": "0.7.9" + }, + "drmaa-0.7.9-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "934bb2a844127c61c3431041d6396eef", + "name": "drmaa", + "sha256": "4d3e0c28c06a0565a15758117f745f6c9279b1195f466c92a76a7688f0a73a6a", + "size": 33569, + "subdir": "linux-64", + "timestamp": 1611677526406, + "version": "0.7.9" + }, + "drmaa-0.7.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "d325610ca72169376744345703e5addf", + "name": "drmaa", + "sha256": "627e89476531884bb198e1c9e89e812096083f0557204646555ba913e75335a8", + "size": 30594, + "subdir": "linux-64", + "timestamp": 1542077464619, + "version": "0.7.9" + }, + "drmaa-0.7.9-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "e5c221db417bd18ec6ae481f1cfd8b95", + "name": "drmaa", + "sha256": "db7c3e8168a641c5da980fb1688047cebd460723308dd2c729f33ac7fcf7f51e", + "size": 33536, + "subdir": "linux-64", + "timestamp": 1611678829789, + "version": "0.7.9" + }, + "drmaa-0.7.9-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "063865dc6d74086a4c623ceef016e8f9", + "name": "drmaa", + "sha256": "5d2446202067556f7e694eac23ad2114f9d764a8cc88971107ef5c3373bf84b1", + "size": 30939, + "subdir": "linux-64", + "timestamp": 1572435136146, + "version": "0.7.9" + }, + "drmaa-0.7.9-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "7fde1ef28cc78c36b418d12a85b99608", + "name": "drmaa", + "sha256": "d083ce4a7276fdfc2281c30afd81bc35a64205155d3412605df5a588184e44c2", + "size": 33648, + "subdir": "linux-64", + "timestamp": 1611677542179, + "version": "0.7.9" + }, + "drmaa-0.7.9-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "e8cc47a8b08f81c9a782e8fc11df0c23", + "name": "drmaa", + "sha256": "7c52d19361a44c6296d358a01e941a3a06f951e9b5fcabe11f82b76305d2f2e8", + "size": 33481, + "subdir": "linux-64", + "timestamp": 1611677548427, + "version": "0.7.9" + }, + "dropbox-10.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96fa74a7b11edf6f9cb1714d03f4bc97", + "name": "dropbox", + "sha256": "4e51eb91abaa66dc20c17047006ef6904e88a15e4cfec0a2aa07737f7747dc11", + "size": 1028926, + "subdir": "linux-64", + "timestamp": 1590086487899, + "version": "10.1.2" + }, + "dropbox-10.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e14ae355b43ede5ffe15092751781689", + "name": "dropbox", + "sha256": "17a514e7e2a6c92408d02dddd95f5df233ac429a550924eaae67b57131e6c905", + "size": 1030681, + "subdir": "linux-64", + "timestamp": 1590086475257, + "version": "10.1.2" + }, + "dropbox-10.1.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7d759d4549982f7f8008c3ddbe1ec090", + "name": "dropbox", + "sha256": "ecb678df5068902524598b06d06d10b8e5fa1270b96f3a6f81d7eca3a18014e8", + "size": 1039225, + "subdir": "linux-64", + "timestamp": 1590086478670, + "version": "10.1.2" + }, + "dropbox-10.10.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9da2306719311af9de3ca33e3c734b7f", + "name": "dropbox", + "sha256": "6716f4cd1e6e85e033072464e14644d83a15fb07cc6858aea2650622e21d900f", + "size": 1083616, + "subdir": "linux-64", + "timestamp": 1606082683059, + "version": "10.10.0" + }, + "dropbox-10.10.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5229e68e5162b9f9c9404cd1ce03f6f0", + "name": "dropbox", + "sha256": "f344db84e1dd8ae3f0d9938851a3a7a2cbc99cd49a1a0feb77b7ee8f060652f7", + "size": 1078732, + "subdir": "linux-64", + "timestamp": 1606082717410, + "version": "10.10.0" + }, + "dropbox-10.10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2219404989ddea6ad5090145089306b5", + "name": "dropbox", + "sha256": "a8a14e4638939179b36373eb76784630bcee0aa202a55b5547e898077b628080", + "size": 1084146, + "subdir": "linux-64", + "timestamp": 1606082728447, + "version": "10.10.0" + }, + "dropbox-10.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c37f6113356d84e5d0fc32094abd2c61", + "name": "dropbox", + "sha256": "2a355d7e919f62e4f3137b9568f366c03e73e86d31dbc884afb730cf89b0785e", + "size": 1085015, + "subdir": "linux-64", + "timestamp": 1606082695930, + "version": "10.10.0" + }, + "dropbox-10.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8a52216e53f0cc14cf2cc35fe3cfd40", + "name": "dropbox", + "sha256": "ecace3a86c1e319760c8dd3fc96d8600fe9cc59ad43be99605d626b943e2c8ba", + "size": 1063002, + "subdir": "linux-64", + "timestamp": 1593439535340, + "version": "10.2.0" + }, + "dropbox-10.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca08330e76567abbe0875407bad1cc0d", + "name": "dropbox", + "sha256": "8bbb5bf64cd906d81061b3e0d06fba10786fb7103688625c5b1da502cd74172f", + "size": 1061777, + "subdir": "linux-64", + "timestamp": 1593439522334, + "version": "10.2.0" + }, + "dropbox-10.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "deef09a22f1c004132d45df00ae2aa69", + "name": "dropbox", + "sha256": "44c07ad0b459e3795b65b459c3dbaab95f9a1e7286c740e9fbae6ce29d996514", + "size": 1062652, + "subdir": "linux-64", + "timestamp": 1593439522326, + "version": "10.2.0" + }, + "dropbox-10.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c674ff75a688d3d57c5c79fc193fc36", + "name": "dropbox", + "sha256": "6d97e167cefbd9c637c6bb163abca98e86c61f0706c41ff9f8cf76529ac6abf7", + "size": 1063567, + "subdir": "linux-64", + "timestamp": 1600355265497, + "version": "10.4.1" + }, + "dropbox-10.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f979d68d9e9d9f4880ff791f8b4179a2", + "name": "dropbox", + "sha256": "36af5c24c55edceb9bbb9542f14ea2e26e8beceee12eafdecdb3f83a2294ed68", + "size": 1063749, + "subdir": "linux-64", + "timestamp": 1600355257650, + "version": "10.4.1" + }, + "dropbox-10.4.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "46283f55053078fa6366b3a68165ac26", + "name": "dropbox", + "sha256": "cbdd4b3e2577dd1be298f6a92a22d35e20dcf3492cad608ecdd9e570c712923f", + "size": 1067649, + "subdir": "linux-64", + "timestamp": 1600355278101, + "version": "10.4.1" + }, + "dropbox-10.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "802b05df1cd38fe603a2a0150f7b76db", + "name": "dropbox", + "sha256": "3d78c077d2c6280cbc162f623a1133a72eb4d05706b8371e2a53d2544182963e", + "size": 1060255, + "subdir": "linux-64", + "timestamp": 1601994666430, + "version": "10.5.0" + }, + "dropbox-10.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a980b84857a24cee63bfd95b71602d38", + "name": "dropbox", + "sha256": "ba41ad40dcdce47b7a41033d0272ba0f319118a85ea45537f85e86b4697316bf", + "size": 1067521, + "subdir": "linux-64", + "timestamp": 1601994627925, + "version": "10.5.0" + }, + "dropbox-10.5.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "38d11533bc8fe05bfe7c8b72bc751203", + "name": "dropbox", + "sha256": "7ccf3d088bc19b9f9a16bd04ce9c0f4fea6b1421b078e6d1315117ab3e36dd56", + "size": 1062175, + "subdir": "linux-64", + "timestamp": 1601994630565, + "version": "10.5.0" + }, + "dropbox-10.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb631047f7ee64f23d371de03d4bb281", + "name": "dropbox", + "sha256": "96908bce59267443571d444eabcdfb207edd5cddf7ac6c2aa511278c407e889b", + "size": 1064547, + "subdir": "linux-64", + "timestamp": 1602613308040, + "version": "10.6.0" + }, + "dropbox-10.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c86e37dd92ac80887205ca3d12eb7e0b", + "name": "dropbox", + "sha256": "e82ab9c23381ee30ef873a7fd53df3d934e63fe27eba4374bded61a13dcbaa3d", + "size": 1063376, + "subdir": "linux-64", + "timestamp": 1602613276461, + "version": "10.6.0" + }, + "dropbox-10.6.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a94c007a58c904ae67d1b483d2456c75", + "name": "dropbox", + "sha256": "7691b11ea87bea710e0941557411c0dfefb905b7959689923ff56a3278183c65", + "size": 1066691, + "subdir": "linux-64", + "timestamp": 1602613301927, + "version": "10.6.0" + }, + "dropbox-10.7.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ff0dbceb9e529b0f39abae0dc26de1c", + "name": "dropbox", + "sha256": "caed447915f60ab9143d895b0c668ac6510ee9e57514890dbf37abeb64f60747", + "size": 1066462, + "subdir": "linux-64", + "timestamp": 1603926407482, + "version": "10.7.0" + }, + "dropbox-10.7.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b7effc87958735f9929d7ab6ba918a5", + "name": "dropbox", + "sha256": "efd3fc40a3102dc9941d329b508e4577e04246f2a21907ccc86b3f48be2f3789", + "size": 1072532, + "subdir": "linux-64", + "timestamp": 1603926378531, + "version": "10.7.0" + }, + "dropbox-10.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e60652f8aa0d1f3574474e29dc870e08", + "name": "dropbox", + "sha256": "f9b8f658852acc598fc28fa76b73a4b83b68c4471b327a6318590b9350c543ff", + "size": 1067197, + "subdir": "linux-64", + "timestamp": 1603926417338, + "version": "10.7.0" + }, + "dropbox-10.8.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0247e8df6a900d50a3df98e2af4e12d8", + "name": "dropbox", + "sha256": "d829e949bab83d02074da025a727ceabe6aee2db28d98774a1e0faa436cd3bb8", + "size": 1076158, + "subdir": "linux-64", + "timestamp": 1604099179895, + "version": "10.8.0" + }, + "dropbox-10.8.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "840984b75abe24168efe3a21c6658b65", + "name": "dropbox", + "sha256": "a4646c6358ce587dce4937993fe96c055c403db42142043f38bef408d9149858", + "size": 1071222, + "subdir": "linux-64", + "timestamp": 1604099155753, + "version": "10.8.0" + }, + "dropbox-10.8.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8724d18fb43cf6419e6ff7e0753ac899", + "name": "dropbox", + "sha256": "87f93e5a6b2c1b671640c598f5199cb41b9f8fc71ccf4376758196fc4dd7227f", + "size": 1073652, + "subdir": "linux-64", + "timestamp": 1604099163041, + "version": "10.8.0" + }, + "dropbox-10.9.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "abe938435f983f1a98544323d0427be6", + "name": "dropbox", + "sha256": "bffba2aa2a6f02ac6c688476f7ef1e29f96145f4192e7aede9e8659c7b07d803", + "size": 1075985, + "subdir": "linux-64", + "timestamp": 1605066666399, + "version": "10.9.0" + }, + "dropbox-10.9.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "303908696f8beacdbda147f0d2e71017", + "name": "dropbox", + "sha256": "4169ddf699f2abb8baca99dc547c1c30a6802dddf138377d38ddcbfa8b04726f", + "size": 1083048, + "subdir": "linux-64", + "timestamp": 1605066628650, + "version": "10.9.0" + }, + "dropbox-10.9.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b3d12cc0a8e69ff39f3ae6afab254f8e", + "name": "dropbox", + "sha256": "8df369bae3d54947e85372ddf4414f57c9103d4489e26cff1c1a27c33f539698", + "size": 1086780, + "subdir": "linux-64", + "timestamp": 1605066661916, + "version": "10.9.0" + }, + "dropbox-11.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c66c80182081491175d6c04429f52aef", + "name": "dropbox", + "sha256": "ec218daab95b53d0442cfeba90ca20dbb98420ef847aad6de35a9820302c6633", + "size": 1475846, + "subdir": "linux-64", + "timestamp": 1622151293496, + "version": "11.10.0" + }, + "dropbox-11.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab99401fde6f4d29b9763fca2d3b4683", + "name": "dropbox", + "sha256": "d2d2ac600519bdc346570548f348f0f125d69fc4ec071d87d09cfeacd6c485b6", + "size": 1484277, + "subdir": "linux-64", + "timestamp": 1624291604944, + "version": "11.11.0" + }, + "dropbox-11.12.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "177ca62fe14b1081e567061f4f7be0bd", + "name": "dropbox", + "sha256": "a47b5beb7761413442d874b1f76c3010b7cac263dc4826dbb8c74b0f917d2c64", + "size": 1488058, + "subdir": "linux-64", + "timestamp": 1624616881706, + "version": "11.12.0" + }, + "dropbox-11.13.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba54c6c8c86760a11dc65ac8f953dd09", + "name": "dropbox", + "sha256": "decb72ab34d6027520dd0eb11d723092c8c34b16f1387ee8bc273b8a230b2b11", + "size": 1488081, + "subdir": "linux-64", + "timestamp": 1625729138273, + "version": "11.13.1" + }, + "dropbox-11.14.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dff1749211e98aa51ba63efe799fa682", + "name": "dropbox", + "sha256": "bd8bc45fd12c8e2dacedb116e4146df84f9083a127b3c2b30bf2c9d35cfbd299", + "size": 1502319, + "subdir": "linux-64", + "timestamp": 1640805498089, + "version": "11.14.0" + }, + "dropbox-11.14.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "35eb2b6166da77d361ddae79dc42e68a", + "name": "dropbox", + "sha256": "70e8ca9de82d61ad1cbb54f507448829c02f0876fd8fcbf9897f549ca1aeed12", + "size": 1491208, + "subdir": "linux-64", + "timestamp": 1632880820806, + "version": "11.14.0" + }, + "dropbox-11.14.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a7491347142077869ec05824ea02b1b", + "name": "dropbox", + "sha256": "0dd844ba0fafd126da16079ac811719f8ce62343a9f15360434e8bd2c7796e27", + "size": 1500035, + "subdir": "linux-64", + "timestamp": 1632890789054, + "version": "11.14.0" + }, + "dropbox-11.14.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8419fe03f2338cc65ffb8636a000d5e0", + "name": "dropbox", + "sha256": "006972492b7ace07beb77cd2bf066f1ce0648aa4f503b776eb843c1648ce68b6", + "size": 1489496, + "subdir": "linux-64", + "timestamp": 1632890789569, + "version": "11.14.0" + }, + "dropbox-11.14.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0569782ce0e088d5070328e4d5e0c33a", + "name": "dropbox", + "sha256": "c4d6d6f8c7e0b38679e3dadda90c87cf37d8dddda870cc4bf9f84899af8deb10", + "size": 1486929, + "subdir": "linux-64", + "timestamp": 1627019520878, + "version": "11.14.0" + }, + "dropbox-11.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7cce1929e741ac23ee78311b7b3df8a5", + "name": "dropbox", + "sha256": "2bb5b88972350001b032940660723743dee27922bae2cc72c9969359f5e332f0", + "size": 1466043, + "subdir": "linux-64", + "timestamp": 1618565109021, + "version": "11.7.0" + }, + "dropbox-11.8.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92d5d9421cd1377f9cc42a4be1261bbd", + "name": "dropbox", + "sha256": "4eac7d1fd35fd6413d3e7dc1af3efe384c6fc7831a40c5fbd74a07cd7eb34314", + "size": 1473356, + "subdir": "linux-64", + "timestamp": 1620619723022, + "version": "11.8.0" + }, + "dropbox-11.9.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0605fe6660b908e43fbae0b90896ebb0", + "name": "dropbox", + "sha256": "b086f2fd8f827b7571da495cdabbbe3bc561408d51347cd7b10648f66ae33e57", + "size": 1464385, + "subdir": "linux-64", + "timestamp": 1620823759212, + "version": "11.9.0" + }, + "dropbox-8.4.0-py27hdd59973_0.tar.bz2": { + "build": "py27hdd59973_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96edbbcf2ee8dbe908d6be525d971e31", + "name": "dropbox", + "sha256": "6c669bffdc11d52f614be461825f0cea9e96565c7a21c6cdf10c29ef6b052996", + "size": 625030, + "subdir": "linux-64", + "timestamp": 1508628750587, + "version": "8.4.0" + }, + "dropbox-8.4.0-py35hd086d9a_0.tar.bz2": { + "build": "py35hd086d9a_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a920199d3daef1405b29a10c9d0c3be", + "name": "dropbox", + "sha256": "4e04e7af12b2f4bc1f0766bd501eec0279910c243729145782282f8f10169599", + "size": 654236, + "subdir": "linux-64", + "timestamp": 1508628751141, + "version": "8.4.0" + }, + "dropbox-8.4.0-py36ha3455e0_0.tar.bz2": { + "build": "py36ha3455e0_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3647e894dda54e501a1a454b15da21a3", + "name": "dropbox", + "sha256": "e0c81bc9059a16d2c0b948387797abf236862116fb9cf7f7106f932fda5c19f7", + "size": 650958, + "subdir": "linux-64", + "timestamp": 1508628765880, + "version": "8.4.0" + }, + "dropbox-8.5.0-py27h2b0e868_0.tar.bz2": { + "build": "py27h2b0e868_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "072b38b4ab268c8ae7e8c555778fcb5a", + "name": "dropbox", + "sha256": "5d676394f1e05d9d4e95fd01d43be9d1d5fa5a5157dd4356482a1d99b1e573dd", + "size": 635123, + "subdir": "linux-64", + "timestamp": 1511840659135, + "version": "8.5.0" + }, + "dropbox-8.5.0-py35h4c242c8_0.tar.bz2": { + "build": "py35h4c242c8_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f3cc84a068a84c43b0ced7b868e9cc3", + "name": "dropbox", + "sha256": "c9c9b7f92db2a3a64eb732339068c057e427565cc6423a950102ffff44d52eec", + "size": 667093, + "subdir": "linux-64", + "timestamp": 1511840658791, + "version": "8.5.0" + }, + "dropbox-8.5.0-py36h9ff2726_0.tar.bz2": { + "build": "py36h9ff2726_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3911c99a4a575c5ad5520771c6112fe9", + "name": "dropbox", + "sha256": "5365516bf6794f671cfe7963a875f150948cbc4863bbc9bf1c76721a8d17ad9f", + "size": 667450, + "subdir": "linux-64", + "timestamp": 1511840659868, + "version": "8.5.0" + }, + "dropbox-8.7.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd1f23b5f65467d88d40194dad6a1fb1", + "name": "dropbox", + "sha256": "457043affde33c6ddb571d2cab542715451c2123f0f2e36d140d8271782bbc38", + "size": 679048, + "subdir": "linux-64", + "timestamp": 1520916171549, + "version": "8.7.1" + }, + "dropbox-8.7.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5039b6999a1b77158c71a8403f41afcb", + "name": "dropbox", + "sha256": "eb53b55f40944ad33487a79b0d24677e81321aebd1bd9e0836f3d76be66d7f34", + "size": 726817, + "subdir": "linux-64", + "timestamp": 1520916190932, + "version": "8.7.1" + }, + "dropbox-8.7.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "048f2dcf55fdc63da75b8c4b87677661", + "name": "dropbox", + "sha256": "13218116cb2f32c611c61329f076cecdadca8dd8be6ad4f71e7a937061f695c0", + "size": 725886, + "subdir": "linux-64", + "timestamp": 1520916152629, + "version": "8.7.1" + }, + "dropbox-8.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2c85f3fcba783abc1e1b01267d83eb6", + "name": "dropbox", + "sha256": "65b0b125666e7d6b3eee3f0562ec3fc35e597e2e41a0e9ceeb6d66ad9b23f0e7", + "size": 706013, + "subdir": "linux-64", + "timestamp": 1524508581577, + "version": "8.8.1" + }, + "dropbox-8.8.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e30b3981c189c72af90a9e354dc19b3", + "name": "dropbox", + "sha256": "550317d25a443f3b46004e5f87a4fa81489f94136e776a9fd9337791d19a077f", + "size": 743432, + "subdir": "linux-64", + "timestamp": 1524508589869, + "version": "8.8.1" + }, + "dropbox-8.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d6820c1cad4d7e2b5ad99fea27bd961", + "name": "dropbox", + "sha256": "8e61ea31bdfd27bde62b6b5dc2d35680e6ae8f566669c843723afc7fa2aa347c", + "size": 746860, + "subdir": "linux-64", + "timestamp": 1524508592237, + "version": "8.8.1" + }, + "dropbox-8.9.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ae0fb155c31b9744aa4b522fcdc58b6", + "name": "dropbox", + "sha256": "9d08faeb07c08e62fe45d6891b4e4610517660c91541ff79cf9bfea33ed15749", + "size": 714568, + "subdir": "linux-64", + "timestamp": 1526929448043, + "version": "8.9.0" + }, + "dropbox-8.9.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92adb96379bbf917fc1e12f8294b2dd2", + "name": "dropbox", + "sha256": "1fb8fef5e7bb5851670e0b5ee829347d91f4c5043fbf7b3269faea9b30fc352b", + "size": 751110, + "subdir": "linux-64", + "timestamp": 1526929468322, + "version": "8.9.0" + }, + "dropbox-8.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e29fcc426ecfe606762dcf10bc3e12d", + "name": "dropbox", + "sha256": "7b68458b31d2b3d19b4954faac3661633080be3260185b16efc0c2f7d4b5eee6", + "size": 753006, + "subdir": "linux-64", + "timestamp": 1526929416425, + "version": "8.9.0" + }, + "dropbox-9.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74ce43ad65d01b5e16cddaba1fc08ec1", + "name": "dropbox", + "sha256": "36017e0b07c01066b0f08b233e564c7b9b6d4282fd334d33bbac74243ab7686c", + "size": 713335, + "subdir": "linux-64", + "timestamp": 1534438441169, + "version": "9.0.0" + }, + "dropbox-9.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3fd2809f4ee42477f86212b9bb649684", + "name": "dropbox", + "sha256": "dbec921bdb2cac57c2a40b593ff1b9484b676b3b437a7ad6964dc869e29b6041", + "size": 750061, + "subdir": "linux-64", + "timestamp": 1534437094755, + "version": "9.0.0" + }, + "dropbox-9.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7078aa89a5014cfd26dc2acdefc70260", + "name": "dropbox", + "sha256": "1a078789bc80018744ef83732ab8af298596dd68505591c3a61c9558bbfc7ba7", + "size": 752374, + "subdir": "linux-64", + "timestamp": 1534437115387, + "version": "9.0.0" + }, + "dropbox-9.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e254341f3e5529862db26b3dcacb904a", + "name": "dropbox", + "sha256": "a7f1648cd7bdd52644f7a4f2765900c9fc45273a82f3c31ca7a4ef00cc23cd89", + "size": 752731, + "subdir": "linux-64", + "timestamp": 1534437196488, + "version": "9.0.0" + }, + "dropbox-9.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "400fde86da4afa6049114549a843bfd8", + "name": "dropbox", + "sha256": "3f97b94389538470e0a0462ce3dd022250f581a213477c46fa4ce0664c3b77e7", + "size": 741280, + "subdir": "linux-64", + "timestamp": 1539474978419, + "version": "9.1.0" + }, + "dropbox-9.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5de027f3e6bba595984c64ba3749b36b", + "name": "dropbox", + "sha256": "c2000dec1d43d706d59c387b9db228aa90bcb901abd9da2d9f805403a02a3392", + "size": 782687, + "subdir": "linux-64", + "timestamp": 1539475001759, + "version": "9.1.0" + }, + "dropbox-9.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "65eae1925189d561defe7c663a713cd8", + "name": "dropbox", + "sha256": "cb8fafb054ca20bfb5e43d1512680328f02c07b069c1472cf329f004da3b25c6", + "size": 782416, + "subdir": "linux-64", + "timestamp": 1539474990229, + "version": "9.1.0" + }, + "dropbox-9.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96494c305fbdb303e72f5cb18a419254", + "name": "dropbox", + "sha256": "892a22ddcf9b9e9888a542477d4422d6c6b6f399e4901479b327f6490a35021c", + "size": 766505, + "subdir": "linux-64", + "timestamp": 1543521150943, + "version": "9.2.0" + }, + "dropbox-9.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8b15b4ba38ff119eae569bff53ead180", + "name": "dropbox", + "sha256": "4536927285d6a268dd751a33c062151d8c3f0b5515961cb1c4b1d41b03fdf1d5", + "size": 815137, + "subdir": "linux-64", + "timestamp": 1543521186982, + "version": "9.2.0" + }, + "dropbox-9.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ade6f94c2ceb8e63aa767e1fe0cedb3", + "name": "dropbox", + "sha256": "a173f3ac4aac31bda853b43b4891f5f92122e43aaf026bfb904ef9bd1dfdb0a2", + "size": 814121, + "subdir": "linux-64", + "timestamp": 1543521137381, + "version": "9.2.0" + }, + "dropbox-9.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "443261951bef09894257ff1a5d478cf9", + "name": "dropbox", + "sha256": "3457b80a30cfaee234e05a385833910256097628ecd89c9713fc5f0eb23e7828", + "size": 764729, + "subdir": "linux-64", + "timestamp": 1545112084720, + "version": "9.3.0" + }, + "dropbox-9.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a82d5ede20afdb359e614f97131227cf", + "name": "dropbox", + "sha256": "6c23974383dfe04764209b15b3ea5cc57885b64f646cf0c3c0da626221403d83", + "size": 809667, + "subdir": "linux-64", + "timestamp": 1545112125028, + "version": "9.3.0" + }, + "dropbox-9.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7619247daaa388a35e4d86aa6082f20", + "name": "dropbox", + "sha256": "a10885a439cc74ef73ff23ad16f11fe6276afc2056030911cc8f4a2acfaf980d", + "size": 807985, + "subdir": "linux-64", + "timestamp": 1545112121215, + "version": "9.3.0" + }, + "dropbox-9.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2b60aa07e6714dd4716b3b3ae7a7a4b", + "name": "dropbox", + "sha256": "37c9249eab469f5cde9b9bad47b50fa4bb295603f945a3759cee3af8014dcfc2", + "size": 838335, + "subdir": "linux-64", + "timestamp": 1564673307789, + "version": "9.4.0" + }, + "dropbox-9.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c9cd656e855d106941cdc07955dd9886", + "name": "dropbox", + "sha256": "5f70a7b9f75064b72e33d1fdf481fbea5b5644b45d7686ead988735a046bbd34", + "size": 872575, + "subdir": "linux-64", + "timestamp": 1564674410772, + "version": "9.4.0" + }, + "dropbox-9.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df8a139095ab7da88edaa858e51774ad", + "name": "dropbox", + "sha256": "f0f180fb93e12bd2da570ded8649f6841c421ef96159142537e560c921453626", + "size": 875974, + "subdir": "linux-64", + "timestamp": 1564673281371, + "version": "9.4.0" + }, + "dropbox-9.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a960626819964b05d27d9aa1fd409162", + "name": "dropbox", + "sha256": "10a43dec666f66671087b22c2c7ff2b647c23566121642711a6d526bf8bc52ba", + "size": 883554, + "subdir": "linux-64", + "timestamp": 1574238556621, + "version": "9.4.0" + }, + "dsdp-5.8-h2c4e229_0.tar.bz2": { + "build": "h2c4e229_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0" + ], + "license": "DSDP", + "md5": "0fca0268fd52872f55ffe9a6b0e87e0b", + "name": "dsdp", + "sha256": "271f1c79b8afd17c42bce15b802d94a72a4a29131e905fc76b143dc2910c416f", + "size": 236334, + "subdir": "linux-64", + "timestamp": 1528986722167, + "version": "5.8" + }, + "dsdp-5.8-h4077e5c_1.tar.bz2": { + "build": "h4077e5c_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0" + ], + "license": "DSDP", + "md5": "da63ca5de2a54e4b339b6332b56e692c", + "name": "dsdp", + "sha256": "9deec6e57a4573c05af4e50d6a90dd4af47923e0d6aaa5d2d7bd329aad33ec21", + "size": 241751, + "subdir": "linux-64", + "timestamp": 1656067884060, + "version": "5.8" + }, + "dsdp-5.8-h75fe3a5_0.tar.bz2": { + "build": "h75fe3a5_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0" + ], + "license": "DSDP", + "md5": "93b14fc829cf8b993899fae593033f0f", + "name": "dsdp", + "sha256": "7f50ceca1ce2bb7625871a3c388be111a43c82d429963ea6bf7ddc5fe195374c", + "size": 242668, + "subdir": "linux-64", + "timestamp": 1550693665184, + "version": "5.8" + }, + "dsdp-5.8-h7aab8bc_1.tar.bz2": { + "build": "h7aab8bc_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0" + ], + "license": "DSDP", + "md5": "0b4fe7335d582cc86ece39bb8e283504", + "name": "dsdp", + "sha256": "d6faacf65d15ff59e44a1f928c5b896ac4f59faa94a1b7150a508f24a69e82ea", + "size": 241764, + "subdir": "linux-64", + "timestamp": 1656067824413, + "version": "5.8" + }, + "dsdp-5.8-h9e0dedd_0.tar.bz2": { + "build": "h9e0dedd_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0" + ], + "license": "DSDP", + "md5": "c5906ad6aa4bb6e43bf2fca9fbdda62c", + "name": "dsdp", + "sha256": "4239d6505fabb882090920304c532795cc808fbc317c9707338240bcc7fc2f11", + "size": 236370, + "subdir": "linux-64", + "timestamp": 1528986753791, + "version": "5.8" + }, + "dsdp-5.8-hfa32c7d_0.tar.bz2": { + "build": "hfa32c7d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0" + ], + "license": "DSDP", + "md5": "19784ac895de3416fc85d1e8a711067c", + "name": "dsdp", + "sha256": "4869c4e4b2b67afd4bf10986635a3f648660d81fbd8d00c1283a40902b1661a6", + "size": 242803, + "subdir": "linux-64", + "timestamp": 1550693724288, + "version": "5.8" + }, + "dulwich-0.21.3-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "constrains": [ + "paramiko" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "urllib3 >=1.25" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "79cbb0abc037b7a0412ddbc2dd689e69", + "name": "dulwich", + "sha256": "53c1997b38e49577fb12438b1a1473dae1a9c7b42a5d5a9862a7ba2133167a3e", + "size": 766950, + "subdir": "linux-64", + "timestamp": 1679420145441, + "version": "0.21.3" + }, + "dulwich-0.21.3-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "constrains": [ + "paramiko" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "urllib3 >=1.25" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f989fa916ef73f275640a22ed7b3cc70", + "name": "dulwich", + "sha256": "132acfdf31c1338a2a007d41fc14cce5adfb5546d94ccceb0697dcb3d244cdfe", + "size": 1011567, + "subdir": "linux-64", + "timestamp": 1679420178779, + "version": "0.21.3" + }, + "dulwich-0.21.3-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "constrains": [ + "paramiko" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "urllib3 >=1.25" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "405502ce6fad7a20c7a6be476ebeb1ff", + "name": "dulwich", + "sha256": "76606b5f12a36e27be52a487726eaab9770c33ab3094664b7e9c6d514f0a53b3", + "size": 760342, + "subdir": "linux-64", + "timestamp": 1679420111993, + "version": "0.21.3" + }, + "dulwich-0.21.3-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "constrains": [ + "paramiko" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "urllib3 >=1.25" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fa22b6965cd8e755093addfb46b5f9cf", + "name": "dulwich", + "sha256": "d912716f1d0bf4bff3af78850b0031249ea3d171d8739a4bf0248da346f172d9", + "size": 760773, + "subdir": "linux-64", + "timestamp": 1679420079311, + "version": "0.21.3" + }, + "duma_linux-64-2.5.15-h1234567_0.tar.bz2": { + "build": "h1234567_0", + "build_number": 0, + "depends": [], + "license": "GPL", + "md5": "c21f8ee0ee61271b568a2b74a913a923", + "name": "duma_linux-64", + "sha256": "2d2a40168a382bf36c0c3e95a2b8bb0f7d15b7ac5901911cff6f4bf9455a062e", + "size": 115254, + "subdir": "linux-64", + "timestamp": 1652859649182, + "version": "2.5.15" + }, + "duma_linux-64-2.5.15-h1234567_1.tar.bz2": { + "build": "h1234567_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "1e067b6329f3be5b15870825ddc1c7de", + "name": "duma_linux-64", + "sha256": "827d17f881b1aa953ff31389a21863c5bff1d87547cc3190878591e0642d88d4", + "size": 115344, + "subdir": "linux-64", + "timestamp": 1654090732360, + "version": "2.5.15" + }, + "duma_linux-64-2.5.15-h28ad9a3_3.tar.bz2": { + "build": "h28ad9a3_3", + "build_number": 3, + "depends": [], + "license": "GPL", + "md5": "421203c69a22acf9723bd09632a63daf", + "name": "duma_linux-64", + "sha256": "e3bff1738cf3fd2b6e0b89501eadd75f3024e08e80fe57168331d852c39db989", + "size": 109534, + "subdir": "linux-64", + "timestamp": 1520534492887, + "version": "2.5.15" + }, + "duma_linux-64-2.5.15-h49555fe_2.tar.bz2": { + "build": "h49555fe_2", + "build_number": 2, + "depends": [], + "license": "GPL", + "md5": "5d3eb4b548667ea6004cb2ab7109bc1c", + "name": "duma_linux-64", + "sha256": "78a1343b71ef2493d720b7e2da321a07224a4ed65a97b2b311223171e2a426e8", + "size": 95599, + "subdir": "linux-64", + "timestamp": 1507262704045, + "version": "2.5.15" + }, + "duma_linux-64-2.5.15-hec2b5b5_1.tar.bz2": { + "build": "hec2b5b5_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "9c9f35ca21609ec4f865b3ec06a65253", + "name": "duma_linux-64", + "sha256": "4d97093eb54b8f49f650be2c166a657b20fd4d228c60940429693c57e28e9709", + "size": 95451, + "subdir": "linux-64", + "timestamp": 1505665553992, + "version": "2.5.15" + }, + "easyocr-1.6.2-py310hdb19cb5_0.tar.bz2": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ninja", + "numpy", + "pillow", + "py-opencv >=4.6.0", + "pyclipper", + "python >=3.10,<3.11.0a0", + "python-bidi", + "pytorch", + "pyyaml", + "scikit-image", + "scipy", + "shapely", + "torchvision >=0.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "28c40ab8551265e926f5d4e169e3e347", + "name": "easyocr", + "sha256": "b17ae3573751bdcea6d6221ccf66d8f1ec7ef77a72e3b46bb7317dbd29d6b232", + "size": 63620637, + "subdir": "linux-64", + "timestamp": 1676627205933, + "version": "1.6.2" + }, + "easyocr-1.6.2-py37hdb19cb5_0.tar.bz2": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ninja", + "numpy", + "pillow", + "py-opencv >=4.6.0", + "pyclipper", + "python >=3.7,<3.8.0a0", + "python-bidi", + "pytorch", + "pyyaml", + "scikit-image", + "scipy", + "shapely", + "torchvision >=0.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "94f5c9ff8fe279cf7c568e1f8c1e3bab", + "name": "easyocr", + "sha256": "8b06a3bbb421fe6c14c4480b6ea5232884637e0a7a95e08bb77318efa6b0ad14", + "size": 63629878, + "subdir": "linux-64", + "timestamp": 1676627041026, + "version": "1.6.2" + }, + "easyocr-1.6.2-py38hdb19cb5_0.tar.bz2": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ninja", + "numpy", + "pillow", + "py-opencv >=4.6.0", + "pyclipper", + "python >=3.8,<3.9.0a0", + "python-bidi", + "pytorch", + "pyyaml", + "scikit-image", + "scipy", + "shapely", + "torchvision >=0.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9df0224a86e0508ad9765c48b542600c", + "name": "easyocr", + "sha256": "8af4dca3d40e8aedaa0b02ad156a81b089f0aa14a777aed47a5f5b7d98ee9a19", + "size": 63619044, + "subdir": "linux-64", + "timestamp": 1676627360996, + "version": "1.6.2" + }, + "easyocr-1.6.2-py39hdb19cb5_0.tar.bz2": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ninja", + "numpy", + "pillow", + "py-opencv >=4.6.0", + "pyclipper", + "python >=3.9,<3.10.0a0", + "python-bidi", + "pytorch", + "pyyaml", + "scikit-image", + "scipy", + "shapely", + "torchvision >=0.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "89ed1ff7f8f420c92550b0c57098519f", + "name": "easyocr", + "sha256": "18af1de888730ad3f5125f7fbec2d5c89b6d7f9df0c9b4af4dfff213cff912e8", + "size": 63627986, + "subdir": "linux-64", + "timestamp": 1676627515522, + "version": "1.6.2" + }, + "ecdsa-0.13-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "0586efddb5ad328e3eb92d52aff1dca0", + "name": "ecdsa", + "sha256": "b894a02ffcfea93a2d99477180e8659b450185c3db0ba13c7ac1c8e246a5ef8d", + "size": 79655, + "subdir": "linux-64", + "timestamp": 1530876140514, + "version": "0.13" + }, + "ecdsa-0.13-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "83444723b6ae2840b267e03321f16b55", + "name": "ecdsa", + "sha256": "2174b23a59626f81d2b06d8f80f3c404d5cfb209587c795cf7f07bedb8ae5e7e", + "size": 79733, + "subdir": "linux-64", + "timestamp": 1537807921091, + "version": "0.13" + }, + "ecdsa-0.13-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "4559a76eec3dd114a3e3c7f054ed1725", + "name": "ecdsa", + "sha256": "b2403dc54b2137d40dffa53ffc3deb6ca50096fdad44abb9ad8aeb84a4e13308", + "size": 80863, + "subdir": "linux-64", + "timestamp": 1642499233038, + "version": "0.13" + }, + "ecdsa-0.13-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "4f97a3f2169032af710e72e12704fc71", + "name": "ecdsa", + "sha256": "9a57e7a5877920ebe3701d42656b4b0b94c9d20c11cff9c9745bc097d93745f7", + "size": 103212, + "subdir": "linux-64", + "timestamp": 1676905934641, + "version": "0.13" + }, + "ecdsa-0.13-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "3fd71d548edb4e43c57953418d97e9ce", + "name": "ecdsa", + "sha256": "b30b80c4ab0eb8dca6969e641bb8c6c380f2e205e557cf60dc0f1127b7fd7140", + "size": 81116, + "subdir": "linux-64", + "timestamp": 1537807935811, + "version": "0.13" + }, + "ecdsa-0.13-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9320bcf20a5d8e5e3f6a7b0932d055e8", + "name": "ecdsa", + "sha256": "449999098f238f742b6830eefb1bfdcb2e95a5e697e2b206d20d6b235c6696da", + "size": 80489, + "subdir": "linux-64", + "timestamp": 1530876089205, + "version": "0.13" + }, + "ecdsa-0.13-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9b5cd18e001f23a3095c5211c5ad153b", + "name": "ecdsa", + "sha256": "05887840eb6045d49c474a7f65cbd3d533ed53679f6f550a0272b328d96c5644", + "size": 80650, + "subdir": "linux-64", + "timestamp": 1537807945494, + "version": "0.13" + }, + "ecdsa-0.13-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "247a84a5211d0b272732b051f1956690", + "name": "ecdsa", + "sha256": "8d1bf5e50e2090bcc1984ca604bdd6a5c635d29da3d35a1af7bc20c1509efda3", + "size": 355893, + "subdir": "linux-64", + "timestamp": 1632891031686, + "version": "0.13" + }, + "ecdsa-0.13-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6f7d96f75ea2b12bc70e0afd7bdfa079", + "name": "ecdsa", + "sha256": "7d8b73b771bc946a6ced144ad57510cb534c24ee4d2178e19a4e4aa88b9d2122", + "size": 80364, + "subdir": "linux-64", + "timestamp": 1530876115348, + "version": "0.13" + }, + "ecdsa-0.13-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a95aa2b6d830719d3a3e36e3ecd850b6", + "name": "ecdsa", + "sha256": "879af3509a1dc9b9bed10c1c9c186ceb2e5bfa3bae38aea63c49bc925a723808", + "size": 80515, + "subdir": "linux-64", + "timestamp": 1537807884441, + "version": "0.13" + }, + "ecdsa-0.13-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6d712c47bc727c3a7c7c0922bd9eed2e", + "name": "ecdsa", + "sha256": "c1c4e711aa170fdef21115bf1cc6e62eeba260af5d79bbfe30f63838aadc0027", + "size": 349720, + "subdir": "linux-64", + "timestamp": 1632881020834, + "version": "0.13" + }, + "ecdsa-0.13-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "4834c5764a33c0890ab101a528069348", + "name": "ecdsa", + "sha256": "c57aae1be760a0d8fae36354fcb7e2b820ade3f7fbeb4c69241563cacfef9e24", + "size": 80952, + "subdir": "linux-64", + "timestamp": 1572357143205, + "version": "0.13" + }, + "ecdsa-0.13-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "0816dfeae3196e410189446882cabb76", + "name": "ecdsa", + "sha256": "09b058fea05736a872fe6af6649f6715711c8d1cdc2c5d49de91e14d1f32fa12", + "size": 349396, + "subdir": "linux-64", + "timestamp": 1632891447592, + "version": "0.13" + }, + "ecdsa-0.13-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "630ca481833055fb538eb95fa5d1d5dd", + "name": "ecdsa", + "sha256": "070ed1a0510cc6028548f8fcff6ff21848d4cd5b288191c14a4c37fb82e39c4d", + "size": 352088, + "subdir": "linux-64", + "timestamp": 1632891004925, + "version": "0.13" + }, + "ecos-2.0.12-py310ha9d4c09_0.tar.bz2": { + "build": "py310ha9d4c09_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "e3e605f76080f09d7d99d908f742cc35", + "name": "ecos", + "sha256": "f73be7671f094c2c892f8d40b44d9744d192bdbbe15584f8d2e4c432bc518965", + "size": 87577, + "subdir": "linux-64", + "timestamp": 1677702303322, + "version": "2.0.12" + }, + "ecos-2.0.12-py311hbed6279_0.tar.bz2": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "e13de0cfacfbfa5d6017c87eda6c6a4c", + "name": "ecos", + "sha256": "5ce033093c1a1beb8af6b342e1c8eb9c6bad36f9a1c65831682e8f5bf1e9d8cc", + "size": 88449, + "subdir": "linux-64", + "timestamp": 1677770141369, + "version": "2.0.12" + }, + "ecos-2.0.12-py38h7deecbd_0.tar.bz2": { + "build": "py38h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "d5b2db1d6530beb241929862eeb3ee13", + "name": "ecos", + "sha256": "7cfd88752d24d9b5e9feb0ed99901e9527fa06f8e2dcbeb79a49a8548573b8b0", + "size": 87776, + "subdir": "linux-64", + "timestamp": 1677702215206, + "version": "2.0.12" + }, + "ecos-2.0.12-py39h7deecbd_0.tar.bz2": { + "build": "py39h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "ac31ebb290aad86b13395084657235a0", + "name": "ecos", + "sha256": "951eb8e990579983b949f37dca896234d4541a0805f41de8bb432e77f0e8272a", + "size": 87442, + "subdir": "linux-64", + "timestamp": 1677702260169, + "version": "2.0.12" + }, + "ecos-2.0.5-py27h3010b51_0.tar.bz2": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.9" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "2749c5758e5febf983f7a5977f9d5dc3", + "name": "ecos", + "sha256": "c85e2d7573f97e4ff6a88cc55a7f7df0ccba0717e14aa0817a52fad2ab8c5142", + "size": 59413, + "subdir": "linux-64", + "timestamp": 1527023563598, + "version": "2.0.5" + }, + "ecos-2.0.5-py35h3010b51_0.tar.bz2": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.9" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "d82891e4d3464911a83792db0ef30014", + "name": "ecos", + "sha256": "37f806463ccd58c7fddb3d84b909acef4741614819dec1613a9d62985f582509", + "size": 59453, + "subdir": "linux-64", + "timestamp": 1527023567757, + "version": "2.0.5" + }, + "ecos-2.0.5-py36h3010b51_0.tar.bz2": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.9" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "464a1fcef3010c3d1fe16f42a9c37d19", + "name": "ecos", + "sha256": "6994cc9434777a7ee555c6c08f6e7f04e4d894f8db99eb14b5fea5d1ebcdb3e1", + "size": 59353, + "subdir": "linux-64", + "timestamp": 1527023649855, + "version": "2.0.5" + }, + "ecos-2.0.7-py27hdd07704_0.tar.bz2": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "4562b261dfaefb699ff6f8bc2f8b3c6a", + "name": "ecos", + "sha256": "48a8636e9bfcec17dd22f1d2badcafe0f5ae41a95eec5e281edbc1b49fc86679", + "size": 77822, + "subdir": "linux-64", + "timestamp": 1569433227262, + "version": "2.0.7" + }, + "ecos-2.0.7-py36hdd07704_0.tar.bz2": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "710b7c274cffd62f271a4d2e60302227", + "name": "ecos", + "sha256": "0fe7ccaca0d14ecf1fb9253f22935d09ee2e3f04b85924d83f352fc88a4e3f76", + "size": 77846, + "subdir": "linux-64", + "timestamp": 1569433233067, + "version": "2.0.7" + }, + "ecos-2.0.7-py37hdd07704_0.tar.bz2": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "b97c6f7b345511655a0521417e774c70", + "name": "ecos", + "sha256": "10183f2fd8e651ded40617b1001fb15a949a505b1e5a22f94f162509dc1fa86d", + "size": 77861, + "subdir": "linux-64", + "timestamp": 1569433267435, + "version": "2.0.7" + }, + "ecos-2.0.7.post1-py310h9102076_0.tar.bz2": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "c451e9900d9404a908c60c8d4baaca85", + "name": "ecos", + "sha256": "079c2f5bae9cc151435287534beaf57a71ca0debd3d0b7401ec5f821065c8d39", + "size": 198513, + "subdir": "linux-64", + "timestamp": 1640809004825, + "version": "2.0.7.post1" + }, + "ecos-2.0.7.post1-py36h6323ea4_0.tar.bz2": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "20496be965b2ffa720f8cd440de305b4", + "name": "ecos", + "sha256": "8a380a90e2eb73adbdd9ef762895616ddb516b565d9a726f2e36b1e960a1ebd3", + "size": 78505, + "subdir": "linux-64", + "timestamp": 1614178303851, + "version": "2.0.7.post1" + }, + "ecos-2.0.7.post1-py36heb32a55_0.tar.bz2": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "48b3461b521ca8e4805f4a50933cf814", + "name": "ecos", + "sha256": "c43e670e35a46bd0b400eb1d68462a4f852ae51c1b04b8c0239d4ac147a3ef69", + "size": 78123, + "subdir": "linux-64", + "timestamp": 1592217405007, + "version": "2.0.7.post1" + }, + "ecos-2.0.7.post1-py37h6323ea4_0.tar.bz2": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "7706bdc0714eb4f1f48a0c9283beadaa", + "name": "ecos", + "sha256": "a60ea6e3314845b41a4bd1e3a044770d6dd3a193da5bcbf2dd428b3f63237e0c", + "size": 78454, + "subdir": "linux-64", + "timestamp": 1614177951831, + "version": "2.0.7.post1" + }, + "ecos-2.0.7.post1-py37heb32a55_0.tar.bz2": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "e5c3d90ffa362b6c6820d36ad2d1bc33", + "name": "ecos", + "sha256": "d9cdfa926fd476ac4db3d7b25247ec9e8ddaed785ae4bcc7351d26b4b1cfaf64", + "size": 78101, + "subdir": "linux-64", + "timestamp": 1592217405618, + "version": "2.0.7.post1" + }, + "ecos-2.0.7.post1-py38h6323ea4_0.tar.bz2": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "5590d740d34dcb5c1074564f446313ee", + "name": "ecos", + "sha256": "393a7a32558c09c16967f16ae67e01d72c99ff2c3cb8415f68e5afdbe135778f", + "size": 78780, + "subdir": "linux-64", + "timestamp": 1614177364946, + "version": "2.0.7.post1" + }, + "ecos-2.0.7.post1-py38heb32a55_0.tar.bz2": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "ce6aaf92821bb77e9abf8317cca2dbfd", + "name": "ecos", + "sha256": "9ed40e5f71825eee60fb57d5f49f5999019cc452fdf4d918069ed4462b5b7160", + "size": 78511, + "subdir": "linux-64", + "timestamp": 1592217385963, + "version": "2.0.7.post1" + }, + "ecos-2.0.7.post1-py39h6323ea4_0.tar.bz2": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "86d19223416b9fd8df611a5461c7ef1d", + "name": "ecos", + "sha256": "54cef8910bfb8d4458f0ea5fcf57c5575a4a447cb9bf7cf1112169760a3d690b", + "size": 78885, + "subdir": "linux-64", + "timestamp": 1614178291267, + "version": "2.0.7.post1" + }, + "editables-0.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c14f2ec52de02eca04b0b36778c9bc3a", + "name": "editables", + "sha256": "ca6f0d71aab180117ee99a2ef1458c6a8191ee087ffe7f4ea94f0f0035498073", + "size": 10024, + "subdir": "linux-64", + "timestamp": 1661189187722, + "version": "0.3" + }, + "editables-0.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ad8da0cafb1ca7580cbf301b3267beb", + "name": "editables", + "sha256": "286b157e513d1616d8b5237ca7a5c88e4eb88868908f6e7997f43b8b03115e7a", + "size": 11641, + "subdir": "linux-64", + "timestamp": 1676822802816, + "version": "0.3" + }, + "editables-0.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5851e4e8805f75a174a7befe31ee515c", + "name": "editables", + "sha256": "fb11faeafea19809461115ff7d76a0c599fb3e03909fa1f9d1d7feb59716b296", + "size": 9981, + "subdir": "linux-64", + "timestamp": 1661189231151, + "version": "0.3" + }, + "editables-0.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb1ef56a8ad1505169550a8dd12de9be", + "name": "editables", + "sha256": "85406362216bc20e87ff62d472ce3496d5cea4d12e4f9b0a89e341086d08197d", + "size": 9972, + "subdir": "linux-64", + "timestamp": 1661189250044, + "version": "0.3" + }, + "editables-0.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "441a2b6e782b524aaf6c7df8c48187de", + "name": "editables", + "sha256": "a69cc89070a6ddf3e46e10d43acd08c3c61bf4d81b70c6fc36ec2d4c10361494", + "size": 9993, + "subdir": "linux-64", + "timestamp": 1661189211780, + "version": "0.3" + }, + "editdistance-0.5.3-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f1436d2c4cf6999e543b38b7861b4b0", + "name": "editdistance", + "sha256": "fb7bf039a4cfa1bc809e653ea5d0a35edc4ff6f2dc9f361bf9bdeca8f72be637", + "size": 197371, + "subdir": "linux-64", + "timestamp": 1640789751420, + "version": "0.5.3" + }, + "editdistance-0.5.3-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a9b30249026e8d2a05eefadaf3726829", + "name": "editdistance", + "sha256": "0133b3af4c2483e425e5102981f7cfbe4774cbe97544730a0072872c892cdbaa", + "size": 29975, + "subdir": "linux-64", + "timestamp": 1605215855278, + "version": "0.5.3" + }, + "editdistance-0.5.3-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64139620f62936fdc4951225e55a8ba8", + "name": "editdistance", + "sha256": "4d14b997fe2966cc858535b3f8394081b04758d12054021bdd9c0f9aa2e346cf", + "size": 29961, + "subdir": "linux-64", + "timestamp": 1605215862920, + "version": "0.5.3" + }, + "editdistance-0.5.3-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d981a69e2bcd8c92b6c8c135a5da0e5", + "name": "editdistance", + "sha256": "6b9460a5597601f93cf41093fa5675240033ae116e59f3c6c8c56a42e00de474", + "size": 30026, + "subdir": "linux-64", + "timestamp": 1605215860816, + "version": "0.5.3" + }, + "editdistance-0.5.3-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db575683b3528c47a71603b9105afe6b", + "name": "editdistance", + "sha256": "5c3d5e37a3cbc3b119adab2682852313fca1a24f2fab57d16190b7bf5265ef9d", + "size": 30017, + "subdir": "linux-64", + "timestamp": 1605215844145, + "version": "0.5.3" + }, + "editdistance-0.6.1-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e1ba5f973264470bef18b40848a1a044", + "name": "editdistance", + "sha256": "40af27f293b8697a4a931dd691d163c33483638b873e073444d1b71ebdf8ba6d", + "size": 50010, + "subdir": "linux-64", + "timestamp": 1670956874151, + "version": "0.6.1" + }, + "editdistance-0.6.1-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f290f13c7c8ab9d835b770ca5000bb0b", + "name": "editdistance", + "sha256": "d9cb80edf8c20020e6d23bbd2407ccc6540e5f142d24716777293466add9cfe7", + "size": 50265, + "subdir": "linux-64", + "timestamp": 1676852080355, + "version": "0.6.1" + }, + "editdistance-0.6.1-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e94a962464973e2f5ba3ad97e4d71d1a", + "name": "editdistance", + "sha256": "cac47df85ec9d3527aec81260ccfc3a9a143e2bbbf705bda513e75688b2fa7fd", + "size": 49916, + "subdir": "linux-64", + "timestamp": 1670956843590, + "version": "0.6.1" + }, + "editdistance-0.6.1-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8174adc04e5a60378172ead00a789183", + "name": "editdistance", + "sha256": "549d6f451e6a5ad2e0cb9ad577f76d424425beb8e7053d65e3935a0791f291c9", + "size": 49982, + "subdir": "linux-64", + "timestamp": 1670956811013, + "version": "0.6.1" + }, + "editdistance-0.6.1-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "59f7faf489d789f37951a84ed38a1acf", + "name": "editdistance", + "sha256": "c290ece87be55247d96aec20e19ea029cfbc7bae09885b72dd5b5d3ffb49f09a", + "size": 50076, + "subdir": "linux-64", + "timestamp": 1670956778531, + "version": "0.6.1" + }, + "efficientnet-1.0.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "keras >=2.2.0", + "keras-applications >=1.0.7", + "python >=3.10,<3.11.0a0", + "scikit-image" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d7e354eea73c629daaa6d5e514fd9b5c", + "name": "efficientnet", + "sha256": "dd84c074514782f134488a9187f69e3341e2c69fdc58000526b471cd2b66168b", + "size": 27166, + "subdir": "linux-64", + "timestamp": 1640815203846, + "version": "1.0.0" + }, + "efficientnet-1.0.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "keras >=2.2.0", + "keras-applications >=1.0.7", + "python >=3.11,<3.12.0a0", + "scikit-image" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cdd6b625ea6f6b58026e7ee62ff3d981", + "name": "efficientnet", + "sha256": "97f36c0220fcc5da48231aa3e7a76b344732163feec493624fe99f842fdc82af", + "size": 31907, + "subdir": "linux-64", + "timestamp": 1676906026451, + "version": "1.0.0" + }, + "efficientnet-1.0.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "keras >=2.2.0", + "keras-applications >=1.0.7", + "python >=3.6,<3.7.0a0", + "scikit-image" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6f1ce670f576ae639ce8c0ae99006186", + "name": "efficientnet", + "sha256": "2ce8d4759842a4f5738ce463d03275120051aaa988a26c7a49110b304e5189c2", + "size": 214860, + "subdir": "linux-64", + "timestamp": 1605286709366, + "version": "1.0.0" + }, + "efficientnet-1.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "keras >=2.2.0", + "keras-applications >=1.0.7", + "python >=3.7,<3.8.0a0", + "scikit-image" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9c822dd46f1c25ffa0a6f03516c0a302", + "name": "efficientnet", + "sha256": "5a99bea3997cf8850e76689cd6200f720975466be62f43e63252c99c3711f35d", + "size": 216348, + "subdir": "linux-64", + "timestamp": 1605286719049, + "version": "1.0.0" + }, + "efficientnet-1.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "keras >=2.2.0", + "keras-applications >=1.0.7", + "python >=3.8,<3.9.0a0", + "scikit-image" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "adf9f1e8e4b1c17b56d680189720956b", + "name": "efficientnet", + "sha256": "cb40284ed7550208689deba4e449a0d9be50aa656ea04c30517a3b9ff8a6001c", + "size": 219945, + "subdir": "linux-64", + "timestamp": 1605286736226, + "version": "1.0.0" + }, + "eigen-3.3.3-h5721d7b_0.tar.bz2": { + "build": "h5721d7b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MPL2", + "license_family": "Other", + "md5": "6f2e41c8422da2418ed37979c4bd6e9d", + "name": "eigen", + "sha256": "a00d59d9f66936dd0767765089f471e61b435d1133c09856706928f3b36ff403", + "size": 981296, + "subdir": "linux-64", + "timestamp": 1512427311853, + "version": "3.3.3" + }, + "eigen-3.3.5-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MPL2", + "license_family": "Other", + "md5": "4ff6325689c80f4d9a6dbb6e375ea895", + "name": "eigen", + "sha256": "ce80c9e5520b5e426e424f9d494d00543f2266d5e475a3cef276776b3fa5ed0c", + "size": 985779, + "subdir": "linux-64", + "timestamp": 1539475331266, + "version": "3.3.5" + }, + "eigen-3.3.7-hd09550d_1.tar.bz2": { + "build": "hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MPL2", + "license_family": "Other", + "md5": "580b01bc07a0af37b2d3642d412731e0", + "name": "eigen", + "sha256": "3ce18f218b00f313508791914adba6368fdc9f861524b215f8253d672262e5a3", + "size": 993731, + "subdir": "linux-64", + "timestamp": 1646805514357, + "version": "3.3.7" + }, + "eigen-3.3.7-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MPL2", + "license_family": "Other", + "md5": "3be14ca8267303e97dcbfd93f4666512", + "name": "eigen", + "sha256": "63fa5682d2a41663acc6e43a2e7f76c8d2a6a9ccd7d79855cb66854a2baa3959", + "size": 991523, + "subdir": "linux-64", + "timestamp": 1547227671774, + "version": "3.3.7" + }, + "elasticsearch-5.4.0-py27h91d0d75_0.tar.bz2": { + "build": "py27h91d0d75_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "urllib3 >=1.8,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8b44219d515d2e88b64502b123898eb1", + "name": "elasticsearch", + "sha256": "754b0fff589d102c8256b7a08bcae3cde4b16c2ebd5b386a5065af20b80e35c0", + "size": 73731, + "subdir": "linux-64", + "timestamp": 1505742663035, + "version": "5.4.0" + }, + "elasticsearch-5.4.0-py35h40732ba_0.tar.bz2": { + "build": "py35h40732ba_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "urllib3 >=1.8,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f8561b19cdd17acef3da072de90df356", + "name": "elasticsearch", + "sha256": "aa4c9d28899213dc51cf37076bdf5d130396b84bfdf77d98020c63589a841455", + "size": 75100, + "subdir": "linux-64", + "timestamp": 1505742676872, + "version": "5.4.0" + }, + "elasticsearch-5.4.0-py36hd132294_0.tar.bz2": { + "build": "py36hd132294_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "urllib3 >=1.8,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "09ac7725316034c07367bdf97eb5887a", + "name": "elasticsearch", + "sha256": "bdcc7a8cc151e5c830a6991e4a403018d85907c6f1c050bb041f23e3c80136a0", + "size": 75246, + "subdir": "linux-64", + "timestamp": 1505742690839, + "version": "5.4.0" + }, + "elasticsearch-6.0.0-py27hb682f61_0.tar.bz2": { + "build": "py27hb682f61_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "urllib3 >=1.21.1,<1.23" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3932317b9c551ba555aa074387047efc", + "name": "elasticsearch", + "sha256": "0f2e133b510ad8e95ab9b7453ac5ea53ac4e7a6eef4ec88524c0dffb3972a9ef", + "size": 75578, + "subdir": "linux-64", + "timestamp": 1511925803760, + "version": "6.0.0" + }, + "elasticsearch-6.0.0-py35he8fa8db_0.tar.bz2": { + "build": "py35he8fa8db_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "urllib3 >=1.21.1,<1.23" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0c95ef05c2dcb3a3d391cf93b4a2a093", + "name": "elasticsearch", + "sha256": "d5a0ac36c0732aa1313fe55459c4489e7b7bec0fe6c72be864d4838ebf9a77a2", + "size": 76942, + "subdir": "linux-64", + "timestamp": 1511925915481, + "version": "6.0.0" + }, + "elasticsearch-6.0.0-py36h03877a2_0.tar.bz2": { + "build": "py36h03877a2_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.23" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cd0dd7848bba38727236a2e5b7c9d325", + "name": "elasticsearch", + "sha256": "b0bb64bebf86d98dcf6278a3011c1a6022f5cf47ed8bd74a839aa973d3894125", + "size": 76938, + "subdir": "linux-64", + "timestamp": 1511925918172, + "version": "6.0.0" + }, + "elasticsearch-6.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "urllib3 >=1.21.1,<1.23" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9456094b8447e9088d62627c12777ec6", + "name": "elasticsearch", + "sha256": "6739e353cb7d01543e031de0faca24026879b2d8c78a9b0fd62e4a53fbd1c058", + "size": 84655, + "subdir": "linux-64", + "timestamp": 1522714919654, + "version": "6.2.0" + }, + "elasticsearch-6.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "urllib3 >=1.21.1,<1.23" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2b2e259cb5e24688fc75765585ae8b00", + "name": "elasticsearch", + "sha256": "1c961f036196efb56adfa96349536d98b8e78ab0164302fd90048f4c9da81b7e", + "size": 86416, + "subdir": "linux-64", + "timestamp": 1522714650904, + "version": "6.2.0" + }, + "elasticsearch-6.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.23" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "aee92d329f3a3ff59ac304e8c2dc58c3", + "name": "elasticsearch", + "sha256": "841d3ea0cd0de563fce7c986a2e2f399d082580134b8add0a07dc8e4714136de", + "size": 86619, + "subdir": "linux-64", + "timestamp": 1522714649716, + "version": "6.2.0" + }, + "elasticsearch-6.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.4.0,<3.0.0", + "urllib3 >=1.21.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e4cdd9d5f9769855c16050db29b87732", + "name": "elasticsearch", + "sha256": "2af1f38748ea12c61eb1b33804dfac4001d9ed6f26a22323c54bca8e58ca6a70", + "size": 87229, + "subdir": "linux-64", + "timestamp": 1529954367978, + "version": "6.3.0" + }, + "elasticsearch-6.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.4.0,<3.0.0", + "urllib3 >=1.21.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fd73e92c96d5a407b34f9259abc157f8", + "name": "elasticsearch", + "sha256": "32e0b4dc24203e47bc7c7e5258f93e51f29535b87a85fdc41f1c1a3fe41f60e8", + "size": 88933, + "subdir": "linux-64", + "timestamp": 1529954444381, + "version": "6.3.0" + }, + "elasticsearch-6.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.4.0,<3.0.0", + "urllib3 >=1.21.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c9f2bf2458154a840b46514bc65f4890", + "name": "elasticsearch", + "sha256": "79b4ec29a7cef664697892b2f9e72c960bf6841f1e6e0ef0724686614cff5ae3", + "size": 89325, + "subdir": "linux-64", + "timestamp": 1529954355900, + "version": "6.3.0" + }, + "elasticsearch-6.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.4.0,<3.0.0", + "urllib3 >=1.21.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ef16f148c8991633c46f5c7d92dd47f3", + "name": "elasticsearch", + "sha256": "93b8a3ebe6b89d44864640de245244d98c5250326f749d69f0e2382459152400", + "size": 89075, + "subdir": "linux-64", + "timestamp": 1530873560094, + "version": "6.3.0" + }, + "elasticsearch-6.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.4.0,<3.0.0", + "urllib3 >=1.21.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "33c83954c8aa9313f6477c3597748234", + "name": "elasticsearch", + "sha256": "cca930bc77b2da423e48d8d643802f3b7313b4d87f529aab16c792e0f98af9e2", + "size": 85127, + "subdir": "linux-64", + "timestamp": 1535423673672, + "version": "6.3.1" + }, + "elasticsearch-6.3.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.4.0,<3.0.0", + "urllib3 >=1.21.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0c557909c0c4bf66bfe796d4b513d2e1", + "name": "elasticsearch", + "sha256": "132459500d49113e885db9b079cc8dd9583bcaed759d865a061c82cf3b9310f8", + "size": 86737, + "subdir": "linux-64", + "timestamp": 1535423682885, + "version": "6.3.1" + }, + "elasticsearch-6.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.4.0,<3.0.0", + "urllib3 >=1.21.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b190a523448b6c672f4136a15d5b3f77", + "name": "elasticsearch", + "sha256": "e447c67236f7aa9eef161c55e8d16eff82154ca853a77741832ff055f153bb60", + "size": 87127, + "subdir": "linux-64", + "timestamp": 1535423621257, + "version": "6.3.1" + }, + "elasticsearch-6.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.4.0,<3.0.0", + "urllib3 >=1.21.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d23fc622469fe1f226096768d770f590", + "name": "elasticsearch", + "sha256": "157682f4a322aa195cacd699d519fb94cbef2792c2f03c305a26f57a37d4160b", + "size": 87117, + "subdir": "linux-64", + "timestamp": 1535423745322, + "version": "6.3.1" + }, + "elasticsearch-async-5.2.0-py35hb077873_0.tar.bz2": { + "build": "py35hb077873_0", + "build_number": 0, + "depends": [ + "aiohttp", + "elasticsearch >=5.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7078b1977c6c7521b231f9656a7edfaf", + "name": "elasticsearch-async", + "sha256": "50467646ac53f71f018081e0cf167ad6623ddef8af930c6cf16429dd5f5b88a7", + "size": 17360, + "subdir": "linux-64", + "timestamp": 1506937337079, + "version": "5.2.0" + }, + "elasticsearch-async-5.2.0-py36h6fd203e_0.tar.bz2": { + "build": "py36h6fd203e_0", + "build_number": 0, + "depends": [ + "aiohttp", + "elasticsearch >=5.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2a67a87892a303777ef24e03ecd4b971", + "name": "elasticsearch-async", + "sha256": "ad6191af795a514278f153822e07835f3654383c1a81d58048a1b004745fd658", + "size": 17405, + "subdir": "linux-64", + "timestamp": 1506937339392, + "version": "5.2.0" + }, + "elasticsearch-async-6.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aiohttp", + "elasticsearch >=6.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4545261299cebf70a07252af87af9166", + "name": "elasticsearch-async", + "sha256": "ba11ba8ed13033ccd3d4539b44626160b9757e3f3dccdd0388f06b2b39ea2196", + "size": 18376, + "subdir": "linux-64", + "timestamp": 1524107738617, + "version": "6.0.0" + }, + "elasticsearch-async-6.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp", + "elasticsearch >=6.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "24cdff531b04c2d6a807f28293eceaab", + "name": "elasticsearch-async", + "sha256": "97db8e8a2c8291f4fb43b59313ef70c2f0f966c579c7bdfa3999e7ca70b9cff4", + "size": 18394, + "subdir": "linux-64", + "timestamp": 1524107734047, + "version": "6.0.0" + }, + "elasticsearch-async-6.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c710abc6ab8678fc26bdf3511f1f892f", + "name": "elasticsearch-async", + "sha256": "aad97a1197c7efdb762fe9c42d1daf604a827de7be5ff815fc950d2fc619ab51", + "size": 19267, + "subdir": "linux-64", + "timestamp": 1529954952406, + "version": "6.1.0" + }, + "elasticsearch-async-6.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "df18c9634abeb04505c79169b087d760", + "name": "elasticsearch-async", + "sha256": "837850b67a3c0947cb40bcabea0547030d7ccd64bd6c8c441bc3009721acbb7e", + "size": 19283, + "subdir": "linux-64", + "timestamp": 1529954760209, + "version": "6.1.0" + }, + "elasticsearch-async-6.2.0-py310h06a4308_1000.tar.bz2": { + "build": "py310h06a4308_1000", + "build_number": 1000, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "28e0db48d2d3d161d49b0115a6f5497b", + "name": "elasticsearch-async", + "sha256": "7f961d2b9a64fb8b7fc3a5010d7825ff39d81b30686240fe534673c5d9f1a4f9", + "size": 19818, + "subdir": "linux-64", + "timestamp": 1640813493304, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "238c4583c2c0c9bedb71afac8f453f9c", + "name": "elasticsearch-async", + "sha256": "e621e799be9182ea1db1894affffb5905bf3299087b2ba6deeaed10905b59bbb", + "size": 19437, + "subdir": "linux-64", + "timestamp": 1535801297600, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c54de4bba05870983748cd28131d5f22", + "name": "elasticsearch-async", + "sha256": "c44d77f65100ac26333ac88d11bef9e6a34c5df2eaba56b0d63027e29428adc7", + "size": 19410, + "subdir": "linux-64", + "timestamp": 1535801280173, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py36_1000.tar.bz2": { + "build": "py36_1000", + "build_number": 1000, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1a9521446a8e79b864ec8bdaee257f3b", + "name": "elasticsearch-async", + "sha256": "9b04eeb591876762625d8b8ae71c71cd468c0e23ee970522992f87779b182745", + "size": 21095, + "subdir": "linux-64", + "timestamp": 1564163149924, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py36h06a4308_1000.tar.bz2": { + "build": "py36h06a4308_1000", + "build_number": 1000, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f9d07c5615bc5b0c6101a61b586ddf1a", + "name": "elasticsearch-async", + "sha256": "15940d8d3e9bbd36eff2272bc910d243f2d1cc66a4c3994fac85b78ef4a6694a", + "size": 21431, + "subdir": "linux-64", + "timestamp": 1614006176532, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6f68e484689fd322174d62bd1fb44317", + "name": "elasticsearch-async", + "sha256": "8c81db09d220814c43726f49fd50bb3c9aab3b16ab2e0fa99e21f60e77b4c092", + "size": 19489, + "subdir": "linux-64", + "timestamp": 1535801297781, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py37_1000.tar.bz2": { + "build": "py37_1000", + "build_number": 1000, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b5df5375bd57504d01da5d4083708fa8", + "name": "elasticsearch-async", + "sha256": "cfc258a35c52f4b8dcee95c5aa6c1d4edde145de4089997dbf41c4e5b0681a03", + "size": 21139, + "subdir": "linux-64", + "timestamp": 1564163138400, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py37h06a4308_1000.tar.bz2": { + "build": "py37h06a4308_1000", + "build_number": 1000, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "11ab37345a5f7acab95d87f113a9e24e", + "name": "elasticsearch-async", + "sha256": "1769c5f2f65d893ca01b5ec0b874caed87fd1f069c8099fe005dedf3e8e804e7", + "size": 21482, + "subdir": "linux-64", + "timestamp": 1614007047565, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py38_1000.tar.bz2": { + "build": "py38_1000", + "build_number": 1000, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "66b454f49c95472405f0ecd5e1af3f90", + "name": "elasticsearch-async", + "sha256": "cdb5f601868a37bb849b67106fb0a2e7d2bd180cca0c3fd0fdf112182bbca250", + "size": 21579, + "subdir": "linux-64", + "timestamp": 1591789201537, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py38h06a4308_1000.tar.bz2": { + "build": "py38h06a4308_1000", + "build_number": 1000, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "780c39127139cec7504086a4180c959a", + "name": "elasticsearch-async", + "sha256": "5c1a192f52a7921c16bb03b2e10ce067518c0be94e68691250dd33c9975a6d0d", + "size": 21562, + "subdir": "linux-64", + "timestamp": 1614006170305, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py39h06a4308_1000.tar.bz2": { + "build": "py39h06a4308_1000", + "build_number": 1000, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f49b90cc055827e3c05e0bf91c399f13", + "name": "elasticsearch-async", + "sha256": "3881deed644eeb1ff4e3fa36ac11e572c644561334681256f589ee1d42335e13", + "size": 21643, + "subdir": "linux-64", + "timestamp": 1614007043041, + "version": "6.2.0" + }, + "elasticsearch-dsl-5.3.0-py27h02dbe23_0.tar.bz2": { + "build": "py27h02dbe23_0", + "build_number": 0, + "depends": [ + "elasticsearch >=5.0.0,<6.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "25dba26a7066712f80a552a3be2bbdc2", + "name": "elasticsearch-dsl", + "sha256": "65373e1efa86a0c6bfe036b0e8ba92483c1849a55417a5155a8f8de855ff2c06", + "size": 65372, + "subdir": "linux-64", + "timestamp": 1505742705131, + "version": "5.3.0" + }, + "elasticsearch-dsl-5.3.0-py35h5271a11_0.tar.bz2": { + "build": "py35h5271a11_0", + "build_number": 0, + "depends": [ + "elasticsearch >=5.0.0,<6.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2f640e0371bb642ddec07ca8c728d3a0", + "name": "elasticsearch-dsl", + "sha256": "634ac64cae760c6dd2dde0ec5628de6a80a2e428a61dcc0ee7e6f15e6466764f", + "size": 67895, + "subdir": "linux-64", + "timestamp": 1505742718719, + "version": "5.3.0" + }, + "elasticsearch-dsl-5.3.0-py36h024d9ff_0.tar.bz2": { + "build": "py36h024d9ff_0", + "build_number": 0, + "depends": [ + "elasticsearch >=5.0.0,<6.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7c12dc1adff1879e2f1d296c0ade4325", + "name": "elasticsearch-dsl", + "sha256": "618c9387dce61a0fb897591ee7d2223b69f43b871dc99b3b95fc754e21b979ff", + "size": 67957, + "subdir": "linux-64", + "timestamp": 1505742732352, + "version": "5.3.0" + }, + "elasticsearch-dsl-6.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "30ae348e1aa185fe2f4daf8dd1770578", + "name": "elasticsearch-dsl", + "sha256": "ce959c2231c71c0ca92082bd69975020b430ad392e6eec02c25cf08c8e995f1f", + "size": 69406, + "subdir": "linux-64", + "timestamp": 1517132973106, + "version": "6.1.0" + }, + "elasticsearch-dsl-6.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7c7b364b45d6b3fac827057b3ca93524", + "name": "elasticsearch-dsl", + "sha256": "14e81fd2b0297f314bbcdd5b5b9552ac5433785938f124e2b3061f76322e457e", + "size": 71975, + "subdir": "linux-64", + "timestamp": 1517132983409, + "version": "6.1.0" + }, + "elasticsearch-dsl-6.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0f85a7be186b9179e016841fe36bca83", + "name": "elasticsearch-dsl", + "sha256": "12d06c116718e37dec08233738f727fe569fe43402e43c689211a95e7c0707f1", + "size": 72168, + "subdir": "linux-64", + "timestamp": 1517132980724, + "version": "6.1.0" + }, + "elasticsearch-dsl-6.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3fa1e83b460cc69b6a6a5c826edc62f0", + "name": "elasticsearch-dsl", + "sha256": "9a3336bca8d1fd5b679db1528cfde0ce9f46d6a330fb0d7d92a70ac62bbb5223", + "size": 72105, + "subdir": "linux-64", + "timestamp": 1530873591111, + "version": "6.1.0" + }, + "elasticsearch-dsl-6.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9723de50831385f2fe85b58627ac99cb", + "name": "elasticsearch-dsl", + "sha256": "94200d3720348d9934549e82be2bb094e0409ffa160a1f15864b570423e5312c", + "size": 71170, + "subdir": "linux-64", + "timestamp": 1535499615566, + "version": "6.2.1" + }, + "elasticsearch-dsl-6.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d8b1883c8940718b611ab20cd9c12ece", + "name": "elasticsearch-dsl", + "sha256": "1f90a6c6b2d5730179480ce50b5a29ef5d07b6ec022b9d06809c5e6c6a3ce118", + "size": 73689, + "subdir": "linux-64", + "timestamp": 1535499618318, + "version": "6.2.1" + }, + "elasticsearch-dsl-6.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b3e288da6aac972a9e16b79b16ec88a3", + "name": "elasticsearch-dsl", + "sha256": "23dc1f42f7502e11db949b6f1f1ac5e48d204f38ec2d5b397f266e232838dc88", + "size": 73712, + "subdir": "linux-64", + "timestamp": 1535499589552, + "version": "6.2.1" + }, + "elasticsearch-dsl-6.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7cae4e53981e67bb84c2fb5472fdeb9f", + "name": "elasticsearch-dsl", + "sha256": "2e9c06adcab6adf022528e90de9a8425054a4a502586781cf8927b14ab4b35a9", + "size": 74001, + "subdir": "linux-64", + "timestamp": 1535499629312, + "version": "6.2.1" + }, + "elasticsearch-dsl-6.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f06f80b0bde4d2a52400a137e4cee874", + "name": "elasticsearch-dsl", + "sha256": "ca72d5767869c95e3d725dbc4e2b6bd84f9277c10d462cfe3f71008a6a966534", + "size": 80058, + "subdir": "linux-64", + "timestamp": 1543521723446, + "version": "6.3.0" + }, + "elasticsearch-dsl-6.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a66b5d7d5970999e066013e442e9492c", + "name": "elasticsearch-dsl", + "sha256": "d3c57b9a2c8ee094082314fa695017f341cdf09552906a8b5faa07f67a6fc1e1", + "size": 82937, + "subdir": "linux-64", + "timestamp": 1543521765786, + "version": "6.3.0" + }, + "elasticsearch-dsl-6.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "86a96262746e4600070fb5dabb587d86", + "name": "elasticsearch-dsl", + "sha256": "a9ce8dba3ffbb4e3b54d98db4a079c01aeaabaecc6ea5f4c14a0172dde25a5f2", + "size": 83030, + "subdir": "linux-64", + "timestamp": 1543521724676, + "version": "6.3.0" + }, + "elasticsearch-dsl-6.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "08421c7ef94d5b6b542ec365b180e9de", + "name": "elasticsearch-dsl", + "sha256": "dcccc268ca63b78298a0b40b044412faa5fb2284d36636c0eb4388fc7548df4a", + "size": 77807, + "subdir": "linux-64", + "timestamp": 1545116968299, + "version": "6.3.1" + }, + "elasticsearch-dsl-6.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8c548ae2a3082d8d80368c2024f8701e", + "name": "elasticsearch-dsl", + "sha256": "b85922a2abb9f43cb58b221b7d3934de18a55504ea34a588ee517462f7ee9f7e", + "size": 80342, + "subdir": "linux-64", + "timestamp": 1545116997745, + "version": "6.3.1" + }, + "elasticsearch-dsl-6.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "53c153de9c506be63b1896237f891089", + "name": "elasticsearch-dsl", + "sha256": "7b6722b75e56bfa4bd1eb23f22211f18a6316543125ff9655a9b8228f0ce2658", + "size": 80356, + "subdir": "linux-64", + "timestamp": 1545117016721, + "version": "6.3.1" + }, + "elasticsearch-dsl-7.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1e9a70f99f098a9c74e0b79c8a64c551", + "name": "elasticsearch-dsl", + "sha256": "52981c8102fe9d9559ff6762524ed0281ca35389bb20ffee68ca88f861a18dd2", + "size": 82928, + "subdir": "linux-64", + "timestamp": 1558559646033, + "version": "7.0.0" + }, + "elasticsearch-dsl-7.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d58cc986772461148753c4d926a27f38", + "name": "elasticsearch-dsl", + "sha256": "6fca55e0329fc5c880ec68644aff70f1a1400f136d72fdcfc2d38533a99d33f2", + "size": 85658, + "subdir": "linux-64", + "timestamp": 1558559671862, + "version": "7.0.0" + }, + "elasticsearch-dsl-7.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6285cf81cc69451372847f553d51a879", + "name": "elasticsearch-dsl", + "sha256": "21673047b2c3761e57e059d32c4b739ea351be3000a1f957ff0848b8766df052", + "size": 85656, + "subdir": "linux-64", + "timestamp": 1558559585935, + "version": "7.0.0" + }, + "elasticsearch-dsl-7.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f44b7113bb124483c9861e94c13a6232", + "name": "elasticsearch-dsl", + "sha256": "55245e65e7659047a56b4b197e90268cd613e3f29f9a88bafc48793d077b7f62", + "size": 87042, + "subdir": "linux-64", + "timestamp": 1592217438395, + "version": "7.2.1" + }, + "elasticsearch-dsl-7.2.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "85fd87db2b8ccc5aa1c21e8ae56583fa", + "name": "elasticsearch-dsl", + "sha256": "7095b01e6e67a7c22d83d864e11b47993cb25dda313548230a08a123819f383d", + "size": 87427, + "subdir": "linux-64", + "timestamp": 1614249818877, + "version": "7.2.1" + }, + "elasticsearch-dsl-7.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "112eaddd066b3a4e730b254514fe8d3d", + "name": "elasticsearch-dsl", + "sha256": "bdfdc267c9dbdeb6c25d50b68dc5b811146648f263a38d9f34595f82a984723f", + "size": 87097, + "subdir": "linux-64", + "timestamp": 1592217627572, + "version": "7.2.1" + }, + "elasticsearch-dsl-7.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e72e61a82516aa8fa83af64efb389fa8", + "name": "elasticsearch-dsl", + "sha256": "f53ee078902b12482e4410a72033cc7eccb255a909f9985317fa6cab50e1404c", + "size": 87492, + "subdir": "linux-64", + "timestamp": 1614249819397, + "version": "7.2.1" + }, + "elasticsearch-dsl-7.2.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b45604c45f8b34d420240db0dece6a21", + "name": "elasticsearch-dsl", + "sha256": "1020dec112bf2396e017227a3b1a28c0aceb0959914ebe97c5b825dd862c94a6", + "size": 87386, + "subdir": "linux-64", + "timestamp": 1592217615277, + "version": "7.2.1" + }, + "elasticsearch-dsl-7.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "31b5aa1cabe9cfb3277f928c1db622c5", + "name": "elasticsearch-dsl", + "sha256": "c858afca07716a8aaed0e6b696580d77b073f1bacd4b5c2cc3fcd274cc4263f0", + "size": 87700, + "subdir": "linux-64", + "timestamp": 1614249828088, + "version": "7.2.1" + }, + "elasticsearch-dsl-7.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6fd90b6f0baa4949f515722fa1dd7391", + "name": "elasticsearch-dsl", + "sha256": "0e7e01a6c9d13e7b01c74de02a68cf1842b3b2a9199b9dd2b18db988572d4747", + "size": 87631, + "subdir": "linux-64", + "timestamp": 1614249821572, + "version": "7.2.1" + }, + "elasticsearch-dsl-7.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4d08c0d4ce54592a2d43bb24cb8e1e4d", + "name": "elasticsearch-dsl", + "sha256": "ab1ea2eaac2381a5af459445bf88ee4e871dd800d7f459202110c5b9f70d8be8", + "size": 87022, + "subdir": "linux-64", + "timestamp": 1600373959055, + "version": "7.3.0" + }, + "elasticsearch-dsl-7.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0f90a8687f0f9afbeb81c86e233fe484", + "name": "elasticsearch-dsl", + "sha256": "033eabc72594dee99bb81b878120be23a6162a0d2825d7823f1be02432019ef3", + "size": 87094, + "subdir": "linux-64", + "timestamp": 1600373976308, + "version": "7.3.0" + }, + "elasticsearch-dsl-7.3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cd283b8a76e26a735b53f4c084ca5e28", + "name": "elasticsearch-dsl", + "sha256": "e5506bfba92434dde4a0f54b00859b15e5749ec4e0f4f3aac4ab3cb89af7d760", + "size": 87479, + "subdir": "linux-64", + "timestamp": 1600373990905, + "version": "7.3.0" + }, + "elasticsearch-dsl-7.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=7.0.0,<8.0.0", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7fd95ebd91389d0013b5c816b9b8f4ce", + "name": "elasticsearch-dsl", + "sha256": "67aaee709d17e86ad5d30b9e7be8a988ce7403ca3827a880d8579bac99730585", + "size": 89478, + "subdir": "linux-64", + "timestamp": 1640789769520, + "version": "7.4.0" + }, + "elasticsearch-dsl-7.4.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=7.0.0,<8.0.0", + "python >=3.11,<3.12.0a0", + "python-dateutil", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "03792abb1dd81144f395b969924c55d6", + "name": "elasticsearch-dsl", + "sha256": "3eb2260442e109431739d68f8d39a29191a996242dbdf578b254978726f16cfe", + "size": 116734, + "subdir": "linux-64", + "timestamp": 1676852109148, + "version": "7.4.0" + }, + "elasticsearch-dsl-7.4.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=7.0.0,<8.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "463945f0bdb2b2eb6e4c453caf4d113b", + "name": "elasticsearch-dsl", + "sha256": "680218a88ede9815ec660b2798a46e773a4d49cd805afcd80c1778faa55a5a7d", + "size": 88054, + "subdir": "linux-64", + "timestamp": 1626441080839, + "version": "7.4.0" + }, + "elasticsearch-dsl-7.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=7.0.0,<8.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f52a841e1abd859cbb6884f6105981fa", + "name": "elasticsearch-dsl", + "sha256": "5e8988f40996a10f21ee049cebe6d9ab6c4bbfd03566291f9e4b5c807215ea40", + "size": 88129, + "subdir": "linux-64", + "timestamp": 1626441077427, + "version": "7.4.0" + }, + "elasticsearch-dsl-7.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=7.0.0,<8.0.0", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6176f8aa5dd9c5b570ce7afb390a37c5", + "name": "elasticsearch-dsl", + "sha256": "ba99eb5afdf62068fc2be0fb5a85d4b246f7101e7d3da7d46316109d822b3652", + "size": 88499, + "subdir": "linux-64", + "timestamp": 1626441027006, + "version": "7.4.0" + }, + "elasticsearch-dsl-7.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=7.0.0,<8.0.0", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6de554407f5543172ed82c40fd174417", + "name": "elasticsearch-dsl", + "sha256": "71fca671209e6b3ad134d923b4d3f831dcaa1bddd2c508c1b58c1d42eba6683f", + "size": 88262, + "subdir": "linux-64", + "timestamp": 1626433917421, + "version": "7.4.0" + }, + "email-validator-1.2.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "idna >=2.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "54cdbedace02188619f9bb99d2c0d6da", + "name": "email-validator", + "sha256": "47c6f53ff4d64a722c1780c96f9bbc663049d09154fe9c7c757583d78bc3a2f4", + "size": 32966, + "subdir": "linux-64", + "timestamp": 1659798212586, + "version": "1.2.1" + }, + "email-validator-1.2.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "idna >=2.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "3ff1cb2df23902338825ec6345f4752a", + "name": "email-validator", + "sha256": "89ccbe1abdf774a6232eea4ec5f88d9d1c38170c30da02c3a9c3cd59b04dfc6c", + "size": 38048, + "subdir": "linux-64", + "timestamp": 1676827123876, + "version": "1.2.1" + }, + "email-validator-1.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "idna >=2.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "cc832b5a4aea424d8b7b61b4cfc4b58c", + "name": "email-validator", + "sha256": "ed726d2622b9dbda3f073c442d1e1b3fd6699da2f622afe81df86d2d718a0523", + "size": 32818, + "subdir": "linux-64", + "timestamp": 1659798336634, + "version": "1.2.1" + }, + "email-validator-1.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "idna >=2.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "b75214911dd1748ee9a4f4f489f9ed5d", + "name": "email-validator", + "sha256": "37d3b816dadf8832ad7a799da7eb0aacd48947c8274bf8fa66ab7498e44c724c", + "size": 32944, + "subdir": "linux-64", + "timestamp": 1659798254382, + "version": "1.2.1" + }, + "email-validator-1.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "idna >=2.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "9d64d757b979f16137e3d5a8854f1931", + "name": "email-validator", + "sha256": "1f28f6455dd0b39c0447d60c0d41dab79bc5ea8884b9f90355e18b748b008d24", + "size": 32915, + "subdir": "linux-64", + "timestamp": 1659798297040, + "version": "1.2.1" + }, + "emfile-0.3.0-py310h2f386ee_0.tar.bz2": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "593160780904088f43acc3c97ba395a0", + "name": "emfile", + "sha256": "5f79e07efc1da8d78b8b7da4b6dfaad15d4ea7bcb9c67bc8410c2d779c6abf62", + "size": 11419, + "subdir": "linux-64", + "timestamp": 1679385336872, + "version": "0.3.0" + }, + "emfile-0.3.0-py311h92b7b1e_0.tar.bz2": { + "build": "py311h92b7b1e_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "56463bddeb5335cc926aec92f2a1a146", + "name": "emfile", + "sha256": "dce25a2b9fc09f56bf88dc98bd22753d7518489c953951414c3caad6d0875846", + "size": 12679, + "subdir": "linux-64", + "timestamp": 1679385302171, + "version": "0.3.0" + }, + "emfile-0.3.0-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c1cd00e67a8bca0efbb61bca6d662038", + "name": "emfile", + "sha256": "428a3b5dd60655b2f3402723a2dc2e972b9e05c4608063deb77efa7c3167b148", + "size": 10926, + "subdir": "linux-64", + "timestamp": 1679385405750, + "version": "0.3.0" + }, + "emfile-0.3.0-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7ec74773ba5467a67ec24601bc42c592", + "name": "emfile", + "sha256": "38ff00a4669a1b8ae4331aa7ef324e5aa9d9418bd7900e0b89d87aed53722c29", + "size": 11001, + "subdir": "linux-64", + "timestamp": 1679385370804, + "version": "0.3.0" + }, + "enaml-0.10.2-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "atom >=0.4.1", + "future", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ply >=3.4", + "pyqt", + "python >=2.7,<2.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "109659da311e2df750d2f742802fa7dc", + "name": "enaml", + "sha256": "3fb3a02cffc7798a56f90d3ac8166dd58605f38c280fa97a4a461c5d5d8e31c8", + "size": 952150, + "subdir": "linux-64", + "timestamp": 1519763912645, + "version": "0.10.2" + }, + "enaml-0.10.2-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "atom >=0.4.1", + "future", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ply >=3.4", + "pyqt", + "python >=3.5,<3.6.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "14f056bd4e89fb171b0a4020e6fb19fa", + "name": "enaml", + "sha256": "3a697fe88a24bb1c50617d1fedafdd0fea4628ad1da9ae0cfa9bc9fda050775f", + "size": 987802, + "subdir": "linux-64", + "timestamp": 1519764012253, + "version": "0.10.2" + }, + "enaml-0.10.2-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "atom >=0.4.1", + "future", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ply >=3.4", + "pyqt", + "python >=3.6,<3.7.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "005787b53e7bfe998c7b850fab43ff11", + "name": "enaml", + "sha256": "316b4798c883a39c639b2a46c05dc55c9e39da66a41ce9a7ba1a927829f0cf2e", + "size": 979591, + "subdir": "linux-64", + "timestamp": 1519764006329, + "version": "0.10.2" + }, + "enaml-0.10.2-py37hf484d3e_0.tar.bz2": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "atom >=0.4.1", + "future", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ply >=3.4", + "pyqt", + "python >=3.7,<3.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b759f5c5a966ef8e4ca8f5c50299fa87", + "name": "enaml", + "sha256": "98ef86c6f0796abe37dcd85973e9c72acadee78086467dd22a0b5dc0c71f2038", + "size": 964678, + "subdir": "linux-64", + "timestamp": 1530873751740, + "version": "0.10.2" + }, + "enaml-0.10.3-py27hfd86e86_0.tar.bz2": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=2.7,<2.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "de8db4c063ecfd4fcfbad130a1c23286", + "name": "enaml", + "sha256": "398f73245deaa5dd7aec0f5ec4e518691254f32a85b256fe9f4c622de4bc3518", + "size": 870960, + "subdir": "linux-64", + "timestamp": 1552414279515, + "version": "0.10.3" + }, + "enaml-0.10.3-py27hfd86e86_1.tar.bz2": { + "build": "py27hfd86e86_1", + "build_number": 1, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=2.7,<2.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "eb88874c658edb69250c54098ce9bbba", + "name": "enaml", + "sha256": "feda691365aef7a69a16235b0b5774461f4dc4d420329f3bf0fbbd8baa5d3167", + "size": 846937, + "subdir": "linux-64", + "timestamp": 1564163640977, + "version": "0.10.3" + }, + "enaml-0.10.3-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.6,<3.7.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e3e09bb931026de241e400411f4c51ea", + "name": "enaml", + "sha256": "17d1c1e363477935da25ab006324e14a1a89d0570c6cae9d3fe9dea0b1ec2722", + "size": 860173, + "subdir": "linux-64", + "timestamp": 1552414190430, + "version": "0.10.3" + }, + "enaml-0.10.3-py36hfd86e86_1.tar.bz2": { + "build": "py36hfd86e86_1", + "build_number": 1, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.6,<3.7.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "92d4e793708be13336503ad454159efb", + "name": "enaml", + "sha256": "a906da78e75d325cd86a087462a9838383f774f72b1f04b44aa33d688b0a89bf", + "size": 871702, + "subdir": "linux-64", + "timestamp": 1564163636300, + "version": "0.10.3" + }, + "enaml-0.10.3-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.7,<3.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a139d0f6420b8a10e0f6ac30e7bd6d70", + "name": "enaml", + "sha256": "76d1f9cb9429adb7d65954ea60f46e2f2695c38a3aae6b627eddbef780d51e71", + "size": 850898, + "subdir": "linux-64", + "timestamp": 1552412083425, + "version": "0.10.3" + }, + "enaml-0.10.3-py37hfd86e86_1.tar.bz2": { + "build": "py37hfd86e86_1", + "build_number": 1, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.7,<3.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f8200a8c227b7aa38295d0649326807c", + "name": "enaml", + "sha256": "b0f6d1337cb8f49961d131972679a0e307e614a9047fb5d6538a2978e1200384", + "size": 869726, + "subdir": "linux-64", + "timestamp": 1564163640802, + "version": "0.10.3" + }, + "enaml-0.10.4-py27hfd86e86_0.tar.bz2": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=2.7,<2.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ceded3de5c5068560e2a0a89b03d24dd", + "name": "enaml", + "sha256": "8dd4ba6c213fc33dcb960b9a3900c6de8bb3119b3776a1ea7bc9eb3f996c7618", + "size": 838016, + "subdir": "linux-64", + "timestamp": 1569368677989, + "version": "0.10.4" + }, + "enaml-0.10.4-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.6,<3.7.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dac1e1939f24c3d8b1274e64b142ee7d", + "name": "enaml", + "sha256": "6eeadb45911939fd54cda39d90cade2e33f044bbca5fde7ef9f5cd075d6adde1", + "size": 879142, + "subdir": "linux-64", + "timestamp": 1569368678938, + "version": "0.10.4" + }, + "enaml-0.10.4-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.7,<3.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a791b47de22be66bbe23ecc6157053f2", + "name": "enaml", + "sha256": "bfbca0797bb51411ad1c99bcd04feacc9f607d3cee3e1e7bc288adb95b8843d4", + "size": 866602, + "subdir": "linux-64", + "timestamp": 1569368665669, + "version": "0.10.4" + }, + "enaml-0.10.4-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.8,<3.9.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2e7d08e7b5e7a1f1a99e3c8f424a9733", + "name": "enaml", + "sha256": "d6228cad98be93232d7da43cf10affe1ea998d126e28e1e1fe1ee8323ab00eb8", + "size": 861273, + "subdir": "linux-64", + "timestamp": 1574251227828, + "version": "0.10.4" + }, + "enaml-0.11.1-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.5.0", + "bytecode", + "kiwisolver >=1.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.6,<3.7.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d180722830cffb0e188bbe5ddd709f85", + "name": "enaml", + "sha256": "c7b13e8c46e379ecc271854dc52850edef974e3076df8e3268da8ddb515025a3", + "size": 858804, + "subdir": "linux-64", + "timestamp": 1591183494714, + "version": "0.11.1" + }, + "enaml-0.11.1-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.5.0", + "bytecode", + "kiwisolver >=1.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.7,<3.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e549ddb4d45bc64fb3962c886f497991", + "name": "enaml", + "sha256": "c127eb4f98e711dc19be7012c7ee92eb88c0838affce8fdff2656399e3b77d72", + "size": 845504, + "subdir": "linux-64", + "timestamp": 1591183492872, + "version": "0.11.1" + }, + "enaml-0.11.1-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.5.0", + "bytecode", + "kiwisolver >=1.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.8,<3.9.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7da6531b3748de3ef15e7f60ffc1fcb7", + "name": "enaml", + "sha256": "dab895f086268ca003b1805674c63d4c09a8346440918e4e6e0261f51e1d22c1", + "size": 849219, + "subdir": "linux-64", + "timestamp": 1591183495192, + "version": "0.11.1" + }, + "enaml-0.11.2-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.5.0", + "bytecode", + "kiwisolver >=1.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.6,<3.7.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9dacdbf7fe18538fb57bb130d196c2d2", + "name": "enaml", + "sha256": "0d3ca8428f9718ae86abb221cb6557dfc5bcc392905a7065e0044cff67e11f9e", + "size": 840176, + "subdir": "linux-64", + "timestamp": 1592217650761, + "version": "0.11.2" + }, + "enaml-0.11.2-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.5.0", + "bytecode", + "kiwisolver >=1.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.7,<3.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "31fdf76f293a6861b3466ac7d278145f", + "name": "enaml", + "sha256": "5203a4fe479708b1bea78b1fd0c891727dc4ab5a77cf274b45759ed83c0a74fc", + "size": 837013, + "subdir": "linux-64", + "timestamp": 1592217867908, + "version": "0.11.2" + }, + "enaml-0.11.2-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.5.0", + "bytecode", + "kiwisolver >=1.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.8,<3.9.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "29497c659be70e4442592afcd4863991", + "name": "enaml", + "sha256": "54ae80dbed9ca54c31384c560a9bca16ab96573e62ed802416d1e8ab096a9bca", + "size": 856140, + "subdir": "linux-64", + "timestamp": 1592217826004, + "version": "0.11.2" + }, + "enaml-0.12.0-py36hff7bd54_0.tar.bz2": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "atom >=0.6.0", + "bytecode", + "kiwisolver >=1.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.6,<3.7.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "898e81783116c8b8226c861aed541930", + "name": "enaml", + "sha256": "a7737c22c5530032169309ef3ae86159b10ed555d2426461ab25805dda98ddb4", + "size": 769451, + "subdir": "linux-64", + "timestamp": 1617707984313, + "version": "0.12.0" + }, + "enaml-0.12.0-py37hff7bd54_0.tar.bz2": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "atom >=0.6.0", + "bytecode", + "kiwisolver >=1.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.7,<3.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3707e163d238545e0f79f4383e0caae6", + "name": "enaml", + "sha256": "e79d1d7394ed82ace16c93f84cd84e004df59f219f0599f315cd5aced5684007", + "size": 768060, + "subdir": "linux-64", + "timestamp": 1617708000761, + "version": "0.12.0" + }, + "enaml-0.12.0-py38hff7bd54_0.tar.bz2": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "atom >=0.6.0", + "bytecode", + "kiwisolver >=1.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.8,<3.9.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5070c6fc06d02ddefe7f0a65598b6d33", + "name": "enaml", + "sha256": "e0a10b107854e7f0f7a83ab93ca4daedd830405e7238e4d9fe6814e3f97e8b6f", + "size": 753020, + "subdir": "linux-64", + "timestamp": 1617707328960, + "version": "0.12.0" + }, + "enaml-0.12.0-py39hff7bd54_0.tar.bz2": { + "build": "py39hff7bd54_0", + "build_number": 0, + "depends": [ + "atom >=0.6.0", + "bytecode", + "kiwisolver >=1.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.9,<3.10.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e514ab15b0262eae6fe41f2480973051", + "name": "enaml", + "sha256": "f93e537d1548df490c36255ea175839c1d46d184906484fe315f990c4e592d99", + "size": 767762, + "subdir": "linux-64", + "timestamp": 1617705233980, + "version": "0.12.0" + }, + "enaml-0.13.0-py310hd09550d_0.tar.bz2": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "atom >=0.6.0", + "bytecode >=0.11.0", + "kiwisolver >=1.2.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ply >=3.4", + "pyqt", + "python >=3.10,<3.11.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cc2ae783ffbe672f28ecd444063e74af", + "name": "enaml", + "sha256": "0ef583b04940dd33081adcbd7ff271be65ed4ddb266f9b0f1550785c2e0a106b", + "size": 1148774, + "subdir": "linux-64", + "timestamp": 1640811975279, + "version": "0.13.0" + }, + "enaml-0.13.0-py36hff7bd54_0.tar.bz2": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "atom >=0.6.0", + "bytecode", + "kiwisolver >=1.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.6,<3.7.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f4c1883d1dfeb406056a757775eab2e9", + "name": "enaml", + "sha256": "6d484c9f48213ac5b18976ecd2c8c236299c250a0dc25749a3e8526c16793d4d", + "size": 764607, + "subdir": "linux-64", + "timestamp": 1618867314439, + "version": "0.13.0" + }, + "enaml-0.13.0-py37hff7bd54_0.tar.bz2": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "atom >=0.6.0", + "bytecode", + "kiwisolver >=1.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.7,<3.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "988feaaffd9cbf40b4cdf928f0876267", + "name": "enaml", + "sha256": "d84550af72f752cec47e0da4a524b7b01a03dd536a27fcb849e4cfbc321852f1", + "size": 768996, + "subdir": "linux-64", + "timestamp": 1618867207406, + "version": "0.13.0" + }, + "enaml-0.13.0-py38hff7bd54_0.tar.bz2": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "atom >=0.6.0", + "bytecode", + "kiwisolver >=1.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.8,<3.9.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff871df9534f7546bd3aaf9414348be2", + "name": "enaml", + "sha256": "2b76589e512c0a8ee327f655af6989404d97bf22a3b667ad898b662ac73f7b86", + "size": 766446, + "subdir": "linux-64", + "timestamp": 1618863980479, + "version": "0.13.0" + }, + "enaml-0.13.0-py39hff7bd54_0.tar.bz2": { + "build": "py39hff7bd54_0", + "build_number": 0, + "depends": [ + "atom >=0.6.0", + "bytecode >=0.11.0", + "kiwisolver >=1.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.9,<3.10.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b6a18bd3240903f59b5e1bf846861cba", + "name": "enaml", + "sha256": "6e62a9758c87e34f9d899a6cb124947fa08edf133b212fdcb39746c0942bac80", + "size": 773046, + "subdir": "linux-64", + "timestamp": 1618947143277, + "version": "0.13.0" + }, + "enaml-0.16.0-py310hdb19cb5_0.tar.bz2": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "atom >=0.9.0", + "bytecode >=0.13.0", + "kiwisolver >=1.2.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pegen >=0.1.0", + "ply", + "pyqt", + "python >=3.10,<3.11.0a0", + "qtpy >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa209db2c08afa13a42b9f2ba715db5c", + "name": "enaml", + "sha256": "0e6d0d74de70fb7b5f941d182b4fa1d3147cad5b1b73b06596f3def74c5de1c8", + "size": 765995, + "subdir": "linux-64", + "timestamp": 1678397236296, + "version": "0.16.0" + }, + "enaml-0.16.0-py310hdb19cb5_1.tar.bz2": { + "build": "py310hdb19cb5_1", + "build_number": 1, + "depends": [ + "atom >=0.9.0", + "bytecode >=0.13.0", + "kiwisolver >=1.2.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pegen >=0.1.0", + "ply", + "pyqt", + "python >=3.10,<3.11.0a0", + "qtpy >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a68b4cb5db40b8020eb36bc71e77619b", + "name": "enaml", + "sha256": "7e48835dec42eb014c59e5a6b0386e61be2cc91bb45e61fa1a1a480c00bab874", + "size": 781288, + "subdir": "linux-64", + "timestamp": 1680271586780, + "version": "0.16.0" + }, + "enaml-0.16.0-py311hdb19cb5_1.tar.bz2": { + "build": "py311hdb19cb5_1", + "build_number": 1, + "depends": [ + "atom >=0.9.0", + "bytecode >=0.13.0", + "kiwisolver >=1.2.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pegen >=0.1.0", + "ply", + "pyqt", + "python >=3.11,<3.12.0a0", + "qtpy >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f5265de3a1c1e41dfa8f1acc402a3ad6", + "name": "enaml", + "sha256": "ad12c20f2bc2eac64c60bf71ef01d032e0cd9eca495d6b383948ea99123413a8", + "size": 955850, + "subdir": "linux-64", + "timestamp": 1680271540686, + "version": "0.16.0" + }, + "enaml-0.16.0-py38hdb19cb5_0.tar.bz2": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "atom >=0.9.0", + "bytecode >=0.13.0", + "kiwisolver >=1.2.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pegen >=0.1.0", + "ply", + "pyqt", + "python >=3.8,<3.9.0a0", + "qtpy >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6eeab1ebf7f1fe05b80449efb53ff3be", + "name": "enaml", + "sha256": "aa6820ed222de3111051bf978364855cf903760c24a19db67d3f8d5381da6939", + "size": 759998, + "subdir": "linux-64", + "timestamp": 1678397183209, + "version": "0.16.0" + }, + "enaml-0.16.0-py38hdb19cb5_1.tar.bz2": { + "build": "py38hdb19cb5_1", + "build_number": 1, + "depends": [ + "atom >=0.9.0", + "bytecode >=0.13.0", + "kiwisolver >=1.2.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pegen >=0.1.0", + "ply", + "pyqt", + "python >=3.8,<3.9.0a0", + "qtpy >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3e2763859da956e62f527b93e3b539b7", + "name": "enaml", + "sha256": "222725ee66bb0e8d0133a183274459bf9f900e7d938407f9eda8ecbff1b09780", + "size": 771156, + "subdir": "linux-64", + "timestamp": 1680271490160, + "version": "0.16.0" + }, + "enaml-0.16.0-py39hdb19cb5_0.tar.bz2": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "atom >=0.9.0", + "bytecode >=0.13.0", + "kiwisolver >=1.2.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pegen >=0.1.0", + "ply", + "pyqt", + "python >=3.9,<3.10.0a0", + "qtpy >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "60a655b51017f9e40f5cd0555e4ac9ec", + "name": "enaml", + "sha256": "cd373fd60b7d351b034e3d752461131d0465b83d087bad87318d84fd53fc2fcc", + "size": 753864, + "subdir": "linux-64", + "timestamp": 1678397283701, + "version": "0.16.0" + }, + "enaml-0.16.0-py39hdb19cb5_1.tar.bz2": { + "build": "py39hdb19cb5_1", + "build_number": 1, + "depends": [ + "atom >=0.9.0", + "bytecode >=0.13.0", + "kiwisolver >=1.2.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pegen >=0.1.0", + "ply", + "pyqt", + "python >=3.9,<3.10.0a0", + "qtpy >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ba56376980ad689461916c7226b0adb7", + "name": "enaml", + "sha256": "439f0b9c3c8e542b29c5962c57647ed93580471f3c5357d13007c881994cffc1", + "size": 772122, + "subdir": "linux-64", + "timestamp": 1680271631104, + "version": "0.16.0" + }, + "ensureconda-1.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "click >=5.1", + "filelock", + "python >=3.10,<3.11.0a0", + "requests >=2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6aba5a87052419e7927d360848cd5cf8", + "name": "ensureconda", + "sha256": "84102a8aa211c3bd95c44683c183c81521075378a31b8f56abae8f208b28703c", + "size": 18298, + "subdir": "linux-64", + "timestamp": 1676366477098, + "version": "1.4.3" + }, + "ensureconda-1.4.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "click >=5.1", + "filelock", + "python >=3.11,<3.12.0a0", + "requests >=2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9a8e0502e024cb7e026c37d21acf6c0", + "name": "ensureconda", + "sha256": "87db69f00441975b074411666b49bfb51632674d171add93debc39a653dbc18b", + "size": 22165, + "subdir": "linux-64", + "timestamp": 1679340458675, + "version": "1.4.3" + }, + "ensureconda-1.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "click >=5.1", + "filelock", + "python >=3.7,<3.8.0a0", + "requests >=2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e24b8ce1a0d48642bf570cb5c55b3d4a", + "name": "ensureconda", + "sha256": "7eef0b6416f6705d0ae6eae65765e108521ec80123c2558eb3fb385658184747", + "size": 18079, + "subdir": "linux-64", + "timestamp": 1676366389464, + "version": "1.4.3" + }, + "ensureconda-1.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "click >=5.1", + "filelock", + "python >=3.8,<3.9.0a0", + "requests >=2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8aada8f0f0f5fb6c473b298cbac239dc", + "name": "ensureconda", + "sha256": "11abb6a863f9ee5ba25f9bab51345ff06f14ec9143d09403cb88f3434894a593", + "size": 18110, + "subdir": "linux-64", + "timestamp": 1676366418604, + "version": "1.4.3" + }, + "ensureconda-1.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "click >=5.1", + "filelock", + "python >=3.9,<3.10.0a0", + "requests >=2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b0f28c62c0aef28011d2a2fa7cf780c9", + "name": "ensureconda", + "sha256": "0cf20439a466ac8d746ec0d919ded8c1b65f41a1bc9e335ad545db87fd957325", + "size": 18169, + "subdir": "linux-64", + "timestamp": 1676366448337, + "version": "1.4.3" + }, + "entrypoints-0.2.3-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "configparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "ca15ee8af3e91fed5729f96dc60292fa", + "name": "entrypoints", + "sha256": "be9f5eaea29d74f481a6759f46abedb02e8ce3e93c6722c4e1ef39d1ed812c32", + "size": 9184, + "subdir": "linux-64", + "timestamp": 1530734317642, + "version": "0.2.3" + }, + "entrypoints-0.2.3-py27h502b47d_2.tar.bz2": { + "build": "py27h502b47d_2", + "build_number": 2, + "depends": [ + "configparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "c824b44a25e89942c69fde74c73cc676", + "name": "entrypoints", + "sha256": "ddfaa1fe2c92da45448e6f9a21a82ecc38f3933a4e977f8c739996ef3dbd40dd", + "size": 9062, + "subdir": "linux-64", + "timestamp": 1505957183808, + "version": "0.2.3" + }, + "entrypoints-0.2.3-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "8bf3f1e4d0a817f775894f3934b79434", + "name": "entrypoints", + "sha256": "93ea4f971fa98ac5ed3284fc8019612964562dbf86ea50264a6881e475e6f329", + "size": 9253, + "subdir": "linux-64", + "timestamp": 1534350908850, + "version": "0.2.3" + }, + "entrypoints-0.2.3-py35h48174a2_2.tar.bz2": { + "build": "py35h48174a2_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "9e353dc7e2ef3e3f51d95dde6e21bb46", + "name": "entrypoints", + "sha256": "73a77877e6506971abac4181756bc5981f0b2d3585245648269792bb388312f7", + "size": 9247, + "subdir": "linux-64", + "timestamp": 1505957193149, + "version": "0.2.3" + }, + "entrypoints-0.2.3-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "73fc60ad92d50dfc7b16d63eae98e452", + "name": "entrypoints", + "sha256": "f65d791d8fe14f41efde35d45f0c8433eaafd5803fe624eeabd71b614023fd47", + "size": 9310, + "subdir": "linux-64", + "timestamp": 1530734303576, + "version": "0.2.3" + }, + "entrypoints-0.2.3-py36h1aec115_2.tar.bz2": { + "build": "py36h1aec115_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "ae507b625bf8ae737accb095069764ae", + "name": "entrypoints", + "sha256": "3d37e78c468bd784465352e66988d7b6b9c303e3b5e2c2dbd0d99f96e769e394", + "size": 9206, + "subdir": "linux-64", + "timestamp": 1505957202310, + "version": "0.2.3" + }, + "entrypoints-0.2.3-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "8a8884a693659ef8f7a7887ddf19b054", + "name": "entrypoints", + "sha256": "4decac4610c1afb64f8916043b3839ccaca4d9fd26e70a987f671b273ae0350a", + "size": 9353, + "subdir": "linux-64", + "timestamp": 1530734332395, + "version": "0.2.3" + }, + "entrypoints-0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "15e221a039b9be1b886b71772c4a9e48", + "name": "entrypoints", + "sha256": "77f3d186f2fb2a1e8cb1081c6e317f679cab39ba549a7a7e95e3adc8215a782c", + "size": 11905, + "subdir": "linux-64", + "timestamp": 1547904707913, + "version": "0.3" + }, + "entrypoints-0.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "b34144a0ecc5655c98a2da3f4da14ad8", + "name": "entrypoints", + "sha256": "91f587f86092514e07c6be865f5532905329c1b1d70324e96789a0c66d88d34d", + "size": 10167, + "subdir": "linux-64", + "timestamp": 1641916225764, + "version": "0.3" + }, + "entrypoints-0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "808dcd27f36c39a7dcd9f1b5fccb1c11", + "name": "entrypoints", + "sha256": "8868b579707ca9a7b0e64348d2e08c801cd09611f55a01d70863922e93e17b1c", + "size": 12014, + "subdir": "linux-64", + "timestamp": 1547904768453, + "version": "0.3" + }, + "entrypoints-0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "455232993798b8378d543bc25085a36e", + "name": "entrypoints", + "sha256": "51cfe44c9fd557d007ff2e8735b363cdab4bea5952a9d111c261a661e407a0e0", + "size": 12021, + "subdir": "linux-64", + "timestamp": 1547904690205, + "version": "0.3" + }, + "entrypoints-0.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "9730fa5909d198b04d02c53550215f78", + "name": "entrypoints", + "sha256": "4dc6c032bc6ceb7518b6fc190ea42fd544a82f5cd0c92fd4c3b00c41f1bf4160", + "size": 10202, + "subdir": "linux-64", + "timestamp": 1572514983215, + "version": "0.3" + }, + "entrypoints-0.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "61c44ed50379c0ad298e6c4f9be340e4", + "name": "entrypoints", + "sha256": "5905275c422f99d97bb417fbad95e289da6f9cc1ff69ae99d54bc88ec66b8847", + "size": 12288, + "subdir": "linux-64", + "timestamp": 1607365042348, + "version": "0.3" + }, + "entrypoints-0.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "57314b5e1702906d03bfcff4d7eab35a", + "name": "entrypoints", + "sha256": "413921f9bdd75ddbf9667fc35d4f7b8ac6ce751ab992297635e0cad2a8a9174e", + "size": 16500, + "subdir": "linux-64", + "timestamp": 1649908359372, + "version": "0.4" + }, + "entrypoints-0.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "245cb7173dcdba21cf368031cd87f706", + "name": "entrypoints", + "sha256": "4b589e3265c74159130230c164ff2d8d381be65899a249def0b53f93ce83fd47", + "size": 17434, + "subdir": "linux-64", + "timestamp": 1676823330845, + "version": "0.4" + }, + "entrypoints-0.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "d33b58600ae99d4407f2ebbf280d0253", + "name": "entrypoints", + "sha256": "2abbec102532da7c8a972c4ece6faefd385c241f1da0cc56cfb1d647dacde82b", + "size": 16327, + "subdir": "linux-64", + "timestamp": 1649908625568, + "version": "0.4" + }, + "entrypoints-0.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "20c8874b5ae24bf4bea2303aeb5f7f03", + "name": "entrypoints", + "sha256": "fc256adb1e5c237867e04a2699c1eec3ea93256cfa7914880d59c69563f1c95d", + "size": 16351, + "subdir": "linux-64", + "timestamp": 1649926480666, + "version": "0.4" + }, + "entrypoints-0.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "2e6ec51066d825ef3c317abe78d6049e", + "name": "entrypoints", + "sha256": "96289b0fa3e06e1e2093680248f19e01ead264cda209267c113f7910fb2b975b", + "size": 16413, + "subdir": "linux-64", + "timestamp": 1649926472708, + "version": "0.4" + }, + "enum34-1.1.10-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "233fe9d03f1348468f2ad42a6ffdba1e", + "name": "enum34", + "sha256": "11e69022072b12b120a20fa447e15177f89436ce0d7b59b52ad896cccfeefdbf", + "size": 4355, + "subdir": "linux-64", + "timestamp": 1640789804646, + "version": "1.1.10" + }, + "enum34-1.1.10-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "5bfd81971c68b5e844995a719293b138", + "name": "enum34", + "sha256": "8301a37e2141efcfb02132709b38adee2e56aa948a9afe61b173f005dff84ff6", + "size": 4643, + "subdir": "linux-64", + "timestamp": 1676852155800, + "version": "1.1.10" + }, + "enum34-1.1.10-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "266f7b4fe987ab73e2df5118bef64da0", + "name": "enum34", + "sha256": "545bbf2e3e69e11d797526572fb885104b4325762c79ac4470261ceefdd2d2d1", + "size": 5578, + "subdir": "linux-64", + "timestamp": 1617954039209, + "version": "1.1.10" + }, + "enum34-1.1.10-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "0e730077cce4199e8b75e48c2ac62e57", + "name": "enum34", + "sha256": "c78524df9437a7c4a28b92b3ea87ca0011a6e82fffd7f8ff9796dd1e9d0a309c", + "size": 5574, + "subdir": "linux-64", + "timestamp": 1617954039535, + "version": "1.1.10" + }, + "enum34-1.1.10-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e0e26e2990390cc57667a6d2e52cf62a", + "name": "enum34", + "sha256": "1536e50d6061c2b9e20cfd5afe372716412c68046d91f82f5fb3799706ea0d49", + "size": 5581, + "subdir": "linux-64", + "timestamp": 1617951147712, + "version": "1.1.10" + }, + "enum34-1.1.10-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "3687085ef664636f18ec440f108969d3", + "name": "enum34", + "sha256": "8d75df64bc9a2d6e0196cc9de0c2aac291c2e021c98d36786090a7efc3967d8b", + "size": 5605, + "subdir": "linux-64", + "timestamp": 1617954031322, + "version": "1.1.10" + }, + "enum34-1.1.6-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "eaed0f82ad53c1de779afb0faf3b0873", + "name": "enum34", + "sha256": "baa84ebef778f81955fa46a0179b3193b91ea1c62294c0de2869ba8562554094", + "size": 57952, + "subdir": "linux-64", + "timestamp": 1530735352907, + "version": "1.1.6" + }, + "enum34-1.1.6-py27h99a27e9_1.tar.bz2": { + "build": "py27h99a27e9_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9bd29980d37987cd9ad95270e0d22bcf", + "name": "enum34", + "sha256": "1673767d01a4a66c63c623dc658b9fcaa792397a1556053c040ac849183d0fc4", + "size": 57674, + "subdir": "linux-64", + "timestamp": 1505672101856, + "version": "1.1.6" + }, + "envisage-4.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=2.7,<2.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5c5dbd3ad54d9d25433a045e118c2f5c", + "name": "envisage", + "sha256": "ea04071158fea2e82bbb5ca2e75c88085a0d1b215ae950f0c740496020d18086", + "size": 359625, + "subdir": "linux-64", + "timestamp": 1530874981923, + "version": "4.6.0" + }, + "envisage-4.6.0-py27hf3b32b8_0.tar.bz2": { + "build": "py27hf3b32b8_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=2.7,<2.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "730c2150523e406055e04af07fc512c9", + "name": "envisage", + "sha256": "6f6c677a91985f9dea6af11ea76d11a26b81395d20162a2125d8ac57027a3eec", + "size": 360078, + "subdir": "linux-64", + "timestamp": 1507932278907, + "version": "4.6.0" + }, + "envisage-4.6.0-py35hcb524f0_0.tar.bz2": { + "build": "py35hcb524f0_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=3.5,<3.6.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f0f8f700194511168753e44100b52e03", + "name": "envisage", + "sha256": "f5bc68ac01ccec77dfea6d185e075ccbe72c9cc7caf1cbd9ebaa985679c874ad", + "size": 368746, + "subdir": "linux-64", + "timestamp": 1507932304774, + "version": "4.6.0" + }, + "envisage-4.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c0d96a3fa5f29884beb7e754738bf16d", + "name": "envisage", + "sha256": "9f03b63908f110b7e96be2bb22f4297a040177ae661a96578ef212606ddef405", + "size": 367184, + "subdir": "linux-64", + "timestamp": 1530874898541, + "version": "4.6.0" + }, + "envisage-4.6.0-py36h49a624e_0.tar.bz2": { + "build": "py36h49a624e_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "52f9f3e3a9178b27685e72ffaa7dc2bf", + "name": "envisage", + "sha256": "59b816d07ff1aec73ba799eccc0086b9efee7f1324162718de5309cc6d473ae9", + "size": 367009, + "subdir": "linux-64", + "timestamp": 1507932296399, + "version": "4.6.0" + }, + "envisage-4.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "41679e3c7f2f700dcaee9ebce43855ed", + "name": "envisage", + "sha256": "2b0c03e5b59dda92aa67e9ed5b6a7852247f762be1d165f570a48d2b786bfa84", + "size": 366349, + "subdir": "linux-64", + "timestamp": 1530874943283, + "version": "4.6.0" + }, + "envisage-4.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=2.7,<2.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "14bd734c3b0f699333c8d38756f35e43", + "name": "envisage", + "sha256": "0dfaa0c3ad0c86ae8de42b153489de807f6e946d1e87afc7506fb19cc3d014bb", + "size": 378120, + "subdir": "linux-64", + "timestamp": 1536251641471, + "version": "4.7.0" + }, + "envisage-4.7.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=3.5,<3.6.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b2c0154c03f798894fd29e4645bba669", + "name": "envisage", + "sha256": "dbdca49dddede62a75519f9d9e45d6c3664ff2b32a475c5db158366ab109f463", + "size": 386599, + "subdir": "linux-64", + "timestamp": 1536257290860, + "version": "4.7.0" + }, + "envisage-4.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "895adca49c0e0586f7000c5948358292", + "name": "envisage", + "sha256": "5bdb701bc552901bdb9d8ce42537de52ff008de628a747615886553d937ff086", + "size": 384287, + "subdir": "linux-64", + "timestamp": 1536251623107, + "version": "4.7.0" + }, + "envisage-4.7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4569b6c041a9e044b702019a0cd6050a", + "name": "envisage", + "sha256": "ef076ff41d344102e0aefaf1f788662c51a874107cb716a5631b7550ef90fd65", + "size": 384961, + "subdir": "linux-64", + "timestamp": 1536251723736, + "version": "4.7.0" + }, + "ephem-3.7.6.0-py27h14c3975_1.tar.bz2": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL", + "md5": "988a3111cf322cfed914da8296987acd", + "name": "ephem", + "sha256": "49e5cdad9489f91ea7038b74ec0956bc961a52bbe5856393c33f038285c121a0", + "size": 713080, + "subdir": "linux-64", + "timestamp": 1522776099578, + "version": "3.7.6.0" + }, + "ephem-3.7.6.0-py35h14c3975_1.tar.bz2": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL", + "md5": "d17870a02554c574811dc60815d59c2e", + "name": "ephem", + "sha256": "64ee9941399b85fbcbd7d0bee6490a8a7acb1181ee8ecfa996e96c4f8a6d9a4e", + "size": 714244, + "subdir": "linux-64", + "timestamp": 1522776222481, + "version": "3.7.6.0" + }, + "ephem-3.7.6.0-py36h14c3975_1.tar.bz2": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL", + "md5": "142c9678e968efa31aff4ace7c16fd3d", + "name": "ephem", + "sha256": "9c11b47bd860e356954359ff3a714d35836985f0010521fa93ed7a4b8b3ad19b", + "size": 713005, + "subdir": "linux-64", + "timestamp": 1522776122925, + "version": "3.7.6.0" + }, + "ephem-3.7.6.0-py37h14c3975_1.tar.bz2": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL", + "md5": "285579db9d9a5baf142e8d77fbcd85c4", + "name": "ephem", + "sha256": "ee43ea88ba454269601b745872bfa0d2183853d3d0975ab8d56ef8f5d1ab6d4e", + "size": 711570, + "subdir": "linux-64", + "timestamp": 1530875953162, + "version": "3.7.6.0" + }, + "ephem-3.7.7.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL", + "md5": "a896b912230710f718baf9b5f223041d", + "name": "ephem", + "sha256": "b7a8d339eacdadd9299badbc5ed62e5f77a0775f1d46613a5b49c9f49ca2e23f", + "size": 756274, + "subdir": "linux-64", + "timestamp": 1569367363723, + "version": "3.7.7.0" + }, + "ephem-3.7.7.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL", + "md5": "5aa319bd74f7352eee76dfcb8d40d481", + "name": "ephem", + "sha256": "f71a6521e7092795bb07cfc0f1a2471515c796e7abca1ca4ae91ba84f383dca2", + "size": 769901, + "subdir": "linux-64", + "timestamp": 1614254425450, + "version": "3.7.7.0" + }, + "ephem-3.7.7.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL", + "md5": "132ce1dec5ec60c80da3f1eba705a73c", + "name": "ephem", + "sha256": "9cfb4e971b37691ee3f5d8b88aa567d4f0357b3957d3d9cac889f6034c9bf086", + "size": 779402, + "subdir": "linux-64", + "timestamp": 1569367318161, + "version": "3.7.7.0" + }, + "ephem-3.7.7.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL", + "md5": "8dfe3db6260da6b801e7fc60fd8d2f2e", + "name": "ephem", + "sha256": "448ec62bbaef41d7870d223356c467307161917406d936aa2437c1770f10da48", + "size": 749199, + "subdir": "linux-64", + "timestamp": 1614254419633, + "version": "3.7.7.0" + }, + "ephem-3.7.7.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL", + "md5": "9c96f01b35b0cb4496e53a1c0188e09f", + "name": "ephem", + "sha256": "794b76cc4b33546befabec68d87066537ab54b4aad2b0125da391ff6710d12e9", + "size": 782759, + "subdir": "linux-64", + "timestamp": 1569367341724, + "version": "3.7.7.0" + }, + "ephem-3.7.7.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL", + "md5": "7f1f09161bab33d3560ec56d17da4b41", + "name": "ephem", + "sha256": "2b7c7bb39dfcd65f549d90097874c36a078b1949034f61f55f471fb6ba37cb5f", + "size": 755650, + "subdir": "linux-64", + "timestamp": 1614254436553, + "version": "3.7.7.0" + }, + "ephem-3.7.7.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL", + "md5": "a2fa551ec4fc6df484a8e69134d27446", + "name": "ephem", + "sha256": "9edaaae814f1497ac927088b96d3af40e2e259892ea68d4b802e85256aa65b01", + "size": 788901, + "subdir": "linux-64", + "timestamp": 1572515083286, + "version": "3.7.7.0" + }, + "ephem-3.7.7.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL", + "md5": "1b5462cf066c00c4ac8176f262c6e9bf", + "name": "ephem", + "sha256": "ac22ca3a04fb8f238bde956b4521e0a4cf0f270635e3e36c2f9f4d7c2038df6b", + "size": 762557, + "subdir": "linux-64", + "timestamp": 1614253910211, + "version": "3.7.7.0" + }, + "ephem-3.7.7.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL", + "md5": "e46add6baebe5695a50e85a96477c5eb", + "name": "ephem", + "sha256": "ac817f070d65d22c7ea2b7d854e4b72dc2b738534c6d9fda018e9b3a79d15967", + "size": 741224, + "subdir": "linux-64", + "timestamp": 1600355436270, + "version": "3.7.7.1" + }, + "ephem-3.7.7.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL", + "md5": "6754d7d84474d36022f557ae585e14c4", + "name": "ephem", + "sha256": "bf4a1c953781a426f38ff315ee51e107b149cc0d75405544a66965c3c229c6ba", + "size": 772805, + "subdir": "linux-64", + "timestamp": 1600355443111, + "version": "3.7.7.1" + }, + "ephem-3.7.7.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL", + "md5": "a26867cf1782307d603f2ea450c5f7a3", + "name": "ephem", + "sha256": "17be6beb2b1d71afa3401460be73b25310e385b3d81646c9bc092c07ffab5bf5", + "size": 779954, + "subdir": "linux-64", + "timestamp": 1600355448368, + "version": "3.7.7.1" + }, + "ephem-4.0.0.2-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "b6133d97fde10842e38e9e7d4f598fbe", + "name": "ephem", + "sha256": "3154aeb7ef42e1f8875be5ec18d690d1ab4ede465a4b10b6b8d1127b881e1e56", + "size": 770967, + "subdir": "linux-64", + "timestamp": 1623914259875, + "version": "4.0.0.2" + }, + "ephem-4.0.0.2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "4c949bfdd76cc19315546c0fdc671879", + "name": "ephem", + "sha256": "bb51cbafdaa58c9285cb19862470ea247a30cb6d57e1969cda99ca7194ba439d", + "size": 791606, + "subdir": "linux-64", + "timestamp": 1623920149976, + "version": "4.0.0.2" + }, + "ephem-4.0.0.2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "07d2e608540fa8a47ce797124348542b", + "name": "ephem", + "sha256": "e1d290638f2c01e215e32107f27cfe6b7c200a6624adf9251078afc24816101a", + "size": 771508, + "subdir": "linux-64", + "timestamp": 1623919653923, + "version": "4.0.0.2" + }, + "ephem-4.0.0.2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "ca929be3454441b3be87331fba8e1851", + "name": "ephem", + "sha256": "e4fa5d5c82260788f170f9fe6082f55ede891aa240b95dbce3f8105844b4f41d", + "size": 758819, + "subdir": "linux-64", + "timestamp": 1623920142352, + "version": "4.0.0.2" + }, + "ephem-4.1.2-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7adbc7ce67300ecd1e858593c58bf52c", + "name": "ephem", + "sha256": "641b8325631154312924725e0597168293fc42fda976778e507da9476a4691d5", + "size": 1704051, + "subdir": "linux-64", + "timestamp": 1640789838002, + "version": "4.1.2" + }, + "ephem-4.1.2-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fbf707c3cdd296f4bca64940076d100b", + "name": "ephem", + "sha256": "4925ea34978c0ee058e3a51487e22e4586918494cfe0632404addbe2bc3dcae6", + "size": 1500869, + "subdir": "linux-64", + "timestamp": 1676852179216, + "version": "4.1.2" + }, + "ephem-4.1.2-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9488e514d86570e28c5087de4adbbd3", + "name": "ephem", + "sha256": "9251b4c8e09b17a2c6a7033c5dc0b3c857e0c724602160c3a79dd1997468703f", + "size": 1460107, + "subdir": "linux-64", + "timestamp": 1638960359365, + "version": "4.1.2" + }, + "ephem-4.1.2-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eaf81e700d179704bb1bc08bd20cad14", + "name": "ephem", + "sha256": "bbafe8466c0dd296c9659a03123f562b46c53598c3726f95a7b3299cea19d91c", + "size": 1461643, + "subdir": "linux-64", + "timestamp": 1638942240609, + "version": "4.1.2" + }, + "ephem-4.1.2-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3020a95de8401ba23ed27ac0d262bb5b", + "name": "ephem", + "sha256": "b3ba6c18282a387d2a211ad986ca77b66d57a53f9c0a678f40d8a2c3f69379dc", + "size": 1442504, + "subdir": "linux-64", + "timestamp": 1638960361596, + "version": "4.1.2" + }, + "epoxy-1.5.4-h7f8727e_2.tar.bz2": { + "build": "h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "340768eafadc5e0fd4db3fa0ae399b77", + "name": "epoxy", + "sha256": "431679e089a8c54bd993e19a3d4204204d5705e269f03fac137c84b7038fbe85", + "size": 1504597, + "subdir": "linux-64", + "timestamp": 1632392751126, + "version": "1.5.4" + }, + "et_xmlfile-1.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e34c1416c1aa4725b12b5cb876371741", + "name": "et_xmlfile", + "sha256": "55bffbbd03b352f7e061e511aa1ea0db690be4e5d9f87db75672667648c2bdb6", + "size": 20247, + "subdir": "linux-64", + "timestamp": 1530736038853, + "version": "1.0.1" + }, + "et_xmlfile-1.0.1-py27h75840f5_0.tar.bz2": { + "build": "py27h75840f5_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8bf75539ec4217609deccc72519ab0fa", + "name": "et_xmlfile", + "sha256": "35ebbc14046703eb72b26e6da49b672c5083aec038428a285a1c0ae075e1e054", + "size": 20128, + "subdir": "linux-64", + "timestamp": 1505742745961, + "version": "1.0.1" + }, + "et_xmlfile-1.0.1-py35hde8d43e_0.tar.bz2": { + "build": "py35hde8d43e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ff025f06d204d5702fb1f8287ff0cc6", + "name": "et_xmlfile", + "sha256": "796f30dee9a1fc7b5e63e9f2eed3034b54f47a1f2aa331c4e2eb793c9191c1de", + "size": 20756, + "subdir": "linux-64", + "timestamp": 1505742758336, + "version": "1.0.1" + }, + "et_xmlfile-1.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e368075a588f3eb22744013370bcf69", + "name": "et_xmlfile", + "sha256": "973c151c206292335edb095d5cd63dc9b72c7fe25ef0fa2107eb2ee28d26cdb5", + "size": 20875, + "subdir": "linux-64", + "timestamp": 1530736018654, + "version": "1.0.1" + }, + "et_xmlfile-1.0.1-py36hd6bccc3_0.tar.bz2": { + "build": "py36hd6bccc3_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e9009e35f5bcb129cf84ec40f6b4e04", + "name": "et_xmlfile", + "sha256": "f53a6270dc414aa14d9fa6a41a5b472a84b739345790297a37490165f76966b0", + "size": 20738, + "subdir": "linux-64", + "timestamp": 1505742770931, + "version": "1.0.1" + }, + "et_xmlfile-1.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5136a46fc2de1b26e4be3c28ccc8f7ad", + "name": "et_xmlfile", + "sha256": "412f91a9afac54b126f70c9051f12aff564241ea2f3bb2eac6e5c6f0d8529057", + "size": 20898, + "subdir": "linux-64", + "timestamp": 1530736059295, + "version": "1.0.1" + }, + "et_xmlfile-1.0.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33c4fd78e40e6d99748a98f9cf75e716", + "name": "et_xmlfile", + "sha256": "d5416a62ac3266c432272db5e72b18bef579a35daa0f6fe4d196469223658e3e", + "size": 21351, + "subdir": "linux-64", + "timestamp": 1572515104873, + "version": "1.0.1" + }, + "et_xmlfile-1.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT AND PSF-2.0", + "license_family": "MIT", + "md5": "0d2b3b2875b94df63f9071cf41692718", + "name": "et_xmlfile", + "sha256": "04ea9c5303c6a8cfcfa2cea5bb429d563ca3e1f3b23a39fa375a8afaf532ad39", + "size": 8977, + "subdir": "linux-64", + "timestamp": 1642499265483, + "version": "1.1.0" + }, + "et_xmlfile-1.1.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT AND PSF-2.0", + "license_family": "MIT", + "md5": "4a501c0d30834c79007725e1a84ba409", + "name": "et_xmlfile", + "sha256": "ef59f9afbfe1d05a4a43a4e08b93e6a948516a9f6e94859c76e0eef87ef4f524", + "size": 10172, + "subdir": "linux-64", + "timestamp": 1676830488113, + "version": "1.1.0" + }, + "et_xmlfile-1.1.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f064caf208706552b9f43cadf5c8fe38", + "name": "et_xmlfile", + "sha256": "9a5ce6c9f23de2e9210551435db2e581146c6125b0dedb20ffab33e3eee9eaf8", + "size": 8995, + "subdir": "linux-64", + "timestamp": 1621828471711, + "version": "1.1.0" + }, + "et_xmlfile-1.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ab67dffe6b931f38a5ea5187c520e60", + "name": "et_xmlfile", + "sha256": "6802054c34e634a7f18e9b07ae01ca2dd01bb1a9188b24ad0e55400182904812", + "size": 8987, + "subdir": "linux-64", + "timestamp": 1621828463872, + "version": "1.1.0" + }, + "et_xmlfile-1.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16d77bb061cd6d2cc4860c612500fc6e", + "name": "et_xmlfile", + "sha256": "1e885ded0bde776b5cfa087b717172ab5039fe32303d215095271debe2995132", + "size": 9010, + "subdir": "linux-64", + "timestamp": 1621828464340, + "version": "1.1.0" + }, + "et_xmlfile-1.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT AND PSF-2.0", + "license_family": "MIT", + "md5": "5d9311b654d4f3c8db8bb585c94b13ba", + "name": "et_xmlfile", + "sha256": "f1e21bc556aef416c3e6cb9a98b09231b2b2ebab775ef956f259ed766ad2e7d1", + "size": 9045, + "subdir": "linux-64", + "timestamp": 1621866114609, + "version": "1.1.0" + }, + "evaluate-0.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cookiecutter", + "datasets >=2.0.0", + "dill", + "fsspec >=2021.05.0", + "huggingface_hub >=0.7.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "python >=3.10,<3.11.0a0", + "python-xxhash", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1ce879f4c0b945db578d94be8d250603", + "name": "evaluate", + "sha256": "611cb6b9985b8365117869c1e1a5960609d9561f63179b80377316791cf31917", + "size": 103161, + "subdir": "linux-64", + "timestamp": 1668622833770, + "version": "0.3.0" + }, + "evaluate-0.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cookiecutter", + "datasets >=2.0.0", + "dill", + "fsspec >=2021.05.0", + "huggingface_hub >=0.7.0", + "importlib-metadata", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "python >=3.7,<3.8.0a0", + "python-xxhash", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0e7048adb40d7025c5d055e3180dee3c", + "name": "evaluate", + "sha256": "0bae49d2e694c206a9aca328cd2e9df1e0c31c12733e8e6a4ed9eae48f0906c3", + "size": 101146, + "subdir": "linux-64", + "timestamp": 1668622777591, + "version": "0.3.0" + }, + "evaluate-0.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cookiecutter", + "datasets >=2.0.0", + "dill", + "fsspec >=2021.05.0", + "huggingface_hub >=0.7.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "python >=3.8,<3.9.0a0", + "python-xxhash", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2954d6d4c7b48e6bc2d43133409e4c2e", + "name": "evaluate", + "sha256": "76e01f65f5eae28fd26655dcd86d14ec84349ec2f7a848a881c35c6b5422cd93", + "size": 101607, + "subdir": "linux-64", + "timestamp": 1668622931661, + "version": "0.3.0" + }, + "evaluate-0.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cookiecutter", + "datasets >=2.0.0", + "dill", + "fsspec >=2021.05.0", + "huggingface_hub >=0.7.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "python >=3.9,<3.10.0a0", + "python-xxhash", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c262e88219a357adfd3202e0e3799ac8", + "name": "evaluate", + "sha256": "bfb2e08dd0f9e21752b6590607f58502af0407dcd7f3a6c318cb2d9071e8b476", + "size": 101768, + "subdir": "linux-64", + "timestamp": 1668622883126, + "version": "0.3.0" + }, + "evaluate-0.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cookiecutter", + "datasets >=2.0.0", + "dill", + "fsspec >=2021.05.0", + "huggingface_hub >=0.7.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "python >=3.10,<3.11.0a0", + "python-xxhash", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a16975ab6f9bc1a16581a242ad6d97c2", + "name": "evaluate", + "sha256": "16a7fb208f396d351cca803410a28f1b6de239aeec7c552a3df31b016fbae259", + "size": 112975, + "subdir": "linux-64", + "timestamp": 1679573642350, + "version": "0.4.0" + }, + "evaluate-0.4.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cookiecutter", + "datasets >=2.0.0", + "dill", + "fsspec >=2021.05.0", + "huggingface_hub >=0.7.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "python >=3.11,<3.12.0a0", + "python-xxhash", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5d8b9c1e76d1a5ade9fcf64e84c970b4", + "name": "evaluate", + "sha256": "68074886d141ecb9081885c509a7e350d59eb341651dac39bc8e3ce7278d54e8", + "size": 146721, + "subdir": "linux-64", + "timestamp": 1679573745132, + "version": "0.4.0" + }, + "evaluate-0.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cookiecutter", + "datasets >=2.0.0", + "dill", + "fsspec >=2021.05.0", + "huggingface_hub >=0.7.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "python >=3.8,<3.9.0a0", + "python-xxhash", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5d6791dcf3a748dc36781224aa5a3d1a", + "name": "evaluate", + "sha256": "d29053c87c3a7ddf5e1af1339c1c2f0dca12ff05008f80b2ddbc16fcbc6309d9", + "size": 111314, + "subdir": "linux-64", + "timestamp": 1679573697778, + "version": "0.4.0" + }, + "evaluate-0.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cookiecutter", + "datasets >=2.0.0", + "dill", + "fsspec >=2021.05.0", + "huggingface_hub >=0.7.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "python >=3.9,<3.10.0a0", + "python-xxhash", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2ae674159a1a9f22b71e6fcc2d0198a3", + "name": "evaluate", + "sha256": "fa387e638ca21defb6cddd478ba4bb49794e9cfc25091508cae499d5f62ece5e", + "size": 111471, + "subdir": "linux-64", + "timestamp": 1679573791010, + "version": "0.4.0" + }, + "eventlet-0.26.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "greenlet >=0.3", + "monotonic >=1.4", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "six >=1.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f80315b4e17b62bdc7e5c428ef63bca9", + "name": "eventlet", + "sha256": "03dfd6d7c860ae53593e4dd7a3e3ded31e173e15532912f13d601b9ffa10f8a7", + "size": 332057, + "subdir": "linux-64", + "timestamp": 1596834704090, + "version": "0.26.1" + }, + "eventlet-0.27.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0,<2.0.0", + "greenlet >=0.3", + "monotonic >=1.4", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "six >=1.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bef0bc86f873523fd53c5a882d96d8f1", + "name": "eventlet", + "sha256": "48bfb35bde4354e0a12917b4796c83bfa86d4bee2cb9d9a7903065ee774b6cb9", + "size": 326185, + "subdir": "linux-64", + "timestamp": 1600355442520, + "version": "0.27.0" + }, + "eventlet-0.27.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0,<2.0.0", + "greenlet >=0.3", + "monotonic >=1.4", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "six >=1.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "91417c237df98b68206b2e3e6bf9cf6d", + "name": "eventlet", + "sha256": "b3cf1833a87d763d37005e3da1d871b9f1bde186338e79fe94e5b7b798dc5beb", + "size": 332662, + "subdir": "linux-64", + "timestamp": 1600355432175, + "version": "0.27.0" + }, + "eventlet-0.27.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0,<2.0.0", + "greenlet >=0.3", + "monotonic >=1.4", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "six >=1.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff8a961f705303af5b0ac73c44e8260d", + "name": "eventlet", + "sha256": "8e216ef8017f76cf60b3cfd868c99878023badde6f4cbcbfaa2505530fa4fbc2", + "size": 328067, + "subdir": "linux-64", + "timestamp": 1600355427983, + "version": "0.27.0" + }, + "eventlet-0.33.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "greenlet >=0.3", + "pyopenssl", + "python >=3.10,<3.11.0a0", + "six >=1.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37b21166d1f4081678507c763a9e66c7", + "name": "eventlet", + "sha256": "d6488156f39b2efaf83ed082765a16ebf32bc233f4982bf8b239f8d9436ba41e", + "size": 341477, + "subdir": "linux-64", + "timestamp": 1659714656321, + "version": "0.33.1" + }, + "eventlet-0.33.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "greenlet >=0.3", + "pyopenssl", + "python >=3.11,<3.12.0a0", + "six >=1.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85d0a587e0e73ad676a6e63867c826f9", + "name": "eventlet", + "sha256": "a65ea2daf9ddfd37658628da3116a4d071fdfad49e889cc6471763721ab25c69", + "size": 434383, + "subdir": "linux-64", + "timestamp": 1676852212804, + "version": "0.33.1" + }, + "eventlet-0.33.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "greenlet >=0.3", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "six >=1.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "118071feb36448c83ddde0de139d36f9", + "name": "eventlet", + "sha256": "1e32188c36f91360accfceaf253f90455c1cf7fb66502192db3d7d9242fa6e9f", + "size": 338003, + "subdir": "linux-64", + "timestamp": 1659714711796, + "version": "0.33.1" + }, + "eventlet-0.33.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "greenlet >=0.3", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "six >=1.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f49c403c20daa18777860da5a28f256", + "name": "eventlet", + "sha256": "08792b691f10b6cb70a238c3a46014fa244642acc63579c91deb72916e6e439a", + "size": 338328, + "subdir": "linux-64", + "timestamp": 1659714683866, + "version": "0.33.1" + }, + "eventlet-0.33.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "greenlet >=0.3", + "pyopenssl", + "python >=3.9,<3.10.0a0", + "six >=1.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51a04f0ba574f377142785e6ddff7747", + "name": "eventlet", + "sha256": "8d18a3bf20fcefd86ef6a4f1d65bfc5ea67ebb8c14db6b67d030ae065aac1f05", + "size": 339555, + "subdir": "linux-64", + "timestamp": 1659714615473, + "version": "0.33.1" + }, + "exceptiongroup-1.0.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a74f333ec7df6a6ec4793f890560fbdf", + "name": "exceptiongroup", + "sha256": "cfc573ac839d44c53498b07641283668461cf6d503913ea6eaf38e48b7f8c861", + "size": 26988, + "subdir": "linux-64", + "timestamp": 1668714404585, + "version": "1.0.4" + }, + "exceptiongroup-1.0.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8cf6d0248f6c9b090c4567250bac17b9", + "name": "exceptiongroup", + "sha256": "949a82fc74c16c372694b1fd1c80c14359357ae9c449da7f3ec3bd6af3947209", + "size": 34194, + "subdir": "linux-64", + "timestamp": 1676827740583, + "version": "1.0.4" + }, + "exceptiongroup-1.0.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d9d294440814754cb8f1547127343e13", + "name": "exceptiongroup", + "sha256": "1e5ea30763ceeee26d07381436c37030c0cae19b76addb7a6021dcb5eb0d2848", + "size": 26701, + "subdir": "linux-64", + "timestamp": 1668714433596, + "version": "1.0.4" + }, + "exceptiongroup-1.0.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "654399a69fe9ff95809d8e7874d3c75b", + "name": "exceptiongroup", + "sha256": "b9b0c7d312b32bc7355441dc7c19c3305207a71d694a764084eeb93739ecc343", + "size": 26774, + "subdir": "linux-64", + "timestamp": 1668714375773, + "version": "1.0.4" + }, + "exceptiongroup-1.0.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b4d923222d45314856b5378cb115214d", + "name": "exceptiongroup", + "sha256": "e3fa60df94ad383173fa0d565afbe74070fa0765ca1e423720c0f08f525bcb20", + "size": 26728, + "subdir": "linux-64", + "timestamp": 1668714462023, + "version": "1.0.4" + }, + "execnet-1.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "apipkg >=1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9c6767f881a8adcab0de61d85793680f", + "name": "execnet", + "sha256": "b70c75af6330c332eca61747de30a3276e2d4feadc1829acbdc5e027fc39802c", + "size": 63378, + "subdir": "linux-64", + "timestamp": 1530727897484, + "version": "1.5.0" + }, + "execnet-1.5.0-py27hb11c14a_0.tar.bz2": { + "build": "py27hb11c14a_0", + "build_number": 0, + "depends": [ + "apipkg >=1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f105eb3d33b0e90fa03bddafce2a1381", + "name": "execnet", + "sha256": "49e9919df4e8bccbe152ffd616a3f49c60562cd64604ba4fd7045789f03e5d30", + "size": 63728, + "subdir": "linux-64", + "timestamp": 1510987279438, + "version": "1.5.0" + }, + "execnet-1.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "apipkg >=1.4", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "713915b937bf28a496dc3db5bf466e0d", + "name": "execnet", + "sha256": "435ea295c64e608da88c7ec0492f567f3cfdb6b22451ede0177de305090d11b9", + "size": 65015, + "subdir": "linux-64", + "timestamp": 1534347564435, + "version": "1.5.0" + }, + "execnet-1.5.0-py35h6c6e770_0.tar.bz2": { + "build": "py35h6c6e770_0", + "build_number": 0, + "depends": [ + "apipkg >=1.4", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "9668386f137fa257d8e4cd6b558f30e6", + "name": "execnet", + "sha256": "f95dcfb98a08eaf110ae4cf0d3f819b4f30cae4890a37506e7228d79c46ab2ef", + "size": 65428, + "subdir": "linux-64", + "timestamp": 1510987291117, + "version": "1.5.0" + }, + "execnet-1.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "apipkg >=1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "5ea6d090fbeace9cf13eb9e99c41cf8c", + "name": "execnet", + "sha256": "a7b5c0b34250aef5245a02fa618b8ef8f3d2b62dfddb1f036c64bded2f9eb9c2", + "size": 64796, + "subdir": "linux-64", + "timestamp": 1530727939072, + "version": "1.5.0" + }, + "execnet-1.5.0-py36hcd6bdcb_0.tar.bz2": { + "build": "py36hcd6bdcb_0", + "build_number": 0, + "depends": [ + "apipkg >=1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "08520325be9ebe781b2ab21b5380f6f8", + "name": "execnet", + "sha256": "1dbec0e6e6316c99667b66e726fcc0791a9e29c54fc846804615c0af69a495fc", + "size": 65198, + "subdir": "linux-64", + "timestamp": 1510987288583, + "version": "1.5.0" + }, + "execnet-1.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "apipkg >=1.4", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "10df8bddd777f96bd5c972ea46881724", + "name": "execnet", + "sha256": "c84ecbe16d5a07fddc4b629d4c649bc817f568328149352cc330a8188e95c1f0", + "size": 65063, + "subdir": "linux-64", + "timestamp": 1530727917769, + "version": "1.5.0" + }, + "expat-2.2.10-he6710b0_2.tar.bz2": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5de87d9faa999a0797c1e16596580ca0", + "name": "expat", + "sha256": "32c368c2afb64464dbcde179933a5327433494c78534ae1e6185376ee5a39308", + "size": 197036, + "subdir": "linux-64", + "timestamp": 1602279285212, + "version": "2.2.10" + }, + "expat-2.2.4-h6ea4f2b_2.tar.bz2": { + "build": "h6ea4f2b_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "6086e86081f8b15877664020dcea4dcb", + "name": "expat", + "sha256": "fd260f2fd098535d5babfacbb9482781c2358cad882874b5815c5f4fffeabede", + "size": 189902, + "subdir": "linux-64", + "timestamp": 1509378905711, + "version": "2.2.4" + }, + "expat-2.2.4-h8e22279_3.tar.bz2": { + "build": "h8e22279_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "c2045a589bb8528d847fa268ebb09e4b", + "name": "expat", + "sha256": "5f488ade627b2932897d9c9b53bb2dee7d037a6b8742dd696725839b4610c087", + "size": 189893, + "subdir": "linux-64", + "timestamp": 1510603170862, + "version": "2.2.4" + }, + "expat-2.2.4-hc00ebd1_1.tar.bz2": { + "build": "hc00ebd1_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "8ff4de06d63f470b238d764870792c79", + "name": "expat", + "sha256": "cab53cc9f993fe1e015324932ac69eb1e9ec3222875a21c2aba878bf0d732e2d", + "size": 189076, + "subdir": "linux-64", + "timestamp": 1505687765027, + "version": "2.2.4" + }, + "expat-2.2.5-he0dffb1_0.tar.bz2": { + "build": "he0dffb1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "47e888e8c86b5b232935c17089a99365", + "name": "expat", + "sha256": "c95f48678585d511283e0621155772dea03ae116a7b4dd670ad401306740195b", + "size": 190423, + "subdir": "linux-64", + "timestamp": 1510608289734, + "version": "2.2.5" + }, + "expat-2.2.6-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "fa5e74d741afa1964bd703dd29a9cae9", + "name": "expat", + "sha256": "be6df0ad34b11f4b16c7a9af566d0f291eed3dd093679aefe77e3aecafef9ead", + "size": 191153, + "subdir": "linux-64", + "timestamp": 1535396538938, + "version": "2.2.6" + }, + "expat-2.2.9-he6710b0_2.tar.bz2": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f37c7a525da15181c6fd645ebeddaf72", + "name": "expat", + "sha256": "b74a541a9059d5d5336a252d3d7721cd8883737944b6cf65c9cb45709ab46000", + "size": 200795, + "subdir": "linux-64", + "timestamp": 1593113372530, + "version": "2.2.9" + }, + "expat-2.3.0-h2531618_2.tar.bz2": { + "build": "h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ddad3f7fae1c568f629ffae5bb526dd", + "name": "expat", + "sha256": "37a707eda32eaae5e1e0caeaad872664701bb8950589992437694e1849573d8c", + "size": 201041, + "subdir": "linux-64", + "timestamp": 1616699166604, + "version": "2.3.0" + }, + "expat-2.4.1-h2531618_2.tar.bz2": { + "build": "h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11e97b6cb9080e4eca9de20d47a9eefb", + "name": "expat", + "sha256": "e7b5c01894c8f006d8ce405894bea3c937ade414a2e6ca16c2c081827064debc", + "size": 216070, + "subdir": "linux-64", + "timestamp": 1621849457989, + "version": "2.4.1" + }, + "expat-2.4.4-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c12e8c75f3c7c4f5867827c5dc02dc2c", + "name": "expat", + "sha256": "27cde2cf0b1e10c2315bc1384fcb56537b424f6c2c872ca4662bc971e41910da", + "size": 216001, + "subdir": "linux-64", + "timestamp": 1644418571578, + "version": "2.4.4" + }, + "expat-2.4.9-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d254ca6cf5c657cecd6912b0671379cd", + "name": "expat", + "sha256": "608cb32d156c51de43bd1027504af2b580b8b5c4d436e6523f600d0220f42397", + "size": 192070, + "subdir": "linux-64", + "timestamp": 1664286744782, + "version": "2.4.9" + }, + "expressions-0.2.3-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e7f67e2ec3e7a21f9aef7ace71ff276", + "name": "expressions", + "sha256": "4e017ceb4c20725ec69d332b886b40f5e412754bc93efaf2d7d04af5fdfe9a45", + "size": 14868, + "subdir": "linux-64", + "timestamp": 1537212814479, + "version": "0.2.3" + }, + "expressions-0.2.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77c4b9afa1fad153c7bfaf0eb1bc061b", + "name": "expressions", + "sha256": "702437f3b0f20170570111a4d692c41268ff0866669ff6ffb72f8fef6aa59699", + "size": 16487, + "subdir": "linux-64", + "timestamp": 1640809023581, + "version": "0.2.3" + }, + "expressions-0.2.3-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4fa4339097b0ea76d4dd42a674109d7e", + "name": "expressions", + "sha256": "36197818c6d6b04b16158bd5ddb46ee5b7c1ded19f5133a8d6c65d1e7d344a3e", + "size": 15559, + "subdir": "linux-64", + "timestamp": 1537212836938, + "version": "0.2.3" + }, + "expressions-0.2.3-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "613fb5fd8f9708db0a4678f685f12548", + "name": "expressions", + "sha256": "4311e81593ab0643a15f0c32d97c316b80ca718e3d5231919d0566dd00dce9f3", + "size": 15629, + "subdir": "linux-64", + "timestamp": 1537212848215, + "version": "0.2.3" + }, + "expressions-0.2.3-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a44b7ae26ed1d1723e75977609f6680", + "name": "expressions", + "sha256": "d0b4c8217c5be5ebc04627397b1302ce4ad7dcb0648133b0dd4dbb725f68357b", + "size": 233541, + "subdir": "linux-64", + "timestamp": 1613556520176, + "version": "0.2.3" + }, + "expressions-0.2.3-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be26fe10541acb7e60ace773f92b16c4", + "name": "expressions", + "sha256": "ae91c210b4bb617466c20b1140096c685bbd83bca96341a589b280c31b2beeaa", + "size": 15657, + "subdir": "linux-64", + "timestamp": 1537212783991, + "version": "0.2.3" + }, + "expressions-0.2.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "574534e4109761613c01b1527054bb92", + "name": "expressions", + "sha256": "ab837091efcc3f99dba3cb1b473fecff2fc6df46fc8eeeeacbd4e5e9f6fd05b6", + "size": 234901, + "subdir": "linux-64", + "timestamp": 1613556524899, + "version": "0.2.3" + }, + "expressions-0.2.3-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48b6bf94a34bed26146f05cb07c87744", + "name": "expressions", + "sha256": "a031f7951b54d02c1806876c439713de7ebd4d6ff0d5facfe735f91447345631", + "size": 16137, + "subdir": "linux-64", + "timestamp": 1573738050196, + "version": "0.2.3" + }, + "expressions-0.2.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16e652bd2fe33565efad1da5b97349d4", + "name": "expressions", + "sha256": "d2138bb5a8a0378ab82aecf90ef610a7242022e49f23745c126bf6f3dffbef01", + "size": 233739, + "subdir": "linux-64", + "timestamp": 1613557182978, + "version": "0.2.3" + }, + "expressions-0.2.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "40f184b91590270eafd1595552b55758", + "name": "expressions", + "sha256": "437a8570865eae29b1806240cfaaf9445be849a98391840ba8e48ba0684242e6", + "size": 235754, + "subdir": "linux-64", + "timestamp": 1613557182339, + "version": "0.2.3" + }, + "fabric-1.14.0-py27hbb4c3a6_0.tar.bz2": { + "build": "py27hbb4c3a6_0", + "build_number": 0, + "depends": [ + "paramiko >=1.10,<3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "24ba36e3b82938ca89764d8a49303adc", + "name": "fabric", + "sha256": "1b9865370212cd25fd80ff86daed0a2fcf15a53f528324ad61af90a591c84155", + "size": 120541, + "subdir": "linux-64", + "timestamp": 1507933774339, + "version": "1.14.0" + }, + "fabric-2.1.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=1.0", + "invoke >=1.0,<2.0", + "paramiko >=1.10,<3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7c037498f9bddb3320b369c276902602", + "name": "fabric", + "sha256": "d5643890c50efe371442d04cad54feb4d62d4ed85143bb6da110854808696891", + "size": 53882, + "subdir": "linux-64", + "timestamp": 1527696281169, + "version": "2.1.3" + }, + "fabric-2.1.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography >=1.0", + "invoke >=1.0,<2.0", + "paramiko >=1.10,<3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c60ed9049c0ef6a14aab36d35ab7b2bb", + "name": "fabric", + "sha256": "35c7dcaec5c6ef681d0abdbaeb841f42bd67298f2511be04efbb220e6b18c2c1", + "size": 54722, + "subdir": "linux-64", + "timestamp": 1527696320280, + "version": "2.1.3" + }, + "fabric-2.1.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.0", + "invoke >=1.0,<2.0", + "paramiko >=1.10,<3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "83b2a59d052b137f5d5a5e2f9e288ba1", + "name": "fabric", + "sha256": "6c9ed44e16f8e764ebb4592b6282c0722a83ba58e1bf21bf53bff40c41062bfe", + "size": 54663, + "subdir": "linux-64", + "timestamp": 1527696259355, + "version": "2.1.3" + }, + "fabric-2.1.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=1.0", + "invoke >=1.0,<2.0", + "paramiko >=1.10,<3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ec0d2bdaca906b0de5b20fc4a5dc3939", + "name": "fabric", + "sha256": "58ad05c59cf9f6322cc0ca4514e0cf3e3bebb47c56c62c0fae42f75414df6bc1", + "size": 54699, + "subdir": "linux-64", + "timestamp": 1530876230418, + "version": "2.1.3" + }, + "fabric-2.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=1.1", + "invoke >=1.1,<2.0", + "paramiko >=2.4", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f8c9cbbdce3ea0c98d6423391fc27d58", + "name": "fabric", + "sha256": "831ca0eb04486f1cc3fb2eb06ec6ac3dcc607eadc4e04359545cd2ec204b5fea", + "size": 57924, + "subdir": "linux-64", + "timestamp": 1535497831904, + "version": "2.3.1" + }, + "fabric-2.3.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography >=1.1", + "invoke >=1.1,<2.0", + "paramiko >=2.4", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "07c76ff0f291ac0b3f805ce3f48bf8fc", + "name": "fabric", + "sha256": "cddadb07672aba6b92a1f76ee11978f0be02e2972aa1bcf3538e2b306c5def72", + "size": 58941, + "subdir": "linux-64", + "timestamp": 1535497850196, + "version": "2.3.1" + }, + "fabric-2.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.1", + "invoke >=1.1,<2.0", + "paramiko >=2.4", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7f973b672ad2ea86e50fbc5c21fd32c4", + "name": "fabric", + "sha256": "7ad3617582e74823d19ced4d258b4c8a3c7e4051563595dffdf214a8f1042309", + "size": 58976, + "subdir": "linux-64", + "timestamp": 1535497767085, + "version": "2.3.1" + }, + "fabric-2.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=1.1", + "invoke >=1.1,<2.0", + "paramiko >=2.4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "535c2c14e240eb343abfe2a21233c495", + "name": "fabric", + "sha256": "01857f25c7cb1c4a433d8344b29cba710157c146094f799f9141b88e9e91c340", + "size": 59036, + "subdir": "linux-64", + "timestamp": 1535497919455, + "version": "2.3.1" + }, + "fabric-2.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=1.1", + "invoke >=1.1,<2.0", + "paramiko >=2.4", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d32b473f63b1fad23214405c3dab3e36", + "name": "fabric", + "sha256": "d2e8ac9adaff7fec809fef178dff4c0e5769e393bc077f8bf93c1e97da1d7947", + "size": 60745, + "subdir": "linux-64", + "timestamp": 1539475570762, + "version": "2.4.0" + }, + "fabric-2.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.1", + "invoke >=1.1,<2.0", + "paramiko >=2.4", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8b3b8e84f0d2ca63314cd3c4ea7cbf66", + "name": "fabric", + "sha256": "4acb34bde1dd1053637c1f679db4cb591a1fab4356da2ca64fb0708f50f718d1", + "size": 61790, + "subdir": "linux-64", + "timestamp": 1539475614173, + "version": "2.4.0" + }, + "fabric-2.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=1.1", + "invoke >=1.1,<2.0", + "paramiko >=2.4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e18afa0f3968b07e947625b1afc00831", + "name": "fabric", + "sha256": "0aaca454957315ada1cfbbc7809a8c58a5971066ba6e2d5d7a1da749c225fcce", + "size": 61904, + "subdir": "linux-64", + "timestamp": 1539475612961, + "version": "2.4.0" + }, + "fabric-2.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "df1513a9a0a8087158aa237d4817dcab", + "name": "fabric", + "sha256": "c4bced3b3293a054d507a5ebc84f4dee6924e21062f8f9985a87277e176d423c", + "size": 64869, + "subdir": "linux-64", + "timestamp": 1569361112841, + "version": "2.5.0" + }, + "fabric-2.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "29869ae17992f522a7415d6a2c9db34c", + "name": "fabric", + "sha256": "f0958fda49589fe69108c3b49740a38b5cba47ac08b27f11fa4cecbef0b7956c", + "size": 65974, + "subdir": "linux-64", + "timestamp": 1569361132801, + "version": "2.5.0" + }, + "fabric-2.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "438ea44ab3dc6a47c5d84143fd520559", + "name": "fabric", + "sha256": "b9edeea245a65607771221a9d83fcadeff962e07092a47dc982269b8791499c4", + "size": 66051, + "subdir": "linux-64", + "timestamp": 1569361249341, + "version": "2.5.0" + }, + "fabric-2.5.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ab3c89acda73f26c86bcff8adbd83070", + "name": "fabric", + "sha256": "469db4dbd39ce5210f3328396243560e5f9539e5288a9d3864888aa33c4dd1fd", + "size": 64045, + "subdir": "linux-64", + "timestamp": 1574177714500, + "version": "2.5.0" + }, + "fabric-2.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8d0509a98c9f0a61c8555888c83d8d5e", + "name": "fabric", + "sha256": "7f187e16f17568a33d0c143c8d6fefec53a34caeff6698351781818013f1fb5d", + "size": 65961, + "subdir": "linux-64", + "timestamp": 1640811995074, + "version": "2.6.0" + }, + "fabric-2.6.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5160a64ec59af12cafdaac0d67930a1b", + "name": "fabric", + "sha256": "feb73df7966ec067fae3f5f241d89306534461b722f3eb9a191690eb9c8d4510", + "size": 78154, + "subdir": "linux-64", + "timestamp": 1676852229434, + "version": "2.6.0" + }, + "fabric-2.6.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b81ccb38ec175486082469c87ed4adfd", + "name": "fabric", + "sha256": "4d0d0307ea442bbe65b7c18b3b842799e371430fb022f857ed0763cd5f5b3d52", + "size": 65553, + "subdir": "linux-64", + "timestamp": 1611082275585, + "version": "2.6.0" + }, + "fabric-2.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5fe57e61954283ca824a09863a8e28ed", + "name": "fabric", + "sha256": "30d36dd914f741c2b94007029f8b6bcff92b5ffd36b006d0ef37f7907fe1be96", + "size": 65601, + "subdir": "linux-64", + "timestamp": 1611081499825, + "version": "2.6.0" + }, + "fabric-2.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "99e083cfa80eb5db1f7261ada9c9c0f7", + "name": "fabric", + "sha256": "145bd7957b5d5285a0ee7d39d1041553b2caa68ee7b43fa74aad35f9a5156482", + "size": 65644, + "subdir": "linux-64", + "timestamp": 1611082266940, + "version": "2.6.0" + }, + "fabric-2.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7d5e583daeadaa943a49b841efc8bb7a", + "name": "fabric", + "sha256": "f99256e156cc182e577c3a8397fce5157f0cb4c7dd3446059c4ae869d37f387f", + "size": 68016, + "subdir": "linux-64", + "timestamp": 1614254413728, + "version": "2.6.0" + }, + "fabric3-1.13.1.post1-py27hc4c2163_0.tar.bz2": { + "build": "py27hc4c2163_0", + "build_number": 0, + "depends": [ + "paramiko >=1.17.2,<2.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "54d332a36d53767ed550c929eac3a1d2", + "name": "fabric3", + "sha256": "a3f585924776083c87b7c5a853e89567a8fb4a7eeb8c85a9728f1d06ae3672a8", + "size": 119990, + "subdir": "linux-64", + "timestamp": 1511041304482, + "version": "1.13.1.post1" + }, + "fabric3-1.13.1.post1-py35h70d5be3_0.tar.bz2": { + "build": "py35h70d5be3_0", + "build_number": 0, + "depends": [ + "paramiko >=1.17.2,<2.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b1eea8cd883fe80f9e7514c6c75f718a", + "name": "fabric3", + "sha256": "7ad825822cf3797f87a7c79b7642ba0814a04988fd4378a389a37cd9a2ceade9", + "size": 121600, + "subdir": "linux-64", + "timestamp": 1511041310608, + "version": "1.13.1.post1" + }, + "fabric3-1.13.1.post1-py36hde4fd86_0.tar.bz2": { + "build": "py36hde4fd86_0", + "build_number": 0, + "depends": [ + "paramiko >=1.17.2,<2.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c2b0574f54b60db75051906c6492f926", + "name": "fabric3", + "sha256": "a55534dcef6b1fc4806cca5bf9ef59c7498816284a14e87045516b77925cba9e", + "size": 120963, + "subdir": "linux-64", + "timestamp": 1511041308980, + "version": "1.13.1.post1" + }, + "fabric3-1.14.post1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "paramiko >=1.17.2,<2.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "50d782b8003a86fa6d6cbfde730dc524", + "name": "fabric3", + "sha256": "235096bb5c23f80659b8a9089015e1453863af0cde069f85d02046717dd35a18", + "size": 120387, + "subdir": "linux-64", + "timestamp": 1522787079036, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "paramiko >=2.0,<3.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f1fce9eee7e36e5e2b6adcf11a4981d7", + "name": "fabric3", + "sha256": "8abd61b400d75c66007b516b7cd2f0052f4d55d19a6bc7353c58ae8b9ef126e3", + "size": 120269, + "subdir": "linux-64", + "timestamp": 1530876317107, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "paramiko >=2.0,<3.0", + "python >=3.10,<3.11.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c1180c967b5858113dd9732abc22187e", + "name": "fabric3", + "sha256": "4785fdf61e22f5427e1b9088c151f34dc70fe62e6c3c3400d7eb31c6fe77e67a", + "size": 123344, + "subdir": "linux-64", + "timestamp": 1640789856968, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "paramiko >=1.17.2,<2.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "bb36fe615a9de75d24da7d097077b90a", + "name": "fabric3", + "sha256": "97eda759774cf242ac36fb9149853410007e29706fcf9718cfa93c82d42c75f5", + "size": 121889, + "subdir": "linux-64", + "timestamp": 1522787074989, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "paramiko >=1.17.2,<2.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d6d612e124b12c688907c48d7e1a7b9c", + "name": "fabric3", + "sha256": "caa64ba35cee71af0de926c1b5207b1a8bbc18a4d93c942f2ecf0d8a3388f08e", + "size": 121430, + "subdir": "linux-64", + "timestamp": 1522787083891, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "paramiko >=2.0,<3.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "00b70d04af979350c174a79986c12530", + "name": "fabric3", + "sha256": "3c10eca676d3419616abf17ac026a292c17177142516924569ea05e0b3801c13", + "size": 121296, + "subdir": "linux-64", + "timestamp": 1530876260481, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "paramiko >=2.0,<3.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "717ea8b1154a34c0a5ff6eb9a7a9fbcb", + "name": "fabric3", + "sha256": "0040377b89cd59bec2e6e21ff5aa4043f66d5bf9021d42fadcec1b8232c0c7a9", + "size": 122700, + "subdir": "linux-64", + "timestamp": 1614254405656, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "paramiko >=2.0,<3.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4f8a1b0c93c1dc8f7448d8c9f44d4d00", + "name": "fabric3", + "sha256": "9000370ebc63c570a6e8d855e8c79182528d55a1a758391baad0d794994218ae", + "size": 121408, + "subdir": "linux-64", + "timestamp": 1530876289599, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "paramiko >=2.0,<3.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9144cd109a26cf91c6501ae0bafcf317", + "name": "fabric3", + "sha256": "ba8c5ecf71dee44bec1a1765c55f90174b552443ee937aa214b1543a45eddcaa", + "size": 122802, + "subdir": "linux-64", + "timestamp": 1614254395773, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "paramiko >=2.0,<3.0", + "python >=3.8,<3.9.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "99795714229bf699b1e5f3170ea4a5d1", + "name": "fabric3", + "sha256": "468988694fe3bf95417dc169b3002e6ca8875eb811929beb71a37a7e386df82d", + "size": 122013, + "subdir": "linux-64", + "timestamp": 1574177733705, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "paramiko >=2.0,<3.0", + "python >=3.8,<3.9.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "dbef3d50792169c68013b4dd98ae210a", + "name": "fabric3", + "sha256": "c183433af3b52cfc9c18266f3bf9e7bd9a65bfe489ddf69e44406ffba5fef80d", + "size": 122935, + "subdir": "linux-64", + "timestamp": 1614254402071, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "paramiko >=2.0,<3.0", + "python >=3.9,<3.10.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "31d0ba25a7e1f9cc78f9c601682dbaa4", + "name": "fabric3", + "sha256": "0a110859641a802e1fecb291186b1122e0ce8f4ecf129b07b293a939d4badb00", + "size": 123326, + "subdir": "linux-64", + "timestamp": 1614254399507, + "version": "1.14.post1" + }, + "factory_boy-2.10.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4166b11d05417ab8f6b1d6882bb14494", + "name": "factory_boy", + "sha256": "9ca448d948c202db2936cb6476e0e60ef02d7fb975a450de743f2a0fa199ecb8", + "size": 54670, + "subdir": "linux-64", + "timestamp": 1520882460120, + "version": "2.10.0" + }, + "factory_boy-2.10.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b37745fd5e509f79d6814816f7923b5f", + "name": "factory_boy", + "sha256": "fac40125a397cd07303efa6011068bb368cb7ae1fc24ac3f357a46f74f653c20", + "size": 56567, + "subdir": "linux-64", + "timestamp": 1520882510960, + "version": "2.10.0" + }, + "factory_boy-2.10.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02a79b68d23fccc79b23146e6e662fac", + "name": "factory_boy", + "sha256": "24160d776e55c31cf1a42fe8d562497ed825a664c737a6dacaa3d31f9b05028f", + "size": 56531, + "subdir": "linux-64", + "timestamp": 1520882442744, + "version": "2.10.0" + }, + "factory_boy-2.11.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c4cf6cf3bb68f7d849e4ddb26417475", + "name": "factory_boy", + "sha256": "d3a544306f0650d590745884eabb2668b556f0e014e9f65f595312b6ce01a527", + "size": 56507, + "subdir": "linux-64", + "timestamp": 1526940384857, + "version": "2.11.1" + }, + "factory_boy-2.11.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d9cc4d857a65430c0e446b31e3c4bdb", + "name": "factory_boy", + "sha256": "2f1b499ec7026be36fad76e62ad7d1b1a642cfc4d617fc9552a123ba738a5457", + "size": 58430, + "subdir": "linux-64", + "timestamp": 1526940400136, + "version": "2.11.1" + }, + "factory_boy-2.11.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff36634b540f428cf403f177bfacd8ce", + "name": "factory_boy", + "sha256": "60a3373afe62187430350c1ba16fc003c30dbe21480dadc850514af2f9bce757", + "size": 58264, + "subdir": "linux-64", + "timestamp": 1526940366757, + "version": "2.11.1" + }, + "factory_boy-2.11.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a51819bb753b59903ba2ecad2d54ecaf", + "name": "factory_boy", + "sha256": "a34d38f4a12e9f6b8ea837c052be82f4dd6ab58e1484d3d74dd348bab575bd7b", + "size": 58436, + "subdir": "linux-64", + "timestamp": 1530876348285, + "version": "2.11.1" + }, + "factory_boy-2.12.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f591d0a53854ff4e9f7bf182deb6d61a", + "name": "factory_boy", + "sha256": "81d71423ae253b59bc49fed29619492762d05a21e564a46059574afa298fd264", + "size": 59344, + "subdir": "linux-64", + "timestamp": 1559065488486, + "version": "2.12.0" + }, + "factory_boy-2.12.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4dac610bae25172bdb55ba10d0974a9c", + "name": "factory_boy", + "sha256": "88bc2ed9fb0d8774a7b60326665fa72f35fa729ba10b50ab2de8789e9599a402", + "size": 61016, + "subdir": "linux-64", + "timestamp": 1559065505854, + "version": "2.12.0" + }, + "factory_boy-2.12.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "faker >=0.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e22da348697a36720534663df48d003e", + "name": "factory_boy", + "sha256": "97879b59ccbe48870b166a82e5d4dd8fbe8bb1e26d1594896f1bc3dc8091bcd3", + "size": 61192, + "subdir": "linux-64", + "timestamp": 1588560267918, + "version": "2.12.0" + }, + "factory_boy-2.12.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c76aade1a2bcde6ddb027c78d166aa47", + "name": "factory_boy", + "sha256": "8a3a64ebd332cf4459344581cd2698fc01daa3ac8d8ff79bb4e39ad464332dd2", + "size": 61196, + "subdir": "linux-64", + "timestamp": 1559065468966, + "version": "2.12.0" + }, + "factory_boy-2.12.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "faker >=0.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "519050c2e5d72bd46f653bdc5a01a8d5", + "name": "factory_boy", + "sha256": "c15eae39fea10316ce8206bac025711226d368fc784c2fdc3bcf4924042edada", + "size": 61316, + "subdir": "linux-64", + "timestamp": 1588560268890, + "version": "2.12.0" + }, + "factory_boy-2.12.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "faker >=0.7.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a662d897e2369afa656633ec028f2a7", + "name": "factory_boy", + "sha256": "2ea98495753bb3a4597c7baa06cd351385fac8a93eea1760be8fb206bd07513a", + "size": 61632, + "subdir": "linux-64", + "timestamp": 1588560262624, + "version": "2.12.0" + }, + "factory_boy-2.9.2-py27h5e84f35_0.tar.bz2": { + "build": "py27h5e84f35_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98086fc9875c77cd37bee8847c9ea4b2", + "name": "factory_boy", + "sha256": "efe4f3fd804dd1f4ff70961e7913deef09a788029bb1ee1a64d6dd93d5ee7e40", + "size": 53895, + "subdir": "linux-64", + "timestamp": 1508957382752, + "version": "2.9.2" + }, + "factory_boy-2.9.2-py35hf635695_0.tar.bz2": { + "build": "py35hf635695_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d1a2bc341bbe9e081c4945bbdaef2bc", + "name": "factory_boy", + "sha256": "e2fe07c022d66a112fcc5ee554dce32421e3e52df5c347f2f43b9d7974df9891", + "size": 55845, + "subdir": "linux-64", + "timestamp": 1508957381351, + "version": "2.9.2" + }, + "factory_boy-2.9.2-py36h7ef2604_0.tar.bz2": { + "build": "py36h7ef2604_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "688e2c7b3ca707abcf15f744466ee0cb", + "name": "factory_boy", + "sha256": "290c24b5ce995d16bc850c86113fd2df682a7f90c28bd69036b5dfe4c167142d", + "size": 55793, + "subdir": "linux-64", + "timestamp": 1508957385950, + "version": "2.9.2" + }, + "factory_boy-3.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba02b5a26682ed95709d951d172aab1c", + "name": "factory_boy", + "sha256": "7d9e38cc68c95c04e895cdf420699391c2b93555c65638e0a9922420b8650bab", + "size": 60371, + "subdir": "linux-64", + "timestamp": 1598412480310, + "version": "3.0.1" + }, + "factory_boy-3.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bcac7dea9e53f7710b270f27c0c17722", + "name": "factory_boy", + "sha256": "32fbe5c9a9fba27b9d812b433240e5d68fde769530f4800b1615595d44acc8c8", + "size": 60593, + "subdir": "linux-64", + "timestamp": 1598412523613, + "version": "3.0.1" + }, + "factory_boy-3.0.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b35e7e948a2ab3e0002076013f05ecb", + "name": "factory_boy", + "sha256": "50161636f8ce877e9b70e0cbed0a24b18834439f318574b982e6cc325eec8f0f", + "size": 60936, + "subdir": "linux-64", + "timestamp": 1598412492549, + "version": "3.0.1" + }, + "factory_boy-3.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e997cbabae940fe8b20989a273a8c460", + "name": "factory_boy", + "sha256": "e0d60427f9558482ad4b1e7830c579cebc4350b6ed130857859c6b60cca6586d", + "size": 57869, + "subdir": "linux-64", + "timestamp": 1601911062308, + "version": "3.1.0" + }, + "factory_boy-3.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b352bd6965db6f06ae7b3b9d2bc14638", + "name": "factory_boy", + "sha256": "ed77da99a5bd35e885afe3e2d1b363f2d2a5ff49e487f96e9f9e1741ee903fa0", + "size": 58038, + "subdir": "linux-64", + "timestamp": 1601911059102, + "version": "3.1.0" + }, + "factory_boy-3.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c5fa2e24938e62326688582977a7fe4", + "name": "factory_boy", + "sha256": "4832f802c95d29f4687781ebdeaa659ca01e351da5246f2b15c8b748243a3c62", + "size": 58503, + "subdir": "linux-64", + "timestamp": 1601911091952, + "version": "3.1.0" + }, + "factory_boy-3.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45c7e7ca9a634be28dcc8dc3eacc8f5b", + "name": "factory_boy", + "sha256": "11fa5c7d9ef1f997c5154bcab89c3d914f849bdf005f5f9ff1731f4e4d6c6b1f", + "size": 58564, + "subdir": "linux-64", + "timestamp": 1640789874713, + "version": "3.2.0" + }, + "factory_boy-3.2.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2985096da1d1cb3946c2f7e274b7e918", + "name": "factory_boy", + "sha256": "109b9b7825c67d032b410c7560698cdca662202ef7b3d9d65054cea203e14eeb", + "size": 75888, + "subdir": "linux-64", + "timestamp": 1676852259394, + "version": "3.2.0" + }, + "factory_boy-3.2.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c0b01ed4b1fdd15bfb8f79105f0b383", + "name": "factory_boy", + "sha256": "0d34eafb9a447763de3edf732977b81cf2b953abaa1c7642bd16725bc0d3d914", + "size": 57487, + "subdir": "linux-64", + "timestamp": 1609265824664, + "version": "3.2.0" + }, + "factory_boy-3.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b04342533dc7a6ccc5967391a62e23f0", + "name": "factory_boy", + "sha256": "c0dfeaab4192ff383b922b5f77f4e056fad1d4c870feb7cd00d2a857cf9c04f5", + "size": 57690, + "subdir": "linux-64", + "timestamp": 1609265822070, + "version": "3.2.0" + }, + "factory_boy-3.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b49a44eec16209900dd5b24575ccee23", + "name": "factory_boy", + "sha256": "888f1a56b236b0d4381896a961961dd2cfd5f8f33c72ff6e577f1c02fe4d6bd2", + "size": 58022, + "subdir": "linux-64", + "timestamp": 1609265839074, + "version": "3.2.0" + }, + "factory_boy-3.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f4b757cda6fb8855affc4c95649269a", + "name": "factory_boy", + "sha256": "debdb4dd2e5efd1a370fbd24b22880e1fd6c89c572af3932178ba1cabaa00f81", + "size": 58104, + "subdir": "linux-64", + "timestamp": 1609265837458, + "version": "3.2.0" + }, + "faker-0.8.13-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode ==1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fff9930a1118ac8dcf31a02b2e4a78d0", + "name": "faker", + "sha256": "5846e6269edcf0ff29e88dae815e15b26efcd699de9135512cf8d47e3482a324", + "size": 1400737, + "subdir": "linux-64", + "timestamp": 1524092830613, + "version": "0.8.13" + }, + "faker-0.8.13-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode ==1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b70997b647a460f463dc69b936b056d", + "name": "faker", + "sha256": "9730a71169b5469437bdf3a025b2374d2c0d6f70bef06217554edf7df715c9dd", + "size": 1229438, + "subdir": "linux-64", + "timestamp": 1524092889403, + "version": "0.8.13" + }, + "faker-0.8.13-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode ==1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "864be432d496cf43b660b432a2c4b06c", + "name": "faker", + "sha256": "c208237ff2ff76479f4ad6ae8dd2a9688630c26243aeb4c6fa2b1044948f20f0", + "size": 1228003, + "subdir": "linux-64", + "timestamp": 1524092858491, + "version": "0.8.13" + }, + "faker-0.8.15-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff8d74ca0eb71a91f63e3647518c5290", + "name": "faker", + "sha256": "7ae90d625964ea0cb8ebb109bd553b3f642b676ba02ee6bac7aa3e53c7ff9441", + "size": 1401171, + "subdir": "linux-64", + "timestamp": 1526939821912, + "version": "0.8.15" + }, + "faker-0.8.15-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21dc80eb65b854bdd2a96929e3193e59", + "name": "faker", + "sha256": "891574a67900016d409b5b6e5189c8284115b10da29a401bf2368909b24143da", + "size": 1250450, + "subdir": "linux-64", + "timestamp": 1526939925128, + "version": "0.8.15" + }, + "faker-0.8.15-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b544c38438c795703a512bfcb4e9b177", + "name": "faker", + "sha256": "13abcc72395976c168829bc995fa090a1ce5091cc39a9f3f2530331998895cba", + "size": 1241993, + "subdir": "linux-64", + "timestamp": 1526939784279, + "version": "0.8.15" + }, + "faker-0.8.16-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45009fb083a3a72f538cabac04f85421", + "name": "faker", + "sha256": "64366cc82e4de27eafc55628015a7bcc1e459371447f1a0e2ed4701f391f04ab", + "size": 1405588, + "subdir": "linux-64", + "timestamp": 1529443803730, + "version": "0.8.16" + }, + "faker-0.8.16-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87a2cfaf04f930dc68037542cff01c76", + "name": "faker", + "sha256": "5db503665f0e5a2b17c9c1a73d87530219a3227db87a2b46fec5a710a037f927", + "size": 1250726, + "subdir": "linux-64", + "timestamp": 1529443850334, + "version": "0.8.16" + }, + "faker-0.8.16-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da5d7b07c61d571bc6c4d81caa761aa4", + "name": "faker", + "sha256": "bbe2ad05b6e3dc3480d284a78607032e345b915061d4759066e876f83db4aa15", + "size": 1242203, + "subdir": "linux-64", + "timestamp": 1529443663560, + "version": "0.8.16" + }, + "faker-0.8.16-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ed859740be3ea713db313fd6a96edd1e", + "name": "faker", + "sha256": "7b383c0e7c56bb47d1dd671447adfe3b00c4364e01d0516d1bdcf9daabff32f5", + "size": 1169811, + "subdir": "linux-64", + "timestamp": 1530727749702, + "version": "0.8.16" + }, + "faker-0.8.6-py27hd0256cd_0.tar.bz2": { + "build": "py27hd0256cd_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six", + "text-unidecode" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7aee811a23437d40155bd72eab6b02f7", + "name": "faker", + "sha256": "9f5786f2be45b60307feeb550400d8a5b8f02f43b879506ff1bbb281bf2c26a9", + "size": 1250692, + "subdir": "linux-64", + "timestamp": 1508956457239, + "version": "0.8.6" + }, + "faker-0.8.6-py35h59ce941_0.tar.bz2": { + "build": "py35h59ce941_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.4", + "six", + "text-unidecode" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1531105ad64b0e030a932554ab0a53bb", + "name": "faker", + "sha256": "c1d61fa23bcf1e9ac9fb3c159018a150728792202453e2c097bab47bda3c04e4", + "size": 1109743, + "subdir": "linux-64", + "timestamp": 1508956507666, + "version": "0.8.6" + }, + "faker-0.8.6-py36h14e001f_0.tar.bz2": { + "build": "py36h14e001f_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six", + "text-unidecode" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "517c4accb1a2dab5376f5aac32f4a4da", + "name": "faker", + "sha256": "e989945801afee4e463aa817b10cb617fc03b98dbf823fe656560f807d96706c", + "size": 1107370, + "subdir": "linux-64", + "timestamp": 1508956528542, + "version": "0.8.6" + }, + "faker-0.9.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6557c72920e4885c39b829f3aed3ec8", + "name": "faker", + "sha256": "6b4fadfee57cceaaa104289756e363b95ab5c0613849a15c3991b697464d8f1e", + "size": 1413036, + "subdir": "linux-64", + "timestamp": 1535510061588, + "version": "0.9.0" + }, + "faker-0.9.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e6c9dd0bb68ac492dfcb98b48853aef", + "name": "faker", + "sha256": "a1f66bd2c369bffab287d1f0439c8efaacc0920fb5588b22d0ad23bced443b81", + "size": 1254148, + "subdir": "linux-64", + "timestamp": 1535510092897, + "version": "0.9.0" + }, + "faker-0.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d760ec34cb0c03b59376346ef99894f0", + "name": "faker", + "sha256": "91377aeb8b690cddd40629d12c63ae7b476b5bd432cbe2762dec91c8491bbc32", + "size": 1250022, + "subdir": "linux-64", + "timestamp": 1535510037267, + "version": "0.9.0" + }, + "faker-0.9.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3bd012e7c1e063d965bbdf03c6e49af3", + "name": "faker", + "sha256": "754ad3ee7ab1fdede7e9e15a5a23618297ce843d986316a521e314f253e353f4", + "size": 1175232, + "subdir": "linux-64", + "timestamp": 1535510069022, + "version": "0.9.0" + }, + "faker-0.9.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15e71cd23929770089dd094f291eb915", + "name": "faker", + "sha256": "ae9575f37e94a383d814c950e14a6440f442fa281831079f43e4439265b905b9", + "size": 1438311, + "subdir": "linux-64", + "timestamp": 1538360131027, + "version": "0.9.1" + }, + "faker-0.9.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c29444555565063085b33021d7f0e859", + "name": "faker", + "sha256": "7d126648ac2f0621d8e38024adab53ec2182f60878d4ba3a211a96d9f746030f", + "size": 1275181, + "subdir": "linux-64", + "timestamp": 1538360171507, + "version": "0.9.1" + }, + "faker-0.9.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "966fa9dbed856f21fc43406daf96eb3f", + "name": "faker", + "sha256": "14e137084925238f815fa33cf43ccef2d93571740d0f77c72210fd9a76fb97e8", + "size": 1208166, + "subdir": "linux-64", + "timestamp": 1538360151068, + "version": "0.9.1" + }, + "faker-0.9.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a24cb05a5d7c4ac851624319ef906586", + "name": "faker", + "sha256": "dcd6730e38892447b6b905e30f55da453f32d20be558ca4da37b00af323e9872", + "size": 1454568, + "subdir": "linux-64", + "timestamp": 1539721341517, + "version": "0.9.2" + }, + "faker-0.9.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d5ab391c0d96391d5c7ef2193c3e8e77", + "name": "faker", + "sha256": "029daa6ae3cdb03e46cbd67f8a1861f570db4a1ad1d2aa7e2ead279630568e29", + "size": 1289348, + "subdir": "linux-64", + "timestamp": 1539721382148, + "version": "0.9.2" + }, + "faker-0.9.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c12bcd8833604566098b27ab8ab44c1", + "name": "faker", + "sha256": "c0962a44bd745a8a378495791d9f240973bae7603b1b0086dadb0c8a00c00ccc", + "size": 1220779, + "subdir": "linux-64", + "timestamp": 1539721356887, + "version": "0.9.2" + }, + "faker-1.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7d87ce1660484161df8d71bc61d186a4", + "name": "faker", + "sha256": "6001aedda6b28a95c21954d48e8134d33fff9399908e5b0e0498a768bb4b6d3f", + "size": 1611337, + "subdir": "linux-64", + "timestamp": 1542387769634, + "version": "1.0.0" + }, + "faker-1.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db814316198f58a81812396c68f124ae", + "name": "faker", + "sha256": "86e2f70df8591b35d2e8b2d76d1a3b931db340c450b32db5ee621a0ddf3622c1", + "size": 1495501, + "subdir": "linux-64", + "timestamp": 1542387779888, + "version": "1.0.0" + }, + "faker-1.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7dcc830b17a9d069c07380c71d7091c7", + "name": "faker", + "sha256": "1aaab75bc874520894ad6beb42b8b1f70ee6e1c610041db51b45afd2637ecb36", + "size": 1423147, + "subdir": "linux-64", + "timestamp": 1542387758300, + "version": "1.0.0" + }, + "faker-1.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c7ac26597d65d1cbc7670288a4090190", + "name": "faker", + "sha256": "86835b3d5f91d63be9812ffc26c3aac19ce44154cb82754a21ed1b0ee433a26b", + "size": 1612901, + "subdir": "linux-64", + "timestamp": 1545127578624, + "version": "1.0.1" + }, + "faker-1.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e8c51b7968fb02c6652cecdcf614626", + "name": "faker", + "sha256": "a46707eb3467811ecb685f1aeff76382d8567f3ea0f6ec74a5d27c538ee3191b", + "size": 1501732, + "subdir": "linux-64", + "timestamp": 1545127555797, + "version": "1.0.1" + }, + "faker-1.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7a760afedccffedafd40f03467ac9414", + "name": "faker", + "sha256": "0a03ddf33b222691fc18fcc5de5323190c9a4f4693ea3a6627413e89c4ed3f33", + "size": 1422973, + "subdir": "linux-64", + "timestamp": 1545147399051, + "version": "1.0.1" + }, + "faker-1.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "20a56ad2290724e235920531862d6028", + "name": "faker", + "sha256": "e9a2c923c4d8b1e18176a2fdbbebebf260f104701092e836690c1abe872ccba2", + "size": 1631396, + "subdir": "linux-64", + "timestamp": 1550269338340, + "version": "1.0.2" + }, + "faker-1.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ed2d906500e10347b470e476b5fcdcc", + "name": "faker", + "sha256": "bb51b1e4688fa369357bc960df43f9db1f5c00f6e6636f9588e807aee1a8f469", + "size": 1506914, + "subdir": "linux-64", + "timestamp": 1550269350303, + "version": "1.0.2" + }, + "faker-1.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60e652b915f5b93ccb7255cbd2b98f0e", + "name": "faker", + "sha256": "c86130f97cfc82e061a98ba78fa02bb7787ae40d23ee2f805742467bd6b84da1", + "size": 1433701, + "subdir": "linux-64", + "timestamp": 1550269290281, + "version": "1.0.2" + }, + "faker-1.0.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a2ae2e729f52e785190e4a02a6956b92", + "name": "faker", + "sha256": "844d1920bfa82c9c128e35e22f592bb8b3c691fc4b2215033ac556e3542cc3ef", + "size": 1667349, + "subdir": "linux-64", + "timestamp": 1556081075233, + "version": "1.0.5" + }, + "faker-1.0.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dfebc97319e048159ccaf15e60d1c332", + "name": "faker", + "sha256": "e69ab5e7012d5a4e6e594bedc86a1e4ff3df2cf296f93b0fdeae75b6c5d02964", + "size": 1551785, + "subdir": "linux-64", + "timestamp": 1556081095526, + "version": "1.0.5" + }, + "faker-1.0.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e1ffd3a2b5f223a7c0ae73037feed205", + "name": "faker", + "sha256": "a33d8361747d0837373b73742da975fb5ee3d04c49c30fb5f2e94d9807880eab", + "size": 1465936, + "subdir": "linux-64", + "timestamp": 1556080924866, + "version": "1.0.5" + }, + "faker-1.0.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a41271d15fd53140549dc896b9c285bd", + "name": "faker", + "sha256": "a1db896d798432ece5ea6d6ccdc621b542b0db9a9dfe3a227a9cc7e3e834e1c4", + "size": 1695343, + "subdir": "linux-64", + "timestamp": 1559064414833, + "version": "1.0.7" + }, + "faker-1.0.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7cb8be98aabf4d08c4df080322d269c2", + "name": "faker", + "sha256": "477c892434959d1d9286ff3addbcfbcd68c060930198c04241a708d491ed8aa3", + "size": 1568413, + "subdir": "linux-64", + "timestamp": 1559064528812, + "version": "1.0.7" + }, + "faker-1.0.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbe1a5b9735e7ff028793825e097dc70", + "name": "faker", + "sha256": "6138722da00ac88edb8d01a7f86632b7e39bdf7084c9cee7b571778621eb2d16", + "size": 1490346, + "subdir": "linux-64", + "timestamp": 1559064408900, + "version": "1.0.7" + }, + "faker-2.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c40e132722d12e84a48fe1f711a6c3d7", + "name": "faker", + "sha256": "b88f1fe336ed713b754aec2ee98da799a74dd0211ceb846b1054d68ef31ed768", + "size": 1701882, + "subdir": "linux-64", + "timestamp": 1564674574823, + "version": "2.0.0" + }, + "faker-2.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e7265060b946a8fdfac33470c4a057bc", + "name": "faker", + "sha256": "36c047e3edead64c57c6489c02f4bfbe482a025a3be38629dd01e37f7986531f", + "size": 1581173, + "subdir": "linux-64", + "timestamp": 1564674598697, + "version": "2.0.0" + }, + "faker-2.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "baa377a161642769d1a94a21c0950634", + "name": "faker", + "sha256": "eaec523819300b9c2d3adb8785558cf9a0742f5ff0bee1b1d30ee67bffa623aa", + "size": 1492553, + "subdir": "linux-64", + "timestamp": 1564674575092, + "version": "2.0.0" + }, + "faker-2.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e7e30f9f6ec44d2eee0228a9e3ab3ff", + "name": "faker", + "sha256": "916671926e3ef2b39b5964544af888f22118a467b3a91f7a8fd94c9eb904d300", + "size": 1694683, + "subdir": "linux-64", + "timestamp": 1569419129747, + "version": "2.0.2" + }, + "faker-2.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca0608fa7cfbd6852049b9b98e744016", + "name": "faker", + "sha256": "2c8e5281d9a30338682e1f90aff073d2dc9985040876c868f4233dc9f4f94342", + "size": 1577643, + "subdir": "linux-64", + "timestamp": 1569419122208, + "version": "2.0.2" + }, + "faker-2.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "499eb38503d5e9a1039763735942d998", + "name": "faker", + "sha256": "6ecdfbcfb5289b510016d7ad05b6e563bb3d1caed7fc6d24db1813f6453e1586", + "size": 1497360, + "subdir": "linux-64", + "timestamp": 1569419120779, + "version": "2.0.2" + }, + "faker-2.0.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a75e7e8b6ce89a79a3bf9fbd68e6b5c6", + "name": "faker", + "sha256": "9a19a15b0974c3090578daa94aa5f0550a5a1ed3b906e3eb3e34a16f7340a9c5", + "size": 1858306, + "subdir": "linux-64", + "timestamp": 1573963518900, + "version": "2.0.4" + }, + "faker-2.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18231f996ffcd9b64c439e1de884735c", + "name": "faker", + "sha256": "03c000789b8f03273bc00f5159755cd234ae926474d2f18a57b76bdaa9cecb79", + "size": 1720304, + "subdir": "linux-64", + "timestamp": 1573963454799, + "version": "2.0.4" + }, + "faker-2.0.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca7b03fc9982943015f91deb614659d9", + "name": "faker", + "sha256": "f31043bbf0063e90542465aa1549b7085cf0072b2ea29b036ec7772a277adcdc", + "size": 1633828, + "subdir": "linux-64", + "timestamp": 1573963509837, + "version": "2.0.4" + }, + "faker-2.0.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c57e88c9415df2478c38997b6c6ce1a9", + "name": "faker", + "sha256": "fe48a82639d1fdea9f0416330cc7e73024b053ee0b82d13522916853b282cfbb", + "size": 1635325, + "subdir": "linux-64", + "timestamp": 1574251298577, + "version": "2.0.4" + }, + "faker-3.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "69457d07cc4379522228950c03f2cde2", + "name": "faker", + "sha256": "4f954948b5cf519efb809497dd8ec6067bdf12a6d2c36715e380d5648c0d1100", + "size": 1878941, + "subdir": "linux-64", + "timestamp": 1576689279588, + "version": "3.0.0" + }, + "faker-3.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9e50903a63e718cf336290e855f3e93", + "name": "faker", + "sha256": "1dcffe29d17f20b2b0324ff319153d2693ca0d8fb46c815547cca2d6e9b03bfd", + "size": 1727341, + "subdir": "linux-64", + "timestamp": 1576689276661, + "version": "3.0.0" + }, + "faker-3.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bea2cbd675fa548e9d7d338cf1958d8e", + "name": "faker", + "sha256": "3dfe32d1fe0f92f3dcc842c5ffcf5333a21a0953aa1c9c56e7ed1750c9dada0b", + "size": 1649703, + "subdir": "linux-64", + "timestamp": 1576689275402, + "version": "3.0.0" + }, + "faker-4.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "151446944341d697d7e1a04190c3a09e", + "name": "faker", + "sha256": "95444b40e788400af24de5d414fbbf2f5d79c85f5ccd88856506a1287345e4da", + "size": 1817320, + "subdir": "linux-64", + "timestamp": 1588474968267, + "version": "4.0.3" + }, + "faker-4.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "615b039b0f8490eaafc79cb8e7bdd29b", + "name": "faker", + "sha256": "e7eb814e182e25c31c8ca126c04ca8cc826f198cf5c9b5aaa816a4b56369ab37", + "size": 1733746, + "subdir": "linux-64", + "timestamp": 1588474968948, + "version": "4.0.3" + }, + "faker-4.0.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c9e8c4dfc08b0bd17fe0d421e14becd", + "name": "faker", + "sha256": "8cfa74f6c44f31d4e404fc7bbb9d00b0ee68b9df991330e989b1b0387e2327c5", + "size": 1738417, + "subdir": "linux-64", + "timestamp": 1588474978782, + "version": "4.0.3" + }, + "fast-histogram-0.3-py27h3010b51_0.tar.bz2": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "24b56d02b5c4b5a9e9cbc29050cbd4a0", + "name": "fast-histogram", + "sha256": "1b66ad360349bec7bbfc524da4a5ce7df2760697f14dd2d47c3d6639dd46cd21", + "size": 17275, + "subdir": "linux-64", + "timestamp": 1525294123069, + "version": "0.3" + }, + "fast-histogram-0.3-py35h3010b51_0.tar.bz2": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "68f891c91058a5019ce111d049b44f06", + "name": "fast-histogram", + "sha256": "e772788ce3bbdff177dbb56e3f9e4166c256374b799ee8095faaf0ea11d904f2", + "size": 17377, + "subdir": "linux-64", + "timestamp": 1525294122551, + "version": "0.3" + }, + "fast-histogram-0.3-py36h3010b51_0.tar.bz2": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "3ef801ecdf9383486fc3ad02e133a213", + "name": "fast-histogram", + "sha256": "3f22ea4c275b3d5afbfe47d1615f11ce8d56ad51168ee72ff0608337baf3be87", + "size": 17315, + "subdir": "linux-64", + "timestamp": 1525293360430, + "version": "0.3" + }, + "fast-histogram-0.4-py27h035aef0_0.tar.bz2": { + "build": "py27h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "098516d24529c43c327e39532efacc71", + "name": "fast-histogram", + "sha256": "e1ae7df30fce53f8d32bf51d6fe94691d65ce2319cca60e5d6311f8f34ddd2f2", + "size": 17237, + "subdir": "linux-64", + "timestamp": 1530890962389, + "version": "0.4" + }, + "fast-histogram-0.4-py27h3010b51_0.tar.bz2": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "ed0db470dd4750b8489ef2c20b3d11c9", + "name": "fast-histogram", + "sha256": "983e29171e282e9c35a8cb087b3b23ddd7241627603fc021ea6aed947b5b00ae", + "size": 17144, + "subdir": "linux-64", + "timestamp": 1526943674066, + "version": "0.4" + }, + "fast-histogram-0.4-py35h3010b51_0.tar.bz2": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "140a8cb39bd0abd7519b9ca0e5a794d2", + "name": "fast-histogram", + "sha256": "050d7741b737ba90d4dbd408e45e4011b52292961f0d827b0871e1429eafcc36", + "size": 17273, + "subdir": "linux-64", + "timestamp": 1526943624843, + "version": "0.4" + }, + "fast-histogram-0.4-py36h035aef0_0.tar.bz2": { + "build": "py36h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "28c7edb638c32aa852798a861d9b2e35", + "name": "fast-histogram", + "sha256": "16529ca9d349460c7129646d796f955afe1e9fedeb6c79c2044fa87c157d5843", + "size": 17250, + "subdir": "linux-64", + "timestamp": 1530890933923, + "version": "0.4" + }, + "fast-histogram-0.4-py36h3010b51_0.tar.bz2": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "161acf538c231f64112c347d05bb9caa", + "name": "fast-histogram", + "sha256": "178013d77ae2a0fafeeb78c5d95ce5709182134d2e6ace898d62bb32550ce8d6", + "size": 17184, + "subdir": "linux-64", + "timestamp": 1526943993536, + "version": "0.4" + }, + "fast-histogram-0.4-py37h035aef0_0.tar.bz2": { + "build": "py37h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "13cc9121e4a48e2642f7cd2e0957b7ad", + "name": "fast-histogram", + "sha256": "a638c28ed20b28a258de2e2927e9b77045132b4b348eed5e4e295fa9381edb2e", + "size": 17234, + "subdir": "linux-64", + "timestamp": 1530890904045, + "version": "0.4" + }, + "fast-histogram-0.5-py27hdd07704_1.tar.bz2": { + "build": "py27hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "231cee7edc651523261e68e4da1b71ce", + "name": "fast-histogram", + "sha256": "aa286605a4362a397a644b946bed42e71b5eaf2101e91d97c7071b41ff0b5524", + "size": 20315, + "subdir": "linux-64", + "timestamp": 1535424228546, + "version": "0.5" + }, + "fast-histogram-0.5-py35hdd07704_1.tar.bz2": { + "build": "py35hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "6dceb6145eb61cb35c31dd05a38c89cc", + "name": "fast-histogram", + "sha256": "d8fdcba37856de3acb0b5d241c0b4ef8e8b31a09ef10d1d2608e43e74ca2f3c5", + "size": 20388, + "subdir": "linux-64", + "timestamp": 1535424650350, + "version": "0.5" + }, + "fast-histogram-0.5-py36hdd07704_1.tar.bz2": { + "build": "py36hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "c87809309225073c4d6bd113fc941130", + "name": "fast-histogram", + "sha256": "3eaddb6bf9440878b0d6e890ccb2dd40221c78e7225c26b75c4c2c38789c7ddd", + "size": 20310, + "subdir": "linux-64", + "timestamp": 1535424631908, + "version": "0.5" + }, + "fast-histogram-0.5-py37hdd07704_1.tar.bz2": { + "build": "py37hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "43608347b3dda30ecb5e2bd87f8acb5f", + "name": "fast-histogram", + "sha256": "7439369daab84965b58f690b3152cdc264f64a18173bc1473fe8c24f524502ba", + "size": 20247, + "subdir": "linux-64", + "timestamp": 1535424775835, + "version": "0.5" + }, + "fast-histogram-0.7-py27hdd07704_1000.tar.bz2": { + "build": "py27hdd07704_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "35cde2f8170d802a7160a8acb6754723", + "name": "fast-histogram", + "sha256": "5306b5627b9b5a7ffc38a7e537a9c48f25f2f2b96ed3d3b7f00c57a834116fc9", + "size": 23439, + "subdir": "linux-64", + "timestamp": 1552376168634, + "version": "0.7" + }, + "fast-histogram-0.7-py36hdd07704_1000.tar.bz2": { + "build": "py36hdd07704_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "2453109ee6e881b0af65b58c7729217d", + "name": "fast-histogram", + "sha256": "5c672132c493f4771631f22e896e033e7e2eb84edfa4c5f9df27078fb05d2b02", + "size": 23496, + "subdir": "linux-64", + "timestamp": 1552376191866, + "version": "0.7" + }, + "fast-histogram-0.7-py37hdd07704_1000.tar.bz2": { + "build": "py37hdd07704_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "a97524c0a077bd5529bd746a9601186e", + "name": "fast-histogram", + "sha256": "419fb993ad0c7f70c2e629d07b8787eead3606d711e3131517c3d1bc6bba7af5", + "size": 23423, + "subdir": "linux-64", + "timestamp": 1552376142575, + "version": "0.7" + }, + "fast-histogram-0.7-py38hdd07704_1000.tar.bz2": { + "build": "py38hdd07704_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "214357893a54d5abbd9b2ec04978ff4d", + "name": "fast-histogram", + "sha256": "914f3c7065a76a858d0c9e36f10aeb73450e1dcadb7876223cd54d3bb1dc62e1", + "size": 28638, + "subdir": "linux-64", + "timestamp": 1573738175112, + "version": "0.7" + }, + "fast-histogram-0.8-py36heb32a55_1000.tar.bz2": { + "build": "py36heb32a55_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "fc4cb9b3360627d406cd01e441dc5503", + "name": "fast-histogram", + "sha256": "6e2c59ba5b4ccddd14d4396fa39a6805cdd9dd158e48e2711cd669f33e3ece65", + "size": 24033, + "subdir": "linux-64", + "timestamp": 1583249450589, + "version": "0.8" + }, + "fast-histogram-0.8-py37heb32a55_1000.tar.bz2": { + "build": "py37heb32a55_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "5b716617b92d768eefd1171c1b469421", + "name": "fast-histogram", + "sha256": "947040a627b5ec9cbaa87b3c5c4a354f937ff2024efc43ef0cbe7325b321e09f", + "size": 23966, + "subdir": "linux-64", + "timestamp": 1583249387141, + "version": "0.8" + }, + "fast-histogram-0.8-py38heb32a55_1000.tar.bz2": { + "build": "py38heb32a55_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "0ccf15fe2459dca4f28ed2908495abb0", + "name": "fast-histogram", + "sha256": "926890008b149c615a4fa5b0fe713368fdbaf859c774f53b4048a8abe51c18ac", + "size": 24331, + "subdir": "linux-64", + "timestamp": 1583249403171, + "version": "0.8" + }, + "fast-histogram-0.9-py310h9102076_0.tar.bz2": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "7348c16dfe85875072de59a472af188a", + "name": "fast-histogram", + "sha256": "b64bce4b3f92241052ac018d14aa63c3ef8c392160ebb302e79694f7d08c6378", + "size": 44085, + "subdir": "linux-64", + "timestamp": 1640789902988, + "version": "0.9" + }, + "fast-histogram-0.9-py311hbed6279_0.tar.bz2": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "79d346d9aaa6285f6f2798f83f905506", + "name": "fast-histogram", + "sha256": "231bcb2a7ca1e8a52a231e1c11991eaf17ba16768599ca9fedf48362bbbdeafc", + "size": 26310, + "subdir": "linux-64", + "timestamp": 1676830508531, + "version": "0.9" + }, + "fast-histogram-0.9-py36h6323ea4_0.tar.bz2": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "d97f1c2bb5fb27ab5f070cee8ee43b19", + "name": "fast-histogram", + "sha256": "4e81f55c8603f6720f25f7ca7806250a1e03c4545443f403f20b9e855564fbf9", + "size": 25191, + "subdir": "linux-64", + "timestamp": 1614080141062, + "version": "0.9" + }, + "fast-histogram-0.9-py36heb32a55_0.tar.bz2": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "3fd3e04d4fcd3ef49d971d94903ec5c8", + "name": "fast-histogram", + "sha256": "6de6d2e6d8ac0dc6235f1a5efaea323abb3263eadbec11588757e0dc07611599", + "size": 24888, + "subdir": "linux-64", + "timestamp": 1591836792107, + "version": "0.9" + }, + "fast-histogram-0.9-py37h6323ea4_0.tar.bz2": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "0c271893b565a80593bd09a4d52ba8fb", + "name": "fast-histogram", + "sha256": "29018c2c6b49e909f12a18b48af5a771dd8d830a8f5befb1203a1ccd4b66b40c", + "size": 25096, + "subdir": "linux-64", + "timestamp": 1614079232710, + "version": "0.9" + }, + "fast-histogram-0.9-py37heb32a55_0.tar.bz2": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "edfe28950848899f8802c398405d68c5", + "name": "fast-histogram", + "sha256": "f5f25a5a60915f3a3fa42dc6fb2f40b7516598991ca434b2fdadc200bac7ee61", + "size": 24765, + "subdir": "linux-64", + "timestamp": 1591836771482, + "version": "0.9" + }, + "fast-histogram-0.9-py38h6323ea4_0.tar.bz2": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "8e695f4bcfb936ecc196728b9f1b0865", + "name": "fast-histogram", + "sha256": "b7868f0c95eec65fa7e581c34bfe133c40380085fa2b6e481988377402c35b60", + "size": 25451, + "subdir": "linux-64", + "timestamp": 1614079228110, + "version": "0.9" + }, + "fast-histogram-0.9-py38heb32a55_0.tar.bz2": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "5b074e04ac97a156b6cd9ef42e8eef34", + "name": "fast-histogram", + "sha256": "b818d0c2a0e42103c22d6eb8ec839bf78031c4186bd2bdaddb0829b67a8f469d", + "size": 25071, + "subdir": "linux-64", + "timestamp": 1591836755275, + "version": "0.9" + }, + "fast-histogram-0.9-py39h6323ea4_0.tar.bz2": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "63fbe77fadb3a9661ee2cb8ddc6d1760", + "name": "fast-histogram", + "sha256": "09960ea168fac9943351026876aa832e977e6b2f56bd3695c2c0941445ec0c06", + "size": 25438, + "subdir": "linux-64", + "timestamp": 1614080128413, + "version": "0.9" + }, + "fastavro-0.17.10-py27h14c3975_1.tar.bz2": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9ca71267aa2c141f0e24af571e20dbdf", + "name": "fastavro", + "sha256": "b106fc2412fdacd4b10a737bf76b70ac57b9a20b0b7c6baa67af5d7da06cc76a", + "size": 332530, + "subdir": "linux-64", + "timestamp": 1522790188086, + "version": "0.17.10" + }, + "fastavro-0.17.10-py35h14c3975_1.tar.bz2": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "0bf0bd15f558bc6e917e519fbcae628d", + "name": "fastavro", + "sha256": "3109c4acd318df88fe962d07a4d6a5c295ffa33eef2ef512655d55a7738de2a5", + "size": 335259, + "subdir": "linux-64", + "timestamp": 1522790337248, + "version": "0.17.10" + }, + "fastavro-0.17.10-py36h14c3975_1.tar.bz2": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "049823d9cb142c05fd7d99a3af765959", + "name": "fastavro", + "sha256": "2e1b73a8055afafbfef35295b8d56353b73c8136bebc20d48a7351420969f931", + "size": 346233, + "subdir": "linux-64", + "timestamp": 1522790468195, + "version": "0.17.10" + }, + "fastavro-0.17.5-py27h14c3975_1.tar.bz2": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5fd8e7a8523b61702d8cb78b50d9f3f0", + "name": "fastavro", + "sha256": "955bda93e6b6f1ca23fc69e963d1f774fc38552385e0f2dd982e9a5d5053d4b8", + "size": 341414, + "subdir": "linux-64", + "timestamp": 1516906015047, + "version": "0.17.5" + }, + "fastavro-0.17.5-py35h14c3975_1.tar.bz2": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "594f5d7ac799825971730eaa7a797c5e", + "name": "fastavro", + "sha256": "2e24a2107b52f5cb7483efaaa4240eea0eb7032371ae7609e3c6b5362a554e26", + "size": 343594, + "subdir": "linux-64", + "timestamp": 1516906051626, + "version": "0.17.5" + }, + "fastavro-0.17.5-py36h14c3975_1.tar.bz2": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "21136de6c238b980545648925fce0309", + "name": "fastavro", + "sha256": "7713b764e68a573c3902c7aeb3c5567fb35fd24bd63659934f0e7cb779556466", + "size": 353372, + "subdir": "linux-64", + "timestamp": 1516906053340, + "version": "0.17.5" + }, + "fastavro-0.19.3-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "3345dd56c15d6ba58c2fadbf20bb01f0", + "name": "fastavro", + "sha256": "d606ff48c5e364e8393add7d5f8d2577864132ff32c5c64844bce7b0530b2a77", + "size": 334312, + "subdir": "linux-64", + "timestamp": 1526943496142, + "version": "0.19.3" + }, + "fastavro-0.19.3-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "b4be5d1acbdc74b72f14202d46fed34d", + "name": "fastavro", + "sha256": "2230e914e0c6e7f9fe0b9026ddd180220dc5ba4d86401837e5312bc65024b9c3", + "size": 336943, + "subdir": "linux-64", + "timestamp": 1526942949930, + "version": "0.19.3" + }, + "fastavro-0.19.3-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "69a7264d5727da1f523ef863921c8677", + "name": "fastavro", + "sha256": "ff41c938412a50103c79910d77af1112eae4f9b56e5ce4c4a91fcad161826f2e", + "size": 349273, + "subdir": "linux-64", + "timestamp": 1526942897511, + "version": "0.19.3" + }, + "fastavro-0.19.5-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "944237d7152d9495c56bacca435d33dd", + "name": "fastavro", + "sha256": "0698e4f79eaced6fc584398357fe07ad2ec7d8a8d4bbe6f6defab8c1c3a03be2", + "size": 364921, + "subdir": "linux-64", + "timestamp": 1527854019353, + "version": "0.19.5" + }, + "fastavro-0.19.5-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "42cd51ecf9b417c364e39836d846c5bb", + "name": "fastavro", + "sha256": "e7cec2549c56f07180a7cc02b93611314f9e408109e419c0a877337125a04a6a", + "size": 367520, + "subdir": "linux-64", + "timestamp": 1527854041721, + "version": "0.19.5" + }, + "fastavro-0.19.5-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "54ba3371c35227272934f25f982bdfe3", + "name": "fastavro", + "sha256": "dfe7e5892424ae8d237f6026224c609356f639400aca68e188071fce535ca28f", + "size": 378300, + "subdir": "linux-64", + "timestamp": 1527854022351, + "version": "0.19.5" + }, + "fastavro-0.19.6-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e552d7f6506bc1725f11db6723ea7ddd", + "name": "fastavro", + "sha256": "ae9e0ebd278ed9f951149ff59292ad8c6e9111485bc3b05efaf0de27f572d3fc", + "size": 365007, + "subdir": "linux-64", + "timestamp": 1528221254164, + "version": "0.19.6" + }, + "fastavro-0.19.6-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "ef519cb1851cb3d2e9cce5f4a9a51886", + "name": "fastavro", + "sha256": "5eb71f084659bbaaf851c5a30adcf7db85449cbb061b844daae25848b213bfc4", + "size": 367723, + "subdir": "linux-64", + "timestamp": 1528221175044, + "version": "0.19.6" + }, + "fastavro-0.19.6-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ee1f0a0f0d22b945982b73adc2873f2a", + "name": "fastavro", + "sha256": "6986e8c0110ad21ad44d49c6466b31ac640810f53176aea1a9b2db8edb71cd00", + "size": 378372, + "subdir": "linux-64", + "timestamp": 1528221245099, + "version": "0.19.6" + }, + "fastavro-0.19.7-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "a531c5bc844dfc06006baf99d2de7d96", + "name": "fastavro", + "sha256": "576d75cc49d28032ed6841ab2195d92f726239df00f31b0badce18ced1e77545", + "size": 361708, + "subdir": "linux-64", + "timestamp": 1529443765019, + "version": "0.19.7" + }, + "fastavro-0.19.7-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "df55ac6318829421a18b5424558a6ff6", + "name": "fastavro", + "sha256": "612076639e28aae67fdb21caa6139500778d9ae6a7c4f1bb0ec1fddf9196abfe", + "size": 364273, + "subdir": "linux-64", + "timestamp": 1529443769217, + "version": "0.19.7" + }, + "fastavro-0.19.7-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "977cbd830f6fa23984378466960691cd", + "name": "fastavro", + "sha256": "0ed3f903c0d9c8fd720d261d4007408e6dedcb9fdca0761dcf3eb574e660027f", + "size": 377244, + "subdir": "linux-64", + "timestamp": 1529443385115, + "version": "0.19.7" + }, + "fastavro-0.19.7-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1c3db4d0f318a6d15a71212175bbbbca", + "name": "fastavro", + "sha256": "bb59ecc3bbd050dfe0b6c28771d3a562676abf7bd29f0f4384ec8001be11408a", + "size": 373102, + "subdir": "linux-64", + "timestamp": 1530876405406, + "version": "0.19.7" + }, + "fastavro-0.21.11-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "74ccdfb2e61b892db3f1e6299c308028", + "name": "fastavro", + "sha256": "688bbbd4792da08d2cd095f7dbff50b9ae6fa6088a569a82b32e6a2619003914", + "size": 318846, + "subdir": "linux-64", + "timestamp": 1540964903902, + "version": "0.21.11" + }, + "fastavro-0.21.11-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ffd24078f35f1ab9a417825f726ed7dd", + "name": "fastavro", + "sha256": "4a3454d1af4955533e9e696a70baa26a6bcf166d59b83d8bd3a008fd14f04064", + "size": 342167, + "subdir": "linux-64", + "timestamp": 1540964952723, + "version": "0.21.11" + }, + "fastavro-0.21.11-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "97432fe35b1093513ada36c893028fcc", + "name": "fastavro", + "sha256": "74f7f1b030ee2a878f782b609b760f1bbf6a599dd182ab044ea1b4b42be3d4cc", + "size": 340494, + "subdir": "linux-64", + "timestamp": 1540964951665, + "version": "0.21.11" + }, + "fastavro-0.21.12-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "3185260792de18c8e7e3c7fdedde594d", + "name": "fastavro", + "sha256": "70544fa9ce92dec09e29f4f60cc4fe104c5138a0bf5ca8dfb528da9578b03ee5", + "size": 317937, + "subdir": "linux-64", + "timestamp": 1541105875934, + "version": "0.21.12" + }, + "fastavro-0.21.12-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "368e78a6ac3fdff8d5e6ffe00527257f", + "name": "fastavro", + "sha256": "1931904fe9ee47f424a3c8e8e6d5ef89a9894d02317a874fa02022779a0188fa", + "size": 337718, + "subdir": "linux-64", + "timestamp": 1541105897170, + "version": "0.21.12" + }, + "fastavro-0.21.12-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "bd7a4ca013664b5e65dfa16002f5ed94", + "name": "fastavro", + "sha256": "49f609130b20246523b1fa0e8e508cfa0c74ca8ead0ac50b28fdd99927f5c670", + "size": 340044, + "subdir": "linux-64", + "timestamp": 1541105814618, + "version": "0.21.12" + }, + "fastavro-0.21.13-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "efcc202e2355905e16a633ebde7c4161", + "name": "fastavro", + "sha256": "38dcb6cf05f3abd50aa6deba01a6b050207e8bdbeb962f3fbdd5d92b8303866f", + "size": 320176, + "subdir": "linux-64", + "timestamp": 1542078613692, + "version": "0.21.13" + }, + "fastavro-0.21.13-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "71fac8cc632d48bf2deadf09ae493b88", + "name": "fastavro", + "sha256": "5cebfdc21dc18bc600512c1af2c8400ee59793bda23e04f186aeefd99abe4e5a", + "size": 343839, + "subdir": "linux-64", + "timestamp": 1542078644587, + "version": "0.21.13" + }, + "fastavro-0.21.13-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "39b884f0b821551ebacbcb0a7df749f0", + "name": "fastavro", + "sha256": "46f20b8317e5dacdf7be25ebbe10faa393200e989cd6091396c0d73bbb6e6535", + "size": 343459, + "subdir": "linux-64", + "timestamp": 1542078615736, + "version": "0.21.13" + }, + "fastavro-0.21.14-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "22efb3aff2f1d4e5d4582b38eb6a6593", + "name": "fastavro", + "sha256": "99a0a7950003319f44874c03b5f5aedb499f73b7cb0b12870201a3d0348be2e8", + "size": 319526, + "subdir": "linux-64", + "timestamp": 1542639112966, + "version": "0.21.14" + }, + "fastavro-0.21.14-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a1787c496270857702f4f02bf83c18b2", + "name": "fastavro", + "sha256": "637451b6fee51ceefb184f06c497127875d607b4da1a2821bdd8428074b9f336", + "size": 341076, + "subdir": "linux-64", + "timestamp": 1542639145129, + "version": "0.21.14" + }, + "fastavro-0.21.14-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "afa22677092f76bed97115dbbd879fb6", + "name": "fastavro", + "sha256": "14d66b02f8205b3cfbf37523c3f5e45d9fd87bdea1f84290dc6c6e0141b0776b", + "size": 340229, + "subdir": "linux-64", + "timestamp": 1542639103685, + "version": "0.21.14" + }, + "fastavro-0.21.15-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5cc0fee9199b7483f83e4eba41319c53", + "name": "fastavro", + "sha256": "73c6a652c31a9754b8df479e342f0a06eb0ef6b430395b0823cdd6def3598006", + "size": 323082, + "subdir": "linux-64", + "timestamp": 1545147112964, + "version": "0.21.15" + }, + "fastavro-0.21.15-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f132ac44ea7427e93c79aa58e2ba40ad", + "name": "fastavro", + "sha256": "ab5aaa75b2041670548d08bad5ee1bfffaf408e3019902d6259a74165a26e7bf", + "size": 350180, + "subdir": "linux-64", + "timestamp": 1545129557379, + "version": "0.21.15" + }, + "fastavro-0.21.15-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a7a13615f9828bb3ad7c9c3a95d44fd9", + "name": "fastavro", + "sha256": "e77fdd73e80374acf3ec38e0d203226ec8ccd67132a755f034eae4acb110200d", + "size": 338370, + "subdir": "linux-64", + "timestamp": 1545129562691, + "version": "0.21.15" + }, + "fastavro-0.21.16-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e6cbb121f16ed681f7230e93e569d36e", + "name": "fastavro", + "sha256": "8b14255bcdfee971ff277b7232ca49978ce5c69fafee90e563ea31851dfd1f38", + "size": 330546, + "subdir": "linux-64", + "timestamp": 1547228153268, + "version": "0.21.16" + }, + "fastavro-0.21.16-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "cd5e097dfdbd10349337d1b72091eb4d", + "name": "fastavro", + "sha256": "f7f84b8531a64466545f00b6399ae9dc67b96a0f6423b4f14cf589738377f6be", + "size": 349591, + "subdir": "linux-64", + "timestamp": 1547228278530, + "version": "0.21.16" + }, + "fastavro-0.21.16-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "bbad51a7e997172da13a7dc94b8b9b71", + "name": "fastavro", + "sha256": "4ef39061e2d02d691d4fa369a149c7194676c73a29555daa965e0160e9709e9c", + "size": 360180, + "subdir": "linux-64", + "timestamp": 1547228278372, + "version": "0.21.16" + }, + "fastavro-0.21.18-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7b5052cfebbfb4cc6008a479d9af515f", + "name": "fastavro", + "sha256": "2d8135fd373ee5ff3c025f24c1014f781d5a1fa13ea59372fe497a50864457ca", + "size": 335856, + "subdir": "linux-64", + "timestamp": 1550269505928, + "version": "0.21.18" + }, + "fastavro-0.21.18-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3d8d359c4379a0b2b5af811bd40bf98d", + "name": "fastavro", + "sha256": "5d76d31f6dcbdd8745e680d422701e19b5557433c68204fa7f68ca7e07a22fd4", + "size": 349169, + "subdir": "linux-64", + "timestamp": 1550269513327, + "version": "0.21.18" + }, + "fastavro-0.21.18-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c0b3cda5b93ec2c5b3772467d1cce33a", + "name": "fastavro", + "sha256": "a74feb7612fa7d97f0a94cd45a1f912e8ed9d4bacd84b608f3a22de159b93488", + "size": 354145, + "subdir": "linux-64", + "timestamp": 1550269481274, + "version": "0.21.18" + }, + "fastavro-0.21.19-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "747fe0fc0b50eb1020d3a17d7b895780", + "name": "fastavro", + "sha256": "68fdf3578854484f577c790fbb959493f78dc20f2d0d89077bebd476966968b6", + "size": 332529, + "subdir": "linux-64", + "timestamp": 1552376670083, + "version": "0.21.19" + }, + "fastavro-0.21.19-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8d4b647a11d53bba35f2a40b5d88e456", + "name": "fastavro", + "sha256": "8746e363774b3e953685a86b6f469e9ccefaea8a221edd418b90a3ef1d27cf7b", + "size": 352315, + "subdir": "linux-64", + "timestamp": 1552376713638, + "version": "0.21.19" + }, + "fastavro-0.21.19-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "9fbd6c003100dd882def22ded783be8d", + "name": "fastavro", + "sha256": "5d7135b72296dd7d127d05dc46c7cf10ad997014e38a41329cc16a2bbafeb9c8", + "size": 350217, + "subdir": "linux-64", + "timestamp": 1552376643879, + "version": "0.21.19" + }, + "fastavro-0.21.21-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "fd2009f9c04409cdad651ee4aa10b958", + "name": "fastavro", + "sha256": "42bb960d6891f40d49921304632aeaac59e4addc8f43697cec1498c735e8b62b", + "size": 340195, + "subdir": "linux-64", + "timestamp": 1556081464914, + "version": "0.21.21" + }, + "fastavro-0.21.21-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "188b2580b7dc1050693d45551f24e4c5", + "name": "fastavro", + "sha256": "3907c07b6db90f65fd63e9061253b3bde3f7bf38f602ff0557d8b84d15dbcc66", + "size": 365832, + "subdir": "linux-64", + "timestamp": 1556112708224, + "version": "0.21.21" + }, + "fastavro-0.21.21-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a0ca19389091db5d5cca9c30eac3c4c2", + "name": "fastavro", + "sha256": "cbf91f6b03f714693785c81d4238da54146fb6b8947e0fcdd084e6902f4b79d3", + "size": 351026, + "subdir": "linux-64", + "timestamp": 1556112564470, + "version": "0.21.21" + }, + "fastavro-0.21.23-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "85bd86f049f57b6dcb55b575b723504c", + "name": "fastavro", + "sha256": "910d0cc589a02325e0bf8ffffa7d377237ea195699018ee0fd401f89a999253c", + "size": 347424, + "subdir": "linux-64", + "timestamp": 1558587743409, + "version": "0.21.23" + }, + "fastavro-0.21.23-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a1cff44de4e1ec8f52f1c46c3b26ea6a", + "name": "fastavro", + "sha256": "1e5dcfcc9c457710263b4f9632a698b43d035daaacef721888c0a93eca00f794", + "size": 379884, + "subdir": "linux-64", + "timestamp": 1558588078536, + "version": "0.21.23" + }, + "fastavro-0.21.23-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3e5cb2a09024cf14959ef070739f110d", + "name": "fastavro", + "sha256": "e3b9e2d11d653572f357eebd0f6907f70e348dac0d2a2398d25e114943845f30", + "size": 364607, + "subdir": "linux-64", + "timestamp": 1558587886692, + "version": "0.21.23" + }, + "fastavro-0.21.4-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "2e964a2878f9d5f944d30c95ae9b29e7", + "name": "fastavro", + "sha256": "20a612948f9a35f0e41fd2d1d514a1ca39a458fc43dd36bb8dfbd662d7d098db", + "size": 319837, + "subdir": "linux-64", + "timestamp": 1535424990046, + "version": "0.21.4" + }, + "fastavro-0.21.4-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "93e26b09bf2779323f5c6efdfa9f6348", + "name": "fastavro", + "sha256": "cfc9392a4b267dbb03462c98f489f2a925ccfc2845138f05706f4de5caa51a17", + "size": 321346, + "subdir": "linux-64", + "timestamp": 1535424749383, + "version": "0.21.4" + }, + "fastavro-0.21.4-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7e070eee8e99f9447580a5a81965f892", + "name": "fastavro", + "sha256": "d65a34f38fab8c3f866dc4e73fde1db897c228ad6fa345247bb1715e2ccb3910", + "size": 332344, + "subdir": "linux-64", + "timestamp": 1535424882506, + "version": "0.21.4" + }, + "fastavro-0.21.4-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f79187b92aa5e0333251205016dda169", + "name": "fastavro", + "sha256": "2217c156d833e8c9b2bc5d1e878811bb20222ee8f4a80c931606fa0716f90a79", + "size": 329813, + "subdir": "linux-64", + "timestamp": 1535425060280, + "version": "0.21.4" + }, + "fastavro-0.21.8-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d1585773a843cd202aa054d640e716d0", + "name": "fastavro", + "sha256": "8bce0a6a00d7461b35b458831baae560b96497267a160a47ab3fd79f618d362b", + "size": 335868, + "subdir": "linux-64", + "timestamp": 1538361881004, + "version": "0.21.8" + }, + "fastavro-0.21.8-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b3e40e6130d9e9bdd0cde3dafe7f84d5", + "name": "fastavro", + "sha256": "11d1d0a3316ad7c2a43995a53a0ce8175f42d1a687d834e225d907a6e8474cf6", + "size": 349630, + "subdir": "linux-64", + "timestamp": 1538361911879, + "version": "0.21.8" + }, + "fastavro-0.21.8-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8a33c29d7114a651465a6a81a67dc39a", + "name": "fastavro", + "sha256": "44b5c1384306221bda148f3f08fd3cc81cc76758efe8933661cf79e908e62c4f", + "size": 346183, + "subdir": "linux-64", + "timestamp": 1538361872794, + "version": "0.21.8" + }, + "fastavro-0.21.9-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "860537f962307892c7d708d6e1f38553", + "name": "fastavro", + "sha256": "24dd632ba459b9403dfa1d2c612aec197f90fedfd70d634e84b0bd510143faee", + "size": 336046, + "subdir": "linux-64", + "timestamp": 1539476228933, + "version": "0.21.9" + }, + "fastavro-0.21.9-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6392e6eebfc265394704e3449beb0902", + "name": "fastavro", + "sha256": "b0094117e8b0ee6788981f2e12fcb3d7b323c93a9f6a22ad657dbf734d7f18a3", + "size": 348130, + "subdir": "linux-64", + "timestamp": 1539476263226, + "version": "0.21.9" + }, + "fastavro-0.21.9-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a56476d67a0c721d8cbf003d3d2641c8", + "name": "fastavro", + "sha256": "1ec97986553f0366273632cebbe76aa8254c7319fba022197f75fb6c24f2f909", + "size": 345693, + "subdir": "linux-64", + "timestamp": 1539476266823, + "version": "0.21.9" + }, + "fastavro-0.22.13-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "cb933ea8a93a7c5292632e34cdd65726", + "name": "fastavro", + "sha256": "500095bb0528bb124a4fc9fc0da76aacc717ae16dc35d0d152dfcaaab462c107", + "size": 429210, + "subdir": "linux-64", + "timestamp": 1584961130829, + "version": "0.22.13" + }, + "fastavro-0.22.13-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "174e621753ba2ed209ca0b76f8a112d0", + "name": "fastavro", + "sha256": "973af6d032a728d7ee4d91cf7152862152f7d4b50e79ff1b1db12e391b3b5a18", + "size": 426635, + "subdir": "linux-64", + "timestamp": 1584961137161, + "version": "0.22.13" + }, + "fastavro-0.22.13-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "da197f5f82b4815a5c43fdd81c43dca9", + "name": "fastavro", + "sha256": "7a54022218af2019beac2a0d0a22d2456289daefa456f370b186941bac17d235", + "size": 457454, + "subdir": "linux-64", + "timestamp": 1584961139197, + "version": "0.22.13" + }, + "fastavro-0.22.5-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b772263f198e0574b37d8241545e6c90", + "name": "fastavro", + "sha256": "029749527a64b9aac0a36dbd087f43d4031ad9581ac2aae8ec853c320288298d", + "size": 397111, + "subdir": "linux-64", + "timestamp": 1569420049308, + "version": "0.22.5" + }, + "fastavro-0.22.5-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a9f88569e955a900ba8ef782fe1d95b3", + "name": "fastavro", + "sha256": "fdbbdbe9da6fe25d13572bd2ff3d33a3371f3b1f3c3bd2cf42fbe1a4c12202e3", + "size": 413068, + "subdir": "linux-64", + "timestamp": 1569420023058, + "version": "0.22.5" + }, + "fastavro-0.22.5-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c053b7b297f093274f88c437d9468946", + "name": "fastavro", + "sha256": "d44514f2f28aa32f21f0b2c01699e92e6cb1928c7fa618472761cdcc90b77a4c", + "size": 407402, + "subdir": "linux-64", + "timestamp": 1569420006165, + "version": "0.22.5" + }, + "fastavro-0.22.5-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "1a82b833f17f885be933738d0c69f077", + "name": "fastavro", + "sha256": "3f514aeedc50b0bb8f3963e58ce7500ad399dd7d3243d643ca6103985b60ffd4", + "size": 441751, + "subdir": "linux-64", + "timestamp": 1572880577707, + "version": "0.22.5" + }, + "fastavro-0.22.7-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5d219ec26e1408a6a318924a7c07da65", + "name": "fastavro", + "sha256": "d374e318a686b57228713b20fb35a3e323e4195401f8dbe04f33604e5cee31da", + "size": 379783, + "subdir": "linux-64", + "timestamp": 1573964049091, + "version": "0.22.7" + }, + "fastavro-0.22.7-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c7589eef704e836b36771d01599c0817", + "name": "fastavro", + "sha256": "84fd54bd2a349e310062bfdebe4be81ecee55740c2008ddc0b58669be1c116bb", + "size": 423522, + "subdir": "linux-64", + "timestamp": 1573964053278, + "version": "0.22.7" + }, + "fastavro-0.22.7-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "44658c9e6df31d2cf87e68e2b23ee4db", + "name": "fastavro", + "sha256": "88b96d2616dca9844a5fefb73a6af8bc62aa9e9f9e26600c89af4d9ee7abda9a", + "size": 421849, + "subdir": "linux-64", + "timestamp": 1573964004156, + "version": "0.22.7" + }, + "fastavro-0.23.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "34f8d16af7936b00f245dfd9d8e170d0", + "name": "fastavro", + "sha256": "9b2b48925bed02e3bd5b44b8f8308d8f37035d2f5a17235c2c1ba5f7b6bd7af7", + "size": 443962, + "subdir": "linux-64", + "timestamp": 1589230057950, + "version": "0.23.3" + }, + "fastavro-0.23.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "d387a6c73d171cfb3748bb88cb8b8958", + "name": "fastavro", + "sha256": "9c3a85e9127e0bc67d488650abe333d6e9d6f3d89c30c45707519f225a5c2813", + "size": 448124, + "subdir": "linux-64", + "timestamp": 1589230043681, + "version": "0.23.3" + }, + "fastavro-0.23.3-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "d5ba75d0e495137ca5440add2b591c8e", + "name": "fastavro", + "sha256": "6cbfe78116feb4545a731b803c4e3e532857bb3dae3ea892b22bf1883b38990a", + "size": 472745, + "subdir": "linux-64", + "timestamp": 1589230058979, + "version": "0.23.3" + }, + "fastavro-0.23.4-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "5fe60d40d116ae4629a7751be58c0b1a", + "name": "fastavro", + "sha256": "c2f7596849032ce8e0b062bc7fbc20b02fc7a18ef10df88abbb3280b66bfc334", + "size": 449862, + "subdir": "linux-64", + "timestamp": 1591183471592, + "version": "0.23.4" + }, + "fastavro-0.23.4-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "bef8f51aff8f11aa3daf0aec2005b996", + "name": "fastavro", + "sha256": "7adb519abf245bf4e224a977524b5c2407d2619c675e5e587c2df3fe4e667f91", + "size": 435441, + "subdir": "linux-64", + "timestamp": 1591183478421, + "version": "0.23.4" + }, + "fastavro-0.23.4-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "db6d6c2c8f18b60d24d1fa269398071a", + "name": "fastavro", + "sha256": "d435a5992846de03851220a555200d5f403c262e075972122f4021b2527c66c6", + "size": 467988, + "subdir": "linux-64", + "timestamp": 1591183471801, + "version": "0.23.4" + }, + "fastavro-0.23.5-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "4ad95ef2b7b6c44b17c88186a07f452f", + "name": "fastavro", + "sha256": "ee2a327e5ff979c72190d691636b18198451cdc3792691e7700082a971616834", + "size": 405540, + "subdir": "linux-64", + "timestamp": 1593483787649, + "version": "0.23.5" + }, + "fastavro-0.23.5-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "d6834b3c58d053244022ed0c9a3958c8", + "name": "fastavro", + "sha256": "5ab3c9f2390bb5e6be6e1e57718df60a1e7e1a42cd5813532def95f5b2e9efc9", + "size": 398943, + "subdir": "linux-64", + "timestamp": 1593483748725, + "version": "0.23.5" + }, + "fastavro-0.23.5-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "d2d4689b680023cc99534c2e77b4288e", + "name": "fastavro", + "sha256": "f53e2a1a2ef8d8487ddd0f76825a7cd2cee6cf8f623eaead79e9157988cb8c51", + "size": 423704, + "subdir": "linux-64", + "timestamp": 1593483750888, + "version": "0.23.5" + }, + "fastavro-1.0.0.post1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "0d61e2af41f0e9568320bf48d1eec69d", + "name": "fastavro", + "sha256": "bee7f0e5f74faba88cf5c6bbc09b5d8f2bc2e856dde5ee5039abc116161eddc4", + "size": 390689, + "subdir": "linux-64", + "timestamp": 1600356316566, + "version": "1.0.0.post1" + }, + "fastavro-1.0.0.post1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "c9f294951c5df7ab9f15966c5992001a", + "name": "fastavro", + "sha256": "59abc418a779a2574f07d0d24310b46f8b9f4c662ef713fa4972197c3dcf858a", + "size": 403709, + "subdir": "linux-64", + "timestamp": 1600356316048, + "version": "1.0.0.post1" + }, + "fastavro-1.0.0.post1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "54ae4ba52a32eda477a32431a55cc3ff", + "name": "fastavro", + "sha256": "12addf14a50eb84da05dec3ce5096023b907dcc8245f427be043be883332f247", + "size": 428960, + "subdir": "linux-64", + "timestamp": 1600356336933, + "version": "1.0.0.post1" + }, + "fastavro-1.1.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "309f4488a3d2744b753075c3dc3df7ce", + "name": "fastavro", + "sha256": "0f0ac644fd1dcef7e0ad25eece687d0ee835409af85d3560b81131f715dedfd7", + "size": 402311, + "subdir": "linux-64", + "timestamp": 1604099523215, + "version": "1.1.0" + }, + "fastavro-1.1.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "1ea872b0aee71dece951892df68b9e33", + "name": "fastavro", + "sha256": "8c878d0c0dd4ea4c73dc4477b5c7153b43476fb18512c3f84538a24ac8875a5b", + "size": 400498, + "subdir": "linux-64", + "timestamp": 1604099505364, + "version": "1.1.0" + }, + "fastavro-1.1.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "4a0357a90f7e4d426fb74e4e050d3c5b", + "name": "fastavro", + "sha256": "fb2bd1876a16e620426f276191b2ec38db3184adf29a140b023c2e16a1dd4c01", + "size": 416273, + "subdir": "linux-64", + "timestamp": 1604099493442, + "version": "1.1.0" + }, + "fastavro-1.2.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "de4557224c83a75158d614e9990fdf9b", + "name": "fastavro", + "sha256": "5d7a2ce40c772cc2b02d7796b02d7e1b5a1b5bdb26c6e23e5ce76917de039419", + "size": 407542, + "subdir": "linux-64", + "timestamp": 1606083231361, + "version": "1.2.0" + }, + "fastavro-1.2.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "03360c5e57c49b11d94914d597e25ee0", + "name": "fastavro", + "sha256": "f72ef727646acce948280fbf8b4aa05897ce5f099271bd7e3aa2278ca7498411", + "size": 405539, + "subdir": "linux-64", + "timestamp": 1606083219994, + "version": "1.2.0" + }, + "fastavro-1.2.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "cc10d6a89f355afa4da00d9a50522af4", + "name": "fastavro", + "sha256": "f6b5ba88a93dba466bf17075a1c534c9312e87ca8bb1473754f5d2e51080f174", + "size": 430779, + "subdir": "linux-64", + "timestamp": 1606083220342, + "version": "1.2.0" + }, + "fastavro-1.2.1-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "8dab4a6ad3b297de2f827574a6c68a12", + "name": "fastavro", + "sha256": "f6bec3b1665ece4271b1661c64b622afbeb3938554a7a1ff7821f72651c495e8", + "size": 409079, + "subdir": "linux-64", + "timestamp": 1606946705406, + "version": "1.2.1" + }, + "fastavro-1.2.1-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "c2b08f28de496d28d9ca31f808f25837", + "name": "fastavro", + "sha256": "8e72ec117d3c5ce018378b6a2b0ba0775025baca72e1c33fa7a99a048fca40a8", + "size": 407085, + "subdir": "linux-64", + "timestamp": 1606946673364, + "version": "1.2.1" + }, + "fastavro-1.2.1-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "76193045b94bea7a0cd0b9f76cea3ab9", + "name": "fastavro", + "sha256": "0e20634e3fedece759fbddcde57d04f7ed8702c92785c7dd22aef7490e8c61fb", + "size": 432255, + "subdir": "linux-64", + "timestamp": 1606946707530, + "version": "1.2.1" + }, + "fastavro-1.2.2-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "52b9d1c146f3308a36cf43e3241d62e3", + "name": "fastavro", + "sha256": "10d92a1c61babcab9f02e5a8360e33a781e7a930c1c3986089b3f87e2a7d1d3f", + "size": 410033, + "subdir": "linux-64", + "timestamp": 1608755123228, + "version": "1.2.2" + }, + "fastavro-1.2.2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "52c590ccd7e2631da5fde8bd884f1a08", + "name": "fastavro", + "sha256": "41768a794c42a52fec74a138ded7b4c8ca943cc4f420df3e7abba653a0d40f75", + "size": 407033, + "subdir": "linux-64", + "timestamp": 1608755077297, + "version": "1.2.2" + }, + "fastavro-1.2.2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "b82b040c04fcf02485d3fe6287f5db8f", + "name": "fastavro", + "sha256": "b6db3f6f66525ea4d89045719818c5d2531c5d830fc28e48b388dacfe9b92c0e", + "size": 433934, + "subdir": "linux-64", + "timestamp": 1608755125652, + "version": "1.2.2" + }, + "fastavro-1.2.2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "b01b62b127b479d2e71bd69d6b7bd9eb", + "name": "fastavro", + "sha256": "e651c56b1521c78b725bf0a5ced84c8aacd471d941fdc5dac55c01d91aad9314", + "size": 421275, + "subdir": "linux-64", + "timestamp": 1608755034014, + "version": "1.2.2" + }, + "fastavro-1.2.3-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "613a7bdffa470b1cf5b9cdeb265e5acb", + "name": "fastavro", + "sha256": "f653bd070643ea16e2c1aa4e758aee03024f3ee121f6c6622f3aa0cf1b491bd5", + "size": 398936, + "subdir": "linux-64", + "timestamp": 1608833667969, + "version": "1.2.3" + }, + "fastavro-1.2.3-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "c3614b360adff57af62ded406850f113", + "name": "fastavro", + "sha256": "acdbfd616a07288a42acfe4d7150afecaef134323b720214bf54785d954617ce", + "size": 408156, + "subdir": "linux-64", + "timestamp": 1608833674291, + "version": "1.2.3" + }, + "fastavro-1.2.3-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "7178fe8a24da8d90202c9c04fd5ddc58", + "name": "fastavro", + "sha256": "4551d02cc15696afc39c13d9934a4d9a5ef85e6f3f545345f52f0d33e8af7a0e", + "size": 434781, + "subdir": "linux-64", + "timestamp": 1608833681644, + "version": "1.2.3" + }, + "fastavro-1.2.3-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "2476ac105ed833c4642d3db2e31b9b87", + "name": "fastavro", + "sha256": "c4d1676f724431c36e15adba3e2e4164ff387fa09b9a13a4c39aeb8592920b01", + "size": 430618, + "subdir": "linux-64", + "timestamp": 1608833672483, + "version": "1.2.3" + }, + "fastavro-1.2.4-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "01a95cb8588e60f487e91fe9a546d586", + "name": "fastavro", + "sha256": "da8b40b2f1d6cb348e19dbbf9de062d27fc790098f721c866b35e4ea66362805", + "size": 409850, + "subdir": "linux-64", + "timestamp": 1610908894834, + "version": "1.2.4" + }, + "fastavro-1.2.4-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "e74af9b0eac77bfe386c610df8c63a1e", + "name": "fastavro", + "sha256": "3a735053af72da1e6bbaf1e51d93f26933b64e685dd97dfe1e3162b1417d0dfa", + "size": 407673, + "subdir": "linux-64", + "timestamp": 1610908909129, + "version": "1.2.4" + }, + "fastavro-1.2.4-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "2bdd28adcf0fd0bf9fda28ea43dbec41", + "name": "fastavro", + "sha256": "5c58bc8c7dfe670b7689cc8f4a87d450fda0311b576a5a3d248edeb1673a2156", + "size": 425001, + "subdir": "linux-64", + "timestamp": 1610908210884, + "version": "1.2.4" + }, + "fastavro-1.2.4-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "cf104b28c6278479ab65353a076d2658", + "name": "fastavro", + "sha256": "451b32bf13947d44cfcf350074d0c5902d824bde9c45c1c17d0b29a1699c99d9", + "size": 434766, + "subdir": "linux-64", + "timestamp": 1610908893402, + "version": "1.2.4" + }, + "fastavro-1.3.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "01272c77af6b3aa2f0114b10bcf2d3a1", + "name": "fastavro", + "sha256": "61733edfc9097c7a0e30b7feb7a462b0565bf3a854e1916d9aa1b0fb33762a1d", + "size": 415016, + "subdir": "linux-64", + "timestamp": 1611341703422, + "version": "1.3.0" + }, + "fastavro-1.3.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "768ff1a92516e5527ff6498841daa4df", + "name": "fastavro", + "sha256": "c91205d3233e6138df8044b4bd859330b425e665c81c47b7e1e63eb97affae67", + "size": 411736, + "subdir": "linux-64", + "timestamp": 1611341711051, + "version": "1.3.0" + }, + "fastavro-1.3.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "9dd0fe1715bcbcd0a8842baf97c5070f", + "name": "fastavro", + "sha256": "4424849409707a6aec33c239290e2a3c13ecbc15f9477296ddb7309369056d02", + "size": 439370, + "subdir": "linux-64", + "timestamp": 1611341219974, + "version": "1.3.0" + }, + "fastavro-1.3.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "00ab984b3520b1b27961476b32446086", + "name": "fastavro", + "sha256": "0ee7230b5f2c7501c254c39068c688cead65a44084b0d466bf9b7d30c0878185", + "size": 427692, + "subdir": "linux-64", + "timestamp": 1611341707993, + "version": "1.3.0" + }, + "fastavro-1.3.1-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "e2d901ca46084bba62caf82ba6b61669", + "name": "fastavro", + "sha256": "8e5d0f6c5b61afaa9f14db35dc8bea702d97c8bdbb3d62ca9f1951c77e1c2cc7", + "size": 444636, + "subdir": "linux-64", + "timestamp": 1613328447643, + "version": "1.3.1" + }, + "fastavro-1.3.1-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "5e290cd33558b6ad2c335b09f7577e53", + "name": "fastavro", + "sha256": "fd58ab58c3001899b410e8513c18f06c76823f31263833f59384e8decd3743e8", + "size": 446866, + "subdir": "linux-64", + "timestamp": 1613327826592, + "version": "1.3.1" + }, + "fastavro-1.3.1-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "3f2c21f3b0474d9c271774c5b4a853f2", + "name": "fastavro", + "sha256": "39b8ce4d805be5c8e36a8f99a25d87cfe9de4f8ba6fabae7acb5c39aa9e5861b", + "size": 470420, + "subdir": "linux-64", + "timestamp": 1613328445659, + "version": "1.3.1" + }, + "fastavro-1.3.1-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "f321bb2130f2b1140a244b6496d05418", + "name": "fastavro", + "sha256": "ca41aa0a4c0520387c4e07b8d4d5214f8ff36cc798eb0258793cc2c261dc051a", + "size": 466082, + "subdir": "linux-64", + "timestamp": 1613328442447, + "version": "1.3.1" + }, + "fastavro-1.3.2-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "89e7e93bb4e9c966739af30034bc48e4", + "name": "fastavro", + "sha256": "a851599e55fc45d156e2155f13b05a9c3a7b065846a3099d90458a4c88e4bdc7", + "size": 439588, + "subdir": "linux-64", + "timestamp": 1613414970546, + "version": "1.3.2" + }, + "fastavro-1.3.2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "f753f4fb5b965108afbe2dd0e17eefb6", + "name": "fastavro", + "sha256": "8f4629d3117cfbb2384c3184d14fe69a34704e88d79169bb5dd08ba7def830c1", + "size": 437447, + "subdir": "linux-64", + "timestamp": 1613414856954, + "version": "1.3.2" + }, + "fastavro-1.3.2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "d36827940bbd3403832caebf15407444", + "name": "fastavro", + "sha256": "2dc3a796ca4d70321183bc74acb1c98d29c952653a9eef32a1e28671699a5251", + "size": 463328, + "subdir": "linux-64", + "timestamp": 1613414977867, + "version": "1.3.2" + }, + "fastavro-1.3.2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "47066c08577d2e8fa408932933c7025a", + "name": "fastavro", + "sha256": "f2f939b5aa4ef967f67d2e8db9d16ece0e640f310b6b98f8b4cd30ac37508f71", + "size": 475535, + "subdir": "linux-64", + "timestamp": 1613414969506, + "version": "1.3.2" + }, + "fastavro-1.3.3-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "270826ec4d2bfa5eaea346b4a7e5551d", + "name": "fastavro", + "sha256": "303ba40e339251d4dde7b54e5d2648a3c8d6cc4348cf134531d3c4b3e44f2fdc", + "size": 453480, + "subdir": "linux-64", + "timestamp": 1615661545658, + "version": "1.3.3" + }, + "fastavro-1.3.3-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "b709f6808a8d4bda45acb73833193cc5", + "name": "fastavro", + "sha256": "e27095116198e63f39d779b66a7731752ab61da2939edc4b2e8bc0c70560f97a", + "size": 446877, + "subdir": "linux-64", + "timestamp": 1615661536510, + "version": "1.3.3" + }, + "fastavro-1.3.3-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "2b0187af5d6a3ff31705c6b0b11ef18d", + "name": "fastavro", + "sha256": "442bcb92a684fe9dccae2f594f1685f282d95d9288015b25aa7e8cb8aa63ad6c", + "size": 475004, + "subdir": "linux-64", + "timestamp": 1615661546293, + "version": "1.3.3" + }, + "fastavro-1.3.3-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "69d51d0927bb2b12c53e533d7ebfc505", + "name": "fastavro", + "sha256": "76699187f7dd2a4449e343955a8c03a6c28b49bf374c2ce056c3a1f0c1719a47", + "size": 481152, + "subdir": "linux-64", + "timestamp": 1615661549634, + "version": "1.3.3" + }, + "fastavro-1.3.4-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "2f304869807dac1fe5b681ff0bec7723", + "name": "fastavro", + "sha256": "376a1f8e98f0e9de28524a326cc1e966ce2427fe51093b76b98118e0834c2a65", + "size": 445677, + "subdir": "linux-64", + "timestamp": 1616268959089, + "version": "1.3.4" + }, + "fastavro-1.3.4-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "3ad16dbc527549e6435e4387df4c51d1", + "name": "fastavro", + "sha256": "54b70c6c935f28e3bad50f58bb10409cacbb03045a85d04f1883ebc78dc29562", + "size": 449228, + "subdir": "linux-64", + "timestamp": 1616268963787, + "version": "1.3.4" + }, + "fastavro-1.3.4-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "7924636d0e881dfbe9ac6d95b1e86296", + "name": "fastavro", + "sha256": "dae8ba64303762aa501c09beaded2458453a6ee430dd60174779541343128139", + "size": 471280, + "subdir": "linux-64", + "timestamp": 1616266938857, + "version": "1.3.4" + }, + "fastavro-1.3.4-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "c0fe14d24369b5125b929661c91b35bb", + "name": "fastavro", + "sha256": "229cb8c4015a0bd464455f9078137b71f23d1d16c0a49db8f6b95c27f68781c6", + "size": 477081, + "subdir": "linux-64", + "timestamp": 1616268269274, + "version": "1.3.4" + }, + "fastavro-1.3.5-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "0b4d9e10953cac2983bc349fb7f32a94", + "name": "fastavro", + "sha256": "070363161f4246fe5df3b1c27b9b2b815e672e2b5ee791f6d940ccc2b437c7ff", + "size": 455173, + "subdir": "linux-64", + "timestamp": 1617219860649, + "version": "1.3.5" + }, + "fastavro-1.3.5-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "aad2600b0138d39f568bd1da87f98c43", + "name": "fastavro", + "sha256": "52078e44681e1ed2e57bd7461ffb60de5740bb71bbae60a752259746fb64b1ec", + "size": 458166, + "subdir": "linux-64", + "timestamp": 1617222343993, + "version": "1.3.5" + }, + "fastavro-1.3.5-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "f6bb393e71839118a6c67ae761d7c813", + "name": "fastavro", + "sha256": "1d98f4dc8ebbf429715e8d3e685d6cdacdfeab27bc3078f3aeb0d7eb1ec1936c", + "size": 486295, + "subdir": "linux-64", + "timestamp": 1617222320395, + "version": "1.3.5" + }, + "fastavro-1.3.5-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "a1f787df098dc7610844df2200170a39", + "name": "fastavro", + "sha256": "f16526e791d4ceebadb0d227a2d761110ebb32d3e701c4f97b5a62d36b8a06a9", + "size": 476345, + "subdir": "linux-64", + "timestamp": 1617222360624, + "version": "1.3.5" + }, + "fastavro-1.4.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "4104610edc35e04766db5c40510ca7d1", + "name": "fastavro", + "sha256": "07a0563b1c30f3cbaf9ad3a5b387dd4604b7db6b723113fd9fe756cba66e551b", + "size": 462475, + "subdir": "linux-64", + "timestamp": 1618690802749, + "version": "1.4.0" + }, + "fastavro-1.4.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "981899c62f9cbc6d3414803113e2c6bf", + "name": "fastavro", + "sha256": "7e16b554858f2de867c1a65a3fad6284e311b62fec978028803471a12b70b642", + "size": 449347, + "subdir": "linux-64", + "timestamp": 1618694048698, + "version": "1.4.0" + }, + "fastavro-1.4.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "caab6564725fbdaa946dbdf94ee3d704", + "name": "fastavro", + "sha256": "f21c44ee6bd76a5a8e98b0da860cfa6104636d5ed31855cb3a99b71641f3924d", + "size": 486484, + "subdir": "linux-64", + "timestamp": 1618694059093, + "version": "1.4.0" + }, + "fastavro-1.4.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "82435338f75237413c1e64bd94afa8b1", + "name": "fastavro", + "sha256": "a03988a7ca6414d19ab9053c7a68cb6ee9898611b3dad29ad41b27ee8f94dbeb", + "size": 482627, + "subdir": "linux-64", + "timestamp": 1618789080530, + "version": "1.4.0" + }, + "fastavro-1.4.1-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "ecc2e8eec3431b674b5aed0897be1c53", + "name": "fastavro", + "sha256": "0ab692126d51dd839d6d5bf02114162cc062177a05736b2cc87770be319d1b8b", + "size": 488795, + "subdir": "linux-64", + "timestamp": 1621431970457, + "version": "1.4.1" + }, + "fastavro-1.4.2-py36h7f8727e_0.tar.bz2": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "ae20653c413ff8ee5d1c1ff4dcc46e10", + "name": "fastavro", + "sha256": "6a9dc68fe9315ecbce13781f515a36d4429f9dc210f81c135dcf84932eb26a5f", + "size": 466122, + "subdir": "linux-64", + "timestamp": 1625077490914, + "version": "1.4.2" + }, + "fastavro-1.4.2-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "5042a3344b708e0ae06cbe4d85ed8c54", + "name": "fastavro", + "sha256": "9cc7f6f99d1aa01d3d531e03ccd3e66af77633fc6ff8701ce3782e7c100fec0e", + "size": 465391, + "subdir": "linux-64", + "timestamp": 1625077471945, + "version": "1.4.2" + }, + "fastavro-1.4.2-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "ed4c13d3284577a00f0e807698009280", + "name": "fastavro", + "sha256": "9c2f46065ac037c85867a57ba325c9125a2365097132545204179a3df58af536", + "size": 482755, + "subdir": "linux-64", + "timestamp": 1625071002066, + "version": "1.4.2" + }, + "fastavro-1.4.2-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ed7945544ac3cd0930c9ae3c7bb15813", + "name": "fastavro", + "sha256": "eb382ee1f58033a17682db2dccda1553726e70ed86e198e3d3175e106835f197", + "size": 514220, + "subdir": "linux-64", + "timestamp": 1625127143866, + "version": "1.4.2" + }, + "fastavro-1.4.3-py36h7f8727e_0.tar.bz2": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d694198fc008c718ddc13af71fc48617", + "name": "fastavro", + "sha256": "de75002214242fee7dfbb43c121f4ff7cd870e68ad92da308097c2d2e759ec2b", + "size": 479572, + "subdir": "linux-64", + "timestamp": 1632841022712, + "version": "1.4.3" + }, + "fastavro-1.4.3-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ad199cb2b1c9ade4365868aaad5b983", + "name": "fastavro", + "sha256": "26a14b052eb82b260adc5dfc2ef02698a98af68873fcd74a82376b540ab54578", + "size": 468428, + "subdir": "linux-64", + "timestamp": 1632841086129, + "version": "1.4.3" + }, + "fastavro-1.4.3-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "79d75b44973da020db079108019f6cf9", + "name": "fastavro", + "sha256": "dd6ef4beb8add065a9f170d17cbc74ff96acdd70400d703d07000596ecdb179f", + "size": 507214, + "subdir": "linux-64", + "timestamp": 1632841006787, + "version": "1.4.3" + }, + "fastavro-1.4.3-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3be7c9377d31d6356546c4979147f79d", + "name": "fastavro", + "sha256": "bc86bb3bb3a0962aab0ad3738f025524bb81c5837a7b0f649f5013ad4b07bce9", + "size": 512938, + "subdir": "linux-64", + "timestamp": 1626492995036, + "version": "1.4.3" + }, + "fastavro-1.4.7-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "20b106d207b93ccbed9bbc8f4ecb3b83", + "name": "fastavro", + "sha256": "857a7b7ce70f14a5fbb68e7c922fd0ac631e4c9a1ce9323002361b69a84e7975", + "size": 1856427, + "subdir": "linux-64", + "timestamp": 1640789946347, + "version": "1.4.7" + }, + "fastavro-1.4.7-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1df614dd0677d0c4c11494fcdaef6491", + "name": "fastavro", + "sha256": "b36032e4cd6bd09b41713875fccce10f91577662bb7da5b0e25b7283206f7874", + "size": 461096, + "subdir": "linux-64", + "timestamp": 1638961800596, + "version": "1.4.7" + }, + "fastavro-1.4.7-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f912706c08e897788290586283947dc7", + "name": "fastavro", + "sha256": "4e5857aa9a0eb20cb9ec030859ece7b2b951fbc98675e527c1ac7841745aefb6", + "size": 483781, + "subdir": "linux-64", + "timestamp": 1638975306103, + "version": "1.4.7" + }, + "fastavro-1.4.7-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fcea6266f281ef6bc9de5ba7a21dbeef", + "name": "fastavro", + "sha256": "77b55fb42809ccd6c0d9565aa220683be58e4fa5169f71d0adfac82dbebf4cf2", + "size": 495393, + "subdir": "linux-64", + "timestamp": 1638975315401, + "version": "1.4.7" + }, + "fastavro-1.7.0-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3ebbf5018acd3e2afac41c66d43e46a", + "name": "fastavro", + "sha256": "8d1a644216dc345627b4eb46427876550b673ca46a11726c37bccb12f7491381", + "size": 513678, + "subdir": "linux-64", + "timestamp": 1670513337336, + "version": "1.7.0" + }, + "fastavro-1.7.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3493ca963b415f609901d8cea09a7090", + "name": "fastavro", + "sha256": "55ead1e45212dc5030a82e41b97771ad6ddb4bdc576130d452e817fce0d0e8bb", + "size": 526022, + "subdir": "linux-64", + "timestamp": 1676839815476, + "version": "1.7.0" + }, + "fastavro-1.7.0-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba4ac833c7893bbcf7b384a8a1faf699", + "name": "fastavro", + "sha256": "efb9d7457c6d94522ae89e72eb07104e41be8d2ebd481bc282d2d29a328d5b3e", + "size": 493798, + "subdir": "linux-64", + "timestamp": 1670513384106, + "version": "1.7.0" + }, + "fastavro-1.7.0-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a8e50d9a7bfc0c0d029735a87cbb72b", + "name": "fastavro", + "sha256": "fb44789cb1fa86c9433d1997d2ae8a2a33ca93802e4ea9b77d6c35d416a58a7f", + "size": 517562, + "subdir": "linux-64", + "timestamp": 1670513429590, + "version": "1.7.0" + }, + "fastavro-1.7.0-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7193f2923389373d4ca26c08e06cf8e5", + "name": "fastavro", + "sha256": "47971b69f336a060a5a23c08973785d80b8db86f1a85e5b82ae1b31a6f3ca7a8", + "size": 514239, + "subdir": "linux-64", + "timestamp": 1670513292517, + "version": "1.7.0" + }, + "fastcache-1.0.2-py27h14c3975_2.tar.bz2": { + "build": "py27h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f68e08bb6c51b8da9fc92daa7d807405", + "name": "fastcache", + "sha256": "404b0605ad9c67f7b2f5460e0bf6a5cb6262567893283fe582b9fd9317808cfa", + "size": 30218, + "subdir": "linux-64", + "timestamp": 1518031539912, + "version": "1.0.2" + }, + "fastcache-1.0.2-py27h4cb8e01_0.tar.bz2": { + "build": "py27h4cb8e01_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c8c1db0cb99339eca8efa14351098b8", + "name": "fastcache", + "sha256": "f294227eda0b730711834f7513b1240e4ecd5a33338ef1e4f40a7931946176cf", + "size": 29839, + "subdir": "linux-64", + "timestamp": 1505742787495, + "version": "1.0.2" + }, + "fastcache-1.0.2-py35h14c3975_2.tar.bz2": { + "build": "py35h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "300bc498e05e66a079e2fc8d6c92ae0f", + "name": "fastcache", + "sha256": "cfc42c241ae0d7d6b9d8f5466e8cb353bca2949b0efe32aa8b396be5ba6bdd0c", + "size": 30373, + "subdir": "linux-64", + "timestamp": 1518031667907, + "version": "1.0.2" + }, + "fastcache-1.0.2-py35hec2bbaa_0.tar.bz2": { + "build": "py35hec2bbaa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62dce0e5a86bb3c3ea594466cd4403f3", + "name": "fastcache", + "sha256": "dc3afeed77b5d36e24fc722ea6b318cfe4c3b0a16388e115977e4cbd0a2864c1", + "size": 30023, + "subdir": "linux-64", + "timestamp": 1505742839495, + "version": "1.0.2" + }, + "fastcache-1.0.2-py36h14c3975_2.tar.bz2": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1c51264dd8fb568b28a6ecb6162ef43", + "name": "fastcache", + "sha256": "2de84afa3c70ca18230e4b38adf901a721cb28ccf82f3a0191be8be2fb4ffbc4", + "size": 30208, + "subdir": "linux-64", + "timestamp": 1518031518610, + "version": "1.0.2" + }, + "fastcache-1.0.2-py36h5b0c431_0.tar.bz2": { + "build": "py36h5b0c431_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "40065e12d950e78fa06a48f57aad32d6", + "name": "fastcache", + "sha256": "b7fbaa043fd9042646847269db003924a400d0cd6837fda0388ab1422a786512", + "size": 29893, + "subdir": "linux-64", + "timestamp": 1505742887049, + "version": "1.0.2" + }, + "fastcache-1.0.2-py37h14c3975_2.tar.bz2": { + "build": "py37h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e059cc48acbec40567f0c2483e8d64b", + "name": "fastcache", + "sha256": "fe82e2491eaa21330ae728cd7b1bc6b1f0ac51a8539a80680f8050c16423b3b3", + "size": 30101, + "subdir": "linux-64", + "timestamp": 1530876437717, + "version": "1.0.2" + }, + "fastcache-1.1.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0fda49373b7ef6a05a739441c99002db", + "name": "fastcache", + "sha256": "1de538c820628d8a4b10e40bd58b82f69eb49106298d4fd488ac8f3037daf9d4", + "size": 31609, + "subdir": "linux-64", + "timestamp": 1557506988688, + "version": "1.1.0" + }, + "fastcache-1.1.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "06fe1222c742035ce744ff026bae2f4b", + "name": "fastcache", + "sha256": "abad6a2f15f130ca112eadad2852d5650dd5785f74f018892faee85b89dd67a9", + "size": 52151, + "subdir": "linux-64", + "timestamp": 1640789971784, + "version": "1.1.0" + }, + "fastcache-1.1.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a810a954bfd1b086887cbbfa65091eb5", + "name": "fastcache", + "sha256": "e475dd8cdb9e7a3ece78eeefe7ad75517c7afe281cc74b7cf30348fc76b390ec", + "size": 37805, + "subdir": "linux-64", + "timestamp": 1676852276755, + "version": "1.1.0" + }, + "fastcache-1.1.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1d2bc082d0ab6cf78700ffae9d4ac14", + "name": "fastcache", + "sha256": "6e55bb3d3df14480f13a4f7b3a212b5a92ad46df5edd6d879700e70b4691b754", + "size": 31651, + "subdir": "linux-64", + "timestamp": 1557507091745, + "version": "1.1.0" + }, + "fastcache-1.1.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66f5bcbb99f0a6fdd0ea5e9847c3f99c", + "name": "fastcache", + "sha256": "5bb2947542548b75787dc23856e84b2ec30ad81b30ec10c64cbabe6d7430f517", + "size": 31674, + "subdir": "linux-64", + "timestamp": 1557506998178, + "version": "1.1.0" + }, + "fastcache-1.1.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc2a2ceac4762c21efffdc9afce39afb", + "name": "fastcache", + "sha256": "e0411c5053dc9858058882adcfd50ce8c087070f34a087a7d487eb5b1e958883", + "size": 37508, + "subdir": "linux-64", + "timestamp": 1572880642654, + "version": "1.1.0" + }, + "fastcache-1.1.0-py39he8ac12f_0.tar.bz2": { + "build": "py39he8ac12f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d24104b49e2eb4314c14a0c0d3918afe", + "name": "fastcache", + "sha256": "b7df17c666c4bcf4cc80fb9dc2c6b06e44847c4afe65a640c6d2fccb3566c05f", + "size": 32293, + "subdir": "linux-64", + "timestamp": 1607571313944, + "version": "1.1.0" + }, + "fastcluster-1.1.26-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "9e4b62b9aad9d98dce3f096504fb6cc7", + "name": "fastcluster", + "sha256": "de1c143a5254196e4b06607a333fa2fffbeaf9b28cd46b9d0c915780a409d780", + "size": 169483, + "subdir": "linux-64", + "timestamp": 1640790001278, + "version": "1.1.26" + }, + "fastcluster-1.1.26-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "ad13795ddbe5bbd6ddd7b97781eda36d", + "name": "fastcluster", + "sha256": "3e35e86028fa588dd8fecc932eb8e5f0ba48ea751d5a468901350e8525918991", + "size": 49825, + "subdir": "linux-64", + "timestamp": 1676852299528, + "version": "1.1.26" + }, + "fastcluster-1.1.26-py36h295c915_0.tar.bz2": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "77c11157e5c3bf56c1307d28d803452a", + "name": "fastcluster", + "sha256": "5c890ff482e76de5616c9e8537d9a90b9e51cc3337926291e0cfd5f95d9a0581", + "size": 49406, + "subdir": "linux-64", + "timestamp": 1633433586324, + "version": "1.1.26" + }, + "fastcluster-1.1.26-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "65d3e543c8dbf1fc545e931cdc24bd49", + "name": "fastcluster", + "sha256": "33b9094ecfad926eeb916e0de2ce61e30b3ecdedd4e3731e36cd327c07e6316a", + "size": 49291, + "subdir": "linux-64", + "timestamp": 1633422872490, + "version": "1.1.26" + }, + "fastcluster-1.1.26-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "7800a101c01b3bc41efaf89855834ea8", + "name": "fastcluster", + "sha256": "3509c19a216eca6cd08401bd5da83f4506e745f08daf92bb038b8b7ec6cbc619", + "size": 49323, + "subdir": "linux-64", + "timestamp": 1633433554061, + "version": "1.1.26" + }, + "fastcluster-1.1.26-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20.3,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "175935b2f5b2c40406d9716d95f6593e", + "name": "fastcluster", + "sha256": "4c061cea4a2fafee09f19757176e7a5cad8da382fe6efaba86b8b2439454bad6", + "size": 49259, + "subdir": "linux-64", + "timestamp": 1633432981629, + "version": "1.1.26" + }, + "fastcluster-1.2.4-py36h295c915_0.tar.bz2": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "c1a2da46eadaad394375f70d718b809b", + "name": "fastcluster", + "sha256": "05e3bcd50135abcc834480c969a7ca54e573c6cfab7579d232bf945f998f5566", + "size": 49405, + "subdir": "linux-64", + "timestamp": 1633429531428, + "version": "1.2.4" + }, + "fastcluster-1.2.4-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "788f8a7de5ef568d588a28a99faf5139", + "name": "fastcluster", + "sha256": "125b98a88c24bef54caf2c2f6fc1fc644a6b5be54f512d6996c362436b12bd0b", + "size": 49275, + "subdir": "linux-64", + "timestamp": 1633429321191, + "version": "1.2.4" + }, + "fastcluster-1.2.4-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "9559719b2de87032221fa8b3479f64ea", + "name": "fastcluster", + "sha256": "3b0f750a948a57183bbd2e1bedd45a240de27980ed74323dff81c251d31e0201", + "size": 49330, + "subdir": "linux-64", + "timestamp": 1633418815631, + "version": "1.2.4" + }, + "fastcluster-1.2.4-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20.3,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "3cf9469f3a4e9c2a541b7d3cdc7ffcb2", + "name": "fastcluster", + "sha256": "ca8c5388a7cde85d831c1ff5c07014f519943d9752fe59a521d2e4783d5b0e5a", + "size": 49291, + "subdir": "linux-64", + "timestamp": 1633429502695, + "version": "1.2.4" + }, + "fastparquet-0.1.2-py27h934da83_0.tar.bz2": { + "build": "py27h934da83_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11", + "pandas", + "pytest", + "python >=2.7,<2.8.0a0", + "thrift >=0.10" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "fa68469cccb63e98014c310c317897c2", + "name": "fastparquet", + "sha256": "5e273eecafd07fa9797dae8502644ceef4a6a4c7e77657b39d9403d2e48739b1", + "size": 214184, + "subdir": "linux-64", + "timestamp": 1505742977675, + "version": "0.1.2" + }, + "fastparquet-0.1.2-py35hba653af_0.tar.bz2": { + "build": "py35hba653af_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11", + "pandas", + "pytest", + "python >=3.5,<3.6.0a0", + "thrift >=0.10" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "08212b18ba99fde4b87f21b849d43779", + "name": "fastparquet", + "sha256": "a3ce97611710d03a3ba2b99e98ca7b53ad9bcc4af2098fa14e386ab6b19cc21e", + "size": 209501, + "subdir": "linux-64", + "timestamp": 1505742998726, + "version": "0.1.2" + }, + "fastparquet-0.1.2-py36hd59b1b2_0.tar.bz2": { + "build": "py36hd59b1b2_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11", + "pandas", + "pytest", + "python >=3.6,<3.7.0a0", + "thrift >=0.10" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "f354c1d43e0e95897ab1c73739360d54", + "name": "fastparquet", + "sha256": "6991c0bf45cae824a45bba5a0037a2fc698534a28c5c2ce23ae0c1d46bdf6b29", + "size": 208643, + "subdir": "linux-64", + "timestamp": 1505743019639, + "version": "0.1.2" + }, + "fastparquet-0.1.3-py27hc8d2e31_0.tar.bz2": { + "build": "py27hc8d2e31_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytest", + "python >=2.7,<2.8.0a0", + "thrift >=0.10" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "3efedde89df7de285c737c8301e28bbc", + "name": "fastparquet", + "sha256": "cc0baac6ffdb56ab419b5cd70889ce7c0b966f3350549f0f85c97660bfd81c70", + "size": 215722, + "subdir": "linux-64", + "timestamp": 1509052903909, + "version": "0.1.3" + }, + "fastparquet-0.1.3-py35hd8c2413_0.tar.bz2": { + "build": "py35hd8c2413_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytest", + "python >=3.5,<3.6.0a0", + "thrift >=0.10" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "1cd6ea64b4dc980edaa4094fbfe914d4", + "name": "fastparquet", + "sha256": "7536fcbb50e9e24f42adbb4cd3d31465e909c31fe65c60a00779374218535f0a", + "size": 211272, + "subdir": "linux-64", + "timestamp": 1509052720489, + "version": "0.1.3" + }, + "fastparquet-0.1.3-py36h49281c8_0.tar.bz2": { + "build": "py36h49281c8_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytest", + "python >=3.6,<3.7.0a0", + "thrift >=0.10" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "8f15046a1d114d132a2095792a1f7500", + "name": "fastparquet", + "sha256": "5b6d3f6fba8328a393fe2dc81872dc6c1d4fae5061ff367dc8ea7244ec7cc398", + "size": 209105, + "subdir": "linux-64", + "timestamp": 1509052916660, + "version": "0.1.3" + }, + "fastparquet-0.1.4-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=2.7,<2.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "1c2bbaa85fa1eb4ade43837b3b2b7161", + "name": "fastparquet", + "sha256": "d75e43921d70151a5097f4bd268bb0bdca9f1e771a695e751dd998f3ce130ff7", + "size": 223299, + "subdir": "linux-64", + "timestamp": 1517417507159, + "version": "0.1.4" + }, + "fastparquet-0.1.4-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.5,<3.6.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "e6b456dd51e3062e28b04af8b785804c", + "name": "fastparquet", + "sha256": "24e1d2548a8f879fcbde2a594ea791c2cf09cb7879df3f2ab92a03bf91ec9711", + "size": 219265, + "subdir": "linux-64", + "timestamp": 1517417661761, + "version": "0.1.4" + }, + "fastparquet-0.1.4-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "3f06a176a69f2747b1bc58c9f8cf5b38", + "name": "fastparquet", + "sha256": "4987247a2f11c22459c44b6fc643f4d6f723b244bbe4a07da0820dfcddebb0b6", + "size": 218235, + "subdir": "linux-64", + "timestamp": 1517417656074, + "version": "0.1.4" + }, + "fastparquet-0.1.5-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=2.7,<2.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "4707b4206b177b1d16b71324910ab323", + "name": "fastparquet", + "sha256": "56057bdd871c3e3a1b5fc5a240026dd1e1b87e13877fc8da6c8d1ca3f587ba8d", + "size": 228611, + "subdir": "linux-64", + "timestamp": 1530876623114, + "version": "0.1.5" + }, + "fastparquet-0.1.5-py27h3010b51_0.tar.bz2": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=2.7,<2.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "e60b93e70f2b05b2ed0945b08fd4d91f", + "name": "fastparquet", + "sha256": "38ff23fb3b0e3c15d05ccfd246c85d25cb6028217d41d593c446f80b5bb40ca4", + "size": 225108, + "subdir": "linux-64", + "timestamp": 1522709064587, + "version": "0.1.5" + }, + "fastparquet-0.1.5-py35h3010b51_0.tar.bz2": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.5,<3.6.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "3e84236612c0c2b313577909be8699ac", + "name": "fastparquet", + "sha256": "93df2b02fa398a2727a9824b184a3e2dceae660f7b84169651dfcaa0d371788e", + "size": 221419, + "subdir": "linux-64", + "timestamp": 1522709075209, + "version": "0.1.5" + }, + "fastparquet-0.1.5-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "7cb9f8e2f38e80dae39db1e1dd7c011e", + "name": "fastparquet", + "sha256": "0e35115ded2072f4a70499843455c605f3c0215a346d354002da0601afe73e36", + "size": 224087, + "subdir": "linux-64", + "timestamp": 1530876547053, + "version": "0.1.5" + }, + "fastparquet-0.1.5-py36h3010b51_0.tar.bz2": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "ffe377805649212c18706440a75bd077", + "name": "fastparquet", + "sha256": "68cf35d4531aef42829af3f259958ec73c408324984ec6f29e25d12e2c7c815f", + "size": 220801, + "subdir": "linux-64", + "timestamp": 1522708999469, + "version": "0.1.5" + }, + "fastparquet-0.1.5-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "72bb929e01afce6ea25b9d627528bbf8", + "name": "fastparquet", + "sha256": "658b9ca08e723aca2b11b3faebace85ced55b04b9c0930e6e52ffbc8f932989a", + "size": 225024, + "subdir": "linux-64", + "timestamp": 1530876584960, + "version": "0.1.5" + }, + "fastparquet-0.1.6-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=2.7,<2.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "218571151d311cadb58a6b39cda2c7c6", + "name": "fastparquet", + "sha256": "0f2fd50614e099bd1d92749dfc350957198d11fc617b9e5727ef0c2285a978be", + "size": 234259, + "subdir": "linux-64", + "timestamp": 1535425704470, + "version": "0.1.6" + }, + "fastparquet-0.1.6-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.5,<3.6.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "90a8c43c2ce0318ef205ea8b6c523916", + "name": "fastparquet", + "sha256": "a4a986add5babf41359260e2c338f5d7b0f114d06b89f8cf340a4095e69dd913", + "size": 230662, + "subdir": "linux-64", + "timestamp": 1535425910096, + "version": "0.1.6" + }, + "fastparquet-0.1.6-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "52e0e1d2bf0151fed5801db420684da4", + "name": "fastparquet", + "sha256": "cca8487681f2a4bce26c0ee13a37fd4d59b72e598eb2ac216a2cb29d86276d70", + "size": 229905, + "subdir": "linux-64", + "timestamp": 1535425652572, + "version": "0.1.6" + }, + "fastparquet-0.1.6-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "11f3d6c3bc4e5d4e195412c04b31d1ea", + "name": "fastparquet", + "sha256": "5d5f8dde1366e7ddbdabe38b1fd9573f5949811621641db4ff939df8f7929e13", + "size": 230679, + "subdir": "linux-64", + "timestamp": 1535425729621, + "version": "0.1.6" + }, + "fastparquet-0.2.1-py27hdd07704_1.tar.bz2": { + "build": "py27hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=2.7,<2.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "03af74d0a698c7d22d82067c642403b3", + "name": "fastparquet", + "sha256": "e0c9e7e8eb8196feda950484166b3b395acc8ad5a57e99b2f6ba3760016169ea", + "size": 247344, + "subdir": "linux-64", + "timestamp": 1549636253148, + "version": "0.2.1" + }, + "fastparquet-0.2.1-py36hdd07704_1.tar.bz2": { + "build": "py36hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "8602914cabb583ad27f5f464acd20049", + "name": "fastparquet", + "sha256": "42c623b31e52a4382c95a7ca6800df0ddd576e6c13eccbf74639a952a88d8e02", + "size": 237350, + "subdir": "linux-64", + "timestamp": 1549636239954, + "version": "0.2.1" + }, + "fastparquet-0.2.1-py37hdd07704_1.tar.bz2": { + "build": "py37hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "f392c09d19e3f4ef436744c1df02a4f3", + "name": "fastparquet", + "sha256": "4709e6f97701ad68e0473a5005c068c4ca4e20582ef9bad2b22ada8e620ee920", + "size": 244242, + "subdir": "linux-64", + "timestamp": 1549636226730, + "version": "0.2.1" + }, + "fastparquet-0.3.0-py27hdd07704_0.tar.bz2": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "python >=2.7,<2.8.0a0", + "six", + "thrift >=0.11.0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "8425550228c9d932594d831afbbe50f7", + "name": "fastparquet", + "sha256": "eb92ce7ab823ff1934758c03d7751a0306c32dde9eb22500e6f4e1f92d139a2a", + "size": 254042, + "subdir": "linux-64", + "timestamp": 1556065745665, + "version": "0.3.0" + }, + "fastparquet-0.3.0-py36hdd07704_0.tar.bz2": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "six", + "thrift >=0.11.0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "03e6ccd44e981ea87fe902c2742aac53", + "name": "fastparquet", + "sha256": "03a2cf9ec82deb72ae30445e73fccd814ddec02e2f64dd139160350fdcbd10e0", + "size": 244190, + "subdir": "linux-64", + "timestamp": 1556065748070, + "version": "0.3.0" + }, + "fastparquet-0.3.0-py37hdd07704_0.tar.bz2": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "six", + "thrift >=0.11.0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "02cfaf1af15c7d9e014a6d6fe338789a", + "name": "fastparquet", + "sha256": "7fc65af86a64714315a1245912eb2af95590a5680d45e4f7430b9f1fc98d75cf", + "size": 248751, + "subdir": "linux-64", + "timestamp": 1556065567267, + "version": "0.3.0" + }, + "fastparquet-0.3.2-py27hdd07704_0.tar.bz2": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "python >=2.7,<2.8.0a0", + "six", + "thrift >=0.11.0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "0c2fdf57b10ad71968bc113a09b3d960", + "name": "fastparquet", + "sha256": "1d6babf4b11dccd04a7f8d86526192be2f710a5440895752ecacb3b2b57e1086", + "size": 263879, + "subdir": "linux-64", + "timestamp": 1569351473872, + "version": "0.3.2" + }, + "fastparquet-0.3.2-py36hdd07704_0.tar.bz2": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "six", + "thrift >=0.11.0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "eca03f2060fa602957df986feb71c70c", + "name": "fastparquet", + "sha256": "d1cb80f6288d2ab009f78d390b3bd2a233c6a762ed11505a4489bc66e21265ea", + "size": 256207, + "subdir": "linux-64", + "timestamp": 1569351514594, + "version": "0.3.2" + }, + "fastparquet-0.3.2-py36heb32a55_0.tar.bz2": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.14.6,<2.0a0", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "six", + "thrift >=0.11.0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "312f6fb1e6f56ab6b97675390fb9e174", + "name": "fastparquet", + "sha256": "464ab8d38b0477b640afa61c045787b1a3aae09d2dc85ecd526a9018f6cd7b6e", + "size": 247951, + "subdir": "linux-64", + "timestamp": 1592380548107, + "version": "0.3.2" + }, + "fastparquet-0.3.2-py37hdd07704_0.tar.bz2": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "six", + "thrift >=0.11.0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "46ec5c634b34b00b9240b0c2abd99aa3", + "name": "fastparquet", + "sha256": "6840531f7ffdbd3b3df2746a66675181cb27669c3863a35c3bd0a82c4a881faa", + "size": 259483, + "subdir": "linux-64", + "timestamp": 1569351485759, + "version": "0.3.2" + }, + "fastparquet-0.3.2-py37heb32a55_0.tar.bz2": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.14.6,<2.0a0", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "six", + "thrift >=0.11.0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "cb9ae423f72cdf82634ee645fd756334", + "name": "fastparquet", + "sha256": "04243a1236d6f513c81be771353a18cdc4bc1ce85044ceedcc641707ce62579f", + "size": 249062, + "subdir": "linux-64", + "timestamp": 1592380535427, + "version": "0.3.2" + }, + "fastparquet-0.3.2-py38heb32a55_0.tar.bz2": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.14.6,<2.0a0", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "six", + "thrift >=0.11.0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "1b4197e52e58a2b1ef7cec90be68f540", + "name": "fastparquet", + "sha256": "be374457f23cbb4175add5ae9218067f8a8ce0c1f272eee1f44ba39ea2a92d22", + "size": 256452, + "subdir": "linux-64", + "timestamp": 1592380526741, + "version": "0.3.2" + }, + "fastparquet-0.3.3-py36heb32a55_0.tar.bz2": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "d10de5dd5106e3b1735cc98fb8659001", + "name": "fastparquet", + "sha256": "fd409f5d55c687cc849484ccb602e4ae9b818ddf8c6309d8bb20c71805b7408a", + "size": 257999, + "subdir": "linux-64", + "timestamp": 1598036464021, + "version": "0.3.3" + }, + "fastparquet-0.3.3-py37heb32a55_0.tar.bz2": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "bb380554291375e1187c04208341823a", + "name": "fastparquet", + "sha256": "a759d115fb4c0da5679cbf6008ff49aec33e4535ae48dd3b5c580a3631166d8e", + "size": 250379, + "subdir": "linux-64", + "timestamp": 1598036468063, + "version": "0.3.3" + }, + "fastparquet-0.3.3-py38heb32a55_0.tar.bz2": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "514beaea418b21aa3ab59637c559f4c1", + "name": "fastparquet", + "sha256": "ed47ca82c5bad14f7dd3306e7fb7d780f68c03b35368dbaa9882b9a969e85e55", + "size": 252907, + "subdir": "linux-64", + "timestamp": 1598036452604, + "version": "0.3.3" + }, + "fastparquet-0.4.0-py36heb32a55_0.tar.bz2": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "b37545df6ff108c232829113cfdc8cec", + "name": "fastparquet", + "sha256": "6e16162407f868e10ad0ca62ef045d5b0ca30ca861595f72e667934a3f853098", + "size": 258251, + "subdir": "linux-64", + "timestamp": 1598037895407, + "version": "0.4.0" + }, + "fastparquet-0.4.0-py37heb32a55_0.tar.bz2": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "4832ae7e10df921ac4e60affbad88531", + "name": "fastparquet", + "sha256": "077f97c7a85c24b14453fe75a241009ba2538ffd4cf6a4a9f34cb48f60212629", + "size": 258988, + "subdir": "linux-64", + "timestamp": 1598037884834, + "version": "0.4.0" + }, + "fastparquet-0.4.0-py38heb32a55_0.tar.bz2": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "4980a62948e189707cce0a6b7d5b5a4e", + "name": "fastparquet", + "sha256": "9881da11d64a641b9624bff95fda2025554bd261042d8d2c9a536bf39bbe2b18", + "size": 260425, + "subdir": "linux-64", + "timestamp": 1598037895517, + "version": "0.4.0" + }, + "fastparquet-0.4.1-py36heb32a55_0.tar.bz2": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "be90b6f6e96ed1cc732ddbdb2ed38b9f", + "name": "fastparquet", + "sha256": "35a70c0444cbb2e5683127bfc6d63b6fa5d00857dbc78130b066c15d6faf60a2", + "size": 5403048, + "subdir": "linux-64", + "timestamp": 1598038695758, + "version": "0.4.1" + }, + "fastparquet-0.4.1-py37heb32a55_0.tar.bz2": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "6034cbf8c86d67f96254c1ee13c34399", + "name": "fastparquet", + "sha256": "6f27c2f07470a2e8b7b3122a40da9e2421a57d4839346a65892d3e3ec166bc87", + "size": 5412613, + "subdir": "linux-64", + "timestamp": 1598038723986, + "version": "0.4.1" + }, + "fastparquet-0.4.1-py38heb32a55_0.tar.bz2": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "e9b2734d77c98300d4766113352df9ae", + "name": "fastparquet", + "sha256": "d537c357106e6e7939a7327957fe5a652f1d3bec5b2a15083b04be74ada68a0b", + "size": 5403383, + "subdir": "linux-64", + "timestamp": 1598038730770, + "version": "0.4.1" + }, + "fastparquet-0.4.2-py36h6323ea4_0.tar.bz2": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "b75ae8cf5a7de16cecb54c8433a9ef9f", + "name": "fastparquet", + "sha256": "fbea79ed702f22801d6c9a325fcda701d807c27e197f11b5e749f519c6a0c66a", + "size": 190033, + "subdir": "linux-64", + "timestamp": 1607969564742, + "version": "0.4.2" + }, + "fastparquet-0.4.2-py37h6323ea4_0.tar.bz2": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "9a22332059e6be368edd7f6e3a033d49", + "name": "fastparquet", + "sha256": "78c7239d4938864888d972a89b75653ac9216ed12f1fd2cf6eda75699855f7be", + "size": 188714, + "subdir": "linux-64", + "timestamp": 1607969529575, + "version": "0.4.2" + }, + "fastparquet-0.4.2-py38h6323ea4_0.tar.bz2": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "7ef3805d66e68ded6749ab1104736f0b", + "name": "fastparquet", + "sha256": "b55d9f7717db0730ae91784b38430048820f8465c3f81ee58d77b8e15d5ca96e", + "size": 192336, + "subdir": "linux-64", + "timestamp": 1607969565853, + "version": "0.4.2" + }, + "fastparquet-0.5.0-py310ha9d4c09_2.tar.bz2": { + "build": "py310ha9d4c09_2", + "build_number": 2, + "constrains": [ + "numpy >=1.18,<1.22" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "numba >=0.49", + "numpy >=1.21.5,<2.0a0", + "packaging", + "pandas >=1.1.0", + "python >=3.10,<3.11.0a0", + "thrift >=0.11" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c203bd39d2e00c7d0b04b5d656e6f65d", + "name": "fastparquet", + "sha256": "f9960b06a8acf7581e77ddd71eefdf5037ba8ef49e9cb9f51419d5b49a6309ba", + "size": 281981, + "subdir": "linux-64", + "timestamp": 1658500821948, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py36h6323ea4_0.tar.bz2": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "ba0ca219903c27b8375baec95a98fa03", + "name": "fastparquet", + "sha256": "e2ff3bdc6f1dd98750926b5ad5a4e4fa1ebb337e670b730ce5c2f741e830ccc2", + "size": 190090, + "subdir": "linux-64", + "timestamp": 1609265989487, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py36h6323ea4_1.tar.bz2": { + "build": "py36h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "923bbd2514e9185e05736d1124ca50ba", + "name": "fastparquet", + "sha256": "685a21bcdeec3a7a752d5a5b455725a2f5291c7a53ee9d49c503a06c146cffef", + "size": 189615, + "subdir": "linux-64", + "timestamp": 1610480463284, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py36hce1f21e_1.tar.bz2": { + "build": "py36hce1f21e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "74467834250eed15188009d4494d2e36", + "name": "fastparquet", + "sha256": "a9fa4da63197674cdf79a9caa9a18a9d9631321e35d211515a3247a6b0cd505a", + "size": 196270, + "subdir": "linux-64", + "timestamp": 1632742586462, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py37h6323ea4_0.tar.bz2": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "e81be9384c49e5f1b05514e5e17a0d42", + "name": "fastparquet", + "sha256": "0bb139b1c35291d4d6d7a4e474890a2242a6640c17bc0ca93bdc20cfd7074e19", + "size": 193127, + "subdir": "linux-64", + "timestamp": 1609265959270, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py37h6323ea4_1.tar.bz2": { + "build": "py37h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "dcf85da18582311cedf82da680218ff5", + "name": "fastparquet", + "sha256": "2c3ac67dee01f367074fc8508f4870781e52c520181d6da84e60ba75a8b6db99", + "size": 192613, + "subdir": "linux-64", + "timestamp": 1610480435219, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py37h7deecbd_2.tar.bz2": { + "build": "py37h7deecbd_2", + "build_number": 2, + "constrains": [ + "numpy >=1.18,<1.22" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "numba >=0.49", + "numpy >=1.16.6,<2.0a0", + "packaging", + "pandas >=1.1.0", + "python >=3.7,<3.8.0a0", + "thrift >=0.11" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f24c36afa85f0ef205803f9e504abe0c", + "name": "fastparquet", + "sha256": "746e5abb159cec477c1e6ae6675f63c7050b0491dba731ebe5920c853e312dcd", + "size": 191145, + "subdir": "linux-64", + "timestamp": 1658500665617, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py37hce1f21e_1.tar.bz2": { + "build": "py37hce1f21e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "1ad9af9bd85315c77f9d9810345d0779", + "name": "fastparquet", + "sha256": "8511598b9c4e20765a583861a5532ffdbbc25c176c6ddf3b7413d2d87fe16dbb", + "size": 191769, + "subdir": "linux-64", + "timestamp": 1632742563495, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py38h6323ea4_0.tar.bz2": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "a7624decb6b14b9e554c30ba3e694416", + "name": "fastparquet", + "sha256": "d1018262b7425ef4f7685c73c260e703652ac0d975a851afab482078622bb11a", + "size": 189693, + "subdir": "linux-64", + "timestamp": 1609265948058, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py38h6323ea4_1.tar.bz2": { + "build": "py38h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "04513dd9687c3e24602bd7dbc2d5ada3", + "name": "fastparquet", + "sha256": "3d118ad406520528b2341812941d8dd51b9856d2d7e9a22d9245ebd13ef569ae", + "size": 195086, + "subdir": "linux-64", + "timestamp": 1610480426195, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py38h7deecbd_2.tar.bz2": { + "build": "py38h7deecbd_2", + "build_number": 2, + "constrains": [ + "numpy >=1.18,<1.22" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "numba >=0.49", + "numpy >=1.16.6,<2.0a0", + "packaging", + "pandas >=1.1.0", + "python >=3.8,<3.9.0a0", + "thrift >=0.11" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8ca5334ce12675d3863a98ea51a9267b", + "name": "fastparquet", + "sha256": "f0cff0cfb1d7b0b2bbfe78e224b206fd49670914364d4f21a5acc56981bc8376", + "size": 192321, + "subdir": "linux-64", + "timestamp": 1658500714903, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py38hce1f21e_1.tar.bz2": { + "build": "py38hce1f21e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "6da43c62c5fc93d3000ecb04c2c361da", + "name": "fastparquet", + "sha256": "01e90febcd32312d29506fd8c6f0d86a28db583d0efeaed7ac1279b2d01f6d50", + "size": 195285, + "subdir": "linux-64", + "timestamp": 1632742568948, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py39h6323ea4_0.tar.bz2": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.9,<3.10.0a0", + "thrift >=0.11" + ], + "license": "BSD-3-Clause", + "md5": "4a9b3f105531ab08232b0baa9cb7a89e", + "name": "fastparquet", + "sha256": "715ee5b5fedcd2f627fdbec088f360f061f544f2498df2fa20f4e9dfc0d60c9e", + "size": 194950, + "subdir": "linux-64", + "timestamp": 1615918606368, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py39h7deecbd_2.tar.bz2": { + "build": "py39h7deecbd_2", + "build_number": 2, + "constrains": [ + "numpy >=1.18,<1.22" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "numba >=0.49", + "numpy >=1.16.6,<2.0a0", + "packaging", + "pandas >=1.1.0", + "python >=3.9,<3.10.0a0", + "thrift >=0.11" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a9d854d6c96221d50f85a8b12e48c162", + "name": "fastparquet", + "sha256": "003e760b30ed5e9322c3dac37feea0552ebb9b5e92d0b1a10267592154fdc675", + "size": 191820, + "subdir": "linux-64", + "timestamp": 1658500763114, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py39hce1f21e_1.tar.bz2": { + "build": "py39hce1f21e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.9,<3.10.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "b4cfefade4fb2f73c7578849ba715aba", + "name": "fastparquet", + "sha256": "e5eba25dade26ef3f57f8305c1ea2c3568412cb6fe8f23dc435cb789f7c2175b", + "size": 193290, + "subdir": "linux-64", + "timestamp": 1632742520549, + "version": "0.5.0" + }, + "fastrlock-0.3-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d4e2eb7296f06436689e345897a58c8f", + "name": "fastrlock", + "sha256": "f3941f5badf670c6dd0de0c1fccab6cf7ea30bdc67e718f5a0888ed227c3609f", + "size": 28356, + "subdir": "linux-64", + "timestamp": 1524327943139, + "version": "0.3" + }, + "fastrlock-0.3-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2dcfb33f1a2fff3e52441b488769c7c", + "name": "fastrlock", + "sha256": "23964c4e96dec4c9adabcda39456b2281e6c7218a5610905e58f571f398adb21", + "size": 29053, + "subdir": "linux-64", + "timestamp": 1524327943249, + "version": "0.3" + }, + "fastrlock-0.3-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce5e9648c883ed50d9bf6862fd453ce5", + "name": "fastrlock", + "sha256": "42777a344bde4aba5276eedcae94477884efc0098eb41f563f78c553da1c0f22", + "size": 29077, + "subdir": "linux-64", + "timestamp": 1524327683104, + "version": "0.3" + }, + "fastrlock-0.3-py37hf484d3e_0.tar.bz2": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9756dfde9375c32c63c09a2d0772e01", + "name": "fastrlock", + "sha256": "5282fc70cd77b267c87c426e54f657b779c14c8d415387cc98b5573856742175", + "size": 28974, + "subdir": "linux-64", + "timestamp": 1530814380458, + "version": "0.3" + }, + "fastrlock-0.4-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea607f8e019e00b3be226d2afc31b102", + "name": "fastrlock", + "sha256": "4619d8373419cc12bab61b63aa8d5b04a516cccca7cb97969a852f02996137d9", + "size": 30277, + "subdir": "linux-64", + "timestamp": 1535511229200, + "version": "0.4" + }, + "fastrlock-0.4-py35he6710b0_0.tar.bz2": { + "build": "py35he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "efcf12bb5ac363b13b164c8835f64ea9", + "name": "fastrlock", + "sha256": "50463e98da79033218a4b57192878bda346fb91e40698235dcec2e83276718c5", + "size": 30551, + "subdir": "linux-64", + "timestamp": 1535511239611, + "version": "0.4" + }, + "fastrlock-0.4-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "72b4fb695819998a093ba8462c1799fe", + "name": "fastrlock", + "sha256": "99fa138ecc9fcd03827fbde983149fffc9dc638c482bbe74af7a21b9f35172a7", + "size": 30553, + "subdir": "linux-64", + "timestamp": 1535511197979, + "version": "0.4" + }, + "fastrlock-0.4-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5f9801de284110033ce663e8a9ec314", + "name": "fastrlock", + "sha256": "1e3adb6d0d4261f6ca64da75bb11d69f349b2c40c12228ba19353db9b0b938d3", + "size": 30400, + "subdir": "linux-64", + "timestamp": 1535511296251, + "version": "0.4" + }, + "fastrlock-0.4-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e21500436f044f9072d8684577b22076", + "name": "fastrlock", + "sha256": "8e4e0ba8c07cd3126d541ee0a847331351c4f69cdf1d626b74f9e2136b78e6ef", + "size": 31059, + "subdir": "linux-64", + "timestamp": 1572357520917, + "version": "0.4" + }, + "fastrlock-0.5-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45bdc3017a3f8da9c5f7959e3055c5c2", + "name": "fastrlock", + "sha256": "3335a3a34a620e43639d0be346c9b9899905476e5aafc0e281d8fa9d90f72fc5", + "size": 83173, + "subdir": "linux-64", + "timestamp": 1640790026258, + "version": "0.5" + }, + "fastrlock-0.5-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0607087c1b4a7ca5f7156ff729a587bd", + "name": "fastrlock", + "sha256": "4b1271b5f4d520da327e2b945976d23d92599a4f7799571f58507903fd55f41c", + "size": 31420, + "subdir": "linux-64", + "timestamp": 1676852319513, + "version": "0.5" + }, + "fastrlock-0.5-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4e3499c1de0e31ff9bab07ad53b707d", + "name": "fastrlock", + "sha256": "838e65ea556f72c42767fd5d0d6a78f5a4c504c279ba69136a3a1c524614526c", + "size": 33272, + "subdir": "linux-64", + "timestamp": 1599766709419, + "version": "0.5" + }, + "fastrlock-0.5-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "19ca4bc024d20eacbd945e4cd35f33e2", + "name": "fastrlock", + "sha256": "da9aa0e3a82a70ba10524f0126a1844fa24b2d26f603e22ce6c0bb0fdfa2f61a", + "size": 33189, + "subdir": "linux-64", + "timestamp": 1599766729813, + "version": "0.5" + }, + "fastrlock-0.5-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce9027c37097506ad24f7c6c7ecebcbe", + "name": "fastrlock", + "sha256": "385cf22de34f74580831ebdfb574a5fee3daaf10ebd242f619f44b6a1a378df3", + "size": 33524, + "subdir": "linux-64", + "timestamp": 1599766705650, + "version": "0.5" + }, + "fastrlock-0.5-py39he6710b0_0.tar.bz2": { + "build": "py39he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a474237ba5fa7a365b4610dd93697da7", + "name": "fastrlock", + "sha256": "a95c9f7219d19083341ae7389f1c9eda6789f628e01f116d7f02ff666137ce59", + "size": 33149, + "subdir": "linux-64", + "timestamp": 1610048070026, + "version": "0.5" + }, + "fastrlock-0.6-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be1a4020eac5c1218ea3500fa1e6027e", + "name": "fastrlock", + "sha256": "5851d02c621a52d146f86bc1233a452b08144266277f3e4bf4f2b27e3e55ef5e", + "size": 31593, + "subdir": "linux-64", + "timestamp": 1616528362919, + "version": "0.6" + }, + "fastrlock-0.6-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "699265491e1291de370c30622e58e7b8", + "name": "fastrlock", + "sha256": "c363b7f1852980adbe49910b3b44ed1f1132ceed4314ddc8be1df2608a5de55e", + "size": 31529, + "subdir": "linux-64", + "timestamp": 1616527930744, + "version": "0.6" + }, + "fastrlock-0.6-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b810a8ebc11c01b56a4275ef6cb971e", + "name": "fastrlock", + "sha256": "ada9bbaa17cfd61df41a2daeeecc735730c2f86282e1e206adab419b1371bd12", + "size": 31857, + "subdir": "linux-64", + "timestamp": 1616528366658, + "version": "0.6" + }, + "fastrlock-0.6-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4754c4d58c00092c2f4e4972ef32ed2a", + "name": "fastrlock", + "sha256": "b733862203f250be2a8144cd02151f1745e388ca0c17a5c7ec1707081a7b95fa", + "size": 31519, + "subdir": "linux-64", + "timestamp": 1616528355701, + "version": "0.6" + }, + "fasttsne-0.2.13-py36hdd07704_1.tar.bz2": { + "build": "py36hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.38.1", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "205b8154f7740efd133ae7782aee7011", + "name": "fasttsne", + "sha256": "355030cfe2140d080dd40f57ded3208f0e33f1e49415227dd7ff168d8aef4a3b", + "size": 445402, + "subdir": "linux-64", + "timestamp": 1547969572656, + "version": "0.2.13" + }, + "fasttsne-0.2.13-py37hdd07704_1.tar.bz2": { + "build": "py37hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.38.1", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "967805b6386195c2184a19c2534ffaf1", + "name": "fasttsne", + "sha256": "6218497b04830809b27532c5f02672f51786631d8b58adc6ea58282f45197c2a", + "size": 462221, + "subdir": "linux-64", + "timestamp": 1547969502556, + "version": "0.2.13" + }, + "faulthandler-3.1-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "de4e1612ed8c4feb71591889cbf0c616", + "name": "faulthandler", + "sha256": "c98b657b44dc71c57f9677f0893cbb4f5ca7d951f6d046db20a5dbeb1495a9b4", + "size": 17572, + "subdir": "linux-64", + "timestamp": 1529346531868, + "version": "3.1" + }, + "feedparser-5.2.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "90645f1f4014c2da8d4720b26396f3d9", + "name": "feedparser", + "sha256": "149198fe57eb852ade1fe29de9a07571bf8879ff59d02049930adcccbb541510", + "size": 82288, + "subdir": "linux-64", + "timestamp": 1537207058707, + "version": "5.2.1" + }, + "feedparser-5.2.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "dcf290a0cd3f352c4fc5a680622673cd", + "name": "feedparser", + "sha256": "fde90fef011ff80451d76b0122e387bcae38b3bdaaeb32c751748f3d9a38dbfb", + "size": 83566, + "subdir": "linux-64", + "timestamp": 1537207084146, + "version": "5.2.1" + }, + "feedparser-5.2.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "d46e9f4e81725a4659666ed552ac2380", + "name": "feedparser", + "sha256": "8ec688861d0a716e363935efbfca5931ea88d091e13ccc46c5d927fb5fec30c1", + "size": 82752, + "subdir": "linux-64", + "timestamp": 1537207101004, + "version": "5.2.1" + }, + "feedparser-5.2.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "12ae64c0f4619ab052d6d1d3d11e8ef3", + "name": "feedparser", + "sha256": "3b8539244580de957c19a930a7d7719afdbdf2237cb7d7e4b016a67bdfcc4b14", + "size": 82278, + "subdir": "linux-64", + "timestamp": 1537207025484, + "version": "5.2.1" + }, + "feedparser-5.2.1-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "a9f0e2512da4c83e153ea70529ddfa5b", + "name": "feedparser", + "sha256": "d1d6d2202abcb50a2616ba82b3a84158be43bfbf5de82d87eb8b5cdb8e551f80", + "size": 83381, + "subdir": "linux-64", + "timestamp": 1572357556284, + "version": "5.2.1" + }, + "feedparser-5.2.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "126acfc3f7d65c76c4386105c245f514", + "name": "feedparser", + "sha256": "a614619e489e88038a228c0456f7d22512e5596353886a3e2b7bd3c24ff8aeeb", + "size": 82122, + "subdir": "linux-64", + "timestamp": 1607007496279, + "version": "5.2.1" + }, + "feedparser-6.0.8-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "sgmllib3k" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "33aa23384b228d58e2b647efaa26b942", + "name": "feedparser", + "sha256": "5f4d5a75580f9564aa27bda301ac813ffdf7e17ec4ba1a2687d5f84820d4bc09", + "size": 93584, + "subdir": "linux-64", + "timestamp": 1640790045761, + "version": "6.0.8" + }, + "feedparser-6.0.8-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "sgmllib3k" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "1f2a29a8437a73f34fd81184f180cbf1", + "name": "feedparser", + "sha256": "f215ff68af509f85b4ce417aaa2810c33a8f22b4faddc92ad34fd46fca794625", + "size": 120960, + "subdir": "linux-64", + "timestamp": 1676907122074, + "version": "6.0.8" + }, + "feedparser-6.0.8-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "sgmllib3k" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "a789ad97893f86ff8e5a2bb5c0a693bb", + "name": "feedparser", + "sha256": "ade40818260c263cce2567d7b0b2e5ab4b1c970498e9c12adb964ef5f9b5ba27", + "size": 371897, + "subdir": "linux-64", + "timestamp": 1636039078858, + "version": "6.0.8" + }, + "feedparser-6.0.8-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "sgmllib3k" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "5042d116fe01feede427f47426d409fe", + "name": "feedparser", + "sha256": "896507aabd11dd67a2606e2b98194fe10a54bb44c8727b97c16c5033c4708bb8", + "size": 377603, + "subdir": "linux-64", + "timestamp": 1636038971948, + "version": "6.0.8" + }, + "feedparser-6.0.8-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "sgmllib3k" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "fb756a4de6e224b9d7c2e3b3fb32fbe5", + "name": "feedparser", + "sha256": "42567164e0737667fa7e932d9328a9c95cb606cd9717fad8016fc2ec4d45e80c", + "size": 367442, + "subdir": "linux-64", + "timestamp": 1636027071653, + "version": "6.0.8" + }, + "ffmpeg-3.4-h7264315_0.tar.bz2": { + "build": "h7264315_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.2.0", + "libopus >=1.2.1,<2.0a0", + "libstdcxx-ng >=7.2.0", + "libvpx >=1.6.1,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "78883f6105af27b3389165f3b197219c", + "name": "ffmpeg", + "sha256": "253ebc435b83b3c8916d5dd04fbce1be4ef2e9e715b2f566b364c9a6a69516d1", + "size": 8400073, + "subdir": "linux-64", + "timestamp": 1512489786386, + "version": "3.4" + }, + "ffmpeg-3.4-h7985aa0_0.tar.bz2": { + "build": "h7985aa0_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.2.0", + "libopus >=1.2.1,<2.0a0", + "libstdcxx-ng >=7.2.0", + "libvpx >=1.7.0,<1.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "b13f62b3058c137d168441ef766a7dee", + "name": "ffmpeg", + "sha256": "d6852d08229c1993037410e02cab885b1abb6459d3a65f121e115c63267f22d9", + "size": 8399576, + "subdir": "linux-64", + "timestamp": 1530807868145, + "version": "3.4" + }, + "ffmpeg-4.0-h04d0a96_0.tar.bz2": { + "build": "h04d0a96_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "freetype >=2.8,<2.9.0a0", + "libgcc-ng >=7.2.0", + "libopus >=1.2.1,<2.0a0", + "libstdcxx-ng >=7.2.0", + "libvpx >=1.7.0,<1.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 3", + "md5": "76ed07d5b6f8a9c43e24798757e29c35", + "name": "ffmpeg", + "sha256": "a325db087da1dc4ff75889dfc32c19db67843e80faede6e4af868881f346b37e", + "size": 77303846, + "subdir": "linux-64", + "timestamp": 1526323943701, + "version": "4.0" + }, + "ffmpeg-4.0-hcdf2ecd_0.tar.bz2": { + "build": "hcdf2ecd_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.2.0", + "libopus >=1.2.1,<2.0a0", + "libstdcxx-ng >=7.2.0", + "libvpx >=1.7.0,<1.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 3", + "md5": "a82fe075b502fadf938ac30267bce2b5", + "name": "ffmpeg", + "sha256": "77d38088a9e005efd7a8ecfffcd1f8c35027161fcaf0406a36dcc03edb68827b", + "size": 77291021, + "subdir": "linux-64", + "timestamp": 1531089119627, + "version": "4.0" + }, + "ffmpeg-4.2-h1a5d6f3_0.tar.bz2": { + "build": "h1a5d6f3_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "freetype >=2.9.1,<3.0a0", + "gmp >=6.1.2", + "lame >=3.100,<3.101.0a0", + "libgcc-ng >=7.3.0", + "libopus >=1.3,<2.0a0", + "libstdcxx-ng >=7.3.0", + "libvpx >=1.7.0,<1.8.0a0", + "openh264 >=1.8.0,<1.9.0a0", + "openssl >=1.1.1d,<1.1.2a", + "x264 >=1!152.20180806,<1!153", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 3", + "md5": "722f99c8cc8164af30261019a9b20b17", + "name": "ffmpeg", + "sha256": "85130370c021b7eb914ce766a87c23fee6e8246c08307243a9087b552f7a0b1d", + "size": 84446861, + "subdir": "linux-64", + "timestamp": 1576692476884, + "version": "4.2" + }, + "ffmpeg-4.2.2-h20bf706_0.tar.bz2": { + "build": "h20bf706_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "freetype >=2.9.1,<3.0a0", + "gmp >=6.1.2", + "gnutls >=3.6.5,<3.7.0a0", + "lame >=3.100,<3.101.0a0", + "libgcc-ng >=7.3.0", + "libopus >=1.3.1,<2.0a0", + "libvpx >=1.7.0,<1.8.0a0", + "openh264 >=2.1.0,<2.2.0a0", + "x264 >=1!157.20191217,<1!158", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 3", + "md5": "45f245147704c070d2e3861d0a761f13", + "name": "ffmpeg", + "sha256": "15aedb68ecae6b79fe56d1a14be501af5a1692420094bad5d7dd7005cbc8226c", + "size": 84423619, + "subdir": "linux-64", + "timestamp": 1587155035511, + "version": "4.2.2" + }, + "fftw-3.3.8-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 2", + "md5": "4b15c8ebb5d51094a9e369597b91715f", + "name": "fftw", + "sha256": "2ab757c3ebcda1f9b3a7cd1963017e788dd988fe441a8428869bbf92bbecab50", + "size": 4012115, + "subdir": "linux-64", + "timestamp": 1528733567738, + "version": "3.3.8" + }, + "fftw-3.3.8-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2", + "md5": "d9e9ead58c4a1a966ae7aa28b1687c04", + "name": "fftw", + "sha256": "d15cfe0c4867fbe3245815e9c8083f22e06d5e813a943efeed7c224016ed554f", + "size": 4065655, + "subdir": "linux-64", + "timestamp": 1541613129286, + "version": "3.3.8" + }, + "fftw-3.3.8-h7b6447c_1.tar.bz2": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2", + "md5": "482fa7e146a6d67b72bc7a1cad3bd114", + "name": "fftw", + "sha256": "9050d201c579f80331498e7bfa86cb3814fa1141b22f492c20c78393e6f8f2ba", + "size": 4072908, + "subdir": "linux-64", + "timestamp": 1541619763511, + "version": "3.3.8" + }, + "fftw-3.3.8-h7b6447c_2.tar.bz2": { + "build": "h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2", + "md5": "335d227bb75ff4113412ba9d3afd4597", + "name": "fftw", + "sha256": "e54fe632a82521b201253c5c7f91c81c8cdb83cba18ab9d002a934f35f284743", + "size": 4077616, + "subdir": "linux-64", + "timestamp": 1541708102573, + "version": "3.3.8" + }, + "fftw-3.3.8-h7b6447c_3.tar.bz2": { + "build": "h7b6447c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2", + "md5": "43cec2cbbff0ecb36e4e92c9782c8f79", + "name": "fftw", + "sha256": "7b4cf1d1c8a28722d4b878325c26da3c21dd530f7cf039b959764129e5f82a56", + "size": 4040372, + "subdir": "linux-64", + "timestamp": 1541922820942, + "version": "3.3.8" + }, + "fftw-3.3.9-h27cfd23_1.tar.bz2": { + "build": "h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2", + "md5": "7d40c13591f949a2032801059e2e6e06", + "name": "fftw", + "sha256": "c33e8d9b095f9db09ced6c9a1c64f893ef926e48e5e37f02c56395a8b1f9b988", + "size": 4100710, + "subdir": "linux-64", + "timestamp": 1607970357824, + "version": "3.3.9" + }, + "filelock-2.0.12-py27h38fa839_0.tar.bz2": { + "build": "py27h38fa839_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "md5": "e0f44e8f12c46bb400b62b6fb0a32ecf", + "name": "filelock", + "sha256": "be5400802dd93cfc9fa161ca67ce9ec510064cb1015ac3b0ec6458120dbcece7", + "size": 10823, + "subdir": "linux-64", + "timestamp": 1505957212074, + "version": "2.0.12" + }, + "filelock-2.0.12-py35h7855d60_0.tar.bz2": { + "build": "py35h7855d60_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain", + "md5": "110ebb658c637cb566618de8ef5e5853", + "name": "filelock", + "sha256": "e1a74a256cf0ffd1068c69dad21da3d709fd669f1857befd32337726032a77f6", + "size": 11009, + "subdir": "linux-64", + "timestamp": 1505957225059, + "version": "2.0.12" + }, + "filelock-2.0.12-py36hacfa1f5_0.tar.bz2": { + "build": "py36hacfa1f5_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "md5": "dc7002c92b3afdc05e7628d82528dd32", + "name": "filelock", + "sha256": "bcbebe1eb986b21582b8b17f4199a26b7e1b4a60d2c0ffe404c639e1429bff96", + "size": 11016, + "subdir": "linux-64", + "timestamp": 1505957237843, + "version": "2.0.12" + }, + "filelock-2.0.13-py27h61a9c69_0.tar.bz2": { + "build": "py27h61a9c69_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "d73cbb2cbe565f9227381d5dfae7817e", + "name": "filelock", + "sha256": "45a907dfaaa9e7f86889fcd00b243e22aadca2d0ffb805dd651e457672d287dc", + "size": 11521, + "subdir": "linux-64", + "timestamp": 1511286413278, + "version": "2.0.13" + }, + "filelock-2.0.13-py35h4160c53_0.tar.bz2": { + "build": "py35h4160c53_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "5ba0eac2d0a34c1a00e5023fa2d0c61a", + "name": "filelock", + "sha256": "0f992aabeefe04946a291654b8a5fbda2ae049a8237087897e89ead8228e0d25", + "size": 11691, + "subdir": "linux-64", + "timestamp": 1511286417303, + "version": "2.0.13" + }, + "filelock-2.0.13-py36h646ffb5_0.tar.bz2": { + "build": "py36h646ffb5_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "18fd2677e379345ee588822750091a4c", + "name": "filelock", + "sha256": "026b950a6204030230540a08d987fd412967a938b1b4d65c2024bfd86582ad84", + "size": 11691, + "subdir": "linux-64", + "timestamp": 1511286417175, + "version": "2.0.13" + }, + "filelock-3.0.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "587c3fac801a906d195ac437378e3989", + "name": "filelock", + "sha256": "4d00c2817b712f25541b339ff8a09b9a4b4540c39b3cf73cbf67e5abd642e82d", + "size": 13364, + "subdir": "linux-64", + "timestamp": 1541105314522, + "version": "3.0.10" + }, + "filelock-3.0.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "5373748b9308581d37a6ea2f0d1618b2", + "name": "filelock", + "sha256": "4efa7a5ba040694f849f0160d4d5b45a0c6b8f4c2edd06bdeabff50f4aee39a1", + "size": 13541, + "subdir": "linux-64", + "timestamp": 1541105507859, + "version": "3.0.10" + }, + "filelock-3.0.10-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "b52f875c075f061cfb45e5e2069e3b74", + "name": "filelock", + "sha256": "2bf86467bbc157b03aa4ecc826dc9b0e6fce1c676a7aea2bdd18ff056c3b1c38", + "size": 13546, + "subdir": "linux-64", + "timestamp": 1541105309293, + "version": "3.0.10" + }, + "filelock-3.0.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "6ffc786d4f9d3b68e977b79704ee8596", + "name": "filelock", + "sha256": "88f36c3c3eeb61ce0056840f5d2f311a968bf30427623e0e8e766c7fd8cf473d", + "size": 12096, + "subdir": "linux-64", + "timestamp": 1519108209338, + "version": "3.0.4" + }, + "filelock-3.0.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "8363bdfd0f5cd70bfd6cd707b70c92e3", + "name": "filelock", + "sha256": "af29c11bb31c5fd3f7eaabf61bb853b9086fdc3927f89d0f14fe1a567618397b", + "size": 12308, + "subdir": "linux-64", + "timestamp": 1519108221511, + "version": "3.0.4" + }, + "filelock-3.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "b328948a97c082c6d958eaea96023a82", + "name": "filelock", + "sha256": "798ac8800f728433aa50b40e9e576fe1162788d37b3f97966584da5b9a6b519c", + "size": 12323, + "subdir": "linux-64", + "timestamp": 1519108223962, + "version": "3.0.4" + }, + "filelock-3.0.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "8f647dbdb0321c0dfbd0403d17664c67", + "name": "filelock", + "sha256": "0180deab3c0ba883fd9fddd9f191207ce71357ea7d0d48c8dbb2ba55f380a7de", + "size": 12227, + "subdir": "linux-64", + "timestamp": 1530811893950, + "version": "3.0.4" + }, + "filelock-3.0.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "91dfcad98eb00b6e132403f9e3703b62", + "name": "filelock", + "sha256": "d050bd48f961330f80cb8b95859bf5be995d18b2e3cae847eb8715da89475f50", + "size": 12100, + "subdir": "linux-64", + "timestamp": 1535379497436, + "version": "3.0.6" + }, + "filelock-3.0.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "23420cc06118c8374d35d7f18bbb2c33", + "name": "filelock", + "sha256": "c804042e27d252367ed85c2601feab9b7866846baf117924fbd6b9017d58007b", + "size": 12316, + "subdir": "linux-64", + "timestamp": 1535379225369, + "version": "3.0.6" + }, + "filelock-3.0.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "bf6c1817960d245e1238d9d10e4a062a", + "name": "filelock", + "sha256": "d6bfc120b03eeb6a6a041e9d5bc456464930e98aca61b5927eeb592c019368a4", + "size": 12291, + "subdir": "linux-64", + "timestamp": 1535379488238, + "version": "3.0.6" + }, + "filelock-3.0.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "ffb0f9416e07ec7c1f6f1307cbfbc4c7", + "name": "filelock", + "sha256": "5f4ad429e88938caf2d0ccabbc9d566b687c4a9686c7a82afdee174cbafb47c1", + "size": 12323, + "subdir": "linux-64", + "timestamp": 1535379517775, + "version": "3.0.6" + }, + "filelock-3.0.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "6e6a541c395ece11a9c1aede440569c4", + "name": "filelock", + "sha256": "d3acc02d510440a82d36c7ebf60f2a04c98e975a58080b4d21af59dcf7b874dd", + "size": 13057, + "subdir": "linux-64", + "timestamp": 1536777028397, + "version": "3.0.8" + }, + "filelock-3.0.8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "244de86a7eb961dea5a481658d4ebcfd", + "name": "filelock", + "sha256": "128eb09d42434e2e48ceacfc41cb4aabeef3aa86730d0f9043bfd2790e4f113e", + "size": 13251, + "subdir": "linux-64", + "timestamp": 1536777043586, + "version": "3.0.8" + }, + "filelock-3.0.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "999f5a33676235a3946bb21b530ff2ab", + "name": "filelock", + "sha256": "b9ff09f4a34fd72a930caa84fcde7fe10ae3661e434e7e42ec6eac38d9ae4ebb", + "size": 13224, + "subdir": "linux-64", + "timestamp": 1536777053619, + "version": "3.0.8" + }, + "filelock-3.0.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "1c0775455af99bab4b0e4c650b577e48", + "name": "filelock", + "sha256": "c0519458d50587d58ac642c6ec076cc43338545aac09c8fbf21faffb0eeed36e", + "size": 13230, + "subdir": "linux-64", + "timestamp": 1536776994737, + "version": "3.0.8" + }, + "filelock-3.0.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "47922c258df0c36eb69cf4dbc4c47b06", + "name": "filelock", + "sha256": "fe78cd1df3ac4a3216ee7e79a250412d980e17de31902273f23f59627f80d776", + "size": 13447, + "subdir": "linux-64", + "timestamp": 1539100208653, + "version": "3.0.9" + }, + "filelock-3.0.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "63abfa6b4b98f025e683a3ba8fa10588", + "name": "filelock", + "sha256": "e7c2e05ecbd4b5e7d396e1eac6571820064d56685b48c10d54a26cc424793b28", + "size": 13624, + "subdir": "linux-64", + "timestamp": 1539100215355, + "version": "3.0.9" + }, + "filelock-3.0.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "95d2c51cba0ae79956ee191a4561f729", + "name": "filelock", + "sha256": "352f7e9b6031015517b5cce9524216ed0263cb2533ad22024301c0c09a8edb6b", + "size": 13624, + "subdir": "linux-64", + "timestamp": 1539100177919, + "version": "3.0.9" + }, + "filelock-3.9.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Unlicense", + "license_family": "Public-Domain", + "md5": "26d015e07ce85cf4d2a714b2a42d5664", + "name": "filelock", + "sha256": "bb65981b8b371755c92e1aeca7307f6d15ecdb175f3550be072472c828acc19c", + "size": 17755, + "subdir": "linux-64", + "timestamp": 1672387160431, + "version": "3.9.0" + }, + "filelock-3.9.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Unlicense", + "license_family": "Public-Domain", + "md5": "eb35cabf4f8ee1c8fafde8a407a8acf3", + "name": "filelock", + "sha256": "8110ef0c4d08dac8e3153c007b957558ba750feae429371f8268fdc6f7d3264e", + "size": 20972, + "subdir": "linux-64", + "timestamp": 1676823036011, + "version": "3.9.0" + }, + "filelock-3.9.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Unlicense", + "license_family": "Public-Domain", + "md5": "decdbad249db8fb18c5daf9850cba26e", + "name": "filelock", + "sha256": "b8db000f0dcf87760e7f3f3fc92ef5704736019941439c0a7071f2e061170800", + "size": 17579, + "subdir": "linux-64", + "timestamp": 1672387215084, + "version": "3.9.0" + }, + "filelock-3.9.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Unlicense", + "license_family": "Public-Domain", + "md5": "f8ea3490f10c3437e3b4d85f92f38824", + "name": "filelock", + "sha256": "72694a8c0a80c321bf4d787b237039d6987f5f4af732779644ae5349f469bdf2", + "size": 17598, + "subdir": "linux-64", + "timestamp": 1672387187242, + "version": "3.9.0" + }, + "filelock-3.9.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Unlicense", + "license_family": "Public-Domain", + "md5": "af87e3db75efe2dc1d25f8e4bed12ce6", + "name": "filelock", + "sha256": "d67fe5d3064f54ba4459525e619a546d11408a2721e87145df7923c9bc347965", + "size": 17660, + "subdir": "linux-64", + "timestamp": 1672387242626, + "version": "3.9.0" + }, + "findpython-0.2.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb3a9a056f1dd46f8e64cbd8a844e837", + "name": "findpython", + "sha256": "f892c1bef8f2af4b534c47023289f87659ed5071d36c089177b03acf470a09e3", + "size": 32142, + "subdir": "linux-64", + "timestamp": 1669937857846, + "version": "0.2.2" + }, + "findpython-0.2.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e756328f1884ea1be104b87fc302bdfb", + "name": "findpython", + "sha256": "922ef16a0b26d73eef35a27011c2af1a01e4c55de87ba3876a45eec61f5dcc97", + "size": 41223, + "subdir": "linux-64", + "timestamp": 1676839832501, + "version": "0.2.2" + }, + "findpython-0.2.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "89d90e9acaf2fef88be664bba419fbdc", + "name": "findpython", + "sha256": "c62ea6def8ccc04f05de78586082bdbd346d507de14468c4eec8c0c9232b6cb2", + "size": 31627, + "subdir": "linux-64", + "timestamp": 1669937831421, + "version": "0.2.2" + }, + "findpython-0.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87aecb1852820a08c1e82b80546ffdf0", + "name": "findpython", + "sha256": "7cad0ceafd06556c69572954fa28aa837ed0029e4f6b1cbc993cebb3b0a8fa10", + "size": 31756, + "subdir": "linux-64", + "timestamp": 1669937778488, + "version": "0.2.2" + }, + "findpython-0.2.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "69b8ad3398e0ce7b80166655009acf12", + "name": "findpython", + "sha256": "618181092ce1b8a81a367df27af272851c496fbb9c8ff77ee9b74c2a893b8b30", + "size": 31781, + "subdir": "linux-64", + "timestamp": 1669937804770, + "version": "0.2.2" + }, + "fiona-1.7.10-py27hc43112a_0.tar.bz2": { + "build": "py27hc43112a_0", + "build_number": 0, + "depends": [ + "click-plugins", + "cligj", + "enum34", + "gdal 2.2.*", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "munch", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "shapely", + "six" + ], + "license": "BSD 3-Clause", + "md5": "aef916abc43910fbfd05aff6f36e2b60", + "name": "fiona", + "sha256": "0bec62f9dc14d13334bcaee3d3fcf316d10d29fb127211ccfebaeda2fbbf55cd", + "size": 778895, + "subdir": "linux-64", + "timestamp": 1511983847259, + "version": "1.7.10" + }, + "fiona-1.7.10-py35h82be5b1_0.tar.bz2": { + "build": "py35h82be5b1_0", + "build_number": 0, + "depends": [ + "click-plugins", + "cligj", + "gdal 2.2.*", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "munch", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools", + "shapely", + "six" + ], + "license": "BSD 3-Clause", + "md5": "6484b58e7f1a510efde6f29cf6d5b434", + "name": "fiona", + "sha256": "4026aab1c7be076f8929cfe3416eade573822f4900bb018d94a168c256e95901", + "size": 779433, + "subdir": "linux-64", + "timestamp": 1511983969343, + "version": "1.7.10" + }, + "fiona-1.7.10-py36h48a52f0_0.tar.bz2": { + "build": "py36h48a52f0_0", + "build_number": 0, + "depends": [ + "click-plugins", + "cligj", + "gdal 2.2.*", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "munch", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "shapely", + "six" + ], + "license": "BSD 3-Clause", + "md5": "92177a7e55409aea8e8558e0f8fe785f", + "name": "fiona", + "sha256": "319e805cf2131106f3a53b23c072524fd7afcf7990b737ac62741b1a189f2a0d", + "size": 784532, + "subdir": "linux-64", + "timestamp": 1511984077706, + "version": "1.7.10" + }, + "fiona-1.7.12-py27h3f37509_0.tar.bz2": { + "build": "py27h3f37509_0", + "build_number": 0, + "depends": [ + "click-plugins", + "cligj", + "enum34", + "gdal 2.2.*", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "shapely", + "six" + ], + "license": "BSD 3-Clause", + "md5": "d2cc7219b2185410ad13f9eebfe24e1e", + "name": "fiona", + "sha256": "46330adc4555e004f64c322c6f9bf6f80b08342b597755453a2812593a6ea4ce", + "size": 701781, + "subdir": "linux-64", + "timestamp": 1530877096309, + "version": "1.7.12" + }, + "fiona-1.7.12-py36h3f37509_0.tar.bz2": { + "build": "py36h3f37509_0", + "build_number": 0, + "depends": [ + "click-plugins", + "cligj", + "gdal 2.2.*", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "shapely", + "six" + ], + "license": "BSD 3-Clause", + "md5": "bbc0c9b8fddca266564ad3e446941735", + "name": "fiona", + "sha256": "cff552ebba5ff02023ffc273a16744f391913448252a6a047f450cb6d348d09b", + "size": 721006, + "subdir": "linux-64", + "timestamp": 1530876755800, + "version": "1.7.12" + }, + "fiona-1.7.12-py37h3f37509_0.tar.bz2": { + "build": "py37h3f37509_0", + "build_number": 0, + "depends": [ + "click-plugins", + "cligj", + "gdal 2.2.*", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "shapely", + "six" + ], + "license": "BSD 3-Clause", + "md5": "27885cfe10282c933872741839a8b1a8", + "name": "fiona", + "sha256": "9593685aa7d115caede2d274dc351d6e4c4b2f66ad8e9bdd7c07098560582c34", + "size": 716817, + "subdir": "linux-64", + "timestamp": 1530877317964, + "version": "1.7.12" + }, + "fiona-1.8.11-py27h41e4f33_0.tar.bz2": { + "build": "py27h41e4f33_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "enum34", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "9975aa691e492137954a4539b87d3b84", + "name": "fiona", + "sha256": "b29fa63250422f2e96d0137bc7b919087f9f01acd052a4e4aecca769d50fdc2f", + "size": 1083814, + "subdir": "linux-64", + "timestamp": 1573761086306, + "version": "1.8.11" + }, + "fiona-1.8.11-py36h41e4f33_0.tar.bz2": { + "build": "py36h41e4f33_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "ec1f83a44a8d10e074863138422bda1e", + "name": "fiona", + "sha256": "65e44540a3fd240a6cb68d4282752cb204c849c09a07cf831bd0326bccf0f140", + "size": 1001013, + "subdir": "linux-64", + "timestamp": 1573761086333, + "version": "1.8.11" + }, + "fiona-1.8.11-py37h41e4f33_0.tar.bz2": { + "build": "py37h41e4f33_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "1e804e70c5351d7469e0fb721f7ad77d", + "name": "fiona", + "sha256": "d3a5d1f6f73099c1eccde2aac5b1dd00ddb36def5e4066f7bc9de97e6d5c5981", + "size": 1126959, + "subdir": "linux-64", + "timestamp": 1573760987816, + "version": "1.8.11" + }, + "fiona-1.8.13.post1-py36hc820daa_0.tar.bz2": { + "build": "py36hc820daa_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "0d3b63f673ba848e8445a98c8f1475ff", + "name": "fiona", + "sha256": "95e15640240f5e8cf60aa8a0f8b921f85f375468e5efc719cbfabd0c191947e9", + "size": 1071732, + "subdir": "linux-64", + "timestamp": 1597154810002, + "version": "1.8.13.post1" + }, + "fiona-1.8.13.post1-py37hc820daa_0.tar.bz2": { + "build": "py37hc820daa_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "1bfa92a8d8f6750e49a9141b1ef1776e", + "name": "fiona", + "sha256": "1d0421af436d3ff750aea64790c9aa0338a33b0c46473a6a0fb069d3211a5410", + "size": 1037622, + "subdir": "linux-64", + "timestamp": 1597154792721, + "version": "1.8.13.post1" + }, + "fiona-1.8.13.post1-py38hc820daa_0.tar.bz2": { + "build": "py38hc820daa_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "c40804d0aabb8c8340b63a78a14d7a36", + "name": "fiona", + "sha256": "2805161e64f6dfc78a52cfa0cb7512103adbd507981912d523e99c6ad4ec6426", + "size": 1094071, + "subdir": "linux-64", + "timestamp": 1597154790852, + "version": "1.8.13.post1" + }, + "fiona-1.8.22-py310h1128e8f_0.tar.bz2": { + "build": "py310h1128e8f_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=11.2.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=11.2.0", + "munch", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22ac401739472656e168304023acaead", + "name": "fiona", + "sha256": "68d7c8bf4ab9d16d32a4836d692f5eb8471ff544a97e386e35e217d45524c76d", + "size": 1062781, + "subdir": "linux-64", + "timestamp": 1674252691083, + "version": "1.8.22" + }, + "fiona-1.8.22-py37h417a72b_0.tar.bz2": { + "build": "py37h417a72b_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "certifi", + "click >=4.0", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=11.2.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=11.2.0", + "munch", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6ecf68ef04bf9b03474d62ec37e86d19", + "name": "fiona", + "sha256": "64f333fd0e8f8cb0fab692732f96ad4e5950777983edeb52d7c71f4e04b59796", + "size": 1053088, + "subdir": "linux-64", + "timestamp": 1674252911217, + "version": "1.8.22" + }, + "fiona-1.8.22-py38h417a72b_0.tar.bz2": { + "build": "py38h417a72b_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=11.2.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=11.2.0", + "munch", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ab6734a96bcc7a489314bc68a89b4367", + "name": "fiona", + "sha256": "82d777b5780bd3b6fedb4afdd3ab86a33bb03fb673a4982fc8817a6a59fb1243", + "size": 1095534, + "subdir": "linux-64", + "timestamp": 1674252581565, + "version": "1.8.22" + }, + "fiona-1.8.22-py39h417a72b_0.tar.bz2": { + "build": "py39h417a72b_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=11.2.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=11.2.0", + "munch", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d41b5891e312b3de5c0228b1d2b9395", + "name": "fiona", + "sha256": "ccb42c3dbc2ae964f6a7e1502784814067786599c48b1363f66c13b998563ea5", + "size": 1081102, + "subdir": "linux-64", + "timestamp": 1674252798488, + "version": "1.8.22" + }, + "fiona-1.8.4-py27hc38cc03_0.tar.bz2": { + "build": "py27hc38cc03_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "enum34", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "e8ed9d6dba70f51fcef717a49ba33a93", + "name": "fiona", + "sha256": "4a923427fd281fbd9f2a4e0d026ddf661fb5e88e2daa4a6f78e331a07538f655", + "size": 1078181, + "subdir": "linux-64", + "timestamp": 1545417941359, + "version": "1.8.4" + }, + "fiona-1.8.4-py36hc38cc03_0.tar.bz2": { + "build": "py36hc38cc03_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "b7dda76d2718abeb279f17745520f494", + "name": "fiona", + "sha256": "ceb7c5ba85996452abff570fe819247137c7cafb02c9ac683906c2069e301ab8", + "size": 1066122, + "subdir": "linux-64", + "timestamp": 1545417889425, + "version": "1.8.4" + }, + "fiona-1.8.4-py37hc38cc03_0.tar.bz2": { + "build": "py37hc38cc03_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "9d58c4ecfc534cadd823aab0ffeb5da9", + "name": "fiona", + "sha256": "5655b7583a8ddc503a44874910ca58fd6116cfd78d6f986d8f255773591e94db", + "size": 1094801, + "subdir": "linux-64", + "timestamp": 1545417913982, + "version": "1.8.4" + }, + "fiona-1.8.4-py38hc38cc03_0.tar.bz2": { + "build": "py38hc38cc03_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "c9bfff62280d690a330c36a0d6dc88da", + "name": "fiona", + "sha256": "d000dddcf66a757f3fb18330bd33d6e78d63a497cad029b9d4752065b9bff812", + "size": 1137993, + "subdir": "linux-64", + "timestamp": 1574413871152, + "version": "1.8.4" + }, + "fiona-1.9.1-py310h1128e8f_0.tar.bz2": { + "build": "py310h1128e8f_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "certifi", + "click >=8.0,<9.dev0", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=11.2.0", + "libgdal >=3.6.2,<3.7.0a0", + "libstdcxx-ng >=11.2.0", + "munch >=2.3.2", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools", + "shapely" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cb98e45f665bb29d498e548767e02eaf", + "name": "fiona", + "sha256": "6bd9e1799541acae07ad5dbe87354a38a8e406847fba1681401c58e0b26decd6", + "size": 1506516, + "subdir": "linux-64", + "timestamp": 1678226138526, + "version": "1.9.1" + }, + "fiona-1.9.1-py311hba01205_0.tar.bz2": { + "build": "py311hba01205_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "certifi", + "click >=8.0,<9.dev0", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=11.2.0", + "libgdal >=3.6.2,<3.7.0a0", + "libstdcxx-ng >=11.2.0", + "munch >=2.3.2", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0", + "setuptools", + "shapely" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1c7638e35cd9cab644071ae007408eac", + "name": "fiona", + "sha256": "8f56e95733726ca4e814bd19fda980ce99591b325a606a0fa91eccab9fcfe5da", + "size": 1516368, + "subdir": "linux-64", + "timestamp": 1678243202198, + "version": "1.9.1" + }, + "fiona-1.9.1-py38h417a72b_0.tar.bz2": { + "build": "py38h417a72b_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "certifi", + "click >=8.0,<9.dev0", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=11.2.0", + "libgdal >=3.6.2,<3.7.0a0", + "libstdcxx-ng >=11.2.0", + "munch >=2.3.2", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "shapely" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7fb69a307bed27497c3b8e4393a2b3e9", + "name": "fiona", + "sha256": "435b570879e33f252710aab974ccfc9c5a17690059e2c6c6660bbbcbe182f2a4", + "size": 1530015, + "subdir": "linux-64", + "timestamp": 1678226422936, + "version": "1.9.1" + }, + "fiona-1.9.1-py39h417a72b_0.tar.bz2": { + "build": "py39h417a72b_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "certifi", + "click >=8.0,<9.dev0", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=11.2.0", + "libgdal >=3.6.2,<3.7.0a0", + "libstdcxx-ng >=11.2.0", + "munch >=2.3.2", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "shapely" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e6d35c4d3544f7f47f0f129a5afc4149", + "name": "fiona", + "sha256": "6e887166ac89e30415418b2fccded0d2ad927abc715cf6c234b16cca4f61e083", + "size": 1515568, + "subdir": "linux-64", + "timestamp": 1678226278439, + "version": "1.9.1" + }, + "flake8-3.4.1-py27hbe79fde_0.tar.bz2": { + "build": "py27hbe79fde_0", + "build_number": 0, + "depends": [ + "configparser", + "enum34", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.4.0", + "pyflakes >=1.5.0,<1.6.0", + "python >=2.7,<2.8.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d5d5cd69fcb69fd8a508e21a9bc66755", + "name": "flake8", + "sha256": "c137d76e031a0bb4446d09775cc07a618b3f241083d4f9189325b85c258e559c", + "size": 118073, + "subdir": "linux-64", + "timestamp": 1505743148902, + "version": "3.4.1" + }, + "flake8-3.4.1-py35hbd4ebb8_0.tar.bz2": { + "build": "py35hbd4ebb8_0", + "build_number": 0, + "depends": [ + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.4.0", + "pyflakes >=1.5.0,<1.6.0", + "python >=3.5,<3.6.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8fa375850c2eeffc6968c3a7ffd9fff1", + "name": "flake8", + "sha256": "2940e5f126dbb308ef459a73455a86edb5af615601ad5342ea81a03fbf3f2c7f", + "size": 120783, + "subdir": "linux-64", + "timestamp": 1505743164170, + "version": "3.4.1" + }, + "flake8-3.4.1-py36h541458f_0.tar.bz2": { + "build": "py36h541458f_0", + "build_number": 0, + "depends": [ + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.4.0", + "pyflakes >=1.5.0,<1.6.0", + "python >=3.6,<3.7.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "53e29f1fc3942a4c19cf1ea9eca00da8", + "name": "flake8", + "sha256": "42a931296d5c224f00275eb625fc7d50baa395d98b9f23da62f74d6ad7d487dc", + "size": 120583, + "subdir": "linux-64", + "timestamp": 1505743179645, + "version": "3.4.1" + }, + "flake8-3.5.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "configparser", + "enum34", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.4.0", + "pyflakes >=1.5.0,<1.7.0", + "python >=2.7,<2.8.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "691d4d0d8a77252863e5f84217fcbdd0", + "name": "flake8", + "sha256": "3887ab8b52b9014d86e51e66253f0a495dc61ef4d0c5f9eca2cf3c9ea03dad57", + "size": 122204, + "subdir": "linux-64", + "timestamp": 1516632822696, + "version": "3.5.0" + }, + "flake8-3.5.0-py27h544e95e_0.tar.bz2": { + "build": "py27h544e95e_0", + "build_number": 0, + "depends": [ + "configparser", + "enum34", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.4.0", + "pyflakes >=1.5.0,<1.6.0", + "python >=2.7,<2.8.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3bc3aacaa81c4edcdbb1eea6eafbd70", + "name": "flake8", + "sha256": "68df1956c2fdc4cd03d64cecbb5101887e427870781d7b701af1e343fad9db10", + "size": 122365, + "subdir": "linux-64", + "timestamp": 1511296351780, + "version": "3.5.0" + }, + "flake8-3.5.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.4.0", + "pyflakes >=1.5.0,<1.7.0", + "python >=3.5,<3.6.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbccbc318e12ff65d73389fabc6a05b7", + "name": "flake8", + "sha256": "e5f38d81f8123f45518952f9988fd79bf9664d37671a6a50b40a2f9e12896807", + "size": 124856, + "subdir": "linux-64", + "timestamp": 1516632825627, + "version": "3.5.0" + }, + "flake8-3.5.0-py35h92eb085_0.tar.bz2": { + "build": "py35h92eb085_0", + "build_number": 0, + "depends": [ + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.4.0", + "pyflakes >=1.5.0,<1.6.0", + "python >=3.5,<3.6.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d0177bff1fa979b4127c38830d5680ff", + "name": "flake8", + "sha256": "558fc3f1914d74ae33b6815557d53379b8aab03cf26f08b7268c5c04fc752254", + "size": 124985, + "subdir": "linux-64", + "timestamp": 1511296358882, + "version": "3.5.0" + }, + "flake8-3.5.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.4.0", + "pyflakes >=1.5.0,<1.7.0", + "python >=3.6,<3.7.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "57a4c347d3f8c6c3d5e232d02b14a9da", + "name": "flake8", + "sha256": "bbb85cca450ec0b279f02f20099175358ae578193da6d1e0401f88d061912d62", + "size": 124608, + "subdir": "linux-64", + "timestamp": 1516632833568, + "version": "3.5.0" + }, + "flake8-3.5.0-py36hda1b316_0.tar.bz2": { + "build": "py36hda1b316_0", + "build_number": 0, + "depends": [ + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.4.0", + "pyflakes >=1.5.0,<1.6.0", + "python >=3.6,<3.7.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5d02f4dd783044c67f7e8adf55a9170", + "name": "flake8", + "sha256": "56ee6faee0485d67d97c2b349507d6e7dd9005e866c1443b1d62dc3a7117d1a5", + "size": 124760, + "subdir": "linux-64", + "timestamp": 1511296362034, + "version": "3.5.0" + }, + "flake8-3.5.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.5.0", + "pyflakes >=1.5.0,<1.7.0", + "python >=3.7,<3.8.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56c029259c4695fbba1a9df6166ad78e", + "name": "flake8", + "sha256": "25432ecefca0b6850cb30acba1f0a52aeebcfabc4f3be51ef78a7152cb5b43b9", + "size": 124966, + "subdir": "linux-64", + "timestamp": 1530812701418, + "version": "3.5.0" + }, + "flake8-3.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser", + "enum34", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.4.0,<2.5.0", + "pyflakes >=2.0.0,<2.1.0", + "python >=2.7,<2.8.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c754fd041467e35804e56c5b3545d6b", + "name": "flake8", + "sha256": "68b71b1a51c87d9247ff955d1f61e46cf515114f75ae0d99455c4985ac496317", + "size": 124607, + "subdir": "linux-64", + "timestamp": 1541178562579, + "version": "3.6.0" + }, + "flake8-3.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.4.0,<2.5.0", + "pyflakes >=2.0.0,<2.1.0", + "python >=3.6,<3.7.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b26f97904ca9a2509a3e564e2e9d26da", + "name": "flake8", + "sha256": "737939abf007d9f3337d021394e33715912b121fff833db3ba6ffb596cff80d4", + "size": 126696, + "subdir": "linux-64", + "timestamp": 1541178592171, + "version": "3.6.0" + }, + "flake8-3.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.4.0,<2.5.0", + "pyflakes >=2.0.0,<2.1.0", + "python >=3.7,<3.8.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ef80b1f943a184cb86947daaf5f1d25", + "name": "flake8", + "sha256": "6ac19912acf568244df1ea34ca5364006f7d5fa768549052347aa3c819f6e46a", + "size": 126865, + "subdir": "linux-64", + "timestamp": 1541178554748, + "version": "3.6.0" + }, + "flake8-3.7.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser", + "entrypoints >=0.3.0,<0.4.0", + "enum34", + "functools32", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=2.7,<2.8.0a0", + "setuptools >=30.0.0", + "typing" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6500660d6a05204c640e1c6a571e063f", + "name": "flake8", + "sha256": "0788b49d7a4ba42ad290a1778d5814ee0839f0267be647b93b8f1ed33e582e80", + "size": 131399, + "subdir": "linux-64", + "timestamp": 1552360706852, + "version": "3.7.7" + }, + "flake8-3.7.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints >=0.3.0,<0.4.0", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=3.6,<3.7.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7bd42a5119276535361a2c80cd3b971e", + "name": "flake8", + "sha256": "7fc7f2061c5cf256276a84f8fd4b7fe32f8ecda00156fba084591c0bc828002c", + "size": 133582, + "subdir": "linux-64", + "timestamp": 1552360737575, + "version": "3.7.7" + }, + "flake8-3.7.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints >=0.3.0,<0.4.0", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=3.7,<3.8.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49e601e46baabccf55048c96c9d433e6", + "name": "flake8", + "sha256": "0413292a8ad91e670a94e55f0fa721b87218467b94300825ccbc087b8379a325", + "size": 133637, + "subdir": "linux-64", + "timestamp": 1552360683501, + "version": "3.7.7" + }, + "flake8-3.7.8-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "configparser", + "entrypoints >=0.3.0,<0.4.0", + "enum34", + "functools32", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=2.7,<2.8.0a0", + "setuptools >=30.0.0", + "typing" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9be43179034500575f3142ea0ee303ad", + "name": "flake8", + "sha256": "cb8827e0850bf7e9c63b09ab43a5b3b540c2b988aa2566d78e887ecce7550559", + "size": 135325, + "subdir": "linux-64", + "timestamp": 1569334746687, + "version": "3.7.8" + }, + "flake8-3.7.8-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "entrypoints >=0.3.0,<0.4.0", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=3.6,<3.7.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0813fe0608658da92c30e28d7de58cba", + "name": "flake8", + "sha256": "27c57551a6b162cf66474e5d4e34b47177eff82494857eb10f49dd3207f795c0", + "size": 137336, + "subdir": "linux-64", + "timestamp": 1569334770746, + "version": "3.7.8" + }, + "flake8-3.7.8-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "entrypoints >=0.3.0,<0.4.0", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=3.7,<3.8.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e10f7b05c875e0304793e2e3ba8d5a0", + "name": "flake8", + "sha256": "fd54dc881bc80ac59b60e9b86c640912aec172662f1e1f734cbfa719b1085d9b", + "size": 137289, + "subdir": "linux-64", + "timestamp": 1569334748586, + "version": "3.7.8" + }, + "flake8-3.7.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser", + "entrypoints >=0.3.0,<0.4.0", + "enum34", + "functools32", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=2.7,<2.8.0a0", + "setuptools >=30.0.0", + "typing" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "579389cffd3812f06002a43182df8f5a", + "name": "flake8", + "sha256": "032203e630bb9187534f21f380920cf27ce29cff5f5305c34175691fe52af7f1", + "size": 135239, + "subdir": "linux-64", + "timestamp": 1573233032570, + "version": "3.7.9" + }, + "flake8-3.7.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints >=0.3.0,<0.4.0", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=3.6,<3.7.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e737ea7985a186e95790273fa605cbc1", + "name": "flake8", + "sha256": "ba187d85e4b32f748c53982c86ec2e10dd09ff00f15320649afe0254cb987ca9", + "size": 137335, + "subdir": "linux-64", + "timestamp": 1573233107653, + "version": "3.7.9" + }, + "flake8-3.7.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints >=0.3.0,<0.4.0", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=3.7,<3.8.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "280d608dbaa142b3edf35e25804e2d08", + "name": "flake8", + "sha256": "6cbc2d39aaac8e75a0d38c55d0f42d325a418c8412e21c1d2f154679ec6bf484", + "size": 137386, + "subdir": "linux-64", + "timestamp": 1573232994106, + "version": "3.7.9" + }, + "flake8-3.7.9-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints >=0.3.0,<0.4.0", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=3.8,<3.9.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e95654941ca926c7dc1c946c32c71821", + "name": "flake8", + "sha256": "e0646d5038c6b8443abdfb9719a647eae03222653ea97fc7a21f09553cfcfceb", + "size": 131861, + "subdir": "linux-64", + "timestamp": 1574251330548, + "version": "3.7.9" + }, + "flake8-6.0.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "mccabe >=0.7.0,<0.8.0", + "pycodestyle >=2.10.0,<2.11.0", + "pyflakes >=3.0.0,<3.1.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c554af77cda5add3ed9503a4edddd67", + "name": "flake8", + "sha256": "ed9ed69c4f870f25b01ca4d5ddd5288e71859e810c0ca45d13a9e79004a68d1a", + "size": 119275, + "subdir": "linux-64", + "timestamp": 1674581847639, + "version": "6.0.0" + }, + "flake8-6.0.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "mccabe >=0.7.0,<0.8.0", + "pycodestyle >=2.10.0,<2.11.0", + "pyflakes >=3.0.0,<3.1.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e2c7bc9687e43b73f5dcc4e6c8ca174b", + "name": "flake8", + "sha256": "ffa2f9f0778ab2fff42c2631d6d22c59534f8aaf1bcebc5360282afe967fd044", + "size": 142501, + "subdir": "linux-64", + "timestamp": 1677709259514, + "version": "6.0.0" + }, + "flake8-6.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "mccabe >=0.7.0,<0.8.0", + "pycodestyle >=2.10.0,<2.11.0", + "pyflakes >=3.0.0,<3.1.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98fcab69ebe483eb416d47db41762996", + "name": "flake8", + "sha256": "1ffe1bbec18d4e7cd5e3b010f0b40ebd6a30c4c5c83f38169cf9a37c969f950b", + "size": 118035, + "subdir": "linux-64", + "timestamp": 1674581873099, + "version": "6.0.0" + }, + "flake8-6.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "mccabe >=0.7.0,<0.8.0", + "pycodestyle >=2.10.0,<2.11.0", + "pyflakes >=3.0.0,<3.1.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "394f7b7906e8e90195b95de16cefb220", + "name": "flake8", + "sha256": "e3a87e664c6668db01932a9cec776923d9834dcbeed2089a57910c84d72252ad", + "size": 118164, + "subdir": "linux-64", + "timestamp": 1674581821922, + "version": "6.0.0" + }, + "flake8-import-order-0.12-py27h9b42c04_0.tar.bz2": { + "build": "py27h9b42c04_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "5f3309bfd0c958f468f58196e990cc98", + "name": "flake8-import-order", + "sha256": "68bca36a469ae409b151da6fda65950ac9d7cb742dca8ef259f8c16fa3ee60cf", + "size": 22210, + "subdir": "linux-64", + "timestamp": 1505743193549, + "version": "0.12" + }, + "flake8-import-order-0.12-py35hfe8de38_0.tar.bz2": { + "build": "py35hfe8de38_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "de0609eec8dfa3ca3624005ca71be5af", + "name": "flake8-import-order", + "sha256": "66985d6217c681d288781dcd40adc31187a83b48aadc1341f2218f9e9f7918e6", + "size": 22666, + "subdir": "linux-64", + "timestamp": 1505743205983, + "version": "0.12" + }, + "flake8-import-order-0.12-py36h03aae4d_0.tar.bz2": { + "build": "py36h03aae4d_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "90a0c0d143884ac68a3bf52a9975b0c6", + "name": "flake8-import-order", + "sha256": "82aa2884521bb04d47c9e2a124ebb7c292c8ea005693f1e960b6e65ba93cc1eb", + "size": 22576, + "subdir": "linux-64", + "timestamp": 1505743218319, + "version": "0.12" + }, + "flake8-import-order-0.16-py27h9d8f0cb_0.tar.bz2": { + "build": "py27h9d8f0cb_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "4959bf99096e1c2d837a8c5e1cc051b9", + "name": "flake8-import-order", + "sha256": "3b62fb4f98d2ca25a261fbff26b6e6a233e75b2bbdecfa1bb9545de3ab01701d", + "size": 24979, + "subdir": "linux-64", + "timestamp": 1512035327308, + "version": "0.16" + }, + "flake8-import-order-0.16-py35h68db374_0.tar.bz2": { + "build": "py35h68db374_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "570ad0a8f5c74e1c233103177372b9df", + "name": "flake8-import-order", + "sha256": "4a0fbaaabbf1f781b070a607b75ccc2f9ada7a5fd37eab68e2fdefebfcfbdd72", + "size": 25512, + "subdir": "linux-64", + "timestamp": 1512035292559, + "version": "0.16" + }, + "flake8-import-order-0.16-py36hb126a73_0.tar.bz2": { + "build": "py36hb126a73_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "2f007df9a8973057533604f2269d0bfa", + "name": "flake8-import-order", + "sha256": "2ca768edbbc3d6bef4eddd15216e061a22b3451d865317bf653c272cc6e7bb1e", + "size": 25466, + "subdir": "linux-64", + "timestamp": 1512035337798, + "version": "0.16" + }, + "flake8-import-order-0.17-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "flake8", + "pycodestyle", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "5d1f850e596bac3c16a826051cbcdfd9", + "name": "flake8-import-order", + "sha256": "8ef57dd26ab7722df40c56c6a45d89b4dc9f59af87f5e96281f18ee1e3deb978", + "size": 25307, + "subdir": "linux-64", + "timestamp": 1519241864595, + "version": "0.17" + }, + "flake8-import-order-0.17-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "a489cfa0095a4d4feba4d0478aedb3f6", + "name": "flake8-import-order", + "sha256": "12fe55ef6eecad32ae8df6f184fd9f7a2addb010cc457fb9c2edef3e317611b4", + "size": 25818, + "subdir": "linux-64", + "timestamp": 1519241919854, + "version": "0.17" + }, + "flake8-import-order-0.17-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "9e71e623443a3553cf6b0461808e2508", + "name": "flake8-import-order", + "sha256": "9eaaf64be0355219faf7a01ba0a6289f08e4380e0ce1c23cf095b04d6a64d02e", + "size": 25761, + "subdir": "linux-64", + "timestamp": 1519241787985, + "version": "0.17" + }, + "flake8-import-order-0.17.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "flake8", + "pycodestyle", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "b934f3e328ea73f9a6b171720b5d2f5b", + "name": "flake8-import-order", + "sha256": "6e4ca9b33f16cb867aee20f23b1f2487b57bce5c586f50a8bde10abbcca37263", + "size": 25409, + "subdir": "linux-64", + "timestamp": 1522786496420, + "version": "0.17.1" + }, + "flake8-import-order-0.17.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "457963dfd38fa342a219dc4cd99c3679", + "name": "flake8-import-order", + "sha256": "a5ab108f2701db7ed7b2eae0f5aa65e2a24976ef17d774a921d9b58098b3e24e", + "size": 25957, + "subdir": "linux-64", + "timestamp": 1522786507492, + "version": "0.17.1" + }, + "flake8-import-order-0.17.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "78032c3aa8a267dfe455811c86756b31", + "name": "flake8-import-order", + "sha256": "ab13e6d6c905e6600362bc76919a72e2866b50db20b605fe6e368ca6c295002e", + "size": 25858, + "subdir": "linux-64", + "timestamp": 1522786309136, + "version": "0.17.1" + }, + "flake8-import-order-0.17.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "fb308e12399abbf196e02b3658b9585a", + "name": "flake8-import-order", + "sha256": "c787720499d916db686a982a7ee6611186792a8a6e30d16f140580212a573dc7", + "size": 25809, + "subdir": "linux-64", + "timestamp": 1530877422615, + "version": "0.17.1" + }, + "flake8-import-order-0.18-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "flake8", + "pycodestyle", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "2ba71ed7f3f6407bb2f5095c91fb481a", + "name": "flake8-import-order", + "sha256": "810afd7f58a8eb241e7e3350dc3237717709b5212edaec32ddf7d5896ac80eee", + "size": 25463, + "subdir": "linux-64", + "timestamp": 1535425792413, + "version": "0.18" + }, + "flake8-import-order-0.18-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "fb6c8b0651ff5f8bc22a0e8c42cd998d", + "name": "flake8-import-order", + "sha256": "86af23b6aec594bc99bd7df104299fc7d3499015671b49cded31362e608a2625", + "size": 26054, + "subdir": "linux-64", + "timestamp": 1535425816656, + "version": "0.18" + }, + "flake8-import-order-0.18-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "cecb931d73ccc863beaf71539b54f250", + "name": "flake8-import-order", + "sha256": "f04b6bbffeede6aa6f117fda7c3d78896d75f90da83f12be6e4a0d173a92a57f", + "size": 25966, + "subdir": "linux-64", + "timestamp": 1535425568107, + "version": "0.18" + }, + "flake8-import-order-0.18-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "86bb68c776cd885ad0620cacbcf71b13", + "name": "flake8-import-order", + "sha256": "17da2a4822daf4cf62bf497397090593527cbc4d23ad16429ca1f21f40efe958", + "size": 26056, + "subdir": "linux-64", + "timestamp": 1535425816585, + "version": "0.18" + }, + "flake8-import-order-0.18.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "flake8", + "pycodestyle", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "67e493c3576fe3c82bce57279c0b6547", + "name": "flake8-import-order", + "sha256": "8747a3130672733e35888bbd6b80703e803c29124088d845816b1c7d79368fb0", + "size": 29331, + "subdir": "linux-64", + "timestamp": 1552377063631, + "version": "0.18.1" + }, + "flake8-import-order-0.18.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "4e501c5296fbcb1e164708353c4e7186", + "name": "flake8-import-order", + "sha256": "879fcb8899d8c0e221074a7e09bb58e973aac4d60fcb190c00b473e6bf13b026", + "size": 27423, + "subdir": "linux-64", + "timestamp": 1640790063356, + "version": "0.18.1" + }, + "flake8-import-order-0.18.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "907cdc612b6ab8f118e1b2c4dc9c917a", + "name": "flake8-import-order", + "sha256": "803b9ebf5ea4d38f56701b363b0f363984db35b46938698ab574a9bbe523d1c7", + "size": 32725, + "subdir": "linux-64", + "timestamp": 1676852341629, + "version": "0.18.1" + }, + "flake8-import-order-0.18.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "4193e173ade2a8e9efc044940a11d741", + "name": "flake8-import-order", + "sha256": "2c3b071011eb27133cd15030916bd82174f5358e0bdca9e9d20de77cdcda35c2", + "size": 29813, + "subdir": "linux-64", + "timestamp": 1552377099091, + "version": "0.18.1" + }, + "flake8-import-order-0.18.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "5997573b34840a54aa26bf69f43221ea", + "name": "flake8-import-order", + "sha256": "02e50bb9d51d900f59b2251f8d3aa8603d990304fc7078695f6ab3a67238aa04", + "size": 30253, + "subdir": "linux-64", + "timestamp": 1614172018542, + "version": "0.18.1" + }, + "flake8-import-order-0.18.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "0ff45aa7df149dd1ef91cf6ba271ff16", + "name": "flake8-import-order", + "sha256": "2d4c67a9be4b99bc6b36a60046e99742d9e64ab9cdaca80309002d461c189077", + "size": 29839, + "subdir": "linux-64", + "timestamp": 1552377060800, + "version": "0.18.1" + }, + "flake8-import-order-0.18.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "231bc5fc0b2d21fa1b38e3d1ef6b97d2", + "name": "flake8-import-order", + "sha256": "4c1bb491329e83e0622928af897ef07cb074d7419d10b04464a32094953dc140", + "size": 30233, + "subdir": "linux-64", + "timestamp": 1614172012116, + "version": "0.18.1" + }, + "flake8-import-order-0.18.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "fda9b57997792bc2fdda3c55030a9021", + "name": "flake8-import-order", + "sha256": "13e39e56f15e25342e6fe14e19af994070dc0bf3ef211bf95e1a3bf0d9bb02d3", + "size": 27969, + "subdir": "linux-64", + "timestamp": 1574413897779, + "version": "0.18.1" + }, + "flake8-import-order-0.18.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "43b184424eb88f4dabf9a970fb33809f", + "name": "flake8-import-order", + "sha256": "b04585800ddaee3a326a73e3b57273741d4dc0570a9d8231fe436f8f89217315", + "size": 30427, + "subdir": "linux-64", + "timestamp": 1614171045708, + "version": "0.18.1" + }, + "flake8-import-order-0.18.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "5b265c6b4fa3225b4f79b1ed7eadad27", + "name": "flake8-import-order", + "sha256": "5df5ca110fe734c87aca7c4fde93ed518bb06fd4283db8f3c9cb21f20200b426", + "size": 29600, + "subdir": "linux-64", + "timestamp": 1614172016193, + "version": "0.18.1" + }, + "flake8-import-order-0.18.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "2fdfe61895622996f26079407ac4b005", + "name": "flake8-import-order", + "sha256": "222b345ca0bbf753c56c653f0573624dfb0c85b04363b58326b0db6e65a9eae8", + "size": 27507, + "subdir": "linux-64", + "timestamp": 1678214206977, + "version": "0.18.2" + }, + "flake8-import-order-0.18.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "28ee647e9625137a636aa09fbf30ced8", + "name": "flake8-import-order", + "sha256": "77b1715fe9a39356ad77bc667a4943bb0591559edb8f715c4f4e5ac8c195b456", + "size": 32833, + "subdir": "linux-64", + "timestamp": 1678243021410, + "version": "0.18.2" + }, + "flake8-import-order-0.18.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "d6aa0c2718409472f15605d525fac898", + "name": "flake8-import-order", + "sha256": "b282a33e743e8e88d834ee5b1042c7a69e65f587ade983f0b966a0d7f034fc20", + "size": 28137, + "subdir": "linux-64", + "timestamp": 1678214258556, + "version": "0.18.2" + }, + "flake8-import-order-0.18.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "733869061062e00e3a6204de2191d802", + "name": "flake8-import-order", + "sha256": "d0fd41eb0ebe303ddf636fe56167c226d19db5acca8ca1720046cdf7e40f34fa", + "size": 27369, + "subdir": "linux-64", + "timestamp": 1678214232792, + "version": "0.18.2" + }, + "flake8-polyfill-1.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9b3137b067c0bf311751498864c9572", + "name": "flake8-polyfill", + "sha256": "a5934130f20a52a1f852b048548c0947a4207664e8c457c4f7e8853a9fc5a263", + "size": 10140, + "subdir": "linux-64", + "timestamp": 1524096410206, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47fcc47a76400e67a830e81fc172193c", + "name": "flake8-polyfill", + "sha256": "349e5476f1d733ea134848c69f308ca2c62ffa64a29aa764fe9b8312a22ef7b1", + "size": 10468, + "subdir": "linux-64", + "timestamp": 1642515378291, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8042e648cac9e465062f11377d5d8075", + "name": "flake8-polyfill", + "sha256": "96a4b932a12378400c7c9a4e2455cef371d9ca9596fb729f38b107fa897c15f2", + "size": 12276, + "subdir": "linux-64", + "timestamp": 1676844036142, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "982caf72269cd82752983993dfb45ef0", + "name": "flake8-polyfill", + "sha256": "4e9f6b199500410aa56d8d97d191005e4f897fce71002a837ec54d1a597ab910", + "size": 10303, + "subdir": "linux-64", + "timestamp": 1524096417943, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0055597d0193caf4fe11c89d6c2432c1", + "name": "flake8-polyfill", + "sha256": "c1af9b836d1e04f5d70806592e80960f1c298c6e8fb65d6cb00b5bb66121efa0", + "size": 10276, + "subdir": "linux-64", + "timestamp": 1524096607968, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c25d48a99514a6c92a79f99f520224e9", + "name": "flake8-polyfill", + "sha256": "7938a6d5c0e7b3ab2dcef2bde5c0ae5eaeeb5a3e2253a3b891c1f6004f15bc61", + "size": 11635, + "subdir": "linux-64", + "timestamp": 1632891244200, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c6265165864c6fae3c935e3deeb8537", + "name": "flake8-polyfill", + "sha256": "b430d654937bd89f007f98a0a99de833181a18060e27b9d9976fbfceb7859e20", + "size": 10141, + "subdir": "linux-64", + "timestamp": 1530877451641, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0e8eb8dc63c3a6cc7b83703358c95bf6", + "name": "flake8-polyfill", + "sha256": "0606e573c902f39cd1b2475280a646ea33620a5c37c07e65dc7808d7c01e295d", + "size": 11650, + "subdir": "linux-64", + "timestamp": 1632890779792, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd503a16ccb4456187418d1caa146ede", + "name": "flake8-polyfill", + "sha256": "c2dcb448f3728ca42fd90626a665e3b2635f0d0d34567203a98ac87d28d98e11", + "size": 10652, + "subdir": "linux-64", + "timestamp": 1574413918703, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d934a9a98b7421f9eedc9a8eeda2138e", + "name": "flake8-polyfill", + "sha256": "368673e574452b0fd29c087008e4a3637c94e0fff2c0655e8750a9fa4c603434", + "size": 11693, + "subdir": "linux-64", + "timestamp": 1632890786003, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8562cbfe846521cad4bffea51c8a4701", + "name": "flake8-polyfill", + "sha256": "d9a20f7d0e347fea2fecedef12ab457e7cc7bc0b0e0d5a218899e8c80664766f", + "size": 11680, + "subdir": "linux-64", + "timestamp": 1632891210598, + "version": "1.0.2" + }, + "flaky-3.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3ed3dbd69c39e948055c12c23a9b5ade", + "name": "flaky", + "sha256": "71adf127c7a0d3591e5526bde183f8a08ba68f79b0e27217bb7f1b1a33f8d254", + "size": 29439, + "subdir": "linux-64", + "timestamp": 1530727646665, + "version": "3.4.0" + }, + "flaky-3.4.0-py27h8a62d16_0.tar.bz2": { + "build": "py27h8a62d16_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ee45f00176b1483aefb1953b81a4484e", + "name": "flaky", + "sha256": "a4952825181614789e8c3c2cabd72ee5acd0d47105f73998aa2a0115dda7f18b", + "size": 29773, + "subdir": "linux-64", + "timestamp": 1510981411135, + "version": "3.4.0" + }, + "flaky-3.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "acc54c1819ff40cf9970e72af6f144cd", + "name": "flaky", + "sha256": "1216befca3fd73a8aa681e2a1ebdef5fbe638011adebf1e2be28347438518825", + "size": 29924, + "subdir": "linux-64", + "timestamp": 1534347475433, + "version": "3.4.0" + }, + "flaky-3.4.0-py35hdbc305c_0.tar.bz2": { + "build": "py35hdbc305c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "db21effd28ef270ec36396f9363486eb", + "name": "flaky", + "sha256": "cdc9fd3582ea27ff52f0eb26ae23e429eaee8ed6da393c44b45a166eb3f1527c", + "size": 30348, + "subdir": "linux-64", + "timestamp": 1510981423604, + "version": "3.4.0" + }, + "flaky-3.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d1b3d8437a3c48cf42ea1e62485c332d", + "name": "flaky", + "sha256": "b2f7043c1677350cbdf9f22f5382df541062426b5682a088dd0a9d0cca24dc9f", + "size": 30000, + "subdir": "linux-64", + "timestamp": 1530727686767, + "version": "3.4.0" + }, + "flaky-3.4.0-py36h0c56b27_0.tar.bz2": { + "build": "py36h0c56b27_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2f5cb01b3f5cceeb6b469953ad1f28cc", + "name": "flaky", + "sha256": "e9d9800c2f9a940d28e5d6d651fbe8fe8bab6fc41bbc0561dc45e753eaae7f74", + "size": 30275, + "subdir": "linux-64", + "timestamp": 1510981419327, + "version": "3.4.0" + }, + "flaky-3.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "14c81d82bdfa4343f8c565d363094e31", + "name": "flaky", + "sha256": "6a819f1a26e945a24ecc9f78d1bb01f4dae2fd03af9d8b669bc4c7b1c2cd6035", + "size": 30008, + "subdir": "linux-64", + "timestamp": 1530727666342, + "version": "3.4.0" + }, + "flaky-3.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c225c0992d2390b967a122121be66411", + "name": "flaky", + "sha256": "343c651de9f4b98cde542e5e39de7eefb715fa05474ccfbece73cbbad629fc5d", + "size": 31316, + "subdir": "linux-64", + "timestamp": 1547228814219, + "version": "3.5.0" + }, + "flaky-3.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3b81c0c4ccfb62157c5f031dc09ae30a", + "name": "flaky", + "sha256": "fbe46386e046e8fe61f128d555ca809627a30aac648ae164af73e96c5ea59d96", + "size": 31750, + "subdir": "linux-64", + "timestamp": 1547228862778, + "version": "3.5.0" + }, + "flaky-3.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f2b278ed6033cd310a6139c3b28919b7", + "name": "flaky", + "sha256": "fee1d249a7063bd5ec3d18cde28060215fbdf06c9424f5af68d3b036c8e5c507", + "size": 31780, + "subdir": "linux-64", + "timestamp": 1547228841022, + "version": "3.5.0" + }, + "flaky-3.5.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c4d07f261800e605adf32373b72ea678", + "name": "flaky", + "sha256": "2ce7ac58140100a1174eef33a661b4b5b43b1e1164f80cde26fdaf1865fdce67", + "size": 31727, + "subdir": "linux-64", + "timestamp": 1547749293148, + "version": "3.5.3" + }, + "flaky-3.5.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "31b2a85a7d29d62e0733aa3440b9f5b9", + "name": "flaky", + "sha256": "0f6986ae1222eaab628bfffca70fe5e64bb8754ab2666705c3415270be2f8a3a", + "size": 32249, + "subdir": "linux-64", + "timestamp": 1547749339180, + "version": "3.5.3" + }, + "flaky-3.5.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "781588a22e0568491c1cca7f88743b1d", + "name": "flaky", + "sha256": "852cb9babfadfdb7e5c81de28d0a2bbb336f9ad4ced03db8ca1b7d9ce97796b0", + "size": 32265, + "subdir": "linux-64", + "timestamp": 1547749326097, + "version": "3.5.3" + }, + "flask-0.12.2-py27h6d5c1cd_0.tar.bz2": { + "build": "py27h6d5c1cd_0", + "build_number": 0, + "depends": [ + "click >=2.0", + "itsdangerous >=0.21", + "jinja2 >=2.4", + "python >=2.7,<2.8.0a0", + "werkzeug >=0.7,<1.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dd813390dc66dce7235b83c80467eebe", + "name": "flask", + "sha256": "fe78c215934da23afcedd807eb6c3bc0245f58707d9999234e4e150420f0d438", + "size": 104986, + "subdir": "linux-64", + "timestamp": 1505740403221, + "version": "0.12.2" + }, + "flask-0.12.2-py35h679e90e_0.tar.bz2": { + "build": "py35h679e90e_0", + "build_number": 0, + "depends": [ + "click >=2.0", + "itsdangerous >=0.21", + "jinja2 >=2.4", + "python >=3.5,<3.6.0a0", + "werkzeug >=0.7,<1.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9709821ad9a3ce560000bb1d9491fc19", + "name": "flask", + "sha256": "cf314c72887cb43d9608d79ea0dc980db60c2df965a4342603fe6d2a21d5eda7", + "size": 107450, + "subdir": "linux-64", + "timestamp": 1505740417217, + "version": "0.12.2" + }, + "flask-0.12.2-py36hb24657c_0.tar.bz2": { + "build": "py36hb24657c_0", + "build_number": 0, + "depends": [ + "click >=2.0", + "itsdangerous >=0.21", + "jinja2 >=2.4", + "python >=3.6,<3.7.0a0", + "werkzeug >=0.7,<1.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ed3b287044a6f8fbe61c3bb6caf07ec2", + "name": "flask", + "sha256": "a4158c495cda3ee7a2a68c00aec39ef55c55dbffff37564dad7330c5dc64b12a", + "size": 106873, + "subdir": "linux-64", + "timestamp": 1505740431814, + "version": "0.12.2" + }, + "flask-1.0.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "click >=5.1", + "itsdangerous >=0.24", + "jinja2 >=2.10,<3.0", + "python >=2.7,<2.8.0a0", + "werkzeug >=0.15,<2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d8351592f3d2f6ee9ea59c21fdd43abb", + "name": "flask", + "sha256": "61f9830e5fe0613e9b94ddb51503ad2714bbbf871565c0ce3368f269c4f5eea0", + "size": 119861, + "subdir": "linux-64", + "timestamp": 1525817220724, + "version": "1.0.2" + }, + "flask-1.0.2-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "click >=5.1", + "itsdangerous >=0.24", + "jinja2 >=2.10,<3.0", + "python >=3.5,<3.6.0a0", + "werkzeug >=0.15,<2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "054cb581e47825164b65ad20f93d93c5", + "name": "flask", + "sha256": "e933223272dd94ab40cd53decd23ae2b0fe64822dd4b18889faf7dde13c4da35", + "size": 122376, + "subdir": "linux-64", + "timestamp": 1525817046568, + "version": "1.0.2" + }, + "flask-1.0.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "click >=5.1", + "itsdangerous >=0.24", + "jinja2 >=2.10,<3.0", + "python >=3.6,<3.7.0a0", + "werkzeug >=0.15,<2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d167d96c2f3e58dd11509b4ff372fa9c", + "name": "flask", + "sha256": "9d3c9689c330e17d6cd469637e7382d3b71447a0eedf9691cd55d7db07d5c5b3", + "size": 122140, + "subdir": "linux-64", + "timestamp": 1525817058589, + "version": "1.0.2" + }, + "flask-1.0.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "click >=5.1", + "itsdangerous >=0.24", + "jinja2 >=2.10,<3.0", + "python >=3.7,<3.8.0a0", + "werkzeug >=0.15,<2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b1585f51b5335d354aeb16d52c3a1ff6", + "name": "flask", + "sha256": "131c54d7fbe6a7a06dc120b7d150d0129c4d3cbd1cd8a1e2ccb6cbaa9c7ef718", + "size": 122034, + "subdir": "linux-64", + "timestamp": 1530771776393, + "version": "1.0.2" + }, + "flask-1.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=5.1", + "itsdangerous >=0.24", + "jinja2 >=2.10,<3.0", + "python >=2.7,<2.8.0a0", + "werkzeug >=0.15,<2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6c37c6fc1bfa85c6e145bce8aa1f3581", + "name": "flask", + "sha256": "bb1cf5d703e319104aa581d2d2bf7d03b5e2ce214c7848f61d529150347b9dc2", + "size": 123471, + "subdir": "linux-64", + "timestamp": 1559064650640, + "version": "1.0.3" + }, + "flask-1.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=5.1", + "itsdangerous >=0.24", + "jinja2 >=2.10,<3.0", + "python >=3.6,<3.7.0a0", + "werkzeug >=0.15,<2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6de945204329c6cccb9353fad8ec9235", + "name": "flask", + "sha256": "b6ba514a2d0d104f73b25896ed0fbfb533b8774431458b3731ee1045733431cd", + "size": 125789, + "subdir": "linux-64", + "timestamp": 1559064680497, + "version": "1.0.3" + }, + "flask-1.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=5.1", + "itsdangerous >=0.24", + "jinja2 >=2.10,<3.0", + "python >=3.7,<3.8.0a0", + "werkzeug >=0.15,<2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0e771f8e14e61f48f23152e4815ae3b9", + "name": "flask", + "sha256": "2c03403673b00663196c75543b7123a83c09097f2ae42e197f4fefe1d94d499d", + "size": 125524, + "subdir": "linux-64", + "timestamp": 1559064558591, + "version": "1.0.3" + }, + "flask-2.1.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8.0", + "itsdangerous >=2.0", + "jinja2 >=3.0", + "python >=3.10,<3.11.0a0", + "werkzeug >=2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f447df4b6394dfcdc59ce2c186c25dba", + "name": "flask", + "sha256": "5d163adf79f4e4fcc0651986aefdebeff7084c0aa9c53b9ca19e863397a4b580", + "size": 133451, + "subdir": "linux-64", + "timestamp": 1658870830934, + "version": "2.1.3" + }, + "flask-2.1.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8.0", + "importlib-metadata >=3.6.0", + "itsdangerous >=2.0", + "jinja2 >=3.0", + "python >=3.7,<3.8.0a0", + "werkzeug >=2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bc61ae7fbf5426d391d19b03022218f9", + "name": "flask", + "sha256": "11adf42cda04c86866c7e8136485d2598256918d7392ba5409e38d7c83bda7f9", + "size": 131411, + "subdir": "linux-64", + "timestamp": 1658870881818, + "version": "2.1.3" + }, + "flask-2.1.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8.0", + "importlib-metadata >=3.6.0", + "itsdangerous >=2.0", + "jinja2 >=3.0", + "python >=3.8,<3.9.0a0", + "werkzeug >=2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6b6358dff3ef034c6a35fda70f65fbbc", + "name": "flask", + "sha256": "e12a84957080bc9478fa1690c67871c10d1e90692259183f0b20fb38f1bb8acb", + "size": 132222, + "subdir": "linux-64", + "timestamp": 1658870856122, + "version": "2.1.3" + }, + "flask-2.1.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8.0", + "importlib-metadata >=3.6.0", + "itsdangerous >=2.0", + "jinja2 >=3.0", + "python >=3.9,<3.10.0a0", + "werkzeug >=2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0c0fb47cf337aff9f5d3c939f945e4fc", + "name": "flask", + "sha256": "03bbcf3cafcb63ef8d08903a6122e7b4e9c8e0daf9595a9517ba77f13741444c", + "size": 132319, + "subdir": "linux-64", + "timestamp": 1658870794542, + "version": "2.1.3" + }, + "flask-2.2.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8.0", + "itsdangerous >=2.0", + "jinja2 >=3.0", + "python >=3.10,<3.11.0a0", + "werkzeug >=2.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1176253e75c6d3cb6b339064951238c7", + "name": "flask", + "sha256": "0d1c53bb66e92674382d1741ba783a6082865ed85e88cfedc3c04e74b2b32bc3", + "size": 140032, + "subdir": "linux-64", + "timestamp": 1671217451831, + "version": "2.2.2" + }, + "flask-2.2.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8.0", + "itsdangerous >=2.0", + "jinja2 >=3.0", + "python >=3.11,<3.12.0a0", + "werkzeug >=2.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85680b0928c0349cd0856c706aa158e9", + "name": "flask", + "sha256": "7354cba03425be3506db30cd3b13d37d471a3aeb97d3af1b4fb13b88d7954391", + "size": 176117, + "subdir": "linux-64", + "timestamp": 1676827153822, + "version": "2.2.2" + }, + "flask-2.2.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8.0", + "importlib-metadata >=3.6.0", + "itsdangerous >=2.0", + "jinja2 >=3.0", + "python >=3.7,<3.8.0a0", + "werkzeug >=2.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a36102018230d8852289539ef31d3f1b", + "name": "flask", + "sha256": "d52de166d1de8222536f7542b76673fee1ed064aa8b3a2b0990cb35c6af819d6", + "size": 137879, + "subdir": "linux-64", + "timestamp": 1671217425180, + "version": "2.2.2" + }, + "flask-2.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8.0", + "importlib-metadata >=3.6.0", + "itsdangerous >=2.0", + "jinja2 >=3.0", + "python >=3.8,<3.9.0a0", + "werkzeug >=2.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2cffdceb177617682f03325776dada46", + "name": "flask", + "sha256": "9a99e43fe429f8cc8ac565aad31038753187883d51e8f23e1c385fce97cb0815", + "size": 138606, + "subdir": "linux-64", + "timestamp": 1671217398740, + "version": "2.2.2" + }, + "flask-2.2.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8.0", + "importlib-metadata >=3.6.0", + "itsdangerous >=2.0", + "jinja2 >=3.0", + "python >=3.9,<3.10.0a0", + "werkzeug >=2.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "955454cc15f41a82cee439270f4dfe45", + "name": "flask", + "sha256": "2cfe655cb4f55a61d7802c7998ec1edb7757efc6a8a4ffabe758ddb62c92fc53", + "size": 138899, + "subdir": "linux-64", + "timestamp": 1671217372741, + "version": "2.2.2" + }, + "flask-admin-1.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.7", + "python >=3.10,<3.11.0a0", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c2e980a8ef9907cdda3034bc1871a18b", + "name": "flask-admin", + "sha256": "ac11f5786f63365e60e1f5da7add110a418652c91b55b43897cd4db697981b23", + "size": 5532354, + "subdir": "linux-64", + "timestamp": 1669054947277, + "version": "1.6.0" + }, + "flask-admin-1.6.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.7", + "python >=3.11,<3.12.0a0", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5266a83c90f827cd032a089f026be2fd", + "name": "flask-admin", + "sha256": "2d3ef436778f8c15491cd05ec19645a676ee29eec9ba11f6e42385bc37df7060", + "size": 5667651, + "subdir": "linux-64", + "timestamp": 1676852365602, + "version": "1.6.0" + }, + "flask-admin-1.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.7", + "python >=3.7,<3.8.0a0", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4032d878fb66fbf2124bab1ccfb2d048", + "name": "flask-admin", + "sha256": "37af1697e749cc3d8bf25ce2ff3d52937a3824c9bca89bcf59db1893dbb63fb0", + "size": 5524790, + "subdir": "linux-64", + "timestamp": 1669055035903, + "version": "1.6.0" + }, + "flask-admin-1.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.7", + "python >=3.8,<3.9.0a0", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "13252298cdc5e0ce5c622d2194a503c1", + "name": "flask-admin", + "sha256": "019d7b4090df92d3e53054d8ce25914a102251e2274ef8c62cebf6351292f533", + "size": 5524821, + "subdir": "linux-64", + "timestamp": 1669055079097, + "version": "1.6.0" + }, + "flask-admin-1.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.7", + "python >=3.9,<3.10.0a0", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20a177b4d13158a5b482a79a670a7385", + "name": "flask-admin", + "sha256": "fb057c44cb824eb0fa77f0e13185b242a409824ad9019bdb0a35e42bfa94ed29", + "size": 5523729, + "subdir": "linux-64", + "timestamp": 1669054991697, + "version": "1.6.0" + }, + "flask-appbuilder-4.1.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "apispec >=3.3,<4", + "click >=8,<9", + "colorama >=0.3.9,<1", + "email_validator >=1.0.5,<2", + "flask >=2,<3", + "flask-babel >=1,<3", + "flask-jwt-extended >=4.0.0,<5.0.0", + "flask-login >=0.3,<0.7", + "flask-sqlalchemy >=2.4,<3", + "flask-wtf >=0.14.2,<1.0.0", + "jsonschema >=3,<5", + "marshmallow >=3,<4", + "marshmallow-enum >=1.5.1,<2", + "marshmallow-sqlalchemy >=0.22.0,<0.27.0", + "prison >=0.2.1,<1.0.0", + "pyjwt >=2.0.0,<3.0.0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.3,<3", + "sqlalchemy <1.5.0", + "sqlalchemy-utils >=0.32.21,<1", + "wtforms <3.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7f2c70a27239510c253c4f0190b5c1eb", + "name": "flask-appbuilder", + "sha256": "768174e26b8917f530a0e5f3e7da6f6a8c64ca4cd3110068fac6b44aafee9403", + "size": 1587800, + "subdir": "linux-64", + "timestamp": 1659862429185, + "version": "4.1.2" + }, + "flask-appbuilder-4.1.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "apispec >=3.3,<4", + "click >=8,<9", + "colorama >=0.3.9,<1", + "email_validator >=1.0.5,<2", + "flask >=2,<3", + "flask-babel >=1,<3", + "flask-jwt-extended >=4.0.0,<5.0.0", + "flask-login >=0.3,<0.7", + "flask-sqlalchemy >=2.4,<3", + "flask-wtf >=0.14.2,<1.0.0", + "jsonschema >=3,<5", + "marshmallow >=3,<4", + "marshmallow-enum >=1.5.1,<2", + "marshmallow-sqlalchemy >=0.22.0,<0.27.0", + "prison >=0.2.1,<1.0.0", + "pyjwt >=2.0.0,<3.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.3,<3", + "sqlalchemy <1.5.0", + "sqlalchemy-utils >=0.32.21,<1", + "wtforms <3.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bf1e1e4c3795b103c238da1d017130a8", + "name": "flask-appbuilder", + "sha256": "dec34bc8d83724cb8f668d773299156619e8ff48159ffc48b4475362ac77c24d", + "size": 1575685, + "subdir": "linux-64", + "timestamp": 1659862372553, + "version": "4.1.2" + }, + "flask-appbuilder-4.1.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "apispec >=3.3,<4", + "click >=8,<9", + "colorama >=0.3.9,<1", + "email_validator >=1.0.5,<2", + "flask >=2,<3", + "flask-babel >=1,<3", + "flask-jwt-extended >=4.0.0,<5.0.0", + "flask-login >=0.3,<0.7", + "flask-sqlalchemy >=2.4,<3", + "flask-wtf >=0.14.2,<1.0.0", + "jsonschema >=3,<5", + "marshmallow >=3,<4", + "marshmallow-enum >=1.5.1,<2", + "marshmallow-sqlalchemy >=0.22.0,<0.27.0", + "prison >=0.2.1,<1.0.0", + "pyjwt >=2.0.0,<3.0.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.3,<3", + "sqlalchemy <1.5.0", + "sqlalchemy-utils >=0.32.21,<1", + "wtforms <3.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b69c7160fe26f3a38e49fe154b987597", + "name": "flask-appbuilder", + "sha256": "393141106d383139ab66dd59d02e6daa5e1a3aafbd80c1ad9f71c89f2e2e716f", + "size": 1579693, + "subdir": "linux-64", + "timestamp": 1659862327581, + "version": "4.1.2" + }, + "flask-appbuilder-4.1.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "apispec >=3.3,<4", + "click >=8,<9", + "colorama >=0.3.9,<1", + "email_validator >=1.0.5,<2", + "flask >=2,<3", + "flask-babel >=1,<3", + "flask-jwt-extended >=4.0.0,<5.0.0", + "flask-login >=0.3,<0.7", + "flask-sqlalchemy >=2.4,<3", + "flask-wtf >=0.14.2,<1.0.0", + "jsonschema >=3,<5", + "marshmallow >=3,<4", + "marshmallow-enum >=1.5.1,<2", + "marshmallow-sqlalchemy >=0.22.0,<0.27.0", + "prison >=0.2.1,<1.0.0", + "pyjwt >=2.0.0,<3.0.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.3,<3", + "sqlalchemy <1.5.0", + "sqlalchemy-utils >=0.32.21,<1", + "wtforms <3.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "04830a6650b14591290e359c45ca0384", + "name": "flask-appbuilder", + "sha256": "2adf56315f1d4047f46ff7f1fcf32888739b393d4ce88ad3fd473b1a0c525030", + "size": 1580174, + "subdir": "linux-64", + "timestamp": 1659862476136, + "version": "4.1.2" + }, + "flask-appbuilder-4.1.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "apispec >=3.3,<4", + "click >=8,<9", + "colorama >=0.3.9,<1", + "email_validator >=1.0.5,<2", + "flask >=2,<3", + "flask-babel >=1,<3", + "flask-jwt-extended >=4.0.0,<5.0.0", + "flask-login >=0.3,<0.7", + "flask-sqlalchemy >=2.4,<3", + "flask-wtf >=0.14.2,<2", + "jsonschema >=3,<5", + "marshmallow >=3,<4", + "marshmallow-enum >=1.5.1,<2", + "marshmallow-sqlalchemy >=0.22.0,<0.27.0", + "prison >=0.2.1,<1.0.0", + "pyjwt >=2.0.0,<3.0.0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.3,<3", + "sqlalchemy <1.5.0", + "sqlalchemy-utils >=0.32.21,<1", + "wtforms <4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "37908ed6bca120ccc188430da3492c9f", + "name": "flask-appbuilder", + "sha256": "c4a093b7b61a5b78d1880303ff997e1327f7af7ae89f0a2831793faace57b519", + "size": 1577410, + "subdir": "linux-64", + "timestamp": 1668714811782, + "version": "4.1.4" + }, + "flask-appbuilder-4.1.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "apispec >=3.3,<4", + "click >=8,<9", + "colorama >=0.3.9,<1", + "email_validator >=1.0.5,<2", + "flask >=2,<3", + "flask-babel >=1,<3", + "flask-jwt-extended >=4.0.0,<5.0.0", + "flask-login >=0.3,<0.7", + "flask-sqlalchemy >=2.4,<3", + "flask-wtf >=0.14.2,<2", + "jsonschema >=3,<5", + "marshmallow >=3,<4", + "marshmallow-enum >=1.5.1,<2", + "marshmallow-sqlalchemy >=0.22.0,<0.27.0", + "prison >=0.2.1,<1.0.0", + "pyjwt >=2.0.0,<3.0.0", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.3,<3", + "sqlalchemy <1.5.0", + "sqlalchemy-utils >=0.32.21,<1", + "wtforms <4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9d6952bfe96ee21541d41a66acb44526", + "name": "flask-appbuilder", + "sha256": "751fe433469e61a76b06208ea3e5d9dc62ebad6f12892311cb425744e4c0b9b0", + "size": 1727564, + "subdir": "linux-64", + "timestamp": 1676830527785, + "version": "4.1.4" + }, + "flask-appbuilder-4.1.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "apispec >=3.3,<4", + "click >=8,<9", + "colorama >=0.3.9,<1", + "email_validator >=1.0.5,<2", + "flask >=2,<3", + "flask-babel >=1,<3", + "flask-jwt-extended >=4.0.0,<5.0.0", + "flask-login >=0.3,<0.7", + "flask-sqlalchemy >=2.4,<3", + "flask-wtf >=0.14.2,<2", + "jsonschema >=3,<5", + "marshmallow >=3,<4", + "marshmallow-enum >=1.5.1,<2", + "marshmallow-sqlalchemy >=0.22.0,<0.27.0", + "prison >=0.2.1,<1.0.0", + "pyjwt >=2.0.0,<3.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.3,<3", + "sqlalchemy <1.5.0", + "sqlalchemy-utils >=0.32.21,<1", + "wtforms <4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "08109d7af973754881626c8ae27b9793", + "name": "flask-appbuilder", + "sha256": "718cbff9adc5f1c0b1109f02b469381ff9d7d84c552a33bc95d6edb6300f8d76", + "size": 1567526, + "subdir": "linux-64", + "timestamp": 1668714719259, + "version": "4.1.4" + }, + "flask-appbuilder-4.1.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "apispec >=3.3,<4", + "click >=8,<9", + "colorama >=0.3.9,<1", + "email_validator >=1.0.5,<2", + "flask >=2,<3", + "flask-babel >=1,<3", + "flask-jwt-extended >=4.0.0,<5.0.0", + "flask-login >=0.3,<0.7", + "flask-sqlalchemy >=2.4,<3", + "flask-wtf >=0.14.2,<2", + "jsonschema >=3,<5", + "marshmallow >=3,<4", + "marshmallow-enum >=1.5.1,<2", + "marshmallow-sqlalchemy >=0.22.0,<0.27.0", + "prison >=0.2.1,<1.0.0", + "pyjwt >=2.0.0,<3.0.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.3,<3", + "sqlalchemy <1.5.0", + "sqlalchemy-utils >=0.32.21,<1", + "wtforms <4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3983fbe0c4ae361b661c7145d520cb1b", + "name": "flask-appbuilder", + "sha256": "8cf02099b59851e07916a989c321841d4d0648ac882f9ef000449f9d7d890995", + "size": 1564572, + "subdir": "linux-64", + "timestamp": 1668714670338, + "version": "4.1.4" + }, + "flask-appbuilder-4.1.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "apispec >=3.3,<4", + "click >=8,<9", + "colorama >=0.3.9,<1", + "email_validator >=1.0.5,<2", + "flask >=2,<3", + "flask-babel >=1,<3", + "flask-jwt-extended >=4.0.0,<5.0.0", + "flask-login >=0.3,<0.7", + "flask-sqlalchemy >=2.4,<3", + "flask-wtf >=0.14.2,<2", + "jsonschema >=3,<5", + "marshmallow >=3,<4", + "marshmallow-enum >=1.5.1,<2", + "marshmallow-sqlalchemy >=0.22.0,<0.27.0", + "prison >=0.2.1,<1.0.0", + "pyjwt >=2.0.0,<3.0.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.3,<3", + "sqlalchemy <1.5.0", + "sqlalchemy-utils >=0.32.21,<1", + "wtforms <4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "675acac45f73de7e1ed0e1055fda7f36", + "name": "flask-appbuilder", + "sha256": "8d65a9b4bff8e9085291a3ff608561e83598ff64da3d11c5b620f61297c48358", + "size": 1567683, + "subdir": "linux-64", + "timestamp": 1668714765801, + "version": "4.1.4" + }, + "flask-apscheduler-1.12.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "apscheduler >=3.2.0,<4.0.0", + "flask >=0.10.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d1c8f4e661736de98c0bb8ad50d00a60", + "name": "flask-apscheduler", + "sha256": "385321c50c4b7b48dda8801d1e78e1ff1ae9d62aa48755679178251d36278e1c", + "size": 26280, + "subdir": "linux-64", + "timestamp": 1668715299193, + "version": "1.12.4" + }, + "flask-apscheduler-1.12.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "apscheduler >=3.2.0,<4.0.0", + "flask >=0.10.1", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7748026ecea8bfe2a2eb7554feec8219", + "name": "flask-apscheduler", + "sha256": "e428763a2124e58bc95d3754e87379c642770c92eccaf657a701831e8c0e6de3", + "size": 31494, + "subdir": "linux-64", + "timestamp": 1676852389438, + "version": "1.12.4" + }, + "flask-apscheduler-1.12.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "apscheduler >=3.2.0,<4.0.0", + "flask >=0.10.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6b8ee611efcd9deb34fa1cf2db5a1bd7", + "name": "flask-apscheduler", + "sha256": "9b494971862893e2d711e0c03638a5237aaf53a4f25d82e95ad22237b7d884b2", + "size": 26113, + "subdir": "linux-64", + "timestamp": 1668715355228, + "version": "1.12.4" + }, + "flask-apscheduler-1.12.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "apscheduler >=3.2.0,<4.0.0", + "flask >=0.10.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "71cec6e69edb7e169934735edba2d3d1", + "name": "flask-apscheduler", + "sha256": "772422f0ab3134a46325ea72f1eb85a22c8209d93d34df26e9e2f819e8033115", + "size": 26174, + "subdir": "linux-64", + "timestamp": 1668715327031, + "version": "1.12.4" + }, + "flask-apscheduler-1.12.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "apscheduler >=3.2.0,<4.0.0", + "flask >=0.10.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c7fbe07a18640828ff40d61433c515b4", + "name": "flask-apscheduler", + "sha256": "c53581e49d5a9de5f609db5d5534ec9c61e7b575d2628de590a91cb8a757cee7", + "size": 26204, + "subdir": "linux-64", + "timestamp": 1668715270717, + "version": "1.12.4" + }, + "flask-bcrypt-1.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.1", + "flask", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ab26a56c97d3e20c0f1eed879314615e", + "name": "flask-bcrypt", + "sha256": "9f013b5fba365c5066ed2cc6aac61ecceba423aa23afba6e251862456f53ce69", + "size": 11779, + "subdir": "linux-64", + "timestamp": 1669799384320, + "version": "1.0.1" + }, + "flask-bcrypt-1.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.1", + "flask", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c33d95493dbc3c015c4ceffcd09aa43d", + "name": "flask-bcrypt", + "sha256": "83bbb6303587c1a60ce33fb5e05cfcef27b75bf266fc00c770461d3838d90a45", + "size": 13016, + "subdir": "linux-64", + "timestamp": 1676852404035, + "version": "1.0.1" + }, + "flask-bcrypt-1.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.1", + "flask", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa3411bee3ef889694b53e6b7c90890f", + "name": "flask-bcrypt", + "sha256": "08fb4f459579de42efecf76b71394ea74a985268df4eb5de3fbb6989990746a8", + "size": 11732, + "subdir": "linux-64", + "timestamp": 1669799309097, + "version": "1.0.1" + }, + "flask-bcrypt-1.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.1", + "flask", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "006dc41f5ef18325a994eae99cce24b2", + "name": "flask-bcrypt", + "sha256": "2d6b3820459be8e4d5c2021dd629c8c678c0b3cf730aa4d830386fc03697ca8c", + "size": 11738, + "subdir": "linux-64", + "timestamp": 1669799359191, + "version": "1.0.1" + }, + "flask-bcrypt-1.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.1", + "flask", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b9432514201d7d6364a554d683e0a04d", + "name": "flask-bcrypt", + "sha256": "4ddb2bdd3f291e948813bf79b9de5841c30b4539cd0cd4e0975f6218cd93e99e", + "size": 11729, + "subdir": "linux-64", + "timestamp": 1669799334260, + "version": "1.0.1" + }, + "flask-caching-2.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib >=0.9.0", + "flask <3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f618e8e72039d4b01f029a3ebe2efb0", + "name": "flask-caching", + "sha256": "85a0aceea6ba2b1e959cf6d87fbc7f27131837aec5db153a6a76578b777df0be", + "size": 44692, + "subdir": "linux-64", + "timestamp": 1668715163949, + "version": "2.0.1" + }, + "flask-caching-2.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib >=0.9.0", + "flask <3", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c5f5ab78a509d0a956f97adbd82ebf82", + "name": "flask-caching", + "sha256": "ad49bfc1283094607d5c287f1228c1c637a80882070f697c88e5f9e95125839f", + "size": 56243, + "subdir": "linux-64", + "timestamp": 1676830543678, + "version": "2.0.1" + }, + "flask-caching-2.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib >=0.9.0", + "flask <3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "97ccfc95609430d3f676e486eb0d3008", + "name": "flask-caching", + "sha256": "385911875d6761e2286b8d5e5c1b7f465e170a16637f6dd04c47f35f42a8a91d", + "size": 44049, + "subdir": "linux-64", + "timestamp": 1668715107936, + "version": "2.0.1" + }, + "flask-caching-2.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib >=0.9.0", + "flask <3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7b981c5a0b56de3ab9d9931c02076314", + "name": "flask-caching", + "sha256": "ea82bd16d577f3c1d09cc48f79f114b0caf08b88e36552c1fbe39585fcca38f5", + "size": 44285, + "subdir": "linux-64", + "timestamp": 1668715135845, + "version": "2.0.1" + }, + "flask-caching-2.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib >=0.9.0", + "flask <3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "42370e2aa0f8214da85630cb0ef7a576", + "name": "flask-caching", + "sha256": "d3899fdff94ddfae4814f6cb054b86070d8ff9fc160569deebf85326b6e81084", + "size": 44401, + "subdir": "linux-64", + "timestamp": 1668715191514, + "version": "2.0.1" + }, + "flask-compress-1.13-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "brotli-python", + "flask", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "362bf07ae1c582978c01ecd2d465c17e", + "name": "flask-compress", + "sha256": "8417610ed62a547426927f8b9d0a838c62d255f17fc6bdc0bb5fdafdde284f8f", + "size": 17690, + "subdir": "linux-64", + "timestamp": 1668715006122, + "version": "1.13" + }, + "flask-compress-1.13-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "brotli-python", + "flask", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43a8089f9b9977425dbee0f65c524591", + "name": "flask-compress", + "sha256": "e155ad2b930b3202c11d52eb0c8d7ab41c9f8a838000f225bb944d2615943bfe", + "size": 20336, + "subdir": "linux-64", + "timestamp": 1676839847005, + "version": "1.13" + }, + "flask-compress-1.13-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "brotli-python", + "flask", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4c65fe40ab24c593c2cda430677ef0cb", + "name": "flask-compress", + "sha256": "9944b39aebe715dd840bfd4193d1aa5cb7c1c9179d766b812de4e280352e6704", + "size": 17631, + "subdir": "linux-64", + "timestamp": 1668715036630, + "version": "1.13" + }, + "flask-compress-1.13-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "brotli-python", + "flask", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0803e0376719e79b69304be4747c1f0", + "name": "flask-compress", + "sha256": "d7fff225ef426dacb85b784d913f30851ff7502e30bfba5ba213c9b79e7738a3", + "size": 17670, + "subdir": "linux-64", + "timestamp": 1668714975815, + "version": "1.13" + }, + "flask-compress-1.13-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "brotli-python", + "flask", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "edac1b1e75c0d461ed0eadf930943f9a", + "name": "flask-compress", + "sha256": "5dabb5edde61ba162a0b31f5bf9e0c90c43597fe2af23c1c7b59f5f428ae88db", + "size": 17653, + "subdir": "linux-64", + "timestamp": 1668715066506, + "version": "1.13" + }, + "flask-cors-3.0.3-py27h1a8a27f_0.tar.bz2": { + "build": "py27h1a8a27f_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c9e2f66d809952b3883cc05ef7e4de6", + "name": "flask-cors", + "sha256": "1021aef09259a61c6817464729024753dfb319ba4366581489f18b7fd7aa8f6b", + "size": 20138, + "subdir": "linux-64", + "timestamp": 1505740446272, + "version": "3.0.3" + }, + "flask-cors-3.0.3-py35h9b2065d_0.tar.bz2": { + "build": "py35h9b2065d_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b2a96d9bfb3b54f6fe031729fe77300", + "name": "flask-cors", + "sha256": "28e87a1463b93802b58f8bb8fe6a7a53eb94bf5b67b291560088146353cd345e", + "size": 20590, + "subdir": "linux-64", + "timestamp": 1505740459106, + "version": "3.0.3" + }, + "flask-cors-3.0.3-py36h2d857d3_0.tar.bz2": { + "build": "py36h2d857d3_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e56d507d043c981d7c3005477345d6f", + "name": "flask-cors", + "sha256": "5a364a6b4bc8897d8e8f66f333d61db2945279cdead03e1b44d0c7e9d4ffa212", + "size": 20464, + "subdir": "linux-64", + "timestamp": 1505740472201, + "version": "3.0.3" + }, + "flask-cors-3.0.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ff0a1ac05a6a8cc4418f844fe2130bc", + "name": "flask-cors", + "sha256": "a62b94036df1465b0f180bcf1abeef6c49175190e9e7c1408098d3ed664cdbb5", + "size": 20872, + "subdir": "linux-64", + "timestamp": 1525812647683, + "version": "3.0.4" + }, + "flask-cors-3.0.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0aaf50a8915ffe6d85496cf6b4075245", + "name": "flask-cors", + "sha256": "59a9d8dc956ddfc57277e43cadbe357b9e60d86dd09a975d070ec764dbf416f5", + "size": 21330, + "subdir": "linux-64", + "timestamp": 1525812691182, + "version": "3.0.4" + }, + "flask-cors-3.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9dd28ca1ddcd97bcec2e79a943d1e278", + "name": "flask-cors", + "sha256": "90715f7589890cf91272c24ae585d9441728db49c2320ec1d240ecfdf68bf1c4", + "size": 21169, + "subdir": "linux-64", + "timestamp": 1525812746295, + "version": "3.0.4" + }, + "flask-cors-3.0.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1387a0501072f8a56423f1b45d778d55", + "name": "flask-cors", + "sha256": "8540ce06221ef5bab362e94c5a29bb0264576e219a6f918737c650eb9200d5a1", + "size": 20848, + "subdir": "linux-64", + "timestamp": 1529347022400, + "version": "3.0.6" + }, + "flask-cors-3.0.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6c532a3c1a3a6bd2884d190d44e55a8", + "name": "flask-cors", + "sha256": "63465dce2aef612350355125aa01b8a5a883a364e5f5562a51e50559cf955df5", + "size": 21255, + "subdir": "linux-64", + "timestamp": 1529347037592, + "version": "3.0.6" + }, + "flask-cors-3.0.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37cca6627d3c4f91dfa2927425843d90", + "name": "flask-cors", + "sha256": "826953b606a0fa234d720d902276bd53cf9368c62c90c01c7be561ff6a980176", + "size": 21093, + "subdir": "linux-64", + "timestamp": 1529347006906, + "version": "3.0.6" + }, + "flask-cors-3.0.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1da4c6d31c11fd9a0a78c1139322c58e", + "name": "flask-cors", + "sha256": "1f6e94e3c0088e8a3ea1aa08068d1842ae6ed34d58f2fd5896b6d384d8afd837", + "size": 21141, + "subdir": "linux-64", + "timestamp": 1530771801305, + "version": "3.0.6" + }, + "flask-cors-3.0.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a26d2491066f4c26c60d1a37e73d8594", + "name": "flask-cors", + "sha256": "3678c87944069c2b68680ee3e89db71b30f62cb46f21f7b0efeaceb76a8d2991", + "size": 21256, + "subdir": "linux-64", + "timestamp": 1542079353810, + "version": "3.0.7" + }, + "flask-cors-3.0.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6302ce2465c84c45102901cdc49ffd48", + "name": "flask-cors", + "sha256": "4da4afee3d428896df19196720f7357ffbee3c18f6a3f5b10a77351109764ee1", + "size": 21548, + "subdir": "linux-64", + "timestamp": 1542079403453, + "version": "3.0.7" + }, + "flask-cors-3.0.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd28877b30cfe0254854cc776fcd3e59", + "name": "flask-cors", + "sha256": "3cc75b6fcc598c4cd0d117d6824fb756c0b3800d4f4e3ea4d65d62d0c3775806", + "size": 21560, + "subdir": "linux-64", + "timestamp": 1542079340072, + "version": "3.0.7" + }, + "flask-jwt-extended-4.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.3.1", + "flask >=2.0,<3.0", + "pyjwt >=2.0,<3.0", + "python >=3.10,<3.11.0a0", + "werkzeug >=0.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c5ab8caa4c0a4b77870051e5112f3e4", + "name": "flask-jwt-extended", + "sha256": "427c8374f750125cba601c4af4c4fe71e65ce8429afb6aaa8f4ac32b88085657", + "size": 37688, + "subdir": "linux-64", + "timestamp": 1659620747921, + "version": "4.4.3" + }, + "flask-jwt-extended-4.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.3.1", + "flask >=2.0,<3.0", + "pyjwt >=2.0,<3.0", + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.7.4", + "werkzeug >=0.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "029495067adb303426931ac77210e7d2", + "name": "flask-jwt-extended", + "sha256": "e4ca5bbf1520f95bb96e6cf4225c7a5877d57acc74c9c916fb83bef021e1db90", + "size": 37295, + "subdir": "linux-64", + "timestamp": 1659620769909, + "version": "4.4.3" + }, + "flask-jwt-extended-4.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.3.1", + "flask >=2.0,<3.0", + "pyjwt >=2.0,<3.0", + "python >=3.8,<3.9.0a0", + "werkzeug >=0.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3247296b099d426b28d897abc31916eb", + "name": "flask-jwt-extended", + "sha256": "079b7ef67faacf6bfee42461438f7127b999aaf5a2661fedc70791bd1bb548b2", + "size": 37453, + "subdir": "linux-64", + "timestamp": 1659620693293, + "version": "4.4.3" + }, + "flask-jwt-extended-4.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.3.1", + "flask >=2.0,<3.0", + "pyjwt >=2.0,<3.0", + "python >=3.9,<3.10.0a0", + "werkzeug >=0.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc39f8dad83aa231ba246c3d5e927e56", + "name": "flask-jwt-extended", + "sha256": "5d7f6ba3025672fcd63908af2bfe200ef572a59a20dc8c914b8e8b175909b020", + "size": 37464, + "subdir": "linux-64", + "timestamp": 1659620715616, + "version": "4.4.3" + }, + "flask-jwt-extended-4.4.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.3.1", + "flask >=2.0,<3.0", + "pyjwt >=2.0,<3.0", + "python >=3.10,<3.11.0a0", + "werkzeug >=0.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6da35ebbb099ccd813d6b3c0f34d0bb2", + "name": "flask-jwt-extended", + "sha256": "4778a01e14a9d5331f32bd89f6f5c5dcb1c120374165e4f23c3819c3adf7de0f", + "size": 37534, + "subdir": "linux-64", + "timestamp": 1668814750559, + "version": "4.4.4" + }, + "flask-jwt-extended-4.4.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.3.1", + "flask >=2.0,<3.0", + "pyjwt >=2.0,<3.0", + "python >=3.11,<3.12.0a0", + "werkzeug >=0.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4feeb57fda4d39a70b7c9783afacedcc", + "name": "flask-jwt-extended", + "sha256": "7b8f7152f93df05166af85345763ec5dd953d42092ca47d35021061f81982551", + "size": 46594, + "subdir": "linux-64", + "timestamp": 1676827768723, + "version": "4.4.4" + }, + "flask-jwt-extended-4.4.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.3.1", + "flask >=2.0,<3.0", + "pyjwt >=2.0,<3.0", + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.7.4", + "werkzeug >=0.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e7cbdbd968572bd1524585041f23698d", + "name": "flask-jwt-extended", + "sha256": "21493c33fd968ac6041a4013af9e67a26ca987d309645ebcdd0856fe85e8309c", + "size": 37117, + "subdir": "linux-64", + "timestamp": 1668814803649, + "version": "4.4.4" + }, + "flask-jwt-extended-4.4.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.3.1", + "flask >=2.0,<3.0", + "pyjwt >=2.0,<3.0", + "python >=3.8,<3.9.0a0", + "werkzeug >=0.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb89bc1950485f85a57fb5455d36f020", + "name": "flask-jwt-extended", + "sha256": "d679501dfa0852f95541cce0a36d51c164916a559864e3f1e32faba17c99b01f", + "size": 37300, + "subdir": "linux-64", + "timestamp": 1668814830227, + "version": "4.4.4" + }, + "flask-jwt-extended-4.4.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.3.1", + "flask >=2.0,<3.0", + "pyjwt >=2.0,<3.0", + "python >=3.9,<3.10.0a0", + "werkzeug >=0.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "69dcf3bf0ee9c385cf0bd7adf067b9bb", + "name": "flask-jwt-extended", + "sha256": "95434c79a2a68e93db05d0ab1ce9349e1e4e4cefc31204dca39c1ba9b9ca9fd8", + "size": 37306, + "subdir": "linux-64", + "timestamp": 1668814776920, + "version": "4.4.4" + }, + "flask-login-0.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "daf906f54611c4216ecafdeb8088b515", + "name": "flask-login", + "sha256": "f56f63f044cb24c2000f5a7abf64e70fd9038e0ac5112bad8b9fffc3580a096a", + "size": 24413, + "subdir": "linux-64", + "timestamp": 1522774405699, + "version": "0.4.1" + }, + "flask-login-0.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flask", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "5998ddd890fcf69ea936ab95fba28f80", + "name": "flask-login", + "sha256": "540bdeef49d7fc4ed4a628c8ae78ec2b91017fd717f4ba9f6a2cdd97cf1a2fb5", + "size": 24738, + "subdir": "linux-64", + "timestamp": 1522774439302, + "version": "0.4.1" + }, + "flask-login-0.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "62033f74b05a3c17d5f64dbe1c2e3160", + "name": "flask-login", + "sha256": "b83b13386326edd837ea4e1a5a23019bbd1cca2e31b980dd7f8d3218aff292c7", + "size": 24761, + "subdir": "linux-64", + "timestamp": 1522774422150, + "version": "0.4.1" + }, + "flask-login-0.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flask", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "9462b924dc9f49416f6751f1b10b26f7", + "name": "flask-login", + "sha256": "a4ebab3b4f6ac969154458c9dcaffd3d1a7279ce7430a2da88ccb185c3cb5c45", + "size": 24624, + "subdir": "linux-64", + "timestamp": 1530877481765, + "version": "0.4.1" + }, + "flask-login-0.4.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "flask", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "154365d8213c7875493d4e7fcbca18d4", + "name": "flask-login", + "sha256": "8a17ca5968ae6d69ba4359d612f308799f69a79465681c8c0eee2b4d650d7f52", + "size": 25193, + "subdir": "linux-64", + "timestamp": 1574177518225, + "version": "0.4.1" + }, + "flask-login-0.6.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=1.0.4", + "python >=3.10,<3.11.0a0", + "werkzeug >=1.0.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d06ef0b6e3f7c730857e4ed9eeabddf6", + "name": "flask-login", + "sha256": "62291d3145bc9d9dd25037438379623445a0b21a554cd9fbe3775222a2e35b12", + "size": 28718, + "subdir": "linux-64", + "timestamp": 1669057640640, + "version": "0.6.2" + }, + "flask-login-0.6.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=1.0.4", + "python >=3.11,<3.12.0a0", + "werkzeug >=1.0.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da38bd64050fabc7bdfbaf5c83c80611", + "name": "flask-login", + "sha256": "3fe16700468520118ce48ba33640211cb6e91a9a9b4ae6e1dc446357c9d4eab1", + "size": 34644, + "subdir": "linux-64", + "timestamp": 1676827783031, + "version": "0.6.2" + }, + "flask-login-0.6.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=1.0.4", + "python >=3.7,<3.8.0a0", + "werkzeug >=1.0.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "faae8ff36a3c21e88b036c97899baa8a", + "name": "flask-login", + "sha256": "4f200b9e7db7cb6ace784f73e34aaf83b676c95ece9a5cc68b99f7452cfa33a1", + "size": 28571, + "subdir": "linux-64", + "timestamp": 1669057702910, + "version": "0.6.2" + }, + "flask-login-0.6.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=1.0.4", + "python >=3.8,<3.9.0a0", + "werkzeug >=1.0.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ccb92762b0450d79fe92e4afebada67f", + "name": "flask-login", + "sha256": "94bf69ffa028d8233e462a5fad259e1d40fc298b49dc203e8aab7c09663aea3b", + "size": 28659, + "subdir": "linux-64", + "timestamp": 1669057670819, + "version": "0.6.2" + }, + "flask-login-0.6.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=1.0.4", + "python >=3.9,<3.10.0a0", + "werkzeug >=1.0.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9de47ee4912702cc107c1a36fc1a5f76", + "name": "flask-login", + "sha256": "3c23f812ba854ee0cf0147cc6627e37f781cf44f03044cf3b4424794c79d3ff7", + "size": 28684, + "subdir": "linux-64", + "timestamp": 1669057611684, + "version": "0.6.2" + }, + "flask-openid-1.2.5-py27_1003.tar.bz2": { + "build": "py27_1003", + "build_number": 1003, + "depends": [ + "flask >=0.3", + "python >=2.7,<2.8.0a0", + "python-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b2164b7ed874e119c166d137439d96fd", + "name": "flask-openid", + "sha256": "2fefaf2d9ee35fa34b3a985bfd0fee8afca74fd7908bfb8ca142889806846f19", + "size": 20605, + "subdir": "linux-64", + "timestamp": 1579615662425, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py310h06a4308_1004.tar.bz2": { + "build": "py310h06a4308_1004", + "build_number": 1004, + "depends": [ + "flask >=0.10.1", + "python >=3.10,<3.11.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "438275b2bbd5452ace865039f17889af", + "name": "flask-openid", + "sha256": "90c6465f825faf480f1f959d621ac1720748e1e170b932a6cb5faf566aef49de", + "size": 21448, + "subdir": "linux-64", + "timestamp": 1659705525396, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py36_1003.tar.bz2": { + "build": "py36_1003", + "build_number": 1003, + "depends": [ + "flask >=0.10.1", + "python >=3.6,<3.7.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "30db4c8b91d76a81b94bb4b96fe55dff", + "name": "flask-openid", + "sha256": "6f36a59f8c9b376b21df7b9a6556e81c4990f14a276b234f056bf27bc639053b", + "size": 20670, + "subdir": "linux-64", + "timestamp": 1579615602010, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py36h06a4308_1003.tar.bz2": { + "build": "py36h06a4308_1003", + "build_number": 1003, + "depends": [ + "flask >=0.10.1", + "python >=3.6,<3.7.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "60eb6ef61398571cbab044d1676a3a28", + "name": "flask-openid", + "sha256": "fb463fda74055616d9a124ef925d8e467f68abb187c46184994dcb3d21e82467", + "size": 20990, + "subdir": "linux-64", + "timestamp": 1614089141014, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py37_1003.tar.bz2": { + "build": "py37_1003", + "build_number": 1003, + "depends": [ + "flask >=0.10.1", + "python >=3.7,<3.8.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e5aec282b1c4eda79f27ad997f0bc7e6", + "name": "flask-openid", + "sha256": "8f24b54373bfffbe35b1fbe6f197548606d0ace397f725791f11535b6d6e2cfa", + "size": 20655, + "subdir": "linux-64", + "timestamp": 1579615484229, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py37h06a4308_1003.tar.bz2": { + "build": "py37h06a4308_1003", + "build_number": 1003, + "depends": [ + "flask >=0.10.1", + "python >=3.7,<3.8.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c426e409d0d389c86dbe569ff8bef43a", + "name": "flask-openid", + "sha256": "027dae029c09a2d63ac18a2b8cc4cd812d6414b24220b5c31d60a45641a1385d", + "size": 21027, + "subdir": "linux-64", + "timestamp": 1614088203115, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py37h06a4308_1004.tar.bz2": { + "build": "py37h06a4308_1004", + "build_number": 1004, + "depends": [ + "flask >=0.10.1", + "python >=3.7,<3.8.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bf4d473bd349ee94d9ee3e2446694f16", + "name": "flask-openid", + "sha256": "55a13e47a981d06a13d4d311a7958e15813680715d8340321fb40f175aba505b", + "size": 21183, + "subdir": "linux-64", + "timestamp": 1659705547694, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py38_1003.tar.bz2": { + "build": "py38_1003", + "build_number": 1003, + "depends": [ + "flask >=0.10.1", + "python >=3.8,<3.9.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7ea839bfe4070ba80b8c5dcb971b3648", + "name": "flask-openid", + "sha256": "e21df803f14c1fa86a13ebc707fbeca1104ed50c0d9f63512887d7f859198c6c", + "size": 20759, + "subdir": "linux-64", + "timestamp": 1579615760879, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py38h06a4308_1003.tar.bz2": { + "build": "py38h06a4308_1003", + "build_number": 1003, + "depends": [ + "flask >=0.10.1", + "python >=3.8,<3.9.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6396849f3a27ec0d83d25b6d09c386a9", + "name": "flask-openid", + "sha256": "b1d9113e8d80917ec5215f4458adca04e17315c189dee39588bae81f1b3ec9b2", + "size": 21125, + "subdir": "linux-64", + "timestamp": 1614089137698, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py38h06a4308_1004.tar.bz2": { + "build": "py38h06a4308_1004", + "build_number": 1004, + "depends": [ + "flask >=0.10.1", + "python >=3.8,<3.9.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f06395cfed46cef4a2f024d724084beb", + "name": "flask-openid", + "sha256": "24acdefb07bb97fb175a3900aff8f3c29e3528e1880f1263f2acce41e9e29545", + "size": 21236, + "subdir": "linux-64", + "timestamp": 1659705493387, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py39h06a4308_1003.tar.bz2": { + "build": "py39h06a4308_1003", + "build_number": 1003, + "depends": [ + "flask >=0.10.1", + "python >=3.9,<3.10.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "60c597145036ae525db10915977ce955", + "name": "flask-openid", + "sha256": "df2d73a39d7942e3c97b278d7d5e2859ab27ee40655cd71046c4cfb5b964b0a9", + "size": 21115, + "subdir": "linux-64", + "timestamp": 1614089014804, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py39h06a4308_1004.tar.bz2": { + "build": "py39h06a4308_1004", + "build_number": 1004, + "depends": [ + "flask >=0.10.1", + "python >=3.9,<3.10.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0c6f9f84ec53e142e7b53b6d416b53a0", + "name": "flask-openid", + "sha256": "68e44991a57764f27fee8ca3b31ca3bebe7408750512e509c55fe9c797c9ae2c", + "size": 21223, + "subdir": "linux-64", + "timestamp": 1659705471317, + "version": "1.2.5" + }, + "flask-openid-1.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.10.1", + "python >=3.10,<3.11.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f70b25babae18690832f1022b140dbc6", + "name": "flask-openid", + "sha256": "8c8f1244a33c70c0035bede4af168c169bc60b3c51f9340e373f20052589c4ec", + "size": 19194, + "subdir": "linux-64", + "timestamp": 1640855875858, + "version": "1.3.0" + }, + "flask-openid-1.3.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "flask >=0.10.1", + "python >=3.10,<3.11.0a0", + "python3-openid >=2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cfe2790ab4ad8d79d0b4ff23adbfe636", + "name": "flask-openid", + "sha256": "dc4296c38e03f33ac2060df571031a302ae5de2a71d9187811ff85f23681b37b", + "size": 19440, + "subdir": "linux-64", + "timestamp": 1669237466920, + "version": "1.3.0" + }, + "flask-openid-1.3.0-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "flask >=0.10.1", + "python >=3.11,<3.12.0a0", + "python3-openid >=2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c7752fd8eb599253937983dc27c950a1", + "name": "flask-openid", + "sha256": "b9fac56bba6a1fb316db039fc2d46cc0f1d2354e772de8735de556af5b08897f", + "size": 23674, + "subdir": "linux-64", + "timestamp": 1676852419943, + "version": "1.3.0" + }, + "flask-openid-1.3.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "flask >=0.10.1", + "python >=3.7,<3.8.0a0", + "python3-openid >=2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f83ccc88aab94c73aa139392e934d9a7", + "name": "flask-openid", + "sha256": "c78a952a252bd27762c19f7a197bc4e0981043f62cdb92c6307da29f08177be3", + "size": 19172, + "subdir": "linux-64", + "timestamp": 1669237416631, + "version": "1.3.0" + }, + "flask-openid-1.3.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "flask >=0.10.1", + "python >=3.8,<3.9.0a0", + "python3-openid >=2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "132da455904c0d9264a874e19328590b", + "name": "flask-openid", + "sha256": "adc0db27e8cb832c8c0e33d44e92dd3bf20be7cc96077582b4cd87c6280b3425", + "size": 19276, + "subdir": "linux-64", + "timestamp": 1669237441926, + "version": "1.3.0" + }, + "flask-openid-1.3.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "flask >=0.10.1", + "python >=3.9,<3.10.0a0", + "python3-openid >=2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "08c03d6e41e1adf78805650f444d87a8", + "name": "flask-openid", + "sha256": "efc79a2c6e8d0e73ce929fdd4166e3b0d7eb0e22b39f256f3c18b9e3c8af07e6", + "size": 19241, + "subdir": "linux-64", + "timestamp": 1669237390959, + "version": "1.3.0" + }, + "flask-restful-0.3.9-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8", + "python >=3.10,<3.11.0a0", + "pytz", + "six >=1.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9486d84507cf438b0b438d133cefd364", + "name": "flask-restful", + "sha256": "3eed8acd523360bd741d6db3544397a8fc4bf5a48a240dc1c47919aff761ecd7", + "size": 44896, + "subdir": "linux-64", + "timestamp": 1669054959628, + "version": "0.3.9" + }, + "flask-restful-0.3.9-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8", + "python >=3.11,<3.12.0a0", + "pytz", + "six >=1.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "526fa50065c82b41ffc83b264c3eb90d", + "name": "flask-restful", + "sha256": "533da071981d8585d8ed719779427755c91aa4300604656e39033366669c26a5", + "size": 56660, + "subdir": "linux-64", + "timestamp": 1676852434755, + "version": "0.3.9" + }, + "flask-restful-0.3.9-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8", + "python >=3.7,<3.8.0a0", + "pytz", + "six >=1.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d56f71138e713b316911ed4f6293b35a", + "name": "flask-restful", + "sha256": "a6c2bdbde3407e1a59202c06e85f54608f6c49921673318142e4d73e5ff51b29", + "size": 44479, + "subdir": "linux-64", + "timestamp": 1669054906396, + "version": "0.3.9" + }, + "flask-restful-0.3.9-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8", + "python >=3.8,<3.9.0a0", + "pytz", + "six >=1.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "465ec9a35b3c4a17000e8d365443cc9a", + "name": "flask-restful", + "sha256": "1f6c5e6122ef40ad5eed8e87f6d84396348db1eead999e03af328c82c1304505", + "size": 44692, + "subdir": "linux-64", + "timestamp": 1669054932982, + "version": "0.3.9" + }, + "flask-restful-0.3.9-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8", + "python >=3.9,<3.10.0a0", + "pytz", + "six >=1.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dba7ec5cdb2f8d2a11d481c0fdb6473a", + "name": "flask-restful", + "sha256": "f794a0027e40cb139a18e302da57799887997ab5464dffc6999a10dcbe683baa", + "size": 44741, + "subdir": "linux-64", + "timestamp": 1669054985844, + "version": "0.3.9" + }, + "flask-restx-1.0.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8,!=2.0.0", + "jsonschema", + "python >=3.10,<3.11.0a0", + "pytz", + "werkzeug !=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3bf9752d9dbb3a37bbf416e8d840cbc7", + "name": "flask-restx", + "sha256": "72ac7f45c4fe3276277289305bd8ed5c9dc9aa8fe178c02426e4524669c55c39", + "size": 4591954, + "subdir": "linux-64", + "timestamp": 1669057147147, + "version": "1.0.3" + }, + "flask-restx-1.0.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8,!=2.0.0", + "jsonschema", + "python >=3.11,<3.12.0a0", + "pytz", + "werkzeug !=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c536c9bce2584e1b4889e3b0e21122c0", + "name": "flask-restx", + "sha256": "606245a1766f62936ed6c65dd7221714c198a3b42298cd68e030395199495dcc", + "size": 4593364, + "subdir": "linux-64", + "timestamp": 1676852453377, + "version": "1.0.3" + }, + "flask-restx-1.0.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8,!=2.0.0", + "jsonschema", + "python >=3.7,<3.8.0a0", + "pytz", + "werkzeug !=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "824ee06d95bf7dd64bdd12aca29fd222", + "name": "flask-restx", + "sha256": "4823708ca5270d53c3257ccf91040eae17911383e8f43a549d62f6d20ecbbf66", + "size": 4588334, + "subdir": "linux-64", + "timestamp": 1669057182040, + "version": "1.0.3" + }, + "flask-restx-1.0.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8,!=2.0.0", + "jsonschema", + "python >=3.8,<3.9.0a0", + "pytz", + "werkzeug !=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "595627276545b06f98b12a9fd39527db", + "name": "flask-restx", + "sha256": "6d5298f1137f21cfafd44563f85dcd4cebfd4d41ac4d794e47a3c622300ae1aa", + "size": 4587383, + "subdir": "linux-64", + "timestamp": 1669057109292, + "version": "1.0.3" + }, + "flask-restx-1.0.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8,!=2.0.0", + "jsonschema", + "python >=3.9,<3.10.0a0", + "pytz", + "werkzeug !=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f189723e00061b5396bee304a3c60d39", + "name": "flask-restx", + "sha256": "8a44ee0fe64c92601206a968406f6d7a487b70edd8b482b33b393c1de8df2ad6", + "size": 4586886, + "subdir": "linux-64", + "timestamp": 1669057219721, + "version": "1.0.3" + }, + "flask-session-0.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib", + "flask >=0.8", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2e18ea3a517a987e7c9b761d05db420c", + "name": "flask-session", + "sha256": "cfd69df775f95f7411d8ac38e2c00700cc244786b3f6311e0ea8a42e787652cf", + "size": 17005, + "subdir": "linux-64", + "timestamp": 1659857606374, + "version": "0.4.0" + }, + "flask-session-0.4.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib", + "flask >=0.8", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "afa98bc5e2fac6ba7c39e1b6fbc3f97d", + "name": "flask-session", + "sha256": "ef6d4df40b3aadec071ed6bb336c70bea6b8927d3cbf3cfef4cf9b7ec1c29a5d", + "size": 21407, + "subdir": "linux-64", + "timestamp": 1676830558905, + "version": "0.4.0" + }, + "flask-session-0.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib", + "flask >=0.8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f82d63757d025c2e0c9d77583d9d659f", + "name": "flask-session", + "sha256": "aa808b089bbc3ae1dc35c992809fdc8d22640253e2503bc009aba31a04ea5243", + "size": 16855, + "subdir": "linux-64", + "timestamp": 1659857534518, + "version": "0.4.0" + }, + "flask-session-0.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib", + "flask >=0.8", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d68785b4bdfab376f3130d9ab45d364f", + "name": "flask-session", + "sha256": "76f1e769a8cff3e160e82b6d3f04531bfc7f7340b81a0d446f36fd486371f3ed", + "size": 16913, + "subdir": "linux-64", + "timestamp": 1659857507173, + "version": "0.4.0" + }, + "flask-session-0.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib", + "flask >=0.8", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "557600b9f1c55276920c4c48c06a4f9a", + "name": "flask-session", + "sha256": "ddf95cc7489deacb532e4f33bc190b9e82ca160a85aae8c9d560f744281ddfeb", + "size": 16922, + "subdir": "linux-64", + "timestamp": 1659857566057, + "version": "0.4.0" + }, + "flask-socketio-2.9.2-py27hbb26ec0_0.tar.bz2": { + "build": "py27hbb26ec0_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "python-engineio >=1.0.0", + "python-socketio >=1.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f268118cd0f5b9e2d6abbeb21f2bdbf4", + "name": "flask-socketio", + "sha256": "df944fca113b8bbc6a8c026e6b36fc86b51165a2d3813328080e9b43c4eb307f", + "size": 25812, + "subdir": "linux-64", + "timestamp": 1512043280984, + "version": "2.9.2" + }, + "flask-socketio-2.9.2-py35ha1def9a_0.tar.bz2": { + "build": "py35ha1def9a_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.5,<3.6.0a0", + "python-engineio >=1.0.0", + "python-socketio >=1.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "42e6dcf6b8638af4d189f1182c260a1c", + "name": "flask-socketio", + "sha256": "3141a1ebd328bf6e8d690707d453f10240f6f22c4ee9764b0ef799437b1ef19d", + "size": 26294, + "subdir": "linux-64", + "timestamp": 1512043285249, + "version": "2.9.2" + }, + "flask-socketio-2.9.2-py36hec8e26b_0.tar.bz2": { + "build": "py36hec8e26b_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "python-engineio >=1.0.0", + "python-socketio >=1.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7a51a4b011b3585ac22982ac5e080d6", + "name": "flask-socketio", + "sha256": "cd8d700aa278d65fd734201160cf5f8634d2c7ed9532273dbddc205ea4084621", + "size": 26171, + "subdir": "linux-64", + "timestamp": 1512043284131, + "version": "2.9.2" + }, + "flask-socketio-2.9.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71fad74d1762c130ce8a6f102e620389", + "name": "flask-socketio", + "sha256": "ef6a020b9f4aa7ba31ee43b0ee37759d062aeecf974b74aa96ec44b9adf3a3b2", + "size": 25736, + "subdir": "linux-64", + "timestamp": 1522193682046, + "version": "2.9.3" + }, + "flask-socketio-2.9.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.5,<3.6.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad21b8cd486be541d913578446acc443", + "name": "flask-socketio", + "sha256": "daa1728a3889f9d27490059edfb385a71d08168eb2830a029c86c7415efaf2e5", + "size": 26240, + "subdir": "linux-64", + "timestamp": 1522193698117, + "version": "2.9.3" + }, + "flask-socketio-2.9.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8bc63da4b47c97d680668fb9724b7ebb", + "name": "flask-socketio", + "sha256": "f32bc253205e875553613f80ed8b5315b5fd7bd8b5bc1c679673d84cc54b1f5a", + "size": 26185, + "subdir": "linux-64", + "timestamp": 1522193699559, + "version": "2.9.3" + }, + "flask-socketio-2.9.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fbd3d5171db8ae01c05b1347fb781656", + "name": "flask-socketio", + "sha256": "b263457304857bd0c23f7363e99c30842920ccd3de32ad11dc05f5352cd424f4", + "size": 26001, + "subdir": "linux-64", + "timestamp": 1522096773375, + "version": "2.9.6" + }, + "flask-socketio-2.9.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.5,<3.6.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6dfde4727b70eb745a02353fca78ae3", + "name": "flask-socketio", + "sha256": "f6b6eae02c9ee0a108eb8f9cf898cf980fbc767f9ff64efa2f23e4451c6f298c", + "size": 26486, + "subdir": "linux-64", + "timestamp": 1522096823780, + "version": "2.9.6" + }, + "flask-socketio-2.9.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee017a2e78113752834ee5ba25d2494d", + "name": "flask-socketio", + "sha256": "cabcb5b63b0f8192401d4fab264c177358bdd2761b674871246a386b4202421d", + "size": 26477, + "subdir": "linux-64", + "timestamp": 1522096825021, + "version": "2.9.6" + }, + "flask-socketio-3.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b0900f2969bb34996cc2ed358efbafd6", + "name": "flask-socketio", + "sha256": "7443c520b5b253ce7fcdcdf441e236b2a328fc6efb665a810c2303a6a9f711d4", + "size": 26345, + "subdir": "linux-64", + "timestamp": 1526939404685, + "version": "3.0.0" + }, + "flask-socketio-3.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.5,<3.6.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01fe7cc4bfa04bee1a0b36c5bc79deb4", + "name": "flask-socketio", + "sha256": "63913e49bca15da84656602b76800aef3b8b251b91c31fce2f2603a3a17b1187", + "size": 26826, + "subdir": "linux-64", + "timestamp": 1526939419261, + "version": "3.0.0" + }, + "flask-socketio-3.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "639129f29faf0910d2f78cef227eb660", + "name": "flask-socketio", + "sha256": "3fa2ed2b8517bbfe8e8c8d962b7ff81e48aa4ac447603fa6f3c43155c52b1ff9", + "size": 26836, + "subdir": "linux-64", + "timestamp": 1526939383857, + "version": "3.0.0" + }, + "flask-socketio-3.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9ac5ac18272691c704f84a31667232e", + "name": "flask-socketio", + "sha256": "6c3ec19a62884d1b83c1ca1458c1ee7b731ea21ea8c188d36be9280128f61f52", + "size": 26491, + "subdir": "linux-64", + "timestamp": 1528221809127, + "version": "3.0.1" + }, + "flask-socketio-3.0.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.5,<3.6.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "07deaf1ddee8de36815cab0051a824c8", + "name": "flask-socketio", + "sha256": "4eb3083e7c03806a934e673c5e57d0c9aa4c10313e4269379a16555aaebe0e90", + "size": 26935, + "subdir": "linux-64", + "timestamp": 1528221822694, + "version": "3.0.1" + }, + "flask-socketio-3.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a1a867799fd4cefed348526aff6caa1e", + "name": "flask-socketio", + "sha256": "70a343f1198e5ac06fba20deb4a82f03fd61a6b10e98c40416269b35a5e1e8bc", + "size": 26931, + "subdir": "linux-64", + "timestamp": 1528221796599, + "version": "3.0.1" + }, + "flask-socketio-3.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.7,<3.8.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bf54e573664baae3fdf7507c75d09cc5", + "name": "flask-socketio", + "sha256": "2cd5eb892b08ad8b5c9e1e6b407d6ba6f7e193206372fae026345542b53082a9", + "size": 26953, + "subdir": "linux-64", + "timestamp": 1530877568507, + "version": "3.0.1" + }, + "flask-socketio-3.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4a365f5a787d05674ed46ce61cbe7e2f", + "name": "flask-socketio", + "sha256": "4534dff33acafb2c939c27f6233c992313ec3eb815bab0cc146e2e85a9407d87", + "size": 26933, + "subdir": "linux-64", + "timestamp": 1539656511789, + "version": "3.0.2" + }, + "flask-socketio-3.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "739c4c476c3f1b998e0eb08c0032e752", + "name": "flask-socketio", + "sha256": "98ac0cf764c439a1ccd330c9066a54acb12e6970208f42229b470ac8d4347756", + "size": 27415, + "subdir": "linux-64", + "timestamp": 1539656530287, + "version": "3.0.2" + }, + "flask-socketio-3.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.7,<3.8.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e71d72012ffc61ae1303496c62dc13b1", + "name": "flask-socketio", + "sha256": "da59718d83ffd4d7dd5d9df3035c87342655c4c19d3b1c3902f3cad5712b9652", + "size": 27465, + "subdir": "linux-64", + "timestamp": 1539656533110, + "version": "3.0.2" + }, + "flask-socketio-3.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "python-socketio >=2.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8792020b420100fb6e3596192bc5cde1", + "name": "flask-socketio", + "sha256": "0943cef5e70f854fe254d8cbec0fd7dfcba5bc7e96751f9d8ebe2016c1f8ec3a", + "size": 27019, + "subdir": "linux-64", + "timestamp": 1545166972153, + "version": "3.1.1" + }, + "flask-socketio-3.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "python-socketio >=2.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17d639cc52e0405a5eced34159bdeab4", + "name": "flask-socketio", + "sha256": "6ff564daa1385d02796578086a1f1eb283c15244e66ce22114bad475a5acd620", + "size": 27470, + "subdir": "linux-64", + "timestamp": 1545167026157, + "version": "3.1.1" + }, + "flask-socketio-3.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.7,<3.8.0a0", + "python-socketio >=2.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "91673404b75b5dadc31212d6c8a7ee63", + "name": "flask-socketio", + "sha256": "fad60bbebc455a3622f6a357e1e21f8e882ad8ed8b867cf82952aadc11480a25", + "size": 27462, + "subdir": "linux-64", + "timestamp": 1545167027548, + "version": "3.1.1" + }, + "flask-socketio-3.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "python-socketio >=2.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd392379a751b5184ab4af10e976a122", + "name": "flask-socketio", + "sha256": "8edb108f27f9d07cc92daac4998607bf0fd68c075317e6b8b7a034f9dac26a8b", + "size": 29648, + "subdir": "linux-64", + "timestamp": 1547229204605, + "version": "3.1.2" + }, + "flask-socketio-3.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "python-socketio >=2.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "593ce0fcdcd7f4c9f39d42864f1e2b6f", + "name": "flask-socketio", + "sha256": "8e3a9fa426838632a369a5949714aa6ffd0a9b827336e27f7df937c819005be1", + "size": 30138, + "subdir": "linux-64", + "timestamp": 1547229207623, + "version": "3.1.2" + }, + "flask-socketio-3.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.7,<3.8.0a0", + "python-socketio >=2.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "246695c36471faf3fc37d05caa86f420", + "name": "flask-socketio", + "sha256": "bc21e941ac1f854dac90d908f7c0c46b413d342d2208c0f3ee8eadf501b1c6f9", + "size": 30194, + "subdir": "linux-64", + "timestamp": 1547229233734, + "version": "3.1.2" + }, + "flask-socketio-5.3.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.10,<3.11.0a0", + "python-socketio >=5.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1571a015a68a056614718a8011d45e7f", + "name": "flask-socketio", + "sha256": "ca3e92ca6c9d41e344c26733364e9f06506220c14c4a111c2ee2939953de50dc", + "size": 31190, + "subdir": "linux-64", + "timestamp": 1669060278710, + "version": "5.3.1" + }, + "flask-socketio-5.3.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.11,<3.12.0a0", + "python-socketio >=5.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d527a2a7f90bd4127f0f61a0ca49d55", + "name": "flask-socketio", + "sha256": "19e9ada7e5d3f1ef2a2b2b6494ae592041179b5d868b9983aaf787d2ab79a6e0", + "size": 38088, + "subdir": "linux-64", + "timestamp": 1676852472081, + "version": "5.3.1" + }, + "flask-socketio-5.3.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.7,<3.8.0a0", + "python-socketio >=5.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "07bd9ddb8f1a19cf88ca7891aa9fc2de", + "name": "flask-socketio", + "sha256": "6e5b269443770517e2b9b64853c27df853929e2d47fa5dd01441d824c07fcf15", + "size": 30898, + "subdir": "linux-64", + "timestamp": 1669060307821, + "version": "5.3.1" + }, + "flask-socketio-5.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.8,<3.9.0a0", + "python-socketio >=5.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "84699d5bf3fa4598e12892161bccae65", + "name": "flask-socketio", + "sha256": "10d5bcb5ceddce40233cc0db8a61f0cab63967eb0b37b5ef9ae808f520b541b5", + "size": 31066, + "subdir": "linux-64", + "timestamp": 1669060249099, + "version": "5.3.1" + }, + "flask-socketio-5.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.9,<3.10.0a0", + "python-socketio >=5.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "200ac559968d25940accf38ea3271111", + "name": "flask-socketio", + "sha256": "b95b19745d99f80038987a29274f086c04946ae4d84a7bd32f3a42118d4ed866", + "size": 31106, + "subdir": "linux-64", + "timestamp": 1669060336743, + "version": "5.3.1" + }, + "flask-sqlalchemy-2.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.10", + "python >=2.7,<2.8.0a0", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a50d197e1b7a010a24d9a12d8a82f014", + "name": "flask-sqlalchemy", + "sha256": "c42de16311ce7ecb886114b2ee0dd73908732139e3eb896b783c9fc24e5d926d", + "size": 28080, + "subdir": "linux-64", + "timestamp": 1536858960389, + "version": "2.3.2" + }, + "flask-sqlalchemy-2.3.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flask >=0.10", + "python >=3.5,<3.6.0a0", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eaa05254d59aea681470932e17f864de", + "name": "flask-sqlalchemy", + "sha256": "f1ec0063e7c767ee59b0efd475709f813d6df9333d475bc025b252b933dc3d36", + "size": 28674, + "subdir": "linux-64", + "timestamp": 1536858754356, + "version": "2.3.2" + }, + "flask-sqlalchemy-2.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.10", + "python >=3.6,<3.7.0a0", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "17e948da0a4277777aee7a5f37e80fd4", + "name": "flask-sqlalchemy", + "sha256": "4747a21240d60aa6546b9b6abbf0058502ad988cc4b450ad9fc7bc12b80f9d07", + "size": 28637, + "subdir": "linux-64", + "timestamp": 1536858974213, + "version": "2.3.2" + }, + "flask-sqlalchemy-2.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flask >=0.10", + "python >=3.7,<3.8.0a0", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "36fe834544167efa3cff1f61807f7874", + "name": "flask-sqlalchemy", + "sha256": "c91f153f294342e6da76fbecfbd2ea572b91bc769d18eaefd2db47d33f1f408a", + "size": 28679, + "subdir": "linux-64", + "timestamp": 1536858675607, + "version": "2.3.2" + }, + "flask-sqlalchemy-3.0.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=2.2", + "python >=3.10,<3.11.0a0", + "sqlalchemy >=1.4.18" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "de8d8d79747f94a6cff0d4283f6426f7", + "name": "flask-sqlalchemy", + "sha256": "d98ee68ae6e6672a711a6d726b8680891a476fc89199e12f0ec027e8085a028e", + "size": 38088, + "subdir": "linux-64", + "timestamp": 1671219175110, + "version": "3.0.2" + }, + "flask-sqlalchemy-3.0.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=2.2", + "python >=3.11,<3.12.0a0", + "sqlalchemy >=1.4.18" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "53f948d953c68940ad09e849cdac7c6e", + "name": "flask-sqlalchemy", + "sha256": "6887fef5f4aaf139b954b2fad460f9bdd12612d3862c80a0d9de52269d7c3960", + "size": 46419, + "subdir": "linux-64", + "timestamp": 1676827797884, + "version": "3.0.2" + }, + "flask-sqlalchemy-3.0.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=2.2", + "python >=3.7,<3.8.0a0", + "sqlalchemy >=1.4.18" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "15b1bfa83143a4a20963f3fc59db8090", + "name": "flask-sqlalchemy", + "sha256": "128a9bc38e67e74238c729fd01f64cd47e049433a129b8b25f1eb7304b85d155", + "size": 37574, + "subdir": "linux-64", + "timestamp": 1671219228473, + "version": "3.0.2" + }, + "flask-sqlalchemy-3.0.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=2.2", + "python >=3.8,<3.9.0a0", + "sqlalchemy >=1.4.18" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "12cf7eaad6e2a7c981cfdb27daec7f13", + "name": "flask-sqlalchemy", + "sha256": "cf9a52ec2eb0bb81bf7ea930ed7072a496f5c12145e01474de7ecf319640a932", + "size": 37681, + "subdir": "linux-64", + "timestamp": 1671219201525, + "version": "3.0.2" + }, + "flask-sqlalchemy-3.0.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=2.2", + "python >=3.9,<3.10.0a0", + "sqlalchemy >=1.4.18" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d61e4ffba413246c7e9e46872a5d091b", + "name": "flask-sqlalchemy", + "sha256": "9ea39e1a0d81c1378108c5cc2cef1e41aa281fc89aa7035d9241f07accd785ad", + "size": 37653, + "subdir": "linux-64", + "timestamp": 1671219148094, + "version": "3.0.2" + }, + "flask-wtf-0.14.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "flask", + "python >=2.7,<2.8.0a0", + "werkzeug", + "wtforms" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2bc0fc56c34e743369e65f3ec10bbaf1", + "name": "flask-wtf", + "sha256": "a49f87cf33c0bd493ebc149607fae16e7c2e6b6bcea7e348225bed42e76f67ca", + "size": 23730, + "subdir": "linux-64", + "timestamp": 1537198180595, + "version": "0.14.2" + }, + "flask-wtf-0.14.2-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "flask", + "python >=3.5,<3.6.0a0", + "werkzeug", + "wtforms" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "81621a05beff8c4dd0217d9581fab206", + "name": "flask-wtf", + "sha256": "0d8a83ca71083df8503d49efca9b62620764a40c42f6662c5ce9e07116f5caef", + "size": 24260, + "subdir": "linux-64", + "timestamp": 1537198197999, + "version": "0.14.2" + }, + "flask-wtf-0.14.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "flask", + "python >=3.6,<3.7.0a0", + "werkzeug", + "wtforms" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2976710ef477924bcdeea02abacb9d05", + "name": "flask-wtf", + "sha256": "634bff0a3f38a8e94544ce5e690fdd2e05fbcd5a3b3eb5246d848819fda792be", + "size": 24241, + "subdir": "linux-64", + "timestamp": 1537198210598, + "version": "0.14.2" + }, + "flask-wtf-0.14.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "flask", + "python >=3.7,<3.8.0a0", + "werkzeug", + "wtforms" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cbd815847c8046c80fe73d7c4cae17e4", + "name": "flask-wtf", + "sha256": "f8a76e42ae7e0c9d49a3801f313e3127592eae71aec0a1598280543ce868d2b1", + "size": 24306, + "subdir": "linux-64", + "timestamp": 1537203907549, + "version": "0.14.2" + }, + "flask-wtf-1.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "email-validator", + "flask", + "itsdangerous", + "python >=3.10,<3.11.0a0", + "werkzeug", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "606b91be13f640b3406c0440d4b9f0bd", + "name": "flask-wtf", + "sha256": "334029c81c5c3455715ac5d2bb4940444f4a94db12b71e194b854da5b8271c57", + "size": 23111, + "subdir": "linux-64", + "timestamp": 1668812635933, + "version": "1.0.1" + }, + "flask-wtf-1.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "email-validator", + "flask", + "itsdangerous", + "python >=3.11,<3.12.0a0", + "werkzeug", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "43066a52d85d08dfe1c2d91c397947cd", + "name": "flask-wtf", + "sha256": "f260ccf1036dab1d7f8083ce02e049cd5d521ff3d68bbd1f31342c2d9d16c8e8", + "size": 28493, + "subdir": "linux-64", + "timestamp": 1676827882149, + "version": "1.0.1" + }, + "flask-wtf-1.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "email-validator", + "flask", + "itsdangerous", + "python >=3.7,<3.8.0a0", + "werkzeug", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0555b652b90b5320200e193ae4b55a0c", + "name": "flask-wtf", + "sha256": "eda28c3692f54b54f12c71327be8baa5d5874f358c7dc95d7855d07917ffbae6", + "size": 22906, + "subdir": "linux-64", + "timestamp": 1668812606714, + "version": "1.0.1" + }, + "flask-wtf-1.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "email-validator", + "flask", + "itsdangerous", + "python >=3.8,<3.9.0a0", + "werkzeug", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "753be9a9f65c8328f0dfa67306799378", + "name": "flask-wtf", + "sha256": "b66cb501f3be38f96f676e7d22c84e7047c9f08dc2ff0617e2547f9468185a92", + "size": 23009, + "subdir": "linux-64", + "timestamp": 1668812577936, + "version": "1.0.1" + }, + "flask-wtf-1.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "email-validator", + "flask", + "itsdangerous", + "python >=3.9,<3.10.0a0", + "werkzeug", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fc4b55c44012c47aa88b0d932005fb19", + "name": "flask-wtf", + "sha256": "a68fd6e93f548aeb1c41c3e7b6562dcdcb0a91c5f55dc36cb6e19a3cedb1d99c", + "size": 22969, + "subdir": "linux-64", + "timestamp": 1668812549179, + "version": "1.0.1" + }, + "flatbuffers-1.10.0-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "md5": "02c92391322304b0658c95d3c01bb706", + "name": "flatbuffers", + "sha256": "fe5e0d08d6db51ea1434f397917508aff935e55f442ed78ec822bf1d78c82da3", + "size": 854644, + "subdir": "linux-64", + "timestamp": 1553104261966, + "version": "1.10.0" + }, + "flatbuffers-1.11.0-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "md5": "530ddbc449368ce4a3987f535beb9789", + "name": "flatbuffers", + "sha256": "bc2d0165f4d6f4636cbbc321275eea897f726e0955da55d92832a986470957aa", + "size": 885277, + "subdir": "linux-64", + "timestamp": 1559064706994, + "version": "1.11.0" + }, + "flatbuffers-1.12.0-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "md5": "dd5b221e45e24b7a642184b19c8477c8", + "name": "flatbuffers", + "sha256": "a11164ad224883149820d68017f9e3fa1ab7f96b215cd4e5c0b1995c2a346616", + "size": 1105518, + "subdir": "linux-64", + "timestamp": 1607037188008, + "version": "1.12.0" + }, + "flatbuffers-1.7.1-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "md5": "22b39e9935c2f26e710a3a18095f77b1", + "name": "flatbuffers", + "sha256": "c71c867e3d921c8555f6d97a8a5e0d544bae9535f7178863661844abdfbf80a2", + "size": 579216, + "subdir": "linux-64", + "timestamp": 1529361984513, + "version": "1.7.1" + }, + "flatbuffers-2.0.0-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "md5": "2d49c2c22ff354d63edce93308a44098", + "name": "flatbuffers", + "sha256": "0f707d1ee049635311f66f1c0801546af184156751088384851b7b1d33d293f4", + "size": 1219349, + "subdir": "linux-64", + "timestamp": 1620825878215, + "version": "2.0.0" + }, + "flex-2.6.4-ha10e3a4_1.tar.bz2": { + "build": "ha10e3a4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "m4" + ], + "license": "BSD 2-Clause", + "md5": "4d7f125b901465d7e34703dda348a76b", + "name": "flex", + "sha256": "fdcb64f216cd4e126d149c5b16e8da279ae687c67201da2e2f533d8f983c95f6", + "size": 342518, + "subdir": "linux-64", + "timestamp": 1505728637175, + "version": "2.6.4" + }, + "flit-1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils", + "pip", + "python >=3.5,<3.6.0a0", + "pytoml", + "requests", + "requests_download", + "zipfile36" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d900137e150749d43322aed0b6b9e28f", + "name": "flit", + "sha256": "2e784a9fd658911fda0bdae76531675c6f60435faf4c0259702725e50db62fcc", + "size": 80996, + "subdir": "linux-64", + "timestamp": 1529953172115, + "version": "1.0" + }, + "flit-1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils", + "pip", + "python >=3.6,<3.7.0a0", + "pytoml", + "requests", + "requests_download" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "bd7aaf63030c5967ca1e287e7e690606", + "name": "flit", + "sha256": "7a4482c6caafd30b4a97c63249f35cab4b4bb242095e2b4f55a69a0ac43396df", + "size": 80641, + "subdir": "linux-64", + "timestamp": 1529952774915, + "version": "1.0" + }, + "flit-1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils", + "pip", + "python >=3.7,<3.8.0a0", + "pytoml", + "requests", + "requests_download" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ca9749d6ab080df2a3f31b8541fab7c9", + "name": "flit", + "sha256": "239b8ad4f101d594bedd15dbc38ae3fbdd43f38f5aef6d89c87273e81d55f084", + "size": 80659, + "subdir": "linux-64", + "timestamp": 1530898115696, + "version": "1.0" + }, + "flit-1.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "docutils", + "pip", + "python >=3.5,<3.6.0a0", + "pytoml", + "requests", + "requests_download", + "zipfile36" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6314141288129283d9c2c69797942b67", + "name": "flit", + "sha256": "e5dbfd9dbee9927c8e6cd4c8ab2423367c22e0cd63ab70595911b89c30cb6f80", + "size": 83368, + "subdir": "linux-64", + "timestamp": 1535511849349, + "version": "1.1" + }, + "flit-1.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "docutils", + "pip", + "python >=3.6,<3.7.0a0", + "pytoml", + "requests", + "requests_download" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c5a74a801b8dea882104da6c7a328ae6", + "name": "flit", + "sha256": "993d1d519de3911a339f8127f4fcd38c6a212609af3abccb2072f29ff2552520", + "size": 82738, + "subdir": "linux-64", + "timestamp": 1535511828059, + "version": "1.1" + }, + "flit-1.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "docutils", + "pip", + "python >=3.7,<3.8.0a0", + "pytoml", + "requests", + "requests_download" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "428b069cf72ded5d7164f33d3536cdf9", + "name": "flit", + "sha256": "943407d06576f471e78df60179530fbf03f380d9d41d53171ffbd728c7203c63", + "size": 83019, + "subdir": "linux-64", + "timestamp": 1535511841879, + "version": "1.1" + }, + "flit-1.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils", + "pip", + "python >=3.6,<3.7.0a0", + "pytoml", + "requests", + "requests_download" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8537c14b170e07a22caaafb7f527795a", + "name": "flit", + "sha256": "46a3fc5df3413a039b760b13b89151d931a94b212e446cbf4c791dbb3ccedaa3", + "size": 83241, + "subdir": "linux-64", + "timestamp": 1538861582139, + "version": "1.2.1" + }, + "flit-1.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils", + "pip", + "python >=3.7,<3.8.0a0", + "pytoml", + "requests", + "requests_download" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "090223d1337ef7f06d4e2232dc90709e", + "name": "flit", + "sha256": "63645923d6ff3fd77c4ffc371309fb844a159d599bdd3e8dd1cd6f1dce4386ce", + "size": 83366, + "subdir": "linux-64", + "timestamp": 1538861561713, + "version": "1.2.1" + }, + "flit-1.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils", + "pip", + "python >=3.6,<3.7.0a0", + "pytoml", + "requests", + "requests_download" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c4cd2529249615fdb9937bae10facbdc", + "name": "flit", + "sha256": "1ed69708b63f78bff649962af14309942c236923b04f0c23fffea056ddfaadaa", + "size": 85820, + "subdir": "linux-64", + "timestamp": 1552377724665, + "version": "1.3" + }, + "flit-1.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils", + "pip", + "python >=3.7,<3.8.0a0", + "pytoml", + "requests", + "requests_download" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a36de17e5cda7f3af8cf2a4befbed32f", + "name": "flit", + "sha256": "2d6a28a6f69c96d1a6ad54edd5d3257ac3f1ff602c77fc7c8039c3d06ceed3ce", + "size": 85894, + "subdir": "linux-64", + "timestamp": 1552377662968, + "version": "1.3" + }, + "flit-3.8.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "flit-core 3.8.0 py310h06a4308_0", + "pip", + "python >=3.10,<3.11.0a0", + "requests", + "tomli-w" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d0661a68714a2acddd26b7067b8964d8", + "name": "flit", + "sha256": "07595ac182d37ef39fc8a1942ec4f83bda74432ae0dcf1c1e0fa4ecae19aad4d", + "size": 69461, + "subdir": "linux-64", + "timestamp": 1679397202550, + "version": "3.8.0" + }, + "flit-3.8.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "flit-core 3.8.0 py311h06a4308_0", + "pip", + "python >=3.11,<3.12.0a0", + "requests", + "tomli-w" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5d632094610d301d233b7f3f3f165f3f", + "name": "flit", + "sha256": "a4da8b78aa27b3febf72b303560fab930030ce05f990cb1f9bcb2a5e26aaaa4d", + "size": 87604, + "subdir": "linux-64", + "timestamp": 1679397299181, + "version": "3.8.0" + }, + "flit-3.8.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "flit-core 3.8.0 py38h06a4308_0", + "pip", + "python >=3.8,<3.9.0a0", + "requests", + "tomli-w" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c6d946d235b52f60ec5c63b25fdbade6", + "name": "flit", + "sha256": "37e4c7d3ded0f632a76c620912e97ff9da87109c4bba02d8ed0b85ac539be738", + "size": 68916, + "subdir": "linux-64", + "timestamp": 1679397250372, + "version": "3.8.0" + }, + "flit-3.8.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "flit-core 3.8.0 py39h06a4308_0", + "pip", + "python >=3.9,<3.10.0a0", + "requests", + "tomli-w" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6704c46b80a7aecdf9cee33d51e0e5cd", + "name": "flit", + "sha256": "f34efa3d19397fd235eb807594b34648f1da50fa3b28f475165fa916e098d148", + "size": 69011, + "subdir": "linux-64", + "timestamp": 1679397153552, + "version": "3.8.0" + }, + "flit-core-3.8.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ca5f0053895e7bc3a6bdf4ccebff513b", + "name": "flit-core", + "sha256": "3aec4b20e74375a3bfff97d6aacbc3c30f9540767cb9c8fca779974dd6680b2b", + "size": 81505, + "subdir": "linux-64", + "timestamp": 1679397188810, + "version": "3.8.0" + }, + "flit-core-3.8.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dcb1c5f2fc3cc2c183b30a92ef5432cd", + "name": "flit-core", + "sha256": "47faf062384995cbec50e2a654b865026bdd0f5c61b0309e85d3ae6e957d77ac", + "size": 106751, + "subdir": "linux-64", + "timestamp": 1679397285296, + "version": "3.8.0" + }, + "flit-core-3.8.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1b2ecebf246b333cbeecb24b68ea9bd6", + "name": "flit-core", + "sha256": "771c3b4d4f106bf36a0fea7cad85d5c30519543b69fb7ee24a2c9ef7d1c3107f", + "size": 80904, + "subdir": "linux-64", + "timestamp": 1679397237065, + "version": "3.8.0" + }, + "flit-core-3.8.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ef11f0d7dfd3967401016ea0b36eb409", + "name": "flit-core", + "sha256": "6b5c679162f710cedbdb324f57a3cd835b0590dfd4b3995c52a2b6906d27e223", + "size": 81046, + "subdir": "linux-64", + "timestamp": 1679397140311, + "version": "3.8.0" + }, + "flit-scm-1.7.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.5.0,<4", + "python >=3.10,<3.11.0a0", + "setuptools_scm >=6.4", + "tomli" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "599ebcd764fe79368b8d859bb45d151b", + "name": "flit-scm", + "sha256": "9831907da18aae3ea803c32fdcf7f2d52228549835133d08a5624549bcc962e5", + "size": 7737, + "subdir": "linux-64", + "timestamp": 1668696594888, + "version": "1.7.0" + }, + "flit-scm-1.7.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.5.0,<4", + "python >=3.11,<3.12.0a0", + "setuptools_scm >=6.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "29e3204a1d1faddc1d80466b788c958f", + "name": "flit-scm", + "sha256": "d242eb62fb550e18409efe7d9fa9238b9591fbb5392e8206cb4525a4b8cfb051", + "size": 8459, + "subdir": "linux-64", + "timestamp": 1676827167888, + "version": "1.7.0" + }, + "flit-scm-1.7.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.5.0,<4", + "python >=3.7,<3.8.0a0", + "setuptools_scm >=6.4", + "tomli" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d108ad4d47ac379f391051a088df523", + "name": "flit-scm", + "sha256": "b80c149a4353d2b6fec69ded54db9775c5d3a9b3786bc5c205005329ee29883a", + "size": 7667, + "subdir": "linux-64", + "timestamp": 1668696566220, + "version": "1.7.0" + }, + "flit-scm-1.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.5.0,<4", + "python >=3.8,<3.9.0a0", + "setuptools_scm >=6.4", + "tomli" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "185ac7f402891b1ae3f805d273b4ab9d", + "name": "flit-scm", + "sha256": "a7d65d068412ec37f62a6299b957c3f7301f743912dbfaee222ba084dd83deae", + "size": 7675, + "subdir": "linux-64", + "timestamp": 1668696623276, + "version": "1.7.0" + }, + "flit-scm-1.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.5.0,<4", + "python >=3.9,<3.10.0a0", + "setuptools_scm >=6.4", + "tomli" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60f63fca23fe8424e306713e599cfa38", + "name": "flit-scm", + "sha256": "c7ab755c4bc92ada2b58fb8fd66fea1639c22519265dff34ce3b14d136f9b149", + "size": 7673, + "subdir": "linux-64", + "timestamp": 1668696651688, + "version": "1.7.0" + }, + "flite-2.2-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "md5": "573c9ecf5a30ffa70788504d7c13ac3c", + "name": "flite", + "sha256": "a33aa07f8275bd82145c22bc32d5a99082665bc20aa7e7a3a46822e93225def9", + "size": 49482367, + "subdir": "linux-64", + "timestamp": 1600349410028, + "version": "2.2" + }, + "fmt-7.1.3-hff7bd54_0.tar.bz2": { + "build": "hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e923c0d050ce26dcd92a465cb5cb5206", + "name": "fmt", + "sha256": "84ede8098166817142c503dec9b1957606fd95a2c6b5593f6506800d032073a1", + "size": 187515, + "subdir": "linux-64", + "timestamp": 1608223474733, + "version": "7.1.3" + }, + "fmt-8.1.1-hd09550d_1.tar.bz2": { + "build": "hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77f54a86b5bd58941176ea33f8facc5e", + "name": "fmt", + "sha256": "e41ad5f0c1427b0162f40e278e0242704fdda120d7b00bc83f280847e5201885", + "size": 181609, + "subdir": "linux-64", + "timestamp": 1646411305067, + "version": "8.1.1" + }, + "fmt-9.1.0-hdb19cb5_0.tar.bz2": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec2ac09cdda49865af0b93c6c4d84b98", + "name": "fmt", + "sha256": "31d9c120a3f1df19a2a5378c781710c2af2d764f81f76ec803eb7418cab560a1", + "size": 190016, + "subdir": "linux-64", + "timestamp": 1676360280858, + "version": "9.1.0" + }, + "folium-0.14.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "branca >=0.6.0", + "jinja2 >=2.9", + "numpy", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "910e5f9a3e04221cc609aca682c13668", + "name": "folium", + "sha256": "0444e503fc0abaf14c7503bdb66d12ee633a0e1603b6f51e872dcd9f3977bcf8", + "size": 114534, + "subdir": "linux-64", + "timestamp": 1675353541104, + "version": "0.14.0" + }, + "folium-0.14.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "branca >=0.6.0", + "jinja2 >=2.9", + "numpy", + "python >=3.11,<3.12.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11e63939b47a8f2f52311f739e40c2bb", + "name": "folium", + "sha256": "a1ba73410e26bed5ac999e4d8187a51525d93170b9b0bb569980e266d6c9f3a0", + "size": 135137, + "subdir": "linux-64", + "timestamp": 1676852488567, + "version": "0.14.0" + }, + "folium-0.14.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "branca >=0.6.0", + "jinja2 >=2.9", + "numpy", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "110f987c940b913e862701fdf6ea5f75", + "name": "folium", + "sha256": "5efa6b8ce19b3e461a371db0b4587850fff53d665e00697c244591cfe7d6da13", + "size": 113643, + "subdir": "linux-64", + "timestamp": 1675353434617, + "version": "0.14.0" + }, + "folium-0.14.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "branca >=0.6.0", + "jinja2 >=2.9", + "numpy", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dead3a557dfe066fc55baf327a859857", + "name": "folium", + "sha256": "02792c44f5e66b754fbeb6c07fbb4baa7bf43988bf9641402ee9d669855b3761", + "size": 113940, + "subdir": "linux-64", + "timestamp": 1675353472060, + "version": "0.14.0" + }, + "folium-0.14.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "branca >=0.6.0", + "jinja2 >=2.9", + "numpy", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51a38d514c6fa4129a24533ae4742540", + "name": "folium", + "sha256": "50378a0c4fe4e4511693dad2b60f0837cc5b8041e25106a0ad640b664151a541", + "size": 113729, + "subdir": "linux-64", + "timestamp": 1675353507823, + "version": "0.14.0" + }, + "fontconfig-2.12.4-h88586e7_1.tar.bz2": { + "build": "h88586e7_1", + "build_number": 1, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libxml2 >=2.9.4,<2.10.0a0" + ], + "license": "MIT", + "md5": "970739ad4489311f138fb6deaf73c400", + "name": "fontconfig", + "sha256": "9945e51bc9a23f123c7409896a7fa1317dc15d078cc10538933d62383f83b5ba", + "size": 288852, + "subdir": "linux-64", + "timestamp": 1505734186823, + "version": "2.12.4" + }, + "fontconfig-2.12.6-h49f89f6_0.tar.bz2": { + "build": "h49f89f6_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libxml2 >=2.9.7,<2.10.0a0" + ], + "license": "MIT", + "md5": "1e6043185c9ff6a5334feb7762170998", + "name": "fontconfig", + "sha256": "773f7f9d012f5b7cac9345dc0891ecdc3c9356aa39fd7dc73072bef3b04fa050", + "size": 289787, + "subdir": "linux-64", + "timestamp": 1520614595614, + "version": "2.12.6" + }, + "fontconfig-2.13.0-h23c43c1_0.tar.bz2": { + "build": "h23c43c1_0", + "build_number": 0, + "depends": [ + "freetype >=2.9,<3.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.7,<2.10.0a0" + ], + "license": "MIT", + "md5": "48e2fdffe3ef8994be44893d291486a1", + "name": "fontconfig", + "sha256": "ea682a90c7b856609fdb05a91675799f579bd7c305760db82c679565b7279a0b", + "size": 297919, + "subdir": "linux-64", + "timestamp": 1522464465668, + "version": "2.13.0" + }, + "fontconfig-2.13.0-h9420a91_0.tar.bz2": { + "build": "h9420a91_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0" + ], + "license": "MIT", + "md5": "3a0b2d9cec0fdb464b8d34946669250f", + "name": "fontconfig", + "sha256": "95a375c47633b95098e35407a9e7f6dfac19fc2742d66d1af511d511d8f827e4", + "size": 297631, + "subdir": "linux-64", + "timestamp": 1527253867511, + "version": "2.13.0" + }, + "fontconfig-2.13.1-h6c09931_0.tar.bz2": { + "build": "h6c09931_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.10,<2.10.0a0" + ], + "license": "MIT", + "md5": "e2fda4383ff9a690a6ac174553e10414", + "name": "fontconfig", + "sha256": "f80526def98864c9560dd3f6754d1c905edc001d18279f6e169913ee8f26a6a2", + "size": 306671, + "subdir": "linux-64", + "timestamp": 1612452969808, + "version": "2.13.1" + }, + "fontconfig-2.13.1-hef1e5e3_1.tar.bz2": { + "build": "hef1e5e3_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.14,<2.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "86e6243fb91dfdc5c21b098131a447d1", + "name": "fontconfig", + "sha256": "b7173a97f826c26450d73e719ec2fec7dcf758fc237e2ce0e80b162d3acfe954", + "size": 313472, + "subdir": "linux-64", + "timestamp": 1667568393817, + "version": "2.13.1" + }, + "fontconfig-2.14.1-h4c34cd2_2.tar.bz2": { + "build": "h4c34cd2_2", + "build_number": 2, + "depends": [ + "expat >=2.4.9,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "libxml2 >=2.10.3,<2.11.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c9dc79248f887050dc89e19670dcbd66", + "name": "fontconfig", + "sha256": "4a623c7f73f4531a16271ded00c80e7dce65aa35b5105015fc4d0ceb37c9fa0d", + "size": 383064, + "subdir": "linux-64", + "timestamp": 1679578197653, + "version": "2.14.1" + }, + "fontconfig-2.14.1-h52c9d5c_1.tar.bz2": { + "build": "h52c9d5c_1", + "build_number": 1, + "depends": [ + "expat >=2.4.9,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "84568e1f38e8a2d876c82eca0e09c3b6", + "name": "fontconfig", + "sha256": "96ce36ceaec9dd42c6309ad347416ba4d5d05f5a09d6ce98157edce8f0bcdf21", + "size": 362567, + "subdir": "linux-64", + "timestamp": 1671001523785, + "version": "2.14.1" + }, + "fontconfig-2.14.1-hef1e5e3_0.tar.bz2": { + "build": "hef1e5e3_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "93bef6274d3049b1fea2b2f5870f7e87", + "name": "fontconfig", + "sha256": "1482d90e064a05eca5fa7eb57bf2459399b1fa40748e0ec6544a9a2297662170", + "size": 355151, + "subdir": "linux-64", + "timestamp": 1670019602470, + "version": "2.14.1" + }, + "freeglut-3.0.0-hf484d3e_5.tar.bz2": { + "build": "hf484d3e_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a71d4b3d4236d7dc6110a72611c6600", + "name": "freeglut", + "sha256": "f95dd30ea242d8a72eccc605848c7825e37ec0d342c9d58aae0610719af4a249", + "size": 257431, + "subdir": "linux-64", + "timestamp": 1520767673427, + "version": "3.0.0" + }, + "freetds-1.00.83-hb7f436b_0.tar.bz2": { + "build": "hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2n,<1.0.3a", + "readline >=7.0,<8.0a0", + "unixodbc >=2.3.5,<2.4.0a0" + ], + "license": "GPL-2", + "license_family": "GPL2", + "md5": "a3fbf75d1f90cc59ec55b4812b5653ad", + "name": "freetds", + "sha256": "9905e522ded714d8d1f4b8c26beb46a02759aa6f785d0403236cbca0ff954916", + "size": 2590079, + "subdir": "linux-64", + "timestamp": 1522004329353, + "version": "1.00.83" + }, + "freetds-1.00.86-hb7f436b_0.tar.bz2": { + "build": "hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "GPL-2", + "license_family": "GPL2", + "md5": "68bdd7eac2d01f981bb4a063bb85927b", + "name": "freetds", + "sha256": "8fac0ee6660306ce8d3c13b15ec576a026b625ceeda2ece2d62cd594d2e553e7", + "size": 2589629, + "subdir": "linux-64", + "timestamp": 1524158884662, + "version": "1.00.86" + }, + "freetds-1.00.91-hb7f436b_0.tar.bz2": { + "build": "hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "GPL-2", + "license_family": "GPL2", + "md5": "e63e2742ac98a67b3bb19bcc93204048", + "name": "freetds", + "sha256": "7fdda1838ab8bf339c514a2eb8405ed9b68e7c376bd11a7f051a5105a1750c15", + "size": 2590680, + "subdir": "linux-64", + "timestamp": 1529962956850, + "version": "1.00.91" + }, + "freetds-1.00.97-h1ba5d50_0.tar.bz2": { + "build": "h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "GPL-2", + "license_family": "GPL2", + "md5": "87d80920d92e6cb4421df84c3d01f15d", + "name": "freetds", + "sha256": "ea874ef4934c29b3f81cd32e7cbd39112670c1af46c6157e657fcc0df12cfeaf", + "size": 2509726, + "subdir": "linux-64", + "timestamp": 1540226527571, + "version": "1.00.97" + }, + "freetds-1.00.97-h52ef933_0.tar.bz2": { + "build": "h52ef933_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1e,<1.1.2a", + "readline >=8.0,<9.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "GPL-2", + "license_family": "GPL2", + "md5": "9c09d2053c558a45b9b4ddd44c0c5abe", + "name": "freetds", + "sha256": "25fba31e2a86032abb5dde8ec2dae2e1c1d018dcd246420df435af3b8998d66a", + "size": 2481715, + "subdir": "linux-64", + "timestamp": 1585178811031, + "version": "1.00.97" + }, + "freetds-1.00.97-hc365091_0.tar.bz2": { + "build": "hc365091_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a", + "readline >=7.0,<8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "GPL-2", + "license_family": "GPL2", + "md5": "14d7839a53b81ead18943fd465fda1b2", + "name": "freetds", + "sha256": "9072e64840a1caef9204839a94045d790f3f722ebefe9a4a8093b00899cd55ce", + "size": 2518796, + "subdir": "linux-64", + "timestamp": 1536076695281, + "version": "1.00.97" + }, + "freetds-1.1.15-hdedb384_0.tar.bz2": { + "build": "hdedb384_0", + "build_number": 0, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "readline >=8.0,<9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "GPL-2", + "license_family": "GPL2", + "md5": "5f34e0bdf8fb1afc44d607e78dc61371", + "name": "freetds", + "sha256": "6205b921ce14059017fbe7f79f32c32001bb94e24547afab175e17972e578c57", + "size": 2567703, + "subdir": "linux-64", + "timestamp": 1611074767837, + "version": "1.1.15" + }, + "freetds-1.2.19-hdedb384_0.tar.bz2": { + "build": "hdedb384_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.1,<1.20.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "9a5f9f99ef9a0eed0d50c5a6b8a6b2b4", + "name": "freetds", + "sha256": "2da1f16b409fae49f0d9aae712bf52499861ff4e2534378d4c3068a71905a57b", + "size": 2492398, + "subdir": "linux-64", + "timestamp": 1618326621306, + "version": "1.2.19" + }, + "freetds-1.2.20-hdedb384_0.tar.bz2": { + "build": "hdedb384_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.1,<1.20.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "12e6604c0ccf9651e437ee7936181ae3", + "name": "freetds", + "sha256": "4979b0813a08b20f8440c66e06ead7fda6bc2147163b1649c5e36e694b0e85a6", + "size": 2548320, + "subdir": "linux-64", + "timestamp": 1618381964612, + "version": "1.2.20" + }, + "freetds-1.2.21-hdedb384_0.tar.bz2": { + "build": "hdedb384_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.1,<1.20.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "593e6d3e5d03db693515f401a3aee3c3", + "name": "freetds", + "sha256": "8715e0b82fa515aadc71d5b5a63ce707094389ab653d405bccd955e3e7bed8e6", + "size": 2508205, + "subdir": "linux-64", + "timestamp": 1619476887860, + "version": "1.2.21" + }, + "freetds-1.3-ha584ca3_0.tar.bz2": { + "build": "ha584ca3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.1,<1.20.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "LGPL-2.0 AND GPL-2.0", + "license_family": "LGPL", + "md5": "7f89044fbf275072e48a7698539ed2c5", + "name": "freetds", + "sha256": "2ca20e396fcaf7fb4fa751e812af4e251cc65af47c84800f1adeb975b28115cb", + "size": 2519244, + "subdir": "linux-64", + "timestamp": 1626258071143, + "version": "1.3" + }, + "freetds-1.3.3-ha584ca3_0.tar.bz2": { + "build": "ha584ca3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "readline >=8.0,<9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "LGPL-2.0 AND GPL-2.0", + "license_family": "LGPL", + "md5": "c90f59add2059ccdbc10a001820b526c", + "name": "freetds", + "sha256": "0f06b4a6c4b1fe2460506c5aaf2861b7ce5dbd1c36ab7db32f6b29ddc89910a9", + "size": 2527152, + "subdir": "linux-64", + "timestamp": 1638441044819, + "version": "1.3.3" + }, + "freetype-2.10.2-h5ab3b9f_0.tar.bz2": { + "build": "h5ab3b9f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-only and LicenseRef-FreeType", + "md5": "cbee898f89e49bc61cc8e878b7e03b22", + "name": "freetype", + "sha256": "dd6d05ec6d60761346987341bcf8e9ce7803e602a12769926e64539cd7bf8f2a", + "size": 936791, + "subdir": "linux-64", + "timestamp": 1592507538188, + "version": "2.10.2" + }, + "freetype-2.10.3-h5ab3b9f_0.tar.bz2": { + "build": "h5ab3b9f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-only and LicenseRef-FreeType", + "md5": "f23be623c6934407ea0e681d5998b33f", + "name": "freetype", + "sha256": "39a4f65a302d9926205e55f243e3e8f0aa5b01925a0cbff8261955a9ac1c6df5", + "size": 911268, + "subdir": "linux-64", + "timestamp": 1602517554418, + "version": "2.10.3" + }, + "freetype-2.10.4-h5ab3b9f_0.tar.bz2": { + "build": "h5ab3b9f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-only and LicenseRef-FreeType", + "md5": "d0851d60dd8db00f4f222e849ecffb4d", + "name": "freetype", + "sha256": "91e972afa01f027e6b0229875ef3f44a633fc2566500077dbfe7e8ddab558e87", + "size": 922268, + "subdir": "linux-64", + "timestamp": 1603212964927, + "version": "2.10.4" + }, + "freetype-2.11.0-h70c0345_0.tar.bz2": { + "build": "h70c0345_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-only and LicenseRef-FreeType", + "md5": "d2b24736491290a6c6d0138932111150", + "name": "freetype", + "sha256": "8a121233d0b2cbb2463b67e798739ad2946f38933430a6a7fd1197cc6eab1c99", + "size": 965280, + "subdir": "linux-64", + "timestamp": 1635422707211, + "version": "2.11.0" + }, + "freetype-2.12.1-h4a9f257_0.tar.bz2": { + "build": "h4a9f257_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2-only and LicenseRef-FreeType", + "license_family": "Other", + "md5": "a5dc8677d891dff2393b63189a3ad42f", + "name": "freetype", + "sha256": "171f80eb26f00426bf47a361236cf0cc4cc0fb04769252b6f1d88a3bdb1f03cd", + "size": 971975, + "subdir": "linux-64", + "timestamp": 1666798278693, + "version": "2.12.1" + }, + "freetype-2.8-h52ed37b_0.tar.bz2": { + "build": "h52ed37b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0 and FreeType", + "md5": "2578a154d4939e827e189937657ebfd5", + "name": "freetype", + "sha256": "c4ffa5caed57493342ab837514a323c6231ce09ff6e129114da4f2b9d172794a", + "size": 822754, + "subdir": "linux-64", + "timestamp": 1505733467465, + "version": "2.8" + }, + "freetype-2.8-hab7d2ae_1.tar.bz2": { + "build": "hab7d2ae_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0 and FreeType", + "md5": "0e4f09b80709a8b8b5fe3a91154c262e", + "name": "freetype", + "sha256": "573c1424d3a1465d0b85e28449471b5715cbd79e83f489351fdfde7b8cbe065b", + "size": 822924, + "subdir": "linux-64", + "timestamp": 1510603249537, + "version": "2.8" + }, + "freetype-2.9-hadd163a_0.tar.bz2": { + "build": "hadd163a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0 and FreeType", + "md5": "8b182909ed6d132c72049a243c310aac", + "name": "freetype", + "sha256": "8006abce32863b595ba1c0f2b16258dfa9ffb37a1103833abae17b225f1a8005", + "size": 840324, + "subdir": "linux-64", + "timestamp": 1522459361480, + "version": "2.9" + }, + "freetype-2.9.1-h8a8886c_0.tar.bz2": { + "build": "h8a8886c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0 and FreeType", + "md5": "ec0681f66551aeef3f8b50fed2958383", + "name": "freetype", + "sha256": "b5c87557f96ddc9daed97cd7bea8f7af5aabe8974d0f556b7f7934a419b0bd09", + "size": 841190, + "subdir": "linux-64", + "timestamp": 1527164842029, + "version": "2.9.1" + }, + "freetype-2.9.1-h8a8886c_1.tar.bz2": { + "build": "h8a8886c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libpng >=1.6.34,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0 and FreeType", + "md5": "f14a8bdc57f97e2feec097ff3f0d06aa", + "name": "freetype", + "sha256": "fce37dd180261faa651ed998ee4e8271524b0f08933e7d84703b7c533217f074", + "size": 842173, + "subdir": "linux-64", + "timestamp": 1535129426985, + "version": "2.9.1" + }, + "freexl-1.0.4-h2367b09_4.tar.bz2": { + "build": "h2367b09_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "md5": "423be8f8be3aaea994accba9e2ebe795", + "name": "freexl", + "sha256": "74f3efaa30d350e44f6d9ee67bec160ac2d918706e17e7f39ee1149501e65a14", + "size": 45349, + "subdir": "linux-64", + "timestamp": 1509502667050, + "version": "1.0.4" + }, + "freexl-1.0.4-hf32cdb2_5.tar.bz2": { + "build": "hf32cdb2_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "md5": "aedb0aeaf0e5689b926331903dcbd2e9", + "name": "freexl", + "sha256": "494bbf29747552c4e4a436eee376e99297c53aca98d9eefbeee37c3bd64cf3e4", + "size": 45357, + "subdir": "linux-64", + "timestamp": 1510603248058, + "version": "1.0.4" + }, + "freexl-1.0.5-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "md5": "39197f765d09c5dc47d38d42eb17fd38", + "name": "freexl", + "sha256": "fb066b1a916a3396cc96714633ee348a2566a87f53dad0eb0a98e4c83d0c5daf", + "size": 45554, + "subdir": "linux-64", + "timestamp": 1520963065745, + "version": "1.0.5" + }, + "freexl-1.0.6-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MPL-1.1", + "md5": "4a608c3e1873b5f5d319d1a093291c42", + "name": "freexl", + "sha256": "8e060f863a4a3ae66733c03d400dce277b831e15fbd23f6beccd43501b15b74d", + "size": 47744, + "subdir": "linux-64", + "timestamp": 1607116152702, + "version": "1.0.6" + }, + "fribidi-1.0.10-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "md5": "65d93572c4ff2ee0cc8241221aee7f12", + "name": "fribidi", + "sha256": "6d2cad4f0c819ae368a2a2796592d9ce1d23bef8bedd722a6f9fe941e95434c9", + "size": 117929, + "subdir": "linux-64", + "timestamp": 1597684734171, + "version": "1.0.10" + }, + "fribidi-1.0.2-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "md5": "fe03fc4a859767737ea8a7522d858914", + "name": "fribidi", + "sha256": "9171145a9c8df6ca00cd82072e55e123b9bd6849bc44c2998c605d552f217c55", + "size": 113422, + "subdir": "linux-64", + "timestamp": 1522873067928, + "version": "1.0.2" + }, + "fribidi-1.0.4-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "md5": "3dd0a212344415aa098bb5292ec3db4c", + "name": "fribidi", + "sha256": "a87f5fdc51a5f593243907064fae13e53b9ce59495958c20245d0087a2eba2f7", + "size": 112977, + "subdir": "linux-64", + "timestamp": 1529962411408, + "version": "1.0.4" + }, + "fribidi-1.0.5-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "md5": "ec85385ea34443d6547ad4b504997f68", + "name": "fribidi", + "sha256": "a8135332e8e66a4301a3390321b9ae9c2328a754faf7881e0f17559624d95ef2", + "size": 114240, + "subdir": "linux-64", + "timestamp": 1536086961039, + "version": "1.0.5" + }, + "fribidi-1.0.9-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "md5": "2a96f1e30dea866b286fcdb8a0883cec", + "name": "fribidi", + "sha256": "5df46ddb27f5efbabd4bb3c6679decde2aa4eeedf30062e866185f36651ed797", + "size": 117812, + "subdir": "linux-64", + "timestamp": 1593119676634, + "version": "1.0.9" + }, + "frozenlist-1.2.0-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "4f46d45f75e308eebc4a4b48d74d2a1f", + "name": "frozenlist", + "sha256": "448036ca409e1db596f5822ded3ac5523b95ccc99c221b8992ca6bb1214c882b", + "size": 170639, + "subdir": "linux-64", + "timestamp": 1640790103552, + "version": "1.2.0" + }, + "frozenlist-1.2.0-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b1fd626f53bd61ab03019c979d0cb5c2", + "name": "frozenlist", + "sha256": "6469c43cf3a63e914e72161ea727d42b29c3657991be1d48b4a1a86cc974e59c", + "size": 82408, + "subdir": "linux-64", + "timestamp": 1637767158189, + "version": "1.2.0" + }, + "frozenlist-1.2.0-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e38e7ad9afc1f43c2ed533f330cffb98", + "name": "frozenlist", + "sha256": "acc4a10f395289cb5359512b2caa43707b1b105aa8204c48553c2cc7959866af", + "size": 83485, + "subdir": "linux-64", + "timestamp": 1637767147948, + "version": "1.2.0" + }, + "frozenlist-1.2.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "521db792b3d05f70400c0c546dc2a00a", + "name": "frozenlist", + "sha256": "2c9a6578356d11f04c4aa2d1c5cedac55c7b52680a0397060b7ff01c6e03602c", + "size": 83118, + "subdir": "linux-64", + "timestamp": 1637767150249, + "version": "1.2.0" + }, + "frozenlist-1.3.3-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8d685651b202439b7d77969317ec5279", + "name": "frozenlist", + "sha256": "edbbddbf30ab88fc23bfa9363a19fef79009298a1ce6db927f625a5aadf9e53d", + "size": 44420, + "subdir": "linux-64", + "timestamp": 1670004544636, + "version": "1.3.3" + }, + "frozenlist-1.3.3-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8cd91d711bec7c29c5393f8064d8d31f", + "name": "frozenlist", + "sha256": "cdcd31d9f0e3cfe81ef51e37ad4c5a9500ac12fc366592f296b0b4c5fc15359b", + "size": 45175, + "subdir": "linux-64", + "timestamp": 1676825245209, + "version": "1.3.3" + }, + "frozenlist-1.3.3-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2abfbdb61e9af875089b65b5734967f3", + "name": "frozenlist", + "sha256": "4be5eefbc083cbfddffa91a7963500a38a1cde7f8888652d899ffabf4a7b2ddc", + "size": 44039, + "subdir": "linux-64", + "timestamp": 1670004631894, + "version": "1.3.3" + }, + "frozenlist-1.3.3-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2d88b79b35a3163b2087b3c24ea81f17", + "name": "frozenlist", + "sha256": "b45d6bccbe07817fb74a15b63b001ef891b71ef22424d2e35efa9648aa24f90c", + "size": 44707, + "subdir": "linux-64", + "timestamp": 1670004602514, + "version": "1.3.3" + }, + "frozenlist-1.3.3-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cc258dfe1fca0174d864a6987fcc8b47", + "name": "frozenlist", + "sha256": "b7df6a2f48479046738ac18e1f5d7ba9e9203068f980bd5199e4e3f22811af43", + "size": 44427, + "subdir": "linux-64", + "timestamp": 1670004573921, + "version": "1.3.3" + }, + "fsspec-2022.10.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6f6fd6286000758f363d3f59f38d5719", + "name": "fsspec", + "sha256": "250f6e0cd4c26475feb4d18f8d758bae7f48322988e74913b20a845b4ebcfe95", + "size": 205482, + "subdir": "linux-64", + "timestamp": 1667497055163, + "version": "2022.10.0" + }, + "fsspec-2022.10.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3e552b543502511d680e443f313afb7b", + "name": "fsspec", + "sha256": "24c4f6defacdecc76f7113fcb82a90e13581ba70033dd6b543193dd73e91ee4f", + "size": 201400, + "subdir": "linux-64", + "timestamp": 1667497081379, + "version": "2022.10.0" + }, + "fsspec-2022.10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a1ac433096099ee9f406c017cf506d58", + "name": "fsspec", + "sha256": "6ada8cd77e15b43ac3f9c530c964565fc33ab5b807ca894dc46754deb323dd43", + "size": 202338, + "subdir": "linux-64", + "timestamp": 1667497106927, + "version": "2022.10.0" + }, + "fsspec-2022.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a9396035ef1dec9baf0bb0398df52888", + "name": "fsspec", + "sha256": "06d143a270a5198277f55614a2ab788b2f6c98d22fc2847be609f08cd648dac6", + "size": 202848, + "subdir": "linux-64", + "timestamp": 1667497028895, + "version": "2022.10.0" + }, + "fsspec-2022.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7991051067241552ef21d20ef40ac68c", + "name": "fsspec", + "sha256": "12422cc0bd175226f155e5c39233f693369730051a0a5d3b8eac523e2cb35b32", + "size": 206545, + "subdir": "linux-64", + "timestamp": 1670336700344, + "version": "2022.11.0" + }, + "fsspec-2022.11.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ef30682edf3c8db5d47c35f550d93843", + "name": "fsspec", + "sha256": "6d00da753c4b41873a1f100c4547b29082b0eef54669d6e834a7417ee2b6da48", + "size": 288229, + "subdir": "linux-64", + "timestamp": 1676827754606, + "version": "2022.11.0" + }, + "fsspec-2022.11.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e72e88a9a3320b3be3bacbb3fe4fbcb7", + "name": "fsspec", + "sha256": "805430de40c28cbf7d4723f883a998d7b28cf10630cd0097e662f2148357da1b", + "size": 202469, + "subdir": "linux-64", + "timestamp": 1670336648454, + "version": "2022.11.0" + }, + "fsspec-2022.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4c1452671305002293a32df972525c38", + "name": "fsspec", + "sha256": "80f4e4b51eb3815ac8361ed62fbe32919c3ced468b99390cef039f253b0028b9", + "size": 203472, + "subdir": "linux-64", + "timestamp": 1670336622478, + "version": "2022.11.0" + }, + "fsspec-2022.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "25a36c0fb06869b826574f0dbb13e52f", + "name": "fsspec", + "sha256": "c8da6635e906e1d646a456d1700a04a0bd8a9ea712b312c65071365fc5ce6607", + "size": 204014, + "subdir": "linux-64", + "timestamp": 1670336674291, + "version": "2022.11.0" + }, + "fsspec-2022.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "484791fd9a52290107bbe9fa7be8c607", + "name": "fsspec", + "sha256": "6f590c90ebe913f85de45875fe603e442b4e20dc65e8f63b9e124e34a845c7e1", + "size": 199856, + "subdir": "linux-64", + "timestamp": 1652802179339, + "version": "2022.3.0" + }, + "fsspec-2022.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "83d286c8711200b3d8c2c60114e3dfc9", + "name": "fsspec", + "sha256": "ae8759566351f7ce5e485adee45728620f759766dedba62a7a4a5667c8dd8943", + "size": 195961, + "subdir": "linux-64", + "timestamp": 1652802207569, + "version": "2022.3.0" + }, + "fsspec-2022.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a810cb83d188776dc9bc5f6bda877323", + "name": "fsspec", + "sha256": "d1a6ba7a4956d61e60366163b41822f92495e5d1041a6c38fb52691b6740b44c", + "size": 196945, + "subdir": "linux-64", + "timestamp": 1652802235832, + "version": "2022.3.0" + }, + "fsspec-2022.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ba3cf9651e31701294e3582314a5c5fb", + "name": "fsspec", + "sha256": "42d5ace16994c14d6eb48615e62c56559ee2c1bcb4e65a9217c29fd58f4d03df", + "size": 197330, + "subdir": "linux-64", + "timestamp": 1652802140522, + "version": "2022.3.0" + }, + "fsspec-2022.7.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "db018d99c5f2c36c01f315c7650de2aa", + "name": "fsspec", + "sha256": "fb1eef0e7b2a72b71e2288679a2ed4b792245048c8a42d2977ed3a5706ccdced", + "size": 207417, + "subdir": "linux-64", + "timestamp": 1659972306331, + "version": "2022.7.1" + }, + "fsspec-2022.7.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0962a6a046d9a6467a20c4bc8733bcf9", + "name": "fsspec", + "sha256": "b48578a0ed1118b87734e11b5d5b95e495086f47c349960b4c4594d6754faaa8", + "size": 203242, + "subdir": "linux-64", + "timestamp": 1659972263070, + "version": "2022.7.1" + }, + "fsspec-2022.7.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4cdcdaf89c5767d204a17b5c4d4c8525", + "name": "fsspec", + "sha256": "4bb1d80b46637371ae8f1f6969958fda06459dd13e7d68428c6c33f0a62fca8b", + "size": 204349, + "subdir": "linux-64", + "timestamp": 1659972234013, + "version": "2022.7.1" + }, + "fsspec-2022.7.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a4efbd4b0eda070db48d3ab551f1847", + "name": "fsspec", + "sha256": "12ec985e7f2c676020f3d9f54737f80a4dc5c42a63d995fdf2feac4f824575e8", + "size": 204737, + "subdir": "linux-64", + "timestamp": 1659972337708, + "version": "2022.7.1" + }, + "fsspec-2023.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1aa8c80a908dbc83c419cad77bc90d53", + "name": "fsspec", + "sha256": "d2eb869c90811514a4f92289bcffb2fcb1eadde15426564d1d54f982abe798cc", + "size": 222905, + "subdir": "linux-64", + "timestamp": 1679418818027, + "version": "2023.3.0" + }, + "fsspec-2023.3.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "800dbbb9feb562ec4646c44e0ea95290", + "name": "fsspec", + "sha256": "cae1b8f7997f1e7883885d8329f885fb7ece5e51d510121d2cd5aaf3b59b4b92", + "size": 308814, + "subdir": "linux-64", + "timestamp": 1679418895424, + "version": "2023.3.0" + }, + "fsspec-2023.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f3f8aa3907a629be4dbeea020f5a658b", + "name": "fsspec", + "sha256": "060d1b3832197147e53bea54866d761f08797cf499e2a190dabf055b1c7721f5", + "size": 218036, + "subdir": "linux-64", + "timestamp": 1679418843983, + "version": "2023.3.0" + }, + "fsspec-2023.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "70e0479a9905485187c4563c07afe467", + "name": "fsspec", + "sha256": "4f4c3fde40e356cb1ec5340d27725f6b52b2c0530df140d10da67836f41ed60d", + "size": 220227, + "subdir": "linux-64", + "timestamp": 1679418868935, + "version": "2023.3.0" + }, + "ftfy-5.1.1-py35h1b93f42_0.tar.bz2": { + "build": "py35h1b93f42_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "980a254fc48b85f6d417bc110e6ec1b2", + "name": "ftfy", + "sha256": "75d5d3f3ba00bb69eb338de57d26d67657fee460ae8441b63fb8d6bfb63d06dc", + "size": 59269, + "subdir": "linux-64", + "timestamp": 1508600979995, + "version": "5.1.1" + }, + "ftfy-5.1.1-py36hfde7620_0.tar.bz2": { + "build": "py36hfde7620_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "1ae0a945ed30b639c0d70e5f1266d1dd", + "name": "ftfy", + "sha256": "629d5cd23f45ae8602b225621873c688f94978fc2974e7c01c2016fe698f9823", + "size": 59235, + "subdir": "linux-64", + "timestamp": 1508600975837, + "version": "5.1.1" + }, + "ftfy-5.2.0-py35h5167a2d_0.tar.bz2": { + "build": "py35h5167a2d_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "3b282f4c2a323f176b4ef9747a905f88", + "name": "ftfy", + "sha256": "b546a14cf5569cb74f2a5f8f0391636b5339b67935f8798c36fb0de7640af5cc", + "size": 60296, + "subdir": "linux-64", + "timestamp": 1512059501629, + "version": "5.2.0" + }, + "ftfy-5.2.0-py36h43dc9bd_0.tar.bz2": { + "build": "py36h43dc9bd_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "0874b935db85bccaebbb6280ea50aec8", + "name": "ftfy", + "sha256": "e693634b319937825692cb7e9b4e604d8a9f72b8348a6db16358be9d1bd6aa94", + "size": 60213, + "subdir": "linux-64", + "timestamp": 1512059495692, + "version": "5.2.0" + }, + "ftfy-5.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "acb2ca90084d5591e120ae1f9fd9cf96", + "name": "ftfy", + "sha256": "edde39ad694a84c02743463630ac00e132f3b937dee77da3b2caa0fb79fb7696", + "size": 60693, + "subdir": "linux-64", + "timestamp": 1519484581869, + "version": "5.3.0" + }, + "ftfy-5.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "dc5a9e10d6c4406f25175afb93fa81b4", + "name": "ftfy", + "sha256": "8c70d9e11d581d7c82469d2097bb79abcd3f2ac8c2c786f63217b39de653b553", + "size": 60538, + "subdir": "linux-64", + "timestamp": 1519484535324, + "version": "5.3.0" + }, + "ftfy-5.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "c122f26c8b590ba2a8facd7c26decca0", + "name": "ftfy", + "sha256": "b2ed850b1a51df999eba5778a44e8e3862316cc58447cde47558fca562e8e581", + "size": 63943, + "subdir": "linux-64", + "timestamp": 1529561424070, + "version": "5.4.1" + }, + "ftfy-5.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "fd66af5cb14a085661096bfc9c38fb21", + "name": "ftfy", + "sha256": "17809eee66749925292e9738231cdcfb1f66ec21762b63bf6e0a9e79d97ba977", + "size": 63842, + "subdir": "linux-64", + "timestamp": 1529561399113, + "version": "5.4.1" + }, + "ftfy-5.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "80a16c8da02e9dabf494878f1207840c", + "name": "ftfy", + "sha256": "ba5cc8e3cf4057b51809288ec66a308671cb8ab140de272871157eef852d3e47", + "size": 63217, + "subdir": "linux-64", + "timestamp": 1530877599468, + "version": "5.4.1" + }, + "ftfy-5.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "c785933925de6937e44b8cc7c46e3645", + "name": "ftfy", + "sha256": "2b51025eddedcb445b65b5872842a248a13703f6d45caae32023649f8aec0c9a", + "size": 64882, + "subdir": "linux-64", + "timestamp": 1540062826997, + "version": "5.5.0" + }, + "fuel-0.2.0-py27h7b6447c_1.tar.bz2": { + "build": "py27h7b6447c_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.3.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=2.7,<2.8.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "f99cdcce7b02b53b5b35bc813e8999de", + "name": "fuel", + "sha256": "85ecb7bba45808a16587a31ffb384c25b116a539d22d06cc0579319f8a994298", + "size": 249544, + "subdir": "linux-64", + "timestamp": 1537294484317, + "version": "0.2.0" + }, + "fuel-0.2.0-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.5.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=3.10,<3.11.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "de3d49ff0d96af369ee9266e155b74fb", + "name": "fuel", + "sha256": "bc3f3ef21ff89a1f552912a97fa6a938d965e049fb8d8046ae2ea2011e5d49f9", + "size": 487221, + "subdir": "linux-64", + "timestamp": 1642520087653, + "version": "0.2.0" + }, + "fuel-0.2.0-py35h7b6447c_1.tar.bz2": { + "build": "py35h7b6447c_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.3.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=3.5,<3.6.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "bff7716645b320aa22e6e0d217471b1d", + "name": "fuel", + "sha256": "17302c6b7b7618eb20e889719054c3c827ac06778bd3ed12690ecbb83db9baac", + "size": 254854, + "subdir": "linux-64", + "timestamp": 1537294535106, + "version": "0.2.0" + }, + "fuel-0.2.0-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.3.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=3.6,<3.7.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "5f311735efdf5bec0db1d163a1338d35", + "name": "fuel", + "sha256": "59f07d53f4bc3be6177a4ba92f2573c34596e3532172f0ec4bf8cca5ffbb2ab2", + "size": 485957, + "subdir": "linux-64", + "timestamp": 1614326569833, + "version": "0.2.0" + }, + "fuel-0.2.0-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.3.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=3.6,<3.7.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "3362525b2f9932ff6197b73550344b59", + "name": "fuel", + "sha256": "13f5f648a29f022359caff34d1e2ad049eaa51d72df889ef986d09224b5dffef", + "size": 253949, + "subdir": "linux-64", + "timestamp": 1537294535707, + "version": "0.2.0" + }, + "fuel-0.2.0-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.3.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=3.7,<3.8.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "4192c00a01bb60f1f59b20f9234135df", + "name": "fuel", + "sha256": "7b4abd6fa57d6402f21f734aa89e053cceb8f2d9a5ecd8e41ce78237c1475612", + "size": 470658, + "subdir": "linux-64", + "timestamp": 1614325508136, + "version": "0.2.0" + }, + "fuel-0.2.0-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.3.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=3.7,<3.8.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "d4ba66bd44ff16edb7ffbd900120bac5", + "name": "fuel", + "sha256": "557abd26011d2a653f8eb489d1246d13895373531badfd72333c4db27f777da5", + "size": 253140, + "subdir": "linux-64", + "timestamp": 1537294460505, + "version": "0.2.0" + }, + "fuel-0.2.0-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.3.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=3.8,<3.9.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "4038fb0e34861203875950552464d88a", + "name": "fuel", + "sha256": "2c1843c630924c83bd4c876864d9231a1fa1400f6402b776c60ea3df57ffd456", + "size": 497400, + "subdir": "linux-64", + "timestamp": 1614326551170, + "version": "0.2.0" + }, + "fuel-0.2.0-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.3.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=3.8,<3.9.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "faa187b6defeebc59b219ee366f0a8b2", + "name": "fuel", + "sha256": "13e1b6e744389868d46a54b9c893bad45655e6c0356cb6bc978ed2827974696e", + "size": 260417, + "subdir": "linux-64", + "timestamp": 1574238607577, + "version": "0.2.0" + }, + "fuel-0.2.0-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.3.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=3.9,<3.10.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "802eb3da15bedcbd4172167eba7cc947", + "name": "fuel", + "sha256": "727ec5e1d835128c916e9f2674b633c8e1f72bea76d817fa9a119aa03008da19", + "size": 491513, + "subdir": "linux-64", + "timestamp": 1614326551248, + "version": "0.2.0" + }, + "funcsigs-1.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "3bb0ae7dc752b3776501f6494157ad6b", + "name": "funcsigs", + "sha256": "402af6f4632a7e89b9e3b794c9620e5b14a70606d6afff875491952c61cd797a", + "size": 20899, + "subdir": "linux-64", + "timestamp": 1530735147541, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py27h83f16ab_0.tar.bz2": { + "build": "py27h83f16ab_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "596ea0f2d9964075a647f66a914d2b1f", + "name": "funcsigs", + "sha256": "1842a9e7c382c82a8ce2735eb3cadf7745d005bdf41d695c9a48194368a110c5", + "size": 20764, + "subdir": "linux-64", + "timestamp": 1505691231315, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "md5": "cedaf21418f9a1c486f23f3e24246978", + "name": "funcsigs", + "sha256": "9897bfb457d5005e9dcae2536d5303217fd37b96890a40747f25f5cd7d865a5c", + "size": 21537, + "subdir": "linux-64", + "timestamp": 1640790121231, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache 2.0", + "md5": "eec9d920004fdb1d71a0b7132d77554e", + "name": "funcsigs", + "sha256": "e6bc37e43a177b1dce707a873a6c47eb9cac6de2f01666b457ee8df56e30516c", + "size": 27422, + "subdir": "linux-64", + "timestamp": 1676852502873, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "a67ce376482f53177d47768ab92c85b0", + "name": "funcsigs", + "sha256": "18c808dc4c98d58647634e2b0ac6d7f378117213aff563a3ccb10272c374b55c", + "size": 21164, + "subdir": "linux-64", + "timestamp": 1534351830914, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "427596f7330fe3022de9d6276e7f7fab", + "name": "funcsigs", + "sha256": "c68eb268bd11a6f63258ce88995ab9b0807dd96c62ed3010cde7d670b1875b8a", + "size": 21118, + "subdir": "linux-64", + "timestamp": 1530735127840, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "1c15ddad09fd9971dd7a97a0106c423f", + "name": "funcsigs", + "sha256": "e74a3667409bd6f8987f5b8ea59da540da116c6d2a484f2d0a649c4c1c0f7f4a", + "size": 22283, + "subdir": "linux-64", + "timestamp": 1613164608111, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "e1a32fbde8ff259df0dcd2e0f4f24f57", + "name": "funcsigs", + "sha256": "0f4a05dc5fd0696f0d11a73adad9fd8c9b1059b685ff3a4161bccc0e8142c8cc", + "size": 21157, + "subdir": "linux-64", + "timestamp": 1530735167799, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "c7d654d31f29d45b63c704a4c42864fa", + "name": "funcsigs", + "sha256": "ce4b10b6d40370287519798d39f24550c8e278a0b443921054067e82db5a9435", + "size": 22306, + "subdir": "linux-64", + "timestamp": 1613165857178, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "802b50c0fafca65342aaa53413c5c577", + "name": "funcsigs", + "sha256": "2b5f4925c70c1813898282180b551ac24b6a9b1a7b7501dddb5f14bc8570d5de", + "size": 21722, + "subdir": "linux-64", + "timestamp": 1572880763116, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "c890da3569bb1ce616de45cf646fd637", + "name": "funcsigs", + "sha256": "1ca040a0c78ff616c74ad57328f7134e45d6543ffb10b4daaea67b3f9d4004cf", + "size": 22409, + "subdir": "linux-64", + "timestamp": 1613165868000, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "0a8f255a47f4232b9d2a3a481fdff8b5", + "name": "funcsigs", + "sha256": "0543445b7233969877574c105c2c8ad9d71d4247c6ffbb005b55708d641d5101", + "size": 22434, + "subdir": "linux-64", + "timestamp": 1613165417467, + "version": "1.0.2" + }, + "functools32-3.2.3.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF license", + "md5": "e7d36567e6bd594c060798e468355a5a", + "name": "functools32", + "sha256": "20039231fae326f111860c039870839646296556fbb7ccd5adba616a986bef6e", + "size": 23091, + "subdir": "linux-64", + "timestamp": 1530735188460, + "version": "3.2.3.2" + }, + "functools32-3.2.3.2-py27h4ead58f_1.tar.bz2": { + "build": "py27h4ead58f_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF license", + "md5": "7f9b6fccfd6d9ff023707301b285042c", + "name": "functools32", + "sha256": "2fa6e304d996655b21f74c0c5aee727dfd5958b1eef02d5cd2525231beb1f70f", + "size": 22930, + "subdir": "linux-64", + "timestamp": 1505957251004, + "version": "3.2.3.2" + }, + "functools32-3.2.3.2-py36hc1f28f5_1.tar.bz2": { + "build": "py36hc1f28f5_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF license", + "md5": "52d4e4a42d59b2c6d3969cbccad2e037", + "name": "functools32", + "sha256": "5144c72fc5da26ed9d4a48d7758faf87f23899464633772e32286d1ffeab0aef", + "size": 22816, + "subdir": "linux-64", + "timestamp": 1505722662729, + "version": "3.2.3.2" + }, + "functools_lru_cache-1.4-hf48f6e4_0.tar.bz2": { + "build": "hf48f6e4_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache 1.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23e2aa6993d40f743f6704f333669be2", + "name": "functools_lru_cache", + "sha256": "3583bf29f6dbcdb00f4ab06d5f66abc439f478aab0480df843d12106c60aac41", + "size": 2739, + "subdir": "linux-64", + "timestamp": 1507051196329, + "version": "1.4" + }, + "functools_lru_cache-1.5-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache 1.5.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f716f201762a7f7ba5596c73b2a3e7f", + "name": "functools_lru_cache", + "sha256": "36f4a5ff364c4702aa54325b1f81d0ae404ed27f8b80f14399b70ca545411c58", + "size": 3131, + "subdir": "linux-64", + "timestamp": 1519170657572, + "version": "1.5" + }, + "furl-1.0.1-py27hb01be32_0.tar.bz2": { + "build": "py27hb01be32_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "13179e31b4f62d2c1151c9fd49c4a4ac", + "name": "furl", + "sha256": "cfce53a263f16e6ce5929a383a68a904a685671456a0a1a9a0893e6ab15f6ddd", + "size": 31400, + "subdir": "linux-64", + "timestamp": 1505743270687, + "version": "1.0.1" + }, + "furl-1.0.1-py35h1507926_0.tar.bz2": { + "build": "py35h1507926_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=3.5,<3.6.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "7f206707acab7dd3d0e0135fca8c00c9", + "name": "furl", + "sha256": "bf15c0041ca3f14c42e0986a7b4432d21fcf98b135bf5f44aca155d19a06e9f4", + "size": 32331, + "subdir": "linux-64", + "timestamp": 1505743282492, + "version": "1.0.1" + }, + "furl-1.0.1-py36h1286c47_0.tar.bz2": { + "build": "py36h1286c47_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "834759e0ca2be66924aa29ce36a1bf34", + "name": "furl", + "sha256": "b697046af5c0c4177ee188226bb90ecaff2c5402198ca3ececd7f6c09be74dab", + "size": 32203, + "subdir": "linux-64", + "timestamp": 1505743294433, + "version": "1.0.1" + }, + "furl-1.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "5bfb888d509bd282c5d2893ce0223741", + "name": "furl", + "sha256": "ce6ec48c892ccf51ca9a6d2fc6f9689df97298f6da2e9db73459e0a7c47bea99", + "size": 32262, + "subdir": "linux-64", + "timestamp": 1527630958081, + "version": "1.0.2" + }, + "furl-1.0.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=3.5,<3.6.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "19a9be96c3386dc0520073047b42d0a2", + "name": "furl", + "sha256": "cce0c8f8aa8bda23e77a37ecda4a50e17eb11f78c0b0f92432eaed5f8245dc17", + "size": 33164, + "subdir": "linux-64", + "timestamp": 1527630981128, + "version": "1.0.2" + }, + "furl-1.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "7d577210cb7b1050ddf991161a2f6839", + "name": "furl", + "sha256": "86e7a8ead942893c49c4efcb93cbde7494d15d34133997d5478d5c3eb8a5cbc0", + "size": 33021, + "subdir": "linux-64", + "timestamp": 1527630947100, + "version": "1.0.2" + }, + "furl-1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "ea7dce3b2f1ceed3a5892589f2f26f2e", + "name": "furl", + "sha256": "fa07ca5ba868124a318ae3b177d08a782b16c9428ce65b1b1876118aecdd8f47", + "size": 32876, + "subdir": "linux-64", + "timestamp": 1528218681128, + "version": "1.1" + }, + "furl-1.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=3.5,<3.6.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "3fd68f50741ddaceda455acbb9768730", + "name": "furl", + "sha256": "cc69433dc9400481ebfae59bff6bc400555de26396df689b8130be196e49222a", + "size": 33770, + "subdir": "linux-64", + "timestamp": 1528218672519, + "version": "1.1" + }, + "furl-1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "0b882aab833f6d3866f7748839989a3e", + "name": "furl", + "sha256": "d1c96466afed3a93ac02dd4e2881ca3c8fc3c1175e8488691de3f86ee5ec6f40", + "size": 33646, + "subdir": "linux-64", + "timestamp": 1528218653895, + "version": "1.1" + }, + "furl-1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=3.7,<3.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "b0028d8b73222bcd82223d2691618d7a", + "name": "furl", + "sha256": "d9bca6ba8b8671048d91884fc6ce91ddbab527e1bea4e96df21fcd9d2b5f4748", + "size": 33665, + "subdir": "linux-64", + "timestamp": 1530879379608, + "version": "1.1" + }, + "furl-1.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=1.0", + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "7b4f5bb3d1b0d0aafa315a32cba2d558", + "name": "furl", + "sha256": "141109ce45f021b707b6375afb73e921046181f05a32f4476076ee33e95ef275", + "size": 32677, + "subdir": "linux-64", + "timestamp": 1535500127933, + "version": "1.2.1" + }, + "furl-1.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=1.0", + "python >=3.5,<3.6.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "b9d2c461fd81c477231a8971018527fb", + "name": "furl", + "sha256": "6773889c3571ce27fb56b90e67593ccfb875f5b789b008e34861ac0025c7176e", + "size": 33629, + "subdir": "linux-64", + "timestamp": 1535500136083, + "version": "1.2.1" + }, + "furl-1.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "2ed3e89ec2788bfd7baf9029f6394988", + "name": "furl", + "sha256": "36c4577a0dc36b3acddf700e143586cf1692b66e81ef04dacdc1d9521a0469e4", + "size": 33514, + "subdir": "linux-64", + "timestamp": 1535500131670, + "version": "1.2.1" + }, + "furl-1.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=1.0", + "python >=3.7,<3.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "a39355d1fe060f9a1953d8a4a2dd8dc6", + "name": "furl", + "sha256": "d0aad0cc0f484f0e3f7f2a627957c46f9fb7527cd2a2c429d08f2f63a56714eb", + "size": 33546, + "subdir": "linux-64", + "timestamp": 1535500143308, + "version": "1.2.1" + }, + "furl-2.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=1.0", + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "3919d52a5ed30e346ef6146f7cc050ad", + "name": "furl", + "sha256": "65179875d900060d5966ae08b08226de9ae730505a2a01cbca3c17b0c09d40ce", + "size": 33877, + "subdir": "linux-64", + "timestamp": 1539623214269, + "version": "2.0.0" + }, + "furl-2.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "e3c292c4e36b456fd7386efed9e2de23", + "name": "furl", + "sha256": "3744dc00aa7b3976b081c3d9f2149a075722e4f7f798021a644852b49fd6ae2f", + "size": 34574, + "subdir": "linux-64", + "timestamp": 1539478162128, + "version": "2.0.0" + }, + "furl-2.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=1.0", + "python >=3.7,<3.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "3bc0dac801915cac6ff277f865e35359", + "name": "furl", + "sha256": "b01b8898b490e59f1bc34570876da54fc8e755d7fb99e54836b923b1453c765d", + "size": 34605, + "subdir": "linux-64", + "timestamp": 1539478166086, + "version": "2.0.0" + }, + "future-0.16.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb47725e8aa242a74ffa056b4cc3dad4", + "name": "future", + "sha256": "1d1ca9751f23ffe495584a54d8d2104cb6fb2dcb4ff0e4c4d0ac42b2c8fa1048", + "size": 683905, + "subdir": "linux-64", + "timestamp": 1530693597407, + "version": "0.16.0" + }, + "future-0.16.0-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c392c0bb8f06e677972fb42c069ca58", + "name": "future", + "sha256": "c23422b5d9f4249dfc86f4e9e5a7bdb9048a1f2b99f913b0b1e7f2be0a0e8a41", + "size": 682667, + "subdir": "linux-64", + "timestamp": 1535545061672, + "version": "0.16.0" + }, + "future-0.16.0-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b1b640ab24b59c13815116f10465d03", + "name": "future", + "sha256": "a30c3239563864385c93cb819046c51cd24addcdda057df2ec24474dd913202e", + "size": 693237, + "subdir": "linux-64", + "timestamp": 1535788261805, + "version": "0.16.0" + }, + "future-0.16.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "54eaf31145fbeeb83713fdb98b81e0e1", + "name": "future", + "sha256": "f181685f1afa41026e2b53511c77e0b97ba10df8dbcf617ff91c52f56e2720fd", + "size": 683857, + "subdir": "linux-64", + "timestamp": 1530693534939, + "version": "0.16.0" + }, + "future-0.16.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eedc1994dafd60b8da8b65c6bca5cf2e", + "name": "future", + "sha256": "7b0f83be2fb851709b663244eaecd0e7290e888439e71a5ecb6484433132e056", + "size": 682040, + "subdir": "linux-64", + "timestamp": 1530693567126, + "version": "0.16.0" + }, + "future-0.17.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "032d1fa785fda0af11fd9e4378d29b15", + "name": "future", + "sha256": "4fd95a2411b867586d88052056d96d8286d5ba50e3752ea487d9c09ee4271bc7", + "size": 726549, + "subdir": "linux-64", + "timestamp": 1540967282409, + "version": "0.17.0" + }, + "future-0.17.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62fa58290df26b2d63f68cb59494e1a0", + "name": "future", + "sha256": "8e29729cea179ef85f57e51de7312a52c007d1c9af841afe3488b793a5e90b62", + "size": 716939, + "subdir": "linux-64", + "timestamp": 1540967294250, + "version": "0.17.0" + }, + "future-0.17.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3082f5e97c46a66662978a3a2ad175a1", + "name": "future", + "sha256": "c09e030749c84f56e7808d67aacdd712bf6ca350f0f37af0e0e3b2633a39bd77", + "size": 715764, + "subdir": "linux-64", + "timestamp": 1540967313150, + "version": "0.17.0" + }, + "future-0.17.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a01fe57963a50a57df092f2b5020dc1d", + "name": "future", + "sha256": "20d3bb6dac2a0584f85525bf0781172d3747e85c9ae7eef9c34d33238a57eb0e", + "size": 727143, + "subdir": "linux-64", + "timestamp": 1541134222813, + "version": "0.17.1" + }, + "future-0.17.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "06ce85da24de04b769adcb8b03817503", + "name": "future", + "sha256": "b9cc1f70610a77665856ac692d7c235723d6018d913741cdbe44dd3983988eca", + "size": 719814, + "subdir": "linux-64", + "timestamp": 1541134282677, + "version": "0.17.1" + }, + "future-0.17.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4eb886395d1da7825339d6145530339c", + "name": "future", + "sha256": "d3a06737e3ed68ab0b205743b0304dbe7d2f2c7ce76aa2727b1ecfa783d164c0", + "size": 715918, + "subdir": "linux-64", + "timestamp": 1541134197047, + "version": "0.17.1" + }, + "future-0.17.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db39e0d22f7502d351109b3d824b0f8c", + "name": "future", + "sha256": "d7024142f5829c25d0ffa32b4afd136b223fbb6b6ffe8d5c58ce8468e49c8223", + "size": 718982, + "subdir": "linux-64", + "timestamp": 1572880778966, + "version": "0.17.1" + }, + "future-0.18.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "810d73576f98de32b2edc8985ddc36ed", + "name": "future", + "sha256": "1ed58e11ea3e0bf60ad375442404c4d731722ad32622f88722de7e224d56e45a", + "size": 745598, + "subdir": "linux-64", + "timestamp": 1573232739928, + "version": "0.18.2" + }, + "future-0.18.2-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b70a3d8fc0786816431f321791bdbb3c", + "name": "future", + "sha256": "789a958c1678c8e6ebcd1f410693e54023a711a4944f46438c9dc56ad961d05a", + "size": 755310, + "subdir": "linux-64", + "timestamp": 1640790142392, + "version": "0.18.2" + }, + "future-0.18.2-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ba9e8efde986e948c4f00ec7f8e526d", + "name": "future", + "sha256": "d78d2a3450f4535413921d484b7c38d84988c7971822a8e7ffcfd3005ec1181f", + "size": 933275, + "subdir": "linux-64", + "timestamp": 1676827184954, + "version": "0.18.2" + }, + "future-0.18.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b9def27080c30db0985a381f56e6eca", + "name": "future", + "sha256": "431699a427f1004fff7d777ca7106301d6272e72a1d71061163cf9de64c4ce0f", + "size": 738248, + "subdir": "linux-64", + "timestamp": 1573232675434, + "version": "0.18.2" + }, + "future-0.18.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d28aa5f86d42d1c78a9033f87d8cb1fe", + "name": "future", + "sha256": "f635388f61ce0a984b4ec254fd879e3f2aa647c5534fca9a9f0f050a57e095f3", + "size": 733569, + "subdir": "linux-64", + "timestamp": 1591811034362, + "version": "0.18.2" + }, + "future-0.18.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "503f54b8d71df989cb14d0bddac77025", + "name": "future", + "sha256": "60c928da3c5f1b5133adeb5b0f3b9a318b1623f1b87ca0be2ea6f58c5b797e44", + "size": 733018, + "subdir": "linux-64", + "timestamp": 1573232624165, + "version": "0.18.2" + }, + "future-0.18.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62fe30ae07378981879c53898f73d260", + "name": "future", + "sha256": "92fcfc732eb0714626630f7ad1978857a66b787abdbd456b5556e08d110f6454", + "size": 737768, + "subdir": "linux-64", + "timestamp": 1591809972903, + "version": "0.18.2" + }, + "future-0.18.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a2c66a25f19686ab9a2107b5ccaebf35", + "name": "future", + "sha256": "0c98731629787dc9d4159b1399f7f08c81ec266a798034a81aef23a7567b8059", + "size": 732691, + "subdir": "linux-64", + "timestamp": 1573232654126, + "version": "0.18.2" + }, + "future-0.18.2-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9510d0c231bfe09cab774cf53c16460b", + "name": "future", + "sha256": "4858175db3d67e2f1c6e6ca1e790ea4ff9318a8495b0b3d57a8cc54ada3df264", + "size": 737688, + "subdir": "linux-64", + "timestamp": 1591810642409, + "version": "0.18.2" + }, + "future-0.18.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4bf8d614fe59795455a96e5d9043bad", + "name": "future", + "sha256": "07506eb3dd014ef655e6efeb826038d5d6cb0258794effacfacfc1ce6e19785b", + "size": 737387, + "subdir": "linux-64", + "timestamp": 1607571374156, + "version": "0.18.2" + }, + "future-0.18.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ecaaf4df042c71443d80e235b51a5f6", + "name": "future", + "sha256": "0ecb6bf4a0b49479881efba2b1e97708534ed4a8814b53fe0dea9a25a9d42059", + "size": 745925, + "subdir": "linux-64", + "timestamp": 1677599962721, + "version": "0.18.3" + }, + "future-0.18.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9bc93401eff9b97a097575087a7f3420", + "name": "future", + "sha256": "98ae441eb026f4c34ed767923fefc38c1767ee870c51a1d4b16972d62eb52848", + "size": 936003, + "subdir": "linux-64", + "timestamp": 1679335951872, + "version": "0.18.3" + }, + "future-0.18.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "676c34222c367f87d8552fa101bd72a3", + "name": "future", + "sha256": "64d4f073615f830d746be80a99b1058ee5317e10500350ece0ab15e708b72434", + "size": 733553, + "subdir": "linux-64", + "timestamp": 1677599903548, + "version": "0.18.3" + }, + "future-0.18.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0bb19edf70e6c381f1ad60e093168b6", + "name": "future", + "sha256": "35ce905299b43ad47dc3055713a01240ee5b784b464742ef64f6fc4b7560320d", + "size": 733788, + "subdir": "linux-64", + "timestamp": 1677599990780, + "version": "0.18.3" + }, + "future-0.18.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec3002754b19b7f404623294f3df3a47", + "name": "future", + "sha256": "14c6075d84aec5867036a20876ee3b238069afac4c264aede13a51eb079bc3ca", + "size": 732993, + "subdir": "linux-64", + "timestamp": 1677599933597, + "version": "0.18.3" + }, + "futures-3.1.1-py27hdbc8cbb_0.tar.bz2": { + "build": "py27hdbc8cbb_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "fb5b82ad45279ec62e479df558605aa5", + "name": "futures", + "sha256": "6933525589508842d3ae1a993086aeb20a2f3616d37c34d062c7a87564fc109d", + "size": 23586, + "subdir": "linux-64", + "timestamp": 1505733247585, + "version": "3.1.1" + }, + "futures-3.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "6892ff402aef19d82a6472ce5c2c1ea9", + "name": "futures", + "sha256": "a8e6133f20263a553e493a84f69de858fb333d9a920b6328658e2dde47590449", + "size": 24947, + "subdir": "linux-64", + "timestamp": 1530735271877, + "version": "3.2.0" + }, + "futures-3.2.0-py27_1000.tar.bz2": { + "build": "py27_1000", + "build_number": 1000, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "d3da77ab9df208466aa2b1d5e3fd47d5", + "name": "futures", + "sha256": "1917d9e82dcf56fa35c237020d9d0fb3051b0ae3fadeff44bba10fcb97ff4d46", + "size": 28366, + "subdir": "linux-64", + "timestamp": 1558589210132, + "version": "3.2.0" + }, + "futures-3.2.0-py27h7b459c0_0.tar.bz2": { + "build": "py27h7b459c0_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "f30a137e59618fed1c7ab74481b59c7f", + "name": "futures", + "sha256": "49dd1b281b382ae404eac712e3e4cbc7827daa8bf1084627548fc56350bfedbf", + "size": 25312, + "subdir": "linux-64", + "timestamp": 1512192950121, + "version": "3.2.0" + }, + "futures-3.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "22624f5a3e4b10c654dc9baccf852cb2", + "name": "futures", + "sha256": "acc9f8d7da8993f134c62c34cc4badf0e1482dfca62ea51d9cdd82176d8c59b6", + "size": 28574, + "subdir": "linux-64", + "timestamp": 1563286742065, + "version": "3.3.0" + }, + "fuzzywuzzy-0.18.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "9709fa986a72f89763d22925a0506c84", + "name": "fuzzywuzzy", + "sha256": "dd8a4d32f684cae3bcb0cd5cc82831131578ab63afb2362dc6f499b2afbd3068", + "size": 29611, + "subdir": "linux-64", + "timestamp": 1650548292461, + "version": "0.18.0" + }, + "fuzzywuzzy-0.18.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "f59112a6661b11a362507874e2fc9766", + "name": "fuzzywuzzy", + "sha256": "05e432b6b2e338f576ba3f02ac7f51ecdb800e62033a11dc9d085f8dec3f6c13", + "size": 34256, + "subdir": "linux-64", + "timestamp": 1676852518908, + "version": "0.18.0" + }, + "fuzzywuzzy-0.18.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "0d78a08d874986589d4760bbcb6cfbc3", + "name": "fuzzywuzzy", + "sha256": "d45f2f1b5252ac71698f75f2c46c3d363e420c49f0ef8913d9bf3d275997ea12", + "size": 29432, + "subdir": "linux-64", + "timestamp": 1650548256396, + "version": "0.18.0" + }, + "fuzzywuzzy-0.18.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "01095bb68087ac7ba3958c3e785a7dc5", + "name": "fuzzywuzzy", + "sha256": "75b67c23faa31b92a1f2f4707830a0c372df94f5c493333368af50ee056d336c", + "size": 29513, + "subdir": "linux-64", + "timestamp": 1650548316884, + "version": "0.18.0" + }, + "fuzzywuzzy-0.18.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "69e54d7841abb18c0d6dfc4b3daa8f96", + "name": "fuzzywuzzy", + "sha256": "ebb4c710d634e18a7858989d34734dfd99207c94a8031756c60f169a28d24cd9", + "size": 29546, + "subdir": "linux-64", + "timestamp": 1650548231543, + "version": "0.18.0" + }, + "g2clib-1.6.0-h838ce51_4.tar.bz2": { + "build": "h838ce51_4", + "build_number": 4, + "depends": [ + "jasper >=1.900.1,<2.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public Domain", + "md5": "664c502f1668038f2b7250c324105b34", + "name": "g2clib", + "sha256": "af0acbbd9d53ecdac1fe2fa80ea9ae14b9e5fed39829499995951daae3e3e5dd", + "size": 57699, + "subdir": "linux-64", + "timestamp": 1512065852712, + "version": "1.6.0" + }, + "g2clib-1.6.0-h8a8886c_5.tar.bz2": { + "build": "h8a8886c_5", + "build_number": 5, + "depends": [ + "jasper >=2.0.14,<3.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public Domain", + "md5": "d3bdc4f496122e1b943ec9d49dc17cff", + "name": "g2clib", + "sha256": "cd1986badff9c28170dc2c0fb9830e7717432f37a2e23109bbc0c0b7f1513285", + "size": 57582, + "subdir": "linux-64", + "timestamp": 1531092606455, + "version": "1.6.0" + }, + "g2clib-1.6.2-ha7d24e7_0.tar.bz2": { + "build": "ha7d24e7_0", + "build_number": 0, + "depends": [ + "jasper >=2.0.14,<3.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public Domain", + "md5": "ee14048583fb91f48de7b1297ef9348d", + "name": "g2clib", + "sha256": "e770d07375074ba0d71de9039c610ff16c99aa4034d57f1d6bef42e4fc9b72c9", + "size": 58240, + "subdir": "linux-64", + "timestamp": 1608329007862, + "version": "1.6.2" + }, + "g2clib-1.6.3-ha7d24e7_0.tar.bz2": { + "build": "ha7d24e7_0", + "build_number": 0, + "depends": [ + "jasper >=2.0.14,<3.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public Domain", + "md5": "60e80c30a07c781ca3ff1ac4c8cdb67e", + "name": "g2clib", + "sha256": "a2a0668a3576e6b3e664ed304eeb73d3cefbb488e1b1cf138dcca21a1c1e8c3a", + "size": 54699, + "subdir": "linux-64", + "timestamp": 1615381036664, + "version": "1.6.3" + }, + "gast-0.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "cac1c7bb33cf74885c2620e9d083f772", + "name": "gast", + "sha256": "221b44660aa39bda6284c8fdc65a997ad059f114d950cd0dc20c5a493b1cf116", + "size": 15111, + "subdir": "linux-64", + "timestamp": 1519945760708, + "version": "0.2.0" + }, + "gast-0.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "82c70c670fdc2cd71faac11e6394cf17", + "name": "gast", + "sha256": "c839e8f229882083f222a24912a086b3087ff012229c3d35cc2ea5fc3ae15a01", + "size": 15337, + "subdir": "linux-64", + "timestamp": 1519945768224, + "version": "0.2.0" + }, + "gast-0.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "3fd33380e0baaae3ccd1b795f57208aa", + "name": "gast", + "sha256": "1e2c3506d728ad4ac29551bc728aff58b9a7195d92ec8f044bd318592a6c2ad7", + "size": 15031, + "subdir": "linux-64", + "timestamp": 1519945787974, + "version": "0.2.0" + }, + "gast-0.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "ca403e51e18509ab4c8dfeaa669ea2ec", + "name": "gast", + "sha256": "f386d0762aa23022ef3541981b6e5176c2520a0f29f179b936c6866a2d8abd34", + "size": 14526, + "subdir": "linux-64", + "timestamp": 1530879408932, + "version": "0.2.0" + }, + "gast-0.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "1cc56612025b43ce3f82110e5ec56db5", + "name": "gast", + "sha256": "b6fc448ba3c0259f5b4ac5bb4a982e9a64eb3daf46f90a815f3c5307a817d4a7", + "size": 140748, + "subdir": "linux-64", + "timestamp": 1547229621936, + "version": "0.2.1" + }, + "gast-0.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "a8aff5b19cfb5bf2c1b4c5021d250d60", + "name": "gast", + "sha256": "263c01d3382c6c5df0ea2c3508000e5d9ff8a2342e6c0e50eca03c50286e80fb", + "size": 140372, + "subdir": "linux-64", + "timestamp": 1547229640591, + "version": "0.2.1" + }, + "gast-0.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "961bd5a22a10d858700e7047daab04e3", + "name": "gast", + "sha256": "531bcc9a0c6274846fc0bfe029091c651636926b6c55aa60d0ee2fc635c75f9c", + "size": 139950, + "subdir": "linux-64", + "timestamp": 1547229606088, + "version": "0.2.1" + }, + "gast-0.2.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "e8049dc33f156001f1786b49223b30b0", + "name": "gast", + "sha256": "8bdcb1ef1837b03e64bf95900ac143d2c73e6da17d7e7c1f65eaaaaf2cda6bdd", + "size": 141434, + "subdir": "linux-64", + "timestamp": 1547749522913, + "version": "0.2.2" + }, + "gast-0.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "332b34e0a6ff6cb14011e7bbdfecfd14", + "name": "gast", + "sha256": "9b3ed457bd7b35b316aa42c372d3a3fb2d0708ee6eec4002e5f52cbdbfe4ced6", + "size": 141067, + "subdir": "linux-64", + "timestamp": 1547749527299, + "version": "0.2.2" + }, + "gast-0.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "e8ce30dc531112ec46e1370b856b1278", + "name": "gast", + "sha256": "5ef7f672e0e910627cb73ebdc611ffc05144c3a8c11d4357213e97797d505c3b", + "size": 140576, + "subdir": "linux-64", + "timestamp": 1547749463316, + "version": "0.2.2" + }, + "gawk-4.2.1-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "b2d07e28d029e51e387c6adc2210afab", + "name": "gawk", + "sha256": "31424c223810156b6d7802415fb0b4996ea65f8410b1af3fbd8e8bd412faf80e", + "size": 1338209, + "subdir": "linux-64", + "timestamp": 1527332422904, + "version": "4.2.1" + }, + "gawk-5.0.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "de7374bce90edc48aa10eff56bc40303", + "name": "gawk", + "sha256": "6e9f347a3d84266262f20df973a1221797e705108adb791bac63094833816896", + "size": 1460312, + "subdir": "linux-64", + "timestamp": 1558589486887, + "version": "5.0.0" + }, + "gawk-5.0.1-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "980cb6daad1d8be76b950f8171334822", + "name": "gawk", + "sha256": "f44f93bd1fc402a8e0189826c990dd8d4e79e5767daa32366372eb318e52aa3a", + "size": 1475888, + "subdir": "linux-64", + "timestamp": 1565191723331, + "version": "5.0.1" + }, + "gawk-5.1.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "bee33ea3054e9c5be0c36d8a4f36c436", + "name": "gawk", + "sha256": "184afd00bf4b6b3839f43bf9133f0a921104fd191297cd5f8aa8552f0a02ee29", + "size": 1444328, + "subdir": "linux-64", + "timestamp": 1587132617252, + "version": "5.1.0" + }, + "gcab-1.4-h8b4e3a7_0.tar.bz2": { + "build": "h8b4e3a7_0", + "build_number": 0, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "7566490851792d0d2cae99f7a4d3cd98", + "name": "gcab", + "sha256": "50f5b654096e4fde590c486e4c9f8f5b6fef737ba2e30b900d5bb14506258389", + "size": 59893, + "subdir": "linux-64", + "timestamp": 1667484696429, + "version": "1.4" + }, + "gcc-dbg_linux-64-7.2.0-19.tar.bz2": { + "build": "19", + "build_number": 19, + "depends": [ + "binutils_linux-64 7.2.0 19", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "e49f4467adb402e44a2d4365eee2fb8d", + "name": "gcc-dbg_linux-64", + "sha256": "e36e9216a0d481ccc016487a8d8e37f6e7fb7f8b303a106806662a57a8819e64", + "size": 6497, + "subdir": "linux-64", + "timestamp": 1513886592858, + "version": "7.2.0" + }, + "gcc-dbg_linux-64-7.2.0-24.tar.bz2": { + "build": "24", + "build_number": 24, + "depends": [ + "binutils_linux-64 7.2.0 24", + "gcc_impl_linux-64 7.2.0.*", + "package_has_been_revoked" + ], + "license": "GPL", + "md5": "68f0dc697d782bf5fee758756bd19e5d", + "name": "gcc-dbg_linux-64", + "revoked": true, + "sha256": "7bfa6adea2aac343c7f81db267418c3d9e1515bcb8d468e7ac2a51df9cb1a1a6", + "size": 5960, + "subdir": "linux-64", + "timestamp": 1514480887329, + "version": "7.2.0" + }, + "gcc-dbg_linux-64-7.2.0-25.tar.bz2": { + "build": "25", + "build_number": 25, + "depends": [ + "binutils_linux-64 7.2.0 25", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "f92909f738c1ff48aba231592c1d162a", + "name": "gcc-dbg_linux-64", + "sha256": "c70cb45ecc4a77bd736ab2149a197a2300e5944480c2961a932f5071e9ffeb1a", + "size": 5980, + "subdir": "linux-64", + "timestamp": 1515156400620, + "version": "7.2.0" + }, + "gcc-dbg_linux-64-7.3.0-h553295d_1.tar.bz2": { + "build": "h553295d_1", + "build_number": 1, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_1", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "3163e6853bb2d8add596d088feaa3835", + "name": "gcc-dbg_linux-64", + "sha256": "10f3d23aedd1ca94a8e5087b8e1903cd1f34f3e124d09b455062f91adb92080f", + "size": 9736, + "subdir": "linux-64", + "timestamp": 1534694155758, + "version": "7.3.0" + }, + "gcc-dbg_linux-64-7.3.0-h553295d_2.tar.bz2": { + "build": "h553295d_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_2", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "37af45b0a78bdf77141904ff4532d49a", + "name": "gcc-dbg_linux-64", + "sha256": "dc94922a5e3f2024122a547e26c4a4079e5b0fc52705ea7b52681a4294e965a2", + "size": 9753, + "subdir": "linux-64", + "timestamp": 1534794490768, + "version": "7.3.0" + }, + "gcc-dbg_linux-64-7.3.0-h553295d_26.tar.bz2": { + "build": "h553295d_26", + "build_number": 26, + "depends": [ + "binutils_linux-64 7.3.0 h6176602_26", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "54b6d98e716bd712df7f228557c1223e", + "name": "gcc-dbg_linux-64", + "sha256": "86f3f8bb967858e806d1a86fb4d4cfe8a0727b2cdf18421103ea33977b7e1500", + "size": 9176, + "subdir": "linux-64", + "timestamp": 1534693901075, + "version": "7.3.0" + }, + "gcc-dbg_linux-64-8.2.0-h218040c_1.tar.bz2": { + "build": "h218040c_1", + "build_number": 1, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_1", + "gcc_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "295f1559da0e6346718fdedc08a5b46a", + "name": "gcc-dbg_linux-64", + "sha256": "d44be4a5eded490c19557ac3cab7d4f1686d6c748c382ee4cae67c65f7a1e97f", + "size": 9715, + "subdir": "linux-64", + "timestamp": 1534694048676, + "version": "8.2.0" + }, + "gcc-dbg_linux-64-8.2.0-h218040c_26.tar.bz2": { + "build": "h218040c_26", + "build_number": 26, + "depends": [ + "binutils_linux-64 8.2.0 h6176602_26", + "gcc_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "d9feeecfc9117d04da39c773b549628f", + "name": "gcc-dbg_linux-64", + "sha256": "feffbe6466334819a9438b2e0936bfb4b1a6239ba73c075aa00972f686cc54df", + "size": 9160, + "subdir": "linux-64", + "timestamp": 1534693817310, + "version": "8.2.0" + }, + "gcc_bootstrap_linux-64-11.2.0-h99d4493_0.tar.bz2": { + "build": "h99d4493_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=4.9", + "libstdcxx-ng >=4.9" + ], + "license": "GPL", + "md5": "5f6230a058975489ae371be9a6fdae04", + "name": "gcc_bootstrap_linux-64", + "sha256": "f6fe74e06618df23afafdef8d74601626f8c8021e3eb07f65e8e7508b3a901b6", + "size": 170982389, + "subdir": "linux-64", + "timestamp": 1652867324153, + "version": "11.2.0" + }, + "gcc_bootstrap_linux-64-7.3.0-h64e4fec_15.tar.bz2": { + "build": "h64e4fec_15", + "build_number": 15, + "depends": [], + "license": "GPL", + "md5": "92d8c4c68b891523c2c351ba660731b0", + "name": "gcc_bootstrap_linux-64", + "sha256": "7d24f1c3d8db5f8c844f5e9d70034abb0b85b36e17fdd907b1d8a8f4d336c89f", + "size": 128096482, + "subdir": "linux-64", + "timestamp": 1576707947593, + "version": "7.3.0" + }, + "gcc_bootstrap_linux-64-7.3.0-h64e4fec_9.tar.bz2": { + "build": "h64e4fec_9", + "build_number": 9, + "depends": [], + "license": "GPL", + "md5": "f674e1c8c7341eeae848e8274447504b", + "name": "gcc_bootstrap_linux-64", + "sha256": "7efc4bf8484a06923347e57b642641205273228bd2e62efa0c56fd9735e0f676", + "size": 135517300, + "subdir": "linux-64", + "timestamp": 1576689821203, + "version": "7.3.0" + }, + "gcc_bootstrap_linux-64-7.5.0-hbbeae57_30.tar.bz2": { + "build": "hbbeae57_30", + "build_number": 30, + "depends": [], + "license": "GPL", + "md5": "e29864ebc209f3a5dfa05bc9fce9b7d7", + "name": "gcc_bootstrap_linux-64", + "sha256": "b77fe93789d4c9166d66a86b4690640dc994ef137a86feec7bd2f0c361e7ec35", + "size": 137722084, + "subdir": "linux-64", + "timestamp": 1623135406488, + "version": "7.5.0" + }, + "gcc_bootstrap_linux-64-8.4.0-hd257e2f_30.tar.bz2": { + "build": "hd257e2f_30", + "build_number": 30, + "depends": [], + "license": "GPL", + "md5": "afa96e2c9491d4eda09962de8c555e1d", + "name": "gcc_bootstrap_linux-64", + "sha256": "a84f779291b2092bca4607b47692cfb4cc4de06bb13aea11014b0bcc350da336", + "size": 145855171, + "subdir": "linux-64", + "timestamp": 1623135977196, + "version": "8.4.0" + }, + "gcc_bootstrap_linux-64-9.3.0-hb95220a_30.tar.bz2": { + "build": "hb95220a_30", + "build_number": 30, + "depends": [], + "license": "GPL", + "md5": "aee3db8563c36d4b704ecee407da3cd3", + "name": "gcc_bootstrap_linux-64", + "sha256": "07cb3a0e65fd87493f92e2300676f6e72a0d6c461e66c1fc259a980e7c73520f", + "size": 147739206, + "subdir": "linux-64", + "timestamp": 1623136540355, + "version": "9.3.0" + }, + "gcc_impl_linux-64-11.2.0-h1234567_0.tar.bz2": { + "build": "h1234567_0", + "build_number": 0, + "depends": [ + "binutils_impl_linux-64 >=2.38", + "libgcc-devel_linux-64 11.2.0 h1234567_0", + "libgcc-ng >=11.2.0", + "libgcc-ng >=4.9", + "libgomp >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libstdcxx-ng >=4.9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "877a6b9fcb1d375631fe23f1cfb22192", + "name": "gcc_impl_linux-64", + "sha256": "2447430b0df3c886d02d2bfbb42924eaa11417f2f050dddabb1415138ae38103", + "size": 54131736, + "subdir": "linux-64", + "timestamp": 1652859794417, + "version": "11.2.0" + }, + "gcc_impl_linux-64-11.2.0-h1234567_1.tar.bz2": { + "build": "h1234567_1", + "build_number": 1, + "depends": [ + "binutils_impl_linux-64 >=2.38", + "libgcc-devel_linux-64 11.2.0 h1234567_1", + "libgcc-ng >=11.2.0", + "libgcc-ng >=4.9", + "libgomp >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libstdcxx-ng >=4.9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "e19520fb6dfddf7e6822d7c97f41660c", + "name": "gcc_impl_linux-64", + "sha256": "7d10b4ae6ec05fb299232322006e9dba3e3b644f13a840a9a897ec2eb61c70fa", + "size": 53953100, + "subdir": "linux-64", + "timestamp": 1654090883178, + "version": "11.2.0" + }, + "gcc_impl_linux-64-5.4.0-habb00fd_3.tar.bz2": { + "build": "habb00fd_3", + "build_number": 3, + "depends": [ + "binutils_impl_linux-64 >=2.28.1,<3", + "libstdcxx-ng >=5.4.0" + ], + "license": "GPL", + "md5": "5ecceed03521f426c1a4d0c1972e8a6e", + "name": "gcc_impl_linux-64", + "sha256": "b2bc6a7491e23989a52c884237564e00e77b1d60960f66a895dffcca1f747f9c", + "size": 64013855, + "subdir": "linux-64", + "timestamp": 1520969643017, + "version": "5.4.0" + }, + "gcc_impl_linux-64-7.2.0-habb00fd_3.tar.bz2": { + "build": "habb00fd_3", + "build_number": 3, + "depends": [ + "binutils_impl_linux-64 >=2.28.1,<3", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL", + "md5": "9557fa25d92054c4817d6144a2b6ad7e", + "name": "gcc_impl_linux-64", + "sha256": "5d8a020d3c9f0459ebc7c901e1d0fa83a0b317cf07e8bb324e857de20216b84d", + "size": 75946690, + "subdir": "linux-64", + "timestamp": 1520534652729, + "version": "7.2.0" + }, + "gcc_impl_linux-64-7.2.0-hc5ce805_2.tar.bz2": { + "build": "hc5ce805_2", + "build_number": 2, + "depends": [ + "binutils_impl_linux-64 >=2.28.1,<3", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL", + "md5": "757bd7369cdc8949aa68d9adc338c771", + "name": "gcc_impl_linux-64", + "sha256": "59c7a305598525a321e8ca13e166341bd3d624070a8ba20756a3952747929767", + "size": 74343497, + "subdir": "linux-64", + "timestamp": 1507262906442, + "version": "7.2.0" + }, + "gcc_impl_linux-64-7.3.0-habb00fd_0.tar.bz2": { + "build": "habb00fd_0", + "build_number": 0, + "depends": [ + "binutils_impl_linux-64 >=2.31.1,<3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL", + "md5": "0329b343d3732712a0be51904274e5be", + "name": "gcc_impl_linux-64", + "sha256": "628e744d024e248ff7ae182649a654a04bac38e2ccb6c453d64d23178e2d9bf9", + "size": 76757870, + "subdir": "linux-64", + "timestamp": 1534628568186, + "version": "7.3.0" + }, + "gcc_impl_linux-64-7.3.0-habb00fd_1.tar.bz2": { + "build": "habb00fd_1", + "build_number": 1, + "depends": [ + "binutils_impl_linux-64 >=2.31.1,<3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL", + "md5": "815a1b1430442d977658a94b68ce7dd0", + "name": "gcc_impl_linux-64", + "sha256": "53d3485cb17128e4c4dc7495a5d1b6fdb88f3e7198e42492d142056983b95bfb", + "size": 76730088, + "subdir": "linux-64", + "timestamp": 1534866771998, + "version": "7.3.0" + }, + "gcc_impl_linux-64-7.5.0-h7105cf2_17.tar.bz2": { + "build": "h7105cf2_17", + "build_number": 17, + "depends": [ + "binutils_impl_linux-64 >=2.35.1", + "libgcc-devel_linux-64 7.5.0 hbbeae57_17", + "libgcc-ng >=4.9", + "libgcc-ng >=7.5.0", + "libgomp >=7.5.0", + "libstdcxx-ng >=4.9", + "libstdcxx-ng >=7.5.0", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "1647f0b5e046076f47c11163e27ef3de", + "name": "gcc_impl_linux-64", + "sha256": "6234f373bbc27d6bf9c323cdd64791486eaf31bbb54e9e1d3c4d721c17e1f0d5", + "size": 43948765, + "subdir": "linux-64", + "timestamp": 1622660170900, + "version": "7.5.0" + }, + "gcc_impl_linux-64-8.4.0-he7ac559_17.tar.bz2": { + "build": "he7ac559_17", + "build_number": 17, + "depends": [ + "binutils_impl_linux-64 >=2.35.1", + "libgcc-devel_linux-64 8.4.0 hd257e2f_17", + "libgcc-ng >=4.9", + "libgcc-ng >=8.4.0", + "libgomp >=8.4.0", + "libstdcxx-ng >=4.9", + "libstdcxx-ng >=8.4.0", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "5c2f921a09af60ddee447caae1ffba86", + "name": "gcc_impl_linux-64", + "sha256": "52f18fbfc9f5818adf1d5a3becfa19408fb6e8f7b566833cf024f90f58175bb4", + "size": 46488192, + "subdir": "linux-64", + "timestamp": 1622661781113, + "version": "8.4.0" + }, + "gcc_impl_linux-64-9.3.0-h6df7d76_17.tar.bz2": { + "build": "h6df7d76_17", + "build_number": 17, + "depends": [ + "binutils_impl_linux-64 >=2.35.1", + "libgcc-devel_linux-64 9.3.0 hb95220a_17", + "libgcc-ng >=4.9", + "libgcc-ng >=9.3.0", + "libgomp >=9.3.0", + "libstdcxx-ng >=4.9", + "libstdcxx-ng >=9.3.0", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "797ac218963c62b79e1bdcf8c98e1ab4", + "name": "gcc_impl_linux-64", + "sha256": "7838539f91f4e936f17aaf30137d18899f4a07bfc5605a42bbd5becf90dd7cf1", + "size": 46766764, + "subdir": "linux-64", + "timestamp": 1622663430911, + "version": "9.3.0" + }, + "gcc_linux-64-11.2.0-h5c386dc_0.tar.bz2": { + "build": "h5c386dc_0", + "build_number": 0, + "depends": [ + "binutils_linux-64 2.38.0 hc2dff05_0", + "gcc_impl_linux-64 11.2.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "4171eeeb32f7c0e789283639b6ffdacc", + "name": "gcc_linux-64", + "sha256": "fbaa9a8e316cae57cedf2d61be423251606dda507d3e5d617d17fa38b57637e2", + "size": 23383, + "subdir": "linux-64", + "timestamp": 1652867211979, + "version": "11.2.0" + }, + "gcc_linux-64-5.4.0-h98af8de_24.tar.bz2": { + "build": "h98af8de_24", + "build_number": 24, + "depends": [ + "binutils_linux-64 5.4.0 had2808c_24", + "gcc_impl_linux-64 5.4.0.*" + ], + "license": "GPL", + "md5": "c711728916be7a8c3c8a3fe8195098ac", + "name": "gcc_linux-64", + "sha256": "fa0c7fbbbe1e44dcc67c1c431cf64926fffb075c9b160339168f76d64187ac61", + "size": 8737, + "subdir": "linux-64", + "timestamp": 1520970082066, + "version": "5.4.0" + }, + "gcc_linux-64-7.2.0-19.tar.bz2": { + "build": "19", + "build_number": 19, + "depends": [ + "binutils_linux-64 7.2.0 19", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "10bc363b855b0a940e856e8b7b73408e", + "name": "gcc_linux-64", + "sha256": "2edfccb93a2e5c3704918a163207eecd7fb7b43b2a1a9a944f848b4e4b7e43ca", + "size": 6447, + "subdir": "linux-64", + "timestamp": 1513886714900, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-24.tar.bz2": { + "build": "24", + "build_number": 24, + "depends": [ + "package_has_been_revoked" + ], + "license": "GPL", + "md5": "f9e7d53aace773415713f2f15255d9cc", + "name": "gcc_linux-64", + "revoked": true, + "sha256": "ad3ab401b893cd814f3237ac95f4c9769bd70f996f16f623c1ef27aaed68af3b", + "size": 5922, + "subdir": "linux-64", + "timestamp": 1514474638847, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-25.tar.bz2": { + "build": "25", + "build_number": 25, + "depends": [ + "binutils_linux-64 7.2.0 25", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "a93a8600bf1883e43c6652107e883611", + "name": "gcc_linux-64", + "sha256": "750ce6dabc744e048db0765868652367d3935dcf96fd95159330bd40e53b97b8", + "size": 5965, + "subdir": "linux-64", + "timestamp": 1514480906213, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-26.tar.bz2": { + "build": "26", + "build_number": 26, + "depends": [ + "binutils_linux-64 7.2.0 26", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "bebded9bd255ab5d9bd0e8df7936eae5", + "name": "gcc_linux-64", + "sha256": "fdf7324d94bdb0d172e718d9b7f6742fa7009515e4366300a259f469be066ae2", + "size": 8899, + "subdir": "linux-64", + "timestamp": 1521829426235, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-h196ecd4_10.tar.bz2": { + "build": "h196ecd4_10", + "build_number": 10, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_10", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "04e4d40a4742d482ab1618f54cd461ec", + "name": "gcc_linux-64", + "sha256": "11c28caee4d99e073f4b49ba897c1b767b3b192a6cda05993285e6ed3a900906", + "size": 5128, + "subdir": "linux-64", + "timestamp": 1510244819367, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-h217957b_13.tar.bz2": { + "build": "h217957b_13", + "build_number": 13, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_13", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "381d1b233f1b696a10ffde9b6a859c01", + "name": "gcc_linux-64", + "sha256": "b32988b15cea3e5c1205bb2b8d98e894cdcd40f38df901d8a911effd23206df7", + "size": 5434, + "subdir": "linux-64", + "timestamp": 1510925048019, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-h22f992b_7.tar.bz2": { + "build": "h22f992b_7", + "build_number": 7, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_7", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "9f877b4e55858da8a0811c75edc5237a", + "name": "gcc_linux-64", + "sha256": "7e4d61c89a67a9af41d77fc4dfb0d580501d6a2e9fb274ff866191edde5b6259", + "size": 5031, + "subdir": "linux-64", + "timestamp": 1507845399722, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-h29fd5c9_3.tar.bz2": { + "build": "h29fd5c9_3", + "build_number": 3, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_3", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "7b8372828c67ff006d63291881bda858", + "name": "gcc_linux-64", + "sha256": "94fed64e103d2d01615feb46ee5d2038e4b3eaafd1a2b200e2690b1aefd5ef23", + "size": 5237, + "subdir": "linux-64", + "timestamp": 1507320234616, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-h4118e58_11.tar.bz2": { + "build": "h4118e58_11", + "build_number": 11, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_11", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "532cf294f9227cae78a0b31b57d7d6c6", + "name": "gcc_linux-64", + "sha256": "3081765fcbb8ea789a150fadb6a94993c31c64f20f720854726deaa6a1b53c9a", + "size": 5231, + "subdir": "linux-64", + "timestamp": 1510566119502, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-h550dcbe_27.tar.bz2": { + "build": "h550dcbe_27", + "build_number": 27, + "depends": [ + "binutils_linux-64 7.2.0 had2808c_27", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "2bade4d166a4fd85e176468828c3551c", + "name": "gcc_linux-64", + "sha256": "bfee782975e46060358a5335642bf4dd7f86f2859fde9c94038e142307844e6b", + "size": 8836, + "subdir": "linux-64", + "timestamp": 1526461254217, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-h60973fd_9.tar.bz2": { + "build": "h60973fd_9", + "build_number": 9, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_9", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "9b0fd4be1b86204b8c83211c2b7d6ac4", + "name": "gcc_linux-64", + "sha256": "045bd6f4fb221d639b43749e0126da954ab3cd9ca7ac53f60822b6d6e4d628d2", + "size": 5257, + "subdir": "linux-64", + "timestamp": 1509836579789, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-h6f34251_8.tar.bz2": { + "build": "h6f34251_8", + "build_number": 8, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_8", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "252a6545ba962541618a4b13c2ed8bd6", + "name": "gcc_linux-64", + "sha256": "833b684cc647aa30c29aea26dd0bf691a7564ca51cd1ab436b780373aaba3b43", + "size": 4997, + "subdir": "linux-64", + "timestamp": 1509635178401, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-haf1f6fa_15.tar.bz2": { + "build": "haf1f6fa_15", + "build_number": 15, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_15", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "82fed4d7afd8bcc5f8f52a094f35fa3a", + "name": "gcc_linux-64", + "sha256": "171e32db98848d635370d1a4a78dd1ecba94cc996298e01deaa7f5af001bd124", + "size": 5424, + "subdir": "linux-64", + "timestamp": 1511640858292, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-hc7b1ceb_1.tar.bz2": { + "build": "hc7b1ceb_1", + "build_number": 1, + "depends": [ + "binutils_linux-64 2.28.1 he4fe6c7_1" + ], + "license": "GPL", + "md5": "7e41e383df034342213a4460aa3b0433", + "name": "gcc_linux-64", + "sha256": "69c625bfaff333103cb8baea7039f968c00f8f5fe9c2aa55a3015aa62cc996d7", + "size": 74987153, + "subdir": "linux-64", + "timestamp": 1505665670247, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-hd763dfe_12.tar.bz2": { + "build": "hd763dfe_12", + "build_number": 12, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_12", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "7c342ec5e7fa6686bb2702ec183b4959", + "name": "gcc_linux-64", + "sha256": "32a35c776adaa229effb19e3d981572f06fe704465755c98c9d0a59a541d5179", + "size": 5827, + "subdir": "linux-64", + "timestamp": 1510792709510, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-hecb3f9c_2.tar.bz2": { + "build": "hecb3f9c_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_2", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "18329c327ce6b1d60b95964472e8adf5", + "name": "gcc_linux-64", + "sha256": "c247124fff26d3f2bbf87b8d2994b73ccab516607215900b1aa935e6bfe84cae", + "size": 5219, + "subdir": "linux-64", + "timestamp": 1507320098487, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-hf1c97a4_14.tar.bz2": { + "build": "hf1c97a4_14", + "build_number": 14, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_14", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "15e176c21873f82a8acec164d0c0ce0d", + "name": "gcc_linux-64", + "sha256": "b9474bbb48d03f40e9fa4481c11ac6525c86dde5a64874a2d89ef4aaee2a5cc3", + "size": 5441, + "subdir": "linux-64", + "timestamp": 1510930963879, + "version": "7.2.0" + }, + "gcc_linux-64-7.3.0-h553295d_1.tar.bz2": { + "build": "h553295d_1", + "build_number": 1, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_1", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "2db41038d0194e00352c07177acf2141", + "name": "gcc_linux-64", + "sha256": "4d17d2b2c1688398db58efd3cc4f436d9d242db20c127278a0ebf1b7bea3d252", + "size": 9875, + "subdir": "linux-64", + "timestamp": 1534628901966, + "version": "7.3.0" + }, + "gcc_linux-64-7.3.0-h553295d_15.tar.bz2": { + "build": "h553295d_15", + "build_number": 15, + "depends": [ + "binutils_linux-64 2.33.1 h9595d00_15", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "BSD-3-Clause", + "md5": "0f2128892c34d01f2e1bed94d04ab1bd", + "name": "gcc_linux-64", + "sha256": "6011dbeefd6368be8a644398ab8f2b3879077eaffcd7e472add93e2a9321d88c", + "size": 25344, + "subdir": "linux-64", + "timestamp": 1576707749392, + "version": "7.3.0" + }, + "gcc_linux-64-7.3.0-h553295d_2.tar.bz2": { + "build": "h553295d_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_2", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "de49e351bffefd1a15b42974b8961650", + "name": "gcc_linux-64", + "sha256": "b9ad7e54693d9e7a5b9d461efd63098780282f7a87b3f4aa477720924bff46cb", + "size": 9822, + "subdir": "linux-64", + "timestamp": 1534793051330, + "version": "7.3.0" + }, + "gcc_linux-64-7.3.0-h553295d_3.tar.bz2": { + "build": "h553295d_3", + "build_number": 3, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_3", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "455ba9f69cc1e8521e0d5d66d62e42b5", + "name": "gcc_linux-64", + "sha256": "29455c085b7dd9bc37c0232a4f660fd79f3c0e18a8b90d3195cc4c605bbf1df3", + "size": 9822, + "subdir": "linux-64", + "timestamp": 1534948640654, + "version": "7.3.0" + }, + "gcc_linux-64-7.3.0-h553295d_6.tar.bz2": { + "build": "h553295d_6", + "build_number": 6, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_6", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "d571a1ec2ac4985fb2fff80297a0cccc", + "name": "gcc_linux-64", + "sha256": "07898a7a8d8fb0b0eb96187e9ef7956ee088e10d54862846ee7dfe9d82a94630", + "size": 10708, + "subdir": "linux-64", + "timestamp": 1546883610036, + "version": "7.3.0" + }, + "gcc_linux-64-7.3.0-h553295d_7.tar.bz2": { + "build": "h553295d_7", + "build_number": 7, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_7", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "736d5ff07b7af68bec6e030e452ac472", + "name": "gcc_linux-64", + "sha256": "fc5e55459ae72cf54de3862e1107783468e28e2934d68ed76113bc2c8457b17a", + "size": 9925, + "subdir": "linux-64", + "timestamp": 1556137064827, + "version": "7.3.0" + }, + "gcc_linux-64-7.3.0-h553295d_8.tar.bz2": { + "build": "h553295d_8", + "build_number": 8, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_8", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "672f96e945c9c6dbd67fc2228b6590ad", + "name": "gcc_linux-64", + "sha256": "84be5d78e389cd5614795d880ed5f0b9e0dfc27bd16f455ba835fb6fd5fa2d48", + "size": 152327, + "subdir": "linux-64", + "timestamp": 1565123442020, + "version": "7.3.0" + }, + "gcc_linux-64-7.3.0-h553295d_9.tar.bz2": { + "build": "h553295d_9", + "build_number": 9, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_9", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "BSD-3-Clause", + "md5": "5d78331272a2888ddba2b8d914e5e7fa", + "name": "gcc_linux-64", + "sha256": "97da28cb06e2b543db3839ee68752ced7ebf70860c453faf34d34f44fdb4cbd8", + "size": 25289, + "subdir": "linux-64", + "timestamp": 1576689709738, + "version": "7.3.0" + }, + "gcc_linux-64-7.5.0-h8f34230_30.tar.bz2": { + "build": "h8f34230_30", + "build_number": 30, + "depends": [ + "binutils_linux-64 2.35.1 h454624a_30", + "gcc_impl_linux-64 7.5.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "91d2e1f19998c96bd873c85a0cd81195", + "name": "gcc_linux-64", + "sha256": "c25e4d88c0d67614f8c8c4881f8b2d27771e4a1b3525bee73945f55216648f6f", + "size": 23048, + "subdir": "linux-64", + "timestamp": 1623135025610, + "version": "7.5.0" + }, + "gcc_linux-64-8.2.0-h218040c_2.tar.bz2": { + "build": "h218040c_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_2", + "gcc_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "36218ee449f4055c7ec6f11207c1ed32", + "name": "gcc_linux-64", + "sha256": "2f14986103fce734482125bef0098f6e1a248f9d01d60bb0f300943b0423d764", + "size": 9784, + "subdir": "linux-64", + "timestamp": 1534792655651, + "version": "8.2.0" + }, + "gcc_linux-64-8.2.0-h218040c_3.tar.bz2": { + "build": "h218040c_3", + "build_number": 3, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_3", + "gcc_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "25452729eeccfef1dab42729a2e83408", + "name": "gcc_linux-64", + "sha256": "db81c111083d53f89420eac537205086afbb941dd26283280e492eba4a367cfa", + "size": 10657, + "subdir": "linux-64", + "timestamp": 1546883587488, + "version": "8.2.0" + }, + "gcc_linux-64-8.4.0-he201b7d_30.tar.bz2": { + "build": "he201b7d_30", + "build_number": 30, + "depends": [ + "binutils_linux-64 2.35.1 h454624a_30", + "gcc_impl_linux-64 8.4.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "83dee78841b677f9b52f259095947052", + "name": "gcc_linux-64", + "sha256": "47d66b6c3a8a60576f96e84684f2716ac370c4ae2e65107105231e18aa8acea2", + "size": 23058, + "subdir": "linux-64", + "timestamp": 1623135558243, + "version": "8.4.0" + }, + "gcc_linux-64-9.3.0-h1ee779e_30.tar.bz2": { + "build": "h1ee779e_30", + "build_number": 30, + "depends": [ + "binutils_linux-64 2.35.1 h454624a_30", + "gcc_impl_linux-64 9.3.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "d13f54cc85d57b89d541896434935bcb", + "name": "gcc_linux-64", + "sha256": "4371c707e24140490150cb8866c0c73fd827dbef36ea50a0d584c243602e0958", + "size": 23067, + "subdir": "linux-64", + "timestamp": 1623136132366, + "version": "9.3.0" + }, + "gdal-2.2.2-py27hae9aa10_1.tar.bz2": { + "build": "py27hae9aa10_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "085934bc7f7305b8013dff8c3246a53d", + "name": "gdal", + "sha256": "64a2099c7a15b00a1276c3f3fc1678040ba41f616318c8225c30ab274e812a40", + "size": 797087, + "subdir": "linux-64", + "timestamp": 1511391229901, + "version": "2.2.2" + }, + "gdal-2.2.2-py35h40af447_1.tar.bz2": { + "build": "py35h40af447_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "65e1bf8a31ba7dff06f76855428f9459", + "name": "gdal", + "sha256": "fb5f23cde6c09c9b553a747c719c957012a8822826f0378fcf069db9d470f0a7", + "size": 792508, + "subdir": "linux-64", + "timestamp": 1511391230101, + "version": "2.2.2" + }, + "gdal-2.2.2-py36hc209d97_1.tar.bz2": { + "build": "py36hc209d97_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d1167f8e8016b6d5656f9f76021dc1a0", + "name": "gdal", + "sha256": "da827b93ef518719c573c451e6a2a3f0cd21ff91900de7dc26cc89baab5fc549", + "size": 785008, + "subdir": "linux-64", + "timestamp": 1511391229950, + "version": "2.2.2" + }, + "gdal-2.2.4-py27h04863e7_1.tar.bz2": { + "build": "py27h04863e7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal 2.2.4 heea9cce_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "593de488cba7f6e8e91f50e781c19afd", + "name": "gdal", + "sha256": "1864c7d0339ec6c4647a6135564679542f7d71114adb5701c32f684624caa62d", + "size": 1141668, + "subdir": "linux-64", + "timestamp": 1530871220701, + "version": "2.2.4" + }, + "gdal-2.2.4-py27h637b7d7_1.tar.bz2": { + "build": "py27h637b7d7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal 2.2.4 hc8d23f9_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "54eafedbf7d96cb5213906319fc2b343", + "name": "gdal", + "sha256": "8f01bdc55e6864691ecbbab219c5aab2b8ae26aeda7ae40395a209f144ab4a6c", + "size": 1178151, + "subdir": "linux-64", + "timestamp": 1527912911342, + "version": "2.2.4" + }, + "gdal-2.2.4-py35h637b7d7_1.tar.bz2": { + "build": "py35h637b7d7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal 2.2.4 hc8d23f9_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "8fe06df71a910904f04db60c96f43d9a", + "name": "gdal", + "sha256": "ec41a1e81bc1a5594ae6a745bfaca154160bb0bef4d50e3297738d88a9964091", + "size": 1181272, + "subdir": "linux-64", + "timestamp": 1527912720081, + "version": "2.2.4" + }, + "gdal-2.2.4-py36h04863e7_1.tar.bz2": { + "build": "py36h04863e7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal 2.2.4 heea9cce_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9bcae905c7c141aa0f5e3ad6995e4d19", + "name": "gdal", + "sha256": "e3a705d451c0a3629db183a0487511c48ce93383daf60ae331f17eeac5c9b01c", + "size": 1155545, + "subdir": "linux-64", + "timestamp": 1530871366684, + "version": "2.2.4" + }, + "gdal-2.2.4-py36h637b7d7_1.tar.bz2": { + "build": "py36h637b7d7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal 2.2.4 hc8d23f9_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ed92b7272c5e6597c74f78e3d63d3938", + "name": "gdal", + "sha256": "a94d82d9a7bfe6ba829f6b09ecf4af95676e1ec3bc33ef2f8bb6cc79684c2013", + "size": 1178632, + "subdir": "linux-64", + "timestamp": 1527913103357, + "version": "2.2.4" + }, + "gdal-2.2.4-py37h04863e7_1.tar.bz2": { + "build": "py37h04863e7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal 2.2.4 heea9cce_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "0c4efe839cfa5822c2f5962790b3fe61", + "name": "gdal", + "sha256": "df34c6a3b54b39aef33ce64c5dbd9f556d90bd764a140f9af2e52c09b0ad11e7", + "size": 1155500, + "subdir": "linux-64", + "timestamp": 1530871294536, + "version": "2.2.4" + }, + "gdal-2.3.0-py27h04863e7_1.tar.bz2": { + "build": "py27h04863e7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal 2.3.0 heea9cce_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "323c480160e68e4fad4642c90bf20a7d", + "name": "gdal", + "sha256": "6960ea40b27edc63a00952007076e4ab7ebf3a37450549328b6730ac1c0c5892", + "size": 1170791, + "subdir": "linux-64", + "timestamp": 1530869627399, + "version": "2.3.0" + }, + "gdal-2.3.0-py36h04863e7_1.tar.bz2": { + "build": "py36h04863e7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal 2.3.0 heea9cce_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1c2cccd87658a9126b73bd43009c59de", + "name": "gdal", + "sha256": "6dfff34ecb22e9809115f3ccc9e888122d7541096e75e246ea9fc00714d12a9d", + "size": 1170605, + "subdir": "linux-64", + "timestamp": 1530869777171, + "version": "2.3.0" + }, + "gdal-2.3.0-py37h04863e7_1.tar.bz2": { + "build": "py37h04863e7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal 2.3.0 heea9cce_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "fcfed845bef0857aa2d506730c0c553d", + "name": "gdal", + "sha256": "75c51eb98272d92a9e6f127ef0a5e386db6c09a5d5197596a67e645887d16d55", + "size": 1171107, + "subdir": "linux-64", + "timestamp": 1530869702090, + "version": "2.3.0" + }, + "gdal-2.3.2-py27h2924dbc_0.tar.bz2": { + "build": "py27h2924dbc_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.2 h9d4a965_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "260d74de97263261d061ec9c67ee2ee8", + "name": "gdal", + "sha256": "045ab68934374d557b7131f438e361a89c1fc492c1985c6f5d3b40bcba0a8e43", + "size": 1274855, + "subdir": "linux-64", + "timestamp": 1544656089046, + "version": "2.3.2" + }, + "gdal-2.3.2-py27hfcb4a02_0.tar.bz2": { + "build": "py27hfcb4a02_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.2 hda2fc8e_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c4f3660efc0effa19e981be14e7e87fa", + "name": "gdal", + "sha256": "27702e28df0e975bbf3085645fb9d8e44541ee4425a7cdf8c208d7a8c7bf5760", + "size": 1285235, + "subdir": "linux-64", + "timestamp": 1544661955845, + "version": "2.3.2" + }, + "gdal-2.3.2-py36h2924dbc_0.tar.bz2": { + "build": "py36h2924dbc_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.2 h9d4a965_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e68439d29fb100e380012dd05d188b19", + "name": "gdal", + "sha256": "a6817c879e427b7655295d976d758a567024b006797dce8d0203b42cdbb7726b", + "size": 1333453, + "subdir": "linux-64", + "timestamp": 1544655998650, + "version": "2.3.2" + }, + "gdal-2.3.2-py36hfcb4a02_0.tar.bz2": { + "build": "py36hfcb4a02_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.2 hda2fc8e_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "859d54622486c0227ec569a14f997e49", + "name": "gdal", + "sha256": "2a9cbec5c4d96b097035246371a9ae5ec74809bdace6a45f1dda095906171199", + "size": 1404687, + "subdir": "linux-64", + "timestamp": 1544661868557, + "version": "2.3.2" + }, + "gdal-2.3.2-py37h2924dbc_0.tar.bz2": { + "build": "py37h2924dbc_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.2 h9d4a965_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c2e9692c1e0b41b471ada81c1628f49e", + "name": "gdal", + "sha256": "719a2d701af267ef9800623d8a53ac6389c041d8dfb8df90a8064b4bb99779e8", + "size": 1333909, + "subdir": "linux-64", + "timestamp": 1544656185654, + "version": "2.3.2" + }, + "gdal-2.3.2-py37hfcb4a02_0.tar.bz2": { + "build": "py37hfcb4a02_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.2 hda2fc8e_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8fa86ed6d42cb901e6a44bcb26117105", + "name": "gdal", + "sha256": "4dbd42229a01b2b5bb38d1c08d9938c495a0458fe175085cdf017e7062935054", + "size": 1397208, + "subdir": "linux-64", + "timestamp": 1544661776846, + "version": "2.3.2" + }, + "gdal-2.3.3-py27hbb2a789_0.tar.bz2": { + "build": "py27hbb2a789_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.3 h2e7e64b_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "60b9dcd3d0607ca65a1c4db83a496b44", + "name": "gdal", + "sha256": "8a04af8f7a2389feb4fb2f3cd0d6afb9bf6c4e9f99002cd5ddce0c1b2d713d07", + "size": 1330850, + "subdir": "linux-64", + "timestamp": 1545408767024, + "version": "2.3.3" + }, + "gdal-2.3.3-py36hbb2a789_0.tar.bz2": { + "build": "py36hbb2a789_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.3 h2e7e64b_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a7de8cbde5e89f098d1d4e77b87c0e23", + "name": "gdal", + "sha256": "03a644d9bef05466484817f7d6dd2312ec5373e7f487a2d8afe3e079fb0bcc73", + "size": 1330475, + "subdir": "linux-64", + "timestamp": 1545408875430, + "version": "2.3.3" + }, + "gdal-2.3.3-py37hbb2a789_0.tar.bz2": { + "build": "py37hbb2a789_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.3 h2e7e64b_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5fe83ce6b52cca6d3385e9b53867f354", + "name": "gdal", + "sha256": "6c65b30ad3da98d004ecaea0f151ae51693d12451c505e51769043236fbc7e0d", + "size": 1330990, + "subdir": "linux-64", + "timestamp": 1545408652901, + "version": "2.3.3" + }, + "gdal-2.3.3-py38hbb2a789_0.tar.bz2": { + "build": "py38hbb2a789_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.3 h2e7e64b_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "04edb6e7e2226c0c4bbfac56e9d93641", + "name": "gdal", + "sha256": "a174bf708199242feafd81ee0fecca3825227e7e051e57c8efa35c4f949581cf", + "size": 1298116, + "subdir": "linux-64", + "timestamp": 1573739716408, + "version": "2.3.3" + }, + "gdal-3.0.2-py27hbb2a789_0.tar.bz2": { + "build": "py27hbb2a789_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 3.0.2 h27ab9cc_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d93b9e6a52e14f6406371084df30f789", + "name": "gdal", + "sha256": "6b83562d688c35a5f2a0ffe0d2b6360cbe8480a3d2307433c26353318532d4d0", + "size": 1336776, + "subdir": "linux-64", + "timestamp": 1573574897764, + "version": "3.0.2" + }, + "gdal-3.0.2-py310h3fbc5c2_3.tar.bz2": { + "build": "py310h3fbc5c2_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 h1d2d1f6_3", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9bc3e7352578472dbb02f8f3053b088", + "name": "gdal", + "sha256": "a5fffc2421bf41285f3b5a4390d87e90314684a45e28849187f39b298f205836", + "size": 3209168, + "subdir": "linux-64", + "timestamp": 1657806816850, + "version": "3.0.2" + }, + "gdal-3.0.2-py310h3fbc5c2_5.tar.bz2": { + "build": "py310h3fbc5c2_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 hf71aff0_5", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "75bb99c0b29cb7bdbae21581db263657", + "name": "gdal", + "sha256": "2a8da4da31c11bc41622fd89eaaf68a9d92c56923890a8976e667bcab9483217", + "size": 1576648, + "subdir": "linux-64", + "timestamp": 1673971922288, + "version": "3.0.2" + }, + "gdal-3.0.2-py310h3fbc5c2_6.tar.bz2": { + "build": "py310h3fbc5c2_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 hf71aff0_6", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a62fe432f2d40c8ebcb668a06a729c9e", + "name": "gdal", + "sha256": "2cd8c4275cd5f25287edf9c8580ade02cad4d1a967cd5280c3da1fd939482aa8", + "size": 1581116, + "subdir": "linux-64", + "timestamp": 1673992532364, + "version": "3.0.2" + }, + "gdal-3.0.2-py310h8f0303e_0.tar.bz2": { + "build": "py310h8f0303e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libgdal 3.0.2 h20ab51d_0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "c1ac208de49e7e9a627eb20239df093c", + "name": "gdal", + "sha256": "bc840df8cac09bc615961b81d14de751474d23c5d69b92d37f1cd9395f53eb77", + "size": 2979280, + "subdir": "linux-64", + "timestamp": 1641553338209, + "version": "3.0.2" + }, + "gdal-3.0.2-py36h4694593_1.tar.bz2": { + "build": "py36h4694593_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 3.0.2 h7c14f60_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4188818b8a2911edc8db375c57625cc5", + "name": "gdal", + "sha256": "868cbe8445c4966cc8aaa9f3eb9bd8e8b025e5703d6281e5b459542602813e55", + "size": 1574940, + "subdir": "linux-64", + "timestamp": 1622392924465, + "version": "3.0.2" + }, + "gdal-3.0.2-py36hbb2a789_0.tar.bz2": { + "build": "py36hbb2a789_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 3.0.2 h27ab9cc_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "792f54ce810e4d61fa80fa9c2992ca4a", + "name": "gdal", + "sha256": "a404d00098089e70c6cc470bf1beb6e91354a834cdb16e52bc2ad7a68019d9eb", + "size": 1354375, + "subdir": "linux-64", + "timestamp": 1573574560931, + "version": "3.0.2" + }, + "gdal-3.0.2-py37h2c27f0e_2.tar.bz2": { + "build": "py37h2c27f0e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libgdal 3.0.2 he6cead7_2", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "22345f98053267e0ba869f491e6c205a", + "name": "gdal", + "sha256": "8b73fd2cc456a2958f72bbf149af4f97c38b066e0047b9cb6f51e78eac0f9357", + "size": 1357666, + "subdir": "linux-64", + "timestamp": 1643382774337, + "version": "3.0.2" + }, + "gdal-3.0.2-py37h40f10ac_3.tar.bz2": { + "build": "py37h40f10ac_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 h1d2d1f6_3", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fff64cdc85ada89f571a90c043e6b02a", + "name": "gdal", + "sha256": "54c856f72a0035c815694a5311b10264d9cd60eb33aaaa2b0e5c498f7202774b", + "size": 1654469, + "subdir": "linux-64", + "timestamp": 1657806692732, + "version": "3.0.2" + }, + "gdal-3.0.2-py37h40f10ac_5.tar.bz2": { + "build": "py37h40f10ac_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 hf71aff0_5", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "487007b063da282d57c982a139bfb2d4", + "name": "gdal", + "sha256": "ca694b7e06af6f8123224faaad70a365edc699fe526b12449f40abce5d385ef7", + "size": 1565183, + "subdir": "linux-64", + "timestamp": 1673972073435, + "version": "3.0.2" + }, + "gdal-3.0.2-py37h40f10ac_6.tar.bz2": { + "build": "py37h40f10ac_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 hf71aff0_6", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "553621910b83acac52ef09467cd230d4", + "name": "gdal", + "sha256": "920258ce607d75450bc14528bf7718ca9cb18f55aaefc2dc855d13fabf654360", + "size": 1568282, + "subdir": "linux-64", + "timestamp": 1673992632747, + "version": "3.0.2" + }, + "gdal-3.0.2-py37h4694593_1.tar.bz2": { + "build": "py37h4694593_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 3.0.2 h7c14f60_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4f65598a8b41fd722b1c2df5cc8ccab7", + "name": "gdal", + "sha256": "103c92f69eb75500fb683102d87c4fc145d4918643dd4b1881f72939f3127b95", + "size": 1568449, + "subdir": "linux-64", + "timestamp": 1622393146434, + "version": "3.0.2" + }, + "gdal-3.0.2-py37hbb2a789_0.tar.bz2": { + "build": "py37hbb2a789_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 3.0.2 h27ab9cc_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "313319ff33086dbb346c9c72cb5de60d", + "name": "gdal", + "sha256": "f6c80e73166b27c9864ce9097301d452b19a0b8cbaae48565cd2cfd3a10f12fc", + "size": 1353628, + "subdir": "linux-64", + "timestamp": 1573574803369, + "version": "3.0.2" + }, + "gdal-3.0.2-py38h2c27f0e_2.tar.bz2": { + "build": "py38h2c27f0e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libgdal 3.0.2 he6cead7_2", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "7a75f579140e4a48c5cb9c3a5cf8d676", + "name": "gdal", + "sha256": "bf22b18cdf698cefec0d85f6b3f5177c949054b56e30acfd5692bd6aaf0ce63f", + "size": 1367460, + "subdir": "linux-64", + "timestamp": 1643382663578, + "version": "3.0.2" + }, + "gdal-3.0.2-py38h40f10ac_3.tar.bz2": { + "build": "py38h40f10ac_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 h1d2d1f6_3", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbb63bf37ae969bea627c8d36ef7edba", + "name": "gdal", + "sha256": "33386b3ecc0c8cfbd0ab8c1ad091b7eeaf4cb79e521fb9b1661dc7e4c4141aee", + "size": 1660342, + "subdir": "linux-64", + "timestamp": 1657806876333, + "version": "3.0.2" + }, + "gdal-3.0.2-py38h40f10ac_5.tar.bz2": { + "build": "py38h40f10ac_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 hf71aff0_5", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95e07aad405010077fe9d5a5181297b6", + "name": "gdal", + "sha256": "407fad0e996e994c80ca711dc3e3850ea271bd4a3622dc74b986633864bcec13", + "size": 1576144, + "subdir": "linux-64", + "timestamp": 1673971972406, + "version": "3.0.2" + }, + "gdal-3.0.2-py38h40f10ac_6.tar.bz2": { + "build": "py38h40f10ac_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 hf71aff0_6", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd07b90649316713a06ed17efb2e90ad", + "name": "gdal", + "sha256": "60919dfabc51a99fc7745f63765e6334e7a519330b751a03f922f1f8a8301e0e", + "size": 1579173, + "subdir": "linux-64", + "timestamp": 1673992682520, + "version": "3.0.2" + }, + "gdal-3.0.2-py38h4694593_1.tar.bz2": { + "build": "py38h4694593_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 3.0.2 h7c14f60_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "a89accddf42350a55beeebea203a346b", + "name": "gdal", + "sha256": "7f29baeccaf4e4a0af2abbabda4c677eba6e5be67491fac460c8e39c9e041ffa", + "size": 1582765, + "subdir": "linux-64", + "timestamp": 1622392998045, + "version": "3.0.2" + }, + "gdal-3.0.2-py38hbb2a789_0.tar.bz2": { + "build": "py38hbb2a789_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 3.0.2 h27ab9cc_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "a0fa67749835818b067eeb6c2602d66d", + "name": "gdal", + "sha256": "f9f34b5bb1902c65ec0e6948fc0ddf3d87df1b22151eec7d8917dce90b39d18f", + "size": 1369572, + "subdir": "linux-64", + "timestamp": 1573574659895, + "version": "3.0.2" + }, + "gdal-3.0.2-py39h2c27f0e_2.tar.bz2": { + "build": "py39h2c27f0e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libgdal 3.0.2 he6cead7_2", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "42b7b906e9082e46298793d2d9dec80a", + "name": "gdal", + "sha256": "f25651e97ea5ae2d9cbbbe0095c277d2b8234919cd438c0d0fe3138388223a63", + "size": 1376238, + "subdir": "linux-64", + "timestamp": 1643382722488, + "version": "3.0.2" + }, + "gdal-3.0.2-py39h40f10ac_3.tar.bz2": { + "build": "py39h40f10ac_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 h1d2d1f6_3", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8005f65c8d2108d09f6b40ae0ba0da0c", + "name": "gdal", + "sha256": "e03a93fbdf9ea7ad331c0706b08b69b7fc6ad05911d70d52b93f476153b98505", + "size": 1662270, + "subdir": "linux-64", + "timestamp": 1657806751401, + "version": "3.0.2" + }, + "gdal-3.0.2-py39h40f10ac_5.tar.bz2": { + "build": "py39h40f10ac_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 hf71aff0_5", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c9f0cf02f23610d39408ef369458f381", + "name": "gdal", + "sha256": "fc778d5c89ffae10e948104046b371119f40d8fa16914f8a2817a70ebf59f2c0", + "size": 1574855, + "subdir": "linux-64", + "timestamp": 1673972023589, + "version": "3.0.2" + }, + "gdal-3.0.2-py39h40f10ac_6.tar.bz2": { + "build": "py39h40f10ac_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 hf71aff0_6", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "89b8cf07c2ba60c02310e473575c1383", + "name": "gdal", + "sha256": "9f4650820d30de316aaacf3b0478ce360917a2b3412fd0c8f55eba32e495070e", + "size": 1578519, + "subdir": "linux-64", + "timestamp": 1673992582452, + "version": "3.0.2" + }, + "gdal-3.0.2-py39h4694593_1.tar.bz2": { + "build": "py39h4694593_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 3.0.2 h7c14f60_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "e37add94f350b7ce5b513aad256dfb76", + "name": "gdal", + "sha256": "d2f984f5fdfa373f2ae1c7a8353aeea8381aacd0f564aff0af6fca06c953e721", + "size": 1579001, + "subdir": "linux-64", + "timestamp": 1622393072557, + "version": "3.0.2" + }, + "gdal-3.4.1-py310h8f0303e_0.tar.bz2": { + "build": "py310h8f0303e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libgdal 3.4.1.*", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "8cb06c337e1de5e78827c808c3929623", + "name": "gdal", + "sha256": "e1330b23a186212f2dd7defca64671114b75979cb373dbf76d927f909dcd9536", + "size": 3567825, + "subdir": "linux-64", + "timestamp": 1647030727174, + "version": "3.4.1" + }, + "gdal-3.4.1-py311hcb128cc_0.tar.bz2": { + "build": "py311hcb128cc_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.4.1.*", + "libgdal >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "d4c484e78d2838dd5eb1cbd32df83fd9", + "name": "gdal", + "sha256": "c01cd4f59ea7d49fdc2496963483a03594fc1be9ab818362ba20a8fb8ab416ac", + "size": 2122904, + "subdir": "linux-64", + "timestamp": 1676844084923, + "version": "3.4.1" + }, + "gdal-3.4.1-py37h2c27f0e_0.tar.bz2": { + "build": "py37h2c27f0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libgdal 3.4.1.*", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b7c0ada4da6bb18b8378291d70c63f08", + "name": "gdal", + "sha256": "1d4a0706b8a3c44f1a31dc2207e146a47722f3ed44558cf0ba908df60da32df6", + "size": 1682215, + "subdir": "linux-64", + "timestamp": 1643825184861, + "version": "3.4.1" + }, + "gdal-3.4.1-py38h2c27f0e_0.tar.bz2": { + "build": "py38h2c27f0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libgdal 3.4.1.*", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "8f8fb32f8f3271d1f0adf17c9610b6fe", + "name": "gdal", + "sha256": "5fa5b2390ebda080fd6293f365eb97ce817e33c1217eb2f521cabb26b83582c5", + "size": 1693077, + "subdir": "linux-64", + "timestamp": 1643825115278, + "version": "3.4.1" + }, + "gdal-3.4.1-py39h2c27f0e_0.tar.bz2": { + "build": "py39h2c27f0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libgdal 3.4.1.*", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "ff82c40a76d3f86bda1a710d102f3a0f", + "name": "gdal", + "sha256": "343b8a30ea59252899cca0666f600851d7efebf184f82e714aeae17c7d2f588a", + "size": 1691693, + "subdir": "linux-64", + "timestamp": 1643825259668, + "version": "3.4.1" + }, + "gdal-3.6.0-py310h708d02d_0.tar.bz2": { + "build": "py310h708d02d_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.0 hc0e11bb_0", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.21.5,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9399d9d4d4e5378ed605d2a9a16fb6c9", + "name": "gdal", + "sha256": "0662cbcaa5cf9d5630169d10651589a98cb616dd2390f30b962c0f66481538c1", + "size": 1980999, + "subdir": "linux-64", + "timestamp": 1676727194678, + "version": "3.6.0" + }, + "gdal-3.6.0-py310h708d02d_1.tar.bz2": { + "build": "py310h708d02d_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.0 hc0e11bb_1", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.21.5,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52eb857d62b614fad228ef246dc4b133", + "name": "gdal", + "sha256": "0c06e8a2eb674bbe7d4c1e638e38164966297025829c53fd9c0151e0800d1e01", + "size": 1980169, + "subdir": "linux-64", + "timestamp": 1677574455706, + "version": "3.6.0" + }, + "gdal-3.6.0-py311h89ef87f_0.tar.bz2": { + "build": "py311h89ef87f_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.0 hc0e11bb_0", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.22.3,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a4c92492a5918573a9870e3a58e0eea8", + "name": "gdal", + "sha256": "9e361b9a1a48dadf5eb747bceebd196f367fd6144eb920cc6093cd7585d5f048", + "size": 2168344, + "subdir": "linux-64", + "timestamp": 1676920028162, + "version": "3.6.0" + }, + "gdal-3.6.0-py37hf9a8271_0.tar.bz2": { + "build": "py37hf9a8271_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.0 hc0e11bb_0", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d5aad18040c789d288817f83da4a71d", + "name": "gdal", + "sha256": "85d31fdbf4e728d964aa892bad84c5e02f6480191f28028beb1a800f67d40e90", + "size": 1956426, + "subdir": "linux-64", + "timestamp": 1676727291992, + "version": "3.6.0" + }, + "gdal-3.6.0-py37hf9a8271_1.tar.bz2": { + "build": "py37hf9a8271_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.0 hc0e11bb_1", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "25403c5b0e2c1e172eecf36ae2e69f8d", + "name": "gdal", + "sha256": "d0f9250b649884a5c7ffb7971f22ab2676ad2e6d951a3d88e2b0eb9881771e9f", + "size": 1954155, + "subdir": "linux-64", + "timestamp": 1677574500832, + "version": "3.6.0" + }, + "gdal-3.6.0-py38hf9a8271_0.tar.bz2": { + "build": "py38hf9a8271_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.0 hc0e11bb_0", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c58d76194eaddca91b685c1074d1db7", + "name": "gdal", + "sha256": "0ee7a276ba6e624852517c2b0165650c18753e39144183829fee4bf823242520", + "size": 1968213, + "subdir": "linux-64", + "timestamp": 1676727341107, + "version": "3.6.0" + }, + "gdal-3.6.0-py38hf9a8271_1.tar.bz2": { + "build": "py38hf9a8271_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.0 hc0e11bb_1", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2166d7a8278f29812e84d0231d8ac504", + "name": "gdal", + "sha256": "571547fa3f04c7ef5d16d7ce86235c2ed2ab3137caeed1b037cd561d9f23af8b", + "size": 1965202, + "subdir": "linux-64", + "timestamp": 1677574547808, + "version": "3.6.0" + }, + "gdal-3.6.0-py39hf9a8271_0.tar.bz2": { + "build": "py39hf9a8271_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.0 hc0e11bb_0", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e72f732a9d7ca3d5dd327727bb73a88", + "name": "gdal", + "sha256": "fa311b5d3bdeb2bc2037fab6b2758295689cd02cd2980139a2c4bdb89543097c", + "size": 1975413, + "subdir": "linux-64", + "timestamp": 1676727242468, + "version": "3.6.0" + }, + "gdal-3.6.0-py39hf9a8271_1.tar.bz2": { + "build": "py39hf9a8271_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.0 hc0e11bb_1", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6edac0580ecc67bf6612ed7972379c90", + "name": "gdal", + "sha256": "e6b166de8ecc60bb570a5f7fab7c26fcf12b65e7b2b82e7e3f2f386624b478c2", + "size": 1971281, + "subdir": "linux-64", + "timestamp": 1677574408039, + "version": "3.6.0" + }, + "gdal-3.6.2-py310h65ec567_1.tar.bz2": { + "build": "py310h65ec567_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.2 hc0e11bb_1", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "numpy >=1.21.5,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b14e444e80850865550df3d2f47b8aeb", + "name": "gdal", + "sha256": "582a236ff80082fbc1f35822ad74eb3bdca5a98d0b40a86f2c1f7f2f87358b87", + "size": 1985675, + "subdir": "linux-64", + "timestamp": 1680121180989, + "version": "3.6.2" + }, + "gdal-3.6.2-py310h708d02d_0.tar.bz2": { + "build": "py310h708d02d_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.2 hc0e11bb_0", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.21.5,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c513635a928c38092c16614266c60c5", + "name": "gdal", + "sha256": "26c7454267942ea0e0533f922da79f874a13dee8d6d9de648c2e01c076b60b81", + "size": 1971852, + "subdir": "linux-64", + "timestamp": 1678138704653, + "version": "3.6.2" + }, + "gdal-3.6.2-py311h4618797_1.tar.bz2": { + "build": "py311h4618797_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.2 hc0e11bb_1", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "numpy >=1.23.5,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2996be70507164c02a4d6d4580d7f2e5", + "name": "gdal", + "sha256": "47912e160fe0940bda05d7fb7e9bc9b945b740a4f19e7aebcec7c8b66f30861a", + "size": 2159845, + "subdir": "linux-64", + "timestamp": 1680121090296, + "version": "3.6.2" + }, + "gdal-3.6.2-py311h89ef87f_0.tar.bz2": { + "build": "py311h89ef87f_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.2 hc0e11bb_0", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.22.3,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a60dde410b9253403466b9f84d36142", + "name": "gdal", + "sha256": "fda60388b912804ebd3bdaf8a9e64f44007d74fdde082e9d7be8075e4d05c95c", + "size": 2149399, + "subdir": "linux-64", + "timestamp": 1678242957630, + "version": "3.6.2" + }, + "gdal-3.6.2-py38h2fd6ed0_1.tar.bz2": { + "build": "py38h2fd6ed0_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.2 hc0e11bb_1", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d78fdc794271a6b0c3423849cf04dc72", + "name": "gdal", + "sha256": "1bb3e4334813bbe3539eea041d3c5da6220b7f223b9d618791c273df05277983", + "size": 1974686, + "subdir": "linux-64", + "timestamp": 1680121135682, + "version": "3.6.2" + }, + "gdal-3.6.2-py38hf9a8271_0.tar.bz2": { + "build": "py38hf9a8271_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.2 hc0e11bb_0", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c4d078b4f157c81a3a8c99c27b41012", + "name": "gdal", + "sha256": "51846d5e1fc4c7145adf9abaadd22ff702dc87e0a23dd8785e18a0ce55e10380", + "size": 1962342, + "subdir": "linux-64", + "timestamp": 1678138750891, + "version": "3.6.2" + }, + "gdal-3.6.2-py39h2fd6ed0_1.tar.bz2": { + "build": "py39h2fd6ed0_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.2 hc0e11bb_1", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2033ee31e98c86a448293e33b48c8383", + "name": "gdal", + "sha256": "5dd9989a220d8524d3218a076221bfcc848491ca4e7c667377269a3d925fb7e5", + "size": 1979552, + "subdir": "linux-64", + "timestamp": 1680121226484, + "version": "3.6.2" + }, + "gdal-3.6.2-py39hf9a8271_0.tar.bz2": { + "build": "py39hf9a8271_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.2 hc0e11bb_0", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5057ae18e9720ae960357e543b7d4ece", + "name": "gdal", + "sha256": "04f5796ac39bdf1c5d34a736ba904c3c4d4194cd47a61233692f334c9db8de02", + "size": 1964866, + "subdir": "linux-64", + "timestamp": 1678138795746, + "version": "3.6.2" + }, + "gdata-2.0.18-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "e88a15562b09bc3fe6e30dac90e9fc33", + "name": "gdata", + "sha256": "5bec9e5bf25610b426cadc09f6cbe75d5112a57d136903a91cd8561e4c9d98c6", + "size": 945563, + "subdir": "linux-64", + "timestamp": 1541010065333, + "version": "2.0.18" + }, + "gdb-11.2-py310he3c4487_2.tar.bz2": { + "build": "py310he3c4487_2", + "build_number": 2, + "depends": [ + "libgcc-ng", + "libstdcxx-ng", + "ncurses", + "pygments", + "python >=3.10,<3.11.0a0", + "six", + "xz" + ], + "license": "GPL", + "md5": "1429ad5b700d7fa1e83bbde9b5e34b22", + "name": "gdb", + "sha256": "2b18755eee14f096498482fe6a7e8c4559d9a1a28ea6dfe3f1672ec83ebb2ab4", + "size": 6984418, + "subdir": "linux-64", + "timestamp": 1654065060940, + "version": "11.2" + }, + "gdb-11.2-py311he3c4487_2.tar.bz2": { + "build": "py311he3c4487_2", + "build_number": 2, + "depends": [ + "libgcc-ng", + "libstdcxx-ng", + "ncurses", + "pygments", + "python >=3.11,<3.12.0a0", + "six", + "xz" + ], + "license": "GPL", + "md5": "57a42fe371df5b510e0499e5e80cb01f", + "name": "gdb", + "sha256": "c87e1ac36b6f62e42822e7b3185d55b20d36dab5a66e44ae224f3fd6bc7a0394", + "size": 6862417, + "subdir": "linux-64", + "timestamp": 1676921908353, + "version": "11.2" + }, + "gdb-11.2-py37he3c4487_2.tar.bz2": { + "build": "py37he3c4487_2", + "build_number": 2, + "depends": [ + "libgcc-ng", + "libstdcxx-ng", + "ncurses", + "pygments", + "python >=3.7,<3.8.0a0", + "six", + "xz" + ], + "license": "GPL", + "md5": "2a2d4d0660e6c7c18fcaecc45645cd28", + "name": "gdb", + "sha256": "0821fff06a1a4e3519e80ea820554ad1ad67dce94855aa75c4f32132870706dc", + "size": 6990579, + "subdir": "linux-64", + "timestamp": 1654066414973, + "version": "11.2" + }, + "gdb-11.2-py38he3c4487_2.tar.bz2": { + "build": "py38he3c4487_2", + "build_number": 2, + "depends": [ + "libgcc-ng", + "libstdcxx-ng", + "ncurses", + "pygments", + "python >=3.8,<3.9.0a0", + "six", + "xz" + ], + "license": "GPL", + "md5": "c45ca082d2746684c7964a73abd5c530", + "name": "gdb", + "sha256": "1d8ba61bc86b416d7277b0d08a45cbfcf127ed0927e7d9fba30c4519d1be39ba", + "size": 6993338, + "subdir": "linux-64", + "timestamp": 1654063656583, + "version": "11.2" + }, + "gdb-11.2-py39he3c4487_2.tar.bz2": { + "build": "py39he3c4487_2", + "build_number": 2, + "depends": [ + "libgcc-ng", + "libstdcxx-ng", + "ncurses", + "pygments", + "python >=3.9,<3.10.0a0", + "six", + "xz" + ], + "license": "GPL", + "md5": "95c93c947967ada4aa4d132475d240a5", + "name": "gdb", + "sha256": "c808ffd17b8d2ef02e50341e1d744a09cd9ba21469e53f3a19b58df77f2670fe", + "size": 6990870, + "subdir": "linux-64", + "timestamp": 1654067818897, + "version": "11.2" + }, + "gdb-pretty-printer-11.2.0-py310hcff718f_2.tar.bz2": { + "build": "py310hcff718f_2", + "build_number": 2, + "depends": [ + "gdb >=11.2", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "a04c56a39d0d5f851b06dca11d4d4b48", + "name": "gdb-pretty-printer", + "sha256": "3e9ddc1a564e8e64fb3156c5d000a8df212beed94e55dfa45e8fb72ed4a374a4", + "size": 64540, + "subdir": "linux-64", + "timestamp": 1654065074087, + "version": "11.2.0" + }, + "gdb-pretty-printer-11.2.0-py311hcff718f_2.tar.bz2": { + "build": "py311hcff718f_2", + "build_number": 2, + "depends": [ + "gdb >=11.2", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "e3608baa6bb13f88c3ce7d244aab9e42", + "name": "gdb-pretty-printer", + "sha256": "155abab3ebc931c12c0482637da7aece31279230965f8cf95251732cd1c751b9", + "size": 87202, + "subdir": "linux-64", + "timestamp": 1676921920641, + "version": "11.2.0" + }, + "gdb-pretty-printer-11.2.0-py37hcff718f_2.tar.bz2": { + "build": "py37hcff718f_2", + "build_number": 2, + "depends": [ + "gdb >=11.2", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "ef97e3cf72a93b2c0b0fb479c5654929", + "name": "gdb-pretty-printer", + "sha256": "7f033ac6471e8dc122c043db49ce905183512440c29cce021d37cd8d2d111d9a", + "size": 63858, + "subdir": "linux-64", + "timestamp": 1654066428076, + "version": "11.2.0" + }, + "gdb-pretty-printer-11.2.0-py38hcff718f_2.tar.bz2": { + "build": "py38hcff718f_2", + "build_number": 2, + "depends": [ + "gdb >=11.2", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "f54986b5fabef68d9f753ecdc9414e85", + "name": "gdb-pretty-printer", + "sha256": "dfc8ec6c7415a7630894aa9c0fd362980455bb9ce564594cdb9cc4dd9db8d86e", + "size": 64133, + "subdir": "linux-64", + "timestamp": 1654063669693, + "version": "11.2.0" + }, + "gdb-pretty-printer-11.2.0-py39hcff718f_2.tar.bz2": { + "build": "py39hcff718f_2", + "build_number": 2, + "depends": [ + "gdb >=11.2", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "1e5a1adfe0e0f8872557daa997797390", + "name": "gdb-pretty-printer", + "sha256": "e840ecdd9bec31e39fed45d13f9043191d2512f9808d542ac12b3993e7f9ca04", + "size": 64093, + "subdir": "linux-64", + "timestamp": 1654067832410, + "version": "11.2.0" + }, + "gdb_linux-64-11.2-h1234567_0.tar.bz2": { + "build": "h1234567_0", + "build_number": 0, + "depends": [], + "license": "GPL", + "md5": "fefa7000b20d6e4d493762269d5dedd8", + "name": "gdb_linux-64", + "sha256": "2966d2e701f2361797e8c2af62add16cad2c9ca54a93c0da7790ad7046e14810", + "size": 5320109, + "subdir": "linux-64", + "timestamp": 1652859654120, + "version": "11.2" + }, + "gdb_linux-64-11.2-h1234567_1.tar.bz2": { + "build": "h1234567_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "05919ef4f8f4f6481017efb8f2e6146c", + "name": "gdb_linux-64", + "sha256": "3ba40d0fb33872b5db4a24347e18b803b17c7bfa049e89b3e939674c49d58dfe", + "size": 5351988, + "subdir": "linux-64", + "timestamp": 1654090737336, + "version": "11.2" + }, + "gdb_linux-64-7.12.1-h0d70bb3_3.tar.bz2": { + "build": "h0d70bb3_3", + "build_number": 3, + "depends": [], + "license": "GPL", + "md5": "cb7b8467c244d8934d74c9d96098622f", + "name": "gdb_linux-64", + "sha256": "b1956dea34747099325f4b2237441083db311acd2b628f235010698260fc7cf7", + "size": 2903806, + "subdir": "linux-64", + "timestamp": 1520534499595, + "version": "7.12.1" + }, + "gdb_linux-64-7.12.1-hd7315ee_1.tar.bz2": { + "build": "hd7315ee_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "a623ae0b2b6a993e83e89cf411307f92", + "name": "gdb_linux-64", + "sha256": "e70e9d659eb6e1e0d133f6c910ec38100f04044f685a3e83467ed85540ef0ecb", + "size": 2898328, + "subdir": "linux-64", + "timestamp": 1505665557371, + "version": "7.12.1" + }, + "gdb_linux-64-7.12.1-hf9d566d_2.tar.bz2": { + "build": "hf9d566d_2", + "build_number": 2, + "depends": [], + "license": "GPL", + "md5": "8c759745f27e8e86c49a41bbc7757422", + "name": "gdb_linux-64", + "sha256": "4479aa75047747278613d72e2ce7958dccae4174ca04bc6642c121d69563b99b", + "size": 2899626, + "subdir": "linux-64", + "timestamp": 1507262711202, + "version": "7.12.1" + }, + "gdb_server_linux-64-11.2-h1234567_0.tar.bz2": { + "build": "h1234567_0", + "build_number": 0, + "depends": [], + "license": "GPL", + "md5": "67fabf6b68acfa3f97b5a445988c42b1", + "name": "gdb_server_linux-64", + "sha256": "5828dd1d5aa3040dd2cbbf16cfaba39675e95192933c45f77ed3b859260ea9d4", + "size": 952777, + "subdir": "linux-64", + "timestamp": 1652859661753, + "version": "11.2" + }, + "gdb_server_linux-64-11.2-h1234567_1.tar.bz2": { + "build": "h1234567_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "b338d6926c97f2b9e9c166b743401cb3", + "name": "gdb_server_linux-64", + "sha256": "7f5984e318089b45acf81512e01eb39ddc54667b3b2390a54607fe9a407d53e1", + "size": 969006, + "subdir": "linux-64", + "timestamp": 1654090744991, + "version": "11.2" + }, + "gdbm-1.18-hd4cb3f1_0.tar.bz2": { + "build": "hd4cb3f1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "readline >=8.0,<9.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "3c4f88dba09329b00fb47021c244ddb7", + "name": "gdbm", + "sha256": "d46b5feabf0b430d9f015b500b93f8286711b859ac39fed41f9b6d62bddde89a", + "size": 194711, + "subdir": "linux-64", + "timestamp": 1658933501580, + "version": "1.18" + }, + "gdbm-1.18-hd4cb3f1_4.tar.bz2": { + "build": "hd4cb3f1_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=11.2.0", + "readline >=8.0,<9.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "8a56d24c01b9cd2190c4640227643664", + "name": "gdbm", + "sha256": "0e56a23cb5876d7cd11f505940566b231de9b162614da663ca7d7709dcf25d03", + "size": 197198, + "subdir": "linux-64", + "timestamp": 1667379356099, + "version": "1.18" + }, + "gdk-pixbuf-2.42.10-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "glib >=2.56.0,<3.0a0", + "glib >=2.69.1,<3.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.39,<1.7.0a0", + "libtiff >=4.2.0,<5.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "91d63f5353a1cb1c1a2bead12511acc8", + "name": "gdk-pixbuf", + "sha256": "96780002e9dfb0375b4e4f5d88ace9ac04286780e0f0ad8b38b0a14393b771f1", + "size": 607503, + "subdir": "linux-64", + "timestamp": 1678446474565, + "version": "2.42.10" + }, + "gdk-pixbuf-2.42.6-h8cc273a_4.tar.bz2": { + "build": "h8cc273a_4", + "build_number": 4, + "depends": [ + "glib >=2.69.1,<3.0a0", + "gobject-introspection", + "jpeg >=9b,<10a", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "zlib" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "2fb52440f32aa154d8b3f64ff3ea4a54", + "name": "gdk-pixbuf", + "sha256": "c8b9bc18e78941abefb712c2a546ecd3a83e41d38133ed6b7deb668eaae0739b", + "size": 627166, + "subdir": "linux-64", + "timestamp": 1631785294033, + "version": "2.42.6" + }, + "gdk-pixbuf-2.42.6-h8cc273a_5.tar.bz2": { + "build": "h8cc273a_5", + "build_number": 5, + "depends": [ + "glib >=2.69.1,<3.0a0", + "gobject-introspection", + "jpeg", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "zlib" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "22614d5cc3bec318d447f797c7132fc3", + "name": "gdk-pixbuf", + "sha256": "faf48b37fa9ef294d50190dcf6c97fcc2c635612095fa74ad5143da93a41cb9b", + "size": 624543, + "subdir": "linux-64", + "timestamp": 1632493367697, + "version": "2.42.6" + }, + "gdk-pixbuf-2.42.8-h433bba3_0.tar.bz2": { + "build": "h433bba3_0", + "build_number": 0, + "depends": [ + "glib >=2.56.0,<3.0a0", + "glib >=2.69.1,<3.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "zlib" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "6333e79ba7d103847ab629db09048ed4", + "name": "gdk-pixbuf", + "sha256": "14279aefdc41e86fa63bfb4db10d752080fa7e29ad7e8a53c4b28e049db83afb", + "size": 230498, + "subdir": "linux-64", + "timestamp": 1656524732030, + "version": "2.42.8" + }, + "gdk-pixbuf-2.42.8-h433bba3_1.tar.bz2": { + "build": "h433bba3_1", + "build_number": 1, + "depends": [ + "glib >=2.56.0,<3.0a0", + "glib >=2.69.1,<3.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "zlib" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "f12e827cfd71ae06ccc0c88330944d33", + "name": "gdk-pixbuf", + "sha256": "0511ccb7e29186cb5f009ad1f8ad9d27fede801c7856ee7c352c7d0b26b1c288", + "size": 230934, + "subdir": "linux-64", + "timestamp": 1669625880112, + "version": "2.42.8" + }, + "gdk-pixbuf-2.42.8-h5eee18b_2.tar.bz2": { + "build": "h5eee18b_2", + "build_number": 2, + "depends": [ + "glib >=2.56.0,<3.0a0", + "glib >=2.69.1,<3.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.2.0,<5.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "fa5be9f1b2930338bf8ce8995c43fb81", + "name": "gdk-pixbuf", + "sha256": "03a77db0c1d75bde0d890fa3adb11b7c27888e4aef43782c4ce67a160a5678e0", + "size": 231683, + "subdir": "linux-64", + "timestamp": 1677573443403, + "version": "2.42.8" + }, + "gensim-3.0.1-py27h297c816_0.tar.bz2": { + "build": "py27h297c816_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "4a2e7260afd93dc0bb49619b8d2363ea", + "name": "gensim", + "sha256": "d275c4fc654701bc4c3e3a933f669b461922bb97098ef8d224e7fc5682afb843", + "size": 12929844, + "subdir": "linux-64", + "timestamp": 1508797441593, + "version": "3.0.1" + }, + "gensim-3.0.1-py35h6653ba0_0.tar.bz2": { + "build": "py35h6653ba0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "d74abe0e1dc7bea87f08568e639746b7", + "name": "gensim", + "sha256": "0e358a90e222fbd70b84c8a58c4daa5245a8ddb07508d58fb1eca9735d51652f", + "size": 12897305, + "subdir": "linux-64", + "timestamp": 1508797306817, + "version": "3.0.1" + }, + "gensim-3.0.1-py36h4ebfbf4_0.tar.bz2": { + "build": "py36h4ebfbf4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "1480f225aead0f380e143afa1fd37a41", + "name": "gensim", + "sha256": "c203e5fba91c4be252449249c3ed7b2582ce8f494ff0a0b94d0c582827882484", + "size": 12903990, + "subdir": "linux-64", + "timestamp": 1508797509978, + "version": "3.0.1" + }, + "gensim-3.1.0-py27h4d79aa8_0.tar.bz2": { + "build": "py27h4d79aa8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "e820127c830713cda1112d1c0873542b", + "name": "gensim", + "sha256": "1b4dd81b03b4da48250eaa7f3ed228014d0c4cc8c2d31d509ad969c79a470e6e", + "size": 14019266, + "subdir": "linux-64", + "timestamp": 1512065876696, + "version": "3.1.0" + }, + "gensim-3.1.0-py35h7300b16_0.tar.bz2": { + "build": "py35h7300b16_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "119a2d59a7ddc67918847ed2bafe59e9", + "name": "gensim", + "sha256": "6fd94863ad8fe4826fcb33fac9cdc3c152357687d7f897fe4a38a3a76ee29e53", + "size": 14040806, + "subdir": "linux-64", + "timestamp": 1512065888806, + "version": "3.1.0" + }, + "gensim-3.1.0-py36hc2fc318_0.tar.bz2": { + "build": "py36hc2fc318_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "2b033832a8b9b3ce2fceb76079b9397b", + "name": "gensim", + "sha256": "626ca514c7167831550f821c56f5d3675f4509b8210e3666ab9fb45fe558293e", + "size": 14067319, + "subdir": "linux-64", + "timestamp": 1512065733044, + "version": "3.1.0" + }, + "gensim-3.3.0-py27h3010b51_0.tar.bz2": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "23d81e18ff93f5ffa851e33619b43468", + "name": "gensim", + "sha256": "977037a77c1c9b9df169fc83efa0ab4c7d7b38e0f744bcc12dc202016ceaf3f1", + "size": 22082389, + "subdir": "linux-64", + "timestamp": 1519149939566, + "version": "3.3.0" + }, + "gensim-3.3.0-py35h3010b51_0.tar.bz2": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "d0776ceb9865dc2276f08f362fcb0d31", + "name": "gensim", + "sha256": "9cd5bfd63a9dcf20b86c5466482f18d55caaac2cce26ff99ff87fa4f0ccd3fb3", + "size": 22052513, + "subdir": "linux-64", + "timestamp": 1519150000374, + "version": "3.3.0" + }, + "gensim-3.3.0-py36h3010b51_0.tar.bz2": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "26443c3750cda9dca3e5d8dca773a70b", + "name": "gensim", + "sha256": "dbfce4b46bfc89dc83ef38c410a04805c4da1189125519186fe235ef8ddf1601", + "size": 22081375, + "subdir": "linux-64", + "timestamp": 1519149994716, + "version": "3.3.0" + }, + "gensim-3.4.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "28518a385196c864ae0a4b35a43db7a0", + "name": "gensim", + "sha256": "4cc298997695d0056a9e4f45daad38ec08141d760d5f845a83ba8d6c2f82368d", + "size": 22562404, + "subdir": "linux-64", + "timestamp": 1530889413279, + "version": "3.4.0" + }, + "gensim-3.4.0-py27h3010b51_0.tar.bz2": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "84b4a89a25e2657a1085b188c8b12fe6", + "name": "gensim", + "sha256": "a59d80d55c8f627e9f88610e49c8bb563ac04502d7e192373e367bd202829b30", + "size": 22562577, + "subdir": "linux-64", + "timestamp": 1520782139295, + "version": "3.4.0" + }, + "gensim-3.4.0-py35h3010b51_0.tar.bz2": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "d6a4b491b8dbe6572e39474a870c5bfa", + "name": "gensim", + "sha256": "918e0e306001eb947eb502f20cdbdf558a2b30fe2e0813cb9b1f9bac250d17bf", + "size": 22588017, + "subdir": "linux-64", + "timestamp": 1520782275819, + "version": "3.4.0" + }, + "gensim-3.4.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "10bb0bfe6e1e34cea025234d42160002", + "name": "gensim", + "sha256": "5dee136c84dec340e3237980c44eff73226007331f6c6c276ea2f267fb48c066", + "size": 22565137, + "subdir": "linux-64", + "timestamp": 1530880415964, + "version": "3.4.0" + }, + "gensim-3.4.0-py36h3010b51_0.tar.bz2": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "349d8d7565f039fd2ca6027175701a50", + "name": "gensim", + "sha256": "90f586d2ed20adfbe37cff282079d802a0e4ac1a0ca85fd7bfd9135dace86b8b", + "size": 22564112, + "subdir": "linux-64", + "timestamp": 1520782263833, + "version": "3.4.0" + }, + "gensim-3.4.0-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "3ee0c88fe32d3e928a252ea0eb3d4c5b", + "name": "gensim", + "sha256": "a742e318f295bc5d883421c8c917fac6214c942e8028151f3564910755eabe45", + "size": 22562188, + "subdir": "linux-64", + "timestamp": 1530879696124, + "version": "3.4.0" + }, + "gensim-3.7.3-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.5,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "67ac79ccc48b8b0a43806efa00ab4f13", + "name": "gensim", + "sha256": "aa4084a9c0b4e6700ff25bc199d21e7650fef99a09863eea0f7261a7f6fe7676", + "size": 23869714, + "subdir": "linux-64", + "timestamp": 1569336660183, + "version": "3.7.3" + }, + "gensim-3.7.3-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.5,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "4f1d6619c936fa319d0380982bdd685c", + "name": "gensim", + "sha256": "567375bd1a149056f387df1108bf86c45557127a1c22682fa651e25ae2ad4086", + "size": 23917657, + "subdir": "linux-64", + "timestamp": 1569336679810, + "version": "3.7.3" + }, + "gensim-3.7.3-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.5,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "a13d919968a5c6bd6e2fad85346889f6", + "name": "gensim", + "sha256": "d002e40f9508be51df83458c6a563178352615d1c955b53ce40786027343a0db", + "size": 23876315, + "subdir": "linux-64", + "timestamp": 1569336662990, + "version": "3.7.3" + }, + "gensim-3.8.0-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "8679dc3d258a98be9695adb3f7de2cf5", + "name": "gensim", + "sha256": "1203fd66ed24d8799aae2103958fa38520774b41f62c2b1b61a200918b517e7e", + "size": 23837349, + "subdir": "linux-64", + "timestamp": 1569354064548, + "version": "3.8.0" + }, + "gensim-3.8.0-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "5fdfe9465517ce535a91bf7729f4ab71", + "name": "gensim", + "sha256": "7af8d0c71c316694968e8efd24426ef476fc3b11ccbda76f8c90bedbf0eb4297", + "size": 24021168, + "subdir": "linux-64", + "timestamp": 1569354077761, + "version": "3.8.0" + }, + "gensim-3.8.0-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "1f0ea0b08bee95a2fcc4b212a6711950", + "name": "gensim", + "sha256": "723369ef77149a10882d14843b3f9460a24cc4368444875c68ec8ed45a1ceb09", + "size": 23812476, + "subdir": "linux-64", + "timestamp": 1569354077282, + "version": "3.8.0" + }, + "gensim-3.8.3-py36h2531618_2.tar.bz2": { + "build": "py36h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "md5": "538aed652a3f9e84b2856a1c98128624", + "name": "gensim", + "sha256": "26d263cd07b12f4964ded970744e503649deeac007ec497a74811b9dc25ac463", + "size": 23877552, + "subdir": "linux-64", + "timestamp": 1613993712786, + "version": "3.8.3" + }, + "gensim-3.8.3-py37h2531618_2.tar.bz2": { + "build": "py37h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "md5": "1c2347ef9cc258cbfb88a291b9b8fe3b", + "name": "gensim", + "sha256": "28e58eb1feb798e5d28c872f247f8156a2e67e9ba278fb1df6dbad91576b419c", + "size": 23916780, + "subdir": "linux-64", + "timestamp": 1613994598843, + "version": "3.8.3" + }, + "gensim-3.8.3-py38h2531618_2.tar.bz2": { + "build": "py38h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "md5": "f315623d564f9748789aae9700a40098", + "name": "gensim", + "sha256": "2f206e55311891241c2f07c0d994e7fd13a1ce03620e307230df4f56648bfda3", + "size": 23941963, + "subdir": "linux-64", + "timestamp": 1613994569427, + "version": "3.8.3" + }, + "gensim-3.8.3-py39h2531618_2.tar.bz2": { + "build": "py39h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "md5": "91c2c852f804830dc04a1fb597422902", + "name": "gensim", + "sha256": "b2c0800d72d188658fc83ee3ae814efe2b81bd2ee2d22fc15f471c726abb6666", + "size": 23956459, + "subdir": "linux-64", + "timestamp": 1613994590150, + "version": "3.8.3" + }, + "gensim-4.0.1-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "cython 0.29.23", + "dataclasses", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3", + "python >=3.6,<3.7.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "md5": "854762993ff4f950648507e8c53e2bba", + "name": "gensim", + "sha256": "2b6bdc0669f6e96cce1faa6a9a53616df28ccac0ccbe07fe8b466c3addefad88", + "size": 23464296, + "subdir": "linux-64", + "timestamp": 1621559079230, + "version": "4.0.1" + }, + "gensim-4.0.1-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "cython 0.29.23", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3", + "python >=3.7,<3.8.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "md5": "5b5ea1e37e8a104284e5e54936fb5609", + "name": "gensim", + "sha256": "9af9c6ac5d5ec36301dfc7e4fecad054a2c935ea6792f39f60041ed034c50949", + "size": 23473363, + "subdir": "linux-64", + "timestamp": 1621559071992, + "version": "4.0.1" + }, + "gensim-4.0.1-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "cython 0.29.23", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3", + "python >=3.8,<3.9.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "md5": "4dcf1ff61928409e289168c8e92929ca", + "name": "gensim", + "sha256": "0dbc037b7fe75cac6bf4c0c074086a26c177b37763772b1bc773f087156fca76", + "size": 23507085, + "subdir": "linux-64", + "timestamp": 1621559068349, + "version": "4.0.1" + }, + "gensim-4.0.1-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "cython 0.29.23", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3", + "python >=3.9,<3.10.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "md5": "df543fb535ba386d17a88f27bf5f63de", + "name": "gensim", + "sha256": "55074f2b3a2f804440a19612940a0c15c700e01c52d4cc7197c40f27b11a7c9f", + "size": 23496452, + "subdir": "linux-64", + "timestamp": 1621558618835, + "version": "4.0.1" + }, + "gensim-4.1.2-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "cython >=0.29.23", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "adbc784dd5496b48015b5ceb25832ab3", + "name": "gensim", + "sha256": "fe718f75205d507454529c9ba433ea15a3c994f5d4b02fe1c8efd9ef7013a89c", + "size": 25416506, + "subdir": "linux-64", + "timestamp": 1646825045675, + "version": "4.1.2" + }, + "gensim-4.1.2-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "cython >=0.29.23", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "4c8549fa034731dc6d7ec2d32734abce", + "name": "gensim", + "sha256": "9ba49d6e7318a4a89ecab47ad9286660a29f58331a0c4647f99d2f072bc553f2", + "size": 23543425, + "subdir": "linux-64", + "timestamp": 1646807555025, + "version": "4.1.2" + }, + "gensim-4.1.2-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "cython >=0.29.23", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "757a96b0fae9a53e3ff24d14094364ec", + "name": "gensim", + "sha256": "ecfb9733524a2b9d88edc6c7f83740f2374cec7880bd5e64678ef8fb1b9720e7", + "size": 23646192, + "subdir": "linux-64", + "timestamp": 1646825032012, + "version": "4.1.2" + }, + "gensim-4.1.2-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "cython >=0.29.23", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "64c1e48d4229c477cdd10390246ad7c7", + "name": "gensim", + "sha256": "22e4bf33a9bcb63caff802577b6512a562e61163662e32636afc81bc0aafc7b6", + "size": 23604301, + "subdir": "linux-64", + "timestamp": 1646806891493, + "version": "4.1.2" + }, + "gensim-4.2.0-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "cython 0.29.28", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "5eebf66b668d6e66799ae33d01100b29", + "name": "gensim", + "sha256": "beca4115a31f1a6ca257fd886c1485fe6dee86c3ae1310caed59ce4df20141a1", + "size": 25683102, + "subdir": "linux-64", + "timestamp": 1657909473209, + "version": "4.2.0" + }, + "gensim-4.2.0-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "cython 0.29.28", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "a609025e6aae31228cda8d2f3e65cb80", + "name": "gensim", + "sha256": "38fd8a2a3da1969094f482e8b4a53d07327c55768a4e6e09168a8191aa95b00c", + "size": 23527170, + "subdir": "linux-64", + "timestamp": 1657909378832, + "version": "4.2.0" + }, + "gensim-4.2.0-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "cython 0.29.28", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "4cca0073cac3553d117a17a65f63bab7", + "name": "gensim", + "sha256": "fd159af66a310d8aee4a8f4c60a021aae09e93a2b1127bd7ab2b687a8c8340e8", + "size": 23550047, + "subdir": "linux-64", + "timestamp": 1657909627285, + "version": "4.2.0" + }, + "gensim-4.2.0-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "cython 0.29.28", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "51c189febdbdf65099f6da4d5bd3842e", + "name": "gensim", + "sha256": "6a39ff82928b82d8e9f0590ca1d8a354dc52f719ef7cc6e941a4d307fa6c2742", + "size": 23646564, + "subdir": "linux-64", + "timestamp": 1657909550490, + "version": "4.2.0" + }, + "gensim-4.3.0-py310h1128e8f_0.tar.bz2": { + "build": "py310h1128e8f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=1.7.0", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "3c9ac489f256a9237b7ba1f9f9019b53", + "name": "gensim", + "sha256": "757f6c49098394ec2b8a9e25957cdd3f224e5f23d14a5d5dde6a744d2ae524c3", + "size": 23705351, + "subdir": "linux-64", + "timestamp": 1674852699002, + "version": "4.3.0" + }, + "gensim-4.3.0-py311hba01205_1.tar.bz2": { + "build": "py311hba01205_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0", + "scipy >=1.7.0", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "9853293a8373e0212ae4f75f34d66055", + "name": "gensim", + "sha256": "d76f10d13f91eb170cfdfa55a6703a1480913787d43ae6dafd4e649f83d0e4c3", + "size": 24018587, + "subdir": "linux-64", + "timestamp": 1677033437187, + "version": "4.3.0" + }, + "gensim-4.3.0-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.7.0", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "dc94cfec799b2076a3ea449709cd97dd", + "name": "gensim", + "sha256": "69a60273f3b33445870b67747a1e7cb84cd9c7eb631805cb5576b5d60dce481e", + "size": 23664309, + "subdir": "linux-64", + "timestamp": 1674852610534, + "version": "4.3.0" + }, + "gensim-4.3.0-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.7.0", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "030484e01d126b047a7a5a0f01aaf15f", + "name": "gensim", + "sha256": "d1687c53c26bdc14b989b3dce78f3382b82bd4cbbb46220d285b71aa2e50d446", + "size": 23663275, + "subdir": "linux-64", + "timestamp": 1674852521396, + "version": "4.3.0" + }, + "genson-1.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c41b8b62a823f999c9642dcbf8f6754", + "name": "genson", + "sha256": "ac30f994cd8669823ace7a81f24971a076a42d8f8f14096a130529aa3ad5df6a", + "size": 22938, + "subdir": "linux-64", + "timestamp": 1519234621585, + "version": "1.0.1" + }, + "genson-1.0.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f5ed85f2d9f0d811e0ed2f225a2c1e2b", + "name": "genson", + "sha256": "b40354c0c3266dd294172e20fc329756ad679d401bc7672b20b841fed95ea4b0", + "size": 23652, + "subdir": "linux-64", + "timestamp": 1519234612038, + "version": "1.0.1" + }, + "genson-1.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "968446a7e2fcd648af435e682998d2cf", + "name": "genson", + "sha256": "e07f295acffd174a935eeb1d96ba060682176b5b219402e0eb216b95ea45917f", + "size": 23620, + "subdir": "linux-64", + "timestamp": 1519234561279, + "version": "1.0.1" + }, + "genson-1.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea8e12501947056d32eb29a3f8e5cd24", + "name": "genson", + "sha256": "432dac7ee00730e274db8330a49f6312a287600e9206ac33828dcb813130bdd4", + "size": 23596, + "subdir": "linux-64", + "timestamp": 1530890140838, + "version": "1.0.1" + }, + "genson-1.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cffc6d28810cbf579dd44694fdc3a325", + "name": "genson", + "sha256": "c26c92b10272f44a37c5745319a26004dec36203d4cb4eea85fc83e95f12143d", + "size": 23323, + "subdir": "linux-64", + "timestamp": 1545151337943, + "version": "1.0.2" + }, + "genson-1.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4515b31c727cafeeb89f0e82cf5bcb07", + "name": "genson", + "sha256": "e0cec5350f26fb5a7b035aa885af0c4e74d2d22222228124a86cbfa1078180a8", + "size": 23997, + "subdir": "linux-64", + "timestamp": 1545130114122, + "version": "1.0.2" + }, + "genson-1.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4b2fc648b84c3c4b13d40323a6cd0cc4", + "name": "genson", + "sha256": "f2c1bb5868b2832efe24a3ab8ba5515e58b1b0d5ad2dd5f9e66c687975ca705e", + "size": 23984, + "subdir": "linux-64", + "timestamp": 1545130119070, + "version": "1.0.2" + }, + "geopandas-0.12.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "folium", + "geopandas-base 0.12.2 py38h06a4308_0", + "mapclassify >=2.4.0", + "matplotlib-base >=3.2.0", + "python >=3.8,<3.9.0a0", + "rtree", + "xyzservices" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2195a5ccc9f71c4628f6c090861c15ac", + "name": "geopandas", + "sha256": "c3be7721dfbaecd526e21e055cf135a361f9174ba143fbad3d40e87af5b6cab3", + "size": 6230, + "subdir": "linux-64", + "timestamp": 1675672124803, + "version": "0.12.2" + }, + "geopandas-0.12.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "folium", + "geopandas-base 0.12.2 py39h06a4308_0", + "mapclassify >=2.4.0", + "matplotlib-base >=3.2.0", + "python >=3.9,<3.10.0a0", + "rtree", + "xyzservices" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5155de2423b5bc74a24a59f0278550fc", + "name": "geopandas", + "sha256": "08b103afcd8339cac3d69a387af77e55e10eda75948f3a1ec6e8738668fa2506", + "size": 6216, + "subdir": "linux-64", + "timestamp": 1675672048767, + "version": "0.12.2" + }, + "geopandas-0.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "descartes", + "fiona", + "matplotlib", + "pandas", + "psycopg2", + "pyproj", + "pysal", + "python >=2.7,<2.8.0a0", + "rtree", + "shapely", + "six", + "sqlalchemy" + ], + "license": "BSD 3-clause", + "md5": "4e8d21c15ce8aa47d0a45abf2ab27e1e", + "name": "geopandas", + "sha256": "4992c401f5f5212d9bccc2cc343e5a66b36c296b51b147325fc3c33e2bca7d87", + "size": 940732, + "subdir": "linux-64", + "timestamp": 1530890422320, + "version": "0.3.0" + }, + "geopandas-0.3.0-py27h5233db4_0.tar.bz2": { + "build": "py27h5233db4_0", + "build_number": 0, + "depends": [ + "descartes", + "fiona", + "matplotlib", + "pandas", + "psycopg2", + "pyproj", + "pysal", + "python >=2.7,<2.8.0a0", + "rtree", + "shapely", + "six", + "sqlalchemy" + ], + "license": "BSD 3-clause", + "md5": "87941b995ba5ff17250d7d5d0bef703e", + "name": "geopandas", + "sha256": "edc53bcd4fcc6f0f1f2236ea82f643720e7b82abbc22ad2edf685609a250270a", + "size": 941093, + "subdir": "linux-64", + "timestamp": 1513269372160, + "version": "0.3.0" + }, + "geopandas-0.3.0-py35h2f9c1c0_0.tar.bz2": { + "build": "py35h2f9c1c0_0", + "build_number": 0, + "depends": [ + "descartes", + "fiona", + "matplotlib", + "pandas", + "psycopg2", + "pyproj", + "pysal", + "python >=3.5,<3.6.0a0", + "rtree", + "shapely", + "six", + "sqlalchemy" + ], + "license": "BSD 3-clause", + "md5": "313b5bcf24a3f174e4cf8ba8be07eb0d", + "name": "geopandas", + "sha256": "ca62e3612fb5c1a7d60c3cfeeff71746801d25272b0fc31026bd4ea291f49cc3", + "size": 945723, + "subdir": "linux-64", + "timestamp": 1513269562762, + "version": "0.3.0" + }, + "geopandas-0.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "descartes", + "fiona", + "matplotlib", + "pandas", + "psycopg2", + "pyproj", + "pysal", + "python >=3.6,<3.7.0a0", + "rtree", + "shapely", + "six", + "sqlalchemy" + ], + "license": "BSD 3-clause", + "md5": "7659b3433487e616dd706d8d2153f744", + "name": "geopandas", + "sha256": "38f4aff67dbaa1810722f18edf1c79322a8c8196d5fca51409ad02e30cd74a92", + "size": 946222, + "subdir": "linux-64", + "timestamp": 1530890375512, + "version": "0.3.0" + }, + "geopandas-0.3.0-py36h2f9c1c0_0.tar.bz2": { + "build": "py36h2f9c1c0_0", + "build_number": 0, + "depends": [ + "descartes", + "fiona", + "matplotlib", + "pandas", + "psycopg2", + "pyproj", + "pysal", + "python >=3.6,<3.7.0a0", + "rtree", + "shapely", + "six", + "sqlalchemy" + ], + "license": "BSD 3-clause", + "md5": "a95c6ad2e29a302aa487f2d042db864d", + "name": "geopandas", + "sha256": "d98a7fa0e7b43c7514bc5727afe2dd193eb954e4a856dcc7b9cba2e2d475921f", + "size": 946443, + "subdir": "linux-64", + "timestamp": 1513269580516, + "version": "0.3.0" + }, + "geopandas-0.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "descartes", + "fiona", + "matplotlib", + "pandas", + "psycopg2", + "pyproj", + "pysal", + "python >=3.7,<3.8.0a0", + "rtree", + "shapely", + "six", + "sqlalchemy" + ], + "license": "BSD 3-clause", + "md5": "5a93b00f397deaec4355fe7210784f9e", + "name": "geopandas", + "sha256": "ba9393acc066e14e30f2c911b8de10d12fc098172510047d170ecbe917ff5492", + "size": 946133, + "subdir": "linux-64", + "timestamp": 1530890334061, + "version": "0.3.0" + }, + "geopandas-0.4.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "descartes", + "fiona", + "matplotlib", + "pandas", + "psycopg2", + "pyproj", + "pysal", + "python >=2.7,<2.8.0a0", + "rtree", + "shapely", + "six", + "sqlalchemy" + ], + "license": "BSD 3-clause", + "md5": "3253d3fadedaae6226547d8b37d98001", + "name": "geopandas", + "sha256": "dc138b68e42abe771342950fb2bd55bcb963fcb46db827458277affc1b931de2", + "size": 985350, + "subdir": "linux-64", + "timestamp": 1545418163994, + "version": "0.4.0" + }, + "geopandas-0.4.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "descartes", + "fiona", + "matplotlib", + "pandas", + "psycopg2", + "pyproj", + "pysal", + "python >=3.6,<3.7.0a0", + "rtree", + "shapely", + "six", + "sqlalchemy" + ], + "license": "BSD 3-clause", + "md5": "07b6f4a985ffe900c3f46d714d00eb4c", + "name": "geopandas", + "sha256": "3c468154bbbec1d67198d710f4d1738ccc6963fecac8417054b7618751ccad5b", + "size": 965338, + "subdir": "linux-64", + "timestamp": 1545418174408, + "version": "0.4.0" + }, + "geopandas-0.4.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "descartes", + "fiona", + "matplotlib", + "pandas", + "psycopg2", + "pyproj", + "pysal", + "python >=3.7,<3.8.0a0", + "rtree", + "shapely", + "six", + "sqlalchemy" + ], + "license": "BSD 3-clause", + "md5": "d80b4b1ed1cd9a6e19fa5a506f551652", + "name": "geopandas", + "sha256": "eb07e8097710f5ee6635f0a9e44d3adfd2e777351392fdfa42f3f574afa7db81", + "size": 969624, + "subdir": "linux-64", + "timestamp": 1545418185137, + "version": "0.4.0" + }, + "geopandas-base-0.12.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "fiona >=1.8", + "packaging", + "pandas >=1.0.0", + "pyproj >=2.6.1.post1", + "python >=3.8,<3.9.0a0", + "shapely >=1.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9c9b910f82d0ec74660ebca9261c113e", + "name": "geopandas-base", + "sha256": "2cd41da7f5c9f9c018c4f14ee1383f3d6416283f5ba267b75bc0cb94a6c76ed8", + "size": 1256343, + "subdir": "linux-64", + "timestamp": 1675672123162, + "version": "0.12.2" + }, + "geopandas-base-0.12.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "fiona >=1.8", + "packaging", + "pandas >=1.0.0", + "pyproj >=2.6.1.post1", + "python >=3.9,<3.10.0a0", + "shapely >=1.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f5550863d8c5b35ca56bf12d6c23561", + "name": "geopandas-base", + "sha256": "7fc3d76b0962a6b490cb1a8b0b6b43f66b9c7a36ca4180cb525104cfcace50dd", + "size": 1253125, + "subdir": "linux-64", + "timestamp": 1675672047136, + "version": "0.12.2" + }, + "geos-3.6.0-h03ef862_2.tar.bz2": { + "build": "h03ef862_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPLv2.1", + "md5": "4ce444940fb4a6a8d29e71ad865ee06c", + "name": "geos", + "sha256": "6ee315a46b93cae167cc34e49c34694a7c1b1ee948a2809a7294dd457a381653", + "size": 1715312, + "subdir": "linux-64", + "timestamp": 1510864387320, + "version": "3.6.0" + }, + "geos-3.6.0-h62fd342_1.tar.bz2": { + "build": "h62fd342_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPLv2.1", + "md5": "721f067c44a22c58b54585a2afdea596", + "name": "geos", + "sha256": "b3dba5cb3c49979395a3d3c7366e9ce97803d903b7eb1830a485688289c80044", + "size": 1714910, + "subdir": "linux-64", + "timestamp": 1509380099632, + "version": "3.6.0" + }, + "geos-3.6.2-heeff764_2.tar.bz2": { + "build": "heeff764_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPLv2.1", + "md5": "4a3cf51c37c8dcb7ab55769555f435d0", + "name": "geos", + "sha256": "23bd1f3e22b3555a9fa324d4f2958242b5bd05f33c62736a1b20c82f2baed6e4", + "size": 1718118, + "subdir": "linux-64", + "timestamp": 1511288943183, + "version": "3.6.2" + }, + "geos-3.7.1-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPLv2.1", + "md5": "77a0a3d7cd603d25dd94249280d6660a", + "name": "geos", + "sha256": "0c8ba661dac0ffc47108eb850ba75d36a450f5922224a46f951eeda576c13610", + "size": 1704264, + "subdir": "linux-64", + "timestamp": 1545278503715, + "version": "3.7.1" + }, + "geos-3.8.0-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "md5": "7f115aea55f4cffe8c6c937240697f06", + "name": "geos", + "sha256": "6d791f835f915ad4f34171399b7d3141e548446dcce384f7d11f28a04c002bb7", + "size": 1078422, + "subdir": "linux-64", + "timestamp": 1573215838521, + "version": "3.8.0" + }, + "geos-3.8.1-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "md5": "a5c7ebcc66e5f56c64851847d44b2100", + "name": "geos", + "sha256": "75e79fe6f1ec163a58264dda1043c4b7ec0d288faf2dcab87e4e01991039afd5", + "size": 1069823, + "subdir": "linux-64", + "timestamp": 1588540645544, + "version": "3.8.1" + }, + "geos-3.9.0-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "md5": "ddd9b4ebca6b88401c5e67c3d6371042", + "name": "geos", + "sha256": "5f3528cc181df8945402f7bdb7845c2606124fc7a8f2500bebfebb90e5d88bf6", + "size": 1077393, + "subdir": "linux-64", + "timestamp": 1613161685682, + "version": "3.9.0" + }, + "geos-3.9.1-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "md5": "46cb78963aa63f16b6133f3af51036f8", + "name": "geos", + "sha256": "e00cf55d04bef85925c3c3870b71561e6556e944700ee02e6c28727e3ebf7c40", + "size": 1079706, + "subdir": "linux-64", + "timestamp": 1613329302907, + "version": "3.9.1" + }, + "geos-3.9.1-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "LGPL-2.1", + "md5": "82fb5d79af5fdcaf07c99618bf9e81c5", + "name": "geos", + "sha256": "c9bdfaa84e461c4c88f8ac72127c3e5781f77c2248da024b9aae30b4f5b5a130", + "size": 1087467, + "subdir": "linux-64", + "timestamp": 1643015949041, + "version": "3.9.1" + }, + "geotiff-1.4.2-h8e81d37_0.tar.bz2": { + "build": "h8e81d37_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "proj4 >=4.9.3,<4.9.4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "15e820054b2c75145249453317a7e52a", + "name": "geotiff", + "sha256": "0d3066d98cebb313ba921b09735eb8083afc7360038caddab8d42dbdd5127f88", + "size": 1397488, + "subdir": "linux-64", + "timestamp": 1524095706648, + "version": "1.4.2" + }, + "geotiff-1.4.2-h9c7010b_0.tar.bz2": { + "build": "h9c7010b_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "proj4 >=5.2.0,<5.2.1.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "11440acce2b642b1c9e8ee4f0607845c", + "name": "geotiff", + "sha256": "67f404a7f1e4f1dbd57289cec30a651d878b73cae1ef1b62e0946544314b0d47", + "size": 1396510, + "subdir": "linux-64", + "timestamp": 1545265212234, + "version": "1.4.2" + }, + "geotiff-1.5.1-h21e8280_0.tar.bz2": { + "build": "h21e8280_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "0a1813fcbd24f005f1f3070245227a36", + "name": "geotiff", + "sha256": "4a5443be96b081c7b0ba749c6133c19fb7ff68b7fcb1ca8b98a9270fc3984fd6", + "size": 290386, + "subdir": "linux-64", + "timestamp": 1573241782337, + "version": "1.5.1" + }, + "geotiff-1.5.1-h21e8280_1.tar.bz2": { + "build": "h21e8280_1", + "build_number": 1, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "14f064227a69d03d609dc76688c8c6bd", + "name": "geotiff", + "sha256": "a9c26d3bda98fdd733617897b8a63047a5f2e946b20f108e83854ef8a313e70b", + "size": 292618, + "subdir": "linux-64", + "timestamp": 1590596163321, + "version": "1.5.1" + }, + "geotiff-1.5.1-hda54ad2_1.tar.bz2": { + "build": "hda54ad2_1", + "build_number": 1, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "proj >=7.0.1,<7.0.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "9851e6f0787e48bb9ca373d0a37a2f51", + "name": "geotiff", + "sha256": "77af3954e0ef186d06267a27e9b95971955cf5a1d0bae495fa996d2351888946", + "size": 291143, + "subdir": "linux-64", + "timestamp": 1590596211313, + "version": "1.5.1" + }, + "geotiff-1.6.0-h21e8280_0.tar.bz2": { + "build": "h21e8280_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "4deca3ba1690c3050f75a30d060e7b78", + "name": "geotiff", + "sha256": "cc1194e940c81690136696285afd627a69424592421255ba0d1265d260c50a09", + "size": 292317, + "subdir": "linux-64", + "timestamp": 1596829845039, + "version": "1.6.0" + }, + "geotiff-1.7.0-h2a26cda_1.tar.bz2": { + "build": "h2a26cda_1", + "build_number": 1, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9c7770ab6be1735c8c545c1cefd2ea4", + "name": "geotiff", + "sha256": "6c86b6ac3cadbda6fbd1c7a7205bbcea543a261f05f8fcf5e90bf8083c6cfc9f", + "size": 303456, + "subdir": "linux-64", + "timestamp": 1679997074086, + "version": "1.7.0" + }, + "geotiff-1.7.0-hd69d5b1_0.tar.bz2": { + "build": "hd69d5b1_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "zlib" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0be412b39ea3969b79829a2556698416", + "name": "geotiff", + "sha256": "27f153e921dd9adae169043ffdca3903ad98344bde7c3e8ab8c771f2b4d116a0", + "size": 284741, + "subdir": "linux-64", + "timestamp": 1625555192147, + "version": "1.7.0" + }, + "geoviews-1.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "netcdf4 <1.4.0" + ], + "depends": [ + "bokeh >=0.12.13", + "cartopy >=0.14.2", + "holoviews >=1.10.1", + "jupyter", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2de4b93fa9a28332defc23d377964b2f", + "name": "geoviews", + "sha256": "9f882d33a53ec71a1d7d24d7a6ec2973435e2c770a49be4ebc04eef318e7c8f2", + "size": 388130, + "subdir": "linux-64", + "timestamp": 1528137058073, + "version": "1.5.0" + }, + "geoviews-1.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "netcdf4 <1.4.0" + ], + "depends": [ + "bokeh >=0.12.13", + "cartopy >=0.14.2", + "holoviews >=1.10.1", + "jupyter", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "241aeb80c981fc2d65b82549ef83bca5", + "name": "geoviews", + "sha256": "5f9221edd454d6fb32146f602192fb0a3ba52ce3fd54dbdd53bcef9dd08dec31", + "size": 390043, + "subdir": "linux-64", + "timestamp": 1528137107740, + "version": "1.5.0" + }, + "geoviews-1.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "netcdf4 <1.4.0" + ], + "depends": [ + "bokeh >=0.12.13", + "cartopy >=0.14.2", + "holoviews >=1.10.1", + "jupyter", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1c09eabc2ea2a6d48183f1e904415332", + "name": "geoviews", + "sha256": "72baccf82f709eaf55655ebab745d5604fc37fcd0cee41b0e5dbbfb3aab54d56", + "size": 387433, + "subdir": "linux-64", + "timestamp": 1528137045031, + "version": "1.5.0" + }, + "geoviews-1.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "datashader", + "gdal", + "geopandas", + "geoviews-core 1.5.1.*", + "jupyter", + "libgdal", + "matplotlib", + "netcdf4 <1.4.0", + "pandas", + "pyct", + "python >=2.7,<2.8.0a0", + "scipy", + "shapely", + "xarray" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9fafc6d20bf9033d310b19bbcd3e1899", + "name": "geoviews", + "sha256": "22101794444d6fc4ad2504628b7eb07b8b4419685a8b9e0fe217eea3a03c71ee", + "size": 4854, + "subdir": "linux-64", + "timestamp": 1529435490028, + "version": "1.5.1" + }, + "geoviews-1.5.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "datashader", + "gdal", + "geopandas", + "geoviews-core 1.5.1.*", + "jupyter", + "libgdal", + "matplotlib", + "netcdf4 <1.4.0", + "pandas", + "pyct", + "python >=3.5,<3.6.0a0", + "scipy", + "shapely", + "xarray" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6d40c917a05e42e80896e2c2b7ad3887", + "name": "geoviews", + "sha256": "4b759d9e2442dce4e279b454d5ccdccc5e27d247ed2812b36f28da70fe933de0", + "size": 4839, + "subdir": "linux-64", + "timestamp": 1529435414481, + "version": "1.5.1" + }, + "geoviews-1.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "datashader", + "gdal", + "geopandas", + "geoviews-core 1.5.1.*", + "jupyter", + "libgdal", + "matplotlib", + "netcdf4 <1.4.0", + "pandas", + "pyct", + "python >=3.6,<3.7.0a0", + "scipy", + "shapely", + "xarray" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8c87cf8203657e971982ba41ea009a2a", + "name": "geoviews", + "sha256": "d6c9cb94479bd4e1839bb15ebd33b452613b0c7af93a61d79ef92c45a822b047", + "size": 4849, + "subdir": "linux-64", + "timestamp": 1529435207959, + "version": "1.5.1" + }, + "geoviews-core-1.5.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "constrains": [ + "geoviews 1.5.1" + ], + "depends": [ + "bokeh >=0.12.15", + "cartopy >=0.14.2", + "holoviews >=1.10.1", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1ef1dc19f7dae533afb3f5d03e917c17", + "name": "geoviews-core", + "sha256": "21da5de4b042e0a060da99b27047c65fa5cde318a91ffdab24ea6ff612043f30", + "size": 383013, + "subdir": "linux-64", + "timestamp": 1529433878078, + "version": "1.5.1" + }, + "geoviews-core-1.5.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "constrains": [ + "geoviews 1.5.1" + ], + "depends": [ + "bokeh >=0.12.15", + "cartopy >=0.14.2", + "holoviews >=1.10.1", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c73b3ff060036134dc24c6d2f4768441", + "name": "geoviews-core", + "sha256": "0bfe14b5d9b8007a5cbd07aa1c4dc69c3a06bfecf71d0b4d72180b3fd5fb3c93", + "size": 391997, + "subdir": "linux-64", + "timestamp": 1642522440553, + "version": "1.5.1" + }, + "geoviews-core-1.5.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "constrains": [ + "geoviews 1.5.1" + ], + "depends": [ + "bokeh >=0.12.15", + "cartopy >=0.14.2", + "holoviews >=1.10.1", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aa80004de913af316ef7758723038a3a", + "name": "geoviews-core", + "sha256": "c38ae813832970610c39e85e737a9decfb52293894a5d14e26747e284af4528d", + "size": 382130, + "subdir": "linux-64", + "timestamp": 1529433921219, + "version": "1.5.1" + }, + "geoviews-core-1.5.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "constrains": [ + "geoviews 1.5.1" + ], + "depends": [ + "bokeh >=0.12.15", + "cartopy >=0.14.2", + "holoviews >=1.10.1", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0183191950b4097f78baaaff625a9671", + "name": "geoviews-core", + "sha256": "4efe443de0767057975f0193a20e82f46048ae5d374f91a585147c18d59a2654", + "size": 380965, + "subdir": "linux-64", + "timestamp": 1529433816686, + "version": "1.5.1" + }, + "get_terminal_size-1.0.0-haa9412d_0.tar.bz2": { + "build": "haa9412d_0", + "build_number": 0, + "depends": [ + "backports.shutil_get_terminal_size" + ], + "license": "MIT", + "md5": "6f23685ff397cc83815632a4bd389516", + "name": "get_terminal_size", + "sha256": "47efe5289ae82838ebd18eb20aabb991a947140ddb7ff97f53de45fdf76d8945", + "size": 2736, + "subdir": "linux-64", + "timestamp": 1505743304546, + "version": "1.0.0" + }, + "gettext-0.19.8.1-h9b4dc7a_1.tar.bz2": { + "build": "h9b4dc7a_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPLv2", + "md5": "6876bdc87ad2f1f004f79eb5df0437b0", + "name": "gettext", + "sha256": "913cb1d4b2c1c082c7a26e36585816410a8b1c0dc7e2d85162e551924fd944db", + "size": 3838622, + "subdir": "linux-64", + "timestamp": 1505743479908, + "version": "0.19.8.1" + }, + "gettext-0.19.8.1-hd7bead4_3.tar.bz2": { + "build": "hd7bead4_3", + "build_number": 3, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0" + ], + "license": "GPLv2", + "md5": "7d2890f694d11a9d5f59b4046f254d4c", + "name": "gettext", + "sha256": "6f436316c84a1a2dda8c95b36bc7964b155c6f4bf549be52c2c6e583b1c867e7", + "size": 3839015, + "subdir": "linux-64", + "timestamp": 1510610506539, + "version": "0.19.8.1" + }, + "gettext-0.20.2-hf68c758_0.tar.bz2": { + "build": "hf68c758_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0" + ], + "license": "GPL-2.0", + "md5": "90ff09950227afceb963664aa5700882", + "name": "gettext", + "sha256": "4f9a658396f4b39382493bd78a63d250169a48a50e2f3bfb11a9be395f74d691", + "size": 3540605, + "subdir": "linux-64", + "timestamp": 1617203743233, + "version": "0.20.2" + }, + "gettext-0.21.0-h39681ba_1.tar.bz2": { + "build": "h39681ba_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "ncurses >=6.4,<7.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "0b074830efc0ac3a9c26cb30afb8f2ae", + "name": "gettext", + "sha256": "16360158b9f35eb16159615aad9abde4960a2b080de729b1fe3c4904247e08db", + "size": 3579176, + "subdir": "linux-64", + "timestamp": 1679578452756, + "version": "0.21.0" + }, + "gettext-0.21.0-hf68c758_0.tar.bz2": { + "build": "hf68c758_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0" + ], + "license": "GPL-2.0", + "md5": "7b50d8014e3ffd9258944e356c2fec93", + "name": "gettext", + "sha256": "ed1517be29af622c3ddb2be99e601842f080e923d73209182fcebfbe53dcbb71", + "size": 3575487, + "subdir": "linux-64", + "timestamp": 1617290893597, + "version": "0.21.0" + }, + "gevent-1.2.2-py27h475ea6a_0.tar.bz2": { + "build": "py27h475ea6a_0", + "build_number": 0, + "depends": [ + "cffi >=1.3.0", + "greenlet >=0.4.10", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a5a8f0904da12b7079e60e7b368ed66e", + "name": "gevent", + "sha256": "ca551fae07ca7caa705ebae851185fc24a4f34e0141f7950577a945198c9b224", + "size": 772264, + "subdir": "linux-64", + "timestamp": 1505743619086, + "version": "1.2.2" + }, + "gevent-1.2.2-py35he064abf_0.tar.bz2": { + "build": "py35he064abf_0", + "build_number": 0, + "depends": [ + "cffi >=1.3.0", + "greenlet >=0.4.10", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbe9ae8b03951e7b7a6c970cc4ffa92c", + "name": "gevent", + "sha256": "b8475d63946bfc0b7fcd80bbad0fc671fd0223c586093619d9a145fe47d530af", + "size": 790162, + "subdir": "linux-64", + "timestamp": 1505743706509, + "version": "1.2.2" + }, + "gevent-1.2.2-py36h2fe25dc_0.tar.bz2": { + "build": "py36h2fe25dc_0", + "build_number": 0, + "depends": [ + "cffi >=1.3.0", + "greenlet >=0.4.10", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc5fe19ebf2103056286a772f18efb86", + "name": "gevent", + "sha256": "8799e675be92e0eea63d7e810faaba2bec8638f718abbdde37b30ec39f2bcd4a", + "size": 791246, + "subdir": "linux-64", + "timestamp": 1505743794067, + "version": "1.2.2" + }, + "gevent-1.3.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.10", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1947b9298751e021ddb1ff4e484bdbc5", + "name": "gevent", + "sha256": "11efdf558fd5b69383eb26b64b30dcf79b12e4d95273b35f61590bda5be2d215", + "size": 1924508, + "subdir": "linux-64", + "timestamp": 1526406170564, + "version": "1.3.0" + }, + "gevent-1.3.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.10", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca9d4dc7b991bd745aeff9f11d0333ff", + "name": "gevent", + "sha256": "8e274d7f24b07728bc7f5b10400467f98ee742a50fca4a2f4f8df060ad96a4ab", + "size": 1937536, + "subdir": "linux-64", + "timestamp": 1526406142626, + "version": "1.3.0" + }, + "gevent-1.3.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.10", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1bb806bffcc994a06b0ff096b2c5aecf", + "name": "gevent", + "sha256": "b2558e303b5930feb5c0ca90a06798117fa5948140d8d6d0c8b13c190a81d10b", + "size": 1945391, + "subdir": "linux-64", + "timestamp": 1526406104590, + "version": "1.3.0" + }, + "gevent-1.3.2.post0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce1d067af7aed6b92ac8f84ad83e804b", + "name": "gevent", + "sha256": "a2672e46b7189bc5deec966b3b6c13eb9ba1ef350f4bbae648b99d75499cdfd9", + "size": 1931166, + "subdir": "linux-64", + "timestamp": 1527855212552, + "version": "1.3.2.post0" + }, + "gevent-1.3.2.post0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1c0fbf2e53d6a6a6b9583bfacfce18a", + "name": "gevent", + "sha256": "96b0d580699626f79b4f17b94871fe3e569242be7eebcd2365dc6a0dbf099393", + "size": 1942140, + "subdir": "linux-64", + "timestamp": 1527855184769, + "version": "1.3.2.post0" + }, + "gevent-1.3.2.post0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b51435a4b445e3bbb6fd0a815296ce6", + "name": "gevent", + "sha256": "dded7c1eb22429aa891a3873d0825ff3a71c23e2230949629d603d0d0b23ea8d", + "size": 1947377, + "subdir": "linux-64", + "timestamp": 1527855144156, + "version": "1.3.2.post0" + }, + "gevent-1.3.3-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f55cd6f7d6c8f2d86f640e6fa531040", + "name": "gevent", + "sha256": "e0c74d363701c79bd3f7b02732f8a48c9ed6a99c182ec5a10e32266a04f6f48c", + "size": 1932394, + "subdir": "linux-64", + "timestamp": 1529355276316, + "version": "1.3.3" + }, + "gevent-1.3.3-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab52ef0e2b042b3b76f76a3cdcf3bf00", + "name": "gevent", + "sha256": "1ca84fd5afc877c759944087540e4cb15432108fc7840fce8727764cf752c5fa", + "size": 1942213, + "subdir": "linux-64", + "timestamp": 1529355431696, + "version": "1.3.3" + }, + "gevent-1.3.3-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1478937391171975beb88031c20aacce", + "name": "gevent", + "sha256": "bdafdbea02d385f0adecd18e5fd84fc6af205ebeefa857787d08674296d2d257", + "size": 1948667, + "subdir": "linux-64", + "timestamp": 1529355425004, + "version": "1.3.3" + }, + "gevent-1.3.4-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c712df66f8a1e078945b4e6283af58b4", + "name": "gevent", + "sha256": "b070fe41addd7e8685358892079786627c421740a93d2b0d0411b56001d21db1", + "size": 1933743, + "subdir": "linux-64", + "timestamp": 1529941283252, + "version": "1.3.4" + }, + "gevent-1.3.4-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8b5c08bbe2ba51907038d1865a2d3c77", + "name": "gevent", + "sha256": "3d84d1bfa95462affbdca6daf81cbbf6efa18dd8976186847d2dd3a61f443382", + "size": 1943867, + "subdir": "linux-64", + "timestamp": 1529941293431, + "version": "1.3.4" + }, + "gevent-1.3.4-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0b151142312964cc05e46784a1a7c36", + "name": "gevent", + "sha256": "1234d4227d3d13c6897ed2bc71996360637cea0c0cf060dd2e5bc1ce8ac3bbcd", + "size": 1950689, + "subdir": "linux-64", + "timestamp": 1529941282776, + "version": "1.3.4" + }, + "gevent-1.3.4-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a75bd8fdc15781a97023c1376ad5954", + "name": "gevent", + "sha256": "712fad33397dc030cec3234e23258bad8b663271ae74c0cff7d60dd734a0aea8", + "size": 1945344, + "subdir": "linux-64", + "timestamp": 1530890621572, + "version": "1.3.4" + }, + "gevent-1.3.5-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e779fd480a386289b8fef7efb470e4bf", + "name": "gevent", + "sha256": "888ba375f8828db41b71d9783ef24a808ef7d133b70af44ef336f9c3f2a63e7c", + "size": 1939558, + "subdir": "linux-64", + "timestamp": 1532523064998, + "version": "1.3.5" + }, + "gevent-1.3.5-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0079df6a2e8fa40446aea5265e6b5394", + "name": "gevent", + "sha256": "d29138ccba148ed160f1e8beec4769b0a2bb8380a3739340e79791d3571fcceb", + "size": 1951782, + "subdir": "linux-64", + "timestamp": 1532523012360, + "version": "1.3.5" + }, + "gevent-1.3.5-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cfcbacd8ab067c473bfa87af85be9319", + "name": "gevent", + "sha256": "9610ca7f065374c98909d28f2c62ac69b34d14578f0139abc4f05eb010aa75ad", + "size": 1958417, + "subdir": "linux-64", + "timestamp": 1532523059083, + "version": "1.3.5" + }, + "gevent-1.3.5-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e820c95d47b0ee330eb4a22b619054f8", + "name": "gevent", + "sha256": "89ae5ecd70b8c954c3332a825077d513d0837b6c7fe748a00e16abdacd40abf2", + "size": 1954308, + "subdir": "linux-64", + "timestamp": 1532523105175, + "version": "1.3.5" + }, + "gevent-1.3.6-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "579edeb7ee11a64deb0d432a2ad4be98", + "name": "gevent", + "sha256": "bb367c93c3f2f048a37eb33a15391f0667e600d2541276356471c8c80e114b8a", + "size": 1930781, + "subdir": "linux-64", + "timestamp": 1534951777163, + "version": "1.3.6" + }, + "gevent-1.3.6-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "88ebae43f46247679c059c0dbcdf19d8", + "name": "gevent", + "sha256": "04c102f3a25983091323ea3356ba3f4f599a793446db580b17ada147375e21ef", + "size": 1953311, + "subdir": "linux-64", + "timestamp": 1534951783744, + "version": "1.3.6" + }, + "gevent-1.3.6-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0943d9a55df6e9df5570c167dc748e1a", + "name": "gevent", + "sha256": "c2fbc3403fb3fec65e18c85d579862105073112b8da6f5cacb7a383457c7e795", + "size": 1958944, + "subdir": "linux-64", + "timestamp": 1534951782210, + "version": "1.3.6" + }, + "gevent-1.3.6-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48798081157ddfd2ef777cd5f70615ae", + "name": "gevent", + "sha256": "8624bf7242fddb344215135ac0fcefb28225f1de1944457cd7475a41cf4fdddc", + "size": 1954245, + "subdir": "linux-64", + "timestamp": 1534951786423, + "version": "1.3.6" + }, + "gevent-1.3.7-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1dd10b7a35b967b9d1086fc135fa2b73", + "name": "gevent", + "sha256": "1eacd0ea2821215c078395a957c42a3d976a8a9f6541e4a1fdf7dbfd124dc585", + "size": 1929285, + "subdir": "linux-64", + "timestamp": 1539635707799, + "version": "1.3.7" + }, + "gevent-1.3.7-py27h7b6447c_1.tar.bz2": { + "build": "py27h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ba13a72a645ef17f3de51ff96f933d2", + "name": "gevent", + "sha256": "1a76f9f260980da80100e14f18b2be27e80e9784aba7ed84410224acdd1508a9", + "size": 1928993, + "subdir": "linux-64", + "timestamp": 1540307935570, + "version": "1.3.7" + }, + "gevent-1.3.7-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "637244f926827304114df2c98af320ab", + "name": "gevent", + "sha256": "23e022e2983604aca11a01e6889a329f8bb9d9114f06ec0e36e9fb382a8fd75e", + "size": 1958765, + "subdir": "linux-64", + "timestamp": 1539635727846, + "version": "1.3.7" + }, + "gevent-1.3.7-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f8fbbfe2469c39013a7299c6991bac8", + "name": "gevent", + "sha256": "bdb962f52f912dc9d2b14194ce4df3e033335268f39c5199797cc09d19a54ea2", + "size": 1959691, + "subdir": "linux-64", + "timestamp": 1540307995611, + "version": "1.3.7" + }, + "gevent-1.3.7-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de9cc47189845f796db5b27b54f2f155", + "name": "gevent", + "sha256": "53ebdc9edca418a48603c9767aa1650473d4bfd01c82c7234eb0191daf356359", + "size": 1953789, + "subdir": "linux-64", + "timestamp": 1539635675590, + "version": "1.3.7" + }, + "gevent-1.3.7-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "470917d7b4501eb3ec8df6ecb000fc26", + "name": "gevent", + "sha256": "0cd4174dcfd6756fac1ad0ecbd984cda1273b55940724b9012f14d68662c500e", + "size": 1954152, + "subdir": "linux-64", + "timestamp": 1540307941561, + "version": "1.3.7" + }, + "gevent-1.3.7-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c04c529b94930463571c57502eb20981", + "name": "gevent", + "sha256": "630471394ecb310190a407c947a5b76b14717e47c6d3ab27c9bf5bc831aefaf6", + "size": 1959038, + "subdir": "linux-64", + "timestamp": 1574251613699, + "version": "1.3.7" + }, + "gevent-1.4.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8eab0a263fec3f4ac677f304ba10f48", + "name": "gevent", + "sha256": "865d9a1d5b1c66a10d03cb9848129811a12d7a150066a6754a5c875803f94ea4", + "size": 2607658, + "subdir": "linux-64", + "timestamp": 1547230529337, + "version": "1.4.0" + }, + "gevent-1.4.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dfe6d356e1dde05693ec1f4d4f6cc928", + "name": "gevent", + "sha256": "911e79d8b383f5cba3be368a8a6ee0531b4da8e15163e9997339970809f55847", + "size": 2633623, + "subdir": "linux-64", + "timestamp": 1547230577792, + "version": "1.4.0" + }, + "gevent-1.4.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c454d49c2301cf24550d6673897aa0ad", + "name": "gevent", + "sha256": "3db0a166b6d25fdf2f75b89ac687bfc8ddf969831ebbb79d45c6c8c08389ecd0", + "size": 2644984, + "subdir": "linux-64", + "timestamp": 1547230549840, + "version": "1.4.0" + }, + "gevent-20.12.0-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11b6f80464e6311c17db19dd2e6b2b76", + "name": "gevent", + "sha256": "4bdd573ac8283a737a1461ff99b56e54bd179adc5d8f71e0d3f23a3fdb37e49e", + "size": 1892316, + "subdir": "linux-64", + "timestamp": 1608661211551, + "version": "20.12.0" + }, + "gevent-20.12.0-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f731f7e68f0f2d635c33aa6a13c8d883", + "name": "gevent", + "sha256": "6e05fd7bdb3676a34fed1bee14813e98ab5a6296ad43f88b77550607329fad13", + "size": 1911897, + "subdir": "linux-64", + "timestamp": 1608661214889, + "version": "20.12.0" + }, + "gevent-20.12.0-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5769c6ab716ec538975840844eef9c92", + "name": "gevent", + "sha256": "ea11461f6a60a5f9af35de6500ec860d62961c3f29bb89f69503c1fd3d6505cc", + "size": 1957336, + "subdir": "linux-64", + "timestamp": 1608661221297, + "version": "20.12.0" + }, + "gevent-20.12.0-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce26c1a2cc79983ad19920e22daad977", + "name": "gevent", + "sha256": "e9b167732291dd53e783a4e95b5eaf947f84a342cce6cfcc46606d7e466c3835", + "size": 1963776, + "subdir": "linux-64", + "timestamp": 1608661218373, + "version": "20.12.0" + }, + "gevent-20.12.1-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "130c8c4a275ced186c938fa11f54a35e", + "name": "gevent", + "sha256": "39e8a90ad2d6eaea8734724c46e65465bb8cd94f91b0f22d120e5ebebdfc2781", + "size": 1880887, + "subdir": "linux-64", + "timestamp": 1609093283457, + "version": "20.12.1" + }, + "gevent-20.12.1-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a7b3aaa1145940dd7da9bb78e610a59e", + "name": "gevent", + "sha256": "7c9d38a31bab607255ca4f2cb5973f815119ad42a81ab74fc787e98ddce3b6c9", + "size": 1929724, + "subdir": "linux-64", + "timestamp": 1609093269600, + "version": "20.12.1" + }, + "gevent-20.12.1-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52305672e0a6c70bec3bea7741c3907d", + "name": "gevent", + "sha256": "e3fbdef2faccbdf348783926873c8bdc6ea2fde906c0903c594b1d5d10787144", + "size": 1955470, + "subdir": "linux-64", + "timestamp": 1609093283675, + "version": "20.12.1" + }, + "gevent-20.12.1-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1be61982d7803a7890478cda4c2bddfc", + "name": "gevent", + "sha256": "0ca8d9743649b4bf979309174c66d2027cd7c61d9cf86073ba61df02ac1705dc", + "size": 1965410, + "subdir": "linux-64", + "timestamp": 1609093315890, + "version": "20.12.1" + }, + "gevent-20.6.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0016290dd7d3ad210ab0e32af1904f84", + "name": "gevent", + "sha256": "0fcb5fbe787b1138861b1832bc61efce91e244e33a29ffca3319395d7179ccf9", + "size": 1834280, + "subdir": "linux-64", + "timestamp": 1593009704377, + "version": "20.6.2" + }, + "gevent-20.6.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebfbf1288575c6f49d1e8ee0b4563ddf", + "name": "gevent", + "sha256": "ef44ed5c85a9d4b5f1d3c0a61d865e8da7eb42d5b869e489661f839f3c69f9a1", + "size": 1863968, + "subdir": "linux-64", + "timestamp": 1593010102114, + "version": "20.6.2" + }, + "gevent-20.6.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd72e28602fc3dba7c7ccd6df670c61e", + "name": "gevent", + "sha256": "a4cd85b9a3278348a9065aa653f607bf79ec77304172705d60b3d1a680fff27b", + "size": 1911048, + "subdir": "linux-64", + "timestamp": 1593009695671, + "version": "20.6.2" + }, + "gevent-20.9.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e617b0511b62da645f86a5a778191f51", + "name": "gevent", + "sha256": "e3af55945689991965310655e928b5878b2d29b5338c52a58e694a6e7700cf89", + "size": 1851070, + "subdir": "linux-64", + "timestamp": 1601397716384, + "version": "20.9.0" + }, + "gevent-20.9.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bebbfdfda58b94bb2b16fbd05dc10b39", + "name": "gevent", + "sha256": "df1a5e4b2cf788cb36f2b87e381a68361fda8b2860ae50343210a764970f2c27", + "size": 1888422, + "subdir": "linux-64", + "timestamp": 1601397718157, + "version": "20.9.0" + }, + "gevent-20.9.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dcfd02fc83ec1de059c48448c3181f04", + "name": "gevent", + "sha256": "3195fa33f94ed0ddf8373e317d5e5039deddb6afee4953107c24d60d3cf42bc5", + "size": 1916765, + "subdir": "linux-64", + "timestamp": 1601397678878, + "version": "20.9.0" + }, + "gevent-20.9.0-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f5894d633cca71ed3e1cd4739904408", + "name": "gevent", + "sha256": "8d13ff5af1a189b0fc342ef05b31e30322b3eb479178869a2518316dc600880e", + "size": 1922291, + "subdir": "linux-64", + "timestamp": 1608154882021, + "version": "20.9.0" + }, + "gevent-21.1.0-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "165127e167884a87867356efa088b6d5", + "name": "gevent", + "sha256": "dc531997e3e9d36722ff798dfae94517bba3a7d01c65f6af983b291ab952357c", + "size": 1921640, + "subdir": "linux-64", + "timestamp": 1610823139106, + "version": "21.1.0" + }, + "gevent-21.1.0-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b83f37393863c208d8262d659527c20d", + "name": "gevent", + "sha256": "7b677e096f816900ff64a9bf79cf0bf18f0f9b28b39eb005bd0d61fdd6533e10", + "size": 1940521, + "subdir": "linux-64", + "timestamp": 1610823157323, + "version": "21.1.0" + }, + "gevent-21.1.0-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c3ef77baa699ae55e5789d444abb322", + "name": "gevent", + "sha256": "9909c56dfed765a454d3ec8f5aac391cb052d3ee29899e739b258e1031649080", + "size": 1982070, + "subdir": "linux-64", + "timestamp": 1610822512901, + "version": "21.1.0" + }, + "gevent-21.1.0-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "42bb4b3f1c548526a7d44c1f0331e6f9", + "name": "gevent", + "sha256": "01c516f17be91838ee69b913dea10a51e92cafd8793626ea57efb73f125a247f", + "size": 1982732, + "subdir": "linux-64", + "timestamp": 1610823147679, + "version": "21.1.0" + }, + "gevent-21.1.1-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "862b1891ba60be63150b5887d58a4211", + "name": "gevent", + "sha256": "61340911395041a0476d774c0418906bd1a6955dbb1dda363f9bc640780ac8be", + "size": 1919748, + "subdir": "linux-64", + "timestamp": 1610995914836, + "version": "21.1.1" + }, + "gevent-21.1.1-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60928de41a9958d087484f06ef8f0dea", + "name": "gevent", + "sha256": "7d4841acea2a566567208eda11202c2a5cb260a45d1eee06d209062d0ea3d4a8", + "size": 1935182, + "subdir": "linux-64", + "timestamp": 1610995949439, + "version": "21.1.1" + }, + "gevent-21.1.1-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "55cd3648f75ac7e44205328b3eb797f8", + "name": "gevent", + "sha256": "94830362a5bc375516e3fb182b47e22666df5db56a5ebe5882afbee74c19f850", + "size": 1975860, + "subdir": "linux-64", + "timestamp": 1610995170970, + "version": "21.1.1" + }, + "gevent-21.1.1-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01352250aa6c693fd7ca93f951dfedeb", + "name": "gevent", + "sha256": "2daf6dea02da5bf5156ae414a50a9654a8933bc9e38cbe2ab86ff67a8cff7739", + "size": 1978046, + "subdir": "linux-64", + "timestamp": 1610995891765, + "version": "21.1.1" + }, + "gevent-21.1.2-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.11.5", + "greenlet >=0.4.17,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "40e2d84e7b1755d5f458e8c397362f6b", + "name": "gevent", + "sha256": "82f7cbccfeac73f67f8a93a77b32e43831c2b2ab4ab2d55b523bb5655536be97", + "size": 1731432, + "subdir": "linux-64", + "timestamp": 1616408845827, + "version": "21.1.2" + }, + "gevent-21.1.2-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.11.5", + "greenlet >=0.4.17,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b0afc0ccdf64ba7cc1838adaab63e9a", + "name": "gevent", + "sha256": "ca6ec2cdc200505e4117097a8a4384a01e753f5e40026e5bac6eb170ddba2ca2", + "size": 1726323, + "subdir": "linux-64", + "timestamp": 1616773050134, + "version": "21.1.2" + }, + "gevent-21.1.2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.11.5", + "greenlet >=0.4.17,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21e40072fa855fcfae003439a2b72fa9", + "name": "gevent", + "sha256": "a21ecdbcfc65f1291807e471b133a5c941f788a48e969812006f0138ed800988", + "size": 1764668, + "subdir": "linux-64", + "timestamp": 1616408840824, + "version": "21.1.2" + }, + "gevent-21.1.2-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.11.5", + "greenlet >=0.4.17,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d24154c4e8439ed856c2c96c7dcac821", + "name": "gevent", + "sha256": "e91af564e1a429fadb0f41b3f5bacaa03f6e6e90f9cf64dd069b8cb5273913b5", + "size": 1767094, + "subdir": "linux-64", + "timestamp": 1616773046117, + "version": "21.1.2" + }, + "gevent-21.1.2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.11.5", + "greenlet >=0.4.17,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "70ecc2fc892665dae220f4a4221c20e2", + "name": "gevent", + "sha256": "f9c9a3417ec2a8d912715049c1135ca3e51c52cad2c23dfe0138eaef8e640cba", + "size": 1806323, + "subdir": "linux-64", + "timestamp": 1616408790711, + "version": "21.1.2" + }, + "gevent-21.1.2-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.11.5", + "greenlet >=0.4.17,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6086b0566284783db7002274e36364c8", + "name": "gevent", + "sha256": "bf294cbcaf555c4a655af729eb84653bc18ab79cf0978f122f8ea085397282b0", + "size": 1792684, + "subdir": "linux-64", + "timestamp": 1616770791479, + "version": "21.1.2" + }, + "gevent-21.1.2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.11.5", + "greenlet >=0.4.17,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cce18f90dda2ab52ab1760c6f1fe1dcc", + "name": "gevent", + "sha256": "d4d4f062c93f20e0c0abae9c444824455e5ac7f8d5ba8f44a6223460c146b540", + "size": 1777391, + "subdir": "linux-64", + "timestamp": 1616408845353, + "version": "21.1.2" + }, + "gevent-21.1.2-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.11.5", + "greenlet >=0.4.17,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "398aaf1bbf6b4abae979c90d49f13363", + "name": "gevent", + "sha256": "df2e60ef1d7731d5dfa70023b37e67976db22097fadf78ecf7e07b4b94e26207", + "size": 1794585, + "subdir": "linux-64", + "timestamp": 1616772977051, + "version": "21.1.2" + }, + "gevent-21.8.0-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=1.1.0,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a8faa962f7e19fd130244617cd9a055", + "name": "gevent", + "sha256": "afb248ed70a8ae9e410dca3d1c869254832284a6f59448ebf9feadb81eaa9005", + "size": 4634209, + "subdir": "linux-64", + "timestamp": 1640809197070, + "version": "21.8.0" + }, + "gevent-21.8.0-py36h7f8727e_1.tar.bz2": { + "build": "py36h7f8727e_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=1.1.0,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16349afa72b5ea2b3e5164c608bfe555", + "name": "gevent", + "sha256": "5346aad08780dc88ee775029933b542cede0c69a6f8d59bc632c7fc550dbaa44", + "size": 1763908, + "subdir": "linux-64", + "timestamp": 1628273801591, + "version": "21.8.0" + }, + "gevent-21.8.0-py37h7f8727e_1.tar.bz2": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=1.1.0,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b086024168534e7c8f00685173b56049", + "name": "gevent", + "sha256": "3508c600791c124929a6d2a9088d27a4e71b9532805b62c4b43b35415218117e", + "size": 1792993, + "subdir": "linux-64", + "timestamp": 1628265701491, + "version": "21.8.0" + }, + "gevent-21.8.0-py38h7f8727e_1.tar.bz2": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=1.1.0,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b19c0401f7a530e32263703364c04b9", + "name": "gevent", + "sha256": "606e891644b6936db9c03aaaadce4a2e9407056cc672e800d998eef7accdb3d9", + "size": 1834602, + "subdir": "linux-64", + "timestamp": 1628273784436, + "version": "21.8.0" + }, + "gevent-21.8.0-py39h7f8727e_1.tar.bz2": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=1.1.0,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4cabee5da995863b48c6226cc77a123e", + "name": "gevent", + "sha256": "cf2756e40b562b8d654936a31ec27f7dc090ab5054ffea81f924bbb99c54f088", + "size": 1838834, + "subdir": "linux-64", + "timestamp": 1628273362982, + "version": "21.8.0" + }, + "gevent-22.10.2-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "c-ares >=1.18.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=2.0.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=11.2.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c7aa3ad6f273e71a5d6aef1fca81ae6c", + "name": "gevent", + "sha256": "a53dba0e73a9bf57b59577508a36fbf43631512bd606aa8bf5017c3dbbf9f0e8", + "size": 1827882, + "subdir": "linux-64", + "timestamp": 1670621524042, + "version": "22.10.2" + }, + "gevent-22.10.2-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "c-ares >=1.18.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=2.0.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=11.2.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.11,<3.12.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cda2cea19d2c67c23de8b335b60007de", + "name": "gevent", + "sha256": "bb60811a4ebed88bcf486438b987e4660eefef7f3184ddcee4f8621da9c6a43d", + "size": 2102523, + "subdir": "linux-64", + "timestamp": 1676844142426, + "version": "22.10.2" + }, + "gevent-22.10.2-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "c-ares >=1.18.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=2.0.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=11.2.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f7c8a64619a2cce4e473886414b209d", + "name": "gevent", + "sha256": "47da574ea3a19e3dd1fb026b3a3aea7c4f5ccb33140744b0236757259cbae73e", + "size": 1797220, + "subdir": "linux-64", + "timestamp": 1670621368949, + "version": "22.10.2" + }, + "gevent-22.10.2-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "c-ares >=1.18.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=2.0.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=11.2.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ad6127d604be64fcf0b6b55d5f0207b", + "name": "gevent", + "sha256": "b65a5b479812a785dd4e61e7bf3e3f227484432fd3df1438636099a9f02209a8", + "size": 1831612, + "subdir": "linux-64", + "timestamp": 1670621446346, + "version": "22.10.2" + }, + "gevent-22.10.2-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "c-ares >=1.18.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=2.0.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=11.2.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c96d11ea6e59aa2f58279b5d60c921a8", + "name": "gevent", + "sha256": "b37cb136ca6af1cf7e30562f9428c9dd4679e88a286aa6b886e904b62241f6ec", + "size": 1818880, + "subdir": "linux-64", + "timestamp": 1670621282648, + "version": "22.10.2" + }, + "gevent-websocket-0.10.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "af89aa36a7f6d5a7e0c9168271e0e415", + "name": "gevent-websocket", + "sha256": "cbd0e9d7d8d443a4d55f5c778a202d9244b74a6dc828e8c99c6600fc27fd2ef0", + "size": 33983, + "subdir": "linux-64", + "timestamp": 1537207584620, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "81785e94fed09facba80e9fb18bbb5e7", + "name": "gevent-websocket", + "sha256": "39bb14ea3019f0089741f852e4415c1f76953d1b8dc061da9e26844ed78b5c34", + "size": 35769, + "subdir": "linux-64", + "timestamp": 1640812144314, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "3f65404fcdd34da36c9c82875a4d0c7a", + "name": "gevent-websocket", + "sha256": "7eb90dd421765eb2cdde4aa7ab4ab869d1778321c5c1dcaed3117d441f941987", + "size": 45535, + "subdir": "linux-64", + "timestamp": 1676907240781, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "1f9ba6c4d13676f72aff2864d484732c", + "name": "gevent-websocket", + "sha256": "303d41ae1d327eb64c048f33cfe1ec8039dcb1ba609ea41e46748a8642cb05de", + "size": 34883, + "subdir": "linux-64", + "timestamp": 1537207631764, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "670acb4fdac2322d4a4e589281b4c8c7", + "name": "gevent-websocket", + "sha256": "38280e9f2da6d3b3256bec938de76571206d7b1d66f7ecd0ca5487aa25b65665", + "size": 34817, + "subdir": "linux-64", + "timestamp": 1537207644912, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "660670ef4eef8d700fbaf66020b4b4a3", + "name": "gevent-websocket", + "sha256": "7a017eb86b57b64bea65671cb45af0e41a509018d7fc94644ad360962a9545f9", + "size": 260252, + "subdir": "linux-64", + "timestamp": 1614094094044, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "ef31b6ff62de13f080e682cf83aa39f0", + "name": "gevent-websocket", + "sha256": "8e0da9ccd83f76b00a2069a9bcb99579aeeedcfc58836f4ecb605ce4f11a5e15", + "size": 34674, + "subdir": "linux-64", + "timestamp": 1537207568212, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "b649e7d52ea2ca59f56eb7286ebd6267", + "name": "gevent-websocket", + "sha256": "1f4edea6c32264b45cf77fff8bcc91e3458b0cceed057522042afce5fd4f9054", + "size": 258442, + "subdir": "linux-64", + "timestamp": 1614093964108, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "9fa920ee6c0344d96e1ad163e61f549e", + "name": "gevent-websocket", + "sha256": "c069614a8fe33a2b4f799de1fd2eae1d99883767ad22a7dc068ae1b6a26c9490", + "size": 35557, + "subdir": "linux-64", + "timestamp": 1574413933779, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "4ee3d05c78ec3a8148513c6ffc8474a6", + "name": "gevent-websocket", + "sha256": "036ee65d7c9069e569ea0334231258d0f5d7506f929c9d86dd5e8eb52f2a6436", + "size": 260637, + "subdir": "linux-64", + "timestamp": 1614094090600, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "2da236390e3eced5e16ce3da6b38b522", + "name": "gevent-websocket", + "sha256": "c46b913620303d3221cb09c2f28afd90a3eb1ae8c19d0d3c9eae5dd1da89785a", + "size": 258183, + "subdir": "linux-64", + "timestamp": 1614094091461, + "version": "0.10.1" + }, + "geventhttpclient-1.3.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d89ca5503b535fb7d8beef122e10e2c5", + "name": "geventhttpclient", + "sha256": "422bd8cc45fa5fbd26b1de49bad20f8fad1eff9fa67b0df5c7e61ff11bc5dc42", + "size": 106734, + "subdir": "linux-64", + "timestamp": 1585079509097, + "version": "1.3.1" + }, + "geventhttpclient-1.3.1-py37hdbfa776_0.tar.bz2": { + "build": "py37hdbfa776_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31facd01445b4b7348b471716bbc29fa", + "name": "geventhttpclient", + "sha256": "8053d826f89344d80984a5338ac2d613b1d2f556fd6a35faec3b28295279b198", + "size": 107118, + "subdir": "linux-64", + "timestamp": 1636035831444, + "version": "1.3.1" + }, + "geventhttpclient-1.3.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "146859888e4642dbac7e5a85bb17ed3e", + "name": "geventhttpclient", + "sha256": "8acb70b6576cea9a6ceb940e21410021a80215549f06d9d1326181bbc4013ae3", + "size": 106827, + "subdir": "linux-64", + "timestamp": 1585079507899, + "version": "1.3.1" + }, + "geventhttpclient-1.3.1-py38hdbfa776_0.tar.bz2": { + "build": "py38hdbfa776_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12d1a845c91183d36d4d6614779967bc", + "name": "geventhttpclient", + "sha256": "d2fb8f6775ed9a13421c6be34252b0f8f1ef07196268ef2ff5dd9eda69b2bff8", + "size": 107637, + "subdir": "linux-64", + "timestamp": 1636035204194, + "version": "1.3.1" + }, + "geventhttpclient-1.3.1-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d7785d112a7e990df421bf59f9db607f", + "name": "geventhttpclient", + "sha256": "c08747ad658f9ca245466c6c48230e5984000aa09a0a27b9e3969cf49b880b51", + "size": 107394, + "subdir": "linux-64", + "timestamp": 1585079511958, + "version": "1.3.1" + }, + "geventhttpclient-1.3.1-py39hdbfa776_0.tar.bz2": { + "build": "py39hdbfa776_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bef7527d8a3b840936faff3265a08980", + "name": "geventhttpclient", + "sha256": "c22d61ae7924fa50736867ece4be544575fc2f49cf0bc8223e72c75f8466659c", + "size": 107659, + "subdir": "linux-64", + "timestamp": 1636023823754, + "version": "1.3.1" + }, + "geventhttpclient-1.4.2-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87c87ed7ced8b85c0ae5975969ec17e6", + "name": "geventhttpclient", + "sha256": "a682a07ed35b75df091b0abaef5b209be62164f1e24d9296e40b7eaddab5b72e", + "size": 59469, + "subdir": "linux-64", + "timestamp": 1591811179108, + "version": "1.4.2" + }, + "geventhttpclient-1.4.2-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f107e83b8947fecc8c996b55490d2f74", + "name": "geventhttpclient", + "sha256": "9bf36657ebb3fc56d9f4e0b1d19c6b76ff4887cc2c268731a05e88bd20428dd8", + "size": 59388, + "subdir": "linux-64", + "timestamp": 1591810866551, + "version": "1.4.2" + }, + "geventhttpclient-1.4.2-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc99a6d1351ad084c96776a235f4493e", + "name": "geventhttpclient", + "sha256": "ab1c1827278c35b7762ad94bd7be3de4fffb50d0d548353219ff82f10991ed95", + "size": 59840, + "subdir": "linux-64", + "timestamp": 1591811045959, + "version": "1.4.2" + }, + "geventhttpclient-1.4.4-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "934ca91b01b5c6fecc853c792c11adf3", + "name": "geventhttpclient", + "sha256": "6ea969ae227e237687e73a8041d8336ac646298ae99a344ec80f789d43b58045", + "size": 60356, + "subdir": "linux-64", + "timestamp": 1599271884848, + "version": "1.4.4" + }, + "geventhttpclient-1.4.4-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "151a737057324cd1d10d48d9fcc7759f", + "name": "geventhttpclient", + "sha256": "d19e5f5fcbf0b49140e9685533cd01c0535bd84204fe8e49c4dcdbeba58b730f", + "size": 60363, + "subdir": "linux-64", + "timestamp": 1599271885144, + "version": "1.4.4" + }, + "geventhttpclient-1.4.4-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b03a9885bb3f101f09f1bbcfc10e3c8", + "name": "geventhttpclient", + "sha256": "53273d2a385995b2a9de252e8beccb47e09cd3a24fb5137cac9ab7c6ca417638", + "size": 60759, + "subdir": "linux-64", + "timestamp": 1599271877507, + "version": "1.4.4" + }, + "geventhttpclient-1.4.5-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d3064d38042e91a5a2d6e60dc8cd4a70", + "name": "geventhttpclient", + "sha256": "76424ef439ca14c2c434e6792f887469d29995231c52c81aeada46fbc876fb74", + "size": 94273, + "subdir": "linux-64", + "timestamp": 1640812170028, + "version": "1.4.5" + }, + "geventhttpclient-1.4.5-py311h6a678d5_1.tar.bz2": { + "build": "py311h6a678d5_1", + "build_number": 1, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a7061b25ab45e00fa2ee6fd0d6c8b52", + "name": "geventhttpclient", + "sha256": "48ff68d0a00990f961b07d507bb66e584d26a8ff6e44987f024aa48407cad32b", + "size": 75113, + "subdir": "linux-64", + "timestamp": 1676852578775, + "version": "1.4.5" + }, + "geventhttpclient-1.4.5-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48743979e44c63ba2f5d8de8185568db", + "name": "geventhttpclient", + "sha256": "447a4a9562ec3a9def8e61f713b0c6cd8489b7ebcd4d8177c4a8017fdc0ee6c3", + "size": 59349, + "subdir": "linux-64", + "timestamp": 1607366522680, + "version": "1.4.5" + }, + "geventhttpclient-1.4.5-py36h295c915_0.tar.bz2": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "05e4138d3323bdb18c16951bd23b6540", + "name": "geventhttpclient", + "sha256": "06135e0de8192ad73141d95c3e7f2657be4a9b3b11c8587e0d4476d5431db272", + "size": 61353, + "subdir": "linux-64", + "timestamp": 1632890830354, + "version": "1.4.5" + }, + "geventhttpclient-1.4.5-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc665b0f0f410c40a6bc0adbef38d24f", + "name": "geventhttpclient", + "sha256": "5139635b5bd085eed9667043e0df252508b944bbf490e9af41a4b0ce8e2a4d1e", + "size": 59294, + "subdir": "linux-64", + "timestamp": 1607366545317, + "version": "1.4.5" + }, + "geventhttpclient-1.4.5-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37c65ed84c65b7baa2a8d59cd2fa7a08", + "name": "geventhttpclient", + "sha256": "9e3ca6728cd265a9508f236762f9f79e49ccf8f408133a44db9270ac860304b5", + "size": 61306, + "subdir": "linux-64", + "timestamp": 1632891251272, + "version": "1.4.5" + }, + "geventhttpclient-1.4.5-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f18164ab683010c1c2e4652216a68e8", + "name": "geventhttpclient", + "sha256": "10b79febb4f9db5f02445347f0dba27664571dfe0e1f0e319677c8daef88e65d", + "size": 59746, + "subdir": "linux-64", + "timestamp": 1607366543008, + "version": "1.4.5" + }, + "geventhttpclient-1.4.5-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a6d75a483f3c93080b2d01f6583da0a2", + "name": "geventhttpclient", + "sha256": "05d49b3308f9daf07975017613854cb5acf1cc5379c71efe53d2430d249f18d6", + "size": 61681, + "subdir": "linux-64", + "timestamp": 1632891249758, + "version": "1.4.5" + }, + "geventhttpclient-1.4.5-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96b00e155ce1189c957ebd463f472c06", + "name": "geventhttpclient", + "sha256": "3ddf31188f6990f36cfab598148651dea2792cde0d719ed7b969f6531ef48a1b", + "size": 61731, + "subdir": "linux-64", + "timestamp": 1632891266018, + "version": "1.4.5" + }, + "gflags-2.2.1-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9450c8c77c97baa4206bd19a9146ac87", + "name": "gflags", + "sha256": "70efc0bba750a3b1b01609780273882809cddf14b50acec766beec7256afaa45", + "size": 184421, + "subdir": "linux-64", + "timestamp": 1512755419155, + "version": "2.2.1" + }, + "gflags-2.2.2-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bcb2fff3ff80e0466eb2dafc93f88fa1", + "name": "gflags", + "sha256": "bb154050063e427d00f261baa1e7884a0a2db54d57791322048296439147a89a", + "size": 164178, + "subdir": "linux-64", + "timestamp": 1542388351673, + "version": "2.2.2" + }, + "gfortran-dbg_linux-64-7.2.0-19.tar.bz2": { + "build": "19", + "build_number": 19, + "depends": [ + "binutils_linux-64 7.2.0 19", + "gcc-dbg_linux-64 7.2.0 19", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "4d3980fbe58e43e419c15361c47937eb", + "name": "gfortran-dbg_linux-64", + "sha256": "10a7061a23ce0b3a9483b980573a7a540e61f88e65a0151dd9f450c3dc6646d3", + "size": 5920, + "subdir": "linux-64", + "timestamp": 1513886593018, + "version": "7.2.0" + }, + "gfortran-dbg_linux-64-7.2.0-24.tar.bz2": { + "build": "24", + "build_number": 24, + "depends": [ + "binutils_linux-64 7.2.0 24", + "gcc-dbg_linux-64 7.2.0 24", + "gfortran_impl_linux-64 7.2.0.*", + "package_has_been_revoked" + ], + "license": "GPL", + "md5": "c624b83ee88c47db792448be1b618354", + "name": "gfortran-dbg_linux-64", + "revoked": true, + "sha256": "6bfa560a288e14eb75662ce87e2c5c35aa7e4e180578d324a8c0acd763b262ae", + "size": 5378, + "subdir": "linux-64", + "timestamp": 1514480887498, + "version": "7.2.0" + }, + "gfortran-dbg_linux-64-7.2.0-25.tar.bz2": { + "build": "25", + "build_number": 25, + "depends": [ + "binutils_linux-64 7.2.0 25", + "gcc-dbg_linux-64 7.2.0 25", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "d5d27dc693e647d4b920f4a365fc5098", + "name": "gfortran-dbg_linux-64", + "sha256": "013d5c448e332b45f4a24a65d96c0cf332378f34c3e67720adc6d3945e82152a", + "size": 5392, + "subdir": "linux-64", + "timestamp": 1515156401641, + "version": "7.2.0" + }, + "gfortran-dbg_linux-64-7.3.0-h553295d_1.tar.bz2": { + "build": "h553295d_1", + "build_number": 1, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_1", + "gcc-dbg_linux-64 7.3.0 h553295d_1", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "b529da28ac02858a5c3f606d8087672d", + "name": "gfortran-dbg_linux-64", + "sha256": "0ec10036718e79a1ffd41cc7469b6da64816cd1dc92267d696718d3e455c8bdf", + "size": 9621, + "subdir": "linux-64", + "timestamp": 1534694160118, + "version": "7.3.0" + }, + "gfortran-dbg_linux-64-7.3.0-h553295d_2.tar.bz2": { + "build": "h553295d_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_2", + "gcc-dbg_linux-64 7.3.0 h553295d_2", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "ce659a68f5b0a700f529f4486d50bdb1", + "name": "gfortran-dbg_linux-64", + "sha256": "cbf491a6a2adf631de8781577f69e31fc0d8d1cf2f02f7e33260ab5568aa132a", + "size": 9643, + "subdir": "linux-64", + "timestamp": 1534794495493, + "version": "7.3.0" + }, + "gfortran-dbg_linux-64-7.3.0-h553295d_26.tar.bz2": { + "build": "h553295d_26", + "build_number": 26, + "depends": [ + "binutils_linux-64 7.3.0 h6176602_26", + "gcc-dbg_linux-64 7.3.0 h553295d_26", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "63e88cce01391e71fb8aa427dd36f8ac", + "name": "gfortran-dbg_linux-64", + "sha256": "ff807a221fbbe9dc28b36adb870d5202c0896ae36fa322fe8c9b1882a9c7ea46", + "size": 9075, + "subdir": "linux-64", + "timestamp": 1534693905902, + "version": "7.3.0" + }, + "gfortran-dbg_linux-64-8.2.0-h218040c_1.tar.bz2": { + "build": "h218040c_1", + "build_number": 1, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_1", + "gcc-dbg_linux-64 8.2.0 h218040c_1", + "gfortran_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "d2c7691ffd304a6c31e3bbf4722eac85", + "name": "gfortran-dbg_linux-64", + "sha256": "963a38530ff135cded0663b2b7f9be0a6747a2f3ef824b04016388ceff53c7f3", + "size": 9622, + "subdir": "linux-64", + "timestamp": 1534694053005, + "version": "8.2.0" + }, + "gfortran-dbg_linux-64-8.2.0-h218040c_26.tar.bz2": { + "build": "h218040c_26", + "build_number": 26, + "depends": [ + "binutils_linux-64 8.2.0 h6176602_26", + "gcc-dbg_linux-64 8.2.0 h218040c_26", + "gfortran_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "e1008239f7977fbabd36501a9dffb551", + "name": "gfortran-dbg_linux-64", + "sha256": "aa61e990b39e13740f0d647beb038b57356debb9f27c2dadd8e8413fa7f08754", + "size": 9113, + "subdir": "linux-64", + "timestamp": 1534693821605, + "version": "8.2.0" + }, + "gfortran_impl_linux-64-11.2.0-h1234567_0.tar.bz2": { + "build": "h1234567_0", + "build_number": 0, + "depends": [ + "gcc_impl_linux-64 >=11.2.0", + "libgcc-ng >=11.2.0", + "libgcc-ng >=4.9", + "libgfortran5 >=11.2.0,<12.0a0", + "libstdcxx-ng >=4.9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "7bd038fbf08a53851c5098523a3bd389", + "name": "gfortran_impl_linux-64", + "sha256": "fff39ff42641fc3df9c8c0e5fb4996774fb2449987e72dac4a3b1c8593c70151", + "size": 12180710, + "subdir": "linux-64", + "timestamp": 1652859869476, + "version": "11.2.0" + }, + "gfortran_impl_linux-64-11.2.0-h1234567_1.tar.bz2": { + "build": "h1234567_1", + "build_number": 1, + "depends": [ + "gcc_impl_linux-64 >=11.2.0", + "libgcc-ng >=11.2.0", + "libgcc-ng >=4.9", + "libgfortran5 >=11.2.0,<12.0a0", + "libstdcxx-ng >=4.9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "0ea9ac65c1d7bf882eca7280799d178c", + "name": "gfortran_impl_linux-64", + "sha256": "13aea744efc139beebbb9cb52edbbed3bf976810ebe31c434b12b35e9286a1cf", + "size": 12256095, + "subdir": "linux-64", + "timestamp": 1654090965677, + "version": "11.2.0" + }, + "gfortran_impl_linux-64-5.4.0-hdf63c60_3.tar.bz2": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [ + "gcc_impl_linux-64 5.4.0 habb00fd_3", + "libgfortran-ng >=5.4.0,<8.0a0" + ], + "license": "GPL", + "md5": "b3cba163d6ab3680e455bb610337292e", + "name": "gfortran_impl_linux-64", + "sha256": "1579e8d9dc4d85237e630288a20e8877eba40cd723dffcf2a559b45735883c07", + "size": 8016172, + "subdir": "linux-64", + "timestamp": 1520969729994, + "version": "5.4.0" + }, + "gfortran_impl_linux-64-7.2.0-hb3c8cce_2.tar.bz2": { + "build": "hb3c8cce_2", + "build_number": 2, + "depends": [ + "gcc_impl_linux-64 7.2.0 hc5ce805_2", + "libgfortran-ng >=7.2.0,<8.0a0" + ], + "license": "GPL", + "md5": "742a4b2430433f95b7cd96923f989953", + "name": "gfortran_impl_linux-64", + "sha256": "56e669f4d81eed50bd382fb235b09b1d8a8d55786937b01f805a4ca00cb596d5", + "size": 9271887, + "subdir": "linux-64", + "timestamp": 1507263022031, + "version": "7.2.0" + }, + "gfortran_impl_linux-64-7.2.0-hdf63c60_3.tar.bz2": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [ + "gcc_impl_linux-64 7.2.0 habb00fd_3", + "libgfortran-ng >=7.2.0,<8.0a0" + ], + "license": "GPL", + "md5": "942de19cccc5764a61556ce7f425f2b7", + "name": "gfortran_impl_linux-64", + "sha256": "cc2f53b262af28f9defd6e3bd084c6506efeebb168336c854438da9620ef3502", + "size": 9283477, + "subdir": "linux-64", + "timestamp": 1520534747402, + "version": "7.2.0" + }, + "gfortran_impl_linux-64-7.3.0-hdf63c60_0.tar.bz2": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [ + "gcc_impl_linux-64 7.3.0 habb00fd_0", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7.3.0,<8.0a0" + ], + "license": "GPL", + "md5": "62197056b38398dfd903edc74d266d7b", + "name": "gfortran_impl_linux-64", + "sha256": "b473c8c081a2defde7a277b3c5fd53859def413217e49c6c324b5effbc1741e7", + "size": 9398069, + "subdir": "linux-64", + "timestamp": 1534628635931, + "version": "7.3.0" + }, + "gfortran_impl_linux-64-7.3.0-hdf63c60_1.tar.bz2": { + "build": "hdf63c60_1", + "build_number": 1, + "depends": [ + "gcc_impl_linux-64 7.3.0 habb00fd_1", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7.3.0,<8.0a0" + ], + "license": "GPL", + "md5": "a1e5cfe50c73da69b31c49c6bdc82b9a", + "name": "gfortran_impl_linux-64", + "sha256": "7e42d1108388dd54178d3581d3200d728872d210a0e888c1e92aa56c439519d9", + "size": 9390781, + "subdir": "linux-64", + "timestamp": 1534866846414, + "version": "7.3.0" + }, + "gfortran_impl_linux-64-7.5.0-ha8c8e06_17.tar.bz2": { + "build": "ha8c8e06_17", + "build_number": 17, + "depends": [ + "gcc_impl_linux-64 >=7.5.0", + "libgcc-ng >=4.9", + "libgcc-ng >=7.5.0", + "libgfortran4 >=7.5.0,<8.0a0", + "libstdcxx-ng >=4.9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "988a50589c5dfa12bbe936d09c3912be", + "name": "gfortran_impl_linux-64", + "sha256": "40b6cf129e6f5deb09461789cad7e1acec3ed814245c97e84415912eb1373bf1", + "size": 9904996, + "subdir": "linux-64", + "timestamp": 1622660259535, + "version": "7.5.0" + }, + "gfortran_impl_linux-64-8.4.0-h5ed45b9_17.tar.bz2": { + "build": "h5ed45b9_17", + "build_number": 17, + "depends": [ + "gcc_impl_linux-64 >=8.4.0", + "libgcc-ng >=4.9", + "libgcc-ng >=8.4.0", + "libgfortran5 >=8.4.0,<9.0a0", + "libstdcxx-ng >=4.9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "4c77990ff1f37768f17b0f6fff380edd", + "name": "gfortran_impl_linux-64", + "sha256": "6fd21311546f02c1dac06247337d825be46240374fc87396bfe143bbd8de70be", + "size": 10484186, + "subdir": "linux-64", + "timestamp": 1622661872136, + "version": "8.4.0" + }, + "gfortran_impl_linux-64-9.3.0-h5abd6ed_17.tar.bz2": { + "build": "h5abd6ed_17", + "build_number": 17, + "depends": [ + "gcc_impl_linux-64 >=9.3.0", + "libgcc-ng >=4.9", + "libgcc-ng >=9.3.0", + "libgfortran5 >=9.3.0,<10.0a0", + "libstdcxx-ng >=4.9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "13e4b724ad14835299a970c96cb64f44", + "name": "gfortran_impl_linux-64", + "sha256": "6aef24bc1b910ae35ad3c5966fea45f439a0a3553dce22b0eb686c6f6125c5eb", + "size": 10551808, + "subdir": "linux-64", + "timestamp": 1622663523249, + "version": "9.3.0" + }, + "gfortran_linux-64-11.2.0-hc2dff05_0.tar.bz2": { + "build": "hc2dff05_0", + "build_number": 0, + "depends": [ + "binutils_linux-64 2.38.0 hc2dff05_0", + "gcc_linux-64 11.2.0 h5c386dc_0", + "gfortran_impl_linux-64 11.2.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "2c6050d7ae6111a122bb99dabd53b4ee", + "name": "gfortran_linux-64", + "sha256": "1fb1fe5b3d1663d4eefc99af82886791b6bfa3ec98acbf367142d79795818f86", + "size": 23079, + "subdir": "linux-64", + "timestamp": 1652867216237, + "version": "11.2.0" + }, + "gfortran_linux-64-5.4.0-h98af8de_24.tar.bz2": { + "build": "h98af8de_24", + "build_number": 24, + "depends": [ + "binutils_linux-64 5.4.0 had2808c_24", + "gcc_linux-64 5.4.0 h98af8de_24", + "gfortran_impl_linux-64 5.4.0.*" + ], + "license": "GPL", + "md5": "94205138508004ee86d7960faba93bac", + "name": "gfortran_linux-64", + "sha256": "9f82290085fc13d5979d4fe4c35346c421c7c1547bb7cebf5761976a52bfacc2", + "size": 8666, + "subdir": "linux-64", + "timestamp": 1520970085933, + "version": "5.4.0" + }, + "gfortran_linux-64-7.2.0-19.tar.bz2": { + "build": "19", + "build_number": 19, + "depends": [ + "binutils_linux-64 7.2.0 19", + "gcc_linux-64 7.2.0 19", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "3c0be44d08a34ecd9a67c4c50b2d891e", + "name": "gfortran_linux-64", + "sha256": "2530dee12ac8241c36075d544bc144f180e8000ece97ac63a699e694d5f680ea", + "size": 5852, + "subdir": "linux-64", + "timestamp": 1513886715098, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-24.tar.bz2": { + "build": "24", + "build_number": 24, + "depends": [ + "package_has_been_revoked" + ], + "license": "GPL", + "md5": "77b26befa191f76ccc4d8e08870c572c", + "name": "gfortran_linux-64", + "revoked": true, + "sha256": "622e6f21f55da1159aa5f01438c8b7487ea8609fb105ae00f773df7ce57066e3", + "size": 5326, + "subdir": "linux-64", + "timestamp": 1514474639015, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-25.tar.bz2": { + "build": "25", + "build_number": 25, + "depends": [ + "binutils_linux-64 7.2.0 25", + "gcc_linux-64 7.2.0 25", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "26f416bd7f4f5847b09ca195db005e99", + "name": "gfortran_linux-64", + "sha256": "0200f5f8142f4419b52e1194cf5061ae3815a24b730920f32e70914d2465dd6c", + "size": 5382, + "subdir": "linux-64", + "timestamp": 1514480906390, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-26.tar.bz2": { + "build": "26", + "build_number": 26, + "depends": [ + "binutils_linux-64 7.2.0 26", + "gcc_linux-64 7.2.0 26", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "4f592af0894089411c44178ad29ee268", + "name": "gfortran_linux-64", + "sha256": "fe380bf6ef21802ed38da8d11c6b8ec7cee0eefb4c06fb86dfb545362aa48acf", + "size": 8794, + "subdir": "linux-64", + "timestamp": 1521829429734, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-h0d86fa5_2.tar.bz2": { + "build": "h0d86fa5_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_2", + "gcc_linux-64 7.2.0 hecb3f9c_2", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "396b894c27df2ea6788b99bb259ec1f8", + "name": "gfortran_linux-64", + "sha256": "a5345d59a50b06eee70331b1e8d00d1621357573f38bf90e04f2cb1fbf1e8c57", + "size": 5283, + "subdir": "linux-64", + "timestamp": 1507320099894, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-h36698f7_3.tar.bz2": { + "build": "h36698f7_3", + "build_number": 3, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_3", + "gcc_linux-64 7.2.0 h29fd5c9_3", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "19b8894b89252f817c6d6eb842430a91", + "name": "gfortran_linux-64", + "sha256": "b68f37674d4c3fbffd63faf4a14ad150f35531487c7667d5c4eafacf33309832", + "size": 5282, + "subdir": "linux-64", + "timestamp": 1507320236046, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-h3a66261_14.tar.bz2": { + "build": "h3a66261_14", + "build_number": 14, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_14", + "gcc_linux-64 7.2.0 hf1c97a4_14", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "d9839f8482d88504694a64819da4e57b", + "name": "gfortran_linux-64", + "sha256": "d281931310d629e283f1d6b3292a0ff902266ef48fef7d912f956b0d9be7be29", + "size": 5452, + "subdir": "linux-64", + "timestamp": 1510930964630, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-h550dcbe_27.tar.bz2": { + "build": "h550dcbe_27", + "build_number": 27, + "depends": [ + "binutils_linux-64 7.2.0 had2808c_27", + "gcc_linux-64 7.2.0 h550dcbe_27", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "f49ba3882a606e9021b82b82753ddc76", + "name": "gfortran_linux-64", + "sha256": "a61259bf4fc3e2fc0ad2b571f526d1b5e9635d80b19e916307aa996245b4e005", + "size": 8760, + "subdir": "linux-64", + "timestamp": 1526461257915, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-h6c08c0b_8.tar.bz2": { + "build": "h6c08c0b_8", + "build_number": 8, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_8", + "gcc_linux-64 7.2.0 h6f34251_8", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "8860c31910d4ddb76e5e05a1a79c35ce", + "name": "gfortran_linux-64", + "sha256": "7ea3c2a69099393793dcccf76f34f493112327eb6085cfdd04b1d022f3768f65", + "size": 5050, + "subdir": "linux-64", + "timestamp": 1509635179005, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-h6fbc3aa_9.tar.bz2": { + "build": "h6fbc3aa_9", + "build_number": 9, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_9", + "gcc_linux-64 7.2.0 h60973fd_9", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "aba44fd0a3349dba16fd88db944f9aed", + "name": "gfortran_linux-64", + "sha256": "9df10e4c0dfb5f78c85d203e0f791f410496c8868454779de754260477b69731", + "size": 5316, + "subdir": "linux-64", + "timestamp": 1509836579938, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-h939f3e1_1.tar.bz2": { + "build": "h939f3e1_1", + "build_number": 1, + "depends": [ + "gcc_linux-64 7.2.0 hc7b1ceb_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1" + ], + "license": "GPL", + "md5": "ff5e4d23150cde2d7a15a0c936578b06", + "name": "gfortran_linux-64", + "sha256": "58778bcb011e11722c991b492691c60da92ad092e63853d2ac33e8292ad2ff4e", + "size": 9275626, + "subdir": "linux-64", + "timestamp": 1505665756299, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-h9b3fb79_10.tar.bz2": { + "build": "h9b3fb79_10", + "build_number": 10, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_10", + "gcc_linux-64 7.2.0 h196ecd4_10", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "a9383a8267d98a264609609e2b78706e", + "name": "gfortran_linux-64", + "sha256": "3e62d1df2ef0b2430c858d9185cf81500044ad9dfd0ebcf14af537777bfa4221", + "size": 5219, + "subdir": "linux-64", + "timestamp": 1510244819941, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-ha0c5ce7_12.tar.bz2": { + "build": "ha0c5ce7_12", + "build_number": 12, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_12", + "gcc_linux-64 7.2.0 hd763dfe_12", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "438c0d3589e04b372f98cefaa0fdbc96", + "name": "gfortran_linux-64", + "sha256": "dbe8a29f1054222ffd32bab06c59af9e8235018f5e854d685a8c77510320081e", + "size": 5711, + "subdir": "linux-64", + "timestamp": 1510792710104, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-hbff877f_13.tar.bz2": { + "build": "hbff877f_13", + "build_number": 13, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_13", + "gcc_linux-64 7.2.0 h217957b_13", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "0a823ca0d4a44e1b2c50b464a60c33c5", + "name": "gfortran_linux-64", + "sha256": "0912ff1132fbd7bf22fe1c14b1f511bd1122dadf8c488d7c31e11f229dcaf70c", + "size": 5458, + "subdir": "linux-64", + "timestamp": 1510925048763, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-hc3a7fdf_7.tar.bz2": { + "build": "hc3a7fdf_7", + "build_number": 7, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_7", + "gcc_linux-64 7.2.0 h22f992b_7", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "a27f5a4fe0da513c3063286689571053", + "name": "gfortran_linux-64", + "sha256": "413163f40c881b5dd061f46a8d1d447e30313d56f5c268036a25814f223a2b6f", + "size": 5103, + "subdir": "linux-64", + "timestamp": 1507845399821, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-hc6796cf_11.tar.bz2": { + "build": "hc6796cf_11", + "build_number": 11, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_11", + "gcc_linux-64 7.2.0 h4118e58_11", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "43d13ae1535c004dc6d5d87138d89d08", + "name": "gfortran_linux-64", + "sha256": "e6af95dbc23a5ff3a5829f6c59287ab4d90bb9755d0ceb9ce1c3fd32564e4a2a", + "size": 5291, + "subdir": "linux-64", + "timestamp": 1510566119764, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-hd729bf5_15.tar.bz2": { + "build": "hd729bf5_15", + "build_number": 15, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_15", + "gcc_linux-64 7.2.0 haf1f6fa_15", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "48e9b17e488547c84c1035a3cd6bd4a8", + "name": "gfortran_linux-64", + "sha256": "358ab6ea7da8c5e46f9f9cec8df8a6ab30ec382bae1217624909fb0f85915f15", + "size": 5461, + "subdir": "linux-64", + "timestamp": 1511640859457, + "version": "7.2.0" + }, + "gfortran_linux-64-7.3.0-h553295d_15.tar.bz2": { + "build": "h553295d_15", + "build_number": 15, + "depends": [ + "binutils_linux-64 2.33.1 h9595d00_15", + "gcc_linux-64 7.3.0 h553295d_15", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "BSD-3-Clause", + "md5": "9da10d196a928c75260cd103dda59ba0", + "name": "gfortran_linux-64", + "sha256": "31d2f87618beb775706352df2d58bd2c5b6492ecfb7ceb24ede67d721a23caf2", + "size": 25104, + "subdir": "linux-64", + "timestamp": 1576707756158, + "version": "7.3.0" + }, + "gfortran_linux-64-7.3.0-h553295d_2.tar.bz2": { + "build": "h553295d_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_2", + "gcc_linux-64 7.3.0 h553295d_2", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "d07250b4cd868f0f89af1e97ec97ccf5", + "name": "gfortran_linux-64", + "sha256": "53a44cbc88e79069d0f066a34646665e3054fb611e42f7fc3b4b51b1f7dcc6c1", + "size": 9682, + "subdir": "linux-64", + "timestamp": 1534793056069, + "version": "7.3.0" + }, + "gfortran_linux-64-7.3.0-h553295d_3.tar.bz2": { + "build": "h553295d_3", + "build_number": 3, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_3", + "gcc_linux-64 7.3.0 h553295d_3", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "2e21ef05f53b2163e2165ac21b9f5383", + "name": "gfortran_linux-64", + "sha256": "708fa29bc01372cf59da093184518d52c7244d576ca32891b0693c7e5bc1a1d9", + "size": 9696, + "subdir": "linux-64", + "timestamp": 1534948645368, + "version": "7.3.0" + }, + "gfortran_linux-64-7.3.0-h553295d_6.tar.bz2": { + "build": "h553295d_6", + "build_number": 6, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_6", + "gcc_linux-64 7.3.0 h553295d_6", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "fa280f4eaef41c5456ef336b0dece6df", + "name": "gfortran_linux-64", + "sha256": "1c9fa136d79d0010906459b419f7e8458676e942f92e90d6738e85a186c2120a", + "size": 10602, + "subdir": "linux-64", + "timestamp": 1546883613464, + "version": "7.3.0" + }, + "gfortran_linux-64-7.3.0-h553295d_7.tar.bz2": { + "build": "h553295d_7", + "build_number": 7, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_7", + "gcc_linux-64 7.3.0 h553295d_7", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "cf0a442305ab8220a18d1698f789ad73", + "name": "gfortran_linux-64", + "sha256": "e4448c9819248339e3f995892cea81d353adac0b5d90f5126b0a73dffe8de66b", + "size": 9790, + "subdir": "linux-64", + "timestamp": 1556137067538, + "version": "7.3.0" + }, + "gfortran_linux-64-7.3.0-h553295d_8.tar.bz2": { + "build": "h553295d_8", + "build_number": 8, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_8", + "gcc_linux-64 7.3.0 h553295d_8", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "a61e669f20a650722da759b57851de3a", + "name": "gfortran_linux-64", + "sha256": "fecdfb3771541af94fca61ffa79152a9928d1d5abaa35dec184d9c8ae3d330f5", + "size": 152013, + "subdir": "linux-64", + "timestamp": 1565123587560, + "version": "7.3.0" + }, + "gfortran_linux-64-7.3.0-h553295d_9.tar.bz2": { + "build": "h553295d_9", + "build_number": 9, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_9", + "gcc_linux-64 7.3.0 h553295d_9", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "BSD-3-Clause", + "md5": "eaf83f11bd8da869066025726337caae", + "name": "gfortran_linux-64", + "sha256": "dd811b06adfee416cb87b2df5db635802ca7447042514f9954aa393c854cd037", + "size": 25085, + "subdir": "linux-64", + "timestamp": 1576689715188, + "version": "7.3.0" + }, + "gfortran_linux-64-7.5.0-h96bb648_30.tar.bz2": { + "build": "h96bb648_30", + "build_number": 30, + "depends": [ + "binutils_linux-64 2.35.1 h454624a_30", + "gcc_linux-64 7.5.0 h8f34230_30", + "gfortran_impl_linux-64 7.5.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "ce6af51e6017ee8b1aaaa86318dc671e", + "name": "gfortran_linux-64", + "sha256": "8e39a7c655bb96d1254ad31d6679e27f834ed39e23a2e4480ff1878ca3783434", + "size": 22777, + "subdir": "linux-64", + "timestamp": 1623135029770, + "version": "7.5.0" + }, + "gfortran_linux-64-8.2.0-h218040c_2.tar.bz2": { + "build": "h218040c_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_2", + "gcc_linux-64 8.2.0 h218040c_2", + "gfortran_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "122088e1b50cd662e41864ad2050b359", + "name": "gfortran_linux-64", + "sha256": "0225e8f354dd5cae61cfee855c1aa2646616730b486beb9f86853ac6ad32087f", + "size": 9681, + "subdir": "linux-64", + "timestamp": 1534792662978, + "version": "8.2.0" + }, + "gfortran_linux-64-8.2.0-h218040c_3.tar.bz2": { + "build": "h218040c_3", + "build_number": 3, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_3", + "gcc_linux-64 8.2.0 h218040c_3", + "gfortran_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "e0b8c580572a837d9328410312721e09", + "name": "gfortran_linux-64", + "sha256": "cd2315165dce9011e27c4bbafd2c857f804400f8f697d8c05c2d84b2ec9f5854", + "size": 10628, + "subdir": "linux-64", + "timestamp": 1546883590891, + "version": "8.2.0" + }, + "gfortran_linux-64-8.4.0-h65c0feb_30.tar.bz2": { + "build": "h65c0feb_30", + "build_number": 30, + "depends": [ + "binutils_linux-64 2.35.1 h454624a_30", + "gcc_linux-64 8.4.0 he201b7d_30", + "gfortran_impl_linux-64 8.4.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "83dbb8ad34ee93a40cbdd722dbfc5d1c", + "name": "gfortran_linux-64", + "sha256": "c3e9a160f7ad17b2b6cd6bde2914f54e21c5ab808ae0d18cb61fb6677f5e13da", + "size": 22786, + "subdir": "linux-64", + "timestamp": 1623135564464, + "version": "8.4.0" + }, + "gfortran_linux-64-9.3.0-hf47db2c_30.tar.bz2": { + "build": "hf47db2c_30", + "build_number": 30, + "depends": [ + "binutils_linux-64 2.35.1 h454624a_30", + "gcc_linux-64 9.3.0 h1ee779e_30", + "gfortran_impl_linux-64 9.3.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "a386d907fc79f09a8178adfa414a4fc7", + "name": "gfortran_linux-64", + "sha256": "4546c6a606bfdd50970b3c0e6e5ab98016a9542efbe1a9f76b9c87265a4c6fa2", + "size": 22769, + "subdir": "linux-64", + "timestamp": 1623136139292, + "version": "9.3.0" + }, + "ghc-8.2.2-h4c737dc_1003.tar.bz2": { + "build": "h4c737dc_1003", + "build_number": 1003, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9c192a3f67f9b7d8e88a2a60f130f145", + "name": "ghc", + "sha256": "9a0417d8a8ea963048d9c3e37d510b7bc831439344b2e888c4163cea18aaad98", + "size": 184181171, + "subdir": "linux-64", + "timestamp": 1620299799676, + "version": "8.2.2" + }, + "gi-docgen-2022.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "markdown", + "markupsafe", + "pygments", + "python >=3.10,<3.11.0a0", + "toml", + "typogrify" + ], + "license": "GPL-3.0-or-later AND Apache-2.0 AND CC0-1.0", + "license_family": "GPL", + "md5": "ca900b0d315150e8a3899ce7ea549664", + "name": "gi-docgen", + "sha256": "3f3d92dfe7e5172313bfbf334cbb73df27954057786b0f582732fe7c39f297e0", + "size": 1307232, + "subdir": "linux-64", + "timestamp": 1677600369373, + "version": "2022.1" + }, + "gi-docgen-2022.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "markdown", + "markupsafe", + "pygments", + "python >=3.11,<3.12.0a0", + "toml", + "typogrify" + ], + "license": "Apache Software License or GNU General Public v3 or later (GPLv3+)", + "license_family": "GPL3", + "md5": "d694cac99a22aece6eceedb9f7a8c93b", + "name": "gi-docgen", + "sha256": "9637628f75ccf2dd476b5a728668f0a4fdb55ab6a0f8b1ce042d445f869d7b87", + "size": 1331628, + "subdir": "linux-64", + "timestamp": 1677686983474, + "version": "2022.1" + }, + "gi-docgen-2022.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "markdown", + "markupsafe", + "pygments", + "python >=3.7,<3.8.0a0", + "toml", + "typogrify" + ], + "license": "GPL-3.0-or-later AND Apache-2.0 AND CC0-1.0", + "license_family": "GPL", + "md5": "fe953aeb2174ec003b50691c56f0d4b0", + "name": "gi-docgen", + "sha256": "59b572bed215944637f399b9e53900f52f105399e6652d72c00448fe7e8609d3", + "size": 1304092, + "subdir": "linux-64", + "timestamp": 1677600339621, + "version": "2022.1" + }, + "gi-docgen-2022.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "markdown", + "markupsafe", + "pygments", + "python >=3.8,<3.9.0a0", + "toml", + "typogrify" + ], + "license": "GPL-3.0-or-later AND Apache-2.0 AND CC0-1.0", + "license_family": "GPL", + "md5": "aa046fc9fe18618c64866dd4baf6cb25", + "name": "gi-docgen", + "sha256": "5e93f0d284d7d5613f949d4d56918cdf19017917a0ced1dd227fd8520a7d0531", + "size": 1304816, + "subdir": "linux-64", + "timestamp": 1677600277597, + "version": "2022.1" + }, + "gi-docgen-2022.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "markdown", + "markupsafe", + "pygments", + "python >=3.9,<3.10.0a0", + "toml", + "typogrify" + ], + "license": "GPL-3.0-or-later AND Apache-2.0 AND CC0-1.0", + "license_family": "GPL", + "md5": "485c4fff6664c445037ebdb5e766e052", + "name": "gi-docgen", + "sha256": "133e6bd970d6b8c00147c4e4a3789a8dc580634a20b4fc697ee50349448e5dce", + "size": 1307187, + "subdir": "linux-64", + "timestamp": 1677600307612, + "version": "2022.1" + }, + "giflib-5.1.4-h14c3975_1.tar.bz2": { + "build": "h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "b568f550b44c200fa29e80ae243de83a", + "name": "giflib", + "sha256": "9b68871a18d4b47f378ad7566be62dadfac90bc562cf92b848baab35e0446724", + "size": 79609, + "subdir": "linux-64", + "timestamp": 1530868405704, + "version": "5.1.4" + }, + "giflib-5.1.4-h26a3ec6_1.tar.bz2": { + "build": "h26a3ec6_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "bebf6b7f988bcf4522c23df5334eb444", + "name": "giflib", + "sha256": "1f996855c8b383a3186decdf2620d40d82e2b5ca978e306208ab301de6e5d4d8", + "size": 79604, + "subdir": "linux-64", + "timestamp": 1511371539652, + "version": "5.1.4" + }, + "giflib-5.1.4-ha764e47_1.tar.bz2": { + "build": "ha764e47_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "149d6cfd3c1ba6e8b425195ce9753df8", + "name": "giflib", + "sha256": "d0e576c3c038d4d1670c5e938f1c7675e7854bd249a3d20a4e558c20b60567b2", + "size": 79639, + "subdir": "linux-64", + "timestamp": 1509378873674, + "version": "5.1.4" + }, + "giflib-5.2.1-h5eee18b_1.tar.bz2": { + "build": "h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "md5": "e1f6343a7093d3785bb7f44a11566071", + "name": "giflib", + "sha256": "e7963d598a812ad002c97e3cd893ecaab0dcfb652d3160400242032ef3e40593", + "size": 73334, + "subdir": "linux-64", + "timestamp": 1674666766879, + "version": "5.2.1" + }, + "giflib-5.2.1-h5eee18b_2.tar.bz2": { + "build": "h5eee18b_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52cf815e902487ed38d8c784a80d3e66", + "name": "giflib", + "sha256": "29b8028b3fbef43b6f9bcba5dc2a8ca4d49ec86cd410f1f584747f8a4123a52f", + "size": 78518, + "subdir": "linux-64", + "timestamp": 1676976716663, + "version": "5.2.1" + }, + "giflib-5.2.1-h5eee18b_3.tar.bz2": { + "build": "h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6485f51176cf651b3b28c3548cef10ad", + "name": "giflib", + "sha256": "c323a9800a358c178f6f3b8860bbb77c373fbc3be981bb6420175fbb5431adf5", + "size": 78533, + "subdir": "linux-64", + "timestamp": 1676983203797, + "version": "5.2.1" + }, + "giflib-5.2.1-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "md5": "299bf4271d710651a1d71d3795580c2d", + "name": "giflib", + "sha256": "3c8ece1a7257b1d45f8fa25f46504bb709a1923d7175f2996e891366ec434b9d", + "size": 83592, + "subdir": "linux-64", + "timestamp": 1603192039050, + "version": "5.2.1" + }, + "git-2.14.1-pl526h58e4575_2.tar.bz2": { + "build": "pl526h58e4575_2", + "build_number": 2, + "depends": [ + "curl", + "expat", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "perl 5.*", + "tk 8.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "3f6c7e1eedbc412753c09ba9225a75fb", + "name": "git", + "namespace": "global", + "sha256": "2b6647184bfc9c35c1a8df62488bf1b16b2729306d669014dfa630a2be4b6791", + "size": 11798295, + "subdir": "linux-64", + "timestamp": 1505742602911, + "version": "2.14.1" + }, + "git-2.15.0-pl526h838b92b_0.tar.bz2": { + "build": "pl526h838b92b_0", + "build_number": 0, + "depends": [ + "curl", + "expat", + "expat >=2.2.5,<3.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "perl 5.*", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "fbc744ec1134d33fb57baf80a6c73a89", + "name": "git", + "namespace": "global", + "sha256": "bc338cc52d2118843d7a9069b245e74c928ab0c6d66c4b4c0d001c9361167238", + "size": 12234675, + "subdir": "linux-64", + "timestamp": 1510699319939, + "version": "2.15.0" + }, + "git-2.16.1-hb75a9fb_0.tar.bz2": { + "build": "hb75a9fb_0", + "build_number": 0, + "depends": [ + "expat >=2.2.5,<3.0a0", + "libcurl >=7.57.0,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2n,<1.0.3a", + "perl 5.*", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "15b1b2dd7e5c77b036c6d178e2be47be", + "name": "git", + "namespace": "global", + "sha256": "75cc46822516f7c7f07a791ea7281943cd4eacc1284fe736467ab81c0f98fcc9", + "size": 12338869, + "subdir": "linux-64", + "timestamp": 1516814671815, + "version": "2.16.1" + }, + "git-2.16.1-pl526hb75a9fb_1.tar.bz2": { + "build": "pl526hb75a9fb_1", + "build_number": 1, + "depends": [ + "expat >=2.2.5,<3.0a0", + "libcurl >=7.58.0,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2n,<1.0.3a", + "perl 5.*", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "15a699454be663e6ee0b6fb8d07801bf", + "name": "git", + "namespace": "global", + "sha256": "e141c544c013988f0ae3456fcca262a0024c55dc4d48ad0228352c72d66c3e3b", + "size": 12339634, + "subdir": "linux-64", + "timestamp": 1519073519659, + "version": "2.16.1" + }, + "git-2.17.0-pl526hb75a9fb_0.tar.bz2": { + "build": "pl526hb75a9fb_0", + "build_number": 0, + "depends": [ + "expat >=2.2.5,<3.0a0", + "libcurl >=7.59.0,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "perl 5.*", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "d22a015cde6e1f95ece43f0d06c84d8b", + "name": "git", + "namespace": "global", + "sha256": "9ef3d8cc91f4ae816475e5f724e3dd47a4c0254b4e2383cebe3e73bde39cf5e0", + "size": 12763044, + "subdir": "linux-64", + "timestamp": 1523306827090, + "version": "2.17.0" + }, + "git-2.17.1-pl526hb37396a_0.tar.bz2": { + "build": "pl526hb37396a_0", + "build_number": 0, + "depends": [ + "expat >=2.2.5,<3.0a0", + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "perl 5.*", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "7200a1d36ffd6cf4e6d296407027e295", + "name": "git", + "namespace": "global", + "sha256": "254af9a698acc669b7968af259b9e143d314c2001efeec314f880e62488be1fa", + "size": 12957833, + "subdir": "linux-64", + "timestamp": 1529247849731, + "version": "2.17.1" + }, + "git-2.18.0-pl526hb37396a_0.tar.bz2": { + "build": "pl526hb37396a_0", + "build_number": 0, + "depends": [ + "expat >=2.2.5,<3.0a0", + "libcurl >=7.61.0,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "perl 5.*", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "c01cf57df93030abce13ca651b852c86", + "name": "git", + "namespace": "global", + "sha256": "cc9b7be0c69021eebf68f49db56764f18ad2e418fdc93709ab64898715c64474", + "size": 12140468, + "subdir": "linux-64", + "timestamp": 1533675527769, + "version": "2.18.0" + }, + "git-2.19.1-pl526h7fee0ce_0.tar.bz2": { + "build": "pl526h7fee0ce_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "libcurl >=7.61.1,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a", + "perl 5.*", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "f626e9d9f95d9a9323decda0cfc9c7f6", + "name": "git", + "namespace": "global", + "sha256": "3f7703d5f08a8631a4a05046de195fa3f5ef85e323762317c0003a372f24791d", + "size": 11983602, + "subdir": "linux-64", + "timestamp": 1539147443148, + "version": "2.19.1" + }, + "git-2.19.1-pl526hacde149_0.tar.bz2": { + "build": "pl526hacde149_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "libcurl >=7.61.1,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "perl 5.*", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "b8568ae4783971d4779c0148b5f8d930", + "name": "git", + "namespace": "global", + "sha256": "78756472368948c7525e038929d01c845afb57750ee1aae683ed3b0a3b7750ca", + "size": 11984064, + "subdir": "linux-64", + "timestamp": 1539969882324, + "version": "2.19.1" + }, + "git-2.20.1-pl526hacde149_0.tar.bz2": { + "build": "pl526hacde149_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "libcurl >=7.63.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "perl 5.*", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "94c6e0ae30678985cbe027ac56ee6a98", + "name": "git", + "namespace": "global", + "sha256": "7a7b9780653b0b18721ad1fead2b211294bd432416babf6fdfb4ba4da0241b3a", + "size": 8315333, + "subdir": "linux-64", + "timestamp": 1548311457032, + "version": "2.20.1" + }, + "git-2.23.0-pl526hacde149_0.tar.bz2": { + "build": "pl526hacde149_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "libcurl >=7.65.3,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "pcre >=8.43,<9.0a0", + "perl 5.*", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "ca354c13f6037ea75f7a01f9f86cb4f4", + "name": "git", + "namespace": "global", + "sha256": "1b8c01260c886bea202b76295b8beb70c69a9916eb0b7e46e0ce579afbd8c954", + "size": 11080135, + "subdir": "linux-64", + "timestamp": 1572030249779, + "version": "2.23.0" + }, + "git-2.32.0-pl5262hc120c5b_1.tar.bz2": { + "build": "pl5262hc120c5b_1", + "build_number": 1, + "depends": [ + "curl", + "expat >=2.2.10,<3.0a0", + "gettext", + "libgcc-ng >=7.5.0", + "libiconv", + "openssl >=1.1.1k,<1.1.2a", + "pcre2 >=10.35,<10.36.0a0", + "perl 5.*", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later and LGPL-2.1-or-later", + "md5": "0fbdb79a3f8d25109faedd076422512f", + "name": "git", + "namespace": "global", + "sha256": "cbdcee94eb61596fcad74e8fd5ae01a6344f87cefcefd8c98f50c3285cfbfdf5", + "size": 13571784, + "subdir": "linux-64", + "timestamp": 1628849197344, + "version": "2.32.0" + }, + "git-2.34.1-pl5262hc120c5b_0.tar.bz2": { + "build": "pl5262hc120c5b_0", + "build_number": 0, + "depends": [ + "curl", + "expat >=2.2.10,<3.0a0", + "gettext", + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1m,<1.1.2a", + "pcre2 >=10.37,<10.38.0a0", + "perl 5.*", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later and LGPL-2.1-or-later", + "md5": "be5ae977ec85cd6bbb50a864f70bcbf8", + "name": "git", + "namespace": "global", + "sha256": "41af362ec00b64a6253691ab21fdf0b5915bcd0f0fb61b28212c2dc058150c43", + "size": 13886995, + "subdir": "linux-64", + "timestamp": 1641997303674, + "version": "2.34.1" + }, + "git-lfs-2.13.2-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MIT", + "md5": "881518a1e8383558c9fde21e2e4ebd98", + "name": "git-lfs", + "sha256": "2ba0e82a29e95d5bc328457d6dafec7ec7a3e0e30f9b345549c391d84eac39f0", + "size": 4293382, + "subdir": "linux-64", + "timestamp": 1610639278970, + "version": "2.13.2" + }, + "git-lfs-2.13.2-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f907c9b34895132115f375936cc85e5", + "name": "git-lfs", + "sha256": "ea4d7b449f7fc8f7064c08d65f759d18c654b3fa939d6f8d36400e4b4934a497", + "size": 6945320, + "subdir": "linux-64", + "timestamp": 1610563424033, + "version": "2.13.2" + }, + "git-lfs-2.13.3-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MIT", + "license_family": "MIT", + "md5": "fe909d6430c60e43b62be9c575a17ef1", + "name": "git-lfs", + "sha256": "fcea49b7643cffd6ae524284b0ea3f66c7845b0d83163e00dbfad835192556ad", + "size": 3634706, + "subdir": "linux-64", + "timestamp": 1622195800346, + "version": "2.13.3" + }, + "git-lfs-2.5.2-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d607dfd832e7338ac29447e6a37f0f28", + "name": "git-lfs", + "sha256": "131b91425a5305abb54e500f1c5624a16de125c7c4e86af60bfedf3181ad0cad", + "size": 3865989, + "subdir": "linux-64", + "timestamp": 1537382432430, + "version": "2.5.2" + }, + "git-lfs-2.6.1-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08c5150d1a91cb41cb49506742c193e0", + "name": "git-lfs", + "sha256": "5655d3a0fabf8e1f9200f49aaa13d78edbf3831d3dd83d7246d53ea41e5e1311", + "size": 5558651, + "subdir": "linux-64", + "timestamp": 1547231035591, + "version": "2.6.1" + }, + "gitdb2-2.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "87af39f25d641885f770da35351238c1", + "name": "gitdb2", + "sha256": "372d732170659451eec51e98a5a74146a1c11660a9b825266ac4ad5c8075a16b", + "size": 83653, + "subdir": "linux-64", + "timestamp": 1522881964888, + "version": "2.0.3" + }, + "gitdb2-2.0.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7654e695ffef425d02530a4344ac2cb5", + "name": "gitdb2", + "sha256": "110cda32f3772a91771bf37dd472330329e1891477b5ffde40a6e1799c1c662a", + "size": 86015, + "subdir": "linux-64", + "timestamp": 1522881966312, + "version": "2.0.3" + }, + "gitdb2-2.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fcbace749cf1ea826b7da89938442653", + "name": "gitdb2", + "sha256": "692b58e1b488021d23e9a87a4beef47325d769e81e82571b32fae5961674c0ca", + "size": 85871, + "subdir": "linux-64", + "timestamp": 1522881976331, + "version": "2.0.3" + }, + "gitdb2-2.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "35485f388f7a01c56d1c09dc15ff585b", + "name": "gitdb2", + "sha256": "4501ebdced7aa8b1012539f25d353e2178b835c13b4a118516ada84fcf04e5e6", + "size": 87088, + "subdir": "linux-64", + "timestamp": 1530890683881, + "version": "2.0.3" + }, + "gitdb2-2.0.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fdb7d897777eb5c1993cb02a5cca7035", + "name": "gitdb2", + "sha256": "01d0193839a3935ddf6d88d24c07017b2df6f47de7a24117ed8653a34c382c90", + "size": 83649, + "subdir": "linux-64", + "timestamp": 1535426214104, + "version": "2.0.4" + }, + "gitdb2-2.0.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "47447565564d361ddd638baf825674db", + "name": "gitdb2", + "sha256": "fdf2f914e33485ad4651a140558073f01588a7449003ff0e91fc070ddca39aff", + "size": 85953, + "subdir": "linux-64", + "timestamp": 1535426223816, + "version": "2.0.4" + }, + "gitdb2-2.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5710f8c89cac1c3724440c632b790ca4", + "name": "gitdb2", + "sha256": "efef5dc5e88e8ca82f4cb68724a6357b55cf92a0366f2af82ffe23b1f00b0d77", + "size": 85780, + "subdir": "linux-64", + "timestamp": 1535426182740, + "version": "2.0.4" + }, + "gitdb2-2.0.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fa96d54bfc5e04bce0a2a6088b91d3a9", + "name": "gitdb2", + "sha256": "421c3762f1dcfbf912bf2224a6d17119ef8e997a024d1d7135ef9e91aab31401", + "size": 85715, + "subdir": "linux-64", + "timestamp": 1535426253499, + "version": "2.0.4" + }, + "gitdb2-2.0.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dab59c0f573230ab06761d2205a3d00f", + "name": "gitdb2", + "sha256": "5efbb2583ed79ba0a388458d3c412399e7528990545354c9366dfb0fc1797332", + "size": 85955, + "subdir": "linux-64", + "timestamp": 1539661246044, + "version": "2.0.5" + }, + "gitdb2-2.0.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "afbc9f5d484ce7a0a76487d5b4bba06a", + "name": "gitdb2", + "sha256": "08f156463b1a3e34af0e72c6ab7439119beac756f071e8757bfc8297d5b87182", + "size": 88114, + "subdir": "linux-64", + "timestamp": 1539661245617, + "version": "2.0.5" + }, + "gitdb2-2.0.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4aaea1b7d6b81b56e0700a1830299797", + "name": "gitdb2", + "sha256": "2f3a10d07ce63a76874b084cb9a3b9449e56b069cd827bb82210c1452026719e", + "size": 88052, + "subdir": "linux-64", + "timestamp": 1539661254827, + "version": "2.0.5" + }, + "gitpython-2.1.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d1e94d7f70125ac57e4b4f47e152dcad", + "name": "gitpython", + "sha256": "879ef069ee3af28ab98533d9fc0f79a555cb2def6ad81ff328305e2bb305a993", + "size": 508122, + "subdir": "linux-64", + "timestamp": 1527642576086, + "version": "2.1.10" + }, + "gitpython-2.1.10-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b3a541efd90ecdd7203087f45dbc1d12", + "name": "gitpython", + "sha256": "2824de73a1caaa1fbd576a1ab0f3dafade917d519f2895b75187e3fe3898d3af", + "size": 517334, + "subdir": "linux-64", + "timestamp": 1527642601566, + "version": "2.1.10" + }, + "gitpython-2.1.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "df9346c240116077bc071e88d244b083", + "name": "gitpython", + "sha256": "375d9706c6d5c030341306a1794d078b7612272faf41805ea460fa6e28fdc43c", + "size": 517179, + "subdir": "linux-64", + "timestamp": 1527642546425, + "version": "2.1.10" + }, + "gitpython-2.1.10-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d5614790ea934c8bd6bc3cb9f3ba58c1", + "name": "gitpython", + "sha256": "a5597c2fd896c5677ca6fb424f47ba294ea1492a231f7082747c2a98f573ea4d", + "size": 517263, + "subdir": "linux-64", + "timestamp": 1530890717348, + "version": "2.1.10" + }, + "gitpython-2.1.11-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d9c17825766285076d23bedeb70279b6", + "name": "gitpython", + "sha256": "2d24ec6e0f1d60fb6844d879f8f834d2b530b3b3c7138f58343fdf2d08725c76", + "size": 508108, + "subdir": "linux-64", + "timestamp": 1532629753823, + "version": "2.1.11" + }, + "gitpython-2.1.11-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b325b183e14a32566aa7ee4af3be7fc7", + "name": "gitpython", + "sha256": "c3ee68f0cca78c2a5e2f838295176e364b969679802c593167647afb2b0007bb", + "size": 516948, + "subdir": "linux-64", + "timestamp": 1532629801287, + "version": "2.1.11" + }, + "gitpython-2.1.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ab6beb45fe615093504c92319ce9a0dc", + "name": "gitpython", + "sha256": "481beb484edebff245f71f6a80c006022d62c1125e36119b7340721dac439a23", + "size": 517328, + "subdir": "linux-64", + "timestamp": 1532629710625, + "version": "2.1.11" + }, + "gitpython-2.1.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "da4e7128158acecd196dbee52438a4aa", + "name": "gitpython", + "sha256": "b75e88536e7a2a3a2f3aaf36a1ac4da22aa65bf43437276da5d3ea994332a52e", + "size": 517512, + "subdir": "linux-64", + "timestamp": 1532629798513, + "version": "2.1.11" + }, + "gitpython-2.1.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c222b2f3dffd11912bb9c4ef1b52cfce", + "name": "gitpython", + "sha256": "9d92589d7d0aef55bdd05c64c5a7fb2989e2f3aa30fbc7632638a763f8ba026d", + "size": 494033, + "subdir": "linux-64", + "timestamp": 1522778050709, + "version": "2.1.5" + }, + "gitpython-2.1.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bad14c873280884b2c4446f883ea9ef7", + "name": "gitpython", + "sha256": "956c362361d8806e7951a7066d61d5bbea1b0dbf6c6fcc1125892d570042da4c", + "size": 503652, + "subdir": "linux-64", + "timestamp": 1522778083279, + "version": "2.1.5" + }, + "gitpython-2.1.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c7d60c34e256ef43ebbe53b3067f3e14", + "name": "gitpython", + "sha256": "97e0e7320e0a43b282c3ab28e93a1314e51f7afa78f47e93bc99bf2fba0ba872", + "size": 502837, + "subdir": "linux-64", + "timestamp": 1522778002208, + "version": "2.1.5" + }, + "gitpython-2.1.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a81ed01b4f28de0f9b2b2342a64fd6ef", + "name": "gitpython", + "sha256": "9701d2bff137f95e281edcfec1b994538bf663a11c9531fe4eddb42e96125e16", + "size": 498295, + "subdir": "linux-64", + "timestamp": 1522782218281, + "version": "2.1.8" + }, + "gitpython-2.1.8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4170db303025d12c37fe1d97aa0ea4d6", + "name": "gitpython", + "sha256": "d9eb08a6bad997b655e9f60f6c0e48cd4a80a7b52dafbd62b4c9c255064c2482", + "size": 509962, + "subdir": "linux-64", + "timestamp": 1522782242186, + "version": "2.1.8" + }, + "gitpython-2.1.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1bd60c5cbc5d40153e1ad15468f3e658", + "name": "gitpython", + "sha256": "d5379811a2b6084288aa211e643f3506f7ef64e8d0f185a769c523f61d77b43a", + "size": 511073, + "subdir": "linux-64", + "timestamp": 1522782215232, + "version": "2.1.8" + }, + "gitpython-2.1.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "301e1b6bce3927ee60debd079b58fe71", + "name": "gitpython", + "sha256": "af8d2752153da255c718f8ab5b2e0a627920f4cb8622e7c6b3f84b35ae48df5b", + "size": 497594, + "subdir": "linux-64", + "timestamp": 1522783953595, + "version": "2.1.9" + }, + "gitpython-2.1.9-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "869956a37eaba173109a3b64b459add6", + "name": "gitpython", + "sha256": "c254ab2dc9bbb98d6c2bae78ec2c59d93b3d90421bb933eb48f70b085504c4cc", + "size": 509379, + "subdir": "linux-64", + "timestamp": 1522783428511, + "version": "2.1.9" + }, + "gitpython-2.1.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bce68c26e0c9f6422f1c30610f381612", + "name": "gitpython", + "sha256": "c21a5040ce918c3cc1834864c64c7e8602115402cb3ee566e9d892f3239a1c2b", + "size": 508588, + "subdir": "linux-64", + "timestamp": 1522783430790, + "version": "2.1.9" + }, + "gitpython-3.1.30-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "gitdb >=4.0.1,<5", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1ac1d6f6f5394e6d2a4fba3b94c1318e", + "name": "gitpython", + "sha256": "b5466db5f15efbfc369db817eb7b31fbc499fcbe57070efb53ca893a884d316d", + "size": 261197, + "subdir": "linux-64", + "timestamp": 1674662848129, + "version": "3.1.30" + }, + "gitpython-3.1.30-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "gitdb >=4.0.1,<5", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d1f866a089646209e61fe69bf58be8b5", + "name": "gitpython", + "sha256": "72ef77d4ecfba0db11b15d5f44dc69982fed7140ee5ee47d1232396fcee51f60", + "size": 348030, + "subdir": "linux-64", + "timestamp": 1676830573119, + "version": "3.1.30" + }, + "gitpython-3.1.30-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "gitdb >=4.0.1,<5", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6843ab465fa4e37a8da42f716ee1f430", + "name": "gitpython", + "sha256": "eb0aed97646bd3bfab4c81898729dcf5763318c57afa457de2ac263daf5197fb", + "size": 257055, + "subdir": "linux-64", + "timestamp": 1674662819097, + "version": "3.1.30" + }, + "gitpython-3.1.30-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "gitdb >=4.0.1,<5", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6ecaf76f8f792879a2f05bc41e0a5b4e", + "name": "gitpython", + "sha256": "6cbf98233fc97fc200b0abae437f7d48cce7e2c90892836d35f99b23220ea85c", + "size": 257836, + "subdir": "linux-64", + "timestamp": 1674662874859, + "version": "3.1.30" + }, + "gitpython-3.1.30-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "gitdb >=4.0.1,<5", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a7dae4f56e54f39428de3b3191b9e9a5", + "name": "gitpython", + "sha256": "d104cf483fcdc1e7ad5704490dba7a4cea7b45ceca9dea29e103664ce807aba4", + "size": 258036, + "subdir": "linux-64", + "timestamp": 1674662901951, + "version": "3.1.30" + }, + "gl2ps-1.4.2-h70c0345_0.tar.bz2": { + "build": "h70c0345_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "dd799c50fe6bee7080eddd2806df08b8", + "name": "gl2ps", + "sha256": "90961db498cb3fc1eab7897eac656fbdff51510fdc8dde40781d31430c2f1db3", + "size": 137247, + "subdir": "linux-64", + "timestamp": 1642094816398, + "version": "1.4.2" + }, + "gl2ps-1.4.2-h70c0345_1.tar.bz2": { + "build": "h70c0345_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "b9003894917761391d5db47da4555bda", + "name": "gl2ps", + "sha256": "4f8358cd9f28bed95733df0fc7647d21db87bf33a3c67c4e3689175d37ffac94", + "size": 137216, + "subdir": "linux-64", + "timestamp": 1644215894265, + "version": "1.4.2" + }, + "glew-2.1.0-h295c915_2.tar.bz2": { + "build": "h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libglu", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "md5": "66f20466ef678fb93a5591242b333c67", + "name": "glew", + "sha256": "ce622304de3e16ebf378a7c81d8da567294df388ea0fbfa60a407f21d58db3cd", + "size": 701206, + "subdir": "linux-64", + "timestamp": 1642106226883, + "version": "2.1.0" + }, + "glew-2.1.0-h295c915_3.tar.bz2": { + "build": "h295c915_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libglu", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "md5": "6fa6b609c7202860934eb70f2b1fc0f2", + "name": "glew", + "sha256": "a277b046a81bd65550725ac751068c912c19589ade7dc5d8af2f1512e0279e4a", + "size": 710130, + "subdir": "linux-64", + "timestamp": 1643883747315, + "version": "2.1.0" + }, + "glew-2.2.0-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libglu", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e706f54254365df1dfee283854220dfc", + "name": "glew", + "sha256": "5980c7265423db1257a0ae7f4022b47dc4792159b203a13ef85d5408fa6e22de", + "size": 773190, + "subdir": "linux-64", + "timestamp": 1679057475203, + "version": "2.2.0" + }, + "glib-2.53.6-h0d2cc06_1.tar.bz2": { + "build": "h0d2cc06_1", + "build_number": 1, + "depends": [ + "libffi >=3.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "pcre", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "c14522bf65e17b05cc552326ec36de18", + "name": "glib", + "sha256": "970edac7aa9f2395e0e381ccf83dbad9a0c839d73361b328d79780df725db351", + "size": 8850105, + "subdir": "linux-64", + "timestamp": 1509735425274, + "version": "2.53.6" + }, + "glib-2.53.6-h56f7bfe_1.tar.bz2": { + "build": "h56f7bfe_1", + "build_number": 1, + "depends": [ + "libffi >=3.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "pcre", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "6810116fd8d4eb6334cdd7eacbe88a6d", + "name": "glib", + "sha256": "8bf20f31ee18d15c8ec23e1992e5b8e5fad86520c83e9bc72abc3b7efc727366", + "size": 8839691, + "subdir": "linux-64", + "timestamp": 1509735426706, + "version": "2.53.6" + }, + "glib-2.53.6-h5d9569c_2.tar.bz2": { + "build": "h5d9569c_2", + "build_number": 2, + "depends": [ + "libffi >=3.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "pcre", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "793fff913803dfe6bb362250bba31175", + "name": "glib", + "sha256": "7fdddb0e585b4682a6be977940e3001e1fd759168ee8d3521538d889fbef018f", + "size": 8835765, + "subdir": "linux-64", + "timestamp": 1509994845830, + "version": "2.53.6" + }, + "glib-2.53.6-h7684f33_1.tar.bz2": { + "build": "h7684f33_1", + "build_number": 1, + "depends": [ + "libffi >=3.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "pcre", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "60b246a5bd331cd16954a9faa0b1d8b6", + "name": "glib", + "sha256": "59ced599ea3e6615e4233bde915620bb2014e2579d3ca41eb690f46ee6e6591b", + "size": 8841923, + "subdir": "linux-64", + "timestamp": 1509735226137, + "version": "2.53.6" + }, + "glib-2.53.6-hc861d11_1.tar.bz2": { + "build": "hc861d11_1", + "build_number": 1, + "depends": [ + "libffi >=3.0.0", + "libgcc-ng >=7.2.0", + "pcre", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "f0c1d8c0fdf91d63c782146c33efa286", + "name": "glib", + "sha256": "2a5367f5d1dbbf672823dc9194ddd1730262a03b2baf3b503f54f9add21d5920", + "size": 8805327, + "subdir": "linux-64", + "timestamp": 1505735456263, + "version": "2.53.6" + }, + "glib-2.56.0-h000015b_0.tar.bz2": { + "build": "h000015b_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "pcre", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "4fe867b93a04e1371f6a5eb4126193de", + "name": "glib", + "sha256": "f4fd5f6b9244e1d2cdac878be265f758c614aed88a59c840ae9199c563c6dba7", + "size": 5177487, + "subdir": "linux-64", + "timestamp": 1522691446165, + "version": "2.56.0" + }, + "glib-2.56.1-h000015b_0.tar.bz2": { + "build": "h000015b_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "pcre", + "pcre >=8.42,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "d0e7ad5c699cf577d34f64c571939abc", + "name": "glib", + "sha256": "e9f050b556daf910d24379fbd28f3cf65c08f2b907e76a0c6542561f1cff65a7", + "size": 5194647, + "subdir": "linux-64", + "timestamp": 1523664837756, + "version": "2.56.1" + }, + "glib-2.56.2-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.42,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "00d5c0ac884e6176dd740e4b40ba612a", + "name": "glib", + "sha256": "b82ee554b1a0ccb8fb181b84df68d7033e77d3f0a4265563e0bb7ba0735f6207", + "size": 5227073, + "subdir": "linux-64", + "timestamp": 1535475913016, + "version": "2.56.2" + }, + "glib-2.63.1-h3eb4bd4_1.tar.bz2": { + "build": "h3eb4bd4_1", + "build_number": 1, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.43,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "a7cbb61a8a403c41178e291b962b54eb", + "name": "glib", + "sha256": "eea328a3303019e49a7ed5e574abd45f6f834cf1983f6c677cfcb2b026e4061c", + "size": 3566407, + "subdir": "linux-64", + "timestamp": 1589813870891, + "version": "2.63.1" + }, + "glib-2.63.1-h5a9c865_0.tar.bz2": { + "build": "h5a9c865_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.43,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "dad669f1119b1062e12933cebe0302ec", + "name": "glib", + "sha256": "499b7af5f366bb14d09333fe1649de4cb648742356684866f54fe1ed5a449aea", + "size": 3534165, + "subdir": "linux-64", + "timestamp": 1573052323452, + "version": "2.63.1" + }, + "glib-2.65.0-h3eb4bd4_0.tar.bz2": { + "build": "h3eb4bd4_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "268d016b5048343396c1bffc445ff35e", + "name": "glib", + "sha256": "3ccffa0c4035b4cb166c66bdaee49eb71267ead9c03b60897d388e7e9fd087b1", + "size": 3647340, + "subdir": "linux-64", + "timestamp": 1593199609035, + "version": "2.65.0" + }, + "glib-2.66.1-h92f7085_0.tar.bz2": { + "build": "h92f7085_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "814457a69603c00b74222f229e8780a5", + "name": "glib", + "sha256": "fbb815ed68d28aa6fff92838e676cf23217a6e95459a995da66f67a3d3b9388a", + "size": 3615664, + "subdir": "linux-64", + "timestamp": 1602709775969, + "version": "2.66.1" + }, + "glib-2.67.3-h36276a3_1.tar.bz2": { + "build": "h36276a3_1", + "build_number": 1, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "2505ea39203250c38bb2e9978006b72e", + "name": "glib", + "sha256": "0ea53ac3fc1a746c350ef875e679671a66ceee41c078b9f21533ba45cae32629", + "size": 3689746, + "subdir": "linux-64", + "timestamp": 1613329495364, + "version": "2.67.3" + }, + "glib-2.67.4-h36276a3_1.tar.bz2": { + "build": "h36276a3_1", + "build_number": 1, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "cf69a15ec1e416f0b50523e2d1dbb4ae", + "name": "glib", + "sha256": "e1ff0e52f59a0bddeb362f6427261cdec61c287f9754a8e070e701f2f2dea471", + "size": 3723937, + "subdir": "linux-64", + "timestamp": 1613587777854, + "version": "2.67.4" + }, + "glib-2.68.0-h36276a3_0.tar.bz2": { + "build": "h36276a3_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "072134504f7faba860d0090f79249e39", + "name": "glib", + "sha256": "9cc54d417110643252eadc4638f42838992e72e6fec6833d57d611f691c8bf74", + "size": 3712982, + "subdir": "linux-64", + "timestamp": 1616685061597, + "version": "2.68.0" + }, + "glib-2.68.1-h36276a3_0.tar.bz2": { + "build": "h36276a3_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "159da930ac488be2b667f95beb4f829b", + "name": "glib", + "sha256": "a1984727104b679e951b7581162d192756f21e65c75f6a42683c1c196a566c27", + "size": 3686887, + "subdir": "linux-64", + "timestamp": 1617998734166, + "version": "2.68.1" + }, + "glib-2.68.2-h36276a3_0.tar.bz2": { + "build": "h36276a3_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "1ab6ad0e819975c5d4f8a6956b915523", + "name": "glib", + "sha256": "f6c2d49a8ae4f3fbfa153fd7f86b1a4f0580e792988283244bee0effc70f9bdc", + "size": 3717881, + "subdir": "linux-64", + "timestamp": 1621259668015, + "version": "2.68.2" + }, + "glib-2.69.0-h5202010_0.tar.bz2": { + "build": "h5202010_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "pcre >=8.45,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "a24ecee8a086b71b4941a1df32211187", + "name": "glib", + "sha256": "5b4c78a665fded4b305f91a7c9f81984356a17e79fd37ec25f9e6cbee7415031", + "size": 2017031, + "subdir": "linux-64", + "timestamp": 1625681449233, + "version": "2.69.0" + }, + "glib-2.69.1-h4ff587b_1.tar.bz2": { + "build": "h4ff587b_1", + "build_number": 1, + "depends": [ + "libffi >=3.3", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "pcre >=8.45,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "858d4f13f1b0e54ee8cc3dd7c67cf0de", + "name": "glib", + "sha256": "bb98f022743e5df14d73db0edae49eb95a11abcc41c973fe2f30c3810bc5021e", + "size": 2021087, + "subdir": "linux-64", + "timestamp": 1642701448286, + "version": "2.69.1" + }, + "glib-2.69.1-h5202010_0.tar.bz2": { + "build": "h5202010_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "pcre >=8.45,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "3e9834fa42fd6cb36475b66044b7f42a", + "name": "glib", + "sha256": "14c4d75806fe3f45633a7cd59502a60604ac82d8c473940a3086dfa54bb2c411", + "size": 2020592, + "subdir": "linux-64", + "timestamp": 1629381585657, + "version": "2.69.1" + }, + "glib-2.69.1-he621ea3_2.tar.bz2": { + "build": "he621ea3_2", + "build_number": 2, + "depends": [ + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pcre >=8.45,<9.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "0223c02d020cf3ff6637210d99000b5a", + "name": "glib", + "sha256": "e5e0b6a6c7bdd8a2453bce4b5045e022c6df3ad5a5a4d3085eb59ac4e1ded452", + "size": 1989267, + "subdir": "linux-64", + "timestamp": 1669364519815, + "version": "2.69.1" + }, + "glob2-0.5-py27hd3b7d1f_1.tar.bz2": { + "build": "py27hd3b7d1f_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "58cfecd9ca50035621981d44769fae13", + "name": "glob2", + "sha256": "0b7eed4a01a0cea007b8a5c9ed11dbc9d1dba55cf826b200adcdc71fd954b5e6", + "size": 15705, + "subdir": "linux-64", + "timestamp": 1505742233538, + "version": "0.5" + }, + "glob2-0.5-py35h98a1f2a_1.tar.bz2": { + "build": "py35h98a1f2a_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-2-Clause", + "md5": "3c0ae9dd64ca8c5e472d3c32590a8b4b", + "name": "glob2", + "sha256": "e068468b0764d42e8cbec42c0231da76638897e456b1a23d31aeef54e650de21", + "size": 15947, + "subdir": "linux-64", + "timestamp": 1505742245766, + "version": "0.5" + }, + "glob2-0.5-py36h2c1b292_1.tar.bz2": { + "build": "py36h2c1b292_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "afb1bff6367db7ec5d0467411838fda6", + "name": "glob2", + "sha256": "183e280147d200c178fc24253cec07c6cef0ca2f6a2490f5e66e36efab4a4658", + "size": 15898, + "subdir": "linux-64", + "timestamp": 1505742258045, + "version": "0.5" + }, + "glob2-0.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c8cc750dda0ea3b3a78bbfbc3eaaae52", + "name": "glob2", + "sha256": "3f800bcebc8d8849f33e73fe2ca44b4e04e9842bab4a7cef2868a9e7f0b465e1", + "size": 16897, + "subdir": "linux-64", + "timestamp": 1530813614048, + "version": "0.6" + }, + "glob2-0.6-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d0aa46931c4fcde46ba898b87786ca77", + "name": "glob2", + "sha256": "1e2f596de1102bd61982d50dfe15b0a80a02faa34f3044ac39dd359646e4b867", + "size": 17408, + "subdir": "linux-64", + "timestamp": 1538518983444, + "version": "0.6" + }, + "glob2-0.6-py27hcea9cbd_0.tar.bz2": { + "build": "py27hcea9cbd_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "53d22fd846865439452a4dcf61099f4d", + "name": "glob2", + "sha256": "b0021507d50f54eae789e5b51d2017877c550fdc54326ce402ed768565985c1d", + "size": 17212, + "subdir": "linux-64", + "timestamp": 1511295062443, + "version": "0.6" + }, + "glob2-0.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "6ce6553d3cb663915d26c64259f577d8", + "name": "glob2", + "sha256": "9318fba9834b7987639da0fa5dc3a12f6d5985a802f6bbfafaf39e575aa7be96", + "size": 17171, + "subdir": "linux-64", + "timestamp": 1535130222865, + "version": "0.6" + }, + "glob2-0.6-py35hff66265_0.tar.bz2": { + "build": "py35hff66265_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5b6d984ef48a6a9859f9f84ce82c8003", + "name": "glob2", + "sha256": "5cbff85de5de3ede54aa1c6e373287b42934dab14061a655701339e17fef3235", + "size": 17490, + "subdir": "linux-64", + "timestamp": 1511295064174, + "version": "0.6" + }, + "glob2-0.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "45b2c9b650f211e4a5c8443549ec49e3", + "name": "glob2", + "sha256": "a68f31f1b6abc1af7812b8f5f7dfa54e3219849d1b26bd2a55dad2430e8195da", + "size": 17075, + "subdir": "linux-64", + "timestamp": 1530813637414, + "version": "0.6" + }, + "glob2-0.6-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9141de5a5454f421d9a268b2ea09c89f", + "name": "glob2", + "sha256": "22c10ce21ddb3f036f1673b9369d9e77678d7cf6b9393f27881924c262681d78", + "size": 17668, + "subdir": "linux-64", + "timestamp": 1538518986058, + "version": "0.6" + }, + "glob2-0.6-py36he249c77_0.tar.bz2": { + "build": "py36he249c77_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8f9d9d687f9fa1955660ef2b966c4ab5", + "name": "glob2", + "sha256": "7467faedba684d1532a95b2982043670e6e60ec9149012bc8ce2600ba5dd029f", + "size": 17408, + "subdir": "linux-64", + "timestamp": 1511295001725, + "version": "0.6" + }, + "glob2-0.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "374e91c86b2d9d2e4251abd565369b10", + "name": "glob2", + "sha256": "997ffa9c4130654ef419ed7555b63a064c33f4976d9b63bfdfb9486679ee67cd", + "size": 17095, + "subdir": "linux-64", + "timestamp": 1530813590386, + "version": "0.6" + }, + "glob2-0.6-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "af95a726ff89d867c8569562501bf6aa", + "name": "glob2", + "sha256": "53c6d2d03b4460930bef17cf2dcd6f02dff44b146a4b1fe59895c90f3c0fd8b6", + "size": 17636, + "subdir": "linux-64", + "timestamp": 1538518971046, + "version": "0.6" + }, + "glog-0.3.5-hf484d3e_1.tar.bz2": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "gflags >=2.2.1,<2.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD", + "md5": "5f34566e079d9e89da2663906a554c97", + "name": "glog", + "sha256": "264275c87bb9e9673ed5e585337f548d2ec50381162a01c3f3f640d19ac8508b", + "size": 161653, + "subdir": "linux-64", + "timestamp": 1512765467074, + "version": "0.3.5" + }, + "glog-0.4.0-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "gflags >=2.2.2,<2.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "md5": "087b2ded78bd08600c8c1c0445340559", + "name": "glog", + "sha256": "d06edf3426a882158414458b6f56e8aacf8a1017490026b22ec8e311ff4c50bd", + "size": 131515, + "subdir": "linux-64", + "timestamp": 1567108316306, + "version": "0.4.0" + }, + "glog-0.5.0-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "gflags >=2.2.2,<2.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "md5": "bfbf6dcde0288f43857e8371087e81da", + "name": "glog", + "sha256": "cb4410750b5d94bd1a75e6dff662e4192481d0f5fd53dcbfa5853e21d20b20c8", + "size": 108274, + "subdir": "linux-64", + "timestamp": 1620732909459, + "version": "0.5.0" + }, + "glpk-4.65-h276157c_3.tar.bz2": { + "build": "h276157c_3", + "build_number": 3, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=11.2.0" + ], + "license": "GPL3", + "md5": "4df9a4bf7a1af46b886fb7288528b010", + "name": "glpk", + "sha256": "b860a0ed73810ec39a857db0d088fb0475831186bb494e59256397577f13e6e5", + "size": 1149209, + "subdir": "linux-64", + "timestamp": 1656071603169, + "version": "4.65" + }, + "glpk-4.65-h3ceedfd_1.tar.bz2": { + "build": "h3ceedfd_1", + "build_number": 1, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0" + ], + "license": "GPL3", + "md5": "64f2e9ba9d514143d1a7a885c080c6d7", + "name": "glpk", + "sha256": "61b0b26a5122af6ec0f993cb9586f0884d0a43bdd8fd8f1899368d62978d037a", + "size": 1204971, + "subdir": "linux-64", + "timestamp": 1528734837924, + "version": "4.65" + }, + "glpk-4.65-h3ceedfd_2.tar.bz2": { + "build": "h3ceedfd_2", + "build_number": 2, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0" + ], + "license": "GPL3", + "md5": "c9f3f7d9adecf645c64be02f5342a488", + "name": "glpk", + "sha256": "2d19d66ce82d6fc2e2d3b9d436aebd8a011d72a7b0212fc5a70cb6e10f26e1bc", + "size": 1204665, + "subdir": "linux-64", + "timestamp": 1528987054732, + "version": "4.65" + }, + "glue-core-0.12.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=2.7,<2.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "822e38aa6f00614cc1128acc1a678b1c", + "name": "glue-core", + "sha256": "94953cd0fbfc928e7ef71affb4fb9fc85512109ac63c5d59e83deb0fcfd577df", + "size": 1299465, + "subdir": "linux-64", + "timestamp": 1522703248244, + "version": "0.12.0" + }, + "glue-core-0.12.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=3.5,<3.6.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "e2707c553da9c5898e68ba1f09bd831f", + "name": "glue-core", + "sha256": "042998ed40aa8530700b861efae20d090026462bb67c02f562fda591e46ca608", + "size": 1320428, + "subdir": "linux-64", + "timestamp": 1522703274328, + "version": "0.12.0" + }, + "glue-core-0.12.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "3eda38438a0d1ca8f7a41a86dadf1a6e", + "name": "glue-core", + "sha256": "65a217696dc1ba36cddaf2550fa4bec8428937d5f8880d5b53bca2947e2d0a52", + "size": 1307948, + "subdir": "linux-64", + "timestamp": 1522703290976, + "version": "0.12.0" + }, + "glue-core-0.12.3-py27hb826bfd_0.tar.bz2": { + "build": "py27hb826bfd_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=2.7,<2.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "645b0e4d70df31b86fee8f66b3c055be", + "name": "glue-core", + "sha256": "28a224e85819dd19b9c2591cb96c4bb21595797d8bc13b688af9e71b4fae6cc0", + "size": 1302207, + "subdir": "linux-64", + "timestamp": 1511759474214, + "version": "0.12.3" + }, + "glue-core-0.12.3-py35h70c2699_0.tar.bz2": { + "build": "py35h70c2699_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=3.5,<3.6.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "57f59148ef98a00f7b10d5d0bc1d116f", + "name": "glue-core", + "sha256": "55304553ea5d0a682588fd4ff07a6004a6d9d9e9e5347bad52dd89c6d6328874", + "size": 1324432, + "subdir": "linux-64", + "timestamp": 1511759515008, + "version": "0.12.3" + }, + "glue-core-0.12.3-py36h15cce50_0.tar.bz2": { + "build": "py36h15cce50_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "123ce990f8c295c5dc31c398941f9cd0", + "name": "glue-core", + "sha256": "8eb45e89c119b9d61c8d451470d315ebe9eb9ce6ee75000215e2ea4ccfa6958c", + "size": 1310009, + "subdir": "linux-64", + "timestamp": 1511759538905, + "version": "0.12.3" + }, + "glue-core-0.12.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=2.7,<2.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "f1f9791f59d1ef9be8b63b7a04364256", + "name": "glue-core", + "sha256": "283e7d0ebc82ea68ef75f27a8f44dc67cca46c7f7a4e8e4c014f1e6f95385617", + "size": 1300239, + "subdir": "linux-64", + "timestamp": 1519756612327, + "version": "0.12.4" + }, + "glue-core-0.12.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=3.5,<3.6.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "9f3ceb7583400ee718e4cf0c43c8941f", + "name": "glue-core", + "sha256": "582259d0fa29898f3a553386f5c285575f11d90b3e4ea3a2d1090aa6d2ebb53c", + "size": 1322783, + "subdir": "linux-64", + "timestamp": 1519756731745, + "version": "0.12.4" + }, + "glue-core-0.12.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "8f95ada18dc87cc661dda9a0299727a3", + "name": "glue-core", + "sha256": "dac61a1060e06016434717c7719260faf990e33d74cdd557bf78dbbf80704179", + "size": 1309737, + "subdir": "linux-64", + "timestamp": 1519756716484, + "version": "0.12.4" + }, + "glue-core-0.12.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=2.7,<2.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "e2a48fc760ec800e26450609db07ad93", + "name": "glue-core", + "sha256": "f42bf13b5aaf121181dff616a2af0ebcaf2f9f20768eee71b04862f72b755864", + "size": 1306107, + "subdir": "linux-64", + "timestamp": 1525089841539, + "version": "0.12.5" + }, + "glue-core-0.12.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=3.5,<3.6.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "ab5092a1e25bbc2c0ac3a59230a9593d", + "name": "glue-core", + "sha256": "530eea1bbbaff20d3ec87f9435a04de186a63bec10969a9d403d216af446c963", + "size": 1329914, + "subdir": "linux-64", + "timestamp": 1525089878044, + "version": "0.12.5" + }, + "glue-core-0.12.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "bc5faaea0658176bef01c0b3bec549a8", + "name": "glue-core", + "sha256": "176d3cc3e887cb5030d7b97ddd6b6b80f9b323c80c77bf9cebd9e49f3d038b6a", + "size": 1316287, + "subdir": "linux-64", + "timestamp": 1525089854298, + "version": "0.12.5" + }, + "glue-core-0.13.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.3", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=2.7,<2.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "4a36d5ed4cb606ff4d371129cae9c07e", + "name": "glue-core", + "sha256": "f7a8a18e327adae922a89688462e10a6677c89c452be4474df42e98818541921", + "size": 1451944, + "subdir": "linux-64", + "timestamp": 1526243307700, + "version": "0.13.3" + }, + "glue-core-0.13.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.3", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=3.5,<3.6.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "6519289b183a627d8f40cfa354215349", + "name": "glue-core", + "sha256": "58471f895bddf7dbc644abb8e2d187969a66d0e97ae325a2fb6fb28f6c9f63be", + "size": 1477964, + "subdir": "linux-64", + "timestamp": 1526243348548, + "version": "0.13.3" + }, + "glue-core-0.13.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.3", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "ccd0c72b1deadb479815f7854a520506", + "name": "glue-core", + "sha256": "efecc18c4182984b317a4cb3e1cf51c293a56f6afc7be0e74f07f908245e3d1f", + "size": 1472454, + "subdir": "linux-64", + "timestamp": 1526243331796, + "version": "0.13.3" + }, + "glue-core-0.13.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.3", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "f6c50eaf59e46371b274bd7d640a0d31", + "name": "glue-core", + "sha256": "a23700eaee61f6e793637e782e394551e2348455434947df0a986c413e7244ba", + "size": 1471656, + "subdir": "linux-64", + "timestamp": 1530891636845, + "version": "0.13.3" + }, + "glue-core-0.13.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.3", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=2.7,<2.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "3317179da04029709d327aff9bc8399a", + "name": "glue-core", + "sha256": "c22e3156b65098717c0d56f7e3a8f362dd055ec2458850bcf677c5ff7491c110", + "size": 1398677, + "subdir": "linux-64", + "timestamp": 1540971381756, + "version": "0.13.4" + }, + "glue-core-0.13.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.3", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "d1fe83e69f85baf7ad8cf474551255f5", + "name": "glue-core", + "sha256": "074e42e343e00ef86779c81f0221d813b1c79c032614ebf5c51a6d3775e9c0a8", + "size": 1409604, + "subdir": "linux-64", + "timestamp": 1540971520669, + "version": "0.13.4" + }, + "glue-core-0.13.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.3", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "7fbf0a514c19e4ae9e5c3386f3c97c2c", + "name": "glue-core", + "sha256": "05f935028e652e6bfac09337b7014e433c6349de4fccd4394495030ae1ac865d", + "size": 1401822, + "subdir": "linux-64", + "timestamp": 1540971454680, + "version": "0.13.4" + }, + "glue-core-0.14.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=2.7,<2.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "a9cf16ecb9c8409ec2efecce8ea35757", + "name": "glue-core", + "sha256": "34732c5e5b069eadd6f4dd876f8dd072baca6dc18a69b3744aca136902fb46e3", + "size": 1453117, + "subdir": "linux-64", + "timestamp": 1545093378889, + "version": "0.14.1" + }, + "glue-core-0.14.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "b37ab1731e4fa21532f776216c1b62d1", + "name": "glue-core", + "sha256": "f7ed2a9e2a84cf0a538ca4b47d4cb5dfe56f466e06291579e67d6fd384d25756", + "size": 1475475, + "subdir": "linux-64", + "timestamp": 1545093404118, + "version": "0.14.1" + }, + "glue-core-0.14.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.7,<3.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "bd6acc39ae1b9e932239254deaa12eae", + "name": "glue-core", + "sha256": "a7f091239ed17c0f7a94c8071428d706f2ab93324f976934a29d0df18e861138", + "size": 1462180, + "subdir": "linux-64", + "timestamp": 1545093501627, + "version": "0.14.1" + }, + "glue-core-0.14.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=2.7,<2.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "2752890c7f8881f83275dac64a0c278d", + "name": "glue-core", + "sha256": "74b073591d2c937fc48f690788c8b0b2fce1db589f7e23370ba9a5a4dfb19b69", + "size": 1456688, + "subdir": "linux-64", + "timestamp": 1556066472588, + "version": "0.14.2" + }, + "glue-core-0.14.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "45f67a2f02df9447c46cbc488e4d1b00", + "name": "glue-core", + "sha256": "fcabcb5da9ca66585a2c59643cc3e9ccd122f37d5b8931d708e185b5469ac4f0", + "size": 1470639, + "subdir": "linux-64", + "timestamp": 1556066475993, + "version": "0.14.2" + }, + "glue-core-0.14.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.7,<3.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "68241f5b27fddfad25f25624bea22efa", + "name": "glue-core", + "sha256": "157c1dbc2b1af73de973da54666d855f528b09819f97057ef668f5dd8e99473a", + "size": 1473868, + "subdir": "linux-64", + "timestamp": 1556066430535, + "version": "0.14.2" + }, + "glue-core-0.15.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=2.7,<2.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "f20e1d666810183774e0b9df3701851a", + "name": "glue-core", + "sha256": "7cebb43b5824795558efdcb73923f9d1c163724e07687a853de1fbfd64ca7dc6", + "size": 1724154, + "subdir": "linux-64", + "timestamp": 1568317227045, + "version": "0.15.6" + }, + "glue-core-0.15.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "c73f07042555c45830c946f03c2c1b14", + "name": "glue-core", + "sha256": "c513db2c84e9850ae6c6c59e22a60af52073f3897201791da42cc55fb2635665", + "size": 1743077, + "subdir": "linux-64", + "timestamp": 1568317057276, + "version": "0.15.6" + }, + "glue-core-0.15.6-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "2d1d20a0e08de6ba1d90f7ce231b8c55", + "name": "glue-core", + "sha256": "69a07287f632f2ff79187d232d5a0c49231c4ded574a93ca2b5ca1cb006e48b6", + "size": 1731785, + "subdir": "linux-64", + "timestamp": 1614166769404, + "version": "0.15.6" + }, + "glue-core-0.15.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.7,<3.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "6fa969b109ea2b85c195c08cb5464a3f", + "name": "glue-core", + "sha256": "2ae7af82cbef4a04f8b7456f127379dce72a09ccbac0b72f0b5fcccd764e358d", + "size": 1737906, + "subdir": "linux-64", + "timestamp": 1568317125094, + "version": "0.15.6" + }, + "glue-core-0.15.6-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "fdb7777aa99e4223c5b1127d3a3bcbd1", + "name": "glue-core", + "sha256": "886cb50ba3f56a40ce5b48da3f5430a241dd4a4c9cb557ca003a947f717d8ee3", + "size": 1729274, + "subdir": "linux-64", + "timestamp": 1614166771042, + "version": "0.15.6" + }, + "glue-core-0.15.6-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.8,<3.9.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "180b296896e7849af89f21292774ebc0", + "name": "glue-core", + "sha256": "ac4dda39ee91512dc83ade4dafbbca7b8c2cc4fbdea7c30695a4af497ea2de43", + "size": 1736049, + "subdir": "linux-64", + "timestamp": 1592221721999, + "version": "0.15.6" + }, + "glue-core-0.15.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=3.8,<3.9.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "e29a45ca21d65994b6e7e9596542b6ef", + "name": "glue-core", + "sha256": "6958118e97bc4c6909e4c175fd855ad514b165209834254c482f145521285fd4", + "size": 1744290, + "subdir": "linux-64", + "timestamp": 1614166760683, + "version": "0.15.6" + }, + "glue-core-0.15.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=3.9,<3.10.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "8913fea1a5e4863db029f5b3781d9b2c", + "name": "glue-core", + "sha256": "6bed8ffd8adf10ed251092f2653ed3c98cc4dc0e7e88c05d72f93d666b30ab06", + "size": 1737000, + "subdir": "linux-64", + "timestamp": 1614166447511, + "version": "0.15.6" + }, + "glue-core-1.0.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "astropy >=4.0", + "bottleneck >=1.2", + "dill >=0.2", + "echo >=0.5", + "h5py >=2.10", + "ipykernel >=4.0,!=5.0.0,!=5.1.0", + "ipython >=4.0", + "jupyter_client <7", + "matplotlib >=3.2", + "mpl-scatter-density >=0.7", + "numpy >=1.16", + "pandas >=1.0", + "pillow !=7.1.0", + "plotly", + "python >=3.10,<3.11.0a0", + "qtconsole >=4.3", + "qtpy >=1.9", + "scikit-image", + "scipy >=1.0", + "setuptools >=30.3.0", + "xlrd >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "611b9ef1726e960a46a118bd71c4771d", + "name": "glue-core", + "sha256": "1e34d250a6315ce7e90b40f04fd65a028084252de028c7c9cc72d04421e3f9bb", + "size": 1779777, + "subdir": "linux-64", + "timestamp": 1643117372511, + "version": "1.0.1" + }, + "glue-core-1.0.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astropy >=4.0", + "bottleneck >=1.2", + "dill >=0.2", + "echo >=0.5", + "h5py >=2.10", + "ipykernel >=4.0,!=5.0.0,!=5.1.0", + "ipython >=4.0", + "jupyter_client <7", + "matplotlib >=3.2", + "mpl-scatter-density >=0.7", + "numpy >=1.16", + "pandas >=1.0", + "pillow !=7.1.0", + "plotly", + "python >=3.9,<3.10.0a0", + "qtconsole >=4.3", + "qtpy >=1.9", + "scikit-image", + "scipy >=1.0", + "setuptools >=30.3.0", + "xlrd >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7ce7b66a04d9fcadb1a9a7bcf0ddf0ad", + "name": "glue-core", + "sha256": "4401bec34db83455dd057810f7f5482e90ea55d90549cf540548db2bd5a74106", + "size": 1771573, + "subdir": "linux-64", + "timestamp": 1625832703270, + "version": "1.0.1" + }, + "glue-core-1.2.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "dill >=0.2", + "echo >=0.5", + "h5py >=2.10", + "ipykernel >=4.0,!=5.0.0,!=5.1.0", + "ipython >=4.0", + "matplotlib-base >=3.2", + "mpl-scatter-density >=0.7", + "numpy >=1.17", + "openpyxl >=3.0", + "pandas >=1.2", + "pillow !=7.1.0", + "plotly", + "python >=3.10,<3.11.0a0", + "qtconsole >=4.3", + "qtpy >=1.9", + "scikit-image", + "scipy >=1.1", + "setuptools >=30.3.0", + "xlrd >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aa101a3afd02fb6330bb29e35e02474b", + "name": "glue-core", + "sha256": "7aab75da90e4bb9148da07dba183307865d768badd7ba27287c613108f524e2f", + "size": 1790505, + "subdir": "linux-64", + "timestamp": 1665682408431, + "version": "1.2.4" + }, + "glue-core-1.2.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "dill >=0.2", + "echo >=0.5", + "h5py >=2.10", + "ipykernel >=4.0,!=5.0.0,!=5.1.0", + "ipython >=4.0", + "matplotlib-base >=3.2", + "mpl-scatter-density >=0.7", + "numpy >=1.17", + "openpyxl >=3.0", + "pandas >=1.2", + "pillow !=7.1.0", + "plotly", + "python >=3.11,<3.12.0a0", + "qtconsole >=4.3", + "qtpy >=1.9", + "scikit-image", + "scipy >=1.1", + "setuptools >=30.3.0", + "xlrd >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b02383b2afa3665d79ac9129e98cb3d6", + "name": "glue-core", + "sha256": "cf65910dd58c04381cf66f480e157c9c620752795245c65f1dde8fc7e1d5c4af", + "size": 2143188, + "subdir": "linux-64", + "timestamp": 1676844178119, + "version": "1.2.4" + }, + "glue-core-1.2.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "dill >=0.2", + "echo >=0.5", + "h5py >=2.10", + "ipykernel >=4.0,!=5.0.0,!=5.1.0", + "ipython >=4.0", + "matplotlib-base >=3.2", + "mpl-scatter-density >=0.7", + "numpy >=1.17", + "openpyxl >=3.0", + "pandas >=1.2", + "pillow !=7.1.0", + "plotly", + "python >=3.7,<3.8.0a0", + "qtconsole >=4.3", + "qtpy >=1.9", + "scikit-image", + "scipy >=1.1", + "setuptools >=30.3.0", + "xlrd >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dc4c3f81037cb0b6050e98cea1b4a2ff", + "name": "glue-core", + "sha256": "59355a433243905b9745b8758708fced4709426e858a817758b9c43576cf00e1", + "size": 1777196, + "subdir": "linux-64", + "timestamp": 1665682317795, + "version": "1.2.4" + }, + "glue-core-1.2.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "dill >=0.2", + "echo >=0.5", + "h5py >=2.10", + "ipykernel >=4.0,!=5.0.0,!=5.1.0", + "ipython >=4.0", + "matplotlib-base >=3.2", + "mpl-scatter-density >=0.7", + "numpy >=1.17", + "openpyxl >=3.0", + "pandas >=1.2", + "pillow !=7.1.0", + "plotly", + "python >=3.8,<3.9.0a0", + "qtconsole >=4.3", + "qtpy >=1.9", + "scikit-image", + "scipy >=1.1", + "setuptools >=30.3.0", + "xlrd >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "15e53c0d3944815c10a62911802d2c0c", + "name": "glue-core", + "sha256": "edafb109332cc8fa1c1c344aff5a35f89d894a6b668a898d7d42527c1a542dc0", + "size": 1779685, + "subdir": "linux-64", + "timestamp": 1665682127009, + "version": "1.2.4" + }, + "glue-core-1.2.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "dill >=0.2", + "echo >=0.5", + "h5py >=2.10", + "ipykernel >=4.0,!=5.0.0,!=5.1.0", + "ipython >=4.0", + "matplotlib-base >=3.2", + "mpl-scatter-density >=0.7", + "numpy >=1.17", + "openpyxl >=3.0", + "pandas >=1.2", + "pillow !=7.1.0", + "plotly", + "python >=3.9,<3.10.0a0", + "qtconsole >=4.3", + "qtpy >=1.9", + "scikit-image", + "scipy >=1.1", + "setuptools >=30.3.0", + "xlrd >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f4570bc7e1a5b7f63215e29b2e88754c", + "name": "glue-core", + "sha256": "7c7ae6aebb488f275ad7765c6b3558b1750c775484d04d225f70257f0df5b9f9", + "size": 1776764, + "subdir": "linux-64", + "timestamp": 1665682224287, + "version": "1.2.4" + }, + "glue-vispy-viewers-0.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.13", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt >=5.6,<6.0a0", + "python >=2.7,<2.8.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "4bfe3d9686702a990c1e24efee5282de", + "name": "glue-vispy-viewers", + "sha256": "932a4d95928e36566e2f6442ae5915ca6ceea6a45b0f80dd17745ee6ba509f78", + "size": 1195195, + "subdir": "linux-64", + "timestamp": 1526244828860, + "version": "0.10" + }, + "glue-vispy-viewers-0.10-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.13", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt >=5.6,<6.0a0", + "python >=3.5,<3.6.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "2a653dc94f89c921ce916dea34ad6295", + "name": "glue-vispy-viewers", + "sha256": "dd2ee5af74ddbeedf7b977e7eca91027f93d09bde016f24be4f07a2ef6c6501b", + "size": 1206430, + "subdir": "linux-64", + "timestamp": 1526244694070, + "version": "0.10" + }, + "glue-vispy-viewers-0.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.13", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt >=5.6,<6.0a0", + "python >=3.6,<3.7.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "0c5b2e3405024427c93b25622c2f204b", + "name": "glue-vispy-viewers", + "sha256": "cbe34229dcc74179338cbd688df287e9935e68f35033f4a7412ccdd1a122c859", + "size": 1206640, + "subdir": "linux-64", + "timestamp": 1526244235294, + "version": "0.10" + }, + "glue-vispy-viewers-0.10-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.13", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "aaabb38ca7f992336506defca27a130d", + "name": "glue-vispy-viewers", + "sha256": "763de9c513b39e3bbcafb9077b188651cbe27e4ec816829884a25cee6cd9dd86", + "size": 1203580, + "subdir": "linux-64", + "timestamp": 1530892199866, + "version": "0.10" + }, + "glue-vispy-viewers-0.9-py27ha2d5490_0.tar.bz2": { + "build": "py27ha2d5490_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.12", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt 4.11.*|5.6.*", + "python >=2.7,<2.8.0a0", + "qtpy" + ], + "license": "BSD 3-Clause", + "md5": "9feb9bc965bc4f9544b8f05eba3fd8e9", + "name": "glue-vispy-viewers", + "sha256": "5dc4501f6e122b840eb39b3a40e7527b740a094a5bd3c9d08baf64773fb194a7", + "size": 1199180, + "subdir": "linux-64", + "timestamp": 1511802346267, + "version": "0.9" + }, + "glue-vispy-viewers-0.9-py35h69f1dd5_0.tar.bz2": { + "build": "py35h69f1dd5_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.12", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt 4.11.*|5.6.*", + "python >=3.5,<3.6.0a0", + "qtpy" + ], + "license": "BSD 3-Clause", + "md5": "cc4ace86aa30f967ec29f11e52904e21", + "name": "glue-vispy-viewers", + "sha256": "9f420747fe2a78b3a1862cc093a6575b2e2c517ef0cab432a920484a919d1f98", + "size": 1211224, + "subdir": "linux-64", + "timestamp": 1511802363570, + "version": "0.9" + }, + "glue-vispy-viewers-0.9-py36h491feeb_0.tar.bz2": { + "build": "py36h491feeb_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.12", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt 4.11.*|5.6.*", + "python >=3.6,<3.7.0a0", + "qtpy" + ], + "license": "BSD 3-Clause", + "md5": "99352822d2527730bb8b478ad68103f1", + "name": "glue-vispy-viewers", + "sha256": "3a6b19356b2932dc43ad4c5882e9c0d98acde9847dd95c7339b9eb75958251a8", + "size": 1208506, + "subdir": "linux-64", + "timestamp": 1511802368274, + "version": "0.9" + }, + "glue-vispy-viewers-0.9.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.12", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt 4.11.*|5.6.*", + "python >=2.7,<2.8.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "e90b279ac238b007698a33d1e0f880d4", + "name": "glue-vispy-viewers", + "sha256": "b0f12fdf2f93b690769e739a5a281a8db224f268e83856ff39f2e72a7ee41ad7", + "size": 1199511, + "subdir": "linux-64", + "timestamp": 1519757083637, + "version": "0.9.1" + }, + "glue-vispy-viewers-0.9.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.12", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt 4.11.*|5.6.*", + "python >=3.5,<3.6.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "4eebb34cb8e5c5f4e4922b5a194cc0a3", + "name": "glue-vispy-viewers", + "sha256": "d23ac9edd96b69c1a9904d7d41efd0e46eae914ab25a5f70fc547535046d87c7", + "size": 1211280, + "subdir": "linux-64", + "timestamp": 1519757455183, + "version": "0.9.1" + }, + "glue-vispy-viewers-0.9.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.12", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt 4.11.*|5.6.*", + "python >=3.6,<3.7.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "9cc72cf1af62d39fa6fd9c3eca29bf9a", + "name": "glue-vispy-viewers", + "sha256": "2e4cee24da17fbc1e185b11a64cf7bca647e67a78c6d4f422f9f61931aa6ccbe", + "size": 1209461, + "subdir": "linux-64", + "timestamp": 1519757420870, + "version": "0.9.1" + }, + "glue-vispy-viewers-0.9.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.12", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt 4.11.*|5.6.*", + "python >=2.7,<2.8.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "e9fdbc1f54119d6ac23d5ea22b1951b4", + "name": "glue-vispy-viewers", + "sha256": "885d4b76f9fc694f9d3a935190101393430f4cf4e8fec40ce8f07e69059ae766", + "size": 1199589, + "subdir": "linux-64", + "timestamp": 1522705765256, + "version": "0.9.2" + }, + "glue-vispy-viewers-0.9.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.12", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt 4.11.*|5.6.*", + "python >=3.5,<3.6.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "b8190c25edfb0c837a39b7ef55c5b6f7", + "name": "glue-vispy-viewers", + "sha256": "fcf75c4a77b237a870021c377acf0a7bf20894442407b1d8657bddd00aac75ea", + "size": 1211599, + "subdir": "linux-64", + "timestamp": 1522706173760, + "version": "0.9.2" + }, + "glue-vispy-viewers-0.9.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.12", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt 4.11.*|5.6.*", + "python >=3.6,<3.7.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "ef18c2927a53ae2dd8c71ad6df114d0d", + "name": "glue-vispy-viewers", + "sha256": "a0446421c68ffa0fdaff6aa92687660a1f6eca03465c032fe298ae0a131a85ac", + "size": 1209182, + "subdir": "linux-64", + "timestamp": 1522706131799, + "version": "0.9.2" + }, + "glue-vispy-viewers-1.0.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "glue-core >=1.0", + "matplotlib-base", + "numpy", + "pillow", + "pyopengl", + "pyqt >=5.9,<6.0a0", + "python >=3.10,<3.11.0a0", + "qtpy", + "scipy", + "vispy >=0.6" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a8f774d7018c8a2cb54cce66146b7222", + "name": "glue-vispy-viewers", + "sha256": "a3786444cd6b02bbb03033c77303d782e7d413f69bad7c170757fb4b472661bc", + "size": 149638, + "subdir": "linux-64", + "timestamp": 1669917258365, + "version": "1.0.5" + }, + "glue-vispy-viewers-1.0.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "glue-core >=1.0", + "matplotlib-base", + "numpy", + "pillow", + "pyopengl", + "pyqt >=5.9,<6.0a0", + "python >=3.11,<3.12.0a0", + "qtpy", + "scipy", + "vispy >=0.6" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9dbbdfa305de4c55bad6f90d7cd9d805", + "name": "glue-vispy-viewers", + "sha256": "fb3e9045ca9229ae1d1cfd1943389191a8919abcd76c1392cdd38973735922d0", + "size": 186695, + "subdir": "linux-64", + "timestamp": 1676852595198, + "version": "1.0.5" + }, + "glue-vispy-viewers-1.0.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "glue-core >=1.0", + "matplotlib-base", + "numpy", + "pillow", + "pyopengl", + "pyqt >=5.9,<6.0a0", + "python >=3.7,<3.8.0a0", + "qtpy", + "scipy", + "vispy >=0.6" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5254d65dfd126df325d4df673f29bb1d", + "name": "glue-vispy-viewers", + "sha256": "3f7f82b09af10e5f70881a1d756d6c28aad1fcecf016a48faf597de6d721e9dd", + "size": 148456, + "subdir": "linux-64", + "timestamp": 1669917191427, + "version": "1.0.5" + }, + "glue-vispy-viewers-1.0.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "glue-core >=1.0", + "matplotlib-base", + "numpy", + "pillow", + "pyopengl", + "pyqt >=5.9,<6.0a0", + "python >=3.8,<3.9.0a0", + "qtpy", + "scipy", + "vispy >=0.6" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "1abe2297a43302f76647107792024baa", + "name": "glue-vispy-viewers", + "sha256": "17b8d7a374f94ced64c230c127400173f9e63ff804aea7b0c2b03d2e9ab97b12", + "size": 148911, + "subdir": "linux-64", + "timestamp": 1669917326921, + "version": "1.0.5" + }, + "glue-vispy-viewers-1.0.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "glue-core >=1.0", + "matplotlib-base", + "numpy", + "pillow", + "pyopengl", + "pyqt >=5.9,<6.0a0", + "python >=3.9,<3.10.0a0", + "qtpy", + "scipy", + "vispy >=0.6" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "3faf14aec17ef529bd979889d461de34", + "name": "glue-vispy-viewers", + "sha256": "6458f9b344b8e567b2242e4a38bc4d59190eb237f5f22ea8d831bc428fca3632", + "size": 148904, + "subdir": "linux-64", + "timestamp": 1669917112285, + "version": "1.0.5" + }, + "glueviz-0.12.0-ha37a3ef_0.tar.bz2": { + "app_entry": "glue", + "app_type": "desk", + "build": "ha37a3ef_0", + "build_number": 0, + "depends": [ + "glue-core >=0.12.0", + "glue-vispy-viewers >=0.9" + ], + "icon": "c124cb3a3bf9bb32f258a6e6f9b5c187.png", + "license": "BSD 3-Clause", + "md5": "ef593c724f4f365692e41d28b56472b9", + "name": "glueviz", + "sha256": "45c40a74d41ac838e54e403c9e4b8bbd4c065a530d8461bab4845f693929981e", + "size": 17969, + "subdir": "linux-64", + "summary": "Multi-dimensional linked data exploration", + "timestamp": 1511806296716, + "type": "app", + "version": "0.12.0" + }, + "glueviz-0.12.4-0.tar.bz2": { + "app_entry": "glue", + "app_type": "desk", + "build": "0", + "build_number": 0, + "depends": [ + "glue-core >=0.12.4", + "glue-vispy-viewers >=0.9.1" + ], + "icon": "c124cb3a3bf9bb32f258a6e6f9b5c187.png", + "license": "BSD 3-Clause", + "md5": "2065c9c882e4b842719ccf67c7c9f750", + "name": "glueviz", + "sha256": "b0502ec4044c40d1081d2afe7584f38763117eb1d73057d2cb30f160c7b35f3f", + "size": 17877, + "subdir": "linux-64", + "summary": "Multi-dimensional linked data exploration", + "timestamp": 1519757855077, + "type": "app", + "version": "0.12.4" + }, + "glueviz-0.13.3-0.tar.bz2": { + "app_entry": "glue", + "app_type": "desk", + "build": "0", + "build_number": 0, + "depends": [ + "glue-core >=0.13.3", + "glue-vispy-viewers >=0.10" + ], + "icon": "c124cb3a3bf9bb32f258a6e6f9b5c187.png", + "license": "BSD 3-Clause", + "md5": "1434d390e17ca135c0dcc273f3c8cf1a", + "name": "glueviz", + "sha256": "20077e6343f57c2d55d60fc3bfdb174b23dda6240ae0b55d4acef6632e2ee76b", + "size": 17951, + "subdir": "linux-64", + "summary": "Multi-dimensional linked data exploration", + "timestamp": 1526246220910, + "type": "app", + "version": "0.13.3" + }, + "glueviz-0.15.2-0.tar.bz2": { + "app_entry": "glue", + "app_type": "desk", + "build": "0", + "build_number": 0, + "depends": [ + "glue-core >=0.15.3", + "glue-vispy-viewers >=0.12.2" + ], + "icon": "c124cb3a3bf9bb32f258a6e6f9b5c187.png", + "license": "BSD 3-Clause", + "md5": "f4e76f40762488fe2622d34dbc621a02", + "name": "glueviz", + "sha256": "db4fbfd38654a727eb4fd995791f4193d83cace585fe675f23aa461145c1fba9", + "size": 26198, + "subdir": "linux-64", + "summary": "Multi-dimensional linked data exploration", + "timestamp": 1568318439164, + "type": "app", + "version": "0.15.2" + }, + "glueviz-0.15.2-h06a4308_0.tar.bz2": { + "app_entry": "glue", + "app_type": "desk", + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "glue-core >=0.15.3", + "glue-vispy-viewers >=0.12.2" + ], + "icon": "c124cb3a3bf9bb32f258a6e6f9b5c187.png", + "license": "BSD 3-Clause", + "md5": "6160d1844023e9d76c0ffebf37a48594", + "name": "glueviz", + "sha256": "1d2bb8d4ca5a7b32082039a497ec62ceffa2650adffcddee7e518a65fb147592", + "size": 23262, + "subdir": "linux-64", + "summary": "Multi-dimensional linked data exploration", + "timestamp": 1643117856507, + "type": "app", + "version": "0.15.2" + }, + "glueviz-1.0.0-0.tar.bz2": { + "app_entry": "glue", + "app_type": "desk", + "build": "0", + "build_number": 0, + "depends": [ + "glue-core >=0.15.3", + "glue-vispy-viewers >=0.12.2" + ], + "icon": "c124cb3a3bf9bb32f258a6e6f9b5c187.png", + "license": "BSD 3-Clause", + "md5": "877bde2f59411d46eda294ba60bf6f93", + "name": "glueviz", + "sha256": "63858dc1a24d4c8b467ddfb460950585777f16f4e130a254421fa0f53fd57f4c", + "size": 20666, + "subdir": "linux-64", + "summary": "Multi-dimensional linked data exploration", + "timestamp": 1600379026461, + "type": "app", + "version": "1.0.0" + }, + "glueviz-1.2.4-h06a4308_0.tar.bz2": { + "app_entry": "glue", + "app_type": "desk", + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "glue-core 1.2.4", + "glue-vispy-viewers >=1.0.3" + ], + "icon": "c124cb3a3bf9bb32f258a6e6f9b5c187.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "364f001d8e146c7d252c1210b4bd25cb", + "name": "glueviz", + "sha256": "3cdf6d741a15ebe5a958b915502a2ec456c34d2529bdf226a696b1bbbd8f0175", + "size": 17382, + "subdir": "linux-64", + "summary": "Multi-dimensional linked data exploration", + "timestamp": 1670011307388, + "type": "app", + "version": "1.2.4" + }, + "gmock-1.11.0-hdb19cb5_0.tar.bz2": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "gtest 1.11.0 hdb19cb5_0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "229446a0625267152ce5eb1c312da6f2", + "name": "gmock", + "sha256": "02f14c9a8d1f4d6b290565a776b3595abaafb2cbf3dec19d28a5dbcc394f206f", + "size": 141029, + "subdir": "linux-64", + "timestamp": 1658973578956, + "version": "1.11.0" + }, + "gmp-6.1.2-h6c8ec71_1.tar.bz2": { + "build": "h6c8ec71_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL 2 and LGPL 3", + "md5": "6344038378cefeb1e4010852183a497d", + "name": "gmp", + "sha256": "b50310e7524d59e52cef989155fa8ae0bc692544fb7fd60ccffa865754668cba", + "size": 762286, + "subdir": "linux-64", + "timestamp": 1510610105481, + "version": "6.1.2" + }, + "gmp-6.1.2-hb3b607b_0.tar.bz2": { + "build": "hb3b607b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL 2 and LGPL 3", + "md5": "f822d00963fe46a540039993bda1c141", + "name": "gmp", + "sha256": "3776b447a2e8d094d0d87e5680a8f82694a763ddd7ab4559b5c9b732c60f1ce5", + "size": 761774, + "subdir": "linux-64", + "timestamp": 1505690005789, + "version": "6.1.2" + }, + "gmp-6.2.1-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-2.0-or-later AND LGPL-3.0-or-later", + "md5": "6936fb32a80a246f7e799f5342e03de8", + "name": "gmp", + "sha256": "466a308cc01150c2df2f0213adfbb2411ee5365d4e456f706a499ef378524c38", + "size": 828023, + "subdir": "linux-64", + "timestamp": 1612282186049, + "version": "6.2.1" + }, + "gmp-6.2.1-h2531618_2.tar.bz2": { + "build": "h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL 2 and LGPL 3", + "md5": "ff3b51fcfc4c50141c74d44c734b1c5c", + "name": "gmp", + "sha256": "b858ce43aa232db965f917ec297acc15a3851aceae033390963bc58b8a4d6c5d", + "size": 833941, + "subdir": "linux-64", + "timestamp": 1612242995303, + "version": "6.2.1" + }, + "gmp-6.2.1-h295c915_3.tar.bz2": { + "build": "h295c915_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "GPL-2.0-or-later AND LGPL-3.0-or-later", + "md5": "4f4570f23a92244101431ec46a235436", + "name": "gmp", + "sha256": "670ae61b47df07aa53dd2a75b31d023213321ba9d5037b18be0c17a6e79f28f7", + "size": 822432, + "subdir": "linux-64", + "timestamp": 1653996358530, + "version": "6.2.1" + }, + "gmpy2-2.0.8-py27h10f8cd9_2.tar.bz2": { + "build": "py27h10f8cd9_2", + "build_number": 2, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "mpc", + "mpfr >=4.0.1,<5.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 3", + "md5": "0fc84c06e0761a56a91dbdf737f8b21f", + "name": "gmpy2", + "sha256": "3bec61d4b45faaad6be2eb0c147481f880710df98afa305f8774d630cd709bd2", + "size": 171610, + "subdir": "linux-64", + "timestamp": 1530892340739, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py27h4cf3fa8_2.tar.bz2": { + "build": "py27h4cf3fa8_2", + "build_number": 2, + "depends": [ + "gmp", + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "mpc", + "mpfr 3.*", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 3", + "md5": "59db57c52b6e0e46d457bd3dacc6948a", + "name": "gmpy2", + "sha256": "b00184f4bc8a32995f80d1b606dc6e371a0844692a7e0caaec5f62e568a75aeb", + "size": 171864, + "subdir": "linux-64", + "timestamp": 1511294948101, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py27hc856308_1.tar.bz2": { + "build": "py27hc856308_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "mpc", + "mpfr 3.*", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 3", + "md5": "57cde6a96554a1ad325ff46fec59bdd8", + "name": "gmpy2", + "sha256": "b3cf0caa1b44f4ac1b8fb5350a10778da04db9213f6b2b2eaa7ea24ec1bc6dec", + "size": 171099, + "subdir": "linux-64", + "timestamp": 1505743997451, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py310heeb90bb_3.tar.bz2": { + "build": "py310heeb90bb_3", + "build_number": 3, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.5.0", + "mpc", + "mpfr >=4.0.2,<5.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL 3", + "md5": "78c14d6a1a6234835aed13a3760f6b27", + "name": "gmpy2", + "sha256": "a9980f0be1a42ec8e9be262eecabd0fb22ba6179c935ab12377148d0cb9fa2ae", + "size": 508101, + "subdir": "linux-64", + "timestamp": 1643052589220, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py35h89a7545_1.tar.bz2": { + "build": "py35h89a7545_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "mpc", + "mpfr 3.*", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL 3", + "md5": "bb8c30d4c0593544f89060a9c22ca221", + "name": "gmpy2", + "sha256": "64cd79f573271c3b1ae1303e9e95c4c6b3544f245dd3dc0b191c949d6b7ac04a", + "size": 168836, + "subdir": "linux-64", + "timestamp": 1505744025929, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py35hd0a1c9a_2.tar.bz2": { + "build": "py35hd0a1c9a_2", + "build_number": 2, + "depends": [ + "gmp", + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "mpc", + "mpfr 3.*", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL 3", + "md5": "4124d97a5b3d1d2e4d78852ca7223f0c", + "name": "gmpy2", + "sha256": "38c1776ff283b9d52cb8100875cb4106916f06c23af76582e6b6bec4b373747f", + "size": 169543, + "subdir": "linux-64", + "timestamp": 1511294995399, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py36h10f8cd9_2.tar.bz2": { + "build": "py36h10f8cd9_2", + "build_number": 2, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "mpc", + "mpfr >=4.0.1,<5.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 3", + "md5": "8bcd8d83405addad2fadb5a84f93ff70", + "name": "gmpy2", + "sha256": "3ab6563af2ba7c3dbd4f5db8c561d60f371c0ab9100b55b2fd69aa42c9af52bc", + "size": 169000, + "subdir": "linux-64", + "timestamp": 1530892301647, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py36h55090d7_1.tar.bz2": { + "build": "py36h55090d7_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "mpc", + "mpfr 3.*", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 3", + "md5": "c925d34f0e1c81e40024b1852a284f68", + "name": "gmpy2", + "sha256": "1989081c08c6d7b5ed01d8f5334d015159f1a236e7398f2034ac83e20849aad7", + "size": 168688, + "subdir": "linux-64", + "timestamp": 1505744052326, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py36hc8893dd_2.tar.bz2": { + "build": "py36hc8893dd_2", + "build_number": 2, + "depends": [ + "gmp", + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "mpc", + "mpfr 3.*", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 3", + "md5": "f4b4afb1c0baf03655824f94f3588930", + "name": "gmpy2", + "sha256": "b03728c54feb29f2c3766ac46e8a0e920112e226a9e425abeb8d11620e008011", + "size": 169439, + "subdir": "linux-64", + "timestamp": 1511295011835, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py37h10f8cd9_2.tar.bz2": { + "build": "py37h10f8cd9_2", + "build_number": 2, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "mpc", + "mpfr >=4.0.1,<5.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 3", + "md5": "3fa4ca5bcfc72e5786653a36820ccaa9", + "name": "gmpy2", + "sha256": "d54d25d82a8a9244a7840747c557b28e945492ebbfcaeebe087422187adad452", + "size": 168984, + "subdir": "linux-64", + "timestamp": 1530892262558, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py38hd5f6e3b_3.tar.bz2": { + "build": "py38hd5f6e3b_3", + "build_number": 3, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "mpc", + "mpfr >=4.0.1,<5.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL 3", + "md5": "483a8f2063a40892ee274de75bb6cef7", + "name": "gmpy2", + "sha256": "79ba7136257533bdb5407407491b81dd6dd4851a0db21efde3d33f846b200966", + "size": 183566, + "subdir": "linux-64", + "timestamp": 1572880912253, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py39h8083e48_3.tar.bz2": { + "build": "py39h8083e48_3", + "build_number": 3, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "mpc", + "mpfr >=4.0.2,<5.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL 3", + "md5": "a9c90d264454776fed5de946385cbeab", + "name": "gmpy2", + "sha256": "99ab32f6ff25a1cb200d5eca4f09004de362d25a565d6946871710eb10798bf8", + "size": 178031, + "subdir": "linux-64", + "timestamp": 1607571491123, + "version": "2.0.8" + }, + "gmpy2-2.1.2-py310heeb90bb_0.tar.bz2": { + "build": "py310heeb90bb_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.5.0", + "mpc", + "mpfr >=4.0.2,<5.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "4b3d0e9c6904a91c8081e9d2f4fca43a", + "name": "gmpy2", + "sha256": "04c3e49d5239bbe60c0ae5b16c7452fe72a99105da03fc2a592ef9142d617d1a", + "size": 656118, + "subdir": "linux-64", + "timestamp": 1645455594626, + "version": "2.1.2" + }, + "gmpy2-2.1.2-py311hc9b5ff0_0.tar.bz2": { + "build": "py311hc9b5ff0_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=11.2.0", + "mpc", + "mpfr >=4.0.2,<5.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "1d34d0dd61007a32f6786c90581ea433", + "name": "gmpy2", + "sha256": "cc7800c2ce6a6b42c677dd6a0f9f5dd48303dae1ee0136c81ab18c23556052a3", + "size": 221323, + "subdir": "linux-64", + "timestamp": 1676839873370, + "version": "2.1.2" + }, + "gmpy2-2.1.2-py37heeb90bb_0.tar.bz2": { + "build": "py37heeb90bb_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.5.0", + "mpc", + "mpfr >=4.0.2,<5.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "d412e74dddfd73e4c04944dd4cac0382", + "name": "gmpy2", + "sha256": "63132ca0fa27147961e3b8f1265a72a1c3ff5b0eb522fa9c74bd29b5e18516bf", + "size": 213639, + "subdir": "linux-64", + "timestamp": 1645455579467, + "version": "2.1.2" + }, + "gmpy2-2.1.2-py38heeb90bb_0.tar.bz2": { + "build": "py38heeb90bb_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.5.0", + "mpc", + "mpfr >=4.0.2,<5.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "de98e971adcd0cbf6461878a3088f75b", + "name": "gmpy2", + "sha256": "253abbe16e46e22952c5e0389deb5900ec36f4f762d315efe211d8331e4a4af9", + "size": 217648, + "subdir": "linux-64", + "timestamp": 1645455581201, + "version": "2.1.2" + }, + "gmpy2-2.1.2-py39heeb90bb_0.tar.bz2": { + "build": "py39heeb90bb_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.5.0", + "mpc", + "mpfr >=4.0.2,<5.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "ae2924a47ff1c78b01088a248f76e673", + "name": "gmpy2", + "sha256": "e0b2501055bc7b93d1d63e634ef7305916950ce4b838d4ed0353e1d700bbaa70", + "size": 217855, + "subdir": "linux-64", + "timestamp": 1645438799445, + "version": "2.1.2" + }, + "gn-0.0.20190712172645-he6710b0_2.tar.bz2": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "896e16f82bce9e94225fc7ce71be44f2", + "name": "gn", + "sha256": "e56b4fab5e554a193cc110b9099017dc34f273343aa19b33086bc655ccc0c26b", + "size": 820855, + "subdir": "linux-64", + "timestamp": 1591809863667, + "version": "0.0.20190712172645" + }, + "gn-0.0.20200720112859-hf484d3e_2.tar.bz2": { + "build": "hf484d3e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c8df8ea7e21edebb412a3ea49984f631", + "name": "gn", + "sha256": "e77271df7826b4634a7fac56ffcc155476682ad32621fc2840aebe3e26994cd7", + "size": 1034369, + "subdir": "linux-64", + "timestamp": 1596862074363, + "version": "0.0.20200720112859" + }, + "gn-0.0.20200909083119-h2531618_2.tar.bz2": { + "build": "h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e221126d5b66db3417ce7adaa6482fcc", + "name": "gn", + "sha256": "6c1a3b8c3d8d7ff4a2b609240de74733767b9fdc754853337ba822c288fca8ba", + "size": 1063134, + "subdir": "linux-64", + "timestamp": 1605068825257, + "version": "0.0.20200909083119" + }, + "gnutls-3.6.15-he1e5248_0.tar.bz2": { + "build": "he1e5248_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "libidn2 >=2,<3.0a0", + "libstdcxx-ng >=7.3.0", + "libtasn1 >=4.16.0,<5.0a0", + "libunistring >=0,<1.0a0", + "nettle >=3.7.2,<3.8.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "6f59b4688f08f47023eb2d374478984e", + "name": "gnutls", + "sha256": "952785be03fb6b3c10952f7ebf5c11a4685a29b89137c47864a47e2c2e643375", + "size": 1246670, + "subdir": "linux-64", + "timestamp": 1617814418590, + "version": "3.6.15" + }, + "gnutls-3.6.5-h71b1129_1002.tar.bz2": { + "build": "h71b1129_1002", + "build_number": 1002, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nettle >=3.4.1", + "nettle >=3.4.1,<3.5.0a0" + ], + "license": "LGPLv2.1", + "license_family": "LGPL", + "md5": "d0c538d74c757902d2b5c9b755791cc5", + "name": "gnutls", + "sha256": "454950810a71a7d1bfda5693da22d9a9c7b54497ebb8adf6f8908907c34ec7d7", + "size": 2038701, + "subdir": "linux-64", + "timestamp": 1587125136161, + "version": "3.6.5" + }, + "go-1.10.3-3.tar.bz2": { + "build": "3", + "build_number": 3, + "depends": [ + "go_linux-64 1.10.3 h0f5337a_3" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "5f0a0d38bd986265cfe251fd0c283c28", + "name": "go", + "sha256": "b4e73f38968455d74b56a530c36c11fb0ba380b83e7d9ecfbd99481fd9d5b0c5", + "size": 7184, + "subdir": "linux-64", + "timestamp": 1537370191397, + "version": "1.10.3" + }, + "go-1.11.4-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "go_linux-64 1.11.4 h0f5337a_0" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "2843df1f815162c7582ef63ace428e20", + "name": "go", + "sha256": "036b8b0bf29e80c5d8c67ec2bf55d612b77e75cc60ff847c56f527f0b2ffdb59", + "size": 11304, + "subdir": "linux-64", + "timestamp": 1544962598792, + "version": "1.11.4" + }, + "go-1.16.5-h59941bc_0.tar.bz2": { + "build": "h59941bc_0", + "build_number": 0, + "constrains": [ + "gfortran_linux-64 9.3.*", + "gcc_linux-64 9.3.*", + "gxx_linux-64 9.3.*" + ], + "depends": [ + "_go_select ==2.3.0 cgo", + "libgcc-ng >=9.3.0", + "libgfortran-ng", + "libgfortran5 >=9.3.0", + "libstdcxx-ng >=9.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "161c1ea10e75157de73ccac7f7a14c81", + "name": "go", + "sha256": "04555151af9d1f85bedd793ad56e9d33441ad4757322d79c36970a76777eba88", + "size": 127216685, + "subdir": "linux-64", + "timestamp": 1623674097722, + "version": "1.16.5" + }, + "go-1.16.5-hb589e2e_0.tar.bz2": { + "build": "hb589e2e_0", + "build_number": 0, + "depends": [ + "_go_select ==2.2.0 nocgo" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8b6082fb4f92f9038e72305f54c6ccef", + "name": "go", + "sha256": "33d725fdfcd4838aa7de0c9b1c0cefcc40da8be7bc0d61fa7ab28c0f1a03b4b1", + "size": 127188695, + "subdir": "linux-64", + "timestamp": 1623660026344, + "version": "1.16.5" + }, + "go-1.16.5-hfe6e22e_0.tar.bz2": { + "build": "hfe6e22e_0", + "build_number": 0, + "constrains": [ + "gxx_linux-64 8.4.*", + "gcc_linux-64 8.4.*", + "gfortran_linux-64 8.4.*" + ], + "depends": [ + "_go_select ==2.3.0 cgo", + "libgcc-ng >=8.4.0", + "libgfortran-ng", + "libgfortran5 >=8.4.0", + "libstdcxx-ng >=8.4.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d0d1550c551c78ac100fdf5527138d35", + "name": "go", + "sha256": "e8a133f8b09a2f541ef5511b7f44e77b1d8540362692c0f0c44bb72e0bd71198", + "size": 127313305, + "subdir": "linux-64", + "timestamp": 1623674057291, + "version": "1.16.5" + }, + "go-1.19.1-hb589e2e_0.tar.bz2": { + "build": "hb589e2e_0", + "build_number": 0, + "depends": [ + "_go_select ==2.2.0 nocgo" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "460694e4a1b04eeb3874a00f012f9f0a", + "name": "go", + "sha256": "b618d75b8240768628bfb056ca1544d933a56e274745fd921215ce8cde2e2f9d", + "size": 151879654, + "subdir": "linux-64", + "timestamp": 1665476726225, + "version": "1.19.1" + }, + "go-1.19.1-hcefc947_0.tar.bz2": { + "build": "hcefc947_0", + "build_number": 0, + "constrains": [ + "gxx_linux-64 11.2.0.*", + "gcc_linux-64 11.2.0.*", + "gfortran_linux-64 11.2.0.*" + ], + "depends": [ + "_go_select ==2.3.0 cgo", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "572385b58c0d15524282e3910ab067cd", + "name": "go", + "sha256": "859f33a161373d37be62892910eeffb6f92fd5489e4cbedd290e482fe3c72869", + "size": 152024071, + "subdir": "linux-64", + "timestamp": 1665477429097, + "version": "1.19.1" + }, + "go-1.19.3-hb589e2e_0.tar.bz2": { + "build": "hb589e2e_0", + "build_number": 0, + "depends": [ + "_go_select ==2.2.0 nocgo" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3ba0c214ecc282ac7435d51b4e41e6d5", + "name": "go", + "sha256": "a1da98819977a9e9a0030eac616c11ab23cb64262500f7603c5383d1a1989fcb", + "size": 151807657, + "subdir": "linux-64", + "timestamp": 1673315087267, + "version": "1.19.3" + }, + "go-1.19.3-hcefc947_0.tar.bz2": { + "build": "hcefc947_0", + "build_number": 0, + "constrains": [ + "gcc_linux-64 11.2.0.*", + "gfortran_linux-64 11.2.0.*", + "gxx_linux-64 11.2.0.*" + ], + "depends": [ + "_go_select ==2.3.0 cgo", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4096e6032bd726b388ec0e068864f4e1", + "name": "go", + "sha256": "73efc50d6ae123d290f21aeb7369f8f901a13810e8894856b8c91daf054ca71c", + "size": 151976644, + "subdir": "linux-64", + "timestamp": 1673315786898, + "version": "1.19.3" + }, + "go-cgo-1.16.5-h480a41b_0.tar.bz2": { + "build": "h480a41b_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 8.4.*", + "go 1.16.5 hfe6e22e_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "623db5d79a5c8c8e8a4226b8aaecb825", + "name": "go-cgo", + "sha256": "e95f00e210fe5bdac13b5cf5cc065d66462797776cc4081c37d0d2ba0b54cc66", + "size": 32034, + "subdir": "linux-64", + "timestamp": 1623674158531, + "version": "1.16.5" + }, + "go-cgo-1.16.5-hd57fb8f_0.tar.bz2": { + "build": "hd57fb8f_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 9.3.*", + "go 1.16.5 h59941bc_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "701062001fd963b2356d1b5ae6ff164d", + "name": "go-cgo", + "sha256": "8aaa838ef70b9afe6a646bc5b3f3df69d320b9286247d99a47a423518ab2010e", + "size": 32026, + "subdir": "linux-64", + "timestamp": 1623674203601, + "version": "1.16.5" + }, + "go-cgo-1.19.1-h043d29a_0.tar.bz2": { + "build": "h043d29a_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 11.2.0.*", + "go 1.19.1 hcefc947_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fd12eee09e1d7533b6931b2e477b6b46", + "name": "go-cgo", + "sha256": "db395bbfc5b43f39710ed4d2c4cfa58bd456f91505b27285ef4cb8f53858d254", + "size": 16768, + "subdir": "linux-64", + "timestamp": 1665477536085, + "version": "1.19.1" + }, + "go-cgo-1.19.3-h043d29a_0.tar.bz2": { + "build": "h043d29a_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 11.2.0.*", + "go 1.19.3 hcefc947_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "16dbcc2db6d037d1e85d4e82a94b494f", + "name": "go-cgo", + "sha256": "2a06b6c5c8db253d5e6a213950823f37ab295c1caa4917e6fa686098be75fc00", + "size": 16775, + "subdir": "linux-64", + "timestamp": 1673315891152, + "version": "1.19.3" + }, + "go-cgo_linux-64-1.16.5-h833015d_0.tar.bz2": { + "build": "h833015d_0", + "build_number": 0, + "depends": [ + "_go_select ==2.3.0 cgo", + "go >=1.16.5,<1.16.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f3589d817a44de17af9fa2757a3dc559", + "name": "go-cgo_linux-64", + "sha256": "c8cb6dd424b0192fd1a593fc0341a759b261bf899bae2f53dfe0750602a9d764", + "size": 32719, + "subdir": "linux-64", + "timestamp": 1623674206463, + "version": "1.16.5" + }, + "go-core-1.10.3-hf39692e_3.tar.bz2": { + "build": "hf39692e_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "bb0b99e4bd9c58fff713a73f274c62ae", + "name": "go-core", + "sha256": "efc0061c69e26bc1a18f2b75e1cac1be49bdc8d670bf13a17eb149a5cda1896b", + "size": 86816083, + "subdir": "linux-64", + "timestamp": 1537370031018, + "version": "1.10.3" + }, + "go-core-1.11.4-hf39692e_0.tar.bz2": { + "build": "hf39692e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "eb80409e1e9539b7ca752048621bf498", + "name": "go-core", + "sha256": "506d7847bbe873de25c15cdd12f75baee9cae89941431684bbec134793b18e2f", + "size": 120652839, + "subdir": "linux-64", + "timestamp": 1544962272460, + "version": "1.11.4" + }, + "go-nocgo-1.16.5-h94e987e_0.tar.bz2": { + "build": "h94e987e_0", + "build_number": 0, + "depends": [ + "go 1.16.5 hb589e2e_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "980e27c23b2b189e86ca163fd5e66a78", + "name": "go-nocgo", + "sha256": "0e45487904a0bff646a14cbc2ba0a8f9e1e3d7cec5f351d2d8a7ec7fb87b7c21", + "size": 32004, + "subdir": "linux-64", + "timestamp": 1623660122898, + "version": "1.16.5" + }, + "go-nocgo-1.19.1-hecb7f51_0.tar.bz2": { + "build": "hecb7f51_0", + "build_number": 0, + "depends": [ + "go 1.19.1 hb589e2e_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9daf29712b49f4e76c29a7c23368d916", + "name": "go-nocgo", + "sha256": "194f32dbe2528a3f617ef525522aa82f4c5625d4cb0930b4171eca333f7c0874", + "size": 16758, + "subdir": "linux-64", + "timestamp": 1665476827893, + "version": "1.19.1" + }, + "go-nocgo-1.19.3-hecb7f51_0.tar.bz2": { + "build": "hecb7f51_0", + "build_number": 0, + "depends": [ + "go 1.19.3 hb589e2e_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7c7a63472f077b2e40d4a1ddd1ba3aa4", + "name": "go-nocgo", + "sha256": "0eedc9da8ad6d6b42a25ae55580384596e0243ef88850bc01289d7de4286814e", + "size": 16756, + "subdir": "linux-64", + "timestamp": 1673315189869, + "version": "1.19.3" + }, + "go-nocgo_linux-64-1.16.5-he21932f_0.tar.bz2": { + "build": "he21932f_0", + "build_number": 0, + "depends": [ + "_go_select ==2.2.0 nocgo", + "go >=1.16.5,<1.16.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50fd00075381438127f4fbd0e8ceac5a", + "name": "go-nocgo_linux-64", + "sha256": "64fe43d91d46b14f802975dca32b4fb0f1c65ee73561b955acfc380e2727f104", + "size": 32684, + "subdir": "linux-64", + "timestamp": 1623660125663, + "version": "1.16.5" + }, + "go_linux-32-1.11.4-hd1bdc26_0.tar.bz2": { + "build": "hd1bdc26_0", + "build_number": 0, + "depends": [ + "go-core 1.11.4 hf39692e_0" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "26584d1d09c3b3a8a681609e4dd137d3", + "name": "go_linux-32", + "sha256": "7e957f2ff101aaee2ea772d2e2bac3eac10464e436550258a2fc7fc95a8a48c3", + "size": 11585292, + "subdir": "linux-64", + "timestamp": 1544962452615, + "version": "1.11.4" + }, + "go_linux-64-1.10.3-h0f5337a_3.tar.bz2": { + "build": "h0f5337a_3", + "build_number": 3, + "depends": [ + "go-core 1.10.3 hf39692e_3" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "757354fe930aaf30044b6590401b162e", + "name": "go_linux-64", + "sha256": "6c545024152fef8efc593ecc7920d6da78fb46a3cecf568f6d1fb2dc97a3ad47", + "size": 8170389, + "subdir": "linux-64", + "timestamp": 1537370141010, + "version": "1.10.3" + }, + "go_linux-64-1.11.4-h0f5337a_0.tar.bz2": { + "build": "h0f5337a_0", + "build_number": 0, + "depends": [ + "go-core 1.11.4 hf39692e_0" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "9e8a0ea7afbe87bd0b72739a0692c5c8", + "name": "go_linux-64", + "sha256": "9aecb7f1f24ea09987fcb0dfbaff07e4fd54c7e44358e011193c6bd438c09c40", + "size": 11709711, + "subdir": "linux-64", + "timestamp": 1544962477735, + "version": "1.11.4" + }, + "go_linux-ppc64le-1.11.4-hca29223_0.tar.bz2": { + "build": "hca29223_0", + "build_number": 0, + "depends": [ + "go-core 1.11.4 hf39692e_0" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "d2815e15d0471fb097f43c9655b9082e", + "name": "go_linux-ppc64le", + "sha256": "3c5ad3efd49cbdd5846576827e20f05591eb147a274d8842b61b95d1a2345d5c", + "size": 10984512, + "subdir": "linux-64", + "timestamp": 1544962503776, + "version": "1.11.4" + }, + "go_osx-64-1.10.3-h144c09f_3.tar.bz2": { + "build": "h144c09f_3", + "build_number": 3, + "depends": [ + "go-core 1.10.3 hf39692e_3" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "e20160d1e876b09f7d3c0b7804261f66", + "name": "go_osx-64", + "sha256": "e4c84b770fab044210d0fa141edda59af930196bb41006e7bd8149a57e47a59d", + "size": 8189413, + "subdir": "linux-64", + "timestamp": 1537370162401, + "version": "1.10.3" + }, + "go_osx-64-1.11.4-h144c09f_0.tar.bz2": { + "build": "h144c09f_0", + "build_number": 0, + "depends": [ + "go-core 1.11.4 hf39692e_0" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "cb0fc0874c72f5a51354280c15b740c4", + "name": "go_osx-64", + "sha256": "3297f729cc06aa5849eada5af75d7cf2957e32adbc6e1615ba088805d938ae72", + "size": 11735784, + "subdir": "linux-64", + "timestamp": 1544962530352, + "version": "1.11.4" + }, + "go_win-32-1.11.4-h03c23ce_0.tar.bz2": { + "build": "h03c23ce_0", + "build_number": 0, + "depends": [ + "go-core 1.11.4 hf39692e_0" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "d4012f993a9bcbbc96c9c0bfd524e4d6", + "name": "go_win-32", + "sha256": "da2f217d2435b64a070a4fe5f7a50b25d8ffd6ea20d840138a27d894c943b0eb", + "size": 11563361, + "subdir": "linux-64", + "timestamp": 1544962557611, + "version": "1.11.4" + }, + "go_win-64-1.10.3-h2df250f_3.tar.bz2": { + "build": "h2df250f_3", + "build_number": 3, + "depends": [ + "go-core 1.10.3 hf39692e_3" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "62efaed58fe684f4fcc9ad00d97b25f8", + "name": "go_win-64", + "sha256": "f4faa8e41212b6bb623243a9a6307a588096faac585ab4f4121cd7c789da316a", + "size": 8199532, + "subdir": "linux-64", + "timestamp": 1537370184055, + "version": "1.10.3" + }, + "go_win-64-1.11.4-h2df250f_0.tar.bz2": { + "build": "h2df250f_0", + "build_number": 0, + "depends": [ + "go-core 1.11.4 hf39692e_0" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "3470f33a2b7fde22c621947e4204c451", + "name": "go_win-64", + "sha256": "0f7cced68be61442d96def64beecbcc52bd6b56ad5b5afed11040954669415ee", + "size": 11701922, + "subdir": "linux-64", + "timestamp": 1544962583474, + "version": "1.11.4" + }, + "gobject-introspection-1.53.5-py27h02755b6_0.tar.bz2": { + "build": "py27h02755b6_0", + "build_number": 0, + "depends": [ + "glib >=2.53.6,<3.0a0", + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "9e05b5187a079d67d25b79978ca32420", + "name": "gobject-introspection", + "sha256": "6d3c6389e856c5b91e25f2bf3fe76b898035b7ac01f0300c97edce580f1f10ea", + "size": 1323545, + "subdir": "linux-64", + "timestamp": 1505744109151, + "version": "1.53.5" + }, + "gobject-introspection-1.53.5-py27h26494a4_0.tar.bz2": { + "build": "py27h26494a4_0", + "build_number": 0, + "depends": [ + "glib >=2.53.6,<3.0a0", + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "5a684502e9eba75217d7d1ce3879229c", + "name": "gobject-introspection", + "sha256": "6c5644b1bb36d4c0be6df402b7f4360d02da1bb7abb9246c01806b2f8ab16dd4", + "size": 1323769, + "subdir": "linux-64", + "timestamp": 1507907868257, + "version": "1.53.5" + }, + "gobject-introspection-1.53.5-py35hcfa166f_0.tar.bz2": { + "build": "py35hcfa166f_0", + "build_number": 0, + "depends": [ + "glib >=2.53.6,<3.0a0", + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "29b124592595a289ee356e714370e963", + "name": "gobject-introspection", + "sha256": "b504ba1814b06e6dbc8b3f63cb07b2d197ebb88ad655a8084180ce98f15db890", + "size": 1318244, + "subdir": "linux-64", + "timestamp": 1507907932884, + "version": "1.53.5" + }, + "gobject-introspection-1.53.5-py36h0c36277_0.tar.bz2": { + "build": "py36h0c36277_0", + "build_number": 0, + "depends": [ + "glib >=2.53.6,<3.0a0", + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "ff7ba06f64e5956cdb7a4087e7d247b9", + "name": "gobject-introspection", + "sha256": "9bfb6bd66ad2d8a607ff151afec4e2855ea6d129fc7e213c8d3bc2f9b86619a6", + "size": 1310016, + "subdir": "linux-64", + "timestamp": 1507907991005, + "version": "1.53.5" + }, + "gobject-introspection-1.53.5-py36h92d389f_0.tar.bz2": { + "build": "py36h92d389f_0", + "build_number": 0, + "depends": [ + "glib >=2.53.6,<3.0a0", + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "0066af9f913cab5c82d1fc1daeeb5445", + "name": "gobject-introspection", + "sha256": "6b0775eeb3d878721e20a0b89ef7efc53eda33fef54a68c2b8ebf5f46ebfd3d6", + "size": 1310488, + "subdir": "linux-64", + "timestamp": 1505744228634, + "version": "1.53.5" + }, + "gobject-introspection-1.56.1-py27h085f2ab_0.tar.bz2": { + "build": "py27h085f2ab_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "6611c53ae3cb9219b680655732b439bb", + "name": "gobject-introspection", + "sha256": "5e2195198f5ea8b9fa71c098ac774d00fa93913f791db68c7cbe0d19eb82523d", + "size": 1324422, + "subdir": "linux-64", + "timestamp": 1523669888567, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py27hbc4ca2d_1.tar.bz2": { + "build": "py27hbc4ca2d_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "b565c59f01296ebd73804e6c569191de", + "name": "gobject-introspection", + "sha256": "f1beb949a6ef1b27da9acce7ca09a8b490d8aa0d6f1a25b9a2a450449e9fbfa8", + "size": 1324512, + "subdir": "linux-64", + "timestamp": 1527187905744, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py27hbc4ca2d_2.tar.bz2": { + "build": "py27hbc4ca2d_2", + "build_number": 2, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "b90e91d1fec9b9078f0dfee3154976a0", + "name": "gobject-introspection", + "sha256": "820976f017bdb29681230eabd62390a180815ccd9eff5d3a98f6e4ccd91b3992", + "size": 1323755, + "subdir": "linux-64", + "timestamp": 1527894780765, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py35h085f2ab_0.tar.bz2": { + "build": "py35h085f2ab_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "c9a0e7226568bdaf5214585ff9cc29a3", + "name": "gobject-introspection", + "sha256": "2d5fa90fc8a87d9f4837547862e2f3c93234ad4ea56948feb53964485748ceee", + "size": 1319979, + "subdir": "linux-64", + "timestamp": 1523670064585, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py35hbc4ca2d_1.tar.bz2": { + "build": "py35hbc4ca2d_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "71de2ea6fbd96a53a9be2f66bb324fb3", + "name": "gobject-introspection", + "sha256": "0ffd248b72660fe5a26048a645ac0a1c4eeb454ae72d23e4c43dac9927d5fbaa", + "size": 1320440, + "subdir": "linux-64", + "timestamp": 1527187932305, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py35hbc4ca2d_2.tar.bz2": { + "build": "py35hbc4ca2d_2", + "build_number": 2, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "d7430e193e060891dbc1911bc05baf59", + "name": "gobject-introspection", + "sha256": "44019409c7f0d324ae6e1fa978e2136f92da204b089f5a41bf2cad779cf19d20", + "size": 1319890, + "subdir": "linux-64", + "timestamp": 1527894780610, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py36h085f2ab_0.tar.bz2": { + "build": "py36h085f2ab_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "54ac9e7ed3f5edc3df4ad047fbf64c72", + "name": "gobject-introspection", + "sha256": "1540018af92eca75f7d28ec93eeda22481fbeedfadad27db5b6014dd81da825b", + "size": 1313038, + "subdir": "linux-64", + "timestamp": 1523670105791, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py36hbc4ca2d_1.tar.bz2": { + "build": "py36hbc4ca2d_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "b2dcc09d76857332bc6c03dc7b17646f", + "name": "gobject-introspection", + "sha256": "a3c259a99d37430d5075e0e12f83a3f353b0d177995f3ae415105713ec8d83dd", + "size": 1312926, + "subdir": "linux-64", + "timestamp": 1527187898494, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py36hbc4ca2d_2.tar.bz2": { + "build": "py36hbc4ca2d_2", + "build_number": 2, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "d2a51edabf8c5fee9e1d97c10dc2a8ae", + "name": "gobject-introspection", + "sha256": "ebd066cb3a4970ca75e9a1cd93ce2d97f669984b36a6dca2c2beb477f3298978", + "size": 1312343, + "subdir": "linux-64", + "timestamp": 1527894778182, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py37hbc4ca2d_2.tar.bz2": { + "build": "py37hbc4ca2d_2", + "build_number": 2, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "adbd708dd913801f6380147f8a5ec84e", + "name": "gobject-introspection", + "sha256": "5ff5536b60c9647c01fba43d61c05c3e56423f9fd66da7e3ee47852d128e30c2", + "size": 1312345, + "subdir": "linux-64", + "timestamp": 1530892415851, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py38h56ee657_3.tar.bz2": { + "build": "py38h56ee657_3", + "build_number": 3, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.63.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.43,<9.0a0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "395740ecede05e7f46ddb3ac48cde6c4", + "name": "gobject-introspection", + "sha256": "b33b951d0eb4dd065069737d98e75b3b251a5ecf623f1607ede5f9ef7f41d4ae", + "size": 1367849, + "subdir": "linux-64", + "timestamp": 1589891621683, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py38h9a62fa1_2.tar.bz2": { + "build": "py38h9a62fa1_2", + "build_number": 2, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.63.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.43,<9.0a0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "4755145fecda2211ff342ee0f4ddc48c", + "name": "gobject-introspection", + "sha256": "faf677f4c6740b2748ec2e0b32faa0fdfeff6dbba3c3f38e1d5e1f1268986774", + "size": 1355865, + "subdir": "linux-64", + "timestamp": 1573638896977, + "version": "1.56.1" + }, + "gobject-introspection-1.66.1-py36h94476cb_0.tar.bz2": { + "build": "py36h94476cb_0", + "build_number": 0, + "depends": [ + "glib >=2.63.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "dd576aadaf9a64b83b7849e8189cc837", + "name": "gobject-introspection", + "sha256": "9b93c9ec8a7cca1820ad81938208819649e584a5089238bd8a2f760ba9125121", + "size": 1569441, + "subdir": "linux-64", + "timestamp": 1609185455029, + "version": "1.66.1" + }, + "gobject-introspection-1.66.1-py37h94476cb_0.tar.bz2": { + "build": "py37h94476cb_0", + "build_number": 0, + "depends": [ + "glib >=2.63.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "20b9d232e153575c7f435d95bb4bc00f", + "name": "gobject-introspection", + "sha256": "2a7f7b0c5c3b9d1f4ed4c980ca4a1343a6e3bd15df33681ec724e98b52aef060", + "size": 1560950, + "subdir": "linux-64", + "timestamp": 1609185450282, + "version": "1.66.1" + }, + "gobject-introspection-1.66.1-py38h94476cb_0.tar.bz2": { + "build": "py38h94476cb_0", + "build_number": 0, + "depends": [ + "glib >=2.63.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "51230d909cb87908a78c8ae8c10848cb", + "name": "gobject-introspection", + "sha256": "e709c29d5464daab179738a3c8f06b6e662d2d20ede30e478e47f39a10ae719b", + "size": 1562878, + "subdir": "linux-64", + "timestamp": 1609185434597, + "version": "1.66.1" + }, + "gobject-introspection-1.66.1-py39h94476cb_0.tar.bz2": { + "build": "py39h94476cb_0", + "build_number": 0, + "depends": [ + "glib >=2.63.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "f771df86fbfdc5a503c8d1ba154415d3", + "name": "gobject-introspection", + "sha256": "f556055d8f11171540ca9a62dfccc1f77430161eb88178ccc67044c552e69894", + "size": 1572392, + "subdir": "linux-64", + "timestamp": 1609185460135, + "version": "1.66.1" + }, + "gobject-introspection-1.67.1-py36h2109141_1.tar.bz2": { + "build": "py36h2109141_1", + "build_number": 1, + "depends": [ + "glib >=2.67.4,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "b111c5b1d2fec1530bc6fbbfaf7da796", + "name": "gobject-introspection", + "sha256": "5b9172f369e67fb5861f0e1b4ddf0a26eb2b497a2990c463d68a401c9947d9e2", + "size": 1587863, + "subdir": "linux-64", + "timestamp": 1615661986336, + "version": "1.67.1" + }, + "gobject-introspection-1.67.1-py37h2109141_1.tar.bz2": { + "build": "py37h2109141_1", + "build_number": 1, + "depends": [ + "glib >=2.67.4,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "43997a28c649f322e55d9c4a17232460", + "name": "gobject-introspection", + "sha256": "bce48beba33f6dc4a2538870f75d2a66f697b8cd923276be3179092ee281a416", + "size": 1562000, + "subdir": "linux-64", + "timestamp": 1615660299116, + "version": "1.67.1" + }, + "gobject-introspection-1.67.1-py38h2109141_1.tar.bz2": { + "build": "py38h2109141_1", + "build_number": 1, + "depends": [ + "glib >=2.67.4,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "720e95369755450888104b46d0cccbdb", + "name": "gobject-introspection", + "sha256": "1765fdca445169c6c1e486156cc945e02b460ecddb22560587c81799eac6922a", + "size": 1588543, + "subdir": "linux-64", + "timestamp": 1615662024201, + "version": "1.67.1" + }, + "gobject-introspection-1.67.1-py39h2109141_1.tar.bz2": { + "build": "py39h2109141_1", + "build_number": 1, + "depends": [ + "glib >=2.67.4,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "92294aa4f51c24730fbe75d64dc99277", + "name": "gobject-introspection", + "sha256": "75977d899dcfad076910028de3fd545288030ca04776ead36d9a562e3c6b98df", + "size": 1540338, + "subdir": "linux-64", + "timestamp": 1615662021664, + "version": "1.67.1" + }, + "gobject-introspection-1.68.0-py310hc6cf493_2.tar.bz2": { + "build": "py310hc6cf493_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "229cd83875543351f62e70d864f67d68", + "name": "gobject-introspection", + "sha256": "8bfba1b3d7dfb4b347991af30c3b81e0f5e0f88b43d443607d9d368876ddee37", + "size": 1588097, + "subdir": "linux-64", + "timestamp": 1640790560057, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py36h2109141_1.tar.bz2": { + "build": "py36h2109141_1", + "build_number": 1, + "depends": [ + "glib >=2.67.4,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "9ed92695545abeb675501c39667f46cb", + "name": "gobject-introspection", + "sha256": "eb91949b7ee9756091b98610617528904b15364d33bbbee2036b8ef667bc08da", + "size": 1598489, + "subdir": "linux-64", + "timestamp": 1616269317754, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py36hc6cf493_1.tar.bz2": { + "build": "py36hc6cf493_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "9687974f94d0045fdd7e978eaefdfcaa", + "name": "gobject-introspection", + "sha256": "285ab66c90f5feecedb4c751759ffeb66647b0d1851b9bf61c1db9d3aab37134", + "size": 1581087, + "subdir": "linux-64", + "timestamp": 1631782815981, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py36hc6cf493_2.tar.bz2": { + "build": "py36hc6cf493_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "b99333f418190c8e2b929ea9e685f1c7", + "name": "gobject-introspection", + "sha256": "5d7ae8c550d53317eb3bc394a5504bb89cb6f1379a062e59c2905cfbf4e1d526", + "size": 1594099, + "subdir": "linux-64", + "timestamp": 1632481180932, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py37h2109141_1.tar.bz2": { + "build": "py37h2109141_1", + "build_number": 1, + "depends": [ + "glib >=2.67.4,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "4bb22b0849155a5da2a4d05033157cac", + "name": "gobject-introspection", + "sha256": "cf32b34c7695eee1b361c034583887b0fc41e6b02efd76725922357e4896e8ee", + "size": 1552062, + "subdir": "linux-64", + "timestamp": 1616269311443, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py37hc6cf493_1.tar.bz2": { + "build": "py37hc6cf493_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "9b999d113c2d919ea1415bc63845167d", + "name": "gobject-introspection", + "sha256": "8e164366e64b42cbb6219a38349085f3901c7b923537ff75c7a5fe528a5ad851", + "size": 1590527, + "subdir": "linux-64", + "timestamp": 1631783221956, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py37hc6cf493_2.tar.bz2": { + "build": "py37hc6cf493_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "6c3f7b7d758653638d81b25733842fcf", + "name": "gobject-introspection", + "sha256": "316086e89d24d7f6e325cfda79b438040a53a9557cc90dfea392a1e9e5e70a8a", + "size": 1595899, + "subdir": "linux-64", + "timestamp": 1632481018276, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py37he41a700_3.tar.bz2": { + "build": "py37he41a700_3", + "build_number": 3, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "34597213739b3442a27f03588cb10d87", + "name": "gobject-introspection", + "sha256": "2cb5efd4445b9033276b3120d8be1cfa7ac948874c8da7f7dd5f9fdf9f1232b8", + "size": 1560213, + "subdir": "linux-64", + "timestamp": 1642702386246, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py38h2109141_1.tar.bz2": { + "build": "py38h2109141_1", + "build_number": 1, + "depends": [ + "glib >=2.67.4,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "65c166db563b9243372f0ab84dc3bdd6", + "name": "gobject-introspection", + "sha256": "049c4658a11b8aeea94e2445e136114b11bf94fe54962e4086b249d72532b61e", + "size": 1583327, + "subdir": "linux-64", + "timestamp": 1616268593803, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py38hc6cf493_1.tar.bz2": { + "build": "py38hc6cf493_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "27438bd530275995a8cb2dcaa104ad6d", + "name": "gobject-introspection", + "sha256": "547d65b238292a118407dbda9bc0b8de8a2113d4dad0da193bc9f3983e53ab62", + "size": 1599087, + "subdir": "linux-64", + "timestamp": 1631783212703, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py38hc6cf493_2.tar.bz2": { + "build": "py38hc6cf493_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "9d5bcd4f9f59eef56a9a1a0f02ed8065", + "name": "gobject-introspection", + "sha256": "a6a0354f4424a5e521d096d9c65b7ddefe76a786d30c8b63ccc1a2a76cacba9c", + "size": 1603723, + "subdir": "linux-64", + "timestamp": 1632481162622, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py38he41a700_3.tar.bz2": { + "build": "py38he41a700_3", + "build_number": 3, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "92550d5c6aecd3f22c295c467dd12bee", + "name": "gobject-introspection", + "sha256": "7737cd14fd1cb69d081409fb10e8c68b5800d94943ad5e32ba713d135a97ccca", + "size": 1561322, + "subdir": "linux-64", + "timestamp": 1642702317938, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py39h2109141_1.tar.bz2": { + "build": "py39h2109141_1", + "build_number": 1, + "depends": [ + "glib >=2.67.4,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "b7fc8ab104ca2e2348de248c5db56bde", + "name": "gobject-introspection", + "sha256": "6c948b84477140ba5bd4537b7cf8a640b5f90904c99d75466e83bbcd217389ce", + "size": 1583860, + "subdir": "linux-64", + "timestamp": 1616267279765, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py39hc6cf493_1.tar.bz2": { + "build": "py39hc6cf493_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "9b99fc1595f89d7aad39fafa6b3c1e99", + "name": "gobject-introspection", + "sha256": "1283ac7a705fd6da39e3dc69764e9567405a9736822a5dcab5f1150c0e34dd03", + "size": 1594121, + "subdir": "linux-64", + "timestamp": 1631783210170, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py39hc6cf493_2.tar.bz2": { + "build": "py39hc6cf493_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "f7853a5db0e4e6a1278ce1f52eca88b1", + "name": "gobject-introspection", + "sha256": "695bc4b6170f952c32ce8a8a6d992b472e31fd2f3816fb293b633ed6c49717cc", + "size": 1599263, + "subdir": "linux-64", + "timestamp": 1632481151140, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py39he41a700_3.tar.bz2": { + "build": "py39he41a700_3", + "build_number": 3, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "bcbcc5f6d5e72c16da8a84f795c458f2", + "name": "gobject-introspection", + "sha256": "e20ee68f3354095bc313f25b5f0230ad9baef8c6397322cc76933f745007a02e", + "size": 1561256, + "subdir": "linux-64", + "timestamp": 1642702246699, + "version": "1.68.0" + }, + "gobject-introspection-1.72.0-py310hbb6d50b_0.tar.bz2": { + "build": "py310hbb6d50b_0", + "build_number": 0, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "f58465f3cb0ab0b12a046ae204e2f00d", + "name": "gobject-introspection", + "sha256": "225c381496e37b46175182ca6114eb9059674e4eeba8eb95f7b5ac602a00c68d", + "size": 1609756, + "subdir": "linux-64", + "timestamp": 1656517264696, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py310hbb6d50b_1.tar.bz2": { + "build": "py310hbb6d50b_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "cbadae2c78d3bd9194c7df571efb87c5", + "name": "gobject-introspection", + "sha256": "d8bcbae7b3eca730d073156099a922fe4d1702e7a321920f9288478b1389c27b", + "size": 1625689, + "subdir": "linux-64", + "timestamp": 1669366989970, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py310hbb6d50b_2.tar.bz2": { + "build": "py310hbb6d50b_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "34ad183538d2e10d1b0437b92fe9254a", + "name": "gobject-introspection", + "sha256": "a35b9c7c497a1528ff7cabc11f56a6cd46822259235610e4bcce1a50341fe479", + "size": 1610736, + "subdir": "linux-64", + "timestamp": 1678430377081, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py311hbb6d50b_1.tar.bz2": { + "build": "py311hbb6d50b_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "f4b0a9d25c3947c9743eda312974f12d", + "name": "gobject-introspection", + "sha256": "afe00b82fa113418dd1ae174695933767be96e16ca40a008c1c8a49d9386d7b5", + "size": 1677252, + "subdir": "linux-64", + "timestamp": 1676823485436, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py311hbb6d50b_2.tar.bz2": { + "build": "py311hbb6d50b_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "537ddf2ebc592c72a514a95d338b9cfb", + "name": "gobject-introspection", + "sha256": "028f4607e9ef645ae78842f07f3745066dbdb8cf4821c8e1eefdacdc1e9641bf", + "size": 1667593, + "subdir": "linux-64", + "timestamp": 1679336020517, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py37hbb6d50b_0.tar.bz2": { + "build": "py37hbb6d50b_0", + "build_number": 0, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "0ce638a4276f2d48f1a430507e447194", + "name": "gobject-introspection", + "sha256": "e9dd1388ce3928eea51073feace3810f31bcf5b524c218860ec1528a88c04bc2", + "size": 1607010, + "subdir": "linux-64", + "timestamp": 1656517182296, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py37hbb6d50b_1.tar.bz2": { + "build": "py37hbb6d50b_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "30f84b9091a1ad99bd83f14787e21b35", + "name": "gobject-introspection", + "sha256": "d85c8443fe079f51a4638f845e1d2bb14c129d94363b783abc02d288ad047442", + "size": 1641945, + "subdir": "linux-64", + "timestamp": 1669367000146, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py38hbb6d50b_0.tar.bz2": { + "build": "py38hbb6d50b_0", + "build_number": 0, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "a2bdcfacca027e112786f90714e4fd22", + "name": "gobject-introspection", + "sha256": "21a6dc49698a4b1b0802e8b5f0bf54c15b20d5185067ec6d6e115cc13ed303d2", + "size": 1607621, + "subdir": "linux-64", + "timestamp": 1656517405236, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py38hbb6d50b_1.tar.bz2": { + "build": "py38hbb6d50b_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "de4fe1ebf8ec22f13da1e53a052c4267", + "name": "gobject-introspection", + "sha256": "92ecbe2853b317b6b1d625f31cf7455b8d939ce13cf25a2286b263c6bb6a4607", + "size": 1616870, + "subdir": "linux-64", + "timestamp": 1669367018651, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py38hbb6d50b_2.tar.bz2": { + "build": "py38hbb6d50b_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "60b08f2bbcd4273f1d5e3796fcdf4ad7", + "name": "gobject-introspection", + "sha256": "b8b651d8718d52d43bc1555d9cce815421023ade626fd5750fb33a9c0cc82c69", + "size": 1609868, + "subdir": "linux-64", + "timestamp": 1678430204759, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py39hbb6d50b_0.tar.bz2": { + "build": "py39hbb6d50b_0", + "build_number": 0, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "308baa1728e5b8c6db901ff158669560", + "name": "gobject-introspection", + "sha256": "6bbd1df79a86ce0bc5359d59fb5f5f3421355d10d3f4106e34e7d1b48c527929", + "size": 1607702, + "subdir": "linux-64", + "timestamp": 1656517334776, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py39hbb6d50b_1.tar.bz2": { + "build": "py39hbb6d50b_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "90f259c57180c0ab50225822dff19632", + "name": "gobject-introspection", + "sha256": "b472229544c22d0a37f4012345c0c6d7e0abe4362eba7c96573101f0583f97d8", + "size": 1597127, + "subdir": "linux-64", + "timestamp": 1669367015091, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py39hbb6d50b_2.tar.bz2": { + "build": "py39hbb6d50b_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "7bed41ea69fe4f21eb1bbbd858deccc8", + "name": "gobject-introspection", + "sha256": "f12c3bc557cb9a55bd126c3a0b948b8ddcff00da1ef4558ff484ec304a291490", + "size": 1610716, + "subdir": "linux-64", + "timestamp": 1678430292045, + "version": "1.72.0" + }, + "google-api-core-1.16.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "google-auth >=0.4.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "56c3013c26e39cbc11e9cb41697bbe6a", + "name": "google-api-core", + "sha256": "de30abadc7ff4c6fa57a52965762f253b4bc869c11f1d8b4d727ae642a932802", + "size": 90576, + "subdir": "linux-64", + "timestamp": 1586571786143, + "version": "1.16.0" + }, + "google-api-core-1.16.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "google-auth >=0.4.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "5816713829d05637a2c42dbab17eef9f", + "name": "google-api-core", + "sha256": "620203c25a34035c56be4d16c2ba5ea6f7648e3938acf6ae5206ee4ec6ec7394", + "size": 90690, + "subdir": "linux-64", + "timestamp": 1586571788882, + "version": "1.16.0" + }, + "google-api-core-1.16.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "google-auth >=0.4.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "60136b646b68496e1d40b336879e8f43", + "name": "google-api-core", + "sha256": "e4aba4f9dd09726864819eb4c5782d0bd3084c80ab23af0a5b6c7c91051881a5", + "size": 91102, + "subdir": "linux-64", + "timestamp": 1586571758910, + "version": "1.16.0" + }, + "google-api-core-1.17.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7c8b58584d9d8a9bac5f46dedec1f71e", + "name": "google-api-core", + "sha256": "3e159e0d5bd5c0c36940922c33e58e86b0422c5726aba1bed50db1ef9cc3bca3", + "size": 91266, + "subdir": "linux-64", + "timestamp": 1588594642046, + "version": "1.17.0" + }, + "google-api-core-1.17.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "545e9ab599c7fbeae08d921ca8b9ab32", + "name": "google-api-core", + "sha256": "af0a21670069a3765dd9bfe638a0721a004011b922fa7d9533bcd11d4d581063", + "size": 91146, + "subdir": "linux-64", + "timestamp": 1588594618233, + "version": "1.17.0" + }, + "google-api-core-1.17.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "3f01072835c51ba04b7a4f9606617827", + "name": "google-api-core", + "sha256": "488aab8dc9c47d3e4ce6f35e076c715a0a50ee77d6c73c7135a72e1001ba10e7", + "size": 91591, + "subdir": "linux-64", + "timestamp": 1588594639220, + "version": "1.17.0" + }, + "google-api-core-1.20.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "566eff44e6ec28d105cdbb6080da6f8a", + "name": "google-api-core", + "sha256": "3315e5b6b48ffefc73f6e575652fbd5963c77e94440447504f9ef35ea38929bd", + "size": 103087, + "subdir": "linux-64", + "timestamp": 1604438236344, + "version": "1.20.0" + }, + "google-api-core-1.20.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b09f539488da13738bebe4f1f4b86854", + "name": "google-api-core", + "sha256": "971e0e35047b9683cb0c5b78a7f458b6a783a72d437134f0b8aa20166cafb2d4", + "size": 103234, + "subdir": "linux-64", + "timestamp": 1604438225060, + "version": "1.20.0" + }, + "google-api-core-1.20.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a6601fb44b9c53e88faee87d146e53d4", + "name": "google-api-core", + "sha256": "5ff1f673464445cfa95a33ce29be6443633e0f72e50d09d20acae4b09dddc3a6", + "size": 103550, + "subdir": "linux-64", + "timestamp": 1604438257657, + "version": "1.20.0" + }, + "google-api-core-1.20.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.9,<3.10.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ff314097ef011f406e556bcbc9126adc", + "name": "google-api-core", + "sha256": "2364ba698799227288ae7311574067d7fcf444c40d1d93eefa5d54c998e0c2d5", + "size": 103498, + "subdir": "linux-64", + "timestamp": 1636035850990, + "version": "1.20.0" + }, + "google-api-core-1.22.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "87f6a5899f9d67691ea3037f373927a1", + "name": "google-api-core", + "sha256": "bc63ed5fc35191d0ce0da53bf01906f0668f3749004b3e77a0753d681ebaffef", + "size": 103453, + "subdir": "linux-64", + "timestamp": 1601307118120, + "version": "1.22.2" + }, + "google-api-core-1.22.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "fe5c3f1880c94dfd053060ad109fe3a2", + "name": "google-api-core", + "sha256": "945cf8351ab1805d485bc0d5d0ebc3b48c73d32ca86ef1f1073a5a7b7a13d0f2", + "size": 103567, + "subdir": "linux-64", + "timestamp": 1601307091464, + "version": "1.22.2" + }, + "google-api-core-1.22.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "cbb0d32ac51a6b8a7a85c8e4f1196df9", + "name": "google-api-core", + "sha256": "3f5ce8d0e63cabd7d8d3bf399f922f37304db0a5a161558b10504b2d4a5cbdb0", + "size": 103909, + "subdir": "linux-64", + "timestamp": 1601307116386, + "version": "1.22.2" + }, + "google-api-core-2.10.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio-status >=1.33.2,<2.0dev", + "grpcio >=1.33.2,<2.0dev", + "grpcio-gcp >=0.2.2,<1.0dev" + ], + "depends": [ + "google-auth >=1.25.0,<3.0dev", + "googleapis-common-protos >=1.56.2,<2.0dev", + "protobuf >=3.20.1", + "python >=3.10,<3.11.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "d8325fa24f2ea0f161858634628feeec", + "name": "google-api-core", + "sha256": "dbab3c0d71617c084ab15bf21dc3d83035e23f99e75ec6b4a3e7089af502b841", + "size": 124316, + "subdir": "linux-64", + "timestamp": 1663638672043, + "version": "2.10.1" + }, + "google-api-core-2.10.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio >=1.33.2,<2.0dev", + "grpcio-status >=1.33.2,<2.0dev", + "grpcio-gcp >=0.2.2,<1.0dev" + ], + "depends": [ + "google-auth >=1.25.0,<3.0dev", + "googleapis-common-protos >=1.56.2,<2.0dev", + "protobuf >=3.20.1", + "python >=3.11,<3.12.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f32e477dd41e1d55d471ec9cec00c54c", + "name": "google-api-core", + "sha256": "289e910278d8daff7fc781a82f8e20843be156b413ea387eafa1596891e18199", + "size": 152305, + "subdir": "linux-64", + "timestamp": 1676839889187, + "version": "2.10.1" + }, + "google-api-core-2.10.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio-status >=1.33.2,<2.0dev", + "grpcio >=1.33.2,<2.0dev", + "grpcio-gcp >=0.2.2,<1.0dev" + ], + "depends": [ + "google-auth >=1.25.0,<3.0dev", + "googleapis-common-protos >=1.56.2,<2.0dev", + "protobuf >=3.20.1", + "python >=3.7,<3.8.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "4ddeed0927bb055eb209e1d66d911e60", + "name": "google-api-core", + "sha256": "26b7fe57ea2611bd70eb7606226fc0118b71acbc36702de5ede106eb4bf0b9d2", + "size": 122573, + "subdir": "linux-64", + "timestamp": 1663638871279, + "version": "2.10.1" + }, + "google-api-core-2.10.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio-status >=1.33.2,<2.0dev", + "grpcio >=1.33.2,<2.0dev", + "grpcio-gcp >=0.2.2,<1.0dev" + ], + "depends": [ + "google-auth >=1.25.0,<3.0dev", + "googleapis-common-protos >=1.56.2,<2.0dev", + "protobuf >=3.20.1", + "python >=3.8,<3.9.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "796bf741bd6b7530cdbf7b3dd1aebbb4", + "name": "google-api-core", + "sha256": "17ad468dbe2e53aed909c7b204b6fd4a03398041064f3117a3afdc3fcf382545", + "size": 123237, + "subdir": "linux-64", + "timestamp": 1663638806063, + "version": "2.10.1" + }, + "google-api-core-2.10.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio-status >=1.33.2,<2.0dev", + "grpcio >=1.33.2,<2.0dev", + "grpcio-gcp >=0.2.2,<1.0dev" + ], + "depends": [ + "google-auth >=1.25.0,<3.0dev", + "googleapis-common-protos >=1.56.2,<2.0dev", + "protobuf >=3.20.1", + "python >=3.9,<3.10.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "d3c738b0d9606986b1b1ba4d6e81c0fa", + "name": "google-api-core", + "sha256": "f2b45ad93abfbc51c1b327caabd00dff1865ceb01ee2f5266bd88170682b713f", + "size": 123356, + "subdir": "linux-64", + "timestamp": 1663638739929, + "version": "2.10.1" + }, + "google-api-core-grpc-1.16.0-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "google-api-core >=1.16,<1.17.0a0", + "grpcio >=1.8.2" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "ef054fe5f60caa5b9bb8b9c4747f489a", + "name": "google-api-core-grpc", + "sha256": "5a94c234fe75293b558f63f6d36e854d2e74ad00b7deb3df104f70d6520b7876", + "size": 10281, + "subdir": "linux-64", + "timestamp": 1586571801386, + "version": "1.16.0" + }, + "google-api-core-grpc-1.17.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "google-api-core >=1.17,<1.18.0a0", + "grpcio >=1.8.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9bb2849d80c353ccfb3f436b73607162", + "name": "google-api-core-grpc", + "sha256": "f38def1c0a9893e37827a2c71c140105a8de21f8ec7fce95fb8edfc82612cd5b", + "size": 10362, + "subdir": "linux-64", + "timestamp": 1588594651151, + "version": "1.17.0" + }, + "google-api-core-grpc-1.20.0-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.20,<1.21.0a0", + "grpcio >=1.8.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "d43d395013e006c381359ffe925588c2", + "name": "google-api-core-grpc", + "sha256": "7f5fb5a7fd13ecc03c9329de518179c84d0f268854a48ce3471d927bf9786a5e", + "size": 10323, + "subdir": "linux-64", + "timestamp": 1604438267854, + "version": "1.20.0" + }, + "google-api-core-grpc-1.22.2-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "google-api-core >=1.22,<1.23.0a0", + "grpcio >=1.8.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "49cffffa08ed332c0f555fe41f96efd3", + "name": "google-api-core-grpc", + "sha256": "f49a8031c9f9ab87b6eb9b75d23b9f0bdaed6a9800542c9b5d833f78a89619d9", + "size": 10292, + "subdir": "linux-64", + "timestamp": 1601307099377, + "version": "1.22.2" + }, + "google-api-core-grpc-1.25.1-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.25,<1.26.0a0", + "grpcio >=1.29.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8731b876539def47f6515e73c6ba0a4d", + "name": "google-api-core-grpc", + "sha256": "0594337c549ffd11433dae7935a6df9964720f6d409e0899d90224dec6c92edf", + "size": 11599, + "subdir": "linux-64", + "timestamp": 1613979807101, + "version": "1.25.1" + }, + "google-api-core-grpc-2.10.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py310h06a4308_0", + "grpcio >=1.33.2,<2.0dev", + "grpcio-status >=1.33.2,<2.0dev", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "760667e6d9eef908ae7f3dd954bc6505", + "name": "google-api-core-grpc", + "sha256": "f79e17ff229d69ea13e1b03f1c7feaf27b7231fb92c027ac08614a21e1ff54f6", + "size": 4030, + "subdir": "linux-64", + "timestamp": 1663638677868, + "version": "2.10.1" + }, + "google-api-core-grpc-2.10.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py311h06a4308_0", + "grpcio >=1.33.2,<2.0dev", + "grpcio-status >=1.33.2,<2.0dev", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "98f4be622f148f75fe8989be4b44a2f3", + "name": "google-api-core-grpc", + "sha256": "874454cc6bc1ba2ea7852321fc252e030070644bb5dad7098522744d574c1852", + "size": 4336, + "subdir": "linux-64", + "timestamp": 1676839893371, + "version": "2.10.1" + }, + "google-api-core-grpc-2.10.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py37h06a4308_0", + "grpcio >=1.33.2,<2.0dev", + "grpcio-status >=1.33.2,<2.0dev", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "fd4d369ca84c5916555665f83c2728ab", + "name": "google-api-core-grpc", + "sha256": "536bb59f0a2b6898374840f8485e96435c765534da76100802fa5fb586fa6217", + "size": 4012, + "subdir": "linux-64", + "timestamp": 1663638876754, + "version": "2.10.1" + }, + "google-api-core-grpc-2.10.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py38h06a4308_0", + "grpcio >=1.33.2,<2.0dev", + "grpcio-status >=1.33.2,<2.0dev", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f351ffe65ecb710cbcacc022a73b0d25", + "name": "google-api-core-grpc", + "sha256": "3ae71adcd003138138818268d9e0f990daad48473d6b2982a4fcf54fd2f9ba12", + "size": 4012, + "subdir": "linux-64", + "timestamp": 1663638811603, + "version": "2.10.1" + }, + "google-api-core-grpc-2.10.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py39h06a4308_0", + "grpcio >=1.33.2,<2.0dev", + "grpcio-status >=1.33.2,<2.0dev", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "eb38fcdea05a9f46d238257412163fa4", + "name": "google-api-core-grpc", + "sha256": "e58d2e0cb9492514658c6844e86436edf02bb524e3c6cf3479f7582468574728", + "size": 4024, + "subdir": "linux-64", + "timestamp": 1663638745634, + "version": "2.10.1" + }, + "google-api-core-grpcgcp-1.16.0-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "google-api-core-grpcio-gcp >=1.16,<1.17.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "c9dd3d8ab384702e614eff55a8eb310e", + "name": "google-api-core-grpcgcp", + "sha256": "6f3afdd1f18b9a7683f61f15b92db8ad09222bae538864f18dbaa82f8155e1cf", + "size": 10304, + "subdir": "linux-64", + "timestamp": 1586571824931, + "version": "1.16.0" + }, + "google-api-core-grpcgcp-1.17.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "google-api-core-grpcio-gcp >=1.17,<1.18.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "073939c98458807a63a6bb6a48e096c6", + "name": "google-api-core-grpcgcp", + "sha256": "2f487780d82e1a479275f102085b28340853b81fd274a006fc214c282b085a04", + "size": 10355, + "subdir": "linux-64", + "timestamp": 1588594675207, + "version": "1.17.0" + }, + "google-api-core-grpcgcp-1.20.0-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core-grpcio-gcp >=1.20,<1.21.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "1b1509c2a1d453977b556d93fd5d3539", + "name": "google-api-core-grpcgcp", + "sha256": "57550ef01f4b99e5326c502e7fa7ae26aac02f239c5f81bbfe5dde408658d614", + "size": 10301, + "subdir": "linux-64", + "timestamp": 1604438285519, + "version": "1.20.0" + }, + "google-api-core-grpcgcp-1.22.2-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "google-api-core-grpcio-gcp >=1.22,<1.23.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b7cb6774c543fdd7ba61f6f279c0b326", + "name": "google-api-core-grpcgcp", + "sha256": "f7778d73adbb51b2444918a187bf32d0e256ab75e7782f54b6e90e965f0006c2", + "size": 10320, + "subdir": "linux-64", + "timestamp": 1601307154324, + "version": "1.22.2" + }, + "google-api-core-grpcgcp-1.25.1-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core-grpcio-gcp >=1.25,<1.26.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "005f5dad2be003407f0c25c6c1a96aa1", + "name": "google-api-core-grpcgcp", + "sha256": "f9b14e63b06a92ad2702b29030224079ec03b557939bd7bffd6d57d55ef36c14", + "size": 11569, + "subdir": "linux-64", + "timestamp": 1613979824327, + "version": "1.25.1" + }, + "google-api-core-grpcgcp-2.10.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core-grpcio-gcp 2.10.1 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "1338789429f964ae68c8b8fb72b3b6c4", + "name": "google-api-core-grpcgcp", + "sha256": "381001892222973ffa15b1f7797e5d1aeed82824ea244ffb54360fc6bcc6ecc0", + "size": 4042, + "subdir": "linux-64", + "timestamp": 1663638688894, + "version": "2.10.1" + }, + "google-api-core-grpcgcp-2.10.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core-grpcio-gcp 2.10.1 py311h06a4308_0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7baf86ac7a6bd175996ed8066b8534e9", + "name": "google-api-core-grpcgcp", + "sha256": "11367d788a33aac02b23f264abd3ae1b2391c90df31018170806fc59beba7944", + "size": 4351, + "subdir": "linux-64", + "timestamp": 1676839901173, + "version": "2.10.1" + }, + "google-api-core-grpcgcp-2.10.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core-grpcio-gcp 2.10.1 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f20403df48eb6c0458f4e28287b4b0e7", + "name": "google-api-core-grpcgcp", + "sha256": "6e18a42d12710cef28bf2d624b824b2e0c8b9f3aecaf48666cc36ab86ce25fd5", + "size": 4025, + "subdir": "linux-64", + "timestamp": 1663638887137, + "version": "2.10.1" + }, + "google-api-core-grpcgcp-2.10.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core-grpcio-gcp 2.10.1 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c8899a09557ce42c0acb21da420f9cab", + "name": "google-api-core-grpcgcp", + "sha256": "217a38c2f0f483f2e997e89115885f8a2ad6ee44f8d5d1bd7098d936d5729b2e", + "size": 4015, + "subdir": "linux-64", + "timestamp": 1663638821996, + "version": "2.10.1" + }, + "google-api-core-grpcgcp-2.10.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core-grpcio-gcp 2.10.1 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6f314919be2c515488a75fae8a88e435", + "name": "google-api-core-grpcgcp", + "sha256": "d8c1e9f8d428d9a5b518ca98ff9c56ccbbd833f86a0610e227f94a48bae296ce", + "size": 4033, + "subdir": "linux-64", + "timestamp": 1663638756603, + "version": "2.10.1" + }, + "google-api-core-grpcio-gcp-1.16.0-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "google-api-core >=1.16,<1.17.0a0", + "grpcio-gcp" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "1b9b72ccc44b2f38afd3889ee35af0eb", + "name": "google-api-core-grpcio-gcp", + "sha256": "5d083416fbfb109220b00a4b34b177368c787e565203cf2bcd94853043eca83b", + "size": 10324, + "subdir": "linux-64", + "timestamp": 1586571814274, + "version": "1.16.0" + }, + "google-api-core-grpcio-gcp-1.17.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "google-api-core >=1.17,<1.18.0a0", + "grpcio-gcp" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "f344bcb1f123d0a91eab9ba3cac4dfba", + "name": "google-api-core-grpcio-gcp", + "sha256": "40f682a295bd2d9f95fcb89ea32474934baea8d16924d48f0e1c56dc99da8ff6", + "size": 10418, + "subdir": "linux-64", + "timestamp": 1588594663660, + "version": "1.17.0" + }, + "google-api-core-grpcio-gcp-1.20.0-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.20,<1.21.0a0", + "grpcio-gcp" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "39e6aa7acb5080564e46a2ccf39efd89", + "name": "google-api-core-grpcio-gcp", + "sha256": "3594c3b49e88960aa14c81bcc02099a3f3c58806bf3456eaaabedfbe4e3adc56", + "size": 10364, + "subdir": "linux-64", + "timestamp": 1604438278206, + "version": "1.20.0" + }, + "google-api-core-grpcio-gcp-1.22.2-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "google-api-core >=1.22,<1.23.0a0", + "grpcio-gcp" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "4b3ec4f77447bc3edb5e86886d5fe810", + "name": "google-api-core-grpcio-gcp", + "sha256": "69f3b5a7ce430171b750c0530707c63633d14060e1f9db82b658d095f087f337", + "size": 10348, + "subdir": "linux-64", + "timestamp": 1601307107546, + "version": "1.22.2" + }, + "google-api-core-grpcio-gcp-1.25.1-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.25,<1.26.0a0", + "grpcio-gcp" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "33927301ce1cda6bc3c30a768a9b9509", + "name": "google-api-core-grpcio-gcp", + "sha256": "5c142f1cd8aa5b2c2b0ce1df42552c28aed66a4bbea2c55be3daf01427e5ffd5", + "size": 11659, + "subdir": "linux-64", + "timestamp": 1613979816578, + "version": "1.25.1" + }, + "google-api-core-grpcio-gcp-2.10.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py310h06a4308_0", + "grpcio-gcp >=0.2.2,<1.0dev", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9751f75bec9f2b49d91db16e724adbb7", + "name": "google-api-core-grpcio-gcp", + "sha256": "225d51c96881bb46361bd41d8d88f017a4196161bb42bfca21f03a838abf6ca1", + "size": 4049, + "subdir": "linux-64", + "timestamp": 1663638683445, + "version": "2.10.1" + }, + "google-api-core-grpcio-gcp-2.10.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py311h06a4308_0", + "grpcio-gcp >=0.2.2,<1.0dev", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "3658d60a1e3543697753dc49ff19b841", + "name": "google-api-core-grpcio-gcp", + "sha256": "15a25876a15012e2f1406bc035820aa382336a607e20a06fb4639efec8fa793b", + "size": 4350, + "subdir": "linux-64", + "timestamp": 1676839897181, + "version": "2.10.1" + }, + "google-api-core-grpcio-gcp-2.10.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py37h06a4308_0", + "grpcio-gcp >=0.2.2,<1.0dev", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "4bc542f8b9eb1cc9ddf732989e00c2c8", + "name": "google-api-core-grpcio-gcp", + "sha256": "41936a6330f78d34c19e7cb8713e53c9a121e6c8106d085fdc2b43875fe95151", + "size": 4016, + "subdir": "linux-64", + "timestamp": 1663638881968, + "version": "2.10.1" + }, + "google-api-core-grpcio-gcp-2.10.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py38h06a4308_0", + "grpcio-gcp >=0.2.2,<1.0dev", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "998533d248bb0ea55c8d176842454954", + "name": "google-api-core-grpcio-gcp", + "sha256": "21618869227f0bf3c8f96998c541aa264a1a33bd1ce5c69967f4e769bf3f2645", + "size": 4021, + "subdir": "linux-64", + "timestamp": 1663638816857, + "version": "2.10.1" + }, + "google-api-core-grpcio-gcp-2.10.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py39h06a4308_0", + "grpcio-gcp >=0.2.2,<1.0dev", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9f68e40e6211b33abb3640d2a1c759e8", + "name": "google-api-core-grpcio-gcp", + "sha256": "bf8855cf92515aa70ab1222ce1e548f7a70f595b2b91d57bdc1d069340f69a2a", + "size": 4024, + "subdir": "linux-64", + "timestamp": 1663638751134, + "version": "2.10.1" + }, + "google-auth-oauthlib-0.5.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click >=6.0.0", + "google-auth >=1.0.0", + "python >=3.10,<3.11.0a0", + "requests-oauthlib >=0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6fa601b942709067f6e60f31b9400254", + "name": "google-auth-oauthlib", + "sha256": "21eb0c746ed75350feecdb4e6087c08ca43afee660a681bd7f94b384a6eac998", + "size": 27281, + "subdir": "linux-64", + "timestamp": 1660687833850, + "version": "0.5.2" + }, + "google-auth-oauthlib-0.5.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "click >=6.0.0", + "google-auth >=1.0.0", + "python >=3.11,<3.12.0a0", + "requests-oauthlib >=0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1dd67570ddce8e4f80c3bafbf60b1aac", + "name": "google-auth-oauthlib", + "sha256": "35e44bc5abfeaea4f1b119e4aa2d3c38520f53a8ebd469e3b914b1dd8e62a580", + "size": 31045, + "subdir": "linux-64", + "timestamp": 1679340700723, + "version": "0.5.2" + }, + "google-auth-oauthlib-0.5.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click >=6.0.0", + "google-auth >=1.0.0", + "python >=3.7,<3.8.0a0", + "requests-oauthlib >=0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8b11d9d3597010d0ff56231f2d8f162f", + "name": "google-auth-oauthlib", + "sha256": "72944290fe30c5cc7c557fa37b9a7a2ab6d497ede8d8f560daafa14f70b44cc0", + "size": 27122, + "subdir": "linux-64", + "timestamp": 1660687894514, + "version": "0.5.2" + }, + "google-auth-oauthlib-0.5.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=6.0.0", + "google-auth >=1.0.0", + "python >=3.8,<3.9.0a0", + "requests-oauthlib >=0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "849beabcaac9b95fac7eabab1b246f97", + "name": "google-auth-oauthlib", + "sha256": "73f8183706739695ddeb4ced758e05d79439868061877fac14521d582483b460", + "size": 27223, + "subdir": "linux-64", + "timestamp": 1660687864157, + "version": "0.5.2" + }, + "google-auth-oauthlib-0.5.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=6.0.0", + "google-auth >=1.0.0", + "python >=3.9,<3.10.0a0", + "requests-oauthlib >=0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c491192022d2b6339f76e38b1d6f7727", + "name": "google-auth-oauthlib", + "sha256": "16b39c9d16cdd63a2fc306c960fc82d71ade2a68c17b5800130209aaacae76c1", + "size": 27265, + "subdir": "linux-64", + "timestamp": 1660687928336, + "version": "0.5.2" + }, + "google-cloud-core-2.3.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.6,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0.0dev", + "grpcio >=1.38.0,<2.0.0dev", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3280b76f9be0923542b4195a724035f2", + "name": "google-cloud-core", + "sha256": "0cb9c8fc6c2fc9f07edecca5fafe3f885e88288220da874c1fc1fc81d537fc15", + "size": 40556, + "subdir": "linux-64", + "timestamp": 1666887837161, + "version": "2.3.2" + }, + "google-cloud-core-2.3.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.6,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0.0dev", + "grpcio >=1.38.0,<2.0.0dev", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5e0bb2d751b18709124df9fee717af8f", + "name": "google-cloud-core", + "sha256": "c1ee1505845f8b40b26f70b04aa09f11005d713e8875a6975606fdfab28a4a96", + "size": 47527, + "subdir": "linux-64", + "timestamp": 1676844197302, + "version": "2.3.2" + }, + "google-cloud-core-2.3.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.6,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0.0dev", + "grpcio >=1.38.0,<2.0.0dev", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b2c7089d8b8e4ccabcc4136139ff702d", + "name": "google-cloud-core", + "sha256": "b1777a75ff7da6ea48ba3612e3b3be18ad8d7e90023461ff2c8eaf189766b185", + "size": 40206, + "subdir": "linux-64", + "timestamp": 1666887779483, + "version": "2.3.2" + }, + "google-cloud-core-2.3.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.6,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0.0dev", + "grpcio >=1.38.0,<2.0.0dev", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7f34e33e74dc4d5ecaacd8c02fbee683", + "name": "google-cloud-core", + "sha256": "36fd1c88b24dfe3ebbf1a20dd62c3320d20fe3ab5cbe9deaaec07406e2a1b5d5", + "size": 40392, + "subdir": "linux-64", + "timestamp": 1666887808369, + "version": "2.3.2" + }, + "google-cloud-core-2.3.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.6,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0.0dev", + "grpcio >=1.38.0,<2.0.0dev", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4151dc8d7ba32d5f7898e2081c477b05", + "name": "google-cloud-core", + "sha256": "c23e4ea1f5f508ea1ee1ac6a90ce66e6afc2e4c15462fe8b6b3752fe622c1160", + "size": 40390, + "subdir": "linux-64", + "timestamp": 1666887750381, + "version": "2.3.2" + }, + "google-cloud-storage-1.43.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.29.0,<3.0dev", + "google-auth >=1.25.0,<3.0dev", + "google-cloud-core >=1.6.0,<3.0dev", + "google-resumable-media >=1.3.0,<3.0dev", + "protobuf", + "python >=3.10,<3.11.0a0", + "requests >=2.18.0,<3.0.0dev", + "six" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "4d6fc4f63e6a5d3be2e8ffbb3746d15e", + "name": "google-cloud-storage", + "sha256": "84114abd789cc73727efaf525386b6f8a9deb66d44c4505a21d89e01f1c5e5c9", + "size": 129472, + "subdir": "linux-64", + "timestamp": 1654699272170, + "version": "1.43.0" + }, + "google-cloud-storage-1.43.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.29.0,<3.0dev", + "google-auth >=1.25.0,<3.0dev", + "google-cloud-core >=1.6.0,<3.0dev", + "google-resumable-media >=1.3.0,<3.0dev", + "protobuf", + "python >=3.7,<3.8.0a0", + "requests >=2.18.0,<3.0.0dev", + "six" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "803cd19931b36d717fc04e27e86784cd", + "name": "google-cloud-storage", + "sha256": "f5015739588f8a5c41620c472e9e09c45a644f389a5ef7a394e3f86f5075e42c", + "size": 128547, + "subdir": "linux-64", + "timestamp": 1654699305227, + "version": "1.43.0" + }, + "google-cloud-storage-1.43.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.29.0,<3.0dev", + "google-auth >=1.25.0,<3.0dev", + "google-cloud-core >=1.6.0,<3.0dev", + "google-resumable-media >=1.3.0,<3.0dev", + "protobuf", + "python >=3.8,<3.9.0a0", + "requests >=2.18.0,<3.0.0dev", + "six" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ce16f3c24d8dc1eeebb3c5017f589e57", + "name": "google-cloud-storage", + "sha256": "a292a2526511ebb07ab1e43a79b472bb65f05d1838fb1ff4320416f5bc185ae1", + "size": 128937, + "subdir": "linux-64", + "timestamp": 1654699337624, + "version": "1.43.0" + }, + "google-cloud-storage-1.43.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.29.0,<3.0dev", + "google-auth >=1.25.0,<3.0dev", + "google-cloud-core >=1.6.0,<3.0dev", + "google-resumable-media >=1.3.0,<3.0dev", + "protobuf", + "python >=3.9,<3.10.0a0", + "requests >=2.18.0,<3.0.0dev", + "six" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "febb867ec9e3a6d6f7bc9a54817b981d", + "name": "google-cloud-storage", + "sha256": "2cfda1ffbea8ab1fbe7dbae499da16b46097e87f5156b453530e2babab0cd91a", + "size": 134413, + "subdir": "linux-64", + "timestamp": 1654699227079, + "version": "1.43.0" + }, + "google-cloud-storage-2.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.5,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0dev", + "google-cloud-core >=2.3.0,<3.0dev", + "google-resumable-media >=2.3.2", + "protobuf <5.0.0dev", + "python >=3.10,<3.11.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "1955199fb9c183dbc4adabd01f058d73", + "name": "google-cloud-storage", + "sha256": "8efebe95ce0e322bf753e319a445649cffb1a4d6b8ef7192a6de860d750c0915", + "size": 133634, + "subdir": "linux-64", + "timestamp": 1668474027043, + "version": "2.6.0" + }, + "google-cloud-storage-2.6.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.5,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0dev", + "google-cloud-core >=2.3.0,<3.0dev", + "google-resumable-media >=2.3.2", + "protobuf <5.0.0dev", + "python >=3.11,<3.12.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e434b95e2e1c83f0a82cff9649391c4c", + "name": "google-cloud-storage", + "sha256": "f8481b586830dd65d3c7212039cbc2532d534018c82e5682a044825077e2fd93", + "size": 168317, + "subdir": "linux-64", + "timestamp": 1676852626027, + "version": "2.6.0" + }, + "google-cloud-storage-2.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.5,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0dev", + "google-cloud-core >=2.3.0,<3.0dev", + "google-resumable-media >=2.3.2", + "protobuf <5.0.0dev", + "python >=3.7,<3.8.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "53715d27a1e15bd01df991db0a52e4dd", + "name": "google-cloud-storage", + "sha256": "c86468f71ac2eba2e517701ca267080328194e0399f1e07d57c9593154c50876", + "size": 132000, + "subdir": "linux-64", + "timestamp": 1668474056822, + "version": "2.6.0" + }, + "google-cloud-storage-2.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.5,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0dev", + "google-cloud-core >=2.3.0,<3.0dev", + "google-resumable-media >=2.3.2", + "protobuf <5.0.0dev", + "python >=3.8,<3.9.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "83ed0f87d268aaf406542ef61d11caa8", + "name": "google-cloud-storage", + "sha256": "6ae78b1c0d8f1736341a656f291275b2a83c71f18b173422091c2706b754c8e5", + "size": 132905, + "subdir": "linux-64", + "timestamp": 1668473997181, + "version": "2.6.0" + }, + "google-cloud-storage-2.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.5,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0dev", + "google-cloud-core >=2.3.0,<3.0dev", + "google-resumable-media >=2.3.2", + "protobuf <5.0.0dev", + "python >=3.9,<3.10.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "10fe7b9a4135b8f2ba24f31b5c57e31f", + "name": "google-cloud-storage", + "sha256": "748913366778d5d6a0f1c89675b04bf1984ae6a28e6cb5cb7871d70d8c4b30ff", + "size": 132618, + "subdir": "linux-64", + "timestamp": 1668473967548, + "version": "2.6.0" + }, + "google-crc32c-1.0.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3dc471f426b7bab60cd6268eefdfaa84", + "name": "google-crc32c", + "sha256": "881831b5613229130454871f225da45649ea2bc2b89b0e60d69d174a0d10a5ef", + "size": 26596, + "subdir": "linux-64", + "timestamp": 1601305151291, + "version": "1.0.0" + }, + "google-crc32c-1.0.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "330d61bbae99d41e425fe2a2f5681b94", + "name": "google-crc32c", + "sha256": "e84cb2c6ba03b2fef315fe3568e50c4ae405f4390da34e41ab5a40f219ee57f9", + "size": 26580, + "subdir": "linux-64", + "timestamp": 1601305142179, + "version": "1.0.0" + }, + "google-crc32c-1.0.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2793ef2d6efe50a07e8f00dc2fcd369d", + "name": "google-crc32c", + "sha256": "e182c5b5d552d3008aeb758f5aac3fd122e18b7569844e74df30895f29063bc1", + "size": 26592, + "subdir": "linux-64", + "timestamp": 1601305146818, + "version": "1.0.0" + }, + "google-crc32c-1.1.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7a6f8a6199925e0f8a1b97daf83adaf8", + "name": "google-crc32c", + "sha256": "fdd84af85c49b2df7d5273aee4413b388002a85e28a9ce3c005724966bd60279", + "size": 25481, + "subdir": "linux-64", + "timestamp": 1608071254553, + "version": "1.1.0" + }, + "google-crc32c-1.1.0-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3bfde50d0e940140fe5d9995c5c506eb", + "name": "google-crc32c", + "sha256": "704a7de1db61f70dc6189dc0130fa48472f54e58204b3637e6f8dd35ff39763b", + "size": 25459, + "subdir": "linux-64", + "timestamp": 1608056225027, + "version": "1.1.0" + }, + "google-crc32c-1.1.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7905d6acac5bf73e3c3761eae6fc43c4", + "name": "google-crc32c", + "sha256": "6fa66716a334cbd53da1b70e14fb40d25541e6d9123e73e4f2ce1980e84a52fc", + "size": 25504, + "subdir": "linux-64", + "timestamp": 1608071247207, + "version": "1.1.0" + }, + "google-crc32c-1.1.0-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f55111081c73633944ac607aca144137", + "name": "google-crc32c", + "sha256": "15361094cfc723182297d4dbcc44b9fd9d02120ee1fa9f9793836f7c025c9834", + "size": 25454, + "subdir": "linux-64", + "timestamp": 1608056274376, + "version": "1.1.0" + }, + "google-crc32c-1.1.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "970854a8c9805e6675d040a0c2b63f7b", + "name": "google-crc32c", + "sha256": "daf94bce58da177fc87979493722ad76ca6b4f2b35545ba10cbfc10c83603755", + "size": 25497, + "subdir": "linux-64", + "timestamp": 1608071253573, + "version": "1.1.0" + }, + "google-crc32c-1.1.0-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ee78848bf5b650699fd508416cf07e02", + "name": "google-crc32c", + "sha256": "0023baf269328446640bca0951439ba62530231142cba2266ce9fe93466e25b2", + "size": 25473, + "subdir": "linux-64", + "timestamp": 1608056268496, + "version": "1.1.0" + }, + "google-crc32c-1.1.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e7e09ad4fa5bc39ff3ceb5cb288d1922", + "name": "google-crc32c", + "sha256": "9e4c41e9ffdb698ddc4ace691df08f73f8171636ded69d1ea28afe270919d165", + "size": 24915, + "subdir": "linux-64", + "timestamp": 1608071208786, + "version": "1.1.0" + }, + "google-crc32c-1.1.0-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ef7719a319229d4089b4c916ff3b2fcc", + "name": "google-crc32c", + "sha256": "10a07d1806e3c09dbc4d8be2c0e1a9343ee65d4d4111f81109f3c0a713d113cf", + "size": 24893, + "subdir": "linux-64", + "timestamp": 1608056271836, + "version": "1.1.0" + }, + "google-crc32c-1.1.1-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b158a993e400e258dab24502adca77a3", + "name": "google-crc32c", + "sha256": "17ca78b6d076bcdfb49cae60ded19558ec5ddfd3147f738d159c3037b4aad45f", + "size": 24484, + "subdir": "linux-64", + "timestamp": 1610650056180, + "version": "1.1.1" + }, + "google-crc32c-1.1.1-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f673c21d1482a80d5da09f201a6dcaf4", + "name": "google-crc32c", + "sha256": "8f88df11422b7da540806b8837afc8e383bdee07112c3ad26cbed4207d21672b", + "size": 24496, + "subdir": "linux-64", + "timestamp": 1610650048641, + "version": "1.1.1" + }, + "google-crc32c-1.1.1-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "368850ff2313c500931eb576a652da5a", + "name": "google-crc32c", + "sha256": "7a8108fdab412d42593c97b88274100e0c8e9559a1f75750087bd6400f55f045", + "size": 24522, + "subdir": "linux-64", + "timestamp": 1610649479800, + "version": "1.1.1" + }, + "google-crc32c-1.1.1-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "883850f77e459df795e5fd561f0ef45c", + "name": "google-crc32c", + "sha256": "da2b816135fadd1e96a1012302fbb864dc45d963c3118ba49d5c3505d1a321be", + "size": 23961, + "subdir": "linux-64", + "timestamp": 1610650039816, + "version": "1.1.1" + }, + "google-crc32c-1.1.2-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f4afc0eebd4cd8476c77adc1db4611e5", + "name": "google-crc32c", + "sha256": "2667f4b21104c67278ea966ad98e8325d96b7005578429001ee210a9ad80c326", + "size": 31682, + "subdir": "linux-64", + "timestamp": 1640809226323, + "version": "1.1.2" + }, + "google-crc32c-1.1.2-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "beee620c78f0314f1a70a03a5ace7b92", + "name": "google-crc32c", + "sha256": "55889961865e2e7f9b226bcbf5ec7a55a245ed672cf04db23bfc22fe2314ad03", + "size": 24653, + "subdir": "linux-64", + "timestamp": 1612242779739, + "version": "1.1.2" + }, + "google-crc32c-1.1.2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9daa78f01669c115073aaa2134641712", + "name": "google-crc32c", + "sha256": "cef2e5a04db5f8e1763f019c3b99ff05a3eca700526bfeee00744301819bb709", + "size": 24661, + "subdir": "linux-64", + "timestamp": 1612242973516, + "version": "1.1.2" + }, + "google-crc32c-1.1.2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "13106e1312de02b736cc7d5a01ab93cc", + "name": "google-crc32c", + "sha256": "8e85b5c2bba59835b1a912a91b948a628bfba6eb3e247163081f7facbb5ae24e", + "size": 24697, + "subdir": "linux-64", + "timestamp": 1612242978327, + "version": "1.1.2" + }, + "google-crc32c-1.1.2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "313ac31ef23ae11f7a2589bea185bebd", + "name": "google-crc32c", + "sha256": "dc6f04807c46fb8817ce3cd0fbd245a7a6e30b91dc9d561ae9eb74301bde16ea", + "size": 24067, + "subdir": "linux-64", + "timestamp": 1612242979913, + "version": "1.1.2" + }, + "google-crc32c-1.5.0-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libcrc32c >=1.1.2,<1.2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ea897a43c2b422a799e634ac0f12fb95", + "name": "google-crc32c", + "sha256": "a97e559471a2046d0f7f1962473bfb57c3cb67a44e784db866ceb152e37633a3", + "size": 24248, + "subdir": "linux-64", + "timestamp": 1667946656002, + "version": "1.5.0" + }, + "google-crc32c-1.5.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libcrc32c >=1.1.2,<1.2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5ed824da8ad381b9d946aa19073e7937", + "name": "google-crc32c", + "sha256": "9c6aa03aa50172d359ba3cea6536eecfc1114256fdbeb304f46d9b8255fc1b58", + "size": 25917, + "subdir": "linux-64", + "timestamp": 1676839918213, + "version": "1.5.0" + }, + "google-crc32c-1.5.0-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libcrc32c >=1.1.2,<1.2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aff42fe3760f65a208ad9b2eb71da14a", + "name": "google-crc32c", + "sha256": "4a084d4bc7f1b10adc2bef76499f48702e8d283ead8fbe77038f54a85cbaad4b", + "size": 24802, + "subdir": "linux-64", + "timestamp": 1667946684560, + "version": "1.5.0" + }, + "google-crc32c-1.5.0-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libcrc32c >=1.1.2,<1.2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c900acc062889f1fc0c232e2d8ae5f27", + "name": "google-crc32c", + "sha256": "1c6a95a5bf9809d483002a25c42cae026478ce28306e72941b934b51bb80d847", + "size": 24816, + "subdir": "linux-64", + "timestamp": 1667946741380, + "version": "1.5.0" + }, + "google-crc32c-1.5.0-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libcrc32c >=1.1.2,<1.2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ad095269aad4b4d75cb94c2a20a0d131", + "name": "google-crc32c", + "sha256": "8a6461c654f43c95cc52cdf50b32c50a6bfe917505dc5558f27f4f82f524de62", + "size": 24167, + "subdir": "linux-64", + "timestamp": 1667946713063, + "version": "1.5.0" + }, + "google-resumable-media-2.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "requests >=2.18.0,<3.0.0dev", + "aiohttp >=3.6.2,<4.0.0dev" + ], + "depends": [ + "google-crc32c >=1.0,<2.0dev", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "cab675dc01b6c373806957e2662caf80", + "name": "google-resumable-media", + "sha256": "b30e05b6dc5b1601b66a06f09b9081da5dd34b9a4087de860626768ee0520587", + "size": 68642, + "subdir": "linux-64", + "timestamp": 1668208245495, + "version": "2.4.0" + }, + "google-resumable-media-2.4.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "aiohttp >=3.6.2,<4.0.0dev", + "requests >=2.18.0,<3.0.0dev" + ], + "depends": [ + "google-crc32c >=1.0,<2.0dev", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "d2ddea913380afb07955d5618f12ab47", + "name": "google-resumable-media", + "sha256": "2e42a8407cb04d7fea6130eea6d16c1cdc4b994323095dfbb2330a2e86bee8a6", + "size": 80128, + "subdir": "linux-64", + "timestamp": 1676844211888, + "version": "2.4.0" + }, + "google-resumable-media-2.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "requests >=2.18.0,<3.0.0dev", + "aiohttp >=3.6.2,<4.0.0dev" + ], + "depends": [ + "google-crc32c >=1.0,<2.0dev", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7c5adb90a415e8e0ec635ab7d375d77b", + "name": "google-resumable-media", + "sha256": "7304d8d667f98350bcbde2d142626aefa6271db3ef3966aca72beae8a8e96861", + "size": 67704, + "subdir": "linux-64", + "timestamp": 1668208219765, + "version": "2.4.0" + }, + "google-resumable-media-2.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "requests >=2.18.0,<3.0.0dev", + "aiohttp >=3.6.2,<4.0.0dev" + ], + "depends": [ + "google-crc32c >=1.0,<2.0dev", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "65b305cb3dddf9f7772f569e4caff908", + "name": "google-resumable-media", + "sha256": "c706944b5d7a29cb3c67cbf4da70dd8ba61702babc05b451b327d2e46eb39268", + "size": 68073, + "subdir": "linux-64", + "timestamp": 1668208295643, + "version": "2.4.0" + }, + "google-resumable-media-2.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "requests >=2.18.0,<3.0.0dev", + "aiohttp >=3.6.2,<4.0.0dev" + ], + "depends": [ + "google-crc32c >=1.0,<2.0dev", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "3aa7399fe47651bf3ea6371dab9c686b", + "name": "google-resumable-media", + "sha256": "e93ed9560e69f49eb34da7d13df1b3b3fc1deaee9b91a9cafd92744fd06d590c", + "size": 68088, + "subdir": "linux-64", + "timestamp": 1668208270634, + "version": "2.4.0" + }, + "googleapis-common-protos-1.5.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "f11aeb76c397a0732e2baa44326fa1d0", + "name": "googleapis-common-protos", + "sha256": "2b7d706d54da9f8e811c562197e66d72c914335b2d16f8f600b8dd5475b84f84", + "size": 73828, + "subdir": "linux-64", + "timestamp": 1558590757407, + "version": "1.5.10" + }, + "googleapis-common-protos-1.5.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "7a21e1dac0f8ac267b419a38e0a73d01", + "name": "googleapis-common-protos", + "sha256": "18ef9c5e321192c75aab24dc64e146112e6d07a5e382988ef5a4986a4226f093", + "size": 72157, + "subdir": "linux-64", + "timestamp": 1558590445353, + "version": "1.5.10" + }, + "googleapis-common-protos-1.5.10-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "f0d3a5de87c9a9b19a47254cc6978334", + "name": "googleapis-common-protos", + "sha256": "6c24a0e79c5bc1e770db5d5402f406269f28730eab5ad3e2f7501b4e76da51a6", + "size": 72288, + "subdir": "linux-64", + "timestamp": 1558590591360, + "version": "1.5.10" + }, + "googleapis-common-protos-1.51.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "protobuf", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "b740be233aeb37687400192e17c3dc82", + "name": "googleapis-common-protos", + "sha256": "9b2cfc96aa7b396aaa6121dcb8d975e86f575c434147ffe58891d8f512a81f94", + "size": 70321, + "subdir": "linux-64", + "timestamp": 1581952484222, + "version": "1.51.0" + }, + "googleapis-common-protos-1.51.0-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "protobuf", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "0073ee2c1efbff0ff35dd3a11ba5efad", + "name": "googleapis-common-protos", + "sha256": "8f4cc93ff005440c0eb4a66e74bcac946a44e8d86675fe14e08af62fbfc650a3", + "size": 70655, + "subdir": "linux-64", + "timestamp": 1586570305655, + "version": "1.51.0" + }, + "googleapis-common-protos-1.51.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e8bcd6fb148bb9021fd7964708a0f5ce", + "name": "googleapis-common-protos", + "sha256": "af2da14e099c416cc5db126917ab8b891eb860447a28c7f31dd77d5dd6bfad87", + "size": 65924, + "subdir": "linux-64", + "timestamp": 1594357250343, + "version": "1.51.0" + }, + "googleapis-common-protos-1.51.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "protobuf", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "d40cf1ef2b82c649c1c53c9cf0dc4a36", + "name": "googleapis-common-protos", + "sha256": "0eaecbb75225b5624578eaa55e04947c9718e12c897c145ed3952f072ba08dc2", + "size": 70430, + "subdir": "linux-64", + "timestamp": 1581952473748, + "version": "1.51.0" + }, + "googleapis-common-protos-1.51.0-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "protobuf", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "e1f24748219cdd4845097134f622096e", + "name": "googleapis-common-protos", + "sha256": "5bff652717fd1bf24560158d44a4163f0a10d4d8c4b8254e36779b799bb6ce63", + "size": 70784, + "subdir": "linux-64", + "timestamp": 1586570291236, + "version": "1.51.0" + }, + "googleapis-common-protos-1.51.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "protobuf", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "f2b54391f73c713922409ecfe3c3667e", + "name": "googleapis-common-protos", + "sha256": "5c08214b5bdfc478a723f368834ca292a513a6f2373ff5fa504e3e9d89f10c5c", + "size": 70837, + "subdir": "linux-64", + "timestamp": 1581952492517, + "version": "1.51.0" + }, + "googleapis-common-protos-1.51.0-py38_2.tar.bz2": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "protobuf", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "686a4f114c8eb1e16c9987cc49b0c377", + "name": "googleapis-common-protos", + "sha256": "e367f8c43dc5915952bf2f48f219a364361f112de2c7b5eb41338f8c896ccc19", + "size": 71176, + "subdir": "linux-64", + "timestamp": 1586570294724, + "version": "1.51.0" + }, + "googleapis-common-protos-1.52.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "bab4ed97f7e18f106d30712ca9960595", + "name": "googleapis-common-protos", + "sha256": "53bb1e0992c7d81d7aa2af9f6693992971e9eabce8c7938e83bdcab6e4e9483e", + "size": 75916, + "subdir": "linux-64", + "timestamp": 1600455697070, + "version": "1.52.0" + }, + "googleapis-common-protos-1.52.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "dfdc46a6a5e6beeaa8b375ac0627b548", + "name": "googleapis-common-protos", + "sha256": "5fdc8097d40b07b01d5c5028778f6ce95d06e9b501700f419b25dc25238b5f7a", + "size": 76010, + "subdir": "linux-64", + "timestamp": 1613732403584, + "version": "1.52.0" + }, + "googleapis-common-protos-1.52.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a07cbc14c725ecb34483ad169055a3d1", + "name": "googleapis-common-protos", + "sha256": "f4d3a0640e47c4bdbea626cea5799258e13382866da2d6fc1874e6e8f970e22c", + "size": 75919, + "subdir": "linux-64", + "timestamp": 1600455653639, + "version": "1.52.0" + }, + "googleapis-common-protos-1.52.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "2f5d748f94379415e590ddb93941b37f", + "name": "googleapis-common-protos", + "sha256": "ac14b7945fcb70bce0f3c1775d2fe286528757563ba306ba3acfdea18a457452", + "size": 76076, + "subdir": "linux-64", + "timestamp": 1613732402313, + "version": "1.52.0" + }, + "googleapis-common-protos-1.52.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "29e760e3803bd7da9f441d9e089b45c3", + "name": "googleapis-common-protos", + "sha256": "1a5ba96daf5bdc2c321659353d278f7ea1cd267168a1a23aab30a7fe180831de", + "size": 76622, + "subdir": "linux-64", + "timestamp": 1600455687368, + "version": "1.52.0" + }, + "googleapis-common-protos-1.52.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7e26f548a0a99a461a32e8b68d1c4a18", + "name": "googleapis-common-protos", + "sha256": "a3be9fdd590505a209901f7d3d51b4bd3a7a18fcfab6f5b65f3d94be4e977841", + "size": 76701, + "subdir": "linux-64", + "timestamp": 1613732409647, + "version": "1.52.0" + }, + "googleapis-common-protos-1.52.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "1964f746fbdb353fac4bb744ac98a7e6", + "name": "googleapis-common-protos", + "sha256": "8a660465426ece8d4eb986e620b7fbc962d881a79243722f7000548239bd73c9", + "size": 76718, + "subdir": "linux-64", + "timestamp": 1613731664596, + "version": "1.52.0" + }, + "googleapis-common-protos-1.53.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.12.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e6ae359d95f580674344ab0d94fc49bd", + "name": "googleapis-common-protos", + "sha256": "0dec62653859f8ba726964fafa8f53b2b18d770f6fe7ab16cbdbfe4fbff14d62", + "size": 135814, + "subdir": "linux-64", + "timestamp": 1640809266383, + "version": "1.53.0" + }, + "googleapis-common-protos-1.53.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.12.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6dd51c588f4917a82095b7932d660170", + "name": "googleapis-common-protos", + "sha256": "1ba095c413cee79f5e523317e0280f6355be68992efe3f65f7a30dbf2ae6c475", + "size": 134095, + "subdir": "linux-64", + "timestamp": 1617957353130, + "version": "1.53.0" + }, + "googleapis-common-protos-1.53.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.12.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "d442d790da8fb524f3b48630b229c82a", + "name": "googleapis-common-protos", + "sha256": "606169e9d93f0b5dc1bffcffd08c0e6d365608c69ebf86942c3dec8d3f329c1e", + "size": 134152, + "subdir": "linux-64", + "timestamp": 1617957697684, + "version": "1.53.0" + }, + "googleapis-common-protos-1.53.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.12.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c16cab1278a429b5250ddcdc7cc82802", + "name": "googleapis-common-protos", + "sha256": "91b72b04e02613e838531c009159e1acd52e9af3161955de672c68ac4281aa4c", + "size": 138184, + "subdir": "linux-64", + "timestamp": 1617957704740, + "version": "1.53.0" + }, + "googleapis-common-protos-1.53.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.12.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "d8ae846e09ebea8fc1d7da69692623d8", + "name": "googleapis-common-protos", + "sha256": "c5e7467a1472ce81f428a38a8d58bf903a11cc85e7da0e68539ca03daa61e8b1", + "size": 133230, + "subdir": "linux-64", + "timestamp": 1617957709296, + "version": "1.53.0" + }, + "googleapis-common-protos-1.56.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio >=1.0.0,<2.0.0" + ], + "depends": [ + "libprotobuf", + "protobuf >=3.15.0,<5.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "dc90f7754b438bb3eb5daf40c05112d6", + "name": "googleapis-common-protos", + "sha256": "4608ed021a86162726e895866c135d1430cad7b2ae5bd873c965728653f2f7bb", + "size": 124547, + "subdir": "linux-64", + "timestamp": 1660256275429, + "version": "1.56.4" + }, + "googleapis-common-protos-1.56.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio >=1.0.0,<2.0.0" + ], + "depends": [ + "libprotobuf", + "protobuf >=3.15.0,<5.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "584402aede76869857a573bfeaa2cb47", + "name": "googleapis-common-protos", + "sha256": "a2afecfe0ea656fcba6b9f06f5b81e9b9c54759dea0b7d6421629357e391b693", + "size": 133173, + "subdir": "linux-64", + "timestamp": 1676830589102, + "version": "1.56.4" + }, + "googleapis-common-protos-1.56.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio >=1.0.0,<2.0.0" + ], + "depends": [ + "libprotobuf", + "protobuf >=3.15.0,<5.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f64a21b78ff1c557e8db6332e4682240", + "name": "googleapis-common-protos", + "sha256": "93f4a4487900f9c0d1c37600a59c5d40d76e2abfd1f735a77399fa51588ad5b9", + "size": 124311, + "subdir": "linux-64", + "timestamp": 1660256288704, + "version": "1.56.4" + }, + "googleapis-common-protos-1.56.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio >=1.0.0,<2.0.0" + ], + "depends": [ + "libprotobuf", + "protobuf >=3.15.0,<5.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "4163cdb2de91f214c682e5363479a829", + "name": "googleapis-common-protos", + "sha256": "bb4ed738ed39bdda4659613c10863088f50cabcdee80ab43f34e92f7fd479dc5", + "size": 124448, + "subdir": "linux-64", + "timestamp": 1660256245839, + "version": "1.56.4" + }, + "googleapis-common-protos-1.56.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio >=1.0.0,<2.0.0" + ], + "depends": [ + "libprotobuf", + "protobuf >=3.15.0,<5.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "490de98b7be1174d94f0c93171117a9d", + "name": "googleapis-common-protos", + "sha256": "41eef3f26f982be9c71b2567aa957618b1374b816687379995954cb9dbd890a6", + "size": 124456, + "subdir": "linux-64", + "timestamp": 1660256263647, + "version": "1.56.4" + }, + "googleapis-common-protos-1.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "fa086fbdd477bd83b02b0bbdeac0f3dc", + "name": "googleapis-common-protos", + "sha256": "7a57313615979942ad82641ce11a038d89a7bb82e5141bf891e60da3f0ef404c", + "size": 70539, + "subdir": "linux-64", + "timestamp": 1564754286136, + "version": "1.6.0" + }, + "googleapis-common-protos-1.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "21e386d9606d1e79123042ff7c4bf0fe", + "name": "googleapis-common-protos", + "sha256": "1491e1710933d89132dac95f30cb9129d9ac120d02c7d6217aa42559f00aa284", + "size": 68730, + "subdir": "linux-64", + "timestamp": 1564753971037, + "version": "1.6.0" + }, + "googleapis-common-protos-1.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "07b79ebc7d133aee418436e606ad0627", + "name": "googleapis-common-protos", + "sha256": "208c0946bfc1853f170098f939b1e5434096086116cdaad985641acbf4a70edf", + "size": 68748, + "subdir": "linux-64", + "timestamp": 1564753984318, + "version": "1.6.0" + }, + "googleapis-common-protos-1.6.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "512d2819a0446ca942bef8386660d2a1", + "name": "googleapis-common-protos", + "sha256": "d1f8d141e1b4aaf2cb10fcff7e3e3508d539694948451f2794cd5fe88b2c61e3", + "size": 66068, + "subdir": "linux-64", + "timestamp": 1574252034007, + "version": "1.6.0" + }, + "googleapis-common-protos-grpc-1.5.10-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.5,<1.6.0a0", + "grpcio" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "4df584e13a2e1f5019a9b9cac9e0abe8", + "name": "googleapis-common-protos-grpc", + "sha256": "afad6f7db4431e890e07579e1716d46f9e622acfdb30f64ea645f9750a66c0ea", + "size": 9505, + "subdir": "linux-64", + "timestamp": 1558590805617, + "version": "1.5.10" + }, + "googleapis-common-protos-grpc-1.51.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.51,<1.52.0a0", + "grpcio" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8e6bf6fd55ba0d22e86d26970a37445b", + "name": "googleapis-common-protos-grpc", + "sha256": "7554c8254a17e14b7b39a936b4dab93a4940e09a3e41066389fdf9fcda92d7d6", + "size": 9437, + "subdir": "linux-64", + "timestamp": 1594357258377, + "version": "1.51.0" + }, + "googleapis-common-protos-grpc-1.51.0-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "googleapis-common-protos >=1.51,<1.52.0a0", + "grpcio" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "6ae78621164655bbb21cf424266d32c0", + "name": "googleapis-common-protos-grpc", + "sha256": "e032536720f9508cc70e144de5fa0b2e6a6d6165a1e0a436a894083e567dc0ee", + "size": 13951, + "subdir": "linux-64", + "timestamp": 1581952503996, + "version": "1.51.0" + }, + "googleapis-common-protos-grpc-1.51.0-2.tar.bz2": { + "build": "2", + "build_number": 2, + "depends": [ + "googleapis-common-protos >=1.51,<1.52.0a0", + "grpcio" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "561c94514773134d954348b7dc553224", + "name": "googleapis-common-protos-grpc", + "sha256": "533afe393e2cbee8ac24683deeac86cdd19d4bfe64393fd374688ce93418dfc0", + "size": 14247, + "subdir": "linux-64", + "timestamp": 1586570318414, + "version": "1.51.0" + }, + "googleapis-common-protos-grpc-1.52.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.52,<1.53.0a0", + "grpcio" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "efbc8018e081b464a4fadafc31922b0d", + "name": "googleapis-common-protos-grpc", + "sha256": "78420d6a7a097a6e33c33cc27fe0336df7d3585503f7ce708d52a554bf5db0e0", + "size": 15647, + "subdir": "linux-64", + "timestamp": 1600455704442, + "version": "1.52.0" + }, + "googleapis-common-protos-grpc-1.52.0-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "cython", + "googleapis-common-protos >=1.52,<1.53.0a0", + "grpcio" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c89700ba9a9df4f78a05b484a27232ff", + "name": "googleapis-common-protos-grpc", + "sha256": "a31f00df99351697ab334bbfe2b357e3923722854a462364719b5437a1ceaccd", + "size": 15729, + "subdir": "linux-64", + "timestamp": 1613731673860, + "version": "1.52.0" + }, + "googleapis-common-protos-grpc-1.53.0-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.53,<1.54.0a0", + "grpcio" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ba53eb9c94d3e244301db29a2c640cdd", + "name": "googleapis-common-protos-grpc", + "sha256": "cf8c8169ffdb65ac5f9c7fc087a1cde19cdf0b30b4f7afb42f70f7d552733b0f", + "size": 14693, + "subdir": "linux-64", + "timestamp": 1617957719246, + "version": "1.53.0" + }, + "googleapis-common-protos-grpc-1.56.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.56,<1.57.0a0", + "grpcio >=1.0.0,<2.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5b661e76dc892de9e59a5b9cc0255f9a", + "name": "googleapis-common-protos-grpc", + "sha256": "46a76137c4dc72593593d3063d8f90c20cf1c9630a9ef32255c73e887514f997", + "size": 9544, + "subdir": "linux-64", + "timestamp": 1660256306009, + "version": "1.56.4" + }, + "googleapis-common-protos-grpc-1.56.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.56,<1.57.0a0", + "grpcio >=1.0.0,<2.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "273091d11d06f79b2a9eca1b00ea2223", + "name": "googleapis-common-protos-grpc", + "sha256": "ecd50f3dce0477836d52cfc0922d5ac7eeae4edb832aa7f5ad97a59b534cc34c", + "size": 9946, + "subdir": "linux-64", + "timestamp": 1676830593344, + "version": "1.56.4" + }, + "googleapis-common-protos-grpc-1.56.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.56,<1.57.0a0", + "grpcio >=1.0.0,<2.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6fd79695dc0d12c168eaa2d16c0efc0a", + "name": "googleapis-common-protos-grpc", + "sha256": "ececf473a13c159e30512f2a774836adba51f01f958cdccb2b36124d084d3669", + "size": 9523, + "subdir": "linux-64", + "timestamp": 1660256311395, + "version": "1.56.4" + }, + "googleapis-common-protos-grpc-1.56.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.56,<1.57.0a0", + "grpcio >=1.0.0,<2.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c00853eec46407b1277f4187cb7c4345", + "name": "googleapis-common-protos-grpc", + "sha256": "c74f0621afebbfe7c41aea892137a43defd30e361532d61a72ab849fee38f36b", + "size": 9518, + "subdir": "linux-64", + "timestamp": 1660256294586, + "version": "1.56.4" + }, + "googleapis-common-protos-grpc-1.56.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.56,<1.57.0a0", + "grpcio >=1.0.0,<2.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "d7130ef6bfd0a4e186cdb9da0a5ee760", + "name": "googleapis-common-protos-grpc", + "sha256": "5a140c522e7009cd75ebe47ecb466641cf8abe4ae4a89b8ec8796e2d7acd57b6", + "size": 9518, + "subdir": "linux-64", + "timestamp": 1660256300202, + "version": "1.56.4" + }, + "googleapis-common-protos-grpc-1.6.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.6,<1.7.0a0", + "grpcio" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "900748df0af35f78aa4058d5c29dcf38", + "name": "googleapis-common-protos-grpc", + "sha256": "0031cb2e4564fb03b82e76f0329859be0026fd8461c6ec93e240013fcf83c97d", + "size": 9614, + "subdir": "linux-64", + "timestamp": 1564754010940, + "version": "1.6.0" + }, + "gperf-3.1-hb29a3a9_0.tar.bz2": { + "build": "hb29a3a9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL-3", + "md5": "4df184f089943030413a0ef6f4576f41", + "name": "gperf", + "sha256": "eb2fd60b3b22d3c8bf98b37a73ebd6e0349d33ff8cb04c82bb62160b27d79ef2", + "size": 94729, + "subdir": "linux-64", + "timestamp": 1505734080490, + "version": "3.1" + }, + "grako-3.99.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "1ae286a09fbead9f08e2f4814ae76819", + "name": "grako", + "sha256": "e3282189d80dfd2e91c940e6857d967f1cbc176583774f3d0936afebf384cd4f", + "size": 120470, + "subdir": "linux-64", + "timestamp": 1537208008444, + "version": "3.99.9" + }, + "grako-3.99.9-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "dfa746f53e1ff5e97a337305e5c65269", + "name": "grako", + "sha256": "3f802a5c31be3ec80468e87043d8840dc46b758dffbaeeb62090067a4f0fca49", + "size": 127435, + "subdir": "linux-64", + "timestamp": 1537208030857, + "version": "3.99.9" + }, + "grako-3.99.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "22f59468bd19fc84653a6dfdb1eeb01b", + "name": "grako", + "sha256": "cda682941cc2756538dac33ffe9d4f97ce36de832702275d2fa854093e9e5248", + "size": 126750, + "subdir": "linux-64", + "timestamp": 1537208024326, + "version": "3.99.9" + }, + "grako-3.99.9-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "2d1a9d0fbc5315b4387a04ec5c00ae43", + "name": "grako", + "sha256": "92f1abda947b04ced7cc5d8d405ffe59093f435697d72d5a42bf56fafe053e45", + "size": 346016, + "subdir": "linux-64", + "timestamp": 1613557866607, + "version": "3.99.9" + }, + "grako-3.99.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "6ab4327f3afc5d378d8abe31900c4077", + "name": "grako", + "sha256": "9339c82083cde08c1ded06727b7985b6f70c60083c94de150ace3ab4c8ced8ef", + "size": 127121, + "subdir": "linux-64", + "timestamp": 1537207962584, + "version": "3.99.9" + }, + "grako-3.99.9-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "ed7af90e89fb0d208a2a68a98171f527", + "name": "grako", + "sha256": "75b2e084d3e933cd5d3f22eba351bf1a6d34b4979c1e9fe1d154316c01b11b4b", + "size": 356236, + "subdir": "linux-64", + "timestamp": 1613557862060, + "version": "3.99.9" + }, + "grako-3.99.9-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "b25f0b90728efc80df4815178b24d831", + "name": "grako", + "sha256": "b027f504514cb9ccf9c210a047294d8d92920ba8fcf8f8feb739d0500c2ff629", + "size": 128226, + "subdir": "linux-64", + "timestamp": 1572621481105, + "version": "3.99.9" + }, + "grako-3.99.9-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "a3f855ca352799df3ff9022181c5357b", + "name": "grako", + "sha256": "0e335b93e9dda895d0dfa76a00170bf8b0b76faedcce91a94980d7801377a78d", + "size": 356685, + "subdir": "linux-64", + "timestamp": 1613557203469, + "version": "3.99.9" + }, + "grako-3.99.9-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "a2402630403a546b29978ce9a9f62c98", + "name": "grako", + "sha256": "07d595007cc68a59e1813b96ffbea12de2ce764893978d8deca9cba13a1197e1", + "size": 129686, + "subdir": "linux-64", + "timestamp": 1607007517997, + "version": "3.99.9" + }, + "graphite2-1.3.10-hc526e54_0.tar.bz2": { + "build": "hc526e54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPLv2", + "md5": "a5e6d69f88545feb80bf0464dd55c022", + "name": "graphite2", + "sha256": "754e6f4fd52fbf88b0f95142353f06affb2af67fb80a20c78687da45150d4df3", + "size": 127680, + "subdir": "linux-64", + "timestamp": 1505744265130, + "version": "1.3.10" + }, + "graphite2-1.3.10-hf63cedd_1.tar.bz2": { + "build": "hf63cedd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPLv2", + "md5": "c277868e0e21d22ea4a367c4aa96d8b2", + "name": "graphite2", + "sha256": "4544b2a4cb1330d4467144c10934c749a4ed8f94c0096f0f5b8702c54ece0a9d", + "size": 128266, + "subdir": "linux-64", + "timestamp": 1516742845589, + "version": "1.3.10" + }, + "graphite2-1.3.11-h16798f4_2.tar.bz2": { + "build": "h16798f4_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPLv2", + "md5": "2816ff875c6edb89694f963083a27b30", + "name": "graphite2", + "sha256": "d80ffa6ab29e2ab1173fccb2e2c17debc717db4a7a894afcc9613f3d383a3c4f", + "size": 131867, + "subdir": "linux-64", + "timestamp": 1527034769226, + "version": "1.3.11" + }, + "graphite2-1.3.11-hf63cedd_1.tar.bz2": { + "build": "hf63cedd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPLv2", + "md5": "f82352aaae57e12f630e9cbfe7ce946a", + "name": "graphite2", + "sha256": "5d574fd42aa322d77be7a2ee959cb3329bad7c686f99069ad849e73868a23151", + "size": 129022, + "subdir": "linux-64", + "timestamp": 1523977600380, + "version": "1.3.11" + }, + "graphite2-1.3.12-h23475e2_2.tar.bz2": { + "build": "h23475e2_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPLv2", + "md5": "aefeaa2875b4d0ca492e08aef7f6eea7", + "name": "graphite2", + "sha256": "2cfec6c12266d96e6ff4840a8310d1423747e5d698ec6136e0eeeb80fc3fc66f", + "size": 108873, + "subdir": "linux-64", + "timestamp": 1535464092597, + "version": "1.3.12" + }, + "graphite2-1.3.13-h23475e2_0.tar.bz2": { + "build": "h23475e2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPLv2", + "md5": "4acc975ed77b4e7f342bd10f9059306f", + "name": "graphite2", + "sha256": "3223417610a5ed10dd11800f394d245b6906331688830527281dcf2c408d6f04", + "size": 103419, + "subdir": "linux-64", + "timestamp": 1547231219268, + "version": "1.3.13" + }, + "graphite2-1.3.14-h23475e2_0.tar.bz2": { + "build": "h23475e2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPLv2", + "md5": "fcb3180b5b9e59ab6748f29d7388f4a2", + "name": "graphite2", + "sha256": "7b66d0b6ac9d20609215a1048f48deaf44515a7af272aeb0f17d12efbbabee6a", + "size": 104370, + "subdir": "linux-64", + "timestamp": 1593114287915, + "version": "1.3.14" + }, + "graphite2-1.3.14-h295c915_1.tar.bz2": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "09fcddfe703ce76b4b2d7dd0b6d2f928", + "name": "graphite2", + "sha256": "5fc3a4233c2dd83c4afeaab51465e6e786427636908c77553a3ea80b32eacb79", + "size": 103592, + "subdir": "linux-64", + "timestamp": 1654175396761, + "version": "1.3.14" + }, + "graphql-core-3.2.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90fb198941ce49017a32a61b22cd3743", + "name": "graphql-core", + "sha256": "4edc486c902bc5c51373be91918022c7af73affb3f90b3f9469d28dc27be24f7", + "size": 508643, + "subdir": "linux-64", + "timestamp": 1670009943242, + "version": "3.2.3" + }, + "graphql-core-3.2.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c7737d7f93d7801045eab636afff946", + "name": "graphql-core", + "sha256": "78374ed9def9772e331f38ea904b4d69af78b6cbc88dec57230051d4ea233490", + "size": 615823, + "subdir": "linux-64", + "timestamp": 1676906066686, + "version": "3.2.3" + }, + "graphql-core-3.2.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions >=4.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "167efc16887e27ff684a458abe73dc61", + "name": "graphql-core", + "sha256": "93e437d4da7ae8142e3896f7ef41785989763185921d82b3dea82a8c663a182e", + "size": 502012, + "subdir": "linux-64", + "timestamp": 1670010009256, + "version": "3.2.3" + }, + "graphql-core-3.2.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "typing_extensions >=4.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e163296f31d9fddf85a70decea7602b9", + "name": "graphql-core", + "sha256": "a50fa78baa00421fd4cc113627ea01ce94a4df3ccd049c1a1e0383e3c93b4dab", + "size": 504477, + "subdir": "linux-64", + "timestamp": 1670009812934, + "version": "3.2.3" + }, + "graphql-core-3.2.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "typing_extensions >=4.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5cf197de21277be19663819d5d0f77c1", + "name": "graphql-core", + "sha256": "993ae0f44c457467a0a498fd2dafb9bce70c3ef2688d3e209eb42fa62b9df59b", + "size": 504255, + "subdir": "linux-64", + "timestamp": 1670009878360, + "version": "3.2.3" + }, + "graphviz-2.40.1-h21bd128_1.tar.bz2": { + "build": "h21bd128_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.4,<2.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.11,<2.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libtiff >=4.0.9,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.1,<2.0a0", + "pcre >=8.42,<9.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "EPL v1.0", + "license_family": "Other", + "md5": "ef7f6fbf20f3db03a1f9c7e081ccca51", + "name": "graphviz", + "sha256": "a35a764fdbeba03d3a52e314727292b76da13a5a173df87af41a121e86522e04", + "size": 7264366, + "subdir": "linux-64", + "timestamp": 1530914504953, + "version": "2.40.1" + }, + "graphviz-2.40.1-h21bd128_2.tar.bz2": { + "build": "h21bd128_2", + "build_number": 2, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.4,<2.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.11,<2.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libtiff >=4.0.9,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.1,<2.0a0", + "pcre >=8.42,<9.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "EPL v1.0", + "license_family": "Other", + "md5": "05d3caefd92848b6b5db824671d8873b", + "name": "graphviz", + "sha256": "05d011cfbb511ed667f3ab05aa69aec69d5efcb93af88a67603b7e160f470e7d", + "size": 7266803, + "subdir": "linux-64", + "timestamp": 1531089802644, + "version": "2.40.1" + }, + "graphviz-2.40.1-h25d223c_0.tar.bz2": { + "build": "h25d223c_0", + "build_number": 0, + "depends": [ + "cairo", + "cairo >=1.14.12,<2.0a0", + "expat", + "expat >=2.2.5,<3.0a0", + "freetype", + "freetype >=2.8,<2.9.0a0", + "jpeg", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff", + "libtiff >=4.0.9,<5.0a0", + "libtool", + "pango", + "pango >=1.41.0,<2.0a0", + "zlib", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "EPL v1.0", + "license_family": "Other", + "md5": "5895ef7dabee348bfa1bdcc3c018e2f7", + "name": "graphviz", + "sha256": "9d9a7db8e3f1b981ae0f06745bc74cefa8f5c10cecfe11434fa1e7f4629b8412", + "size": 7263943, + "subdir": "linux-64", + "timestamp": 1516896801372, + "version": "2.40.1" + }, + "graphviz-2.50.0-h1b29801_1.tar.bz2": { + "build": "h1b29801_1", + "build_number": 1, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "expat >=2.4.9,<3.0a0", + "fontconfig >=2.14.1,<3.0a0", + "fonts-conda-ecosystem", + "freetype >=2.10.4,<3.0a0", + "gdk-pixbuf >=2.42.10,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gtk2", + "gts >=0.7.6,<0.8.0a0", + "libgcc-ng >=11.2.0", + "libgd >=2.3.3,<2.4.0a0", + "librsvg >=2.54.4,<3.0a0", + "libstdcxx-ng >=11.2.0", + "libtool", + "libwebp", + "libwebp-base >=1.2.4,<2.0a0", + "pango >=1.50.7,<2.0a0", + "poppler", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "EPL-1.0", + "license_family": "Other", + "md5": "bd9ed3ea11c0408b55b132e504b3530e", + "name": "graphviz", + "sha256": "aaff7da80a3fba218a0735b98b8ec71ad75982f2cb352f105e2427b69efe013b", + "size": 3081042, + "subdir": "linux-64", + "timestamp": 1678708498745, + "version": "2.50.0" + }, + "graphviz-2.50.0-h3cd0ef9_0.tar.bz2": { + "build": "h3cd0ef9_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "expat >=2.2.10,<3.0a0", + "fontconfig", + "fonts-conda-ecosystem", + "freetype", + "gdk-pixbuf", + "glib >=2.69.1,<3.0a0", + "gtk2", + "gts >=0.7.6,<0.8.0a0", + "libgcc-ng >=11.2.0", + "libgd >=2.3.3,<2.4.0a0", + "librsvg >=2.54.4,<3.0a0", + "libstdcxx-ng >=11.2.0", + "libtool", + "libwebp-base", + "pango >=1.50.7,<2.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "EPL-1.0", + "license_family": "Other", + "md5": "ebb2f2f69725fd1dcfb9f8de2f82b5bd", + "name": "graphviz", + "sha256": "9baa33bd52a6ee675e63d59b3dd93e7761c423f070729695410ae932b574cbc2", + "size": 3089478, + "subdir": "linux-64", + "timestamp": 1656619299645, + "version": "2.50.0" + }, + "grayskull-2.2.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "colorama", + "conda-souschef >=2.2.3", + "packaging >=21.3", + "pip", + "pkginfo", + "progressbar2 >=3.53.0", + "python >=3.10,<3.11.0a0", + "rapidfuzz >=1.7.1", + "requests", + "ruamel.yaml >=0.16.10", + "ruamel.yaml.jinja2", + "setuptools >=30.3.0", + "stdlib-list", + "tomli", + "tomli-w" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a2bc160de8567810b6f974754be03728", + "name": "grayskull", + "sha256": "55dbb6a64d9ffef2873717683aa848ece34fb683ba3da032d4e0de1bbb3646a3", + "size": 124307, + "subdir": "linux-64", + "timestamp": 1677054003200, + "version": "2.2.2" + }, + "grayskull-2.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "colorama", + "conda-souschef >=2.2.3", + "packaging >=21.3", + "pip", + "pkginfo", + "progressbar2 >=3.53.0", + "python >=3.8,<3.9.0a0", + "rapidfuzz >=1.7.1", + "requests", + "ruamel.yaml >=0.16.10", + "ruamel.yaml.jinja2", + "setuptools >=30.3.0", + "stdlib-list", + "tomli", + "tomli-w" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bb33427d4448c67f649e64bca5f62111", + "name": "grayskull", + "sha256": "c97ec84e6bb8fc14d67a7e766a290839833dab22bfd2dbbefd805acb29321041", + "size": 123586, + "subdir": "linux-64", + "timestamp": 1677053968475, + "version": "2.2.2" + }, + "grayskull-2.2.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "colorama", + "conda-souschef >=2.2.3", + "packaging >=21.3", + "pip", + "pkginfo", + "progressbar2 >=3.53.0", + "python >=3.9,<3.10.0a0", + "rapidfuzz >=1.7.1", + "requests", + "ruamel.yaml >=0.16.10", + "ruamel.yaml.jinja2", + "setuptools >=30.3.0", + "stdlib-list", + "tomli", + "tomli-w" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1b0f02e852b24d78ff6f3f5dff0569d6", + "name": "grayskull", + "sha256": "7f132dd9214307e1a5d44db0c287043b16918f21e8520b545ccd7387699b05fa", + "size": 123626, + "subdir": "linux-64", + "timestamp": 1677053930315, + "version": "2.2.2" + }, + "greenlet-0.4.12-py27hac09c53_0.tar.bz2": { + "build": "py27hac09c53_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af426069b7914bcac5291725ebb2c278", + "name": "greenlet", + "sha256": "e46ef4abf1767800a23485ba52e0ef54929dbfd9617f9fe9e42d3a002e79f8b7", + "size": 19057, + "subdir": "linux-64", + "timestamp": 1505743502584, + "version": "0.4.12" + }, + "greenlet-0.4.12-py35h2547b41_0.tar.bz2": { + "build": "py35h2547b41_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d8352d2b1af6d8dda4c4cfeb99772d6", + "name": "greenlet", + "sha256": "3d1d5715d9cbed22e0a330d5f8a11a6fade1d4e216dd49c4d77e1039f4cf37d3", + "size": 19046, + "subdir": "linux-64", + "timestamp": 1505743518057, + "version": "0.4.12" + }, + "greenlet-0.4.12-py36h2d503a6_0.tar.bz2": { + "build": "py36h2d503a6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2781c885e6b81fa0fa1ec0fb2957a07", + "name": "greenlet", + "sha256": "1c86e8a8ddcacf6471ea2690da6656aecc6e3cbd26a9fec922e256cf5540dba2", + "size": 19055, + "subdir": "linux-64", + "timestamp": 1505743533853, + "version": "0.4.12" + }, + "greenlet-0.4.13-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8158340d37df51e57e42b0aec78f7c94", + "name": "greenlet", + "sha256": "100f6195226f7c03341d0ac5a7486b1f5ed81fd4d5f8034c72b163d361389b34", + "size": 19889, + "subdir": "linux-64", + "timestamp": 1519170004934, + "version": "0.4.13" + }, + "greenlet-0.4.13-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3de68aadc0744f28e2e0fca56ef66567", + "name": "greenlet", + "sha256": "df44283f5ce43c7c2da2e3b7c74620e3f4783727c5f3d3df4bee5ce668c6f269", + "size": 19882, + "subdir": "linux-64", + "timestamp": 1519170013384, + "version": "0.4.13" + }, + "greenlet-0.4.13-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df37c7e71686b218180778d234cbcbf3", + "name": "greenlet", + "sha256": "f0ffefa0517b7c94f28c9ede8130e47bcc826079ea732ccbe11755adac38cdf8", + "size": 19877, + "subdir": "linux-64", + "timestamp": 1519169903064, + "version": "0.4.13" + }, + "greenlet-0.4.13-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "302f1ef941db9f413fc2b13d0611b330", + "name": "greenlet", + "sha256": "4f6ec7b0c54fbfde8589189925bb73a1714e959a0b5a30751485ec753bc094cb", + "size": 19825, + "subdir": "linux-64", + "timestamp": 1530890469520, + "version": "0.4.13" + }, + "greenlet-0.4.14-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0644daed0705dbd909cc9c7e9d9dcc88", + "name": "greenlet", + "sha256": "658d5104e20f9a9bc32437a3bca45221716bd616c75e56eb1f7a6a1f4cfe7c5a", + "size": 20089, + "subdir": "linux-64", + "timestamp": 1532524595079, + "version": "0.4.14" + }, + "greenlet-0.4.14-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6836d21b6faad4dad0160fb845f23e1d", + "name": "greenlet", + "sha256": "49ba2c20906470e195df4d09525dea30f65a985bd0b2598191bbe485eb8a6dcc", + "size": 20022, + "subdir": "linux-64", + "timestamp": 1532522084480, + "version": "0.4.14" + }, + "greenlet-0.4.14-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "323e3c40c8fc92cc0174bc4d9e44085d", + "name": "greenlet", + "sha256": "b533ec91d3436594603286e2cec08105d6eebd77f6f6b46b8e444f645012203e", + "size": 20020, + "subdir": "linux-64", + "timestamp": 1532521910440, + "version": "0.4.14" + }, + "greenlet-0.4.14-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2364d3f2365bdacf634006ae6c61f7d", + "name": "greenlet", + "sha256": "848b9f7016751a1e2e16633dfe62428f00f17bfa709724ad8e85f0572d3671b8", + "size": 20111, + "subdir": "linux-64", + "timestamp": 1532521941259, + "version": "0.4.14" + }, + "greenlet-0.4.15-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9dff044e41e194d84fc0ab76ae17e1c", + "name": "greenlet", + "sha256": "8a4a8bc839469f2e46acdddf87e1d6380ba2e3312874422c6fa4fb10a7324c45", + "size": 20341, + "subdir": "linux-64", + "timestamp": 1536767955430, + "version": "0.4.15" + }, + "greenlet-0.4.15-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83d0ebdb196f8dc49373a1cb7b639b55", + "name": "greenlet", + "sha256": "61bb9e1533ede91d88e30bf82b1fd5fff1565da1de37e2a383ab32638381b92f", + "size": 20233, + "subdir": "linux-64", + "timestamp": 1536767982369, + "version": "0.4.15" + }, + "greenlet-0.4.15-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37d5c107cf3ab3b51c9f93d3b2a7b545", + "name": "greenlet", + "sha256": "ad275154a13050b76462127f9d125259219ed04cea7ffe63cad3253c20093ced", + "size": 20210, + "subdir": "linux-64", + "timestamp": 1536767991184, + "version": "0.4.15" + }, + "greenlet-0.4.15-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d0acec415aaa40517b031945940a0f10", + "name": "greenlet", + "sha256": "eff8ca3fc8cf15e3f7c2f432dde3e9b08fc1621f6dc069c9356499ccec4b8834", + "size": 20316, + "subdir": "linux-64", + "timestamp": 1536700046535, + "version": "0.4.15" + }, + "greenlet-0.4.15-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39bde96d572fad770306973cc60c82fc", + "name": "greenlet", + "sha256": "e2ee34d73dbbacdf0682e5466d3ece44179b3476a1752bcffc167a24c6639f86", + "size": 30164, + "subdir": "linux-64", + "timestamp": 1572621589725, + "version": "0.4.15" + }, + "greenlet-0.4.16-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77b42e168bde86cbcc89db714ef6ca13", + "name": "greenlet", + "sha256": "bf4f22b48d2c5a8cdc7372c893b9456686a98fc4b5214acf68d01686fb743d0e", + "size": 25460, + "subdir": "linux-64", + "timestamp": 1592330986140, + "version": "0.4.16" + }, + "greenlet-0.4.16-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e086ba5a6063f5599e8a87cc5a3c9b1", + "name": "greenlet", + "sha256": "5b190754a0c8f7815d2c63dc437efe645c9f847d425c3ce45616e3cffcf4f225", + "size": 25468, + "subdir": "linux-64", + "timestamp": 1592330982320, + "version": "0.4.16" + }, + "greenlet-0.4.16-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "317b2e120b1b4283e38bf9c8819f48c1", + "name": "greenlet", + "sha256": "81118a2219929dc8e26938e06c97c6f961a1f5d050c713675417851ffe0331cc", + "size": 25997, + "subdir": "linux-64", + "timestamp": 1592330980066, + "version": "0.4.16" + }, + "greenlet-0.4.16-py39he8ac12f_0.tar.bz2": { + "build": "py39he8ac12f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9db6bcede5f6704c60b8d72333e59c9a", + "name": "greenlet", + "sha256": "636c7a345999da0e66c08a82640f01ffee8ac76c92efa7d12d8525a12bb7a6d1", + "size": 26341, + "subdir": "linux-64", + "timestamp": 1607025773216, + "version": "0.4.16" + }, + "greenlet-0.4.17-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d3f883d362ad08c1b483aaa02e44e2c", + "name": "greenlet", + "sha256": "1e529f843454a9de62fc68d4bf3b79b4e9e3df411a6c71e079059bfc9ecf5574", + "size": 22998, + "subdir": "linux-64", + "timestamp": 1600874033501, + "version": "0.4.17" + }, + "greenlet-0.4.17-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f618f8915b4c93ee6a4bfe3a68f76db", + "name": "greenlet", + "sha256": "14a6ed6e79adc70a1176beb70d0a95c25d63038abe974d883a79909d411319c9", + "size": 23105, + "subdir": "linux-64", + "timestamp": 1600874030289, + "version": "0.4.17" + }, + "greenlet-0.4.17-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87426bac5d11fa50b27789984b77044f", + "name": "greenlet", + "sha256": "aeb34371d3e0bcd1e66bd75b66c108416800eee8f9b59a0a16460a9d74449bff", + "size": 23575, + "subdir": "linux-64", + "timestamp": 1600874051223, + "version": "0.4.17" + }, + "greenlet-0.4.17-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2538afe9f8aba512c8c1232709f045a", + "name": "greenlet", + "sha256": "87970e4573bf9100120d48f7b10fcf6873ccbf4893b45887ab5f0779e37ecbbd", + "size": 26543, + "subdir": "linux-64", + "timestamp": 1608154615997, + "version": "0.4.17" + }, + "greenlet-1.0.0-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4409be35a21bff100109b3536474480", + "name": "greenlet", + "sha256": "6e9b325b90ca533a597ab318f0ff405cb231cfe44f85f00e53773db586325d33", + "size": 83782, + "subdir": "linux-64", + "timestamp": 1611961651218, + "version": "1.0.0" + }, + "greenlet-1.0.0-py36h2531618_2.tar.bz2": { + "build": "py36h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb3ff4c1e97d95350b976eed41bfc33c", + "name": "greenlet", + "sha256": "ad22a34227d06f37f24da0eaf4492b6ba8a3ecace76cdbe738dbebdc5d33d136", + "size": 83794, + "subdir": "linux-64", + "timestamp": 1611958421257, + "version": "1.0.0" + }, + "greenlet-1.0.0-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ba3fc0fca667947e7a671665662929c", + "name": "greenlet", + "sha256": "636260ba3da71b4b75ab2da33325819065e3e3431e29d2092dfe781a72a0c863", + "size": 84346, + "subdir": "linux-64", + "timestamp": 1611961617835, + "version": "1.0.0" + }, + "greenlet-1.0.0-py37h2531618_2.tar.bz2": { + "build": "py37h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f26ce1b9cd60e732acca135d343b794f", + "name": "greenlet", + "sha256": "5aa201508d057716a18ba67063ecc1188ff003bccaf9745c4417a6c0b9dc0531", + "size": 84347, + "subdir": "linux-64", + "timestamp": 1611958402464, + "version": "1.0.0" + }, + "greenlet-1.0.0-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b609efabb79e2a6b355bc09a3af89fe0", + "name": "greenlet", + "sha256": "cf60eafb96f172ec29ceca77d4aeb42cd6f66df5a462ce1d3ca064726972aaef", + "size": 85137, + "subdir": "linux-64", + "timestamp": 1611961624772, + "version": "1.0.0" + }, + "greenlet-1.0.0-py38h2531618_2.tar.bz2": { + "build": "py38h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f365fe6333f1420160d30de540c92bb2", + "name": "greenlet", + "sha256": "8bdb9fa45c5d33ddabf680b5acc632d2a3dff41bdcd84a98a047b56fd48c9fa2", + "size": 85099, + "subdir": "linux-64", + "timestamp": 1611957748048, + "version": "1.0.0" + }, + "greenlet-1.0.0-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63c729fc9a9d3f5adfa531a4337f8e67", + "name": "greenlet", + "sha256": "2926eae4281892d483e67652905c085b8f98aee495eeb9b3b6ba33b7fe758e09", + "size": 85192, + "subdir": "linux-64", + "timestamp": 1611961667222, + "version": "1.0.0" + }, + "greenlet-1.0.0-py39h2531618_2.tar.bz2": { + "build": "py39h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1cd6da084344be5e2d4ab5af4fb17178", + "name": "greenlet", + "sha256": "732b0da733a14bcfa6c8f897ed365cb4033e72ad8265057a3dff7b5bf9ab1044", + "size": 85181, + "subdir": "linux-64", + "timestamp": 1611958419735, + "version": "1.0.0" + }, + "greenlet-1.1.0-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f8ebf9029d6f1b41a1bdf72202b0e96", + "name": "greenlet", + "sha256": "efd59bf017ee195c7db00af513ce426bc54f0c13226a95cdc2ad6ae5023a0f6a", + "size": 84016, + "subdir": "linux-64", + "timestamp": 1620913685100, + "version": "1.1.0" + }, + "greenlet-1.1.0-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3749d55609273e8caba5ffc27ced02d7", + "name": "greenlet", + "sha256": "aa426255a840ce44ab6465c7d27ceff78f33939f4e504b4a469746a8b7ced1bf", + "size": 84549, + "subdir": "linux-64", + "timestamp": 1620913696443, + "version": "1.1.0" + }, + "greenlet-1.1.0-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01b8551947835eb9fa84163422a69143", + "name": "greenlet", + "sha256": "258ee3768485df37d4e9b8202915a28ca5489ee79c4264c951a0e758c28e5ec7", + "size": 85296, + "subdir": "linux-64", + "timestamp": 1620913375268, + "version": "1.1.0" + }, + "greenlet-1.1.0-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1ccdde73f0351564731e29045d0700c", + "name": "greenlet", + "sha256": "15127659263351e7d5d9bbf7e4835642d2de8eb32763f9d4492d54581a8a58b8", + "size": 85443, + "subdir": "linux-64", + "timestamp": 1620913698526, + "version": "1.1.0" + }, + "greenlet-1.1.1-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14ba742e5efa5307d355c282dd7ce4ae", + "name": "greenlet", + "sha256": "e43c90858ea3f435330dc80b184951fb6609f8e291e4014a2f3f80ddefe70503", + "size": 139306, + "subdir": "linux-64", + "timestamp": 1640790632904, + "version": "1.1.1" + }, + "greenlet-1.1.1-py36h295c915_0.tar.bz2": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2b8fdb42e1ce64127de7eb9b2167c14", + "name": "greenlet", + "sha256": "bd82fea34324845473ba3b42a2ddc48fed15c208df5f734b45ee61bb700b3332", + "size": 83990, + "subdir": "linux-64", + "timestamp": 1628879803161, + "version": "1.1.1" + }, + "greenlet-1.1.1-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bdce405fa00034646a75cc8967d0d374", + "name": "greenlet", + "sha256": "aa1913079c92cf22f6e865fc739f918f6543e969ac8246367421059be2e5a92c", + "size": 84423, + "subdir": "linux-64", + "timestamp": 1628888185299, + "version": "1.1.1" + }, + "greenlet-1.1.1-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63e88b0d18af8d9b02efad334dca1481", + "name": "greenlet", + "sha256": "26adc398aa19bbf922843d916307416318d5fc33095584a1edb2fc06197586d6", + "size": 85277, + "subdir": "linux-64", + "timestamp": 1628887771107, + "version": "1.1.1" + }, + "greenlet-1.1.1-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "25022550ce757bd599f58d02c14c8ad2", + "name": "greenlet", + "sha256": "9c997e4d200223d64bdf5ab3fdf7a8df7d30191a9b9a0c65b00260095fb364b9", + "size": 85274, + "subdir": "linux-64", + "timestamp": 1628888187452, + "version": "1.1.1" + }, + "greenlet-1.1.3-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "72b62e3478b1d4b1845ede6f959b2b03", + "name": "greenlet", + "sha256": "5e81125b30f0956cacbdffd568233aa9a0d57c120dcc521d304c646830237595", + "size": 93362, + "subdir": "linux-64", + "timestamp": 1670013276464, + "version": "1.1.3" + }, + "greenlet-1.1.3-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de05d021085b6639cfa6f86dae6bb8fe", + "name": "greenlet", + "sha256": "320f688f1d605821df38f4f9a094466b7f39bb37c1661e94b2e5ec7ea49c54f8", + "size": 92168, + "subdir": "linux-64", + "timestamp": 1670013306552, + "version": "1.1.3" + }, + "greenlet-1.1.3-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b20757a26eb452a0f51a033e84790d14", + "name": "greenlet", + "sha256": "bfe67eaef397097b8aa0ee1db66a704c84ebf181ed8b48cd2c107a975645cd0a", + "size": 92699, + "subdir": "linux-64", + "timestamp": 1670013365891, + "version": "1.1.3" + }, + "greenlet-1.1.3-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "53117ab0faafe78274d1733df2e1118f", + "name": "greenlet", + "sha256": "81ffae0673632060f7b2827409c734d65e3cd7536d7ca379f0200e9e5dc91583", + "size": 92591, + "subdir": "linux-64", + "timestamp": 1670013336395, + "version": "1.1.3" + }, + "greenlet-2.0.1-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85b2431b19c1dc33c0250114a70ed83d", + "name": "greenlet", + "sha256": "bba6196bd4ab4af33bc355b403fb2102e0d2413e9a48ab77aff30266c0f858e5", + "size": 188752, + "subdir": "linux-64", + "timestamp": 1670513354121, + "version": "2.0.1" + }, + "greenlet-2.0.1-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a216b7aa5bff27211a6cfaf438f96b47", + "name": "greenlet", + "sha256": "e2a9e5096ef08490125dfd7c04d72eb92adf709fda5d936a78e8f335162c5cef", + "size": 211578, + "subdir": "linux-64", + "timestamp": 1676825264503, + "version": "2.0.1" + }, + "greenlet-2.0.1-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3aa77d8e280f195090a0568ad48ca10f", + "name": "greenlet", + "sha256": "961b1ce7bacecbf8b4e1f03377125dd90587ed3655d830557c6c57576c56fea5", + "size": 185437, + "subdir": "linux-64", + "timestamp": 1670513324126, + "version": "2.0.1" + }, + "greenlet-2.0.1-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eeb66cd9658c68d5d61d5aca9f51b756", + "name": "greenlet", + "sha256": "22044930621c705c4224dcc996461d6a856b971106e3c59b1d2503caa35b842d", + "size": 187105, + "subdir": "linux-64", + "timestamp": 1670513294315, + "version": "2.0.1" + }, + "greenlet-2.0.1-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f160783995b87dc9007f6d3d423eaec", + "name": "greenlet", + "sha256": "e8f2b3b0155498af571362a68bcb859965ed800dd41fd985cb28c0bcad9df0b6", + "size": 187608, + "subdir": "linux-64", + "timestamp": 1670513264536, + "version": "2.0.1" + }, + "gridmap-0.14.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "drmaa", + "psutil >=2.0.0", + "python >=2.7,<2.8.0a0", + "pyzmq" + ], + "license": "GPL3", + "md5": "3b3d05acadfd63f7b7d323bb38a067e6", + "name": "gridmap", + "sha256": "ce50450bad09cdb817a691dd8e83612e3bb6c9d0b208f40b7454bc6cf01312b3", + "size": 45612, + "subdir": "linux-64", + "timestamp": 1529990039017, + "version": "0.14.0" + }, + "gridmap-0.14.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "drmaa", + "psutil >=2.0.0", + "python >=3.10,<3.11.0a0", + "pyzmq" + ], + "license": "GPL3", + "md5": "bac38cec98526a8ea156122559a158de", + "name": "gridmap", + "sha256": "180ee2fd7b7725a92922ffc41b9e9d4ddf60def7f36f4b9a3d0bdd79cd8106d7", + "size": 46408, + "subdir": "linux-64", + "timestamp": 1640809285438, + "version": "0.14.0" + }, + "gridmap-0.14.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "drmaa", + "psutil >=2.0.0", + "python >=3.11,<3.12.0a0", + "pyzmq" + ], + "license": "GPL3", + "md5": "10bcfbaec8e741a26e2e2da971729dd6", + "name": "gridmap", + "sha256": "7e3ce091dc68eb8c169e75e93d01b63489332363a28ea43ff81204a2b6078fda", + "size": 56522, + "subdir": "linux-64", + "timestamp": 1676907255812, + "version": "0.14.0" + }, + "gridmap-0.14.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "drmaa", + "psutil >=2.0.0", + "python >=3.5,<3.6.0a0", + "pyzmq" + ], + "license": "GPL3", + "md5": "e119824eba9ca0627dd3993de68b4ad2", + "name": "gridmap", + "sha256": "5a0da52cf82533411650de3e2056a95bceef84d49f1f24dc4ab7915b63f2dfee", + "size": 45952, + "subdir": "linux-64", + "timestamp": 1529990059975, + "version": "0.14.0" + }, + "gridmap-0.14.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "drmaa", + "psutil >=2.0.0", + "python >=3.6,<3.7.0a0", + "pyzmq" + ], + "license": "GPL3", + "md5": "d999a9b6c22bb987f758b1c609ba8169", + "name": "gridmap", + "sha256": "1cc390ce3f833b634c0e5f63887f750a3ae3c21e6f83291bea574e830bc22cc0", + "size": 45946, + "subdir": "linux-64", + "timestamp": 1529990021141, + "version": "0.14.0" + }, + "gridmap-0.14.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "drmaa", + "psutil >=2.0.0", + "python >=3.6,<3.7.0a0", + "pyzmq" + ], + "license": "GPL3", + "md5": "1b9addc81347b2e837669fa25024c646", + "name": "gridmap", + "sha256": "52563275da52ec6af15488f8772119c74d6b1eb517cc0cee01888fcd3b4330d4", + "size": 319175, + "subdir": "linux-64", + "timestamp": 1632891251129, + "version": "0.14.0" + }, + "gridmap-0.14.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "drmaa", + "psutil >=2.0.0", + "python >=3.7,<3.8.0a0", + "pyzmq" + ], + "license": "GPL3", + "md5": "b738dc87e54e3943e707e158331741b1", + "name": "gridmap", + "sha256": "e1f1fd056a70b95b3705527caac75b81b23d5891bbbdcefde6486056b768d9ba", + "size": 315928, + "subdir": "linux-64", + "timestamp": 1632891213271, + "version": "0.14.0" + }, + "gridmap-0.14.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "drmaa", + "psutil >=2.0.0", + "python >=3.8,<3.9.0a0", + "pyzmq" + ], + "license": "GPL3", + "md5": "2ba1128840706477f06859946dd06e6d", + "name": "gridmap", + "sha256": "766950eefa9c7f4ea8706377f1648b88c802f1643103ba4493850d83c063998e", + "size": 319346, + "subdir": "linux-64", + "timestamp": 1632890774957, + "version": "0.14.0" + }, + "gridmap-0.14.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "drmaa", + "psutil >=2.0.0", + "python >=3.9,<3.10.0a0", + "pyzmq" + ], + "license": "GPL3", + "md5": "ad3bf0cc982e302dec31650c00345e4a", + "name": "gridmap", + "sha256": "5f481fc590c9ae63b0374965820e4db5240530c0db783e1f8094f8e855e70718", + "size": 314263, + "subdir": "linux-64", + "timestamp": 1632884002727, + "version": "0.14.0" + }, + "grin-1.2.1-py27_4.tar.bz2": { + "build": "py27_4", + "build_number": 4, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "05c0719bab123f85b3002e981bd9f0d4", + "name": "grin", + "sha256": "a95a56c736e32edf59b7ab7529c55260280017acf12da5a3d134f7e9f7e36ea3", + "size": 28093, + "subdir": "linux-64", + "timestamp": 1518030803541, + "version": "1.2.1" + }, + "grin-1.2.1-py27h54abee7_1.tar.bz2": { + "build": "py27h54abee7_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "759fd349fd22f672cb7d3d264137f194", + "name": "grin", + "sha256": "e06a48e7d1cb08521e7a39b9dfde2954dc275a8175a2136435da734bb96b49a5", + "size": 27779, + "subdir": "linux-64", + "timestamp": 1505744280494, + "version": "1.2.1" + }, + "groff-1.22.4-pl5262he6710b0_2.tar.bz2": { + "build": "pl5262he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "perl" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "5340f6a5fbf0e228df954346cefba304", + "name": "groff", + "sha256": "f8cd065a44bdb31ede6b44dc54a797afe00a6f6ab36e588d86b5df85a148594d", + "size": 3708577, + "subdir": "linux-64", + "timestamp": 1600927491863, + "version": "1.22.4" + }, + "groff-1.22.4-pl5262hf484d3e_2.tar.bz2": { + "build": "pl5262hf484d3e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "perl" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "ff4d7a2b61347bcee5ea0d47bbe1b5f7", + "name": "groff", + "sha256": "6b38c4fdc727cde05b6819d208f6878c6fe74f6d9c01694b43fb5f065e0cfe6a", + "size": 3710455, + "subdir": "linux-64", + "timestamp": 1600927577486, + "version": "1.22.4" + }, + "grpc-cpp-1.26.0-hf484d3e_1.tar.bz2": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "c-ares >=1.16.1,<2.0a0", + "gflags", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.13.0,<3.13.1.0a0", + "libprotobuf >=3.13.0,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "fcc21c51da9a0f21ce67ba287a5e99f2", + "name": "grpc-cpp", + "sha256": "dfc4ab858f4d0c16366f69ec8f25ad677d8d054d0a0c35ebee6307ca8f4f25d3", + "size": 6323071, + "subdir": "linux-64", + "timestamp": 1601514044015, + "version": "1.26.0" + }, + "grpc-cpp-1.26.0-hf8bcb03_0.tar.bz2": { + "build": "hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares", + "gflags >=2.2.2,<2.3.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.11.3.0a0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "3f4fca8649aa196df2ed0377d313bf33", + "name": "grpc-cpp", + "sha256": "47eb032ccafbedd87787960a1ebea8d7dcee67cc0879420251430b67c8dbe3aa", + "size": 6323465, + "subdir": "linux-64", + "timestamp": 1580397868189, + "version": "1.26.0" + }, + "grpc-cpp-1.26.0-hf8bcb03_1.tar.bz2": { + "build": "hf8bcb03_1", + "build_number": 1, + "depends": [ + "c-ares >=1.16.1,<2.0a0", + "gflags", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.13.0,<3.13.1.0a0", + "libprotobuf >=3.13.0,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "f986a7c8d74a67e6c48f44f6dc9a72ab", + "name": "grpc-cpp", + "sha256": "a3366256783512e85f42c40bcb246ce485c9310150d42c5b7601981b7e8240a1", + "size": 6324684, + "subdir": "linux-64", + "timestamp": 1601513940169, + "version": "1.26.0" + }, + "grpc-cpp-1.33.2-h2157cd5_4.tar.bz2": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "fb357b7da78fa0fe690490ea61835866", + "name": "grpc-cpp", + "sha256": "3f8ba7d8c068ddc82cac44edbdb3817622134ad739c3e78948e4102e1b257f17", + "size": 4278044, + "subdir": "linux-64", + "timestamp": 1607206484921, + "version": "1.33.2" + }, + "grpc-cpp-1.34.1-h2157cd5_4.tar.bz2": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "53fb248a7fb1ed1280ab3a7cfbaa4ae7", + "name": "grpc-cpp", + "sha256": "3567ffb5c9e3716b7b4c1e7b5e1639fcb3d9626e93a5e9f4ee0c58e18711ea49", + "size": 4407441, + "subdir": "linux-64", + "timestamp": 1610563677342, + "version": "1.34.1" + }, + "grpc-cpp-1.35.0-h2157cd5_4.tar.bz2": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "2deb9b4f4524bf1cbc1d41c16cf8c029", + "name": "grpc-cpp", + "sha256": "9bf322bdd31fc0cac9ccf9b19184b2fda455b8d1436ffd08c3bc2ae3e226be4f", + "size": 4603033, + "subdir": "linux-64", + "timestamp": 1611255700755, + "version": "1.35.0" + }, + "grpc-cpp-1.36.0-h2157cd5_4.tar.bz2": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "eacd62a2da68c7598e91896ebba15782", + "name": "grpc-cpp", + "sha256": "4f926aaed6c64ff253f44d0fdae108881184d21bc25945853391a9d611e63fca", + "size": 4634293, + "subdir": "linux-64", + "timestamp": 1614363011831, + "version": "1.36.0" + }, + "grpc-cpp-1.36.1-h2157cd5_4.tar.bz2": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "67d56d3549a3e9445e56c8fa3cc83338", + "name": "grpc-cpp", + "sha256": "1e9eeb0af6d2383fc7eb022b421586ecfd3bb7a179d5fdf52dd0a2cfc5d66192", + "size": 4632788, + "subdir": "linux-64", + "timestamp": 1614882945334, + "version": "1.36.1" + }, + "grpc-cpp-1.36.2-h2157cd5_4.tar.bz2": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "feb509fb40f7f204660ca574cb03b42d", + "name": "grpc-cpp", + "sha256": "a74d4124b51c86ddbd401a94306cc67c28c4f75abafea4370da6ba4ea6f5395c", + "size": 4630694, + "subdir": "linux-64", + "timestamp": 1615315917420, + "version": "1.36.2" + }, + "grpc-cpp-1.36.3-h2157cd5_4.tar.bz2": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "055024f03a3864e6282612d7c7ab0601", + "name": "grpc-cpp", + "sha256": "bb71d714aab6d08395c22784b388ee5bb9eaca9c652b7af43f812a3bd1bf7d8e", + "size": 4637928, + "subdir": "linux-64", + "timestamp": 1615921849401, + "version": "1.36.3" + }, + "grpc-cpp-1.36.4-h2157cd5_4.tar.bz2": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "aed82252cb75f998b1028afb0565fa61", + "name": "grpc-cpp", + "sha256": "5005e88fcf2dce98314ba06af1d1bc83cca0de7ea6b5b94a64f1a97ebc7ea528", + "size": 4628310, + "subdir": "linux-64", + "timestamp": 1616179890104, + "version": "1.36.4" + }, + "grpc-cpp-1.37.0-h2157cd5_4.tar.bz2": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "179c74058b079647e4444bfc1c5881e6", + "name": "grpc-cpp", + "sha256": "9c09b3c041859478e660bbe4994c4ab3c6b8b8dad37aa49042b8aebf36c08fd6", + "size": 4801631, + "subdir": "linux-64", + "timestamp": 1617828604546, + "version": "1.37.0" + }, + "grpc-cpp-1.37.1-h2157cd5_4.tar.bz2": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "04b755a326ca5020d60b3f6d482d6910", + "name": "grpc-cpp", + "sha256": "e2301da3b63846fd9a2da18e13339b50389787956ef0c414d16377f0b3a35259", + "size": 4806226, + "subdir": "linux-64", + "timestamp": 1619735993721, + "version": "1.37.1" + }, + "grpc-cpp-1.38.1-hce63b2e_4.tar.bz2": { + "build": "hce63b2e_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.5.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "2f7bfc342e7d021b875d2ea340205e2e", + "name": "grpc-cpp", + "sha256": "9691969ea893a7a4675aa3dc18fb7b1aa9fca8fa57726bc292b6b6ecf614fcd2", + "size": 4852840, + "subdir": "linux-64", + "timestamp": 1624485740659, + "version": "1.38.1" + }, + "grpc-cpp-1.39.0-hae934f6_5.tar.bz2": { + "build": "hae934f6_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf >=3.17.2,<3.17.3.0a0", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "040a416033725268344d275a5a57873a", + "name": "grpc-cpp", + "sha256": "932acd310119b9e6916c7a51f9982b3fb8c3cfd08e59d79c53cbe68b7b1ca00c", + "size": 4918101, + "subdir": "linux-64", + "timestamp": 1631219715382, + "version": "1.39.0" + }, + "grpc-cpp-1.39.0-hce63b2e_4.tar.bz2": { + "build": "hce63b2e_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.5.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6e2efbd039430fe4ea669d1a085e551e", + "name": "grpc-cpp", + "sha256": "6edeb7fb6ad8375ae012998c96b478d1bc2bfd662eed3348facdcc8cca78acb2", + "size": 4926261, + "subdir": "linux-64", + "timestamp": 1627018445192, + "version": "1.39.0" + }, + "grpc-cpp-1.43.0-h63824a7_0.tar.bz2": { + "build": "h63824a7_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "c-ares >=1.18.1,<2.0a0", + "libgcc-ng >=9.3.0", + "libprotobuf >=3.19.1,<3.19.2.0a0", + "libprotobuf >=3.19.1,<3.20.0a0", + "libstdcxx-ng >=9.3.0", + "openssl >=1.1.1m,<1.1.2a", + "re2 >=2020.11.1,<2020.11.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5ef932a25a3789927df47ee7eb297493", + "name": "grpc-cpp", + "sha256": "8bc8f46e4e883aa8f739c213c05d77560020d3aacbfddd6f23fa91ac061a849d", + "size": 4232226, + "subdir": "linux-64", + "timestamp": 1642703924279, + "version": "1.43.0" + }, + "grpc-cpp-1.46.1-h33aed49_0.tar.bz2": { + "build": "h33aed49_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "c-ares >=1.18.1,<2.0a0", + "libgcc-ng >=8.4.0", + "libprotobuf >=3.20.1,<3.20.2.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=8.4.0", + "openssl >=1.1.1o,<1.1.2a", + "re2 >=2022.4.1,<2022.4.2.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "345225f020f8513a7c9c8d9ad94831b1", + "name": "grpc-cpp", + "sha256": "d1a1b42a188cd108f2e61e35dcbb884559dbf40cf05d4f7a1826fab41f982bf9", + "size": 4772682, + "subdir": "linux-64", + "timestamp": 1652942891317, + "version": "1.46.1" + }, + "grpc-cpp-1.46.1-h33aed49_1.tar.bz2": { + "build": "h33aed49_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "c-ares >=1.18.1,<2.0a0", + "libgcc-ng >=8.4.0", + "libprotobuf >=3.20.3,<3.20.4.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=8.4.0", + "openssl >=1.1.1s,<1.1.2a", + "re2 >=2022.4.1,<2022.4.2.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "cf5ca45f567aa3479ba3933d76fdfde7", + "name": "grpc-cpp", + "sha256": "de57a2e800a976cab1f0104b0c1415e7431dd4fda8e7f29b2de77fbc85d3829a", + "size": 4781780, + "subdir": "linux-64", + "timestamp": 1675356525107, + "version": "1.46.1" + }, + "grpcio-1.10.0-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "protobuf >=3.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "51f63b02a364ff63509e374e0b1428a1", + "name": "grpcio", + "sha256": "9e0fd488fbdb0bfd9c6752f9ad2e7a6f06aa0a061bcbe95ee699877a0bc4e6a1", + "size": 1658055, + "subdir": "linux-64", + "timestamp": 1520017144164, + "version": "1.10.0" + }, + "grpcio-1.10.0-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "protobuf >=3.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "723e3325d67ea00f05f85bcc9bbe762a", + "name": "grpcio", + "sha256": "a327be02f36189713d241c5c54fe8a1a1bf32a12342fa137df4df69fd17f82db", + "size": 1663883, + "subdir": "linux-64", + "timestamp": 1520017149139, + "version": "1.10.0" + }, + "grpcio-1.10.0-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "protobuf >=3.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "9a4a708f151113188e486419af75d412", + "name": "grpcio", + "sha256": "d3af3dc84ba8d4dd081699184c904ccd8a1e5b2c9c5aefece51a365b87abb828", + "size": 1666882, + "subdir": "linux-64", + "timestamp": 1520016990428, + "version": "1.10.0" + }, + "grpcio-1.11.0-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "protobuf >=3.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "8b99ee500383bd738c79bb11b14f3ca2", + "name": "grpcio", + "sha256": "cc8c902d1eaad2002aa2599b946ebc49bbbd53461d06551017d740886284dbcf", + "size": 1781979, + "subdir": "linux-64", + "timestamp": 1524088742683, + "version": "1.11.0" + }, + "grpcio-1.11.0-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "protobuf >=3.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "382cca0adc0bc1e38b2ab7d01c180a82", + "name": "grpcio", + "sha256": "0dd21eef28b53e78b73a5012695e4c4504f72902f967b08dbf9ee3faa914425f", + "size": 1789830, + "subdir": "linux-64", + "timestamp": 1524088821197, + "version": "1.11.0" + }, + "grpcio-1.11.0-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "protobuf >=3.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "4878c4a109c86a3776bc0a876167a165", + "name": "grpcio", + "sha256": "b702b07318f98e27bab39c7a21962362ce5042f6cc3ae0760ec1bccdfa6a695d", + "size": 1792582, + "subdir": "linux-64", + "timestamp": 1524088823238, + "version": "1.11.0" + }, + "grpcio-1.12.0-py27hdbcaa40_0.tar.bz2": { + "build": "py27hdbcaa40_0", + "build_number": 0, + "depends": [ + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "protobuf >=3.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "55025f5a84622dcebcc2d63e9ebba498", + "name": "grpcio", + "sha256": "05fb04dd5759a7884a21c7be75ddd85c9777f7cb66688d7d13a16e7ab386204a", + "size": 1825253, + "subdir": "linux-64", + "timestamp": 1527833752151, + "version": "1.12.0" + }, + "grpcio-1.12.0-py35hdbcaa40_0.tar.bz2": { + "build": "py35hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "protobuf >=3.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "91cde48b11b9f4aef4ff1319550007a8", + "name": "grpcio", + "sha256": "6857ee0d03726beafe4473d0ae576dc8dbeb8017df09f79596b6ce23f7013124", + "size": 1826759, + "subdir": "linux-64", + "timestamp": 1527833832731, + "version": "1.12.0" + }, + "grpcio-1.12.0-py36hdbcaa40_0.tar.bz2": { + "build": "py36hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "protobuf >=3.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "5f758134066c1d0abf3a250d152ea643", + "name": "grpcio", + "sha256": "b627647d7de28ac004b3537e2c1a5c70cfc190c9df4beebe341e419ead7b2579", + "size": 1827084, + "subdir": "linux-64", + "timestamp": 1527833908871, + "version": "1.12.0" + }, + "grpcio-1.12.1-py27hdbcaa40_0.tar.bz2": { + "build": "py27hdbcaa40_0", + "build_number": 0, + "depends": [ + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "d63177cadd6f65140a4fdad569181ee6", + "name": "grpcio", + "sha256": "7c9cada2fc71dddf99e8e37f4aede4f764f910b2c2da7ee9106e39a1cd2e28c1", + "size": 1830098, + "subdir": "linux-64", + "timestamp": 1529433346834, + "version": "1.12.1" + }, + "grpcio-1.12.1-py35hdbcaa40_0.tar.bz2": { + "build": "py35hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "a607ec50de72e266f32d1c9f47bbefe5", + "name": "grpcio", + "sha256": "dc59c4ed3ba402fd635733a0e3919ce48c686502fb67f50ef7d9c85dd6ac6dfa", + "size": 1831915, + "subdir": "linux-64", + "timestamp": 1529433401942, + "version": "1.12.1" + }, + "grpcio-1.12.1-py36hdbcaa40_0.tar.bz2": { + "build": "py36hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "f08e676531e779cf323dd2aeceab4254", + "name": "grpcio", + "sha256": "23a1220fadd37102eba60d2d253915cf417884ea13f0cd6740b397261e2e26cd", + "size": 1834483, + "subdir": "linux-64", + "timestamp": 1529433350282, + "version": "1.12.1" + }, + "grpcio-1.12.1-py37hdbcaa40_0.tar.bz2": { + "build": "py37hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "034a8176d741f05d7ea95c46dedfa2f6", + "name": "grpcio", + "sha256": "04fd2ca8e5ae2020bef0b767a3abdfd4434a940f647fd175d1a843ce211e5dd1", + "size": 1833125, + "subdir": "linux-64", + "timestamp": 1530892643313, + "version": "1.12.1" + }, + "grpcio-1.14.1-py27h9ba97e2_0.tar.bz2": { + "build": "py27h9ba97e2_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "eb53511139f145897702efb1831f3e13", + "name": "grpcio", + "sha256": "c6661ba17021a0b65c72b72247c917bca071490ced0310b3c85b452f10213b85", + "size": 1048367, + "subdir": "linux-64", + "timestamp": 1541542294982, + "version": "1.14.1" + }, + "grpcio-1.14.1-py27hf8bcb03_0.tar.bz2": { + "build": "py27hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "49d85dc85930c605cda82810c86aaab3", + "name": "grpcio", + "sha256": "0b4c5780578fc78f0914b68a62d6adae09b3f83e46a68acd18d809986a8f4c6b", + "size": 1041051, + "subdir": "linux-64", + "timestamp": 1541545051748, + "version": "1.14.1" + }, + "grpcio-1.14.1-py27hf8bcb03_1.tar.bz2": { + "build": "py27hf8bcb03_1", + "build_number": 1, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "bd075d25f18fe56278fb1ac417fe5cde", + "name": "grpcio", + "sha256": "33068442ea3482e8512b0fc9af49575dfeacdc064f25bc3fa453453f5ad0a587", + "size": 1046177, + "subdir": "linux-64", + "timestamp": 1542417806321, + "version": "1.14.1" + }, + "grpcio-1.14.1-py36h9ba97e2_0.tar.bz2": { + "build": "py36h9ba97e2_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "52bd1588a4d82dd301e8128499689914", + "name": "grpcio", + "sha256": "522687dbbae86d0ecf98fa8bf44eb100a4a8ce8a1bf63c721e343203b7b59c88", + "size": 1054197, + "subdir": "linux-64", + "timestamp": 1541542179041, + "version": "1.14.1" + }, + "grpcio-1.14.1-py36hf8bcb03_0.tar.bz2": { + "build": "py36hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "969cbc553e94735d803d4ffd2fb98b59", + "name": "grpcio", + "sha256": "f3299e36caf325e61f88bb97c08e1102acaf8fd43a439a6208894c00269f1c9d", + "size": 1054449, + "subdir": "linux-64", + "timestamp": 1541545056009, + "version": "1.14.1" + }, + "grpcio-1.14.1-py36hf8bcb03_1.tar.bz2": { + "build": "py36hf8bcb03_1", + "build_number": 1, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "41d4a9177816322f10c2afcbfd63b206", + "name": "grpcio", + "sha256": "d516a6c19721a702a10231c68c03471ddf695625394abebdad052236d3203e22", + "size": 1056199, + "subdir": "linux-64", + "timestamp": 1542417910047, + "version": "1.14.1" + }, + "grpcio-1.14.1-py37h9ba97e2_0.tar.bz2": { + "build": "py37h9ba97e2_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "70762551a851d5dd6fc193a9c8677201", + "name": "grpcio", + "sha256": "d46dc34b2716496ef91861501c283703594c8c5887e887889c4bc2ec0a6bd4a3", + "size": 1044849, + "subdir": "linux-64", + "timestamp": 1541542297492, + "version": "1.14.1" + }, + "grpcio-1.14.1-py37hf8bcb03_0.tar.bz2": { + "build": "py37hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "0f524ae6bd3818067da97a51948ce29f", + "name": "grpcio", + "sha256": "d70f5c6c32aeb445dd4ea4ffc9f92e980d91c4f0fecfed10b36b77b698ec5449", + "size": 1052921, + "subdir": "linux-64", + "timestamp": 1541545020349, + "version": "1.14.1" + }, + "grpcio-1.14.1-py37hf8bcb03_1.tar.bz2": { + "build": "py37hf8bcb03_1", + "build_number": 1, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "dfb1044f36695542538aa0e63b0d408c", + "name": "grpcio", + "sha256": "c3e35ef7cafb16e5df9f574239e1cd17c607ca1d0bb30ba22250a8e7c3486f45", + "size": 1046126, + "subdir": "linux-64", + "timestamp": 1542417809905, + "version": "1.14.1" + }, + "grpcio-1.16.0-py27hf8bcb03_0.tar.bz2": { + "build": "py27hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "b20242ab8e0ab0c47a822cb24d1e231f", + "name": "grpcio", + "sha256": "3b3644529ef917b72bf82ded1624f2e05983a36948687c54f1cb5878df8dae32", + "size": 1086223, + "subdir": "linux-64", + "timestamp": 1542136639437, + "version": "1.16.0" + }, + "grpcio-1.16.0-py36hf8bcb03_0.tar.bz2": { + "build": "py36hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "d07cb5a69c8e761633c79f4222a46dd5", + "name": "grpcio", + "sha256": "f59b1144107bcef7defa71c9596845ffaf3f0d3964ee27067514008958991940", + "size": 1096443, + "subdir": "linux-64", + "timestamp": 1542136775682, + "version": "1.16.0" + }, + "grpcio-1.16.0-py37hf8bcb03_0.tar.bz2": { + "build": "py37hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "7d7eb840e6d9d16b3ad67cf6d35b728b", + "name": "grpcio", + "sha256": "f248f9ce46269c5de16f3a0b04834141937b40c54e49c7d95db2b39b82cd2649", + "size": 1094791, + "subdir": "linux-64", + "timestamp": 1542136738746, + "version": "1.16.0" + }, + "grpcio-1.16.1-py27hf8bcb03_0.tar.bz2": { + "build": "py27hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "424c57abd0357f8e80a2ab8ffaa10a9a", + "name": "grpcio", + "sha256": "2ea1f7431f54fa97d849b521c17d910492bfc633feb9c95cd6cfb244139d8a1d", + "size": 1084910, + "subdir": "linux-64", + "timestamp": 1542389654273, + "version": "1.16.1" + }, + "grpcio-1.16.1-py27hf8bcb03_1.tar.bz2": { + "build": "py27hf8bcb03_1", + "build_number": 1, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "e99358f151b760f531489686480f71ae", + "name": "grpcio", + "sha256": "3cd2378bbd9e0befd70bf5f13d3a8faa39d59390dd7a76840608a69d51442846", + "size": 1080651, + "subdir": "linux-64", + "timestamp": 1542480068976, + "version": "1.16.1" + }, + "grpcio-1.16.1-py36hf8bcb03_0.tar.bz2": { + "build": "py36hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "19160c4b0161ca7d7b2694fa24e25448", + "name": "grpcio", + "sha256": "4b3fdf79cad00e167e302399241180e6c7ecd08474fb43d6e4835a7322c6c890", + "size": 1102199, + "subdir": "linux-64", + "timestamp": 1542389586218, + "version": "1.16.1" + }, + "grpcio-1.16.1-py36hf8bcb03_1.tar.bz2": { + "build": "py36hf8bcb03_1", + "build_number": 1, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "e95952360a4cdec1d43f9c0251b29efa", + "name": "grpcio", + "sha256": "5fd852b114a953860908b5870f3236307392916dcec091b7cdd152f15d15eb87", + "size": 1101402, + "subdir": "linux-64", + "timestamp": 1542480175632, + "version": "1.16.1" + }, + "grpcio-1.16.1-py37hf8bcb03_0.tar.bz2": { + "build": "py37hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "91503a888346a7daf92ee6e0db85ebcd", + "name": "grpcio", + "sha256": "f2c4d925758ccf16ba39c9cf4e32e4948b56a3e03d633fb8eee9da1c4084964e", + "size": 1100353, + "subdir": "linux-64", + "timestamp": 1542389421220, + "version": "1.16.1" + }, + "grpcio-1.16.1-py37hf8bcb03_1.tar.bz2": { + "build": "py37hf8bcb03_1", + "build_number": 1, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "469d64770d7ed7be046ca854719d5db7", + "name": "grpcio", + "sha256": "436001b5de75d646eccbcc9b004c8f6d9d43144fce87e9f0026bc550ca3bd4ed", + "size": 1098331, + "subdir": "linux-64", + "timestamp": 1542480078679, + "version": "1.16.1" + }, + "grpcio-1.16.1-py38hf8bcb03_1.tar.bz2": { + "build": "py38hf8bcb03_1", + "build_number": 1, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "94577c93b4077682c434c19234b20727", + "name": "grpcio", + "sha256": "16232681cd3a1b3279c35c6bb1755710eeb507808e69c0b47884ccd047ccac05", + "size": 1014795, + "subdir": "linux-64", + "timestamp": 1574251845417, + "version": "1.16.1" + }, + "grpcio-1.27.2-py27hf8bcb03_0.tar.bz2": { + "build": "py27hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "56e43c55ea0b8a2bdd224089fd5c6685", + "name": "grpcio", + "sha256": "8a0716522651932aa3b788a2b7edc2eeb93cbfe6e06074d928073db2bccb19a0", + "size": 1426719, + "subdir": "linux-64", + "timestamp": 1582044959557, + "version": "1.27.2" + }, + "grpcio-1.27.2-py36hf8bcb03_0.tar.bz2": { + "build": "py36hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "807db7212391eb6f73a0ed60941a7c97", + "name": "grpcio", + "sha256": "29bbc180db9a38aa5537348f9f244c3596369a1ec4e51cdd0ed97004f410509a", + "size": 1458374, + "subdir": "linux-64", + "timestamp": 1581978720544, + "version": "1.27.2" + }, + "grpcio-1.27.2-py37hf8bcb03_0.tar.bz2": { + "build": "py37hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "8c1a974e7dfafa1585e2c7988d6edc04", + "name": "grpcio", + "sha256": "e5f0c298d8151e36ddcb330ac0bcf1a5e0bacc0d99e9253f585ea567064a4979", + "size": 1472730, + "subdir": "linux-64", + "timestamp": 1581978537409, + "version": "1.27.2" + }, + "grpcio-1.27.2-py38hf8bcb03_0.tar.bz2": { + "build": "py38hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "272962c5162e28d6f0eda684b68a31d4", + "name": "grpcio", + "sha256": "91f001cfa7f60a43d27aeca62988faeac1c9f7c941ed0244e114dcd3b10f8a3e", + "size": 1482237, + "subdir": "linux-64", + "timestamp": 1581978730234, + "version": "1.27.2" + }, + "grpcio-1.31.0-py36hf8bcb03_0.tar.bz2": { + "build": "py36hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9a5f4d17fd75d5b2c070a99578770d1e", + "name": "grpcio", + "sha256": "77bfe37f3d76137bfc40b8d58ac5245446721822b7429ffd8cd480d29433a17f", + "size": 2337732, + "subdir": "linux-64", + "timestamp": 1597424580274, + "version": "1.31.0" + }, + "grpcio-1.31.0-py37hf8bcb03_0.tar.bz2": { + "build": "py37hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b31cc66a407171eb5f402e55de320206", + "name": "grpcio", + "sha256": "915eed0f134c0bddf9a9643953b79d1e3fe25d8c9c35ba57b9263591b9123399", + "size": 2336270, + "subdir": "linux-64", + "timestamp": 1597424582078, + "version": "1.31.0" + }, + "grpcio-1.31.0-py38hf8bcb03_0.tar.bz2": { + "build": "py38hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "0d2247534be21cfc4c0b25462a9b7226", + "name": "grpcio", + "sha256": "316c7461e37de51e83e3e3c152c85754aeebcd325a66804dbccb12d456f489c9", + "size": 2366118, + "subdir": "linux-64", + "timestamp": 1597424617399, + "version": "1.31.0" + }, + "grpcio-1.35.0-py310hce63b2e_0.tar.bz2": { + "build": "py310hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.10,<3.11.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "3c33d8ac02642612ee4267f59abf060a", + "name": "grpcio", + "sha256": "4c7c4f88e152daa1f5f61856479a4713db99cb1cf4ed76a70eb0e551977ced17", + "size": 26697574, + "subdir": "linux-64", + "timestamp": 1640790718584, + "version": "1.35.0" + }, + "grpcio-1.35.0-py36h2157cd5_1.tar.bz2": { + "build": "py36h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "4a9e678ddb8cf91129e9b33fa6f49e8c", + "name": "grpcio", + "sha256": "e5658d3b097c350fc0442995b10e57cb6a6e7e026ced9b00cf067fa6dba1ff92", + "size": 2098694, + "subdir": "linux-64", + "timestamp": 1613730259403, + "version": "1.35.0" + }, + "grpcio-1.35.0-py36hce63b2e_0.tar.bz2": { + "build": "py36hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c2f039effe6c91162fcfa3208ead1e2c", + "name": "grpcio", + "sha256": "1cc02363240f24a21f0194ebc3da80a708dbe59f6a4569fb82e6f41c4d4a1b08", + "size": 2106708, + "subdir": "linux-64", + "timestamp": 1613123348768, + "version": "1.35.0" + }, + "grpcio-1.35.0-py37h2157cd5_1.tar.bz2": { + "build": "py37h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c3aa340e723be02f22164f82caafa2eb", + "name": "grpcio", + "sha256": "0a0e0dd82f47c07731178bec2fe71251f4f155becf1eb7b557b977cf96e04d9a", + "size": 2105742, + "subdir": "linux-64", + "timestamp": 1613730258454, + "version": "1.35.0" + }, + "grpcio-1.35.0-py37hce63b2e_0.tar.bz2": { + "build": "py37hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "bd836b96449a242c1b2ff087d17d54d0", + "name": "grpcio", + "sha256": "9827ae12168c02befb8c1b3965294e1187179302d590ab435cabf89d38550afe", + "size": 2097185, + "subdir": "linux-64", + "timestamp": 1613123417932, + "version": "1.35.0" + }, + "grpcio-1.35.0-py38h2157cd5_1.tar.bz2": { + "build": "py38h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "4b05079fdb9765041abe5ec552469072", + "name": "grpcio", + "sha256": "90c5d13b0fc7e182cf4483547c391fd877d8aac5f007120f021c412e94455add", + "size": 2135621, + "subdir": "linux-64", + "timestamp": 1613730258855, + "version": "1.35.0" + }, + "grpcio-1.35.0-py38hce63b2e_0.tar.bz2": { + "build": "py38hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7c3618db71bfb92fa8b8ce1add0d22eb", + "name": "grpcio", + "sha256": "7a25bb105316b2c2574a950cf3e032fea08b988c67eefb528962bdc12f1fd0af", + "size": 2145184, + "subdir": "linux-64", + "timestamp": 1613123555260, + "version": "1.35.0" + }, + "grpcio-1.35.0-py39h2157cd5_1.tar.bz2": { + "build": "py39h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8e42866b67d52bc229e61a102ac2d48b", + "name": "grpcio", + "sha256": "b1690a21d5c7b3b74582c4e56a5b39ab9af84ec5dcf0fa6f0ef6f3b3920077c4", + "size": 2156445, + "subdir": "linux-64", + "timestamp": 1613729902975, + "version": "1.35.0" + }, + "grpcio-1.35.0-py39hce63b2e_0.tar.bz2": { + "build": "py39hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "0ca516ca36c3f3816862b19813259322", + "name": "grpcio", + "sha256": "7897fbe8cee8fb913f45a0de47737af174a72463baeed2480ae6ce610f4f976d", + "size": 2149742, + "subdir": "linux-64", + "timestamp": 1613123488152, + "version": "1.35.0" + }, + "grpcio-1.36.0-py36h2157cd5_1.tar.bz2": { + "build": "py36h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "57d9382ad784cab40b4f5c3b6cd5e469", + "name": "grpcio", + "sha256": "71ff2252a1c95c6f10dbcc2586cc5a2e0bdd40a57c213e6540908148737a071c", + "size": 2135163, + "subdir": "linux-64", + "timestamp": 1614614921359, + "version": "1.36.0" + }, + "grpcio-1.36.0-py37h2157cd5_1.tar.bz2": { + "build": "py37h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "83d61a9843d243773df9ddd08b63442a", + "name": "grpcio", + "sha256": "f40b68101ffec6bc4d23e7189fc70390d9fdcc61d9b8679c9fd4bbbd84dd25e0", + "size": 2145872, + "subdir": "linux-64", + "timestamp": 1614616088040, + "version": "1.36.0" + }, + "grpcio-1.36.0-py38h2157cd5_1.tar.bz2": { + "build": "py38h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b50037ecad8b09ae02bab97f54694bfd", + "name": "grpcio", + "sha256": "1dd50b364558d9f5ed72530252ab081a6777fd607cf1033552a81cd7e70ff5b2", + "size": 2187571, + "subdir": "linux-64", + "timestamp": 1614616092937, + "version": "1.36.0" + }, + "grpcio-1.36.0-py39h2157cd5_1.tar.bz2": { + "build": "py39h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5b87867f9c01b6682c2c8385e49a560f", + "name": "grpcio", + "sha256": "27ddd1dad81c4998e3ee350b62e4285546c1d67fd0072a68f4a3e357f6cb4b37", + "size": 2195700, + "subdir": "linux-64", + "timestamp": 1614616081813, + "version": "1.36.0" + }, + "grpcio-1.36.1-py36h2157cd5_1.tar.bz2": { + "build": "py36h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "1ea1ab97911bd29c9c0115c03b6f05c9", + "name": "grpcio", + "sha256": "6ce7fd3d4afff95e99a8fec24b020d5b879da7fa1800f487342c0361228a1051", + "size": 2136354, + "subdir": "linux-64", + "timestamp": 1614884350411, + "version": "1.36.1" + }, + "grpcio-1.36.1-py37h2157cd5_1.tar.bz2": { + "build": "py37h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a94a88056e794ed7605c7a761db22595", + "name": "grpcio", + "sha256": "ffdca5ba87071c14e8aa01747ad7a30086ccd710ecf6df6be6d58c2044fc97d2", + "size": 2134168, + "subdir": "linux-64", + "timestamp": 1614884088704, + "version": "1.36.1" + }, + "grpcio-1.36.1-py38h2157cd5_1.tar.bz2": { + "build": "py38h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e68548d2aadfa521d31deae1028d4eb4", + "name": "grpcio", + "sha256": "460d10eccbafbb5064e10f3f2eb8e93b877a58fc34dd7cd2cc82903e30a7050e", + "size": 2188098, + "subdir": "linux-64", + "timestamp": 1614884308168, + "version": "1.36.1" + }, + "grpcio-1.36.1-py39h2157cd5_1.tar.bz2": { + "build": "py39h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "01f200fa945a104de41010465550bc10", + "name": "grpcio", + "sha256": "bb98f895c539848f3392d0ca3de75e75edafd0f19a7d96f732909e2c58077967", + "size": 2179610, + "subdir": "linux-64", + "timestamp": 1614884327430, + "version": "1.36.1" + }, + "grpcio-1.42.0-py310hce63b2e_0.tar.bz2": { + "build": "py310hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.18.1,<2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1o,<1.1.2a", + "python >=3.10,<3.11.0a0", + "six >=1.5.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "55e3bda87762aa4150dd34ebe926c6c6", + "name": "grpcio", + "sha256": "af4e0b8c2e3a5177ef14f2464e8145cc3305922ae14ef5d3fb9d7cd361e409f4", + "size": 35554430, + "subdir": "linux-64", + "timestamp": 1655801249151, + "version": "1.42.0" + }, + "grpcio-1.42.0-py311ha637b67_0.tar.bz2": { + "build": "py311ha637b67_0", + "build_number": 0, + "depends": [ + "c-ares >=1.18.1,<2.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.11,<3.12.0a0", + "six >=1.5.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a91202baff2544156384865620711f67", + "name": "grpcio", + "sha256": "d8276680b99d1df72e7329231774821d2f177cb4100664ad677bb8840ea26f3a", + "size": 2437326, + "subdir": "linux-64", + "timestamp": 1676830777553, + "version": "1.42.0" + }, + "grpcio-1.42.0-py37hce63b2e_0.tar.bz2": { + "build": "py37hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "61cfb4b4b6ae55f3662780a28d4f08c4", + "name": "grpcio", + "sha256": "9aacf2c368d32f41fb0eeb7e5ce0fe191d889afb4543f87dcd6ff000b91de71d", + "size": 2356854, + "subdir": "linux-64", + "timestamp": 1637578137686, + "version": "1.42.0" + }, + "grpcio-1.42.0-py38hce63b2e_0.tar.bz2": { + "build": "py38hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "58a5b6e638408a7a4c1a86d84b0af41f", + "name": "grpcio", + "sha256": "1febebaf5662f11e70f9e8387fa94452c47bb75657dd4e9107bd4207db28ce41", + "size": 2413694, + "subdir": "linux-64", + "timestamp": 1637590943256, + "version": "1.42.0" + }, + "grpcio-1.42.0-py39hce63b2e_0.tar.bz2": { + "build": "py39hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.9,<3.10.0a0", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "1e59a8028206e4b49fbaf44df6de185b", + "name": "grpcio", + "sha256": "547510025ac7f3d400ff1ac1dcecdb27b9b1dd3b9706432efc9cd2f48aa59995", + "size": 2425059, + "subdir": "linux-64", + "timestamp": 1637590949116, + "version": "1.42.0" + }, + "grpcio-gcp-0.2.2-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "grpcio >=1.35.0,<2.0a0", + "protobuf >=3.17.2,<4.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "fae720c0d484539135957488815cfde0", + "name": "grpcio-gcp", + "sha256": "aef8dfab00adf71881c059fbdce518718496ad3d7cbadc9bb3cb8aba93c8c2c4", + "size": 26257, + "subdir": "linux-64", + "timestamp": 1640809317521, + "version": "0.2.2" + }, + "grpcio-gcp-0.2.2-py311h06a4308_2.tar.bz2": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "grpcio >=1.42.0,<2.0a0", + "protobuf >=3.20.3,<4.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "10b4248890bae0f28cbaac61da560ab0", + "name": "grpcio-gcp", + "sha256": "5a55a9a5220931ab9d624e6ed6d076f12d72851ab4538929f4f9abc7776ca1ca", + "size": 32363, + "subdir": "linux-64", + "timestamp": 1676839934572, + "version": "0.2.2" + }, + "grpcio-gcp-0.2.2-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "grpcio >=1.27.2,<2.0a0", + "protobuf >=3.11.4,<4.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "5ccac6de43636ab2c2b309aa6349052a", + "name": "grpcio-gcp", + "sha256": "755436b2524e3b2ed35a8e0b842c28174d6bee93dda3af1b38c74ef43ffc784c", + "size": 26570, + "subdir": "linux-64", + "timestamp": 1586542195785, + "version": "0.2.2" + }, + "grpcio-gcp-0.2.2-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "grpcio >=1.35.0,<2.0a0", + "protobuf >=3.14.0,<4.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "81d4b9acc52c25a1bdefa502b08095f4", + "name": "grpcio-gcp", + "sha256": "04c26726b2bcc90acb6f77764a6cf65de369c74a600d1c167211805083534889", + "size": 26766, + "subdir": "linux-64", + "timestamp": 1613736034557, + "version": "0.2.2" + }, + "grpcio-gcp-0.2.2-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "grpcio >=1.27.2,<2.0a0", + "protobuf >=3.11.4,<4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "c11bf3c4275a40064fc431dc42e03ed7", + "name": "grpcio-gcp", + "sha256": "cea081ef337289e3ee9d3493ff00080038d6acfa0bff9f8e24974d7c53e38d0c", + "size": 26584, + "subdir": "linux-64", + "timestamp": 1586542188662, + "version": "0.2.2" + }, + "grpcio-gcp-0.2.2-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "grpcio >=1.35.0,<2.0a0", + "protobuf >=3.14.0,<4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "85b282085f8e0b67b410953289cb9b89", + "name": "grpcio-gcp", + "sha256": "13e88d1fb7c8263ec1d0f48075a5ceb0e5f29a186f0550db56b682f8f698d9e3", + "size": 26800, + "subdir": "linux-64", + "timestamp": 1613736783692, + "version": "0.2.2" + }, + "grpcio-gcp-0.2.2-py38_2.tar.bz2": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "grpcio >=1.27.2,<2.0a0", + "protobuf >=3.11.4,<4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "41df2a84ed665677928a2a5cd09cf3f0", + "name": "grpcio-gcp", + "sha256": "656da441318a7beec0e60c2dfb8b205c2175c6450f0893f423692b1948707c0d", + "size": 26878, + "subdir": "linux-64", + "timestamp": 1586542193855, + "version": "0.2.2" + }, + "grpcio-gcp-0.2.2-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "grpcio >=1.35.0,<2.0a0", + "protobuf >=3.14.0,<4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "a962094861b57603c50247d18f19a2b1", + "name": "grpcio-gcp", + "sha256": "434161f62f05dd35e6bffb8f84db51b17506fa4e982c31d4cd1e9a65a50682a2", + "size": 27068, + "subdir": "linux-64", + "timestamp": 1613736457618, + "version": "0.2.2" + }, + "grpcio-gcp-0.2.2-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "grpcio >=1.35.0,<2.0a0", + "protobuf >=3.14.0,<4.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "31bfe9e071f1678ec80d852f8f008830", + "name": "grpcio-gcp", + "sha256": "eb89112ace14b8cabf16b998e84b92c4534c24b68231ac212ab9734d825169b4", + "size": 27118, + "subdir": "linux-64", + "timestamp": 1613736791059, + "version": "0.2.2" + }, + "grpcio-tools-1.16.1-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "grpcio >=1.16.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "3222a3f2b5099e145740b2324cad9766", + "name": "grpcio-tools", + "sha256": "98fd7f264b853e15b47feb85d685887892f2017c0ef12c6c4e10dea03e491fa2", + "size": 1863227, + "subdir": "linux-64", + "timestamp": 1542484630393, + "version": "1.16.1" + }, + "grpcio-tools-1.16.1-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "grpcio >=1.16.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "protobuf >=3.6.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "7c26b90a0d39313b2aefa801c531b7db", + "name": "grpcio-tools", + "sha256": "70037b6c384c10d6b4e2ee67a85a48086827a1647d9d9b67aa1cc37192fb0031", + "size": 21238483, + "subdir": "linux-64", + "timestamp": 1641902617662, + "version": "1.16.1" + }, + "grpcio-tools-1.16.1-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "grpcio >=1.16.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "d392e586fffaff09bbd8d21aad1b4583", + "name": "grpcio-tools", + "sha256": "863d7ca052d70682d281c7c50977d959f8233d4cb23c575b4296dca6ecceaaef", + "size": 1954565, + "subdir": "linux-64", + "timestamp": 1614094849788, + "version": "1.16.1" + }, + "grpcio-tools-1.16.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "grpcio >=1.16.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "df17b4968b8861dfb6032928810fc314", + "name": "grpcio-tools", + "sha256": "362cdce421ed28cf6a394364efa0e1b7fff6ac5082e88c39b325e601badba34b", + "size": 1860722, + "subdir": "linux-64", + "timestamp": 1542484668532, + "version": "1.16.1" + }, + "grpcio-tools-1.16.1-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "grpcio >=1.16.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "67ded29edc3405cee91a3e29cb3a5c65", + "name": "grpcio-tools", + "sha256": "8d6a55fed6691c564c78c719c200fc5ef9bb091d599f3f008028a7d5051bbb05", + "size": 1956873, + "subdir": "linux-64", + "timestamp": 1614094820551, + "version": "1.16.1" + }, + "grpcio-tools-1.16.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "grpcio >=1.16.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "54f2db990dc9cd49adfa0b1ef5935daa", + "name": "grpcio-tools", + "sha256": "fcb440174807f5c3de4d22055431e482de8b85ceeb3cb43a0bb5f17754cd1946", + "size": 1864092, + "subdir": "linux-64", + "timestamp": 1542484648236, + "version": "1.16.1" + }, + "grpcio-tools-1.16.1-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "grpcio >=1.16.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "eec63082263a56bdc5d3b92434b0c235", + "name": "grpcio-tools", + "sha256": "c8a6e0f11c5849e6b4bca78a5682cdda58526266bb4e4c31598735d5cbd897f6", + "size": 1960527, + "subdir": "linux-64", + "timestamp": 1614094782356, + "version": "1.16.1" + }, + "grpcio-tools-1.16.1-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "grpcio >=1.16.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "e794f8f1bbc6427fe42ab71df1d28dea", + "name": "grpcio-tools", + "sha256": "6f93e000368c8e131247f004c27c0d531c8118183f87028b25e3d511c1c48c08", + "size": 1911249, + "subdir": "linux-64", + "timestamp": 1592222363402, + "version": "1.16.1" + }, + "grpcio-tools-1.16.1-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "grpcio >=1.16.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "d5f9035856cddf784e72e2ad22ad51df", + "name": "grpcio-tools", + "sha256": "227df03484454f62473e153184e5dda952d8df886981d41823d513306513ece1", + "size": 1952919, + "subdir": "linux-64", + "timestamp": 1614094850053, + "version": "1.16.1" + }, + "grpcio-tools-1.35.0-py36h2531618_1.tar.bz2": { + "build": "py36h2531618_1", + "build_number": 1, + "depends": [ + "grpcio 1.35.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6b45f9f696f6cd8c1f67d5f6b50526f1", + "name": "grpcio-tools", + "sha256": "d0b1f36d5b111cec44bf1e2c5955b4b16eef8b5bf55ace0ff281e07a11972f5b", + "size": 2035002, + "subdir": "linux-64", + "timestamp": 1614095581957, + "version": "1.35.0" + }, + "grpcio-tools-1.35.0-py37h2531618_1.tar.bz2": { + "build": "py37h2531618_1", + "build_number": 1, + "depends": [ + "grpcio 1.35.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8f06d47f88ad8c55eb633870742c7672", + "name": "grpcio-tools", + "sha256": "3907e0a85047bdd5c6bdcf04dd1cdebaef511f0dd6cacf72d9589c74b0b4d31f", + "size": 2032737, + "subdir": "linux-64", + "timestamp": 1614095562664, + "version": "1.35.0" + }, + "grpcio-tools-1.35.0-py38h2531618_1.tar.bz2": { + "build": "py38h2531618_1", + "build_number": 1, + "depends": [ + "grpcio 1.35.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b6131c35ea68fedd6848cd977713e528", + "name": "grpcio-tools", + "sha256": "f040a2bf8e10b48209ccda74abb346b62eacb239cba6ea7c3dc0fbc687d72633", + "size": 2038950, + "subdir": "linux-64", + "timestamp": 1614095601451, + "version": "1.35.0" + }, + "grpcio-tools-1.35.0-py39h2531618_1.tar.bz2": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "grpcio 1.35.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e329c9a74061b9318e41697e1678d355", + "name": "grpcio-tools", + "sha256": "5ee3fa7691ab4234fb6c83bfd07159ad8711d9a4a8622b4ebb08a0f91578c8b4", + "size": 2038281, + "subdir": "linux-64", + "timestamp": 1614094643681, + "version": "1.35.0" + }, + "grpcio-tools-1.42.0-py310h6a678d5_2.tar.bz2": { + "build": "py310h6a678d5_2", + "build_number": 2, + "depends": [ + "grpcio 1.42.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "protobuf >=3.6.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6310ef86fd6b01b966301cb30d0312de", + "name": "grpcio-tools", + "sha256": "a65c7b2ccc0ac386156fde48f72caf4a504ac176adc142e982dbf0a872ff7a1d", + "size": 2211012, + "subdir": "linux-64", + "timestamp": 1678832108599, + "version": "1.42.0" + }, + "grpcio-tools-1.42.0-py311h6a678d5_1.tar.bz2": { + "build": "py311h6a678d5_1", + "build_number": 1, + "depends": [ + "grpcio 1.42.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "protobuf >=3.6.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "34b903bf521904cb55d931225607c724", + "name": "grpcio-tools", + "sha256": "fb6b2d03b96ebc8a4ce494684d20dbd31f88b56c4cb0fa9b5e107983795e5b06", + "size": 2209082, + "subdir": "linux-64", + "timestamp": 1677033086776, + "version": "1.42.0" + }, + "grpcio-tools-1.42.0-py311h6a678d5_2.tar.bz2": { + "build": "py311h6a678d5_2", + "build_number": 2, + "depends": [ + "grpcio 1.42.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "protobuf >=3.6.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5be471ff8f0b7a4613489253941e3efa", + "name": "grpcio-tools", + "sha256": "eca864ff2f1037f00f55d9fbc19228a3cd2b83367929323c4a6355887f191393", + "size": 2212058, + "subdir": "linux-64", + "timestamp": 1679336156122, + "version": "1.42.0" + }, + "grpcio-tools-1.42.0-py38h6a678d5_2.tar.bz2": { + "build": "py38h6a678d5_2", + "build_number": 2, + "depends": [ + "grpcio 1.42.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "protobuf >=3.6.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ca8ab86b2d1d8f50d24189b4d3d9f4fa", + "name": "grpcio-tools", + "sha256": "ff19c15fca79c495aa616b0ba15bfdd96cce8bddb2e8e2843a123cb05073e9ef", + "size": 2210921, + "subdir": "linux-64", + "timestamp": 1678831805023, + "version": "1.42.0" + }, + "grpcio-tools-1.42.0-py39h6a678d5_2.tar.bz2": { + "build": "py39h6a678d5_2", + "build_number": 2, + "depends": [ + "grpcio 1.42.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "protobuf >=3.6.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5c9b5e073998067fe6921a80cefbfdee", + "name": "grpcio-tools", + "sha256": "280b38a8d46682d8095bb2fd0fa0f4e6b5c36a8d7c934e71ae2e229f598798c0", + "size": 2209979, + "subdir": "linux-64", + "timestamp": 1678831955815, + "version": "1.42.0" + }, + "gsl-2.2.1-h0743c53_2.tar.bz2": { + "build": "h0743c53_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-3.0", + "md5": "9cb5cc5198b14b97f59a6403996ae910", + "name": "gsl", + "sha256": "990ba72670f68b89bad40699f90b576e1ceb09bec3a5cc4b397e9c8bf514d8a3", + "size": 2739882, + "subdir": "linux-64", + "timestamp": 1505853592676, + "version": "2.2.1" + }, + "gsl-2.2.1-h0c605f7_3.tar.bz2": { + "build": "h0c605f7_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-3.0", + "md5": "e02581a16e3db91dab50890717de2401", + "name": "gsl", + "sha256": "1e9eb850b807663171423349942dcdb6b814fead809c364ccb5f25f5709ce336", + "size": 2740379, + "subdir": "linux-64", + "timestamp": 1510863242362, + "version": "2.2.1" + }, + "gsl-2.2.1-h8267d9d_2.tar.bz2": { + "build": "h8267d9d_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-3.0", + "md5": "8af7b5e33a62397cc8d1631e38f686ec", + "name": "gsl", + "sha256": "7a460670f090b5d148ce2fcb23fe908e68eb613f9aacb891308e5a3dcf2e6b79", + "size": 2740926, + "subdir": "linux-64", + "timestamp": 1507908707654, + "version": "2.2.1" + }, + "gsl-2.4-h14c3975_4.tar.bz2": { + "build": "h14c3975_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-3.0", + "md5": "6ddfd90f41962216874a1524d873e556", + "name": "gsl", + "sha256": "00becf8ebd6984ccca3f8ff6e1852c2da661ab0cf02e06d9c37de3089d6d4d64", + "size": 2768675, + "subdir": "linux-64", + "timestamp": 1528733108675, + "version": "2.4" + }, + "gsl-2.4-h1bed415_3.tar.bz2": { + "build": "h1bed415_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-3.0", + "md5": "500c35fe20070c4a5efc5e1b277d15a2", + "name": "gsl", + "sha256": "e6f4d51d2423511155fdbe7d2fd868f912d773295da81169e784496026620f5a", + "size": 2770343, + "subdir": "linux-64", + "timestamp": 1522454546595, + "version": "2.4" + }, + "gsl-2.6-ha341630_0.tar.bz2": { + "build": "ha341630_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "GPL-3.0", + "md5": "f40817546d3c9b352cd9dcbcbd5016c9", + "name": "gsl", + "sha256": "ac9b4e6643006a02f576280bc0aff73f012d435f49407f5e2785736b49052e63", + "size": 3206227, + "subdir": "linux-64", + "timestamp": 1646837162243, + "version": "2.6" + }, + "gsl-2.6-he715372_0.tar.bz2": { + "build": "he715372_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0" + ], + "license": "GPL-3.0", + "md5": "7c2eba379b6e75bfed83c1cf3c8476bd", + "name": "gsl", + "sha256": "220ded0453f2441ee9605f941b7e471ac8a1717d9ac7d231081db2f681a7af17", + "size": 3205022, + "subdir": "linux-64", + "timestamp": 1646836943961, + "version": "2.6" + }, + "gsl-2.7-ha341630_0.tar.bz2": { + "build": "ha341630_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "GPL-3.0", + "md5": "860fd4fd7a5a6803f385018e349a2419", + "name": "gsl", + "sha256": "9a27e7d641371e4a34e68569625951cad0ed8a28e6232bfa3b36c792c74d6860", + "size": 3282917, + "subdir": "linux-64", + "timestamp": 1646932570996, + "version": "2.7" + }, + "gsl-2.7-he715372_0.tar.bz2": { + "build": "he715372_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0" + ], + "license": "GPL-3.0", + "md5": "6291b6d6ccbb1959dc48aa0433abb36d", + "name": "gsl", + "sha256": "dae51f7b43e80bd81c0d935b56067e9f0b97eba1257c84505ccd0df6b60dee3e", + "size": 3282326, + "subdir": "linux-64", + "timestamp": 1646932809871, + "version": "2.7" + }, + "gsl-2.7.1-h6e86dc7_1.tar.bz2": { + "build": "h6e86dc7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "2b007d0d86d2bc680c640e51aa4ae2ce", + "name": "gsl", + "sha256": "477615902fc4df0312caa6fc2076f03ab832e612080af810bfe591ce539f9ed5", + "size": 3384459, + "subdir": "linux-64", + "timestamp": 1656079436673, + "version": "2.7.1" + }, + "gsl-2.7.1-h917eeb2_1.tar.bz2": { + "build": "h917eeb2_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "f58c84913465f83033ca90db52460699", + "name": "gsl", + "sha256": "a098b550ce7713c9ed1ca59bde1bc606b507da9f9b6132b0b429ae71ef11e392", + "size": 3384226, + "subdir": "linux-64", + "timestamp": 1656079188989, + "version": "2.7.1" + }, + "gsl-2.7.1-h9f31491_0.tar.bz2": { + "build": "h9f31491_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "8da3e0e970c9853e8966d8a588c6cb81", + "name": "gsl", + "sha256": "b6111eba30786083ac60886ac10ed1ace0b15b9edba6bf9766c4a4e867f7cac5", + "size": 3285823, + "subdir": "linux-64", + "timestamp": 1647851723326, + "version": "2.7.1" + }, + "gsl-2.7.1-hd82f3ee_0.tar.bz2": { + "build": "hd82f3ee_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "decb3215b83887ea1c46f693c16d58c6", + "name": "gsl", + "sha256": "7549d425cc85678f681cc602260525806bcffda87f278423851db48759328f20", + "size": 3303039, + "subdir": "linux-64", + "timestamp": 1647869597902, + "version": "2.7.1" + }, + "gst-plugins-base-1.12.2-he3457e5_0.tar.bz2": { + "build": "he3457e5_0", + "build_number": 0, + "depends": [ + "gstreamer >=1.12.2,<1.13.0a0", + "libgcc-ng >=7.2.0", + "xz >=5.2.3,<6.0a0" + ], + "license": "GPL2", + "md5": "e22a59540e7dc1cb35c0edc432683d2b", + "name": "gst-plugins-base", + "sha256": "83307555c6160a891d0ab799431c83e38bc7d248e891ea257b504b255d993ef3", + "size": 5145424, + "subdir": "linux-64", + "timestamp": 1505735977489, + "version": "1.12.2" + }, + "gst-plugins-base-1.12.4-h33fb286_0.tar.bz2": { + "build": "h33fb286_0", + "build_number": 0, + "depends": [ + "gstreamer >=1.12.4,<1.13.0a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.12,<2.0a0", + "xz >=5.2.3,<6.0a0" + ], + "license": "GPL2", + "md5": "ca942792e5d3886919a2b7b91a8f39c8", + "name": "gst-plugins-base", + "sha256": "bb4b014d3daea95dd511a5eb1dd3187fb3b19324670465f25957fd8c0ebc05a1", + "size": 5049636, + "subdir": "linux-64", + "timestamp": 1516817613741, + "version": "1.12.4" + }, + "gst-plugins-base-1.14.0-h8213a91_2.tar.bz2": { + "build": "h8213a91_2", + "build_number": 2, + "depends": [ + "glib >=2.66.1,<3.0a0", + "gstreamer >=1.14.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxcb >=1.14,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "df2e0695e2edbd91b719da5b15249c5a", + "name": "gst-plugins-base", + "sha256": "c85c664066c685b606df768d23eac08e1b824e391eb59f61a9ef608f4f46c5b6", + "size": 6651032, + "subdir": "linux-64", + "timestamp": 1609866747525, + "version": "1.14.0" + }, + "gst-plugins-base-1.14.0-hbbd80ab_1.tar.bz2": { + "build": "hbbd80ab_1", + "build_number": 1, + "depends": [ + "glib >=2.56.1,<3.0a0", + "gstreamer >=1.14.0,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "d0d3ac97d7a559d27b9e99959db81207", + "name": "gst-plugins-base", + "sha256": "1c675b50fae5b9a2ce7c7944f9d7e5f3725b9d426d0b2ba507aaf95dd856356b", + "size": 6555655, + "subdir": "linux-64", + "timestamp": 1523671420695, + "version": "1.14.0" + }, + "gst-plugins-base-1.14.0-he9c8b40_0.tar.bz2": { + "build": "he9c8b40_0", + "build_number": 0, + "depends": [ + "glib >=2.53.6,<3.0a0", + "gstreamer >=1.14.0,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "xz >=5.2.3,<6.0a0" + ], + "md5": "b6d1166e4e251ae77f2495e560215541", + "name": "gst-plugins-base", + "sha256": "82ede287db44b1d8bcc75a60d831c354e40f345c7412387e013603325792dec1", + "size": 5229179, + "subdir": "linux-64", + "timestamp": 1522700978144, + "version": "1.14.0" + }, + "gst-plugins-base-1.14.1-h6a678d5_1.tar.bz2": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "gstreamer >=1.14.1,<2.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxcb >=1.14,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "2fa837925e0633ceae4ec826f6daa93f", + "name": "gst-plugins-base", + "sha256": "833208211f0ecb52198f5fae585f937be3c337c15b4569d8f1a28638545250d5", + "size": 2253949, + "subdir": "linux-64", + "timestamp": 1677171916164, + "version": "1.14.1" + }, + "gst-plugins-base-1.18.5-hc549b11_0.tar.bz2": { + "build": "hc549b11_0", + "build_number": 0, + "depends": [ + "gettext", + "glib >=2.69.1,<3.0a0", + "gstreamer >=1.18.5,<2.0a0", + "libgcc-ng >=7.5.0", + "libogg", + "libopus >=1.3.1,<2.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libvorbis", + "libxcb >=1.14,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "e85c8d6014d04fc5588961be62e10026", + "name": "gst-plugins-base", + "sha256": "578e066a37c6f6d76f2d66b793f4c6d8d70be7af20f52ac421d166a9a20462b9", + "size": 2681062, + "subdir": "linux-64", + "timestamp": 1632218706352, + "version": "1.18.5" + }, + "gst-plugins-good-1.18.5-hb67d8dd_0.tar.bz2": { + "build": "hb67d8dd_0", + "build_number": 0, + "depends": [ + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.18.5,<2.0a0", + "gstreamer >=1.18.5,<2.0a0", + "lame >=3.100,<3.101.0a0", + "libgcc-ng >=7.5.0", + "libpng", + "libstdcxx-ng >=7.5.0", + "mpg123", + "zlib" + ], + "md5": "08223859dcd46cb2cb4bbe409e22d9a0", + "name": "gst-plugins-good", + "sha256": "cedc2f6ebf0b302808df4e7f4e2fa57c818a99871d43d120921c419343630b4b", + "size": 1969173, + "subdir": "linux-64", + "timestamp": 1632218761681, + "version": "1.18.5" + }, + "gstreamer-1.12.2-h4f93127_0.tar.bz2": { + "build": "h4f93127_0", + "build_number": 0, + "depends": [ + "glib >=2.53.6,<3.0a0", + "libgcc-ng >=7.2.0", + "xz >=5.2.3,<6.0a0" + ], + "license": "LGPL 2", + "md5": "fab6c29a9f81ff87a0998e9cae9f89d7", + "name": "gstreamer", + "sha256": "9bfce566aeb911fa82c6e3c7036000cd912a14f615e2018e93cfecb59b516dfb", + "size": 3814934, + "subdir": "linux-64", + "timestamp": 1505735891617, + "version": "1.12.2" + }, + "gstreamer-1.12.4-hb53b477_0.tar.bz2": { + "build": "hb53b477_0", + "build_number": 0, + "depends": [ + "glib >=2.53.6,<3.0a0", + "libgcc-ng >=7.2.0", + "xz >=5.2.3,<6.0a0" + ], + "license": "LGPL 2", + "md5": "ad6d21bfd3644dc6bbaeca33a5f4b9d7", + "name": "gstreamer", + "sha256": "014d568d971fb3a0163ef668d61a30817944c866fd0165f6826f62a5f852cd59", + "size": 3825916, + "subdir": "linux-64", + "timestamp": 1516817410492, + "version": "1.12.4" + }, + "gstreamer-1.14.0-h28cd5cc_2.tar.bz2": { + "build": "h28cd5cc_2", + "build_number": 2, + "depends": [ + "glib >=2.66.1,<3.0a0", + "libgcc-ng >=7.3.0" + ], + "md5": "83453eb716b94c66fb64391760c0eeb1", + "name": "gstreamer", + "sha256": "dc1af8ae3b38b8d81c00b54dac851618dba87ea8d4083af84dcb60c3070039ad", + "size": 4178090, + "subdir": "linux-64", + "timestamp": 1609866593800, + "version": "1.14.0" + }, + "gstreamer-1.14.0-hb31296c_0.tar.bz2": { + "build": "hb31296c_0", + "build_number": 0, + "depends": [ + "glib >=2.53.6,<3.0a0", + "libgcc-ng >=7.2.0", + "xz >=5.2.3,<6.0a0" + ], + "md5": "0eadae498ccec369140cde904ab558b8", + "name": "gstreamer", + "sha256": "bdcc84470b1b6b5db9cc5f4aeaf06a15e6075ee09c0753ef87647d30a6b711ae", + "size": 3928242, + "subdir": "linux-64", + "timestamp": 1522700842442, + "version": "1.14.0" + }, + "gstreamer-1.14.0-hb453b48_1.tar.bz2": { + "build": "hb453b48_1", + "build_number": 1, + "depends": [ + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pcre >=8.42,<9.0a0", + "xz >=5.2.3,<6.0a0" + ], + "md5": "c76b52069ea63fc59a9b6074b2084657", + "name": "gstreamer", + "sha256": "51f58fde34f182392d63c8d0c7941d9ae12a0e67fe7e3a41321c017a469a01f8", + "size": 4022762, + "subdir": "linux-64", + "timestamp": 1523671228623, + "version": "1.14.0" + }, + "gstreamer-1.14.1-h5eee18b_1.tar.bz2": { + "build": "h5eee18b_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0" + ], + "md5": "5cd8e1f16b1ce869d0c3a98b9f0897fb", + "name": "gstreamer", + "sha256": "8257a1c1c967d48561f62adb649fe21c467f0a37c41f783ba6e2c6d79fa1cc4f", + "size": 1690003, + "subdir": "linux-64", + "timestamp": 1677171850557, + "version": "1.14.1" + }, + "gstreamer-1.18.5-ha1a6a79_0.tar.bz2": { + "build": "ha1a6a79_0", + "build_number": 0, + "depends": [ + "gettext", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=7.5.0" + ], + "md5": "473cda6a24471acbfec11ab2bee3d16c", + "name": "gstreamer", + "sha256": "30e999a6f7af8ace2866d5b17cc2d79724cf448876e986a4e75c54a470a5d8f4", + "size": 2082636, + "subdir": "linux-64", + "timestamp": 1632218649858, + "version": "1.18.5" + }, + "gtest-1.11.0-hdb19cb5_0.tar.bz2": { + "build": "hdb19cb5_0", + "build_number": 0, + "constrains": [ + "gmock 1.11.0" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "73bfbfaa3a70660318849918c2da0980", + "name": "gtest", + "sha256": "96ee44b44c65a9b5b4511c0d4db8ddd7975d389a3dc26b8e9c9786d71e03f018", + "size": 301158, + "subdir": "linux-64", + "timestamp": 1658973567464, + "version": "1.11.0" + }, + "gtest-1.8.0-hf484d3e_4.tar.bz2": { + "build": "hf484d3e_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "95ba34a245f2ebdc4c79fa3dd6d732e1", + "name": "gtest", + "sha256": "832ce5ee0720db7dbcd4079b315ab4edbdfb9b2e0debfa0074f1c4646cb91f33", + "size": 326402, + "subdir": "linux-64", + "timestamp": 1526680086130, + "version": "1.8.0" + }, + "gtk2-2.24.33-h73c1081_2.tar.bz2": { + "build": "h73c1081_2", + "build_number": 2, + "depends": [ + "atk-1.0 >=1.29.2", + "atk-1.0 >=2.36.0", + "cairo >=1.16.0,<2.0a0", + "cairo >=1.6", + "fontconfig", + "freetype", + "gdk-pixbuf >=2.21.0", + "gdk-pixbuf >=2.42.8,<3.0a0", + "glib >=2.28.0,<3.0a0", + "glib >=2.69.1,<3.0a0", + "harfbuzz", + "libgcc-ng >=11.2.0", + "pango >=1.20", + "pango >=1.50.7,<2.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "33770bf2f2e0bb4f804f66a8c718ae3d", + "name": "gtk2", + "sha256": "c9e569e7742e2aea0aaa779ca6ecc31582f629217fb0f996eb43c963e901337b", + "size": 3706756, + "subdir": "linux-64", + "timestamp": 1656608247070, + "version": "2.24.33" + }, + "gts-0.7.6-hb67d8dd_2.tar.bz2": { + "build": "hb67d8dd_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "LGPL-2.0-or-later", + "md5": "3fbd73feb3ac6f3289cf9b64b1dda928", + "name": "gts", + "sha256": "372198d4c966b97759b21b32c3d4507c1f36feb0a6cf2237511c7141bea3bbbd", + "size": 421300, + "subdir": "linux-64", + "timestamp": 1631785118368, + "version": "0.7.6" + }, + "gts-0.7.6-hb67d8dd_3.tar.bz2": { + "build": "hb67d8dd_3", + "build_number": 3, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "7959ca29b7f34b7f2164884b7dbc2d6d", + "name": "gts", + "sha256": "832e3610305dd1a4023e55c90c50c83f28b5de80a6985482d2221c7056918bcf", + "size": 409748, + "subdir": "linux-64", + "timestamp": 1648045431763, + "version": "0.7.6" + }, + "gunicorn-19.7.1-py27h5cfa6e4_0.tar.bz2": { + "build": "py27h5cfa6e4_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "b1dbf3810ada958407c266a96f404b5a", + "name": "gunicorn", + "sha256": "5b6996c327203a71fa8da56635907adc2c5c6c480a7b03283f47920ddd50a909", + "size": 167648, + "subdir": "linux-64", + "timestamp": 1507873665059, + "version": "19.7.1" + }, + "gunicorn-19.7.1-py35h985f2da_0.tar.bz2": { + "build": "py35h985f2da_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "472cea70eba6a0199215f8f2c5d2f534", + "name": "gunicorn", + "sha256": "a1388d6d3e9ecf31a29505bb37128070c0c95dfb9e0f2e808012209bceff9d6d", + "size": 173750, + "subdir": "linux-64", + "timestamp": 1507873687061, + "version": "19.7.1" + }, + "gunicorn-19.7.1-py36h38c4014_0.tar.bz2": { + "build": "py36h38c4014_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "9604e15c64b84efeba146a5886bc8f94", + "name": "gunicorn", + "sha256": "df9784f6b947fa072195834afaef29440dd7379e8fa8ad35412b6916e4e8843d", + "size": 173177, + "subdir": "linux-64", + "timestamp": 1507873689802, + "version": "19.7.1" + }, + "gunicorn-19.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "2296d45b97cd32f8767df88b6c79d8f8", + "name": "gunicorn", + "sha256": "74a1f751bc1074f34767917a663d93ed4b8222af01285c31b3dbcb91b69b645c", + "size": 175709, + "subdir": "linux-64", + "timestamp": 1573964789862, + "version": "19.8.0" + }, + "gunicorn-19.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "0e98c56d71ed5e6ea1b24e17c1ba4d00", + "name": "gunicorn", + "sha256": "8a518bc8d383e5f028fa3c854f20a298ad7df810d0029b2856e584f35860a8cb", + "size": 181089, + "subdir": "linux-64", + "timestamp": 1573964789437, + "version": "19.8.0" + }, + "gunicorn-19.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "ea4bae5217c1b9a13026faa935983f4d", + "name": "gunicorn", + "sha256": "8f1113ac2347a7fe99dcc2e76af0cfeb042ac74e6e80f5584440d84b7d3fb46b", + "size": 177324, + "subdir": "linux-64", + "timestamp": 1573964781156, + "version": "19.8.0" + }, + "gunicorn-19.8.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "7ee73e3a7171f1f0a4511fb7b284e0f3", + "name": "gunicorn", + "sha256": "7ac6a46026100d4e7b672ee6c8b846f4ff094a2cdc2099db1ffa125caf1e05d6", + "size": 174768, + "subdir": "linux-64", + "timestamp": 1574157869577, + "version": "19.8.0" + }, + "gunicorn-19.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "b14395c41a196dea91f40994b9d71973", + "name": "gunicorn", + "sha256": "a9823efe47d5bdacb355b10bc4cd7f2ab999d4d8624b29dd4a5b703d73c109ec", + "size": 170683, + "subdir": "linux-64", + "timestamp": 1526125494980, + "version": "19.8.1" + }, + "gunicorn-19.8.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "839b628252c23aed840e4b93096b795a", + "name": "gunicorn", + "sha256": "a436293b962f80076fe7af8b8e4e654c2d0e010f43d5fb0497b1af86ed91f69c", + "size": 177429, + "subdir": "linux-64", + "timestamp": 1526125523220, + "version": "19.8.1" + }, + "gunicorn-19.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "af8c6b59a9044c2125a71e1a2926e5b8", + "name": "gunicorn", + "sha256": "76c0dd248b0b81b4a5cda1279b4cd77b1d14712e1978cd0f5fd47ca7c63a0e4e", + "size": 175833, + "subdir": "linux-64", + "timestamp": 1526125485975, + "version": "19.8.1" + }, + "gunicorn-19.8.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "cb7322226c7e6dc1be35f4193e08cbf0", + "name": "gunicorn", + "sha256": "0cb253c90f8aa8bb4b8efd86e402eee53fb778be41e9d3e580b1d67bf457dbc2", + "size": 171668, + "subdir": "linux-64", + "timestamp": 1530892778974, + "version": "19.8.1" + }, + "gunicorn-19.9.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "c614d745761d9606a7bfe02af6504f79", + "name": "gunicorn", + "sha256": "a173ccff2e77e744b16eaf437a06d6d3e67fa19939d30d6204275e1cde901e33", + "size": 170233, + "subdir": "linux-64", + "timestamp": 1532802173081, + "version": "19.9.0" + }, + "gunicorn-19.9.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "d060293553a1c4d744d4788615a67f46", + "name": "gunicorn", + "sha256": "08f88fb8fa22c9ad5068bacc6bc937717dd5d2ce834c4e08a4645039082768e9", + "size": 176754, + "subdir": "linux-64", + "timestamp": 1532802183156, + "version": "19.9.0" + }, + "gunicorn-19.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "5a572a27d03ba184193960d5c135e712", + "name": "gunicorn", + "sha256": "a84e13d74695356b1a677d959d252eafc08532312ade4107e2762087f99d86da", + "size": 175746, + "subdir": "linux-64", + "timestamp": 1532802156392, + "version": "19.9.0" + }, + "gunicorn-19.9.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "4cbcabddac1c51a0ee1d37b77f3fe776", + "name": "gunicorn", + "sha256": "f984960fbebbe3fca64fc0ca77de89254cd2eb3a8a289c3494d991331cee6d35", + "size": 176406, + "subdir": "linux-64", + "timestamp": 1532802234755, + "version": "19.9.0" + }, + "gunicorn-20.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "3bf41df1607a2017d0c2d0cd8afdaba7", + "name": "gunicorn", + "sha256": "7d61abcb3588bbd3e1b206411521cbe3dea8fff5cd1c64111fac5018418b3a53", + "size": 122701, + "subdir": "linux-64", + "timestamp": 1574367708823, + "version": "20.0.0" + }, + "gunicorn-20.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "0cb7973662f33293791e70988a8e38bc", + "name": "gunicorn", + "sha256": "fa634056a016cecc7596631938af769a405f0eafd59af2971a8f510f5efbde4d", + "size": 122962, + "subdir": "linux-64", + "timestamp": 1574367729201, + "version": "20.0.0" + }, + "gunicorn-20.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "19ff93438aab76464ca2b6461a0e0747", + "name": "gunicorn", + "sha256": "f0d8b7ef15f1aa9e992bc093dc2b23c902390e0511b77a40e74aac32469d9053", + "size": 123149, + "subdir": "linux-64", + "timestamp": 1574367724054, + "version": "20.0.0" + }, + "gunicorn-20.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "a87a9d1a08c298d2e2574b6f24741c73", + "name": "gunicorn", + "sha256": "84da24da2d4256bf7f8dbb6d3b908640877e6197035cb43d1b166e7460e6306b", + "size": 123578, + "subdir": "linux-64", + "timestamp": 1576539113150, + "version": "20.0.4" + }, + "gunicorn-20.0.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "eee4ea1b7aaef8259aac277a39b73da2", + "name": "gunicorn", + "sha256": "6884743b85e101f6f2ccdc24223204c3592458fde9cc707585874a37e27ef4b0", + "size": 123652, + "subdir": "linux-64", + "timestamp": 1615980824610, + "version": "20.0.4" + }, + "gunicorn-20.0.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "9d9d632283e6aaaf7baa96abba7fa560", + "name": "gunicorn", + "sha256": "32896a777b7a13f19175e43ecc1b5ed4f1631b23f4177cd6da11ce14e34b5ddb", + "size": 123725, + "subdir": "linux-64", + "timestamp": 1576539089525, + "version": "20.0.4" + }, + "gunicorn-20.0.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "a4dd22b665e671844af55fc1aec23b7a", + "name": "gunicorn", + "sha256": "70ac4b844f69c8aea4ef23fe35b088b9ff3658b54dedca4e0041960173b846d9", + "size": 123870, + "subdir": "linux-64", + "timestamp": 1615981110413, + "version": "20.0.4" + }, + "gunicorn-20.0.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "3e53bedd2bd147eec5df9bc6b219dbb2", + "name": "gunicorn", + "sha256": "bd0de1b1fb4fe4b6787d117ba25636df777b9fe7f27386542eb9f4a0302d9b39", + "size": 123916, + "subdir": "linux-64", + "timestamp": 1576539112556, + "version": "20.0.4" + }, + "gunicorn-20.0.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "4df70087c235c84425eaaf8db444a485", + "name": "gunicorn", + "sha256": "7aaf1818d63ed5c5c08df3ff870b05925247ee705ae6680072ccbc5281e4611a", + "size": 124104, + "subdir": "linux-64", + "timestamp": 1615979224269, + "version": "20.0.4" + }, + "gunicorn-20.0.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "f973b6ce913335ea30f28e685b6e9035", + "name": "gunicorn", + "sha256": "afade9b4068d77e6d222ea3ed8ad1f626149ecda19dd4ae0d28a6cd6c234f0df", + "size": 124446, + "subdir": "linux-64", + "timestamp": 1615982984732, + "version": "20.0.4" + }, + "gunicorn-20.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "e7a8f7af37e089a136d2ae0f5e113c5a", + "name": "gunicorn", + "sha256": "d09a34b93336009fd82d14f4ff28dfabb19f8ec2647d7f686be11f103521abf8", + "size": 123629, + "subdir": "linux-64", + "timestamp": 1640790751007, + "version": "20.1.0" + }, + "gunicorn-20.1.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "fb86fb2173737ec20f4363fcd293abaa", + "name": "gunicorn", + "sha256": "d9c8611c298bd8cab0edbd91406d41c12f37fbbe06847494420120dc5ef1a13a", + "size": 164529, + "subdir": "linux-64", + "timestamp": 1676830795360, + "version": "20.1.0" + }, + "gunicorn-20.1.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "dfb5b9622afcfe09dbd8f53c488879f2", + "name": "gunicorn", + "sha256": "ce9ccf70420aba5eb9b5fce15a24a4aaa9ad04c3428a4ada6081f903f8727178", + "size": 121372, + "subdir": "linux-64", + "timestamp": 1617118223053, + "version": "20.1.0" + }, + "gunicorn-20.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "073073d610f25d2ab9ea334dd48c016a", + "name": "gunicorn", + "sha256": "3126989ae9c6e3cdf53843568c9fa32120b4385df299f7fc747f618ec0489263", + "size": 121636, + "subdir": "linux-64", + "timestamp": 1617120680866, + "version": "20.1.0" + }, + "gunicorn-20.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "786d378221f1b47801493e788c9410ad", + "name": "gunicorn", + "sha256": "6aa1872d9c9ecd68012e4078fae15f35c88117f535b857b3e9ec72d18acc222b", + "size": 121787, + "subdir": "linux-64", + "timestamp": 1617120686537, + "version": "20.1.0" + }, + "gunicorn-20.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "9d878bdcf7411d86b0688bc6e151a245", + "name": "gunicorn", + "sha256": "fe7b5a9895f34424e7806e80516a50c3ce662ba98b789220c34845e7b31b87e4", + "size": 122138, + "subdir": "linux-64", + "timestamp": 1617118229902, + "version": "20.1.0" + }, + "gxx-dbg_linux-64-7.2.0-19.tar.bz2": { + "build": "19", + "build_number": 19, + "depends": [ + "binutils_linux-64 7.2.0 19", + "gcc-dbg_linux-64 7.2.0 19", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "1c9edfb20d9078b9b3235d0c2ddf258e", + "name": "gxx-dbg_linux-64", + "sha256": "65b90b75b6b6c4131fe89e2486c29aee0d3c8cf924a417516e605cbf1591e847", + "size": 5820, + "subdir": "linux-64", + "timestamp": 1513886593194, + "version": "7.2.0" + }, + "gxx-dbg_linux-64-7.2.0-24.tar.bz2": { + "build": "24", + "build_number": 24, + "depends": [ + "binutils_linux-64 7.2.0 24", + "gcc-dbg_linux-64 7.2.0 24", + "gxx_impl_linux-64 7.2.0.*", + "package_has_been_revoked" + ], + "license": "GPL", + "md5": "f4188f1a9f2c1f770291215af4da99c7", + "name": "gxx-dbg_linux-64", + "revoked": true, + "sha256": "0eb85b24ae5ac7c0616ddf92d8dc6dc872df9de24463a5e3d2e292689592cdd2", + "size": 5289, + "subdir": "linux-64", + "timestamp": 1514480887691, + "version": "7.2.0" + }, + "gxx-dbg_linux-64-7.2.0-25.tar.bz2": { + "build": "25", + "build_number": 25, + "depends": [ + "binutils_linux-64 7.2.0 25", + "gcc-dbg_linux-64 7.2.0 25", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "fff6e2c78a4d39088c3d0f5b207fc47b", + "name": "gxx-dbg_linux-64", + "sha256": "5d325792ac60ac01ea38688a536ec2c826e4e00c5ea1bd6ce1fb755a29962948", + "size": 5297, + "subdir": "linux-64", + "timestamp": 1515156402667, + "version": "7.2.0" + }, + "gxx-dbg_linux-64-7.3.0-h553295d_1.tar.bz2": { + "build": "h553295d_1", + "build_number": 1, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_1", + "gcc-dbg_linux-64 7.3.0 h553295d_1", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "f871fda77dd07a17972c94872af84361", + "name": "gxx-dbg_linux-64", + "sha256": "189d20221711982544e6f578659e99656e1506d3ffa26d9d4e8aed239ad1b9da", + "size": 9578, + "subdir": "linux-64", + "timestamp": 1534694164189, + "version": "7.3.0" + }, + "gxx-dbg_linux-64-7.3.0-h553295d_2.tar.bz2": { + "build": "h553295d_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_2", + "gcc-dbg_linux-64 7.3.0 h553295d_2", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "4c064eb90dca22f21c3594da558101d1", + "name": "gxx-dbg_linux-64", + "sha256": "77d220d09fb1306a0e6bc293d7cf661abc3f5999474b77cc4c313bd76da21d85", + "size": 9642, + "subdir": "linux-64", + "timestamp": 1534794499906, + "version": "7.3.0" + }, + "gxx-dbg_linux-64-7.3.0-h553295d_26.tar.bz2": { + "build": "h553295d_26", + "build_number": 26, + "depends": [ + "binutils_linux-64 7.3.0 h6176602_26", + "gcc-dbg_linux-64 7.3.0 h553295d_26", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "17d3ccd8505ab9aef93f0ebb76dc44b6", + "name": "gxx-dbg_linux-64", + "sha256": "0fe17d26053c1f88187128beca8feb5270298027f497a2db9cd6bf591e814aa4", + "size": 9065, + "subdir": "linux-64", + "timestamp": 1534693909906, + "version": "7.3.0" + }, + "gxx-dbg_linux-64-8.2.0-h218040c_1.tar.bz2": { + "build": "h218040c_1", + "build_number": 1, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_1", + "gcc-dbg_linux-64 8.2.0 h218040c_1", + "gxx_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "35b56e636f372633238813c2ed8725f3", + "name": "gxx-dbg_linux-64", + "sha256": "2f979229b04b0ea8e54c55645f422957dde17ba99c2731e2c764eafc7e45783b", + "size": 9606, + "subdir": "linux-64", + "timestamp": 1534694057047, + "version": "8.2.0" + }, + "gxx-dbg_linux-64-8.2.0-h218040c_26.tar.bz2": { + "build": "h218040c_26", + "build_number": 26, + "depends": [ + "binutils_linux-64 8.2.0 h6176602_26", + "gcc-dbg_linux-64 8.2.0 h218040c_26", + "gxx_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "05bbed1b711db308da0e46ae08205c43", + "name": "gxx-dbg_linux-64", + "sha256": "332a8553b92176fb7257cde54d95d5baf7932370940afe04a508d95cd75d52d0", + "size": 9069, + "subdir": "linux-64", + "timestamp": 1534693825575, + "version": "8.2.0" + }, + "gxx_impl_linux-64-11.2.0-h1234567_0.tar.bz2": { + "build": "h1234567_0", + "build_number": 0, + "depends": [ + "gcc_impl_linux-64 11.2.0 h1234567_0", + "libstdcxx-devel_linux-64 11.2.0 h1234567_0", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "394b5bd9dcd7ad74ee184f4108b1c666", + "name": "gxx_impl_linux-64", + "sha256": "a548f3e5e0ced88e7b3f9b6505b03bad7597feb54161d4199aab61e58fa08269", + "size": 13059036, + "subdir": "linux-64", + "timestamp": 1652859909107, + "version": "11.2.0" + }, + "gxx_impl_linux-64-11.2.0-h1234567_1.tar.bz2": { + "build": "h1234567_1", + "build_number": 1, + "depends": [ + "gcc_impl_linux-64 11.2.0 h1234567_1", + "libstdcxx-devel_linux-64 11.2.0 h1234567_1", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "bb0e4cbc37583feff59e1202c2993a3a", + "name": "gxx_impl_linux-64", + "sha256": "a684d49a89a625d947552f13bc1e12670ec1c0bdd452003e25e439b06fba32b2", + "size": 13114401, + "subdir": "linux-64", + "timestamp": 1654091011628, + "version": "11.2.0" + }, + "gxx_impl_linux-64-5.4.0-hdf63c60_3.tar.bz2": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [ + "gcc_impl_linux-64 5.4.0 habb00fd_3" + ], + "license": "GPL", + "md5": "4cb179917d3527d3ba2a70f81779972c", + "name": "gxx_impl_linux-64", + "sha256": "ce29872c0c6e47e12c278e7ea5d81eff4152fafb47e4049a7c9c114def94d663", + "size": 17423291, + "subdir": "linux-64", + "timestamp": 1520969771600, + "version": "5.4.0" + }, + "gxx_impl_linux-64-7.2.0-hd3faf3d_2.tar.bz2": { + "build": "hd3faf3d_2", + "build_number": 2, + "depends": [ + "gcc_impl_linux-64 7.2.0 hc5ce805_2" + ], + "license": "GPL", + "md5": "b5106ae0f434a9df022bbc5d93779d86", + "name": "gxx_impl_linux-64", + "sha256": "23b38831fd6ad842163a8b3bddf118a82ace54e47217ebaf9c8bb5520cd139d1", + "size": 19499088, + "subdir": "linux-64", + "timestamp": 1507263089640, + "version": "7.2.0" + }, + "gxx_impl_linux-64-7.2.0-hdf63c60_3.tar.bz2": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [ + "gcc_impl_linux-64 7.2.0 habb00fd_3" + ], + "license": "GPL", + "md5": "00491a9679a7eb487dad45aafa153c52", + "name": "gxx_impl_linux-64", + "sha256": "4b9c9ff9d271bf18888e415c2f78118d4a494919bc9fd436797dc980043a9672", + "size": 19495556, + "subdir": "linux-64", + "timestamp": 1520534791657, + "version": "7.2.0" + }, + "gxx_impl_linux-64-7.3.0-hdf63c60_0.tar.bz2": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [ + "gcc_impl_linux-64 7.3.0 habb00fd_0" + ], + "license": "GPL", + "md5": "cb2b8a7a09553838b50c9ce67323718f", + "name": "gxx_impl_linux-64", + "sha256": "3ffb2d3b6c45421f5073369903eb56a5e1536f0cb25c7131d430394aa64ed7c3", + "size": 19667639, + "subdir": "linux-64", + "timestamp": 1534628679813, + "version": "7.3.0" + }, + "gxx_impl_linux-64-7.3.0-hdf63c60_1.tar.bz2": { + "build": "hdf63c60_1", + "build_number": 1, + "depends": [ + "gcc_impl_linux-64 7.3.0 habb00fd_1" + ], + "license": "GPL", + "md5": "9641ec21fad5dac14cb13a26607cbac7", + "name": "gxx_impl_linux-64", + "sha256": "b0a240b12f885476c0b10a0aef494d65c464739ffefc74d99484c2b17609bd71", + "size": 19646193, + "subdir": "linux-64", + "timestamp": 1534866887969, + "version": "7.3.0" + }, + "gxx_impl_linux-64-7.5.0-h0a5bf11_17.tar.bz2": { + "build": "h0a5bf11_17", + "build_number": 17, + "depends": [ + "gcc_impl_linux-64 7.5.0 h7105cf2_17", + "libstdcxx-devel_linux-64 7.5.0 hf0c5c8d_17", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "50d7c393c5d22b99c7337bb38fd97feb", + "name": "gxx_impl_linux-64", + "sha256": "0d4c2ca2d1ca1717a327dd5ae25d287e28b4a740634850bf491b8f45baffd680", + "size": 10466053, + "subdir": "linux-64", + "timestamp": 1622660315993, + "version": "7.5.0" + }, + "gxx_impl_linux-64-8.4.0-h9ce2e92_17.tar.bz2": { + "build": "h9ce2e92_17", + "build_number": 17, + "depends": [ + "gcc_impl_linux-64 8.4.0 he7ac559_17", + "libstdcxx-devel_linux-64 8.4.0 hf0c5c8d_17", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "32e637d0a82c87b805c1acddb5b464ec", + "name": "gxx_impl_linux-64", + "sha256": "dfae75a8d2c1826977d4c4bf24413008e62e473dc03add2adf946ad306a49278", + "size": 11076116, + "subdir": "linux-64", + "timestamp": 1622661931975, + "version": "8.4.0" + }, + "gxx_impl_linux-64-9.3.0-hbdd7822_17.tar.bz2": { + "build": "hbdd7822_17", + "build_number": 17, + "depends": [ + "gcc_impl_linux-64 9.3.0 h6df7d76_17", + "libstdcxx-devel_linux-64 9.3.0 hf0c5c8d_17", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "26ea54491f8186e3e93e34687c118e2e", + "name": "gxx_impl_linux-64", + "sha256": "abbc859557da0b08132d3e51cdcfdac20422daa4ec4ccf5808a7fd465497dd81", + "size": 11153464, + "subdir": "linux-64", + "timestamp": 1622663583351, + "version": "9.3.0" + }, + "gxx_linux-64-11.2.0-hc2dff05_0.tar.bz2": { + "build": "hc2dff05_0", + "build_number": 0, + "depends": [ + "binutils_linux-64 2.38.0 hc2dff05_0", + "gcc_linux-64 11.2.0 h5c386dc_0", + "gxx_impl_linux-64 11.2.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "240eea55418d2d2d4a36db6d46e4c69b", + "name": "gxx_linux-64", + "sha256": "41822bf31cb1e1eeee32f04b63472758531053ff9ac35918e5543af856d5a17b", + "size": 23121, + "subdir": "linux-64", + "timestamp": 1652867219256, + "version": "11.2.0" + }, + "gxx_linux-64-5.4.0-h98af8de_24.tar.bz2": { + "build": "h98af8de_24", + "build_number": 24, + "depends": [ + "binutils_linux-64 5.4.0 had2808c_24", + "gcc_linux-64 5.4.0 h98af8de_24", + "gxx_impl_linux-64 5.4.0.*" + ], + "license": "GPL", + "md5": "4fd74b0ce9ee7a3064089539e32870d8", + "name": "gxx_linux-64", + "sha256": "07c4c42b5e05f51162a7de493e43f3d76db2db9af37b2ccfad29a90a44e73e54", + "size": 8619, + "subdir": "linux-64", + "timestamp": 1520970089793, + "version": "5.4.0" + }, + "gxx_linux-64-7.2.0-19.tar.bz2": { + "build": "19", + "build_number": 19, + "depends": [ + "binutils_linux-64 7.2.0 19", + "gcc_linux-64 7.2.0 19", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "6a20721829bf28376df3b642603ec512", + "name": "gxx_linux-64", + "sha256": "353b3b8796934c63959745b223bb29ebfb2f331c3b96d6c19c97cd542217bc50", + "size": 5761, + "subdir": "linux-64", + "timestamp": 1513886715267, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-24.tar.bz2": { + "build": "24", + "build_number": 24, + "depends": [ + "package_has_been_revoked" + ], + "license": "GPL", + "md5": "299bb57acd7f7c6b74e61871e9381fa0", + "name": "gxx_linux-64", + "revoked": true, + "sha256": "113470fb10200d552a7576ceaaadf2e4add2435e4d863aa9e947353dd3f12b48", + "size": 5216, + "subdir": "linux-64", + "timestamp": 1514474639180, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-25.tar.bz2": { + "build": "25", + "build_number": 25, + "depends": [ + "binutils_linux-64 7.2.0 25", + "gcc_linux-64 7.2.0 25", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "2f012a7c31b23580368460027ada5a88", + "name": "gxx_linux-64", + "sha256": "c428402fb5e99113cf45a70661c66977d18389b9c0411e5a098da4addc6f5f77", + "size": 5262, + "subdir": "linux-64", + "timestamp": 1514480906560, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-26.tar.bz2": { + "build": "26", + "build_number": 26, + "depends": [ + "binutils_linux-64 7.2.0 26", + "gcc_linux-64 7.2.0 26", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "fce2707c6bb81aee05a54b79faefd972", + "name": "gxx_linux-64", + "sha256": "f6b766c405da59ffacda624c01592cb963c0dd1e544b34e12ac527aecf680fd8", + "size": 8786, + "subdir": "linux-64", + "timestamp": 1521829433260, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h2e50c1c_15.tar.bz2": { + "build": "h2e50c1c_15", + "build_number": 15, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_15", + "gcc_linux-64 7.2.0 haf1f6fa_15", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "3c3b2b4d36eefe4ef5ed61d45c68f2e8", + "name": "gxx_linux-64", + "sha256": "12ced05b4a8ebfc5cac9d3df843653c4fe0ae2c249a2eb1ae0043d4477317be3", + "size": 5399, + "subdir": "linux-64", + "timestamp": 1511640860559, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h33f4dac_3.tar.bz2": { + "build": "h33f4dac_3", + "build_number": 3, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_3", + "gcc_linux-64 7.2.0 h29fd5c9_3", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "1290a46c6efa93fce6605d3d9420b729", + "name": "gxx_linux-64", + "sha256": "2514e21c5888e4b848a9cc2107832b98175a07fcbf25813a9dd2e311ee747cb3", + "size": 5178, + "subdir": "linux-64", + "timestamp": 1507320237462, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h3aab023_7.tar.bz2": { + "build": "h3aab023_7", + "build_number": 7, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_7", + "gcc_linux-64 7.2.0 h22f992b_7", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "522d0bf49750db4149674f9d79b1c516", + "name": "gxx_linux-64", + "sha256": "aad0734588d4d6cc0331864137fdac01be6414c463c2bebae629e5a18100d7c7", + "size": 4989, + "subdir": "linux-64", + "timestamp": 1507845399923, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h41d9e3f_12.tar.bz2": { + "build": "h41d9e3f_12", + "build_number": 12, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_12", + "gcc_linux-64 7.2.0 hd763dfe_12", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "bb770f1f21052a69220216904dae3966", + "name": "gxx_linux-64", + "sha256": "9b5a53f27e78b277f1f624e26f18a8589368f6e8b869b0acb4861b95fd5490d2", + "size": 5778, + "subdir": "linux-64", + "timestamp": 1510792710651, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h4bc98f9_14.tar.bz2": { + "build": "h4bc98f9_14", + "build_number": 14, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_14", + "gcc_linux-64 7.2.0 hf1c97a4_14", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "2e589e5bf067a8aa62a3711fc7866fc5", + "name": "gxx_linux-64", + "sha256": "44b9df583d8f5108f6111466e58b9f9a3c61e9840a8252a06d4003ee27e27e80", + "size": 5368, + "subdir": "linux-64", + "timestamp": 1510930965483, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h550dcbe_27.tar.bz2": { + "build": "h550dcbe_27", + "build_number": 27, + "depends": [ + "binutils_linux-64 7.2.0 had2808c_27", + "gcc_linux-64 7.2.0 h550dcbe_27", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "7a7c84153ade27b28403f6ce4fe8093e", + "name": "gxx_linux-64", + "sha256": "20365b4f747dd75b1a9338a19c67e28bd3a294328b3e7bc412f1f6463eff334b", + "size": 8689, + "subdir": "linux-64", + "timestamp": 1526461261504, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h57110d4_9.tar.bz2": { + "build": "h57110d4_9", + "build_number": 9, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_9", + "gcc_linux-64 7.2.0 h60973fd_9", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "958feee7d31434284713a7259d663956", + "name": "gxx_linux-64", + "sha256": "85c7e407fce505019d6d21242f10465d350e8c67aaf337b52a1a4a4d92527ccd", + "size": 5195, + "subdir": "linux-64", + "timestamp": 1509836580115, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h5e79354_11.tar.bz2": { + "build": "h5e79354_11", + "build_number": 11, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_11", + "gcc_linux-64 7.2.0 h4118e58_11", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "4ed37951dc49b61fb6c82c18f3d66501", + "name": "gxx_linux-64", + "sha256": "2aa93b1f36061e562f745d0288cc575c9d8fa62cbdcd12d95913bf5a8c653142", + "size": 5193, + "subdir": "linux-64", + "timestamp": 1510566120000, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h60a51f1_2.tar.bz2": { + "build": "h60a51f1_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_2", + "gcc_linux-64 7.2.0 hecb3f9c_2", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "231f22037329851f77ea9ce01562e396", + "name": "gxx_linux-64", + "sha256": "66973ae7a635833fa7f221f022c0969486a365af3bc3135e576e6ed2f66470ef", + "size": 5174, + "subdir": "linux-64", + "timestamp": 1507320101324, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h7798672_13.tar.bz2": { + "build": "h7798672_13", + "build_number": 13, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_13", + "gcc_linux-64 7.2.0 h217957b_13", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "70076ec996b9566f1f4cc720fb095a43", + "name": "gxx_linux-64", + "sha256": "6ee295a490026cb28e3b7e15b590ded88c60f7a574b6c9161daa8a934e3824d4", + "size": 5363, + "subdir": "linux-64", + "timestamp": 1510925049582, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h8cc0f3c_1.tar.bz2": { + "build": "h8cc0f3c_1", + "build_number": 1, + "depends": [ + "gcc_linux-64 7.2.0 hc7b1ceb_1", + "libstdcxx-ng 7.2.0 h24385c6_1" + ], + "license": "GPL", + "md5": "becff21f7d605353bf0082a8ccd749e4", + "name": "gxx_linux-64", + "sha256": "a5c6deb51b9726b18bd8a33acea9c5085139c2811b52728fbca4c863411431d2", + "size": 19714864, + "subdir": "linux-64", + "timestamp": 1505665795414, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-hc01b44c_10.tar.bz2": { + "build": "hc01b44c_10", + "build_number": 10, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_10", + "gcc_linux-64 7.2.0 h196ecd4_10", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "993e9dcd5ca2faa3529821046f4c9d4e", + "name": "gxx_linux-64", + "sha256": "f051de6ad05622702253af203988f495b4445c83ca23e47f16f6e98110c6a2ef", + "size": 5122, + "subdir": "linux-64", + "timestamp": 1510244820492, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-he93fcd3_8.tar.bz2": { + "build": "he93fcd3_8", + "build_number": 8, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_8", + "gcc_linux-64 7.2.0 h6f34251_8", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "71db0b2695112b9d2519338abbef0970", + "name": "gxx_linux-64", + "sha256": "2354c78dc2154bd41158d2e775a23c1948de2703b65fc29339907e18f4fce91d", + "size": 4941, + "subdir": "linux-64", + "timestamp": 1509635179708, + "version": "7.2.0" + }, + "gxx_linux-64-7.3.0-h553295d_15.tar.bz2": { + "build": "h553295d_15", + "build_number": 15, + "depends": [ + "binutils_linux-64 2.33.1 h9595d00_15", + "gcc_linux-64 7.3.0 h553295d_15", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "BSD-3-Clause", + "md5": "5a58d977860308194de55b9cce044abf", + "name": "gxx_linux-64", + "sha256": "2367561c0099879afc4edf7212cbdd1316050fdb9bd182fcd998537456d04502", + "size": 25100, + "subdir": "linux-64", + "timestamp": 1576707760857, + "version": "7.3.0" + }, + "gxx_linux-64-7.3.0-h553295d_2.tar.bz2": { + "build": "h553295d_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_2", + "gcc_linux-64 7.3.0 h553295d_2", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "ccce72728dadbd87fff2231bc778c361", + "name": "gxx_linux-64", + "sha256": "af8a46b6933733e5f33cc09a9f3400b56e63f125ca2e888a3472f9c1a4ea9bb3", + "size": 9680, + "subdir": "linux-64", + "timestamp": 1534793060512, + "version": "7.3.0" + }, + "gxx_linux-64-7.3.0-h553295d_3.tar.bz2": { + "build": "h553295d_3", + "build_number": 3, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_3", + "gcc_linux-64 7.3.0 h553295d_3", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "87c065e198addda4116d1887c99c433d", + "name": "gxx_linux-64", + "sha256": "24cd488188e2227769ec26bc2ee17416a1156c0f6371e47ff43b1776a5d2e16e", + "size": 9668, + "subdir": "linux-64", + "timestamp": 1534948650088, + "version": "7.3.0" + }, + "gxx_linux-64-7.3.0-h553295d_6.tar.bz2": { + "build": "h553295d_6", + "build_number": 6, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_6", + "gcc_linux-64 7.3.0 h553295d_6", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "68987a6fe6ec55ddedfaf82950591ec7", + "name": "gxx_linux-64", + "sha256": "d2ac5e24ef0522272931615f8e729f2c35bd068acb900fa6c947eeada17ba93d", + "size": 10589, + "subdir": "linux-64", + "timestamp": 1546883616664, + "version": "7.3.0" + }, + "gxx_linux-64-7.3.0-h553295d_7.tar.bz2": { + "build": "h553295d_7", + "build_number": 7, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_7", + "gcc_linux-64 7.3.0 h553295d_7", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "4189e8ed9b21fe75404c18cb405b423b", + "name": "gxx_linux-64", + "sha256": "fdfce84c025ef93a0caa8c5a794120a0a32e1f155754ef009d22704a5509f288", + "size": 9766, + "subdir": "linux-64", + "timestamp": 1556137070192, + "version": "7.3.0" + }, + "gxx_linux-64-7.3.0-h553295d_8.tar.bz2": { + "build": "h553295d_8", + "build_number": 8, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_8", + "gcc_linux-64 7.3.0 h553295d_8", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "62201d8b1e60b5c07ab6194ace2d14ff", + "name": "gxx_linux-64", + "sha256": "7b6566fad9d93994afcfca5ee15f7651c7fea7f2ff192c4bdce68c81959f507e", + "size": 152006, + "subdir": "linux-64", + "timestamp": 1565123741742, + "version": "7.3.0" + }, + "gxx_linux-64-7.3.0-h553295d_9.tar.bz2": { + "build": "h553295d_9", + "build_number": 9, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_9", + "gcc_linux-64 7.3.0 h553295d_9", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "BSD-3-Clause", + "md5": "ba98cd7386b608368654fc80beba7c12", + "name": "gxx_linux-64", + "sha256": "070c7344b2f44cb9a861ec05a85b565e3dd64b618c89fff8b2a559bd0cfd5cc7", + "size": 25067, + "subdir": "linux-64", + "timestamp": 1576689718754, + "version": "7.3.0" + }, + "gxx_linux-64-7.5.0-hffc177d_30.tar.bz2": { + "build": "hffc177d_30", + "build_number": 30, + "depends": [ + "binutils_linux-64 2.35.1 h454624a_30", + "gcc_linux-64 7.5.0 h8f34230_30", + "gxx_impl_linux-64 7.5.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "6053753064d82123bed1993619962ec9", + "name": "gxx_linux-64", + "sha256": "2a38e5ec8f42772dbc850b65951e45a03e8d56e0db3f4d7e053c79895b503915", + "size": 22816, + "subdir": "linux-64", + "timestamp": 1623135032961, + "version": "7.5.0" + }, + "gxx_linux-64-8.2.0-h218040c_2.tar.bz2": { + "build": "h218040c_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_2", + "gcc_linux-64 8.2.0 h218040c_2", + "gxx_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "094281fda19d52569a714d105a54bef8", + "name": "gxx_linux-64", + "sha256": "77f6294c566b79595ffcb10107dbcace128fded609445ea52fa9a7271eeb2338", + "size": 9677, + "subdir": "linux-64", + "timestamp": 1534792667384, + "version": "8.2.0" + }, + "gxx_linux-64-8.2.0-h218040c_3.tar.bz2": { + "build": "h218040c_3", + "build_number": 3, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_3", + "gcc_linux-64 8.2.0 h218040c_3", + "gxx_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "8c8102bcb06226349f4b4cdacdf66f10", + "name": "gxx_linux-64", + "sha256": "0739be1ba36045575273951fec2db3ed2b74c4c0601941323f342521087615e6", + "size": 10573, + "subdir": "linux-64", + "timestamp": 1546883594184, + "version": "8.2.0" + }, + "gxx_linux-64-8.4.0-h85ed34b_30.tar.bz2": { + "build": "h85ed34b_30", + "build_number": 30, + "depends": [ + "binutils_linux-64 2.35.1 h454624a_30", + "gcc_linux-64 8.4.0 he201b7d_30", + "gxx_impl_linux-64 8.4.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "dfa2a12ef71375665134c8ffbb07a571", + "name": "gxx_linux-64", + "sha256": "8d90683c81f7dfc8181f8c1c69bfd4b7833e0587edf25d4b3bf34d9549a9d4f7", + "size": 22802, + "subdir": "linux-64", + "timestamp": 1623135567676, + "version": "8.4.0" + }, + "gxx_linux-64-9.3.0-h7e70986_30.tar.bz2": { + "build": "h7e70986_30", + "build_number": 30, + "depends": [ + "binutils_linux-64 2.35.1 h454624a_30", + "gcc_linux-64 9.3.0 h1ee779e_30", + "gxx_impl_linux-64 9.3.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "8ed3a75f808319731720cd589835ef97", + "name": "gxx_linux-64", + "sha256": "f6d62da597bc1e5ab5c75a12f8ae1ac4056cae5f906725a52872fad5e02c9b6d", + "size": 22786, + "subdir": "linux-64", + "timestamp": 1623136142801, + "version": "9.3.0" + }, + "gymnasium-0.26.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.2.0", + "gymnasium-notices", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d35778e08de453fc5625eddb24bdfca", + "name": "gymnasium", + "sha256": "d949efed83f9f0a11e2c92173ddbc48d0b16ceda8cfb3bcdf030a6903055f542", + "size": 915932, + "subdir": "linux-64", + "timestamp": 1678091784144, + "version": "0.26.3" + }, + "gymnasium-0.26.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.2.0", + "gymnasium-notices", + "importlib_metadata >=4.8.1", + "numpy >=1.19.5,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e26951a31d54e3146ff20ce19d7b1207", + "name": "gymnasium", + "sha256": "ae1a71905ba885b1b8037b985d253d62a4d2d90fbafda40ef834295593b53cda", + "size": 918210, + "subdir": "linux-64", + "timestamp": 1678091696810, + "version": "0.26.3" + }, + "gymnasium-0.26.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.2.0", + "gymnasium-notices", + "importlib_metadata >=4.8.1", + "numpy >=1.19.5,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34376b552b632c66b1a1f2399a502d41", + "name": "gymnasium", + "sha256": "7113eba392f85b2551aa4423bb82cc0475f567739cec7471faed12a01adbeb1e", + "size": 913426, + "subdir": "linux-64", + "timestamp": 1678091740601, + "version": "0.26.3" + }, + "gymnasium-notices-0.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5784a9afcf218093d5d9b166e0d6f420", + "name": "gymnasium-notices", + "sha256": "72a583617a6d347879448f7e79fe810e73a7222a50c1a3639cdb7ea818d172bc", + "size": 6803, + "subdir": "linux-64", + "timestamp": 1677830286713, + "version": "0.0.1" + }, + "gymnasium-notices-0.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e42291db8b690069d6f0c0404d7c3bad", + "name": "gymnasium-notices", + "sha256": "6b68fa651a3094ce36c6d89d020393c150e01b1202f0a366a9bbac7ac454c3a9", + "size": 6760, + "subdir": "linux-64", + "timestamp": 1677830262325, + "version": "0.0.1" + }, + "gymnasium-notices-0.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f164ca426d6e7f8e97d3072edd49213b", + "name": "gymnasium-notices", + "sha256": "f586efe789ad966cee271786da5cf79bf3d3ee70cae0e166d800f1ff72c83c3c", + "size": 6774, + "subdir": "linux-64", + "timestamp": 1677830238500, + "version": "0.0.1" + }, + "h2-3.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34 >=1.1.6,<2", + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "622363ea1909b52ab5f309622f5630b3", + "name": "h2", + "sha256": "2c985bb4dd07a71064854f3c54621d6665ab46dc7f1c7519f7bd49a64393a5bd", + "size": 79140, + "subdir": "linux-64", + "timestamp": 1530919165874, + "version": "3.0.1" + }, + "h2-3.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c7a3c7e724a3cf559e14b81c74f9c37", + "name": "h2", + "sha256": "984e9cb5bca7ed7d6c8e69302c9a15533a28f1c0fe26a7b82bf778368c447cf5", + "size": 80820, + "subdir": "linux-64", + "timestamp": 1530919107631, + "version": "3.0.1" + }, + "h2-3.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8305a1077a73c04cee8fb33655247d0", + "name": "h2", + "sha256": "246bfb3e64d08cfaab8794459173d1c0315ff7e81bc2e7a092ff1c5e43769252", + "size": 80889, + "subdir": "linux-64", + "timestamp": 1530919136798, + "version": "3.0.1" + }, + "h2-3.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34 >=1.1.6,<2", + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e2459ef450fd3639d93fb189005da38", + "name": "h2", + "sha256": "b172d7f100712639130b4fc3aa5f63636d476cfd45e223b1627330aaedb7b450", + "size": 81924, + "subdir": "linux-64", + "timestamp": 1552378479679, + "version": "3.1.0" + }, + "h2-3.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14e75f888cbeadb87e02a8bb1ce2d0af", + "name": "h2", + "sha256": "66ff720492bddd27d65d2fa41fd36ec6d5bdcac403ac0a42a5937962dee11453", + "size": 83838, + "subdir": "linux-64", + "timestamp": 1552378546254, + "version": "3.1.0" + }, + "h2-3.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7293a4299af4588ce61b361fc2417666", + "name": "h2", + "sha256": "a14c72a9e8f92e17010642ceb03ed9c78c3d9af809aacd9a99809ee6ca6325fb", + "size": 83533, + "subdir": "linux-64", + "timestamp": 1552378459512, + "version": "3.1.0" + }, + "h2-3.1.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "enum34 >=1.1.6,<2", + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0e131478421a6b06d480782696f5023", + "name": "h2", + "sha256": "dce78b210e887017284a2f06c4d5d433dd8305e904ae5ba164ab69c84e3bc0de", + "size": 82895, + "subdir": "linux-64", + "timestamp": 1569424037301, + "version": "3.1.1" + }, + "h2-3.1.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbffb5d77df55e343d30a5e8cb6355b1", + "name": "h2", + "sha256": "00b59212b05be173894357d09ef66323982e9c476aceac67ec9a839f4a280307", + "size": 84735, + "subdir": "linux-64", + "timestamp": 1569424080764, + "version": "3.1.1" + }, + "h2-3.1.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "800caa0f3abfb1f2ef550312a3bb7796", + "name": "h2", + "sha256": "646ed6d79c8bdd508b63c72a25f39b4d70252cd334fe9df54ae2aebebfa7332d", + "size": 84646, + "subdir": "linux-64", + "timestamp": 1569424075409, + "version": "3.1.1" + }, + "h2-3.1.1-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9fa78826748952a1c0ddb599478025bb", + "name": "h2", + "sha256": "76790db9bf5491b0b13be0241b8e2e3b43502361be958ce7f77b894ffa1e3d3c", + "size": 83615, + "subdir": "linux-64", + "timestamp": 1573739755358, + "version": "3.1.1" + }, + "h2-3.2.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c6f89790bd5ff2e5375d288ccadfc4e1", + "name": "h2", + "sha256": "1cf9d8af8303ef4db4eda50034dbc69d5a9beecaa0b35cf7115d7bda4878ce81", + "size": 85939, + "subdir": "linux-64", + "timestamp": 1584958576925, + "version": "3.2.0" + }, + "h2-3.2.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da4f7e05decbc1b9c9666e25f59c24b2", + "name": "h2", + "sha256": "982a5bf1a2d1930c499b086164388d85f2f421abbf3fc1816489f0fc25947129", + "size": 85889, + "subdir": "linux-64", + "timestamp": 1584958518329, + "version": "3.2.0" + }, + "h2-3.2.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0eef4c7c32848d320e3e96792a0fe15c", + "name": "h2", + "sha256": "d3d99c427ef1e5e7e8234502e5200e4c6f77efa90ba7746a3e641de0b1d87a53", + "size": 86288, + "subdir": "linux-64", + "timestamp": 1584958552513, + "version": "3.2.0" + }, + "h2-4.0.0-py310h06a4308_3.tar.bz2": { + "build": "py310h06a4308_3", + "build_number": 3, + "depends": [ + "hpack >=4.0,<5", + "hyperframe >=6.0,<7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11f59ac37b9b78a714edd092cbe3e15c", + "name": "h2", + "sha256": "cda014532e147765992a472a9cbc5d67147800db007311abaf7b4c12ce78b9fb", + "size": 79315, + "subdir": "linux-64", + "timestamp": 1640790768629, + "version": "4.0.0" + }, + "h2-4.0.0-py311h06a4308_3.tar.bz2": { + "build": "py311h06a4308_3", + "build_number": 3, + "depends": [ + "hpack >=4.0,<5", + "hyperframe >=6.0,<7", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be7a234e45ca206d6b7aaaabcac14a11", + "name": "h2", + "sha256": "af1a2d52b945c74ce8243bf5d90b5cba48901d23bf932c0e874c24984a0bf2c4", + "size": 96878, + "subdir": "linux-64", + "timestamp": 1676827200127, + "version": "4.0.0" + }, + "h2-4.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e2ff8105a3d885ee6b0e9b5d9755b9a", + "name": "h2", + "sha256": "c71a8656ee71949658f055b96d709372cadbd1c54fe6f3b973da74b6f6b6d9cc", + "size": 78175, + "subdir": "linux-64", + "timestamp": 1600701272196, + "version": "4.0.0" + }, + "h2-4.0.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa0d5f99c1aeab30a7aae9ad0283e478", + "name": "h2", + "sha256": "9270c6f64792221cc9d4f4906a7f92cec00cb727d3da7265498871abcb9b03f0", + "size": 80905, + "subdir": "linux-64", + "timestamp": 1614083124500, + "version": "4.0.0" + }, + "h2-4.0.0-py36h06a4308_3.tar.bz2": { + "build": "py36h06a4308_3", + "build_number": 3, + "depends": [ + "hpack >=4.0,<5", + "hyperframe >=6.0,<7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34aaf7b45fe5f824156a81fca9b04268", + "name": "h2", + "sha256": "0992c87aceb31de5af155c3576157b62591ccdf347bf2fda0d33864e47eb4350", + "size": 81445, + "subdir": "linux-64", + "timestamp": 1615904362446, + "version": "4.0.0" + }, + "h2-4.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3cb718293d9a9d44e998196bbe6d85e", + "name": "h2", + "sha256": "3429cde82893a4290ca8de603b9b086598ee618c49dba02bf2cb84d795f31d66", + "size": 78174, + "subdir": "linux-64", + "timestamp": 1600701289652, + "version": "4.0.0" + }, + "h2-4.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9089a851d1811ed0e351ba065a63ac4b", + "name": "h2", + "sha256": "e130b096b320c4f732de7cae5dedc714f96e4fca1a285eabaa0616510620e199", + "size": 80840, + "subdir": "linux-64", + "timestamp": 1614082187813, + "version": "4.0.0" + }, + "h2-4.0.0-py37h06a4308_3.tar.bz2": { + "build": "py37h06a4308_3", + "build_number": 3, + "depends": [ + "hpack >=4.0,<5", + "hyperframe >=6.0,<7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a1efb7f052b49c01d6ec7bdd1200bd2", + "name": "h2", + "sha256": "a5add40731fb3385a4b4c9fd9e3eb618cdac0521a0d8f619cafa15aee83ffdbb", + "size": 81439, + "subdir": "linux-64", + "timestamp": 1615904357144, + "version": "4.0.0" + }, + "h2-4.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "838a61738cdd1abe2a92077128f11dfb", + "name": "h2", + "sha256": "d6ccdc3c4a77ee439b1f08c3852b8c76f06f2a764a8f2d558692dbd83c95da18", + "size": 78582, + "subdir": "linux-64", + "timestamp": 1600701294299, + "version": "4.0.0" + }, + "h2-4.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "04bac7158a3cd6bfcbb5625454493d07", + "name": "h2", + "sha256": "f77d4be4d15df0de450aca3fccfc8c112500d7f268636a756704977747a6ef33", + "size": 81258, + "subdir": "linux-64", + "timestamp": 1614082524713, + "version": "4.0.0" + }, + "h2-4.0.0-py38h06a4308_3.tar.bz2": { + "build": "py38h06a4308_3", + "build_number": 3, + "depends": [ + "hpack >=4.0,<5", + "hyperframe >=6.0,<7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e76224e741a4292df9469701a811af9b", + "name": "h2", + "sha256": "0e8cae144673d5fa77d08bd11204c30039956927b9b6631b4b1b1af9d3777f91", + "size": 81829, + "subdir": "linux-64", + "timestamp": 1615904362475, + "version": "4.0.0" + }, + "h2-4.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92c2b0cac182ab8cdd6c6f5038de047b", + "name": "h2", + "sha256": "dea4ad974888de0cb90ca263ea29ede08584cd20d9edcdb8f88d9240fb5b4119", + "size": 81067, + "subdir": "linux-64", + "timestamp": 1614083120606, + "version": "4.0.0" + }, + "h2-4.0.0-py39h06a4308_3.tar.bz2": { + "build": "py39h06a4308_3", + "build_number": 3, + "depends": [ + "hpack >=4.0,<5", + "hyperframe >=6.0,<7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "06efa75e933dd7624889ae3716a71e9f", + "name": "h2", + "sha256": "a6c242abe077adea9d7cb56ac2110555ce80a63fac54d9f089f270817b31a291", + "size": 81879, + "subdir": "linux-64", + "timestamp": 1615904348776, + "version": "4.0.0" + }, + "h2o-3.18.0.2-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "openjdk" + ], + "md5": "1601c59414c1b406520bb9a6118b16b0", + "name": "h2o", + "sha256": "889e7bc533866c52d3ffde7c48a08d54fe2d8b2c43a6f20510c6ded6c3993b01", + "size": 130837997, + "subdir": "linux-64", + "timestamp": 1520278916714, + "version": "3.18.0.2" + }, + "h2o-py-3.18.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "colorama", + "future", + "patsy", + "python >=2.7,<2.8.0a0", + "requests", + "scikit-learn", + "tabulate" + ], + "md5": "939dead565bdd024abad8b151b3e28cb", + "name": "h2o-py", + "sha256": "270e33615266c95713ea57008288e840eb8db71d628013058cc481aeca01fb7f", + "size": 361053, + "subdir": "linux-64", + "timestamp": 1520279240772, + "version": "3.18.0.2" + }, + "h2o-py-3.18.0.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "colorama", + "future", + "patsy", + "python >=3.5,<3.6.0a0", + "requests", + "scikit-learn", + "tabulate" + ], + "md5": "e86bb912e67250a5cd8fc18c1226d211", + "name": "h2o-py", + "sha256": "f7157bfff5ca10c26a0040f5596915025eab36065fd5814a0bfefaa4ae3b335a", + "size": 366917, + "subdir": "linux-64", + "timestamp": 1520279562012, + "version": "3.18.0.2" + }, + "h2o-py-3.18.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "colorama", + "future", + "patsy", + "python >=3.6,<3.7.0a0", + "requests", + "scikit-learn", + "tabulate" + ], + "md5": "68c95d206317d664642b914e52b069b6", + "name": "h2o-py", + "sha256": "8a0616c6f106f8eca7d0d04045159ad85ac1046f726a9b105200d1dafb03dda4", + "size": 368613, + "subdir": "linux-64", + "timestamp": 1520279424827, + "version": "3.18.0.2" + }, + "h5py-2.10.0-py36h7918eee_0.tar.bz2": { + "build": "py36h7918eee_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "e1bf8ede0f7b76bebee0f33d7ffa2dc9", + "name": "h5py", + "sha256": "b49fdac1221aff7b44102c46db183fdf5f98bf001c51b2f99552ceb157313308", + "size": 1246149, + "subdir": "linux-64", + "timestamp": 1580260071832, + "version": "2.10.0" + }, + "h5py-2.10.0-py36hd6299e0_1.tar.bz2": { + "build": "py36hd6299e0_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "4ec8e862f42fa9ee6bda250b88c886ed", + "name": "h5py", + "sha256": "d2bd14280ff58f355d94b362bdf9f285fee72eea34cd63fdc5c033dba8874dcf", + "size": 1109111, + "subdir": "linux-64", + "timestamp": 1593454278638, + "version": "2.10.0" + }, + "h5py-2.10.0-py37h7918eee_0.tar.bz2": { + "build": "py37h7918eee_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "887e7355f3e3382368f19cf14c25dbc9", + "name": "h5py", + "sha256": "03ea3d5d21e590bda07c6f593f53623d6a6ba92580f3513e021d771368a18561", + "size": 1256012, + "subdir": "linux-64", + "timestamp": 1580260008947, + "version": "2.10.0" + }, + "h5py-2.10.0-py37hd6299e0_1.tar.bz2": { + "build": "py37hd6299e0_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "31e9492971c19b39a5f09f17132f10f1", + "name": "h5py", + "sha256": "579d6b954841538fb910e35df672ce9e67d42f59b12c91df109f7aaeaf878f9d", + "size": 1105133, + "subdir": "linux-64", + "timestamp": 1593454273894, + "version": "2.10.0" + }, + "h5py-2.10.0-py38h7918eee_0.tar.bz2": { + "build": "py38h7918eee_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "81f938196d165bcd989d15678b7c3ec3", + "name": "h5py", + "sha256": "f0221b943fd581703d0702ce06478a87ace1612acec141e244b86258e2c8c647", + "size": 1299174, + "subdir": "linux-64", + "timestamp": 1580260036973, + "version": "2.10.0" + }, + "h5py-2.10.0-py38hd6299e0_1.tar.bz2": { + "build": "py38hd6299e0_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "00e754069356c88c3c0c1822bb5b278d", + "name": "h5py", + "sha256": "5082206c6a205ecb662be8e6b77c67bf70610d0a2bff0da84af8e6094fec7e4c", + "size": 1134475, + "subdir": "linux-64", + "timestamp": 1593454278766, + "version": "2.10.0" + }, + "h5py-2.10.0-py39hec9cf62_0.tar.bz2": { + "build": "py39hec9cf62_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "ddce22947c6e548893635adf442695b2", + "name": "h5py", + "sha256": "99bbd33c3288ebd071e70eacd504ed064c581f50629be8787e2085c0f9a4b203", + "size": 1125784, + "subdir": "linux-64", + "timestamp": 1608649145845, + "version": "2.10.0" + }, + "h5py-2.7.0-py27h71d1790_1.tar.bz2": { + "build": "py27h71d1790_1", + "build_number": 1, + "depends": [ + "hdf5", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "e5abf2f52298cb312a8efce473651b8f", + "name": "h5py", + "sha256": "5fe895e37d07d85ca7090de084931df84c62fe4023002a9762b8722098afcc4d", + "size": 1082338, + "subdir": "linux-64", + "timestamp": 1505732542922, + "version": "2.7.0" + }, + "h5py-2.7.0-py35h41d5d6e_1.tar.bz2": { + "build": "py35h41d5d6e_1", + "build_number": 1, + "depends": [ + "hdf5", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "32410f4fa1163432d534af8f17707060", + "name": "h5py", + "sha256": "a461f5e26222af27e41a87032d77d5af662e712f4e303cd0d919218828397af0", + "size": 1081708, + "subdir": "linux-64", + "timestamp": 1505732633193, + "version": "2.7.0" + }, + "h5py-2.7.0-py36he81ebca_1.tar.bz2": { + "build": "py36he81ebca_1", + "build_number": 1, + "depends": [ + "hdf5", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "4e020ddc25b04b031269b8ee7f7b0788", + "name": "h5py", + "sha256": "a38335a7c7118a6691bcae0e5103c5364d687f78c087efe7930f8d92776737e0", + "size": 1102255, + "subdir": "linux-64", + "timestamp": 1505732727459, + "version": "2.7.0" + }, + "h5py-2.7.1-py27h2697762_0.tar.bz2": { + "build": "py27h2697762_0", + "build_number": 0, + "depends": [ + "hdf5", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "b9efd22a4ade19f6c84bb63952f9f3f1", + "name": "h5py", + "sha256": "7d8d585f80868f2ffdfe0d6e50a4321cbafaed21693aec4670c429c394bb50c0", + "size": 1079345, + "subdir": "linux-64", + "timestamp": 1511314445067, + "version": "2.7.1" + }, + "h5py-2.7.1-py27ha1f6525_2.tar.bz2": { + "build": "py27ha1f6525_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "819971ffd12ebfc0cb701827c6b94d51", + "name": "h5py", + "sha256": "9fff74f80285b644570eedfaf1ce62f46228ecc2c41fb495398964f1795ec91e", + "size": 1058078, + "subdir": "linux-64", + "timestamp": 1527222120427, + "version": "2.7.1" + }, + "h5py-2.7.1-py27he2f5538_0.tar.bz2": { + "build": "py27he2f5538_0", + "build_number": 0, + "depends": [ + "hdf5", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "7b1b206e8d2409bccc2610fa7ed3e53b", + "name": "h5py", + "sha256": "08fbf4227f2ca9f8a4e19c3ff06a39692359bf519d9fe3884b0d4d29098efa55", + "size": 1059581, + "subdir": "linux-64", + "timestamp": 1511314295975, + "version": "2.7.1" + }, + "h5py-2.7.1-py35h8d53cdc_0.tar.bz2": { + "build": "py35h8d53cdc_0", + "build_number": 0, + "depends": [ + "hdf5", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "4bf84bebbd516c4ac711350cca8dbc3a", + "name": "h5py", + "sha256": "720eaa94dbcbb323db0ccc56435f98628bd66b33ea85d724b5b67c3931a65919", + "size": 1079963, + "subdir": "linux-64", + "timestamp": 1511314302735, + "version": "2.7.1" + }, + "h5py-2.7.1-py35ha1a889d_0.tar.bz2": { + "build": "py35ha1a889d_0", + "build_number": 0, + "depends": [ + "hdf5", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "a0db07747ddc995fcd49fe3af847fa18", + "name": "h5py", + "sha256": "fe09f4a7f8582f7a251bd430184f3cf0cdd36e377f090bf78b2d80bad5174878", + "size": 1062666, + "subdir": "linux-64", + "timestamp": 1511314474461, + "version": "2.7.1" + }, + "h5py-2.7.1-py35ha1f6525_2.tar.bz2": { + "build": "py35ha1f6525_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "0da91e32c4427a5a6ff625ce3a6d0c35", + "name": "h5py", + "sha256": "fadda4af648561e436dce1941488d869b1b6d91a4e599237bf9b2901789f1e16", + "size": 1070290, + "subdir": "linux-64", + "timestamp": 1527222166885, + "version": "2.7.1" + }, + "h5py-2.7.1-py36h3585f63_0.tar.bz2": { + "build": "py36h3585f63_0", + "build_number": 0, + "depends": [ + "hdf5", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "1f9f00ba4b3d5302595202efd0902de4", + "name": "h5py", + "sha256": "0e52e2937595bfdc7d67395fd900b446155e9dedbc111c4f8968fb5fea785ad7", + "size": 1099850, + "subdir": "linux-64", + "timestamp": 1511314482473, + "version": "2.7.1" + }, + "h5py-2.7.1-py36h9b8c120_0.tar.bz2": { + "build": "py36h9b8c120_0", + "build_number": 0, + "depends": [ + "hdf5", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "395dd1992b5170334c654969bf500fea", + "name": "h5py", + "sha256": "99fad15ebde3158e74a6bd252254b2a384e61e9396bb57e6516bf48b292b0566", + "size": 1079588, + "subdir": "linux-64", + "timestamp": 1511314482429, + "version": "2.7.1" + }, + "h5py-2.7.1-py36ha1f6525_2.tar.bz2": { + "build": "py36ha1f6525_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "e358983bf4fa398d2458967690d0f3d8", + "name": "h5py", + "sha256": "8970850014036002c6dedbf3ae41432b87d297e3dfe993db56776f34e23fc6d6", + "size": 1085575, + "subdir": "linux-64", + "timestamp": 1527221961350, + "version": "2.7.1" + }, + "h5py-2.8.0-py27h39dcb92_0.tar.bz2": { + "build": "py27h39dcb92_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "six", + "unittest2" + ], + "license": "BSD 3-Clause", + "md5": "f6475805ebefaf6109c7726269f3021e", + "name": "h5py", + "sha256": "3ed36fac756db9b3878e282857c5a436b463b7ef480d8c90c75340a6a6874b90", + "size": 1072400, + "subdir": "linux-64", + "timestamp": 1530771427172, + "version": "2.8.0" + }, + "h5py-2.8.0-py27h39dcb92_2.tar.bz2": { + "build": "py27h39dcb92_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "unittest2" + ], + "license": "BSD 3-Clause", + "md5": "1279af99df30b5671bdf1e032696f2b4", + "name": "h5py", + "sha256": "09c97af950a767cf79b127dd496cad2274cbc8d329c3c54a5ce37fcbec96e9cb", + "size": 1061448, + "subdir": "linux-64", + "timestamp": 1534803789056, + "version": "2.8.0" + }, + "h5py-2.8.0-py27h61e79e4_3.tar.bz2": { + "build": "py27h61e79e4_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "unittest2" + ], + "license": "BSD 3-Clause", + "md5": "ddd9ab1c588d92ce5bd8c2b756c56446", + "name": "h5py", + "sha256": "676563d940ca79cd2f67195781b78f0e50064acc315fc4a97e4fc97f498fc89c", + "size": 1061626, + "subdir": "linux-64", + "timestamp": 1534896246279, + "version": "2.8.0" + }, + "h5py-2.8.0-py27h8d01980_0.tar.bz2": { + "build": "py27h8d01980_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "six", + "unittest2" + ], + "license": "BSD 3-Clause", + "md5": "27ba0b0ad9bb6788f1b11881f2163920", + "name": "h5py", + "sha256": "f9d2ddbabd1a073d75c31e95c9ea46a4b5c772d3c1402c178d6b60ad7517303b", + "size": 1087655, + "subdir": "linux-64", + "timestamp": 1530771314025, + "version": "2.8.0" + }, + "h5py-2.8.0-py27h8d01980_2.tar.bz2": { + "build": "py27h8d01980_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "unittest2" + ], + "license": "BSD 3-Clause", + "md5": "4518c9d7e31007073aaf3d545a0de20b", + "name": "h5py", + "sha256": "dbbe0082478c5ba10676c8d26bcd1c5bdcf1fe6d42ccd7f73ff14368f22860af", + "size": 1080011, + "subdir": "linux-64", + "timestamp": 1534803656249, + "version": "2.8.0" + }, + "h5py-2.8.0-py27h989c5e5_3.tar.bz2": { + "build": "py27h989c5e5_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "unittest2" + ], + "license": "BSD 3-Clause", + "md5": "28487c0e7e731d1a2e5db9d2fb3a9266", + "name": "h5py", + "sha256": "78e68c9fb985b083c9a414187e6a8f09e360f68bc9095035ef71fac66c7384bd", + "size": 1079089, + "subdir": "linux-64", + "timestamp": 1534896129694, + "version": "2.8.0" + }, + "h5py-2.8.0-py27ha1f6525_0.tar.bz2": { + "build": "py27ha1f6525_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "six", + "unittest2" + ], + "license": "BSD 3-Clause", + "md5": "f3bd6fe6dcb087a40902cdfabfde19ce", + "name": "h5py", + "sha256": "32a52c680ded35328d0466c3607eea21b61da4f5ebb73efa3188e982ca0bc92a", + "size": 1089070, + "subdir": "linux-64", + "timestamp": 1527801378586, + "version": "2.8.0" + }, + "h5py-2.8.0-py27hca9c191_0.tar.bz2": { + "build": "py27hca9c191_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "six", + "unittest2" + ], + "license": "BSD 3-Clause", + "md5": "2772f26f188dab36f0464acec52799a0", + "name": "h5py", + "sha256": "d0fcf04fe036a19b57dabfc48e9c5080e50814d0b05719a21e090ec746a431c8", + "size": 1072035, + "subdir": "linux-64", + "timestamp": 1527801175706, + "version": "2.8.0" + }, + "h5py-2.8.0-py35h39dcb92_2.tar.bz2": { + "build": "py35h39dcb92_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "5af378f3da478b67d183b1b306012418", + "name": "h5py", + "sha256": "6154f3909879c7aa96f9de553c968d1efdb84441cc4d757c4866ee185d92b382", + "size": 1077480, + "subdir": "linux-64", + "timestamp": 1534803139371, + "version": "2.8.0" + }, + "h5py-2.8.0-py35h61e79e4_3.tar.bz2": { + "build": "py35h61e79e4_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "150cae89ae2c17c016f09cf969d7798d", + "name": "h5py", + "sha256": "5b7aec395a37d6cb68cd8327249c123a18a0b12450ec0d132668087ac77fbe57", + "size": 1077252, + "subdir": "linux-64", + "timestamp": 1534896717081, + "version": "2.8.0" + }, + "h5py-2.8.0-py35h8d01980_2.tar.bz2": { + "build": "py35h8d01980_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "2c85a4e2dd697c3fd94671a2e98179ec", + "name": "h5py", + "sha256": "aa00e36d28c30cc8331cca0f2f47aeb1928bc770f3cd31e7ccbf088163f71eba", + "size": 1095988, + "subdir": "linux-64", + "timestamp": 1534803001064, + "version": "2.8.0" + }, + "h5py-2.8.0-py35h989c5e5_3.tar.bz2": { + "build": "py35h989c5e5_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "44be5ce9b4363fc840aa0d88f2b03d2b", + "name": "h5py", + "sha256": "e9f62a52499e0580bed1e981701b1593de9ee4ab550d64e5fc2056acc0373920", + "size": 1095972, + "subdir": "linux-64", + "timestamp": 1534896601393, + "version": "2.8.0" + }, + "h5py-2.8.0-py35ha1f6525_0.tar.bz2": { + "build": "py35ha1f6525_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "188cdb3421283804ae34e3bc04d9e500", + "name": "h5py", + "sha256": "675740d8433419ac09423d7291578e7f45afa6c80768381acbf6048204caa290", + "size": 1103255, + "subdir": "linux-64", + "timestamp": 1527801407110, + "version": "2.8.0" + }, + "h5py-2.8.0-py35hca9c191_0.tar.bz2": { + "build": "py35hca9c191_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "712a4c03f2740cc7a14facd06d985f58", + "name": "h5py", + "sha256": "e58241a9a092fb6f055042addb5d96d350214b99953d2b13d1e8129eabbc8609", + "size": 1087201, + "subdir": "linux-64", + "timestamp": 1527801409845, + "version": "2.8.0" + }, + "h5py-2.8.0-py36h39dcb92_0.tar.bz2": { + "build": "py36h39dcb92_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "eae1d2ab4374214540be78f9bbb64b2a", + "name": "h5py", + "sha256": "bbd3097c41a0df0561b92e0e1f2feb004cf62886da04c8e116b22779bccd020f", + "size": 1105065, + "subdir": "linux-64", + "timestamp": 1530771658436, + "version": "2.8.0" + }, + "h5py-2.8.0-py36h39dcb92_2.tar.bz2": { + "build": "py36h39dcb92_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "b85491c41c5af036a5adbd4110cbe550", + "name": "h5py", + "sha256": "e7ecaa831575aa015556b85b4761dae5748266b739a3dd09f17f60e7fe6bba49", + "size": 1093517, + "subdir": "linux-64", + "timestamp": 1534804324221, + "version": "2.8.0" + }, + "h5py-2.8.0-py36h61e79e4_3.tar.bz2": { + "build": "py36h61e79e4_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "8450901a76ca5f0ab59c680f61071d10", + "name": "h5py", + "sha256": "6e02a702df9a663417d62c02eeac0d6f8bbba464da64d36938f9edcc23e55517", + "size": 1093513, + "subdir": "linux-64", + "timestamp": 1534896010158, + "version": "2.8.0" + }, + "h5py-2.8.0-py36h8d01980_0.tar.bz2": { + "build": "py36h8d01980_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "94e4cbfcb4d9b5d36cc118a6665d5a2b", + "name": "h5py", + "sha256": "503c398409ed4b5befa60b562583b61d5ffa62a94395023bf56bb3a30480456a", + "size": 1121156, + "subdir": "linux-64", + "timestamp": 1530771543951, + "version": "2.8.0" + }, + "h5py-2.8.0-py36h8d01980_2.tar.bz2": { + "build": "py36h8d01980_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "03c346a82a3aff1cd18090029bc35521", + "name": "h5py", + "sha256": "b511f5115aa928e76593dc30558c97246bb7a5b7108b75d332596957ab0187b7", + "size": 1110427, + "subdir": "linux-64", + "timestamp": 1534804192410, + "version": "2.8.0" + }, + "h5py-2.8.0-py36h989c5e5_3.tar.bz2": { + "build": "py36h989c5e5_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "11e69855025be2a1a51eb5b00a435f8b", + "name": "h5py", + "sha256": "2a99659a02b5ae149bf291a95dd4e376cd03218ffc65da2ce347c1239ad63056", + "size": 1110602, + "subdir": "linux-64", + "timestamp": 1534895888187, + "version": "2.8.0" + }, + "h5py-2.8.0-py36ha1f6525_0.tar.bz2": { + "build": "py36ha1f6525_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "53f4c8114de501cc5883589ee05ee1f3", + "name": "h5py", + "sha256": "0f6eced4cda930b803400833cd72636449858c5c089672ce92e6b9435520defc", + "size": 1120803, + "subdir": "linux-64", + "timestamp": 1527801386533, + "version": "2.8.0" + }, + "h5py-2.8.0-py36hca9c191_0.tar.bz2": { + "build": "py36hca9c191_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "952308b26c14f79e87ae82060ad45300", + "name": "h5py", + "sha256": "0d208953e7ca474b818697b827ba90eb6943a3de62f49029c42d6239249933bd", + "size": 1106594, + "subdir": "linux-64", + "timestamp": 1527801144883, + "version": "2.8.0" + }, + "h5py-2.8.0-py37h39dcb92_0.tar.bz2": { + "build": "py37h39dcb92_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "deee16c75fef457c0c11459d2540340a", + "name": "h5py", + "sha256": "f95f7c517868afb43d6ef6a8322c936c26fa0b544255488c3c7ed1d22846b574", + "size": 1102436, + "subdir": "linux-64", + "timestamp": 1530771198834, + "version": "2.8.0" + }, + "h5py-2.8.0-py37h39dcb92_2.tar.bz2": { + "build": "py37h39dcb92_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "d4531e1d6f72ba27d38ae1c8b5c0e3b0", + "name": "h5py", + "sha256": "d854c60bbbcfcf7f5b612658da5567a415e82c8ae31d21a8676372e203e03f02", + "size": 1090878, + "subdir": "linux-64", + "timestamp": 1534804056947, + "version": "2.8.0" + }, + "h5py-2.8.0-py37h61e79e4_3.tar.bz2": { + "build": "py37h61e79e4_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "61288965017704ec4f5c86dbe46c614e", + "name": "h5py", + "sha256": "7033832d16fedf6f4d9145f74b035d729666f8025643d1d764a1a1956acf36df", + "size": 1090661, + "subdir": "linux-64", + "timestamp": 1534896483336, + "version": "2.8.0" + }, + "h5py-2.8.0-py37h8d01980_0.tar.bz2": { + "build": "py37h8d01980_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "16421a63dc83205b1ccbef6222781de2", + "name": "h5py", + "sha256": "38a4297d241a7ae3164788a9b2bffd48905216fe8cc6e64c0ff3c72deb2ffcb7", + "size": 1118533, + "subdir": "linux-64", + "timestamp": 1530771081330, + "version": "2.8.0" + }, + "h5py-2.8.0-py37h8d01980_2.tar.bz2": { + "build": "py37h8d01980_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "b3b4bface481757ac51902c32c5e3c7b", + "name": "h5py", + "sha256": "4d3b5f69ff8e73b53f5b6bdb3a32d9a3c2d9f09d11b543bea44aad13de444cbe", + "size": 1108358, + "subdir": "linux-64", + "timestamp": 1534803924076, + "version": "2.8.0" + }, + "h5py-2.8.0-py37h989c5e5_3.tar.bz2": { + "build": "py37h989c5e5_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "2b1316e3f3e51fb36f2ed489f1fc453f", + "name": "h5py", + "sha256": "9c732d8aedc292e0193b9011418dc11ce85a668ac8dba8cc82ab47b713d63f98", + "size": 1107971, + "subdir": "linux-64", + "timestamp": 1534896366448, + "version": "2.8.0" + }, + "h5py-2.9.0-py27h7918eee_0.tar.bz2": { + "build": "py27h7918eee_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "unittest2" + ], + "license": "BSD-3-Clause", + "md5": "56143a9c47a786987cd55819fea7c0ef", + "name": "h5py", + "sha256": "1566cd98f66988d6c0d7e94b1dda3be20c0fb94c095683323195ef8cb1dc84b9", + "size": 1165871, + "subdir": "linux-64", + "timestamp": 1545411872838, + "version": "2.9.0" + }, + "h5py-2.9.0-py36h7918eee_0.tar.bz2": { + "build": "py36h7918eee_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "667e91016b7c5381c6b3f95bc120919a", + "name": "h5py", + "sha256": "59f67b31da01cc1df76986a3d9737cabd1748ad8a7d70d3258ccbc21e893e765", + "size": 1216600, + "subdir": "linux-64", + "timestamp": 1545411898065, + "version": "2.9.0" + }, + "h5py-2.9.0-py37h7918eee_0.tar.bz2": { + "build": "py37h7918eee_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "1d2dceea245a0401ed2869695ea05e2b", + "name": "h5py", + "sha256": "3a4ad33e8f02700e3faa439d0bc427d135edfdc8f824825de24178cff548cb97", + "size": 1211733, + "subdir": "linux-64", + "timestamp": 1545411834002, + "version": "2.9.0" + }, + "h5py-2.9.0-py38h7918eee_0.tar.bz2": { + "build": "py38h7918eee_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "b737dfb1ff0ee990e07bd39a9663ab69", + "name": "h5py", + "sha256": "58ba611ab5e4382ef1a5c5673229e6cc17daeb94d3a5155174bccf7ea47a9638", + "size": 1277966, + "subdir": "linux-64", + "timestamp": 1573739904095, + "version": "2.9.0" + }, + "h5py-3.2.1-py37h6c542dc_0.tar.bz2": { + "build": "py37h6c542dc_0", + "build_number": 0, + "depends": [ + "cached-property", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7f4c18627abe57fa6559d1463b947cb9", + "name": "h5py", + "sha256": "e6438944681af482a631fbd4565e832def2eb08abdb745d4bf5c3894bb07d83a", + "size": 1274333, + "subdir": "linux-64", + "timestamp": 1622088619911, + "version": "3.2.1" + }, + "h5py-3.2.1-py38h6c542dc_0.tar.bz2": { + "build": "py38h6c542dc_0", + "build_number": 0, + "depends": [ + "cached-property", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "cc96d81f91257c632453e419837b859e", + "name": "h5py", + "sha256": "ba4899c9acbfa459830202b5ee2cef470ec2e7fa96e178210c740125ea9ebdae", + "size": 1337265, + "subdir": "linux-64", + "timestamp": 1622088642011, + "version": "3.2.1" + }, + "h5py-3.2.1-py39h6c542dc_0.tar.bz2": { + "build": "py39h6c542dc_0", + "build_number": 0, + "depends": [ + "cached-property", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "aa362520bb5d7128ac0030ca0d960d05", + "name": "h5py", + "sha256": "b1306144bf6d3afbab0d1bd49bf6856d0c0cd6802f6dfc71eaf9a37f62f4165e", + "size": 1348834, + "subdir": "linux-64", + "timestamp": 1622088279593, + "version": "3.2.1" + }, + "h5py-3.3.0-py37h930cdd6_0.tar.bz2": { + "build": "py37h930cdd6_0", + "build_number": 0, + "depends": [ + "cached-property", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f72840f310ae0bc64dcfc51c48574fa5", + "name": "h5py", + "sha256": "e5ca9ca24a7ac586f7a26f98a63d4e197ff69057056f1e6e00f6022247c2fb81", + "size": 1276501, + "subdir": "linux-64", + "timestamp": 1636040444012, + "version": "3.3.0" + }, + "h5py-3.3.0-py38h930cdd6_0.tar.bz2": { + "build": "py38h930cdd6_0", + "build_number": 0, + "depends": [ + "cached-property", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "74b344c0302c3392f4d38a990b428300", + "name": "h5py", + "sha256": "df9eb1cd91713d58372f31badcf87811296693d8165a24cc5393e286124d9437", + "size": 1334872, + "subdir": "linux-64", + "timestamp": 1636040714141, + "version": "3.3.0" + }, + "h5py-3.3.0-py39h930cdd6_0.tar.bz2": { + "build": "py39h930cdd6_0", + "build_number": 0, + "depends": [ + "cached-property", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "4c1006c1a2a2eaa3db511f1613d50ff6", + "name": "h5py", + "sha256": "79b7d53f9ff5c04f1debbb039f5c9a9f9c2a5180adfe25e74e0a84cbba36a455", + "size": 1334635, + "subdir": "linux-64", + "timestamp": 1636040709943, + "version": "3.3.0" + }, + "h5py-3.5.0-py37ha0f2276_0.tar.bz2": { + "build": "py37ha0f2276_0", + "build_number": 0, + "depends": [ + "cached-property", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cb894db7e0fabfd27e35d50c723aec61", + "name": "h5py", + "sha256": "b7b6c7be8e34c330c447268093653120c0bb2ebab1c2d24aacc8f35c5dccbb4e", + "size": 1288039, + "subdir": "linux-64", + "timestamp": 1636991252271, + "version": "3.5.0" + }, + "h5py-3.5.0-py37hd430a98_100.tar.bz2": { + "build": "py37hd430a98_100", + "build_number": 100, + "depends": [ + "cached-property", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "333d57d1e8644c513de84087a8d87a70", + "name": "h5py", + "sha256": "97f75cb8cc2a5fccf61c145f6e9ba982696eb3de77a036db43724dd4ff49b8a9", + "size": 1297832, + "subdir": "linux-64", + "timestamp": 1636636868803, + "version": "3.5.0" + }, + "h5py-3.5.0-py38ha0f2276_0.tar.bz2": { + "build": "py38ha0f2276_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "75ef36a5048b84e1e4f6c318cfdc34b0", + "name": "h5py", + "sha256": "d9fad10365679c392fe529a6e358cda7e1ba81318f283fb0da1ddc87cb469130", + "size": 1339520, + "subdir": "linux-64", + "timestamp": 1636978741829, + "version": "3.5.0" + }, + "h5py-3.5.0-py38hd430a98_100.tar.bz2": { + "build": "py38hd430a98_100", + "build_number": 100, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5be1a1cc97573639d2e7d7a47f94351d", + "name": "h5py", + "sha256": "62fbb9386c7a104e74b3804ecf5a252070983696622a024ce51504f4071e69c9", + "size": 1355624, + "subdir": "linux-64", + "timestamp": 1636636858374, + "version": "3.5.0" + }, + "h5py-3.5.0-py39ha0f2276_0.tar.bz2": { + "build": "py39ha0f2276_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2b1fcb9cba2fe74a6aee765ea774489f", + "name": "h5py", + "sha256": "f76f70ffb0526adeabad9fa6d5d60fcdf435406575f30f5b731de1ac4904e78d", + "size": 1380736, + "subdir": "linux-64", + "timestamp": 1636991247778, + "version": "3.5.0" + }, + "h5py-3.5.0-py39hd430a98_100.tar.bz2": { + "build": "py39hd430a98_100", + "build_number": 100, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "044482024500939bb07e1f38835f9be7", + "name": "h5py", + "sha256": "a0c5a13f83a009031d5de8e20900aa01f57d9058ae020d123a3fe9c8a5308dc9", + "size": 1388891, + "subdir": "linux-64", + "timestamp": 1636624527741, + "version": "3.5.0" + }, + "h5py-3.6.0-py310h18f346e_0.tar.bz2": { + "build": "py310h18f346e_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6a67a483dc65c73e93ef222d0c2b2456", + "name": "h5py", + "sha256": "8a65fe074f1ef57a668e01566c54c702a6d6aa29cd720f2342e8c97630c5678a", + "size": 5239025, + "subdir": "linux-64", + "timestamp": 1640887474099, + "version": "3.6.0" + }, + "h5py-3.6.0-py37ha0f2276_0.tar.bz2": { + "build": "py37ha0f2276_0", + "build_number": 0, + "depends": [ + "cached-property", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3be5a3b0cce20beaf8e9e62bd4f62e7d", + "name": "h5py", + "sha256": "dfb0515e1daa19f035dd28db121e743c6fbda34fa626b289582c6f4b5007fdc8", + "size": 1326761, + "subdir": "linux-64", + "timestamp": 1637139039745, + "version": "3.6.0" + }, + "h5py-3.6.0-py38ha0f2276_0.tar.bz2": { + "build": "py38ha0f2276_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "60a2e462452013f2bccb51723abcb19c", + "name": "h5py", + "sha256": "e0fa97cbaab5cf258044b96e0ffaaaf3f8f986ed5eead457f78ac8c6ae2894c6", + "size": 1385212, + "subdir": "linux-64", + "timestamp": 1637139021142, + "version": "3.6.0" + }, + "h5py-3.6.0-py39ha0f2276_0.tar.bz2": { + "build": "py39ha0f2276_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b27642eec11c939a82db7e054a01c307", + "name": "h5py", + "sha256": "5da547c34ab9826451de18b4eefd28e30c9abc18847a0db3a30fa0d12a10b939", + "size": 1391873, + "subdir": "linux-64", + "timestamp": 1637138630244, + "version": "3.6.0" + }, + "h5py-3.7.0-py310he06866b_0.tar.bz2": { + "build": "py310he06866b_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e3cfd9b28f9dae103194806bc98cb4e6", + "name": "h5py", + "sha256": "9d8d7321094cd1c732a8e1329a4e12bd74af039c6bda880f2e2e41540c5da1ce", + "size": 5674109, + "subdir": "linux-64", + "timestamp": 1659092007638, + "version": "3.7.0" + }, + "h5py-3.7.0-py311h021c08c_0.tar.bz2": { + "build": "py311h021c08c_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "35579d8fca3f0ba86d79c799843b45f1", + "name": "h5py", + "sha256": "40237733b1d10f7c6559457271a723e6c88a1380726a2bdd8901736b3b749ec7", + "size": 1424175, + "subdir": "linux-64", + "timestamp": 1676904091959, + "version": "3.7.0" + }, + "h5py-3.7.0-py37h737f45e_0.tar.bz2": { + "build": "py37h737f45e_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a22c6d55beb539b265a733023f85bc39", + "name": "h5py", + "sha256": "7a7c2a673a426a9f150480b6c45f784969da408fe7e461291536d0a9c33379fd", + "size": 1352288, + "subdir": "linux-64", + "timestamp": 1659091536323, + "version": "3.7.0" + }, + "h5py-3.7.0-py38h737f45e_0.tar.bz2": { + "build": "py38h737f45e_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "29120092ca05cc9a0caea3c426f754bd", + "name": "h5py", + "sha256": "58d34a4c77cbd83dafe81bdd252a8504617272f6648e13762cc9d5b806603c61", + "size": 1395331, + "subdir": "linux-64", + "timestamp": 1659091830828, + "version": "3.7.0" + }, + "h5py-3.7.0-py39h737f45e_0.tar.bz2": { + "build": "py39h737f45e_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2e5495b6d4b8cefdb59db1648a99c0b5", + "name": "h5py", + "sha256": "d63990ddee46df61d8c9bc33b2d7102c8ea493288ab3284a0865280015ed33c0", + "size": 1373986, + "subdir": "linux-64", + "timestamp": 1659091680893, + "version": "3.7.0" + }, + "harfbuzz-1.5.0-h2545bd6_0.tar.bz2": { + "build": "h2545bd6_0", + "build_number": 0, + "depends": [ + "cairo 1.14.*", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "graphite2 1.3.*", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxcb" + ], + "license": "MIT", + "md5": "b4a43838365ad8fcd42defc9cb8f6401", + "name": "harfbuzz", + "sha256": "6495e29257bd9deaa41451dee7ba06e71b2ecab7c43cd02c0ca70a862e098cb0", + "size": 690227, + "subdir": "linux-64", + "timestamp": 1505744340721, + "version": "1.5.0" + }, + "harfbuzz-1.7.4-hc5b324e_0.tar.bz2": { + "build": "hc5b324e_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.10,<2.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "graphite2 >=1.3.10,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.12,<2.0a0" + ], + "license": "MIT", + "md5": "f940367f554c91326dbaacf92d5dc60c", + "name": "harfbuzz", + "sha256": "331044dd00030c3211a4993bebf887cf9772ad38beb12b69bfb6a65c16fb4268", + "size": 712106, + "subdir": "linux-64", + "timestamp": 1516743038041, + "version": "1.7.4" + }, + "harfbuzz-1.7.6-h5f0a787_1.tar.bz2": { + "build": "h5f0a787_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.10,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.13,<2.0a0" + ], + "license": "MIT", + "md5": "4b6982f0a0460dab9a92595cd8d9fd97", + "name": "harfbuzz", + "sha256": "90b15175bf09f4a58724cf61d4751a48c242ec09be4a0ce67b301e5b3b2069b5", + "size": 826792, + "subdir": "linux-64", + "timestamp": 1523672404228, + "version": "1.7.6" + }, + "harfbuzz-1.7.6-hc5b324e_0.tar.bz2": { + "build": "hc5b324e_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "graphite2 >=1.3.10,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.12,<2.0a0" + ], + "license": "MIT", + "md5": "2c18b61ca36f5fb5fbcffa5749576e45", + "name": "harfbuzz", + "sha256": "b52d9054d7256bda8ef7b9cb767a5937c00e5d76d46415ebdb8194e2717960b2", + "size": 874158, + "subdir": "linux-64", + "timestamp": 1522349021236, + "version": "1.7.6" + }, + "harfbuzz-1.7.6-hec2c2bc_3.tar.bz2": { + "build": "hec2c2bc_3", + "build_number": 3, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.11,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.13,<2.0a0" + ], + "license": "MIT", + "md5": "b549c65016a7c19aef6e6b94153c950e", + "name": "harfbuzz", + "sha256": "c6cf0dc31ed96f08577da42a3fbb7f6d0ab2a07f312f5d19e14b52852d58a199", + "size": 826637, + "subdir": "linux-64", + "timestamp": 1527258939186, + "version": "1.7.6" + }, + "harfbuzz-1.8.4-hec2c2bc_0.tar.bz2": { + "build": "hec2c2bc_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.11,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.13,<2.0a0" + ], + "license": "MIT", + "md5": "a99b68725b1180c07e3df3acf76c19eb", + "name": "harfbuzz", + "sha256": "eba46a5284b8c695e8aad6d5e764bc208560d856559765526ba6996c61469fb2", + "size": 831317, + "subdir": "linux-64", + "timestamp": 1532580168746, + "version": "1.8.4" + }, + "harfbuzz-1.8.8-hffaf4a1_0.tar.bz2": { + "build": "hffaf4a1_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.11,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxcb >=1.13,<2.0a0" + ], + "license": "MIT", + "md5": "6c9767371ac52ab0a524019b46bcb803", + "name": "harfbuzz", + "sha256": "aa42fcb100549461c1af1560290a434b7e652cfbc3100528987f83237d36f90f", + "size": 883307, + "subdir": "linux-64", + "timestamp": 1535414042498, + "version": "1.8.8" + }, + "harfbuzz-2.4.0-hca77d97_0.tar.bz2": { + "build": "hca77d97_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.63.1,<3.0a0", + "graphite2 >=1.3.13,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxcb >=1.13,<2.0a0" + ], + "license": "MIT", + "md5": "94af850c4efbdcfe6f46032540456bb7", + "name": "harfbuzz", + "sha256": "a67f877c4dc44694b99cde7eeea74bb9ead0a25cb40e64161ff5f145aa58460f", + "size": 1472418, + "subdir": "linux-64", + "timestamp": 1593115783327, + "version": "2.4.0" + }, + "harfbuzz-2.4.0-hca77d97_1.tar.bz2": { + "build": "hca77d97_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.65.0,<3.0a0", + "graphite2 >=1.3.14,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxcb >=1.13,<2.0a0" + ], + "license": "MIT", + "md5": "dd5d6fc625ba03578d1a13e379ce68a4", + "name": "harfbuzz", + "sha256": "f94af81c329990021eb1c52844a527c2642d04939e3cda91622f27cdc8a7d063", + "size": 1538093, + "subdir": "linux-64", + "timestamp": 1593435707459, + "version": "2.4.0" + }, + "harfbuzz-2.7.4-h6f93f22_0.tar.bz2": { + "build": "h6f93f22_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.67.4,<3.0a0", + "graphite2 >=1.3.14,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "a8eac1014356aefa9aa2ccd363a920a8", + "name": "harfbuzz", + "sha256": "e641477ff89e32a1ffbc5efb7ced6db5442592263e5e75f8f698b95bf55698e5", + "size": 1920075, + "subdir": "linux-64", + "timestamp": 1615344138620, + "version": "2.7.4" + }, + "harfbuzz-2.8.0-h6f93f22_0.tar.bz2": { + "build": "h6f93f22_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.67.4,<3.0a0", + "graphite2 >=1.3.14,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "acd966f06602750dd5d152fc0ee9e3d8", + "name": "harfbuzz", + "sha256": "f746d4562f6d927feca2a42313f3bc075d01d96b48024679598c8276ddf26ffd", + "size": 1948702, + "subdir": "linux-64", + "timestamp": 1615920026036, + "version": "2.8.0" + }, + "harfbuzz-2.8.1-h6f93f22_0.tar.bz2": { + "build": "h6f93f22_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.68.2,<3.0a0", + "graphite2 >=1.3.14,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d81aa1cab18ac6bd94a375023166f77e", + "name": "harfbuzz", + "sha256": "20442c9b0259b45638760ec8a21932186c0796c4f3734938eeefab070bffce9f", + "size": 2002511, + "subdir": "linux-64", + "timestamp": 1622035133941, + "version": "2.8.1" + }, + "harfbuzz-3.1.2-h6b1f951_0.tar.bz2": { + "build": "h6b1f951_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "graphite2 >=1.3.14,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f7d933b86023fa7facc980296f98b305", + "name": "harfbuzz", + "sha256": "da650330019a24b3d2776193daf2326d3531ac792ee5c73097a26dc0df98e8ea", + "size": 2183893, + "subdir": "linux-64", + "timestamp": 1638357221518, + "version": "3.1.2" + }, + "harfbuzz-4.3.0-hd55b92a_0.tar.bz2": { + "build": "hd55b92a_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "graphite2 >=1.3.14,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "efa6dfc4ba0cbd728210ff715448b0e4", + "name": "harfbuzz", + "sha256": "52107681dda994acf9694889c736f5630bd3495d95a18a64ebe162c631a2bbcd", + "size": 2046293, + "subdir": "linux-64", + "timestamp": 1656510744872, + "version": "4.3.0" + }, + "harfbuzz-4.3.0-hf52aaf7_1.tar.bz2": { + "build": "hf52aaf7_1", + "build_number": 1, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "graphite2 >=1.3.14,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dfe3ea41776c242225e4d32a99f3e85e", + "name": "harfbuzz", + "sha256": "44f27ea242f9518a0787fa1b6a4b8a17c99f5225c95547c7388a2f7a654d5f0e", + "size": 2052812, + "subdir": "linux-64", + "timestamp": 1678800467402, + "version": "4.3.0" + }, + "hatch-nodejs-version-0.3.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a7d328367df9842b6a5da401a64a9b2", + "name": "hatch-nodejs-version", + "sha256": "84042b38cef8d5e23ea31bcf1f94871549ecbd581dae105302822969c52b1674", + "size": 17860, + "subdir": "linux-64", + "timestamp": 1670275341857, + "version": "0.3.1" + }, + "hatch-nodejs-version-0.3.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "19e775ad663b978f820b47b6dbbfefdc", + "name": "hatch-nodejs-version", + "sha256": "874e972a80ec1a48f803bfe7c43896c3cb23aef5a803db30e41d33404c80c338", + "size": 21212, + "subdir": "linux-64", + "timestamp": 1676823346085, + "version": "0.3.1" + }, + "hatch-nodejs-version-0.3.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c0b6bad2663f285a9e8da1fcbcb6fc3", + "name": "hatch-nodejs-version", + "sha256": "3cb4c1ecdc01f0145a04b15bcd8b80c1705c5354294f56a705abd15bc1a23352", + "size": 17759, + "subdir": "linux-64", + "timestamp": 1670275312382, + "version": "0.3.1" + }, + "hatch-nodejs-version-0.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02fcb35e0372306e9d874e6f9533b078", + "name": "hatch-nodejs-version", + "sha256": "8a04fd3bdee5aebcee80614403c4b1092d5a2c5ee9c48c1cc9cd75cad33f362b", + "size": 17811, + "subdir": "linux-64", + "timestamp": 1670275399819, + "version": "0.3.1" + }, + "hatch-nodejs-version-0.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "733be803cf435f28d4a719e91b5ede28", + "name": "hatch-nodejs-version", + "sha256": "293c99f7c7d3f4b2291a460fb4c86c26ccd85c2dc45d34e2a7074205468cfcb2", + "size": 17850, + "subdir": "linux-64", + "timestamp": 1670275370764, + "version": "0.3.1" + }, + "hatch-requirements-txt-0.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "packaging >=21.3", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "384880a5d783dde43b9c3effef5e8c2c", + "name": "hatch-requirements-txt", + "sha256": "e82e225f6080c3f2c3aaa0fb6632f38633f4be718a26de8dc9e7d92bd86454d8", + "size": 11830, + "subdir": "linux-64", + "timestamp": 1676362030300, + "version": "0.3.0" + }, + "hatch-requirements-txt-0.3.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "packaging >=21.3", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f097f8f681fd939eded74b3fa7d45215", + "name": "hatch-requirements-txt", + "sha256": "7d47456fcbf22af6264347add480cc1dc5cb703ac844e708098f841afb928e38", + "size": 13623, + "subdir": "linux-64", + "timestamp": 1676844234743, + "version": "0.3.0" + }, + "hatch-requirements-txt-0.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "packaging >=21.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe1ac7940ddc77fabe22d8cc2adbf9e0", + "name": "hatch-requirements-txt", + "sha256": "b120963aa0c0ef737050c22cd9c11040eb139bc31fe235a9a3b38df4e950f554", + "size": 11813, + "subdir": "linux-64", + "timestamp": 1676362057912, + "version": "0.3.0" + }, + "hatch-requirements-txt-0.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "packaging >=21.3", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e6071af76fe219124e80fe0a8eb8af9", + "name": "hatch-requirements-txt", + "sha256": "9e4c87c324484143f94fba90f091cf03af98b0af9d2bddd823887b73167b64f3", + "size": 11771, + "subdir": "linux-64", + "timestamp": 1676362003448, + "version": "0.3.0" + }, + "hatch-requirements-txt-0.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "packaging >=21.3", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "20543eefb85afa1158aa5a5324f26110", + "name": "hatch-requirements-txt", + "sha256": "856f4a33ec26994a9809642015007fb09314cc176d7d2191c93fb77434a3f5c6", + "size": 11809, + "subdir": "linux-64", + "timestamp": 1676362084544, + "version": "0.3.0" + }, + "hatch-vcs-0.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.10,<3.11.0a0", + "setuptools-scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b1d4455f694d25cfe73b6ff065d0b33", + "name": "hatch-vcs", + "sha256": "f13e1ceb9a4a9d7e52028160a93f8967cfe4fd278b69086d1edeec8c9775b7b7", + "size": 11124, + "subdir": "linux-64", + "timestamp": 1661381063870, + "version": "0.2.0" + }, + "hatch-vcs-0.2.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.11,<3.12.0a0", + "setuptools-scm" + ], + "license": "MIT", + "md5": "947ea918d787047d2c6f039a52f06f4b", + "name": "hatch-vcs", + "sha256": "dc657b21b28aef67dd163843fafb74353725277bce4c73221c6566d694e03a1b", + "size": 12657, + "subdir": "linux-64", + "timestamp": 1676822977375, + "version": "0.2.0" + }, + "hatch-vcs-0.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.7,<3.8.0a0", + "setuptools-scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "88d2c389715f1846c2390b628acd17ce", + "name": "hatch-vcs", + "sha256": "a41318694de9591d48ee661d00daa33e06b8ccf18464946442779af3373f1277", + "size": 11096, + "subdir": "linux-64", + "timestamp": 1661381124999, + "version": "0.2.0" + }, + "hatch-vcs-0.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.8,<3.9.0a0", + "setuptools-scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "934b082b953218df9986c9105ebfd444", + "name": "hatch-vcs", + "sha256": "906a4823a1cb3909a62369f740d91aaee8fb1083c56941830fa778216d998529", + "size": 11058, + "subdir": "linux-64", + "timestamp": 1661381019253, + "version": "0.2.0" + }, + "hatch-vcs-0.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.9,<3.10.0a0", + "setuptools-scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4063ff616018a7647e306e59b0dd4237", + "name": "hatch-vcs", + "sha256": "e3909b2ef06deb6b4fd38c40277f44079ef9d269da3af5ff031887d5e391dae0", + "size": 11066, + "subdir": "linux-64", + "timestamp": 1661381095239, + "version": "0.2.0" + }, + "hatchling-1.12.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "packaging >=21.3", + "pathspec >=0.10.1", + "pluggy >=1.0.0", + "python >=3.10,<3.11.0a0", + "tomli >=1.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "99b8a953fbbb3062e875d9518e638547", + "name": "hatchling", + "sha256": "a73785b3f3aafd06a0c8a8865d8f6e62803d1cc39d00736703006a87014e8a40", + "size": 126708, + "subdir": "linux-64", + "timestamp": 1674690467906, + "version": "1.12.2" + }, + "hatchling-1.12.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "packaging >=21.3", + "pathspec >=0.10.1", + "pluggy >=1.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1d22d47f93c9edb7ec22d0f58bb6cbf", + "name": "hatchling", + "sha256": "bbf5ba116bd1a31db670e084d1c5a4fbad4968de8f953d3a6d8a1885cab28006", + "size": 163520, + "subdir": "linux-64", + "timestamp": 1679516954850, + "version": "1.12.2" + }, + "hatchling-1.12.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "importlib-metadata", + "packaging >=21.3", + "pathspec >=0.10.1", + "pluggy >=1.0.0", + "python >=3.7,<3.8.0a0", + "tomli >=1.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7610f8b3107a8a7a4a9cc4f58d639d5", + "name": "hatchling", + "sha256": "70296d3879cf5a326aaf355bcb84a0c483c0955a8d050ecda248a7030ac146f8", + "size": 123082, + "subdir": "linux-64", + "timestamp": 1674690496283, + "version": "1.12.2" + }, + "hatchling-1.12.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "packaging >=21.3", + "pathspec >=0.10.1", + "pluggy >=1.0.0", + "python >=3.8,<3.9.0a0", + "tomli >=1.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eec8be45e5691d04f28b30d75d8877fa", + "name": "hatchling", + "sha256": "d3ff21879939ff9915f15571ddf8e02fac4250b8ef843cad0875433963d9157b", + "size": 122927, + "subdir": "linux-64", + "timestamp": 1674690523415, + "version": "1.12.2" + }, + "hatchling-1.12.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "packaging >=21.3", + "pathspec >=0.10.1", + "pluggy >=1.0.0", + "python >=3.9,<3.10.0a0", + "tomli >=1.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da6eded132f8c77b35cd0f042f607756", + "name": "hatchling", + "sha256": "98687a42ddf647e12b8ee791c5e12ba936895064206d9758c1060fb6af0a77cd", + "size": 121662, + "subdir": "linux-64", + "timestamp": 1674690440549, + "version": "1.12.2" + }, + "hatchling-1.8.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "packaging >=21.3", + "pathspec >=0.9", + "pluggy >=1.0.0", + "python >=3.10,<3.11.0a0", + "tomli >=1.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f1d02cfa28274b518067625b9861788", + "name": "hatchling", + "sha256": "9540c68a60b9b0b782fba0ccf02d797333c7af368203db61d9811d3d3be8c479", + "size": 113764, + "subdir": "linux-64", + "timestamp": 1661204335007, + "version": "1.8.0" + }, + "hatchling-1.8.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "packaging >=21.3", + "pathspec >=0.9", + "pluggy >=1.0.0", + "python >=3.11,<3.12.0a0", + "tomli >=1.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d8d8ffd1df926942ffbbe83bdd350b4", + "name": "hatchling", + "sha256": "0abecea3e1ace575e819045a9259bc14537355cb8979bdce3422640de7e47716", + "size": 148945, + "subdir": "linux-64", + "timestamp": 1676822861141, + "version": "1.8.0" + }, + "hatchling-1.8.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "importlib-metadata", + "packaging >=21.3", + "pathspec >=0.9", + "pluggy >=1.0.0", + "python >=3.7,<3.8.0a0", + "tomli >=1.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8176b9afc1532bd5934231e2d1a43182", + "name": "hatchling", + "sha256": "cc8c5fc57b35bdb0034bea704ddd1c534b1c53a46e936384cd4d7c947a942ccd", + "size": 110804, + "subdir": "linux-64", + "timestamp": 1661204288811, + "version": "1.8.0" + }, + "hatchling-1.8.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "packaging >=21.3", + "pathspec >=0.9", + "pluggy >=1.0.0", + "python >=3.8,<3.9.0a0", + "tomli >=1.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2fe4d9576849f4087032ab5574455955", + "name": "hatchling", + "sha256": "96a88a0b4e5f0eeaa842f130aaf19a7642a6eac2160cbadaf60bba1fdeb602ce", + "size": 110876, + "subdir": "linux-64", + "timestamp": 1661204363698, + "version": "1.8.0" + }, + "hatchling-1.8.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "packaging >=21.3", + "pathspec >=0.9", + "pluggy >=1.0.0", + "python >=3.9,<3.10.0a0", + "tomli >=1.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "42fb93247bd923bfce384d81d2095719", + "name": "hatchling", + "sha256": "a207bcd2137f9728a43fa6501875f40ea8f341f7e088577c9c7afd04fd93a32e", + "size": 109454, + "subdir": "linux-64", + "timestamp": 1661204258862, + "version": "1.8.0" + }, + "hdf4-4.2.13-h1976432_1.tar.bz2": { + "build": "h1976432_1", + "build_number": 1, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "de7e9798cabe55920b4274a7c066df55", + "name": "hdf4", + "sha256": "5f73ec5029cd433c0259fbfa828bb065d6f5c2e5d0c824cd202f82f0d851d78c", + "size": 937609, + "subdir": "linux-64", + "timestamp": 1509502810225, + "version": "4.2.13" + }, + "hdf4-4.2.13-h3ca952b_2.tar.bz2": { + "build": "h3ca952b_2", + "build_number": 2, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "35da658876a3e2a62dda54dcd5a7e5c2", + "name": "hdf4", + "sha256": "70e1f9fdc6b123d8270bcd8cdd555519372924d39419ef8692b36bfa9d0b4653", + "size": 937548, + "subdir": "linux-64", + "timestamp": 1510862959026, + "version": "4.2.13" + }, + "hdf5-1.10.1-h9caa474_1.tar.bz2": { + "build": "h9caa474_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "d1050f9828f36625e4fd8ab1d49f5537", + "name": "hdf5", + "sha256": "bb1549578acb64ca712846fd553ae2c052fa2d4761bbc05196e9eef625a4b313", + "size": 5562803, + "subdir": "linux-64", + "timestamp": 1510864218176, + "version": "1.10.1" + }, + "hdf5-1.10.1-hb0523eb_0.tar.bz2": { + "build": "hb0523eb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "ae24072b6d05b79e6a9c6d7b77ff0a87", + "name": "hdf5", + "sha256": "c3e21fa6c495c0f70270cfbc217b37489473caab99a56204b7d2456dd664730d", + "size": 5561972, + "subdir": "linux-64", + "timestamp": 1505730098014, + "version": "1.10.1" + }, + "hdf5-1.10.2-hba1933b_1.tar.bz2": { + "build": "hba1933b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "eb87b8b556b5e3f9a035c1cd2291a6cc", + "name": "hdf5", + "sha256": "8f7d5c90993e7c5d798c1bb03020a6e8ed346c16f5db08666d50821d7969275a", + "size": 5453991, + "subdir": "linux-64", + "timestamp": 1525909482253, + "version": "1.10.2" + }, + "hdf5-1.10.4-hb1b8bf9_0.tar.bz2": { + "build": "hb1b8bf9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "e25e1d2af9836593f3678198b14816eb", + "name": "hdf5", + "sha256": "077c4723b58063f827bd5702228efdba2c5f8bd4a0f6bf76ec5f81e582897988", + "size": 5535051, + "subdir": "linux-64", + "timestamp": 1545245222343, + "version": "1.10.4" + }, + "hdf5-1.10.6-h3ffc7dd_1.tar.bz2": { + "build": "h3ffc7dd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "917a48c56de42126687bf7a952252a8f", + "name": "hdf5", + "sha256": "9f7e32b82bfccd48f0ddcc8871a9f7c5e334e509d5700564a2339751846039ac", + "size": 5085715, + "subdir": "linux-64", + "timestamp": 1655307962864, + "version": "1.10.6" + }, + "hdf5-1.10.6-hb1b8bf9_0.tar.bz2": { + "build": "hb1b8bf9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "c2a4fff8bb9066058971622f9b2b3e00", + "name": "hdf5", + "sha256": "ab8cb89a9c1e8341785c53c7aff84ed2e5ad42efe6897b54e0b2bf5712a77057", + "size": 5077151, + "subdir": "linux-64", + "timestamp": 1593121597858, + "version": "1.10.6" + }, + "hdf5-1.10.7-hb1b8bf9_0.tar.bz2": { + "build": "hb1b8bf9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "5c2992553653270fb9c1cf2c5a533bc3", + "name": "hdf5", + "sha256": "4939c2d9bb4c0956f39646fdb24325927efaea8a535696e12525d0dd9558a06f", + "size": 5199933, + "subdir": "linux-64", + "timestamp": 1600361203389, + "version": "1.10.7" + }, + "hdf5-1.12.0-hc3cf35f_0.tar.bz2": { + "build": "hc3cf35f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "4d6427799e77f67d12997ec4a5c62f80", + "name": "hdf5", + "sha256": "1681beaec0bcbd0025731735902744ef4db6a3084d9d325d814ec9758a2da31c", + "size": 5519242, + "subdir": "linux-64", + "timestamp": 1611516031048, + "version": "1.12.0" + }, + "hdf5-1.12.1-h69dfa17_1.tar.bz2": { + "build": "h69dfa17_1", + "build_number": 1, + "depends": [ + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "d76d6310c76de337fbe2ac4f994eeadc", + "name": "hdf5", + "sha256": "b45e401b805f6bdba4e6854d9741605a18f7e185a69f0a1aff54884c1f263104", + "size": 5732636, + "subdir": "linux-64", + "timestamp": 1636040445739, + "version": "1.12.1" + }, + "hdf5-1.12.1-h70be1eb_2.tar.bz2": { + "build": "h70be1eb_2", + "build_number": 2, + "depends": [ + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1o,<1.1.2a", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "9249c8c2d04f5bb91f1dffcb00be691a", + "name": "hdf5", + "sha256": "30a88eb6e50bb2201d06734f74d3f98624f3b7ff1371607f770bb71d5dd86c61", + "size": 5763149, + "subdir": "linux-64", + "timestamp": 1655307949265, + "version": "1.12.1" + }, + "hdf5-1.8.18-h525d4c3_0.tar.bz2": { + "build": "h525d4c3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "zlib 1.2.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "e2a89e65bc08dd5b4efce505f9d99382", + "name": "hdf5", + "sha256": "d73c3228ccab99d844a8d1ea5251376d1e91def5bb62eb4395d571147a11a4c3", + "size": 4436209, + "subdir": "linux-64", + "timestamp": 1505729146643, + "version": "1.8.18" + }, + "hdf5-1.8.18-h6792536_1.tar.bz2": { + "build": "h6792536_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "e1777f7e576b39d342061a1c8d712832", + "name": "hdf5", + "sha256": "4f635f8baf7aa62f86aeb7afc2b92a868cadfd9abbd60459268bcd93081228a0", + "size": 4438102, + "subdir": "linux-64", + "timestamp": 1510863817753, + "version": "1.8.18" + }, + "hdf5-1.8.20-hba1933b_1.tar.bz2": { + "build": "hba1933b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "a024dc9ab0465d38e9607287ad710de1", + "name": "hdf5", + "sha256": "4105bdfdef72f0f5764aa798860a2e2f162d5a8ffdeba282a4758a493e01b8c2", + "size": 4450710, + "subdir": "linux-64", + "timestamp": 1530868368461, + "version": "1.8.20" + }, + "hdfeos2-2.19.1-h25c61e6_9.tar.bz2": { + "build": "h25c61e6_9", + "build_number": 9, + "depends": [ + "hdf4 >=4.2.13,<4.2.14.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public Domain", + "md5": "b80d731797087b6704882b2844accf81", + "name": "hdfeos2", + "sha256": "7140bc74b2f79cacdd5b4c64e7d00a590f77db9fed8635d5305a19a3c771c1ff", + "size": 250437, + "subdir": "linux-64", + "timestamp": 1512104007886, + "version": "2.19.1" + }, + "hdfeos2-2.20-h64bfcee_0.tar.bz2": { + "build": "h64bfcee_0", + "build_number": 0, + "depends": [ + "hdf4 >=4.2.13,<4.2.14.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public Domain", + "md5": "267f5bc41e8e9b16577145b113b008dc", + "name": "hdfeos2", + "sha256": "b0277f54177f5469072eaff10dc3bb945e9c7e17db42fd8c9ef4dd53d01c598b", + "size": 252183, + "subdir": "linux-64", + "timestamp": 1531092706071, + "version": "2.20" + }, + "hdfs3-0.1.4-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "libhdfs3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9b3747723a903a5937c542f74b599874", + "name": "hdfs3", + "sha256": "f8c3d1f527e6cfd1d84bb4721f4216690bfc8b6e7a4fcf6da721b86eec4b34c1", + "size": 30975, + "subdir": "linux-64", + "timestamp": 1515697222212, + "version": "0.1.4" + }, + "hdfs3-0.1.4-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "libhdfs3", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "aee848e0f36365cfb43cc83e2be671a8", + "name": "hdfs3", + "sha256": "4cf9505e0b62bf926553b009adbab0478d61a884b295a8b1bb5598afd98f39d1", + "size": 31580, + "subdir": "linux-64", + "timestamp": 1515697246799, + "version": "0.1.4" + }, + "hdfs3-0.1.4-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "libhdfs3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "aca5916eb19fa5f46658873aae2d7f7b", + "name": "hdfs3", + "sha256": "1263f1ac739202275d852e8c9ccaa7e715d9b4aa671378d295bdfe3cea052b86", + "size": 31567, + "subdir": "linux-64", + "timestamp": 1515697215173, + "version": "0.1.4" + }, + "hdfs3-0.3.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "libhdfs3 >=2.3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "14ea7f50df5422dd9e56d393f6e72a55", + "name": "hdfs3", + "sha256": "3445366e47ffd525d86ab2681819ba1646a033a53d2cc5ac20fee7543ca1c19f", + "size": 38917, + "subdir": "linux-64", + "timestamp": 1515710225106, + "version": "0.3.0" + }, + "hdfs3-0.3.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "896afded92dcd4ffaf8bf94c45bbd39f", + "name": "hdfs3", + "sha256": "d9e6dad4053710078b9d4056db09cced72a0120f43df70c5ef88c4d34c00f460", + "size": 39962, + "subdir": "linux-64", + "timestamp": 1515710239218, + "version": "0.3.0" + }, + "hdfs3-0.3.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "eae5d29a30f9761463ddef2e30fb5de8", + "name": "hdfs3", + "sha256": "ec8edc62f6107d97bf104ecea0babbbc51c1560fa49e4545100fb35ac9eeff92", + "size": 39873, + "subdir": "linux-64", + "timestamp": 1515710207534, + "version": "0.3.0" + }, + "hdfs3-0.3.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f0986c29b712cc0a321bd9fd9859e0a4", + "name": "hdfs3", + "sha256": "c15818f58e4b42d31b48e4da9ad56c8614b4b8af23295413d94b1b26b4c67387", + "size": 39743, + "subdir": "linux-64", + "timestamp": 1530892808972, + "version": "0.3.0" + }, + "hdfs3-0.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "libhdfs3 >=2.3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f2d082b24cd620e66cc271269c0cdf2c", + "name": "hdfs3", + "sha256": "75d93a61623d3b71724b59368653e91647295000de76778fc63a2534ecacefd0", + "size": 42682, + "subdir": "linux-64", + "timestamp": 1569343261553, + "version": "0.3.1" + }, + "hdfs3-0.3.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "39672b9d7a9bd6ff0a8c6ef7b27ca7dd", + "name": "hdfs3", + "sha256": "b0548015bd9689b322506e91141f13cd3be4d1094801f003f244020a4e8c93e5", + "size": 41329, + "subdir": "linux-64", + "timestamp": 1640790832421, + "version": "0.3.1" + }, + "hdfs3-0.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fa6ab43de98f1fb10f4f280a97e22c9c", + "name": "hdfs3", + "sha256": "76e97a4ec3b17a983b14d352e1fb7467d7f253d9b71368d7a3824045726c4a24", + "size": 43453, + "subdir": "linux-64", + "timestamp": 1569343298181, + "version": "0.3.1" + }, + "hdfs3-0.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "749e54c35f49888707f13a65cacedcbe", + "name": "hdfs3", + "sha256": "5073ee9e0da50795968c5b43d2c3c05d0b57a7b126f8201c8310e2b5ad338b50", + "size": 43447, + "subdir": "linux-64", + "timestamp": 1569343263785, + "version": "0.3.1" + }, + "hdfs3-0.3.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6c42b13dcd0508917f7a4fe972cd5f54", + "name": "hdfs3", + "sha256": "814c75f2a37b3e608f1a1a68af9aa494639aa53d94883d8b261f27e08f85eb16", + "size": 40842, + "subdir": "linux-64", + "timestamp": 1641828211910, + "version": "0.3.1" + }, + "hdfs3-0.3.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0acc9d83933cd420a791d1762cdbe655", + "name": "hdfs3", + "sha256": "97515b9243aa71bb9b070b9686871af1b9010557c148d0804376d4668bbe9150", + "size": 41257, + "subdir": "linux-64", + "timestamp": 1572621616875, + "version": "0.3.1" + }, + "hdfs3-0.3.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4ce9d9fdd2d34f3520e948c7d1f9008b", + "name": "hdfs3", + "sha256": "4cae044b3565ed5aa85e434a121d0c4d54e96c358ab424fa870e94da48c3b43c", + "size": 40965, + "subdir": "linux-64", + "timestamp": 1641828270275, + "version": "0.3.1" + }, + "hdfs3-0.3.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c245afc98b7716573c847545c153b16c", + "name": "hdfs3", + "sha256": "90683e22c52d1aed7a7d5cfa519b6623d3814fa4520f5d718e8a81bf81d58aed", + "size": 41069, + "subdir": "linux-64", + "timestamp": 1641828244747, + "version": "0.3.1" + }, + "hdijupyterutils-0.12.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "05d81f379f818bbdc81d6b052f7bf99c", + "name": "hdijupyterutils", + "sha256": "d5fd017dfcb89de651974860e13c9298e8d1e4df7e1ee9bf257fee9beb9192c3", + "size": 12351, + "subdir": "linux-64", + "timestamp": 1530738696020, + "version": "0.12.5" + }, + "hdijupyterutils-0.12.5-py27hcc60360_0.tar.bz2": { + "build": "py27hcc60360_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "937dddc9802000e3c0f45deed8c895c0", + "name": "hdijupyterutils", + "sha256": "67768d4115c3c0c1aff6bc0a9e8a2c9acabd83829548b192d655b05f3d09287d", + "size": 12609, + "subdir": "linux-64", + "timestamp": 1511835492832, + "version": "0.12.5" + }, + "hdijupyterutils-0.12.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8d981b4e21b508dde1f5f106df0ee709", + "name": "hdijupyterutils", + "sha256": "0236a5c9154e6a6199cd6ebe3c932b92336d650fa884b9cb548e91c97ecdb178", + "size": 12730, + "subdir": "linux-64", + "timestamp": 1534355171942, + "version": "0.12.5" + }, + "hdijupyterutils-0.12.5-py35h8a67a8b_0.tar.bz2": { + "build": "py35h8a67a8b_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "39dc10ea29162d191c67db96a7bb20f8", + "name": "hdijupyterutils", + "sha256": "33ed3a731ceff3202c5ca94c40a2c11b4ea9b14071b0d6a4bf7fed7a68854164", + "size": 13076, + "subdir": "linux-64", + "timestamp": 1511835504913, + "version": "0.12.5" + }, + "hdijupyterutils-0.12.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b040861b1d35687941deeaf4a7befb01", + "name": "hdijupyterutils", + "sha256": "3430f9b5ba8615a5987a495a030f2edbac6295fd099f26d4ce143688e81c401f", + "size": 12751, + "subdir": "linux-64", + "timestamp": 1530738667179, + "version": "0.12.5" + }, + "hdijupyterutils-0.12.5-py36hc0bb8fd_0.tar.bz2": { + "build": "py36hc0bb8fd_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6490dcf62e0be310c777e1435a92426d", + "name": "hdijupyterutils", + "sha256": "48a9b96e8854c74be7c0312b99d86eb53db656645b98bab0748e2df66851474d", + "size": 13059, + "subdir": "linux-64", + "timestamp": 1511835504913, + "version": "0.12.5" + }, + "hdijupyterutils-0.12.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ca5d688f83a2008bee72dd856a280196", + "name": "hdijupyterutils", + "sha256": "228d6688448d7ab65d0a83f6736800cf7fe84614d192642b4a6d317826411228", + "size": 12763, + "subdir": "linux-64", + "timestamp": 1530738726665, + "version": "0.12.5" + }, + "hdijupyterutils-0.12.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "243ecc8b6d686828f5502fd83e434b4a", + "name": "hdijupyterutils", + "sha256": "45709dde06a1faddd9c78ac6b640a018b547bee10ad6e5c1598990fe694fea90", + "size": 14094, + "subdir": "linux-64", + "timestamp": 1539725818145, + "version": "0.12.6" + }, + "hdijupyterutils-0.12.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "6fb247fed82e1d7698913a8f9adab3ee", + "name": "hdijupyterutils", + "sha256": "beefaaf7ab5970d0e7b0573ac43368e4e96a760a99afc09249560ab4fa7495a4", + "size": 14535, + "subdir": "linux-64", + "timestamp": 1539725840122, + "version": "0.12.6" + }, + "hdijupyterutils-0.12.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "60c627111fc70444d10ebdef99bd0f4c", + "name": "hdijupyterutils", + "sha256": "cddeaa7f743421b02a523e321b19532638c5fc52e2dcb752b0a7e30e666fd280", + "size": 14533, + "subdir": "linux-64", + "timestamp": 1539725840081, + "version": "0.12.6" + }, + "hdijupyterutils-0.20.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "jupyter >=1", + "mock", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cc6f3d4ac86f260a0c0bc17b3d00bab1", + "name": "hdijupyterutils", + "sha256": "0a5b5ee012641976f53380f33c244cdadf961056daffaeb6cdb39720c09b3e61", + "size": 15331, + "subdir": "linux-64", + "timestamp": 1663054046392, + "version": "0.20.0" + }, + "hdijupyterutils-0.20.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "jupyter >=1", + "mock", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "658e158c75dd50d3a81ebb77e7563c7b", + "name": "hdijupyterutils", + "sha256": "687b9d12812071892b59a701bf62ea3e1297666eae4164e5bfcfe259495bd1d6", + "size": 18489, + "subdir": "linux-64", + "timestamp": 1676839957770, + "version": "0.20.0" + }, + "hdijupyterutils-0.20.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "jupyter >=1", + "mock", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8b45f83cf15ca9e78c5d4245ab2e6268", + "name": "hdijupyterutils", + "sha256": "1e46e51561fb2592862aea428a7197a5cf7a634e62ae904f99027ce24898b146", + "size": 15118, + "subdir": "linux-64", + "timestamp": 1663053879113, + "version": "0.20.0" + }, + "hdijupyterutils-0.20.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "jupyter >=1", + "mock", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a26295308c14ccdf719a0e0df2a8536f", + "name": "hdijupyterutils", + "sha256": "6f49158f3037d4e5711cb965d915636b4774ef0494f9847669f4f94af932160e", + "size": 15232, + "subdir": "linux-64", + "timestamp": 1663053938574, + "version": "0.20.0" + }, + "hdijupyterutils-0.20.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "jupyter >=1", + "mock", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "98bb016745003feac36ee17cf30171be", + "name": "hdijupyterutils", + "sha256": "0e867dbc88b7dd3e0d33a90105668b8885c7221aa96483b6d0a932bf77799c17", + "size": 15260, + "subdir": "linux-64", + "timestamp": 1663053986978, + "version": "0.20.0" + }, + "hdmedians-0.13-py27h035aef0_0.tar.bz2": { + "build": "py27h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "ec8beeb0aedc7860eadb59a18880caad", + "name": "hdmedians", + "sha256": "3d0d9b199576bfa4892584cd2f4ae997fde5044d061d00241fb75be982c888ad", + "size": 164378, + "subdir": "linux-64", + "timestamp": 1534604115351, + "version": "0.13" + }, + "hdmedians-0.13-py27hdd07704_1000.tar.bz2": { + "build": "py27hdd07704_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "fe570d233590e31dc57284e798715df5", + "name": "hdmedians", + "sha256": "74dcb8b1de226fffe9e3a6457a4dfddc0f682e049f6891bcd9ff029cdeb940ed", + "size": 162897, + "subdir": "linux-64", + "timestamp": 1565188723674, + "version": "0.13" + }, + "hdmedians-0.13-py35h035aef0_0.tar.bz2": { + "build": "py35h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "355584ac70153c4d39030b51eb43ab55", + "name": "hdmedians", + "sha256": "e783584993c4b57f46c03b6d0edf1d9a987eccfd56952bc9587ad558d0211850", + "size": 157908, + "subdir": "linux-64", + "timestamp": 1534604668581, + "version": "0.13" + }, + "hdmedians-0.13-py36h035aef0_0.tar.bz2": { + "build": "py36h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "ae1924db8f3cdf6b2ef6d0b9823001e4", + "name": "hdmedians", + "sha256": "5df1544fdd704d564f230526f9ae026e8aa9a851a474545fa03ca80ded10be64", + "size": 159677, + "subdir": "linux-64", + "timestamp": 1534604542100, + "version": "0.13" + }, + "hdmedians-0.13-py36hdd07704_1000.tar.bz2": { + "build": "py36hdd07704_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "d6808068db7c089704720f4e9c590cfd", + "name": "hdmedians", + "sha256": "7244e20ed32a7b9d0aa55a775561c99739cb845ead40b13af26ae4991ada0025", + "size": 162596, + "subdir": "linux-64", + "timestamp": 1565190174871, + "version": "0.13" + }, + "hdmedians-0.13-py36heb32a55_1001.tar.bz2": { + "build": "py36heb32a55_1001", + "build_number": 1001, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "278f4daa70ccafea54ee1f378b504f38", + "name": "hdmedians", + "sha256": "57b3fdf2c49c548fa17765793c90d6975ba1f939eed99b918529e553616d4e4e", + "size": 163719, + "subdir": "linux-64", + "timestamp": 1584958700900, + "version": "0.13" + }, + "hdmedians-0.13-py37h035aef0_0.tar.bz2": { + "build": "py37h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "f6da62f50e3c119376053dbcf72f76c2", + "name": "hdmedians", + "sha256": "d8c38a106bdf3f30d58c429e3b0a9ca773c53a9833fdf0ce4d4dbc346c18678e", + "size": 160125, + "subdir": "linux-64", + "timestamp": 1534604666124, + "version": "0.13" + }, + "hdmedians-0.13-py37h035aef0_1002.tar.bz2": { + "build": "py37h035aef0_1002", + "build_number": 1002, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "307b5187fadef22ca6477e69bd434b5a", + "name": "hdmedians", + "sha256": "8e39f170b9d2c64a5ccb99f711d5a94c38b0e26af4e743305efcc39532a9589d", + "size": 143004, + "subdir": "linux-64", + "timestamp": 1594358873687, + "version": "0.13" + }, + "hdmedians-0.13-py37hdd07704_1000.tar.bz2": { + "build": "py37hdd07704_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "6901916413aae2dd91ea737aa8ee0228", + "name": "hdmedians", + "sha256": "e7f12d16506e98a44224c246b48c28ff4554a221a97ec6ed86ac57856bbd6659", + "size": 162238, + "subdir": "linux-64", + "timestamp": 1565188704577, + "version": "0.13" + }, + "hdmedians-0.13-py37heb32a55_1001.tar.bz2": { + "build": "py37heb32a55_1001", + "build_number": 1001, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "3d15a958e6e448dd80fa9e4e3504d594", + "name": "hdmedians", + "sha256": "f0c0078adc59dc29846f423d7bc9133ba97baf8a8e3b5fb47fef6b0bc7d6c33e", + "size": 163531, + "subdir": "linux-64", + "timestamp": 1584958639182, + "version": "0.13" + }, + "hdmedians-0.13-py38hdd07704_1000.tar.bz2": { + "build": "py38hdd07704_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "8df3bebc7abce37315b4da0a9ffb9d38", + "name": "hdmedians", + "sha256": "ff806b873a3680b00bb3507471266e9b2e3aef3e4557f5ff0045a8fe7a4e1a29", + "size": 169451, + "subdir": "linux-64", + "timestamp": 1573469574547, + "version": "0.13" + }, + "hdmedians-0.13-py38heb32a55_1001.tar.bz2": { + "build": "py38heb32a55_1001", + "build_number": 1001, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "9966e085ed7a09429c72456730c1a3f5", + "name": "hdmedians", + "sha256": "d588fcbe079004ff8c0885a96ea35bd6ba0124a756d4315ffd6103eb6d8b33d8", + "size": 171228, + "subdir": "linux-64", + "timestamp": 1584958722594, + "version": "0.13" + }, + "hdmedians-0.14.1-py36hdd07704_0.tar.bz2": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c49046e8e8ecc401ec2fa20bf5d020a4", + "name": "hdmedians", + "sha256": "e3ca99656185f08cb201afe7ac7c786ea9d93984ba81c634c97c930f6e941b64", + "size": 140656, + "subdir": "linux-64", + "timestamp": 1601310916710, + "version": "0.14.1" + }, + "hdmedians-0.14.1-py37hdd07704_0.tar.bz2": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cd0c246b4aaa7380089189923f6fbae1", + "name": "hdmedians", + "sha256": "595c76116d2db1e3bb60a23d647a196df16d390c736a4ff5017d486d8742b9ef", + "size": 139709, + "subdir": "linux-64", + "timestamp": 1601310925966, + "version": "0.14.1" + }, + "hdmedians-0.14.1-py38hdd07704_0.tar.bz2": { + "build": "py38hdd07704_0", + "build_number": 0, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5f0e36c5d4d9da49e0dbe506cdf58cae", + "name": "hdmedians", + "sha256": "89e18850ad3a215880fbcad9262140184901927b45b675f6ad6046c76656d910", + "size": 146098, + "subdir": "linux-64", + "timestamp": 1601310892725, + "version": "0.14.1" + }, + "hdmedians-0.14.1-py39h6323ea4_0.tar.bz2": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "98e0072fcd6e1d1923a13a198f9d9860", + "name": "hdmedians", + "sha256": "54d1d4cd90b65a82d0dd6f3c19a6667f8b4b200ab5a8afd40800d737a84f9c46", + "size": 148130, + "subdir": "linux-64", + "timestamp": 1614414140355, + "version": "0.14.1" + }, + "hdmedians-0.14.2-py310h9102076_1.tar.bz2": { + "build": "py310h9102076_1", + "build_number": 1, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "59568235844a8670ffd87c1a7b856de2", + "name": "hdmedians", + "sha256": "c0807d6a4d289f5679f60e6a24669c7612d3204ead8c4097a1f1d1592cf1332d", + "size": 532565, + "subdir": "linux-64", + "timestamp": 1640790867004, + "version": "0.14.2" + }, + "hdmedians-0.14.2-py310ha9d4c09_2.tar.bz2": { + "build": "py310ha9d4c09_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "20121949c9bb396d9d4ba686f170761b", + "name": "hdmedians", + "sha256": "bc383cb27d206df0a1efb7a3ab72e4eb38aaed732417ca30c54055354f6095d9", + "size": 147957, + "subdir": "linux-64", + "timestamp": 1676301103162, + "version": "0.14.2" + }, + "hdmedians-0.14.2-py311hbed6279_2.tar.bz2": { + "build": "py311hbed6279_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "89bf52399dac0b5a92267473806bca34", + "name": "hdmedians", + "sha256": "fbfc4e6b5bfcb47811b0693f7296bf26fba8d90125e6d51283c8db6148afa165", + "size": 150648, + "subdir": "linux-64", + "timestamp": 1676844261477, + "version": "0.14.2" + }, + "hdmedians-0.14.2-py36h6323ea4_1.tar.bz2": { + "build": "py36h6323ea4_1", + "build_number": 1, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b791c854d3976c0d10f6e6eb94877d72", + "name": "hdmedians", + "sha256": "bb3ff4d6816f5d7d9a13c5bf87036f6cb3e2b8321e6e022e5e2bfcd523ecbbe3", + "size": 140907, + "subdir": "linux-64", + "timestamp": 1614616181251, + "version": "0.14.2" + }, + "hdmedians-0.14.2-py37h6323ea4_1.tar.bz2": { + "build": "py37h6323ea4_1", + "build_number": 1, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0220a00918168f66bbb02a1bdb74218c", + "name": "hdmedians", + "sha256": "1158b589566c5bd036187b0c5ae914e06eab06dde04143d1a10db2152b5af509", + "size": 139462, + "subdir": "linux-64", + "timestamp": 1614615401126, + "version": "0.14.2" + }, + "hdmedians-0.14.2-py37h7deecbd_2.tar.bz2": { + "build": "py37h7deecbd_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c6a9196f88db95fb2f8c6a70fef1de33", + "name": "hdmedians", + "sha256": "70125daf94b8697e5ff5c9f3d3881b35da1800eb93c15af521179d144e5f3559", + "size": 150907, + "subdir": "linux-64", + "timestamp": 1676301243460, + "version": "0.14.2" + }, + "hdmedians-0.14.2-py38h6323ea4_1.tar.bz2": { + "build": "py38h6323ea4_1", + "build_number": 1, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3e184a19f0db1431b2557a439ab448f8", + "name": "hdmedians", + "sha256": "fe10fd6b77e26d533ceeae3e7c9ec2b80ec2116d32ed81ca0e33adc5d57af912", + "size": 146935, + "subdir": "linux-64", + "timestamp": 1614616179847, + "version": "0.14.2" + }, + "hdmedians-0.14.2-py38h7deecbd_2.tar.bz2": { + "build": "py38h7deecbd_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "219f52f92ceee658a31e1805e680aefa", + "name": "hdmedians", + "sha256": "8b095f2498df868d307b32c12de4f21fb4d8edc0e123c1c75cb8e2969e5345a8", + "size": 154301, + "subdir": "linux-64", + "timestamp": 1676301195580, + "version": "0.14.2" + }, + "hdmedians-0.14.2-py39h6323ea4_1.tar.bz2": { + "build": "py39h6323ea4_1", + "build_number": 1, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7aee3aca6d447d28023991aa6a3fb9f7", + "name": "hdmedians", + "sha256": "552cab6f6a7673245b859c598aed6843365dd8b5e65202f9120f8b56ed8850ea", + "size": 146155, + "subdir": "linux-64", + "timestamp": 1614616175611, + "version": "0.14.2" + }, + "hdmedians-0.14.2-py39h7deecbd_2.tar.bz2": { + "build": "py39h7deecbd_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "218cfbbb6d94fb6e3c9c1dc42b79ad40", + "name": "hdmedians", + "sha256": "3b90a446be455feb7d3d93cdbf0c373b888656b7cfb01200a4fabf247dc9c216", + "size": 149846, + "subdir": "linux-64", + "timestamp": 1676301148908, + "version": "0.14.2" + }, + "heapdict-1.0.0-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "00567523f3207ade781fc66da3a1b822", + "name": "heapdict", + "sha256": "69103f5b8f6c650b9c3f7aef1c6808f5f310976b0aff766e5108e5b9d3e99004", + "size": 7880, + "subdir": "linux-64", + "timestamp": 1518029695426, + "version": "1.0.0" + }, + "heapdict-1.0.0-py27h33770af_0.tar.bz2": { + "build": "py27h33770af_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8772d50220994a01a25c0c7c5954f266", + "name": "heapdict", + "sha256": "398cbbb760ef91960143efee6ab9c9336d934e5c8b1dc21b491ab4dc35296ec7", + "size": 7605, + "subdir": "linux-64", + "timestamp": 1505732926826, + "version": "1.0.0" + }, + "heapdict-1.0.0-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "25c488fe552e16b76c12fb0dd2377715", + "name": "heapdict", + "sha256": "f47d234fa420eeeec87b38425614249389b789d72e232ea279810cfb73e81a4b", + "size": 7662, + "subdir": "linux-64", + "timestamp": 1518029712593, + "version": "1.0.0" + }, + "heapdict-1.0.0-py35h51e6c10_0.tar.bz2": { + "build": "py35h51e6c10_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "24f9f659ed95e25da4f3e6c311007c76", + "name": "heapdict", + "sha256": "d3a56d1a7f1018f53832420b4f2b886c848748380919b19d9b5d17e1999eac1e", + "size": 7330, + "subdir": "linux-64", + "timestamp": 1505732937783, + "version": "1.0.0" + }, + "heapdict-1.0.0-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "15b6e0bf50eec3dfa22c1202c34b5aad", + "name": "heapdict", + "sha256": "95f1afae8a7e0933ecb56c5691da2ebc4c1e48f9ed234512b72817c229698bc5", + "size": 7629, + "subdir": "linux-64", + "timestamp": 1518029728032, + "version": "1.0.0" + }, + "heapdict-1.0.0-py36h79797d7_0.tar.bz2": { + "build": "py36h79797d7_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b2ca4e711414459eadf40e09396347eb", + "name": "heapdict", + "sha256": "177e40d496e375a66d38a7ee206ddd15f5b256702396c48c8eafbba74f5c2e75", + "size": 7322, + "subdir": "linux-64", + "timestamp": 1505732948871, + "version": "1.0.0" + }, + "heapdict-1.0.0-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5a470aec90a20a467317cd9ed8662765", + "name": "heapdict", + "sha256": "0731195f6bb2ebb09bf631527c029ba2cbd47a0b4031e770923de882d56bd48c", + "size": 7520, + "subdir": "linux-64", + "timestamp": 1530741351719, + "version": "1.0.0" + }, + "heapdict-1.0.0-py38_2.tar.bz2": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ef9624c1c7a02bbea63b22b23ecb8d16", + "name": "heapdict", + "sha256": "9b6fc6031d33f40df0c612203b7a32ad09b1aed9f5c0b82a6976853e23f410a8", + "size": 7929, + "subdir": "linux-64", + "timestamp": 1572512127985, + "version": "1.0.0" + }, + "help2man-1.47.17-pl5262h27cfd23_0.tar.bz2": { + "build": "pl5262h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "perl" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "e76fcc714ff42daa7c72ec8039723ef6", + "name": "help2man", + "sha256": "14d720120a599685ca732377e2a60d504dfcbcd0a939ebae3747029142b360e5", + "size": 27863, + "subdir": "linux-64", + "timestamp": 1611514780274, + "version": "1.47.17" + }, + "help2man-1.47.6-pl526h14c3975_0.tar.bz2": { + "build": "pl526h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "perl" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "07989ab80afbbe3a874dfb8c24a6dbec", + "name": "help2man", + "sha256": "50ee33bde4109b51c3c133d51a02ae1e1e86c3d5fca9a3d0fad0243f3c916ce9", + "size": 27496, + "subdir": "linux-64", + "timestamp": 1527326658152, + "version": "1.47.6" + }, + "help2man-1.47.7-pl526h7b6447c_0.tar.bz2": { + "build": "pl526h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "perl" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "8f6ce1605bc49d3f825fa7993f13aef1", + "name": "help2man", + "sha256": "d83f6215572f406854548d957b2a7ce16fa8dbc560b3fbd5abdc2e88207e9186", + "size": 27769, + "subdir": "linux-64", + "timestamp": 1539663973702, + "version": "1.47.7" + }, + "help2man-1.47.8-pl526h7b6447c_0.tar.bz2": { + "build": "pl526h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "perl" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "c2b988ea55684d9817a104f4ac362a8c", + "name": "help2man", + "sha256": "50e9065c6c520487af35a0136c9a2b03d181d3a8f66778fae2f652f816663973", + "size": 28510, + "subdir": "linux-64", + "timestamp": 1547231987595, + "version": "1.47.8" + }, + "help2man-1.48.1-pl5262h27cfd23_0.tar.bz2": { + "build": "pl5262h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "perl" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "1a1775b1276f984e596c25a1aab51408", + "name": "help2man", + "sha256": "10799c2482bc11e1e23f0234d2c7701a5dd020249b6c1cc7c6f7320d89a5eb7b", + "size": 27864, + "subdir": "linux-64", + "timestamp": 1613415235045, + "version": "1.48.1" + }, + "help2man-1.48.2-pl5262h27cfd23_0.tar.bz2": { + "build": "pl5262h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "perl" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "10c1c24400a7af6d549af261de361c2c", + "name": "help2man", + "sha256": "805ae227b5208bc6ce9046737cacb41b9adb76fd394dbd79211f3e4355da2a7b", + "size": 27894, + "subdir": "linux-64", + "timestamp": 1614797165362, + "version": "1.48.2" + }, + "help2man-1.48.3-pl5262h27cfd23_0.tar.bz2": { + "build": "pl5262h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "perl" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "febd172fc0e56f59d503f5d1e2bf49ea", + "name": "help2man", + "sha256": "54d7bd20f7de0c890100b00e44c55b41e41586a721ac75f396f11532119d7fbf", + "size": 27896, + "subdir": "linux-64", + "timestamp": 1617222655891, + "version": "1.48.3" + }, + "help2man-1.48.4-pl5262h7f8727e_0.tar.bz2": { + "build": "pl5262h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "perl" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "4bcac82e80190bd98f191ec058881923", + "name": "help2man", + "sha256": "e1dd30818525f46928184927fcae5b307cc392ad87432f6090e71840d87fa7f2", + "size": 27707, + "subdir": "linux-64", + "timestamp": 1629126812456, + "version": "1.48.4" + }, + "hicolor-icon-theme-0.17-h06a4308_2.tar.bz2": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "40198ee07bc87c113ad049d82f20c5c3", + "name": "hicolor-icon-theme", + "sha256": "c274cff1209978e266feaf6639bd381817cee49cb37809bcd797d71e36ee197e", + "size": 15723, + "subdir": "linux-64", + "timestamp": 1632405199912, + "version": "0.17" + }, + "hiredis-1.1.0-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9f4a5f580944b705981dc10945d0ac91", + "name": "hiredis", + "sha256": "59bd59ca6c4722c025f3c468cebb306d3814e1359ed09cd549e8635658bd042d", + "size": 63587, + "subdir": "linux-64", + "timestamp": 1640790891992, + "version": "1.1.0" + }, + "hiredis-1.1.0-py311h5eee18b_1.tar.bz2": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "6547416394c9a1986e4bb4ec596b710a", + "name": "hiredis", + "sha256": "a4ea6e69095542b3e816ad75d038bb71fb68c1132f2cf00fe9897af1c7b8f061", + "size": 24876, + "subdir": "linux-64", + "timestamp": 1676852669568, + "version": "1.1.0" + }, + "hiredis-1.1.0-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e735f37849df7353253ba2900fc1f113", + "name": "hiredis", + "sha256": "848ded16fe207b48cc7d1404c2ef832b1735f286e694d9a8366dbafd8c7c7d99", + "size": 28370, + "subdir": "linux-64", + "timestamp": 1621433454445, + "version": "1.1.0" + }, + "hiredis-1.1.0-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "bafb703543ee3a902339d7bddc0745ff", + "name": "hiredis", + "sha256": "d3b6bf97eeb1ff8cb0b6edadd9c9ca704d3fdf548df24228928585a892f31ecb", + "size": 28350, + "subdir": "linux-64", + "timestamp": 1621433322215, + "version": "1.1.0" + }, + "hiredis-1.1.0-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c04d75bca59d996b33059cb000e1e461", + "name": "hiredis", + "sha256": "795f8e3a31a3555ebb9fa81ccd80a6819c5b5fed0c86d22eee7cf48240d8b342", + "size": 28515, + "subdir": "linux-64", + "timestamp": 1621428822822, + "version": "1.1.0" + }, + "hiredis-1.1.0-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e0a5b02f855d20b45c46376e27d17e78", + "name": "hiredis", + "sha256": "4d4ec6eda6b169587f354b1da647ea76142a69fbc65b6f4a79503fac563c9e97", + "size": 29012, + "subdir": "linux-64", + "timestamp": 1621433461897, + "version": "1.1.0" + }, + "hiredis-2.0.0-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4dc27d263e51982e534d1ddcf8ddbd64", + "name": "hiredis", + "sha256": "c86ddb21ea5f89c34f010d7c030422275e867c6d1fe2afb504cfb7af244e1aba", + "size": 84652, + "subdir": "linux-64", + "timestamp": 1661475819874, + "version": "2.0.0" + }, + "hiredis-2.0.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bf5a64be0f0cdd10a29080b7ccb46c76", + "name": "hiredis", + "sha256": "b3aee7adc11dbf9986c239b91c318cf579e0ae9101311edae76b826d56c27af4", + "size": 31045, + "subdir": "linux-64", + "timestamp": 1679336253654, + "version": "2.0.0" + }, + "hiredis-2.0.0-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b29dade3e81a1c425bccbfd1c08ebd15", + "name": "hiredis", + "sha256": "6ac6bfcf5a08ed883c1e93475d89b7bfe21c6f3d9ef4cb57630c6650cc95fb9f", + "size": 30799, + "subdir": "linux-64", + "timestamp": 1661475850237, + "version": "2.0.0" + }, + "hiredis-2.0.0-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "98ded0aba9049ece37a25670298955f4", + "name": "hiredis", + "sha256": "49b426a769c6bc146ef0d1dd83bd8fc72278ba61e0e9f88424fbcb5eaef798dd", + "size": 30835, + "subdir": "linux-64", + "timestamp": 1661475738627, + "version": "2.0.0" + }, + "hiredis-2.0.0-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50553716e4a933f5b05f253267cbf4fd", + "name": "hiredis", + "sha256": "0706d77f73a51601f8d32398cad0ede49c8066c537b59636960deecb779568de", + "size": 30782, + "subdir": "linux-64", + "timestamp": 1661475773357, + "version": "2.0.0" + }, + "holidays-0.18-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.3.0", + "hijri-converter", + "korean_lunar_calendar", + "pymeeus", + "python >=3.10,<3.11.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc8454923940cbfb3f57cb70f67e5778", + "name": "holidays", + "sha256": "b1c6ca073d5c09875ee73fee69002551ce89b4191b0b618f2fa6d76090937f1e", + "size": 199756, + "subdir": "linux-64", + "timestamp": 1673991951253, + "version": "0.18" + }, + "holidays-0.18-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.3.0", + "hijri-converter", + "korean_lunar_calendar", + "pymeeus", + "python >=3.11,<3.12.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9f8be923c85784419060e420ad077f6", + "name": "holidays", + "sha256": "4f6be5e16133d0848b98b0a712a9910e943e36c50521e3d4502ac4559c6de6c6", + "size": 242489, + "subdir": "linux-64", + "timestamp": 1676852685158, + "version": "0.18" + }, + "holidays-0.18-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.3.0", + "hijri-converter", + "korean_lunar_calendar", + "pymeeus", + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "04e9239f1ef26051e9982ec2a1871eb3", + "name": "holidays", + "sha256": "cd45f876c1745512ccf99fe14573c1bf8d4825adf0f3555a0b27730e92871edf", + "size": 197306, + "subdir": "linux-64", + "timestamp": 1673991978404, + "version": "0.18" + }, + "holidays-0.18-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.3.0", + "hijri-converter", + "korean_lunar_calendar", + "pymeeus", + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58b8c8460cb424f36d04f642efd341fa", + "name": "holidays", + "sha256": "1c776fa31e1ca48fedc2904ff2d30b1ce85393afcb31c0beeac0e3db44d6e2d4", + "size": 196747, + "subdir": "linux-64", + "timestamp": 1673991923805, + "version": "0.18" + }, + "holidays-0.18-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.3.0", + "hijri-converter", + "korean_lunar_calendar", + "pymeeus", + "python >=3.9,<3.10.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "460cb310c13cceec77c316f154e5ba28", + "name": "holidays", + "sha256": "eb3fcc41bb598612a7507577587cd1da119903a3b77294316f16b677100d5078", + "size": 196118, + "subdir": "linux-64", + "timestamp": 1673992005411, + "version": "0.18" + }, + "holoviews-1.10.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b1fde50eeb160c79717f86e6ca0a9fff", + "name": "holoviews", + "sha256": "16bca08617cd0893a9cda3517902120f4472a86db3ddaad01c98fa699eb98c4e", + "size": 3700012, + "subdir": "linux-64", + "timestamp": 1524000900626, + "version": "1.10.0" + }, + "holoviews-1.10.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "98ca5b4d9b6b854e3704e62b2c6263fd", + "name": "holoviews", + "sha256": "ee54076dc42d17902d27bb68ef2a353702449e36689c63a1be8cfe190bf205f0", + "size": 3716744, + "subdir": "linux-64", + "timestamp": 1524000901459, + "version": "1.10.0" + }, + "holoviews-1.10.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "39c7e9850bd1d6067d66b40cd32858f9", + "name": "holoviews", + "sha256": "fd927734b740bf5215e2b3062d2386af3504a26106b41e7baab3b61180146cf7", + "size": 3619345, + "subdir": "linux-64", + "timestamp": 1524000907461, + "version": "1.10.0" + }, + "holoviews-1.10.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.14,<=0.12.16", + "ipython >=5.4.0", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param >=1.6.0,<2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8076a702fc70f6237aa8289874241dfd", + "name": "holoviews", + "sha256": "f2e6415f84bcad6225624244521433cf053f5abbd16e6501ca2d68e6b57503e4", + "size": 3699630, + "subdir": "linux-64", + "timestamp": 1524514123796, + "version": "1.10.1" + }, + "holoviews-1.10.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.14,<=0.12.16", + "ipython >=5.4.0", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param >=1.6.0,<2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a8f5b1fa808da5793ab3f13eba2346fc", + "name": "holoviews", + "sha256": "3ac8796238d224a6c87b22f53d5ac6da4491017925919572f585bd86a9405ee7", + "size": 3720790, + "subdir": "linux-64", + "timestamp": 1524514148087, + "version": "1.10.1" + }, + "holoviews-1.10.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.14,<=0.12.16", + "ipython >=5.4.0", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param >=1.6.0,<2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ca83b9c2dd572e2d3fb8fbefd3972ae0", + "name": "holoviews", + "sha256": "df9f857db0a01159bc90e5a397e5ac23f2e7d206c147794185a3fb043c8f4aa0", + "size": 3619915, + "subdir": "linux-64", + "timestamp": 1524514146371, + "version": "1.10.1" + }, + "holoviews-1.10.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2958e0ac16a81cbca690f2940b4b3960", + "name": "holoviews", + "sha256": "da61844ae144b89ebff55a2f3a7c4c09972df82b65c091f83e722a5d3eed67fb", + "size": 3724520, + "subdir": "linux-64", + "timestamp": 1525186194852, + "version": "1.10.2" + }, + "holoviews-1.10.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e85e776ed53aef823e2dca8a6e0f542d", + "name": "holoviews", + "sha256": "ffd028302ac5328434cc844276a0f659b7c3af3d959ad755a131ae3d6d48da1a", + "size": 3733356, + "subdir": "linux-64", + "timestamp": 1525186205025, + "version": "1.10.2" + }, + "holoviews-1.10.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c7c51349a0ad86d8fdbbfe64c5afaf4c", + "name": "holoviews", + "sha256": "73cc3843eb6d1a5d22db68ac22d9d9a5ea7765bb06cf2de51694489412296b5e", + "size": 3639156, + "subdir": "linux-64", + "timestamp": 1525186212529, + "version": "1.10.2" + }, + "holoviews-1.10.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "198039cbc05f001a82232016202f1244", + "name": "holoviews", + "sha256": "be4c43ef0e2448be9ad5c25ad36b8f5fa66964d4ea0ec7aa07de32dcfc9515d4", + "size": 3723342, + "subdir": "linux-64", + "timestamp": 1525875540944, + "version": "1.10.3" + }, + "holoviews-1.10.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "43bacf9f22665ccb6843db4ae3af473e", + "name": "holoviews", + "sha256": "fb0210b7ad723ec807b2bda8199bdf788b53edb9c546e1e4a05ca682fdd4e92d", + "size": 3734485, + "subdir": "linux-64", + "timestamp": 1525875853722, + "version": "1.10.3" + }, + "holoviews-1.10.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ac657fb41c00f25d19872db7cc709c4b", + "name": "holoviews", + "sha256": "53ea0705f28f74f79290b5d1e9f4704beaffc8a6ef69e62265b97f816e8e5b56", + "size": 3639440, + "subdir": "linux-64", + "timestamp": 1525875821486, + "version": "1.10.3" + }, + "holoviews-1.10.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0f0e2c1bfaf09e5bed3b2c535697f29c", + "name": "holoviews", + "sha256": "216643759170d112a69a04ae21ce4ba87bc6d6005c6c24b79bf069e69278bfcc", + "size": 3724982, + "subdir": "linux-64", + "timestamp": 1526567774916, + "version": "1.10.4" + }, + "holoviews-1.10.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fd30fc341b0358ab9833788f45dbde32", + "name": "holoviews", + "sha256": "de55b88d62e3bf38ddc94268479054254e89ca926cf8f8e1ca379c6b7c102b2d", + "size": 3732271, + "subdir": "linux-64", + "timestamp": 1526567844000, + "version": "1.10.4" + }, + "holoviews-1.10.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3cc3832e09b245a08a61c5ee578c03de", + "name": "holoviews", + "sha256": "39d436d23603c3e0e13df3264aa55f75616918d0aea086bc634d7257aaef7543", + "size": 3639770, + "subdir": "linux-64", + "timestamp": 1526567777956, + "version": "1.10.4" + }, + "holoviews-1.10.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.12.16", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=2.7,<2.8.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "9ade53ae1139436860831dc919e0b7f7", + "name": "holoviews", + "sha256": "32d1a115ab673ed3e13634ce66d42c028ec85ec84ab6396d7472cd0cc15b7820", + "size": 3728958, + "subdir": "linux-64", + "timestamp": 1529337042097, + "version": "1.10.5" + }, + "holoviews-1.10.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.12.16", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.5,<3.6.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "3ca6d03af8c66273c2bbe06a517a309f", + "name": "holoviews", + "sha256": "46f492f71321461ab4ec16c159c8834f81893d2da9a4f22b52689a7a7e395268", + "size": 3728277, + "subdir": "linux-64", + "timestamp": 1529337073689, + "version": "1.10.5" + }, + "holoviews-1.10.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.12.16", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.6,<3.7.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "7d24091f975f995d3fbb69f6876603d2", + "name": "holoviews", + "sha256": "f23d7abd76dc6c1e30cea92d4205353f1b4762ca3ae6826595bcc966997076e3", + "size": 3636588, + "subdir": "linux-64", + "timestamp": 1529337038472, + "version": "1.10.5" + }, + "holoviews-1.10.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.13.0", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=2.7,<2.8.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "71b44cddc99520be22e6a4c78698f28d", + "name": "holoviews", + "sha256": "a8ec56c082678ee1e8620d9be624d0da05057ff1c81bf821a1f37adbc332fcd0", + "size": 3716775, + "subdir": "linux-64", + "timestamp": 1530893129662, + "version": "1.10.6" + }, + "holoviews-1.10.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.13.0", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.6,<3.7.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "0b312b93c20db7722c15037f313ac2e8", + "name": "holoviews", + "sha256": "9e5f3ab7ae79a9f5385367d1d13dae0a60d1f34c0f5b4d4c58bd2082127ab9d9", + "size": 3640514, + "subdir": "linux-64", + "timestamp": 1530893076288, + "version": "1.10.6" + }, + "holoviews-1.10.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.13.0", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.7,<3.8.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "6f92128d6f6872de63c065905399a6f4", + "name": "holoviews", + "sha256": "754cd73ef3f00da936bc01a78d455fb245e478aba55d91e1f93809337c694e0a", + "size": 3642439, + "subdir": "linux-64", + "timestamp": 1530893021819, + "version": "1.10.6" + }, + "holoviews-1.10.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.13.0", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=2.7,<2.8.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "b63b04b0a465dc88bfd59b860f4335e4", + "name": "holoviews", + "sha256": "32707b4a1bf184b1308442be523959c7cd36e07605a09e91bde6baaf62f5e436", + "size": 3719851, + "subdir": "linux-64", + "timestamp": 1532552538106, + "version": "1.10.7" + }, + "holoviews-1.10.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.13.0", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.5,<3.6.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "f388993ad9676e6623431e3cf455bb96", + "name": "holoviews", + "sha256": "e2295d3a9922d87d275340230fea917a4deb74dbad4d02a0785393238c1552ba", + "size": 3758591, + "subdir": "linux-64", + "timestamp": 1532552713752, + "version": "1.10.7" + }, + "holoviews-1.10.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.13.0", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.6,<3.7.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "8f8fad07e62b7dc8313ca6e6202aeb30", + "name": "holoviews", + "sha256": "03300b2635ec257335f59066a1e21508275a6db11bd1daa3c32314467cff5d6e", + "size": 3644682, + "subdir": "linux-64", + "timestamp": 1532552531235, + "version": "1.10.7" + }, + "holoviews-1.10.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.13.0", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.7,<3.8.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "70a8ef8fa60f2df7eb36ad259eabf6e3", + "name": "holoviews", + "sha256": "a524256e9bfe4a37a1649aaace260366c17d9a2708c0ad63b9d1ed375350ad4e", + "size": 3646058, + "subdir": "linux-64", + "timestamp": 1532552571608, + "version": "1.10.7" + }, + "holoviews-1.15.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2cc39a2f98e2eebc5af59bbae87245d1", + "name": "holoviews", + "sha256": "a27c37be6063962f9d3149942031f1216ce20f58baadcfc1e34b9fcf2ffd59ed", + "size": 4553188, + "subdir": "linux-64", + "timestamp": 1658171786808, + "version": "1.15.0" + }, + "holoviews-1.15.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "bokeh >=2.4.3,<2.5.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50e4e1d30333eb0801c2b15ee923e8d5", + "name": "holoviews", + "sha256": "923baae7485ccb2f4d4c3d3d16fa049f932720fb0e410447384c03b78df6217c", + "size": 4464259, + "subdir": "linux-64", + "timestamp": 1668502209372, + "version": "1.15.0" + }, + "holoviews-1.15.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "17b47eebd2331cced85c75d54ce85ba1", + "name": "holoviews", + "sha256": "474a659ecd140b31b7116cb5a64caff6a8159e2c78e91ec1184afa15a58ef0fe", + "size": 4416754, + "subdir": "linux-64", + "timestamp": 1658171635265, + "version": "1.15.0" + }, + "holoviews-1.15.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "bokeh >=2.4.3,<2.5.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d3cf4049e9e7a1a984b1cf03c9e5d480", + "name": "holoviews", + "sha256": "71b457950f08a11c076c5bc35ad8eb4988bc714dfdaa92c1a3e654e8ecbbf5ed", + "size": 4440587, + "subdir": "linux-64", + "timestamp": 1668501986794, + "version": "1.15.0" + }, + "holoviews-1.15.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5fb9abe9c96a49ca5f87efb541bd75d9", + "name": "holoviews", + "sha256": "8cd8dc9974ff0b0d55371d689d2f6788f6cb8e40f2ba84b311e48ffab5adbcc6", + "size": 4527407, + "subdir": "linux-64", + "timestamp": 1658171557394, + "version": "1.15.0" + }, + "holoviews-1.15.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "bokeh >=2.4.3,<2.5.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "df9da7bd2dfa06dc6ff37ce8535838b1", + "name": "holoviews", + "sha256": "dc347c3816604ce45e635a9b7ebd64e88cdccd6fa5abcda03eb9f3217689fc0f", + "size": 4485821, + "subdir": "linux-64", + "timestamp": 1668502137628, + "version": "1.15.0" + }, + "holoviews-1.15.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dfa0d02d55201a64a525d1a28be123e8", + "name": "holoviews", + "sha256": "bad4f62939fdc9f5a1d3ac6bf2278bc5ba6beed3c349dcb39b0ad648490b6ef7", + "size": 4532808, + "subdir": "linux-64", + "timestamp": 1658171704915, + "version": "1.15.0" + }, + "holoviews-1.15.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "bokeh >=2.4.3,<2.5.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "54b34e55c54bca4fb7aef02fc2efc64c", + "name": "holoviews", + "sha256": "49eccc1b80d461e12916945a31bd9bfed7e37df9c2db16723ecd798852c9984a", + "size": 4447019, + "subdir": "linux-64", + "timestamp": 1668502065853, + "version": "1.15.0" + }, + "holoviews-1.15.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dc2bafa929c4245d8e83e8d6f32bc7ec", + "name": "holoviews", + "sha256": "334757a5699e4089c184c35815d6a8886b61e613e08985bfea52c66059aaf6c2", + "size": 4475579, + "subdir": "linux-64", + "timestamp": 1668507167161, + "version": "1.15.2" + }, + "holoviews-1.15.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bd4db4976833783cd2f988de61fa8f79", + "name": "holoviews", + "sha256": "0bca35db4615043c19990e63798fe4df7d0f6f4a0facfbe983ac87f0dead0a22", + "size": 4441763, + "subdir": "linux-64", + "timestamp": 1668506944896, + "version": "1.15.2" + }, + "holoviews-1.15.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c5d7dc878ba15f34edddf8d950e89336", + "name": "holoviews", + "sha256": "d7f6ee97ff26f46af3ba932bc27b6067ce64f201456d2b50cca871bdcf9baa4a", + "size": 4460033, + "subdir": "linux-64", + "timestamp": 1668507095660, + "version": "1.15.2" + }, + "holoviews-1.15.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2e6e930a334ff4e9a28df9cacbef72e4", + "name": "holoviews", + "sha256": "3bf752d3c51e7fca5d4a04ac1c92ceeb9103f49a2291cd4011a832e81246b2e1", + "size": 4459779, + "subdir": "linux-64", + "timestamp": 1668507023468, + "version": "1.15.2" + }, + "holoviews-1.15.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a60dde448cb4b328c004ca8d35feefc", + "name": "holoviews", + "sha256": "e35f7d28d06f30c0529d7d48ba24713762bb21fed7ed16885fedeb4e8c85a00c", + "size": 4465241, + "subdir": "linux-64", + "timestamp": 1671783124208, + "version": "1.15.3" + }, + "holoviews-1.15.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.11,<3.12.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9ba5c1868a00ad1e9e5c141c54eac79c", + "name": "holoviews", + "sha256": "095ad41d0e9ce6c18efb4aaffcdfd2eadb05b155d67a7b90a1d75cac601ce42f", + "size": 5221081, + "subdir": "linux-64", + "timestamp": 1676844282740, + "version": "1.15.3" + }, + "holoviews-1.15.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2a6e24e581f95704502ef7146a331ddc", + "name": "holoviews", + "sha256": "ac88b0c86226e5fae73217a7eb7fababf8b7c824ba0b35b9624ea74114c8af22", + "size": 4449071, + "subdir": "linux-64", + "timestamp": 1671783053444, + "version": "1.15.3" + }, + "holoviews-1.15.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a2dd51c75d4b403cbd785fdd60c4e93a", + "name": "holoviews", + "sha256": "cbaa57067ff6d0cec2b1a9c3295ececea38dde206981e0373e48124e9db51250", + "size": 4444837, + "subdir": "linux-64", + "timestamp": 1671783195954, + "version": "1.15.3" + }, + "holoviews-1.15.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "497e5242e8e513702f00a2b625b0674b", + "name": "holoviews", + "sha256": "54f35df9586b95021561266b7aaffb3849a871d635c3e9c8f61e5127d21553d6", + "size": 4452572, + "subdir": "linux-64", + "timestamp": 1671782975232, + "version": "1.15.3" + }, + "holoviews-1.15.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "78ae68c456e41842df383f48c58e4265", + "name": "holoviews", + "sha256": "4111000e99fff6a04e23e2a206563e12224de1c2587797b71bcb5600500de50b", + "size": 4575945, + "subdir": "linux-64", + "timestamp": 1676372933494, + "version": "1.15.4" + }, + "holoviews-1.15.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.11,<3.12.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ed169767dde3e1aeb973a20489be454", + "name": "holoviews", + "sha256": "9c5fecfa43c6a49901882afe6e9ae252cfb6893237ca1461f14bb8c53a7272f7", + "size": 5215014, + "subdir": "linux-64", + "timestamp": 1679336285609, + "version": "1.15.4" + }, + "holoviews-1.15.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d98b7afcef2626c3516475fb8ded9470", + "name": "holoviews", + "sha256": "ea12e63cbf015ba66bb4baec116d3e7a9a8785903d0dcaae8ed652bda26968d4", + "size": 4441486, + "subdir": "linux-64", + "timestamp": 1676373081665, + "version": "1.15.4" + }, + "holoviews-1.15.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ffd4e5deba9f449e2b96842ee709e7e1", + "name": "holoviews", + "sha256": "9acf440f17c85327847ea70733cf59691dac11b04b0c23be40e7545d4c8e9d9b", + "size": 4429969, + "subdir": "linux-64", + "timestamp": 1676373153977, + "version": "1.15.4" + }, + "holoviews-1.15.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b18b89f53ccd63f2c57c7dde1f2c05f3", + "name": "holoviews", + "sha256": "3d1e8540b29782d3f123a2fe0cfaec0f05a735c4cd3a8aa78ac30a3bb3cc9791", + "size": 4435249, + "subdir": "linux-64", + "timestamp": 1676373006514, + "version": "1.15.4" + }, + "holoviews-1.9.1-py27h8db4e1f_0.tar.bz2": { + "build": "py27h8db4e1f_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "lancet", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "12bdc011983583c36c0e45a9d1a9fa50", + "name": "holoviews", + "sha256": "138bd09e6c66210c36945d08fb1850846a508124b6daa8d874e4d7fe5e6e2df5", + "size": 3383778, + "subdir": "linux-64", + "timestamp": 1511672937588, + "version": "1.9.1" + }, + "holoviews-1.9.1-py35hd7d2f6e_0.tar.bz2": { + "build": "py35hd7d2f6e_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "lancet", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7f9847738ad6e024612b5e7dad5ea06c", + "name": "holoviews", + "sha256": "c00251c1c7c5b4bbcc4b92142cc3be007e116ebe54f2e9773f1f7818b00b2aac", + "size": 3480450, + "subdir": "linux-64", + "timestamp": 1511672959495, + "version": "1.9.1" + }, + "holoviews-1.9.1-py36h76d18d8_0.tar.bz2": { + "build": "py36h76d18d8_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "lancet", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1bc32964f32f830af65e57575d47e52a", + "name": "holoviews", + "sha256": "113c43e7b66a43a0238e02f4ff9bb02e9bba721066671bb3a1aeb28aa558a9d1", + "size": 3457626, + "subdir": "linux-64", + "timestamp": 1511672942702, + "version": "1.9.1" + }, + "holoviews-1.9.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8aba63b149c151d9ddf14ef8bebdfde2", + "name": "holoviews", + "sha256": "846a06a436cf01e535eb33501b12cf994a99c0ab5efae71ab4730cb93a46056d", + "size": 3383054, + "subdir": "linux-64", + "timestamp": 1515177941849, + "version": "1.9.2" + }, + "holoviews-1.9.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bf6bf8a62ac852a2dabf52a599f377a5", + "name": "holoviews", + "sha256": "4ca0d5e2c55eeb430279e082b8f776d78f76de9d74b69ba4bdb850eca6b624d4", + "size": 3469485, + "subdir": "linux-64", + "timestamp": 1515178049434, + "version": "1.9.2" + }, + "holoviews-1.9.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0c48965d64f910f420c6a5b37c500892", + "name": "holoviews", + "sha256": "43c243e43e1d95d0ec2d509b6ae1fc7a89f3d06c8e49b0aa7002f0dbbc681424", + "size": 3485469, + "subdir": "linux-64", + "timestamp": 1515178049561, + "version": "1.9.2" + }, + "holoviews-1.9.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "66b782881a5af04b2c8172121aea9f77", + "name": "holoviews", + "sha256": "a9b53c031f3ec4d38c791291f22497e0b68ab828a880e1e9df980ee83614eaa2", + "size": 3395914, + "subdir": "linux-64", + "timestamp": 1519237201753, + "version": "1.9.4" + }, + "holoviews-1.9.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "832b71182550cfa53a2372ce19cf0591", + "name": "holoviews", + "sha256": "9c7564d94fdcc246c543cd2d37b7e98e60d4f72b1f090198c3bc842e5a17b1ad", + "size": 3446943, + "subdir": "linux-64", + "timestamp": 1519237180976, + "version": "1.9.4" + }, + "holoviews-1.9.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "440c9bc076742a9ecc2f0d2e38461cdc", + "name": "holoviews", + "sha256": "2d07fd75ef2f3f8194533a1a61a1e552ea07382b4b7a89c05f23ddfc1426edf1", + "size": 3511955, + "subdir": "linux-64", + "timestamp": 1519237019722, + "version": "1.9.4" + }, + "holoviews-1.9.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "db26796fa3b4118f26708271a66356df", + "name": "holoviews", + "sha256": "751023ac2bbc1ed18ef5baac4ada5cb78190bee0f988730ae03074e4edce068c", + "size": 3402349, + "subdir": "linux-64", + "timestamp": 1522360445793, + "version": "1.9.5" + }, + "holoviews-1.9.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9b12b7a1eb24a68935e36db020a10691", + "name": "holoviews", + "sha256": "61acb358604a75aab8d3d83cb9a6450c0dc23d8702c3b8f329332dc7644cc445", + "size": 3435123, + "subdir": "linux-64", + "timestamp": 1522360757526, + "version": "1.9.5" + }, + "holoviews-1.9.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "01ec5c8acff70f570ecf417b2593da3d", + "name": "holoviews", + "sha256": "be5a39739a0cc14dd0071f526d5fe38fb77e9ae718954e3e57d64eae2aeeea69", + "size": 3510885, + "subdir": "linux-64", + "timestamp": 1522360747895, + "version": "1.9.5" + }, + "hpack-3.0.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef8b68774a0b00285d20247d9acc11e7", + "name": "hpack", + "sha256": "77f1729d5f0c998be577121a58f39fa7d3429f310df713a60bc69517329b0958", + "size": 44260, + "subdir": "linux-64", + "timestamp": 1530918994794, + "version": "3.0.0" + }, + "hpack-3.0.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0239f8510bb2c1bb470b57cd3d92cacc", + "name": "hpack", + "sha256": "4a35e290d1c754ed46ec14e3929d010a8b71551d354903aab8462cd4b005b789", + "size": 45068, + "subdir": "linux-64", + "timestamp": 1530918937189, + "version": "3.0.0" + }, + "hpack-3.0.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e2698a9f2cefe38c0d069a1b87c9f6d", + "name": "hpack", + "sha256": "f5b37deb2456000765130f58c65d60d5fb922ae2ceee7ad37bee36564c24c659", + "size": 45881, + "subdir": "linux-64", + "timestamp": 1530918966503, + "version": "3.0.0" + }, + "hsluv-5.0.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools >=38.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96ef3bc17a7be20dc4f088a132ace64a", + "name": "hsluv", + "sha256": "1e8b0a443cd6f9e63d6482b9c2c34cce8846bcf019db4b6218e45eb262e3fbdc", + "size": 13020, + "subdir": "linux-64", + "timestamp": 1670833721262, + "version": "5.0.3" + }, + "hsluv-5.0.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools >=38.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "050b1da90f6285a23a091c7f46f374f4", + "name": "hsluv", + "sha256": "cfb57f362d76884f658595ab6c01938ece01eb94c66bc3cf565d0445e5422b66", + "size": 15472, + "subdir": "linux-64", + "timestamp": 1676839971908, + "version": "5.0.3" + }, + "hsluv-5.0.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools >=38.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ac5715d1ebb16e9f50f5dcbbbc9dada0", + "name": "hsluv", + "sha256": "f5fb7e04e5d98709fe267de2512bd5ec6bbb4d98c85e7a9b157bf13d8fc11bfd", + "size": 12875, + "subdir": "linux-64", + "timestamp": 1670833671060, + "version": "5.0.3" + }, + "hsluv-5.0.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools >=38.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4a9033b2ff629f857f0f6d68f7bfcf3", + "name": "hsluv", + "sha256": "0ac80f4ed66e3730e89284a689e2cb2e22c0258c2b5a337a6a0fc0033cde2409", + "size": 12966, + "subdir": "linux-64", + "timestamp": 1670833695707, + "version": "5.0.3" + }, + "hsluv-5.0.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools >=38.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d89c9cab13f0181140ca74172b6a9143", + "name": "hsluv", + "sha256": "f0c6f17591dff416dcb968ba5fd8faf5c885d4131ecd3d403ebd6866b591b958", + "size": 12925, + "subdir": "linux-64", + "timestamp": 1670833646288, + "version": "5.0.3" + }, + "html5lib-0.999999999-py27hdf15f34_0.tar.bz2": { + "build": "py27hdf15f34_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4280fc071baeeb699f54d725e93c62d4", + "name": "html5lib", + "sha256": "3aeaadf66e47b957d4168bae4486ef28952b9a40bd4d4fc86c00aa1d14d6ba6e", + "size": 188763, + "subdir": "linux-64", + "timestamp": 1505688715735, + "version": "0.999999999" + }, + "html5lib-0.999999999-py35h0543385_0.tar.bz2": { + "build": "py35h0543385_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "775611b905fc2693e59babcbbc50eccb", + "name": "html5lib", + "sha256": "0e1800f8d20143d5d93f656b550def85ec31a5e233c64a1bbf64272572e13209", + "size": 189574, + "subdir": "linux-64", + "timestamp": 1505688730339, + "version": "0.999999999" + }, + "html5lib-0.999999999-py36h2cfc398_0.tar.bz2": { + "build": "py36h2cfc398_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f3b06267f95cd3c8f62e6bdf91b0725", + "name": "html5lib", + "sha256": "27148c83f5d7d27ad9e0f6478c5f8327a7f332192d109ed910bd5a4304811e5d", + "size": 182264, + "subdir": "linux-64", + "timestamp": 1505688745067, + "version": "0.999999999" + }, + "html5lib-1.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83854253113dafda7a55b768cb38b6d7", + "name": "html5lib", + "sha256": "47ed0b701dd58d8ae3cc71298a393d17335d0fd53d9a5dede780dcc9f42c2b63", + "size": 194001, + "subdir": "linux-64", + "timestamp": 1530734173152, + "version": "1.0.1" + }, + "html5lib-1.0.1-py27h5233db4_0.tar.bz2": { + "build": "py27h5233db4_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b5600e6a2af90aef7c751154b504a54", + "name": "html5lib", + "sha256": "d08241300aaa697d52cc71b273b9f3a7d56c55f85a6077f19c8a70956413b232", + "size": 192398, + "subdir": "linux-64", + "timestamp": 1512923123581, + "version": "1.0.1" + }, + "html5lib-1.0.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "885f9c429a809f7ef2b42acf66a60c8e", + "name": "html5lib", + "sha256": "aac364625278211f910f8e8d8e368a42d7a9ded44373bd662f1f4b74672c7880", + "size": 194403, + "subdir": "linux-64", + "timestamp": 1534350881761, + "version": "1.0.1" + }, + "html5lib-1.0.1-py35h2f9c1c0_0.tar.bz2": { + "build": "py35h2f9c1c0_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc1f79b4de4aa451df2dd9a52ffaac21", + "name": "html5lib", + "sha256": "554d99221c9bca0c44b5400f0797c9f5247936487f5ec511684474a84c204c1a", + "size": 193553, + "subdir": "linux-64", + "timestamp": 1512923144145, + "version": "1.0.1" + }, + "html5lib-1.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8d7ca9b600c7de86001dc722f76ecd0", + "name": "html5lib", + "sha256": "356f798bcb38184b2ea8caed9dfcb3f75f281d248387a67b3da2614222ab8037", + "size": 188014, + "subdir": "linux-64", + "timestamp": 1530734150784, + "version": "1.0.1" + }, + "html5lib-1.0.1-py36h2f9c1c0_0.tar.bz2": { + "build": "py36h2f9c1c0_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd532b3677f37a7eb5cbf2aa4fc8358c", + "name": "html5lib", + "sha256": "54fe2f03ba9b177599024264b22777b9c0de5bda481592d66abbcaa2f8890e92", + "size": 185249, + "subdir": "linux-64", + "timestamp": 1512923153402, + "version": "1.0.1" + }, + "html5lib-1.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e645af2692af251a46d9617da92dbff", + "name": "html5lib", + "sha256": "2be80c82a08c14244c8bc8b273935875826411f6c61ed904a9b4f178ef131b39", + "size": 185574, + "subdir": "linux-64", + "timestamp": 1530734195767, + "version": "1.0.1" + }, + "htslib-1.6-h42e7767_0.tar.bz2": { + "build": "h42e7767_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "curl >=7.78.0,<8.0a0", + "libcurl", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "43cd7b4c1debfd19721242b5d46ac9b6", + "name": "htslib", + "sha256": "c858f9e0219df0ade5213b1d5fd36109054197079d8079b12be54c8b7b217dc2", + "size": 1710507, + "subdir": "linux-64", + "timestamp": 1636040051295, + "version": "1.6" + }, + "httpcore-0.15.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anyio 3.*", + "certifi", + "h11 >=0.11,<0.13", + "h2 >=3,<5", + "python >=3.10,<3.11.0a0", + "sniffio 1.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "74c8ec038d2b95568253d9f3e4bf40be", + "name": "httpcore", + "sha256": "435eb670a1bfcd5501abe6749daaa145b714873729f692295c0020eb8292b091", + "size": 78874, + "subdir": "linux-64", + "timestamp": 1659344330513, + "version": "0.15.0" + }, + "httpcore-0.15.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "anyio 3.*", + "certifi", + "h11 >=0.11,<0.13", + "h2 >=3,<5", + "python >=3.11,<3.12.0a0", + "sniffio 1.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3756e0c7cd2be3f80d7e2aa30d755a48", + "name": "httpcore", + "sha256": "ac4abba46cb6102e14e4525e2fc58f482cbefe4336c984adebd024a8b9abe69a", + "size": 106117, + "subdir": "linux-64", + "timestamp": 1676827896293, + "version": "0.15.0" + }, + "httpcore-0.15.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anyio 3.*", + "certifi", + "h11 >=0.11,<0.13", + "h2 >=3,<5", + "python >=3.7,<3.8.0a0", + "sniffio 1.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dc83caa16db239a6f04974325b54b5a3", + "name": "httpcore", + "sha256": "607a756791fe9a237c8eaf9c727cbdd3b403d38c44cf197cc456a4d8abab14ff", + "size": 76247, + "subdir": "linux-64", + "timestamp": 1659344217753, + "version": "0.15.0" + }, + "httpcore-0.15.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anyio 3.*", + "certifi", + "h11 >=0.11,<0.13", + "h2 >=3,<5", + "python >=3.8,<3.9.0a0", + "sniffio 1.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee9091b1c287feeea173ab684efff244", + "name": "httpcore", + "sha256": "b7b7402de0e4ca38bcd358391e5ed9dd5c6dfd30301187aee0b1be9873eb4dcf", + "size": 76553, + "subdir": "linux-64", + "timestamp": 1659344250620, + "version": "0.15.0" + }, + "httpcore-0.15.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anyio 3.*", + "certifi", + "h11 >=0.11,<0.13", + "h2 >=3,<5", + "python >=3.9,<3.10.0a0", + "sniffio 1.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bf578928cf9811ef246d0c8970addf46", + "name": "httpcore", + "sha256": "683ba383a94b3e4f57229891491b7634b54fe6d157014a0aa791f2ef39f141fd", + "size": 77057, + "subdir": "linux-64", + "timestamp": 1659344283013, + "version": "0.15.0" + }, + "httpretty-0.8.14-py27h160e1a8_1.tar.bz2": { + "build": "py27h160e1a8_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "956f54a5e4181b6777e15103835d39fb", + "name": "httpretty", + "sha256": "c5aebeaf2a1e6f971d289fd2c686f126eaba7537ff8f965841ffe34b68f4bfdf", + "size": 34908, + "subdir": "linux-64", + "timestamp": 1509562627081, + "version": "0.8.14" + }, + "httpretty-0.8.14-py35h72974e7_1.tar.bz2": { + "build": "py35h72974e7_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "9849b4e2ed859fec29e3a11620116994", + "name": "httpretty", + "sha256": "420e2fbcbf0f67e88417d025c9fa554094dab4126c120a82cb23e0a68ad30f97", + "size": 35325, + "subdir": "linux-64", + "timestamp": 1509562638096, + "version": "0.8.14" + }, + "httpretty-0.8.14-py36hb7a778b_1.tar.bz2": { + "build": "py36hb7a778b_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a275dca7ae140d963b1b9a8d1955f5ef", + "name": "httpretty", + "sha256": "a4c3b14459be4aaf867f6b5dc64917599fac6f443ea2335061d0f627c75d621e", + "size": 35176, + "subdir": "linux-64", + "timestamp": 1509562614056, + "version": "0.8.14" + }, + "httpretty-0.9.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "aecfcfb5596ef87abe468b8db207904a", + "name": "httpretty", + "sha256": "358a7337fc29ac848f44c4599d5584bb5545e17f9a663fa58c24eb89c21e3d8f", + "size": 37142, + "subdir": "linux-64", + "timestamp": 1526409700432, + "version": "0.9.4" + }, + "httpretty-0.9.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "2f0a5dcf3d8d121c00ac0ef0885b158a", + "name": "httpretty", + "sha256": "d47d6b6559200b7631df857ca03868a90a01ac2563a4b39a13211912c5e538dc", + "size": 37890, + "subdir": "linux-64", + "timestamp": 1526409889020, + "version": "0.9.4" + }, + "httpretty-0.9.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "0d378f20e44ab6c1d8dec61ac9c7c36f", + "name": "httpretty", + "sha256": "1a0bd451747190667e82b7acb601992446bae3e342cc6bd2612905bb2712c206", + "size": 37605, + "subdir": "linux-64", + "timestamp": 1526409689237, + "version": "0.9.4" + }, + "httpretty-0.9.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "54cf0440544e2270ce3e3c9dc923aacc", + "name": "httpretty", + "sha256": "779193011ece63d1542822b8c1ba9675c8c47baa0c2b919b76d0bde350c28401", + "size": 37328, + "subdir": "linux-64", + "timestamp": 1529444175654, + "version": "0.9.5" + }, + "httpretty-0.9.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "56374a8efe699c33f6811484336d973a", + "name": "httpretty", + "sha256": "c852ee3929758b6245a0bcc9cb948e1c944cb12af30b5f0c7b146e975e48b30f", + "size": 38014, + "subdir": "linux-64", + "timestamp": 1529444190244, + "version": "0.9.5" + }, + "httpretty-0.9.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "ff0f2ebceae351ddd2f940e6c1aa89f5", + "name": "httpretty", + "sha256": "324ccc1fde77127f8937bc019c8c993790ab47916e80a06889fe8c014918372c", + "size": 37743, + "subdir": "linux-64", + "timestamp": 1529444234638, + "version": "0.9.5" + }, + "httpretty-0.9.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "8b6c7febf3d14099ef8b07684f7be448", + "name": "httpretty", + "sha256": "5dd32b31c72505ff9c541e6c71366f2c2ca8c7a16f56b769bff93dfd1ec3f98a", + "size": 37773, + "subdir": "linux-64", + "timestamp": 1530893175608, + "version": "0.9.5" + }, + "httpretty-0.9.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "8aa90fdff5afd905ee90466cd0d1b0d3", + "name": "httpretty", + "sha256": "d76c7f0359fc081f9d3bdc2afd97c7435bfbe8dfb6ddad5093b4506b04f9dbc7", + "size": 39210, + "subdir": "linux-64", + "timestamp": 1541435640584, + "version": "0.9.6" + }, + "httpretty-0.9.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "756998ab421ea91890dbba3b2fd10818", + "name": "httpretty", + "sha256": "28bc36983050324a206c8b437d7bffe7b95a63cda9356814b32c747789abfbd4", + "size": 39636, + "subdir": "linux-64", + "timestamp": 1541435640851, + "version": "0.9.6" + }, + "httpretty-0.9.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "de120e68503004cde92f46533bd48fd2", + "name": "httpretty", + "sha256": "9d19ee1c0e65ad36375fd86c0d4d3641b779266ebcc6f827880cebf4d9c4054f", + "size": 39666, + "subdir": "linux-64", + "timestamp": 1541435611067, + "version": "0.9.6" + }, + "httpretty-0.9.6-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "md5": "b851520cc31d1abf4c396f280e376100", + "name": "httpretty", + "sha256": "c31264b8d8101f00e3d5cc09c4495c4a97413ca4f7d75903624e6d045ac66fc0", + "size": 40114, + "subdir": "linux-64", + "timestamp": 1573469597120, + "version": "0.9.6" + }, + "httpretty-0.9.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "046f7c33c98ea06a5af5c2a1b812083e", + "name": "httpretty", + "sha256": "bf364cf1b4e0bbe16812e31c9881594506feb86ca964e972549b772fa62023a1", + "size": 41782, + "subdir": "linux-64", + "timestamp": 1573965074851, + "version": "0.9.7" + }, + "httpretty-0.9.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "cbe6593a46e09d0d2fd1a9c79c4d1e05", + "name": "httpretty", + "sha256": "2b2a30382eee562611faf081460f6a53e25d409acdd9251131e5e5d543eb86c3", + "size": 42218, + "subdir": "linux-64", + "timestamp": 1573965096679, + "version": "0.9.7" + }, + "httpretty-0.9.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "fd5df4efce2036b179b131219fefd333", + "name": "httpretty", + "sha256": "9f9cdc051a7108321a70373ce0d725bb3e7d78a90f5da27e27e16ad3e21c314c", + "size": 42314, + "subdir": "linux-64", + "timestamp": 1573965079768, + "version": "0.9.7" + }, + "httpretty-0.9.7-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "md5": "4a3060475d9f2f71be91821597ebee1d", + "name": "httpretty", + "sha256": "3aa63d6e2fa6aec3b80d6639a0d965c959ba538dce133b32769dfba9ba638aa4", + "size": 42433, + "subdir": "linux-64", + "timestamp": 1573965115730, + "version": "0.9.7" + }, + "httptools-0.5.0-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da076e89a8b90fba4d7ce20fc7a42bc4", + "name": "httptools", + "sha256": "a660dba2f470b9043510f5c82e46e6ac2c653bc447706e9d6c62dbe340125fba", + "size": 131660, + "subdir": "linux-64", + "timestamp": 1677830227383, + "version": "0.5.0" + }, + "httptools-0.5.0-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "41ab51335e57fa10bbd99fa89769ceec", + "name": "httptools", + "sha256": "46542d201a707ada6d45b379849b23b5ad24e578fdb8842f2dac66dd51979450", + "size": 133365, + "subdir": "linux-64", + "timestamp": 1677830257645, + "version": "0.5.0" + }, + "httptools-0.5.0-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52664484631de24af85b9c065c42c34d", + "name": "httptools", + "sha256": "8ec873e8eeaff89dcf49bd9839df31a9b37655fbcf8a88fcc01767c6e364c345", + "size": 132270, + "subdir": "linux-64", + "timestamp": 1677830287946, + "version": "0.5.0" + }, + "httpx-0.23.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "httpcore >=0.15.0,<0.16.0", + "idna", + "python >=3.10,<3.11.0a0", + "rfc3986 >=1.3,<2", + "sniffio" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "db675b0d06fe0c331347cb2ec462f582", + "name": "httpx", + "sha256": "2685a43d72bec823d5cf7e53ac13ffc1833fb57564edaa9490eb44927f28e87f", + "size": 131543, + "subdir": "linux-64", + "timestamp": 1659460991688, + "version": "0.23.0" + }, + "httpx-0.23.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "httpcore >=0.15.0,<0.16.0", + "idna", + "python >=3.11,<3.12.0a0", + "rfc3986 >=1.3,<2", + "sniffio" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "872c21a5bdeafccadf4e7c9710cb6293", + "name": "httpx", + "sha256": "2332e93d9af311c385f3ccc7f98abb304f8dc5af2c94914fce1a4e7ed972b2b8", + "size": 172182, + "subdir": "linux-64", + "timestamp": 1676830809742, + "version": "0.23.0" + }, + "httpx-0.23.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "httpcore >=0.15.0,<0.16.0", + "idna", + "python >=3.7,<3.8.0a0", + "rfc3986 >=1.3,<2", + "sniffio" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f6a65c211dbe849b15d36ac506e4c18b", + "name": "httpx", + "sha256": "d3b7467f342ca1357ea1e0b7c306104490b1864ed8ce242fc773416f3753419e", + "size": 129022, + "subdir": "linux-64", + "timestamp": 1659460959466, + "version": "0.23.0" + }, + "httpx-0.23.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "httpcore >=0.15.0,<0.16.0", + "idna", + "python >=3.8,<3.9.0a0", + "rfc3986 >=1.3,<2", + "sniffio" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9158bea103fb089e8d91dac52083f951", + "name": "httpx", + "sha256": "8ff0bf73760e4e86e9090bf7c0aacef76236769ccd62e9512e78ed0a825c859c", + "size": 129999, + "subdir": "linux-64", + "timestamp": 1659461013402, + "version": "0.23.0" + }, + "httpx-0.23.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "httpcore >=0.15.0,<0.16.0", + "idna", + "python >=3.9,<3.10.0a0", + "rfc3986 >=1.3,<2", + "sniffio" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fe49460bb7677536c89870877d6a80d8", + "name": "httpx", + "sha256": "4c76911b865b155cc2edcbabe9b66fc496a6e592dcf4b53414b81de11a1b8ff6", + "size": 130029, + "subdir": "linux-64", + "timestamp": 1659460937227, + "version": "0.23.0" + }, + "huggingface_accelerate-0.15.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.17", + "packaging >=20.0", + "psutil", + "python >=3.10,<3.11.0a0", + "pytorch >=1.4.0,<3", + "pyyaml" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1688eefad96e1b80f4ab00bdddc71041", + "name": "huggingface_accelerate", + "sha256": "fbdf66264b98d74e4200fcfd22e3229e9d027b72eef386b0ae4d80d67722246b", + "size": 270950, + "subdir": "linux-64", + "timestamp": 1670426367321, + "version": "0.15.0" + }, + "huggingface_accelerate-0.15.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "numpy >=1.17", + "packaging >=20.0", + "psutil", + "python >=3.7,<3.8.0a0", + "pytorch >=1.4.0,<3", + "pyyaml" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "752b8880015ef9a9257b7adace735639", + "name": "huggingface_accelerate", + "sha256": "aadbc456eb2e3fd727d11a1a1738e870db47ea4a62e114f6d2603095ab25c75b", + "size": 267630, + "subdir": "linux-64", + "timestamp": 1670426437730, + "version": "0.15.0" + }, + "huggingface_accelerate-0.15.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.17", + "packaging >=20.0", + "psutil", + "python >=3.8,<3.9.0a0", + "pytorch >=1.4.0,<3", + "pyyaml" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a3986b579b7fd258b1e7d0cced2f3449", + "name": "huggingface_accelerate", + "sha256": "86668e0d5b54f640c8b9d0bf25c8a9a40c25009ab8944edcd50653c32062ebf2", + "size": 268230, + "subdir": "linux-64", + "timestamp": 1670426401998, + "version": "0.15.0" + }, + "huggingface_accelerate-0.15.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.17", + "packaging >=20.0", + "psutil", + "python >=3.9,<3.10.0a0", + "pytorch >=1.4.0,<3", + "pyyaml" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1b7ad5b76b7bd7a109025bd074ee6eb5", + "name": "huggingface_accelerate", + "sha256": "b72cdf0b5db36d6cf77470f2266cc5dc291e018f13e5a31655edcf731e092f4d", + "size": 269189, + "subdir": "linux-64", + "timestamp": 1670426329246, + "version": "0.15.0" + }, + "huggingface_hub-0.10.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "packaging >=20.9", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.1", + "requests", + "tqdm", + "typing-extensions >=3.7.4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c8a44ea584c96f44ebac196f689f07a1", + "name": "huggingface_hub", + "sha256": "8a20d06108b54364798d1c72b1ec516ee9e987f984d24bc016dbaa2a73c3d601", + "size": 227072, + "subdir": "linux-64", + "timestamp": 1667490303076, + "version": "0.10.1" + }, + "huggingface_hub-0.10.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "packaging >=20.9", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.1", + "requests", + "tqdm", + "typing-extensions >=3.7.4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fe1682fe4a90555f78fa5860da8812d2", + "name": "huggingface_hub", + "sha256": "a86eeb6d46aa4c5921a1fe8f7223c1e2cbf3403d4d1114e626f47b5610df1865", + "size": 293477, + "subdir": "linux-64", + "timestamp": 1676839986214, + "version": "0.10.1" + }, + "huggingface_hub-0.10.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "importlib-metadata", + "packaging >=20.9", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "requests", + "tqdm", + "typing-extensions >=3.7.4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "112d41fcee8f85d6996f125cbdfde6ed", + "name": "huggingface_hub", + "sha256": "a20b9b825d7ffeec0fc8b325bd9a05ed8fabd567037af158efcde3432b6d4477", + "size": 222992, + "subdir": "linux-64", + "timestamp": 1667490359736, + "version": "0.10.1" + }, + "huggingface_hub-0.10.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "packaging >=20.9", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "requests", + "tqdm", + "typing-extensions >=3.7.4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9ea7babf5f71d77d1c3a966c0f836b13", + "name": "huggingface_hub", + "sha256": "634f505d4675031472dbb1fb5d3b1df741717f70d4d64d5117ad93dffe27deaa", + "size": 224326, + "subdir": "linux-64", + "timestamp": 1667490274356, + "version": "0.10.1" + }, + "huggingface_hub-0.10.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "packaging >=20.9", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "requests", + "tqdm", + "typing-extensions >=3.7.4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9c6d69668bb1adb45eba5bb30a74bbfd", + "name": "huggingface_hub", + "sha256": "2b03f9005c7d04428cff8bc015759946a2f0744653ad54030dd9debfb8475416", + "size": 224845, + "subdir": "linux-64", + "timestamp": 1667490331327, + "version": "0.10.1" + }, + "humanfriendly-10.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4df5b5998fa05fcb3d1f7d4273eac7e4", + "name": "humanfriendly", + "sha256": "66574542c8dc7d0621c35796cb0d37486f9e227d74634caca646691249b8a542", + "size": 122756, + "subdir": "linux-64", + "timestamp": 1640790909537, + "version": "10.0" + }, + "humanfriendly-10.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b9cbc959dd7ad9dae926ee8a97252c7", + "name": "humanfriendly", + "sha256": "9a2e8762dc00550b88aae64c0022378accdd4ae5906b5e780395577a55b0d2ce", + "size": 122633, + "subdir": "linux-64", + "timestamp": 1668016418367, + "version": "10.0" + }, + "humanfriendly-10.0-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7eb1c87cb6ec45b6bea4cb94694d337b", + "name": "humanfriendly", + "sha256": "49dcb039ea126b1bbce4357f7d9da1ae4ba1ca5a62965e7a382a04ba9821f270", + "size": 155462, + "subdir": "linux-64", + "timestamp": 1676840001274, + "version": "10.0" + }, + "humanfriendly-10.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58ef761353a2765244d8f7d8b9fbf145", + "name": "humanfriendly", + "sha256": "95df544bf18a701474dc9dba983f7689d512b3a5c79689fc3b034f25f2cc08a3", + "size": 121035, + "subdir": "linux-64", + "timestamp": 1639115593777, + "version": "10.0" + }, + "humanfriendly-10.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d21a8ca81b6e944bae33e7f246e8bd4", + "name": "humanfriendly", + "sha256": "e8acc6e73a191005f7631ddd11040ebe0692c21e94aaf6f8c6f29ba3126ffd52", + "size": 121237, + "subdir": "linux-64", + "timestamp": 1668016444209, + "version": "10.0" + }, + "humanfriendly-10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba1df7625061ccea1f33433175306544", + "name": "humanfriendly", + "sha256": "0fe97f69b620a3e30a9f12b4c05326546b3e68978b07aef3efe2bcca93fd0afd", + "size": 121184, + "subdir": "linux-64", + "timestamp": 1639133712491, + "version": "10.0" + }, + "humanfriendly-10.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22dbe638a75785f88d093473d0daa231", + "name": "humanfriendly", + "sha256": "14b66b6a660da238ee8c9b55b7ec7251f0a9b431fdafe78720c404d5f52cee75", + "size": 121350, + "subdir": "linux-64", + "timestamp": 1668016469555, + "version": "10.0" + }, + "humanfriendly-10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df148e261d4e930e99f6a8a27a822455", + "name": "humanfriendly", + "sha256": "30cf89c9f479e36cf54a8fe12f9da5bdb6a556047a80e43adc62662e1f3e9226", + "size": 121542, + "subdir": "linux-64", + "timestamp": 1639133710406, + "version": "10.0" + }, + "humanfriendly-10.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6946de57b079b1c7af040b3fc515bfac", + "name": "humanfriendly", + "sha256": "f62010743e8705ca1005f6991891e954af690b3606c6a1a71276df8e3140f105", + "size": 121844, + "subdir": "linux-64", + "timestamp": 1668016494682, + "version": "10.0" + }, + "humanfriendly-4.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9e9e2b275546dc9484698eb65a4991c4", + "name": "humanfriendly", + "sha256": "0e6a6871675f8eb95e6d5e05508dc89fe156bf14c25eb1f3956d5ef91bf132b7", + "size": 91569, + "subdir": "linux-64", + "timestamp": 1522786281171, + "version": "4.10" + }, + "humanfriendly-4.10-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "60e0a1c374c9ea892fbaa87c91ad538f", + "name": "humanfriendly", + "sha256": "d961591413907dfaab88d4f6a69c3f9786259f6c88aa15e2d68267580938c51b", + "size": 93516, + "subdir": "linux-64", + "timestamp": 1522786283187, + "version": "4.10" + }, + "humanfriendly-4.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c946dd75f191516787625749a72dc022", + "name": "humanfriendly", + "sha256": "9a310978722d80992cef9b46a8e29c47124206cf168aa69d440a4e5c49ebbb54", + "size": 93504, + "subdir": "linux-64", + "timestamp": 1522786283715, + "version": "4.10" + }, + "humanfriendly-4.12.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "25d9a286b81dde3fe37f73ee4abd212f", + "name": "humanfriendly", + "sha256": "7f631849793a09260b14e61f3d409f1bc86d488a97d31f718641d85a8b8feecf", + "size": 93196, + "subdir": "linux-64", + "timestamp": 1526938619897, + "version": "4.12.1" + }, + "humanfriendly-4.12.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "6a82a5ece9eec095954b4cf9f9d5cfa4", + "name": "humanfriendly", + "sha256": "c9b611fd921d9c1495c7ac4790f8dcffcb2f39c65467a903b12e9d5763187c46", + "size": 95183, + "subdir": "linux-64", + "timestamp": 1526938635504, + "version": "4.12.1" + }, + "humanfriendly-4.12.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9983d9d0aa04678b7a6cdb72700c4e90", + "name": "humanfriendly", + "sha256": "73649d0dddd43bfaf170c5462e48ecf9e05764e3bf4adec6054e417b7e645d3b", + "size": 94989, + "subdir": "linux-64", + "timestamp": 1526938595634, + "version": "4.12.1" + }, + "humanfriendly-4.12.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ee42c29f15dafa4767eb6b2d13b7b3f5", + "name": "humanfriendly", + "sha256": "61f508fcf20204cf2485dace4a31696e7f49e9037f4942b02f7c39ce03e87c76", + "size": 94537, + "subdir": "linux-64", + "timestamp": 1530811004931, + "version": "4.12.1" + }, + "humanfriendly-4.16.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "8606f8e3cd02c7eba6ae148e21348d18", + "name": "humanfriendly", + "sha256": "9af1a3e96ffe32f5aed94a4071c67a1546f887f76be5781ef2eb8336a1bcf3d0", + "size": 100977, + "subdir": "linux-64", + "timestamp": 1535426943023, + "version": "4.16.1" + }, + "humanfriendly-4.16.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "c17d4099a2d13c5ff8d21060afb86591", + "name": "humanfriendly", + "sha256": "0e644e0fca1db98c8cfaedf8e8c0f90007d94c00ffdf2a44df4d0b04c2706af8", + "size": 102855, + "subdir": "linux-64", + "timestamp": 1535426843171, + "version": "4.16.1" + }, + "humanfriendly-4.16.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "67ae0f3f7ca2a92a80b313141bf90c58", + "name": "humanfriendly", + "sha256": "63792396efe72f1c312dc97f5792ab8a996bdb68906478706c07d9ca2a0b9888", + "size": 102700, + "subdir": "linux-64", + "timestamp": 1535426916759, + "version": "4.16.1" + }, + "humanfriendly-4.16.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c42f969aa77e590f101b8eb3774fedc1", + "name": "humanfriendly", + "sha256": "d2092e079d98d5fb674fc6d5130aa67348c5e8d2cc0003bd89d29560a5b39e5f", + "size": 102456, + "subdir": "linux-64", + "timestamp": 1535426957107, + "version": "4.16.1" + }, + "humanfriendly-4.17-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "a5fc6930fe730cf01ae0667c30afd2de", + "name": "humanfriendly", + "sha256": "aa917e06918653ea4983c8232fe1fcc4f9918cae205823b9472b6f618d9d6f1a", + "size": 103681, + "subdir": "linux-64", + "timestamp": 1540975880329, + "version": "4.17" + }, + "humanfriendly-4.17-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b2a83153b2c65f9e9d1a73b7781ad62b", + "name": "humanfriendly", + "sha256": "fd23220826a5cf2a2c7fcd5935f4bc2515a21186ad1b396f33d3e3eef8149900", + "size": 105763, + "subdir": "linux-64", + "timestamp": 1540975893907, + "version": "4.17" + }, + "humanfriendly-4.17-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a937cc0ccd7432a010ce7417e1bd53f6", + "name": "humanfriendly", + "sha256": "ea3d7deb71fd364f73263288c9e929b5acc4de464bd10746a714c2935ba018d8", + "size": 105292, + "subdir": "linux-64", + "timestamp": 1540975904671, + "version": "4.17" + }, + "humanfriendly-4.18-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "1485e7af5007fccf0f5325ce7639ee45", + "name": "humanfriendly", + "sha256": "de970e47319fa3527063046e2dce6b342de6fb8b3f2552909c1464890c91f7e5", + "size": 107790, + "subdir": "linux-64", + "timestamp": 1552378485425, + "version": "4.18" + }, + "humanfriendly-4.18-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e36681a6b812c02705729f2278b1657d", + "name": "humanfriendly", + "sha256": "5a5817bf73cd9bd790218606ef90674b5c6ac1727490085190af1dea1b7e9d9f", + "size": 109798, + "subdir": "linux-64", + "timestamp": 1552378551847, + "version": "4.18" + }, + "humanfriendly-4.18-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "95fec67fa967d93d7eaedd26ae45b7c9", + "name": "humanfriendly", + "sha256": "88bc02f3def36dc36cb187a82c2b1884119ce537eccd3cf3aea8da0d3cd2529f", + "size": 109241, + "subdir": "linux-64", + "timestamp": 1552378495029, + "version": "4.18" + }, + "humanfriendly-4.18-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "04767059122a616d33d22436d19f7431", + "name": "humanfriendly", + "sha256": "16b3a7c47af2b2bbf8d945b9ac1ab667014c3c4b931d0b6e926dd34d413bada9", + "size": 106282, + "subdir": "linux-64", + "timestamp": 1572512179816, + "version": "4.18" + }, + "humanfriendly-4.4-py27h983c27b_0.tar.bz2": { + "build": "py27h983c27b_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b9ad717a332ca41156deff97a9625f6e", + "name": "humanfriendly", + "sha256": "26d6bcb66015a2a8e63ab1878cff95fe8ae7e818f26bfcc5fe200d01eadfc810", + "size": 84933, + "subdir": "linux-64", + "timestamp": 1505741982496, + "version": "4.4" + }, + "humanfriendly-4.4-py35haa9438c_0.tar.bz2": { + "build": "py35haa9438c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "ca1a721c064b3c317344bc0898e7e43f", + "name": "humanfriendly", + "sha256": "a97bec76fd20d17d5badfdfe54975c3dd50fa5ed400c5d0b83efdcfb727e90f6", + "size": 86700, + "subdir": "linux-64", + "timestamp": 1505741994636, + "version": "4.4" + }, + "humanfriendly-4.4-py36h10ed9d1_0.tar.bz2": { + "build": "py36h10ed9d1_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f07304349b2286307fcd4f92ca6b491a", + "name": "humanfriendly", + "sha256": "ce5957f4749508867b2287589dff2dc26dcf919ad25549fecdc016fa2cbe5366", + "size": 86501, + "subdir": "linux-64", + "timestamp": 1505742007077, + "version": "4.4" + }, + "humanfriendly-4.4.1-py27h1bea999_0.tar.bz2": { + "build": "py27h1bea999_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d5d3cf50ec61f679b788e83bc70760d6", + "name": "humanfriendly", + "sha256": "25a4d2ea13bf998d3cd41c406290df91189aa7743111f3adb7f970cd735b0a02", + "size": 85515, + "subdir": "linux-64", + "timestamp": 1511968355291, + "version": "4.4.1" + }, + "humanfriendly-4.4.1-py35h457744f_0.tar.bz2": { + "build": "py35h457744f_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "c24f6c9d598d8697946cef4f870b9c9a", + "name": "humanfriendly", + "sha256": "29995b6e4ea74ae5c85f46383ac037b16821e0b35fb8faf938f7c2ea2c10c276", + "size": 87319, + "subdir": "linux-64", + "timestamp": 1511968363149, + "version": "4.4.1" + }, + "humanfriendly-4.4.1-py36h3cfbe1d_0.tar.bz2": { + "build": "py36h3cfbe1d_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "35489f4de8c162ec3a11c3bb83f144aa", + "name": "humanfriendly", + "sha256": "2c7bffde53e80f5fb4ff6615ac326c0f3cf5c3c823eba35fea8daafaa251b33e", + "size": 87292, + "subdir": "linux-64", + "timestamp": 1511968331268, + "version": "4.4.1" + }, + "humanfriendly-4.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5f899b2fc3b69dad95ad7c59540b004b", + "name": "humanfriendly", + "sha256": "4bfa506582390fe44c71ba79185778b85cbf231ee628c348919a24723389c6d5", + "size": 90098, + "subdir": "linux-64", + "timestamp": 1519067753804, + "version": "4.8" + }, + "humanfriendly-4.8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "301450372e4daee58c60f69862b784a0", + "name": "humanfriendly", + "sha256": "f4e2a1c94630f6221eee8273048c10ed389685c8e7fbf8a138de564f71cca3dc", + "size": 92207, + "subdir": "linux-64", + "timestamp": 1519067792215, + "version": "4.8" + }, + "humanfriendly-4.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "64431bdc9ea7f1893796369869b4b594", + "name": "humanfriendly", + "sha256": "c96a0a81699b451f9e17750a0e7f625258d80e1e83255e31097990d294bb2e70", + "size": 92002, + "subdir": "linux-64", + "timestamp": 1519067847073, + "version": "4.8" + }, + "humanfriendly-6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "5b560fc20d185f3bbf45db32df2223a9", + "name": "humanfriendly", + "sha256": "c0eda8bfaa747cf8346f7ee4674e937f9d7ccccfdf1528cc2414dc52c6158a31", + "size": 112746, + "subdir": "linux-64", + "timestamp": 1581539569493, + "version": "6.1" + }, + "humanfriendly-6.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "9465a6f4ac2f67bc9d78faed51512277", + "name": "humanfriendly", + "sha256": "1b7fe4f672151ae001d3a68f987b81f7c60c09e43594e7ddf422404fd9719aaf", + "size": 112309, + "subdir": "linux-64", + "timestamp": 1581539551763, + "version": "6.1" + }, + "humanfriendly-6.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "e92d62eff76a0a96f91d7ff54ce7e9e3", + "name": "humanfriendly", + "sha256": "c878097e650dd71986044f1e1e3ec9317f02f84d098b8c0286c7b393fa351030", + "size": 112397, + "subdir": "linux-64", + "timestamp": 1581539535542, + "version": "6.1" + }, + "humanfriendly-8.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a93028fdda97ac5c6a93dcc42017a676", + "name": "humanfriendly", + "sha256": "6f015ce9a24ee48f993385b8df3612299d12c14dca288031210318ca7b0bd2c6", + "size": 125024, + "subdir": "linux-64", + "timestamp": 1592228480999, + "version": "8.2" + }, + "humanfriendly-8.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e3a9a3e6895e91416f5710070c4d21c0", + "name": "humanfriendly", + "sha256": "87b64262a0135851543cc1d9b1e043cc55cab0ede12d806004b55681af42666c", + "size": 119538, + "subdir": "linux-64", + "timestamp": 1588299943089, + "version": "8.2" + }, + "humanfriendly-8.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "14d636322949140052fda5f224dace01", + "name": "humanfriendly", + "sha256": "2f5dd59c031286e6e4de6affc892b160484d7d9cf23f026d36914d16984caa17", + "size": 124555, + "subdir": "linux-64", + "timestamp": 1592228463289, + "version": "8.2" + }, + "humanfriendly-9.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "bde04621443c2c6fa96050755df0a14c", + "name": "humanfriendly", + "sha256": "7dbbbdbb1185ad7f4340c7bcff2ef94520a3db4f499618fd6d5337a97cb85f6e", + "size": 121681, + "subdir": "linux-64", + "timestamp": 1607115555893, + "version": "9.0" + }, + "humanfriendly-9.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b1707c9a661cd798df5e9a740458b619", + "name": "humanfriendly", + "sha256": "661b0f429f4f4f5634e5d52e2957940150cf9cb60039f2c81edf67e73563aa48", + "size": 121180, + "subdir": "linux-64", + "timestamp": 1607113876291, + "version": "9.0" + }, + "humanfriendly-9.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "3d005e8f641dd078195f83a298254d22", + "name": "humanfriendly", + "sha256": "2a72001206536357672e3dd5e8eea5f412a0e1a229a00de3b5c45a7e7d6b64b1", + "size": 121297, + "subdir": "linux-64", + "timestamp": 1607115243981, + "version": "9.0" + }, + "humanfriendly-9.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "16d2e7a0f9f746974cbf9b8a54e770d7", + "name": "humanfriendly", + "sha256": "1c46e0a50709a9efdbbdac6ba6e63595858d91a22ddfe90eb8b8da5a34c1c17d", + "size": 121694, + "subdir": "linux-64", + "timestamp": 1607113847032, + "version": "9.0" + }, + "humanfriendly-9.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8e4698b69d9ccfe0181955f0f9ce6617", + "name": "humanfriendly", + "sha256": "4df5b8d0cd6615bd72a6c044b1c8d40555b62ebf41dc701c63de2936cef0c73d", + "size": 121738, + "subdir": "linux-64", + "timestamp": 1607621766762, + "version": "9.1" + }, + "humanfriendly-9.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "36975e96be55aecbfc370c666fc00fea", + "name": "humanfriendly", + "sha256": "d4d667b36c9bab7b38ce7f954f3af33987bbcdfc95d05da00217eb64391dd86a", + "size": 121312, + "subdir": "linux-64", + "timestamp": 1607621804456, + "version": "9.1" + }, + "humanfriendly-9.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "6f40d7f4aa4c9180e521ddb292b53477", + "name": "humanfriendly", + "sha256": "b89d756f9dee34376b15afd8d73a6f72bb20ce8b9dce86167bc603145ec9deb6", + "size": 121408, + "subdir": "linux-64", + "timestamp": 1607621748883, + "version": "9.1" + }, + "humanfriendly-9.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "cdf356adcc6134fe74b0d7f968c607fa", + "name": "humanfriendly", + "sha256": "05ae48add1309b4ae243c8d5702b41f48d669c222d8c4c48fece7cb8e7ef9547", + "size": 121784, + "subdir": "linux-64", + "timestamp": 1607621786005, + "version": "9.1" + }, + "humanfriendly-9.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "19f28165a1d1799bb69fb9c5fb4befbf", + "name": "humanfriendly", + "sha256": "380607911190e915507163e4edf71f73953d112e234cfc6e5cffd723753245c4", + "size": 121490, + "subdir": "linux-64", + "timestamp": 1623659455826, + "version": "9.2" + }, + "humanfriendly-9.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d5e2602d3fc46f6e3fd573f9a3c08e9c", + "name": "humanfriendly", + "sha256": "bbe1476f35232bb155baa6e88301c63ebf1b62f13e964d9ab93d653bf3eac70c", + "size": 121069, + "subdir": "linux-64", + "timestamp": 1623653705270, + "version": "9.2" + }, + "humanfriendly-9.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f524f166e3eeb7cd3733da5095973b87", + "name": "humanfriendly", + "sha256": "1f1a5de015e0a38a0d9bd1cfbe78eda9f8b31e634f260e9e4375d5f0bd14cb9b", + "size": 121244, + "subdir": "linux-64", + "timestamp": 1623659088846, + "version": "9.2" + }, + "humanfriendly-9.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b648f372cb297021e63caceabb60b055", + "name": "humanfriendly", + "sha256": "17d38cf82f8b2de70174322e908350ceeb0a0307c460bae81af669d54adeb380", + "size": 121522, + "subdir": "linux-64", + "timestamp": 1623659453284, + "version": "9.2" + }, + "humanize-0.5.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "2e6d6e4c3effb980fe49d585a00103d1", + "name": "humanize", + "sha256": "71f0183a69f24304746efe3d1246a39dbfafda24e1cccb368a49ad62b117a0a2", + "size": 21422, + "subdir": "linux-64", + "timestamp": 1537198295974, + "version": "0.5.1" + }, + "humanize-0.5.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "cac686d6c6e9db0766a285db147e83c2", + "name": "humanize", + "sha256": "507daa02ca10df1befcb8947ba3d450e4d03751c96be3f7e1e63ec785f80a3f9", + "size": 21618, + "subdir": "linux-64", + "timestamp": 1537198319570, + "version": "0.5.1" + }, + "humanize-0.5.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "cb873ee916c1ef7c53561eab3b1a513e", + "name": "humanize", + "sha256": "671ca630c289b5eafa85a45b6b3caca1139286a7516eb76d658ee6d5349f2d09", + "size": 21600, + "subdir": "linux-64", + "timestamp": 1537198325242, + "version": "0.5.1" + }, + "humanize-0.5.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8f65179c17799c5e271411f7f280764e", + "name": "humanize", + "sha256": "2ef2e619be71d96c85907b8d5fee4ef6730ac5380428d85c09e2081d33216bd8", + "size": 21564, + "subdir": "linux-64", + "timestamp": 1537198273544, + "version": "0.5.1" + }, + "hupper-1.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ee3905ab57f57867d7dbb158e293064", + "name": "hupper", + "sha256": "4bcd40de577b7971cab151ede728e5e2c796d9d00f1cc0c21d4b4a4e81106ffd", + "size": 33309, + "subdir": "linux-64", + "timestamp": 1530025359547, + "version": "1.3" + }, + "hupper-1.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f82a8fe5439a73841489f5c00368f7ad", + "name": "hupper", + "sha256": "26242aa74b6c666f1e9fad4d025a627484d437c769a5062fb7b76fc3ae7cb1d3", + "size": 34061, + "subdir": "linux-64", + "timestamp": 1530025641209, + "version": "1.3" + }, + "hupper-1.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0256c1428107c2a28fd46f7435edbaac", + "name": "hupper", + "sha256": "39142bab170e833d570005b921beaf3d2dce550c33f9aca76e667ee7ceace4de", + "size": 33964, + "subdir": "linux-64", + "timestamp": 1530025499493, + "version": "1.3" + }, + "hupper-1.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c40a53a9eb6888d8a2251dff9785eb5c", + "name": "hupper", + "sha256": "1e208e6d5f8a58339385c17bbbcb7b8fc88d406b621fa83c591ea620927665b7", + "size": 33949, + "subdir": "linux-64", + "timestamp": 1530875173823, + "version": "1.3" + }, + "hupper-1.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1690a967509f7918151866f7c771de82", + "name": "hupper", + "sha256": "2f43a4d957d82973ee4e3ca871250443301aa205821717999f0c6a98d3e7c457", + "size": 33930, + "subdir": "linux-64", + "timestamp": 1539657522728, + "version": "1.3.1" + }, + "hupper-1.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1df0a8f0a90316ad87c9032fd00709b0", + "name": "hupper", + "sha256": "33d4aea22fc2a6faa02bf58ad8669e76c7f732882c9ddd9618ceefab8a30f500", + "size": 34570, + "subdir": "linux-64", + "timestamp": 1539657533648, + "version": "1.3.1" + }, + "hupper-1.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7cf40c04f30af32238f3652a208cdbfc", + "name": "hupper", + "sha256": "519752f7c80f16ad7368ba11303c74936d0f97f204b52eec3a00e140fe38e395", + "size": 34623, + "subdir": "linux-64", + "timestamp": 1539657545370, + "version": "1.3.1" + }, + "hupper-1.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "72efcb2906149f08530222facae4c238", + "name": "hupper", + "sha256": "9382d5ee2606617527027c0a4093777db78c7ddfb119ccca8e55dee1c0451be7", + "size": 34655, + "subdir": "linux-64", + "timestamp": 1540977811524, + "version": "1.4" + }, + "hupper-1.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47e3c72e54e70a05accfadba8905fab4", + "name": "hupper", + "sha256": "e18bb7aaf9bd135d7d7f21828a2957252d5de4d364ad7eb9b56a74ac309aafbf", + "size": 35334, + "subdir": "linux-64", + "timestamp": 1540977846085, + "version": "1.4" + }, + "hupper-1.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "70292146b95a8d60fa6ca0064a013062", + "name": "hupper", + "sha256": "199a8197e92fae433295e8fadb06c729cbe93c81165a946dad3ffd056a7bb296", + "size": 35398, + "subdir": "linux-64", + "timestamp": 1540977794160, + "version": "1.4" + }, + "hupper-1.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3f13bb878ad061a355bba5d5b0bb472", + "name": "hupper", + "sha256": "29a630a7aa5e591a2d53277d971187ef1bc6069dd430aee9402d2e04f037b48e", + "size": 34787, + "subdir": "linux-64", + "timestamp": 1542079701270, + "version": "1.4.1" + }, + "hupper-1.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "25d43cec9f6b852a96d094d241687e24", + "name": "hupper", + "sha256": "6546d966b079ff7b381c849ff336d342eb26949e1eee9b10ef578a310626f134", + "size": 35467, + "subdir": "linux-64", + "timestamp": 1542079707290, + "version": "1.4.1" + }, + "hupper-1.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9bdef7fd51ff4abeb4df3981a9382ed5", + "name": "hupper", + "sha256": "4740f62722e40a124be8734c1d4d61e79ad7bd0b1865e7f645d83d55d4034d16", + "size": 35517, + "subdir": "linux-64", + "timestamp": 1542079709116, + "version": "1.4.1" + }, + "hupper-1.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e37575300501ff7500ae49c0b5ee588c", + "name": "hupper", + "sha256": "815afea2de570f6dfcca004a96cd39c7f76ca61dd428226d0467430ea469a4d1", + "size": 34867, + "subdir": "linux-64", + "timestamp": 1545131308305, + "version": "1.4.2" + }, + "hupper-1.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2fafd98eb955698d8b4cf20654e9c463", + "name": "hupper", + "sha256": "4840419622b897df1991941730c7c00de297688e5498bec8d8b0c52b4fac1d05", + "size": 35565, + "subdir": "linux-64", + "timestamp": 1545131346048, + "version": "1.4.2" + }, + "hupper-1.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ef27d9d44a778aab4e71128470061f6", + "name": "hupper", + "sha256": "a5a15f187c3b65037f8057d2de7846fdc394c65315dee3c3bd72cd1612ed8cf3", + "size": 35600, + "subdir": "linux-64", + "timestamp": 1545131383050, + "version": "1.4.2" + }, + "hupper-1.6.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd66abc66305da885e3efb437a98c7f2", + "name": "hupper", + "sha256": "c8d7e2b6f202b39f2f0b7c7af19957cc18a54a91715df0e9378f2d00abd458a9", + "size": 173052, + "subdir": "linux-64", + "timestamp": 1552435922979, + "version": "1.6.1" + }, + "hupper-1.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85d2ce4e1730b33b5968014a61ff6d68", + "name": "hupper", + "sha256": "c96b0688e9d67e11ecf13b6858391ab83aa1ba6cb98a720e0be134198cbad7de", + "size": 173644, + "subdir": "linux-64", + "timestamp": 1552435937344, + "version": "1.6.1" + }, + "hupper-1.6.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "44d694df4b341f08872a9d3690e53a83", + "name": "hupper", + "sha256": "6910f529227ba45613d31e323ec1f264a59a57b8b43f9824f54e04039a8d55b0", + "size": 173741, + "subdir": "linux-64", + "timestamp": 1552435944248, + "version": "1.6.1" + }, + "hupper-1.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f040d824baa41ef1c55dcd67ef954403", + "name": "hupper", + "sha256": "0b406434cdd0e97acd5c88a5570339bd5002f18ad15562eb3107a79728adbabf", + "size": 180918, + "subdir": "linux-64", + "timestamp": 1564680578077, + "version": "1.8.1" + }, + "hupper-1.8.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e47ed664df1ae489f832ad5c0231e890", + "name": "hupper", + "sha256": "b3c2cc9347af783bd8f1ac38b3c65585c6878efbf2b42e34747dacf5d3fd3879", + "size": 40420, + "subdir": "linux-64", + "timestamp": 1640790928246, + "version": "1.8.1" + }, + "hupper-1.8.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13165bfb61ac037260a735ffc080d342", + "name": "hupper", + "sha256": "7aa55cb3d7c3d9b7dbf1a176dadca9c4321f06bb8fe949bd78c1258a329faf6d", + "size": 51655, + "subdir": "linux-64", + "timestamp": 1676904110273, + "version": "1.8.1" + }, + "hupper-1.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7eb8e7948d6ccc4686a66da5efc8b974", + "name": "hupper", + "sha256": "31dab905ed3aeb6b2b894e335ff79e710cb27adf2dde8f2f2273051399a829dc", + "size": 181582, + "subdir": "linux-64", + "timestamp": 1564680865940, + "version": "1.8.1" + }, + "hupper-1.8.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d682bbc9fd9e03b279c62db601a95b34", + "name": "hupper", + "sha256": "e5b204fd2c47345ca538ce241aacc4f86a425f8e339e7b610a6460419aa51906", + "size": 181653, + "subdir": "linux-64", + "timestamp": 1564680747045, + "version": "1.8.1" + }, + "hupper-1.8.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa679f9d3b6bac7d88b46d9f7340bf07", + "name": "hupper", + "sha256": "48e494862ec7f92236db8d6487f79e90dc7140e2bc1dbe8bd5bcebd1dd24e1bf", + "size": 39831, + "subdir": "linux-64", + "timestamp": 1572357239256, + "version": "1.8.1" + }, + "hupper-1.8.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21169062427b5672e22ac53f47d16ddd", + "name": "hupper", + "sha256": "e4d9ae6b39f56400b2ddef45fc12beda8c57b72b4aae37c186d07ee148ef79c3", + "size": 40173, + "subdir": "linux-64", + "timestamp": 1607007521319, + "version": "1.8.1" + }, + "hvplot-0.8.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.0.0", + "colorcet >=2", + "holoviews >=1.12.0", + "numpy >=1.15", + "packaging", + "pandas", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1bc0e7d8744d454d36d5036b1d2f2be0", + "name": "hvplot", + "sha256": "ddae65ea46ead8dd268dc421b7dfe813f69b61153c01f5fae1963624e1be9c7e", + "size": 3251894, + "subdir": "linux-64", + "timestamp": 1659026563609, + "version": "0.8.0" + }, + "hvplot-0.8.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.0.0", + "colorcet >=2", + "holoviews >=1.12.0", + "numpy >=1.15", + "packaging", + "pandas", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5b019022c5a193f5a20b7b2311d0757f", + "name": "hvplot", + "sha256": "60ea7b9fbad4bec8caaa40c51528f171bb6d9a473fc62cd55a98ef399bf4cdc1", + "size": 3250399, + "subdir": "linux-64", + "timestamp": 1659026643259, + "version": "0.8.0" + }, + "hvplot-0.8.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.0.0", + "colorcet >=2", + "holoviews >=1.12.0", + "numpy >=1.15", + "packaging", + "pandas", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2bac892928d428b72981c647ea6af7f8", + "name": "hvplot", + "sha256": "23fcaa374bc1019c82e4120ff42a9440e5465a36cd900bafc4c6fa7709862f50", + "size": 3249956, + "subdir": "linux-64", + "timestamp": 1659026784479, + "version": "0.8.0" + }, + "hvplot-0.8.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.0.0", + "colorcet >=2", + "holoviews >=1.12.0", + "numpy >=1.15", + "packaging", + "pandas", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0084204303daf3af378d8145aaa3496f", + "name": "hvplot", + "sha256": "e6e4d096dc8d1c3244e4732d1ff9c3f75d740b33fff194d9660ff0dc6ca3c160", + "size": 3250442, + "subdir": "linux-64", + "timestamp": 1659026715322, + "version": "0.8.0" + }, + "hvplot-0.8.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=1.0.0", + "colorcet >=2", + "holoviews >=1.11.0", + "numpy >=1.15", + "packaging", + "pandas", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f93acb3705929ec684cae1475baa8592", + "name": "hvplot", + "sha256": "bee543b910bdee8a44876eb1f5446748d3e32d34c0291baaa3d8882a167afb2f", + "size": 3291298, + "subdir": "linux-64", + "timestamp": 1668767226780, + "version": "0.8.1" + }, + "hvplot-0.8.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=1.0.0", + "colorcet >=2", + "holoviews >=1.11.0", + "numpy >=1.15", + "packaging", + "pandas", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4f8607684e19fd2df0535eb861bca3ce", + "name": "hvplot", + "sha256": "285c3a53f82171f32785f35ce6664c2c7203ce5930f07334211549ae5c2918db", + "size": 3288813, + "subdir": "linux-64", + "timestamp": 1668767162094, + "version": "0.8.1" + }, + "hvplot-0.8.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=1.0.0", + "colorcet >=2", + "holoviews >=1.11.0", + "numpy >=1.15", + "packaging", + "pandas", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a590b0541dca54713948e689e9daa711", + "name": "hvplot", + "sha256": "37af1766d7db2fe7395b64fd33db5e8faca1256c697ffc68d3eff08098ed10a8", + "size": 3289892, + "subdir": "linux-64", + "timestamp": 1668767351132, + "version": "0.8.1" + }, + "hvplot-0.8.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=1.0.0", + "colorcet >=2", + "holoviews >=1.11.0", + "numpy >=1.15", + "packaging", + "pandas", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d0e4941ffa6972b71f5772e123fcddf7", + "name": "hvplot", + "sha256": "ab1e1c45fc9fd9898245be9f12df0352f2fa832cfc217ea5eb934d4cd7d95b49", + "size": 3283135, + "subdir": "linux-64", + "timestamp": 1668767287275, + "version": "0.8.1" + }, + "hvplot-0.8.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=1.0.0", + "colorcet >=2", + "holoviews >=1.11.0", + "numpy >=1.15", + "packaging", + "pandas", + "panel >=0.11.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "27ae96795bb6f9d71dfdc578c50fe56a", + "name": "hvplot", + "sha256": "49141c6c45da7a60013ac3de00efacbcf26af85944a366c80c78c7309b5a41e7", + "size": 3318409, + "subdir": "linux-64", + "timestamp": 1670509148333, + "version": "0.8.2" + }, + "hvplot-0.8.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=1.0.0", + "colorcet >=2", + "holoviews >=1.11.0", + "numpy >=1.15", + "packaging", + "pandas", + "panel >=0.11.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c1afc55c7e6f5a1374f7b5cee919a130", + "name": "hvplot", + "sha256": "d4c3c651d629eebf8ec1cc3cdd20ed306af17d8de4ea6834c6902d58e58d0782", + "size": 3339341, + "subdir": "linux-64", + "timestamp": 1676852704821, + "version": "0.8.2" + }, + "hvplot-0.8.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=1.0.0", + "colorcet >=2", + "holoviews >=1.11.0", + "numpy >=1.15", + "packaging", + "pandas", + "panel >=0.11.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d81d2bca22eecd2788dfa8974a207a19", + "name": "hvplot", + "sha256": "499e1f5e3991c434b62add679abb9f340f6aa9614cf7e5b2975fac9d1fb86441", + "size": 3321755, + "subdir": "linux-64", + "timestamp": 1670509087218, + "version": "0.8.2" + }, + "hvplot-0.8.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=1.0.0", + "colorcet >=2", + "holoviews >=1.11.0", + "numpy >=1.15", + "packaging", + "pandas", + "panel >=0.11.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "61d92a06daa2a2a9e8380c289dd0db0c", + "name": "hvplot", + "sha256": "904deac781682576494785cbbcd22ae292c19a60e395ce040cc2fb585ea564fc", + "size": 3322560, + "subdir": "linux-64", + "timestamp": 1670509023118, + "version": "0.8.2" + }, + "hvplot-0.8.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=1.0.0", + "colorcet >=2", + "holoviews >=1.11.0", + "numpy >=1.15", + "packaging", + "pandas", + "panel >=0.11.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eeaf446c867d78dfe538c4fb103c0d6c", + "name": "hvplot", + "sha256": "abfaba6b3c846a9839c31c5da984fc07f817e7ae1c860a511cb6dbc8765c813c", + "size": 3316651, + "subdir": "linux-64", + "timestamp": 1670508954130, + "version": "0.8.2" + }, + "hyperframe-5.1.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "831497b75cc8186de67cf2ab8f2ce283", + "name": "hyperframe", + "sha256": "cb5cf19fc72413b0c61c1bc5099b49bd98ae1109f4b4e7d4b0e81f541d07b1de", + "size": 20387, + "subdir": "linux-64", + "timestamp": 1530919078388, + "version": "5.1.0" + }, + "hyperframe-5.1.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "851dde2d8d89fb6ec10eb2dd573a9307", + "name": "hyperframe", + "sha256": "a40c5669009a6659edc548745457c9ddce1348db1119d1e4f222e1d363061c98", + "size": 21016, + "subdir": "linux-64", + "timestamp": 1530919022683, + "version": "5.1.0" + }, + "hyperframe-5.1.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa3ed22a1b6ec88c70b07b026cfa85ef", + "name": "hyperframe", + "sha256": "7bfa5c855c6c3170fbcdeac6f3262b1f19209d3ed7aecd4ea0793a7918801eec", + "size": 21010, + "subdir": "linux-64", + "timestamp": 1530919050918, + "version": "5.1.0" + }, + "hyperlink-18.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "idna >=2.5", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8b403ef201aaa5cbb8efd0091457b526", + "name": "hyperlink", + "sha256": "d65b4ca2fa3e2e9f6dc84b4883255c395a381bb11a3009c2f6fefa24aa284db8", + "size": 62756, + "subdir": "linux-64", + "timestamp": 1519671840987, + "version": "18.0.0" + }, + "hyperlink-18.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "idna >=2.5", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9c65847372130c8ae2a7464eedf1347", + "name": "hyperlink", + "sha256": "315ef300c48c8af3304aa7a250c5195a0ce46b2434233cdcf3266e46b96a225a", + "size": 64119, + "subdir": "linux-64", + "timestamp": 1519671861383, + "version": "18.0.0" + }, + "hyperlink-18.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "idna >=2.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f273734df3d799620973506df933558a", + "name": "hyperlink", + "sha256": "91a1ca6dc47f3dc0a1eb7a899109c70c59393dfe7f744fc4000646725484cd05", + "size": 63927, + "subdir": "linux-64", + "timestamp": 1519671858639, + "version": "18.0.0" + }, + "hyperlink-18.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "idna >=2.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66f4d008a0603a14ac4b68b6c3bba7f6", + "name": "hyperlink", + "sha256": "85afe1f3da46cb20d1c8da355b59d8eb5246164d7a8af6905b458039c778bc23", + "size": 63363, + "subdir": "linux-64", + "timestamp": 1530893205250, + "version": "18.0.0" + }, + "hypothesis-3.23.0-py27hb9bf4c2_0.tar.bz2": { + "build": "py27hb9bf4c2_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "md5": "7358660e3f117f9323361d7d943e4cfc", + "name": "hypothesis", + "sha256": "b745c44917fbea3e7182c6fef5f1f6cd2a8121512e3c7f7c13a0b48ccc913298", + "size": 191176, + "subdir": "linux-64", + "timestamp": 1505691802242, + "version": "3.23.0" + }, + "hypothesis-3.23.0-py35h5ac4e47_0.tar.bz2": { + "build": "py35h5ac4e47_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "md5": "02476bc077e53fa9d5608d2289ad4442", + "name": "hypothesis", + "sha256": "b20d35d616dc5522a32c96600544a9a086929a580116b8f3aaa6ca92a22edaf7", + "size": 191443, + "subdir": "linux-64", + "timestamp": 1505691817549, + "version": "3.23.0" + }, + "hypothesis-3.23.0-py36h6c998d5_0.tar.bz2": { + "build": "py36h6c998d5_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "md5": "1c3628771d839c93674c0f11226e4c65", + "name": "hypothesis", + "sha256": "8e5173932d347b3d3ad2798957b3b834f7ac54a997b237a1c49a74ae0ed27522", + "size": 190477, + "subdir": "linux-64", + "timestamp": 1505691832947, + "version": "3.23.0" + }, + "hypothesis-3.37.0-py27h1e90009_1.tar.bz2": { + "build": "py27h1e90009_1", + "build_number": 1, + "depends": [ + "attrs", + "coverage", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "md5": "95a9cd117b40e6e180b90f5b2ed62076", + "name": "hypothesis", + "sha256": "5039c5d9004b0e826c09bf3409a3a3b5c80347ece0bcc20395cbf8954d5ff2be", + "size": 227574, + "subdir": "linux-64", + "timestamp": 1510987883998, + "version": "3.37.0" + }, + "hypothesis-3.37.0-py35h38301bd_1.tar.bz2": { + "build": "py35h38301bd_1", + "build_number": 1, + "depends": [ + "attrs", + "coverage", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "md5": "c4fd056ab99cdd416b89e42aa940b4de", + "name": "hypothesis", + "sha256": "f096cdbcbad4845a0c6e8fe86b3e200847cc04415f36809e00db77b69d94d825", + "size": 231109, + "subdir": "linux-64", + "timestamp": 1510987891417, + "version": "3.37.0" + }, + "hypothesis-3.37.0-py36hefa9d8b_1.tar.bz2": { + "build": "py36hefa9d8b_1", + "build_number": 1, + "depends": [ + "attrs", + "coverage", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "md5": "b9efc657982f47dafdc1edb1c630bfd1", + "name": "hypothesis", + "sha256": "e31c2cd6489a717fc0094fd2e76ff26c81e7e6c252149fcb2ac46373e7e10d37", + "size": 229266, + "subdir": "linux-64", + "timestamp": 1510987891706, + "version": "3.37.0" + }, + "hypothesis-3.38.5-py27h2236425_0.tar.bz2": { + "build": "py27h2236425_0", + "build_number": 0, + "depends": [ + "attrs", + "coverage", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "b300be8a38c68a87c46bc559748135c2", + "name": "hypothesis", + "sha256": "644aea15c3240041bb3114980010fc0caee4004cb791e0e403d7c901cb7870d7", + "size": 227330, + "subdir": "linux-64", + "timestamp": 1511884077080, + "version": "3.38.5" + }, + "hypothesis-3.38.5-py35h785bf34_0.tar.bz2": { + "build": "py35h785bf34_0", + "build_number": 0, + "depends": [ + "attrs", + "coverage", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "224044e90732fbf97372342272662dbb", + "name": "hypothesis", + "sha256": "7f1b27f741ba68cbea394debd67045e2a76d136d73e09ed5a1c672ac0b2a5b69", + "size": 231741, + "subdir": "linux-64", + "timestamp": 1511884082425, + "version": "3.38.5" + }, + "hypothesis-3.38.5-py36h196a6cc_0.tar.bz2": { + "build": "py36h196a6cc_0", + "build_number": 0, + "depends": [ + "attrs", + "coverage", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "aa3bac9dc81fc9df0fe1bb8134dd44e3", + "name": "hypothesis", + "sha256": "0bdccd53974fd131841981e6b164b18229f840923a65d3122fa08428d24e273d", + "size": 228884, + "subdir": "linux-64", + "timestamp": 1511884082940, + "version": "3.38.5" + }, + "hypothesis-3.46.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "attrs", + "coverage", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "b50fc2e0baccda37c1a5357306c15e7b", + "name": "hypothesis", + "sha256": "b77009d6d778655086c8e52e31838744fb67f7adf693b3d08b602f83d0302cb5", + "size": 251809, + "subdir": "linux-64", + "timestamp": 1519762048955, + "version": "3.46.0" + }, + "hypothesis-3.46.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "attrs", + "coverage", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "3dad3c4c08bca0a0ce3aa03a045545b4", + "name": "hypothesis", + "sha256": "f60bd56b978313c131af59a5af6ebffbf2fef533f1757f04a883528e9935a99f", + "size": 258459, + "subdir": "linux-64", + "timestamp": 1519762166207, + "version": "3.46.0" + }, + "hypothesis-3.46.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "attrs", + "coverage", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "27538d113f7fa30f88e8a31adfd55eac", + "name": "hypothesis", + "sha256": "10f3639ccb5168d8c7b414ec0e046820c23869839ad7887a80b52a20975a3a61", + "size": 256962, + "subdir": "linux-64", + "timestamp": 1519762067548, + "version": "3.46.0" + }, + "hypothesis-3.52.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "62cd8bd49317aec809d0cb1ada28f157", + "name": "hypothesis", + "sha256": "e44a59959a5e0536b5d736c68c6cf368fd841822abd70b746b81f6ae9dc8f574", + "size": 256590, + "subdir": "linux-64", + "timestamp": 1522004075530, + "version": "3.52.0" + }, + "hypothesis-3.52.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "78b5cfff9be6b70a31f24bcdd876c3dd", + "name": "hypothesis", + "sha256": "1ebcd39f07a5f9bcb890f36825b70deef8fff2c8342c0bdb8b886846ddb5848b", + "size": 262004, + "subdir": "linux-64", + "timestamp": 1522004154088, + "version": "3.52.0" + }, + "hypothesis-3.52.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "9b97390e67749a4c90ee2bb9f929486d", + "name": "hypothesis", + "sha256": "4049e15ea253d1dffbe374baef1c5c512789790b897dbf058ab480d086e8b8ad", + "size": 262722, + "subdir": "linux-64", + "timestamp": 1522004156571, + "version": "3.52.0" + }, + "hypothesis-3.53.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "64b1a7808c3d0c1e7fb0b95622954d42", + "name": "hypothesis", + "sha256": "df16b507d852a3adda1981e97721fe5280d80594a5f66d1edfeff23dd5f54e03", + "size": 257017, + "subdir": "linux-64", + "timestamp": 1522785051437, + "version": "3.53.0" + }, + "hypothesis-3.53.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "3f30b82554641483920148004aeea582", + "name": "hypothesis", + "sha256": "76b6675adb9f811f837ea35691b144eb42a0cf9941c4ffa5b74477c33941148b", + "size": 262687, + "subdir": "linux-64", + "timestamp": 1522785064928, + "version": "3.53.0" + }, + "hypothesis-3.53.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "22e75bc05de97908bd322b1224d62512", + "name": "hypothesis", + "sha256": "ecae2b3da33553d8725676fb87278a08667aaa06b7e7aeb2cf6127e73d8e331f", + "size": 261999, + "subdir": "linux-64", + "timestamp": 1522785049307, + "version": "3.53.0" + }, + "hypothesis-3.56.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "01707e13aa620d74e62e6f3d5481b3de", + "name": "hypothesis", + "sha256": "38dec32584d1e3336336e19e999c8d45542f1ad641112b2149cc0f68cefe3c67", + "size": 260054, + "subdir": "linux-64", + "timestamp": 1524083370341, + "version": "3.56.0" + }, + "hypothesis-3.56.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "2e797394198c7c3bc86026b4c95fa4b6", + "name": "hypothesis", + "sha256": "ee75ac041e3ea225c99e72b19a2028c2e317783714b7d26d6ddd5c0b156d57a6", + "size": 265015, + "subdir": "linux-64", + "timestamp": 1524083395650, + "version": "3.56.0" + }, + "hypothesis-3.56.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "f4ced63b2f2f8561c7688e65f8109e12", + "name": "hypothesis", + "sha256": "f0b16b5d3eb94dca0b1cf844c625bdf3888213c481507c223e188de4cabe026c", + "size": 264318, + "subdir": "linux-64", + "timestamp": 1524083315568, + "version": "3.56.0" + }, + "hypothesis-3.57.0-py27h24bf2e0_0.tar.bz2": { + "build": "py27h24bf2e0_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "1ad9e010502ee0144a3c413400512c80", + "name": "hypothesis", + "sha256": "210c1ac37a8dba48a90d6700e5bc85286b405fe3fd953b73fc2e54458c83b1e5", + "size": 263472, + "subdir": "linux-64", + "timestamp": 1527702543749, + "version": "3.57.0" + }, + "hypothesis-3.57.0-py35h24bf2e0_0.tar.bz2": { + "build": "py35h24bf2e0_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "835ebe9ab37bb7419d0660a4ee7b7b38", + "name": "hypothesis", + "sha256": "6d2372408d05a20415a152567e2faa2182091a5e0b96facd1fe6d82dfad8b29e", + "size": 266636, + "subdir": "linux-64", + "timestamp": 1527702573924, + "version": "3.57.0" + }, + "hypothesis-3.57.0-py36h24bf2e0_0.tar.bz2": { + "build": "py36h24bf2e0_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "da7c14e16d0cdf6644b57f73b7b416b9", + "name": "hypothesis", + "sha256": "2203d9ca13da5fe26cd33a8d7ad8d0946534c029d05403f479f1660693225c82", + "size": 266599, + "subdir": "linux-64", + "timestamp": 1527702461706, + "version": "3.57.0" + }, + "hypothesis-3.59.1-py27h39e3cac_0.tar.bz2": { + "build": "py27h39e3cac_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "8d82ded0ded244da9d69ce24c227cd5d", + "name": "hypothesis", + "sha256": "ba3c243e1dc00264cec1d02863da576d10d1c069caf70b3e52755f9c340f9dec", + "size": 364166, + "subdir": "linux-64", + "timestamp": 1530729834378, + "version": "3.59.1" + }, + "hypothesis-3.59.1-py35h39e3cac_0.tar.bz2": { + "build": "py35h39e3cac_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "afb6557aca8256143c32aa3f09b5c01c", + "name": "hypothesis", + "sha256": "6188c07284399ac4c91fe402d7b95a80634fb63a80b828fe31b738ad725c1fb8", + "size": 364774, + "subdir": "linux-64", + "timestamp": 1534347734583, + "version": "3.59.1" + }, + "hypothesis-3.59.1-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "7b8e0e6ba9e119f4dbad36a2c679851c", + "name": "hypothesis", + "sha256": "95bc8c27e544d461f68dc73935770d1275d9a95449513cc11a47d462b7581e0b", + "size": 359854, + "subdir": "linux-64", + "timestamp": 1530732222565, + "version": "3.59.1" + }, + "hypothesis-3.59.1-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "58b542023bcfa7f18123a824a6444145", + "name": "hypothesis", + "sha256": "8de0feaa8c88aa6d0482712160477c2bde7588559a57171f8ef61b074b10c9fb", + "size": 360318, + "subdir": "linux-64", + "timestamp": 1530730530148, + "version": "3.59.1" + }, + "hypothesis-3.68.0-py27h39e3cac_0.tar.bz2": { + "build": "py27h39e3cac_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "29d3cb2fdb7f6733cf9bb26dfe33c1f1", + "name": "hypothesis", + "sha256": "d18a433d8118226bc1b75716e1d776905dd6924694c8f403baa9f6358347fa79", + "size": 390303, + "subdir": "linux-64", + "timestamp": 1534778398436, + "version": "3.68.0" + }, + "hypothesis-3.68.0-py35h39e3cac_0.tar.bz2": { + "build": "py35h39e3cac_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "f31df4271813c2ea29d39d258d19d9f7", + "name": "hypothesis", + "sha256": "c85f5b0f999ac9eb33222aad6fc5c38676ecee2eca5b81047d3dea7735dcfb3b", + "size": 398401, + "subdir": "linux-64", + "timestamp": 1534777898275, + "version": "3.68.0" + }, + "hypothesis-3.68.0-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "2b3b9573636138ed2664e9c61de064df", + "name": "hypothesis", + "sha256": "da058c6228a4cd6407ad64ef28a06dc47384ee0acba2dc15c0c0f7c80ba51f2f", + "size": 396020, + "subdir": "linux-64", + "timestamp": 1534778904612, + "version": "3.68.0" + }, + "hypothesis-3.68.0-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "4fd0ad305f6b0922a635c70bb1337ff0", + "name": "hypothesis", + "sha256": "09a5b14312f874d9ff427335000e516201f4fcc27cc4ec333e64b318a036ae7e", + "size": 395505, + "subdir": "linux-64", + "timestamp": 1534779380655, + "version": "3.68.0" + }, + "hypothesis-4.10.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "df447d71f0e15b89130729ce96cf1764", + "name": "hypothesis", + "sha256": "3fc70599cd5efda7ccae10552705e7def1c0cb2d4165ca74ed9a8e05f7649aec", + "size": 350328, + "subdir": "linux-64", + "timestamp": 1552436663716, + "version": "4.10.0" + }, + "hypothesis-4.10.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "bc156ee248d25d3d95f2582f454ff4f5", + "name": "hypothesis", + "sha256": "be790f0d99ed3f86e400f3625734d103263ac450d1731f15c90d40a85190af39", + "size": 360989, + "subdir": "linux-64", + "timestamp": 1552436778307, + "version": "4.10.0" + }, + "hypothesis-4.10.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "f4acd3b4eaab3f081a0ae4971e811391", + "name": "hypothesis", + "sha256": "3a759df2acc67c2dbca9ff70d93aee443a8cb9524397308f9b887b254430e565", + "size": 352837, + "subdir": "linux-64", + "timestamp": 1552436725880, + "version": "4.10.0" + }, + "hypothesis-4.17.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "cf0bbb4821746fcf6f07b701c7ad0716", + "name": "hypothesis", + "sha256": "903fdad7a30ee6dba51da56c8480a8735ae4d06a26d878e2d96ee028808822fa", + "size": 366069, + "subdir": "linux-64", + "timestamp": 1556082487091, + "version": "4.17.2" + }, + "hypothesis-4.17.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "88cc6897332e1c2ce2ba909b3a774abc", + "name": "hypothesis", + "sha256": "77a3fa9228cd0e0cd70820e2b5f4e2dfba122ab30b6bf633942ea8d37ff40e83", + "size": 367315, + "subdir": "linux-64", + "timestamp": 1556112457288, + "version": "4.17.2" + }, + "hypothesis-4.17.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "f0a5013da2ce4622bc72070ea1382177", + "name": "hypothesis", + "sha256": "ad6d2ed1fbb733a3e1fa164f19098c2e872ea389728855e855d4acdff2aa62b9", + "size": 367115, + "subdir": "linux-64", + "timestamp": 1556112429839, + "version": "4.17.2" + }, + "hypothesis-4.23.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "843a1be125fe23b87e757515e877c446", + "name": "hypothesis", + "sha256": "5b955043cc98f23a6920ac3ff28254a4e706bd455c450e726cbe7a8a76295d23", + "size": 364138, + "subdir": "linux-64", + "timestamp": 1559063682385, + "version": "4.23.6" + }, + "hypothesis-4.23.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "aaefefb874dd57b45205fa4e660cef2c", + "name": "hypothesis", + "sha256": "72b83b2df87a56419417483f8393907047a7303fdccaf53273482b0f4daefc70", + "size": 370963, + "subdir": "linux-64", + "timestamp": 1559063692093, + "version": "4.23.6" + }, + "hypothesis-4.23.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "202477a6b8dce3cbf4dc139a0fc425d1", + "name": "hypothesis", + "sha256": "58bad39846041fe9ed2e5e65d32116e094b0cd2f54e20ec537a89ad9006cc923", + "size": 371976, + "subdir": "linux-64", + "timestamp": 1559063647202, + "version": "4.23.6" + }, + "hypothesis-4.32.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "c0a82f517143db966bdf3f45f66abc82", + "name": "hypothesis", + "sha256": "ebac6998838d11d263040d46c94e8224fae6db6e20d8919b16a097d2c79e9909", + "size": 369035, + "subdir": "linux-64", + "timestamp": 1564685687824, + "version": "4.32.2" + }, + "hypothesis-4.32.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "02b58e7b05a0ced60ae4248b6e17dd91", + "name": "hypothesis", + "sha256": "396ce331819ce3e090bdc15bb13e3e492fbee9e9b46d57f89db59760df448973", + "size": 376473, + "subdir": "linux-64", + "timestamp": 1564685679514, + "version": "4.32.2" + }, + "hypothesis-4.32.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "1015be6638e1c3f0e33f7b5fcf531353", + "name": "hypothesis", + "sha256": "b2e75159ee5b27af57554479a8f7158729aabcc1e2b7279067ab30bda1c06265", + "size": 373834, + "subdir": "linux-64", + "timestamp": 1564685387128, + "version": "4.32.2" + }, + "hypothesis-4.36.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "15b963ba7f7c1d0d58d6bdfcf118bcbd", + "name": "hypothesis", + "sha256": "8ef6afb523e735d1c8fe987f695d6f0b7a511f3400cc0864d3ce7632102af709", + "size": 377634, + "subdir": "linux-64", + "timestamp": 1569375203269, + "version": "4.36.2" + }, + "hypothesis-4.36.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "bdb4d611e391f9f96909a4c325317023", + "name": "hypothesis", + "sha256": "fbf497244eb489f1c2e02ff53f01fb7d171e0a1594d1553c6f5d9b56335f86be", + "size": 390123, + "subdir": "linux-64", + "timestamp": 1569375186919, + "version": "4.36.2" + }, + "hypothesis-4.36.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "fc9c99872ee317729e9273cf3a95a54c", + "name": "hypothesis", + "sha256": "aea1c4489d132fdea912da72b1a4ec2ea3e9285cb4d490d5778b56e799e90135", + "size": 390447, + "subdir": "linux-64", + "timestamp": 1569375208689, + "version": "4.36.2" + }, + "hypothesis-4.36.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "4f0d5c1d491a5f8a0c2caed73cb549f3", + "name": "hypothesis", + "sha256": "af784573f41eb24922885c3d7fe28470f4abc175924606a3d6adc7e227383c28", + "size": 360918, + "subdir": "linux-64", + "timestamp": 1573469614261, + "version": "4.36.2" + }, + "hypothesis-4.44.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "b49d0d37db4cec531e417671e52fccc1", + "name": "hypothesis", + "sha256": "bc03fc13da45a297cf61430ff0a637e5e8e5ca55a90ae7f3605c18e935fe5750", + "size": 397150, + "subdir": "linux-64", + "timestamp": 1573965442937, + "version": "4.44.2" + }, + "hypothesis-4.44.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "815a6ac05d4828453de6c49c79024aea", + "name": "hypothesis", + "sha256": "6f601065478a15edb8522bde6f95b6dd588fcaccea04abb91893ca9fea770561", + "size": 402317, + "subdir": "linux-64", + "timestamp": 1573965424136, + "version": "4.44.2" + }, + "hypothesis-4.44.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "698635cc922e108629dbaf82a9155e53", + "name": "hypothesis", + "sha256": "cdb47e6a4d2789d799390e518f7c34ba790252fafe60b70cf17b267df9a495ef", + "size": 402270, + "subdir": "linux-64", + "timestamp": 1573965435552, + "version": "4.44.2" + }, + "hypothesis-4.44.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "6835187bf28d31da23134ef98c20d802", + "name": "hypothesis", + "sha256": "4a5a5d0b21bd7c53a95b1e26f41d52ac07b928734b7b161cbd333e70c2cb1554", + "size": 410947, + "subdir": "linux-64", + "timestamp": 1573965471265, + "version": "4.44.2" + }, + "hypothesis-4.54.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "b29c07d5a192d263ba44095695683622", + "name": "hypothesis", + "sha256": "44988d12e00e08755039f8928549a8be4cc95247a3dd497b9ad8736848addec3", + "size": 412535, + "subdir": "linux-64", + "timestamp": 1576539568622, + "version": "4.54.2" + }, + "hypothesis-4.54.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "bb4865c02d15e09ff9ac210789cdf3fc", + "name": "hypothesis", + "sha256": "8c6d469adf67b6b2405915a091edeeba417e7d3a64309bfe476f9002c0892606", + "size": 416335, + "subdir": "linux-64", + "timestamp": 1576539600334, + "version": "4.54.2" + }, + "hypothesis-4.54.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "59fd04641fb8a967306f445cdf5807c0", + "name": "hypothesis", + "sha256": "5fc3066d80162fd378cc72e57999f3dbf426148fce2a60ad3892887515d8417e", + "size": 414749, + "subdir": "linux-64", + "timestamp": 1576539503458, + "version": "4.54.2" + }, + "hypothesis-4.54.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "0fe58bf3d626a91aa6a85ca4f04dd893", + "name": "hypothesis", + "sha256": "2d65789969c59e27b835b82e638631c754a3a3992864568be512f341bca58149", + "size": 418634, + "subdir": "linux-64", + "timestamp": 1576539606800, + "version": "4.54.2" + }, + "ibis-framework-0.12.0-py27h9175896_0.tar.bz2": { + "build": "py27h9175896_0", + "build_number": 0, + "depends": [ + "enum34", + "graphviz", + "impyla >=0.14.0", + "multipledispatch", + "numpy >=1.10.0", + "pandas >=0.18.1", + "psycopg2", + "python >=2.7,<2.8.0a0", + "python-graphviz", + "setuptools", + "six", + "sqlalchemy >=1.0.0", + "thrift <=0.9.3", + "thriftpy <=0.3.9", + "toolz" + ], + "license": "Apache 2.0", + "md5": "8df236882299945bd3b2364ada392004", + "name": "ibis-framework", + "sha256": "c2f8d53e4048c20ba65b0932375f5cb95571399c5346bb0157859d00bda85037", + "size": 626553, + "subdir": "linux-64", + "timestamp": 1510945275278, + "version": "0.12.0" + }, + "ibis-framework-0.12.0-py35hf90f30f_0.tar.bz2": { + "build": "py35hf90f30f_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "multipledispatch", + "numpy >=1.10.0", + "pandas >=0.18.1", + "psycopg2", + "python >=3.5,<3.6.0a0", + "python-graphviz", + "setuptools", + "six", + "sqlalchemy >=1.0.0", + "thrift <=0.9.3", + "thriftpy <=0.3.9", + "toolz" + ], + "license": "Apache 2.0", + "md5": "a224cc35264527cad1a6cc33ae465d68", + "name": "ibis-framework", + "sha256": "ffd64fb79a62267c434525a8754b7270bbba6f0d623bb9f8e91c1318d6219df2", + "size": 642172, + "subdir": "linux-64", + "timestamp": 1510945246210, + "version": "0.12.0" + }, + "ibis-framework-0.12.0-py36h5db9e08_0.tar.bz2": { + "build": "py36h5db9e08_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "multipledispatch", + "numpy >=1.10.0", + "pandas >=0.18.1", + "psycopg2", + "python >=3.6,<3.7.0a0", + "python-graphviz", + "setuptools", + "six", + "sqlalchemy >=1.0.0", + "thrift", + "thriftpy <=0.3.9", + "toolz" + ], + "license": "Apache 2.0", + "md5": "b2574bead825536e0532ef3426e815e2", + "name": "ibis-framework", + "sha256": "05df7221145367e4aaec436f8c6e0a49e9ce0906e11a66483bf339722d715a0d", + "size": 637515, + "subdir": "linux-64", + "timestamp": 1510945250466, + "version": "0.12.0" + }, + "ibis-framework-0.13.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "functools32", + "graphviz", + "impyla >=0.14.0", + "multipledispatch", + "numpy >=1.10.0", + "pandas >=0.18.1", + "pathlib2", + "psycopg2", + "python >=2.7,<2.8.0a0", + "python-graphviz", + "setuptools", + "six", + "sqlalchemy >=1.0.0", + "thrift <=0.9.3", + "thriftpy <=0.3.9", + "toolz" + ], + "license": "Apache 2.0", + "md5": "cc2430e88eacf8c3c716692e5d596718", + "name": "ibis-framework", + "sha256": "f1a57c02db7d24f62a54a25341f6e6c2b30554f5f03bf6fdf1fee872c1403f4b", + "size": 732812, + "subdir": "linux-64", + "timestamp": 1530914713869, + "version": "0.13.0" + }, + "ibis-framework-0.13.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "multipledispatch", + "numpy >=1.10.0", + "pandas >=0.18.1", + "psycopg2", + "python >=3.6,<3.7.0a0", + "python-graphviz", + "setuptools", + "six", + "sqlalchemy >=1.0.0", + "thrift", + "thriftpy <=0.3.9", + "toolz" + ], + "license": "Apache 2.0", + "md5": "61e88fca6cc87de24f204b4351b84c14", + "name": "ibis-framework", + "sha256": "d53abfa6e0460e1c569cb8b533e59a60983381b57e9068546327a412695ba38d", + "size": 738899, + "subdir": "linux-64", + "timestamp": 1530914784017, + "version": "0.13.0" + }, + "ibis-framework-0.13.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "multipledispatch", + "numpy >=1.10.0", + "pandas >=0.18.1", + "psycopg2", + "python >=3.7,<3.8.0a0", + "python-graphviz", + "setuptools", + "six", + "sqlalchemy >=1.0.0", + "thrift", + "thriftpy <=0.3.9", + "toolz" + ], + "license": "Apache 2.0", + "md5": "d0cf63016c6b6203bdc2ceccaccfdf41", + "name": "ibis-framework", + "sha256": "6dbba0bdceb0eb51743e848c2c59e9e4960b2648758b875955db05e7603820da", + "size": 733844, + "subdir": "linux-64", + "timestamp": 1530914846248, + "version": "0.13.0" + }, + "ibis-framework-0.13.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "multipledispatch", + "numpy >=1.10.0", + "pandas >=0.18.1", + "psycopg2", + "python >=3.8,<3.9.0a0", + "python-graphviz", + "setuptools", + "six", + "sqlalchemy >=1.0.0", + "thrift", + "thriftpy <=0.3.9", + "toolz" + ], + "license": "Apache 2.0", + "md5": "0187a97c2c22efbae470e0d0963ef074", + "name": "ibis-framework", + "sha256": "962819ca6a6473f565187b03a122499c4fdf53d32477ff726753a5e5d49dca1d", + "size": 745253, + "subdir": "linux-64", + "timestamp": 1574414004322, + "version": "0.13.0" + }, + "ibis-framework-0.14.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "funcsigs", + "functools32", + "graphviz", + "impyla >=0.14.0", + "lz4", + "multipledispatch", + "numpy >=1.11", + "pandas >=0.20", + "pathlib2", + "psycopg2", + "pyarrow >=0.6.0", + "pymysql", + "pytables >=3.0.0", + "python >=2.7,<2.8.0a0", + "python-graphviz", + "python-hdfs >=2.0.16", + "regex", + "setuptools", + "six", + "sqlalchemy", + "thrift <=0.9.3", + "thriftpy <=0.3.9", + "toolz" + ], + "license": "Apache 2.0", + "md5": "97119dc6bff32bf49bdd20aec72f3149", + "name": "ibis-framework", + "sha256": "0ca5e42719ad844086c0fd66cdbe9afaced0bdc9f30198f7379ad06327b5457b", + "size": 846985, + "subdir": "linux-64", + "timestamp": 1545242235398, + "version": "0.14.0" + }, + "ibis-framework-0.14.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "lz4", + "multipledispatch", + "numpy >=1.11", + "pandas >=0.20", + "psycopg2", + "pyarrow >=0.6.0", + "pymysql", + "pytables >=3.0.0", + "python >=3.10,<3.11.0a0", + "python-graphviz", + "python-hdfs >=2.0.16", + "regex", + "setuptools", + "six", + "sqlalchemy", + "toolz" + ], + "license": "Apache 2.0", + "md5": "f7ad536ffcf7026c5e9e0fe9f8b8ff86", + "name": "ibis-framework", + "sha256": "f6a7c4fb57ebaa74b6b25e0ddf4463d40038b02dd07a8aac9bf1004f90d288b3", + "size": 871831, + "subdir": "linux-64", + "timestamp": 1641558163172, + "version": "0.14.0" + }, + "ibis-framework-0.14.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "lz4", + "multipledispatch", + "numpy >=1.11", + "pandas >=0.20", + "psycopg2", + "pyarrow >=0.6.0", + "pymysql", + "pytables >=3.0.0", + "python >=3.6,<3.7.0a0", + "python-graphviz", + "python-hdfs >=2.0.16", + "regex", + "setuptools", + "six", + "sqlalchemy", + "toolz" + ], + "license": "Apache 2.0", + "md5": "00e36fb31927e44dda79dde49ddd3289", + "name": "ibis-framework", + "sha256": "75ce0a4c2d5993f32ba647305ff8dfcf0abe2e7f5cd556146fe0b4df332c18be", + "size": 856981, + "subdir": "linux-64", + "timestamp": 1545242271255, + "version": "0.14.0" + }, + "ibis-framework-0.14.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "lz4", + "multipledispatch", + "numpy >=1.11", + "pandas >=0.20", + "psycopg2", + "pyarrow >=0.6.0", + "pymysql", + "pytables >=3.0.0", + "python >=3.7,<3.8.0a0", + "python-graphviz", + "python-hdfs >=2.0.16", + "regex", + "setuptools", + "six", + "sqlalchemy", + "toolz" + ], + "license": "Apache 2.0", + "md5": "9bf3c8555b099fad98d7dc26c4f44650", + "name": "ibis-framework", + "sha256": "53165b0840844975059d7ce55f0d62e37a7f5c584e5323d88d4a7524880381c8", + "size": 860637, + "subdir": "linux-64", + "timestamp": 1545242272599, + "version": "0.14.0" + }, + "ibis-framework-1.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "lz4", + "multipledispatch", + "numpy >=1.11", + "pandas >=0.20", + "psycopg2", + "pyarrow >=0.6.0", + "pymysql", + "pytables >=3.0.0", + "python >=3.6,<3.7.0a0", + "python-graphviz", + "python-hdfs >=2.0.16", + "regex", + "setuptools", + "six", + "sqlalchemy", + "toolz" + ], + "license": "Apache 2.0", + "md5": "98d13b724b14c6ff68dc5b5cdbc2920c", + "name": "ibis-framework", + "sha256": "542fcca87a3f0b85bbea77af8aa791fcea5db655bbfe48f7f4739f48881e8eb0", + "size": 1034452, + "subdir": "linux-64", + "timestamp": 1600361257841, + "version": "1.3.0" + }, + "ibis-framework-1.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "lz4", + "multipledispatch", + "numpy >=1.11", + "pandas >=0.20", + "psycopg2", + "pyarrow >=0.6.0", + "pymysql", + "pytables >=3.0.0", + "python >=3.7,<3.8.0a0", + "python-graphviz", + "python-hdfs >=2.0.16", + "regex", + "setuptools", + "six", + "sqlalchemy", + "toolz" + ], + "license": "Apache 2.0", + "md5": "067cc61515486e4bc151c523200119f7", + "name": "ibis-framework", + "sha256": "0825c25f1e32a8f93095026684b7ac2e9850f2140e0d2bd5e9742a57e5522ae5", + "size": 1032730, + "subdir": "linux-64", + "timestamp": 1600361217475, + "version": "1.3.0" + }, + "ibis-framework-1.3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "lz4", + "multipledispatch", + "numpy >=1.11", + "pandas >=0.20", + "psycopg2", + "pyarrow >=0.6.0", + "pymysql", + "pytables >=3.0.0", + "python >=3.8,<3.9.0a0", + "python-graphviz", + "python-hdfs >=2.0.16", + "regex", + "setuptools", + "six", + "sqlalchemy", + "toolz" + ], + "license": "Apache 2.0", + "md5": "93de8794cd52f9d0a3f2f78b856320be", + "name": "ibis-framework", + "sha256": "3dc8a74e0130b4d0a0f8b7d4939a40e0d33c7fae0beb692083c32ce9af07ff1e", + "size": 1039599, + "subdir": "linux-64", + "timestamp": 1600361214588, + "version": "1.3.0" + }, + "icalendar-4.0.2-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a9bfe18bc45a43f0efcc8e051137264b", + "name": "icalendar", + "sha256": "ecfa61c890126ba28dc821575813d6ebb01b8dac670cccdc177c12349c2d1a4d", + "size": 101452, + "subdir": "linux-64", + "timestamp": 1531494963767, + "version": "4.0.2" + }, + "icalendar-4.0.2-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "7b16756fccbe0d6da47cb359e8fece32", + "name": "icalendar", + "sha256": "b5de7c0a9cce5b4b0b5baa192750e013a42bd176e33b73490d1c04d2f6ed48c6", + "size": 103631, + "subdir": "linux-64", + "timestamp": 1531495110459, + "version": "4.0.2" + }, + "icalendar-4.0.2-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b0f68ecac27fa51f690aed0d96550471", + "name": "icalendar", + "sha256": "1d89448a107d4ea5e22119de6f9fb772abd4128958e6f35011fe2e205ad9a5aa", + "size": 103106, + "subdir": "linux-64", + "timestamp": 1531495110822, + "version": "4.0.2" + }, + "icalendar-4.0.2-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9ab522a9e40461180cd0530f1d9ed939", + "name": "icalendar", + "sha256": "0a3dea820ed92665e6541175d608bce08756b2b201b039091c49afe52cbac086", + "size": 102676, + "subdir": "linux-64", + "timestamp": 1531495107278, + "version": "4.0.2" + }, + "icalendar-4.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e1a17001d53786a258146fa9a4a88abd", + "name": "icalendar", + "sha256": "0c5891ab9d8f4d1e20f601a4101318c63b383f8964aa0425d423a08eeab736cb", + "size": 102243, + "subdir": "linux-64", + "timestamp": 1539657757062, + "version": "4.0.3" + }, + "icalendar-4.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "3b4391df16b0af40509669d12d1c6325", + "name": "icalendar", + "sha256": "2ad51c4afc11042f34237a14f63ab3ff84b2aaef22d0e22f34bec2582a1c9052", + "size": 103806, + "subdir": "linux-64", + "timestamp": 1539657773796, + "version": "4.0.3" + }, + "icalendar-4.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "006180a6c0a680a90f0a351deaa9cf1b", + "name": "icalendar", + "sha256": "2ece37c8453b95086acdb9f60b8cfd6b62f0580bd80b8c39d4be6e73d91d1a74", + "size": 103349, + "subdir": "linux-64", + "timestamp": 1539657777559, + "version": "4.0.3" + }, + "icu-58.2-h211956c_0.tar.bz2": { + "build": "h211956c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "f2bcef3d781b1a70d5887a73324b5864", + "name": "icu", + "sha256": "3075c14d635a50d3097392d14ce457bb1b2bfc3db9460d398662b0358c8fc7da", + "size": 23618389, + "subdir": "linux-64", + "timestamp": 1505733580747, + "version": "58.2" + }, + "icu-58.2-h9c2bf20_1.tar.bz2": { + "build": "h9c2bf20_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "a29f6435b6dc57dadf81665d6957bcde", + "name": "icu", + "sha256": "b954fa8b8cc1b87a42d7ca4ab61946b86a59543669721f134be6950ce3671ad6", + "size": 23617371, + "subdir": "linux-64", + "timestamp": 1510863235474, + "version": "58.2" + }, + "icu-58.2-he6710b0_3.tar.bz2": { + "build": "he6710b0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "9213e0336e3a5216c989cfe52648412e", + "name": "icu", + "sha256": "bc2f45de45fba5aeb97e55cbbf68c1b4bdc49ac9982db27a7e871aaab66ca107", + "size": 23805906, + "subdir": "linux-64", + "timestamp": 1588026213084, + "version": "58.2" + }, + "icu-68.1-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "de8e4da8a0b6f9a27d934c452d5756e5", + "name": "icu", + "sha256": "974927ce77a880c97ff10854e8b947fd92bd211ebf4450c8b5b11a2e990f214e", + "size": 26530049, + "subdir": "linux-64", + "timestamp": 1611658295025, + "version": "68.1" + }, + "identify-2.5.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "ukkonen" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6eb713bc49b4011b4543e9eb69f49592", + "name": "identify", + "sha256": "9473553958dac4340fe4e571f960d9f13f0d41928900aec6c90bcc17896fd4d2", + "size": 103500, + "subdir": "linux-64", + "timestamp": 1663193251802, + "version": "2.5.5" + }, + "identify-2.5.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "ukkonen" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc423d5649f5f7b5beda9f5ed5b68974", + "name": "identify", + "sha256": "028a2b210325de0f49a62e5dabc0eb02cf175c96d5e9c9821b3ab343584d8b9e", + "size": 108700, + "subdir": "linux-64", + "timestamp": 1676844305369, + "version": "2.5.5" + }, + "identify-2.5.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "ukkonen" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37c977d0fd5e2287837bd925954269ec", + "name": "identify", + "sha256": "0e4c1436e3595cdc60e11d4471aa40d6e7503f52aa58202ef057e616f1aa278f", + "size": 101447, + "subdir": "linux-64", + "timestamp": 1663193211289, + "version": "2.5.5" + }, + "identify-2.5.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "ukkonen" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "806c00f734270cdd54d5694634b50af3", + "name": "identify", + "sha256": "fdc636d9b281caa39ef8b261857fccf4bc0f93b83db9b899753d72667516fadb", + "size": 101414, + "subdir": "linux-64", + "timestamp": 1663193306595, + "version": "2.5.5" + }, + "identify-2.5.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "ukkonen" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0114f1508372cb04572aff02ac80c94d", + "name": "identify", + "sha256": "9009669f83380d10786798ba38a0e735a0b64062905e13c22983aa14e67fae3d", + "size": 101555, + "subdir": "linux-64", + "timestamp": 1663193279927, + "version": "2.5.5" + }, + "idna-2.6-py27h5722d68_1.tar.bz2": { + "build": "py27h5722d68_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD Like", + "md5": "d90055a7b08ca188d2d8841ec7cf2d23", + "name": "idna", + "sha256": "f661fa246140bbd9f66cc9b35049722c92b0185cf44c214b2b3594105b7971d1", + "size": 124748, + "subdir": "linux-64", + "timestamp": 1505691711574, + "version": "2.6" + }, + "idna-2.6-py35h8605a33_1.tar.bz2": { + "build": "py35h8605a33_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD Like", + "md5": "928f97e845bc28a0aae3ca55df5aad14", + "name": "idna", + "sha256": "64cf5c56ae666b79cc57a7845310d8c5919382c12bbdc6361a5a406e92436a28", + "size": 125898, + "subdir": "linux-64", + "timestamp": 1505691723368, + "version": "2.6" + }, + "idna-2.6-py36h82fb2a8_1.tar.bz2": { + "build": "py36h82fb2a8_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD Like", + "md5": "79f798ec15f0df45d85fcf83339f6895", + "name": "idna", + "sha256": "cf1af50445e7efbcee5caec9a34ad1dab17b5b4b19ad7802b02d761b6a07ac43", + "size": 125025, + "subdir": "linux-64", + "timestamp": 1505691735281, + "version": "2.6" + }, + "idna-2.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD Like", + "md5": "f5bdecc47fc1733472cdcaa7d2a03f70", + "name": "idna", + "sha256": "98fd8cf2ad2b0f015418b0aaab544e396e0d5cad666a4b55e2d8fb2fc8484977", + "size": 135004, + "subdir": "linux-64", + "timestamp": 1528923514438, + "version": "2.7" + }, + "idna-2.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD Like", + "md5": "a8ac935471a23fbad9554cd104fd2b6f", + "name": "idna", + "sha256": "73193f5cddf0fc6c3a72821fbea4c30c128bdb2e7651b83e6479f645c16adaa0", + "size": 136230, + "subdir": "linux-64", + "timestamp": 1528923507756, + "version": "2.7" + }, + "idna-2.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD Like", + "md5": "52339ccd1ee0792a593a64b00245788e", + "name": "idna", + "sha256": "0b0aebf35d868b4163a944e93ac71f59cf7429c7e389a27e05b59b723ca83fa2", + "size": 134897, + "subdir": "linux-64", + "timestamp": 1528923498940, + "version": "2.7" + }, + "idna-2.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD Like", + "md5": "175bf6e6dbb2782dae983b39461b60c0", + "name": "idna", + "sha256": "5b49e03e9d9d0be2b93b3545fa0e967ffa85b63ffc7b9e4a041c54a62d3f7a42", + "size": 101529, + "subdir": "linux-64", + "timestamp": 1531342378046, + "version": "2.7" + }, + "idna-2.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD Like", + "md5": "8128b1c61408b43fcb6f7b9013ebe7d5", + "name": "idna", + "sha256": "668d8ae0ab84f5206b3deb3b9c429678074f0f793ef511bef196ca9d5c2f7c14", + "size": 136544, + "subdir": "linux-64", + "timestamp": 1545082875447, + "version": "2.8" + }, + "idna-2.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD Like", + "md5": "c249f4e0d80f8dc4990298300135cd01", + "name": "idna", + "sha256": "38069074998e30190d5bf8a6e8a36f3bb5e8c593b31565e80ad1be4970d08588", + "size": 136225, + "subdir": "linux-64", + "timestamp": 1545082944493, + "version": "2.8" + }, + "idna-2.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD Like", + "md5": "96d99d20df365f24497d35850ec0f808", + "name": "idna", + "sha256": "11cdd1f5527e6f9612b275339fade6a48f8c24bfdc87395adbea611bf9ec56ca", + "size": 102943, + "subdir": "linux-64", + "timestamp": 1545082953868, + "version": "2.8" + }, + "idna-2.8-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD Like", + "md5": "dfb67c8820f3ac652b0c6dff19481c2b", + "name": "idna", + "sha256": "5313c985cb346e17b98648a3f1abb8250729872dbd733ad6f121178e7c9a79c2", + "size": 108377, + "subdir": "linux-64", + "timestamp": 1575486166738, + "version": "2.8" + }, + "idna-2.8-py38_1000.tar.bz2": { + "build": "py38_1000", + "build_number": 1000, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD Like", + "md5": "602deef63dbd7e543274a9aa6a844925", + "name": "idna", + "sha256": "28c648b4cda17fdd03e7a3d93a387566c76f208a8f3a2d4b35941b8cdc7bad20", + "size": 105579, + "subdir": "linux-64", + "timestamp": 1572512253707, + "version": "2.8" + }, + "idna-3.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aaedbfe2ce4396b9ae3598d8b1abb21d", + "name": "idna", + "sha256": "e71243f2719dce357ad12b215c23257a3ea353e8fabe954112ca4a204665a5b6", + "size": 115993, + "subdir": "linux-64", + "timestamp": 1666125633476, + "version": "3.4" + }, + "idna-3.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c4aa1c5005412821f81fa13e4cd78514", + "name": "idna", + "sha256": "1b65cda7fbe1e9300a5aa96c6098788f61d4389fc5bdc2beab12d27ac62102a9", + "size": 123676, + "subdir": "linux-64", + "timestamp": 1676822710633, + "version": "3.4" + }, + "idna-3.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9fa85ba4b6f80e326e8b0019f5461242", + "name": "idna", + "sha256": "e2226f1eb58f96c9b13f4a39e3b834a528d0db83ef279f929b7dcd8db92f40f1", + "size": 109773, + "subdir": "linux-64", + "timestamp": 1666125686415, + "version": "3.4" + }, + "idna-3.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22a39ae9bbf0f9dab8b7c7dafed3d454", + "name": "idna", + "sha256": "78c6e445d2365147307ab5631fb82bfb9f929ca0fe8849d7d7f4991e991fe125", + "size": 111304, + "subdir": "linux-64", + "timestamp": 1666125659782, + "version": "3.4" + }, + "idna-3.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1eb52f9f45cea2fb9ce27b19f990160e", + "name": "idna", + "sha256": "4ef0e1d11cf14da72ed8388d7e6d094e306889cb538dcd6aa02e9dd08ff10dbf", + "size": 110793, + "subdir": "linux-64", + "timestamp": 1666125606878, + "version": "3.4" + }, + "idna_ssl-1.0.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e6e419a663d6ea064a8e589c72c8caa", + "name": "idna_ssl", + "sha256": "45009ed66c77eb97b8ce14e729c1cd4b1a70cc49194fb89e23263ed0769e5180", + "size": 6549, + "subdir": "linux-64", + "timestamp": 1520920996598, + "version": "1.0.1" + }, + "idna_ssl-1.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f0def94b1cc73d61dd7e277afd7238f3", + "name": "idna_ssl", + "sha256": "e8b0e125f39ef36e3bfc81e9201cedc6651000cd75841c4c011d5d31e96cce65", + "size": 6525, + "subdir": "linux-64", + "timestamp": 1520920966171, + "version": "1.0.1" + }, + "idna_ssl-1.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "05a42d51f130fb7da1d2f5258bde0d57", + "name": "idna_ssl", + "sha256": "08baebae82fbe66e868b1593a690cf3e6400587709993db9edefd1470501c96e", + "size": 7572, + "subdir": "linux-64", + "timestamp": 1640790945882, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0986cfc504a9fac165520a892db1fbc", + "name": "idna_ssl", + "sha256": "04d8f1587d426ba2f2e429353738a6462d5c9ac7d5cc164fc70b81850ee6b929", + "size": 8299, + "subdir": "linux-64", + "timestamp": 1676852742992, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "24908cd25a7826a4d7de413625a4e7d3", + "name": "idna_ssl", + "sha256": "9e667c8766f971c4a53a99e4562c9d340188cc9b38e7cd18cc5e289bf91e58d5", + "size": 6570, + "subdir": "linux-64", + "timestamp": 1535510959667, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a827baa4b47e657ef01680fdfef157cc", + "name": "idna_ssl", + "sha256": "5e7f385d1d1ad86b882fbef1cdb22c649dc374bd3d65c03037916cba3f7742d5", + "size": 6558, + "subdir": "linux-64", + "timestamp": 1535510962043, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "26d1348cab53e00036b8e9e8e83dd7e5", + "name": "idna_ssl", + "sha256": "f71b2b663ded3f6746159c97aa0a8b9c6bf47f4c7777f60454aae6a791633865", + "size": 8370, + "subdir": "linux-64", + "timestamp": 1611752521045, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48ed179feb5e1bc41bcd496bf991b950", + "name": "idna_ssl", + "sha256": "77e9c73e169df1ff64cc58b6d37cdaa346a5255c008cbc0e3b36063904ad6468", + "size": 6546, + "subdir": "linux-64", + "timestamp": 1535543696935, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py37_1000.tar.bz2": { + "build": "py37_1000", + "build_number": 1000, + "depends": [ + "idna >=2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eaa46eea1de7e9f3b8c5be62cd6c7c5d", + "name": "idna_ssl", + "sha256": "6bbcbd3693093fcfc289b8ecd13a09bf5532266d175d21daed5b5eae02e29e4b", + "size": 6801, + "subdir": "linux-64", + "timestamp": 1594359721583, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "753819708094a9b38dbf75b25bdc848b", + "name": "idna_ssl", + "sha256": "65b428ec3fb033493867c8d534910b7587b215ac3919a75b569143d896adab56", + "size": 8360, + "subdir": "linux-64", + "timestamp": 1611752521047, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "546c7819150e95132dc668632ca3af59", + "name": "idna_ssl", + "sha256": "86cb5a6e631f889ddf7237215c2e23353231294d4cd51e4e289382e40525a3cd", + "size": 7436, + "subdir": "linux-64", + "timestamp": 1573469630319, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c6a066478009798fa83c5a8de47a0fe", + "name": "idna_ssl", + "sha256": "5d60194cf966acd066d4a29512346a225db21eeb6ac5e414d17e29f1edc6884e", + "size": 8358, + "subdir": "linux-64", + "timestamp": 1611752500343, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6eb9230d795234792315df47a0929e31", + "name": "idna_ssl", + "sha256": "d4433bc631cbae73c6980ce2589a1c92e076cec8c9e675ce604f029de2a466a8", + "size": 8396, + "subdir": "linux-64", + "timestamp": 1611752520139, + "version": "1.1.0" + }, + "ijson-3.1.4-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "yajl" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a567244f6ec6eff48d50e8bbef7922c0", + "name": "ijson", + "sha256": "5dbc41f686582b23ae9e81aa378f412e2e6ddfb6b0fa769a50bd10e22006757b", + "size": 119920, + "subdir": "linux-64", + "timestamp": 1655384141822, + "version": "3.1.4" + }, + "ijson-3.1.4-py311h5eee18b_1.tar.bz2": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "yajl" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fb36e973d7609e0f7580be67e1e2ac4a", + "name": "ijson", + "sha256": "9f5f43410422bc8eab653657cf122fc8322a192cb098115e19219df1a8ef38e5", + "size": 67096, + "subdir": "linux-64", + "timestamp": 1679340176418, + "version": "3.1.4" + }, + "ijson-3.1.4-py37h7f8727e_1.tar.bz2": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "yajl" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f3cb5d7b606bfa9af7a69b350e99607e", + "name": "ijson", + "sha256": "122f36c29481ff10aa6c163e4a3b289d16d2f3d58eb3c3ba95f1682d09a9d5d7", + "size": 55585, + "subdir": "linux-64", + "timestamp": 1655384170860, + "version": "3.1.4" + }, + "ijson-3.1.4-py38h7f8727e_1.tar.bz2": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "yajl" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "17696714a586f6087e069af8206340d7", + "name": "ijson", + "sha256": "15d499bb26fccb92cdc606a0a5e25d4de26aeb2c505fbb2b2f8e5ac709f609d6", + "size": 56431, + "subdir": "linux-64", + "timestamp": 1655384199670, + "version": "3.1.4" + }, + "ijson-3.1.4-py39h7f8727e_1.tar.bz2": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "yajl" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b3888e65b88dc7c487a7b2007bea6d35", + "name": "ijson", + "sha256": "99b3dc0886d9e3e780d0bb9c4a34721b461c0a9e8aa9f2f25fdf6abcaacf006a", + "size": 56372, + "subdir": "linux-64", + "timestamp": 1655384101163, + "version": "3.1.4" + }, + "imagecodecs-2020.5.30-py36h567f118_1.tar.bz2": { + "build": "py36h567f118_1", + "build_number": 1, + "depends": [ + "blosc >=1.19.0,<2.0a0", + "brotli >=1.0.7,<1.1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.2,<1.10.0a0", + "numpy >=1.15.4,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.4,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb2e805b5aea01e813d5a14108a1c70d", + "name": "imagecodecs", + "sha256": "28cd2f32844ce4b64c3aae1b997ff46c2054505d38490db7f054890e84b6e904", + "size": 6303814, + "subdir": "linux-64", + "timestamp": 1593454003151, + "version": "2020.5.30" + }, + "imagecodecs-2020.5.30-py36hfa7d478_2.tar.bz2": { + "build": "py36hfa7d478_2", + "build_number": 2, + "depends": [ + "blosc >=1.20.1,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.2,<1.10.0a0", + "numpy >=1.15.4,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b40de92b8be3f84bc6130049e6dc18cd", + "name": "imagecodecs", + "sha256": "9bc288fa38b3e32b097c2fdb6c3fe82ff0bd4001199e02e1759132b7469f1c0e", + "size": 6354326, + "subdir": "linux-64", + "timestamp": 1603270701716, + "version": "2020.5.30" + }, + "imagecodecs-2020.5.30-py37h567f118_1.tar.bz2": { + "build": "py37h567f118_1", + "build_number": 1, + "depends": [ + "blosc >=1.19.0,<2.0a0", + "brotli >=1.0.7,<1.1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.2,<1.10.0a0", + "numpy >=1.15.4,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.4,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "371ac77cfc1ae70f26a573e37e26e0e1", + "name": "imagecodecs", + "sha256": "9a0463bbae7f0a50aea9ef42f25806a51873cb0ac1092c1788a07d0fd9ace448", + "size": 6373451, + "subdir": "linux-64", + "timestamp": 1593453966719, + "version": "2020.5.30" + }, + "imagecodecs-2020.5.30-py37hfa7d478_2.tar.bz2": { + "build": "py37hfa7d478_2", + "build_number": 2, + "depends": [ + "blosc >=1.20.1,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.2,<1.10.0a0", + "numpy >=1.15.4,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "08b33485de0afeb909f650bdd77d4bd6", + "name": "imagecodecs", + "sha256": "810897b9e543ca2ba13842809690378422ddef6ad8fecb25be9c0786588e1d19", + "size": 6360929, + "subdir": "linux-64", + "timestamp": 1603270678223, + "version": "2020.5.30" + }, + "imagecodecs-2020.5.30-py38h567f118_1.tar.bz2": { + "build": "py38h567f118_1", + "build_number": 1, + "depends": [ + "blosc >=1.19.0,<2.0a0", + "brotli >=1.0.7,<1.1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.2,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.4,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a95dad7eed54709ad9cdef4666b62e0f", + "name": "imagecodecs", + "sha256": "f4288461cc15ffa1bd2a555a9b7c983d821ceea591f0ac08f1693e72d8b6973f", + "size": 6439253, + "subdir": "linux-64", + "timestamp": 1593453995153, + "version": "2020.5.30" + }, + "imagecodecs-2020.5.30-py38hfa7d478_2.tar.bz2": { + "build": "py38hfa7d478_2", + "build_number": 2, + "depends": [ + "blosc >=1.20.1,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.2,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38b77242236a80a7c5cb1b26fb41bd09", + "name": "imagecodecs", + "sha256": "421a73bd93cd560fdc78c814d1a3a7418187f649bf260976b580c2c29d346410", + "size": 6448094, + "subdir": "linux-64", + "timestamp": 1603270690952, + "version": "2020.5.30" + }, + "imagecodecs-2020.5.30-py39h581e88b_2.tar.bz2": { + "build": "py39h581e88b_2", + "build_number": 2, + "depends": [ + "blosc >=1.20.1,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.2,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ecbc94d294aec6a375e69087a30b574b", + "name": "imagecodecs", + "sha256": "91aca74c466d744684eba00349903304a25816b5112d145edd527c33a1d46697", + "size": 6485496, + "subdir": "linux-64", + "timestamp": 1608062001498, + "version": "2020.5.30" + }, + "imagecodecs-2021.1.11-py37h581e88b_1.tar.bz2": { + "build": "py37h581e88b_1", + "build_number": 1, + "depends": [ + "blosc >=1.20.1,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3c03be1ee8e07c9f9b056b65a7a02128", + "name": "imagecodecs", + "sha256": "664a38a02922476e29b8606b7605d8ca54e5f868e6699e8533c3534f425b8221", + "size": 6704747, + "subdir": "linux-64", + "timestamp": 1611258496132, + "version": "2021.1.11" + }, + "imagecodecs-2021.1.11-py38h581e88b_1.tar.bz2": { + "build": "py38h581e88b_1", + "build_number": 1, + "depends": [ + "blosc >=1.20.1,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "856d056ba96779732ac2db95a44b781b", + "name": "imagecodecs", + "sha256": "cf17061a6366ac819342d14d1421017cc702d3cee3c187478a4dc463109a636b", + "size": 6773240, + "subdir": "linux-64", + "timestamp": 1611258357258, + "version": "2021.1.11" + }, + "imagecodecs-2021.1.11-py39h581e88b_1.tar.bz2": { + "build": "py39h581e88b_1", + "build_number": 1, + "depends": [ + "blosc >=1.20.1,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "26154dadef5db227562a2ed8fa79628a", + "name": "imagecodecs", + "sha256": "70dd7d3c9a7dba2ae558e467927126241f3aca008ee1307357d2d4d8f492e327", + "size": 6747627, + "subdir": "linux-64", + "timestamp": 1611258475326, + "version": "2021.1.11" + }, + "imagecodecs-2021.3.31-py37h581e88b_0.tar.bz2": { + "build": "py37h581e88b_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f2170fefe4318215258aa0816f9c9260", + "name": "imagecodecs", + "sha256": "529911456523ec7dffbfd15e619db9f900ca9b935aadae72424a702416e2ff12", + "size": 6965562, + "subdir": "linux-64", + "timestamp": 1617993657920, + "version": "2021.3.31" + }, + "imagecodecs-2021.3.31-py38h581e88b_0.tar.bz2": { + "build": "py38h581e88b_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3268c3ae6c4387cdf39ea9649a6f86d5", + "name": "imagecodecs", + "sha256": "668735f2ab811a61fb4b34263b2b29e230e9678df8942cc92b0424b7380398c1", + "size": 7134448, + "subdir": "linux-64", + "timestamp": 1617996579272, + "version": "2021.3.31" + }, + "imagecodecs-2021.3.31-py39h581e88b_0.tar.bz2": { + "build": "py39h581e88b_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa22317677f4866d7b2718193764b577", + "name": "imagecodecs", + "sha256": "3c79bc7e780f88326fd4cbd372acdcb1b9088bd9895e0e8a59e99370f78fdd4b", + "size": 7056128, + "subdir": "linux-64", + "timestamp": 1617996588573, + "version": "2021.3.31" + }, + "imagecodecs-2021.4.28-py37h581e88b_0.tar.bz2": { + "build": "py37h581e88b_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "015e770da1a4a9174ac0df4c021652c1", + "name": "imagecodecs", + "sha256": "6ba75bf0cecad6b793c47582035b36ba50ead48f1bc89cbdf90ed6c6026ade61", + "size": 6997728, + "subdir": "linux-64", + "timestamp": 1621408170398, + "version": "2021.4.28" + }, + "imagecodecs-2021.4.28-py38h581e88b_0.tar.bz2": { + "build": "py38h581e88b_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c874c5f79142bb9d055f619d593284f3", + "name": "imagecodecs", + "sha256": "4efb083d9bc145377e79c98257441195a2dbb8985357da63a92179d3522d26ab", + "size": 7101717, + "subdir": "linux-64", + "timestamp": 1621408155389, + "version": "2021.4.28" + }, + "imagecodecs-2021.4.28-py39h581e88b_0.tar.bz2": { + "build": "py39h581e88b_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "78b2cd8b4a11c8f9ee9550dfd050b315", + "name": "imagecodecs", + "sha256": "40c3b6d07f247609f86670bf0dc4e4b58eb505ec51a666afaaeca4300d9d1243", + "size": 7134027, + "subdir": "linux-64", + "timestamp": 1621408148552, + "version": "2021.4.28" + }, + "imagecodecs-2021.6.8-py37h20f8b18_1.tar.bz2": { + "build": "py37h20f8b18_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9d,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88ba42426a5f5eeca5896b1e18f4828d", + "name": "imagecodecs", + "sha256": "2fdb65e801dd9dd7e3c1c5ffbd08c0692527fa4901f217ce24304cd596db4d52", + "size": 7085991, + "subdir": "linux-64", + "timestamp": 1634837056342, + "version": "2021.6.8" + }, + "imagecodecs-2021.6.8-py37h581e88b_0.tar.bz2": { + "build": "py37h581e88b_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e90f40aa3f218fc428446f49c11d14cd", + "name": "imagecodecs", + "sha256": "a729e7f5fdbcebdb9b49795c8e8c221c45f00d9027820f8d157662b585c4a81e", + "size": 7153794, + "subdir": "linux-64", + "timestamp": 1623228585001, + "version": "2021.6.8" + }, + "imagecodecs-2021.6.8-py38h20f8b18_1.tar.bz2": { + "build": "py38h20f8b18_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9d,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4aba62e1dc0fe6c5065b9e4d571e122a", + "name": "imagecodecs", + "sha256": "a392d258a97661e81dec59be39c6d68134dd84f0d9985728c04d3bfb8dc3541f", + "size": 7207664, + "subdir": "linux-64", + "timestamp": 1634825654364, + "version": "2021.6.8" + }, + "imagecodecs-2021.6.8-py38h581e88b_0.tar.bz2": { + "build": "py38h581e88b_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0df4c2688f8bbee98cede018eed65b21", + "name": "imagecodecs", + "sha256": "39da4d6d1bbb60854a58e23ffb7ef4f7797154362ec34faccfc3f19630324f05", + "size": 7253705, + "subdir": "linux-64", + "timestamp": 1623223093131, + "version": "2021.6.8" + }, + "imagecodecs-2021.6.8-py39h20f8b18_1.tar.bz2": { + "build": "py39h20f8b18_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9d,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "269c0dfe189c738bb3b2dbc28d8c557c", + "name": "imagecodecs", + "sha256": "411bec0256a6004ed51298202f1bb3e61cd6cb6438aef2d9f175dae8c505e9a1", + "size": 7178509, + "subdir": "linux-64", + "timestamp": 1634843997131, + "version": "2021.6.8" + }, + "imagecodecs-2021.6.8-py39h581e88b_0.tar.bz2": { + "build": "py39h581e88b_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "509b5ee4aa1a55ead7b7140dae2d8622", + "name": "imagecodecs", + "sha256": "fc09ab2540fef12db8d251953818046b4ead2b080181f8ecba4d6f774179ecde", + "size": 7215510, + "subdir": "linux-64", + "timestamp": 1623227982821, + "version": "2021.6.8" + }, + "imagecodecs-2021.8.26-py310h2a2ad71_0.tar.bz2": { + "build": "py310h2a2ad71_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9d,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.21.2,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "25394feced7f6a5566591dc58b14b5d3", + "name": "imagecodecs", + "sha256": "a9ab63b4b5e9272d08fc2c9e97cd18c74f70e1d406950cddb4b440e8d5e2fd7b", + "size": 16358007, + "subdir": "linux-64", + "timestamp": 1642084705147, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py310h46e8fbd_2.tar.bz2": { + "build": "py310h46e8fbd_2", + "build_number": 2, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.5.0,<5.0a0", + "libwebp-base >=1.2.4,<2.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.21.5,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.10,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fcaada25d6dcccbd6bb6d4b5b4564872", + "name": "imagecodecs", + "sha256": "acd28092d7d4fb3ad7c1ac9ff58d7875dc9752e7b32dfb0aa1fd28a4fba27e7a", + "size": 7235606, + "subdir": "linux-64", + "timestamp": 1677576900926, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py310hecf7e94_1.tar.bz2": { + "build": "py310hecf7e94_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.21.5,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.6,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3cedd7c0a92a2838037299b4c0bec243", + "name": "imagecodecs", + "sha256": "5e5bbc3c3eb998564aec1c228c7a8fd2b426516b8d06085c6629698fe5614e8e", + "size": 18116090, + "subdir": "linux-64", + "timestamp": 1664563374130, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py311h1307a82_0.tar.bz2": { + "build": "py311h1307a82_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.22.3,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.11,<3.12.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.10,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "86506250e3b8f699cf2d8bbb9a8715ad", + "name": "imagecodecs", + "sha256": "55f9e2ab5c79da61707e16cf303b8e74b48ff4f4f4dfc5bf010fc23550015168", + "size": 7229674, + "subdir": "linux-64", + "timestamp": 1676919123830, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py311hb63acbb_2.tar.bz2": { + "build": "py311hb63acbb_2", + "build_number": 2, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.39,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.5.0,<5.0a0", + "libwebp-base >=1.2.4,<2.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.22.3,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.11,<3.12.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.10,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "13c62c6e3d0d7470d56b7bd80990cdb3", + "name": "imagecodecs", + "sha256": "b89ce10aa75bfb49fe58fe1235aff09d7f642b9712d07c9d3df5003471323f4f", + "size": 7228714, + "subdir": "linux-64", + "timestamp": 1679336463587, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py37h4cda21f_0.tar.bz2": { + "build": "py37h4cda21f_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9d,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "92a47b776366c9ddd8076f78e26dfe7f", + "name": "imagecodecs", + "sha256": "4b34007a27ec43b5e5a44fd020488ed6e8949085f40fd30e074ec8130efe4530", + "size": 7230312, + "subdir": "linux-64", + "timestamp": 1635529358467, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py37hf0132c2_1.tar.bz2": { + "build": "py37hf0132c2_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.6,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0465495a15c23cf34dda4d7dd884fb4e", + "name": "imagecodecs", + "sha256": "8ea7b7bbae4192c8835b01475d34e8a04714b15504fe828be66e4fe97e7fd482", + "size": 7211554, + "subdir": "linux-64", + "timestamp": 1664562965130, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py37hfcb8610_2.tar.bz2": { + "build": "py37hfcb8610_2", + "build_number": 2, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.5.0,<5.0a0", + "libwebp-base >=1.2.4,<2.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.10,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "670fed1a024d1a52d35786f976e483a8", + "name": "imagecodecs", + "sha256": "eb1186cb582586213351def695aabaf80828f4063968f55d040bf65cc5e9926c", + "size": 7206878, + "subdir": "linux-64", + "timestamp": 1677577508385, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py38h4cda21f_0.tar.bz2": { + "build": "py38h4cda21f_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9d,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a6e8b465c0a84c259d774abf31eea18b", + "name": "imagecodecs", + "sha256": "2c78cda50769c6f887eb2ad8736ffda56cad9712637fe76b50de38bb5d9ce998", + "size": 7342540, + "subdir": "linux-64", + "timestamp": 1635529352441, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py38hf0132c2_1.tar.bz2": { + "build": "py38hf0132c2_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.6,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9400677eb7f53565970a6f75c80bce49", + "name": "imagecodecs", + "sha256": "bfb07729449b9f6d7193eff67602a1a89cf64e920d9bc4a20c2d5d3706947775", + "size": 7329152, + "subdir": "linux-64", + "timestamp": 1664562581922, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py38hfcb8610_2.tar.bz2": { + "build": "py38hfcb8610_2", + "build_number": 2, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.5.0,<5.0a0", + "libwebp-base >=1.2.4,<2.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.10,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8ebf67c760b11aedbb295f98f7d4eea5", + "name": "imagecodecs", + "sha256": "c69921bf5e3234138120e140c2b601118da7e448d19e2b312fe9586a840d3227", + "size": 7320745, + "subdir": "linux-64", + "timestamp": 1677577200072, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py39h4cda21f_0.tar.bz2": { + "build": "py39h4cda21f_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9d,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5fc941b80d14d863a25b7623f3e812e1", + "name": "imagecodecs", + "sha256": "b83be438a079b319f05a566a3d724d25644037a8ffd10cf6d9c8cbd64fad07f2", + "size": 7334228, + "subdir": "linux-64", + "timestamp": 1635529364456, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py39hf0132c2_1.tar.bz2": { + "build": "py39hf0132c2_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.6,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cde289abcb860a5b5533198cae49e239", + "name": "imagecodecs", + "sha256": "e9c8acfcb1201fa69f19666644141612d213f02bb452dee01bd4a8a6db7c66ec", + "size": 7269451, + "subdir": "linux-64", + "timestamp": 1664562215324, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py39hfcb8610_2.tar.bz2": { + "build": "py39hfcb8610_2", + "build_number": 2, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.5.0,<5.0a0", + "libwebp-base >=1.2.4,<2.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.10,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3f74993c524bcecbe1ea8463db2d865e", + "name": "imagecodecs", + "sha256": "5d3e1c6bf218523e4ac7d8312c32d82ee275f23a55770450118815381ae93f67", + "size": 7291428, + "subdir": "linux-64", + "timestamp": 1677577808062, + "version": "2021.8.26" + }, + "imagehash-4.3.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.10,<3.11.0a0", + "pywavelets", + "scipy" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "bd7cc72e085bb40f1d42142febbd7623", + "name": "imagehash", + "sha256": "8bbb6a01f1ea9fc7790e6c88af5139826af5631b6d848da4e19d633b12ca59e6", + "size": 308876, + "subdir": "linux-64", + "timestamp": 1679418774806, + "version": "4.3.1" + }, + "imagehash-4.3.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.11,<3.12.0a0", + "pywavelets", + "scipy" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "53c74ddc55c3ba147e217d5269df1fa4", + "name": "imagehash", + "sha256": "604448d48ffe2bbc7ed4b77658d0b996090555a8d809419059d7b9984be71fe0", + "size": 314651, + "subdir": "linux-64", + "timestamp": 1679418704301, + "version": "4.3.1" + }, + "imagehash-4.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.8,<3.9.0a0", + "pywavelets", + "scipy" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "497d52110c0b63532b06abc738e52a9a", + "name": "imagehash", + "sha256": "c43fab81cc2d6300d9d0ef2f10154a718b1ceabf6c113c0972892da91c2b9698", + "size": 308872, + "subdir": "linux-64", + "timestamp": 1679418740480, + "version": "4.3.1" + }, + "imagehash-4.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.9,<3.10.0a0", + "pywavelets", + "scipy" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "171c4ff00ab118d1c0150659902dff34", + "name": "imagehash", + "sha256": "ea7f5def715971f8d835fdb0e8c658f21cfea7a7887e35cb283516eca33092c6", + "size": 308758, + "subdir": "linux-64", + "timestamp": 1679418808344, + "version": "4.3.1" + }, + "imageio-2.19.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=8.3.2", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f6515ec31c0ec92bb05fbb0b143f27c1", + "name": "imageio", + "sha256": "212ba2c4633eff7080e378da6623f210f03705c13bffc805458344ef424f162e", + "size": 3577506, + "subdir": "linux-64", + "timestamp": 1658785153453, + "version": "2.19.3" + }, + "imageio-2.19.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=8.3.2", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "569587232fabdde739f263fbc331c817", + "name": "imageio", + "sha256": "3497161baf9506c59b1870296f56ed87ac6af5d5b1e9462f06ddca5a8211a188", + "size": 3722684, + "subdir": "linux-64", + "timestamp": 1677083672444, + "version": "2.19.3" + }, + "imageio-2.19.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=8.3.2", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "1d55347dedf38d0f346808439e1de379", + "name": "imageio", + "sha256": "a8109fcb023d1076b60259f3cbc413bfc44569f702edb5185908adfda122b4d9", + "size": 3563338, + "subdir": "linux-64", + "timestamp": 1658785072600, + "version": "2.19.3" + }, + "imageio-2.19.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=8.3.2", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e4a15cacfcf670a5b907c0243f9de6bb", + "name": "imageio", + "sha256": "38541f86e4f117a62dd426b28112c66d8c6a334ba8d2a121b2623799e697b9da", + "size": 3564945, + "subdir": "linux-64", + "timestamp": 1658785109705, + "version": "2.19.3" + }, + "imageio-2.19.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=8.3.2", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8aabd5e0ca1ee6ab51901769a12d1c88", + "name": "imageio", + "sha256": "bc11205b6a4fc17a2d148044a127bf5d38b4f10c3676e115fe9174152e597860", + "size": 3565414, + "subdir": "linux-64", + "timestamp": 1658785185768, + "version": "2.19.3" + }, + "imageio-2.2.0-py27hf108a7f_0.tar.bz2": { + "build": "py27hf108a7f_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "315d03c0c64dfcc0317d2338fb0fd648", + "name": "imageio", + "sha256": "af0c967c3d0bd57652cfbf4e634543c7185abab625977a8f58507ad709211a16", + "size": 3355176, + "subdir": "linux-64", + "timestamp": 1505744538012, + "version": "2.2.0" + }, + "imageio-2.2.0-py35hd0a6de2_0.tar.bz2": { + "build": "py35hd0a6de2_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "5611989fcdd81497b66c8c2a57699701", + "name": "imageio", + "sha256": "836b0f619aeee8ae22abb5aa22a0a3d0f951701779e036c5ad14f099bd4b4f60", + "size": 3365583, + "subdir": "linux-64", + "timestamp": 1505744554535, + "version": "2.2.0" + }, + "imageio-2.2.0-py36he555465_0.tar.bz2": { + "build": "py36he555465_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "8208cdda7a1ca9e8d2e03f50ddac5c80", + "name": "imageio", + "sha256": "5513efc0b7a21245af982b341742df9b7ef2355eafc3655ed3145bea31003c18", + "size": 3367186, + "subdir": "linux-64", + "timestamp": 1505744571122, + "version": "2.2.0" + }, + "imageio-2.26.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=8.3.2", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "0556451e67cb7b8e1885c82d81e05d95", + "name": "imageio", + "sha256": "38e7f696adc37488dc85dbd1459b0e80a2ed32595ab2c66ddd079c870324898a", + "size": 3584477, + "subdir": "linux-64", + "timestamp": 1677879669662, + "version": "2.26.0" + }, + "imageio-2.26.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=8.3.2", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8caa9bb3a4ccec5f69d0ce699f966bf7", + "name": "imageio", + "sha256": "7d1a19bd3bc4d4ccebf4fd5f0e520637586782af7e859db6f41b9fe71841cae3", + "size": 3767585, + "subdir": "linux-64", + "timestamp": 1677869340419, + "version": "2.26.0" + }, + "imageio-2.26.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=8.3.2", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ef0d5e4e7253e9cf543ef9ceaca60272", + "name": "imageio", + "sha256": "7cdaabcfc772d74e529c544ca18c35a81c5064567ea30f2efc3732b8c2decbc1", + "size": 3569033, + "subdir": "linux-64", + "timestamp": 1677879594578, + "version": "2.26.0" + }, + "imageio-2.26.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=8.3.2", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "fcfc3ce34c8c644cb91a01e22d310306", + "name": "imageio", + "sha256": "56d4896e84271be64a14e6b7989c5f364ecb07e1b0c0f606a86890eb742ecfd8", + "size": 3568683, + "subdir": "linux-64", + "timestamp": 1677879633168, + "version": "2.26.0" + }, + "imageio-2.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "a54c0d105fa31f6fbd2d22a385166bcc", + "name": "imageio", + "sha256": "f5424a663dd8555f90b8e0ecd5cd82522bd9b91591e812ebe305e8c2ffc5a622", + "size": 3442936, + "subdir": "linux-64", + "timestamp": 1522082081812, + "version": "2.3.0" + }, + "imageio-2.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "f0f1b2b8ce453ad86e05599d264d8872", + "name": "imageio", + "sha256": "05eb8f8dd7cae6639cce12441ae9152fafcb6acc54ed483d3bc99703809775af", + "size": 3438950, + "subdir": "linux-64", + "timestamp": 1522082097340, + "version": "2.3.0" + }, + "imageio-2.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "680f697935c8e63d44a273f18aa9cc5f", + "name": "imageio", + "sha256": "eed503385493d43b31b2982abe609f33fbae6b044894f254dde9866bac94b649", + "size": 3432552, + "subdir": "linux-64", + "timestamp": 1522082099186, + "version": "2.3.0" + }, + "imageio-2.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "8e8f1cd7bea04b658eddccc2f17ac926", + "name": "imageio", + "sha256": "2cd7373d49022e9ae7c6ce3e7eb698b2a2d68365a4cf168ee911cf5b453b9bd5", + "size": 3429940, + "subdir": "linux-64", + "timestamp": 1530793146155, + "version": "2.3.0" + }, + "imageio-2.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "a71f3b084806429abdfad125dacb2956", + "name": "imageio", + "sha256": "8187abc4100ad5c7b791790048fe041128a90225e873a7e67cb670563826313c", + "size": 3449284, + "subdir": "linux-64", + "timestamp": 1536699292992, + "version": "2.4.1" + }, + "imageio-2.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "1bd96a9c056d28c68a350c73e2b37394", + "name": "imageio", + "sha256": "45ba9f2def87ca5cab8d369a3c8a9c84876527a01121c09460e443be4f05d13d", + "size": 3446253, + "subdir": "linux-64", + "timestamp": 1536699294688, + "version": "2.4.1" + }, + "imageio-2.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "7acb6d3885e82814d23665484cc80d39", + "name": "imageio", + "sha256": "915dc60ccafcc6dc9fe0521899905ddfa3c6f7d490456198c738fe505cd63764", + "size": 3438876, + "subdir": "linux-64", + "timestamp": 1536699298207, + "version": "2.4.1" + }, + "imageio-2.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "96f96a6d26b77e1701a6cff23626e9f6", + "name": "imageio", + "sha256": "d35104b2eac9f62869329d1baa358df12d090ac6e8b599b1951372eb1356412c", + "size": 3436100, + "subdir": "linux-64", + "timestamp": 1536699273402, + "version": "2.4.1" + }, + "imageio-2.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "b6c0c3ba3a9faa852dbefdc45ec6303a", + "name": "imageio", + "sha256": "a5d0ba450c248d208671e37e209f5ce2ff611305bee5ccbf5d757c96de5c58cf", + "size": 3504120, + "subdir": "linux-64", + "timestamp": 1551139233003, + "version": "2.5.0" + }, + "imageio-2.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "22680614565088812eafc38d8c21aa3f", + "name": "imageio", + "sha256": "71625a2eab6444a840294c1caf5c641c4b22c89f71daa103e353f09dc587bca6", + "size": 3499671, + "subdir": "linux-64", + "timestamp": 1551139326048, + "version": "2.5.0" + }, + "imageio-2.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "fef0903582c13a2a0d8345f4deeda163", + "name": "imageio", + "sha256": "21500fb6f98e6ca98725fe0953972419e71963079b8ad5f3bdecb7c083fe37d0", + "size": 3486083, + "subdir": "linux-64", + "timestamp": 1551139235819, + "version": "2.5.0" + }, + "imageio-2.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "futures", + "numpy", + "pillow", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "05521099d468f0b4babfca5d896d6761", + "name": "imageio", + "sha256": "48fb8d5ac9b0f3fb84bad521427321e774c87222997eebe1772407114e334807", + "size": 3477656, + "subdir": "linux-64", + "timestamp": 1570464573473, + "version": "2.6.0" + }, + "imageio-2.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "b6ad6f58b86c8fdb7fad809e65585ee8", + "name": "imageio", + "sha256": "6cebbca0f72c0902db7d9d78541fa612202c08b08565b40701084b58efab8249", + "size": 3464188, + "subdir": "linux-64", + "timestamp": 1570464585749, + "version": "2.6.0" + }, + "imageio-2.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "ba7ad58a64f99ad2d4b10683b3208c3f", + "name": "imageio", + "sha256": "4bada7967ae7201963e698bbc3458e84355eb19d56233ec7eb829ec12e8a3ad2", + "size": 3521178, + "subdir": "linux-64", + "timestamp": 1570464593756, + "version": "2.6.0" + }, + "imageio-2.6.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "futures", + "numpy", + "pillow", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "a33c9b3f8c6fdc968a9735297c1d85b1", + "name": "imageio", + "sha256": "1d4e7292180710c7e94a048846f9a898d9f4513bb6bdf627e813b8223a16801e", + "size": 3500984, + "subdir": "linux-64", + "timestamp": 1571761258337, + "version": "2.6.1" + }, + "imageio-2.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "3861aa2c1d6d26b3c7c1a9fc819fd964", + "name": "imageio", + "sha256": "47cc8a801a44d976c12e73e0f16bc592382eb9666ef0201d741367937934e1fb", + "size": 3545759, + "subdir": "linux-64", + "timestamp": 1571761291154, + "version": "2.6.1" + }, + "imageio-2.6.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "24c9c1bae1b9783b5feb0fdd5d948776", + "name": "imageio", + "sha256": "8f3d3550a1e7a4eb3ecf87f4667fed27f965553ea16e5e223753324619057e0e", + "size": 3502439, + "subdir": "linux-64", + "timestamp": 1571761257266, + "version": "2.6.1" + }, + "imageio-2.6.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "fd38dfe3ca34eccaf9e741e9b0d63c59", + "name": "imageio", + "sha256": "dd80987fbf3030d4a16b32accafb1dbb53166ad520fc962b4cd2323bf189455d", + "size": 3542437, + "subdir": "linux-64", + "timestamp": 1574157898960, + "version": "2.6.1" + }, + "imagesize-0.7.1-py27hd17bf80_0.tar.bz2": { + "build": "py27hd17bf80_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5543a72c82b24b14c1fc0d9adc7d2683", + "name": "imagesize", + "sha256": "448e2fc7b262ab8edda27f14253c55acda6a5262c5afd051c0dd339fad2fd927", + "size": 6026, + "subdir": "linux-64", + "timestamp": 1505744587169, + "version": "0.7.1" + }, + "imagesize-0.7.1-py35hf008fae_0.tar.bz2": { + "build": "py35hf008fae_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "9938b37b6305b2ac4b3d5b53014f8ce8", + "name": "imagesize", + "sha256": "01dd32bdb633f93327d1593fbfb79fc2a8702c76c96cb3b5d3ecdd73e8caa962", + "size": 6133, + "subdir": "linux-64", + "timestamp": 1505744599862, + "version": "0.7.1" + }, + "imagesize-0.7.1-py36h52d8127_0.tar.bz2": { + "build": "py36h52d8127_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "832e1e15f995a49a2e604970eaf935e6", + "name": "imagesize", + "sha256": "b28621ccea2bf63f5d08ae1a1bc7cc1def2829fa142c5b564ba0f73005b8d25a", + "size": 6125, + "subdir": "linux-64", + "timestamp": 1505744612732, + "version": "0.7.1" + }, + "imagesize-1.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ea3d993636d00a6815f1c9d860c18e37", + "name": "imagesize", + "sha256": "39881c344c04de869146653dd44a8c4ab69b0a49586f7dc27caa3c7e4be1d4eb", + "size": 8407, + "subdir": "linux-64", + "timestamp": 1519153057710, + "version": "1.0.0" + }, + "imagesize-1.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "786cb780e2820cab0ea6dab2311c5f78", + "name": "imagesize", + "sha256": "8ac5590ae0e6291be47ebb5708af7eace81f53f9d8344cac19dfb4363529ef30", + "size": 8544, + "subdir": "linux-64", + "timestamp": 1519153054425, + "version": "1.0.0" + }, + "imagesize-1.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "458fb5c5046c9adb20dd84a8d4ef423d", + "name": "imagesize", + "sha256": "38ec87b7a842363b3ef0999b4b3089a27edf2cf6dcfc37347c3e387feee8f9a0", + "size": 8484, + "subdir": "linux-64", + "timestamp": 1519153009294, + "version": "1.0.0" + }, + "imagesize-1.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b361e1d182551340a5027353e923bbc7", + "name": "imagesize", + "sha256": "0ddbb0a7d764ba54b5918ae78fd3e17e18420ee9b4f2f391092895c94418f1f7", + "size": 8382, + "subdir": "linux-64", + "timestamp": 1530695243157, + "version": "1.0.0" + }, + "imagesize-1.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7af0d7eed122dc9e4c97ce4deed8c999", + "name": "imagesize", + "sha256": "b3c2c92adf0fac6c46d769e59afed6bd397ee39fe866061d0f91f77a3749d9ff", + "size": 9421, + "subdir": "linux-64", + "timestamp": 1536074331532, + "version": "1.1.0" + }, + "imagesize-1.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "05438941805ecefbf19dc69a42efc767", + "name": "imagesize", + "sha256": "3bf3f68b6557d196f7bf2ee61a973ffba7082c0b807abcbc8c8ae9c8e4d56cf7", + "size": 9517, + "subdir": "linux-64", + "timestamp": 1536074353217, + "version": "1.1.0" + }, + "imagesize-1.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "365de532aa95a82b0495b94806100494", + "name": "imagesize", + "sha256": "105d65e19e992d4f4b2c38bc39a04e2a990b597ac55a88eb7a1c84446566918e", + "size": 9451, + "subdir": "linux-64", + "timestamp": 1536074305437, + "version": "1.1.0" + }, + "imagesize-1.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "051b6624bea3afe51cda1a3b44a79d09", + "name": "imagesize", + "sha256": "aa0973ea9cba8b78a2fd7f9b3be75c65b8eecc6da3e2d71cce90063791993f58", + "size": 9420, + "subdir": "linux-64", + "timestamp": 1536074354238, + "version": "1.1.0" + }, + "imagesize-1.4.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9bf831c5ead3e6c41237c9ad7b2d9e28", + "name": "imagesize", + "sha256": "52951378979e73726f3e5f2aa486c5a6ff43ad2723be352614ebd181ed3d2fe1", + "size": 13957, + "subdir": "linux-64", + "timestamp": 1657179640057, + "version": "1.4.1" + }, + "imagesize-1.4.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "daf45dc0800390b79357ff2b017778a0", + "name": "imagesize", + "sha256": "3293f150dc5298b3683388dcae37570198da90fefb3d5752dcb64ee7dc977fc8", + "size": 17845, + "subdir": "linux-64", + "timestamp": 1676830841315, + "version": "1.4.1" + }, + "imagesize-1.4.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "582cb536df2da3238e50e1975bdf3920", + "name": "imagesize", + "sha256": "cc0be0313b91e1ca818d0acb510db17a15caf87538e4ddd3f3e83d7fd2d69b4f", + "size": 13725, + "subdir": "linux-64", + "timestamp": 1657179573348, + "version": "1.4.1" + }, + "imagesize-1.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6a7ba2f448ce64aa8306d8487edc323", + "name": "imagesize", + "sha256": "751cfbe901b604fbc597cfbed2789aa6df3ce21ee36ba7d5b735075f581da61e", + "size": 13653, + "subdir": "linux-64", + "timestamp": 1657179542889, + "version": "1.4.1" + }, + "imagesize-1.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2876b62ecf3021b060ea2ab945843007", + "name": "imagesize", + "sha256": "3ccb6678ee08e04223cb05b14f38ca4e2b2f46d1db12b17fb51440a60978a14f", + "size": 13675, + "subdir": "linux-64", + "timestamp": 1657179601801, + "version": "1.4.1" + }, + "imbalanced-learn-0.10.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "joblib >=1.1.1", + "numpy", + "python >=3.10,<3.11.0a0", + "scikit-learn >=1.0.2", + "scipy >=1.3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17e7fb16573da5db68ee98b3c2e64ed1", + "name": "imbalanced-learn", + "sha256": "abc570ee7c91a45b0da41f4a1e7bfc23a92bb345d8722fa55b90fe203a5f7f7e", + "size": 299137, + "subdir": "linux-64", + "timestamp": 1677191754591, + "version": "0.10.1" + }, + "imbalanced-learn-0.10.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "joblib >=1.1.1", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn >=1.0.2", + "scipy >=1.3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b70f92b11b6fe6c4f3ea8959004a432", + "name": "imbalanced-learn", + "sha256": "dd2812521df9e2cba8e79c7ee1b196f80d45ec12d891e46409a15751912a0992", + "size": 298467, + "subdir": "linux-64", + "timestamp": 1677191597309, + "version": "0.10.1" + }, + "imbalanced-learn-0.10.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "joblib >=1.1.1", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn >=1.0.2", + "scipy >=1.3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fcee367ca43f44bd9097caae4a17265d", + "name": "imbalanced-learn", + "sha256": "471b39802311cbcc4de4d4b1e35133f0ab4c30350d8ec0bac91d29d18baad97f", + "size": 296636, + "subdir": "linux-64", + "timestamp": 1677191906932, + "version": "0.10.1" + }, + "iminuit-1.2-py27h30ba22a_0.tar.bz2": { + "build": "py27h30ba22a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "dd8c0e799a6496d678c713fea2ebc9a1", + "name": "iminuit", + "sha256": "976f74220c97182666106483f2b087960c253fea87139edb9c7c51cfe8006559", + "size": 457060, + "subdir": "linux-64", + "timestamp": 1508269264786, + "version": "1.2" + }, + "iminuit-1.2-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "1b05b651cd8ce29130df80c9bdb0b31d", + "name": "iminuit", + "sha256": "8620dcd9d7f21d98761763ca9fd6288e5d4fa048de160095fe3659be3f1d23fc", + "size": 487971, + "subdir": "linux-64", + "timestamp": 1530897313188, + "version": "1.2" + }, + "iminuit-1.2-py35hd0651ea_0.tar.bz2": { + "build": "py35hd0651ea_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "01b99380319230d84e7442b22254e7b9", + "name": "iminuit", + "sha256": "d40733232dd256d5fc75515acfdb6aa62fb67a8d87f111fe89aa2abbe9cdec7d", + "size": 456447, + "subdir": "linux-64", + "timestamp": 1508269258504, + "version": "1.2" + }, + "iminuit-1.2-py36h393febe_0.tar.bz2": { + "build": "py36h393febe_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "92f1607ffa7fad6a945978f9c2909676", + "name": "iminuit", + "sha256": "991085c4c8a5804c0a96c417632d69c1c6bffd47cf888fbc5a31fa9a28069a92", + "size": 457117, + "subdir": "linux-64", + "timestamp": 1508269278552, + "version": "1.2" + }, + "iminuit-1.2-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "6f3f78adebd1b38e4f5d935409443454", + "name": "iminuit", + "sha256": "0070e39ad1b77d86714d71dab4de7faf83e9360b344082bde59a521a8bf1706b", + "size": 494427, + "subdir": "linux-64", + "timestamp": 1530897412991, + "version": "1.2" + }, + "iminuit-1.2-py37hf484d3e_0.tar.bz2": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "cb30c25cef92a9a205c239cae6f73e79", + "name": "iminuit", + "sha256": "d08ec963d94c18585352a24ca0c5696df3381dfc81f5d247c804c22e1e142b76", + "size": 493051, + "subdir": "linux-64", + "timestamp": 1530897513102, + "version": "1.2" + }, + "iminuit-1.3.2-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "c48da335b121c746c607961a83b285aa", + "name": "iminuit", + "sha256": "3a6654ba1c2d50518dca8e3149ef6006127e029c7210159c61a5ee3c00a5ddb0", + "size": 439638, + "subdir": "linux-64", + "timestamp": 1536113223982, + "version": "1.3.2" + }, + "iminuit-1.3.2-py35h962f231_0.tar.bz2": { + "build": "py35h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "50c85c1ee60dd808e6bab18d47edbad5", + "name": "iminuit", + "sha256": "ead902a9926e3908b5ce7bc04d0e72be12f386308c20527741a06f63377f4dd6", + "size": 441607, + "subdir": "linux-64", + "timestamp": 1536113108228, + "version": "1.3.2" + }, + "iminuit-1.3.2-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "a97467568d9990f1392769a5016b02d7", + "name": "iminuit", + "sha256": "453622dbd886d8561ef7225ffb88211aa6240517df9b9d9f3b9a79d3c23e0bef", + "size": 445511, + "subdir": "linux-64", + "timestamp": 1536113024988, + "version": "1.3.2" + }, + "iminuit-1.3.2-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "31ba83ff156c2be83d8f4330180f74bc", + "name": "iminuit", + "sha256": "93770e0137f4ff96ae586bd42040c4990cd90f5e229551afc352b1347c71c281", + "size": 444763, + "subdir": "linux-64", + "timestamp": 1536113255344, + "version": "1.3.2" + }, + "iminuit-1.3.3-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "c552648869beb58003b0e069bb83dfe5", + "name": "iminuit", + "sha256": "bfecac09580e83232a61650851cdd9ef7398861e176e6a7bc113d781549b4cb5", + "size": 432246, + "subdir": "linux-64", + "timestamp": 1538180486411, + "version": "1.3.3" + }, + "iminuit-1.3.3-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "dc9c6e042611869ba9e356547d4c1809", + "name": "iminuit", + "sha256": "ec2121c75878dac588c646a23f14f9c310dae2db5899c5d9b53f5cec54576f1a", + "size": 439057, + "subdir": "linux-64", + "timestamp": 1538180465756, + "version": "1.3.3" + }, + "iminuit-1.3.3-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "927649a8f628873a0fc3ce44fc38e581", + "name": "iminuit", + "sha256": "f1678d0ab82c83f398858b6d3839657b2ed82d335198f0fa7d565449f6c9c3c4", + "size": 437943, + "subdir": "linux-64", + "timestamp": 1538180538381, + "version": "1.3.3" + }, + "iminuit-1.3.7-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "dd55142fed41830cf88fb018f5446c95", + "name": "iminuit", + "sha256": "d0f36d0dedf185af6460c1f0f1145fb99a46bc1f28fd5fd84690098e65725204", + "size": 432864, + "subdir": "linux-64", + "timestamp": 1569369039644, + "version": "1.3.7" + }, + "iminuit-1.3.7-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "fe9461c66a2c4bf70c245c079c600126", + "name": "iminuit", + "sha256": "d0c1056231ba0cd55c75b11cf5f908ca7162fe9102f0615eb514b51ad8565ec3", + "size": 440798, + "subdir": "linux-64", + "timestamp": 1569369091317, + "version": "1.3.7" + }, + "iminuit-1.3.7-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "1e008565698a2b966c4c05a17be60bb1", + "name": "iminuit", + "sha256": "db58fa000b569ae18e45cd14674d85dbdf45b990fddd7ff96df6e2c85136ff5f", + "size": 439807, + "subdir": "linux-64", + "timestamp": 1569369085911, + "version": "1.3.7" + }, + "iminuit-1.3.7-py38h962f231_0.tar.bz2": { + "build": "py38h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "7fe57ef62082ef720728f93f33b1fcae", + "name": "iminuit", + "sha256": "68415cc37e0a71fc3dffb31b227a05b9b09e5f5cb2ac27e29f4d584b99c01973", + "size": 448485, + "subdir": "linux-64", + "timestamp": 1572621902709, + "version": "1.3.7" + }, + "iminuit-1.3.8-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "d5c5d85c510880939e5f5f978fa290a3", + "name": "iminuit", + "sha256": "9113f9a071c304ea0ede367b5a37c468a1362e68ba8551b298709cee1e8cb431", + "size": 438275, + "subdir": "linux-64", + "timestamp": 1573966101570, + "version": "1.3.8" + }, + "iminuit-1.3.8-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "3d4497d7d6e0d4758f5f41a24ac583e9", + "name": "iminuit", + "sha256": "7f5e7fe2e12400acf48a63c0e398e0e3cab56f48c493969fef09d66d629297f5", + "size": 445887, + "subdir": "linux-64", + "timestamp": 1573966080824, + "version": "1.3.8" + }, + "iminuit-1.3.8-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "57e2d3497f5dc54f5cbc1308bb4dc5b6", + "name": "iminuit", + "sha256": "2ff2c2e56aef1999ef7a2a842a4d5e50b1d6479bf8b2e51d7bcb3a97c289bbcd", + "size": 446320, + "subdir": "linux-64", + "timestamp": 1573966076600, + "version": "1.3.8" + }, + "iminuit-1.3.8-py38h962f231_0.tar.bz2": { + "build": "py38h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "c8896e534e74bd1ce42e61f7c542b458", + "name": "iminuit", + "sha256": "f3dcd20e8da5ffe88f97aeca3264124f8143f9cb8d1fa996ebc5792984ba59fc", + "size": 452753, + "subdir": "linux-64", + "timestamp": 1573966109417, + "version": "1.3.8" + }, + "iminuit-1.4.2-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "1836369b805da7834d28787e1d93a3d0", + "name": "iminuit", + "sha256": "15e2ad6f5d279d4cd5c816800f3952bdc942ced2ad9e6fcf1055a247bc497b84", + "size": 465561, + "subdir": "linux-64", + "timestamp": 1592228706118, + "version": "1.4.2" + }, + "iminuit-1.4.2-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "6d4a712af59da0138b46a4ebc51c7337", + "name": "iminuit", + "sha256": "425e8ad526ea416feb7d560037cecdc743ed7785613bdb76728a5eaa0f680f67", + "size": 458339, + "subdir": "linux-64", + "timestamp": 1592228685062, + "version": "1.4.2" + }, + "iminuit-1.4.2-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "1265667ae3506bab76c0e79e3dec6f63", + "name": "iminuit", + "sha256": "8c9c27489046467a8b575f51576a0cb0631ade36b992a10c1a1c3def5e2d9a33", + "size": 477537, + "subdir": "linux-64", + "timestamp": 1592228681060, + "version": "1.4.2" + }, + "iminuit-1.4.9-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "4eaa2e5c787f2e5d6faa5e54716508cc", + "name": "iminuit", + "sha256": "4f55a6e4856beec79014022ce6c49612d56e5df6a7e66afbba6f2ac5f0bf8cd8", + "size": 464325, + "subdir": "linux-64", + "timestamp": 1600361325730, + "version": "1.4.9" + }, + "iminuit-1.4.9-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "f2a7ab20bddf8adcb2941f819b87e4a2", + "name": "iminuit", + "sha256": "3c50e45a7161faff1b38a5adda5d3bc07c09eaeb905e347fb2439352a4c6bed4", + "size": 470403, + "subdir": "linux-64", + "timestamp": 1600361285150, + "version": "1.4.9" + }, + "iminuit-1.4.9-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "26e0b13a48ef4d9e7be9096463e1bca2", + "name": "iminuit", + "sha256": "5f326510199cbe8a31cbd1179dbbb2ff416b37d3f6548c29766e83bf9beb3c22", + "size": 488002, + "subdir": "linux-64", + "timestamp": 1600361303247, + "version": "1.4.9" + }, + "iminuit-1.5.0-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "435ab54119db0473e9bc362696d9cf75", + "name": "iminuit", + "sha256": "56c1f3c25d78cca5172029cc7c569cc120ebca015ec279325b5b870e89dea561", + "size": 465167, + "subdir": "linux-64", + "timestamp": 1600379491703, + "version": "1.5.0" + }, + "iminuit-1.5.0-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "d24a434ba55a30003ae75f4a847fe422", + "name": "iminuit", + "sha256": "87e54e8c0463aca8522aa7258409da55ecdca43ba9f40654d8a2e031f13f443d", + "size": 469683, + "subdir": "linux-64", + "timestamp": 1600379491690, + "version": "1.5.0" + }, + "iminuit-1.5.0-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "fad50786d93f0814fc2b1282863f5a7f", + "name": "iminuit", + "sha256": "0bc2632ad95db37875ba7fc9223c4263c7b9d0fb2709e91837081c22c14d32a3", + "size": 483087, + "subdir": "linux-64", + "timestamp": 1600379477858, + "version": "1.5.0" + }, + "iminuit-1.5.1-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "c694cda47b0441e89fe157a94f091112", + "name": "iminuit", + "sha256": "6bba68fae3bd68e1122a005416f822cab2fdae30ba697206814092acfb8008eb", + "size": 465817, + "subdir": "linux-64", + "timestamp": 1600701647933, + "version": "1.5.1" + }, + "iminuit-1.5.1-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "ca78fe3a40285cc592659eea2702a192", + "name": "iminuit", + "sha256": "5633227465fbf19e5545a025fe2131d0c24499ed8004d2e0f03117cb875094c3", + "size": 463623, + "subdir": "linux-64", + "timestamp": 1600701621774, + "version": "1.5.1" + }, + "iminuit-1.5.1-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "91cb68bd1df58b0047f0508a65886b17", + "name": "iminuit", + "sha256": "59d2038ed18e3d4c7f78c25c91af2a2822b7946bf747688d03dab82ac3545e19", + "size": 485363, + "subdir": "linux-64", + "timestamp": 1600701622404, + "version": "1.5.1" + }, + "iminuit-1.5.2-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "65e87cd83476785c4eeb09473a81b60c", + "name": "iminuit", + "sha256": "449f0499bfaa533fefda04eb45d83c9090d16eac53f557719631142a95c45e3e", + "size": 476441, + "subdir": "linux-64", + "timestamp": 1600967561535, + "version": "1.5.2" + }, + "iminuit-1.5.2-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "3445366b1ab2dce816e2eb9ba8c50e4a", + "name": "iminuit", + "sha256": "db32d6f2ccc3c529342aae66583b49a8fa5d938d439154280b9de9dadfc61e0f", + "size": 471578, + "subdir": "linux-64", + "timestamp": 1600962133833, + "version": "1.5.2" + }, + "iminuit-1.5.2-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "544706c1b77c8bb696a5671bb5333cf1", + "name": "iminuit", + "sha256": "d13e6450047ed1850f25898f0c7ec8b8c04248d415ec88263b228762fcfefe61", + "size": 488094, + "subdir": "linux-64", + "timestamp": 1600967550148, + "version": "1.5.2" + }, + "iminuit-1.5.4-py36ha9443f7_0.tar.bz2": { + "build": "py36ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "273811f375455e8c8781407798527190", + "name": "iminuit", + "sha256": "4d9c8fb5de282bed42b6ef87e3cf7c5531d74771e68b2451fb2cbd6998ac6e4f", + "size": 459348, + "subdir": "linux-64", + "timestamp": 1606145751585, + "version": "1.5.4" + }, + "iminuit-1.5.4-py37ha9443f7_0.tar.bz2": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "148f9f99eb8791709cc1dfcf1809fde6", + "name": "iminuit", + "sha256": "bbf58ea250d9223f20d0d24c3782a74cc2c66c7d56b63f803bbf9b5d26bf3f2b", + "size": 457127, + "subdir": "linux-64", + "timestamp": 1606145753720, + "version": "1.5.4" + }, + "iminuit-1.5.4-py38ha9443f7_0.tar.bz2": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "8a249ab55500b8761e14eb3e2761eb5e", + "name": "iminuit", + "sha256": "3c54c13802507942393de4e8f25ad6bf752ef73d6b40a8167c934f794a23f807", + "size": 477738, + "subdir": "linux-64", + "timestamp": 1606145754467, + "version": "1.5.4" + }, + "iminuit-2.18.0-py310h1128e8f_0.tar.bz2": { + "build": "py310h1128e8f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "ba72691926019923f66c74de84184912", + "name": "iminuit", + "sha256": "635688d2f9369ba11cb8819a51425661a92e3dc538d959455845d871e5106b7b", + "size": 418505, + "subdir": "linux-64", + "timestamp": 1674746701738, + "version": "2.18.0" + }, + "iminuit-2.18.0-py311hba01205_0.tar.bz2": { + "build": "py311hba01205_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "3cae610f2e7a41cbc74b04a2f6f0b829", + "name": "iminuit", + "sha256": "48cceb1bef4301cda817003be83656936c3abe00cf350af9682fadd2907e4795", + "size": 464999, + "subdir": "linux-64", + "timestamp": 1676852821156, + "version": "2.18.0" + }, + "iminuit-2.18.0-py37h417a72b_0.tar.bz2": { + "build": "py37h417a72b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "39c480be2ddb97534c30684de81a4f39", + "name": "iminuit", + "sha256": "9ecf49ffeac787a8db21e44e633e33ab5958bd0e12251d41ba1d09a5d0d0c842", + "size": 431955, + "subdir": "linux-64", + "timestamp": 1674746622311, + "version": "2.18.0" + }, + "iminuit-2.18.0-py38h417a72b_0.tar.bz2": { + "build": "py38h417a72b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "bed7a55c0cdb59c557927d9e231eecde", + "name": "iminuit", + "sha256": "cbc63dd7c8df96bf9b3b58d9e18881f5633361e92ddf9da4ebc5ee1e583b1669", + "size": 417129, + "subdir": "linux-64", + "timestamp": 1674746780504, + "version": "2.18.0" + }, + "iminuit-2.18.0-py39h417a72b_0.tar.bz2": { + "build": "py39h417a72b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "1625ced7e709a2070344d0878463927b", + "name": "iminuit", + "sha256": "cc2ff7fb8511ff7461c7100d4910eb2ac9586426560d7bf5b42be130b3cb029a", + "size": 419054, + "subdir": "linux-64", + "timestamp": 1674746860422, + "version": "2.18.0" + }, + "iminuit-2.2.0-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "0e65e304145beeb85548a26453ff8d3c", + "name": "iminuit", + "sha256": "30b6fc6e87acc3feba8954eb8796d0ddedef83812292823e684821f5ef5fd349", + "size": 319374, + "subdir": "linux-64", + "timestamp": 1608650636987, + "version": "2.2.0" + }, + "iminuit-2.2.0-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "1cc00901a498f6f64f77b498c6aa7ab6", + "name": "iminuit", + "sha256": "62a173614092abd23b77dc7596e8a4ee9ce9246506a7e78b82c89c2056b9cffa", + "size": 316171, + "subdir": "linux-64", + "timestamp": 1608650659260, + "version": "2.2.0" + }, + "iminuit-2.2.0-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "0e048883d5a5ae317612857061cb482b", + "name": "iminuit", + "sha256": "7d57b1abb43fa43d65c579b0f6c902ba76e107969b0bbbd694d2750fa9e0297b", + "size": 318388, + "subdir": "linux-64", + "timestamp": 1608650667481, + "version": "2.2.0" + }, + "iminuit-2.2.0-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "ef72a966fd2b068aa202e75b46dbaee0", + "name": "iminuit", + "sha256": "c279d1a729d0491cc5115f7a6a316d62cbc8bae69186e6e5eaf5189c1d3a52be", + "size": 318320, + "subdir": "linux-64", + "timestamp": 1608650689736, + "version": "2.2.0" + }, + "iminuit-2.4.0-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "e650735ba9b4e750e40207cb7ab46172", + "name": "iminuit", + "sha256": "c8418f13186a2e55d47a3a437a9fe462dcf3dc09c315267ef17928e4fab79e9e", + "size": 323706, + "subdir": "linux-64", + "timestamp": 1619185894667, + "version": "2.4.0" + }, + "iminuit-2.4.0-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "dfe35561e04a0646f68a9c43584f99a1", + "name": "iminuit", + "sha256": "710fced904dfa9679d0ee028ee3cdf3c1a1cc1df258228e009eca94172fded41", + "size": 324356, + "subdir": "linux-64", + "timestamp": 1619189387973, + "version": "2.4.0" + }, + "iminuit-2.4.0-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "9bda85b83ad5db8bb858780d778f2e93", + "name": "iminuit", + "sha256": "1b22ba339ca317f5b79e7e210756de76672b7cfebcb7edee74046599d8c2ab46", + "size": 321638, + "subdir": "linux-64", + "timestamp": 1619189386842, + "version": "2.4.0" + }, + "iminuit-2.4.0-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "604dcb3dee8b87997d506e245af6d622", + "name": "iminuit", + "sha256": "c4e7264114a2f1380417a06eedbccebeb96812b48d644fc0176e6f9c94f6e9ab", + "size": 323948, + "subdir": "linux-64", + "timestamp": 1619188934070, + "version": "2.4.0" + }, + "iminuit-2.6.0-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "bf3d646455f4e5833377e60881ab721c", + "name": "iminuit", + "sha256": "69b0caab8c7720ddfd1ae14026144efc86721c6a9aed2d9e03e1cb8bb50d16c6", + "size": 332818, + "subdir": "linux-64", + "timestamp": 1619997415121, + "version": "2.6.0" + }, + "iminuit-2.6.0-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "397c9979ebcadd8f7b91aa20f3aba164", + "name": "iminuit", + "sha256": "9fc59ffba2c677e6a37e50cd815f95957e10a896c90f72b02d865d4692c04a7f", + "size": 331945, + "subdir": "linux-64", + "timestamp": 1619997420037, + "version": "2.6.0" + }, + "iminuit-2.6.0-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "75b86c7c46d47a23235641f227eea827", + "name": "iminuit", + "sha256": "968897887fe2cda59c1d163a2324b2b879983e6e1b8fb751081dfae4df2ffcb2", + "size": 333180, + "subdir": "linux-64", + "timestamp": 1619997412382, + "version": "2.6.0" + }, + "iminuit-2.6.0-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "901c68483694983912863b15e5d0ca46", + "name": "iminuit", + "sha256": "3ab805b1d792dfd5917add6ee36ca9d8865d0e0816d9eed8dcdb120938f233f6", + "size": 323785, + "subdir": "linux-64", + "timestamp": 1619997410514, + "version": "2.6.0" + }, + "iminuit-2.6.1-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "0b9358af331211cacb740a7bbd8fc73f", + "name": "iminuit", + "sha256": "96e6d409dccc2d7464a4bffd8bfa7cf18480508827000b2a5962669d870cd70c", + "size": 322332, + "subdir": "linux-64", + "timestamp": 1620999511151, + "version": "2.6.1" + }, + "iminuit-2.6.1-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "92b79bd9cede79795212ca82d917d1a1", + "name": "iminuit", + "sha256": "6f6bbdb87f5cfc01e6cf64021c6e543e2f137f10ca34f590d918ae7f511af079", + "size": 334018, + "subdir": "linux-64", + "timestamp": 1621000095437, + "version": "2.6.1" + }, + "iminuit-2.6.1-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "df54ad9739747da5e42ce5d17a5b45c1", + "name": "iminuit", + "sha256": "dc0eed81402d231232e2a16d326a15ab0837de3100f16ad086b80c5ce6594416", + "size": 335131, + "subdir": "linux-64", + "timestamp": 1620999506674, + "version": "2.6.1" + }, + "iminuit-2.6.1-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "497c2b54c64c727791c0b3f22e0e2a27", + "name": "iminuit", + "sha256": "27a403ae81dd2a0a9cd09319337748c5c5f170d5661bb61cb7f57e9779d0138f", + "size": 332066, + "subdir": "linux-64", + "timestamp": 1621244792845, + "version": "2.6.1" + }, + "iminuit-2.6.1-py39ha9443f7_0.tar.bz2": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "d30b3bdd8c9a5ffa69dea797585e4d57", + "name": "iminuit", + "sha256": "2bd4351959810fea4ef253dd682ff777a8941502317500d7640be56c3a7955bc", + "size": 324440, + "subdir": "linux-64", + "timestamp": 1621248270916, + "version": "2.6.1" + }, + "iminuit-2.7.0-py36h295c915_0.tar.bz2": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "80cd92a0624b0e8bf4fee02a25a540c8", + "name": "iminuit", + "sha256": "6e30ce891aec3e2ef8600d141704e9f8ef935b35faf59ad7183b2e3701108bf4", + "size": 351261, + "subdir": "linux-64", + "timestamp": 1625730141216, + "version": "2.7.0" + }, + "iminuit-2.7.0-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "da5bfa2db34918285003eba011bdc390", + "name": "iminuit", + "sha256": "127c238e373f5436ec88780f4dd7df05602b2edee0eff1898bf44923176514d7", + "size": 350615, + "subdir": "linux-64", + "timestamp": 1625751163511, + "version": "2.7.0" + }, + "iminuit-2.7.0-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "ca1fe4f1e95b51d3d9f5d02ac029d315", + "name": "iminuit", + "sha256": "d059f5e5467d2d05e907fb175bdc9d964d0c6a65681f129a8ea1315d847c3f22", + "size": 351449, + "subdir": "linux-64", + "timestamp": 1625730111345, + "version": "2.7.0" + }, + "iminuit-2.7.0-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "08e9801796279c3daaae08cc9e1d7ec4", + "name": "iminuit", + "sha256": "8c55d7be711f8a3d033270d37a24a2bd9749d0ad9596a81c3d3bd966cfb791b2", + "size": 351221, + "subdir": "linux-64", + "timestamp": 1625730125595, + "version": "2.7.0" + }, + "iminuit-2.8.4-py310h00e6091_0.tar.bz2": { + "build": "py310h00e6091_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "01aadadec000f9d5ceff54e45690e331", + "name": "iminuit", + "sha256": "e8fb81ba100dfd78b38f009255c1f03ba96e4548f8f8e9a5fff5a5423bb49dd4", + "size": 346352, + "subdir": "linux-64", + "timestamp": 1640790998430, + "version": "2.8.4" + }, + "iminuit-2.8.4-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "a7e7ff77a63787a7cba583240a8e3262", + "name": "iminuit", + "sha256": "8b97a287da7be12647db1b5dc989116bc629e6027ba638796bc3941c00e7e719", + "size": 346335, + "subdir": "linux-64", + "timestamp": 1638708998377, + "version": "2.8.4" + }, + "iminuit-2.8.4-py37h51133e4_0.tar.bz2": { + "build": "py37h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "9ed11e6fe6f33e9a37c4c84109fb8ec8", + "name": "iminuit", + "sha256": "d621eb802393cc20a894a81a7a4cd0335aec77db5b292499d277526f397f087d", + "size": 355502, + "subdir": "linux-64", + "timestamp": 1638960151390, + "version": "2.8.4" + }, + "iminuit-2.8.4-py38h51133e4_0.tar.bz2": { + "build": "py38h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "05bebe537017f9acb2a54437d2e464c5", + "name": "iminuit", + "sha256": "16e288e70349165843995fb0f407c1b42857633bdd5dfa831dde27feb26f2c73", + "size": 356004, + "subdir": "linux-64", + "timestamp": 1638960073391, + "version": "2.8.4" + }, + "iminuit-2.8.4-py39h51133e4_0.tar.bz2": { + "build": "py39h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "de28cc2c4c6f55642cb114b9be8b31a4", + "name": "iminuit", + "sha256": "762c32515f2c5371deaec6b25ada4a98d17d3cf28ae7e9228c2872c3375164e3", + "size": 356213, + "subdir": "linux-64", + "timestamp": 1638959999055, + "version": "2.8.4" + }, + "immutables-0.11-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "010a68444c4ef8c1ad0b0869f3a0def8", + "name": "immutables", + "sha256": "fce392ea66ba88202beb0a02fb5038e095bcdde6a0b9fcecf8c65d867f9404fd", + "size": 67384, + "subdir": "linux-64", + "timestamp": 1585075320037, + "version": "0.11" + }, + "immutables-0.11-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "afd3feb7e3ef677fe6841c3998d12ba7", + "name": "immutables", + "sha256": "ee5eb4b017ca3bcba6bbf16be85891b9d11bcd6e2aaa633e1bf25c4952cf870f", + "size": 67420, + "subdir": "linux-64", + "timestamp": 1585075322507, + "version": "0.11" + }, + "immutables-0.11-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5c05cbb2becd7b5cb7ccc23af0787635", + "name": "immutables", + "sha256": "c243dc4c68546083f25052c7d6c9402c477983d5a77f628c2466d0596c8e81e8", + "size": 68080, + "subdir": "linux-64", + "timestamp": 1585075345952, + "version": "0.11" + }, + "immutables-0.14-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "22af31890e815303b948c44496ea0a33", + "name": "immutables", + "sha256": "5bf56a25563248a0df73d72cabfdb892cf0f3d2fc44e03a8d4981ccda9a5365c", + "size": 73274, + "subdir": "linux-64", + "timestamp": 1613500317110, + "version": "0.14" + }, + "immutables-0.14-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "06f1f9c5a35e25b25f9869877f7e88b2", + "name": "immutables", + "sha256": "1737feecaa74905041546c5846dc88d25b9b8f286267f4cef22f4557b2d6f5c2", + "size": 73157, + "subdir": "linux-64", + "timestamp": 1592426033717, + "version": "0.14" + }, + "immutables-0.14-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a687cb89d8ac4d06fc09f52392a39ffd", + "name": "immutables", + "sha256": "907cac6d48734c7d31002a7ac264c4c9be33ea5c83e82c1fc3d2ce6e67013611", + "size": 73267, + "subdir": "linux-64", + "timestamp": 1613500943714, + "version": "0.14" + }, + "immutables-0.14-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a4b966519284f43b3f039ff8af28f593", + "name": "immutables", + "sha256": "435800de4a8b168f2b196e389fd7ee8904cbf9dc6f4b2cc21bbf7a721a0cfee0", + "size": 73136, + "subdir": "linux-64", + "timestamp": 1592426029434, + "version": "0.14" + }, + "immutables-0.14-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c660b26a0854871cc53f31df716ea371", + "name": "immutables", + "sha256": "457435446e77f83f26e93dc7af1b23b07d5361f2d8d96257d0a7b43306ede4bb", + "size": 73940, + "subdir": "linux-64", + "timestamp": 1613500950294, + "version": "0.14" + }, + "immutables-0.14-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "951e08b38733fa279a6f4867ab310edb", + "name": "immutables", + "sha256": "706cadf6aa56257fd15b2a18e6e32ad0a0d173f0c3301c5eb907abf275e4173f", + "size": 73851, + "subdir": "linux-64", + "timestamp": 1592426008592, + "version": "0.14" + }, + "immutables-0.14-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a4a4031c4b98c4002723e6a899d9b688", + "name": "immutables", + "sha256": "56f34c601d88f3a48eaf42a826c6543ef767c5e1e5cbff96e2fd661246a332e1", + "size": 73779, + "subdir": "linux-64", + "timestamp": 1613500952155, + "version": "0.14" + }, + "immutables-0.15-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e16a7fa3d730c64d56ecc2f32675c476", + "name": "immutables", + "sha256": "2979dbf657641f8d84a6f30da6df7188eb189437359f679f2519746e6898ba60", + "size": 71692, + "subdir": "linux-64", + "timestamp": 1615839353431, + "version": "0.15" + }, + "immutables-0.15-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8ee30ac04a0006635eee8a978a40ae03", + "name": "immutables", + "sha256": "fb740bb4de45dc1006146d2bf0469fdc5a9852bfdc88178a003da30fca083657", + "size": 71646, + "subdir": "linux-64", + "timestamp": 1615841159787, + "version": "0.15" + }, + "immutables-0.15-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "efa9a99b7da4ae9106ba841942db69ac", + "name": "immutables", + "sha256": "88304df9e9f8c07bb38d3ae509c4d5f566471b915bf8159317edb89eca6dad54", + "size": 72266, + "subdir": "linux-64", + "timestamp": 1615840871095, + "version": "0.15" + }, + "immutables-0.15-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e1ca2fdcf323175f7b447c65073fe75a", + "name": "immutables", + "sha256": "2fb470b9a49238d573ee8cf71eb6638ace038ad2ba4cb552affe7941c676d999", + "size": 72154, + "subdir": "linux-64", + "timestamp": 1615841168110, + "version": "0.15" + }, + "immutables-0.16-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "fe927e8e5c01a5f3270720fccdbeaf9a", + "name": "immutables", + "sha256": "2a5f97b130875a55cba21d49822d455f33d6ac2ab06fa54685ad7eb6feed9302", + "size": 119057, + "subdir": "linux-64", + "timestamp": 1640791023448, + "version": "0.16" + }, + "immutables-0.16-py311h5eee18b_1.tar.bz2": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0 AND MIT", + "license_family": "Apache", + "md5": "d8567448918a3b310b3e527716960d8d", + "name": "immutables", + "sha256": "cd8b2f985e866bd12fdf8ec589b63cd1b02a02ba2c997949662673a11ede9d26", + "size": 75772, + "subdir": "linux-64", + "timestamp": 1676852842799, + "version": "0.16" + }, + "immutables-0.16-py36h7f8727e_0.tar.bz2": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "0a4e8b141816859de0ff1a72135ee8d9", + "name": "immutables", + "sha256": "201c3a54f9748e7a5d921f8cbb1d290b02d3410703bd6f4c4054e18aff6708a7", + "size": 66265, + "subdir": "linux-64", + "timestamp": 1628889054704, + "version": "0.16" + }, + "immutables-0.16-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "bec1336725cb67d48459ad4308e410db", + "name": "immutables", + "sha256": "dde4277cdfba77818c38657e63c37dfef4203d889b1deb354783906ebf4eff3f", + "size": 66266, + "subdir": "linux-64", + "timestamp": 1628881178135, + "version": "0.16" + }, + "immutables-0.16-py37h7f8727e_1.tar.bz2": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "Apache-2.0 AND MIT", + "license_family": "Apache", + "md5": "50e5b801f8e2fb8724d00520a7e19666", + "name": "immutables", + "sha256": "e1f7995ce5d142198d5eb1cee00d8f3e0b47004faec291c5ca80baac1e4a1df1", + "size": 70318, + "subdir": "linux-64", + "timestamp": 1640145868168, + "version": "0.16" + }, + "immutables-0.16-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b7b8e65cc4b97719f04b451477a510db", + "name": "immutables", + "sha256": "eb735652f11776fc080d16864cd17e369d0a22bcdd98e1e88a790fb3a27abf9a", + "size": 66819, + "subdir": "linux-64", + "timestamp": 1628889576722, + "version": "0.16" + }, + "immutables-0.16-py38h7f8727e_1.tar.bz2": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 AND MIT", + "license_family": "Apache", + "md5": "e7747113d27a247d33a27ced0d70dc01", + "name": "immutables", + "sha256": "579513a5f3a22fd07cb671f980c04e74d591d91efb0ef66ab0bf0f26b9f91037", + "size": 70931, + "subdir": "linux-64", + "timestamp": 1640163987214, + "version": "0.16" + }, + "immutables-0.16-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "d2ad7d50ce626d4a4d567e3b434293ed", + "name": "immutables", + "sha256": "ce4f006db79e92d6e19a70f67cfe34df5b4676e49346bc4f39e22be573424f57", + "size": 66746, + "subdir": "linux-64", + "timestamp": 1628889582131, + "version": "0.16" + }, + "immutables-0.16-py39h7f8727e_1.tar.bz2": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 AND MIT", + "license_family": "Apache", + "md5": "ef562828c49fbcf663699344b849e2c7", + "name": "immutables", + "sha256": "c536edf27660b6efb064fe63a66da72d527262a88dc534bb8aaa1ae1e8bc3af9", + "size": 70873, + "subdir": "linux-64", + "timestamp": 1640163986689, + "version": "0.16" + }, + "importlib-metadata-1.1.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "ceb134dd2535b004117c0f97f35e4360", + "name": "importlib-metadata", + "sha256": "7b6578698c9a25d432225aadb783fa583351a0b8dd69d96e886697aa6b037e8c", + "size": 47703, + "subdir": "linux-64", + "timestamp": 1594838469052, + "version": "1.1.3" + }, + "importlib-metadata-1.1.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "028d9f172e34ee855ca6f2c83f194ab0", + "name": "importlib-metadata", + "sha256": "16b41fe24c2881ab942249ea625dc1215de8c23a690d7ed6019d346c9c9d1669", + "size": 47795, + "subdir": "linux-64", + "timestamp": 1594838467114, + "version": "1.1.3" + }, + "importlib-metadata-1.1.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "712e7c81e400bdc650a032c539941134", + "name": "importlib-metadata", + "sha256": "4da1257dcd6ac6f631e163063e10067e34c39e3999a29c7464b1dca3a762d87e", + "size": 47973, + "subdir": "linux-64", + "timestamp": 1594838467093, + "version": "1.1.3" + }, + "importlib-metadata-1.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c812c576c6a4bdbee541754231ada94f", + "name": "importlib-metadata", + "sha256": "dfc05d58422ea0c1aee7bd15c48b0933500f6ca62a3c4e3d0e01f5e04fccce4d", + "size": 49930, + "subdir": "linux-64", + "timestamp": 1590516354242, + "version": "1.6.0" + }, + "importlib-metadata-1.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a952014946f10b09e89add354c2168d5", + "name": "importlib-metadata", + "sha256": "053e08b77f4d53651191fed959cb77919b2340b8db43ec6694b812603eeceb2a", + "size": 50024, + "subdir": "linux-64", + "timestamp": 1590516380777, + "version": "1.6.0" + }, + "importlib-metadata-1.6.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "900be0084986aef1b8d0d98fd4a2bc55", + "name": "importlib-metadata", + "sha256": "ae414fa682e8a458298537bb1846576b41efa139abee8f878ebcffa046d91d34", + "size": 50276, + "subdir": "linux-64", + "timestamp": 1590516388056, + "version": "1.6.0" + }, + "importlib-metadata-1.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6da39125a80446a0e25d70ae54a2dbd2", + "name": "importlib-metadata", + "sha256": "4233d01354203fb70031075d4279495e9a30659e0cefcfc009588b2dcf7e296c", + "size": 51020, + "subdir": "linux-64", + "timestamp": 1592328454024, + "version": "1.6.1" + }, + "importlib-metadata-1.6.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b3f5491955302e5e60f09f9eee7d9e30", + "name": "importlib-metadata", + "sha256": "beed5b57e3ca8d9227c2b0508a0f6a49bb8e29575b3a2664946cc09476ee55c5", + "size": 51113, + "subdir": "linux-64", + "timestamp": 1592328452018, + "version": "1.6.1" + }, + "importlib-metadata-1.6.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "31755620cf96d9c095a1871782fd1146", + "name": "importlib-metadata", + "sha256": "eec136ae7004e7d9eb5ef0f63900c5736b14580360dc6bdf06f0c8bd11477aa0", + "size": 51407, + "subdir": "linux-64", + "timestamp": 1592328452098, + "version": "1.6.1" + }, + "importlib-metadata-1.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e0ae32a1f5d5ffb81223ac7ce97e918b", + "name": "importlib-metadata", + "sha256": "8310e2bd3f88d14fc4a7c72e593e3cccbd0d34e05f01369b10d038491d6f7a64", + "size": 51973, + "subdir": "linux-64", + "timestamp": 1593446464880, + "version": "1.7.0" + }, + "importlib-metadata-1.7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c83bb4ad15dc93024f24734da5f2aa89", + "name": "importlib-metadata", + "sha256": "c47f54d3f22bae2a63300fb30a13616927567848b32c5e8d0a7813df4800712c", + "size": 51947, + "subdir": "linux-64", + "timestamp": 1593446439336, + "version": "1.7.0" + }, + "importlib-metadata-1.7.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e925d5ebf008bbc8990b7e512f473149", + "name": "importlib-metadata", + "sha256": "b3a51ae5308f1fe13e5d961eb9e69948d3a5262761b870fb7a57661345436689", + "size": 52268, + "subdir": "linux-64", + "timestamp": 1593446439244, + "version": "1.7.0" + }, + "importlib-metadata-1.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e31a188c15a088fc0718b05d4425e11b", + "name": "importlib-metadata", + "sha256": "08e7a463710dda9248e64d3c64287ad53e5291d9737fd54bbb8b1811857e8559", + "size": 52383, + "subdir": "linux-64", + "timestamp": 1608273463536, + "version": "1.7.0" + }, + "importlib-metadata-3.10.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "04e42c5e8fa81e3ec59f395cb2f681eb", + "name": "importlib-metadata", + "sha256": "d3d4ead394a0785ca9b665b8e8acd18691cbad8f6240e9a089ad5f7fa2eed5a6", + "size": 33683, + "subdir": "linux-64", + "timestamp": 1617877348218, + "version": "3.10.0" + }, + "importlib-metadata-3.10.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8d53b4f29c946bed91dd8445bc0a1fb6", + "name": "importlib-metadata", + "sha256": "841e7e471d0fbdab1e185e11c51e099355e30325e80e1a57cfa041ff4a41aee4", + "size": 33764, + "subdir": "linux-64", + "timestamp": 1617877353498, + "version": "3.10.0" + }, + "importlib-metadata-3.10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8e0f600b4b152b5c274230f75edd0dba", + "name": "importlib-metadata", + "sha256": "5b17c1b9470bbffd886c77037bca6b30be66255567801e1a63cde0ff997d5932", + "size": 33992, + "subdir": "linux-64", + "timestamp": 1617874510790, + "version": "3.10.0" + }, + "importlib-metadata-3.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "51d118e8f4871f79930f0878dcfada97", + "name": "importlib-metadata", + "sha256": "f75ada718ca2df259da3c25025e7e328cfd8103dd540e8721734f52e3184abae", + "size": 34022, + "subdir": "linux-64", + "timestamp": 1617877346541, + "version": "3.10.0" + }, + "importlib-metadata-3.7.3-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "77ed319280ead67d4beb7da06bdba4b5", + "name": "importlib-metadata", + "sha256": "7ffd2b6078132b7ae5e15cf0c599a62d0b0e05827706b9de202f61d15c25d260", + "size": 31070, + "subdir": "linux-64", + "timestamp": 1615900373215, + "version": "3.7.3" + }, + "importlib-metadata-3.7.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ca861a8b7cc78245739d646937694eed", + "name": "importlib-metadata", + "sha256": "cb7484af8b6d7a8954f1acd85a76b55a8868bee3dd2638d10f1d497ea71877ab", + "size": 31171, + "subdir": "linux-64", + "timestamp": 1615900494797, + "version": "3.7.3" + }, + "importlib-metadata-3.7.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "143b62c5458f521ef7b11a14f1607bce", + "name": "importlib-metadata", + "sha256": "830e9d3d7113aa7c3c03727ca2af24d8294d8bc38bd0ca239708f8bbc0d9ee9a", + "size": 31321, + "subdir": "linux-64", + "timestamp": 1615900481322, + "version": "3.7.3" + }, + "importlib-metadata-3.7.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "528384616aae9c4345120720a19997dc", + "name": "importlib-metadata", + "sha256": "e96a1a51b478f7eaeb0d0e17ed9f8d918eb51dd7327408ce3a067cad05cf7711", + "size": 31365, + "subdir": "linux-64", + "timestamp": 1615900490143, + "version": "3.7.3" + }, + "importlib-metadata-4.11.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "208a17964d666fdce80ef884d2e7d19f", + "name": "importlib-metadata", + "sha256": "1054cc6975e772bb884ccf1535effb11d42575f3a970063e3b448ab26d5731f5", + "size": 41321, + "subdir": "linux-64", + "timestamp": 1648562468048, + "version": "4.11.3" + }, + "importlib-metadata-4.11.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5db31bc62c4eed746358746991e9003e", + "name": "importlib-metadata", + "sha256": "cac1cbca58b01ab1e881d2595208ad765282babf7321f3d8e350fc379d8a740a", + "size": 42397, + "subdir": "linux-64", + "timestamp": 1676822992907, + "version": "4.11.3" + }, + "importlib-metadata-4.11.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "41963cf1ec8ef8a7bd6cbad3c7e8b26b", + "name": "importlib-metadata", + "sha256": "d6460106c8b08ec3cd8dd952801d524b628a157ee335aff7d562364fa1cadd53", + "size": 40769, + "subdir": "linux-64", + "timestamp": 1648562455026, + "version": "4.11.3" + }, + "importlib-metadata-4.11.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "73453a6753732cf5d25d8fe1b16ffe14", + "name": "importlib-metadata", + "sha256": "2eff13a7597388ed744d7dd0ba301ce287ad651f702b93d8dc2cbb4cb340f338", + "size": 40905, + "subdir": "linux-64", + "timestamp": 1648562454191, + "version": "4.11.3" + }, + "importlib-metadata-4.11.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "17cf1debff15f60c0cf86ae275e33880", + "name": "importlib-metadata", + "sha256": "2b670c99a90ab4372d3e64458fecf11f837bb7443b753887b73fcf6e1e1f5802", + "size": 40911, + "subdir": "linux-64", + "timestamp": 1648544587647, + "version": "4.11.3" + }, + "importlib-metadata-4.6.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "1858c1bf8b5cb951d791ded8e51addfc", + "name": "importlib-metadata", + "sha256": "623934845bc32a5411166c15e735170f3a79ef82ed67d198c99d6b10fa846185", + "size": 38265, + "subdir": "linux-64", + "timestamp": 1631053088668, + "version": "4.6.4" + }, + "importlib-metadata-4.6.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ba5383205d8d0c31fb8ba369d593ab19", + "name": "importlib-metadata", + "sha256": "3ce6eb5beb07f4b5683a658dce46f48bcdda0adca7e966f8ba6d9e1d77b83117", + "size": 38322, + "subdir": "linux-64", + "timestamp": 1631043574684, + "version": "4.6.4" + }, + "importlib-metadata-4.6.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a20f796aaf02ff89726618ea01343a84", + "name": "importlib-metadata", + "sha256": "9594349f7e634c0c5c1506ade8a8cbac376d02612f7a533ad57909c909ca0451", + "size": 38490, + "subdir": "linux-64", + "timestamp": 1631053072153, + "version": "4.6.4" + }, + "importlib-metadata-4.6.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "30290f32e6562ca1e112c4017082a3c2", + "name": "importlib-metadata", + "sha256": "957b864b4acb30907721eefa08ff33605e38d7218133e2baecfcdac88d91b375", + "size": 38541, + "subdir": "linux-64", + "timestamp": 1631053074829, + "version": "4.6.4" + }, + "importlib-metadata-4.8.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "fdaee87d5ffc5a910671095fe7e19a26", + "name": "importlib-metadata", + "sha256": "b8a4db11a6e5aec5109dddc55f0f7a30509a8e50681f9163beb93014a37c1289", + "size": 39278, + "subdir": "linux-64", + "timestamp": 1631916743742, + "version": "4.8.1" + }, + "importlib-metadata-4.8.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "553df9b7dcf1cc3b3875f116aa0537e5", + "name": "importlib-metadata", + "sha256": "f92ea185147d4b2d6abcbf1fb98c01811e26c7541d733ec753138a4bc1c006f8", + "size": 39397, + "subdir": "linux-64", + "timestamp": 1631906794031, + "version": "4.8.1" + }, + "importlib-metadata-4.8.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a3a89e9e8f4ba241659cc2117629702c", + "name": "importlib-metadata", + "sha256": "49f1ce3610196846b7f10c37f952033011832f949a59dee171dad577f72d3f5d", + "size": 39512, + "subdir": "linux-64", + "timestamp": 1631916728650, + "version": "4.8.1" + }, + "importlib-metadata-4.8.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6c3a46ace49b057f31a45b64008a5748", + "name": "importlib-metadata", + "sha256": "4c9f84c64975d1c8ad1817dcc4ecfed5226da3df52c93d4b6a37a0a7a568b402", + "size": 39560, + "subdir": "linux-64", + "timestamp": 1631916728376, + "version": "4.8.1" + }, + "importlib-metadata-4.8.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "46f870cb206be954921ba545b50947ff", + "name": "importlib-metadata", + "sha256": "f6b4a212a1c1b5f950acc501ba4466efa12752a3876097d911d58b268e2b1b2d", + "size": 33721, + "subdir": "linux-64", + "timestamp": 1640886206486, + "version": "4.8.2" + }, + "importlib-metadata-4.8.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "04ab7f6e35b47440c338d9af181a7906", + "name": "importlib-metadata", + "sha256": "868d93d9ec5932056839fb07010c385b1ec9f7d0fa9e3206f77f89d0c49833f1", + "size": 40326, + "subdir": "linux-64", + "timestamp": 1638529639804, + "version": "4.8.2" + }, + "importlib-metadata-4.8.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b13a20bdaa243ce9bc7e829702b6626d", + "name": "importlib-metadata", + "sha256": "f4d19a5ed1739021aeaa9247c4ca77921b19b261fc1d81d6fd638564bf04a3e9", + "size": 40493, + "subdir": "linux-64", + "timestamp": 1638542925707, + "version": "4.8.2" + }, + "importlib-metadata-4.8.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "25d2a4358b62ce3a60bb9dceefc1ab66", + "name": "importlib-metadata", + "sha256": "933d132e1553cf78d295d9ff6e8aefd306e6385d9e5fe5c8df42b3a1ee22569c", + "size": 40517, + "subdir": "linux-64", + "timestamp": 1638542805718, + "version": "4.8.2" + }, + "importlib-metadata-6.0.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "070bf45b15a6013ca5155c51c8f15f7a", + "name": "importlib-metadata", + "sha256": "3da607850129031903a17d32aa2491997c19d8043acdf7dd68bfe9ee2b266bf4", + "size": 37981, + "subdir": "linux-64", + "timestamp": 1678997157064, + "version": "6.0.0" + }, + "importlib-metadata-6.0.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c2a18177b9cdd06e843144e82ddc1bb6", + "name": "importlib-metadata", + "sha256": "edad98b0c7d68cc354156c95dfcd885cd83dec2332d7fcb443fc009067c09bc9", + "size": 45765, + "subdir": "linux-64", + "timestamp": 1678997105314, + "version": "6.0.0" + }, + "importlib-metadata-6.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6284754d30be21d201fa708661a40ee5", + "name": "importlib-metadata", + "sha256": "b4c67d58af728ccc02ded656950609cbb90cfc5c9d23c67962e2118726fa4bdf", + "size": 37562, + "subdir": "linux-64", + "timestamp": 1678997179162, + "version": "6.0.0" + }, + "importlib-metadata-6.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "126b3c1933b7364ff03f67455b687e99", + "name": "importlib-metadata", + "sha256": "a9fe83b3aa6ffb8fc2a1cf767a0fd1a2633375f77b0f28aa6336c745880d4299", + "size": 37588, + "subdir": "linux-64", + "timestamp": 1678997134023, + "version": "6.0.0" + }, + "importlib_metadata-0.17-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "configparser", + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "bec3cdc1d961ab8c65fb1a177e0519ed", + "name": "importlib_metadata", + "sha256": "f6f7ebb07816fe2ce4a0ac1a92cd5bf84b8e268edcf6e72bf39e2e5d8f5b3fe2", + "size": 39580, + "subdir": "linux-64", + "timestamp": 1559659706254, + "version": "0.17" + }, + "importlib_metadata-0.17-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "7a2daa678861d83db80a0dfd7a53ee29", + "name": "importlib_metadata", + "sha256": "97c6e979a3fdf99fb7896ffcca6b0befabdb959c763d6e18bddcf656ab3ee894", + "size": 40342, + "subdir": "linux-64", + "timestamp": 1559659727045, + "version": "0.17" + }, + "importlib_metadata-0.17-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "7c9ff8cd728ea5a0339a2801577b0662", + "name": "importlib_metadata", + "sha256": "4e1db0db2e7457abcdebf3a3a008d5d77dd5ed717c6c998bd4424377e664581f", + "size": 40419, + "subdir": "linux-64", + "timestamp": 1559659699765, + "version": "0.17" + }, + "importlib_metadata-0.19-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser >=3.5", + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "bcf5adad9a0f581ae020b04af66ad773", + "name": "importlib_metadata", + "sha256": "cf211bd3e314dd7301852cc9ccc47b9a34402f9417d8f70507bc1010e40d85d6", + "size": 40704, + "subdir": "linux-64", + "timestamp": 1565189825791, + "version": "0.19" + }, + "importlib_metadata-0.19-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "db04b05d9c53d564b7c70935df92b8d9", + "name": "importlib_metadata", + "sha256": "0ffe7f6a30f82e5a4947feff20aacf6c5ffec3f6919efd8f2c4053173a50f8bb", + "size": 41434, + "subdir": "linux-64", + "timestamp": 1565189331177, + "version": "0.19" + }, + "importlib_metadata-0.19-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "a1aa5f9918c5af9ca05ce48b66a28e54", + "name": "importlib_metadata", + "sha256": "c7086ed75b14a562dc86658e0184342336d415a7ec47d3641d3c238c435cf3b3", + "size": 41478, + "subdir": "linux-64", + "timestamp": 1565189079347, + "version": "0.19" + }, + "importlib_metadata-0.23-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser >=3.5", + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "bd98456929dc6e3e01c6f8e28b0e0150", + "name": "importlib_metadata", + "sha256": "f7263840a829292e77a7a1a9f92cd70d36b58c9cea390313dd55ec2417595ee2", + "size": 43569, + "subdir": "linux-64", + "timestamp": 1569374940359, + "version": "0.23" + }, + "importlib_metadata-0.23-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "8a72d1f141ea8cc20a62258a45bf573c", + "name": "importlib_metadata", + "sha256": "029f4b9b5bfa6a4f4028a7a7ea1e88dfa2b0f9283b2698bc227901be53c6837c", + "size": 44404, + "subdir": "linux-64", + "timestamp": 1569374926672, + "version": "0.23" + }, + "importlib_metadata-0.23-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "c4b0f063b4163ed380299d364fc18492", + "name": "importlib_metadata", + "sha256": "e2d7be99494a63ed768e6bc50979d0dac863ac93999261b55dc72f0822321e54", + "size": 44492, + "subdir": "linux-64", + "timestamp": 1569374920397, + "version": "0.23" + }, + "importlib_metadata-0.23-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "890707cde0dbd29c4583c6aafbf73bb8", + "name": "importlib_metadata", + "sha256": "301d08f4df3b6722e01bdf1c7f586d2f6b663a51ad5209af6ae5893a8e33ee58", + "size": 40749, + "subdir": "linux-64", + "timestamp": 1573469654223, + "version": "0.23" + }, + "importlib_metadata-0.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "d6daffa7ccd86f9befe03155919a6af6", + "name": "importlib_metadata", + "sha256": "6d7872ece3173b38ed70237b9fd4c692f6052ddd0a5bba127f7e772a0fcf6dd2", + "size": 21753, + "subdir": "linux-64", + "timestamp": 1539703310780, + "version": "0.6" + }, + "importlib_metadata-0.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "c532a6df5f9f835d738606306dba8f64", + "name": "importlib_metadata", + "sha256": "571549a0fff470dad8271f6fb199b2eef83eeaaa459437509459ffd141dad196", + "size": 22146, + "subdir": "linux-64", + "timestamp": 1539703377551, + "version": "0.6" + }, + "importlib_metadata-0.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "bf1aad622798e90a8b6a524aa6253e19", + "name": "importlib_metadata", + "sha256": "7b568283b2d560d1913b0968f02446614c7de896e885b0629bf8b2c99d3e3d96", + "size": 22234, + "subdir": "linux-64", + "timestamp": 1539703324459, + "version": "0.6" + }, + "importlib_metadata-0.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "7a2d32c31a38b3bba13db5461d46b33a", + "name": "importlib_metadata", + "sha256": "4f4161fc3251614292bcec80951bccf2c4630f8f929a6403bc2886ec32e7d5a3", + "size": 24247, + "subdir": "linux-64", + "timestamp": 1548295254367, + "version": "0.7" + }, + "importlib_metadata-0.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "50c369d5708aa537222bbbf32dffc25d", + "name": "importlib_metadata", + "sha256": "5757f48af8d88a6560cf0a7816c3bab1d83b992c8d227aea11bfbcd347b942a6", + "size": 24680, + "subdir": "linux-64", + "timestamp": 1548295291914, + "version": "0.7" + }, + "importlib_metadata-0.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "815351d2ba870b2446d5ce6c9ec794aa", + "name": "importlib_metadata", + "sha256": "c4305828514174c3a7019fbd2f14b01ca2498acffebfa46950f690d0df0b35e3", + "size": 24704, + "subdir": "linux-64", + "timestamp": 1548291054129, + "version": "0.7" + }, + "importlib_metadata-0.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser", + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0", + "zipp >=0.3.2" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "091f983c40afd43ce33e7fc8a16b0dbe", + "name": "importlib_metadata", + "sha256": "a8b7cc59a75b730f042b2a82490fb80bd032cfa7b760e80d866bd2e8025370a8", + "size": 33017, + "subdir": "linux-64", + "timestamp": 1552361522552, + "version": "0.8" + }, + "importlib_metadata-0.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.3.2" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "d3fdea6e7b30c97ea43663ea7d7d2f26", + "name": "importlib_metadata", + "sha256": "218c06433511ae81be9c173b56b2995bd5a3419846bde24e09fec87a3aeb8bf7", + "size": 33749, + "subdir": "linux-64", + "timestamp": 1552361554146, + "version": "0.8" + }, + "importlib_metadata-0.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.3.2" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "d8b2e5c52b8a1d3444cbd7994a205fbf", + "name": "importlib_metadata", + "sha256": "1aac3cf35568b626d419b05946665a6c8839716d2446c349736c9b553a9763f8", + "size": 33784, + "subdir": "linux-64", + "timestamp": 1552361481855, + "version": "0.8" + }, + "importlib_metadata-0.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser", + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0", + "zipp >=0.3.2" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "f84e62206e433b8ca2a6264466dc9d22", + "name": "importlib_metadata", + "sha256": "6c5e9fb009cc713501eeb1e8ea665d6e3dd6463aba599bf075e64c7653c69bf2", + "size": 35569, + "subdir": "linux-64", + "timestamp": 1556067217232, + "version": "0.9" + }, + "importlib_metadata-0.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.3.2" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "ee4d4c118caabcac6eb914c9e5eb8c32", + "name": "importlib_metadata", + "sha256": "2623a8ec2834e55b6f14e2419c1dfba7c47acb8b19d3b84f696160add0aa865b", + "size": 36322, + "subdir": "linux-64", + "timestamp": 1556067102786, + "version": "0.9" + }, + "importlib_metadata-0.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.3.2" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "9d5bf87eb18eb3a448950c31508ad6c9", + "name": "importlib_metadata", + "sha256": "b6ac73d756f59803c453566457c89acf1dfab95b7667f28dfdfe0f904acc9fbc", + "size": 36386, + "subdir": "linux-64", + "timestamp": 1556067200544, + "version": "0.9" + }, + "importlib_metadata-1.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser >=3.5", + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "3366080713425786bb13caa074e32566", + "name": "importlib_metadata", + "sha256": "73ae6df12bf21f6c14b3eda1fd3538cb40602d753b62d097f14e2b04bc0268c1", + "size": 45225, + "subdir": "linux-64", + "timestamp": 1575393468208, + "version": "1.1.0" + }, + "importlib_metadata-1.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "45c393eb9898b802440fd5ca2513f3ff", + "name": "importlib_metadata", + "sha256": "76602cc955351c9ce9d5f665523b9a9553a93b354836fd5b7df5e4ed8e5a75a4", + "size": 46086, + "subdir": "linux-64", + "timestamp": 1575393521047, + "version": "1.1.0" + }, + "importlib_metadata-1.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "0441fbd8e2e7b41526c792d553003583", + "name": "importlib_metadata", + "sha256": "2c20c4324f626fbb44a392494e5cc5989eb739d929b88fe5b267cf31355494e4", + "size": 46158, + "subdir": "linux-64", + "timestamp": 1575393392981, + "version": "1.1.0" + }, + "importlib_metadata-1.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "517f7d635795e32095321222e57c5109", + "name": "importlib_metadata", + "sha256": "6dc92f280197f11b72a24aa5ff35c81c839e637fb6d431c3b2335355b1418b4c", + "size": 46459, + "subdir": "linux-64", + "timestamp": 1575393533407, + "version": "1.1.0" + }, + "importlib_metadata-1.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser >=3.5", + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "fc9448a20c6d338692dc1c6a1d332654", + "name": "importlib_metadata", + "sha256": "525263ae36809a627e609eed6c7865c09cff26142c51279b2d3537c89b19c65a", + "size": 45596, + "subdir": "linux-64", + "timestamp": 1576004195238, + "version": "1.2.0" + }, + "importlib_metadata-1.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "819996298e12d2dc321962c30b229731", + "name": "importlib_metadata", + "sha256": "438522e5c1846b2d8b1b22314e17774e3f7f6873e21536ec34428d33ac8103c6", + "size": 46494, + "subdir": "linux-64", + "timestamp": 1576004189902, + "version": "1.2.0" + }, + "importlib_metadata-1.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "f74db9d84e34564f1efe3a26bb774138", + "name": "importlib_metadata", + "sha256": "a94377cb4fff2683359c999538ddd36575bbdbc9ad50750888a1f32a13ef8002", + "size": 46625, + "subdir": "linux-64", + "timestamp": 1576004176228, + "version": "1.2.0" + }, + "importlib_metadata-1.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "a527194cdc9d2bda6debe6170acd1a26", + "name": "importlib_metadata", + "sha256": "bfec531ccf184d1d9fcb92437010cd145b3f51158740a4b279ab686f5530b328", + "size": 46807, + "subdir": "linux-64", + "timestamp": 1576004219932, + "version": "1.2.0" + }, + "importlib_metadata-1.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser >=3.5", + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "ca79c46196b7f35c2de97277973dc205", + "name": "importlib_metadata", + "sha256": "f10f9b83ae083dc470d430693104dff04715f7512b5a75250dc94df05edcb3d2", + "size": 45909, + "subdir": "linux-64", + "timestamp": 1576514618793, + "version": "1.3.0" + }, + "importlib_metadata-1.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "56c543d5e12557f369a75dade9ee3404", + "name": "importlib_metadata", + "sha256": "d3ad433bdf3340a9a4eb3071f6c6e28ce6026e9a641c2e43d2f2e65ea5f9be6d", + "size": 46799, + "subdir": "linux-64", + "timestamp": 1576514713839, + "version": "1.3.0" + }, + "importlib_metadata-1.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "673a2662602c6f76bc58cefc50f60233", + "name": "importlib_metadata", + "sha256": "47af8e21a1f406c049726309ba6dc563cbfaa7c3cb7a6708dbc28e56538a949e", + "size": 46845, + "subdir": "linux-64", + "timestamp": 1576514674055, + "version": "1.3.0" + }, + "importlib_metadata-1.3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "267a58e9fcbcb19930e46cbf5faa910c", + "name": "importlib_metadata", + "sha256": "a5cadecc2dd68700c99df625368e4565f2391b1dd1c1bedae3ea39e5925819b8", + "size": 47100, + "subdir": "linux-64", + "timestamp": 1576514742081, + "version": "1.3.0" + }, + "importlib_metadata-1.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "1e4129e53f8a9e5e0b14e44b95618e46", + "name": "importlib_metadata", + "sha256": "d84fdc11cc0a7723cf255729ceefe92fc62ca27cce5faa0d958ec560194598c8", + "size": 47156, + "subdir": "linux-64", + "timestamp": 1580153661482, + "version": "1.4.0" + }, + "importlib_metadata-1.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "f878f114462b8be08d48ca4cdc5b883c", + "name": "importlib_metadata", + "sha256": "e4d7e37f8a3249d892db0c77156ec580ce1f3d586f585d6fa4d3b3f2c658de0a", + "size": 47261, + "subdir": "linux-64", + "timestamp": 1580153767506, + "version": "1.4.0" + }, + "importlib_metadata-1.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "72866cf5a3e99a456be945b7d3c9b63f", + "name": "importlib_metadata", + "sha256": "df7a5c13b26b63f6863274ab5c373af81944c67a02e339f305b9fc15ec644b0b", + "size": 47438, + "subdir": "linux-64", + "timestamp": 1580153698023, + "version": "1.4.0" + }, + "importlib_metadata-1.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "2b111514a7cd1e1dd3297a7f892b5256", + "name": "importlib_metadata", + "sha256": "b503ac5585ac4f63ee1f78b100a3ab36deed5ede87dc3040ec505c128fa5bb88", + "size": 48345, + "subdir": "linux-64", + "timestamp": 1580835911627, + "version": "1.5.0" + }, + "importlib_metadata-1.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "702dcb9639f426814f3e439286f57205", + "name": "importlib_metadata", + "sha256": "d01f06af577d27cde9f8954266e5abf6139256c29c0af0784dd54dc4226f6428", + "size": 48411, + "subdir": "linux-64", + "timestamp": 1580835921617, + "version": "1.5.0" + }, + "importlib_metadata-1.5.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "3fd92dff78bbe08bacf5cb0869b9f638", + "name": "importlib_metadata", + "sha256": "ac6d1f161079e114debec8f08fb9e3a14af6254f56bc845021ff2075318d0efe", + "size": 48674, + "subdir": "linux-64", + "timestamp": 1580835949770, + "version": "1.5.0" + }, + "importlib_resources-1.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "d19c8ec5528e9149b6f4b842dff54a6b", + "name": "importlib_resources", + "sha256": "49a878d5beb945db61105dd3e84081f3c4cddccb5879a81581b7c54e96e1209a", + "size": 32104, + "subdir": "linux-64", + "timestamp": 1585051569102, + "version": "1.4.0" + }, + "importlib_resources-1.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "1b558657f439bfed835efcf9c6f3c791", + "name": "importlib_resources", + "sha256": "9965f7313186e9a58eb80267748678b014d4ad10f7fb72655c9c729229024c79", + "size": 32227, + "subdir": "linux-64", + "timestamp": 1585051601550, + "version": "1.4.0" + }, + "importlib_resources-1.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "e1acdb46106c69b9e8aeb1a0b71ebae0", + "name": "importlib_resources", + "sha256": "e66ca19279a44d1a7a4a5fc76d0a20114b799d30648d86055be1028e2351e8a5", + "size": 32377, + "subdir": "linux-64", + "timestamp": 1585051586312, + "version": "1.4.0" + }, + "importlib_resources-3.0.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "7866a86973f610526430f9e93af39b85", + "name": "importlib_resources", + "sha256": "6963d97919e8f984ae398f2ea89a7de8c2c65b56a3d6f90b08c49d65f1cdb219", + "size": 35455, + "subdir": "linux-64", + "timestamp": 1605034136267, + "version": "3.0.0" + }, + "importlib_resources-3.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "cc3ce3b6dfcc1f2e26a6934b42a692b0", + "name": "importlib_resources", + "sha256": "10b6a09b38867629648994f3929152cf48e7dcf021fedcc21a956608a42eae7b", + "size": 31620, + "subdir": "linux-64", + "timestamp": 1594360859153, + "version": "3.0.0" + }, + "importlib_resources-3.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "853e94d4d9f9e5f3e10fa6db451fdbd3", + "name": "importlib_resources", + "sha256": "1b8aa4f10c83550bfffe33e61573ec800390e8f8460f28ae3b8bdc1dcda3c0ab", + "size": 35788, + "subdir": "linux-64", + "timestamp": 1605034440631, + "version": "3.0.0" + }, + "importlib_resources-3.3.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "b3216084d6ea13349934fcb9e5c378fe", + "name": "importlib_resources", + "sha256": "95b5925494281485b06e220b524aa89671e4e9fad896ea01b2def37af68677d2", + "size": 37432, + "subdir": "linux-64", + "timestamp": 1603999996610, + "version": "3.3.0" + }, + "importlib_resources-3.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "14ecb9c9885f835039ec9f0414ee2469", + "name": "importlib_resources", + "sha256": "59c38ef40300468d64967747077e6ba19aae9044f63aba7e64a8df6daa720915", + "size": 37571, + "subdir": "linux-64", + "timestamp": 1603999988741, + "version": "3.3.0" + }, + "importlib_resources-3.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "c0f2c4914d9f57ea4810f73f195ff1ee", + "name": "importlib_resources", + "sha256": "f5b5fce3e9d058e7c4965940255bb6b6ee8dbbfcf10a8279a3b7d82ff63e69a1", + "size": 37977, + "subdir": "linux-64", + "timestamp": 1603999993709, + "version": "3.3.0" + }, + "importlib_resources-3.3.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "2421ea56df5d51b72f584c2176d05996", + "name": "importlib_resources", + "sha256": "662639a471dc17b7c72347e056e4a58c40d2eeb954a9aabce1ff73c161d428e3", + "size": 37500, + "subdir": "linux-64", + "timestamp": 1608755762262, + "version": "3.3.1" + }, + "importlib_resources-3.3.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "47a105a834303ba5e9a137d359ee3d86", + "name": "importlib_resources", + "sha256": "2857d82e336127b6881e67931ad96b77a068c2ba340f8f6167fa419868e4c0b1", + "size": 37621, + "subdir": "linux-64", + "timestamp": 1608755761563, + "version": "3.3.1" + }, + "importlib_resources-3.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "65cb92e6b8a20b9c2a6abce093e4e7d2", + "name": "importlib_resources", + "sha256": "cda4a92f60bbfe09fadcb0436ddfe15ce49a604fa233039f282ee39ff2862eba", + "size": 38000, + "subdir": "linux-64", + "timestamp": 1608755761702, + "version": "3.3.1" + }, + "importlib_resources-3.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "a9b25a03d02e14eb01282b23c9d47fb2", + "name": "importlib_resources", + "sha256": "3f6e0d1b163b81d65d1979da91565d592071e5ff0c1670b732fd3864c31aabfa", + "size": 37980, + "subdir": "linux-64", + "timestamp": 1608755762214, + "version": "3.3.1" + }, + "importlib_resources-4.0.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "1450469b7b3ce816f7f9af5c460a45e1", + "name": "importlib_resources", + "sha256": "1ffe712b11e2ec49dd1cb7abb3ab53c14526eb31af49d54d7a8993c5e1a2b0b6", + "size": 34329, + "subdir": "linux-64", + "timestamp": 1608834336975, + "version": "4.0.0" + }, + "importlib_resources-4.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "abd3afc88c5a26897e27f22cc94802d5", + "name": "importlib_resources", + "sha256": "c8fb85da07f3bb5fdbb560830ca586568b72c8cb35b25989ae8fe80f314c4dec", + "size": 34353, + "subdir": "linux-64", + "timestamp": 1608834342861, + "version": "4.0.0" + }, + "importlib_resources-4.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "87b2485e90702060e6fcae5c592d2c23", + "name": "importlib_resources", + "sha256": "53d431e559340293bd4758ff4976ba0d0f67471a4e599bc9e932c780d894113e", + "size": 34767, + "subdir": "linux-64", + "timestamp": 1608834326130, + "version": "4.0.0" + }, + "importlib_resources-4.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "4d1302a8d855b95143d8f099c1f994d1", + "name": "importlib_resources", + "sha256": "bde13009b6e478a52a495f663271464ed83b783e3cfd4407c74371564eab8896", + "size": 34799, + "subdir": "linux-64", + "timestamp": 1608834345583, + "version": "4.0.0" + }, + "importlib_resources-4.1.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "2d5e47f882be610a2450d7f52192555d", + "name": "importlib_resources", + "sha256": "9c264818e8d4349d85e8168114d14b73862cd407036816d13053531b06f0b156", + "size": 33904, + "subdir": "linux-64", + "timestamp": 1608920536490, + "version": "4.1.0" + }, + "importlib_resources-4.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "8cea7881f8eb569f7e264166ccc39413", + "name": "importlib_resources", + "sha256": "a0e652a8c4e82d0711b1a2878e6182063b36a40c5ed6d4bf9d82c3ffba1003fa", + "size": 34035, + "subdir": "linux-64", + "timestamp": 1608920525862, + "version": "4.1.0" + }, + "importlib_resources-4.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "90bc6b38a14c9217cd3ddbf8e125a8d5", + "name": "importlib_resources", + "sha256": "c5468f131a185a01563da09ea6165607fc4c1d2e4ee7f3d313474a43f74bd63c", + "size": 34329, + "subdir": "linux-64", + "timestamp": 1608920521057, + "version": "4.1.0" + }, + "importlib_resources-4.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "a58c22bc28a4deb595e22cf32ae9f369", + "name": "importlib_resources", + "sha256": "f0e4fdb78bf3ee7b14f6cd0554bf374858b329ab08b1dbf5a99cc506fe67ae6a", + "size": 34395, + "subdir": "linux-64", + "timestamp": 1608920527850, + "version": "4.1.0" + }, + "importlib_resources-4.1.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "32b457297b6ddba5615cd495dad774ac", + "name": "importlib_resources", + "sha256": "683f2f85f00382b3abfd27bedc3ee202cefb663df9b5bff01bfa9394633ae3f7", + "size": 33938, + "subdir": "linux-64", + "timestamp": 1609860461401, + "version": "4.1.1" + }, + "importlib_resources-4.1.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "ff50829383c42ca62ed600bfff9709a8", + "name": "importlib_resources", + "sha256": "b4ec5f2962a0cc9ee4dec54b83e3fabfe12b53cefe38b18c17e0db7675f13d26", + "size": 33936, + "subdir": "linux-64", + "timestamp": 1609860333624, + "version": "4.1.1" + }, + "importlib_resources-4.1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "ace8cc421d7fc16c23d6d1532e6581a7", + "name": "importlib_resources", + "sha256": "07200c1feed8b5c4de955d6c101b69d76c61b4d516fa08b8642cbc06e7ca4621", + "size": 34275, + "subdir": "linux-64", + "timestamp": 1609353277649, + "version": "4.1.1" + }, + "importlib_resources-4.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "237ddbea3ca27833d569430c720d9bdb", + "name": "importlib_resources", + "sha256": "5d4db279330162a11ac629853056959bcc83d6cdebdd7923716357c5a3c3286a", + "size": 34374, + "subdir": "linux-64", + "timestamp": 1609860196526, + "version": "4.1.1" + }, + "importlib_resources-5.0.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "a72010128a2495ea5e1d059d9881674b", + "name": "importlib_resources", + "sha256": "d512c08d0a717404025dcf28a392a397f4d350f6b631aed990e23c0842a78a89", + "size": 33568, + "subdir": "linux-64", + "timestamp": 1610303935680, + "version": "5.0.0" + }, + "importlib_resources-5.0.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "59d6572ef635d9b0bfc71e7c025ddad4", + "name": "importlib_resources", + "sha256": "e3e265c46f1d200db82e05a5c4a1d852f4e0dd7decd990fe9f3a7adc96c9954e", + "size": 38144, + "subdir": "linux-64", + "timestamp": 1610481599840, + "version": "5.0.0" + }, + "importlib_resources-5.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "2019b2c0650fd84219c5b5563efdaba2", + "name": "importlib_resources", + "sha256": "c9ed7ab2866c5d55efa87b661d1682eea2e415d45de44dbc934b14cd662f208f", + "size": 33632, + "subdir": "linux-64", + "timestamp": 1610303928139, + "version": "5.0.0" + }, + "importlib_resources-5.0.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "caccc0eaeda29873e265e15acae27a6c", + "name": "importlib_resources", + "sha256": "a33696366cb665dd859f1bf6b6dee63a509f9fa40538f23bc57431d8b9ea67bc", + "size": 38274, + "subdir": "linux-64", + "timestamp": 1610481523126, + "version": "5.0.0" + }, + "importlib_resources-5.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "ae38c6b0334d3a98f023ee93d61fe349", + "name": "importlib_resources", + "sha256": "6893ef9a936b4806c3e022e9f7b441d5a8ea9c991e93aa47b48a4b4e6bc733d4", + "size": 33855, + "subdir": "linux-64", + "timestamp": 1610303967414, + "version": "5.0.0" + }, + "importlib_resources-5.0.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "238081d9655ccd8fad7a758616533cbb", + "name": "importlib_resources", + "sha256": "f1bd134d0adffd1c634d632b89f44860d0761a00faefc0fd40ada1defaa9c963", + "size": 38467, + "subdir": "linux-64", + "timestamp": 1610481119514, + "version": "5.0.0" + }, + "importlib_resources-5.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "569d70ba0549de16ec5ebaf4552c1ddf", + "name": "importlib_resources", + "sha256": "d231dfa3e6075680ea339c5bf169f7e090e5887871055a2ea86bd0d378918f3c", + "size": 33985, + "subdir": "linux-64", + "timestamp": 1610303929224, + "version": "5.0.0" + }, + "importlib_resources-5.0.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "38d0b9c50430ed4a9d5363812c1d53b7", + "name": "importlib_resources", + "sha256": "3c5408305c6d0518c24543f4ea4314666dbdc215352fc6905758020008b87307", + "size": 38609, + "subdir": "linux-64", + "timestamp": 1610481596107, + "version": "5.0.0" + }, + "importlib_resources-5.1.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "5c1a8f025d134c82035c7d5b79a28ca0", + "name": "importlib_resources", + "sha256": "599c9512c1d233542a22c9915a5ac1b10f7790967aa94a43cb816215297e1cc0", + "size": 36598, + "subdir": "linux-64", + "timestamp": 1611082891907, + "version": "5.1.0" + }, + "importlib_resources-5.1.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "215e3e0cdbec97a5b4d07d350c657891", + "name": "importlib_resources", + "sha256": "7d3ac59aa52aa58431be12ba78bcadabf811ddc8e81637766b67bd0d979e9fd2", + "size": 36718, + "subdir": "linux-64", + "timestamp": 1611082893936, + "version": "5.1.0" + }, + "importlib_resources-5.1.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "b7247cc74aa5005f0027727eeb6e6f6c", + "name": "importlib_resources", + "sha256": "6ba527194386231fa892714b0780df5130ace2454a73543a2c07c61f7abcc454", + "size": 36966, + "subdir": "linux-64", + "timestamp": 1611082096345, + "version": "5.1.0" + }, + "importlib_resources-5.1.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "1420017e06c6b2fa4caf1a4f9ab14604", + "name": "importlib_resources", + "sha256": "780a035c32b72fb5b40da01779569f6295fa998075fc16fef89c4f1a40cb31eb", + "size": 37063, + "subdir": "linux-64", + "timestamp": 1611082868990, + "version": "5.1.0" + }, + "importlib_resources-5.1.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "7070182ef1c6e0d74b406a0f3d340bc4", + "name": "importlib_resources", + "sha256": "abd6274d26c84d3c07fcff38b40895675e4f216f194ceddf66b70dc186459e28", + "size": 37698, + "subdir": "linux-64", + "timestamp": 1614615181800, + "version": "5.1.1" + }, + "importlib_resources-5.1.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "4d3c20b75b1bb6f80e7c5630b2b6bcfd", + "name": "importlib_resources", + "sha256": "0f7d3d5570ae897e11ea1f697b06f1b3758b3225d1084a8c090cccd59e55d6f4", + "size": 37737, + "subdir": "linux-64", + "timestamp": 1614616372780, + "version": "5.1.1" + }, + "importlib_resources-5.1.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "7c26e63d09d70fed1c867da906047c00", + "name": "importlib_resources", + "sha256": "c3803e02e0b212e075eb35014312ee22c563e365c1147a072595644b10f4c6f1", + "size": 38108, + "subdir": "linux-64", + "timestamp": 1614616365065, + "version": "5.1.1" + }, + "importlib_resources-5.1.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "9f80f8b5e82a37ac5d0d048c42e3d535", + "name": "importlib_resources", + "sha256": "ae16cced9795568d800c12d8427dc102fe8ce2639d4542ad7c0f5b5bff8ba63a", + "size": 38245, + "subdir": "linux-64", + "timestamp": 1614615572998, + "version": "5.1.1" + }, + "importlib_resources-5.1.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "0755d688a90ceb5fbc2e9c3d2a06454f", + "name": "importlib_resources", + "sha256": "a7934ac1a847725ab5224263ff82169175fec2038c7272d78aa9778ba29f0725", + "size": 37874, + "subdir": "linux-64", + "timestamp": 1614969166535, + "version": "5.1.2" + }, + "importlib_resources-5.1.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "3a6d63c7691ce9af0b83efef1f89034a", + "name": "importlib_resources", + "sha256": "67f7cf9dcde33ebc7a6354b19caf319e7a66233a13e265e3ace318ca83c38870", + "size": 37851, + "subdir": "linux-64", + "timestamp": 1614969328489, + "version": "5.1.2" + }, + "importlib_resources-5.1.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "6d7df79ca72c197133bcafd0853d00b2", + "name": "importlib_resources", + "sha256": "17b33181b92eb9a1390c4b76a3f4208d9f589207efba4887bc987a4e46cbff0b", + "size": 38192, + "subdir": "linux-64", + "timestamp": 1614969306177, + "version": "5.1.2" + }, + "importlib_resources-5.1.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "ed050a548d1c2cec1fc09788a739cafc", + "name": "importlib_resources", + "sha256": "2feb2046be08ddfb2daef6ee3982808cc5f458253a6b1fc187e3de111fc55afd", + "size": 38312, + "subdir": "linux-64", + "timestamp": 1614969310955, + "version": "5.1.2" + }, + "importlib_resources-5.1.3-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "38f7906b95e70ec9a701202ab4302297", + "name": "importlib_resources", + "sha256": "348f248defb90d514dfe81576ae1a610a429d06547c2dbc7ee7f2911ac6daf5c", + "size": 39082, + "subdir": "linux-64", + "timestamp": 1620913895816, + "version": "5.1.3" + }, + "importlib_resources-5.1.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "0bd76d0b166aa5619b827b82c020ddb9", + "name": "importlib_resources", + "sha256": "2069c50202722b08c4c20bd03b54ba6d3d44d98a1fc53fdebf9c03d64e89236a", + "size": 39221, + "subdir": "linux-64", + "timestamp": 1620909527956, + "version": "5.1.3" + }, + "importlib_resources-5.1.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "b37b81c389efb92260eba421f227170b", + "name": "importlib_resources", + "sha256": "af3aee3603219a708cf488c555a07d1a7d161793020855405b019894b610b838", + "size": 39545, + "subdir": "linux-64", + "timestamp": 1620913887732, + "version": "5.1.3" + }, + "importlib_resources-5.1.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "59feabb984252346f9b0618dbd408d9f", + "name": "importlib_resources", + "sha256": "b6e1f8f6077c97059412ee2e96e8529be749a42e4a6fdd9252f987ec531adeec", + "size": 39638, + "subdir": "linux-64", + "timestamp": 1620913551064, + "version": "5.1.3" + }, + "importlib_resources-5.1.4-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "9792da4804107058e4bcb1fcfc12c494", + "name": "importlib_resources", + "sha256": "0a97be5bd129684a38a352cd2bf90a5fd3a071edf8dd3ee3bb596ec1ae7b3a71", + "size": 39110, + "subdir": "linux-64", + "timestamp": 1622567524906, + "version": "5.1.4" + }, + "importlib_resources-5.1.4-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "76b79d354b38cb4c0da0aa2d65367236", + "name": "importlib_resources", + "sha256": "26fd14c7b7b7e0a9945da2a85bdf8e98875d7c9b8c948940becb62cf63747259", + "size": 39335, + "subdir": "linux-64", + "timestamp": 1622567525511, + "version": "5.1.4" + }, + "impyla-0.14.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "thrift", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1ca71bfde629c8759c72f977406182e3", + "name": "impyla", + "sha256": "97e37f9d65f064d224c125d55bb8ecfa7d93bad749df1a17d182e3b313a161d4", + "size": 235434, + "subdir": "linux-64", + "timestamp": 1522780092223, + "version": "0.14.0" + }, + "impyla-0.14.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2b89610e5c7563c9ae716e2578045a54", + "name": "impyla", + "sha256": "f25233e5e9f5a8a7172bbdd9b9b68ef0ed2cadf2d4c7187593535f4bb837c28c", + "size": 90916, + "subdir": "linux-64", + "timestamp": 1522780172113, + "version": "0.14.0" + }, + "impyla-0.14.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "998459566529ab286d19c460720fcae8", + "name": "impyla", + "sha256": "a58d8058ada48924f1829cc6b7cfa469c5b6aebda07c8cfd7c520ff150902d5f", + "size": 90971, + "subdir": "linux-64", + "timestamp": 1522779801524, + "version": "0.14.0" + }, + "impyla-0.14.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "thrift", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3e76ada9a89a82a7256d869513a7b184", + "name": "impyla", + "sha256": "30c2446823d1a5e9b9ffdf4eb71d1b5c0f3c70dff5365bbea239dc4dc0ab7e3c", + "size": 235266, + "subdir": "linux-64", + "timestamp": 1522787603146, + "version": "0.14.1" + }, + "impyla-0.14.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "thrift", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b76f76c7efc5223c826140f44a4c8613", + "name": "impyla", + "sha256": "cdbb0f89c6670e09216bc9ca107d654bc03bff4fa22ce197136925d0928c9442", + "size": 235659, + "subdir": "linux-64", + "timestamp": 1530893431896, + "version": "0.14.1" + }, + "impyla-0.14.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "edb5e7bf8c26add2579311a0660fda4a", + "name": "impyla", + "sha256": "00e574664cbfa63d974cc3af3affcfc0b22aa4d5f11ebf7503ba353d6153942a", + "size": 90790, + "subdir": "linux-64", + "timestamp": 1522787550613, + "version": "0.14.1" + }, + "impyla-0.14.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8a54e37df95413a0bf5f022071e777e9", + "name": "impyla", + "sha256": "ad513db5caa6abbd71a7e450f73283a1eff01b28bef4c497843b940f6c3c6dda", + "size": 90848, + "subdir": "linux-64", + "timestamp": 1522787613060, + "version": "0.14.1" + }, + "impyla-0.14.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fc17069347eaf6461f98baea02fa9562", + "name": "impyla", + "sha256": "8a169cf73790ae79d7cb4ff1e0d23546b5d056cf8c93d73eb85d254b4fa60745", + "size": 91037, + "subdir": "linux-64", + "timestamp": 1530893399207, + "version": "0.14.1" + }, + "impyla-0.14.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d3bf4755125ee8fe862d3a1e685dfcd3", + "name": "impyla", + "sha256": "876b5b1ae3b92d68b0840f867da7488c3b99a9a535952c9af4458cbe2b665fba", + "size": 90648, + "subdir": "linux-64", + "timestamp": 1530893367689, + "version": "0.14.1" + }, + "impyla-0.14.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "thrift", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "01fedbc1e365613af03fa8f308717fc7", + "name": "impyla", + "sha256": "f395827f57e591eab926b7f4c2c3c977cdd9524e9110bbc6bf4c1838a9603bb7", + "size": 240892, + "subdir": "linux-64", + "timestamp": 1556067466261, + "version": "0.14.2" + }, + "impyla-0.14.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "08a4c2918328094ee4a07c9218445d19", + "name": "impyla", + "sha256": "03557d71e52a69cda0f7c7d5fd9f86e88614902e01d93611711ea3d446720eb6", + "size": 194783, + "subdir": "linux-64", + "timestamp": 1556067645775, + "version": "0.14.2" + }, + "impyla-0.14.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "df77e1f48db9a10bae2077ebc97d5b56", + "name": "impyla", + "sha256": "89975d3792ed08c54829415da1ca646ac19a0f13e6020a55f330168633de38cb", + "size": 202911, + "subdir": "linux-64", + "timestamp": 1556067455974, + "version": "0.14.2" + }, + "impyla-0.15.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "thrift", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1b9c2477663523bb8d3c8c5666c4f4bc", + "name": "impyla", + "sha256": "86848aa7753cbd1ba2165dd52155a8e46808a17de34a373e4aa12d6a21f98e6b", + "size": 353948, + "subdir": "linux-64", + "timestamp": 1559063928497, + "version": "0.15.0" + }, + "impyla-0.15.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "933327e161f2cee1d3f5be9447a93fcd", + "name": "impyla", + "sha256": "3de841e990483611bca170eae6c2aa28d5de95ee79df9e6c3adfdf882db4a9ac", + "size": 383668, + "subdir": "linux-64", + "timestamp": 1559063951692, + "version": "0.15.0" + }, + "impyla-0.15.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "004b495ad79e6d3af3f2d328ad0ba7a3", + "name": "impyla", + "sha256": "cc240e78d0542df994543c0507e036a0ea71a954297b36020c2ba2141798da70", + "size": 389970, + "subdir": "linux-64", + "timestamp": 1559063865075, + "version": "0.15.0" + }, + "impyla-0.15.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.8,<3.9.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "978f568c6dea0e1eaed0cd4d56527068", + "name": "impyla", + "sha256": "afa27fe25d084826ab414b4e9b38dadf2c41be687ac4573513699c62c1bbb421", + "size": 378366, + "subdir": "linux-64", + "timestamp": 1574157921472, + "version": "0.15.0" + }, + "impyla-0.16.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.10,<3.11.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "316b57d73ad69ef7ed391d878cd4f71a", + "name": "impyla", + "sha256": "e096e39987b2b339d09e0251b27fa9b18ae36339c51b9cd919e56772384fc4aa", + "size": 386902, + "subdir": "linux-64", + "timestamp": 1640812191322, + "version": "0.16.2" + }, + "impyla-0.16.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d92cb4fd321f4667837f7241efbf7971", + "name": "impyla", + "sha256": "8ec483bf5f8827b3eae6ae61f8b353e15cc62c33ee9dbedc09277e03a8e34143", + "size": 395266, + "subdir": "linux-64", + "timestamp": 1592228759779, + "version": "0.16.2" + }, + "impyla-0.16.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7d15279cb737fede879fed9e22bc349a", + "name": "impyla", + "sha256": "4c970bb36ea556722ad532392068b9818b710704e29463ed9c84821f99cf2c5d", + "size": 390131, + "subdir": "linux-64", + "timestamp": 1592228570415, + "version": "0.16.2" + }, + "impyla-0.16.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ce763f99f6883e200e90ee2b1e21f8ca", + "name": "impyla", + "sha256": "e22c65820cd4948d79f38f02dc7432c32e9d3b1c6505ea074eb0c2b535eeb1a5", + "size": 392104, + "subdir": "linux-64", + "timestamp": 1636035816587, + "version": "0.16.2" + }, + "impyla-0.16.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.8,<3.9.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "662b4d375dfae6110f5b5ff33e7529b1", + "name": "impyla", + "sha256": "67693a218cb252fb203091ef7e8983a5c6301b5a97d582dfdfae0116a4485169", + "size": 385913, + "subdir": "linux-64", + "timestamp": 1592228759938, + "version": "0.16.2" + }, + "impyla-0.16.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.8,<3.9.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "877f57a801298d7c696e54302f17ab8a", + "name": "impyla", + "sha256": "79f1c5334acd0f3f87c761f9947a1fe1e77d38317a7e4b55581793a636fd2eb2", + "size": 389437, + "subdir": "linux-64", + "timestamp": 1636035818301, + "version": "0.16.2" + }, + "impyla-0.16.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.9,<3.10.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0cc0c1ac8a534582e5ad247042db9a2f", + "name": "impyla", + "sha256": "ab34d4b0f4b64c0f2d65444544943bc6ef4138bfed2c0461bc02ac873ef384fe", + "size": 384139, + "subdir": "linux-64", + "timestamp": 1636035820340, + "version": "0.16.2" + }, + "impyla-0.16.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=3.10,<3.11.0a0", + "six", + "thriftpy2 >=0.4.0,<0.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5d1bcc36f612e5cee44c7603cfec9ea6", + "name": "impyla", + "sha256": "e2e42001f4afaf4da7ab261394a8a6b14ea809ae35c7dc23b06f43caeea861e1", + "size": 407483, + "subdir": "linux-64", + "timestamp": 1677160437855, + "version": "0.16.3" + }, + "impyla-0.16.3-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=3.11,<3.12.0a0", + "six", + "thriftpy2 >=0.4.0,<0.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eec9794f9a8841bb0f0d8c2420e0dbf3", + "name": "impyla", + "sha256": "d59e95f1295b77089128c1bf4b55ae0391895e7761c2e80f80f00d4adac27141", + "size": 521936, + "subdir": "linux-64", + "timestamp": 1677125418024, + "version": "0.16.3" + }, + "impyla-0.16.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9726d721a6c2fdeffaab88d7a4f08a15", + "name": "impyla", + "sha256": "743b2a624ad4343a02e209ae0ffb8603e0525fb5e6ff2122103768e7bf180a9a", + "size": 387017, + "subdir": "linux-64", + "timestamp": 1602258512962, + "version": "0.16.3" + }, + "impyla-0.16.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f20c26fdb306b7cf5a3a85db158e8587", + "name": "impyla", + "sha256": "ef7f721c99ed869fb67a753262ce2e03f6df8ab0c640826bc82eefd45fe59d4b", + "size": 383128, + "subdir": "linux-64", + "timestamp": 1632732177321, + "version": "0.16.3" + }, + "impyla-0.16.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a7c728bf1ce4eef7c56f4abcb51fb5c7", + "name": "impyla", + "sha256": "ee4238b0a441b8611c735296ab51e4c6ef1df5aa00981c90e8ba3fbfc6976e9d", + "size": 385308, + "subdir": "linux-64", + "timestamp": 1602258517684, + "version": "0.16.3" + }, + "impyla-0.16.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "de19dcbcec8ef7c1658f2442746ee0fe", + "name": "impyla", + "sha256": "e4d915f70f42997722c9354863ea49347fc50239e7b742ee267c393a898351e9", + "size": 382112, + "subdir": "linux-64", + "timestamp": 1632742513329, + "version": "0.16.3" + }, + "impyla-0.16.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=3.7,<3.8.0a0", + "six", + "thriftpy2 >=0.4.0,<0.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f82676c7fffad21fefb197300c79419b", + "name": "impyla", + "sha256": "5b64b0d7d84a1c51b60ea4df29b60843c21b92b5c63acaa6300e2f17f672fed7", + "size": 401341, + "subdir": "linux-64", + "timestamp": 1677160495553, + "version": "0.16.3" + }, + "impyla-0.16.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.8,<3.9.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5530c6eff442f3c27a957b692e249c3d", + "name": "impyla", + "sha256": "e39814d6bcb4b6927bb0d5304a989d93d22c497cfd8ffb34a325ee3d1344a235", + "size": 392927, + "subdir": "linux-64", + "timestamp": 1602258519631, + "version": "0.16.3" + }, + "impyla-0.16.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.8,<3.9.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "43362b097aefb3612780d7bf1e40ec7b", + "name": "impyla", + "sha256": "5bb4dd984074ff17ae665a64261809f2652c5cf811db20e8f50ece6e4ffb297c", + "size": 390774, + "subdir": "linux-64", + "timestamp": 1632742509905, + "version": "0.16.3" + }, + "impyla-0.16.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=3.8,<3.9.0a0", + "six", + "thriftpy2 >=0.4.0,<0.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dc602b06ab92283cba525ff3cf9fafaf", + "name": "impyla", + "sha256": "6211f47fdeedafefc459e6082480ee15db22e918cc6dc7b84dca8f2aeda88627", + "size": 400975, + "subdir": "linux-64", + "timestamp": 1677160524272, + "version": "0.16.3" + }, + "impyla-0.16.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.9,<3.10.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f91d1787b98eb58e32ce78f1f8d7bca2", + "name": "impyla", + "sha256": "a3cbc19b6302705e9d2967abe63b1d3d40dc862f8c4eb39d543e748d7ee1ffc5", + "size": 392853, + "subdir": "linux-64", + "timestamp": 1632742469081, + "version": "0.16.3" + }, + "impyla-0.16.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=3.9,<3.10.0a0", + "six", + "thriftpy2 >=0.4.0,<0.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "514634c3a30f0b70b80474ff10a3998f", + "name": "impyla", + "sha256": "f4b6dd1dcd0e3b6769ec3ae4248a4b913c5c093ba81f63949c3b4e9d349d5ae1", + "size": 401245, + "subdir": "linux-64", + "timestamp": 1677160466542, + "version": "0.16.3" + }, + "incremental-17.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "d32d084c0994706787053c18b0684ab1", + "name": "incremental", + "sha256": "949330b5f72a2ed0aa6a46f72493d23764979915d780506738285bfb4f57f187", + "size": 24923, + "subdir": "linux-64", + "timestamp": 1530919745465, + "version": "17.5.0" + }, + "incremental-17.5.0-py27h1923969_0.tar.bz2": { + "build": "py27h1923969_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "c928750c50a0ab0bc8ae7ca225c12b36", + "name": "incremental", + "sha256": "8130f2adce96843d002b6bcee5888e93200c713ddeb7ce483e5a6daf1dad6e3e", + "size": 25185, + "subdir": "linux-64", + "timestamp": 1508608341130, + "version": "17.5.0" + }, + "incremental-17.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "3ed12d2a7ed6950ca5a7eed7144621f9", + "name": "incremental", + "sha256": "b114c025cb811ff359ee6117523fc6e94e1f2a7563565c2082fdf9f888ea5274", + "size": 25480, + "subdir": "linux-64", + "timestamp": 1534350999806, + "version": "17.5.0" + }, + "incremental-17.5.0-py35head57c3_0.tar.bz2": { + "build": "py35head57c3_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "27e7931f7ccd349bd4afb5909def3967", + "name": "incremental", + "sha256": "a705637c4b387535f5229c33cde042864b708860e0836d58292ef371ee4f0142", + "size": 25843, + "subdir": "linux-64", + "timestamp": 1508608357898, + "version": "17.5.0" + }, + "incremental-17.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "f7b05a224e915bf0f5f5800ac89ac547", + "name": "incremental", + "sha256": "35e9d6fe2de4eea5c0473e8849e59fad847ab993bcdf74f0155b483ace916e56", + "size": 25388, + "subdir": "linux-64", + "timestamp": 1530919689032, + "version": "17.5.0" + }, + "incremental-17.5.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "937bfae5a5aae4d536b9300f894bc8ff", + "name": "incremental", + "sha256": "2c2a0fd8298074dc76f73047f94e7dd3aadb3b621cd7bf22371fc873405d52b7", + "size": 246587, + "subdir": "linux-64", + "timestamp": 1614067516025, + "version": "17.5.0" + }, + "incremental-17.5.0-py36hff7e2ee_0.tar.bz2": { + "build": "py36hff7e2ee_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "aea0f3518b269c9eb85353be58ba985f", + "name": "incremental", + "sha256": "917b496e1b0ade8ccb9bdca0616c49c20463b29f77fb9a4dcb2f17061adef272", + "size": 25647, + "subdir": "linux-64", + "timestamp": 1508608357827, + "version": "17.5.0" + }, + "incremental-17.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "2b9826cc80a095e455b99b5474be7601", + "name": "incremental", + "sha256": "e86e11ea6aab123d4d5ab6aced1e392b6f0b5194364639ab11cdf5eadad01470", + "size": 25446, + "subdir": "linux-64", + "timestamp": 1530919717388, + "version": "17.5.0" + }, + "incremental-17.5.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "c4407baf2e18e7b37c0b29c96c51014d", + "name": "incremental", + "sha256": "e51fe44b88a4077a279eedff2a366966edf3e8527af0e54869f851a331009098", + "size": 246532, + "subdir": "linux-64", + "timestamp": 1614067501575, + "version": "17.5.0" + }, + "incremental-17.5.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "5bdd5a58e16fee14043060dfe5185284", + "name": "incremental", + "sha256": "69dc7e0bd991cc80f468426c005eb80194564d14fe993e6967128761daee3e50", + "size": 25965, + "subdir": "linux-64", + "timestamp": 1572357265596, + "version": "17.5.0" + }, + "incremental-17.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "6312e438d0ca7cda2c4f415d89e1bd61", + "name": "incremental", + "sha256": "3e6a5dc9f9a1a30bccb668327e7fbba16c27108449c59b23e75962f55c82695c", + "size": 245727, + "subdir": "linux-64", + "timestamp": 1614067507701, + "version": "17.5.0" + }, + "incremental-17.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "cdddbd40d5b542dab89c03bb3861669d", + "name": "incremental", + "sha256": "5ab8f976e0d5b616a965376d8bd4bd08e7398751ebf139b9ddb1ff81048ed3d2", + "size": 26058, + "subdir": "linux-64", + "timestamp": 1607007534952, + "version": "17.5.0" + }, + "infinity-1.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bd634e617105ae5107bbf3f6e313f989", + "name": "infinity", + "sha256": "8bcf6b804b9afe69a7f479802baa2801fc97fb5925a2a82af81e27110f863128", + "size": 7207, + "subdir": "linux-64", + "timestamp": 1530897681937, + "version": "1.4" + }, + "infinity-1.4-py27h1eb3021_0.tar.bz2": { + "build": "py27h1eb3021_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "45e16ccf77c1425d2134a57d159fefa8", + "name": "infinity", + "sha256": "6e75e916e3c5e64cf908ea8bceb16cd08794c74d65e3fd34796bfdedb2999ce7", + "size": 7460, + "subdir": "linux-64", + "timestamp": 1507384407568, + "version": "1.4" + }, + "infinity-1.4-py35hb24af9e_0.tar.bz2": { + "build": "py35hb24af9e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "38644b84789acbbf851a500518514c68", + "name": "infinity", + "sha256": "b1c68b32c0cf2eeee61199e674c458b309fee65f5e2cefb37d3249941ddb152b", + "size": 7682, + "subdir": "linux-64", + "timestamp": 1507384413971, + "version": "1.4" + }, + "infinity-1.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b6006f3b51803e82b45de0b65f620e7b", + "name": "infinity", + "sha256": "e317fc416e103a079029a7a880b3209f8ce671e0d759026707b6ec1854a68bf3", + "size": 7371, + "subdir": "linux-64", + "timestamp": 1530897735851, + "version": "1.4" + }, + "infinity-1.4-py36h8fa02c4_0.tar.bz2": { + "build": "py36h8fa02c4_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f683409f849f3450f21e5a98693ef437", + "name": "infinity", + "sha256": "cc09e2fcf9c44aa4feeb3b37fd7e8725364f3e63a19d48dea417ea287b616730", + "size": 7641, + "subdir": "linux-64", + "timestamp": 1507384419631, + "version": "1.4" + }, + "infinity-1.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9872512154da6ef15f9a686876535fe0", + "name": "infinity", + "sha256": "9ab020f63d9deb30514d7d014cfa4ea13e0eaba164b6c005c981e6d164d7ad16", + "size": 7358, + "subdir": "linux-64", + "timestamp": 1530897708536, + "version": "1.4" + }, + "infinity-1.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e0d51abc53de221d63a59e8e38baea04", + "name": "infinity", + "sha256": "2e0a6dedc0433b457d81ca40726392468e2a913330455818c982821a6960b95d", + "size": 7808, + "subdir": "linux-64", + "timestamp": 1572437472829, + "version": "1.4" + }, + "infinity-1.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9470a5f1f62543d643ad4b5e27440dad", + "name": "infinity", + "sha256": "9ed56dd54424226f9346beb27ae078f6bcb701f6ecbc9f28ba7299040a4a7faa", + "size": 7594, + "subdir": "linux-64", + "timestamp": 1640791066922, + "version": "1.5" + }, + "infinity-1.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a109f89146b7e0f466540f26bc553704", + "name": "infinity", + "sha256": "d468468913f7c2a9a27e1e6025f9035edeeed43e35d4fbb3c639f0304b6b2b81", + "size": 8747, + "subdir": "linux-64", + "timestamp": 1676825277450, + "version": "1.5" + }, + "infinity-1.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9b10bb1f21ffc9a17aa1e6735796b22b", + "name": "infinity", + "sha256": "c09f5703a89e9f4afe08fd490c428a65d1148cd652be6c1ae81181a66caa4fc7", + "size": 8441, + "subdir": "linux-64", + "timestamp": 1598411740229, + "version": "1.5" + }, + "infinity-1.5-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b3082bf336ef557f230d5ccf37215c8b", + "name": "infinity", + "sha256": "52588712316870af382f730f8665b5648f2e8cd2948ae86de3e66d343bf0e700", + "size": 8546, + "subdir": "linux-64", + "timestamp": 1613236247085, + "version": "1.5" + }, + "infinity-1.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "db6e5d25a5455e21c9f165353049655e", + "name": "infinity", + "sha256": "db57813c1a52e8ba9118d1684ddf04c25a87ee9956cbc3e9d9259a6108aa2756", + "size": 8447, + "subdir": "linux-64", + "timestamp": 1598411741799, + "version": "1.5" + }, + "infinity-1.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d2220a283cdc016fd0a66a32c91f43f7", + "name": "infinity", + "sha256": "1ca8e3cff1583ab5c00cc5dd81acb57609343ac31e70d143110077e1998c0d9e", + "size": 8504, + "subdir": "linux-64", + "timestamp": 1613236746180, + "version": "1.5" + }, + "infinity-1.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e3202337e48b69dbeeb241f933c7ac1b", + "name": "infinity", + "sha256": "650d7b6157e036458438989c3b906fe0ae6a116810e72df7519873bf492f563e", + "size": 8473, + "subdir": "linux-64", + "timestamp": 1598411766619, + "version": "1.5" + }, + "infinity-1.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "960d9b9c97730f438a3f58048cadbc6b", + "name": "infinity", + "sha256": "1ed0e25edbf3d8468719d6c1107ed7ef4eff76bcc9ad061e0f6f67595cedef38", + "size": 8572, + "subdir": "linux-64", + "timestamp": 1613236758242, + "version": "1.5" + }, + "infinity-1.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f192ca37c885f6695f5675bf14e64f86", + "name": "infinity", + "sha256": "8d57a100eb8b42bcc2250ea624ff83a97a3396ea47275087eefead1a55b5c748", + "size": 8608, + "subdir": "linux-64", + "timestamp": 1613236745794, + "version": "1.5" + }, + "inflect-4.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bea89d6dc29fe5efaa1d23b9f6cabbaf", + "name": "inflect", + "sha256": "fad962c584aba75c5d84f3bb41cd6cc2bbd55ae7a01d0c6012d203b731d489af", + "size": 63266, + "subdir": "linux-64", + "timestamp": 1580836718702, + "version": "4.1.0" + }, + "inflect-4.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "294be9f7f1880d5e83b36f7bb78afb3d", + "name": "inflect", + "sha256": "806f73243fe6520743c16efb1936598acc1da1809a775bf89ef2cb927d796112", + "size": 61246, + "subdir": "linux-64", + "timestamp": 1580836718073, + "version": "4.1.0" + }, + "inflect-4.1.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "67d4ac3c047ea6e7eb41793487d67cc4", + "name": "inflect", + "sha256": "46ea33a089ef327dab63404cdb0c2a23920f4f8914218c37146c83c5aaa3b2b1", + "size": 57106, + "subdir": "linux-64", + "timestamp": 1594361274391, + "version": "4.1.0" + }, + "inflect-4.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ec0db4b8e35aaa156340540cdbb3c02", + "name": "inflect", + "sha256": "dd1b3ec3ac5dd99c5897f64c6038f83e0ce136415ce1952d4264364d41fce088", + "size": 61529, + "subdir": "linux-64", + "timestamp": 1580836709008, + "version": "4.1.0" + }, + "inflect-5.0.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a941c0f74ad5e1d9c2a1eaa9592584c", + "name": "inflect", + "sha256": "97363b18b6f338e07c332d4e5ec29ff8723fbfe34aaec62fcfde476d1be316eb", + "size": 60346, + "subdir": "linux-64", + "timestamp": 1606148662523, + "version": "5.0.2" + }, + "inflect-5.0.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b39e7b08de60f26f2f96b76586d4927", + "name": "inflect", + "sha256": "da363cdb3505d9c49128ad622fb1b88b0400d3bffbb0bf7d91d0be08e3cc3a96", + "size": 58295, + "subdir": "linux-64", + "timestamp": 1606148655177, + "version": "5.0.2" + }, + "inflect-5.0.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2220aecc23b4c123148b4ad03bbc2593", + "name": "inflect", + "sha256": "1f5b5c19e27cae644213f0756869ec0e650e3e70fe7283ced27b8f8e4017b00e", + "size": 58590, + "subdir": "linux-64", + "timestamp": 1606148648606, + "version": "5.0.2" + }, + "inflect-5.0.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d76334a0db6d36b1f42e3ca701060f9", + "name": "inflect", + "sha256": "d1b7fc3b214ae53df76aab3c07b9108f76cf7c54dc5e6774652c0f39602ac602", + "size": 57666, + "subdir": "linux-64", + "timestamp": 1606148629502, + "version": "5.0.2" + }, + "inflect-5.2.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "importlib-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "188377a87c8779940e46e2d0ba5a6e2c", + "name": "inflect", + "sha256": "ab2706dae36c45453410ee12c503ac3b34a60cef7804e9afd8dd4ecd3689492f", + "size": 61934, + "subdir": "linux-64", + "timestamp": 1614363006456, + "version": "5.2.0" + }, + "inflect-5.2.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "998fdc06549dfe7c8618adfc9ffdb962", + "name": "inflect", + "sha256": "c4574b1deb4373b33f1b887918a0fc93b828e9406c6d6b7311160dfcae1005e5", + "size": 59934, + "subdir": "linux-64", + "timestamp": 1614363007942, + "version": "5.2.0" + }, + "inflect-5.2.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4c02a0947d65c42cf71db04c46fce3d5", + "name": "inflect", + "sha256": "aaa30ce51cdfdd90cbe76a826d28cef9140ee05d8cc225b5913b579c66a118fb", + "size": 60261, + "subdir": "linux-64", + "timestamp": 1614363053311, + "version": "5.2.0" + }, + "inflect-5.2.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af90b441f09f9b333fe053812d183713", + "name": "inflect", + "sha256": "bcdb4bf5993398569691d615cd065f4ee39847c3f48cf1be96fe80d719548a5d", + "size": 59411, + "subdir": "linux-64", + "timestamp": 1614361950139, + "version": "5.2.0" + }, + "inflect-5.3.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "82f53a476166f7327fa912d56c45445f", + "name": "inflect", + "sha256": "8c34f06787380b0b47a60c9cb21f84842df33a4c2cb9b5bee33825e594470832", + "size": 60722, + "subdir": "linux-64", + "timestamp": 1640809420882, + "version": "5.3.0" + }, + "inflect-5.3.0-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "72e839e1708a5981dac9ec5b22603017", + "name": "inflect", + "sha256": "ab8122ab1de17ae7193957746446fb488524f7e024645a41d7f3ee119d2344a4", + "size": 76832, + "subdir": "linux-64", + "timestamp": 1676852857740, + "version": "5.3.0" + }, + "inflect-5.3.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "importlib-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6aedeb480f08818ee050746b27b69616", + "name": "inflect", + "sha256": "b38eb8ff4953c1dc25d9e6f95c77f00bfdd86793456c49e571fe189b5601d7e0", + "size": 62436, + "subdir": "linux-64", + "timestamp": 1614797335387, + "version": "5.3.0" + }, + "inflect-5.3.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "91c67b2f9a6a748f480450fb9d7e00ef", + "name": "inflect", + "sha256": "903078eddf6f9ab947127d7b7af2bc8c522d78e13ba13df5d7c2050530db79a4", + "size": 60515, + "subdir": "linux-64", + "timestamp": 1614796047577, + "version": "5.3.0" + }, + "inflect-5.3.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21efee4e6798ba08d6ca48fba6e7f2c7", + "name": "inflect", + "sha256": "6310d07ea626646303f9aeb4aa6ddf9b65a6f90e451613f089611fbc1b9b8b9f", + "size": 60864, + "subdir": "linux-64", + "timestamp": 1614797338017, + "version": "5.3.0" + }, + "inflect-5.3.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0ddd5b79f339039aabcc563195b2570", + "name": "inflect", + "sha256": "d24de9fe1299ab3a553fe73d728e47ae23f0617923d3e93add4fddc40d632a47", + "size": 59988, + "subdir": "linux-64", + "timestamp": 1614797335438, + "version": "5.3.0" + }, + "inflection-0.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "50d87cd62a1bdb23c676516713417d06", + "name": "inflection", + "sha256": "cd05c6f04850e171813d441ddf5f0d260fb829a7d2bd3d28c606a6ae1fd39ea3", + "size": 11226, + "subdir": "linux-64", + "timestamp": 1530923300192, + "version": "0.3.1" + }, + "inflection-0.3.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "abc24154487ff83b6fc53de9794c6d85", + "name": "inflection", + "sha256": "0a86f4ba770e4d3ced08d92a4a33602b586014b845306b39b4ef986614a46145", + "size": 11297, + "subdir": "linux-64", + "timestamp": 1536247755827, + "version": "0.3.1" + }, + "inflection-0.3.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "58510703268b4c3800e1e7d7fe73985d", + "name": "inflection", + "sha256": "6bd20d3ebedcaa6f0d42d4c1de77af70f2c3d2900b648e4829f106196e683d92", + "size": 11410, + "subdir": "linux-64", + "timestamp": 1536247747479, + "version": "0.3.1" + }, + "inflection-0.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "086b07dee01bea05259945c712ed38e5", + "name": "inflection", + "sha256": "5568919fb7963ee2a6e4335c792bf1d37d0ed60b8494c4b568fffa31e8136159", + "size": 11325, + "subdir": "linux-64", + "timestamp": 1530923233883, + "version": "0.3.1" + }, + "inflection-0.3.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "306de628441f33d77e9892c5808ef96a", + "name": "inflection", + "sha256": "7d6930ac7a9fc8350561bcdaae24e40006f4ce125f38b6c772187ed2c97aa630", + "size": 11375, + "subdir": "linux-64", + "timestamp": 1536247680850, + "version": "0.3.1" + }, + "inflection-0.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f138c70e690a8df37e21d4356b920e75", + "name": "inflection", + "sha256": "ae444ec49c474b8630dec10029cff3cc0c55ce06e9f270d54473ad37171eb769", + "size": 11047, + "subdir": "linux-64", + "timestamp": 1530923266715, + "version": "0.3.1" + }, + "inflection-0.3.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6611e600d62453e90b9817368dd411d3", + "name": "inflection", + "sha256": "02fba3141c02be73abed660a8c09fc68fd3e70ac71c5eb1eaa0014fb0d96d08f", + "size": 11106, + "subdir": "linux-64", + "timestamp": 1536247755949, + "version": "0.3.1" + }, + "inflection-0.3.1-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "ea1d6d0b531c40471ecaaca3babe869f", + "name": "inflection", + "sha256": "645801e8bf67eb34de1542717b620e18a6df780a8216f5cbf2ba9a047d0deedf", + "size": 11516, + "subdir": "linux-64", + "timestamp": 1572437492238, + "version": "0.3.1" + }, + "inflection-0.5.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "5e194d5b7cec8a14373f9a314ec98641", + "name": "inflection", + "sha256": "91928a59f72ff63b510d860ff681bbdd473b26ab67f66505be37087875e8f367", + "size": 11282, + "subdir": "linux-64", + "timestamp": 1640791083957, + "version": "0.5.1" + }, + "inflection-0.5.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "0c6161c0f8d150d5230b01c83f2de6e2", + "name": "inflection", + "sha256": "626d78ce85e44cc97f7641a2b1dd859e0f271fc2ce3d64706a49b78ae8d50b6d", + "size": 13525, + "subdir": "linux-64", + "timestamp": 1676827910382, + "version": "0.5.1" + }, + "inflection-0.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9cc08604f526e99c7b5dcfd21c671fcb", + "name": "inflection", + "sha256": "29b7760e2fd1ee622a6f5ed9b8d23dc118d33ca919b33850b19d886199538036", + "size": 12595, + "subdir": "linux-64", + "timestamp": 1598401857257, + "version": "0.5.1" + }, + "inflection-0.5.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "dffbeea624f5305455c3c2a066898793", + "name": "inflection", + "sha256": "2fdd06548668aa3ab24745de18a95ef0d788c67bb09c6943d5c0861dc297b1a5", + "size": 12734, + "subdir": "linux-64", + "timestamp": 1611675362382, + "version": "0.5.1" + }, + "inflection-0.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "21927d9148d49a1b6e01fcda02cc697d", + "name": "inflection", + "sha256": "72f6ba3addba3aac3e1ef49fe22604757b61962ec0a969f9001c1a811d91332e", + "size": 12285, + "subdir": "linux-64", + "timestamp": 1598401854111, + "version": "0.5.1" + }, + "inflection-0.5.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6c41fe1b4f90f1451562fe2fdfb6df79", + "name": "inflection", + "sha256": "10199c74cf5c8754cd705c5edeae654cd971d566cf6d047a082e5c06376384d3", + "size": 12407, + "subdir": "linux-64", + "timestamp": 1611675309732, + "version": "0.5.1" + }, + "inflection-0.5.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "68b18492dbc921913f22f85d977cd559", + "name": "inflection", + "sha256": "f5d22da6ea8e1adf7b979fad68367b2034fd303150301883e98fe463d009af91", + "size": 12389, + "subdir": "linux-64", + "timestamp": 1598401883183, + "version": "0.5.1" + }, + "inflection-0.5.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "4bcb78f9c65669129856401bef116c7c", + "name": "inflection", + "sha256": "6dbf7ae6827c121fea0f2cdb1018faeffcc70cc657f6d5b8bae64e675d5d1425", + "size": 12509, + "subdir": "linux-64", + "timestamp": 1611675361301, + "version": "0.5.1" + }, + "inflection-0.5.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "2079a5c625080cdaa4511da4e9dbee53", + "name": "inflection", + "sha256": "8f216489943e9f3e339a8dcae8627756abb10832ec65abe819ef671223427400", + "size": 12379, + "subdir": "linux-64", + "timestamp": 1611675359323, + "version": "0.5.1" + }, + "intake-0.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs", + "dask >=0.17.0", + "holoviews", + "jinja2", + "msgpack-numpy", + "msgpack-python", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "python-snappy", + "requests", + "ruamel_yaml >=0.15.0", + "tornado >=4.5.1" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c7950ea970e7554423da13f735423c6c", + "name": "intake", + "sha256": "a7515590a158d02ae8014a97ac2ecc21e697943bd0348d8da7b560b3c0db8aae", + "size": 2688425, + "subdir": "linux-64", + "timestamp": 1547677151278, + "version": "0.3.0" + }, + "intake-0.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs", + "dask >=0.17.0", + "holoviews", + "jinja2", + "msgpack-numpy", + "msgpack-python", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "python-snappy", + "requests", + "ruamel_yaml >=0.15.0", + "tornado >=4.5.1" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "89b34769f203fe3ecef84b4bade59f0f", + "name": "intake", + "sha256": "0ce286c23878720e012f9d112b92ff8d0f526ee385bde336ca4451c420a045f3", + "size": 2719520, + "subdir": "linux-64", + "timestamp": 1548432632688, + "version": "0.4.1" + }, + "intake-0.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs", + "dask >=0.17.0", + "holoviews", + "jinja2", + "msgpack-numpy", + "msgpack-python", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "python-snappy", + "requests", + "ruamel_yaml >=0.15.0", + "tornado >=4.5.1" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9c68d40e8e262614ad7afb0e4d5d6c35", + "name": "intake", + "sha256": "8a95e3680078fe82066223a55eda2b665ac60e0b6a74c69ef0fa07b9eec5a8f5", + "size": 2705534, + "subdir": "linux-64", + "timestamp": 1548432622531, + "version": "0.4.1" + }, + "intake-0.6.6-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "hvplot", + "bokeh", + "panel >=0.7.0" + ], + "depends": [ + "appdirs", + "dask-core", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.10,<3.11.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "605fbbb1ebca8b568cd1affcc3d660e2", + "name": "intake", + "sha256": "34ecc3f14e3bca47b13678b048540a4057a6bcbb475518309fc6f9ca10ba137a", + "size": 190673, + "subdir": "linux-64", + "timestamp": 1668767499603, + "version": "0.6.6" + }, + "intake-0.6.6-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "panel >=0.7.0", + "bokeh", + "hvplot" + ], + "depends": [ + "appdirs", + "dask-core", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.11,<3.12.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "103d5e0a6a7ccb3e30167fa1cea0ee6f", + "name": "intake", + "sha256": "c89f0b193d9598ba5da70a893220b76865d4af463658fb5a75f643e619e5498b", + "size": 260044, + "subdir": "linux-64", + "timestamp": 1676844327922, + "version": "0.6.6" + }, + "intake-0.6.6-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "hvplot", + "bokeh", + "panel >=0.7.0" + ], + "depends": [ + "appdirs", + "dask-core", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.7,<3.8.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "810571ba3e3ef512f3bbcde977e06a9f", + "name": "intake", + "sha256": "1ac902a2ffd36e7150695e67344d471b3719aee45aab5d435c0cc70d6b1371de", + "size": 187603, + "subdir": "linux-64", + "timestamp": 1668767463678, + "version": "0.6.6" + }, + "intake-0.6.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "hvplot", + "bokeh", + "panel >=0.7.0" + ], + "depends": [ + "appdirs", + "dask-core", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.8,<3.9.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8696d47e1a84e2230d114d8eed706607", + "name": "intake", + "sha256": "e72368f5fd08d99619d766f2f767ffdab171492c1cfe7ad50855fd470b568737", + "size": 188715, + "subdir": "linux-64", + "timestamp": 1668767566829, + "version": "0.6.6" + }, + "intake-0.6.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "hvplot", + "bokeh", + "panel >=0.7.0" + ], + "depends": [ + "appdirs", + "dask-core", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.9,<3.10.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "219ad7d5f88d6e132f4269d7943047b3", + "name": "intake", + "sha256": "7ef32d072b9fab767d2d142ba58054687d30a05190e19d9c6231575c9d495b5f", + "size": 188993, + "subdir": "linux-64", + "timestamp": 1668767532901, + "version": "0.6.6" + }, + "intake-0.6.7-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "hvplot", + "panel >=0.7.0", + "bokeh" + ], + "depends": [ + "appdirs", + "dask >=1.0", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.10,<3.11.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5293653b1d5f019cb366a25500ef6759", + "name": "intake", + "sha256": "e26be2d62a30397c99b46d26ac76d1c750dcec51ff099f2828f16633adba67b5", + "size": 193321, + "subdir": "linux-64", + "timestamp": 1676619951562, + "version": "0.6.7" + }, + "intake-0.6.7-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "hvplot", + "panel >=0.7.0", + "bokeh" + ], + "depends": [ + "appdirs", + "dask >=1.0", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.8,<3.9.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "fbecbc906b98f954bed2bada4ec734d9", + "name": "intake", + "sha256": "36d11ae752f6cba7f298acd568ab016dfaac253eb80e758a11f895db26fc61dd", + "size": 191274, + "subdir": "linux-64", + "timestamp": 1676619898218, + "version": "0.6.7" + }, + "intake-0.6.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "hvplot", + "panel >=0.7.0", + "bokeh" + ], + "depends": [ + "appdirs", + "dask >=1.0", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.9,<3.10.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ae37f3dfd5ba60c63fd6d010dadc88ec", + "name": "intake", + "sha256": "a020ca43592a3381b9919a6452c390eb58f641ad8d60180ab1f1229a5c52f0ae", + "size": 191554, + "subdir": "linux-64", + "timestamp": 1676619999457, + "version": "0.6.7" + }, + "intake-0.6.8-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "panel >=0.7.0", + "hvplot", + "bokeh" + ], + "depends": [ + "appdirs", + "dask >=1.0", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.10,<3.11.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "cf5080a8a0a02846abae45ebb5a016d9", + "name": "intake", + "sha256": "9b80f60f09afb785585578d7c17884dd92a45deab5cf4b7b2ae6bbab294b0058", + "size": 192406, + "subdir": "linux-64", + "timestamp": 1678787739687, + "version": "0.6.8" + }, + "intake-0.6.8-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "hvplot", + "panel >=0.7.0", + "bokeh" + ], + "depends": [ + "appdirs", + "dask >=1.0", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.11,<3.12.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "583d6a6e3fea6886d727969f17e1ac1a", + "name": "intake", + "sha256": "3b4a497edbe358a7c5f61a615d65a8870c16dd88583d287282452fc91b7c62c4", + "size": 265191, + "subdir": "linux-64", + "timestamp": 1679336493260, + "version": "0.6.8" + }, + "intake-0.6.8-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "panel >=0.7.0", + "hvplot", + "bokeh" + ], + "depends": [ + "appdirs", + "dask >=1.0", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.8,<3.9.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8f810d7f901ed1c2d2135830ef944f01", + "name": "intake", + "sha256": "2935149f9ddffca37129022af2257b1e1f1ed6778432e22bb2fee13b4957d2cd", + "size": 190444, + "subdir": "linux-64", + "timestamp": 1678787690195, + "version": "0.6.8" + }, + "intake-0.6.8-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "panel >=0.7.0", + "hvplot", + "bokeh" + ], + "depends": [ + "appdirs", + "dask >=1.0", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.9,<3.10.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "95a53ccdc295f1ea8c47e466dac4b136", + "name": "intake", + "sha256": "5997c1d84530fbbac328078b6aa02ffacb781aba6d2cd1c04624d4fc9f57db4e", + "size": 190565, + "subdir": "linux-64", + "timestamp": 1678787636365, + "version": "0.6.8" + }, + "intake-xarray-0.6.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dask-core >=2.2", + "fsspec >=2022", + "intake >=0.6.6", + "msgpack-python", + "netcdf4", + "python >=3.10,<3.11.0a0", + "requests", + "xarray >=2022", + "zarr" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "aac85eed7cddeba929bf9b67a3018baf", + "name": "intake-xarray", + "sha256": "cfac71a9a68f9925190435198497f655b666761fb74c493f356c2a5e44b478b9", + "size": 1516605, + "subdir": "linux-64", + "timestamp": 1669628930104, + "version": "0.6.1" + }, + "intake-xarray-0.6.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "dask-core >=2.2", + "fsspec >=2022", + "intake >=0.6.6", + "msgpack-python", + "netcdf4", + "python >=3.11,<3.12.0a0", + "requests", + "xarray >=2022", + "zarr" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "95fe85bd99b5b36a4b715dbc4018f84a", + "name": "intake-xarray", + "sha256": "372512725d56b9316eeb9c690e5606cacd2786c48829ff934798deeed2e9aac9", + "size": 1601382, + "subdir": "linux-64", + "timestamp": 1676852874065, + "version": "0.6.1" + }, + "intake-xarray-0.6.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dask-core >=2.2", + "fsspec >=2022", + "intake >=0.6.6", + "msgpack-python", + "netcdf4", + "python >=3.8,<3.9.0a0", + "requests", + "xarray >=2022", + "zarr" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "87f104aaca54e5afdced2fcbb408c7b2", + "name": "intake-xarray", + "sha256": "7b137d12764ed6d99bc865ddfd8b834b4c12daef70f1c418b4b968c3cf71b10d", + "size": 1517172, + "subdir": "linux-64", + "timestamp": 1669629023511, + "version": "0.6.1" + }, + "intake-xarray-0.6.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dask-core >=2.2", + "fsspec >=2022", + "intake >=0.6.6", + "msgpack-python", + "netcdf4", + "python >=3.9,<3.10.0a0", + "requests", + "xarray >=2022", + "zarr" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5158ac1da8c7c6e727ca4e8bc8c9f278", + "name": "intake-xarray", + "sha256": "6f4eca8d01c810ebf21ca8012a6c4c2b65b5931ff86f7b8f966c1c35dc7106e4", + "size": 1516184, + "subdir": "linux-64", + "timestamp": 1669628977358, + "version": "0.6.1" + }, + "intel-cmplr-lib-rt-2021.3.0-h06a4308_3350.tar.bz2": { + "build": "h06a4308_3350", + "build_number": 3350, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "bf9ae8e3364157088420e460f237a01e", + "name": "intel-cmplr-lib-rt", + "sha256": "332eeecf88f6713a0052c578f9572e841a214b26e776896be9ead3d7161025cb", + "size": 28505631, + "subdir": "linux-64", + "timestamp": 1626976023087, + "version": "2021.3.0" + }, + "intel-cmplr-lib-rt-2021.4.0-h06a4308_3561.tar.bz2": { + "build": "h06a4308_3561", + "build_number": 3561, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "719413b15284ec6fbe5a64d3fbf572e8", + "name": "intel-cmplr-lib-rt", + "sha256": "aa5da3184ced5666dca43e57562ddc13854ecaba723e9670d66611fffc564db4", + "size": 29872739, + "subdir": "linux-64", + "timestamp": 1641816003446, + "version": "2021.4.0" + }, + "intel-cmplr-lib-rt-2022.0.1-h06a4308_3633.tar.bz2": { + "build": "h06a4308_3633", + "build_number": 3633, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "90d9e3b97a3733cda3e11781798f75b2", + "name": "intel-cmplr-lib-rt", + "sha256": "d8ec54047931d30b1a73306b5c0a571dd410e103c9fb3356facf742579f8bbcd", + "size": 29209999, + "subdir": "linux-64", + "timestamp": 1642778486847, + "version": "2022.0.1" + }, + "intel-cmplr-lib-rt-2022.1.0-h06a4308_3768.tar.bz2": { + "build": "h06a4308_3768", + "build_number": 3768, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "8b0a27d8215d0def6960c0ce0c74fde5", + "name": "intel-cmplr-lib-rt", + "sha256": "a3bb1202e0d83dc593368a826308f3b0cf0ff9fd0510ca091132b94617d2efe2", + "size": 32456897, + "subdir": "linux-64", + "timestamp": 1667585029156, + "version": "2022.1.0" + }, + "intel-cmplr-lib-rt-2023.0.0-h06a4308_25370.tar.bz2": { + "build": "h06a4308_25370", + "build_number": 25370, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "557f51dd27c6924139c510363d948194", + "name": "intel-cmplr-lib-rt", + "sha256": "9090451a089964e433906e6f13b3bedd51617424ef8e6fb58a28fb1992cf55d9", + "size": 37920686, + "subdir": "linux-64", + "timestamp": 1679614919821, + "version": "2023.0.0" + }, + "intel-cmplr-lic-rt-2021.3.0-h06a4308_3350.tar.bz2": { + "build": "h06a4308_3350", + "build_number": 3350, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "5f92f940b958e63d98b21534165015ed", + "name": "intel-cmplr-lic-rt", + "sha256": "dc78854f3673fab37cadbdbbc6f72fe31e4c666e4bed54c21f1fbefe79c46089", + "size": 29493, + "subdir": "linux-64", + "timestamp": 1626976049328, + "version": "2021.3.0" + }, + "intel-cmplr-lic-rt-2021.4.0-h06a4308_3561.tar.bz2": { + "build": "h06a4308_3561", + "build_number": 3561, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "6fe1b0c2dee4971a512b36a09f30069c", + "name": "intel-cmplr-lic-rt", + "sha256": "d1b9a135a0faa707972f41db1705778641c20301fea10578a9ba37c3fe26dfab", + "size": 30035, + "subdir": "linux-64", + "timestamp": 1641816030306, + "version": "2021.4.0" + }, + "intel-cmplr-lic-rt-2022.0.1-h06a4308_3633.tar.bz2": { + "build": "h06a4308_3633", + "build_number": 3633, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "ca942647a2246f842ebedd33df6bc409", + "name": "intel-cmplr-lic-rt", + "sha256": "2bcb5e14b06dcbcb1b6a4f04b49a02735ed3d5a09b141c3c1657d59051ec7b9b", + "size": 27299, + "subdir": "linux-64", + "timestamp": 1642778514661, + "version": "2022.0.1" + }, + "intel-cmplr-lic-rt-2022.1.0-h06a4308_3768.tar.bz2": { + "build": "h06a4308_3768", + "build_number": 3768, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "2807d748d5600daf5a9b959d93dc92da", + "name": "intel-cmplr-lic-rt", + "sha256": "b37bb60beb9055920920e86ca3e6031a05ad84f91270580c29c8d850dc8b9c55", + "size": 30734, + "subdir": "linux-64", + "timestamp": 1667585053432, + "version": "2022.1.0" + }, + "intel-cmplr-lic-rt-2023.0.0-h06a4308_25370.tar.bz2": { + "build": "h06a4308_25370", + "build_number": 25370, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "3769b849ca3900a654255e18432a30fc", + "name": "intel-cmplr-lic-rt", + "sha256": "8ad8a80a3e2f204f7d12b824784a216663edd1239c7844166f639f1fea3bc0aa", + "size": 31201, + "subdir": "linux-64", + "timestamp": 1679614947442, + "version": "2023.0.0" + }, + "intel-fortran-rt-2021.3.0-h06a4308_3350.tar.bz2": { + "build": "h06a4308_3350", + "build_number": 3350, + "depends": [ + "intel-cmplr-lib-rt 2021.3.0 h06a4308_3350", + "intel-cmplr-lic-rt 2021.3.0 h06a4308_3350", + "intel-openmp 2021.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "d6101f629f155d7b1bf0131c3060e6fc", + "name": "intel-fortran-rt", + "sha256": "87293a4595f653ab793db84afa145e3f67b7eae74711505b88109a92de1d8887", + "size": 1180055, + "subdir": "linux-64", + "timestamp": 1626976072168, + "version": "2021.3.0" + }, + "intel-fortran-rt-2021.4.0-h06a4308_3561.tar.bz2": { + "build": "h06a4308_3561", + "build_number": 3561, + "depends": [ + "intel-cmplr-lib-rt 2021.4.0 h06a4308_3561", + "intel-cmplr-lic-rt 2021.4.0 h06a4308_3561", + "intel-openmp 2021.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "b2fec017057307175fba15d6a370d449", + "name": "intel-fortran-rt", + "sha256": "3983b8419cd76e93af06849e5411e9abbb9cab10f4747f9fd419713194a93117", + "size": 1150089, + "subdir": "linux-64", + "timestamp": 1641816045790, + "version": "2021.4.0" + }, + "intel-fortran-rt-2022.0.1-h06a4308_3633.tar.bz2": { + "build": "h06a4308_3633", + "build_number": 3633, + "depends": [ + "intel-cmplr-lib-rt 2022.0.1 h06a4308_3633", + "intel-cmplr-lic-rt 2022.0.1 h06a4308_3633", + "intel-openmp 2022.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "db9995b5a7a0cd1b78163f0b3848c433", + "name": "intel-fortran-rt", + "sha256": "b5ce2386548ac8b6289c2d4cd72735eb7fee2a0105c343deabb351124c039f0c", + "size": 1149982, + "subdir": "linux-64", + "timestamp": 1642778527588, + "version": "2022.0.1" + }, + "intel-fortran-rt-2022.1.0-h06a4308_3768.tar.bz2": { + "build": "h06a4308_3768", + "build_number": 3768, + "depends": [ + "intel-cmplr-lib-rt 2022.1.0 h06a4308_3768", + "intel-cmplr-lic-rt 2022.1.0 h06a4308_3768", + "intel-openmp 2022.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "97c3f1582d69aec814630effec52aa86", + "name": "intel-fortran-rt", + "sha256": "f72d77b83d76c34a9a24dd4b71be923512cd85ca92ba33d0717ddaf7040afea8", + "size": 1174431, + "subdir": "linux-64", + "timestamp": 1667585064645, + "version": "2022.1.0" + }, + "intel-fortran-rt-2023.0.0-h06a4308_25370.tar.bz2": { + "build": "h06a4308_25370", + "build_number": 25370, + "depends": [ + "intel-cmplr-lib-rt 2023.0.0 h06a4308_25370", + "intel-cmplr-lic-rt 2023.0.0 h06a4308_25370", + "intel-openmp 2023.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "85f5fec8f620130bd8193918ead26972", + "name": "intel-fortran-rt", + "sha256": "18dcef362d799510f97d84d48ade0182e0049c8bdf46f896be4fbdbb78c0b92e", + "size": 1077372, + "subdir": "linux-64", + "timestamp": 1679614960176, + "version": "2023.0.0" + }, + "intel-opencl-rt-2021.3.0-h06a4308_3350.tar.bz2": { + "build": "h06a4308_3350", + "build_number": 3350, + "depends": [ + "intel-cmplr-lic-rt 2021.3.0 h06a4308_3350", + "intel-openmp 2021.*", + "tbb 2021.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "01346cf7690617004eacb76ecd64ba8c", + "name": "intel-opencl-rt", + "sha256": "b33848881d548d2f5692f2d8193faa612baedd1aa7769c6d6f45de454989ad59", + "size": 88474067, + "subdir": "linux-64", + "timestamp": 1626976158872, + "version": "2021.3.0" + }, + "intel-opencl-rt-2021.4.0-h06a4308_3561.tar.bz2": { + "build": "h06a4308_3561", + "build_number": 3561, + "depends": [ + "intel-cmplr-lic-rt 2021.4.0 h06a4308_3561", + "intel-openmp 2021.*", + "tbb 2021.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "fa7d7d83ac987bf1d201777e1c31ca1c", + "name": "intel-opencl-rt", + "sha256": "58fe0537be6248f612284d9fb94faec37eff5a60dbccb0a3290c011a34ebffbe", + "size": 80142102, + "subdir": "linux-64", + "timestamp": 1641816073673, + "version": "2021.4.0" + }, + "intel-opencl-rt-2022.0.1-h06a4308_3633.tar.bz2": { + "build": "h06a4308_3633", + "build_number": 3633, + "depends": [ + "intel-cmplr-lic-rt 2022.0.1 h06a4308_3633", + "intel-openmp 2022.*", + "tbb 2021.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "c636c25403b042a6d645dc770cb3793f", + "name": "intel-opencl-rt", + "sha256": "113bd9613702795498867f954de3ad70aebbd73e2c5c2f2c423c110a42b6ba6c", + "size": 125582625, + "subdir": "linux-64", + "timestamp": 1642778672185, + "version": "2022.0.1" + }, + "intel-opencl-rt-2022.1.0-h06a4308_3768.tar.bz2": { + "build": "h06a4308_3768", + "build_number": 3768, + "depends": [ + "intel-cmplr-lic-rt 2022.1.0 h06a4308_3768", + "intel-openmp 2022.*", + "tbb 2021.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "0558b1ca1d80b9b7bbef518d88cd1322", + "name": "intel-opencl-rt", + "sha256": "15def0595519b67dfd8a6157904553f0e4589c227e2db60e091d341321ec9ca6", + "size": 127763514, + "subdir": "linux-64", + "timestamp": 1667585079825, + "version": "2022.1.0" + }, + "intel-opencl-rt-2023.0.0-h06a4308_25370.tar.bz2": { + "build": "h06a4308_25370", + "build_number": 25370, + "depends": [ + "intel-cmplr-lic-rt 2023.0.0 h06a4308_25370", + "intel-openmp 2023.*", + "tbb 2021.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "c211f92ce9e34b683e9ed22a23629dd0", + "name": "intel-opencl-rt", + "sha256": "133f00b0bfa2fc14e3fce3a934d709535b3505ef407356645cbb5bc354b43d02", + "size": 169571490, + "subdir": "linux-64", + "timestamp": 1679614975597, + "version": "2023.0.0" + }, + "intel-openmp-2017.0.4-hf7c01fb_0.tar.bz2": { + "build": "hf7c01fb_0", + "build_number": 0, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "36153a32c88164052367121e009e6f8c", + "name": "intel-openmp", + "sha256": "d0b685a556a4578a76b76eac88d33205cf470cd47a1923b25e5d8bf0673bf029", + "size": 633536, + "subdir": "linux-64", + "timestamp": 1508962801421, + "version": "2017.0.4" + }, + "intel-openmp-2018.0.0-8.tar.bz2": { + "build": "8", + "build_number": 8, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "d6c7f47504ffa7547db227c1ec2c3be9", + "name": "intel-openmp", + "sha256": "e0bf293064652dd8a798e71b93c5e72d9d9c7ce638598577c9f03e8d25562a3a", + "size": 634758, + "subdir": "linux-64", + "timestamp": 1521735596719, + "version": "2018.0.0" + }, + "intel-openmp-2018.0.0-h15fc484_7.tar.bz2": { + "build": "h15fc484_7", + "build_number": 7, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "43a02edcf628c9ab783f40428cd37eba", + "name": "intel-openmp", + "sha256": "e6153508be82b599b52f99fee2f842b48df31d24f9a8932650a62be5bd75a268", + "size": 631626, + "subdir": "linux-64", + "timestamp": 1505745611021, + "version": "2018.0.0" + }, + "intel-openmp-2018.0.0-hc7b2577_8.tar.bz2": { + "build": "hc7b2577_8", + "build_number": 8, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "658ff659cd4178ae7b41a613188b025b", + "name": "intel-openmp", + "sha256": "571922e716e61ffa024139bdfe24c0136817b6d0353b779cca89e6ce13520a67", + "size": 632408, + "subdir": "linux-64", + "timestamp": 1511376416187, + "version": "2018.0.0" + }, + "intel-openmp-2018.0.3-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "364bdca356b384243cb72c7daca416be", + "name": "intel-openmp", + "sha256": "4408676351b8cdf5a54cea3b7211773a62e1ecfd3ee9825d99d78b5dffbab197", + "size": 721827, + "subdir": "linux-64", + "timestamp": 1528122050163, + "version": "2018.0.3" + }, + "intel-openmp-2019.0-117.tar.bz2": { + "build": "117", + "build_number": 117, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "36f42016b6a01a423acecbb79641f88b", + "name": "intel-openmp", + "sha256": "f6fb2de5f12f8b11366e152f16cacbc924fce98e505ddc7805351303365f34a6", + "size": 738738, + "subdir": "linux-64", + "timestamp": 1536594375868, + "version": "2019.0" + }, + "intel-openmp-2019.0-118.tar.bz2": { + "build": "118", + "build_number": 118, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "13bc2b14e1727a744e6ec91358db9b68", + "name": "intel-openmp", + "sha256": "695235411b994b9ff00c7a204e63efe36529eb3adddd59ca61e334b5618f980d", + "size": 738118, + "subdir": "linux-64", + "timestamp": 1537292389205, + "version": "2019.0" + }, + "intel-openmp-2019.1-144.tar.bz2": { + "build": "144", + "build_number": 144, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "c44b06139a08fde7192a9d9aa06a95e1", + "name": "intel-openmp", + "sha256": "00124325a24c56a2da36bd62e5e288ac9083cbcb00a16b2b65a0293f11f7c142", + "size": 906581, + "subdir": "linux-64", + "timestamp": 1542661340496, + "version": "2019.1" + }, + "intel-openmp-2019.3-199.tar.bz2": { + "build": "199", + "build_number": 199, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "a5899677213fa3d86e51e8ce34b12048", + "name": "intel-openmp", + "sha256": "082473e1c51144b64da0254a5ab1a6a76f38cab9684f457727a504c8830bc41c", + "size": 906753, + "subdir": "linux-64", + "timestamp": 1552593606793, + "version": "2019.3" + }, + "intel-openmp-2019.4-243.tar.bz2": { + "build": "243", + "build_number": 243, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "4e69e689d708e6dc17a9ada383e8e25e", + "name": "intel-openmp", + "sha256": "c88d6b359f9ef150b57595fd217d3e90906b6a282b07ac7a0fa39d8fd0182626", + "size": 897146, + "subdir": "linux-64", + "timestamp": 1559526508129, + "version": "2019.4" + }, + "intel-openmp-2020.0-166.tar.bz2": { + "build": "166", + "build_number": 166, + "constrains": [ + "mkl >=2020.0" + ], + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "dcdad8d3be0b7bc528e198450524a368", + "name": "intel-openmp", + "sha256": "4b796e3168117c24fb4d7f378200ae76313350c371a80afd225ce747139546ac", + "size": 938116, + "subdir": "linux-64", + "timestamp": 1580943972633, + "version": "2020.0" + }, + "intel-openmp-2020.1-217.tar.bz2": { + "build": "217", + "build_number": 217, + "constrains": [ + "mkl >=2020.1" + ], + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "3981aed1d883a49ca0d4f1762ea943b7", + "name": "intel-openmp", + "sha256": "9473037f2a84047a0b07280361d9cbad4a95e96a685cfb8e32223f90e7ffc826", + "size": 962726, + "subdir": "linux-64", + "timestamp": 1589162242087, + "version": "2020.1" + }, + "intel-openmp-2020.2-254.tar.bz2": { + "build": "254", + "build_number": 254, + "constrains": [ + "mkl >=2020.2" + ], + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "5117f3c52aaa8d9a7fd957aba5a3ee40", + "name": "intel-openmp", + "sha256": "80c3dba0c6d79ab6fbde9a04175f32953210ece5a212de39dc70565ba1a07b4e", + "size": 969429, + "subdir": "linux-64", + "timestamp": 1598384192885, + "version": "2020.2" + }, + "intel-openmp-2021.2.0-h06a4308_610.tar.bz2": { + "build": "h06a4308_610", + "build_number": 610, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "ff7b205b335400e53ad6af39fafe2be0", + "name": "intel-openmp", + "sha256": "8a2136a1738d68e2c9380d108eb9232cde3047913a8746d145bf7eee878e9f3a", + "size": 2007161, + "subdir": "linux-64", + "timestamp": 1618534005074, + "version": "2021.2.0" + }, + "intel-openmp-2021.3.0-h06a4308_3350.tar.bz2": { + "build": "h06a4308_3350", + "build_number": 3350, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "75225ab3ec3898e0a2661d5f4a71c1a7", + "name": "intel-openmp", + "sha256": "861a5c1f38851c7d4156567aa96f9b61044c6222dca5ac017293e74083e066bb", + "size": 2077831, + "subdir": "linux-64", + "timestamp": 1626182296095, + "version": "2021.3.0" + }, + "intel-openmp-2021.4.0-h06a4308_3561.tar.bz2": { + "build": "h06a4308_3561", + "build_number": 3561, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "4aa8bcf74c81cd3600978f791191692a", + "name": "intel-openmp", + "sha256": "1b424413f28b840fc6d4bf467f37e9e405823b1e3b899005df80152d48936d64", + "size": 9246735, + "subdir": "linux-64", + "timestamp": 1634546760713, + "version": "2021.4.0" + }, + "intel-openmp-2022.0.1-h06a4308_3633.tar.bz2": { + "build": "h06a4308_3633", + "build_number": 3633, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "0c731aee1f1ba6aafce25946035e1cac", + "name": "intel-openmp", + "sha256": "45a705a98dabb84e414d02bc712900e57f3b725c4de0b39eadd39115afec641d", + "size": 8867665, + "subdir": "linux-64", + "timestamp": 1642705440370, + "version": "2022.0.1" + }, + "intel-openmp-2022.1.0-h9e868ea_3768.tar.bz2": { + "build": "h9e868ea_3768", + "build_number": 3768, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "36aa37964b3eca3bea804d21616f2b45", + "name": "intel-openmp", + "sha256": "fa7ad4b8a0e255c027e3e8c83f854035e8e2b163ab8451a2da06a5a970774b1d", + "size": 9973542, + "subdir": "linux-64", + "timestamp": 1662087962858, + "version": "2022.1.0" + }, + "intel-openmp-2022.1.0-h9e868ea_3769.tar.bz2": { + "build": "h9e868ea_3769", + "build_number": 3769, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "708196c1ce8f6906c33104ba2fa3d034", + "name": "intel-openmp", + "sha256": "9f098711fffe4839c62e19023641f0263f2d6898cd09df166573c35d0cb5bb49", + "size": 9996869, + "subdir": "linux-64", + "timestamp": 1662497664244, + "version": "2022.1.0" + }, + "intel-openmp-2023.0.0-h9e868ea_25371.tar.bz2": { + "build": "h9e868ea_25371", + "build_number": 25371, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [ + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "a697c16260c306a45acbac1b8203852d", + "name": "intel-openmp", + "sha256": "a6968cbf1c95f173958ac9bd4eab0a1d80a04284a739c72f0376735a1ac3b1cb", + "size": 16561990, + "subdir": "linux-64", + "timestamp": 1677516507053, + "version": "2023.0.0" + }, + "intervals-0.8.0-py27h5a35102_0.tar.bz2": { + "build": "py27h5a35102_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b8dcfcdf903672e5f876bf304327d425", + "name": "intervals", + "sha256": "2c39b990d59f4b8c0261ba9fd7f03561300d4d21375a0c072d142b2fe923927a", + "size": 17046, + "subdir": "linux-64", + "timestamp": 1507384538825, + "version": "0.8.0" + }, + "intervals-0.8.0-py35h051fd7f_0.tar.bz2": { + "build": "py35h051fd7f_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2e1cebea1341573020430193a54867fb", + "name": "intervals", + "sha256": "6be8864998e107e7bcdf27f0b18ffe8c8d1318e1d72198eb397413ee306ac725", + "size": 17671, + "subdir": "linux-64", + "timestamp": 1507384540438, + "version": "0.8.0" + }, + "intervals-0.8.0-py36h1633872_0.tar.bz2": { + "build": "py36h1633872_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7dba2e8a231db7e01f0d223d4febc50e", + "name": "intervals", + "sha256": "d116948e330896ec085b24a7fc5afb99c4d6e9c7692fb58986e3d9a8cb1c098b", + "size": 17573, + "subdir": "linux-64", + "timestamp": 1507384550902, + "version": "0.8.0" + }, + "intervals-0.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5b2eee15ab2923c3621da62e5ae57384", + "name": "intervals", + "sha256": "2e81d8746bef24c898ef340ed7fc56f2a269b2d1ab367ced5b4e4d374172b17b", + "size": 16955, + "subdir": "linux-64", + "timestamp": 1520909886155, + "version": "0.8.1" + }, + "intervals-0.8.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ffbe7a0aa22d36c11107251054882be8", + "name": "intervals", + "sha256": "599eb26ffb1cb83d5aa48d73c8cc3c28a7b080710e4b83fb5dac3e5ebccea03b", + "size": 17537, + "subdir": "linux-64", + "timestamp": 1520909920744, + "version": "0.8.1" + }, + "intervals-0.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b815ba7c374d87c3e583258ce53c9215", + "name": "intervals", + "sha256": "ec48de884c6daf6a4b6818919495e4bef1299b0312671177054e98de3f625458", + "size": 17459, + "subdir": "linux-64", + "timestamp": 1520909852635, + "version": "0.8.1" + }, + "intervals-0.8.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cc25499a76773e13089c056e08199ede", + "name": "intervals", + "sha256": "cbb1ecddc7133ea19b6b14dca5fa14168c8ae4e03e80835d2a59fed4102df9f3", + "size": 17384, + "subdir": "linux-64", + "timestamp": 1530897762998, + "version": "0.8.1" + }, + "intervals-0.8.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ff3cc75cf7efed72c8ca57f1af80b5ea", + "name": "intervals", + "sha256": "156f938e19312f6d05025a693b01cabf8b95d9efa09a9ae9cdd31d3d457645ff", + "size": 18085, + "subdir": "linux-64", + "timestamp": 1573469673080, + "version": "0.8.1" + }, + "intervals-0.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "020c13a04befdb90e3c9eb0bfe41c054", + "name": "intervals", + "sha256": "703f10bfb3e540a6446604cbc013a8027b846ff7ee3b42889cdf2d9a47f03718", + "size": 18863, + "subdir": "linux-64", + "timestamp": 1598411867381, + "version": "0.9.0" + }, + "intervals-0.9.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "da79e8c88b3bf2b768ed3c2e5e85d9ef", + "name": "intervals", + "sha256": "53a108d41c45c07db1752c999e25cdd03d114ad737d1a3e3acfedcfffc675b68", + "size": 18880, + "subdir": "linux-64", + "timestamp": 1598411864056, + "version": "0.9.0" + }, + "intervals-0.9.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9a420e0e50fd7c65acda65d1e1c2b2e8", + "name": "intervals", + "sha256": "b2f7296154edcfaec99f99e632633ff6959455b6971b7130550274da6e76d2fc", + "size": 19144, + "subdir": "linux-64", + "timestamp": 1598411905393, + "version": "0.9.0" + }, + "intervals-0.9.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "10d4dc4801e815f5f511245bf8150e13", + "name": "intervals", + "sha256": "fa7f86150bc27628e3a7100c27576b00ee0016b3f4b1242b0bda2ac9721d9c9b", + "size": 17774, + "subdir": "linux-64", + "timestamp": 1613237422813, + "version": "0.9.1" + }, + "intervals-0.9.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dac5049d98a4db94b85a46a0af05f976", + "name": "intervals", + "sha256": "fad80793914c75f8e46b228214673e4664b716a65e2427bab52e4566ccdcf9ac", + "size": 17785, + "subdir": "linux-64", + "timestamp": 1613237920777, + "version": "0.9.1" + }, + "intervals-0.9.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2d75a7948abf4566aa7c561616685849", + "name": "intervals", + "sha256": "c29191326b6cd69fa58a1c207abef35efa19bf548a73cf0c32c4e7b83743c8da", + "size": 18034, + "subdir": "linux-64", + "timestamp": 1613237931606, + "version": "0.9.1" + }, + "intervals-0.9.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7dbec491c9db03ad6b403b2bd74165bf", + "name": "intervals", + "sha256": "03fc83f713518081577f13e248b2b7de9e9955d327ee1a53ce8fc2c32c93ea9c", + "size": 18041, + "subdir": "linux-64", + "timestamp": 1613237928516, + "version": "0.9.1" + }, + "intervals-0.9.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "256608e842f0e06ce793f8f4b379c58a", + "name": "intervals", + "sha256": "f3829dd6b7b2d2881b74532ea1b30096e03770a185b9c5fd2a5e1aa08004433e", + "size": 18390, + "subdir": "linux-64", + "timestamp": 1640809439215, + "version": "0.9.2" + }, + "intervals-0.9.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eed5b58367d0b6d876c12863ba93002d", + "name": "intervals", + "sha256": "bb7448355550a289f527eb4a42f66715b718a46f8a9e70a81727845ef2a915b6", + "size": 23489, + "subdir": "linux-64", + "timestamp": 1676827214107, + "version": "0.9.2" + }, + "intervals-0.9.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7714f598cba195e71f7eea1ab7d43747", + "name": "intervals", + "sha256": "a933f8a5706357edbfebefda45c6cb64394cc36fa8773a03cc8d663e71999d31", + "size": 17692, + "subdir": "linux-64", + "timestamp": 1625723310469, + "version": "0.9.2" + }, + "intervals-0.9.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "81c0ff07c661d2a4f65e973d4d1bb271", + "name": "intervals", + "sha256": "f64bff9e11d1c78f795b52db29236611e4f0aa0e0ce44329d95a1e491f49697a", + "size": 17692, + "subdir": "linux-64", + "timestamp": 1625730103837, + "version": "0.9.2" + }, + "intervals-0.9.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b800daef5c50fd7e6922870d707d59f4", + "name": "intervals", + "sha256": "6f9a7f43d083c7b6d41f14f4cc426dd376e3eb049744c7c6dfde0f60f673b33c", + "size": 17911, + "subdir": "linux-64", + "timestamp": 1625729522371, + "version": "0.9.2" + }, + "intervals-0.9.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "79aa13276f9711f08928e57251304fa5", + "name": "intervals", + "sha256": "c237cc2cad83907dae1e18ecdabba5448ef73f232561c5e68450bb65ad981c8c", + "size": 18081, + "subdir": "linux-64", + "timestamp": 1625753542839, + "version": "0.9.2" + }, + "invoke-1.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e5bd4ead79075b7ee79e9a6da623eb8a", + "name": "invoke", + "sha256": "399e4a64387d280ac2999b5c6265d668738fa8d101819b9efee05eda5fbe5382", + "size": 227180, + "subdir": "linux-64", + "timestamp": 1527696140397, + "version": "1.0.0" + }, + "invoke-1.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "599d0462fc97244b97f9ae738c8c7ebd", + "name": "invoke", + "sha256": "2928ab26674eeec2851d906b8700e67270daaccaf40fcb9305d8a7cbe924b8db", + "size": 225715, + "subdir": "linux-64", + "timestamp": 1527696176212, + "version": "1.0.0" + }, + "invoke-1.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "1385964a7a5a469ac5d10a44a694ea7f", + "name": "invoke", + "sha256": "5b70a4742ea8d7fd0460fe5902c30bd3919f80a3807ab125cd90c0eda4d5ffc9", + "size": 222013, + "subdir": "linux-64", + "timestamp": 1527696125083, + "version": "1.0.0" + }, + "invoke-1.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "2937b94af6379aaea398ad5b7c6a2f73", + "name": "invoke", + "sha256": "36e029d0e85f41c7fc0dd737ecd6dc8d3409933a0092f140418486ffbef774fa", + "size": 222491, + "subdir": "linux-64", + "timestamp": 1530876201469, + "version": "1.0.0" + }, + "invoke-1.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b7af6c6a0648355d82d140122bb37b28", + "name": "invoke", + "sha256": "216768125ff81a47136bb211f400fac85478169b1ef7a63eada3a7c355d750f4", + "size": 225847, + "subdir": "linux-64", + "timestamp": 1535427184141, + "version": "1.1.1" + }, + "invoke-1.1.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c6eed8eba63644adb7709e81f3e7a163", + "name": "invoke", + "sha256": "f251f6f644c9dc1c521c74f3014db4942c37b54e0504b4766096e857cd79c055", + "size": 224862, + "subdir": "linux-64", + "timestamp": 1535427406502, + "version": "1.1.1" + }, + "invoke-1.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "257322532127256eecff59ca3f7d784d", + "name": "invoke", + "sha256": "27655de211bbe4a7f380046e4c1f1a4a63be9cf63e7e0c0461fe873f4178ee53", + "size": 220690, + "subdir": "linux-64", + "timestamp": 1535427335493, + "version": "1.1.1" + }, + "invoke-1.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "df034fa886cd5680272bb0784f432416", + "name": "invoke", + "sha256": "b062d3270e7707d74719f3d6188a0774c8fcfaf9d8198d8d45bb90d345378ca0", + "size": 220857, + "subdir": "linux-64", + "timestamp": 1535427406767, + "version": "1.1.1" + }, + "invoke-1.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "0fe422ccc82851e473bf276df0a93ce4", + "name": "invoke", + "sha256": "3c94a54c9ea0ad8047b50dd35d68d164b4d0ab1e3f8aae8ab6a9139f83b57e4f", + "size": 263000, + "subdir": "linux-64", + "timestamp": 1538175566060, + "version": "1.2.0" + }, + "invoke-1.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a8db7047d714e6e8c033f507126244ae", + "name": "invoke", + "sha256": "8268410898d06c4c6572e761ef3485f2ee28d733711eb66c634af563649fb596", + "size": 257358, + "subdir": "linux-64", + "timestamp": 1538175575204, + "version": "1.2.0" + }, + "invoke-1.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c9351717ab8a14af22109719b163446c", + "name": "invoke", + "sha256": "7cc51ba5a5132fbac32a50c422cea8e2843041ccb97ee09626b1d8184a945d47", + "size": 258453, + "subdir": "linux-64", + "timestamp": 1538175516365, + "version": "1.2.0" + }, + "invoke-1.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f80c0eda812accf736f1a855ac0ef9dd", + "name": "invoke", + "sha256": "3470fff7945c88b7de24a44698436a758abe07eb6e6c254e1cc284e1034b0394", + "size": 282024, + "subdir": "linux-64", + "timestamp": 1569360906640, + "version": "1.3.0" + }, + "invoke-1.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "061086fed91ee663ccc0157021517a0a", + "name": "invoke", + "sha256": "65a2d4f4fc267563d40c0da4538ff6dc417d7dec0f0f27b8dc4bcda1ae674159", + "size": 277804, + "subdir": "linux-64", + "timestamp": 1569360951866, + "version": "1.3.0" + }, + "invoke-1.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "4649612af95fffe4de417580632ebb9e", + "name": "invoke", + "sha256": "2270790682a3c72de4793b95c64cf1c981e31e9aca6631b4e38b3e75ba7f51a0", + "size": 278288, + "subdir": "linux-64", + "timestamp": 1569360942018, + "version": "1.3.0" + }, + "invoke-1.3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "896a2a4bb335fba9f8fddf598ce14917", + "name": "invoke", + "sha256": "4e865bf0a600a1706b59de5a83877b3967d0c89d80a263090a6a8235378f822d", + "size": 275079, + "subdir": "linux-64", + "timestamp": 1572437524313, + "version": "1.3.0" + }, + "invoke-1.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "4b5d3d39a974ae9c52e17103ff03337b", + "name": "invoke", + "sha256": "0e468ea3ee90e88cb93790cc4ee4a44987793f7494ecf7f38078835ac6b3a9a1", + "size": 271336, + "subdir": "linux-64", + "timestamp": 1600361249611, + "version": "1.4.1" + }, + "invoke-1.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b9b59ea6fd3e2e3697553878e130e64a", + "name": "invoke", + "sha256": "fad16803e84c0efb22c19c9da815cd0bbd5f1da1c6af380c79639a0fc1719c0e", + "size": 278225, + "subdir": "linux-64", + "timestamp": 1600361232070, + "version": "1.4.1" + }, + "invoke-1.4.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "0eab86faf75905bace90ce60d410e2cf", + "name": "invoke", + "sha256": "a0701a92bc9a6ba5592786f5a343dfe1f6a18f68d0e847bce797748c1e1497c4", + "size": 274815, + "subdir": "linux-64", + "timestamp": 1600361228337, + "version": "1.4.1" + }, + "invoke-1.5.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "421ec9be163ddb4c8314aa1cec5e6ed3", + "name": "invoke", + "sha256": "1fa98bed2af8a5bb0ede6560b51de1bcb0ed316cb05202c18c16eea819d4e3b2", + "size": 274119, + "subdir": "linux-64", + "timestamp": 1612279037237, + "version": "1.5.0" + }, + "invoke-1.5.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ead43a629004c4d40c3267d3c4e5867a", + "name": "invoke", + "sha256": "e1620dfa16ccb45250c387a74c8a8e532a4db21ab548a44844acfd8dfcb38981", + "size": 275779, + "subdir": "linux-64", + "timestamp": 1612278983156, + "version": "1.5.0" + }, + "invoke-1.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "2ad73ef55e841e8d1acb8261a28cfa9a", + "name": "invoke", + "sha256": "e0d8501910373cd190d743eb5e419f7e94053f4a227c6de83e97c336feaeac20", + "size": 273986, + "subdir": "linux-64", + "timestamp": 1612278737805, + "version": "1.5.0" + }, + "invoke-1.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d8f36917967dba02afc19db17592c188", + "name": "invoke", + "sha256": "1f5014f0ab671f2c823b1b4ef3118fc91beebd7d4fd927cfc31f9fa8b459d8be", + "size": 282079, + "subdir": "linux-64", + "timestamp": 1612278986029, + "version": "1.5.0" + }, + "invoke-1.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "0b32653941677addf3b2f98ecf58e1cf", + "name": "invoke", + "sha256": "9e0322378f7fba0a06d9735d46df470faad0dce92f25ce7766ed42ba6cbbb688", + "size": 280295, + "subdir": "linux-64", + "timestamp": 1640791101835, + "version": "1.6.0" + }, + "invoke-1.6.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "3df13b4e069eefc58f73a5e594c0bc7c", + "name": "invoke", + "sha256": "c42e9efb8b3f595eaedfedb1021c0d108f7f28ca3523f9ddcc9b85a693cf6404", + "size": 358635, + "subdir": "linux-64", + "timestamp": 1676844344407, + "version": "1.6.0" + }, + "invoke-1.6.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "22332f5459eeff8d717a18d6ea1efdac", + "name": "invoke", + "sha256": "4964b8735c6e7b6f10cf4db7abaf78cb1a27291e24ec17f7bf3ba33e4b8720a4", + "size": 280623, + "subdir": "linux-64", + "timestamp": 1626067442194, + "version": "1.6.0" + }, + "invoke-1.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c255d4e28dfb3022d4d252faed9ac51a", + "name": "invoke", + "sha256": "ef955b4c0ee8ed5b81924e494dbc9c9169fa9e133a618a63c5219fc2c2f764de", + "size": 280381, + "subdir": "linux-64", + "timestamp": 1626060455377, + "version": "1.6.0" + }, + "invoke-1.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "578ebbf300e04d1452d4acd691a2029b", + "name": "invoke", + "sha256": "0a3e30a0f4b5600f1ff609ca2a10064462d7c90b5e5e4a20b16674aec17946de", + "size": 274554, + "subdir": "linux-64", + "timestamp": 1626067428560, + "version": "1.6.0" + }, + "invoke-1.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "eb274dd6216558b46d8da6d984d86d62", + "name": "invoke", + "sha256": "300e227f40559f41e52e12097f6c3604c21d68ca2168c97d08336fd6af59b00b", + "size": 274358, + "subdir": "linux-64", + "timestamp": 1626089899372, + "version": "1.6.0" + }, + "ipaddr-2.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "464db21187892765b3265ce4ae1fc90b", + "name": "ipaddr", + "sha256": "03d915eb62c915a3ed792fee6afdd3ea65767df42426d46c02987ba86895fa10", + "size": 29614, + "subdir": "linux-64", + "timestamp": 1530897789745, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py27h59904b5_0.tar.bz2": { + "build": "py27h59904b5_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d0e558f0a3fa0c7ccca25dd9f73d2950", + "name": "ipaddr", + "sha256": "fbaaeb637d2444b43ef7d6e9971bc95aa7bae309f53682d5db5b99c8e86a2de0", + "size": 29809, + "subdir": "linux-64", + "timestamp": 1507401429255, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f4104d859740faa8ddc000b17233c8a6", + "name": "ipaddr", + "sha256": "704cd23db344efa0bc5433d2f3ccb9bc12733faeffc10b6c58f20190d516b91d", + "size": 31085, + "subdir": "linux-64", + "timestamp": 1640791119558, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f489595b8f14768d5b5d106621780f01", + "name": "ipaddr", + "sha256": "2dcca70e819e05e124fe862d902fda207cc6489a54a7131a3c4ad10b57b6084e", + "size": 39238, + "subdir": "linux-64", + "timestamp": 1676852888924, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py35h205650a_0.tar.bz2": { + "build": "py35h205650a_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c971725816b394d40a14caf5575185d0", + "name": "ipaddr", + "sha256": "168823f8b9190180498e7b4fc7e68d93b7413b903d903467aae02e8658e99e80", + "size": 30741, + "subdir": "linux-64", + "timestamp": 1507401431662, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bbd26a78544d074ae78eb1edec98efae", + "name": "ipaddr", + "sha256": "3562df136ac27e59fd2f3e4da7e0cb74bfa6cbd0396d2f8444b995043722c334", + "size": 30396, + "subdir": "linux-64", + "timestamp": 1530897842059, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c42b0fee7492e7ee9ffd432105385cdb", + "name": "ipaddr", + "sha256": "7709ed06eb71053765b99345f51d00af6667de02412556bce13891952a1f2f11", + "size": 31459, + "subdir": "linux-64", + "timestamp": 1632748096907, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py36h982ec33_0.tar.bz2": { + "build": "py36h982ec33_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "109c652045a72385d989496446c5f0de", + "name": "ipaddr", + "sha256": "f30a1478c1bb2d4a371d5e6b42a7355466080f09fc70263b42e7887c82fc42fe", + "size": 30607, + "subdir": "linux-64", + "timestamp": 1507401429067, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9f608a2666d1f40f2c689cce986e33c6", + "name": "ipaddr", + "sha256": "a145b4de037dfac5d7c406b349e0f751c6ca97b8b064a5a9dd8a28b305725f1b", + "size": 30394, + "subdir": "linux-64", + "timestamp": 1530897815335, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f8ccdad53b3bc569a9a306909a9a2a96", + "name": "ipaddr", + "sha256": "d1f5e97d6cef7d39f1168a68d84d9c4763bea7b538a2134f435b79d66c08429c", + "size": 31453, + "subdir": "linux-64", + "timestamp": 1632748437870, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8c919e7ff0bafabf00871f6940e4395e", + "name": "ipaddr", + "sha256": "5826081b348bee018469972bba686f46b17acbf359d849dc7a33727acacfcf08", + "size": 31052, + "subdir": "linux-64", + "timestamp": 1572437552878, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6e8a457781751dd53f4f190c795c42c2", + "name": "ipaddr", + "sha256": "1139106e63fb20dd4e0e3e668ec374f502279fd536535023f9ed3909f8d0501f", + "size": 31674, + "subdir": "linux-64", + "timestamp": 1632748441464, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c1343da1479d73f005660e5849ef0e3f", + "name": "ipaddr", + "sha256": "2e3cf03d96e81a3af310997c50b4b75499dc8139adb633f392ba1e0117d26429", + "size": 31634, + "subdir": "linux-64", + "timestamp": 1632748442398, + "version": "2.2.0" + }, + "ipaddress-1.0.18-py27h337fd85_0.tar.bz2": { + "build": "py27h337fd85_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "license_family": "PSF", + "md5": "75c426b37914c52ea937e6bb6604d9a8", + "name": "ipaddress", + "sha256": "b9562b893a924c91190ea6d54637f845e8e3463f493cd8443ee24995669ecabc", + "size": 32581, + "subdir": "linux-64", + "timestamp": 1505691786314, + "version": "1.0.18" + }, + "ipaddress-1.0.19-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "license_family": "PSF", + "md5": "bc07509b8f0de0f14edd9ac0075f2c97", + "name": "ipaddress", + "sha256": "5bcb735ed66f014ca9c19a77d4bdc57c91575190dd0afb0f9b9bd5558d4b9189", + "size": 33038, + "subdir": "linux-64", + "timestamp": 1515704334664, + "version": "1.0.19" + }, + "ipaddress-1.0.22-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "license_family": "PSF", + "md5": "3ff78790b92ed2bb5c73c031db1104da", + "name": "ipaddress", + "sha256": "41898b62022e5725f9b73385202dfa6f2ae28a72d68b3c20416ebdf3cfee373c", + "size": 33023, + "subdir": "linux-64", + "timestamp": 1523974561353, + "version": "1.0.22" + }, + "ipykernel-4.10.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "80719b0db0db84baf1c8a7b40f594e8c", + "name": "ipykernel", + "sha256": "1acc00c32907ef0ee469b5d23b9fa4b39a67e7121a8c2713fe1859acee58d033", + "size": 148241, + "subdir": "linux-64", + "timestamp": 1538040731267, + "version": "4.10.0" + }, + "ipykernel-4.10.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5fe7b8ef5cca8bd09809990ac671d5bf", + "name": "ipykernel", + "sha256": "30c3239801121b393c79d369adcbe339a1163e586dcb9635d576c00ddc52f7c8", + "size": 151489, + "subdir": "linux-64", + "timestamp": 1538040792655, + "version": "4.10.0" + }, + "ipykernel-4.10.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "78ceebf812e03508640ee7baf8ee1de1", + "name": "ipykernel", + "sha256": "843d1f340fb43b980923a48af05d3a4786dfd355088e78285c3a1b62f561ee54", + "size": 150148, + "subdir": "linux-64", + "timestamp": 1538040761425, + "version": "4.10.0" + }, + "ipykernel-4.10.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "57646855eee9facb0f0752a1a10d17a3", + "name": "ipykernel", + "sha256": "78d063b3e4758e4b018fdecc06e62c9f649d0308e52205662f76071863f28720", + "size": 150215, + "subdir": "linux-64", + "timestamp": 1538040700771, + "version": "4.10.0" + }, + "ipykernel-4.6.1-py27hc93e584_0.tar.bz2": { + "build": "py27hc93e584_0", + "build_number": 0, + "depends": [ + "ipython", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "53e699ff0b1c80574a1692551704c0d9", + "name": "ipykernel", + "sha256": "8184a504c3927059d4939de39a0941626abf76fcdd1185c977a97e0b0909e401", + "size": 140802, + "subdir": "linux-64", + "timestamp": 1505690571612, + "version": "4.6.1" + }, + "ipykernel-4.6.1-py35h29d130c_0.tar.bz2": { + "build": "py35h29d130c_0", + "build_number": 0, + "depends": [ + "ipython", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "4a9a37f83cafb1a5cbe4aa932d1da4e2", + "name": "ipykernel", + "sha256": "eb8064ca7ccb57051ef1b9efdcb4b31c51ae54dd3a00bc53ab0c2cd83c07db65", + "size": 143968, + "subdir": "linux-64", + "timestamp": 1505690708184, + "version": "4.6.1" + }, + "ipykernel-4.6.1-py36hbf841aa_0.tar.bz2": { + "build": "py36hbf841aa_0", + "build_number": 0, + "depends": [ + "ipython", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "6501d12125d330e075f0bde0c9526019", + "name": "ipykernel", + "sha256": "d46edccbc688718ff7b84fc420a24c711e6eaab2fe4f447045e6c4c5d3d49513", + "size": 142708, + "subdir": "linux-64", + "timestamp": 1505690727501, + "version": "4.6.1" + }, + "ipykernel-4.7.0-py27h5233db4_0.tar.bz2": { + "build": "py27h5233db4_0", + "build_number": 0, + "depends": [ + "ipython", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e270d1f6f98e6fb243dc874f609a9d68", + "name": "ipykernel", + "sha256": "f47fb1607c4f3c6e80e8c77e56ab05535f2e3b203c4a76b35e57bb461e3c95ba", + "size": 143975, + "subdir": "linux-64", + "timestamp": 1512586018518, + "version": "4.7.0" + }, + "ipykernel-4.7.0-py35h2f9c1c0_0.tar.bz2": { + "build": "py35h2f9c1c0_0", + "build_number": 0, + "depends": [ + "ipython", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "af29e135206cf20cc8df7b551a17cf98", + "name": "ipykernel", + "sha256": "620d62bd0297e5bb35990f1e909d36d8687e1bb45bfeb0bc060aac099c28870a", + "size": 147124, + "subdir": "linux-64", + "timestamp": 1512586049343, + "version": "4.7.0" + }, + "ipykernel-4.7.0-py36h2f9c1c0_0.tar.bz2": { + "build": "py36h2f9c1c0_0", + "build_number": 0, + "depends": [ + "ipython", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3097e3020ca8a85e7713c0ae5675aba8", + "name": "ipykernel", + "sha256": "03fcc3c61751cda080eeee1369563d64ff5b37fb13bdcd8a9d6d15ed09427783", + "size": 145761, + "subdir": "linux-64", + "timestamp": 1512586060687, + "version": "4.7.0" + }, + "ipykernel-4.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipython >=4.0.0", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "54ed979df72ccd7ad75b8713049b6e8a", + "name": "ipykernel", + "sha256": "aab07cbceab17653e6c9c47f94b21a96e4ba22f7fcc980a2a6f9feef16797589", + "size": 146326, + "subdir": "linux-64", + "timestamp": 1516652174979, + "version": "4.8.0" + }, + "ipykernel-4.8.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipython >=4.0.0", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dc5271f8f1c7b029c1eacef861c2662a", + "name": "ipykernel", + "sha256": "d48666999867c9606dc98895557e1b730db7732ddf474ebd55df8bc1b68e73dd", + "size": 149230, + "subdir": "linux-64", + "timestamp": 1516652159456, + "version": "4.8.0" + }, + "ipykernel-4.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4.0.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "29fd9d11502a2805cf8e6d7a8c24525e", + "name": "ipykernel", + "sha256": "7bc43718eec20cc3e9563cb06024cfb17d41b57ac1dd7ebd0545b4b3f242c300", + "size": 148188, + "subdir": "linux-64", + "timestamp": 1516652159262, + "version": "4.8.0" + }, + "ipykernel-4.8.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipython >=4.0.0", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1d1d9eea36f20060e11561cad3eee9eb", + "name": "ipykernel", + "sha256": "232bdc4e1f14e2dd22cb4f6758db4af93845d5ee3bad0412d313550162b03402", + "size": 146422, + "subdir": "linux-64", + "timestamp": 1519152937479, + "version": "4.8.2" + }, + "ipykernel-4.8.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipython >=4.0.0", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "21f38591e6ce17d25aec9ae23c69f9fe", + "name": "ipykernel", + "sha256": "af885438cf974dd3afe72888c8c4a62a13c92dcfc9ebaa3daffd6b69608a3ebd", + "size": 149885, + "subdir": "linux-64", + "timestamp": 1519152976611, + "version": "4.8.2" + }, + "ipykernel-4.8.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4.0.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "14bee4049ede818d81724c3077fdc3e0", + "name": "ipykernel", + "sha256": "db6e420edbf5e002123583466b76b72165326864ebe9115381d4a96555b4e7d1", + "size": 148545, + "subdir": "linux-64", + "timestamp": 1519152923770, + "version": "4.8.2" + }, + "ipykernel-4.8.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4.0.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "60c813f6d1176e25e42178b8b400e1ba", + "name": "ipykernel", + "sha256": "c79dbcc1b162ed1c48af7c5529022199e5f0bd6c655d0293f7cb2d3042fcf043", + "size": 151915, + "subdir": "linux-64", + "timestamp": 1530734063073, + "version": "4.8.2" + }, + "ipykernel-4.9.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "792179a1a218b77c47429f7990d348b9", + "name": "ipykernel", + "sha256": "20bf66c30ae459cd54e77ccf3260211d78769ce353a0b66ecdd69309ab53c372", + "size": 147817, + "subdir": "linux-64", + "timestamp": 1536073577085, + "version": "4.9.0" + }, + "ipykernel-4.9.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "436ab8fc4bc94c5c35bfcd90e80cc74f", + "name": "ipykernel", + "sha256": "d050e266bb5ea005390b744b74de81c372044562290144ff5e446f2b138680c3", + "size": 147864, + "subdir": "linux-64", + "timestamp": 1537386314387, + "version": "4.9.0" + }, + "ipykernel-4.9.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "82356ce50ce5c2c7735a9d7de58076ff", + "name": "ipykernel", + "sha256": "7267bf4fec1783cbfc682a7165ac02fee606d868079c9ba0b5c1274ba347542a", + "size": 150735, + "subdir": "linux-64", + "timestamp": 1536073616730, + "version": "4.9.0" + }, + "ipykernel-4.9.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6e337bc7143c80a09abc07b13ba48cb5", + "name": "ipykernel", + "sha256": "513eb572a3a5960d5a7e34ca5bee90106a9a72b441cf826a8dac8b73243de699", + "size": 150828, + "subdir": "linux-64", + "timestamp": 1537386369650, + "version": "4.9.0" + }, + "ipykernel-4.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4649d82e1bac9ab994668d42e5c24f5d", + "name": "ipykernel", + "sha256": "22461f15f47902af1ae16c8ba7ce1396d99470b96449a39d8b81f79b3100a8c4", + "size": 149724, + "subdir": "linux-64", + "timestamp": 1536073582294, + "version": "4.9.0" + }, + "ipykernel-4.9.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "af95aad1ccefbd2c5309f32c82e87bea", + "name": "ipykernel", + "sha256": "7ab20c5898a70cc1e73505a51c7bc6bd86aa0d24707c3cd8a134f1281080e859", + "size": 149871, + "subdir": "linux-64", + "timestamp": 1537386383438, + "version": "4.9.0" + }, + "ipykernel-4.9.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8f18aeecb60f7f9ab9fa48073ed1c8b7", + "name": "ipykernel", + "sha256": "00e358441059b05147d90beef9e5bce9d9e8e9d45db3dc40664fb98ee9cd6530", + "size": 149862, + "subdir": "linux-64", + "timestamp": 1536073622581, + "version": "4.9.0" + }, + "ipykernel-4.9.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "49fc64a200be4608eac8c3bfcb401870", + "name": "ipykernel", + "sha256": "4eb4e555c7b62b2622e00f1470af975f1ead4c1f4dd7c3aa41a8f73654c5aee2", + "size": 149981, + "subdir": "linux-64", + "timestamp": 1537386308958, + "version": "4.9.0" + }, + "ipykernel-5.0.0-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "702b8a9232b3b13f5df79e5b5afb5c15", + "name": "ipykernel", + "sha256": "a2ea64c607e49a4cda61733a1561b51ca9f4072c70b444a9d199450f4f79b274", + "size": 159414, + "subdir": "linux-64", + "timestamp": 1538603381927, + "version": "5.0.0" + }, + "ipykernel-5.0.0-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f9c34649b5bd0e833a762a3fa12af859", + "name": "ipykernel", + "sha256": "96c519cc61a18db4a2cbccbf51076dc155f54f110b8bece9be21f465da0a15b8", + "size": 159474, + "subdir": "linux-64", + "timestamp": 1538606276960, + "version": "5.0.0" + }, + "ipykernel-5.1.0-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "974fa3b8c9ea129c882978f5bde72204", + "name": "ipykernel", + "sha256": "a51de2a341b16ab555b2a1afc7fb8cedccda30182c05115e70a07923aa7877e2", + "size": 159992, + "subdir": "linux-64", + "timestamp": 1539879520077, + "version": "5.1.0" + }, + "ipykernel-5.1.0-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e841ca6c03228af0ea3a4b69f36bf140", + "name": "ipykernel", + "sha256": "3f047bab44eb6665525147bd89c2b2ea0e26725019d44fe49da44dafef96797a", + "size": 160199, + "subdir": "linux-64", + "timestamp": 1539879520664, + "version": "5.1.0" + }, + "ipykernel-5.1.1-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "702906ae0b71731790b1248781eb87cc", + "name": "ipykernel", + "sha256": "9caa509b379dd1df7b8439b2bc11fbf73574d227423aac84cfc98a2dff2c8751", + "size": 165735, + "subdir": "linux-64", + "timestamp": 1559658946956, + "version": "5.1.1" + }, + "ipykernel-5.1.1-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "84c69040cbcce19b589ac5acc054f78a", + "name": "ipykernel", + "sha256": "a0c9862e653b9efc2fd2701f2108be0d89e4a7b7e6e8b25bc0a15917bdc6f8a2", + "size": 165841, + "subdir": "linux-64", + "timestamp": 1559658916651, + "version": "5.1.1" + }, + "ipykernel-5.1.2-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "54bb5bfff2543b5f92889abb2c7a610e", + "name": "ipykernel", + "sha256": "d3e7686c5b2ef6cdde808520d2b70f170dd7e6f1c58928596af37acb999b4058", + "size": 168887, + "subdir": "linux-64", + "timestamp": 1565955912025, + "version": "5.1.2" + }, + "ipykernel-5.1.2-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7610a064574fd569b839f33d7873ccf4", + "name": "ipykernel", + "sha256": "3eb4acb683dc7809b3049ce0b0f0f066e77a1bedf6cade32e6c591c04539e89a", + "size": 169166, + "subdir": "linux-64", + "timestamp": 1565899836330, + "version": "5.1.2" + }, + "ipykernel-5.1.3-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "29991e385a23599ba0d37a1d4d53df1d", + "name": "ipykernel", + "sha256": "78d3beae51732ce1cd1ef7d03a7062f78fb0eb249a8ea534a3cc588d49df39bc", + "size": 171280, + "subdir": "linux-64", + "timestamp": 1572456863865, + "version": "5.1.3" + }, + "ipykernel-5.1.3-py36h39e3cac_1.tar.bz2": { + "build": "py36h39e3cac_1", + "build_number": 1, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "868d712673c4807b4eece1773f194c45", + "name": "ipykernel", + "sha256": "bfc92e74e9e089609bc1e690177ae9544e9f71d544a9ad5a521b0dfebfdbb651", + "size": 171664, + "subdir": "linux-64", + "timestamp": 1579118681344, + "version": "5.1.3" + }, + "ipykernel-5.1.3-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "265f4bfbb680bdb532c44309cecae973", + "name": "ipykernel", + "sha256": "b546f6855f98c65668dcdcd053cf5d658586792828c0d30693563cb8f28038d8", + "size": 171501, + "subdir": "linux-64", + "timestamp": 1572456830675, + "version": "5.1.3" + }, + "ipykernel-5.1.3-py37h39e3cac_1.tar.bz2": { + "build": "py37h39e3cac_1", + "build_number": 1, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2a011049f274d0c2d5c59aec5ddf06bd", + "name": "ipykernel", + "sha256": "b25417c88c8454ac5eba2b0df6242c4b073145c4400645a9d211578fd26af403", + "size": 171918, + "subdir": "linux-64", + "timestamp": 1579118684637, + "version": "5.1.3" + }, + "ipykernel-5.1.3-py38h39e3cac_0.tar.bz2": { + "build": "py38h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "57095195fc8edb000b890739bdbaf69b", + "name": "ipykernel", + "sha256": "d0141b4a1c00a6e4ba72a38406109322ed336069d82ec20f6b506c628211adb8", + "size": 164842, + "subdir": "linux-64", + "timestamp": 1574235734148, + "version": "5.1.3" + }, + "ipykernel-5.1.3-py38h39e3cac_1.tar.bz2": { + "build": "py38h39e3cac_1", + "build_number": 1, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d1f679313bf0bbf814a976b876a56c8", + "name": "ipykernel", + "sha256": "60686ab0571feca02f108ed7a9c62c92f5ccc7e85f0ddf0058d7d291d2d65943", + "size": 172512, + "subdir": "linux-64", + "timestamp": 1579118667631, + "version": "5.1.3" + }, + "ipykernel-5.1.4-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c77eb29ab73510e394fd79d7e205f3e2", + "name": "ipykernel", + "sha256": "d441065a7565fb2938c78b6ac2425770d14c7ab042893733869035a5ce14f74a", + "size": 171782, + "subdir": "linux-64", + "timestamp": 1580149653429, + "version": "5.1.4" + }, + "ipykernel-5.1.4-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4e6a81b7fa4c1f503183ff840389246b", + "name": "ipykernel", + "sha256": "3215c665750f0040a2bef0de680132a84981156359dd613cf817d166c864a8b9", + "size": 172010, + "subdir": "linux-64", + "timestamp": 1580149676813, + "version": "5.1.4" + }, + "ipykernel-5.1.4-py38h39e3cac_0.tar.bz2": { + "build": "py38h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "34502c7c740d9227b9686cb76b083c48", + "name": "ipykernel", + "sha256": "2c434de3dcb2bb63794f74d9558d2967851e8c53d2cd6f9df7375bb4a939e784", + "size": 172483, + "subdir": "linux-64", + "timestamp": 1580149667914, + "version": "5.1.4" + }, + "ipykernel-5.3.0-py36h5ca1d4c_0.tar.bz2": { + "build": "py36h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "090f8623673d48aac8d284f4a1832669", + "name": "ipykernel", + "sha256": "93cba99177819d7e1f7e84aefe5daeeafaa8d77567496a5280246912086a36a4", + "size": 178136, + "subdir": "linux-64", + "timestamp": 1592339939667, + "version": "5.3.0" + }, + "ipykernel-5.3.0-py37h5ca1d4c_0.tar.bz2": { + "build": "py37h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3a55a6cc10803a02baac04490ae03a5b", + "name": "ipykernel", + "sha256": "f7ec97a6c6c34a4cb3ff035d93ec6e17724564dcf7cb33d0f93262ca95841130", + "size": 178413, + "subdir": "linux-64", + "timestamp": 1592339944504, + "version": "5.3.0" + }, + "ipykernel-5.3.0-py38h5ca1d4c_0.tar.bz2": { + "build": "py38h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aeec240519ef7f69857a3c12bf2a0da6", + "name": "ipykernel", + "sha256": "174e8955ebd99898cf04232a3693be5aa5fe44eb6580e2bff3cd399570177e10", + "size": 178993, + "subdir": "linux-64", + "timestamp": 1592339891383, + "version": "5.3.0" + }, + "ipykernel-5.3.2-py36h5ca1d4c_0.tar.bz2": { + "build": "py36h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b8359c885593abd4ff0c6080c40f1467", + "name": "ipykernel", + "sha256": "4ec0eaa51c8b4bb9c9c8400995dc49abc60373ecacb495c2c264e8d08900727d", + "size": 179957, + "subdir": "linux-64", + "timestamp": 1594755362658, + "version": "5.3.2" + }, + "ipykernel-5.3.2-py37h5ca1d4c_0.tar.bz2": { + "build": "py37h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "93fab102462f2dd555857ec2ecb1bd70", + "name": "ipykernel", + "sha256": "42e32ed0deb92815de7cc60fb4aecae8f318a6014108ae74044773a28eff277f", + "size": 180188, + "subdir": "linux-64", + "timestamp": 1594753413943, + "version": "5.3.2" + }, + "ipykernel-5.3.2-py38h5ca1d4c_0.tar.bz2": { + "build": "py38h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f5de39fb1ccc4e0a60ec3a89faf66433", + "name": "ipykernel", + "sha256": "a7aea685db83a38936bba15f411f3667fa80c964aba1b035eb8096c503f6499c", + "size": 180831, + "subdir": "linux-64", + "timestamp": 1594753414032, + "version": "5.3.2" + }, + "ipykernel-5.3.3-py36h5ca1d4c_0.tar.bz2": { + "build": "py36h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bae1f3c59ba5d395fbc8751d15f1a07d", + "name": "ipykernel", + "sha256": "5840a69b59edda8d64c530aa11544e7bf2e212e1cf1eef847f688f4e168bdb99", + "size": 180174, + "subdir": "linux-64", + "timestamp": 1595346605681, + "version": "5.3.3" + }, + "ipykernel-5.3.3-py37h5ca1d4c_0.tar.bz2": { + "build": "py37h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "37e9758e393cd7b399be83b75a372ba9", + "name": "ipykernel", + "sha256": "30ca327c18753c0b6c3af4627541436812c9ec9fcbcb3b4ea2d7bf74220088a8", + "size": 180410, + "subdir": "linux-64", + "timestamp": 1595347189618, + "version": "5.3.3" + }, + "ipykernel-5.3.3-py38h5ca1d4c_0.tar.bz2": { + "build": "py38h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85e4326ea1cb8be11e058202b77da22f", + "name": "ipykernel", + "sha256": "9575a445053e4ba163a4955871a1a1fc349769e16ea0f7bf1b413ff1c159ee69", + "size": 180971, + "subdir": "linux-64", + "timestamp": 1595347191937, + "version": "5.3.3" + }, + "ipykernel-5.3.4-py36h5ca1d4c_0.tar.bz2": { + "build": "py36h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "60bf91c2409d6412f1617f80b8a77d7f", + "name": "ipykernel", + "sha256": "91dfe8c478865d3bc84ff6239b094a2236ea20a3b5fe28a3db7327ba5b61bda4", + "size": 180336, + "subdir": "linux-64", + "timestamp": 1596206647122, + "version": "5.3.4" + }, + "ipykernel-5.3.4-py37h5ca1d4c_0.tar.bz2": { + "build": "py37h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fd3ae202ea14cd212cfbf5019b7198b6", + "name": "ipykernel", + "sha256": "93af30f1a331549f450ac9b1e863ff6ff7854fe1ced0a8eccd2da0e31ae388cb", + "size": 180460, + "subdir": "linux-64", + "timestamp": 1596206637562, + "version": "5.3.4" + }, + "ipykernel-5.3.4-py38h5ca1d4c_0.tar.bz2": { + "build": "py38h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "37fdb0c4ea5c79b3b66bd59bb3e7d34a", + "name": "ipykernel", + "sha256": "0efb03b15cc10c71c5afe5880b2201d0d7c766391db141e7ec02f584984cc9a2", + "size": 181221, + "subdir": "linux-64", + "timestamp": 1596207682698, + "version": "5.3.4" + }, + "ipykernel-5.3.4-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.9,<3.10.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d33389fcb3af9c6a5b73ef46756db37c", + "name": "ipykernel", + "sha256": "babb3ddd644cc283a6452ccb1501adce4ff8ed6a80e9bb0dbceb8c853612f508", + "size": 181275, + "subdir": "linux-64", + "timestamp": 1607452836012, + "version": "5.3.4" + }, + "ipykernel-6.15.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "debugpy >=1.0.0", + "ipython >=7.23.1", + "jupyter_client >=6.1.12", + "matplotlib-inline >=0.1.0", + "nest-asyncio", + "packaging", + "psutil", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "tornado >=6.1,<7.0", + "traitlets >=5.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b68acfd9fcc509b837ca0aa5d89a628b", + "name": "ipykernel", + "sha256": "8468b2ac6664cccdcc9473cd0d1f1535cb0b82641c7caa65530eb6c2bb948738", + "size": 192143, + "subdir": "linux-64", + "timestamp": 1662362226787, + "version": "6.15.2" + }, + "ipykernel-6.15.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "debugpy >=1.0.0", + "ipython >=7.23.1", + "jupyter_client >=6.1.12", + "matplotlib-inline >=0.1.0", + "nest-asyncio", + "packaging", + "psutil", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "tornado >=6.1,<7.0", + "traitlets >=5.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0df557e7510960b2d779f963ad79841a", + "name": "ipykernel", + "sha256": "b96ad4a4636497fe409d3b850c930fda19affee3cbe756125c01d6fb311e036f", + "size": 189527, + "subdir": "linux-64", + "timestamp": 1662362093833, + "version": "6.15.2" + }, + "ipykernel-6.15.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "debugpy >=1.0.0", + "ipython >=7.23.1", + "jupyter_client >=6.1.12", + "matplotlib-inline >=0.1.0", + "nest-asyncio", + "packaging", + "psutil", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "tornado >=6.1,<7.0", + "traitlets >=5.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9e93ac2b017044fdeb3b93fa7fa3022f", + "name": "ipykernel", + "sha256": "a25c823df79a51fd1fe4fefe6ff710d9db2af8f59a8229894b3717597fab99c4", + "size": 189689, + "subdir": "linux-64", + "timestamp": 1662361974763, + "version": "6.15.2" + }, + "ipykernel-6.15.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "debugpy >=1.0.0", + "ipython >=7.23.1", + "jupyter_client >=6.1.12", + "matplotlib-inline >=0.1.0", + "nest-asyncio", + "packaging", + "psutil", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "tornado >=6.1,<7.0", + "traitlets >=5.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5284c0b9b76b52b10cb311f6f2d82121", + "name": "ipykernel", + "sha256": "ca304daecfa2d41d223615c4370232b2ea58ee7151f6a39d1770be2af45f6cb4", + "size": 190303, + "subdir": "linux-64", + "timestamp": 1662361852777, + "version": "6.15.2" + }, + "ipykernel-6.19.2-py310h2f386ee_0.tar.bz2": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "comm >=0.1.1", + "debugpy >=1.0", + "ipython >=7.23.1", + "jupyter_client >=6.1.12", + "matplotlib-inline >=0.1", + "nest-asyncio", + "packaging", + "psutil", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "tornado >=6.1", + "traitlets >=5.4.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c3310faa0f2fabb44a61384e8deee2f7", + "name": "ipykernel", + "sha256": "7dd3a2d36e69778e77cbb5bb53bd8cee420f6cef7e5b9e7db5d3eae5ab15e7f9", + "size": 205933, + "subdir": "linux-64", + "timestamp": 1671488556575, + "version": "6.19.2" + }, + "ipykernel-6.19.2-py311h6410fe4_0.tar.bz2": { + "build": "py311h6410fe4_0", + "build_number": 0, + "depends": [ + "comm >=0.1.1", + "debugpy >=1.0", + "ipython >=7.23.1", + "jupyter_client >=6.1.12", + "matplotlib-inline >=0.1", + "nest-asyncio", + "packaging", + "psutil", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "tornado >=6.1", + "traitlets >=5.4.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f917e511c1f6f3fd72bd299b10b7b2e", + "name": "ipykernel", + "sha256": "9e321e3de2622c6e421397b87b0fd959d06abb75f3add6f0226319477105f43c", + "size": 279238, + "subdir": "linux-64", + "timestamp": 1677867968670, + "version": "6.19.2" + }, + "ipykernel-6.19.2-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "comm >=0.1.1", + "debugpy >=1.0", + "ipython >=7.23.1", + "jupyter_client >=6.1.12", + "matplotlib-inline >=0.1", + "nest-asyncio", + "packaging", + "psutil", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "tornado >=6.1", + "traitlets >=5.4.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8411fbef7b61093a89bcfb698e4a94c4", + "name": "ipykernel", + "sha256": "2f7bbc17d6f687a7e0436dca6ac387add5fe5894d29569efef0d177779b731a8", + "size": 203314, + "subdir": "linux-64", + "timestamp": 1671488427499, + "version": "6.19.2" + }, + "ipykernel-6.19.2-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "comm >=0.1.1", + "debugpy >=1.0", + "ipython >=7.23.1", + "jupyter_client >=6.1.12", + "matplotlib-inline >=0.1", + "nest-asyncio", + "packaging", + "psutil", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "tornado >=6.1", + "traitlets >=5.4.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0d56ab1950f952284b895ac0f78284a7", + "name": "ipykernel", + "sha256": "b51b2e0dd37a74784ba19db22aded3f4c843b6fddb4a74399f65f36fc018aaa2", + "size": 203541, + "subdir": "linux-64", + "timestamp": 1671488675347, + "version": "6.19.2" + }, + "ipykernel-6.2.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "argcomplete >=1.12.3", + "debugpy >=1,<2.0", + "importlib-metadata <5", + "ipython >=7.23.1,<8.0", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "python >=3.7,<3.8.0a0", + "tornado >=4.2,<7.0", + "traitlets >=4.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "980c88be2b0e2bae7cffe351a6194cd7", + "name": "ipykernel", + "sha256": "0dee573f611c0752ff2259cd4673819d6020af45706146ee7c71689ac41b7dc2", + "size": 189527, + "subdir": "linux-64", + "timestamp": 1629986184914, + "version": "6.2.0" + }, + "ipykernel-6.2.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "debugpy >=1,<2.0", + "ipython >=7.23.1,<8.0", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "python >=3.8,<3.9.0a0", + "tornado >=4.2,<7.0", + "traitlets >=4.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "67a8bfcaa9a6c306dda79999e75bb47e", + "name": "ipykernel", + "sha256": "eeab64e151f9a2d814066fe805221fcfcb5b025fd740027b483e5df06920a43d", + "size": 190330, + "subdir": "linux-64", + "timestamp": 1629995147032, + "version": "6.2.0" + }, + "ipykernel-6.2.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "debugpy >=1,<2.0", + "ipython >=7.23.1,<8.0", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "python >=3.9,<3.10.0a0", + "tornado >=4.2,<7.0", + "traitlets >=4.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1044997b55d2bd071fe14a932b983b3", + "name": "ipykernel", + "sha256": "4717d303d220368c7c3468ed5a920be8959ed23fb5b23b6b469962366b735cf1", + "size": 190469, + "subdir": "linux-64", + "timestamp": 1629995148430, + "version": "6.2.0" + }, + "ipykernel-6.4.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "debugpy >=1,<2.0", + "ipython >=7.23.1,<8.0", + "ipython_genutils", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "python >=3.10,<3.11.0a0", + "tornado >=4.2,<7.0", + "traitlets >=4.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "560cc45eaced9ecfcd80a747a49d12eb", + "name": "ipykernel", + "sha256": "37b05b627f66768bd36c4d64b809ee4631742080a94f8ce298e5c6189bc431bf", + "size": 179998, + "subdir": "linux-64", + "timestamp": 1640812222903, + "version": "6.4.1" + }, + "ipykernel-6.4.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "argcomplete >=1.12.3", + "debugpy >=1,<2.0", + "importlib-metadata <5", + "ipython >=7.23.1,<8.0", + "ipython_genutils", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "python >=3.7,<3.8.0a0", + "tornado >=4.2,<7.0", + "traitlets >=4.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dd08af96cf934923f5e2a5221b9cb41c", + "name": "ipykernel", + "sha256": "206eaccfd1b97697c63bc10816a8f54d1d25ae7bf1c44038cc75b8973e5cffc7", + "size": 192126, + "subdir": "linux-64", + "timestamp": 1633545462807, + "version": "6.4.1" + }, + "ipykernel-6.4.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "debugpy >=1,<2.0", + "ipython >=7.23.1,<8.0", + "ipython_genutils", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "python >=3.8,<3.9.0a0", + "tornado >=4.2,<7.0", + "traitlets >=4.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2c775acc35afe758c892410e3c262d45", + "name": "ipykernel", + "sha256": "db447033b68068ab15942047ab11108ec9fce577f4831502e16b4104a2f94e00", + "size": 192619, + "subdir": "linux-64", + "timestamp": 1633545454359, + "version": "6.4.1" + }, + "ipykernel-6.4.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "debugpy >=1,<2.0", + "ipython >=7.23.1,<8.0", + "ipython_genutils", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "python >=3.9,<3.10.0a0", + "tornado >=4.2,<7.0", + "traitlets >=4.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9808bfd061bc92c4e444fd4f4405d1af", + "name": "ipykernel", + "sha256": "ea86328d448d383669c3a0ef7a82067d1c659c406f06498c124591943bb2874b", + "size": 192985, + "subdir": "linux-64", + "timestamp": 1633534698061, + "version": "6.4.1" + }, + "ipykernel-6.9.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "debugpy >=1.0.0,<2.0", + "ipython >=7.23.1", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "nest-asyncio", + "python >=3.10,<3.11.0a0", + "tornado >=4.2,<7.0", + "traitlets >=5.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4039a7feed05bb47355e089b3382cfdd", + "name": "ipykernel", + "sha256": "c6b58c19bc980c84fa1e053e1f8bcf392914587c0c26b364cb44fdbbd556df49", + "size": 202352, + "subdir": "linux-64", + "timestamp": 1647000831741, + "version": "6.9.1" + }, + "ipykernel-6.9.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "debugpy >=1.0.0,<2.0", + "ipython >=7.23.1", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "nest-asyncio", + "python >=3.7,<3.8.0a0", + "tornado >=4.2,<7.0", + "traitlets >=5.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "45da680716c8da5fbbebcf90fe262ec2", + "name": "ipykernel", + "sha256": "bba85ff3c74d1355eca9507eec21eba518a3111f8c0b33f9e4ae6e3e50d7cb0b", + "size": 199722, + "subdir": "linux-64", + "timestamp": 1646983262624, + "version": "6.9.1" + }, + "ipykernel-6.9.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "debugpy >=1.0.0,<2.0", + "ipython >=7.23.1", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "nest-asyncio", + "python >=3.8,<3.9.0a0", + "tornado >=4.2,<7.0", + "traitlets >=5.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "abd0ca6584dab003633d2e03e387fbfa", + "name": "ipykernel", + "sha256": "95ae06ff4b99e1c4d15925ef956dda94b4e03053bc8fed6b874a2fa88c8d35f4", + "size": 200595, + "subdir": "linux-64", + "timestamp": 1646982691923, + "version": "6.9.1" + }, + "ipykernel-6.9.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "debugpy >=1.0.0,<2.0", + "ipython >=7.23.1", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "nest-asyncio", + "python >=3.9,<3.10.0a0", + "tornado >=4.2,<7.0", + "traitlets >=5.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "199293adeb8a78e347c7514915c8098a", + "name": "ipykernel", + "sha256": "04ff05450b825c28ba4adc5f6474279ecf9141097233a567ccf939ba57133a2b", + "size": 200661, + "subdir": "linux-64", + "timestamp": 1647000816111, + "version": "6.9.1" + }, + "ipyparallel-6.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator", + "futures", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9283f63f55d324d25d440273271a7585", + "name": "ipyparallel", + "sha256": "1ff62d380a7486ab41f859c90660175f90e8079cf17180f98a81e8b3c9a5ffce", + "size": 301221, + "subdir": "linux-64", + "timestamp": 1518721747213, + "version": "6.1.1" + }, + "ipyparallel-6.1.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c39e645a3d6f054934cc2c7ac3d124c9", + "name": "ipyparallel", + "sha256": "0a45ee72cd33831dc4b813e59b1f58fa64fb88696247b2a565dc4cc150226595", + "size": 309960, + "subdir": "linux-64", + "timestamp": 1518721757546, + "version": "6.1.1" + }, + "ipyparallel-6.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "143c5ca340935be5db7a356f8bce7b92", + "name": "ipyparallel", + "sha256": "a6b700331ed0b515ddbddbb5ccfe55fa027a742181b09651eb11692404721c8c", + "size": 306784, + "subdir": "linux-64", + "timestamp": 1518721824708, + "version": "6.1.1" + }, + "ipyparallel-6.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator", + "futures", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e05c75a86c22c815f8fc02c982ddde53", + "name": "ipyparallel", + "sha256": "a1a859af882d7af7ac797569b090410ef52f3d0f0eab75460fa3ea847751fa8a", + "size": 304794, + "subdir": "linux-64", + "timestamp": 1528219407881, + "version": "6.2.1" + }, + "ipyparallel-6.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bcbc3233f88090f42fbadd6eb01e8ece", + "name": "ipyparallel", + "sha256": "a9cda489147b0b286f8290be704d26f6ed9a2f9eb5dc65b932baeb97e3f49196", + "size": 313464, + "subdir": "linux-64", + "timestamp": 1528219433975, + "version": "6.2.1" + }, + "ipyparallel-6.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9e98e19ae1fcf1e9c0eedf9ee8cebe0d", + "name": "ipyparallel", + "sha256": "b96d2bd6eabc458df215bff5d2f0909242c17277c790d6df5f73d5fb7c875c56", + "size": 310100, + "subdir": "linux-64", + "timestamp": 1528219387902, + "version": "6.2.1" + }, + "ipyparallel-6.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "21d395f175e0a60471627049f8ab5a17", + "name": "ipyparallel", + "sha256": "71c539d882c385dcf9ecdf7cf95c3d997264e161e5e878161d87000a058493ad", + "size": 310486, + "subdir": "linux-64", + "timestamp": 1530897876704, + "version": "6.2.1" + }, + "ipyparallel-6.2.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator", + "futures", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c6304e48e8640479f1c7ba9cac595caf", + "name": "ipyparallel", + "sha256": "ccbfb083b88d9affe0f82f307719b0a7917b48ebbc0117b45d893bee377a93a8", + "size": 306021, + "subdir": "linux-64", + "timestamp": 1532629328930, + "version": "6.2.2" + }, + "ipyparallel-6.2.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0e610c503a8c2edc974e0c5501b69771", + "name": "ipyparallel", + "sha256": "cd1983a52adb5a4047c2717af857c73048f46357ee33b499e74f33ff8213c6a4", + "size": 314834, + "subdir": "linux-64", + "timestamp": 1532629463657, + "version": "6.2.2" + }, + "ipyparallel-6.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f8f9d90bc734125430dfa0d276b05c9d", + "name": "ipyparallel", + "sha256": "95cb7b57f162a68a55dbe5bcaf589ad62a19c2ba546d5738436f8821e71bd715", + "size": 311088, + "subdir": "linux-64", + "timestamp": 1532629387504, + "version": "6.2.2" + }, + "ipyparallel-6.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "91b91970296241f1bf60f3dab952f15d", + "name": "ipyparallel", + "sha256": "435f310ce09b5ea92340069e21f47145cb3120de9760d0035d849a69651541b0", + "size": 311039, + "subdir": "linux-64", + "timestamp": 1532629449211, + "version": "6.2.2" + }, + "ipyparallel-6.2.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator", + "futures", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b078cf24e7b1c69428ab845d45d512f7", + "name": "ipyparallel", + "sha256": "27c24bc51120170672ed3dc6b3de8b95164580d63cfd8e5244b576c1e91369d8", + "size": 315818, + "subdir": "linux-64", + "timestamp": 1540979213173, + "version": "6.2.3" + }, + "ipyparallel-6.2.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5eb650ab4dc1bc4701e2c648feb14378", + "name": "ipyparallel", + "sha256": "59fecc161a309b8de37dd85c12f6ddfd802612a9583ae73b03787f562e74f9c3", + "size": 321339, + "subdir": "linux-64", + "timestamp": 1540979291738, + "version": "6.2.3" + }, + "ipyparallel-6.2.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1b4e0ad6aec49f3baa12fed8aa169ca9", + "name": "ipyparallel", + "sha256": "c0c13b5315cac565565e3c38ea261cf386de6ecd04a0b877bf053ad2a4a18c03", + "size": 321425, + "subdir": "linux-64", + "timestamp": 1540979295449, + "version": "6.2.3" + }, + "ipyparallel-6.2.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator", + "futures", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c5c81206fb59150bc42936c276712909", + "name": "ipyparallel", + "sha256": "d0480d71f2591ccf9376cd6d97592c97876765e8e4429ac383cfb9d0297ea921", + "size": 322411, + "subdir": "linux-64", + "timestamp": 1559061922771, + "version": "6.2.4" + }, + "ipyparallel-6.2.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "20c3567fe5bc317bf27bfd2a7380c530", + "name": "ipyparallel", + "sha256": "101395f97bade408b93c4739d83229961cfffd77ed6f5a72bbef8d5bf8397db4", + "size": 328210, + "subdir": "linux-64", + "timestamp": 1558606856336, + "version": "6.2.4" + }, + "ipyparallel-6.2.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fc2faaed56b13b253894aee87eaa0d3f", + "name": "ipyparallel", + "sha256": "28ae3d17aecddff81c2129c9cd187e6084307d7579f6a7d07a385ed4d5f1f458", + "size": 329394, + "subdir": "linux-64", + "timestamp": 1559061878626, + "version": "6.2.4" + }, + "ipyparallel-6.2.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7a7b97b490b3dc9f8d2110e0be122d3a", + "name": "ipyparallel", + "sha256": "82bb9ada6641ea283399e47a17eede9f2db7043d4df317a72aad0efe6c1ac313", + "size": 320650, + "subdir": "linux-64", + "timestamp": 1574238629998, + "version": "6.2.4" + }, + "ipyparallel-6.2.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "125facff08f9e83e5ea1f618debf5694", + "name": "ipyparallel", + "sha256": "0e8c51146e30b99745c702ca71b44bebdae286dc429a344362c252805a5aa299", + "size": 327137, + "subdir": "linux-64", + "timestamp": 1587604293282, + "version": "6.2.5" + }, + "ipyparallel-6.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fd61f07690553612d9869a487a990f80", + "name": "ipyparallel", + "sha256": "6e46db273e3a2ae220333a3998e3cb849c31ef9dc3691a754ec959397681f241", + "size": 325876, + "subdir": "linux-64", + "timestamp": 1640813536590, + "version": "6.3.0" + }, + "ipyparallel-6.3.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "54faccafdbed25091690f7818e440c1b", + "name": "ipyparallel", + "sha256": "3fa2d21e0f5b38dd5e5008cd250df7e63e1b9de8133710666f476694a0ebaf8d", + "size": 431718, + "subdir": "linux-64", + "timestamp": 1676852906083, + "version": "6.3.0" + }, + "ipyparallel-6.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b9fd68fffa4735db0951c8824ed1fb05", + "name": "ipyparallel", + "sha256": "b42436c6caba8b8972ee2ea85e40eb1a68d37b40024927d3bbae54caf36abb5a", + "size": 329027, + "subdir": "linux-64", + "timestamp": 1593440631905, + "version": "6.3.0" + }, + "ipyparallel-6.3.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f78b059ac29c2778f4f0b646546f9c9", + "name": "ipyparallel", + "sha256": "9f3298b84a2159f125eb761b234c85fe3fc17caef774f1cda12848c28265fef3", + "size": 331603, + "subdir": "linux-64", + "timestamp": 1613482868716, + "version": "6.3.0" + }, + "ipyparallel-6.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "89ac1b763027f996221a3b68fb0a8349", + "name": "ipyparallel", + "sha256": "881b9d76fd2bd9df680e9c1d6ff6f34c99241875dda9d411ebbd5ec9d8dc1dea", + "size": 329282, + "subdir": "linux-64", + "timestamp": 1593440631932, + "version": "6.3.0" + }, + "ipyparallel-6.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c738d5d111b3e2958068ba13f3e33f72", + "name": "ipyparallel", + "sha256": "54d8efb13d6e82ce98d3948d47a2e0300d513625b316412dd84c818b1040762e", + "size": 328884, + "subdir": "linux-64", + "timestamp": 1613482859694, + "version": "6.3.0" + }, + "ipyparallel-6.3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "533dc0f90ca3ee573bfa8475121fa7aa", + "name": "ipyparallel", + "sha256": "34f76ad2c8ff63f220d6bf723ea3f1f05478085564bda0c2a4ab2187c0096912", + "size": 328081, + "subdir": "linux-64", + "timestamp": 1593440631905, + "version": "6.3.0" + }, + "ipyparallel-6.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e43860c8899a474d92791e6d50888a4a", + "name": "ipyparallel", + "sha256": "69ceb83e81928896d719025b4132f43627806a89e7945934bac0b88f9bace15f", + "size": 329527, + "subdir": "linux-64", + "timestamp": 1613482863072, + "version": "6.3.0" + }, + "ipyparallel-6.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4af84dd9e10d9f777af1ddd0a3b064b1", + "name": "ipyparallel", + "sha256": "a6802da715495ca14be0ad88053032d8f602ab0e52f9d341e0ceddeee9193a93", + "size": 329456, + "subdir": "linux-64", + "timestamp": 1613482240946, + "version": "6.3.0" + }, + "ipyparallel-8.4.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "entrypoints", + "ipykernel >=4.4", + "ipython >=4", + "jupyter_client", + "psutil", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.1", + "pyzmq >=18", + "tornado >=5.1", + "tqdm", + "traitlets >=4.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cd84c5113bd52b69be219c8fd0dc755a", + "name": "ipyparallel", + "sha256": "c111ef7db3a42a8a1f312a7b718a9b9d3ae3e82b60645be19a5f19b0daf0a9ad", + "size": 448053, + "subdir": "linux-64", + "timestamp": 1677879768000, + "version": "8.4.1" + }, + "ipyparallel-8.4.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "entrypoints", + "ipykernel >=4.4", + "ipython >=4", + "jupyter_client", + "psutil", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.1", + "pyzmq >=18", + "tornado >=5.1", + "tqdm", + "traitlets >=4.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8816ed91ec98b61f10af47f1b65fb608", + "name": "ipyparallel", + "sha256": "3cff5ae952cdd707890df3824fc3ec31fe43ae4272ec2675ab03d62e5ddabaac", + "size": 596458, + "subdir": "linux-64", + "timestamp": 1677867596417, + "version": "8.4.1" + }, + "ipyparallel-8.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "entrypoints", + "ipykernel >=4.4", + "ipython >=4", + "jupyter_client", + "psutil", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyzmq >=18", + "tornado >=5.1", + "tqdm", + "traitlets >=4.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f8647a0b94574fa17168b146a45a6bfd", + "name": "ipyparallel", + "sha256": "4feb8bff6178efc985f2a5b9d114f769cd19dfb9cb88b15e8b7f06b22e6455a4", + "size": 442811, + "subdir": "linux-64", + "timestamp": 1677879697626, + "version": "8.4.1" + }, + "ipyparallel-8.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "entrypoints", + "ipykernel >=4.4", + "ipython >=4", + "jupyter_client", + "psutil", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "pyzmq >=18", + "tornado >=5.1", + "tqdm", + "traitlets >=4.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "536cb103437935e7f1cfc0fdf2296848", + "name": "ipyparallel", + "sha256": "1e79927a5d9d55a6d7919ed6d7cd975b155c5c0ac86def274583fc93327d8fa9", + "size": 443338, + "subdir": "linux-64", + "timestamp": 1677879624343, + "version": "8.4.1" + }, + "ipython-5.4.1-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "backports.shutil_get_terminal_size", + "decorator", + "pathlib2", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=2.7,<2.8.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "fa6919da61372d894f6f0ab52f1dcbdb", + "name": "ipython", + "sha256": "48842b039cc6917b7d341d29e7ffff519d35ed8dec2747ca0afcadf9b7108366", + "size": 1038651, + "subdir": "linux-64", + "timestamp": 1516650353919, + "version": "5.4.1" + }, + "ipython-5.4.1-py27h36c99b6_1.tar.bz2": { + "build": "py27h36c99b6_1", + "build_number": 1, + "depends": [ + "backports.shutil_get_terminal_size", + "decorator", + "pathlib2", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=2.7,<2.8.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "242274e61d2e7022aeb285cee0ae17bc", + "name": "ipython", + "sha256": "0f9ad38f99805ced781661e390af2059ecfc86ac099497b79713184f3a5d0785", + "size": 1040639, + "subdir": "linux-64", + "timestamp": 1505690417052, + "version": "5.4.1" + }, + "ipython-5.4.1-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "decorator", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "9c2e70e876f8acc25e385b1300b9ae2a", + "name": "ipython", + "sha256": "39f3e9b29ff630835afdc52784ed13bec352d8c7a042a0f00b0b54438144aafd", + "size": 1056014, + "subdir": "linux-64", + "timestamp": 1516650397213, + "version": "5.4.1" + }, + "ipython-5.4.1-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "decorator", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "beaf0d69c3e5c47fc08ad3b286eedcdf", + "name": "ipython", + "sha256": "c8840c768f416bf8df3b30652b6e478957d8741b740816f3e42965b1cfd5e5c0", + "size": 1048851, + "subdir": "linux-64", + "timestamp": 1516650399834, + "version": "5.4.1" + }, + "ipython-5.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.shutil_get_terminal_size", + "decorator", + "pathlib2", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=2.7,<2.8.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "9b4062ef55ba84d78b237051e181e15b", + "name": "ipython", + "sha256": "be776ebcde64cb5ae492b93db741fa854000d889b0f0cf09147b84eb740db67f", + "size": 1043080, + "subdir": "linux-64", + "timestamp": 1522686124984, + "version": "5.5.0" + }, + "ipython-5.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "73b3137bcbd4160fb33ed14a235bf201", + "name": "ipython", + "sha256": "b3ffed16c06cde8d87ccf8f2ebce6c1531c2ebbc472cf5d6d871e1fa0010bd66", + "size": 1057189, + "subdir": "linux-64", + "timestamp": 1522686147501, + "version": "5.5.0" + }, + "ipython-5.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "cebf0b1609621bad84d08e32bf11bea1", + "name": "ipython", + "sha256": "33e43c45185b42d944afff64602d29b0c4d76054a5726c24e135feaf1afcee83", + "size": 1051254, + "subdir": "linux-64", + "timestamp": 1522686050018, + "version": "5.5.0" + }, + "ipython-5.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.shutil_get_terminal_size", + "decorator", + "pathlib2", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=2.7,<2.8.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "be2fa6ea333d7e459fa2d194d66d4400", + "name": "ipython", + "sha256": "183d9a646774da127d76d57185943c3bff0fc86407f357bbaaff0ec8514a1659", + "size": 1044104, + "subdir": "linux-64", + "timestamp": 1522690259211, + "version": "5.6.0" + }, + "ipython-5.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "399ce22b24d4bc6b5189f0b64805ff4d", + "name": "ipython", + "sha256": "d815cc143135ed07cd0c8f39378cb6751dc39adbf55073ad380b2a9f1b4b775b", + "size": 1058760, + "subdir": "linux-64", + "timestamp": 1522690360749, + "version": "5.6.0" + }, + "ipython-5.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "d1266ab98372604308b1e01b28b0dd58", + "name": "ipython", + "sha256": "73157335ddeb9f8d8bdb73c2a54683c6bf5ad1fb79659a669cdca5ad282ee72b", + "size": 1053368, + "subdir": "linux-64", + "timestamp": 1522690361398, + "version": "5.6.0" + }, + "ipython-5.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.shutil_get_terminal_size", + "decorator", + "pathlib2", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=2.7,<2.8.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "3b59c8040d96076a85ac04f1c78fca93", + "name": "ipython", + "sha256": "ea0236ae5108736e7a3ff8d06c3244f49d98b4748a8eb25b6d853df32abda086", + "size": 1057056, + "subdir": "linux-64", + "timestamp": 1526050673300, + "version": "5.7.0" + }, + "ipython-5.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.shutil_get_terminal_size", + "decorator", + "pathlib2", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=2.7,<2.8.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "3f566c5cebeb7be8be93aadfe893ac20", + "name": "ipython", + "sha256": "f83066d4d5c9e1044b19bc6b182195e14d03db19399dcf63c7a2529fbe990878", + "size": 1058195, + "subdir": "linux-64", + "timestamp": 1532967271125, + "version": "5.8.0" + }, + "ipython-5.8.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "16e5256afba6771035a06bf5aeb39343", + "name": "ipython", + "sha256": "5bcc5e80e439a4e6b21b161fed129b18d76d2ce6a44c826a1516b4a4f3c051e3", + "size": 1073699, + "subdir": "linux-64", + "timestamp": 1532967246834, + "version": "5.8.0" + }, + "ipython-5.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "27635b09fe636a42a01a0d8b28e639b9", + "name": "ipython", + "sha256": "cc56a43aca71c608793676ccf08fdfa0d24a950d8fd06ae21b99f8e8366fcc78", + "size": 1069107, + "subdir": "linux-64", + "timestamp": 1532967193884, + "version": "5.8.0" + }, + "ipython-5.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "70a19d1bf626d14b6a1457b99a00bd62", + "name": "ipython", + "sha256": "15569528d767c0abf61f7058386c213d5e15efd432c3673cc1bfa38242590659", + "size": 1068137, + "subdir": "linux-64", + "timestamp": 1532967295886, + "version": "5.8.0" + }, + "ipython-6.1.0-py35h1b71439_1.tar.bz2": { + "build": "py35h1b71439_1", + "build_number": 1, + "depends": [ + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "9f4835904a439643e734e886815a24bc", + "name": "ipython", + "sha256": "8c3ddafe06ae7363306f6d24ec5df3db9dececd6db6bba61e48a52ba8ec00d14", + "size": 1044142, + "subdir": "linux-64", + "timestamp": 1505690651442, + "version": "6.1.0" + }, + "ipython-6.1.0-py36hc72a948_1.tar.bz2": { + "build": "py36hc72a948_1", + "build_number": 1, + "depends": [ + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "01072ea6bc7887bd4b0583ce3b111bd5", + "name": "ipython", + "sha256": "f628d5b1978afed99b0f855cdde74967b2b8a68d4d17464a293383975b5f9810", + "size": 1047792, + "subdir": "linux-64", + "timestamp": 1505690685499, + "version": "6.1.0" + }, + "ipython-6.2.1-py35hd850d2a_1.tar.bz2": { + "build": "py35hd850d2a_1", + "build_number": 1, + "depends": [ + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7145cb61fe6d9eb686aa006781353d34", + "name": "ipython", + "sha256": "e4b3fe739721848424605bb6648942fd05db3608d2826a0f76930925e5b9082b", + "size": 1052804, + "subdir": "linux-64", + "timestamp": 1511288261990, + "version": "6.2.1" + }, + "ipython-6.2.1-py36h88c514a_1.tar.bz2": { + "build": "py36h88c514a_1", + "build_number": 1, + "depends": [ + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6b7d6375b94af078fbff6e31869bccb3", + "name": "ipython", + "sha256": "58ed5f4f6027e9104421039b148cee0bada6f6609e665a999b1b643ef13e023a", + "size": 1060619, + "subdir": "linux-64", + "timestamp": 1511288267019, + "version": "6.2.1" + }, + "ipython-6.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "19c7ed43d3849933bf0b4e3e30396f5b", + "name": "ipython", + "sha256": "03ac2c739bf042581810342ae8f828fae48900a21ae1e35c6258f59117c16d8b", + "size": 1057698, + "subdir": "linux-64", + "timestamp": 1522693081451, + "version": "6.3.0" + }, + "ipython-6.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2bbabb29fc4bbe97edb146db47011b84", + "name": "ipython", + "sha256": "9fea9ac7c10ff6f372d5eef0b91f06e0c409136f5aeba57cef3af9f1b45dbf0f", + "size": 1064966, + "subdir": "linux-64", + "timestamp": 1522693112517, + "version": "6.3.0" + }, + "ipython-6.3.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ae1e437c29cf679761843b87b1b908d2", + "name": "ipython", + "sha256": "ba6061c2f7ab172f34aaba3d847af60ea482b98d100c2d442ca5965ff2211734", + "size": 1058015, + "subdir": "linux-64", + "timestamp": 1523021923356, + "version": "6.3.1" + }, + "ipython-6.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "761c63f78c573d8b6359388b4be2e4b8", + "name": "ipython", + "sha256": "4cec55d8abec33739a388092e7ffba37081118c9e6eeb9380ee51448c041dc8d", + "size": 1065120, + "subdir": "linux-64", + "timestamp": 1523021917817, + "version": "6.3.1" + }, + "ipython-6.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b9651d2c6fd814ac21f1f113b7bb9765", + "name": "ipython", + "sha256": "d67a5866e14c6926b920da701c0a7a306925dba5d9fa56b95f4e31fb7d110695", + "size": 1072689, + "subdir": "linux-64", + "timestamp": 1526048601663, + "version": "6.4.0" + }, + "ipython-6.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "98d5bdb5d694d31a56c0686ac920da65", + "name": "ipython", + "sha256": "8d3955bac2d572baccb8181ff0e18d42604ef0821df6125ef08f6dec7c1cdaaf", + "size": 1078386, + "subdir": "linux-64", + "timestamp": 1526048575813, + "version": "6.4.0" + }, + "ipython-6.4.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d2e0d2cf786a64185fc1097fe435cf16", + "name": "ipython", + "sha256": "39c37ab38d7c0926c97447da8d63db82fb2dd6b477c7a70298eb5479f431b799", + "size": 1077910, + "subdir": "linux-64", + "timestamp": 1530733978622, + "version": "6.4.0" + }, + "ipython-6.4.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7723bedf8d08e1f3b2aba4cb19c60738", + "name": "ipython", + "sha256": "df330653a4148e984294499726421911b98c55379ace99d580befae61c7f9010", + "size": 1074347, + "subdir": "linux-64", + "timestamp": 1530734022931, + "version": "6.4.0" + }, + "ipython-6.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b66f85dd33e19cad6b188ca1f332884d", + "name": "ipython", + "sha256": "861803f01c0039840c3c674e7892d7cc2b3be826723026bff1b673d058d262ce", + "size": 1072965, + "subdir": "linux-64", + "timestamp": 1532964115048, + "version": "6.5.0" + }, + "ipython-6.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "98bd12198cbbc9cd533e854757b6d118", + "name": "ipython", + "sha256": "6d26ed02316089a17b093b9d6e539af41f24f81405e15b96e052b44c43ceeeec", + "size": 1078408, + "subdir": "linux-64", + "timestamp": 1532964056811, + "version": "6.5.0" + }, + "ipython-6.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c11eb8bc8ce25f7a5ffe1d8fc00d414b", + "name": "ipython", + "sha256": "7eee21deef098e9e0adfb05a7118a64167ae875bb3b18428ae6659c0f5eee860", + "size": 1076641, + "subdir": "linux-64", + "timestamp": 1532964096121, + "version": "6.5.0" + }, + "ipython-7.0.1-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e43f5aa4471e612b2d7fc96859f57604", + "name": "ipython", + "sha256": "b9004ef8299b8a9894a049b4383b12af7ef93f45ce7dd60ee02e72d1336b9335", + "size": 1088468, + "subdir": "linux-64", + "timestamp": 1538670848971, + "version": "7.0.1" + }, + "ipython-7.0.1-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a8e30ea3ba1b86a526840138e523594a", + "name": "ipython", + "sha256": "0c4f1f28646e0db5a768342747747526ab06ce5a733cd889150cbd84098b4792", + "size": 1085511, + "subdir": "linux-64", + "timestamp": 1538670818476, + "version": "7.0.1" + }, + "ipython-7.1.1-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5239062fc8dd1bf5e0cf3f9b612e3772", + "name": "ipython", + "sha256": "f46e5adc38cc6604ad2912b2590a36be0f78c09335df95c6c297c5865016a915", + "size": 1135227, + "subdir": "linux-64", + "timestamp": 1541004636457, + "version": "7.1.1" + }, + "ipython-7.1.1-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa53091f3be5c927e0d70e3f4e7e3b55", + "name": "ipython", + "sha256": "1cf313d936cea3d4ad6b9ac9f459c920f1b336f0b057981a8775948464c0f628", + "size": 1133405, + "subdir": "linux-64", + "timestamp": 1541004679359, + "version": "7.1.1" + }, + "ipython-7.10.1-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8daee99e846c66f42bbe06fd623168ab", + "name": "ipython", + "sha256": "f88d1599b2321619d0df83f5f8e91aa13980ad074799ee49beebdeef6ee4cb6e", + "size": 1168470, + "subdir": "linux-64", + "timestamp": 1575478621608, + "version": "7.10.1" + }, + "ipython-7.10.1-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "17a51531a9dd483a9d111d7627b8a9da", + "name": "ipython", + "sha256": "9c055f276784f0491d5453b458783f7b3c6c8af8bcad75143e464023c2f4e2d7", + "size": 1167484, + "subdir": "linux-64", + "timestamp": 1575478625028, + "version": "7.10.1" + }, + "ipython-7.10.1-py38h39e3cac_0.tar.bz2": { + "build": "py38h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.8,<3.9.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "31cd07dd63e1302aacdc5502218723ea", + "name": "ipython", + "sha256": "11df4e23e0c29b6493ba0cd2fa8992c31e83a6a23d61c71922bbb7e5dc4705c5", + "size": 1170668, + "subdir": "linux-64", + "timestamp": 1575484718359, + "version": "7.10.1" + }, + "ipython-7.10.2-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a58e1537b011eea949c1adb9b6298231", + "name": "ipython", + "sha256": "e378424ede7f58942f0653abd7736ea659db6816a3f92816eb1542c3622c6a69", + "size": 1170247, + "subdir": "linux-64", + "timestamp": 1576511992396, + "version": "7.10.2" + }, + "ipython-7.10.2-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bcde6368295e495268bac11838d8edba", + "name": "ipython", + "sha256": "0ac0df35ed3f53ffc5e2b204433d95097bb5fbf516e2ce64eb5636ac1798a2d3", + "size": 1168946, + "subdir": "linux-64", + "timestamp": 1576511944100, + "version": "7.10.2" + }, + "ipython-7.10.2-py38h39e3cac_0.tar.bz2": { + "build": "py38h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.8,<3.9.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b70fbb7f9475e56b44d0239a031a03b5", + "name": "ipython", + "sha256": "c7acd922c01d61af0d4e5c53e159e3f62e4e294be181d7b29580027744b4db2d", + "size": 1169212, + "subdir": "linux-64", + "timestamp": 1576511990405, + "version": "7.10.2" + }, + "ipython-7.11.1-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e4d0ffa80bea36fd9e86c24187a23f15", + "name": "ipython", + "sha256": "8067d17a543e69e2bdd05272a4233e09764d121ce31a5c499d549a24c4d87c88", + "size": 1170490, + "subdir": "linux-64", + "timestamp": 1578325685352, + "version": "7.11.1" + }, + "ipython-7.11.1-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b32e16af739fe02f592ee3b5ed598e86", + "name": "ipython", + "sha256": "58576706d1ab28340b22dcdcf6d7ad0f115850011e05dea2a2c6634de179cc29", + "size": 1170123, + "subdir": "linux-64", + "timestamp": 1578325572628, + "version": "7.11.1" + }, + "ipython-7.11.1-py38h39e3cac_0.tar.bz2": { + "build": "py38h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.8,<3.9.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ec9f931cfd33585917a6033ca0f96346", + "name": "ipython", + "sha256": "5601500533fc45a387a75885c2cd6a57346995a12859c627eafcd46962b08b30", + "size": 1165183, + "subdir": "linux-64", + "timestamp": 1578325638547, + "version": "7.11.1" + }, + "ipython-7.12.0-py36h5ca1d4c_0.tar.bz2": { + "build": "py36h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.6,<3.7.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a03630f61c61e511f83361da727723ce", + "name": "ipython", + "sha256": "fb936b4b4292250a1d96cc73c0e1495ba566ae5afba9e1703c037cf1a7244721", + "size": 1168520, + "subdir": "linux-64", + "timestamp": 1580837277994, + "version": "7.12.0" + }, + "ipython-7.12.0-py37h5ca1d4c_0.tar.bz2": { + "build": "py37h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b45b55c530db3f242e28de7cf65a7283", + "name": "ipython", + "sha256": "7327e3733e3da72f93d158b451b491e41bea9380052b19a2aa823f29d7164009", + "size": 1168119, + "subdir": "linux-64", + "timestamp": 1580837257262, + "version": "7.12.0" + }, + "ipython-7.12.0-py38h5ca1d4c_0.tar.bz2": { + "build": "py38h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f504ed00607f3fbebe4b258195e98560", + "name": "ipython", + "sha256": "c2ea207569bc417e85003ee971931d0fdaf60c624792f49974ba1209d3b516fd", + "size": 1165136, + "subdir": "linux-64", + "timestamp": 1580837278274, + "version": "7.12.0" + }, + "ipython-7.13.0-py36h5ca1d4c_0.tar.bz2": { + "build": "py36h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.6,<3.7.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "641fed2a95e4732d58eba8522099867e", + "name": "ipython", + "sha256": "aa85976671bd96e983892ac57747f42d09b728c25d8fe2eb7c6a4c2e120b8482", + "size": 1167865, + "subdir": "linux-64", + "timestamp": 1584021361904, + "version": "7.13.0" + }, + "ipython-7.13.0-py37h5ca1d4c_0.tar.bz2": { + "build": "py37h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "30840c82232dbf1c1c38582ff635980e", + "name": "ipython", + "sha256": "cf3c42ac3b6b9b07bcdb07166c1200a435e9a7f56d7024e2cc35cec4b461b177", + "size": 1169424, + "subdir": "linux-64", + "timestamp": 1584021296829, + "version": "7.13.0" + }, + "ipython-7.13.0-py38h5ca1d4c_0.tar.bz2": { + "build": "py38h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7dea151e794df1c6dc2f2e99d7ad6c72", + "name": "ipython", + "sha256": "5a3e50b83aaad835699898b6b064a42b9bfe4e27934b52ce4559943cab52924a", + "size": 1171805, + "subdir": "linux-64", + "timestamp": 1584021348429, + "version": "7.13.0" + }, + "ipython-7.15.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2c7b2511598edd80d550a791c4eaf4d5", + "name": "ipython", + "sha256": "b0134578648c807ad8108492ec390c43f1fed06faccc398452c52c281a2596e2", + "size": 1176756, + "subdir": "linux-64", + "timestamp": 1592348421007, + "version": "7.15.0" + }, + "ipython-7.15.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f9735df3bf64281be7f2b6234fc9c5c0", + "name": "ipython", + "sha256": "45e3aa1b6ced6b95ad5bb972a8099c425c6f1a3d7cb72016bfe6e406b2586d06", + "size": 1174750, + "subdir": "linux-64", + "timestamp": 1592348440742, + "version": "7.15.0" + }, + "ipython-7.15.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2b810f67182f52650513389b4f098072", + "name": "ipython", + "sha256": "d3e21f72746c6349d763eaad22c0b34be71d2d6b4f7e541c835d7e440093d4ff", + "size": 1179195, + "subdir": "linux-64", + "timestamp": 1592348420828, + "version": "7.15.0" + }, + "ipython-7.16.1-py36h5ca1d4c_0.tar.bz2": { + "build": "py36h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5fe5fe1520da221b8064f0d6b732c6c0", + "name": "ipython", + "sha256": "93d65bbf65708be8c21e500302f2323b27eff6b7477d5391b39d4397ad6a20b7", + "size": 1179158, + "subdir": "linux-64", + "timestamp": 1593447403316, + "version": "7.16.1" + }, + "ipython-7.16.1-py37h5ca1d4c_0.tar.bz2": { + "build": "py37h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7cfa6244d615935b40507a4ec6a34140", + "name": "ipython", + "sha256": "122a873ffcff205f210f6e90be4b605851a9ee17dbd983f50a11747e4fd5d8f9", + "size": 1176948, + "subdir": "linux-64", + "timestamp": 1593447400040, + "version": "7.16.1" + }, + "ipython-7.16.1-py38h5ca1d4c_0.tar.bz2": { + "build": "py38h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ecd57f22a6fb4d7f86d3aeff59b4f1d", + "name": "ipython", + "sha256": "9012f3d6d29b259782d8e9c12090383f91d559202f3802d34b0fc689a62f0ca3", + "size": 1176664, + "subdir": "linux-64", + "timestamp": 1593447407997, + "version": "7.16.1" + }, + "ipython-7.17.0-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "280d6a99f1f1091b8ce99479aab82d38", + "name": "ipython", + "sha256": "d7f7bd1db8fe966a8ba576aa606a9aad211a4e0a698cd5ec68e462fede4996db", + "size": 1169588, + "subdir": "linux-64", + "timestamp": 1596868550866, + "version": "7.17.0" + }, + "ipython-7.17.0-py37h5ca1d4c_0.tar.bz2": { + "build": "py37h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "54f54ac1dc4d87a5364286bbdd832831", + "name": "ipython", + "sha256": "b02bb098e076aafdfc6f3cece0673ce2ac14c1f89e7c5ccb4bd9202e6bce4ed1", + "size": 1183531, + "subdir": "linux-64", + "timestamp": 1598371611907, + "version": "7.17.0" + }, + "ipython-7.17.0-py38h5ca1d4c_0.tar.bz2": { + "build": "py38h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ccfc2d165987a766fbd69a2e1c73262e", + "name": "ipython", + "sha256": "b590cd791384ed383c86ab9e248fa8f0500630612b0e517e807c2c7afaed4470", + "size": 1185694, + "subdir": "linux-64", + "timestamp": 1598371614238, + "version": "7.17.0" + }, + "ipython-7.18.1-py37h5ca1d4c_0.tar.bz2": { + "build": "py37h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b390b902eb01077f602c5f4d7786725b", + "name": "ipython", + "sha256": "9855c699316c1c45d4b72e053f5d1f4b0b90b3711dc820277c98a26b076df857", + "size": 1182601, + "subdir": "linux-64", + "timestamp": 1598883876782, + "version": "7.18.1" + }, + "ipython-7.18.1-py38h5ca1d4c_0.tar.bz2": { + "build": "py38h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "58c19b717c97b6d95fd3a76564f979ff", + "name": "ipython", + "sha256": "cc58adb44a18f7e6f6eff98835e28e291337176a62fd02c86e6456a0feee63bb", + "size": 1184110, + "subdir": "linux-64", + "timestamp": 1598883859417, + "version": "7.18.1" + }, + "ipython-7.19.0-py37hb070fc8_0.tar.bz2": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "186ca9652fa17d548751d1cddf024749", + "name": "ipython", + "sha256": "7966b4a57d696eba784857658a094abd14c84ef6132efa05fd5b25ebbdd48d42", + "size": 1168977, + "subdir": "linux-64", + "timestamp": 1604101276114, + "version": "7.19.0" + }, + "ipython-7.19.0-py37hb070fc8_1.tar.bz2": { + "build": "py37hb070fc8_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "973302c7ed8199de96ba2f80ee0276a1", + "name": "ipython", + "sha256": "1d3be2682285da036d1afb2ac3e9a729fe461cbb108242a70d5c3ac7bbf4a19f", + "size": 1184840, + "subdir": "linux-64", + "timestamp": 1610725452752, + "version": "7.19.0" + }, + "ipython-7.19.0-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f2ede0992f8a6b3d52e7989c382d343a", + "name": "ipython", + "sha256": "a97f4e5fa10bef99851dd435afd2417d76a1e6c6390fc831068dd4164968da50", + "size": 1170692, + "subdir": "linux-64", + "timestamp": 1604101235603, + "version": "7.19.0" + }, + "ipython-7.19.0-py38hb070fc8_1.tar.bz2": { + "build": "py38hb070fc8_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f357a55f5120ff736cdccbcf8a67393b", + "name": "ipython", + "sha256": "da56d65ce73cb1ee4bc348ee0c7933048b9e424c4ccee6346a5f63b0c2d5b20e", + "size": 1183603, + "subdir": "linux-64", + "timestamp": 1610724841120, + "version": "7.19.0" + }, + "ipython-7.19.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0def1e85dc77bdfbba56f7ff16a05133", + "name": "ipython", + "sha256": "ff0eab31ac4549348a0c6a59c527c3126aa5c60760e3e0553b7178afe0b18334", + "size": 1188116, + "subdir": "linux-64", + "timestamp": 1607355389749, + "version": "7.19.0" + }, + "ipython-7.19.0-py39hb070fc8_1.tar.bz2": { + "build": "py39hb070fc8_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "86e45a63efb9a78a9e1488f8e2a550fe", + "name": "ipython", + "sha256": "a019afe9f8589d17aefc2dc6e00cce93d1ef08553a9605264ceb505eebd07110", + "size": 1186167, + "subdir": "linux-64", + "timestamp": 1610725439229, + "version": "7.19.0" + }, + "ipython-7.2.0-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7269a49ba8e35907d6fe1fc726c7aa50", + "name": "ipython", + "sha256": "06da802b75d238dad809dfca2a7b09b2c0711c47c7d93d884abf8683b63347bf", + "size": 1097265, + "subdir": "linux-64", + "timestamp": 1543586495209, + "version": "7.2.0" + }, + "ipython-7.2.0-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f084d9f11f76db127ee70746723d0c4f", + "name": "ipython", + "sha256": "cd57d8ce5c7eea53a712f5db9a30f90ebb6053ed522000796c9b168e32e8c7ec", + "size": 1096985, + "subdir": "linux-64", + "timestamp": 1543586457880, + "version": "7.2.0" + }, + "ipython-7.20.0-py37hb070fc8_0.tar.bz2": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "367e1f4b5b7d866dbe8828fac7b9fc95", + "name": "ipython", + "sha256": "3275698b11e3dfdca72faddfabdffce5403ddef6e8ec4e34a956ba8d04bdb398", + "size": 1171693, + "subdir": "linux-64", + "timestamp": 1612218596736, + "version": "7.20.0" + }, + "ipython-7.20.0-py37hb070fc8_1.tar.bz2": { + "build": "py37hb070fc8_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a5db57e7aeaea8f29bcbf6ca970f4fa", + "name": "ipython", + "sha256": "174b0edca013177cd00b0767cecdeb3d765f9c7128b117ae6ef8b6688a1ec7b2", + "size": 1167313, + "subdir": "linux-64", + "timestamp": 1612212964562, + "version": "7.20.0" + }, + "ipython-7.20.0-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3522bb5b7e75bc07ede239b8123f2313", + "name": "ipython", + "sha256": "03eca992b33210b2d0a5cb76c86ae2d730c5a67634339bb302bbc47eab7869a1", + "size": 1169114, + "subdir": "linux-64", + "timestamp": 1612218578644, + "version": "7.20.0" + }, + "ipython-7.20.0-py38hb070fc8_1.tar.bz2": { + "build": "py38hb070fc8_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "96edd4ecccfbadaf967b3c03f85225b4", + "name": "ipython", + "sha256": "355d167c17fdca654729db320e2c75a266e9cf5107616da354e8507368cfe401", + "size": 1174931, + "subdir": "linux-64", + "timestamp": 1612212966918, + "version": "7.20.0" + }, + "ipython-7.20.0-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c7852d14708947abf94ee5ec04a7430d", + "name": "ipython", + "sha256": "b0eddef661ac0d0edcf8ffc5d3cb4ed7270f46cb9fba334aa1e890a1b65ee9eb", + "size": 1175844, + "subdir": "linux-64", + "timestamp": 1612218614529, + "version": "7.20.0" + }, + "ipython-7.20.0-py39hb070fc8_1.tar.bz2": { + "build": "py39hb070fc8_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8dcccbc920999089e96b0a84f36a7748", + "name": "ipython", + "sha256": "041fc6ecbfe90d2bbf35677b02fc29ea179d2f1e5b2cd5edee3338fad4b528cb", + "size": 1172412, + "subdir": "linux-64", + "timestamp": 1612212962797, + "version": "7.20.0" + }, + "ipython-7.21.0-py37hb070fc8_0.tar.bz2": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "30c556687fb7b5f22ba7fbdf8b7108b3", + "name": "ipython", + "sha256": "8a1249fa780f3e0f22d16e1d6248a0aab499356164833a8cb0ef8f881ceda361", + "size": 1167660, + "subdir": "linux-64", + "timestamp": 1614615683465, + "version": "7.21.0" + }, + "ipython-7.21.0-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "068717ae3f7c2d2824eeda74107ae039", + "name": "ipython", + "sha256": "1e6109e0d055969144c778b8eacfe801249b83609f6f1c7aa5aa2b963aff0845", + "size": 1174616, + "subdir": "linux-64", + "timestamp": 1614615289105, + "version": "7.21.0" + }, + "ipython-7.21.0-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1a6b481965f562f663c6ff1263157b59", + "name": "ipython", + "sha256": "9672389c1588bc254b6b077407efd5b69d445c388939e8a9acfba2ee8dc29f30", + "size": 1172778, + "subdir": "linux-64", + "timestamp": 1614616498997, + "version": "7.21.0" + }, + "ipython-7.22.0-py37hb070fc8_0.tar.bz2": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5e66bc12a97f3f55acca9d75e47c1114", + "name": "ipython", + "sha256": "8e5ad22fdf10b7d7c6ef1ad8617d85a81215404800ff92f4b43fe665660bc052", + "size": 1172395, + "subdir": "linux-64", + "timestamp": 1617118475839, + "version": "7.22.0" + }, + "ipython-7.22.0-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50b67dce969839330cddaca61046de0a", + "name": "ipython", + "sha256": "65f140559cb9c8669aaa44c57e6c1d11438a68d13e1f3c9aa60913f88988e0d4", + "size": 1173654, + "subdir": "linux-64", + "timestamp": 1617120931612, + "version": "7.22.0" + }, + "ipython-7.22.0-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "361c55293717049f32f890ba710aaae3", + "name": "ipython", + "sha256": "495d2b31e80cc7958d5f980e734b98999188de25dc9a5c77c1197a1bf4dcff55", + "size": 1175726, + "subdir": "linux-64", + "timestamp": 1617120932001, + "version": "7.22.0" + }, + "ipython-7.26.0-py37hb070fc8_0.tar.bz2": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "12dd90f1fe3361672ed040ac6f8ea868", + "name": "ipython", + "sha256": "d1eb374a0de1ce791e8b18eab676e52977bdf7183fb31d551e7395bb350ff4d9", + "size": 1186806, + "subdir": "linux-64", + "timestamp": 1628235884911, + "version": "7.26.0" + }, + "ipython-7.26.0-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "815467534c7bd0f3ea650c1c3e9476b7", + "name": "ipython", + "sha256": "12b94eaf90ad731b3e475d497e5d04f9bf3cb3084de9494d0f46ddbb5e3b7778", + "size": 1184201, + "subdir": "linux-64", + "timestamp": 1628243960674, + "version": "7.26.0" + }, + "ipython-7.26.0-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2f23aeafe55b379a4b219c58cbab3f3f", + "name": "ipython", + "sha256": "3ee68d242aac85d5ec7100562a0e03cc9d099c9b1c9ee67df5e8059099c15348", + "size": 1191902, + "subdir": "linux-64", + "timestamp": 1628243954554, + "version": "7.26.0" + }, + "ipython-7.27.0-py37hb070fc8_0.tar.bz2": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "708be8cd185f15d2c1336a669fdea294", + "name": "ipython", + "sha256": "47816a4353e6d0d2ecd494f15098b1e9b3fe4e092b4382a8c234b8c0c171ba01", + "size": 1190563, + "subdir": "linux-64", + "timestamp": 1632141092862, + "version": "7.27.0" + }, + "ipython-7.27.0-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1b5e1e20a86cdea1a93c22f7a5ee4125", + "name": "ipython", + "sha256": "c7949fea26ee80005d096c1356aeef7615556b07977461548a9c8d671eff6f12", + "size": 1188050, + "subdir": "linux-64", + "timestamp": 1632141430069, + "version": "7.27.0" + }, + "ipython-7.27.0-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ea0a88050282cd7bb20fdafcccec5be4", + "name": "ipython", + "sha256": "c63eea4c5bb9b7600499aaf30e5ecb2d950c49189851054c51054851ac44d223", + "size": 1192984, + "subdir": "linux-64", + "timestamp": 1632131381979, + "version": "7.27.0" + }, + "ipython-7.29.0-py310h2f386ee_0.tar.bz2": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.10,<3.11.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f0a6897018bbc0e91a2efa8033e83754", + "name": "ipython", + "sha256": "3a08518b1f318c8c312d3da3bdf7b278886b85661df515594b61600efc88b7fd", + "size": 1198043, + "subdir": "linux-64", + "timestamp": 1640809461659, + "version": "7.29.0" + }, + "ipython-7.29.0-py37hb070fc8_0.tar.bz2": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b396ab451c3639f25eba97eb68e52cbe", + "name": "ipython", + "sha256": "0abdee589c383ddbae0c37b731fb790f3201e551a0ee90f5721a24d73737efdc", + "size": 1195941, + "subdir": "linux-64", + "timestamp": 1635944212908, + "version": "7.29.0" + }, + "ipython-7.29.0-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fb3c6c1be8c1def8339e1426a6b7a7d3", + "name": "ipython", + "sha256": "cb274a60ea5d4e9c8730c325ac5b6ed1b5de13a0bc53cb7afa2592f1e6d0c82f", + "size": 1197033, + "subdir": "linux-64", + "timestamp": 1635944038316, + "version": "7.29.0" + }, + "ipython-7.29.0-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "96a3d0636d772cefdd72aa30a0f4efdc", + "name": "ipython", + "sha256": "c205e0636fbc60ba061d6c0d76da06c37e20da83e9c73e407a92cba70802d624", + "size": 1196495, + "subdir": "linux-64", + "timestamp": 1635944205923, + "version": "7.29.0" + }, + "ipython-7.3.0-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7528c17d61110511020589e58ffa4108", + "name": "ipython", + "sha256": "40001c9fce8c5fbbe717f72da4eb07694160584203a61281e9622e58c42c781d", + "size": 1150106, + "subdir": "linux-64", + "timestamp": 1551128451092, + "version": "7.3.0" + }, + "ipython-7.3.0-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4b20ad0fe2667f0e27e6a2e8b3d0f122", + "name": "ipython", + "sha256": "0dd3403caa0e3b490f0fbe697917fdbabebde710bb724876e291047b12345977", + "size": 1149298, + "subdir": "linux-64", + "timestamp": 1551128448776, + "version": "7.3.0" + }, + "ipython-7.31.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.10,<3.11.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e45542317229241ea79e0b5383557fff", + "name": "ipython", + "sha256": "61d37c4f3f67a9a4686ca7a165ab2a265c9ca7035c4daeb820da50aa3b138bb4", + "size": 1201654, + "subdir": "linux-64", + "timestamp": 1659530038998, + "version": "7.31.1" + }, + "ipython-7.31.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a92130338c7753502ef4a4d78a18425f", + "name": "ipython", + "sha256": "ea37cde06435f6e10abe241d90c352f35384f000d9e87ca2a00c29d43e01b93c", + "size": 1198468, + "subdir": "linux-64", + "timestamp": 1643818185716, + "version": "7.31.1" + }, + "ipython-7.31.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e8710b2c1dcd5965da47eb9d62e60124", + "name": "ipython", + "sha256": "cb26560fd99124098ede88dcc866043bc6b52782f58d7b4b2986502ca6c06a9d", + "size": 1181384, + "subdir": "linux-64", + "timestamp": 1659530195402, + "version": "7.31.1" + }, + "ipython-7.31.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2347089c83357da4778645c847f32092", + "name": "ipython", + "sha256": "f3a1a286de4a8d3f91a2193f63e9b6883cccff5273942e68869b71ccce278279", + "size": 1201614, + "subdir": "linux-64", + "timestamp": 1643818185749, + "version": "7.31.1" + }, + "ipython-7.31.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2c7b7432a2582479178dcdf4958677a3", + "name": "ipython", + "sha256": "b03511e14d1de6c38019c08d0fa351cdd72a501619d0f958423170440645f31c", + "size": 1183252, + "subdir": "linux-64", + "timestamp": 1659530314001, + "version": "7.31.1" + }, + "ipython-7.31.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "090b5310e9d9917f2932ab37e7c29538", + "name": "ipython", + "sha256": "84641c96351e427f66ed1fde13e112b20a577a7a0c6a9588f6f61ff8c5dc6c96", + "size": 1201576, + "subdir": "linux-64", + "timestamp": 1643818181622, + "version": "7.31.1" + }, + "ipython-7.31.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9660cb769662ae9b0f3c21c975dc156f", + "name": "ipython", + "sha256": "3a9c7396a2a03ab3d3a214d2dc509bd099b54e8c487a01fd46699c93e5d682ba", + "size": 1186166, + "subdir": "linux-64", + "timestamp": 1659529902720, + "version": "7.31.1" + }, + "ipython-7.4.0-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5fc6ba2c639d262db25efae91abbbb61", + "name": "ipython", + "sha256": "e23eeeaa82f77b41025a779b2619bcca33dec6bf345c7145c121b6f37dc81e4a", + "size": 1153704, + "subdir": "linux-64", + "timestamp": 1553524015818, + "version": "7.4.0" + }, + "ipython-7.4.0-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b53b4252bdd32e3bb303a020fcef341c", + "name": "ipython", + "sha256": "6968d56b661c38a4d17088a04e5202578e387c848a866e4774aa09297aa703dc", + "size": 1153303, + "subdir": "linux-64", + "timestamp": 1553523922027, + "version": "7.4.0" + }, + "ipython-7.5.0-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "75a193452ac5fa5ea8ed7bee402c3cb8", + "name": "ipython", + "sha256": "6f635a112895a0af0ee36d83f4e5491c4e6e9a7de175646b1366cc093cc717b2", + "size": 1153037, + "subdir": "linux-64", + "timestamp": 1556287378160, + "version": "7.5.0" + }, + "ipython-7.5.0-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1447aad5061f590111b428e5d6897f97", + "name": "ipython", + "sha256": "6ea82ba26bbd225e07be45324c92c2004d1bff60a72d3e263afa19c4c47c1dfa", + "size": 1152239, + "subdir": "linux-64", + "timestamp": 1556287301718, + "version": "7.5.0" + }, + "ipython-7.6.0-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0800047c0fc5818a164f94d9bba5a2f6", + "name": "ipython", + "sha256": "d44dc95796095150bad4057a9ae1caff1334299cbbc1d4d86375a1ddae910248", + "size": 1162058, + "subdir": "linux-64", + "timestamp": 1562004138392, + "version": "7.6.0" + }, + "ipython-7.6.0-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "73359399a9092f3837fe68e4a1871640", + "name": "ipython", + "sha256": "f70c8095f2c41950d1edca7b5fb68e0a6249ccd8cc439f2b5629e5c487dd592d", + "size": 1157830, + "subdir": "linux-64", + "timestamp": 1562004415723, + "version": "7.6.0" + }, + "ipython-7.6.1-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bfb560d680a2e5fc4ffc55e9dac8b7f0", + "name": "ipython", + "sha256": "d2873752a888ed786e92608d758451548c19e37c08be9afc8a4f24cd5dde1f48", + "size": 1161311, + "subdir": "linux-64", + "timestamp": 1562701456465, + "version": "7.6.1" + }, + "ipython-7.6.1-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "15c98952f23efac6b186b6015cf51de5", + "name": "ipython", + "sha256": "abb3808c66dc473ca2264dcf942858bcda8ad04073193eac6f346260daa9fa16", + "size": 1159332, + "subdir": "linux-64", + "timestamp": 1562701469725, + "version": "7.6.1" + }, + "ipython-7.7.0-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "17ec2b0d85eccf51c0471cec0878b701", + "name": "ipython", + "sha256": "ef4707305fc798de0d1269158e8518e2814b54d600d328676eecb7fcbfa233ec", + "size": 1162523, + "subdir": "linux-64", + "timestamp": 1564509261240, + "version": "7.7.0" + }, + "ipython-7.7.0-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bf0594a1c17ff5782a9015dde66e683f", + "name": "ipython", + "sha256": "bd692f409d2ab382ca05334521d9726488cc465d63da919ab13aa59c18c41956", + "size": 1161348, + "subdir": "linux-64", + "timestamp": 1564509520323, + "version": "7.7.0" + }, + "ipython-7.8.0-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b531da557150ded0e31cbca7c9c60936", + "name": "ipython", + "sha256": "551db1ff2f1d755cef2b35c314d1a92b52597f52ec032055036db874c4fc7b93", + "size": 1164895, + "subdir": "linux-64", + "timestamp": 1567191137752, + "version": "7.8.0" + }, + "ipython-7.8.0-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cec5026ad52b66a64df1202f23790ca5", + "name": "ipython", + "sha256": "7817c5cf634fdd0318de0590d98fd8dad8f9dcc01c2966353a106bedd7814ef0", + "size": 1160542, + "subdir": "linux-64", + "timestamp": 1567191119747, + "version": "7.8.0" + }, + "ipython-7.9.0-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d04814b6ed6d2762ea1b041cc885d95a", + "name": "ipython", + "sha256": "834e4b1a0eca4ff7067fa36fa1d600902a4d2ed518ded199d11709281a54ce0b", + "size": 1163308, + "subdir": "linux-64", + "timestamp": 1572462615818, + "version": "7.9.0" + }, + "ipython-7.9.0-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f5b43e3e28a6939038e0db479481cc4e", + "name": "ipython", + "sha256": "14764d62b539598b04c41da11d96af706b58518913b7553a89797607c1291927", + "size": 1163014, + "subdir": "linux-64", + "timestamp": 1572462603146, + "version": "7.9.0" + }, + "ipython-7.9.0-py38h39e3cac_0.tar.bz2": { + "build": "py38h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.8,<3.9.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5c938e749c689f51c6389d34f5abf71e", + "name": "ipython", + "sha256": "b372fb17df1795ea380a13b1ce394222ce8463ff1a87db9fcd333a5db8ca6f45", + "size": 1153783, + "subdir": "linux-64", + "timestamp": 1574177550400, + "version": "7.9.0" + }, + "ipython-8.1.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3732436bdb8e6f1f85026989a60917fd", + "name": "ipython", + "sha256": "ebc05a669fa47397b90d15fca50e132b2dbcfa7793a6fbb47cfa468bec8c0d6b", + "size": 1166126, + "subdir": "linux-64", + "timestamp": 1646949833716, + "version": "8.1.1" + }, + "ipython-8.1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6e3c47da3721de86312fb4ed52e48094", + "name": "ipython", + "sha256": "970f5288b0964dd5f7152bc48469b6a0a5b09195348f070212abba3d8c13d697", + "size": 1149067, + "subdir": "linux-64", + "timestamp": 1646949544519, + "version": "8.1.1" + }, + "ipython-8.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3778f0d50695389253a9be41efb610f4", + "name": "ipython", + "sha256": "91f6f5282472bc9a20cc62ee8777640773d12c3fcb55d43585fa827d60f9463c", + "size": 1149948, + "subdir": "linux-64", + "timestamp": 1646949689716, + "version": "8.1.1" + }, + "ipython-8.10.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb3dbef036133d8cb04bcab6a40d0216", + "name": "ipython", + "sha256": "21d22fe8ae22a82197f39fa524be8e2fa13e66fff6bc677a9b27adf9458e0196", + "size": 1231334, + "subdir": "linux-64", + "timestamp": 1676582497535, + "version": "8.10.0" + }, + "ipython-8.10.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0", + "pygments >=2.4.0", + "python >=3.11,<3.12.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "516331820097a2be03638b870647044c", + "name": "ipython", + "sha256": "5cad679f2c966d7d6302b3b5a88b5fa789fdee76198392f9004daa60dc6bb0a5", + "size": 1554741, + "subdir": "linux-64", + "timestamp": 1676824943533, + "version": "8.10.0" + }, + "ipython-8.10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1d508c48f8f8fe02ce1ffd0a4f2a5fb9", + "name": "ipython", + "sha256": "a5c3fc21d7f7dc7c8065bd6033ea618af4669180433045391b274b585c605c6e", + "size": 1211951, + "subdir": "linux-64", + "timestamp": 1676582385859, + "version": "8.10.0" + }, + "ipython-8.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a402ce05de95a61a46bf64fb8177b9b3", + "name": "ipython", + "sha256": "9ea2af4dbf9a46552ba0234f625ea88b24e66fa3b7ee5331e8e5e2da0ca40115", + "size": 1215231, + "subdir": "linux-64", + "timestamp": 1676582265069, + "version": "8.10.0" + }, + "ipython-8.12.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0,!=3.0.37", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "371e5476b2e918fbce4cacd5ddaf232f", + "name": "ipython", + "sha256": "5dfad34340224e623f5711d2e9b22e90aefb26799329881cf997321aacf46e3d", + "size": 1257145, + "subdir": "linux-64", + "timestamp": 1680701911266, + "version": "8.12.0" + }, + "ipython-8.12.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0,!=3.0.37", + "pygments >=2.4.0", + "python >=3.11,<3.12.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20cc36a96c9c295fe0cfdc87fd7ca402", + "name": "ipython", + "sha256": "82bf1fe905810a4a9a11ecfae1fd9fad031a403a9c3508775da03d52e79ed2ca", + "size": 1585090, + "subdir": "linux-64", + "timestamp": 1680702276698, + "version": "8.12.0" + }, + "ipython-8.12.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0,!=3.0.37", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "stack_data", + "traitlets >=5", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c2fd3af476b91905b41d1798a4877f6b", + "name": "ipython", + "sha256": "815887e1832da26fa69e804d543d4bf68e1cfb1d2eb114fdfb30cd7a37f1014d", + "size": 1238614, + "subdir": "linux-64", + "timestamp": 1680702037294, + "version": "8.12.0" + }, + "ipython-8.12.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0,!=3.0.37", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "stack_data", + "traitlets >=5", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f4a90105a5f414e782bf5ed9e13aaeea", + "name": "ipython", + "sha256": "b384d96b3cdf6852dc159a18c45b2daac147d91130485d537a90465266f06310", + "size": 1239575, + "subdir": "linux-64", + "timestamp": 1680702156755, + "version": "8.12.0" + }, + "ipython-8.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b97ef10716b72adc4f8c9885a2aa65e3", + "name": "ipython", + "sha256": "6454aa605346eb9864626037de438617f0df9a0c866a58678d62f32b95164933", + "size": 1163952, + "subdir": "linux-64", + "timestamp": 1649079009751, + "version": "8.2.0" + }, + "ipython-8.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d04c67832dea43f6a7645bf2b759b3d8", + "name": "ipython", + "sha256": "0dc166bde84b710d9178c154422d7c806f8d144816a373ace25d8304735e246e", + "size": 1146641, + "subdir": "linux-64", + "timestamp": 1649079154888, + "version": "8.2.0" + }, + "ipython-8.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bfc33b26dc0ef94a2afe90acbe42e8b9", + "name": "ipython", + "sha256": "894822969c8464b1663cae479be871f042a8263ac269877cbd49666d38a625d8", + "size": 1148748, + "subdir": "linux-64", + "timestamp": 1649079285722, + "version": "8.2.0" + }, + "ipython-8.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "662b21521c561bf6decefa89e0032141", + "name": "ipython", + "sha256": "34a478d7f11d17f5b6a6497eabe10bbf56698aefcf92517acccd483f10d6c345", + "size": 1167677, + "subdir": "linux-64", + "timestamp": 1651600469933, + "version": "8.3.0" + }, + "ipython-8.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cef11390df6955cf91992093cfc930fb", + "name": "ipython", + "sha256": "f721032aa5587105049caebb1bf6e386ed4d4a266d9545e488076d7d7c7f7d49", + "size": 1150744, + "subdir": "linux-64", + "timestamp": 1651600182146, + "version": "8.3.0" + }, + "ipython-8.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "267a7b82de1fc25ecff98549157d3ff9", + "name": "ipython", + "sha256": "c9547436e4d81def8a0385cb5a2c259c755ab3a1cb2973432de961a1011729f7", + "size": 1154117, + "subdir": "linux-64", + "timestamp": 1651600322541, + "version": "8.3.0" + }, + "ipython-8.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85909576c48de45fda002145385a187c", + "name": "ipython", + "sha256": "fd859a41ef6e70887f86f9741c99dc28d9c0f370575e1ac4fdb6c68f17c7768f", + "size": 1166221, + "subdir": "linux-64", + "timestamp": 1657652542580, + "version": "8.4.0" + }, + "ipython-8.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb3945a32771b696596078fab4b6f921", + "name": "ipython", + "sha256": "b29f6c86ee8ab60f76b577f8c8697cb3c5134a89a023bb93a76e4d79ab8a9ee6", + "size": 1148558, + "subdir": "linux-64", + "timestamp": 1657652396073, + "version": "8.4.0" + }, + "ipython-8.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a327261dfeaeecc56019b0efcbe483c7", + "name": "ipython", + "sha256": "5b16779663a278778f4481b7cd54bb6edfcd6168d468e86f8947bd84d8972973", + "size": 1152152, + "subdir": "linux-64", + "timestamp": 1657652249749, + "version": "8.4.0" + }, + "ipython-8.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.1,<3.1.0", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "78b6e15444923282f67c23ceb945a7ee", + "name": "ipython", + "sha256": "30dac1f23c1e60d25dc1fb8b0ce5942c598f4e6bbdec92f97315775b2a993083", + "size": 1186463, + "subdir": "linux-64", + "timestamp": 1668088371980, + "version": "8.6.0" + }, + "ipython-8.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.1,<3.1.0", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5d0f382a4719531c11f905eb286f126f", + "name": "ipython", + "sha256": "90ffbde456e96d528d40430c909a04190b51ca7c15495c222ac2869da2bc62ec", + "size": 1168781, + "subdir": "linux-64", + "timestamp": 1668088271001, + "version": "8.6.0" + }, + "ipython-8.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.1,<3.1.0", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "11983ece9bb1d7506410a2bde02e67c0", + "name": "ipython", + "sha256": "aac7a2d4cf00e8ec8601ee4fb1f9f1ab352acb529851e23d19f9a1562a3498e6", + "size": 1170502, + "subdir": "linux-64", + "timestamp": 1668088159097, + "version": "8.6.0" + }, + "ipython-8.7.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.11,<3.1.0", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9b412f1a8b3a9a518e396a9eae6203f1", + "name": "ipython", + "sha256": "09c0df047c4acf4633a284d79f5c16ee6807ac763f6e1cac408df0f5ea5da957", + "size": 1186937, + "subdir": "linux-64", + "timestamp": 1670919474577, + "version": "8.7.0" + }, + "ipython-8.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.11,<3.1.0", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a73398d740006966bbbaf3c4803e1666", + "name": "ipython", + "sha256": "75af8209439f98461530d9dd3dc72264fafae7a06403ab0124fb937130bdcfd3", + "size": 1169267, + "subdir": "linux-64", + "timestamp": 1670919585793, + "version": "8.7.0" + }, + "ipython-8.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.11,<3.1.0", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07bf8cad4a58596dc037991fb777ed14", + "name": "ipython", + "sha256": "04046a5d84ab1506f8f5abe7babb327468a2971d1daf4c7c8ff942cbe27aa561", + "size": 1170454, + "subdir": "linux-64", + "timestamp": 1670919359769, + "version": "8.7.0" + }, + "ipython-8.8.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.11,<3.1.0", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "951f826f6e56599248c75c2185f966a6", + "name": "ipython", + "sha256": "fe02abc5ca7b0524729ad51ec7892b257d8b5c01a618712312fbaed2cad5becf", + "size": 1216468, + "subdir": "linux-64", + "timestamp": 1674681578555, + "version": "8.8.0" + }, + "ipython-8.8.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.11,<3.1.0", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d92a8766125c1f742dba71f127b4c12a", + "name": "ipython", + "sha256": "540092d93af4cca0dd410e6c782aec0c2177e1fc795012cc4e551f5e40897638", + "size": 1197910, + "subdir": "linux-64", + "timestamp": 1674681691019, + "version": "8.8.0" + }, + "ipython-8.8.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.11,<3.1.0", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1478da7f4acd201445be9511e1a12dfa", + "name": "ipython", + "sha256": "3a748c28d04006540ff4d968ab25ceda0b3a7aa4a27a7705c88475272e5f16a8", + "size": 1200315, + "subdir": "linux-64", + "timestamp": 1674681462183, + "version": "8.8.0" + }, + "ipython-8.9.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff61dcb53562d3fa23f9caf18a22d1a6", + "name": "ipython", + "sha256": "49bffdeb7dd5650b6ae6bc93db77014335f4314a5ba024f13e3d7d3ac0454ef7", + "size": 1227932, + "subdir": "linux-64", + "timestamp": 1676331680829, + "version": "8.9.0" + }, + "ipython-8.9.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4924e1d7f6b82ec261cb4d99af2f6fba", + "name": "ipython", + "sha256": "84e5ce1c99f2abc36475958d1192f5c234f9d7807d1cc4e37ff07a44197017f2", + "size": 1210689, + "subdir": "linux-64", + "timestamp": 1676331568643, + "version": "8.9.0" + }, + "ipython-8.9.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ae57b4fb48db73cdaf812d778b0cef4d", + "name": "ipython", + "sha256": "9c9c9a6a28f87dc1305a859f972c5f28f4ee86864798c9fd9cae6c98bbf950d2", + "size": 1214093, + "subdir": "linux-64", + "timestamp": 1676331794114, + "version": "8.9.0" + }, + "ipython-sql-0.3.9-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=1.0", + "ipython_genutils >=0.1.0", + "prettytable", + "python >=3.10,<3.11.0a0", + "six", + "sqlalchemy >=0.6.7", + "sqlparse" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1367ace07b19e5850bfcdb478e73c2a6", + "name": "ipython-sql", + "sha256": "146a2e29f059132de62860d62ee5adb057216ac6b9bfb658500965b53e2a0b25", + "size": 28248, + "subdir": "linux-64", + "timestamp": 1672342838681, + "version": "0.3.9" + }, + "ipython-sql-0.3.9-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=1.0", + "ipython_genutils >=0.1.0", + "prettytable", + "python >=3.11,<3.12.0a0", + "six", + "sqlalchemy >=0.6.7", + "sqlparse" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a16cb310539bf7670a84bf2a6495cdcd", + "name": "ipython-sql", + "sha256": "a0143ec92915afaa2f018ef6714e07a43d8325e0bcef52e7e3b2fa3539555bb3", + "size": 35340, + "subdir": "linux-64", + "timestamp": 1676852921259, + "version": "0.3.9" + }, + "ipython-sql-0.3.9-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=1.0", + "ipython_genutils >=0.1.0", + "prettytable", + "python >=3.7,<3.8.0a0", + "six", + "sqlalchemy >=0.6.7", + "sqlparse" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b4c6bb7147947e53d5b4121c26a8afd", + "name": "ipython-sql", + "sha256": "394df125fc6814cffc2efd836c703e2160ee3eeb15a78380d8bf4f811b2cb17f", + "size": 28060, + "subdir": "linux-64", + "timestamp": 1672342809384, + "version": "0.3.9" + }, + "ipython-sql-0.3.9-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=1.0", + "ipython_genutils >=0.1.0", + "prettytable", + "python >=3.8,<3.9.0a0", + "six", + "sqlalchemy >=0.6.7", + "sqlparse" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8b1b337a9a9a9ffab60723039d6794c", + "name": "ipython-sql", + "sha256": "964f2ed26f99d571ac4e661c7fe38eb80110f580d6a8a9305003adc4141c10dd", + "size": 28132, + "subdir": "linux-64", + "timestamp": 1672342895691, + "version": "0.3.9" + }, + "ipython-sql-0.3.9-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=1.0", + "ipython_genutils >=0.1.0", + "prettytable", + "python >=3.9,<3.10.0a0", + "six", + "sqlalchemy >=0.6.7", + "sqlparse" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "972082b3bc48515f6eee9359606da1ec", + "name": "ipython-sql", + "sha256": "efde70c61c420cacd450dc3716ae64405a19d0a5577007bdbedf2c56caba1cee", + "size": 28152, + "subdir": "linux-64", + "timestamp": 1672342867246, + "version": "0.3.9" + }, + "ipython_genutils-0.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "425d85dd8c3c103743f2259791166ccc", + "name": "ipython_genutils", + "sha256": "b72072dc57d65c3234187c29d3c0899cbc3aea06656f3b2d722ef4efc11e17ca", + "size": 38658, + "subdir": "linux-64", + "timestamp": 1530694312457, + "version": "0.2.0" + }, + "ipython_genutils-0.2.0-py27h89fb69b_0.tar.bz2": { + "build": "py27h89fb69b_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2378e2812abf7437313d672d1fda33ec", + "name": "ipython_genutils", + "sha256": "55723d578cb7879d9648d5321d44041a64396f39e59c30d40275254e5523941f", + "size": 38442, + "subdir": "linux-64", + "timestamp": 1505672034041, + "version": "0.2.0" + }, + "ipython_genutils-0.2.0-py35hc9e07d0_0.tar.bz2": { + "build": "py35hc9e07d0_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "513e2d4f32efbc7db1e1057ff3928bd5", + "name": "ipython_genutils", + "sha256": "93bdf44da03d4f66431ae37288fd065c798eb0453dc51a36825dc3e2cdb5ab1a", + "size": 39497, + "subdir": "linux-64", + "timestamp": 1505672045196, + "version": "0.2.0" + }, + "ipython_genutils-0.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "91bd9ce667d64b1009545f4d94c97ad8", + "name": "ipython_genutils", + "sha256": "605788e3c7aa4f38ab37f29be1157e0fc9a05819a38f7208651d04409b1ec6dd", + "size": 39692, + "subdir": "linux-64", + "timestamp": 1530694274705, + "version": "0.2.0" + }, + "ipython_genutils-0.2.0-py36hb52b0d5_0.tar.bz2": { + "build": "py36hb52b0d5_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5e35f443e197f34a95d6222a1806a948", + "name": "ipython_genutils", + "sha256": "e56714fd8510995fcd5a188fe7d3540f92162d306ad988cf0e33c72c38357275", + "size": 39443, + "subdir": "linux-64", + "timestamp": 1505672056487, + "version": "0.2.0" + }, + "ipython_genutils-0.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3f663952d0c9fc552ba341ed6dab38e3", + "name": "ipython_genutils", + "sha256": "dade1e6c92fb25487d20a74b9aeb405a1897632d879c07da9d83e70de513cb80", + "size": 39745, + "subdir": "linux-64", + "timestamp": 1530694294222, + "version": "0.2.0" + }, + "ipython_genutils-0.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b5c44d3230412e85c3e7d1915e109934", + "name": "ipython_genutils", + "sha256": "ea417390b3620872ee301b3ace61bb0f19f8d52ae8ac681afc3cd4a95f97ae13", + "size": 40204, + "subdir": "linux-64", + "timestamp": 1572437574248, + "version": "0.2.0" + }, + "ipywidgets-7.0.0-py27h4fda95d_0.tar.bz2": { + "build": "py27h4fda95d_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=3.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "563a3b58e075396e3b8c57cf84790043", + "name": "ipywidgets", + "sha256": "9e7342c888b78b2593b47d1d23130d42842f03f7ad03a63109664dd9c7952bed", + "size": 91221, + "subdir": "linux-64", + "timestamp": 1505690954179, + "version": "7.0.0" + }, + "ipywidgets-7.0.0-py35h8ebd919_0.tar.bz2": { + "build": "py35h8ebd919_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=3.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1daf7b4ee2dfa833d4b8a43651ff298c", + "name": "ipywidgets", + "sha256": "b0eacb9e7e250fe92c767ab0ae50a8fcf7a29443b00199bcf705849cd71d1d0d", + "size": 93464, + "subdir": "linux-64", + "timestamp": 1505690970262, + "version": "7.0.0" + }, + "ipywidgets-7.0.0-py36h7b55c3a_0.tar.bz2": { + "build": "py36h7b55c3a_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=3.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "72a2b5d53f5369daf295542c2b61c793", + "name": "ipywidgets", + "sha256": "fe15084847ebc27fca976eb796e3f35e67643fd30b6e1273120ab63d4073ed56", + "size": 93193, + "subdir": "linux-64", + "timestamp": 1505690986629, + "version": "7.0.0" + }, + "ipywidgets-7.0.5-py27hfb35cc2_0.tar.bz2": { + "build": "py27hfb35cc2_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=3.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6d340e4bd42125f4f73defd6d2700a1e", + "name": "ipywidgets", + "sha256": "39e707ba6b82594358a9b85752d099184543f2ae200e6e665615b7d8dfc13018", + "size": 96385, + "subdir": "linux-64", + "timestamp": 1511288756637, + "version": "7.0.5" + }, + "ipywidgets-7.0.5-py35h8147dc1_0.tar.bz2": { + "build": "py35h8147dc1_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=3.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6c2603cb705d59713234fdaa5b1a4ca7", + "name": "ipywidgets", + "sha256": "cf710e37fd68fefb54a00958cb4345f69c5d4d8657882392f5de2fefdca20c95", + "size": 99135, + "subdir": "linux-64", + "timestamp": 1511288768996, + "version": "7.0.5" + }, + "ipywidgets-7.0.5-py36h31d6531_0.tar.bz2": { + "build": "py36h31d6531_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=3.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0aa16bef84b270ee8f886ef9bc878341", + "name": "ipywidgets", + "sha256": "a2e4fd08d8b17ab19b65c4192aa9a1875c6a2995aa0f0d6ad16660e4109f1ddc", + "size": 98645, + "subdir": "linux-64", + "timestamp": 1511288772204, + "version": "7.0.5" + }, + "ipywidgets-7.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=3.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "177ce1274cf5c99e34cabcacf5f56bd2", + "name": "ipywidgets", + "sha256": "ac7368ef76c6c954fc8c4936f364393a9f728238ad808d56d397b53fa44ec3dd", + "size": 96387, + "subdir": "linux-64", + "timestamp": 1515704174749, + "version": "7.1.0" + }, + "ipywidgets-7.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=3.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "11632d1bbf6ddfd8f81bffd6f92818ac", + "name": "ipywidgets", + "sha256": "8736527d44539c5b1266d1a378ca5f38f966f161f609a5e856f6bc339779daf3", + "size": 99184, + "subdir": "linux-64", + "timestamp": 1515704439260, + "version": "7.1.0" + }, + "ipywidgets-7.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=3.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a79b0f490ba0e2caaddec2b484909a3b", + "name": "ipywidgets", + "sha256": "c7d9f76b52a8146a24378296545ff738aa44dde52543a44ef06a7c1b56bbe903", + "size": 98447, + "subdir": "linux-64", + "timestamp": 1515704144782, + "version": "7.1.0" + }, + "ipywidgets-7.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.1.0,<4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1d0d1cdf5e3f333c9955c5288d7d1d2d", + "name": "ipywidgets", + "sha256": "8d25e95a18a598e3b88026913a3c1c6f8259d3a28ea5266c2bc0de1935e26e44", + "size": 96483, + "subdir": "linux-64", + "timestamp": 1517329729968, + "version": "7.1.1" + }, + "ipywidgets-7.1.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.1.0,<4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c593d9a8cc931def89a41e7950b75769", + "name": "ipywidgets", + "sha256": "96d99cdfb2fa4491f4f3cbf63b748eed746805400f7172cb49f3d83de1bd57c0", + "size": 99133, + "subdir": "linux-64", + "timestamp": 1517329742141, + "version": "7.1.1" + }, + "ipywidgets-7.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.1.0,<4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1bb993c3a8c4d1c674c7e0eec27337e6", + "name": "ipywidgets", + "sha256": "8742917a3df963f5b179b6425dd4309ddff0a246ef3a3899c9c2de9fdba6fcc0", + "size": 98561, + "subdir": "linux-64", + "timestamp": 1517329833205, + "version": "7.1.1" + }, + "ipywidgets-7.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.1.0,<4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "56426ada88d5f21d14df0313dae1a40b", + "name": "ipywidgets", + "sha256": "8d7e82ae8ee6e8f6d609b42ef8dd326b5538f1d12bc9b5f728f4cb2e4f5062b1", + "size": 96325, + "subdir": "linux-64", + "timestamp": 1519152784523, + "version": "7.1.2" + }, + "ipywidgets-7.1.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.1.0,<4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "84fef4bb93e5bfdb82b0316b9e2dbcab", + "name": "ipywidgets", + "sha256": "ef5103ce0af37a577f368d6f746a05586ad0074e0cf57c34e2b7e354b95e3bd3", + "size": 98958, + "subdir": "linux-64", + "timestamp": 1519152800784, + "version": "7.1.2" + }, + "ipywidgets-7.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.1.0,<4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8098417f41885bf3f30e6e868e5d3bb4", + "name": "ipywidgets", + "sha256": "2ae1656cd4d60a24da046840605c12a112d3c7eba9218d09058de9cc6b0bac7a", + "size": 98643, + "subdir": "linux-64", + "timestamp": 1519152753893, + "version": "7.1.2" + }, + "ipywidgets-7.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.2.0,<4.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "658c64c8197122981799c0d73b04a5bb", + "name": "ipywidgets", + "sha256": "cf1d3f25a3ac2bac671d96849098d12da0cb6d1021ed153562c16d6195752702", + "size": 144787, + "subdir": "linux-64", + "timestamp": 1522694865672, + "version": "7.2.0" + }, + "ipywidgets-7.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.2.0,<4.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dc7bbe6e4b7a0796a22e0c03c7fe9758", + "name": "ipywidgets", + "sha256": "b0b3c48833a151ee042f827f589680f82dd782f12801bdb2729765f1dc2b417a", + "size": 147848, + "subdir": "linux-64", + "timestamp": 1522695059882, + "version": "7.2.0" + }, + "ipywidgets-7.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.2.0,<4.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "25dc59f9986a0cea2899f34516f8cf58", + "name": "ipywidgets", + "sha256": "73d9d99c06541af0b7afa28b6edd32ce7ce7902f5f784e83f0a305ead1d8f639", + "size": 147455, + "subdir": "linux-64", + "timestamp": 1522694922847, + "version": "7.2.0" + }, + "ipywidgets-7.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.2.0,<4.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "06ebdaa7e2acc4fd63ac5a2ad719c9d7", + "name": "ipywidgets", + "sha256": "97d3a473dc31f31876cc653cef5b2d3c930f0dfed2f3d86372195986c339ab90", + "size": 144781, + "subdir": "linux-64", + "timestamp": 1523907722999, + "version": "7.2.1" + }, + "ipywidgets-7.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.2.0,<4.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7aa79939edac8ae2535906b1770a2a06", + "name": "ipywidgets", + "sha256": "ddc012d7565340429ba704ae8db621b322ee21cdaa0975dc3654dfe5a8523cfd", + "size": 147804, + "subdir": "linux-64", + "timestamp": 1523908337820, + "version": "7.2.1" + }, + "ipywidgets-7.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.2.0,<4.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "39d466bff03e4edad66c9a7dd212fb16", + "name": "ipywidgets", + "sha256": "6d8d27f0238aab3de39b0123d78475c7c6bbb42b703b50e376a2eebd213e6f76", + "size": 147482, + "subdir": "linux-64", + "timestamp": 1523907720523, + "version": "7.2.1" + }, + "ipywidgets-7.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.7,<3.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.2.0,<4.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b8e8597bc4eb99b08f343187a0341a26", + "name": "ipywidgets", + "sha256": "5efa66c1554df1ce9d8e5cdea0bca550c48fdecf3632fad7c07500cdf537abca", + "size": 149577, + "subdir": "linux-64", + "timestamp": 1530734792962, + "version": "7.2.1" + }, + "ipywidgets-7.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.3.0,<3.4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f411cd0c41332814999c73c1ffcdde21", + "name": "ipywidgets", + "sha256": "016a82c1ef9da3b13a1e8e37d4e9c107357ed33fe29a3598d410feff15abb7e9", + "size": 148141, + "subdir": "linux-64", + "timestamp": 1532452146269, + "version": "7.3.0" + }, + "ipywidgets-7.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.3.0,<3.4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b3b92570a042bf48877b283db8cffb32", + "name": "ipywidgets", + "sha256": "00db3dd3cf74105e6e34de2110f4c502c2533b536b3b74db10de9396fc630f8b", + "size": 151339, + "subdir": "linux-64", + "timestamp": 1532452494177, + "version": "7.3.0" + }, + "ipywidgets-7.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.3.0,<3.4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "082b0ed28cf78984cfd607e9364668f5", + "name": "ipywidgets", + "sha256": "ded253cb5c30ef7b7393410fd9b2ee94f9c5ba773a78998886b0813384195e3c", + "size": 150682, + "subdir": "linux-64", + "timestamp": 1532452784490, + "version": "7.3.0" + }, + "ipywidgets-7.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.7,<3.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.3.0,<3.4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b7f85e74c6ed5076f377e3ff28645d9b", + "name": "ipywidgets", + "sha256": "2d28daf8ba6e443667a57b0c1c6b21e093b213e2c57c2e9d480c8ba3c63e861f", + "size": 150635, + "subdir": "linux-64", + "timestamp": 1532452864384, + "version": "7.3.0" + }, + "ipywidgets-7.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.3.0,<3.4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f37fd3ff54ba5a1c57a911160bd3941e", + "name": "ipywidgets", + "sha256": "c2e4f9d94378948e3243f3b56b6a4076908e43c7802acd1f244b2da524fbd160", + "size": 148543, + "subdir": "linux-64", + "timestamp": 1532970553709, + "version": "7.3.1" + }, + "ipywidgets-7.3.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.3.0,<3.4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e86b48ad206ab66690d4c5ffda2020d8", + "name": "ipywidgets", + "sha256": "43f6d13e9f37eeb7f13ba535d4800fe590c6d7e89b4b439b99466e56bbbeed04", + "size": 151727, + "subdir": "linux-64", + "timestamp": 1532970615177, + "version": "7.3.1" + }, + "ipywidgets-7.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.3.0,<3.4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b052e3b2f7186d1745b49bfd23936417", + "name": "ipywidgets", + "sha256": "3cc59b9b4955d62f1f7392e52216d8c810aaa29b56db98d9bd59e7508f6825b3", + "size": 151141, + "subdir": "linux-64", + "timestamp": 1532970469582, + "version": "7.3.1" + }, + "ipywidgets-7.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.7,<3.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.3.0,<3.4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c2a5467263197a080c8d8af3ab4bd894", + "name": "ipywidgets", + "sha256": "57c8ea24d1f181e875a274dbc23e7456af107c4f17f731dccc0bd68d08b03d79", + "size": 151105, + "subdir": "linux-64", + "timestamp": 1532970578281, + "version": "7.3.1" + }, + "ipywidgets-7.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "bbe8a38a52687240327a942a8f0b0b57", + "name": "ipywidgets", + "sha256": "18d6eed37ccb127b5632566a4f3d970a51ed9fe0d83bb9e66c68d6e0de4d3c02", + "size": 147885, + "subdir": "linux-64", + "timestamp": 1533743200121, + "version": "7.4.0" + }, + "ipywidgets-7.4.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8a2b8cbaa0f0128c7b675eb1bc03df10", + "name": "ipywidgets", + "sha256": "72cfa969801dc847c599b3ace5daf61faf5c153e8d73278ad340ee81f68cb458", + "size": 150725, + "subdir": "linux-64", + "timestamp": 1534351422043, + "version": "7.4.0" + }, + "ipywidgets-7.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "32c76a472ab22777bbb26c5b55406f8d", + "name": "ipywidgets", + "sha256": "dc9b079dcec2c90ff8be83f43a54a7f50aeb964a51500d7ecd4548eb3d401877", + "size": 151190, + "subdir": "linux-64", + "timestamp": 1533743754904, + "version": "7.4.0" + }, + "ipywidgets-7.4.0-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8514592b0fbfd7b0cf3611f80c196146", + "name": "ipywidgets", + "sha256": "28c9070bb46ceefce52aa78db06ab7c915fc4e962ce71b0fa0e1b6a38475e343", + "size": 154059, + "subdir": "linux-64", + "timestamp": 1534351464492, + "version": "7.4.0" + }, + "ipywidgets-7.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7d01f0a2ec9f8c244b9f1ddab60f9b34", + "name": "ipywidgets", + "sha256": "36862a61e8c315234d287907ca53fd49289ceb6a9be42608e4571c3c796030a7", + "size": 150598, + "subdir": "linux-64", + "timestamp": 1533743207071, + "version": "7.4.0" + }, + "ipywidgets-7.4.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "569ac9f638672857805b92a814b434ac", + "name": "ipywidgets", + "sha256": "3396fb7c943a136f5cb4f9283387b1e4a912376ac9ede9bab2c77d00a0f17d49", + "size": 153386, + "subdir": "linux-64", + "timestamp": 1534351509863, + "version": "7.4.0" + }, + "ipywidgets-7.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.7,<3.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "16e199602dbc977d88a0012305fe0e12", + "name": "ipywidgets", + "sha256": "4ab70943bfc57eb89e15d5db22a5fb1652823074cd9ab1adfb33719d46f6fa71", + "size": 150600, + "subdir": "linux-64", + "timestamp": 1533743303993, + "version": "7.4.0" + }, + "ipywidgets-7.4.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.7,<3.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "12174d62a8e1b4e88eae15ba364c3ed3", + "name": "ipywidgets", + "sha256": "28b7a2a55a0e9cbf7750d210af48ee5e386ef7fdbccff20f90978ebc87373397", + "size": 153381, + "subdir": "linux-64", + "timestamp": 1534351383908, + "version": "7.4.0" + }, + "ipywidgets-7.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "024aaf3bd89d070d59f7eb37a0c5e7a2", + "name": "ipywidgets", + "sha256": "62916bba74869a5419a3824cf038aff47a035f3e8527c572a730d45b39ea9c90", + "size": 148381, + "subdir": "linux-64", + "timestamp": 1536074929997, + "version": "7.4.1" + }, + "ipywidgets-7.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e2f13a54bbd170b1f669602f0971d65f", + "name": "ipywidgets", + "sha256": "ceb1a14bea790f47ed4608c4fe931fce99b057ded52a804992b3c9e6c3b46405", + "size": 151698, + "subdir": "linux-64", + "timestamp": 1536074922151, + "version": "7.4.1" + }, + "ipywidgets-7.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8fcce2b676bcfff852b8057aa1c98405", + "name": "ipywidgets", + "sha256": "3faa7267629aec6d13b84d7d18529d2ed2fc850e8d0094636c89c496262db446", + "size": 151047, + "subdir": "linux-64", + "timestamp": 1536074927237, + "version": "7.4.1" + }, + "ipywidgets-7.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.7,<3.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "bf396c4e0c1bc27e33152727f8b69b38", + "name": "ipywidgets", + "sha256": "113f26fc32347ab108152928509d94357f1d0c5528ce773efeb88aaf82097f37", + "size": 151131, + "subdir": "linux-64", + "timestamp": 1536074956515, + "version": "7.4.1" + }, + "ipywidgets-7.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e4892c2f88e19fb4012f7439ce2a9016", + "name": "ipywidgets", + "sha256": "6b2281807053db86c15b3480630992c3e4a6a74f3fe9e49af941c7eff7dda1f4", + "size": 151705, + "subdir": "linux-64", + "timestamp": 1538158579676, + "version": "7.4.2" + }, + "ipywidgets-7.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "879d62cc4bf5d54e1a37c73244a5fdc1", + "name": "ipywidgets", + "sha256": "e436a9efd882656a79ea5889b0ea4e31f552bb15a0173b25288237713a383774", + "size": 154367, + "subdir": "linux-64", + "timestamp": 1538158648009, + "version": "7.4.2" + }, + "ipywidgets-7.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.7,<3.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "39d47044c6c56b47e3a5ea6ee5c8c3e7", + "name": "ipywidgets", + "sha256": "3b9c13f1a9a25281862f82c750cbd790b0ac32c919d9246573999eb6db7c7c5c", + "size": 154368, + "subdir": "linux-64", + "timestamp": 1538158606399, + "version": "7.4.2" + }, + "ipywidgets-8.0.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=6.1.0", + "jupyterlab_widgets >=3.0.4,<4.0.0", + "python >=3.10,<3.11.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=4.0.4,<5.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4ce74dc45221fe7eb8f932ef34532f22", + "name": "ipywidgets", + "sha256": "fa263fb808105ee96e5ee53663995e57db56c61d2bdd40b49a22636b9e153d8a", + "size": 197466, + "subdir": "linux-64", + "timestamp": 1679394901804, + "version": "8.0.4" + }, + "ipywidgets-8.0.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=6.1.0", + "jupyterlab_widgets >=3.0.4,<4.0.0", + "python >=3.11,<3.12.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=4.0.4,<5.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fda19b999c7d294b0334865675a40fef", + "name": "ipywidgets", + "sha256": "22cb97082c61f273bc13106951fb1c97669442fc33005c3aabf7a9cb7cb25563", + "size": 247955, + "subdir": "linux-64", + "timestamp": 1679394936739, + "version": "8.0.4" + }, + "ipywidgets-8.0.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=6.1.0", + "jupyterlab_widgets >=3.0.4,<4.0.0", + "python >=3.8,<3.9.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=4.0.4,<5.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a8152828442c98c9361058f9017e9881", + "name": "ipywidgets", + "sha256": "d80388dc7900e341fd7a9ceeda6832db32a8c9290dfe03de3e6d3b4b5ce96da1", + "size": 196231, + "subdir": "linux-64", + "timestamp": 1679394865401, + "version": "8.0.4" + }, + "ipywidgets-8.0.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=6.1.0", + "jupyterlab_widgets >=3.0.4,<4.0.0", + "python >=3.9,<3.10.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=4.0.4,<5.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1521ce8aa27df7d97e601a09227b8fb3", + "name": "ipywidgets", + "sha256": "6d450e39c907745dbeb154e2859a1b1f4cfbc856012151a2c968fb7acdfed755", + "size": 196130, + "subdir": "linux-64", + "timestamp": 1679394829252, + "version": "8.0.4" + }, + "isl-0.12.2-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "gmp" + ], + "license": "MIT", + "md5": "97aaa02735b4c5e71a08cec175287b0e", + "name": "isl", + "sha256": "814d07ee8b25222dd08ffa01ef20b34d0407927f383d44ef580cefbd6e162f68", + "size": 1151169, + "version": "0.12.2" + }, + "isl-0.22.1-h295c915_3.tar.bz2": { + "build": "h295c915_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "59303224b0f1e31878460fc314f29458", + "name": "isl", + "sha256": "abbfc0edc0c4d3aa4354aadfdb9a40e485040e717f6153087a02b1eda6805628", + "size": 893729, + "subdir": "linux-64", + "timestamp": 1646827138055, + "version": "0.22.1" + }, + "iso8601-0.1.12-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b86291004aef8143149593cf731ed11a", + "name": "iso8601", + "sha256": "6fefeff972bfb55ea084713941d0dd60aecad3c64da63340485ee415728eefba", + "size": 14524, + "subdir": "linux-64", + "timestamp": 1530733069005, + "version": "0.1.12" + }, + "iso8601-0.1.12-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5b2b9a16051d0ac88371fb5b39a68d95", + "name": "iso8601", + "sha256": "907839035d7e3bba0e6f9be1f00ef3527fc4cdc50bbc578c4205397bcdd6a4cb", + "size": 14589, + "subdir": "linux-64", + "timestamp": 1535126122103, + "version": "0.1.12" + }, + "iso8601-0.1.12-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "1916f41f580a49b4d5370f291c2fc83f", + "name": "iso8601", + "sha256": "f8fcc5f816388bdd0fdd73f628211c57735669a343768304d10846fa72a99b1c", + "size": 14769, + "subdir": "linux-64", + "timestamp": 1535126129734, + "version": "0.1.12" + }, + "iso8601-0.1.12-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3eecb38f8416bda9df74a6d52cb50248", + "name": "iso8601", + "sha256": "3de8042fb08fa3ec2ad47cc802231ddc864de11f67e84bf227e745759a3d16c7", + "size": 14690, + "subdir": "linux-64", + "timestamp": 1530733049433, + "version": "0.1.12" + }, + "iso8601-0.1.12-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "78fce302511d000d01ae97bf7c7cc746", + "name": "iso8601", + "sha256": "06f5e5addc20106e375d29cc1dd89de7dc8bb5d949fedc8745b79fafd8b1d96f", + "size": 14751, + "subdir": "linux-64", + "timestamp": 1535125912782, + "version": "0.1.12" + }, + "iso8601-0.1.12-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4e58d0a891d97def4f7697ca3ee08d51", + "name": "iso8601", + "sha256": "3b39ef704e4cbefb98c3459d375aae81f8bbf0195a619ce1920bad566fd0bb1b", + "size": 16238, + "subdir": "linux-64", + "timestamp": 1605213729849, + "version": "0.1.12" + }, + "iso8601-0.1.12-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e1fcebc20d33316af59ea42b6018b2f8", + "name": "iso8601", + "sha256": "9c9ca8c597b50d1f2faf18193d3b53efc68af448dd97c0774853acd7efefc08d", + "size": 14661, + "subdir": "linux-64", + "timestamp": 1530733088629, + "version": "0.1.12" + }, + "iso8601-0.1.12-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "569aac21c50f204a0718dc1c358e2f91", + "name": "iso8601", + "sha256": "98ed0e42fe8d31a2fda4f2be74b96e2b9e77ee089eddc882546c8cb6fc84049f", + "size": 14731, + "subdir": "linux-64", + "timestamp": 1535125999079, + "version": "0.1.12" + }, + "iso8601-0.1.12-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "fbe19bf203f62b498edf3e10012dd853", + "name": "iso8601", + "sha256": "b7fe9fc29e22ff3591a13cddd803ecd4f7d81cb8fc0b89c44fba5560260abf5e", + "size": 16214, + "subdir": "linux-64", + "timestamp": 1605213713753, + "version": "0.1.12" + }, + "iso8601-0.1.12-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "0089bbd20759047edc19cfc2eb5f472b", + "name": "iso8601", + "sha256": "8000e1ee496c5c9b294adcbae44ed104e00eb49799e525236807a57b57e261fe", + "size": 15143, + "subdir": "linux-64", + "timestamp": 1572437621791, + "version": "0.1.12" + }, + "iso8601-0.1.12-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "4c0a95a824de21d6c2baf61dcbab0b3d", + "name": "iso8601", + "sha256": "0f1902ed8c79ef5d673fed9377e87bad2b521cfa95ad68f290254e2504df02a1", + "size": 16237, + "subdir": "linux-64", + "timestamp": 1605213721250, + "version": "0.1.12" + }, + "iso8601-0.1.12-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "6e297dd19457e73503023a74bdddc4f0", + "name": "iso8601", + "sha256": "288ddcd3341e589544454c265cb71ea8a1107d5f4788e28cff006e990095714b", + "size": 16213, + "subdir": "linux-64", + "timestamp": 1605213695003, + "version": "0.1.12" + }, + "iso8601-0.1.13-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0e9203b40d09a44cb667c768cd2cc086", + "name": "iso8601", + "sha256": "beae0f086af95488cb4c40caf2f8c337529e22e34ddad614ed7c840633462f92", + "size": 15193, + "subdir": "linux-64", + "timestamp": 1600379569044, + "version": "0.1.13" + }, + "iso8601-0.1.13-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5836f049cab73fa81e969005cf0487fb", + "name": "iso8601", + "sha256": "af6365369ca74ffe8a164216d3dd1b9a507028ca56afa37ed2022cd47347da83", + "size": 15118, + "subdir": "linux-64", + "timestamp": 1600379566702, + "version": "0.1.13" + }, + "iso8601-0.1.13-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "4055c8dbe1183dc2c2537d5e5648aa89", + "name": "iso8601", + "sha256": "1d25a1ca126e005757e3e983195f91dc83228681dae4c78c0beb9a81f3d8ef76", + "size": 15184, + "subdir": "linux-64", + "timestamp": 1600379586609, + "version": "0.1.13" + }, + "iso8601-0.1.14-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "42fcc068cb7d2df25e792c32d288f246", + "name": "iso8601", + "sha256": "d08565111028bb260cd10d5f50c4aba50436a6c0f81a78f390a02bddcc68d09d", + "size": 15415, + "subdir": "linux-64", + "timestamp": 1613502215658, + "version": "0.1.14" + }, + "iso8601-0.1.14-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "238fd5b54a250ec20c3aa58245407685", + "name": "iso8601", + "sha256": "5089e202e5f9f298ff33310d21caa758e3390d4fa47952b3a2708c4e15bf3d2c", + "size": 15393, + "subdir": "linux-64", + "timestamp": 1613502217695, + "version": "0.1.14" + }, + "iso8601-0.1.14-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "07408938a9ee20e7d78af9c3f4ec9ec4", + "name": "iso8601", + "sha256": "e69eb4cd19af26d8fc06313c80a4e73afd3437f4ea1bf7c722d6c59f5e1d359c", + "size": 15443, + "subdir": "linux-64", + "timestamp": 1613502217258, + "version": "0.1.14" + }, + "iso8601-0.1.14-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "6ee904e3b1460f75b58cb8988ecb9645", + "name": "iso8601", + "sha256": "1083f2ea54a7ae118160ab2fce20ac7243c223a206bb5079fbfd6064287a5318", + "size": 15378, + "subdir": "linux-64", + "timestamp": 1613501576700, + "version": "0.1.14" + }, + "iso8601-0.1.16-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "601d59cfcb1c67dd1699284f6a0d5144", + "name": "iso8601", + "sha256": "de284859a540c2218ef798b20e3267f3c5012bf77c6c5320cf4e73e6404bb4fe", + "size": 16447, + "subdir": "linux-64", + "timestamp": 1626702135050, + "version": "0.1.16" + }, + "iso8601-0.1.16-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1db9092043165f61e6f0edd2fc6e0ea0", + "name": "iso8601", + "sha256": "65247add39b71a5eef72e3105c8076a0b46930fb9d4181c22408900b1dbfe2c2", + "size": 16393, + "subdir": "linux-64", + "timestamp": 1626694819602, + "version": "0.1.16" + }, + "iso8601-0.1.16-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e72ca1e893f4599ea21a499193d9745", + "name": "iso8601", + "sha256": "d3390bf333615737ef985b0926e63b725c2d4ca725c59a709baf317161988cf7", + "size": 16441, + "subdir": "linux-64", + "timestamp": 1626702055242, + "version": "0.1.16" + }, + "iso8601-0.1.16-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d1c503b84298f38192d845eb45561ee3", + "name": "iso8601", + "sha256": "61a67556c45b309b0c2f1a0521d9107ed19b77a3127e97c9ccc13401e90469fa", + "size": 16421, + "subdir": "linux-64", + "timestamp": 1626702133908, + "version": "0.1.16" + }, + "isodate-0.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "d9507e0f0a5f41462620f60b3af52f28", + "name": "isodate", + "sha256": "b1077f9f9cbf212faec0a281a21383dc3e4b1a21727b82b81d0f73df8c8da234", + "size": 45618, + "subdir": "linux-64", + "timestamp": 1530735719545, + "version": "0.6.0" + }, + "isodate-0.6.0-py27hf5b12f5_0.tar.bz2": { + "build": "py27hf5b12f5_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "1282058625f77b14821580e75182b34b", + "name": "isodate", + "sha256": "a44cdd9796da334ed1e8e1fb065e7f8ee55213acda3e39e02a5d198a5a620237", + "size": 45929, + "subdir": "linux-64", + "timestamp": 1508620696791, + "version": "0.6.0" + }, + "isodate-0.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "74c6ac08aba9cbabe4621b242a3a6de2", + "name": "isodate", + "sha256": "c7d0baa5a34dce938676cb418cc39d9a73c8ef1752b4fcc625d06ea0ac61c69f", + "size": 46528, + "subdir": "linux-64", + "timestamp": 1534352042771, + "version": "0.6.0" + }, + "isodate-0.6.0-py35h6a86938_0.tar.bz2": { + "build": "py35h6a86938_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "2789be12c4389e8fd3a6bae86cfa3efe", + "name": "isodate", + "sha256": "09f4b9f0de004535be1123df89964c27ac08761d7b4e352ee5f78da667e5e4fd", + "size": 46951, + "subdir": "linux-64", + "timestamp": 1508620683489, + "version": "0.6.0" + }, + "isodate-0.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "c5221c2df016ff34cdc93dbc49dd50cd", + "name": "isodate", + "sha256": "6752fe5173a8652e76a918c8fb3d5803461d864825f29d953417fca90208f21c", + "size": 46511, + "subdir": "linux-64", + "timestamp": 1530735698818, + "version": "0.6.0" + }, + "isodate-0.6.0-py36h3a1d279_0.tar.bz2": { + "build": "py36h3a1d279_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "ce418d7df87ea9728fd4f3448358f306", + "name": "isodate", + "sha256": "27b72d5a7b4ed76abfb12fa3bfa5b34b608396fdff4caf3b683c4c74b692454d", + "size": 46836, + "subdir": "linux-64", + "timestamp": 1508620730136, + "version": "0.6.0" + }, + "isodate-0.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "8e8f93b7b1320c628c861f78601186aa", + "name": "isodate", + "sha256": "13eebc1741d04a6c23f24ac23462276f932993d30a36a4c2b1c296a849809799", + "size": 46326, + "subdir": "linux-64", + "timestamp": 1530735740946, + "version": "0.6.0" + }, + "isort-4.2.15-py27hcfa4749_0.tar.bz2": { + "build": "py27hcfa4749_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "417e2609a1da77c682696b033f523e3f", + "name": "isort", + "sha256": "ceb2824e9f764d8ad037b0697888e76e6730a5dafa832e5d229b00902d1fbe93", + "size": 58059, + "subdir": "linux-64", + "timestamp": 1505744628252, + "version": "4.2.15" + }, + "isort-4.2.15-py35h44a00d2_0.tar.bz2": { + "build": "py35h44a00d2_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "8a22699f7409f562b23d15d6124b7335", + "name": "isort", + "sha256": "7ded27840b487ef51019c7f53a809e911201c7aa5a48db462d8d9ae1492406c2", + "size": 58990, + "subdir": "linux-64", + "timestamp": 1505744641942, + "version": "4.2.15" + }, + "isort-4.2.15-py36had401c0_0.tar.bz2": { + "build": "py36had401c0_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "4f482bc092921f61e2177dc2ad48afd9", + "name": "isort", + "sha256": "2fdf6d74de0909ebcbbf00f4a91122ea3c7be438294795a44bcaedcf8866e41e", + "size": 58632, + "subdir": "linux-64", + "timestamp": 1505744655582, + "version": "4.2.15" + }, + "isort-4.3.15-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "futures", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "5ce0630ce1961644cf5d295bd935b858", + "name": "isort", + "sha256": "15f7dcbc93421be39b249d9eb246d902efaf9b62d43910660b82b212bc4dc4d2", + "size": 68263, + "subdir": "linux-64", + "timestamp": 1552332165092, + "version": "4.3.15" + }, + "isort-4.3.15-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "f5578508939af7b877b99b4a2501a8aa", + "name": "isort", + "sha256": "d45fd9de488b9179a08950e9a2044fe04f0ae3aaaabff08bb8f25b649298b8da", + "size": 68665, + "subdir": "linux-64", + "timestamp": 1552332197001, + "version": "4.3.15" + }, + "isort-4.3.15-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "18bc9c85b9c326de402423d63aafcc25", + "name": "isort", + "sha256": "1303ab5f3fbdb7ccab2514f1301e69f552cab2ba3f18102d1cd7dd0033911ca3", + "size": 68711, + "subdir": "linux-64", + "timestamp": 1552332091910, + "version": "4.3.15" + }, + "isort-4.3.16-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "futures", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "c2e6e3f171bfe5e0edb73d8c44593238", + "name": "isort", + "sha256": "d4974b645fbfdb5b26e9a87f690728b48cf527cf772b7037240012060be20357", + "size": 68549, + "subdir": "linux-64", + "timestamp": 1553525057080, + "version": "4.3.16" + }, + "isort-4.3.16-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "fda7503dba3b0cc20995c0baa7865d84", + "name": "isort", + "sha256": "76623e114f27075a6ac5c12e4762a138bed58dd2c96faed950facd9a99d151f4", + "size": 69004, + "subdir": "linux-64", + "timestamp": 1553525005490, + "version": "4.3.16" + }, + "isort-4.3.16-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "5050d4aa595f5aff830abe1342eb4288", + "name": "isort", + "sha256": "c684a7b82035f26a7f95adbfb9a262a9ad8351b9f224d131ab3535186eea537c", + "size": 68887, + "subdir": "linux-64", + "timestamp": 1553525028445, + "version": "4.3.16" + }, + "isort-4.3.17-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "futures", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "5a2c64fbfeaa3bb77e6c77a21c09714c", + "name": "isort", + "sha256": "a72a4a0884a8862255a3de3bb598dcd2d417b56f5a2bec93a814b77ca314fa5c", + "size": 68625, + "subdir": "linux-64", + "timestamp": 1555430965266, + "version": "4.3.17" + }, + "isort-4.3.17-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "274585c0dd07e36fe87788f52ec7d2da", + "name": "isort", + "sha256": "4489fdda63b04604669762239fc28728891c511994fc1525473bfa1e964bf686", + "size": 69029, + "subdir": "linux-64", + "timestamp": 1555430976644, + "version": "4.3.17" + }, + "isort-4.3.17-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "b6b3e7fd45a8a012690794f0749be9ba", + "name": "isort", + "sha256": "1bf23e78d5c5457e6b09bc671483294a4452bbfe3638f62ceefb7dc52909a927", + "size": 69061, + "subdir": "linux-64", + "timestamp": 1555430951300, + "version": "4.3.17" + }, + "isort-4.3.18-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "futures", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "0847dba1abacc15292200052bf799a1f", + "name": "isort", + "sha256": "1c77c612d3c6cd82a89733ad9187e7b7c79f2ba40cf662fc280bca6843258035", + "size": 68946, + "subdir": "linux-64", + "timestamp": 1557505719630, + "version": "4.3.18" + }, + "isort-4.3.18-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "70c696c7d0bae80bfd46159cc5869eb4", + "name": "isort", + "sha256": "195a547af5fa53ac19126fd28cd956e19f990be775202f83da099305a79e6538", + "size": 69298, + "subdir": "linux-64", + "timestamp": 1557505747704, + "version": "4.3.18" + }, + "isort-4.3.18-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "e7974bb8ee9a74776f8b3fd3e31b0370", + "name": "isort", + "sha256": "8f8a43576ba4d096c29658a201ba7dd39133332b20d1f57381823d9cdf459991", + "size": 69234, + "subdir": "linux-64", + "timestamp": 1557505709201, + "version": "4.3.18" + }, + "isort-4.3.19-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "futures", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "3c643cadf45e5050cf06ddd6fea833fd", + "name": "isort", + "sha256": "93cbd24b4396461821d2819acfa67ed1c823b802c08a2c38f2b890952e57a9c8", + "size": 69211, + "subdir": "linux-64", + "timestamp": 1557855800039, + "version": "4.3.19" + }, + "isort-4.3.19-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "c884f05c006aefdfee940ed445ebbe3b", + "name": "isort", + "sha256": "cdeb8ac423c2f6128006f13773405d47225c4ba6b582270db41a3720999347f1", + "size": 69639, + "subdir": "linux-64", + "timestamp": 1557855853291, + "version": "4.3.19" + }, + "isort-4.3.19-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "83c6fc73b814004af819cb6c55ae72bf", + "name": "isort", + "sha256": "a836a7375d1bab5eb67ed5f64ce2437f1517b4cf4f99484c90485d039196600e", + "size": 69426, + "subdir": "linux-64", + "timestamp": 1557855792852, + "version": "4.3.19" + }, + "isort-4.3.20-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "futures", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "2bac1df94afc76a25cd579919cb0ff57", + "name": "isort", + "sha256": "db3deea218a42a7749343507525d51cf199f1bf9079773dca9ea1153bb75c8e4", + "size": 69311, + "subdir": "linux-64", + "timestamp": 1559772926344, + "version": "4.3.20" + }, + "isort-4.3.20-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "dda5af210563215f7fb231084d295b82", + "name": "isort", + "sha256": "b44023d57559c1aa7fca0966563e467ed32abd0c65f0d47cb4f7b4e538513727", + "size": 69594, + "subdir": "linux-64", + "timestamp": 1559773054508, + "version": "4.3.20" + }, + "isort-4.3.20-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "f0b4bf1dfd687f369ebd1b421c931588", + "name": "isort", + "sha256": "a81f7d721b316529f33af14a81e981ed4aa83a40c26a1d15eb2f270e4c506835", + "size": 69544, + "subdir": "linux-64", + "timestamp": 1559772906478, + "version": "4.3.20" + }, + "isort-4.3.21-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "futures", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "0cef29295ad5d25c2b32016b164ba15a", + "name": "isort", + "sha256": "45525257633ca6cb85844438af125663568066a1f97d4f063420c9087a5a548f", + "size": 69586, + "subdir": "linux-64", + "timestamp": 1562085504919, + "version": "4.3.21" + }, + "isort-4.3.21-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "a36fd24f675dc606775290ad37397e48", + "name": "isort", + "sha256": "1f692b3f148ffb31900a0b16a4e41244f86d91ae1c550f7f1a0d5b02d9069eb7", + "size": 70026, + "subdir": "linux-64", + "timestamp": 1562085542403, + "version": "4.3.21" + }, + "isort-4.3.21-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "8001d10689a3bfd64a21f8dba3bc5e65", + "name": "isort", + "sha256": "d0360a441d04b7844eb6d0556066963b7b4a8c83a7534c5ac57318cd2e2ea990", + "size": 69964, + "subdir": "linux-64", + "timestamp": 1562085540235, + "version": "4.3.21" + }, + "isort-4.3.21-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "92bdbe0419477751b03388bd4649f43f", + "name": "isort", + "sha256": "5a449781c26604bf84c719020aea0b58b0bb371aa5ad21368992a14eaf2e0edb", + "size": 66087, + "subdir": "linux-64", + "timestamp": 1574157987422, + "version": "4.3.21" + }, + "isort-4.3.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "0685baed4ad24768a532057cc6d0bf23", + "name": "isort", + "sha256": "be443e7cc0f44943ec8a9c1a1de377e7bc4a832518ebe6f45d26ee29ec31bf5b", + "size": 59367, + "subdir": "linux-64", + "timestamp": 1519152646289, + "version": "4.3.4" + }, + "isort-4.3.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "4c0a32705f027a4d140ff6320efa0083", + "name": "isort", + "sha256": "ea85dddaa212e913eb50d3721378f6fe01ae44afc1a4f7ec8840b55700ee242c", + "size": 60392, + "subdir": "linux-64", + "timestamp": 1519152646931, + "version": "4.3.4" + }, + "isort-4.3.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "9f6f6ad7ab0b87f8e54aaa1c20196ce4", + "name": "isort", + "sha256": "a4b593334ef3f4df49c781198c22a6f4d011cee8b4c36b9591a9eb590ca9af5f", + "size": 59854, + "subdir": "linux-64", + "timestamp": 1519152572471, + "version": "4.3.4" + }, + "isort-4.3.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "d6df2209e16207467d60d8ed3ddce239", + "name": "isort", + "sha256": "49031648dbb34066968bbd402e25e9821985e50bb8d46b322969c3245139b77d", + "size": 59566, + "subdir": "linux-64", + "timestamp": 1530897913208, + "version": "4.3.4" + }, + "isort-4.3.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "b21871d4f5d55942db8dd3d2a39a4e32", + "name": "isort", + "sha256": "b1351e911d354c5157e8104954ae0af52c352fe0940277b0472881212e45f814", + "size": 62973, + "subdir": "linux-64", + "timestamp": 1551139857556, + "version": "4.3.8" + }, + "isort-4.3.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "4961fb33b4ad285efd733ad954d5a0a7", + "name": "isort", + "sha256": "a4976effc47fcb4daebf8dbda76f6d1086e25c5a6b25627e0fe77e8f4331e85c", + "size": 63257, + "subdir": "linux-64", + "timestamp": 1551139877828, + "version": "4.3.8" + }, + "isort-4.3.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "a62520c38d9a2ed40bbdea3931206d58", + "name": "isort", + "sha256": "53b473317d79c6fee2874e185a75d91c14662cb1b6c532b986c63307be016335", + "size": 63188, + "subdir": "linux-64", + "timestamp": 1551139836425, + "version": "4.3.8" + }, + "isort-5.0.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "47d8f3e31aa129ca85eb8c2d87a2d453", + "name": "isort", + "sha256": "4c89d2baf80f103babdcabb7b09c20aa44c5e0c6d22279b1bd166be784ecaf60", + "size": 138293, + "subdir": "linux-64", + "timestamp": 1594747370756, + "version": "5.0.9" + }, + "isort-5.0.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "dec67cf744147cb9e093c2e1223a3327", + "name": "isort", + "sha256": "42371d7ba670c66930bed06bf6ccc4b9cc2978cd47b40022442a64a99549e240", + "size": 138001, + "subdir": "linux-64", + "timestamp": 1594747347283, + "version": "5.0.9" + }, + "isort-5.0.9-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "19640e7ecd065c4d5c40ad2e27021c3b", + "name": "isort", + "sha256": "3af28d01644311d1250491e9b67697c0f5c8d7a864a7b69be06bf9f878979405", + "size": 138555, + "subdir": "linux-64", + "timestamp": 1594851245432, + "version": "5.0.9" + }, + "isort-5.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "7e015c6aedb24fc1fb4af3e3fe2aa437", + "name": "isort", + "sha256": "aeb3f05a0bba3fc57a5a401f1fd961ef50919f723a1e44d79db299a8eb96526f", + "size": 145298, + "subdir": "linux-64", + "timestamp": 1596472834478, + "version": "5.2.2" + }, + "isort-5.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "eb8c613dcb6276d47884b0fee7538e63", + "name": "isort", + "sha256": "d9aeb8f10d7ace2694bbc4ff4c1104b85cb10437dedebcac449fb6978854c38c", + "size": 145083, + "subdir": "linux-64", + "timestamp": 1596472854356, + "version": "5.2.2" + }, + "isort-5.2.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "e1e6bb7f974376bc7ad7d08eb0b3aabe", + "name": "isort", + "sha256": "204b8e7bd1a72cece7d9863137d5e9d92be9165f1b2ef671262ab37640e3ab5e", + "size": 145598, + "subdir": "linux-64", + "timestamp": 1596472870493, + "version": "5.2.2" + }, + "isort-5.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "9ecebf21a3d735f4fa637525bc1562bb", + "name": "isort", + "sha256": "f50aa1fb49496baa4979732cf9032b13a1a4b3b5674f308617dede61b28198e8", + "size": 151134, + "subdir": "linux-64", + "timestamp": 1601750471788, + "version": "5.3.2" + }, + "isort-5.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "0aa81a5423ef2cb1364b67eaa2c1b08f", + "name": "isort", + "sha256": "ec4946be58d51a10d91ad00f6dfd2a24ffbd4cd62d368af7b7473cf623b10954", + "size": 143502, + "subdir": "linux-64", + "timestamp": 1596868939877, + "version": "5.3.2" + }, + "isort-5.3.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "4fbff358a634e2fb7eac1d51c91a9302", + "name": "isort", + "sha256": "2d4264ba71fbed8d6a1e821c59e7e4070ba7c473331161b56036d3edd16283c8", + "size": 151534, + "subdir": "linux-64", + "timestamp": 1601750516287, + "version": "5.3.2" + }, + "isort-5.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "c7da07cc0f573703a0efc7be8a767450", + "name": "isort", + "sha256": "914156b3123e7130bee0731f0e2373e805362c9376f9d3d18aceff11f3efb9f8", + "size": 151774, + "subdir": "linux-64", + "timestamp": 1601749738514, + "version": "5.4.1" + }, + "isort-5.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "3764ba4ab517ca7c4268937a37d38eef", + "name": "isort", + "sha256": "419c27739c1974ab3b72835a19143bfda5b6ed191456587477eb431b174ee490", + "size": 144141, + "subdir": "linux-64", + "timestamp": 1597337619604, + "version": "5.4.1" + }, + "isort-5.4.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "323723424862ddf45f060438980329bf", + "name": "isort", + "sha256": "91ff88e52afba664168876e9e25b4a5197a928dcbf03917f865da57dc384719e", + "size": 152285, + "subdir": "linux-64", + "timestamp": 1601749721984, + "version": "5.4.1" + }, + "isort-5.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "48b301c7cbb6458016b0b3f49dd7a784", + "name": "isort", + "sha256": "e04e263a16572f82f79140e725b5a0b7b34f2768887375f2828b1fe2f668d317", + "size": 151988, + "subdir": "linux-64", + "timestamp": 1598376251679, + "version": "5.4.2" + }, + "isort-5.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "1c42a13685e4cf90dbf521aa357ac420", + "name": "isort", + "sha256": "166bae3a34cb9cb7b7a299789bc3cccacfe5473fdca44e54d0e7b55feaf6d93c", + "size": 144207, + "subdir": "linux-64", + "timestamp": 1597597621739, + "version": "5.4.2" + }, + "isort-5.4.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "569c8f786872de14ac83abf6a116e614", + "name": "isort", + "sha256": "fc078d78d0172753cb5c93e3f7b81b929327aff986326efdbb0850e5f92972f2", + "size": 152356, + "subdir": "linux-64", + "timestamp": 1598376233810, + "version": "5.4.2" + }, + "isort-5.5.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "786f312c0d82bae40dc57c136d1969cc", + "name": "isort", + "sha256": "90e68476d155a34f31b614d2339de601728f94ec3a5b786c55fb51a25c1505df", + "size": 154513, + "subdir": "linux-64", + "timestamp": 1600485493604, + "version": "5.5.2" + }, + "isort-5.5.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "771c16f35d69d3109bac3db1b8b59dfa", + "name": "isort", + "sha256": "be5d9a5cc115ad89d757859bcc9612ad3d3381d2dcbb31746c7b83fe0db7d415", + "size": 154247, + "subdir": "linux-64", + "timestamp": 1600480687403, + "version": "5.5.2" + }, + "isort-5.5.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "f6142973cf74ed22816c3997f794cb99", + "name": "isort", + "sha256": "dcdf81f3e6d129cb359b3f71888b58a4f573338f3612043689be86bb52a13a56", + "size": 154914, + "subdir": "linux-64", + "timestamp": 1600480672098, + "version": "5.5.2" + }, + "isort-5.5.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "74389b2dfb1207490a230b9412c0d322", + "name": "isort", + "sha256": "3dedbd21e32863699a3ed7feac3598efbd35cb9b0f57532a1947f7f0b8257fc9", + "size": 147500, + "subdir": "linux-64", + "timestamp": 1600701732730, + "version": "5.5.3" + }, + "isort-5.5.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "3b10ff3f135e5072b554791ca5b6e21a", + "name": "isort", + "sha256": "a8d3a30a415f236bfd22dc3b9f0b7f56ccfbcfbdcd034172c3480de5af8aae38", + "size": 147319, + "subdir": "linux-64", + "timestamp": 1600701717448, + "version": "5.5.3" + }, + "isort-5.5.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "f3c65cb0ad4f02233965575df4325fab", + "name": "isort", + "sha256": "9661128c688b5e40e425ff5ee368669450da6a52be1a3bc2c75270ea40465e7b", + "size": 147921, + "subdir": "linux-64", + "timestamp": 1600701683645, + "version": "5.5.3" + }, + "isort-5.5.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "a0c351aab6ce61f453162dddf952a9dc", + "name": "isort", + "sha256": "136e8cb8355bec28fb965cb44b9d3db4e975b1274c8e61e562ae2ed58e0cb3f5", + "size": 147422, + "subdir": "linux-64", + "timestamp": 1601490247645, + "version": "5.5.4" + }, + "isort-5.5.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "ec83de199b042f0c6fcf9c48e4de295e", + "name": "isort", + "sha256": "98b58d17a439df33c80fd23f89c327e8824c5cb592143f02a063731c63d436ce", + "size": 147254, + "subdir": "linux-64", + "timestamp": 1601490245902, + "version": "5.5.4" + }, + "isort-5.5.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "5b07fd231cd8345bf86fee91ab79fd88", + "name": "isort", + "sha256": "20d2640af23295b0fbeaed83dd44830a09f508c2a70fc2e1413229e5c9d1e5fd", + "size": 147876, + "subdir": "linux-64", + "timestamp": 1601490259926, + "version": "5.5.4" + }, + "isort-5.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "4326b659e94f357f972cefcfd0c9797d", + "name": "isort", + "sha256": "eff859e140a329c2929aacfcf138d14af288aa131bf8c11259632ac62f40812d", + "size": 151485, + "subdir": "linux-64", + "timestamp": 1602258739807, + "version": "5.6.1" + }, + "isort-5.6.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "62e4c66448c0a4b4eeb3b849b985a56c", + "name": "isort", + "sha256": "a193fe25e261e7101bd1fa4fcb2f0e22fc1e47afac427df4f95b720529a42400", + "size": 151317, + "subdir": "linux-64", + "timestamp": 1602258714384, + "version": "5.6.1" + }, + "isort-5.6.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "8e28677410efc181657e1a9737af5e59", + "name": "isort", + "sha256": "2751d82e5d1efc8f8e1ec2fa85ab67b55b1fbcbc5d4b8841d31fa38f88622958", + "size": 152062, + "subdir": "linux-64", + "timestamp": 1602258705919, + "version": "5.6.1" + }, + "itsdangerous-0.24-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "84253acc864d1220658f852e6fa4ad40", + "name": "itsdangerous", + "sha256": "2f4b68e226a94552ad71eacdd6d0b55aad47bb90115488259294c1f38a9a058a", + "size": 20438, + "subdir": "linux-64", + "timestamp": 1530771705041, + "version": "0.24" + }, + "itsdangerous-0.24-py27hb8295c1_1.tar.bz2": { + "build": "py27hb8295c1_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b2df61b0f2dec6439d065a5fb4bd4892", + "name": "itsdangerous", + "sha256": "6a6d1c92e297a403aca24731f60d37d1ee2362fc90c2fd957f697196498a12d3", + "size": 20243, + "subdir": "linux-64", + "timestamp": 1505740319564, + "version": "0.24" + }, + "itsdangerous-0.24-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "add4fb9220ed1b0027acbd18ff47a081", + "name": "itsdangerous", + "sha256": "acf46b9773e85fe908dc3c0a64d8e1b11f456f41d6e4207e18e6f95416ff76b1", + "size": 21103, + "subdir": "linux-64", + "timestamp": 1534804365488, + "version": "0.24" + }, + "itsdangerous-0.24-py35h7c46880_1.tar.bz2": { + "build": "py35h7c46880_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3d42368486991bb72c6e6e1059c43b9c", + "name": "itsdangerous", + "sha256": "fff001543b1f484e4cb306745ad27e60dc9a8f210f89965e3209b76a223cc3c3", + "size": 20833, + "subdir": "linux-64", + "timestamp": 1505740331441, + "version": "0.24" + }, + "itsdangerous-0.24-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fd9253d74bc6dc993eb635c9ce0a9c28", + "name": "itsdangerous", + "sha256": "183920d405a2f6a7d7807fd3b0643232bfa033a4ecfb081bd2967537ddf21e9b", + "size": 20984, + "subdir": "linux-64", + "timestamp": 1530771726429, + "version": "0.24" + }, + "itsdangerous-0.24-py36h93cc618_1.tar.bz2": { + "build": "py36h93cc618_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8411601fdb2def4fcd996b15890cc617", + "name": "itsdangerous", + "sha256": "6f0d7dbe8c200cc66b914b7ee5e76d59e3cf8d91d3bc29277cd17e35d4f5a12a", + "size": 20838, + "subdir": "linux-64", + "timestamp": 1505740343513, + "version": "0.24" + }, + "itsdangerous-0.24-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b579c59f7653bf2ae09607a90f128b18", + "name": "itsdangerous", + "sha256": "6496efb78783d139f110855a939623b5cc20bca671d687858eab3250efadf328", + "size": 21046, + "subdir": "linux-64", + "timestamp": 1530771684001, + "version": "0.24" + }, + "itsdangerous-1.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5285de8cf8ada6ec886dde118343bd7c", + "name": "itsdangerous", + "sha256": "1cdd64446bba953b038a3abc9cb1d365e643e59ab733def0acc0fb618c207ebd", + "size": 24131, + "subdir": "linux-64", + "timestamp": 1540238063568, + "version": "1.0.0" + }, + "itsdangerous-1.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "661ef9d474679a388eb7fcedd2ff4fad", + "name": "itsdangerous", + "sha256": "fcf66ce0b7445c50c0ffbcc2602e0e69dbdedf6c3c1f3c14b794a1452f0bafa3", + "size": 24713, + "subdir": "linux-64", + "timestamp": 1540238139090, + "version": "1.0.0" + }, + "itsdangerous-1.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5361d5c3623f877c47fdf50961af6788", + "name": "itsdangerous", + "sha256": "b4d1333f3d89274349766dadbf34e3ee0baf6623ef8a28d349e533327c77d71e", + "size": 24756, + "subdir": "linux-64", + "timestamp": 1540238127817, + "version": "1.0.0" + }, + "itsdangerous-1.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f8a6a086ecac2dd6ef3c1dc56a6b70af", + "name": "itsdangerous", + "sha256": "835951e0953ed7023282c4f605cba249d8e01f3ac84e834e3f733d2e80b41133", + "size": 26534, + "subdir": "linux-64", + "timestamp": 1541025216123, + "version": "1.1.0" + }, + "itsdangerous-1.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ae80dd11a821dbcb457f59ee425ac429", + "name": "itsdangerous", + "sha256": "5b532aaf1304f737fa3a1e11429bf25a222fbe731d1ee357077f849c53a481c2", + "size": 27129, + "subdir": "linux-64", + "timestamp": 1541025205968, + "version": "1.1.0" + }, + "itsdangerous-1.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4e8e4d299c21bbcf5a8081ade37d4440", + "name": "itsdangerous", + "sha256": "f9966597feaf298bb7e4b44f27797d877fbb3ef25bf36e486c2eca37cef79b6a", + "size": 27189, + "subdir": "linux-64", + "timestamp": 1541025206057, + "version": "1.1.0" + }, + "jaeger-client-3.13.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "opentracing", + "python >=2.7,<2.8.0a0", + "threadloop", + "thrift", + "tornado" + ], + "license": "MIT", + "md5": "587ed829537eae646aafa95d63559aa5", + "name": "jaeger-client", + "sha256": "36f66361a57b0a41f950c9108c914eb8c4457a0624d4bbb9d62f1a7162d881e9", + "size": 79070, + "subdir": "linux-64", + "timestamp": 1545418711428, + "version": "3.13.0" + }, + "jaeger-client-3.13.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "opentracing", + "python >=3.6,<3.7.0a0", + "threadloop", + "thrift", + "tornado" + ], + "license": "MIT", + "md5": "4e2454a9cec384b0cb5f0b51839833d5", + "name": "jaeger-client", + "sha256": "e3c55b61c99f0c52beea59f5814d5e405c7691e1b7a087c7b17011cf72399997", + "size": 81480, + "subdir": "linux-64", + "timestamp": 1545418733982, + "version": "3.13.0" + }, + "jaeger-client-3.13.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "opentracing", + "python >=3.7,<3.8.0a0", + "threadloop", + "thrift", + "tornado" + ], + "license": "MIT", + "md5": "33f4450e015b9805f069b719ba428dfe", + "name": "jaeger-client", + "sha256": "5d77938d19d6925025d49a6301a57b090140e84e141c5c45c423210737098ee0", + "size": 81496, + "subdir": "linux-64", + "timestamp": 1545418744799, + "version": "3.13.0" + }, + "jaeger-client-4.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=2.7,<2.8.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "61d30d18b769753069b43af539bd9c2c", + "name": "jaeger-client", + "sha256": "754ad3ae606616628b2d5723598df9894ca40019531704ffb2a20f2cb53eb7a0", + "size": 82218, + "subdir": "linux-64", + "timestamp": 1569424453797, + "version": "4.1.0" + }, + "jaeger-client-4.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.6,<3.7.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "fc065c0ce196ab6e8967a88bcc7e445e", + "name": "jaeger-client", + "sha256": "5d91e81f5f81e9483f91b8dfdb5d1b4f88774022a2daf2c5ba53fc4538df30d1", + "size": 84644, + "subdir": "linux-64", + "timestamp": 1569424449014, + "version": "4.1.0" + }, + "jaeger-client-4.1.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.6,<3.7.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "8476d9c4acff46881134dcf5e16054d8", + "name": "jaeger-client", + "sha256": "d9b88c29a70bab3dd82105d8a96bb41358e35e4bb85199a1de6fe3484bff7304", + "size": 84939, + "subdir": "linux-64", + "timestamp": 1613485555983, + "version": "4.1.0" + }, + "jaeger-client-4.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.7,<3.8.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "711307d05a952193efdbfc6c05ad4bb4", + "name": "jaeger-client", + "sha256": "d70b4aa338dd7940d9f88c42698859d22a27853f09635972d448b5ae39d491e1", + "size": 84449, + "subdir": "linux-64", + "timestamp": 1569424453439, + "version": "4.1.0" + }, + "jaeger-client-4.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.7,<3.8.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "60b4620cd2545c25ea53a49c1d13cf90", + "name": "jaeger-client", + "sha256": "4bc63a1ceafc3479a0a76c7d7892ef66b068c2b3502f500103518c2dade9e1dc", + "size": 84933, + "subdir": "linux-64", + "timestamp": 1613485539519, + "version": "4.1.0" + }, + "jaeger-client-4.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.8,<3.9.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "488950b008459ec845ebda52a876e740", + "name": "jaeger-client", + "sha256": "a2d218b421cdd139a458f3e5d720a66bbd1a418567125e2b129d2e64a96ac676", + "size": 84674, + "subdir": "linux-64", + "timestamp": 1574158004797, + "version": "4.1.0" + }, + "jaeger-client-4.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.8,<3.9.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "de498d5a994acaf52413caa80c631856", + "name": "jaeger-client", + "sha256": "802a98a80bfe25f565c526b8aa3022d736bb546ff858592a868910b0b5f718e7", + "size": 85466, + "subdir": "linux-64", + "timestamp": 1613485162175, + "version": "4.1.0" + }, + "jaeger-client-4.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.9,<3.10.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "76e913fb7fd12d3fbff7b7d502142955", + "name": "jaeger-client", + "sha256": "c59b12a656722e5a8938ca7f4380d882e01b5fb9d3ff43fcecffc27cb28c339e", + "size": 85474, + "subdir": "linux-64", + "timestamp": 1613485538339, + "version": "4.1.0" + }, + "jaeger-client-4.4.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.6,<3.7.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "230a71968ccbd44bf3a0267824e603da", + "name": "jaeger-client", + "sha256": "389b2bb784e930c6422c46ab11c74feff223686822dd7f046f2534cd37e34a28", + "size": 83969, + "subdir": "linux-64", + "timestamp": 1613502271842, + "version": "4.4.0" + }, + "jaeger-client-4.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.7,<3.8.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "bf1d0b8b499c4a7cd452b4342092538f", + "name": "jaeger-client", + "sha256": "8a2ed39d9433d791fbd16d57dd4c13994c779e5a12702f6569ceb14fd4648c4d", + "size": 84257, + "subdir": "linux-64", + "timestamp": 1613502285386, + "version": "4.4.0" + }, + "jaeger-client-4.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.8,<3.9.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "63818ffd2d3adea5026cf79b51d3d6eb", + "name": "jaeger-client", + "sha256": "0f8c2015cbfde860b49b76ba8ae10fdc0d306a719f944e96baa11f4687745794", + "size": 84820, + "subdir": "linux-64", + "timestamp": 1613501645558, + "version": "4.4.0" + }, + "jaeger-client-4.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.9,<3.10.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "0c0b0e03057ddfefa1913b1ffa485180", + "name": "jaeger-client", + "sha256": "6a3588ddbf3801de14e06c8d6b1a6566971eccc4b9dc38f7008d7bd44fb047fa", + "size": 84934, + "subdir": "linux-64", + "timestamp": 1613502014820, + "version": "4.4.0" + }, + "jaeger-client-4.5.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.6,<3.7.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "md5": "5ceaf7a15db72a8e7e27ef74164de94a", + "name": "jaeger-client", + "sha256": "11a5a54414aa8d2552f552aedcfcacd6022887bd499b7187bad428cc5c4a77ce", + "size": 88491, + "subdir": "linux-64", + "timestamp": 1621330381064, + "version": "4.5.0" + }, + "jaeger-client-4.5.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.7,<3.8.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "md5": "4dfc95c9f63d5f73ca94cac08c2fbac9", + "name": "jaeger-client", + "sha256": "bd2ae7acbf55eed92231757e49e119363dfc85d0268e276ff76d29d7e6a44c30", + "size": 88514, + "subdir": "linux-64", + "timestamp": 1621334977590, + "version": "4.5.0" + }, + "jaeger-client-4.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.8,<3.9.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "md5": "ce6c92bae764071421c28d9f9c80b0a9", + "name": "jaeger-client", + "sha256": "44862521835ccf135f0597750897ce2f0789bdbc641eb0017c29282076ba4c29", + "size": 89076, + "subdir": "linux-64", + "timestamp": 1621334968640, + "version": "4.5.0" + }, + "jaeger-client-4.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.9,<3.10.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "md5": "bb005f1f157efdc0e17022357d92db35", + "name": "jaeger-client", + "sha256": "32f3dc52c3f19a28b410548f730e522f064b9623a41e702c677b57eb23a9f7c9", + "size": 89111, + "subdir": "linux-64", + "timestamp": 1621334641952, + "version": "4.5.0" + }, + "jaeger-client-4.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.10,<3.11.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d80bd12d4d730f5b3c68985cde3e57be", + "name": "jaeger-client", + "sha256": "d8ba23d9ae59f08e8be4bf567bdd011c5e5a67b6cffecae245d1ce00941f0a75", + "size": 86666, + "subdir": "linux-64", + "timestamp": 1640809478751, + "version": "4.6.0" + }, + "jaeger-client-4.6.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.11,<3.12.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "16de8eab36fcea7217bdb7aa2ce235eb", + "name": "jaeger-client", + "sha256": "df3da4b70e0f18a1e57b889d3e5ad1a776e01135c125c15849b9b8241f5dc31d", + "size": 115094, + "subdir": "linux-64", + "timestamp": 1676852937188, + "version": "4.6.0" + }, + "jaeger-client-4.6.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.6,<3.7.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9c6dcc4ee4baed4382ed9146616676f9", + "name": "jaeger-client", + "sha256": "778075c187058b9bb33c9e63cd14b140572494680f3910b6b82cbe51330c17d3", + "size": 84525, + "subdir": "linux-64", + "timestamp": 1627065877796, + "version": "4.6.0" + }, + "jaeger-client-4.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.7,<3.8.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "be2527110ab8da5cb4a1864822de02a5", + "name": "jaeger-client", + "sha256": "455b6465c8b4f1d693deb4aecaae25c7fe60b48d5e899b70c06ca337288dd06e", + "size": 84723, + "subdir": "linux-64", + "timestamp": 1627065864628, + "version": "4.6.0" + }, + "jaeger-client-4.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.8,<3.9.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aee15b2845c21f619f4835fad0de36cd", + "name": "jaeger-client", + "sha256": "d82fc930aa78825ac62c82f9118e2b399e824772f11acea76c4adae37503e47d", + "size": 85228, + "subdir": "linux-64", + "timestamp": 1627065856540, + "version": "4.6.0" + }, + "jaeger-client-4.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.9,<3.10.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d4ed41865ca0833235ef4780fbb12c41", + "name": "jaeger-client", + "sha256": "22e29135b15801cdec68c328bf5e02a39be1f0fa3da688d6405d514144cbda5c", + "size": 85338, + "subdir": "linux-64", + "timestamp": 1627058395580, + "version": "4.6.0" + }, + "jansson-2.14-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "753e12a965baaebbd528cef54eb82fc8", + "name": "jansson", + "sha256": "079aadbe117fcae949471da4613425286b228050e25da640ea5a93382a4de203", + "size": 38355, + "subdir": "linux-64", + "timestamp": 1677685765389, + "version": "2.14" + }, + "jaraco.classes-1.4.3-py27h6fce145_0.tar.bz2": { + "build": "py27h6fce145_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c42707697d0fabf05979d3790712ca1", + "name": "jaraco.classes", + "sha256": "283ecc95e0c513343fbf6ef8242838ac8225778c80b04a55a2c5def77b8395b0", + "size": 8974, + "subdir": "linux-64", + "timestamp": 1511702977991, + "version": "1.4.3" + }, + "jaraco.classes-1.4.3-py35h46561aa_0.tar.bz2": { + "build": "py35h46561aa_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d0eb662841140b0fefa8709af7bcbde", + "name": "jaraco.classes", + "sha256": "234bc06f76b2dc3ad984c5704f39820b9c686582df1b98b32c50bd1e60d29f0c", + "size": 9148, + "subdir": "linux-64", + "timestamp": 1511702976581, + "version": "1.4.3" + }, + "jaraco.classes-1.4.3-py36h1d0d791_0.tar.bz2": { + "build": "py36h1d0d791_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2b8f510cd27119499df34de56bf6425", + "name": "jaraco.classes", + "sha256": "7378b110313275619108fd040ae77ad3e733753c54c38798c02c97e16d8dc23d", + "size": 9137, + "subdir": "linux-64", + "timestamp": 1511702980783, + "version": "1.4.3" + }, + "jaraco.classes-1.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6d2901a44a9e77df61edec29a4ab1a1", + "name": "jaraco.classes", + "sha256": "9090b8e686f5c0ad469fd42276c99ef66d9b49d57c117bc3056f18b53bd1609d", + "size": 9948, + "subdir": "linux-64", + "timestamp": 1528172318869, + "version": "1.5" + }, + "jaraco.classes-1.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0ae8ed9ae38549d3dad4724c63aafb4a", + "name": "jaraco.classes", + "sha256": "c88775c0a96afe5aa7d9155a9849c620a63d165aa1c86c75aa1ace9eafeb172e", + "size": 10102, + "subdir": "linux-64", + "timestamp": 1528172341564, + "version": "1.5" + }, + "jaraco.classes-1.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "70323b53698c41521c24fb5d10c0291d", + "name": "jaraco.classes", + "sha256": "43013876fc0195ff2e757b7c92e1232b3b6cf54e09f9995b1fb118829f04b55b", + "size": 10125, + "subdir": "linux-64", + "timestamp": 1528172299585, + "version": "1.5" + }, + "jaraco.classes-1.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f7a33d8cfa4777cc55a6318ade01e70", + "name": "jaraco.classes", + "sha256": "9824b9b9ae1ffbddb8b0707b3fd6fb9c9d2a3125c6659d714c0ec9ebe3530f3b", + "size": 10100, + "subdir": "linux-64", + "timestamp": 1530897945231, + "version": "1.5" + }, + "jaraco.functools-1.20-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache >=1.0.3", + "more-itertools", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "744293f1ea7619dbae50084a1bc40f5b", + "name": "jaraco.functools", + "sha256": "7b0f6fdad18504fba504291e278af17da6c4a654050584d2ac89f42bf4ab612f", + "size": 13209, + "subdir": "linux-64", + "timestamp": 1539721892536, + "version": "1.20" + }, + "jaraco.functools-1.20-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa40199897f3adfd4ade4582061e87f1", + "name": "jaraco.functools", + "sha256": "fc8622512e28261ccdf4ba7befa8468acdf9b87b744782e86653d05d7acfae27", + "size": 13451, + "subdir": "linux-64", + "timestamp": 1539721927085, + "version": "1.20" + }, + "jaraco.functools-1.20-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "more-itertools", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4616167f2eea680b6b135d4bf41522c5", + "name": "jaraco.functools", + "sha256": "c6d4ac946cd0ad05ba54cbc66176f42f35da2b709ed5fb3476327bdd47093c11", + "size": 13485, + "subdir": "linux-64", + "timestamp": 1539721907690, + "version": "1.20" + }, + "jaraco.functools-2.0-py27_1000.tar.bz2": { + "build": "py27_1000", + "build_number": 1000, + "depends": [ + "backports.functools_lru_cache >=1.0.3", + "more-itertools", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "68da12711de90393a50ef0e786f230be", + "name": "jaraco.functools", + "sha256": "6cf94cab62da98b42b355b081981c92ee4d0ac707e6f62511785b7cf96447c5c", + "size": 14486, + "subdir": "linux-64", + "timestamp": 1552437074285, + "version": "2.0" + }, + "jaraco.functools-2.0-py36_1000.tar.bz2": { + "build": "py36_1000", + "build_number": 1000, + "depends": [ + "more-itertools", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "397adf6c7cc2309f927bc6cb98766cad", + "name": "jaraco.functools", + "sha256": "f9e497e8cce07b0dc879c3116f9e76b5992cc8550306e343db103215d8f2de9b", + "size": 14783, + "subdir": "linux-64", + "timestamp": 1552437101985, + "version": "2.0" + }, + "jaraco.functools-2.0-py37_1000.tar.bz2": { + "build": "py37_1000", + "build_number": 1000, + "depends": [ + "more-itertools", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "542ca0c18f1fb70a37b4810aeaec8a53", + "name": "jaraco.functools", + "sha256": "6e3095330ab1e792f01549f572317d7d09055714516b31ea1ad19453ebb20d3a", + "size": 14769, + "subdir": "linux-64", + "timestamp": 1552437059106, + "version": "2.0" + }, + "jaraco.functools-2.0-py38_1000.tar.bz2": { + "build": "py38_1000", + "build_number": 1000, + "depends": [ + "more-itertools", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7a23380746a3d16d825af83ad384099", + "name": "jaraco.functools", + "sha256": "37055ae91b0d08e502df0d6c4731db3da34e348b869ba60a78328b97bd7d2774", + "size": 14254, + "subdir": "linux-64", + "timestamp": 1574158025486, + "version": "2.0" + }, + "jaraco.text-3.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib_resources", + "jaraco.functools", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce9b482740e83df16ad6a3e175abb8a5", + "name": "jaraco.text", + "sha256": "3d3f7c7edc2ccdd4b2c0bd079680177e3f23796cb100e08d20294d49b84d84bf", + "size": 16678, + "subdir": "linux-64", + "timestamp": 1585058393511, + "version": "3.2.0" + }, + "jaraco.text-3.2.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "importlib_resources", + "jaraco.functools", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "78328550f41d89816d3aa251aec5d55b", + "name": "jaraco.text", + "sha256": "f5b2e60fd12894eb72999ba488efdf95bdc6fb61a7075f2fba9fec293a483447", + "size": 16127, + "subdir": "linux-64", + "timestamp": 1601490335368, + "version": "3.2.0" + }, + "jaraco.text-3.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1220e8b4dd95abb24829a97f54ea0ffc", + "name": "jaraco.text", + "sha256": "6dabff3d274ff94ab32c056932df313cc4e21489bccf51d727bac0e3a695fea7", + "size": 16732, + "subdir": "linux-64", + "timestamp": 1585053247704, + "version": "3.2.0" + }, + "jaraco.text-3.2.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a57eb97dfe542fcb87e3de367f64e3c", + "name": "jaraco.text", + "sha256": "31f621030e4325f7892e26d3dc5c0fc058c3bb9a733c74a815ca45f066a18e07", + "size": 15308, + "subdir": "linux-64", + "timestamp": 1594363002191, + "version": "3.2.0" + }, + "jaraco.text-3.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbb2b537c824b52cca05a6b6d4a1a61c", + "name": "jaraco.text", + "sha256": "6bd33c8285e9e0f604115438d36debb1afc68c80cd1e7cb06a3d730899f0fc4b", + "size": 16750, + "subdir": "linux-64", + "timestamp": 1585053273240, + "version": "3.2.0" + }, + "jaraco.text-3.2.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1739104df55103ae71fb5dde50f55827", + "name": "jaraco.text", + "sha256": "cc10393067384b06874653516f959440f1edc7cb3328a09d5d7724e1e1e4648a", + "size": 16186, + "subdir": "linux-64", + "timestamp": 1601490300815, + "version": "3.2.0" + }, + "jaraco.text-3.4.0-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "importlib_resources", + "jaraco.functools", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "07a5d4aaded9f8f93bc06912c5776a3b", + "name": "jaraco.text", + "sha256": "a9791657bc8b937a379f4469fe2b51f04398255a71b71c77274b368d6ad48a69", + "size": 16484, + "subdir": "linux-64", + "timestamp": 1609093480849, + "version": "3.4.0" + }, + "jaraco.text-3.4.0-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b286dd4829c5ccbcfc7f69b7159ab77b", + "name": "jaraco.text", + "sha256": "f157b2fcb9894003304b3a3b7b34d3ab40661223289e66a9acc57f4199bff4c6", + "size": 16485, + "subdir": "linux-64", + "timestamp": 1609093459039, + "version": "3.4.0" + }, + "jaraco.text-3.4.0-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3b7601ba9394d707be1f65e33505343", + "name": "jaraco.text", + "sha256": "ecc94daf942a07b011d49d6b544fcfb2ad4451b6dcfde5faecaf4cf805c03e55", + "size": 16535, + "subdir": "linux-64", + "timestamp": 1609093482333, + "version": "3.4.0" + }, + "jaraco.text-3.4.0-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d45ac469dcd84578bfc360c6246e2f7", + "name": "jaraco.text", + "sha256": "10adf3be5238034b9829443f8f4e68397956ae80dfe06e49708dbc29bf7f964a", + "size": 16534, + "subdir": "linux-64", + "timestamp": 1609093478999, + "version": "3.4.0" + }, + "jaraco.text-3.5.0-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "importlib_resources", + "jaraco.functools", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "669a95369488e5bf855520f3b9ab5556", + "name": "jaraco.text", + "sha256": "8c0c8dbd03376c8b24ed242a05cc11713c2112803ec8c8daec9099c8e4d28e4c", + "size": 16157, + "subdir": "linux-64", + "timestamp": 1613502409045, + "version": "3.5.0" + }, + "jaraco.text-3.5.0-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5a0c6d42cf3c0827ac4b7d69bde9ab99", + "name": "jaraco.text", + "sha256": "ac8cf61512a7a5097e5d1aceb26371048735bdd5a7d8d98288ca819657d18e92", + "size": 16180, + "subdir": "linux-64", + "timestamp": 1613502400289, + "version": "3.5.0" + }, + "jaraco.text-3.5.0-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f7bd2d0c9087a930181f47629f2192b", + "name": "jaraco.text", + "sha256": "26b398d5b226af2fc00b87633bf708ad775d2ed4d4310d08afb0f69ba12fc057", + "size": 16225, + "subdir": "linux-64", + "timestamp": 1613501768092, + "version": "3.5.0" + }, + "jaraco.text-3.5.0-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dec539529f470b9e39d251a3274b4ce7", + "name": "jaraco.text", + "sha256": "0664d01f986fd88ba0a2fb3f3c8b66106414368ca8705d33704f7c0614ca5723", + "size": 16222, + "subdir": "linux-64", + "timestamp": 1613502402539, + "version": "3.5.0" + }, + "jaraco.text-3.5.1-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a7e84fb10a461c2c6c893014068a4e85", + "name": "jaraco.text", + "sha256": "cf5c47665ded252b4d398b7bf2d8843d720d28d32fcaec9b6ba4cea82a8c1aa0", + "size": 16384, + "subdir": "linux-64", + "timestamp": 1640791137719, + "version": "3.5.1" + }, + "jaraco.text-3.5.1-py311h06a4308_2.tar.bz2": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "664a60d4a2481e57775d26368a35d809", + "name": "jaraco.text", + "sha256": "41e9ef7cb4031a89055f3d5c7e53451b9cc94f2761b8b79e751e39733ae9f406", + "size": 19029, + "subdir": "linux-64", + "timestamp": 1676840015996, + "version": "3.5.1" + }, + "jaraco.text-3.5.1-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "importlib_resources", + "jaraco.functools", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9751f83f6b2dc0bf21a75885b578d69", + "name": "jaraco.text", + "sha256": "73e26761297659d1cfb7bc8de4abbfe0733540bcb3984d1928e2abe16b166750", + "size": 16010, + "subdir": "linux-64", + "timestamp": 1626445393969, + "version": "3.5.1" + }, + "jaraco.text-3.5.1-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc8f9beee1131dc926152b73713ae9e7", + "name": "jaraco.text", + "sha256": "ec6c97ec25686cf6276a70ac31ead5ad402485f1c6e2ed5219ed4d42b110048d", + "size": 16042, + "subdir": "linux-64", + "timestamp": 1626438312434, + "version": "3.5.1" + }, + "jaraco.text-3.5.1-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5965a03c74d3aa79e1aa4ae2c21637cd", + "name": "jaraco.text", + "sha256": "fa95b7e218f847b6233f7293ad927254425502825485257868254da0e3cb517f", + "size": 16064, + "subdir": "linux-64", + "timestamp": 1626445481180, + "version": "3.5.1" + }, + "jaraco.text-3.5.1-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a77697c1d817c948e487c63599a9594d", + "name": "jaraco.text", + "sha256": "1dcaa3651f9c776ec32f5bf8118ca4d0e50328e704f38986feea2fd4598f5ccc", + "size": 16061, + "subdir": "linux-64", + "timestamp": 1626445493892, + "version": "3.5.1" + }, + "jasper-1.900.1-hd497a04_4.tar.bz2": { + "build": "hd497a04_4", + "build_number": 4, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0" + ], + "license": "JasPer 2.0", + "md5": "91aebe1a7e7ebfdd279fef071b901a6a", + "name": "jasper", + "sha256": "3c8d78ff830d0720f5fb3b04463e95208909447fce9623cdd9c6709fa920d536", + "size": 286122, + "subdir": "linux-64", + "timestamp": 1512065615327, + "version": "1.900.1" + }, + "jasper-2.0.14-h07fcdf6_0.tar.bz2": { + "build": "h07fcdf6_0", + "build_number": 0, + "depends": [ + "freeglut >=2.8.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu >=9.0.0,<10.0a0" + ], + "license": "JasPer 2.0", + "md5": "a51228a853db8230dc280c657f48253f", + "name": "jasper", + "sha256": "522c667507f29eca7873064160d5dd9118e34c9f19d4f8f64b00fce50821c28e", + "size": 1184190, + "subdir": "linux-64", + "timestamp": 1520775456386, + "version": "2.0.14" + }, + "jasper-2.0.14-h07fcdf6_1.tar.bz2": { + "build": "h07fcdf6_1", + "build_number": 1, + "depends": [ + "freeglut >=3.0.0,<4.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu >=9.0.0,<10.0a0" + ], + "license": "JasPer 2.0", + "md5": "075ab4924c339de53eda9509f09aba56", + "name": "jasper", + "sha256": "b3d0893f424f519c7debd0855094383917fdf944e702cad605d77e28d14d1a44", + "size": 1183774, + "subdir": "linux-64", + "timestamp": 1527038694212, + "version": "2.0.14" + }, + "jasper-2.0.14-hd8c5072_2.tar.bz2": { + "build": "hd8c5072_2", + "build_number": 2, + "depends": [ + "freeglut >=3.0.0,<4.0a0", + "jpeg", + "libgcc-ng >=7.5.0", + "libglu >=9.0.0,<10.0a0" + ], + "license": "JasPer 2.0", + "md5": "3f9876cff47cc1cdeca4f41030c128ad", + "name": "jasper", + "sha256": "6e8a2a9d33b8f7ad4400cad5fa1e81f6dfcc39a08d2962bfd827169bf7a20337", + "size": 1222294, + "subdir": "linux-64", + "timestamp": 1633701200112, + "version": "2.0.14" + }, + "jax-0.3.25-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jaxlib >=0.3.22", + "numpy >=1.21,<2", + "opt_einsum", + "python >=3.10,<3.11.0a0", + "scipy >=1.5", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "d45e53455103addcf298bc0a0d74e5a7", + "name": "jax", + "sha256": "aa5c3d36d078307ae9e014ebfc50c85635e3f99289744f0d082f383915d09215", + "size": 2175610, + "subdir": "linux-64", + "timestamp": 1669936888469, + "version": "0.3.25" + }, + "jax-0.3.25-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jaxlib >=0.3.22", + "numpy >=1.21,<2", + "opt_einsum", + "python >=3.11,<3.12.0a0", + "scipy >=1.5", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ba0e6256f44ec13da297209c22dd698b", + "name": "jax", + "sha256": "126d3cf2eec4d7a2b6b0ff0e8bc8dfe35d8871c8e298f2e2be2c300258914711", + "size": 2982691, + "subdir": "linux-64", + "timestamp": 1676840034730, + "version": "0.3.25" + }, + "jax-0.3.25-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jaxlib >=0.3.22", + "numpy >=1.20,<2", + "opt_einsum", + "python >=3.7,<3.8.0a0", + "scipy >=1.5", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9fb49d2a540d9f3efde4cb807108b634", + "name": "jax", + "sha256": "268b390616d71c4cf6e7bc09c61a1e17e595d7d64bca9123ed3bbcaa3fcdb71f", + "size": 2142348, + "subdir": "linux-64", + "timestamp": 1669936928288, + "version": "0.3.25" + }, + "jax-0.3.25-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jaxlib >=0.3.22", + "numpy >=1.20,<2", + "opt_einsum", + "python >=3.8,<3.9.0a0", + "scipy >=1.5", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "51428c786dd34278a9276e84f1092b5a", + "name": "jax", + "sha256": "ee05441c9e8169391d61dbe4af7877bf9fbd3d92a9ef05f2ebdc44474bb146e3", + "size": 2157182, + "subdir": "linux-64", + "timestamp": 1669937003072, + "version": "0.3.25" + }, + "jax-0.3.25-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jaxlib >=0.3.22", + "numpy >=1.20,<2", + "opt_einsum", + "python >=3.9,<3.10.0a0", + "scipy >=1.5", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "72175862df263201fde4fb2c491593ea", + "name": "jax", + "sha256": "9eb372c3d933cb8b00e712d7e5bbe39b322e72d85c5cba79651927b82cea733c", + "size": 2157269, + "subdir": "linux-64", + "timestamp": 1669936965684, + "version": "0.3.25" + }, + "jax-jumpy-0.2.0-py310h2f386ee_0.tar.bz2": { + "build": "py310h2f386ee_0", + "build_number": 0, + "constrains": [ + "jax >=0.3.24", + "jaxlib >=0.3.24" + ], + "depends": [ + "numpy >=1.18.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b2c4de2effdb69e582f8e1570e91db58", + "name": "jax-jumpy", + "sha256": "9e673cdf6fbbd5bbac031d608037b5e3bb1538345c34ed9e15b6e7a5be2dccc9", + "size": 23574, + "subdir": "linux-64", + "timestamp": 1677830303948, + "version": "0.2.0" + }, + "jax-jumpy-0.2.0-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "constrains": [ + "jax >=0.3.24", + "jaxlib >=0.3.24" + ], + "depends": [ + "numpy >=1.18.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "47ba94cf72eb49b54c315c624256d906", + "name": "jax-jumpy", + "sha256": "9985632334e955c465155277c2ff4c6133929cf3a95641e6e11e71ec9aec5c97", + "size": 23382, + "subdir": "linux-64", + "timestamp": 1677830267392, + "version": "0.2.0" + }, + "jax-jumpy-0.2.0-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "constrains": [ + "jax >=0.3.24", + "jaxlib >=0.3.24" + ], + "depends": [ + "numpy >=1.18.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a8ee56fb20d9bd5dbec300d58df09fcc", + "name": "jax-jumpy", + "sha256": "03b64ca63f632f987f13db549d1d70eebadb3b9901cb2c15dd44cdafe9de49c3", + "size": 23389, + "subdir": "linux-64", + "timestamp": 1677830232829, + "version": "0.2.0" + }, + "jaxlib-0.3.25-py310h6a678d5_1.tar.bz2": { + "build": "py310h6a678d5_1", + "build_number": 1, + "constrains": [ + "jax >=0.3.25" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<2", + "python >=3.10,<3.11.0a0", + "scipy >=1.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "be99dac8f71fe43fdb58c81940a0f356", + "name": "jaxlib", + "sha256": "11d804cc4e90dd9fee30c2a09490baabbf372e83f346473449243eb249b1642a", + "size": 44098087, + "subdir": "linux-64", + "timestamp": 1669917536637, + "version": "0.3.25" + }, + "jaxlib-0.3.25-py311h6a678d5_2.tar.bz2": { + "build": "py311h6a678d5_2", + "build_number": 2, + "constrains": [ + "jax >=0.3.25" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<2", + "python >=3.11,<3.12.0a0", + "scipy >=1.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0d46c1ac3127625768720fd8c4aea3d2", + "name": "jaxlib", + "sha256": "f8d2caf11f905e362d1401d5a184b2a6428e0f483f7a6fd75690ec2840bc5830", + "size": 44127595, + "subdir": "linux-64", + "timestamp": 1676836981586, + "version": "0.3.25" + }, + "jaxlib-0.3.25-py37h6a678d5_1.tar.bz2": { + "build": "py37h6a678d5_1", + "build_number": 1, + "constrains": [ + "jax >=0.3.25" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<2", + "python >=3.7,<3.8.0a0", + "scipy >=1.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dc66558cf40ed3dae64fbc4efaed3a86", + "name": "jaxlib", + "sha256": "f4406f16f00e5f5a16e5f68a4dd0d4539bc2f0275674fe6307c713307f2487f2", + "size": 44053765, + "subdir": "linux-64", + "timestamp": 1669909422909, + "version": "0.3.25" + }, + "jaxlib-0.3.25-py38h6a678d5_1.tar.bz2": { + "build": "py38h6a678d5_1", + "build_number": 1, + "constrains": [ + "jax >=0.3.25" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<2", + "python >=3.8,<3.9.0a0", + "scipy >=1.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e81d5d43109d65bcd490453146252180", + "name": "jaxlib", + "sha256": "3e2b7670c0e8a14432ec2c27d23c06749b1a03cde06fd36fe23a053e37016352", + "size": 44072409, + "subdir": "linux-64", + "timestamp": 1669925614935, + "version": "0.3.25" + }, + "jaxlib-0.3.25-py39h6a678d5_1.tar.bz2": { + "build": "py39h6a678d5_1", + "build_number": 1, + "constrains": [ + "jax >=0.3.25" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<2", + "python >=3.9,<3.10.0a0", + "scipy >=1.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fbe47b0294e94373b47ce9724bf28523", + "name": "jaxlib", + "sha256": "43b74e9498c2099ce18417250ba755fb6bd0924aff71f990d03c765c0caf6ba4", + "size": 44121864, + "subdir": "linux-64", + "timestamp": 1669933680493, + "version": "0.3.25" + }, + "jbig-2.1-hdba287a_0.tar.bz2": { + "build": "hdba287a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "e9aca70f11e42d8ab5d4e111e0dfb03b", + "name": "jbig", + "sha256": "0a7b2d04fc13051d025d036fcaf11b85a36beeaa79bd3f7aad626f683a111b8e", + "size": 42165, + "subdir": "linux-64", + "timestamp": 1505744775994, + "version": "2.1" + }, + "jdcal-1.3-py27h2cc5433_0.tar.bz2": { + "build": "py27h2cc5433_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4a49ba902ce9fd809b282fd207c79093", + "name": "jdcal", + "sha256": "f92e42ec445411c0176fd811bbea26b7848c2b9aa02a36bdb68d7d23c4c4ce46", + "size": 11259, + "subdir": "linux-64", + "timestamp": 1505744787171, + "version": "1.3" + }, + "jdcal-1.3-py35hf1f7175_0.tar.bz2": { + "build": "py35hf1f7175_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "62dcd0104ff643690094b12ff53b01bb", + "name": "jdcal", + "sha256": "c73a022b6210fe8bce9a9021fcc30b8cdecc1117e7903265ab0ddfec4da142c2", + "size": 11370, + "subdir": "linux-64", + "timestamp": 1505744799659, + "version": "1.3" + }, + "jdcal-1.3-py36h4c697fb_0.tar.bz2": { + "build": "py36h4c697fb_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "af322507383b9f651d090f09d99fafc2", + "name": "jdcal", + "sha256": "3588ee2bdc993e9e2749f3f05226aa0bf40c3c5bc97a1a8614c482cb8476392e", + "size": 11333, + "subdir": "linux-64", + "timestamp": 1505744812149, + "version": "1.3" + }, + "jdcal-1.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c423ec7c2c1b072de0aada753f752201", + "name": "jdcal", + "sha256": "37a67daebcee64b95753d76ece09871d60943fc33e2d97e2a5de7d53eec74a1f", + "size": 11673, + "subdir": "linux-64", + "timestamp": 1523943908324, + "version": "1.4" + }, + "jdcal-1.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "75a9b7d1b083e426376afd304ac03782", + "name": "jdcal", + "sha256": "6623e31d34b1b86acf4b830c9c48294adb606ec70a3149a54a4ea9d5c85cf55d", + "size": 11777, + "subdir": "linux-64", + "timestamp": 1523943843456, + "version": "1.4" + }, + "jdcal-1.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4bebae96d7e510cc4052c068bbb2d016", + "name": "jdcal", + "sha256": "fdb31733bc502cefd27a0d755d57d8812b672d09c646f3942e425eac4b9ede67", + "size": 11725, + "subdir": "linux-64", + "timestamp": 1523944002303, + "version": "1.4" + }, + "jdcal-1.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d1d6812140677f7e9836617a03353e14", + "name": "jdcal", + "sha256": "e70032eef33cef65c6fff842be3041fb8cea64b5541d7ffe37ab334d813fc98b", + "size": 11606, + "subdir": "linux-64", + "timestamp": 1530735997064, + "version": "1.4" + }, + "jedi-0.10.2-py27h8af4e35_0.tar.bz2": { + "build": "py27h8af4e35_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96f6e9cc65b973a7c0a2b187e9a71430", + "name": "jedi", + "sha256": "f2307f4f68d5127646a0523dc5b457c9387a8498ab93d7eb386521b1222dbbc8", + "size": 250400, + "subdir": "linux-64", + "timestamp": 1505690588395, + "version": "0.10.2" + }, + "jedi-0.10.2-py35hc33c70f_0.tar.bz2": { + "build": "py35hc33c70f_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0db510aa9c4f16b14714b2ada1a8b1d4", + "name": "jedi", + "sha256": "f6cf84fc4071c48063a2260edb3d125ecc08352f55ded5f9c5c6792e88fb8624", + "size": 256563, + "subdir": "linux-64", + "timestamp": 1505690603584, + "version": "0.10.2" + }, + "jedi-0.10.2-py36h552def0_0.tar.bz2": { + "build": "py36h552def0_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4cd14cce2dadbbacf0bb11a1c853f77", + "name": "jedi", + "sha256": "d7a46a2c6689f48065b0b281419555c78450e37c8e3c7098de5b65331a818ff8", + "size": 254088, + "subdir": "linux-64", + "timestamp": 1505690618923, + "version": "0.10.2" + }, + "jedi-0.11.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "parso >=0.1.0,<0.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bed374c27f2265ac91fbf9ecc9992400", + "name": "jedi", + "sha256": "f938aa9a1288b3398d734e78d856ae9a03e2168b5e8f9c90dba83ce186feb243", + "size": 189814, + "subdir": "linux-64", + "timestamp": 1512675226636, + "version": "0.11.0" + }, + "jedi-0.11.0-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "parso >=0.1.0,<0.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74997961d0a9a1162e86a3ba0101281b", + "name": "jedi", + "sha256": "feb44a71a7f03de5c02a575c23030e425dfe60de20b2e7f47e8de1a06d9122e6", + "size": 190088, + "subdir": "linux-64", + "timestamp": 1512802210504, + "version": "0.11.0" + }, + "jedi-0.11.0-py27hb1d440e_0.tar.bz2": { + "build": "py27hb1d440e_0", + "build_number": 0, + "depends": [ + "parso ==0.1.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a7122a5ca97a565d63b301e74f1f200", + "name": "jedi", + "sha256": "fe440ff60aa6be6644f098a9dbe7db6298e031c0229118f2ff2c47c4418bcad2", + "size": 190094, + "subdir": "linux-64", + "timestamp": 1512058836974, + "version": "0.11.0" + }, + "jedi-0.11.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "parso >=0.1.0,<0.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "acc91403e560985374f1929ac2eb1198", + "name": "jedi", + "sha256": "492dc22a72e446f1049fedb80708ac2b5de0d8b8fe43702270ecde7dbfd7bc6b", + "size": 193326, + "subdir": "linux-64", + "timestamp": 1512675237974, + "version": "0.11.0" + }, + "jedi-0.11.0-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "parso >=0.1.0,<0.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39c1680790a68ebca6feaafa20713ce0", + "name": "jedi", + "sha256": "880ed26835fde6bcf99694517a50e776f03d9a18766349ff6c0270f604d17679", + "size": 193424, + "subdir": "linux-64", + "timestamp": 1512802247535, + "version": "0.11.0" + }, + "jedi-0.11.0-py35h48b7ba3_0.tar.bz2": { + "build": "py35h48b7ba3_0", + "build_number": 0, + "depends": [ + "parso ==0.1.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ed63111074ac695b4f7a15c7a23396f", + "name": "jedi", + "sha256": "2c2c5be252829c56279d06e3d49d5660f8fa0450f522cb5a0bceb8d89b094128", + "size": 193232, + "subdir": "linux-64", + "timestamp": 1512058837639, + "version": "0.11.0" + }, + "jedi-0.11.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "parso >=0.1.0,<0.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18c4a68618b921dc52c04a21c18a1d04", + "name": "jedi", + "sha256": "5487d945e1cfb0e018030d1a724b23b2242655c1a5b81ad8b9846c34e4f2e4c2", + "size": 191777, + "subdir": "linux-64", + "timestamp": 1512675253432, + "version": "0.11.0" + }, + "jedi-0.11.0-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "parso >=0.1.0,<0.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66b45b48a8448c86a4c1ab2751c88ece", + "name": "jedi", + "sha256": "7f6eafb8c4548aa1ce1bd9809b354007192051bdbe8ab253f049a13c6aac8b2c", + "size": 192077, + "subdir": "linux-64", + "timestamp": 1512802215982, + "version": "0.11.0" + }, + "jedi-0.11.0-py36hf290c5b_0.tar.bz2": { + "build": "py36hf290c5b_0", + "build_number": 0, + "depends": [ + "parso ==0.1.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "443e31fc2fd6e30a1f93fe4226091c8c", + "name": "jedi", + "sha256": "b2fbb66dae91d5119a49ac6a7a4d0c5d6ef0da412c8a27b48771a31cf302c49c", + "size": 191866, + "subdir": "linux-64", + "timestamp": 1512058861563, + "version": "0.11.0" + }, + "jedi-0.11.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "parso >=0.1.0,<0.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba477cfb2246efd9fae4e79fdc7bac70", + "name": "jedi", + "sha256": "b64e3ce8109f0c598425090d36ef120d1aba5410498c036158ab552dd392f149", + "size": 304388, + "subdir": "linux-64", + "timestamp": 1515791358516, + "version": "0.11.1" + }, + "jedi-0.11.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "numpydoc", + "parso >=0.1.0,<0.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d359848cf46fc5b6d80dbdf8927bd6c", + "name": "jedi", + "sha256": "2fcf95957528e1cb5ec13d4848a8536f1b7e20e8bae552c80c380770e5c8ad50", + "size": 304048, + "subdir": "linux-64", + "timestamp": 1521633485650, + "version": "0.11.1" + }, + "jedi-0.11.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "parso >=0.1.0,<0.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12927c5330207ab2253c07d7396ac05e", + "name": "jedi", + "sha256": "c71aa87631e0ba2369786d45c4daab80ddfb0da1a0f819af1f87bad1d4531ad6", + "size": 315312, + "subdir": "linux-64", + "timestamp": 1515791523666, + "version": "0.11.1" + }, + "jedi-0.11.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "numpydoc", + "parso >=0.1.0,<0.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1dd835f151450a743fcd6d3b475cb189", + "name": "jedi", + "sha256": "991babb58b0dba369140655fa5ab9d189c5de22321c8436432b68431382fbdcb", + "size": 315492, + "subdir": "linux-64", + "timestamp": 1521633501130, + "version": "0.11.1" + }, + "jedi-0.11.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.1.0,<0.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e5d605453b8531e14382ffa5fd1f2dbb", + "name": "jedi", + "sha256": "39f627efeb8fc268c8427cec8f21a03e82319ba37d4804621de8ea7edbc56e98", + "size": 313488, + "subdir": "linux-64", + "timestamp": 1515791326040, + "version": "0.11.1" + }, + "jedi-0.11.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "numpydoc", + "parso >=0.1.0,<0.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "88d7f3b04a5dcc5ed9003704a0c3747a", + "name": "jedi", + "sha256": "102fa017e9248be3cab62fab0208ce231037e38b0b0bd181692b204ff42e3b93", + "size": 313583, + "subdir": "linux-64", + "timestamp": 1521633499682, + "version": "0.11.1" + }, + "jedi-0.12.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpydoc", + "parso >=0.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33c46887a302b290f972b2a2209e590f", + "name": "jedi", + "sha256": "4175eb2822e3be5fd501028f461929abbfa4f5eeb6e6baa9ce27c757c9c98333", + "size": 226627, + "subdir": "linux-64", + "timestamp": 1523970976509, + "version": "0.12.0" + }, + "jedi-0.12.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "parso", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "902d4b1f53f883e1ae749b5978b0ccdf", + "name": "jedi", + "sha256": "7b89d86cbe59d66e8ee47d87985ed12dda885fb11c8e09064c116003bb10afda", + "size": 226900, + "subdir": "linux-64", + "timestamp": 1524675554736, + "version": "0.12.0" + }, + "jedi-0.12.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpydoc", + "parso >=0.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5a7929c4dc942d925262508ef350d73b", + "name": "jedi", + "sha256": "662a52d2942e37848fc2d947c2b56df6b4e1fc70dd072322538d9857c208d7ed", + "size": 230721, + "subdir": "linux-64", + "timestamp": 1523971007545, + "version": "0.12.0" + }, + "jedi-0.12.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "parso", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "724c5aca1a51973f6e8b0bb1c5c196b6", + "name": "jedi", + "sha256": "777187d1c8ad6ad241902f9010ac61ac5e8f56ee365913f8d64e38ea26ea8c92", + "size": 230831, + "subdir": "linux-64", + "timestamp": 1524675569984, + "version": "0.12.0" + }, + "jedi-0.12.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpydoc", + "parso >=0.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c6aec06ce6e04192e20ffac29152c5ee", + "name": "jedi", + "sha256": "8af0347ff3613bc1708ffe35bac63e7370ce7c3ff638496f71f4a24163f3411b", + "size": 228606, + "subdir": "linux-64", + "timestamp": 1523971008186, + "version": "0.12.0" + }, + "jedi-0.12.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "parso", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bfc32de419c9fffac71f5b6206266872", + "name": "jedi", + "sha256": "1a015ddf6bad02ac2ff25b2764f51bf4e95007475f9e4adbf409eef1bc4781a8", + "size": 228550, + "subdir": "linux-64", + "timestamp": 1524675572686, + "version": "0.12.0" + }, + "jedi-0.12.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "parso >=0.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f41e497efbe2ef0ca5003b68653249e", + "name": "jedi", + "sha256": "a78838912c100096bc1e85424f348cce92d05faeaa15303648567a6c8e37294b", + "size": 229215, + "subdir": "linux-64", + "timestamp": 1530733677896, + "version": "0.12.0" + }, + "jedi-0.12.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a639f721b1e053d7dd9c2a8136c02337", + "name": "jedi", + "sha256": "bed1f65a2673037194c568ebae5233ccdbfde718ecffcf8413a720a7895e65eb", + "size": 228237, + "subdir": "linux-64", + "timestamp": 1532365272634, + "version": "0.12.1" + }, + "jedi-0.12.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8635cbc49dea8b6baa8e7527d0b51370", + "name": "jedi", + "sha256": "682c60d7304257d8f55be5d0fa276d6f509c980d3e79547b31f3284430f2e923", + "size": 232158, + "subdir": "linux-64", + "timestamp": 1532365309846, + "version": "0.12.1" + }, + "jedi-0.12.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab4e0ec62d6c57d53ba7b201c8081f83", + "name": "jedi", + "sha256": "0c79f4fe748948b51fa917ebbfa39a84f6829718ecb1cc7512ad691aa536af2d", + "size": 230563, + "subdir": "linux-64", + "timestamp": 1532365129053, + "version": "0.12.1" + }, + "jedi-0.12.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8cc9a6c17f748e3ff81cf5ff971bb492", + "name": "jedi", + "sha256": "4e615bbbade2df6053550ac80f63b13be7ebddca598742a3d4bd6234e44df72c", + "size": 230658, + "subdir": "linux-64", + "timestamp": 1532365324039, + "version": "0.12.1" + }, + "jedi-0.13.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bfbc5584e641d7bdbd25cd6eac936be7", + "name": "jedi", + "sha256": "8ae9d0c1195bdea7626633ea44f3eaaa9d010670fba654a54e9999ccd47f934c", + "size": 232591, + "subdir": "linux-64", + "timestamp": 1539023217343, + "version": "0.13.1" + }, + "jedi-0.13.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "84e9b8d9aeb1083a172cdd3bce500a60", + "name": "jedi", + "sha256": "3282b6eb03e09cee4f77921016757cc0c13a576ec6fd512de04127f5632d39c6", + "size": 234491, + "subdir": "linux-64", + "timestamp": 1539023226347, + "version": "0.13.1" + }, + "jedi-0.13.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba49dc3a6a6f050118f517cff0c502ae", + "name": "jedi", + "sha256": "8d9adea9221c46e56fa7a644a27c2c357dae64af1e102b481dfcabefeca30f66", + "size": 234611, + "subdir": "linux-64", + "timestamp": 1539023205129, + "version": "0.13.1" + }, + "jedi-0.13.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "becd94e9937dc59a565037edb0b0cc0f", + "name": "jedi", + "sha256": "36ccca322382294dbf4af170a46eb2fb26a492b88bc52faff508635f6cbec6e1", + "size": 233842, + "subdir": "linux-64", + "timestamp": 1545072609078, + "version": "0.13.2" + }, + "jedi-0.13.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ef1b8767472b8ddc9f3a7640d04f5d9", + "name": "jedi", + "sha256": "d0ed749c4d7f2d70b2d35110f46a24323f7fa730d3b0d572fa825ce09ed77c98", + "size": 233548, + "subdir": "linux-64", + "timestamp": 1545072628071, + "version": "0.13.2" + }, + "jedi-0.13.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "07e33cc4e49e73ed252a3644290d4190", + "name": "jedi", + "sha256": "90506f5794f5014c87a801cec5bfadffb9bec1838e56c52959a0d3db75fe20f6", + "size": 237086, + "subdir": "linux-64", + "timestamp": 1545072602226, + "version": "0.13.2" + }, + "jedi-0.13.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01be9a45feb31c20478c3483417ac2b5", + "name": "jedi", + "sha256": "b6df24726db2cc003ae3a0e58798b8fef7184dfd43c6760f1aa46db579fec744", + "size": 238497, + "subdir": "linux-64", + "timestamp": 1551140327364, + "version": "0.13.3" + }, + "jedi-0.13.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a9bc8eec8bd179a252e8fef3c4e3b6e0", + "name": "jedi", + "sha256": "550fcb2faf3a1be36253e4efebfc5aa94b1dc329be784cb1914615ca6c155518", + "size": 241581, + "subdir": "linux-64", + "timestamp": 1551140353363, + "version": "0.13.3" + }, + "jedi-0.13.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f23af5f50f6625a41ad87071cdc08d0c", + "name": "jedi", + "sha256": "6d070ce9a89eab5e5a083e98b2694faa2f629679aa4b4e00e2794a4836c58b17", + "size": 239599, + "subdir": "linux-64", + "timestamp": 1551195541963, + "version": "0.13.3" + }, + "jedi-0.14.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6fa31669496a5d4fdf0076dda54fd2ab", + "name": "jedi", + "sha256": "b02ea781d99af51513c1cf6cde879be3db9756fbb83f1bb00a1ee8705f9317df", + "size": 708829, + "subdir": "linux-64", + "timestamp": 1575415316457, + "version": "0.14.1" + }, + "jedi-0.14.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb36e3c16c37a0cb63ff742e5a490582", + "name": "jedi", + "sha256": "d1b4136904c5c2a983c3b502d7b7bc2dc74e7bde6712e0b41e50d353710f0fc3", + "size": 727876, + "subdir": "linux-64", + "timestamp": 1575415346909, + "version": "0.14.1" + }, + "jedi-0.14.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dfca6f1202f4600013d166f8d94963c2", + "name": "jedi", + "sha256": "b1cb4774bf98d6b39d17a755ce974146ef57d04a8bdaf0e5197b00672be7ab98", + "size": 722054, + "subdir": "linux-64", + "timestamp": 1575415316672, + "version": "0.14.1" + }, + "jedi-0.14.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5db1a969b000115e01d8f4153cf5e9a0", + "name": "jedi", + "sha256": "545bab7bc155c059c4934e8f15d11f99c77738ee9ecc89e4d035313bf94fda53", + "size": 718575, + "subdir": "linux-64", + "timestamp": 1575415377015, + "version": "0.14.1" + }, + "jedi-0.15.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98d52f147c05fee0ce5c108f8e393bbc", + "name": "jedi", + "sha256": "16a7bcf5fc330ded54332da3a51271181955ad651fe68ea90379a0878206172a", + "size": 726068, + "subdir": "linux-64", + "timestamp": 1565957055936, + "version": "0.15.1" + }, + "jedi-0.15.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8258233d2acf61a98948441e0c9545c8", + "name": "jedi", + "sha256": "5d04269d2f6db8e4971dd8200003b58ef0e0fc2f1fa40ef00b4767f4e4ea3177", + "size": 738411, + "subdir": "linux-64", + "timestamp": 1565957154975, + "version": "0.15.1" + }, + "jedi-0.15.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a7d6cfe377901094f63a75cf93127f1", + "name": "jedi", + "sha256": "e26b291d5407ecba32732da91bf39b9d43016136b0cd5f6b9c1e92dd37d30f69", + "size": 729891, + "subdir": "linux-64", + "timestamp": 1565957079630, + "version": "0.15.1" + }, + "jedi-0.15.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "76b2b1a54bc3ae3ef8aa371f7651111b", + "name": "jedi", + "sha256": "922933b63967483a6d1a80fe76ba4fe16e8420ce000e03acf8a73619e2172859", + "size": 725424, + "subdir": "linux-64", + "timestamp": 1573469701161, + "version": "0.15.1" + }, + "jedi-0.15.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8830533fb0d750ebd1521f090c471756", + "name": "jedi", + "sha256": "534ad5b4f2d0736456c95a4a01cd1a08fb22b2e3ef44adaa7ea76c3d2fe06ffe", + "size": 785578, + "subdir": "linux-64", + "timestamp": 1578412349295, + "version": "0.15.2" + }, + "jedi-0.15.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a7283a5281037dfeae59281b7bf10b64", + "name": "jedi", + "sha256": "cd16d2292e429b3c26cc19ca79e50bb0ac91e994c3d8b75184b3739b228a96a5", + "size": 786243, + "subdir": "linux-64", + "timestamp": 1578412357813, + "version": "0.15.2" + }, + "jedi-0.15.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6ea74b3e6774f54aa3253ac1e89e206", + "name": "jedi", + "sha256": "1d550a65c5ebdb9214a7d0f91f3a10a9b496be3c22b63d181610cd6ed06d50f1", + "size": 777003, + "subdir": "linux-64", + "timestamp": 1578412340302, + "version": "0.15.2" + }, + "jedi-0.15.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f35b71d36204856afbfa04f6f6b6a6e2", + "name": "jedi", + "sha256": "87695c6f9028a9af2c3707fff52d4097a115fd74cafe0ca4a9cc0f310702dcb9", + "size": 782896, + "subdir": "linux-64", + "timestamp": 1578412340906, + "version": "0.15.2" + }, + "jedi-0.16.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d7bb5fdf0c92f236ced2e1fa9e36d628", + "name": "jedi", + "sha256": "bf2a948bf37b60fac5a38e391230848a76890f29b6813cc02f40030917785014", + "size": 791792, + "subdir": "linux-64", + "timestamp": 1580150723998, + "version": "0.16.0" + }, + "jedi-0.16.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "parso >=0.5.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c274b40cd45bc26bd7d3d36ae4fb838", + "name": "jedi", + "sha256": "7295a1fd08cb4ce41ef81231a294509ea0dd5f21d528515236127a6b6efd9ae4", + "size": 807080, + "subdir": "linux-64", + "timestamp": 1585135569560, + "version": "0.16.0" + }, + "jedi-0.16.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "569e1af409444ffd78c7938781800d70", + "name": "jedi", + "sha256": "f9e16f0b66a858f1c31e84dd59b89b9b540a2ed35db1a00c8064933a721d6852", + "size": 787410, + "subdir": "linux-64", + "timestamp": 1580150575183, + "version": "0.16.0" + }, + "jedi-0.16.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "parso >=0.5.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cf7a4c8f5c516170d796c5d6521f2681", + "name": "jedi", + "sha256": "aef1f7f5f06036ecfedbc52384234eae06463bbb334db64c446fad0e01580cea", + "size": 787403, + "subdir": "linux-64", + "timestamp": 1585135563743, + "version": "0.16.0" + }, + "jedi-0.16.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0396078fe4b2d7fc93b0c5a09fee2af3", + "name": "jedi", + "sha256": "7e3ad892c464b538fa0c3c3dbe4093f6ea82688b9e8ac364b6cddbef1ec05e64", + "size": 802218, + "subdir": "linux-64", + "timestamp": 1580150697828, + "version": "0.16.0" + }, + "jedi-0.16.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "parso >=0.5.2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df50e6bd6c0b0c4e94dd522d99cf375f", + "name": "jedi", + "sha256": "7c761ea09f63152e1511b3438ed641f9909358b471cc9b74374824b35b630290", + "size": 799650, + "subdir": "linux-64", + "timestamp": 1585135588633, + "version": "0.16.0" + }, + "jedi-0.17.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "032832ac21da383cb3a61ee0013c422d", + "name": "jedi", + "sha256": "3eba29cdeb8d7e3c47a2f754e9cadf62777d8f9913c533fc599c10592b34588d", + "size": 828369, + "subdir": "linux-64", + "timestamp": 1588278615673, + "version": "0.17.0" + }, + "jedi-0.17.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1fd1cbaf6bc98d0882aee18facb47928", + "name": "jedi", + "sha256": "96cc85c3580d0f133f8c3d55dd80b2160ef7733cbbba08fae0dbaba8ec677da1", + "size": 820002, + "subdir": "linux-64", + "timestamp": 1588278584242, + "version": "0.17.0" + }, + "jedi-0.17.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "248f6dc01d1771ae51c64c8524e68fa2", + "name": "jedi", + "sha256": "68e1dbd5db044f343d4e2ad00320ac4e8e9331f7914173d9f85068644a50b018", + "size": 826822, + "subdir": "linux-64", + "timestamp": 1588278612377, + "version": "0.17.0" + }, + "jedi-0.17.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f754f22b02fae23d0b24facf71896f3b", + "name": "jedi", + "sha256": "c1c22aa7021c271ba15b555778b894d284875f5ed08fb6a513941f3c83ca0834", + "size": 958593, + "subdir": "linux-64", + "timestamp": 1592841949873, + "version": "0.17.1" + }, + "jedi-0.17.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "059b3ada1f4712957e13959b41f2fb54", + "name": "jedi", + "sha256": "be74bb37a88aee87e4a989b2ac0dbde3159349226be65e2a28006e24f4d7c665", + "size": 965607, + "subdir": "linux-64", + "timestamp": 1592841924909, + "version": "0.17.1" + }, + "jedi-0.17.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "938e6ae6694b5834d0c3bd88bb96c7ba", + "name": "jedi", + "sha256": "94875a57c1f90515095ac7d0768b5c4c7d8b55cb682bac641bae2de85af7e040", + "size": 966469, + "subdir": "linux-64", + "timestamp": 1592841910536, + "version": "0.17.1" + }, + "jedi-0.17.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4304270ca99b27fc4b28ceda7a7904c", + "name": "jedi", + "sha256": "2b1d8ff6f1f4275ea533c0b675546c602621566720e1f1aa9fa964acbadd800a", + "size": 975267, + "subdir": "linux-64", + "timestamp": 1598371660772, + "version": "0.17.2" + }, + "jedi-0.17.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ebc254cc81122f74eb2c2b01f96aa18", + "name": "jedi", + "sha256": "231451286f823ebbfd84278b7196c61f77585d69630b5192a7e0b5e0fe899f86", + "size": 963723, + "subdir": "linux-64", + "timestamp": 1606932616049, + "version": "0.17.2" + }, + "jedi-0.17.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5002bd75fe544576675cacbdc910856c", + "name": "jedi", + "sha256": "35df09bc60f5ee500b6498d7e409ae22b1c715c9354fc266e37bd4ff1c6ad8e3", + "size": 972327, + "subdir": "linux-64", + "timestamp": 1596490780717, + "version": "0.17.2" + }, + "jedi-0.17.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df711cde960954ebcb9622ef9311d969", + "name": "jedi", + "sha256": "6972a71659ac09023bb64c84877c174d146d0ac90c91dc7a26099df555e5b451", + "size": 975120, + "subdir": "linux-64", + "timestamp": 1606932595287, + "version": "0.17.2" + }, + "jedi-0.17.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b70addbcd8f91566722d8233eeb6bb5f", + "name": "jedi", + "sha256": "aac8150517fd1ed4abb9c402202a00832c8e8d8c1c4a556fe565edf196059ea7", + "size": 964545, + "subdir": "linux-64", + "timestamp": 1598371708046, + "version": "0.17.2" + }, + "jedi-0.17.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43dd45a0e4ce9b0589c8c8c00b95d10f", + "name": "jedi", + "sha256": "95f508751917a43e4b6fa5a63a3534f3b316d4e1c0c6d7a8a278aab941a1b747", + "size": 968089, + "subdir": "linux-64", + "timestamp": 1606932606482, + "version": "0.17.2" + }, + "jedi-0.17.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "589b395286a6a0a5e12808aac1e7dc98", + "name": "jedi", + "sha256": "7603682929fe3d423ac8dba5bc9a4919e4b3675a28b2f6009a16baad2cff2799", + "size": 982288, + "subdir": "linux-64", + "timestamp": 1606932608161, + "version": "0.17.2" + }, + "jedi-0.18.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48468c617191437c44c2afc5d07973b9", + "name": "jedi", + "sha256": "a678b7efa3f190ff92bc206258e3e598ed8ae9326a25400d02a9fb5e02d76410", + "size": 942493, + "subdir": "linux-64", + "timestamp": 1641919232989, + "version": "0.18.0" + }, + "jedi-0.18.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "188e154faf03fa1ccafef0465df6c96e", + "name": "jedi", + "sha256": "9f0069dde660aafc9858f0b34641df557c13106029c8c6e5730ac32e33fbe82a", + "size": 943459, + "subdir": "linux-64", + "timestamp": 1608920763380, + "version": "0.18.0" + }, + "jedi-0.18.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd6ec3af8df3eb66db0dbd38b3f4bdc8", + "name": "jedi", + "sha256": "3ca6ddd0069e008b2bb46931c05a1c0ea387f1c33d278b79cc69907db2484367", + "size": 954312, + "subdir": "linux-64", + "timestamp": 1611333791626, + "version": "0.18.0" + }, + "jedi-0.18.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8e3a17095c48f7fb96a359d3e386828", + "name": "jedi", + "sha256": "39fd20c8f2aa69fc1dc757b541315e7f55667018b0deba2382c279bd15ecd570", + "size": 951398, + "subdir": "linux-64", + "timestamp": 1608920731822, + "version": "0.18.0" + }, + "jedi-0.18.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c21e4ff96b8d7aef079c4d574657bc11", + "name": "jedi", + "sha256": "85ef8f8aa02c0b73ce77e520bf13513349513430df643caea534d5b136c42153", + "size": 966174, + "subdir": "linux-64", + "timestamp": 1611333797020, + "version": "0.18.0" + }, + "jedi-0.18.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5cd12b96d294752edb5d1b103ab881fa", + "name": "jedi", + "sha256": "f544376bd2ef19a34285975cf34474d17d4c7b003617d2c2c1e561e4928f9839", + "size": 936233, + "subdir": "linux-64", + "timestamp": 1608920752427, + "version": "0.18.0" + }, + "jedi-0.18.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f460012757f82d9b0c6eae283720b54", + "name": "jedi", + "sha256": "8f443f1c381affcd56638516d7474640f694d4ca22322598e69b9c827d4252d0", + "size": 964216, + "subdir": "linux-64", + "timestamp": 1611333166324, + "version": "0.18.0" + }, + "jedi-0.18.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4c06e5ae11e557c140295315067142b3", + "name": "jedi", + "sha256": "f082130299c172352742f496b151ce4ca46ff1f5624e06486e51052ece3fb88f", + "size": 945801, + "subdir": "linux-64", + "timestamp": 1608920764545, + "version": "0.18.0" + }, + "jedi-0.18.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6171c4161274cb7592884a1e2f473e10", + "name": "jedi", + "sha256": "6359b46cd8f3486317212981c093465015ed804688f7c0f1b1b58e96e160d791", + "size": 953755, + "subdir": "linux-64", + "timestamp": 1611333804528, + "version": "0.18.0" + }, + "jedi-0.18.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "304ff041f756d6bac257f77c63a72aff", + "name": "jedi", + "sha256": "791097a544c793a7befc7778383c10e534c909adab9a446e38977d98a0fb0bb7", + "size": 1036683, + "subdir": "linux-64", + "timestamp": 1644315282525, + "version": "0.18.1" + }, + "jedi-0.18.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96d06bff620c915364b402911e91fa70", + "name": "jedi", + "sha256": "071f1ba16eef845642f30a312f5ff42c963b93208a6f242ee297df7352aa548b", + "size": 1163263, + "subdir": "linux-64", + "timestamp": 1676823821205, + "version": "0.18.1" + }, + "jedi-0.18.1-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "84fadd6b7fef393cccc0d123dae6cae8", + "name": "jedi", + "sha256": "a2918ea8a3e2c56fc6d91191e84b2f35500c392b16ab687a0c03ded2e2e51239", + "size": 1162207, + "subdir": "linux-64", + "timestamp": 1679336523618, + "version": "0.18.1" + }, + "jedi-0.18.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d054ab14a1af20b50f0b3245c5a7c5b4", + "name": "jedi", + "sha256": "792f053d3a4b969f3d0049476e091f9755ec8c088f9baf6ae94e82011a9e5fac", + "size": 1019898, + "subdir": "linux-64", + "timestamp": 1642692294657, + "version": "0.18.1" + }, + "jedi-0.18.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f175ff9d30b43e8987b4bed43516cc50", + "name": "jedi", + "sha256": "2090152f846e3cf7224a8b269413d57933a7f77b20e4e1a7ccba3e0a997cfcb9", + "size": 1025277, + "subdir": "linux-64", + "timestamp": 1644299065124, + "version": "0.18.1" + }, + "jedi-0.18.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce6132034c84b616c7b3809c6e5e80c2", + "name": "jedi", + "sha256": "b62d4a6a29199f952f448c37a0178312b7830927e0b05dc643786abcdbbc692e", + "size": 1015113, + "subdir": "linux-64", + "timestamp": 1642692219238, + "version": "0.18.1" + }, + "jedi-0.18.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "19ed6fe5573ad375cddc95056ecd13a0", + "name": "jedi", + "sha256": "3a960eb70bfc70b68e8a4c18789d6e4e38d957fcc131e0a2dd0c40d9a69d299f", + "size": 1029639, + "subdir": "linux-64", + "timestamp": 1644315273267, + "version": "0.18.1" + }, + "jedi-0.18.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77c5b2bfd39962858ee150b0b9894907", + "name": "jedi", + "sha256": "decad89341e2f8774c3d405deafc09353b74529e30fe1be47edf6d2d1df4b2e6", + "size": 1015463, + "subdir": "linux-64", + "timestamp": 1642692260138, + "version": "0.18.1" + }, + "jedi-0.18.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ef6c6a0d1ac79143c7359d305155167", + "name": "jedi", + "sha256": "6feb2896156814ddfe0cf4f5d2fd41c419b3ce7f6cdfcec9a7a40a260bda3dff", + "size": 1021637, + "subdir": "linux-64", + "timestamp": 1644297140650, + "version": "0.18.1" + }, + "jeepney-0.3.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0fb9f1039d6be584d8b1583753fadc8", + "name": "jeepney", + "sha256": "bd54a55d21653223a006975231da1477f9372fb5c9d97b0a34ebf1499ba65a22", + "size": 36576, + "subdir": "linux-64", + "timestamp": 1529952896194, + "version": "0.3.1" + }, + "jeepney-0.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7cd3fe739825064cd92971c491d00644", + "name": "jeepney", + "sha256": "108f58fd57337a0e70e3786488a0d85c50d4db9aea19b886ecaa277a59cf5fe4", + "size": 36434, + "subdir": "linux-64", + "timestamp": 1529952854702, + "version": "0.3.1" + }, + "jeepney-0.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9053d487e6674208712187a0c96521bd", + "name": "jeepney", + "sha256": "ed7d2912216db27fc634d924f882a6121eb77f582da04015326a8150f7568125", + "size": 36453, + "subdir": "linux-64", + "timestamp": 1530898151273, + "version": "0.3.1" + }, + "jeepney-0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "771da5a2b6676a49b52a4674f6733515", + "name": "jeepney", + "sha256": "76e90e2f99729fb141bcfe27f5b8a101076bd00fc4718a5d93d4a3ceccc22748", + "size": 38296, + "subdir": "linux-64", + "timestamp": 1538366583168, + "version": "0.4" + }, + "jeepney-0.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37be33ddb3b82ba03c4acb2dd2e0b015", + "name": "jeepney", + "sha256": "ea9d500ee30e0b1a8bab8bafb26265b737205ba57c2669847e0e2174d7f0ac09", + "size": 38395, + "subdir": "linux-64", + "timestamp": 1538366552165, + "version": "0.4" + }, + "jellyfish-0.9.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "26f10ad1b9fe06b79690826d74905adc", + "name": "jellyfish", + "sha256": "ce6df32ce78c76c29a8736b4ade28ff5a58e7a8d4568b418505ae84d0f08bfd2", + "size": 95753, + "subdir": "linux-64", + "timestamp": 1647944479821, + "version": "0.9.0" + }, + "jellyfish-0.9.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5bdfb9219f010eb2e52eea9a79dc14a8", + "name": "jellyfish", + "sha256": "96415bb4fdbc49aaf5d3a630e584033af412fed1f13fd0f43be5c2b90d65294c", + "size": 48507, + "subdir": "linux-64", + "timestamp": 1676844363764, + "version": "0.9.0" + }, + "jellyfish-0.9.0-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "4c5a8f28535a0505c32d7aa43c05ea34", + "name": "jellyfish", + "sha256": "20629ceb939df6bc27c8277193272a17a582ffbab3a7ceebb387bf076f7ea089", + "size": 44999, + "subdir": "linux-64", + "timestamp": 1647944732093, + "version": "0.9.0" + }, + "jellyfish-0.9.0-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "623b49f1a513c5f2170509f3d110347b", + "name": "jellyfish", + "sha256": "36ca71d1f3b362f5cb9ecb5012f956f253dc90f884795f28fd025e2b16e03c3d", + "size": 45114, + "subdir": "linux-64", + "timestamp": 1647962586771, + "version": "0.9.0" + }, + "jellyfish-0.9.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e32f0967aa9c5db11ff5a809dda615df", + "name": "jellyfish", + "sha256": "9c7491c69a5b7695d719e4b1c579369f2693771b730e3b1e1c201e1e534d3e49", + "size": 45268, + "subdir": "linux-64", + "timestamp": 1647944464758, + "version": "0.9.0" + }, + "jemalloc-5.0.1-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 2-Clause", + "md5": "d567798872bc68caaad49b4e22b37c7b", + "name": "jemalloc", + "sha256": "2da98294dbedb2071762ef1e91f3f6a62f0d4e386e022926c681912806198e45", + "size": 9546581, + "subdir": "linux-64", + "timestamp": 1514580884546, + "version": "5.0.1" + }, + "jemalloc-5.0.1-hf484d3e_1.tar.bz2": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 2-Clause", + "md5": "c78456319a9b03679af698c718efeaa8", + "name": "jemalloc", + "sha256": "3bae6ea57585afeee22b03218c7c0a4313dfc586bbe69b32e0d573b34e602ec4", + "size": 9533206, + "subdir": "linux-64", + "timestamp": 1514725114781, + "version": "5.0.1" + }, + "jemalloc-5.2.1-h2531618_5.tar.bz2": { + "build": "h2531618_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "md5": "b21844d04e8791aa64bd373951a416d2", + "name": "jemalloc", + "sha256": "155f295fb13f7a9d6ab5474b8d6d3746ff646ccd41817b1d14c8ca09a19cde03", + "size": 1347241, + "subdir": "linux-64", + "timestamp": 1619184855594, + "version": "5.2.1" + }, + "jemalloc-5.2.1-h6a678d5_6.tar.bz2": { + "build": "h6a678d5_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "0e7cb5b2b5ff95da6c5f4ce77fb6d684", + "name": "jemalloc", + "sha256": "74554ebb364e7e2ceb3bc24840662818a2b80ee0bc0b81aef8a04e37a7a9abc1", + "size": 1519492, + "subdir": "linux-64", + "timestamp": 1678115311319, + "version": "5.2.1" + }, + "jinja2-2.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "b05d31df3566875b3e4e0d90ed0efbf3", + "name": "jinja2", + "sha256": "83871c418888c99b5c51714482fd83b22e5b520cae67f695dfc64b9c5278cb1c", + "size": 180745, + "subdir": "linux-64", + "timestamp": 1530695459930, + "version": "2.10" + }, + "jinja2-2.10-py27h4114e70_0.tar.bz2": { + "build": "py27h4114e70_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "f321d5e83aec5f35084ac2de5ff68098", + "name": "jinja2", + "sha256": "94e23f16759542e0baac395616576cc1fec4da795c2de98ef0d68340c0c80b42", + "size": 181173, + "subdir": "linux-64", + "timestamp": 1512041847443, + "version": "2.10" + }, + "jinja2-2.10-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "f52b34c0f521ba123cb9b437a3cff9b5", + "name": "jinja2", + "sha256": "2685338503be57b4648caa4669f7e764c28fa73ed60b52e32b4f2248d7020859", + "size": 185482, + "subdir": "linux-64", + "timestamp": 1534345527196, + "version": "2.10" + }, + "jinja2-2.10-py35h480ab6d_0.tar.bz2": { + "build": "py35h480ab6d_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "0e4c3e7a7959136a899788b4c8e99f09", + "name": "jinja2", + "sha256": "b9c4663ef0c5b03ae82e89d691d9a2a9ad783998b7bec442c3447c6257aa9d48", + "size": 185963, + "subdir": "linux-64", + "timestamp": 1512041875277, + "version": "2.10" + }, + "jinja2-2.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "647f8ca6942adeb0af0b96aa8993b1a3", + "name": "jinja2", + "sha256": "a46401235f9b789ea40fc770620a019449185c7e26a1c4b8fe8d02428c864407", + "size": 187963, + "subdir": "linux-64", + "timestamp": 1530695417666, + "version": "2.10" + }, + "jinja2-2.10-py36ha16c418_0.tar.bz2": { + "build": "py36ha16c418_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "759c96520abd1a103c0bd9c01b5fba68", + "name": "jinja2", + "sha256": "2c0119475f49d3cf6aaeb1bd87cc19d451f5e6ddadb8e36287003bf1bdd69e04", + "size": 188276, + "subdir": "linux-64", + "timestamp": 1512041876307, + "version": "2.10" + }, + "jinja2-2.10-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "e9d3c1f4a727b135cd82031ff17b9515", + "name": "jinja2", + "sha256": "4bb36b824359b3616877de78e419dae0aaf6578f8485164197935287b01186e0", + "size": 187670, + "subdir": "linux-64", + "timestamp": 1530695439574, + "version": "2.10" + }, + "jinja2-2.10.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "5dc709d34bbf89fccfe336b9dc9430d9", + "name": "jinja2", + "sha256": "63adccf33f088f1227459e181599dddba1a21cc6f2b932604ccdcda8bfd2307a", + "size": 185737, + "subdir": "linux-64", + "timestamp": 1555082260029, + "version": "2.10.1" + }, + "jinja2-2.10.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "f1837495e451a2ba36a088ad8ecfb57b", + "name": "jinja2", + "sha256": "7e991b1c8ce4aed89d1691b77f58e1991f4af73a976c20000ef683af290aabf9", + "size": 192625, + "subdir": "linux-64", + "timestamp": 1555082266836, + "version": "2.10.1" + }, + "jinja2-2.10.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "22b058063b541f25f3e584da3eb2dda1", + "name": "jinja2", + "sha256": "502b16cedac785e73a077b57d351a6115f6df49b25bd16a475e41f7a5c75b656", + "size": 192356, + "subdir": "linux-64", + "timestamp": 1555082345132, + "version": "2.10.1" + }, + "jinja2-2.9.6-py27h82327ae_1.tar.bz2": { + "build": "py27h82327ae_1", + "build_number": 1, + "depends": [ + "markupsafe >=0.23", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "3155dc5e6127587eb16092356ee535dd", + "name": "jinja2", + "sha256": "4640d8cea047fb6a7e473620b22d593efb1364a65f195d0fd8e19faebb282812", + "size": 331783, + "subdir": "linux-64", + "timestamp": 1505672379234, + "version": "2.9.6" + }, + "jinja2-2.9.6-py35h90b8645_1.tar.bz2": { + "build": "py35h90b8645_1", + "build_number": 1, + "depends": [ + "markupsafe >=0.23", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "0da19d39a9da68dbb8cc5058ca9f242b", + "name": "jinja2", + "sha256": "3576820ffdd1a2372dccb7472579112a8854271812bec1d5c6afe7b37a428518", + "size": 365266, + "subdir": "linux-64", + "timestamp": 1505672392862, + "version": "2.9.6" + }, + "jinja2-2.9.6-py36h489bce4_1.tar.bz2": { + "build": "py36h489bce4_1", + "build_number": 1, + "depends": [ + "markupsafe >=0.23", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "e5380d74f4a4a1afb6114b95f2f7dea7", + "name": "jinja2", + "sha256": "40b33af07ecafa232e72e32b5a5e9a22036a5a041f680ed6d9fb99ab2696e35b", + "size": 370938, + "subdir": "linux-64", + "timestamp": 1505672406680, + "version": "2.9.6" + }, + "jinja2-3.1.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "76227e72320c19ab16d6bda143f12096", + "name": "jinja2", + "sha256": "b9e48b8c30ebc01e30a49ced6ee45bdd89d153f412936db53f80b0d53227861b", + "size": 216531, + "subdir": "linux-64", + "timestamp": 1666908186956, + "version": "3.1.2" + }, + "jinja2-3.1.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aae6e7fc8df184bd49ab795f8991eb91", + "name": "jinja2", + "sha256": "c2ff5b76f927bd3694e0bea57b7689e211fc09e8857da94dca2deb2cf41b5eb0", + "size": 302037, + "subdir": "linux-64", + "timestamp": 1676823601235, + "version": "3.1.2" + }, + "jinja2-3.1.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b09fad994ccbded7410ac93349cb8e7f", + "name": "jinja2", + "sha256": "c0bd084cfad3b795f73d6c7283e7c858e616027482a1e5b78a8b5c392c894e04", + "size": 211409, + "subdir": "linux-64", + "timestamp": 1666908161286, + "version": "3.1.2" + }, + "jinja2-3.1.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "076bfd81cccc64215235fa877946a20f", + "name": "jinja2", + "sha256": "5eb7b3fd9af76470efa0e9959b5f24f0f2323cb33a0b5ef4a47e6589fe48a9df", + "size": 212296, + "subdir": "linux-64", + "timestamp": 1666908237448, + "version": "3.1.2" + }, + "jinja2-3.1.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eaeb023688f781e7dd89e74310c38195", + "name": "jinja2", + "sha256": "ac5842abf82b3a86091a3e46881ef74891d40442c53254b885e9c29f53af4d0f", + "size": 211775, + "subdir": "linux-64", + "timestamp": 1666908212136, + "version": "3.1.2" + }, + "jmespath-0.9.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2138f156090b557676d2b20eaabb00e8", + "name": "jmespath", + "sha256": "7889dc619c5b1be6c278aef62b9ad107d419d0e7a53178b1d5db39d7d04cfc51", + "size": 34659, + "subdir": "linux-64", + "timestamp": 1530736686119, + "version": "0.9.3" + }, + "jmespath-0.9.3-py27h7df6b23_0.tar.bz2": { + "build": "py27h7df6b23_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2de0cbb4ba961400b49c295dcfaf85d4", + "name": "jmespath", + "sha256": "19ca6219788c9e49003f2e597f9d4586acbe4d374e309bb96412b6cf655a5eff", + "size": 34457, + "subdir": "linux-64", + "timestamp": 1505740978273, + "version": "0.9.3" + }, + "jmespath-0.9.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a4fe05ec6a33f4e53d6fcdb5770557e3", + "name": "jmespath", + "sha256": "6f4cf3d7d4be78fb434e88d3e0079e52e3b76b905ad3fb2acb04ebbda460798c", + "size": 35680, + "subdir": "linux-64", + "timestamp": 1534352333374, + "version": "0.9.3" + }, + "jmespath-0.9.3-py35h8a35363_0.tar.bz2": { + "build": "py35h8a35363_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cbbf4fbc3b0d2a3c472be70087691934", + "name": "jmespath", + "sha256": "a8e6af624b27c868c71a51a4e66d391976180e4a508f2ff70271b38c1e5d0d98", + "size": 35562, + "subdir": "linux-64", + "timestamp": 1505740990926, + "version": "0.9.3" + }, + "jmespath-0.9.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ea11ca06afad6e03183df111e79f913", + "name": "jmespath", + "sha256": "537c47dfb6021ca3dcb4759875ac4d77805e086435b2a5ddc3658fabcf1a5e2b", + "size": 35351, + "subdir": "linux-64", + "timestamp": 1530736665109, + "version": "0.9.3" + }, + "jmespath-0.9.3-py36hd3948f9_0.tar.bz2": { + "build": "py36hd3948f9_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dfd4be76c119184a5ea4ae87c73ccff4", + "name": "jmespath", + "sha256": "dbd407f3a04d2c700d7d81dd83e65597b4cf8bc53ebe4c3ce765db415d0cffe4", + "size": 35164, + "subdir": "linux-64", + "timestamp": 1505741003574, + "version": "0.9.3" + }, + "jmespath-0.9.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "065a6fc665550ff2f3e31cb318bc245f", + "name": "jmespath", + "sha256": "2daffd0057de35d17b693551967d129f9fb6d9dad6acb267341e10cb09e7ff81", + "size": 35417, + "subdir": "linux-64", + "timestamp": 1530736707235, + "version": "0.9.3" + }, + "joblib-0.12-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ef06dac4ea8428f7101e4458212bf3c0", + "name": "joblib", + "sha256": "6a05fc8a8638307bf9a13cf3de2b5b20e0076fc1a585f96632bd3c615200a7df", + "size": 329109, + "subdir": "linux-64", + "timestamp": 1529943845096, + "version": "0.12" + }, + "joblib-0.12-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a6d222e41da2a48edc8e75d728795a53", + "name": "joblib", + "sha256": "ce3f47edf1f75bc7c44ca9d01a8b8d09fa82c450dbb77546caadb50c506151d1", + "size": 338043, + "subdir": "linux-64", + "timestamp": 1529943876472, + "version": "0.12" + }, + "joblib-0.12-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ecf043295d8e736b12a8a6b5c6edbd39", + "name": "joblib", + "sha256": "932caed21e2b4af417a832820a3180eebf2bb631e9edf8ac764973e5d1dd127e", + "size": 337644, + "subdir": "linux-64", + "timestamp": 1529943818226, + "version": "0.12" + }, + "joblib-0.12-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f4bbf083f273129e7a2cde9ae120f377", + "name": "joblib", + "sha256": "d15e437e63a719ada6a9efaa24eddc24541450a7b342584e01d46db22b5df387", + "size": 337187, + "subdir": "linux-64", + "timestamp": 1530902811876, + "version": "0.12" + }, + "joblib-0.12.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "844b4a3e73f30ca89dc4a472a848d8b5", + "name": "joblib", + "sha256": "ae947f5c1318894138fc38ca6065c8e73f658f6bb7565c0aa65da0c3869ba93f", + "size": 329756, + "subdir": "linux-64", + "timestamp": 1532534652266, + "version": "0.12.1" + }, + "joblib-0.12.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "28c83ecd867fb9de314bd8e2860dc8a6", + "name": "joblib", + "sha256": "aed3a70e2030ad5d06bc79aaf641170d3e574f4c7d35ec6c59dec87697039cc5", + "size": 338022, + "subdir": "linux-64", + "timestamp": 1532534643190, + "version": "0.12.1" + }, + "joblib-0.12.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "82eb6c38a1ae00cefb21157dccf226aa", + "name": "joblib", + "sha256": "b7d620f1185b51518703298bc806a0867381c96db478c56983c78283dd44a108", + "size": 338050, + "subdir": "linux-64", + "timestamp": 1532534633711, + "version": "0.12.1" + }, + "joblib-0.12.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d8174b7325d20d4f622e14e8db8f59d6", + "name": "joblib", + "sha256": "52a56fcdf2237b8e8cc4bf86bbfa61701fe575ab3d78cc5e25b6a7393ec626b8", + "size": 337788, + "subdir": "linux-64", + "timestamp": 1532534672781, + "version": "0.12.1" + }, + "joblib-0.12.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e5ff305d78c6c93ace27d90eef8dad96", + "name": "joblib", + "sha256": "28e4131db388d148897da7ec63a2c894a6b099e004e5dbeed15ad3993a5ec660", + "size": 336369, + "subdir": "linux-64", + "timestamp": 1534173012149, + "version": "0.12.2" + }, + "joblib-0.12.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0a790059e79eeb70eee4b9a5839df442", + "name": "joblib", + "sha256": "6297044d7fa58d68becb13b35e211ef5dc28b598d6e6fbf115a33c79de96fdf5", + "size": 341229, + "subdir": "linux-64", + "timestamp": 1534173069792, + "version": "0.12.2" + }, + "joblib-0.12.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e59bce3ffaf7c7b41cc5cf8141bf6d02", + "name": "joblib", + "sha256": "78203eebea3f05be773e8110a95628bb00c0feadb1038ce479e4a9682f99aba8", + "size": 341772, + "subdir": "linux-64", + "timestamp": 1534173021003, + "version": "0.12.2" + }, + "joblib-0.12.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1dedd11bf2918d9ad6fe4f6a67172083", + "name": "joblib", + "sha256": "52407ffd36b66ab003f01d884fdbaed2031f8d75eefe042e980cec4c4ab165bd", + "size": 341338, + "subdir": "linux-64", + "timestamp": 1534173049988, + "version": "0.12.2" + }, + "joblib-0.12.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a2ebd86ae4323ba996c8d428ae4a7562", + "name": "joblib", + "sha256": "b7648d8bf436ba06b03f6ac14895e35b10e653b05ee56baf28d6d1bc1e72217d", + "size": 343289, + "subdir": "linux-64", + "timestamp": 1536102440140, + "version": "0.12.3" + }, + "joblib-0.12.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b3704c0d662b6ff893ad88cd8ebb931c", + "name": "joblib", + "sha256": "b81b85e7a40708854fd51150c34a08847a52214246b78796826b749561ef1391", + "size": 349022, + "subdir": "linux-64", + "timestamp": 1536102454857, + "version": "0.12.3" + }, + "joblib-0.12.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "74a558bf5b28d1700dd827111816fb91", + "name": "joblib", + "sha256": "495d0e04455b471db80fcaff4685aa4de1e3b07abdc833dc0ff54b9dbbda98ea", + "size": 346935, + "subdir": "linux-64", + "timestamp": 1536102411723, + "version": "0.12.3" + }, + "joblib-0.12.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1ad2e27b7b776026d0ea6eb8b32a3e5d", + "name": "joblib", + "sha256": "6eb83cdd1debb72f57e7dd58e0bd657240872691127ca56578d06468410ce33e", + "size": 346595, + "subdir": "linux-64", + "timestamp": 1536102446763, + "version": "0.12.3" + }, + "joblib-0.12.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ea759f621a2e7d36b3ec3088bc0b17f1", + "name": "joblib", + "sha256": "46b7a34d4b86de7d566ba169458af0cbd5698afab2a8f7a1279d60872b95e560", + "size": 343250, + "subdir": "linux-64", + "timestamp": 1538176661770, + "version": "0.12.5" + }, + "joblib-0.12.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d5d2178771288025af231a6364646a12", + "name": "joblib", + "sha256": "4858e7a4cea303c8108b99afeb0fe15c6e3a0369f6fc98017f19b879cf0a06d5", + "size": 348108, + "subdir": "linux-64", + "timestamp": 1538176695132, + "version": "0.12.5" + }, + "joblib-0.12.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6443a9c1881599321167012b82018045", + "name": "joblib", + "sha256": "a03b50796f772e7452cc76e702f866458939b5974d232a0b0fdc01993f7ff63d", + "size": 347713, + "subdir": "linux-64", + "timestamp": 1538176659260, + "version": "0.12.5" + }, + "joblib-0.13.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "34f6076571ec6da40134cc61302dc247", + "name": "joblib", + "sha256": "7732a8fe9f688c7274f8f3702bfd681798c0754f21a7ea7c962bfe44c292da4d", + "size": 358230, + "subdir": "linux-64", + "timestamp": 1542080129057, + "version": "0.13.0" + }, + "joblib-0.13.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "be21e24c668a5f35668eada67d69fe92", + "name": "joblib", + "sha256": "06df20999b8d8fa8ee5c91d90d5ca0f737bca22225164efd42edefb0d49dc827", + "size": 365548, + "subdir": "linux-64", + "timestamp": 1542080111898, + "version": "0.13.0" + }, + "joblib-0.13.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4eb23532c8161e12c3095d6705cd1083", + "name": "joblib", + "sha256": "b2b5089d5caf97e46123717c1e1f5f663ce92eb07451751c9d350dcfb65a8aa1", + "size": 367000, + "subdir": "linux-64", + "timestamp": 1542080110819, + "version": "0.13.0" + }, + "joblib-0.13.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "005127c9008d36d38626f15113764c9a", + "name": "joblib", + "sha256": "2077f56c1f2068f366a311305c713ae7bc0dddcfa041d37e542c491635e73a11", + "size": 368004, + "subdir": "linux-64", + "timestamp": 1547750057946, + "version": "0.13.1" + }, + "joblib-0.13.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9b836b9da42982d79c9f8917152e8232", + "name": "joblib", + "sha256": "815cfed041eddff28932ec3c5f48fd1ad4d31c68d5f67a6b97a3081ac6d8c2fe", + "size": 368757, + "subdir": "linux-64", + "timestamp": 1547750127437, + "version": "0.13.1" + }, + "joblib-0.13.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9dd830a453517050e40c8ade48e781c7", + "name": "joblib", + "sha256": "6e35448c2111baa1c0c29ff8ef1a880ac310b66aea6c844d0dc491206637a3a2", + "size": 372667, + "subdir": "linux-64", + "timestamp": 1547750086026, + "version": "0.13.1" + }, + "joblib-0.13.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3373ca9708ff9995efe4fb849b437eea", + "name": "joblib", + "sha256": "98710d7e088f878453abb895237b1a6d317fb87c528b3f77d02989ea785f0493", + "size": 367084, + "subdir": "linux-64", + "timestamp": 1550348198201, + "version": "0.13.2" + }, + "joblib-0.13.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "841a85bd1858fa5b94053e97d772080b", + "name": "joblib", + "sha256": "53ea71c1e715d85d90f0165cdc8cf0d40317f0bdfadcbb4cd816d698d7733871", + "size": 373397, + "subdir": "linux-64", + "timestamp": 1550348196395, + "version": "0.13.2" + }, + "joblib-0.13.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e00f2a514273647c928878648ef1d723", + "name": "joblib", + "sha256": "ae726a1702cdb6f245f6a61e61dd1a40ce3c958d431ea00a2d7f238e01360ba0", + "size": 371526, + "subdir": "linux-64", + "timestamp": 1550348149568, + "version": "0.13.2" + }, + "joblib-1.1.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "04ad84a852def6d0fbfbd2f643db3878", + "name": "joblib", + "sha256": "6cf5190cb6f1d0251c3d6d2a3c580cf80550bb7b3263838ec097a176f0885ec3", + "size": 419467, + "subdir": "linux-64", + "timestamp": 1666298931868, + "version": "1.1.1" + }, + "joblib-1.1.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f93413f69d0ab3590454a551e9e983f1", + "name": "joblib", + "sha256": "efa72945010ac06bcdd42389971e8db20b6061d8b55780e15238d2ddfac88f5b", + "size": 544581, + "subdir": "linux-64", + "timestamp": 1676837036611, + "version": "1.1.1" + }, + "joblib-1.1.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e675c44d81a2774bdbc5873be5cbaa11", + "name": "joblib", + "sha256": "2a2fe5db9e5252e84262e5e81296a876f5467135470ef37d4ca2683ccf78ae01", + "size": 413911, + "subdir": "linux-64", + "timestamp": 1666298959625, + "version": "1.1.1" + }, + "joblib-1.1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "15cc28e2b2d13ae8863422b385038cf6", + "name": "joblib", + "sha256": "ea9c65c531959ae2085ea97a8368eb74e3f6efb404175d3b9169c1da71ecdf4a", + "size": 415833, + "subdir": "linux-64", + "timestamp": 1666298876713, + "version": "1.1.1" + }, + "joblib-1.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6709547ee61e4b47e2684ce4e6e2933d", + "name": "joblib", + "sha256": "97746f533d7eafc121b271de4420b320c625a8e6700b4268407754a565304f53", + "size": 416070, + "subdir": "linux-64", + "timestamp": 1666298904238, + "version": "1.1.1" + }, + "jpeg-9b-h024ee3a_2.tar.bz2": { + "build": "h024ee3a_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "Custom free software license", + "md5": "30883b0c44d35192a9b7967b0da9bf98", + "name": "jpeg", + "sha256": "3baeea4d1f10060b12646c49480576cea314f247f5217a44b71dac0402bee4f9", + "size": 254074, + "subdir": "linux-64", + "timestamp": 1510201951443, + "version": "9b" + }, + "jpeg-9b-h376031c_1.tar.bz2": { + "build": "h376031c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "Custom free software license", + "md5": "a0e741eddd9b96075ef37f580886ac62", + "name": "jpeg", + "sha256": "3c88c476e4a4d5dc64d703bc27db1c35f26b94f454ca919cc47555f64849a4b5", + "size": 254047, + "subdir": "linux-64", + "timestamp": 1509502668308, + "version": "9b" + }, + "jpeg-9b-habf39ab_1.tar.bz2": { + "build": "habf39ab_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "Custom free software license", + "md5": "16bca0084212b9e8ce7f89516cad0227", + "name": "jpeg", + "sha256": "03c81fb19b27c2741d529f15d9bcdc0ca1e085a952bbbc66f52e10ef8dff5c25", + "size": 253195, + "subdir": "linux-64", + "timestamp": 1505735527625, + "version": "9b" + }, + "jpeg-9d-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "Custom free software license", + "md5": "b3d8b4bf24d3ac7bd969f0ab0a131d4a", + "name": "jpeg", + "sha256": "6eb717b78a79637845166237ca2210184037384289820834f86fbf0c0a68888c", + "size": 271770, + "subdir": "linux-64", + "timestamp": 1631864296647, + "version": "9d" + }, + "jpeg-9e-h5eee18b_1.tar.bz2": { + "build": "h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "IJG", + "license_family": "Other", + "md5": "ba1f47411e9e07876c7a3e9d3be6a98e", + "name": "jpeg", + "sha256": "c21f8f407266d039e819c27fe9eb4fb26587e974f3bd059b37cbaec5073722d0", + "size": 281400, + "subdir": "linux-64", + "timestamp": 1677849152168, + "version": "9e" + }, + "jpeg-9e-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "IJG", + "license_family": "Other", + "md5": "6e1c0fb5260c590f7ef5235cb3d05863", + "name": "jpeg", + "sha256": "85348bfb14db4fea84078d703e766a3c978c5a592a06e41266748826dd59d8ae", + "size": 279884, + "subdir": "linux-64", + "timestamp": 1651065953960, + "version": "9e" + }, + "jpype1-1.0.2-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "md5": "bc43cbde33cda7db68faf2c3ed46fbae", + "name": "jpype1", + "sha256": "5fa859794fdb70af16f2d64bac70042d61d8eaaa5ce3228d3462dc4b5e2be504", + "size": 3064345, + "subdir": "linux-64", + "timestamp": 1601400922437, + "version": "1.0.2" + }, + "jpype1-1.0.2-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "md5": "559416eb5ed499f851bc7eb76e5d552b", + "name": "jpype1", + "sha256": "487f31ead4aae18fab84c9c8c65059fc0f80255fc64bdf1d2961a34ae0af7649", + "size": 3090014, + "subdir": "linux-64", + "timestamp": 1601400871501, + "version": "1.0.2" + }, + "jpype1-1.0.2-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "5326276b88083df918cbba7026d104f3", + "name": "jpype1", + "sha256": "58dc752690b86e3d949e30d43999c00ba04f8ea19ee98dbd46ad8b36b070072a", + "size": 3074277, + "subdir": "linux-64", + "timestamp": 1601400894345, + "version": "1.0.2" + }, + "jpype1-1.1.2-py36hff7bd54_0.tar.bz2": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "md5": "38c4698a0bfc614e3e179479f91217ef", + "name": "jpype1", + "sha256": "f361b2ee67be1b6903fa84c82ded17b3d71b1232c7c4584aa1bfd8c739cd77a6", + "size": 454051, + "subdir": "linux-64", + "timestamp": 1604013964037, + "version": "1.1.2" + }, + "jpype1-1.1.2-py37hff7bd54_0.tar.bz2": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "md5": "c818c86c2051ae391eb1870a20a1574f", + "name": "jpype1", + "sha256": "fc4f9136e6de6858eae9ed0455e3b02b4ecb693af63ee2987d14f45e868656c9", + "size": 464520, + "subdir": "linux-64", + "timestamp": 1604013959343, + "version": "1.1.2" + }, + "jpype1-1.1.2-py38hff7bd54_0.tar.bz2": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "f40c2409c64d5bdabb1f01448fb5de5d", + "name": "jpype1", + "sha256": "e49df5318641e93291a9fbad06370c27fbc18ea3709e0b612518bb0bd13269e7", + "size": 455596, + "subdir": "linux-64", + "timestamp": 1604013989703, + "version": "1.1.2" + }, + "jpype1-1.2.1-py36hff7bd54_0.tar.bz2": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "md5": "9b1cc0e468fd360eec8489cc1c7a9755", + "name": "jpype1", + "sha256": "13cfcd80150d0ab86e2b86e296b4a280727c93c9c764153e31cf4aa113acd053", + "size": 469587, + "subdir": "linux-64", + "timestamp": 1609785231179, + "version": "1.2.1" + }, + "jpype1-1.2.1-py37hff7bd54_0.tar.bz2": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "md5": "3a22ecd14c708594dbdb7802890429cf", + "name": "jpype1", + "sha256": "6638740dc273741512e26af7699e23dccd4e316d2d38777b0c26cd71f8f58311", + "size": 485838, + "subdir": "linux-64", + "timestamp": 1609785346655, + "version": "1.2.1" + }, + "jpype1-1.2.1-py38hff7bd54_0.tar.bz2": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "f7860e3229fd216c542280111bf0957b", + "name": "jpype1", + "sha256": "d62a08af3a6027b4a6d13522ff159c4ecd1a7e208e66fd1656d42d043fe8389e", + "size": 473199, + "subdir": "linux-64", + "timestamp": 1609785317589, + "version": "1.2.1" + }, + "jpype1-1.2.1-py39hff7bd54_0.tar.bz2": { + "build": "py39hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "43557c520026d0203e143eb0a9767e50", + "name": "jpype1", + "sha256": "52584c58dd0a6313cd3c12e3000e5203fb2e374804ddde8317ad6ed1dd0b1e74", + "size": 470536, + "subdir": "linux-64", + "timestamp": 1609785334036, + "version": "1.2.1" + }, + "jpype1-1.3.0-py310hd09550d_0.tar.bz2": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "c82392f498c8d2800c39f09e9b69de5a", + "name": "jpype1", + "sha256": "f565dc6968b1808606a8c668766cf5c7273b1d42f1ff8a8a7ba720d4785d6746", + "size": 480076, + "subdir": "linux-64", + "timestamp": 1643968732370, + "version": "1.3.0" + }, + "jpype1-1.3.0-py37hd09550d_0.tar.bz2": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "md5": "3931c99e539c6ca56ca4251ccdf2a063", + "name": "jpype1", + "sha256": "a81ae18a1d9ef12ddddc31c828d78c3487d528dbc42ab2a470240fb043951154", + "size": 478566, + "subdir": "linux-64", + "timestamp": 1643968653546, + "version": "1.3.0" + }, + "jpype1-1.3.0-py38hd09550d_0.tar.bz2": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "45c1fb68a3b08789634e52ce48db323a", + "name": "jpype1", + "sha256": "00e005580ad99445cf2439fcca017900aeeb712fc9221964fd76de0c7ae73b9a", + "size": 481586, + "subdir": "linux-64", + "timestamp": 1643968797362, + "version": "1.3.0" + }, + "jpype1-1.3.0-py39hd09550d_0.tar.bz2": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "a35e3c90b5e399d9787e13022c0acd52", + "name": "jpype1", + "sha256": "3dddc23d4309182b1d0ab3d4f141cfa84287efc62d36ffe7f96028c1c5f6fca5", + "size": 479146, + "subdir": "linux-64", + "timestamp": 1643968866804, + "version": "1.3.0" + }, + "jpype1-1.4.1-py310hdb19cb5_0.tar.bz2": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "57f0436d8f95a9a901e9c0a554dafa45", + "name": "jpype1", + "sha256": "f1e64bbdd09f48aacfeaa6f8b2ead8d3e0a7106a40aa9fd8f7efda9d44161244", + "size": 503186, + "subdir": "linux-64", + "timestamp": 1674515356498, + "version": "1.4.1" + }, + "jpype1-1.4.1-py311hdb19cb5_0.tar.bz2": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cf418789d4acb6d8a79a452be86f7821", + "name": "jpype1", + "sha256": "d7680cdc99da041b3959b77d7cdf542f1f35e1895fea1fada71edee2ffcfe1f3", + "size": 538659, + "subdir": "linux-64", + "timestamp": 1676852985424, + "version": "1.4.1" + }, + "jpype1-1.4.1-py37hdb19cb5_0.tar.bz2": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0c242858006824e09c0d1bb11251650c", + "name": "jpype1", + "sha256": "89a999d691462dcde703b49f7956a625dd0c2c2cc24fab24e62ec638e18516d5", + "size": 502900, + "subdir": "linux-64", + "timestamp": 1674515420627, + "version": "1.4.1" + }, + "jpype1-1.4.1-py38hdb19cb5_0.tar.bz2": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4bf62c57cfb4187e0b1567abd6dcd3b5", + "name": "jpype1", + "sha256": "28aeb36c7a469773d271521d41c8f8fe7565a38fbdaa5c9fa8b0ceee44fb65c7", + "size": 503493, + "subdir": "linux-64", + "timestamp": 1674515227594, + "version": "1.4.1" + }, + "jpype1-1.4.1-py39hdb19cb5_0.tar.bz2": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "71c2ed74d2fd669a8d5f8ae736e3eee4", + "name": "jpype1", + "sha256": "1d24be97b8758a2a1f643e3639e24af16a590f0e81c6861d3dcc188de072f48e", + "size": 503571, + "subdir": "linux-64", + "timestamp": 1674515291629, + "version": "1.4.1" + }, + "jq-1.6-h27cfd23_1.tar.bz2": { + "build": "h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "oniguruma 6.9.*", + "oniguruma >=6.9.3,<6.10.0a0" + ], + "license": "MIT", + "md5": "574a14ab2cf342cca56710e273683083", + "name": "jq", + "sha256": "6050f13c265c78f7fa123addbccb02dce8710ec22ab14f9941c75fecadeff4ad", + "size": 378930, + "subdir": "linux-64", + "timestamp": 1604748492335, + "version": "1.6" + }, + "jq-1.6-h27cfd23_1000.tar.bz2": { + "build": "h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "oniguruma 6.9.*", + "oniguruma >=6.9.3,<6.10.0a0" + ], + "license": "MIT", + "md5": "e275805740c3196af07e2b9375f303a1", + "name": "jq", + "sha256": "7e3f64024e1f956cef9cca33ba90d855073f8e5049011ed79f9473251724623c", + "size": 375514, + "subdir": "linux-64", + "timestamp": 1604335045432, + "version": "1.6" + }, + "js2py-0.71-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pyjsparser >=2.5.1", + "python >=3.10,<3.11.0a0", + "six >=1.10", + "tzlocal >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea31b5ed75fc89deb6f8a6718339e317", + "name": "js2py", + "sha256": "5cd3e013523c1e304567f90ce9cb4e02da3fb965af8e3da1c684e14cfdd04477", + "size": 1810033, + "subdir": "linux-64", + "timestamp": 1663948596274, + "version": "0.71" + }, + "js2py-0.71-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pyjsparser >=2.5.1", + "python >=3.7,<3.8.0a0", + "six >=1.10", + "tzlocal >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8934f180ca5043c690de23a932226cd8", + "name": "js2py", + "sha256": "f02d3bf6516e9b86ad88a3226f72757be2649a7a911084de9db9ff46248d53ae", + "size": 1750340, + "subdir": "linux-64", + "timestamp": 1663948476181, + "version": "0.71" + }, + "js2py-0.71-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pyjsparser >=2.5.1", + "python >=3.8,<3.9.0a0", + "six >=1.10", + "tzlocal >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f63e0a48fb533cd70046ea9a1fd0745", + "name": "js2py", + "sha256": "f5affae4e4827206569b65923e2f5ee92725b4984a2c4d0544abd0a927f256f8", + "size": 1755752, + "subdir": "linux-64", + "timestamp": 1663948510716, + "version": "0.71" + }, + "js2py-0.71-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pyjsparser >=2.5.1", + "python >=3.9,<3.10.0a0", + "six >=1.10", + "tzlocal >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6baa080906c48263718671108df2f94", + "name": "js2py", + "sha256": "b58f9ed0d277183043962ff93fdf19e261b6a770e2a7992c2cf807a341f63f99", + "size": 1776635, + "subdir": "linux-64", + "timestamp": 1663948546861, + "version": "0.71" + }, + "js2py-0.74-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pyjsparser >=2.5.1", + "python >=3.10,<3.11.0a0", + "six >=1.10", + "tzlocal >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd08749dd9d04cc2f3ff378cd4f7647c", + "name": "js2py", + "sha256": "fb09aebce632dce6a9682dd39b362c9119387a6c7fc18e50655d6cd99a84028e", + "size": 1805086, + "subdir": "linux-64", + "timestamp": 1679573781415, + "version": "0.74" + }, + "js2py-0.74-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pyjsparser >=2.5.1", + "python >=3.11,<3.12.0a0", + "six >=1.10", + "tzlocal >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c051149901e2d424a7806d4110ca969", + "name": "js2py", + "sha256": "f461bfa5b839865f0e83288d28f3bc6583213af68e4e7dbe09f6f2e31a85d083", + "size": 3476985, + "subdir": "linux-64", + "timestamp": 1679573677178, + "version": "0.74" + }, + "js2py-0.74-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pyjsparser >=2.5.1", + "python >=3.8,<3.9.0a0", + "six >=1.10", + "tzlocal >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "122b730a02a2e5573b149f1b786e6eb6", + "name": "js2py", + "sha256": "9d2ab3e0b2281f5e4c3e33e49f026fbba716826dfdb92869d69e21f1ade9dc84", + "size": 1750037, + "subdir": "linux-64", + "timestamp": 1679573713578, + "version": "0.74" + }, + "js2py-0.74-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pyjsparser >=2.5.1", + "python >=3.9,<3.10.0a0", + "six >=1.10", + "tzlocal >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af3fb2ee0ea8f79f7cab891f128075ac", + "name": "js2py", + "sha256": "436feff8fdce69bee099bc18fe4e99ef44bb8f6bd015d7441dcade712f9777f9", + "size": 1769039, + "subdir": "linux-64", + "timestamp": 1679573746682, + "version": "0.74" + }, + "json-c-0.12.1-ha6a3662_2.tar.bz2": { + "build": "ha6a3662_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "bfca6406c4c62cacbe96da68c8270121", + "name": "json-c", + "sha256": "ce16bed713712a9c1628f2c43c0a9bffeb603bb853d021015a43b1bae46a1e2e", + "size": 50987, + "subdir": "linux-64", + "timestamp": 1511371612257, + "version": "0.12.1" + }, + "json-c-0.13.1-h1bed415_0.tar.bz2": { + "build": "h1bed415_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "d62003ffec6d7b46dd2f23c1d2ef1a22", + "name": "json-c", + "sha256": "3467b6700f6886bd0faa30eedcb9cc616f3c913c555e8ae92f8a2f8a14fbc9c5", + "size": 71804, + "subdir": "linux-64", + "timestamp": 1520912298499, + "version": "0.13.1" + }, + "json-c-0.16-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0594055417685a7b7a828c2647fb8fc3", + "name": "json-c", + "sha256": "eaf9ba80be45651a8e3c8598bd3b00e5671cd929359c06d7c9b668a3636ee04c", + "size": 84251, + "subdir": "linux-64", + "timestamp": 1659123696523, + "version": "0.16" + }, + "jsoncpp-1.8.3-h3a67955_0.tar.bz2": { + "build": "h3a67955_0", + "build_number": 0, + "depends": [ + "libstdcxx-ng >=7.2.0" + ], + "license": "Public Domain/MIT", + "md5": "14c8edf29d506e5864787bed8bb80ef8", + "name": "jsoncpp", + "sha256": "0aca251947df340540f99c41337c4940ff70597802ef095ffbf238915a8ef175", + "size": 160301, + "subdir": "linux-64", + "timestamp": 1508958342092, + "version": "1.8.3" + }, + "jsoncpp-1.8.4-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Public Domain/MIT", + "md5": "1f2d3b0db9abfbd52ca8a1e3f987154c", + "name": "jsoncpp", + "sha256": "51c60b1aa0e9db151bdea8d69b5b93473b4053f1f76db8244a739649b8f715b9", + "size": 161311, + "subdir": "linux-64", + "timestamp": 1539527206948, + "version": "1.8.4" + }, + "jsoncpp-1.9.4-hff7bd54_0.tar.bz2": { + "build": "hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Public Domain/MIT", + "md5": "094d06a20f27b9992730d4aaeac1c8c0", + "name": "jsoncpp", + "sha256": "470f1ac7025b72fa28f61581a5691ae88f07be5f621e135c2eaf1ff72bca9871", + "size": 251279, + "subdir": "linux-64", + "timestamp": 1619131096802, + "version": "1.9.4" + }, + "jsoncpp-1.9.4-hff7bd54_2.tar.bz2": { + "build": "hff7bd54_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Public Domain/MIT", + "md5": "86a01e3466dc4292269503611db9a5ce", + "name": "jsoncpp", + "sha256": "9c219c1420a980829fcd3e8b5d1b32c9e840e82bb78c85c6ed9914a87f24b29a", + "size": 291787, + "subdir": "linux-64", + "timestamp": 1619620540210, + "version": "1.9.4" + }, + "jsondate-0.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13d744c562afb11e46d996880966946c", + "name": "jsondate", + "sha256": "dd2833f806aadbf6b1341883008826c4f9a6f97acc49d804b758d0640bcab9dc", + "size": 8120, + "subdir": "linux-64", + "timestamp": 1530897972899, + "version": "0.1.2" + }, + "jsondate-0.1.2-py27h2933415_0.tar.bz2": { + "build": "py27h2933415_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3af33ad567fcc975beab2d4b0328dbcf", + "name": "jsondate", + "sha256": "14ea43e62f390708ef9e0928617b55046e6a0a6a52e6bd9657835191cec8b442", + "size": 8416, + "subdir": "linux-64", + "timestamp": 1509139728161, + "version": "0.1.2" + }, + "jsondate-0.1.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de611244dac6613055fc9dd8ef5675f2", + "name": "jsondate", + "sha256": "193810cb7938a2fea8079c3dfa9a50ef6d99edb57f70bf6779a8097636a7b988", + "size": 8608, + "subdir": "linux-64", + "timestamp": 1640791219969, + "version": "0.1.2" + }, + "jsondate-0.1.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0fb4a4cb12fd63443c0a04cdfe7d9fa", + "name": "jsondate", + "sha256": "ae9fbf7a31e357d32db8a427998b6762c0aba27fd1e1609f3215f067466df65e", + "size": 10307, + "subdir": "linux-64", + "timestamp": 1676853001325, + "version": "0.1.2" + }, + "jsondate-0.1.2-py35hde4c474_0.tar.bz2": { + "build": "py35hde4c474_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4200f7d91ca6f549cff5c1375e5f7ce", + "name": "jsondate", + "sha256": "b6563fbbfef04aa0b9cfa3d2ae071eeb4b3564d5af76afceb173e33006b6ea3c", + "size": 8564, + "subdir": "linux-64", + "timestamp": 1509139802251, + "version": "0.1.2" + }, + "jsondate-0.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "29777746507968db5035440e1ad67cd6", + "name": "jsondate", + "sha256": "a741ae537d628006b8677012820eb44e462f9d9aa9e4e747153ebee38dfc2c7a", + "size": 8294, + "subdir": "linux-64", + "timestamp": 1530898025972, + "version": "0.1.2" + }, + "jsondate-0.1.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f022155b2680a77456b25fb78a1e63b", + "name": "jsondate", + "sha256": "ed55446427bdcb8af15d5e9015509900b0f99476c060527ed83dcd4398da761e", + "size": 9037, + "subdir": "linux-64", + "timestamp": 1614070136078, + "version": "0.1.2" + }, + "jsondate-0.1.2-py36hd087d56_0.tar.bz2": { + "build": "py36hd087d56_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c76e55d2cd1dbbadea0887d79f82986b", + "name": "jsondate", + "sha256": "224653876b438f9c871eec4a2a063136df9e5294fba4f56d8bb6d39372f09bda", + "size": 8551, + "subdir": "linux-64", + "timestamp": 1509139814420, + "version": "0.1.2" + }, + "jsondate-0.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd728623bff42e0b59e33cae14fab183", + "name": "jsondate", + "sha256": "e7380a9a181f0179dad7694ab7ec9c39b1a1edfd1c3d45c2546d0b26b055a501", + "size": 8272, + "subdir": "linux-64", + "timestamp": 1530897999335, + "version": "0.1.2" + }, + "jsondate-0.1.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dcaf08e8589e3095b4d2110cf4f36dca", + "name": "jsondate", + "sha256": "54f17ba8cc5ee1a5e0bc172d54d66749b8b51147cbb3ba0bf84f95cda384f2f2", + "size": 9030, + "subdir": "linux-64", + "timestamp": 1614070229965, + "version": "0.1.2" + }, + "jsondate-0.1.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a2431f47b261b0d146c5423f4e8b1f60", + "name": "jsondate", + "sha256": "e661e3dc1f032cf78080d1ce8309a91ef8d6132f2fb00f80010d66c45a5bca0b", + "size": 8719, + "subdir": "linux-64", + "timestamp": 1573489732190, + "version": "0.1.2" + }, + "jsondate-0.1.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98c9a4b23172d37f2567be75f6322a35", + "name": "jsondate", + "sha256": "660544a04be42bc779c1c7d5f352625bdc1390cbecd859cd42c771af2d8fc777", + "size": 9057, + "subdir": "linux-64", + "timestamp": 1614069315232, + "version": "0.1.2" + }, + "jsondate-0.1.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b4483c1ef2aa5bb90103cf91468fc86", + "name": "jsondate", + "sha256": "563be66f18b8a4de06edbcf3a4c0fde86c51e5f849685b70f05d4d45e1492643", + "size": 9085, + "subdir": "linux-64", + "timestamp": 1614070246449, + "version": "0.1.2" + }, + "jsondiff-1.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0eaeaf248d8e1d2750f0b16f3ac0c3e4", + "name": "jsondiff", + "sha256": "feb372052488c8a4a2866accf993390f670772c27a032ca982810f72e67025a4", + "size": 15759, + "subdir": "linux-64", + "timestamp": 1543383167096, + "version": "1.1.1" + }, + "jsondiff-1.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66683317a70741d9c49634a56d58060e", + "name": "jsondiff", + "sha256": "a76d3b45e892cb03bc7e9b7f9fac6850ac8718b432c44da3fd1d19d4677d4800", + "size": 16129, + "subdir": "linux-64", + "timestamp": 1543383184061, + "version": "1.1.1" + }, + "jsondiff-1.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "46f236214074428f072070ffe87ac151", + "name": "jsondiff", + "sha256": "e0327e0943a7dad954a94dcf9057c6dde5a57cffbf8ab85394e297755c85e095", + "size": 16108, + "subdir": "linux-64", + "timestamp": 1543383149370, + "version": "1.1.1" + }, + "jsondiff-1.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f693ecd8b6be64d39a1538d93fe1195e", + "name": "jsondiff", + "sha256": "920a9cc6924083a9894fbd6ead9d486bb6b63c6129f9bcf3aafc9bae469f87de", + "size": 16192, + "subdir": "linux-64", + "timestamp": 1552437708480, + "version": "1.1.2" + }, + "jsondiff-1.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ac390d2be3e82806e3a6389489dbc017", + "name": "jsondiff", + "sha256": "1a0a7ab1392a555e58019fd3dc0d400d1b49c68225d494c55a66b9e01da8496e", + "size": 16539, + "subdir": "linux-64", + "timestamp": 1552437685154, + "version": "1.1.2" + }, + "jsondiff-1.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a923852af28ffb228e8b98b43297c44e", + "name": "jsondiff", + "sha256": "f5020eeee7e90db73436f689f3827ee4c8131e183d69475e925a9e8e30fed4fa", + "size": 16589, + "subdir": "linux-64", + "timestamp": 1552437776612, + "version": "1.1.2" + }, + "jsonpickle-2.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d22c78fb3b3e915be1e3ee305f7adf6a", + "name": "jsonpickle", + "sha256": "210ec1cc85dc05edceed65d77f967e110b6504277875e3fa7e69db4c54b7aa5c", + "size": 63769, + "subdir": "linux-64", + "timestamp": 1659021481631, + "version": "2.2.0" + }, + "jsonpickle-2.2.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5921a304233622bbccb7cdeeacf6b77e", + "name": "jsonpickle", + "sha256": "215e285cfb7f7aaf8c3960200f721d573e2d8a4046f86d3aa62a61152aac3135", + "size": 81833, + "subdir": "linux-64", + "timestamp": 1676853016209, + "version": "2.2.0" + }, + "jsonpickle-2.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c39fa485ba95dfcdf68a82a46a110ada", + "name": "jsonpickle", + "sha256": "0fa1774920ff4f62c481c21bba31fafa2068417131319fdb2a25f11f3dcd1fac", + "size": 63000, + "subdir": "linux-64", + "timestamp": 1659021400367, + "version": "2.2.0" + }, + "jsonpickle-2.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "822e94c23bf0457b1d0a41c93e074957", + "name": "jsonpickle", + "sha256": "51f77a0f161b2571dd568d4c15de6fca9ecce6e3958bc7c0bd2ca5a9363bba0c", + "size": 63281, + "subdir": "linux-64", + "timestamp": 1659021366097, + "version": "2.2.0" + }, + "jsonpickle-2.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e32f1a42bc6bbe3e212b77d700704219", + "name": "jsonpickle", + "sha256": "bef7065b090b7468861ad5103d17e6bb95c87211c0853f1a9db52092097fc5ba", + "size": 63264, + "subdir": "linux-64", + "timestamp": 1659021433559, + "version": "2.2.0" + }, + "jsonschema-2.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "functools32", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "d4ef7593351df1ce14eb0b1ebf7b46d5", + "name": "jsonschema", + "sha256": "ca3ce7cf9d3a4cadda202dcee3d1612c7ddf00d5b93b73606c7b7952f0235086", + "size": 62365, + "subdir": "linux-64", + "timestamp": 1530693972968, + "version": "2.6.0" + }, + "jsonschema-2.6.0-py27h7ed5aa4_0.tar.bz2": { + "build": "py27h7ed5aa4_0", + "build_number": 0, + "depends": [ + "functools32", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "ecbda32e3aaf5fb331581ebdc5ca28b1", + "name": "jsonschema", + "sha256": "e1d1bb03e9963de956956506872acfed85b81b5e7fe14d63fc59eaee6155d87b", + "size": 62305, + "subdir": "linux-64", + "timestamp": 1505672201982, + "version": "2.6.0" + }, + "jsonschema-2.6.0-py35h4395190_0.tar.bz2": { + "build": "py35h4395190_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "66d8624b3fd9f81fbb6dd1b1ff0d8077", + "name": "jsonschema", + "sha256": "fa7085c04d941fe677f56af53ea66bd2c32f8b0a13bd73a6d1864d2ed954f2c4", + "size": 64025, + "subdir": "linux-64", + "timestamp": 1505672214133, + "version": "2.6.0" + }, + "jsonschema-2.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "99d3a2f036f425ef2678182bb64f6b89", + "name": "jsonschema", + "sha256": "1db8f3a6bba2544340282af45d76243ae8abe5306009583790cd22273675b3cf", + "size": 63733, + "subdir": "linux-64", + "timestamp": 1530693932134, + "version": "2.6.0" + }, + "jsonschema-2.6.0-py36h006f8b5_0.tar.bz2": { + "build": "py36h006f8b5_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "94174efcf1b0d5ffe40c96d6f5a6972c", + "name": "jsonschema", + "sha256": "382517cb33941723fe54ce8eb249069c82e5cd7d5808375e85ee78a76ab7bf91", + "size": 63564, + "subdir": "linux-64", + "timestamp": 1505672226456, + "version": "2.6.0" + }, + "jsonschema-2.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "9fb605f536235ac287d93f0da419879f", + "name": "jsonschema", + "sha256": "fe34798e08f3f6b97be6c3c867113aa32d03d1b42c6a85300ef28ff60813c4d5", + "size": 63875, + "subdir": "linux-64", + "timestamp": 1530693952933, + "version": "2.6.0" + }, + "jsonschema-3.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "functools32", + "pyrsistent >=0.14.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "53e616f65ec05bf7ecf909394485b3f8", + "name": "jsonschema", + "sha256": "8eb094712e57c81f5cc1bdcd54693b01d9fc1b49d2ec8070ecda98cdad0a525b", + "size": 87976, + "subdir": "linux-64", + "timestamp": 1552335896413, + "version": "3.0.1" + }, + "jsonschema-3.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent >=0.14.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "137100fc70d30982f727139cea44f611", + "name": "jsonschema", + "sha256": "53f65f2edb213673c23385ba18df14f4ff2179d33cfa2ea9ab16016ca9cd27a2", + "size": 90077, + "subdir": "linux-64", + "timestamp": 1552335993372, + "version": "3.0.1" + }, + "jsonschema-3.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent >=0.14.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "c6cd54b982ddddb6c22141d33b7ff35d", + "name": "jsonschema", + "sha256": "14cc459a040d25db79921534831e89c1128bacb121d444abc97236498a4609db", + "size": 90515, + "subdir": "linux-64", + "timestamp": 1552340741547, + "version": "3.0.1" + }, + "jsonschema-3.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "functools32", + "pyrsistent >=0.14.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "19ac7ae49d8bbf1101e37f7b74d411eb", + "name": "jsonschema", + "sha256": "36decc1cea3a0066a700fc5f0101484639b40e1f828191e941494b4b099a0745", + "size": 90822, + "subdir": "linux-64", + "timestamp": 1565957026120, + "version": "3.0.2" + }, + "jsonschema-3.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent >=0.14.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "a05e5dc43c5aafeec38a14b6d0f95e5e", + "name": "jsonschema", + "sha256": "ccfde3cc6018d996cf3c5e2139987a0133c4cb7d7b46fab97a63296881c50627", + "size": 92573, + "subdir": "linux-64", + "timestamp": 1565957034144, + "version": "3.0.2" + }, + "jsonschema-3.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent >=0.14.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "78d401cfaf3b56fb8acaba3d2359bf2c", + "name": "jsonschema", + "sha256": "78f9f71f1495e7c2c1510d880f301d5eb409edd05adf1b8b73e45de9f95ba5d8", + "size": 92854, + "subdir": "linux-64", + "timestamp": 1565957057091, + "version": "3.0.2" + }, + "jsonschema-3.0.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "fcb115b3b504320f25fe609ae9b0b878", + "name": "jsonschema", + "sha256": "c3beeba6d0357b4e8e4c63ae96353a4f9a44cdcfea8e35a522b0a50582eadd36", + "size": 94335, + "subdir": "linux-64", + "timestamp": 1594303840751, + "version": "3.0.2" + }, + "jsonschema-3.0.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent >=0.14.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "33ba174313c5c4b6bcc6310ddeba0d9d", + "name": "jsonschema", + "sha256": "650f91aaaa567c69e63665f7af5a224b93aaa2bc6cf6f1a660498995e606709b", + "size": 93990, + "subdir": "linux-64", + "timestamp": 1608322003951, + "version": "3.0.2" + }, + "jsonschema-3.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "functools32", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "81d7e44865ab28db22f1a2808cd3614d", + "name": "jsonschema", + "sha256": "820bb61297c7125ad51df7e736fe5a14f8a03bce2192d82124906d4635d341bf", + "size": 92301, + "subdir": "linux-64", + "timestamp": 1571757583344, + "version": "3.1.1" + }, + "jsonschema-3.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "965a0015618653e6c50c91b3e62793d3", + "name": "jsonschema", + "sha256": "2c0cf6fccb459dcdac8d4c53a1f0b4d946de6e6698ff68907b4a1abad8dcbb78", + "size": 94479, + "subdir": "linux-64", + "timestamp": 1571757605489, + "version": "3.1.1" + }, + "jsonschema-3.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "047fa2f806f688658875d536b540965f", + "name": "jsonschema", + "sha256": "19f39fcf579f548d1f8fc1343b8fdc1b2b80a89e323651689779668ff2672d65", + "size": 94578, + "subdir": "linux-64", + "timestamp": 1571757607039, + "version": "3.1.1" + }, + "jsonschema-3.1.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "9629cb404f19d51c02da0a3ec1cea86c", + "name": "jsonschema", + "sha256": "3cc7a22c8622d115892287c5607e8200f7757d8921a8eb09ccd0cab8d4e1e90f", + "size": 91962, + "subdir": "linux-64", + "timestamp": 1574158041698, + "version": "3.1.1" + }, + "jsonschema-3.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "functools32", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "468bb1c54548e4620f53fbb2e0fc5c0f", + "name": "jsonschema", + "sha256": "5e64ac9945af16a09ef73e04420b7a60c790e59149cf7a604d49eaa1d5d081fe", + "size": 93307, + "subdir": "linux-64", + "timestamp": 1574266800104, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.10,<3.11.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "fa5fa59d0d84ba19f8310e3922fab011", + "name": "jsonschema", + "sha256": "f798d0d548b970c3317df84f8bded5df5f2a3a44487151e46629736b75e200a4", + "size": 93933, + "subdir": "linux-64", + "timestamp": 1640878114983, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "6e99898e5394b416d1ef2abaa62d67b4", + "name": "jsonschema", + "sha256": "c00c49942ef4b9d53f93e01d0f3427fb96d7b05550d1702a7a068c27541f84af", + "size": 95229, + "subdir": "linux-64", + "timestamp": 1574266890507, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "1f0a27be7cba83e7eecde95d8cbf8d54", + "name": "jsonschema", + "sha256": "ca73f8bc32ec19d8ed4b6761acb810142b0c8c08b5b9c30e9711548e37c85256", + "size": 91634, + "subdir": "linux-64", + "timestamp": 1601490641956, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "054e630503215a2504e08d09ac7278d2", + "name": "jsonschema", + "sha256": "c27a48625ac62c1fcc1ec8a793853d656a8fecb2d410d824189bafb8d6ffb40e", + "size": 95335, + "subdir": "linux-64", + "timestamp": 1632891494325, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "f7e3e38e3212a7c8cb430d621fdbdc88", + "name": "jsonschema", + "sha256": "be82adab6f59c04ed6c10f57a787123da57e1fa3e3f67de8e485c920763e86f5", + "size": 95402, + "subdir": "linux-64", + "timestamp": 1574266775784, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "d12d2ffc41700e344ca0f30b3c71e615", + "name": "jsonschema", + "sha256": "8499bea19b38521810a7dc31417f675271e4e898bda8d290ae7be6327ab6bbfc", + "size": 91026, + "subdir": "linux-64", + "timestamp": 1594363581181, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "770b411ee823ec9758ba6d7480dbcace", + "name": "jsonschema", + "sha256": "790691df851606fc7d7e09fc7786539747c204dee4956206002579db4e8973d8", + "size": 95399, + "subdir": "linux-64", + "timestamp": 1632881032917, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "559af2a3dbe4ec3fd17480ba2f8f8cd6", + "name": "jsonschema", + "sha256": "046ea2ad33021d426f070613f3e305854bbbfd6a8e3064f04bde6ead1c281aec", + "size": 96127, + "subdir": "linux-64", + "timestamp": 1574266988780, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "31630d847acafa41afd51cdf37b227ad", + "name": "jsonschema", + "sha256": "22999ed7752743eff8e4a3e1985b7d90a90f5f549932eab370845375391f4bf2", + "size": 92540, + "subdir": "linux-64", + "timestamp": 1601490606424, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "a704fd8f1eb73ea6ec90dc1647ed75c4", + "name": "jsonschema", + "sha256": "2e3771fd83293836326bb210099b296c113076f9d9bb3936661e6e6cb74dc2dd", + "size": 96124, + "subdir": "linux-64", + "timestamp": 1632890996816, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "7c5e6af092175b25d3377546e055d941", + "name": "jsonschema", + "sha256": "bb8665a7808d129f0809e3a974da02a54b52b64e51e4836d2a775c7ad6e42e0d", + "size": 96497, + "subdir": "linux-64", + "timestamp": 1632891473678, + "version": "3.2.0" + }, + "jsonschema-4.16.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent !=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "94a82748b05b45859f91e82ff7ebaada", + "name": "jsonschema", + "sha256": "f9f5c0b0689c43423e354f82ead3d4f05498d836148c2bc203d3e5afff88f5c7", + "size": 129788, + "subdir": "linux-64", + "timestamp": 1663375614686, + "version": "4.16.0" + }, + "jsonschema-4.16.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "importlib_resources >=1.4.0", + "pkgutil-resolve-name >=1.3.10", + "pyrsistent !=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c8d2fb5d0273b200f11714fb86196790", + "name": "jsonschema", + "sha256": "363b42775b122157094eae60f8d0d289398b5e0237618fbaf6c97197a3c0976d", + "size": 126743, + "subdir": "linux-64", + "timestamp": 1663375543814, + "version": "4.16.0" + }, + "jsonschema-4.16.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_resources >=1.4.0", + "pkgutil-resolve-name >=1.3.10", + "pyrsistent !=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9bdba7a355e3589ab0e8241e272f7ace", + "name": "jsonschema", + "sha256": "323500414e1965a85e4467b59a8f40e55e64cac48ddda965ddde965fceca03d6", + "size": 127613, + "subdir": "linux-64", + "timestamp": 1663375513879, + "version": "4.16.0" + }, + "jsonschema-4.16.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent !=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47e52d536830f5a943ed5c74997e32ca", + "name": "jsonschema", + "sha256": "c0fc70357e72d6f475cd5e57e180af5933841770c5fdba50c008245ef1ecb0ca", + "size": 128076, + "subdir": "linux-64", + "timestamp": 1663375573769, + "version": "4.16.0" + }, + "jsonschema-4.17.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent !=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "871812adc9bb6e34d64620d7b539862b", + "name": "jsonschema", + "sha256": "76a783faccefbbbfe6b408d2cb3ad4c364a058df6610080d858ef4f0a38f76af", + "size": 133051, + "subdir": "linux-64", + "timestamp": 1676558776772, + "version": "4.17.3" + }, + "jsonschema-4.17.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent !=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6919ca6f96b87f03ccbb0a1ce00baf28", + "name": "jsonschema", + "sha256": "3677ea878670d7d9ba821562e04a97d22dfe7717d2488695b7bef30efeb5fd12", + "size": 175318, + "subdir": "linux-64", + "timestamp": 1678983467176, + "version": "4.17.3" + }, + "jsonschema-4.17.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "importlib_resources >=1.4.0", + "pkgutil-resolve-name >=1.3.10", + "pyrsistent !=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ecfc9b6d23cd11a3ae9c9365d360bcd", + "name": "jsonschema", + "sha256": "fb82e97c58b86a36f7a9ce05d194267973d15bddf2b79a16eca06a529fc33190", + "size": 129297, + "subdir": "linux-64", + "timestamp": 1676558747293, + "version": "4.17.3" + }, + "jsonschema-4.17.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_resources >=1.4.0", + "pkgutil-resolve-name >=1.3.10", + "pyrsistent !=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85499c4d81f591081111c92b80658c46", + "name": "jsonschema", + "sha256": "405e9f469376ef4103dd20143182200becd1826e09c4ceaf1c3624ba1f550c46", + "size": 130909, + "subdir": "linux-64", + "timestamp": 1676558687406, + "version": "4.17.3" + }, + "jsonschema-4.17.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent !=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d2c3c5edf671b575532d5a3e8bf15fc", + "name": "jsonschema", + "sha256": "fd552c9fe7779219844ea9d67e1abc27cd6549307087960d422ece8dbe5a4951", + "size": 131510, + "subdir": "linux-64", + "timestamp": 1676558716852, + "version": "4.17.3" + }, + "jsonschema-4.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent >=0.14.0,!=0.17.0,!=0.17.1,!=0.17.2", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "261153dd77941e9f08096e67caa98c76", + "name": "jsonschema", + "sha256": "c625b5c2216208feb14dba8eb9baa1c8c735bd2a815f3d5f9e0f3eaeeb8c15fd", + "size": 124010, + "subdir": "linux-64", + "timestamp": 1650007885399, + "version": "4.4.0" + }, + "jsonschema-4.4.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent >=0.14.0,!=0.17.0,!=0.17.1,!=0.17.2", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b532d8fe206e23abf2acc4916e85d2df", + "name": "jsonschema", + "sha256": "be98c10d757b342d5d191ae0997863024a810f710b5ec58d2c934716eb0aee86", + "size": 159723, + "subdir": "linux-64", + "timestamp": 1676823160726, + "version": "4.4.0" + }, + "jsonschema-4.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "importlib_resources >=1.4.0", + "pyrsistent >=0.14.0,!=0.17.0,!=0.17.1,!=0.17.2", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd261a962e1965a68c2e2d9e49c6f292", + "name": "jsonschema", + "sha256": "dd8fcfc855af43d21dcab1988f14205ab84f48f20eeea244029d6d47bab9c32c", + "size": 121293, + "subdir": "linux-64", + "timestamp": 1650008131057, + "version": "4.4.0" + }, + "jsonschema-4.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_resources >=1.4.0", + "pyrsistent >=0.14.0,!=0.17.0,!=0.17.1,!=0.17.2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08971119285edbc20ad6eab2b37fc580", + "name": "jsonschema", + "sha256": "a89b58ee54aa236223feaca164da0fa2893e2c7e1e8dd77bfb654504d17cef75", + "size": 122348, + "subdir": "linux-64", + "timestamp": 1650025986553, + "version": "4.4.0" + }, + "jsonschema-4.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent >=0.14.0,!=0.17.0,!=0.17.1,!=0.17.2", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "40577541303ba023ef688b974ddd6150", + "name": "jsonschema", + "sha256": "6597557b1a9cd761304f90919bc42ccc3c54809a32da581321e1df0da804730c", + "size": 122587, + "subdir": "linux-64", + "timestamp": 1650025990702, + "version": "4.4.0" + }, + "jupyter-1.0.0-py27_4.tar.bz2": { + "build": "py27_4", + "build_number": 4, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=2.7,<2.8.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "9c69d3813db299f52f12ba3f3cc5aeef", + "name": "jupyter", + "sha256": "44b1f289ef9435c900c73c8b8e16cba09d3c5c0901c632331c6ce202b436c086", + "size": 5509, + "subdir": "linux-64", + "timestamp": 1518035203304, + "version": "1.0.0" + }, + "jupyter-1.0.0-py27_6.tar.bz2": { + "build": "py27_6", + "build_number": 6, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=2.7,<2.8.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "2cdab0186acf847e898dd2741baee07f", + "name": "jupyter", + "sha256": "63ebbdae5fe49bfa6af208edf20a7b2680aa0a4c2d320d73777a86c1c5fee0bb", + "size": 6153, + "subdir": "linux-64", + "timestamp": 1537216810475, + "version": "1.0.0" + }, + "jupyter-1.0.0-py27_7.tar.bz2": { + "build": "py27_7", + "build_number": 7, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=2.7,<2.8.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "808d3826c599c508f742eed93727ff3e", + "name": "jupyter", + "sha256": "cfc86c5b3072e4842f41ee25b154ade9fb702ca5be553741a9df5f82c377147d", + "size": 5813, + "subdir": "linux-64", + "timestamp": 1537454692904, + "version": "1.0.0" + }, + "jupyter-1.0.0-py27h505fd4b_0.tar.bz2": { + "build": "py27h505fd4b_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=2.7,<2.8.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "4f7a0bdcc9480c85a8d96117e42776d3", + "name": "jupyter", + "sha256": "0771daa16a04ba85162bf35b5838f817037ef30cb1372bfee2be6ddb15910a0c", + "size": 4019, + "subdir": "linux-64", + "timestamp": 1505744965582, + "version": "1.0.0" + }, + "jupyter-1.0.0-py310h06a4308_7.tar.bz2": { + "build": "py310h06a4308_7", + "build_number": 7, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.10,<3.11.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "93c8e8c7baf296bcd03f9b95b1eb63e6", + "name": "jupyter", + "sha256": "12c8391a99a4215fbabf8fce5b5610765eade73ea08c39dfeb42f8ecd8e76c42", + "size": 6659, + "subdir": "linux-64", + "timestamp": 1641917241052, + "version": "1.0.0" + }, + "jupyter-1.0.0-py310h06a4308_8.tar.bz2": { + "build": "py310h06a4308_8", + "build_number": 8, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "jupyterlab", + "nbconvert", + "notebook", + "python >=3.10,<3.11.0a0", + "qtconsole" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c4bbeffad4d66d5246321b1b81a7c003", + "name": "jupyter", + "sha256": "d3f91ba2dd789b814cafdf1dded64cf8a22ba6566b8dbb2eb58073369fa8a4b0", + "size": 7522, + "subdir": "linux-64", + "timestamp": 1659349161198, + "version": "1.0.0" + }, + "jupyter-1.0.0-py311h06a4308_8.tar.bz2": { + "build": "py311h06a4308_8", + "build_number": 8, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "jupyterlab", + "nbconvert", + "notebook", + "python >=3.11,<3.12.0a0", + "qtconsole" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "419059ea1bf52c9d350ef18ff865f016", + "name": "jupyter", + "sha256": "323807c17b0c123124aeca26b42b051a798bb85c1e6530a6272b3e9e1635381a", + "size": 7188, + "subdir": "linux-64", + "timestamp": 1676837051219, + "version": "1.0.0" + }, + "jupyter-1.0.0-py35_4.tar.bz2": { + "build": "py35_4", + "build_number": 4, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.5,<3.6.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "fac708bddb0018d04e7b0bb1b3d1f8b2", + "name": "jupyter", + "sha256": "41b8a1565837870a3935462c6797c9c9e3d8f569d5af0dcf369a2bb7d536f3cd", + "size": 5551, + "subdir": "linux-64", + "timestamp": 1518035258706, + "version": "1.0.0" + }, + "jupyter-1.0.0-py35_6.tar.bz2": { + "build": "py35_6", + "build_number": 6, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.5,<3.6.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "f8564833f44f42e0393da66c503509d5", + "name": "jupyter", + "sha256": "eec78d9e10f543644370f4a881739c9bf07ef16a032a95ac416d7903bfc9ec6e", + "size": 5823, + "subdir": "linux-64", + "timestamp": 1537216847715, + "version": "1.0.0" + }, + "jupyter-1.0.0-py35_7.tar.bz2": { + "build": "py35_7", + "build_number": 7, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.5,<3.6.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "ab4520b4d243f43d6d49437469191e19", + "name": "jupyter", + "sha256": "9bea018d930cc295f2401931844ee89ae5d8e8120061be90d9eeba099e36e6d3", + "size": 5821, + "subdir": "linux-64", + "timestamp": 1537454718884, + "version": "1.0.0" + }, + "jupyter-1.0.0-py35hd38625c_0.tar.bz2": { + "build": "py35hd38625c_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.5,<3.6.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "4d5cd69743257021918e4d16eaf72cf7", + "name": "jupyter", + "sha256": "4e939f1db1797a54021f96049d9dbf9c172b466ff441f39579e534f36515872d", + "size": 4013, + "subdir": "linux-64", + "timestamp": 1505744981873, + "version": "1.0.0" + }, + "jupyter-1.0.0-py36_4.tar.bz2": { + "build": "py36_4", + "build_number": 4, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.6,<3.7.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "8d4c7dd96808b7337f589903e8876022", + "name": "jupyter", + "sha256": "809dc92b4c47e5bd51de7e104245cc6dcd885f09b34dc0a12200ce4695531892", + "size": 5533, + "subdir": "linux-64", + "timestamp": 1518035258479, + "version": "1.0.0" + }, + "jupyter-1.0.0-py36_6.tar.bz2": { + "build": "py36_6", + "build_number": 6, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.6,<3.7.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "158a27b2b37b53afdf62d4de0994b454", + "name": "jupyter", + "sha256": "27258e8eef5d04adfe2e7f46e30a7d2c0560ec2f03fc56732ddd9906c007f15a", + "size": 5827, + "subdir": "linux-64", + "timestamp": 1537216864188, + "version": "1.0.0" + }, + "jupyter-1.0.0-py36_7.tar.bz2": { + "build": "py36_7", + "build_number": 7, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.6,<3.7.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "fde3d052079b152394ed0f3cf8f90f43", + "name": "jupyter", + "sha256": "2b9ac0f12a80fd861060d506f98983a0f12c490e6a390af766965a4af20aa51a", + "size": 5838, + "subdir": "linux-64", + "timestamp": 1537454708191, + "version": "1.0.0" + }, + "jupyter-1.0.0-py36h9896ce5_0.tar.bz2": { + "build": "py36h9896ce5_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.6,<3.7.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "5765196f6ad4861e63110a4fb9abb7ee", + "name": "jupyter", + "sha256": "71c1b70434ee7824a88a493fc58295e0c1f270c4ef1e9b3dd3c894e92724a09d", + "size": 4040, + "subdir": "linux-64", + "timestamp": 1505744998703, + "version": "1.0.0" + }, + "jupyter-1.0.0-py37_4.tar.bz2": { + "build": "py37_4", + "build_number": 4, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.7,<3.8.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "419dafb8b7c8ed08e38a91e442d341f5", + "name": "jupyter", + "sha256": "b629bc64fa4d8ad1cf3d962589c0554217a414c87c9111197171df38ac6f1e39", + "size": 6000, + "subdir": "linux-64", + "timestamp": 1530892936616, + "version": "1.0.0" + }, + "jupyter-1.0.0-py37_5.tar.bz2": { + "build": "py37_5", + "build_number": 5, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.7,<3.8.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "2c698e802d99c433f93cd49fcce7d8be", + "name": "jupyter", + "sha256": "63d0695f0542521366222432763152ec228ebfa1ccef6316e4e9f367963d8f1d", + "size": 5711, + "subdir": "linux-64", + "timestamp": 1531500225458, + "version": "1.0.0" + }, + "jupyter-1.0.0-py37_6.tar.bz2": { + "build": "py37_6", + "build_number": 6, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.7,<3.8.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "fcb93789693131a2aa5c08c1569c0adc", + "name": "jupyter", + "sha256": "4d894b30ee40d92d58610106c8ca6cde3a540066a65e8b1693656fb240d28f75", + "size": 5818, + "subdir": "linux-64", + "timestamp": 1537216787888, + "version": "1.0.0" + }, + "jupyter-1.0.0-py37_7.tar.bz2": { + "build": "py37_7", + "build_number": 7, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.7,<3.8.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "d21485c7baedb413f3b207c6620ca0d1", + "name": "jupyter", + "sha256": "9437b2d4c96aea61b3a570d2c14808e97f9dc221fd1bb5fb719672acfe65eb48", + "size": 5833, + "subdir": "linux-64", + "timestamp": 1537454658837, + "version": "1.0.0" + }, + "jupyter-1.0.0-py37h06a4308_8.tar.bz2": { + "build": "py37h06a4308_8", + "build_number": 8, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "jupyterlab", + "nbconvert", + "notebook", + "python >=3.7,<3.8.0a0", + "qtconsole" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "60a8ea21414098d042b851d7e519af5d", + "name": "jupyter", + "sha256": "ab956c2c067a4fcaf4c46478001be8fbed9000c7f7daa5a6218f52268064145e", + "size": 7494, + "subdir": "linux-64", + "timestamp": 1659349213260, + "version": "1.0.0" + }, + "jupyter-1.0.0-py38_7.tar.bz2": { + "build": "py38_7", + "build_number": 7, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.8,<3.9.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "2533b230365be386432c98967055490f", + "name": "jupyter", + "sha256": "aa2eabdccb2486ab133c84b3a7b554b9f128be6dec17a08398875e4e45b125fd", + "size": 7566, + "subdir": "linux-64", + "timestamp": 1580250115272, + "version": "1.0.0" + }, + "jupyter-1.0.0-py38h06a4308_8.tar.bz2": { + "build": "py38h06a4308_8", + "build_number": 8, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "jupyterlab", + "nbconvert", + "notebook", + "python >=3.8,<3.9.0a0", + "qtconsole" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6c69e7b654b16017773ccd2dbc06d0e8", + "name": "jupyter", + "sha256": "1a92f32e0436b20651fed76ffcfc3ff4459ae09b1e01e09f5715bdd24b548e43", + "size": 7507, + "subdir": "linux-64", + "timestamp": 1659349266270, + "version": "1.0.0" + }, + "jupyter-1.0.0-py39h06a4308_7.tar.bz2": { + "build": "py39h06a4308_7", + "build_number": 7, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.9,<3.10.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "bda7bd1285b7628ca4eec66796d0901c", + "name": "jupyter", + "sha256": "9db53f25ca32d4b3cf8f106c8b51c4a4a25d5caba0481aff576cf83a0bb91b17", + "size": 7889, + "subdir": "linux-64", + "timestamp": 1607700875873, + "version": "1.0.0" + }, + "jupyter-1.0.0-py39h06a4308_8.tar.bz2": { + "build": "py39h06a4308_8", + "build_number": 8, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "jupyterlab", + "nbconvert", + "notebook", + "python >=3.9,<3.10.0a0", + "qtconsole" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b6d8d430c1f20d2bd6691a0b2bbdbacc", + "name": "jupyter", + "sha256": "4aef748afd14bf1b5e0a550e194def5cb736966c00e51f171c5a504b9a991472", + "size": 7516, + "subdir": "linux-64", + "timestamp": 1659349087693, + "version": "1.0.0" + }, + "jupyter-dash-0.4.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ansi2html", + "dash", + "flask", + "ipykernel", + "ipython", + "nest-asyncio", + "python >=3.10,<3.11.0a0", + "requests", + "retrying" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9ec3377bbd4a512fed123b65bed788c", + "name": "jupyter-dash", + "sha256": "f3fd6590db0add96effc8a7f7871b4e218735d29a3472dcb6e2ffed845bf2c9d", + "size": 27830, + "subdir": "linux-64", + "timestamp": 1679330902270, + "version": "0.4.2" + }, + "jupyter-dash-0.4.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ansi2html", + "dash", + "flask", + "ipykernel", + "ipython", + "nest-asyncio", + "python >=3.11,<3.12.0a0", + "requests", + "retrying" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2cd3d8d0ae0a209907d4112c447bb0d0", + "name": "jupyter-dash", + "sha256": "3b3f464fc20d5063ce046f360c289ffd8bff4f1c415e2319e50f68d11d827cb6", + "size": 31982, + "subdir": "linux-64", + "timestamp": 1679331050936, + "version": "0.4.2" + }, + "jupyter-dash-0.4.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ansi2html", + "dash", + "flask", + "ipykernel", + "ipython", + "nest-asyncio", + "python >=3.8,<3.9.0a0", + "requests", + "retrying" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d95291c0890e2ea16a7b14bf401abd1", + "name": "jupyter-dash", + "sha256": "46d4b0e5c95e91b46e319c2c13f7aefa1b805daacbf8b8f10a03ac3ed69e9d62", + "size": 27751, + "subdir": "linux-64", + "timestamp": 1679330956089, + "version": "0.4.2" + }, + "jupyter-dash-0.4.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ansi2html", + "dash", + "flask", + "ipykernel", + "ipython", + "nest-asyncio", + "python >=3.9,<3.10.0a0", + "requests", + "retrying" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16ae8a96c44e3cbf11b2aff3331fb682", + "name": "jupyter-dash", + "sha256": "39e414809545f24fda4ff28b1b46dab7e5fa28b1f2ae691cca371e735251a5c1", + "size": 27785, + "subdir": "linux-64", + "timestamp": 1679330999864, + "version": "0.4.2" + }, + "jupyter-packaging-0.12.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "deprecation", + "packaging", + "python >=3.10,<3.11.0a0", + "setuptools >=60.2.0", + "tomlkit", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d063cb121bcc595befae942627df4c2a", + "name": "jupyter-packaging", + "sha256": "92e773dc0a3e567548c2e7e80984f7232d1316e5dcd525c4c878ad52d6912784", + "size": 45443, + "subdir": "linux-64", + "timestamp": 1654695016159, + "version": "0.12.0" + }, + "jupyter-packaging-0.12.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "deprecation", + "packaging", + "python >=3.10,<3.11.0a0", + "setuptools >=60.2.0", + "tomlkit", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "79f87b0833d7c460b660692be58813c7", + "name": "jupyter-packaging", + "sha256": "7e59a46362f87022d9c191429f758ee7964dffbc8f32f99adf7ee107d8903659", + "size": 45764, + "subdir": "linux-64", + "timestamp": 1678960981148, + "version": "0.12.0" + }, + "jupyter-packaging-0.12.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "deprecation", + "packaging", + "python >=3.11,<3.12.0a0", + "setuptools >=60.2.0", + "tomlkit", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "277b9bab92ea5f72080469b8acb536ca", + "name": "jupyter-packaging", + "sha256": "951d57f3c360adeec952a7fd02e998862626e040b94dc072b570aa589c4c6af9", + "size": 59772, + "subdir": "linux-64", + "timestamp": 1676823839221, + "version": "0.12.0" + }, + "jupyter-packaging-0.12.0-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "deprecation", + "packaging", + "python >=3.11,<3.12.0a0", + "setuptools >=60.2.0", + "tomlkit", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "992a75e1be78aac33b6cd69bdd2cb4cb", + "name": "jupyter-packaging", + "sha256": "706472d73a321a4e463fd32239a7958fba289ddb43e67bb3a14da3a949da29d0", + "size": 59589, + "subdir": "linux-64", + "timestamp": 1678961058849, + "version": "0.12.0" + }, + "jupyter-packaging-0.12.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "deprecation", + "packaging", + "python >=3.7,<3.8.0a0", + "setuptools >=60.2.0", + "tomlkit", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff480c7408557f8f7b148a970c5e00d3", + "name": "jupyter-packaging", + "sha256": "f453bd5338f19ae2a346a3ce07aeb3607301430f1fcaf564cc06ae94a90d4d84", + "size": 45125, + "subdir": "linux-64", + "timestamp": 1654694978616, + "version": "0.12.0" + }, + "jupyter-packaging-0.12.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "deprecation", + "packaging", + "python >=3.8,<3.9.0a0", + "setuptools >=60.2.0", + "tomlkit", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1c6c107129e8ac8bd0441e995799473c", + "name": "jupyter-packaging", + "sha256": "1dffb63010c89eaae405af3577192fe597c3fdfacefafc87702df46e08e26786", + "size": 45250, + "subdir": "linux-64", + "timestamp": 1654695069876, + "version": "0.12.0" + }, + "jupyter-packaging-0.12.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "deprecation", + "packaging", + "python >=3.8,<3.9.0a0", + "setuptools >=60.2.0", + "tomlkit", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4ad6a3cb4acf9ae453cc21325d3cd470", + "name": "jupyter-packaging", + "sha256": "80fee7c265d1684474d6fa62acce0aa5d29e13d96d85a953218ffacf25ddb675", + "size": 45472, + "subdir": "linux-64", + "timestamp": 1678961006899, + "version": "0.12.0" + }, + "jupyter-packaging-0.12.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "deprecation", + "packaging", + "python >=3.9,<3.10.0a0", + "setuptools >=60.2.0", + "tomlkit", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4527db1587cff822b964c00ca8db050b", + "name": "jupyter-packaging", + "sha256": "c5cca6661d7893b7f14eb11c0230eafd5c041a6b45f647509901615c58b976f7", + "size": 45164, + "subdir": "linux-64", + "timestamp": 1654695043414, + "version": "0.12.0" + }, + "jupyter-packaging-0.12.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "deprecation", + "packaging", + "python >=3.9,<3.10.0a0", + "setuptools >=60.2.0", + "tomlkit", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "89de19231b230aa171b691dcfb4b2b28", + "name": "jupyter-packaging", + "sha256": "1be28069aa67d40428e2d573f0724f9bee1e4fa4e96998bfc6e29b1ff011daf7", + "size": 45436, + "subdir": "linux-64", + "timestamp": 1678961031723, + "version": "0.12.0" + }, + "jupyter-server-proxy-3.2.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "jupyter_server >=1", + "python >=3.10,<3.11.0a0", + "simpervisor >=0.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5a18ace0ee480dd96f016d7360ffc786", + "name": "jupyter-server-proxy", + "sha256": "5ce329fbbc1c14db5e2021ca92ebbbd5958588f4b2999a87dcee22c65a9a965b", + "size": 43833, + "subdir": "linux-64", + "timestamp": 1679384838638, + "version": "3.2.2" + }, + "jupyter-server-proxy-3.2.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "jupyter_server >=1", + "python >=3.11,<3.12.0a0", + "simpervisor >=0.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "129802b09a07321de450547a032e9cd9", + "name": "jupyter-server-proxy", + "sha256": "f630fc1c52a80c98b9fe407af071b47755f3ab496f0a5663933867b110bf1915", + "size": 51905, + "subdir": "linux-64", + "timestamp": 1679384644435, + "version": "3.2.2" + }, + "jupyter-server-proxy-3.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "jupyter_server >=1", + "python >=3.8,<3.9.0a0", + "simpervisor >=0.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "44d62623c5af17c28969d17c9ace37a3", + "name": "jupyter-server-proxy", + "sha256": "c2adf0aada7dfa08caa52e8953197ecfdb8dcd995c100c04a76a5798a9b981de", + "size": 43604, + "subdir": "linux-64", + "timestamp": 1679384773558, + "version": "3.2.2" + }, + "jupyter-server-proxy-3.2.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "jupyter_server >=1", + "python >=3.9,<3.10.0a0", + "simpervisor >=0.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f25e9f29a90848a19b9df9d8cff7c5d", + "name": "jupyter-server-proxy", + "sha256": "37e548cc0cbc77c50facb3840d0b6e6c30a6f47b13f936a1a72f47802e7749cc", + "size": 43632, + "subdir": "linux-64", + "timestamp": 1679384707331, + "version": "3.2.2" + }, + "jupyter_bokeh-3.0.7-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "bokeh >=3,<4", + "ipywidgets >=8,<9", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "69ecbbf06ca145a8e784a9ca0d9ca857", + "name": "jupyter_bokeh", + "sha256": "928de749a277b3e93807a2c9b54850aa881dde4a25021dc52b71476a7a28b12b", + "size": 1075650, + "subdir": "linux-64", + "timestamp": 1679489253752, + "version": "3.0.7" + }, + "jupyter_bokeh-3.0.7-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "bokeh >=3,<4", + "ipywidgets >=8,<9", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ad8da5f86e995e488270ba21cc91cf71", + "name": "jupyter_bokeh", + "sha256": "00b505b14e246910bf9eb76ba7c6e6c91686f11de7bcda4ba5b5675a9984f2cd", + "size": 1076362, + "subdir": "linux-64", + "timestamp": 1679489335323, + "version": "3.0.7" + }, + "jupyter_bokeh-3.0.7-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "bokeh >=3,<4", + "ipywidgets >=8,<9", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "33ba0e7eec886f37a911c6fbfba62a20", + "name": "jupyter_bokeh", + "sha256": "8fb356535929e4b6b26a41f432b062b547c324904c078472756048cea6c6ce27", + "size": 1074517, + "subdir": "linux-64", + "timestamp": 1679489495070, + "version": "3.0.7" + }, + "jupyter_bokeh-3.0.7-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "bokeh >=3,<4", + "ipywidgets >=8,<9", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "453b9ecdf399aa60353626a68399027e", + "name": "jupyter_bokeh", + "sha256": "9b2dfd88f778d746dcd847fb37b0be3976f622a4c96c6f557912c450a3fa736f", + "size": 1076140, + "subdir": "linux-64", + "timestamp": 1679489411883, + "version": "3.0.7" + }, + "jupyter_client-5.1.0-py27hbee1118_0.tar.bz2": { + "build": "py27hbee1118_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "ec7e25bd0ed882e749534f35a3ff7b3c", + "name": "jupyter_client", + "sha256": "b66a37f580c3aad0e270e788259f577b514f7dc8ff5eaf4398d4925637bcb689", + "size": 117997, + "subdir": "linux-64", + "timestamp": 1505688479689, + "version": "5.1.0" + }, + "jupyter_client-5.1.0-py35h2bff583_0.tar.bz2": { + "build": "py35h2bff583_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "38358bc32514f750678e3c0e1046b3bb", + "name": "jupyter_client", + "sha256": "ac47bfdd999349157c4fc7f4915da9b97be45ebb4095818b1204d4a3d6fcf406", + "size": 120848, + "subdir": "linux-64", + "timestamp": 1505688494728, + "version": "5.1.0" + }, + "jupyter_client-5.1.0-py36h614e9ea_0.tar.bz2": { + "build": "py36h614e9ea_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "47c637fc364eb1ccee7c2376778b4db0", + "name": "jupyter_client", + "sha256": "e3b3f146177f86214ce38fa58e0e182290adbdbe92b1fc9e0649a75e791a397f", + "size": 120075, + "subdir": "linux-64", + "timestamp": 1505688510089, + "version": "5.1.0" + }, + "jupyter_client-5.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "b2748c4cdccb147a195ba978f9013224", + "name": "jupyter_client", + "sha256": "a7749ac1f7b0bb779a7e69dc6f5e12877b001f6ffd7c67aa4fe79d8d4db1266e", + "size": 124133, + "subdir": "linux-64", + "timestamp": 1515706426034, + "version": "5.2.1" + }, + "jupyter_client-5.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "c7580731f226ba2a672d703928e84d83", + "name": "jupyter_client", + "sha256": "d1c9bb1b7d507fb6e82c1004c7d87f3ba911aac94845c57b35bc6068c8a02faf", + "size": 127144, + "subdir": "linux-64", + "timestamp": 1515706417747, + "version": "5.2.1" + }, + "jupyter_client-5.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "64826a4a3f664cba2767b5f32af821f2", + "name": "jupyter_client", + "sha256": "a85ba6f8f4dcb68a706c74b79146cad42d4070ceae6a73dfffa27370aac89602", + "size": 126302, + "subdir": "linux-64", + "timestamp": 1515706346643, + "version": "5.2.1" + }, + "jupyter_client-5.2.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "d3b81023f9c054f6a730ca58149c2541", + "name": "jupyter_client", + "sha256": "fab3121e44f95e4b7260482166a0b14044dfa5e417d1e4944af076e22687225f", + "size": 123993, + "subdir": "linux-64", + "timestamp": 1516910116981, + "version": "5.2.2" + }, + "jupyter_client-5.2.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "0b0d1bf762b0eccd5883fe1f191617ac", + "name": "jupyter_client", + "sha256": "5957a53f9a41be32e49c54d621b72b2152588485808b1f69959c09b16924c83a", + "size": 126994, + "subdir": "linux-64", + "timestamp": 1516910136639, + "version": "5.2.2" + }, + "jupyter_client-5.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "5c49937d5632c3309abcf76879477fab", + "name": "jupyter_client", + "sha256": "f304391a1be13946b4a80a71395861c31038cf468138919a331b10ad962b781f", + "size": 126816, + "subdir": "linux-64", + "timestamp": 1516910135717, + "version": "5.2.2" + }, + "jupyter_client-5.2.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "b1f6ba26143b69f6981ce64dce21cfd5", + "name": "jupyter_client", + "sha256": "63da16f329cb4e6e9cf0d2e18c536b979a0357656990b0029dfab7451e0046c7", + "size": 124583, + "subdir": "linux-64", + "timestamp": 1521484125000, + "version": "5.2.3" + }, + "jupyter_client-5.2.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "3547a467147ab5874030fd56e4115e80", + "name": "jupyter_client", + "sha256": "45199d876ea18171216c4342398012d70042b7d97e0296174e4a94712d1d66b9", + "size": 127549, + "subdir": "linux-64", + "timestamp": 1521484132858, + "version": "5.2.3" + }, + "jupyter_client-5.2.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "157d28d79d52b7f69bf5af27a1ed2d9e", + "name": "jupyter_client", + "sha256": "4d18cec87bfbafc1bc868b8270a28316aea9f621c11a6d2e731b1ae62afd594b", + "size": 127291, + "subdir": "linux-64", + "timestamp": 1521484134735, + "version": "5.2.3" + }, + "jupyter_client-5.2.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "5d0fe2f9b805a2c1de8501f2ed47a4c9", + "name": "jupyter_client", + "sha256": "957ac901ef0b9e6bb256e673bf976fee1324f920ee111be769147dfa0a13bf3d", + "size": 129265, + "subdir": "linux-64", + "timestamp": 1530694716397, + "version": "5.2.3" + }, + "jupyter_client-5.2.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "c63ede14eca0a1e5ed1211a9b0be8df2", + "name": "jupyter_client", + "sha256": "dc1391abd9f1b20c428b24869b31375517d13c283afd65651ba665310f816193", + "size": 128430, + "subdir": "linux-64", + "timestamp": 1545071982225, + "version": "5.2.4" + }, + "jupyter_client-5.2.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "681b89114532483434713acde71a4357", + "name": "jupyter_client", + "sha256": "cf7295520891098a246dcce0d26dcb1edad368d03b479a3986da25181837ba99", + "size": 130604, + "subdir": "linux-64", + "timestamp": 1545072025530, + "version": "5.2.4" + }, + "jupyter_client-5.2.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "8d823df8873d0bda855ba7ee49cbc5a9", + "name": "jupyter_client", + "sha256": "19b2b42e04715cb142d48d9092390d6a577242fb5071f74f0d6501e58ebd328d", + "size": 130319, + "subdir": "linux-64", + "timestamp": 1545072007262, + "version": "5.2.4" + }, + "jupyter_client-5.3.3-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "jupyter_core", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4.1", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "0a0a8603974ed38f52def5d1bfc17277", + "name": "jupyter_client", + "sha256": "df2d15446b1410ca910f4c3fccd64be555fd218b3ab47307793efa7571db0a3d", + "size": 138180, + "subdir": "linux-64", + "timestamp": 1569448159366, + "version": "5.3.3" + }, + "jupyter_client-5.3.3-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "jupyter_core", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4.1", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "680b7f672c027f6eb300ea56a5de6532", + "name": "jupyter_client", + "sha256": "29a1b78f709f0218959310aa0f9ad6219bec014cd73ca96049490af9fc0ec3af", + "size": 140107, + "subdir": "linux-64", + "timestamp": 1569448157660, + "version": "5.3.3" + }, + "jupyter_client-5.3.3-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "jupyter_core", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4.1", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "2b47763bbb6db038c56736eceae2cb37", + "name": "jupyter_client", + "sha256": "22d71e42d8f0fcfba9d4ce546f7d991b696bd7e50bb607ae4a8e25c05d6b608d", + "size": 140123, + "subdir": "linux-64", + "timestamp": 1569448156654, + "version": "5.3.3" + }, + "jupyter_client-5.3.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jupyter_core >=4.6.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4.1", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "68ce634e34fbc40b2aef1618c5eaf050", + "name": "jupyter_client", + "sha256": "f572c1aeb74e21251945388b4576e25e97725e3ce4df1b9d8c6d133de77e4733", + "size": 136931, + "subdir": "linux-64", + "timestamp": 1571154013472, + "version": "5.3.4" + }, + "jupyter_client-5.3.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyter_core >=4.6.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4.1", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "42a730a9ba95693cc7d498fcefdb1fcf", + "name": "jupyter_client", + "sha256": "0beedea70a1fbb6f91c950074a69021ded8baf7adf181b3501242fb86d268fad", + "size": 138882, + "subdir": "linux-64", + "timestamp": 1571153981176, + "version": "5.3.4" + }, + "jupyter_client-5.3.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyter_core >=4.6.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4.1", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "ebd7b3511784261a4dcec9b47c0793b7", + "name": "jupyter_client", + "sha256": "d75ce7c704946434637170d827103042a79f89c22288921546d76e3fb2ed7463", + "size": 138895, + "subdir": "linux-64", + "timestamp": 1571154026784, + "version": "5.3.4" + }, + "jupyter_client-5.3.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jupyter_core >=4.6.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4.1", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "3f4a5339bc91a27dcdddbeb3954b8640", + "name": "jupyter_client", + "sha256": "12665c46ef8f73b7a14f1acb24e37232ef13f3feba188d919fc4de66033403cc", + "size": 134657, + "subdir": "linux-64", + "timestamp": 1574448337627, + "version": "5.3.4" + }, + "jupyter_client-7.2.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=22.3", + "tornado >=6.0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9d97708df2ccb59b58082da5bc84c07f", + "name": "jupyter_client", + "sha256": "1b898bebca729e6ef210e274706fb8a037baa10f61f3e0d51f970dcd44684e8d", + "size": 193313, + "subdir": "linux-64", + "timestamp": 1650623162029, + "version": "7.2.2" + }, + "jupyter_client-7.2.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=22.3", + "tornado >=6.0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a54dad23723d875284016bda532360f9", + "name": "jupyter_client", + "sha256": "38c1995d707a05ce54560d2129eec1687540b1345b5c78142da84b09cfc39770", + "size": 190394, + "subdir": "linux-64", + "timestamp": 1650622242192, + "version": "7.2.2" + }, + "jupyter_client-7.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=22.3", + "tornado >=6.0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bdbcdf04055343c414aa431ccb1b788e", + "name": "jupyter_client", + "sha256": "363bf1ec4fc436281b982243c320d1e5f3f4f8eb32b165b3d9065ba8cec976e5", + "size": 190946, + "subdir": "linux-64", + "timestamp": 1650622858276, + "version": "7.2.2" + }, + "jupyter_client-7.2.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=22.3", + "tornado >=6.0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c5fd100e3062e831cbdf33331042f627", + "name": "jupyter_client", + "sha256": "92bc012f9eb4ad71158cf4826fd3e125fcebff53b529276a81224acda48be547", + "size": 190884, + "subdir": "linux-64", + "timestamp": 1650622553813, + "version": "7.2.2" + }, + "jupyter_client-7.3.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "584085041afe534aa6dc6fb9f1354892", + "name": "jupyter_client", + "sha256": "9d0ca61e76b25261ab197c51f6a68c209d926d070112b3617e27f2bd0d3b08e3", + "size": 194315, + "subdir": "linux-64", + "timestamp": 1661849794892, + "version": "7.3.4" + }, + "jupyter_client-7.3.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3ec9b4fd159b1f9b2b9a78fe4ce7f542", + "name": "jupyter_client", + "sha256": "17f88a9c6466d0a4e04c534d2e7e2bd9fc39fb1a2cd239880463c0e257ca41a3", + "size": 191410, + "subdir": "linux-64", + "timestamp": 1661848952899, + "version": "7.3.4" + }, + "jupyter_client-7.3.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d3d77befbab564cb6bff3c6a4f7f5df0", + "name": "jupyter_client", + "sha256": "c85239b57cca1e9511f32ac4d4dc3e6ab27f5530b0dff6287e8e91a6b91c5c8b", + "size": 191851, + "subdir": "linux-64", + "timestamp": 1661849504409, + "version": "7.3.4" + }, + "jupyter_client-7.3.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c15a11b8eb01e95fe99777de5c882c54", + "name": "jupyter_client", + "sha256": "c61be62997c41769362e37e311f0a629a4e754c725f1c7fd5882f03f0e85eb08", + "size": 191324, + "subdir": "linux-64", + "timestamp": 1661849228699, + "version": "7.3.4" + }, + "jupyter_client-7.3.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f8fd21c027a3a0e81767f1eafdd216b2", + "name": "jupyter_client", + "sha256": "21ec2220445c3f630f2230661adad14b84589e30e36a273d94f56301008c984f", + "size": 194435, + "subdir": "linux-64", + "timestamp": 1662504601486, + "version": "7.3.5" + }, + "jupyter_client-7.3.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "78553321fec7c8e54cca1eb22f8abca7", + "name": "jupyter_client", + "sha256": "da95031862dc4af1276edf0ea855375c6169fe26da8519d7ea19dc1ddb43bd92", + "size": 191382, + "subdir": "linux-64", + "timestamp": 1662504779143, + "version": "7.3.5" + }, + "jupyter_client-7.3.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5ae7dab8d20695a06c9e30f15034d06a", + "name": "jupyter_client", + "sha256": "d7dc4daeef6b1ee6f9fe9bb70d2137b98aaa32a660e13bee2e71cbe873fc0116", + "size": 191870, + "subdir": "linux-64", + "timestamp": 1662504405200, + "version": "7.3.5" + }, + "jupyter_client-7.3.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9b77c362df52110d52fd9d2062f38bc0", + "name": "jupyter_client", + "sha256": "78fcc34963059c5d8733b54c8c3399f173f1df1a2a397de240b00f5e6a0b7dd7", + "size": 191980, + "subdir": "linux-64", + "timestamp": 1662504952424, + "version": "7.3.5" + }, + "jupyter_client-7.4.7-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f786a87ae400e1246783104276397968", + "name": "jupyter_client", + "sha256": "c7436e4ab00fd0119999d7af28139192e6b4cfd170ff544dfb6359695c179aac", + "size": 195923, + "subdir": "linux-64", + "timestamp": 1669040879808, + "version": "7.4.7" + }, + "jupyter_client-7.4.7-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cb9a12deaec6a6d4e5ce2ff57c533e2e", + "name": "jupyter_client", + "sha256": "5a81ce9a52b41d5703f783c2b264617d6b61f670829a898f1ce8c17c72880191", + "size": 192402, + "subdir": "linux-64", + "timestamp": 1669040597438, + "version": "7.4.7" + }, + "jupyter_client-7.4.7-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7585f1c830e14fc1e020a4af8f230101", + "name": "jupyter_client", + "sha256": "c8f4d261b31fa2263497184cae441c1a1fc93a0b34687cf1b4242647fe1f019e", + "size": 193632, + "subdir": "linux-64", + "timestamp": 1669040311231, + "version": "7.4.7" + }, + "jupyter_client-7.4.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fc49916bdf9e1be120680554946921f8", + "name": "jupyter_client", + "sha256": "f0d5f12cac0dac18939cca97b5c2853f20ef4ad3eb0f93010df7d70b5e9dfcd8", + "size": 193671, + "subdir": "linux-64", + "timestamp": 1669041158256, + "version": "7.4.7" + }, + "jupyter_client-7.4.8-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "74b572e932dd70379ffb92fa866497ed", + "name": "jupyter_client", + "sha256": "26ed635e6c8e0607df84d3cdc9a0782db2cc3052e44cff41849740d1a36a4164", + "size": 196199, + "subdir": "linux-64", + "timestamp": 1671703086222, + "version": "7.4.8" + }, + "jupyter_client-7.4.8-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "01ed4c93af9616532c8cc06b49e24b85", + "name": "jupyter_client", + "sha256": "4b569c2b554c0cca7419cdbe3111553d78061fa3d93d5c0e134193d41fe32cd6", + "size": 193126, + "subdir": "linux-64", + "timestamp": 1671703876053, + "version": "7.4.8" + }, + "jupyter_client-7.4.8-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c65550f0d8367a2f0467cd3ed654cc45", + "name": "jupyter_client", + "sha256": "98fd318581257e51126310fba302951d71d91095b33c85354523f5d855fde5ea", + "size": 193650, + "subdir": "linux-64", + "timestamp": 1671703615861, + "version": "7.4.8" + }, + "jupyter_client-7.4.8-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e709c3424ba525af4c2d83098ded8f12", + "name": "jupyter_client", + "sha256": "794d3bc2e630ebb63c7596407203bc0021765cbb00008f3ec2ce14e235abe2e5", + "size": 193477, + "subdir": "linux-64", + "timestamp": 1671703353352, + "version": "7.4.8" + }, + "jupyter_client-7.4.9-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d6492166b889eb2eb2e0add30516de59", + "name": "jupyter_client", + "sha256": "7732f241da3062efc233c313d00bec20e04a4e1c7e9613432d2b9ff4cba37a08", + "size": 195965, + "subdir": "linux-64", + "timestamp": 1676329563637, + "version": "7.4.9" + }, + "jupyter_client-7.4.9-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "db395b0efd7018fcf3a4af879170c2a8", + "name": "jupyter_client", + "sha256": "79ce6dff3d93649a2555b1d2a4ae9eb77175a1c00664cb8eb0e6f848d5cdd1b9", + "size": 276856, + "subdir": "linux-64", + "timestamp": 1676823504812, + "version": "7.4.9" + }, + "jupyter_client-7.4.9-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "70e15140dededa828bf0b5f5964e63c3", + "name": "jupyter_client", + "sha256": "639c071612d7889a76ca0804b002f894dbd8f4e3c217b420ac9b3b7f57217732", + "size": 193084, + "subdir": "linux-64", + "timestamp": 1676329265802, + "version": "7.4.9" + }, + "jupyter_client-7.4.9-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "966714096421f7371663c8bfa72bfa89", + "name": "jupyter_client", + "sha256": "4c8a46b9b7ec7121a00b2d731b1da19fc5bf9f742be31b2d73985d1b384d6a38", + "size": 193526, + "subdir": "linux-64", + "timestamp": 1676329113709, + "version": "7.4.9" + }, + "jupyter_client-7.4.9-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8e9c0ef4b0b57caa87c146892e56a313", + "name": "jupyter_client", + "sha256": "4ba1f5698f0b483af397021b2047554afb3129790cac3a1502c79693154331d2", + "size": 192921, + "subdir": "linux-64", + "timestamp": 1676329415827, + "version": "7.4.9" + }, + "jupyter_client-8.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_core >=4.12,!=5.0.*", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "32ddc2e29610f4af6983f184fb3b01df", + "name": "jupyter_client", + "sha256": "f4303f454948be5648ffc25608b2ebee27832e290a4fc6e68dbfdd04245ca5e1", + "size": 168312, + "subdir": "linux-64", + "timestamp": 1680172590767, + "version": "8.1.0" + }, + "jupyter_client-8.1.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_core >=4.12,!=5.0.*", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "15d6d91f14a41035ab065d76c4586b19", + "name": "jupyter_client", + "sha256": "f2c64b7ddc342caabf745306255c0eb6704229af422356aff99fa5290d564534", + "size": 215759, + "subdir": "linux-64", + "timestamp": 1680172241388, + "version": "8.1.0" + }, + "jupyter_client-8.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=4.8.3", + "jupyter_core >=4.12,!=5.0.*", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "671901af9c3946b01563b8744ea2b72a", + "name": "jupyter_client", + "sha256": "dd63779d5f1e88463f77154c29fa5eead0ef52e7bac823ba78012d20bca51dd7", + "size": 166531, + "subdir": "linux-64", + "timestamp": 1680172942337, + "version": "8.1.0" + }, + "jupyter_client-8.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=4.8.3", + "jupyter_core >=4.12,!=5.0.*", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a3bed426a8dd4f0702bd28f14cf1cc20", + "name": "jupyter_client", + "sha256": "c0d652dad485030b55ff88a85092d11e4e31555a7d79491de1ce56fc4ed1b1a5", + "size": 166653, + "subdir": "linux-64", + "timestamp": 1680171895221, + "version": "8.1.0" + }, + "jupyter_console-5.2.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client", + "pexpect", + "prompt_toolkit >=1.0.0,<2", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f42787a3f6800fbb781ee0b5c293d9fb", + "name": "jupyter_console", + "sha256": "3679e6031b6e8da6cdca3117b7f83e502e6918ba74ea3aab06f0b9e81cf663ee", + "size": 35856, + "subdir": "linux-64", + "timestamp": 1530892903069, + "version": "5.2.0" + }, + "jupyter_console-5.2.0-py27hc6bee7e_1.tar.bz2": { + "build": "py27hc6bee7e_1", + "build_number": 1, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client", + "pexpect", + "prompt_toolkit >=1.0.0,<2", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2b5910c7a23b69c765fa840edae9880f", + "name": "jupyter_console", + "sha256": "bff35bb4f8c687e796fd373eb72d8ec6f2ad7a1bf3961dc8aa86cf3eeccc33c0", + "size": 34914, + "subdir": "linux-64", + "timestamp": 1505957266748, + "version": "5.2.0" + }, + "jupyter_console-5.2.0-py35h4044a63_1.tar.bz2": { + "build": "py35h4044a63_1", + "build_number": 1, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client", + "pexpect", + "prompt_toolkit >=1.0.0,<2", + "pygments", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "07c52cbdd995f2425ee226d055d7bc05", + "name": "jupyter_console", + "sha256": "efbf549d040c56d92de738fc3eeab8e57c70d0ed642484b55479b4aa2315228f", + "size": 35665, + "subdir": "linux-64", + "timestamp": 1505957283283, + "version": "5.2.0" + }, + "jupyter_console-5.2.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client", + "pexpect", + "prompt_toolkit >=1.0.0,<2", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0b3ae75d3e80a5daa51b4b27f3315462", + "name": "jupyter_console", + "sha256": "e499fa7263b6ad54f5eb39aebbdf9e47fd1d2ae069cb3a13ef3be9c769c16623", + "size": 36468, + "subdir": "linux-64", + "timestamp": 1530892872961, + "version": "5.2.0" + }, + "jupyter_console-5.2.0-py36he59e554_1.tar.bz2": { + "build": "py36he59e554_1", + "build_number": 1, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client", + "pexpect", + "prompt_toolkit >=1.0.0,<2", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3f1114bd1acf60858ac9f17515d1fc79", + "name": "jupyter_console", + "sha256": "ea184e30f6b4233d03144cb7ccb771b5e4a07a637fb4c90a7a6b480c58088a87", + "size": 35539, + "subdir": "linux-64", + "timestamp": 1505957299707, + "version": "5.2.0" + }, + "jupyter_console-5.2.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client", + "pexpect", + "prompt_toolkit >=1.0.0,<2", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "04282a115d1a889f85981c4f8e4d8f27", + "name": "jupyter_console", + "sha256": "e8a4a6068ea586f0b410615e662e4e63b1ee0f2e02432e3ad80ca4af521b7c25", + "size": 36532, + "subdir": "linux-64", + "timestamp": 1530892841146, + "version": "5.2.0" + }, + "jupyter_console-6.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client", + "prompt_toolkit >=2.0.0,<2.1.0", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f05108803133b6e2369311e98056ce10", + "name": "jupyter_console", + "sha256": "5b809daf1b0684cfd8a658b98e8d4b8873f695dbeb750c8abc8355f5a436be45", + "size": 36331, + "subdir": "linux-64", + "timestamp": 1539024695322, + "version": "6.0.0" + }, + "jupyter_console-6.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client", + "prompt_toolkit >=2.0.0,<2.1.0", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "33b75c6b5af16967dedf0630ab908371", + "name": "jupyter_console", + "sha256": "1a353cf6f2512e61f4eb0364d238e1cfad55638e82e6447c1943d78caeeceaf4", + "size": 36339, + "subdir": "linux-64", + "timestamp": 1539024664638, + "version": "6.0.0" + }, + "jupyter_console-6.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client", + "prompt_toolkit >=2.0.0,<2.1.0", + "pygments", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "43705eb49ea5e99d11e3ebff898b0746", + "name": "jupyter_console", + "sha256": "aecc7a74b70438d0b491b3954c5785e110608140fb36444cebc6c0176ca9a81c", + "size": 38282, + "subdir": "linux-64", + "timestamp": 1574238645702, + "version": "6.0.0" + }, + "jupyter_console-6.4.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client >=7.0.0", + "prompt_toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "41f122d1a347c451956bea3d3ca93f35", + "name": "jupyter_console", + "sha256": "99a9b02b97996a49f55d8220d7c4fff65044abb733db94e3ec078a48a6052804", + "size": 41261, + "subdir": "linux-64", + "timestamp": 1671541939419, + "version": "6.4.4" + }, + "jupyter_console-6.4.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client >=7.0.0", + "prompt_toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e6d3b3ba923ccdc7a9e75b5b4db2a7d", + "name": "jupyter_console", + "sha256": "272590c4df8e92a50ff2cd4c3a11f005ad2cac721a0f658a656b53f9e2ed6f49", + "size": 52793, + "subdir": "linux-64", + "timestamp": 1676827924183, + "version": "6.4.4" + }, + "jupyter_console-6.4.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client >=7.0.0", + "prompt_toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f7489ad6486676a67db8277ac07b6cab", + "name": "jupyter_console", + "sha256": "1e35b6287916ffbf75a4127a824ab5b5290fe44e62ecffe62367c48e4d841d88", + "size": 40771, + "subdir": "linux-64", + "timestamp": 1671541969961, + "version": "6.4.4" + }, + "jupyter_console-6.4.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client >=7.0.0", + "prompt_toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "08a63d3c9560fecb6e56bbe79fe925d0", + "name": "jupyter_console", + "sha256": "0b4d422cdb09634fe131e1eb945e757ccf88aea507522b46d425195188c70c96", + "size": 40938, + "subdir": "linux-64", + "timestamp": 1671542029723, + "version": "6.4.4" + }, + "jupyter_console-6.4.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client >=7.0.0", + "prompt_toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "09faefd54d0e63f28d428eb7a7dbe955", + "name": "jupyter_console", + "sha256": "ace24a0371c24a4d02786a114d218e268d9406c6fd65deba5120245e3c396bed", + "size": 40941, + "subdir": "linux-64", + "timestamp": 1671541999949, + "version": "6.4.4" + }, + "jupyter_console-6.6.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "ipython", + "jupyter_client >=7.0.0", + "jupyter_core >=4.12,!=5.0.*", + "prompt_toolkit >=3.0.30", + "pygments", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "traitlets >=5.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa20d90241f0c41172609f31d645c97d", + "name": "jupyter_console", + "sha256": "665d54b694ad58a684e3e797e74f9663e428972a0ddc684a0f63ed0477129d1b", + "size": 42474, + "subdir": "linux-64", + "timestamp": 1677674741056, + "version": "6.6.2" + }, + "jupyter_console-6.6.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "ipython", + "jupyter_client >=7.0.0", + "jupyter_core >=4.12,!=5.0.*", + "prompt_toolkit >=3.0.30", + "pygments", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "traitlets >=5.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a14e60bb7f1348bae16c594ac14bfd73", + "name": "jupyter_console", + "sha256": "cce664730e0954b3c2c2c50aa4c6b825f56d5a8be137a2701eb95b0855092409", + "size": 54027, + "subdir": "linux-64", + "timestamp": 1679336550072, + "version": "6.6.2" + }, + "jupyter_console-6.6.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "ipython", + "jupyter_client >=7.0.0", + "jupyter_core >=4.12,!=5.0.*", + "prompt_toolkit >=3.0.30", + "pygments", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "traitlets >=5.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "da6db6ecbf8011c4dc156fa9ef2952a4", + "name": "jupyter_console", + "sha256": "9ef8ced28c06e4c178bd33f75ce023219c1a3c91ab85bff4c6dbf692bcacf79e", + "size": 42141, + "subdir": "linux-64", + "timestamp": 1677674680500, + "version": "6.6.2" + }, + "jupyter_console-6.6.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "ipython", + "jupyter_client >=7.0.0", + "jupyter_core >=4.12,!=5.0.*", + "prompt_toolkit >=3.0.30", + "pygments", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "traitlets >=5.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "73fdc911149792bc45d3c387b2f1b6ab", + "name": "jupyter_console", + "sha256": "8bca6dfbb4d503fcc1162a48ca6a43d50de0fe26e6445d7be344eeafbeebde15", + "size": 42150, + "subdir": "linux-64", + "timestamp": 1677674711139, + "version": "6.6.2" + }, + "jupyter_console-6.6.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "ipython", + "jupyter_client >=7.0.0", + "jupyter_core >=4.12,!=5.0.*", + "prompt_toolkit >=3.0.30", + "pygments", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "traitlets >=5.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9d98fae5262fe53618bc1bddbb370d6f", + "name": "jupyter_console", + "sha256": "3da0b690f0a1ad6f6a437a0968dddd2e87c2338a65cfa5726c973ce30dcad2a2", + "size": 42901, + "subdir": "linux-64", + "timestamp": 1679999729802, + "version": "6.6.3" + }, + "jupyter_console-6.6.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "ipython", + "jupyter_client >=7.0.0", + "jupyter_core >=4.12,!=5.0.*", + "prompt_toolkit >=3.0.30", + "pygments", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "traitlets >=5.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a7c33c0f4079ffcc118d92bf849e9cd", + "name": "jupyter_console", + "sha256": "f1e1a89e093a05bc93ad07b0ebd71ada215861437998358a94ed7528feef1a0f", + "size": 54223, + "subdir": "linux-64", + "timestamp": 1679999662329, + "version": "6.6.3" + }, + "jupyter_console-6.6.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "ipython", + "jupyter_client >=7.0.0", + "jupyter_core >=4.12,!=5.0.*", + "prompt_toolkit >=3.0.30", + "pygments", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "traitlets >=5.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d50bcc70e958ed0fe37174ba8646a55e", + "name": "jupyter_console", + "sha256": "a3fda117e7626aed619eb8c6eb0c6a6d880c09bce6c0a74ed8a4c7dc28bc7a70", + "size": 42569, + "subdir": "linux-64", + "timestamp": 1679999763666, + "version": "6.6.3" + }, + "jupyter_console-6.6.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "ipython", + "jupyter_client >=7.0.0", + "jupyter_core >=4.12,!=5.0.*", + "prompt_toolkit >=3.0.30", + "pygments", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "traitlets >=5.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "94b84bb1643b814c50481ae79615916d", + "name": "jupyter_console", + "sha256": "a3c896692e0a01a8b8c3925685ebf1b3036283305692855d34cfb57c4f1d8629", + "size": 42565, + "subdir": "linux-64", + "timestamp": 1679999694997, + "version": "6.6.3" + }, + "jupyter_core-4.10.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b79c5bbe64731c46d73b4ed31ced8f53", + "name": "jupyter_core", + "sha256": "61a33c8b020c0e2a51a7e8f147f8a93f28f19f4ca6c9b23e88727b5abec777a6", + "size": 82984, + "subdir": "linux-64", + "timestamp": 1651671331477, + "version": "4.10.0" + }, + "jupyter_core-4.10.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7300d42ac1cccdca8b8223d63c94722b", + "name": "jupyter_core", + "sha256": "c5a7242bed0c60395192ef1f60d1c702c8dd222eea04f17c31b929c7f2882c39", + "size": 82320, + "subdir": "linux-64", + "timestamp": 1651671261820, + "version": "4.10.0" + }, + "jupyter_core-4.10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f6d831a7bd563e48bcc08e12f7af6ab", + "name": "jupyter_core", + "sha256": "f75c3d5d070ca6da3dd53de20e82a096fbcce99a198fccee4976c035a877c4b9", + "size": 82341, + "subdir": "linux-64", + "timestamp": 1651671359188, + "version": "4.10.0" + }, + "jupyter_core-4.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88f9e1c99b3920499eb68db8e3d0590a", + "name": "jupyter_core", + "sha256": "b55a60a6e408fcfe87f5f17482009695d74e379cb0a70fe7a6a7ae95df760467", + "size": 82586, + "subdir": "linux-64", + "timestamp": 1651671292026, + "version": "4.10.0" + }, + "jupyter_core-4.11.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5b0b1eaff19fb0ed738520f9e03f0720", + "name": "jupyter_core", + "sha256": "13b2d047397dfdfbe3e41f6ba053c2684ec19a7bd3ed76392d98e297bcd6ad28", + "size": 83241, + "subdir": "linux-64", + "timestamp": 1664917412252, + "version": "4.11.1" + }, + "jupyter_core-4.11.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb5b9078e94d8f23998dbe4302b6aa5a", + "name": "jupyter_core", + "sha256": "55e134f3a2b9f9dadc02245f7c71d796d6ea85468132215ff203f59b303d5296", + "size": 82569, + "subdir": "linux-64", + "timestamp": 1664917442869, + "version": "4.11.1" + }, + "jupyter_core-4.11.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0cc004a99cf72175509c6bbbebfeedd5", + "name": "jupyter_core", + "sha256": "b5e2798b0277a1253fe45776424a64b3b6bbeaf6fa740e8c721e567ad2a613d4", + "size": 82631, + "subdir": "linux-64", + "timestamp": 1664917336879, + "version": "4.11.1" + }, + "jupyter_core-4.11.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cebf1913a5b28e4a52d382cc06097844", + "name": "jupyter_core", + "sha256": "a7be54f51cde2cd36d87da466533f2ed8b3428a61f52d491ff79835b60396358", + "size": 82781, + "subdir": "linux-64", + "timestamp": 1664917370029, + "version": "4.11.1" + }, + "jupyter_core-4.11.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "73fe06708e831167ca92967c03c87a63", + "name": "jupyter_core", + "sha256": "b73f381862550c1dc39328d3219300f7f9da554d320bbaad5b77fa5b5e062e47", + "size": 83270, + "subdir": "linux-64", + "timestamp": 1668084533635, + "version": "4.11.2" + }, + "jupyter_core-4.11.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e5180295ff0ef9cd58a4e6ce70fbec0a", + "name": "jupyter_core", + "sha256": "9c06cbfa6098ba6917ef00fdf169175a8f0aad56d3eb22ac16d11dd23e230e00", + "size": 82557, + "subdir": "linux-64", + "timestamp": 1668084564177, + "version": "4.11.2" + }, + "jupyter_core-4.11.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "47f50bf8be0c410e7c258d79a642b1ed", + "name": "jupyter_core", + "sha256": "1608e432776fd5088bf8dc22fa3efa725a4b6b6b618ce0426a9036f895cdb593", + "size": 82629, + "subdir": "linux-64", + "timestamp": 1668084503651, + "version": "4.11.2" + }, + "jupyter_core-4.11.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7ce47777400c68e053e8766037fa8b32", + "name": "jupyter_core", + "sha256": "51073db4fc6537639b3405bc389e21189574d4139f8a10060315d77b13f18fde", + "size": 82919, + "subdir": "linux-64", + "timestamp": 1668084473932, + "version": "4.11.2" + }, + "jupyter_core-4.3.0-py27hcd9ae3a_0.tar.bz2": { + "build": "py27hcd9ae3a_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "2bea444cffe2779bcbfce79780d5c997", + "name": "jupyter_core", + "sha256": "f08c4b8327c304acd3424cec88910ec7133d0e317ebfeab2527258acf755feb5", + "size": 60470, + "subdir": "linux-64", + "timestamp": 1505672242706, + "version": "4.3.0" + }, + "jupyter_core-4.3.0-py35he2f7985_0.tar.bz2": { + "build": "py35he2f7985_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "a718c2545cf2dc2d21403969b3ed2fae", + "name": "jupyter_core", + "sha256": "5cc8c9a7ec68f25d6f6e29687d2e333d11a82ef44a274e0810c0b80a875f36e7", + "size": 61202, + "subdir": "linux-64", + "timestamp": 1505672257166, + "version": "4.3.0" + }, + "jupyter_core-4.3.0-py36h357a921_0.tar.bz2": { + "build": "py36h357a921_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "3c056df46e058a19f9bbdc86f6df0b29", + "name": "jupyter_core", + "sha256": "d8b0140c3ba856481afba6d3a4cbcefa39a115554f6e4abe2d6e241401cc8a55", + "size": 61149, + "subdir": "linux-64", + "timestamp": 1505672272011, + "version": "4.3.0" + }, + "jupyter_core-4.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "fad88070dac03ed6ac1cd36c1c5fda89", + "name": "jupyter_core", + "sha256": "e268cce0264d4d7e522e32e8a9969c7b1029b3e88e917ed64c598f5b1a820ef5", + "size": 63659, + "subdir": "linux-64", + "timestamp": 1530694461495, + "version": "4.4.0" + }, + "jupyter_core-4.4.0-py27h345911c_0.tar.bz2": { + "build": "py27h345911c_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6511c05950adedc3cb13a4d07dec79ad", + "name": "jupyter_core", + "sha256": "4a9bb9c9124d5127bff3fbfd79be42159299b92520714b22a287cf7bd638cea5", + "size": 61861, + "subdir": "linux-64", + "timestamp": 1511290813060, + "version": "4.4.0" + }, + "jupyter_core-4.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "be88ac8d4dd23e1be9baec628c15c358", + "name": "jupyter_core", + "sha256": "7075c74b370b6bd757895b955d41780d692fb18c2b976696d8067a8583196035", + "size": 64151, + "subdir": "linux-64", + "timestamp": 1534345287327, + "version": "4.4.0" + }, + "jupyter_core-4.4.0-py35ha89e94b_0.tar.bz2": { + "build": "py35ha89e94b_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6ecc58864633b94cbb99078373b5616f", + "name": "jupyter_core", + "sha256": "def5eda3246e2526adc8a9f57c63a3c8b58293daabc9b7e23ceeb56cdccadfe8", + "size": 62518, + "subdir": "linux-64", + "timestamp": 1511290832830, + "version": "4.4.0" + }, + "jupyter_core-4.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "33abba9e90787e73f2b51a3c4691c544", + "name": "jupyter_core", + "sha256": "628535f84dfcf919e61783ccee4dc9c8c9dfa653d461444091bf8fe65d76f2d6", + "size": 64122, + "subdir": "linux-64", + "timestamp": 1530694419261, + "version": "4.4.0" + }, + "jupyter_core-4.4.0-py36h7c827e3_0.tar.bz2": { + "build": "py36h7c827e3_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b720865d024116815271eea281bce8c3", + "name": "jupyter_core", + "sha256": "c6253af13201c004ccc5c53dcdc9e3cf75b2c00abc358a0e08a0f0025d439bde", + "size": 62452, + "subdir": "linux-64", + "timestamp": 1511290842789, + "version": "4.4.0" + }, + "jupyter_core-4.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4631bcdff8c8595bd30384c154e852a4", + "name": "jupyter_core", + "sha256": "c576c0e275517cbb794089a8449583be5a6f7e3e068649163ea59b11c2fe225b", + "size": 64103, + "subdir": "linux-64", + "timestamp": 1530694440867, + "version": "4.4.0" + }, + "jupyter_core-4.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "217e2bc7cae36c0168eaa493de9a1721", + "name": "jupyter_core", + "sha256": "b71b2baa23316c4a592ddb8e21780b3b54af1a5f46a8b90958223f44c01bce13", + "size": 68907, + "subdir": "linux-64", + "timestamp": 1572457594939, + "version": "4.5.0" + }, + "jupyter_core-4.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1139fc053de7144c01b29051055830b1", + "name": "jupyter_core", + "sha256": "0a660778b51fea6757f4fb0d23f506a76c73a58ab756640213c56be93df0dd57", + "size": 69411, + "subdir": "linux-64", + "timestamp": 1572457593977, + "version": "4.5.0" + }, + "jupyter_core-4.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c4b68d56b8699a337255e92da4c74c4a", + "name": "jupyter_core", + "sha256": "d465a85203d956eeb002c19bf94408fcff20ffccb71eb8114b23fe8e7880f2b4", + "size": 69401, + "subdir": "linux-64", + "timestamp": 1572457550358, + "version": "4.5.0" + }, + "jupyter_core-4.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0650e356fd627924114c243c6d7cac82", + "name": "jupyter_core", + "sha256": "85f5ee338f9d2a62472002875ffab43b00a90471fd9b2f777d89df80b62f70bb", + "size": 74932, + "subdir": "linux-64", + "timestamp": 1571153848777, + "version": "4.6.0" + }, + "jupyter_core-4.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ea7b01e3c2d7ab086c11393a27b46363", + "name": "jupyter_core", + "sha256": "b74018bd58dd4ba9766134bc743560e9547bc74f05dd6389938173d3a60ea32c", + "size": 75525, + "subdir": "linux-64", + "timestamp": 1571153862840, + "version": "4.6.0" + }, + "jupyter_core-4.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "449014d054e8cddb25a0cb4c24b2f677", + "name": "jupyter_core", + "sha256": "502ad465ca4f1bcb323f8ae9c09e0cd8fd0b285bd39f01fc65788ff8f02bbdb5", + "size": 75407, + "subdir": "linux-64", + "timestamp": 1571153862604, + "version": "4.6.0" + }, + "jupyter_core-4.6.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6b7348ba97213c7ee30b3b214df2e623", + "name": "jupyter_core", + "sha256": "1f4a4f71f62326be962fa5bb9d6235c86eae400d93d63ff988a47844e34204e8", + "size": 75376, + "subdir": "linux-64", + "timestamp": 1573062510826, + "version": "4.6.1" + }, + "jupyter_core-4.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "80a05143cafbb73f868934459d07dd6a", + "name": "jupyter_core", + "sha256": "48d9a7d751ed7e17ea70d424ca65af27942037c36c93ce5221b348c39e580fdb", + "size": 75968, + "subdir": "linux-64", + "timestamp": 1573062515899, + "version": "4.6.1" + }, + "jupyter_core-4.6.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f6d606300baf2f1c6fd54451b8be4022", + "name": "jupyter_core", + "sha256": "1bc9a40a2f3cc3554bb1dbcf14b794cc433d5795b7b2e828e591736dfcd8ae5d", + "size": 75773, + "subdir": "linux-64", + "timestamp": 1573062508223, + "version": "4.6.1" + }, + "jupyter_core-4.6.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d8e2806e817a408744b0e6d083ff4d14", + "name": "jupyter_core", + "sha256": "002e75b8f1ec47729a193046401ab305cce99edc531fb9c6337672f85394febd", + "size": 72646, + "subdir": "linux-64", + "timestamp": 1574097555051, + "version": "4.6.1" + }, + "jupyter_core-4.6.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c9e9f819dcc838bb552d9e2553e4bb06", + "name": "jupyter_core", + "sha256": "bdaac859538adf0d4f64fcd79aafab36ddaee9b41ba5a0f8286fa11f8d1023d9", + "size": 76794, + "subdir": "linux-64", + "timestamp": 1585645262710, + "version": "4.6.3" + }, + "jupyter_core-4.6.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "effa5eeb9d69a9bf05cd541a156f73a8", + "name": "jupyter_core", + "sha256": "121944d52caeb6080216872568b7aa53b5a4f3fd1d8319ecad422681d5feb1fc", + "size": 76580, + "subdir": "linux-64", + "timestamp": 1585645218484, + "version": "4.6.3" + }, + "jupyter_core-4.6.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a9924c22b6416cb3a10a9dbeeb8a57a5", + "name": "jupyter_core", + "sha256": "46b24126eebadf551e6729cf3ebb2886e002592277e0ec7c4d1b3480d42c1671", + "size": 76747, + "subdir": "linux-64", + "timestamp": 1585645262149, + "version": "4.6.3" + }, + "jupyter_core-4.7.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "16f9a056500bb052c96321402b4302d6", + "name": "jupyter_core", + "sha256": "8582665b229f3dd8d1de0008fe73de6d5f0b1892e082d0cdfb007ff82ef32c1b", + "size": 73954, + "subdir": "linux-64", + "timestamp": 1606149006140, + "version": "4.7.0" + }, + "jupyter_core-4.7.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "48fc167172b8b9ad0bc15b88edeaa8a9", + "name": "jupyter_core", + "sha256": "08b381ce8d7ff089e5d855b7ba373590af0826b461d12260242f23c199fc404f", + "size": 73854, + "subdir": "linux-64", + "timestamp": 1606148988928, + "version": "4.7.0" + }, + "jupyter_core-4.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e5446e798f5d7f7030845b2166183c05", + "name": "jupyter_core", + "sha256": "861490a544bf011fc7af2818f5772e8044801faa0c3dbcc87e3a2bd4eb0f995d", + "size": 74015, + "subdir": "linux-64", + "timestamp": 1606149038092, + "version": "4.7.0" + }, + "jupyter_core-4.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "abdcf149c324836e6cbb861995cb0d37", + "name": "jupyter_core", + "sha256": "f028c77f1fcbd82ae10eacd4d52d6155766192be82bc81766a8f5aea7041bc7e", + "size": 77606, + "subdir": "linux-64", + "timestamp": 1606834060003, + "version": "4.7.0" + }, + "jupyter_core-4.7.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8240264240cc8a6b29a951de6e1f6c69", + "name": "jupyter_core", + "sha256": "1da0c5793ebf7918105b054f78306f6f568ea46bd403054d65f62769ecca67d6", + "size": 73954, + "subdir": "linux-64", + "timestamp": 1612213346084, + "version": "4.7.1" + }, + "jupyter_core-4.7.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0752164ac4ff8eee76238f15fd4ba86b", + "name": "jupyter_core", + "sha256": "c59b918061f6231c7f5fe91348e52f37fd86586f1bf3ee39bd278a4e12117318", + "size": 73883, + "subdir": "linux-64", + "timestamp": 1612213343388, + "version": "4.7.1" + }, + "jupyter_core-4.7.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7235d5ac2cb7062c003608357633357d", + "name": "jupyter_core", + "sha256": "0cc900eb7d6fd512f8dee4a608bbf60019c252e752795f48324eeefe595452dd", + "size": 73892, + "subdir": "linux-64", + "timestamp": 1612213351745, + "version": "4.7.1" + }, + "jupyter_core-4.7.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a90599b280b497d2ed154c4dbef5cce7", + "name": "jupyter_core", + "sha256": "663cbe5946e82042303a8a4d8a2e9e537baa94db08a9a765b6f6fb7c317ce09c", + "size": 74105, + "subdir": "linux-64", + "timestamp": 1612213349730, + "version": "4.7.1" + }, + "jupyter_core-4.8.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1dd4db758a1abf798b8f8e2f11eacdee", + "name": "jupyter_core", + "sha256": "084c9aae840e54b837286ecb44285060c7b0accbe955cbdc45698563163a5149", + "size": 80127, + "subdir": "linux-64", + "timestamp": 1633420155136, + "version": "4.8.1" + }, + "jupyter_core-4.8.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a9da65acd9c6674d5c2c1f04369f78d1", + "name": "jupyter_core", + "sha256": "a33ac7074abac3c037bb4dae108527f81e17b2ae6d4d734e9cbdc7a27a35afe5", + "size": 80092, + "subdir": "linux-64", + "timestamp": 1633420124599, + "version": "4.8.1" + }, + "jupyter_core-4.8.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aca533a8b72475c24fc9fad65349ac60", + "name": "jupyter_core", + "sha256": "e7ea7c36c4e3b2f3b0281ac1b9c9004b5b9897424fdbed352ef0c906cf2fe407", + "size": 80259, + "subdir": "linux-64", + "timestamp": 1633409436315, + "version": "4.8.1" + }, + "jupyter_core-4.8.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3c50033ec769a00150ac176280ec18d1", + "name": "jupyter_core", + "sha256": "c9e5b0614990e533615951fb35f9ee3e26ea6052d3c5467e9974b1c48faa3ef0", + "size": 80416, + "subdir": "linux-64", + "timestamp": 1633420138922, + "version": "4.8.1" + }, + "jupyter_core-4.9.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5d1df89563bc29f22cc3f5eac5967b63", + "name": "jupyter_core", + "sha256": "69fb8c0d876a9d4b89a1ac3d5b5c2ebe8214c4d12efb6684ecccc76f1f0f8f26", + "size": 82246, + "subdir": "linux-64", + "timestamp": 1641916134081, + "version": "4.9.1" + }, + "jupyter_core-4.9.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "042758f6133e6b0a40fd9187f82bcc6c", + "name": "jupyter_core", + "sha256": "ffcfeb994bdcbe56fd8f556a8a9877a12f5091330bed3ae419f79ac5f06a42e9", + "size": 81414, + "subdir": "linux-64", + "timestamp": 1636537069547, + "version": "4.9.1" + }, + "jupyter_core-4.9.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f89018a30f5ce82128b656d0bde280f5", + "name": "jupyter_core", + "sha256": "dc442338e1a0386f0515cb6f7410cb6fd7da459bed48057dca561f91f22a42ce", + "size": 81453, + "subdir": "linux-64", + "timestamp": 1636524790246, + "version": "4.9.1" + }, + "jupyter_core-4.9.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9eec2092ba985f6cdd36daba09de03fb", + "name": "jupyter_core", + "sha256": "2034f61b3b9c2fbbe9b84618b667cb2fc19e1e9b15e8fb895c058c7acdbe9239", + "size": 81680, + "subdir": "linux-64", + "timestamp": 1636537058844, + "version": "4.9.1" + }, + "jupyter_core-4.9.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c85cf1f70bb030ce6b2c264219523cd4", + "name": "jupyter_core", + "sha256": "c2c3153454048749c50ec636d020b6fc22ac85a05a6aef9ee169fe844872dfcf", + "size": 86690, + "subdir": "linux-64", + "timestamp": 1646994486831, + "version": "4.9.2" + }, + "jupyter_core-4.9.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1c8e226ee09e2b7372d24a5cc67a7054", + "name": "jupyter_core", + "sha256": "a4ddad6e2b65c679b273308517bff883e65ccfadbc51559088926c446e57b0b3", + "size": 85928, + "subdir": "linux-64", + "timestamp": 1646994476826, + "version": "4.9.2" + }, + "jupyter_core-4.9.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c1e344766d48bda292dfb0d898454067", + "name": "jupyter_core", + "sha256": "cc740e32c68ac72f9eadaf47f999ee65a047e9c4b144273ab6dc2b23cf94317d", + "size": 86107, + "subdir": "linux-64", + "timestamp": 1646994473562, + "version": "4.9.2" + }, + "jupyter_core-4.9.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d93cf759c4ec1e41608f0151d15dc58f", + "name": "jupyter_core", + "sha256": "498f2b57cf8ec879db2bf0446a7e3497decdf3f245dbfdd408f0a4cb91d16662", + "size": 86298, + "subdir": "linux-64", + "timestamp": 1646976345169, + "version": "4.9.2" + }, + "jupyter_core-5.1.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.10,<3.11.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "843339aa2770735aaff599b462ccd24a", + "name": "jupyter_core", + "sha256": "b9be0f382ec55d803522410147c39d388b65ea3b831f4dc4bf670c73934c5bc4", + "size": 90891, + "subdir": "linux-64", + "timestamp": 1672332284637, + "version": "5.1.1" + }, + "jupyter_core-5.1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.8,<3.9.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "832158fabba6a151d1a6f42a2992745c", + "name": "jupyter_core", + "sha256": "b6c50e04ef1f690db0945c61918ba39b0e8006499392c9433b86d9bcb5bb6883", + "size": 90151, + "subdir": "linux-64", + "timestamp": 1672332313759, + "version": "5.1.1" + }, + "jupyter_core-5.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.9,<3.10.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eb4df68faa3f92ea00675988202cd089", + "name": "jupyter_core", + "sha256": "f1ccb742af76e87c6d11134f4d1d2d6e30e75f1a9cd13e822ad80d4b1b074ba6", + "size": 90359, + "subdir": "linux-64", + "timestamp": 1672332255325, + "version": "5.1.1" + }, + "jupyter_core-5.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.10,<3.11.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1ba0d70baa8532b75a430f22d55723b7", + "name": "jupyter_core", + "sha256": "3577f7e1086474fad9619dccac778df004de596bffafb26ecd70941a6df29531", + "size": 92182, + "subdir": "linux-64", + "timestamp": 1676538658256, + "version": "5.2.0" + }, + "jupyter_core-5.2.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.11,<3.12.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0cfbcbcf2fab39bfd4a4443b9ad17fa7", + "name": "jupyter_core", + "sha256": "332819adf4daacd190f0078879a33504d2e82253ea928d2fe66b09142cba78f8", + "size": 115918, + "subdir": "linux-64", + "timestamp": 1676823359810, + "version": "5.2.0" + }, + "jupyter_core-5.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.8,<3.9.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f73cebb37a78ec0498dafe229a6aafe5", + "name": "jupyter_core", + "sha256": "9d5152b4f68e3a5e34db5c5521a93c962d3bce3674bf558ef2c0ffc1751649ae", + "size": 91671, + "subdir": "linux-64", + "timestamp": 1676538598023, + "version": "5.2.0" + }, + "jupyter_core-5.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.9,<3.10.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b6b9e07c090bb36906bb810422b1a0a9", + "name": "jupyter_core", + "sha256": "8c4720ebe8bd0ad37af519f3ce69b34e053d54155fc1a7e9b57de79ea80e2300", + "size": 91655, + "subdir": "linux-64", + "timestamp": 1676538628009, + "version": "5.2.0" + }, + "jupyter_core-5.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.10,<3.11.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b6ee7e9337a0ce9731b54c194ce72d73", + "name": "jupyter_core", + "sha256": "0f122770cc027c9a69678db1067d949c6629e30116acb0b7a3a5b35e2b5d8b06", + "size": 91958, + "subdir": "linux-64", + "timestamp": 1679906681642, + "version": "5.3.0" + }, + "jupyter_core-5.3.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.11,<3.12.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9281382628d336b5480c27a10f3e702d", + "name": "jupyter_core", + "sha256": "16162119b0fa3826c97fb1a4b822aaf5ba71d258d456bbf8e9f2593ccb2b2cc8", + "size": 115219, + "subdir": "linux-64", + "timestamp": 1679906624249, + "version": "5.3.0" + }, + "jupyter_core-5.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.8,<3.9.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "55dcff614b00ebf9d9133a94b51525d3", + "name": "jupyter_core", + "sha256": "ddfb7d8c465e40624168c4298783fc3241674c26652f22e6ed83766f2154f544", + "size": 91415, + "subdir": "linux-64", + "timestamp": 1679906595114, + "version": "5.3.0" + }, + "jupyter_core-5.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.9,<3.10.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d851b401dc13d04e6848bb36e12efc1c", + "name": "jupyter_core", + "sha256": "0192bd48cd96c60dc3054d5addd8cdb4a29a218843181318371f79daec8242f8", + "size": 91534, + "subdir": "linux-64", + "timestamp": 1679906652183, + "version": "5.3.0" + }, + "jupyter_dashboards_bundlers-0.9.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "notebook >=5.0", + "python >=2.7,<2.8.0a0", + "requests >=2.7" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "82f66b818dee7638ca931f4319dd76ee", + "name": "jupyter_dashboards_bundlers", + "sha256": "36c7ccdd8b367f167498938811a12ac5de47d7803854fe97add03e2f128c4b5a", + "size": 14022, + "subdir": "linux-64", + "timestamp": 1539206257280, + "version": "0.9.1" + }, + "jupyter_dashboards_bundlers-0.9.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "notebook >=5.0", + "python >=3.10,<3.11.0a0", + "requests >=2.7" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "30a156804953c376ae297b8300daecff", + "name": "jupyter_dashboards_bundlers", + "sha256": "598069a1800f095568ed8dc81bf0b255930078b03cbae173138421b0b4468129", + "size": 14583, + "subdir": "linux-64", + "timestamp": 1640815241939, + "version": "0.9.1" + }, + "jupyter_dashboards_bundlers-0.9.1-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "notebook >=5.0", + "python >=3.11,<3.12.0a0", + "requests >=2.7" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "55410bfbe3dab9f8e09d8aa2a6682572", + "name": "jupyter_dashboards_bundlers", + "sha256": "066a536cfeb628f1223f9036a62efd3f56020dcbf4924df085f15d45c0fe0b96", + "size": 17253, + "subdir": "linux-64", + "timestamp": 1676907278937, + "version": "0.9.1" + }, + "jupyter_dashboards_bundlers-0.9.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "notebook >=5.0", + "python >=3.6,<3.7.0a0", + "requests >=2.7" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "ac0e91cc49782f31e3d15275a1d709b6", + "name": "jupyter_dashboards_bundlers", + "sha256": "86cf81f8900c52a854ad900cf2ca463f7b5f49d5a03346770c21721620ec55ed", + "size": 14133, + "subdir": "linux-64", + "timestamp": 1539206280719, + "version": "0.9.1" + }, + "jupyter_dashboards_bundlers-0.9.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "notebook >=5.0", + "python >=3.6,<3.7.0a0", + "requests >=2.7" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "3ebb467f324293f8bd63d41ca6ee6d68", + "name": "jupyter_dashboards_bundlers", + "sha256": "ee64518c3cdcf2b2a6325f0d2aff16880c8a7369aad7a8c1a425a552bd7a5083", + "size": 239547, + "subdir": "linux-64", + "timestamp": 1615394836203, + "version": "0.9.1" + }, + "jupyter_dashboards_bundlers-0.9.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "notebook >=5.0", + "python >=3.7,<3.8.0a0", + "requests >=2.7" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "6f93db9b56c8976cd28cc71ade8597a8", + "name": "jupyter_dashboards_bundlers", + "sha256": "3e9b6c484a0b8bf92feb166f4869078551b95d104ada27130f5ea80e78d6d13f", + "size": 14134, + "subdir": "linux-64", + "timestamp": 1539206295458, + "version": "0.9.1" + }, + "jupyter_dashboards_bundlers-0.9.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "notebook >=5.0", + "python >=3.7,<3.8.0a0", + "requests >=2.7" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "76b6d64a4649054cc4bd761b64e5fd18", + "name": "jupyter_dashboards_bundlers", + "sha256": "480cf42c53f826019423696032168f3f29f35615ebe99e0d94a357b112ecb732", + "size": 239639, + "subdir": "linux-64", + "timestamp": 1615394985475, + "version": "0.9.1" + }, + "jupyter_dashboards_bundlers-0.9.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "notebook >=5.0", + "python >=3.8,<3.9.0a0", + "requests >=2.7" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "8bc6efafbc0205bc3a4ebed1ebbc66a5", + "name": "jupyter_dashboards_bundlers", + "sha256": "6d29fee0401189fddbae1a1efa00d0abe35cb465e58dfc7b9efcfab25066c08f", + "size": 240231, + "subdir": "linux-64", + "timestamp": 1615394987932, + "version": "0.9.1" + }, + "jupyter_dashboards_bundlers-0.9.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "notebook >=5.0", + "python >=3.9,<3.10.0a0", + "requests >=2.7" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "4db346f80c44ae29aac444efd9b1f76c", + "name": "jupyter_dashboards_bundlers", + "sha256": "aa6cf037566a27b0bcb66b11d8db3d00b9f8a1ba0646be027b35fe4881ca5909", + "size": 240017, + "subdir": "linux-64", + "timestamp": 1615394992359, + "version": "0.9.1" + }, + "jupyter_kernel_gateway-2.1.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "notebook >=5.3.0,<6.0", + "python >=2.7,<2.8.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD 3-Clause", + "md5": "b6cc06a70b82cea2fdbf94dfc1731414", + "name": "jupyter_kernel_gateway", + "sha256": "68e1d3ce5a0f28473768277d4387fb94e2c5bc290d642133902e6ae0a10e6c70", + "size": 54784, + "subdir": "linux-64", + "timestamp": 1536855145864, + "version": "2.1.0" + }, + "jupyter_kernel_gateway-2.1.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "notebook >=5.3.0,<6.0", + "python >=3.5,<3.6.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD 3-Clause", + "md5": "c42c8848b73acab03853b87cdc330326", + "name": "jupyter_kernel_gateway", + "sha256": "1867ba44e5e57371e29eef9800f7102f4e94055caa94a75c20b5f8a37f2107f7", + "size": 56307, + "subdir": "linux-64", + "timestamp": 1536855193796, + "version": "2.1.0" + }, + "jupyter_kernel_gateway-2.1.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "notebook >=5.3.0,<6.0", + "python >=3.6,<3.7.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD 3-Clause", + "md5": "74182cc3ef76eaad0782bb4418044944", + "name": "jupyter_kernel_gateway", + "sha256": "70123e312a8b77dccb5f99bd32d0f28a40e9d3c3d93c5b927895371aae29fe08", + "size": 56158, + "subdir": "linux-64", + "timestamp": 1536855181727, + "version": "2.1.0" + }, + "jupyter_kernel_gateway-2.1.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "notebook >=5.3.0,<6.0", + "python >=3.7,<3.8.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD 3-Clause", + "md5": "dcc0aa4ab2ddc8c1b7bc0db984aa22db", + "name": "jupyter_kernel_gateway", + "sha256": "d2ac9e04d09b3bc59f650c94a789149ffe471fbd6b7d9c83eb92666d2319d0f4", + "size": 56238, + "subdir": "linux-64", + "timestamp": 1536855141121, + "version": "2.1.0" + }, + "jupyter_kernel_gateway-2.5.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "notebook >=5.7.6,<7.0", + "python >=3.10,<3.11.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fd0f715ebae3b5979f8dc32bf1fbcba5", + "name": "jupyter_kernel_gateway", + "sha256": "77af4961f3138d902df74d73ba8025a2e951ad8ac6443f0962553544507c873e", + "size": 57975, + "subdir": "linux-64", + "timestamp": 1670546582778, + "version": "2.5.1" + }, + "jupyter_kernel_gateway-2.5.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "notebook >=5.7.6,<7.0", + "python >=3.11,<3.12.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eacc112883816953eba2d3b5c1dcd258", + "name": "jupyter_kernel_gateway", + "sha256": "6e90930685a756754fa58e4451d807409ef2f99a11d81b92a6dda20646e2ee46", + "size": 73459, + "subdir": "linux-64", + "timestamp": 1676853030777, + "version": "2.5.1" + }, + "jupyter_kernel_gateway-2.5.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "notebook >=5.7.6,<7.0", + "python >=3.7,<3.8.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "64063526671f0152978dfb25a1373b13", + "name": "jupyter_kernel_gateway", + "sha256": "ef5e2f9e9622eca88a448c3b94fd02ae146b1c7b87dfa0d4d3e752f72a24df19", + "size": 57263, + "subdir": "linux-64", + "timestamp": 1670546652652, + "version": "2.5.1" + }, + "jupyter_kernel_gateway-2.5.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "notebook >=5.7.6,<7.0", + "python >=3.8,<3.9.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1ddc3d7dc15775c5347bf2cd6ccb02da", + "name": "jupyter_kernel_gateway", + "sha256": "d9b6b2a0b8d1b984e87c48e65518ad3aa0b8f2b864a3af8d18ed31a5c509ac44", + "size": 57329, + "subdir": "linux-64", + "timestamp": 1670546687842, + "version": "2.5.1" + }, + "jupyter_kernel_gateway-2.5.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "notebook >=5.7.6,<7.0", + "python >=3.9,<3.10.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "87098f7720b169b0019c6930eb1e5e52", + "name": "jupyter_kernel_gateway", + "sha256": "20663cd2c34a5bd74cde09336826f319be3cc48cb329b1ef1de71270a0695e94", + "size": 57411, + "subdir": "linux-64", + "timestamp": 1670546617998, + "version": "2.5.1" + }, + "jupyter_kernel_gateway-2.5.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=5.2.0,<8.0", + "jupyter_core >=4.4.0", + "notebook >=5.7.6,<7.0", + "python >=3.10,<3.11.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "944a3c1933acb2a3708b6ac3b8085f61", + "name": "jupyter_kernel_gateway", + "sha256": "bb400e768c7e85334285fb7240332ea9995b471f6bb0feea3b239a6a820b85c7", + "size": 61168, + "subdir": "linux-64", + "timestamp": 1679567467295, + "version": "2.5.2" + }, + "jupyter_kernel_gateway-2.5.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=5.2.0,<8.0", + "jupyter_core >=4.4.0", + "notebook >=5.7.6,<7.0", + "python >=3.11,<3.12.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0c9329a321c5e71445651828e5c2f2a1", + "name": "jupyter_kernel_gateway", + "sha256": "376694e687b19ef55e40a068dbf451734dd863b2ce7ba889b3bb6bb8eba928a3", + "size": 76086, + "subdir": "linux-64", + "timestamp": 1679567354950, + "version": "2.5.2" + }, + "jupyter_kernel_gateway-2.5.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=5.2.0,<8.0", + "jupyter_core >=4.4.0", + "notebook >=5.7.6,<7.0", + "python >=3.8,<3.9.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5d9ecd1eeb9314a35edf5d2a8e8bb8e6", + "name": "jupyter_kernel_gateway", + "sha256": "6e02d3909edd4dce305e0ea85d6e7a139b1f363378b7ffda05e8b478599eaca7", + "size": 60534, + "subdir": "linux-64", + "timestamp": 1679567392897, + "version": "2.5.2" + }, + "jupyter_kernel_gateway-2.5.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=5.2.0,<8.0", + "jupyter_core >=4.4.0", + "notebook >=5.7.6,<7.0", + "python >=3.9,<3.10.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7180ca4fb33c6045b5d1a7254049660e", + "name": "jupyter_kernel_gateway", + "sha256": "56f7062b5e320cc0e9fb0a3038d389fda0f376b7dd74e2cf57067ba5e83ea47b", + "size": 60625, + "subdir": "linux-64", + "timestamp": 1679567429889, + "version": "2.5.2" + }, + "jupyter_server-1.1.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=2.0.2", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f400bf35e52a19fbf69fec700456d1a2", + "name": "jupyter_server", + "sha256": "ecf90a728e48bfc1ea07e1e093d0a59267a0ff3eef5b20dc47770f0426d5ac65", + "size": 317048, + "subdir": "linux-64", + "timestamp": 1641917277595, + "version": "1.1.3" + }, + "jupyter_server-1.17.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "76d37de4f3d7beb871aabafd56cc47a1", + "name": "jupyter_server", + "sha256": "5f17861bb42ed706689382a5821da77cf65831582edf508dc1916ff0d07251a1", + "size": 381948, + "subdir": "linux-64", + "timestamp": 1654784448888, + "version": "1.17.1" + }, + "jupyter_server-1.17.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c681dfdff034f5a48df8f3075e4f4a3b", + "name": "jupyter_server", + "sha256": "cef61220085771de786766e53999bef04a31c9e4a117c9758ce8e656c8e7e8db", + "size": 380204, + "subdir": "linux-64", + "timestamp": 1654784047544, + "version": "1.17.1" + }, + "jupyter_server-1.17.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "95276dbd6439f7f624ae4b833fce0dcb", + "name": "jupyter_server", + "sha256": "c3df4b2e0ca62a4dea385e94e2a707dd0ce6e8095e6887aa624d6d6ba01c2a9a", + "size": 379608, + "subdir": "linux-64", + "timestamp": 1654784199050, + "version": "1.17.1" + }, + "jupyter_server-1.17.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2a8bd952cf5147e545a6df325c94eae5", + "name": "jupyter_server", + "sha256": "501b92733716742df46e456daa03d11512bfdaaf39e651741c4cc2e726e50a71", + "size": 382017, + "subdir": "linux-64", + "timestamp": 1654784319629, + "version": "1.17.1" + }, + "jupyter_server-1.18.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "61d69d93179f6c291d3f08bd3523887a", + "name": "jupyter_server", + "sha256": "e88cb11a388396f869405e0ddca31d999fa63d0842e180f7f23e6543cabedb77", + "size": 401042, + "subdir": "linux-64", + "timestamp": 1658754619953, + "version": "1.18.1" + }, + "jupyter_server-1.18.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "24755db32512de00089db388b3ad2431", + "name": "jupyter_server", + "sha256": "e67271c6bc79fff2606a8c7a7f3fec73097b25632ea8f397e5177db8b7011298", + "size": 397152, + "subdir": "linux-64", + "timestamp": 1658754546998, + "version": "1.18.1" + }, + "jupyter_server-1.18.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7cbb7bd21145aec31def76d69346f9ce", + "name": "jupyter_server", + "sha256": "ea7ee43354ea0f29372a550efb589e9ca456f9172047e4866a3e341ed696cdf3", + "size": 398083, + "subdir": "linux-64", + "timestamp": 1658754578796, + "version": "1.18.1" + }, + "jupyter_server-1.18.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c1ed5e69b2c3aab9f8380d275c0ddc08", + "name": "jupyter_server", + "sha256": "8fcbeeaa877f479f421c4197483e772c7f35213920af19306520bc27d547016c", + "size": 398384, + "subdir": "linux-64", + "timestamp": 1658754514317, + "version": "1.18.1" + }, + "jupyter_server-1.23.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ad34dede640c1068b2df718e9eb56e7a", + "name": "jupyter_server", + "sha256": "8f74a19dd1efe33431c591688de139ef34c3c7cb7f397d67a835ea7ab71807c1", + "size": 413980, + "subdir": "linux-64", + "timestamp": 1671707770227, + "version": "1.23.4" + }, + "jupyter_server-1.23.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6b7514cb7f8ff51731434f6d4737b16e", + "name": "jupyter_server", + "sha256": "a1468052be80d7578ad5b5d5581425040b085c53ed8af1e17f7e679561222f1e", + "size": 489225, + "subdir": "linux-64", + "timestamp": 1676824961113, + "version": "1.23.4" + }, + "jupyter_server-1.23.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a4405a09211a45e13959f55c2373aef9", + "name": "jupyter_server", + "sha256": "b8c03341276bf543360bd8c8c07078afe81a27389018bf9fc607b368bd2ab8a0", + "size": 411131, + "subdir": "linux-64", + "timestamp": 1671707666926, + "version": "1.23.4" + }, + "jupyter_server-1.23.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0310c282f4db53891f1bbd904eb911ea", + "name": "jupyter_server", + "sha256": "93715877ed17774e2ab8914e61392b47ccbc287ecc0090b9f503652079307428", + "size": 410727, + "subdir": "linux-64", + "timestamp": 1671707735470, + "version": "1.23.4" + }, + "jupyter_server-1.23.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a4beb461f0a60998a090d760b5c6c907", + "name": "jupyter_server", + "sha256": "69ddf26162941898630d1505442660bd16ed08a58112ae1ad7e0829c9d82bb44", + "size": 411564, + "subdir": "linux-64", + "timestamp": 1671707702849, + "version": "1.23.4" + }, + "jupyter_server-1.4.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=2.0.2", + "dataclasses", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff889f9f1364438efdbc71ec47635219", + "name": "jupyter_server", + "sha256": "f3922fe88590e9070988460dcac5d8ed74f797599808aad94fbd4d083a62b27f", + "size": 335058, + "subdir": "linux-64", + "timestamp": 1616083679501, + "version": "1.4.1" + }, + "jupyter_server-1.4.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=2.0.2", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1b1ed9a4cbb81525eea70f09d82872be", + "name": "jupyter_server", + "sha256": "923e6a673a425eec5a01d8aa8b0e2107a586b1f91c87dccfd98a91850e9110c9", + "size": 335081, + "subdir": "linux-64", + "timestamp": 1616084101991, + "version": "1.4.1" + }, + "jupyter_server-1.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=2.0.2", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "005ac5d42835ec8ff92334bf96796b14", + "name": "jupyter_server", + "sha256": "4f8966b78d9f5f1eb337f399176d8b768accd66f3a64679ddc5f78d57f526f2e", + "size": 335580, + "subdir": "linux-64", + "timestamp": 1616083678327, + "version": "1.4.1" + }, + "jupyter_server-1.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=2.0.2", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "96e1e1c49465b4ccaf47a96c103ddaae", + "name": "jupyter_server", + "sha256": "74bb975b593cd999a49b7522c87fe1b7dbd696e73cfbb3ab8ffb8db96898d0df", + "size": 341050, + "subdir": "linux-64", + "timestamp": 1616084108246, + "version": "1.4.1" + }, + "jupyterhub-0.9.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alembic", + "async_generator >=1.8", + "configurable-http-proxy", + "jinja2", + "pamela", + "prometheus_client >=0.0.21", + "pycurl", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-oauth2 >=1.0", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.0", + "traitlets >=4.3.2" + ], + "license": "BSD 3-Clause", + "md5": "3313c3ea935bf78a1f6111fe05bc5ccd", + "name": "jupyterhub", + "sha256": "6f9258419b493a1b76e9d7b747aacfaf93d953d6a887abd1fab71e162923ea0a", + "size": 1683966, + "subdir": "linux-64", + "timestamp": 1541099793519, + "version": "0.9.4" + }, + "jupyterhub-0.9.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alembic", + "async_generator >=1.8", + "configurable-http-proxy", + "jinja2", + "pamela", + "prometheus_client >=0.0.21", + "pycurl", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-oauth2 >=1.0", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.0", + "traitlets >=4.3.2" + ], + "license": "BSD 3-Clause", + "md5": "d5348d9b4a94279f6cd796f809041fab", + "name": "jupyterhub", + "sha256": "cc75649ab4663f91f7d97f3fdf7ff06c3111576baf1316215f6a2ef071e78240", + "size": 1794628, + "subdir": "linux-64", + "timestamp": 1541099831863, + "version": "0.9.4" + }, + "jupyterhub-0.9.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alembic", + "async_generator >=1.8", + "configurable-http-proxy", + "jinja2", + "pamela", + "prometheus_client >=0.0.21", + "pycurl", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-oauth2 >=1.0", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.0", + "traitlets >=4.3.2" + ], + "license": "BSD 3-Clause", + "md5": "198872c9634573a284c253708091a10d", + "name": "jupyterhub", + "sha256": "5d8a5f09b5c3379fc66ee532961a56a804745bf9727046d2e72a4a916a358859", + "size": 1790106, + "subdir": "linux-64", + "timestamp": 1553788360540, + "version": "0.9.5" + }, + "jupyterhub-0.9.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alembic", + "async_generator >=1.8", + "configurable-http-proxy", + "jinja2", + "pamela", + "prometheus_client >=0.0.21", + "pycurl", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-oauth2 >=1.0", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.0", + "traitlets >=4.3.2" + ], + "license": "BSD 3-Clause", + "md5": "53016a423bd1811da2e96e7c2b522cba", + "name": "jupyterhub", + "sha256": "5f36015b4b5da3ddca86f4753fb79dfe3773b3dfdad0c2a113594e9fb67b0cd7", + "size": 1703453, + "subdir": "linux-64", + "timestamp": 1553788331303, + "version": "0.9.5" + }, + "jupyterhub-0.9.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alembic", + "async_generator >=1.8", + "configurable-http-proxy", + "jinja2", + "pamela", + "prometheus_client >=0.0.21", + "pycurl", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-oauth2 >=1.0", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.0", + "traitlets >=4.3.2" + ], + "license": "BSD 3-Clause", + "md5": "89168a56e1f92c97c5f0f2d3a80ba9ff", + "name": "jupyterhub", + "sha256": "eba57104dfa48a768072832615c9755398233a91f7f902307fe1cb46785eac8d", + "size": 1749219, + "subdir": "linux-64", + "timestamp": 1554133925983, + "version": "0.9.6" + }, + "jupyterhub-0.9.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alembic", + "async_generator >=1.8", + "configurable-http-proxy", + "jinja2", + "pamela", + "prometheus_client >=0.0.21", + "pycurl", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-oauth2 >=1.0", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.0", + "traitlets >=4.3.2" + ], + "license": "BSD 3-Clause", + "md5": "56a94e2687d41e8aacf414f785b59f67", + "name": "jupyterhub", + "sha256": "85fb48f576d017650ac2ccf4905347b23d12e45f79f83bb5196bde4924c7a427", + "size": 1795135, + "subdir": "linux-64", + "timestamp": 1554133925484, + "version": "0.9.6" + }, + "jupyterhub-1.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alembic", + "async_generator >=1.8", + "certipy >=0.1.2", + "configurable-http-proxy", + "entrypoints", + "jinja2", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.0.21", + "pycurl", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.0", + "traitlets >=4.3.2" + ], + "license": "BSD 3-Clause", + "md5": "d8323c33c57c793d4f2473c4cbb06dac", + "name": "jupyterhub", + "sha256": "e6f9cebecfdbd5c83778a814bf85df8ecd07eaff5d86f7ec5977b6be4f337ced", + "size": 1836598, + "subdir": "linux-64", + "timestamp": 1569510028748, + "version": "1.0.0" + }, + "jupyterhub-1.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alembic", + "async_generator >=1.8", + "certipy >=0.1.2", + "configurable-http-proxy", + "entrypoints", + "jinja2", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.0.21", + "pycurl", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.0", + "traitlets >=4.3.2" + ], + "license": "BSD 3-Clause", + "md5": "6bbfccdefdb65d4969103077db7f2908", + "name": "jupyterhub", + "sha256": "f104e876c7bc4aefc22f775fa95701f4fcd46d002b883cd1702b5c4436dd6e15", + "size": 1888750, + "subdir": "linux-64", + "timestamp": 1569510034643, + "version": "1.0.0" + }, + "jupyterhub-1.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "alembic", + "async_generator >=1.8", + "certipy >=0.1.2", + "configurable-http-proxy", + "entrypoints", + "jinja2", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.0.21", + "pycurl", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.0", + "traitlets >=4.3.2" + ], + "license": "BSD 3-Clause", + "md5": "ce32198f05102114e6f7a867b08bc664", + "name": "jupyterhub", + "sha256": "84412ec9bcf77cdebf29caa3eeda08f24052cac9f887b5c29116fd12dde31081", + "size": 1863651, + "subdir": "linux-64", + "timestamp": 1574238667121, + "version": "1.0.0" + }, + "jupyterhub-1.3.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "configurable-http-proxy >=4", + "jupyterhub-base 1.3.0 py36h06a4308_1", + "nodejs >=12", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "703d384baa533afa73b462e722587f62", + "name": "jupyterhub", + "sha256": "f089972aafcf32f7b25cf21a0025f24c4ad42504c1979e8cdb24c28b313ec295", + "size": 12301, + "subdir": "linux-64", + "timestamp": 1615900885200, + "version": "1.3.0" + }, + "jupyterhub-1.3.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "configurable-http-proxy >=4", + "jupyterhub-base 1.3.0 py37h06a4308_1", + "nodejs >=12", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7bd4279e40b4e343f82801defe068813", + "name": "jupyterhub", + "sha256": "e3bd74ce8f16ff490c47b02abaada715bf5adde056a550b8c254ab55f7fda753", + "size": 12306, + "subdir": "linux-64", + "timestamp": 1615899025551, + "version": "1.3.0" + }, + "jupyterhub-1.3.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "configurable-http-proxy >=4", + "jupyterhub-base 1.3.0 py38h06a4308_1", + "nodejs >=12", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7e74912490a8a6dc13817b9be3327d8f", + "name": "jupyterhub", + "sha256": "30f87acdb4a7f7fbc6d8c8f97b1659c32c2f7061716d9f668f1bf34a3e5de057", + "size": 12319, + "subdir": "linux-64", + "timestamp": 1615900874023, + "version": "1.3.0" + }, + "jupyterhub-1.3.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "configurable-http-proxy >=4", + "jupyterhub-base 1.3.0 py39h06a4308_1", + "nodejs >=12", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "de5a0668c749709e77c2c121a333b781", + "name": "jupyterhub", + "sha256": "29913fff2452a3a83accc22dc7182d0b904f889b009b0f6decab49f8549af9d3", + "size": 12321, + "subdir": "linux-64", + "timestamp": 1615900875779, + "version": "1.3.0" + }, + "jupyterhub-1.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "entrypoints", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "18269a61e8491f09d0a2627e5658d894", + "name": "jupyterhub", + "sha256": "7478627082d70182c6ccf6d875d1863125a40be87f7ffbf9f27556bbfcbd95a4", + "size": 1982261, + "subdir": "linux-64", + "timestamp": 1622645507544, + "version": "1.4.1" + }, + "jupyterhub-1.4.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "entrypoints", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d1a38b791799f65988455c7fc6befbbe", + "name": "jupyterhub", + "sha256": "6b0b09c0597a045c25424f953f3a85997b9636af9ba303ef2878f312d512db9d", + "size": 2026059, + "subdir": "linux-64", + "timestamp": 1641903286783, + "version": "1.4.2" + }, + "jupyterhub-1.4.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "entrypoints", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ae905d75f727211a95accac6f71fce99", + "name": "jupyterhub", + "sha256": "265d115c42e314549fa9c40c18be5bba6a13a0f404171bfed74c20d97dab98fe", + "size": 1999798, + "subdir": "linux-64", + "timestamp": 1626856531280, + "version": "1.4.2" + }, + "jupyterhub-1.4.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "entrypoints", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "32f71262bdf95dd42bd110e29361e52a", + "name": "jupyterhub", + "sha256": "114c0e5a6c6dfe15f22d34eacc5d125cdc96b736c5149cbb501bddbc33fa734b", + "size": 1982680, + "subdir": "linux-64", + "timestamp": 1626856695303, + "version": "1.4.2" + }, + "jupyterhub-1.4.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "entrypoints", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38ec94c7614cca0999236707da78a309", + "name": "jupyterhub", + "sha256": "0a8036177715f764f3d872f08074acdb466f54fe29a2ee5e997c1f7018f17db4", + "size": 1992929, + "subdir": "linux-64", + "timestamp": 1626856646700, + "version": "1.4.2" + }, + "jupyterhub-1.4.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "entrypoints", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "be140c114d9e8f741fc22518858668b6", + "name": "jupyterhub", + "sha256": "56f126fe9fd45d2ba5c96cc5b75186a4f1ee9be1b7a0c5020241fad03860644c", + "size": 1994715, + "subdir": "linux-64", + "timestamp": 1626856601534, + "version": "1.4.2" + }, + "jupyterhub-3.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "packaging", + "pamela", + "prometheus_client >=0.4.0", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2fa51532600efbc94325837574310dc0", + "name": "jupyterhub", + "sha256": "3384f457a83b11dfb95b907d6005eccb817a1bedbddf7dcaa228665b7b97a8f7", + "size": 2208395, + "subdir": "linux-64", + "timestamp": 1671135622360, + "version": "3.1.0" + }, + "jupyterhub-3.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "importlib_metadata >=3.6", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "packaging", + "pamela", + "prometheus_client >=0.4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "520fb2fd6728baffd1f06a5090397548", + "name": "jupyterhub", + "sha256": "0252f950a4085cb48bd9f6b657d4c6675c9a77618c326d617351b7935bb19b77", + "size": 2205669, + "subdir": "linux-64", + "timestamp": 1671135579182, + "version": "3.1.0" + }, + "jupyterhub-3.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "importlib_metadata >=3.6", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "packaging", + "pamela", + "prometheus_client >=0.4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "36715bb2747751d668b96d492a3a724d", + "name": "jupyterhub", + "sha256": "1321bb6d8929fa8f6061f707fef52812b3d64f9ed7861f036312d7b18e2d95d0", + "size": 2209420, + "subdir": "linux-64", + "timestamp": 1671135533292, + "version": "3.1.0" + }, + "jupyterhub-3.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "importlib_metadata >=3.6", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "packaging", + "pamela", + "prometheus_client >=0.4.0", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2915abca2f4dfcb3e1c856a4e1476044", + "name": "jupyterhub", + "sha256": "fae51252a8f1d6fa5874c2b11a579b03f177e415bf05a05504b9fda5d9b5a09b", + "size": 2202853, + "subdir": "linux-64", + "timestamp": 1671135488126, + "version": "3.1.0" + }, + "jupyterhub-3.1.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "jinja2 >=2.11.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "packaging", + "pamela", + "prometheus_client >=0.4.0", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dbad21d7bcce8b082479ef1ca6f69ae4", + "name": "jupyterhub", + "sha256": "e5da5c76408eeeba5f5bac390707f8eb18856b1ce26963f6444065a1e878f987", + "size": 2143380, + "subdir": "linux-64", + "timestamp": 1675293528136, + "version": "3.1.1" + }, + "jupyterhub-3.1.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "jinja2 >=2.11.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "packaging", + "pamela", + "prometheus_client >=0.4.0", + "python >=3.11,<3.12.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4993d39b869731133b090fee5224beef", + "name": "jupyterhub", + "sha256": "1b93cd3b6588881c31a641c1bfd4798d66ede12ed9f91ad37dfb5845e88da03f", + "size": 2387979, + "subdir": "linux-64", + "timestamp": 1676844403832, + "version": "3.1.1" + }, + "jupyterhub-3.1.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "importlib_metadata >=3.6", + "jinja2 >=2.11.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "packaging", + "pamela", + "prometheus_client >=0.4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d00dbb1c00193c96f368db2054ccb428", + "name": "jupyterhub", + "sha256": "8f7db92065f11a45c0bc45e2333fafe2cf4ae364f603cf0d8ab877a824fdfeea", + "size": 2142361, + "subdir": "linux-64", + "timestamp": 1675293481209, + "version": "3.1.1" + }, + "jupyterhub-3.1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "importlib_metadata >=3.6", + "jinja2 >=2.11.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "packaging", + "pamela", + "prometheus_client >=0.4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d88b461032119068e5c663a2d829bdf4", + "name": "jupyterhub", + "sha256": "f0c7930c383e01970f6436756efa85474e19b8b19e047c9cad67e75c8addcc0b", + "size": 2143885, + "subdir": "linux-64", + "timestamp": 1675293611477, + "version": "3.1.1" + }, + "jupyterhub-3.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "importlib_metadata >=3.6", + "jinja2 >=2.11.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "packaging", + "pamela", + "prometheus_client >=0.4.0", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "41c8df372b4d64b10a3e2d2e76648e3a", + "name": "jupyterhub", + "sha256": "66fcfd3458b85b018187180777e7351483f860112b0980edc2782adfe4e93ac9", + "size": 2159654, + "subdir": "linux-64", + "timestamp": 1675293569907, + "version": "3.1.1" + }, + "jupyterhub-base-1.3.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "alembic", + "async_generator >=1.9", + "certipy >=0.1.2", + "entrypoints", + "jinja2 >=2.11.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "md5": "464888412c343ccc004d43c0d3a6f000", + "name": "jupyterhub-base", + "sha256": "932d4e64b6b42c50dba167c0dc9350e672ee5f0fdf9a0028dae8fa5ee3f915c6", + "size": 2013163, + "subdir": "linux-64", + "timestamp": 1615900875567, + "version": "1.3.0" + }, + "jupyterhub-base-1.3.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "alembic", + "async_generator >=1.9", + "certipy >=0.1.2", + "entrypoints", + "jinja2 >=2.11.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "md5": "54129398423720e9df854ce4b1037b7d", + "name": "jupyterhub-base", + "sha256": "fff6ddb8b9ed612174e9ffdc64a63e5e725727aaa70331e567cf4db35865e40c", + "size": 1949903, + "subdir": "linux-64", + "timestamp": 1615899016369, + "version": "1.3.0" + }, + "jupyterhub-base-1.3.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "alembic", + "async_generator >=1.9", + "certipy >=0.1.2", + "entrypoints", + "jinja2 >=2.11.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "md5": "4ffd68cb8f7efb074d38d0ad13024eec", + "name": "jupyterhub-base", + "sha256": "9b35698dd60df6b6b6a84df7a9eaba8d3359f4d03a58cab360c7f2ae60eb87ca", + "size": 1996996, + "subdir": "linux-64", + "timestamp": 1615900865293, + "version": "1.3.0" + }, + "jupyterhub-base-1.3.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "alembic", + "async_generator >=1.9", + "certipy >=0.1.2", + "entrypoints", + "jinja2 >=2.11.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "md5": "99eb5654a0ee8e36d5ce0303f939e9e7", + "name": "jupyterhub-base", + "sha256": "16c053b9da267df28be1e3bcd3c6ac18c5738a1372212092e35f0f3b542de326", + "size": 1998526, + "subdir": "linux-64", + "timestamp": 1615900866032, + "version": "1.3.0" + }, + "jupyterhub-singleuser-1.3.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "jupyterhub-base 1.3.0 py36h06a4308_1", + "notebook >=4", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "249e1b17554b399e30c6786a66cc1c7b", + "name": "jupyterhub-singleuser", + "sha256": "ef0407858b722085b6c9cab4163d4ddd9a5f941d054b451abf4f558d109f7a9c", + "size": 12290, + "subdir": "linux-64", + "timestamp": 1615900892038, + "version": "1.3.0" + }, + "jupyterhub-singleuser-1.3.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "jupyterhub-base 1.3.0 py37h06a4308_1", + "notebook >=4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "edb7e048fc6547f2a92393063664280e", + "name": "jupyterhub-singleuser", + "sha256": "90de53483dd9e100342d3a89b7f6d7b9678c431b4e1109f898c078d79905eacc", + "size": 12294, + "subdir": "linux-64", + "timestamp": 1615899032777, + "version": "1.3.0" + }, + "jupyterhub-singleuser-1.3.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "jupyterhub-base 1.3.0 py38h06a4308_1", + "notebook >=4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c5ce81cf0bdf974eb1f29c21c8391e68", + "name": "jupyterhub-singleuser", + "sha256": "80ca26feccdc8a730f9da85eae7e39640427c933361e2f7dd166fead91706701", + "size": 12301, + "subdir": "linux-64", + "timestamp": 1615900880611, + "version": "1.3.0" + }, + "jupyterhub-singleuser-1.3.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "jupyterhub-base 1.3.0 py39h06a4308_1", + "notebook >=4", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "bfd52b062b8addadf1c845cebe65aa93", + "name": "jupyterhub-singleuser", + "sha256": "ec905597fdc3140f4e93e61d2dd614f44553cfa40b48d58642a4b8ff0e007409", + "size": 12317, + "subdir": "linux-64", + "timestamp": 1615900882805, + "version": "1.3.0" + }, + "jupyterlab-0.27.0-py27h42ebfef_2.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27h42ebfef_2", + "build_number": 2, + "depends": [ + "jupyterlab_launcher >=0.4.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "md5": "90631f932036a96ceed18b2c6fa49195", + "name": "jupyterlab", + "sha256": "204fe0168b982f4d111d331c57721f9aa834bc8852517a6f1395bbb4a10a53e7", + "size": 3256588, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1505691039765, + "type": "app", + "version": "0.27.0" + }, + "jupyterlab-0.27.0-py35h29561ed_2.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35h29561ed_2", + "build_number": 2, + "depends": [ + "jupyterlab_launcher >=0.4.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "md5": "85ed1f17db62d5b5e9c67185e49de126", + "name": "jupyterlab", + "sha256": "e1af0cfd8a62ece8b5e3fa70d511b5cf7e28edc1f715e1296125ba3fed2701bd", + "size": 3257743, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1505691060028, + "type": "app", + "version": "0.27.0" + }, + "jupyterlab-0.27.0-py36h86377d0_2.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36h86377d0_2", + "build_number": 2, + "depends": [ + "jupyterlab_launcher >=0.4.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "md5": "7d4141eeb036c42506758d331a0d7a0e", + "name": "jupyterlab", + "sha256": "dca8e3fb22742b3d502f067fd476bab11fe1d46879cf035516a7f9fd3bd72917", + "size": 3254633, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1505691080678, + "type": "app", + "version": "0.27.0" + }, + "jupyterlab-0.30.4-py27_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.6.0,<0.7.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "90f508eafd015a60af998d97dfc0f9cb", + "name": "jupyterlab", + "sha256": "4f0eb634a249563d83e7cc0aaa39f99e43efce44f2e76bdb40392f084483fa43", + "size": 7541418, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1512661433769, + "type": "app", + "version": "0.30.4" + }, + "jupyterlab-0.30.4-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.6.0,<0.7.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "da4d6e7c6c689f7b3ea7c576845f63a0", + "name": "jupyterlab", + "sha256": "5f87a13be4016bf1ef3e7ead86592ce6bfe461628dcb6f5c595d33cf4b2c6c73", + "size": 7521775, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1512661427206, + "type": "app", + "version": "0.30.4" + }, + "jupyterlab-0.30.4-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.6.0,<0.7.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "943b3c21f4237c9ff3b68842d0cf9832", + "name": "jupyterlab", + "sha256": "587cf605e0e1986df757e29ac8fea17abaf05311628c41af81e68e2a77c56b5c", + "size": 7491776, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1512661486641, + "type": "app", + "version": "0.30.4" + }, + "jupyterlab-0.30.5-py27_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.6.0,<0.7.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "19aa9252f412e9ea8f4b64f3a9cc595d", + "name": "jupyterlab", + "sha256": "fde0edf24204b0f1099326ae6a36d54184a7ecd061724f0a41d38ff380a9e3b6", + "size": 7541246, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1512748510835, + "type": "app", + "version": "0.30.5" + }, + "jupyterlab-0.30.5-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.6.0,<0.7.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "308fbbb13a09ccbcf11eb9bffef1f5da", + "name": "jupyterlab", + "sha256": "2e55a746a41af6846904b8dd4f365c0a915e047c0988ae8c6a075cf5de3dbe66", + "size": 7521969, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1512748519990, + "type": "app", + "version": "0.30.5" + }, + "jupyterlab-0.30.5-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.6.0,<0.7.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "56343f2fcd7b5be9814b5da5b9d4199c", + "name": "jupyterlab", + "sha256": "6b5934885c4e62b619147b9b16eb85b7c78007ed0c2a1099d3b28fad3ecb0f3f", + "size": 7491680, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1512748504472, + "type": "app", + "version": "0.30.5" + }, + "jupyterlab-0.30.6-py27h5233db4_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27h5233db4_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.6.0,<0.7.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f8496824c6dcb13dc8d9b4073477a559", + "name": "jupyterlab", + "sha256": "2eb89ec4578a855b7b0006e74605e733c7ca589d7fc84b08592bf4909567d1b7", + "size": 7542594, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1513007702360, + "type": "app", + "version": "0.30.6" + }, + "jupyterlab-0.30.6-py35h2f9c1c0_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35h2f9c1c0_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.6.0,<0.7.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2578771aadf669dfe2a4c10d6ac4a63f", + "name": "jupyterlab", + "sha256": "c01d6ee4848b154a0d013d11d264df48895904bedcaa1651cf80daaabbece3e4", + "size": 7522692, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1513007738216, + "type": "app", + "version": "0.30.6" + }, + "jupyterlab-0.30.6-py36h2f9c1c0_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36h2f9c1c0_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.6.0,<0.7.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f638114060074368714b39d3178c10d1", + "name": "jupyterlab", + "sha256": "522f8a0b41e4171e4e3fe88d617c1bbb81074877151cc7dd9b9934e0f225303b", + "size": 7492651, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1513007762094, + "type": "app", + "version": "0.30.6" + }, + "jupyterlab-0.31.0-py27_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9615da8f953e8c6e890c44c6a485289d", + "name": "jupyterlab", + "sha256": "125a163e675b22bd8de3fbe9339fb9958213c710d53b409a61903fada5257814", + "size": 3539493, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1515950051675, + "type": "app", + "version": "0.31.0" + }, + "jupyterlab-0.31.0-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6d1797e4da607d78ac4dd045eb76e8e8", + "name": "jupyterlab", + "sha256": "a909d329440bb0fb91fb6e4a87cf1e734510f96501fbc752d4bfb72a35ae95b6", + "size": 3545419, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1515950062650, + "type": "app", + "version": "0.31.0" + }, + "jupyterlab-0.31.0-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7c0d9f7104895e366004fee66c197041", + "name": "jupyterlab", + "sha256": "829d0becc931c2d76fc28df0ca113bf6419cd516d30196a611c25af1596e477d", + "size": 3544119, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1515950039360, + "type": "app", + "version": "0.31.0" + }, + "jupyterlab-0.31.1-py27_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "71cfb0ba43c8d3da5baa55cc59f2349f", + "name": "jupyterlab", + "sha256": "9ea0dca9a01ca5fb0476e25e56b53240774024bba263a8c2aebd0fa56b349a2c", + "size": 8860174, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1515951260764, + "type": "app", + "version": "0.31.1" + }, + "jupyterlab-0.31.1-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "58bf3683428d2b197bfbe1753d11106c", + "name": "jupyterlab", + "sha256": "6887de2d6d323c362bb5ed659fe398f6fa8b5e8906c6cd51465fadea456bde41", + "size": 8865766, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1515951301584, + "type": "app", + "version": "0.31.1" + }, + "jupyterlab-0.31.1-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eecf0627e885722c19f43be95035dccb", + "name": "jupyterlab", + "sha256": "96bdc8b38fea995bccdcbc0585de92c9282b5b26b9f4d1c3ebeb89d7d0796b89", + "size": 8866889, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1515951221467, + "type": "app", + "version": "0.31.1" + }, + "jupyterlab-0.31.10-py27_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "429d352e7bccc3bb5d37c47715f6bbdc", + "name": "jupyterlab", + "sha256": "118ca1d1cb4998d859ab9b26988599935f56a31bf287e3b83c39a9cfd52bd9c2", + "size": 8925853, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1519920180924, + "type": "app", + "version": "0.31.10" + }, + "jupyterlab-0.31.10-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "718d71382ce274c96760f81075384aa9", + "name": "jupyterlab", + "sha256": "6cbfd5c46efc9f7743ff08ac932860f0c28c99936117c7820b4cb2cfc5166793", + "size": 8939642, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1519920306726, + "type": "app", + "version": "0.31.10" + }, + "jupyterlab-0.31.10-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eb2de4500cca24b1fad40e3ebb849f99", + "name": "jupyterlab", + "sha256": "f1c157943d50375a91951b0e3c09bb417462bd2f29b9bca54b6e2ffe56a1f7a7", + "size": 8947993, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1519920322013, + "type": "app", + "version": "0.31.10" + }, + "jupyterlab-0.31.11-py27_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "014a78b04ac777f6037801cd63b6e390", + "name": "jupyterlab", + "sha256": "e5397514959b4956aa778517b07b988494c7847817d6ccbd6198b15e109ce9b4", + "size": 8926411, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1520521453016, + "type": "app", + "version": "0.31.11" + }, + "jupyterlab-0.31.11-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f4eb59c578c27e0e75f5692a5ec0206c", + "name": "jupyterlab", + "sha256": "51a74a801459b967f9b136d93c7ae91b6eef4ea8049071b8f108d9ee28330f7d", + "size": 8939297, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1520521456795, + "type": "app", + "version": "0.31.11" + }, + "jupyterlab-0.31.11-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3064019702aae4205214999eb47ee82c", + "name": "jupyterlab", + "sha256": "7f7e1f7478bd87369f22bcb818f37a50af6da4fd759ff8a5dd685bc7d2f69bcb", + "size": 8950203, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1520521613183, + "type": "app", + "version": "0.31.11" + }, + "jupyterlab-0.31.12-py27_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "faf0bac2c1e87f692f423fe48f9b5d41", + "name": "jupyterlab", + "sha256": "748c6f175b9122d2120079658e67e085e39a16991d991e58b6bef35081518758", + "size": 8938762, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1520522807685, + "type": "app", + "version": "0.31.12" + }, + "jupyterlab-0.31.12-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e5d6e3cd049e318adafd0c9b46820ac5", + "name": "jupyterlab", + "sha256": "e08d27f06df56a13a06a34c23a402c3f677d4676b31e15c11f646c834f0bf4bc", + "size": 8952431, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1520522816532, + "type": "app", + "version": "0.31.12" + }, + "jupyterlab-0.31.12-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "309582eb98b5b8f2a463686d70fad7c1", + "name": "jupyterlab", + "sha256": "9425d72d75bfa334e5e3bd4baac0ef600ddfb98f3833c5564a3aa325a6da0b1d", + "size": 8960687, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1520522818492, + "type": "app", + "version": "0.31.12" + }, + "jupyterlab-0.31.2-py27_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "84d1a56f446ceb64ad124905d8128776", + "name": "jupyterlab", + "sha256": "ba986cbd17d6cefe98fe2d6d2e9c38526cb1ae41933718176a0b37d19ba6921e", + "size": 8922041, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1517330752002, + "type": "app", + "version": "0.31.2" + }, + "jupyterlab-0.31.2-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1df7b01917c024d85aa42baf439e36fa", + "name": "jupyterlab", + "sha256": "48b6af4e55069700e28a6bb071d9b46ad8b941f7ff62541d70d1eed5a5e93edb", + "size": 8938381, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1517330741099, + "type": "app", + "version": "0.31.2" + }, + "jupyterlab-0.31.2-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "82f7fdf61f7121da3ca9aec64f2806e8", + "name": "jupyterlab", + "sha256": "252b10e21120baf7d9e7117ce1bc289687d156c65ff9046ba607f83592358cb1", + "size": 8942252, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1517330738162, + "type": "app", + "version": "0.31.2" + }, + "jupyterlab-0.31.3-py27_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d156b4a136dc54566f435e04165da463", + "name": "jupyterlab", + "sha256": "01892f32a90d6ea3c2f58e97f62c0067365fdaf288bf58a55688ede09f9f649a", + "size": 8914964, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1517937285085, + "type": "app", + "version": "0.31.3" + }, + "jupyterlab-0.31.3-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "82449d625ec092f53043760b7cfba619", + "name": "jupyterlab", + "sha256": "ab2fd18505c53c33a453cf99665c9406550dc09d3091872f3b9f76e251377d83", + "size": 8930566, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1517937352628, + "type": "app", + "version": "0.31.3" + }, + "jupyterlab-0.31.3-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fa55794ed4c390e8a01d162be41c91ba", + "name": "jupyterlab", + "sha256": "8318c40ddf2111481443de56f32948d97b5b2d58a30a09abb4ae66e7d12a9c23", + "size": 8942097, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1517937351015, + "type": "app", + "version": "0.31.3" + }, + "jupyterlab-0.31.4-py27_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a0ed548dba050d588e95344c58e83259", + "name": "jupyterlab", + "sha256": "545dbad0f8a923d279053ef56de2ab852d7d9e58626669dc3cea60e6b02ff5ed", + "size": 8916561, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1517940187348, + "type": "app", + "version": "0.31.4" + }, + "jupyterlab-0.31.4-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f1864a83ed877284c531fb061628bc13", + "name": "jupyterlab", + "sha256": "7637801677c1ce14e339ef2ef76844a518d4e5f85cb209956ab73fc2aecb284b", + "size": 8933452, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1517940253876, + "type": "app", + "version": "0.31.4" + }, + "jupyterlab-0.31.4-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "522fef57e28b3b517e3272d0ad4ea71f", + "name": "jupyterlab", + "sha256": "18013fa7b1185077c5e490a42b312f54192144e3f5cf4da70ea9762f5bf569cb", + "size": 8939699, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1517940203029, + "type": "app", + "version": "0.31.4" + }, + "jupyterlab-0.31.5-py27_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "792781db8fccba5b5ffabd62ed893749", + "name": "jupyterlab", + "sha256": "9db6328fecfe823965c5a2d50d205d45890b44ae15ba61aa59d7d570e0b6fd75", + "size": 8914941, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1518196757728, + "type": "app", + "version": "0.31.5" + }, + "jupyterlab-0.31.5-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b541983fcefaaa9f3ff3179f9f203030", + "name": "jupyterlab", + "sha256": "38dd974ecde81bf69e7f74a31b040cb46f6d19a6e297ae53bfe044aa63a50a26", + "size": 8933101, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1518196834610, + "type": "app", + "version": "0.31.5" + }, + "jupyterlab-0.31.5-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2f32a91a9cb6cdbd9c249a47dd17293d", + "name": "jupyterlab", + "sha256": "f36bcfd12a5bead33dbbe3fce936e94c04314b8b7c1e95aab1f6df73573f5b32", + "size": 8941747, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1518196831334, + "type": "app", + "version": "0.31.5" + }, + "jupyterlab-0.31.6-py27_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1e2401f8a9096edf61e373b48a83f814", + "name": "jupyterlab", + "sha256": "8db563599303b8d44576c1f5e2062a1d91f19bcb6193d6ddc7407b17594c8799", + "size": 8912035, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1518800639943, + "type": "app", + "version": "0.31.6" + }, + "jupyterlab-0.31.6-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4b46cde5eb750c574e3f12ce45617f0b", + "name": "jupyterlab", + "sha256": "2838e793e823571c729507890108a31b01505a17ebe348f3b81658ed587470e3", + "size": 8928655, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1518800665355, + "type": "app", + "version": "0.31.6" + }, + "jupyterlab-0.31.6-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f8bc66f7b914764c2af34c66bbd2109b", + "name": "jupyterlab", + "sha256": "1e57c8d32cb7ce65003606074c416b3784d2657161d3421475e8a7fb75025f22", + "size": 8936266, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1518800667349, + "type": "app", + "version": "0.31.6" + }, + "jupyterlab-0.31.8-py27_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3537bb7332768fc84b7bb2ab59ec910a", + "name": "jupyterlab", + "sha256": "8d7c4c7f4e7b0544025e038f720c7f004f277d0856a2a551bc075e9edf9b0a73", + "size": 8912335, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1518802021283, + "type": "app", + "version": "0.31.8" + }, + "jupyterlab-0.31.8-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7d114b131ce7aec47cc096ea21a1fb68", + "name": "jupyterlab", + "sha256": "62fa422988fc69903c2cad64360a3c9f87d938b885a7f2a6d08defec81f059dd", + "size": 8928519, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1518802065738, + "type": "app", + "version": "0.31.8" + }, + "jupyterlab-0.31.8-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "890647208fab6011fb8c918a271c7a65", + "name": "jupyterlab", + "sha256": "68e16e888ee92d86b78756529ffd0840da386c1589ff8c0dac7f9a833ebb5fcb", + "size": 8936580, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1518802055805, + "type": "app", + "version": "0.31.8" + }, + "jupyterlab-0.31.9-py27_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c5c8e0b5a24ea516bc971742e1ba524d", + "name": "jupyterlab", + "sha256": "dd2ba592d28f4d82b92f1fbfd076c28a1e291e1d91aab85d3de34d539c1325e6", + "size": 8917245, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1519832193936, + "type": "app", + "version": "0.31.9" + }, + "jupyterlab-0.31.9-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dbe4b0c4205011e0ba403c032040afc9", + "name": "jupyterlab", + "sha256": "89d35975a4784f48ce4eec0e5a49c7111d1d77fd58aadac53dcc0f9693f4599f", + "size": 8932405, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1519832223468, + "type": "app", + "version": "0.31.9" + }, + "jupyterlab-0.31.9-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "485a3c22800bbc9ad1798349c70c5c30", + "name": "jupyterlab", + "sha256": "e3839a2fa8363fb378cccfb1e4bd8cc9faa045c0e9b1897c5529a0d5e170304c", + "size": 8941599, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1519832815809, + "type": "app", + "version": "0.31.9" + }, + "jupyterlab-0.32.0-py27_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5efbdae335b9e13619f37b040edd728f", + "name": "jupyterlab", + "sha256": "2ad9188dc03232ab8944681b465e00371586f8d439a0ad2a0590324023de7c99", + "size": 10397446, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1524231812960, + "type": "app", + "version": "0.32.0" + }, + "jupyterlab-0.32.0-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f067488e4b3ad5d13b478627d15dc21f", + "name": "jupyterlab", + "sha256": "c596c82ebe8b884fc02882384cfaffcb1ecd0215d726867c4559548205f2cc81", + "size": 10409786, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1524231938986, + "type": "app", + "version": "0.32.0" + }, + "jupyterlab-0.32.0-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0d40c0a96f1bc1f21528ba2ebca940d3", + "name": "jupyterlab", + "sha256": "9a98c6cf17f5e038fe53498f20939a594600a3b604a7dbef0c8c5b505976726d", + "size": 10415666, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1524231943681, + "type": "app", + "version": "0.32.0" + }, + "jupyterlab-0.32.1-py27_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6941676a6bfba134822dff9f63925503", + "name": "jupyterlab", + "sha256": "ac79f253b0a795758918538f39cd492470757a37132c32003be9c63ab831664c", + "size": 10476461, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1525117196419, + "type": "app", + "version": "0.32.1" + }, + "jupyterlab-0.32.1-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1d17969dd718913eaa41679b7cc0a112", + "name": "jupyterlab", + "sha256": "a55666f9ef444f42eb36d29a00bbd0f4325f0320191a167a6f651a2ba0f13b41", + "size": 10488854, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1525117222090, + "type": "app", + "version": "0.32.1" + }, + "jupyterlab-0.32.1-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bc74f70e63abb489b879febc60d3bcdc", + "name": "jupyterlab", + "sha256": "dc871373af9f9dadd67105f8101c80985b8dcee4eea9bd5af018902da8cc5866", + "size": 10498482, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1525117205771, + "type": "app", + "version": "0.32.1" + }, + "jupyterlab-0.32.1-py37_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.11.0,<0.12.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bb42a53cc6d5b3cf55cb7571ac36341a", + "name": "jupyterlab", + "sha256": "fe979d5565f870d204e8d8180cce751d7dba067af62ffbd22b2ef3ef743341c3", + "size": 10496256, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1530734856746, + "type": "app", + "version": "0.32.1" + }, + "jupyterlab-0.33.11-py27_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "futures", + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b6e242ae559d6d63b7b546ee0a2f20e1", + "name": "jupyterlab", + "sha256": "cac065c3a97905969fcee20e8203f5470759ff34798d47f2016b84f06c7f8acf", + "size": 10441218, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1534268331242, + "type": "app", + "version": "0.33.11" + }, + "jupyterlab-0.33.11-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9d963b897b463cfee9a7e69489130973", + "name": "jupyterlab", + "sha256": "665c3f0b63257c55c763f4ee4f2cd3fe9506930fca6db0a62eb1552c778694ac", + "size": 10473395, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1534268353242, + "type": "app", + "version": "0.33.11" + }, + "jupyterlab-0.33.11-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3cda8df7b1838a0a841593b605017bea", + "name": "jupyterlab", + "sha256": "8b32f0f3ceaad8177f034e4ade72315cee650a08cf85a417df26baa6406ae3d6", + "size": 10487449, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1534266395710, + "type": "app", + "version": "0.33.11" + }, + "jupyterlab-0.33.11-py37_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f3f6afb21d1d6865560b67bc27ac52c6", + "name": "jupyterlab", + "sha256": "2ae0b8908c7ef40470c1c45e871ebbc6e41293116cea343b62da7f7b9451a37b", + "size": 10489615, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1534266466194, + "type": "app", + "version": "0.33.11" + }, + "jupyterlab-0.33.4-py27_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "futures", + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "90fbbd13c9f20d84373ec65d767fa433", + "name": "jupyterlab", + "sha256": "bc5b434042dfb723e91b671a3d6d9adc7fd7b03c5a18fbea5a3f7d045ee9ad42", + "size": 10445694, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1532985946522, + "type": "app", + "version": "0.33.4" + }, + "jupyterlab-0.33.4-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3de6a1f06a41f7063e00755414c7eb48", + "name": "jupyterlab", + "sha256": "e03f417c4d3cbbeb36056a8a5c928ca7c74b59d0815fcc9dc56a3fcfe3cb5649", + "size": 10474279, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1532986019727, + "type": "app", + "version": "0.33.4" + }, + "jupyterlab-0.33.4-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7cb7a87aba7a15baac9d55555eafaf33", + "name": "jupyterlab", + "sha256": "b89e05d59c9b16eb6af2e8ae2d15e8275321f3e5d8a3174e4d2b2502fd7384d2", + "size": 10489856, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1532985876120, + "type": "app", + "version": "0.33.4" + }, + "jupyterlab-0.33.4-py37_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4dc86d0802c34957f433b1a26cf8845d", + "name": "jupyterlab", + "sha256": "91d92073856d730fd7139248dda3d85677f2e631146a6eeceab7e7ebc9adef33", + "size": 10487630, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1532986002212, + "type": "app", + "version": "0.33.4" + }, + "jupyterlab-0.33.8-py27_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "futures", + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "98073594616b453f423144b81398f4ca", + "name": "jupyterlab", + "sha256": "ad0250ba81d59df35b23a08e539b83ace0213afd2461cf12cfb5f4a3b2606270", + "size": 10442912, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1533752021561, + "type": "app", + "version": "0.33.8" + }, + "jupyterlab-0.33.8-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "47e02266947c154ab9451c170bb395dc", + "name": "jupyterlab", + "sha256": "61e58d5311fc2799ec64e2566a1e3d684f190e25cf0a3866cedb7d872b8683d2", + "size": 10472384, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1533752082681, + "type": "app", + "version": "0.33.8" + }, + "jupyterlab-0.33.8-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a1e7f9ea780244d852b8a1648a338299", + "name": "jupyterlab", + "sha256": "1155abb101db3504656cc60d4d80e523f50de5beef31597449896d909e9e176b", + "size": 10489202, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1533752011446, + "type": "app", + "version": "0.33.8" + }, + "jupyterlab-0.33.8-py37_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0bf708c2d247474c10e9eb9e22bcfb01", + "name": "jupyterlab", + "sha256": "8e95020bc0296575db291b87d6795598985ad26821ce09303fbedb48709384fd", + "size": 10488008, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1533752022968, + "type": "app", + "version": "0.33.8" + }, + "jupyterlab-0.34.1-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7f86fb3c332cab5d69cb17877839e9a0", + "name": "jupyterlab", + "sha256": "e08748b9bf2499c1627877be51ef0bc7b91d9cdcd6c7e9ee5076c1b5536bb1ba", + "size": 10378474, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1534946826941, + "type": "app", + "version": "0.34.1" + }, + "jupyterlab-0.34.1-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38571713a565d82014725c24869ea085", + "name": "jupyterlab", + "sha256": "8d711069ecfd9599b8cb63a972c7be91bbb696835fbadfaebc599d4816c257d5", + "size": 10383027, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1534946799045, + "type": "app", + "version": "0.34.1" + }, + "jupyterlab-0.34.1-py37_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "553e8615dbdde2132492a92e9c9f4c90", + "name": "jupyterlab", + "sha256": "90c64c8450c249d07793793c3766f6cabfa8c818573bb8bc0e67b1e8171a2028", + "size": 10381235, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1534946857011, + "type": "app", + "version": "0.34.1" + }, + "jupyterlab-0.34.12-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b88277267517704f25a1e02ad6aafdb7", + "name": "jupyterlab", + "sha256": "ebf2279fe90ab7cb93d0f3930bdedd02b3cdd7f54506b5684ae56a2a00f4f6ae", + "size": 10474100, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1538599401293, + "type": "app", + "version": "0.34.12" + }, + "jupyterlab-0.34.12-py37_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "60652bde9a269844de74711cce0cdb39", + "name": "jupyterlab", + "sha256": "6d35d410f94051f5046e87bbb2f8e3ea68e6eb901059fd476760506c972cecb4", + "size": 10472067, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1538599389027, + "type": "app", + "version": "0.34.12" + }, + "jupyterlab-0.34.3-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1768be940d148a2d5a5676995e6e3454", + "name": "jupyterlab", + "sha256": "4549f255406ab8b7e9a8066e1ad435a4b8d0df6410ef6e22002f3111de9df8b3", + "size": 10397471, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1535385210313, + "type": "app", + "version": "0.34.3" + }, + "jupyterlab-0.34.3-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a65fc7e59585e8f9a07a1877028ac746", + "name": "jupyterlab", + "sha256": "3167c8aeb8717d3f170b87ad79fdb5643275c9aa526c6e790ed538830edd8871", + "size": 10409560, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1535385052723, + "type": "app", + "version": "0.34.3" + }, + "jupyterlab-0.34.3-py37_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1d86e323d31739f63fa1f0bb6191f7e7", + "name": "jupyterlab", + "sha256": "1d906494a9bf6acedd53608a028df349ef1faca1411be313b7f2890a608d91e6", + "size": 10408537, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1535385093018, + "type": "app", + "version": "0.34.3" + }, + "jupyterlab-0.34.7-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "915dc78cb33d30373fe68ea6c8b788e6", + "name": "jupyterlab", + "sha256": "bb7f13276e413901d762de41032234a36a962de0a23821f056188085774871f7", + "size": 10456722, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1536080200962, + "type": "app", + "version": "0.34.7" + }, + "jupyterlab-0.34.7-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d4ce8fa84ede62bd96116ca13eb9ce9", + "name": "jupyterlab", + "sha256": "622673ace45c4f7a32c4ac784cbc07b12db57110a822d8f78083141316b05422", + "size": 10467803, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1536080106751, + "type": "app", + "version": "0.34.7" + }, + "jupyterlab-0.34.7-py37_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eff29370fcf8cc35568e2fd7e3c2f91c", + "name": "jupyterlab", + "sha256": "4418cabaa551951d8c6c98397080dd82297134b9dfbb4428306d633311d537db", + "size": 10468366, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1536083528352, + "type": "app", + "version": "0.34.7" + }, + "jupyterlab-0.34.9-py35_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "23e827f4f363851e7580f1086ec238dd", + "name": "jupyterlab", + "sha256": "72dd4ae4266286cebe2e77cbe6d9d7aefff195327394bb20c517757afe66f30c", + "size": 10459034, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1536767434211, + "type": "app", + "version": "0.34.9" + }, + "jupyterlab-0.34.9-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0f28dc6dc48cd3c08c59d4a34a531a86", + "name": "jupyterlab", + "sha256": "36ff6f3f3a42b4cfa932004801f5ded80334cec52545b8ac7b99b248a517ba91", + "size": 10471152, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1536700699953, + "type": "app", + "version": "0.34.9" + }, + "jupyterlab-0.34.9-py37_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eead8d331b56d08d8905662782872c58", + "name": "jupyterlab", + "sha256": "72414365a723e9a7a8092d80dc83b237d24880f46908dc13a8c05af556f4e15d", + "size": 10472083, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1536767403298, + "type": "app", + "version": "0.34.9" + }, + "jupyterlab-0.35.0-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d1283a469bdd6b752fc38c0eeee0546a", + "name": "jupyterlab", + "sha256": "22092ce042c375cd9546f1cb911353db771bc41998fc06776edad5b8dcd10a67", + "size": 11191516, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1539095156582, + "type": "app", + "version": "0.35.0" + }, + "jupyterlab-0.35.0-py37_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5490c84ae2cf1f2d0926d83c671a5ef2", + "name": "jupyterlab", + "sha256": "35732ff7c3be403f3b4e52bfc9e91c2dfac6e6d051d6ba8d256c8511aa75ed60", + "size": 10884496, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1539095107196, + "type": "app", + "version": "0.35.0" + }, + "jupyterlab-0.35.1-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4382376d5966d2e2f01beda99ba144a4", + "name": "jupyterlab", + "sha256": "3a05656f11103c1af769c3e729bca73c56b9e1e93fbfe1d0d81aea5478129336", + "size": 11006763, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1539695627210, + "type": "app", + "version": "0.35.1" + }, + "jupyterlab-0.35.1-py37_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1217d2caff71fac2966ac49e1847af0d", + "name": "jupyterlab", + "sha256": "8ae70f4b973c32ed52ffdfb2cb6f6c7353221ecef5644ee571bfd3be1e27c4da", + "size": 11008164, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1539695632957, + "type": "app", + "version": "0.35.1" + }, + "jupyterlab-0.35.2-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "35384d12233b7fc202383fe2881dc1d7", + "name": "jupyterlab", + "sha256": "71a16f08240a19dd63d50044307893284b389a3a8e09b06aeec21dbfa1134754", + "size": 11010508, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1540234891875, + "type": "app", + "version": "0.35.2" + }, + "jupyterlab-0.35.2-py37_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4e60b57575f61b1c419968d5516e6214", + "name": "jupyterlab", + "sha256": "da63fa91727b477cec5af37fd961a6664c8d50321f488dd4710a297fba21987a", + "size": 11008664, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1540234889766, + "type": "app", + "version": "0.35.2" + }, + "jupyterlab-0.35.3-py36_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c141096647b3b0cfb53bfc709942c421", + "name": "jupyterlab", + "sha256": "2a280cac0f1aec73cb9da676ec25ca534ad651a19a149046621c9ced6dcf5921", + "size": 11076676, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1540980644840, + "type": "app", + "version": "0.35.3" + }, + "jupyterlab-0.35.3-py37_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c0ce7e74a969763459fedfa91e1d43d1", + "name": "jupyterlab", + "sha256": "fe675a6cdb227009bce7fd4a338054f77d77cb629d22713d4c1efc4cb98b1c6c", + "size": 11191002, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1540980649755, + "type": "app", + "version": "0.35.3" + }, + "jupyterlab-0.35.4-py36hf63ae98_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36hf63ae98_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "89ca51e89eb6db19fae0d44c8102ae47", + "name": "jupyterlab", + "sha256": "345cc77729cd96a1499b679d46dfebcb7eb398a60bf6edd5a8d45b59a08308ee", + "size": 11097975, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1552338927961, + "type": "app", + "version": "0.35.4" + }, + "jupyterlab-0.35.4-py37hf63ae98_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37hf63ae98_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cc43d13d0a20836e1eb795da325e7b0f", + "name": "jupyterlab", + "sha256": "e16ef48cf4874de468e80545adaf11989f4945bcf4d3be57e3970dd47f20f961", + "size": 11171395, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1552338905887, + "type": "app", + "version": "0.35.4" + }, + "jupyterlab-0.35.5-py36hf63ae98_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36hf63ae98_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0aa9b7d07222d1c77a02bd3eecfe909d", + "name": "jupyterlab", + "sha256": "2736ed6abba8d4c5708bc22bc07a8344c6d4cbfe72ea5d60d883c951366f235e", + "size": 11171875, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1556288301278, + "type": "app", + "version": "0.35.5" + }, + "jupyterlab-0.35.5-py37hf63ae98_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37hf63ae98_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f77ea8abdf3dcd2853f6d0146ac7df62", + "name": "jupyterlab", + "sha256": "6d911d35e6939509cd329cb0d0c478002d5a489939d4cd1867481f53668ec833", + "size": 11271184, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1556288282715, + "type": "app", + "version": "0.35.5" + }, + "jupyterlab-1.0.2-py36hf63ae98_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36hf63ae98_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=1.0.0,<2.0.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0", + "tornado !=6.0.0,!=6.0.1,!=6.0.2" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a87ce6aa78c9b4c69f7e825d0cf7628f", + "name": "jupyterlab", + "sha256": "443e7b9062469da626fdb9c3e100e196400ecda31a45061ee76046656e49a326", + "size": 14270118, + "subdir": "linux-64", + "summary": "JupyterLab", + "timestamp": 1563286194193, + "type": "app", + "version": "1.0.2" + }, + "jupyterlab-1.0.2-py37hf63ae98_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37hf63ae98_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=1.0.0,<2.0.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0", + "tornado !=6.0.0,!=6.0.1,!=6.0.2" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "53b5de1b0c9d205cef1e79b169d1abe0", + "name": "jupyterlab", + "sha256": "e34c40c7623890e16d2da72ec0b89efbaa793ff0dd18c08915ecb9fa8ffe5eb0", + "size": 14188429, + "subdir": "linux-64", + "summary": "JupyterLab", + "timestamp": 1563286126507, + "type": "app", + "version": "1.0.2" + }, + "jupyterlab-3.4.4-py310h06a4308_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<2", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.10,<3.11.0a0", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a3d6f0a846d7947246080d1c189b3f36", + "name": "jupyterlab", + "sha256": "fcf5b12806a8ee012c5aafc9c1eeae352eb6c830d3ff093482cf7ba4dc0d6579", + "size": 6345029, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1658907667387, + "type": "app", + "version": "3.4.4" + }, + "jupyterlab-3.4.4-py37h06a4308_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<2", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.7,<3.8.0a0", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fbf107df7f8c641e026410831bf6da98", + "name": "jupyterlab", + "sha256": "361b365ac2632c46658274df117ed2204c01b09430847a9337f7031a9edf3023", + "size": 6347322, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1658907751102, + "type": "app", + "version": "3.4.4" + }, + "jupyterlab-3.4.4-py38h06a4308_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<2", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.8,<3.9.0a0", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a487fefb6fc5a6894a12c4c564a824b2", + "name": "jupyterlab", + "sha256": "9168e4a405b93b92bb6121bcad0c053df4f38a93122ed70866c0deb316a9181d", + "size": 6309771, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1658907573057, + "type": "app", + "version": "3.4.4" + }, + "jupyterlab-3.4.4-py39h06a4308_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<2", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.9,<3.10.0a0", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "12530a98aa54eb82094d8922f829896d", + "name": "jupyterlab", + "sha256": "0a40826a98c817b7466ad8a820dd0ef22231dc7d79b8e5fd5b229d564600b4bc", + "size": 6345264, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1658907833263, + "type": "app", + "version": "3.4.4" + }, + "jupyterlab-3.5.0-py310h06a4308_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.10,<3.11.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3ae8343f4c5e42b66fbe465425d6cbfe", + "name": "jupyterlab", + "sha256": "f1fb5d7fc693ba7c1a3e3972e0f389a1076a231d4d16302cb86b3314bfd28680", + "size": 6457503, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1669368595313, + "type": "app", + "version": "3.5.0" + }, + "jupyterlab-3.5.0-py37h06a4308_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.7,<3.8.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f3ece685b8b7aca96ca2d30eca3a4584", + "name": "jupyterlab", + "sha256": "8d13aaa7946831eb609d4cce59e7a61406d0e6c9718ebe4f96c9e241be192cf3", + "size": 6454158, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1669368496128, + "type": "app", + "version": "3.5.0" + }, + "jupyterlab-3.5.0-py38h06a4308_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.8,<3.9.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e3798777b920dfd78f2608971ac0fbd9", + "name": "jupyterlab", + "sha256": "40ea75fdf05589811cfbab4667e67f89d4e79f065211597a962dce45d50b7af2", + "size": 6489917, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1669368682316, + "type": "app", + "version": "3.5.0" + }, + "jupyterlab-3.5.0-py39h06a4308_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.9,<3.10.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eef8f6d378a3640ce6c7a854a6b81763", + "name": "jupyterlab", + "sha256": "e294aaba5df71f5c92952e5eece88d2f5148b0a694817aab789972fb293c47ea", + "size": 6491149, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1669368769612, + "type": "app", + "version": "3.5.0" + }, + "jupyterlab-3.5.2-py310h06a4308_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.10,<3.11.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9299a3b99efa174e476ec1f1f29cdad5", + "name": "jupyterlab", + "sha256": "d3820b656d7bbe0e99a9a26cf3f9cdc00a27ef32bf601b9a59a1c9755564faf1", + "size": 6413543, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1672132901521, + "type": "app", + "version": "3.5.2" + }, + "jupyterlab-3.5.2-py37h06a4308_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.7,<3.8.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2240d264a3b85bcef85f3c7f1691d920", + "name": "jupyterlab", + "sha256": "ea306aef3afbb04a5c1f8bbb159970107c12f26449dd01eb552accaa9c6e437e", + "size": 6464418, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1672132982831, + "type": "app", + "version": "3.5.2" + }, + "jupyterlab-3.5.2-py38h06a4308_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.8,<3.9.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "31ebb3212449d52d6fdb7b837a7b40dc", + "name": "jupyterlab", + "sha256": "efbe97a533d3c8a63afd7a5b932b6b682f9dcba7a7e4a812b2cd8649a37557c9", + "size": 6471500, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1672132726593, + "type": "app", + "version": "3.5.2" + }, + "jupyterlab-3.5.2-py39h06a4308_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.9,<3.10.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c408da6e4a09fcc243f49ff2a59b8d08", + "name": "jupyterlab", + "sha256": "656ac6a7c8167dc87eda4b7bb35715d172250208e921e030d423902f7b283bcb", + "size": 6413627, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1672132821306, + "type": "app", + "version": "3.5.2" + }, + "jupyterlab-3.5.3-py310h06a4308_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.10,<3.11.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3fead9ef05dfcadd77f39d641229d5b4", + "name": "jupyterlab", + "sha256": "acf6656141c987b1afcff5ca2e9fa9ecebd0174e26835d2813ca9e09310854fa", + "size": 6333054, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1675354153054, + "type": "app", + "version": "3.5.3" + }, + "jupyterlab-3.5.3-py311h06a4308_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.11,<3.12.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d71f9f487c2fb448ee1fb4d602a9352b", + "name": "jupyterlab", + "sha256": "f810bee95142cd4f8a1bb0148dbff99eef0c95de5fb3c50f723fcc0a6b3cc602", + "size": 6451911, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1677874041337, + "type": "app", + "version": "3.5.3" + }, + "jupyterlab-3.5.3-py37h06a4308_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.7,<3.8.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "102aeb5a55d1f9f296f70745797a0529", + "name": "jupyterlab", + "sha256": "48af5ccd85fa875b37f7ab2f25d1afaff6a20f9f43477746c3e3ded518b6777b", + "size": 6355466, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1675354347491, + "type": "app", + "version": "3.5.3" + }, + "jupyterlab-3.5.3-py38h06a4308_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.8,<3.9.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e9cadc6c87edf9100a7fcdec88ac90e3", + "name": "jupyterlab", + "sha256": "aa16ddbb2fbcd4e63c39272cd77c193371f7326857409dda7fc7575b4897bb05", + "size": 6328082, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1675354257535, + "type": "app", + "version": "3.5.3" + }, + "jupyterlab-3.5.3-py39h06a4308_0.tar.bz2": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.9,<3.10.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "95668f7599f7ad814a064e3a14b29e48", + "name": "jupyterlab", + "sha256": "56075b1ba80297503782659d142d3c57f2ffd18bdf476b98ad92645a3058e27c", + "size": 6330897, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1675354436606, + "type": "app", + "version": "3.5.3" + }, + "jupyterlab-geojson-3.3.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e8e6c26dd171ca69d2258cf175229b48", + "name": "jupyterlab-geojson", + "sha256": "a3514a203f09406a445869583f53331362d6a89b80e63c7d6370302aacd5af29", + "size": 98217, + "subdir": "linux-64", + "timestamp": 1679915894232, + "version": "3.3.1" + }, + "jupyterlab-geojson-3.3.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f0d5da91221466f8e8f8c321c410c9b1", + "name": "jupyterlab-geojson", + "sha256": "d4aa1c5287cc05d77f8def891a08def788dc7be7cfac9044f02e5f216778a76a", + "size": 98758, + "subdir": "linux-64", + "timestamp": 1679916010600, + "version": "3.3.1" + }, + "jupyterlab-geojson-3.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "009a7c866bd0a415fbc05028fa063494", + "name": "jupyterlab-geojson", + "sha256": "687d35892b40246e36543fda6bb180ee8b17feee56e964fcac7b4351323c568a", + "size": 98045, + "subdir": "linux-64", + "timestamp": 1679915952791, + "version": "3.3.1" + }, + "jupyterlab-geojson-3.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3f23704b25034e6bc83d3f3b3a2a3862", + "name": "jupyterlab-geojson", + "sha256": "6a2cbde4a231330650adbca41a28aed8652bac91d728df94c9c08e2661c01824", + "size": 97974, + "subdir": "linux-64", + "timestamp": 1679915837752, + "version": "3.3.1" + }, + "jupyterlab_launcher-0.10.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "521f602355682304db740736c8e2b4c0", + "name": "jupyterlab_launcher", + "sha256": "1935494078f90de467e65977571f290354fcd0ba77259e13bf4cb95adcaf8122", + "size": 24627, + "subdir": "linux-64", + "timestamp": 1515949888848, + "version": "0.10.0" + }, + "jupyterlab_launcher-0.10.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7d6a3bd62c033930a32352c07d624abb", + "name": "jupyterlab_launcher", + "sha256": "2a00fb4674cc141c3aba7b8f6004451d6522197facf7999cf516096962deb0f3", + "size": 25128, + "subdir": "linux-64", + "timestamp": 1515949911245, + "version": "0.10.0" + }, + "jupyterlab_launcher-0.10.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "34797a8f43e9ed64707857cd0067a819", + "name": "jupyterlab_launcher", + "sha256": "c985b50dda7c3ab21581838315fa9c88f5b9f6d4da5843b756becbbf3a409bad", + "size": 25089, + "subdir": "linux-64", + "timestamp": 1515949880807, + "version": "0.10.0" + }, + "jupyterlab_launcher-0.10.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8876f2f1f46fcb703b16389dcb11c0df", + "name": "jupyterlab_launcher", + "sha256": "05cefd991c069bd289750875aaba71e30ec5625a50f0427041495ef7a34bd1a8", + "size": 24606, + "subdir": "linux-64", + "timestamp": 1515950581219, + "version": "0.10.1" + }, + "jupyterlab_launcher-0.10.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0077c05fa6756aea3ce1297d75f05a8f", + "name": "jupyterlab_launcher", + "sha256": "df3545661a50bdefb61c2cad4f7476a2d46116b44febf3c52753d89dd767cad2", + "size": 25159, + "subdir": "linux-64", + "timestamp": 1515950604939, + "version": "0.10.1" + }, + "jupyterlab_launcher-0.10.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3c5a54e326fb3fd2dd1bbfe08962fc7c", + "name": "jupyterlab_launcher", + "sha256": "156a3d66d40eeddda1c942aa4216f58265adea13996f2ac852291e17a4bc41d3", + "size": 25107, + "subdir": "linux-64", + "timestamp": 1515950563276, + "version": "0.10.1" + }, + "jupyterlab_launcher-0.10.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0769f6ea6ab298736ae4238da46470eb", + "name": "jupyterlab_launcher", + "sha256": "a4eba34070e609254d54ea82e224679fc3e80bdb897b4e7b3fd5873f6e463edf", + "size": 24640, + "subdir": "linux-64", + "timestamp": 1515951092342, + "version": "0.10.2" + }, + "jupyterlab_launcher-0.10.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8e8184df4c3977ddac14455b325b5ef2", + "name": "jupyterlab_launcher", + "sha256": "0898a83ec860e0c7c21123bfd3abb82a9237f517576add16dc80dce4d666f8fd", + "size": 25153, + "subdir": "linux-64", + "timestamp": 1515951110824, + "version": "0.10.2" + }, + "jupyterlab_launcher-0.10.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a2c7810ad1ba276bbf453e9e0dff9f0c", + "name": "jupyterlab_launcher", + "sha256": "e25bdfbb13f763c909398e492e579c84349444b929e7c3e7ceb8af0fcd419b49", + "size": 25093, + "subdir": "linux-64", + "timestamp": 1515951069301, + "version": "0.10.2" + }, + "jupyterlab_launcher-0.10.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c6f4dd40ce3f769af925974d5a00f845", + "name": "jupyterlab_launcher", + "sha256": "bb80d75f9a4aef4b794a74d6fbcc4989e338aec02e3056f5472b526f1c1c2d75", + "size": 24667, + "subdir": "linux-64", + "timestamp": 1519832051305, + "version": "0.10.5" + }, + "jupyterlab_launcher-0.10.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e3268019d0f662837eb0cd00a7da0d0c", + "name": "jupyterlab_launcher", + "sha256": "7de917af1be13a897d15f810ea71dba4a4aa09f8dd83133fda1b5765c7420374", + "size": 25175, + "subdir": "linux-64", + "timestamp": 1519832061476, + "version": "0.10.5" + }, + "jupyterlab_launcher-0.10.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "22a5061ed5d6fe4d662a8de1a56f7692", + "name": "jupyterlab_launcher", + "sha256": "6d84c28cf8860c1d5ed6f6c7768672e356a38c032f6e5defed82d2c0aba05e78", + "size": 25136, + "subdir": "linux-64", + "timestamp": 1519832629274, + "version": "0.10.5" + }, + "jupyterlab_launcher-0.11.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e7cb894ccddf6ab9a411ca880b27f63d", + "name": "jupyterlab_launcher", + "sha256": "878865a60ea70814dc3d7f49c6e94a569fe84d3a31a96480df9c548e51ce3b1a", + "size": 30061, + "subdir": "linux-64", + "timestamp": 1529348389751, + "version": "0.11.0" + }, + "jupyterlab_launcher-0.11.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "74b24e164a108a7f7a5ad760be0c38f5", + "name": "jupyterlab_launcher", + "sha256": "66880fd0920e04431ccacf9b0f8ccde58ee4dc079c6a3e46aa8677bb810c729e", + "size": 30675, + "subdir": "linux-64", + "timestamp": 1529348430489, + "version": "0.11.0" + }, + "jupyterlab_launcher-0.11.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "313da4bbe427b53d0fbd151744802b2d", + "name": "jupyterlab_launcher", + "sha256": "2cd5cb39268e97bbaa3ca28f067d58459ade7346da4dc5948ac1fceecae9478b", + "size": 30589, + "subdir": "linux-64", + "timestamp": 1529348370280, + "version": "0.11.0" + }, + "jupyterlab_launcher-0.11.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d7836ea1be8b78152030134a186a6c92", + "name": "jupyterlab_launcher", + "sha256": "440f9628b2cf26614d6ce257286cc5b4b9dec20c52aabf1bc68d6d92992b9cb7", + "size": 30693, + "subdir": "linux-64", + "timestamp": 1530734823652, + "version": "0.11.0" + }, + "jupyterlab_launcher-0.11.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "07500ca15f00cda8be99e9178e0e5840", + "name": "jupyterlab_launcher", + "sha256": "3b2611fd6ebcaa2c8bb701c403ffbcb5fd1d3acb1bce4d41b6a7b6afd3875285", + "size": 32984, + "subdir": "linux-64", + "timestamp": 1532522427982, + "version": "0.11.2" + }, + "jupyterlab_launcher-0.11.2-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "36c8ee112fed7786f43ee8c266cd8297", + "name": "jupyterlab_launcher", + "sha256": "7ddcbb9b31df8bd046cfa62be3549177d8f5a9ee8618e58716bba30b92b6e0f6", + "size": 32972, + "subdir": "linux-64", + "timestamp": 1534351594663, + "version": "0.11.2" + }, + "jupyterlab_launcher-0.11.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "034ccb4263d546adfe9024b866f83ca9", + "name": "jupyterlab_launcher", + "sha256": "e9692f46667fcdb8b54d857aaf4e5ac367c1e078577886b410200f487af2cb32", + "size": 33631, + "subdir": "linux-64", + "timestamp": 1532522516629, + "version": "0.11.2" + }, + "jupyterlab_launcher-0.11.2-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "622b769856af66498adee440e7268d39", + "name": "jupyterlab_launcher", + "sha256": "2a329156934280390495db9768818d13d3b282a8dc510187e658b6bafca37b94", + "size": 33634, + "subdir": "linux-64", + "timestamp": 1534351633153, + "version": "0.11.2" + }, + "jupyterlab_launcher-0.11.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a7b55f1b0e8f76634037efb18e621aae", + "name": "jupyterlab_launcher", + "sha256": "eebfa42c406daa8a76f99c6df33ae5a84566d6d6ab6961520623134e58f506b5", + "size": 33591, + "subdir": "linux-64", + "timestamp": 1532522309936, + "version": "0.11.2" + }, + "jupyterlab_launcher-0.11.2-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "178cde08747a97cb0c2196736f673104", + "name": "jupyterlab_launcher", + "sha256": "7420d86c2f2050df3ae4a42e756bc236dcad195a3a0c3f0201571e5e84fb4b1a", + "size": 33552, + "subdir": "linux-64", + "timestamp": 1534351673312, + "version": "0.11.2" + }, + "jupyterlab_launcher-0.11.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0b170fdf908f1582d32e78866b22dc26", + "name": "jupyterlab_launcher", + "sha256": "2e8557cf442505764295b5cd83d4b36823652120b061d7a8b395ce014a739c63", + "size": 33658, + "subdir": "linux-64", + "timestamp": 1532522486958, + "version": "0.11.2" + }, + "jupyterlab_launcher-0.11.2-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e8b2d20a2d59b5a187279332b5a598c3", + "name": "jupyterlab_launcher", + "sha256": "f824724629d1d853cf27bbb31338eb10633bec111c4baff06c1f6796669b849b", + "size": 33664, + "subdir": "linux-64", + "timestamp": 1534351561052, + "version": "0.11.2" + }, + "jupyterlab_launcher-0.13.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1ef9f06a3ba991d0751929512754cd63", + "name": "jupyterlab_launcher", + "sha256": "506510c02dc2dd88e8a2939543e31685281a1a1b22101ed60917efceb9b3e41a", + "size": 39632, + "subdir": "linux-64", + "timestamp": 1642519562022, + "version": "0.13.1" + }, + "jupyterlab_launcher-0.13.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "525e23a90146f85672bb035254dac313", + "name": "jupyterlab_launcher", + "sha256": "d7f176781c54c059ec7504a008ee8a9a3095084ba31782a07e047c39348772a5", + "size": 51356, + "subdir": "linux-64", + "timestamp": 1676853045764, + "version": "0.13.1" + }, + "jupyterlab_launcher-0.13.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "071a8c085732e9b653c94edae954fe0d", + "name": "jupyterlab_launcher", + "sha256": "7e43e910c88085e0f4392bf8f52619f68a2f23bfed7be18adf6aad1e564412a9", + "size": 36824, + "subdir": "linux-64", + "timestamp": 1534266449732, + "version": "0.13.1" + }, + "jupyterlab_launcher-0.13.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "849cf528252bd80eb8950546f5ff32fb", + "name": "jupyterlab_launcher", + "sha256": "1cf8b29c29bec0d5c70bcdbd6dbc26d1ca29d302866af20c8d43ce7364b18e9a", + "size": 36742, + "subdir": "linux-64", + "timestamp": 1534266392565, + "version": "0.13.1" + }, + "jupyterlab_launcher-0.13.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "78624d33110c1faf3a3d86c204cbadd6", + "name": "jupyterlab_launcher", + "sha256": "0e7aed9b99a9e60e7f20b4b5c28571dc50c80a429975738811735320c9d671cb", + "size": 36766, + "subdir": "linux-64", + "timestamp": 1534266428724, + "version": "0.13.1" + }, + "jupyterlab_launcher-0.4.0-py27h0e16d15_0.tar.bz2": { + "build": "py27h0e16d15_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "95f8e952ddfa798b5ff5b51d94904abd", + "name": "jupyterlab_launcher", + "sha256": "da45f2d95e2767e7ab8c0b210a0a791650ad67c2384051cdbcded575e19ba7f2", + "size": 17222, + "subdir": "linux-64", + "timestamp": 1505690999927, + "version": "0.4.0" + }, + "jupyterlab_launcher-0.4.0-py35ha4e430f_0.tar.bz2": { + "build": "py35ha4e430f_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2eb6168d66bceaa67f1963a54880e65a", + "name": "jupyterlab_launcher", + "sha256": "c0d138505a506e9314ce5c7aaa422d4eeac3b91719a36c462db6140bf206a1a5", + "size": 17554, + "subdir": "linux-64", + "timestamp": 1505691012126, + "version": "0.4.0" + }, + "jupyterlab_launcher-0.4.0-py36h4d8058d_0.tar.bz2": { + "build": "py36h4d8058d_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "540ab87bff4b173556fea089cb5aa355", + "name": "jupyterlab_launcher", + "sha256": "9098329797863b8d98ea9157aa2bcf29405277b79fc84b9c8fd9b8f4c51495aa", + "size": 17495, + "subdir": "linux-64", + "timestamp": 1505691024679, + "version": "0.4.0" + }, + "jupyterlab_launcher-0.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "45728b1ef0d4d206b6a3624a0e3846cf", + "name": "jupyterlab_launcher", + "sha256": "e72b9c9c9b99562663067fe2b30027890256560a8c8c0b92630e558f4ad66c17", + "size": 20619, + "subdir": "linux-64", + "timestamp": 1512661225068, + "version": "0.6.0" + }, + "jupyterlab_launcher-0.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c010dd2a8f23117b6d57fa7d30a1c1f1", + "name": "jupyterlab_launcher", + "sha256": "156612a885bd64fd1014af5c6d23a24628db90e74cad92e1c069ac246bc9c1d5", + "size": 20953, + "subdir": "linux-64", + "timestamp": 1512661277914, + "version": "0.6.0" + }, + "jupyterlab_launcher-0.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4d0b0f880cd898fa2689827576ec9fcd", + "name": "jupyterlab_launcher", + "sha256": "3d1161d221af946d02a8453291b66bcb5ce42ffb904950dc746a21e216b62d3c", + "size": 20900, + "subdir": "linux-64", + "timestamp": 1512661294342, + "version": "0.6.0" + }, + "jupyterlab_server-0.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "17b0274ea9774d4a38db0e8cc2c895d1", + "name": "jupyterlab_server", + "sha256": "9cceee656d9e25228e421d55bae274f8d7d14be1e8f78cf0e5966b57a66ed200", + "size": 40988, + "subdir": "linux-64", + "timestamp": 1539095022210, + "version": "0.2.0" + }, + "jupyterlab_server-0.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "80cd48e21eaba9bed73537dbfdf80d5d", + "name": "jupyterlab_server", + "sha256": "aa4b8d4588771ce407b3ba7e69b6198e7c8fb8e10ed02d7f1f131ca97e6842af", + "size": 41091, + "subdir": "linux-64", + "timestamp": 1539095000160, + "version": "0.2.0" + }, + "jupyterlab_server-0.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3d984ddf24ada575968660b2929db894", + "name": "jupyterlab_server", + "sha256": "c30f47be9b7564f16dc18ce411f15829f7d91f1dc2c3ad9c7bc4c87df2e526c6", + "size": 41842, + "subdir": "linux-64", + "timestamp": 1551141564654, + "version": "0.3.0" + }, + "jupyterlab_server-0.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c31b145805282986db3c58ed829471c1", + "name": "jupyterlab_server", + "sha256": "67005e165593f47917c33db1a06821279afad67e710cabfeadccf027bb1555d9", + "size": 41934, + "subdir": "linux-64", + "timestamp": 1551141544312, + "version": "0.3.0" + }, + "jupyterlab_server-0.3.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b56d2a9304ff5b2aab6dd4c134a2fe56", + "name": "jupyterlab_server", + "sha256": "97f42e8d986b41ca375dfe013950b89c291d6348a7f45827c828c42099625024", + "size": 42832, + "subdir": "linux-64", + "timestamp": 1559849278712, + "version": "0.3.4" + }, + "jupyterlab_server-0.3.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8f2fd16c6f3b58f5eb5eefea668cd64d", + "name": "jupyterlab_server", + "sha256": "cdb3ee92108bb049ac2fd08a389473cc4f13786e252cbd4d594b9b080ba884fd", + "size": 42869, + "subdir": "linux-64", + "timestamp": 1559849231775, + "version": "0.3.4" + }, + "jupyterlab_server-2.12.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "entrypoints >=0.2.2", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<2", + "packaging", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "952cf5b4dbedede781f384d0e244a8ff", + "name": "jupyterlab_server", + "sha256": "61f31dd3947aaa6086f244f887e0a36c86c4847ad4c91e3b436e37b2d9ca50f9", + "size": 76742, + "subdir": "linux-64", + "timestamp": 1650462524608, + "version": "2.12.0" + }, + "jupyterlab_server-2.12.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "entrypoints >=0.2.2", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<2", + "packaging", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "12ca5bf7434cc1637e2bd74cee6dc581", + "name": "jupyterlab_server", + "sha256": "b60547004bdb691bb8ce944a2a23102d847daff7947af4b12f8e558687241117", + "size": 75990, + "subdir": "linux-64", + "timestamp": 1650462650715, + "version": "2.12.0" + }, + "jupyterlab_server-2.12.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "entrypoints >=0.2.2", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<2", + "packaging", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1494113e0050ac8f25e21ba8812c52a9", + "name": "jupyterlab_server", + "sha256": "8a1ae0a58aeeead63f7268a2b4a79b546c6b746318609242ca349b710e83b77a", + "size": 76188, + "subdir": "linux-64", + "timestamp": 1650462385574, + "version": "2.12.0" + }, + "jupyterlab_server-2.12.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "entrypoints >=0.2.2", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<2", + "packaging", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4a4607d3d48e56d0fd2fe1469e02b567", + "name": "jupyterlab_server", + "sha256": "472e59fabfdb7e9a8c8327389558433ddf57e235c74eaba4ead05533aeae9b91", + "size": 76349, + "subdir": "linux-64", + "timestamp": 1650462228197, + "version": "2.12.0" + }, + "jupyterlab_server-2.15.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<2", + "packaging", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eecea6865c795786faa0a52554f0c0a7", + "name": "jupyterlab_server", + "sha256": "26f66cac0893c09293bafcb4c6edbf5c975c1db7dab8356045f2e8f6136c8fbc", + "size": 76166, + "subdir": "linux-64", + "timestamp": 1664908287526, + "version": "2.15.2" + }, + "jupyterlab_server-2.15.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "importlib-metadata >=3.6", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<2", + "packaging", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6214154b7257bbf48673cbf487927e5c", + "name": "jupyterlab_server", + "sha256": "6ebcbf76223caa551b337d8af750f0f2471c2b6c1dab90ac3b68e9cd408b9c95", + "size": 75484, + "subdir": "linux-64", + "timestamp": 1664908410213, + "version": "2.15.2" + }, + "jupyterlab_server-2.15.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "importlib-metadata >=3.6", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<2", + "packaging", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ddee0cb20d6c7740d6411988b403ec5f", + "name": "jupyterlab_server", + "sha256": "f86e54c5544c8bc7f1a50a4ef4fec049cc1c86c30be32bf2290349c05cfdf737", + "size": 75612, + "subdir": "linux-64", + "timestamp": 1664908369980, + "version": "2.15.2" + }, + "jupyterlab_server-2.15.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "importlib-metadata >=3.6", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<2", + "packaging", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a1b21b672f558e1a78cd8fc64c64ed85", + "name": "jupyterlab_server", + "sha256": "99bfdeec2be4a6355db38282816a18785b8e5d2daf038547495e190d5f1557ea", + "size": 75686, + "subdir": "linux-64", + "timestamp": 1664908329910, + "version": "2.15.2" + }, + "jupyterlab_server-2.16.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<3", + "packaging", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5d061226b58ac5aa8a38a1199644ab62", + "name": "jupyterlab_server", + "sha256": "7735721321bbee777966909b5bcb617963542391a069d9435df9b1605786f4c2", + "size": 76212, + "subdir": "linux-64", + "timestamp": 1669363810464, + "version": "2.16.3" + }, + "jupyterlab_server-2.16.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<3", + "packaging", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a0d4267f38590e431a22b1104c68b9b", + "name": "jupyterlab_server", + "sha256": "f8a7391abccc35ab84e942217d53e91313176e3e2033f9edba317447c54af1f2", + "size": 75289, + "subdir": "linux-64", + "timestamp": 1669363774742, + "version": "2.16.3" + }, + "jupyterlab_server-2.16.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<3", + "packaging", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "631fea33948ea278335b3d9e72c17480", + "name": "jupyterlab_server", + "sha256": "2c6a7ea3393f61fb528eeb22a276c8f24f56684975102aa5271e67eb83b8ac8c", + "size": 75323, + "subdir": "linux-64", + "timestamp": 1669363845111, + "version": "2.16.3" + }, + "jupyterlab_server-2.16.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<3", + "packaging", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "97d49479945911c4426fa5cd241661bb", + "name": "jupyterlab_server", + "sha256": "13e970c00a52ce1f3489f7b3355c92c4b8cc3294fbb64c6845ce26d274da97b4", + "size": 75779, + "subdir": "linux-64", + "timestamp": 1669363737316, + "version": "2.16.3" + }, + "jupyterlab_server-2.16.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=3.0.1", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.10,<3.11.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1c854a1bbe78cc85651737d064cc12b", + "name": "jupyterlab_server", + "sha256": "2a1ba2aacd886b2f658d5f9368a2942be1981427a89810a6ca41f39569a3efee", + "size": 76883, + "subdir": "linux-64", + "timestamp": 1672127661882, + "version": "2.16.5" + }, + "jupyterlab_server-2.16.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=3.0.1", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.11,<3.12.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "164a27b22a9943aed395ce6424ebbd8f", + "name": "jupyterlab_server", + "sha256": "1790ce3dc10506c37dd7846ad64d4267b6c2cb4bed253c2c20f6c500778de6e4", + "size": 100860, + "subdir": "linux-64", + "timestamp": 1676827228114, + "version": "2.16.5" + }, + "jupyterlab_server-2.16.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=3.0.1", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.7,<3.8.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e0c9654e1e1bf47d798bd64f2299022d", + "name": "jupyterlab_server", + "sha256": "033c66ef6e2304a51ad17b557acac4d49ef40e6904705bf23e9ebb6699498cab", + "size": 76192, + "subdir": "linux-64", + "timestamp": 1672127489938, + "version": "2.16.5" + }, + "jupyterlab_server-2.16.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=3.0.1", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.8,<3.9.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "701160002aed2d9a16ac6a1d528e081d", + "name": "jupyterlab_server", + "sha256": "0188eb1cae3b0d3e4748a847df1dbdd947357fdcb83acd9fc12cc1e61193baba", + "size": 76202, + "subdir": "linux-64", + "timestamp": 1672127576652, + "version": "2.16.5" + }, + "jupyterlab_server-2.16.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=3.0.1", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.9,<3.10.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6741c6e4e46d75aa67d6eb1bde478471", + "name": "jupyterlab_server", + "sha256": "54c161fed09e525d60b7822c67c1f4dbc509709e32d9af4180b08af4df097af6", + "size": 76207, + "subdir": "linux-64", + "timestamp": 1672127389677, + "version": "2.16.5" + }, + "jupyterlab_server-2.19.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.10,<3.11.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d09d99a26fdfb33618c24c4979ee75b2", + "name": "jupyterlab_server", + "sha256": "772645a78c670d2c95b5d5edbeb9c62accdc6b802a961d6d872604e967b87501", + "size": 77619, + "subdir": "linux-64", + "timestamp": 1677143155986, + "version": "2.19.0" + }, + "jupyterlab_server-2.19.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.11,<3.12.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "58b921ef8a38d4fe75e96cba50001118", + "name": "jupyterlab_server", + "sha256": "91387ef4ba9edf7a6cc8f24c173c4967790aa5223192d2e5ebea902f28245d3a", + "size": 102020, + "subdir": "linux-64", + "timestamp": 1679046576246, + "version": "2.19.0" + }, + "jupyterlab_server-2.19.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.7,<3.8.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b12b20069f3f063e88fa1930d15d2f64", + "name": "jupyterlab_server", + "sha256": "8e8fca4744c8b125b17e7cd7d3cd6d4ad0fb5d4f0bd2c3c76ebd1da339c64f09", + "size": 76956, + "subdir": "linux-64", + "timestamp": 1677143088566, + "version": "2.19.0" + }, + "jupyterlab_server-2.19.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.8,<3.9.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "afa2de1151fed1b702325e90ee18076b", + "name": "jupyterlab_server", + "sha256": "4afb80b60ce712a79917a00c680406e8926af60bfa6b9f0b8a54e87188c6c66c", + "size": 77120, + "subdir": "linux-64", + "timestamp": 1677143123430, + "version": "2.19.0" + }, + "jupyterlab_server-2.19.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.9,<3.10.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5e33ac1fd4e410f1f87c98c9cd78ba6f", + "name": "jupyterlab_server", + "sha256": "603f6b7b8f63760fe3c1dabee656d140b846654181a015ca5b6b6c72f8d193be", + "size": 77135, + "subdir": "linux-64", + "timestamp": 1677143188283, + "version": "2.19.0" + }, + "jupyterlab_server-2.21.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.10,<3.11.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "40caf8b48b354f69a823e4b977b1d9f8", + "name": "jupyterlab_server", + "sha256": "fabf05099762b5f03585c7cc6704bfee9d0ef7dc5179250f0538e414d0f88a54", + "size": 78813, + "subdir": "linux-64", + "timestamp": 1679906335081, + "version": "2.21.0" + }, + "jupyterlab_server-2.21.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.11,<3.12.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bcef7d3ec4ad2496e7bd360fead9fd84", + "name": "jupyterlab_server", + "sha256": "ed1b8f98de04e31d20d4e1782fa3626cda757330289c471373bf1335e680c453", + "size": 102775, + "subdir": "linux-64", + "timestamp": 1679906370711, + "version": "2.21.0" + }, + "jupyterlab_server-2.21.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.8,<3.9.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7452182558782805481f563ddfe6a5a2", + "name": "jupyterlab_server", + "sha256": "f476e6970cca4c4c493a01db1cc072ae4edcf2f7950bbc6f906a6e8c8a1c1164", + "size": 78116, + "subdir": "linux-64", + "timestamp": 1679906440834, + "version": "2.21.0" + }, + "jupyterlab_server-2.21.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.9,<3.10.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9b546a5bf8d322638cee387e237bfc26", + "name": "jupyterlab_server", + "sha256": "afbd5fc7852c6cea4a0253c9cd06cd110bd7f6cc80b92ca9e708994db9606d73", + "size": 78330, + "subdir": "linux-64", + "timestamp": 1679906405016, + "version": "2.21.0" + }, + "jupyterlab_server-2.22.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.10,<3.11.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "db0dc3fa38db07109df4c6f681126dde", + "name": "jupyterlab_server", + "sha256": "049c3a3448006890fc39f5049b210281b4f27781f1221aa45f6adb3d6f79249f", + "size": 79379, + "subdir": "linux-64", + "timestamp": 1680792640261, + "version": "2.22.0" + }, + "jupyterlab_server-2.22.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.11,<3.12.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f53357eb5742cdc11a7ca048f171a0fa", + "name": "jupyterlab_server", + "sha256": "c6f0bb2dee2fc97a8759a6afbf653ccd085a0da028817a5f71b034e9a4a5e72e", + "size": 103353, + "subdir": "linux-64", + "timestamp": 1680792605044, + "version": "2.22.0" + }, + "jupyterlab_server-2.22.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.8,<3.9.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "564cdf0c27643d2cd09351a88358fe8c", + "name": "jupyterlab_server", + "sha256": "018858bf7cb0bd4204ad8a365dfa7c97b9fa1c257c244e385a41f811b0ac5a57", + "size": 78656, + "subdir": "linux-64", + "timestamp": 1680792570109, + "version": "2.22.0" + }, + "jupyterlab_server-2.22.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.9,<3.10.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "57785fecfa19b4a8deba666eb85ba068", + "name": "jupyterlab_server", + "sha256": "af90dd98591c9519384fa9c01a50486ed043b7fdaf8bbe72392d3225242447c6", + "size": 78818, + "subdir": "linux-64", + "timestamp": 1680792534677, + "version": "2.22.0" + }, + "jupyterlab_widgets-3.0.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyterlab >=3,<4" + ], + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "94e9f2fc336bc71258188db426d6e6fc", + "name": "jupyterlab_widgets", + "sha256": "1936062e21a35c63bae99c4de1636d5ab2e03e5213d1bb51fbaa472c0cbcfdae", + "size": 232946, + "subdir": "linux-64", + "timestamp": 1679055314433, + "version": "3.0.5" + }, + "jupyterlab_widgets-3.0.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyterlab >=3,<4" + ], + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "713378fd9718ca48f1729de451386d58", + "name": "jupyterlab_widgets", + "sha256": "d258783fdeda8f4fe4896fcc55b302a0859da5de467d1b377c54d7b42e633eaf", + "size": 233102, + "subdir": "linux-64", + "timestamp": 1679055342664, + "version": "3.0.5" + }, + "jupyterlab_widgets-3.0.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyterlab >=3,<4" + ], + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cd01086e222ccf977bfdecde3bcf578d", + "name": "jupyterlab_widgets", + "sha256": "016a1ac9ddde0c7ec44334bcffed68939ea0f1d6e57a01d810fac5dab4e13ae5", + "size": 232988, + "subdir": "linux-64", + "timestamp": 1679055371126, + "version": "3.0.5" + }, + "jupyterlab_widgets-3.0.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyterlab >=3,<4" + ], + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee6eafc0657c781e1be2d9a9de08f4cf", + "name": "jupyterlab_widgets", + "sha256": "4b6aa4412d0ad391c93b2f82f7c42d1d3ac2a010683938fed371085408211e38", + "size": 233193, + "subdir": "linux-64", + "timestamp": 1679055398232, + "version": "3.0.5" + }, + "jxrlib-1.1-h7b6447c_2.tar.bz2": { + "build": "h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e1ae8a1211dfebe4c60b7e755200a327", + "name": "jxrlib", + "sha256": "46fa3b9ce2790a2efd328560b7e76f6716c92288702ced1f63168f22bad487d0", + "size": 244049, + "subdir": "linux-64", + "timestamp": 1593197090424, + "version": "1.1" + }, + "kealib-1.4.12-hd0c454d_0.tar.bz2": { + "build": "hd0c454d_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "60803c2c5df9671fd19ddf0dcd676a34", + "name": "kealib", + "sha256": "5c6633c4acedfd9cdafccdc9c154775cd6cec29bb3983e3767552eb433df7dfc", + "size": 179340, + "subdir": "linux-64", + "timestamp": 1582227404676, + "version": "1.4.12" + }, + "kealib-1.4.14-h54c064f_0.tar.bz2": { + "build": "h54c064f_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "38274ab574828a7490f90dc1590ec57e", + "name": "kealib", + "sha256": "c1d201bb079de78f873b70eec91a79ab00174c595cd0227bd5d618ad55533e68", + "size": 185571, + "subdir": "linux-64", + "timestamp": 1621648701471, + "version": "1.4.14" + }, + "kealib-1.4.14-hb50703a_1.tar.bz2": { + "build": "hb50703a_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fcd61c7464836aa82c15899a0516907b", + "name": "kealib", + "sha256": "6e331fc982591919ce61ce3a265f9179f7356443fa746491ac3fe07a4c956d92", + "size": 185531, + "subdir": "linux-64", + "timestamp": 1640000342243, + "version": "1.4.14" + }, + "kealib-1.4.7-h5472223_5.tar.bz2": { + "build": "h5472223_5", + "build_number": 5, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "fb60743a895333985db390b4e96001fd", + "name": "kealib", + "sha256": "e9afb72bd98ce0611b75ff4d386cfd4905eb624118aad2b256d372fa63d83564", + "size": 174739, + "subdir": "linux-64", + "timestamp": 1511297426193, + "version": "1.4.7" + }, + "kealib-1.4.7-h77bc034_6.tar.bz2": { + "build": "h77bc034_6", + "build_number": 6, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "90d346c48b248d8b3bf21f40af94af15", + "name": "kealib", + "sha256": "78c09e6118f3eea79d03cb8fad0a8f93fc0fe33af91eed62c0c590b2f433fc1a", + "size": 174246, + "subdir": "linux-64", + "timestamp": 1526039819783, + "version": "1.4.7" + }, + "kealib-1.4.7-h79811e5_5.tar.bz2": { + "build": "h79811e5_5", + "build_number": 5, + "depends": [ + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "6f05be5e2b9442b954578dc17c7fbf52", + "name": "kealib", + "sha256": "a166a319218c3d13df044943e4f55b4cb005d1b20afceda8ee79d0df38ff82c3", + "size": 174548, + "subdir": "linux-64", + "timestamp": 1511297631757, + "version": "1.4.7" + }, + "kealib-1.4.7-hbc776fa_4.tar.bz2": { + "build": "hbc776fa_4", + "build_number": 4, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "c8418944ac83bc1bcfc6b893c5bd700f", + "name": "kealib", + "sha256": "af53a87ffb334d95ffc2baf238c35d49259e59700cefce5d94def3fb5eda2945", + "size": 174663, + "subdir": "linux-64", + "timestamp": 1509379010164, + "version": "1.4.7" + }, + "kealib-1.4.7-hd0c454d_6.tar.bz2": { + "build": "hd0c454d_6", + "build_number": 6, + "depends": [ + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "8a9b4bbf763e15f769ff2aeddb9cb690", + "name": "kealib", + "sha256": "59f8afcb895f4d801451736dd5d03878cde91eee15029eb48289cc91e01558a1", + "size": 179626, + "subdir": "linux-64", + "timestamp": 1545404578691, + "version": "1.4.7" + }, + "kealib-1.4.7-hd1b091a_4.tar.bz2": { + "build": "hd1b091a_4", + "build_number": 4, + "depends": [ + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "0ec12e34cd3c9487cef14bdac128f07e", + "name": "kealib", + "sha256": "397abcc6979975053bc7a85655f98e99c02d1b09458611de0fa9d3e5ffd706d9", + "size": 174442, + "subdir": "linux-64", + "timestamp": 1509379009228, + "version": "1.4.7" + }, + "kealib-1.5.0-hd940352_0.tar.bz2": { + "build": "hd940352_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3cd2524c55e52f9ad16aa247b0dc63b5", + "name": "kealib", + "sha256": "4f0c8e1196707252b9699166636b7fac3cf4dd19e08782d12142d4c5b5196d08", + "size": 193515, + "subdir": "linux-64", + "timestamp": 1674215888200, + "version": "1.5.0" + }, + "keras-2.0.8-py27hd1b5a5b_0.tar.bz2": { + "build": "py27hd1b5a5b_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "983e54fedb074901cd8677c70bf06026", + "name": "keras", + "namespace": "python", + "sha256": "7fb73e5a99b3f7936494ad1092dc8768d5497674faf297bb7e2597750f68e387", + "size": 419795, + "subdir": "linux-64", + "timestamp": 1508952999367, + "version": "2.0.8" + }, + "keras-2.0.8-py35h4bddecc_0.tar.bz2": { + "build": "py35h4bddecc_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db32b9d0813b622452c6de5288ffe930", + "name": "keras", + "namespace": "python", + "sha256": "04199ada2bbd0f7c5971ce18d98ae69fbaed8b762d1528248d83afb16ff50947", + "size": 430948, + "subdir": "linux-64", + "timestamp": 1508953001103, + "version": "2.0.8" + }, + "keras-2.0.8-py36hc0b6f7c_0.tar.bz2": { + "build": "py36hc0b6f7c_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a5f545e6f209593fc6afdc01aeb42f1", + "name": "keras", + "namespace": "python", + "sha256": "c388d0b705544275dd107ec41fa51b6396a0f380ceb95df8780afcd3d8d39912", + "size": 428411, + "subdir": "linux-64", + "timestamp": 1508953071686, + "version": "2.0.8" + }, + "keras-2.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a9602ea52c7a3f65c63941d32457110", + "name": "keras", + "namespace": "python", + "sha256": "32d1c6bba3ccfcd96c39cea2657481df929b96d65ca76ff34ed9cba960df583c", + "size": 458199, + "subdir": "linux-64", + "timestamp": 1515179977234, + "version": "2.1.2" + }, + "keras-2.1.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b30f68dcc8c0445ab08a8f7701147fdf", + "name": "keras", + "namespace": "python", + "sha256": "b482a136bef18c5e1d99b2ca9d0e2801b80f8ef69fbb6c1b8512bba3ff8c35d1", + "size": 468518, + "subdir": "linux-64", + "timestamp": 1515180000850, + "version": "2.1.2" + }, + "keras-2.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8330d71cf44dc5e74c89ca7472ae9116", + "name": "keras", + "namespace": "python", + "sha256": "69a291e7fa948d5cea66ff3ca91f43b68ec7aa587a8eaeb70006444abca588b7", + "size": 463567, + "subdir": "linux-64", + "timestamp": 1515179993965, + "version": "2.1.2" + }, + "keras-2.1.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f7efec6077ac19d24746142a29ce5053", + "name": "keras", + "namespace": "python", + "sha256": "791b8abc926b849586ca27874e48ebdc3c1b4046bba2bba5798591d08490a8f3", + "size": 479654, + "subdir": "linux-64", + "timestamp": 1516651576337, + "version": "2.1.3" + }, + "keras-2.1.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e8555e8e07e2ca2cafef6a18dced565", + "name": "keras", + "namespace": "python", + "sha256": "c7189183aa570bc699e2af57395d1084e2ba19294f7ba4a3cd12977d7524ca47", + "size": 486487, + "subdir": "linux-64", + "timestamp": 1516651595794, + "version": "2.1.3" + }, + "keras-2.1.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2d3d8e0e7a434a95eafecfec9fa431e", + "name": "keras", + "namespace": "python", + "sha256": "22fdc03cec557fc8975b6adb9570c176795b9030c83641db13db34daab0a31c0", + "size": 486539, + "subdir": "linux-64", + "timestamp": 1516651602800, + "version": "2.1.3" + }, + "keras-2.1.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "59bc1efe00662eaf9aeb5afca3413026", + "name": "keras", + "namespace": "python", + "sha256": "cc6990458fd5af59d1c6d0f8339e4bb527fac5f6a12f6fadace6b45031a32274", + "size": 484211, + "subdir": "linux-64", + "timestamp": 1519752809947, + "version": "2.1.4" + }, + "keras-2.1.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1fab6e001018974b64c91b6d3da74f6", + "name": "keras", + "namespace": "python", + "sha256": "e0215e929e4f069ea14dff8bd5780b9cc92e7b1a3d456201093e56ed7ba8ddbd", + "size": 491917, + "subdir": "linux-64", + "timestamp": 1519752834691, + "version": "2.1.4" + }, + "keras-2.1.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31e76da89bb727c48ac239cfdb152387", + "name": "keras", + "namespace": "python", + "sha256": "f9a9ba22da35e8bd248dfa0abbff43d1c74397a0ab310f35531808d3fbbeb466", + "size": 491251, + "subdir": "linux-64", + "timestamp": 1519752802685, + "version": "2.1.4" + }, + "keras-2.1.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b85d385a0541a69b888fba6361e9400b", + "name": "keras", + "namespace": "python", + "sha256": "ed3de561171fdc426897233282c774b3f854223b4ab5e24bcd4ad664fc7acb2f", + "size": 501326, + "subdir": "linux-64", + "timestamp": 1521484643022, + "version": "2.1.5" + }, + "keras-2.1.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64161c66b59b539fade5480e8acf83de", + "name": "keras", + "namespace": "python", + "sha256": "b11556f27720bd3bf3b96de7f36be305992373275e6907e988245c837b4cff5d", + "size": 508018, + "subdir": "linux-64", + "timestamp": 1521484732468, + "version": "2.1.5" + }, + "keras-2.1.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f0bba78cf0db6812d7ce0b3101c81ada", + "name": "keras", + "namespace": "python", + "sha256": "2625e01200b75f4ab09369df8edf80df5b8f0a95c39bce1a6748e1c42ef4577f", + "size": 501753, + "subdir": "linux-64", + "timestamp": 1521484738304, + "version": "2.1.5" + }, + "keras-2.1.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "260f1cf79801d992483a690be04a2aed", + "name": "keras", + "namespace": "python", + "sha256": "d914600e67376206e8f80dd79b11cb55cc3098332173ff4881d62620416768df", + "size": 511530, + "subdir": "linux-64", + "timestamp": 1527628588238, + "version": "2.1.6" + }, + "keras-2.1.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11621f4157ef45efe82328ab0854b059", + "name": "keras", + "namespace": "python", + "sha256": "8ccba826e27be363d4165381657b80491a86155ce11f95c6d4ce91dc1a666c13", + "size": 518335, + "subdir": "linux-64", + "timestamp": 1527628602976, + "version": "2.1.6" + }, + "keras-2.1.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "221bc6efe20603c6af95cd9e58d68997", + "name": "keras", + "namespace": "python", + "sha256": "f1196745a85596c896a3b8820bc8526cdd3d18eecd6f717086ef74e92353f359", + "size": 511616, + "subdir": "linux-64", + "timestamp": 1527628614296, + "version": "2.1.6" + }, + "keras-2.10.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.10.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "4c157b8ad12741e7e32a9388747e0890", + "name": "keras", + "namespace": "python", + "sha256": "e26ed0b0b2c759eb39c4e7fed135a00f3ec490d264797c9538614b0dbf7a939a", + "size": 2182116, + "subdir": "linux-64", + "timestamp": 1666889663660, + "version": "2.10.0" + }, + "keras-2.10.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.10.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "91eda698178ca0c2e4e05b9b72c77e7c", + "name": "keras", + "namespace": "python", + "sha256": "8db00de967caa17a3cf52ad5d5829f310db8ae7dacf498c3f55be1aef42685a0", + "size": 2161555, + "subdir": "linux-64", + "timestamp": 1666889754798, + "version": "2.10.0" + }, + "keras-2.10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.10.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "4e12bae8455aa57ce1909f5e868dc956", + "name": "keras", + "namespace": "python", + "sha256": "9ee2b4cedc681739ba9bc54e81f1282e47d6b37548052bf04618b5ec50712f82", + "size": 2169462, + "subdir": "linux-64", + "timestamp": 1666889613052, + "version": "2.10.0" + }, + "keras-2.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.10.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "79b24a572aeb3e8083008162e3f8779a", + "name": "keras", + "namespace": "python", + "sha256": "11910bcb8ecdb35d4b1e2e5ad339b74a26eef29e7be827f3599a87e7c90ee1fc", + "size": 2165000, + "subdir": "linux-64", + "timestamp": 1666889707655, + "version": "2.10.0" + }, + "keras-2.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.11.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "923f1a29f7bd8ebafcda049e71ee4437", + "name": "keras", + "namespace": "python", + "sha256": "c63c4545534cc5558653954c3029507821e3a2c7458164cc7de5b1ced22f29c9", + "size": 2197448, + "subdir": "linux-64", + "timestamp": 1678126533487, + "version": "2.11.0" + }, + "keras-2.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.11.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "b57910b4b4a5e505dd8ce37759318e65", + "name": "keras", + "namespace": "python", + "sha256": "2b42956e799139bd4060a3dd15fb128aa4db95310c28cf606fae2fa22b8c7acd", + "size": 2170326, + "subdir": "linux-64", + "timestamp": 1678126568175, + "version": "2.11.0" + }, + "keras-2.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.11.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "2e35280efdbe0ff16ce079ef93b1f06e", + "name": "keras", + "namespace": "python", + "sha256": "02bd57c08283742d697c2c762c48c2b39f5e1e8a85f5cd7e98bd9073da516266", + "size": 2178992, + "subdir": "linux-64", + "timestamp": 1678126499316, + "version": "2.11.0" + }, + "keras-2.2.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "keras-base 2.2.0.*", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e84f39bd5b471a0f2c8cac40ba8117b", + "name": "keras", + "namespace": "python", + "sha256": "27c58f81fe720dadf5a7f0585f3a64582ac03f57a7f7dee3deac28c9454e44d0", + "size": 5756, + "subdir": "linux-64", + "timestamp": 1529076397295, + "version": "2.2.0" + }, + "keras-2.2.2-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "keras-base 2.2.2.*", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "26885487cb928b4c550989f0df678c44", + "name": "keras", + "namespace": "python", + "sha256": "571128df7969b8c1cce5d52cd590286901e54f3e2ed20814e3b4c76f37cee985", + "size": 5656, + "subdir": "linux-64", + "timestamp": 1533138374255, + "version": "2.2.2" + }, + "keras-2.2.4-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "keras-base 2.2.4.*", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e7dcdcb4fa17daee8382dddbe7887f78", + "name": "keras", + "namespace": "python", + "sha256": "1a916c1e283c48f104e74f45331fac43ea0ba83787c1ccddaace8d0a23def150", + "size": 5255, + "subdir": "linux-64", + "timestamp": 1539019786931, + "version": "2.2.4" + }, + "keras-2.3.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "keras-base 2.3.1.*", + "tensorflow" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ac6ec88833a7bb223ec337aa2716d42", + "name": "keras", + "namespace": "python", + "sha256": "432c85c0e4614a46dfae1f543146b21d5b2a683b7b621b8429c98826b6b7842f", + "size": 11902, + "subdir": "linux-64", + "timestamp": 1582144378752, + "version": "2.3.1" + }, + "keras-2.8.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.10,<3.11.0a0", + "pyyaml", + "tensorflow-base 2.8.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fade83f20d7dfe18c0c7d5533e8f5470", + "name": "keras", + "namespace": "python", + "sha256": "2ecd9ce85bd13601c280cd50d469e8b3f3f855f519daf7ed6ccecf71b39a2c75", + "size": 1944264, + "subdir": "linux-64", + "timestamp": 1659009025922, + "version": "2.8.0" + }, + "keras-2.8.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.7,<3.8.0a0", + "pyyaml", + "tensorflow-base 2.8.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0da3a2718d396da5201ac3dfaf021acc", + "name": "keras", + "namespace": "python", + "sha256": "a14db6dedcac6223a5712a0172c3014635786ebf7483ee950478ba3388a0beeb", + "size": 1924885, + "subdir": "linux-64", + "timestamp": 1659009046203, + "version": "2.8.0" + }, + "keras-2.8.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.8,<3.9.0a0", + "pyyaml", + "tensorflow-base 2.8.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5040dd6baf9b2ae2c90c5b3dd77aee59", + "name": "keras", + "namespace": "python", + "sha256": "934150e9f881c2f72315e8bb0c98828028eeaf5020e179828f4df81e22ca8906", + "size": 1927034, + "subdir": "linux-64", + "timestamp": 1659009004716, + "version": "2.8.0" + }, + "keras-2.8.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.9,<3.10.0a0", + "pyyaml", + "tensorflow-base 2.8.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e880be433ac373e4c61d97fc057c4804", + "name": "keras", + "namespace": "python", + "sha256": "07f1f71776df677bb76056a6f18054a70ff4f5c1266412d9147ad734fa3a6ce9", + "size": 1929930, + "subdir": "linux-64", + "timestamp": 1659009066974, + "version": "2.8.0" + }, + "keras-2.9.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.9.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.10,<3.11.0a0", + "pyyaml", + "scipy 1.7.3.*" + ], + "license": "Apache-2.0", + "md5": "d28e9bc6bd30a53c0a6b027ec0f86ded", + "name": "keras", + "namespace": "python", + "sha256": "c36e74ecbc76018fbec9b9f22922042c3567e7db63bb7829888c35b9fe280483", + "size": 2132872, + "subdir": "linux-64", + "timestamp": 1661556291615, + "version": "2.9.0" + }, + "keras-2.9.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.9.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy 1.7.3.*" + ], + "license": "Apache-2.0", + "md5": "f8b3376d484866bf1b15ca876d95960c", + "name": "keras", + "namespace": "python", + "sha256": "7e12ca0846a45304128043f0ab31352540619be880328aa89ae205c0b7bf11c3", + "size": 2103163, + "subdir": "linux-64", + "timestamp": 1661556329112, + "version": "2.9.0" + }, + "keras-2.9.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.9.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.8,<3.9.0a0", + "pyyaml", + "scipy 1.7.3.*" + ], + "license": "Apache-2.0", + "md5": "7e71d7123733bdfe9e4423777d9bb7ac", + "name": "keras", + "namespace": "python", + "sha256": "9ddf1ea4d6198c654db3baee120f419af523302a2bb8050dac93a554db17e7e4", + "size": 2114085, + "subdir": "linux-64", + "timestamp": 1661556254881, + "version": "2.9.0" + }, + "keras-2.9.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.9.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.9,<3.10.0a0", + "pyyaml", + "scipy 1.7.3.*" + ], + "license": "Apache-2.0", + "md5": "735ed7efc60641590ffcce5814b008a9", + "name": "keras", + "namespace": "python", + "sha256": "bf6a8833389e57a18fd1dd2423efd10f0e27d31e8d06fe2d90fbaa9f06251fc6", + "size": 2113904, + "subdir": "linux-64", + "timestamp": 1661556367767, + "version": "2.9.0" + }, + "keras-applications-1.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a2287f89e33ec9fbda04ed93b16d66da", + "name": "keras-applications", + "sha256": "6a87a74e6337d8ef7a2bec9396e676fe0166403c8f7743ea136cb6b8ba1de3d3", + "size": 48528, + "subdir": "linux-64", + "timestamp": 1529074359080, + "version": "1.0.2" + }, + "keras-applications-1.0.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3939bc8fcef3168fcd3132aa2369af78", + "name": "keras-applications", + "sha256": "aefa75fab16b102973396d6a7fff1ea1a1b0475e9e0cf9e2c31893782374b03d", + "size": 48748, + "subdir": "linux-64", + "timestamp": 1529074482497, + "version": "1.0.2" + }, + "keras-applications-1.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de4ef2ac633daf1fa9db548790be905c", + "name": "keras-applications", + "sha256": "f971054d0a9effe06f922ecb3695fdeac55b238d5450052ca1a0878ef578dda1", + "size": 48616, + "subdir": "linux-64", + "timestamp": 1529074342790, + "version": "1.0.2" + }, + "keras-applications-1.0.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "73aeb79c1551638a28fb671f192c2882", + "name": "keras-applications", + "sha256": "a552a81da1907d08c25d3b259f87c422bb03c0ff1d3054563b0d94d48a9949dc", + "size": 48805, + "subdir": "linux-64", + "timestamp": 1533108212107, + "version": "1.0.4" + }, + "keras-applications-1.0.4-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa18193e16b9bc0dab1a6d8b060edc07", + "name": "keras-applications", + "sha256": "f9cf899e4e4b9098b6c0d1d9a2b6f5e28d240365b4e4b4508094d5a2b3634def", + "size": 48343, + "subdir": "linux-64", + "timestamp": 1534973224051, + "version": "1.0.4" + }, + "keras-applications-1.0.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e5b85e868085e06d3d4b22fd6e19c239", + "name": "keras-applications", + "sha256": "b9b27d0f7600ade63eed23680cb4159c906c69d60e68df9cd059ff9574aed3c4", + "size": 48924, + "subdir": "linux-64", + "timestamp": 1533108227375, + "version": "1.0.4" + }, + "keras-applications-1.0.4-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "047b7b7b5c373148e1369869cf5c96cb", + "name": "keras-applications", + "sha256": "7319421961b3d40dbaa5d520a4eeebac0db16a211bb6ca33ccb048212607842b", + "size": 48471, + "subdir": "linux-64", + "timestamp": 1534973211581, + "version": "1.0.4" + }, + "keras-applications-1.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "355ab0804dce700dc1f54d732f5b1646", + "name": "keras-applications", + "sha256": "571a6ca2e2c25056b4c550c2bd40563fdb6d98669979a37023b5bc4376f58a28", + "size": 48848, + "subdir": "linux-64", + "timestamp": 1533108220694, + "version": "1.0.4" + }, + "keras-applications-1.0.4-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9e9d54aef6a7b17e6456fd8f3d48d1d", + "name": "keras-applications", + "sha256": "1f952d71ca08fc9723c500757008900d40af568cdc45446ec12cdf445730dbd9", + "size": 48392, + "subdir": "linux-64", + "timestamp": 1534973121293, + "version": "1.0.4" + }, + "keras-applications-1.0.4-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f5afe3cc96c56481c9f1fa230e293a1a", + "name": "keras-applications", + "sha256": "473c97a7f3b2fb790c4d7b1bacc80f75d02fb0551b716d9db6d1bf72a229720b", + "size": 48005, + "subdir": "linux-64", + "timestamp": 1534973164791, + "version": "1.0.4" + }, + "keras-applications-1.0.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d943598c47eb9672e8b5bf3383887cb2", + "name": "keras-applications", + "sha256": "b9347f0679a38088b7e30038d4c794c061726f0b81cfde987347615bc582e216", + "size": 49827, + "subdir": "linux-64", + "timestamp": 1538424962758, + "version": "1.0.6" + }, + "keras-applications-1.0.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "094bd85e74596f5eb17c37a8f96b43d6", + "name": "keras-applications", + "sha256": "ffbef8000edbb1d96c5e5e670e7c8354f5396feae13f0ff5cd34ea343bf99c4b", + "size": 49864, + "subdir": "linux-64", + "timestamp": 1538425005197, + "version": "1.0.6" + }, + "keras-applications-1.0.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc393ae0226a9e68ab2483a1c0ca12f6", + "name": "keras-applications", + "sha256": "943e22ce19fe04f823b36af6b12f448ebf29a44c8d2ceb14550689df105b554e", + "size": 49521, + "subdir": "linux-64", + "timestamp": 1538424928230, + "version": "1.0.6" + }, + "keras-base-2.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "keras 2.2.0" + ], + "depends": [ + "h5py", + "keras-applications 1.0.2.*", + "keras-preprocessing 1.0.1.*", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "da254818915440293cf23df342a71387", + "name": "keras-base", + "sha256": "f87801abcf4743770f61ed22930a3dbbd4e780bbcf2e1815bc7d3618b1664268", + "size": 442149, + "subdir": "linux-64", + "timestamp": 1529076390809, + "version": "2.2.0" + }, + "keras-base-2.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "keras 2.2.0" + ], + "depends": [ + "h5py", + "keras-applications 1.0.2.*", + "keras-preprocessing 1.0.1.*", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "98ca1a2e14aeca1d260aafa0c47f0880", + "name": "keras-base", + "sha256": "da3078a871efb06b69b457e1f70e6f3d3a43ac6321c4390e3ffc2ca2d87a2c6d", + "size": 456089, + "subdir": "linux-64", + "timestamp": 1529076283729, + "version": "2.2.0" + }, + "keras-base-2.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras 2.2.0" + ], + "depends": [ + "h5py", + "keras-applications 1.0.2.*", + "keras-preprocessing 1.0.1.*", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "fa171c1b3a5d1396ee88511ad1778572", + "name": "keras-base", + "sha256": "c9d483f8bd020ad378c9a8dbae702327ed5682a7479f4e259fb2fa38621f58a1", + "size": 460456, + "subdir": "linux-64", + "timestamp": 1529076344151, + "version": "2.2.0" + }, + "keras-base-2.2.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "keras 2.2.2" + ], + "depends": [ + "h5py", + "keras-applications 1.0.4.*", + "keras-preprocessing 1.0.2.*", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "141d44b9b7fded5d81377fd7e94153de", + "name": "keras-base", + "sha256": "c631db19bdd2bef83281b8f39362b5e92aebc72d1b1333546a1f45b14383d223", + "size": 440428, + "subdir": "linux-64", + "timestamp": 1533138746296, + "version": "2.2.2" + }, + "keras-base-2.2.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "keras 2.2.2" + ], + "depends": [ + "h5py", + "keras-applications 1.0.4.*", + "keras-preprocessing 1.0.2.*", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "676c09b23225d1e940d0100d0d2e5d05", + "name": "keras-base", + "sha256": "010be7b10c4a06f43dfb8d7f44cc26b6f0b15082e40ea53f51e5659eaad8ab34", + "size": 453295, + "subdir": "linux-64", + "timestamp": 1533138980666, + "version": "2.2.2" + }, + "keras-base-2.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras 2.2.2" + ], + "depends": [ + "h5py", + "keras-applications 1.0.4.*", + "keras-preprocessing 1.0.2.*", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "d374db4de7a4c658a4e909b4d8582aa8", + "name": "keras-base", + "sha256": "a2efad9a12e97bc228953e964e2d3c474141ee6cbb038901fe7eb247d4be474c", + "size": 456020, + "subdir": "linux-64", + "timestamp": 1533138372434, + "version": "2.2.2" + }, + "keras-base-2.2.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "keras 2.2.4" + ], + "depends": [ + "h5py", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "40bdf9374ccb820a6145895070fd98db", + "name": "keras-base", + "sha256": "e1242bf7698f2d301e4789341c54597bf5e6bdbfd4a5eca418af9397ede3baa8", + "size": 456104, + "subdir": "linux-64", + "timestamp": 1539019773289, + "version": "2.2.4" + }, + "keras-base-2.2.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras 2.2.4" + ], + "depends": [ + "h5py", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "c7690004160987f271768a70d265fd09", + "name": "keras-base", + "sha256": "22be0a3c1706fdb3c7a4f1bc685b59e464d61424a2bdf1b45d16c1d4afc1a081", + "size": 467805, + "subdir": "linux-64", + "timestamp": 1539019785472, + "version": "2.2.4" + }, + "keras-base-2.2.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "keras 2.2.4" + ], + "depends": [ + "h5py", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "numpy >=1.9.1", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "3d7f1db8525a08779a45ff8772854b3c", + "name": "keras-base", + "sha256": "436db12a2a242a28a8e8f9ce4fe7358c9969d08b25ee99915846542078cd12e8", + "size": 501079, + "subdir": "linux-64", + "timestamp": 1554743173443, + "version": "2.2.4" + }, + "keras-base-2.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras 2.3.1" + ], + "depends": [ + "h5py", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "0553522b57f5d3b1b96a6bd5d180deff", + "name": "keras-base", + "sha256": "72f28d4f8c3bb7f106f2569dbdef2271c9aeabd7e8deab1e3e0396bce526b444", + "size": 613274, + "subdir": "linux-64", + "timestamp": 1582144353884, + "version": "2.3.1" + }, + "keras-base-2.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "keras 2.3.1" + ], + "depends": [ + "h5py", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "numpy >=1.9.1", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "7c9bd761542d65cdb287db37ee33775d", + "name": "keras-base", + "sha256": "fd8a24035e96f88d9d5b007aac54f532ca085a19ff8fb8aac74914eecf498345", + "size": 612011, + "subdir": "linux-64", + "timestamp": 1582144375962, + "version": "2.3.1" + }, + "keras-base-2.3.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "keras 2.3.1" + ], + "depends": [ + "h5py", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "numpy >=1.9.1", + "python >=3.8,<3.9.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "ae4ecda8cb0c09be4b1072c63c19e025", + "name": "keras-base", + "sha256": "13efd7fdce9a5bbf6dbbd615db1cd1f202597e1ca50277ec7e661aeed6206b34", + "size": 614700, + "subdir": "linux-64", + "timestamp": 1590699728675, + "version": "2.3.1" + }, + "keras-gpu-2.0.8-py27hde4dcf2_0.tar.bz2": { + "build": "py27hde4dcf2_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71bcc8ad86e1c6eac7b9c8dea72d6462", + "name": "keras-gpu", + "namespace": "python", + "sha256": "5efe51c6ab8d3062c10928066f093f08eaedfaea8bb56b3fa919dad7c116eafb", + "size": 419255, + "subdir": "linux-64", + "timestamp": 1508953006444, + "version": "2.0.8" + }, + "keras-gpu-2.0.8-py35ha2fb4ba_0.tar.bz2": { + "build": "py35ha2fb4ba_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f7a4571e5473f7f9a1ad03f991bb6ae7", + "name": "keras-gpu", + "namespace": "python", + "sha256": "afeaa31411b950fa7904e777c674513cfb5e3dcc422830b44ec4a27c3c9f2c57", + "size": 430107, + "subdir": "linux-64", + "timestamp": 1508953022004, + "version": "2.0.8" + }, + "keras-gpu-2.0.8-py36h0585f72_0.tar.bz2": { + "build": "py36h0585f72_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "900a25f647f05d5985e3bb90a925c4ac", + "name": "keras-gpu", + "namespace": "python", + "sha256": "7099b3691aee103e60dcc8b6f7334aa07d35d24cfc82306a42f714d6dfd45884", + "size": 427580, + "subdir": "linux-64", + "timestamp": 1508953072153, + "version": "2.0.8" + }, + "keras-gpu-2.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "953e884652767b63dc517a9010010f5c", + "name": "keras-gpu", + "namespace": "python", + "sha256": "a57aa409a0b8e932f78af5878161ef18c3188565503a0041d9e5d41d57932651", + "size": 458179, + "subdir": "linux-64", + "timestamp": 1516650822522, + "version": "2.1.2" + }, + "keras-gpu-2.1.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "91856efc7f060492937ad13cdf69bc1e", + "name": "keras-gpu", + "namespace": "python", + "sha256": "c95e7ad98a8a7a8040db253e1c882e6ef6a9bde90e730a9b1a1301a6e9176b59", + "size": 468608, + "subdir": "linux-64", + "timestamp": 1516650836662, + "version": "2.1.2" + }, + "keras-gpu-2.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "707ee56761ae8acd26fb8f8b286b9f98", + "name": "keras-gpu", + "namespace": "python", + "sha256": "61ed2980ddfcdbb674579d1ca24870e6bcecc6026c8b1a63bb4592871446ed4f", + "size": 463707, + "subdir": "linux-64", + "timestamp": 1516650839818, + "version": "2.1.2" + }, + "keras-gpu-2.1.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92dc6772bb6a5eda10fea5e367b417b6", + "name": "keras-gpu", + "namespace": "python", + "sha256": "c6c733f4c67ffb6bf495dc0297821ba1f098e4431450f4f4d8d14d541cd62c84", + "size": 479214, + "subdir": "linux-64", + "timestamp": 1516651962619, + "version": "2.1.3" + }, + "keras-gpu-2.1.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a880f0227f8f0b796c1eed3fbe48c8df", + "name": "keras-gpu", + "namespace": "python", + "sha256": "d7eb361af0bd0e989c909f02afc4128672108582d330c1d0047624049fec9480", + "size": 486435, + "subdir": "linux-64", + "timestamp": 1516651994826, + "version": "2.1.3" + }, + "keras-gpu-2.1.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "856e5923ae28101f8fb7e3a7e4fdafe4", + "name": "keras-gpu", + "namespace": "python", + "sha256": "3f6702cdf2aecf7d258f04c392841cdcb79dcef35179aa7089626aff5c1820bb", + "size": 486493, + "subdir": "linux-64", + "timestamp": 1516652135543, + "version": "2.1.3" + }, + "keras-gpu-2.1.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a50ab96f5f5e5c7c75a14d0211393fc", + "name": "keras-gpu", + "namespace": "python", + "sha256": "8f543a6f3d41207adcefd9893f98a84b83b5e53c1fcc9a46cf1dca25f9e28501", + "size": 484345, + "subdir": "linux-64", + "timestamp": 1519752874758, + "version": "2.1.4" + }, + "keras-gpu-2.1.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62a56a3766b0553af3a4de9ba9733383", + "name": "keras-gpu", + "namespace": "python", + "sha256": "020958635c49395cd1b1d11f57177530deaa36197d48898ac839b3f7d61dd7ac", + "size": 491569, + "subdir": "linux-64", + "timestamp": 1519752875449, + "version": "2.1.4" + }, + "keras-gpu-2.1.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e31bb1105830f3291a29ac0e2692d373", + "name": "keras-gpu", + "namespace": "python", + "sha256": "93d8ae390f523bc41cae1e36cba9cdda98accccaeef3b81d5569aeff5fbc9b57", + "size": 491118, + "subdir": "linux-64", + "timestamp": 1519752865485, + "version": "2.1.4" + }, + "keras-gpu-2.1.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "315654d23835696cfc38df50a1bdaa93", + "name": "keras-gpu", + "namespace": "python", + "sha256": "7ce4a6ca15ed768e87087c3c2fc68f0ca431e528945c7a13e085ddad99b94c7e", + "size": 501216, + "subdir": "linux-64", + "timestamp": 1521485514807, + "version": "2.1.5" + }, + "keras-gpu-2.1.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ed306cf9f7bcdd1322d3e36c308b7ab", + "name": "keras-gpu", + "namespace": "python", + "sha256": "ac09e27dfffbdfeccb58112cdf44accc2407a64f4605181b9e53dfa34ab52ec4", + "size": 508334, + "subdir": "linux-64", + "timestamp": 1521485206438, + "version": "2.1.5" + }, + "keras-gpu-2.1.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "211cc27d24b5a54f39d5031fff5a2455", + "name": "keras-gpu", + "namespace": "python", + "sha256": "067b79f7a450005030886fedf83b8cc7bc1cf1b3ca461006e9183781e8b9ece2", + "size": 501726, + "subdir": "linux-64", + "timestamp": 1521485209262, + "version": "2.1.5" + }, + "keras-gpu-2.1.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95e79a695e396e4c383be9fb672478dc", + "name": "keras-gpu", + "namespace": "python", + "sha256": "79e9eb1a721c1cf5d5142d4c450ec21001423099ab22e170e324eadbb67f07f5", + "size": 511130, + "subdir": "linux-64", + "timestamp": 1527633627177, + "version": "2.1.6" + }, + "keras-gpu-2.1.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5bed897fb7954e72851b70c9c363f010", + "name": "keras-gpu", + "namespace": "python", + "sha256": "32e807004771debee4ed78f98e7e60a105b4235de6d946a4fc5c422665fa1f5a", + "size": 518476, + "subdir": "linux-64", + "timestamp": 1527633658064, + "version": "2.1.6" + }, + "keras-gpu-2.1.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "333325314995d5cc86638e5ff09d61b1", + "name": "keras-gpu", + "namespace": "python", + "sha256": "ef7eb755ce1809d90cd0d567bdada6cef8db9db4475f5e0dbf0663406c225ed5", + "size": 511656, + "subdir": "linux-64", + "timestamp": 1527633631545, + "version": "2.1.6" + }, + "keras-gpu-2.2.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "keras-base 2.2.0.*", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bad0f8f821ad5ad014b7ab6f4bd9f4b3", + "name": "keras-gpu", + "namespace": "python", + "sha256": "10a4ddec7a591aa458fad8b5ca865a758ab2ab451789c988afb178ba63ee9387", + "size": 5753, + "subdir": "linux-64", + "timestamp": 1529076398075, + "version": "2.2.0" + }, + "keras-gpu-2.2.2-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "keras-base 2.2.2.*", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3aa23d6a1eac2c163c2dfb52a880ea7a", + "name": "keras-gpu", + "namespace": "python", + "sha256": "fe488f0fe3fc0570424fa5e8eca6739c8e300c6dce0571033cdd85d715190a49", + "size": 5665, + "subdir": "linux-64", + "timestamp": 1533138374640, + "version": "2.2.2" + }, + "keras-gpu-2.2.4-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "keras-base 2.2.4.*", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e377af7527b9fa89ade7e1ce520aab8e", + "name": "keras-gpu", + "namespace": "python", + "sha256": "0a2fcfc86e12d72cdec588be5fec7fe847bf4f9d78a55d09e0c1bf964d3a2b33", + "size": 5259, + "subdir": "linux-64", + "timestamp": 1539019787297, + "version": "2.2.4" + }, + "keras-gpu-2.3.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "keras-base 2.3.1.*", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "55f9352574e8e3e3523d4e990f226dbe", + "name": "keras-gpu", + "namespace": "python", + "sha256": "d46056448d0fc6b128561e34852cf39b1d665ebb2be0080cbbec532cc5b16250", + "size": 11897, + "subdir": "linux-64", + "timestamp": 1582144379857, + "version": "2.3.1" + }, + "keras-ocr-0.8.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "editdistance", + "efficientnet 1.0.0", + "essential_generators", + "fonttools", + "imgaug", + "pyclipper", + "python >=3.10,<3.11.0a0", + "shapely", + "tensorflow >=2.0", + "tqdm", + "validators" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e40f03063cff941ab912aeaf90119cbc", + "name": "keras-ocr", + "sha256": "2496d9df32308bbf2de9cd8a58a9df38d14031e9c71be09087fe5abe2fef1045", + "size": 73760, + "subdir": "linux-64", + "timestamp": 1640815728486, + "version": "0.8.5" + }, + "keras-ocr-0.8.5-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "editdistance", + "efficientnet 1.0.0", + "essential_generators", + "fonttools", + "imgaug", + "pyclipper", + "python >=3.6,<3.7.0a0", + "shapely", + "tensorflow >=2.0", + "tqdm", + "validators" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ea78812d093e80871b1898fdf66ab9c", + "name": "keras-ocr", + "sha256": "8194665a15bab1079e8c7d5e9aa17c2da2707059c7d43cf1ccc56cbc2e33702b", + "size": 266568, + "subdir": "linux-64", + "timestamp": 1605289713743, + "version": "0.8.5" + }, + "keras-ocr-0.8.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "editdistance", + "efficientnet 1.0.0", + "essential_generators", + "fonttools", + "imgaug", + "pyclipper", + "python >=3.7,<3.8.0a0", + "shapely", + "tensorflow >=2.0", + "tqdm", + "validators" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "159829a64550faa34bfc16f841d0c609", + "name": "keras-ocr", + "sha256": "c90dba9fddf4f17c053866caff26a3dbad5e388b830dfa3063919a97a3244bca", + "size": 260316, + "subdir": "linux-64", + "timestamp": 1605289716575, + "version": "0.8.5" + }, + "keras-preprocessing-1.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d55d97257d1ce0102c204b471cc75421", + "name": "keras-preprocessing", + "sha256": "77fe8a5ced9b2a35eb2d0f42704857b2f51f8e77c47b0aa06fc1e6afe18cca06", + "size": 45214, + "subdir": "linux-64", + "timestamp": 1529074474117, + "version": "1.0.1" + }, + "keras-preprocessing-1.0.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "815e731c419d820247b115514058d129", + "name": "keras-preprocessing", + "sha256": "1141eb665958c9c0733612b7bf4e5bafeab6ae4a285f601cb01cf9bf86cd7d65", + "size": 46028, + "subdir": "linux-64", + "timestamp": 1529074378967, + "version": "1.0.1" + }, + "keras-preprocessing-1.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5e266dcca596b77c08b9c5cfc985f8e", + "name": "keras-preprocessing", + "sha256": "fd2dba59443debd07deec196fbae6de4943ddb1b70b4b3e87eddab7555d954dd", + "size": 45928, + "subdir": "linux-64", + "timestamp": 1529074504538, + "version": "1.0.1" + }, + "keras-preprocessing-1.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "94463e95d3a6e2b055c6ca8aaa6c65c8", + "name": "keras-preprocessing", + "sha256": "cc61e4898bb15aa01a9f2b4f2a93426b9f1c606e17c5c47d8b4b78c546a02eea", + "size": 46298, + "subdir": "linux-64", + "timestamp": 1533108188555, + "version": "1.0.2" + }, + "keras-preprocessing-1.0.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca1dfeca58ba850d612dc55d50b715df", + "name": "keras-preprocessing", + "sha256": "edd7890c7ab3d8113313f9ecf1690f8b175c0207f484ce7edf127fd57d820c9f", + "size": 46289, + "subdir": "linux-64", + "timestamp": 1534973207466, + "version": "1.0.2" + }, + "keras-preprocessing-1.0.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8cb64d4352c2e651c51becb16997a509", + "name": "keras-preprocessing", + "sha256": "e607b48314c3a3af797caabb4d490290c5c1eb5be9e5610c237ec21588c05a8f", + "size": 47133, + "subdir": "linux-64", + "timestamp": 1533108197212, + "version": "1.0.2" + }, + "keras-preprocessing-1.0.2-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a296e89501bce78b280dcf44b662b5e", + "name": "keras-preprocessing", + "sha256": "69d4a7a10c58bf3bfae2601f39c4eecf2f1f6a68c0b7543a34c5c38847cf0470", + "size": 47174, + "subdir": "linux-64", + "timestamp": 1534973212635, + "version": "1.0.2" + }, + "keras-preprocessing-1.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "654b50fe9a32e2944206cc175dac0acc", + "name": "keras-preprocessing", + "sha256": "9353686737130a5d0be1471517e344044df2a69dc854a6e0ce263d413629f75a", + "size": 46962, + "subdir": "linux-64", + "timestamp": 1533108217816, + "version": "1.0.2" + }, + "keras-preprocessing-1.0.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e79dcbd0a13f266b110f2db1577ed6d2", + "name": "keras-preprocessing", + "sha256": "59347f0cb1bcd620a4253d73fb65bb9862add832fc18623de089cd94a18a3f71", + "size": 46970, + "subdir": "linux-64", + "timestamp": 1534973148997, + "version": "1.0.2" + }, + "keras-preprocessing-1.0.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=3.7,<3.8.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "05970ad1696819f8c5c35d2e1ea90e71", + "name": "keras-preprocessing", + "sha256": "a929ace7f418464d1a32a49217c999d3f34287d6ad914c6f5a477821bd01e1ee", + "size": 47068, + "subdir": "linux-64", + "timestamp": 1534973207447, + "version": "1.0.2" + }, + "keras-preprocessing-1.0.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "635ac23c4218d618c4719b57519b4130", + "name": "keras-preprocessing", + "sha256": "8f1507b78a08eac20f7d4a5997f05d23461f091b0b14c273bd3ee6193e3a9781", + "size": 52553, + "subdir": "linux-64", + "timestamp": 1538424982424, + "version": "1.0.5" + }, + "keras-preprocessing-1.0.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a0372db4212fa9ed1099ddcd2a91c25", + "name": "keras-preprocessing", + "sha256": "c93b801f7675b4390859cbd47aac2ff748c2e2e6fb16cb0f3d00be818a03ab65", + "size": 53230, + "subdir": "linux-64", + "timestamp": 1538425360255, + "version": "1.0.5" + }, + "keras-preprocessing-1.0.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=3.7,<3.8.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df047289792a973a63aa42e60cfa0872", + "name": "keras-preprocessing", + "sha256": "5e2cd1f239a275296f2768142a5e8e5a670c90021a449913d219e2150bef8669", + "size": 53297, + "subdir": "linux-64", + "timestamp": 1538424954137, + "version": "1.0.5" + }, + "keyring-10.4.0-py27h70e99c7_0.tar.bz2": { + "build": "py27h70e99c7_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "md5": "76adeafb86250d8679fb7a5d2e6d28db", + "name": "keyring", + "sha256": "0d3984582335a3e0fdd0261f540746581c8386c1a4acf396d362d5d40eb4e5f5", + "size": 45026, + "subdir": "linux-64", + "timestamp": 1508689966965, + "version": "10.4.0" + }, + "keyring-10.4.0-py35h596fbf2_0.tar.bz2": { + "build": "py35h596fbf2_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Python Software Foundation or MIT", + "md5": "2a1a0ded8ade0976b7c2b589aaa1338f", + "name": "keyring", + "sha256": "cd0761e07a47cfc3df022b50159081168a16ad80012004477c456de1659c3b8a", + "size": 45916, + "subdir": "linux-64", + "timestamp": 1508689968457, + "version": "10.4.0" + }, + "keyring-10.4.0-py36h4fce1c9_0.tar.bz2": { + "build": "py36h4fce1c9_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation or MIT", + "md5": "55ce470da78cbee416a8b78745fb85bf", + "name": "keyring", + "sha256": "ef26c43f3e88ecc71791ab5b4884e4f4c6ebaf18c15982bd46727eccbf0a2dc8", + "size": 45776, + "subdir": "linux-64", + "timestamp": 1508689992612, + "version": "10.4.0" + }, + "keyring-10.5.0-py27h855395d_0.tar.bz2": { + "build": "py27h855395d_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "882b20938442cd055aecbece708a1632", + "name": "keyring", + "sha256": "e94710082e224e8f15a9e23a9572b4bcc6282ac4acb68339ae8fb18ae0df145c", + "size": 45329, + "subdir": "linux-64", + "timestamp": 1511832203907, + "version": "10.5.0" + }, + "keyring-10.5.0-py35hbf6c1c3_0.tar.bz2": { + "build": "py35hbf6c1c3_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "e3007cb616f65abd43632ad0ad58cebc", + "name": "keyring", + "sha256": "bbf3c81a09db1e66168a95cc58e484e3ea043baf659513156728339df15ab5d4", + "size": 46313, + "subdir": "linux-64", + "timestamp": 1511832213563, + "version": "10.5.0" + }, + "keyring-10.5.0-py36h0041fa8_0.tar.bz2": { + "build": "py36h0041fa8_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "ebb753d27c772335c03a53fb8a36db1c", + "name": "keyring", + "sha256": "e9096a6d759d37a78176905bb34d8c641b305d61aae375ea1cd22ccce442236e", + "size": 46148, + "subdir": "linux-64", + "timestamp": 1511832213254, + "version": "10.5.0" + }, + "keyring-11.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "68a4ce12f24e1f336f7e6600e512a8ce", + "name": "keyring", + "sha256": "96f2261b1b251f49402111fa6fca970eb9042fd1f16413af94f3e00eca2c03ac", + "size": 45022, + "subdir": "linux-64", + "timestamp": 1519758157765, + "version": "11.0.0" + }, + "keyring-11.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "89f5503f40f054770095614b62deb664", + "name": "keyring", + "sha256": "9e349fa1fe4b580e1ed29698fb8ea10181ae307730dd1fa523f7714bc535ae21", + "size": 45941, + "subdir": "linux-64", + "timestamp": 1519758239384, + "version": "11.0.0" + }, + "keyring-11.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "29866fb9185dbcdb0d690d0664a1ce42", + "name": "keyring", + "sha256": "1ce8a4ede62cfab9631a749c537b3864539c697a8f00c1592ad9a4cb99759ee0", + "size": 45821, + "subdir": "linux-64", + "timestamp": 1519758120888, + "version": "11.0.0" + }, + "keyring-12.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "8f21f283cdca75835486cb583bb75324", + "name": "keyring", + "sha256": "1a62407367fa66c8ad8386b3739d8530e833d67d2519a0bb8492582c30dc58f6", + "size": 45580, + "subdir": "linux-64", + "timestamp": 1522855493404, + "version": "12.0.0" + }, + "keyring-12.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.5,<3.6.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "f2e55a8dd64fcbd998f7484ac6d5b468", + "name": "keyring", + "sha256": "43182f759ab201510281eea63411b1be695084a27daae5c4eba18b3a16c172cc", + "size": 46412, + "subdir": "linux-64", + "timestamp": 1522855513959, + "version": "12.0.0" + }, + "keyring-12.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "a17e642c9b044e75fca376f31b45b0f7", + "name": "keyring", + "sha256": "bc532836f0aeecfdb8c82ed3c06258d2ece8fca15f886de42f9d3b9e786664ce", + "size": 46293, + "subdir": "linux-64", + "timestamp": 1522855526893, + "version": "12.0.0" + }, + "keyring-12.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "5bf7b040bfc0b378b63bcbf6b84aad4d", + "name": "keyring", + "sha256": "34955985b798fe300907510ceaab26abd44c062d7d7516b604406b73f30d008e", + "size": 45630, + "subdir": "linux-64", + "timestamp": 1523991349355, + "version": "12.0.1" + }, + "keyring-12.0.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.5,<3.6.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "fe639fb6a03ebd2560e99ff2c196589a", + "name": "keyring", + "sha256": "8cb005c6ea38cc2a41bb09fdd00b6952914feaf8cdd312a4285e5ed4104e1b25", + "size": 46521, + "subdir": "linux-64", + "timestamp": 1523991779698, + "version": "12.0.1" + }, + "keyring-12.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "c9886c33024a90b6adf8af1f967f9bc4", + "name": "keyring", + "sha256": "3745e147f064d2165aaf925243ef9f968c5e16aedb669bab9703f7127c0e1f19", + "size": 46392, + "subdir": "linux-64", + "timestamp": 1523991778011, + "version": "12.0.1" + }, + "keyring-12.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "16b225edb4745b41f9189adf673cd641", + "name": "keyring", + "sha256": "48f27036f4e868441b1097155b4ac6b82bd2ac8d61f29be638091eddac248e47", + "size": 45604, + "subdir": "linux-64", + "timestamp": 1527688222798, + "version": "12.2.1" + }, + "keyring-12.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.5,<3.6.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "6aec1a9cddbe2f24037ce391aa805aaf", + "name": "keyring", + "sha256": "6f22a0cb33d2ccf40ce62a0f716b70f007d48c6d4851c112a8b3ee10587134c6", + "size": 46639, + "subdir": "linux-64", + "timestamp": 1527688239064, + "version": "12.2.1" + }, + "keyring-12.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "2f2990068e7deba5eb8d92678c21eabc", + "name": "keyring", + "sha256": "22f11411d417035fa9b4957947525432fd0b8be41c331164f05cae8d98e07685", + "size": 46428, + "subdir": "linux-64", + "timestamp": 1527688209849, + "version": "12.2.1" + }, + "keyring-13.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "e72a6020e2ca111d60fb13451850b5e8", + "name": "keyring", + "sha256": "974933957a95b94b5d21fc993c3d0b90261523b0bb9d8e4db64067fd3ede44da", + "size": 45864, + "subdir": "linux-64", + "timestamp": 1529952753705, + "version": "13.0.0" + }, + "keyring-13.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.5,<3.6.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "fa8f106dc30d16e9f15d741e63e9640d", + "name": "keyring", + "sha256": "bbf72e9127d49829f5443543336d9046b1abcad0bfb982c22451b7b577d6908b", + "size": 46888, + "subdir": "linux-64", + "timestamp": 1529953525524, + "version": "13.0.0" + }, + "keyring-13.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "86f7c9391495bbed1600581304c9f476", + "name": "keyring", + "sha256": "8b48aba41405dcbfe6b7adb17c298d49476db160c3a7bc16ebe8421656669524", + "size": 46788, + "subdir": "linux-64", + "timestamp": 1529953407015, + "version": "13.0.0" + }, + "keyring-13.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "946c8dba79695d81948ec995390f8f03", + "name": "keyring", + "sha256": "68b26d133100d9ec6bb1a02b613b763f84e92c475ea70b1038aaa578d60f9636", + "size": 46820, + "subdir": "linux-64", + "timestamp": 1530898213730, + "version": "13.0.0" + }, + "keyring-13.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "147d823dfb6e9d93dde28abdd2b980bd", + "name": "keyring", + "sha256": "d325b2cf5c263f43deceb0407ad7193d1bacf2d8c48f1517a00cd000850690f0", + "size": 46266, + "subdir": "linux-64", + "timestamp": 1532540690912, + "version": "13.2.1" + }, + "keyring-13.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.5,<3.6.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "0b4138ca5f4dd9317b3df2977ab0d437", + "name": "keyring", + "sha256": "02ee0296a44e0afcd058b038d849c1194ee048ca450427912de265fcb5ad8fad", + "size": 47141, + "subdir": "linux-64", + "timestamp": 1532540823640, + "version": "13.2.1" + }, + "keyring-13.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "74710b67fc982b9c9ed89a63a635d4ad", + "name": "keyring", + "sha256": "41f03c4a01a5e5c28bd49648987599ef8a9a0e2ae8821b178e82a52b94eb3bb6", + "size": 47014, + "subdir": "linux-64", + "timestamp": 1532540661721, + "version": "13.2.1" + }, + "keyring-13.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "9ca430e718c4d403307351424891b852", + "name": "keyring", + "sha256": "11f297af613f733293cb06485495c88b4be6783a5eedaeae2b34e2c09718641e", + "size": 47139, + "subdir": "linux-64", + "timestamp": 1532540708238, + "version": "13.2.1" + }, + "keyring-15.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "c791597d81e20e6080dde3aeedba2962", + "name": "keyring", + "sha256": "3e1c5ae0d126bcfca7c1a5f6dbcb1de03261468d5c4bec1fd73954390b8b8c4d", + "size": 46946, + "subdir": "linux-64", + "timestamp": 1539637773281, + "version": "15.1.0" + }, + "keyring-15.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "fa9641a08186f36f103555e78d293e10", + "name": "keyring", + "sha256": "0e7581c1c748bb6c421e102de88d3d922ab06c6081847aed18597476ccb31cff", + "size": 47664, + "subdir": "linux-64", + "timestamp": 1539637795056, + "version": "15.1.0" + }, + "keyring-15.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "2d02ff46b9b14ba9190a6e1aefb97c44", + "name": "keyring", + "sha256": "d0e9bc14064f05acbadf2595780e6f4d43deeaa63d4b83509ee9a5e35831f2a3", + "size": 47766, + "subdir": "linux-64", + "timestamp": 1539637787710, + "version": "15.1.0" + }, + "keyring-16.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "b41e95353f5f3212d10307e6749f5268", + "name": "keyring", + "sha256": "ea9470fc470add11379e204a07aa13f6c2b3e2ffc01c9598683114a344abdb81", + "size": 48480, + "subdir": "linux-64", + "timestamp": 1540981129976, + "version": "16.0.0" + }, + "keyring-16.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "72f88c06ec9ef942deddb6831989dc07", + "name": "keyring", + "sha256": "a3cffcd1bb9a43bc5f880c437ed46104a8916f90a4ba232c2e0147f94fe51ac9", + "size": 49329, + "subdir": "linux-64", + "timestamp": 1540981149966, + "version": "16.0.0" + }, + "keyring-16.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "b9920aac2b4bc5ef38f824ad484c6199", + "name": "keyring", + "sha256": "1dc4d5824067799f0d339ce3655f0f27ab88f8f05e2833158ce55503a24bca15", + "size": 49391, + "subdir": "linux-64", + "timestamp": 1540981150962, + "version": "16.0.0" + }, + "keyring-16.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "4f6e9325911e39560c2b61e6b5190b12", + "name": "keyring", + "sha256": "4ffa2c17d228df8451cb3b81bb9e84cd191dbb98ad0fbca531bd4382d8da868c", + "size": 48826, + "subdir": "linux-64", + "timestamp": 1542313636873, + "version": "16.0.2" + }, + "keyring-16.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "b25f7670203c55e0874b2fb223dec075", + "name": "keyring", + "sha256": "77973f815a257c05112b3e32f50270135b6ce756431a8e9b694963e45e130a07", + "size": 49680, + "subdir": "linux-64", + "timestamp": 1542313657330, + "version": "16.0.2" + }, + "keyring-16.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "89da756389cb21fdeafbe9aae1370e82", + "name": "keyring", + "sha256": "e1f8a400d6120f3c95cc2b9246285bf9c7664451466c76cae331bcfbe2e948b4", + "size": 49753, + "subdir": "linux-64", + "timestamp": 1542313592244, + "version": "16.0.2" + }, + "keyring-16.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "8f5ff0ceb7f878701dd6287f2b6e35c0", + "name": "keyring", + "sha256": "374c83b2cddf9adac2cbf558673428f25250060b92ed42cabf9930153788e57b", + "size": 49227, + "subdir": "linux-64", + "timestamp": 1542639700278, + "version": "16.1.0" + }, + "keyring-16.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "6edbebecc084c598c11003cf7c1762df", + "name": "keyring", + "sha256": "cb6d38ffeb9a0e05c5eef50ece5e5698cbfa43937c792598d3fc3226d62d3640", + "size": 50175, + "subdir": "linux-64", + "timestamp": 1542639722579, + "version": "16.1.0" + }, + "keyring-16.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "ac57514c2a1cb410f95cf52f4ad5dff3", + "name": "keyring", + "sha256": "e6fa0c1eb92f54b24c62442725cf0021695909239e67573f0729d63a5e8a2469", + "size": 50222, + "subdir": "linux-64", + "timestamp": 1542639689237, + "version": "16.1.0" + }, + "keyring-16.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "b506d71a7222bba04b861cf98a263c63", + "name": "keyring", + "sha256": "c7637b718c28781fa71cedb87cbabdfbb914b559a7e23c10360a38f2a03be014", + "size": 52160, + "subdir": "linux-64", + "timestamp": 1543525883570, + "version": "16.1.1" + }, + "keyring-16.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "bd1b9455773301d1a845acb4fa515cf5", + "name": "keyring", + "sha256": "446165e3d509b60e91b6ecc311e6b34519c51c441a0d221008a8ff9b2b77b5f1", + "size": 53049, + "subdir": "linux-64", + "timestamp": 1543525904962, + "version": "16.1.1" + }, + "keyring-16.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "37275ff56dc79d9606968405f922ef49", + "name": "keyring", + "sha256": "ca649d1fbe1865161e5643ce277f617fa9bf114f03f664e2173c5f7c18150e17", + "size": 53117, + "subdir": "linux-64", + "timestamp": 1543525860603, + "version": "16.1.1" + }, + "keyring-17.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "4b084947f719680d6bb0266fc1c64b3a", + "name": "keyring", + "sha256": "753153f5124c0c81ce97ee1eff47cefe2c929e108f0006c879cc44a3829d826a", + "size": 49325, + "subdir": "linux-64", + "timestamp": 1545091737710, + "version": "17.0.0" + }, + "keyring-17.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "f70d31e0fa50532e0bfc20fc01e781a8", + "name": "keyring", + "sha256": "fd89e5f60c181b0e29c4a6b9168b9b24bcce292bd65876cfb46bf9024fc7fd40", + "size": 50239, + "subdir": "linux-64", + "timestamp": 1545091745092, + "version": "17.0.0" + }, + "keyring-17.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "30b7d8ae36c5b69eebcc86dd4bacd506", + "name": "keyring", + "sha256": "c3d9a6b6aa778c8a5c1b92a37d6dd5516ec7f67e60109fa7d15746ffc57e3b9b", + "size": 50331, + "subdir": "linux-64", + "timestamp": 1545091764210, + "version": "17.0.0" + }, + "keyring-17.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "c76c996182c8fcd428f6a124b3f66549", + "name": "keyring", + "sha256": "6897830b1119a4ec699aa6e41178832c19a19071f170692449f4f1971f1ca497", + "size": 52420, + "subdir": "linux-64", + "timestamp": 1547232997607, + "version": "17.1.1" + }, + "keyring-17.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "742ddd01f4e9f05bbe4486465c63b3ac", + "name": "keyring", + "sha256": "605b220c1b5025943575555f3dea9d9bd6749923d7bca9a88b6d979959cdd864", + "size": 53521, + "subdir": "linux-64", + "timestamp": 1547233003068, + "version": "17.1.1" + }, + "keyring-17.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "02f2bcd8a94173b0771352a7e3b2b296", + "name": "keyring", + "sha256": "489a202ca595907fca39c2e9ac199cc858451138eef0dd59af36d6117ccc6329", + "size": 53416, + "subdir": "linux-64", + "timestamp": 1547233009265, + "version": "17.1.1" + }, + "keyring-18.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "ad8ce7b2f83e52a315b6c93d72627b3e", + "name": "keyring", + "sha256": "b962914dac0a105e53a2198b36217f570e9176c5abab33c7abe020084d31de58", + "size": 55448, + "subdir": "linux-64", + "timestamp": 1550348346763, + "version": "18.0.0" + }, + "keyring-18.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "bd1f5b159460a13b81d5e1bedc6b5482", + "name": "keyring", + "sha256": "9378472008703c06c8b9a87aca8d17c433dba5d9cccd7091958f1b8a867f0bab", + "size": 56355, + "subdir": "linux-64", + "timestamp": 1550348348939, + "version": "18.0.0" + }, + "keyring-18.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "41aefa3e1e4722c872fa4284d13228be", + "name": "keyring", + "sha256": "fc9d542f695860ccae150bcd2ae86278c89b7ccdd6071d753de7ee332ca1f2c5", + "size": 56383, + "subdir": "linux-64", + "timestamp": 1550348287541, + "version": "18.0.0" + }, + "keyring-18.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "bbca59f412c1ab78d9a0ab91f7631957", + "name": "keyring", + "sha256": "58b978b02f7f3863674b03fbd6c24b7d14f45bf1a01419f7ace50806d2235c45", + "size": 53718, + "subdir": "linux-64", + "timestamp": 1574177569500, + "version": "18.0.0" + }, + "keyring-18.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib-metadata", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "md5": "5f33244fba3ff0483f6c824af1bb763e", + "name": "keyring", + "sha256": "d216a32dc58dbb90bb0e0af76e679ead0a2360e8e2c180e6189762cbe0d8b8f8", + "size": 57792, + "subdir": "linux-64", + "timestamp": 1594840368567, + "version": "18.0.1" + }, + "keyring-18.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib-metadata", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "md5": "89ef120c122b4a77e6d6f0bc7a9132a4", + "name": "keyring", + "sha256": "b9ebc3ad33675998c70d10155599590dec009abb116b1f3486253f9800607149", + "size": 57831, + "subdir": "linux-64", + "timestamp": 1594844550640, + "version": "18.0.1" + }, + "keyring-18.0.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "md5": "96bd29c7056f8e9d53134f2f625f00a9", + "name": "keyring", + "sha256": "6c5f9a27e1b72059d6f20fdc4945b583def42f6d1188569e453e1fd4233e33db", + "size": 58095, + "subdir": "linux-64", + "timestamp": 1594842854796, + "version": "18.0.1" + }, + "keyring-19.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "df9105b58c3a47eb84c918362bf91b13", + "name": "keyring", + "sha256": "d4bafe563c7850a1081fa67b5d729405ff650e04be1d36dab593bcec044c6b75", + "size": 56931, + "subdir": "linux-64", + "timestamp": 1574272893974, + "version": "19.2.0" + }, + "keyring-19.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "316780e3eb4e44a04470434deecc2871", + "name": "keyring", + "sha256": "538ab237d610e897d7ed0f5d1307bd194670908faa8266d8d713ae0b87e222aa", + "size": 56992, + "subdir": "linux-64", + "timestamp": 1574272884458, + "version": "19.2.0" + }, + "keyring-19.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "1c46893388c1769b8ce42d8f4a2add44", + "name": "keyring", + "sha256": "b6a57f4a428b10c660012dd942bc79ba193508f49bda4133744baabd9c621a0b", + "size": 57151, + "subdir": "linux-64", + "timestamp": 1574272932911, + "version": "19.2.0" + }, + "keyring-20.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "e5d5aa4f79a3a6444a3bf2b6a9f25fa3", + "name": "keyring", + "sha256": "bc122ca347f255341793564bb3e5614e86492ad50e5bceaa87e2c302dd7adbe0", + "size": 54383, + "subdir": "linux-64", + "timestamp": 1576602572036, + "version": "20.0.0" + }, + "keyring-20.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "4b65364dc55b136df4708440439c9b86", + "name": "keyring", + "sha256": "ed9f175fe144c2522cffb2a1d3e19f74a845035fd9a0ca67899b1fe899529a1a", + "size": 54419, + "subdir": "linux-64", + "timestamp": 1576602522043, + "version": "20.0.0" + }, + "keyring-20.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "fe19f9cd3e818fc8a1ccdebc916c680d", + "name": "keyring", + "sha256": "dd6c6452da75c4bc56f1893c8380f63e150aff76dce275bfa7588a78e85692c5", + "size": 54486, + "subdir": "linux-64", + "timestamp": 1576602596353, + "version": "20.0.0" + }, + "keyring-21.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "98015a4334d64f7b88f5fce27e043d8f", + "name": "keyring", + "sha256": "29b7cf4a42a9154cccce7e38df33cd156963f7b82690d1536ff2923f34928a54", + "size": 54901, + "subdir": "linux-64", + "timestamp": 1580400530486, + "version": "21.1.0" + }, + "keyring-21.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "8552020de857c1d329206b705248f665", + "name": "keyring", + "sha256": "2307e658b5368f274ed362d5b33ec91dc3457bbc2753522aaa6bad1b2e9b0873", + "size": 54898, + "subdir": "linux-64", + "timestamp": 1580400528276, + "version": "21.1.0" + }, + "keyring-21.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "d2723e249613965a9ed1490ae726ca8d", + "name": "keyring", + "sha256": "3a55862561e00e4e3e0fc267ff274abf29722085334bd94273c02cd3b89bf946", + "size": 55021, + "subdir": "linux-64", + "timestamp": 1580400525851, + "version": "21.1.0" + }, + "keyring-21.1.1-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "157f6b68272ef393eadf4330f0bc0f0b", + "name": "keyring", + "sha256": "7b2ff0e547a20960a9b5b8edc6b07916a53f2107a41343a17a456600d57cbe5c", + "size": 56021, + "subdir": "linux-64", + "timestamp": 1585850904212, + "version": "21.1.1" + }, + "keyring-21.1.1-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "26ec13465c5c156b0cff8ca489fe2b52", + "name": "keyring", + "sha256": "807022125339d683ca0c965ae4c5024491756e9ba5800bec9d6adc332e4b8b63", + "size": 56020, + "subdir": "linux-64", + "timestamp": 1585850900433, + "version": "21.1.1" + }, + "keyring-21.1.1-py38_2.tar.bz2": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "entrypoints", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "dd10ee735e2a61b49a14680b1efc9d81", + "name": "keyring", + "sha256": "26a2363cb5b5244deda5abbf0cc7b3deb7a4be7621166246c5addf2c58b02d81", + "size": 56184, + "subdir": "linux-64", + "timestamp": 1585850897188, + "version": "21.1.1" + }, + "keyring-21.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "617b22a45c290ef8d5ccbb2654eb1a45", + "name": "keyring", + "sha256": "b3fba4d5f540b3936dffc2e7e225df328c01d548cdd5990e39a51473638b0f2b", + "size": 56830, + "subdir": "linux-64", + "timestamp": 1593109750955, + "version": "21.2.1" + }, + "keyring-21.2.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "97388528345b52d39fbb8e613686b41e", + "name": "keyring", + "sha256": "4d85cf44a045496bd5ed2e0db5d715321fd10759b5c35b497f7a0e0adb76fdf7", + "size": 58433, + "subdir": "linux-64", + "timestamp": 1615497932053, + "version": "21.2.1" + }, + "keyring-21.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "ec91c1bebc201732d1b01176fe3d2b0c", + "name": "keyring", + "sha256": "59db43ccaf78110e56f2dbac5d5350662dfa97089635ff7484ec44f3b0b2ba36", + "size": 56773, + "subdir": "linux-64", + "timestamp": 1593109729316, + "version": "21.2.1" + }, + "keyring-21.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d44a8de0e4179a7b90afba3b77a320e", + "name": "keyring", + "sha256": "9732c6b4f776120a808a1377661edeac541a62942c66fba99fb852e568e804c4", + "size": 58452, + "subdir": "linux-64", + "timestamp": 1615498319103, + "version": "21.2.1" + }, + "keyring-21.2.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "8273f57e4b37bb425e67f1ff20096075", + "name": "keyring", + "sha256": "c3c6e10cbeaf335db6251543f6eb8ef52bffa36c0e8bfbf8ee6b9b68c15bc137", + "size": 56927, + "subdir": "linux-64", + "timestamp": 1593109750628, + "version": "21.2.1" + }, + "keyring-21.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad46dc3f179ebcd6e292f3b6cc6e333a", + "name": "keyring", + "sha256": "2bdb97c16c85d73b3c4b1115feccd6d247637161fc8b606d571f215f6ccdff7b", + "size": 58562, + "subdir": "linux-64", + "timestamp": 1615496691816, + "version": "21.2.1" + }, + "keyring-21.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e1c5a1e3f6af977bd5888ee430154749", + "name": "keyring", + "sha256": "8b32407931c1f277d0b3f682de76b261903f8965065a6a63fd34dd20fec676c5", + "size": 58748, + "subdir": "linux-64", + "timestamp": 1615498327718, + "version": "21.2.1" + }, + "keyring-21.3.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "md5": "d9e6cf193a7d829310b8dc63597cbf9c", + "name": "keyring", + "sha256": "6812f5426bd60abe24153d6620588ebf10415b0003662e3a6208fcb904922dbc", + "size": 54558, + "subdir": "linux-64", + "timestamp": 1605040305638, + "version": "21.3.0" + }, + "keyring-21.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "9cf048da30220df71a567dfda2a55dd4", + "name": "keyring", + "sha256": "200d7b114e67194819467df3f87aa2fed5ea1d89b54afba288442b04bc032d6c", + "size": 49563, + "subdir": "linux-64", + "timestamp": 1596873535518, + "version": "21.3.0" + }, + "keyring-21.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "md5": "28f4c4390f0f433cab0ca21f8f7c3e5e", + "name": "keyring", + "sha256": "92cff3d179e0d509d1b052c5300ef5f2c79906a0e12d23cfd94d7324dc96c4ae", + "size": 54677, + "subdir": "linux-64", + "timestamp": 1605040293440, + "version": "21.3.0" + }, + "keyring-21.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "60daa8e62241d74d4eabb8067d393458", + "name": "keyring", + "sha256": "943837c00c38ceb3b3e3313f828dc7c5546e5def3a38f9b756a560e803ca35b3", + "size": 57489, + "subdir": "linux-64", + "timestamp": 1598375836132, + "version": "21.3.1" + }, + "keyring-21.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "f364c83987c516b28623eac17a6f0b10", + "name": "keyring", + "sha256": "9f93fcaaee2a8af1c7845ebb8cd14e5dde2f85d3dff85783ae2ea231de967b57", + "size": 57476, + "subdir": "linux-64", + "timestamp": 1598375837495, + "version": "21.3.1" + }, + "keyring-21.3.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "38d5338bc1fe828f3f385fdc1b444ccb", + "name": "keyring", + "sha256": "5807278cc2dcb3e3d81c8cfe4c4469391a6d884bbdf3ea2c13cf1cf186c2ddac", + "size": 57641, + "subdir": "linux-64", + "timestamp": 1598375852204, + "version": "21.3.1" + }, + "keyring-21.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.9,<3.10.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "831f5135d68b9b41b80819e35eef5db8", + "name": "keyring", + "sha256": "c15b6e5a59865174f8d755c3c5ad505c6cd8b8082c0c5a8dca9dbcb2ba8826ee", + "size": 57878, + "subdir": "linux-64", + "timestamp": 1607573567387, + "version": "21.3.1" + }, + "keyring-21.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "e2eb2e33b0d7898270573fef1f9d0d76", + "name": "keyring", + "sha256": "f67a32a0399fae15656dda362672a8624037d12d3553dd95a9742fb201046bdc", + "size": 57796, + "subdir": "linux-64", + "timestamp": 1598884793506, + "version": "21.4.0" + }, + "keyring-21.4.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "eef16060580703e3751d885413b6b67d", + "name": "keyring", + "sha256": "6cf5a9e60f0e56d1627de631a2470cf128ff227216695540bef961b7d46ca0e5", + "size": 50803, + "subdir": "linux-64", + "timestamp": 1601490889875, + "version": "21.4.0" + }, + "keyring-21.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "f300ddc39f6de49187529809ad65e9c9", + "name": "keyring", + "sha256": "7902b9253d3183f7e09a0584f56cebf0d9273c6e2a14326046ae95f2779733b3", + "size": 57813, + "subdir": "linux-64", + "timestamp": 1598884806937, + "version": "21.4.0" + }, + "keyring-21.4.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "cece0b6effa1ea2371b5280ed809b4c5", + "name": "keyring", + "sha256": "e188b28a753ae2c421a801cd77ce5a62ebbe67d9dcddc713ba76ea2946a64bc4", + "size": 50837, + "subdir": "linux-64", + "timestamp": 1601490870236, + "version": "21.4.0" + }, + "keyring-21.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "f8dfe44364bbd1dc8e9417e9d9cb84fa", + "name": "keyring", + "sha256": "14e7383c028dfcfab9f250073c90df61a352d4db061ca4bc9be2def326454cef", + "size": 57955, + "subdir": "linux-64", + "timestamp": 1598884788122, + "version": "21.4.0" + }, + "keyring-21.4.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "b4df11c3e6f780d58fb89b0d298b21a8", + "name": "keyring", + "sha256": "fac0b2df98e674acb0bf764c06b85aa0818ea2ac7b3ea9387b8f33e723c44700", + "size": 50956, + "subdir": "linux-64", + "timestamp": 1601490866628, + "version": "21.4.0" + }, + "keyring-21.4.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "9909ce2266f012dbdbb495fe7d6f311a", + "name": "keyring", + "sha256": "a6ee4ccd7c5ac3e1d506d2c9ae8562566d8c9e4755594260549909e09dd7b1b5", + "size": 58398, + "subdir": "linux-64", + "timestamp": 1607709224657, + "version": "21.4.0" + }, + "keyring-21.6.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea6977b3bdf5a664f9fd3a09b4797c76", + "name": "keyring", + "sha256": "b40c63d524d205a1bfbd23db49b2359cea899dca4615231f1f52f99c28545920", + "size": 51447, + "subdir": "linux-64", + "timestamp": 1608667223912, + "version": "21.6.0" + }, + "keyring-21.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b39c3d713aae3644022a47806c2da4b", + "name": "keyring", + "sha256": "f3dc492e9dd0ee99ac3c71550cc279e81e677b7b625da115b24e7bb9c77b4fae", + "size": 51539, + "subdir": "linux-64", + "timestamp": 1608667262867, + "version": "21.6.0" + }, + "keyring-21.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd5fe72d42682cfffb705f869b2948bd", + "name": "keyring", + "sha256": "7cf241584d6b68b6ea94daa9e821dff92844be73072127d86b45d7b9e3800613", + "size": 51612, + "subdir": "linux-64", + "timestamp": 1608667261813, + "version": "21.6.0" + }, + "keyring-21.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd19afe5a677ca3c8e8e0629ad25a6ad", + "name": "keyring", + "sha256": "c3f088e321aaf203b8d5a706318e85cc5e0cbb3f74d54bd734f3039932912184", + "size": 51726, + "subdir": "linux-64", + "timestamp": 1608667247731, + "version": "21.6.0" + }, + "keyring-21.7.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d3bfca47ec6a00962accb057185b0d0f", + "name": "keyring", + "sha256": "f6e956dd69bd53cf2ae10b8fb810b26e9d87ce1b9bba3d90cda1bce07a4bf088", + "size": 51447, + "subdir": "linux-64", + "timestamp": 1608756057308, + "version": "21.7.0" + }, + "keyring-21.7.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c568b1052342bd93b2954c7216b12f6e", + "name": "keyring", + "sha256": "8a2bdee54c4c118925ae713deb3754994d176af081051e3603d5c25b45b36a90", + "size": 51444, + "subdir": "linux-64", + "timestamp": 1608756127608, + "version": "21.7.0" + }, + "keyring-21.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2da49757589da1a7d836878ecf1645ff", + "name": "keyring", + "sha256": "895078a1d001136e56a9e831fd56d11e9498c33fd32fa287a96198568e6932e4", + "size": 51634, + "subdir": "linux-64", + "timestamp": 1608756147645, + "version": "21.7.0" + }, + "keyring-21.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5eebffcaa9ce3e566ceec249b27f91c", + "name": "keyring", + "sha256": "7932b8e777925ee6cdfa347fd1163384aa2baef374a78866b0223212ac050fb4", + "size": 51702, + "subdir": "linux-64", + "timestamp": 1608756137553, + "version": "21.7.0" + }, + "keyring-21.8.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "801da0d7cfb9fc9a8f04721986d6ae0c", + "name": "keyring", + "sha256": "861a6a2bfd5a3cdf65c16bb41b8739dee232e6fca9c9108bdedb45fe8cf7d131", + "size": 52055, + "subdir": "linux-64", + "timestamp": 1609353679610, + "version": "21.8.0" + }, + "keyring-21.8.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eeaa36cd46ef1b31d797b050b8c9aa16", + "name": "keyring", + "sha256": "f94b6b0fedf6f11ecd36bb99e3d502d6de900d108bade70553660e4a08f977c8", + "size": 52081, + "subdir": "linux-64", + "timestamp": 1609353658083, + "version": "21.8.0" + }, + "keyring-21.8.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e926e155329959865fc2a326c7f2342", + "name": "keyring", + "sha256": "4d6172d986de7ea6be972814daeb5ec49cdf61a550922de1adb441ee39ce6dd4", + "size": 52171, + "subdir": "linux-64", + "timestamp": 1609353699125, + "version": "21.8.0" + }, + "keyring-21.8.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d16cb8c6760f84aacc55431771639269", + "name": "keyring", + "sha256": "cab1c31a4c6827f68fa1e6a6becf36b234fdd151c8d8a5f129618ffc41261be5", + "size": 52333, + "subdir": "linux-64", + "timestamp": 1609353654697, + "version": "21.8.0" + }, + "keyring-22.0.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62fe1479a9d170b833c659526691a839", + "name": "keyring", + "sha256": "285c84948e3f04339f10817dc97bf1de8ac5a3fe252a5607da3c054f1af0fc82", + "size": 51960, + "subdir": "linux-64", + "timestamp": 1611601981541, + "version": "22.0.0" + }, + "keyring-22.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a7ef328d29f944540d79ce00813c48ae", + "name": "keyring", + "sha256": "945bf9bf0045ffe2915fa74b416f9f8dd29c910b1dc3768f393d90cecb5c0cf7", + "size": 51924, + "subdir": "linux-64", + "timestamp": 1611601668373, + "version": "22.0.0" + }, + "keyring-22.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98a5d49da8455eedf9d7c8c26c0b9df8", + "name": "keyring", + "sha256": "a5c0dc3eed3a8d6120d0fcbdac232400f7cffa219cc314e869f55c233ec26ff5", + "size": 52113, + "subdir": "linux-64", + "timestamp": 1611601990105, + "version": "22.0.0" + }, + "keyring-22.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5deb0fbd96822c845f98de7cd5fd0d2b", + "name": "keyring", + "sha256": "c29717cfc4080b3e80c4baffbcfed3792719801d6cecad2c7fd3bbf0d0c00bb1", + "size": 52248, + "subdir": "linux-64", + "timestamp": 1611601982765, + "version": "22.0.0" + }, + "keyring-22.0.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96a254a50dec35965f48267c3d18926d", + "name": "keyring", + "sha256": "4d25d0296d5459d565bc538478416966b525a60bfb45e0d550083c813f39165f", + "size": 52096, + "subdir": "linux-64", + "timestamp": 1611778748393, + "version": "22.0.1" + }, + "keyring-22.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "99e196544a93df40178fbe2423144833", + "name": "keyring", + "sha256": "97743294ec77e9538c43726a275e3066b2cb56ff512eaf0f71473232b9ca5231", + "size": 52149, + "subdir": "linux-64", + "timestamp": 1611778551038, + "version": "22.0.1" + }, + "keyring-22.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bfb6ad7a646d98b2c6b0579295f3163a", + "name": "keyring", + "sha256": "c97efe743d76a8cf189a572540466b47f01a0bb914fbe0443ad6b5c52913a7aa", + "size": 52278, + "subdir": "linux-64", + "timestamp": 1611778758423, + "version": "22.0.1" + }, + "keyring-22.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b85ec8584138e382518d196a64b79fbe", + "name": "keyring", + "sha256": "0c73572c5c4ef36b7f64a3600547213ba9cd9dfda9a812c90d77e2529b207df0", + "size": 52471, + "subdir": "linux-64", + "timestamp": 1611778747109, + "version": "22.0.1" + }, + "keyring-22.2.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21fefb9df3710a2f307859cda4b096c7", + "name": "keyring", + "sha256": "c2760cc86ff8d7da308becb922918b8702a04b6a7780abc6b06b22c5c678f170", + "size": 52257, + "subdir": "linux-64", + "timestamp": 1614363063443, + "version": "22.2.0" + }, + "keyring-22.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4604889fa4385eedde17225ee360739f", + "name": "keyring", + "sha256": "8c7a79395df655d56d07802c81a84e8b5b39ca9ccde608a468d6cc2a80627769", + "size": 52253, + "subdir": "linux-64", + "timestamp": 1614363359476, + "version": "22.2.0" + }, + "keyring-22.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87d324b8dd2876536f907b8fffbab1ae", + "name": "keyring", + "sha256": "55806713cfa55e26e84af4b638db26dc77991455ac678055406d216a9ec398e4", + "size": 52438, + "subdir": "linux-64", + "timestamp": 1614363312639, + "version": "22.2.0" + }, + "keyring-22.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "157951272a4a23a34e19203a85ff68a6", + "name": "keyring", + "sha256": "5ba51fa0a7d5eb610115f3b6d3da777c330adfce00a7d48be177f0dc5ec94ac5", + "size": 52544, + "subdir": "linux-64", + "timestamp": 1614363365136, + "version": "22.2.0" + }, + "keyring-22.3.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9897cb2c685a9ce37c935306d6dfeb2", + "name": "keyring", + "sha256": "8cd6e2a0b6d4e7323ab3f1133a0d9246685094b69d916f9256fee5d489bf9860", + "size": 52468, + "subdir": "linux-64", + "timestamp": 1614615585935, + "version": "22.3.0" + }, + "keyring-22.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d425f6e11b857e84d128744f2b5fe79c", + "name": "keyring", + "sha256": "e6ed8359355c84e7f8c192e40fd69a41594efe96d2557b799b50d7fd13272b3a", + "size": 52438, + "subdir": "linux-64", + "timestamp": 1614616787817, + "version": "22.3.0" + }, + "keyring-22.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52780668bcdb28da76d4385bc29b90bb", + "name": "keyring", + "sha256": "f088b8e327cb5d364e60cb8e2560e9242e60787317269ff19e16e047ec33dd9a", + "size": 52606, + "subdir": "linux-64", + "timestamp": 1614616779212, + "version": "22.3.0" + }, + "keyring-22.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7a6ea5ab13805b5e7bddb8a0febee495", + "name": "keyring", + "sha256": "040b2b344d9135ac9fbfb3888610d67deafa5da1148ded529e98c8ba209aff4c", + "size": 52783, + "subdir": "linux-64", + "timestamp": 1614615940431, + "version": "22.3.0" + }, + "keyring-23.0.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "md5": "b4c2f291a344e5d9c9446096acb14c9b", + "name": "keyring", + "sha256": "53cfdebf6f373a11d9af1ceaf78b42386b261cb2fd0f0b21df0c248a074b5167", + "size": 52653, + "subdir": "linux-64", + "timestamp": 1621519938758, + "version": "23.0.1" + }, + "keyring-23.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "md5": "cf5151f9ac4e76c5e76ba8d25f2e1c24", + "name": "keyring", + "sha256": "b42dc826aacc9e15cac86795d3d1be68d62340b42544a4e2b6eb05dceb574f09", + "size": 52690, + "subdir": "linux-64", + "timestamp": 1621524620349, + "version": "23.0.1" + }, + "keyring-23.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "md5": "c8e1750c38f7d84699aedff46a0b415e", + "name": "keyring", + "sha256": "0e9834ca0bcede44d5e3581422ed4839a7342d3806a56484c168f1487e144c13", + "size": 52886, + "subdir": "linux-64", + "timestamp": 1621524444162, + "version": "23.0.1" + }, + "keyring-23.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "md5": "aafeb673c8c142f7a3b8266b890d0bc1", + "name": "keyring", + "sha256": "19e2402df3a842ad3fedf7d081e366ea4fac8b7f8af7971ce2ccb2af5171413a", + "size": 53014, + "subdir": "linux-64", + "timestamp": 1621524620745, + "version": "23.0.1" + }, + "keyring-23.1.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e6297946d6dffb5aed2541be4d5b791", + "name": "keyring", + "sha256": "f34dde38c0838ae41336b48424637a2c996749f5fd10961643fa890116f2e58c", + "size": 59540, + "subdir": "linux-64", + "timestamp": 1629312985224, + "version": "23.1.0" + }, + "keyring-23.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bfc8d51e1c431f1710ffbbad5f55d282", + "name": "keyring", + "sha256": "817490bbcb144fcf77b387882cf4a4721950ec13665404711d82150af653cc6c", + "size": 59561, + "subdir": "linux-64", + "timestamp": 1629321372602, + "version": "23.1.0" + }, + "keyring-23.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6dfe02fd41ba3659d8f329d5c66250f2", + "name": "keyring", + "sha256": "0b285a06616cbd0fad335fa2b2a1e7acc5a0df8fc432c29384fc0938dffc8682", + "size": 59741, + "subdir": "linux-64", + "timestamp": 1629321588236, + "version": "23.1.0" + }, + "keyring-23.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5260f2a0f7af3687a76d53f2ab1aeabd", + "name": "keyring", + "sha256": "708b9adbd9b5b78f3f438972f88e07f567694f208b43956b30d5f72e911c7f30", + "size": 59866, + "subdir": "linux-64", + "timestamp": 1629321584007, + "version": "23.1.0" + }, + "keyring-23.13.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=4.11.4", + "jaraco.classes", + "jeepney >=0.4.2", + "python >=3.10,<3.11.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9c449adb64e36888c4e272528ff4799", + "name": "keyring", + "sha256": "de321819e03ae4a3c86d3aafe2f93f1da26d844bf45e9018e5e159893b4ec726", + "size": 59592, + "subdir": "linux-64", + "timestamp": 1678999281695, + "version": "23.13.1" + }, + "keyring-23.13.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=4.11.4", + "jaraco.classes", + "jeepney >=0.4.2", + "python >=3.11,<3.12.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d28e7e98b09e15dfd72dea93b0e15e5", + "name": "keyring", + "sha256": "345cbf6943ed1dc4fcd50ea96f762ccc239e478258ee1d7e3e69115140788742", + "size": 73967, + "subdir": "linux-64", + "timestamp": 1678999344745, + "version": "23.13.1" + }, + "keyring-23.13.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=4.11.4", + "importlib_resources", + "jaraco.classes", + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "753cfd518149cc69b728c72d201596c2", + "name": "keyring", + "sha256": "dddb538de1db9ec69dfb9c0c3a8e90fd9fc44dfd653e80ed97bf1465b5d86065", + "size": 59049, + "subdir": "linux-64", + "timestamp": 1678999313102, + "version": "23.13.1" + }, + "keyring-23.13.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=4.11.4", + "jaraco.classes", + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5287a76f628879f4ff6a73f67dbb976e", + "name": "keyring", + "sha256": "88384355a7aa9ef267f9a0f00d8d82d09270fadbed1de881168ab5cb8348117c", + "size": 59171, + "subdir": "linux-64", + "timestamp": 1678999249834, + "version": "23.13.1" + }, + "keyring-23.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.10,<3.11.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62fe474a537fca35dce51466b273b35f", + "name": "keyring", + "sha256": "6c33081b3b19a3e75ab3991496677b43e2deb4b86fd85ecd6fa70273722d9dfc", + "size": 53963, + "subdir": "linux-64", + "timestamp": 1640884852850, + "version": "23.4.0" + }, + "keyring-23.4.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.11,<3.12.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "41dcd2a4f788f76fffeaa4b38935898e", + "name": "keyring", + "sha256": "349eabf5b053f3b980090d1fe048f8ba1db015db96fc12a6f66f8b8768fd024a", + "size": 67548, + "subdir": "linux-64", + "timestamp": 1676823176179, + "version": "23.4.0" + }, + "keyring-23.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "296dade9f86733096b0ac3b47b32980c", + "name": "keyring", + "sha256": "830165b93d3f8326801d9f183846e4b09dd2a9dcee027a7e6e8a8a6d2b2b42a9", + "size": 53098, + "subdir": "linux-64", + "timestamp": 1638531289024, + "version": "23.4.0" + }, + "keyring-23.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d5f35620c89d8005f6bee99c631a444b", + "name": "keyring", + "sha256": "b62e098cee9e02360d13fd94cadf1b80ef1cdae28be0acb75b810bfc5631d197", + "size": 53265, + "subdir": "linux-64", + "timestamp": 1638531389937, + "version": "23.4.0" + }, + "keyring-23.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df58c9801832173935697381697f26ac", + "name": "keyring", + "sha256": "43375edb8dd4891f047c49d98cb9dc029f5624b7541b4d1370ad07b3d604c5fe", + "size": 53351, + "subdir": "linux-64", + "timestamp": 1638531384627, + "version": "23.4.0" + }, + "keyrings.alt-2.3-py27he1d4c3b_0.tar.bz2": { + "build": "py27he1d4c3b_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "88fb9efdff117525739efe05156f444e", + "name": "keyrings.alt", + "sha256": "7936a71d4d44719a0b71d530ebfa8046f8d9c9f044dfd73e56ff832d00e3f47f", + "size": 32230, + "subdir": "linux-64", + "timestamp": 1509228222928, + "version": "2.3" + }, + "keyrings.alt-2.3-py35h10e0aba_0.tar.bz2": { + "build": "py35h10e0aba_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83623b1325e222a337adb26a83410deb", + "name": "keyrings.alt", + "sha256": "cf8bc4c1b086b32e8898c329011c6ea556ec94fe9a89c72d6fb68c06fbed16b2", + "size": 33036, + "subdir": "linux-64", + "timestamp": 1509228223904, + "version": "2.3" + }, + "keyrings.alt-2.3-py36h0f3a8d9_0.tar.bz2": { + "build": "py36h0f3a8d9_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd59e8b928591b592f3c82e190e52701", + "name": "keyrings.alt", + "sha256": "fc4a7f2f372b4b2681fb2159068808ad0773cf25162f293aaacd96cf2d96677a", + "size": 32959, + "subdir": "linux-64", + "timestamp": 1509228217782, + "version": "2.3" + }, + "keyrings.alt-3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8749d71a22033743a868f4a56daafbe4", + "name": "keyrings.alt", + "sha256": "ab2f81100ae0c48dbb98645df5df0afce5108145c3601c9386192992d1dcbfd1", + "size": 32297, + "subdir": "linux-64", + "timestamp": 1522789592918, + "version": "3.0" + }, + "keyrings.alt-3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a59f25fb4764186471777a052f0a073a", + "name": "keyrings.alt", + "sha256": "4a96071d1cfdd8d047a49e0a7bed14e23cba6cae0c9a44ca551c6c1b9c9833c9", + "size": 33130, + "subdir": "linux-64", + "timestamp": 1522789602128, + "version": "3.0" + }, + "keyrings.alt-3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe44029e5701473203c1f846c7e2c20b", + "name": "keyrings.alt", + "sha256": "7cf1e24662cd9e189427bfe829c27f63c688cfd0e6c5f6789a383ab968910e08", + "size": 33068, + "subdir": "linux-64", + "timestamp": 1522789837662, + "version": "3.0" + }, + "keyrings.alt-3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b88e5d871a72ad805da287cd70494420", + "name": "keyrings.alt", + "sha256": "34090fb50a514696b432644f33c3cfa79fc1f91101f812aec3a49053639a6cb0", + "size": 33547, + "subdir": "linux-64", + "timestamp": 1527853790441, + "version": "3.1" + }, + "keyrings.alt-3.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95f23cf1a1907c67cb0d7dd9cbf520ce", + "name": "keyrings.alt", + "sha256": "283a97c7d72794929b3f0804bcf97845991004d3e83b3f5537441e26081627e6", + "size": 34235, + "subdir": "linux-64", + "timestamp": 1527853788232, + "version": "3.1" + }, + "keyrings.alt-3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80a14d7906430f09e63bf959dab85cc8", + "name": "keyrings.alt", + "sha256": "dc9cf3dab1514be96bfbf1542179fa414a5d8d23c9e00c7ea01b384202bb3df9", + "size": 34174, + "subdir": "linux-64", + "timestamp": 1527853779429, + "version": "3.1" + }, + "keyrings.alt-3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c14deaa2f8834672e9fc243e4b74c8a4", + "name": "keyrings.alt", + "sha256": "4e9ab505e250be0ba68d60e74fa8fa3af3a483222aea9e832dda59b894cf3b52", + "size": 34299, + "subdir": "linux-64", + "timestamp": 1530898246487, + "version": "3.1" + }, + "keyrings.alt-3.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1799a5eb45c89cece7dfc3a0bacf8012", + "name": "keyrings.alt", + "sha256": "b10300ad581d1839d6b828d98fed7e7b63cc609eb4e12c52927aad100f1493a8", + "size": 33563, + "subdir": "linux-64", + "timestamp": 1545123872974, + "version": "3.1.1" + }, + "keyrings.alt-3.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d4fb62370d72c00eda5cf2ec93032f8c", + "name": "keyrings.alt", + "sha256": "f4cda1d0662f793383998c3ae273841d8655e173fd896db4a36a608f140f9ff4", + "size": 34289, + "subdir": "linux-64", + "timestamp": 1545123917800, + "version": "3.1.1" + }, + "keyrings.alt-3.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9fcc7581e27e5c5a3bc3ee8d4d0e3cad", + "name": "keyrings.alt", + "sha256": "6df28295a764693fce09c9642c3c84e2270ac16c5be909bb11ef419a16eae4fa", + "size": 34349, + "subdir": "linux-64", + "timestamp": 1545123923662, + "version": "3.1.1" + }, + "keyrings.alt-3.1.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dae01cd0db2b25dfe01ea22a70f09306", + "name": "keyrings.alt", + "sha256": "c65aed5eaa7337d57cc524a1bb4b9c6f5c66784f3616ab8c256e534320436c44", + "size": 34741, + "subdir": "linux-64", + "timestamp": 1574235751895, + "version": "3.1.1" + }, + "keyrings.alt-3.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d851d9ff1e337faa5c10f0e5c1e8d5b5", + "name": "keyrings.alt", + "sha256": "a244cf784ff0a5bf6ca794bc94e934481cd57bfaed0b3c413ea6bba52a2c04f5", + "size": 52177, + "subdir": "linux-64", + "timestamp": 1592250377450, + "version": "3.4.0" + }, + "keyrings.alt-3.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18a1df719fecb96c161ca1f644de3ea1", + "name": "keyrings.alt", + "sha256": "3339e914b357af93626d68c1d345558e768d6c2b643240697dd43f48d4e5b9aa", + "size": 52345, + "subdir": "linux-64", + "timestamp": 1592250376100, + "version": "3.4.0" + }, + "keyrings.alt-3.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bde626737adda86454f2b50cad91d615", + "name": "keyrings.alt", + "sha256": "22f5c1be5ca7cb2ca8424aee7a053907c2121be54e39469f13e467be90d8ced9", + "size": 52560, + "subdir": "linux-64", + "timestamp": 1592250387276, + "version": "3.4.0" + }, + "keyrings.alt-4.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "68f7dfe70149bef3a3fd9744e8a8e29c", + "name": "keyrings.alt", + "sha256": "586dc821b8fd26963e5df2951a955bd00e5699192c821cad5b73daa7c67b62d6", + "size": 50779, + "subdir": "linux-64", + "timestamp": 1602262359170, + "version": "4.0.0" + }, + "keyrings.alt-4.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c04a823d802902eae1ba7de9994c388b", + "name": "keyrings.alt", + "sha256": "e715515be3ecc44c0937a07542db74da54b4c5ffc04e7bc23cdf5f1f765a73de", + "size": 50889, + "subdir": "linux-64", + "timestamp": 1602262629566, + "version": "4.0.0" + }, + "keyrings.alt-4.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "401cc1eb52949dbeb56bca11b47ece56", + "name": "keyrings.alt", + "sha256": "9ef61eac5dd8202463a4757742441ff7e0b071748b11e2c21530d60b40062b80", + "size": 51164, + "subdir": "linux-64", + "timestamp": 1602262619556, + "version": "4.0.0" + }, + "keyrings.alt-4.0.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64c192f5b5077998245099bec466e111", + "name": "keyrings.alt", + "sha256": "1b0a9c1f8b362d12221705474269d3dfd5249e8fbb0a508e36cc5e6629302ca4", + "size": 50222, + "subdir": "linux-64", + "timestamp": 1605125191740, + "version": "4.0.1" + }, + "keyrings.alt-4.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a98fd12fab635bd60568613be9603cfd", + "name": "keyrings.alt", + "sha256": "26293f84e94b9e4cfa58b0d3d2ae24085143f183a62e52fe9924a625d4fac45a", + "size": 50399, + "subdir": "linux-64", + "timestamp": 1605125184947, + "version": "4.0.1" + }, + "keyrings.alt-4.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c30aeb5f33512df24d7e0108c8a9e38", + "name": "keyrings.alt", + "sha256": "02323c906ad1c70f81fd65fdde5296252c0455e32bca11bf8828f9973a970e19", + "size": 50595, + "subdir": "linux-64", + "timestamp": 1605125151951, + "version": "4.0.1" + }, + "keyrings.alt-4.0.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1add9a28fde9b16e218c8a52b76ac4d3", + "name": "keyrings.alt", + "sha256": "dc9cb842542e4d325fdb758021c9b35793f094438105c62c4a2ccc8ab652d854", + "size": 33340, + "subdir": "linux-64", + "timestamp": 1608143118150, + "version": "4.0.2" + }, + "keyrings.alt-4.0.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e18dbd8d965a3803c27e855cd43dc454", + "name": "keyrings.alt", + "sha256": "bde008d56d4cfa6d778dda06fb77d89b9a077dc84f2714f335fa2cffb0747085", + "size": 33393, + "subdir": "linux-64", + "timestamp": 1608143091241, + "version": "4.0.2" + }, + "keyrings.alt-4.0.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18e0490fdbd9430acf5182d20b2b1ec7", + "name": "keyrings.alt", + "sha256": "1877a0b7de939fdc69d829b92789425ca6120cbb4653dbd54bc685f7e646152c", + "size": 33548, + "subdir": "linux-64", + "timestamp": 1608143133971, + "version": "4.0.2" + }, + "keyrings.alt-4.0.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "605f415517e467077985f46a37805f13", + "name": "keyrings.alt", + "sha256": "f18754b70ab1700b5a8eb01e61ccb5f62f8bc2c73d9e05eecad1542c7849d6a1", + "size": 33558, + "subdir": "linux-64", + "timestamp": 1608143126058, + "version": "4.0.2" + }, + "keyrings.alt-4.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec08af6158aeaa7dac0e989843e08ced", + "name": "keyrings.alt", + "sha256": "55a454fd05a85ca75573add4d549e3bd55b18829bce972bf0e4fccc321d143f7", + "size": 33922, + "subdir": "linux-64", + "timestamp": 1640815261641, + "version": "4.1.0" + }, + "keyrings.alt-4.1.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbb33e6920fa27ee8215e06bae12d0d8", + "name": "keyrings.alt", + "sha256": "12e512d52d8bf01b009c4dd700b4a8249f144db1b842eebd8a95c90867db8fe3", + "size": 45153, + "subdir": "linux-64", + "timestamp": 1676853087777, + "version": "4.1.0" + }, + "keyrings.alt-4.1.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "caf0af7113d5420db046186a3eb04ebf", + "name": "keyrings.alt", + "sha256": "cd7654a0eb278a536688f5e88c485c50d3aa296918e4c9c151f99e45dfe755ae", + "size": 33225, + "subdir": "linux-64", + "timestamp": 1626447616179, + "version": "4.1.0" + }, + "keyrings.alt-4.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9167bf96f1bb0df010985e57ced4c627", + "name": "keyrings.alt", + "sha256": "4ee4259f17ea2ef7a00981dda7194879ffed6fdf3e5ee70dac5b76403f4efe43", + "size": 33330, + "subdir": "linux-64", + "timestamp": 1626440755175, + "version": "4.1.0" + }, + "keyrings.alt-4.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e12c5b402835e4f84cdb9ea730e1211f", + "name": "keyrings.alt", + "sha256": "ab476b3fac0461147c1e66b617545894e2972733b7ca362967f0990cdc9a7000", + "size": 33423, + "subdir": "linux-64", + "timestamp": 1626447920493, + "version": "4.1.0" + }, + "keyrings.alt-4.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb4fb7276c6bd5d00a3c87c8eb7fa0e2", + "name": "keyrings.alt", + "sha256": "97b7136c4b885ecad3ee93c081973faadf8103029ca1b35a51bc7ff473f6af81", + "size": 33459, + "subdir": "linux-64", + "timestamp": 1626447933564, + "version": "4.1.0" + }, + "kiwisolver-1.0.0-py27h5923d62_0.tar.bz2": { + "build": "py27h5923d62_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "007af3d44e70d1ec7245415a170efa79", + "name": "kiwisolver", + "sha256": "04519e3cf5b9bf702e004f5d529a74be631bbb494ad4132ec8649a200f1fa78b", + "size": 87023, + "subdir": "linux-64", + "timestamp": 1508261302614, + "version": "1.0.0" + }, + "kiwisolver-1.0.0-py35h49e2766_0.tar.bz2": { + "build": "py35h49e2766_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "289a97dbc5b670356c1ac25955cc8e56", + "name": "kiwisolver", + "sha256": "7bef8118ec9043abf80cceefb933ad1963e0d73037875befb8bbf0c219f41ae6", + "size": 85536, + "subdir": "linux-64", + "timestamp": 1508261290043, + "version": "1.0.0" + }, + "kiwisolver-1.0.0-py36h506f09e_0.tar.bz2": { + "build": "py36h506f09e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "19ec616cee79d06d9b8572e8266e5e3a", + "name": "kiwisolver", + "sha256": "4bf6a565cd69d922f9801bfacd4a116c06a30cca2c80f5b8f963738af8886987", + "size": 85524, + "subdir": "linux-64", + "timestamp": 1508261305531, + "version": "1.0.0" + }, + "kiwisolver-1.0.1-py27hc15e7b5_0.tar.bz2": { + "build": "py27hc15e7b5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "230c0a2f9631e693d50dd9796152ca9f", + "name": "kiwisolver", + "sha256": "3aabd00c702ea1adcb0004630e75161d1d47d9aa344046830bdce7192475ee18", + "size": 87702, + "subdir": "linux-64", + "timestamp": 1511805540597, + "version": "1.0.1" + }, + "kiwisolver-1.0.1-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8f47cb43102a3e87c6368149cc6c4b6b", + "name": "kiwisolver", + "sha256": "2a3b1da6a90c2cba3a55e88f269a8fd522d990418f559663661d224d6fa0975c", + "size": 87276, + "subdir": "linux-64", + "timestamp": 1530793196224, + "version": "1.0.1" + }, + "kiwisolver-1.0.1-py35hcb1117a_0.tar.bz2": { + "build": "py35hcb1117a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "490984960001e3642a44a8a62eecf456", + "name": "kiwisolver", + "sha256": "cf9429a34c7c27f7a1f85d3a00ef0f65f39ddd2d2237dfedccf0e84d32beda1c", + "size": 85871, + "subdir": "linux-64", + "timestamp": 1511805509554, + "version": "1.0.1" + }, + "kiwisolver-1.0.1-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "965f92af9c16d23abfc243a0ef51d8d5", + "name": "kiwisolver", + "sha256": "633edf9d9c913ac7a1c0f5cdeb60575a183efa151d052f51ab84ce99ec6bc170", + "size": 86654, + "subdir": "linux-64", + "timestamp": 1534955365240, + "version": "1.0.1" + }, + "kiwisolver-1.0.1-py36h764f252_0.tar.bz2": { + "build": "py36h764f252_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b9f5391f57447cca0869e5161b22dd7e", + "name": "kiwisolver", + "sha256": "21c5a98db6ecd966f12e5c342ede7c12ef685215cc507939cdb3125c862755c8", + "size": 85848, + "subdir": "linux-64", + "timestamp": 1511805557717, + "version": "1.0.1" + }, + "kiwisolver-1.0.1-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e311de376a79a6bc2466150ff7339da7", + "name": "kiwisolver", + "sha256": "868d81837e35349c2dbbaac029c2566e5cb74d3e3c52657d37979f177e4af5ca", + "size": 85323, + "subdir": "linux-64", + "timestamp": 1530793238722, + "version": "1.0.1" + }, + "kiwisolver-1.0.1-py37hf484d3e_0.tar.bz2": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2ce73de35c2ac32367266e1218ee0ac1", + "name": "kiwisolver", + "sha256": "8780a0e30cb9a80286c4cd26af111e5c66b3341390a80550b8f0a550376137b0", + "size": 85360, + "subdir": "linux-64", + "timestamp": 1530793280787, + "version": "1.0.1" + }, + "kiwisolver-1.0.1-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "98911e171bc46af18fbb08538b8cac1e", + "name": "kiwisolver", + "sha256": "dd5cdeb3de5147315df3bc8fd2da668ab6245e2780ba55acf2bf450fa34189c3", + "size": 95037, + "subdir": "linux-64", + "timestamp": 1573489791599, + "version": "1.0.1" + }, + "kiwisolver-1.1.0-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4504297c4a172c943217699dbca2db49", + "name": "kiwisolver", + "sha256": "fcc7246e073b21585c6f7215d2a8b934ff9b0cec8a05a05a3bb19a79c66eeb7d", + "size": 93508, + "subdir": "linux-64", + "timestamp": 1556560918632, + "version": "1.1.0" + }, + "kiwisolver-1.1.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a79ef7ec23d816179459b76059f322bf", + "name": "kiwisolver", + "sha256": "644aa1211a31622171fb22e49fe01161fc194c169b5c6c265b59de09877b7c26", + "size": 91777, + "subdir": "linux-64", + "timestamp": 1556560942778, + "version": "1.1.0" + }, + "kiwisolver-1.1.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b4692f437bd50cb18ec43fdbb5ad9bdb", + "name": "kiwisolver", + "sha256": "5dd0dac116dfb20c073b38625893aa876c7a6cfc20a5a9914a823a658c7024fb", + "size": 91739, + "subdir": "linux-64", + "timestamp": 1556560851628, + "version": "1.1.0" + }, + "kiwisolver-1.2.0-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6a030522696e1f327ffdcbef6c178661", + "name": "kiwisolver", + "sha256": "4a2006f76eb18fe5dede8e7b8c591b6d7fb20474970f2e48c65559a9e921b7b1", + "size": 93182, + "subdir": "linux-64", + "timestamp": 1588545733797, + "version": "1.2.0" + }, + "kiwisolver-1.2.0-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ec3bd8d67ac22fecb31335dfd8b373da", + "name": "kiwisolver", + "sha256": "1cf8cfbcbd7990f3147d2ba2db25650ba5514aca91edeb35578404b8bc5292a5", + "size": 93169, + "subdir": "linux-64", + "timestamp": 1588545730625, + "version": "1.2.0" + }, + "kiwisolver-1.2.0-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fe5b7ba18b5114d9cd0768945cf6dd47", + "name": "kiwisolver", + "sha256": "0946b482731933a08eba2a8f875b66d6af2393f3f9a53fc8f69d7104641ff668", + "size": 93535, + "subdir": "linux-64", + "timestamp": 1588545740960, + "version": "1.2.0" + }, + "kiwisolver-1.3.0-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6e248489788fe41ee5b3c8c044db00e5", + "name": "kiwisolver", + "sha256": "9d3cf8023dbc579922703846317df2d396e89fdda20849564ad78b8284159ac5", + "size": 88145, + "subdir": "linux-64", + "timestamp": 1604014622162, + "version": "1.3.0" + }, + "kiwisolver-1.3.0-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "678649e2e6ece51e35ecd41719b502ad", + "name": "kiwisolver", + "sha256": "d682cdd5a64b1d1818fafde396a22cea6869b032a4158d99264710bc4b1d29e3", + "size": 88195, + "subdir": "linux-64", + "timestamp": 1604014595582, + "version": "1.3.0" + }, + "kiwisolver-1.3.0-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20e354abf1e207dbf1cc5167297f4427", + "name": "kiwisolver", + "sha256": "1a4884d6946bbc0e3742fd974784aa49c8491a5d2843ac4a6e1442c3d4b378af", + "size": 88694, + "subdir": "linux-64", + "timestamp": 1604014600301, + "version": "1.3.0" + }, + "kiwisolver-1.3.0-py39h66f3464_0.tar.bz2": { + "build": "py39h66f3464_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c191af9b980b27537113de9797f755a2", + "name": "kiwisolver", + "sha256": "4f970504569edac2bf253286bc282303835b9dd586112704b38ba7606eb3023b", + "size": 92632, + "subdir": "linux-64", + "timestamp": 1607570912735, + "version": "1.3.0" + }, + "kiwisolver-1.3.1-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d4961540c7e5fb7d30cd9e2c315393ff", + "name": "kiwisolver", + "sha256": "71f71cf880f1ca163e8ae153124ca932c9847ce04f3057b2bf0bf5e2c0fe03e7", + "size": 1056253, + "subdir": "linux-64", + "timestamp": 1643038906469, + "version": "1.3.1" + }, + "kiwisolver-1.3.1-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cf308e77f0813f0927762adc58789520", + "name": "kiwisolver", + "sha256": "33b711f6cb380ad0c48845ebe66816ea657a3a3afafd86c4293f8670875049ad", + "size": 88182, + "subdir": "linux-64", + "timestamp": 1612282477750, + "version": "1.3.1" + }, + "kiwisolver-1.3.1-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "647c0a5b19823981a290a56ae1d78529", + "name": "kiwisolver", + "sha256": "2721002984231e4352c0d98861bb155d42e296385b67cc3b4f792b1ec827f668", + "size": 88229, + "subdir": "linux-64", + "timestamp": 1612282475046, + "version": "1.3.1" + }, + "kiwisolver-1.3.1-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20ea2bfaba06c4d2baed15a59db28bc1", + "name": "kiwisolver", + "sha256": "9a24005924e0409cd91a88d101b45a387008e752e9ed5ef720863206bf814622", + "size": 88672, + "subdir": "linux-64", + "timestamp": 1612282488640, + "version": "1.3.1" + }, + "kiwisolver-1.3.1-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ecb7dafd178f46cbe79d3d6004cf49b", + "name": "kiwisolver", + "sha256": "4d8788ddbbd2e5fb608e031a1feb7f9e85043d82300abeb403ea4b92336ebada", + "size": 88641, + "subdir": "linux-64", + "timestamp": 1612281900774, + "version": "1.3.1" + }, + "kiwisolver-1.3.2-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1378ec1577c5748a75f6a3af8f4ca24d", + "name": "kiwisolver", + "sha256": "380b0462678686efdd07f8a0d2a4dfe291dbe729d18cd4cf1974968294adf440", + "size": 88260, + "subdir": "linux-64", + "timestamp": 1638569980628, + "version": "1.3.2" + }, + "kiwisolver-1.3.2-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a5e55b092cc6ea3ef1653526e5f03eec", + "name": "kiwisolver", + "sha256": "ac4baa63e5622a53af053019e2ccce1378902cc26ec10ebf4adb1099f9f9f245", + "size": 88703, + "subdir": "linux-64", + "timestamp": 1638570016144, + "version": "1.3.2" + }, + "kiwisolver-1.3.2-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "31dde8390cfb4c9737297b80f27b249d", + "name": "kiwisolver", + "sha256": "db50263b19be08090ddaa2a861231993266d81b7408847bebf906b66fb945139", + "size": 88569, + "subdir": "linux-64", + "timestamp": 1638569943848, + "version": "1.3.2" + }, + "kiwisolver-1.4.2-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dd78f06c5539e774ae2d302f82961709", + "name": "kiwisolver", + "sha256": "782f57a582753d54f0a92191a7dd7feeb2092b2b4b4c9d0f2a070cf36d2db676", + "size": 1056439, + "subdir": "linux-64", + "timestamp": 1653292125501, + "version": "1.4.2" + }, + "kiwisolver-1.4.2-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee44ea05de20a0a4ea4b31d50ec888f8", + "name": "kiwisolver", + "sha256": "661d9123945008552968d17cd17d4b7093ad0a5bc1979980cbe0b4695c4a806a", + "size": 91941, + "subdir": "linux-64", + "timestamp": 1653292169829, + "version": "1.4.2" + }, + "kiwisolver-1.4.2-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "af1bbc1e7edc97963e8ced3d17542b19", + "name": "kiwisolver", + "sha256": "a1eb0041ef76935f9a6bd6b2615cba9dace682f1ea7ff45ea8f4f45acb3560bf", + "size": 92258, + "subdir": "linux-64", + "timestamp": 1653292259825, + "version": "1.4.2" + }, + "kiwisolver-1.4.2-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "81b969d1a00153759b30554a1f11ddfd", + "name": "kiwisolver", + "sha256": "974df3dc76089be57b327acd6634384def84249003f58678ca1142bb274a75d9", + "size": 92144, + "subdir": "linux-64", + "timestamp": 1653292217019, + "version": "1.4.2" + }, + "kiwisolver-1.4.4-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1728f1fe8a6b260a1097d5723defc547", + "name": "kiwisolver", + "sha256": "847b6b284b1ddb73b398c64bffc4808ca15acd4540b0631d93c3a36c00d1fafa", + "size": 77845, + "subdir": "linux-64", + "timestamp": 1672387187154, + "version": "1.4.4" + }, + "kiwisolver-1.4.4-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eae62735d710cf5ff6d51e6f59fcd999", + "name": "kiwisolver", + "sha256": "b040f0d0ee4588188ab6b83a93738b3ff6e6d1775424be97995bd0df0f4fb904", + "size": 78148, + "subdir": "linux-64", + "timestamp": 1676827253282, + "version": "1.4.4" + }, + "kiwisolver-1.4.4-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fd1ba65f991fa6670d107377796f3692", + "name": "kiwisolver", + "sha256": "155f3faeee9c53d41bfa3ba2e425ec34914825ed8738407e750e029c2223ffc5", + "size": 75353, + "subdir": "linux-64", + "timestamp": 1672387263318, + "version": "1.4.4" + }, + "kiwisolver-1.4.4-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a0f9997ddc49e6a31cf204b04149b3d", + "name": "kiwisolver", + "sha256": "cf12730976bd3123a14fced370792fb29703bb3415a9dc461c1a7b102fff4074", + "size": 77848, + "subdir": "linux-64", + "timestamp": 1672387224889, + "version": "1.4.4" + }, + "kiwisolver-1.4.4-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07957e1d2fb6a407f7d7293b84938e1e", + "name": "kiwisolver", + "sha256": "6d6c384c9c65e33d5d047e01131e0687eb2bc1e5a4a67f80af3c0b773c1bba82", + "size": 77689, + "subdir": "linux-64", + "timestamp": 1672387301020, + "version": "1.4.4" + }, + "knit-0.2.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "96e009a3d354896dc7677861c3a748bf", + "name": "knit", + "sha256": "130e3be96e38887f54faad2a6841c7f3ba275ee85392618d1b8082a5236ebc5a", + "size": 23209324, + "subdir": "linux-64", + "timestamp": 1522783147701, + "version": "0.2.4" + }, + "knit-0.2.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8a75a21cd718b468aa4a4f600904542a", + "name": "knit", + "sha256": "5e52326119e5cb03e2557b13e77e395c975f7330662e7f8be7cc22d14ca354c7", + "size": 23211497, + "subdir": "linux-64", + "timestamp": 1640791279683, + "version": "0.2.4" + }, + "knit-0.2.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.11,<3.12.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d498fb23a40f8a9f1d93efea8188b9be", + "name": "knit", + "sha256": "9b4ada5cb133ea4d2fb5024de287210e51d5595e91326fd722da6b2ba0467c03", + "size": 23223175, + "subdir": "linux-64", + "timestamp": 1676853106637, + "version": "0.2.4" + }, + "knit-0.2.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a529871f620b42e45158bcedc3ee2437", + "name": "knit", + "sha256": "777ddea6579cc1df63563e64639c4e8405a27f10fcd90795c19b75bc05cda786", + "size": 23210864, + "subdir": "linux-64", + "timestamp": 1522783188984, + "version": "0.2.4" + }, + "knit-0.2.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8ad10b6c21a199c0729d044d31a03674", + "name": "knit", + "sha256": "789fe8a1aa7ea0e38b0ea408c50659af90a567d0310ec85ed2b1b897906a4053", + "size": 23210858, + "subdir": "linux-64", + "timestamp": 1522783199614, + "version": "0.2.4" + }, + "knit-0.2.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fd47109d62c2924e62af3be0491a1330", + "name": "knit", + "sha256": "e73735146684cddeb686749347f7e3712fff6741188f818f15e788fc65e8bed4", + "size": 23214454, + "subdir": "linux-64", + "timestamp": 1614178278500, + "version": "0.2.4" + }, + "knit-0.2.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "34f6a3635ef7b68da5a2af1b62be9bf7", + "name": "knit", + "sha256": "8ac2a24c8767e16a45c99f568135a1eecf515f250e33a833b3fa1f664f2ff727", + "size": 23209897, + "subdir": "linux-64", + "timestamp": 1530898309933, + "version": "0.2.4" + }, + "knit-0.2.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e5d51e72b8c47708a596d26476b2c427", + "name": "knit", + "sha256": "f94ff849adc648a069ea9948c67eaf12a8def047c93157feba63658bc7018a8e", + "size": 23220314, + "subdir": "linux-64", + "timestamp": 1614177918952, + "version": "0.2.4" + }, + "knit-0.2.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4d305aa85e9723d7eed96963b556d955", + "name": "knit", + "sha256": "93ed943adaa4930d386e69646ba2689d846ef88c88188f603fda4bd3908d73bc", + "size": 23212522, + "subdir": "linux-64", + "timestamp": 1574238024798, + "version": "0.2.4" + }, + "knit-0.2.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fce84127d450963dde2d064f20f311c5", + "name": "knit", + "sha256": "95dc08dfc1c33115e7180b76db8051ac3bec0fc50ef3614b038abc77142c3b58", + "size": 23212499, + "subdir": "linux-64", + "timestamp": 1614178284825, + "version": "0.2.4" + }, + "knit-0.2.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "247a4802d80d2c2e9f7923de98e6d7ca", + "name": "knit", + "sha256": "88c1ba77b3099007a7072ffd8b2227b6b902c3a16af9cd7cd3657d307a78c94d", + "size": 23212612, + "subdir": "linux-64", + "timestamp": 1614178275589, + "version": "0.2.4" + }, + "kombu-4.6.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "74b79d45edb3455a70322d3dbd5152a8", + "name": "kombu", + "sha256": "f3702fd21cbae1c0a7f62c3223a2f48aaa64e2f6ef80cd53a5588c0de06acc7a", + "size": 290262, + "subdir": "linux-64", + "timestamp": 1595344168085, + "version": "4.6.10" + }, + "kombu-4.6.10-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c44102afd1f500482d557f27a30f7df2", + "name": "kombu", + "sha256": "738c0614921ee5f7d06e6bffd7808ea41aa92c0517aa84d811f769afefe67283", + "size": 283530, + "subdir": "linux-64", + "timestamp": 1595349487271, + "version": "4.6.10" + }, + "kombu-4.6.10-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d384eb7597a04ca9e44591deb0e9a7a5", + "name": "kombu", + "sha256": "97c8717aa3ca3b62507dbc8207ba899c8d8ddd3f46dc7d0bdfa10c443f1172e6", + "size": 291321, + "subdir": "linux-64", + "timestamp": 1595349485445, + "version": "4.6.10" + }, + "kombu-4.6.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "cc9f4ff201e2465d61973fdd17006e28", + "name": "kombu", + "sha256": "dbce008a37f2be16572bf57e9da9b916a5a109b6ceb2a7ed5010578a0550e719", + "size": 285456, + "subdir": "linux-64", + "timestamp": 1596111263573, + "version": "4.6.11" + }, + "kombu-4.6.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c7caf25fc16ba7b3e598905299bb8c79", + "name": "kombu", + "sha256": "b655612b888dfb9b23ad3d5f36db36276d483acedc6305c971b607b05fe14a27", + "size": 290400, + "subdir": "linux-64", + "timestamp": 1596111250326, + "version": "4.6.11" + }, + "kombu-4.6.11-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "cacf33083bf424f64e91a8fba30655b7", + "name": "kombu", + "sha256": "6814f3e97d82cb5d0d6b7e5d659483238d2d271a57eadb9a789720c40a2d42bf", + "size": 287382, + "subdir": "linux-64", + "timestamp": 1596111279096, + "version": "4.6.11" + }, + "kombu-4.6.8-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "amqp >=2.5.2,<2.6", + "importlib_metadata >=0.18", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "3bf202ae26fa62ac4eac59635448692c", + "name": "kombu", + "sha256": "7f01d1b9cb839de3c9cbed17c156d4f41172de83fe5465b3e26079073ce5f318", + "size": 283643, + "subdir": "linux-64", + "timestamp": 1585237611939, + "version": "4.6.8" + }, + "kombu-4.6.8-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "amqp >=2.5.2,<2.6", + "importlib_metadata >=0.18", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "0f7767a3fabb3d219e1924835fdcf0af", + "name": "kombu", + "sha256": "c45dc3717ac7a15df288654645b9954658f4b7e9d5caaa090dbbc8730ee41a78", + "size": 284023, + "subdir": "linux-64", + "timestamp": 1585237573034, + "version": "4.6.8" + }, + "kombu-4.6.8-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "amqp >=2.5.2,<2.6", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "29e69d2396810bb0474655752b7727e1", + "name": "kombu", + "sha256": "ffd2d50457aeb45610ccb753c100936840ff05bea16ef6c2be4e39ba40c1c605", + "size": 290151, + "subdir": "linux-64", + "timestamp": 1585237605606, + "version": "4.6.8" + }, + "kombu-5.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e66e7e96b4380372461fed5816ef1bff", + "name": "kombu", + "sha256": "2034ab03cab397fb13ae92e4e5aecd8ae8cd3cf93177c4162e3835dd2a4dbb62", + "size": 287582, + "subdir": "linux-64", + "timestamp": 1597347980238, + "version": "5.0.0" + }, + "kombu-5.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d413aa1d61487371bf7658544e9dca99", + "name": "kombu", + "sha256": "0ee89086ff8dfdc01f850fa2238500e0364382e7137497cde91fa16a1a2c2487", + "size": 282268, + "subdir": "linux-64", + "timestamp": 1597347975915, + "version": "5.0.0" + }, + "kombu-5.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "bc6e96d95cc06c15a2a55245b819fc90", + "name": "kombu", + "sha256": "de1e1f1ab5185ef8b9e1cbe0e5ad1ad56e2f4079e823494db5c38bbcc6a92905", + "size": 288648, + "subdir": "linux-64", + "timestamp": 1597347985231, + "version": "5.0.0" + }, + "kombu-5.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "92ad96cb24aad8ff7d26273add006a23", + "name": "kombu", + "sha256": "a3942bd203c43ac1b9003c5107fad33ffebce7562a33c3b7e3fe4dbaefc85226", + "size": 282596, + "subdir": "linux-64", + "timestamp": 1598410748986, + "version": "5.0.1" + }, + "kombu-5.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9bbf02df5af52a922f90c21082b2109f", + "name": "kombu", + "sha256": "3404d6782fa7b998ce775cabe5eca0182bc648f428f77a9be7c612cb81e4fab5", + "size": 286545, + "subdir": "linux-64", + "timestamp": 1598410746584, + "version": "5.0.1" + }, + "kombu-5.0.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "dba492331126d67f55adc7a66e6b747e", + "name": "kombu", + "sha256": "e6f8409bbda3046f41b47083f3e83e174dcb50fae45c458edd9852ea37efdebd", + "size": 289528, + "subdir": "linux-64", + "timestamp": 1598410771722, + "version": "5.0.1" + }, + "kombu-5.0.2-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "amqp >=5.0.0,<6.0.0", + "python >=3.10,<3.11.0a0", + "vine" + ], + "license": "BSD-3-Clause", + "md5": "8ae9061407987c072a6b9a1df1bb271c", + "name": "kombu", + "sha256": "704f21bd1bde68951fefb7c2f82adf82715e6d67a35fcb945effbd54ef644f14", + "size": 282515, + "subdir": "linux-64", + "timestamp": 1642513025526, + "version": "5.0.2" + }, + "kombu-5.0.2-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "amqp >=5.0.0,<6.0.0", + "python >=3.11,<3.12.0a0", + "vine" + ], + "license": "BSD-3-Clause", + "md5": "d2d460716e98636e8235ccd49db70009", + "name": "kombu", + "sha256": "c0b8dafeef9bd8a40a93aaf95dce4bf4cb6c0c640b9c604945acba0414fe964a", + "size": 375862, + "subdir": "linux-64", + "timestamp": 1676853132535, + "version": "5.0.2" + }, + "kombu-5.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.6,<3.7.0a0", + "vine <=1.3.0" + ], + "license": "BSD-3-Clause", + "md5": "1005e3c8dce30892db161c570a6be5b8", + "name": "kombu", + "sha256": "e648f1f6a1eb63bbb2f553dfe42753e786c31d9f10fd2ccf9e5c355940f4dd36", + "size": 276826, + "subdir": "linux-64", + "timestamp": 1600557701147, + "version": "5.0.2" + }, + "kombu-5.0.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "amqp >=5.0.0,<6.0.0", + "importlib_metadata >=0.18", + "python >=3.6,<3.7.0a0", + "vine" + ], + "license": "BSD-3-Clause", + "md5": "c8880be87adc24e8b9dce9c224211ea8", + "name": "kombu", + "sha256": "3c3e60f53ac853cdcaef674348788c70b554cb3612657895193063b6887fcfe7", + "size": 283415, + "subdir": "linux-64", + "timestamp": 1607353541356, + "version": "5.0.2" + }, + "kombu-5.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.7,<3.8.0a0", + "vine <=1.3.0" + ], + "license": "BSD-3-Clause", + "md5": "104037c76e3c78aff3bfcdc89269d58d", + "name": "kombu", + "sha256": "177370cde904347987f58fc3ef5e0da0ba7acd9d5f792c4c3c03a31ba29ad50d", + "size": 276915, + "subdir": "linux-64", + "timestamp": 1600557697824, + "version": "5.0.2" + }, + "kombu-5.0.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "amqp >=5.0.0,<6.0.0", + "importlib_metadata >=0.18", + "python >=3.7,<3.8.0a0", + "vine" + ], + "license": "BSD-3-Clause", + "md5": "e9d585de2cdc4fc842ba89dd7829494c", + "name": "kombu", + "sha256": "74e986d8a92e3c2026963551f84d4e78a3bae2f94c1428c4c38a601af8039429", + "size": 283627, + "subdir": "linux-64", + "timestamp": 1607353522523, + "version": "5.0.2" + }, + "kombu-5.0.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "python >=3.8,<3.9.0a0", + "vine <=1.3.0" + ], + "license": "BSD-3-Clause", + "md5": "a23d4d2eecb0800c4c1af64877fc404d", + "name": "kombu", + "sha256": "e532204359482f29bf8d355368637fed2636c3e1b739dbda26c4b7b638d6798b", + "size": 278740, + "subdir": "linux-64", + "timestamp": 1600557698530, + "version": "5.0.2" + }, + "kombu-5.0.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "amqp >=5.0.0,<6.0.0", + "python >=3.8,<3.9.0a0", + "vine" + ], + "license": "BSD-3-Clause", + "md5": "046af743c2659407ca547b6b04f75570", + "name": "kombu", + "sha256": "6a0ea5c872293ed656cc8fa7d074a465ba67b4801577e4bc1b3db75ea9c20cc9", + "size": 289624, + "subdir": "linux-64", + "timestamp": 1607353501128, + "version": "5.0.2" + }, + "kombu-5.0.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "amqp >=5.0.0,<6.0.0", + "python >=3.9,<3.10.0a0", + "vine" + ], + "license": "BSD-3-Clause", + "md5": "27857876649d490688f6a98653305ddc", + "name": "kombu", + "sha256": "c8c6658c7d2a16c51abcb5173a402829400bf54bdd6d43f09f14b2b841c2f68e", + "size": 291481, + "subdir": "linux-64", + "timestamp": 1607353531023, + "version": "5.0.2" + }, + "krb5-1.14.2-h56d4222_4.tar.bz2": { + "build": "h56d4222_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2l,<1.0.3a" + ], + "license": "MIT", + "md5": "3f922e92d0b2eb23024d00b350787ec7", + "name": "krb5", + "sha256": "116216f98713158f3ba1bbaaab234d11d196da547f65d9a5f2abe993ac25cdbf", + "size": 1426819, + "subdir": "linux-64", + "timestamp": 1509379141731, + "version": "1.14.2" + }, + "krb5-1.14.2-h668a083_3.tar.bz2": { + "build": "h668a083_3", + "build_number": 3, + "depends": [ + "libedit", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl 1.0.*", + "tk 8.6.*" + ], + "license": "MIT", + "md5": "1ed2090981c468aeaad21669204a506c", + "name": "krb5", + "sha256": "015497af34f44c01e414649652bcddb6c75668341d2513ced5d6b262c6307334", + "size": 1426052, + "subdir": "linux-64", + "timestamp": 1505851356735, + "version": "1.14.2" + }, + "krb5-1.14.2-hbabe799_5.tar.bz2": { + "build": "hbabe799_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "tk >=8.6.7,<8.7.0a0" + ], + "license": "MIT", + "md5": "a14faefa5af9d4c5afbeeddea6e5ca20", + "name": "krb5", + "sha256": "d6eb99052b0894715b758b9a815cf751b843e358701c3bd5b60ee1c35302bb09", + "size": 1425584, + "subdir": "linux-64", + "timestamp": 1510862694694, + "version": "1.14.2" + }, + "krb5-1.14.2-hcc13386_3.tar.bz2": { + "build": "hcc13386_3", + "build_number": 3, + "depends": [ + "libedit", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl 1.0.*", + "tk 8.6.*" + ], + "license": "MIT", + "md5": "67cd1dbbda33825f401f58d491412fb4", + "name": "krb5", + "sha256": "fbd0448da7a876c00fcfd1af87a0c0c49824fac0a8689d581fc33a48c2f015e4", + "size": 1426181, + "subdir": "linux-64", + "timestamp": 1505851248622, + "version": "1.14.2" + }, + "krb5-1.14.2-hcdc1b81_6.tar.bz2": { + "build": "hcdc1b81_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "tk >=8.6.7,<8.7.0a0" + ], + "license": "MIT", + "md5": "9f3cc5b94c2048f78e7f87fcc137aca9", + "name": "krb5", + "sha256": "c2348368609063009f27a7aa6fc45d5c08ae451fd340f7c3aba6f2e92e0c7188", + "size": 1425876, + "subdir": "linux-64", + "timestamp": 1511386521866, + "version": "1.14.2" + }, + "krb5-1.14.2-hd3fe544_3.tar.bz2": { + "build": "hd3fe544_3", + "build_number": 3, + "depends": [ + "libedit", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl 1.0.*", + "tk 8.6.*" + ], + "license": "MIT", + "md5": "70ed14388b88b6071de9d18f0b470c56", + "name": "krb5", + "sha256": "01532474023d9133fd3ce74c9068d81fcac6ecbf145dbcadebb5d2d4c2b0887b", + "size": 1425861, + "subdir": "linux-64", + "timestamp": 1505851463876, + "version": "1.14.2" + }, + "krb5-1.16-h3f6afd0_6.tar.bz2": { + "build": "h3f6afd0_6", + "build_number": 6, + "depends": [ + "libedit >=3.1,<4.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2n,<1.0.3a", + "tk >=8.6.7,<8.7.0a0" + ], + "license": "MIT", + "md5": "4097b4010aa0aac5c33f0e4a21a3fe0e", + "name": "krb5", + "sha256": "49700ab49c675fd2162883029e523541d44e6009bd93f3a9e62533c12368d95d", + "size": 1361752, + "subdir": "linux-64", + "timestamp": 1519755691640, + "version": "1.16" + }, + "krb5-1.16.1-h173b8e3_7.tar.bz2": { + "build": "h173b8e3_7", + "build_number": 7, + "depends": [ + "libedit >=3.1.20170329,<3.2.0a0", + "libedit >=3.1.20170329,<4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "tk >=8.6.8,<8.7.0a0" + ], + "license": "MIT", + "md5": "5118b37e6679a5c202e5f51ed72aa797", + "name": "krb5", + "sha256": "beedfe3917756134f0c33074d6e19d7b721737b150613b86b4a079da6c4208fe", + "size": 1460071, + "subdir": "linux-64", + "timestamp": 1540589223793, + "version": "1.16.1" + }, + "krb5-1.16.1-hc83ff2d_6.tar.bz2": { + "build": "hc83ff2d_6", + "build_number": 6, + "depends": [ + "libedit >=3.1.20170329,<3.2.0a0", + "libedit >=3.1.20170329,<4.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "tk >=8.6.7,<8.7.0a0" + ], + "license": "MIT", + "md5": "b5c418be620371caac86220202373c5e", + "name": "krb5", + "sha256": "e0e16541d2a18f4431d2e9fec8e2a093e2cc3189be9a22217695ad1d5107eb53", + "size": 1448011, + "subdir": "linux-64", + "timestamp": 1528259004760, + "version": "1.16.1" + }, + "krb5-1.16.4-h173b8e3_0.tar.bz2": { + "build": "h173b8e3_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libedit >=3.1.20181209,<4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "tk >=8.6.8,<8.7.0a0" + ], + "license": "MIT", + "md5": "e3cd8bd281f203260df543faddd2fdec", + "name": "krb5", + "sha256": "a5b0391c9dcaa641cd6772f760c5089e65723d0fdb306acb3fc96d3b8371b7b4", + "size": 1467600, + "subdir": "linux-64", + "timestamp": 1576515758124, + "version": "1.16.4" + }, + "krb5-1.17.1-h173b8e3_0.tar.bz2": { + "build": "h173b8e3_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libedit >=3.1.20181209,<4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "tk >=8.6.8,<8.7.0a0" + ], + "license": "MIT", + "md5": "21ff64d7e6005a20bcbc0f97474c55f9", + "name": "krb5", + "sha256": "528e3a593ccb35dcb43971ca947f3ecd3c42268f0cfb5186ab2b562b06e84df6", + "size": 1540456, + "subdir": "linux-64", + "timestamp": 1576540393941, + "version": "1.17.1" + }, + "krb5-1.18.2-h173b8e3_0.tar.bz2": { + "build": "h173b8e3_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20191231,<3.2.0a0", + "libedit >=3.1.20191231,<4.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a" + ], + "license": "MIT", + "md5": "48775aa9100c66a72154b335d725c2e6", + "name": "krb5", + "sha256": "1aafc5ba31cec5bac353a4a227851a973cac4406ee4af236ed85dd1558f324aa", + "size": 1524969, + "subdir": "linux-64", + "timestamp": 1593436520744, + "version": "1.18.2" + }, + "krb5-1.19.1-h3535a68_0.tar.bz2": { + "build": "h3535a68_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20191231,<3.2.0a0", + "libedit >=3.1.20191231,<4.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "MIT", + "md5": "3d855f940c26a9851c94858c97f8940b", + "name": "krb5", + "sha256": "754304a276e3066c6d8b7d74486ae0817c2a10b7f2dc1b8c479ec8123dffb043", + "size": 1523283, + "subdir": "linux-64", + "timestamp": 1613679171439, + "version": "1.19.1" + }, + "krb5-1.19.2-hac12032_0.tar.bz2": { + "build": "hac12032_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20210216,<3.2.0a0", + "libedit >=3.1.20210216,<4.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "MIT", + "md5": "fe9cc044a22b2fc3a5a0699e2fde72fd", + "name": "krb5", + "sha256": "19b886c33c110a8a7a3616ebd9b5c18efc7653e42a40e36d6d6179ac591169b1", + "size": 1447400, + "subdir": "linux-64", + "timestamp": 1627388807149, + "version": "1.19.2" + }, + "krb5-1.19.4-h568e23c_0.tar.bz2": { + "build": "h568e23c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20221030,<3.2.0a0", + "libedit >=3.1.20221030,<4.0a0", + "libgcc-ng >=11.2.0", + "openssl >=1.1.1s,<1.1.2a" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f72dd6c996afe8e088d587932aaaadd5", + "name": "krb5", + "sha256": "00821f3ae7e44f8f86d53018486a0b8268943ec70b65b0d1d2640bdd481c7134", + "size": 1449565, + "subdir": "linux-64", + "timestamp": 1674242843410, + "version": "1.19.4" + }, + "lame-3.100-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "LGPL", + "md5": "89c4b52f7f550c3dff5ad8e9221a1ccc", + "name": "lame", + "sha256": "b660f96a449adcc063364f0f69145522f33900eea18f365f8abad5e7f6db000c", + "size": 514126, + "subdir": "linux-64", + "timestamp": 1576633249203, + "version": "3.100" + }, + "lancet-0.9.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "param", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7c4b8b1bf30b59af9b83330c9213ca88", + "name": "lancet", + "sha256": "69d61a52b04a9c6671796d4389d7e4111238b4d9bdf0606c8b54b9407e6bff37", + "size": 59824, + "subdir": "linux-64", + "timestamp": 1527884547169, + "version": "0.9.0" + }, + "lancet-0.9.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "param", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9ba5a4be7efc353d57d785d13fb7eddc", + "name": "lancet", + "sha256": "9ff5874cf95ebec7aabca3d42bd4ae505c41db975d037ba44e3145a4846b8ebb", + "size": 63201, + "subdir": "linux-64", + "timestamp": 1640791305113, + "version": "0.9.0" + }, + "lancet-0.9.0-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "param", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f2ad677ee2c9536518a1f45740debc47", + "name": "lancet", + "sha256": "3a69514ed1462371e27b4556066370aebd5838ad89bb8d837710028e20890e31", + "size": 85595, + "subdir": "linux-64", + "timestamp": 1676853147162, + "version": "0.9.0" + }, + "lancet-0.9.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "param", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b4b0494431d3ad9e9e07ba23082a4435", + "name": "lancet", + "sha256": "2ef982f448918fdf73f7b147922b0c2d6862bd85c4e9ea9aa58ff920afd51ebf", + "size": 62117, + "subdir": "linux-64", + "timestamp": 1527884558254, + "version": "0.9.0" + }, + "lancet-0.9.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9ca946d20e9a9c6e91532bdab679a61b", + "name": "lancet", + "sha256": "e4a3b0567b66e0a8d3f7af02f66f0a775fe312cf43676f97a0e5671d8b8aedf0", + "size": 61970, + "subdir": "linux-64", + "timestamp": 1527884653971, + "version": "0.9.0" + }, + "lancet-0.9.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2e4281d37495125796019411f8fccb6d", + "name": "lancet", + "sha256": "26126eefbeca89631c697c519d9a15f3fd5cbdcb87fe1736213ddc72b7120a9a", + "size": 62648, + "subdir": "linux-64", + "timestamp": 1632881051312, + "version": "0.9.0" + }, + "lancet-0.9.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "param", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "df9bfffb23ae080312b877deed02a11e", + "name": "lancet", + "sha256": "ef213df985b1310421b48b12ff357f70a0f04be6b756d61a90dad0c7fc1e2305", + "size": 62730, + "subdir": "linux-64", + "timestamp": 1632891463158, + "version": "0.9.0" + }, + "lancet-0.9.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "param", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8c5abe512f3a5c1722ff30fae8662d8a", + "name": "lancet", + "sha256": "7d673441982b46fcfe95116d8a49f64d882a0a64a79b24635c311bf38604f410", + "size": 63182, + "subdir": "linux-64", + "timestamp": 1632891453725, + "version": "0.9.0" + }, + "lancet-0.9.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "param", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d2541b024e9c7e8742337c1a5bbc3ce7", + "name": "lancet", + "sha256": "4dbf4429bef91f0fa42a76d65e10efd76f8fc254b9a81fc504e309654585efdb", + "size": 63144, + "subdir": "linux-64", + "timestamp": 1632891463960, + "version": "0.9.0" + }, + "lark-1.1.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "js2py", + "python >=3.10,<3.11.0a0", + "regex" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f711f123a1ba87688d393bdf7f116c5c", + "name": "lark", + "sha256": "798895eb1466327cc1a043586a9fb707d19a39113b96d9236b00470af52bc012", + "size": 168912, + "subdir": "linux-64", + "timestamp": 1663951822673, + "version": "1.1.2" + }, + "lark-1.1.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "js2py", + "python >=3.11,<3.12.0a0", + "regex" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "25246eabf4c5e7d9935eaa64f72516dc", + "name": "lark", + "sha256": "9c6f5d36a0a49c30d4a6a62436f559b32e783ca71bfd947fed648cc67316965d", + "size": 231919, + "subdir": "linux-64", + "timestamp": 1679340099904, + "version": "1.1.2" + }, + "lark-1.1.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "js2py", + "python >=3.7,<3.8.0a0", + "regex" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cbe38e6033ff4890e910850821cc8428", + "name": "lark", + "sha256": "97c9e2a3002d2e6741fef45c67f75c559709b7ad9b5d5785d06a83c1b23f50c7", + "size": 166346, + "subdir": "linux-64", + "timestamp": 1663951780421, + "version": "1.1.2" + }, + "lark-1.1.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "js2py", + "python >=3.8,<3.9.0a0", + "regex" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d411a8c7b04cefc391da20d0f5d7a77b", + "name": "lark", + "sha256": "b8fb8501348b179892c6bf54e3b1ed2c12fb0a8b7fb1c53cf3045a4da1acc670", + "size": 166665, + "subdir": "linux-64", + "timestamp": 1663951752058, + "version": "1.1.2" + }, + "lark-1.1.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "js2py", + "python >=3.9,<3.10.0a0", + "regex" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0640bf4686020e8618fa2b212f3b36b", + "name": "lark", + "sha256": "2af533e8055fe49db24b02b4caea33d7999cbb6f1ffec839f9d547cc9062d269", + "size": 166447, + "subdir": "linux-64", + "timestamp": 1663951852208, + "version": "1.1.2" + }, + "lazy-object-proxy-1.3.1-py27h14c3975_2.tar.bz2": { + "build": "py27h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "655ded9001726195573a80444bb2f047", + "name": "lazy-object-proxy", + "sha256": "559fa170cb119c7aebcab969b78552fb0e47bc13b36412068df65dc565f1298e", + "size": 29824, + "subdir": "linux-64", + "timestamp": 1530737934236, + "version": "1.3.1" + }, + "lazy-object-proxy-1.3.1-py27h682c727_0.tar.bz2": { + "build": "py27h682c727_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "83581e1db3d0ce60d00db1f8703b41d1", + "name": "lazy-object-proxy", + "sha256": "cb0a33faccf39a2388f1fcee6a7533acd0f5b0bb029670ea22e105b9d160ae56", + "size": 29630, + "subdir": "linux-64", + "timestamp": 1505693814804, + "version": "1.3.1" + }, + "lazy-object-proxy-1.3.1-py35h14c3975_2.tar.bz2": { + "build": "py35h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "8a3d5c5d68abe84f96d95389d2f18b85", + "name": "lazy-object-proxy", + "sha256": "71cea349e003cedd9c4ce384f82cbc770ce5328150d58f2ef8e11686a20e66a6", + "size": 30227, + "subdir": "linux-64", + "timestamp": 1534352853265, + "version": "1.3.1" + }, + "lazy-object-proxy-1.3.1-py35h4c720c6_0.tar.bz2": { + "build": "py35h4c720c6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "34e75e5c5d297b2aa11e424f99db1cce", + "name": "lazy-object-proxy", + "sha256": "be620b9068992ab407bb5a2af605ba0a0136ee26e334775c281312b8a8fee645", + "size": 30118, + "subdir": "linux-64", + "timestamp": 1505693829994, + "version": "1.3.1" + }, + "lazy-object-proxy-1.3.1-py36h10fcdad_0.tar.bz2": { + "build": "py36h10fcdad_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "69595ff655f6c4adf9f4b61c73ec7e5e", + "name": "lazy-object-proxy", + "sha256": "d8a684be9d17b9bc838f26e76e04974dc72e7beb309f3b7302a843b99cc2a43f", + "size": 30077, + "subdir": "linux-64", + "timestamp": 1505693845469, + "version": "1.3.1" + }, + "lazy-object-proxy-1.3.1-py36h14c3975_2.tar.bz2": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "f82e36ba2edafd2ea6d11584d8377703", + "name": "lazy-object-proxy", + "sha256": "6dfe617dff32fcfa1d2f2068e3d405781c8bded191e2209c0ccbd81acd740de5", + "size": 30241, + "subdir": "linux-64", + "timestamp": 1530737911582, + "version": "1.3.1" + }, + "lazy-object-proxy-1.3.1-py37h14c3975_2.tar.bz2": { + "build": "py37h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "e6acbf833c27c6449004c371a3532c2b", + "name": "lazy-object-proxy", + "sha256": "effcd15e76d2a0242510ec2b42388e70d3f5adfa9c711c9925c46efd78d8895d", + "size": 30276, + "subdir": "linux-64", + "timestamp": 1530737956788, + "version": "1.3.1" + }, + "lazy-object-proxy-1.4.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "951dd6c671380d8a1c46261ee07da269", + "name": "lazy-object-proxy", + "sha256": "0781d4c58f201dac2259411ceda46ef1536cc869c7dbdf0107ff45e37eca0066", + "size": 33621, + "subdir": "linux-64", + "timestamp": 1557506321762, + "version": "1.4.0" + }, + "lazy-object-proxy-1.4.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "9f7a84dc27080f8a5992dc4fa3c3ba9c", + "name": "lazy-object-proxy", + "sha256": "13ca361ceea48a23158953fb707ad4ab5fdca084163dc517a6618bf57d759dd5", + "size": 34170, + "subdir": "linux-64", + "timestamp": 1557506389660, + "version": "1.4.0" + }, + "lazy-object-proxy-1.4.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "3b3fbf821d78ee090195847198a6f3ae", + "name": "lazy-object-proxy", + "sha256": "5e3753dc5e60424e6f347f55db2221f2f2092524de3388e84a7095b8c17ca05c", + "size": 34107, + "subdir": "linux-64", + "timestamp": 1557506322044, + "version": "1.4.0" + }, + "lazy-object-proxy-1.4.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "2176a90f68ede51398fd3705392ff0d4", + "name": "lazy-object-proxy", + "sha256": "fa0acb838cfd7832dae996d235050852d9a01769cc974810099fe1d8a19f9218", + "size": 30169, + "subdir": "linux-64", + "timestamp": 1558026953991, + "version": "1.4.1" + }, + "lazy-object-proxy-1.4.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "aac7f01ab74ab0dfc4bfa3ceadfa29cb", + "name": "lazy-object-proxy", + "sha256": "6ef3a7ca015870160ac98188b23d42fa40841446b76869afd5ba0fb4dd495f94", + "size": 30615, + "subdir": "linux-64", + "timestamp": 1558027042190, + "version": "1.4.1" + }, + "lazy-object-proxy-1.4.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "678b4f8f039ba0ed90374648e313b7f7", + "name": "lazy-object-proxy", + "sha256": "a02e43a343d6e0691c43901acdcc7f246ccf247058c0064e3840924d9f1530e3", + "size": 30693, + "subdir": "linux-64", + "timestamp": 1558027023549, + "version": "1.4.1" + }, + "lazy-object-proxy-1.4.2-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "ccff3ffbb89d8b9a829481908d4302eb", + "name": "lazy-object-proxy", + "sha256": "c3886f5832523057f7e2827d340867568f5b94e4e77ed08b6483c1790dd1bb49", + "size": 30404, + "subdir": "linux-64", + "timestamp": 1566571436953, + "version": "1.4.2" + }, + "lazy-object-proxy-1.4.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "316eabf2c460c6330dcfe457fe4fff5e", + "name": "lazy-object-proxy", + "sha256": "3824f81bc187f616608f239358d43a1cc60e642d90b11b3b1ce9afe88c4afd37", + "size": 30936, + "subdir": "linux-64", + "timestamp": 1566571428047, + "version": "1.4.2" + }, + "lazy-object-proxy-1.4.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "e7005abc48694fdc3c9bbdd5bfeb7256", + "name": "lazy-object-proxy", + "sha256": "667282f9b7a4f0013e33143a43ce48a852aa0c24b99407e0c029e85c76aae6a9", + "size": 30927, + "subdir": "linux-64", + "timestamp": 1566571398106, + "version": "1.4.2" + }, + "lazy-object-proxy-1.4.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "5a475bc72eb63b62047eadaa77e03ba7", + "name": "lazy-object-proxy", + "sha256": "ff33ba5192418479b79d58a28797bb03f82c6b4ed73506bfe9986b66ac1cd8ed", + "size": 35581, + "subdir": "linux-64", + "timestamp": 1573489820587, + "version": "1.4.2" + }, + "lazy-object-proxy-1.4.3-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "17673e793bda8db3cde427181bd43c6f", + "name": "lazy-object-proxy", + "sha256": "a1679319a505343dc2c664a6c55b2ae241fba05f56040ad20e1b7c14734fcce3", + "size": 31049, + "subdir": "linux-64", + "timestamp": 1573080326770, + "version": "1.4.3" + }, + "lazy-object-proxy-1.4.3-py36h27cfd23_2.tar.bz2": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "d00090d1e64a4a7d590873da01e39730", + "name": "lazy-object-proxy", + "sha256": "3be115cbf1a36273dcf25c5d3cc5c9df0f9a39bfaa65c34312a6ea4695fe21aa", + "size": 32337, + "subdir": "linux-64", + "timestamp": 1607707373307, + "version": "1.4.3" + }, + "lazy-object-proxy-1.4.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "14a57a56be79ded4a74876d9e7050983", + "name": "lazy-object-proxy", + "sha256": "1619205de98f7bd5a1c47498f99e9ec0b8a3d11cc60f809f1d83663516433035", + "size": 31516, + "subdir": "linux-64", + "timestamp": 1573080363921, + "version": "1.4.3" + }, + "lazy-object-proxy-1.4.3-py37h27cfd23_2.tar.bz2": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "99eb08e2ac7d1c256596f3853562dfa0", + "name": "lazy-object-proxy", + "sha256": "c1b5128b36a532592a2a9a3ce76240b80f872690972caadc897cbf4a79de3280", + "size": 32401, + "subdir": "linux-64", + "timestamp": 1607707358780, + "version": "1.4.3" + }, + "lazy-object-proxy-1.4.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "19c0a8b5bb1c757c037aa051ae1bfc91", + "name": "lazy-object-proxy", + "sha256": "b72ce84a7454454ad610b702ee24616090f2cb156ff628d507c78156c6950382", + "size": 31545, + "subdir": "linux-64", + "timestamp": 1573080326793, + "version": "1.4.3" + }, + "lazy-object-proxy-1.4.3-py38h27cfd23_2.tar.bz2": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "04efbf8f92667b7d09db4cdf00395c8a", + "name": "lazy-object-proxy", + "sha256": "d7edd67f36fafa9b088e9485cfdfe336076307c2e84511d05a964b3f984ad9ff", + "size": 32678, + "subdir": "linux-64", + "timestamp": 1607707403067, + "version": "1.4.3" + }, + "lazy-object-proxy-1.4.3-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "2b49301d5f948217a7917dfa2cec6218", + "name": "lazy-object-proxy", + "sha256": "e4181c2c468934d225ab92cf506830ca20ea555566dbffce033471c992c76c90", + "size": 38624, + "subdir": "linux-64", + "timestamp": 1573080360085, + "version": "1.4.3" + }, + "lazy-object-proxy-1.4.3-py39h27cfd23_2.tar.bz2": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "md5": "4b05fd6bdb778b542014daeb99ef9bb2", + "name": "lazy-object-proxy", + "sha256": "caa00e9d34e8a039eab958daf259965687530620e4e7a3c7de3447a963e871d4", + "size": 32720, + "subdir": "linux-64", + "timestamp": 1607707375743, + "version": "1.4.3" + }, + "lazy-object-proxy-1.5.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "cffbe26012c43d4fe4328f4961f88cf7", + "name": "lazy-object-proxy", + "sha256": "ef7bf12d3f54e9be7e67cab4e0dbc62130e5e9003a3b10eea73ebe1c06c44bb4", + "size": 32908, + "subdir": "linux-64", + "timestamp": 1592328146755, + "version": "1.5.0" + }, + "lazy-object-proxy-1.5.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "4a913eec2afbb8dfb333d6f9067209a0", + "name": "lazy-object-proxy", + "sha256": "6321e1f3154d12716a37861efd54adcd303f4272266519f81893e77a7c3c9f55", + "size": 32895, + "subdir": "linux-64", + "timestamp": 1592328160498, + "version": "1.5.0" + }, + "lazy-object-proxy-1.5.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "647f0f74e08f45a51c534fced3903822", + "name": "lazy-object-proxy", + "sha256": "67937466283f34e9c3b90a896385f02be116e1517c315d09b62d63f3dc33adeb", + "size": 33279, + "subdir": "linux-64", + "timestamp": 1592328133378, + "version": "1.5.0" + }, + "lazy-object-proxy-1.5.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "8747ba7f22430542d9773516e08fed1c", + "name": "lazy-object-proxy", + "sha256": "05c9e4a6d02f3a7073897d98c9dc417bd7671580c08aa3117c33f71af3ef0eeb", + "size": 33448, + "subdir": "linux-64", + "timestamp": 1597442141426, + "version": "1.5.1" + }, + "lazy-object-proxy-1.5.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "c2059c77a767972fc2ea995a5dba5982", + "name": "lazy-object-proxy", + "sha256": "2b4d74c962da5660dd1468d933a7cf2041dc18347ef829aca48cd8e0d66970c4", + "size": 33424, + "subdir": "linux-64", + "timestamp": 1597442157229, + "version": "1.5.1" + }, + "lazy-object-proxy-1.5.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "6e70ddcec9215a6f450d4f9dcc4dd2dc", + "name": "lazy-object-proxy", + "sha256": "6fcac5c4694ea51262f2c9d9ae813b2d663403f141edc1bed0bb748978f013f0", + "size": 33813, + "subdir": "linux-64", + "timestamp": 1597442156985, + "version": "1.5.1" + }, + "lazy-object-proxy-1.5.2-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "4ae35cd13db082dbfd752dc005f3b94a", + "name": "lazy-object-proxy", + "sha256": "9ceeda89d98144fe3f9136d1188b33c7f3dd20ca95f69c4f0db7de509f906aeb", + "size": 29391, + "subdir": "linux-64", + "timestamp": 1606850116253, + "version": "1.5.2" + }, + "lazy-object-proxy-1.5.2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "9e1bd42c77d65febff79ecf752032867", + "name": "lazy-object-proxy", + "sha256": "972e002e8735fa6d9e30df53a8152d7bff36a9ebc35afe1cdfd30c98e3a53616", + "size": 29349, + "subdir": "linux-64", + "timestamp": 1606850081152, + "version": "1.5.2" + }, + "lazy-object-proxy-1.5.2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "876b00c25e4220ae917d29aaa92e3e85", + "name": "lazy-object-proxy", + "sha256": "eea907e2e3e0c79db95e35b695ab54d6b8b1e510c1f01005a44f55394b3baed6", + "size": 29712, + "subdir": "linux-64", + "timestamp": 1606850097090, + "version": "1.5.2" + }, + "lazy-object-proxy-1.5.2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "md5": "3e0558540c7efeb144eee4edc328f19b", + "name": "lazy-object-proxy", + "sha256": "b08dcef696002e7cba04f49b95ff63979afd30b9473a9a6c6679543c1c1e70f3", + "size": 29757, + "subdir": "linux-64", + "timestamp": 1606850130322, + "version": "1.5.2" + }, + "lazy-object-proxy-1.6.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "md5": "c9ed278c58b40545f179073da705db99", + "name": "lazy-object-proxy", + "sha256": "6ad28f50a2330ab64a86b04a98d9d3808313728488f34a24fe724147f0c164b9", + "size": 59627, + "subdir": "linux-64", + "timestamp": 1640791329792, + "version": "1.6.0" + }, + "lazy-object-proxy-1.6.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "md5": "57a5749dd6139f87ab80dc217c742dbb", + "name": "lazy-object-proxy", + "sha256": "b5946dcc9d97cf6723c15d1c58b64949309f8e806816a59d8103c3b4cfd53490", + "size": 37766, + "subdir": "linux-64", + "timestamp": 1676827272418, + "version": "1.6.0" + }, + "lazy-object-proxy-1.6.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "6aa77f384fc974429fc478a6230de5ba", + "name": "lazy-object-proxy", + "sha256": "f4b09a249a766e3ce57048e25c4519e3d5d8ab172fab6acf06cccd21452455a3", + "size": 31670, + "subdir": "linux-64", + "timestamp": 1616526969119, + "version": "1.6.0" + }, + "lazy-object-proxy-1.6.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "0d9f4eab30a03b0cc0fd40b242290767", + "name": "lazy-object-proxy", + "sha256": "098cee4f9cc448dddc7e421684867c8a5829d68165d865e183e79ccfd54d41fd", + "size": 31694, + "subdir": "linux-64", + "timestamp": 1616529129646, + "version": "1.6.0" + }, + "lazy-object-proxy-1.6.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "df1be7e94430bc6ed14be907a48008d4", + "name": "lazy-object-proxy", + "sha256": "6e2912e1376160430c0a64c3cb6712e5643e28176036059c9e0cd49646ba0fad", + "size": 32041, + "subdir": "linux-64", + "timestamp": 1616526968966, + "version": "1.6.0" + }, + "lazy-object-proxy-1.6.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "md5": "bc3b5a69d04269afb6e490a83f1477d0", + "name": "lazy-object-proxy", + "sha256": "d8b2fd69e6962e1cf236c25027d60169c255892720861b715f03acbc8b6e6216", + "size": 32101, + "subdir": "linux-64", + "timestamp": 1616529071988, + "version": "1.6.0" + }, + "lazy_loader-0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "68f965cba3b7a4031cdc34f217ee210f", + "name": "lazy_loader", + "sha256": "89694322b0309d2cbd22493b99e4cb2de327fa8fb8a0e9f994be35aabf4d21c5", + "size": 16487, + "subdir": "linux-64", + "timestamp": 1679411931777, + "version": "0.1" + }, + "lazy_loader-0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "fdbc741a0df2feaa150267846bcc9264", + "name": "lazy_loader", + "sha256": "84bbdb599b297cc4b2f8d45118a446335b99c827e175031832901721cd813c7f", + "size": 19328, + "subdir": "linux-64", + "timestamp": 1679411907109, + "version": "0.1" + }, + "lazy_loader-0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e404ab70633d3a21f441bb6bb87f472a", + "name": "lazy_loader", + "sha256": "e02ea457e621b5eb54e823ed4004b7365577d3945e9f08a98b4025cd72752842", + "size": 16453, + "subdir": "linux-64", + "timestamp": 1679411979942, + "version": "0.1" + }, + "lazy_loader-0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e3feb9d27743a82d044ce688e1286b85", + "name": "lazy_loader", + "sha256": "80dd6eec3e023e4476ff60d3ea341eb06ba9097b28068402c9069ad01790f523", + "size": 16413, + "subdir": "linux-64", + "timestamp": 1679411955197, + "version": "0.1" + }, + "lcms2-2.11-h396b838_0.tar.bz2": { + "build": "h396b838_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ac8b0fb0f25b61a73c0f033e5cbe3295", + "name": "lcms2", + "sha256": "36e99af642cd9a5be9eaa0db14c82420b0091e695dbfd20eeb2e71864d1a7260", + "size": 429176, + "subdir": "linux-64", + "timestamp": 1593198336289, + "version": "2.11" + }, + "lcms2-2.12-h3be6417_0.tar.bz2": { + "build": "h3be6417_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "653b4f425f6d4a21f04619b1f5f8aa43", + "name": "lcms2", + "sha256": "415b837a89c718d1ae308611125e359b03907ccdebbec5240ebccff9c5c62356", + "size": 405739, + "subdir": "linux-64", + "timestamp": 1617648674152, + "version": "2.12" + }, + "ld64-530-h0c34534_25.tar.bz2": { + "build": "h0c34534_25", + "build_number": 25, + "constrains": [ + "cctools_linux-64 949.0.1.*", + "cctools 949.0.1.*" + ], + "depends": [ + "ld64_linux-64 530 h3868468_25" + ], + "license": "APSL-2.0", + "license_family": "Other", + "md5": "ef1ddfd02dde16cdece1c471403d1448", + "name": "ld64", + "sha256": "0e554e8b3ac95fb213be9a644dfe234bb33a7992ca93ee8d82900d688abd8ce7", + "size": 14950, + "subdir": "linux-64", + "timestamp": 1662554230436, + "version": "530" + }, + "ld64_linux-64-530-h3868468_25.tar.bz2": { + "build": "h3868468_25", + "build_number": 25, + "constrains": [ + "cctools_linux-64 949.0.1.*", + "clang >=14.0.6,<15.0a0", + "cctools 949.0.1.*", + "ld 530.*" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "libuuid >=1.0.3,<2.0a0", + "tapi >=1100.0.11,<1101.0a0" + ], + "license": "APSL-2.0", + "license_family": "Other", + "md5": "946d9849fd1af1ec602eeccd1e8ce9d6", + "name": "ld64_linux-64", + "sha256": "7992a89a39e26561a482aa5341792faaee3d0628aabf6d89f3575d7b25da8963", + "size": 7807503, + "subdir": "linux-64", + "timestamp": 1662554195053, + "version": "530" + }, + "ld_impl_linux-64-2.33.1-h53a641e_7.tar.bz2": { + "build": "h53a641e_7", + "build_number": 7, + "depends": [], + "license": "GPL 3", + "md5": "85a01d2f8a5faa97fa2dfcc7ad7852e6", + "name": "ld_impl_linux-64", + "sha256": "5c196b348ee871657d2508bece2c697692418584c5558ee3f8b87c3992c7c660", + "size": 660486, + "subdir": "linux-64", + "timestamp": 1576704246287, + "version": "2.33.1" + }, + "ld_impl_linux-64-2.35.1-h7274673_9.tar.bz2": { + "build": "h7274673_9", + "build_number": 9, + "constrains": [ + "binutils_impl_linux-64 2.35.1" + ], + "depends": [], + "license": "GPL-3.0-only", + "md5": "74753bc14c44f52ce318f4385c746eb8", + "name": "ld_impl_linux-64", + "sha256": "90fcb03d8f04099b57f0f1ea7e29ebeaba9515ac3917a586a4f4b5af55b7523c", + "size": 652172, + "subdir": "linux-64", + "timestamp": 1622698544714, + "version": "2.35.1" + }, + "ld_impl_linux-64-2.38-h1181459_0.tar.bz2": { + "build": "h1181459_0", + "build_number": 0, + "constrains": [ + "binutils_impl_linux-64 2.38" + ], + "depends": [], + "license": "GPL-3.0-only", + "md5": "be7dbe9ce5a4f9d43e67acfd8fe69a0a", + "name": "ld_impl_linux-64", + "sha256": "a7a0bc3d05b140041d02e8fe7fd0fd50f375faf3e8d963de1ef497696dd804d6", + "size": 756331, + "subdir": "linux-64", + "timestamp": 1652588230998, + "version": "2.38" + }, + "ld_impl_linux-64-2.38-h1181459_1.tar.bz2": { + "build": "h1181459_1", + "build_number": 1, + "constrains": [ + "binutils_impl_linux-64 2.38" + ], + "depends": [], + "license": "GPL-3.0-only", + "md5": "9508af80612e4fa1b5d1abb43ca7e63c", + "name": "ld_impl_linux-64", + "sha256": "9efd56db85f14f597db9844207d0fa81cbdc5d7a163ca38a7c5dd6c08219db21", + "size": 749072, + "subdir": "linux-64", + "timestamp": 1652971360657, + "version": "2.38" + }, + "ldap3-2.3-py27hcb53f9d_0.tar.bz2": { + "build": "py27hcb53f9d_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "0f48c7aef97a1e77fb939405781a5353", + "name": "ldap3", + "sha256": "4a3086e27f87683d8fe13cc28596e55e15c55911991e3017aef52dabf9f9d986", + "size": 439932, + "subdir": "linux-64", + "timestamp": 1507979328562, + "version": "2.3" + }, + "ldap3-2.3-py35h8e63e30_0.tar.bz2": { + "build": "py35h8e63e30_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "cc95420430821a162cb53fd5e2f41180", + "name": "ldap3", + "sha256": "4d9b428e2350631daca1627bb0a99ebecdbba0df47bfc13b69ba5bc7bb027004", + "size": 445742, + "subdir": "linux-64", + "timestamp": 1507979341514, + "version": "2.3" + }, + "ldap3-2.3-py36h3a9aeb9_0.tar.bz2": { + "build": "py36h3a9aeb9_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "bda1b19810d39e550ed1c6d13b9c12fc", + "name": "ldap3", + "sha256": "a0296d5179613c2812fa30d2d5128baf89a78097b8358b12f3a22b612a85254a", + "size": 439549, + "subdir": "linux-64", + "timestamp": 1507979337932, + "version": "2.3" + }, + "ldap3-2.4-py27h4f5a97a_0.tar.bz2": { + "build": "py27h4f5a97a_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "3c1c40206b459b36bcb33c6663c506aa", + "name": "ldap3", + "sha256": "29648db62c57e12bd5f623a88f18165d536d0c6eb44211eefef3001de584a496", + "size": 440872, + "subdir": "linux-64", + "timestamp": 1511808749761, + "version": "2.4" + }, + "ldap3-2.4-py35h5cb38fc_0.tar.bz2": { + "build": "py35h5cb38fc_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "5e962eb2d50782e844763036ffc157b0", + "name": "ldap3", + "sha256": "a8e77e51d3eab06b21691f7162d72f39d1d54f74b18d8ea2958884c66a455721", + "size": 447976, + "subdir": "linux-64", + "timestamp": 1511808759856, + "version": "2.4" + }, + "ldap3-2.4-py36hcd36b8f_0.tar.bz2": { + "build": "py36hcd36b8f_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "dfd1b48339d588594c852b60ff6d7ff6", + "name": "ldap3", + "sha256": "ca8d13106c446339a9a626a63cef848487b0d4f28ac60f331db3175918f3d62f", + "size": 442912, + "subdir": "linux-64", + "timestamp": 1511808759111, + "version": "2.4" + }, + "ldap3-2.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "42cece52f3a07397ffc50d1cc4c166ea", + "name": "ldap3", + "sha256": "65d9c3c8ed6a94f12ab9705e152c4679482d1cbe18e02b3bbed0542acf25e742", + "size": 441333, + "subdir": "linux-64", + "timestamp": 1520880232097, + "version": "2.4.1" + }, + "ldap3-2.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "4153d7255a55f2599d28487d1c789249", + "name": "ldap3", + "sha256": "80ba66850a5835d3eb64d2773e21058f76902d3a07b6012b25958d7771ab58c7", + "size": 450673, + "subdir": "linux-64", + "timestamp": 1520880264823, + "version": "2.4.1" + }, + "ldap3-2.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "c60385a893a880c69d63ff580720f153", + "name": "ldap3", + "sha256": "56a68f4873b68d3e17705743ea7321303a7e96de5904d715cbc8ef61ce87b279", + "size": 445302, + "subdir": "linux-64", + "timestamp": 1520880205168, + "version": "2.4.1" + }, + "ldap3-2.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "a68c5f2c0326e0227d8782b772b316df", + "name": "ldap3", + "sha256": "4c765d695c5f5f823467a211b046b7556a724cb62518bc5835cd033ef9c057a8", + "size": 445311, + "subdir": "linux-64", + "timestamp": 1524070577726, + "version": "2.5" + }, + "ldap3-2.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "51390296c426716a84b8d45f45b74c41", + "name": "ldap3", + "sha256": "99f9073e23fcef7e07e728b3c4b5ea4f90f1be7e7ad0b53ad6bd157800c5e183", + "size": 456171, + "subdir": "linux-64", + "timestamp": 1524070588227, + "version": "2.5" + }, + "ldap3-2.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "4ebe0abb8cf778547e6aae469e842b71", + "name": "ldap3", + "sha256": "5f9f23a97b2ae7af306ed9d8ac8c147bcfd23587e291d566d2852189499147a6", + "size": 453917, + "subdir": "linux-64", + "timestamp": 1524070586566, + "version": "2.5" + }, + "ldap3-2.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "c5f02b7853d1d610a5173e3edeab578e", + "name": "ldap3", + "sha256": "e81a5a4edc39ba196ce0e8574e44dc8be1bc80b5585c74bf0675eb5e71d73728", + "size": 453577, + "subdir": "linux-64", + "timestamp": 1530898361521, + "version": "2.5" + }, + "ldap3-2.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "37575ecb6633978f1bb5f1a8fa30e2fd", + "name": "ldap3", + "sha256": "14d827d2d6ca323cb71fd125db78cc961cd5129397d2809cae52b03e6019b54e", + "size": 449776, + "subdir": "linux-64", + "timestamp": 1535498058044, + "version": "2.5.1" + }, + "ldap3-2.5.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "ce06a4ce047dcfeb06359d2dbec2ebdf", + "name": "ldap3", + "sha256": "1ec0979303c302d1754899bb7fdd92c735b5e2aa7e54b4f3903e0dd9dd7cb77f", + "size": 459326, + "subdir": "linux-64", + "timestamp": 1535498065371, + "version": "2.5.1" + }, + "ldap3-2.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "1cb457ed6dda3b93297926222b1bf909", + "name": "ldap3", + "sha256": "87b94360d11525ccd371e6d23656586156b4178220903a9281c13879bdd819f6", + "size": 457357, + "subdir": "linux-64", + "timestamp": 1535498057390, + "version": "2.5.1" + }, + "ldap3-2.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "a24337080bddebad57e381dd9bc4f237", + "name": "ldap3", + "sha256": "70f0a7fb350767f108ba2ad5d6e803cbfac0ccdcef7b496360387afb6ab5a459", + "size": 457054, + "subdir": "linux-64", + "timestamp": 1535498098078, + "version": "2.5.1" + }, + "leather-0.3.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4fce75cf011a133b93c2599105b1bc56", + "name": "leather", + "sha256": "14e7a9b8b89f8337a79da99f02a725a6456d9896325086a26d0f45d48882f01d", + "size": 40834, + "subdir": "linux-64", + "timestamp": 1530735530860, + "version": "0.3.3" + }, + "leather-0.3.3-py27hb189859_0.tar.bz2": { + "build": "py27hb189859_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e880d98e806be17dfac816a86b1f5e09", + "name": "leather", + "sha256": "d58d7ff43abba1d9ea8ff5fb7111c8285b017c295d77a81e732a744682f3ce62", + "size": 41090, + "subdir": "linux-64", + "timestamp": 1508618544519, + "version": "0.3.3" + }, + "leather-0.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c25bb4066c9bd2466507c6ff028385f", + "name": "leather", + "sha256": "b995c97e88f16d07fd09c216b0539aec26e633ca7f1260548069cafbdd2d1021", + "size": 42384, + "subdir": "linux-64", + "timestamp": 1642510498924, + "version": "0.3.3" + }, + "leather-0.3.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef1bab44b0db73777df319c5732b9d3a", + "name": "leather", + "sha256": "0de1426a9cd54d574a29313a65198b91097f5cc2b15fc64cbb88ee90dc3c9677", + "size": 41971, + "subdir": "linux-64", + "timestamp": 1534351989580, + "version": "0.3.3" + }, + "leather-0.3.3-py35h0484072_0.tar.bz2": { + "build": "py35h0484072_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be168c6d8587a128fa08ab53ed0a1f96", + "name": "leather", + "sha256": "b1e5bf625395392ccbb2be6a067d4d569a2f6e0c884dd6b8c20f04f2f55daace", + "size": 42352, + "subdir": "linux-64", + "timestamp": 1508618588022, + "version": "0.3.3" + }, + "leather-0.3.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "319439e54aa4db1efaeb69ff526f75a3", + "name": "leather", + "sha256": "2b165b9013ba07f8051e294f51d3f783e383042d77a75a224574252683954160", + "size": 41881, + "subdir": "linux-64", + "timestamp": 1530735509476, + "version": "0.3.3" + }, + "leather-0.3.3-py36hdd9ea39_0.tar.bz2": { + "build": "py36hdd9ea39_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4382089ff13a14648a99fbb410a2279f", + "name": "leather", + "sha256": "3687d365397748ab0c18b7577db80eb3981a3e0739cfe0e655350a3f483f1572", + "size": 42154, + "subdir": "linux-64", + "timestamp": 1508618584920, + "version": "0.3.3" + }, + "leather-0.3.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96ab9cb25a619ca4a2a764a0b8eec615", + "name": "leather", + "sha256": "b6b53412d9519cd4d11e764d842764e1119efaca3978f69e07ad1b115117b588", + "size": 41989, + "subdir": "linux-64", + "timestamp": 1530735553205, + "version": "0.3.3" + }, + "leather-0.3.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c267181d115dd48313a096dcbce07d25", + "name": "leather", + "sha256": "085043b88a20328e71630b7c51b66d33abab27bf06b05ee497d1c0d830660eca", + "size": 42419, + "subdir": "linux-64", + "timestamp": 1573469724170, + "version": "0.3.3" + }, + "leather-0.3.4-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c30c4bad4553242733b7e78198d9000a", + "name": "leather", + "sha256": "c91cd72f2acafd2312e930d2618b80bf2384add8a84eaa871cd056ea7a997051", + "size": 45624, + "subdir": "linux-64", + "timestamp": 1674746011099, + "version": "0.3.4" + }, + "leather-0.3.4-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd3586e7cf828b2ee0d119ae3797325a", + "name": "leather", + "sha256": "c07b8c9ac9f827af474f66c03c97d08484f9ee2a105e4acacc8824b6b33dbc29", + "size": 58397, + "subdir": "linux-64", + "timestamp": 1676837066920, + "version": "0.3.4" + }, + "leather-0.3.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5dfc91a328a4ce89577841367544a456", + "name": "leather", + "sha256": "d00f56ae8767b159d32009c46334e25eef2e1f9b515dd4e1613da49ca9dd7c18", + "size": 42882, + "subdir": "linux-64", + "timestamp": 1634292754744, + "version": "0.3.4" + }, + "leather-0.3.4-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "20f34339b547e1f3bba291bbadfa4978", + "name": "leather", + "sha256": "63eeb3a84d1d798c25b28e8dfcbfe4933201c9d04a7ae188c81750125c66cb24", + "size": 45514, + "subdir": "linux-64", + "timestamp": 1674746036614, + "version": "0.3.4" + }, + "leather-0.3.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5caa915220433b94ef660379ed559d44", + "name": "leather", + "sha256": "e7854ef8d112a73681cce287d98ac0c75d8bb921b5a04e8b47cbe92cfd04e6c6", + "size": 42791, + "subdir": "linux-64", + "timestamp": 1634292753102, + "version": "0.3.4" + }, + "leather-0.3.4-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d348e68ff2e8c489ff60d5f63de2d7de", + "name": "leather", + "sha256": "0fc6fb8f1ab75c76be1678975ed57397eb2dc322b2738460ef98c9824a8c76b7", + "size": 45427, + "subdir": "linux-64", + "timestamp": 1674745985446, + "version": "0.3.4" + }, + "leather-0.3.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d4484c2b818163c2d46d48288d76ef6a", + "name": "leather", + "sha256": "8361e863dd206d110f3ca180d5464379d4944c698ca6cff62dd81bc5f1023bab", + "size": 42789, + "subdir": "linux-64", + "timestamp": 1634292760476, + "version": "0.3.4" + }, + "leather-0.3.4-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8a4421dea175a98fcebcc379d9ced82", + "name": "leather", + "sha256": "d308500487613b45361c61a7b9f65aafb9e21f3ac61bcbf77067181dbe433d5f", + "size": 45390, + "subdir": "linux-64", + "timestamp": 1674745959938, + "version": "0.3.4" + }, + "leptonica-1.82.0-he027829_0.tar.bz2": { + "build": "he027829_0", + "build_number": 0, + "depends": [ + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "openjpeg >=2.3.0,<3.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f1eee6ab38298e8927d2439158a5ff8f", + "name": "leptonica", + "sha256": "0237947d0946336a301e42d62f74b3f96754dd0f59aafa82496d12d2ca6e0dc4", + "size": 2830593, + "subdir": "linux-64", + "timestamp": 1665399843062, + "version": "1.82.0" + }, + "leptonica-1.82.0-he027829_1.tar.bz2": { + "build": "he027829_1", + "build_number": 1, + "depends": [ + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libwebp-base", + "openjpeg >=2.3.0,<3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "6482c18a72fd63bdab40bbdd66404718", + "name": "leptonica", + "sha256": "9f1925bb504fe85f7e9e350b9b212e0895d6116d19a227c1add933a423a4a2e4", + "size": 2843407, + "subdir": "linux-64", + "timestamp": 1676988421664, + "version": "1.82.0" + }, + "lerc-2.2-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3e0fe81607c286261cf72f90a6a1d9ed", + "name": "lerc", + "sha256": "4bedc4546d2a7159b7387a4e0273b5e7846832ec55a771f7c2f56e1c5bd71d04", + "size": 215580, + "subdir": "linux-64", + "timestamp": 1600373731109, + "version": "2.2" + }, + "lerc-2.2.1-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cc295524bfc70dae5843258857ce6e59", + "name": "lerc", + "sha256": "decb80fdc7e623c22fb7c3dd12e7c333791fe06fecd4c8c390d570e03b43f4bb", + "size": 214395, + "subdir": "linux-64", + "timestamp": 1609353805386, + "version": "2.2.1" + }, + "lerc-3.0-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "88199c75f2ac211728febced7785c24e", + "name": "lerc", + "sha256": "ba7fab6985a18b8e510041b9ba8e61f1fe3121ac1fe23bebaf283bd284a11df8", + "size": 228278, + "subdir": "linux-64", + "timestamp": 1635523146417, + "version": "3.0" + }, + "leveldb-1.20-hf484d3e_1.tar.bz2": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "snappy", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD", + "md5": "8296657537299d416b023c8f8ffe8958", + "name": "leveldb", + "sha256": "183d00f45b9c8bdeb31a333b8551fcb45cc7c9a6e6338046322e9dd785108d87", + "size": 361617, + "subdir": "linux-64", + "timestamp": 1512801642355, + "version": "1.20" + }, + "leveldb-1.23-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "33617609754f7f6f28e3484c775ba072", + "name": "leveldb", + "sha256": "c402269c58ec54237d561305d724451ec9345ab1822d8555ce62d205eaa6fe24", + "size": 197014, + "subdir": "linux-64", + "timestamp": 1622722453206, + "version": "1.23" + }, + "leveldb-1.23-h6a678d5_2.tar.bz2": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "snappy >=1.1.9,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "985aecc028c13d5851a0b107bc384715", + "name": "leveldb", + "sha256": "f909484ce94f30627a5b65ede72a0e904d2e656ed8f67611c0c6be47d4251a7e", + "size": 182465, + "subdir": "linux-64", + "timestamp": 1659773640052, + "version": "1.23" + }, + "libaec-1.0.4-he6710b0_1.tar.bz2": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e911ac853b19bd7073f1047699e2118e", + "name": "libaec", + "sha256": "860ecdf2e21768f806f9c0d272e92dbc521b249a7171b0def500a30937fb079a", + "size": 35409, + "subdir": "linux-64", + "timestamp": 1593197267510, + "version": "1.0.4" + }, + "libaio-0.3.110-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPLv2.1", + "license_family": "LGPL", + "md5": "e8b8c018fe5ab18e0e762c320f0b7a88", + "name": "libaio", + "sha256": "9a4bcd79821a07ac02bad079cefb1bae75527ac8ad82551adf80500aa232aadd", + "size": 19794, + "subdir": "linux-64", + "timestamp": 1525298567034, + "version": "0.3.110" + }, + "libaio-0.3.111-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPLv2.1", + "license_family": "LGPL", + "md5": "ae32e2c05f46fee366ef84abbe7b48b1", + "name": "libaio", + "sha256": "e70fb4294731786eb6bc18cec2d0ca8563ddef6d3e2cd721ff347c5665cbba69", + "size": 20460, + "subdir": "linux-64", + "timestamp": 1527852225975, + "version": "0.3.111" + }, + "libaio-0.3.113-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "b199a18f9872f4e0ddbf95e0e231bd0f", + "name": "libaio", + "sha256": "f87141bd7f1682741a6d0a4dbd19bcc6a46fe1404e5b6cb7975e40a38fb490e0", + "size": 18772, + "subdir": "linux-64", + "timestamp": 1656416114008, + "version": "0.3.113" + }, + "libapr-1.7.0-hf178f73_5.tar.bz2": { + "build": "hf178f73_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "993fd5e839abc3412a3140ed9e20fa75", + "name": "libapr", + "sha256": "a073d34b6a42886c02252a42afc88d588a3371f55c27e6a656b510dac7b18f8e", + "size": 709942, + "subdir": "linux-64", + "timestamp": 1631785188555, + "version": "1.7.0" + }, + "libapriconv-1.2.2-h7f8727e_5.tar.bz2": { + "build": "h7f8727e_5", + "build_number": 5, + "depends": [ + "libapr", + "libgcc-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0bb0bd45f420452be24fd02976747698", + "name": "libapriconv", + "sha256": "b57d49b9e955bb515d0586b7ffc24ad296bc06c55d76189ac6674579204f6ece", + "size": 1586026, + "subdir": "linux-64", + "timestamp": 1631785348398, + "version": "1.2.2" + }, + "libaprutil-1.6.1-hfefca11_5.tar.bz2": { + "build": "hfefca11_5", + "build_number": 5, + "depends": [ + "expat >=2.2.10,<3.0a0", + "libapr", + "libgcc-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bb808c760b331c77d068c049788ca36f", + "name": "libaprutil", + "sha256": "f9fb93758e5c4d461946e0d299cdbbad7c7c1e330fa2692ceda66ba5c8ee9ad2", + "size": 515988, + "subdir": "linux-64", + "timestamp": 1631785382881, + "version": "1.6.1" + }, + "libarchive-3.3.2-h4a23435_4.tar.bz2": { + "build": "h4a23435_4", + "build_number": 4, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "lz4-c >=1.8.0,<1.9.0a0", + "lzo >=2.10,<3.0a0", + "openssl >=1.0.2o,<1.0.3a", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "_low_priority" + ], + "license": "BSD 2-Clause", + "md5": "2de2eb83e965a3557efa9f74ec60ba85", + "name": "libarchive", + "sha256": "12f2ea64e0eab0d5d2dcdb511f21c49df6816fff9a90877e8d011d10e9813720", + "size": 1520805, + "subdir": "linux-64", + "timestamp": 1522166972224, + "version": "3.3.2" + }, + "libarchive-3.3.2-h4a23435_5.tar.bz2": { + "build": "h4a23435_5", + "build_number": 5, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "lzo >=2.10,<3.0a0", + "openssl >=1.0.2o,<1.0.3a", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "_low_priority" + ], + "license": "BSD 2-Clause", + "md5": "963b048946ae6dff34a0a2ac1e661f68", + "name": "libarchive", + "sha256": "8875e7bdbca888139320c91d36ac148091c318220057b3aac8336370fe68e240", + "size": 1526494, + "subdir": "linux-64", + "timestamp": 1524615997334, + "version": "3.3.2" + }, + "libarchive-3.3.2-ha7923ee_0.tar.bz2": { + "build": "ha7923ee_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "expat", + "expat >=2.2.4,<3.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2l,<1.0.3a", + "_low_priority" + ], + "license": "BSD 2-Clause", + "md5": "61b61b6fcd6235f70f6ce64a24bea022", + "name": "libarchive", + "sha256": "153b5f4c93846b52adfb47cef61b20c8df4ab31887534b887ff17391fd5e809a", + "size": 1300825, + "subdir": "linux-64", + "timestamp": 1509635328694, + "version": "3.3.2" + }, + "libarchive-3.3.2-hb43526a_6.tar.bz2": { + "build": "hb43526a_6", + "build_number": 6, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "lzo >=2.10,<3.0a0", + "openssl >=1.0.2o,<1.0.3a", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "_low_priority" + ], + "license": "BSD 2-Clause", + "md5": "96755d56547dfe3f5767141cb2e09cdd", + "name": "libarchive", + "sha256": "47497c0681ef31d8913206e908564b9dc585335315ebaadb1c1301439fbb3436", + "size": 1526456, + "subdir": "linux-64", + "timestamp": 1527041461012, + "version": "3.3.2" + }, + "libarchive-3.3.2-hbf4e9fd_1.tar.bz2": { + "build": "hbf4e9fd_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "lz4-c >=1.8.0,<1.9.0a0", + "lzo >=2.10,<3.0a0", + "openssl >=1.0.2m,<1.0.3a", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "_low_priority" + ], + "license": "BSD 2-Clause", + "md5": "fcfff14314daa39ce1a0650ea74e5a97", + "name": "libarchive", + "sha256": "ed72740d95e28f3ffdf3356979ad7af5d2c8bc3f6cf8e17bfc77bf66faa9a2c7", + "size": 1484844, + "subdir": "linux-64", + "timestamp": 1510141959053, + "version": "3.3.2" + }, + "libarchive-3.3.3-h5d8350f_2.tar.bz2": { + "build": "h5d8350f_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "lzo >=2.10,<3.0a0", + "openssl >=1.1.1a,<1.1.2a", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "BSD 2-Clause", + "md5": "ef1497771fddeeec662a23147f66f05d", + "name": "libarchive", + "sha256": "1eb4b802feb48f596dab5a4ac8586ff3a344936ae88bccab8056443a25f0541f", + "size": 1570311, + "subdir": "linux-64", + "timestamp": 1540778684214, + "version": "3.3.3" + }, + "libarchive-3.3.3-h5d8350f_4.tar.bz2": { + "build": "h5d8350f_4", + "build_number": 4, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "lzo >=2.10,<3.0a0", + "openssl >=1.1.1a,<1.1.2a", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "5974071c3632be6c05aff1fb8048093f", + "name": "libarchive", + "sha256": "9ec5e025d4d654e8579a6b546bcdbf7454180fd6e3535a70caaaf2309fddcf5c", + "size": 1577702, + "subdir": "linux-64", + "timestamp": 1541477533189, + "version": "3.3.3" + }, + "libarchive-3.3.3-h5d8350f_5.tar.bz2": { + "build": "h5d8350f_5", + "build_number": 5, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "lzo >=2.10,<3.0a0", + "openssl >=1.1.1a,<1.1.2a", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "0815f9450ee621ac1bc4eae76ff34c89", + "name": "libarchive", + "sha256": "c3a61d583c38a124b926514b7633e5f80f20083dd91fd234fe40b5ed327ac25e", + "size": 1567898, + "subdir": "linux-64", + "timestamp": 1544640956053, + "version": "3.3.3" + }, + "libarchive-3.3.3-h7d0bbab_1.tar.bz2": { + "build": "h7d0bbab_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "lzo >=2.10,<3.0a0", + "openssl >=1.0.2p,<1.0.3a", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "BSD 2-Clause", + "md5": "f168fa0ce67982e6600c166d1f44a6c1", + "name": "libarchive", + "sha256": "538f376f9ce8f2a3ea460e2cf5afceb0a7d22126c59a087620251a8b15cb500a", + "size": 1544002, + "subdir": "linux-64", + "timestamp": 1537557918416, + "version": "3.3.3" + }, + "libarchive-3.4.2-h5de8990_2.tar.bz2": { + "build": "h5de8990_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "openssl >=1.1.1o,<1.1.2a", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b58081fcceb1b18037492bef4b16341f", + "name": "libarchive", + "sha256": "d24cd356ff38c510d869c8efe774029599fad44c48c8512b1c61a0bb5b333e47", + "size": 1598857, + "subdir": "linux-64", + "timestamp": 1652979024081, + "version": "3.4.2" + }, + "libarchive-3.4.2-h62408e4_0.tar.bz2": { + "build": "h62408e4_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "lz4-c >=1.9.2,<1.10.0a0", + "openssl >=1.1.1f,<1.1.2a", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.4,<1.5.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "28c3c2693de03fc72b1e92707b4a009a", + "name": "libarchive", + "sha256": "e376f8d1eb910c015626b6fc185ae84b24e29153c0bb33bcd1092d0dc498e545", + "size": 1648398, + "subdir": "linux-64", + "timestamp": 1587215846741, + "version": "3.4.2" + }, + "libarchive-3.5.2-h5de8990_0.tar.bz2": { + "build": "h5de8990_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.14,<2.10.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "openssl >=1.1.1o,<1.1.2a", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f7d8911020dcc6718886b3758f7ae5be", + "name": "libarchive", + "sha256": "22fc3c22e6726ef7ce96f98c8ab9ad0a1c99adca28e367888f22dd32dc9d1c02", + "size": 1748228, + "subdir": "linux-64", + "timestamp": 1654255326579, + "version": "3.5.2" + }, + "libarchive-3.6.1-hab531cd_0.tar.bz2": { + "build": "hab531cd_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "openssl >=1.1.1q,<1.1.2a", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e6af03c292c8c898d81153d209e7477a", + "name": "libarchive", + "sha256": "740f53f4a6b3df10810df512775a378ed2b5efd66a605733149d8578c77e8c15", + "size": 1690831, + "subdir": "linux-64", + "timestamp": 1663062388221, + "version": "3.6.1" + }, + "libarchive-3.6.2-hab531cd_0.tar.bz2": { + "build": "hab531cd_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "openssl >=1.1.1s,<1.1.2a", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "00dec3fdfd7a70238fc735e286ef3ed8", + "name": "libarchive", + "sha256": "b2f9eaa59ed5323c45785d949e85b7e4008b3c7283c0ae17beb99d27c7df2bad", + "size": 1685278, + "subdir": "linux-64", + "timestamp": 1674632192945, + "version": "3.6.2" + }, + "libarchive-3.6.2-hb4bd9a0_1.tar.bz2": { + "build": "hb4bd9a0_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "openssl >=1.1.1t,<1.1.2a", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "bc470a9280b2faaeb48dd2a20cb49d06", + "name": "libarchive", + "sha256": "7196dec998931928a378fe3c60f8d1810071da4434f8696b5aaadc84e3f8ad07", + "size": 1683019, + "subdir": "linux-64", + "timestamp": 1679578141147, + "version": "3.6.2" + }, + "libboost-1.65.1-h4055789_3.tar.bz2": { + "build": "h4055789_3", + "build_number": 3, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Boost-1.0", + "md5": "e9dce6bd53547d3398ce4bea36a26ae9", + "name": "libboost", + "sha256": "6814290b2a771a54ad69202ce6b168da583befa7bf3c877b4a800bc9b8653cbc", + "size": 20119358, + "subdir": "linux-64", + "timestamp": 1508786567485, + "version": "1.65.1" + }, + "libboost-1.65.1-habcd387_4.tar.bz2": { + "build": "habcd387_4", + "build_number": 4, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Boost-1.0", + "md5": "a17532403128726d4ab2f0258229ad01", + "name": "libboost", + "sha256": "fc95c2af9cf72dbdfeaf520023584fd61de2a88fb86beed54ca47baacae83ba5", + "size": 20126063, + "subdir": "linux-64", + "timestamp": 1515095183212, + "version": "1.65.1" + }, + "libboost-1.67.0-h46d08c1_4.tar.bz2": { + "build": "h46d08c1_4", + "build_number": 4, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Boost-1.0", + "md5": "6d21c07e7c7a44ebf21e9a45ddf9522f", + "name": "libboost", + "sha256": "ad8f711cb5270ab86f0627df7c0c52c2354ffbb83d880ab1555db5bf0397b647", + "size": 21942204, + "subdir": "linux-64", + "timestamp": 1530782048345, + "version": "1.67.0" + }, + "libboost-1.71.0-h97c9712_0.tar.bz2": { + "build": "h97c9712_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "5f77fd93180fedd1358c0abe5496ea11", + "name": "libboost", + "sha256": "207d6068f33810444b4ce36b38c4805336f32b36a94b5dc338c252e1ba56c739", + "size": 23009017, + "subdir": "linux-64", + "timestamp": 1572610543643, + "version": "1.71.0" + }, + "libboost-1.71.0-haf77d95_1.tar.bz2": { + "build": "haf77d95_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.5.0,<1.6.0a0" + ], + "license": "Boost-1.0", + "md5": "a7671cae746b9e0850e20e907611cdb6", + "name": "libboost", + "sha256": "369ec772fbddfecf529399aa4867b40fd97f54e293f7218c1cea63a6fe46d55c", + "size": 22942142, + "subdir": "linux-64", + "timestamp": 1642425039425, + "version": "1.71.0" + }, + "libboost-1.73.0-h28710b8_12.tar.bz2": { + "build": "h28710b8_12", + "build_number": 12, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "34dd22cf2bca0dbccbb9697f190f504a", + "name": "libboost", + "sha256": "1d69d22e3a27260658d33d22c49dfa78effb9f0d612d2223a6a76dba4e55b171", + "size": 22152039, + "subdir": "linux-64", + "timestamp": 1655879823139, + "version": "1.73.0" + }, + "libboost-1.73.0-h37e3b65_10.tar.bz2": { + "build": "h37e3b65_10", + "build_number": 10, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Boost-1.0", + "md5": "6e072917cdc1edbad2320bfaa9bea5ce", + "name": "libboost", + "sha256": "176d725e7d842857267548bbce703e5d0d59e5fd99c29ed4440686ece204f0c3", + "size": 22283636, + "subdir": "linux-64", + "timestamp": 1601386035154, + "version": "1.73.0" + }, + "libboost-1.73.0-h37e3b65_11.tar.bz2": { + "build": "h37e3b65_11", + "build_number": 11, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Boost-1.0", + "md5": "d954324e16033942189c5feaf88d30fd", + "name": "libboost", + "sha256": "2f9d2fe6e2e45335fa2da6f96fcd44514e0f4aaeb1c9e71ef59e25369945ca54", + "size": 22226083, + "subdir": "linux-64", + "timestamp": 1601470540575, + "version": "1.73.0" + }, + "libboost-1.73.0-h3ff78a5_11.tar.bz2": { + "build": "h3ff78a5_11", + "build_number": 11, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Boost-1.0", + "md5": "b41dce08aea9e243db25a95f00708724", + "name": "libboost", + "sha256": "55e595d5b5c5c2361c56a9ea3868ed5e97c99b3ffc614487b7aec7126722292a", + "size": 22298574, + "subdir": "linux-64", + "timestamp": 1611677068430, + "version": "1.73.0" + }, + "libboost-1.73.0-hf484d3e_10.tar.bz2": { + "build": "hf484d3e_10", + "build_number": 10, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Boost-1.0", + "md5": "36450acf88af1ebbe82bd356a1feb3eb", + "name": "libboost", + "sha256": "0389a7f234a04ed2f087e590cf777548bdcec5d661dab752a19a952c705b16f6", + "size": 22272875, + "subdir": "linux-64", + "timestamp": 1601386770076, + "version": "1.73.0" + }, + "libboost-1.73.0-hf484d3e_11.tar.bz2": { + "build": "hf484d3e_11", + "build_number": 11, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Boost-1.0", + "md5": "2a238c43c99e564ccb66758ca12eae2a", + "name": "libboost", + "sha256": "fe5cb3da0e3251b0c2df3e63870c53e03f3528d7cd0cb0e836287201fcbbfafc", + "size": 22212095, + "subdir": "linux-64", + "timestamp": 1601471289913, + "version": "1.73.0" + }, + "libbrotlicommon-1.0.9-h5eee18b_7.tar.bz2": { + "build": "h5eee18b_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "md5": "787927eff72e62c270f614cbcba9479c", + "name": "libbrotlicommon", + "sha256": "472cf888db65d00451fcd5fccd5244d55c061e8d7efe43f70220414ef64521a5", + "size": 67109, + "subdir": "linux-64", + "timestamp": 1659616145972, + "version": "1.0.9" + }, + "libbrotlidec-1.0.9-h5eee18b_7.tar.bz2": { + "build": "h5eee18b_7", + "build_number": 7, + "depends": [ + "libbrotlicommon 1.0.9 h5eee18b_7", + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "md5": "c0608d376a30b5aa4d2f2c22978135db", + "name": "libbrotlidec", + "sha256": "19a43182ca343510ba51baa0fce91d64c840a19cdf13c6dde4e03e819c70897e", + "size": 34691, + "subdir": "linux-64", + "timestamp": 1659616154057, + "version": "1.0.9" + }, + "libbrotlienc-1.0.9-h5eee18b_7.tar.bz2": { + "build": "h5eee18b_7", + "build_number": 7, + "depends": [ + "libbrotlicommon 1.0.9 h5eee18b_7", + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "md5": "cc6a6d362912a2d112310bd3f8acd44e", + "name": "libbrotlienc", + "sha256": "158c401aa0bab05aa5f4134aea798085e4e3849209946f896cca352930d2225d", + "size": 295287, + "subdir": "linux-64", + "timestamp": 1659616162282, + "version": "1.0.9" + }, + "libclang-10.0.1-default_h658b4fb_2.tar.bz2": { + "build": "default_h658b4fb_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "e0cb6c13d4066b9a9ec4f31454a9a997", + "name": "libclang", + "sha256": "78c1255035df342d05fce1aea2f7930ceb589a331d8fce6936b716461068be48", + "size": 27286220, + "subdir": "linux-64", + "timestamp": 1601486012482, + "version": "10.0.1" + }, + "libclang-10.0.1-default_hb85057a_2.tar.bz2": { + "build": "default_hb85057a_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "303df88e60520fefb6ed6d07eecbb645", + "name": "libclang", + "sha256": "9259dd1bb4a042533687623cfea1f29ad21456b592b3077355e855ad0689aa0a", + "size": 27218305, + "subdir": "linux-64", + "timestamp": 1601487939823, + "version": "10.0.1" + }, + "libclang-14.0.6-default_hc1a23ef_0.tar.bz2": { + "build": "default_hc1a23ef_0", + "build_number": 0, + "depends": [ + "libclang13 14.0.6 default_h31cde19_0", + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "79b24aa2986c41fb26630237c5426b3f", + "name": "libclang", + "sha256": "be658455fc3420a743d538682cc1c517c30407b150864ecad27f65d391d43583", + "size": 129692, + "subdir": "linux-64", + "timestamp": 1661930404826, + "version": "14.0.6" + }, + "libclang-cpp-10.0.1-default_h658b4fb_2.tar.bz2": { + "build": "default_h658b4fb_2", + "build_number": 2, + "depends": [ + "libclang-cpp10 10.0.1 default_h658b4fb_2", + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "d43c57d240fcb3e6d26fd42039266c34", + "name": "libclang-cpp", + "sha256": "61560deeae3aeb8953549724136f87d1b447ec52af724932682ef4abdba38456", + "size": 16276712, + "subdir": "linux-64", + "timestamp": 1601485964187, + "version": "10.0.1" + }, + "libclang-cpp-10.0.1-default_hb85057a_2.tar.bz2": { + "build": "default_hb85057a_2", + "build_number": 2, + "depends": [ + "libclang-cpp10 10.0.1 default_hb85057a_2", + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "4df717d50eaaacc80dc9615405e2bc71", + "name": "libclang-cpp", + "sha256": "845f6292e6d9c5c8da19495d4195f1a3b9b137bcff5b893ace1764e9ceaac6e1", + "size": 16206542, + "subdir": "linux-64", + "timestamp": 1601487893552, + "version": "10.0.1" + }, + "libclang-cpp-14.0.6-default_hc1a23ef_0.tar.bz2": { + "build": "default_hc1a23ef_0", + "build_number": 0, + "depends": [ + "libclang-cpp14 14.0.6 default_hc1a23ef_0", + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "3e9fb3cf18b064257d1626d184ef6fb1", + "name": "libclang-cpp", + "sha256": "c300e4694f6b8b8d6e96a6ad636a40e17afb02d59b3b7b8722214f3562ac1d6a", + "size": 129724, + "subdir": "linux-64", + "timestamp": 1661930346313, + "version": "14.0.6" + }, + "libclang-cpp10-10.0.1-default_h658b4fb_2.tar.bz2": { + "build": "default_h658b4fb_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "94944a45c1d07be6971189a3c74120a7", + "name": "libclang-cpp10", + "sha256": "1a873e15ea3ad692910718bd34ef8aaac5651c15ae34df75a66146428f348860", + "size": 16245922, + "subdir": "linux-64", + "timestamp": 1601485857815, + "version": "10.0.1" + }, + "libclang-cpp10-10.0.1-default_hb85057a_2.tar.bz2": { + "build": "default_hb85057a_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "d05351a1b5abf7925159d0bfbf59607a", + "name": "libclang-cpp10", + "sha256": "a2c9854fe4f460fc8fe64f3faa3589faf2688b73e1f7060e183f847828cd45f6", + "size": 16161668, + "subdir": "linux-64", + "timestamp": 1601487815912, + "version": "10.0.1" + }, + "libclang-cpp14-14.0.6-default_hc1a23ef_0.tar.bz2": { + "build": "default_hc1a23ef_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "c77742ab3211f338daaa2d95e00e42de", + "name": "libclang-cpp14", + "sha256": "fe3d99375d8a8a9ed0167fb97fc84d115cc20b10648c3d4e38463b9fc56c2cb2", + "size": 19833574, + "subdir": "linux-64", + "timestamp": 1661930294179, + "version": "14.0.6" + }, + "libclang13-14.0.6-default_h31cde19_0.tar.bz2": { + "build": "default_h31cde19_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "158aa7c9eef274f5fab4f6dba74f8000", + "name": "libclang13", + "sha256": "92ba52e5ad8594c91716062a77d77f7b1389dd859b1bdb1dbe175f062c39f4b3", + "size": 11150702, + "subdir": "linux-64", + "timestamp": 1661930380098, + "version": "14.0.6" + }, + "libcrc32c-1.1.1-he6710b0_2.tar.bz2": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "270f663ec256e6ba1724bb9102596229", + "name": "libcrc32c", + "sha256": "a6ad703eb5759a8ef73f43c07cffb128db415d06294b1a408916fe97d291de4f", + "size": 21993, + "subdir": "linux-64", + "timestamp": 1601305006983, + "version": "1.1.1" + }, + "libcrc32c-1.1.2-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "746f054f76950345b2c2f57bf4855de2", + "name": "libcrc32c", + "sha256": "7e84cf021f8957123e3658de7e5caa9ff6441fc6d68b406d9f9ebc59840e7692", + "size": 21542, + "subdir": "linux-64", + "timestamp": 1666883171505, + "version": "1.1.2" + }, + "libcryptominisat-5.6.6-h0e08187_0.tar.bz2": { + "build": "h0e08187_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f78fc47f4e1f2c2f71ccd019890e60d", + "name": "libcryptominisat", + "sha256": "56e711183ae4fe885a742f4eb3f89a307894fe0cac742a75dd4fb766125126ad", + "size": 5093595, + "subdir": "linux-64", + "timestamp": 1548446889535, + "version": "5.6.6" + }, + "libcryptominisat-5.6.6-h9e868ea_1.tar.bz2": { + "build": "h9e868ea_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a864b406a72e5e4abb4d79d9396bfc7e", + "name": "libcryptominisat", + "sha256": "8adb2619a56bcc3ba347801ea1f1270cdb44d7edea85baee3f396e5568cdfa4e", + "size": 6702096, + "subdir": "linux-64", + "timestamp": 1676725901683, + "version": "5.6.6" + }, + "libcryptominisat-5.6.6-h9e868ea_2.tar.bz2": { + "build": "h9e868ea_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "73a30df7fa5a007fb2f076c6fa2a736a", + "name": "libcryptominisat", + "sha256": "e05e71bebc250935c86c5b43afb1f1b5ccb010212b39451d2170096c18258595", + "size": 6702084, + "subdir": "linux-64", + "timestamp": 1679313384931, + "version": "5.6.6" + }, + "libcryptominisat-5.6.6-hc0fe6c6_0.tar.bz2": { + "build": "hc0fe6c6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "307863387aa0bda1a3b58f227b13d5f0", + "name": "libcryptominisat", + "sha256": "2c31bb7e623375cf4e36926c3627490e0638f9ce9646276a4dff32b22ee4681e", + "size": 5116447, + "subdir": "linux-64", + "timestamp": 1611760247956, + "version": "5.6.6" + }, + "libcst-0.3.14-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "dataclasses", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96aea04ec5df3c43d34580d39502c6cf", + "name": "libcst", + "sha256": "e866830fa610c7a7f94d0d7f2fe5e299d206a90ec17d68ea8df3dfa08181ac3a", + "size": 728973, + "subdir": "linux-64", + "timestamp": 1606163965155, + "version": "0.3.14" + }, + "libcst-0.3.14-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a453e3fc363e3bd85b57f7f0c4538606", + "name": "libcst", + "sha256": "784c1184f63c463797024cfc5244e8609d35e910a0a9d4151109a59e53793bfb", + "size": 724621, + "subdir": "linux-64", + "timestamp": 1606163960318, + "version": "0.3.14" + }, + "libcst-0.3.14-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca59983f9d0f6fc27d7c767e975481e9", + "name": "libcst", + "sha256": "e724810a0309f97116d2687cc9120441b5d5eed7abe95c9b0fab60434f1c5aec", + "size": 728803, + "subdir": "linux-64", + "timestamp": 1606163939152, + "version": "0.3.14" + }, + "libcst-0.3.15-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "dataclasses", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec94073125789cafe89e2bf26468515c", + "name": "libcst", + "sha256": "ab8f6d27b044dd5996ad00f2c05f8d3d44ced0592f7549e55645b9fb1fc089fb", + "size": 726014, + "subdir": "linux-64", + "timestamp": 1606861658827, + "version": "0.3.15" + }, + "libcst-0.3.15-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "59b098c252c128d05e18f9270591d38b", + "name": "libcst", + "sha256": "10015cee82cdae3e680b755f76cbc74a93fe5355d92f1e6e24d7bbba14fe189e", + "size": 720491, + "subdir": "linux-64", + "timestamp": 1606861671673, + "version": "0.3.15" + }, + "libcst-0.3.15-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e437bc5610fcaa43bb47d15cc4ae1ceb", + "name": "libcst", + "sha256": "85a9d58f2b73d9a6e24212ed9f7f80bdcd081c2f5993c5c0525e3cfdfdf9cc71", + "size": 729787, + "subdir": "linux-64", + "timestamp": 1606861681476, + "version": "0.3.15" + }, + "libcst-0.3.16-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "dataclasses", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "786e311f89934aa5301a90a2ee545c7f", + "name": "libcst", + "sha256": "1aa5db0de0928a95316a4533cd42bafe04cd206bcc319d2ed8d8c3d19334bf4b", + "size": 722593, + "subdir": "linux-64", + "timestamp": 1608230239373, + "version": "0.3.16" + }, + "libcst-0.3.16-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0c27939d7369fc532295998b19bf53c", + "name": "libcst", + "sha256": "b5a072b7063b16c21c4387789d4d64e06e7231e3ef1b5aedb63b3bf8189e79c7", + "size": 725720, + "subdir": "linux-64", + "timestamp": 1608230221894, + "version": "0.3.16" + }, + "libcst-0.3.16-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4739a6fe2a2bed33d9eb9b04a37908a2", + "name": "libcst", + "sha256": "389f74fbc7560f3f29ae542ecfb749ce8f47f4a801b57f5b3ccc4fbdca647213", + "size": 738239, + "subdir": "linux-64", + "timestamp": 1608230215754, + "version": "0.3.16" + }, + "libcst-0.3.17-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0decceeeb7641852b011416e4830f907", + "name": "libcst", + "sha256": "f790808ccac38fc310c8f621cd236306d889a0c96a0f65c7c670bd72f92622a8", + "size": 745117, + "subdir": "linux-64", + "timestamp": 1640809502459, + "version": "0.3.17" + }, + "libcst-0.3.17-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "417962c5b5336fb63a505c0e968a7851", + "name": "libcst", + "sha256": "4de12433e513f9d1a5387b8ffdd490d3aecb967968dd75e7af21e8473a5bc774", + "size": 980765, + "subdir": "linux-64", + "timestamp": 1676853181579, + "version": "0.3.17" + }, + "libcst-0.3.17-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "dataclasses", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d6fc2bbe2afbd633b5e2dbc16faf571f", + "name": "libcst", + "sha256": "92706a58713eaf2b21fe04ee24be72f391f4551d68a6ea36fb01ec9e0584a0a3", + "size": 722678, + "subdir": "linux-64", + "timestamp": 1613588862065, + "version": "0.3.17" + }, + "libcst-0.3.17-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af9670834c764d78b5ba1f5f9386df56", + "name": "libcst", + "sha256": "8681ed7797c35117c290f30a97a05a7fd27e402e5418830e7c0f68f34cc38ca8", + "size": 726271, + "subdir": "linux-64", + "timestamp": 1613588869467, + "version": "0.3.17" + }, + "libcst-0.3.17-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e138955c77f537eaa6f329591ad1ef1", + "name": "libcst", + "sha256": "87456c7d8f79f7819d94e43666a5264527ea7cfbbf2f139fa08e0d4633df8fcb", + "size": 736895, + "subdir": "linux-64", + "timestamp": 1613588543593, + "version": "0.3.17" + }, + "libcst-0.3.17-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "91fb707b0709d3df72860f7c1fb3178b", + "name": "libcst", + "sha256": "5806cb61d3b6f62dcc4c6f8f683f70bf192ad74997e78999353344974f0ae61d", + "size": 729766, + "subdir": "linux-64", + "timestamp": 1613588203703, + "version": "0.3.17" + }, + "libcst-0.3.18-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "dataclasses", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5e03a2408c0847c5bec6a0eeac2778f", + "name": "libcst", + "sha256": "c67549acb965b23e9f05e50fe18854cf9d6536d2c6327101262ed5e5a4a33d43", + "size": 730476, + "subdir": "linux-64", + "timestamp": 1617121307699, + "version": "0.3.18" + }, + "libcst-0.3.18-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c6f76b6f892bb46de75b4a493138cef", + "name": "libcst", + "sha256": "bb1de1b8dacf8b7e11404370cd0d303576e5ccb5b09585665290fd528cf93b85", + "size": 733701, + "subdir": "linux-64", + "timestamp": 1617121309809, + "version": "0.3.18" + }, + "libcst-0.3.18-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "82ce6e1f82dbf70f89439c7c1dc36b5b", + "name": "libcst", + "sha256": "9bf6d067476ac328951ff4efb92ed5a798a45f1024efa7d70717cfbf2fbcb96a", + "size": 737464, + "subdir": "linux-64", + "timestamp": 1617118853335, + "version": "0.3.18" + }, + "libcst-0.3.18-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "84b2534db9715aa512cd8ea62daa85b0", + "name": "libcst", + "sha256": "975558e8b322f7fae16b48a9e873da5b779838ad949537493fafbf7434424717", + "size": 735940, + "subdir": "linux-64", + "timestamp": 1617121313374, + "version": "0.3.18" + }, + "libcst-0.3.19-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "dataclasses", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3fbe25aeea9fdc549e308686ac5d28af", + "name": "libcst", + "sha256": "1151a7fddf343b186530486915607ad58844788e6b44d27e999a753c34689ba9", + "size": 731951, + "subdir": "linux-64", + "timestamp": 1620999857101, + "version": "0.3.19" + }, + "libcst-0.3.19-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fbc02cd164edb03ce275b08eeea76921", + "name": "libcst", + "sha256": "33ad2c7b2081203761dd906f0822494ae0b0b12b3b53d716dceb9bcbc025ae69", + "size": 736419, + "subdir": "linux-64", + "timestamp": 1621000482533, + "version": "0.3.19" + }, + "libcst-0.3.19-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad70c3626b72ef0e8253b4f7c581d924", + "name": "libcst", + "sha256": "b396d8d231fb012d8e31209ec37f1cd7082c62851d54302f8b235ff8d4dfada2", + "size": 737869, + "subdir": "linux-64", + "timestamp": 1621000490790, + "version": "0.3.19" + }, + "libcst-0.3.19-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e612791e30e89076bcebff6350e53479", + "name": "libcst", + "sha256": "4149fc9b048df4bee4b1295ef97927fd88ce3c698d8ced657c091debefdd6baa", + "size": 745350, + "subdir": "linux-64", + "timestamp": 1621000481107, + "version": "0.3.19" + }, + "libcups-2.2.12-h4ff587b_1.tar.bz2": { + "build": "h4ff587b_1", + "build_number": 1, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "4c7173b73ea4de12bf510d8c18fd90c9", + "name": "libcups", + "sha256": "7f2def74a03abc23644aa4cc946cc3bd12842a1fe1bde46b98496eba1d9f4370", + "size": 6682301, + "subdir": "linux-64", + "timestamp": 1632414655779, + "version": "2.2.12" + }, + "libcups-2.4.2-ha637b67_0.tar.bz2": { + "build": "ha637b67_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1q,<1.1.2a", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "65dbd500f48d34d27f1dd376439da1c4", + "name": "libcups", + "sha256": "dc4e101bf4c17c46c620e8daf8b719ba290afc9b3032fe2b8776ede002340f02", + "size": 4875830, + "subdir": "linux-64", + "timestamp": 1665596528843, + "version": "2.4.2" + }, + "libcurl-7.57.0-h1ad7b7a_0.tar.bz2": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.0.2n,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "07b9b1cc5d887ded871b15bcf2eac7ea", + "name": "libcurl", + "sha256": "c192ecf0106459e0e870f2ecf4afb0aeec7cdb0bc72282cf6d6a320b13844138", + "size": 522148, + "subdir": "linux-64", + "timestamp": 1516812880776, + "version": "7.57.0" + }, + "libcurl-7.58.0-h1ad7b7a_0.tar.bz2": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.0.2n,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "59d70cf4bfc390aff44ec0009ae0a4cf", + "name": "libcurl", + "sha256": "59ab91b0e248fdbb178b4d8e84115232ae5ce3da3e3a0901e2c4b46a3046f9d9", + "size": 496670, + "subdir": "linux-64", + "timestamp": 1517284610702, + "version": "7.58.0" + }, + "libcurl-7.59.0-h1ad7b7a_0.tar.bz2": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.0.2o,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "7b28d086958eb16a30dd36dafa112fce", + "name": "libcurl", + "sha256": "ac859d1911e4630047e62ecb6156650a82fac36788892c57befbb98fa77c75dd", + "size": 502502, + "subdir": "linux-64", + "timestamp": 1522272204460, + "version": "7.59.0" + }, + "libcurl-7.60.0-h1ad7b7a_0.tar.bz2": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.0.2o,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "71bd4310aad2be79a1fc5ade796fe482", + "name": "libcurl", + "sha256": "57fb31b57f557f8857124a780ae971b7a10776a1afc45ecd6768ea7fdafb9d86", + "size": 506999, + "subdir": "linux-64", + "timestamp": 1527109699454, + "version": "7.60.0" + }, + "libcurl-7.61.0-h1ad7b7a_0.tar.bz2": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.0.2o,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "6b6e39fb0a36e69fe330e97f1e9fc31c", + "name": "libcurl", + "sha256": "d47b15281a6d6ca8e1373a12f611cd8135aed1677058b9b674b0d8e5bf69a634", + "size": 505509, + "subdir": "linux-64", + "timestamp": 1532525678731, + "version": "7.61.0" + }, + "libcurl-7.61.1-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "8d3ec094ef90b643a59de71ef5b6ffc3", + "name": "libcurl", + "sha256": "7e6591ef5fcd8c94675ce489aff4e20a05fb8491a0dbbb83c3fd5c7a6bccb908", + "size": 514638, + "subdir": "linux-64", + "timestamp": 1539968313039, + "version": "7.61.1" + }, + "libcurl-7.61.1-heec0ca6_0.tar.bz2": { + "build": "heec0ca6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.0.2p,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "74295be8679203ad390acb9e4a3c2127", + "name": "libcurl", + "sha256": "b69bad2700657bc218907f1019565ec90e4191552ed9a3f3ccbad18bcf78c3be", + "size": 507445, + "subdir": "linux-64", + "timestamp": 1538232666465, + "version": "7.61.1" + }, + "libcurl-7.62.0-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.1.1a,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "1ea83ed790139f5266f37e4ba5b4d851", + "name": "libcurl", + "sha256": "d7f72c508bbdd8bf486b55a14893ee6de32fa8b6d1434e48abfccf9ae1c48f1b", + "size": 529896, + "subdir": "linux-64", + "timestamp": 1541435347443, + "version": "7.62.0" + }, + "libcurl-7.63.0-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.1.1a,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "06f81e1227a44ff77d148ca238bd5d60", + "name": "libcurl", + "sha256": "8f91e70377d153b14210fd370c0c792e57622c5d8ad491981958a54f68ccb9bc", + "size": 602330, + "subdir": "linux-64", + "timestamp": 1547225793370, + "version": "7.63.0" + }, + "libcurl-7.63.0-h20c2e04_1000.tar.bz2": { + "build": "h20c2e04_1000", + "build_number": 1000, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.1.1a,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "2057434527d343f433ca7abf5aba1f29", + "name": "libcurl", + "sha256": "db2848fc0c8ded20d140941927b356870ddcf1fd5f3e5a5e2b215798868d637b", + "size": 563693, + "subdir": "linux-64", + "timestamp": 1545106026062, + "version": "7.63.0" + }, + "libcurl-7.64.0-h20c2e04_2.tar.bz2": { + "build": "h20c2e04_2", + "build_number": 2, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.1.1b,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "ae368268670589903a5c803b1bd69d3c", + "name": "libcurl", + "sha256": "5668a2e87c6af13ca08a99f71c5034a544bebbf94f992601aa8ce88ec2a43026", + "size": 614162, + "subdir": "linux-64", + "timestamp": 1552411755987, + "version": "7.64.0" + }, + "libcurl-7.64.1-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "openssl >=1.1.1b,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "fab8302d44fd4e580e95afb22bab91cb", + "name": "libcurl", + "sha256": "eaced3e11dd2536029926c1e709b033c0e9ea141bfac9c948217caf9135ef9b6", + "size": 595628, + "subdir": "linux-64", + "timestamp": 1556031956997, + "version": "7.64.1" + }, + "libcurl-7.65.2-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "openssl >=1.1.1c,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "ed74c4c6a4cb6f854ce106baf247ed42", + "name": "libcurl", + "sha256": "70488c881bc040a77ba5664295d2a2c98a7b5e89dd478dc8f00e3a0f1048f353", + "size": 601677, + "subdir": "linux-64", + "timestamp": 1563398718220, + "version": "7.65.2" + }, + "libcurl-7.65.3-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "openssl >=1.1.1c,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "bfff1068b78dcf8248e087cbeaddb620", + "name": "libcurl", + "sha256": "4b5498e04d2a4d28a261807a0fc4421b21aee9236aa42e1fbeeb1360ff6be364", + "size": 602253, + "subdir": "linux-64", + "timestamp": 1566828842344, + "version": "7.65.3" + }, + "libcurl-7.67.0-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "openssl >=1.1.1d,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "7764f31a380330dd0709e91c3f8aef26", + "name": "libcurl", + "sha256": "8707bb9b52d4dec4880f35640c4acf6cab0207b7b51181e8ef52e3e1d85e9f9a", + "size": 589964, + "subdir": "linux-64", + "timestamp": 1574273435826, + "version": "7.67.0" + }, + "libcurl-7.68.0-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.17.1,<1.18.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "openssl >=1.1.1d,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "030a42029bc19f824786c0cf691edcac", + "name": "libcurl", + "sha256": "8476462bf18db63c074649283280c027af19dd5ec0051e1dfec0754b12e5e0c0", + "size": 594310, + "subdir": "linux-64", + "timestamp": 1580837341017, + "version": "7.68.0" + }, + "libcurl-7.69.1-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.17.1,<1.18.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1d,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "9dc9ae1df3e3b750d6b8f44f2d44354b", + "name": "libcurl", + "sha256": "462a06ab9e31bd88c8e1c14fc37980403b4d92e7fa00807d991de555793c8b47", + "size": 605070, + "subdir": "linux-64", + "timestamp": 1584460896818, + "version": "7.69.1" + }, + "libcurl-7.71.0-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1g,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "65794a15839407222327b5cddb939665", + "name": "libcurl", + "sha256": "25b9b87c6d9152bfca833f2128c199ef6444e3293679c7084a35abe600409850", + "size": 620183, + "subdir": "linux-64", + "timestamp": 1593438198583, + "version": "7.71.0" + }, + "libcurl-7.71.1-h20c2e04_1.tar.bz2": { + "build": "h20c2e04_1", + "build_number": 1, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1g,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "49b7de59c7f643dfda8c531f313bec53", + "name": "libcurl", + "sha256": "07c931c0a623f8de4626d6fae3800cf051a4094c0829ba30eb447b324131858e", + "size": 320788, + "subdir": "linux-64", + "timestamp": 1594834903124, + "version": "7.71.1" + }, + "libcurl-7.71.1-h303737a_2.tar.bz2": { + "build": "h303737a_2", + "build_number": 2, + "depends": [ + "krb5 >=1.19.1,<1.20.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1k,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "773a17ef2ce2770338c47d70a886e36c", + "name": "libcurl", + "sha256": "4b173fd2d7bfa5f5e244b9d8c64478686f143888925f9346e5f757b955970311", + "size": 320823, + "subdir": "linux-64", + "timestamp": 1621648761512, + "version": "7.71.1" + }, + "libcurl-7.78.0-h0b77cf5_0.tar.bz2": { + "build": "h0b77cf5_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "libnghttp2 >=1.41.0,<2.0a0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1k,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "8142887a4af24cf551d3f8fb66358d39", + "name": "libcurl", + "sha256": "c2429bd9a16de49dc13fcac1f0cf96b0e45b7c24cedae8e4fbb648ae8a41363f", + "size": 355750, + "subdir": "linux-64", + "timestamp": 1628797013645, + "version": "7.78.0" + }, + "libcurl-7.80.0-h0b77cf5_0.tar.bz2": { + "build": "h0b77cf5_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "libnghttp2 >=1.46.0,<2.0a0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1l,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "73df472a9b93d740fac016252af70b41", + "name": "libcurl", + "sha256": "dd0836d9adf78be1021aa7cf0bd90ae46119edfd0d4dc19a032d7c8f57c40661", + "size": 359212, + "subdir": "linux-64", + "timestamp": 1639143826639, + "version": "7.80.0" + }, + "libcurl-7.82.0-h0b77cf5_0.tar.bz2": { + "build": "h0b77cf5_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "libnghttp2 >=1.46.0,<2.0a0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1n,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "58bfe76e3f31d4a36acd7a7f4092b6ce", + "name": "libcurl", + "sha256": "765358a6dbb22f82dc3bb929b94df73b7b5fe6b4faf0caee83eff73c24c379f7", + "size": 359251, + "subdir": "linux-64", + "timestamp": 1649731351073, + "version": "7.82.0" + }, + "libcurl-7.84.0-h91b91d3_0.tar.bz2": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libnghttp2 >=1.46.0,<2.0a0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "0609d762533acd27ac555f3d3f06034c", + "name": "libcurl", + "sha256": "dd80d58faeb29ec5baf521f9ca46de5f485d19ccdcb7ae264f258ae8d78e59c6", + "size": 355290, + "subdir": "linux-64", + "timestamp": 1659041689515, + "version": "7.84.0" + }, + "libcurl-7.85.0-h91b91d3_0.tar.bz2": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libnghttp2 >=1.46.0,<2.0a0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "77a6db7aea0a5756150f869e87d30248", + "name": "libcurl", + "sha256": "a9dfad4c610ecd56257d7fa64f6d194d52997e74221acc0b2a9efe22d1e4c0d0", + "size": 357001, + "subdir": "linux-64", + "timestamp": 1666683418263, + "version": "7.85.0" + }, + "libcurl-7.86.0-h91b91d3_0.tar.bz2": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libnghttp2 >=1.46.0,<2.0a0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1s,<1.1.2a", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "6d49c8de32c6bda792891a8c998a5ffb", + "name": "libcurl", + "sha256": "7c4e1fed207e3acd27a40b6e7a00927b55f745e412333d86941165a0b1d19276", + "size": 358501, + "subdir": "linux-64", + "timestamp": 1669738513219, + "version": "7.86.0" + }, + "libcurl-7.87.0-h91b91d3_0.tar.bz2": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libnghttp2 >=1.46.0,<2.0a0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1s,<1.1.2a", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "ed36884d59089798d78894f7fa8f0ff0", + "name": "libcurl", + "sha256": "969b3f7b95843f5687f7c3c5c7e09bffff9e0c390e90489fa560bc5a53d1d380", + "size": 362969, + "subdir": "linux-64", + "timestamp": 1674234304307, + "version": "7.87.0" + }, + "libcurl-7.88.1-h91b91d3_0.tar.bz2": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.4,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libnghttp2 >=1.46.0", + "libnghttp2 >=1.46.0,<2.0a0", + "libssh2 >=1.10.0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1t,<1.1.2a", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "3b52be1968f0806917449b525986e11d", + "name": "libcurl", + "sha256": "49827a135b17d611b7d360c55ba57e27c5a5b528a7eadaa90e72f5e7a96c2cdc", + "size": 372523, + "subdir": "linux-64", + "timestamp": 1678377841152, + "version": "7.88.1" + }, + "libcurl-static-7.78.0-h0b77cf5_0.tar.bz2": { + "build": "h0b77cf5_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libcurl 7.78.0 h0b77cf5_0", + "libgcc-ng >=7.5.0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1k,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "32428801a869cbb0194c66b983e5f217", + "name": "libcurl-static", + "sha256": "dfa048268fd3ff0db80600cd0323795c07a701841174c4087cc0f69571e7ab54", + "size": 361611, + "subdir": "linux-64", + "timestamp": 1628797027827, + "version": "7.78.0" + }, + "libcurl-static-7.80.0-h8f2d780_0.tar.bz2": { + "build": "h8f2d780_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libcurl 7.80.0 h0b77cf5_0", + "libgcc-ng >=7.5.0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1l,<1.1.2a" + ], + "license": "curl", + "license_family": "MIT", + "md5": "1715f7d8191a9efa976ca6f846fe5d27", + "name": "libcurl-static", + "sha256": "0adba2c76d637b504072d56ba633d9254fd2e27f702dd548879146df7f5a5e37", + "size": 364073, + "subdir": "linux-64", + "timestamp": 1639143840502, + "version": "7.80.0" + }, + "libcurl-static-7.82.0-h8f2d780_0.tar.bz2": { + "build": "h8f2d780_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libcurl 7.82.0 h0b77cf5_0", + "libgcc-ng >=7.5.0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1n,<1.1.2a" + ], + "license": "curl", + "license_family": "MIT", + "md5": "71c6de7ab9875a0ad66f255420f13ee6", + "name": "libcurl-static", + "sha256": "59e515fc2c8ee36c020f2b1d6a3d685a37c02984afe89a3708cf4506035d4c41", + "size": 366067, + "subdir": "linux-64", + "timestamp": 1649731365130, + "version": "7.82.0" + }, + "libcurl-static-7.84.0-h91b91d3_0.tar.bz2": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libcurl 7.84.0 h91b91d3_0", + "libgcc-ng >=11.2.0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "89b1303587396c9f20d3a62c08195f24", + "name": "libcurl-static", + "sha256": "b593118d96e89f51e1048bb652a90562fd17d6cda589454289fca1c10417106c", + "size": 361768, + "subdir": "linux-64", + "timestamp": 1659041704179, + "version": "7.84.0" + }, + "libcurl-static-7.85.0-h91b91d3_0.tar.bz2": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libcurl 7.85.0 h91b91d3_0", + "libgcc-ng >=11.2.0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "0b3abf5b055d00eaff92bfd85b17d2e7", + "name": "libcurl-static", + "sha256": "09303eb39976fff0c3bb53d86e713b43957acd1b1bb03e2f7ca0d491a3c4abde", + "size": 363259, + "subdir": "linux-64", + "timestamp": 1666683430224, + "version": "7.85.0" + }, + "libcurl-static-7.86.0-h91b91d3_0.tar.bz2": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libcurl 7.86.0 h91b91d3_0", + "libgcc-ng >=11.2.0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1s,<1.1.2a", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "7a9b009894b3fe354d5ea31152a462a8", + "name": "libcurl-static", + "sha256": "fa02f3a3b549b4e138fc07352d320c61eb7b5e5584f209aa4b1cf3698df48cae", + "size": 363478, + "subdir": "linux-64", + "timestamp": 1669738524947, + "version": "7.86.0" + }, + "libcurl-static-7.87.0-h91b91d3_0.tar.bz2": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libcurl 7.87.0 h91b91d3_0", + "libgcc-ng >=11.2.0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1s,<1.1.2a", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "8afcd00d849639d5490a5145c330d5ab", + "name": "libcurl-static", + "sha256": "70641556d7a0ce303b039fcd90bc8778c4d7915977ae5384c5ca24f98a321e98", + "size": 368959, + "subdir": "linux-64", + "timestamp": 1674234316189, + "version": "7.87.0" + }, + "libcurl-static-7.88.1-h91b91d3_0.tar.bz2": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.4,<1.20.0a0", + "libcurl 7.88.1 h91b91d3_0", + "libgcc-ng >=11.2.0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1t,<1.1.2a", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "be67ca4d53966ac283aee8ae9376f1f8", + "name": "libcurl-static", + "sha256": "5b7f0a2cd5bedf21e4503ebdad326714b1a2e2e45e9883f986a37f28895c8416", + "size": 380453, + "subdir": "linux-64", + "timestamp": 1678377853606, + "version": "7.88.1" + }, + "libcxx-14.0.6-h83ecd13_0.tar.bz2": { + "build": "h83ecd13_0", + "build_number": 0, + "depends": [ + "libcxxabi 14.0.6 h06a4308_0", + "libgcc-ng >=11.2.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "a766e849bdce0097363302515fea4511", + "name": "libcxx", + "sha256": "7cb3beb92e3ecdeec91c27f4ede93375aaddac1fe19bc5dab14c1f9d82dc156c", + "size": 1528727, + "subdir": "linux-64", + "timestamp": 1662620535350, + "version": "14.0.6" + }, + "libcxxabi-14.0.6-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "constrains": [ + "libcxx 14.0.6.*" + ], + "depends": [], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "d2124203fe070945c8dc685b38bd8719", + "name": "libcxxabi", + "sha256": "7dc1e6c62242f868643850e934baa07d69b3457e063aac357a7e4c79bff26e96", + "size": 188309, + "subdir": "linux-64", + "timestamp": 1662620526949, + "version": "14.0.6" + }, + "libdap4-3.19.0-h5bd89bb_2.tar.bz2": { + "build": "h5bd89bb_2", + "build_number": 2, + "depends": [ + "curl", + "libcurl >=7.58.0,<8.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.7,<2.10.0a0" + ], + "license": "GNU LGPL", + "md5": "d003a5fd674ccc8ff43944cdbe072d4f", + "name": "libdap4", + "sha256": "966f16db181be5ea73385b713509c3b0af15e7513e2e0f5081aa09f56b0372e5", + "size": 1621744, + "subdir": "linux-64", + "timestamp": 1518111422068, + "version": "3.19.0" + }, + "libdap4-3.19.0-h6ec2957_2.tar.bz2": { + "build": "h6ec2957_2", + "build_number": 2, + "depends": [ + "curl", + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0" + ], + "license": "GNU LGPL", + "md5": "d6474830928c88f5ba44e2104c0de654", + "name": "libdap4", + "sha256": "f0f053bd9e8a713bcceae30a1aaa569d904b3000a0389be35b7305f014a72ea5", + "size": 1611590, + "subdir": "linux-64", + "timestamp": 1530868852589, + "version": "3.19.0" + }, + "libdap4-3.19.0-h8c95237_1.tar.bz2": { + "build": "h8c95237_1", + "build_number": 1, + "depends": [ + "curl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "util-linux" + ], + "license": "GNU LGPL", + "md5": "2b51a62c7ad9fe90ee1965b7295f8a9b", + "name": "libdap4", + "sha256": "33aefbed6959ae607b2eb740e31442e04a8b5e43299ee297ee594c3880c17fbb", + "size": 1650047, + "subdir": "linux-64", + "timestamp": 1511371852263, + "version": "3.19.0" + }, + "libdap4-3.19.0-haaf9fdb_1.tar.bz2": { + "build": "haaf9fdb_1", + "build_number": 1, + "depends": [ + "curl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "util-linux" + ], + "license": "GNU LGPL", + "md5": "1c1a133801b50374dff8f6d8dd6f93eb", + "name": "libdap4", + "sha256": "598a893c0edfa3bb30c79d449670a0baa7bf71ae1540bf58f5ec071ed88d7185", + "size": 1649712, + "subdir": "linux-64", + "timestamp": 1509503009528, + "version": "3.19.0" + }, + "libdap4-3.19.1-h6a678d5_1.tar.bz2": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "curl", + "libcurl >=7.88.1,<8.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "libxml2 >=2.10.3,<2.11.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "13d680efc5ccd56566119a834335483c", + "name": "libdap4", + "sha256": "858fcbbabcfbc9b1d6094ee580fe1f6b5bd7440ca324e1b5eb70fbafc20fe363", + "size": 1846810, + "subdir": "linux-64", + "timestamp": 1679578334916, + "version": "3.19.1" + }, + "libdap4-3.19.1-h6ec2957_0.tar.bz2": { + "build": "h6ec2957_0", + "build_number": 0, + "depends": [ + "curl", + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0" + ], + "license": "GNU LGPL", + "md5": "6c12fa06df93e20a3b53d790e1fc7fc8", + "name": "libdap4", + "sha256": "a9a73e8eeff093c5c4fb28e9f2e9c4fba2af8ec90961179429008c37a928f952", + "size": 1616824, + "subdir": "linux-64", + "timestamp": 1532084028670, + "version": "3.19.1" + }, + "libdate-3.0.1-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87864a8bd5c3b42f1c2b2e565fa28d1b", + "name": "libdate", + "sha256": "18e1d018c53af4190116d416c5f1f99b6bd5163bb9f53b8422d3448023873ad0", + "size": 120812, + "subdir": "linux-64", + "timestamp": 1659102203728, + "version": "3.0.1" + }, + "libdb-6.1.26-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "AGPL-3.0", + "md5": "8a91308dc9d698f4594a8a07211bf527", + "name": "libdb", + "sha256": "830b7e145a1232322655a412a585d07f86772af48095599da913c4695e12dda4", + "size": 23224146, + "subdir": "linux-64", + "timestamp": 1537817966915, + "version": "6.1.26" + }, + "libdb-6.2.32-h6a678d5_1.tar.bz2": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "AGPL-3.0-only", + "md5": "a6c379d9ba2c77c976a1a61101eee63d", + "name": "libdb", + "sha256": "45a70065492354d544e9b2922ca9388d5173fee217343d5454745fbed4183430", + "size": 24293391, + "subdir": "linux-64", + "timestamp": 1656332129152, + "version": "6.2.32" + }, + "libdb-6.2.32-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "AGPL-3.0-only", + "md5": "38c739cc0e9b25bfd8a43856c4e4b590", + "name": "libdb", + "sha256": "d789d5267516c11d1b528c0c08ac49b4cb41788a7da6c816d174ae7751b509eb", + "size": 24401252, + "subdir": "linux-64", + "timestamp": 1601249370375, + "version": "6.2.32" + }, + "libdb-6.2.32-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "AGPL-3.0-only", + "md5": "4a19ad1ffd1dc03a515f5a7d6b7775e3", + "name": "libdb", + "sha256": "d998c247e94c42838074e78c895fc4150f1957718550197b24b9ca1ff742ccb7", + "size": 24391178, + "subdir": "linux-64", + "timestamp": 1601249464834, + "version": "6.2.32" + }, + "libdeflate-1.17-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0bba870378a2bef020ba80093daad19a", + "name": "libdeflate", + "sha256": "65787b4bce0b108758751ad0a49c0f98858ba126e61d76ac439ceef84b67dbee", + "size": 72444, + "subdir": "linux-64", + "timestamp": 1677486576483, + "version": "1.17" + }, + "libdeflate-1.7-h27cfd23_5.tar.bz2": { + "build": "h27cfd23_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "md5": "ea4a2376d5602b194c36389de2baa19c", + "name": "libdeflate", + "sha256": "03a149b4a392eaec990a7faa7924c0d38ee522742f2780f8f17f95299d5a9270", + "size": 73823, + "subdir": "linux-64", + "timestamp": 1611255495157, + "version": "1.7" + }, + "libdeflate-1.8-h7f8727e_5.tar.bz2": { + "build": "h7f8727e_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "88cd43eece362464d4842f1b2f92a1de", + "name": "libdeflate", + "sha256": "baa972018b6f8c880ff567194ae4026425c77baa0f285e6a0c50a0aa06c50498", + "size": 68963, + "subdir": "linux-64", + "timestamp": 1626439978555, + "version": "1.8" + }, + "libedit-3.1-heed3624_0.tar.bz2": { + "build": "heed3624_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "ncurses 6.0.*" + ], + "license": "3-Clause BSD", + "license_family": "BSD", + "md5": "91ce7622c3bc0a51cb3b897749f1aeaf", + "name": "libedit", + "sha256": "2bb9db22098bce99a2511d8d223dca07827f7bde76b14be7a3500c3c166bf211", + "size": 175030, + "subdir": "linux-64", + "timestamp": 1505666480132, + "version": "3.1" + }, + "libedit-3.1.20170329-h6b74fdf_2.tar.bz2": { + "build": "h6b74fdf_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "ncurses >=6.1,<7.0a0" + ], + "license": "NetBSD", + "license_family": "BSD", + "md5": "a964d1e4af67f04710aa18950279b7f4", + "name": "libedit", + "sha256": "4a30b3252242d542c804792afd605358869d07db3a3c42302ba6fa99360e5696", + "size": 176192, + "subdir": "linux-64", + "timestamp": 1525913899914, + "version": "3.1.20170329" + }, + "libedit-3.1.20181209-hc058e9b_0.tar.bz2": { + "build": "hc058e9b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ncurses >=6.1,<7.0a0" + ], + "license": "NetBSD", + "license_family": "BSD", + "md5": "bd18612aa844e6c52e3b659cbaa706ea", + "name": "libedit", + "sha256": "8a34c8d291819de4a9c83a8be789687ea83e7d9ae6022467bb49d6b57e6c88b0", + "size": 192019, + "subdir": "linux-64", + "timestamp": 1547971047214, + "version": "3.1.20181209" + }, + "libedit-3.1.20191231-h14c3975_1.tar.bz2": { + "build": "h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "6448fbc5c3a35ff00bb1e5e066bc929a", + "name": "libedit", + "sha256": "47747e1d30bd4998b864f233194428fba6e202e1e86b93a1253cfb0347dfee68", + "size": 124096, + "subdir": "linux-64", + "timestamp": 1594367571417, + "version": "3.1.20191231" + }, + "libedit-3.1.20191231-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "fc2160cdfed0eb62e57e7b17f3eeecb3", + "name": "libedit", + "sha256": "f74b3fe2242c44f933f5e2537f1aa5f885178df0f2e3c4424e2c01ac499511bd", + "size": 194204, + "subdir": "linux-64", + "timestamp": 1592512294724, + "version": "3.1.20191231" + }, + "libedit-3.1.20210216-h27cfd23_1.tar.bz2": { + "build": "h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "3479886f83471bb71c80e5a96a95b62c", + "name": "libedit", + "sha256": "bca6da6904b108acd850dd33e038823706a8ee19d8f6dda2c8c675ca9b2fe0a9", + "size": 194415, + "subdir": "linux-64", + "timestamp": 1615827969117, + "version": "3.1.20210216" + }, + "libedit-3.1.20210714-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "ncurses >=6.2,<7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c4d6a9395eee6a809d424734ea109eb0", + "name": "libedit", + "sha256": "6d04a5174568adbe311979539e4c98c7b00164d002cd1dd9ac501ea5049249ca", + "size": 192762, + "subdir": "linux-64", + "timestamp": 1630071246101, + "version": "3.1.20210714" + }, + "libedit-3.1.20210910-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "ncurses >=6.3,<7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5f295795bb8e419eacb4d6ffbba68ceb", + "name": "libedit", + "sha256": "47d3ff15d11ffed8a2b8954d5e100b3806ff6898a12ec500d7afe043dc2076de", + "size": 195324, + "subdir": "linux-64", + "timestamp": 1636026988621, + "version": "3.1.20210910" + }, + "libedit-3.1.20221030-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "af7584851084abae8eaa8cee2ed288b4", + "name": "libedit", + "sha256": "5d66a60672f8e7dd0c048b5f158b5d406f16133b260ffde95a93eb453a1e7af9", + "size": 195621, + "subdir": "linux-64", + "timestamp": 1670840131081, + "version": "3.1.20221030" + }, + "libev-4.33-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "cfcb4ea0b167d1a33adc920283b8a6cd", + "name": "libev", + "sha256": "e34a7f4601fbaa355fea9a5c54fbcc2482616a9dff7dba74ede2bd9f80298acf", + "size": 109499, + "subdir": "linux-64", + "timestamp": 1597168717341, + "version": "4.33" + }, + "libev-4.33-h7f8727e_1.tar.bz2": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "eeca774c6154c49340dd403b1928d5e9", + "name": "libev", + "sha256": "efdab884c85fda4461f7a393aa6d4e0e50d03cb59fb9c8a980b1307b8379ebe0", + "size": 108906, + "subdir": "linux-64", + "timestamp": 1632891483341, + "version": "4.33" + }, + "libev-libevent-4.33-h7f8727e_1.tar.bz2": { + "build": "h7f8727e_1", + "build_number": 1, + "constrains": [ + "libevent ==9999999999" + ], + "depends": [ + "libev 4.33 h7f8727e_1", + "libgcc-ng >=7.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5510701987b4579e44014a5b0cb6bef4", + "name": "libev-libevent", + "sha256": "160e1df8ca77260d43fcee9af95e581684628915111e80bb4ca1b9d06842db3f", + "size": 9806, + "subdir": "linux-64", + "timestamp": 1632891491283, + "version": "4.33" + }, + "libev-static-4.33-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libev 4.33 h7b6447c_0", + "libgcc-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "fadee131d5361044dfdcd8b6d06849ca", + "name": "libev-static", + "sha256": "73ebecd580da37b05cf6663912383ee9acaa9b9b0a90b512be9976a6351fd768", + "size": 32519, + "subdir": "linux-64", + "timestamp": 1597168723823, + "version": "4.33" + }, + "libev-static-4.33-h7f8727e_1.tar.bz2": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libev 4.33 h7f8727e_1", + "libgcc-ng >=7.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "4d695ba8bf1fd61e2fde285ff2288b1f", + "name": "libev-static", + "sha256": "10af76db2c254d34ee5dcdda02656fa7a511aaee7aeb9285118e9526a22cb854", + "size": 33399, + "subdir": "linux-64", + "timestamp": 1632891498542, + "version": "4.33" + }, + "libevent-2.1.12-h8f2d780_0.tar.bz2": { + "build": "h8f2d780_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openssl >=1.1.1m,<1.1.2a" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2e3534102d10ade546c0feb056bbffbe", + "name": "libevent", + "sha256": "2b9470932f5c923f19fcc14c8d1c7ed5f58a468588c09d6b04e0a905c07a297f", + "size": 491177, + "subdir": "linux-64", + "timestamp": 1642102679055, + "version": "2.1.12" + }, + "libevent-2.1.8-h1ba5d50_0.tar.bz2": { + "build": "h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "56c890925ee3b779fffcf3b653bee52c", + "name": "libevent", + "sha256": "a0388c31387dc3e556d1fbd5f06520b2aaaad24d4f5d49e086bfe9d0f3c2b714", + "size": 1268362, + "subdir": "linux-64", + "timestamp": 1540396874706, + "version": "2.1.8" + }, + "libevent-2.1.8-h1ba5d50_1.tar.bz2": { + "build": "h1ba5d50_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a8378bac6a583a927cff1e0832397a8b", + "name": "libevent", + "sha256": "1a92a1645dec068a6dc1558faa984cb7957ce9587ecd437d1db624084ff497fd", + "size": 1389331, + "subdir": "linux-64", + "timestamp": 1599251065437, + "version": "2.1.8" + }, + "libevent-2.1.8-h93c0eb6_0.tar.bz2": { + "build": "h93c0eb6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d51d348b1c784578de72cc14cbb584ab", + "name": "libevent", + "sha256": "74eac37e57d89e168a4eb233fa4e1e20293f5478ed3a810d809a18c98fd09e59", + "size": 1477414, + "subdir": "linux-64", + "timestamp": 1511641734520, + "version": "2.1.8" + }, + "libffi-3.2.1-h4deb6c0_3.tar.bz2": { + "build": "h4deb6c0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Custom", + "md5": "910c1cfa6413d81007a989fac054d67b", + "name": "libffi", + "sha256": "68d33d24d3a8321654b85d0fa46270c238c0b77839a7a681476a88f11c6e4b4e", + "size": 43748, + "subdir": "linux-64", + "timestamp": 1505666561994, + "version": "3.2.1" + }, + "libffi-3.2.1-hd88cf55_4.tar.bz2": { + "build": "hd88cf55_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Custom", + "md5": "723c98107d830bdf000772bf1976e0c3", + "name": "libffi", + "sha256": "7eac01729dcdb187a1bc3584e61956d1ded34ee50e7a810daa7b83f34d54e063", + "size": 44477, + "subdir": "linux-64", + "timestamp": 1510177337742, + "version": "3.2.1" + }, + "libffi-3.2.1-he6710b0_1007.tar.bz2": { + "build": "he6710b0_1007", + "build_number": 1007, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Custom", + "md5": "b781f3849dccd470c0fcb41a77a97577", + "name": "libffi", + "sha256": "63db0af38029b94f9a39fb14489bda7f76847502a26216f42372d6c014fa346b", + "size": 56753, + "subdir": "linux-64", + "timestamp": 1601368071003, + "version": "3.2.1" + }, + "libffi-3.2.1-hf484d3e_1007.tar.bz2": { + "build": "hf484d3e_1007", + "build_number": 1007, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Custom", + "md5": "73fed6814c1b3c21f69d740164b7a937", + "name": "libffi", + "sha256": "decb4d52c4923a04f81fe2c6e3b7ade3bf0911a79343a6a803e32d7da2cf0afe", + "size": 53202, + "subdir": "linux-64", + "timestamp": 1601368102100, + "version": "3.2.1" + }, + "libffi-3.3-he6710b0_1.tar.bz2": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Custom", + "md5": "43bcdf2e6198aa64303aa6eb0af22ec7", + "name": "libffi", + "sha256": "e0a9523beb4e22c0a515221c961d40857555b969635f8147b7391173c5a1d5ca", + "size": 55007, + "subdir": "linux-64", + "timestamp": 1587588834166, + "version": "3.3" + }, + "libffi-3.3-he6710b0_2.tar.bz2": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Custom", + "md5": "822b5201dde61bc838072dc5b670c88c", + "name": "libffi", + "sha256": "3b4afe7665dcdb99bd4586a888b85b2e0325f8faecdd31c7780792080ee97872", + "size": 55183, + "subdir": "linux-64", + "timestamp": 1594054267890, + "version": "3.3" + }, + "libffi-3.4.2-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "md5": "ba6b559eddad1de9b1e57cf7447427f8", + "name": "libffi", + "sha256": "2995575e5ac85b3fc00b97df4549de12c804d6993e3df8931b20dae94c664747", + "size": 68360, + "subdir": "linux-64", + "timestamp": 1632983431265, + "version": "3.4.2" + }, + "libffi-3.4.2-h295c915_1.tar.bz2": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "md5": "6b596a8a25799a427ff850c71cc505a3", + "name": "libffi", + "sha256": "9a0728dacc994e78cd97dbb7846fae055fc531fd725835912b4e53e85726382b", + "size": 65983, + "subdir": "linux-64", + "timestamp": 1636541731368, + "version": "3.4.2" + }, + "libffi-3.4.2-h295c915_2.tar.bz2": { + "build": "h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "md5": "2d5973d4d85288cf9091f864aa6f4e69", + "name": "libffi", + "sha256": "6ae8f555b17afe0ece68eefd8cf715b75b0a0010ce9a62a0571d4809125a955d", + "size": 65976, + "subdir": "linux-64", + "timestamp": 1636543695241, + "version": "3.4.2" + }, + "libffi-3.4.2-h295c915_4.tar.bz2": { + "build": "h295c915_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9420f780186158fa096601855f2f2b92", + "name": "libffi", + "sha256": "421f766ce69ea307bb2b4fed020baa82bd9f511e51b6ee9951a030c62a767a10", + "size": 135466, + "subdir": "linux-64", + "timestamp": 1654878550541, + "version": "3.4.2" + }, + "libffi-3.4.2-h6a678d5_5.tar.bz2": { + "build": "h6a678d5_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58b4f421e9e84886d17919f1b209bab0", + "name": "libffi", + "sha256": "f3922867c43404c88394ed37f78903d8dd24e75dc9e1501c99e7c2343a00f370", + "size": 137441, + "subdir": "linux-64", + "timestamp": 1669039999559, + "version": "3.4.2" + }, + "libffi-3.4.2-h6a678d5_6.tar.bz2": { + "build": "h6a678d5_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e87570b45df1cd10db6ad9c2c79a3b30", + "name": "libffi", + "sha256": "511cb2648f208b6530f1e11969aeb664dea4515082299838ba4320ec9cae7394", + "size": 138391, + "subdir": "linux-64", + "timestamp": 1669126632561, + "version": "3.4.2" + }, + "libgcc-7.2.0-h69d50b8_2.tar.bz2": { + "build": "h69d50b8_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GNU GPL 3+ with GCC Runtime Library", + "license_family": "GPL", + "md5": "9962126180acc1a4fec0c6aabe7c2459", + "name": "libgcc", + "sha256": "fe7f1ac1ce89f37d7314760bf17fad8198435443358d570f620fb1dec33ca051", + "size": 311733, + "subdir": "linux-64", + "timestamp": 1505745053518, + "version": "7.2.0" + }, + "libgcc-devel_linux-64-11.2.0-h1234567_0.tar.bz2": { + "build": "h1234567_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "84507aaa09ed81142972e10ce9fc8fcf", + "name": "libgcc-devel_linux-64", + "sha256": "60a24c301027db32acfd98928d202613e8d6c3d2d3797c082697a39b371387a0", + "size": 3740497, + "subdir": "linux-64", + "timestamp": 1652859669676, + "version": "11.2.0" + }, + "libgcc-devel_linux-64-11.2.0-h1234567_1.tar.bz2": { + "build": "h1234567_1", + "build_number": 1, + "depends": [ + "__glibc >=2.17,<3.0.a0" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "3ad4f8ccca9a49b9d3e18855393274b6", + "name": "libgcc-devel_linux-64", + "sha256": "4501ff9747049e8e7f4dbfb44a54600891d92c7c6444bcb760939daf32c5ff0d", + "size": 3734181, + "subdir": "linux-64", + "timestamp": 1654090753647, + "version": "11.2.0" + }, + "libgcc-devel_linux-64-7.5.0-hbbeae57_17.tar.bz2": { + "build": "hbbeae57_17", + "build_number": 17, + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "4ec7b66cd861dd0ecba8040bccfcd8ea", + "name": "libgcc-devel_linux-64", + "sha256": "2e260fb18db414bbace9d23c96ee8855f28b972976a2c4c5fae8d7e09d8867d8", + "size": 3779404, + "subdir": "linux-64", + "timestamp": 1622660030050, + "version": "7.5.0" + }, + "libgcc-devel_linux-64-8.4.0-hd257e2f_17.tar.bz2": { + "build": "hd257e2f_17", + "build_number": 17, + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "2c81919313b67966d3cacd11b11f0b7c", + "name": "libgcc-devel_linux-64", + "sha256": "50c465deca7ee4c7ce753c8973e460d8320f6723e5c116a49dbc1d57938b21ad", + "size": 4171900, + "subdir": "linux-64", + "timestamp": 1622661638276, + "version": "8.4.0" + }, + "libgcc-devel_linux-64-9.3.0-hb95220a_17.tar.bz2": { + "build": "hb95220a_17", + "build_number": 17, + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "a44134b6be72f6895305587a7b9d7c73", + "name": "libgcc-devel_linux-64", + "sha256": "7a8995522a0939426232307e138c12c1444c3e405371d78425565f402a351054", + "size": 4185652, + "subdir": "linux-64", + "timestamp": 1622663285149, + "version": "9.3.0" + }, + "libgcc-ng-11.2.0-h1234567_0.tar.bz2": { + "build": "h1234567_0", + "build_number": 0, + "constrains": [ + "_openmp_mutex", + "libgomp 11.2.0 h1234567_0", + "_libgcc_mutex 0.1 main" + ], + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex", + "_libgcc_mutex * main", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "f98805181b8640ea1eabc2de537ff3b4", + "name": "libgcc-ng", + "sha256": "4531feda599f0722fee2029a90e29378883b8237dd324e9169fc2dd28f943d37", + "size": 8893334, + "subdir": "linux-64", + "timestamp": 1652859742018, + "version": "11.2.0" + }, + "libgcc-ng-11.2.0-h1234567_1.tar.bz2": { + "build": "h1234567_1", + "build_number": 1, + "constrains": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex", + "libgomp 11.2.0 h1234567_1" + ], + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex", + "_libgcc_mutex * main", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "641e72e5067bd6d5454405879e1cd2a7", + "name": "libgcc-ng", + "sha256": "f52d33d9c7cccf09b429a341d0bf803c8365a02a73a77b7ff887ec88f25d1c1a", + "size": 8895144, + "subdir": "linux-64", + "timestamp": 1654090827491, + "version": "11.2.0" + }, + "libgcc-ng-5.4.0-hdf63c60_3.tar.bz2": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [ + "_libgcc_mutex * main" + ], + "license": "GPL", + "md5": "c877cd302d5f2c19821122dc6b7d5814", + "name": "libgcc-ng", + "sha256": "09cd5e27c06954034b3517628a7467edbbfe8b755cb9608a5a2410d145cc1995", + "size": 4613415, + "subdir": "linux-64", + "timestamp": 1520969505500, + "version": "5.4.0" + }, + "libgcc-ng-7.2.0-h7cc24e2_2.tar.bz2": { + "build": "h7cc24e2_2", + "build_number": 2, + "depends": [ + "_libgcc_mutex * main" + ], + "license": "GPL", + "md5": "2317e046bcd4aca2bb213b445c61fee0", + "name": "libgcc-ng", + "sha256": "b85f6408eee136c575a574bbf7ae4ebd0f7b8ad286900da46b915af01ae4e215", + "size": 6388124, + "subdir": "linux-64", + "timestamp": 1507262720504, + "version": "7.2.0" + }, + "libgcc-ng-7.2.0-hcbc56d2_1.tar.bz2": { + "build": "hcbc56d2_1", + "build_number": 1, + "depends": [ + "_libgcc_mutex * main" + ], + "license": "GPL", + "md5": "dac76163800f4547c1cb27f4460cedb8", + "name": "libgcc-ng", + "sha256": "4e543bf64ab0ed73ac010e6be6200182e7b3de2647b5e13291e74f843eddac1f", + "size": 6386759, + "subdir": "linux-64", + "timestamp": 1505665562970, + "version": "7.2.0" + }, + "libgcc-ng-7.2.0-hdf63c60_3.tar.bz2": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [ + "_libgcc_mutex * main" + ], + "license": "GPL", + "md5": "944ff8bc5bbcd6004f2b84726513dede", + "name": "libgcc-ng", + "sha256": "68dc2ea056ec0f1d8900b7bc7208262f3b5c9a8a51352c86c6891bc0fd0d6a26", + "size": 6386400, + "subdir": "linux-64", + "timestamp": 1520534508914, + "version": "7.2.0" + }, + "libgcc-ng-7.3.0-hdf63c60_0.tar.bz2": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex * main" + ], + "license": "GPL", + "md5": "f5e8a0e4b1ed4de1eac31dab66a6d2f2", + "name": "libgcc-ng", + "sha256": "16d5b619692899a1e2ce1a971c76859fd935698f53f0a5681e5b1754a2b1a9ee", + "size": 6444558, + "subdir": "linux-64", + "timestamp": 1534628447830, + "version": "7.3.0" + }, + "libgcc-ng-7.5.0-h5101ec6_17.tar.bz2": { + "build": "h5101ec6_17", + "build_number": 17, + "constrains": [ + "libgomp 7.5.0 h5101ec6_17" + ], + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex >=4.5", + "_libgcc_mutex * main", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "bf9a7b4b875ac4873a8be537822b8b03", + "name": "libgcc-ng", + "sha256": "e9a120e8ff26442e6a42b77a585a5dff98e404403261839080b55685fef34221", + "size": 6198919, + "subdir": "linux-64", + "timestamp": 1622660095834, + "version": "7.5.0" + }, + "libgcc-ng-8.2.0-hdf63c60_0.tar.bz2": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex * main" + ], + "license": "GPL", + "md5": "784853613131f4ace00c54d5c00c3a10", + "name": "libgcc-ng", + "sha256": "05ebb2c67c393ecd6b65f2a16b8e0a7b251c4ab58af7b0430cd9429f28ae325d", + "size": 7999846, + "subdir": "linux-64", + "timestamp": 1534277498668, + "version": "8.2.0" + }, + "libgcc-ng-8.2.0-hdf63c60_1.tar.bz2": { + "build": "hdf63c60_1", + "build_number": 1, + "depends": [ + "_libgcc_mutex * main" + ], + "license": "GPL", + "md5": "7d17c0d663e285a5e6cd7bfa8eed1cd8", + "name": "libgcc-ng", + "sha256": "1b6c9018bdfbd3c6b998ba072a244bb45f52d88b8774f4d458263bd3ac91c53f", + "size": 7996349, + "subdir": "linux-64", + "timestamp": 1534516107109, + "version": "8.2.0" + }, + "libgcc-ng-8.4.0-h5101ec6_17.tar.bz2": { + "build": "h5101ec6_17", + "build_number": 17, + "constrains": [ + "libgomp 8.4.0 h5101ec6_17" + ], + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex >=4.5", + "_libgcc_mutex * main", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "4e2b806b170198fd3af8d22a610b7cd9", + "name": "libgcc-ng", + "sha256": "403cac2852365ca509c19cc9ddc3c6ea0330ef055449f86c4064d982c645de59", + "size": 7719830, + "subdir": "linux-64", + "timestamp": 1622661701487, + "version": "8.4.0" + }, + "libgcc-ng-9.1.0-hdf63c60_0.tar.bz2": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex * main" + ], + "license": "GPL", + "md5": "238f19c803a6ba7bd6dbd6989e03cbf1", + "name": "libgcc-ng", + "sha256": "c6fafbe73d2f93b91b6f4b65829f925f52a8f84746a57abd216b39da9ce8c494", + "size": 8496776, + "subdir": "linux-64", + "timestamp": 1560112207081, + "version": "9.1.0" + }, + "libgcc-ng-9.3.0-h5101ec6_17.tar.bz2": { + "build": "h5101ec6_17", + "build_number": 17, + "constrains": [ + "libgomp 9.3.0 h5101ec6_17" + ], + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex >=4.5", + "_libgcc_mutex * main", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "877cdee0cc95b9b1a685a2d047072364", + "name": "libgcc-ng", + "sha256": "bdb43a7a4483ab03f4d5dba6212d5d9462764980c01cdea524eebc156765f540", + "size": 8201947, + "subdir": "linux-64", + "timestamp": 1622663350853, + "version": "9.3.0" + }, + "libgcrypt-1.8.0-h14c3975_2.tar.bz2": { + "build": "h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpg-error >=1.27,<2.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "8235f17ddb677a3518d6dbcbc97b290b", + "name": "libgcrypt", + "sha256": "53ad54b1ec83042dfb328c8bbea934cbf2e11b7d30caff59efca1a205980f28f", + "size": 619522, + "subdir": "linux-64", + "timestamp": 1515696811175, + "version": "1.8.0" + }, + "libgcrypt-1.8.2-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpg-error >=1.29,<2.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "81b2c0394998166ec827f71fba58f643", + "name": "libgcrypt", + "sha256": "c2632bbb1ea2de135c3c617b8bb34546e944451ac9c4728327d084d4dcf21448", + "size": 621253, + "subdir": "linux-64", + "timestamp": 1523954047529, + "version": "1.8.2" + }, + "libgcrypt-1.8.3-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpg-error >=1.31,<2.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "c8e7d8b52edc26fba188e6dfcef65cb6", + "name": "libgcrypt", + "sha256": "9a1b3470c1dbcfcaf79698ff88879ea3a7c7f22b336d089684b71e78c2d823bd", + "size": 622580, + "subdir": "linux-64", + "timestamp": 1529961323434, + "version": "1.8.3" + }, + "libgcrypt-1.8.4-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpg-error >=1.32,<2.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "6df86877965e87b9c7682c0983d5b4e5", + "name": "libgcrypt", + "sha256": "425fd44ed9a4bea40170d8386426f1e8224a5f5ee880924285835951ecc007f3", + "size": 628967, + "subdir": "linux-64", + "timestamp": 1540981549661, + "version": "1.8.4" + }, + "libgcrypt-1.8.6-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpg-error >=1.32,<2.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "720345154eab95d89aee964a96034f28", + "name": "libgcrypt", + "sha256": "aea7e7373767a2d6ec9761161df184071dbae4c1ea115600909a12358d1aff56", + "size": 627160, + "subdir": "linux-64", + "timestamp": 1600381734428, + "version": "1.8.6" + }, + "libgcrypt-1.8.7-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpg-error >=1.39,<2.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "9c757a1c7412d57915d794a90fc3581d", + "name": "libgcrypt", + "sha256": "a9d734d2b2f19232874f878a4a07980bf3c5b3b1264c6177164671c4022182a7", + "size": 629136, + "subdir": "linux-64", + "timestamp": 1603821168850, + "version": "1.8.7" + }, + "libgcrypt-1.9.0-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpg-error >=1.41,<2.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "f1bd1933884095815578704938728880", + "name": "libgcrypt", + "sha256": "4018f86d03626fcedf822556e2660191c5eaba8d2b41b6de8535b8e52ddcb54a", + "size": 667747, + "subdir": "linux-64", + "timestamp": 1611082600169, + "version": "1.9.0" + }, + "libgcrypt-1.9.1-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpg-error >=1.41,<2.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "755316655fd8544d47769fae0fbee5ec", + "name": "libgcrypt", + "sha256": "3c26bcc89a63cf623b58de28d59b5ccc9c7366102349e40eec6227f0174dce99", + "size": 682395, + "subdir": "linux-64", + "timestamp": 1611951455942, + "version": "1.9.1" + }, + "libgcrypt-1.9.2-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpg-error >=1.41,<2.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "e8976a7394b576c1ed0f67838ca02222", + "name": "libgcrypt", + "sha256": "43032cccf7c3550297a645907fe55db53dfb527c624c24c8c7fabee63042f290", + "size": 678724, + "subdir": "linux-64", + "timestamp": 1613588719411, + "version": "1.9.2" + }, + "libgcrypt-1.9.3-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpg-error >=1.42,<2.0a0" + ], + "license": "LGPL-2.1-or-later AND GPL-2.0-or-later", + "license_family": "GPL", + "md5": "dda0a6ccaeb4f3995b3537ccaa3d8606", + "name": "libgcrypt", + "sha256": "fdcfe5505d001d04673cb04e4220e40a30e7fadae347e28d32b856f72def7158", + "size": 693852, + "subdir": "linux-64", + "timestamp": 1618922221586, + "version": "1.9.3" + }, + "libgd-2.2.5-h0db58fd_3.tar.bz2": { + "build": "h0db58fd_3", + "build_number": 3, + "depends": [ + "expat >=2.2.6,<3.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GD", + "license_family": "BSD", + "md5": "0a8cd768daa61325bb78b0a03832a905", + "name": "libgd", + "sha256": "394b4c1858e41cf5b72a4c02e009f0eed3079fc8b5ea52f6b485be3dfce2156b", + "size": 317979, + "subdir": "linux-64", + "timestamp": 1581434054141, + "version": "2.2.5" + }, + "libgd-2.2.5-h8e06009_4.tar.bz2": { + "build": "h8e06009_4", + "build_number": 4, + "depends": [ + "expat", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "icu", + "jpeg >=9b,<10a", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GD", + "license_family": "BSD", + "md5": "080ba0ab3b3cf901a2699f566ee64817", + "name": "libgd", + "sha256": "af4b444489068c41f0b9c238385e920fa994651e330d5a790c0ccba12f16c204", + "size": 284553, + "subdir": "linux-64", + "timestamp": 1631695646696, + "version": "2.2.5" + }, + "libgd-2.2.5-hceca4fd_3.tar.bz2": { + "build": "hceca4fd_3", + "build_number": 3, + "depends": [ + "expat >=2.2.5,<3.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libtiff >=4.0.9,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GD", + "license_family": "BSD", + "md5": "ca6c4700ae75cd60381eb45c7a613bd2", + "name": "libgd", + "sha256": "553016c19b9f2bbe9e484865ff6280b8bea118e18922d4c87742d5e71a87fb31", + "size": 297028, + "subdir": "linux-64", + "timestamp": 1534486421561, + "version": "2.2.5" + }, + "libgd-2.3.2-hdd3ff0f_3.tar.bz2": { + "build": "hdd3ff0f_3", + "build_number": 3, + "depends": [ + "expat", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "icu", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GD", + "license_family": "BSD", + "md5": "7bda0da9ac1842ee5d10c7e272eaca61", + "name": "libgd", + "sha256": "3b5b6b293454a26569087af1b1d980c853c5b3a6b95aa56e233ed70162adcf4a", + "size": 282975, + "subdir": "linux-64", + "timestamp": 1621419196671, + "version": "2.3.2" + }, + "libgd-2.3.3-h695aa2c_0.tar.bz2": { + "build": "h695aa2c_0", + "build_number": 0, + "depends": [ + "expat", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "icu", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base" + ], + "license": "GD", + "license_family": "BSD", + "md5": "e63c24f0fc9ca28d96306f17653f5c30", + "name": "libgd", + "sha256": "dc6e77865d3cc35e261a5a252c4cfd27ab95af484434576fbbcc0cd6cbf0c83f", + "size": 311710, + "subdir": "linux-64", + "timestamp": 1639139509275, + "version": "2.3.3" + }, + "libgd-2.3.3-h695aa2c_1.tar.bz2": { + "build": "h695aa2c_1", + "build_number": 1, + "depends": [ + "expat", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "icu", + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base" + ], + "license": "GD", + "license_family": "BSD", + "md5": "e17d73f9dbc6791d2462d0b3ea348c65", + "name": "libgd", + "sha256": "8413eaab9fa329b570d1184af0d03313447408fed8b4d602874dba44756a9b8f", + "size": 305837, + "subdir": "linux-64", + "timestamp": 1655396452872, + "version": "2.3.3" + }, + "libgd-2.3.3-h6a678d5_2.tar.bz2": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "expat >=2.4.9,<3.0a0", + "fontconfig >=2.14.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "icu >=58.0,<59.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libwebp-base >=1.2.4,<2.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GD", + "license_family": "BSD", + "md5": "e07f4cafe3366764b646df9be69aad74", + "name": "libgd", + "sha256": "4ae0b7cd1497833b1e88c89f0eb15a1ba14b93b8f1b83f4f78f769929325939a", + "size": 297306, + "subdir": "linux-64", + "timestamp": 1677001623648, + "version": "2.3.3" + }, + "libgdal-2.2.2-h1c3dc7d_1.tar.bz2": { + "build": "h1c3dc7d_1", + "build_number": 1, + "depends": [ + "curl", + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.4,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jpeg >=9b,<10a", + "json-c >=0.12.1,<0.13.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "libpng >=1.6.32,<1.7.0a0", + "libpq >=9.6.6", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "openjpeg >=2.2.0,<3.0a0", + "poppler >=0.60.1,<1.0a0", + "proj4 >=4.9.3,<4.9.4.0a0", + "sqlite >=3.20.1,<4.0a0", + "xerces-c >=3.2.0,<3.3.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "2d6ad00b148dd980d91ade8cb1175b35", + "name": "libgdal", + "sha256": "ba97068e985803157c29c56212030b037810517f3d3d447495335a04de8ea8a6", + "size": 16753533, + "subdir": "linux-64", + "timestamp": 1511373362469, + "version": "2.2.2" + }, + "libgdal-2.2.2-h2422bbf_1.tar.bz2": { + "build": "h2422bbf_1", + "build_number": 1, + "depends": [ + "curl", + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.4,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jpeg >=9b,<10a", + "json-c >=0.12.1,<0.13.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "libpng >=1.6.32,<1.7.0a0", + "libpq >=9.6.6", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "openjpeg >=2.2.0,<3.0a0", + "poppler >=0.60.1,<1.0a0", + "proj4 >=4.9.3,<4.9.4.0a0", + "sqlite >=3.20.1,<4.0a0", + "xerces-c >=3.2.0,<3.3.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "a9010661dee77f7a4ed170371608c580", + "name": "libgdal", + "sha256": "e8ecd4cfe5fb3562ba7517305e1489cc7707581af4fe15cabde389bdc860ce1f", + "size": 16753563, + "subdir": "linux-64", + "timestamp": 1511373363420, + "version": "2.2.2" + }, + "libgdal-2.2.2-h6bd4d82_1.tar.bz2": { + "build": "h6bd4d82_1", + "build_number": 1, + "depends": [ + "curl", + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.4,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jpeg >=9b,<10a", + "json-c >=0.12.1,<0.13.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "libpng >=1.6.32,<1.7.0a0", + "libpq >=9.6.6", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "openjpeg >=2.2.0,<3.0a0", + "poppler >=0.60.1,<1.0a0", + "proj4 >=4.9.3,<4.9.4.0a0", + "sqlite >=3.20.1,<4.0a0", + "xerces-c >=3.2.0,<3.3.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "73abc9287d3b683f1cf3ea7038d59d70", + "name": "libgdal", + "sha256": "4d29b26f34e6104a1960449e0bf960518637c052a381174bfd13b7a9a3441e7d", + "size": 16929018, + "subdir": "linux-64", + "timestamp": 1511390349717, + "version": "2.2.2" + }, + "libgdal-2.2.2-h804cdde_1.tar.bz2": { + "build": "h804cdde_1", + "build_number": 1, + "depends": [ + "curl", + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.4,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jpeg >=9b,<10a", + "json-c >=0.12.1,<0.13.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "libpng >=1.6.32,<1.7.0a0", + "libpq >=9.6.6", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "openjpeg >=2.2.0,<3.0a0", + "poppler >=0.60.1,<1.0a0", + "proj4 >=4.9.3,<4.9.4.0a0", + "sqlite >=3.20.1,<4.0a0", + "xerces-c >=3.2.0,<3.3.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "62740f85d0e78de6ca09f352632573a3", + "name": "libgdal", + "sha256": "799d08be5989047f3eb5b25e2321b7ca05211f1ea2001fa419aaf3173c6f605c", + "size": 16924328, + "subdir": "linux-64", + "timestamp": 1511390362915, + "version": "2.2.2" + }, + "libgdal-2.2.4-h6f639c0_1.tar.bz2": { + "build": "h6f639c0_1", + "build_number": 1, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.60.0,<8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libpq >=10.3,<11.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.0.2o,<1.0.3a", + "pcre >=8.42,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "sqlite >=3.24.0,<4.0a0", + "xerces-c >=3.2.1,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "50cc3f5e344769fb2e8cff608e39015e", + "name": "libgdal", + "sha256": "4cf996e175729d203392ee8c40dfcd4a45ed01730537bcb2a9f12c1cac9bbb70", + "size": 16853583, + "subdir": "linux-64", + "timestamp": 1530872128937, + "version": "2.2.4" + }, + "libgdal-2.2.4-h864d619_1.tar.bz2": { + "build": "h864d619_1", + "build_number": 1, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.60.0,<8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libpq >=10.3,<11.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "pcre >=8.42,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "proj4 >=4.9.3,<4.9.4.0a0", + "sqlite >=3.23.1,<4.0a0", + "xerces-c >=3.2.1,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "cbe67a7534ca9e8dbfaad55a088f26fe", + "name": "libgdal", + "sha256": "03830317a04429d0a2eba97429c413f746f86079b78b085d34111ef45ebb1252", + "size": 16932605, + "subdir": "linux-64", + "timestamp": 1527912262110, + "version": "2.2.4" + }, + "libgdal-2.2.4-hc8d23f9_1.tar.bz2": { + "build": "hc8d23f9_1", + "build_number": 1, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.60.0,<8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libpq >=10.3,<11.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "pcre >=8.42,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "proj4 >=4.9.3,<4.9.4.0a0", + "sqlite >=3.23.1,<4.0a0", + "xerces-c >=3.2.1,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "9d48795722857c62eda3f88ae80636fe", + "name": "libgdal", + "sha256": "b63c1745e9be6c978179a79ef75aa024cc487ab23581b9f11559b75e81dcc183", + "size": 16934996, + "subdir": "linux-64", + "timestamp": 1527912267707, + "version": "2.2.4" + }, + "libgdal-2.2.4-heea9cce_1.tar.bz2": { + "build": "heea9cce_1", + "build_number": 1, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.60.0,<8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libpq >=10.3,<11.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.0.2o,<1.0.3a", + "pcre >=8.42,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "sqlite >=3.24.0,<4.0a0", + "xerces-c >=3.2.1,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "ebd7187bb6e34060d699421e90de6a89", + "name": "libgdal", + "sha256": "08e7da6d2a913ba3000cfb7cc81a65129eb47adbebc7d11dbd5edf51dd6d4ce1", + "size": 16854645, + "subdir": "linux-64", + "timestamp": 1530871137278, + "version": "2.2.4" + }, + "libgdal-2.3.0-h6f639c0_1.tar.bz2": { + "build": "h6f639c0_1", + "build_number": 1, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.60.0,<8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libpq >=10.3,<11.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.0.2o,<1.0.3a", + "pcre >=8.42,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "sqlite >=3.24.0,<4.0a0", + "xerces-c >=3.2.1,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "d0d5ef4ce1bc1fb271a1da0619f8e317", + "name": "libgdal", + "sha256": "58c40b50ee82ceafe36ca3aa829e58dddb7e4851f45fdfdc8e92508c97cbbc50", + "size": 18399957, + "subdir": "linux-64", + "timestamp": 1530870526950, + "version": "2.3.0" + }, + "libgdal-2.3.0-heea9cce_1.tar.bz2": { + "build": "heea9cce_1", + "build_number": 1, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.60.0,<8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libpq >=10.3,<11.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.0.2o,<1.0.3a", + "pcre >=8.42,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "sqlite >=3.24.0,<4.0a0", + "xerces-c >=3.2.1,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "d6f2059497a42bc170bd088d74a5d24d", + "name": "libgdal", + "sha256": "58607bfa6506d8f4c89d2ca962b6aad6b0dad8ed2e22a33e2ed04e00de08b02d", + "size": 18399348, + "subdir": "linux-64", + "timestamp": 1530869539802, + "version": "2.3.0" + }, + "libgdal-2.3.2-h9d4a965_0.tar.bz2": { + "build": "h9d4a965_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.61.1,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=7.3.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.35,<1.7.0a0", + "libpq >=10.5,<11.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.0.2p,<1.0.3a", + "pcre >=8.42,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "sqlite >=3.25.3,<4.0a0", + "xerces-c >=3.2.2,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "e794980de96811f73df93860f14f4b76", + "name": "libgdal", + "sha256": "0441b94e5a5627326381862ae4562e15835e6615168ac2abb2d8c6a3154bf2cb", + "size": 18620261, + "subdir": "linux-64", + "timestamp": 1544655823241, + "version": "2.3.2" + }, + "libgdal-2.3.2-hda2fc8e_0.tar.bz2": { + "build": "hda2fc8e_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.61.1,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=7.3.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.35,<1.7.0a0", + "libpq >=10.5,<11.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.0.2p,<1.0.3a", + "pcre >=8.42,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "sqlite >=3.25.3,<4.0a0", + "xerces-c >=3.2.2,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "4d622f8912fc8c1a2b78f6129d21cbf0", + "name": "libgdal", + "sha256": "eaafe5ecb2f0321157cc5a437960312713a381305eef0bc545ccf54b498b4374", + "size": 18477219, + "subdir": "linux-64", + "timestamp": 1544661591241, + "version": "2.3.2" + }, + "libgdal-2.3.3-h2e7e64b_0.tar.bz2": { + "build": "h2e7e64b_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.7.1,<3.7.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.63.0,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=7.3.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.35,<1.7.0a0", + "libpq >=11.1,<12.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1a,<1.1.2a", + "pcre >=8.42,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "proj4 >=5.2.0,<5.2.1.0a0", + "sqlite >=3.26.0,<4.0a0", + "xerces-c >=3.2.2,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "8f5f980c235311d7cefd4caf8c2ec3e5", + "name": "libgdal", + "sha256": "4100548d49ca51f590ee092c985bfb219aea9e24e636635699962c4394c8ec25", + "size": 18586248, + "subdir": "linux-64", + "timestamp": 1545408403571, + "version": "2.3.3" + }, + "libgdal-3.0.2-h1d2d1f6_3.tar.bz2": { + "build": "h1d2d1f6_3", + "build_number": 3, + "depends": [ + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.2.10,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.14,<1.5.0a0", + "libcurl >=7.82.0,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=11.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libwebp-base", + "libxml2 >=2.9.14,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1q,<1.1.2a", + "pcre >=8.45,<9.0a0", + "poppler >=0.81.0,<1.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.38.5,<4.0a0", + "tiledb >=2.3.3,<2.4.0a0", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "md5": "94211ad5ed86df5b1adb195a4e07a1f6", + "name": "libgdal", + "sha256": "d1ccec6539e528fb38e2922b4566dae2624a5b36e85cb7682068a2c9341df117", + "size": 20969674, + "subdir": "linux-64", + "timestamp": 1657806613512, + "version": "3.0.2" + }, + "libgdal-3.0.2-h20ab51d_0.tar.bz2": { + "build": "h20ab51d_0", + "build_number": 0, + "depends": [ + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.2.10,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9d,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.14,<1.5.0a0", + "libcurl >=7.80.0,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=7.5.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.12,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1m,<1.1.2a", + "pcre >=8.45,<9.0a0", + "poppler >=0.81.0,<1.0a0", + "postgresql", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.37.0,<4.0a0", + "tiledb >=2.2,<3.0a0", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "md5": "fee6619ae08cb0d24d85f8590f712534", + "name": "libgdal", + "sha256": "fa7fff642791e9e16a29a21dd5dcff5b871a70fc9ec14a2b0999a682ef8ed9d6", + "size": 19633441, + "subdir": "linux-64", + "timestamp": 1642506825271, + "version": "3.0.2" + }, + "libgdal-3.0.2-h27ab9cc_0.tar.bz2": { + "build": "h27ab9cc_0", + "build_number": 0, + "depends": [ + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.2.6,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.5.1,<1.6.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.65.3,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=7.3.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=11.2,<12.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.9,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1d,<1.1.2a", + "pcre >=8.43,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "postgresql", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.30.1,<4.0a0", + "tiledb >=1.6.3,<2.0a0", + "xerces-c >=3.2.2,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "md5": "1fa644aa87aa95e56a44a07946e56381", + "name": "libgdal", + "sha256": "c16f2a46684a40c3a20ead399f948b600e6f1ad845b8627a6f56b7a3878c7035", + "size": 19684255, + "subdir": "linux-64", + "timestamp": 1573574427624, + "version": "3.0.2" + }, + "libgdal-3.0.2-h7c14f60_1.tar.bz2": { + "build": "h7c14f60_1", + "build_number": 1, + "depends": [ + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.2.10,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.6.0,<1.7.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.14,<1.5.0a0", + "libcurl >=7.71.1,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=7.3.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.2,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.10,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1k,<1.1.2a", + "pcre >=8.44,<9.0a0", + "poppler >=0.81.0,<1.0a0", + "postgresql", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.35.4,<4.0a0", + "tiledb >=2.2,<3.0a0", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "md5": "d9afb9e8d518b1d6bb11423d54d30446", + "name": "libgdal", + "sha256": "06be4d62a3e95365a1356b4e66e9dbd368cfdf899a40b15f1edd3be4a62eecd4", + "size": 19567381, + "subdir": "linux-64", + "timestamp": 1622392825455, + "version": "3.0.2" + }, + "libgdal-3.0.2-he6cead7_2.tar.bz2": { + "build": "he6cead7_2", + "build_number": 2, + "depends": [ + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.2.10,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9d,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.14,<1.5.0a0", + "libcurl >=7.80.0,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=7.5.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libwebp-base", + "libxml2 >=2.9.12,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1m,<1.1.2a", + "pcre >=8.45,<9.0a0", + "poppler >=0.81.0,<1.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.37.0,<4.0a0", + "tiledb >=2.2,<3.0a0", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "md5": "deb3f0e7bbb8d7faeb2a8cc37b7d94cd", + "name": "libgdal", + "sha256": "1f3e00689fa84861e32cee9770b34e476f3f2ccc459bb8b4d0d78f9d9150bc8e", + "size": 19859167, + "subdir": "linux-64", + "timestamp": 1643382592086, + "version": "3.0.2" + }, + "libgdal-3.0.2-hf71aff0_5.tar.bz2": { + "build": "hf71aff0_5", + "build_number": 5, + "depends": [ + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "json-c >=0.16,<0.17.0a0", + "kealib >=1.4.14,<1.5.0a0", + "libcurl >=7.86.0,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=11.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.41.5,<2.0a0", + "libwebp-base", + "libxml2 >=2.9.14,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1s,<1.1.2a", + "pcre >=8.45,<9.0a0", + "poppler >=0.81.0,<1.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tiledb >=2.3.3,<2.4.0a0", + "xerces-c >=3.2.4,<3.3.0a0", + "xz >=5.2.8,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a08e7ba4e175bfeb33896c11fe98027", + "name": "libgdal", + "sha256": "db9b61f70e03ede8a3b7903d34714d89344e2f83b35de357ce9ef578d06f7555", + "size": 20869035, + "subdir": "linux-64", + "timestamp": 1673971850418, + "version": "3.0.2" + }, + "libgdal-3.0.2-hf71aff0_6.tar.bz2": { + "build": "hf71aff0_6", + "build_number": 6, + "depends": [ + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "json-c >=0.16,<0.17.0a0", + "kealib >=1.4.14,<1.5.0a0", + "libcurl >=7.86.0,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=11.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.41.5,<2.0a0", + "libwebp-base", + "libxml2 >=2.9.14,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1s,<1.1.2a", + "pcre >=8.45,<9.0a0", + "poppler >=0.81.0,<1.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tiledb >=2.3.3,<2.4.0a0", + "xerces-c >=3.2.4,<3.3.0a0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90a866106e28cecf8ca4c9c018f2c95c", + "name": "libgdal", + "sha256": "9e9c767675658b28eea4519777f225371409a2de2c41143503cc274ec6f1b2b1", + "size": 20864056, + "subdir": "linux-64", + "timestamp": 1673992462294, + "version": "3.0.2" + }, + "libgdal-3.4.1-h05199a0_1.tar.bz2": { + "build": "h05199a0_1", + "build_number": 1, + "depends": [ + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.2.10,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.14,<1.5.0a0", + "libcurl >=7.82.0,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=11.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf 4.8.*", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libwebp-base", + "libxml2 >=2.9.14,<2.10.0a0", + "lz4-c", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1o,<1.1.2a", + "pcre >=8.45,<9.0a0", + "poppler >=0.81.0,<1.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.38.3,<4.0a0", + "tiledb >=2.3.3,<2.4.0a0", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b74acfd3b7ef04ae0583bde3611af24", + "name": "libgdal", + "sha256": "6f272f6d38e8372f997fbf5cd6eb694907221b1986661a95a1d3fab221c575bc", + "size": 31269452, + "subdir": "linux-64", + "timestamp": 1656058258624, + "version": "3.4.1" + }, + "libgdal-3.4.1-hdd9df00_0.tar.bz2": { + "build": "hdd9df00_0", + "build_number": 0, + "depends": [ + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.2.10,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9d,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.14,<1.5.0a0", + "libcurl >=7.80.0,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=7.5.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf 4.8.*", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libwebp-base", + "libxml2 >=2.9.12,<2.10.0a0", + "lz4-c", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1m,<1.1.2a", + "pcre >=8.45,<9.0a0", + "poppler >=0.81.0,<1.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.37.0,<4.0a0", + "tiledb >=2.2,<3.0a0", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd" + ], + "license": "MIT", + "md5": "a5170b8f1de5370c2c08d4bf529cd19b", + "name": "libgdal", + "sha256": "fadcf94b35d0996ddeb81dae9fcc711c2cd7450152d7772712e9b675e64ba3bd", + "size": 28021335, + "subdir": "linux-64", + "timestamp": 1643735898947, + "version": "3.4.1" + }, + "libgdal-3.6.0-hc0e11bb_0.tar.bz2": { + "build": "hc0e11bb_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "json-c >=0.16,<0.17.0a0", + "kealib >=1.5.0,<1.6.0a0", + "lerc >=3.0,<4.0a0", + "libcurl >=7.87.0,<8.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libiconv >=1.16,<2.0a0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.41.5,<2.0a0", + "libwebp-base", + "libxml2 >=2.9.14,<2.10.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre2 >=10.37,<10.38.0a0", + "poppler", + "postgresql", + "proj >=6.2.1,<6.2.2.0a0", + "qhull >=2020.2,<2020.3.0a0", + "sqlite >=3.40.1,<4.0a0", + "tiledb >=2.3.3,<2.4.0a0", + "xerces-c >=3.2.4,<3.3.0a0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "73a6731c450961d191a0bd01412f5f98", + "name": "libgdal", + "sha256": "bee536f983e8ec018fbd4ce1f549dff32cbc38415fa5c963039ad5159389cda5", + "size": 11611532, + "subdir": "linux-64", + "timestamp": 1676727131097, + "version": "3.6.0" + }, + "libgdal-3.6.0-hc0e11bb_1.tar.bz2": { + "build": "hc0e11bb_1", + "build_number": 1, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "json-c >=0.16,<0.17.0a0", + "kealib >=1.5.0,<1.6.0a0", + "lerc >=3.0,<4.0a0", + "libcurl >=7.87.0,<8.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libiconv >=1.16,<2.0a0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.41.5,<2.0a0", + "libwebp-base", + "libxml2 >=2.9.14,<2.10.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre2 >=10.37,<10.38.0a0", + "poppler", + "postgresql", + "proj >=6.2.1,<6.2.2.0a0", + "qhull >=2020.2,<2020.3.0a0", + "sqlite >=3.40.1,<4.0a0", + "tiledb >=2.3.3,<2.4.0a0", + "xerces-c >=3.2.4,<3.3.0a0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c52e141bf9e275014ab5ab9882ba6f2", + "name": "libgdal", + "sha256": "e4a87d57b7a8587e20e3888c66d89bbee1def39cabf53fddfa0f16617e0cdc3c", + "size": 11577600, + "subdir": "linux-64", + "timestamp": 1677574346815, + "version": "3.6.0" + }, + "libgdal-3.6.2-hc0e11bb_0.tar.bz2": { + "build": "hc0e11bb_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "json-c >=0.16,<0.17.0a0", + "kealib >=1.5.0,<1.6.0a0", + "lerc >=3.0,<4.0a0", + "libcurl >=7.87.0,<8.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libiconv >=1.16,<2.0a0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.39,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.41.5,<2.0a0", + "libwebp-base", + "libxml2 >=2.9.14,<2.10.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre2 >=10.37,<10.38.0a0", + "poppler", + "postgresql", + "proj >=6.2.1,<6.2.2.0a0", + "qhull", + "sqlite >=3.40.1,<4.0a0", + "tiledb >=2.3.3,<2.4.0a0", + "xerces-c >=3.2.4,<3.3.0a0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c5401bdf9224264f71f00fd3bde8ee1", + "name": "libgdal", + "sha256": "96fdf5ff777682cd96b56a83fb50f196d919622c4d1dfaf2a2f3b19fa5ca9914", + "size": 11803888, + "subdir": "linux-64", + "timestamp": 1678138645438, + "version": "3.6.2" + }, + "libgdal-3.6.2-hc0e11bb_1.tar.bz2": { + "build": "hc0e11bb_1", + "build_number": 1, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "json-c >=0.16,<0.17.0a0", + "kealib >=1.5.0,<1.6.0a0", + "lerc >=3.0,<4.0a0", + "libcurl >=7.88.1,<8.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libiconv >=1.16,<2.0a0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.39,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.41.5,<2.0a0", + "libwebp-base", + "libxml2 >=2.10.3,<2.11.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre2 >=10.37,<10.38.0a0", + "poppler", + "postgresql", + "proj >=6.2.1,<6.2.2.0a0", + "qhull", + "sqlite >=3.41.1,<4.0a0", + "tiledb >=2.3.3,<2.4.0a0", + "xerces-c >=3.2.4,<3.3.0a0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab8779faf4429d51dd7cffc02c2e14fc", + "name": "libgdal", + "sha256": "c6d2765d1575d23f4e167182bc0348bf73d369b99f5fb36b4e18bc4803cee247", + "size": 11812494, + "subdir": "linux-64", + "timestamp": 1680121032785, + "version": "3.6.2" + }, + "libgfortran-ng-11.2.0-h00389a5_0.tar.bz2": { + "build": "h00389a5_0", + "build_number": 0, + "depends": [ + "libgfortran5 11.2.0.*", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "c5949786d53d6bb249975b98b8e94de6", + "name": "libgfortran-ng", + "sha256": "76e60642a40cde800e87ac7351f2821e6e8dba0bedf28bf5525d0803e7941d6f", + "size": 19789, + "subdir": "linux-64", + "timestamp": 1652859734310, + "version": "11.2.0" + }, + "libgfortran-ng-11.2.0-h00389a5_1.tar.bz2": { + "build": "h00389a5_1", + "build_number": 1, + "depends": [ + "libgfortran5 11.2.0.*", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "27082517590f3b9fbffecc68513b461b", + "name": "libgfortran-ng", + "sha256": "2a24dd54fee86551eb2b03b6ef78433d0cbab3915ed538ecee28af123394137b", + "size": 19860, + "subdir": "linux-64", + "timestamp": 1654090819660, + "version": "11.2.0" + }, + "libgfortran-ng-5.4.0-hdf63c60_3.tar.bz2": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [], + "license": "GPL", + "md5": "ba94cd23abea0f16f1a77900ffe1ba50", + "name": "libgfortran-ng", + "sha256": "80972edce6e577905f003b348891f09e5f3410c5e2e97126eb037674ec3399da", + "size": 980500, + "subdir": "linux-64", + "timestamp": 1520969513418, + "version": "5.4.0" + }, + "libgfortran-ng-7.2.0-h6fcbd8e_1.tar.bz2": { + "build": "h6fcbd8e_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "359e284d84fa9cc5eef1085901e722b2", + "name": "libgfortran-ng", + "sha256": "9092a8f8ee277ce75778eefbf0decb946f2f50f13df5be20abf655f749431838", + "size": 357639, + "subdir": "linux-64", + "timestamp": 1505665568036, + "version": "7.2.0" + }, + "libgfortran-ng-7.2.0-h9f7466a_2.tar.bz2": { + "build": "h9f7466a_2", + "build_number": 2, + "depends": [], + "license": "GPL", + "md5": "f5ae707dd1843643224d5946e901a960", + "name": "libgfortran-ng", + "sha256": "e5549ff42f3c3c315b756552c51e32d555296a24f2a79e0ee71500116d6b108b", + "size": 357812, + "subdir": "linux-64", + "timestamp": 1507262726991, + "version": "7.2.0" + }, + "libgfortran-ng-7.2.0-hdf63c60_3.tar.bz2": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [], + "license": "GPL", + "md5": "249575a07286c1500173c6afb0567825", + "name": "libgfortran-ng", + "sha256": "01590119aac9fa090eef9a5d2d0f21743fffa7bfaffe1db892b831641eff9bbc", + "size": 1300780, + "subdir": "linux-64", + "timestamp": 1520534517851, + "version": "7.2.0" + }, + "libgfortran-ng-7.3.0-hdf63c60_0.tar.bz2": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [], + "license": "GPL", + "md5": "6003e09e8cef9aca91b954abfdd0f39c", + "name": "libgfortran-ng", + "sha256": "83c6fdb30a240fbaa09f5d2e2ae8f092759cb710bc3fa628ccb18934fc237b7f", + "size": 1336385, + "subdir": "linux-64", + "timestamp": 1534628456385, + "version": "7.3.0" + }, + "libgfortran-ng-7.5.0-ha8ba4b0_17.tar.bz2": { + "build": "ha8ba4b0_17", + "build_number": 17, + "depends": [ + "libgfortran4 7.5.0.*", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "526a52415a29fc6df26612f2d42b162f", + "name": "libgfortran-ng", + "sha256": "baf06cda3054e2a1eb67b2dfb28fb11b6245f6c1625f369a7629dfcee622e96f", + "size": 22250, + "subdir": "linux-64", + "timestamp": 1622660084422, + "version": "7.5.0" + }, + "libgfortran-ng-8.2.0-hdf63c60_0.tar.bz2": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [], + "license": "GPL", + "md5": "4fe591831908f2d454fb003f2201d546", + "name": "libgfortran-ng", + "sha256": "e1ce9862472d409fac65e396f3615cacad753d7c4970d5c4173a0dd894eda9cc", + "size": 1844697, + "subdir": "linux-64", + "timestamp": 1534277508708, + "version": "8.2.0" + }, + "libgfortran-ng-8.2.0-hdf63c60_1.tar.bz2": { + "build": "hdf63c60_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "01fe37923779d22d1034b2cbd1d50bdd", + "name": "libgfortran-ng", + "sha256": "a8601d00368c4fe633397e5580208896f659107879ed9230bd6b30f395d69514", + "size": 1842939, + "subdir": "linux-64", + "timestamp": 1534516119090, + "version": "8.2.0" + }, + "libgfortran-ng-8.4.0-he6ba991_17.tar.bz2": { + "build": "he6ba991_17", + "build_number": 17, + "depends": [ + "libgfortran5 8.4.0.*", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "dedce0103828ebcc479ce1b80f6404cf", + "name": "libgfortran-ng", + "sha256": "b8cec01ebc8212cd827647acc0461c1fa71041ed5e55853e5da759d30e434b8e", + "size": 22268, + "subdir": "linux-64", + "timestamp": 1622661689809, + "version": "8.4.0" + }, + "libgfortran-ng-9.3.0-ha5ec8a7_17.tar.bz2": { + "build": "ha5ec8a7_17", + "build_number": 17, + "depends": [ + "libgfortran5 9.3.0.*", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "7cf9711f0474ff216fe8deb9ebe061e1", + "name": "libgfortran-ng", + "sha256": "ec57e194d98ee57c161e54056e323e5d8e2070749b11d64d2eec34c4700dc772", + "size": 22258, + "subdir": "linux-64", + "timestamp": 1622663339018, + "version": "9.3.0" + }, + "libgfortran4-7.5.0-ha8ba4b0_17.tar.bz2": { + "build": "ha8ba4b0_17", + "build_number": 17, + "constrains": [ + "libgfortran-ng 7.5.0 *_17" + ], + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "ee92f85ca6a790b738daa5e143f1ae5a", + "name": "libgfortran4", + "sha256": "e9b16e87276a8e1707c1d858ef0318eef0ce2222b1fc16529bf8a1d40de06aeb", + "size": 1313206, + "subdir": "linux-64", + "timestamp": 1622660038350, + "version": "7.5.0" + }, + "libgfortran5-11.2.0-h1234567_0.tar.bz2": { + "build": "h1234567_0", + "build_number": 0, + "constrains": [ + "libgfortran-ng 11.2.0 *_0" + ], + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "34019aeb514b4c85eb7a04759a350120", + "name": "libgfortran5", + "sha256": "3ea6056d400c371711602566bb72cb1e281da5d3886b661c7043b992afa14342", + "size": 5222770, + "subdir": "linux-64", + "timestamp": 1652859678573, + "version": "11.2.0" + }, + "libgfortran5-11.2.0-h1234567_1.tar.bz2": { + "build": "h1234567_1", + "build_number": 1, + "constrains": [ + "libgfortran-ng 11.2.0 *_1" + ], + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "0202c3c8ae4735cac6c7f3d1e1685964", + "name": "libgfortran5", + "sha256": "b170f2d1dc4c33c525261b2b61f9efffb6eb3dbb0a3e9966dd4c5ed0b33069f2", + "size": 5228750, + "subdir": "linux-64", + "timestamp": 1654090762569, + "version": "11.2.0" + }, + "libgfortran5-8.4.0-he6ba991_17.tar.bz2": { + "build": "he6ba991_17", + "build_number": 17, + "constrains": [ + "libgfortran-ng 8.4.0 *_17" + ], + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "9bfa4c3380acdea7b8a9a246ac907e82", + "name": "libgfortran5", + "sha256": "8ab546f06ba232715964239b7f565b626d87780a5a54c96e7774ff8857503818", + "size": 1869839, + "subdir": "linux-64", + "timestamp": 1622661646530, + "version": "8.4.0" + }, + "libgfortran5-9.3.0-ha5ec8a7_17.tar.bz2": { + "build": "ha5ec8a7_17", + "build_number": 17, + "constrains": [ + "libgfortran-ng 9.3.0 *_17" + ], + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "07c23f865bef92e42d5e0c4dffa61349", + "name": "libgfortran5", + "sha256": "22cadb64c2a0428091e8e07632724f15172b559092d0ebd8387aaf9d993ac2c9", + "size": 2055363, + "subdir": "linux-64", + "timestamp": 1622663293084, + "version": "9.3.0" + }, + "libgit2-1.5.0-ha637b67_0.tar.bz2": { + "build": "ha637b67_0", + "build_number": 0, + "depends": [ + "curl", + "libgcc-ng >=11.2.0", + "libssh2 >=1.10.0,<2.0a0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1q,<1.1.2a", + "pcre2 >=10.37,<10.38.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-only WITH GCC-exception-2.0", + "license_family": "GPL2", + "md5": "11ff9d6d84351410e7b81bfb955c6253", + "name": "libgit2", + "sha256": "edc66ba2c8de8e5a23f5473a39978d339b69f832b155c4396a2c5fdd04db8270", + "size": 1157954, + "subdir": "linux-64", + "timestamp": 1667503279109, + "version": "1.5.0" + }, + "libglu-9.0.0-h0c0bdc1_1.tar.bz2": { + "build": "h0c0bdc1_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "SGI-2", + "md5": "11837086ab553dd9166c9dee2054b06f", + "name": "libglu", + "sha256": "cd54fb3445c21f18a712248b092f6f44c8336abef925a06109c30df97f673bc8", + "size": 462690, + "subdir": "linux-64", + "timestamp": 1507908736126, + "version": "9.0.0" + }, + "libglu-9.0.0-hf484d3e_1.tar.bz2": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "SGI-2", + "md5": "bfe192f11bd63baaed691ca9638920cb", + "name": "libglu", + "sha256": "a230ded00e24da7c6f8a7e3f25fc9ac59fad1b5104857a45bee85fa0b73c20f3", + "size": 386407, + "subdir": "linux-64", + "timestamp": 1530807703852, + "version": "9.0.0" + }, + "libgomp-11.2.0-h1234567_0.tar.bz2": { + "build": "h1234567_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "7689dbd0e55de9656c4eac451fadcb60", + "name": "libgomp", + "sha256": "e122a22321cc9eb584fe626e2cc601a5da4a63c901aa8cfba69cfd6a65262c04", + "size": 573369, + "subdir": "linux-64", + "timestamp": 1652859691785, + "version": "11.2.0" + }, + "libgomp-11.2.0-h1234567_1.tar.bz2": { + "build": "h1234567_1", + "build_number": 1, + "depends": [ + "_libgcc_mutex 0.1 main" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "3080c2813e6e1d0f8a100a38b5b3456d", + "name": "libgomp", + "sha256": "118665c3af6392704fe608da9b98dbf815304537bb80ae99fb9fd59fc81f8b8e", + "size": 573231, + "subdir": "linux-64", + "timestamp": 1654090775721, + "version": "11.2.0" + }, + "libgomp-7.5.0-h5101ec6_17.tar.bz2": { + "build": "h5101ec6_17", + "build_number": 17, + "depends": [ + "_libgcc_mutex 0.1 main" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "3237dfa8e2e0b9117a9c98a91be0444d", + "name": "libgomp", + "sha256": "e40a6710c3afcaef8771aadd4b5476432fae46399e0046a663650462b9a242a8", + "size": 298313, + "subdir": "linux-64", + "timestamp": 1622660050908, + "version": "7.5.0" + }, + "libgomp-8.4.0-h5101ec6_17.tar.bz2": { + "build": "h5101ec6_17", + "build_number": 17, + "depends": [ + "_libgcc_mutex 0.1 main" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "18a7c0266b9ebafc706dbb581bd810e7", + "name": "libgomp", + "sha256": "eb95944a4dcbea9fdad8782646e75740f709b846418cb9c95366a400f12eb544", + "size": 336984, + "subdir": "linux-64", + "timestamp": 1622661660057, + "version": "8.4.0" + }, + "libgomp-9.3.0-h5101ec6_17.tar.bz2": { + "build": "h5101ec6_17", + "build_number": 17, + "depends": [ + "_libgcc_mutex 0.1 main" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "cb456a1e627168ffbbfbf417002454ea", + "name": "libgomp", + "sha256": "fd8540c16e79afdead8c6dcfb4e7401294f4185522f41deb4dc12f27fb58b3a8", + "size": 386800, + "subdir": "linux-64", + "timestamp": 1622663306647, + "version": "9.3.0" + }, + "libgpg-error-1.27-h14c3975_2.tar.bz2": { + "build": "h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "c47311c66634c8c412689685ee9af27a", + "name": "libgpg-error", + "sha256": "4feecc0dabf96d5d388c4e11285f80b4c6793830ccc90468e6c89611b8bbd4a9", + "size": 196522, + "subdir": "linux-64", + "timestamp": 1515696704892, + "version": "1.27" + }, + "libgpg-error-1.29-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "ac7132d7dbe37035c48df31b2172531a", + "name": "libgpg-error", + "sha256": "3b3f68d0dff6164a0f751cac45aed73e969823b231fb42b41e0a09d5985c5afb", + "size": 245548, + "subdir": "linux-64", + "timestamp": 1523953940896, + "version": "1.29" + }, + "libgpg-error-1.31-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "1bc105be4963d657bda2987fbc38bddc", + "name": "libgpg-error", + "sha256": "1cac9b54bf8ba0ce7861eca6e5b4dffc2d72ae53400bb4be27e77497bb764973", + "size": 251419, + "subdir": "linux-64", + "timestamp": 1527179944603, + "version": "1.31" + }, + "libgpg-error-1.32-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "9cd74d47aabf081a7ff2fc97d8b67dca", + "name": "libgpg-error", + "sha256": "e8e05dd91192ab1912f6f1abbd7d08577de2d3b3ec2bde7059e7fcec80b80364", + "size": 253736, + "subdir": "linux-64", + "timestamp": 1532875867442, + "version": "1.32" + }, + "libgpg-error-1.39-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "4e4d28f36ce78b3453a3ab06d5eb0ddf", + "name": "libgpg-error", + "sha256": "acc1f5506d20ca87cb07afa46fae0a0847716846e97ec103469864f98ef3bcd9", + "size": 274822, + "subdir": "linux-64", + "timestamp": 1601491507911, + "version": "1.39" + }, + "libgpg-error-1.41-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "6a3e343b011ef6b33843f431fbc82f96", + "name": "libgpg-error", + "sha256": "0ef0ad2d98bff2422d50de3b96c22d8a4453f5abec1be1291ac99d6f2b395309", + "size": 272983, + "subdir": "linux-64", + "timestamp": 1608576978124, + "version": "1.41" + }, + "libgpg-error-1.42-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "94c0a4a51aa580ef7df863860ebeb431", + "name": "libgpg-error", + "sha256": "7e94da0d7168fc8285f896088747ac1420f92d28f4a95b07b3c009a72dfd18f1", + "size": 280771, + "subdir": "linux-64", + "timestamp": 1616440454143, + "version": "1.42" + }, + "libgpuarray-0.7.5-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "ISC", + "md5": "6af821a45b6637a17895de7aaded6782", + "name": "libgpuarray", + "sha256": "37ff69e94372f41bdc7908ca46401032258bfe41c84a556192fcc4e72cacc1ca", + "size": 268539, + "subdir": "linux-64", + "timestamp": 1515100476747, + "version": "0.7.5" + }, + "libgpuarray-0.7.6-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "ISC", + "md5": "28cd45b5e86ba1ef756b0ce8b958261d", + "name": "libgpuarray", + "sha256": "67ddad5f9fba21d47ca45693e46fb65724eec2bb28f9bcf9c6af900d0aa8e002", + "size": 269961, + "subdir": "linux-64", + "timestamp": 1526494991655, + "version": "0.7.6" + }, + "libgpuarray-0.7.6-h7f8727e_1.tar.bz2": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "ISC", + "md5": "a311553c92f35f6df87be1a624652a42", + "name": "libgpuarray", + "sha256": "336cad4c0644310bba3144e0ee55780f331929dd6517ba86c7872c79e8ff18dd", + "size": 267647, + "subdir": "linux-64", + "timestamp": 1642510472908, + "version": "0.7.6" + }, + "libgsasl-1.10.0-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "libgcrypt >=1.9.3,<2.0a0", + "libgpg-error >=1.42,<2.0a0", + "libntlm >=1.6,<2.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "e10e3183902e817e93e28aacb63b390b", + "name": "libgsasl", + "sha256": "28a4d64d10c9ab1b55eb05cc9b29cdf3b958b85aaa28f204393dfa000d7d10e2", + "size": 179010, + "subdir": "linux-64", + "timestamp": 1642672232315, + "version": "1.10.0" + }, + "libgsasl-1.8.0-h14c3975_3.tar.bz2": { + "build": "h14c3975_3", + "build_number": 3, + "depends": [ + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "libgcrypt >=1.8.0,<2.0a0", + "libntlm >=1.4,<2.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "1cc7d469ddd97b731d5548cb3eaabe1b", + "name": "libgsasl", + "sha256": "5113e6243826e39de0b3bb3c0fe007c85a13625df8f5fb2c4a664acd67cffacd", + "size": 135510, + "subdir": "linux-64", + "timestamp": 1515696923573, + "version": "1.8.0" + }, + "libgsasl-1.8.0-h7b6447c_3.tar.bz2": { + "build": "h7b6447c_3", + "build_number": 3, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libgcrypt >=1.8.3,<2.0a0", + "libntlm >=1.4,<2.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "115859a4e4ac9b0231c047e08e27b004", + "name": "libgsasl", + "sha256": "d243dcfacb6ca0d9ebc595c382a06f60272c800e63620573e7801a1853c469e2", + "size": 138858, + "subdir": "linux-64", + "timestamp": 1540967010187, + "version": "1.8.0" + }, + "libgsf-1.14.50-h622765d_1.tar.bz2": { + "build": "h622765d_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "pcre >=8.45,<9.0a0", + "zlib >=1.2.13,<1.2.14", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-only", + "license_family": "GPL", + "md5": "93ed0f66b4d4e81feb9834df0dd9383b", + "name": "libgsf", + "sha256": "f959565467b376f26dffe5deca593c8ed2f9f2efd86ab5a032d5bc847f259324", + "size": 473982, + "subdir": "linux-64", + "timestamp": 1679988293565, + "version": "1.14.50" + }, + "libgsf-1.14.50-hc037cb4_0.tar.bz2": { + "build": "hc037cb4_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "pcre >=8.45,<9.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-only", + "license_family": "GPL", + "md5": "e28f4ebcf9cf62a87bb223b0824fb4d2", + "name": "libgsf", + "sha256": "dffd061487bba8a434f24b12ddf6afecb30c71b499a6612e68ac12d78a933023", + "size": 472014, + "subdir": "linux-64", + "timestamp": 1667992205668, + "version": "1.14.50" + }, + "libhdfs3-2.2.31-hfff6f95_2.tar.bz2": { + "build": "hfff6f95_2", + "build_number": 2, + "depends": [ + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "libgsasl >=1.8.0,<2.0a0", + "libntlm >=1.4,<2.0a0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.4,<2.10.0a0" + ], + "license": "Apache 2.0", + "md5": "9b8db90f98598f811d42598ef3a6e677", + "name": "libhdfs3", + "sha256": "c8c244c88f97047e63c3b1f41fedf6a54d7d5495c2f6f8d0056930e7afd3ecca", + "size": 7571467, + "subdir": "linux-64", + "timestamp": 1515697141057, + "version": "2.2.31" + }, + "libhdfs3-2.3.0-h1a0844a_3.tar.bz2": { + "build": "h1a0844a_3", + "build_number": 3, + "depends": [ + "krb5 >=1.16.4,<1.17.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libcurl >=7.67.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libgsasl >=1.8.0,<2.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.12,<2.10.0a0", + "openssl >=1.1.1o,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "153883d24bd1898341c7d7e631d778f6", + "name": "libhdfs3", + "sha256": "17124c07f465712740da90d242be4635d042e329ca279d61fd46576769d96ddd", + "size": 10273928, + "subdir": "linux-64", + "timestamp": 1652943196633, + "version": "2.3.0" + }, + "libhdfs3-2.3.0-h2fca0e8_1.tar.bz2": { + "build": "h2fca0e8_1", + "build_number": 1, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libcurl >=7.61.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libgsasl >=1.8.0,<2.0a0", + "libntlm >=1.4,<2.0a0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "Apache 2.0", + "md5": "4ccf208a414dee181e0898dcc5f7f020", + "name": "libhdfs3", + "sha256": "1daead010cfc847efa0f6ebef15a1a8a927a0ace7ce940ff170fe4c08f9b69e8", + "size": 9518612, + "subdir": "linux-64", + "timestamp": 1540968914523, + "version": "2.3.0" + }, + "libhdfs3-2.3.0-h6233a4a_4.tar.bz2": { + "build": "h6233a4a_4", + "build_number": 4, + "depends": [ + "krb5 >=1.16.4,<1.17.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libcurl >=7.67.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libgsasl >=1.8.0,<2.0a0", + "libntlm >=1.6,<2.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "libxml2 >=2.10.3,<2.11.0a0", + "openssl >=1.1.1t,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1f1e57d7e7ee95867735e6cb0d3a7168", + "name": "libhdfs3", + "sha256": "29d665a8c9c9500069833b4be53fcbeea5ca7a76cecc23790ceb738b64d5fd92", + "size": 11349294, + "subdir": "linux-64", + "timestamp": 1679578395694, + "version": "2.3.0" + }, + "libhdfs3-2.3.0-h97226ba_1.tar.bz2": { + "build": "h97226ba_1", + "build_number": 1, + "depends": [ + "curl >=7.55.1,<8.0a0", + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "libgsasl >=1.8.0,<2.0a0", + "libntlm >=1.4,<2.0a0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.4,<2.10.0a0", + "openssl >=1.0.2n,<1.0.3a" + ], + "license": "Apache 2.0", + "md5": "8f10077a8b290360c469a746c4471845", + "name": "libhdfs3", + "sha256": "72edd691db3dbd9b61b0108fba0241640a29fbf6ecb2bfdc16ff74d846255c2e", + "size": 8856342, + "subdir": "linux-64", + "timestamp": 1515710070367, + "version": "2.3.0" + }, + "libhdfs3-2.3.0-hcdb25c3_2.tar.bz2": { + "build": "hcdb25c3_2", + "build_number": 2, + "depends": [ + "krb5 >=1.16.4,<1.17.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libcurl >=7.67.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libgsasl >=1.8.0,<2.0a0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.5.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.12,<2.10.0a0", + "openssl >=1.1.1l,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e992415b94c76ec51d343cf1a1006fb4", + "name": "libhdfs3", + "sha256": "62c37ea80ba47d7569d586a26632e69eef7d56b05f8f4744046ad324d9af721f", + "size": 10427103, + "subdir": "linux-64", + "timestamp": 1641390579146, + "version": "2.3.0" + }, + "libhdfs3-2.3.0-hd191362_1.tar.bz2": { + "build": "hd191362_1", + "build_number": 1, + "depends": [ + "krb5 >=1.14.2,<1.15.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "libgsasl >=1.8.0,<2.0a0", + "libntlm >=1.4,<2.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openssl >=1.0.2o,<1.0.3a" + ], + "license": "Apache 2.0", + "md5": "aa4ac40fc7f5e1e346b48eb152e32a3a", + "name": "libhdfs3", + "sha256": "891033557d571e76ebcf268f5b17f5ac83a388156824feab359443db9583f8a5", + "size": 8876003, + "subdir": "linux-64", + "timestamp": 1530914264111, + "version": "2.3.0" + }, + "libiconv-1.15-h63c8f33_5.tar.bz2": { + "build": "h63c8f33_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL and LGPL", + "md5": "34e84d0e575edbdc3c8b123d1130d6f5", + "name": "libiconv", + "sha256": "333ea2cc7589fb4dd49627c73fc0fd410adadb60485d6869c83ae7221733e817", + "size": 2103011, + "subdir": "linux-64", + "timestamp": 1505745162898, + "version": "1.15" + }, + "libiconv-1.16-h7f8727e_2.tar.bz2": { + "build": "h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL3", + "md5": "a8345526ee5452b2c8de4c5ac5b1c05f", + "name": "libiconv", + "sha256": "0eaee595266540cf3c81fb96e99fdca0e3ea2d20f2cb72a9f148b92e92b2f1a0", + "size": 1454956, + "subdir": "linux-64", + "timestamp": 1650983457202, + "version": "1.16" + }, + "libidn11-1.33-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "LGPLv3", + "license_family": "GPL", + "md5": "7c24a61a8e9a2c92aa1b9311f64e720b", + "name": "libidn11", + "sha256": "d0cca4e8f4f297210f917a2649d39b015606ee4f43646d1edc55a9ae9755c411", + "size": 225531, + "subdir": "linux-64", + "timestamp": 1576614314267, + "version": "1.33" + }, + "libidn2-2.3.0-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libunistring >=0,<1.0a0" + ], + "license": "LGPLv2", + "md5": "eab1f39d0ca7774c7d23d1b939b43271", + "name": "libidn2", + "sha256": "e674a6573ee4928fcb710d48e58aa8f32e00086edd3dc2c1456ca4d95de68c02", + "size": 102844, + "subdir": "linux-64", + "timestamp": 1617768421518, + "version": "2.3.0" + }, + "libidn2-2.3.1-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libunistring >=0,<1.0a0" + ], + "license": "LGPLv2 AND LGPL-3.0-or-later AND GPL-3.0-or-later", + "md5": "298c77b5e1d234bcc3c744c00c610ab5", + "name": "libidn2", + "sha256": "81307181e7d19b3a5ca6d6e0f86135ace05c4ac168334146180ee8bb4301e599", + "size": 100340, + "subdir": "linux-64", + "timestamp": 1621322982007, + "version": "2.3.1" + }, + "libidn2-2.3.2-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libunistring >=0,<1.0a0" + ], + "license": "LGPLv2 AND LGPL-3.0-or-later AND GPL-3.0-or-later", + "md5": "f856a968543e8d862a89e5aabe44419d", + "name": "libidn2", + "sha256": "a325a9ae13d8f4858730420656fdee77dbd700b932baad22587bb3e237d23b99", + "size": 97333, + "subdir": "linux-64", + "timestamp": 1626872281578, + "version": "2.3.2" + }, + "libkml-1.3.0-h096b73e_6.tar.bz2": { + "build": "h096b73e_6", + "build_number": 6, + "depends": [ + "expat >=2.4.9,<3.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "73f4be19a9e958982d041cddaeb29b90", + "name": "libkml", + "sha256": "948bbc31677dbbaa9992b11ebb147839a4ac93e23145c8eee7974bdec77b20d2", + "size": 618454, + "subdir": "linux-64", + "timestamp": 1674197618983, + "version": "1.3.0" + }, + "libkml-1.3.0-h590aaf7_3.tar.bz2": { + "build": "h590aaf7_3", + "build_number": 3, + "depends": [ + "expat >=2.2.5,<3.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f53ac7e0411370675f2ce455127faff4", + "name": "libkml", + "sha256": "e7106c3f04569c8581361bd0884ff325a5b8e2214c69262fa89615fbe7ac63ee", + "size": 647871, + "subdir": "linux-64", + "timestamp": 1530868696494, + "version": "1.3.0" + }, + "libkml-1.3.0-h590aaf7_4.tar.bz2": { + "build": "h590aaf7_4", + "build_number": 4, + "depends": [ + "expat >=2.2.5,<3.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3fe7919918ac4a8577ee65e735d865f3", + "name": "libkml", + "sha256": "c252fbff639e3ad0bf24e998edc18b92889e4224d6dd96fe9c77c379a297e5b3", + "size": 648099, + "subdir": "linux-64", + "timestamp": 1530874561085, + "version": "1.3.0" + }, + "libkml-1.3.0-h7ecb851_5.tar.bz2": { + "build": "h7ecb851_5", + "build_number": 5, + "depends": [ + "expat >=2.2.10,<3.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3c2d1e438121487642301abd252f7f6b", + "name": "libkml", + "sha256": "84ba7a094c39081a1a2d7226480fc20f80ec9535fdd4af499a80fac25af48b9d", + "size": 661183, + "subdir": "linux-64", + "timestamp": 1622296726318, + "version": "1.3.0" + }, + "libkml-1.3.0-h8777076_2.tar.bz2": { + "build": "h8777076_2", + "build_number": 2, + "depends": [ + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9be7c02ff1ae35786cbc00cc8ac72896", + "name": "libkml", + "sha256": "0ba573a3492e44ee5fcbb68c3a1dd9c0569b64dfd2c420afa5ffcfb32e18fb39", + "size": 648480, + "subdir": "linux-64", + "timestamp": 1509502887176, + "version": "1.3.0" + }, + "libkml-1.3.0-h9d32c78_3.tar.bz2": { + "build": "h9d32c78_3", + "build_number": 3, + "depends": [ + "expat >=2.2.5,<3.0a0", + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8de71b11ed779c9bef00886f52e72aad", + "name": "libkml", + "sha256": "11c791f5f0d5b413a4cafaf7b793ec40c1a7af8e724e12bad0cae34d6992c503", + "size": 648526, + "subdir": "linux-64", + "timestamp": 1510863086949, + "version": "1.3.0" + }, + "liblief-0.10.1-h2531618_1.tar.bz2": { + "build": "h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a56b03f4e4aa481ef66353fe6379c9be", + "name": "liblief", + "sha256": "9cc220b353c1cb26654dffae8457629afeba3273d8ee8d208f01e9ec616a95c7", + "size": 2124868, + "subdir": "linux-64", + "timestamp": 1607401876049, + "version": "0.10.1" + }, + "liblief-0.10.1-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7278b91ba1f6c3aaedbc56ea509af34d", + "name": "liblief", + "sha256": "4a868e804598fc2e083d879c34326b2312ab9d39c1b832ab835e33cd2df04074", + "size": 2109806, + "subdir": "linux-64", + "timestamp": 1588593780971, + "version": "0.10.1" + }, + "liblief-0.11.5-h295c915_1.tar.bz2": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "361d58e367bb56e6755e93897ee6147f", + "name": "liblief", + "sha256": "bc2ff324a0a2ea889423cd7c50ff58412d146595087e35bda10eba6b12ef664d", + "size": 2190943, + "subdir": "linux-64", + "timestamp": 1648523621267, + "version": "0.11.5" + }, + "liblief-0.12.3-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "20a996c998529f62d01b29cd26fa7c23", + "name": "liblief", + "sha256": "8dc3782002dca8d7a95677b7337e3385f1a57d6d51b4cba2c694fbff48fec348", + "size": 2205685, + "subdir": "linux-64", + "timestamp": 1670876577307, + "version": "0.12.3" + }, + "liblief-0.8.3-h1532aa0_0.tar.bz2": { + "build": "h1532aa0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "62d8a5915035ed84e7bdb9f951e7f178", + "name": "liblief", + "sha256": "a6b1fc4f7f38435c2a6d4573a8d748f2e0f2357a12c86416b284c515a3ba87c6", + "size": 3438674, + "subdir": "linux-64", + "timestamp": 1528206739722, + "version": "0.8.3" + }, + "liblief-0.9.0-h1532aa0_0.tar.bz2": { + "build": "h1532aa0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8f5ebd271a6b1490351cdc05fbccef5c", + "name": "liblief", + "sha256": "ef7ef9359c4a2cdcf74cf35dcf4ae159f101f5041f043b416365f0876b7e943b", + "size": 4507867, + "subdir": "linux-64", + "timestamp": 1528675660467, + "version": "0.9.0" + }, + "liblief-0.9.0-h7725739_1.tar.bz2": { + "build": "h7725739_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fbc9a90a3c76b47de45ba13b4d48297e", + "name": "liblief", + "sha256": "88c053e7e97f81c985af9067fad46e461747ea5eb22ba9e5e2b4e6c9439e1494", + "size": 4723380, + "subdir": "linux-64", + "timestamp": 1541028761721, + "version": "0.9.0" + }, + "liblief-0.9.0-h7725739_2.tar.bz2": { + "build": "h7725739_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dfc5a92590577d1afb150be6e66e6732", + "name": "liblief", + "sha256": "c2a453cc958c01ec500592a8cb376c7e32bd21cd5a4fa0715a05ccc1b0312292", + "size": 4565541, + "subdir": "linux-64", + "timestamp": 1547591875929, + "version": "0.9.0" + }, + "libllvm10-10.0.0-h4a3c616_1.tar.bz2": { + "build": "h4a3c616_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "57655335baf2cf94a20f767d2bd64cef", + "name": "libllvm10", + "sha256": "00fb72e475745c868884c0778818dfff7f28e34df88705f7413e6e705fd2ff58", + "size": 27691819, + "subdir": "linux-64", + "timestamp": 1594485727493, + "version": "10.0.0" + }, + "libllvm10-10.0.1-hbcb73fb_5.tar.bz2": { + "build": "hbcb73fb_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "018341009ad2153562af92ebf6f7752a", + "name": "libllvm10", + "sha256": "b10864d65909dda6e625106502331005d7ee5ec7604d72917034b76241a44837", + "size": 27747496, + "subdir": "linux-64", + "timestamp": 1599257442808, + "version": "10.0.1" + }, + "libllvm11-11.0.0-h3826bc1_0.tar.bz2": { + "build": "h3826bc1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "fd5f488fc184fe27cf492addc91a770d", + "name": "libllvm11", + "sha256": "ba0fdc4c106ac71aec38b07656efb806822918c56197675695b1580cf836d68b", + "size": 29813060, + "subdir": "linux-64", + "timestamp": 1626720887434, + "version": "11.0.0" + }, + "libllvm11-11.0.0-h3826bc1_1.tar.bz2": { + "build": "h3826bc1_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "6daa3aad932f5a099829b61c07368e0a", + "name": "libllvm11", + "sha256": "1106ab3350c5fc6181019728ba7a575667135731590d309fed26dc32163f54f8", + "size": 29802574, + "subdir": "linux-64", + "timestamp": 1646054256176, + "version": "11.0.0" + }, + "libllvm11-11.1.0-h3826bc1_0.tar.bz2": { + "build": "h3826bc1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "418f3d701f43dd02505005c6d1706d98", + "name": "libllvm11", + "sha256": "8fcc3fc1603745475fff88fa0a2221733b529b991a272ef863bb5778070ad791", + "size": 29820871, + "subdir": "linux-64", + "timestamp": 1624906818854, + "version": "11.1.0" + }, + "libllvm11-11.1.0-h3826bc1_1.tar.bz2": { + "build": "h3826bc1_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "c261302f1b58f6b2851f856d230dc947", + "name": "libllvm11", + "sha256": "effad2034f13cf7f1cdc51127e3a88123ae957c13f8c95f1817dfd79b5eba779", + "size": 29798461, + "subdir": "linux-64", + "timestamp": 1647523885063, + "version": "11.1.0" + }, + "libllvm11-11.1.0-h9e868ea_5.tar.bz2": { + "build": "h9e868ea_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "12707b0bf5a1096840b088925de5e27d", + "name": "libllvm11", + "sha256": "e5fadd9fced996578c1ea596a445e77ffcb533496128066db8504f0660792b99", + "size": 30360492, + "subdir": "linux-64", + "timestamp": 1662598008362, + "version": "11.1.0" + }, + "libllvm11-11.1.0-h9e868ea_6.tar.bz2": { + "build": "h9e868ea_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "c2b4c6491de2bf531083a51092ecd077", + "name": "libllvm11", + "sha256": "0fd833e8a519f75e2c4b6cdbec75b8fffc1cd015b2b795d1566855e486705736", + "size": 30349190, + "subdir": "linux-64", + "timestamp": 1665079289108, + "version": "11.1.0" + }, + "libllvm14-14.0.6-h9e868ea_1.tar.bz2": { + "build": "h9e868ea_1", + "build_number": 1, + "depends": [ + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "b6fcd5bd9bbcfd00fe4df8886af1d1da", + "name": "libllvm14", + "sha256": "e1203e9288436917e53d2e1f13ffa02e8e32ce846d0ff06ebc87bc9714370099", + "size": 37181852, + "subdir": "linux-64", + "timestamp": 1669293197994, + "version": "14.0.6" + }, + "libllvm14-14.0.6-hef93074_0.tar.bz2": { + "build": "hef93074_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "ddfa4e1272dbedbf9d9659d7e73b9c3b", + "name": "libllvm14", + "sha256": "dc616297f32f5a4a6a819919a96c2a79453f538b4005e23ccda35726014a099b", + "size": 37114996, + "subdir": "linux-64", + "timestamp": 1661449591289, + "version": "14.0.6" + }, + "libllvm9-9.0.1-h4a3c616_0.tar.bz2": { + "build": "h4a3c616_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "c4e4a32c08aacede365595b85d46c4ae", + "name": "libllvm9", + "sha256": "2e30af38992aeeae5a61084024e0c1a0f132dab5fae9eb8acd35b62d3dbe26eb", + "size": 26337811, + "subdir": "linux-64", + "timestamp": 1592929433291, + "version": "9.0.1" + }, + "libllvm9-9.0.1-h4a3c616_1.tar.bz2": { + "build": "h4a3c616_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "287f7bdfeb66df78d82059171cecf030", + "name": "libllvm9", + "sha256": "71ae71e1cc69ec2a7b900ca6d745592b61ac80f9ee023d5c58ba220de6af502e", + "size": 26344144, + "subdir": "linux-64", + "timestamp": 1594477682199, + "version": "9.0.1" + }, + "libmagic-5.36-h27cfd23_2.tar.bz2": { + "build": "h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "7654a772830fbb02c0f65d5197170755", + "name": "libmagic", + "sha256": "a2c4dddcd4fcdbeb6a8edb32ed696589717a47eccdef6a31fcf3dc834371a912", + "size": 537400, + "subdir": "linux-64", + "timestamp": 1616768333417, + "version": "5.36" + }, + "libmamba-0.22.1-h1566912_0.tar.bz2": { + "build": "h1566912_0", + "build_number": 0, + "depends": [ + "libarchive >=3.4.2,<3.5.0a0", + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1m,<1.1.2a", + "reproc >=14.2,<15.0a0", + "reproc-cpp >=14.2,<15.0a0", + "spdlog-fmt-embed >=1.9.2,<2.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4cf8b0ae1b4537fb28efeb1e60780cde", + "name": "libmamba", + "sha256": "6b75cf811f85ae9ccfa8e6b7e4f0d2b17c97e9e94b26d81e801de8d47ab2a064", + "size": 1358593, + "subdir": "linux-64", + "timestamp": 1647297012673, + "version": "0.22.1" + }, + "libmamba-0.24.0-h1566912_0.tar.bz2": { + "build": "h1566912_0", + "build_number": 0, + "depends": [ + "libarchive >=3.5.2,<3.6.0a0", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1o,<1.1.2a", + "reproc >=14.2,<15.0a0", + "reproc-cpp >=14.2,<15.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2c6bfa5c85cac0e18e17dc8276ec9a48", + "name": "libmamba", + "sha256": "0e23407a5f3b2bbb1e15f79db3ae7cbf5f830b2a05b0f587a92e8af219000553", + "size": 1391721, + "subdir": "linux-64", + "timestamp": 1654274054610, + "version": "0.24.0" + }, + "libmamba-1.0.0-ha06983f_0.tar.bz2": { + "build": "ha06983f_0", + "build_number": 0, + "depends": [ + "fmt >=8.1.1,<9.0a0", + "libarchive >=3.6.1,<3.7.0a0", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libsolv >=0.7.22", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1s,<1.1.2a", + "reproc >=14.2", + "reproc-cpp >=14.2", + "reproc-cpp >=14.2,<15.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f6c851f85d3cae9042ccdc0eda741eeb", + "name": "libmamba", + "sha256": "a457c6783af7af1d69bef67482ccae8d214f98ca2c7747a181ab3ca84f686908", + "size": 1636371, + "subdir": "linux-64", + "timestamp": 1669229533825, + "version": "1.0.0" + }, + "libmamba-1.3.1-hdb19cb5_0.tar.bz2": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "fmt >=9.1.0,<10.0a0", + "libarchive >=3.6.2,<3.7.0a0", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libsolv >=0.7.22,<0.8.0a0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "reproc >=14.2,<15.0a0", + "reproc >=14.2.4,<15.0a0", + "reproc-cpp >=14.2,<15.0a0", + "reproc-cpp >=14.2.4,<15.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a4c79182b70b69f243ac307f8955e687", + "name": "libmamba", + "sha256": "de5b49941655afc6d393c79172513d9e507e68852f6daf8608e3afe1dfd77635", + "size": 1890831, + "subdir": "linux-64", + "timestamp": 1676389107025, + "version": "1.3.1" + }, + "libmamba-1.3.1-hdb19cb5_1.tar.bz2": { + "build": "hdb19cb5_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "fmt >=9.1.0,<10.0a0", + "libarchive >=3.6.2,<3.7.0a0", + "libcurl >=7.88.1,<8.0a0", + "libgcc-ng >=11.2.0", + "libsolv >=0.7.22,<0.8.0a0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "reproc >=14.2,<15.0a0", + "reproc >=14.2.4,<15.0a0", + "reproc-cpp >=14.2,<15.0a0", + "reproc-cpp >=14.2.4,<15.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cf11ed98e5d5a312400e3af300fa11ce", + "name": "libmamba", + "sha256": "8e51e611e8c863c1c102a15f051788f02a684b038d1ed872f9371ad42c2bc388", + "size": 1883544, + "subdir": "linux-64", + "timestamp": 1678914319576, + "version": "1.3.1" + }, + "libmamba-1.4.1-hdb19cb5_0.tar.bz2": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "fmt >=9.1.0,<10.0a0", + "libarchive >=3.6.2,<3.7.0a0", + "libcurl >=7.88.1,<8.0a0", + "libgcc-ng >=11.2.0", + "libsolv >=0.7.22,<0.8.0a0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "reproc >=14.2,<15.0a0", + "reproc >=14.2.4,<15.0a0", + "reproc-cpp >=14.2,<15.0a0", + "reproc-cpp >=14.2.4,<15.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0", + "zstd >=1.5.4,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b0b28f670c08a17aace83d57215d3599", + "name": "libmamba", + "sha256": "487f1770ece246684c6237313a7e3c0815084b1db8023ab1aecf6112efd8c9e0", + "size": 1909613, + "subdir": "linux-64", + "timestamp": 1680093200323, + "version": "1.4.1" + }, + "libmambapy-0.22.1-py310hd09550d_0.tar.bz2": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.22.1 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7f4ab123e3b30ee735ec2eb46833cc22", + "name": "libmambapy", + "sha256": "d2e23f6eb3f7508ef88d158d9d0e57cbdcc3cb215fc327e18674d3d14165bd6a", + "size": 258536, + "subdir": "linux-64", + "timestamp": 1647294651758, + "version": "0.22.1" + }, + "libmambapy-0.22.1-py37hd09550d_0.tar.bz2": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.22.1 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "092b4972f88f9debb9d864835d5f39ab", + "name": "libmambapy", + "sha256": "9da766c52f474d129490e3065748c1d59bace4bfcfe40fb64aee0f80745e0885", + "size": 258752, + "subdir": "linux-64", + "timestamp": 1647294589665, + "version": "0.22.1" + }, + "libmambapy-0.22.1-py38hd09550d_0.tar.bz2": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.22.1 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0340d5b80e591508c492d46c2f36393a", + "name": "libmambapy", + "sha256": "8315552ba785b9a05ec7244eec33fdf150362198ef1375ff55bb78d9e2e3f13b", + "size": 258477, + "subdir": "linux-64", + "timestamp": 1647294526210, + "version": "0.22.1" + }, + "libmambapy-0.22.1-py39hd09550d_0.tar.bz2": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.22.1 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b79977b40cd84493158076f1872dadb8", + "name": "libmambapy", + "sha256": "3be630eaf9b660c25bed15d334c725ca900d23d36b5b13a47dfb32f0b353b661", + "size": 258763, + "subdir": "linux-64", + "timestamp": 1647294464629, + "version": "0.22.1" + }, + "libmambapy-0.23.1-py310hd09550d_0.tar.bz2": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.23.1 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dceae6a42ba9520dfbbcba3539746179", + "name": "libmambapy", + "sha256": "5a64d1f201c421aab8655d684822c4995fb70dd929df48415a58d101ee4da832", + "size": 214189, + "subdir": "linux-64", + "timestamp": 1652475517207, + "version": "0.23.1" + }, + "libmambapy-0.23.1-py37hd09550d_0.tar.bz2": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.23.1 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee32c85f94cbdbc35051f72af5dcd18a", + "name": "libmambapy", + "sha256": "eaf4dc4e52f6af73324a4f90eaf5229765cf529f4565966da271ddffea5826f3", + "size": 212340, + "subdir": "linux-64", + "timestamp": 1652475607196, + "version": "0.23.1" + }, + "libmambapy-0.23.1-py38hd09550d_0.tar.bz2": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.23.1 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dbcc979750a876118476c84252493e54", + "name": "libmambapy", + "sha256": "64a2420f281c4147a805add51f7578904a8e3352b26ab163378f6ddcd34112dc", + "size": 214248, + "subdir": "linux-64", + "timestamp": 1652475561214, + "version": "0.23.1" + }, + "libmambapy-0.23.1-py39hd09550d_0.tar.bz2": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.23.1 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "079c75c70e1f8611cdb484828d008c45", + "name": "libmambapy", + "sha256": "b9c382207f23e0aca78d309f0d444f022b3d8a19e98f2360252d93c91ba12630", + "size": 214483, + "subdir": "linux-64", + "timestamp": 1652475653297, + "version": "0.23.1" + }, + "libmambapy-0.23.3-py310hd09550d_0.tar.bz2": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.23.3 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1cf0ea2a85e71b5e7ef0db194c49b656", + "name": "libmambapy", + "sha256": "353451a12a578232afe348c5d43828c14178af59029cc2f9ed212217b5990e4f", + "size": 214221, + "subdir": "linux-64", + "timestamp": 1653512397922, + "version": "0.23.3" + }, + "libmambapy-0.23.3-py37hd09550d_0.tar.bz2": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.23.3 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "409eb9fa94682500137700dddd42e320", + "name": "libmambapy", + "sha256": "fcc4004da88ff9b91bf92cfd9a57112ae2af33690cb7b0f92d26d6232e42fd23", + "size": 212172, + "subdir": "linux-64", + "timestamp": 1653512488549, + "version": "0.23.3" + }, + "libmambapy-0.23.3-py38hd09550d_0.tar.bz2": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.23.3 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0051df883c8179a02202e73ea52e5ef2", + "name": "libmambapy", + "sha256": "144c4c81d553c5615e1d9b729de3d4079370458ece70a17476b3c8a1534a8097", + "size": 213913, + "subdir": "linux-64", + "timestamp": 1653512442317, + "version": "0.23.3" + }, + "libmambapy-0.23.3-py39hd09550d_0.tar.bz2": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.23.3 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1fa3eeae26e92c3b63061342d8d87db8", + "name": "libmambapy", + "sha256": "51f9cdf04c3317e0ad492e78564c7d573ba4316423b60c9d22a3626c7c55777f", + "size": 214298, + "subdir": "linux-64", + "timestamp": 1653512353475, + "version": "0.23.3" + }, + "libmambapy-0.24.0-py310hd09550d_0.tar.bz2": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.24.0 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "825f83c77a0d0ea2ac5fc6c4b0bfad33", + "name": "libmambapy", + "sha256": "92cec8c6cdd151f3d74f4596ab6a91ff175e69db6e8e1de02c76ceebded9d24c", + "size": 214133, + "subdir": "linux-64", + "timestamp": 1654274236735, + "version": "0.24.0" + }, + "libmambapy-0.24.0-py37hd09550d_0.tar.bz2": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.24.0 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3059ce1a045a200b43f9a51b0ae3a3d2", + "name": "libmambapy", + "sha256": "9b7d615d9593baad10d8ca3056e453245ec93e65c422642b0e683368c2c20ecd", + "size": 212270, + "subdir": "linux-64", + "timestamp": 1654274192389, + "version": "0.24.0" + }, + "libmambapy-0.24.0-py38hd09550d_0.tar.bz2": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.24.0 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07ac7f09cd37352196dd6ef0425bc34f", + "name": "libmambapy", + "sha256": "76f4b80e65cb8c56437f340fbce1040a2e37438c4a856ba1be37e005a3658ffe", + "size": 213864, + "subdir": "linux-64", + "timestamp": 1654274099961, + "version": "0.24.0" + }, + "libmambapy-0.24.0-py39hd09550d_0.tar.bz2": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.24.0 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "964661ea574137e76715248a76b3087d", + "name": "libmambapy", + "sha256": "bbeb3a5d2af4304363fa2c468702bf377e13c142ca99f8cceac28a3ed84558ae", + "size": 214382, + "subdir": "linux-64", + "timestamp": 1654274146269, + "version": "0.24.0" + }, + "libmambapy-1.0.0-py310ha06983f_0.tar.bz2": { + "build": "py310ha06983f_0", + "build_number": 0, + "depends": [ + "fmt >=8.1.1,<9.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.0.0 ha06983f_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1s,<1.1.2a", + "pybind11-abi 4", + "python >=3.10,<3.11.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a1c5b974a5f3aaac3131f89e8ea39027", + "name": "libmambapy", + "sha256": "f96271a8999194cf7b233dbb9a2d9a4cc4a85dc2e96f780eba71e524b5c6a5f0", + "size": 300415, + "subdir": "linux-64", + "timestamp": 1669229582419, + "version": "1.0.0" + }, + "libmambapy-1.0.0-py311ha06983f_0.tar.bz2": { + "build": "py311ha06983f_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.0.0 ha06983f_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.11,<3.12.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "75962b2a0a19bbee4bac9381b338433f", + "name": "libmambapy", + "sha256": "c48e99e14f4519e412b38ba29952bd11c532eecf35d8c3f0cdc0aa2116c1ab83", + "size": 298599, + "subdir": "linux-64", + "timestamp": 1676844677347, + "version": "1.0.0" + }, + "libmambapy-1.0.0-py37ha06983f_0.tar.bz2": { + "build": "py37ha06983f_0", + "build_number": 0, + "depends": [ + "fmt >=8.1.1,<9.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.0.0 ha06983f_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1s,<1.1.2a", + "pybind11-abi 4", + "python >=3.7,<3.8.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b3b0e274fbd1b516e473fc9f93d4426d", + "name": "libmambapy", + "sha256": "b4be1c15e2c695906fa71fb551a57c85b8245917b545fd6602c12096e37ef1de", + "size": 290866, + "subdir": "linux-64", + "timestamp": 1669229675989, + "version": "1.0.0" + }, + "libmambapy-1.0.0-py38ha06983f_0.tar.bz2": { + "build": "py38ha06983f_0", + "build_number": 0, + "depends": [ + "fmt >=8.1.1,<9.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.0.0 ha06983f_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1s,<1.1.2a", + "pybind11-abi 4", + "python >=3.8,<3.9.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0267cd7916d42a7b0f3c81ef52d97e1e", + "name": "libmambapy", + "sha256": "db5d881532d2a527af2c2905aa19bfefa2243bb17a1ac60cac216df46ac64765", + "size": 294748, + "subdir": "linux-64", + "timestamp": 1669229723069, + "version": "1.0.0" + }, + "libmambapy-1.0.0-py39ha06983f_0.tar.bz2": { + "build": "py39ha06983f_0", + "build_number": 0, + "depends": [ + "fmt >=8.1.1,<9.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.0.0 ha06983f_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1s,<1.1.2a", + "pybind11-abi 4", + "python >=3.9,<3.10.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bdeeee0196e56e75986ca4a1a5e28bd9", + "name": "libmambapy", + "sha256": "7cc2afe2bc8e5776544a9339f27e3bb4c85bddff77650612a419e1a62f10f003", + "size": 299352, + "subdir": "linux-64", + "timestamp": 1669229629332, + "version": "1.0.0" + }, + "libmambapy-1.3.1-py310hdb19cb5_0.tar.bz2": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.3.1 hdb19cb5_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.10,<3.11.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07282347d0ae01ff34ac5f15d34f4f66", + "name": "libmambapy", + "sha256": "04f23a8a8ddd5991e18c771706ba7d497e25f674de0043572bdcacef2f0abaff", + "size": 308497, + "subdir": "linux-64", + "timestamp": 1676389159466, + "version": "1.3.1" + }, + "libmambapy-1.3.1-py310hdb19cb5_1.tar.bz2": { + "build": "py310hdb19cb5_1", + "build_number": 1, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.3.1 hdb19cb5_1", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.10,<3.11.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "32623f9d90bd7f610cf895884803cc17", + "name": "libmambapy", + "sha256": "5df46c17f51eb5fe875a04733681e2944fe4d9cfc67d80d1cf467b4fd5b77d89", + "size": 308698, + "subdir": "linux-64", + "timestamp": 1678914523749, + "version": "1.3.1" + }, + "libmambapy-1.3.1-py311hdb19cb5_1.tar.bz2": { + "build": "py311hdb19cb5_1", + "build_number": 1, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.3.1 hdb19cb5_1", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.11,<3.12.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a760fe8d068e7106adb83ff1da131c85", + "name": "libmambapy", + "sha256": "e55522bc078ef68483c25f99e878fd5e2e8ab391e4add64547970a6b70f97c33", + "size": 308562, + "subdir": "linux-64", + "timestamp": 1678914422539, + "version": "1.3.1" + }, + "libmambapy-1.3.1-py37hdb19cb5_0.tar.bz2": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.3.1 hdb19cb5_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.7,<3.8.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c5dbce04ed68af3bed946d97045e3de9", + "name": "libmambapy", + "sha256": "f8a7f928f1e8c05d6ff42b74e2a99fad6f61b4a21cc75ae1a41b4f24fcd224f4", + "size": 323608, + "subdir": "linux-64", + "timestamp": 1676389214197, + "version": "1.3.1" + }, + "libmambapy-1.3.1-py38hdb19cb5_0.tar.bz2": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.3.1 hdb19cb5_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.8,<3.9.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb7097a2a9d360f9b6e69727a10fa98d", + "name": "libmambapy", + "sha256": "e3ce66de7855339cb47a2c71471b53c2d21fbdd6858375517f8865e1d7cd0b22", + "size": 308153, + "subdir": "linux-64", + "timestamp": 1676389315732, + "version": "1.3.1" + }, + "libmambapy-1.3.1-py38hdb19cb5_1.tar.bz2": { + "build": "py38hdb19cb5_1", + "build_number": 1, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.3.1 hdb19cb5_1", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.8,<3.9.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "17d0ece02f95502e13529632347936ba", + "name": "libmambapy", + "sha256": "371b6dd393d9d12dba348abf553d355b1c792284796b5f2fe06af13e5d7626ef", + "size": 308374, + "subdir": "linux-64", + "timestamp": 1678914371312, + "version": "1.3.1" + }, + "libmambapy-1.3.1-py39hdb19cb5_0.tar.bz2": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.3.1 hdb19cb5_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.9,<3.10.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b6327fec79e1b729a446a70c1c1a181b", + "name": "libmambapy", + "sha256": "45082a2c088ed69d24dcf880ec12e4d7dfe19ac93fa199b0570f6ee3ab4c5f32", + "size": 308581, + "subdir": "linux-64", + "timestamp": 1676389265137, + "version": "1.3.1" + }, + "libmambapy-1.3.1-py39hdb19cb5_1.tar.bz2": { + "build": "py39hdb19cb5_1", + "build_number": 1, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.3.1 hdb19cb5_1", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.9,<3.10.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5dbdebe3b5a6ff08aa0f3d19dca530c1", + "name": "libmambapy", + "sha256": "3393c402bfc5dfad9bac0372b8d555959f34bedaa1047b63aa75bc86936b8b88", + "size": 308687, + "subdir": "linux-64", + "timestamp": 1678914472797, + "version": "1.3.1" + }, + "libmambapy-1.4.1-py310hdb19cb5_0.tar.bz2": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.4.1 hdb19cb5_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.10,<3.11.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dd5bbc4de68787cfd34f32bfde17ec91", + "name": "libmambapy", + "sha256": "a71f6b50ab9f8ec10b609775223e1e251230a7dde835c64d63d969048cbf1369", + "size": 309184, + "subdir": "linux-64", + "timestamp": 1680093363322, + "version": "1.4.1" + }, + "libmambapy-1.4.1-py311hdb19cb5_0.tar.bz2": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.4.1 hdb19cb5_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.11,<3.12.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f38fe9fe4a619e952937be36c912f7ca", + "name": "libmambapy", + "sha256": "f5a6d1268b95b3167b432c9fd6022fe693acf85cd8b44556dc0c52d2657bfb0c", + "size": 308873, + "subdir": "linux-64", + "timestamp": 1680093255621, + "version": "1.4.1" + }, + "libmambapy-1.4.1-py38hdb19cb5_0.tar.bz2": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.4.1 hdb19cb5_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.8,<3.9.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6544464a42506431e7254a2d83bf382a", + "name": "libmambapy", + "sha256": "fde24961a5c43b5f604b7c39cd90135bd41a30cece99951a4f0fd0f64752af63", + "size": 308997, + "subdir": "linux-64", + "timestamp": 1680093308873, + "version": "1.4.1" + }, + "libmambapy-1.4.1-py39hdb19cb5_0.tar.bz2": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.4.1 hdb19cb5_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.9,<3.10.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c177075bc688c3a94d75ce0f4cb38361", + "name": "libmambapy", + "sha256": "67b3cd628a7bf62910e4092a3851162a94245d883752616f574df2933bab9c9f", + "size": 308906, + "subdir": "linux-64", + "timestamp": 1680093416778, + "version": "1.4.1" + }, + "libmklml-2018.0.3-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "intel-openmp 2018.0.3.*", + "libgcc-ng" + ], + "md5": "7e870170603bd3c31b1f712f4560147d", + "name": "libmklml", + "sha256": "f82ecdef05642394d940d9eefb245852d0beb7bf6ac9684b6fec8d2cba77a933", + "size": 60757317, + "subdir": "linux-64", + "timestamp": 1530345087172, + "version": "2018.0.3" + }, + "libmklml-2019.0.3-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "intel-openmp 2019.*", + "libgcc-ng" + ], + "md5": "07117d291e9896bf0384282cbe81feca", + "name": "libmklml", + "sha256": "1ccfd151a2d0e6589c686f2f6de50c93e2b937d8698c47f8056f3a9db22701aa", + "size": 52802482, + "subdir": "linux-64", + "timestamp": 1551761704067, + "version": "2019.0.3" + }, + "libmklml-2019.0.5-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "intel-openmp 2019.*", + "libgcc-ng" + ], + "md5": "1d9e30ae80a631b93943ac600cd33a5d", + "name": "libmklml", + "sha256": "689957f43000dfe3019a569e86c78e8db74831d67aae987a174ad3ec1cab28cb", + "size": 52771343, + "subdir": "linux-64", + "timestamp": 1564677966774, + "version": "2019.0.5" + }, + "libmklml-2019.0.5-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "intel-openmp 2019.*", + "libgcc-ng" + ], + "md5": "b18cfce0301aedade3f2ddc887cdc4e4", + "name": "libmklml", + "sha256": "dc998f883ff9f328ce3803b368f0217ef8f136015fc22e17e092c4d50e1be515", + "size": 52674736, + "subdir": "linux-64", + "timestamp": 1641844474278, + "version": "2019.0.5" + }, + "libmlir-14.0.6-h9e868ea_0.tar.bz2": { + "build": "h9e868ea_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libmlir14 14.0.6 h9e868ea_0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "69b5a9453209f19daad595114480ef57", + "name": "libmlir", + "sha256": "8d8208c8a46ba601030228d5a5a15ab2f4e5e09acecfd1927674c32fc39987d8", + "size": 9064234, + "subdir": "linux-64", + "timestamp": 1662555382434, + "version": "14.0.6" + }, + "libmlir14-14.0.6-h9e868ea_0.tar.bz2": { + "build": "h9e868ea_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "d23e28d1932b8744558b21b0657cb0f9", + "name": "libmlir14", + "sha256": "3048ba15b8566d12b645c362c9690fdbe08919332762884f55f483858c804001", + "size": 9061268, + "subdir": "linux-64", + "timestamp": 1662555355611, + "version": "14.0.6" + }, + "libmxnet-1.0.0-hb7fadbc_0.tar.bz2": { + "build": "hb7fadbc_0", + "build_number": 0, + "depends": [ + "jemalloc", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.1,<2019.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "blas * mkl" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "93b9c9ef28665a716be04909a7cf773e", + "name": "libmxnet", + "sha256": "f43a897eb5b1ff03ce3ea9aa236e88986205da8b7f3dc2bf368fda811a942bcf", + "size": 50432209, + "subdir": "linux-64", + "timestamp": 1514730526365, + "version": "1.0.0" + }, + "libmxnet-1.0.0-nomklh2cb3ce3_0.tar.bz2": { + "build": "nomklh2cb3ce3_0", + "build_number": 0, + "depends": [ + "jemalloc", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "opencv >=3.3.1,<3.3.2.0a0", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "6056cdcff99fb2cec5cf702c5f2ae304", + "name": "libmxnet", + "sha256": "2075bb69cc7b58e8a3fef950bcf9483d41860250836bdddd740473f6bd74d932", + "size": 50367275, + "subdir": "linux-64", + "timestamp": 1514731439768, + "version": "1.0.0" + }, + "libmxnet-1.1.0-h47cb24f_0.tar.bz2": { + "build": "h47cb24f_0", + "build_number": 0, + "depends": [ + "jemalloc", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "blas * mkl" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "4a3fd8fb8d89e608c10b11e78525607e", + "name": "libmxnet", + "sha256": "3911885d6260518653a354206648888c10daa4f293d04a4792173e0ac01859f9", + "size": 51417189, + "subdir": "linux-64", + "timestamp": 1522952735018, + "version": "1.1.0" + }, + "libmxnet-1.1.0-nomklh028b6bb_0.tar.bz2": { + "build": "nomklh028b6bb_0", + "build_number": 0, + "depends": [ + "jemalloc", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "opencv >=3.3.1,<3.3.2.0a0", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "50c6ca3fbb36e7962223de42875822dd", + "name": "libmxnet", + "sha256": "286fd7bd4bb8fcbaf37740f689fd810ed4842210514df787c9c52718560850fd", + "size": 51254613, + "subdir": "linux-64", + "timestamp": 1522953489196, + "version": "1.1.0" + }, + "libmxnet-1.2.1-gpu_mkl_h3d71631_1.tar.bz2": { + "build": "gpu_mkl_h3d71631_1", + "build_number": 1, + "depends": [ + "_mutex_mxnet 0.0.20 gpu_mkl", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "intel-openmp >=2018.0.3,<2019.0a0", + "libgcc-ng >=5.4.0", + "libmklml >=2018.0.3", + "libopencv >=3.4.1,<3.4.2.0a0", + "libstdcxx-ng >=5.4.0", + "mkl-dnn >=0.14,<1.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "5e3de0bf4c731a05dd3ebcfab3976cc7", + "name": "libmxnet", + "sha256": "76c79902859bb440c6cb66f4242c9a57d1cb00d1e9dfa4e6ae7c3ea7ceffef8b", + "size": 353689196, + "subdir": "linux-64", + "timestamp": 1533387308069, + "version": "1.2.1" + }, + "libmxnet-1.2.1-gpu_mkl_he87abd8_1.tar.bz2": { + "build": "gpu_mkl_he87abd8_1", + "build_number": 1, + "depends": [ + "_mutex_mxnet 0.0.20 gpu_mkl", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "intel-openmp >=2018.0.3,<2019.0a0", + "libgcc-ng >=5.4.0", + "libmklml >=2018.0.3", + "libopencv >=3.4.1,<3.4.2.0a0", + "libstdcxx-ng >=5.4.0", + "mkl-dnn >=0.14,<1.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "a38c1d065c9f1691a7421f603d1b3239", + "name": "libmxnet", + "sha256": "b3be2195a7e1f44475646419c19be3bfcac4f1989c99cf82587f54edc4ffdeab", + "size": 352179935, + "subdir": "linux-64", + "timestamp": 1533382716051, + "version": "1.2.1" + }, + "libmxnet-1.2.1-gpu_openblas_h1d4bbbf_1.tar.bz2": { + "build": "gpu_openblas_h1d4bbbf_1", + "build_number": 1, + "depends": [ + "_mutex_mxnet 0.0.10 gpu_openblas", + "blas 1.0 openblas", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libopencv >=3.4.1,<3.4.2.0a0", + "libstdcxx-ng >=5.4.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "7ad16ddcc05fdfd21e43373f9fa9a4f2", + "name": "libmxnet", + "sha256": "fd32f9de5076078900e3ce0ab9a157b512e0718f54fb23692c131537cea4829e", + "size": 352513506, + "subdir": "linux-64", + "timestamp": 1533388173538, + "version": "1.2.1" + }, + "libmxnet-1.2.1-gpu_openblas_hf1ee61d_1.tar.bz2": { + "build": "gpu_openblas_hf1ee61d_1", + "build_number": 1, + "depends": [ + "_mutex_mxnet 0.0.10 gpu_openblas", + "blas 1.0 openblas", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "libgcc-ng >=5.4.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libopencv >=3.4.1,<3.4.2.0a0", + "libstdcxx-ng >=5.4.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "4f7f460a11478ef0297bb8e2cdea1dcb", + "name": "libmxnet", + "sha256": "67e566c31074927f3e05898523398a89948940b6614ea41f786ddd625674baec", + "size": 350150016, + "subdir": "linux-64", + "timestamp": 1533383695098, + "version": "1.2.1" + }, + "libmxnet-1.2.1-mkl_hcbe7347_1.tar.bz2": { + "build": "mkl_hcbe7347_1", + "build_number": 1, + "depends": [ + "_mutex_mxnet 0.0.40 mkl", + "intel-openmp >=2018.0.3,<2019.0a0", + "libgcc-ng >=7.2.0", + "libmklml >=2018.0.3", + "libopencv >=3.4.1,<3.4.2.0a0", + "libstdcxx-ng >=7.2.0", + "mkl-dnn >=0.14,<1.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "3d5e6d6cfd5d9250798c182ac00043c6", + "name": "libmxnet", + "sha256": "931359e81175c8f204753bd324aab74fcae0f6f109fcdb451dde548e4ace8b91", + "size": 57677688, + "subdir": "linux-64", + "timestamp": 1533370399585, + "version": "1.2.1" + }, + "libmxnet-1.2.1-openblas_h42b7326_1.tar.bz2": { + "build": "openblas_h42b7326_1", + "build_number": 1, + "depends": [ + "_mutex_mxnet 0.0.30 openblas", + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libopencv >=3.4.1,<3.4.2.0a0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "9731cf115011723b0e7ebc68609f6d74", + "name": "libmxnet", + "sha256": "49d49c9d6ce7d83500fcc494ecf901a5d905d546e0fa6878259c52f9dfb0a547", + "size": 56657427, + "subdir": "linux-64", + "timestamp": 1533371129876, + "version": "1.2.1" + }, + "libmxnet-1.5.0-mkl_h902f91f_0.tar.bz2": { + "build": "mkl_h902f91f_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.30 mkl", + "blas 1.0 mkl", + "intel-openmp >=2019.4,<2020.0a0", + "libgcc-ng >=7.5.0", + "libmklml >=2019.0.5", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.5.0", + "mkl >=2019.4,<2021.0a0", + "mkl-dnn >=0.19,<1.0a0", + "mkl-service >=2,<3.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "a052733a27ea1db7088b741c441ac9c2", + "name": "libmxnet", + "sha256": "58193407169ff4b6a90e3419cfee16c035df3fbfc5f34839963eceb57738a2f5", + "size": 26415645, + "subdir": "linux-64", + "timestamp": 1633948736619, + "version": "1.5.0" + }, + "libmxnet-1.5.0-mkl_hfe83b78_0.tar.bz2": { + "build": "mkl_hfe83b78_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.40 mkl", + "blas 1.0 mkl", + "intel-openmp >=2019.4,<2020.0a0", + "libgcc-ng >=7.3.0", + "libmklml >=2019.0.5", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-dnn >=0.19,<1.0a0", + "mkl-service >=2,<3.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "ea6092b7ff9a77f8a9a1906018ff2e84", + "name": "libmxnet", + "sha256": "a410ecce8ecc9c4bf8d18184d1dc58d411cce0221ae3ae57bcc2ba6f5f5fc58a", + "size": 26442851, + "subdir": "linux-64", + "timestamp": 1564767316679, + "version": "1.5.0" + }, + "libmxnet-1.5.0-openblas_h7253574_0.tar.bz2": { + "build": "openblas_h7253574_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.40 openblas", + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.13,<1.0a0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "8a1d8758f4669e54eab3a680377df7e8", + "name": "libmxnet", + "sha256": "b29509293858bd5b2a19e4f165a2d9c037c8c06d0a9202d5e5b3ba28b6ff6234", + "size": 25197450, + "subdir": "linux-64", + "timestamp": 1633949017027, + "version": "1.5.0" + }, + "libmxnet-1.5.0-openblas_ha1db078_0.tar.bz2": { + "build": "openblas_ha1db078_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.30 openblas", + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.6,<1.0a0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "4e08030d205c0d43a6bb0129ff942d01", + "name": "libmxnet", + "sha256": "ec2c605269a6bbe888ec5d58cda06eea65ef3903b93e34658711cc516c875f63", + "size": 25189806, + "subdir": "linux-64", + "timestamp": 1564768892182, + "version": "1.5.0" + }, + "libmxnet-1.5.1-openblas_h8848447_0.tar.bz2": { + "build": "openblas_h8848447_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.50 openblas", + "_openmp_mutex", + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "opencv >=4.6" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "eafd4b08b63a038a41fce87fad85de84", + "name": "libmxnet", + "sha256": "33bd323d98b0d5af99dae540f29c5317703c547f05689b9caf2a839a9d585a32", + "size": 28980754, + "subdir": "linux-64", + "timestamp": 1665586651378, + "version": "1.5.1" + }, + "libmxnet-1.9.1-openblas_h8848447_0.tar.bz2": { + "build": "openblas_h8848447_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.50 openblas", + "_openmp_mutex", + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "opencv >=4.6" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "68cad4713c02aa6104d67eedde2cc52f", + "name": "libmxnet", + "sha256": "b6bbb8ebef2b47dc5c8686bdb3e7d5f66784bc4f29b9c6e6427f4a6d84c04239", + "size": 27692574, + "subdir": "linux-64", + "timestamp": 1666596907579, + "version": "1.9.1" + }, + "libnetcdf-4.4.1.1-h816af47_8.tar.bz2": { + "build": "h816af47_8", + "build_number": 8, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "63c3dca2d3cfabf44ecd917b56ba63b0", + "name": "libnetcdf", + "sha256": "ec10ede3f806342b6855242a5d24a7e97e22565b0ae7cd51acf2a44e4b3e420a", + "size": 3966062, + "subdir": "linux-64", + "timestamp": 1511287888297, + "version": "4.4.1.1" + }, + "libnetcdf-4.4.1.1-h97d33d9_8.tar.bz2": { + "build": "h97d33d9_8", + "build_number": 8, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "bd343e58d6141e85030e4da81056f7e5", + "name": "libnetcdf", + "sha256": "f2d64c44a01ace66fa1d5eed41a2041b62e13fab6bee50c0d6694b5e4e5ee247", + "size": 3957812, + "subdir": "linux-64", + "timestamp": 1511287907397, + "version": "4.4.1.1" + }, + "libnetcdf-4.5.0-h3d11b55_5.tar.bz2": { + "build": "h3d11b55_5", + "build_number": 5, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "90f3981edcd29dc7a1b9e6f947022f7c", + "name": "libnetcdf", + "sha256": "6444e55dc371847ce98041a475003d82e8f0386c1879bc465da6a838c4cf1c84", + "size": 4594537, + "subdir": "linux-64", + "timestamp": 1511988220225, + "version": "4.5.0" + }, + "libnetcdf-4.5.0-h569e9f1_7.tar.bz2": { + "build": "h569e9f1_7", + "build_number": 7, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "dc26f320b1cc195add0fdd65aea1bc9d", + "name": "libnetcdf", + "sha256": "77e283a347aa039090acf5cd45a3715222b5dbeae7ea90d879ce6f144a708b19", + "size": 1207359, + "subdir": "linux-64", + "timestamp": 1515001499977, + "version": "4.5.0" + }, + "libnetcdf-4.5.0-h5cf2a1f_4.tar.bz2": { + "build": "h5cf2a1f_4", + "build_number": 4, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "5afb1e78c8d61aafe2d24b418be5cc40", + "name": "libnetcdf", + "sha256": "099df4151cdc71eb16326df9a72b89772a22889c9486d282bbce21de01860cce", + "size": 4612895, + "subdir": "linux-64", + "timestamp": 1511817560815, + "version": "4.5.0" + }, + "libnetcdf-4.5.0-h7338db0_5.tar.bz2": { + "build": "h7338db0_5", + "build_number": 5, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "ef82ab6ebc4b8545027bdb57115cdd21", + "name": "libnetcdf", + "sha256": "ebb99ab9bb6c8fdcd8e9d3acf63c8e064b90a1ef49f8204aa90f699a50af77a5", + "size": 4611903, + "subdir": "linux-64", + "timestamp": 1511988202884, + "version": "4.5.0" + }, + "libnetcdf-4.5.0-hc9a163a_7.tar.bz2": { + "build": "hc9a163a_7", + "build_number": 7, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "1423a922b9ed46728612b03149643215", + "name": "libnetcdf", + "sha256": "b7df838ffee4bbb430f57b51f0534d46e42e8064f85804dd184068ab783ada75", + "size": 1207300, + "subdir": "linux-64", + "timestamp": 1515001518688, + "version": "4.5.0" + }, + "libnetcdf-4.5.0-he97b2d4_4.tar.bz2": { + "build": "he97b2d4_4", + "build_number": 4, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "fe757cd3193e13de388b83663a09682b", + "name": "libnetcdf", + "sha256": "528a0aefe19273f456e832718c965bb109a4bd4cd611930ea14a559daa38f4c6", + "size": 4595626, + "subdir": "linux-64", + "timestamp": 1511817562262, + "version": "4.5.0" + }, + "libnetcdf-4.6.1-h015f1c5_0.tar.bz2": { + "build": "h015f1c5_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.59.0,<8.0a0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "c467ecbc0244bc3d3501a68717306c8e", + "name": "libnetcdf", + "sha256": "56168e174491ecbf76f43c6fa1c797284ce539ecd953157c85632278bdaf91fc", + "size": 1311836, + "subdir": "linux-64", + "timestamp": 1526211407364, + "version": "4.6.1" + }, + "libnetcdf-4.6.1-h10edf3e_1.tar.bz2": { + "build": "h10edf3e_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.61.0,<8.0a0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "06de00d11c3da17e6c37153f816735b4", + "name": "libnetcdf", + "sha256": "c8ab1d0a526ffa503d4947518811b81a56da1dac481272331e862b9d1ba2183d", + "size": 1322800, + "subdir": "linux-64", + "timestamp": 1536427419490, + "version": "4.6.1" + }, + "libnetcdf-4.6.1-h10edf3e_2.tar.bz2": { + "build": "h10edf3e_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.61.1,<8.0a0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "6de128bb810e408d0de46011e8b329c4", + "name": "libnetcdf", + "sha256": "90fb5a8ac059e86a9ada7f759e3e9abebd193930b85ecbe4299440afddd199f9", + "size": 1323311, + "subdir": "linux-64", + "timestamp": 1539979652433, + "version": "4.6.1" + }, + "libnetcdf-4.6.1-h11d0813_2.tar.bz2": { + "build": "h11d0813_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.63.0,<8.0a0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "ec2c16d46f789863c64709343226877d", + "name": "libnetcdf", + "sha256": "3c8aef66d0e261f32d5f998801a9aaa915325e8b11e8840df6f225080278f7bd", + "size": 1322306, + "subdir": "linux-64", + "timestamp": 1545349808889, + "version": "4.6.1" + }, + "libnetcdf-4.6.1-h13459d8_0.tar.bz2": { + "build": "h13459d8_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.59.0,<8.0a0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "16fc62fa78045b5153e15899f77a0d73", + "name": "libnetcdf", + "sha256": "491ad9a7395e40ebfd93b43797ef564b25e536857e2e0dafd647eba24d8ae6cf", + "size": 1309970, + "subdir": "linux-64", + "timestamp": 1526211406831, + "version": "4.6.1" + }, + "libnetcdf-4.6.1-h2053bdc_3.tar.bz2": { + "build": "h2053bdc_3", + "build_number": 3, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "zlib" + ], + "license": "MIT", + "md5": "6c730ee5eacaafa4a370edb7a585d8bb", + "name": "libnetcdf", + "sha256": "7e53cf47009d36f71d8b95cc53b340fb0cc24549466c38f211109c5e9d940243", + "size": 1350513, + "subdir": "linux-64", + "timestamp": 1613574842822, + "version": "4.6.1" + }, + "libnetcdf-4.6.1-h2053bdc_4.tar.bz2": { + "build": "h2053bdc_4", + "build_number": 4, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "zlib" + ], + "license": "MIT", + "md5": "21c308222f08e465801c10750ec624b4", + "name": "libnetcdf", + "sha256": "5e957bdb5ff09e4e599f1fa201a9302bd11b86eb32fe3f13a10a2a770235aa26", + "size": 1358980, + "subdir": "linux-64", + "timestamp": 1621644214403, + "version": "4.6.1" + }, + "libnetcdf-4.6.1-h6ee366c_1.tar.bz2": { + "build": "h6ee366c_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.20,<1.9.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.61.0,<8.0a0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "a18cb0911aee1471b91a08f61e4475ff", + "name": "libnetcdf", + "sha256": "c252d102557bd2981e36cf5091cbc9b5484caae9a522887b638b388510f3fa89", + "size": 1322517, + "subdir": "linux-64", + "timestamp": 1536427620237, + "version": "4.6.1" + }, + "libnetcdf-4.6.1-h6ee366c_2.tar.bz2": { + "build": "h6ee366c_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.20,<1.9.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.61.1,<8.0a0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "7e3b2f26a1d7779873e6ea3bf84dd7fe", + "name": "libnetcdf", + "sha256": "2627aa07c8a9e4479ded3010397bb7835bccb7f70a9262528b493efdfa2ff434", + "size": 1324088, + "subdir": "linux-64", + "timestamp": 1539979651736, + "version": "4.6.1" + }, + "libnetcdf-4.7.3-hb80b6cc_0.tar.bz2": { + "build": "hb80b6cc_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.68.0,<8.0a0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "a42d2ce8ad910ce5dc38b8658c27f869", + "name": "libnetcdf", + "sha256": "b1337e44931363cdca484942f06f054c5dc70c4e179b318ac7a511cd623a060e", + "size": 1393976, + "subdir": "linux-64", + "timestamp": 1582140035959, + "version": "4.7.3" + }, + "libnetcdf-4.8.1-h42ceab0_0.tar.bz2": { + "build": "h42ceab0_0", + "build_number": 0, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libzip" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc1af6737d6d682b1a1f45da1ab299b8", + "name": "libnetcdf", + "sha256": "77708b0a8bbd5b835a7fe57addba3df356428176f665d455435a4d6ca69c8a45", + "size": 1573630, + "subdir": "linux-64", + "timestamp": 1641396335597, + "version": "4.8.1" + }, + "libnetcdf-4.8.1-h42ceab0_1.tar.bz2": { + "build": "h42ceab0_1", + "build_number": 1, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libzip", + "zlib" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a2566f0db9a998fdcee525ebc452f2b5", + "name": "libnetcdf", + "sha256": "8291a338553b086e91121b081de2631dc8de2430cf9c45d2da21d8a646e9804e", + "size": 1575093, + "subdir": "linux-64", + "timestamp": 1642426008501, + "version": "4.8.1" + }, + "libnetcdf-4.8.1-h8322cc2_2.tar.bz2": { + "build": "h8322cc2_2", + "build_number": 2, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libzip", + "zlib" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "709fea807f79a715b15e0eb3bdf06824", + "name": "libnetcdf", + "sha256": "53a1d864956ee531133a6dc55a5d2d57475e9be606b01f5c1badb430aa730e27", + "size": 1576298, + "subdir": "linux-64", + "timestamp": 1674628166020, + "version": "4.8.1" + }, + "libnghttp2-1.41.0-hf8bcb03_2.tar.bz2": { + "build": "hf8bcb03_2", + "build_number": 2, + "depends": [ + "c-ares >=1.16.1,<2.0a0", + "c-ares >=1.7.5", + "libev >=4.11", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a61f167c1adec4d7d8ae3b1936394eb", + "name": "libnghttp2", + "sha256": "8d8b8418973563fa671958ee491cac01aad1faf39e1b1af1e8045f65026baaef", + "size": 811073, + "subdir": "linux-64", + "timestamp": 1602882997296, + "version": "1.41.0" + }, + "libnghttp2-1.46.0-hce63b2e_0.tar.bz2": { + "build": "hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "c-ares >=1.7.5", + "libev >=4.11", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "97f632fd848c61ef9ac21fdf95ddd412", + "name": "libnghttp2", + "sha256": "35e522586539ca4b437626cdd3927adb8cdafae3bd73a9d725891d79aa7a3850", + "size": 814126, + "subdir": "linux-64", + "timestamp": 1637149827126, + "version": "1.46.0" + }, + "libnghttp2-static-1.41.0-he6710b0_2.tar.bz2": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "c-ares-static", + "libev-static", + "libgcc-ng >=7.3.0", + "libnghttp2 1.41.0 hf8bcb03_2", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb82eeb04e6cc65320828bbb40a119ad", + "name": "libnghttp2-static", + "sha256": "f5a023f29bb11bd93cf2312ac2a93ca1b9272cd96bb6abda5f357cbb5f8423c2", + "size": 86539, + "subdir": "linux-64", + "timestamp": 1602883007216, + "version": "1.41.0" + }, + "libnghttp2-static-1.46.0-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "c-ares-static", + "libev-static", + "libgcc-ng >=7.5.0", + "libnghttp2 1.46.0 hce63b2e_0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33b0972d8cb923db4042b40b18b7a81f", + "name": "libnghttp2-static", + "sha256": "f77da149cd5934648f431954d46c920e98eebddd26a4898bdf49ad1d0049aaa6", + "size": 87442, + "subdir": "linux-64", + "timestamp": 1637149836847, + "version": "1.46.0" + }, + "libnsl-2.0.0-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "GPL-2.0-only", + "license_family": "GPL", + "md5": "052ef554ca63e4050127e1adb78c57e4", + "name": "libnsl", + "sha256": "251069ca7085e8ffc7037faffd6ec0562f328f1852b43979319c8a508a5315f3", + "size": 31704, + "subdir": "linux-64", + "timestamp": 1666886617155, + "version": "2.0.0" + }, + "libntlm-1.4-h14c3975_2.tar.bz2": { + "build": "h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "md5": "1147f7afb136d68ee69d99de5af4e971", + "name": "libntlm", + "sha256": "13f2734ebb352c17c698c8b1910ae75897054b850404ab55544359b3281b1c87", + "size": 33616, + "subdir": "linux-64", + "timestamp": 1515696708073, + "version": "1.4" + }, + "libntlm-1.4-hbaadc6b_1.tar.bz2": { + "build": "hbaadc6b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "md5": "fc5ef77501c10a998b13158b1397f700", + "name": "libntlm", + "sha256": "f55f3efe01c998d468a668980a9e5fe283240338d1fd5026aa0365c5249cfbba", + "size": 33419, + "subdir": "linux-64", + "timestamp": 1508757755952, + "version": "1.4" + }, + "libntlm-1.5-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "md5": "90dacc39274b1fc4141cd302dfefb4a6", + "name": "libntlm", + "sha256": "2afc0ab7954c162fb5a06334e0a844d0aeb40e5d208b3eb459b134d7f985c26a", + "size": 36314, + "subdir": "linux-64", + "timestamp": 1552511223163, + "version": "1.5" + }, + "libntlm-1.6-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "LGPL-2.1", + "md5": "ba9230334b800e524f199135a392954e", + "name": "libntlm", + "sha256": "5bbe1e5f4d479c587b2d7ed7399f59df9483efb4d2908e5575613d0da0eb4738", + "size": 35976, + "subdir": "linux-64", + "timestamp": 1631837639630, + "version": "1.6" + }, + "libogg-1.3.2-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD3", + "md5": "5fb81ee8b272d16f0eb0c396b3d10748", + "name": "libogg", + "sha256": "bebc4d9422f5cd3eeba1bd64dd11af61377fa5d155c04ba4f67d634a43ce5a48", + "size": 209893, + "subdir": "linux-64", + "timestamp": 1539168795260, + "version": "1.3.2" + }, + "libogg-1.3.4-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD3", + "md5": "7aaa01b5d78569308c4b338a1cdeb1cf", + "name": "libogg", + "sha256": "7456a5066a1a215bac76488eb68f54437b5ff4cf559a2db5bb51c9e27dd6f98d", + "size": 222724, + "subdir": "linux-64", + "timestamp": 1619217664147, + "version": "1.3.4" + }, + "libogg-1.3.4-h27cfd23_1.tar.bz2": { + "build": "h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "md5": "3e4083ae5953af85e97748999e7a5cce", + "name": "libogg", + "sha256": "c9a6722e81ea9eca74882965ec7d3b74d35dbb485b95d6f172695aac6a5ff339", + "size": 210739, + "subdir": "linux-64", + "timestamp": 1619530117892, + "version": "1.3.4" + }, + "libogg-1.3.5-h27cfd23_1.tar.bz2": { + "build": "h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "48ff183e45bf81c02fa5f9ce1ad669dc", + "name": "libogg", + "sha256": "64ec2e3bef01cb27a1abb788f55df01c0d6d1df4af1a11ee5b92695bdfd209b4", + "size": 210848, + "subdir": "linux-64", + "timestamp": 1623063983024, + "version": "1.3.5" + }, + "libopenblas-0.2.20-h9ac9557_4.tar.bz2": { + "build": "h9ac9557_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "c4d3e53c0ca9baacfc9992ec5e05232a", + "name": "libopenblas", + "sha256": "66403cdd97d72ecc4664a5d5bb9aeab553b4c9e0a7b98c7218250fd964f4b61a", + "size": 9131700, + "subdir": "linux-64", + "timestamp": 1515516215744, + "version": "0.2.20" + }, + "libopenblas-0.2.20-h9ac9557_7.tar.bz2": { + "build": "h9ac9557_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "30e651fef1725cef021b24cafda2c223", + "name": "libopenblas", + "sha256": "a3e911754817ecf9edb12f8bf109550a9b835f2d540d80fc99c618564766be10", + "size": 9195354, + "subdir": "linux-64", + "timestamp": 1527877193514, + "version": "0.2.20" + }, + "libopenblas-0.2.20-hae245c1_3.tar.bz2": { + "build": "hae245c1_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0" + ], + "license": "BSD", + "md5": "e8f0064d71bcc2b7bd73110556d6c30e", + "name": "libopenblas", + "sha256": "7037769d2027b094f6ba65ed7f7b924f9a93c7f7feec5ec1a3dd906cd891bc31", + "size": 9131004, + "subdir": "linux-64", + "timestamp": 1509731009108, + "version": "0.2.20" + }, + "libopenblas-0.3.10-h5a2b251_0.tar.bz2": { + "build": "h5a2b251_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "9aabc4bb8d65076053ccf58132ba794a", + "name": "libopenblas", + "sha256": "270feccfbcf550fec8b7af16652e007e331f5cadf56d06b1d3006a5c639eebf1", + "size": 8182663, + "subdir": "linux-64", + "timestamp": 1594191939436, + "version": "0.3.10" + }, + "libopenblas-0.3.13-h4367d64_0.tar.bz2": { + "build": "h4367d64_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "6603158305550f2aa9fb191412ffd6ad", + "name": "libopenblas", + "sha256": "10e41d03ade8f3b7eab1550595a8a2efb5077c6498f4985ec32e1034fa1e6f8b", + "size": 8679945, + "subdir": "linux-64", + "timestamp": 1616438133183, + "version": "0.3.13" + }, + "libopenblas-0.3.17-hf726d26_1.tar.bz2": { + "build": "hf726d26_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-clause", + "md5": "95d50f8fff9c7a65d823c5e400300381", + "name": "libopenblas", + "sha256": "4c844edc705da13cf5f4ab282a8f4b4297f6c9d26249bd03aa1cc02fb0d694b7", + "size": 8721952, + "subdir": "linux-64", + "timestamp": 1643995245345, + "version": "0.3.17" + }, + "libopenblas-0.3.18-hf726d26_0.tar.bz2": { + "build": "hf726d26_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-clause", + "md5": "0955e27bf8115698fbfb3a12e539db53", + "name": "libopenblas", + "sha256": "134aff79da732bb5b26d19d5a7290f19da163390919631c4e779288de825d9f3", + "size": 8999694, + "subdir": "linux-64", + "timestamp": 1649691280533, + "version": "0.3.18" + }, + "libopenblas-0.3.2-h5a2b251_1.tar.bz2": { + "build": "h5a2b251_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "9d5f10f3a7be5c86fa0c1c8e45a2138c", + "name": "libopenblas", + "sha256": "6e065c1c86d68fbe89bde4f62086d643dbed02fa057e9c16fe2f2dc5dcb06115", + "size": 8093129, + "subdir": "linux-64", + "timestamp": 1535382564840, + "version": "0.3.2" + }, + "libopenblas-0.3.2-h7aa55d7_0.tar.bz2": { + "build": "h7aa55d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=8.2.0", + "libgfortran-ng >=8,<9.0a0" + ], + "license": "BSD", + "md5": "22981c80fe5b5e805febaeb3474be963", + "name": "libopenblas", + "sha256": "5625a2e676197a7ca5a935117166c424387539bba87ac068168812709e040fde", + "size": 27557063, + "subdir": "linux-64", + "timestamp": 1534769988486, + "version": "0.3.2" + }, + "libopenblas-0.3.2-h9ac9557_0.tar.bz2": { + "build": "h9ac9557_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "361b77f43e5a7237501455adbec1a530", + "name": "libopenblas", + "sha256": "2d994f167f2af41fb6ea310fb625bf230872c8804b4a8ab07d44ff8d70c7269b", + "size": 8220932, + "subdir": "linux-64", + "timestamp": 1534770579276, + "version": "0.3.2" + }, + "libopenblas-0.3.2-h9ac9557_1.tar.bz2": { + "build": "h9ac9557_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=8.2.0", + "libgfortran-ng >=8,<9.0a0" + ], + "license": "BSD", + "md5": "84dc262c7384a10eeeb8d662a4be8ed9", + "name": "libopenblas", + "sha256": "ed19d824d5f6233e81eaa0d5e0afdf6e2dff4e75067e53a5f1dbe85c812ece51", + "size": 9059909, + "subdir": "linux-64", + "timestamp": 1534782531307, + "version": "0.3.2" + }, + "libopenblas-0.3.20-h043d6bf_0.tar.bz2": { + "build": "h043d6bf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-clause", + "md5": "1d2ec19f750583b7d5e56bf8af5f77e0", + "name": "libopenblas", + "sha256": "ae4a2aa75ef31ea64db09b7efb6c591d4fa72a5b2e9606105c84af4062552adc", + "size": 10078365, + "subdir": "linux-64", + "timestamp": 1652995305837, + "version": "0.3.20" + }, + "libopenblas-0.3.20-h043d6bf_1.tar.bz2": { + "build": "h043d6bf_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-clause", + "md5": "61f860d152bd9b7dd57e2ec4dabbdeaf", + "name": "libopenblas", + "sha256": "803250e199d993bc1ab162dfe282b340457af42ab305df70f419cf1179cfa1b7", + "size": 10064827, + "subdir": "linux-64", + "timestamp": 1653477000378, + "version": "0.3.20" + }, + "libopenblas-0.3.21-h043d6bf_0.tar.bz2": { + "build": "h043d6bf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a52842101bd3b3815c5d6f0ec1729aaa", + "name": "libopenblas", + "sha256": "8afaf6d6dc085c6c1aee513d4d6b7aaab4b8d4b0b86a105a679f4922f8f7c9bb", + "size": 10131842, + "subdir": "linux-64", + "timestamp": 1664897187441, + "version": "0.3.21" + }, + "libopenblas-0.3.3-h5a2b251_1.tar.bz2": { + "build": "h5a2b251_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "22cbe726ccf31d9985e5c49ba405721a", + "name": "libopenblas", + "sha256": "aaf3bb4b92a1d9b037cd2478cf07f97ece6e2dd5b604a711a54ed4fd04b98529", + "size": 8181200, + "subdir": "linux-64", + "timestamp": 1536076208904, + "version": "0.3.3" + }, + "libopenblas-0.3.3-h5a2b251_2.tar.bz2": { + "build": "h5a2b251_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "d13f031bd192d9c8c5fad963dcc1f327", + "name": "libopenblas", + "sha256": "13bc509d66ee8a5f69f2d067004b231aa487ed374df0f9444048336319a085f1", + "size": 8014129, + "subdir": "linux-64", + "timestamp": 1536889145220, + "version": "0.3.3" + }, + "libopenblas-0.3.3-h5a2b251_3.tar.bz2": { + "build": "h5a2b251_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "e87a81f3ccd21d6033363644c00737d4", + "name": "libopenblas", + "sha256": "5f085127686026be3a012e11a62e46678faa9afb6a3bf73c1445a12eaf854323", + "size": 8012943, + "subdir": "linux-64", + "timestamp": 1537472768584, + "version": "0.3.3" + }, + "libopenblas-0.3.6-h5a2b251_0.tar.bz2": { + "build": "h5a2b251_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "7dcbbfe325c254f20272ceadc62916e2", + "name": "libopenblas", + "sha256": "a827781c69d9046f96b4c111dc11c357b8d2ea128b861f39ea39b132b2f2b389", + "size": 8120729, + "subdir": "linux-64", + "timestamp": 1559239803591, + "version": "0.3.6" + }, + "libopenblas-0.3.6-h5a2b251_1.tar.bz2": { + "build": "h5a2b251_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "7964e5c7a84decd67950706eefea6286", + "name": "libopenblas", + "sha256": "0b7e884ca6d3f759d062a96229aa730da18efc9e5f2a987d06024333d78637a9", + "size": 8117554, + "subdir": "linux-64", + "timestamp": 1563464662571, + "version": "0.3.6" + }, + "libopenblas-0.3.6-h5a2b251_2.tar.bz2": { + "build": "h5a2b251_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "231d0a853af63add98f97dbd12856bfe", + "name": "libopenblas", + "sha256": "f4ad2869ab5d44c85a61efd03f601b7479a6e2445ab4b155e047773e3cfcdc88", + "size": 8122452, + "subdir": "linux-64", + "timestamp": 1573061073675, + "version": "0.3.6" + }, + "libopenblas-static-0.2.20-4.tar.bz2": { + "build": "4", + "build_number": 4, + "depends": [], + "md5": "23e5ca23d8591bed5a07b1264b009538", + "name": "libopenblas-static", + "sha256": "dece245cd7cbb1027e333c3557be567fec22e455ece1cb19300043b6852b6226", + "size": 9778135, + "subdir": "linux-64", + "timestamp": 1515516228087, + "version": "0.2.20" + }, + "libopenblas-static-0.2.20-7.tar.bz2": { + "build": "7", + "build_number": 7, + "depends": [], + "md5": "52f79c47a3b7fbe1efd82f4d74b1d3a0", + "name": "libopenblas-static", + "sha256": "a026e62a0900ebe345626837097257f75687c38236577e3d32a4f213bccf24ea", + "size": 9804749, + "subdir": "linux-64", + "timestamp": 1527877204140, + "version": "0.2.20" + }, + "libopenblas-static-0.2.20-hb692580_3.tar.bz2": { + "build": "hb692580_3", + "build_number": 3, + "depends": [], + "md5": "c1731ad00a96fc00f7641b7ccf3269f1", + "name": "libopenblas-static", + "sha256": "d1c31df93ad35928a085c0ba937added387e2bf205e2dbedd173caf657e8ce2a", + "size": 9774195, + "subdir": "linux-64", + "timestamp": 1509731020378, + "version": "0.2.20" + }, + "libopenblas-static-0.3.10-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "BSD", + "md5": "061ae915773e4380b65f3a807691c144", + "name": "libopenblas-static", + "sha256": "93c1134b129ea298e9b0da03bbb93037283198f516b9d621d033d27841cb9af2", + "size": 8659022, + "subdir": "linux-64", + "timestamp": 1594191947553, + "version": "0.3.10" + }, + "libopenblas-static-0.3.13-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "BSD", + "md5": "f6eec77d46d5c6d25264e5a58a917e2b", + "name": "libopenblas-static", + "sha256": "91009418a0d6623236f3881ee3cc43498fcc6e8a8bec58361f02f4b524e4adcf", + "size": 9210848, + "subdir": "linux-64", + "timestamp": 1616438141788, + "version": "0.3.13" + }, + "libopenblas-static-0.3.17-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "BSD-3-clause", + "md5": "feb48e8ae264b208d2ad7615e071b045", + "name": "libopenblas-static", + "sha256": "08f33305843b8480b0f632b27dd478d54d021bc800f13ad812aa578127557cd0", + "size": 9271527, + "subdir": "linux-64", + "timestamp": 1643995252475, + "version": "0.3.17" + }, + "libopenblas-static-0.3.18-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "BSD-3-clause", + "md5": "d498ce889b400567d9824f35abf812df", + "name": "libopenblas-static", + "sha256": "3964eaf24771c15357c272d5673cadeb9caaeffb9e1e4806f8a58a54a681952e", + "size": 9604461, + "subdir": "linux-64", + "timestamp": 1649691288073, + "version": "0.3.18" + }, + "libopenblas-static-0.3.2-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "BSD", + "md5": "a43b8722c488abf03f1b1c486d2d6c64", + "name": "libopenblas-static", + "sha256": "d608ad20e1d5f577312d1c49a974a6fabd2c0a02f01265cb54ac7a25411c52d4", + "size": 8567414, + "subdir": "linux-64", + "timestamp": 1534770586513, + "version": "0.3.2" + }, + "libopenblas-static-0.3.2-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [], + "license": "BSD", + "md5": "8fc54a6c6a15813b0ef261e5210acb2e", + "name": "libopenblas-static", + "sha256": "c3f8209b97497f1e4cb687d66a667259bcae5cd91f65ec835136373eb2ce2a7c", + "size": 9520498, + "subdir": "linux-64", + "timestamp": 1534782551674, + "version": "0.3.2" + }, + "libopenblas-static-0.3.20-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "BSD-3-clause", + "md5": "f34cfc334977ce51697a2afbce6268f8", + "name": "libopenblas-static", + "sha256": "b33522b0d0f47974651bedbf4cd6fe7ed48ce481e6772d9c19a9ea136a16b7a0", + "size": 10774438, + "subdir": "linux-64", + "timestamp": 1652995313839, + "version": "0.3.20" + }, + "libopenblas-static-0.3.20-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "BSD-3-clause", + "md5": "db1117cf301b1f3c97d57bdde6722633", + "name": "libopenblas-static", + "sha256": "61723a64671aa570185917d7eb2864cb3a8e3fc259bd30d1b45468eab06a439d", + "size": 10775405, + "subdir": "linux-64", + "timestamp": 1653477008412, + "version": "0.3.20" + }, + "libopenblas-static-0.3.21-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2780dde02da035e14d13445f60b83204", + "name": "libopenblas-static", + "sha256": "b7d7069e86a67ba2f080809ea36ca005040c391b096e3e045d3ce9868868a84a", + "size": 10828342, + "subdir": "linux-64", + "timestamp": 1664897195360, + "version": "0.3.21" + }, + "libopenblas-static-0.3.3-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [], + "license": "BSD", + "md5": "1909fa65a5d24e4ab656e973b3ec1fff", + "name": "libopenblas-static", + "sha256": "9dcd66a5cc8140ce6341814c76d982202f5d2238ca310be1ffd05de23ef63a5f", + "size": 8624957, + "subdir": "linux-64", + "timestamp": 1536076214950, + "version": "0.3.3" + }, + "libopenblas-static-0.3.3-2.tar.bz2": { + "build": "2", + "build_number": 2, + "depends": [], + "license": "BSD", + "md5": "0d5adc2f160a917d4dc1144104ad1803", + "name": "libopenblas-static", + "sha256": "ba023be6a73bb661e88f2c8c73c2f52a76a13b3544425558dd69af61cd5f6d70", + "size": 8503143, + "subdir": "linux-64", + "timestamp": 1536889154281, + "version": "0.3.3" + }, + "libopenblas-static-0.3.3-3.tar.bz2": { + "build": "3", + "build_number": 3, + "depends": [], + "license": "BSD", + "md5": "02e736f252d0a8ee67022ea06d2c5a31", + "name": "libopenblas-static", + "sha256": "1a62929b04263a0d11b443bbae8cfd8eacd197a90c95a63cc02c8d3b445459e9", + "size": 8485011, + "subdir": "linux-64", + "timestamp": 1537472782825, + "version": "0.3.3" + }, + "libopenblas-static-0.3.6-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "BSD", + "md5": "4743074554011891b45f08954296887b", + "name": "libopenblas-static", + "sha256": "fcccc3d27d5a4261d056075c7e98784775518f88287e1bb388e21668782f435e", + "size": 8602789, + "subdir": "linux-64", + "timestamp": 1559239819494, + "version": "0.3.6" + }, + "libopenblas-static-0.3.6-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [], + "license": "BSD", + "md5": "c2a787e81ac5a4804e972778873a4e07", + "name": "libopenblas-static", + "sha256": "a8d78c0dace987dd98d41575b3485401c0f533f120e28390f8d09130856e5bb4", + "size": 8613277, + "subdir": "linux-64", + "timestamp": 1563464680446, + "version": "0.3.6" + }, + "libopenblas-static-0.3.6-2.tar.bz2": { + "build": "2", + "build_number": 2, + "depends": [], + "license": "BSD", + "md5": "96442d2d5855560bababf8e5e1fcb422", + "name": "libopenblas-static", + "sha256": "8d5cc635717dc3f5cfe1ae0b025b079dc1e3273a86ab9f7556d7d5bb00e626f4", + "size": 8615891, + "subdir": "linux-64", + "timestamp": 1573061082474, + "version": "0.3.6" + }, + "libopencv-3.4.1-h1a3b859_1.tar.bz2": { + "build": "h1a3b859_1", + "build_number": 1, + "depends": [ + "ffmpeg >=4.0,<4.1.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5528460f204a6c5b2905f2f9674c68fa", + "name": "libopencv", + "sha256": "28b537a748c35e7864821bb69a5c8a43e7955791b7a30285296555409d3607c2", + "size": 43544887, + "subdir": "linux-64", + "timestamp": 1527005695368, + "version": "3.4.1" + }, + "libopencv-3.4.1-h62359dd_1.tar.bz2": { + "build": "h62359dd_1", + "build_number": 1, + "depends": [ + "ffmpeg >=4.0,<4.1.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "bdec5b0b88452b855e166ee04c7ec063", + "name": "libopencv", + "sha256": "01eb6ae902a69c7d73b8883542a2a41bcff325ff13156e4b3c524069631a4945", + "size": 43549792, + "subdir": "linux-64", + "timestamp": 1527006615490, + "version": "3.4.1" + }, + "libopencv-3.4.1-h8fa1ad8_3.tar.bz2": { + "build": "h8fa1ad8_3", + "build_number": 3, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "freetype >=2.9.1,<3.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "72ed6c24f9397aac775809498ead340b", + "name": "libopencv", + "sha256": "ec6eda2fc3fe6a3c278381e41fac83c446d2eee41e700b531444f67f3f398ec1", + "size": 43510731, + "subdir": "linux-64", + "timestamp": 1530790782681, + "version": "3.4.1" + }, + "libopencv-3.4.1-he6673a0_3.tar.bz2": { + "build": "he6673a0_3", + "build_number": 3, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "freetype >=2.9.1,<3.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f21801d98b851f905819447ec376faa5", + "name": "libopencv", + "sha256": "e076b7837f425852a7e417de743dc7a3f5967452cdacfe2d52e23985eec756b0", + "size": 43509208, + "subdir": "linux-64", + "timestamp": 1530792449948, + "version": "3.4.1" + }, + "libopencv-3.4.2-h765d7f9_1.tar.bz2": { + "build": "h765d7f9_1", + "build_number": 1, + "depends": [ + "ffmpeg >=4.0,<4.1.0a0", + "freetype >=2.9.1,<3.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "hdf5 >=1.8.20,<1.9.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c6fbc9f31303f606ebe710a4238dc053", + "name": "libopencv", + "sha256": "79459e92f7a929bfb74ae60484bcc915dc43586f193d9438cafbffe720a53121", + "size": 42317583, + "subdir": "linux-64", + "timestamp": 1535561159743, + "version": "3.4.2" + }, + "libopencv-3.4.2-h8fa1ad8_0.tar.bz2": { + "build": "h8fa1ad8_0", + "build_number": 0, + "depends": [ + "ffmpeg >=4.0,<4.1.0a0", + "freetype >=2.9.1,<3.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8f69800128d057281ea50ecf75a8f3ca", + "name": "libopencv", + "sha256": "7a4ed1fc2171f1cd609ca9cfa063a1d14a4fda7c2aa22ce876605cfd07641100", + "size": 42165505, + "subdir": "linux-64", + "timestamp": 1533642139251, + "version": "3.4.2" + }, + "libopencv-3.4.2-hb342d67_1.tar.bz2": { + "build": "hb342d67_1", + "build_number": 1, + "depends": [ + "ffmpeg >=4.0,<4.1.0a0", + "freetype >=2.9.1,<3.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cb8d010df2192263488c19492e70d582", + "name": "libopencv", + "sha256": "de901775c5d9de3bb66281ae248e2564c01bef85d8a133031dc1346a7af7d4d2", + "size": 42322561, + "subdir": "linux-64", + "timestamp": 1535561152670, + "version": "3.4.2" + }, + "libopencv-3.4.2-he6673a0_0.tar.bz2": { + "build": "he6673a0_0", + "build_number": 0, + "depends": [ + "ffmpeg >=4.0,<4.1.0a0", + "freetype >=2.9.1,<3.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "hdf5 >=1.8.20,<1.9.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "41ffddc373852cb5a953edcf0e447e8c", + "name": "libopencv", + "sha256": "9c1c93062aa6ee133a252a896d0f0f48ba7cfb20239e2e273f078c064aac4b2d", + "size": 42164073, + "subdir": "linux-64", + "timestamp": 1533643718463, + "version": "3.4.2" + }, + "libopencv-4.5.4-h06a4308_2.tar.bz2": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [ + "opencv >=4.5.4,<4.5.5.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a9d0b45a30304299ce76d1bada71adef", + "name": "libopencv", + "sha256": "f7c7d9c10afc91e963784f30d53d9f19be8aaa766fd55d498089c0e0f2e3d0ca", + "size": 30389, + "subdir": "linux-64", + "timestamp": 1648833842781, + "version": "4.5.4" + }, + "libopencv-4.5.4-h06a4308_3.tar.bz2": { + "build": "h06a4308_3", + "build_number": 3, + "depends": [ + "opencv 4.5.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1361fa105ee8d6963a6fd646cbfb69db", + "name": "libopencv", + "sha256": "bd0ccf863e42d43debdf3d1bcca79e75d0e843fe100a699a9f9135a33f5ea89d", + "size": 30586, + "subdir": "linux-64", + "timestamp": 1648873491917, + "version": "4.5.4" + }, + "libopencv-4.5.5-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a3ffc7b70bc664f4daf0210b09092fb6", + "name": "libopencv", + "sha256": "052d91fb4d2609968e23637ff291ef9d0f954cf5605af77950155b731eed229c", + "size": 10325, + "subdir": "linux-64", + "timestamp": 1652956698046, + "version": "4.5.5" + }, + "libopencv-4.5.5-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d06193ddb56b8ed902b4a300fea73346", + "name": "libopencv", + "sha256": "4ad640409dd98d3c795e4bd8bb2845d2f5f7d25dd7932cf93f1eda4fe4ee0882", + "size": 10448, + "subdir": "linux-64", + "timestamp": 1655908326802, + "version": "4.5.5" + }, + "libopencv-4.5.5-h06a4308_2.tar.bz2": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "755b3a39e8dda4b06681c108cd477030", + "name": "libopencv", + "sha256": "d8eacd69ecc6476e3c1f2c1e4880e8b6cd64b7a133977b30defdf1d1f1e83eea", + "size": 10528, + "subdir": "linux-64", + "timestamp": 1656000399624, + "version": "4.5.5" + }, + "libopencv-4.5.5-h06a4308_3.tar.bz2": { + "build": "h06a4308_3", + "build_number": 3, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e85f959f95e407504324fb1d18916e14", + "name": "libopencv", + "sha256": "81fc5312bd10bbf940b1bf9970a55d990d85dab9250a432c5ad3b0eb74fe665e", + "size": 14174, + "subdir": "linux-64", + "timestamp": 1656607334301, + "version": "4.5.5" + }, + "libopencv-4.5.5-h06a4308_4.tar.bz2": { + "build": "h06a4308_4", + "build_number": 4, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a433cae6fe7d41c4cd434c4bc3090403", + "name": "libopencv", + "sha256": "ab2200f47dc036e64314e70a9900256314f7ce241833225fb5dad6201cc6ac34", + "size": 14228, + "subdir": "linux-64", + "timestamp": 1659975118525, + "version": "4.5.5" + }, + "libopencv-4.6.0-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "opencv 4.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "368313558a689e6c975f8ae9245a4e71", + "name": "libopencv", + "sha256": "82081af6bda2117508d612e4baae06f3cb6a975b57c9a264ececd9b193513d91", + "size": 12584, + "subdir": "linux-64", + "timestamp": 1663874027904, + "version": "4.6.0" + }, + "libopencv-4.6.0-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [ + "opencv 4.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b240d6a54333247e1e450b6c203bb861", + "name": "libopencv", + "sha256": "c70b426207927788e76fdba548f7d47bb82167e1a32da5b716db9cac73405c29", + "size": 12629, + "subdir": "linux-64", + "timestamp": 1664372684059, + "version": "4.6.0" + }, + "libopencv-4.6.0-h06a4308_2.tar.bz2": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [ + "opencv 4.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "57e38ea0c361005fff4b2865987da835", + "name": "libopencv", + "sha256": "16cf14620d217a28c14304a26c92742793ce895bea2eb673796f6f9d472cb85c", + "size": 12615, + "subdir": "linux-64", + "timestamp": 1664550105546, + "version": "4.6.0" + }, + "libopencv-4.6.0-h06a4308_3.tar.bz2": { + "build": "h06a4308_3", + "build_number": 3, + "depends": [ + "opencv 4.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "728efa777d62d98e060349a2584b6266", + "name": "libopencv", + "sha256": "b7d54cd18a6ba7a5a5f7681f0d89cf7a88261dff0ed92eaf71f861c8d04370ed", + "size": 12824, + "subdir": "linux-64", + "timestamp": 1676453511641, + "version": "4.6.0" + }, + "libopus-1.2.1-hb9ed12e_0.tar.bz2": { + "build": "hb9ed12e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "e367950d363102e40b99d0df51aff8b3", + "name": "libopus", + "sha256": "baa45062814a284704a21d355089e347ae636eeef334a6d5798fdb6d1f740ba6", + "size": 390995, + "subdir": "linux-64", + "timestamp": 1512490365561, + "version": "1.2.1" + }, + "libopus-1.3-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "93c4707d18d3625551d03f8b5e5188c1", + "name": "libopus", + "sha256": "37482a4a9ca78450db7ce32f5d8e939da2109ba2b3df5d448f0b7e86e9ff51eb", + "size": 645813, + "subdir": "linux-64", + "timestamp": 1540710911748, + "version": "1.3" + }, + "libopus-1.3.1-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "049062fe7765952d7db02925f43e8fe5", + "name": "libopus", + "sha256": "a3a672e5e39e4e80b99cf015d7118a71907ede3e0f63c74a553552a3a1662f13", + "size": 583934, + "subdir": "linux-64", + "timestamp": 1587129391927, + "version": "1.3.1" + }, + "libpcap-1.10.1-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bd9dc26189f62cd13c2c63ec6cd91c8e", + "name": "libpcap", + "sha256": "aed38e28b44dcb8618b432bf2a5e706702ff7a941f3988126f6ef0fd0daec5fe", + "size": 366882, + "subdir": "linux-64", + "timestamp": 1632843431366, + "version": "1.10.1" + }, + "libpcap-1.9.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dca8d13bc3465326c7fbda00c2814e51", + "name": "libpcap", + "sha256": "725407578f31a5e0ba9af31f3c2d82e6e5c5e6eacc9fae50a75687807b4fe4e0", + "size": 316102, + "subdir": "linux-64", + "timestamp": 1544672066845, + "version": "1.9.0" + }, + "libpcap-1.9.1-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5b0b6c9aebc5597b66883eeb417275ee", + "name": "libpcap", + "sha256": "85df28f553dd92017068c11c81aef99346980b25e7bcc9440f728fd7b5dc4be1", + "size": 320308, + "subdir": "linux-64", + "timestamp": 1573952811358, + "version": "1.9.1" + }, + "libpng-1.6.32-hbd3595f_4.tar.bz2": { + "build": "hbd3595f_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "zlib/libpng", + "md5": "2f948fab393d8fdc320f53ac5b3858af", + "name": "libpng", + "sha256": "50601e5e937ea1c7aa2e999fa63fe288787ba5cb3e17af629eaa1f49a251007f", + "size": 343604, + "subdir": "linux-64", + "timestamp": 1511297717727, + "version": "1.6.32" + }, + "libpng-1.6.32-hda9c8bc_2.tar.bz2": { + "build": "hda9c8bc_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "zlib/libpng", + "md5": "884d20e4f66d9ba2ca809cd2575cf2a6", + "name": "libpng", + "sha256": "1a146ecd1d0ace7bbf409505fa6cdf02af8cddf554d2ea66d67626028a4c0bb5", + "size": 342997, + "subdir": "linux-64", + "timestamp": 1505733443215, + "version": "1.6.32" + }, + "libpng-1.6.34-hb9fc6fc_0.tar.bz2": { + "build": "hb9fc6fc_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "zlib/libpng", + "md5": "addc91d81ee975acf95c162604b5487b", + "name": "libpng", + "sha256": "3c4a4558b7600abef0a533ad2a191399873a6c516c2bd2110852312900467c12", + "size": 341708, + "subdir": "linux-64", + "timestamp": 1516738379327, + "version": "1.6.34" + }, + "libpng-1.6.35-hbc83047_0.tar.bz2": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "zlib/libpng", + "md5": "02c212c6524e198600bec09327ac25e6", + "name": "libpng", + "sha256": "a1cf70069cd918ee8469af2f0cf05fd02147c8724c7de0c77d404d248b2bfe26", + "size": 343294, + "subdir": "linux-64", + "timestamp": 1539728120355, + "version": "1.6.35" + }, + "libpng-1.6.36-hbc83047_0.tar.bz2": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "zlib/libpng", + "md5": "8835b3307004ea77bf58dbd8d6817d5c", + "name": "libpng", + "sha256": "30e52b992aafa37cfb37c69ad4d970ebf002ef19243520c7609d135a73df1a37", + "size": 354154, + "subdir": "linux-64", + "timestamp": 1547234458119, + "version": "1.6.36" + }, + "libpng-1.6.37-hbc83047_0.tar.bz2": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "zlib/libpng", + "md5": "9cb85601944ca7383b1769bff74b94e8", + "name": "libpng", + "sha256": "bc3e6e79c32ff0ecea601aa108ae9cf4068f69703580e40e266ad4bcc52cff54", + "size": 372914, + "subdir": "linux-64", + "timestamp": 1556041895170, + "version": "1.6.37" + }, + "libpng-1.6.39-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Zlib", + "license_family": "Other", + "md5": "1bffe1481ed4f88827248fb9001f8923", + "name": "libpng", + "sha256": "e57061a1f4d0f69b774fc0050c7799ca75e241113f8b68f1504ce967f3a73c2e", + "size": 362561, + "subdir": "linux-64", + "timestamp": 1677841789536, + "version": "1.6.39" + }, + "libpq-10.3-h1ad7b7a_0.tar.bz2": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16,<1.17.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "869301138c9a569604b8097c4b8d65ef", + "name": "libpq", + "sha256": "56884c7590d54350b1bf3ee1298778918593c5ee060e09c51324f10761a00544", + "size": 2795476, + "subdir": "linux-64", + "timestamp": 1522426547287, + "version": "10.3" + }, + "libpq-10.4-h1ad7b7a_0.tar.bz2": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "99f8dce3a0c1a7be562683de55d3ef82", + "name": "libpq", + "sha256": "550f5ce51b9f346f28c8836558929b8e6553302a4b5da9c1f4093f5b1d7d1726", + "size": 2794960, + "subdir": "linux-64", + "timestamp": 1532852628907, + "version": "10.4" + }, + "libpq-10.5-h1ad7b7a_0.tar.bz2": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2p,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "ac524f35d049f034ce93a1a0a71e116f", + "name": "libpq", + "sha256": "a96a7c7e058ae012562adadc95fbf9a9faf797271a4de5bb1d54338ea2f9449b", + "size": 2797933, + "subdir": "linux-64", + "timestamp": 1534394926184, + "version": "10.5" + }, + "libpq-11.1-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "642f4870479a45480096f822490bba76", + "name": "libpq", + "sha256": "e2f569e9196de7047bba98f11d0ba411a782e3351ebd8c6071fd3646719e31f7", + "size": 2741353, + "subdir": "linux-64", + "timestamp": 1545233706751, + "version": "11.1" + }, + "libpq-11.2-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1b,<1.1.2a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "8995e9bf5a3f9739f76dff0614523346", + "name": "libpq", + "sha256": "1cac1ebdf0aeae06af97b69acecfe2d120ba758bb83cb11c9bf0aefa5fcd4118", + "size": 2789656, + "subdir": "linux-64", + "timestamp": 1552511043783, + "version": "11.2" + }, + "libpq-12.2-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.17.1,<1.18.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "7cc9cc5aabd3579a151837c31f63f650", + "name": "libpq", + "sha256": "c675c685ab7bca78252c72e3e983c42816a39f8c39e7ed4a78dd3decd6d773f6", + "size": 2946891, + "subdir": "linux-64", + "timestamp": 1582128055574, + "version": "12.2" + }, + "libpq-12.2-h553bfba_1.tar.bz2": { + "build": "h553bfba_1", + "build_number": 1, + "depends": [ + "krb5 >=1.19.1,<1.20.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "md5": "1093a7b6265253eed2d6213964b2ffdb", + "name": "libpq", + "sha256": "6a0ca51040bd79bcfaabeee98da98a29d31ea2df139a004c1dd62b5d91d0a82d", + "size": 2976582, + "subdir": "linux-64", + "timestamp": 1621644106995, + "version": "12.2" + }, + "libpq-12.9-h16c4e8d_3.tar.bz2": { + "build": "h16c4e8d_3", + "build_number": 3, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=11.2.0", + "openssl >=1.1.1o,<1.1.2a", + "readline >=8.0,<9.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "md5": "9a937973dc627e6d2d1f29b73fb714ca", + "name": "libpq", + "sha256": "695af65c21fc3a09d9e54a62bf0dad38ddec85e08b90e977c57d5decce2c2e8f", + "size": 2956023, + "subdir": "linux-64", + "timestamp": 1656062943598, + "version": "12.9" + }, + "libpq-12.9-hc2c5182_1.tar.bz2": { + "build": "hc2c5182_1", + "build_number": 1, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "992bb6ef393c62bb0076d97b27f5a45f", + "name": "libpq", + "sha256": "dbab8bf30f1345546f8b09e624672c0964867cd894e4d676bbdcbdf5589c34fc", + "size": 2950552, + "subdir": "linux-64", + "timestamp": 1638892697693, + "version": "12.9" + }, + "libpq-12.9-hc2c5182_2.tar.bz2": { + "build": "hc2c5182_2", + "build_number": 2, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1o,<1.1.2a", + "readline >=8.0,<9.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "md5": "3912de5f8ecbc526228146d3edff2162", + "name": "libpq", + "sha256": "f07555b0450d8869006b598091b958dd08adf7a00dd64c3945a1c7976ffa39c1", + "size": 2953122, + "subdir": "linux-64", + "timestamp": 1655472390761, + "version": "12.9" + }, + "libpq-9.5.10-h88a1faf_0.tar.bz2": { + "build": "h88a1faf_0", + "build_number": 0, + "depends": [ + "openssl >=1.0.2m,<1.0.3a" + ], + "license": "PostgreSQL", + "md5": "8d593a0fb170a56936cbc98ed007b215", + "name": "libpq", + "sha256": "0714abafc4aa49b1ba4f42880d8e86891f16fb61f94365b8b3dc1c8ceda47bad", + "size": 101124, + "subdir": "linux-64", + "timestamp": 1510351488790, + "version": "9.5.10" + }, + "libpq-9.6.6-h1f21990_0.tar.bz2": { + "build": "h1f21990_0", + "build_number": 0, + "depends": [ + "openssl >=1.0.2m,<1.0.3a" + ], + "license": "PostgreSQL", + "md5": "f66d40076d77668a5ef8bd4a620e1a96", + "name": "libpq", + "sha256": "85e4a253625a69ef97c5ac9bb423bac64ffa833f3002a442f4c25726b38db6c1", + "size": 102703, + "subdir": "linux-64", + "timestamp": 1510610960868, + "version": "9.6.6" + }, + "libpq-9.6.6-h4e02ad2_0.tar.bz2": { + "build": "h4e02ad2_0", + "build_number": 0, + "depends": [ + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a" + ], + "license": "PostgreSQL", + "md5": "1e2ce86d6ee874caf9a72b9d60f5c2c4", + "name": "libpq", + "sha256": "95daab4821e7cae8082832859d091813b554f6713ffddf5556a08f38f823f301", + "size": 102966, + "subdir": "linux-64", + "timestamp": 1511817098958, + "version": "9.6.6" + }, + "libpq-9.6.6-h60b3205_0.tar.bz2": { + "build": "h60b3205_0", + "build_number": 0, + "depends": [ + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a" + ], + "license": "PostgreSQL", + "md5": "08187b637e65b31dfa83ba2a75643207", + "name": "libpq", + "sha256": "12dfd920fa6b6a8dcb2dc6ed88b335c58ff7c69ff5c08e8e03d0488308e1d502", + "size": 102970, + "subdir": "linux-64", + "timestamp": 1511386899875, + "version": "9.6.6" + }, + "libprotobuf-3.10.1-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "37c89010c0fa0876a52724a158c8c2f0", + "name": "libprotobuf", + "sha256": "e7da2c447c2804f8a7feba8d4b97164334202a6bdfd666abddd0ac0a9688962b", + "size": 5017303, + "subdir": "linux-64", + "timestamp": 1573966987405, + "version": "3.10.1" + }, + "libprotobuf-3.11.2-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0cb203fe2cf64272f676d502fe735282", + "name": "libprotobuf", + "sha256": "49de2670c8035b28619dc023b3cbf32bb5af9bfaefc80ddc06bfe4f242acfff5", + "size": 5055824, + "subdir": "linux-64", + "timestamp": 1576541584171, + "version": "3.11.2" + }, + "libprotobuf-3.11.3-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d1dc972745365188a570825ca18f2384", + "name": "libprotobuf", + "sha256": "a755cf820f9265bbbf5fc84f402acac503ef11d988d7ecf0f48a3c204b290c13", + "size": 5047033, + "subdir": "linux-64", + "timestamp": 1581538747478, + "version": "3.11.3" + }, + "libprotobuf-3.11.4-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b67eca258bd0c43a1f943bc704cf82b9", + "name": "libprotobuf", + "sha256": "63e0631b94f1796038990cc9d58d986c5d79191dbba0eafe363e44b284b7b4ac", + "size": 5038393, + "subdir": "linux-64", + "timestamp": 1581952301358, + "version": "3.11.4" + }, + "libprotobuf-3.12.3-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "becd93d45e34eaa6bb52749cc7a930d8", + "name": "libprotobuf", + "sha256": "b3df56d5dac494f88b897025f140bb74af9936ac0c4f6d47d798df404269f7c7", + "size": 5082923, + "subdir": "linux-64", + "timestamp": 1591836337062, + "version": "3.12.3" + }, + "libprotobuf-3.12.4-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6e7b47d9fc57f80fce63e51716251236", + "name": "libprotobuf", + "sha256": "434215f44d7e59b664901f6793c105e935d7ea85e01738331e00f8a2699ae00a", + "size": 2439013, + "subdir": "linux-64", + "timestamp": 1597429722973, + "version": "3.12.4" + }, + "libprotobuf-3.13.0-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f33e6a8688c5b9702c2af317fa9fec7b", + "name": "libprotobuf", + "sha256": "6080217ed4ec3883baf61ec9a769b41ad1b0aa0933c944110f4c2aef6c4384fb", + "size": 2464822, + "subdir": "linux-64", + "timestamp": 1597784395651, + "version": "3.13.0" + }, + "libprotobuf-3.13.0.1-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b10742b62fe64077b42073326cb50c13", + "name": "libprotobuf", + "sha256": "b464b8c74c69db11d51b4c14d6899a43ff975c7784ea04765ba78a4ab00c1f04", + "size": 2437432, + "subdir": "linux-64", + "timestamp": 1602519676737, + "version": "3.13.0.1" + }, + "libprotobuf-3.14.0-h8c45485_0.tar.bz2": { + "build": "h8c45485_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2e283f51a76edf59a8713dcddef470c9", + "name": "libprotobuf", + "sha256": "3ee924bb32d454b59d3cb1e08e365a02ea9aaa50368696856765df5c27670b52", + "size": 2479347, + "subdir": "linux-64", + "timestamp": 1607036010369, + "version": "3.14.0" + }, + "libprotobuf-3.17.2-h4ff587b_1.tar.bz2": { + "build": "h4ff587b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8dc2785982173854a2228daeaaa812b4", + "name": "libprotobuf", + "sha256": "0c2b2e1955497cc03e33496226aceddf57d28f5829324985c5bdd998e00b48ed", + "size": 2484951, + "subdir": "linux-64", + "timestamp": 1626458853901, + "version": "3.17.2" + }, + "libprotobuf-3.19.1-h4ff587b_0.tar.bz2": { + "build": "h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dbd09044841fcf2326df088778455890", + "name": "libprotobuf", + "sha256": "34bd95ea13f45b31c90f86a6aa192b29ffa9180159d89cf0a4cb91bc4b3751c8", + "size": 2613747, + "subdir": "linux-64", + "timestamp": 1640021836928, + "version": "3.19.1" + }, + "libprotobuf-3.19.6-he621ea3_0.tar.bz2": { + "build": "he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c77fb270f8a701fffbeb3a6cc3bd8dc9", + "name": "libprotobuf", + "sha256": "eaa589b4046c97aa9be458408272317036d3848dfe739dae4715ee488069babc", + "size": 2688348, + "subdir": "linux-64", + "timestamp": 1675278885796, + "version": "3.19.6" + }, + "libprotobuf-3.20.1-h4ff587b_0.tar.bz2": { + "build": "h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "841f646db03356d1b08b9673bf037d09", + "name": "libprotobuf", + "sha256": "1cbe876d9d79caf035cbd5f5114448b8c13981dd46b5eff99b8f6092fcce7da6", + "size": 2571454, + "subdir": "linux-64", + "timestamp": 1652364394785, + "version": "3.20.1" + }, + "libprotobuf-3.20.3-he621ea3_0.tar.bz2": { + "build": "he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b32a43de76bc9be9c71f9a12edec8a1e", + "name": "libprotobuf", + "sha256": "a24f7d1cdb5e18466a61860a5a66baffd608e212bbfed2935350e83d4d8659c0", + "size": 2706964, + "subdir": "linux-64", + "timestamp": 1675278653314, + "version": "3.20.3" + }, + "libprotobuf-3.4.1-h5b8497f_0.tar.bz2": { + "build": "h5b8497f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "license_family": "BSD", + "md5": "a60131685713bc0fdf552a5a2ba2ed12", + "name": "libprotobuf", + "sha256": "be369c610ee68ad3fe4e7510e900bfb38df2e4c1970e9465ded6872f6de894cc", + "size": 4233998, + "subdir": "linux-64", + "timestamp": 1510782278543, + "version": "3.4.1" + }, + "libprotobuf-3.5.1-h6f1eeef_0.tar.bz2": { + "build": "h6f1eeef_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "license_family": "BSD", + "md5": "d87c2333cefb153714d547ba13355f6e", + "name": "libprotobuf", + "sha256": "41371b87ede2188ecf07aee7dc134dfb05e4f6d2e5e5909d6d6944f2a6abdf0f", + "size": 4394941, + "subdir": "linux-64", + "timestamp": 1519949265457, + "version": "3.5.1" + }, + "libprotobuf-3.5.2-h6f1eeef_0.tar.bz2": { + "build": "h6f1eeef_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eeb8c91691f7b11f4d11d9297fdd53f4", + "name": "libprotobuf", + "sha256": "6c71085ec3a27f98cbe4097ec007fb474d0f1ddbe459ec16433165bd8f69ac59", + "size": 4392387, + "subdir": "linux-64", + "timestamp": 1523041234939, + "version": "3.5.2" + }, + "libprotobuf-3.6.0-hdbcaa40_0.tar.bz2": { + "build": "hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "001be3c6e17c8b8e108ff434ce9848be", + "name": "libprotobuf", + "sha256": "a447dddfe94d5cebd6cabc79f3bf022edd00056d6c6679b4ec06bd5b8107fe40", + "size": 4252071, + "subdir": "linux-64", + "timestamp": 1534345787089, + "version": "3.6.0" + }, + "libprotobuf-3.6.1-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2feae33f95ee6a58ac943901d3b0c319", + "name": "libprotobuf", + "sha256": "7eab1dc4285ed1b8cd18f7d01576841078db2303c6b5ed3438c2b20143b2c517", + "size": 4262103, + "subdir": "linux-64", + "timestamp": 1541097651174, + "version": "3.6.1" + }, + "libprotobuf-3.7.1-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "68fa89c34e94db7d089245c81f0d18a6", + "name": "libprotobuf", + "sha256": "6bbe1e4d87f83672a51b5a75d04a35651d21fd0aa5dec38da9a328401ddd7858", + "size": 4890953, + "subdir": "linux-64", + "timestamp": 1556563621034, + "version": "3.7.1" + }, + "libprotobuf-3.8.0-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22b39b2f83077ea8274a8895771f323a", + "name": "libprotobuf", + "sha256": "e58de32db4e1b0b7bbd92ab8834b26868c384295d657f9389690b895a0d48c97", + "size": 4919786, + "subdir": "linux-64", + "timestamp": 1559918744508, + "version": "3.8.0" + }, + "libprotobuf-3.9.1-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c880f7ade08a1297f5c03e599f8f6a4e", + "name": "libprotobuf", + "sha256": "2eb1f21c1270cf54ba7c2ee6c51c53bd21171a08c8cf4fc7f5633985d9092d37", + "size": 4929544, + "subdir": "linux-64", + "timestamp": 1567109403157, + "version": "3.9.1" + }, + "libprotobuf-3.9.2-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38b296961dd9bac4c6b1886e811b8d91", + "name": "libprotobuf", + "sha256": "e3b1b6b85bea52808cc3ce8ac9095e23c2d610a13efda798befa88782b3d7167", + "size": 4955359, + "subdir": "linux-64", + "timestamp": 1569267961253, + "version": "3.9.2" + }, + "libprotobuf-static-3.12.4-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "23b72ba20029189aad12c26d26d406c4", + "name": "libprotobuf-static", + "sha256": "a178d9ade9764cc97143902c909082ecbd6de700fe79c46aaf21ef01c91270b0", + "size": 2633558, + "subdir": "linux-64", + "timestamp": 1597429728661, + "version": "3.12.4" + }, + "libprotobuf-static-3.13.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "19386a784b19e30c4a9df6fa0e10a7d3", + "name": "libprotobuf-static", + "sha256": "6cd59a434fec5505e2f4079dd6d0e8d00e452e5b40760474c4e2b385a3262da7", + "size": 2650179, + "subdir": "linux-64", + "timestamp": 1597784401112, + "version": "3.13.0" + }, + "libprotobuf-static-3.13.0.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "709ed2798d98205ddfa6fb96d7336018", + "name": "libprotobuf-static", + "sha256": "864112a84cf229d59c57224a4d355653959776fb4bd14c485ce04f228fa4262d", + "size": 2640949, + "subdir": "linux-64", + "timestamp": 1602519682292, + "version": "3.13.0.1" + }, + "libprotobuf-static-3.14.0-h8c45485_0.tar.bz2": { + "build": "h8c45485_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9659cf6a1854c927863a4cc6ef74b946", + "name": "libprotobuf-static", + "sha256": "1b07140f141ba939b113007ba3fd465827535a3341fc91915c01153a814d08f5", + "size": 2667653, + "subdir": "linux-64", + "timestamp": 1607036023164, + "version": "3.14.0" + }, + "libprotobuf-static-3.17.2-h4ff587b_1.tar.bz2": { + "build": "h4ff587b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.17.2 h4ff587b_1", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "061cc32a8b24e78391c47ee95d0e8318", + "name": "libprotobuf-static", + "sha256": "18d718e9685731146b4b211cf2088568e16a31ba22ce722447c6175394622081", + "size": 2692230, + "subdir": "linux-64", + "timestamp": 1626458864563, + "version": "3.17.2" + }, + "libprotobuf-static-3.19.1-h4ff587b_0.tar.bz2": { + "build": "h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.19.1 h4ff587b_0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eb346a1f59ae15832ff0f79f116b0e8e", + "name": "libprotobuf-static", + "sha256": "743133b464e0e43e53ab61b57b5aa262deaeee1f36d4d16a34829b8089f0a3ea", + "size": 2798325, + "subdir": "linux-64", + "timestamp": 1640021848894, + "version": "3.19.1" + }, + "libprotobuf-static-3.19.6-he621ea3_0.tar.bz2": { + "build": "he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.19.6 he621ea3_0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f7c326538a00196e3855ca30506b8190", + "name": "libprotobuf-static", + "sha256": "70b44de0a1e791a92dcc71a64422917df9ce48bdcd109b7b095ee4356fcf80ef", + "size": 2884746, + "subdir": "linux-64", + "timestamp": 1675278897243, + "version": "3.19.6" + }, + "libprotobuf-static-3.20.1-h4ff587b_0.tar.bz2": { + "build": "h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.20.1 h4ff587b_0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "666d4d8450e48f378ae1b4293273a925", + "name": "libprotobuf-static", + "sha256": "25b4ab5e55070b11f91f0c63e9cda9dfd1ded56bbe4cb316df45516e99bc814c", + "size": 2785979, + "subdir": "linux-64", + "timestamp": 1652364404266, + "version": "3.20.1" + }, + "libprotobuf-static-3.20.3-he621ea3_0.tar.bz2": { + "build": "he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.20.3 he621ea3_0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ad8fb9484908c18444d71bc31671af6c", + "name": "libprotobuf-static", + "sha256": "b1b97315fc480e5fa9af8a0fb63179f8c771ef4df958337d120fd1e9b07d5b5d", + "size": 2921272, + "subdir": "linux-64", + "timestamp": 1675278664195, + "version": "3.20.3" + }, + "libprotobuf-static-3.6.0-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f92f2c1902f75db60d2d2a46b490e8fc", + "name": "libprotobuf-static", + "sha256": "0d4a65fefa1d85310ac9805755bef93615452de54e40e18341639a1db3dde70e", + "size": 3621203, + "subdir": "linux-64", + "timestamp": 1537898286405, + "version": "3.6.0" + }, + "libprotobuf-static-3.7.1-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "71ff5cef00a7e3b7f3bb23f01e3344e4", + "name": "libprotobuf-static", + "sha256": "1178d6877961106b14b37e5d54be4b269dcef18a433fd41738a70778670cbc88", + "size": 4228822, + "subdir": "linux-64", + "timestamp": 1556562968499, + "version": "3.7.1" + }, + "libpython-static-3.10.0-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0 h12debd9_0" + ], + "license": "Python-2.0", + "md5": "316b823a397ba533bb7ee899dde0f23e", + "name": "libpython-static", + "sha256": "8c0e64a1124efa77147780b51122a46496bdd9a24a3da4aac86af0d663407568", + "size": 68933477, + "subdir": "linux-64", + "timestamp": 1633415507473, + "version": "3.10.0" + }, + "libpython-static-3.10.0-h295c915_1.tar.bz2": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0 h12debd9_1" + ], + "license": "Python-2.0", + "md5": "cfa0e071f5b9725f16933319bbf5b15d", + "name": "libpython-static", + "sha256": "5dd1edbeea42b0be01aee42d9ae2b41f638547e318acd32e9c32827dc212807f", + "size": 68959381, + "subdir": "linux-64", + "timestamp": 1633606556586, + "version": "3.10.0" + }, + "libpython-static-3.10.0-h295c915_2.tar.bz2": { + "build": "h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0 h12debd9_2" + ], + "license": "Python-2.0", + "md5": "3604271c6ed19d352c0edf8778722ff8", + "name": "libpython-static", + "sha256": "3bfb8ab365f028b4ac22dc82c67d705469086c2fea9d66940c0eec70720c8cdd", + "size": 68945430, + "subdir": "linux-64", + "timestamp": 1636442381046, + "version": "3.10.0" + }, + "libpython-static-3.10.0-h295c915_4.tar.bz2": { + "build": "h295c915_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0 h12debd9_4" + ], + "license": "Python-2.0", + "md5": "abbe454e4f2b699a81ed27a7f39bc2b6", + "name": "libpython-static", + "sha256": "0cfabe5215567ccc372959d3b2f4447e88004907bdf8f4ff17043aedcdc3e5c9", + "size": 68870393, + "subdir": "linux-64", + "timestamp": 1640094533106, + "version": "3.10.0" + }, + "libpython-static-3.10.0-h295c915_5.tar.bz2": { + "build": "h295c915_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0 h12debd9_5" + ], + "license": "Python-2.0", + "md5": "12ffa2ee76f1867a1edc2771c7071f71", + "name": "libpython-static", + "sha256": "0540bfab9fd9263a9fca0968474d582e191d1ef2fef6d7a22b493b7988333471", + "size": 68866061, + "subdir": "linux-64", + "timestamp": 1646302135485, + "version": "3.10.0" + }, + "libpython-static-3.10.0-hdbfa776_3.tar.bz2": { + "build": "hdbfa776_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0 h151d27f_3" + ], + "license": "Python-2.0", + "md5": "75baaa3dcec8fb4b9265d822a9ba4529", + "name": "libpython-static", + "sha256": "ad64ed31f758723f035c517def79d69b35e134bd9c7d558cd2497c5259c6d513", + "size": 68976820, + "subdir": "linux-64", + "timestamp": 1636572516532, + "version": "3.10.0" + }, + "libpython-static-3.10.10-h6a678d5_2.tar.bz2": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0 h7a1cb2a_2" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "c0fdbd6ae45ea5293ff8a156e1bfd23e", + "name": "libpython-static", + "sha256": "ce979437fd0b9e2ffe96f91679cd23679764d0086f4b41eb5449b7a655cef0dd", + "size": 62585005, + "subdir": "linux-64", + "timestamp": 1679425062401, + "version": "3.10.10" + }, + "libpython-static-3.10.3-h295c915_5.tar.bz2": { + "build": "h295c915_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0 h12debd9_5" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "b32d8b2a2706e207a8a4910b12127a0f", + "name": "libpython-static", + "sha256": "7e86de56fad90f8787d708949fb45f76177a2632b8ebb2031f76b0c7c5295a29", + "size": 69576453, + "subdir": "linux-64", + "timestamp": 1648460496638, + "version": "3.10.3" + }, + "libpython-static-3.10.4-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0 h12debd9_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "c1654b841b285c0e80aafd1bf0d5b64f", + "name": "libpython-static", + "sha256": "4753ee49ea4e8b67a8caca2a46fbd51cce76de5b4be782f31f29f17955742e67", + "size": 69573412, + "subdir": "linux-64", + "timestamp": 1648716787786, + "version": "3.10.4" + }, + "libpython-static-3.10.6-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0 haa1d7c7_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "16ee14b1a46504568870932a60010826", + "name": "libpython-static", + "sha256": "538b924313e67d039dfc320b0f1a31c9ca2979dfcb774ad290657ae7a1901836", + "size": 62540495, + "subdir": "linux-64", + "timestamp": 1665174716129, + "version": "3.10.6" + }, + "libpython-static-3.10.6-h6a678d5_1.tar.bz2": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0 haa1d7c7_1" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "fbf5c814eb141768382eedaa6d961e8a", + "name": "libpython-static", + "sha256": "a3ca7767e956dc42918d2c44e8be88a74d4bc53a7c65704e76772bd22979a145", + "size": 62534316, + "subdir": "linux-64", + "timestamp": 1666628402870, + "version": "3.10.6" + }, + "libpython-static-3.10.8-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0 haa1d7c7_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "f99b78ca49e00888dae6225ede7c5932", + "name": "libpython-static", + "sha256": "edb774e82f718714d813104393494aef435490c59cc7181f3b46529e6fd8cb95", + "size": 62580667, + "subdir": "linux-64", + "timestamp": 1667570424472, + "version": "3.10.8" + }, + "libpython-static-3.10.8-h6a678d5_1.tar.bz2": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0 h7a1cb2a_1" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "1526a5fda6ec6751724b53708de10bdb", + "name": "libpython-static", + "sha256": "3d006efc6e3b1c4cdbd19560f543e442f4d56723b0e233c98e705b0fc7e5491f", + "size": 62589481, + "subdir": "linux-64", + "timestamp": 1669299944919, + "version": "3.10.8" + }, + "libpython-static-3.10.9-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0 h7a1cb2a_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "9f59db08f65585b9e3dce1236c716364", + "name": "libpython-static", + "sha256": "03e237bd4b26b73422bcf3d2d986dce1018992b7ffd9ec8d69a9374be3ddd841", + "size": 62587171, + "subdir": "linux-64", + "timestamp": 1673451245342, + "version": "3.10.9" + }, + "libpython-static-3.10.9-h6a678d5_1.tar.bz2": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0 h7a1cb2a_1" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "209da1e906da3664530abe06a4592fd4", + "name": "libpython-static", + "sha256": "3b44b322f229260f4b1c065c37260224a9882d7536bed107f74e19b182edb5b1", + "size": 62587912, + "subdir": "linux-64", + "timestamp": 1677695724289, + "version": "3.10.9" + }, + "libpython-static-3.10.9-h6a678d5_2.tar.bz2": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0 h7a1cb2a_2" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "dfd3bc5c0712952b2212985fe569b35f", + "name": "libpython-static", + "sha256": "189cae56cd6ce894cc220681ec286d89235a0e056078932de8441a852b532b69", + "size": 62594871, + "subdir": "linux-64", + "timestamp": 1678273164882, + "version": "3.10.9" + }, + "libpython-static-3.11.0-h6a678d5_2.tar.bz2": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0 h7a1cb2a_2" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "9baa0e04f54ef4067a266434a19f218e", + "name": "libpython-static", + "sha256": "268437e3620025583a78c5a9bc4dcd7ddf4bfd924b4d0dc5bd14e31a45aba664", + "size": 85558378, + "subdir": "linux-64", + "timestamp": 1673879797077, + "version": "3.11.0" + }, + "libpython-static-3.11.0-h6a678d5_3.tar.bz2": { + "build": "h6a678d5_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0 h7a1cb2a_3" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "cc249180caec6f481ad701dd31a634ab", + "name": "libpython-static", + "sha256": "d0db24f37ae73ea7a0dcb6e87bec2e532a4b9bb77686a983e1d50ca567f084e8", + "size": 85563180, + "subdir": "linux-64", + "timestamp": 1677696192007, + "version": "3.11.0" + }, + "libpython-static-3.11.2-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0 h7a1cb2a_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "1110747ff7b1f0bbf26e0e74c679b42d", + "name": "libpython-static", + "sha256": "cf665722443e4483fa188c4d6fd86fa44110cffc268e7ee1271cddc96f96dec5", + "size": 85637514, + "subdir": "linux-64", + "timestamp": 1679961560002, + "version": "3.11.2" + }, + "libpython-static-3.8.11-h295c915_0_cpython.tar.bz2": { + "build": "h295c915_0_cpython", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0 h12debd9_0_cpython" + ], + "license": "Python-2.0", + "md5": "3ee031729896699a78da1d0bdab5db8e", + "name": "libpython-static", + "sha256": "365330641915674484d90a6e95efbe2f11189159f90bf6209005227ad5f71e7c", + "size": 60254821, + "subdir": "linux-64", + "timestamp": 1628004061150, + "version": "3.8.11" + }, + "libpython-static-3.8.12-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0 h12debd9_0" + ], + "license": "Python-2.0", + "md5": "c08c02bc1a8ff6dbec298d607ab80fa6", + "name": "libpython-static", + "sha256": "0ef44c8238f11cc4bc785929874341825c9dd0adc3994537495d58f3cb000f1b", + "size": 60139635, + "subdir": "linux-64", + "timestamp": 1634047274729, + "version": "3.8.12" + }, + "libpython-static-3.8.13-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0 h12debd9_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "d18b8ae8e45b9a81741830db8ebb7e7c", + "name": "libpython-static", + "sha256": "bd28c30c28343091a9a83d00d513f040846539f09ee9a115cf077a628357faf8", + "size": 60120964, + "subdir": "linux-64", + "timestamp": 1648468116406, + "version": "3.8.13" + }, + "libpython-static-3.8.13-h6a678d5_1.tar.bz2": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0 haa1d7c7_1" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "b8b1ebebded6ddb1aec1d6baa53dc66c", + "name": "libpython-static", + "sha256": "887ceb11178f40bc6a93f9e4df2b175c5dea9d43c7dab6f114075310507fa060", + "size": 51448172, + "subdir": "linux-64", + "timestamp": 1666397003349, + "version": "3.8.13" + }, + "libpython-static-3.8.15-h3fd9d12_0.tar.bz2": { + "build": "h3fd9d12_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0 h3fd9d12_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "3adb5ccd4347570e8b10b188692ae440", + "name": "libpython-static", + "sha256": "736396826d41b969e599407ab5fc6cff85b9aa8be79bd5d87aff362e257f20a3", + "size": 51509378, + "subdir": "linux-64", + "timestamp": 1667596323330, + "version": "3.8.15" + }, + "libpython-static-3.8.15-h6a678d5_2.tar.bz2": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0 h7a1cb2a_2" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "f1059006b0c59fe0897babec58aef098", + "name": "libpython-static", + "sha256": "509f256147a3555ec1bda99c21b9e526a0ca1bf6005ed2f13de4b062c82ce0b8", + "size": 51497296, + "subdir": "linux-64", + "timestamp": 1669303882150, + "version": "3.8.15" + }, + "libpython-static-3.8.16-h6a678d5_2.tar.bz2": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0 h7a1cb2a_2" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "5341ec21fff887a808276065edb9271f", + "name": "libpython-static", + "sha256": "3849459fbd3cf145c63fff7690628456dfffbaa6a0084d9e7d2144fd1da343ec", + "size": 51495481, + "subdir": "linux-64", + "timestamp": 1673997802345, + "version": "3.8.16" + }, + "libpython-static-3.8.16-h6a678d5_3.tar.bz2": { + "build": "h6a678d5_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0 h7a1cb2a_3" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "cf8ba2c9f84af36a1b8a5325f83ed740", + "name": "libpython-static", + "sha256": "a404ac6d83a25aa6c156832c81e3de3731ac3a27b37fdb1dc568916b22582474", + "size": 51310491, + "subdir": "linux-64", + "timestamp": 1677727933984, + "version": "3.8.16" + }, + "libpython-static-3.9.0-h2531618_2.tar.bz2": { + "build": "h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0 hdb3f193_2" + ], + "license": "Python-2.0", + "md5": "a95cec9d6543b776af86c9d464a76c42", + "name": "libpython-static", + "sha256": "788f096393203e4740bf7307ae7e7ef9d0b3db38e376424cfc60b3cae0dfeb99", + "size": 63722110, + "subdir": "linux-64", + "timestamp": 1605451303688, + "version": "3.9.0" + }, + "libpython-static-3.9.0-he6710b0_1.tar.bz2": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0 hcff3b4d_1" + ], + "license": "Python-2.0", + "md5": "c52074e28d8681c9a4ba34e1cffaae25", + "name": "libpython-static", + "sha256": "06497be7d1cf4a75b434b4526398282ac672666a3ccbadb430c714e80149f790", + "size": 63950675, + "subdir": "linux-64", + "timestamp": 1603370153193, + "version": "3.9.0" + }, + "libpython-static-3.9.1-h2531618_2.tar.bz2": { + "build": "h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0 hdb3f193_2" + ], + "license": "Python-2.0", + "md5": "33f65bc5394a07579537097ca370af84", + "name": "libpython-static", + "sha256": "7070dcf8cdd959204c6c7f1131d6d686616fa5af2513536b9f394f7f21bb1080", + "size": 63614520, + "subdir": "linux-64", + "timestamp": 1607697753382, + "version": "3.9.1" + }, + "libpython-static-3.9.11-h295c915_1.tar.bz2": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0 h12debd9_1" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "370a2a19977be60d7e753e332830ecc3", + "name": "libpython-static", + "sha256": "4d88fdc7cd119c4e301d6b96df92c60c68678cb98d9d7becc177975853b08424", + "size": 64258074, + "subdir": "linux-64", + "timestamp": 1648462888618, + "version": "3.9.11" + }, + "libpython-static-3.9.11-h295c915_2.tar.bz2": { + "build": "h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0 h12debd9_2" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "823a00bf5fdead2cad708ecc7e88ee0f", + "name": "libpython-static", + "sha256": "950e60cb75a1a3f50b9e20515dc86d79fa35b56684628121e5506c89a44ab968", + "size": 64241813, + "subdir": "linux-64", + "timestamp": 1648581561448, + "version": "3.9.11" + }, + "libpython-static-3.9.12-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0 h12debd9_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "bb3f7958c7e47333b8f3186be6619634", + "name": "libpython-static", + "sha256": "728e9615e19c6ed4000aa7059861435634b9074093c7ccec3ac57657fd95b126", + "size": 64339304, + "subdir": "linux-64", + "timestamp": 1649142471890, + "version": "3.9.12" + }, + "libpython-static-3.9.12-h295c915_1.tar.bz2": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0 h12debd9_1" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "6188456441d1592a6f8f61b3d2ff1b74", + "name": "libpython-static", + "sha256": "4c76ad907aee4aecc26c0ae020c0bba6ac6fd4c7352027c5d01ec3b808318770", + "size": 64290797, + "subdir": "linux-64", + "timestamp": 1654084193324, + "version": "3.9.12" + }, + "libpython-static-3.9.13-h6a678d5_1.tar.bz2": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0 haa1d7c7_1" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "bb811ed2e90492e3ce148a1f3991353a", + "name": "libpython-static", + "sha256": "889e599042a36c17c10aa21df5c706390edacf5ab2410c246affe1eeba34f34f", + "size": 56765829, + "subdir": "linux-64", + "timestamp": 1661470694890, + "version": "3.9.13" + }, + "libpython-static-3.9.13-h6a678d5_2.tar.bz2": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0 haa1d7c7_2" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "beeb55f6573a10431ca9a847ff4b3266", + "name": "libpython-static", + "sha256": "5b80eeabcea02dc0ef85a06ec2c34cf5e0ac69214478ffb302519e61de853328", + "size": 56751572, + "subdir": "linux-64", + "timestamp": 1665696384158, + "version": "3.9.13" + }, + "libpython-static-3.9.15-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0 haa1d7c7_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "752f37cd378b16f4855842b570a45133", + "name": "libpython-static", + "sha256": "d0e2b9e8644fe06a6b2ffc8b828f1cf267bec1cd7d0276ee3907bd3192dd4708", + "size": 56801034, + "subdir": "linux-64", + "timestamp": 1667579118299, + "version": "3.9.15" + }, + "libpython-static-3.9.15-h6a678d5_2.tar.bz2": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0 h7a1cb2a_2" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "5a106db41731200f0623192043b6ccf3", + "name": "libpython-static", + "sha256": "d1c38e712b125c1f3a80857d8ec66bb0e51783b514a76824e51bf3d43f40752e", + "size": 56796157, + "subdir": "linux-64", + "timestamp": 1669300977755, + "version": "3.9.15" + }, + "libpython-static-3.9.16-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0 h7a1cb2a_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "8409ae3fa627acf0b0261c028f1c3fe7", + "name": "libpython-static", + "sha256": "fd489325a2e4af830a4ad1c51b4acf3d58c0d7e318d4d6965c4c513298008d24", + "size": 56795214, + "subdir": "linux-64", + "timestamp": 1673453851236, + "version": "3.9.16" + }, + "libpython-static-3.9.16-h6a678d5_1.tar.bz2": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0 h7a1cb2a_1" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "a8c51405817b163d399886916a19f08c", + "name": "libpython-static", + "sha256": "3a7236ecf40a627475257be4c1e4059b8377e4cbe5777e045ff34b6b84283f62", + "size": 56792379, + "subdir": "linux-64", + "timestamp": 1677695618930, + "version": "3.9.16" + }, + "libpython-static-3.9.16-h6a678d5_2.tar.bz2": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0 h7a1cb2a_2" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "8529dc208bb54ab2e74ee5d7d57356df", + "name": "libpython-static", + "sha256": "8ca82c11b52d92a695561929c5af77fd785da63f2751a48ff1d92cfa525ed6e2", + "size": 56793633, + "subdir": "linux-64", + "timestamp": 1678284669315, + "version": "3.9.16" + }, + "libpython-static-3.9.2-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0 hdb3f193_0" + ], + "license": "Python-2.0", + "md5": "3245c244fccbbe079f9b4520e21c6be6", + "name": "libpython-static", + "sha256": "6799324f7523b5f083e38fde581147d1b63a5759f675cab11e675c9266bb462a", + "size": 64532617, + "subdir": "linux-64", + "timestamp": 1614802511391, + "version": "3.9.2" + }, + "libpython-static-3.9.4-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0 hdb3f193_0" + ], + "license": "Python-2.0", + "md5": "0a60472bcd489d97a04aea4984c7611d", + "name": "libpython-static", + "sha256": "a7cca25e57287c7cb00ac53ff1787ef7ef9bb03b9d4e64e05c42b7a54b5ed7cc", + "size": 64635879, + "subdir": "linux-64", + "timestamp": 1617986814028, + "version": "3.9.4" + }, + "libpython-static-3.9.5-h2531618_3.tar.bz2": { + "build": "h2531618_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0 hdb3f193_3" + ], + "license": "Python-2.0", + "md5": "e7c91a9c45c01a00c56dbf4fc854e1d4", + "name": "libpython-static", + "sha256": "0075fa6e98a624fcd45b11674c9e9536bbdda4921add2a30e75ef6ac2138c3fa", + "size": 63852722, + "subdir": "linux-64", + "timestamp": 1621367234679, + "version": "3.9.5" + }, + "libpython-static-3.9.5-h2531618_4.tar.bz2": { + "build": "h2531618_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0 hdb3f193_4" + ], + "license": "Python-2.0", + "md5": "9e8f06be85d365f579c5f8a5bc5b16da", + "name": "libpython-static", + "sha256": "23db87151b290f39f9cc7b1beac1fa1bb12c88e3446369acbc75c09007ca6157", + "size": 64001324, + "subdir": "linux-64", + "timestamp": 1622818412578, + "version": "3.9.5" + }, + "libpython-static-3.9.5-h295c915_4.tar.bz2": { + "build": "h295c915_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0 h12debd9_4" + ], + "license": "Python-2.0", + "md5": "43013c2929bdd81e8774a198abfa6494", + "name": "libpython-static", + "sha256": "ccda3ff2869225ba4bf42d290488fc6810de9b59d00380476c348374adc0b4f9", + "size": 63934597, + "subdir": "linux-64", + "timestamp": 1622828242067, + "version": "3.9.5" + }, + "libpython-static-3.9.6-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0 h12debd9_0" + ], + "license": "Python-2.0", + "md5": "2f085581b50acb3e5e5eb89961eef39d", + "name": "libpython-static", + "sha256": "64d6892ff77ebaae4766235b12e3d271639f7ebadec6b05ebd6524f34466e670", + "size": 63869564, + "subdir": "linux-64", + "timestamp": 1627663657786, + "version": "3.9.6" + }, + "libpython-static-3.9.6-h295c915_1.tar.bz2": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0 h12debd9_1" + ], + "license": "Python-2.0", + "md5": "31e8ecc122ee1988024639402590c388", + "name": "libpython-static", + "sha256": "0feda52d162c3891617b2f9e1172e7fb96ad6f5cdc8dff6f5a03c76a6f9d2cab", + "size": 63932829, + "subdir": "linux-64", + "timestamp": 1629316156023, + "version": "3.9.6" + }, + "libpython-static-3.9.7-h295c915_1.tar.bz2": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0 h12debd9_1" + ], + "license": "Python-2.0", + "md5": "c1a3f46b470263cb525042d3576c0791", + "name": "libpython-static", + "sha256": "01abba8ab9af8c3a3c69d5e6ee1a18958e9ad9efc47cf32b50b892a918c2aec6", + "size": 63909822, + "subdir": "linux-64", + "timestamp": 1631798551238, + "version": "3.9.7" + }, + "librdkafka-1.6.0-h2f57cc4_2.tar.bz2": { + "build": "h2f57cc4_2", + "build_number": 2, + "depends": [ + "cyrus-sasl >=2.1.27,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "lz4-c >=1.9.3,<1.10.0a0", + "openssl >=1.1.1o,<1.1.2a", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "176799cf96ccd0166de415b9c5b51650", + "name": "librdkafka", + "sha256": "10cf245461a3b89a95d952a5b0d865569cff0a8eeddc32096745a8aaa7ab0652", + "size": 10845762, + "subdir": "linux-64", + "timestamp": 1656405317791, + "version": "1.6.0" + }, + "librdkafka-1.6.0-hc0fa4bf_1.tar.bz2": { + "build": "hc0fa4bf_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.27,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "openssl >=1.1.1k,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d326108475929d483fcd0ffe58f9226d", + "name": "librdkafka", + "sha256": "8a74eba28d68f22a1a2ce5c1ed47a07567b7e6779d25266d833fa8fa626b4338", + "size": 10974903, + "subdir": "linux-64", + "timestamp": 1621648716636, + "version": "1.6.0" + }, + "librsvg-2.54.4-h19fe530_0.tar.bz2": { + "build": "h19fe530_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "gdk-pixbuf >=2.42.8,<3.0a0", + "glib >=2.69.1,<3.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "pango >=1.50.7,<2.0a0", + "zlib" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "34292ca2bcd3f2dfa79771e27d84a97c", + "name": "librsvg", + "sha256": "69c5b17d5e67acfada20758944247412cb34efa23b4d056524426505e481039a", + "size": 5415809, + "subdir": "linux-64", + "timestamp": 1656615720019, + "version": "2.54.4" + }, + "librsvg-2.54.4-h36cc946_2.tar.bz2": { + "build": "h36cc946_2", + "build_number": 2, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "fontconfig >=2.14.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "gdk-pixbuf >=2.42.10,<3.0a0", + "glib >=2.69.1,<3.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.39,<1.7.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "pango >=1.50.7,<2.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "17bbb47988cc753070837e68ed2375d7", + "name": "librsvg", + "sha256": "aa2e7c919ba72a53f7cd988b1503812983ed59983a6bd4dc9b1409a176e80efd", + "size": 6681094, + "subdir": "linux-64", + "timestamp": 1678549834206, + "version": "2.54.4" + }, + "librsvg-2.54.4-h36cc946_3.tar.bz2": { + "build": "h36cc946_3", + "build_number": 3, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "fontconfig >=2.14.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "gdk-pixbuf >=2.42.10,<3.0a0", + "glib >=2.69.1,<3.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.39,<1.7.0a0", + "libxml2 >=2.10.3,<2.11.0a0", + "pango >=1.50.7,<2.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "4c0e715c55ff180cb980a2282555fb4e", + "name": "librsvg", + "sha256": "091a7fb1e2a13a119ab08d0dac5e7d380d313355188ab78df8925ac12ea4a57c", + "size": 6693861, + "subdir": "linux-64", + "timestamp": 1679663049125, + "version": "2.54.4" + }, + "libsodium-1.0.13-h31c71d8_2.tar.bz2": { + "build": "h31c71d8_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "ISC", + "md5": "9f13bef505d380da1e525a720a21edef", + "name": "libsodium", + "sha256": "7e87ab3d1b87585d1c137a52a4695f2de2e8cbd3a9f1f554533c31d7a52903b8", + "size": 377991, + "subdir": "linux-64", + "timestamp": 1505687591176, + "version": "1.0.13" + }, + "libsodium-1.0.15-hf101ebd_0.tar.bz2": { + "build": "hf101ebd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "ISC", + "md5": "1b8159c91ba40663ad61da7677c71f48", + "name": "libsodium", + "sha256": "b3fef2eda998a97f39de78614acdbaf248ba71a2a1a8b4a006816e62afbd7a25", + "size": 320347, + "subdir": "linux-64", + "timestamp": 1511036070905, + "version": "1.0.15" + }, + "libsodium-1.0.16-h1bed415_0.tar.bz2": { + "build": "h1bed415_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "ISC", + "md5": "d6da2bc1d41ffc4906f7502b233d487d", + "name": "libsodium", + "sha256": "7ee7fab9212e117f029a55ccb45de64615613001bc15ecd0b9bf3cad57fbd1f4", + "size": 309669, + "subdir": "linux-64", + "timestamp": 1522217356801, + "version": "1.0.16" + }, + "libsodium-1.0.18-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "ISC", + "md5": "6f662c6b244a444869f0c537da106d6d", + "name": "libsodium", + "sha256": "e31aa60464b87c49b12d3baa2f95f92486238246810845365b10d53aab0809ff", + "size": 396743, + "subdir": "linux-64", + "timestamp": 1581700759428, + "version": "1.0.18" + }, + "libsolv-0.7.20-h4ff587b_0.tar.bz2": { + "build": "h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9d6c825e29068c3e6006f051faeedefe", + "name": "libsolv", + "sha256": "e8a28b5fed8d4321728eee90ffe7f95841089fc8663028ad46d627bd2290d949", + "size": 483692, + "subdir": "linux-64", + "timestamp": 1645463043114, + "version": "0.7.20" + }, + "libsolv-0.7.22-he621ea3_0.tar.bz2": { + "build": "he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pcre2 >=10.37,<10.38.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e17dfd4a8fdce9291da7f1d4a68c402b", + "name": "libsolv", + "sha256": "d39f5a823947bb004bf3dbae33fc40ec1d6e3ad149fa8b3e0152972bd74cc7af", + "size": 454993, + "subdir": "linux-64", + "timestamp": 1666304574357, + "version": "0.7.22" + }, + "libsolv-static-0.7.20-h4ff587b_0.tar.bz2": { + "build": "h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libsolv 0.7.20 h4ff587b_0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f3d4488981de4001d6b33c8f42dc769", + "name": "libsolv-static", + "sha256": "c7bf1c401cfe7afd0860cb4184747d799cc66a88bb17bdedc7df174417bde293", + "size": 397499, + "subdir": "linux-64", + "timestamp": 1645463059600, + "version": "0.7.20" + }, + "libsolv-static-0.7.22-he621ea3_0.tar.bz2": { + "build": "he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libsolv 0.7.22 he621ea3_0", + "libstdcxx-ng >=11.2.0", + "pcre2 >=10.37,<10.38.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22e155d161be399f44f62faea6e749db", + "name": "libsolv-static", + "sha256": "edce218e2e9c74397761353b87967a0127d3e8849dc34247851b7580364e189c", + "size": 374167, + "subdir": "linux-64", + "timestamp": 1666304584555, + "version": "0.7.22" + }, + "libspatialindex-1.8.5-h20b78c2_2.tar.bz2": { + "build": "h20b78c2_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "a3903080eff4aaec56e3da3a7772f49d", + "name": "libspatialindex", + "sha256": "19c53bf106d3119cdb77b6e43a0dd3f53a91dbe460479eba95bf09180e21efa8", + "size": 681846, + "subdir": "linux-64", + "timestamp": 1513268848433, + "version": "1.8.5" + }, + "libspatialindex-1.9.3-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "8365a8a1dd0aef199a1214831622a4ef", + "name": "libspatialindex", + "sha256": "b0f60b4c32f917a9c1b1048520cdfb5937ff7a07befa8a71022dfafae6e29ca4", + "size": 3283214, + "subdir": "linux-64", + "timestamp": 1616086764247, + "version": "1.9.3" + }, + "libspatialindex-1.9.3-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "6115700c788e03abb132dcfea63e61f5", + "name": "libspatialindex", + "sha256": "8c2dfcfef1fc5f2bd666d8392ad4e194fbde7fda5594c130226d7f4e3c565269", + "size": 3284487, + "subdir": "linux-64", + "timestamp": 1573154440181, + "version": "1.9.3" + }, + "libspatialite-4.3.0a-h21ec0d7_22.tar.bz2": { + "build": "h21ec0d7_22", + "build_number": 22, + "depends": [ + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.10,<2.11.0a0", + "libxml2 >=2.10.3,<2.11.0a0", + "proj >=7.2.0,<7.2.1.0a0", + "sqlite >=3.41.1,<4.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "1737a12c4e37568eb79434aca24f51ef", + "name": "libspatialite", + "sha256": "06675fdb0cc83e3e11d268aecf9f16806abf6adeb3712266c00f1ba063de0b84", + "size": 3456816, + "subdir": "linux-64", + "timestamp": 1679578297974, + "version": "4.3.0a" + }, + "libspatialite-4.3.0a-h21ec0d7_23.tar.bz2": { + "build": "h21ec0d7_23", + "build_number": 23, + "depends": [ + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.10,<2.11.0a0", + "libxml2 >=2.10.3,<2.11.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.41.1,<4.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "05a84d57a98ec5728ad00e022e46b252", + "name": "libspatialite", + "sha256": "386597f2841ec24509e27e1cf8596f9db7239f9d6f2de5de895567ff71a75992", + "size": 3456651, + "subdir": "linux-64", + "timestamp": 1680110293351, + "version": "4.3.0a" + }, + "libspatialite-4.3.0a-h664321b_0.tar.bz2": { + "build": "h664321b_0", + "build_number": 0, + "depends": [ + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "proj <8.0.0", + "proj >=7.2.0,<7.2.1.0a0", + "sqlite >=3.37.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "52469738e8ee4fecab21504e10b8cade", + "name": "libspatialite", + "sha256": "55736dffba6fa617acb1e89096366c8eda50bc0653f494fefe70e1fdef5a272d", + "size": 3301796, + "subdir": "linux-64", + "timestamp": 1643015097685, + "version": "4.3.0a" + }, + "libspatialite-4.3.0a-h71b31bf_21.tar.bz2": { + "build": "h71b31bf_21", + "build_number": 21, + "depends": [ + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.40.1,<4.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "778151bcf233c375f09f7763fd5329ef", + "name": "libspatialite", + "sha256": "3f0bc36a1e4e243c3edc222b2210929e3a02a0270f94425250f2d4018c94871c", + "size": 3457450, + "subdir": "linux-64", + "timestamp": 1674750914624, + "version": "4.3.0a" + }, + "libspatialite-4.3.0a-h72746d6_18.tar.bz2": { + "build": "h72746d6_18", + "build_number": 18, + "depends": [ + "freexl >=1.0.4,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "proj4 >=4.9.3,<4.9.4.0a0", + "sqlite >=3.20.1,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "7692ca96e4c87ea57613201cd59bc383", + "name": "libspatialite", + "sha256": "595f29126e78c5ab3f1582a8d0870c211b5bbda4fddca98483e62133c723d8cc", + "size": 3268709, + "subdir": "linux-64", + "timestamp": 1511291186010, + "version": "4.3.0a" + }, + "libspatialite-4.3.0a-h793db0d_0.tar.bz2": { + "build": "h793db0d_0", + "build_number": 0, + "depends": [ + "freexl >=1.0.5,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.30.1,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "c0cc53d64131c254f9de5d04368c83e1", + "name": "libspatialite", + "sha256": "257337f8a785505d046beaa90268c3f949c5c89d8af955b7e4fea602c0a9db19", + "size": 3305765, + "subdir": "linux-64", + "timestamp": 1573226969136, + "version": "4.3.0a" + }, + "libspatialite-4.3.0a-hb08deb6_19.tar.bz2": { + "build": "hb08deb6_19", + "build_number": 19, + "depends": [ + "freexl >=1.0.5,<2.0a0", + "geos >=3.7.1,<3.7.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "proj4 >=5.2.0,<5.2.1.0a0", + "sqlite >=3.26.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "def695b94921ce6d606d70b6d87d8ba7", + "name": "libspatialite", + "sha256": "ef8dfad00c96f699867563ffeee3bc1aaa1ae2db8f3cfa80db0a10410d100ffc", + "size": 3293197, + "subdir": "linux-64", + "timestamp": 1545319414931, + "version": "4.3.0a" + }, + "libspatialite-4.3.0a-hbedb2dc_20.tar.bz2": { + "build": "hbedb2dc_20", + "build_number": 20, + "depends": [ + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.37.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "28b616e9f1f5e597c78a6dd82f324cb8", + "name": "libspatialite", + "sha256": "51e90612881c1ae93c1486e31ccea0ab74c2424c57ba9e58d0ec25667c082067", + "size": 3292456, + "subdir": "linux-64", + "timestamp": 1642781088363, + "version": "4.3.0a" + }, + "libspatialite-4.3.0a-he475c7f_19.tar.bz2": { + "build": "he475c7f_19", + "build_number": 19, + "depends": [ + "freexl >=1.0.5,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "sqlite >=3.24.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "49a62f245d832b1eb9e27533b62fe544", + "name": "libspatialite", + "sha256": "15f71b22c543fc90983bdb5bf67d095bb0722e167bf0115aa6918fbf6f5cb339", + "size": 3263016, + "subdir": "linux-64", + "timestamp": 1530868615629, + "version": "4.3.0a" + }, + "libssh2-1.10.0-h8f2d780_0.tar.bz2": { + "build": "h8f2d780_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openssl >=1.1.1n,<1.1.2a" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f99f13daacf379a329e041ec148c4db7", + "name": "libssh2", + "sha256": "97549094b023e65e4a16581593d5b63dfa7b84cc383911b80b44eb71bb23f12c", + "size": 311377, + "subdir": "linux-64", + "timestamp": 1651087263509, + "version": "1.10.0" + }, + "libssh2-1.8.0-h1ba5d50_4.tar.bz2": { + "build": "h1ba5d50_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "041533b0f64ffdeb390e81a64d87ebb9", + "name": "libssh2", + "sha256": "f54eb9dc33b1f059d0e2545cbfde247ae7aa4b7b978b2825c4c75de496f6fbd2", + "size": 238775, + "subdir": "linux-64", + "timestamp": 1540494448731, + "version": "1.8.0" + }, + "libssh2-1.8.0-h2d05a93_3.tar.bz2": { + "build": "h2d05a93_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "41d397165788964bb5fdf2dc8603ebf3", + "name": "libssh2", + "sha256": "8a6091bd54c69d959e842865a0b3bf82d2311cf25ccb179e5f21efded3085310", + "size": 248614, + "subdir": "linux-64", + "timestamp": 1511297592364, + "version": "1.8.0" + }, + "libssh2-1.8.0-h8c220ad_2.tar.bz2": { + "build": "h8c220ad_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "35429d4026342b3539bdd52fc6cfc6af", + "name": "libssh2", + "sha256": "287ae5a2405ce8dd453d45b5ad6ff96a5453da97215e1e9cf2c6e1a7e784fe21", + "size": 248852, + "subdir": "linux-64", + "timestamp": 1505687685660, + "version": "1.8.0" + }, + "libssh2-1.8.0-h9cfc8f7_4.tar.bz2": { + "build": "h9cfc8f7_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2n,<1.0.3a" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c743b2a8fa9d956e6aced072f0ebfeea", + "name": "libssh2", + "sha256": "71adf4fbb6f21e4933bdeab1136e4af44768e18aa2a4fac2773b6bb6b2dbdb58", + "size": 248386, + "subdir": "linux-64", + "timestamp": 1516741046975, + "version": "1.8.0" + }, + "libssh2-1.8.2-h1ba5d50_0.tar.bz2": { + "build": "h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1b,<1.1.2a" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2fc57e5e131fe0a8dfd6aaa6e2f87bbe", + "name": "libssh2", + "sha256": "fa60e63a042aed030c0c0996cafe4dbb7d2cebff8027892b848bfd80540a456e", + "size": 256507, + "subdir": "linux-64", + "timestamp": 1555957533473, + "version": "1.8.2" + }, + "libssh2-1.9.0-h1ba5d50_1.tar.bz2": { + "build": "h1ba5d50_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ecfcc28b0f86626bd89548baaa7d119c", + "name": "libssh2", + "sha256": "2cb882f9e851dfbec52b8f6655cdb7320ea4292e2eadaeecb9b2ad095ce3d102", + "size": 353879, + "subdir": "linux-64", + "timestamp": 1583777378437, + "version": "1.9.0" + }, + "libstdcxx-devel_linux-64-11.2.0-h1234567_0.tar.bz2": { + "build": "h1234567_0", + "build_number": 0, + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "b137386c86849039b902c3e47d7dac66", + "name": "libstdcxx-devel_linux-64", + "sha256": "ef6b939275b4184535583f59eea17e90e77ecd24670485d6cd30a4c949243d05", + "size": 20524331, + "subdir": "linux-64", + "timestamp": 1652859697566, + "version": "11.2.0" + }, + "libstdcxx-devel_linux-64-11.2.0-h1234567_1.tar.bz2": { + "build": "h1234567_1", + "build_number": 1, + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "56cc15425b7ac13a759d8fe56317fe0b", + "name": "libstdcxx-devel_linux-64", + "sha256": "13dfcf8696511b0415917af56ac1ed2e61ab8e7e431b397acdc88d361f9462d2", + "size": 20548804, + "subdir": "linux-64", + "timestamp": 1654090781633, + "version": "11.2.0" + }, + "libstdcxx-devel_linux-64-7.5.0-hf0c5c8d_17.tar.bz2": { + "build": "hf0c5c8d_17", + "build_number": 17, + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "1cee2f34aac956d9e405cedaefdd2529", + "name": "libstdcxx-devel_linux-64", + "sha256": "85523a4e3d63a7c2a958d1970007e7e2d2f4e76ab20bcc25a01c3ce62bd4475e", + "size": 9670046, + "subdir": "linux-64", + "timestamp": 1622660063579, + "version": "7.5.0" + }, + "libstdcxx-devel_linux-64-8.4.0-hf0c5c8d_17.tar.bz2": { + "build": "hf0c5c8d_17", + "build_number": 17, + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "537a79ebe575575132f3b98e0e7dd6b1", + "name": "libstdcxx-devel_linux-64", + "sha256": "618bafc27332f742ca429c68886f4261f9fd672637ece4d14b9e4dc13952cba0", + "size": 13094157, + "subdir": "linux-64", + "timestamp": 1622661672879, + "version": "8.4.0" + }, + "libstdcxx-devel_linux-64-9.3.0-hf0c5c8d_17.tar.bz2": { + "build": "hf0c5c8d_17", + "build_number": 17, + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "0f0ab2bd181556daa93722baeed7a4c9", + "name": "libstdcxx-devel_linux-64", + "sha256": "91437a6a5e6a4d244df5fc16b31cdd5efe00240fed21faa73b370abeccb60e70", + "size": 14627594, + "subdir": "linux-64", + "timestamp": 1622663319968, + "version": "9.3.0" + }, + "libstdcxx-ng-11.2.0-h1234567_0.tar.bz2": { + "build": "h1234567_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "b971ce5fb2482c548966e33ee1b0535f", + "name": "libstdcxx-ng", + "sha256": "5ba87393ec0592e77643197191a070f245b6409f8d843385621750543ce800c2", + "size": 6409402, + "subdir": "linux-64", + "timestamp": 1652859715934, + "version": "11.2.0" + }, + "libstdcxx-ng-11.2.0-h1234567_1.tar.bz2": { + "build": "h1234567_1", + "build_number": 1, + "depends": [ + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "8c195584a5f5471b600ee180e4052773", + "name": "libstdcxx-ng", + "sha256": "112ea187f09c690a87d419450d64f49d6cb3163206fcba38d2fdd8f2c7b5388e", + "size": 6410287, + "subdir": "linux-64", + "timestamp": 1654090800863, + "version": "11.2.0" + }, + "libstdcxx-ng-5.4.0-hdf63c60_3.tar.bz2": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [], + "license": "GPL3 with runtime exception", + "md5": "b24f71dc519b5e45e7c8c3ae140ee147", + "name": "libstdcxx-ng", + "sha256": "4d099f8fb49b1221eca8ecbc1c603cc37898803e7baf8f1a7c1230f4cf7ee226", + "size": 2438719, + "subdir": "linux-64", + "timestamp": 1520969519257, + "version": "5.4.0" + }, + "libstdcxx-ng-7.2.0-h24385c6_1.tar.bz2": { + "build": "h24385c6_1", + "build_number": 1, + "depends": [], + "license": "GPL3 with runtime exception", + "md5": "533b28ecc27cd5ab4eb1739f71a24d0a", + "name": "libstdcxx-ng", + "sha256": "a44bea6c49d4b3facd597b9fc7de0f6b7bf6e944d76faeabfc68a362829a0b55", + "size": 2626737, + "subdir": "linux-64", + "timestamp": 1505665569122, + "version": "7.2.0" + }, + "libstdcxx-ng-7.2.0-h7a57d05_2.tar.bz2": { + "build": "h7a57d05_2", + "build_number": 2, + "depends": [], + "license": "GPL3 with runtime exception", + "md5": "adc03ef4ba1dc78dc5eba80c23be4bb5", + "name": "libstdcxx-ng", + "sha256": "140ab7d3cf222c385938705a935e8aab1edd8258667e24f9ff739b3a745930e7", + "size": 2627769, + "subdir": "linux-64", + "timestamp": 1507262729393, + "version": "7.2.0" + }, + "libstdcxx-ng-7.2.0-hdf63c60_3.tar.bz2": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [], + "license": "GPL3 with runtime exception", + "md5": "6b28769c1660675dfb38d1c36df7f1f2", + "name": "libstdcxx-ng", + "sha256": "3fe9f86fa62af9904525873c28e4317d38827a8c42e54760acc5f1b7d8d06cbc", + "size": 2649912, + "subdir": "linux-64", + "timestamp": 1520534523570, + "version": "7.2.0" + }, + "libstdcxx-ng-7.3.0-hdf63c60_0.tar.bz2": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [], + "license": "GPL3 with runtime exception", + "md5": "c6908d0cfda60fcb8db54fb8c48af10a", + "name": "libstdcxx-ng", + "sha256": "6691144a93febc222970fa21deeab91f48fa3592b1ab9601de3962b6b006d949", + "size": 2685238, + "subdir": "linux-64", + "timestamp": 1534628462259, + "version": "7.3.0" + }, + "libstdcxx-ng-7.5.0-hd4cf53a_17.tar.bz2": { + "build": "hd4cf53a_17", + "build_number": 17, + "depends": [ + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "d13c7bc86530d1d695eeb80612d0c251", + "name": "libstdcxx-ng", + "sha256": "00c010a27abb4f60f5c8aff4d559fb7dbec1b4a2535dd9a9355ffdc6547993f8", + "size": 2700180, + "subdir": "linux-64", + "timestamp": 1622660076260, + "version": "7.5.0" + }, + "libstdcxx-ng-8.2.0-hdf63c60_0.tar.bz2": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [], + "license": "GPL3 with runtime exception", + "md5": "67970e28e26fc7a4c007e61694e7c7ec", + "name": "libstdcxx-ng", + "sha256": "ef6251b979a2da5a857888d7a6de6c6036dc04b17bd3dfe6ef97719401e310cd", + "size": 3060477, + "subdir": "linux-64", + "timestamp": 1534277515972, + "version": "8.2.0" + }, + "libstdcxx-ng-8.2.0-hdf63c60_1.tar.bz2": { + "build": "hdf63c60_1", + "build_number": 1, + "depends": [], + "license": "GPL3 with runtime exception", + "md5": "16e7bf6ac5207cc989841be16938a3cf", + "name": "libstdcxx-ng", + "sha256": "9df01532722aa5658a99e0fdc87d7c5d43245a36cb29ed7bbd4f1e54b9ac67a6", + "size": 3058753, + "subdir": "linux-64", + "timestamp": 1534516131602, + "version": "8.2.0" + }, + "libstdcxx-ng-8.4.0-hd4cf53a_17.tar.bz2": { + "build": "hd4cf53a_17", + "build_number": 17, + "depends": [ + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "a0eb1fbf08466611a01e1fdaceab4302", + "name": "libstdcxx-ng", + "sha256": "b7ee496145437c9bb6ed6923fb7c7f5a6957c4add38365918bdcef5b395422c7", + "size": 3064749, + "subdir": "linux-64", + "timestamp": 1622661686810, + "version": "8.4.0" + }, + "libstdcxx-ng-9.1.0-hdf63c60_0.tar.bz2": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [], + "license": "GPL3 with runtime exception", + "md5": "53fa39fdae936e9d07c4b2f5ef361993", + "name": "libstdcxx-ng", + "sha256": "43b0bd205f539583c088feb5b8d77b60c83d1df80c2a93dac9f2a1127001b2cf", + "size": 4246257, + "subdir": "linux-64", + "timestamp": 1560112223556, + "version": "9.1.0" + }, + "libstdcxx-ng-9.3.0-hd4cf53a_17.tar.bz2": { + "build": "hd4cf53a_17", + "build_number": 17, + "depends": [ + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "47415cfbf9f3d288981db1cd97cfe97b", + "name": "libstdcxx-ng", + "sha256": "564810f222aaac1d23bf5265f9a63f62e18f504a38aa33d418e628c1b6ea9fb5", + "size": 4235389, + "subdir": "linux-64", + "timestamp": 1622663335295, + "version": "9.3.0" + }, + "libtasn1-4.16.0-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-3.0", + "md5": "7fcfe485e6529b79a6e49aa2e18e18d9", + "name": "libtasn1", + "sha256": "0504d50273574a8aebde5c37760a9f8af37d6bfefac4b89ac452f05ae3c11792", + "size": 63494, + "subdir": "linux-64", + "timestamp": 1617770625491, + "version": "4.16.0" + }, + "libtheora-1.1.1-h5ab3b9f_1.tar.bz2": { + "build": "h5ab3b9f_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libogg >=1.3.2,<2.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libvorbis >=1.3.5,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "50115cf4771bb19a608003bd780eb2f9", + "name": "libtheora", + "sha256": "c26157e67ee8c78da7849a4d726000eb4220fb18104e3a2d592707fa97186bde", + "size": 710277, + "subdir": "linux-64", + "timestamp": 1539495957934, + "version": "1.1.1" + }, + "libtheora-1.1.1-h7f8727e_3.tar.bz2": { + "build": "h7f8727e_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libogg >=1.3.5,<1.4.0a0", + "libogg >=1.3.5,<2.0a0", + "libvorbis" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b70a0a3c9741051d4c24f08177607af3", + "name": "libtheora", + "sha256": "8eaf0df85e69198d1cc09c5eb3de050e5221ad13aa01e55b5d11d86ec424ebe1", + "size": 754898, + "subdir": "linux-64", + "timestamp": 1644826597812, + "version": "1.1.1" + }, + "libthrift-0.13.0-hfb8234f_6.tar.bz2": { + "build": "hfb8234f_6", + "build_number": 6, + "depends": [ + "libevent", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl", + "zlib" + ], + "license": "Apache-2.0", + "md5": "a90d894593c49e8880ba0f8b58bb1a47", + "name": "libthrift", + "sha256": "3a8318fe49dc8c591e48a74faef05863266d539ab4ae32b146e80adb38909901", + "size": 3397616, + "subdir": "linux-64", + "timestamp": 1612012797813, + "version": "0.13.0" + }, + "libthrift-0.14.2-hcc01f38_0.tar.bz2": { + "build": "hcc01f38_0", + "build_number": 0, + "depends": [ + "libevent >=2.1.8,<2.2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "md5": "e541af24cf628e9450e9b03bf1ae859b", + "name": "libthrift", + "sha256": "168ffa033ee354a329e840e7b6a2fc03b3d10d407febd225ef32f35902090df8", + "size": 3830502, + "subdir": "linux-64", + "timestamp": 1632847267327, + "version": "0.14.2" + }, + "libthrift-0.15.0-hcc01f38_0.tar.bz2": { + "build": "hcc01f38_0", + "build_number": 0, + "depends": [ + "libevent >=2.1.8,<2.2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl", + "zlib" + ], + "license": "Apache-2.0", + "md5": "f6a514d7de70671fa072024ad7c192c3", + "name": "libthrift", + "sha256": "da1fc2daa60128e0a3f164181a7f9827c026266b98d8fd01356257f95a7af6d1", + "size": 3851957, + "subdir": "linux-64", + "timestamp": 1631679350731, + "version": "0.15.0" + }, + "libtiff-4.0.10-h2733197_2.tar.bz2": { + "build": "h2733197_2", + "build_number": 2, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "HPND", + "md5": "868e9892308967ff2a174c1612eed79a", + "name": "libtiff", + "sha256": "40f871a0bd70fbce678a3afc73787669300bd05d7082feea2a10d29bd540a404", + "size": 618468, + "subdir": "linux-64", + "timestamp": 1548707350095, + "version": "4.0.10" + }, + "libtiff-4.0.8-h29d08b4_11.tar.bz2": { + "build": "h29d08b4_11", + "build_number": 11, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HPND", + "md5": "8afcb3969a06492a94b42e008c100058", + "name": "libtiff", + "sha256": "25634c4dab6d52f8ec5b453975430c90b8a83bb3a918d7728a4d226a26f6aa67", + "size": 592845, + "subdir": "linux-64", + "timestamp": 1511297440769, + "version": "4.0.8" + }, + "libtiff-4.0.8-h90200ff_9.tar.bz2": { + "build": "h90200ff_9", + "build_number": 9, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HPND", + "md5": "1abb52b2fc88d228df6958afb2ffe7ed", + "name": "libtiff", + "sha256": "ee8667b8c01f08d7e934ae3dc362930ca17ef4b285f634738e9a99b7d21afbcb", + "size": 592600, + "subdir": "linux-64", + "timestamp": 1505744388925, + "version": "4.0.8" + }, + "libtiff-4.0.9-h28f6b97_0.tar.bz2": { + "build": "h28f6b97_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HPND", + "md5": "ebc05e186f60127331350d8593ae37fa", + "name": "libtiff", + "sha256": "ac3af89b01a5c5239dcf54bc55edcb37a6a8e317508e860d95e00a537fde71a7", + "size": 600447, + "subdir": "linux-64", + "timestamp": 1511371632213, + "version": "4.0.9" + }, + "libtiff-4.0.9-he85c1e1_1.tar.bz2": { + "build": "he85c1e1_1", + "build_number": 1, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HPND", + "md5": "0a8f05a8bfa5c4e3e015a81c48308f3f", + "name": "libtiff", + "sha256": "f3a76904e804bcc0773aa8a54b2458b67f453fafe78ef1ecf06ca51d03ed9e04", + "size": 579655, + "subdir": "linux-64", + "timestamp": 1525875328091, + "version": "4.0.9" + }, + "libtiff-4.0.9-he85c1e1_2.tar.bz2": { + "build": "he85c1e1_2", + "build_number": 2, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HPND", + "md5": "5a84a92c0a857aa12f28e157955245be", + "name": "libtiff", + "sha256": "f2dc981d1a0aa416ea5c3635a5398d053764d362d3e60bae1e9b49e22c1e2957", + "size": 580230, + "subdir": "linux-64", + "timestamp": 1535046023487, + "version": "4.0.9" + }, + "libtiff-4.1.0-h2733197_0.tar.bz2": { + "build": "h2733197_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "HPND", + "md5": "1dee0236f85da7495ded016a02f1755d", + "name": "libtiff", + "sha256": "9e2f998f609a749e749ceb70b8c6b8cf574bb3944fb754efc01f83fdd616cb5b", + "size": 603315, + "subdir": "linux-64", + "timestamp": 1573232994675, + "version": "4.1.0" + }, + "libtiff-4.1.0-h2733197_1.tar.bz2": { + "build": "h2733197_1", + "build_number": 1, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4", + "zstd >=1.4.4,<1.5.0a0" + ], + "license": "HPND", + "md5": "6c6b5e76bcdf414bed4e61e8b12a2832", + "name": "libtiff", + "sha256": "2dadabea6cb9c68819b7d82d27e734e4f532f2d3a5b09a71edc5394a649fcb75", + "size": 621762, + "subdir": "linux-64", + "timestamp": 1591038832602, + "version": "4.1.0" + }, + "libtiff-4.1.0-h2818925_1.tar.bz2": { + "build": "h2818925_1", + "build_number": 1, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "libtiff", + "license_family": "OTHER", + "md5": "d3de2280b830a869503a8b82d4b0db7b", + "name": "libtiff", + "sha256": "b93ddcee34abb46b18110f3d247d486b5538b94eb8e0b4591b855f6f6dad82db", + "size": 616892, + "subdir": "linux-64", + "timestamp": 1655721058367, + "version": "4.1.0" + }, + "libtiff-4.1.0-hecacb30_2.tar.bz2": { + "build": "hecacb30_2", + "build_number": 2, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "libtiff", + "license_family": "BSD", + "md5": "8ec7c47371dfc4584b65b70684a2d2d8", + "name": "libtiff", + "sha256": "9b0d3c30a25dbbbdb6f0eada4b89bf54cbf7aeb97404388c4f7b8d8656cf0ca3", + "size": 595531, + "subdir": "linux-64", + "timestamp": 1663085286465, + "version": "4.1.0" + }, + "libtiff-4.2.0-h2818925_1.tar.bz2": { + "build": "h2818925_1", + "build_number": 1, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libwebp-base", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "HPND", + "md5": "b25d56d33596623a6a4a9d9baaa4f602", + "name": "libtiff", + "sha256": "711ea05b4c35bdafc762a172b01db896b17942f474c2b1a519f91370964bf9bc", + "size": 592974, + "subdir": "linux-64", + "timestamp": 1653047881023, + "version": "4.2.0" + }, + "libtiff-4.2.0-h3942068_0.tar.bz2": { + "build": "h3942068_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libwebp-base", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "HPND", + "md5": "4a681051cf919b5a1ac2f128759769f0", + "name": "libtiff", + "sha256": "fea3847096b742bd5520f1969320737e1895d53e91513245c828dc827499692a", + "size": 646802, + "subdir": "linux-64", + "timestamp": 1615544136333, + "version": "4.2.0" + }, + "libtiff-4.2.0-h85742a9_0.tar.bz2": { + "build": "h85742a9_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libwebp-base", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "HPND", + "md5": "d7ea21b29e29feec41890296b559555b", + "name": "libtiff", + "sha256": "5e249c94d0b7b3bf035d69c2f707964b5e39995987b359d17de28c0a54ee9405", + "size": 655372, + "subdir": "linux-64", + "timestamp": 1616492392965, + "version": "4.2.0" + }, + "libtiff-4.2.0-hecacb30_2.tar.bz2": { + "build": "hecacb30_2", + "build_number": 2, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libwebp-base", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "libtiff", + "license_family": "BSD", + "md5": "dd48f754335376ba438ce11bbbeb4ba3", + "name": "libtiff", + "sha256": "51f95046208dac90ed2662f3db63e9dde489bf138a1b32ba7b9e14a418634f95", + "size": 666606, + "subdir": "linux-64", + "timestamp": 1663278260224, + "version": "4.2.0" + }, + "libtiff-4.4.0-hecacb30_0.tar.bz2": { + "build": "hecacb30_0", + "build_number": 0, + "depends": [ + "jpeg >=9e,<10a", + "lerc >=3.0,<4.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libwebp-base", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "HPND", + "md5": "08bce00dc53120e006dac33e59f197ee", + "name": "libtiff", + "sha256": "6a4ea261641dfe872361a3520c76b6677f858e930146ba7965bc79c6839dd29a", + "size": 640069, + "subdir": "linux-64", + "timestamp": 1660660381009, + "version": "4.4.0" + }, + "libtiff-4.4.0-hecacb30_1.tar.bz2": { + "build": "hecacb30_1", + "build_number": 1, + "depends": [ + "jpeg >=9e,<10a", + "lerc >=3.0,<4.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libwebp-base", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "HPND", + "license_family": "Other", + "md5": "f6aee0a365b0ce86cc720fbe3a1ed1b8", + "name": "libtiff", + "sha256": "5ad13f5397384f7cc48663e230352ff440b517653ae8629e2b895a0a261fe7cb", + "size": 648022, + "subdir": "linux-64", + "timestamp": 1667343106207, + "version": "4.4.0" + }, + "libtiff-4.4.0-hecacb30_2.tar.bz2": { + "build": "hecacb30_2", + "build_number": 2, + "depends": [ + "jpeg >=9e,<10a", + "lerc >=3.0,<4.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libwebp-base", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "HPND", + "license_family": "Other", + "md5": "5074c89dec1b290cff19d9d677e2c4e2", + "name": "libtiff", + "sha256": "6a2d0f8c3e691b16976a1b599a152d669805c158bcd509cab052ddb62a61c45e", + "size": 680762, + "subdir": "linux-64", + "timestamp": 1668535662291, + "version": "4.4.0" + }, + "libtiff-4.5.0-h6a678d5_1.tar.bz2": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "jpeg >=9e,<10a", + "lerc >=3.0,<4.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libwebp-base", + "xz >=5.2.10,<6.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "HPND", + "license_family": "Other", + "md5": "51d50a8389083dc6124c3777e6020952", + "name": "libtiff", + "sha256": "291e3a227a11bb67c6a01ef3475989901a2815e190bab1f9e08689be7f177f0d", + "size": 677523, + "subdir": "linux-64", + "timestamp": 1675328844757, + "version": "4.5.0" + }, + "libtiff-4.5.0-h6a678d5_2.tar.bz2": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "jpeg >=9e,<10a", + "lerc >=3.0,<4.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libwebp-base", + "xz >=5.2.10,<6.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "HPND", + "license_family": "Other", + "md5": "c8fc88ba2f5f3900d57225c7f1ab4272", + "name": "libtiff", + "sha256": "c01ee5a51b93d6a376d3abf90b24712808b1395feccde45a32a712ea259f4b95", + "size": 645975, + "subdir": "linux-64", + "timestamp": 1677493430198, + "version": "4.5.0" + }, + "libtiff-4.5.0-hecacb30_0.tar.bz2": { + "build": "hecacb30_0", + "build_number": 0, + "depends": [ + "jpeg >=9e,<10a", + "lerc >=3.0,<4.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libwebp-base", + "xz >=5.2.8,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "HPND", + "license_family": "Other", + "md5": "e3a83a9d4d100bff25451b65cbad6717", + "name": "libtiff", + "sha256": "55363e55bcb3c22be17082000f233a9aeb0f5ed3b847a7415705eaa447c981eb", + "size": 664744, + "subdir": "linux-64", + "timestamp": 1673474698484, + "version": "4.5.0" + }, + "libtool-2.4.6-h295c915_1008.tar.bz2": { + "build": "h295c915_1008", + "build_number": 1008, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "501f0b2e570c92def56f3f3290b886d2", + "name": "libtool", + "sha256": "9c759e3a36ac123c872c9bdef61795cddf007a466c5a8674daaa358ad54e7549", + "size": 498387, + "subdir": "linux-64", + "timestamp": 1644482588290, + "version": "2.4.6" + }, + "libtool-2.4.6-h544aabb_3.tar.bz2": { + "build": "h544aabb_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "cae73fb166b600dd0f6e50a93a3fe8b0", + "name": "libtool", + "sha256": "381c1e26ebad1e5300050151ac7100dfbe9126a6d8394ae08b2a5b68c2ee50f9", + "size": 529401, + "subdir": "linux-64", + "timestamp": 1509873791246, + "version": "2.4.6" + }, + "libtool-2.4.6-h6a678d5_1009.tar.bz2": { + "build": "h6a678d5_1009", + "build_number": 1009, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "67eb4fb73dba68075003a4a491151825", + "name": "libtool", + "sha256": "6c654e442823dc3e9ebcad40de688e2b895c7da1e1f37737c871bffbdd36233e", + "size": 533845, + "subdir": "linux-64", + "timestamp": 1670318708338, + "version": "2.4.6" + }, + "libtool-2.4.6-h7b6447c_1005.tar.bz2": { + "build": "h7b6447c_1005", + "build_number": 1005, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-2.0-or-later", + "md5": "5c0a8f19dc76f2de77670f63addb4985", + "name": "libtool", + "sha256": "5667e3c251fa5759c39f62723119b3375ab5684e00c52c1ca70fa0d14917bc84", + "size": 515490, + "subdir": "linux-64", + "timestamp": 1601492198044, + "version": "2.4.6" + }, + "libtool-2.4.6-h7b6447c_5.tar.bz2": { + "build": "h7b6447c_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL 3", + "md5": "ad4dded339e4bb59e6dce81947efab2c", + "name": "libtool", + "sha256": "a6b2487058a56c062089efef26add4aa5267e71a51b645b64b3e917f6249f497", + "size": 524888, + "subdir": "linux-64", + "timestamp": 1538243270871, + "version": "2.4.6" + }, + "libtool-2.4.6-hd50d1a6_0.tar.bz2": { + "build": "hd50d1a6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "2cff6eb6a1f25d47e0171fde95d6119f", + "name": "libtool", + "sha256": "64ddbcf893daf795680067f6c6141cb62cb14dbf2c66b38de60a7faa7af2f2f5", + "size": 527305, + "subdir": "linux-64", + "timestamp": 1505665992983, + "version": "2.4.6" + }, + "libunistring-0.9.10-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "LGPL", + "md5": "88da7938c4376b130ad14480b7fbb49b", + "name": "libunistring", + "sha256": "199384302871d72718a62cce767d6abbcb6d8001b6942edfe9d8d87cbee74ff0", + "size": 705198, + "subdir": "linux-64", + "timestamp": 1617770969934, + "version": "0.9.10" + }, + "libunwind-1.5.0-h295c915_1.tar.bz2": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0a7568decbebc7828ffc326522010ba", + "name": "libunwind", + "sha256": "3187802f49c80182c5263f34081fed9ee8b8e0ba05e7416d39cee31f612fd20a", + "size": 77962, + "subdir": "linux-64", + "timestamp": 1634151888996, + "version": "1.5.0" + }, + "libutf8proc-2.1.1-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c9b31485fb70777f12a3e2bcc02d0c75", + "name": "libutf8proc", + "sha256": "2e77e9794cc12ed94f99e59fc9f125a90800d2862c86c3d0fab7d08d61fe51e2", + "size": 105279, + "subdir": "linux-64", + "timestamp": 1527939600770, + "version": "2.1.1" + }, + "libutf8proc-2.5.0-h14c3975_2.tar.bz2": { + "build": "h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "259dd178cb06d919d087408ba338f272", + "name": "libutf8proc", + "sha256": "3cab1f1e62c2fa6d4bb092a54575ce26d1ed2aef965b02cae43a50415ab5e908", + "size": 90159, + "subdir": "linux-64", + "timestamp": 1601293244712, + "version": "2.5.0" + }, + "libutf8proc-2.5.0-h7b6447c_2.tar.bz2": { + "build": "h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ebb3fef07f04c251825102797f70be7", + "name": "libutf8proc", + "sha256": "0ded20cd3700edb678744258d4c3241cb6e06f4a13a5c3db28946916b2717b32", + "size": 91986, + "subdir": "linux-64", + "timestamp": 1601293227819, + "version": "2.5.0" + }, + "libutf8proc-2.6.1-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4c3485d5655de8dcf7b7413ffe93fe3", + "name": "libutf8proc", + "sha256": "e7c2968f0112ee397d051058cafe4bed5cf2aa1e11ab3fb0620e23a2fc62022f", + "size": 97418, + "subdir": "linux-64", + "timestamp": 1612284952317, + "version": "2.6.1" + }, + "libutf8proc-2.6.1-h5eee18b_1.tar.bz2": { + "build": "h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b462d1cbb50f9378653ce50d9af0f2e0", + "name": "libutf8proc", + "sha256": "2b146674c98d3a05f3d9bda8a3a7d8a01b61a47dd328b5d1eb9a0ec2a82e40cb", + "size": 97360, + "subdir": "linux-64", + "timestamp": 1672422880512, + "version": "2.6.1" + }, + "libuuid-1.0.3-h1bed415_2.tar.bz2": { + "build": "h1bed415_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "md5": "c139036e48b27c84ab08cdd18369851a", + "name": "libuuid", + "sha256": "dc605d7fc28144a7cb2e9804b20230d70e48ac630b8ed071d2958a0a59a32393", + "size": 16335, + "subdir": "linux-64", + "timestamp": 1515696691334, + "version": "1.0.3" + }, + "libuuid-1.0.3-h5bb35a6_1.tar.bz2": { + "build": "h5bb35a6_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "md5": "4a025ddac3b326c5fb79c16a6ce1a862", + "name": "libuuid", + "sha256": "97bc2b876ed2a813f36c90acf628f353ae80b201c3ed82b8beba969ffc62762e", + "size": 15646, + "subdir": "linux-64", + "timestamp": 1505745182024, + "version": "1.0.3" + }, + "libuuid-1.0.3-h7f8727e_2.tar.bz2": { + "build": "h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "BSD 3-Clause", + "md5": "fda36b99463bad87974196da2d5bed08", + "name": "libuuid", + "sha256": "4e1dce80f23551a69761ad48b2372e35f58292ec9cc0ce061312330366a1a223", + "size": 18725, + "subdir": "linux-64", + "timestamp": 1633507857274, + "version": "1.0.3" + }, + "libuuid-1.41.5-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "292768ec77416ae257cfdd44ea2071c8", + "name": "libuuid", + "sha256": "bf310692ee3f3f9aa4a62c5ab334fa8068c1a1add4cf5c741492ca97a172d112", + "size": 29197, + "subdir": "linux-64", + "timestamp": 1668082729834, + "version": "1.41.5" + }, + "libuv-1.14.0-h56b52c2_0.tar.bz2": { + "build": "h56b52c2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ab6cc0278e039821f3eec2d3a48dc98", + "name": "libuv", + "sha256": "e2e189365db646507c61716278cc1d34163cb9a82be4825da84cbaa30d858730", + "size": 731094, + "subdir": "linux-64", + "timestamp": 1505687933785, + "version": "1.14.0" + }, + "libuv-1.19.2-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "79cb7cb43593d8becd9b1e8d45ea752b", + "name": "libuv", + "sha256": "18eb2ce10d6b7cf5709eb6650ab178caac27d9118988112877af2f7a3d200704", + "size": 730491, + "subdir": "linux-64", + "timestamp": 1519712477871, + "version": "1.19.2" + }, + "libuv-1.20.0-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d0334e414d4b885d2b9d9191d0a58ca", + "name": "libuv", + "sha256": "aa322ab3a4b36ecb160b2971f8f042b967526b689d645b96f5ec07293eaa90cd", + "size": 730924, + "subdir": "linux-64", + "timestamp": 1523955739908, + "version": "1.20.0" + }, + "libuv-1.20.3-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c971acae7d122e678324da363ceea9c4", + "name": "libuv", + "sha256": "744ac4e49cb8e60ea0dfa70ccfa01127fad612cf18c94d80c215d58f49cfabf1", + "size": 735009, + "subdir": "linux-64", + "timestamp": 1527275647125, + "version": "1.20.3" + }, + "libuv-1.22.0-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f079c7c3f19ee20a5d726ce3897ee12", + "name": "libuv", + "sha256": "097eac74231ea0fc6743dca48e6b7e69b18cda9dbcb21b974a58a8a473cb1fd2", + "size": 784187, + "subdir": "linux-64", + "timestamp": 1532575712718, + "version": "1.22.0" + }, + "libuv-1.23.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "750e240d8719093ff79f4a2868cd6a93", + "name": "libuv", + "sha256": "d06b2b175b364dec986831cdb6586cd90b23ead2905da83f7a01396f5776d60b", + "size": 788748, + "subdir": "linux-64", + "timestamp": 1536074413202, + "version": "1.23.0" + }, + "libuv-1.23.2-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a432e791dc4c8a628f89bdd378c82a67", + "name": "libuv", + "sha256": "56ed31388dd58303b26c397256eed81a9f22b09c8423d8012f216c6c0723f10f", + "size": 786126, + "subdir": "linux-64", + "timestamp": 1539661723002, + "version": "1.23.2" + }, + "libuv-1.24.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c56a62f85ab5f35d1062c4a5c6886838", + "name": "libuv", + "sha256": "cddacd7dbc78a7f36f2f0aaf2d427e8f84fd0267248c6c83a8971e071960fcbc", + "size": 806203, + "subdir": "linux-64", + "timestamp": 1542390014703, + "version": "1.24.0" + }, + "libuv-1.24.1-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "edc8d94a90ce0ab2bf45a9a74fc3066b", + "name": "libuv", + "sha256": "e18c469d4dd2425a2dd902ecaea6862e4fd92dee5b3aa7b43d17fe03964ae2cd", + "size": 873014, + "subdir": "linux-64", + "timestamp": 1547235277245, + "version": "1.24.1" + }, + "libuv-1.26.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "50081277946ea23aa977607e46f81ca4", + "name": "libuv", + "sha256": "4e7c54eb59b653403a4e05a5c6c36b341fd4a88d3fa17a3cad11f2c49ba5e354", + "size": 866899, + "subdir": "linux-64", + "timestamp": 1552511866328, + "version": "1.26.0" + }, + "libuv-1.38.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d8a390db7bdba89eb03268ad8472831", + "name": "libuv", + "sha256": "ed809a37b22e6490f0545444aed85bf79a973bb5ea45f8b8b21af26364c96965", + "size": 949307, + "subdir": "linux-64", + "timestamp": 1597416619979, + "version": "1.38.0" + }, + "libuv-1.39.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dcfd4b67fde6e031d891c06580a0f00a", + "name": "libuv", + "sha256": "8f944b2d4f4466edb55613584ee75e84bfcb2a26a306fb56913a308a9f70b67d", + "size": 951208, + "subdir": "linux-64", + "timestamp": 1600423255660, + "version": "1.39.0" + }, + "libuv-1.40.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "440323c587792bbd97e2b3e62e214176", + "name": "libuv", + "sha256": "96d46cdd1508563d847a0c2f5aa5306ca284c29cd400ffd455992b6fe9acd237", + "size": 955846, + "subdir": "linux-64", + "timestamp": 1601049115502, + "version": "1.40.0" + }, + "libuv-1.44.2-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "38d0241e44b98801852916b56825115a", + "name": "libuv", + "sha256": "45c40b7fe8a2636485dc9bbfec79b7fa454e82866bbda2674a9daa46511a617d", + "size": 1012659, + "subdir": "linux-64", + "timestamp": 1677079467117, + "version": "1.44.2" + }, + "libvorbis-1.3.5-h7b6447c_1.tar.bz2": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libogg >=1.3.2,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0b319bb60757d893057ac7bc13b320a1", + "name": "libvorbis", + "sha256": "6adbd9eaa1703c2e8f87d69652f3627b32c5f1f69632b704afe67f89b28ea3e3", + "size": 557211, + "subdir": "linux-64", + "timestamp": 1539325110617, + "version": "1.3.5" + }, + "libvorbis-1.3.6-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libogg >=1.3.2,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9226c4a29e79e2a24581554d3ddc8cdd", + "name": "libvorbis", + "sha256": "db1e206408cac03843359dd9e90e317a7a3f7992673a8d7d8f83df6e35973208", + "size": 612446, + "subdir": "linux-64", + "timestamp": 1539664982557, + "version": "1.3.6" + }, + "libvorbis-1.3.7-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libogg >=1.3.2,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e2260ef2263c0747bb17dc3622620928", + "name": "libvorbis", + "sha256": "3786612e1b6961ade5a0ceffa66b67a4b15585746edb1af9a703f3d82d6f5dce", + "size": 562657, + "subdir": "linux-64", + "timestamp": 1600376062963, + "version": "1.3.7" + }, + "libvpx-1.10.0-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "9e6ef91f7f4c278000ae70ad27703330", + "name": "libvpx", + "sha256": "b02bd2114bd73288d9d31fe03124a37a296a41dbe2452ef88e9861d1dbffe230", + "size": 2591065, + "subdir": "linux-64", + "timestamp": 1632843298172, + "version": "1.10.0" + }, + "libvpx-1.11.0-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2608968c9ea7d864e0c3afd58b4df2b1", + "name": "libvpx", + "sha256": "efc72cc6def9dc38a6aa7ca2f9c0178159921d98cc84baef82cc61f80e0b9b82", + "size": 1238285, + "subdir": "linux-64", + "timestamp": 1639406907879, + "version": "1.11.0" + }, + "libvpx-1.6.1-h888fd40_0.tar.bz2": { + "build": "h888fd40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "358187a7c90d904e17c99475d5fb1d96", + "name": "libvpx", + "sha256": "69bb58184d6a6bfcdc3a6e3c7d675db8f210380cd64506aab1812df60951608e", + "size": 2440009, + "subdir": "linux-64", + "timestamp": 1512432093122, + "version": "1.6.1" + }, + "libvpx-1.7.0-h439df22_0.tar.bz2": { + "build": "h439df22_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "5d85bbd2217fd0972c00d692e374a366", + "name": "libvpx", + "sha256": "0723fb7487d2795d8f60acb01a66292475a76dc0a359bf2650b17fd2e707c6dd", + "size": 2503173, + "subdir": "linux-64", + "timestamp": 1519759593884, + "version": "1.7.0" + }, + "libwebp-1.0.0-h222930b_1.tar.bz2": { + "build": "h222930b_1", + "build_number": 1, + "depends": [ + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libtiff >=4.0.9,<5.0a0" + ], + "license": "Google", + "md5": "8b7799bc2cb0d461ab00fc318522c703", + "name": "libwebp", + "sha256": "a9f156cb0e1d0a77791eb544de60750a3ec3d189f7609e255b8f81146f5d92ec", + "size": 930764, + "subdir": "linux-64", + "timestamp": 1534481283875, + "version": "1.0.0" + }, + "libwebp-1.0.1-h8e7db2f_0.tar.bz2": { + "build": "h8e7db2f_0", + "build_number": 0, + "depends": [ + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.35,<1.7.0a0", + "libtiff >=4.0.9,<5.0a0" + ], + "license": "Google", + "md5": "6a685d2948a67d986897c1aace1a48a5", + "name": "libwebp", + "sha256": "63eb8bb53329f678eb06c67849107aeb46bff000205b044800bd927705a14a12", + "size": 934649, + "subdir": "linux-64", + "timestamp": 1542640363230, + "version": "1.0.1" + }, + "libwebp-1.1.0-hd31223b_0.tar.bz2": { + "build": "hd31223b_0", + "build_number": 0, + "depends": [ + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0" + ], + "license": "Google", + "md5": "bb97248f68422a8effeb1ef28e34680d", + "name": "libwebp", + "sha256": "ad3e5f52426dad57a58d5984f9d6b08fac8990d327b58d7e35c365658bce2aa0", + "size": 924120, + "subdir": "linux-64", + "timestamp": 1600443349083, + "version": "1.1.0" + }, + "libwebp-1.2.0-h89dd481_0.tar.bz2": { + "build": "h89dd481_0", + "build_number": 0, + "depends": [ + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0" + ], + "license": "Google", + "md5": "1664c7c911e90ea6af8f4b9e257e42e8", + "name": "libwebp", + "sha256": "76cb067a3291fde91639d7bc65567401ecdee19aaa242846da461cc353779f5a", + "size": 959755, + "subdir": "linux-64", + "timestamp": 1612214220336, + "version": "1.2.0" + }, + "libwebp-1.2.2-h55f646e_0.tar.bz2": { + "build": "h55f646e_0", + "build_number": 0, + "depends": [ + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c566a384259c1d2769852c3bddd81a67", + "name": "libwebp", + "sha256": "146dbb1e4dbccdd57819e5102a8ca00970b8e33d6c6180e8007db89b184da569", + "size": 90150, + "subdir": "linux-64", + "timestamp": 1645441199289, + "version": "1.2.2" + }, + "libwebp-1.2.4-h11a3e52_0.tar.bz2": { + "build": "h11a3e52_0", + "build_number": 0, + "depends": [ + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base 1.2.4.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "496c2f6508db77d5d71cb73a92e26117", + "name": "libwebp", + "sha256": "282e63c164307ba23b543e09c16f8c2d609449b931e75b0160fcc20913be48bd", + "size": 87476, + "subdir": "linux-64", + "timestamp": 1665397142365, + "version": "1.2.4" + }, + "libwebp-1.2.4-h11a3e52_1.tar.bz2": { + "build": "h11a3e52_1", + "build_number": 1, + "depends": [ + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base 1.2.4.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d9ed911c0455fa67680ee67d1c12a50", + "name": "libwebp", + "sha256": "61be199fd866c6f3dcce069fe9a6e08c968c9d2ccfa96e8f21ead48be2f5c69b", + "size": 87434, + "subdir": "linux-64", + "timestamp": 1677058936047, + "version": "1.2.4" + }, + "libwebp-base-1.1.0-h7b6447c_3.tar.bz2": { + "build": "h7b6447c_3", + "build_number": 3, + "constrains": [ + "libwebp 1.1.0" + ], + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "md5": "bc3688a6487e0740ad122243924ef26a", + "name": "libwebp-base", + "sha256": "46a9ca515bbcdd2b9204727a2c24060b209ae258f453f8d6422c2f92bf226847", + "size": 890312, + "subdir": "linux-64", + "timestamp": 1595950847030, + "version": "1.1.0" + }, + "libwebp-base-1.2.0-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "constrains": [ + "libwebp 1.2.0" + ], + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "md5": "4ca6639366b19e17628f10515080885f", + "name": "libwebp-base", + "sha256": "7886fc2bd508a35a1a3b7966a2018c3c2fd21c0314989d3f0371a9587a89032c", + "size": 869130, + "subdir": "linux-64", + "timestamp": 1612214102400, + "version": "1.2.0" + }, + "libwebp-base-1.2.2-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "constrains": [ + "libwebp 1.2.2" + ], + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eeb1bd66f28bed1956ab989d6eff7ae5", + "name": "libwebp-base", + "sha256": "cffb5a063111f7a99a99c74770b23db5dde52325e25a7a46d1903d5ff4a82c88", + "size": 889956, + "subdir": "linux-64", + "timestamp": 1645089138421, + "version": "1.2.2" + }, + "libwebp-base-1.2.4-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "constrains": [ + "libwebp 1.2.4" + ], + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fb63542c653b3be4c16e759e07017914", + "name": "libwebp-base", + "sha256": "13ca59e6673f68600efaf2f5c96db93debabd101904b9ee116e82659b6a8a6d2", + "size": 420942, + "subdir": "linux-64", + "timestamp": 1665395933749, + "version": "1.2.4" + }, + "libwebp-base-1.2.4-h5eee18b_1.tar.bz2": { + "build": "h5eee18b_1", + "build_number": 1, + "constrains": [ + "libwebp 1.2.4" + ], + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ce401f477b09d371d89e008143e2a223", + "name": "libwebp-base", + "sha256": "bcc59d2264dc6893a9f791d01ddd089deb8cefb8f8a0331ed63482fbc785f985", + "size": 424715, + "subdir": "linux-64", + "timestamp": 1677057926950, + "version": "1.2.4" + }, + "libxcb-1.12-h84ff03f_3.tar.bz2": { + "build": "h84ff03f_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d7d64586921d91ffe4b91404895c15b7", + "name": "libxcb", + "sha256": "d1429f67beaf3cbc2a7dfb40672ccb1e97dbe8b81c6e5d6ddc1925a0507a15d2", + "size": 456031, + "subdir": "linux-64", + "timestamp": 1507908036832, + "version": "1.12" + }, + "libxcb-1.12-hcd93eb1_4.tar.bz2": { + "build": "hcd93eb1_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7fdb61e81b96598150f6c65dc3168fac", + "name": "libxcb", + "sha256": "4af9e24258f4f7313523e90dc29c5f2dc5106d9e4a8b9bcb2dbe97904453be80", + "size": 456461, + "subdir": "linux-64", + "timestamp": 1511297685381, + "version": "1.12" + }, + "libxcb-1.12-he6ee5dd_2.tar.bz2": { + "build": "he6ee5dd_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66af1930d5ddc5cd373858ed884e255b", + "name": "libxcb", + "sha256": "3c76570cbecc87d83818a217462226fe01b38b3c4cc1ab74fbf53745e1f99cf2", + "size": 455918, + "subdir": "linux-64", + "timestamp": 1505734062961, + "version": "1.12" + }, + "libxcb-1.13-h1bed415_0.tar.bz2": { + "build": "h1bed415_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "md5": "a777a6c0dec40d1d25c8d6f2082f781c", + "name": "libxcb", + "sha256": "631fec7343b08ac291632014f3720641ed83f400e25c4b466bb822d5ebd2baef", + "size": 512664, + "subdir": "linux-64", + "timestamp": 1522698448141, + "version": "1.13" + }, + "libxcb-1.13-h1bed415_1.tar.bz2": { + "build": "h1bed415_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "md5": "a30332027922e249a80c25faea2f3b34", + "name": "libxcb", + "sha256": "d2addcfabec926e7c6e7e070df2e719cf0c80227a4f1b4d5072f6b7790eb4547", + "size": 513561, + "subdir": "linux-64", + "timestamp": 1523637427898, + "version": "1.13" + }, + "libxcb-1.14-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "md5": "abeb20ac13d2cd53eaaa889c3267c8c2", + "name": "libxcb", + "sha256": "0a1e2dcc859b2fb1414766a5362449ef972ab2087d07f1f3ccd63e284b818089", + "size": 624242, + "subdir": "linux-64", + "timestamp": 1593535452782, + "version": "1.14" + }, + "libxcb-1.15-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "md5": "49e523de8d364b7fabc3850eccbe9bda", + "name": "libxcb", + "sha256": "5d68e69709ae10bd6c4b58b6af447ad2f2bd24955994f3ec77103d1a6bf5e1f5", + "size": 623492, + "subdir": "linux-64", + "timestamp": 1652448233146, + "version": "1.15" + }, + "libxgboost-0.7-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "md5": "2d8295de4db35f06af0aa8f2fda6a370", + "name": "libxgboost", + "sha256": "1aa93996dcbd0fa52bb10d89c2dbf7bb170ee90f202ab8c760d66063354530ef", + "size": 3390942, + "subdir": "linux-64", + "timestamp": 1521480984755, + "version": "0.7" + }, + "libxgboost-0.71-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "md5": "9c512da7ed3d17df5d1ce824d994fd4b", + "name": "libxgboost", + "sha256": "a23405c91eaab0a859000e8d0883f0d526db3f4c96a972cd9914d7a49834fbca", + "size": 3716979, + "subdir": "linux-64", + "timestamp": 1525821700805, + "version": "0.71" + }, + "libxgboost-0.72-h83be7fe_0.tar.bz2": { + "build": "h83be7fe_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "md5": "d5eba1faeeaa71cda7aafa9862801683", + "name": "libxgboost", + "sha256": "27e83e53b4b2b87461018b6066c5cd4dc3962baf30ecec1dc7c05b38aca5ba9c", + "size": 8467944, + "subdir": "linux-64", + "timestamp": 1530222934712, + "version": "0.72" + }, + "libxgboost-0.72-h87a4715_0.tar.bz2": { + "build": "h87a4715_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "md5": "4585f8531efcdc71ebe99fc93743f2b9", + "name": "libxgboost", + "sha256": "cef6589404fca20ddce021fbafa12027d3641361665f11077d11054bddb0243e", + "size": 9282567, + "subdir": "linux-64", + "timestamp": 1530223606110, + "version": "0.72" + }, + "libxgboost-0.72-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "md5": "809f237e5c2cceac2d40140eee0662d8", + "name": "libxgboost", + "sha256": "5754d95b87169b185bd3325ff8a17de1bc08dacf04aa709b54819a29212b8ba3", + "size": 3775101, + "subdir": "linux-64", + "timestamp": 1530218256438, + "version": "0.72" + }, + "libxgboost-0.80-h51060c3_0.tar.bz2": { + "build": "h51060c3_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "md5": "af965e97cdd079f22450afd123e15206", + "name": "libxgboost", + "sha256": "98aa94d2faf2a1846568164844acb22db73ad646c53092974ea56db6748b5a6d", + "size": 12742779, + "subdir": "linux-64", + "timestamp": 1541468824993, + "version": "0.80" + }, + "libxgboost-0.80-h6cbba54_0.tar.bz2": { + "build": "h6cbba54_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.2.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "md5": "5a2bda251772e7a36c6779d0c3340fe3", + "name": "libxgboost", + "sha256": "2b90f1d3fdc59f1d5b1d79a4c786d20136ecc5153b5441519c16dc08d22252f0", + "size": 14184604, + "subdir": "linux-64", + "timestamp": 1541450084466, + "version": "0.80" + }, + "libxgboost-0.80-h6edc907_0.tar.bz2": { + "build": "h6edc907_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "md5": "7e66d4d91c27ccaa700d3701d99fc26a", + "name": "libxgboost", + "sha256": "a37697d82e1d3b08a1ca6abd76c80462916ac885a78f7fc084302a7305245c60", + "size": 14047391, + "subdir": "linux-64", + "timestamp": 1541451058067, + "version": "0.80" + }, + "libxgboost-0.80-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "md5": "40d55dbb1c416ae66a2c90c97d0f590d", + "name": "libxgboost", + "sha256": "6e6e03093832471a64356b392c1c89654f958c863205ba92a2a33b6931445b5d", + "size": 3834461, + "subdir": "linux-64", + "timestamp": 1540835319640, + "version": "0.80" + }, + "libxgboost-0.90-h295c915_1.tar.bz2": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "md5": "882abe02282464f4c218ca0b0dfc83ef", + "name": "libxgboost", + "sha256": "edf1bf8444f4fa57b9402898085fae90c8fee8d8b664f500c48e62d8e23dc73c", + "size": 4031586, + "subdir": "linux-64", + "timestamp": 1642675470075, + "version": "0.90" + }, + "libxgboost-0.90-h4d71fd4_0.tar.bz2": { + "build": "h4d71fd4_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "md5": "cacc4e98e2ea3fc6ef96a63eaec4d6d6", + "name": "libxgboost", + "sha256": "38e0c242bc9f3c385ce0a1bb03337e66ffd862ad17f634e78e76c9da569789f3", + "size": 29156786, + "subdir": "linux-64", + "timestamp": 1560802228082, + "version": "0.90" + }, + "libxgboost-0.90-h688424c_0.tar.bz2": { + "build": "h688424c_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "md5": "21d21564c26b986946acb2cb58d26401", + "name": "libxgboost", + "sha256": "535b5c5668dd344fc707ff738ad37435f1f80034a669ec9ce8da5d489af2bcea", + "size": 32464140, + "subdir": "linux-64", + "timestamp": 1560801030555, + "version": "0.90" + }, + "libxgboost-0.90-h6edc907_0.tar.bz2": { + "build": "h6edc907_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "md5": "56df26fd217c6ed6d8e35c434e6aeb6e", + "name": "libxgboost", + "sha256": "735c85219f91e4af7336fe5f9772d1d4bd64e7d8a241dde1533b99a6d0e992de", + "size": 21998696, + "subdir": "linux-64", + "timestamp": 1560804818600, + "version": "0.90" + }, + "libxgboost-0.90-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "md5": "57f9e782ca5c6ed94df71b8b2dcd215f", + "name": "libxgboost", + "sha256": "810cc1687c3dc90e112e2cff62d9a079009f4b33cfd9596b3fc7b954e262c4a3", + "size": 4069858, + "subdir": "linux-64", + "timestamp": 1559931184751, + "version": "0.90" + }, + "libxgboost-0.90-he6710b0_1.tar.bz2": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "md5": "e9f8c65bdc19025d3d77290903664522", + "name": "libxgboost", + "sha256": "cf02776dc05861b788085dbe0fc21129343f6bb673d9ac68a9dc04a2a356aed2", + "size": 4012178, + "subdir": "linux-64", + "timestamp": 1572481299536, + "version": "0.90" + }, + "libxgboost-0.90-hf484d3e_1.tar.bz2": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [], + "md5": "7b75a5fe1d684f827a2d1cdf41f081ee", + "name": "libxgboost", + "sha256": "7a2465b9bbfb713962df1275f0a5349082e4e03552a87dddc131f86a260bd40c", + "size": 4005120, + "subdir": "linux-64", + "timestamp": 1572476412182, + "version": "0.90" + }, + "libxgboost-1.3.3-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "md5": "dd8350833fc01c06e7abd94e3699c2ea", + "name": "libxgboost", + "sha256": "80307522b90900855a1048368be5d888c9cbaf39688625d72696be325c209c64", + "size": 3210999, + "subdir": "linux-64", + "timestamp": 1619724716187, + "version": "1.3.3" + }, + "libxgboost-1.5.0-h295c915_1.tar.bz2": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "md5": "166655aa2b2605bd6676c239c38682b6", + "name": "libxgboost", + "sha256": "4eef67c42bad83b025906db03cd1ff3c16371629555d36f9cba0c852481ffe01", + "size": 3520823, + "subdir": "linux-64", + "timestamp": 1638290161400, + "version": "1.5.0" + }, + "libxgboost-1.5.0-h6a678d5_2.tar.bz2": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "_openmp_mutex", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0", + "md5": "37217a09451a66df0cdbf8f1251cf165", + "name": "libxgboost", + "sha256": "b12e36431a1d576a3000f8ca21fbd89db7b193f376614d8b399c970d9b2fbee0", + "size": 3759154, + "subdir": "linux-64", + "timestamp": 1659549271981, + "version": "1.5.0" + }, + "libxgboost-1.5.1-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "480f1c3420c010cd163e565b8c917692", + "name": "libxgboost", + "sha256": "c64b00657812aea743e6c715d9f012fb02764d05dc71e74a2c0e3b2ffc0aa801", + "size": 3739852, + "subdir": "linux-64", + "timestamp": 1675119947017, + "version": "1.5.1" + }, + "libxgboost-1.7.3-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "61240c2866056f6b6c76e381fb82682a", + "name": "libxgboost", + "sha256": "4b0ad6d870e65942c422f7eab7abac7833ec807d6a0aae3c5a78a2dd7adcddc4", + "size": 4499047, + "subdir": "linux-64", + "timestamp": 1675458035048, + "version": "1.7.3" + }, + "libxkbcommon-1.0.1-h5eee18b_1.tar.bz2": { + "build": "h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libxcb >=1.15,<2.0a0", + "libxml2 >=2.10.3,<2.11.0a0" + ], + "license": "MIT/X11 Derivative", + "license_family": "MIT", + "md5": "6225f107993ddf5e1f61111b3df025bd", + "name": "libxkbcommon", + "sha256": "114853749b375d54347f18b472456eb7d66beba26238c984403bdd5ff8831947", + "size": 640985, + "subdir": "linux-64", + "timestamp": 1679578328295, + "version": "1.0.1" + }, + "libxkbcommon-1.0.1-hfa300c1_0.tar.bz2": { + "build": "hfa300c1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxcb >=1.14,<2.0a0", + "libxml2 >=2.9.12,<2.10.0a0" + ], + "license": "MIT/X11 Derivative", + "license_family": "MIT", + "md5": "971c3026995b3eac64a061153776f572", + "name": "libxkbcommon", + "sha256": "c8a290beaa78662b056741b3471db10f5ef67f29393a5e476dc77b1eb0bb31cb", + "size": 603233, + "subdir": "linux-64", + "timestamp": 1642166105276, + "version": "1.0.1" + }, + "libxml2-2.10.3-hcbfbd50_0.tar.bz2": { + "build": "hcbfbd50_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=11.2.0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71cb94d645bd051a1a472b1e15073ddb", + "name": "libxml2", + "sha256": "17524686e06fee528886f0a234652dc591824580522f3ba96a1918f22de4c3ad", + "size": 759962, + "subdir": "linux-64", + "timestamp": 1678468377187, + "version": "2.10.3" + }, + "libxml2-2.9.10-hb55368b_3.tar.bz2": { + "build": "hb55368b_3", + "build_number": 3, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4bf3750416ec41de41dbfc9024b84977", + "name": "libxml2", + "sha256": "86a58f66ed3d1628c9e37a7082c365d587add1cf2fc4d02ab24ac849e7396cb6", + "size": 1377325, + "subdir": "linux-64", + "timestamp": 1603239296279, + "version": "2.9.10" + }, + "libxml2-2.9.10-he19cac6_1.tar.bz2": { + "build": "he19cac6_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "adec3e8a968e4dc9f03c5879b34c66b9", + "name": "libxml2", + "sha256": "0cbdcc4ef539dbdb772d5f68bbd91fc869b8bb7c452e0f389326fe8049bdd3f4", + "size": 1377898, + "subdir": "linux-64", + "timestamp": 1591981384134, + "version": "2.9.10" + }, + "libxml2-2.9.12-h03d6c58_0.tar.bz2": { + "build": "h03d6c58_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=9.3.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f09803d12371d1c6bd121e0ca682742f", + "name": "libxml2", + "sha256": "5df58f5c6cfc4acb49767120a2823cc4302d4879f02941ea3a95e3ed6511c711", + "size": 1361550, + "subdir": "linux-64", + "timestamp": 1624477975749, + "version": "2.9.12" + }, + "libxml2-2.9.12-h74e7548_1.tar.bz2": { + "build": "h74e7548_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d0be53e3a22cf2d2257a4eb4ef86ba6", + "name": "libxml2", + "sha256": "a7be54c8f341d041d65ae75469de218cb333b64cd60e8ebdb209d9b8e909ce40", + "size": 1374596, + "subdir": "linux-64", + "timestamp": 1651841277535, + "version": "2.9.12" + }, + "libxml2-2.9.12-h74e7548_2.tar.bz2": { + "build": "h74e7548_2", + "build_number": 2, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c44c2c347d24f42bf733f723caf6806", + "name": "libxml2", + "sha256": "dafbdf41548c58680f2e8a2cc14b6d6cec040cb8f58ebe06dcceeb86461b4fe1", + "size": 1381310, + "subdir": "linux-64", + "timestamp": 1652884304398, + "version": "2.9.12" + }, + "libxml2-2.9.14-h74e7548_0.tar.bz2": { + "build": "h74e7548_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "686e77514ec9f1ef0a6feed374f14d37", + "name": "libxml2", + "sha256": "71f6c4a97014d745c58df52b4dd60ddd75a8508d54fe5b97f42bd1f31cb1c067", + "size": 789469, + "subdir": "linux-64", + "timestamp": 1653546418059, + "version": "2.9.14" + }, + "libxml2-2.9.4-h2e8b1d7_6.tar.bz2": { + "build": "h2e8b1d7_6", + "build_number": 6, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6d199fda00dafe70685c903618234f6", + "name": "libxml2", + "sha256": "97ffa90df9e0d8a01d0f3219ee2794499eb32a5f93c118468853e2030552e28b", + "size": 2053998, + "subdir": "linux-64", + "timestamp": 1511294538916, + "version": "2.9.4" + }, + "libxml2-2.9.4-h6b072ca_5.tar.bz2": { + "build": "h6b072ca_5", + "build_number": 5, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa4805ca2f09b56d251ba942c58dcb70", + "name": "libxml2", + "sha256": "1a4f920f16812dd5bcc76d1ff311fe3d6b27eca9b07b8f7a45b8a87cd2cc17a5", + "size": 2054309, + "subdir": "linux-64", + "timestamp": 1505734150613, + "version": "2.9.4" + }, + "libxml2-2.9.7-h26e45fe_0.tar.bz2": { + "build": "h26e45fe_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a012039d8634991fec15318a70a14dcd", + "name": "libxml2", + "sha256": "ba98a8dc15252f4fac70cb5ca9608d9d7f3d3b9131cd00947939040110d79e1f", + "size": 2046389, + "subdir": "linux-64", + "timestamp": 1516985287556, + "version": "2.9.7" + }, + "libxml2-2.9.8-h26e45fe_1.tar.bz2": { + "build": "h26e45fe_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5a3ade2a72ca403dfdde00756a10cc2d", + "name": "libxml2", + "sha256": "2f09e0469af12892fed881ad569055f6fc676094a916f5c5d031beab35e4cbc0", + "size": 2045311, + "subdir": "linux-64", + "timestamp": 1527065267245, + "version": "2.9.8" + }, + "libxml2-2.9.8-hf84eae3_0.tar.bz2": { + "build": "hf84eae3_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34f9d130fe21d5d4d6acd065ba0118b0", + "name": "libxml2", + "sha256": "2f80f2e435927e0d99b35b661402f28f28470e5036b0050f3917f645994b50af", + "size": 2045121, + "subdir": "linux-64", + "timestamp": 1522941159616, + "version": "2.9.8" + }, + "libxml2-2.9.9-he19cac6_0.tar.bz2": { + "build": "he19cac6_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ffa8f273f02cb02643a9f6d37106632", + "name": "libxml2", + "sha256": "947ce493bece38d421a308fa0897c5d145ba1106ae8914e59b671a861d57164f", + "size": 2092761, + "subdir": "linux-64", + "timestamp": 1547910704655, + "version": "2.9.9" + }, + "libxml2-2.9.9-hea5a465_1.tar.bz2": { + "build": "hea5a465_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e0821f510ccb82ac1897e6412312167", + "name": "libxml2", + "sha256": "9ef0409cfba18eff818ec32800516e229130ad504818d6490cbeb498fd164a73", + "size": 2072022, + "subdir": "linux-64", + "timestamp": 1561393276600, + "version": "2.9.9" + }, + "libxmlsec1-1.2.29-h69ce41f_1.tar.bz2": { + "build": "h69ce41f_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libgcrypt >=1.9.1,<2.0a0", + "libgpg-error >=1.41,<2.0a0", + "libtool >=2.4.6,<3.0a0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "MIT and MPL-1.1", + "license_family": "MIT", + "md5": "4faed6b12d8d2bfa47514f18045d6686", + "name": "libxmlsec1", + "sha256": "c7ea4714d69ced944047ef1c593cc2c6c69975192befe2e352397c90ba30d711", + "size": 601273, + "subdir": "linux-64", + "timestamp": 1613393703376, + "version": "1.2.29" + }, + "libxmlsec1-1.2.29-h8fe84ac_0.tar.bz2": { + "build": "h8fe84ac_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libgcrypt >=1.8.4,<2.0a0", + "libgpg-error >=1.32,<2.0a0", + "libtool >=2.4.6,<3.0a0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "openssl >=1.1.1e,<1.1.2a" + ], + "license": "MIT and MPL-1.1", + "license_family": "MIT", + "md5": "87172167ef8b215ec04c62c75bde4054", + "name": "libxmlsec1", + "sha256": "b508127f00add8e6137d61593310e37a4cb0911c82c4ffe1c295d8389268d4a0", + "size": 549987, + "subdir": "linux-64", + "timestamp": 1584995437454, + "version": "1.2.29" + }, + "libxmlsec1-1.2.32-hba55599_1.tar.bz2": { + "build": "hba55599_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=11.2.0", + "libgcrypt >=1.9.3,<2.0a0", + "libgpg-error >=1.42,<2.0a0", + "libtool >=2.4.6,<3.0a0", + "libxml2 >=2.10.3,<2.11.0a0", + "libxslt >=1.1.37,<2.0a0", + "openssl >=1.1.1t,<1.1.2a", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zlib >=1.2.13,<2.0a0" + ], + "license": "MIT and MPL-1.1", + "license_family": "MIT", + "md5": "482df794fcec99b692d1374fc8f3f2d1", + "name": "libxmlsec1", + "sha256": "81571ea157ee577c0a7d85c9ea12a62cff8715ef9135662a0e351838a711dd9a", + "size": 373064, + "subdir": "linux-64", + "timestamp": 1679901692026, + "version": "1.2.32" + }, + "libxmlsec1-1.2.32-hd42b715_0.tar.bz2": { + "build": "hd42b715_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "libgcrypt >=1.9.3,<2.0a0", + "libgpg-error >=1.42,<2.0a0", + "libtool >=2.4.6,<3.0a0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "openssl >=1.1.1l,<1.1.2a", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<2.0a0" + ], + "license": "MIT and MPL-1.1", + "license_family": "MIT", + "md5": "b91a43a16c9ff784be4890f2b4908475", + "name": "libxmlsec1", + "sha256": "95f9a8c064de3b2df17995f303b9350e9b8a83cee638c0167c21d086cadf0a0d", + "size": 652580, + "subdir": "linux-64", + "timestamp": 1636111200451, + "version": "1.2.32" + }, + "libxslt-1.1.29-h78d5cac_6.tar.bz2": { + "build": "h78d5cac_6", + "build_number": 6, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0" + ], + "license": "MIT", + "md5": "e579c1e40cee9354d272a3c7eb0d91b7", + "name": "libxslt", + "sha256": "85faf9f4f752addfaacfa9f1b3503c9050bed284761b7bc333db8822ef23a8d2", + "size": 546673, + "subdir": "linux-64", + "timestamp": 1511294861873, + "version": "1.1.29" + }, + "libxslt-1.1.29-hcf9102b_5.tar.bz2": { + "build": "hcf9102b_5", + "build_number": 5, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0" + ], + "license": "MIT", + "md5": "e9b9007e4b1692a767e67b7ee257a3f9", + "name": "libxslt", + "sha256": "4ff3e238fbbd264d41e077faf42801008610ee50864a49727ce72885a4776ffc", + "size": 545907, + "subdir": "linux-64", + "timestamp": 1505745247786, + "version": "1.1.29" + }, + "libxslt-1.1.32-h1312cb7_0.tar.bz2": { + "build": "h1312cb7_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0" + ], + "license": "MIT", + "md5": "887aa4f2ad7874b1ab4e567b8433c24a", + "name": "libxslt", + "sha256": "c462d615ff00fda883120d198c380113c15b6d76f91717c5686e6296a7030c8b", + "size": 551314, + "subdir": "linux-64", + "timestamp": 1516986820353, + "version": "1.1.32" + }, + "libxslt-1.1.33-h7d1a2b0_0.tar.bz2": { + "build": "h7d1a2b0_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0" + ], + "license": "MIT", + "md5": "33a5cde90b012a948aa6a821d11ebfcb", + "name": "libxslt", + "sha256": "9ca82f37482f19a03ec86a7c0f4393237a04bacca3c1c4c7c25e6ef219796360", + "size": 591009, + "subdir": "linux-64", + "timestamp": 1547922875391, + "version": "1.1.33" + }, + "libxslt-1.1.34-hc22bd24_0.tar.bz2": { + "build": "hc22bd24_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0" + ], + "license": "MIT", + "md5": "a6825af0ce1ffc0aeb97f93df969a265", + "name": "libxslt", + "sha256": "1b29a9cf7bab2ff133d88aaf3de2e2607dba7f1ebbef6ad13577905653dbc5af", + "size": 586769, + "subdir": "linux-64", + "timestamp": 1591988409457, + "version": "1.1.34" + }, + "libxslt-1.1.35-h4e12654_0.tar.bz2": { + "build": "h4e12654_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.14,<2.10.0a0" + ], + "license": "MIT", + "md5": "66e2aa12181bb2911485bdbe125d24c5", + "name": "libxslt", + "sha256": "ea3355a67c5173f3944f09861043ca66eb7dbeff8f385d13528b3aabc0801d0c", + "size": 584199, + "subdir": "linux-64", + "timestamp": 1654075843119, + "version": "1.1.35" + }, + "libxslt-1.1.37-h2085143_0.tar.bz2": { + "build": "h2085143_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5cf6081637452ef997a166754ffc1b73", + "name": "libxslt", + "sha256": "9922a67dfd9bb13889f742b3790f316ec059e70f11e0bee82316d238fe32de4e", + "size": 265384, + "subdir": "linux-64", + "timestamp": 1679578063222, + "version": "1.1.37" + }, + "libzip-1.5.1-h8d318fa_1002.tar.bz2": { + "build": "h8d318fa_1002", + "build_number": 1002, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "47239639e5e1737a553938c039d05a62", + "name": "libzip", + "sha256": "1a41dafe909f6e27343ee2f03cc340bcdf2c49ec03f4ddc9095bfcb08de78034", + "size": 115809, + "subdir": "linux-64", + "timestamp": 1640109303459, + "version": "1.5.1" + }, + "libzip-1.5.1-h8d318fa_1003.tar.bz2": { + "build": "h8d318fa_1003", + "build_number": 1003, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1m,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cf8aad6d86ccb796731aefc4bbe41562", + "name": "libzip", + "sha256": "f80ddcae6919a83be2253407906f558010db00894a1b577b82eea8f56fd2f6e1", + "size": 115929, + "subdir": "linux-64", + "timestamp": 1646852435711, + "version": "1.5.1" + }, + "libzip-1.5.1-h8d318fa_1004.tar.bz2": { + "build": "h8d318fa_1004", + "build_number": 1004, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1n,<1.1.2a", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "86f9a212269ef9ba56f0ff8a91012e9e", + "name": "libzip", + "sha256": "c66743f02b3aa64e282a6fe0bfd22dd22fdbbc820f6b09390f6faa25868eecd7", + "size": 88675, + "subdir": "linux-64", + "timestamp": 1651789268252, + "version": "1.5.1" + }, + "libzip-1.8.0-h5cef20c_0.tar.bz2": { + "build": "h5cef20c_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1o,<1.1.2a", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6cde3e76dc236a20a012e7fc41224315", + "name": "libzip", + "sha256": "32af09699997b89fb3fc5fe2e2665e505faf23275268b7527e1eabae748a4cc0", + "size": 106709, + "subdir": "linux-64", + "timestamp": 1652978513482, + "version": "1.8.0" + }, + "libzopfli-1.0.3-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6d276711374079b0d91ea31ecbe27b31", + "name": "libzopfli", + "sha256": "04e6f97332bc583ad380f0dc6f3f38c766fe15900c29f52c8097b7743ef2b417", + "size": 183622, + "subdir": "linux-64", + "timestamp": 1593197391897, + "version": "1.0.3" + }, + "license-expression-30.0.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "boolean.py >=4.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "244461f5d0b84f3a5f2a26de26d955e0", + "name": "license-expression", + "sha256": "568f121bcaf18073a88ee7d9130e820f1f44cd5860303ee4c6025e169dafdddd", + "size": 95445, + "subdir": "linux-64", + "timestamp": 1663022085127, + "version": "30.0.0" + }, + "license-expression-30.0.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "boolean.py >=4.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "87f7496fb8449033c2c5498c5d7c9ba6", + "name": "license-expression", + "sha256": "44433ab83f3bee18bb100f9c9c00084bd8e131f742320ed17d23bfc0c6ab88b3", + "size": 107115, + "subdir": "linux-64", + "timestamp": 1676844694173, + "version": "30.0.0" + }, + "license-expression-30.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "boolean.py >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3c7ca4b96769e2ae269ffcdfabb3d233", + "name": "license-expression", + "sha256": "ed5c9259d1f611dd4f3e70e2c1cb9a8fcdfe3d60a55736d188f37d8a11911d13", + "size": 95006, + "subdir": "linux-64", + "timestamp": 1663022045248, + "version": "30.0.0" + }, + "license-expression-30.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "boolean.py >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bc15e2113f50a520bde61a0027763b0c", + "name": "license-expression", + "sha256": "5001183a72caa1c8dee31d709d4e4767cc7d02fdfe98040abf79d1baecddc103", + "size": 95148, + "subdir": "linux-64", + "timestamp": 1663021989216, + "version": "30.0.0" + }, + "license-expression-30.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "boolean.py >=4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "67eec59fdde913bb313031f8174fe067", + "name": "license-expression", + "sha256": "b31996a1e1005931492293fbf6c66458b860345cdc249666eb865ce6ae2318a2", + "size": 95191, + "subdir": "linux-64", + "timestamp": 1663022017832, + "version": "30.0.0" + }, + "lightgbm-2.2.1-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47d59c5b347be8ebe1aa91ef53c8ae83", + "name": "lightgbm", + "sha256": "efa2a6603fbe813dcd24f548b2d50450c05d463b43b012bbca3bf8c806128eee", + "size": 943632, + "subdir": "linux-64", + "timestamp": 1543625057268, + "version": "2.2.1" + }, + "lightgbm-2.2.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "beb401515b60b17a180c1e6db2fc21a1", + "name": "lightgbm", + "sha256": "61987b8075c46a259d8e3108e907d6a5440630f5cf9dee16c4684be5c0a5e6d1", + "size": 959576, + "subdir": "linux-64", + "timestamp": 1543625069147, + "version": "2.2.1" + }, + "lightgbm-2.2.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a2b05538474e2e95babc6a29663608f6", + "name": "lightgbm", + "sha256": "5c2269c2f9ea7cad7c23685be146a8747f487a05a64b0280fdb703ab966c32b0", + "size": 962082, + "subdir": "linux-64", + "timestamp": 1543625044113, + "version": "2.2.1" + }, + "lightgbm-2.2.3-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2744a1a9c0cf860bea38fbfe3c2a20be", + "name": "lightgbm", + "sha256": "b0a9aa4fcf71006cc419f52f2cf7f41ade52f345fa84347daef6642e5a643ff7", + "size": 1022723, + "subdir": "linux-64", + "timestamp": 1569435358278, + "version": "2.2.3" + }, + "lightgbm-2.2.3-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4384550f4fab33eb166e298a2b3aa92e", + "name": "lightgbm", + "sha256": "1af5bfabeff27f133af17fc712a4ebe107f38da80a7ef4d2b65d3c896af9da20", + "size": 1023428, + "subdir": "linux-64", + "timestamp": 1569435382322, + "version": "2.2.3" + }, + "lightgbm-2.2.3-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a67d1286c9e4caf64617b2387ff433e0", + "name": "lightgbm", + "sha256": "adfea3e57da18864fea4c7f97a183f8776dbcc6d01a32531a27222780f997e36", + "size": 1027981, + "subdir": "linux-64", + "timestamp": 1569435374229, + "version": "2.2.3" + }, + "lightgbm-2.3.0-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa4e2e7448c7602d3e8292bf0370ae0d", + "name": "lightgbm", + "sha256": "be6b1ec8d296f14d507522476988398626ca8c399186e1db3a9bbd4260ad42d3", + "size": 1092000, + "subdir": "linux-64", + "timestamp": 1573966561878, + "version": "2.3.0" + }, + "lightgbm-2.3.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d2d964b257befda848812bc97259529", + "name": "lightgbm", + "sha256": "e6276bea3e80d50f2a4320309ebccd77515b84393ab23e58eccf4e9e3cbbd22d", + "size": 1094276, + "subdir": "linux-64", + "timestamp": 1573966564271, + "version": "2.3.0" + }, + "lightgbm-2.3.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83df95a9cf873f4509138076e390a13e", + "name": "lightgbm", + "sha256": "eb21d6c17f751b01c0bbac14054d860b16b27412aa156fb6c6ff86ad5046851e", + "size": 1083528, + "subdir": "linux-64", + "timestamp": 1573966611991, + "version": "2.3.0" + }, + "lightgbm-2.3.0-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "82f31d3c0b92f4d491de2803d492d3b1", + "name": "lightgbm", + "sha256": "b538de09930b4926a4933b9269f0c5c298631b7cbcd4287fa537508e1e50eb7a", + "size": 1076563, + "subdir": "linux-64", + "timestamp": 1574412880732, + "version": "2.3.0" + }, + "lightgbm-3.1.1-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e987f8674cd8f7873e4c0309c92530c", + "name": "lightgbm", + "sha256": "ebda581676a4ea91571b5eeb58e009a582f982f86c4a8a9fbc022c6dd60dbc76", + "size": 1508406, + "subdir": "linux-64", + "timestamp": 1607536112798, + "version": "3.1.1" + }, + "lightgbm-3.1.1-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16d2c7fd5b3bc13fed4ebd350190a523", + "name": "lightgbm", + "sha256": "7f6b2d7b629c5c1411811a3c4af12e88cff07a0227c4b8429cce8d13efbef85a", + "size": 1484784, + "subdir": "linux-64", + "timestamp": 1607536084787, + "version": "3.1.1" + }, + "lightgbm-3.1.1-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "70ba0725215260bad29db3f3d2d4a6d5", + "name": "lightgbm", + "sha256": "2885e723d1f452950828224786b7c72cade2314f6457b0e9420c1cb1f662defe", + "size": 1486323, + "subdir": "linux-64", + "timestamp": 1607536069312, + "version": "3.1.1" + }, + "lightgbm-3.1.1-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11d47b99bffa90cb677df8a62a6526c9", + "name": "lightgbm", + "sha256": "bbdb72e60c8062495a15045780525c736c0f0c2da5f8907238984bccbb63129e", + "size": 1513283, + "subdir": "linux-64", + "timestamp": 1614247416843, + "version": "3.1.1" + }, + "lightgbm-3.2.1-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy", + "python >=3.10,<3.11.0a0", + "scikit-learn !=0.22.0", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0929aaf26773e032a030e5faeae1f67d", + "name": "lightgbm", + "sha256": "6f4f1c5ab6f16713c8c03ee096d02bfe84457fe15b86825afedca747a64d086a", + "size": 1694367, + "subdir": "linux-64", + "timestamp": 1640812315695, + "version": "3.2.1" + }, + "lightgbm-3.2.1-py36h295c915_0.tar.bz2": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn !=0.22.0", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8582061010c31f4666a713f8ccc2f949", + "name": "lightgbm", + "sha256": "ab604b4f4aed0a54cce640cf379d10cecda00dc8cb8f689d7fc1fa8684cfbe23", + "size": 1715046, + "subdir": "linux-64", + "timestamp": 1633019330387, + "version": "3.2.1" + }, + "lightgbm-3.2.1-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn !=0.22.0", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "814d6966f05e883ee659352c2e2a6a3e", + "name": "lightgbm", + "sha256": "7ccff78a4f7aed40a86f1147e3b70a63fe93d157815ecc7bbfae935cfd71ee98", + "size": 1692255, + "subdir": "linux-64", + "timestamp": 1633019245678, + "version": "3.2.1" + }, + "lightgbm-3.2.1-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn !=0.22.0", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "89873e17f668cfeda063522f406c6fc2", + "name": "lightgbm", + "sha256": "fec8f1e41b70980e570931ae23218c37497d36f620cc4d4fa6df49daa4af8f03", + "size": 1695156, + "subdir": "linux-64", + "timestamp": 1633008815333, + "version": "3.2.1" + }, + "lightgbm-3.2.1-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn !=0.22.0", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4f4ee476711148b93decb8c48a367d1", + "name": "lightgbm", + "sha256": "12a709bd87b805d8b605b42f44deaecee4254865f1b92d9a0a660e3bc9de0372", + "size": 1708330, + "subdir": "linux-64", + "timestamp": 1633019335543, + "version": "3.2.1" + }, + "lightgbm-3.3.5-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.10,<3.11.0a0", + "scikit-learn !=0.22.0", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eaa5ad39b437427f6431e217687cb964", + "name": "lightgbm", + "sha256": "a58f005b5db9cf71513c239b09b6b6272c4c903ba637013a4b5cc4165e65dd50", + "size": 1905302, + "subdir": "linux-64", + "timestamp": 1677766611806, + "version": "3.3.5" + }, + "lightgbm-3.3.5-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.11,<3.12.0a0", + "scikit-learn !=0.22.0", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec35179db772ee0d278d04c86eb1768c", + "name": "lightgbm", + "sha256": "4f28922b7589ecf40c0dd63bd3acf923a747a887e2e40bc7ee3f817790c4ec4f", + "size": 1954651, + "subdir": "linux-64", + "timestamp": 1677700446736, + "version": "3.3.5" + }, + "lightgbm-3.3.5-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn !=0.22.0", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b1d23fcf4625acca5349c865699f740", + "name": "lightgbm", + "sha256": "3aac04bcc95519b7d67f43ff3eda70e2951c11af51c6393279a81238ef1aecce", + "size": 1901661, + "subdir": "linux-64", + "timestamp": 1677766847806, + "version": "3.3.5" + }, + "lightgbm-3.3.5-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn !=0.22.0", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "41c311d9377be389217881774d925cef", + "name": "lightgbm", + "sha256": "25771f98cfd4e77b7ab0929a0b5c3acfa9ba7b2bd16a2a05ca4346226af51b26", + "size": 1903525, + "subdir": "linux-64", + "timestamp": 1677766730638, + "version": "3.3.5" + }, + "lightning-utilities-0.7.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=17.1", + "python >=3.10,<3.11.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0f362fd0a5992fec6d54180f6a14ccc1", + "name": "lightning-utilities", + "sha256": "406f7b659cc6ae4aa29e03d9aaf6298798221908f4e56322e65beb8d504d1348", + "size": 29790, + "subdir": "linux-64", + "timestamp": 1677510363916, + "version": "0.7.1" + }, + "lightning-utilities-0.7.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata >=4.0.0", + "packaging >=17.1", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "662581455279ba4ce8d10b3dc28f625a", + "name": "lightning-utilities", + "sha256": "7fb4b167df4057387f232603c57865d53ce7ece1914ec5f3464fde8b458014e8", + "size": 29447, + "subdir": "linux-64", + "timestamp": 1677510413507, + "version": "0.7.1" + }, + "lightning-utilities-0.7.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=17.1", + "python >=3.8,<3.9.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d507b5039819d6d17616b3b056b3d7a5", + "name": "lightning-utilities", + "sha256": "cd125681320862f409ee079eeb5f329dbde20452f235af44edef5b9080a6830c", + "size": 29634, + "subdir": "linux-64", + "timestamp": 1677510388593, + "version": "0.7.1" + }, + "lightning-utilities-0.7.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=17.1", + "python >=3.9,<3.10.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3ecb0ab1a5b9e4445d4d10319e1dfa98", + "name": "lightning-utilities", + "sha256": "7c438b561983647465b2b79281535b438ac74f34dc70c90397578e47232eb66d", + "size": 29556, + "subdir": "linux-64", + "timestamp": 1677510338880, + "version": "0.7.1" + }, + "lighttpd-1.4.50-h334f0b8_0.tar.bz2": { + "build": "h334f0b8_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.2.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "openssl >=1.0.2p,<1.0.3a", + "pcre >=8.42,<9.0a0", + "sqlite >=3.24.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "10b2f373c59d0ab0612fc1e180772c2a", + "name": "lighttpd", + "sha256": "5207c44e09c91a1a425793d1626af1a5de5616da0c68d4528cd0414e014fd666", + "size": 346554, + "subdir": "linux-64", + "timestamp": 1534674947922, + "version": "1.4.50" + }, + "lighttpd-1.4.51-h3fd3949_1.tar.bz2": { + "build": "h3fd3949_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "krb5 >=1.19.4,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "libxml2 >=2.10.3,<2.11.0a0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre >=8.45,<9.0a0", + "sqlite >=3.41.1,<4.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d93b4539a43ed9b21df0cc0da522c78", + "name": "lighttpd", + "sha256": "794e8e20591fbd836265107af611d0b2865c8fc0297a670f433bfbef1cfed7c1", + "size": 339911, + "subdir": "linux-64", + "timestamp": 1679578399483, + "version": "1.4.51" + }, + "lighttpd-1.4.51-hccf73bf_0.tar.bz2": { + "build": "hccf73bf_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "openssl >=1.1.1a,<1.1.2a", + "pcre >=8.42,<9.0a0", + "sqlite >=3.25.2,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5d53e0a32ee93a6b88f6ec05bb369fd8", + "name": "lighttpd", + "sha256": "c5be8d52dce600860f068959d66cf6c8ef835fded3a5d6a226bcbbd93d417db8", + "size": 344981, + "subdir": "linux-64", + "timestamp": 1541011665435, + "version": "1.4.51" + }, + "line_profiler-2.1.2-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "ipython >=0.13", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "1c0c91210393ba34a8b5f5b135972b27", + "name": "line_profiler", + "sha256": "f2f34e4fc2ea5a4038f584de684b013a435519f23d517bc3a979c3d8648eec92", + "size": 64311, + "subdir": "linux-64", + "timestamp": 1522774147770, + "version": "2.1.2" + }, + "line_profiler-2.1.2-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "ipython >=0.13", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "ccfdd54758e768c76748b8f7ebe314a9", + "name": "line_profiler", + "sha256": "1d9577eb10f735c914bfe00c9d9d08fcdc04045ca2fa037c7c8c94c20f169006", + "size": 64457, + "subdir": "linux-64", + "timestamp": 1522774155546, + "version": "2.1.2" + }, + "line_profiler-2.1.2-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "ipython >=0.13", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "1686da4cfdb0bb95aa9d6bce6bedd0ea", + "name": "line_profiler", + "sha256": "d10f1b69b8f3653dd11ed8d5825b4fc31b66cbce5dbdac5ad2c0221355ad4605", + "size": 65136, + "subdir": "linux-64", + "timestamp": 1522773913002, + "version": "2.1.2" + }, + "line_profiler-2.1.2-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "ipython >=0.13", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "3ad81de692e2f86f27b5a6d886bb1638", + "name": "line_profiler", + "sha256": "0d883c13a71a9f215af8671c907ab65aac83bc39e5703fcde64116a427353834", + "size": 68071, + "subdir": "linux-64", + "timestamp": 1530898397461, + "version": "2.1.2" + }, + "line_profiler-2.1.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "ipython >=0.13", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "3434776b41e413ec0eb6e5ad51b9a0c7", + "name": "line_profiler", + "sha256": "45b771d6124b72b6e2d49323816ee527dc180f5d69ea989325a07d91084bfbab", + "size": 70590, + "subdir": "linux-64", + "timestamp": 1574235796144, + "version": "2.1.2" + }, + "line_profiler-3.3.1-py310hd09550d_0.tar.bz2": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "ipython >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "1259d2a68997fd92798244c15a29b394", + "name": "line_profiler", + "sha256": "b03de8fe0977904cd554ddec8d9ce9fa2598132234223212c5ef78c3217f8134", + "size": 72812, + "subdir": "linux-64", + "timestamp": 1642674911590, + "version": "3.3.1" + }, + "line_profiler-3.3.1-py37hd09550d_0.tar.bz2": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "ipython >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "522417e017a8862d75a6444515f82630", + "name": "line_profiler", + "sha256": "4e3b9fcf2bd7f1a0b0f047b5649197069ccc7277d9305ae2fd37a2e055fedfaf", + "size": 65870, + "subdir": "linux-64", + "timestamp": 1642087268983, + "version": "3.3.1" + }, + "line_profiler-3.3.1-py38hd09550d_0.tar.bz2": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "ipython >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "47320104b6a42a99d120fd38e3b74ffa", + "name": "line_profiler", + "sha256": "d8c2c2bf2a5cd777016cf16c27d0063c86311d5c739c23b2fdd0a417a7549eb1", + "size": 69920, + "subdir": "linux-64", + "timestamp": 1642087304655, + "version": "3.3.1" + }, + "line_profiler-3.3.1-py39hd09550d_0.tar.bz2": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "ipython >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "bfe8160736defd74bbaac65b3f63fa24", + "name": "line_profiler", + "sha256": "57a956b1b2c39acd6c0048c1d681358fd949ce59ff7439318bc2a5c9b8aa35f3", + "size": 69907, + "subdir": "linux-64", + "timestamp": 1642087232099, + "version": "3.3.1" + }, + "linecache2-1.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 1.0", + "md5": "d707dc5315d41eaf89c438f10cf9a62a", + "name": "linecache2", + "sha256": "70329e58a012349e778ac9b468fdd0557229326add5737a0015d77a44c4186a3", + "size": 24415, + "subdir": "linux-64", + "timestamp": 1530898427744, + "version": "1.0.0" + }, + "linecache2-1.0.0-py27hc477507_0.tar.bz2": { + "build": "py27hc477507_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 1.0", + "md5": "b2420a4a5b7bfd22068512a009fc8c26", + "name": "linecache2", + "sha256": "984db37b0f8c609a77f592ad0310572c050514dcf79b7ef369f1a41d8bfb9994", + "size": 24748, + "subdir": "linux-64", + "timestamp": 1508303281657, + "version": "1.0.0" + }, + "linecache2-1.0.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "PSF 1.0", + "md5": "4cadbe0b9839a89e8319eeb5018b3759", + "name": "linecache2", + "sha256": "65d6f63dae4536e0db7745a0143ff0a734b44f5529e73b921af9fb76ab014e5e", + "size": 26980, + "subdir": "linux-64", + "timestamp": 1642499453271, + "version": "1.0.0" + }, + "linecache2-1.0.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "PSF 1.0", + "md5": "467df1e6b70d74133350d26c85b7fece", + "name": "linecache2", + "sha256": "192791b3e1a6344646d653c1119d3044c2ee0587d0249e1fe63a5c8e3ade14aa", + "size": 37249, + "subdir": "linux-64", + "timestamp": 1676844708741, + "version": "1.0.0" + }, + "linecache2-1.0.0-py35h4c29c73_0.tar.bz2": { + "build": "py35h4c29c73_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "PSF 1.0", + "md5": "0bdee2e28ae36a83b89bfd259cd0b58a", + "name": "linecache2", + "sha256": "c150fa4b452b1f4c9e621c73c0f395f90df36b8950003a4fec5741af32a2a4bb", + "size": 26742, + "subdir": "linux-64", + "timestamp": 1508303284304, + "version": "1.0.0" + }, + "linecache2-1.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF 1.0", + "md5": "35b967522574a6f9b759006110ed4900", + "name": "linecache2", + "sha256": "6059610dd0ab8a24a58b73e17cb8057ef695a63175f13b74b061eb9d79808318", + "size": 26221, + "subdir": "linux-64", + "timestamp": 1530898483874, + "version": "1.0.0" + }, + "linecache2-1.0.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF 1.0", + "md5": "3f8b245e6fa869cab36ff5ed21728a1d", + "name": "linecache2", + "sha256": "ebdc09813a3ff8d90e5954a93ae4c825ce31ee1e8c1071bdd51e87917dc82f8e", + "size": 27473, + "subdir": "linux-64", + "timestamp": 1632843428671, + "version": "1.0.0" + }, + "linecache2-1.0.0-py36h9981fe4_0.tar.bz2": { + "build": "py36h9981fe4_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF 1.0", + "md5": "d2d0335faf7f1e0eac6702534eb24981", + "name": "linecache2", + "sha256": "e8ce16f17923cc1eafb68f00344cc06a703f90d6c08393b3edfd8489cc0e8885", + "size": 26590, + "subdir": "linux-64", + "timestamp": 1508303293240, + "version": "1.0.0" + }, + "linecache2-1.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF 1.0", + "md5": "579ef6ef21d381dbd8576971260cd93c", + "name": "linecache2", + "sha256": "152b6d9448e51233006acf19bca73bfaf1d585dd5cbd77c21cc94ee44e427698", + "size": 26264, + "subdir": "linux-64", + "timestamp": 1530898455164, + "version": "1.0.0" + }, + "linecache2-1.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF 1.0", + "md5": "faeb3d6feef4dabd1b6e4a71b70a190b", + "name": "linecache2", + "sha256": "88b0cbbef3e83af00d2dd6e221c111e39fef2446a598b40ed49003c3fc4a66e2", + "size": 27514, + "subdir": "linux-64", + "timestamp": 1632843242996, + "version": "1.0.0" + }, + "linecache2-1.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF 1.0", + "md5": "737977b5f722a267d9f2a9139b26bd8e", + "name": "linecache2", + "sha256": "f7baef5fc28f925bbc35da599045e5e95be7b996255105cd7c10bc27d36ad901", + "size": 26931, + "subdir": "linux-64", + "timestamp": 1573489840960, + "version": "1.0.0" + }, + "linecache2-1.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF 1.0", + "md5": "bd0a26ca6c64e104d835a70ccbe9616d", + "name": "linecache2", + "sha256": "3cb588e43dd9816e6ef329fa085368de27705c84fd8d7ce349656f6ca5e64458", + "size": 27627, + "subdir": "linux-64", + "timestamp": 1632843426559, + "version": "1.0.0" + }, + "linecache2-1.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF 1.0", + "md5": "a855d9857a21a43f2953291197cf891d", + "name": "linecache2", + "sha256": "ecfc447bd1250fcc38099a2974a4622aa9b02c58b58dd5fc8001a353fcd42c1e", + "size": 27718, + "subdir": "linux-64", + "timestamp": 1632833017245, + "version": "1.0.0" + }, + "linkify-it-py-2.0.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "uc-micro-py >=1.0.1,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc293648b9caa345b01ac5f9a90392de", + "name": "linkify-it-py", + "sha256": "620fbc4a92da4de3084bd55c609f16c33b241b6d21255ed9dd3e762d415c50ef", + "size": 35342, + "subdir": "linux-64", + "timestamp": 1659783460274, + "version": "2.0.0" + }, + "linkify-it-py-2.0.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "uc-micro-py >=1.0.1,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ed7caf2816c8b85b67b6f4e8833cbd5", + "name": "linkify-it-py", + "sha256": "fd8e30beb8c9442f16e6617fac92dd0c89ec823e98f06e60f712147380ead35f", + "size": 41155, + "subdir": "linux-64", + "timestamp": 1676837080881, + "version": "2.0.0" + }, + "linkify-it-py-2.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "uc-micro-py >=1.0.1,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d7702b0cdd76a279fa9f518cc82989fc", + "name": "linkify-it-py", + "sha256": "474acb4af1d501126d0e710b3048a13b66b7169d360fa4a8337698d468c45255", + "size": 36764, + "subdir": "linux-64", + "timestamp": 1659783420814, + "version": "2.0.0" + }, + "linkify-it-py-2.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "uc-micro-py >=1.0.1,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "217b2c43172c2eca6b97ecbcb98cb5de", + "name": "linkify-it-py", + "sha256": "c53090f78c23f9d9e3c5862f23e444dac7c0df5d0f668043de0841cbf439f4a9", + "size": 37078, + "subdir": "linux-64", + "timestamp": 1659783395053, + "version": "2.0.0" + }, + "linkify-it-py-2.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "uc-micro-py >=1.0.1,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d40d6b6ea51683b29a9e210831db4a13", + "name": "linkify-it-py", + "sha256": "0e4d61ed508712fc16117fc41f0f5bfedd319cfefd114749689db5f78242b0a5", + "size": 35171, + "subdir": "linux-64", + "timestamp": 1659783489143, + "version": "2.0.0" + }, + "lit-11.1.0-py310h06a4308_5.tar.bz2": { + "build": "py310h06a4308_5", + "build_number": 5, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "72956af1b994538c8d2d050e5c7f5c7f", + "name": "lit", + "sha256": "e073e274cd35137cb59858ae9c25229db34a610b0e2f53a9dc031a7c3336fe4f", + "size": 173773, + "subdir": "linux-64", + "timestamp": 1662598064569, + "version": "11.1.0" + }, + "lit-11.1.0-py310h06a4308_6.tar.bz2": { + "build": "py310h06a4308_6", + "build_number": 6, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "5f7b1aaecebec74f61c5de382f117639", + "name": "lit", + "sha256": "b2e78904d5b54c41655cf53d4b6c395abd0f5f69d420e0a25fb3be29f9459639", + "size": 156847, + "subdir": "linux-64", + "timestamp": 1665079326433, + "version": "11.1.0" + }, + "lit-11.1.0-py37h06a4308_5.tar.bz2": { + "build": "py37h06a4308_5", + "build_number": 5, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "2545902aaab0ff4ebf86b82a5a021d1d", + "name": "lit", + "sha256": "cdf8ba07d754a81a4ce6e616b70ea3fff8945a31380cbf76acd02ae9fd7f109f", + "size": 173247, + "subdir": "linux-64", + "timestamp": 1662598074866, + "version": "11.1.0" + }, + "lit-11.1.0-py37h06a4308_6.tar.bz2": { + "build": "py37h06a4308_6", + "build_number": 6, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "03533965c041afb70b593b7004160343", + "name": "lit", + "sha256": "410348caaa87f68f0e858b5632ecf68ac71634698da2cd944eeb355f3c276dd6", + "size": 155712, + "subdir": "linux-64", + "timestamp": 1665079316322, + "version": "11.1.0" + }, + "lit-11.1.0-py38h06a4308_5.tar.bz2": { + "build": "py38h06a4308_5", + "build_number": 5, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "21ab873889a950890a4f5add96304316", + "name": "lit", + "sha256": "4a6cce6a00b6a1415134962b449f84b8ec1fd427e4bcc15f2a06f7174d9feeeb", + "size": 173068, + "subdir": "linux-64", + "timestamp": 1662598053870, + "version": "11.1.0" + }, + "lit-11.1.0-py38h06a4308_6.tar.bz2": { + "build": "py38h06a4308_6", + "build_number": 6, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "650b82c6c5520b5b96c53f5b00643a76", + "name": "lit", + "sha256": "7281e50d2b5962f2b991a8efe9b616610ffebb5767402c0cfb02248944159b54", + "size": 156089, + "subdir": "linux-64", + "timestamp": 1665079345892, + "version": "11.1.0" + }, + "lit-11.1.0-py39h06a4308_5.tar.bz2": { + "build": "py39h06a4308_5", + "build_number": 5, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "3f781df9d7fead610e432af5bee40488", + "name": "lit", + "sha256": "8a5667762a41b8f8c3c49dbea1ce3cac7b3f6ee855f0a6b91b4f8dded2e45055", + "size": 173171, + "subdir": "linux-64", + "timestamp": 1662598043534, + "version": "11.1.0" + }, + "lit-11.1.0-py39h06a4308_6.tar.bz2": { + "build": "py39h06a4308_6", + "build_number": 6, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "bed02d61a75c405f76092bf3ce6900fd", + "name": "lit", + "sha256": "3fb181d65e0189d6b721edd032cbe33223aad6d695f4873077823df09edf9e0c", + "size": 155971, + "subdir": "linux-64", + "timestamp": 1665079336216, + "version": "11.1.0" + }, + "lit-14.0.6-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "0e7641d8aea8e138e936201de04fb90d", + "name": "lit", + "sha256": "7db01701a80a96fc1cb8ae8a3a66c481e6a85154ee4f3e95ff4849e18625e2f0", + "size": 183741, + "subdir": "linux-64", + "timestamp": 1661449658029, + "version": "14.0.6" + }, + "lit-14.0.6-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "b629689e0c0731c8ea1811266999383e", + "name": "lit", + "sha256": "ff7e337adf21a619a2a30e3fe2f54f89e3f6f0e9c3c947985062e17eb1a5dbf4", + "size": 183050, + "subdir": "linux-64", + "timestamp": 1669293249820, + "version": "14.0.6" + }, + "lit-14.0.6-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "bda82508a260ce05f46d3f7182ce749a", + "name": "lit", + "sha256": "6660a7cbcc11a5d0a08a35d853e1851d5a07959603466b8580639c9672a27d6a", + "size": 230418, + "subdir": "linux-64", + "timestamp": 1676858397032, + "version": "14.0.6" + }, + "lit-14.0.6-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "b2d8f419570742950728fa0fd6ea8b41", + "name": "lit", + "sha256": "efa00774dc98e84e68994592d713f4d20f254852f8478cf377114fa471f290af", + "size": 182397, + "subdir": "linux-64", + "timestamp": 1661449623622, + "version": "14.0.6" + }, + "lit-14.0.6-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "2bb4b8c2340fcf1cb9d5bf3395fae47f", + "name": "lit", + "sha256": "e99c1b53af8b593a6fca095e5c34f550359912ebec7c8b36bb140e2b34881b29", + "size": 181735, + "subdir": "linux-64", + "timestamp": 1669293259278, + "version": "14.0.6" + }, + "lit-14.0.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "be0f427a859faa42ed7b6f7c37fb5985", + "name": "lit", + "sha256": "9e7e0c1fc3d0cd59540bcdb2537b6f8b50d98ca8ff2af133f8a4f8e524ab1aa8", + "size": 182836, + "subdir": "linux-64", + "timestamp": 1661449647636, + "version": "14.0.6" + }, + "lit-14.0.6-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "4e95f57eb39c766f0502649882ed285c", + "name": "lit", + "sha256": "a12ef7c1c9d8e3153111e6dd65a76fcece3d63e15a32c4ffab4e64a9a403f9b5", + "size": 182890, + "subdir": "linux-64", + "timestamp": 1669293239691, + "version": "14.0.6" + }, + "lit-14.0.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "418f71073ed01d30d7d5d20e89770984", + "name": "lit", + "sha256": "dd4fd0e8b1443f42a3cfacf6392258768830b4450c6be338b0bd659e9eea8056", + "size": 182827, + "subdir": "linux-64", + "timestamp": 1661449637629, + "version": "14.0.6" + }, + "lit-14.0.6-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "b04a765702495fb9f8a3ecea27f13614", + "name": "lit", + "sha256": "d69764481fddcdda575d57811b3f084acccce2fcbe613270c8e9130253ab8163", + "size": 182942, + "subdir": "linux-64", + "timestamp": 1669293230178, + "version": "14.0.6" + }, + "lld-14.0.6-hbe14939_0.tar.bz2": { + "build": "hbe14939_0", + "build_number": 0, + "constrains": [ + "llvm ==14.0.6" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "f092d9bf9afe98edfe407a20872055af", + "name": "lld", + "sha256": "acb9fe0ce530f38c7fa2aa57848818d61126159e3f89b579fba15772f008b55a", + "size": 4478712, + "subdir": "linux-64", + "timestamp": 1662539715612, + "version": "14.0.6" + }, + "llvm-10.0.0-h21ff451_1.tar.bz2": { + "build": "h21ff451_1", + "build_number": 1, + "constrains": [ + "llvmdev 10.0.0" + ], + "depends": [ + "libllvm10 10.0.0 h4a3c616_1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "e42c1b1da9d17c4b8b5be3d58e0b5966", + "name": "llvm", + "sha256": "db9fc885669da54af5dfabd2b1c25d880d8f8b17d4317e7b2bc879f5ec418818", + "size": 66699, + "subdir": "linux-64", + "timestamp": 1594485764666, + "version": "10.0.0" + }, + "llvm-10.0.1-h21ff451_5.tar.bz2": { + "build": "h21ff451_5", + "build_number": 5, + "constrains": [ + "llvmdev 10.0.1" + ], + "depends": [ + "libllvm10 10.0.1 hbcb73fb_5" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "a064ecf8ce8be942285c6b0c22900bdf", + "name": "llvm", + "sha256": "c0f344bbc77c3d72dd5cfc4947b80c1a3d6843d3f3344d6bcc307e03831f54bd", + "size": 67091, + "subdir": "linux-64", + "timestamp": 1599257532356, + "version": "10.0.1" + }, + "llvm-11.0.0-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "constrains": [ + "llvmdev 11.0.0" + ], + "depends": [ + "libllvm11 11.0.0 h3826bc1_0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "5ac19dfd1fba4979afb432c30b8a5143", + "name": "llvm", + "sha256": "5565a1efbc8ef40844414665a92d9e0104a7b3261a35200946f872e65e82ecfa", + "size": 69517, + "subdir": "linux-64", + "timestamp": 1626720923008, + "version": "11.0.0" + }, + "llvm-11.0.0-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "constrains": [ + "llvmdev 11.0.0" + ], + "depends": [ + "libllvm11 11.0.0 h3826bc1_1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "1efa434f74e46fd6b4a47d242b3b380a", + "name": "llvm", + "sha256": "e4464307c26bcfa3253fd330a80988b79154d82b9b57be46e529d31ec263e9b5", + "size": 71469, + "subdir": "linux-64", + "timestamp": 1646054295328, + "version": "11.0.0" + }, + "llvm-11.1.0-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "constrains": [ + "llvmdev 11.1.0" + ], + "depends": [ + "libllvm11 11.1.0 h3826bc1_0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "30aafa3bfdc175b083e054ea20fde12f", + "name": "llvm", + "sha256": "6cca58fd3baf6d914c59a5e5870a5135e252824e3ab13f6db99820f636152615", + "size": 72206, + "subdir": "linux-64", + "timestamp": 1624906857917, + "version": "11.1.0" + }, + "llvm-11.1.0-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "constrains": [ + "llvmdev 11.1.0" + ], + "depends": [ + "libllvm11 11.1.0 h3826bc1_1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "3611262a4f761c40aff51c4b39a88155", + "name": "llvm", + "sha256": "5a4969dce18079d4df60f623d56a85cca5a9cd05d977e941b9097dc5c408b7e5", + "size": 53654, + "subdir": "linux-64", + "timestamp": 1647523930959, + "version": "11.1.0" + }, + "llvm-11.1.0-h06a4308_5.tar.bz2": { + "build": "h06a4308_5", + "build_number": 5, + "constrains": [ + "llvmdev 11.1.0" + ], + "depends": [ + "libllvm11 11.1.0 h9e868ea_5" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "22696df89f858f63d46e776b613ddc45", + "name": "llvm", + "sha256": "2f991b8677724a5ff9e03827f50fb24621c1b7a4945586aec15a6d470a759398", + "size": 54798, + "subdir": "linux-64", + "timestamp": 1662598084620, + "version": "11.1.0" + }, + "llvm-11.1.0-h06a4308_6.tar.bz2": { + "build": "h06a4308_6", + "build_number": 6, + "constrains": [ + "llvmdev 11.1.0" + ], + "depends": [ + "libllvm11 11.1.0 h9e868ea_6" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "5bd33c754298d8d6c495f36e69d1e7b5", + "name": "llvm", + "sha256": "7598ba73217029e417e2e48ffe7e04857a67733997745e9ec56a23246a174627", + "size": 38053, + "subdir": "linux-64", + "timestamp": 1665079353199, + "version": "11.1.0" + }, + "llvm-14.0.6-h5c3875c_0.tar.bz2": { + "build": "h5c3875c_0", + "build_number": 0, + "constrains": [ + "llvmdev 14.0.6" + ], + "depends": [ + "libllvm14 14.0.6 hef93074_0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "fed0c62afaf5ae5fe97260d5bd8967d2", + "name": "llvm", + "sha256": "8f33d79fdd638bc72a130109d65a21b116dd3da2c69a71f20a924f053fd5e432", + "size": 52445, + "subdir": "linux-64", + "timestamp": 1661449666688, + "version": "14.0.6" + }, + "llvm-14.0.6-h5c3875c_1.tar.bz2": { + "build": "h5c3875c_1", + "build_number": 1, + "constrains": [ + "llvmdev 14.0.6" + ], + "depends": [ + "libllvm14 14.0.6 h9e868ea_1", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "e43dbafe73ef53dd04a9621277024491", + "name": "llvm", + "sha256": "14a5ea2edf6c58cd6e2b6ea461fafc1d08073b8de683efcf31635dc19e5dbfb7", + "size": 52439, + "subdir": "linux-64", + "timestamp": 1669293267975, + "version": "14.0.6" + }, + "llvm-9.0.1-h21ff451_0.tar.bz2": { + "build": "h21ff451_0", + "build_number": 0, + "constrains": [ + "llvmdev 9.0.1" + ], + "depends": [ + "libllvm9 9.0.1 h4a3c616_0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "b4e9eb959b7c48fb41e01e22a7d0ea86", + "name": "llvm", + "sha256": "71041906ac5dd0e8d44f112a855720e4cc96d1ea785c61711ca7a59148fffa3d", + "size": 64422, + "subdir": "linux-64", + "timestamp": 1592929469333, + "version": "9.0.1" + }, + "llvm-9.0.1-h21ff451_1.tar.bz2": { + "build": "h21ff451_1", + "build_number": 1, + "constrains": [ + "llvmdev 9.0.1" + ], + "depends": [ + "libllvm9 9.0.1 h4a3c616_1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "ba2d06dff403bcd161d8b34d8a82c29a", + "name": "llvm", + "sha256": "1eb998f052bad8e20d3d3da7f4d945d80bf6751e359055bfedb5b102ea71748d", + "size": 66369, + "subdir": "linux-64", + "timestamp": 1594477718085, + "version": "9.0.1" + }, + "llvm-openmp-14.0.6-h9e868ea_0.tar.bz2": { + "build": "h9e868ea_0", + "build_number": 0, + "constrains": [ + "openmp 14.0.6|14.0.6.*" + ], + "depends": [ + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "187e20b04cb83b3bca7441f03b34b398", + "name": "llvm-openmp", + "sha256": "99032162e3594d861290e618e8af4b1bc5b79220b60b7635c748194401b6db5f", + "size": 7936641, + "subdir": "linux-64", + "timestamp": 1662635605547, + "version": "14.0.6" + }, + "llvm-spirv-11.0.0-hd09550d_0.tar.bz2": { + "build": "hd09550d_0", + "build_number": 0, + "constrains": [ + "llvmdev 11.0.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.0.0,<11.1.0a0", + "libstdcxx-ng >=7.5.0" + ], + "license": "NCSA", + "license_family": "BSD", + "md5": "931a680b5f7a350a76a584fb64ce033c", + "name": "llvm-spirv", + "sha256": "d995f31ff18fa61fbebe0582012bacbd0916bfa85ca9dac9de1126bab01aa829", + "size": 1009190, + "subdir": "linux-64", + "timestamp": 1646149310654, + "version": "11.0.0" + }, + "llvm-tools-10.0.0-h4a3c616_1.tar.bz2": { + "build": "h4a3c616_1", + "build_number": 1, + "constrains": [ + "llvmdev 10.0.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 10.0.0 h4a3c616_1", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "a0103ccddcfc937593cc25389c00710c", + "name": "llvm-tools", + "sha256": "8065bc1e54aae059279e9f1d61b43a44fab43a950df3d7997272d24d1b39d90b", + "size": 5478295, + "subdir": "linux-64", + "timestamp": 1594485791785, + "version": "10.0.0" + }, + "llvm-tools-10.0.1-h4a3c616_5.tar.bz2": { + "build": "h4a3c616_5", + "build_number": 5, + "constrains": [ + "llvmdev 10.0.1" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 10.0.1 hbcb73fb_5", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "b278db4cf6c864e085f7ee4b312d751e", + "name": "llvm-tools", + "sha256": "9e22219c22afa7b8e42dd62ff1873b1e3f9b08f1bf1682e938200324e178ffb3", + "size": 5481413, + "subdir": "linux-64", + "timestamp": 1599257608678, + "version": "10.0.1" + }, + "llvm-tools-11.0.0-h3826bc1_0.tar.bz2": { + "build": "h3826bc1_0", + "build_number": 0, + "constrains": [ + "llvmdev 11.0.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 11.0.0 h3826bc1_0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "d9f1161de28564f454aff89d11b5ebda", + "name": "llvm-tools", + "sha256": "e3e4e3b93ef03fa6ee84a4decd44ccc3b732e3cea4fc66ca504befab0a82be5c", + "size": 14805986, + "subdir": "linux-64", + "timestamp": 1626721175665, + "version": "11.0.0" + }, + "llvm-tools-11.0.0-h3826bc1_1.tar.bz2": { + "build": "h3826bc1_1", + "build_number": 1, + "constrains": [ + "llvmdev 11.0.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 11.0.0 h3826bc1_1", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "09468eff438061778d81189e6fbd4afa", + "name": "llvm-tools", + "sha256": "9134eca6a3e33a1569ce1de608baf3e75bfb2d89e85803396f940a7ecd9f6d8a", + "size": 14822174, + "subdir": "linux-64", + "timestamp": 1646054548533, + "version": "11.0.0" + }, + "llvm-tools-11.1.0-h3826bc1_0.tar.bz2": { + "build": "h3826bc1_0", + "build_number": 0, + "constrains": [ + "llvmdev 11.1.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 11.1.0 h3826bc1_0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "4db143764082eca8a3f10aaa682023b6", + "name": "llvm-tools", + "sha256": "bac15de3337f8b4be494fe29fdd0a5ba082d666d921d42128ff1167a00b5092c", + "size": 14813678, + "subdir": "linux-64", + "timestamp": 1624906919317, + "version": "11.1.0" + }, + "llvm-tools-11.1.0-h3826bc1_1.tar.bz2": { + "build": "h3826bc1_1", + "build_number": 1, + "constrains": [ + "llvmdev 11.1.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 11.1.0 h3826bc1_1", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "c5d8cdd0807c9533b15d58974387c740", + "name": "llvm-tools", + "sha256": "2127fc77713d767e34d3fcdb26cb88185870b58b09ef55ed6090db94fa288ab9", + "size": 14800657, + "subdir": "linux-64", + "timestamp": 1647523984573, + "version": "11.1.0" + }, + "llvm-tools-11.1.0-h9e868ea_5.tar.bz2": { + "build": "h9e868ea_5", + "build_number": 5, + "constrains": [ + "llvmdev 11.1.0" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm11 11.1.0 h9e868ea_5", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "95605bad72b8164eee86d11b60d4a7d7", + "name": "llvm-tools", + "sha256": "737dabddcf25057306cc7f5d8cd6fd217347e96e631acec0f567d6df9ff6a6fb", + "size": 15019955, + "subdir": "linux-64", + "timestamp": 1662598155309, + "version": "11.1.0" + }, + "llvm-tools-11.1.0-h9e868ea_6.tar.bz2": { + "build": "h9e868ea_6", + "build_number": 6, + "constrains": [ + "llvmdev 11.1.0" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm11 11.1.0 h9e868ea_6", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "a68077f814d88c0a5a39a62d50e54cc5", + "name": "llvm-tools", + "sha256": "4ed127194b27c58acfe210352b1435ec5d99200371fbe9020f88d1c1b7931ea8", + "size": 15044340, + "subdir": "linux-64", + "timestamp": 1665079421330, + "version": "11.1.0" + }, + "llvm-tools-14.0.6-h9e868ea_0.tar.bz2": { + "build": "h9e868ea_0", + "build_number": 0, + "constrains": [ + "llvmdev 14.0.6" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 14.0.6 hef93074_0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "bd64bab07bd89445f06cdedd7c6f0507", + "name": "llvm-tools", + "sha256": "5c99502788dc0004cfac183584c0d0c44e407935da9d38a2945b2fa2b334649f", + "size": 16963515, + "subdir": "linux-64", + "timestamp": 1661449680796, + "version": "14.0.6" + }, + "llvm-tools-14.0.6-h9e868ea_1.tar.bz2": { + "build": "h9e868ea_1", + "build_number": 1, + "constrains": [ + "llvmdev 14.0.6" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 14.0.6 h9e868ea_1", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "cf2b5ce36395a111c37c23ea21bc7e63", + "name": "llvm-tools", + "sha256": "98eff3ef2c4e8bbec20261a9b4a30b1463fcdd730ae09a076934f6c68ce78e78", + "size": 16969139, + "subdir": "linux-64", + "timestamp": 1669293280981, + "version": "14.0.6" + }, + "llvm-tools-9.0.1-h4a3c616_0.tar.bz2": { + "build": "h4a3c616_0", + "build_number": 0, + "constrains": [ + "llvmdev 9.0.1" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9 9.0.1 h4a3c616_0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "69207c031acf9f09f499ca07f2948452", + "name": "llvm-tools", + "sha256": "211aa88f4b50cc6e80ab21d0feba41c7360ef23badf610f345fcf2366cc87cb4", + "size": 5123702, + "subdir": "linux-64", + "timestamp": 1592929496217, + "version": "9.0.1" + }, + "llvm-tools-9.0.1-h4a3c616_1.tar.bz2": { + "build": "h4a3c616_1", + "build_number": 1, + "constrains": [ + "llvmdev 9.0.1" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9 9.0.1 h4a3c616_1", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "a151741c2dc765b5e14ac8a394e407a0", + "name": "llvm-tools", + "sha256": "08111a6883744e272bfbdc969abcfcbd35f26a353a58c08fd58b59a9cb6f4a51", + "size": 5124628, + "subdir": "linux-64", + "timestamp": 1594477744543, + "version": "9.0.1" + }, + "llvmdev-10.0.0-h4a3c616_1.tar.bz2": { + "build": "h4a3c616_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 10.0.0 h4a3c616_1", + "libstdcxx-ng >=7.3.0", + "llvm-tools 10.0.0 h4a3c616_1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "89dbf33dac2c5015a7f5734db4fae966", + "name": "llvmdev", + "sha256": "18765c25c2a02e66a4eee9fd19b67d75d96d5638e92bee307e18fd473ef265ce", + "size": 42536507, + "subdir": "linux-64", + "timestamp": 1594485860108, + "version": "10.0.0" + }, + "llvmdev-10.0.1-h4a3c616_5.tar.bz2": { + "build": "h4a3c616_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 10.0.1 hbcb73fb_5", + "libstdcxx-ng >=7.3.0", + "llvm-tools 10.0.1 h4a3c616_5" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "f6aa8bb6a92a3c1bd894bdeedcd5ddae", + "name": "llvmdev", + "sha256": "0290088f07aee1aa52db45c3581096520880cc37001aa0c7da92f50c524cac59", + "size": 42632882, + "subdir": "linux-64", + "timestamp": 1599257693375, + "version": "10.0.1" + }, + "llvmdev-11.0.0-hd09550d_0.tar.bz2": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 11.0.0 h3826bc1_0", + "libstdcxx-ng >=7.5.0", + "llvm-tools 11.0.0 h3826bc1_0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "1332ccd4028adf3c611c6df6571aa4bd", + "name": "llvmdev", + "sha256": "dfe4efa29c492fc7ca069632849b1335877adad428fb61d9e5f92e4d7adc9dd7", + "size": 45888918, + "subdir": "linux-64", + "timestamp": 1626721450232, + "version": "11.0.0" + }, + "llvmdev-11.0.0-hd09550d_1.tar.bz2": { + "build": "hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 11.0.0 h3826bc1_1", + "libstdcxx-ng >=7.5.0", + "llvm-tools 11.0.0 h3826bc1_1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "9defadcd748615b74f24bc688461e02a", + "name": "llvmdev", + "sha256": "c35d456758aa8bc1b9a2c8710c2135de07400e467bc5a682ce6a6685108cd1d6", + "size": 45892666, + "subdir": "linux-64", + "timestamp": 1646054818147, + "version": "11.0.0" + }, + "llvmdev-11.1.0-hd09550d_0.tar.bz2": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 11.1.0 h3826bc1_0", + "libstdcxx-ng >=7.5.0", + "llvm-tools 11.1.0 h3826bc1_0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "89dd7003339e044d9a9d07eb98f18c2b", + "name": "llvmdev", + "sha256": "bc5a9fd42adb3a48f6d67f2267a63734944b865c62c99329d3dccad9a0ce181a", + "size": 45889905, + "subdir": "linux-64", + "timestamp": 1624906994003, + "version": "11.1.0" + }, + "llvmdev-11.1.0-hd09550d_1.tar.bz2": { + "build": "hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 11.1.0 h3826bc1_1", + "libstdcxx-ng >=7.5.0", + "llvm-tools 11.1.0 h3826bc1_1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "53524ff088abcef64932968981d5f54a", + "name": "llvmdev", + "sha256": "2374281004cac3d5270432cb253bc8cbcabe0cfc8a29a3908f116d8f9d42ca45", + "size": 45924468, + "subdir": "linux-64", + "timestamp": 1647524046749, + "version": "11.1.0" + }, + "llvmdev-11.1.0-hdb19cb5_5.tar.bz2": { + "build": "hdb19cb5_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm11 11.1.0 h9e868ea_5", + "libstdcxx-ng >=11.2.0", + "llvm-tools 11.1.0 h9e868ea_5" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "72484f3235744d7ce0e2cb6df499bd84", + "name": "llvmdev", + "sha256": "829efbe3623a1e989bb71173426804fb207d1caadcd41f8c67b1576a92b5f497", + "size": 45877177, + "subdir": "linux-64", + "timestamp": 1662598240724, + "version": "11.1.0" + }, + "llvmdev-11.1.0-hdb19cb5_6.tar.bz2": { + "build": "hdb19cb5_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm11 11.1.0 h9e868ea_6", + "libstdcxx-ng >=11.2.0", + "llvm-tools 11.1.0 h9e868ea_6" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "83a60c35f55ac3a316f60bbc4cc2012c", + "name": "llvmdev", + "sha256": "52b646a8012a488ba067b378aa38c1e1dd65aa14f5c1c8494b7c438ed9d34f52", + "size": 45904846, + "subdir": "linux-64", + "timestamp": 1665079495506, + "version": "11.1.0" + }, + "llvmdev-14.0.6-h9e868ea_0.tar.bz2": { + "build": "h9e868ea_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 14.0.6 hef93074_0", + "libstdcxx-ng >=11.2.0", + "llvm-tools 14.0.6 h9e868ea_0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "c6513c427dd200b0516fa120d3a5dd91", + "name": "llvmdev", + "sha256": "0cd9155826a785cdfcfe7b386bdbe69da4c3c1eae367ade472450f63d78881f6", + "size": 60426265, + "subdir": "linux-64", + "timestamp": 1661449705330, + "version": "14.0.6" + }, + "llvmdev-14.0.6-h9e868ea_1.tar.bz2": { + "build": "h9e868ea_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 14.0.6 h9e868ea_1", + "libstdcxx-ng >=11.2.0", + "llvm-tools 14.0.6 h9e868ea_1", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "0c73ef5d38e079b14d0d591a979c87b1", + "name": "llvmdev", + "sha256": "86d4a94fd0e4a2216b8ab29448603fa3765cb0f521709b311154c764793c78bd", + "size": 60363073, + "subdir": "linux-64", + "timestamp": 1669293305625, + "version": "14.0.6" + }, + "llvmdev-6.0.0-h1a6f6a4_3.tar.bz2": { + "build": "h1a6f6a4_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "NCSA", + "md5": "d20c457a8bb54bc50f9f9f72d90e3cf1", + "name": "llvmdev", + "sha256": "227294c27bcdc352997887cd5d1488ae55a2d6aefce7eaf8bd5e4a3d4397ad2b", + "size": 196668176, + "subdir": "linux-64", + "timestamp": 1526580046000, + "version": "6.0.0" + }, + "llvmdev-6.0.0-h1a6f6a4_4.tar.bz2": { + "build": "h1a6f6a4_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "NCSA", + "md5": "44d63a5734a732cdc573993e6f870c9e", + "name": "llvmdev", + "sha256": "858ef4ad981e9777245cc39ab45ab7305e735972bb3874e675b891f2a1e90ee2", + "size": 197151926, + "subdir": "linux-64", + "timestamp": 1531253789908, + "version": "6.0.0" + }, + "llvmdev-7.0.0-hc6ec683_1.tar.bz2": { + "build": "hc6ec683_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "NCSA", + "md5": "fadda77f7312ae575d25f23377152a49", + "name": "llvmdev", + "sha256": "b9de8b6e5986894f724ce84690c89d7f1b4cabe0481e318200f757e6f9ecec45", + "size": 242277515, + "subdir": "linux-64", + "timestamp": 1546541412675, + "version": "7.0.0" + }, + "llvmdev-8.0.0-hc6ec683_0.tar.bz2": { + "build": "hc6ec683_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "NCSA", + "md5": "98e69d2696aedf2735c09b49a818eaac", + "name": "llvmdev", + "sha256": "8f02fece765019a6be10e9aa79cb14cfdb591e456d569e4f16dcfa8fc6489559", + "size": 294888756, + "subdir": "linux-64", + "timestamp": 1560808928476, + "version": "8.0.0" + }, + "llvmdev-9.0.1-h4a3c616_0.tar.bz2": { + "build": "h4a3c616_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9 9.0.1 h4a3c616_0", + "libstdcxx-ng >=7.3.0", + "llvm-tools 9.0.1 h4a3c616_0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "4be5d1b795ea053a6e89c654975b0395", + "name": "llvmdev", + "sha256": "b1df1913213e2f64ed957ba21c75ee6b20f0f0ab87bf509b8afe103e94a57a8c", + "size": 39802173, + "subdir": "linux-64", + "timestamp": 1592929560509, + "version": "9.0.1" + }, + "llvmdev-9.0.1-h4a3c616_1.tar.bz2": { + "build": "h4a3c616_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9 9.0.1 h4a3c616_1", + "libstdcxx-ng >=7.3.0", + "llvm-tools 9.0.1 h4a3c616_1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "8c6a4a6b2054b8debce47a50d44def70", + "name": "llvmdev", + "sha256": "9c730d648d9b69a2c2f808e9ee7c2b1d7ee4c58f3c8c038838f1611406eae7d2", + "size": 39762488, + "subdir": "linux-64", + "timestamp": 1594477807275, + "version": "9.0.1" + }, + "llvmlite-0.20.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python 2.7*" + ], + "license": "New BSD License", + "md5": "be0e1083f71d7814991f9e62789fee74", + "name": "llvmlite", + "sha256": "defdee7d037e92afe01af893bdda3fdbeb08398fbc0434942f3a3af55a60083b", + "size": 11788860, + "subdir": "linux-64", + "version": "0.20.0" + }, + "llvmlite-0.20.0-py34_0.tar.bz2": { + "build": "py34_0", + "build_number": 0, + "depends": [ + "python 3.4*" + ], + "license": "New BSD License", + "md5": "f1bf04c8eae87ee54f88cf929e0919b3", + "name": "llvmlite", + "sha256": "9cc2dfbc18709561a52c9d81bfd6fca18cd5fc1f061a28e06d574ffce994373a", + "size": 11790537, + "subdir": "linux-64", + "version": "0.20.0" + }, + "llvmlite-0.20.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python 3.5*" + ], + "license": "New BSD License", + "md5": "71a75773dd78d2a08d94008abd33fdf5", + "name": "llvmlite", + "sha256": "c98d2d38dc756930ef2abffbf3eb707c29532aa92d87e9d6d813c0c5bd7722ae", + "size": 11793304, + "subdir": "linux-64", + "version": "0.20.0" + }, + "llvmlite-0.20.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python 3.6*" + ], + "license": "New BSD License", + "md5": "80a000535012892cca5fb40697eaf2b4", + "name": "llvmlite", + "sha256": "9471ec3662b2ad7813bd38efedb8f6201a2266526cee57fbc460cdafe8d35ff7", + "size": 11792967, + "subdir": "linux-64", + "version": "0.20.0" + }, + "llvmlite-0.21.0-py27h6dad3f9_0.tar.bz2": { + "build": "py27h6dad3f9_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "New BSD License", + "md5": "b84cb6a87fbe2979010582cbae298a44", + "name": "llvmlite", + "sha256": "334b138632a0a227364ca24280812803e8529214198916f5f06d49c970276ea8", + "size": 15407390, + "subdir": "linux-64", + "timestamp": 1512594434391, + "version": "0.21.0" + }, + "llvmlite-0.21.0-py35hcfd7307_0.tar.bz2": { + "build": "py35hcfd7307_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "New BSD License", + "md5": "b1fae628a6eee32c32282f05550ee441", + "name": "llvmlite", + "sha256": "5674a70e0e16c6527889e83508d3d45366a2529845933d579c1f5bc3cad97701", + "size": 15423251, + "subdir": "linux-64", + "timestamp": 1512594320688, + "version": "0.21.0" + }, + "llvmlite-0.21.0-py36ha241eea_0.tar.bz2": { + "build": "py36ha241eea_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "New BSD License", + "md5": "531d3338f47629b81da7f95e037136a0", + "name": "llvmlite", + "sha256": "7391fb1aee62d14fbf43455f12423e0a6c56e1052896b83583a528d6ce290390", + "size": 15421178, + "subdir": "linux-64", + "timestamp": 1512594213795, + "version": "0.21.0" + }, + "llvmlite-0.22.0-py27hdbca893_0.tar.bz2": { + "build": "py27hdbca893_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "New BSD License", + "md5": "0a9fef160318e5e9e690f8250fb9b941", + "name": "llvmlite", + "sha256": "edad7030f3a538134e205dbc9ca4fb3242161a04c60f17296ce422fda4527eb2", + "size": 15410406, + "subdir": "linux-64", + "timestamp": 1518736106894, + "version": "0.22.0" + }, + "llvmlite-0.22.0-py35h998887b_0.tar.bz2": { + "build": "py35h998887b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "New BSD License", + "md5": "4385417079b56d6e3fc2f3eb515d5f58", + "name": "llvmlite", + "sha256": "f733d1b6fce169e3b8168a5196607ca08f49d976f0058e7b903d99c51350ca9e", + "size": 15423596, + "subdir": "linux-64", + "timestamp": 1518736194471, + "version": "0.22.0" + }, + "llvmlite-0.22.0-py36ha27ea49_0.tar.bz2": { + "build": "py36ha27ea49_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "New BSD License", + "md5": "bec9c425fff54909ed649c6e36db020a", + "name": "llvmlite", + "sha256": "0c188a2dc3cb461ab078ea5fc1a2e9453631e03865476d1c5199f3cffc5c6521", + "size": 15425429, + "subdir": "linux-64", + "timestamp": 1518736018153, + "version": "0.22.0" + }, + "llvmlite-0.23.1-py27hdbcaa40_0.tar.bz2": { + "build": "py27hdbcaa40_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "fb244a67a98e227dc451c6a63f5cb701", + "name": "llvmlite", + "sha256": "f2a38046207545fc4ee4a84eccaed377153eebe8bd5ab70eaafa10906f166b60", + "size": 16093391, + "subdir": "linux-64", + "timestamp": 1526589142632, + "version": "0.23.1" + }, + "llvmlite-0.23.1-py35hdbcaa40_0.tar.bz2": { + "build": "py35hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "48bdce0489104b2e16296f8018ce2cbe", + "name": "llvmlite", + "sha256": "74c530834475bfd0da81970c82579ace619a3b8afdfff04369bbecaa16907b1b", + "size": 16090376, + "subdir": "linux-64", + "timestamp": 1526588705392, + "version": "0.23.1" + }, + "llvmlite-0.23.1-py36hdbcaa40_0.tar.bz2": { + "build": "py36hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "44b336cb79486fbe2a052d6cadf6ddd3", + "name": "llvmlite", + "sha256": "bcc97fc2ce6e674a0d2c567288b08bef5e0fcae743af5a29844bf88f63a6cbc6", + "size": 16086933, + "subdir": "linux-64", + "timestamp": 1526589136294, + "version": "0.23.1" + }, + "llvmlite-0.23.2-py27hdbcaa40_0.tar.bz2": { + "build": "py27hdbcaa40_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "2b900cd769338d22b402f3758c5156b8", + "name": "llvmlite", + "sha256": "8debaecd0c0ba5ff28546ea15481097acd48e00a3e3fa06d8d48500d05c16b10", + "size": 16091500, + "subdir": "linux-64", + "timestamp": 1529653658578, + "version": "0.23.2" + }, + "llvmlite-0.23.2-py35hdbcaa40_0.tar.bz2": { + "build": "py35hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "e5ec2d7f8241b4f3903bfc10309ba667", + "name": "llvmlite", + "sha256": "8bb7e2869e1b79ffb9ddefcf76635d96dc3b1ff77b8f2b449c29113bc83263ea", + "size": 16089824, + "subdir": "linux-64", + "timestamp": 1529653683188, + "version": "0.23.2" + }, + "llvmlite-0.23.2-py36hdbcaa40_0.tar.bz2": { + "build": "py36hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "d5f8042ccaff78c8e7c26d52a37246c1", + "name": "llvmlite", + "sha256": "df28723a526329a0bbcb005d80f258c5f59e467b641ba02116bed74b4181ae9e", + "size": 16087605, + "subdir": "linux-64", + "timestamp": 1529653636209, + "version": "0.23.2" + }, + "llvmlite-0.24.0-py27hdbcaa40_0.tar.bz2": { + "build": "py27hdbcaa40_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "d8e2aaf8d67258df39c390dc4a6b8f70", + "name": "llvmlite", + "sha256": "5d02340349818ae27e2db85044ec2085e756216d9a6a7ff51f0c0de62dafa58f", + "size": 16095956, + "subdir": "linux-64", + "timestamp": 1531254529598, + "version": "0.24.0" + }, + "llvmlite-0.24.0-py35hdbcaa40_0.tar.bz2": { + "build": "py35hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "ea25c7b18b2529ac1fd4686773416998", + "name": "llvmlite", + "sha256": "aed94578400e9c24ace6ed85bc6bd2c06c3485bebac20fd20f8752cc983999c7", + "size": 16124847, + "subdir": "linux-64", + "timestamp": 1534899269949, + "version": "0.24.0" + }, + "llvmlite-0.24.0-py36hdbcaa40_0.tar.bz2": { + "build": "py36hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "dbe0dcc1ee35f27f61f8caeb539f4a5f", + "name": "llvmlite", + "sha256": "a240e2778e636309c381ee45669af168f0e5850bdf90d5f1df2568ed2a6784bb", + "size": 16090480, + "subdir": "linux-64", + "timestamp": 1531254355022, + "version": "0.24.0" + }, + "llvmlite-0.24.0-py37hdbcaa40_0.tar.bz2": { + "build": "py37hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "7c98a258cc0a32e7e4d981048623a12f", + "name": "llvmlite", + "sha256": "dd6b8e47513e294a24fa0583c2bd3cbb55c8455c3c98e1aaf140c7f2582d7a58", + "size": 16090049, + "subdir": "linux-64", + "timestamp": 1531254181384, + "version": "0.24.0" + }, + "llvmlite-0.25.0-py27hd408876_0.tar.bz2": { + "build": "py27hd408876_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "7876ca7615dac468324e9c4604087bef", + "name": "llvmlite", + "sha256": "0ecf1c3297e88adc44ab6157aa445f252e2691c8fc1d2a5a3450857d29d1dfdf", + "size": 16167469, + "subdir": "linux-64", + "timestamp": 1538584507200, + "version": "0.25.0" + }, + "llvmlite-0.25.0-py36hd408876_0.tar.bz2": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "e85200debaac22b1696803d17798eea8", + "name": "llvmlite", + "sha256": "3353bc31b9b0f807ca761c20d7eb7cb8f355f89c116ecc1679379d265eaeb913", + "size": 16164509, + "subdir": "linux-64", + "timestamp": 1538584526271, + "version": "0.25.0" + }, + "llvmlite-0.25.0-py37hd408876_0.tar.bz2": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "e7231c8884fb2f637495bd0ecaed96aa", + "name": "llvmlite", + "sha256": "7e016106897848f22eb2918c8beda2c7b3357293b3beb1f2498f47433eaec2b8", + "size": 16166217, + "subdir": "linux-64", + "timestamp": 1538584499645, + "version": "0.25.0" + }, + "llvmlite-0.26.0-py27hd408876_0.tar.bz2": { + "build": "py27hd408876_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "3daaa997ff2aa37f6c3e9d5dd55e1935", + "name": "llvmlite", + "sha256": "87bbb0fb549781baf02f2f30a0c23a845a130a44e71f1865aadae9fc92e11d82", + "size": 16179343, + "subdir": "linux-64", + "timestamp": 1543472774125, + "version": "0.26.0" + }, + "llvmlite-0.26.0-py36hd408876_0.tar.bz2": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "6788d79dd88dca09f663ff4b76261c89", + "name": "llvmlite", + "sha256": "781f16f4f5d4605c2aa59cf013509ee096e1a8c3951ae9e866a173cc296e8887", + "size": 16187994, + "subdir": "linux-64", + "timestamp": 1543472970536, + "version": "0.26.0" + }, + "llvmlite-0.26.0-py37hd408876_0.tar.bz2": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "ec86fb780d16da63ec8d75e1dc9a9ebc", + "name": "llvmlite", + "sha256": "d559b367fb0f7406cd818e05145d7f7e2cfc227584764d07d8342744408406cd", + "size": 16180176, + "subdir": "linux-64", + "timestamp": 1543472879621, + "version": "0.26.0" + }, + "llvmlite-0.27.0-py27hd408876_0.tar.bz2": { + "build": "py27hd408876_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "1ebcf7bbf05f5132e71685867226b6b0", + "name": "llvmlite", + "sha256": "bff4432c414031983af4db9a7f23c7dcfc8d2150149be629a81846728ee769ce", + "size": 17003901, + "subdir": "linux-64", + "timestamp": 1546578664408, + "version": "0.27.0" + }, + "llvmlite-0.27.0-py36hd408876_0.tar.bz2": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "0cc9cc876c6a40d142a0ff19234b21be", + "name": "llvmlite", + "sha256": "abefa4c842d9a9b438b502f8830d6ad5ee5bdfd4a004de73ca8574f73f26bf2d", + "size": 17004337, + "subdir": "linux-64", + "timestamp": 1546578766824, + "version": "0.27.0" + }, + "llvmlite-0.27.0-py37hd408876_0.tar.bz2": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "93bb750dac34e4e8aae98d84de891fe7", + "name": "llvmlite", + "sha256": "7c0c9093f269c67c9890f6ba1473d276bb9f9c3d9afc6f8dd41442de534c4ff0", + "size": 16983882, + "subdir": "linux-64", + "timestamp": 1546578695513, + "version": "0.27.0" + }, + "llvmlite-0.28.0-py27hd408876_0.tar.bz2": { + "build": "py27hd408876_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "c2156a239db8ca9e9cdf5f9dd80a838c", + "name": "llvmlite", + "sha256": "8e24037cee85c4c7f1a7197e2580ffdb68589b61e0d3766468c22279195c4f6d", + "size": 15488877, + "subdir": "linux-64", + "timestamp": 1552584680801, + "version": "0.28.0" + }, + "llvmlite-0.28.0-py36hd408876_0.tar.bz2": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "0b37a28e57f33c8e2466285552946ff9", + "name": "llvmlite", + "sha256": "c8f48754d87c02c179ba015ef6f960d326fc487d76cc0121bc22601027cbc9fa", + "size": 15413921, + "subdir": "linux-64", + "timestamp": 1552584740556, + "version": "0.28.0" + }, + "llvmlite-0.28.0-py37hd408876_0.tar.bz2": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "b9bd9d82502d9be5b0025dcd8add5be8", + "name": "llvmlite", + "sha256": "0635cb7bdab390233a11ebcd1d1488ec9206aaad2792a7f83e6b5295f3d2b037", + "size": 15411028, + "subdir": "linux-64", + "timestamp": 1552584717937, + "version": "0.28.0" + }, + "llvmlite-0.29.0-py27hd408876_0.tar.bz2": { + "build": "py27hd408876_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "68616e554937d6b5c9a1e835d4f66fa0", + "name": "llvmlite", + "sha256": "fb85211c39cc2eb394eef4b3663e23049657675b6bd4574357d2d5ff1e84c679", + "size": 18507508, + "subdir": "linux-64", + "timestamp": 1560810383844, + "version": "0.29.0" + }, + "llvmlite-0.29.0-py36hd408876_0.tar.bz2": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "ef808466d9a681a733f77e6416d67472", + "name": "llvmlite", + "sha256": "802b82ecc1e1606d1200541e8851f7d14f75e1b40d3c27bb5386beb59e01902a", + "size": 18521409, + "subdir": "linux-64", + "timestamp": 1560810177736, + "version": "0.29.0" + }, + "llvmlite-0.29.0-py37hd408876_0.tar.bz2": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "f958842cbc89357b294969f9785a81e6", + "name": "llvmlite", + "sha256": "4045fed362aa569e0db37625d1833e8c5b1510b1b20a02682a6771b1973eb996", + "size": 18512109, + "subdir": "linux-64", + "timestamp": 1560810370347, + "version": "0.29.0" + }, + "llvmlite-0.30.0-py27hd408876_0.tar.bz2": { + "build": "py27hd408876_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "107953d330dc6fbc89ae9383c37b960e", + "name": "llvmlite", + "sha256": "abd298c355109ecb6294cd166c48275416d2fc011bd049a62c38d18886e8c20e", + "size": 18524948, + "subdir": "linux-64", + "timestamp": 1572011372010, + "version": "0.30.0" + }, + "llvmlite-0.30.0-py36hd408876_0.tar.bz2": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "de444e02081533bfdea49a2784e7af51", + "name": "llvmlite", + "sha256": "94ce8b4337bc040565079f06a8bb448ef89c623c24a6ce810fc2b1ac6d9c8a9b", + "size": 18512729, + "subdir": "linux-64", + "timestamp": 1572011427938, + "version": "0.30.0" + }, + "llvmlite-0.30.0-py37hd408876_0.tar.bz2": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "8d87a78ca26338789d7c6a846d58bae1", + "name": "llvmlite", + "sha256": "16a72d4dccc5024d9904f59e2e553e04dfaaa563c3b637474d83836bce9f511c", + "size": 18508811, + "subdir": "linux-64", + "timestamp": 1572011396710, + "version": "0.30.0" + }, + "llvmlite-0.30.0-py38hd408876_0.tar.bz2": { + "build": "py38hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "9aa95f55e8894e4813f187040356bcac", + "name": "llvmlite", + "sha256": "ebc59e694d65e5199164cb6c37c75a44c6192865ae45f03b93cedc0ea234f78e", + "size": 18517857, + "subdir": "linux-64", + "timestamp": 1573638790354, + "version": "0.30.0" + }, + "llvmlite-0.31.0-py27hd408876_0.tar.bz2": { + "build": "py27hd408876_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "f3ba949a7108d3025a685df8b8ee9780", + "name": "llvmlite", + "sha256": "9cf645262494e82be73e8a088bbebc02adb047abeac5da80d933c7cd14ecc72f", + "size": 18531763, + "subdir": "linux-64", + "timestamp": 1579016451759, + "version": "0.31.0" + }, + "llvmlite-0.31.0-py36hd408876_0.tar.bz2": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "6fce6ebc3f8103fda359a7be91c0fd54", + "name": "llvmlite", + "sha256": "338a6769023f14eb3601d5c9b7f61c74ce82e73b1522677cc89966caa7811678", + "size": 18511036, + "subdir": "linux-64", + "timestamp": 1579016457991, + "version": "0.31.0" + }, + "llvmlite-0.31.0-py37hd408876_0.tar.bz2": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "a2b23cce5904eff27843063cf9a33670", + "name": "llvmlite", + "sha256": "c96112607ddba07a2fc7e12ad5cbde6787e18d93ec12c5b24ad47a44f21dc63b", + "size": 18508304, + "subdir": "linux-64", + "timestamp": 1579016355125, + "version": "0.31.0" + }, + "llvmlite-0.31.0-py38hd408876_0.tar.bz2": { + "build": "py38hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "fb3461320891132b8e19f3c321f952f6", + "name": "llvmlite", + "sha256": "024ddd36bf7e4b1c6a92598670e8423293bfa7522379935c93f362611e620f63", + "size": 18507473, + "subdir": "linux-64", + "timestamp": 1579016442010, + "version": "0.31.0" + }, + "llvmlite-0.32.0-py36hd408876_0.tar.bz2": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "969191698a52bdc073c6e1d7f54fbbbb", + "name": "llvmlite", + "sha256": "61fa73af77be5b6f8182783afb0bc41cec0a0f5e8712d15bccf7b8f447661af1", + "size": 18486938, + "subdir": "linux-64", + "timestamp": 1587142789645, + "version": "0.32.0" + }, + "llvmlite-0.32.0-py37hd408876_0.tar.bz2": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "7152fdfbfb16b7c9fec79830b303d12d", + "name": "llvmlite", + "sha256": "c0137656ed42ee4145c8fe01512ccd7e42a5fd5d80bfa587a105bc0581787945", + "size": 18499232, + "subdir": "linux-64", + "timestamp": 1587142756861, + "version": "0.32.0" + }, + "llvmlite-0.32.0-py38hd408876_0.tar.bz2": { + "build": "py38hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "87ccc59e152b9e01b260c717d2a631ef", + "name": "llvmlite", + "sha256": "4c6511a53d0559e2e194a001c217f315101895efb70804ce1d1b7b4780546b88", + "size": 18498051, + "subdir": "linux-64", + "timestamp": 1587142810611, + "version": "0.32.0" + }, + "llvmlite-0.32.1-py36hd408876_0.tar.bz2": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "5028ffbbb921d33e862f760881d5985e", + "name": "llvmlite", + "sha256": "c4bf21cf56236c2792a52b4af111302aac57c1c4951a977983c465465dc6ef55", + "size": 18498927, + "subdir": "linux-64", + "timestamp": 1589294284967, + "version": "0.32.1" + }, + "llvmlite-0.32.1-py37hd408876_0.tar.bz2": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "1b4ca0510330e071115368f3ecdf4994", + "name": "llvmlite", + "sha256": "23b42339c5a1ec9e2b90bf9bf3031eb84a338cd3dd17f67e42d9d12bb72f7c80", + "size": 18495384, + "subdir": "linux-64", + "timestamp": 1589294221649, + "version": "0.32.1" + }, + "llvmlite-0.32.1-py38hd408876_0.tar.bz2": { + "build": "py38hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "bbd43e869586eb0c9c1f850d2343ff95", + "name": "llvmlite", + "sha256": "915c68ac4548badc2ead0bc7240feb9b16de5919c9c43f5afa002d9c80796603", + "size": 18496828, + "subdir": "linux-64", + "timestamp": 1589294233502, + "version": "0.32.1" + }, + "llvmlite-0.33.0-py36hc6ec683_1.tar.bz2": { + "build": "py36hc6ec683_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9 9.0.1 *_1", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "02fd5ec23cfd19601fff8624fd56d44f", + "name": "llvmlite", + "sha256": "6d81fc97183074e33b323e1279fca0bd732516af611493523f64c8ca135d36bd", + "size": 21887047, + "subdir": "linux-64", + "timestamp": 1594578335385, + "version": "0.33.0" + }, + "llvmlite-0.33.0-py36hd408876_0.tar.bz2": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "2849297623780d63ac293c26a7205160", + "name": "llvmlite", + "sha256": "9b28949a97b71f6512473a92290618772d176501e01503d90b031391682444ec", + "size": 21886356, + "subdir": "linux-64", + "timestamp": 1593094013350, + "version": "0.33.0" + }, + "llvmlite-0.33.0-py37hc6ec683_1.tar.bz2": { + "build": "py37hc6ec683_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9 9.0.1 *_1", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "e5c0014df9afbf09b86881b6765c07b6", + "name": "llvmlite", + "sha256": "65df5c8076198b36663be653948282df8f99b63147611294332076e189a9f08e", + "size": 21887803, + "subdir": "linux-64", + "timestamp": 1594577362497, + "version": "0.33.0" + }, + "llvmlite-0.33.0-py37hd408876_0.tar.bz2": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "c5913ca8bc2a883e3c186d21e6d82077", + "name": "llvmlite", + "sha256": "afa74757b2edc9039aa8fa2db0d666c59323a619eaeb1df646187e911789c47b", + "size": 21886318, + "subdir": "linux-64", + "timestamp": 1593094037750, + "version": "0.33.0" + }, + "llvmlite-0.33.0-py38hc6ec683_1.tar.bz2": { + "build": "py38hc6ec683_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9 9.0.1 *_1", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "f5e98cbbe7a31f3e6487b4b7a909e2fa", + "name": "llvmlite", + "sha256": "0c6cc04d07faa609eacf5a3e4fca4bd85b97a19050f9c0fee5abfa1f170b79db", + "size": 21887722, + "subdir": "linux-64", + "timestamp": 1594578183183, + "version": "0.33.0" + }, + "llvmlite-0.33.0-py38hd408876_0.tar.bz2": { + "build": "py38hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "4a6a4ebcab67d8fac9f7092ad88d6f62", + "name": "llvmlite", + "sha256": "a62b5d5574e32f3efba924e3fcb7861764c524c8564e57cbc9d3a4461add7697", + "size": 21932442, + "subdir": "linux-64", + "timestamp": 1593094016966, + "version": "0.33.0" + }, + "llvmlite-0.34.0-py36h269e1b5_3.tar.bz2": { + "build": "py36h269e1b5_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "8daf29fdfaf4d64a100f9d6568ef2f60", + "name": "llvmlite", + "sha256": "83dd0e4d6b98c6c859d60dfbee75aa723692486d7b2b549d170a4e929c0a5b02", + "size": 337407, + "subdir": "linux-64", + "timestamp": 1599298452135, + "version": "0.34.0" + }, + "llvmlite-0.34.0-py36h269e1b5_4.tar.bz2": { + "build": "py36h269e1b5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "a133a382cf6b6b6bf3172db73f1ec16d", + "name": "llvmlite", + "sha256": "1609d2035bf0be04413cf535d89727febbaf6e6594b07b5e571617076213ae01", + "size": 326427, + "subdir": "linux-64", + "timestamp": 1599324295342, + "version": "0.34.0" + }, + "llvmlite-0.34.0-py37h269e1b5_3.tar.bz2": { + "build": "py37h269e1b5_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "6126ae073691d39cfcc2ca0785a2d119", + "name": "llvmlite", + "sha256": "2207968c384a9cde0f0155b7816e1688f388d5562e859654a209c796609f839c", + "size": 325460, + "subdir": "linux-64", + "timestamp": 1599298398991, + "version": "0.34.0" + }, + "llvmlite-0.34.0-py37h269e1b5_4.tar.bz2": { + "build": "py37h269e1b5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "5bf0e86cf07f7909662445ecef1965a7", + "name": "llvmlite", + "sha256": "c1794283c5d81da28392e6d8fab637377f7b81a0b9d03d17bf23157e48e1b33d", + "size": 338591, + "subdir": "linux-64", + "timestamp": 1599324204238, + "version": "0.34.0" + }, + "llvmlite-0.34.0-py38h269e1b5_3.tar.bz2": { + "build": "py38h269e1b5_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "908a6586c5f78ce1e7f135e24f5c19be", + "name": "llvmlite", + "sha256": "22a28bff3dcce9ea2c808077d398cf39c6a20cab286a49d4376ea683c7d2fe32", + "size": 340330, + "subdir": "linux-64", + "timestamp": 1599298453264, + "version": "0.34.0" + }, + "llvmlite-0.34.0-py38h269e1b5_4.tar.bz2": { + "build": "py38h269e1b5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "307c5f1c05bc58276c6ea18d4683b53a", + "name": "llvmlite", + "sha256": "1c0b6aa30a751b63ffb20bf9e248ecbf9a647206ad06e8452ff3338c453d0cb8", + "size": 327355, + "subdir": "linux-64", + "timestamp": 1599324340952, + "version": "0.34.0" + }, + "llvmlite-0.35.0-py36h612dafd_4.tar.bz2": { + "build": "py36h612dafd_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "fdd3eacb8cde9ed4139a8fe20f4c743f", + "name": "llvmlite", + "sha256": "e1ea39419274a9ec47e4d70d6c4f23712b92a0c3fde0a1f075d37ed739cde60a", + "size": 453323, + "subdir": "linux-64", + "timestamp": 1606862159021, + "version": "0.35.0" + }, + "llvmlite-0.35.0-py37h612dafd_4.tar.bz2": { + "build": "py37h612dafd_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "c442bbe1f7884633f72858a3b87af591", + "name": "llvmlite", + "sha256": "13434eade809f674b49cef6d2be7d526b92723f56220c03e180f26d73be0d230", + "size": 441064, + "subdir": "linux-64", + "timestamp": 1606862185989, + "version": "0.35.0" + }, + "llvmlite-0.35.0-py38h612dafd_4.tar.bz2": { + "build": "py38h612dafd_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "7c263e371ab067877a3bb3d259da4a60", + "name": "llvmlite", + "sha256": "f9acea0a5b6a0d0044f0ea0148509394e5ced58d78ef7741d7825a601e344ffd", + "size": 441853, + "subdir": "linux-64", + "timestamp": 1606862192126, + "version": "0.35.0" + }, + "llvmlite-0.35.0-py39h612dafd_4.tar.bz2": { + "build": "py39h612dafd_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "md5": "f7021c4b84567bf2d8916888767d2425", + "name": "llvmlite", + "sha256": "216c4eba913a544674c41d56af0e44c0a38ecc2f2eb65984ee6fced4d02fb610", + "size": 455836, + "subdir": "linux-64", + "timestamp": 1606862186085, + "version": "0.35.0" + }, + "llvmlite-0.36.0-py36h612dafd_4.tar.bz2": { + "build": "py36h612dafd_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "a3115cc6ed4838a661ef4f299ccaa2f7", + "name": "llvmlite", + "sha256": "4468d24017a791277e9780cbe95204308d35f20eefa5cc6eb11732096238aa3e", + "size": 447665, + "subdir": "linux-64", + "timestamp": 1615662902850, + "version": "0.36.0" + }, + "llvmlite-0.36.0-py37h612dafd_4.tar.bz2": { + "build": "py37h612dafd_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "430178a7f5f648530472277a269aeabb", + "name": "llvmlite", + "sha256": "63e836e2a0665cca5210022bad1f8416dba030cb5f3ec60f13b8a4e6b2e621cb", + "size": 461078, + "subdir": "linux-64", + "timestamp": 1615662784289, + "version": "0.36.0" + }, + "llvmlite-0.36.0-py38h612dafd_4.tar.bz2": { + "build": "py38h612dafd_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "c8071d0caa89e6ccdafd59d95ed6f78e", + "name": "llvmlite", + "sha256": "a1d7e2cd9686bdab185ada16d3fed35272a3bd675e86499e35086e79bc0094ad", + "size": 450892, + "subdir": "linux-64", + "timestamp": 1615662884426, + "version": "0.36.0" + }, + "llvmlite-0.36.0-py39h612dafd_4.tar.bz2": { + "build": "py39h612dafd_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "md5": "1003cd7b4b05669c27adf5230acac40c", + "name": "llvmlite", + "sha256": "76f9d3d240d019bd8089bd14dc04341e10722324df74785476b1c07677e62665", + "size": 462843, + "subdir": "linux-64", + "timestamp": 1615661177058, + "version": "0.36.0" + }, + "llvmlite-0.37.0-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "8e2d426e0cececd0f73f9f59d651c2e4", + "name": "llvmlite", + "sha256": "a500b16c2da513422d11b8b1394ee80bc9de4d7a0b6f1af57c44c0f4ff06bf50", + "size": 488538, + "subdir": "linux-64", + "timestamp": 1630587796610, + "version": "0.37.0" + }, + "llvmlite-0.37.0-py37h295c915_1.tar.bz2": { + "build": "py37h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "77b0af4908200886b3a9ba76ebae3ccc", + "name": "llvmlite", + "sha256": "0723226b2ad85813a391bfb543c8b7fe3f7eadd263f8d9a80029cb9923f36972", + "size": 507632, + "subdir": "linux-64", + "timestamp": 1633428729925, + "version": "0.37.0" + }, + "llvmlite-0.37.0-py37h295c915_2.tar.bz2": { + "build": "py37h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.0.0,<11.1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "b241d49770d310e095cc1e38782e5398", + "name": "llvmlite", + "sha256": "f72239ab65e0164049c4a5e049c7b45ba72adcb77f50860f37ed92636c3057e6", + "size": 491337, + "subdir": "linux-64", + "timestamp": 1646168670904, + "version": "0.37.0" + }, + "llvmlite-0.37.0-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "3b1a93243b8e51571aebf9d22b75bfc6", + "name": "llvmlite", + "sha256": "c4c13793c5d170eded2a0f8394a4ae07fd6675c00a1cd090a0c1a5cc661a7a04", + "size": 490537, + "subdir": "linux-64", + "timestamp": 1630597062867, + "version": "0.37.0" + }, + "llvmlite-0.37.0-py38h295c915_1.tar.bz2": { + "build": "py38h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "49d9fdfcd619d4dce671f3151955a4e9", + "name": "llvmlite", + "sha256": "6e831078343e4d5408c05eb90f25e8a6dab49bf3e1fbb93588a0a97187d6352a", + "size": 491127, + "subdir": "linux-64", + "timestamp": 1633418036642, + "version": "0.37.0" + }, + "llvmlite-0.37.0-py38h295c915_2.tar.bz2": { + "build": "py38h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.0.0,<11.1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "c87ba42e4cdcf46d0a8233934c6f42cd", + "name": "llvmlite", + "sha256": "8d8519807e896d67349d97b0c4870eb1384224cd315e607e76834b62b41fa959", + "size": 508375, + "subdir": "linux-64", + "timestamp": 1646151524759, + "version": "0.37.0" + }, + "llvmlite-0.37.0-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "md5": "bb168905a3d7f40ba020fd528182f1ad", + "name": "llvmlite", + "sha256": "532c5e396cf531eaa57bff8ff44070557e2ba77ba93f2a3996a20f19035981be", + "size": 490847, + "subdir": "linux-64", + "timestamp": 1630597067601, + "version": "0.37.0" + }, + "llvmlite-0.37.0-py39h295c915_1.tar.bz2": { + "build": "py39h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "md5": "6c22658dbd507ee2c8405935eb15675b", + "name": "llvmlite", + "sha256": "e6ae0ddaa2f197af20d17f2c980575c1cd50d489376c5476479c5b3cc81ca326", + "size": 508759, + "subdir": "linux-64", + "timestamp": 1633428714988, + "version": "0.37.0" + }, + "llvmlite-0.37.0-py39h295c915_2.tar.bz2": { + "build": "py39h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.0.0,<11.1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "md5": "a45155a7130c5099a97d7ea0b1f5ac03", + "name": "llvmlite", + "sha256": "5e9c0430e9201cfdb3323dc676937872435a83d20f78f7733696347b9361488d", + "size": 492045, + "subdir": "linux-64", + "timestamp": 1646150537930, + "version": "0.37.0" + }, + "llvmlite-0.38.0-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "md5": "9378b6740077389d6d964ea096f58624", + "name": "llvmlite", + "sha256": "d7a0700baa15486f0f69c4ee528ad435c2870a770d2650f587a955fe7cd28912", + "size": 489287, + "subdir": "linux-64", + "timestamp": 1641837826880, + "version": "0.38.0" + }, + "llvmlite-0.38.0-py310h4ff587b_0.tar.bz2": { + "build": "py310h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "zlib" + ], + "license": "BSD-2-Clause", + "md5": "09a11bff1937bc0fcecaeb32a538641f", + "name": "llvmlite", + "sha256": "7c3db81549f4961faf71fd5948d1f7121d79155543534de014366bd9f2e35ab8", + "size": 2830962, + "subdir": "linux-64", + "timestamp": 1647870439669, + "version": "0.38.0" + }, + "llvmlite-0.38.0-py37h4ff587b_0.tar.bz2": { + "build": "py37h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "zlib" + ], + "license": "BSD-2-Clause", + "md5": "0ece8a3bbdd8a94dd82e1040e61729d0", + "name": "llvmlite", + "sha256": "136771b01d00fa814abdf9b958600fcf5a744bbb7ec4c289beab4f3d14f45a27", + "size": 2826012, + "subdir": "linux-64", + "timestamp": 1647870360040, + "version": "0.38.0" + }, + "llvmlite-0.38.0-py38h4ff587b_0.tar.bz2": { + "build": "py38h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "zlib" + ], + "license": "BSD-2-Clause", + "md5": "eb87b15618c4c17eb79f676d79163df6", + "name": "llvmlite", + "sha256": "f1780772574d60a05acbc2e8b815d872aff742deef0771c3a9478e3ddd134d38", + "size": 2828020, + "subdir": "linux-64", + "timestamp": 1647870575953, + "version": "0.38.0" + }, + "llvmlite-0.38.0-py39h4ff587b_0.tar.bz2": { + "build": "py39h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "zlib" + ], + "license": "BSD-2-Clause", + "md5": "ecc0c3c465bbf6988ebbc6a38e2eeb1c", + "name": "llvmlite", + "sha256": "497e0a8e555539787dd237dea5d13a0a6061db2cb50ded20daddaf08bbf267cc", + "size": 2826845, + "subdir": "linux-64", + "timestamp": 1647870510956, + "version": "0.38.0" + }, + "llvmlite-0.39.1-py310he621ea3_0.tar.bz2": { + "build": "py310he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "zlib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c0de7004e90987bc42c980d6771e8e1a", + "name": "llvmlite", + "sha256": "55e4f1187df5cc85915cf133faf99a10abbb5da07c3f72c2f3f2f1a0e8f56eed", + "size": 2644324, + "subdir": "linux-64", + "timestamp": 1665171795884, + "version": "0.39.1" + }, + "llvmlite-0.39.1-py37he621ea3_0.tar.bz2": { + "build": "py37he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "zlib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a17faa63998ddd91dd6325add4964280", + "name": "llvmlite", + "sha256": "64154831a96c5ea883291ce709891f35e926360633a74c36597851566b7a2b63", + "size": 2641497, + "subdir": "linux-64", + "timestamp": 1665171850030, + "version": "0.39.1" + }, + "llvmlite-0.39.1-py38he621ea3_0.tar.bz2": { + "build": "py38he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "zlib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a39ecfcc6b6edae35cada36a1faf8a53", + "name": "llvmlite", + "sha256": "272bac9b3fbd1fd2449731965e94e955955df10e195151a367abfbcc823c43ae", + "size": 2641813, + "subdir": "linux-64", + "timestamp": 1665171903628, + "version": "0.39.1" + }, + "llvmlite-0.39.1-py39he621ea3_0.tar.bz2": { + "build": "py39he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "zlib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5ab58da09421afd7fda97a7f9194a6b4", + "name": "llvmlite", + "sha256": "a469aa8931e5183defaaaefd9dbbc73c20094a2d004c5494812c7695b08abbfb", + "size": 2642247, + "subdir": "linux-64", + "timestamp": 1665171728939, + "version": "0.39.1" + }, + "lmdb-0.9.21-hf484d3e_1.tar.bz2": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "OpenLDAP Public License and BSD 3-clause", + "license_family": "BSD", + "md5": "c03c42ad25ed666509c90da83909fba8", + "name": "lmdb", + "sha256": "d960e40ecb07392df69ec14ca1be534bb12f8b1482c27d97a1a0aedf9ca963d3", + "size": 693428, + "subdir": "linux-64", + "timestamp": 1512756896984, + "version": "0.9.21" + }, + "lmdb-0.9.22-hf484d3e_1.tar.bz2": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "OpenLDAP Public License and BSD 3-clause", + "license_family": "BSD", + "md5": "430a424364d5ff7cb4c00f1a67b24a9e", + "name": "lmdb", + "sha256": "f3abed9e182f68f9be8e7a9f8d0b4235f4d15737c7a2f314c37f6109a57d8cb9", + "size": 678350, + "subdir": "linux-64", + "timestamp": 1524181018724, + "version": "0.9.22" + }, + "lmdb-0.9.23-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "OpenLDAP Public License and BSD 3-clause", + "license_family": "BSD", + "md5": "37e9b90e76294a0ce28ccd9c54ec38e9", + "name": "lmdb", + "sha256": "1bcb3db4667040641ca08ac450592532ac14455638381c4daf66dcc0b3c58afc", + "size": 695316, + "subdir": "linux-64", + "timestamp": 1547235506596, + "version": "0.9.23" + }, + "lmdb-0.9.24-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "OpenLDAP Public License and BSD 3-clause", + "license_family": "BSD", + "md5": "d2199f3fbec8928884ca3248b5b955f3", + "name": "lmdb", + "sha256": "312fe47c01f7c4720d4ecd3c52ab71d62be6ee39c6daef4fd50ef325b9f7465e", + "size": 696149, + "subdir": "linux-64", + "timestamp": 1600443503430, + "version": "0.9.24" + }, + "lmdb-0.9.28-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "OpenLDAP Public License and BSD 3-clause", + "license_family": "BSD", + "md5": "28decc1d320fcc3ea8dc5d6d11dbe8d7", + "name": "lmdb", + "sha256": "f10c3baf29d52247298ea91cc11f10ca66d11d627a77803efbcbd19f2fec4103", + "size": 737062, + "subdir": "linux-64", + "timestamp": 1613676227754, + "version": "0.9.28" + }, + "lmdb-0.9.29-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "OpenLDAP Public License and BSD 3-clause", + "license_family": "BSD", + "md5": "fd4dc6903e4607c9dd0871d41aad4a37", + "name": "lmdb", + "sha256": "869f7512cc3e9e42d5557850035a375b5dabe16b5bdbd6c261fb2df59c56fb77", + "size": 723275, + "subdir": "linux-64", + "timestamp": 1620400717780, + "version": "0.9.29" + }, + "locket-0.2.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "df1ff91d7dd746e8a254d0f0196ca785", + "name": "locket", + "sha256": "c78749dadf08043a6f6dcfcd07c456519f21c2600c28a2a6d9b1604b4577dc58", + "size": 8197, + "subdir": "linux-64", + "timestamp": 1530741752827, + "version": "0.2.0" + }, + "locket-0.2.0-py27h73929a2_1.tar.bz2": { + "build": "py27h73929a2_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "75f8dc45e9814c69647f948c14537b15", + "name": "locket", + "sha256": "9b15e8fb74dcc7172234049e557c6cb864176179b706e632c596fdf38f02112d", + "size": 8022, + "subdir": "linux-64", + "timestamp": 1505732742217, + "version": "0.2.0" + }, + "locket-0.2.0-py35h170bc82_1.tar.bz2": { + "build": "py35h170bc82_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "262c0777d757eea48e43a9c6811402f0", + "name": "locket", + "sha256": "fa3b5d73e16044464bb0bf83c773cab3c8b489551975dcc8c1445252533b8974", + "size": 8210, + "subdir": "linux-64", + "timestamp": 1505732753137, + "version": "0.2.0" + }, + "locket-0.2.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "f46ab9919281d490b28a9c9da46c8c3b", + "name": "locket", + "sha256": "1222328866331f67390cfc0cfa4a99a563e1fac5de24d519a57777e8147771f1", + "size": 8307, + "subdir": "linux-64", + "timestamp": 1530741731902, + "version": "0.2.0" + }, + "locket-0.2.0-py36h787c0ad_1.tar.bz2": { + "build": "py36h787c0ad_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "48dca5102149579a05f2c24a72f7a98c", + "name": "locket", + "sha256": "f99ec73196a98f7d9e8f2657885112a905af63dd4bb8b2477d89f5fa1b75fd68", + "size": 8148, + "subdir": "linux-64", + "timestamp": 1505732764177, + "version": "0.2.0" + }, + "locket-0.2.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "ac9e7e51f1d47e31b5ba210963a6cf9b", + "name": "locket", + "sha256": "fb7296b06fb7361089ce9654b35e8c9dea0913255bbb319edebb3aaf4b592ece", + "size": 8320, + "subdir": "linux-64", + "timestamp": 1530741774429, + "version": "0.2.0" + }, + "locket-0.2.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "md5": "48c81ffcba446b979bd53c7c881b942e", + "name": "locket", + "sha256": "8d43bfa45a2944826aafb54a925f56b81b43af27b7f4ec72bf1670ca475c7415", + "size": 8826, + "subdir": "linux-64", + "timestamp": 1573488766533, + "version": "0.2.0" + }, + "locket-0.2.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "md5": "8d5a8d85fc9c81baf9c66bd3afbafe29", + "name": "locket", + "sha256": "60469dd0fcba23cd1082c5f26845cc63461d5743c1e5ed8f0d18fa084253f3d9", + "size": 9953, + "subdir": "linux-64", + "timestamp": 1607570774449, + "version": "0.2.0" + }, + "locket-0.2.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 2-Clause", + "md5": "fdab44de1da926ac7e95bcfbc828121d", + "name": "locket", + "sha256": "838b3f8711a9f85a06aa0f3a102db010253c9263986584e7278343edf4f6fc7d", + "size": 10474, + "subdir": "linux-64", + "timestamp": 1640791373772, + "version": "0.2.1" + }, + "locket-0.2.1-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "896eb3934f15a8c6e16703815ad19eb4", + "name": "locket", + "sha256": "248cec0a284efacb58d02b157325dadd752e47c35f81c1d21b2df7771cd529a3", + "size": 11619, + "subdir": "linux-64", + "timestamp": 1646987929209, + "version": "0.2.1" + }, + "locket-0.2.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "38792d0523b8b3e9619ee866e354d749", + "name": "locket", + "sha256": "9855fe826e210802c18ada4d5e4b5049d08134e5980bad4f0768dba8a4202c6a", + "size": 10598, + "subdir": "linux-64", + "timestamp": 1611170835352, + "version": "0.2.1" + }, + "locket-0.2.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "78385b25a5941cd14e78a83f936d9ee5", + "name": "locket", + "sha256": "cf934df0825f05c2cd35c6f1171f8a925756e367a881b6c2658886979f311c15", + "size": 10580, + "subdir": "linux-64", + "timestamp": 1611170851518, + "version": "0.2.1" + }, + "locket-0.2.1-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "37af8250134efe01c392861e3148ee4d", + "name": "locket", + "sha256": "ce8cfb762e706dc00e7210611ce61e750c1c2b14791e9c7efe71e03a1dad32cd", + "size": 11508, + "subdir": "linux-64", + "timestamp": 1646988470789, + "version": "0.2.1" + }, + "locket-0.2.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "md5": "a553ff91e1b5144bc06dbbe94781f43b", + "name": "locket", + "sha256": "180fffab3e8ada42d28cb7f8de49c179d8289c38c6027d4440a4c50ef99fd7e1", + "size": 10640, + "subdir": "linux-64", + "timestamp": 1611170807044, + "version": "0.2.1" + }, + "locket-0.2.1-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "04731b9fe696dbbdaff9c9df50427d11", + "name": "locket", + "sha256": "35a15f69fbf062e089c0f2464ca5fc3419a2fe3bcf0b1cea3216a6e5acb8a9ad", + "size": 11538, + "subdir": "linux-64", + "timestamp": 1647006037112, + "version": "0.2.1" + }, + "locket-0.2.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "md5": "01bfc3b0694165d9a82f2213e9200167", + "name": "locket", + "sha256": "25accac875c0ab33845b6a2439d31869cb5011c3593bff94229da8998818c8f1", + "size": 10679, + "subdir": "linux-64", + "timestamp": 1611170764206, + "version": "0.2.1" + }, + "locket-0.2.1-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "0ee4794fbb82313356fc6847271dec04", + "name": "locket", + "sha256": "31ce10c3a97b3fcd92f64d58f9ac3ada91c3bec0844f0ec57e987694867f71d7", + "size": 11532, + "subdir": "linux-64", + "timestamp": 1647006043407, + "version": "0.2.1" + }, + "locket-1.0.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e36d89397033bfc417932702d7519138", + "name": "locket", + "sha256": "4210b70b38fd509ac973d347a654f2cd670b7559411ae783e07b48c071a809e2", + "size": 11131, + "subdir": "linux-64", + "timestamp": 1652903185157, + "version": "1.0.0" + }, + "locket-1.0.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "6a04ec16e3abc1c7e2104be32cd6c418", + "name": "locket", + "sha256": "95fe76d2691feb13203b55ad2aba535bb848cae21ffd05b13ff51c7a45fa2332", + "size": 13458, + "subdir": "linux-64", + "timestamp": 1676827287432, + "version": "1.0.0" + }, + "locket-1.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "dcc27db7071de8128b5961b2dbaa50bf", + "name": "locket", + "sha256": "25adce17d3b0f41f9cd9bd4819d021562b4567c386a516b70376bc992d920abd", + "size": 11014, + "subdir": "linux-64", + "timestamp": 1652903235682, + "version": "1.0.0" + }, + "locket-1.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "dc8d6a9a1e475c5fc9de8531026a4c38", + "name": "locket", + "sha256": "a2c16e4e68e414ea6f7680a6439e80f7d67fb693bf739fc10d2ef5afc3e3c2f4", + "size": 11040, + "subdir": "linux-64", + "timestamp": 1652903148662, + "version": "1.0.0" + }, + "locket-1.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "78c7a3a437536ae24d2d7ce15ec400d2", + "name": "locket", + "sha256": "d8cd22ac7f033507549f6a0d078cd273607cb6e8246b0383375a33941969c12c", + "size": 11065, + "subdir": "linux-64", + "timestamp": 1652903210940, + "version": "1.0.0" + }, + "lockfile-0.12.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "be14b542321c667c229e7078e9fc56c3", + "name": "lockfile", + "sha256": "b4dc569ecb7d0d9b0f0a1c4f5bb0b821136cd5d680d1a4be97fe95707a22384e", + "size": 18851, + "subdir": "linux-64", + "timestamp": 1530898511367, + "version": "0.12.2" + }, + "lockfile-0.12.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "0792ec30a4583e05098504850e36c4e3", + "name": "lockfile", + "sha256": "6143026535c28518d5b7ef35043bff68e1464ece3960c38bc623d753a8dcfc5e", + "size": 19703, + "subdir": "linux-64", + "timestamp": 1640791392442, + "version": "0.12.2" + }, + "lockfile-0.12.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "e76d52bc78f00c21550011dcd61c98e4", + "name": "lockfile", + "sha256": "2112c56441c5067fa68b6ea016f9ffb4682b15cb87bf7119e3b512830a2e7339", + "size": 24528, + "subdir": "linux-64", + "timestamp": 1676903850269, + "version": "0.12.2" + }, + "lockfile-0.12.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "d9646f613fd49ad64e0d8a0a71abd7e7", + "name": "lockfile", + "sha256": "c7875c8fb4e97850b2c7dc99916d9f4e5c463d790ea9b4ae5b3ec807a0b7aee4", + "size": 19207, + "subdir": "linux-64", + "timestamp": 1535480708241, + "version": "0.12.2" + }, + "lockfile-0.12.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "749ead69762bb81d5d942045e3f8014e", + "name": "lockfile", + "sha256": "0c6b815fa3b25a5ead1da64e7169549ac3216dbcea33c74b6d90a2fea1dbd61d", + "size": 19177, + "subdir": "linux-64", + "timestamp": 1530898566621, + "version": "0.12.2" + }, + "lockfile-0.12.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9f3ddde1bc7806824f32090725dd63a7", + "name": "lockfile", + "sha256": "b51f20e0010f8e906be9d86a0a710a9894181fa589e0e1fc10af1eb5c034d561", + "size": 230923, + "subdir": "linux-64", + "timestamp": 1611760097634, + "version": "0.12.2" + }, + "lockfile-0.12.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d4520f14dec61cade75f1aa507304851", + "name": "lockfile", + "sha256": "119d4f4897de09f3fd586d12871d040aaa0799bb0ca5f705264686b33813d7b8", + "size": 19233, + "subdir": "linux-64", + "timestamp": 1530898538255, + "version": "0.12.2" + }, + "lockfile-0.12.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "df0d6744ea1db0b4cab4b24cf1a36f95", + "name": "lockfile", + "sha256": "4a9a3cf314af2f9d594d61e7687471882b1e888e21fd93c36c3c5f177834079c", + "size": 231020, + "subdir": "linux-64", + "timestamp": 1611760052878, + "version": "0.12.2" + }, + "lockfile-0.12.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "e01cc49a05577a329f1fdd29d280b357", + "name": "lockfile", + "sha256": "3770206c22d34326fb7fdc07bfe3f950553a0627938fd6d1ce41f146c70393b7", + "size": 19792, + "subdir": "linux-64", + "timestamp": 1573488788663, + "version": "0.12.2" + }, + "lockfile-0.12.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "905694c50a3b6756ef99718f06297785", + "name": "lockfile", + "sha256": "61e0fa93b3ff8ec9d4db9d8d9e8ee35b3c4ce3b4635126e0039409daa1a0a47d", + "size": 232680, + "subdir": "linux-64", + "timestamp": 1611760094940, + "version": "0.12.2" + }, + "lockfile-0.12.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "34a76c18f0ccc3ad6f0f5d37f1c9fd25", + "name": "lockfile", + "sha256": "da4cc26cb9771b45b5884ad8909c0c4b796b29ec1cab47161f72f2da1d797ed7", + "size": 19753, + "subdir": "linux-64", + "timestamp": 1607007538627, + "version": "0.12.2" + }, + "logilab-common-1.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "b049440161e1fc3ced7abb62ee0cf3a3", + "name": "logilab-common", + "sha256": "20598d9e73ac9788a99231bab4f4fadbfd50c479bfd26aa4ebc72706f3e6bb8f", + "size": 199134, + "subdir": "linux-64", + "timestamp": 1519762037050, + "version": "1.4.1" + }, + "logilab-common-1.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "d959590f9bc2d143960146e23a3c6c7f", + "name": "logilab-common", + "sha256": "39a8dedc389e467773a253081b92e687a06f1aa5106c5a3d38fa52385718ef79", + "size": 202749, + "subdir": "linux-64", + "timestamp": 1519762153368, + "version": "1.4.1" + }, + "logilab-common-1.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "55a2fd3a421a3b921f4954bd730d236b", + "name": "logilab-common", + "sha256": "8a28ff32090839a91818605d9a356bdfc5d0a8c18f86ae94a9bc2fa47a8c580c", + "size": 201367, + "subdir": "linux-64", + "timestamp": 1519762183850, + "version": "1.4.1" + }, + "logilab-common-1.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "89cbe02e64f525da03fb0e6651088cb7", + "name": "logilab-common", + "sha256": "42d0d66d71bdd855d07e68cae3b0bf049c3411bb6669b9b2c95bb5e01ac22f7d", + "size": 201076, + "subdir": "linux-64", + "timestamp": 1530898596605, + "version": "1.4.1" + }, + "logilab-common-1.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "cc6478412e529afd078cb369c66a957e", + "name": "logilab-common", + "sha256": "66c5669145d66fe1fa154d2a72c2d9b71076a65ae4d50c226a93ec464df307b2", + "size": 199293, + "subdir": "linux-64", + "timestamp": 1535509785325, + "version": "1.4.2" + }, + "logilab-common-1.4.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "9e93e3729574bdcb386cfa39a583d361", + "name": "logilab-common", + "sha256": "18ecbdef57111d7bfdfe1f4af9c46abbc6fa3a6dd376c8bd06f5779ba9dc4f97", + "size": 202852, + "subdir": "linux-64", + "timestamp": 1535509828064, + "version": "1.4.2" + }, + "logilab-common-1.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "74bd0dc45d7952934413982c3d52e6fd", + "name": "logilab-common", + "sha256": "8a9693829f586ccd5c81b7f3af51449cb3ba88bcd555f38ef5ad8f3fad1ca5e0", + "size": 201482, + "subdir": "linux-64", + "timestamp": 1535509773395, + "version": "1.4.2" + }, + "logilab-common-1.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "3928761ab653a7d43c4fdcce325465cb", + "name": "logilab-common", + "sha256": "77f45b3743a3de7b6fa831a6fc29cf574ae559c009f5d36875202a5f05193c42", + "size": 201775, + "subdir": "linux-64", + "timestamp": 1535509832665, + "version": "1.4.2" + }, + "logilab-common-1.4.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "28044b0d5c538c4b3c534b2254da1dc7", + "name": "logilab-common", + "sha256": "9e3b4c8c186ec18251a7f24670c8e6b35c7446eb5d37021fb16f0b830258d00c", + "size": 200762, + "subdir": "linux-64", + "timestamp": 1564686064945, + "version": "1.4.3" + }, + "logilab-common-1.4.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "971f02cf1d1d3b526f3f52234d180b1b", + "name": "logilab-common", + "sha256": "3ab02bee4421464ece1a843202556413ec9eb683fc2460708106752ef0585c96", + "size": 202758, + "subdir": "linux-64", + "timestamp": 1564686035810, + "version": "1.4.3" + }, + "logilab-common-1.4.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "089d0c33d325e5f72a2024094a737064", + "name": "logilab-common", + "sha256": "af04084de64badc01cea9839f71a7d7b2f913a5639ec583dbc12a3f38e33fee9", + "size": 202366, + "subdir": "linux-64", + "timestamp": 1564686073527, + "version": "1.4.3" + }, + "logilab-common-1.4.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "0afeefd557cfb3ca4e3dfa142610a360", + "name": "logilab-common", + "sha256": "c212c7b02977b2586a14089f28a7a8bb104e452ebdbf948ae80bde244d9d819c", + "size": 201521, + "subdir": "linux-64", + "timestamp": 1574158060930, + "version": "1.4.3" + }, + "logilab-common-1.7.3-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "21f38777f04e08f3ac1af6ce198cb83f", + "name": "logilab-common", + "sha256": "3e0e61c414d43d4902ed04d3da5feb5194ae95ac8e96494509ff136643ecefc9", + "size": 246197, + "subdir": "linux-64", + "timestamp": 1600443537600, + "version": "1.7.3" + }, + "logilab-common-1.7.3-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "185cb98038e918ecd4a307abe9816caf", + "name": "logilab-common", + "sha256": "e19e0a480a8e3e83b487330bd5ce12e0cdea2d5030124a7a2433ff09236df6c2", + "size": 242055, + "subdir": "linux-64", + "timestamp": 1600443537843, + "version": "1.7.3" + }, + "logilab-common-1.7.3-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "ef3a8f9b91766b18fb9783f1f8e85ea5", + "name": "logilab-common", + "sha256": "9a372d65de3c983bfbde12ecbae2f97bea359608f9a30e720f198ee7f186cae8", + "size": 244441, + "subdir": "linux-64", + "timestamp": 1600443509380, + "version": "1.7.3" + }, + "logilab-common-1.8.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "1a72679bcf4ec94ab651f61175617543", + "name": "logilab-common", + "sha256": "898406f6de0e668413985341aa1377a220cc8f3e48c844bb9abe6d9eb657e724", + "size": 253324, + "subdir": "linux-64", + "timestamp": 1640791410867, + "version": "1.8.0" + }, + "logilab-common-1.8.0-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "1f642d592513cf9e5ce2cff241addc73", + "name": "logilab-common", + "sha256": "b8afaf44b84c86d3a1ce711f730e21de2d8ded82b489f4d66e6470925df7ec47", + "size": 343001, + "subdir": "linux-64", + "timestamp": 1676858523417, + "version": "1.8.0" + }, + "logilab-common-1.8.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "3f1d7c614c26aa7fcfc62fe2cb582129", + "name": "logilab-common", + "sha256": "e6db11b7f4f9aa8c40f706ae9d6c87dd8d0e70a242905a6597fe4642dcb03e07", + "size": 246745, + "subdir": "linux-64", + "timestamp": 1603826705416, + "version": "1.8.0" + }, + "logilab-common-1.8.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "6c0b120ea40c0fe24e04b2a8ef8a2f31", + "name": "logilab-common", + "sha256": "2b735f5df3d87385944e615d251ad0fab0c6f230ecf858c392db42d3e201df3a", + "size": 247757, + "subdir": "linux-64", + "timestamp": 1603826734709, + "version": "1.8.0" + }, + "logilab-common-1.8.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "b499b9c42f51151f16957dc627f5ef58", + "name": "logilab-common", + "sha256": "f285adac9f20c2c72e7f3989d9014af1c4883d31f2a6f64225007946294d7415", + "size": 239231, + "subdir": "linux-64", + "timestamp": 1603826725424, + "version": "1.8.0" + }, + "logilab-common-1.8.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "c657edf84a3aa57c5622f5db6c1f550c", + "name": "logilab-common", + "sha256": "afcafe995fd13042d28bdb0d8ac128443b7d78af662847c7f468bf7a1813c907", + "size": 249216, + "subdir": "linux-64", + "timestamp": 1636035197928, + "version": "1.8.0" + }, + "logilab-common-1.8.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "19da41233aec033da795affb3639f8ff", + "name": "logilab-common", + "sha256": "db58425fac1281f7e64d29d4bb97af093c552e4925e93da559ca2fcf1c309a1a", + "size": 250878, + "subdir": "linux-64", + "timestamp": 1609872538743, + "version": "1.8.1" + }, + "logilab-common-1.8.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "4c650fd82878b854817fa80a27cfe4b9", + "name": "logilab-common", + "sha256": "530cacad36713bd0ca59888c34d7a4133e911dddc33f50d3b417160a5ddb7285", + "size": 246171, + "subdir": "linux-64", + "timestamp": 1609872551478, + "version": "1.8.1" + }, + "logilab-common-1.8.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "89ba0c96da8b0a17f921f129033d238f", + "name": "logilab-common", + "sha256": "307ed97651494a066260ef8b568b40980aa8df54e6aca763c4a5dc4b23bc868f", + "size": 250413, + "subdir": "linux-64", + "timestamp": 1609872380441, + "version": "1.8.1" + }, + "logilab-common-1.8.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "81938832e707a0aba634aa2029b87179", + "name": "logilab-common", + "sha256": "486e089c099d8f958bd11c77a912d11c370a383d1d9209b5708c49b1b016d2a9", + "size": 253606, + "subdir": "linux-64", + "timestamp": 1609872564264, + "version": "1.8.1" + }, + "loguru-0.5.3-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "46a066b4f6e4185339e839703692ba1b", + "name": "loguru", + "sha256": "6f3531e3d076a937c8c3d0590df2ea4aa02995fbd763186da15fc88e6633266b", + "size": 88334, + "subdir": "linux-64", + "timestamp": 1641920760404, + "version": "0.5.3" + }, + "loguru-0.5.3-py310h06a4308_4.tar.bz2": { + "build": "py310h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a92d5f26dbaa6bcb19c55870d2d2765c", + "name": "loguru", + "sha256": "6d36956d3d7018cec67ff0b56732b333512276d04741fbd3708bec2902d6df33", + "size": 88593, + "subdir": "linux-64", + "timestamp": 1675318562473, + "version": "0.5.3" + }, + "loguru-0.5.3-py311h06a4308_4.tar.bz2": { + "build": "py311h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a472e30b9f675100d6f16c09d4d91129", + "name": "loguru", + "sha256": "f4af3b279dbb9a3c05ee8a2ce1ac390f59d98d157694a032d2756bdf42dc0db8", + "size": 113422, + "subdir": "linux-64", + "timestamp": 1676858538751, + "version": "0.5.3" + }, + "loguru-0.5.3-py37h06a4308_3.tar.bz2": { + "build": "py37h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "399e4ada46cede5f5a89d440398fc8b6", + "name": "loguru", + "sha256": "29f3b60418908171592674fe93c1134cd43eb5dbb1e59acd4419fd743889a2ed", + "size": 86836, + "subdir": "linux-64", + "timestamp": 1643635414519, + "version": "0.5.3" + }, + "loguru-0.5.3-py37h06a4308_4.tar.bz2": { + "build": "py37h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5b476b0d1055727f3f5b853af62e9d6", + "name": "loguru", + "sha256": "6eabde0810c8660eec96227218ad9d1cf56808d0442040aa57f58f0be0cce716", + "size": 87120, + "subdir": "linux-64", + "timestamp": 1675318589085, + "version": "0.5.3" + }, + "loguru-0.5.3-py38h06a4308_3.tar.bz2": { + "build": "py38h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8cbda5c51c7f49ce2a46b1b634568a18", + "name": "loguru", + "sha256": "9ff1c70bac60dd61d01941d32372ce5f41ff7bfe7e460389c0f88ace7c241790", + "size": 87050, + "subdir": "linux-64", + "timestamp": 1643635364959, + "version": "0.5.3" + }, + "loguru-0.5.3-py38h06a4308_4.tar.bz2": { + "build": "py38h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d39a17736be3b1db470a169d56ada1eb", + "name": "loguru", + "sha256": "9239a5cb7c8f56ccd690ca7dd79b6ed6f600ffeccb8861541dd0a586ebe86508", + "size": 87333, + "subdir": "linux-64", + "timestamp": 1675318508999, + "version": "0.5.3" + }, + "loguru-0.5.3-py39h06a4308_3.tar.bz2": { + "build": "py39h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71acb0517d3cd9a403ecc8e3482f9650", + "name": "loguru", + "sha256": "919231452cdb010db00fbf935d972aa36f1d34a428ffe9d8e2045684f4670f33", + "size": 87216, + "subdir": "linux-64", + "timestamp": 1643635392339, + "version": "0.5.3" + }, + "loguru-0.5.3-py39h06a4308_4.tar.bz2": { + "build": "py39h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "367fc6a0858a6fb0f758dcab8d0e2f11", + "name": "loguru", + "sha256": "812e4165101867f0248d8fd433d3208583983d768b5618d6fdcbfc3edb227ff3", + "size": 87532, + "subdir": "linux-64", + "timestamp": 1675318535694, + "version": "0.5.3" + }, + "ltrace_linux-64-0.7.3-h1234567_0.tar.bz2": { + "build": "h1234567_0", + "build_number": 0, + "depends": [], + "license": "GPL", + "md5": "3bcbbda749d31cb69844a03cad9cc3fb", + "name": "ltrace_linux-64", + "sha256": "80e3e8b14641704375f91be48088853d1393cf47bd2445dfec6c7eabef78a9e5", + "size": 155355, + "subdir": "linux-64", + "timestamp": 1652859723868, + "version": "0.7.3" + }, + "ltrace_linux-64-0.7.3-h1234567_1.tar.bz2": { + "build": "h1234567_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "78098048efb71cad9d6365c4e54b601d", + "name": "ltrace_linux-64", + "sha256": "19b01b1cd984aef2b48c68b3b20c7473453454f5d9822378065d29e1c8c8b96c", + "size": 155383, + "subdir": "linux-64", + "timestamp": 1654090809095, + "version": "0.7.3" + }, + "lua-5.3.4-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "readline >=7.0,<8.0a0" + ], + "license": "MIT", + "md5": "f1f9d5e3c7af6d2c7c195ab4fb9ac2be", + "name": "lua", + "sha256": "f57273b09384337e727fe9a54064edac5e6bd7434fabf7c29feff4fb94b6c9bf", + "size": 235418, + "subdir": "linux-64", + "timestamp": 1545961178241, + "version": "5.3.4" + }, + "lua-resty-http-0.12.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "openresty" + ], + "license": "BSD", + "md5": "5cd474a7b564cac7a10b90345ae5f6dd", + "name": "lua-resty-http", + "sha256": "253c7143f33a7e4f8a495beda7cefba3384c0d4a5004f2af9f2fc60bb504d93c", + "size": 1266963, + "subdir": "linux-64", + "timestamp": 1545963405195, + "version": "0.12.0" + }, + "luajit-2.0.5-h7b6447c_1000.tar.bz2": { + "build": "h7b6447c_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "46b1c33bdd8e944eec23b9937d498d74", + "name": "luajit", + "sha256": "5fd873827e2b43d3b3ff5de5c124b1eb5f8fb5afd232dadd7bbcf526c452f975", + "size": 624466, + "subdir": "linux-64", + "timestamp": 1545961180298, + "version": "2.0.5" + }, + "luarocks-3.0.0-lua53_0.tar.bz2": { + "build": "lua53_0", + "build_number": 0, + "depends": [ + "lua", + "unzip" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "355f13827372aa4d9b08242d042c6768", + "name": "luarocks", + "sha256": "0af6f2d8311d823edb8de6604b5c348fd3d5621de13e2d37af1efb15fa4ff52d", + "size": 124179, + "subdir": "linux-64", + "timestamp": 1545961186730, + "version": "3.0.0" + }, + "luarocks-3.3.1-lua53_0.tar.bz2": { + "build": "lua53_0", + "build_number": 0, + "depends": [ + "lua", + "unzip" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "00ff01744115f1c726b79cb5cd1f3cd1", + "name": "luarocks", + "sha256": "43ad5e0313d2d25a98bcd0ab31bd49f524463a2b080f1ea25137dcf94e635cdc", + "size": 142645, + "subdir": "linux-64", + "timestamp": 1599161265053, + "version": "3.3.1" + }, + "luarocks-3.4.0-lua53_0.tar.bz2": { + "build": "lua53_0", + "build_number": 0, + "depends": [ + "lua", + "unzip" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4a16ed4e1743f68db3590aff6f135d8a", + "name": "luarocks", + "sha256": "c9367887f5b1234f0dd42a43ff621e76b1fe0e8c397efa297e5462120e72d544", + "size": 142956, + "subdir": "linux-64", + "timestamp": 1601313366726, + "version": "3.4.0" + }, + "luarocks-3.5.0-lua53h06a4308_0.tar.bz2": { + "build": "lua53h06a4308_0", + "build_number": 0, + "depends": [ + "lua", + "unzip" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "deb01fbba3307ba3d0c1373647e87a79", + "name": "luarocks", + "sha256": "8ecef03744445cc7d324cdf40913e18c38f2aadf058651f34b84ae35dc8f8b07", + "size": 143396, + "subdir": "linux-64", + "timestamp": 1607622605561, + "version": "3.5.0" + }, + "luarocks-3.6.0-lua53h06a4308_0.tar.bz2": { + "build": "lua53h06a4308_0", + "build_number": 0, + "depends": [ + "lua", + "unzip" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c3e7128be4e9eff7f2a736cbe7edb0d", + "name": "luarocks", + "sha256": "b57cf7eb2e531bc50d36af3f10858e28969a8eba41a18e5bcbab0e58c2ea43f4", + "size": 144194, + "subdir": "linux-64", + "timestamp": 1617378599650, + "version": "3.6.0" + }, + "luarocks-3.7.0-lua53h06a4308_0.tar.bz2": { + "build": "lua53h06a4308_0", + "build_number": 0, + "depends": [ + "lua", + "unzip" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "508a767b4dd7aa22e100b7ae7d2e19a7", + "name": "luarocks", + "sha256": "1d61e74bdb0621cc8e0c8d4f67ee08fe8e753394b2d0f6ce2fef54238afaab0f", + "size": 144662, + "subdir": "linux-64", + "timestamp": 1618436602010, + "version": "3.7.0" + }, + "luigi-2.7.1-py27h6a3284f_0.tar.bz2": { + "build": "py27h6a3284f_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0e540976c3a6a881268d04d09b97ca23", + "name": "luigi", + "sha256": "95beb0ecf234523bdcc9d4a79ee2017af450010659716857fc68e1477c505b9d", + "size": 1148228, + "subdir": "linux-64", + "timestamp": 1507981695242, + "version": "2.7.1" + }, + "luigi-2.7.1-py35h7a986c5_0.tar.bz2": { + "build": "py35h7a986c5_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.5,<3.6.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cb5ca5bc20c5fd643f02646332bf7af5", + "name": "luigi", + "sha256": "34b4784e1be7094db0549ad47bf4619294227d223fbdc4c4d8641b6335daf413", + "size": 1160528, + "subdir": "linux-64", + "timestamp": 1507981737438, + "version": "2.7.1" + }, + "luigi-2.7.1-py36he7d448a_0.tar.bz2": { + "build": "py36he7d448a_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "053062079dbd8e2b96ff8c97c4eb786d", + "name": "luigi", + "sha256": "5e309397dad3ab9beae5df2c28e94d306f66d1733ecfe4359f3bf24ccb4dc071", + "size": 1155390, + "subdir": "linux-64", + "timestamp": 1507981737704, + "version": "2.7.1" + }, + "luigi-2.7.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2cbd16b1e9aebf391709f81d3d7bc2c1", + "name": "luigi", + "sha256": "d01baefc89af794857dfe27d615efc33c357fb9d91fe0b92ba18c817e14489ab", + "size": 1149881, + "subdir": "linux-64", + "timestamp": 1520829210010, + "version": "2.7.2" + }, + "luigi-2.7.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.5,<3.6.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0e8d066c37e4fd94148b15e195d30d34", + "name": "luigi", + "sha256": "61e995e10a74f580306e9ac3aba6093bbf86e5c64bab98d2f378284a0170602d", + "size": 1162853, + "subdir": "linux-64", + "timestamp": 1520829231051, + "version": "2.7.2" + }, + "luigi-2.7.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d7d410703426066ddbb4dbd13a8b3e0e", + "name": "luigi", + "sha256": "86f572c9731d4566b515a5f26d17523e83abfaa082a00f4d841bd29a67e5f7e5", + "size": 1157811, + "subdir": "linux-64", + "timestamp": 1520829202873, + "version": "2.7.2" + }, + "luigi-2.7.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "787083f6573785d698cf25bcdf69cf11", + "name": "luigi", + "sha256": "386ad6882be6fbd9327cad8ee01e097bb83db89cc2d1e2472918d4b12ad7d36b", + "size": 1156988, + "subdir": "linux-64", + "timestamp": 1522192028468, + "version": "2.7.3" + }, + "luigi-2.7.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.5,<3.6.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "383b1827c14d20162bca54651f7f521b", + "name": "luigi", + "sha256": "a4744741e566bed592bb787ccf2bfa6b207458db078af878b36a2b879d78006d", + "size": 1168881, + "subdir": "linux-64", + "timestamp": 1522192124851, + "version": "2.7.3" + }, + "luigi-2.7.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "205c2a49a027a0d0b49b6d5be4d959d1", + "name": "luigi", + "sha256": "a9a81ee9b8345b7f37f7cf59f0bab9c4504912eb3306e0580e055be2e7837b23", + "size": 1167788, + "subdir": "linux-64", + "timestamp": 1522192095747, + "version": "2.7.3" + }, + "luigi-2.7.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1d1bf1d1375b46a1ec3ee15b5adf8984", + "name": "luigi", + "sha256": "3d3dafdf838f1130b0ca66a244f370eb00e69fa473b6f4dac9064f87436f5bd7", + "size": 1158291, + "subdir": "linux-64", + "timestamp": 1524002240780, + "version": "2.7.5" + }, + "luigi-2.7.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.5,<3.6.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e0f3c93d3a0041005a310f3d2c9b0746", + "name": "luigi", + "sha256": "f8fd7ba886b43b9a9881a466926f5ec59d59d6c8f9f6ae439b9f2fd9875a15d1", + "size": 1170412, + "subdir": "linux-64", + "timestamp": 1524002331352, + "version": "2.7.5" + }, + "luigi-2.7.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7c57b4f5e73ea114fc6a5d7611c2444c", + "name": "luigi", + "sha256": "d3b0df989dfdf0f31a4b741d0f8c56f373c84aaa88e39a23f991bec606b8a9eb", + "size": 1169757, + "subdir": "linux-64", + "timestamp": 1524002328897, + "version": "2.7.5" + }, + "luigi-2.7.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2328734e944f8c8328453b66078f0e1c", + "name": "luigi", + "sha256": "1c0cc1b9cf6176a8a40bd6a38b112f0853c48d42fd5ab714de6fe370cac3f8ff", + "size": 1177619, + "subdir": "linux-64", + "timestamp": 1530899067643, + "version": "2.7.5" + }, + "luigi-2.7.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9d94955f090f06a8045c9e8ca692f706", + "name": "luigi", + "sha256": "f11adaf81b8b206fb69eda19a6a2611ba783bd7a7ca4bc12e059ad28f1f73a29", + "size": 1178884, + "subdir": "linux-64", + "timestamp": 1536104208659, + "version": "2.7.8" + }, + "luigi-2.7.8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d1079bdde92936a8fe1304ddd18cc165", + "name": "luigi", + "sha256": "0d7fa2fabcf38ebed59826995c5c6a81346b6620dad4b7425c78cadd9a504bd4", + "size": 1186021, + "subdir": "linux-64", + "timestamp": 1536104226296, + "version": "2.7.8" + }, + "luigi-2.7.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4e293c48011004e4af0c16f7efb0e85c", + "name": "luigi", + "sha256": "5750e9cb70881f29d93ddfd159f752e7477bb4eda1dc89fbdc57cf2d2a6fd271", + "size": 1186592, + "subdir": "linux-64", + "timestamp": 1536104207811, + "version": "2.7.8" + }, + "luigi-2.7.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "27c0c7d40afa389ab3a2ea27c1d58f7b", + "name": "luigi", + "sha256": "b424312284974efa9f472767e06d7ca30e7fd4a8313ad63cf3cb48df5a11269c", + "size": 1187746, + "subdir": "linux-64", + "timestamp": 1536104234500, + "version": "2.7.8" + }, + "luigi-2.7.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9d4515a074f363fbecd67f00e1ac1ff2", + "name": "luigi", + "sha256": "d5b2c33a03acf263a08e5191fcbd1098ce3bd7d930bab7be45135202e7223f87", + "size": 1180170, + "subdir": "linux-64", + "timestamp": 1538364465478, + "version": "2.7.9" + }, + "luigi-2.7.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a250aeddca864f7df04b9f3fd060aad3", + "name": "luigi", + "sha256": "93d671cd22a53984aa841d1fcdfa893a607a19237c2ca78b18f066cdac2cf776", + "size": 1188792, + "subdir": "linux-64", + "timestamp": 1538364433683, + "version": "2.7.9" + }, + "luigi-2.7.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "07e4eb38493341c7259345864fed2ca5", + "name": "luigi", + "sha256": "c81c06c0c14708391bec3b024c8270ef121976d5f31c04ad2396f32e0554646a", + "size": 1188533, + "subdir": "linux-64", + "timestamp": 1538364465927, + "version": "2.7.9" + }, + "luigi-2.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e891fd81f61cbdc91b359f212bb03e9f", + "name": "luigi", + "sha256": "32fa6f2f836e1002f7685929c653e9f712f60e89514834a26ab253ba5176b4d9", + "size": 1177574, + "subdir": "linux-64", + "timestamp": 1541174693610, + "version": "2.8.0" + }, + "luigi-2.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3008fcdd5afeec6489e3259aac4f93eb", + "name": "luigi", + "sha256": "24f7c5b085113994a6efae308d4b62e6a05e684242859dab3d3628f8d894a0d8", + "size": 1162783, + "subdir": "linux-64", + "timestamp": 1541174659338, + "version": "2.8.0" + }, + "luigi-2.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c38454ef73177cceabfd222b24c9f1ba", + "name": "luigi", + "sha256": "b9b751814a2a57d6ac67614f85bfedf7d102e5365812d0877baea8d553d32f92", + "size": 1186794, + "subdir": "linux-64", + "timestamp": 1541174654975, + "version": "2.8.0" + }, + "luigi-2.8.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ca8e275ff7cff3f93b1602f6fa1f8974", + "name": "luigi", + "sha256": "f03f32a12f4b5037d540bb16812449188a14c73038c99cc5b3a64abcd8d1bfb1", + "size": 1246973, + "subdir": "linux-64", + "timestamp": 1576540502718, + "version": "2.8.10" + }, + "luigi-2.8.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b3e46d818c34dfc9e457bf5cf765a970", + "name": "luigi", + "sha256": "5ca0e87f7a652500a97d9b782e8313ba048ee359dc8597b435580b292ac42373", + "size": 1244523, + "subdir": "linux-64", + "timestamp": 1576540504169, + "version": "2.8.10" + }, + "luigi-2.8.10-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "851e37666afd38d7dd3562ab9466df47", + "name": "luigi", + "sha256": "f26c46b07b3e6dd6513c624c8ad027a5884a377fde8a392de21100f2aa5b0215", + "size": 1248123, + "subdir": "linux-64", + "timestamp": 1576540506074, + "version": "2.8.10" + }, + "luigi-2.8.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d8bb90d7cb8aba4b73e952ccab71f089", + "name": "luigi", + "sha256": "08e3bff11776e7f41ae022a961d0a118d9f4e8d8360457a60d68e2f9bb991673", + "size": 1175021, + "subdir": "linux-64", + "timestamp": 1545108260738, + "version": "2.8.2" + }, + "luigi-2.8.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3b6b0291586bbad09fc7c5527a682c48", + "name": "luigi", + "sha256": "50bf1e7202770a23c99f64b16bbf29cf85187178a56d7deb6bd9e6247e95f488", + "size": 1197020, + "subdir": "linux-64", + "timestamp": 1545108290946, + "version": "2.8.2" + }, + "luigi-2.8.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0942d09d5c48bec9d74234f634c4c0f0", + "name": "luigi", + "sha256": "9a9cba59a5beeb7411ceef643fb9734841b9d27aa2da344194b9b0c89318c7bb", + "size": 1174919, + "subdir": "linux-64", + "timestamp": 1545108293082, + "version": "2.8.2" + }, + "luigi-2.8.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d7e43dd4c3800d3ddd9f8c3fa21be6e8", + "name": "luigi", + "sha256": "04c3c073ef0d7fc89227ffe1945d044396d019446f0b20a3bdda58569d460612", + "size": 1199405, + "subdir": "linux-64", + "timestamp": 1547791150256, + "version": "2.8.3" + }, + "luigi-2.8.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ad5c9846919365c61092010117ee3b8e", + "name": "luigi", + "sha256": "71d50c9e9250c3b1e83cbffc6f0c49b63fb54d1117c7e9af147af3982e208f24", + "size": 1204940, + "subdir": "linux-64", + "timestamp": 1547791199225, + "version": "2.8.3" + }, + "luigi-2.8.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3d3c23d7f6607c519e87bd08dbeb07e5", + "name": "luigi", + "sha256": "416fee593fe2d6d661159bcbd0e20bf9c0cb2031f3b002b317a9a95dc1deca3b", + "size": 1204295, + "subdir": "linux-64", + "timestamp": 1547791196857, + "version": "2.8.3" + }, + "luigi-2.8.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "50f911c2481b1ad63f992a900d6a7544", + "name": "luigi", + "sha256": "0b66ef73c208dcf56ac1587ca9a562644b4534f5387e1c5b54c1e37a69e91656", + "size": 1223490, + "subdir": "linux-64", + "timestamp": 1559919737034, + "version": "2.8.6" + }, + "luigi-2.8.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0cf512c63b30b73da77cfff378287cf0", + "name": "luigi", + "sha256": "42143c5d2842c9b0e862ec5b50661deda80a890d2d6f9c53506b6ae27b43ba87", + "size": 1245624, + "subdir": "linux-64", + "timestamp": 1559919756461, + "version": "2.8.6" + }, + "luigi-2.8.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "615371e78a493d90f2ef8e2571bc5fa2", + "name": "luigi", + "sha256": "3ecd7372b0de2ffd4d85c327119eceb030cd5ec24d583bf5cc203bdc5ee431c8", + "size": 1242161, + "subdir": "linux-64", + "timestamp": 1559919720650, + "version": "2.8.6" + }, + "luigi-2.8.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "930435bb4cb11481b8c3cd93f39f3bee", + "name": "luigi", + "sha256": "e5e33b5f2e6ad4c2d8e7edffd8420427c762359279f07b25e24389fd485d62ba", + "size": 1237771, + "subdir": "linux-64", + "timestamp": 1564686004974, + "version": "2.8.7" + }, + "luigi-2.8.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "74dec9a702a3bb69d85f0288aff196a8", + "name": "luigi", + "sha256": "0042ba5a1094a289db687edd31ec7231886fc768d7dc0276c5aa6919039f1274", + "size": 1243419, + "subdir": "linux-64", + "timestamp": 1564686007319, + "version": "2.8.7" + }, + "luigi-2.8.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c2b0129fc75566db61ca276e8f76a437", + "name": "luigi", + "sha256": "e32139fa1b825613ffff21316e9dec12e61009f820105f852ff345cc00a4fc89", + "size": 1261898, + "subdir": "linux-64", + "timestamp": 1564685717196, + "version": "2.8.7" + }, + "luigi-2.8.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c2d1ea14c35956628a796ad2acaa345a", + "name": "luigi", + "sha256": "2c4fc89f0e771318ccab790c88fb013cfb640b7e93ee2a6e0523a9571ff61518", + "size": 1239835, + "subdir": "linux-64", + "timestamp": 1569356334529, + "version": "2.8.9" + }, + "luigi-2.8.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "16a90713a468adc9222309699a09627e", + "name": "luigi", + "sha256": "9c98bbf9a6935f3d24fbe819c81796e28ccf71fef5cca6edac84c501de4ed551", + "size": 1236374, + "subdir": "linux-64", + "timestamp": 1569356335793, + "version": "2.8.9" + }, + "luigi-2.8.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "88a2cdda258873193a5c1f76531b1c71", + "name": "luigi", + "sha256": "2479cd71fb48a3b98dae927cfbf01d65c143d46f2619120afbfa6a3b3c890241", + "size": 1242811, + "subdir": "linux-64", + "timestamp": 1569356330144, + "version": "2.8.9" + }, + "luigi-2.8.9-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.8,<3.9.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6dbfa052fc04d613ddf7276859469bce", + "name": "luigi", + "sha256": "048c361d7e7a3fd63132511994e6a98ec38e8f90f539f6be4314544c9dc9e75d", + "size": 1236135, + "subdir": "linux-64", + "timestamp": 1574414024347, + "version": "2.8.9" + }, + "luigi-3.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "81e21857ea63d5be53c87ad8309d9021", + "name": "luigi", + "sha256": "d6ef5118ba29b0afb1c9790863fa93c756e244964b3dc4f495bbc7f700d36f06", + "size": 1223750, + "subdir": "linux-64", + "timestamp": 1595271767745, + "version": "3.0.0" + }, + "luigi-3.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a93ae53dd268989f6443a7dfeae5d779", + "name": "luigi", + "sha256": "0d66169845fbba654007204f62db6ee5412e189f465b3425c9345385712502c3", + "size": 1232680, + "subdir": "linux-64", + "timestamp": 1595276645447, + "version": "3.0.0" + }, + "luigi-3.0.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "toml <2.0.0", + "prometheus_client ==0.5.0" + ], + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "87e4c42f6388a8178ada115287bb5637", + "name": "luigi", + "sha256": "357696bff7a0f79dbbbb21c574834e3f001a3d173ce365d43578aa3aee9bc931", + "size": 1225684, + "subdir": "linux-64", + "timestamp": 1613676287421, + "version": "3.0.2" + }, + "luigi-3.0.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "toml <2.0.0", + "prometheus_client ==0.5.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ce1ce95e30253c2603e826fd3b6b46b8", + "name": "luigi", + "sha256": "6866c0bbe4e418b9f89f676b268d5ec5920e11b67659e0870f22e98ece54d543", + "size": 1218226, + "subdir": "linux-64", + "timestamp": 1613676270974, + "version": "3.0.2" + }, + "luigi-3.0.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.8,<3.9.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e5f729ff12caf7a86ab0324ccf2c57ae", + "name": "luigi", + "sha256": "102a1ae0829c919b8134332217d9ea726e70830e7a397133a8a43027eca1a600", + "size": 1227772, + "subdir": "linux-64", + "timestamp": 1613676162812, + "version": "3.0.2" + }, + "luigi-3.0.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.9,<3.10.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1b4cf04dd0a1af5358999192edf9aa06", + "name": "luigi", + "sha256": "276ac3c216fdbbe6eb3780edbf9ab722fa309f77fad2167832664b0c5cdbbde4", + "size": 1224304, + "subdir": "linux-64", + "timestamp": 1613676287504, + "version": "3.0.2" + }, + "luigi-3.0.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "toml <2.0.0", + "prometheus_client ==0.5.0" + ], + "depends": [ + "python >=3.10,<3.11.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tenacity >=6.3.0,<7", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cfc3e7e81f57f8627565d992bf3552d9", + "name": "luigi", + "sha256": "143598e5a00837a8cada5fe38d70e50b4c8ee789276fa73031ba4e58d5b7a54e", + "size": 1219045, + "subdir": "linux-64", + "timestamp": 1640812362734, + "version": "3.0.3" + }, + "luigi-3.0.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tenacity >=6.3.0,<7", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d1f14df259280a2c765878637b54d5b6", + "name": "luigi", + "sha256": "91774fd8132f47a22b0f00f701ea36bc26489426e65da8e62ac09202ba942a7c", + "size": 1216599, + "subdir": "linux-64", + "timestamp": 1618564379343, + "version": "3.0.3" + }, + "luigi-3.0.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "toml <2.0.0", + "prometheus_client ==0.5.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tenacity >=6.3.0,<7", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c9daa2fd4eb05dc731aae1ac51b3ac29", + "name": "luigi", + "sha256": "a8c54e97e99d2ed8cf32cb55721ac49b994126c97b358c60fc3ecdcb7bb23839", + "size": 1210143, + "subdir": "linux-64", + "timestamp": 1618564378459, + "version": "3.0.3" + }, + "luigi-3.0.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.8,<3.9.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tenacity >=6.3.0,<7", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "af4237015bd02c649b28385567bf9706", + "name": "luigi", + "sha256": "0b289f8cdb03654692b5f6be988833b5a416a70298b0f21add4e1d563f64597d", + "size": 1229181, + "subdir": "linux-64", + "timestamp": 1618564380541, + "version": "3.0.3" + }, + "luigi-3.0.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.9,<3.10.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tenacity >=6.3.0,<7", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d91f90f40b7299fb9d0027aa31292933", + "name": "luigi", + "sha256": "a78c0b4cf131be00de5420147bc6efb8c26d13b7c3b013485188dece22c17877", + "size": 1219939, + "subdir": "linux-64", + "timestamp": 1618564378157, + "version": "3.0.3" + }, + "luigi-3.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "prometheus_client >=0.5,<0.15", + "toml <2.0.0" + ], + "depends": [ + "python >=3.10,<3.11.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "tenacity >=8,<9", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "073b91124163dbb9486efe2a1ba693e2", + "name": "luigi", + "sha256": "095cff9c0dc72fd7640c473a453592e5b91d59cfe6185bfe8af72182cf2b1cc1", + "size": 1254793, + "subdir": "linux-64", + "timestamp": 1677013127919, + "version": "3.2.0" + }, + "luigi-3.2.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "toml <2.0.0", + "prometheus_client >=0.5,<0.15" + ], + "depends": [ + "python >=3.11,<3.12.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "tenacity >=8,<9", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1439258f092c4fa1f8bce66bf74c4fd9", + "name": "luigi", + "sha256": "cf11f566d183d797337b69510384d92d236b8b919d254fb1bcf28c43b4f5e3ae", + "size": 1383367, + "subdir": "linux-64", + "timestamp": 1677014417917, + "version": "3.2.0" + }, + "luigi-3.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "prometheus_client >=0.5,<0.15", + "toml <2.0.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "tenacity >=8,<9", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c7ee8b4727f086fbc88cfea7f81adf7c", + "name": "luigi", + "sha256": "349e6ff0c25b76851d5ad4dcd04c61740102bb36f8260c46859acb0958eb1b89", + "size": 1242272, + "subdir": "linux-64", + "timestamp": 1677013066910, + "version": "3.2.0" + }, + "luigi-3.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "prometheus_client >=0.5,<0.15", + "toml <2.0.0" + ], + "depends": [ + "python >=3.8,<3.9.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "tenacity >=8,<9", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "66352d09703b8ae847dbc300c4c69d6e", + "name": "luigi", + "sha256": "52e1a3db4478bdebe8ca47c160bac37f164f025982068e98ebc4addbc9c8066c", + "size": 1248960, + "subdir": "linux-64", + "timestamp": 1677013034332, + "version": "3.2.0" + }, + "luigi-3.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "prometheus_client >=0.5,<0.15", + "toml <2.0.0" + ], + "depends": [ + "python >=3.9,<3.10.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "tenacity >=8,<9", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eef72037799dd02fc89f79797a720746", + "name": "luigi", + "sha256": "ad986dd9d625056a932800c0a55e2255bb49aa70f97721097c71e3702b7b28ec", + "size": 1247800, + "subdir": "linux-64", + "timestamp": 1677013098036, + "version": "3.2.0" + }, + "lxml-3.8.0-py27hb3ac1f5_0.tar.bz2": { + "build": "py27hb3ac1f5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "libxslt", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "2b881bad3ef9202f35795580d21a0966", + "name": "lxml", + "sha256": "18b809ec842d8011559220f0e4149da7b671b1c577f9f9676b8057a03928d71c", + "size": 1154153, + "subdir": "linux-64", + "timestamp": 1505745345946, + "version": "3.8.0" + }, + "lxml-3.8.0-py35h4935ab9_0.tar.bz2": { + "build": "py35h4935ab9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "libxslt", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "0acbeb2dc854487665f0c079c54eebe4", + "name": "lxml", + "sha256": "dd500ba8d3f3f7692c75afc7ec2dfc24c3a4610e9b73c664fef21d2294127f68", + "size": 1157843, + "subdir": "linux-64", + "timestamp": 1505745447727, + "version": "3.8.0" + }, + "lxml-3.8.0-py36h6c6e760_0.tar.bz2": { + "build": "py36h6c6e760_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "libxslt", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "cf90513a57ab6e9c04dfdec6739b6b82", + "name": "lxml", + "sha256": "2470ea0216676b3951c7dbba1c88e1c4b73956253d57bc118fa7a7c52c1187e5", + "size": 1175781, + "subdir": "linux-64", + "timestamp": 1505745549332, + "version": "3.8.0" + }, + "lxml-4.1.0-py27hb025457_0.tar.bz2": { + "build": "py27hb025457_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "libxslt", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "c50d12bd7a88fb6b9661ba1412a5fb4a", + "name": "lxml", + "sha256": "92510ea5d4ef9d6533902d263ccb50fa76845224bf9e74dde7a5c3e0dc08b1fa", + "size": 1534778, + "subdir": "linux-64", + "timestamp": 1508599348346, + "version": "4.1.0" + }, + "lxml-4.1.0-py35ha401a81_0.tar.bz2": { + "build": "py35ha401a81_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "libxslt", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "250dd43f2683fc5beefd99d3955ddf1f", + "name": "lxml", + "sha256": "2723f7b23500295b8ad02d843349c017933a5933a6d48f77ead8ec7a5970198b", + "size": 1562236, + "subdir": "linux-64", + "timestamp": 1508599360221, + "version": "4.1.0" + }, + "lxml-4.1.0-py36h5b66e50_0.tar.bz2": { + "build": "py36h5b66e50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "libxslt", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "c13f6105b12310c8d32560b801a5dab1", + "name": "lxml", + "sha256": "72c8c2f024afaf867c25e8ebc5ffdc733c7051acdf29819802b62da38e3e0cb0", + "size": 1588819, + "subdir": "linux-64", + "timestamp": 1508599391098, + "version": "4.1.0" + }, + "lxml-4.1.1-py27hdd00cef_0.tar.bz2": { + "build": "py27hdd00cef_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "libxslt", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "c7ce4ecbf9cfa307fb0af8536d0d0076", + "name": "lxml", + "sha256": "c28e4d27cf1ae59f1995168641418dcfa1e24a6bfc2312a7bd6dbed753a79f97", + "size": 1532349, + "subdir": "linux-64", + "timestamp": 1511809610344, + "version": "4.1.1" + }, + "lxml-4.1.1-py27hf71bdeb_1.tar.bz2": { + "build": "py27hf71bdeb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "d4e8a2cd81b83c6145625e8b7f426c2d", + "name": "lxml", + "sha256": "fbb22e0674519aac57b853b440b663e75d8fa544113601af2a2cbf98e817e779", + "size": 1532167, + "subdir": "linux-64", + "timestamp": 1516987084941, + "version": "4.1.1" + }, + "lxml-4.1.1-py35ha19ceee_0.tar.bz2": { + "build": "py35ha19ceee_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "libxslt", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "f8634445b404fb2ec32e6ca68bbe70ea", + "name": "lxml", + "sha256": "31be7d2161d1feeaa34d6750215cc0cec11f3441dffacebc4c2247278eb05acc", + "size": 1559728, + "subdir": "linux-64", + "timestamp": 1511809618977, + "version": "4.1.1" + }, + "lxml-4.1.1-py35hf71bdeb_1.tar.bz2": { + "build": "py35hf71bdeb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "dd303a59f483fcb3dbd52a109f92d77c", + "name": "lxml", + "sha256": "d6bd79550ef940c1877c50e476982d07885d438a0228ce88b0c0c176b967abf0", + "size": 1560221, + "subdir": "linux-64", + "timestamp": 1516987092136, + "version": "4.1.1" + }, + "lxml-4.1.1-py36h4d89739_0.tar.bz2": { + "build": "py36h4d89739_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "libxslt", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "161c7db543433b599ce8ffe89b347ba9", + "name": "lxml", + "sha256": "107ab38ef2fa8aa9ef829419b9e84e1b2e92b1fc8ca41e2476c650be4ef089c8", + "size": 1587804, + "subdir": "linux-64", + "timestamp": 1511809548186, + "version": "4.1.1" + }, + "lxml-4.1.1-py36hf71bdeb_1.tar.bz2": { + "build": "py36hf71bdeb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "47db193edae76a967421a7db7baeaf50", + "name": "lxml", + "sha256": "acb40396b6950d7eb38f09f280bb7d947e42b7f166dbc6c2f1bcf0b800a41ac5", + "size": 1588870, + "subdir": "linux-64", + "timestamp": 1516987106864, + "version": "4.1.1" + }, + "lxml-4.2.0-py27h23eabaa_0.tar.bz2": { + "build": "py27h23eabaa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "15d606cc1f9e18c5f771d1ae35a5393d", + "name": "lxml", + "sha256": "2e8c893867d78cbad7e433df992db14980d3571b2dfde91d2c2cc29eb8dc0e13", + "size": 1495678, + "subdir": "linux-64", + "timestamp": 1521491331517, + "version": "4.2.0" + }, + "lxml-4.2.0-py35h23eabaa_0.tar.bz2": { + "build": "py35h23eabaa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "ac0852fa5c7b483bd2cc7a4af448fd07", + "name": "lxml", + "sha256": "78020f56293096fe67bf3b582e291d6b954d126f6c50e589ec94da1ea20bc7c8", + "size": 1498112, + "subdir": "linux-64", + "timestamp": 1521491358013, + "version": "4.2.0" + }, + "lxml-4.2.0-py36h23eabaa_0.tar.bz2": { + "build": "py36h23eabaa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "15b5a54a9c82f9f0793ddb9c021079c9", + "name": "lxml", + "sha256": "1a74fdfce314be5932d4efb45d29cef0abd7ada3ca5b1c8ed0e46a71f8eda39e", + "size": 1518601, + "subdir": "linux-64", + "timestamp": 1521491358304, + "version": "4.2.0" + }, + "lxml-4.2.1-py27h23eabaa_0.tar.bz2": { + "build": "py27h23eabaa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "87270b1ae2879059e34e61085cb029c3", + "name": "lxml", + "sha256": "64c9e927130ccab07578e8bafeccc6093750ce9919bbb46908c74bd992646d2a", + "size": 1495340, + "subdir": "linux-64", + "timestamp": 1522178755394, + "version": "4.2.1" + }, + "lxml-4.2.1-py35h23eabaa_0.tar.bz2": { + "build": "py35h23eabaa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "dd0d4f055bc9ff3bb5aa38912a524362", + "name": "lxml", + "sha256": "700d4c682fd1e0cdd066e44663e3756d350c7fe61cc47e35c67dd2b57b01372f", + "size": 1498619, + "subdir": "linux-64", + "timestamp": 1522178755201, + "version": "4.2.1" + }, + "lxml-4.2.1-py36h23eabaa_0.tar.bz2": { + "build": "py36h23eabaa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "9fd79db6effbe10057789c58c81c0a0b", + "name": "lxml", + "sha256": "85f36ad03b4b81e2fb96f2cbb364dba9cdeb74d44e3fc816e5c803192738d736", + "size": 1519163, + "subdir": "linux-64", + "timestamp": 1522178072276, + "version": "4.2.1" + }, + "lxml-4.2.2-py27hf71bdeb_0.tar.bz2": { + "build": "py27hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "b5b3c26f63344586cbe3443ca21f1760", + "name": "lxml", + "sha256": "07a95ba1c65a21d1d421356f0d74ee4e7bf44ba58b9a25e56dece1e1eb831992", + "size": 1688190, + "subdir": "linux-64", + "timestamp": 1529940312365, + "version": "4.2.2" + }, + "lxml-4.2.2-py35hf71bdeb_0.tar.bz2": { + "build": "py35hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "3f5af6c0642ed629b6d1936a1230bcb4", + "name": "lxml", + "sha256": "c6f3eb3cd5d89306d21427e6bffae6dabae690ea664049a107d8807a07ee40d8", + "size": 1687211, + "subdir": "linux-64", + "timestamp": 1529940334681, + "version": "4.2.2" + }, + "lxml-4.2.2-py36hf71bdeb_0.tar.bz2": { + "build": "py36hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "988701140ce6a858681f58d1a3c1493f", + "name": "lxml", + "sha256": "bb21a4229d43518e103f55da3cd32a9146164cc10757a6e4b06f781cb917c86b", + "size": 1705954, + "subdir": "linux-64", + "timestamp": 1529940316846, + "version": "4.2.2" + }, + "lxml-4.2.2-py37hf71bdeb_0.tar.bz2": { + "build": "py37hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "c76b4c6878bb621ffc31ddbe8931864b", + "name": "lxml", + "sha256": "75ce59ba1c9fd0f1dbf591c1d76a14313afd8f19783460ff74631e8b185ba4f3", + "size": 1695272, + "subdir": "linux-64", + "timestamp": 1530811233033, + "version": "4.2.2" + }, + "lxml-4.2.3-py27hf71bdeb_0.tar.bz2": { + "build": "py27hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "c1a0a147e114d76665fc406fcff39e2e", + "name": "lxml", + "sha256": "35b5b1685d48ec89b8fff665a3ba8f3c72311c8de3451e6368ef2327c0520628", + "size": 1688009, + "subdir": "linux-64", + "timestamp": 1532461514268, + "version": "4.2.3" + }, + "lxml-4.2.3-py35hf71bdeb_0.tar.bz2": { + "build": "py35hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "ed4298d884d79bf352dd2d72f52fe7db", + "name": "lxml", + "sha256": "f944a9ca6f3b758841b70b4a48fd1d58ad969215f0925ce16f349095b3e6ac8d", + "size": 1685548, + "subdir": "linux-64", + "timestamp": 1532461588343, + "version": "4.2.3" + }, + "lxml-4.2.3-py36hf71bdeb_0.tar.bz2": { + "build": "py36hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "1057c7d75499fb9ebe1b7fd78ecfbbff", + "name": "lxml", + "sha256": "e28ad02ddb6457f281e267b06847e06f6b5d88b61e66501dbcf4622e0435ff7c", + "size": 1704849, + "subdir": "linux-64", + "timestamp": 1532461521509, + "version": "4.2.3" + }, + "lxml-4.2.3-py37hf71bdeb_0.tar.bz2": { + "build": "py37hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "ce967b219a3c84a10c3b6b50620a27cc", + "name": "lxml", + "sha256": "3f65d4b1b8a75191cf54e5f077e3359a688bf25e0d7c47925227db286d14b197", + "size": 1697416, + "subdir": "linux-64", + "timestamp": 1532461532778, + "version": "4.2.3" + }, + "lxml-4.2.4-py27hf71bdeb_0.tar.bz2": { + "build": "py27hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "f5973552ae203fd7c80f035860150d44", + "name": "lxml", + "sha256": "8aa6a1c2844ca4b1efebbf4388e0e3a5c092128c6fe9735368697ac577d70c40", + "size": 1677841, + "subdir": "linux-64", + "timestamp": 1533744682774, + "version": "4.2.4" + }, + "lxml-4.2.4-py35hf71bdeb_0.tar.bz2": { + "build": "py35hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "9035cac2b158eabd11dd164536734c9d", + "name": "lxml", + "sha256": "2d4ad629858443c582fffae4cb6abcacc6ddafcd2151242796bc56ffdb65f4af", + "size": 1680131, + "subdir": "linux-64", + "timestamp": 1533744688189, + "version": "4.2.4" + }, + "lxml-4.2.4-py36hf71bdeb_0.tar.bz2": { + "build": "py36hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "cbbb2a339edcfb468f16b3d5101fd309", + "name": "lxml", + "sha256": "d908bea2ad0387201a486b80958c7b4d61af076f650d668b3e5c4470a21cf150", + "size": 1701152, + "subdir": "linux-64", + "timestamp": 1533744623304, + "version": "4.2.4" + }, + "lxml-4.2.4-py37hf71bdeb_0.tar.bz2": { + "build": "py37hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "8fe2659d637a037a346f1e91aba28ea3", + "name": "lxml", + "sha256": "c0da8b435389aae72967c8889e3cedd4a071aa8ba825757e6f8c71035c01c8ff", + "size": 1690367, + "subdir": "linux-64", + "timestamp": 1533744687579, + "version": "4.2.4" + }, + "lxml-4.2.5-py27hefd8a0e_0.tar.bz2": { + "build": "py27hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "d5919e8860f5a9e7116f698a39276e9f", + "name": "lxml", + "sha256": "98a71de79203063c7673f5bd993eee8f56b230d96f8de93efa202a5395bb19c7", + "size": 1668104, + "subdir": "linux-64", + "timestamp": 1536698420009, + "version": "4.2.5" + }, + "lxml-4.2.5-py35hefd8a0e_0.tar.bz2": { + "build": "py35hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "0063aba7c4babd26c7721ccb365e5bce", + "name": "lxml", + "sha256": "0bb538c358a68cbca7897dfd9deb3b58fe2d4e74c6ae522b90bb6145115b60dd", + "size": 1670490, + "subdir": "linux-64", + "timestamp": 1536698596088, + "version": "4.2.5" + }, + "lxml-4.2.5-py36hefd8a0e_0.tar.bz2": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "182928fe137a20750c63d07ff4c44dbd", + "name": "lxml", + "sha256": "d6adcad1ac1f20be11524b9a6016eb1f35c9b3d0cb2348cbb6825441a4511f13", + "size": 1691416, + "subdir": "linux-64", + "timestamp": 1536698603784, + "version": "4.2.5" + }, + "lxml-4.2.5-py37hefd8a0e_0.tar.bz2": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "5052de2c75fdf1c419fd2b1bf6258b4b", + "name": "lxml", + "sha256": "b48ec324e01e8109b9e41fa09be087e4c4de6cf4f1d1f5c99c695d5aeb1412b3", + "size": 1683696, + "subdir": "linux-64", + "timestamp": 1536698509589, + "version": "4.2.5" + }, + "lxml-4.3.0-py27hefd8a0e_0.tar.bz2": { + "build": "py27hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "e1c8a1bc8060fae1ad84df71e65012f3", + "name": "lxml", + "sha256": "6ee1e62d26c9d72745fc5890b1e5a2a43eae3d4ea09c229e74f9fe4daed208ad", + "size": 1513493, + "subdir": "linux-64", + "timestamp": 1547236255688, + "version": "4.3.0" + }, + "lxml-4.3.0-py36hefd8a0e_0.tar.bz2": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "64821f37190191e99616c62b2a12ef64", + "name": "lxml", + "sha256": "5bcd4f986a76555c0ab0013220b76c44ab1747e312b5cd64f3348ff9bfef0495", + "size": 1565045, + "subdir": "linux-64", + "timestamp": 1547236352842, + "version": "4.3.0" + }, + "lxml-4.3.0-py37hefd8a0e_0.tar.bz2": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "f25177d210f090ebdf4b8cc7c5e9adef", + "name": "lxml", + "sha256": "aa9b7ffb5ab3c40143e54d4c3995c993da2c0edd4361e876add2e86ad384eddb", + "size": 1545633, + "subdir": "linux-64", + "timestamp": 1547236279487, + "version": "4.3.0" + }, + "lxml-4.3.1-py27hefd8a0e_0.tar.bz2": { + "build": "py27hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "d18c105099b93bad18bca37105306cdd", + "name": "lxml", + "sha256": "96bee77682bd548f03cf091b6d2b75f25049b932d3ec70a88d572ef464f81b7f", + "size": 1523436, + "subdir": "linux-64", + "timestamp": 1550348751246, + "version": "4.3.1" + }, + "lxml-4.3.1-py36hefd8a0e_0.tar.bz2": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "25e229298da9105deb0a66fc11863ebc", + "name": "lxml", + "sha256": "5967fcc41a879ec65f1110596c3053e509b65560917e72df86d8dbefdbc8e18d", + "size": 1562801, + "subdir": "linux-64", + "timestamp": 1550348776672, + "version": "4.3.1" + }, + "lxml-4.3.1-py37hefd8a0e_0.tar.bz2": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "ab1de92540a83ad61f763484f4c6865d", + "name": "lxml", + "sha256": "d5d36cbdb654584bb250476c058841701fb45aa6db317607de972f20ae470552", + "size": 1551393, + "subdir": "linux-64", + "timestamp": 1550349771708, + "version": "4.3.1" + }, + "lxml-4.3.2-py27hefd8a0e_0.tar.bz2": { + "build": "py27hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "c964e87ccc39f6b4e57c7d74123657fc", + "name": "lxml", + "sha256": "8afb9bef43c543403759b58b2017cf944f4e0aefcf75732aaddd94b088cee059", + "size": 1517727, + "subdir": "linux-64", + "timestamp": 1552327659698, + "version": "4.3.2" + }, + "lxml-4.3.2-py36hefd8a0e_0.tar.bz2": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "d177c3a77a0ca48fdbfbc6a9ec4c2025", + "name": "lxml", + "sha256": "224cf5ea91471127da4c7707596861b40ab81e8dec3df9cc9b85eb0b30762a56", + "size": 1569304, + "subdir": "linux-64", + "timestamp": 1552327703073, + "version": "4.3.2" + }, + "lxml-4.3.2-py37hefd8a0e_0.tar.bz2": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "c0fad472922edeebe35f653fb1233065", + "name": "lxml", + "sha256": "195e72c505ff3cf161044d0e538aa1615c897ce357ef6a1350e24fe41356aa5a", + "size": 1548451, + "subdir": "linux-64", + "timestamp": 1552327644010, + "version": "4.3.2" + }, + "lxml-4.3.3-py27hefd8a0e_0.tar.bz2": { + "build": "py27hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "cee81dc2d29c0488d537b0db41f6c511", + "name": "lxml", + "sha256": "cb521f0b3ca367af275b7904a576d0db8f2a08b2317b60a73c36ef36a93ad7ce", + "size": 1524535, + "subdir": "linux-64", + "timestamp": 1555430125044, + "version": "4.3.3" + }, + "lxml-4.3.3-py36hefd8a0e_0.tar.bz2": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "05264cd34fdb0917f9ca75d896bc039b", + "name": "lxml", + "sha256": "2ab28f4839e18e580986ad9ef38432f3d55c910c68f3c0bcc8cc542751d44fb0", + "size": 1565195, + "subdir": "linux-64", + "timestamp": 1555429929477, + "version": "4.3.3" + }, + "lxml-4.3.3-py37hefd8a0e_0.tar.bz2": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "123d4629985022d076e91f662a1d65d8", + "name": "lxml", + "sha256": "395b604e65a0ba61c177959a666ce54c6c71aefe0040a18144586293d22859d5", + "size": 1554906, + "subdir": "linux-64", + "timestamp": 1555429960245, + "version": "4.3.3" + }, + "lxml-4.3.4-py27hefd8a0e_0.tar.bz2": { + "build": "py27hefd8a0e_0", + "build_number": 0, + "depends": [ + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "e5b4eb4e192628e45f3eb9a8b4f1fc83", + "name": "lxml", + "sha256": "fc49b09ff5a774c014b95e8ef36cd36ec75de4323448ac5f8b450280bee7b02d", + "size": 1512827, + "subdir": "linux-64", + "timestamp": 1562084916851, + "version": "4.3.4" + }, + "lxml-4.3.4-py36hefd8a0e_0.tar.bz2": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "c76bfbdd4f5e694f1859f0772f59f004", + "name": "lxml", + "sha256": "c505853ab6add0695e34abb996c8e5954cb4eb9f7722740621b6529c773cb445", + "size": 1570422, + "subdir": "linux-64", + "timestamp": 1562084855365, + "version": "4.3.4" + }, + "lxml-4.3.4-py37hefd8a0e_0.tar.bz2": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "8ccf8cfd061a21d148f4d8811d89406e", + "name": "lxml", + "sha256": "971282496cb1dbe66770e1fb22f6ef6bb8214dc144032728b1b9ab525b371676", + "size": 1552996, + "subdir": "linux-64", + "timestamp": 1562084929368, + "version": "4.3.4" + }, + "lxml-4.4.1-py27hefd8a0e_0.tar.bz2": { + "build": "py27hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "caecfbbaec4ce690114bc1d96fdfda76", + "name": "lxml", + "sha256": "fa9fb48c933fcaf2184a8db57d429e39f70bdaa3acad073404a1a345a1a861f8", + "size": 1594245, + "subdir": "linux-64", + "timestamp": 1565963417212, + "version": "4.4.1" + }, + "lxml-4.4.1-py36hefd8a0e_0.tar.bz2": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "842fb4da9673f4b41cb93c31fe6077d3", + "name": "lxml", + "sha256": "fcb65d861d77148ef5f932b1a0abe23665189c423c7cdedccf473d9970b8ff0e", + "size": 1639461, + "subdir": "linux-64", + "timestamp": 1565963487076, + "version": "4.4.1" + }, + "lxml-4.4.1-py37hefd8a0e_0.tar.bz2": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "308587ae53393673f3f225a7e6ff08b2", + "name": "lxml", + "sha256": "9344da86e8bcace1df8f2f52689c431bfff4af712d155ff04bcdb46a68c8ef8c", + "size": 1625823, + "subdir": "linux-64", + "timestamp": 1565965057925, + "version": "4.4.1" + }, + "lxml-4.4.1-py38hefd8a0e_0.tar.bz2": { + "build": "py38hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "d3d0d2876458018bd418de41c7e4ca6e", + "name": "lxml", + "sha256": "503c5919a6e605afde0b4779cfa1770fd833ad1587751db17b23b90e2635c9f3", + "size": 1719106, + "subdir": "linux-64", + "timestamp": 1573488981909, + "version": "4.4.1" + }, + "lxml-4.4.2-py27hefd8a0e_0.tar.bz2": { + "build": "py27hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "f9e22832ce40f32dd3482546e820677a", + "name": "lxml", + "sha256": "789dec21ae2bef6f778934f04f8e66cf4f7bb3627b889e4ae60ebee035e1920c", + "size": 1587942, + "subdir": "linux-64", + "timestamp": 1575392874252, + "version": "4.4.2" + }, + "lxml-4.4.2-py36hefd8a0e_0.tar.bz2": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "4168d0035f6a43f85fefe90b6fbb6ab0", + "name": "lxml", + "sha256": "225c59fe86998406a8d3ba58af62e2ae2fb0566be099803de744b0dd5b21c64c", + "size": 1637215, + "subdir": "linux-64", + "timestamp": 1575392877840, + "version": "4.4.2" + }, + "lxml-4.4.2-py37hefd8a0e_0.tar.bz2": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "0fdb4744c2000266eb7b3c86108cfa80", + "name": "lxml", + "sha256": "dc45d5887e903775d81fc1da5a8ac19a4fd2316aef5ceaa826145148aa00904d", + "size": 1627634, + "subdir": "linux-64", + "timestamp": 1575392863820, + "version": "4.4.2" + }, + "lxml-4.4.2-py38hefd8a0e_0.tar.bz2": { + "build": "py38hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "288e640be79303e99dc1d2eeb3531daf", + "name": "lxml", + "sha256": "aa7efcf7c97e0ddb5c54afd803fcac49584b373ba5f467e55ba8b8bdf8be872b", + "size": 1746420, + "subdir": "linux-64", + "timestamp": 1575392881919, + "version": "4.4.2" + }, + "lxml-4.5.0-py36hefd8a0e_0.tar.bz2": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "48dfba003b3b02591e3e4196440e6a07", + "name": "lxml", + "sha256": "6410bac12b9c97a08b2eb03d8cb8e47eb3b902f3e4c9baa9051ade3befaadf19", + "size": 1638037, + "subdir": "linux-64", + "timestamp": 1580834949033, + "version": "4.5.0" + }, + "lxml-4.5.0-py37hefd8a0e_0.tar.bz2": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "55787a0c2a5919a889f903cf7ec31842", + "name": "lxml", + "sha256": "4dff964295fc063c6ec2b753c5320d94f6fd5b416df6c6841f6cb1b163e6ef43", + "size": 1621483, + "subdir": "linux-64", + "timestamp": 1580834923784, + "version": "4.5.0" + }, + "lxml-4.5.0-py38hefd8a0e_0.tar.bz2": { + "build": "py38hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "3714662bc2c17a651c5df84d4ec99f7c", + "name": "lxml", + "sha256": "d89c9e510d57a6c1109df0c9014d61b7d8dbe0e39042596c608141ec099526f0", + "size": 1731624, + "subdir": "linux-64", + "timestamp": 1580834925769, + "version": "4.5.0" + }, + "lxml-4.5.1-py36hefd8a0e_0.tar.bz2": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "3ab2968165789a4afd1eea228a12d76c", + "name": "lxml", + "sha256": "4499edfb9282b6723c66ba77ae864d168a7ab5c6855b6cafa5056782dc364c8f", + "size": 1417078, + "subdir": "linux-64", + "timestamp": 1591882873369, + "version": "4.5.1" + }, + "lxml-4.5.1-py37hefd8a0e_0.tar.bz2": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "e3113ba2ab34faf5bb9c92cb61861fe4", + "name": "lxml", + "sha256": "489d85cd0b705f8544c80e81de5d5ed95ec8d7fb62b76335297caca2d072362c", + "size": 1406256, + "subdir": "linux-64", + "timestamp": 1591882859724, + "version": "4.5.1" + }, + "lxml-4.5.1-py38hefd8a0e_0.tar.bz2": { + "build": "py38hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "c17b001cc6747f287c513468eea7a6e7", + "name": "lxml", + "sha256": "a2e8e5c24cb931f2afecd086df91af1091a83c25ef185169d1ad7bc2615977ef", + "size": 1501801, + "subdir": "linux-64", + "timestamp": 1591882827218, + "version": "4.5.1" + }, + "lxml-4.5.2-py36hefd8a0e_0.tar.bz2": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "a72df3ab5664ccdac024ad03171bcb43", + "name": "lxml", + "sha256": "7471680adde8e7b44e9ce997e106a85c909f090c368f522e1ffaa13fb1d13e13", + "size": 1429243, + "subdir": "linux-64", + "timestamp": 1594826614186, + "version": "4.5.2" + }, + "lxml-4.5.2-py37hefd8a0e_0.tar.bz2": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "9f02f985db0137be17ca64be1f50358e", + "name": "lxml", + "sha256": "f1f54dab036ab4bfc590b6a378dedb96406b75997ce640a31de4d260889c7812", + "size": 1416149, + "subdir": "linux-64", + "timestamp": 1594824538992, + "version": "4.5.2" + }, + "lxml-4.5.2-py38hefd8a0e_0.tar.bz2": { + "build": "py38hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "fd83a029159117c2a8351e870627abe0", + "name": "lxml", + "sha256": "0c9702c36c869433f37ace88ae18d3141a7d85c739da87ad6ce9384ab81d54c1", + "size": 1520549, + "subdir": "linux-64", + "timestamp": 1594826900981, + "version": "4.5.2" + }, + "lxml-4.6.1-py36hefd8a0e_0.tar.bz2": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "1f8f08b15da727d9734c872e215640f1", + "name": "lxml", + "sha256": "2f24c93d022c450d2ad72ec146f52c4810325581c13ed8676b04f6b11db6a849", + "size": 1414467, + "subdir": "linux-64", + "timestamp": 1603216402424, + "version": "4.6.1" + }, + "lxml-4.6.1-py37hefd8a0e_0.tar.bz2": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "a060001a2cf6a4eebe218c283fae1f9d", + "name": "lxml", + "sha256": "9bbd79543d637dc44f13463731c5aae833d4cc6763001f4fc2e1cc7c91b60f83", + "size": 1403503, + "subdir": "linux-64", + "timestamp": 1603216418742, + "version": "4.6.1" + }, + "lxml-4.6.1-py38hefd8a0e_0.tar.bz2": { + "build": "py38hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "c893f410ad67032f43c527b81f37138e", + "name": "lxml", + "sha256": "90567bfa4a4f843ca31687370fd11e3f6a5f21dc4d8c0ec5fa32d62406dc48df", + "size": 1503382, + "subdir": "linux-64", + "timestamp": 1603216417985, + "version": "4.6.1" + }, + "lxml-4.6.2-py36h9120a33_0.tar.bz2": { + "build": "py36h9120a33_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "595956bab52589305bcc4a2bd546186b", + "name": "lxml", + "sha256": "8b78dcfec2f06f0e4a8138d20dbbd81c7f14796cda79fa5b2d7a264ae9285e30", + "size": 1427391, + "subdir": "linux-64", + "timestamp": 1606516980497, + "version": "4.6.2" + }, + "lxml-4.6.2-py37h9120a33_0.tar.bz2": { + "build": "py37h9120a33_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "e9ed08ac9880e4a5d29c929f8eb7e426", + "name": "lxml", + "sha256": "73222a960f4a5ad7516e30f200b1e435a8af5301b6f554b3fcc1af6c08286f6e", + "size": 1415354, + "subdir": "linux-64", + "timestamp": 1606516979285, + "version": "4.6.2" + }, + "lxml-4.6.2-py38h9120a33_0.tar.bz2": { + "build": "py38h9120a33_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "d08e5c54d274fe572d57d3962ee30615", + "name": "lxml", + "sha256": "82558c92c668673b53b37dd56c18b78b6ab89e5778448afccafef630b3b6ed57", + "size": 1503136, + "subdir": "linux-64", + "timestamp": 1606516984778, + "version": "4.6.2" + }, + "lxml-4.6.2-py39h9120a33_0.tar.bz2": { + "build": "py39h9120a33_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "51f20dcea81a9054c546a201b2ecfa4a", + "name": "lxml", + "sha256": "6cfe6a598876abcc29b9ba61260f3c34d3ff99720c6bfd4410a5a59d00dd0901", + "size": 1510769, + "subdir": "linux-64", + "timestamp": 1606516960775, + "version": "4.6.2" + }, + "lxml-4.6.3-py310hec1077d_0.tar.bz2": { + "build": "py310hec1077d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "48e881815af31ca8f43734ae1c7efcba", + "name": "lxml", + "sha256": "4eb157d48e4a184c546332c208d5a3198bc11d069e5b57a2c3de1caceef3c033", + "size": 5845371, + "subdir": "linux-64", + "timestamp": 1640791507708, + "version": "4.6.3" + }, + "lxml-4.6.3-py36h9120a33_0.tar.bz2": { + "build": "py36h9120a33_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "feee822fc2b9792b0b0b41ad1b6783b1", + "name": "lxml", + "sha256": "8ce765292c09ca92ca3fde2e66f77227823046f144e8b1c612e9beda1182d3f6", + "size": 1425626, + "subdir": "linux-64", + "timestamp": 1616443050444, + "version": "4.6.3" + }, + "lxml-4.6.3-py37h9120a33_0.tar.bz2": { + "build": "py37h9120a33_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "718600e0dea6150c481863bedea94dfb", + "name": "lxml", + "sha256": "1763b71190abdc1ae4123332663e59b33418a502b490412d755c5d580493029d", + "size": 1397247, + "subdir": "linux-64", + "timestamp": 1616443048313, + "version": "4.6.3" + }, + "lxml-4.6.3-py38h9120a33_0.tar.bz2": { + "build": "py38h9120a33_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "4364e7a97880b8138674f96b07a54ac4", + "name": "lxml", + "sha256": "e028608468bd896b59914fd6ac94168ddd40f41ec0f29427d5296ae661aa16ae", + "size": 1512644, + "subdir": "linux-64", + "timestamp": 1616443350824, + "version": "4.6.3" + }, + "lxml-4.6.3-py39h9120a33_0.tar.bz2": { + "build": "py39h9120a33_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "1a545d2e12fbc20d49ac1ec97fca7f3e", + "name": "lxml", + "sha256": "b4d2ada4f632e799d37806202b5e41844cc3d99993979a76fc931081d0cc489b", + "size": 1513659, + "subdir": "linux-64", + "timestamp": 1616443358898, + "version": "4.6.3" + }, + "lxml-4.7.1-py37h1f438cf_0.tar.bz2": { + "build": "py37h1f438cf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "8c45d47c670232670fec2a9caf9d8d09", + "name": "lxml", + "sha256": "d0d9f284727feb2d147ac473e192663f099929d73e5b547617d98adee1fcb6eb", + "size": 1437007, + "subdir": "linux-64", + "timestamp": 1640153397171, + "version": "4.7.1" + }, + "lxml-4.7.1-py37h1f438cf_1.tar.bz2": { + "build": "py37h1f438cf_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "2f336d3d543e10556014db32b3d330ad", + "name": "lxml", + "sha256": "c68b3d7ad152c6e12a7315ff17b92fb04a298c97b009c24c4f4064bec9761aa0", + "size": 1440091, + "subdir": "linux-64", + "timestamp": 1640178379946, + "version": "4.7.1" + }, + "lxml-4.7.1-py37hec1077d_0.tar.bz2": { + "build": "py37hec1077d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "1ff96b0224e29f3006540f40505c7345", + "name": "lxml", + "sha256": "fd2920de138154969ec764cc094fe97a1bcbb8a5caef15ea323484f4528bf59a", + "size": 1434298, + "subdir": "linux-64", + "timestamp": 1640087751947, + "version": "4.7.1" + }, + "lxml-4.7.1-py38h1f438cf_0.tar.bz2": { + "build": "py38h1f438cf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "9cc2c003cbd04971c57e2832eb5aadfc", + "name": "lxml", + "sha256": "5b9fe2a07fcc178191a8fb14c992e608d3e255ad4f5df9f222bc1410603743cf", + "size": 1523094, + "subdir": "linux-64", + "timestamp": 1640167505942, + "version": "4.7.1" + }, + "lxml-4.7.1-py38h1f438cf_1.tar.bz2": { + "build": "py38h1f438cf_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "4611f204601af0e28f3ef4e78ce602d4", + "name": "lxml", + "sha256": "1d3aa44ccd2dd5a1645632af249b2e3a58c5cfbc1b888234d0903ef296771412", + "size": 1543557, + "subdir": "linux-64", + "timestamp": 1640164489622, + "version": "4.7.1" + }, + "lxml-4.7.1-py38hec1077d_0.tar.bz2": { + "build": "py38hec1077d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "56ba4a9f5e210077e8fbfef5a0043a3d", + "name": "lxml", + "sha256": "c55d2a7c6f9a9acaa23f7fb2ba788d1d35f821c7913cbe9fbb6d203b5194828e", + "size": 1537637, + "subdir": "linux-64", + "timestamp": 1640166577855, + "version": "4.7.1" + }, + "lxml-4.7.1-py39h1f438cf_0.tar.bz2": { + "build": "py39h1f438cf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "f66e7e458ec1887c5b2b0363097acdb9", + "name": "lxml", + "sha256": "5643b28df2bf5fcfe0859788c97368cba1d928a3adca37cc6c01bb29c7d2e928", + "size": 1538387, + "subdir": "linux-64", + "timestamp": 1640167512186, + "version": "4.7.1" + }, + "lxml-4.7.1-py39h1f438cf_1.tar.bz2": { + "build": "py39h1f438cf_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "7bcfedd6481e0b8d01a1d99a9a28fd30", + "name": "lxml", + "sha256": "799360e18e340c5ab40d06c428b1f0932e701eefd384fb9a13d80166e502cbcf", + "size": 1545007, + "subdir": "linux-64", + "timestamp": 1640160259275, + "version": "4.7.1" + }, + "lxml-4.7.1-py39hec1077d_0.tar.bz2": { + "build": "py39hec1077d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "358bb11e78c254ad95b1bf7ac1aacbd3", + "name": "lxml", + "sha256": "937928937b8754f77c8a76b160d5d312f20d2c5af9dc88a6b6d381c1dbcd7346", + "size": 1534559, + "subdir": "linux-64", + "timestamp": 1640105873206, + "version": "4.7.1" + }, + "lxml-4.8.0-py310h1f438cf_0.tar.bz2": { + "build": "py310h1f438cf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "272fd5ca6590d8388145f32d1a3df749", + "name": "lxml", + "sha256": "4772edafba1c0cdc703ae02a3f2f37299b99fefe2dcd135e329df4ceeb2184e4", + "size": 5977342, + "subdir": "linux-64", + "timestamp": 1646642809299, + "version": "4.8.0" + }, + "lxml-4.8.0-py37h1f438cf_0.tar.bz2": { + "build": "py37h1f438cf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "14f961026143863f9e95131dcd85a7bd", + "name": "lxml", + "sha256": "a19ba483fe8dfee9b8a4c56bfba8c22f99245f7501234d1a916ce9ca2f12be9b", + "size": 1448435, + "subdir": "linux-64", + "timestamp": 1646642772018, + "version": "4.8.0" + }, + "lxml-4.8.0-py38h1f438cf_0.tar.bz2": { + "build": "py38h1f438cf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "7022e768926ab2f0d282e5b6340c14a1", + "name": "lxml", + "sha256": "475b2036ccbe21927259773974277f3a8cfea282bfc5c2cbd543bfc8aa60f7f7", + "size": 1542907, + "subdir": "linux-64", + "timestamp": 1646625393119, + "version": "4.8.0" + }, + "lxml-4.8.0-py39h1f438cf_0.tar.bz2": { + "build": "py39h1f438cf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "ec4f05846aacf634df15c389235725cc", + "name": "lxml", + "sha256": "64b022d706b76c33965a250fdc8c6008443c41bff8ab27bb1df3cb70419576fd", + "size": 1538261, + "subdir": "linux-64", + "timestamp": 1646624639995, + "version": "4.8.0" + }, + "lxml-4.9.1-py310h1edc446_0.tar.bz2": { + "build": "py310h1edc446_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "libxslt >=1.1.28", + "libxslt >=1.1.35,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "license_family": "Other", + "md5": "4ea8c65a572668247c5af8f865d59430", + "name": "lxml", + "sha256": "53c65e2aaec944eeea746f7bf083f07bb8b0842fedae34e419fb530acbeb20d1", + "size": 6391549, + "subdir": "linux-64", + "timestamp": 1657545422195, + "version": "4.9.1" + }, + "lxml-4.9.1-py311h1edc446_0.tar.bz2": { + "build": "py311h1edc446_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "libxslt >=1.1.28", + "libxslt >=1.1.35,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "license_family": "Other", + "md5": "06e1cef1a5fb3f0a227c96c4b3bf72bc", + "name": "lxml", + "sha256": "7ceb56346869befc3ef25c902f6cd1c5b94d3a39b4248e26fe3bf7a901f36d66", + "size": 1478966, + "subdir": "linux-64", + "timestamp": 1676823679793, + "version": "4.9.1" + }, + "lxml-4.9.1-py37h1edc446_0.tar.bz2": { + "build": "py37h1edc446_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "libxslt >=1.1.28", + "libxslt >=1.1.35,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "license_family": "Other", + "md5": "4128b740abbd5dba4d1d7a1052414e10", + "name": "lxml", + "sha256": "1c4737194ac958baa6431a81a10cd249520770b1e99567ae85ad47fb27e97291", + "size": 1434089, + "subdir": "linux-64", + "timestamp": 1657545665009, + "version": "4.9.1" + }, + "lxml-4.9.1-py38h1edc446_0.tar.bz2": { + "build": "py38h1edc446_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "libxslt >=1.1.28", + "libxslt >=1.1.35,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "license_family": "Other", + "md5": "3d598f01a90fdb99c7ba4f076648ad00", + "name": "lxml", + "sha256": "a86f9062fae93ec154e7d9b9df6ab0639c830b85c7384cdb69d6fb7d31656246", + "size": 1513137, + "subdir": "linux-64", + "timestamp": 1657545279429, + "version": "4.9.1" + }, + "lxml-4.9.1-py39h1edc446_0.tar.bz2": { + "build": "py39h1edc446_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "libxslt >=1.1.28", + "libxslt >=1.1.35,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "license_family": "Other", + "md5": "2d0afea32e1b04b75367811e7ce6f850", + "name": "lxml", + "sha256": "ad0a1e80ec92a61472c191b1cf6e0c03fb5ed07df14cba7ef9da8550cd21fe2e", + "size": 1471713, + "subdir": "linux-64", + "timestamp": 1657545537815, + "version": "4.9.1" + }, + "lxml-4.9.2-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "libxslt >=1.1.28,<2.0.0a0", + "libxslt >=1.1.37,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "license_family": "Other", + "md5": "a883d16d137c9444c9b8ecf5ba6c6663", + "name": "lxml", + "sha256": "34518461d53ac228bc24e22264261248323318173222e5a77d450bfc3a546d69", + "size": 1582338, + "subdir": "linux-64", + "timestamp": 1679646648983, + "version": "4.9.2" + }, + "lxml-4.9.2-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "libxslt >=1.1.28,<2.0.0a0", + "libxslt >=1.1.37,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "license_family": "Other", + "md5": "183aef78f7234d69f93368a643424235", + "name": "lxml", + "sha256": "02dcfc34685d7ff860cf729cc0a19fcecc32d41388d3adc8163af04877bd8517", + "size": 1613046, + "subdir": "linux-64", + "timestamp": 1679646846055, + "version": "4.9.2" + }, + "lxml-4.9.2-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "libxslt >=1.1.28,<2.0.0a0", + "libxslt >=1.1.37,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "license_family": "Other", + "md5": "d6c62432285c1205b375487e9c9cdfc6", + "name": "lxml", + "sha256": "1a2693f7890b76c15bc051536e9c6e0522534ce175a784ce3ef8ade503a31803", + "size": 1646033, + "subdir": "linux-64", + "timestamp": 1679646751278, + "version": "4.9.2" + }, + "lxml-4.9.2-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "libxslt >=1.1.28,<2.0.0a0", + "libxslt >=1.1.37,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "license_family": "Other", + "md5": "605a2df95523c24087f320b01f87da51", + "name": "lxml", + "sha256": "7ec16fa14a26aa63d4866c3de41bf3525e90638d5ffc9b6f6254b38ec993d875", + "size": 1598785, + "subdir": "linux-64", + "timestamp": 1679646554227, + "version": "4.9.2" + }, + "lz4-1.1.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4b32dbf2cb6f380db9e711de659b03f2", + "name": "lz4", + "sha256": "0f7bea19ab2cd760966a467ad7f6bb9f4bc6cb42ca5c09c3c3aa402522a5d152", + "size": 36764, + "subdir": "linux-64", + "timestamp": 1537199702830, + "version": "1.1.0" + }, + "lz4-1.1.0-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4a01ed82bf6b6e2d2865e7d8b8eee1dd", + "name": "lz4", + "sha256": "999a44b1b45105a65926f8eabace48f9c01dc434f2774c055f507a0bfbba99f3", + "size": 37218, + "subdir": "linux-64", + "timestamp": 1537199747007, + "version": "1.1.0" + }, + "lz4-1.1.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fb8544c8db5a0b3098a0422483b11993", + "name": "lz4", + "sha256": "43a1243919afa82f3fdc57c96a8427f5aed3f05ae74b2c545f4e5db92352f23e", + "size": 37237, + "subdir": "linux-64", + "timestamp": 1537199727393, + "version": "1.1.0" + }, + "lz4-1.1.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "69407821129d3cf74669e0512da33a49", + "name": "lz4", + "sha256": "fe9adf335ecf2df0826d48fbd44528825db33dd7e285e38fdeed42905684484c", + "size": 37266, + "subdir": "linux-64", + "timestamp": 1537199665286, + "version": "1.1.0" + }, + "lz4-2.1.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "992fbad3afe50d1cac65488cc1512ac2", + "name": "lz4", + "sha256": "91dc478c7e45ce9f6a64541205d083c387301153b2b2cdb092aba9903eca65f0", + "size": 38565, + "subdir": "linux-64", + "timestamp": 1539723775825, + "version": "2.1.1" + }, + "lz4-2.1.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4d4c533643590768f18a807f9741aeaa", + "name": "lz4", + "sha256": "54583876dc994acbc868d37b50feaf689c37c79e0f12a762e8765f63f43b11ef", + "size": 39014, + "subdir": "linux-64", + "timestamp": 1539723815791, + "version": "2.1.1" + }, + "lz4-2.1.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "97eb5cf10b76406437a6e66b50c1e09a", + "name": "lz4", + "sha256": "ea935ab22715c115884ee08f1bd9f6736a5e30c84d0cd682718ac2e6ff0c045a", + "size": 39045, + "subdir": "linux-64", + "timestamp": 1539723815004, + "version": "2.1.1" + }, + "lz4-2.1.2-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "435484d7a964743c814dbeb96620c73f", + "name": "lz4", + "sha256": "626af23dc95c54b3f8ad1551b8e9e2600621310c914fef38e1d8317cbc46658e", + "size": 38591, + "subdir": "linux-64", + "timestamp": 1541436368656, + "version": "2.1.2" + }, + "lz4-2.1.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0d0746b718a24289e617786b76b85a88", + "name": "lz4", + "sha256": "b27412372e28ef62021b5d564ca43e2b83faac96626d815dcb30f7b9925be3b3", + "size": 39062, + "subdir": "linux-64", + "timestamp": 1541436353153, + "version": "2.1.2" + }, + "lz4-2.1.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a4cf4a01bc3332aa45cf1918bc652e11", + "name": "lz4", + "sha256": "d69adb41d2ed3a91d77b2c44ea7162ea1185104d0bb2a60514b16e1e988c7e6d", + "size": 39012, + "subdir": "linux-64", + "timestamp": 1541436332254, + "version": "2.1.2" + }, + "lz4-2.1.6-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2aed95ea0dfe186aade39c6a0978d456", + "name": "lz4", + "sha256": "55fbd9503572ea00b9db71bf220600b8d888ecc5360cf42fde20c1df54bff175", + "size": 39694, + "subdir": "linux-64", + "timestamp": 1547236710378, + "version": "2.1.6" + }, + "lz4-2.1.6-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6a6d3fd5eb312cb4cac94ab667228c87", + "name": "lz4", + "sha256": "6335e3c80e778e1fc5cba4a38a227a1871981910f81efe110f80c87e2c93d4de", + "size": 40222, + "subdir": "linux-64", + "timestamp": 1547236726127, + "version": "2.1.6" + }, + "lz4-2.1.6-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4c5f1a7144be8ae17c6d10824962408f", + "name": "lz4", + "sha256": "f5e1fecfeb7436b26843067dd461d5cccba915be6bcfd769032e2527331fcde1", + "size": 40212, + "subdir": "linux-64", + "timestamp": 1547236677523, + "version": "2.1.6" + }, + "lz4-2.1.9-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2e2b37f647cee3d3ad0000c711ef9222", + "name": "lz4", + "sha256": "ebf72fddfd7450a65b25071c5e7390df7c1e677d51a5ba48df7cf80a4bf86cf6", + "size": 39935, + "subdir": "linux-64", + "timestamp": 1559920132291, + "version": "2.1.9" + }, + "lz4-2.1.9-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2bfad72a5fc6b0951501f31fa547c0ca", + "name": "lz4", + "sha256": "4635f0789f7c279b8a701ff98f05ec767a7d7faf8428da40c1c1bc5b4711139f", + "size": 40319, + "subdir": "linux-64", + "timestamp": 1559920145812, + "version": "2.1.9" + }, + "lz4-2.1.9-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "30ca16f73923ab82fb19664b47da66ac", + "name": "lz4", + "sha256": "59c0a73b527b4f452e16c9ada5c09ec899c4c62e7b6ba79de890b3cc71aca7d5", + "size": 40350, + "subdir": "linux-64", + "timestamp": 1559920127749, + "version": "2.1.9" + }, + "lz4-2.2.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "788a12f9c2d6d55a42ec6dd698017e57", + "name": "lz4", + "sha256": "1a8eda0b231831c955129d7a25b88bd910f45ed8e9f303581bcb94d56667ffba", + "size": 41262, + "subdir": "linux-64", + "timestamp": 1569356777893, + "version": "2.2.1" + }, + "lz4-2.2.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4d5881704fe872f523eaea3909d91e5f", + "name": "lz4", + "sha256": "bdd2645e23ad300ab0be22e6f91cb87524bf86a4d31f0f702163677d931ac31e", + "size": 41708, + "subdir": "linux-64", + "timestamp": 1569356780334, + "version": "2.2.1" + }, + "lz4-2.2.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "04310028aa796f53c6c49a2d600b497a", + "name": "lz4", + "sha256": "d0662ac261ef9c97c755e7922ea15fb1a5591733b8d3bf414039bd9aa6cd933d", + "size": 41743, + "subdir": "linux-64", + "timestamp": 1569356782185, + "version": "2.2.1" + }, + "lz4-2.2.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4004e4b5124a5f087455ff8bdaaf46bc", + "name": "lz4", + "sha256": "0f059bae846f462e1e4360c72fc062d4675af2c0e464486593b3f8c03123af10", + "size": 46553, + "subdir": "linux-64", + "timestamp": 1573638867595, + "version": "2.2.1" + }, + "lz4-3.1.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aa271fbcea1082d33ce1305e920456c4", + "name": "lz4", + "sha256": "faf1918331a7a9dab0eb3ecfc6c7c6c6794e4e36eb7ba8c5cec4c385322e01b7", + "size": 49213, + "subdir": "linux-64", + "timestamp": 1613042036484, + "version": "3.1.0" + }, + "lz4-3.1.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fae65d9e58e5132ef9679fc01a542279", + "name": "lz4", + "sha256": "cd84d65707fd3b37ffe4565018d880c70ddc5fb11b0802db1d1b0b32a9bc7f9f", + "size": 48924, + "subdir": "linux-64", + "timestamp": 1595342417404, + "version": "3.1.0" + }, + "lz4-3.1.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3fb5ca2dba7c07a56a416b84853863d7", + "name": "lz4", + "sha256": "6ba37e00d61704f9daf99c4380c55ea8dfedb3e94085024d9cec611810b55737", + "size": 49209, + "subdir": "linux-64", + "timestamp": 1613042438804, + "version": "3.1.0" + }, + "lz4-3.1.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b9742f5908d209d528b9fd80d35bfe85", + "name": "lz4", + "sha256": "ceb9dc4a0d8dcdeb26d0dae72db298e7d25a5f8c663602b1d5dfb9366426f2a4", + "size": 48948, + "subdir": "linux-64", + "timestamp": 1595342415756, + "version": "3.1.0" + }, + "lz4-3.1.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1c9018880d381cc69f40be1c52a9282c", + "name": "lz4", + "sha256": "c4032b1c8c6edc77f469d5efe4858e222c571f80cb0031830c5cb307aa106fef", + "size": 49502, + "subdir": "linux-64", + "timestamp": 1613041622885, + "version": "3.1.0" + }, + "lz4-3.1.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d253b35cd888cbbcfa176030b6e2b50f", + "name": "lz4", + "sha256": "0b63041235adf2dfb2977b5f9cc7b0b8deb5aaae11069587d2fda13c9e70d55e", + "size": 49173, + "subdir": "linux-64", + "timestamp": 1595342415739, + "version": "3.1.0" + }, + "lz4-3.1.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "95fe7c9120f5fb38537c567ca542bacc", + "name": "lz4", + "sha256": "35232124e9b4a33a23bc17c17eb848366715c2b6409d053eda584cf56d996483", + "size": 49485, + "subdir": "linux-64", + "timestamp": 1613042264749, + "version": "3.1.0" + }, + "lz4-3.1.3-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dc33b662f9bb2a6a923b5da2f76e9a16", + "name": "lz4", + "sha256": "4dcd66e800a331fc491e129428a0b621a393968da16e2532bafce85c66eea215", + "size": 98832, + "subdir": "linux-64", + "timestamp": 1640887669052, + "version": "3.1.3" + }, + "lz4-3.1.3-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "lz4-c >=1.9.4,<1.10.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ea88db203eb273b4746844723c47e898", + "name": "lz4", + "sha256": "a6f89fb58521f907cd7d037a5aea6d425cc971bf2b5d478fd43ffc1ca167d8ca", + "size": 48538, + "subdir": "linux-64", + "timestamp": 1676919153235, + "version": "3.1.3" + }, + "lz4-3.1.3-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a6969b6f31a0072a93260208777a6dfe", + "name": "lz4", + "sha256": "4c78f2aca86764e49a7e0916408e7a98f0253eee9908014a4157a13439b73eff", + "size": 45434, + "subdir": "linux-64", + "timestamp": 1619516554661, + "version": "3.1.3" + }, + "lz4-3.1.3-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "062463cda21e16e8d0d85c490752e869", + "name": "lz4", + "sha256": "00caaeb1337804643fff19380fddc059b6236d4442f2fd2bdb46d5393d2aebcc", + "size": 45392, + "subdir": "linux-64", + "timestamp": 1619516546962, + "version": "3.1.3" + }, + "lz4-3.1.3-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3cdac38c7ab5b4ce5062c1234346cdd9", + "name": "lz4", + "sha256": "f415933fdd48ed34f94196d62d8ce9f23b1d55858ad0e4d79a9ee6d6666db5ee", + "size": 45610, + "subdir": "linux-64", + "timestamp": 1619516566078, + "version": "3.1.3" + }, + "lz4-3.1.3-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1a36bd211c5f4e79989bcfacd2af73a8", + "name": "lz4", + "sha256": "a9206c437ec64caf71c814229979af0ce916146e96a44f863631a76fd7efd629", + "size": 45642, + "subdir": "linux-64", + "timestamp": 1619516561285, + "version": "3.1.3" + }, + "lz4-c-1.8.0-h2d24295_0.tar.bz2": { + "build": "h2d24295_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "BSD 2-clause", + "md5": "111a0b89e1d8a3872acdd1e9c5eed19d", + "name": "lz4-c", + "sha256": "e370ee2ac2020af27c2a64271e23512ac5a9ad4d381d45d6c515557c386a54f9", + "size": 159790, + "subdir": "linux-64", + "timestamp": 1510141889060, + "version": "1.8.0" + }, + "lz4-c-1.8.1.2-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "BSD 2-clause", + "md5": "b199291ab9eaee14cd04199c3f0ba246", + "name": "lz4-c", + "sha256": "52278bcc0ccf6dc96bd88a60f4eba1c939a3b52010e734313467bd798c03c3a3", + "size": 161619, + "subdir": "linux-64", + "timestamp": 1524590233890, + "version": "1.8.1.2" + }, + "lz4-c-1.9.2-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "md5": "ce1f7419298b5e8fdc1813d4506c5226", + "name": "lz4-c", + "sha256": "20d55da6eaff1a29d128eff3d5a66d7b73b6e4dab50c28f813993b677e970972", + "size": 241026, + "subdir": "linux-64", + "timestamp": 1587011750239, + "version": "1.9.2" + }, + "lz4-c-1.9.2-he6710b0_1.tar.bz2": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "md5": "eee2fbfb70da6448f48e54549c8f5d5a", + "name": "lz4-c", + "sha256": "62608a7668637f9072138cb75fc043d6f8e8fe02376a4b17ce7014ad13aa0fa2", + "size": 258589, + "subdir": "linux-64", + "timestamp": 1595960707865, + "version": "1.9.2" + }, + "lz4-c-1.9.2-heb0550a_3.tar.bz2": { + "build": "heb0550a_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "md5": "aa4530a7cc15d93866b196ae0ae38722", + "name": "lz4-c", + "sha256": "ab6ca1a9b6011ca6866ab4177353756b4b225d173cef1a8c36adfcb29f929a6a", + "size": 208313, + "subdir": "linux-64", + "timestamp": 1601566162695, + "version": "1.9.2" + }, + "lz4-c-1.9.3-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "md5": "994cdae3509f9fa875c5c93cf4a18acb", + "name": "lz4-c", + "sha256": "3f2de04460ed2cbc76bf64a11aa1223f5b2291920790ab6184228391b640a21d", + "size": 221332, + "subdir": "linux-64", + "timestamp": 1611255479227, + "version": "1.9.3" + }, + "lz4-c-1.9.3-h295c915_1.tar.bz2": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f35d4bf2fbb39e334992f6dd39f8721e", + "name": "lz4-c", + "sha256": "2c6a5dda7c510a961bc78e31d4232be5e8e0760c93454f5fd200c379355e0f5e", + "size": 220865, + "subdir": "linux-64", + "timestamp": 1627657046002, + "version": "1.9.3" + }, + "lz4-c-1.9.4-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f24adbfdfe16b0bac0d14640bb5ce616", + "name": "lz4-c", + "sha256": "36b23ab8d8aa22d70a2f733462cabe95e5b27ca919ec7a75a5592bc39c5f7d16", + "size": 163649, + "subdir": "linux-64", + "timestamp": 1670944701605, + "version": "1.9.4" + }, + "lz4-c-static-1.9.2-3.tar.bz2": { + "build": "3", + "build_number": 3, + "depends": [], + "license": "BSD-2-Clause", + "md5": "5a6595efe6d5d5b20a4fc455b652ba58", + "name": "lz4-c-static", + "sha256": "6c6496dc0c0112861b5b56acada99b642e55efe5903b8d901c515bf3f1553222", + "size": 109756, + "subdir": "linux-64", + "timestamp": 1601566165831, + "version": "1.9.2" + }, + "lz4-c-static-1.9.3-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "BSD-2-Clause", + "md5": "fdeda82f156a7402fc665a21cc2cb962", + "name": "lz4-c-static", + "sha256": "c341ab2579065ecd76b2900b749ffe28333ef6f80db9ff8a2fb285a6df284a02", + "size": 121089, + "subdir": "linux-64", + "timestamp": 1611255482435, + "version": "1.9.3" + }, + "lz4-c-static-1.9.3-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "88a75d5bcf0f47bc1ca42a10ee44b48e", + "name": "lz4-c-static", + "sha256": "b4df215cb20a418e11d83405bb9c9d39f4c410ed6fccc57620a24f013c8b7e7d", + "size": 121710, + "subdir": "linux-64", + "timestamp": 1627657048924, + "version": "1.9.3" + }, + "lz4-c-static-1.9.4-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "2f3f93af5d96832a7822951bfd9511af", + "name": "lz4-c-static", + "sha256": "355448c006af76f26285f0e67c3cde75a561109003827012c99416c2838da3c6", + "size": 88888, + "subdir": "linux-64", + "timestamp": 1670944704518, + "version": "1.9.4" + }, + "lzo-2.10-h1bfc0ba_1.tar.bz2": { + "build": "h1bfc0ba_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL v2+", + "license_family": "GPL2", + "md5": "eff8fe3234f94b69ba25094991e52c63", + "name": "lzo", + "sha256": "e7d30faf3238faa810c5fc84a5ef48bdd8860ab00794da2a37c3bb1d36961444", + "size": 321103, + "subdir": "linux-64", + "timestamp": 1506561066267, + "version": "2.10" + }, + "lzo-2.10-h49e0be7_2.tar.bz2": { + "build": "h49e0be7_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL v2+", + "license_family": "GPL2", + "md5": "2e4ca3890ae250e87e130af71dcbc288", + "name": "lzo", + "sha256": "15ea1bd039d66ae4c57cc6fccabe5107c929ed3891142fa700679253be958221", + "size": 320789, + "subdir": "linux-64", + "timestamp": 1511294307364, + "version": "2.10" + }, + "lzo-2.10-h7b6447c_2.tar.bz2": { + "build": "h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL v2+", + "license_family": "GPL2", + "md5": "2c4fe397d387680272e4ecbf604cd9e8", + "name": "lzo", + "sha256": "31ed5d7c25be1400fe94ec354f791831fcdf77b8e1373f259616a7c9bead7db0", + "size": 324679, + "subdir": "linux-64", + "timestamp": 1587075113981, + "version": "2.10" + }, + "lzo-2.10-hc0eb8fc_0.tar.bz2": { + "build": "hc0eb8fc_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL v2+", + "license_family": "GPL2", + "md5": "3830e0561320d3edcbcf755f88d866b6", + "name": "lzo", + "sha256": "c9746adf0fbf8aae96f5aefada3526b9298d4fd6b1ba88ba18ce1a9322dd623a", + "size": 319856, + "subdir": "linux-64", + "timestamp": 1505729180342, + "version": "2.10" + }, + "m4-1.4.18-h4e445db_0.tar.bz2": { + "build": "h4e445db_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-3.0", + "md5": "253f8bd138aaeb6220ee2c4e4caf3ff3", + "name": "m4", + "sha256": "f65d0466bbae3afe8b437b9e9887abb942a2a59ac5361d2387798e0f65b9bbee", + "size": 180509, + "subdir": "linux-64", + "timestamp": 1505665975958, + "version": "1.4.18" + }, + "macholib-1.16.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "altgraph >=0.17", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "25be3e4d2d9ba69c6449c31e64d4437f", + "name": "macholib", + "sha256": "4a205209703d21adee33e5e54d49eece0c0b3f493d85cecfd9d3c7785f903e11", + "size": 69731, + "subdir": "linux-64", + "timestamp": 1670513278249, + "version": "1.16.2" + }, + "macholib-1.16.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "altgraph >=0.17", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ce8abc3c5c417b13b64d9cec80f09fc", + "name": "macholib", + "sha256": "22fee2a450b1b8d477d4940f18a97f9e1950fb5580f8a6b3908340e9391e0c4e", + "size": 91072, + "subdir": "linux-64", + "timestamp": 1676858572371, + "version": "1.16.2" + }, + "macholib-1.16.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "altgraph >=0.17", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0dec8dc5a98aa4d7fc62838b06882e6a", + "name": "macholib", + "sha256": "a6ac3e76cd15998b3efa51b6b47007be87bb2a4de3460d988e6abe7a726ab3d5", + "size": 68583, + "subdir": "linux-64", + "timestamp": 1670513303510, + "version": "1.16.2" + }, + "macholib-1.16.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "altgraph >=0.17", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3db1ee8d4fcc20c093c4ce42669f3a36", + "name": "macholib", + "sha256": "8164bcf59517c53b72e36cd3ae4c8344c615cd7f34791c8f141ead10ee659a76", + "size": 68807, + "subdir": "linux-64", + "timestamp": 1670513353580, + "version": "1.16.2" + }, + "macholib-1.16.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "altgraph >=0.17", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4663d4ad9fb651c52e262af2bd526a20", + "name": "macholib", + "sha256": "34e4ada1549d401142a172312949dc5195459b6da2b4f8915199ce7b367c2325", + "size": 68714, + "subdir": "linux-64", + "timestamp": 1670513328733, + "version": "1.16.2" + }, + "magma-2.3.0-h51060c3_0.tar.bz2": { + "build": "h51060c3_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=8.0,<8.1.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "39acc20a16e75d3ae2d53666756af77d", + "name": "magma", + "sha256": "202ea9d0d62b706c3d92a479954182d08d26d3fdf0b26c78fc9756a016e3c3cc", + "size": 48966165, + "subdir": "linux-64", + "timestamp": 1550812835675, + "version": "2.3.0" + }, + "magma-2.3.0-h87a4715_0.tar.bz2": { + "build": "h87a4715_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dd81fdf0d3bbd85d5a1691836c18f599", + "name": "magma", + "sha256": "3ac704d170a40fa5544e164495c31f8aac1cc3d3a1da2ea43b48f2b219bd1b32", + "size": 59761972, + "subdir": "linux-64", + "timestamp": 1525909788890, + "version": "2.3.0" + }, + "magma-2.4.0-h8005fc1_0.tar.bz2": { + "build": "h8005fc1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6938c9f3d0aaffebe528a4e51841d0e2", + "name": "magma", + "sha256": "2538a8d25288b2fb7200dba1dc57964b2a03e0814c08215a9a3d12bcd3f875ed", + "size": 55073042, + "subdir": "linux-64", + "timestamp": 1550847054324, + "version": "2.4.0" + }, + "magma-2.5.0-h6edc907_0.tar.bz2": { + "build": "h6edc907_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ddb3f13ce69992f014261c258b869a51", + "name": "magma", + "sha256": "8eb77b396f2afbd980110b6ee1ac1e79d02388677f24a2e6383fd9e8cd5370ab", + "size": 60817710, + "subdir": "linux-64", + "timestamp": 1550780629067, + "version": "2.5.0" + }, + "magma-2.5.0-h72d0ac2_0.tar.bz2": { + "build": "h72d0ac2_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.1.243,<10.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "312729d9e56a132cbd32bd8e25d9be78", + "name": "magma", + "sha256": "414e4d8ac3d5fc6e8d360be710eb260ac2aaea1521eace5bdec2bf2e50936d10", + "size": 57232079, + "subdir": "linux-64", + "timestamp": 1584542237441, + "version": "2.5.0" + }, + "magma-2.5.0-h72fc40a_0.tar.bz2": { + "build": "h72fc40a_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "460b3bd9a5ff51a24a248ccfa4eeda63", + "name": "magma", + "sha256": "672fbd8df67f5a2ae776634678f19a4e9e063bec2ebd9bb180264c2df38528f4", + "size": 57610757, + "subdir": "linux-64", + "timestamp": 1550793558277, + "version": "2.5.0" + }, + "magma-2.5.0-hc5c8b49_0.tar.bz2": { + "build": "hc5c8b49_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.2.89,<10.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4b1db5b0f96073ff5af2a50b7777e635", + "name": "magma", + "sha256": "5372c21023e5276211012641d52ee7b0b2a7677834565c538bb317d3830bda39", + "size": 59357374, + "subdir": "linux-64", + "timestamp": 1594610648591, + "version": "2.5.0" + }, + "magma-2.7.0-h8db6258_0.tar.bz2": { + "build": "h8db6258_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=11.3.1,<11.4.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1499d5ee8d503d9e41128b3466fca4e5", + "name": "magma", + "sha256": "d390e54d79ac187909adcddde37860ff48e0bee6f830f9bf2a05a66e1f5b98f9", + "size": 131026731, + "subdir": "linux-64", + "timestamp": 1671636138247, + "version": "2.7.0" + }, + "make-4.2.1-h1bed415_1.tar.bz2": { + "build": "h1bed415_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPLv3", + "md5": "274e1eb00ae0a8c18557a5ce7e015e1b", + "name": "make", + "sha256": "264735f402c922f9a9a10111bf21323ebee668af5671041f4175d77e98cb3842", + "size": 439087, + "subdir": "linux-64", + "timestamp": 1522868610272, + "version": "4.2.1" + }, + "make-4.2.1-h3d8f0fa_0.tar.bz2": { + "build": "h3d8f0fa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPLv3", + "md5": "681b386eea2d3450b5882bbcca3b9a37", + "name": "make", + "sha256": "6ce5fba7d1f57ab3c2a6e6d1738f377e041fedbde28bb7cb01e229cb63507fda", + "size": 438932, + "subdir": "linux-64", + "timestamp": 1507907563144, + "version": "4.2.1" + }, + "mako-1.0.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b644d6b868797645794c75c570eed7d1", + "name": "mako", + "sha256": "c6f99413ee7167ca8695938d1c4ee9cdef0e0d91c499292d53a60dbbd143096f", + "size": 115403, + "subdir": "linux-64", + "timestamp": 1530737030980, + "version": "1.0.7" + }, + "mako-1.0.7-py27h3d58d4b_0.tar.bz2": { + "build": "py27h3d58d4b_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "39d25e3905bf34eeabb81c4c837a32d2", + "name": "mako", + "sha256": "90c35c454292fcbb405e37cf4c682cbdab5b66376c9ae9a3442f082c81ab5a61", + "size": 115134, + "subdir": "linux-64", + "timestamp": 1505691393022, + "version": "1.0.7" + }, + "mako-1.0.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "8274e59b2b7c32ba348e4ea40d1516fa", + "name": "mako", + "sha256": "5c7d5a706fd9077094e0d68b92eed55197e0b654c60b7dbbb3a56e5caec1fd0c", + "size": 118975, + "subdir": "linux-64", + "timestamp": 1534352616211, + "version": "1.0.7" + }, + "mako-1.0.7-py35h69899ea_0.tar.bz2": { + "build": "py35h69899ea_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "3a1872709d71a4f47d795f09d74bc4be", + "name": "mako", + "sha256": "162e72e6562bf1c2435d26ecd3ca3dd9adc658ea72261208a72e80ee94c9619e", + "size": 118761, + "subdir": "linux-64", + "timestamp": 1505691405805, + "version": "1.0.7" + }, + "mako-1.0.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "00418f69deaacfea43b8513e1e1210ad", + "name": "mako", + "sha256": "4e949dc9aeeb798af3b9f829ef3b4df3f44c08923f10fe8ea5e33be034108ce3", + "size": 118584, + "subdir": "linux-64", + "timestamp": 1530737008939, + "version": "1.0.7" + }, + "mako-1.0.7-py36h0727276_0.tar.bz2": { + "build": "py36h0727276_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "38c73af2decf7395fc837588816dee3c", + "name": "mako", + "sha256": "d7f5ae70dc76630c6a7f4a43d6ea7130b01113b8cde9c5e010830689cf01533f", + "size": 118446, + "subdir": "linux-64", + "timestamp": 1505691418723, + "version": "1.0.7" + }, + "mako-1.0.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4902065c45f4b66a8d009973476b25ad", + "name": "mako", + "sha256": "8a8a87071994f58158f8dd65ca1819d75362af5603d1d74dc7f9b3d65ee33bd9", + "size": 118667, + "subdir": "linux-64", + "timestamp": 1530737053909, + "version": "1.0.7" + }, + "mako-1.0.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b8e58c1741c770847ea349785e54698c", + "name": "mako", + "sha256": "9c24005d7029c3bc262d88c53605e5b3223de256fc6120f839904738261ca775", + "size": 119040, + "subdir": "linux-64", + "timestamp": 1556068119593, + "version": "1.0.9" + }, + "mako-1.0.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8b70291ce12eef6e255fdcb319f63b72", + "name": "mako", + "sha256": "5f2f95b21fedeaef1271902852d05d4d1e8f8bd47012a8b210d063a205b31bb1", + "size": 122079, + "subdir": "linux-64", + "timestamp": 1556068271361, + "version": "1.0.9" + }, + "mako-1.0.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d7db0777730944958df386e93489a82d", + "name": "mako", + "sha256": "8ad0ff5bfb580c74970b853532a426e8fad07d590a9837e09ccad3d5abd918f6", + "size": 122026, + "subdir": "linux-64", + "timestamp": 1556068117800, + "version": "1.0.9" + }, + "mako-1.2.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "32dbfdeac432597b49e31713ff01a92f", + "name": "mako", + "sha256": "9a5341d7c16268941f8e239e6edf94d14f4de1fbe1b5d0a680647348cd1e4320", + "size": 126080, + "subdir": "linux-64", + "timestamp": 1665472499825, + "version": "1.2.3" + }, + "mako-1.2.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "41c53e36833c7c34eb11c5e35c0d8155", + "name": "mako", + "sha256": "961268a8a1d940e9abacbf22900b13996ee3f8b745b6475a9b2444642e1db2b1", + "size": 166419, + "subdir": "linux-64", + "timestamp": 1676827963723, + "version": "1.2.3" + }, + "mako-1.2.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "markupsafe >=0.9.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4399d4d963aa02b08a3bc8563ea5914a", + "name": "mako", + "sha256": "bef0de681dd72fc36e834ad8072334267ece4cee920960adc7410cfed0ec6906", + "size": 123714, + "subdir": "linux-64", + "timestamp": 1665472449780, + "version": "1.2.3" + }, + "mako-1.2.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1da65bea283a7dde8055f4edb21468ac", + "name": "mako", + "sha256": "53b8c9e25e91ea77a6ed9ce35fe4c5523158f5fca4caa135e3833bda59e168dd", + "size": 124693, + "subdir": "linux-64", + "timestamp": 1665472474847, + "version": "1.2.3" + }, + "mako-1.2.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37818afb98bbedac4d69b12abe59c901", + "name": "mako", + "sha256": "011e049044b55d36917b1af13f132c3e1337b0c785cfd52edc4ffe310857a4d8", + "size": 124746, + "subdir": "linux-64", + "timestamp": 1665472524097, + "version": "1.2.3" + }, + "mapclassify-2.5.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "networkx", + "numpy >=1.3", + "pandas >=1.0", + "python >=3.10,<3.11.0a0", + "scikit-learn", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a4d65cd09e217d4365c5d4b9918e985", + "name": "mapclassify", + "sha256": "03b225077d863514f9f25ad953521f596319fe6f19036bfc37e28ffac3550587", + "size": 66140, + "subdir": "linux-64", + "timestamp": 1675157763842, + "version": "2.5.0" + }, + "mapclassify-2.5.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "networkx", + "numpy >=1.3", + "pandas >=1.0", + "python >=3.11,<3.12.0a0", + "scikit-learn", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2d15555f9810fbccd1cf3c8131a97f16", + "name": "mapclassify", + "sha256": "e4978f900634c42d71203b95c093062d05f068d381915f8173e5bc8e03d70748", + "size": 83254, + "subdir": "linux-64", + "timestamp": 1676858588658, + "version": "2.5.0" + }, + "mapclassify-2.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "networkx", + "numpy >=1.3", + "pandas >=1.0", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d419995013e0ac81bd88a370102edeed", + "name": "mapclassify", + "sha256": "5da141bfe8ca42e7a90914205d7df33058e23edb83f4b49465e4197c744d64c8", + "size": 65945, + "subdir": "linux-64", + "timestamp": 1675157805003, + "version": "2.5.0" + }, + "mapclassify-2.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "networkx", + "numpy >=1.3", + "pandas >=1.0", + "python >=3.9,<3.10.0a0", + "scikit-learn", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f9f7c78639452ecdcad523c7edaaaf97", + "name": "mapclassify", + "sha256": "56c76dd02bf393891e9a4808d59cde3f97a020af739854e6e30828067ff887a4", + "size": 65888, + "subdir": "linux-64", + "timestamp": 1675157845451, + "version": "2.5.0" + }, + "markdown-2.6.11-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bcd71b0a180aa8488143906f10939e7c", + "name": "markdown", + "sha256": "b6665e498a16824d329f4072d56641023646dc21d0ef1bdb0253e4656af7cc60", + "size": 104323, + "subdir": "linux-64", + "timestamp": 1519752448484, + "version": "2.6.11" + }, + "markdown-2.6.11-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aa252dfe224fa14f8d1702dbc76e5df8", + "name": "markdown", + "sha256": "260aa12eaef0e94bab0903806387f6764956a585c7d1cef34d42275be911b47b", + "size": 106711, + "subdir": "linux-64", + "timestamp": 1519752475271, + "version": "2.6.11" + }, + "markdown-2.6.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9ca5fa2a224f6ad7883cf6d5d4b02f34", + "name": "markdown", + "sha256": "0a8677e35d8412f73ab4af3ac78e2ac0bf71fc226ce0b2e46406a31d501a1e39", + "size": 106077, + "subdir": "linux-64", + "timestamp": 1519752435153, + "version": "2.6.11" + }, + "markdown-2.6.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d0c69e5bf2619104b49bcb2cbdb15110", + "name": "markdown", + "sha256": "475a9b5350506818aefea4a2d91805f37073fe52aa0e5cf6ca5194bf49f6bc14", + "size": 106037, + "subdir": "linux-64", + "timestamp": 1530899102878, + "version": "2.6.11" + }, + "markdown-3.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e4e13eabcb38bfdd2364504452929391", + "name": "markdown", + "sha256": "78bae73912e34251fd802b2835a9491baa422b87c49701cef5481445efff486c", + "size": 107979, + "subdir": "linux-64", + "timestamp": 1539712093409, + "version": "3.0.1" + }, + "markdown-3.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "142b016510c2c4708607e66b048a3f2a", + "name": "markdown", + "sha256": "6855bef83294a6c8207689998890ec055082a5bc0eccca3176e5de987dab3095", + "size": 109644, + "subdir": "linux-64", + "timestamp": 1539712107971, + "version": "3.0.1" + }, + "markdown-3.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d6f2471991eb0fe46ff22002e71704e9", + "name": "markdown", + "sha256": "49565b8b782830e4b984e0e86b6748716b16890e9caa81698ce84958037684eb", + "size": 109706, + "subdir": "linux-64", + "timestamp": 1539712099840, + "version": "3.0.1" + }, + "markdown-3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4fd0498f959bf79afa896aea9641b40e", + "name": "markdown", + "sha256": "b766dc4a1f34c8964e01e82e73d6639f55585e32403cf32862e8c52446b289f3", + "size": 113726, + "subdir": "linux-64", + "timestamp": 1556068795863, + "version": "3.1" + }, + "markdown-3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3e1173cfa3b3467fd137b984a65b0d3c", + "name": "markdown", + "sha256": "26e0358a311f3dc79d1c9254972eda70132917e5e97c4438ff62418f78924e6e", + "size": 115492, + "subdir": "linux-64", + "timestamp": 1556068836935, + "version": "3.1" + }, + "markdown-3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "29647fb498536f622ee1deb63adb0da4", + "name": "markdown", + "sha256": "218bebe1963f26d10919d7b94fa8b59261ef78fcae66c755ecb8395a58b96bc7", + "size": 115451, + "subdir": "linux-64", + "timestamp": 1556078766720, + "version": "3.1" + }, + "markdown-3.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8fc05ad603845dfa63be8979f3fe7811", + "name": "markdown", + "sha256": "f31975acb4e165edfe97e639b0ee680bcbba287e24ce75c472e6911bdee634d1", + "size": 114332, + "subdir": "linux-64", + "timestamp": 1559920467671, + "version": "3.1.1" + }, + "markdown-3.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1b0409ddea3c0d8b59e739d844935891", + "name": "markdown", + "sha256": "f5dbccc759a9860455a6da1db8516eb7169f856998957c23528fd72313f45475", + "size": 115770, + "subdir": "linux-64", + "timestamp": 1559920488852, + "version": "3.1.1" + }, + "markdown-3.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "515d826d2ead6ad6c3ad9b2d81f1da62", + "name": "markdown", + "sha256": "4e755aa3a5b290eebbb99025f2b8f0a91f7e61bb017d00e5e9113d5f988b427f", + "size": 115768, + "subdir": "linux-64", + "timestamp": 1559920465005, + "version": "3.1.1" + }, + "markdown-3.1.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f20d62803d3a8aade8281609288b59a5", + "name": "markdown", + "sha256": "bb40ca1c576d52c1d72be7e3e3416b7319231242bd01c1f5187b3a3ebed4c41a", + "size": 115451, + "subdir": "linux-64", + "timestamp": 1573489006550, + "version": "3.1.1" + }, + "markdown-3.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "67e1887fbb03e26220153b712b91b651", + "name": "markdown", + "sha256": "aed252358934c6feb62aaa7ed9660b3beda559d1d8b9c8632c360af9725158af", + "size": 118663, + "subdir": "linux-64", + "timestamp": 1597433287012, + "version": "3.2.2" + }, + "markdown-3.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ea13db85c926b42390946e77010650fd", + "name": "markdown", + "sha256": "8dbb7aed28e73ef730ee1e91feff99984748d1fc4d68f301045ad802e7cb8cef", + "size": 118635, + "subdir": "linux-64", + "timestamp": 1597433295908, + "version": "3.2.2" + }, + "markdown-3.2.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "399ebcf8a965c32544bfc2475cc83031", + "name": "markdown", + "sha256": "a1932b58a9a6e30aa8b6a64f3bbcd1618ee56c7d08c0becf9fa3b6eb0b75da3f", + "size": 118790, + "subdir": "linux-64", + "timestamp": 1597433270579, + "version": "3.2.2" + }, + "markdown-3.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4f69fb0915e3cd2780638ba41e458301", + "name": "markdown", + "sha256": "a9613f40606a6ef35885d5fcb4d263534bdb39574d7d27c2f688b089a2ee0901", + "size": 123684, + "subdir": "linux-64", + "timestamp": 1602086994231, + "version": "3.3" + }, + "markdown-3.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b713d17154184eb7c5c7c9a874616cf3", + "name": "markdown", + "sha256": "d5b3e71618596516bacfcb7c0301b8250de9a2cb30031cd37d0978200641209f", + "size": 123683, + "subdir": "linux-64", + "timestamp": 1602086973507, + "version": "3.3" + }, + "markdown-3.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8669882de78c8289c46269ef0eb9d6e5", + "name": "markdown", + "sha256": "fced34ecc7d135f0d0e60ba96372340a0372f053df135ab40169e285aa093ce9", + "size": 123924, + "subdir": "linux-64", + "timestamp": 1602086998680, + "version": "3.3" + }, + "markdown-3.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1f3a93afcf6ef8f338fc277f559a8acf", + "name": "markdown", + "sha256": "e04a12c259abc4e92c2b1c5d275e2aa436f174025373456b87de0dfd59d1fc63", + "size": 125020, + "subdir": "linux-64", + "timestamp": 1602689134502, + "version": "3.3.1" + }, + "markdown-3.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "01d2b56c57d095bba479a2fe56a85943", + "name": "markdown", + "sha256": "023fdd8430b56cce5c5b0dae205107a2f445b913751c784f2c04a731de4f6937", + "size": 125057, + "subdir": "linux-64", + "timestamp": 1602689131891, + "version": "3.3.1" + }, + "markdown-3.3.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "746f089c76bf5867d51095f6a769c0e7", + "name": "markdown", + "sha256": "0b3282635beadb36ac9e64727943f2cc7611f0a2c11c2b351218ff9653b05964", + "size": 125181, + "subdir": "linux-64", + "timestamp": 1602689107690, + "version": "3.3.1" + }, + "markdown-3.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6334a8252a84aebae6384d79decd2863", + "name": "markdown", + "sha256": "a6435fcfb9db0e40af009ee9e43cd598af82e6301d37e6f6f9a344be8e6cf249", + "size": 125733, + "subdir": "linux-64", + "timestamp": 1603216488724, + "version": "3.3.2" + }, + "markdown-3.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07403c93d3303e9fe7f43f40fdddd9af", + "name": "markdown", + "sha256": "9189c03a839effa3b36fa0c8faf65901159793070bc951ff3dc79a2da13be794", + "size": 125578, + "subdir": "linux-64", + "timestamp": 1603216520480, + "version": "3.3.2" + }, + "markdown-3.3.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f283b8ad61e970c6111daf8785793233", + "name": "markdown", + "sha256": "a3bf3a1776191e4f63a8eee51f5769782f44b13e8fe80d78e1c202d782bc5c6a", + "size": 125869, + "subdir": "linux-64", + "timestamp": 1603216519132, + "version": "3.3.2" + }, + "markdown-3.3.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d0f3d33bdb3bedaf1ad2ee70c37bdfc9", + "name": "markdown", + "sha256": "88ecc7e42064f319610ea013cfe6897b4cf97d9b5e54ccd6120fb93cb55f1203", + "size": 126163, + "subdir": "linux-64", + "timestamp": 1605111115769, + "version": "3.3.3" + }, + "markdown-3.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "33a55b011450bf703581606b42572fb5", + "name": "markdown", + "sha256": "7d5019fd81dc586e1b9003330917b6a33af3303a582658e233e378445fd6d793", + "size": 126231, + "subdir": "linux-64", + "timestamp": 1605111091711, + "version": "3.3.3" + }, + "markdown-3.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "166239657b53409624f1b27c420a9d81", + "name": "markdown", + "sha256": "08c8ee112c2c3149a77b4ffd617705061d0e621c20e7e7f8f654f1a72e7f650d", + "size": 126449, + "subdir": "linux-64", + "timestamp": 1605111086214, + "version": "3.3.3" + }, + "markdown-3.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ba6e3d0a96c476733823dac4050428b3", + "name": "markdown", + "sha256": "d2dac0359df92341cce6658a4be096b2636c6d0cd8455341bc40f04f9b5de4d9", + "size": 126214, + "subdir": "linux-64", + "timestamp": 1605111122536, + "version": "3.3.3" + }, + "markdown-3.3.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "37a8e1ccb37758ad67af9f43fed1324f", + "name": "markdown", + "sha256": "96c4fd7ab0a953c938354e270af5e4056c803eec5f7f3bfe86e5a52196d3e8a6", + "size": 128449, + "subdir": "linux-64", + "timestamp": 1640791574499, + "version": "3.3.4" + }, + "markdown-3.3.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c9654c6ca722027cb5fe651972fbf9da", + "name": "markdown", + "sha256": "fd51dcf1f9261345f3ced32ee1cccce9be8c263105a47dc1a6812a9f4abfb86e", + "size": 127808, + "subdir": "linux-64", + "timestamp": 1614363873131, + "version": "3.3.4" + }, + "markdown-3.3.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "341a20ae4810903ff64961163d885189", + "name": "markdown", + "sha256": "3713c2e147fb824ba45f4580add9d2e66dfc2e269deb443933f3e726df2f1118", + "size": 127684, + "subdir": "linux-64", + "timestamp": 1614363868576, + "version": "3.3.4" + }, + "markdown-3.3.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2adb9f7a0c1ddbe75456d03c76bd9ac8", + "name": "markdown", + "sha256": "dd75341c078a23c8b2c61d997e8d251533b4fab85261cf700065116d8ac306b1", + "size": 127854, + "subdir": "linux-64", + "timestamp": 1614363564728, + "version": "3.3.4" + }, + "markdown-3.3.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d3811276842570f601a24ea6dc298199", + "name": "markdown", + "sha256": "4f9945fe7e2815ecc6b5c69c226e677560a446fbd5d9b0f847914dbcebe5f0e3", + "size": 127718, + "subdir": "linux-64", + "timestamp": 1614363930304, + "version": "3.3.4" + }, + "markdown-3.4.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "37edf1dc070689d9f64021285157aa25", + "name": "markdown", + "sha256": "93b9aa3ffe66b9ea121fcb1a32a2502006df7073fa29a00ccc00b185b00721ce", + "size": 122987, + "subdir": "linux-64", + "timestamp": 1671541964893, + "version": "3.4.1" + }, + "markdown-3.4.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f5d7ddc69cc6f7d44c80d2251dea5d1", + "name": "markdown", + "sha256": "260e26dd509834c1b225ab7bdb97b9a86e00054fbdd5dfa49e68fa4dcf85a661", + "size": 162339, + "subdir": "linux-64", + "timestamp": 1676837095436, + "version": "3.4.1" + }, + "markdown-3.4.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata >=4.4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cb42f7dd367feff7e30e4be9617e20d2", + "name": "markdown", + "sha256": "2f5cc78499959ac9205f0481695575a1389640cb1cddcfb7a3ae1b6227a54949", + "size": 122335, + "subdir": "linux-64", + "timestamp": 1671542016646, + "version": "3.4.1" + }, + "markdown-3.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata >=4.4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "32d28f2c97744b2e954e30fa485b5c5c", + "name": "markdown", + "sha256": "67fb17f71cf101e66ccb210d8a5c3c10fd6966aaff214034fb6f860ca8d00e7f", + "size": 122380, + "subdir": "linux-64", + "timestamp": 1671541939225, + "version": "3.4.1" + }, + "markdown-3.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata >=4.4", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "421f82c8274b44660dba629134faa6af", + "name": "markdown", + "sha256": "f5d4aae9bb975b3baae421e6bcfdb7fa4f364d89f123ceb73225cf069516e48b", + "size": 122221, + "subdir": "linux-64", + "timestamp": 1671541990505, + "version": "3.4.1" + }, + "markdown-it-py-2.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "mdurl >=0.1,<1", + "python >=3.10,<3.11.0a0", + "typing_extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08517e4f305c7eda07478877217014ce", + "name": "markdown-it-py", + "sha256": "549480b54a409036b0d454c37553877ba87d631581c7137fb99984166344b171", + "size": 106000, + "subdir": "linux-64", + "timestamp": 1659718841133, + "version": "2.1.0" + }, + "markdown-it-py-2.1.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "mdurl >=0.1,<1", + "python >=3.11,<3.12.0a0", + "typing_extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5bf768487734795f3b517d45f9e20f6", + "name": "markdown-it-py", + "sha256": "8b8b175c12d80250aa52be1c5ce9818793690e02644ce00f40a43ff437f090cb", + "size": 134555, + "subdir": "linux-64", + "timestamp": 1676828178187, + "version": "2.1.0" + }, + "markdown-it-py-2.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "mdurl >=0.1,<1", + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa82c12dbe92d53eb7daec9f6f32e2af", + "name": "markdown-it-py", + "sha256": "511c5a242ea20b1bc3245220a51c1a3b27c01b1d4f907d2c90e46d86d345c8d5", + "size": 104871, + "subdir": "linux-64", + "timestamp": 1659718749957, + "version": "2.1.0" + }, + "markdown-it-py-2.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "mdurl >=0.1,<1", + "python >=3.8,<3.9.0a0", + "typing_extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "366cc37c51ba3ce23d254f730c6259b0", + "name": "markdown-it-py", + "sha256": "f91b5b9d1d9c59c4a441ef7fa81821bc51771ad9221ab0e69a4d9ed7da9d2508", + "size": 104986, + "subdir": "linux-64", + "timestamp": 1659718774463, + "version": "2.1.0" + }, + "markdown-it-py-2.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "mdurl >=0.1,<1", + "python >=3.9,<3.10.0a0", + "typing_extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2529d6955dbc19f06eb35e8570610988", + "name": "markdown-it-py", + "sha256": "06937a9ef48df92c4ed9eed6e604d9912883bc6d7cd2d7266e2cffa85056a95b", + "size": 104839, + "subdir": "linux-64", + "timestamp": 1659718803309, + "version": "2.1.0" + }, + "markdown2-2.3.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6cfb3ecbefda8bb8b11f68602c5c621a", + "name": "markdown2", + "sha256": "e18e42c4041081180eeaedd0fa625c90823b7895605f1f20ae55d58f09698faf", + "size": 52393, + "subdir": "linux-64", + "timestamp": 1522811434710, + "version": "2.3.5" + }, + "markdown2-2.3.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "454c33a471117ef3e86a5c067c639b77", + "name": "markdown2", + "sha256": "81aa8874390d5f9def3483add577cdc48eb12c8ecd5181d0fb8ad984027e1422", + "size": 53258, + "subdir": "linux-64", + "timestamp": 1522811438604, + "version": "2.3.5" + }, + "markdown2-2.3.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1368694d9ad03f7c937210a61aa9ba11", + "name": "markdown2", + "sha256": "b248db8da2cb377837ede654f43e771cf888b72163aa8be3f74faec8a5d77f78", + "size": 53052, + "subdir": "linux-64", + "timestamp": 1522811455414, + "version": "2.3.5" + }, + "markdown2-2.3.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af895ab504e77224d60fa09fcabbf998", + "name": "markdown2", + "sha256": "65b9b71400f38a523b20c3d3f706e774244ca5ed309af1894098b22468875742", + "size": 52992, + "subdir": "linux-64", + "timestamp": 1530899131612, + "version": "2.3.5" + }, + "markdown2-2.3.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca5f9e438d2235a18f931ff93041a1bb", + "name": "markdown2", + "sha256": "8f328e3f2c2f22a19a9833ea1a7f593342bf1181708eeaa835525050b7a47ebb", + "size": 53054, + "subdir": "linux-64", + "timestamp": 1539645857482, + "version": "2.3.6" + }, + "markdown2-2.3.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17d808969c277e459cd1fd7b186e090c", + "name": "markdown2", + "sha256": "f4124970d600f9a0dec224a89e4910f1203375c84a0f0a2498c109299868218d", + "size": 53734, + "subdir": "linux-64", + "timestamp": 1539645876776, + "version": "2.3.6" + }, + "markdown2-2.3.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6335cd78f81ee8bfa6cdf4cf0850bc28", + "name": "markdown2", + "sha256": "6638cd2b4c33709b8f48e36d93234dd5a7a88b9a5dde55a3dea21c701e8d5721", + "size": 53742, + "subdir": "linux-64", + "timestamp": 1539645879510, + "version": "2.3.6" + }, + "markdown2-2.3.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4a4126e96f9fcd6e21023bff44ad89e0", + "name": "markdown2", + "sha256": "4c4a09e05644f9a421f3e9a6e9297b48a8025bb43d2ea27ac945e4a7ed40b7e3", + "size": 56176, + "subdir": "linux-64", + "timestamp": 1548003484139, + "version": "2.3.7" + }, + "markdown2-2.3.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ded99d9c2546f310c3d1e7e43903e524", + "name": "markdown2", + "sha256": "f2f54ea90711c71e7a3f7ff0251b7a3f4fc39ccd9ed81173021d941754032364", + "size": 34637, + "subdir": "linux-64", + "timestamp": 1548003517914, + "version": "2.3.7" + }, + "markdown2-2.3.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "91fe737ba86325255b82b0c8baae5bda", + "name": "markdown2", + "sha256": "93e2de22d6ca199f12044ef4e3feab68e44b8bdaf29816085b03366f3d9532e5", + "size": 34590, + "subdir": "linux-64", + "timestamp": 1548003508434, + "version": "2.3.7" + }, + "markupsafe-1.0-py27h14c3975_1.tar.bz2": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3d93620d27849830265e4e0cb16119fa", + "name": "markupsafe", + "sha256": "cb89acc21abbfb2a4c4bed8e48ecfb4f87b4940ea00e38160963d4c0418ac317", + "size": 25012, + "subdir": "linux-64", + "timestamp": 1530695395993, + "version": "1.0" + }, + "markupsafe-1.0-py27h97b2822_1.tar.bz2": { + "build": "py27h97b2822_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4a55b545c9c57034af28be2e62454178", + "name": "markupsafe", + "sha256": "1158ee48c15590af26d533c702b1b71e8775216cd73e7a721596e1f8c98ad7cf", + "size": 24774, + "subdir": "linux-64", + "timestamp": 1505672337096, + "version": "1.0" + }, + "markupsafe-1.0-py35h14c3975_1.tar.bz2": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7ac5dc120f2085d8df68885664998c45", + "name": "markupsafe", + "sha256": "91f2314240280bf1109fc5b19fffe0dc55dc66107c0d1fab8f515eae56e0869f", + "size": 25469, + "subdir": "linux-64", + "timestamp": 1534345501077, + "version": "1.0" + }, + "markupsafe-1.0-py35h4f4fcf6_1.tar.bz2": { + "build": "py35h4f4fcf6_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3f7ca7f2ec71199a7fdf79593891b721", + "name": "markupsafe", + "sha256": "1ae0b6d767a29ecfd57b9fc35e7d40867ff2b85ff08fc1ac66b2657a632fb57c", + "size": 25352, + "subdir": "linux-64", + "timestamp": 1505672351754, + "version": "1.0" + }, + "markupsafe-1.0-py36h14c3975_1.tar.bz2": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "868123437d98348dcc22ea97543a0754", + "name": "markupsafe", + "sha256": "b3b7fd208eb58f78d8623032cc9dc4d0039fa5e40732085bd7b814ea138b758a", + "size": 25072, + "subdir": "linux-64", + "timestamp": 1530695355187, + "version": "1.0" + }, + "markupsafe-1.0-py36hd9260cd_1.tar.bz2": { + "build": "py36hd9260cd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1b720811b3d7ac005156bda76947ef95", + "name": "markupsafe", + "sha256": "682768465a7285ec8d4a0259caa2c41f7139d7f0630bbb18d4cc83af5f06ab3a", + "size": 24944, + "subdir": "linux-64", + "timestamp": 1505672366435, + "version": "1.0" + }, + "markupsafe-1.0-py37h14c3975_1.tar.bz2": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7b9d17c322dd4bdc26535a7b0c28e412", + "name": "markupsafe", + "sha256": "7223c10c98132f6ce9faaf4e4ad38cef540e63312236744b2718d389d6c609c1", + "size": 25100, + "subdir": "linux-64", + "timestamp": 1530695375646, + "version": "1.0" + }, + "markupsafe-1.1.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d45ebc05db54156a13ad5dce4f00257d", + "name": "markupsafe", + "sha256": "52621f145e6bcb0bd1c3b26ff7fba2c933c7ab0b391654c0ecbab59e6280fe4a", + "size": 26209, + "subdir": "linux-64", + "timestamp": 1542378546594, + "version": "1.1.0" + }, + "markupsafe-1.1.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5b10e570e097496e872ccb8d6f3425f0", + "name": "markupsafe", + "sha256": "0b85e5e4da158cfc3a9b395af04cae9666750d980f5279890eba160a6bdf4da9", + "size": 26801, + "subdir": "linux-64", + "timestamp": 1542378580214, + "version": "1.1.0" + }, + "markupsafe-1.1.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0983186b0098862203114130512f7076", + "name": "markupsafe", + "sha256": "25e1c3654534e0f250798e32b0ee377b148a254a38bfd7961c11c43c9075b92a", + "size": 26815, + "subdir": "linux-64", + "timestamp": 1542378536641, + "version": "1.1.0" + }, + "markupsafe-1.1.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f54025c6831e7aab07dd7ac696a5dee4", + "name": "markupsafe", + "sha256": "aa322f77efcf3cb76d0a540b4275cd0986f1d0ebf37c5cc72735e89ff8d77d0e", + "size": 29517, + "subdir": "linux-64", + "timestamp": 1551141837511, + "version": "1.1.1" + }, + "markupsafe-1.1.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f8b525390ff04382908b2e7f94b20ece", + "name": "markupsafe", + "sha256": "dffd203bb0053c6c629311bc25461b9074a35bf9e08692f46577f28cdf672610", + "size": 30067, + "subdir": "linux-64", + "timestamp": 1551141859307, + "version": "1.1.1" + }, + "markupsafe-1.1.1-py37h14c3975_1.tar.bz2": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b77974ca4a22c0a29ad762f13b3cf664", + "name": "markupsafe", + "sha256": "48ac7498185849b255e6ff4635c9f74ec7ae8965e39cd1fb0d9321823ca07945", + "size": 27069, + "subdir": "linux-64", + "timestamp": 1594371535331, + "version": "1.1.1" + }, + "markupsafe-1.1.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bd28bf8a166fb20a1846c7adec17866a", + "name": "markupsafe", + "sha256": "311867ff3cf43d60d39901051fd6a7004618d453b07191b6825e69ac36958027", + "size": 30151, + "subdir": "linux-64", + "timestamp": 1551141822150, + "version": "1.1.1" + }, + "markupsafe-1.1.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "49c211162360afb259473cfb1b51dd89", + "name": "markupsafe", + "sha256": "10b6e0cc94bd8ef39f3e54dbad47f523fec2ea9575e059dda82204010e02905b", + "size": 34532, + "subdir": "linux-64", + "timestamp": 1573489028734, + "version": "1.1.1" + }, + "markupsafe-1.1.1-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a6c61872073a6776dac4788049813d6", + "name": "markupsafe", + "sha256": "bced1a303a31f1dd768778dd7da01ca1ae0d90fb8f86063cce260742655cca88", + "size": 30652, + "subdir": "linux-64", + "timestamp": 1607027347436, + "version": "1.1.1" + }, + "markupsafe-2.0.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85843e903cd6661248b70d225e348b65", + "name": "markupsafe", + "sha256": "b8e80621e37f16ecde8cb413d6c75c1549a4f591303e76e778c49bc1efbf7793", + "size": 25207, + "subdir": "linux-64", + "timestamp": 1620984896292, + "version": "2.0.0" + }, + "markupsafe-2.0.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50d51d57cf18755f1ded3041c881a39e", + "name": "markupsafe", + "sha256": "0d6bed87f0154a8fa022d802081e6b58f198a1343883b13ce13b2c7e453c4f5a", + "size": 25206, + "subdir": "linux-64", + "timestamp": 1620985118273, + "version": "2.0.0" + }, + "markupsafe-2.0.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f5d8362a2b2fe7397b9dfe390976bf40", + "name": "markupsafe", + "sha256": "9bcd4a0b6f9622aafb68a77846cb80121ca686f33ace174c3cd91ac47d035afd", + "size": 25309, + "subdir": "linux-64", + "timestamp": 1620985119631, + "version": "2.0.0" + }, + "markupsafe-2.0.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3c164203b14b64208bad809ecafd49c7", + "name": "markupsafe", + "sha256": "9f19175dab8d25f39423e66d2f26657e6a6a34814c3a21a502b0b9c0d0e79b6f", + "size": 25306, + "subdir": "linux-64", + "timestamp": 1620985124304, + "version": "2.0.0" + }, + "markupsafe-2.0.1-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d17295c6b83a5dc7a5411447018c088c", + "name": "markupsafe", + "sha256": "69a087b2db2afac0b0e6c2b5895a4b9e610ef72545a27d88b0a4a0fbea89e32f", + "size": 37858, + "subdir": "linux-64", + "timestamp": 1640791598404, + "version": "2.0.1" + }, + "markupsafe-2.0.1-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07af9d29144848bdeac4cb8cb5175498", + "name": "markupsafe", + "sha256": "686ac1958a78be2d68958f5339ac48c20814c4285564c6806f85ed05c2a1a0ab", + "size": 22997, + "subdir": "linux-64", + "timestamp": 1621528209086, + "version": "2.0.1" + }, + "markupsafe-2.0.1-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9ef40eaa71af389368ca98ebf8a6c224", + "name": "markupsafe", + "sha256": "7ce8354a8913ced790c5827ed5d9d547ef58fe1287252482d494ec5ffb3773fe", + "size": 22953, + "subdir": "linux-64", + "timestamp": 1621528184683, + "version": "2.0.1" + }, + "markupsafe-2.0.1-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "32d66308493c20bed8ca2a852155b9b9", + "name": "markupsafe", + "sha256": "b6cd835c2ab5bfcdd27a86d56982693cdc40b2e45df42d05e08c83916d4c3e38", + "size": 23062, + "subdir": "linux-64", + "timestamp": 1621528207169, + "version": "2.0.1" + }, + "markupsafe-2.0.1-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d41111388cfceda1904958476da096a1", + "name": "markupsafe", + "sha256": "fe70281280902597f453c539de0391b9794d6272a1310e79e36be224204f2032", + "size": 23039, + "subdir": "linux-64", + "timestamp": 1621523521377, + "version": "2.0.1" + }, + "markupsafe-2.1.1-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "constrains": [ + "jinja2 >=3.0.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d30b31c701efc1ab22fd8f7a1e489978", + "name": "markupsafe", + "sha256": "efd169bd41fbc65ffd85725f6a76db92a343085108cc43b9e875c8d2783644b3", + "size": 37487, + "subdir": "linux-64", + "timestamp": 1654598030197, + "version": "2.1.1" + }, + "markupsafe-2.1.1-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "constrains": [ + "jinja2 >=3.0.0" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "846bd3fe17272ef43cbc5066f5665649", + "name": "markupsafe", + "sha256": "b4b8d1f51c38f1135c1e9ccdaa6a1a9ede943d84160f41be9620bf60a875c8c5", + "size": 26145, + "subdir": "linux-64", + "timestamp": 1676823521145, + "version": "2.1.1" + }, + "markupsafe-2.1.1-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "constrains": [ + "jinja2 >=3.0.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "315ed2d10642c8f4a623ef7a176f8ec8", + "name": "markupsafe", + "sha256": "a715cfd04b1b83b9d45713e2f181ad1502cfa1798e572dc9c54233461ade1134", + "size": 22790, + "subdir": "linux-64", + "timestamp": 1654598126425, + "version": "2.1.1" + }, + "markupsafe-2.1.1-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "constrains": [ + "jinja2 >=3.0.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6d1ffdd9a320aa111ac71254339eda7b", + "name": "markupsafe", + "sha256": "117a48e692ca0fc5eda84eacbc0f9475373a2c6880a4945fae42d78db25a67d7", + "size": 22854, + "subdir": "linux-64", + "timestamp": 1654598251803, + "version": "2.1.1" + }, + "markupsafe-2.1.1-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "constrains": [ + "jinja2 >=3.0.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "feb0e452205b44ac45d9b5e55c21a3b1", + "name": "markupsafe", + "sha256": "b253d11efce2f5e65ffaccf2b87bab23ae53d5bf2663ba394187047ca6374405", + "size": 22819, + "subdir": "linux-64", + "timestamp": 1654597913064, + "version": "2.1.1" + }, + "marshmallow-2.15.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "055aec657e83ae3363de767f35682a21", + "name": "marshmallow", + "sha256": "63a8197b66e5f6e7523bb3a756bf409a0b0b56087b6bb259087da35033e4e693", + "size": 70022, + "subdir": "linux-64", + "timestamp": 1543147994637, + "version": "2.15.0" + }, + "marshmallow-2.15.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6c1404f1f903eb62359452266798cce4", + "name": "marshmallow", + "sha256": "388da13f62c3ee936656aed8c62e4523680b1c0140d907b6307a8d84180b47ea", + "size": 71629, + "subdir": "linux-64", + "timestamp": 1543147507402, + "version": "2.15.0" + }, + "marshmallow-2.15.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e8f097ca547409317e4fdfaee7681372", + "name": "marshmallow", + "sha256": "d399bca50363983ab7a2e605e92ad00f60e1617294f4088038f5070ffa045bc8", + "size": 71680, + "subdir": "linux-64", + "timestamp": 1543147417516, + "version": "2.15.0" + }, + "marshmallow-2.17.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d77dd66c42f60ea4410cad5a689f95f7", + "name": "marshmallow", + "sha256": "83062aa1dfd63974aa4a3397cb89abeb7f5ebe1ad45e28c92916bd16c9e098f7", + "size": 77474, + "subdir": "linux-64", + "timestamp": 1547237250481, + "version": "2.17.0" + }, + "marshmallow-2.17.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c0afcedde44dfdeeebbe42ae389fa9fb", + "name": "marshmallow", + "sha256": "52ccc7068659cb97c6db6953bcb06818850e47dc8bbdc9a1223d8d6f6d9a4cb5", + "size": 79053, + "subdir": "linux-64", + "timestamp": 1547237336372, + "version": "2.17.0" + }, + "marshmallow-2.17.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "70f8287c0c9e39ba722e03f1159e4dc8", + "name": "marshmallow", + "sha256": "ba6a0cf5ea180a324f651005db7b4811778b5ee637511061beb22fb6e73a03f7", + "size": 79166, + "subdir": "linux-64", + "timestamp": 1547237332227, + "version": "2.17.0" + }, + "marshmallow-2.18.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "56a2e82b7205d97210d5162174e6bd5e", + "name": "marshmallow", + "sha256": "f6c83bfe7102ba3bc54a42eba03f231bc9dc930d1d84a5a49855132893384e28", + "size": 77595, + "subdir": "linux-64", + "timestamp": 1547759903355, + "version": "2.18.0" + }, + "marshmallow-2.18.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "08fb19f934a725115bda28fc0e44bf00", + "name": "marshmallow", + "sha256": "34debc53e686834323f00946ee58efce097d17c4b5e1dfeaf65f6ecdf4597cde", + "size": 79285, + "subdir": "linux-64", + "timestamp": 1547759935282, + "version": "2.18.0" + }, + "marshmallow-2.18.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "494118d98a1d9cf5407d5d224103676e", + "name": "marshmallow", + "sha256": "b769bee6c5e5ef34d946b402f6ec62a48d6b835bac7701d5d15d5b2bace1e25c", + "size": 79420, + "subdir": "linux-64", + "timestamp": 1547759923835, + "version": "2.18.0" + }, + "marshmallow-3.0.0b8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "2c37815c16c872be7d392fd4b8eb3007", + "name": "marshmallow", + "sha256": "41901ed793a9d37b12fdd3e3b4366b413417cab71803c77b834e8a6d2541d4f2", + "size": 65268, + "subdir": "linux-64", + "timestamp": 1536859740910, + "version": "3.0.0b8" + }, + "marshmallow-3.0.0b8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "d9cea9a0b22d4a4638ba81ffaba3e15e", + "name": "marshmallow", + "sha256": "8f25343504a19c9c0be5f9ad690df235e1ff0faac5cb6d25758d06afcac07b14", + "size": 67106, + "subdir": "linux-64", + "timestamp": 1536858986561, + "version": "3.0.0b8" + }, + "marshmallow-3.0.0b8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "65ea1b60f9b72ad8fc01eee3dd679b0f", + "name": "marshmallow", + "sha256": "0eefc0c78ae9c1feae27f5ccb04ed576982cfe6b9c6b53f1a1ca185d1fd81985", + "size": 66909, + "subdir": "linux-64", + "timestamp": 1536858987232, + "version": "3.0.0b8" + }, + "marshmallow-3.0.0b8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c4cadd4d630fcc10adf6805348c39db6", + "name": "marshmallow", + "sha256": "2e53260fa44033ad02c6e341a8108f614ab314727f05aaf41891fa409c6a327e", + "size": 67074, + "subdir": "linux-64", + "timestamp": 1536859751494, + "version": "3.0.0b8" + }, + "marshmallow-enum-1.5.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=2.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "afb7580c5388ab825577cf5a04b698e4", + "name": "marshmallow-enum", + "sha256": "911a36e52ffda10da20834e417dfd72b792706051adba8127d0f6eb31a01c6f7", + "size": 11521, + "subdir": "linux-64", + "timestamp": 1642510546320, + "version": "1.5.1" + }, + "marshmallow-enum-1.5.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=2.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85c273707b3dce5e4b97ab889a747ff3", + "name": "marshmallow-enum", + "sha256": "467a82f500922af7465d4a8139e0d5df0b1ac5427cc4ca05381215f7840342b5", + "size": 13028, + "subdir": "linux-64", + "timestamp": 1676828193535, + "version": "1.5.1" + }, + "marshmallow-enum-1.5.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=2.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db414c112921a7bf2b4a0d11a1a5bcf5", + "name": "marshmallow-enum", + "sha256": "84a7fcfcf57bfc1056447e2475f27afa23dcd3436f78b9c14ce4f54cd75ccead", + "size": 12230, + "subdir": "linux-64", + "timestamp": 1636044920652, + "version": "1.5.1" + }, + "marshmallow-enum-1.5.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=2.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2eaa40608bf71433e5e5cdac5c746c13", + "name": "marshmallow-enum", + "sha256": "3e8d351ea59cc8b48ae042e20b11000aee6d853661050db7db5945c80eff3dfa", + "size": 12258, + "subdir": "linux-64", + "timestamp": 1636032904114, + "version": "1.5.1" + }, + "marshmallow-enum-1.5.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=2.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "786c9f9b1c1c013a797575c958e2dfa2", + "name": "marshmallow-enum", + "sha256": "3bac84eedcccff2112ccf1c4844095ce600eb02813edd6579d25b9ac746f9eb6", + "size": 12271, + "subdir": "linux-64", + "timestamp": 1636032904097, + "version": "1.5.1" + }, + "marshmallow-oneofschema-3.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=3.0.0,<4.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45196b5c18e3bd40b5402de3b589a341", + "name": "marshmallow-oneofschema", + "sha256": "b1572b510e796cc4856fa14b064dd6e9325b9a463ca5ba3b6fd8cd6933134764", + "size": 11157, + "subdir": "linux-64", + "timestamp": 1659868973200, + "version": "3.0.1" + }, + "marshmallow-oneofschema-3.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=3.0.0,<4.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5ab09d45272e9d6afa226a2fe987054", + "name": "marshmallow-oneofschema", + "sha256": "095815416ebf57db73e5b42fc370d4aba64802e25d09dd5f1b07273b172a9787", + "size": 13041, + "subdir": "linux-64", + "timestamp": 1676837109545, + "version": "3.0.1" + }, + "marshmallow-oneofschema-3.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=3.0.0,<4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6cb157a1fd6ac9b4110359dcbbf4b025", + "name": "marshmallow-oneofschema", + "sha256": "50dce944a1c453a017f1ea5f70c9e99a145c20fe29e8b4be21ed9d426b1d3802", + "size": 11096, + "subdir": "linux-64", + "timestamp": 1659868902952, + "version": "3.0.1" + }, + "marshmallow-oneofschema-3.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=3.0.0,<4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0f2076b036b33ed21b3dbe0c27044a3", + "name": "marshmallow-oneofschema", + "sha256": "ab60954f89771ef6f05d9247b3e27a90a630d8fe3e6e459276d63eb6eea7af9e", + "size": 11097, + "subdir": "linux-64", + "timestamp": 1659868999324, + "version": "3.0.1" + }, + "marshmallow-oneofschema-3.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=3.0.0,<4.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "75e7d51a9a7eb3f61f15ca184efd8183", + "name": "marshmallow-oneofschema", + "sha256": "841e08a785fba044a86cded0634adb64493f3fb8d80ad5c6c577bf84aa9c55bd", + "size": 11106, + "subdir": "linux-64", + "timestamp": 1659868933280, + "version": "3.0.1" + }, + "matplotlib-2.0.2-py27h334a7c2_1.tar.bz2": { + "build": "py27h334a7c2_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "functools32", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "subprocess32", + "tk 8.6.*", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "095d532742c7fa829ab42cbc50dcdbad", + "name": "matplotlib", + "sha256": "8ab42722e10ba037319d0a57507cb9c1a1bbba8682b287bdb6139fa4fae946fa", + "size": 6842770, + "subdir": "linux-64", + "timestamp": 1505739391048, + "version": "2.0.2" + }, + "matplotlib-2.0.2-py35hdbc49ba_1.tar.bz2": { + "build": "py35hdbc49ba_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "45c888d8af54e3419166c2d9dec617c4", + "name": "matplotlib", + "sha256": "79327d67667196ba2442ddba548214e674ccbd8ea2756a7491ded6348fe183c7", + "size": 6977977, + "subdir": "linux-64", + "timestamp": 1505739505786, + "version": "2.0.2" + }, + "matplotlib-2.0.2-py36h2acb4ad_1.tar.bz2": { + "build": "py36h2acb4ad_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "48442e31e93e11fd0cc1fd5c5e5e0a93", + "name": "matplotlib", + "sha256": "149be7ff0d2f7f05a9751f1d8052757148934e3fda010b08e3fec0bd024937d3", + "size": 6919309, + "subdir": "linux-64", + "timestamp": 1505739618706, + "version": "2.0.2" + }, + "matplotlib-2.1.0-py27h09aba24_0.tar.bz2": { + "build": "py27h09aba24_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "functools32", + "icu >=58.2,<59.0a0", + "libpng >=1.6.32,<1.7.0a0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "subprocess32", + "tk 8.6.*", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "e1b81b3ba7ad0d4d4a1b0f32dd0353f9", + "name": "matplotlib", + "sha256": "205f057c1b81a15a0e1febd669dbee553ba247332fe4e2e6d43164f9ef812d38", + "size": 6871680, + "subdir": "linux-64", + "timestamp": 1507569223273, + "version": "2.1.0" + }, + "matplotlib-2.1.0-py35h2cbf27e_0.tar.bz2": { + "build": "py35h2cbf27e_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libpng >=1.6.32,<1.7.0a0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "850db58dc7be0a094a471def70484d83", + "name": "matplotlib", + "sha256": "51585f4995a6732f49968028554850019f13041aa1f72ae8f047f222b6aadb36", + "size": 7026831, + "subdir": "linux-64", + "timestamp": 1507569240309, + "version": "2.1.0" + }, + "matplotlib-2.1.0-py36hba5de38_0.tar.bz2": { + "build": "py36hba5de38_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libpng >=1.6.32,<1.7.0a0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "29f4b54f43a69c0c9bc9bb82078c39b4", + "name": "matplotlib", + "sha256": "a1d3320bdcb37273a383584625de6f91a6717241f10b8324c5d4e99ceeb482c8", + "size": 6964112, + "subdir": "linux-64", + "timestamp": 1507569254086, + "version": "2.1.0" + }, + "matplotlib-2.1.1-py27h0128e01_0.tar.bz2": { + "build": "py27h0128e01_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "functools32", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "subprocess32", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "74b8719f7ee4a5254737f84125da5542", + "name": "matplotlib", + "sha256": "4246e009b8b0d0a168cbd8bf0292d2cae4fe074e56534ddab5da7024f9a9d4e4", + "size": 6883298, + "subdir": "linux-64", + "timestamp": 1513104969782, + "version": "2.1.1" + }, + "matplotlib-2.1.1-py35ha26af80_0.tar.bz2": { + "build": "py35ha26af80_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "44d3c1535cb52553bc3f0308b7ad12e4", + "name": "matplotlib", + "sha256": "e1dbb9fe6f874dff85ee08e0b80c07e0f772f05cade1db4ec6ecc62ecd7f6124", + "size": 7032321, + "subdir": "linux-64", + "timestamp": 1513105021847, + "version": "2.1.1" + }, + "matplotlib-2.1.1-py36ha26af80_0.tar.bz2": { + "build": "py36ha26af80_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "6252c04c0d202639fe46c9635e3582b3", + "name": "matplotlib", + "sha256": "020a9a72c4b05ca5d36eb7e5745ee21b602feb66ab342879e2d1d19000b26273", + "size": 6975209, + "subdir": "linux-64", + "timestamp": 1513105038559, + "version": "2.1.1" + }, + "matplotlib-2.1.2-py27h0e671d2_0.tar.bz2": { + "build": "py27h0e671d2_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "functools32", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "subprocess32", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "37df423470e901dc44299c471618bdb8", + "name": "matplotlib", + "sha256": "0b5135a4c74975b22fff8622d817ac5df78c5b017b0f50acf4041950d615e491", + "size": 6881577, + "subdir": "linux-64", + "timestamp": 1516655973219, + "version": "2.1.2" + }, + "matplotlib-2.1.2-py35h0e671d2_0.tar.bz2": { + "build": "py35h0e671d2_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "2d617b32fe8c8a80a3ee3ba5eaa219a6", + "name": "matplotlib", + "sha256": "1579949091b10e1ebc27f7060cda764ab7b9037009e68bb3570d371e16a345f3", + "size": 7031172, + "subdir": "linux-64", + "timestamp": 1516653448577, + "version": "2.1.2" + }, + "matplotlib-2.1.2-py36h0e671d2_0.tar.bz2": { + "build": "py36h0e671d2_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "7529a8238222a2b57f1b08540417c930", + "name": "matplotlib", + "sha256": "a86868ca2b3d0c929e683325706f878db0e40bba7c205244db502e14e2202e49", + "size": 6977215, + "subdir": "linux-64", + "timestamp": 1516656710395, + "version": "2.1.2" + }, + "matplotlib-2.2.0-py27hbc4b006_0.tar.bz2": { + "build": "py27hbc4b006_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "functools32", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "subprocess32", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "631f0d26998c4be4cdaf486c7a87d693", + "name": "matplotlib", + "sha256": "03c5c5509a63197c2ecb71b1811c53e391949caefd5ae21ee3e7fc2a1050558c", + "size": 6882625, + "subdir": "linux-64", + "timestamp": 1520362827240, + "version": "2.2.0" + }, + "matplotlib-2.2.0-py35hbc4b006_0.tar.bz2": { + "build": "py35hbc4b006_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "47f9ec3921aaed8b3ff745c7ec5f577f", + "name": "matplotlib", + "sha256": "bf964169559900b6a52847e7a096d18a44aedc686c244e891f2283c6b7b9aa07", + "size": 7033723, + "subdir": "linux-64", + "timestamp": 1520362907424, + "version": "2.2.0" + }, + "matplotlib-2.2.0-py36hbc4b006_0.tar.bz2": { + "build": "py36hbc4b006_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "bfc49ea4ae1eb650f24cdf7a67822228", + "name": "matplotlib", + "sha256": "de1840a23268b1ecdf3a71441d2e80b7e4629ff7a9d38e6344282e4abe99c06d", + "size": 6967922, + "subdir": "linux-64", + "timestamp": 1520362408511, + "version": "2.2.0" + }, + "matplotlib-2.2.2-py27h0e671d2_0.tar.bz2": { + "build": "py27h0e671d2_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "functools32", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "subprocess32", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "7310d8ed31d81e90aae20ba9e2f4127a", + "name": "matplotlib", + "sha256": "62ee5181a53aee38e46d430db64dcd3a7b6139152f045536195b8c6bcb9291b5", + "size": 6866731, + "subdir": "linux-64", + "timestamp": 1521486493845, + "version": "2.2.2" + }, + "matplotlib-2.2.2-py27h0e671d2_1.tar.bz2": { + "build": "py27h0e671d2_1", + "build_number": 1, + "depends": [ + "backports.functools_lru_cache", + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "functools32", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.*", + "pyqt >=5.9.2,<5.10.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "subprocess32", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "4762bcc58decb075d2ead0ed7ccfa719", + "name": "matplotlib", + "sha256": "323314c023d07062be4efdcf0aaed6e629d1018b9d10fbd44e498173762b6ab1", + "size": 6866883, + "subdir": "linux-64", + "timestamp": 1523048828677, + "version": "2.2.2" + }, + "matplotlib-2.2.2-py27hb69df0a_2.tar.bz2": { + "build": "py27hb69df0a_2", + "build_number": 2, + "depends": [ + "backports.functools_lru_cache", + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "functools32", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt >=5.6,<6.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "subprocess32", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "b0a57741c56fe5fecb16310b16344afa", + "name": "matplotlib", + "sha256": "12c51766b46536a1545c822fe98905e76f8927bb3d2a935ef3e8a4e850788453", + "size": 6858360, + "subdir": "linux-64", + "timestamp": 1531343362880, + "version": "2.2.2" + }, + "matplotlib-2.2.2-py35h0e671d2_0.tar.bz2": { + "build": "py35h0e671d2_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "3ea2ce665b3f0b6e8572af2badcfbc2d", + "name": "matplotlib", + "sha256": "3ce4a2a32be1a96c4dd73b273a90c13c257b1f89a6f3f5a5f52fb4b73b869fc9", + "size": 7014616, + "subdir": "linux-64", + "timestamp": 1521486502890, + "version": "2.2.2" + }, + "matplotlib-2.2.2-py35h0e671d2_1.tar.bz2": { + "build": "py35h0e671d2_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.*", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "07c4882f673baa872cdd228cf30ffc26", + "name": "matplotlib", + "sha256": "30aab8c7733c293a0a782985ab2195a4f4416a86d688d965daa5718902b63144", + "size": 7013840, + "subdir": "linux-64", + "timestamp": 1523048852475, + "version": "2.2.2" + }, + "matplotlib-2.2.2-py36h0e671d2_0.tar.bz2": { + "build": "py36h0e671d2_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "1ff11e514b5cf33cc3bc607aa1385bb7", + "name": "matplotlib", + "sha256": "815567ed403971163234eeedb3aef9576c3eb48f72e762d22c41ae7131dbbdc2", + "size": 6967536, + "subdir": "linux-64", + "timestamp": 1521485857857, + "version": "2.2.2" + }, + "matplotlib-2.2.2-py36h0e671d2_1.tar.bz2": { + "build": "py36h0e671d2_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.*", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "8bdd1fa53831e2f61ba046eafd4f9e21", + "name": "matplotlib", + "sha256": "f06952599c3af3a0418dcca564696d95a09c4c8e6f4627d33745d53e8d442f95", + "size": 6968950, + "subdir": "linux-64", + "timestamp": 1523048157112, + "version": "2.2.2" + }, + "matplotlib-2.2.2-py36hb69df0a_2.tar.bz2": { + "build": "py36hb69df0a_2", + "build_number": 2, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt >=5.6,<6.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "8710d22d4e5ea656b8bcc6ebfa1c1181", + "name": "matplotlib", + "sha256": "b8409f4d186623aa8643863fc02329255a2ad190815776e83b20eec54505bf92", + "size": 6970289, + "subdir": "linux-64", + "timestamp": 1531343093196, + "version": "2.2.2" + }, + "matplotlib-2.2.2-py37hb69df0a_2.tar.bz2": { + "build": "py37hb69df0a_2", + "build_number": 2, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "7208da413e8780a35e8423256f96dd00", + "name": "matplotlib", + "sha256": "f3a220b41ec8414b185a27eb829b5d22eb25d1d27d36ab4e375b175236e292af", + "size": 6969038, + "subdir": "linux-64", + "timestamp": 1531343229422, + "version": "2.2.2" + }, + "matplotlib-2.2.3-py27hb69df0a_0.tar.bz2": { + "build": "py27hb69df0a_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "functools32", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "subprocess32", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "5c32641e48b1a3efb40dd797c5691943", + "name": "matplotlib", + "sha256": "d80a9f79bca4912fedea27b0573ac480ef8d8216c7a6783ae6947ac62ec2177d", + "size": 6864357, + "subdir": "linux-64", + "timestamp": 1534273730171, + "version": "2.2.3" + }, + "matplotlib-2.2.3-py35hb69df0a_0.tar.bz2": { + "build": "py35hb69df0a_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "6d6e786bdb82b24950e8e0ee123acb9a", + "name": "matplotlib", + "sha256": "2070db3530fc8f4c1e62751aafb053e11360f24c7a4e70f7d72a4de36181fed9", + "size": 7018664, + "subdir": "linux-64", + "timestamp": 1534273740421, + "version": "2.2.3" + }, + "matplotlib-2.2.3-py36hb69df0a_0.tar.bz2": { + "build": "py36hb69df0a_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "b52690dbd6940b4c1ba3b8c1ef7ed979", + "name": "matplotlib", + "sha256": "5a1cf758f0b8fc59e72f9f5e764ef52317dc051629c76c5a99583977d064a6e9", + "size": 6962639, + "subdir": "linux-64", + "timestamp": 1534273679230, + "version": "2.2.3" + }, + "matplotlib-2.2.3-py37hb69df0a_0.tar.bz2": { + "build": "py37hb69df0a_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "a4fa9d10f491522f15789ba6707fce4f", + "name": "matplotlib", + "sha256": "548d15576dd4e6a346985839350bd19460372c13c168ba8ee6ad39d3da6fd56f", + "size": 6967945, + "subdir": "linux-64", + "timestamp": 1534273737662, + "version": "2.2.3" + }, + "matplotlib-3.0.0-py35h5429711_0.tar.bz2": { + "build": "py35h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "cc5e2e260f76a387c07e1dd3288194f6", + "name": "matplotlib", + "sha256": "e33144d16aa372e07463af1174f2dcf1a08a1dc338fd3a938fd06fbedee371fd", + "size": 7267504, + "subdir": "linux-64", + "timestamp": 1538078568491, + "version": "3.0.0" + }, + "matplotlib-3.0.0-py36h5429711_0.tar.bz2": { + "build": "py36h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "d5e08c628dc7de8e425225d7cb46eeb0", + "name": "matplotlib", + "sha256": "b9a3148067b3fbbb6365afa20d6a5a6dea7500dc72a46366b2032d1dfdc25998", + "size": 7149196, + "subdir": "linux-64", + "timestamp": 1538078715172, + "version": "3.0.0" + }, + "matplotlib-3.0.0-py37h5429711_0.tar.bz2": { + "build": "py37h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "afcd235bc83a8a69bf385fc95c18579a", + "name": "matplotlib", + "sha256": "455fbbe76c4b404c48ff4d7fe110127e748b95cca8a36b2dd45e3779131f04e6", + "size": 7146541, + "subdir": "linux-64", + "timestamp": 1538078655020, + "version": "3.0.0" + }, + "matplotlib-3.0.1-py36h5429711_0.tar.bz2": { + "build": "py36h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.35,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "405a70103657eaa84f3df90acafb323b", + "name": "matplotlib", + "sha256": "44a30da02821fde9a521bb59fed19bfab0d1c7f519e7ec83e4bfb3d17f142ca0", + "size": 6940814, + "subdir": "linux-64", + "timestamp": 1540486138455, + "version": "3.0.1" + }, + "matplotlib-3.0.1-py37h5429711_0.tar.bz2": { + "build": "py37h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.35,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "eec86960d13584609a0cb97c51b81562", + "name": "matplotlib", + "sha256": "4899af7aa30c1f357cb3454bebef21a6fea06db528cecab58db58989a3555dc8", + "size": 6898583, + "subdir": "linux-64", + "timestamp": 1540486096610, + "version": "3.0.1" + }, + "matplotlib-3.0.2-py36h5429711_0.tar.bz2": { + "build": "py36h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.35,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "b8ff6195b4e9b81748fe5e8a513acb49", + "name": "matplotlib", + "sha256": "a4d5cff855c15acb124845748ab63fa8046d2a44b44553ae7c0f566c4d176f18", + "size": 6858169, + "subdir": "linux-64", + "timestamp": 1544551502806, + "version": "3.0.2" + }, + "matplotlib-3.0.2-py37h5429711_0.tar.bz2": { + "build": "py37h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.35,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "50599dc951def0dcb6dd6e76b8818777", + "name": "matplotlib", + "sha256": "efbd23945e7eae683f0d95bf5e319baf8cfe65ad1f3808e051cdaedb109f6fa3", + "size": 6902765, + "subdir": "linux-64", + "timestamp": 1544551372275, + "version": "3.0.2" + }, + "matplotlib-3.0.3-py36h5429711_0.tar.bz2": { + "build": "py36h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.36,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "6fda5dce24be38513e61ef1487cf9680", + "name": "matplotlib", + "sha256": "00adeda19e27fbc772522c611ebcfa759b933b473b31c8a4c307bac7d34abb93", + "size": 6981952, + "subdir": "linux-64", + "timestamp": 1552571627898, + "version": "3.0.3" + }, + "matplotlib-3.0.3-py37h5429711_0.tar.bz2": { + "build": "py37h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.36,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "36813fe2bba3225a8bdd779b6c69deb3", + "name": "matplotlib", + "sha256": "8e586129b2f32bf785fba5735688adcf40449075381a351f653059d41d3b4cd5", + "size": 6966913, + "subdir": "linux-64", + "timestamp": 1552571690266, + "version": "3.0.3" + }, + "matplotlib-3.1.0-py36h5429711_0.tar.bz2": { + "build": "py36h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "45ec645e50ba7ea514ff43a5e3e8b7d1", + "name": "matplotlib", + "sha256": "2b7d027a1f9eb0b9620f776a88dbc4ecf304c62db15114130f2363ff5ca7ca82", + "size": 7027871, + "subdir": "linux-64", + "timestamp": 1559228071573, + "version": "3.1.0" + }, + "matplotlib-3.1.0-py37h5429711_0.tar.bz2": { + "build": "py37h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "7fc4162831fe623b9b011307589ddc28", + "name": "matplotlib", + "sha256": "298b2a4d2366dac3392e589985d87098ba7821a71b4f648289c15ab21129c36a", + "size": 6938069, + "subdir": "linux-64", + "timestamp": 1559228090832, + "version": "3.1.0" + }, + "matplotlib-3.1.1-py36h5429711_0.tar.bz2": { + "build": "py36h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "27f731aaa6f9e93191a58a4132a3c730", + "name": "matplotlib", + "sha256": "6b68ff4bae29f5d907f7d82781cc50c5b78b5abf930b28889b4652873d764ff0", + "size": 6998732, + "subdir": "linux-64", + "timestamp": 1566571973772, + "version": "3.1.1" + }, + "matplotlib-3.1.1-py37h5429711_0.tar.bz2": { + "build": "py37h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "3fa65079fef61621712d3d0dda8a8a50", + "name": "matplotlib", + "sha256": "9f319d17baf33c4b1db177fde3e5c43900a3e1c32fb11f5d1d793b598836d39b", + "size": 6981244, + "subdir": "linux-64", + "timestamp": 1566571974233, + "version": "3.1.1" + }, + "matplotlib-3.1.1-py38h5429711_0.tar.bz2": { + "build": "py38h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "8cadbd79332c9fb533e3fb2b1be97a91", + "name": "matplotlib", + "sha256": "723d14d6c01e3be5c64df6c5cc1f7a17f5651c0247d0a3c455033de5ed926191", + "size": 6941087, + "subdir": "linux-64", + "timestamp": 1574449405849, + "version": "3.1.1" + }, + "matplotlib-3.1.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "matplotlib-base 3.1.2 py36hef1b27d_1", + "pyqt", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "d67537932ffa6b33e3d81c773db206f9", + "name": "matplotlib", + "sha256": "de97f0e3608c0ba8a835df54ae5341f6ebfedd7b714bf1f54f8579194c7f8f2e", + "size": 20960, + "subdir": "linux-64", + "timestamp": 1580491892978, + "version": "3.1.2" + }, + "matplotlib-3.1.2-py36h4fdacc2_0.tar.bz2": { + "build": "py36h4fdacc2_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "pyqt 5.9.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "9a7ebb0e8a989bb2a06391ad96cb5232", + "name": "matplotlib", + "sha256": "ffd476115142bccf50ff1c18493ea6e82b8091ba5704236bb7d1582cbe3bf193", + "size": 6959156, + "subdir": "linux-64", + "timestamp": 1580487071006, + "version": "3.1.2" + }, + "matplotlib-3.1.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "matplotlib-base 3.1.2 py37hef1b27d_1", + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "0715524f2529993a12df6b02b7781d64", + "name": "matplotlib", + "sha256": "6d265e3715140f979b49e3d9c058bb49af0351c8511dac614267cad2bb545852", + "size": 20940, + "subdir": "linux-64", + "timestamp": 1580491843427, + "version": "3.1.2" + }, + "matplotlib-3.1.2-py37h4fdacc2_0.tar.bz2": { + "build": "py37h4fdacc2_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "pyqt 5.9.*", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "4f0bced61673509a027b55505ae2393f", + "name": "matplotlib", + "sha256": "419582cfbe6ed949327ca84fb1c3785feb9dd2c4eb419734aee119246ec1df0d", + "size": 6975813, + "subdir": "linux-64", + "timestamp": 1580487072542, + "version": "3.1.2" + }, + "matplotlib-3.1.2-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "matplotlib-base 3.1.2 py38hef1b27d_1", + "pyqt", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "82cdb7dbacc959e1c97172cf1a3b4635", + "name": "matplotlib", + "sha256": "8778cae1025ac8907942270d6e95afc2b42b7e182d1e23dd92b723900b5491ec", + "size": 20972, + "subdir": "linux-64", + "timestamp": 1580491863393, + "version": "3.1.2" + }, + "matplotlib-3.1.2-py38h4fdacc2_0.tar.bz2": { + "build": "py38h4fdacc2_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "pyqt 5.9.*", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "9fab1504aea318dfa3e1b455a0107b26", + "name": "matplotlib", + "sha256": "39eff17f3141db7835e721af4f836066f8cf85fb335e4e77e21b9b130fb620fb", + "size": 6981858, + "subdir": "linux-64", + "timestamp": 1580499227376, + "version": "3.1.2" + }, + "matplotlib-3.1.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "matplotlib-base 3.1.3 py36hef1b27d_0", + "pyqt", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "6e4360e9aad1a57b4a32cd7b9593418b", + "name": "matplotlib", + "sha256": "ee371611a3a41dffedb003021c70aaabd5352b0341434f90e4b38c50259e5298", + "size": 21131, + "subdir": "linux-64", + "timestamp": 1580847934872, + "version": "3.1.3" + }, + "matplotlib-3.1.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "matplotlib-base 3.1.3 py37hef1b27d_0", + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "0907c2c1d1c28037e64afcd77194c659", + "name": "matplotlib", + "sha256": "649f89526159131c0747dbd732fb1b267b62398b6f34b046644a7bdd603adf32", + "size": 21159, + "subdir": "linux-64", + "timestamp": 1580847933394, + "version": "3.1.3" + }, + "matplotlib-3.1.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "matplotlib-base 3.1.3 py38hef1b27d_0", + "pyqt", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "e57a7d3d3e1a739c7c61ca4579338ce8", + "name": "matplotlib", + "sha256": "7134330ab90f3f55e0b7216a386fbc3dbc8c51afaa679e9b8b9bb8f3cd8c1f6a", + "size": 21131, + "subdir": "linux-64", + "timestamp": 1580847931136, + "version": "3.1.3" + }, + "matplotlib-3.2.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.2.1,<3.2.2.0a0", + "pyqt" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "e782af65ab0fe66bc4506eae020b7383", + "name": "matplotlib", + "sha256": "c2673a78dfd56e92a6ea098a686cae199cde29d6fa6b381e108ad37c7b57f825", + "size": 20761, + "subdir": "linux-64", + "timestamp": 1592406282792, + "version": "3.2.1" + }, + "matplotlib-3.2.2-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.2.2,<3.2.3.0a0", + "pyqt" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "a7cc5da80251a8ee4cdc456390e5e8b4", + "name": "matplotlib", + "sha256": "484ae0baf2f55a5680c083b617f7aa6b39e478c758d3a4324a3e6cb4a07b3599", + "size": 20878, + "subdir": "linux-64", + "timestamp": 1592846179535, + "version": "3.2.2" + }, + "matplotlib-3.3.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.3.1,<3.3.2.0a0", + "pyqt" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "e15c77786c2295b7feca9afba34cfd0c", + "name": "matplotlib", + "sha256": "83cc7834d6dec4c7c550353659f19794bfef281b7d1d6416c555a0d8a372e716", + "size": 24123, + "subdir": "linux-64", + "timestamp": 1597876523567, + "version": "3.3.1" + }, + "matplotlib-3.3.2-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.3.2,<3.3.3.0a0", + "pyqt" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "8b1a1a0b3f383e49396808b727b0a1d2", + "name": "matplotlib", + "sha256": "63801545121ec7772879f444b47bead9eaebe1bb841b35f2056a40580c1aa47e", + "size": 23912, + "subdir": "linux-64", + "timestamp": 1603378389600, + "version": "3.3.2" + }, + "matplotlib-3.3.2-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.3.2,<3.3.3.0a0", + "pyqt" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "2524f2ba1e076a0caf56b4ab775e9803", + "name": "matplotlib", + "sha256": "b2776cb71b827220d210c7bec7b27bf49bec9e153cc7d8ed1ee648ea76f263b7", + "size": 23932, + "subdir": "linux-64", + "timestamp": 1607974698232, + "version": "3.3.2" + }, + "matplotlib-3.3.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.3.4,<3.3.5.0a0", + "pyqt", + "python >=3.6,<3.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "17b04ff2e0d945e89ed47f136aea6fba", + "name": "matplotlib", + "sha256": "5fe3979d75e017a5bc40f00d1e8bdc8abc5a1c78e129880466a781a04e8d5005", + "size": 25775, + "subdir": "linux-64", + "timestamp": 1613408293703, + "version": "3.3.4" + }, + "matplotlib-3.3.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.3.4,<3.3.5.0a0", + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "d87512f68e019cb6248b98eb7ea41af7", + "name": "matplotlib", + "sha256": "d5fe095847e43ef45b677275d0284f4c15c6415ceaccae88c5c665a339a830b4", + "size": 25748, + "subdir": "linux-64", + "timestamp": 1613408312956, + "version": "3.3.4" + }, + "matplotlib-3.3.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.3.4,<3.3.5.0a0", + "pyqt", + "python >=3.8,<3.9.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "7b58d2fe5ea654ab807b7d8392e8995e", + "name": "matplotlib", + "sha256": "b291234846aa3fe1abefcfea1ec13edc31008267af6f0f1c80b581cf58a6e230", + "size": 25784, + "subdir": "linux-64", + "timestamp": 1613408300205, + "version": "3.3.4" + }, + "matplotlib-3.3.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.3.4,<3.3.5.0a0", + "pyqt", + "python >=3.9,<3.10.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "29be38e4c3679ef266d1891a4ed68344", + "name": "matplotlib", + "sha256": "39afbf997c87b831680e3f6aaff6e5e3ea2f30dac72ed188cfe6b8e94a3f5f35", + "size": 25760, + "subdir": "linux-64", + "timestamp": 1613408306859, + "version": "3.3.4" + }, + "matplotlib-3.4.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.4.2,<3.4.3.0a0", + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "f133122a37ef8a31dbe6e656096baa42", + "name": "matplotlib", + "sha256": "204bb1048b74dc830d22a28e583bf8882293276dad39ba1467d984e8b766bb63", + "size": 25729, + "subdir": "linux-64", + "timestamp": 1628003863058, + "version": "3.4.2" + }, + "matplotlib-3.4.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.4.2,<3.4.3.0a0", + "pyqt", + "python >=3.8,<3.9.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "34d444dc7620bca975a1897d28a9bb16", + "name": "matplotlib", + "sha256": "463a4b4e5e0ae7e83c93367355898ed8ff9e6e94e580df660b52b21675af9642", + "size": 25742, + "subdir": "linux-64", + "timestamp": 1628003851295, + "version": "3.4.2" + }, + "matplotlib-3.4.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.4.2,<3.4.3.0a0", + "pyqt", + "python >=3.9,<3.10.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "361e0bbd7b05f22ed2d777c8a4130a66", + "name": "matplotlib", + "sha256": "cb9daa1ae9289cdb7361dfd813f2e881f6e3e0cdf5e6997f73be159dd5b5edb9", + "size": 25730, + "subdir": "linux-64", + "timestamp": 1628003857338, + "version": "3.4.2" + }, + "matplotlib-3.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.4.3,<3.4.4.0a0", + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "8bcb0cac114c4e0163ea7d3eba2f89a3", + "name": "matplotlib", + "sha256": "8a784051a0d0b934965c22e31ae0d5574167e7db85facc05d1a8d7e38e8826f7", + "size": 27924, + "subdir": "linux-64", + "timestamp": 1634667376459, + "version": "3.4.3" + }, + "matplotlib-3.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.4.3,<3.4.4.0a0", + "pyqt", + "python >=3.8,<3.9.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "6ab92fbc1ab8e0b623443a617670f83e", + "name": "matplotlib", + "sha256": "cc98ce571322dac819c4db82178188bb182e8922c90aef1ef4d2f9c7106a33ae", + "size": 27937, + "subdir": "linux-64", + "timestamp": 1634667370562, + "version": "3.4.3" + }, + "matplotlib-3.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.4.3,<3.4.4.0a0", + "pyqt", + "python >=3.9,<3.10.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "9e8845ed5603bcdc1e885d72bebec9a7", + "name": "matplotlib", + "sha256": "dfb97f747aba4992c448ea4eef3c8a94e8aa5a4774f60d84b7103d9fa2551baf", + "size": 27910, + "subdir": "linux-64", + "timestamp": 1634667382642, + "version": "3.4.3" + }, + "matplotlib-3.5.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.0,<3.5.1.0a0", + "pyqt", + "python >=3.10,<3.11.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "b3bef441c1cc592056e9a4a9944d5a35", + "name": "matplotlib", + "sha256": "c982ee19bed94c418976def60c4a05dc756265d24fc1071120f7f6d895bcd6b1", + "size": 6810, + "subdir": "linux-64", + "timestamp": 1641903424461, + "version": "3.5.0" + }, + "matplotlib-3.5.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.0,<3.5.1.0a0", + "pyqt", + "python >=3.7,<3.8.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "27d9cdf310b4474493e854ffb0b7ca47", + "name": "matplotlib", + "sha256": "b07339fdb77ea8c4e4934ebe86cfbd259bef152c8b71467969cc69b133e37b96", + "size": 27263, + "subdir": "linux-64", + "timestamp": 1638290037116, + "version": "3.5.0" + }, + "matplotlib-3.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.0,<3.5.1.0a0", + "pyqt", + "python >=3.8,<3.9.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "037b2710aee583ae3f84dec9400dbbd7", + "name": "matplotlib", + "sha256": "b7782d9c1607fe8ae97bafbe972916da457958e837add4af6bd86a118de35496", + "size": 27261, + "subdir": "linux-64", + "timestamp": 1638290024788, + "version": "3.5.0" + }, + "matplotlib-3.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.0,<3.5.1.0a0", + "pyqt", + "python >=3.9,<3.10.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "c3cef8cf552f8bf0dc5f9dddb79a1a7a", + "name": "matplotlib", + "sha256": "be3c6915765be55cbfce576cf645031793e8ff90ea6a92588bb6e2e97010c9d0", + "size": 27242, + "subdir": "linux-64", + "timestamp": 1638290031107, + "version": "3.5.0" + }, + "matplotlib-3.5.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.1,<3.5.2.0a0", + "pyqt", + "python >=3.10,<3.11.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "bdd7689d680dbba8e8e2d8e3d60d3989", + "name": "matplotlib", + "sha256": "b63ca8d230240ffe8d4eaae219c15bdc8996e3f7e64b96ae50136bf168e9c9c0", + "size": 27911, + "subdir": "linux-64", + "timestamp": 1645456139471, + "version": "3.5.1" + }, + "matplotlib-3.5.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base >=3.5.1,<3.5.2.0a0", + "pyqt", + "python >=3.10,<3.11.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "354788892d5193a2aaadb9d09dfb3d6b", + "name": "matplotlib", + "sha256": "7484e445d3500ffb0d5941f1ad20389ec61632374d2f8985440e73903bbc5cc7", + "size": 28391, + "subdir": "linux-64", + "timestamp": 1647442123464, + "version": "3.5.1" + }, + "matplotlib-3.5.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.1,<3.5.2.0a0", + "pyqt", + "python >=3.7,<3.8.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "0310613b1a473a324227104f69967bfd", + "name": "matplotlib", + "sha256": "ed038f664eb99ab3617d83f75f46019ddcb7a7dd71fa980f372fb952de42028e", + "size": 27892, + "subdir": "linux-64", + "timestamp": 1645456132756, + "version": "3.5.1" + }, + "matplotlib-3.5.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base >=3.5.1,<3.5.2.0a0", + "pyqt", + "python >=3.7,<3.8.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "9e088b3adb3646da00154777f6af1b2d", + "name": "matplotlib", + "sha256": "f4373928689acf0b1302979058eb3638d0c81a047bd9eb193853995e31486d25", + "size": 28267, + "subdir": "linux-64", + "timestamp": 1647442116913, + "version": "3.5.1" + }, + "matplotlib-3.5.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.1,<3.5.2.0a0", + "pyqt", + "python >=3.8,<3.9.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "3c52fafb8fade5cf3c5e53ed072b3373", + "name": "matplotlib", + "sha256": "3deec1560b9b0122c053e34b0974389d1f9457b05f8434948973a6dba9c37907", + "size": 27856, + "subdir": "linux-64", + "timestamp": 1645456126748, + "version": "3.5.1" + }, + "matplotlib-3.5.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base >=3.5.1,<3.5.2.0a0", + "pyqt", + "python >=3.8,<3.9.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "e99d4a463721988d8fbd437231b25581", + "name": "matplotlib", + "sha256": "00cb6302dbcbb0cdd6fe6002d6c6b03e0b6f2a55259fe04e8376c125fe5ee17a", + "size": 28355, + "subdir": "linux-64", + "timestamp": 1647442136443, + "version": "3.5.1" + }, + "matplotlib-3.5.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.1,<3.5.2.0a0", + "pyqt", + "python >=3.9,<3.10.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "e44289571cfeec21171328df7c1a88f9", + "name": "matplotlib", + "sha256": "fc196437b598ea5876e0266d3c6f74185488ebbce02f6ef6d2977b6d30600f23", + "size": 27937, + "subdir": "linux-64", + "timestamp": 1645456120275, + "version": "3.5.1" + }, + "matplotlib-3.5.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base >=3.5.1,<3.5.2.0a0", + "pyqt", + "python >=3.9,<3.10.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "364c1e3dddefa27741e540496c38b694", + "name": "matplotlib", + "sha256": "62fb0d06224e15528540718debebeaebbfdbd7f03106fad52a7002fb96c6b8bd", + "size": 28294, + "subdir": "linux-64", + "timestamp": 1647442129989, + "version": "3.5.1" + }, + "matplotlib-3.5.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.2,<3.5.3.0a0", + "pyqt", + "python >=3.10,<3.11.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "aed7802084f1057b04a89ea6e36c84cb", + "name": "matplotlib", + "sha256": "27b613c5fe402d42f92f356ba24b3463217932a1b4e7f1e7579536478da0cf5e", + "size": 6645, + "subdir": "linux-64", + "timestamp": 1660168339775, + "version": "3.5.2" + }, + "matplotlib-3.5.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.2,<3.5.3.0a0", + "pyqt", + "python >=3.7,<3.8.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "0b704e9a7831c6a214c06434d81088f9", + "name": "matplotlib", + "sha256": "9f49e1cd5c275704184e1ba19f4628fb98faabbbd98bfddab196924b87eb37c4", + "size": 6605, + "subdir": "linux-64", + "timestamp": 1660168323143, + "version": "3.5.2" + }, + "matplotlib-3.5.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.2,<3.5.3.0a0", + "pyqt", + "python >=3.8,<3.9.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "8841b335d5f4f9cf7e7339e21fed3745", + "name": "matplotlib", + "sha256": "e9562112b6e6d753f6535fb17e57b81acf17d9af3062a5a8cbc7088a78315795", + "size": 6623, + "subdir": "linux-64", + "timestamp": 1660168334021, + "version": "3.5.2" + }, + "matplotlib-3.5.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.2,<3.5.3.0a0", + "pyqt", + "python >=3.9,<3.10.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "b45988f21d2a6ea7754fd697ac775770", + "name": "matplotlib", + "sha256": "f411abe967c8ea6eb3347fe160c2479bb818b4d1b8509d35b434fb4a22a1150f", + "size": 6612, + "subdir": "linux-64", + "timestamp": 1660168328602, + "version": "3.5.2" + }, + "matplotlib-3.5.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.3,<3.5.4.0a0", + "pyqt", + "python >=3.10,<3.11.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "beec301fc96dbf92dcf1854879ff9158", + "name": "matplotlib", + "sha256": "b2c51e7eb136be738864197f2a477a7395e789196d258b0ed08de7aec492be01", + "size": 6756, + "subdir": "linux-64", + "timestamp": 1667357064526, + "version": "3.5.3" + }, + "matplotlib-3.5.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.3,<3.5.4.0a0", + "pyqt", + "python >=3.7,<3.8.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "5560cbda4ff9ac71cf678db2b10a9fd0", + "name": "matplotlib", + "sha256": "8d74a111a82db6b39a8bdf5d032db417ab37efcf3a83bbb5c23ec02bbe7af8f8", + "size": 6731, + "subdir": "linux-64", + "timestamp": 1667357075287, + "version": "3.5.3" + }, + "matplotlib-3.5.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.3,<3.5.4.0a0", + "pyqt", + "python >=3.8,<3.9.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "db22073f364bc46204ea7f845f1a1cc6", + "name": "matplotlib", + "sha256": "7144e4ce0e9bf6a5b5f58730bf0110a21da0d7a49e747480456dadc9e35e5109", + "size": 6718, + "subdir": "linux-64", + "timestamp": 1667357069932, + "version": "3.5.3" + }, + "matplotlib-3.5.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.3,<3.5.4.0a0", + "pyqt", + "python >=3.9,<3.10.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "2e9cec08c8ebbe7cc24988739be551e3", + "name": "matplotlib", + "sha256": "2cb8a0012354c9c1397f7c613c7788b19334a47badac107ae279ffefd1a57607", + "size": 6747, + "subdir": "linux-64", + "timestamp": 1667357058777, + "version": "3.5.3" + }, + "matplotlib-3.6.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.6.2,<3.6.3.0a0", + "pyqt >=5", + "python >=3.10,<3.11.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "c0564a218374c9393f006f1e96cdc77a", + "name": "matplotlib", + "sha256": "9557d374ede0cbb7486d6dbe569d147f48e646ea69b3facb49af59c5a5b50bb6", + "size": 7639, + "subdir": "linux-64", + "timestamp": 1670466425065, + "version": "3.6.2" + }, + "matplotlib-3.6.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.6.2,<3.6.3.0a0", + "pyqt >=5", + "python >=3.11,<3.12.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "7fd382e891f061f5faee730d730d4c5b", + "name": "matplotlib", + "sha256": "49cf416b95b63fdc1afe40693534b965365eb7874ff2fb066d5b60dd4715f579", + "size": 8009, + "subdir": "linux-64", + "timestamp": 1676828266772, + "version": "3.6.2" + }, + "matplotlib-3.6.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.6.2,<3.6.3.0a0", + "pyqt >=5", + "python >=3.8,<3.9.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "c137bfedffed15164b83335df1c17e40", + "name": "matplotlib", + "sha256": "af98f85d69e79b8f1b1068381a2d8cefe9fa179073de68de527c2e1bbf4b32db", + "size": 7613, + "subdir": "linux-64", + "timestamp": 1670466419260, + "version": "3.6.2" + }, + "matplotlib-3.6.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.6.2,<3.6.3.0a0", + "pyqt >=5", + "python >=3.9,<3.10.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "89cb8c28f585c4aad8b2115e74e0f27a", + "name": "matplotlib", + "sha256": "ea0131fb6f1d6a2be01cf9a84804d6834b476c152ef13c34488207daede47046", + "size": 7641, + "subdir": "linux-64", + "timestamp": 1670466413774, + "version": "3.6.2" + }, + "matplotlib-3.7.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.7.0,<3.7.1.0a0", + "pyqt >=5", + "python >=3.10,<3.11.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "b3b0021e8588540f685566e1bb70119b", + "name": "matplotlib", + "sha256": "ec146688afdef707922717b57b1b784c22a1421e3d2549edf2d0ac4696bdc5c9", + "size": 7846, + "subdir": "linux-64", + "timestamp": 1677674628579, + "version": "3.7.0" + }, + "matplotlib-3.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.7.0,<3.7.1.0a0", + "pyqt >=5", + "python >=3.8,<3.9.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "ba3ce2de5cf60e1a18054908a069cf73", + "name": "matplotlib", + "sha256": "46a1de2d7aa306bea43319107517333283a32969060577deb4c06db18ed18ff6", + "size": 7796, + "subdir": "linux-64", + "timestamp": 1677674622632, + "version": "3.7.0" + }, + "matplotlib-3.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.7.0,<3.7.1.0a0", + "pyqt >=5", + "python >=3.9,<3.10.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "6916bf63e1b404d31f3d062c783043af", + "name": "matplotlib", + "sha256": "c95a066c8df1713bcfdd3eb1def69d345a5122259fbf499039f3bd3f9e101abb", + "size": 7824, + "subdir": "linux-64", + "timestamp": 1677674634360, + "version": "3.7.0" + }, + "matplotlib-3.7.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.7.1,<3.7.2.0a0", + "pyqt >=5", + "python >=3.10,<3.11.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "bc8d0bf93a32bfac2ac2995a868bb3e0", + "name": "matplotlib", + "sha256": "74319dc4527485f3357c9d2563fec3bcc874a5cc9d7521e52d8172371eca178d", + "size": 8006, + "subdir": "linux-64", + "timestamp": 1678724204363, + "version": "3.7.1" + }, + "matplotlib-3.7.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base >=3.7.1,<3.7.2.0a0", + "pyqt >=5", + "python >=3.10,<3.11.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "a399b93535f4a634c11372b23fe70ce7", + "name": "matplotlib", + "sha256": "980211f1bb9c6ccd479d891f2ade0c062e80b3692650e19663e4a6d0eea00dc5", + "size": 7781, + "subdir": "linux-64", + "timestamp": 1679593840686, + "version": "3.7.1" + }, + "matplotlib-3.7.1-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base >=3.7.1,<3.7.2.0a0", + "pyqt >=5", + "python >=3.11,<3.12.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "9243463957dfadc2cb5439714cd211d5", + "name": "matplotlib", + "sha256": "4092e0cfdb69b3185451e34964cd712fd609da572a800d43b2294dccec5ecf33", + "size": 7771, + "subdir": "linux-64", + "timestamp": 1679593858918, + "version": "3.7.1" + }, + "matplotlib-3.7.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.7.1,<3.7.2.0a0", + "pyqt >=5", + "python >=3.8,<3.9.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "bc7b9e265cfc88e4c210c5b342cb212b", + "name": "matplotlib", + "sha256": "e3f4d906eb7a27ef36431d1e7d6b954fe37dbf3346c0bae16807875365f1b3de", + "size": 7970, + "subdir": "linux-64", + "timestamp": 1678724198367, + "version": "3.7.1" + }, + "matplotlib-3.7.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base >=3.7.1,<3.7.2.0a0", + "pyqt >=5", + "python >=3.8,<3.9.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "f044c0d03c6a95042179ade2bcd4efd8", + "name": "matplotlib", + "sha256": "96a61d843d894e4d57f0bf343eeac5cea30b8b9ed2a29025401e7bb3dfb4df7e", + "size": 7763, + "subdir": "linux-64", + "timestamp": 1679593852552, + "version": "3.7.1" + }, + "matplotlib-3.7.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.7.1,<3.7.2.0a0", + "pyqt >=5", + "python >=3.9,<3.10.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "4c7365d62013dc053b1003e5a1f4f029", + "name": "matplotlib", + "sha256": "c9d5e6bfcfe1ef63644187e575d04296807766fa33860176db41db63c69f0059", + "size": 7970, + "subdir": "linux-64", + "timestamp": 1678724192544, + "version": "3.7.1" + }, + "matplotlib-3.7.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base >=3.7.1,<3.7.2.0a0", + "pyqt >=5", + "python >=3.9,<3.10.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "c4fa3f164cd86db650ba219d6aa544de", + "name": "matplotlib", + "sha256": "5265022b74c561323771d50daeed2c267ec2df34d0b42cc97cb30961a9c1e391", + "size": 7771, + "subdir": "linux-64", + "timestamp": 1679593846728, + "version": "3.7.1" + }, + "matplotlib-base-3.1.2-py36hef1b27d_1.tar.bz2": { + "build": "py36hef1b27d_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "dfd463659802de63b67ee5d5ff1753dd", + "name": "matplotlib-base", + "sha256": "2f5799aa9e54e7439a6afab0c64bdb47d5f03fb0226ad9b7de200764fe596f0b", + "size": 6953591, + "subdir": "linux-64", + "timestamp": 1580491870760, + "version": "3.1.2" + }, + "matplotlib-base-3.1.2-py37hef1b27d_1.tar.bz2": { + "build": "py37hef1b27d_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "fa70f1686eac000fb74e8daa5b56aae5", + "name": "matplotlib-base", + "sha256": "7d821e9898994a0bfc38f7b1bb008e5779beb0f9113c8c5fc47dda9c2d92a8df", + "size": 6961444, + "subdir": "linux-64", + "timestamp": 1580491830952, + "version": "3.1.2" + }, + "matplotlib-base-3.1.2-py38hef1b27d_1.tar.bz2": { + "build": "py38hef1b27d_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "45d66dab4de742ee981a5d10725e48eb", + "name": "matplotlib-base", + "sha256": "13035abf05cbdcc32adaeee2a8de9974eb170715c3a4df5abec88e07510e9284", + "size": 6987768, + "subdir": "linux-64", + "timestamp": 1580491844468, + "version": "3.1.2" + }, + "matplotlib-base-3.1.3-py36hef1b27d_0.tar.bz2": { + "build": "py36hef1b27d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "ced012db3ba588f9b8e2e8ea31b4671d", + "name": "matplotlib-base", + "sha256": "11f029d1e35b8e1d977bf517c76a02ade24b666ab9af76ca0590c55c4541c7a4", + "size": 6944535, + "subdir": "linux-64", + "timestamp": 1580847917644, + "version": "3.1.3" + }, + "matplotlib-base-3.1.3-py37hef1b27d_0.tar.bz2": { + "build": "py37hef1b27d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "5c164237ee903663c20b099658d8874b", + "name": "matplotlib-base", + "sha256": "64bf64a26a9167f14b2da8ea09897f73a012d3016e10145e6be65628965a9296", + "size": 6977154, + "subdir": "linux-64", + "timestamp": 1580847915792, + "version": "3.1.3" + }, + "matplotlib-base-3.1.3-py38hef1b27d_0.tar.bz2": { + "build": "py38hef1b27d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "6e11d30227911608567b75b8bdd0460d", + "name": "matplotlib-base", + "sha256": "5e49ea9fee7e04a9aa0ae2402d34ef69a09f584bd70dcfd40a5ecf0bd29e0e8e", + "size": 7038985, + "subdir": "linux-64", + "timestamp": 1580847915072, + "version": "3.1.3" + }, + "matplotlib-base-3.2.1-py36hef1b27d_0.tar.bz2": { + "build": "py36hef1b27d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "898544644196b08588ee7fcee064f604", + "name": "matplotlib-base", + "sha256": "68fd5969c9d43bf58ea50a4e41df54d1326fc3b7f2bffad877251a07df8ea5cb", + "size": 7470523, + "subdir": "linux-64", + "timestamp": 1592406276085, + "version": "3.2.1" + }, + "matplotlib-base-3.2.1-py37hef1b27d_0.tar.bz2": { + "build": "py37hef1b27d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "b26d3248d6abde1f938f10d722d4cb90", + "name": "matplotlib-base", + "sha256": "3b2ad91ddc573605c1a8766a00633963f33d68e5a8b1ff1b41c38bdbce0744c0", + "size": 7452684, + "subdir": "linux-64", + "timestamp": 1592406272723, + "version": "3.2.1" + }, + "matplotlib-base-3.2.1-py38hef1b27d_0.tar.bz2": { + "build": "py38hef1b27d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "ded330adbe837a9aac5de92435bb0ad6", + "name": "matplotlib-base", + "sha256": "f1aefc2147a5a7e4601812fddd78db8f1cf168223d4ad6d74c9aa91af1efc4e0", + "size": 7463577, + "subdir": "linux-64", + "timestamp": 1592406274427, + "version": "3.2.1" + }, + "matplotlib-base-3.2.2-py36hef1b27d_0.tar.bz2": { + "build": "py36hef1b27d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.10,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "943c5a7f5797d02cf5938761e51c802a", + "name": "matplotlib-base", + "sha256": "4810c45f8ca5d2134419eb259ba5b464bb8fc840f0d698893ec9d634c500abba", + "size": 7518491, + "subdir": "linux-64", + "timestamp": 1592846187981, + "version": "3.2.2" + }, + "matplotlib-base-3.2.2-py37hef1b27d_0.tar.bz2": { + "build": "py37hef1b27d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.10,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "6a1cbaffb5c9de9d2f1e776a3b6495a7", + "name": "matplotlib-base", + "sha256": "f66b48cc6d9288b52025e2dd1a3d66aeb123afd4a833a754fbab7bdc51122ce5", + "size": 7505459, + "subdir": "linux-64", + "timestamp": 1592846172846, + "version": "3.2.2" + }, + "matplotlib-base-3.2.2-py38hef1b27d_0.tar.bz2": { + "build": "py38hef1b27d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.10,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "e5fe73fa8e9358f55968ba5c14a82be0", + "name": "matplotlib-base", + "sha256": "64ad3c5568c1fca71b1bc0b91b6e3b7a6ac5a0780a1aa732753fee28cd0b5d69", + "size": 7483154, + "subdir": "linux-64", + "timestamp": 1592846190233, + "version": "3.2.2" + }, + "matplotlib-base-3.3.1-py36h817c723_0.tar.bz2": { + "build": "py36h817c723_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.10.2,<3.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "pillow >=6.2.0", + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.10,<8.7.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "26c88ee3335c287043274125ee26238f", + "name": "matplotlib-base", + "sha256": "e4ee2d3b4f4eabb737e3aadbfb18216dddbc09c4fedfed5683b072c9a153498e", + "size": 7054046, + "subdir": "linux-64", + "timestamp": 1597876463972, + "version": "3.3.1" + }, + "matplotlib-base-3.3.1-py37h817c723_0.tar.bz2": { + "build": "py37h817c723_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.10.2,<3.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "pillow >=6.2.0", + "pyparsing", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.10,<8.7.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "d523379e7424413a4f070fdabac163d0", + "name": "matplotlib-base", + "sha256": "d768adef1f6d205e4c8cb4dac21106873d67f051a28e666e63973e1c4826c0fb", + "size": 7024452, + "subdir": "linux-64", + "timestamp": 1597876514601, + "version": "3.3.1" + }, + "matplotlib-base-3.3.1-py38h817c723_0.tar.bz2": { + "build": "py38h817c723_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.10.2,<3.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.10,<8.7.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "3ea433d72b2e191e335936d82b410414", + "name": "matplotlib-base", + "sha256": "28b1e7858aee2d9f4854f1630ea3ed97f64b74ff33e7c0787ca8217efa1e4e63", + "size": 7081476, + "subdir": "linux-64", + "timestamp": 1597876517109, + "version": "3.3.1" + }, + "matplotlib-base-3.3.2-py36h817c723_0.tar.bz2": { + "build": "py36h817c723_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.0.3,!=2.0.4,!=2.1.2,!=2.1.6", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "c5aa265a6ab6e8d517d34f8fcbd739c5", + "name": "matplotlib-base", + "sha256": "e1b253d075c7c3207fb7ce26b813eac73df66c4630f7de748cf3904c9bd8dfa1", + "size": 7103712, + "subdir": "linux-64", + "timestamp": 1603373934044, + "version": "3.3.2" + }, + "matplotlib-base-3.3.2-py37h817c723_0.tar.bz2": { + "build": "py37h817c723_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.0.3,!=2.0.4,!=2.1.2,!=2.1.6", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "a2ae04c110b65773263ef7e35b1f49f9", + "name": "matplotlib-base", + "sha256": "14b7d34e893039484291d56e5739ba26c6ae2a52f5f69473f002457b71f95ddc", + "size": 7021557, + "subdir": "linux-64", + "timestamp": 1603376178061, + "version": "3.3.2" + }, + "matplotlib-base-3.3.2-py38h817c723_0.tar.bz2": { + "build": "py38h817c723_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.0.3,!=2.0.4,!=2.1.2,!=2.1.6", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "93932340bb10c534032955b0bc5fd61e", + "name": "matplotlib-base", + "sha256": "32e41cb3982150e424850c87f4d23e0f87558a6dae137539c689812efcf69ed2", + "size": 7089051, + "subdir": "linux-64", + "timestamp": 1603378384062, + "version": "3.3.2" + }, + "matplotlib-base-3.3.2-py39hd261b2b_0.tar.bz2": { + "build": "py39hd261b2b_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pillow >=6.2.0", + "pyparsing >=2.0.3,!=2.0.4,!=2.1.2,!=2.1.6", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "52abb8f15c164eb1cafc225bc96ce0ed", + "name": "matplotlib-base", + "sha256": "c59a1b12b7468660eed85368fda9b5a70054d523b2aecda3a8cc41c6d4a8fd1d", + "size": 7020483, + "subdir": "linux-64", + "timestamp": 1607974691989, + "version": "3.3.2" + }, + "matplotlib-base-3.3.4-py36h62a2d02_0.tar.bz2": { + "build": "py36h62a2d02_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.0.3,!=2.0.4,!=2.1.2,!=2.1.6", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "da4d50e8b18ba3e6f89f98e1b84efedc", + "name": "matplotlib-base", + "sha256": "3304dd126f03bd9c243925f0f2a3d1dc1d01a68cacd446020afa510bec3423ad", + "size": 7076715, + "subdir": "linux-64", + "timestamp": 1613408052887, + "version": "3.3.4" + }, + "matplotlib-base-3.3.4-py37h62a2d02_0.tar.bz2": { + "build": "py37h62a2d02_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.0.3,!=2.0.4,!=2.1.2,!=2.1.6", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "18def7271de993f5486260abef32d3da", + "name": "matplotlib-base", + "sha256": "5e61904d42c8b8249f02dc20d032256c6713df0415f437ff884b600138b30df0", + "size": 7058799, + "subdir": "linux-64", + "timestamp": 1613408282761, + "version": "3.3.4" + }, + "matplotlib-base-3.3.4-py38h62a2d02_0.tar.bz2": { + "build": "py38h62a2d02_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.0.3,!=2.0.4,!=2.1.2,!=2.1.6", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "efae109184d777db5659e268e2212bdf", + "name": "matplotlib-base", + "sha256": "c1b4588753a22b5c486be51e41bd89ef585c88972cc220f06f2c5f43ffc9b9c7", + "size": 7079371, + "subdir": "linux-64", + "timestamp": 1613408134644, + "version": "3.3.4" + }, + "matplotlib-base-3.3.4-py39h62a2d02_0.tar.bz2": { + "build": "py39h62a2d02_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.0.3,!=2.0.4,!=2.1.2,!=2.1.6", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "dd8a9fb701cbccc42586e6dafc1fb0a4", + "name": "matplotlib-base", + "sha256": "b9b478437134994843ef118644dcc9d97f6d669246c641d98400a1774485a695", + "size": 7075941, + "subdir": "linux-64", + "timestamp": 1613408209886, + "version": "3.3.4" + }, + "matplotlib-base-3.4.2-py37hab158f2_0.tar.bz2": { + "build": "py37hab158f2_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "0701289ff45ccb17605083cf8dd0297c", + "name": "matplotlib-base", + "sha256": "5e846464253e3c2bbaff0af63cd6e1a59e7cfeeb029d33ffeca5f4f1da87cea5", + "size": 7602974, + "subdir": "linux-64", + "timestamp": 1628003839866, + "version": "3.4.2" + }, + "matplotlib-base-3.4.2-py38hab158f2_0.tar.bz2": { + "build": "py38hab158f2_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "927ea0475484f8d81f404645efb694ca", + "name": "matplotlib-base", + "sha256": "380d450d6f57935aae4bf2d89f3a95995cef9f83ef3fc9f80c11d703ca60d982", + "size": 7619444, + "subdir": "linux-64", + "timestamp": 1628003669621, + "version": "3.4.2" + }, + "matplotlib-base-3.4.2-py39hab158f2_0.tar.bz2": { + "build": "py39hab158f2_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "0be5965039f3b37d6074f8ddce6567a4", + "name": "matplotlib-base", + "sha256": "eb97f85502908a8a6ae016fccd3bafb08f7d2f53043fbae760ac3cb86fd7d82c", + "size": 7616863, + "subdir": "linux-64", + "timestamp": 1628003754874, + "version": "3.4.2" + }, + "matplotlib-base-3.4.3-py37hbbc1b5f_0.tar.bz2": { + "build": "py37hbbc1b5f_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "18341bc452d27358de883c4f5c3372f9", + "name": "matplotlib-base", + "sha256": "0978b943cec3c3ffa8cda67eb82bff78296c6e50e20631b6c26a02ddf6795489", + "size": 7552618, + "subdir": "linux-64", + "timestamp": 1634667274247, + "version": "3.4.3" + }, + "matplotlib-base-3.4.3-py38hbbc1b5f_0.tar.bz2": { + "build": "py38hbbc1b5f_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "8f85a086592644391b4c85752137c4f0", + "name": "matplotlib-base", + "sha256": "296580233000603490d9d29c84de743b5c1d45926af9b7b0aa97896eded994f9", + "size": 7563746, + "subdir": "linux-64", + "timestamp": 1634667193827, + "version": "3.4.3" + }, + "matplotlib-base-3.4.3-py39hbbc1b5f_0.tar.bz2": { + "build": "py39hbbc1b5f_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "ae42a893749027b8ffd6475904467fcc", + "name": "matplotlib-base", + "sha256": "ccc5dd4a420fa2524f9ce76589f79014233d31f8a32a2f7faa405186b3bc7f9e", + "size": 7557494, + "subdir": "linux-64", + "timestamp": 1634667358391, + "version": "3.4.3" + }, + "matplotlib-base-3.5.0-py310h2dab92d_0.tar.bz2": { + "build": "py310h2dab92d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "d2d056d389d99686bb33db0272b53e34", + "name": "matplotlib-base", + "sha256": "d30afab0ae25225df5164326ff1d56e13136b17f973f617b1b93ab4a4c42cd62", + "size": 7757887, + "subdir": "linux-64", + "timestamp": 1641903414938, + "version": "3.5.0" + }, + "matplotlib-base-3.5.0-py37h3ed280b_0.tar.bz2": { + "build": "py37h3ed280b_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "01bf11e5dc253ee9fc88412cc06c7582", + "name": "matplotlib-base", + "sha256": "b668fc2170034911fe352e0f8dc3d77d83aeaaa60402f802c96320ac029fbba8", + "size": 7656841, + "subdir": "linux-64", + "timestamp": 1638290013064, + "version": "3.5.0" + }, + "matplotlib-base-3.5.0-py38h3ed280b_0.tar.bz2": { + "build": "py38h3ed280b_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "755e1dddfcf4d57c73c2eff64b519459", + "name": "matplotlib-base", + "sha256": "d71c8e889a62419718b9b9eb91bcacfcee32cc3d5c14e465a961ef5e1d26f33c", + "size": 7668291, + "subdir": "linux-64", + "timestamp": 1638289855775, + "version": "3.5.0" + }, + "matplotlib-base-3.5.0-py39h3ed280b_0.tar.bz2": { + "build": "py39h3ed280b_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "ef57e872389b2352d63cdbdcb49d5235", + "name": "matplotlib-base", + "sha256": "0a96c4c667dc1f0901b469a50d94af4e8c2a76e315d9f4a4fae2bb6f7d11c4ea", + "size": 7668135, + "subdir": "linux-64", + "timestamp": 1638289932260, + "version": "3.5.0" + }, + "matplotlib-base-3.5.1-py310ha18d171_0.tar.bz2": { + "build": "py310ha18d171_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "0496b42b0a3f57339f105b33a6f6d56d", + "name": "matplotlib-base", + "sha256": "a24e9080735d473ece2a272724ce39a190ce0a03c0ec039522b86465afaf774e", + "size": 7807203, + "subdir": "linux-64", + "timestamp": 1645456108049, + "version": "3.5.1" + }, + "matplotlib-base-3.5.1-py310ha18d171_1.tar.bz2": { + "build": "py310ha18d171_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "06666f989a2eea665569e9d83774f6f7", + "name": "matplotlib-base", + "sha256": "27423a429435c9698361c0fad4e09a081e79a10b0dbee172b6694ff75e4bbd7c", + "size": 7760687, + "subdir": "linux-64", + "timestamp": 1647441945703, + "version": "3.5.1" + }, + "matplotlib-base-3.5.1-py37ha18d171_0.tar.bz2": { + "build": "py37ha18d171_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "26c6c5d2e86a2a41dfbf1ffce017ba6c", + "name": "matplotlib-base", + "sha256": "cee0c46e6d4bab791ce08eb217e5cca73e3af8565856cc0b1d7509b9f12fb64f", + "size": 7752874, + "subdir": "linux-64", + "timestamp": 1645456017368, + "version": "3.5.1" + }, + "matplotlib-base-3.5.1-py37ha18d171_1.tar.bz2": { + "build": "py37ha18d171_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "1ccfadd35bad91309c87837ed22b0f46", + "name": "matplotlib-base", + "sha256": "40380f30a2172a2dd941d5e759f1638aa7b62600159302136878210332fd825f", + "size": 7727039, + "subdir": "linux-64", + "timestamp": 1647441852378, + "version": "3.5.1" + }, + "matplotlib-base-3.5.1-py38ha18d171_0.tar.bz2": { + "build": "py38ha18d171_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "ebc649047aca6f596a8d66a02f317d37", + "name": "matplotlib-base", + "sha256": "085798911bb88759f51007c41134c9c5bd5623a8c16baa939b8476e64be377aa", + "size": 7774533, + "subdir": "linux-64", + "timestamp": 1645455937245, + "version": "3.5.1" + }, + "matplotlib-base-3.5.1-py38ha18d171_1.tar.bz2": { + "build": "py38ha18d171_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "3171c7f58b5d259c202595cb0dad57a0", + "name": "matplotlib-base", + "sha256": "2790aff6f95231024ff9c2d7ebc9733f8f95286792f28950380c30832c84e90f", + "size": 7744768, + "subdir": "linux-64", + "timestamp": 1647442104672, + "version": "3.5.1" + }, + "matplotlib-base-3.5.1-py39ha18d171_0.tar.bz2": { + "build": "py39ha18d171_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "81c423810c6a5493bd4bea95c50301cc", + "name": "matplotlib-base", + "sha256": "29858b22589baf6c15aa7b4a219ea575a438b66db2802cfdd6d62ae37cfcc6f2", + "size": 7768509, + "subdir": "linux-64", + "timestamp": 1645455862011, + "version": "3.5.1" + }, + "matplotlib-base-3.5.1-py39ha18d171_1.tar.bz2": { + "build": "py39ha18d171_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "b0b6b57c140f026b8806051107336576", + "name": "matplotlib-base", + "sha256": "dc51b316ef5dcfb82a9c0afdc40879146ae59516f6cea7db776077783dfd2d76", + "size": 7729454, + "subdir": "linux-64", + "timestamp": 1647442028622, + "version": "3.5.1" + }, + "matplotlib-base-3.5.2-py310hf590b9c_0.tar.bz2": { + "build": "py310hf590b9c_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "9a86d71963fca60d70baa1cb323551d5", + "name": "matplotlib-base", + "sha256": "52da63fd6437b2fa4ff0a7e77e44880ca4a9e550308b5c281f1d1d7c70c8d294", + "size": 10807414, + "subdir": "linux-64", + "timestamp": 1660168311133, + "version": "3.5.2" + }, + "matplotlib-base-3.5.2-py37hf590b9c_0.tar.bz2": { + "build": "py37hf590b9c_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "1fa0a0ab7fd2e21f6263851348481f92", + "name": "matplotlib-base", + "sha256": "4aa3fa0de4af70a5a70a3cbc2a9a892d216ff40a1f5d5dd1aab32184dd37dc17", + "size": 7701359, + "subdir": "linux-64", + "timestamp": 1660168112539, + "version": "3.5.2" + }, + "matplotlib-base-3.5.2-py38hf590b9c_0.tar.bz2": { + "build": "py38hf590b9c_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "f7d86dec239afbb71e8db02acb677c79", + "name": "matplotlib-base", + "sha256": "e00753e0c88e88e2f924de43e5ec9fbb350467edde97cf82eee4b1acbcd05379", + "size": 7716998, + "subdir": "linux-64", + "timestamp": 1660168241713, + "version": "3.5.2" + }, + "matplotlib-base-3.5.2-py39hf590b9c_0.tar.bz2": { + "build": "py39hf590b9c_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "a356ab9537c19bd6bae34f381b20a26c", + "name": "matplotlib-base", + "sha256": "284409df4e07ce603de805bc246b9f9fd62522d3952860f124ae58892a9abbd0", + "size": 7723769, + "subdir": "linux-64", + "timestamp": 1660168180954, + "version": "3.5.2" + }, + "matplotlib-base-3.5.3-py310hf590b9c_0.tar.bz2": { + "build": "py310hf590b9c_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.12.1,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "301c79046def314b0ea27aa535da48cc", + "name": "matplotlib-base", + "sha256": "6ab759f352aced2472490aa42ef6f7647de8aba11303fa72d96ac17928fa2289", + "size": 7727598, + "subdir": "linux-64", + "timestamp": 1667356927731, + "version": "3.5.3" + }, + "matplotlib-base-3.5.3-py37hf590b9c_0.tar.bz2": { + "build": "py37hf590b9c_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.12.1,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "e1cd1304216ae7805e01e4a1ed762cb3", + "name": "matplotlib-base", + "sha256": "30e9f0afa429359d58e2fbac56c9d4fa2c84459d299b5ed3d57afe73bd84710e", + "size": 7682768, + "subdir": "linux-64", + "timestamp": 1667357048104, + "version": "3.5.3" + }, + "matplotlib-base-3.5.3-py38hf590b9c_0.tar.bz2": { + "build": "py38hf590b9c_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.12.1,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "8518636ee486132f4b7aa585fe7e1904", + "name": "matplotlib-base", + "sha256": "0f2e75791af48282d8c4b1eb4e2404a3bdbd0b839729716554d2151d48eda2b8", + "size": 7698443, + "subdir": "linux-64", + "timestamp": 1667356986909, + "version": "3.5.3" + }, + "matplotlib-base-3.5.3-py39hf590b9c_0.tar.bz2": { + "build": "py39hf590b9c_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.12.1,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "e55a3efaff8ab4e00af600db360ad577", + "name": "matplotlib-base", + "sha256": "9b44b18e0ea8f4942b727e44df5934f719b30987f55a8bbd0dd0bda61e2f32ab", + "size": 7697225, + "subdir": "linux-64", + "timestamp": 1667356866273, + "version": "3.5.3" + }, + "matplotlib-base-3.6.2-py310h945d387_0.tar.bz2": { + "build": "py310h945d387_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "cc5d30070a57811528f36319b99e1cf2", + "name": "matplotlib-base", + "sha256": "0e8941c09e29886ee54c0988d5e617be7dde40d4a943e8df6b7e27c290abab40", + "size": 7916924, + "subdir": "linux-64", + "timestamp": 1670466402920, + "version": "3.6.2" + }, + "matplotlib-base-3.6.2-py311h945d387_0.tar.bz2": { + "build": "py311h945d387_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "9ca2b5c20a5f18fe760f8f26e68c3439", + "name": "matplotlib-base", + "sha256": "e4325292011bf288d68b16aa8572f894a5fcd6b614b09fefea83f79b020554f2", + "size": 8741448, + "subdir": "linux-64", + "timestamp": 1676828257531, + "version": "3.6.2" + }, + "matplotlib-base-3.6.2-py38h945d387_0.tar.bz2": { + "build": "py38h945d387_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "87cd6b6286ccd489e09884c396f1d5d1", + "name": "matplotlib-base", + "sha256": "b56348ddd11b339cbb0b43d6b36fbd7339ea0b2c7add5bfb3f7ea381db2655a6", + "size": 7915145, + "subdir": "linux-64", + "timestamp": 1670466343218, + "version": "3.6.2" + }, + "matplotlib-base-3.6.2-py39h945d387_0.tar.bz2": { + "build": "py39h945d387_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "c103a47007fcd783d077ffde5ed83edd", + "name": "matplotlib-base", + "sha256": "ea8f62995c2340755b4581fe5b59e9044a59dfe27911215bedf2cb5244785570", + "size": 7889286, + "subdir": "linux-64", + "timestamp": 1670466285882, + "version": "3.6.2" + }, + "matplotlib-base-3.7.0-py310h1128e8f_0.tar.bz2": { + "build": "py310h1128e8f_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7", + "tk >=8.6.11,<8.7", + "tk >=8.6.11,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "cb332c6fd1b54a404ea9a51526aaa551", + "name": "matplotlib-base", + "sha256": "1669f4a72be01fbf1f826d85411c12f969ae9306d83199ab757a2510494632d3", + "size": 10598746, + "subdir": "linux-64", + "timestamp": 1677674540501, + "version": "3.7.0" + }, + "matplotlib-base-3.7.0-py38h417a72b_0.tar.bz2": { + "build": "py38h417a72b_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "importlib_resources >=5.2.0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "numpy >=1.20", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7", + "tk >=8.6.11,<8.7", + "tk >=8.6.11,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "5f1c66bc29453a33ebcd604c0357fe7c", + "name": "matplotlib-base", + "sha256": "e24c76f87e5005008b2f394cfbd37cd4632930dada363e463fe81dceab291da3", + "size": 7986635, + "subdir": "linux-64", + "timestamp": 1677674462058, + "version": "3.7.0" + }, + "matplotlib-base-3.7.0-py39h417a72b_0.tar.bz2": { + "build": "py39h417a72b_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "importlib_resources >=5.2.0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "numpy >=1.20", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7", + "tk >=8.6.11,<8.7", + "tk >=8.6.11,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "87a159cc92ced99ef71ac42ad06ed91a", + "name": "matplotlib-base", + "sha256": "b6c7db9e46a08397e68479600a0a8dc455374f8681fd78a25142f9c399077621", + "size": 7977867, + "subdir": "linux-64", + "timestamp": 1677674611833, + "version": "3.7.0" + }, + "matplotlib-base-3.7.1-py310h1128e8f_0.tar.bz2": { + "build": "py310h1128e8f_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7", + "tk >=8.6.11,<8.7", + "tk >=8.6.11,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "4129112eb63e7adcec866c16f0ed2528", + "name": "matplotlib-base", + "sha256": "60f5a9154db5ecc7fd85533d71b6c4f6f7c25291011f11284fc00f5f1f68287f", + "size": 10635656, + "subdir": "linux-64", + "timestamp": 1678724180150, + "version": "3.7.1" + }, + "matplotlib-base-3.7.1-py310h1128e8f_1.tar.bz2": { + "build": "py310h1128e8f_1", + "build_number": 1, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7", + "tk >=8.6.12,<8.7", + "tk >=8.6.12,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "0d8b5e8f51c74e834f854abc23c6de88", + "name": "matplotlib-base", + "sha256": "0051434d038218583258f47dad8d173a2f68187d1c81e01a2af4ce3ec996fe5e", + "size": 8021050, + "subdir": "linux-64", + "timestamp": 1679593629865, + "version": "3.7.1" + }, + "matplotlib-base-3.7.1-py311ha02d727_1.tar.bz2": { + "build": "py311ha02d727_1", + "build_number": 1, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20", + "numpy >=1.23.5,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.7", + "tk >=8.6.12,<8.7", + "tk >=8.6.12,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "6c660cdc7571f86b22671b27ae2b9b78", + "name": "matplotlib-base", + "sha256": "2d268322ffad3dde67d9efc4cd90fc43afbbc1e7e4308400055d618f23f9f12e", + "size": 8968664, + "subdir": "linux-64", + "timestamp": 1679593828815, + "version": "3.7.1" + }, + "matplotlib-base-3.7.1-py38h417a72b_0.tar.bz2": { + "build": "py38h417a72b_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "importlib_resources >=5.2.0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "numpy >=1.20", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7", + "tk >=8.6.11,<8.7", + "tk >=8.6.11,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "6e3d88e1289ba502de0163b849563b76", + "name": "matplotlib-base", + "sha256": "14fd7afad40551d42c0415f41840245c9787a9cd089c63bbe9e0c07f92ff2386", + "size": 7979620, + "subdir": "linux-64", + "timestamp": 1678724103738, + "version": "3.7.1" + }, + "matplotlib-base-3.7.1-py38h417a72b_1.tar.bz2": { + "build": "py38h417a72b_1", + "build_number": 1, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "importlib_resources >=5.2.0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "numpy >=1.20", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7", + "tk >=8.6.12,<8.7", + "tk >=8.6.12,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "febdd9d2c4a6a75d592d0f5dd9b963b9", + "name": "matplotlib-base", + "sha256": "97511088e850d1580d33d1a87246ec340bc0f901a6a338fe9101866f1648db6d", + "size": 8023596, + "subdir": "linux-64", + "timestamp": 1679593761887, + "version": "3.7.1" + }, + "matplotlib-base-3.7.1-py39h417a72b_0.tar.bz2": { + "build": "py39h417a72b_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "importlib_resources >=5.2.0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "numpy >=1.20", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7", + "tk >=8.6.11,<8.7", + "tk >=8.6.11,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "ad0d4f77f9ed6bfa3971fc84b99211ed", + "name": "matplotlib-base", + "sha256": "d022d5bf38cc0f7c23e1a0ca2b8d95c4cdcf5d17f4c0c6b13ea8ab5297839c7b", + "size": 7971019, + "subdir": "linux-64", + "timestamp": 1678724034563, + "version": "3.7.1" + }, + "matplotlib-base-3.7.1-py39h417a72b_1.tar.bz2": { + "build": "py39h417a72b_1", + "build_number": 1, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "importlib_resources >=5.2.0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "numpy >=1.20", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7", + "tk >=8.6.12,<8.7", + "tk >=8.6.12,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "581a0dd40d112479edddce6fbc6c9c4b", + "name": "matplotlib-base", + "sha256": "4cf94d202a616ab20157c4cd28bac48fd393c0ca554ddb6f9343412005ac0943", + "size": 8012354, + "subdir": "linux-64", + "timestamp": 1679593695959, + "version": "3.7.1" + }, + "matplotlib-inline-0.1.6-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6336be55da6cebfaf1cbbdc573524fc1", + "name": "matplotlib-inline", + "sha256": "be8075a8d70b0da67859d63016219e3dd1bc84a1b484abcbd8b95eff52884d88", + "size": 16451, + "subdir": "linux-64", + "timestamp": 1662014606193, + "version": "0.1.6" + }, + "matplotlib-inline-0.1.6-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fc83dd1b3d2ec3c0a297ead0c3405907", + "name": "matplotlib-inline", + "sha256": "7ac07ea180b5928086075900afbc332fb1d3c81ddfacb54c891693c284056f14", + "size": 19573, + "subdir": "linux-64", + "timestamp": 1676823852670, + "version": "0.1.6" + }, + "matplotlib-inline-0.1.6-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f4c8261b5341c64567314f3f0467aa03", + "name": "matplotlib-inline", + "sha256": "912d133c0b72fb4c11fdb66daebea0c872dc3f5bc3ebdcd727ae59358e29e878", + "size": 16250, + "subdir": "linux-64", + "timestamp": 1662014508146, + "version": "0.1.6" + }, + "matplotlib-inline-0.1.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "28c78d14ef2a80747df2bf2353ef21d7", + "name": "matplotlib-inline", + "sha256": "228a70eddf0a99801e03179f1ab8ddd915bfb7ce351fe7f94c502163d615eb77", + "size": 16341, + "subdir": "linux-64", + "timestamp": 1662014640999, + "version": "0.1.6" + }, + "matplotlib-inline-0.1.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c04ef34af33da4c71bcc99b7ec24d210", + "name": "matplotlib-inline", + "sha256": "2cce821c755c782aec4fa1713dfa3a1e4f6639c532fefe4eaaba10297df6c546", + "size": 16391, + "subdir": "linux-64", + "timestamp": 1662014553452, + "version": "0.1.6" + }, + "matrixprofile-1.1.10-py310h9102076_0.tar.bz2": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "protobuf >=3.11.2,<4.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fdddb4abc88e2f0c93dcac6175e3cf88", + "name": "matrixprofile", + "sha256": "34b8c50b1e30a3dcc71d71584ede788249eb720dbdd19132cb3e90976a2b659f", + "size": 921264, + "subdir": "linux-64", + "timestamp": 1640812500855, + "version": "1.1.10" + }, + "matrixprofile-1.1.10-py36hce1f21e_0.tar.bz2": { + "build": "py36hce1f21e_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "matplotlib-base >=3.0.3", + "numpy >=1.16.6,<2.0a0", + "protobuf >=3.11.2,<4.0.0", + "python >=3.6,<3.7.0a0", + "scipy >=1.3.2,<2.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "469de479554d5c0a433b9ed109a0b46a", + "name": "matrixprofile", + "sha256": "3826498f200c023dd112a097e3aff8ccea21447d52322972d1c4ab1123a37510", + "size": 448046, + "subdir": "linux-64", + "timestamp": 1633506374136, + "version": "1.1.10" + }, + "matrixprofile-1.1.10-py37hce1f21e_0.tar.bz2": { + "build": "py37hce1f21e_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "matplotlib-base >=3.0.3", + "numpy >=1.16.6,<2.0a0", + "protobuf >=3.11.2,<4.0.0", + "python >=3.7,<3.8.0a0", + "scipy >=1.3.2,<2.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6973fa46392408a18423e0930fb8b3f1", + "name": "matrixprofile", + "sha256": "8856f20f416eed2a3605cc7f5ca6df6fd3e117ae1145038b64ab0fc07cac8364", + "size": 452493, + "subdir": "linux-64", + "timestamp": 1633506357264, + "version": "1.1.10" + }, + "matrixprofile-1.1.10-py38hce1f21e_0.tar.bz2": { + "build": "py38hce1f21e_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "matplotlib-base >=3.0.3", + "numpy >=1.16.6,<2.0a0", + "protobuf >=3.11.2,<4.0.0", + "python >=3.8,<3.9.0a0", + "scipy >=1.3.2,<2.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2a91ba56e005a936150a5c5cfb309b0f", + "name": "matrixprofile", + "sha256": "a358f4207b32836767802e2b64780687c98b808c048e70c0a2be5af76fa26ea7", + "size": 454197, + "subdir": "linux-64", + "timestamp": 1633506109956, + "version": "1.1.10" + }, + "matrixprofile-1.1.10-py39hce1f21e_0.tar.bz2": { + "build": "py39hce1f21e_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "matplotlib-base >=3.0.3", + "numpy >=1.16.6,<2.0a0", + "protobuf >=3.11.2,<4.0.0", + "python >=3.9,<3.10.0a0", + "scipy >=1.3.2,<2.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1172b7ed52fb83bac14d683f8cd0bd8e", + "name": "matrixprofile", + "sha256": "ad183cd0a670a2b3d2674e4c496828acd8b0de42c68799cae7a9ec514ad76021", + "size": 465999, + "subdir": "linux-64", + "timestamp": 1633506347128, + "version": "1.1.10" + }, + "maturin-0.13.7-py310h52d8a92_0.tar.bz2": { + "build": "py310h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "tomli >=1.1.0" + ], + "license": "MIT OR Apache-2.0", + "license_family": "MIT", + "md5": "e01d619f6530fa6f13efda7d466843ad", + "name": "maturin", + "sha256": "760e8fc80ee023a5760bffb396ed36a72bbd51c3204cc3485c4d7a5cc8774840", + "size": 7621157, + "subdir": "linux-64", + "timestamp": 1667960684826, + "version": "0.13.7" + }, + "maturin-0.13.7-py311h52d8a92_0.tar.bz2": { + "build": "py311h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "tomli >=1.1.0" + ], + "license": "MIT OR Apache-2.0", + "license_family": "MIT", + "md5": "b6e080e5b74c6c2dfdea550cad10c2b3", + "name": "maturin", + "sha256": "c6d459c60e58f339099914c4b714ec826510970598bcd07857ab90aa09c12b3a", + "size": 7622014, + "subdir": "linux-64", + "timestamp": 1676844996833, + "version": "0.13.7" + }, + "maturin-0.13.7-py37h52d8a92_0.tar.bz2": { + "build": "py37h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "tomli >=1.1.0" + ], + "license": "MIT OR Apache-2.0", + "license_family": "MIT", + "md5": "60d0cd378cf6f042b032b352a27364e9", + "name": "maturin", + "sha256": "7f0afbe53b74ce7dc1712f82d05ac37bda49169cd216c1f70e793b24595dcb9d", + "size": 7620915, + "subdir": "linux-64", + "timestamp": 1667960971824, + "version": "0.13.7" + }, + "maturin-0.13.7-py38h52d8a92_0.tar.bz2": { + "build": "py38h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "tomli >=1.1.0" + ], + "license": "MIT OR Apache-2.0", + "license_family": "MIT", + "md5": "05ffa8543966396fd10959b904c045da", + "name": "maturin", + "sha256": "c07130ad7230b41da526184b77752935beb1ad70c110b4dd2cd6f6a63bd399bd", + "size": 7621863, + "subdir": "linux-64", + "timestamp": 1667961114771, + "version": "0.13.7" + }, + "maturin-0.13.7-py39h52d8a92_0.tar.bz2": { + "build": "py39h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "tomli >=1.1.0" + ], + "license": "MIT OR Apache-2.0", + "license_family": "MIT", + "md5": "8afd83568ecdaee283550e37b635d074", + "name": "maturin", + "sha256": "5ef4b31f3705757f97955d9c83a0183973633670c56ce95e546c67a015deaf50", + "size": 7621338, + "subdir": "linux-64", + "timestamp": 1667960828826, + "version": "0.13.7" + }, + "maven-3.5.3-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "openjdk" + ], + "license": "Apachev2", + "license_family": "Apache", + "md5": "26eeb3bbbdef6a2858e407621482a7c5", + "name": "maven", + "sha256": "f9c1d674f0178a9d6a941e6be2d6c4fde8e1d4abd8b920e255bd062f446fa591", + "size": 8778178, + "subdir": "linux-64", + "timestamp": 1527872435202, + "version": "3.5.3" + }, + "maven-3.5.4-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "openjdk" + ], + "license": "Apachev2", + "license_family": "Apache", + "md5": "aead8f1185716b36215cd1f9934d2d1a", + "name": "maven", + "sha256": "6f01caedbf2196074cf504f9dba6ebcec2d1e9c7242efcb347af4260f0a9e856", + "size": 8813723, + "subdir": "linux-64", + "timestamp": 1539663717811, + "version": "3.5.4" + }, + "maven-3.6.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "openjdk" + ], + "license": "Apachev2", + "license_family": "Apache", + "md5": "8e767e01fe71eb338938a90cbbfec2f6", + "name": "maven", + "sha256": "440df180af50b46bf3d02f9b816553903b2e1c42c74213a845c54dd4695e33b4", + "size": 8998571, + "subdir": "linux-64", + "timestamp": 1542082060690, + "version": "3.6.0" + }, + "maven-3.8.1-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "openjdk" + ], + "license": "Apachev2", + "license_family": "Apache", + "md5": "72da22875d6277ecdce68e7f555b5878", + "name": "maven", + "sha256": "9f56b5bbefe18c1e62e19f82b98a0abffb083e1be497643fbdfec78b5359b61e", + "size": 9506267, + "subdir": "linux-64", + "timestamp": 1617984199527, + "version": "3.8.1" + }, + "mayavi-4.6.2-py27hcf37d21_4.tar.bz2": { + "build": "py27hcf37d21_4", + "build_number": 4, + "depends": [ + "apptools", + "envisage", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy >=1.11.3,<2.0a0", + "pyqt >=4,<6", + "python >=2.7,<2.8.0a0", + "setuptools", + "traitsui", + "vtk 8.2.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "15ab7aad866cb5d2e9dc883df1016d2d", + "name": "mayavi", + "sha256": "a684ebce605af174da98d136d1986b5f2d4e6b47e361d038bbaf35fe2cb92761", + "size": 13981168, + "subdir": "linux-64", + "timestamp": 1558738741740, + "version": "4.6.2" + }, + "mayavi-4.6.2-py36hcf37d21_4.tar.bz2": { + "build": "py36hcf37d21_4", + "build_number": 4, + "depends": [ + "apptools", + "envisage", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy >=1.11.3,<2.0a0", + "pyqt >=4,<6", + "python >=3.6,<3.7.0a0", + "setuptools", + "traitsui", + "vtk 8.2.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e8055aff7604f7e49265ea33756881b", + "name": "mayavi", + "sha256": "7b7c24e2c1abc0f16856309a2959f177120c7e8f32b16a486f5db8c9d33c0866", + "size": 13939629, + "subdir": "linux-64", + "timestamp": 1559060934784, + "version": "4.6.2" + }, + "mayavi-4.6.2-py37hcf37d21_4.tar.bz2": { + "build": "py37hcf37d21_4", + "build_number": 4, + "depends": [ + "apptools", + "envisage", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy >=1.11.3,<2.0a0", + "pyqt >=4,<6", + "python >=3.7,<3.8.0a0", + "setuptools", + "traitsui", + "vtk 8.2.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a6185a597282dcb80b0cee23daa274a", + "name": "mayavi", + "sha256": "4d9020fb29a8d8574573744a0cb650124adbd10e325a5b0aeddca4462b2ef5e3", + "size": 13805439, + "subdir": "linux-64", + "timestamp": 1559061022718, + "version": "4.6.2" + }, + "mayavi-4.7.1-py36h94891b3_2.tar.bz2": { + "build": "py36h94891b3_2", + "build_number": 2, + "depends": [ + "apptools", + "envisage", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy >=1.14.6,<2.0a0", + "pyqt >=4,<6", + "python >=3.6,<3.7.0a0", + "setuptools", + "traitsui", + "vtk 8.2.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6823508de352e77654c0f0796cf66acf", + "name": "mayavi", + "sha256": "1e74628ee63b130746035d12de896bf0c4b83e1c521e93975274ce1b89bd5383", + "size": 14008027, + "subdir": "linux-64", + "timestamp": 1585309539589, + "version": "4.7.1" + }, + "mayavi-4.7.1-py37h94891b3_2.tar.bz2": { + "build": "py37h94891b3_2", + "build_number": 2, + "depends": [ + "apptools", + "envisage", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy >=1.14.6,<2.0a0", + "pyqt >=4,<6", + "python >=3.7,<3.8.0a0", + "setuptools", + "traitsui", + "vtk 8.2.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "92a79ab479cf9ce610c683ac54d3f586", + "name": "mayavi", + "sha256": "02efdf5a156d08e5503fa2986b32c35a6c6ce6c759f3ed06ff732fa005a9b49d", + "size": 13861835, + "subdir": "linux-64", + "timestamp": 1585309542336, + "version": "4.7.1" + }, + "mccabe-0.6.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f02be6aa4283edf1da99fd0a72f35a9", + "name": "mccabe", + "sha256": "69fdf44fce328e950ba4f7182bb8acb5e3f0f5bd8437cf0251c9f66f38d4f8ec", + "size": 13547, + "subdir": "linux-64", + "timestamp": 1530812495236, + "version": "0.6.1" + }, + "mccabe-0.6.1-py27h0e7c7be_1.tar.bz2": { + "build": "py27h0e7c7be_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e18d36f58ff68c9d56baccccf6e173a", + "name": "mccabe", + "sha256": "0731b475c8a53bc392f15552299552ba2f486e66ba14e1b33d8c01c75352f983", + "size": 13245, + "subdir": "linux-64", + "timestamp": 1505743111077, + "version": "0.6.1" + }, + "mccabe-0.6.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7966832d9c10d5393d94d24f57e4a9c4", + "name": "mccabe", + "sha256": "83c672b07f5062cace5cadc6f79ce9f7f96e735fe24124a8167475c076870ee4", + "size": 14303, + "subdir": "linux-64", + "timestamp": 1640806440553, + "version": "0.6.1" + }, + "mccabe-0.6.1-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "732869c91132416fb36262136e31bfc9", + "name": "mccabe", + "sha256": "658613d8a47b4fb7bc7e3b083ac5e96387d1dd7e473ac8709cbde4552f429001", + "size": 15017, + "subdir": "linux-64", + "timestamp": 1659535422117, + "version": "0.6.1" + }, + "mccabe-0.6.1-py311h06a4308_2.tar.bz2": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c67da848d25cb0532a344f5b94fbf22", + "name": "mccabe", + "sha256": "b2f97f824401b1876e429b33e4df90a7d0facbe1fb4f18b46e7e82e28cd6ea28", + "size": 18124, + "subdir": "linux-64", + "timestamp": 1676825304938, + "version": "0.6.1" + }, + "mccabe-0.6.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee634d14c01c6a929a9c79fb0b9c58a4", + "name": "mccabe", + "sha256": "e143c1ff83fb9b755f37e6637b6567f629a1014406d00e63652306cf9e8a5ea8", + "size": 13949, + "subdir": "linux-64", + "timestamp": 1535130107791, + "version": "0.6.1" + }, + "mccabe-0.6.1-py35hd8c1f23_1.tar.bz2": { + "build": "py35hd8c1f23_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9dc91eb4fe9d1fb9ce61a2793578e996", + "name": "mccabe", + "sha256": "3d235e01e91d56f887e04c411cdc82010f30b29e4a45775190e84295657cd51e", + "size": 13591, + "subdir": "linux-64", + "timestamp": 1505743122954, + "version": "0.6.1" + }, + "mccabe-0.6.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee19410d2a67912eb8f24b03783685bb", + "name": "mccabe", + "sha256": "daaf1d08dd1fb885a1bf9fca30e3a3d993acdd5ccfa5acd2206d1ad4de266e67", + "size": 13845, + "subdir": "linux-64", + "timestamp": 1530812545198, + "version": "0.6.1" + }, + "mccabe-0.6.1-py36h5ad9710_1.tar.bz2": { + "build": "py36h5ad9710_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14cb40d3072395fd48e67b50e2bac549", + "name": "mccabe", + "sha256": "cdbfdaebe7581f0668f2b746c333f643b2fde162f87dd1cc14eed7a42d48257e", + "size": 13572, + "subdir": "linux-64", + "timestamp": 1505743134933, + "version": "0.6.1" + }, + "mccabe-0.6.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d7310d6e562fb9b17ccc2ac0bede407", + "name": "mccabe", + "sha256": "33cf6cc50034adcf3e92c3bf9e68f17d8ad15beb46d0f6e422d5067eef5d58e1", + "size": 13894, + "subdir": "linux-64", + "timestamp": 1530812519822, + "version": "0.6.1" + }, + "mccabe-0.6.1-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fdf8738d3ae425c5eb84e2c6bb2b51f5", + "name": "mccabe", + "sha256": "c9c339ba5d6a0ddd10f015030fad730d8c3671bfe460c427730f9fa2aba131a6", + "size": 14924, + "subdir": "linux-64", + "timestamp": 1659535455073, + "version": "0.6.1" + }, + "mccabe-0.6.1-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2db2b0299b2b89a7ace2b6602efdce40", + "name": "mccabe", + "sha256": "42189139a13661d9c02277eae72c8714560c855c033cfc01e813ad831383d4a3", + "size": 14402, + "subdir": "linux-64", + "timestamp": 1573489052083, + "version": "0.6.1" + }, + "mccabe-0.6.1-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d40eaa51a7ecc14639870728ae197019", + "name": "mccabe", + "sha256": "713e3c907439711d535c6d2ac0308576dd625912d20900da73b05ed3a29a4cbe", + "size": 14921, + "subdir": "linux-64", + "timestamp": 1659535520351, + "version": "0.6.1" + }, + "mccabe-0.6.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f135134aa448bc4881d441c8677dcc9", + "name": "mccabe", + "sha256": "487cca72a918350666b1f4b004ec568a37193e27d536148f81037add51ae239b", + "size": 15943, + "subdir": "linux-64", + "timestamp": 1607574091060, + "version": "0.6.1" + }, + "mccabe-0.6.1-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5a009b0fdea6ea37ca324bbc4920fef2", + "name": "mccabe", + "sha256": "ffad4109029373c9cfa143247daf3d09c0eccb33e6d0f2aaa45d161dda3337f0", + "size": 14973, + "subdir": "linux-64", + "timestamp": 1659535487366, + "version": "0.6.1" + }, + "mdit-py-plugins-0.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "markdown-it-py >=1.0.0,<3.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d626377d7aab29eb38ea16c05dbd103", + "name": "mdit-py-plugins", + "sha256": "c483a73b6b3c2bd3a0f1fbb8a2fefbba96cc3e3cc52d2a6ce121ceeecb7fa61b", + "size": 53361, + "subdir": "linux-64", + "timestamp": 1659721352029, + "version": "0.3.0" + }, + "mdit-py-plugins-0.3.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "markdown-it-py >=1.0.0,<3.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e5dc6b4a5b8e02733ce3bc9e9198a8d2", + "name": "mdit-py-plugins", + "sha256": "c9ba2f9c83820712dd97d6a1b54a1215b9820a0be02ac82380b4c50911b9400c", + "size": 67750, + "subdir": "linux-64", + "timestamp": 1676837123613, + "version": "0.3.0" + }, + "mdit-py-plugins-0.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "markdown-it-py >=1.0.0,<3.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c37a9c5339205adefcd618d1aff970fd", + "name": "mdit-py-plugins", + "sha256": "d5936885df5ae582821e6de2dc33a32eeade55596231177ff2bbbc07b7daa492", + "size": 52535, + "subdir": "linux-64", + "timestamp": 1659721281803, + "version": "0.3.0" + }, + "mdit-py-plugins-0.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "markdown-it-py >=1.0.0,<3.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8593029209b6a8d3d59e1f3a65aba7be", + "name": "mdit-py-plugins", + "sha256": "94268e8c43edb70b0d18d70e66970f3159f1e05e9be92b477064316f1f1f62d2", + "size": 52837, + "subdir": "linux-64", + "timestamp": 1659721378603, + "version": "0.3.0" + }, + "mdit-py-plugins-0.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "markdown-it-py >=1.0.0,<3.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "975a78ae464b1cd9541c498fd8299858", + "name": "mdit-py-plugins", + "sha256": "0dd0157d3d6c591a1087f7b96993412ac9194b7ea0ee2d667b1dc1c587eb0e33", + "size": 52857, + "subdir": "linux-64", + "timestamp": 1659721312521, + "version": "0.3.0" + }, + "mdp-3.5-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "a041d4e8fe53094c4bc50015abb7ff57", + "name": "mdp", + "sha256": "42395ae9a0095d86f3024821e2365ccd1d94cf9590f8c649bf772d99ebb59493", + "size": 528992, + "subdir": "linux-64", + "timestamp": 1537208279158, + "version": "3.5" + }, + "mdp-3.5-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "2028c38946bf46da5ca597810786c634", + "name": "mdp", + "sha256": "673868c2634080bb54b7fe0cad0bbe9a3ca81a39af82f64cf85e82e729ac6493", + "size": 566843, + "subdir": "linux-64", + "timestamp": 1640809525117, + "version": "3.5" + }, + "mdp-3.5-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "d4aba8551be84603c68e3152b9dc7f30", + "name": "mdp", + "sha256": "82ac541e0ee3c0210b054e8aa9689130ea90f2837a2360331f0371c56657ecbf", + "size": 541743, + "subdir": "linux-64", + "timestamp": 1537208300788, + "version": "3.5" + }, + "mdp-3.5-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "6c210a75f1bfeddddc47a6ce27b7d5d4", + "name": "mdp", + "sha256": "41d0b78b718fba5b6a95e1b0969992176e1985220ad7bd894db9bb5197572ad7", + "size": 541410, + "subdir": "linux-64", + "timestamp": 1537208304936, + "version": "3.5" + }, + "mdp-3.5-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "3fa1cba8c8f09abff6d35a967c16c8b9", + "name": "mdp", + "sha256": "1c215455cf0078912209c6e66c6427c41b3eb1c4767fed34ed310a6c77d8b4cb", + "size": 790408, + "subdir": "linux-64", + "timestamp": 1614009641098, + "version": "3.5" + }, + "mdp-3.5-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "503d3d2e813403f554bff5879e7af346", + "name": "mdp", + "sha256": "3b778732e0ba2eb6328d14f4c25e367cbf728e680c6c70c3c6517b11fb70d01b", + "size": 540525, + "subdir": "linux-64", + "timestamp": 1537208214061, + "version": "3.5" + }, + "mdp-3.5-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "6942cbd18222a6db30aea9847a7a8dc4", + "name": "mdp", + "sha256": "27bdbac3c3b6178fa299f3a33b8df09fae0f2c98aecdfbd75761fdeb35b80005", + "size": 784752, + "subdir": "linux-64", + "timestamp": 1614009639231, + "version": "3.5" + }, + "mdp-3.5-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "d531766d5fcd254f6cccacd0fc88d040", + "name": "mdp", + "sha256": "0cdf17286e796f29e33e517e6ff49ac7ec23d7383ab030e1e4b68d8b033aeef4", + "size": 565580, + "subdir": "linux-64", + "timestamp": 1573469741875, + "version": "3.5" + }, + "mdp-3.5-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "5b41d901b3d78df117035c850b257f4b", + "name": "mdp", + "sha256": "5699587551d7260a163764595bf2fa5b8bad728b9f3a2cde87a59f71d42413b7", + "size": 789574, + "subdir": "linux-64", + "timestamp": 1614009656298, + "version": "3.5" + }, + "mdp-3.5-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "51ab89974bb703917d243fd22d73244f", + "name": "mdp", + "sha256": "bde5c12be627ddfc36dd4ee43d2fd469278146318207fc331cf80c5f1fcde902", + "size": 788151, + "subdir": "linux-64", + "timestamp": 1614009618492, + "version": "3.5" + }, + "mdurl-0.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "542c95fd4b9171b036a2d501196210be", + "name": "mdurl", + "sha256": "ae02f23d333380a31ef4bb192baa4e145524e81ad3a53e0383e38d632979cc22", + "size": 18793, + "subdir": "linux-64", + "timestamp": 1659716070293, + "version": "0.1.0" + }, + "mdurl-0.1.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22ac3bc22b68fef4c1f3f6ab3c7bfe0b", + "name": "mdurl", + "sha256": "1a5141ef0de1cbff816f96bb4b212a40606e2fc11301a4c1358c8d63a6b2b027", + "size": 23040, + "subdir": "linux-64", + "timestamp": 1676827301164, + "version": "0.1.0" + }, + "mdurl-0.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "301fe1b6e35b5fb36c13dd215f1b3934", + "name": "mdurl", + "sha256": "e223d57fe50ec525e5fea22d84bc45cae1c015368a63f96722d1240a1147eb94", + "size": 18714, + "subdir": "linux-64", + "timestamp": 1659716142364, + "version": "0.1.0" + }, + "mdurl-0.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aaca094871f81d9bfe2f90de56ddc1a8", + "name": "mdurl", + "sha256": "61b926c1bed9903ed02ec83433559f0dfa63134b1ebad1796f41dcc7341e2d3b", + "size": 18734, + "subdir": "linux-64", + "timestamp": 1659716119261, + "version": "0.1.0" + }, + "mdurl-0.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "19932cd4f64628bf6db1accebdaf7eac", + "name": "mdurl", + "sha256": "cae67d22945f16e1034fc53144eea8bb67f2fecf6d60b22c43822094b6ca2b49", + "size": 18689, + "subdir": "linux-64", + "timestamp": 1659716096534, + "version": "0.1.0" + }, + "meld3-1.0.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "5df2e2b39ff852db2aee42f74817494b", + "name": "meld3", + "sha256": "06e87db6709a6dd01bdbc810df6248623dc1e7b513a4cf72192927aad179a158", + "size": 47609, + "subdir": "linux-64", + "timestamp": 1537208770426, + "version": "1.0.2" + }, + "meld3-1.0.2-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "042178f2a7fc0f2885230e850b90b6e6", + "name": "meld3", + "sha256": "d2b1a2a8317abc8e5732fa9531921310a78b2374be9b6cb82c4ae7d0b5b8bcee", + "size": 48924, + "subdir": "linux-64", + "timestamp": 1537208804028, + "version": "1.0.2" + }, + "meld3-1.0.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "64e301897c39f1856f39e3a5dee190a6", + "name": "meld3", + "sha256": "6622521aef45504a817e7769116dbf060c5f49658de6c49abaa7070fb220ac6f", + "size": 48770, + "subdir": "linux-64", + "timestamp": 1537208794172, + "version": "1.0.2" + }, + "meld3-1.0.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "6732b5b9110a2af4d26c86295df70ded", + "name": "meld3", + "sha256": "741093b1f2d99993230180ed6265946ee57fe515a0c269b809ee50bda61c9d79", + "size": 48741, + "subdir": "linux-64", + "timestamp": 1537208718025, + "version": "1.0.2" + }, + "memory_profiler-0.47-py27hd3766c3_0.tar.bz2": { + "build": "py27hd3766c3_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b27ad7b5f29ea3fc6b796f3228086fbe", + "name": "memory_profiler", + "sha256": "d2c324723070e4be28d8a86f9397467cfdd50f0a81dba7e844da6b81be0848df", + "size": 37336, + "subdir": "linux-64", + "timestamp": 1508439461142, + "version": "0.47" + }, + "memory_profiler-0.47-py35hadf4a1a_0.tar.bz2": { + "build": "py35hadf4a1a_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "db036ec20ae8b253c32dc1f7f214f693", + "name": "memory_profiler", + "sha256": "f358e5b6d0f86aa9e0ee9cd0189387ce226102f16e7d4915b878a1365352650a", + "size": 37813, + "subdir": "linux-64", + "timestamp": 1508439456096, + "version": "0.47" + }, + "memory_profiler-0.47-py36hfa32046_0.tar.bz2": { + "build": "py36hfa32046_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6f1964714b4979125f81402f9da79711", + "name": "memory_profiler", + "sha256": "f2515b3e29f0f164172503c317be03e01df595401b14220abe46ad707221beb4", + "size": 37733, + "subdir": "linux-64", + "timestamp": 1508439454332, + "version": "0.47" + }, + "memory_profiler-0.52.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8fa965d6b2cdd0c4db8e5dc1219daece", + "name": "memory_profiler", + "sha256": "2ca4d21ae3f1494d73cbd44ee4c00a7cbd261f96698a9d889047f27a61e97330", + "size": 38504, + "subdir": "linux-64", + "timestamp": 1519671808089, + "version": "0.52.0" + }, + "memory_profiler-0.52.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5b50f2d367ab1745ea0089fc987f323c", + "name": "memory_profiler", + "sha256": "756bb9e5b62dcf745f31642044882b7c8b066fff0f2c996c4cdb91943b1b8f80", + "size": 38906, + "subdir": "linux-64", + "timestamp": 1519671867540, + "version": "0.52.0" + }, + "memory_profiler-0.52.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "58623e217d6cd6d6b0fe78c8e694e88e", + "name": "memory_profiler", + "sha256": "b613b62ee76f3e3cd05796fd37f634f6471f3793ca1ffd7210d7ee9c99daa2b8", + "size": 38825, + "subdir": "linux-64", + "timestamp": 1519671852307, + "version": "0.52.0" + }, + "memory_profiler-0.52.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7a88b3c5113b4d7753209c3e1411f3a3", + "name": "memory_profiler", + "sha256": "ddc7fe8a2739f253a3933f4339b666a044287711ea43780112673406a925beb5", + "size": 38753, + "subdir": "linux-64", + "timestamp": 1530899160650, + "version": "0.52.0" + }, + "memory_profiler-0.54.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7a5dc38cf43436e2d8f5e67b6189095c", + "name": "memory_profiler", + "sha256": "99ee96162c8a5e0363b63bebe5ec050c6be65255f67d0958ec6aafe8ce2d92ee", + "size": 44656, + "subdir": "linux-64", + "timestamp": 1535498533597, + "version": "0.54.0" + }, + "memory_profiler-0.54.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "48b4b8f85161e7cb65667ee24c85b2d9", + "name": "memory_profiler", + "sha256": "81ea5bc51b1de6d12f586275a5ad7ea998e27019337c67a65b572ce4d661a133", + "size": 45166, + "subdir": "linux-64", + "timestamp": 1535498555179, + "version": "0.54.0" + }, + "memory_profiler-0.54.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f99bb3d82933589d68be776721b22a53", + "name": "memory_profiler", + "sha256": "48c21ccef51fd42624cc354b95c4f1f861fc2eab41df05224d53ea9149ef3790", + "size": 45003, + "subdir": "linux-64", + "timestamp": 1535498519280, + "version": "0.54.0" + }, + "memory_profiler-0.54.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "44e1d07d4ca736031441f3c0884c3410", + "name": "memory_profiler", + "sha256": "a5fa71e69d7f087274db0575ab57beca135172e2074d36defe86cc9f0be62262", + "size": 44970, + "subdir": "linux-64", + "timestamp": 1535498561632, + "version": "0.54.0" + }, + "memory_profiler-0.55.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "30331be4500a1a91037849fc9fb8db3a", + "name": "memory_profiler", + "sha256": "6115d01d0e61b8288590972fb6e1428d47fe698fd82afbc4d7942a1b2fcaf72e", + "size": 46386, + "subdir": "linux-64", + "timestamp": 1545113182771, + "version": "0.55.0" + }, + "memory_profiler-0.55.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b65fb01149e7377d8e4ee3bda1abf424", + "name": "memory_profiler", + "sha256": "91b1e6c231d8de8b4ae710b17c1e20f776a8333192c30ae3f820369646fe3bc3", + "size": 46647, + "subdir": "linux-64", + "timestamp": 1545113216388, + "version": "0.55.0" + }, + "memory_profiler-0.55.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "855bebd9eae6170b27010e6206be9c0e", + "name": "memory_profiler", + "sha256": "7db13f12a9b38a545f379109626ef1067b533782437d7a80aca6809132b6fdcb", + "size": 46725, + "subdir": "linux-64", + "timestamp": 1545113185921, + "version": "0.55.0" + }, + "mercurial-4.3.3-py27h31da970_0.tar.bz2": { + "build": "py27h31da970_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "64f0233b81f0cc351ef379dde93996b2", + "name": "mercurial", + "sha256": "15b4fad61bbf070380f9917859f9171ad624af79cb753820cb7717e70ff615a8", + "size": 2558140, + "subdir": "linux-64", + "timestamp": 1508506951099, + "version": "4.3.3" + }, + "mercurial-4.5-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "7635e65efe22520c017104d2141643ca", + "name": "mercurial", + "sha256": "6c477d691628532f5770ed959d3dc32aa74e0f406f98848a78bbfabaecc5469e", + "size": 2754667, + "subdir": "linux-64", + "timestamp": 1519147402240, + "version": "4.5" + }, + "mercurial-4.5.2-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "6b7856dc5e4f6dfc3964d21f08776dfc", + "name": "mercurial", + "sha256": "6ad26f851376ccfc756c883ee1f4a24fa75e249ec3243baedb9079d526e7f3fc", + "size": 4135510, + "subdir": "linux-64", + "timestamp": 1522800370654, + "version": "4.5.2" + }, + "mercurial-4.5.3-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "f968f5e9955e756be3d54a293da27809", + "name": "mercurial", + "sha256": "d2d0850212433107cb7c0d8b88f3876f61181dce6d72c4e6a5b73b6a9c7ac6e5", + "size": 4136216, + "subdir": "linux-64", + "timestamp": 1524159687770, + "version": "4.5.3" + }, + "mercurial-4.6-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "434ddc4f812bf9f302127aa62eda0e4f", + "name": "mercurial", + "sha256": "43791fcb72a8de976b637bb81054e4f6577440e4e5e7d23fa8a6248a5ad4d50a", + "size": 4587681, + "subdir": "linux-64", + "timestamp": 1527691667533, + "version": "4.6" + }, + "mercurial-4.6.1-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "35d2db6c92f8df0afb936e8ada1e51b7", + "name": "mercurial", + "sha256": "ce5b5e88db438b3905e93f03e107c1310a2a073ca637651b010aa598cf8e231a", + "size": 4591313, + "subdir": "linux-64", + "timestamp": 1529969537311, + "version": "4.6.1" + }, + "mercurial-4.6.2-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "c4099d6918aa2bbd5cfd69447bf34cd8", + "name": "mercurial", + "sha256": "ad5295a0661b12ff62672c0647a717faca403acbe8b38b196c558ffcbe585e15", + "size": 4590082, + "subdir": "linux-64", + "timestamp": 1532856519941, + "version": "4.6.2" + }, + "mercurial-4.7-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "dbd393047f90b6f6b9d6c6b519a6c7b8", + "name": "mercurial", + "sha256": "6edf3d78e20f1baef9c96ef937428f1cbd0d36162c160a657f64105f2e238c98", + "size": 4635696, + "subdir": "linux-64", + "timestamp": 1534830078787, + "version": "4.7" + }, + "mercurial-4.7.2-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "5fce75b4870cb2adac3a16e1be66ead9", + "name": "mercurial", + "sha256": "16664f698b94a71a27df09ba92c135377ce38fa30f5f29f10bf03b11fc387a32", + "size": 4552401, + "subdir": "linux-64", + "timestamp": 1540059284865, + "version": "4.7.2" + }, + "mercurial-4.8.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "d4882564189fd134686a6801d35b09fe", + "name": "mercurial", + "sha256": "5eba70d22f610e9e6ab48e6608890bb83adbed089e0cf4d9ec719c919e57a2ba", + "size": 4818793, + "subdir": "linux-64", + "timestamp": 1547237942056, + "version": "4.8.1" + }, + "mercurial-4.8.2-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "ec404690eccadbebdf8adddd262a42fb", + "name": "mercurial", + "sha256": "b08427e62f92a245ecbd15846eb9212d01d0a5947173ed0b9761f55180e7ac00", + "size": 4817490, + "subdir": "linux-64", + "timestamp": 1547751410839, + "version": "4.8.2" + }, + "meson-0.45.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2", + "md5": "c9acf2b903d980b3354c7d303ea6da4a", + "name": "meson", + "sha256": "2182587a5815c8938fdf9d3641fb3173253fb69e00356069fa067976aef2defd", + "size": 506891, + "subdir": "linux-64", + "timestamp": 1522872874103, + "version": "0.45.0" + }, + "meson-0.45.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "5bc0d2359f3e92e293d70e755679dd06", + "name": "meson", + "sha256": "a98190d49123ac5905263a4767c118668a45a5470f758c144b6f213b4b111755", + "size": 502848, + "subdir": "linux-64", + "timestamp": 1522872899590, + "version": "0.45.0" + }, + "meson-0.46.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2", + "md5": "a7730e592044840ccdd8016fe44a7f25", + "name": "meson", + "sha256": "8971741ecd75398e37d84cc04bccd1f04b9281c981e9eb566ff0576fb7902425", + "size": 538009, + "subdir": "linux-64", + "timestamp": 1528216393128, + "version": "0.46.1" + }, + "meson-0.46.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "ba23418b16fc0d7d4dadc83d152c90c6", + "name": "meson", + "sha256": "e2d331cc500528f7b0c4e3a6714f6c2f8eeefd24aea1762e39d89a31fd29f010", + "size": 535527, + "subdir": "linux-64", + "timestamp": 1528216372315, + "version": "0.46.1" + }, + "meson-0.46.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2", + "md5": "99b307a26cc0e4b503214ef6d4c0975a", + "name": "meson", + "sha256": "a09ce8ca3a5239edcf609911aaad071d9fce0d07d88bd17587e3b10d05d6c588", + "size": 535998, + "subdir": "linux-64", + "timestamp": 1530899197589, + "version": "0.46.1" + }, + "meson-0.47.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2", + "md5": "9c2975217dadb91852bdbfa471034fdc", + "name": "meson", + "sha256": "65985382b9e8515cc84140a5dd0b0a9a3794b30cb602d4748b67cbcdb1ad54fa", + "size": 569447, + "subdir": "linux-64", + "timestamp": 1532528336807, + "version": "0.47.1" + }, + "meson-0.47.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "34da9ebecb0a93faab290b8127455c59", + "name": "meson", + "sha256": "e18832a41e01770ee93a131dc3d53b98c630ba1dba97dc335e291bc9bc2f2fe0", + "size": 566654, + "subdir": "linux-64", + "timestamp": 1532528265909, + "version": "0.47.1" + }, + "meson-0.47.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2", + "md5": "5052d7eeabba90daea5ca5e124a55961", + "name": "meson", + "sha256": "4be5613d5624e60b7e3bce526f1bffbd07a30f1b59750a5b2513b37e489ad72b", + "size": 567474, + "subdir": "linux-64", + "timestamp": 1532528335766, + "version": "0.47.1" + }, + "meson-0.47.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2", + "md5": "83fe13a5b7afa9985529cea6bd3081a7", + "name": "meson", + "sha256": "a1bf742cbe49188ef1e6dda84d789db614a0d08af9a1ba047ddb12a4d2d2d609", + "size": 580270, + "subdir": "linux-64", + "timestamp": 1535385372100, + "version": "0.47.2" + }, + "meson-0.47.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "8931c302307cc2afe89767ec6d0acdcc", + "name": "meson", + "sha256": "252fddeb54c0e5bcb56e2b0cb6f3ce26521d956a07e3d613861bcf276ff7465f", + "size": 578801, + "subdir": "linux-64", + "timestamp": 1535385185959, + "version": "0.47.2" + }, + "meson-0.47.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2", + "md5": "75efbd784f25b5edc6bcfc6811169c2d", + "name": "meson", + "sha256": "ef02552da9146e306fa9695bd2aaf61a704afb763ab8475f1350a8209a370790", + "size": 579338, + "subdir": "linux-64", + "timestamp": 1535385212641, + "version": "0.47.2" + }, + "meson-0.48.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2", + "md5": "3351c3638c943846a11f0c643bcde15f", + "name": "meson", + "sha256": "6253f0990adce108fff3a8cc136e6f19b782ec432d0330984c550c3b76aa1678", + "size": 613688, + "subdir": "linux-64", + "timestamp": 1538232401475, + "version": "0.48.0" + }, + "meson-0.48.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "e662c6a1b6b3633f5d382e7dec91ef0a", + "name": "meson", + "sha256": "240b09ffeb2cd939136a0e00e4cf045960985c2b1cb4c6f26615fb32739e706c", + "size": 604080, + "subdir": "linux-64", + "timestamp": 1538232404877, + "version": "0.48.0" + }, + "meson-0.48.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2", + "md5": "a00c73b99d9d22a366fa4fe9fed36084", + "name": "meson", + "sha256": "b37f2e0cc7154873b2025f983c0c48e113a17375414eda2a47ce5e1a9fd299c8", + "size": 603897, + "subdir": "linux-64", + "timestamp": 1538232360479, + "version": "0.48.0" + }, + "meson-0.48.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "d05bdb5a36506ae0a5423a6e863794d2", + "name": "meson", + "sha256": "b604917f597799749c885a882e7b5ceec5edf4de3606fe5a07173ebdbff6dce1", + "size": 606470, + "subdir": "linux-64", + "timestamp": 1540238468859, + "version": "0.48.1" + }, + "meson-0.48.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2", + "md5": "e5842700eda481456d7ab4946423887a", + "name": "meson", + "sha256": "dd11d9870b74f70fad0c8737351ce6a6398d4675fec77f025a91262d0d08aadc", + "size": 607966, + "subdir": "linux-64", + "timestamp": 1540238463787, + "version": "0.48.1" + }, + "meson-0.48.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "632f3deeaa166cd46bdc30792bcf2b31", + "name": "meson", + "sha256": "ca16595e1482d51e7184ff112e6009230e5ebbfe8f0fd9f5a3eecca26d692c02", + "size": 609809, + "subdir": "linux-64", + "timestamp": 1542082294961, + "version": "0.48.2" + }, + "meson-0.48.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2", + "md5": "edf71eb41d8730453b1faa361f1d8637", + "name": "meson", + "sha256": "5b8c40ef48ce0c72275ee03606add46b59debdd9b3f6aae075746906ca76bd80", + "size": 610968, + "subdir": "linux-64", + "timestamp": 1542082285817, + "version": "0.48.2" + }, + "meson-0.49.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "b90ec22cc4cec02ce40379a6da13a708", + "name": "meson", + "sha256": "dd93bdbffc7ca79e667bd7e5d9c63f2a8bd9d654b67963339eb04f521abef252", + "size": 658241, + "subdir": "linux-64", + "timestamp": 1545081672239, + "version": "0.49.0" + }, + "meson-0.49.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2", + "md5": "9baa7090a9d6679daf1c03866734b27d", + "name": "meson", + "sha256": "84424ec74b064740ea44655007e9fc51e127ebe64fc1873271516577d8ec3819", + "size": 656326, + "subdir": "linux-64", + "timestamp": 1545081656729, + "version": "0.49.0" + }, + "meson-0.49.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "9e91a28e52a46d51d53d6015747d31b0", + "name": "meson", + "sha256": "d81515f32f0af9b7215d87bbb3174e8f1b54344cc552dc09c84f20c2639108c6", + "size": 659959, + "subdir": "linux-64", + "timestamp": 1549332119027, + "version": "0.49.1" + }, + "meson-0.49.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2", + "md5": "3fac1d001c56b20b71047b489f629c5a", + "name": "meson", + "sha256": "208c4e6fe0eaa8e30709bc0f88a53ed7260800bb0a2532932546b050e439216c", + "size": 658269, + "subdir": "linux-64", + "timestamp": 1549332069191, + "version": "0.49.1" + }, + "meson-0.49.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "2100300b78aa785c150e778e947da9a9", + "name": "meson", + "sha256": "a769aca0f9b2be0f90cf23a36dd4a6ef4600d761800730c45f0bf8a73c066688", + "size": 659077, + "subdir": "linux-64", + "timestamp": 1551142307637, + "version": "0.49.2" + }, + "meson-0.49.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2", + "md5": "c761906c6bb9524f6b8710fcd7256e55", + "name": "meson", + "sha256": "16bc8656f35689bfcf9b0c50232d0dd763a83dd9f87c782559fa8d14006247cf", + "size": 662330, + "subdir": "linux-64", + "timestamp": 1551142278033, + "version": "0.49.2" + }, + "meson-0.62.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d153f3bdb7de60f60dc76c89c146204a", + "name": "meson", + "sha256": "71996b6a12521490af4d150d25f586ea7ca7bdb2caff3fd6554553215df6351c", + "size": 1305433, + "subdir": "linux-64", + "timestamp": 1660064925161, + "version": "0.62.2" + }, + "meson-0.62.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1ca8f2e614d12627d8e3cd36108de906", + "name": "meson", + "sha256": "e592fc376694148e39152e1dca4dd43dd8d41c3185f772c6002d32af16006460", + "size": 1835733, + "subdir": "linux-64", + "timestamp": 1676823379006, + "version": "0.62.2" + }, + "meson-0.62.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7a0c48a56204535393678bef68b116bd", + "name": "meson", + "sha256": "8cb3321c352436a1d5544b90ad5f645e20519ce05ae08705b74c15ae6464b150", + "size": 1284744, + "subdir": "linux-64", + "timestamp": 1660064957947, + "version": "0.62.2" + }, + "meson-0.62.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2585ccdf66a3f6b881e79f9a29e8e9ac", + "name": "meson", + "sha256": "f501438b91719bbdd9893acd0659082b92678579334ec44d688d27bb0fa565d3", + "size": 1291820, + "subdir": "linux-64", + "timestamp": 1660064990525, + "version": "0.62.2" + }, + "meson-0.62.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2cb01b55a84097861f8f5e01eae41352", + "name": "meson", + "sha256": "cdba848db0e5e8e0a250249d6e65ea09207b87ee04a4b292442abd9e9a15c528", + "size": 1291366, + "subdir": "linux-64", + "timestamp": 1660064879188, + "version": "0.62.2" + }, + "meson-0.64.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "64b41630c8b88a0dde91625686f24940", + "name": "meson", + "sha256": "434ac4ab330f7406c229906d7213f88c68a26f233b27c1dad9afbb1412608854", + "size": 1356008, + "subdir": "linux-64", + "timestamp": 1674658514361, + "version": "0.64.1" + }, + "meson-0.64.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e405b24b192b43a98d8789fb1ab79377", + "name": "meson", + "sha256": "1372c48d944319ed5a2092902120b8900cfc72b6692e7f88687dca27acccc3d3", + "size": 1325003, + "subdir": "linux-64", + "timestamp": 1674658545766, + "version": "0.64.1" + }, + "meson-0.64.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "426e80e79db67deb0f2d6a6536bad81d", + "name": "meson", + "sha256": "a79cdbcdc803227a6804be9217c2d400119e1a7473384e973999bb26222614da", + "size": 1336900, + "subdir": "linux-64", + "timestamp": 1674658577091, + "version": "0.64.1" + }, + "meson-0.64.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d65b3a68b97a32b1f50e353fce233e38", + "name": "meson", + "sha256": "8efff768a7fa4fb2364c6e6955c9040afb8063f68fe82b1e9b13e50060062a60", + "size": 1333926, + "subdir": "linux-64", + "timestamp": 1674658608487, + "version": "0.64.1" + }, + "meson-1.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "pip", + "python >=3.10,<3.11.0a0", + "setuptools", + "wheel" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "56b8dccc49cab451cf949aaa38c1904e", + "name": "meson", + "sha256": "001b5cd8ef2df3d2a6b5950e30e627aa45b465508f5e419c01dd3b98587b0b4b", + "size": 1363340, + "subdir": "linux-64", + "timestamp": 1678870616695, + "version": "1.0.1" + }, + "meson-1.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "pip", + "python >=3.11,<3.12.0a0", + "setuptools", + "wheel" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8c8a3ffbc3abfa51c8789aee436f3030", + "name": "meson", + "sha256": "8d0879127a3d1e379334f305f7498ab5793bfe4b239137b992a185e9810b3d23", + "size": 1877832, + "subdir": "linux-64", + "timestamp": 1679336653730, + "version": "1.0.1" + }, + "meson-1.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "pip", + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0836b89afc826980c23123b972639fa3", + "name": "meson", + "sha256": "811f97a2770695be57ba7d76c78d3893a69fb8e30afae5a4bce3b4d311050541", + "size": 1337474, + "subdir": "linux-64", + "timestamp": 1678870579817, + "version": "1.0.1" + }, + "meson-1.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "pip", + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cfaf892f45aac41fec67017bbf351425", + "name": "meson", + "sha256": "cb0bb49fed2166025089242e293bc33c68b9c52d0d8ea53ad2f3d028f1f5ef9f", + "size": 1343421, + "subdir": "linux-64", + "timestamp": 1678870543335, + "version": "1.0.1" + }, + "meson-python-0.12.1-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "meson >=0.63.3", + "ninja", + "pyproject-metadata >=0.6.1", + "python >=3.10,<3.11.0a0", + "tomli >=1.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2edc80b0a1d0f58ecc8ebee467597204", + "name": "meson-python", + "sha256": "fb08dd7f0108f74af68b0344e537a9e8dcb57284e3bc42fb83640ccb59cf711c", + "size": 58466, + "subdir": "linux-64", + "timestamp": 1680550570546, + "version": "0.12.1" + }, + "meson-python-0.12.1-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "meson >=0.63.3", + "ninja", + "pyproject-metadata >=0.6.1", + "python >=3.11,<3.12.0a0", + "tomli >=1.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "969b1f2d92f5be16fbb4284a6c7a67a6", + "name": "meson-python", + "sha256": "f1aba2b79020b2ca88bd0810971f8393265ee007fcd1f8b4ce13156582919c7b", + "size": 72214, + "subdir": "linux-64", + "timestamp": 1680550443546, + "version": "0.12.1" + }, + "meson-python-0.12.1-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "meson >=0.63.3", + "ninja", + "pyproject-metadata >=0.6.1", + "python >=3.8,<3.9.0a0", + "tomli >=1.0.0", + "typing-extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb9798b9d728ac51a44201cc235da8cb", + "name": "meson-python", + "sha256": "bb0e31d83f03a548cdf8a425c778523059a6b14dc24de9191a6622865c5f3baf", + "size": 57964, + "subdir": "linux-64", + "timestamp": 1680550487053, + "version": "0.12.1" + }, + "meson-python-0.12.1-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "meson >=0.63.3", + "ninja", + "pyproject-metadata >=0.6.1", + "python >=3.9,<3.10.0a0", + "tomli >=1.0.0", + "typing-extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "efd17ab0fa52b2c4e76bd453cf01a670", + "name": "meson-python", + "sha256": "9a761127bd7630082ed6201ee2e5d69f75521199d39abc3841a32e9b3ba47a0d", + "size": 57995, + "subdir": "linux-64", + "timestamp": 1680550528241, + "version": "0.12.1" + }, + "meson-python-0.7.0-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "meson >=0.60.0", + "ninja", + "pyproject-metadata >=0.5.0", + "python >=3.10,<3.11.0a0", + "tomli >=1.0.0", + "wheel >=0.36.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2a6b66c5ab2a889445a7ef5fd4fc91e6", + "name": "meson-python", + "sha256": "6137cd8f1f5931c2509e164f834604023b7f0d34040350a33eb47971bbe9786d", + "size": 40114, + "subdir": "linux-64", + "timestamp": 1660137705048, + "version": "0.7.0" + }, + "meson-python-0.7.0-py311h5eee18b_1.tar.bz2": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "meson >=0.60.0", + "ninja", + "pyproject-metadata >=0.5.0", + "python >=3.11,<3.12.0a0", + "tomli >=1.0.0", + "wheel >=0.36.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "28efc4693b3b1db60911d7364acb9c7d", + "name": "meson-python", + "sha256": "ddd97cf22288ecd96a15baa2144e97965827db755c1b3f869b49e47ed6d39ba8", + "size": 50911, + "subdir": "linux-64", + "timestamp": 1676858637714, + "version": "0.7.0" + }, + "meson-python-0.7.0-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "meson >=0.60.0", + "ninja", + "pyproject-metadata >=0.5.0", + "python >=3.7,<3.8.0a0", + "tomli >=1.0.0", + "typing-extensions >=3.7.4", + "wheel >=0.36.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bfa10ad5203608007951c89ee136fa45", + "name": "meson-python", + "sha256": "43c52f6dd7220e06901926868017adec6c9bcac0fb5acf3de379c565de9bec17", + "size": 39432, + "subdir": "linux-64", + "timestamp": 1660137756402, + "version": "0.7.0" + }, + "meson-python-0.7.0-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "meson >=0.60.0", + "ninja", + "pyproject-metadata >=0.5.0", + "python >=3.8,<3.9.0a0", + "tomli >=1.0.0", + "wheel >=0.36.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d45bc8db2dfaf94c966a22c3b66b2e0e", + "name": "meson-python", + "sha256": "244109296e05d80f0052cb8eb7eb29002134366eaf7d7b03fadcfdd70a49c526", + "size": 39621, + "subdir": "linux-64", + "timestamp": 1660137575909, + "version": "0.7.0" + }, + "meson-python-0.7.0-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "meson >=0.60.0", + "ninja", + "pyproject-metadata >=0.5.0", + "python >=3.9,<3.10.0a0", + "tomli >=1.0.0", + "wheel >=0.36.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12c2760434b9407f382ef1ac1a1926b9", + "name": "meson-python", + "sha256": "71ebd88b5859940ae204d3c6ded1c1d88924b90ece320827cba8854a0d82936b", + "size": 39740, + "subdir": "linux-64", + "timestamp": 1660137641242, + "version": "0.7.0" + }, + "metakernel-0.20.14-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "af942180b08b183803368c99ccd108f0", + "name": "metakernel", + "sha256": "088d6c7e6fb8991e9bc60095b9cd407976bdd0cbd22d1e4cc41c20c63db3dfdd", + "size": 118996, + "subdir": "linux-64", + "timestamp": 1522192331539, + "version": "0.20.14" + }, + "metakernel-0.20.14-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dbbcbec78ea1743109c4893ad6fa7cae", + "name": "metakernel", + "sha256": "846e9a8d82f771f731d38252b0fb3e4f420c0286e28f40d9756b989d22df23c1", + "size": 121908, + "subdir": "linux-64", + "timestamp": 1522192344635, + "version": "0.20.14" + }, + "metakernel-0.20.14-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "28d0861b6d487b57fda0f172bc31ccf4", + "name": "metakernel", + "sha256": "39f2e67ce21b3044299383c9b59a0b7920d485e5ca2120b7f477649da183899a", + "size": 121372, + "subdir": "linux-64", + "timestamp": 1522192339413, + "version": "0.20.14" + }, + "metakernel-0.20.14-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e752c4fe2b916bc9b73657b43b4ffcc0", + "name": "metakernel", + "sha256": "46f30f317bdce07517a99f595bac38214ac8d0aee9be97496476f07a7a49bdf0", + "size": 121066, + "subdir": "linux-64", + "timestamp": 1530899234749, + "version": "0.20.14" + }, + "metakernel-0.20.7-py27hb56d6b3_0.tar.bz2": { + "build": "py27hb56d6b3_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8955e39b2563d76389e8bb6deca31c68", + "name": "metakernel", + "sha256": "85ef74848e5809ed58a8efc2b4b9557fcbb41be2014e9867bd8b8f984b75ccd3", + "size": 118212, + "subdir": "linux-64", + "timestamp": 1506847986497, + "version": "0.20.7" + }, + "metakernel-0.20.7-py35h54656b8_0.tar.bz2": { + "build": "py35h54656b8_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "02758fd5add2203d00c6a6234bb9698e", + "name": "metakernel", + "sha256": "d6c67de369308d415b3d4a87f743de1887dd798994315e0ee9728c4376ba44b0", + "size": 121283, + "subdir": "linux-64", + "timestamp": 1506848038455, + "version": "0.20.7" + }, + "metakernel-0.20.7-py36hac07065_0.tar.bz2": { + "build": "py36hac07065_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f9071d5a65f03ed74e6908ac36db924d", + "name": "metakernel", + "sha256": "b7df51feac24d92308c6849c82d35feebea0511f89972f6b7864cd48b73b4189", + "size": 120673, + "subdir": "linux-64", + "timestamp": 1506848035994, + "version": "0.20.7" + }, + "metakernel-0.23.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dc93626cc53adc7cb7828db6edfc0e52", + "name": "metakernel", + "sha256": "d9c202a48abe76bec7eab7c45bdc13a9d929a66447663a46b2b14ea12c1afc13", + "size": 243968, + "subdir": "linux-64", + "timestamp": 1559060629700, + "version": "0.23.0" + }, + "metakernel-0.23.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e719a0e18fbdbff4fd7880c3750b7fe2", + "name": "metakernel", + "sha256": "e588755e585525cae6698bb2fc4c334065f7499e033e2eea9a72e9267fcdcba6", + "size": 247175, + "subdir": "linux-64", + "timestamp": 1558738831115, + "version": "0.23.0" + }, + "metakernel-0.23.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b1d14845e494a11c9b18d051dd957c7a", + "name": "metakernel", + "sha256": "3932decdc2455725f615f7482ffa0b45bb2bd0765a11aa3830bdf01fff917ec1", + "size": 247047, + "subdir": "linux-64", + "timestamp": 1559060626275, + "version": "0.23.0" + }, + "metis-5.1.0-hdbfa776_3.tar.bz2": { + "build": "hdbfa776_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "Apache 2.0", + "md5": "defc78a68a0b39ab93644c9caa8c3ec2", + "name": "metis", + "sha256": "07f552c7111a244974a5de8f2e5250dd35e53069633665326d60de582eaf33ca", + "size": 4293438, + "subdir": "linux-64", + "timestamp": 1636111015419, + "version": "5.1.0" + }, + "metis-5.1.0-hf484d3e_4.tar.bz2": { + "build": "hf484d3e_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "md5": "0f47d15d9f839362c6b2a755cb10d93b", + "name": "metis", + "sha256": "7284b2354da49d16fd1e658ef6f53f6b38c72499de13a5b5c2fc40ecf7e22354", + "size": 4271633, + "subdir": "linux-64", + "timestamp": 1528733678436, + "version": "5.1.0" + }, + "mistune-0.7.4-py27h6da7e90_0.tar.bz2": { + "build": "py27h6da7e90_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e4a3ebe8a5c373c06644439e3f6e7abc", + "name": "mistune", + "sha256": "46c21ac9769e6483e9a5c388d5ea4a48bd4d0083ae9856284bb246dd34129d6e", + "size": 52397, + "subdir": "linux-64", + "timestamp": 1505688922769, + "version": "0.7.4" + }, + "mistune-0.7.4-py35hfd0f961_0.tar.bz2": { + "build": "py35hfd0f961_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "accf4c0ce06b628793540d0661fd61b2", + "name": "mistune", + "sha256": "a4e6cc4dfc3e86b2365fb8102f37864827c21c3c132371f1714284f66881112d", + "size": 53107, + "subdir": "linux-64", + "timestamp": 1505689771057, + "version": "0.7.4" + }, + "mistune-0.7.4-py36hbab8784_0.tar.bz2": { + "build": "py36hbab8784_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "03c0b81bd336422ba7e76daac1892f22", + "name": "mistune", + "sha256": "78b77fbf538041c7c7c650002ff286b5fd280e635674a9548ba257c27af068a1", + "size": 53078, + "subdir": "linux-64", + "timestamp": 1505689782769, + "version": "0.7.4" + }, + "mistune-0.8.1-py27h1bd0165_0.tar.bz2": { + "build": "py27h1bd0165_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "84137ab5dce6d6c37200edabe04cdcce", + "name": "mistune", + "sha256": "3a89079381b3c7a77ea6266cc00b13aab0e512454cce7bc3eead795f8e65b6a4", + "size": 53480, + "subdir": "linux-64", + "timestamp": 1510329860159, + "version": "0.8.1" + }, + "mistune-0.8.1-py35h9251d8c_0.tar.bz2": { + "build": "py35h9251d8c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "01d7481417a6f16324f6332c359fc800", + "name": "mistune", + "sha256": "4348d6affacb0b3f23c3a153dd91705784e89d4a0f68ecd8b03a481956177df5", + "size": 54056, + "subdir": "linux-64", + "timestamp": 1510329863865, + "version": "0.8.1" + }, + "mistune-0.8.1-py36h3d5977c_0.tar.bz2": { + "build": "py36h3d5977c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ad0e926e36d552c6207aa499b00790b9", + "name": "mistune", + "sha256": "2740ddfce4fbb61d1442c5ffc4abb0cf68597a62e760a993a6a3c05b66588661", + "size": 54030, + "subdir": "linux-64", + "timestamp": 1510329865278, + "version": "0.8.1" + }, + "mistune-0.8.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a7d6fe7369dae0d7ae6812bd6cc3a64b", + "name": "mistune", + "sha256": "6ac8afb15a7eb22538fbe226b1661b7bb55ff698cd9165082167a92f96495b7d", + "size": 52933, + "subdir": "linux-64", + "timestamp": 1515791342016, + "version": "0.8.3" + }, + "mistune-0.8.3-py27h14c3975_1.tar.bz2": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ff6b0c4344d5d4f1499fc2f8826ad5e8", + "name": "mistune", + "sha256": "65ac71a13864bd3cad1494c6b3e929ac0d842925a07caf48bdec5c04ea245a30", + "size": 271945, + "subdir": "linux-64", + "timestamp": 1524516418991, + "version": "0.8.3" + }, + "mistune-0.8.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3c6a2dd9b7e13e087c012f382f294286", + "name": "mistune", + "sha256": "23177384daa35c80d64af37d3eaa75f0f8886c350cb22248921f30a58a6328ce", + "size": 53535, + "subdir": "linux-64", + "timestamp": 1515791399352, + "version": "0.8.3" + }, + "mistune-0.8.3-py35h14c3975_1.tar.bz2": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "53a883ae579a4ee703d79f2abb595815", + "name": "mistune", + "sha256": "950d569fc66bdbc42777fe5489716bf570bb78b37d44f1d5d131bb1e09851fad", + "size": 274429, + "subdir": "linux-64", + "timestamp": 1524516991482, + "version": "0.8.3" + }, + "mistune-0.8.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "deee5e92d2361ddf1d67d5d550aa2cd7", + "name": "mistune", + "sha256": "1be8f3e3db40a41a938ac1a650b57689f5f86053fb787f8e852212487932f8e8", + "size": 53517, + "subdir": "linux-64", + "timestamp": 1515791272916, + "version": "0.8.3" + }, + "mistune-0.8.3-py36h14c3975_1.tar.bz2": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0bac187b145ca69ffea0b60430be0fb3", + "name": "mistune", + "sha256": "e485a7341e578688592bb9841d4ecc5a7580ecf0dee4231041d30d0f8dcae40c", + "size": 282864, + "subdir": "linux-64", + "timestamp": 1524516980361, + "version": "0.8.3" + }, + "mistune-0.8.3-py37h14c3975_1.tar.bz2": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "39dcb9eb7b09bf1715093111ad93936b", + "name": "mistune", + "sha256": "bcb3eb0711a54aedf4cbf906b2d20e1485df0cb8c8813056f396b1705c41180e", + "size": 281578, + "subdir": "linux-64", + "timestamp": 1530734368767, + "version": "0.8.3" + }, + "mistune-0.8.4-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a9223d3d208724fa814f93fe27fd8c7c", + "name": "mistune", + "sha256": "bd80c033ae041c3b1a309ef6700572ef421bf4c0129bd4fb95a8da71cf281513", + "size": 54414, + "subdir": "linux-64", + "timestamp": 1539631526839, + "version": "0.8.4" + }, + "mistune-0.8.4-py310h7f8727e_1000.tar.bz2": { + "build": "py310h7f8727e_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "33fe473ae7a1202e28c9143014029f62", + "name": "mistune", + "sha256": "2074ac064fd4472eef8858d01cbf8475e775503f6b10803b2882c7d77fa394b9", + "size": 55705, + "subdir": "linux-64", + "timestamp": 1640791663692, + "version": "0.8.4" + }, + "mistune-0.8.4-py311h5eee18b_1000.tar.bz2": { + "build": "py311h5eee18b_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6ea42d06377a1512f29bf89a8ad72127", + "name": "mistune", + "sha256": "1199fd0f85035da8294aeb427554c89dd5f6004d2bc352b848a9b797b45c9610", + "size": 63552, + "subdir": "linux-64", + "timestamp": 1676823711825, + "version": "0.8.4" + }, + "mistune-0.8.4-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e7c5482debf2edf475604cabaa7c203a", + "name": "mistune", + "sha256": "0552bd443c7e5771b40af9e1e9194a770742e0e78c05c609944a078942132914", + "size": 55092, + "subdir": "linux-64", + "timestamp": 1539631542330, + "version": "0.8.4" + }, + "mistune-0.8.4-py37h14c3975_1001.tar.bz2": { + "build": "py37h14c3975_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ba9aa2cb67c5a833a22b506c7f5393eb", + "name": "mistune", + "sha256": "8cf4856e7e5d323062f7ffb0b8057200ce79363c50013210bd62398445e0e2a3", + "size": 54608, + "subdir": "linux-64", + "timestamp": 1594373138585, + "version": "0.8.4" + }, + "mistune-0.8.4-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9e52495aa61827cbb97d0ec01110624d", + "name": "mistune", + "sha256": "567fc0ba210e80c7563b5bf98ddf6b98790c79e24245c7e6f69232446b93da3e", + "size": 55020, + "subdir": "linux-64", + "timestamp": 1539631557616, + "version": "0.8.4" + }, + "mistune-0.8.4-py38h7b6447c_1000.tar.bz2": { + "build": "py38h7b6447c_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1ec38f43661f9db21e2cdae301ce9b42", + "name": "mistune", + "sha256": "e8ba4be2d51f4532870cdc96c212083c782a58da7281b7ecfede0b1d7ab3177b", + "size": 55392, + "subdir": "linux-64", + "timestamp": 1573489078577, + "version": "0.8.4" + }, + "mistune-0.8.4-py39h27cfd23_1000.tar.bz2": { + "build": "py39h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f6c734d73e6e3dbc1b62766cf18ff3e4", + "name": "mistune", + "sha256": "91720216312a88348bc20083c47f7e9232d34e929e08c8762e62611543acdadc", + "size": 58153, + "subdir": "linux-64", + "timestamp": 1607364912263, + "version": "0.8.4" + }, + "mistune-2.0.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "nbconvert >6.1.0" + ], + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "434eefcd517ab08422676df586e111a3", + "name": "mistune", + "sha256": "c1e3fa7d8d4656779fe37d55a9f8a457c8bcde71beab78f091c35adf9de303cb", + "size": 90224, + "subdir": "linux-64", + "timestamp": 1661496364548, + "version": "2.0.4" + }, + "mistune-2.0.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "nbconvert >6.1.0" + ], + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e602057e3b3d80da88c61d66e8851c5b", + "name": "mistune", + "sha256": "9aacfbbe6f638c58a4e8ff31374d1438d78b7db25d6ea6fd0c50ca2109f225d4", + "size": 104681, + "subdir": "linux-64", + "timestamp": 1676823696152, + "version": "2.0.4" + }, + "mistune-2.0.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "nbconvert >6.1.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dde51f1f8159b014958457bfc1f55064", + "name": "mistune", + "sha256": "bdcbd59e7217b192a97700f4b4686e1f35a447f56cbfd7cc57ec61a1a1194b99", + "size": 89608, + "subdir": "linux-64", + "timestamp": 1661496317987, + "version": "2.0.4" + }, + "mistune-2.0.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "nbconvert >6.1.0" + ], + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0219b4aefc356586a8045ae2a77ae3fd", + "name": "mistune", + "sha256": "ae9df84d25f410f1d5ad3af4fb29bd8507211e9f10717f4d47d60bddf9bf02bb", + "size": 89740, + "subdir": "linux-64", + "timestamp": 1661496287860, + "version": "2.0.4" + }, + "mistune-2.0.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "nbconvert >6.1.0" + ], + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88fede163cf0557ac00476616b3a8af3", + "name": "mistune", + "sha256": "78a26b337cd38a17085997dffeedf49fc01103937543a13375fdf2764fdd8ba6", + "size": 89606, + "subdir": "linux-64", + "timestamp": 1661496257549, + "version": "2.0.4" + }, + "mkl-2017.0.4-h4c4d0af_0.tar.bz2": { + "build": "h4c4d0af_0", + "build_number": 0, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "04c898ba784767fc2964bbda9685c62f", + "name": "mkl", + "sha256": "ff048076748169518ee75e9d2d526628ac5e5b2de9e318d97611c7cc94f625eb", + "size": 179360093, + "subdir": "linux-64", + "timestamp": 1508962814801, + "version": "2017.0.4" + }, + "mkl-2018.0.0-hb491cac_4.tar.bz2": { + "build": "hb491cac_4", + "build_number": 4, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "f6d79cdf2ecf31974344265683386a8e", + "name": "mkl", + "sha256": "33bc3e20acd0b9368d5fa87f879ad5742454083c5dcb7ac72c61e8ef117b6622", + "size": 182821744, + "subdir": "linux-64", + "timestamp": 1505745615596, + "version": "2018.0.0" + }, + "mkl-2018.0.1-h19d6760_4.tar.bz2": { + "build": "h19d6760_4", + "build_number": 4, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "cddd74d224a68cd8c76e7cf69aa15c07", + "name": "mkl", + "sha256": "cc4a1c8be339ba1dd2993f3dabca69cb51f8f924208cccf7801a76ea69118e95", + "size": 193625096, + "subdir": "linux-64", + "timestamp": 1511376420864, + "version": "2018.0.1" + }, + "mkl-2018.0.2-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "93309375ae80acf84f93c467b62275ef", + "name": "mkl", + "sha256": "9a46faccf1d409ee8e86d4efc20e26fb3dc55b2da63fc5eba35ff97b7271b323", + "size": 215183373, + "subdir": "linux-64", + "timestamp": 1521735614312, + "version": "2018.0.2" + }, + "mkl-2018.0.3-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "bd6da185bf168502bed822b613cda621", + "name": "mkl", + "sha256": "15e581c6a0aadaeb9ca77dda3bc68ea8de43e2de8e7e052f50fca7c8d161e06f", + "size": 208336938, + "subdir": "linux-64", + "timestamp": 1528122068610, + "version": "2018.0.3" + }, + "mkl-2019.0-117.tar.bz2": { + "build": "117", + "build_number": 117, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "3df7f40013b53abb3684ce2732ad9b3d", + "name": "mkl", + "sha256": "77318311855dea9818d21c12b54c4e50d2c54960ca9f985e31837085dd8498fb", + "size": 214349344, + "subdir": "linux-64", + "timestamp": 1536594387752, + "version": "2019.0" + }, + "mkl-2019.0-118.tar.bz2": { + "build": "118", + "build_number": 118, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "d9b390b4e4ced0feead46ead384d9e6b", + "name": "mkl", + "sha256": "1e53c9a3454f40784df832f1341c0c0985197466664f7bc9e4bd0c9967a2b167", + "size": 214352695, + "subdir": "linux-64", + "timestamp": 1537292399637, + "version": "2019.0" + }, + "mkl-2019.1-144.tar.bz2": { + "build": "144", + "build_number": 144, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "9c6c0d8609ffb94af492d0c07fb7f22c", + "name": "mkl", + "sha256": "18a91bcc7fe2643631496a1e15c4607b306b3bcf78fb072c76828e2c66373d92", + "size": 214510498, + "subdir": "linux-64", + "timestamp": 1542661351585, + "version": "2019.1" + }, + "mkl-2019.3-199.tar.bz2": { + "build": "199", + "build_number": 199, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "437f4a622c470d4e5c5adf6cce981e23", + "name": "mkl", + "sha256": "7efaa32b4dad03b124f4880532a6e6cb541355b5a9a25345b1943be2827d47fb", + "size": 213214191, + "subdir": "linux-64", + "timestamp": 1552593931728, + "version": "2019.3" + }, + "mkl-2019.4-243.tar.bz2": { + "build": "243", + "build_number": 243, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "5a4523f87c4bb00f082651a6af3a350c", + "name": "mkl", + "sha256": "40397ee174f2eca6173c2a547568d4634437e1aebff2ea22d9749ebd966a59cc", + "size": 213996111, + "subdir": "linux-64", + "timestamp": 1559526865803, + "version": "2019.4" + }, + "mkl-2020.0-166.tar.bz2": { + "build": "166", + "build_number": 166, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "4a7ea0ba46c93060d75102131a777c8a", + "name": "mkl", + "sha256": "59154b30dd74561e90d547f9a3af26c75b6f4546210888f09c9d4db8f4bf9d4c", + "size": 211877731, + "subdir": "linux-64", + "timestamp": 1580944423800, + "version": "2020.0" + }, + "mkl-2020.1-217.tar.bz2": { + "build": "217", + "build_number": 217, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "3b5aab2233078d672f41082e2e6dffb0", + "name": "mkl", + "sha256": "b8d2154a4a65271e30372e54f1ec4a74694242f814bcc6b50d44060670a2d492", + "size": 210250792, + "subdir": "linux-64", + "timestamp": 1589162721090, + "version": "2020.1" + }, + "mkl-2020.2-256.tar.bz2": { + "build": "256", + "build_number": 256, + "depends": [ + "intel-openmp" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "309c0fe84b59eb1c4ee0972bcafa319c", + "name": "mkl", + "sha256": "6b81b32c2d73cae7e6f5f96c9feab91334c905384609b3e3ca6586dc4bf3a50e", + "size": 224303362, + "subdir": "linux-64", + "timestamp": 1598384580372, + "version": "2020.2" + }, + "mkl-2021.2.0-h06a4308_296.tar.bz2": { + "build": "h06a4308_296", + "build_number": 296, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [ + "intel-openmp 2021.*" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "6078e1c5ead0cfcec632c96c916e8149", + "name": "mkl", + "sha256": "18719b713825a1d8a2d2729fde77baf3d91c589f6d12382385c4a4c9ecbe62a1", + "size": 234611263, + "subdir": "linux-64", + "timestamp": 1618534385890, + "version": "2021.2.0" + }, + "mkl-2021.3.0-h06a4308_520.tar.bz2": { + "build": "h06a4308_520", + "build_number": 520, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [ + "intel-openmp 2021.*" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "daeb0a6d8947b6fda77db5ffaf523e4e", + "name": "mkl", + "sha256": "14f817c02e3fb4f3fa45e24683afa361666efe2698a10acde14a85a61656338a", + "size": 227978701, + "subdir": "linux-64", + "timestamp": 1626182688537, + "version": "2021.3.0" + }, + "mkl-2021.4.0-h06a4308_640.tar.bz2": { + "build": "h06a4308_640", + "build_number": 640, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [ + "intel-openmp 2021.*" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "bd20f4410b81f327e35ffa0657961146", + "name": "mkl", + "sha256": "7c4ded8b2ef036839f988560848d2c32e1aa4627fd37a32710e42c39f5c61ac2", + "size": 229783051, + "subdir": "linux-64", + "timestamp": 1634547157986, + "version": "2021.4.0" + }, + "mkl-2022.0.1-h06a4308_117.tar.bz2": { + "build": "h06a4308_117", + "build_number": 117, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [ + "intel-openmp 2022.*" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "8a28f20675dc91cd81d5f34ba8aeb7f2", + "name": "mkl", + "sha256": "a7bec83354ddececeee4b3cd99471bd466ba6bfeda5932ff6b1a3b58b986f39b", + "size": 208948880, + "subdir": "linux-64", + "timestamp": 1642705808227, + "version": "2022.0.1" + }, + "mkl-2022.1.0-hc2b9512_223.tar.bz2": { + "build": "hc2b9512_223", + "build_number": 223, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [ + "intel-openmp 2022.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "3b8ba9e566ede255f1d71a4da6c7f373", + "name": "mkl", + "sha256": "44d6facb1d0e0bb938b36d7a53c5a1c9bcf01cf0fea3f2dde91bd1e61177dc70", + "size": 208991772, + "subdir": "linux-64", + "timestamp": 1662088179291, + "version": "2022.1.0" + }, + "mkl-2022.1.0-hc2b9512_224.tar.bz2": { + "build": "hc2b9512_224", + "build_number": 224, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [ + "intel-openmp 2022.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "0d290efe6a8c174f272e4cd923f8145b", + "name": "mkl", + "sha256": "b7b5218bd1936e28389424d19c8324064782951fd80f3d3bb369a0ed7306b9ae", + "size": 209236707, + "subdir": "linux-64", + "timestamp": 1662497914900, + "version": "2022.1.0" + }, + "mkl-2023.0.0-h6d00ec8_25399.tar.bz2": { + "build": "h6d00ec8_25399", + "build_number": 25399, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [ + "intel-openmp 2023.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.*" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "2b299aca1a7cbcb57df269a09252166b", + "name": "mkl", + "sha256": "367971558b2e90ddf9d539b610cac2b109cdfbb9069b89507a421db143644a1b", + "size": 206874304, + "subdir": "linux-64", + "timestamp": 1677516738168, + "version": "2023.0.0" + }, + "mkl-devel-2017.0.4-h2e09e16_0.tar.bz2": { + "build": "h2e09e16_0", + "build_number": 0, + "depends": [ + "mkl 2017.0.4 h4c4d0af_0", + "mkl-include 2017.0.4 hf7c01fb_0", + "blas * mkl" + ], + "md5": "eaf9c73b09fc5c655d131ef71ab89a3d", + "name": "mkl-devel", + "sha256": "e5330578e80db11877490e70c09fdb6b3313f91ba6db06800eaa38a6fbec8e87", + "size": 3170, + "subdir": "linux-64", + "timestamp": 1508963017151, + "version": "2017.0.4" + }, + "mkl-devel-2018.0.0-hed7f433_4.tar.bz2": { + "build": "hed7f433_4", + "build_number": 4, + "depends": [ + "mkl 2018.0.0 hb491cac_4", + "mkl-include 2018.0.0 h15fc484_2", + "blas * mkl" + ], + "md5": "b5e6eb1206a0701e4115a6dc3a3380c3", + "name": "mkl-devel", + "sha256": "91f36eb6ad89d7d18fe9de3fcf61126f8a958dc0d1fb7a51fb0a9070893dcae3", + "size": 2639, + "subdir": "linux-64", + "timestamp": 1505745774859, + "version": "2018.0.0" + }, + "mkl-devel-2018.0.1-h470d631_5.tar.bz2": { + "build": "h470d631_5", + "build_number": 5, + "depends": [ + "mkl", + "mkl-include", + "blas * mkl" + ], + "md5": "fddf53190adcca703b1defb1e2d8da60", + "name": "mkl-devel", + "sha256": "d01c7919863003e49ec09a9cfaa049c51a8ecc196d0c7edc98f8d9efa158892b", + "size": 2803, + "subdir": "linux-64", + "timestamp": 1516825134435, + "version": "2018.0.1" + }, + "mkl-devel-2018.0.1-hf16a5b4_4.tar.bz2": { + "build": "hf16a5b4_4", + "build_number": 4, + "depends": [ + "mkl 2018.0.1 h19d6760_4", + "mkl-include 2018.0.1 hc7b2577_4", + "blas * mkl" + ], + "md5": "b79a912bc9b2b6b9c5f67789ae123ccc", + "name": "mkl-devel", + "sha256": "e12b8314f06bae8aff131b7de009dc4dc00456464d6b10b3c5a9bf03df511d5e", + "size": 3211, + "subdir": "linux-64", + "timestamp": 1511376588378, + "version": "2018.0.1" + }, + "mkl-devel-2018.0.2-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "mkl 2018.0.2 1", + "mkl-include 2018.0.2 1", + "blas * mkl" + ], + "md5": "d12e921ff6d649b83ba7bd924c6b62a6", + "name": "mkl-devel", + "sha256": "26bc1cac904199a7cc19998058c71edf24b29a7656877f21e11db48e9672a039", + "size": 5682, + "subdir": "linux-64", + "timestamp": 1521735821183, + "version": "2018.0.2" + }, + "mkl-devel-2018.0.2-3.tar.bz2": { + "build": "3", + "build_number": 3, + "depends": [ + "mkl 2018.0.2 1", + "mkl-include 2018.0.2 1", + "blas * mkl" + ], + "md5": "96a1fd58e69f32f0705d691b13580854", + "name": "mkl-devel", + "sha256": "811364d450b785bb64242c523dfa4b22731fd0db9eb8573d80b6bc9df4078302", + "size": 6304, + "subdir": "linux-64", + "timestamp": 1526043010740, + "version": "2018.0.2" + }, + "mkl-devel-2018.0.2-4.tar.bz2": { + "build": "4", + "build_number": 4, + "depends": [ + "mkl 2018.0.2 1", + "mkl-include 2018.0.2 1", + "blas * mkl" + ], + "md5": "8fe8f565f9abb8bd894f2b75ea3f151c", + "name": "mkl-devel", + "sha256": "acb922d46b02074a99ce68b718f8740db1244bd5af49680346767b1f0eb1f3bf", + "size": 6262, + "subdir": "linux-64", + "timestamp": 1526831164354, + "version": "2018.0.2" + }, + "mkl-devel-2018.0.3-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "mkl 2018.0.3 1", + "mkl-include 2018.0.3 1", + "blas * mkl" + ], + "md5": "86f9ce6e1eb4ec793215939bf460cffc", + "name": "mkl-devel", + "sha256": "e49fdacdbf31d37101b447c16b79bc457c8e3c08216930f3d7baea6a168ac7c8", + "size": 6190, + "subdir": "linux-64", + "timestamp": 1528122418745, + "version": "2018.0.3" + }, + "mkl-devel-2019.0-117.tar.bz2": { + "build": "117", + "build_number": 117, + "depends": [ + "blas * mkl", + "mkl 2019.0 117", + "mkl-include 2019.0 117" + ], + "md5": "6236ea46cb27541898413c7839069cc4", + "name": "mkl-devel", + "sha256": "cbb64756d329974d282af0fa72ced6f3415819b30b9e32996efdc43714c0d008", + "size": 7301, + "subdir": "linux-64", + "timestamp": 1536594591299, + "version": "2019.0" + }, + "mkl-devel-2019.0-118.tar.bz2": { + "build": "118", + "build_number": 118, + "depends": [ + "blas * mkl", + "mkl 2019.0 118", + "mkl-include 2019.0 118" + ], + "md5": "1162556c3ebf30bb19b598981ba53343", + "name": "mkl-devel", + "sha256": "07b960cc56f2654ce8717877daeb36f555d5a4cc9aae716b3691018bf524ce80", + "size": 6503, + "subdir": "linux-64", + "timestamp": 1537292709568, + "version": "2019.0" + }, + "mkl-devel-2019.0-119.tar.bz2": { + "build": "119", + "build_number": 119, + "depends": [ + "blas * mkl", + "mkl 2019.0 118", + "mkl-include 2019.0 118" + ], + "md5": "89dc8bf668c41777eec658df39275bea", + "name": "mkl-devel", + "sha256": "0fc6ce7085ef9d5feebe1518bd9a80444c70ca45d249e91a302f2b859dc65b0a", + "size": 10111, + "subdir": "linux-64", + "timestamp": 1539280882147, + "version": "2019.0" + }, + "mkl-devel-2019.1-144.tar.bz2": { + "build": "144", + "build_number": 144, + "depends": [ + "blas * mkl", + "mkl 2019.1 144", + "mkl-include 2019.1 144" + ], + "md5": "45cdb7e5220fbaa568997d185db37cff", + "name": "mkl-devel", + "sha256": "ddcd2ed879b25aa850eb44be66a0ad393fdc2ece9fb5543081666d4d500c0fca", + "size": 8928, + "subdir": "linux-64", + "timestamp": 1542661737733, + "version": "2019.1" + }, + "mkl-devel-2019.3-200.tar.bz2": { + "build": "200", + "build_number": 200, + "depends": [ + "blas * mkl", + "mkl 2019.3 199", + "mkl-include 2019.3 199" + ], + "md5": "ecb340d9ec5c3cb42b14bfa6007b2d61", + "name": "mkl-devel", + "sha256": "f9497bbda33002e1d06f652a3a72d2b81711fcb78fde048db4397cf8f4089e74", + "size": 10687, + "subdir": "linux-64", + "timestamp": 1552594346124, + "version": "2019.3" + }, + "mkl-devel-2019.4-243.tar.bz2": { + "build": "243", + "build_number": 243, + "depends": [ + "blas * mkl", + "mkl 2019.4 243", + "mkl-include 2019.4 243" + ], + "md5": "452d3ab9d5d3d6724c23d7e45cd95cfb", + "name": "mkl-devel", + "sha256": "5977a46619b0a258df640948dd7382b99505630c5fe64301b9c73daed5bfcc95", + "size": 11250, + "subdir": "linux-64", + "timestamp": 1559527106419, + "version": "2019.4" + }, + "mkl-devel-2020.0-167.tar.bz2": { + "build": "167", + "build_number": 167, + "depends": [ + "blas * mkl", + "mkl 2020.0 166", + "mkl-include 2020.0 166" + ], + "md5": "3afc6d4866f4f036699428a83f933173", + "name": "mkl-devel", + "sha256": "6c69766e705a613d74c9619bf378aa356a4b42da3fd70db353aa4fdcc1c018e3", + "size": 11548, + "subdir": "linux-64", + "timestamp": 1580944619207, + "version": "2020.0" + }, + "mkl-devel-2020.1-218.tar.bz2": { + "build": "218", + "build_number": 218, + "depends": [ + "blas * mkl", + "mkl 2020.1 217", + "mkl-include 2020.1 217" + ], + "md5": "cd111e3b9dd10d25c867f209f0f54d61", + "name": "mkl-devel", + "sha256": "68d553122ddfb6eac0d08231fa8539885f27c521d61c6129cb177061f0682aa8", + "size": 11541, + "subdir": "linux-64", + "timestamp": 1589162951884, + "version": "2020.1" + }, + "mkl-devel-2020.2-257.tar.bz2": { + "build": "257", + "build_number": 257, + "depends": [ + "blas * mkl", + "mkl 2020.2 256", + "mkl-include 2020.2 256" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "c4a9d0e72a58a1db60f26f1d94affb43", + "name": "mkl-devel", + "sha256": "ee747c62cdf69980c5f5c720276efa5268b06830832b55df20e86d5c8adce508", + "size": 12870, + "subdir": "linux-64", + "timestamp": 1598384790911, + "version": "2020.2" + }, + "mkl-devel-2021.2.0-h66538d2_296.tar.bz2": { + "build": "h66538d2_296", + "build_number": 296, + "depends": [ + "blas * mkl", + "mkl 2021.2.0 h06a4308_296", + "mkl-include 2021.2.0 h06a4308_296" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "429cc96a756e0fe738715c16e4f3f59d", + "name": "mkl-devel", + "sha256": "f20fd62811c6dab9ed7c9ea5eadabbbea66b3ec7495e96993f276cb8b6e5ad9b", + "size": 25582, + "subdir": "linux-64", + "timestamp": 1618534587016, + "version": "2021.2.0" + }, + "mkl-devel-2021.3.0-h66538d2_520.tar.bz2": { + "build": "h66538d2_520", + "build_number": 520, + "depends": [ + "blas * mkl", + "mkl 2021.3.0 h06a4308_520", + "mkl-include 2021.3.0 h06a4308_520" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "1a331797490e99dd6f9f195f14434df9", + "name": "mkl-devel", + "sha256": "037be00a98ae8c511153fae6cc404151722c30f9c6adc4a6af3009363723232c", + "size": 26456, + "subdir": "linux-64", + "timestamp": 1626182870662, + "version": "2021.3.0" + }, + "mkl-devel-2021.4.0-h66538d2_640.tar.bz2": { + "build": "h66538d2_640", + "build_number": 640, + "depends": [ + "blas * mkl", + "mkl 2021.4.0 h06a4308_640", + "mkl-include 2021.4.0 h06a4308_640" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "6d289b62fde0870066ebd49865a3a916", + "name": "mkl-devel", + "sha256": "63548d9d4c7b18958c8dbafe76f3861bbda9883b8e15cf731fa3cb8c04390b97", + "size": 26559, + "subdir": "linux-64", + "timestamp": 1634547339271, + "version": "2021.4.0" + }, + "mkl-devel-2022.0.1-h66538d2_117.tar.bz2": { + "build": "h66538d2_117", + "build_number": 117, + "depends": [ + "blas * mkl", + "mkl 2022.0.1 h06a4308_117", + "mkl-include 2022.0.1 h06a4308_117" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "586315c361646745f7a185b5e14629fe", + "name": "mkl-devel", + "sha256": "cc2276f9655414a85501068505634d312a215cd4bcc35ffb40595b4c509f126b", + "size": 26933, + "subdir": "linux-64", + "timestamp": 1642705976071, + "version": "2022.0.1" + }, + "mkl-devel-2022.1.0-h66538d2_223.tar.bz2": { + "build": "h66538d2_223", + "build_number": 223, + "depends": [ + "blas * mkl", + "mkl 2022.1.0 hc2b9512_223", + "mkl-include 2022.1.0 h06a4308_223" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "aad56eada3435fc515ece2df64c54179", + "name": "mkl-devel", + "sha256": "e027f92cf8d3b4f689c5d72a4e9719944f5a0191ba018ceb557ebee2456cefb6", + "size": 25020, + "subdir": "linux-64", + "timestamp": 1662088274998, + "version": "2022.1.0" + }, + "mkl-devel-2022.1.0-h66538d2_224.tar.bz2": { + "build": "h66538d2_224", + "build_number": 224, + "depends": [ + "blas * mkl", + "mkl 2022.1.0 hc2b9512_224", + "mkl-include 2022.1.0 h06a4308_224" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "767bb26f15243fce76444b0920a07228", + "name": "mkl-devel", + "sha256": "380ec733693c126c19e830798709d9312307e511943158a2baddb62f430214d2", + "size": 25140, + "subdir": "linux-64", + "timestamp": 1662498036788, + "version": "2022.1.0" + }, + "mkl-devel-2023.0.0-h2fb9e7e_25399.tar.bz2": { + "build": "h2fb9e7e_25399", + "build_number": 25399, + "depends": [ + "blas * mkl", + "mkl 2023.0.0 h6d00ec8_25399", + "mkl-include 2023.0.0 h06a4308_25399" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "58bf7e9bb2ded676ea97d798ca9abc86", + "name": "mkl-devel", + "sha256": "e8a78fb8fa7bf32e2593c1c9b74b6386cdd629962356e3a5d574e898cf30dd48", + "size": 34215, + "subdir": "linux-64", + "timestamp": 1677516879366, + "version": "2023.0.0" + }, + "mkl-devel-dpcpp-2021.3.0-h66538d2_521.tar.bz2": { + "build": "h66538d2_521", + "build_number": 521, + "depends": [ + "mkl-devel 2021.3.0", + "mkl-dpcpp 2021.3.0 h66538d2_521" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "b9aca2df1601b7975006247bc2403b43", + "name": "mkl-devel-dpcpp", + "sha256": "45b1735806d5040dd9f3920d2866b71f0398dfed11614f97630489ad3c5db879", + "size": 92101517, + "subdir": "linux-64", + "timestamp": 1645482089748, + "version": "2021.3.0" + }, + "mkl-devel-dpcpp-2021.4.0-h66538d2_640.tar.bz2": { + "build": "h66538d2_640", + "build_number": 640, + "depends": [ + "mkl-devel 2021.4.0", + "mkl-dpcpp 2021.4.0 h66538d2_640" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "cd01f7268598b9d86f4162ef42cf4a73", + "name": "mkl-devel-dpcpp", + "sha256": "ee73b82b436d5e8144048c670674c0b41672936cf3f31d29ae74a475e5c7d1f6", + "size": 100263275, + "subdir": "linux-64", + "timestamp": 1645482440821, + "version": "2021.4.0" + }, + "mkl-devel-dpcpp-2022.0.1-h66538d2_117.tar.bz2": { + "build": "h66538d2_117", + "build_number": 117, + "depends": [ + "mkl-devel 2022.0.1", + "mkl-dpcpp 2022.0.1 h66538d2_117" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "a975686304788674e77665f93eef2cea", + "name": "mkl-devel-dpcpp", + "sha256": "a49afc78a18d246cefc5ba7f88a76f781aafdf174548d16df4deffb1709b2df8", + "size": 100659183, + "subdir": "linux-64", + "timestamp": 1645539618882, + "version": "2022.0.1" + }, + "mkl-devel-dpcpp-2022.1.0-h2fb9e7e_223.tar.bz2": { + "build": "h2fb9e7e_223", + "build_number": 223, + "depends": [ + "mkl-devel 2022.1.0", + "mkl-dpcpp 2022.1.0 h2fb9e7e_223" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "95851a30d073fc52a2b9e44ef481686f", + "name": "mkl-devel-dpcpp", + "sha256": "259d33ff5efe93c9997f4df5f14fa6ce4157418bce111a57ea7df862683be6e9", + "size": 97411304, + "subdir": "linux-64", + "timestamp": 1667585637597, + "version": "2022.1.0" + }, + "mkl-devel-dpcpp-2023.0.0-h2fb9e7e_25398.tar.bz2": { + "build": "h2fb9e7e_25398", + "build_number": 25398, + "depends": [ + "mkl-devel 2023.0.0", + "mkl-dpcpp 2023.0.0 h2fb9e7e_25398" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "7fad90da23a980a1b03b7ef48d9b7de4", + "name": "mkl-devel-dpcpp", + "sha256": "892fa2f7e261c053a219f519b2c2a5272d3a967a5d77e58a0424ea0fed178e93", + "size": 123086864, + "subdir": "linux-64", + "timestamp": 1679615669326, + "version": "2023.0.0" + }, + "mkl-dnn-0.14-h6bb024c_0.tar.bz2": { + "build": "h6bb024c_0", + "build_number": 0, + "depends": [ + "intel-openmp >=2018.0.3,<2019.0a0", + "libgcc-ng >=7.2.0", + "libmklml >=2018.0.3", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "53fc292f505828a79127805db3d09093", + "name": "mkl-dnn", + "sha256": "2aaf9121b474d375228482db8b38ecd73938e9cbc23ef6d6c3375a66946244c0", + "size": 1656785, + "subdir": "linux-64", + "timestamp": 1530347088059, + "version": "0.14" + }, + "mkl-dnn-0.19-hd09550d_1.tar.bz2": { + "build": "hd09550d_1", + "build_number": 1, + "depends": [ + "intel-openmp >=2019.4,<2020.0a0", + "libgcc-ng >=7.5.0", + "libmklml >=2019.0.5", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a7f4495a6d6b72b53bb46597add4ecb0", + "name": "mkl-dnn", + "sha256": "21bf459cad6a33e13a1170b570cc7f22b7bf137bc1f591459b0b583fdf7850a4", + "size": 2560156, + "subdir": "linux-64", + "timestamp": 1643019947840, + "version": "0.19" + }, + "mkl-dnn-0.19-hfd86e86_1.tar.bz2": { + "build": "hfd86e86_1", + "build_number": 1, + "depends": [ + "intel-openmp >=2019.4,<2020.0a0", + "libgcc-ng >=7.3.0", + "libmklml >=2019.0.5", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9708bd91f81ca99edec26daa90d3ca17", + "name": "mkl-dnn", + "sha256": "a5eb1c25748b11661ded06e7730fb1d1e46fc09a8e95031c35f4a55544563b92", + "size": 2688995, + "subdir": "linux-64", + "timestamp": 1564763730429, + "version": "0.19" + }, + "mkl-dpcpp-2021.3.0-h66538d2_521.tar.bz2": { + "build": "h66538d2_521", + "build_number": 521, + "depends": [ + "dpcpp-cpp-rt 2021.*", + "intel-opencl-rt 2021.*", + "mkl 2021.3.0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "e637920edc32a328881369008fc95203", + "name": "mkl-dpcpp", + "sha256": "6c6e9a64ccbe997135297b5d0c59c255246d52d5f589e096a0e2db8ad73243be", + "size": 172612683, + "subdir": "linux-64", + "timestamp": 1645481878589, + "version": "2021.3.0" + }, + "mkl-dpcpp-2021.4.0-h66538d2_640.tar.bz2": { + "build": "h66538d2_640", + "build_number": 640, + "depends": [ + "dpcpp-cpp-rt 2021.*", + "intel-opencl-rt 2021.*", + "mkl 2021.4.0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "fe3fcabdefbf7fa7c6b7a603c71d3aff", + "name": "mkl-dpcpp", + "sha256": "b6f25a926bc6b94fb8fa38ca9c7caba894a5bd0b4d6fa948d8038f3dafc65eaa", + "size": 185661855, + "subdir": "linux-64", + "timestamp": 1645482208671, + "version": "2021.4.0" + }, + "mkl-dpcpp-2022.0.1-h66538d2_117.tar.bz2": { + "build": "h66538d2_117", + "build_number": 117, + "depends": [ + "dpcpp-cpp-rt 2022.*", + "intel-opencl-rt 2022.*", + "mkl 2022.0.1" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "a858b82a575e3bc331abf2a49d3e9289", + "name": "mkl-dpcpp", + "sha256": "8f6c3946a80e64a2ea703e97bbe1c80e50dc237021e4167feed4c061b7b5774a", + "size": 197564392, + "subdir": "linux-64", + "timestamp": 1645539399634, + "version": "2022.0.1" + }, + "mkl-dpcpp-2022.1.0-h2fb9e7e_223.tar.bz2": { + "build": "h2fb9e7e_223", + "build_number": 223, + "depends": [ + "dpcpp-cpp-rt 2022.*", + "intel-opencl-rt 2022.*", + "mkl 2022.1.0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "55877b1aa8ee0a159cbb68adc2a3623c", + "name": "mkl-dpcpp", + "sha256": "4712ecd21e56ed7b952361c3bff56882d43a02560b5270e2e7c9753b0c3ca93e", + "size": 93168933, + "subdir": "linux-64", + "timestamp": 1667585443825, + "version": "2022.1.0" + }, + "mkl-dpcpp-2023.0.0-h2fb9e7e_25398.tar.bz2": { + "build": "h2fb9e7e_25398", + "build_number": 25398, + "depends": [ + "dpcpp-cpp-rt 2023.*", + "intel-opencl-rt 2023.*", + "mkl 2023.0.0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "7b756d975e142823cb0b93d1fd123c3c", + "name": "mkl-dpcpp", + "sha256": "1c833e3e578718ac99ce0c55f17ec3100bcf6136bca85e1e9c10b3657947fdc8", + "size": 108035241, + "subdir": "linux-64", + "timestamp": 1679615461246, + "version": "2023.0.0" + }, + "mkl-include-2017.0.4-hf7c01fb_0.tar.bz2": { + "build": "hf7c01fb_0", + "build_number": 0, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "86a59f660671a3775d66fa32d173a259", + "name": "mkl-include", + "sha256": "af55f24d194c71542e9dec0a7c669acdce153875fa11a3ede0e427a33dacddfe", + "size": 800630, + "subdir": "linux-64", + "timestamp": 1508962803336, + "version": "2017.0.4" + }, + "mkl-include-2018.0.0-h15fc484_2.tar.bz2": { + "build": "h15fc484_2", + "build_number": 2, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "9be20ebf746816c9fdc549182c4e615f", + "name": "mkl-include", + "sha256": "d2e54835b4031352834f02213568315692a8920a4d13110d92ab6c0425583bc2", + "size": 578217, + "subdir": "linux-64", + "timestamp": 1505745612210, + "version": "2018.0.0" + }, + "mkl-include-2018.0.1-hc7b2577_4.tar.bz2": { + "build": "hc7b2577_4", + "build_number": 4, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "e62dc2547caecbc1716d1fac1fbddf1e", + "name": "mkl-include", + "sha256": "950d9fbf32d0257938073b4a948376ee7ef9812f6c7bf1ada9c827c4f7085f88", + "size": 587747, + "subdir": "linux-64", + "timestamp": 1511376417391, + "version": "2018.0.1" + }, + "mkl-include-2018.0.2-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "84886748451ba3303c88068c0e9ff915", + "name": "mkl-include", + "sha256": "70564c5419ed35cf52b8add05ed5bd0e1c3cda66f96cecf977783b9468d6b3d0", + "size": 587693, + "subdir": "linux-64", + "timestamp": 1521735601913, + "version": "2018.0.2" + }, + "mkl-include-2018.0.3-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "441846d6583864694b6da92486ecb011", + "name": "mkl-include", + "sha256": "c5dacef203e58b27756ac7495cc57b591dc714b57c93e5a796cc4ae641e737fa", + "size": 583624, + "subdir": "linux-64", + "timestamp": 1528122055507, + "version": "2018.0.3" + }, + "mkl-include-2019.0-117.tar.bz2": { + "build": "117", + "build_number": 117, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "ff775777432c3d66d1ebaa01f0a2a0f2", + "name": "mkl-include", + "sha256": "0a0baa2d87be7b81a3549b6cf76c37247f109ea7b646b43f85b420cf1f7eccda", + "size": 592210, + "subdir": "linux-64", + "timestamp": 1536594379207, + "version": "2019.0" + }, + "mkl-include-2019.0-118.tar.bz2": { + "build": "118", + "build_number": 118, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "d85832637bdf5dfe52e052107aff7d93", + "name": "mkl-include", + "sha256": "c6bf434ee42468d12cba31835a839ba7449ae40e35f4ff1ef95f4c6c1d3d70cc", + "size": 590907, + "subdir": "linux-64", + "timestamp": 1537292392867, + "version": "2019.0" + }, + "mkl-include-2019.1-144.tar.bz2": { + "build": "144", + "build_number": 144, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "34afdfeb742bb69062c6a49260afd397", + "name": "mkl-include", + "sha256": "95a0fa4624308ec321a46c819174de30aa28465551e696c42f7f6b28172c3a0b", + "size": 601160, + "subdir": "linux-64", + "timestamp": 1542661344765, + "version": "2019.1" + }, + "mkl-include-2019.3-199.tar.bz2": { + "build": "199", + "build_number": 199, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "a77c88a02d7d6d3d4ac4f45095646f3b", + "name": "mkl-include", + "sha256": "e014580b79aa664616d9bd6f0994146cc5cc3249e04c07b1fdfc8d3e097741b3", + "size": 616071, + "subdir": "linux-64", + "timestamp": 1552593611793, + "version": "2019.3" + }, + "mkl-include-2019.4-243.tar.bz2": { + "build": "243", + "build_number": 243, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "ffd361a57ed2b4cfdef826444950bc81", + "name": "mkl-include", + "sha256": "b9fdc98a056d3cb8f74f444e18494766a531729cf5a80de6de8c0683a0aaa64a", + "size": 609711, + "subdir": "linux-64", + "timestamp": 1559526511979, + "version": "2019.4" + }, + "mkl-include-2020.0-166.tar.bz2": { + "build": "166", + "build_number": 166, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "ab0727914cbc190ba291eb187ad6261c", + "name": "mkl-include", + "sha256": "2af3494a4bebe5ddccfdc43bacc80fcd78d14c1954b81d2c8e3d73b55527af90", + "size": 608439, + "subdir": "linux-64", + "timestamp": 1580943976649, + "version": "2020.0" + }, + "mkl-include-2020.1-217.tar.bz2": { + "build": "217", + "build_number": 217, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "07c6d76307e529a3e944326d8397c04c", + "name": "mkl-include", + "sha256": "812ccfab02b7fe3cb5f17727bf75f327690432895dc2db5e4cd4f35296c7030a", + "size": 607116, + "subdir": "linux-64", + "timestamp": 1589162246527, + "version": "2020.1" + }, + "mkl-include-2020.2-256.tar.bz2": { + "build": "256", + "build_number": 256, + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "21aa1f534d260918db7c486d4c3c274e", + "name": "mkl-include", + "sha256": "702a42c582f70e35f172d717e9ec875f477b049f1f80f31d2a40496fd42cd4fc", + "size": 625060, + "subdir": "linux-64", + "timestamp": 1598384196673, + "version": "2020.2" + }, + "mkl-include-2021.2.0-h06a4308_296.tar.bz2": { + "build": "h06a4308_296", + "build_number": 296, + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "d837fd7d127399ef4b6c4550dbe064a1", + "name": "mkl-include", + "sha256": "6997e2963d73b7627f5b961ffb50f3c954678b11fe314448c3c7051cd5a936e6", + "size": 683766, + "subdir": "linux-64", + "timestamp": 1618534009438, + "version": "2021.2.0" + }, + "mkl-include-2021.3.0-h06a4308_520.tar.bz2": { + "build": "h06a4308_520", + "build_number": 520, + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "5ed9f81c65eed134f229f90568e752cb", + "name": "mkl-include", + "sha256": "6db7a50234a0e85e5dbd3c64163d325eabf72cd4f73135cbd6bda10cdcebf2c5", + "size": 702988, + "subdir": "linux-64", + "timestamp": 1626182300408, + "version": "2021.3.0" + }, + "mkl-include-2021.4.0-h06a4308_640.tar.bz2": { + "build": "h06a4308_640", + "build_number": 640, + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "57e155bdd15d2c23083b627fe459a52c", + "name": "mkl-include", + "sha256": "fdfe5c572d0e905b47e064b354f33e4d07d05d6445edbc910ed52c968277fa87", + "size": 694794, + "subdir": "linux-64", + "timestamp": 1634546769614, + "version": "2021.4.0" + }, + "mkl-include-2022.0.1-h06a4308_117.tar.bz2": { + "build": "h06a4308_117", + "build_number": 117, + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "485aea687cb567a0eda4eba6fb12e4f7", + "name": "mkl-include", + "sha256": "f1625887e4e443673e3ac879501081ef7522cf45f6c36fddd7a1ec6a4b44bae5", + "size": 747161, + "subdir": "linux-64", + "timestamp": 1642705449302, + "version": "2022.0.1" + }, + "mkl-include-2022.1.0-h06a4308_223.tar.bz2": { + "build": "h06a4308_223", + "build_number": 223, + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "c92d280659b04a5c7640586475e860c4", + "name": "mkl-include", + "sha256": "e27c12b4ba7a2a594efdc58b2268f3acec579f7f3d6d98fec2defaabd5ae44be", + "size": 761002, + "subdir": "linux-64", + "timestamp": 1662087969702, + "version": "2022.1.0" + }, + "mkl-include-2022.1.0-h06a4308_224.tar.bz2": { + "build": "h06a4308_224", + "build_number": 224, + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "20029d75a66521dadff18f2bb98c4560", + "name": "mkl-include", + "sha256": "cf2a07b765075744d4b438cca5e210fde2627af5e6435ac8085dac2e700b9c0a", + "size": 759166, + "subdir": "linux-64", + "timestamp": 1662497672210, + "version": "2022.1.0" + }, + "mkl-include-2023.0.0-h06a4308_25399.tar.bz2": { + "build": "h06a4308_25399", + "build_number": 25399, + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "0ed16c34c5750463d9d20b8e83da5a62", + "name": "mkl-include", + "sha256": "ea6299ada2558bb691685c59af12d1dc717ab4462de27a246ec4046042192a06", + "size": 784862, + "subdir": "linux-64", + "timestamp": 1677516520184, + "version": "2023.0.0" + }, + "mkl-service-1.1.2-py27h651fb7a_4.tar.bz2": { + "build": "py27h651fb7a_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "d0dfc3307f1cef7c11503d1e027128b0", + "name": "mkl-service", + "sha256": "166eb5413e797ca7c0ffbf55f5bc5aa950840c5e576a7d7147827259ab6f7328", + "size": 10815, + "subdir": "linux-64", + "timestamp": 1530696013217, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py27h90e4bf4_5.tar.bz2": { + "build": "py27h90e4bf4_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "c8c416cf8ff5c32898d9fb5903f684f7", + "name": "mkl-service", + "sha256": "31d43550eb6ae0bede9ee16d4147232a3f46e5681b8c3e4c5ae0de1d2fce7e58", + "size": 10960, + "subdir": "linux-64", + "timestamp": 1537536181426, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py27hb2d42c5_4.tar.bz2": { + "build": "py27hb2d42c5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "d68cd0a17f89490d32ee031f8a65b220", + "name": "mkl-service", + "sha256": "5a7afd913baefdf08b867172e865619d6b8320f8630d06502e3aaed5d76a159f", + "size": 10376, + "subdir": "linux-64", + "timestamp": 1505745850011, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py27he904b0f_5.tar.bz2": { + "build": "py27he904b0f_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "977db172a93e9ce000ca606bee47bf19", + "name": "mkl-service", + "sha256": "8f98488e87ed5966a82965b695202d05d5775ef644d0ce427c66d77cfc91cea0", + "size": 134639, + "subdir": "linux-64", + "timestamp": 1544935218549, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py35h0fc7090_4.tar.bz2": { + "build": "py35h0fc7090_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "1b544875526b804b89fbf9fb657b39b3", + "name": "mkl-service", + "sha256": "faea060503ebc8a4059eb5822894914b20cd59b7530e52742a0e843dd7695005", + "size": 10488, + "subdir": "linux-64", + "timestamp": 1505745864508, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py35h651fb7a_4.tar.bz2": { + "build": "py35h651fb7a_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "5e8ef89fdd0021198a42e4bdf110136f", + "name": "mkl-service", + "sha256": "d1968e15f7e986c29157bd9e95ad31ad2b3862bbc4fc0ce40626bcb7f9202799", + "size": 10864, + "subdir": "linux-64", + "timestamp": 1534345616729, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py35h90e4bf4_5.tar.bz2": { + "build": "py35h90e4bf4_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "017ad3827bff6e0a5518bdd08bfca6d7", + "name": "mkl-service", + "sha256": "bf50d38ced2673e82049c9fe0cf16f0112546b77e443487b8a3830ce0b79ddbe", + "size": 11038, + "subdir": "linux-64", + "timestamp": 1537536212365, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py36h17a0993_4.tar.bz2": { + "build": "py36h17a0993_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "341daab4202a2bc783f5074f4d3d9cba", + "name": "mkl-service", + "sha256": "a3d1ff7a2fd69dee53e90400573a6d7b1958629580673e4bff1da2d06dd23864", + "size": 10510, + "subdir": "linux-64", + "timestamp": 1505745879701, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py36h651fb7a_4.tar.bz2": { + "build": "py36h651fb7a_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "d7b00927e740766caa4aff7f68a83f06", + "name": "mkl-service", + "sha256": "847067c556a7eb0c91d67c8b4a44b613e24416b6d710e7a83193260cc5c5c849", + "size": 10927, + "subdir": "linux-64", + "timestamp": 1530695963798, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py36h90e4bf4_5.tar.bz2": { + "build": "py36h90e4bf4_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "ff45085efa91a5d0a9c818b493233f57", + "name": "mkl-service", + "sha256": "247641f94f05502f518617d3cb9cfa7b7c3b28ceb0a1b6ec4948389063a276bf", + "size": 11052, + "subdir": "linux-64", + "timestamp": 1537536233558, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py36he904b0f_5.tar.bz2": { + "build": "py36he904b0f_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "9d4565b48f3be5179faca5f87ba05243", + "name": "mkl-service", + "sha256": "6e234bbd5d1768fe54e07365390534223426bacec0d48b60e674ea690f1d24d0", + "size": 134715, + "subdir": "linux-64", + "timestamp": 1544935298106, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py37h651fb7a_4.tar.bz2": { + "build": "py37h651fb7a_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "65834987faa155d97a85759046b9fe9e", + "name": "mkl-service", + "sha256": "bceb1ffc83dd1006b6b3831b43b17633674cff3d5fb8d07bb5052ff872a30e55", + "size": 10948, + "subdir": "linux-64", + "timestamp": 1530695988102, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py37h90e4bf4_5.tar.bz2": { + "build": "py37h90e4bf4_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "dcd989cf90ade89127882c73ed6ab559", + "name": "mkl-service", + "sha256": "9ed14a67bc8696a1e7a511d589b3a01c75f46d6fa769f934d3a9d852932cccc3", + "size": 11029, + "subdir": "linux-64", + "timestamp": 1537536095245, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py37he904b0f_5.tar.bz2": { + "build": "py37he904b0f_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "b063ef6981a5310cc7c4f60174af00c7", + "name": "mkl-service", + "sha256": "cb9da75e48ffb76ecc7d87f264b26a97a448ea7980002880fa67dcd01c065459", + "size": 134719, + "subdir": "linux-64", + "timestamp": 1544935303295, + "version": "1.1.2" + }, + "mkl-service-2.0.2-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "63ff8943b827cf82a4d6018e710b71b7", + "name": "mkl-service", + "sha256": "74b3fe23c2164b3c9fd328896f271b5cdd8c863893c79b7dd81418e9f502c11e", + "size": 68914, + "subdir": "linux-64", + "timestamp": 1559316481875, + "version": "2.0.2" + }, + "mkl-service-2.0.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1c77258014d7c5a0f0df7756c8d39b2f", + "name": "mkl-service", + "sha256": "ea3cea634069c21fe647972bfddb221fedaaab916711965454321138f07bf7f5", + "size": 71552, + "subdir": "linux-64", + "timestamp": 1559316384631, + "version": "2.0.2" + }, + "mkl-service-2.0.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "097979936403926185e70cd2a260ad5a", + "name": "mkl-service", + "sha256": "51351beeecc47ec38d1259e3a98ae98a3fea2d616a8fb49b8b6f1eda5d79e325", + "size": 71790, + "subdir": "linux-64", + "timestamp": 1559316371110, + "version": "2.0.2" + }, + "mkl-service-2.3.0-py27he904b0f_0.tar.bz2": { + "build": "py27he904b0f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "2ac5910d03ffa7c2f313bedd5b25f73b", + "name": "mkl-service", + "sha256": "a7ce656429e075abf56a604bff577f960f2251e47cd743c7b39ff2e462f16d55", + "size": 210263, + "subdir": "linux-64", + "timestamp": 1567795987414, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8c28fb9c9a0091af2c50675e580777a3", + "name": "mkl-service", + "sha256": "8643352a8f82e07538c29670691e58f57d6817702e1a72adaa9754fa690b4298", + "size": 58808, + "subdir": "linux-64", + "timestamp": 1618348284133, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py36he8ac12f_0.tar.bz2": { + "build": "py36he8ac12f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eadacb9f86689fe048063db916610103", + "name": "mkl-service", + "sha256": "95d55b4eea79fc714fb948980977677f4e54f423b20628fe0669b66903653285", + "size": 56854, + "subdir": "linux-64", + "timestamp": 1607032457694, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py36he904b0f_0.tar.bz2": { + "build": "py36he904b0f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "c6d6df577b0647f19b8c7f962a055af2", + "name": "mkl-service", + "sha256": "e9dcfbe86444161e99ad74151674953681e5fb7c66c1c6791d7fd771788c1a52", + "size": 212661, + "subdir": "linux-64", + "timestamp": 1567796014703, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a18ab3bc37cba54c7acb0d20803fa6af", + "name": "mkl-service", + "sha256": "4d7830c223d0004301c6be94a4b313a7be3afcf3bbf8e81798742a0837a0e3d9", + "size": 58726, + "subdir": "linux-64", + "timestamp": 1618348297275, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py37he8ac12f_0.tar.bz2": { + "build": "py37he8ac12f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "68eca5d9fc834c2e8cd6d0b821546ea9", + "name": "mkl-service", + "sha256": "ddc6a54e5e7f8e3ab8b2aedc8729652c8d167db621373170e78cc405cfdb8981", + "size": 56965, + "subdir": "linux-64", + "timestamp": 1607032437913, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py37he904b0f_0.tar.bz2": { + "build": "py37he904b0f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "7b624f3f5cc1d6a3b5c9c300c89b3025", + "name": "mkl-service", + "sha256": "da5de7f7e3e06a62436882e17d90176c53c0f4db2fd527977b7e19e612016640", + "size": 212823, + "subdir": "linux-64", + "timestamp": 1567796042190, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20fce816b422dc529fa78b44c36a6b28", + "name": "mkl-service", + "sha256": "a770abfe01e75fd3628910ff32e741a01c16575cf1487b5d9afe8e5077d2e3cd", + "size": 61717, + "subdir": "linux-64", + "timestamp": 1618348300432, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d14755a70c4fbe812359c05e23b2c9bf", + "name": "mkl-service", + "sha256": "869be53b0b5fb2c6f50fefd77b2641454d799248e3c6366c86ddac20be5e5058", + "size": 70827, + "subdir": "linux-64", + "timestamp": 1573151203928, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py38he904b0f_0.tar.bz2": { + "build": "py38he904b0f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "f85364b12ea29862e1e025ddfa868736", + "name": "mkl-service", + "sha256": "fdd07ca5c4e21dbe6dd5433235b7eb2792fe4b746c6e6768bdc48ef803ff6c9d", + "size": 69662, + "subdir": "linux-64", + "timestamp": 1573489133528, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "29db9f149e81cd1ff722cdba5f284092", + "name": "mkl-service", + "sha256": "7dedbd5b9db676aa6e1dbba36563146e0824ffc905931c83edd4badc72d56bb6", + "size": 61560, + "subdir": "linux-64", + "timestamp": 1618348287948, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py39he8ac12f_0.tar.bz2": { + "build": "py39he8ac12f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "39b0b212f9af768bcc80431fcccea40b", + "name": "mkl-service", + "sha256": "9dd0c600b832b87199505649ab13aef33ac08ee2ea0964c33632ed546c5c99ed", + "size": 59488, + "subdir": "linux-64", + "timestamp": 1607032458836, + "version": "2.3.0" + }, + "mkl-service-2.4.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "83252b73851c784755a30c4932db6377", + "name": "mkl-service", + "sha256": "6704d413c29ff9976ad9f08373806c21ef2444ce072a67663023a0d87d3de13f", + "size": 217747, + "subdir": "linux-64", + "timestamp": 1641844379720, + "version": "2.4.0" + }, + "mkl-service-2.4.0-py310heee7806_0.tar.bz2": { + "build": "py310heee7806_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bdc05ceced5c827d401291c3a715c92c", + "name": "mkl-service", + "sha256": "6029fefce3e4e2d6172772361fa3755b3c4f1f6a0600eb196bb00dff60f2309a", + "size": 220703, + "subdir": "linux-64", + "timestamp": 1639659879355, + "version": "2.4.0" + }, + "mkl-service-2.4.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3dcb12c6b0eeeccd8ff639c171d25123", + "name": "mkl-service", + "sha256": "55d6345e0a3a06c9995555cb965841327d70b6cb4a1e11c8101332b30c6ab0bb", + "size": 58378, + "subdir": "linux-64", + "timestamp": 1676845023960, + "version": "2.4.0" + }, + "mkl-service-2.4.0-py36h7f8727e_0.tar.bz2": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mkl >=2021.2.0,<2022.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5173d09d329de29dd65be45bd1450662", + "name": "mkl-service", + "sha256": "6347f79c866f8de75f15189d04a3f4c6f948aef8c12feb20f827d95233be1c22", + "size": 60718, + "subdir": "linux-64", + "timestamp": 1626183963757, + "version": "2.4.0" + }, + "mkl-service-2.4.0-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mkl >=2021.2.0,<2022.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d690672d3342a5b67c4eaa106a11d09d", + "name": "mkl-service", + "sha256": "454ab0ed85ab63c88bf604d4ba9ee4f68c05c62b463cce061e5a47ea2a8648b7", + "size": 60756, + "subdir": "linux-64", + "timestamp": 1626183943934, + "version": "2.4.0" + }, + "mkl-service-2.4.0-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mkl >=2021.2.0,<2022.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "350e1ec6d837a61b44bf3c26dc8d094b", + "name": "mkl-service", + "sha256": "d4bc8c57703eb186f6a95bcb052042ae3bdc18e97e2be7362a1473055c70ea04", + "size": 63766, + "subdir": "linux-64", + "timestamp": 1626183937671, + "version": "2.4.0" + }, + "mkl-service-2.4.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mkl >=2021.2.0,<2022.0a0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d3cb2bfa63e30153f5527797dcc87280", + "name": "mkl-service", + "sha256": "5394f5efd53afb2c1b0abf571ce3d9cb684b6c7e255f140ba2acaa703d6113be", + "size": 63551, + "subdir": "linux-64", + "timestamp": 1626176932911, + "version": "2.4.0" + }, + "mkl_fft-1.0.1-py27h3010b51_0.tar.bz2": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD", + "md5": "d11a8494f8d0f8890c585c6776cdd3b1", + "name": "mkl_fft", + "sha256": "7eaafe83630abada095c56822824e4cefdca8a4bdbdcca7c45ac7098fa6cc030", + "size": 140546, + "subdir": "linux-64", + "timestamp": 1519403907993, + "version": "1.0.1" + }, + "mkl_fft-1.0.1-py35h3010b51_0.tar.bz2": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD", + "md5": "bc88eee3eb5e90325dd8154a01ee30d8", + "name": "mkl_fft", + "sha256": "95e1555c1a6004338bca4735e85b6fa607f1e768b16de66d2d6c328591a6465f", + "size": 142158, + "subdir": "linux-64", + "timestamp": 1519404566936, + "version": "1.0.1" + }, + "mkl_fft-1.0.1-py36h3010b51_0.tar.bz2": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD", + "md5": "8fca95a826e32f65cf1d399fd679c440", + "name": "mkl_fft", + "sha256": "e860ed5b28b8ca91b44794671690da19d3dd203c1efa6192dd16d3806cf7dbcd", + "size": 143307, + "subdir": "linux-64", + "timestamp": 1519403814410, + "version": "1.0.1" + }, + "mkl_fft-1.0.10-py27ha843d7b_0.tar.bz2": { + "build": "py27ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c43914c7bcb2c0adc4cc85af9e8fdd0f", + "name": "mkl_fft", + "sha256": "4592c292b28d6dc10dccaac714f199ec496d9920b8eaaf98fac021178958e5cb", + "size": 165070, + "subdir": "linux-64", + "timestamp": 1547238499605, + "version": "1.0.10" + }, + "mkl_fft-1.0.10-py36ha843d7b_0.tar.bz2": { + "build": "py36ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "98ffd5385e7341692a01eaa56104c3e5", + "name": "mkl_fft", + "sha256": "b7ea306918076251e9d69cb6905fc903d0424c1cc99878e995628f2761b1e097", + "size": 174200, + "subdir": "linux-64", + "timestamp": 1547238568666, + "version": "1.0.10" + }, + "mkl_fft-1.0.10-py37ha843d7b_0.tar.bz2": { + "build": "py37ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6b24a8789bf362251a24bff837fb4f90", + "name": "mkl_fft", + "sha256": "033a33e7307a2d62a5b9b62fcc3cbfdb1ac47587e2f1fbe2b535d20d3e19cb6d", + "size": 173358, + "subdir": "linux-64", + "timestamp": 1547238476684, + "version": "1.0.10" + }, + "mkl_fft-1.0.12-py27ha843d7b_0.tar.bz2": { + "build": "py27ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4151585072f4018248b2105defd042ce", + "name": "mkl_fft", + "sha256": "69cf097fb244620e0788c424a143db88251279fc2ad96441ddc90b8b5565d48c", + "size": 167280, + "subdir": "linux-64", + "timestamp": 1556550168042, + "version": "1.0.12" + }, + "mkl_fft-1.0.12-py36ha843d7b_0.tar.bz2": { + "build": "py36ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "80a76705d0c15c147af19c118a7dd035", + "name": "mkl_fft", + "sha256": "d836be8f9e72334167cf4cc7cbcd932dc8877d1164afca48c17996efb7bbb130", + "size": 176285, + "subdir": "linux-64", + "timestamp": 1556550129699, + "version": "1.0.12" + }, + "mkl_fft-1.0.12-py37ha843d7b_0.tar.bz2": { + "build": "py37ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "28e00310cf0858a05ce0d69c02283a20", + "name": "mkl_fft", + "sha256": "285dc2026058af5422cdfe9269b51a77baa664f51c9511631c343ff31a092fe4", + "size": 175926, + "subdir": "linux-64", + "timestamp": 1556550047823, + "version": "1.0.12" + }, + "mkl_fft-1.0.14-py27ha843d7b_0.tar.bz2": { + "build": "py27ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6e5781fc85343e92e883f900198962f6", + "name": "mkl_fft", + "sha256": "14fb3beb4624c950ffc1d4c6c4ab76d85aad3548a9966f41dd9b310d4a9384ad", + "size": 168098, + "subdir": "linux-64", + "timestamp": 1565899092135, + "version": "1.0.14" + }, + "mkl_fft-1.0.14-py36ha843d7b_0.tar.bz2": { + "build": "py36ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ea1ad348e7188e02cc47cd5b18bb2719", + "name": "mkl_fft", + "sha256": "57d479d300b217bdede0580e8185010a30562294f1407c93106ea15dc8baa1d9", + "size": 177036, + "subdir": "linux-64", + "timestamp": 1565898881483, + "version": "1.0.14" + }, + "mkl_fft-1.0.14-py37ha843d7b_0.tar.bz2": { + "build": "py37ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2198e6adafdc2b138eb7708d13beed10", + "name": "mkl_fft", + "sha256": "dd593e4a729cc0e2110bba00e7a32da3fc9e5210231d739d77d23c4a88def32f", + "size": 176253, + "subdir": "linux-64", + "timestamp": 1565899130807, + "version": "1.0.14" + }, + "mkl_fft-1.0.15-py27ha843d7b_0.tar.bz2": { + "build": "py27ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "aeded7045bea616f6bfe765443c5c244", + "name": "mkl_fft", + "sha256": "018533f701209504e167fb8263c9fee5044a083bffeaaa3e3db51fc6e19e1a99", + "size": 168010, + "subdir": "linux-64", + "timestamp": 1573077616164, + "version": "1.0.15" + }, + "mkl_fft-1.0.15-py36ha843d7b_0.tar.bz2": { + "build": "py36ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0546b210620e8c3fe0500c23a4b618cf", + "name": "mkl_fft", + "sha256": "8c4a78bd9f604f890c9b334816cfeabc0c78b90992f68c61a27b16c008f13b33", + "size": 176987, + "subdir": "linux-64", + "timestamp": 1573077627240, + "version": "1.0.15" + }, + "mkl_fft-1.0.15-py37ha843d7b_0.tar.bz2": { + "build": "py37ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2e1c1bca6bac3aa99b33c8204c509f31", + "name": "mkl_fft", + "sha256": "3c19299fc9e2b3b21d1e702af20f0ede19e53a7f574fe84e9b1cfd18ea5ed963", + "size": 176537, + "subdir": "linux-64", + "timestamp": 1573077646133, + "version": "1.0.15" + }, + "mkl_fft-1.0.15-py38ha843d7b_0.tar.bz2": { + "build": "py38ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dcc5c89a21998a1d269ed9f7a6fae0d9", + "name": "mkl_fft", + "sha256": "ad24e954606f5183d31cc99b20c86d878963c5a75626815cfc056c266ccbb55d", + "size": 182577, + "subdir": "linux-64", + "timestamp": 1573738232276, + "version": "1.0.15" + }, + "mkl_fft-1.0.2-py27h651fb7a_0.tar.bz2": { + "build": "py27h651fb7a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "69ab6a3c2c253bfff33577dc6cc32247", + "name": "mkl_fft", + "sha256": "570bd42023ec5f7a6fcc13cb04f775530167abd815b91bc714eb262f023f6ae5", + "size": 141761, + "subdir": "linux-64", + "timestamp": 1530725215767, + "version": "1.0.2" + }, + "mkl_fft-1.0.2-py35h651fb7a_0.tar.bz2": { + "build": "py35h651fb7a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "6687578cda8d26ddd4caa939b604041d", + "name": "mkl_fft", + "sha256": "03c16900099e2de988908a2140fe8285af4ffe4edb8f34de8553c6d73cfed9f9", + "size": 142593, + "subdir": "linux-64", + "timestamp": 1534346694665, + "version": "1.0.2" + }, + "mkl_fft-1.0.2-py36h651fb7a_0.tar.bz2": { + "build": "py36h651fb7a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "5625f99bbfe75dbe07c16fbdbe6b1706", + "name": "mkl_fft", + "sha256": "8fb860db2e44ede6820ba3cfdefee8b1547d4e3698e1f017f5cd22de18e2f1d4", + "size": 144169, + "subdir": "linux-64", + "timestamp": 1530723353179, + "version": "1.0.2" + }, + "mkl_fft-1.0.2-py37h651fb7a_0.tar.bz2": { + "build": "py37h651fb7a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "622ac6989c43af8b66ad5aae9983568e", + "name": "mkl_fft", + "sha256": "fd60bcfb8a9eed8d1a297d28e448742305bb9ecc9bce2deb9a58d4c52fa1aaeb", + "size": 143538, + "subdir": "linux-64", + "timestamp": 1530716420410, + "version": "1.0.2" + }, + "mkl_fft-1.0.4-py27h4414c95_0.tar.bz2": { + "build": "py27h4414c95_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6a56edbcb6abeba7b7dbd7dad4aaba3c", + "name": "mkl_fft", + "sha256": "12bff79fd41a88b49fbad5020f26bc67b3b9227ec293d04142d048c5f7586fba", + "size": 150444, + "subdir": "linux-64", + "timestamp": 1532663179487, + "version": "1.0.4" + }, + "mkl_fft-1.0.4-py27h4414c95_1.tar.bz2": { + "build": "py27h4414c95_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "03ed0c56a77a56a721a2656852ba88ca", + "name": "mkl_fft", + "sha256": "d4feb9a7ab249f24a4286e88660308ce76a240d8c0267e5385063f4b96b9fe3d", + "size": 150698, + "subdir": "linux-64", + "timestamp": 1532700925153, + "version": "1.0.4" + }, + "mkl_fft-1.0.4-py35h4414c95_0.tar.bz2": { + "build": "py35h4414c95_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "61c1ec87fc8a9305e103d8c3f1765955", + "name": "mkl_fft", + "sha256": "c57f671e7211876773c291e4329dc12ace818ba52122ae6f1d629ec68f8c3141", + "size": 151110, + "subdir": "linux-64", + "timestamp": 1532663187879, + "version": "1.0.4" + }, + "mkl_fft-1.0.4-py35h4414c95_1.tar.bz2": { + "build": "py35h4414c95_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4f4cb7ce1a9c386fe3dd75d6e463e1ad", + "name": "mkl_fft", + "sha256": "e280f1756b91194bff54baa533e8db4668b86a8680af132776d26a7913f3e2df", + "size": 151261, + "subdir": "linux-64", + "timestamp": 1532701016345, + "version": "1.0.4" + }, + "mkl_fft-1.0.4-py36h4414c95_0.tar.bz2": { + "build": "py36h4414c95_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9e7557f0e14eb4619d61417f62055aac", + "name": "mkl_fft", + "sha256": "c334e1856891b6fa91d86c1a94ef8d9c2b18aa4f6f009406f145f514d1f9b4f2", + "size": 152495, + "subdir": "linux-64", + "timestamp": 1532656775556, + "version": "1.0.4" + }, + "mkl_fft-1.0.4-py36h4414c95_1.tar.bz2": { + "build": "py36h4414c95_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f011ccdb171a249221ccef689a11ffef", + "name": "mkl_fft", + "sha256": "4bfd2fdcbab767c2d50a2f9235b6d715cc5a822f1214991af39657e8f7c2697e", + "size": 153360, + "subdir": "linux-64", + "timestamp": 1532700514318, + "version": "1.0.4" + }, + "mkl_fft-1.0.4-py37h4414c95_0.tar.bz2": { + "build": "py37h4414c95_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "54e5f6f2ca250ca60222dc4d4b7e9e29", + "name": "mkl_fft", + "sha256": "b3b3f84a9ab058f1d4f5d2199ad1a4ade827bef13d20c18413710bf53fc7acb8", + "size": 152063, + "subdir": "linux-64", + "timestamp": 1532656777260, + "version": "1.0.4" + }, + "mkl_fft-1.0.4-py37h4414c95_1.tar.bz2": { + "build": "py37h4414c95_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b1d8dfac6e28a2cb19b9b9cfb243eba8", + "name": "mkl_fft", + "sha256": "b7e6d7723ff546007aec2f7ceb0386610f024057c2d0bfa477f99db3d893ad0b", + "size": 152149, + "subdir": "linux-64", + "timestamp": 1532701018408, + "version": "1.0.4" + }, + "mkl_fft-1.0.6-py27h423224d_0.tar.bz2": { + "build": "py27h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.6,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "626447a5bc3b276377d4a30d1f826376", + "name": "mkl_fft", + "sha256": "a40d669eee8664dd72e13658fdd4c3ffca97013319e54bc06ea58dd9b8d5655b", + "size": 196960, + "subdir": "linux-64", + "timestamp": 1580501570031, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py27h7dd41cf_0.tar.bz2": { + "build": "py27h7dd41cf_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "26cdd249e3689fbf29dbe52c085188dc", + "name": "mkl_fft", + "sha256": "08b5e479c94bfc04cf01c8ab74e1f66097cd19b86a096e58e80d9864535fcdff", + "size": 152051, + "subdir": "linux-64", + "timestamp": 1538068237670, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py27hd81dba3_0.tar.bz2": { + "build": "py27hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy-base >=1.0.6,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "696a3c21fadf908905b8d20ca73d7ad3", + "name": "mkl_fft", + "sha256": "6d86b7a287a7c84a3a0040fb862c6ec57ebd062831947db4e4ca4a7a54b4af04", + "size": 195327, + "subdir": "linux-64", + "timestamp": 1544718170889, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py35h7dd41cf_0.tar.bz2": { + "build": "py35h7dd41cf_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7b5cb806b5c322dad752d76790fe3bcc", + "name": "mkl_fft", + "sha256": "a0098ab005cab9e48e36d40a493c2cb5c66906c53e112fc37303765be9ed14a9", + "size": 152523, + "subdir": "linux-64", + "timestamp": 1538068269713, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py36h423224d_0.tar.bz2": { + "build": "py36h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "74650b7948028efc1fd2091500218d41", + "name": "mkl_fft", + "sha256": "21d1091c6634fa6fcb3967ca530e4cca0a626f361c9a8e05e002c3a5f742f9a1", + "size": 203418, + "subdir": "linux-64", + "timestamp": 1580488396134, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py36h7dd41cf_0.tar.bz2": { + "build": "py36h7dd41cf_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "72cfaaca1daec7a6eadb83320cc8f56b", + "name": "mkl_fft", + "sha256": "7312b6bf8c016b3c257e5951bf46e4b530f00b58110727d811dd379ff7710b68", + "size": 153728, + "subdir": "linux-64", + "timestamp": 1538068191970, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py36hd81dba3_0.tar.bz2": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy-base >=1.0.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "59de4cbf7af7f5b0862b7fa97d287cfe", + "name": "mkl_fft", + "sha256": "39ab71af022f9c15cd90028fa42f367df13b46fe561964ab99e99ea762f7b89f", + "size": 201375, + "subdir": "linux-64", + "timestamp": 1544718232355, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py37h423224d_0.tar.bz2": { + "build": "py37h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ea3adab421fdeeb7466feb6ff8849f99", + "name": "mkl_fft", + "sha256": "e383b53287fbfca9d476abe2e0f8cd1cd9d631028ee41ae022424df8ba524353", + "size": 202755, + "subdir": "linux-64", + "timestamp": 1580488314346, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py37h7dd41cf_0.tar.bz2": { + "build": "py37h7dd41cf_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e83da5cf39b2ea951af259db82943064", + "name": "mkl_fft", + "sha256": "1db968f9a425ff32f02e041e486a3689ca75936d98a4d8e21c705af46b81e7c3", + "size": 153383, + "subdir": "linux-64", + "timestamp": 1538068178568, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py37hd81dba3_0.tar.bz2": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy-base >=1.0.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9fa738d93bc6006c918d5ded57bcae9c", + "name": "mkl_fft", + "sha256": "456fa485f2bca513dc073db89a9efbbb3c392c9c0a74a5228da818814aea870c", + "size": 200969, + "subdir": "linux-64", + "timestamp": 1544718346302, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py38h423224d_0.tar.bz2": { + "build": "py38h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f82ad7d6460947941e60be225dc23942", + "name": "mkl_fft", + "sha256": "83c9bb9c721d25ff75d9ce983390a8b75c9ad2f4691ef67db6955692b770432a", + "size": 210047, + "subdir": "linux-64", + "timestamp": 1580495288476, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py39h63df603_0.tar.bz2": { + "build": "py39h63df603_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "298eb1630bb38608238f7f26a423e568", + "name": "mkl_fft", + "sha256": "999e0468931a093860084f71372a6246f30519101fe0e6f53d367c35230b775f", + "size": 193740, + "subdir": "linux-64", + "timestamp": 1607432338100, + "version": "1.0.6" + }, + "mkl_fft-1.1.0-py36h23d657b_0.tar.bz2": { + "build": "py36h23d657b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "438f06d8743cf8bffe8132bf0be03c52", + "name": "mkl_fft", + "sha256": "8c8073da782eba7179f8e02f00c99b17ba076745d51dce411f44c5225552ab6e", + "size": 162710, + "subdir": "linux-64", + "timestamp": 1592407000998, + "version": "1.1.0" + }, + "mkl_fft-1.1.0-py37h23d657b_0.tar.bz2": { + "build": "py37h23d657b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9713fc39a4a61dbe0d1acabceabc58e3", + "name": "mkl_fft", + "sha256": "84f88c828c817028082fdb59cdecc1390371e569bc80844376ac2f96490d5e9e", + "size": 162025, + "subdir": "linux-64", + "timestamp": 1592406998976, + "version": "1.1.0" + }, + "mkl_fft-1.1.0-py38h23d657b_0.tar.bz2": { + "build": "py38h23d657b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fb1a39a6d08b2b3956298e7c3f87c283", + "name": "mkl_fft", + "sha256": "12a63ea7e97d4b6fdbd58ac67693170c9a4bc55c1dc6b902560c597d01016438", + "size": 169796, + "subdir": "linux-64", + "timestamp": 1592406998848, + "version": "1.1.0" + }, + "mkl_fft-1.2.0-py36h23d657b_0.tar.bz2": { + "build": "py36h23d657b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5935da2284e815d99dbd7cb72707e9c1", + "name": "mkl_fft", + "sha256": "b9b50ada0ca0d1c57d7f2484b63414be97644402d131d53a0353872aeba0143d", + "size": 167623, + "subdir": "linux-64", + "timestamp": 1600444550541, + "version": "1.2.0" + }, + "mkl_fft-1.2.0-py37h23d657b_0.tar.bz2": { + "build": "py37h23d657b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "72276ea6f3ac82bea48f710754779d68", + "name": "mkl_fft", + "sha256": "ce0c4575831a9a0c81efb98f745d81581c08e73bf24a49d44e4b17e87b4c73ef", + "size": 167795, + "subdir": "linux-64", + "timestamp": 1600444522443, + "version": "1.2.0" + }, + "mkl_fft-1.2.0-py38h23d657b_0.tar.bz2": { + "build": "py38h23d657b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6312a76a181b2324cfe884334d94cb0b", + "name": "mkl_fft", + "sha256": "79d9ba628abf260db647f44b4b435ff223a06775c138878ca881e29f9d87ff3e", + "size": 176906, + "subdir": "linux-64", + "timestamp": 1600444504891, + "version": "1.2.0" + }, + "mkl_fft-1.2.1-py36h54f3939_0.tar.bz2": { + "build": "py36h54f3939_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "37721be946498eb5769d7e7cbba2596a", + "name": "mkl_fft", + "sha256": "a3555448a1a556ab81fc310cf9294afc22f82f7780bd021abc2a1278d2e189e1", + "size": 167655, + "subdir": "linux-64", + "timestamp": 1613676685307, + "version": "1.2.1" + }, + "mkl_fft-1.2.1-py37h54f3939_0.tar.bz2": { + "build": "py37h54f3939_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8007ef1026b897f77ca513a8edbf98e6", + "name": "mkl_fft", + "sha256": "27e402c3b304fddd3084db85ec98eadf74efad6c2e562565b096d471faf9b43d", + "size": 167801, + "subdir": "linux-64", + "timestamp": 1613676673024, + "version": "1.2.1" + }, + "mkl_fft-1.2.1-py37h807cd23_1.tar.bz2": { + "build": "py37h807cd23_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base >=1.2.1,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9f248de553d97fad72ec21bfa8c63f5d", + "name": "mkl_fft", + "sha256": "1124f83fbc33797c4a8b52701a05ceed4f4ae92e21472a43c5cdbbeffa506d30", + "size": 211889, + "subdir": "linux-64", + "timestamp": 1654863854655, + "version": "1.2.1" + }, + "mkl_fft-1.2.1-py38h54f3939_0.tar.bz2": { + "build": "py38h54f3939_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5cff6a8198009edde9e5b54e53682c06", + "name": "mkl_fft", + "sha256": "2770285f9c13c36453d4a0a53e09909ef9b3b742eab3a23e493fc7cca6c058de", + "size": 176939, + "subdir": "linux-64", + "timestamp": 1613676650333, + "version": "1.2.1" + }, + "mkl_fft-1.2.1-py38h807cd23_1.tar.bz2": { + "build": "py38h807cd23_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base >=1.2.1,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7cbbaf8e1cae72864ea7fa03ee8c6673", + "name": "mkl_fft", + "sha256": "78fc8041431aa8325c83881410ca5de37a3c7e4e712f765d774b40801ea40a88", + "size": 219270, + "subdir": "linux-64", + "timestamp": 1654864484155, + "version": "1.2.1" + }, + "mkl_fft-1.2.1-py39h54f3939_0.tar.bz2": { + "build": "py39h54f3939_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7ce42df2a52cc66020ea7119846f39e4", + "name": "mkl_fft", + "sha256": "1cb85327008cebbeff43500ea910436905b04ff7836660461666550feaeec4a2", + "size": 176559, + "subdir": "linux-64", + "timestamp": 1613676682979, + "version": "1.2.1" + }, + "mkl_fft-1.2.1-py39h807cd23_1.tar.bz2": { + "build": "py39h807cd23_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base >=1.2.1,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8ec312e389577be2160276b4322fcf63", + "name": "mkl_fft", + "sha256": "4c516d241de07f982243dca546890fdcb5bd9be0b01bb4876289c13a27325fc4", + "size": 216017, + "subdir": "linux-64", + "timestamp": 1654864168879, + "version": "1.2.1" + }, + "mkl_fft-1.3.0-py36h42c9631_2.tar.bz2": { + "build": "py36h42c9631_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2f15a934821617a646c22ff0c2f12d22", + "name": "mkl_fft", + "sha256": "fb6d7a24c38400be61ec614b8a7e6d93976c2627720500089c3a1b3225298cae", + "size": 192705, + "subdir": "linux-64", + "timestamp": 1618861123730, + "version": "1.3.0" + }, + "mkl_fft-1.3.0-py36h54f3939_0.tar.bz2": { + "build": "py36h54f3939_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "126d178b303ab5cf710a84d23b667bef", + "name": "mkl_fft", + "sha256": "155e8961ddd5456afcc0b4fc4e4577021e622a879aa18549039d940f999945e9", + "size": 189716, + "subdir": "linux-64", + "timestamp": 1614364012524, + "version": "1.3.0" + }, + "mkl_fft-1.3.0-py37h42c9631_2.tar.bz2": { + "build": "py37h42c9631_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "eefed303130a8e19d83675cefbdfcd4f", + "name": "mkl_fft", + "sha256": "a63e0b872504318d70b1a46300fdc9eaef052a6101282ec0fa070098c1c9b4f1", + "size": 192322, + "subdir": "linux-64", + "timestamp": 1618850762751, + "version": "1.3.0" + }, + "mkl_fft-1.3.0-py37h54f3939_0.tar.bz2": { + "build": "py37h54f3939_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "24239099b4c4b53ffb40cf502d34dbf3", + "name": "mkl_fft", + "sha256": "67b051a80ea0111689b2b243313e032e060700ef3104ec58caa8cf061311bd1e", + "size": 189407, + "subdir": "linux-64", + "timestamp": 1614362923631, + "version": "1.3.0" + }, + "mkl_fft-1.3.0-py38h42c9631_2.tar.bz2": { + "build": "py38h42c9631_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cf860b6bb565078b15d2b570782a714f", + "name": "mkl_fft", + "sha256": "331ff44c6ae3dc311a52d57e4d55875911e3a5bf9c7ca143cb4cedba99a8868d", + "size": 202273, + "subdir": "linux-64", + "timestamp": 1618854093151, + "version": "1.3.0" + }, + "mkl_fft-1.3.0-py38h54f3939_0.tar.bz2": { + "build": "py38h54f3939_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6c2b12cc08ecd1f1f78602ee1bb7e141", + "name": "mkl_fft", + "sha256": "a8c6542396f89fec74afde658c25bbde3dcd1f563e869c8c3dc796cfa2e0f44c", + "size": 199323, + "subdir": "linux-64", + "timestamp": 1614363679071, + "version": "1.3.0" + }, + "mkl_fft-1.3.0-py39h42c9631_2.tar.bz2": { + "build": "py39h42c9631_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e838413e680b553863ed85d8848324bc", + "name": "mkl_fft", + "sha256": "2bf9febbcc29d3da7d0beaf1373bb47b343b7a3a4fb707460a7619b2270fa9a0", + "size": 202309, + "subdir": "linux-64", + "timestamp": 1618854090397, + "version": "1.3.0" + }, + "mkl_fft-1.3.0-py39h54f3939_0.tar.bz2": { + "build": "py39h54f3939_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5ca88801b9293e1f18abfdfa0bec6a0e", + "name": "mkl_fft", + "sha256": "ffedf2e6fc4fd28c050d3082d7d6118471385ed23ac1c5414bd0a240bad52cc1", + "size": 199297, + "subdir": "linux-64", + "timestamp": 1614363991480, + "version": "1.3.0" + }, + "mkl_fft-1.3.1-py310h6feb928_0.tar.bz2": { + "build": "py310h6feb928_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "71e053055ecbce99fa9bb4619fa7165c", + "name": "mkl_fft", + "sha256": "013091bc2e0758257b67070aacb6225a1d5207989ead18d0d37c7bd027211159", + "size": 720701, + "subdir": "linux-64", + "timestamp": 1639978391944, + "version": "1.3.1" + }, + "mkl_fft-1.3.1-py310hd6ae3a3_0.tar.bz2": { + "build": "py310hd6ae3a3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "899b76e4629a62b66a7fee96ca02a487", + "name": "mkl_fft", + "sha256": "546faf25232afb3cf37280589e1f819a5aca6e1aeaed96d5eb9a3a1ddf369a45", + "size": 713451, + "subdir": "linux-64", + "timestamp": 1641843696839, + "version": "1.3.1" + }, + "mkl_fft-1.3.1-py311h30b3d60_0.tar.bz2": { + "build": "py311h30b3d60_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.22,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "md5": "24156958c095e98b4355c7bac0249e9e", + "name": "mkl_fft", + "sha256": "63df48dfdd73951b6491badf98ab7373f8e007a863d92ddf0d538c23502ce20b", + "size": 209748, + "subdir": "linux-64", + "timestamp": 1676828111586, + "version": "1.3.1" + }, + "mkl_fft-1.3.1-py37hd3c417c_0.tar.bz2": { + "build": "py37hd3c417c_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "caf2d9dbf818d1b459ccf45f2dfb100f", + "name": "mkl_fft", + "sha256": "45fc892613283a1f22a6eb2ba36fce9e026d664424ec8f4163d7ee11b9f20212", + "size": 194554, + "subdir": "linux-64", + "timestamp": 1634555144690, + "version": "1.3.1" + }, + "mkl_fft-1.3.1-py38hd3c417c_0.tar.bz2": { + "build": "py38hd3c417c_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "856d2f4ee31539c64641c15d4d887e48", + "name": "mkl_fft", + "sha256": "f60b8a001aa29e29c20f2a1e7328a1f0cb10564fa624f4519fdb9bfdd30f3698", + "size": 204397, + "subdir": "linux-64", + "timestamp": 1634566418352, + "version": "1.3.1" + }, + "mkl_fft-1.3.1-py39hd3c417c_0.tar.bz2": { + "build": "py39hd3c417c_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9b1f8ccc2488d0e04eb73211e2987483", + "name": "mkl_fft", + "sha256": "c244d23da2749857a993f84969fd35ffd183ab8f462986df6d33ae0f705fe034", + "size": 204136, + "subdir": "linux-64", + "timestamp": 1634566416657, + "version": "1.3.1" + }, + "mkl_random-1.0.1-py27h4414c95_1.tar.bz2": { + "build": "py27h4414c95_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0ee93fc7b1a4e52a41561cbff6d77ba7", + "name": "mkl_random", + "sha256": "9161a548e50ecdf489fe1f111c06b0ce44079a89f34c4fb09956a4cbc0ae8f9b", + "size": 369594, + "subdir": "linux-64", + "timestamp": 1530727514494, + "version": "1.0.1" + }, + "mkl_random-1.0.1-py27h629b387_0.tar.bz2": { + "build": "py27h629b387_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "a1e135726cb67f2a3aa8089fdce2f3a1", + "name": "mkl_random", + "sha256": "973e41866a306a41f06edff85736e747784f819ce3fa30d2b655dfa626cae236", + "size": 369766, + "subdir": "linux-64", + "timestamp": 1520264757385, + "version": "1.0.1" + }, + "mkl_random-1.0.1-py35h4414c95_1.tar.bz2": { + "build": "py35h4414c95_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "898323e85a0eb45d5913fa00de0feaeb", + "name": "mkl_random", + "sha256": "a5d6a733ba228c7493967675911a800e6de8f6c8d815cfedf379fa5cd923a0f1", + "size": 370273, + "subdir": "linux-64", + "timestamp": 1534347435802, + "version": "1.0.1" + }, + "mkl_random-1.0.1-py35h629b387_0.tar.bz2": { + "build": "py35h629b387_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "36da5ab454e9c377e98885a3d36f796c", + "name": "mkl_random", + "sha256": "8e616120f3b462614bf4f095b3b9aa14cf33c18bb4a4c83df02e4f90e83b53d4", + "size": 372374, + "subdir": "linux-64", + "timestamp": 1520264780816, + "version": "1.0.1" + }, + "mkl_random-1.0.1-py36h4414c95_1.tar.bz2": { + "build": "py36h4414c95_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c6bd720962dc495827f5489c22effc97", + "name": "mkl_random", + "sha256": "121b947fdf1459e7431bd485965ba2fbdc1439329aa636a2da74364b9bc82d0f", + "size": 381777, + "subdir": "linux-64", + "timestamp": 1530727618262, + "version": "1.0.1" + }, + "mkl_random-1.0.1-py36h629b387_0.tar.bz2": { + "build": "py36h629b387_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "c2f36f3731672df5443d3f2c69553997", + "name": "mkl_random", + "sha256": "44dce7a2e46954b0e50578a8b12cba0b9660f4665edb28b5777118dd30821390", + "size": 381658, + "subdir": "linux-64", + "timestamp": 1520264695959, + "version": "1.0.1" + }, + "mkl_random-1.0.1-py37h4414c95_1.tar.bz2": { + "build": "py37h4414c95_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "99be037abdd3dae38be71a54dbf83cca", + "name": "mkl_random", + "sha256": "278d6a6380b2f5432963e896693ee9f83ae35bfcac33bd346f2c3f9307690835", + "size": 381209, + "subdir": "linux-64", + "timestamp": 1530727564583, + "version": "1.0.1" + }, + "mkl_random-1.0.2-py27h423224d_0.tar.bz2": { + "build": "py27h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.2,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e77959aee0e9c2e2d7606a76132519ed", + "name": "mkl_random", + "sha256": "48d80dd6c6d8a1f0770d500f2a1560e02c9d502f2c2eeba87a22800a336260fc", + "size": 386759, + "subdir": "linux-64", + "timestamp": 1580501604876, + "version": "1.0.2" + }, + "mkl_random-1.0.2-py27hd81dba3_0.tar.bz2": { + "build": "py27hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy-base >=1.0.2,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "137f1b69a541e52ee78aff6d10d4bb8d", + "name": "mkl_random", + "sha256": "36127b43d4aab641170b51edd3d21de9bc9db2cbfb64ff5ed7ee121b809e9bac", + "size": 392295, + "subdir": "linux-64", + "timestamp": 1544718209705, + "version": "1.0.2" + }, + "mkl_random-1.0.2-py36h423224d_0.tar.bz2": { + "build": "py36h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.2,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "eb53479c2762eb16c13044b409e06524", + "name": "mkl_random", + "sha256": "842de2c6a98b5c83ce33822a0669a54e0211f5d6bd4daa26eec6e0b5550a1357", + "size": 431237, + "subdir": "linux-64", + "timestamp": 1580488456855, + "version": "1.0.2" + }, + "mkl_random-1.0.2-py36hd81dba3_0.tar.bz2": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy-base >=1.0.2,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fd88ca8a0039a7bcf797f06cb3004e9d", + "name": "mkl_random", + "sha256": "7c50a22cf6d8dcefa5497035970e67fc7795d001c4917099954e53fa26e40386", + "size": 416333, + "subdir": "linux-64", + "timestamp": 1544718286750, + "version": "1.0.2" + }, + "mkl_random-1.0.2-py37h423224d_0.tar.bz2": { + "build": "py37h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.2,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "676563a244aca53e3975f1808cc51f83", + "name": "mkl_random", + "sha256": "c123f20b9b355d229e4bd8d427e23618df18d4810b5de3687a46e42370c1c3a1", + "size": 415239, + "subdir": "linux-64", + "timestamp": 1580488368347, + "version": "1.0.2" + }, + "mkl_random-1.0.2-py37hd81dba3_0.tar.bz2": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy-base >=1.0.2,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3d244a05a79082ca61347a9d1ab759b2", + "name": "mkl_random", + "sha256": "5580966474e3f2ef8b98b2a104ef439f17becf0f4474d429ad3b3681b0061198", + "size": 415149, + "subdir": "linux-64", + "timestamp": 1544718432566, + "version": "1.0.2" + }, + "mkl_random-1.0.2-py38h423224d_0.tar.bz2": { + "build": "py38h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e4257f519884a39c0f61fcf8d1780631", + "name": "mkl_random", + "sha256": "ef74c5b89e0deb3514afbbc7c7f7ba17c7ca86a88ec6bb219e09fa8d086c5c2a", + "size": 439036, + "subdir": "linux-64", + "timestamp": 1580495323926, + "version": "1.0.2" + }, + "mkl_random-1.0.2-py39h63df603_0.tar.bz2": { + "build": "py39h63df603_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9a52756a1f22318f034c2f1ab1e966a5", + "name": "mkl_random", + "sha256": "cba46e9c374cae08596a1edbd275e5c27fd29366cf9f19814a99393b3375b9a9", + "size": 388252, + "subdir": "linux-64", + "timestamp": 1607432375281, + "version": "1.0.2" + }, + "mkl_random-1.1.0-py27hd6b4f25_0.tar.bz2": { + "build": "py27hd6b4f25_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "d818148f14983ccc100931230bb3f9ae", + "name": "mkl_random", + "sha256": "66050b134439ab9b49b1292539b9718e3cea27ddd4e184facea2720dcb57fc84", + "size": 340355, + "subdir": "linux-64", + "timestamp": 1569349545429, + "version": "1.1.0" + }, + "mkl_random-1.1.0-py36hd6b4f25_0.tar.bz2": { + "build": "py36hd6b4f25_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "b7f3ec7431e2edb9c679bdf8e327df26", + "name": "mkl_random", + "sha256": "9708eba075b7e6f7fbca3fdf0da48aa1cf54940c88675b57046263d520b3b070", + "size": 377971, + "subdir": "linux-64", + "timestamp": 1569349555267, + "version": "1.1.0" + }, + "mkl_random-1.1.0-py37hd6b4f25_0.tar.bz2": { + "build": "py37hd6b4f25_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "4dc4655aa58b9e5719a86c193def3b63", + "name": "mkl_random", + "sha256": "5a905a03e0e1941c7f3693f0bf6e2ae3eba727d29914809c7b4529439730e8f1", + "size": 384878, + "subdir": "linux-64", + "timestamp": 1569349561861, + "version": "1.1.0" + }, + "mkl_random-1.1.0-py38h962f231_0.tar.bz2": { + "build": "py38h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "a2b7ee6c354c6292d38e27f4506423a6", + "name": "mkl_random", + "sha256": "1e8c787e024794de66f4dc272867a01f0afd34387f6c1e7f0572d3368fb962e5", + "size": 407793, + "subdir": "linux-64", + "timestamp": 1573738291813, + "version": "1.1.0" + }, + "mkl_random-1.1.1-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2020.1,<2021.0a0", + "numpy >=1.14,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "61e2cd06540b38bebcea422c1f7a9514", + "name": "mkl_random", + "sha256": "361f0875fba46ff8c47bf3a5b577af57f6d824573a51af442f16415c8a7586a3", + "size": 391483, + "subdir": "linux-64", + "timestamp": 1590531511580, + "version": "1.1.1" + }, + "mkl_random-1.1.1-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2020.1,<2021.0a0", + "numpy >=1.14,<2.0a0", + "python >=3.7,<3.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "4998eb9421ce079ab4fb0618196f6524", + "name": "mkl_random", + "sha256": "1f908370cea95f8d6b54cd76623aac970b6919c99d5311f8ba7a142e0f12ca66", + "size": 384410, + "subdir": "linux-64", + "timestamp": 1590531500653, + "version": "1.1.1" + }, + "mkl_random-1.1.1-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2020.1,<2021.0a0", + "numpy >=1.14,<2.0a0", + "python >=3.8,<3.9.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "39441b592ae28b602dcdba1e236f9326", + "name": "mkl_random", + "sha256": "b949323969ac27374f1f324ef55e0a06e07ebf35463cf40d950f6fa82df2a96e", + "size": 403204, + "subdir": "linux-64", + "timestamp": 1590531546391, + "version": "1.1.1" + }, + "mkl_random-1.2.1-py36ha9443f7_2.tar.bz2": { + "build": "py36ha9443f7_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "a093de4d7a62aeadf636af57bbcdf86f", + "name": "mkl_random", + "sha256": "5ded1fd9a42775fc94b405497f3a9417233afa13e0337ecf8b99143eff7f4c86", + "size": 340625, + "subdir": "linux-64", + "timestamp": 1618861141231, + "version": "1.2.1" + }, + "mkl_random-1.2.1-py37h807cd23_1.tar.bz2": { + "build": "py37h807cd23_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base >=1.2.1,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5479559d2d00e62bcba79ac5ebf61ddd", + "name": "mkl_random", + "sha256": "614f2dfc5c6bb2de1eeb9d22bc0478268ffda878264b512aa812f832a1d237cb", + "size": 386907, + "subdir": "linux-64", + "timestamp": 1654863888954, + "version": "1.2.1" + }, + "mkl_random-1.2.1-py37ha9443f7_2.tar.bz2": { + "build": "py37ha9443f7_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.7,<3.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "c9be9fd6945684ae697770e6df2ad994", + "name": "mkl_random", + "sha256": "4554caded9ed236718634216737ebd7b701ba5683b35101be95fd7f94192e749", + "size": 329346, + "subdir": "linux-64", + "timestamp": 1618854106634, + "version": "1.2.1" + }, + "mkl_random-1.2.1-py38h807cd23_1.tar.bz2": { + "build": "py38h807cd23_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base >=1.2.1,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "33d7958dbfc9901033ddbfbe078ea6b4", + "name": "mkl_random", + "sha256": "c65627502b832d77be144fdedf8c0878a5b9b90c223e7de97324f45d7d77daa6", + "size": 385218, + "subdir": "linux-64", + "timestamp": 1654864516409, + "version": "1.2.1" + }, + "mkl_random-1.2.1-py38ha9443f7_2.tar.bz2": { + "build": "py38ha9443f7_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.8,<3.9.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "69ba4a2e4da280437f775f8d6c0599b9", + "name": "mkl_random", + "sha256": "582834c6c4b316014129c1b18213a3e9c3361484949d5b80547a448fe2dcd8ee", + "size": 362613, + "subdir": "linux-64", + "timestamp": 1618853977229, + "version": "1.2.1" + }, + "mkl_random-1.2.1-py39h807cd23_1.tar.bz2": { + "build": "py39h807cd23_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base >=1.2.1,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b45e0466ae157637eabf8e45cf6028e1", + "name": "mkl_random", + "sha256": "e8bcf71821c9c38724037ce4a0dbf8e2e432e35999985fff8b91e4e309772838", + "size": 369172, + "subdir": "linux-64", + "timestamp": 1654864199152, + "version": "1.2.1" + }, + "mkl_random-1.2.1-py39ha9443f7_2.tar.bz2": { + "build": "py39ha9443f7_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.9,<3.10.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "8b299e419ebd7ea21ac8eecbe7de14a1", + "name": "mkl_random", + "sha256": "dd9a5a5ab99730ab3f08ffc14295ef76a96c8dc506bcd32877f9838d1aa8a386", + "size": 356381, + "subdir": "linux-64", + "timestamp": 1618854115010, + "version": "1.2.1" + }, + "mkl_random-1.2.2-py310h00e6091_0.tar.bz2": { + "build": "py310h00e6091_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<2.0a0", + "python >=3.10,<3.11.0a0", + "blas * mkl" + ], + "license": "BSD-3-Clause", + "md5": "4d23da9a63b3973bff5e8e9b9651c70d", + "name": "mkl_random", + "sha256": "8a0e862e81fd6dd43d5c4f683f50ba06d2a8a58686640b914104fe68dd84fc6b", + "size": 1269509, + "subdir": "linux-64", + "timestamp": 1641843589171, + "version": "1.2.2" + }, + "mkl_random-1.2.2-py310h83d4ef7_0.tar.bz2": { + "build": "py310h83d4ef7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<2.0a0", + "python >=3.10,<3.11.0a0", + "blas * mkl" + ], + "license": "BSD-3-Clause", + "md5": "b21dfe9e98d0c605521847e3fbe4e959", + "name": "mkl_random", + "sha256": "a62067be303f5dc3112a5cc269f1bf4eda8c52f2513062cad6364606ce7fde92", + "size": 1267145, + "subdir": "linux-64", + "timestamp": 1639980120043, + "version": "1.2.2" + }, + "mkl_random-1.2.2-py311hba01205_0.tar.bz2": { + "build": "py311hba01205_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.22,<2.0a0", + "python >=3.11,<3.12.0a0", + "blas * mkl" + ], + "license": "BSD-3-Clause", + "md5": "6c9b75af787a746515d1213119715b45", + "name": "mkl_random", + "sha256": "cb66c20b6f5b686b6ce0aa6875f53cbf92490ec8f3e931bef5115aba4fcdcfdc", + "size": 344380, + "subdir": "linux-64", + "timestamp": 1676828066969, + "version": "1.2.2" + }, + "mkl_random-1.2.2-py36h51133e4_0.tar.bz2": { + "build": "py36h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD-3-Clause", + "md5": "d2e566807467cdca7f6ed7fc0e7718da", + "name": "mkl_random", + "sha256": "decfb3bdcdf53d2ae0529a5da1020bc2c8857dbe15e8919d9a94032ff7aff10c", + "size": 335794, + "subdir": "linux-64", + "timestamp": 1626186170019, + "version": "1.2.2" + }, + "mkl_random-1.2.2-py37h51133e4_0.tar.bz2": { + "build": "py37h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.7,<3.8.0a0", + "blas * mkl" + ], + "license": "BSD-3-Clause", + "md5": "f7751660d66875b1c8aceebbc6ebc25f", + "name": "mkl_random", + "sha256": "70858320e6837b039544f06d746c9c4ed6e796447a595e4735ef96abe8f42853", + "size": 340373, + "subdir": "linux-64", + "timestamp": 1626179132188, + "version": "1.2.2" + }, + "mkl_random-1.2.2-py38h51133e4_0.tar.bz2": { + "build": "py38h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.8,<3.9.0a0", + "blas * mkl" + ], + "license": "BSD-3-Clause", + "md5": "aef6e4c094fb094576b1c74919284787", + "name": "mkl_random", + "sha256": "ea1b274cbae030a69bfac2b9668d3273377ffe5490463955d12034db11a5e95f", + "size": 349357, + "subdir": "linux-64", + "timestamp": 1626186149062, + "version": "1.2.2" + }, + "mkl_random-1.2.2-py39h51133e4_0.tar.bz2": { + "build": "py39h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.9,<3.10.0a0", + "blas * mkl" + ], + "license": "BSD-3-Clause", + "md5": "77aa1d7f958d36bf227e6ff4a34d2e3d", + "name": "mkl_random", + "sha256": "f81f426f8ef306d636664bc49e7cdd70e2b4306d7c6bcb9c75fe35a45ab2087a", + "size": 365386, + "subdir": "linux-64", + "timestamp": 1626186165897, + "version": "1.2.2" + }, + "mkl_umath-0.1.1-py37hb1251f7_0.tar.bz2": { + "build": "py37hb1251f7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "intel-cmplr-lib-rt >=2021.3.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f7d2e8cc278c7b0fba39b63701d91830", + "name": "mkl_umath", + "sha256": "0083a15cfefbe54656d78cacd2f43f6937d739d96a7def22de3ab7714d05b3d6", + "size": 137948, + "subdir": "linux-64", + "timestamp": 1646750489540, + "version": "0.1.1" + }, + "mkl_umath-0.1.1-py38hb1251f7_0.tar.bz2": { + "build": "py38hb1251f7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "intel-cmplr-lib-rt >=2021.3.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2aa416443f95159602cc5a82c77dbb71", + "name": "mkl_umath", + "sha256": "12879ea6cc3f203d65febd4f9ff7ead0df6246cb3c194ca7bf565091313344de", + "size": 139308, + "subdir": "linux-64", + "timestamp": 1646767933918, + "version": "0.1.1" + }, + "mkl_umath-0.1.1-py39hb1251f7_0.tar.bz2": { + "build": "py39hb1251f7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "intel-cmplr-lib-rt >=2021.3.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a5b96f351d12447cab52319b15f81a0", + "name": "mkl_umath", + "sha256": "0153586d4946ebae0880cbe41fc602f52bb9e8bd1f15c3956b16e7387a0ed0e4", + "size": 140477, + "subdir": "linux-64", + "timestamp": 1646767931223, + "version": "0.1.1" + }, + "mklml-2018.0.3-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "libmklml 2018.0.3.*", + "mkl-include 2018.0.3.*" + ], + "md5": "c9c8546a819e4cccf5719947d51b93cc", + "name": "mklml", + "sha256": "99ddfca17e7b20929e81debfd441cc132b78c4c860d2fac8ff3d5f4cd9c453b0", + "size": 4733, + "subdir": "linux-64", + "timestamp": 1530345172210, + "version": "2018.0.3" + }, + "mklml-2019.0.3-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "libmklml 2019.0.3.*", + "mkl-include 2019.*" + ], + "md5": "33fe27147bc3bb295cbe352fdac92344", + "name": "mklml", + "sha256": "f19e637258727d522338e4465328f23fb36a043189ed7d8de45403d4693556aa", + "size": 138789, + "subdir": "linux-64", + "timestamp": 1551761856979, + "version": "2019.0.3" + }, + "mklml-2019.0.5-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "libmklml 2019.0.5.*", + "mkl-include 2019.*" + ], + "md5": "0e4e260c2406f8452d8a67cf02926bc5", + "name": "mklml", + "sha256": "f7d31481dc4628523fdb17ebc77b16454e57f9c482f0fa06b7aef5188d6fd066", + "size": 147144, + "subdir": "linux-64", + "timestamp": 1564678059223, + "version": "2019.0.5" + }, + "mklml-2019.0.5-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libmklml 2019.0.5.*", + "mkl-include 2019.*" + ], + "md5": "f2b623e0b16f0156b37c42928e8c48cf", + "name": "mklml", + "sha256": "b516664c4aeec7fd32a27d6e849f1918db6e2bb97f7b56b40bb704e049713d30", + "size": 5853, + "subdir": "linux-64", + "timestamp": 1641844513766, + "version": "2019.0.5" + }, + "mlir-14.0.6-h9e868ea_0.tar.bz2": { + "build": "h9e868ea_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libmlir 14.0.6 h9e868ea_0", + "libstdcxx-ng >=11.2.0", + "llvmdev 14.0.6.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "7e82c1cd16d41278092d14a3e6798a32", + "name": "mlir", + "sha256": "aa914f57eab7f44f710ed7ff0af2b9968a78bf6969342e42a3a2017c7719d7ce", + "size": 30984511, + "subdir": "linux-64", + "timestamp": 1662555412954, + "version": "14.0.6" + }, + "mmh3-3.0.0-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "19940cf251a7dcddb65a1eb335876ef7", + "name": "mmh3", + "sha256": "3df28b3c4fa036b28bfc9ed304ad6f28942a2640273ba8428dd235a0d42de9d5", + "size": 46754, + "subdir": "linux-64", + "timestamp": 1650548010226, + "version": "3.0.0" + }, + "mmh3-3.0.0-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "7cd09fda947d661f1e3fad5f89ca0064", + "name": "mmh3", + "sha256": "9fd56d90f41faa65f7d8428e88efb7ce158ab8dce58c43957282f180abf54d78", + "size": 18746, + "subdir": "linux-64", + "timestamp": 1676858657774, + "version": "3.0.0" + }, + "mmh3-3.0.0-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "519e8dfc95c5c516a46c407acef38846", + "name": "mmh3", + "sha256": "d5dce0da2a917c1957ef839bc827074967badf89b2b54ce5725df22692d8bd97", + "size": 18487, + "subdir": "linux-64", + "timestamp": 1650548037179, + "version": "3.0.0" + }, + "mmh3-3.0.0-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "50cf3976d596ba2a83b6394545ad374a", + "name": "mmh3", + "sha256": "dce4ded9ac3134633294e5a1fc34003b9fddad82796b3bccc9845a191aa5b09e", + "size": 18501, + "subdir": "linux-64", + "timestamp": 1650547943782, + "version": "3.0.0" + }, + "mmh3-3.0.0-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "d2dba84a63a601873c2611c15a109561", + "name": "mmh3", + "sha256": "7898abf7790a0217bb77e31f20421c87688f96dda4d1123b37ff9eb9ad78acbe", + "size": 18530, + "subdir": "linux-64", + "timestamp": 1650547971837, + "version": "3.0.0" + }, + "mock-2.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "funcsigs", + "pbr", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 2-Clause", + "md5": "b63d4d60d56838376aba5fbe6fdc2a1f", + "name": "mock", + "sha256": "dc535edf6e780341ada2961a9fc2dd43a1d5b5b8bcbfe6b2e08831765c8f070c", + "size": 102756, + "subdir": "linux-64", + "timestamp": 1530728013735, + "version": "2.0.0" + }, + "mock-2.0.0-py27h0c0c831_0.tar.bz2": { + "build": "py27h0c0c831_0", + "build_number": 0, + "depends": [ + "funcsigs", + "pbr", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 2-Clause", + "md5": "35997655e908bead97dd6605c89f9d81", + "name": "mock", + "sha256": "2f58951d34d104cf9dffa55bb991aafdbb0bc465773416ee5871e9cc0562e71c", + "size": 102693, + "subdir": "linux-64", + "timestamp": 1507935253282, + "version": "2.0.0" + }, + "mock-2.0.0-py35h70ca42c_0.tar.bz2": { + "build": "py35h70ca42c_0", + "build_number": 0, + "depends": [ + "pbr", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 2-Clause", + "md5": "91f24511cc29ce0aa7a6f0c027043a42", + "name": "mock", + "sha256": "a17c18370d3d1d195d33d7ab4d93d4ff03714fb1497a844bd12ed3a62ca02214", + "size": 107398, + "subdir": "linux-64", + "timestamp": 1507935269131, + "version": "2.0.0" + }, + "mock-2.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pbr", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 2-Clause", + "md5": "753747b5663004ba41fffb3a33caf0f2", + "name": "mock", + "sha256": "9fe7a05b0b795d75da45117b35ffe89a5a42d47095ff6fdabec424d3f9e7f0ba", + "size": 106734, + "subdir": "linux-64", + "timestamp": 1530728059385, + "version": "2.0.0" + }, + "mock-2.0.0-py36h3c5bf6c_0.tar.bz2": { + "build": "py36h3c5bf6c_0", + "build_number": 0, + "depends": [ + "pbr", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 2-Clause", + "md5": "c4fc01de8873b3a965a55472ffd72c58", + "name": "mock", + "sha256": "b9ed0ae1aa682f07c11d1b2239dfcf280840972050b9ef0c766e9365bd29c82b", + "size": 106487, + "subdir": "linux-64", + "timestamp": 1507935278912, + "version": "2.0.0" + }, + "mock-2.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pbr", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 2-Clause", + "md5": "07bbcbf3391536968eefd03f499ebda2", + "name": "mock", + "sha256": "c83a54e793dcad9fe5e0d133654bd7a381e95285a16c67ba03897b4db5183fd4", + "size": 106943, + "subdir": "linux-64", + "timestamp": 1530728036053, + "version": "2.0.0" + }, + "mock-3.0.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "funcsigs", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD-2-Clause", + "md5": "f5ce14b0ea292f32fb6a169ef57c1dbb", + "name": "mock", + "sha256": "ec227d849692be79d853c1fb70e95061458fdaae7c354990ad057fcb28779478", + "size": 47529, + "subdir": "linux-64", + "timestamp": 1559063941031, + "version": "3.0.5" + }, + "mock-3.0.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-2-Clause", + "md5": "f0fc0dd831375c81d8bd26bc3d6695b0", + "name": "mock", + "sha256": "64ec6a7272f0ed0b8ad03517cb856b3d7cc5c28420b9e170e750a087a945c082", + "size": 48329, + "subdir": "linux-64", + "timestamp": 1559063989188, + "version": "3.0.5" + }, + "mock-3.0.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-2-Clause", + "md5": "2319d456b6eccacc25126682ad071929", + "name": "mock", + "sha256": "13d954b2750b89f37edb926427b4c2d9ba2795614e3c82a686d8f7e60954accf", + "size": 48349, + "subdir": "linux-64", + "timestamp": 1559063904620, + "version": "3.0.5" + }, + "mock-3.0.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-2-Clause", + "md5": "beff1af02c3a4b5429c98fcb1703255a", + "name": "mock", + "sha256": "dc96c7e27009be582dc90236b7817c490d2403bce25e6ba59d7ae83eee235a54", + "size": 48679, + "subdir": "linux-64", + "timestamp": 1573750934389, + "version": "3.0.5" + }, + "modin-0.10.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.12", + "distributed >=2.12", + "pandas 1.2.4", + "python >=3.7,<3.8.0a0", + "ray-core >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0da4820d379a19fbb0dda8b05ded45c6", + "name": "modin", + "sha256": "8b97f3d6e9c9dbce6c5a9438681985b4cda00b7f2900766c30399bab4a153866", + "size": 874094, + "subdir": "linux-64", + "timestamp": 1626550774766, + "version": "0.10.0" + }, + "modin-0.10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.12", + "distributed >=2.12", + "pandas 1.2.4", + "python >=3.8,<3.9.0a0", + "ray-core >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "39d28a104d2f6f25b66559658c9850a9", + "name": "modin", + "sha256": "6e15359ec0791f91a4cb281f49e35568f6f927e7d7fef853501273b0bf234d6e", + "size": 881811, + "subdir": "linux-64", + "timestamp": 1626550771024, + "version": "0.10.0" + }, + "modin-0.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.12", + "distributed >=2.12", + "pandas 1.2.4", + "python >=3.9,<3.10.0a0", + "ray-core >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "991453307cba5505103c83543f716321", + "name": "modin", + "sha256": "2958c6c3c172a68da2e11d190c8c335d5866355f4e6a58ff4c173ed25896f833", + "size": 878156, + "subdir": "linux-64", + "timestamp": 1626550365896, + "version": "0.10.0" + }, + "modin-0.10.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22", + "distributed >=2.22", + "pandas 1.3.2", + "python >=3.7,<3.8.0a0", + "ray-core >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "15bb5d0436c8960168cd0a79822e7e46", + "name": "modin", + "sha256": "622c0fc652c9103234c98b92cc1be53c834d160fa4a0469a721ae381e2137337", + "size": 952171, + "subdir": "linux-64", + "timestamp": 1632133579772, + "version": "0.10.2" + }, + "modin-0.10.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22", + "distributed >=2.22", + "pandas 1.3.2", + "python >=3.8,<3.9.0a0", + "ray-core >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2a1781be012bf622acaf3a32e4f6fc91", + "name": "modin", + "sha256": "d41bf3cf401ca63c1384138c87740cc832bae09837967e421b24fe8d077e6e23", + "size": 955008, + "subdir": "linux-64", + "timestamp": 1632133807092, + "version": "0.10.2" + }, + "modin-0.10.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22", + "distributed >=2.22", + "pandas 1.3.2", + "python >=3.9,<3.10.0a0", + "ray-core >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1d1296f784ead1ee2c51d4765d76cfea", + "name": "modin", + "sha256": "5db7bf7b5c70fd32f749dbacc64ac3b6f03a176a70b64744c1fd2f72e3de83fe", + "size": 958200, + "subdir": "linux-64", + "timestamp": 1632133805209, + "version": "0.10.2" + }, + "modin-0.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.11.0 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "15d1b55d81cb578fec69f1de48fab2cb", + "name": "modin", + "sha256": "7c8e41ae59ff3ffc7c09b2fa40db8d7cf96d7f7d22a2944bde3a821461d243f0", + "size": 10194, + "subdir": "linux-64", + "timestamp": 1640815321468, + "version": "0.11.0" + }, + "modin-0.11.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.11.0 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0abc56ffc36060f78f0a64a37af98134", + "name": "modin", + "sha256": "18a7ecf9fa013415b51228bea942cef39e312cf285ac21fab512b92710a82546", + "size": 16807, + "subdir": "linux-64", + "timestamp": 1633013254457, + "version": "0.11.0" + }, + "modin-0.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.11.0 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4da097db1bfa059228368d9193ecc9c3", + "name": "modin", + "sha256": "9bd2d5cd790158abfe529d54a1ef98666ba4dced3ab95cb015369e6f9e6d45e2", + "size": 16804, + "subdir": "linux-64", + "timestamp": 1633013265133, + "version": "0.11.0" + }, + "modin-0.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.11.0 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2387574e14b1422f6fc1439dc6f45469", + "name": "modin", + "sha256": "60c6b9d6b2548b64d60c21006340475e3c880c7fecce15fc0f0bc8fc241eb933", + "size": 16816, + "subdir": "linux-64", + "timestamp": 1633013260010, + "version": "0.11.0" + }, + "modin-0.11.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.11.3 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2c4091c56fd409106f444f352e5a0c14", + "name": "modin", + "sha256": "c52cceb20065aa1766b8d6d0768c43e4fcbc436e2af031416fed05f148d5649b", + "size": 17881, + "subdir": "linux-64", + "timestamp": 1640803825778, + "version": "0.11.3" + }, + "modin-0.11.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.11.3 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "24183be982cd30aca742ddfca398f766", + "name": "modin", + "sha256": "5d0752c673c005f0083e22ca835ffba9444356cab66d62906abc4935bada2923", + "size": 17874, + "subdir": "linux-64", + "timestamp": 1640803831655, + "version": "0.11.3" + }, + "modin-0.11.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.11.3 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f48b44e945e6442ea8af0e380a7ce355", + "name": "modin", + "sha256": "d7f4f76d0a2441c81a4aa823fcb8810a58d1ed202f9a4d824ae51523ad4a26ba", + "size": 17880, + "subdir": "linux-64", + "timestamp": 1640803837790, + "version": "0.11.3" + }, + "modin-0.15.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.15.2 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a8578ae9d793bc91e7d3c21485f2798a", + "name": "modin", + "sha256": "53797e52a85e987e2d0323b625d28c54193b1d3ee1e79d2bc5593dbac819ebb4", + "size": 11774, + "subdir": "linux-64", + "timestamp": 1659123869316, + "version": "0.15.2" + }, + "modin-0.15.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.15.2 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2d1109ff0a9f579a50cccd335f149bf8", + "name": "modin", + "sha256": "0023840ce628b3590b25825abf8d0c3712e1a9be9dd241d35b292a3cfef89ebc", + "size": 11752, + "subdir": "linux-64", + "timestamp": 1659123885894, + "version": "0.15.2" + }, + "modin-0.15.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.15.2 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1c236561cb120464e851bbfd42ed078f", + "name": "modin", + "sha256": "a03297335bd16a19d8d876676fa91c5d81f29d422f2311b419167154c07e6387", + "size": 11753, + "subdir": "linux-64", + "timestamp": 1659123878148, + "version": "0.15.2" + }, + "modin-0.18.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.18.0 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2755ecc3aa6666286ecb33cd78ef17ec", + "name": "modin", + "sha256": "448be00498449da96235498209094f0c8f251e2208e8dd095f22fb7aee63d81d", + "size": 9267, + "subdir": "linux-64", + "timestamp": 1675936350157, + "version": "0.18.0" + }, + "modin-0.18.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.18.0 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e7e0bf4e4e0659a8c953d48bd35f6969", + "name": "modin", + "sha256": "686f7a9f8227054257bf9ba7dd416287542bca9ca57f5d598259ffa150800327", + "size": 9280, + "subdir": "linux-64", + "timestamp": 1675935992331, + "version": "0.18.0" + }, + "modin-0.18.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.18.0 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e207b0bcd12c13b8a47e1c8a7c9e3e6c", + "name": "modin", + "sha256": "c126d0153828ace647088133beb5cc2139274f620f55d06fb817ccde2bb0af71", + "size": 9261, + "subdir": "linux-64", + "timestamp": 1675936175401, + "version": "0.18.0" + }, + "modin-all-0.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.0 py310h06a4308_0", + "modin-dask 0.11.0 py310h06a4308_0", + "modin-omnisci 0.11.0 py310h06a4308_0", + "modin-ray 0.11.0 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "498b555c92d4d7bea18bedc3e017c08d", + "name": "modin-all", + "sha256": "22a4e6db388ec9605d1da840dfa2caa10b0145662a2a2ac041e5a1a13f9aa4b1", + "size": 10192, + "subdir": "linux-64", + "timestamp": 1640815328105, + "version": "0.11.0" + }, + "modin-all-0.11.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.0 py37h06a4308_0", + "modin-dask 0.11.0 py37h06a4308_0", + "modin-omnisci 0.11.0 py37h06a4308_0", + "modin-ray 0.11.0 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "03c0cee7f117de0a4a23a1b9ce35b142", + "name": "modin-all", + "sha256": "8c5a073f6a9cba4d940813c5c641d293746baaa50d96d6bffdc6d55efd92c836", + "size": 16816, + "subdir": "linux-64", + "timestamp": 1633013270367, + "version": "0.11.0" + }, + "modin-all-0.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.0 py38h06a4308_0", + "modin-dask 0.11.0 py38h06a4308_0", + "modin-omnisci 0.11.0 py38h06a4308_0", + "modin-ray 0.11.0 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "df50ae8bff817a26b8169b9922c2bf02", + "name": "modin-all", + "sha256": "339736009d6dedfe3fca1e6405600fe0374d5e0703923b51948df1cc00d1200a", + "size": 16785, + "subdir": "linux-64", + "timestamp": 1633013281029, + "version": "0.11.0" + }, + "modin-all-0.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.0 py39h06a4308_0", + "modin-dask 0.11.0 py39h06a4308_0", + "modin-omnisci 0.11.0 py39h06a4308_0", + "modin-ray 0.11.0 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d737e2fc9143d504d4d5dacb460a4e12", + "name": "modin-all", + "sha256": "bc6eb60d1f698b1c0e9daef39369110b20fa90c6a3a58c7c3196fefdfef2cb4a", + "size": 16835, + "subdir": "linux-64", + "timestamp": 1633013275729, + "version": "0.11.0" + }, + "modin-all-0.11.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.3 py37h06a4308_0", + "modin-dask 0.11.3 py37h06a4308_0", + "modin-omnisci 0.11.3 py37h06a4308_0", + "modin-ray 0.11.3 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f25cbbefae2eb85485f9860f6574cb46", + "name": "modin-all", + "sha256": "0879583f57a19f83fa67e47c0151509fcee639b31feeb7bf21c51f537ef12e40", + "size": 17890, + "subdir": "linux-64", + "timestamp": 1640803843398, + "version": "0.11.3" + }, + "modin-all-0.11.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.3 py38h06a4308_0", + "modin-dask 0.11.3 py38h06a4308_0", + "modin-omnisci 0.11.3 py38h06a4308_0", + "modin-ray 0.11.3 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fc19c40def2d28b393bcda84d81c7175", + "name": "modin-all", + "sha256": "c1a95ce7c2ac5cdc479492c9f214e01f1352a8b773dd33540e4039a7fd3ae20d", + "size": 17902, + "subdir": "linux-64", + "timestamp": 1640803849306, + "version": "0.11.3" + }, + "modin-all-0.11.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.3 py39h06a4308_0", + "modin-dask 0.11.3 py39h06a4308_0", + "modin-omnisci 0.11.3 py39h06a4308_0", + "modin-ray 0.11.3 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "43e7e517b883b26bf3a8a2b208985a6e", + "name": "modin-all", + "sha256": "2764ed8cf528fed66b7bb8499538566537062af1bdb71ac88cbc3c780f039f38", + "size": 17893, + "subdir": "linux-64", + "timestamp": 1640803855529, + "version": "0.11.3" + }, + "modin-all-0.15.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.15.2 py310h06a4308_0", + "modin-dask 0.15.2 py310h06a4308_0", + "modin-omnisci 0.15.2 py310h2f386ee_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "52e0c3d2b85129237486d1bd63657eac", + "name": "modin-all", + "sha256": "d578a800298ea25a23fbee47dde7317e9a1d17ab60ec6d5224985ff958d49859", + "size": 11805, + "subdir": "linux-64", + "timestamp": 1659123894320, + "version": "0.15.2" + }, + "modin-all-0.15.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.15.2 py38h06a4308_0", + "modin-dask 0.15.2 py38h06a4308_0", + "modin-omnisci 0.15.2 py38hb070fc8_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "397f98bf5c26639413987cea3516af75", + "name": "modin-all", + "sha256": "9a91e843255ca6037107942a988f3261025a28c6b57ba2a3799cd1a2ffdcab98", + "size": 11753, + "subdir": "linux-64", + "timestamp": 1659123911436, + "version": "0.15.2" + }, + "modin-all-0.15.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.15.2 py39h06a4308_0", + "modin-dask 0.15.2 py39h06a4308_0", + "modin-omnisci 0.15.2 py39hb070fc8_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9e8fe2dba1de284c13e95e57ea0c2a23", + "name": "modin-all", + "sha256": "e32217a84d2f713bc0082af2e95f7d72b40e3785047f866d00b355da31cad5c4", + "size": 11782, + "subdir": "linux-64", + "timestamp": 1659123903290, + "version": "0.15.2" + }, + "modin-all-0.18.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.18.0 py310h06a4308_0", + "modin-dask 0.18.0 py310h06a4308_0", + "modin-ray 0.18.0 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1ace7838620ca3a970d2530bb6f272b3", + "name": "modin-all", + "sha256": "3e534b5848a8a605bbca738f34d150019cd5b66752f827d9a4d7c30f7dee94fa", + "size": 9303, + "subdir": "linux-64", + "timestamp": 1675936355983, + "version": "0.18.0" + }, + "modin-all-0.18.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.18.0 py38h06a4308_0", + "modin-dask 0.18.0 py38h06a4308_0", + "modin-ray 0.18.0 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c18a4405e1da6c28c20f0c8a4a9fadae", + "name": "modin-all", + "sha256": "ef2e59f76aa5126eca0666ede71a6cf8ae86f37f7b7a9be8e18eeb277e932875", + "size": 9279, + "subdir": "linux-64", + "timestamp": 1675935997841, + "version": "0.18.0" + }, + "modin-all-0.18.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.18.0 py39h06a4308_0", + "modin-dask 0.18.0 py39h06a4308_0", + "modin-ray 0.18.0 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "11b7171827209eda99ba7509abf831e0", + "name": "modin-all", + "sha256": "c623e20f9c2f9abb9a8529502f54237ec3c9d93efed3d99103d71aeaf6e99783", + "size": 9274, + "subdir": "linux-64", + "timestamp": 1675936181189, + "version": "0.18.0" + }, + "modin-core-0.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.5", + "packaging", + "pandas 1.3.3", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "51761f8c6e591d09e658684e503cfab2", + "name": "modin-core", + "sha256": "efed0d821335d03397b9a96dc36ed6bde727655eb0d18515450f5e95199ab8bc", + "size": 980221, + "subdir": "linux-64", + "timestamp": 1640815293673, + "version": "0.11.0" + }, + "modin-core-0.11.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.5", + "packaging", + "pandas 1.3.3", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f1c123dac4836e9e81ba03081ea08e0f", + "name": "modin-core", + "sha256": "a2c1dac63d5c728f4b5cb9e3be9985c7652d1f35bb66328cb25a8d5ab154d6aa", + "size": 974148, + "subdir": "linux-64", + "timestamp": 1633013174680, + "version": "0.11.0" + }, + "modin-core-0.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.5", + "packaging", + "pandas 1.3.3", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "affb3b0d31d249aef2057c272ab5b1b2", + "name": "modin-core", + "sha256": "07ebaf24b40c75a2c3e7e444a0b04c1c5faebeae0b607b81862b9bf560c71c35", + "size": 983331, + "subdir": "linux-64", + "timestamp": 1633013200073, + "version": "0.11.0" + }, + "modin-core-0.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.5", + "packaging", + "pandas 1.3.3", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "975d2a5acbdd14e105d7103db9162eec", + "name": "modin-core", + "sha256": "3d89a7e9472045026963d4b1d9f3a008f1c59361d7e84740a8319ada9d48ef85", + "size": 981550, + "subdir": "linux-64", + "timestamp": 1633013187846, + "version": "0.11.0" + }, + "modin-core-0.11.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.5", + "packaging", + "pandas 1.3.4", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7ebd57831cd9433facefc82040f5a13e", + "name": "modin-core", + "sha256": "2f088890c1607a5d514d4b2c8f3933855006490957eee58b46e80d7c83fa41e2", + "size": 988032, + "subdir": "linux-64", + "timestamp": 1640803736551, + "version": "0.11.3" + }, + "modin-core-0.11.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.5", + "packaging", + "pandas 1.3.4", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "20bfe2ad4fe8dba45e637b144f10a73f", + "name": "modin-core", + "sha256": "4bf7a1b5dd606daad6e55fbcc0b924edac1ef5586281b36d82d63c8d916208bb", + "size": 995993, + "subdir": "linux-64", + "timestamp": 1640803750311, + "version": "0.11.3" + }, + "modin-core-0.11.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.5", + "packaging", + "pandas 1.3.4", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d5e445995267e0ded0dc13bf8697e0e2", + "name": "modin-core", + "sha256": "222da41693e9fbad76a8ab195bd88c8212b3f47cd9bc479a184ebef0972c766b", + "size": 995388, + "subdir": "linux-64", + "timestamp": 1640803764206, + "version": "0.11.3" + }, + "modin-core-0.15.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec", + "numpy >=1.18.5", + "packaging", + "pandas 1.4.3", + "psutil", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "612be8da980d7a9c282d729e1033d694", + "name": "modin-core", + "sha256": "e76add61069255ee85be73eda215be1196828769c8b09157db7cdbdfd118ebd4", + "size": 1173463, + "subdir": "linux-64", + "timestamp": 1659123751835, + "version": "0.15.2" + }, + "modin-core-0.15.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec", + "numpy >=1.18.5", + "packaging", + "pandas 1.4.3", + "psutil", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2fbe9483d91693d7bbde4c0e1d9debfe", + "name": "modin-core", + "sha256": "b30e1a8d1a6437be1462a19fb39c5ac1d2d044a26504d3c5d787c7c400c4743d", + "size": 1157924, + "subdir": "linux-64", + "timestamp": 1659123788886, + "version": "0.15.2" + }, + "modin-core-0.15.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec", + "numpy >=1.18.5", + "packaging", + "pandas 1.4.3", + "psutil", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0f744e46744039d6b83b22f119eea459", + "name": "modin-core", + "sha256": "ff2c2b6e88b7ad6df0f7600673571f26a760305f40404282f8ad6ee0d2a41b19", + "size": 1158224, + "subdir": "linux-64", + "timestamp": 1659123769632, + "version": "0.15.2" + }, + "modin-core-0.18.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec", + "numpy >=1.18.5", + "packaging", + "pandas 1.5.2", + "psutil", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "608aa7636a0ccc9686d11d906773c54d", + "name": "modin-core", + "sha256": "bd9744c36f7720a0d483e723e8ffc0589dc61946b57c7fc7d56549cf0052ebff", + "size": 1261386, + "subdir": "linux-64", + "timestamp": 1675936330259, + "version": "0.18.0" + }, + "modin-core-0.18.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec", + "numpy >=1.18.5", + "packaging", + "pandas 1.5.2", + "psutil", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "886369ead148d95a4ea4e3c04983a8d8", + "name": "modin-core", + "sha256": "7c00202779623c484e5f3888b37c5626b50b251322a5ef27dff051bd0f96e03c", + "size": 1251972, + "subdir": "linux-64", + "timestamp": 1675935973794, + "version": "0.18.0" + }, + "modin-core-0.18.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec", + "numpy >=1.18.5", + "packaging", + "pandas 1.5.2", + "psutil", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0f7a308c9eaf8f115ef9ebb67f7ceb62", + "name": "modin-core", + "sha256": "0df24e2066353cd8f2cb89805cdf729c00ae9dfd7b50e338289862e5accbffa9", + "size": 1252573, + "subdir": "linux-64", + "timestamp": 1675936156077, + "version": "0.18.0" + }, + "modin-dask-0.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.11.0 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7ce822da5301fa62ebdf4ae5c89cba2e", + "name": "modin-dask", + "sha256": "dbc1c44a78eaf339aa5db6652a67ba8674d0c0debd56a8faa55dfc389249aeef", + "size": 10249, + "subdir": "linux-64", + "timestamp": 1640815301481, + "version": "0.11.0" + }, + "modin-dask-0.11.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.11.0 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8442e5e98c980d5133d9d2da23b6fe8c", + "name": "modin-dask", + "sha256": "4fb26fb67230f1d397f03d1aa2ec9ae627d44b6099a8dae3d05960785132cc3a", + "size": 16889, + "subdir": "linux-64", + "timestamp": 1633013206621, + "version": "0.11.0" + }, + "modin-dask-0.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.11.0 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e6f16b10fbb325b1978a5d3064f46617", + "name": "modin-dask", + "sha256": "3ff23904cbd35bd901d70c1ceb0758b52219b76db1613faab8985f08a1aa58eb", + "size": 16893, + "subdir": "linux-64", + "timestamp": 1633013217279, + "version": "0.11.0" + }, + "modin-dask-0.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.11.0 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f2471171057446ab6654e68b1ddc25f7", + "name": "modin-dask", + "sha256": "5e014a933f22414eeb07a51d707061b34266d6458d030b0c1d1cb1d4aa523300", + "size": 16897, + "subdir": "linux-64", + "timestamp": 1633013212030, + "version": "0.11.0" + }, + "modin-dask-0.11.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.11.3 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7062456eb9da640c9ab69fc47193b01d", + "name": "modin-dask", + "sha256": "6ab84d1a8e12f1e23bc8580e0b196896db3f1b353d364f6d3385425e9eea8d46", + "size": 17976, + "subdir": "linux-64", + "timestamp": 1640803771594, + "version": "0.11.3" + }, + "modin-dask-0.11.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.11.3 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c1ded50476ee8c6b29ccbc7187247db5", + "name": "modin-dask", + "sha256": "eaa04a427992152381fcdd14047b6f06c898ed1ecfd8ea5b539c2a87346723fc", + "size": 17958, + "subdir": "linux-64", + "timestamp": 1640803777459, + "version": "0.11.3" + }, + "modin-dask-0.11.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.11.3 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1b5cbfef315c94fe8df02c2aa7684759", + "name": "modin-dask", + "sha256": "e2be91a0978f470189eadfe5205c53db361d8dd55a824fd427abc1093d8427ed", + "size": 17963, + "subdir": "linux-64", + "timestamp": 1640803783610, + "version": "0.11.3" + }, + "modin-dask-0.15.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0,<2022.2.0", + "distributed >=2.22.0,<2022.2.0", + "modin-core 0.15.2 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "75e6c7c1eb24bf9d6c854c250df11ddc", + "name": "modin-dask", + "sha256": "e5f8715f67537f22dcc936e62089e5ea9ecfcad847d419c63cb5b01f7a9e4086", + "size": 11862, + "subdir": "linux-64", + "timestamp": 1659123800019, + "version": "0.15.2" + }, + "modin-dask-0.15.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0,<2022.2.0", + "distributed >=2.22.0,<2022.2.0", + "modin-core 0.15.2 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0e7e8741bbb49e3466b75cbd22e4eb05", + "name": "modin-dask", + "sha256": "6f833196a825acffef2901b40e6b7c47d6aa960b3be6bc9e5fa5e1aa6d689085", + "size": 11820, + "subdir": "linux-64", + "timestamp": 1659123816477, + "version": "0.15.2" + }, + "modin-dask-0.15.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0,<2022.2.0", + "distributed >=2.22.0,<2022.2.0", + "modin-core 0.15.2 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5b9f986a80767bbea2212fc44930f6e9", + "name": "modin-dask", + "sha256": "23736f99d5f3910540e6eff1e05f8e559fc0ba9409a95322e5730c75b9addb9b", + "size": 11824, + "subdir": "linux-64", + "timestamp": 1659123808446, + "version": "0.15.2" + }, + "modin-dask-0.18.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.18.0 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c65ee0cb6e8c4e8facb4f89661772bf0", + "name": "modin-dask", + "sha256": "1eab9f54d4e32442f6bc7a29789b3353f436b30def54b49baf05e5aa58064eaf", + "size": 9356, + "subdir": "linux-64", + "timestamp": 1675936338194, + "version": "0.18.0" + }, + "modin-dask-0.18.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.18.0 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f75e389b7a669188cc6d12e97056ec0d", + "name": "modin-dask", + "sha256": "26c1d6904bcb4536f9f38d200d57a3a2e44dca2dda6b731589abd937c5343826", + "size": 9357, + "subdir": "linux-64", + "timestamp": 1675935981347, + "version": "0.18.0" + }, + "modin-dask-0.18.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.18.0 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a35263bfeb0a8ce1f4469b51f73149fc", + "name": "modin-dask", + "sha256": "9b87e5faf1d8176f6464384d6e2fa2bf60ea6ec1423d70af0da0305e68974179", + "size": 9304, + "subdir": "linux-64", + "timestamp": 1675936163850, + "version": "0.18.0" + }, + "modin-omnisci-0.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.0 py310h06a4308_0", + "pyarrow >=3.0", + "pyomniscidbe", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "65b5b0d5b9b6cd5d8e7eafd65ec19299", + "name": "modin-omnisci", + "sha256": "760f7d439b64f91fdacd7af527a0121ec8fd14c9c8433c6fc119ba6c28b76685", + "size": 10235, + "subdir": "linux-64", + "timestamp": 1640815308318, + "version": "0.11.0" + }, + "modin-omnisci-0.11.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.0 py37h06a4308_0", + "pyarrow >=3.0", + "pyomniscidbe", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "19bfe6d60eca4243593c0ba3b80006b7", + "name": "modin-omnisci", + "sha256": "455705e0d05de1697a59636e44128c0b16580559546847331920e78eb870883f", + "size": 16893, + "subdir": "linux-64", + "timestamp": 1633013222521, + "version": "0.11.0" + }, + "modin-omnisci-0.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.0 py38h06a4308_0", + "pyarrow >=3.0", + "pyomniscidbe", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2f45c3666eae9de857d95346bc422d41", + "name": "modin-omnisci", + "sha256": "ffc52207cbeab382eccc32fb7330ad730d617c0e09c792d604473684e7982260", + "size": 16901, + "subdir": "linux-64", + "timestamp": 1633013233083, + "version": "0.11.0" + }, + "modin-omnisci-0.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.0 py39h06a4308_0", + "pyarrow >=3.0", + "pyomniscidbe", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4e58d211a6efad5af28396d159a78fc5", + "name": "modin-omnisci", + "sha256": "4d3d268cafe9f242c59dd8b6ddf5a1cc4371e5a8d4714d97d3491797dd5ee20c", + "size": 16930, + "subdir": "linux-64", + "timestamp": 1633013227968, + "version": "0.11.0" + }, + "modin-omnisci-0.11.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.3 py37h06a4308_0", + "pyarrow >=3.0", + "pyomniscidbe 5.7.1.*", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "468319f00b9df881d389369ddd60286f", + "name": "modin-omnisci", + "sha256": "0a7c3cb5cfc8989865f6fe4c9520e37b0db09297b998c2e71c037539a6afda3e", + "size": 17982, + "subdir": "linux-64", + "timestamp": 1640803789443, + "version": "0.11.3" + }, + "modin-omnisci-0.11.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.3 py38h06a4308_0", + "pyarrow >=3.0", + "pyomniscidbe 5.7.1.*", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b8b09a5f8af89e436f36c306f12afeba", + "name": "modin-omnisci", + "sha256": "804c55f4cadd437393112aee65a07b0523325e247b3c6806821aad507a103a19", + "size": 17972, + "subdir": "linux-64", + "timestamp": 1640803795295, + "version": "0.11.3" + }, + "modin-omnisci-0.11.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.3 py39h06a4308_0", + "pyarrow >=3.0", + "pyomniscidbe 5.7.1.*", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "04c81943a998c796c2de9cb20706ced1", + "name": "modin-omnisci", + "sha256": "21fa0b8964d03df5956dc8a32ffb7f10c2f62151b81a97d5d488145ebd4887ae", + "size": 17970, + "subdir": "linux-64", + "timestamp": 1640803801589, + "version": "0.11.3" + }, + "modin-omnisci-0.15.2-py310h2f386ee_0.tar.bz2": { + "build": "py310h2f386ee_0", + "build_number": 0, + "constrains": [ + "pyarrow ==6.0.1" + ], + "depends": [ + "modin-core 0.15.2 py310h06a4308_0", + "pyomniscidbe 5.10.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "947589dea8afbd6298a533b927de2eeb", + "name": "modin-omnisci", + "sha256": "2d48f4fb2485c86b29b91c0dde3eb92002a3de9f8a4c3b077bb02b2fd0caaa92", + "size": 549117, + "subdir": "linux-64", + "timestamp": 1659123825182, + "version": "0.15.2" + }, + "modin-omnisci-0.15.2-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "constrains": [ + "pyarrow ==6.0.1" + ], + "depends": [ + "modin-core 0.15.2 py38h06a4308_0", + "pyomniscidbe 5.10.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c10c7df9a20f7aecc1d939d93cca2142", + "name": "modin-omnisci", + "sha256": "7e5a74c13765b7d725e3eb33ef1a99a283bb36f3d59c7b841a5f10f4e18641da", + "size": 548332, + "subdir": "linux-64", + "timestamp": 1659123844135, + "version": "0.15.2" + }, + "modin-omnisci-0.15.2-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "constrains": [ + "pyarrow ==6.0.1" + ], + "depends": [ + "modin-core 0.15.2 py39h06a4308_0", + "pyomniscidbe 5.10.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2a1f2f86dafb71cb47922a430d1e37e4", + "name": "modin-omnisci", + "sha256": "8e188a9f1b325807dc01f56de7656991e8526b2038b64ef90d13673ac14741bd", + "size": 549051, + "subdir": "linux-64", + "timestamp": 1659123835008, + "version": "0.15.2" + }, + "modin-ray-0.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aioredis <2", + "modin-core 0.11.0 py310h06a4308_0", + "pyarrow >=1.0", + "python >=3.10,<3.11.0a0", + "ray-core >=1.4.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e4bbf3350d32a47e3879a888c6f2a392", + "name": "modin-ray", + "sha256": "e903a07c327a42e04fcf51eb93704ee207c7d73b03de17e3dee70536b0b4c1ae", + "size": 10273, + "subdir": "linux-64", + "timestamp": 1640815315001, + "version": "0.11.0" + }, + "modin-ray-0.11.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aioredis <2", + "modin-core 0.11.0 py37h06a4308_0", + "pyarrow >=1.0", + "python >=3.7,<3.8.0a0", + "ray-core >=1.4.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "843d2e07d70d08062f395881ff28e686", + "name": "modin-ray", + "sha256": "fc03881bfc90551bcb3e739a34ee64f111b73a0b00a3444848a5fdbb56600255", + "size": 16886, + "subdir": "linux-64", + "timestamp": 1633013238354, + "version": "0.11.0" + }, + "modin-ray-0.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aioredis <2", + "modin-core 0.11.0 py38h06a4308_0", + "pyarrow >=1.0", + "python >=3.8,<3.9.0a0", + "ray-core >=1.4.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "af3c85b909a53ce179657b2ab1feb6da", + "name": "modin-ray", + "sha256": "634e5ad998c2988f8d9ac3d122f08fc3f8ec2b326ab956c4f177b845ae6a59ce", + "size": 16898, + "subdir": "linux-64", + "timestamp": 1633013249232, + "version": "0.11.0" + }, + "modin-ray-0.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aioredis <2", + "modin-core 0.11.0 py39h06a4308_0", + "pyarrow >=1.0", + "python >=3.9,<3.10.0a0", + "ray-core >=1.4.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4ca014ff89e7b03768ab40994aa2aa10", + "name": "modin-ray", + "sha256": "8564688279a5229e633eadebb18ae00a981e1debafed6882a208fade939123e3", + "size": 16931, + "subdir": "linux-64", + "timestamp": 1633013243932, + "version": "0.11.0" + }, + "modin-ray-0.11.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aioredis <2", + "modin-core 0.11.3 py37h06a4308_0", + "pyarrow >=1.0", + "python >=3.7,<3.8.0a0", + "ray-core >=1.4.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6429becab96edd9eef006ee84008a8ea", + "name": "modin-ray", + "sha256": "debd5def7cf243393e581a6d491476fba565021e9283b2f421e039aefef8af74", + "size": 17971, + "subdir": "linux-64", + "timestamp": 1640803807478, + "version": "0.11.3" + }, + "modin-ray-0.11.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aioredis <2", + "modin-core 0.11.3 py38h06a4308_0", + "pyarrow >=1.0", + "python >=3.8,<3.9.0a0", + "ray-core >=1.4.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0c2ccfac485e3bbf0498a94d88333233", + "name": "modin-ray", + "sha256": "9b369d16c482993db2513c24118bc9825de52c335826bbb9c002c7f55e05adf9", + "size": 17970, + "subdir": "linux-64", + "timestamp": 1640803813602, + "version": "0.11.3" + }, + "modin-ray-0.11.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aioredis <2", + "modin-core 0.11.3 py39h06a4308_0", + "pyarrow >=1.0", + "python >=3.9,<3.10.0a0", + "ray-core >=1.4.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3bad36b5c905d5e8c4cdda5ba076054f", + "name": "modin-ray", + "sha256": "244e97b95133732e069bcb9372ea05fd48abbd3afc4de00288586b8daeb91c74", + "size": 17962, + "subdir": "linux-64", + "timestamp": 1640803819607, + "version": "0.11.3" + }, + "modin-ray-0.15.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aioredis <2", + "modin-core 0.15.2 py38h06a4308_0", + "protobuf <4", + "pyarrow >=4.0.1", + "python >=3.8,<3.9.0a0", + "ray-default >=1.4.0,<1.13", + "redis-py >=3.5.0,<4.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a22dc73b0196812d4bfd157a05b985be", + "name": "modin-ray", + "sha256": "dfa0f2f3a7e82b3c4b1bff7b41d27d9312e2b7de3c5dc07cf7f5e03e55c3e8d0", + "size": 11842, + "subdir": "linux-64", + "timestamp": 1659123861189, + "version": "0.15.2" + }, + "modin-ray-0.15.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aioredis <2", + "modin-core 0.15.2 py39h06a4308_0", + "protobuf <4", + "pyarrow >=4.0.1", + "python >=3.9,<3.10.0a0", + "ray-default >=1.4.0,<1.13", + "redis-py >=3.5.0,<4.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3a0a090b7eaf07dc6aab03a835b61eab", + "name": "modin-ray", + "sha256": "be6ac119179044b3ef9c9cdcd9bf3ea47fcaac1150675bc3afd8e5cdfb408665", + "size": 11850, + "subdir": "linux-64", + "timestamp": 1659123853429, + "version": "0.15.2" + }, + "modin-ray-0.18.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "grpcio !=1.45.*,!=1.46.*", + "modin-core 0.18.0 py310h06a4308_0", + "pyarrow", + "python >=3.10,<3.11.0a0", + "ray-default >=1.13.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dbcecde2da27f2f795fb3431a0e20072", + "name": "modin-ray", + "sha256": "e960e65365f49ddf29c5c279f9603290abc1c09c8163493ff9f1f8662a4c55f6", + "size": 9347, + "subdir": "linux-64", + "timestamp": 1675936344185, + "version": "0.18.0" + }, + "modin-ray-0.18.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "grpcio !=1.45.*,!=1.46.*", + "modin-core 0.18.0 py38h06a4308_0", + "pyarrow", + "python >=3.8,<3.9.0a0", + "ray-default >=1.13.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0ee971954571443e3ebc79f080e020a8", + "name": "modin-ray", + "sha256": "b3c6ec9afbe6ca65cd60173644a1123a57b01cd8ff9f4465c24789e413f76f0f", + "size": 9360, + "subdir": "linux-64", + "timestamp": 1675935986796, + "version": "0.18.0" + }, + "modin-ray-0.18.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "grpcio !=1.45.*,!=1.46.*", + "modin-core 0.18.0 py39h06a4308_0", + "pyarrow", + "python >=3.9,<3.10.0a0", + "ray-default >=1.13.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a8c8335f9479e2ff279d76cdde047cba", + "name": "modin-ray", + "sha256": "a2653f4b0d6d75c8f682ad2d6109cd5593b730d2738e0c29b1ee635a0a5f9883", + "size": 9325, + "subdir": "linux-64", + "timestamp": 1675936169605, + "version": "0.18.0" + }, + "mongo-tools-3.6.9-h449a5d8_0.tar.bz2": { + "build": "h449a5d8_0", + "build_number": 0, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libpcap >=1.9.0,<1.10.0a0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "Apache 2.0", + "md5": "86825dc9c00324f54ec3fcf2f8b3909a", + "name": "mongo-tools", + "sha256": "aa9d31871fc48505f1543bd0ad55608385c95dfd3291cf4e2da487a43498face", + "size": 45784406, + "subdir": "linux-64", + "timestamp": 1544967667339, + "version": "3.6.9" + }, + "mongo-tools-4.0.4-h689ee8a_1.tar.bz2": { + "build": "h689ee8a_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.27,<3.0a0", + "libgcc-ng >=11.2.0", + "libpcap >=1.9.1,<1.10.0a0", + "openssl >=1.1.1o,<1.1.2a" + ], + "license": "Apache 2.0", + "md5": "3dfa8b4806754fed35f6660b17528250", + "name": "mongo-tools", + "sha256": "5e7ee845e5a030aea099039d39cb4ba6674d6261ef46d615eb3bf2f96a9cd7fc", + "size": 48272865, + "subdir": "linux-64", + "timestamp": 1656407072930, + "version": "4.0.4" + }, + "mongo-tools-4.0.4-h723b31f_0.tar.bz2": { + "build": "h723b31f_0", + "build_number": 0, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libpcap >=1.9.0,<1.10.0a0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "Apache 2.0", + "md5": "6957e7efe05a8a58a6190031898bc247", + "name": "mongo-tools", + "sha256": "012016955b210550c82cadcad00b3d1173b77f76522b6466f471c312707a84ec", + "size": 48292156, + "subdir": "linux-64", + "timestamp": 1547743841506, + "version": "4.0.4" + }, + "mongodb-3.4.10-heb2b672_0.tar.bz2": { + "build": "heb2b672_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2l,<1.0.3a" + ], + "license": "AGPLv3", + "license_family": "AGPL", + "md5": "0cc5c4cbfc74b97394f8757f28a2a4e8", + "name": "mongodb", + "sha256": "bb4a420343c504d98e65ba1bd34c6b10aaea4ce6282a617f0727ac01effa34b1", + "size": 53305248, + "subdir": "linux-64", + "timestamp": 1509408183668, + "version": "3.4.10" + }, + "mongodb-3.6.5-hab6429c_0.tar.bz2": { + "build": "hab6429c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a" + ], + "license": "AGPLv3", + "license_family": "AGPL", + "md5": "5f2cfded38e45d7c2bc670cbe38b3e61", + "name": "mongodb", + "sha256": "5e5d5dc15d3d51e15ff0e2b0c0cbcea1292ab9b39d78cb137625c20d6716f566", + "size": 55192221, + "subdir": "linux-64", + "timestamp": 1529763163898, + "version": "3.6.5" + }, + "mongodb-4.0.2-h3a61b39_0.tar.bz2": { + "build": "h3a61b39_0", + "build_number": 0, + "depends": [ + "libcurl >=7.61.0,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a" + ], + "license": "AGPLv3", + "license_family": "AGPL", + "md5": "bfbef52587a3f71388b87be3685b2fda", + "name": "mongodb", + "sha256": "70f9253da1f56fc86fc2d922f320325c6852e45f84592798f1bea01b250db8bc", + "size": 40279879, + "subdir": "linux-64", + "timestamp": 1535820521500, + "version": "4.0.2" + }, + "mongodb-4.0.3-h597af5e_0.tar.bz2": { + "build": "h597af5e_0", + "build_number": 0, + "depends": [ + "libcurl >=7.61.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "AGPLv3", + "license_family": "AGPL", + "md5": "521b5930bc2c27409dad4d9a2abaa1e3", + "name": "mongodb", + "sha256": "67cd1d77b2b72bca64f4178de91b347fba682c60a45d96023d4f2968d826bb1f", + "size": 40616223, + "subdir": "linux-64", + "timestamp": 1541024139648, + "version": "4.0.3" + }, + "more-itertools-4.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e0db373c305e1c3fdff04b4d92e5aee", + "name": "more-itertools", + "sha256": "a78bee9b26fe432fa4d7d83632e8b46a7e5dd06c3d931e3da75aa8eeef6dcef4", + "size": 74450, + "subdir": "linux-64", + "timestamp": 1519236870023, + "version": "4.1.0" + }, + "more-itertools-4.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ae629c18b9b8a11c767db0986958087", + "name": "more-itertools", + "sha256": "923f77951d975a5a7fc46f81e6af000b70ba1a3acbe1f38be6f7358a22ec91df", + "size": 77827, + "subdir": "linux-64", + "timestamp": 1519236922150, + "version": "4.1.0" + }, + "more-itertools-4.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "81ff36648bb38ac51b7f1bf6a5c18520", + "name": "more-itertools", + "sha256": "0538d8397c95fa16a2ce1df31174cd03d2bd20992622be26379b49c0217307ec", + "size": 77467, + "subdir": "linux-64", + "timestamp": 1519236808731, + "version": "4.1.0" + }, + "more-itertools-4.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9944242f582a04b562c99996c54be1b5", + "name": "more-itertools", + "sha256": "2a5ca51bd4639e461ec35a2b6ba184cec15fec9fc8ba1e7ce7bea7c26d056bdc", + "size": 76614, + "subdir": "linux-64", + "timestamp": 1527787356661, + "version": "4.2.0" + }, + "more-itertools-4.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d24a3c74a989e0c885fc7624e997654", + "name": "more-itertools", + "sha256": "8820966fb6e8f4ce334dcdc481409e8068d433e3db26fd78c00cfd7ebd7f0964", + "size": 79933, + "subdir": "linux-64", + "timestamp": 1527787381730, + "version": "4.2.0" + }, + "more-itertools-4.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2fefd0a76dbca6031b67fe4a831d25de", + "name": "more-itertools", + "sha256": "ded35ed8b8b9e83c477d9d60ca705ef91f525502fcdd96e8831b01377780bfa8", + "size": 79432, + "subdir": "linux-64", + "timestamp": 1527787302933, + "version": "4.2.0" + }, + "more-itertools-4.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "00ce0e3d64a7ba5a9e679eb751615255", + "name": "more-itertools", + "sha256": "f800c883e8562816c7bc1403e4f0a2dab67d60fb88846736449e992332e2bfaf", + "size": 79177, + "subdir": "linux-64", + "timestamp": 1530693776170, + "version": "4.2.0" + }, + "more-itertools-4.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6ca76c891dd4309c347f1d98df76086", + "name": "more-itertools", + "sha256": "c713fd34ff35d8ca43e90e9c801ddd65c84a233a19d56910c45b1b4f2c39669f", + "size": 81635, + "subdir": "linux-64", + "timestamp": 1533709186208, + "version": "4.3.0" + }, + "more-itertools-4.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4b517e24fe498e4fa3e306e4ec7d6193", + "name": "more-itertools", + "sha256": "47318916968658fe6dde910a8bbf1c222ecb746752c0084cd2235d8f09fe0ddc", + "size": 85253, + "subdir": "linux-64", + "timestamp": 1533709260446, + "version": "4.3.0" + }, + "more-itertools-4.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77736d3e76f062cc6e2bd711db6fe5ed", + "name": "more-itertools", + "sha256": "cc99e9508e41a196685279947de9bb7e7ea5cf52836d7d69b82244a94d9d61ec", + "size": 84957, + "subdir": "linux-64", + "timestamp": 1533709162620, + "version": "4.3.0" + }, + "more-itertools-4.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8ad303a73f8ea61df1604ffa35660b6", + "name": "more-itertools", + "sha256": "fc3d3d96a17442b4dc8d3632effe2a79fb4101de6ebc2963e91140b3d17dc134", + "size": 84818, + "subdir": "linux-64", + "timestamp": 1533709451738, + "version": "4.3.0" + }, + "more-itertools-5.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0268371551498811aeb8c39054475ff", + "name": "more-itertools", + "sha256": "0e9b6e8b8e898ce60f37eca08f3386ee70e077a3d46e9c71adbd78101a4b118a", + "size": 88343, + "subdir": "linux-64", + "timestamp": 1547239079749, + "version": "5.0.0" + }, + "more-itertools-5.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3974d163b5a8f9cf0d5430cdad83415", + "name": "more-itertools", + "sha256": "e3e9df7ffdb1c8bd836033c7aa107d767ea35c7094dc404d1689e863f2b97637", + "size": 91946, + "subdir": "linux-64", + "timestamp": 1547239124918, + "version": "5.0.0" + }, + "more-itertools-5.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5476bf24a9a3b7f61ab3ce1031cb331", + "name": "more-itertools", + "sha256": "0e49526fb2471376671500968ad50c8b3df8d24b734fbeaaeb9f1f13e3a12091", + "size": 91655, + "subdir": "linux-64", + "timestamp": 1547239091064, + "version": "5.0.0" + }, + "more-itertools-6.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f21deb8b753097e86705740260dc8486", + "name": "more-itertools", + "sha256": "2130b70a3fe40ccfc838be2abb7abfcb13251eb42d63764479d724bb4dbc5601", + "size": 91556, + "subdir": "linux-64", + "timestamp": 1552446164377, + "version": "6.0.0" + }, + "more-itertools-6.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0a773755cd2fd6999ac8290bc028b63", + "name": "more-itertools", + "sha256": "90a4f2ebf1c7da41b96c5b19fbf006f9c13f13225bcb3ce3ef33e89d670e6ad8", + "size": 91305, + "subdir": "linux-64", + "timestamp": 1552446316901, + "version": "6.0.0" + }, + "more-itertools-7.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4e250fa9fba61ca48868dcfc6ea079b", + "name": "more-itertools", + "sha256": "ee6c5f6b90271ab36a86c78e98ad28a6756bf8905c35a9a5ffdd66bec2d60f23", + "size": 95359, + "subdir": "linux-64", + "timestamp": 1556083013106, + "version": "7.0.0" + }, + "more-itertools-7.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3f370a1087fa8a9245206e2d6eb0002", + "name": "more-itertools", + "sha256": "f8cff347900698442969bfc754ab396e856761d6af978e60ae83c9b07e443090", + "size": 95106, + "subdir": "linux-64", + "timestamp": 1556116252824, + "version": "7.0.0" + }, + "more-itertools-7.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "06babe4caf2abdf1c565fca16a8d3189", + "name": "more-itertools", + "sha256": "185de253fbd11e533fa601f614c42fd32da14d9c3f0a7c422ea9ad7e3b7946f4", + "size": 101861, + "subdir": "linux-64", + "timestamp": 1564701128262, + "version": "7.2.0" + }, + "more-itertools-7.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b76fba748bb0ddaa8b19684cccf908bf", + "name": "more-itertools", + "sha256": "0d5b6d983d39299dff5d23c63a1a9b93aecfd614762d276a2aa79e0c66f66118", + "size": 101418, + "subdir": "linux-64", + "timestamp": 1564701101721, + "version": "7.2.0" + }, + "more-itertools-7.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d94baf4af9a30df3c9b5921551f3cab", + "name": "more-itertools", + "sha256": "ef5ff9557ec3356bfe04adc101abdd756cd96d68c723d3e5ad26cc4aacb4dd5c", + "size": 99775, + "subdir": "linux-64", + "timestamp": 1572609171161, + "version": "7.2.0" + }, + "morfessor-2.0.3-py27h349872b_0.tar.bz2": { + "build": "py27h349872b_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "9b6be88fffb196a0d0222630a3d96943", + "name": "morfessor", + "sha256": "72a547325440057a34c351328a835c87767cad06673d1ab13458a01035f51a49", + "size": 58976, + "subdir": "linux-64", + "timestamp": 1508795515589, + "version": "2.0.3" + }, + "morfessor-2.0.3-py35h28ae230_0.tar.bz2": { + "build": "py35h28ae230_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "3254b4039478e06dcb2724dcb2161254", + "name": "morfessor", + "sha256": "e44427ec8e04233af966df84d87eb89aa0e37878951403ab4ec8c4a1f8eea1e9", + "size": 60448, + "subdir": "linux-64", + "timestamp": 1508795517053, + "version": "2.0.3" + }, + "morfessor-2.0.3-py36h8a99c1e_0.tar.bz2": { + "build": "py36h8a99c1e_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "079dfa90f44b0e1e725fcc415dc44364", + "name": "morfessor", + "sha256": "3299478043e12eaeb10911b36562e409f529516c7678efe038c1cc9bb3f19527", + "size": 60268, + "subdir": "linux-64", + "timestamp": 1508795529734, + "version": "2.0.3" + }, + "morfessor-2.0.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "20c1e9e92d90e6c7a748a90a2b6cf125", + "name": "morfessor", + "sha256": "8c3f56c51bc4a128ab44dffafe25a6b69ec2abbe3ca3b2990f3fbaa928b096a7", + "size": 58629, + "subdir": "linux-64", + "timestamp": 1522129209180, + "version": "2.0.4" + }, + "morfessor-2.0.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "2356e63ce0ebd9cddfc4d92006e85b92", + "name": "morfessor", + "sha256": "ae1508f77574bea3552794cd96a7eec0eee49ef0c3188be6a29c534f83802476", + "size": 60083, + "subdir": "linux-64", + "timestamp": 1522129214249, + "version": "2.0.4" + }, + "morfessor-2.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "59196e84bfee21de231eaf57d4a7c521", + "name": "morfessor", + "sha256": "3c28f59ce303e4af1dcbae35f55f5f8fc6d129f796c0226b26f829ec4afaf4f3", + "size": 59851, + "subdir": "linux-64", + "timestamp": 1522129214932, + "version": "2.0.4" + }, + "morfessor-2.0.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "19f50babb1ffbf2b7dfb6850792e4536", + "name": "morfessor", + "sha256": "69f219bed7e11d53179e613f3d83e8492527fead7e045935e9ea616ead2c68c4", + "size": 59806, + "subdir": "linux-64", + "timestamp": 1530888070446, + "version": "2.0.4" + }, + "moto-4.0.11-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aws-xray-sdk >=0.93,!=0.96", + "boto3 >=1.9.201", + "botocore >=1.12.201", + "cfn-lint >=0.4.0", + "cryptography >=3.3.1", + "docker-py >=2.5.1", + "ecdsa !=0.15", + "flask", + "flask_cors", + "graphql-core", + "idna >=2.5,<4", + "jinja2 >=2.10.1", + "jsondiff >=1.1.2", + "markupsafe !=2.0.0a1", + "openapi-spec-validator", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.1,<3.0.0", + "python-jose >=3.1.0,<4.0.0", + "pytz", + "pyyaml >=5.1", + "requests >=2.5", + "responses >=0.13.0", + "sshpubkeys >=3.1.0", + "werkzeug >=0.5,!=2.2.0,!=2.2.1", + "xmltodict" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "afe4fcea1bd4a05657c05177954cf777", + "name": "moto", + "sha256": "dc171a387b1285c94144323c18917be45d556ff92602b507e6bd887656425e34", + "size": 2646572, + "subdir": "linux-64", + "timestamp": 1671141758412, + "version": "4.0.11" + }, + "moto-4.0.11-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-xray-sdk >=0.93,!=0.96", + "boto3 >=1.9.201", + "botocore >=1.12.201", + "cfn-lint >=0.4.0", + "cryptography >=3.3.1", + "docker-py >=2.5.1", + "ecdsa !=0.15", + "flask", + "flask_cors", + "graphql-core", + "idna >=2.5,<4", + "importlib_metadata", + "jinja2 >=2.10.1", + "jsondiff >=1.1.2", + "markupsafe !=2.0.0a1", + "openapi-spec-validator", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "python-jose >=3.1.0,<4.0.0", + "pytz", + "pyyaml >=5.1", + "requests >=2.5", + "responses >=0.13.0", + "sshpubkeys >=3.1.0", + "werkzeug >=0.5,!=2.2.0,!=2.2.1", + "xmltodict" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "185230c918010513813a4bbfac5d81be", + "name": "moto", + "sha256": "7052a90cbb13be45abc7ceee8e0e9ce465edb2b0fe6d4ee49f9d47dd070f4c74", + "size": 2610408, + "subdir": "linux-64", + "timestamp": 1671141694713, + "version": "4.0.11" + }, + "moto-4.0.11-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-xray-sdk >=0.93,!=0.96", + "boto3 >=1.9.201", + "botocore >=1.12.201", + "cfn-lint >=0.4.0", + "cryptography >=3.3.1", + "docker-py >=2.5.1", + "ecdsa !=0.15", + "flask", + "flask_cors", + "graphql-core", + "idna >=2.5,<4", + "jinja2 >=2.10.1", + "jsondiff >=1.1.2", + "markupsafe !=2.0.0a1", + "openapi-spec-validator", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1,<3.0.0", + "python-jose >=3.1.0,<4.0.0", + "pytz", + "pyyaml >=5.1", + "requests >=2.5", + "responses >=0.13.0", + "sshpubkeys >=3.1.0", + "werkzeug >=0.5,!=2.2.0,!=2.2.1", + "xmltodict" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "467adac04d3387fa2f3609d350bf7b9c", + "name": "moto", + "sha256": "b965ee521a9e7d4f782fb0af5ee3da4b9c5f998850494e785b0429c94cf9c0b0", + "size": 2615795, + "subdir": "linux-64", + "timestamp": 1671141627730, + "version": "4.0.11" + }, + "moto-4.0.11-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aws-xray-sdk >=0.93,!=0.96", + "boto3 >=1.9.201", + "botocore >=1.12.201", + "cfn-lint >=0.4.0", + "cryptography >=3.3.1", + "docker-py >=2.5.1", + "ecdsa !=0.15", + "flask", + "flask_cors", + "graphql-core", + "idna >=2.5,<4", + "jinja2 >=2.10.1", + "jsondiff >=1.1.2", + "markupsafe !=2.0.0a1", + "openapi-spec-validator", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1,<3.0.0", + "python-jose >=3.1.0,<4.0.0", + "pytz", + "pyyaml >=5.1", + "requests >=2.5", + "responses >=0.13.0", + "sshpubkeys >=3.1.0", + "werkzeug >=0.5,!=2.2.0,!=2.2.1", + "xmltodict" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "aa94a92ba0eaa8f07781fba378897495", + "name": "moto", + "sha256": "e51ccf8f0fa504d730fad59001d0121ea8360db595b2e77f10a7b58e39f5d387", + "size": 2613602, + "subdir": "linux-64", + "timestamp": 1671141821140, + "version": "4.0.11" + }, + "moto-4.1.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aws-xray-sdk >=0.93,!=0.96", + "boto3 >=1.9.201", + "botocore >=1.12.201", + "cfn-lint >=0.40.0", + "cryptography >=3.3.1", + "docker-py >=2.5.1", + "ecdsa !=0.15", + "flask !=2.2.0,!=2.2.1", + "flask_cors", + "graphql-core", + "jinja2 >=2.10.1", + "jsondiff >=1.1.2", + "openapi-spec-validator >=0.2.8", + "pyparsing >=3.0.7", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.1,<3.0.0", + "python-jose >=3.1.0,<4.0.0", + "pyyaml >=5.1", + "requests >=2.5", + "responses >=0.13.0", + "sshpubkeys >=3.1.0", + "werkzeug >=0.5,!=2.2.0,!=2.2.1", + "xmltodict" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "01a05c9363bb47c21172071681491970", + "name": "moto", + "sha256": "67a22b9705ef2476ea2c3143a5f80f4752d7c36e8d17499a2b7883373c3c55fc", + "size": 2727703, + "subdir": "linux-64", + "timestamp": 1677780517180, + "version": "4.1.3" + }, + "moto-4.1.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aws-xray-sdk >=0.93,!=0.96", + "boto3 >=1.9.201", + "botocore >=1.12.201", + "cfn-lint >=0.40.0", + "cryptography >=3.3.1", + "docker-py >=2.5.1", + "ecdsa !=0.15", + "flask !=2.2.0,!=2.2.1", + "flask_cors", + "graphql-core", + "jinja2 >=2.10.1", + "jsondiff >=1.1.2", + "openapi-spec-validator >=0.2.8", + "pyparsing >=3.0.7", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.1,<3.0.0", + "python-jose >=3.1.0,<4.0.0", + "pyyaml >=5.1", + "requests >=2.5", + "responses >=0.13.0", + "sshpubkeys >=3.1.0", + "werkzeug >=0.5,!=2.2.0,!=2.2.1", + "xmltodict" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "694477f13c1bb95d36020eafe815b4ad", + "name": "moto", + "sha256": "206210189c148b3750e230b408cc925d7899299d51786a3df7499efb1c643952", + "size": 3493670, + "subdir": "linux-64", + "timestamp": 1677784813804, + "version": "4.1.3" + }, + "moto-4.1.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-xray-sdk >=0.93,!=0.96", + "boto3 >=1.9.201", + "botocore >=1.12.201", + "cfn-lint >=0.40.0", + "cryptography >=3.3.1", + "docker-py >=2.5.1", + "ecdsa !=0.15", + "flask !=2.2.0,!=2.2.1", + "flask_cors", + "graphql-core", + "jinja2 >=2.10.1", + "jsondiff >=1.1.2", + "openapi-spec-validator >=0.2.8", + "pyparsing >=3.0.7", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1,<3.0.0", + "python-jose >=3.1.0,<4.0.0", + "pyyaml >=5.1", + "requests >=2.5", + "responses >=0.13.0", + "sshpubkeys >=3.1.0", + "werkzeug >=0.5,!=2.2.0,!=2.2.1", + "xmltodict" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5b6874208e47fc42eaf0086148fa6ee5", + "name": "moto", + "sha256": "d6bb86e2c1269164df6e6710c69842ff8d3625ed02974213937833169702100b", + "size": 2696023, + "subdir": "linux-64", + "timestamp": 1677780393253, + "version": "4.1.3" + }, + "moto-4.1.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aws-xray-sdk >=0.93,!=0.96", + "boto3 >=1.9.201", + "botocore >=1.12.201", + "cfn-lint >=0.40.0", + "cryptography >=3.3.1", + "docker-py >=2.5.1", + "ecdsa !=0.15", + "flask !=2.2.0,!=2.2.1", + "flask_cors", + "graphql-core", + "jinja2 >=2.10.1", + "jsondiff >=1.1.2", + "openapi-spec-validator >=0.2.8", + "pyparsing >=3.0.7", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1,<3.0.0", + "python-jose >=3.1.0,<4.0.0", + "pyyaml >=5.1", + "requests >=2.5", + "responses >=0.13.0", + "sshpubkeys >=3.1.0", + "werkzeug >=0.5,!=2.2.0,!=2.2.1", + "xmltodict" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9ebd925055ed80a7befcbda1304f8d8b", + "name": "moto", + "sha256": "cc9fe0bc6681047f974188f1c8bbb4808dec533160aaabf765eae8048e05937e", + "size": 2695573, + "subdir": "linux-64", + "timestamp": 1677780457056, + "version": "4.1.3" + }, + "mpc-1.0.3-hec55b23_5.tar.bz2": { + "build": "hec55b23_5", + "build_number": 5, + "depends": [ + "gmp >=5.0.1,<7", + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "mpfr" + ], + "license": "LGPL 3", + "md5": "68902bbaa3824b12b4caf4213b3fbb96", + "name": "mpc", + "sha256": "097a556b06449faa874b1f5bb72d4b076eb0eb8509e9816dbca89562a5589cf1", + "size": 97084, + "subdir": "linux-64", + "timestamp": 1511294796834, + "version": "1.0.3" + }, + "mpc-1.0.3-hf803216_4.tar.bz2": { + "build": "hf803216_4", + "build_number": 4, + "depends": [ + "gmp >=5.0.1,<7", + "libgcc-ng >=7.2.0", + "mpfr 3.*" + ], + "license": "LGPL 3", + "md5": "535b567f19c29b3284fb625d4a116f55", + "name": "mpc", + "sha256": "a0145bcc8a24a87f2799aec0a3d8c1f47a131707e0d52958561d51510263a89b", + "size": 96345, + "subdir": "linux-64", + "timestamp": 1505743972498, + "version": "1.0.3" + }, + "mpc-1.1.0-h10f8cd9_1.tar.bz2": { + "build": "h10f8cd9_1", + "build_number": 1, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "mpfr >=4.0.1,<5.0a0" + ], + "license": "LGPL 3", + "md5": "c3e5119d578d2418331013ba024ba0bc", + "name": "mpc", + "sha256": "2d95fe186309a0ee27df3a9af16aed4135d13e504844807b39d2c8e0b79a7ea0", + "size": 96138, + "subdir": "linux-64", + "timestamp": 1527612531645, + "version": "1.1.0" + }, + "mpfr-3.1.5-h11a74b3_2.tar.bz2": { + "build": "h11a74b3_2", + "build_number": 2, + "depends": [ + "gmp", + "gmp >=6.1.2", + "libgcc-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "9a8877aad0f0ec401a53d806afb8a175", + "name": "mpfr", + "sha256": "2fffe34c67faf25c5a5997b806e1c41909ac1ccfd956df3d77233d15117c9b9c", + "size": 454582, + "subdir": "linux-64", + "timestamp": 1511294529949, + "version": "3.1.5" + }, + "mpfr-3.1.5-h12ff648_1.tar.bz2": { + "build": "h12ff648_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "cadc73e114bc58a24f6363ef2d27cb7a", + "name": "mpfr", + "sha256": "efaeceadd912a4b8d5df3a89a4194e1a74288851a52da7789d83c9364ce24e7a", + "size": 453945, + "subdir": "linux-64", + "timestamp": 1505743909510, + "version": "3.1.5" + }, + "mpfr-4.0.1-hdf1c602_3.tar.bz2": { + "build": "hdf1c602_3", + "build_number": 3, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "09dce7b6c7eeb849a7b0c4a3c807418f", + "name": "mpfr", + "sha256": "e33eaba92c8a6f3984521f6273c926c79dd3cc4b618cd58e82614f2495acf7bd", + "size": 589000, + "subdir": "linux-64", + "timestamp": 1527610359076, + "version": "4.0.1" + }, + "mpfr-4.0.2-hb69a4c5_1.tar.bz2": { + "build": "hb69a4c5_1", + "build_number": 1, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0" + ], + "license": "LGPL-3.0-only", + "md5": "207e53f498d2efe14423a980e4d74816", + "name": "mpfr", + "sha256": "45797c64e087386ef4a31738858fd43ed3c035a4e01f391fac8aa4fc6e6a8b40", + "size": 668948, + "subdir": "linux-64", + "timestamp": 1593116348009, + "version": "4.0.2" + }, + "mpg123-1.25.8-h295c915_1000.tar.bz2": { + "build": "h295c915_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "7be9c751d8fa0642e0bf3660e368dd4c", + "name": "mpg123", + "sha256": "855e1c8d9152f11fa19e774a9a97cc8efc754a6e322f3569baaad7d0cb91c5d8", + "size": 326732, + "subdir": "linux-64", + "timestamp": 1632139645963, + "version": "1.25.8" + }, + "mpg123-1.30.0-h6a678d5_1000.tar.bz2": { + "build": "h6a678d5_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "92188b2814499a9b2bb1d5e9dcebfb58", + "name": "mpg123", + "sha256": "94783cd173aa6d42dbb05fe6244ad6a8cf37a6338ce28706038113b97b150ef5", + "size": 526356, + "subdir": "linux-64", + "timestamp": 1656450584250, + "version": "1.30.0" + }, + "mpi-1.0-mpich.tar.bz2": { + "build": "mpich", + "build_number": 8, + "depends": [], + "license": "MPICH", + "license_family": "Other", + "md5": "c0c509697a317960877a5499ffd9cdbf", + "name": "mpi", + "sha256": "c08fbeec22be3f8d6272c7952f33a8efaba50a7ad22a1a5807e4f82e62c8b5d9", + "size": 13200, + "subdir": "linux-64", + "timestamp": 1555635183453, + "version": "1.0" + }, + "mpi-1.0-openmpi.tar.bz2": { + "build": "openmpi", + "build_number": 0, + "depends": [], + "license": "BSD 3-clause", + "md5": "183b211e7bf9fa783d3aac1d13a807fc", + "name": "mpi", + "sha256": "951ab05a563d041dbca23faeec273af68b5324030292f4b3112a5b8dbc7623ef", + "size": 6149, + "subdir": "linux-64", + "timestamp": 1575396115448, + "version": "1.0" + }, + "mpi4py-3.0.3-py27h028fd6f_0.tar.bz2": { + "build": "py27h028fd6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mpich >=3.3,<3.4.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "73291b955f7fed075644817514664e42", + "name": "mpi4py", + "sha256": "018ed98c4a4a2882b1054a9776e53a4f9192c1870cf4183b288154ec2d24be8f", + "size": 653024, + "subdir": "linux-64", + "timestamp": 1575396802756, + "version": "3.0.3" + }, + "mpi4py-3.0.3-py27hd0bea5a_0.tar.bz2": { + "build": "py27hd0bea5a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openmpi >=4.0,<4.1.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "884ec6dd183c4fc7e7e4b95507b32d5b", + "name": "mpi4py", + "sha256": "f855c515f513bf991cbb5992fef8e1ad012b17099dd5a0358ae2129a2833743f", + "size": 657154, + "subdir": "linux-64", + "timestamp": 1575397289640, + "version": "3.0.3" + }, + "mpi4py-3.0.3-py36h028fd6f_0.tar.bz2": { + "build": "py36h028fd6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mpich >=3.3,<3.4.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "89b2460a14952a4923a379ee0080f554", + "name": "mpi4py", + "sha256": "7a95d3131e4757bc77d855dc17080b880be8461500f06e9f13a11a2b550a7658", + "size": 655103, + "subdir": "linux-64", + "timestamp": 1575396757962, + "version": "3.0.3" + }, + "mpi4py-3.0.3-py36hd0bea5a_0.tar.bz2": { + "build": "py36hd0bea5a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openmpi >=4.0,<4.1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "b30ac4f2adf178f531ecd6b272a5ade7", + "name": "mpi4py", + "sha256": "0c965d20343babd79a309241292fe0ff194dd5ee41e7e9327c59e95321928c8c", + "size": 658238, + "subdir": "linux-64", + "timestamp": 1575397284445, + "version": "3.0.3" + }, + "mpi4py-3.0.3-py37h028fd6f_0.tar.bz2": { + "build": "py37h028fd6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mpich >=3.3,<3.4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "6c9c8c72d0ef53f3399b01461a4dcc4a", + "name": "mpi4py", + "sha256": "1919d9e4edb52fd65dcbbcefc2b00e115ab9591ab2250072340cd7559364d25a", + "size": 658919, + "subdir": "linux-64", + "timestamp": 1575396757721, + "version": "3.0.3" + }, + "mpi4py-3.0.3-py37hd0bea5a_0.tar.bz2": { + "build": "py37hd0bea5a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openmpi >=4.0,<4.1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "eb78041418753fa89d7bb78a5a0ede6a", + "name": "mpi4py", + "sha256": "84815006f4d164f93b536e1c28e1ff996f895220e0f5e85fdbe14bbf4553b2b0", + "size": 662982, + "subdir": "linux-64", + "timestamp": 1575397292358, + "version": "3.0.3" + }, + "mpi4py-3.0.3-py37hd955b32_1.tar.bz2": { + "build": "py37hd955b32_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "openmpi >=4.0,<4.1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "331f1d6d55cfe24eb038a11cce93c8ec", + "name": "mpi4py", + "sha256": "1ddce176192eedeaa136741169dd51c34d8908123f3041bb67a44b04c933c1f6", + "size": 662486, + "subdir": "linux-64", + "timestamp": 1594374186510, + "version": "3.0.3" + }, + "mpi4py-3.0.3-py37hf046da1_1.tar.bz2": { + "build": "py37hf046da1_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "mpich >=3.3,<3.4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "02005f5d77e86a34391d4dfedc7bc4ae", + "name": "mpi4py", + "sha256": "0de2e5fe5c540fb9b416bb0d36a54db91f14f674417e89ea93c8cfea2fda37c0", + "size": 659154, + "subdir": "linux-64", + "timestamp": 1594374096623, + "version": "3.0.3" + }, + "mpi4py-3.0.3-py38h028fd6f_0.tar.bz2": { + "build": "py38h028fd6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mpich >=3.3,<3.4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "d1ff5880f9f757165bc51693da759d6d", + "name": "mpi4py", + "sha256": "4a4b43521cb2a7cc574ae86a464d96b44d7b71c8b265175fce97ad630959e882", + "size": 694412, + "subdir": "linux-64", + "timestamp": 1575396794073, + "version": "3.0.3" + }, + "mpi4py-3.0.3-py38hd0bea5a_0.tar.bz2": { + "build": "py38hd0bea5a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openmpi >=4.0,<4.1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "774515f9944725dee31bcb9f4673ef2d", + "name": "mpi4py", + "sha256": "9084a4f053ed9a62a4023ee9b87cc669c23273e153d7e2ae58a905353439b3ef", + "size": 694112, + "subdir": "linux-64", + "timestamp": 1575397312527, + "version": "3.0.3" + }, + "mpi4py-3.1.4-py310h3e5f7c9_0.tar.bz2": { + "build": "py310h3e5f7c9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openmpi >=4.0,<4.1.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9f673271ef3991e98be3e70024e3c16a", + "name": "mpi4py", + "sha256": "62e8f96fb9df0821eeae028a21e8d36b7f3dee8cc1266db51f78b62c74ec146c", + "size": 625384, + "subdir": "linux-64", + "timestamp": 1671223561358, + "version": "3.1.4" + }, + "mpi4py-3.1.4-py310hfc96bbd_0.tar.bz2": { + "build": "py310hfc96bbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mpich >=3.3,<3.4.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "280779fb2908be20525d6879187230da", + "name": "mpi4py", + "sha256": "d7936fcc21507e8a668f9fc8565f9fcefe962af93f942be3c071419ad54e54b9", + "size": 620871, + "subdir": "linux-64", + "timestamp": 1671223798897, + "version": "3.1.4" + }, + "mpi4py-3.1.4-py311h3e5f7c9_0.tar.bz2": { + "build": "py311h3e5f7c9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openmpi >=4.0,<4.1.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c0d5a6ef2dcfcad353f9470d89a5b674", + "name": "mpi4py", + "sha256": "fa94a085dd55472eb115ced48afd00486a489d8ff274b539b4456ef7e834d1eb", + "size": 647538, + "subdir": "linux-64", + "timestamp": 1676858780773, + "version": "3.1.4" + }, + "mpi4py-3.1.4-py311hfc96bbd_0.tar.bz2": { + "build": "py311hfc96bbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mpich >=3.3,<3.4.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "29424dec4de33de4d1f0507ed0e786c7", + "name": "mpi4py", + "sha256": "3436de709657bf5ae3c7b89c5d82339858c15ae1ed1d878ef1c87e0d00d66654", + "size": 644542, + "subdir": "linux-64", + "timestamp": 1676858739897, + "version": "3.1.4" + }, + "mpi4py-3.1.4-py37h3e5f7c9_0.tar.bz2": { + "build": "py37h3e5f7c9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openmpi >=4.0,<4.1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "31199e172ae0bd131d350b32ef083a7d", + "name": "mpi4py", + "sha256": "5bdb57f8554aaf1d2ad2ec7f6be059307758612a489af845212007796485001d", + "size": 600035, + "subdir": "linux-64", + "timestamp": 1671223445145, + "version": "3.1.4" + }, + "mpi4py-3.1.4-py37hfc96bbd_0.tar.bz2": { + "build": "py37hfc96bbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mpich >=3.3,<3.4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "827814b756efd9d66cc67fde955698cb", + "name": "mpi4py", + "sha256": "4d6ce885d4bda6d159422710b84556fc425f71826e6a8418d57630e0a1066b93", + "size": 596081, + "subdir": "linux-64", + "timestamp": 1671223680592, + "version": "3.1.4" + }, + "mpi4py-3.1.4-py38h3e5f7c9_0.tar.bz2": { + "build": "py38h3e5f7c9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openmpi >=4.0,<4.1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "eaba0702bd035b041dc44b03df76de09", + "name": "mpi4py", + "sha256": "90246d35bc931e2aa6865dbe2ae5a9ba0cb1f29492abd9048a1e141e8ee20518", + "size": 628174, + "subdir": "linux-64", + "timestamp": 1671223619089, + "version": "3.1.4" + }, + "mpi4py-3.1.4-py38hfc96bbd_0.tar.bz2": { + "build": "py38hfc96bbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mpich >=3.3,<3.4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b08295bcef09353b3894f2125f424161", + "name": "mpi4py", + "sha256": "6dd9bca5e3c2be830b1f2b949541871d6b1a4b04057a8de538312868b7be6255", + "size": 624839, + "subdir": "linux-64", + "timestamp": 1671223857796, + "version": "3.1.4" + }, + "mpi4py-3.1.4-py39h3e5f7c9_0.tar.bz2": { + "build": "py39h3e5f7c9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openmpi >=4.0,<4.1.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "2c6d80c86505cd4c9cade9419f6bff56", + "name": "mpi4py", + "sha256": "22120424c3f56636fd947fc8617bcdaa87f6080c971dc5436332c64df3d23840", + "size": 628989, + "subdir": "linux-64", + "timestamp": 1671223503185, + "version": "3.1.4" + }, + "mpi4py-3.1.4-py39hfc96bbd_0.tar.bz2": { + "build": "py39hfc96bbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mpich >=3.3,<3.4.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "4246a710b6550781427a396575efac63", + "name": "mpi4py", + "sha256": "912300d0a9183a9fa06b8633cdb1a2e3c8bc2244f26e62a08fe6ccc0213d7a25", + "size": 625588, + "subdir": "linux-64", + "timestamp": 1671223739584, + "version": "3.1.4" + }, + "mpich-3.2.1-hf39692e_8.tar.bz2": { + "build": "hf39692e_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mpi 1.0 mpich" + ], + "license": "MPICH", + "license_family": "Other", + "md5": "eabc193f8ad3733912ce82a8803beb33", + "name": "mpich", + "sha256": "6e5cde7936ab7e380fd0ac4f63b4d83642356d160342070d74c52c87b6a1d2b7", + "size": 6235375, + "subdir": "linux-64", + "timestamp": 1555635512696, + "version": "3.2.1" + }, + "mpich-3.3.2-external_0.tar.bz2": { + "build": "external_0", + "build_number": 0, + "depends": [ + "mpi 1.0 mpich" + ], + "license": "MPICH", + "license_family": "Other", + "md5": "37793558673502558f7c2fda71ed2ea6", + "name": "mpich", + "sha256": "a114ef54113b8f2a499278025784c2fdba71663d9f181be3178c87b36b05a771", + "size": 14826, + "subdir": "linux-64", + "timestamp": 1575396471911, + "track_features": "mpich_external", + "version": "3.3.2" + }, + "mpich-3.3.2-hc856adb_0.tar.bz2": { + "build": "hc856adb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mpi 1.0 mpich" + ], + "license": "MPICH", + "license_family": "Other", + "md5": "08c4539f50d920a6d39be5b1c741431e", + "name": "mpich", + "sha256": "5e4cc6f8d3cc869a1920c9b90f8a8841aaf2a6032d1520bc65b3f614c012da6a", + "size": 6712610, + "subdir": "linux-64", + "timestamp": 1575396464358, + "version": "3.3.2" + }, + "mpich-mpicc-3.2.1-h7b6447c_8.tar.bz2": { + "build": "h7b6447c_8", + "build_number": 8, + "depends": [ + "gcc_linux-64 7.3.0.*", + "mpich 3.2.1 hf39692e_8" + ], + "license": "MPICH", + "license_family": "Other", + "md5": "3ef6d7ac7565651e8d736c214d42ea46", + "name": "mpich-mpicc", + "sha256": "0a63dcd5955dd8dcb3d7914de721a71cdbe3b482255f4693050ecd61d2a309ed", + "size": 13433, + "subdir": "linux-64", + "timestamp": 1555635526259, + "version": "3.2.1" + }, + "mpich-mpicc-3.3.2-hf39692e_0.tar.bz2": { + "build": "hf39692e_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 7.3.0.*", + "mpich 3.3.2 hc856adb_0" + ], + "license": "MPICH", + "license_family": "Other", + "md5": "f0a1c8433b656041822bed963add5c9b", + "name": "mpich-mpicc", + "sha256": "40402ce92592a870cad9f16fff3847069dbd8de54e576bced9a27319ce67ba23", + "size": 14969, + "subdir": "linux-64", + "timestamp": 1575396475290, + "version": "3.3.2" + }, + "mpich-mpicxx-3.2.1-hfd86e86_8.tar.bz2": { + "build": "hfd86e86_8", + "build_number": 8, + "depends": [ + "gxx_linux-64 7.3.0.*", + "mpich 3.2.1 hf39692e_8" + ], + "license": "MPICH", + "license_family": "Other", + "md5": "3ac109819e29ad67d2894e6102bac0bf", + "name": "mpich-mpicxx", + "sha256": "ce37360a451e2e1a1f0f10e0f0f9788940b572f7b074600f618eb1a63fae24ed", + "size": 13450, + "subdir": "linux-64", + "timestamp": 1555635529681, + "version": "3.2.1" + }, + "mpich-mpicxx-3.3.2-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "gxx_linux-64 7.3.0.*", + "mpich 3.3.2 hc856adb_0" + ], + "license": "MPICH", + "license_family": "Other", + "md5": "e69b7783435073d438d7d2da43d4b6db", + "name": "mpich-mpicxx", + "sha256": "d015fb108ddcddd9b052763099ee0a862a99419cff9f1d2eac78f328f31deb86", + "size": 14956, + "subdir": "linux-64", + "timestamp": 1575396478844, + "version": "3.3.2" + }, + "mpich-mpifort-3.2.1-h84218bc_8.tar.bz2": { + "build": "h84218bc_8", + "build_number": 8, + "depends": [ + "gfortran_linux-64 7.3.0.*", + "mpich 3.2.1 hf39692e_8" + ], + "license": "MPICH", + "license_family": "Other", + "md5": "1a8c32c6067d5e3219f4f863a1c41882", + "name": "mpich-mpifort", + "sha256": "b639bb7ad10b5a690aad68756b977862b352cad9ecb3eead607644af5434b685", + "size": 13499, + "subdir": "linux-64", + "timestamp": 1555635533134, + "version": "3.2.1" + }, + "mpich-mpifort-3.3.2-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "gfortran_linux-64 7.3.0.*", + "mpich 3.3.2 hc856adb_0" + ], + "license": "MPICH", + "license_family": "Other", + "md5": "44cae5a8a0ad38e01631dceb030ca005", + "name": "mpich-mpifort", + "sha256": "ceb172c53f5b292ef4456f31bff8fb2ae55fc950d286f3c3aaccf3e62aa94fd4", + "size": 15021, + "subdir": "linux-64", + "timestamp": 1575396482505, + "version": "3.3.2" + }, + "mpir-3.0.0-h3e5f119_1.tar.bz2": { + "build": "h3e5f119_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "8d7655e7e65ae7f3380e1d4b62a69c8d", + "name": "mpir", + "sha256": "0ee81f18f4df07ffd334f0542c175960d76187344be4955222dee9137bae7f1b", + "size": 635962, + "subdir": "linux-64", + "timestamp": 1511296144847, + "version": "3.0.0" + }, + "mpl-scatter-density-0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "fast-histogram >=0.3", + "matplotlib >=1.5", + "numpy >=1.11", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "c39b90f055de6bf6be909a36369a1fe4", + "name": "mpl-scatter-density", + "sha256": "7f4fffd5e98ee43d087f4f81f434dca4ebe35a5b5d9a519f793b9a42971be4d4", + "size": 1731390, + "subdir": "linux-64", + "timestamp": 1525295118007, + "version": "0.3" + }, + "mpl-scatter-density-0.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "fast-histogram >=0.3", + "matplotlib >=1.5", + "numpy >=1.11", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "f788010a2ba553005937440032b34928", + "name": "mpl-scatter-density", + "sha256": "6eada46600f056a7326b4f65af0bc9d01ac9dba2daeb534b462db90f9da474e0", + "size": 1732008, + "subdir": "linux-64", + "timestamp": 1525295118155, + "version": "0.3" + }, + "mpl-scatter-density-0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "fast-histogram >=0.3", + "matplotlib >=1.5", + "numpy >=1.11", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "b1f99c6315f0fb751859435ea79e7b33", + "name": "mpl-scatter-density", + "sha256": "e82f4a8047d9dd55fd86975704a113bf2136c75e2a9be86ac61fbb5225be52b4", + "size": 1731590, + "subdir": "linux-64", + "timestamp": 1525294023138, + "version": "0.3" + }, + "mpl-scatter-density-0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "fast-histogram >=0.3", + "matplotlib >=1.5", + "numpy >=1.11", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "b0e3bbc240d984f5e8674f94c005e62d", + "name": "mpl-scatter-density", + "sha256": "4114d6cbb217296d61756109afa7a4eda8c642950277960d6a1936752240167c", + "size": 1731447, + "subdir": "linux-64", + "timestamp": 1530891003814, + "version": "0.3" + }, + "mpl-scatter-density-0.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "fast-histogram >=0.3", + "matplotlib >=1.5", + "numpy >=1.11", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "0b593893f11a0146827303151e5e3d85", + "name": "mpl-scatter-density", + "sha256": "3150f0130007dd75abed9092576ea7ae6109a3980f83fb2fb9411e591941f357", + "size": 1738713, + "subdir": "linux-64", + "timestamp": 1536255570778, + "version": "0.4" + }, + "mpl-scatter-density-0.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "fast-histogram >=0.3", + "matplotlib >=1.5", + "numpy >=1.11", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "150c6f1173b9836bdd8821aab79d620c", + "name": "mpl-scatter-density", + "sha256": "7ccca926652939f0ce452e6ce6759d7eaa8e9b16fcbd9b0400e8db7d905254ac", + "size": 1738809, + "subdir": "linux-64", + "timestamp": 1536255716682, + "version": "0.4" + }, + "mpl-scatter-density-0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "fast-histogram >=0.3", + "matplotlib >=1.5", + "numpy >=1.11", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "a3b368065315b75bcfb808df57d5dd1d", + "name": "mpl-scatter-density", + "sha256": "462d9b87603f4dbbe1d028463723b1d39fd6b07a6c0511bc853daa931b6e0576", + "size": 1738843, + "subdir": "linux-64", + "timestamp": 1536255682621, + "version": "0.4" + }, + "mpl-scatter-density-0.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "fast-histogram >=0.3", + "matplotlib >=1.5", + "numpy >=1.11", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "6a3fb4242f55b1437720a57ef9db62f0", + "name": "mpl-scatter-density", + "sha256": "71cb14a7e2eeac1359267dd15c5effa605e7af6fe240687f0089641008a0bf5c", + "size": 1738825, + "subdir": "linux-64", + "timestamp": 1536255705284, + "version": "0.4" + }, + "mpl_sample_data-3.1.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "matplotlib-base 3.1.2 py36hef1b27d_1", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "62cf81664b068deae0d8a77b5ac662f0", + "name": "mpl_sample_data", + "sha256": "7a5dabf48d27b12a4fa2fd5f5d4ef3d3806a8db61532d640755b1563c757f9dd", + "size": 1853518, + "subdir": "linux-64", + "timestamp": 1580491906088, + "version": "3.1.2" + }, + "mpl_sample_data-3.1.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "matplotlib-base 3.1.2 py37hef1b27d_1", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "8c3ce775109ae203066aa0bf8a300f21", + "name": "mpl_sample_data", + "sha256": "ea483794f2127eeb67b7fea26af8bd8b87525198d820e5abaa81cce4514dbf62", + "size": 1848865, + "subdir": "linux-64", + "timestamp": 1580491853267, + "version": "3.1.2" + }, + "mpl_sample_data-3.1.2-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "matplotlib-base 3.1.2 py38hef1b27d_1", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "fd55a4712f4c181bc3bb6b34c3a7930f", + "name": "mpl_sample_data", + "sha256": "a31be19b991b8e64853eda1b46593e9f4ea5eba5d34b6c00e787907a39feec62", + "size": 1853235, + "subdir": "linux-64", + "timestamp": 1580491876441, + "version": "3.1.2" + }, + "mpl_sample_data-3.1.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "matplotlib-base 3.1.3 py36hef1b27d_0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "a11f5c3d49699de6c0c4e749d2c51a50", + "name": "mpl_sample_data", + "sha256": "acd4b3ffd599ff0a8b41270f718eefc0098ef52cb30260b93c7392afccd8527d", + "size": 1852149, + "subdir": "linux-64", + "timestamp": 1580847946636, + "version": "3.1.3" + }, + "mpl_sample_data-3.1.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "matplotlib-base 3.1.3 py37hef1b27d_0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "2f61990a9fdcab878b77c1bddc16064b", + "name": "mpl_sample_data", + "sha256": "4cff93e5aef04d16b61ef0c13d65a41b74b2c65acc8912b0db5c0afbab509c67", + "size": 1848964, + "subdir": "linux-64", + "timestamp": 1580847945812, + "version": "3.1.3" + }, + "mpl_sample_data-3.1.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "matplotlib-base 3.1.3 py38hef1b27d_0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "abf9c380a9b655f0a47b10b4d57eab0c", + "name": "mpl_sample_data", + "sha256": "55b633d762ded04e253cab38b684234a708b3f017cb971cc5e0cabfacb905156", + "size": 1853076, + "subdir": "linux-64", + "timestamp": 1580847941427, + "version": "3.1.3" + }, + "mpld3-0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9148bd0eb5f55f97fea1ed3e55bce878", + "name": "mpld3", + "sha256": "5eab69c8dea9b8d36510dfc69f0e4a5a7be64563c9829b9c5893968dc2709fef", + "size": 128047, + "subdir": "linux-64", + "timestamp": 1522775909175, + "version": "0.3" + }, + "mpld3-0.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "af34b54bc01e2baabba17d323e4f147f", + "name": "mpld3", + "sha256": "2230ee97596525c0828581f9f0f3a54ac212455fa06376cf17db716a6b7466f7", + "size": 129117, + "subdir": "linux-64", + "timestamp": 1522775950358, + "version": "0.3" + }, + "mpld3-0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9824c6974e779a145f820567363e4bff", + "name": "mpld3", + "sha256": "77fa4ed8e6432cb1fb42a12aa124abb892fc4d5f1821252d28c5b7c621478a8b", + "size": 128979, + "subdir": "linux-64", + "timestamp": 1522775977476, + "version": "0.3" + }, + "mpld3-0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "81d015276e911241c97bf95ed04cbeae", + "name": "mpld3", + "sha256": "1a6c3b112355db8f8abb9f774c35b89008564277d589655e64fa3fbc6fcab493", + "size": 128746, + "subdir": "linux-64", + "timestamp": 1530899269539, + "version": "0.3" + }, + "mpld3-0.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3d7adc8b71dcf6e3cefa7b4b6fefaabf", + "name": "mpld3", + "sha256": "19aa5220aea3ee313506d0a8833942e51c3ce923a2c7f6efa6730ed3bbdb5ade", + "size": 129455, + "subdir": "linux-64", + "timestamp": 1574414047235, + "version": "0.3" + }, + "mpld3-0.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ee352c80640319ffdbee9aaa7a7eb30d", + "name": "mpld3", + "sha256": "d9e41a183ac0b02d3f72f83c68c13b98323acad9e3c53a1e53b6cf2f8a248b85", + "size": 238532, + "subdir": "linux-64", + "timestamp": 1600444945965, + "version": "0.5.1" + }, + "mpld3-0.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "970f7f3ec3e2f4960e18a1428c0ebb9b", + "name": "mpld3", + "sha256": "5d3d7ceefb415b3093546537edf8501df2370fbd71d33d9bcb62542abd1216d7", + "size": 231641, + "subdir": "linux-64", + "timestamp": 1600444942489, + "version": "0.5.1" + }, + "mpld3-0.5.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5ec092deef2c330e276575c4173936dd", + "name": "mpld3", + "sha256": "de0c17cf3cb6312b3bc4843c7106819527288ed96888048cdc72764f35df2608", + "size": 238198, + "subdir": "linux-64", + "timestamp": 1600444917241, + "version": "0.5.1" + }, + "mpld3-0.5.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f6627f607487e64e51f432a64381efc5", + "name": "mpld3", + "sha256": "dfea92c599876d9d22890995787fe9ce5e3b5d646200400bbba0778db729ae1f", + "size": 203935, + "subdir": "linux-64", + "timestamp": 1612285389852, + "version": "0.5.2" + }, + "mpld3-0.5.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d6652699e662b3cb800286a67e0baf19", + "name": "mpld3", + "sha256": "a3179342c5ea5e94858e70712cf2edd5d5f4b8034edd2c4afdd5dd3532814153", + "size": 203994, + "subdir": "linux-64", + "timestamp": 1612285352053, + "version": "0.5.2" + }, + "mpld3-0.5.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "734227ca0e8d82ebfd5d98b47e274d39", + "name": "mpld3", + "sha256": "47996de02ff79f22556c7b0dda06350d76149818b3d75f45f624fc7780b0f1f2", + "size": 204034, + "subdir": "linux-64", + "timestamp": 1612285390745, + "version": "0.5.2" + }, + "mpld3-0.5.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ba4edbe802fbe8e5b458fb617a1ed3e3", + "name": "mpld3", + "sha256": "064e6fe3f172637cc0c742b1b6efb17cba2c44d0114e446da7a3c5586233239f", + "size": 203951, + "subdir": "linux-64", + "timestamp": 1612285388834, + "version": "0.5.2" + }, + "mpld3-0.5.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=2.0", + "jinja2 >=2.7", + "matplotlib >=1.3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ba7f4ba723240729358e19bdcf064b08", + "name": "mpld3", + "sha256": "cc45eee65a4fc7c90c4edcad0c60b0ce7c7325e06b66c5c4478d6486db63a357", + "size": 205783, + "subdir": "linux-64", + "timestamp": 1642515664664, + "version": "0.5.5" + }, + "mpld3-0.5.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=2.0", + "jinja2 >=2.7", + "matplotlib >=1.3", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0ad33a8380a83195b8f45bd60d6191ff", + "name": "mpld3", + "sha256": "6d82a2e364eac39e9026752524af95ad08e546ba4fc4e2300e633d001cb61edf", + "size": 222721, + "subdir": "linux-64", + "timestamp": 1676858798014, + "version": "0.5.5" + }, + "mpld3-0.5.5-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=2.0", + "jinja2 >=2.7", + "matplotlib >=1.3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f53be625864b5428801cbc8b1184eac0", + "name": "mpld3", + "sha256": "15c5afd7f76577aca198197e66de840216687c49400a082a5833a42e9dd7be20", + "size": 204937, + "subdir": "linux-64", + "timestamp": 1624427476189, + "version": "0.5.5" + }, + "mpld3-0.5.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=2.0", + "jinja2 >=2.7", + "matplotlib >=1.3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c3195131a37b45cca9e4f67a253a7925", + "name": "mpld3", + "sha256": "804be3602705af07179e13d5479d3af2e4cc3ffda38b201088f2a767ff8026c1", + "size": 204823, + "subdir": "linux-64", + "timestamp": 1624433629074, + "version": "0.5.5" + }, + "mpld3-0.5.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=2.0", + "jinja2 >=2.7", + "matplotlib >=1.3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "412edb5705d6225ff682e7b2111fa718", + "name": "mpld3", + "sha256": "5402bbb345458380cf23506cbb318b1295cdba0d94fc77dce3b7ced33dcf0ce7", + "size": 205012, + "subdir": "linux-64", + "timestamp": 1624433606443, + "version": "0.5.5" + }, + "mpld3-0.5.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=2.0", + "jinja2 >=2.7", + "matplotlib >=1.3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "720db329ec769483dbc45ce61b4f1d61", + "name": "mpld3", + "sha256": "77c8971ea5f9a764851f60f467ec5d8730c8e30f5a2522532b2ba0059195c1ee", + "size": 204973, + "subdir": "linux-64", + "timestamp": 1624433618789, + "version": "0.5.5" + }, + "mpmath-0.19-py27h4bb41bd_2.tar.bz2": { + "build": "py27h4bb41bd_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9394c16607e4b3218851d19240d4d91c", + "name": "mpmath", + "sha256": "79ee2792f10ff77ac1080e95b91bb34852b217fbf3cd7c98e1f9fb048aeffca9", + "size": 926474, + "subdir": "linux-64", + "timestamp": 1505745901141, + "version": "0.19" + }, + "mpmath-0.19-py35h5a16178_2.tar.bz2": { + "build": "py35h5a16178_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "30f24b08e65cd0c8e3687617ca2081c8", + "name": "mpmath", + "sha256": "750d2e5c587a6fc67f41be666a74fb9674c7eba03703bdc6e66f915166ea3a7d", + "size": 928969, + "subdir": "linux-64", + "timestamp": 1505745920389, + "version": "0.19" + }, + "mpmath-0.19-py36h8cc018b_2.tar.bz2": { + "build": "py36h8cc018b_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7160c09d840e6333157173811d31f36a", + "name": "mpmath", + "sha256": "bdffe322acf132fce0694e7e0502b36c0948a06270691690f1d4cd4722d7400b", + "size": 907181, + "subdir": "linux-64", + "timestamp": 1505745939809, + "version": "0.19" + }, + "mpmath-1.0.0-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e448b066fc784134664a155adf499c53", + "name": "mpmath", + "sha256": "a0f3272a4e93101f763efb6b96e3cc611f46b4304fcceff13d2bd59848c6e34f", + "size": 952951, + "subdir": "linux-64", + "timestamp": 1530772160767, + "version": "1.0.0" + }, + "mpmath-1.0.0-py27h9669132_2.tar.bz2": { + "build": "py27h9669132_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "68438f58b0f8d4774cc8874389d3341d", + "name": "mpmath", + "sha256": "e51f788a33006836d83e0970f24dd7e3bc2e52820bd0506da18c0a771a087ec7", + "size": 953290, + "subdir": "linux-64", + "timestamp": 1511810217800, + "version": "1.0.0" + }, + "mpmath-1.0.0-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "12bdc84a1deb7eb2b97642f36301bd1f", + "name": "mpmath", + "sha256": "29a9284db4b58484a7ab7983b1b3cbe5a5cc5150d6c6b021d17d5299e0f9bd99", + "size": 954484, + "subdir": "linux-64", + "timestamp": 1534804520047, + "version": "1.0.0" + }, + "mpmath-1.0.0-py35h7ce6e34_2.tar.bz2": { + "build": "py35h7ce6e34_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aa2dd48c51c913fbe429200b8978076e", + "name": "mpmath", + "sha256": "9ceb19f098e9080c01e2abae8e985f682e0d7c751f54ae35393cc2546eda7ae6", + "size": 955093, + "subdir": "linux-64", + "timestamp": 1511810223005, + "version": "1.0.0" + }, + "mpmath-1.0.0-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "75bde56726192be6364fc019580b9210", + "name": "mpmath", + "sha256": "4c94bf752e3f5ce8541df92dcd427585f5f8958b31a5cfe9480d421c3dc8aa7e", + "size": 913619, + "subdir": "linux-64", + "timestamp": 1530772188923, + "version": "1.0.0" + }, + "mpmath-1.0.0-py36hfeacd6b_2.tar.bz2": { + "build": "py36hfeacd6b_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "39c0f65de6a238281a99bbb41030d97b", + "name": "mpmath", + "sha256": "a88614d11ed8ec294961a73a22d700616d851b6ffc23a0f0ece8bb039241d423", + "size": 929759, + "subdir": "linux-64", + "timestamp": 1511810226368, + "version": "1.0.0" + }, + "mpmath-1.0.0-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5a10140591ae9151f9053db586c193ff", + "name": "mpmath", + "sha256": "a0a5ae4890938d10b8d778c1325cef9bd67737bbdee0aa44f8de2055ca598e9d", + "size": 906259, + "subdir": "linux-64", + "timestamp": 1530772134808, + "version": "1.0.0" + }, + "mpmath-1.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "85e75d7f05272b708d332bf92330efaf", + "name": "mpmath", + "sha256": "d95f777cd09d3ccd39fdb190bba885ec3070ab74276b7f2636c62fb4eac249dc", + "size": 995760, + "subdir": "linux-64", + "timestamp": 1545078602385, + "version": "1.1.0" + }, + "mpmath-1.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "732e40c935a2701af683905bc922747d", + "name": "mpmath", + "sha256": "6f01d24a15c081d5718fef3428859672d30605c0b17d36d978b707d703677e28", + "size": 993488, + "subdir": "linux-64", + "timestamp": 1545078640409, + "version": "1.1.0" + }, + "mpmath-1.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "108de8922f87d629c21eac5007563bdf", + "name": "mpmath", + "sha256": "d4865fb71417113e0cb8b118e9c90f19f2e6128cefff753342f4ea4a97c0e29f", + "size": 980122, + "subdir": "linux-64", + "timestamp": 1545078640500, + "version": "1.1.0" + }, + "mpmath-1.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6165743eb8fddc25d2cf832c5d7ab057", + "name": "mpmath", + "sha256": "0dcf74af5bc627ea0674f48c15f09bb1bca8e6698953dabe3b9f9f59549b50c6", + "size": 981495, + "subdir": "linux-64", + "timestamp": 1573120404744, + "version": "1.1.0" + }, + "mpmath-1.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "27433eb5468300bd3744ef5606c1f408", + "name": "mpmath", + "sha256": "efe00873083b8ff44d5af18d8bed12b2b69886847ed276a6899eb46894bd365d", + "size": 977120, + "subdir": "linux-64", + "timestamp": 1607574102978, + "version": "1.1.0" + }, + "mpmath-1.2.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d5a0a56e87dc075e76fe351680aaf66c", + "name": "mpmath", + "sha256": "e2a9c8c9d9f6b43a686fe7c912288ac13b6439521941c0fb900a434ef0916487", + "size": 984534, + "subdir": "linux-64", + "timestamp": 1640791702614, + "version": "1.2.1" + }, + "mpmath-1.2.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5e8e3491d46af9ed82c14fd658882b1a", + "name": "mpmath", + "sha256": "2e8b08135677be287c33a5af11856d7a6184998e9d79c6d70245623be46d6ef3", + "size": 1207603, + "subdir": "linux-64", + "timestamp": 1676841217311, + "version": "1.2.1" + }, + "mpmath-1.2.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e80005c759da274f8d8bea8384ee2a16", + "name": "mpmath", + "sha256": "ce98016fd52d85147f620eb3b368611af05667caf6fe42d8d98d810bd417124a", + "size": 992167, + "subdir": "linux-64", + "timestamp": 1616617265555, + "version": "1.2.1" + }, + "mpmath-1.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8fb0854b571def8a040611020d37a26a", + "name": "mpmath", + "sha256": "ce51bef05d6f1b92017783a3f0a2af1c6bd217f4ba6964a3de1c62bfafb583e8", + "size": 981180, + "subdir": "linux-64", + "timestamp": 1616617267624, + "version": "1.2.1" + }, + "mpmath-1.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c2462d729f97116149b9cfddb4f8a488", + "name": "mpmath", + "sha256": "9d14d41e05360ce2187082ab28c3c434a8be1a9d30f38e6e1112ed2a487bda59", + "size": 981648, + "subdir": "linux-64", + "timestamp": 1616617934782, + "version": "1.2.1" + }, + "mpmath-1.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "73d899b5b462ae889f986d4d75525def", + "name": "mpmath", + "sha256": "1df4127c7493592032bd709d483157809ac45f766e79f720d5608a6d225d06c3", + "size": 977095, + "subdir": "linux-64", + "timestamp": 1616616743372, + "version": "1.2.1" + }, + "msgpack-numpy-0.4.1-py27h8e01e4a_0.tar.bz2": { + "build": "py27h8e01e4a_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "33dc8f7a80a27332cea2b065380ab42c", + "name": "msgpack-numpy", + "sha256": "f0cc6b6795a605f6e72ccb010c091809bf570633f72ea806a54c3ee060795a44", + "size": 12903, + "subdir": "linux-64", + "timestamp": 1509290026098, + "version": "0.4.1" + }, + "msgpack-numpy-0.4.1-py35h45744f7_0.tar.bz2": { + "build": "py35h45744f7_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "acaf486d62b141aa7b8dded981aac08c", + "name": "msgpack-numpy", + "sha256": "62a321a28432339f4e71b0a95f0d965ef63f5979ca63a6ff7b1d8998c58cc54a", + "size": 13338, + "subdir": "linux-64", + "timestamp": 1509297596147, + "version": "0.4.1" + }, + "msgpack-numpy-0.4.1-py36hfef8c07_0.tar.bz2": { + "build": "py36hfef8c07_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a055dc73623c78215d8ddaab164929c7", + "name": "msgpack-numpy", + "sha256": "4bbe22ce0fbc4d0df59c17b6ba5b92567b80de30ffb5819bac7a8d5f7f41eb97", + "size": 13298, + "subdir": "linux-64", + "timestamp": 1509291483338, + "version": "0.4.1" + }, + "msgpack-numpy-0.4.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "54b3f8e092839944bf02cd40fd3c319e", + "name": "msgpack-numpy", + "sha256": "5c73ddcf0636062ce6ac6d8702d98640ebdfb2d0077c06927edbb801e592b674", + "size": 13737, + "subdir": "linux-64", + "timestamp": 1520917137643, + "version": "0.4.3" + }, + "msgpack-numpy-0.4.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "24fc33709f384f3397c5dd965f167815", + "name": "msgpack-numpy", + "sha256": "1b4c760e79abfc25414857e9b494f193280a1aa8112cc4e8429bae2f7c032aa7", + "size": 14304, + "subdir": "linux-64", + "timestamp": 1520917156553, + "version": "0.4.3" + }, + "msgpack-numpy-0.4.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e21090bfd00568dd3eb9d91941b0c309", + "name": "msgpack-numpy", + "sha256": "12f92e04f87eda999fb779dbce20e577a2b628ccd19411811f6489209cb5f051", + "size": 14254, + "subdir": "linux-64", + "timestamp": 1520917124189, + "version": "0.4.3" + }, + "msgpack-numpy-0.4.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e5b750432920025161e37fe331253b75", + "name": "msgpack-numpy", + "sha256": "81a44f4aad867b6c7b045b9272e7622e226b16315ee5a6bd1e14cc3b02df7263", + "size": 14342, + "subdir": "linux-64", + "timestamp": 1530899304884, + "version": "0.4.3" + }, + "msgpack-numpy-0.4.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0ff766f90a72987bef5f46882e86565e", + "name": "msgpack-numpy", + "sha256": "94c9e3683a27b14a7582df6c725f18cd55d4015810f4fd4baf916d9ab527ac14", + "size": 13687, + "subdir": "linux-64", + "timestamp": 1535508373931, + "version": "0.4.3.1" + }, + "msgpack-numpy-0.4.3.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6d9912de41fd05a17b64f1ef90a56c2a", + "name": "msgpack-numpy", + "sha256": "191baeb85cc8186e6daaf0eff487204f8f2346243fc9dbbcf9bb0f1fa30efcc8", + "size": 14247, + "subdir": "linux-64", + "timestamp": 1535508399871, + "version": "0.4.3.1" + }, + "msgpack-numpy-0.4.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6aa9811e7e15092c3d2f3508ab416ef8", + "name": "msgpack-numpy", + "sha256": "41a0b4c87f5ff48ebd881c3871b64efeb0f8fa61aa3a7ffe0af4283f75e7e7ff", + "size": 14201, + "subdir": "linux-64", + "timestamp": 1535508311327, + "version": "0.4.3.1" + }, + "msgpack-numpy-0.4.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "566000240b18960e74a21399ec36df79", + "name": "msgpack-numpy", + "sha256": "bf39eabe89c98bd0d911d57baca74c20c6081fd3ad4e05b6fc9e960b46f432df", + "size": 14195, + "subdir": "linux-64", + "timestamp": 1535508390005, + "version": "0.4.3.1" + }, + "msgpack-numpy-0.4.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dfb4fa0f8ddaf8188d1bf9fd97038ee5", + "name": "msgpack-numpy", + "sha256": "a26a016a8d56f28642fddeb6a78abf7550e226a53ecf22bfc12b326eaf41f343", + "size": 13988, + "subdir": "linux-64", + "timestamp": 1538360733663, + "version": "0.4.3.2" + }, + "msgpack-numpy-0.4.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "143e182fc578fa76c680ddc74a5b243c", + "name": "msgpack-numpy", + "sha256": "2086e9d3999c2a746b6f49c63cc19b088388e24648564751b9eb83b6577d9d6d", + "size": 14512, + "subdir": "linux-64", + "timestamp": 1538360751241, + "version": "0.4.3.2" + }, + "msgpack-numpy-0.4.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "def167c2179d5faae868a57cc44954fd", + "name": "msgpack-numpy", + "sha256": "4dc5982c056b717adde519f357e2b33ba0f405fa712ba134bdcc6b0b17abf0aa", + "size": 14493, + "subdir": "linux-64", + "timestamp": 1538360674987, + "version": "0.4.3.2" + }, + "msgpack-numpy-0.4.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "numpy >=1.9.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e26b81a553a3e4df25ff0062bdaf72b4", + "name": "msgpack-numpy", + "sha256": "269620d7a82ca87011551c203cbdb02b62702dd7d5f27b89fd60a43470000f60", + "size": 15071, + "subdir": "linux-64", + "timestamp": 1539720499137, + "version": "0.4.4.1" + }, + "msgpack-numpy-0.4.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "numpy >=1.9.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "34eaa16ca356e775eb91e02b4df3be55", + "name": "msgpack-numpy", + "sha256": "4d69191dc261ea0aa7e056b3d5e98be5ac83174f67095825df943870c629f28f", + "size": 15603, + "subdir": "linux-64", + "timestamp": 1539720510273, + "version": "0.4.4.1" + }, + "msgpack-numpy-0.4.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "numpy >=1.9.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cfbeb618ef3ddab80a1182a45c5a5012", + "name": "msgpack-numpy", + "sha256": "1c9f46baa2658d30d827fcee3fcadc43c1246ddf4e303d2f7cc281b7f4dd4118", + "size": 15609, + "subdir": "linux-64", + "timestamp": 1539720524500, + "version": "0.4.4.1" + }, + "msgpack-numpy-0.4.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "numpy >=1.9.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "58ce838c701dec60efc16c1bc97828c9", + "name": "msgpack-numpy", + "sha256": "3eb2c0a393202e4d688d3e18bc913138aeab7aaa796564f9e30cc5e3579f20fe", + "size": 15210, + "subdir": "linux-64", + "timestamp": 1542082685180, + "version": "0.4.4.2" + }, + "msgpack-numpy-0.4.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "numpy >=1.9.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2cbd11d5f5f661370f6025050f0fdaab", + "name": "msgpack-numpy", + "sha256": "f42eb72410d87d6ec8d0f3f4411861a461cec18ce624bda0eebc39141cf92cf1", + "size": 15775, + "subdir": "linux-64", + "timestamp": 1542082750326, + "version": "0.4.4.2" + }, + "msgpack-numpy-0.4.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "numpy >=1.9.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0c7374035aac00eb2af6b90020c00ca2", + "name": "msgpack-numpy", + "sha256": "40d6fe3a997c29c50501cb521d88ec408b1fae104fab19985b29d4c02518e4f8", + "size": 15728, + "subdir": "linux-64", + "timestamp": 1542082696170, + "version": "0.4.4.2" + }, + "msgpack-python-0.4.8-py27hc2fa789_0.tar.bz2": { + "build": "py27hc2fa789_0", + "build_number": 0, + "depends": [ + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "973da979b7614b0b0246c9c05dff1df8", + "name": "msgpack-python", + "sha256": "9fb3381bd122e9b7d6f8fbe54db73cbebac386ac34dc8c7815bc5baf5d2c504a", + "size": 90888, + "subdir": "linux-64", + "timestamp": 1505733156824, + "version": "0.4.8" + }, + "msgpack-python-0.4.8-py35h783f4c8_0.tar.bz2": { + "build": "py35h783f4c8_0", + "build_number": 0, + "depends": [ + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "202e05790472a1a7ba258ca8007ffc7a", + "name": "msgpack-python", + "sha256": "deda164b9d7d62b3d2662cb74a7668e999ab5975fe472f93029c63d49a24e79a", + "size": 91797, + "subdir": "linux-64", + "timestamp": 1505733176278, + "version": "0.4.8" + }, + "msgpack-python-0.4.8-py36hec4c5d1_0.tar.bz2": { + "build": "py36hec4c5d1_0", + "build_number": 0, + "depends": [ + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "51439aa809136989b27fa95383bf581c", + "name": "msgpack-python", + "sha256": "bb9e587af6bef1f1b7ef9b8b972820e5cdc8a7292a175040a89456caafff47ef", + "size": 91845, + "subdir": "linux-64", + "timestamp": 1505733195838, + "version": "0.4.8" + }, + "msgpack-python-0.5.1-py27h6bb024c_0.tar.bz2": { + "build": "py27h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "75eeff87263c9ab41a5e967798ba17d0", + "name": "msgpack-python", + "sha256": "e83e5f8c585ec5ebe55f6125787d03cfd0a3ea3faf9a7ba519071ee7eb9326a9", + "size": 98527, + "subdir": "linux-64", + "timestamp": 1515706352468, + "version": "0.5.1" + }, + "msgpack-python-0.5.1-py35h6bb024c_0.tar.bz2": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fc80efc976d9e6bc66bdc8a171a7e141", + "name": "msgpack-python", + "sha256": "6b5083c00dca77571eeb480596351e2b8e70e9fcd3509f81d3af10e40976b462", + "size": 99611, + "subdir": "linux-64", + "timestamp": 1515706443260, + "version": "0.5.1" + }, + "msgpack-python-0.5.1-py36h6bb024c_0.tar.bz2": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6614358dd16f269edb40c2f215eb48ec", + "name": "msgpack-python", + "sha256": "d9812be90c11518dfbd2a30331aa50c841afdd2fea4d67085f3c763ffce20586", + "size": 99913, + "subdir": "linux-64", + "timestamp": 1515706282349, + "version": "0.5.1" + }, + "msgpack-python-0.5.5-py27h6bb024c_0.tar.bz2": { + "build": "py27h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6a796d69b9ab75e4a23fbef294cbe75d", + "name": "msgpack-python", + "sha256": "c1f6973b389dee022d59717d7fe76ff9d9a212f7ca32c8c09552dcd6f96d5fdc", + "size": 95818, + "subdir": "linux-64", + "timestamp": 1519498251816, + "version": "0.5.5" + }, + "msgpack-python-0.5.5-py35h6bb024c_0.tar.bz2": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b52c6a1aa4d4e6cdc86bc5dee519cd5c", + "name": "msgpack-python", + "sha256": "57ac93aa21912c384ba41b06b3599790c6d0bcb5d6d6026ef8294145ed7673f6", + "size": 95679, + "subdir": "linux-64", + "timestamp": 1519498265435, + "version": "0.5.5" + }, + "msgpack-python-0.5.5-py36h6bb024c_0.tar.bz2": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f7bc43901dfdf4537526d0af083e61d2", + "name": "msgpack-python", + "sha256": "bfe929a4c0248a62648602f6d4cef12e5d4e9f5ba70f26f9ebf780b35750e7f1", + "size": 96334, + "subdir": "linux-64", + "timestamp": 1519498222940, + "version": "0.5.5" + }, + "msgpack-python-0.5.6-py27h6bb024c_0.tar.bz2": { + "build": "py27h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "64ab28adfb7793674fc451e3d3e4f1fe", + "name": "msgpack-python", + "sha256": "eda35fff6ee380ff43397734a38919278153b80dfc3d3455c2de2e1921c01dbe", + "size": 97679, + "subdir": "linux-64", + "timestamp": 1522178447056, + "version": "0.5.6" + }, + "msgpack-python-0.5.6-py27h6bb024c_1.tar.bz2": { + "build": "py27h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9ddb5d5349e76f9325eb81de20df58c1", + "name": "msgpack-python", + "sha256": "b8410b061b8ef1c3c343d5c4259a928206e5cd1473519cd84962aab2f0565c0c", + "size": 101195, + "subdir": "linux-64", + "timestamp": 1533325664443, + "version": "0.5.6" + }, + "msgpack-python-0.5.6-py35h6bb024c_0.tar.bz2": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0b95602d24b068bc4c8dd10425fe25b9", + "name": "msgpack-python", + "sha256": "44d17817483dacfeaea4b0d34302cfdedb496367f504b21e3b600295f8a8e31a", + "size": 97351, + "subdir": "linux-64", + "timestamp": 1522177916404, + "version": "0.5.6" + }, + "msgpack-python-0.5.6-py35h6bb024c_1.tar.bz2": { + "build": "py35h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c8e3b5a1dd35a60356fe9add3103e5e4", + "name": "msgpack-python", + "sha256": "81b4635682d233786e4da694e2fe89ae49efd46ed76dc429669f5556a56222ab", + "size": 100943, + "subdir": "linux-64", + "timestamp": 1533325571761, + "version": "0.5.6" + }, + "msgpack-python-0.5.6-py36h6bb024c_0.tar.bz2": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6978e417caa032b3e0093359025a6278", + "name": "msgpack-python", + "sha256": "1b0b870bf00c353fa464bf32f971a7dd6351f018b4661edf49da395bdb0e245b", + "size": 98211, + "subdir": "linux-64", + "timestamp": 1522178524060, + "version": "0.5.6" + }, + "msgpack-python-0.5.6-py36h6bb024c_1.tar.bz2": { + "build": "py36h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e3ed86e8ef10c9dc747936f33e7a61d9", + "name": "msgpack-python", + "sha256": "7ab7ec306a5e57c4da807a847bb2ebbadbc3cef9e14def2e77a7eb3c248ba2e9", + "size": 101795, + "subdir": "linux-64", + "timestamp": 1533325664619, + "version": "0.5.6" + }, + "msgpack-python-0.5.6-py37h6bb024c_0.tar.bz2": { + "build": "py37h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "afa8fd00affcd144e7196fd1da170c21", + "name": "msgpack-python", + "sha256": "6e8fd05c34d9cfa68b21743169657988132b0aa6718c881d733fe4ac2d6fadc0", + "size": 99018, + "subdir": "linux-64", + "timestamp": 1530741173147, + "version": "0.5.6" + }, + "msgpack-python-0.5.6-py37h6bb024c_1.tar.bz2": { + "build": "py37h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3b6dd62a61de900fae88a53b17bb4cea", + "name": "msgpack-python", + "sha256": "42666aae5ad0400b58382f2a48287198ba864b3281dea438eaf0329de00a4306", + "size": 101535, + "subdir": "linux-64", + "timestamp": 1533325681691, + "version": "0.5.6" + }, + "msgpack-python-0.6.1-py27hfd86e86_1.tar.bz2": { + "build": "py27hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5ed14b46cf367b3510f2636f1efd176a", + "name": "msgpack-python", + "sha256": "e29e63b6b65e4e53f27fc2f10d5d43f66662a8c726250b3dc309fe8a5f89a9d8", + "size": 91976, + "subdir": "linux-64", + "timestamp": 1548949633866, + "version": "0.6.1" + }, + "msgpack-python-0.6.1-py36hfd86e86_1.tar.bz2": { + "build": "py36hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9ee59bc721efb13c05d0bd80bc4667ac", + "name": "msgpack-python", + "sha256": "c2bfd11704367f2d517dd25dccc484afef5dee99c2bd9b1d2348cd0e10d1aa1c", + "size": 94719, + "subdir": "linux-64", + "timestamp": 1548949677204, + "version": "0.6.1" + }, + "msgpack-python-0.6.1-py37hfd86e86_1.tar.bz2": { + "build": "py37hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "26d74c3401372326cf1f96a336f08a95", + "name": "msgpack-python", + "sha256": "10bb4272a0768716f60b34271cdf84ee4c8d3d15b171962c2cec47da58f9c734", + "size": 94308, + "subdir": "linux-64", + "timestamp": 1548949651835, + "version": "0.6.1" + }, + "msgpack-python-0.6.1-py38hfd86e86_1.tar.bz2": { + "build": "py38hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3f621cfb228bbc29ddf23b475a741689", + "name": "msgpack-python", + "sha256": "7f8e02ae61df8c32c660f9775844730d20b5f80593d1cef4983a69df322b03c3", + "size": 94996, + "subdir": "linux-64", + "timestamp": 1573120517751, + "version": "0.6.1" + }, + "msgpack-python-1.0.0-py36hfd86e86_1.tar.bz2": { + "build": "py36hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f713ea1ceca9fc656e00cb145a0f8dc6", + "name": "msgpack-python", + "sha256": "08bf8015cfffd8b706f016acbdaeaf58aaf562cb631f1018651be762b0bcaca1", + "size": 97818, + "subdir": "linux-64", + "timestamp": 1585078612416, + "version": "1.0.0" + }, + "msgpack-python-1.0.0-py37hfd86e86_1.tar.bz2": { + "build": "py37hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1deec9b6a2d77d92a812c35880870457", + "name": "msgpack-python", + "sha256": "0808634a3bd8edda36c7d3ee6ebab5fb7f1f99133bc952ec4d880d8e1e600097", + "size": 97705, + "subdir": "linux-64", + "timestamp": 1585078609625, + "version": "1.0.0" + }, + "msgpack-python-1.0.0-py38hfd86e86_1.tar.bz2": { + "build": "py38hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3f2e375f3337eb966013cdef210a171a", + "name": "msgpack-python", + "sha256": "1535997830b273c9c21eb9023e19fac08041397097c62486970a6557f5ec8464", + "size": 100253, + "subdir": "linux-64", + "timestamp": 1585078610812, + "version": "1.0.0" + }, + "msgpack-python-1.0.0-py39h7739ffd_1.tar.bz2": { + "build": "py39h7739ffd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "07c91610456ce0fa754ceaae6654a8c2", + "name": "msgpack-python", + "sha256": "5cd7e74d40e514511c79fa14ed43f96cc3248dcf42af51327b96e452364dfef4", + "size": 100076, + "subdir": "linux-64", + "timestamp": 1607574252633, + "version": "1.0.0" + }, + "msgpack-python-1.0.1-py36hff7bd54_0.tar.bz2": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5d4d3ec6d7aeeb402f6e4dd37a32069a", + "name": "msgpack-python", + "sha256": "e81f26c4ea613cb39ec70b91136f5d653a0ef02ea83bad3348bb055d9332698d", + "size": 88274, + "subdir": "linux-64", + "timestamp": 1607965601297, + "version": "1.0.1" + }, + "msgpack-python-1.0.1-py37hff7bd54_0.tar.bz2": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aa6079b2ba97b1eb86183d09548ea1ab", + "name": "msgpack-python", + "sha256": "414f9cbf777c0a9ba419c2498f9fe828e5eb202660e2fed78b7a9682ed1cf622", + "size": 88188, + "subdir": "linux-64", + "timestamp": 1607965861255, + "version": "1.0.1" + }, + "msgpack-python-1.0.1-py38hff7bd54_0.tar.bz2": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "346b03a4e5f619baae6ee4ecb5e3c9d7", + "name": "msgpack-python", + "sha256": "a326dbdcb5fa150eafe21255ab9b6f1eae1b0ebd0e0008960469a280f6add87f", + "size": 90138, + "subdir": "linux-64", + "timestamp": 1607965869446, + "version": "1.0.1" + }, + "msgpack-python-1.0.1-py39hff7bd54_0.tar.bz2": { + "build": "py39hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "72593fe8454f57f39fb0f4105e088fa5", + "name": "msgpack-python", + "sha256": "52f2d9f6ae39b45f4bb7a437cb155e7909921475f5f42405e70ecad10500d179", + "size": 90060, + "subdir": "linux-64", + "timestamp": 1607965873378, + "version": "1.0.1" + }, + "msgpack-python-1.0.2-py310hd09550d_1.tar.bz2": { + "build": "py310hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "822df99ab90a9ebc67d4d550a9543503", + "name": "msgpack-python", + "sha256": "35748c46b0d96faac7c52889822690021d1d48039f8e5efa74749d88d718f1f7", + "size": 261911, + "subdir": "linux-64", + "timestamp": 1640884278832, + "version": "1.0.2" + }, + "msgpack-python-1.0.2-py36hff7bd54_1.tar.bz2": { + "build": "py36hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1a657c7686eae3c97f7a694667c2126e", + "name": "msgpack-python", + "sha256": "d8d2d73cc8f22cac667e72fcfdbc8ce21e112e0d8cabcbeeea9700e25ec3000c", + "size": 88215, + "subdir": "linux-64", + "timestamp": 1612287225411, + "version": "1.0.2" + }, + "msgpack-python-1.0.2-py37hff7bd54_1.tar.bz2": { + "build": "py37hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "38319b484331389d76ebf85939d5a09e", + "name": "msgpack-python", + "sha256": "cd717c62a49d7cfacdc7af53c0851b9f5f25b8295c879855a186a564da978d92", + "size": 88075, + "subdir": "linux-64", + "timestamp": 1612287221395, + "version": "1.0.2" + }, + "msgpack-python-1.0.2-py38hff7bd54_1.tar.bz2": { + "build": "py38hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9ed763a494805755db569d62f9e941f4", + "name": "msgpack-python", + "sha256": "c7a80aa304236d4857fbc82d376baa0b794534ae6275c5e5e2a159ce9500d7c6", + "size": 90090, + "subdir": "linux-64", + "timestamp": 1612287200369, + "version": "1.0.2" + }, + "msgpack-python-1.0.2-py39hff7bd54_1.tar.bz2": { + "build": "py39hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ee72480d9ca4295ade12528993f5db8f", + "name": "msgpack-python", + "sha256": "b563bcc0bb5a57e594bcce9dfd4375734246b08c9c6d1e6ece88a6969119aae7", + "size": 89995, + "subdir": "linux-64", + "timestamp": 1612287214639, + "version": "1.0.2" + }, + "msgpack-python-1.0.3-py310hd09550d_0.tar.bz2": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e1a2611549a26e06e7f7f06ab22bf053", + "name": "msgpack-python", + "sha256": "406cc2249facfd03da39731092ce33f1e6cbebf0391a75a04628626183a45f45", + "size": 262416, + "subdir": "linux-64", + "timestamp": 1652362755770, + "version": "1.0.3" + }, + "msgpack-python-1.0.3-py311hdb19cb5_0.tar.bz2": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "17145d1745996667614b52d2b27a1403", + "name": "msgpack-python", + "sha256": "ee4db7daf8d5e41a547e7790dd62aa98e203f4f857cf6018b850e7df8e613a3c", + "size": 37588, + "subdir": "linux-64", + "timestamp": 1676823053826, + "version": "1.0.3" + }, + "msgpack-python-1.0.3-py37hd09550d_0.tar.bz2": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "18a9cca9c087f8fd9e892267ead2b2f3", + "name": "msgpack-python", + "sha256": "c7fe880c202c1153242907417fe5451ecd25e3a5f0d226cc125a8df7abef1e04", + "size": 88014, + "subdir": "linux-64", + "timestamp": 1652362711863, + "version": "1.0.3" + }, + "msgpack-python-1.0.3-py38hd09550d_0.tar.bz2": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "17c600586128f5f226b9a5cda765f302", + "name": "msgpack-python", + "sha256": "0908b112893c3a7a563010e020c810d6aab61a0132ac6ef5ea3ba2e59541da6c", + "size": 90061, + "subdir": "linux-64", + "timestamp": 1652362785051, + "version": "1.0.3" + }, + "msgpack-python-1.0.3-py39hd09550d_0.tar.bz2": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5b2574b896f022cf33ed9a871aacabb3", + "name": "msgpack-python", + "sha256": "a138d682379358886f9d8c1e81da8d126c5cb1f0eff50e236ed471ea5b0b9d24", + "size": 90177, + "subdir": "linux-64", + "timestamp": 1652362815706, + "version": "1.0.3" + }, + "msitools-0.100-h81b3da8_0.tar.bz2": { + "build": "h81b3da8_0", + "build_number": 0, + "depends": [ + "gcab >=1.4,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "libgsf >=1.14,<1.15", + "libgsf >=1.14.50,<1.15.0a0", + "libuuid >=1.41.5,<2.0a0", + "libxml2 >=2.9.14,<2.10.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "8847e21399f5ca2679110d2f866e4ef3", + "name": "msitools", + "sha256": "3fffc3aafe6c914643ac6e8a06865ca93256355dd6c27627f0b288307e4224d4", + "size": 862836, + "subdir": "linux-64", + "timestamp": 1668170030034, + "version": "0.100" + }, + "msitools-0.100-hb6d4d65_1.tar.bz2": { + "build": "hb6d4d65_1", + "build_number": 1, + "depends": [ + "gcab >=1.4,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "libgsf >=1.14,<1.15", + "libgsf >=1.14.50,<1.15.0a0", + "libuuid >=1.41.5,<2.0a0", + "libxml2 >=2.10.3,<2.11.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "36f912c1306e4b5deba545f585285f16", + "name": "msitools", + "sha256": "9a64f62b46e34b47fce33179ca2bcb06988c00d0abb4c8f908f26c4eb3f2a8d9", + "size": 841595, + "subdir": "linux-64", + "timestamp": 1680018604515, + "version": "0.100" + }, + "msvc-headers-libs-14.15.26706-hc402f9b_0.tar.bz2": { + "build": "hc402f9b_0", + "build_number": 0, + "depends": [ + "curl", + "unzip" + ], + "license": "LicenseRef-MSVC_HEADERS", + "license_family": "Proprietary", + "md5": "79ee2f344a695797f81746084a77e496", + "name": "msvc-headers-libs", + "sha256": "6c3bfbc33c6fa70677c7b6c030c47a657ef867f3de0f0c3600781da0bb880a9c", + "size": 23918, + "subdir": "linux-64", + "timestamp": 1668352693102, + "version": "14.15.26706" + }, + "mtq-0.7.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pymongo >=2.8", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pytz >=2013b" + ], + "license": "BSD", + "md5": "afffd34d4304390792214c10e0d9dee6", + "name": "mtq", + "sha256": "8f49a5f192f038578b3a775c7a5ea2135bddba1dac42266cb44680b681ba7b38", + "size": 51815, + "subdir": "linux-64", + "timestamp": 1530900491675, + "version": "0.7.1" + }, + "mtq-0.7.1-py27h6c7fcc8_0.tar.bz2": { + "build": "py27h6c7fcc8_0", + "build_number": 0, + "depends": [ + "pymongo >=2.8", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pytz >=2013b" + ], + "license": "BSD", + "md5": "a2be03b9bccd8a8abffe86a9d4cbca13", + "name": "mtq", + "sha256": "b8085e3000ab0e4b4c6e9deb0fcbf9d6eb7a9814a661403725664227d17104fb", + "size": 52056, + "subdir": "linux-64", + "timestamp": 1509085459929, + "version": "0.7.1" + }, + "multidict-3.2.0-py35h7df3ad6_0.tar.bz2": { + "build": "py35h7df3ad6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "309e53ece2b015bc9b6c980fae36e56f", + "name": "multidict", + "sha256": "8995fd1c848f054c5d963df0226552e7f1a4844859c343be4fd8233335c05105", + "size": 176863, + "subdir": "linux-64", + "timestamp": 1508004881941, + "version": "3.2.0" + }, + "multidict-3.2.0-py36h97a4c74_0.tar.bz2": { + "build": "py36h97a4c74_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3169315261fc4e465f1d572749f0eeb9", + "name": "multidict", + "sha256": "b54e0842220df62e59e54668b5e96e9883602aa13b75cc110440dd584ce9a187", + "size": 177951, + "subdir": "linux-64", + "timestamp": 1508004883674, + "version": "3.2.0" + }, + "multidict-3.3.2-py35he92878e_0.tar.bz2": { + "build": "py35he92878e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fb70db14ecec3e85af155d144be2b36e", + "name": "multidict", + "sha256": "5e1ae09ce4ae05d8949bc4613cce53727a01969684afe74e5265f8485a902ab8", + "size": 187256, + "subdir": "linux-64", + "timestamp": 1511809723915, + "version": "3.3.2" + }, + "multidict-3.3.2-py36h2e68417_0.tar.bz2": { + "build": "py36h2e68417_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8e4420475419cb666fb4b4c34c538aca", + "name": "multidict", + "sha256": "4882d0cc38de9fc0798d115c209a16e8eca0e63b1d875272d29fc85f99924986", + "size": 188842, + "subdir": "linux-64", + "timestamp": 1511809729386, + "version": "3.3.2" + }, + "multidict-4.1.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "58ad1c5a2bbb173c95e8b427e493887b", + "name": "multidict", + "sha256": "18acc32da13f1a5e2c24c3cb3cda9fef96db5ba5e9f6949b277f2416b3831582", + "size": 195448, + "subdir": "linux-64", + "timestamp": 1519066407463, + "version": "4.1.0" + }, + "multidict-4.1.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e3da7d020e4dc4b74201d5160b907469", + "name": "multidict", + "sha256": "7638bfdcf20b3a12d4d91c9abd73bf68a6c8e4f4321e0acdd4f17b32055c1293", + "size": 196873, + "subdir": "linux-64", + "timestamp": 1519066412763, + "version": "4.1.0" + }, + "multidict-4.2.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "79c2e9d5bbada342795c4e8d8883098f", + "name": "multidict", + "sha256": "4a6810bb9dcd4098f2d4e32b3e6e82dc4e375d79b3f16e6823956dd6c30651fa", + "size": 196174, + "subdir": "linux-64", + "timestamp": 1524002303268, + "version": "4.2.0" + }, + "multidict-4.2.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "920b1d0c8f3f0946583899a407cdc5ae", + "name": "multidict", + "sha256": "b7b3a9830817efcc81f08b44824c1b5bb51ba0fb1cc677d530bbcec9abd44c49", + "size": 197434, + "subdir": "linux-64", + "timestamp": 1524002670050, + "version": "4.2.0" + }, + "multidict-4.3.1-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "532a1bc344515b107d714e49e553e177", + "name": "multidict", + "sha256": "e0e0b5b98d1c9e8f6cd5760c63e103418640d06f7f1b5ec044b64844000df86c", + "size": 195839, + "subdir": "linux-64", + "timestamp": 1526921459443, + "version": "4.3.1" + }, + "multidict-4.3.1-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d830ca4a6078bd6813f6c02323ae86a0", + "name": "multidict", + "sha256": "d5eef43bcbf2483f33c6fe3aa9ee2d2f4226f885e2fa082449f1ec5e9b2d4dcc", + "size": 197023, + "subdir": "linux-64", + "timestamp": 1526921700513, + "version": "4.3.1" + }, + "multidict-4.3.1-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "41b116c0c08eeab150b841745f1a222d", + "name": "multidict", + "sha256": "7d7d80ff7d567099508a2428b5fca710243767cd3c77145e7bbdbf68300d55d6", + "size": 197035, + "subdir": "linux-64", + "timestamp": 1530736482353, + "version": "4.3.1" + }, + "multidict-4.4.0-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2a0c8d4fbc664f9273d27b9bdee7f13d", + "name": "multidict", + "sha256": "c985f5294e638116ca78f1cbe5e185a86e9444edc26275334185e71815626912", + "size": 171977, + "subdir": "linux-64", + "timestamp": 1536103771805, + "version": "4.4.0" + }, + "multidict-4.4.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0c1c06da99091aeae497a7b2573a250b", + "name": "multidict", + "sha256": "31c3f9790ca0506daf4ef8e3533c884a80db00f246fc418f67ad061028c53d76", + "size": 172938, + "subdir": "linux-64", + "timestamp": 1536103715783, + "version": "4.4.0" + }, + "multidict-4.4.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e79f15944fe60d62ce86c30a55819a66", + "name": "multidict", + "sha256": "96efb54891b985ee08e39c5cd02126fb5213c6436e681ff7551fcf703502eeb5", + "size": 172888, + "subdir": "linux-64", + "timestamp": 1536103745626, + "version": "4.4.0" + }, + "multidict-4.4.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4bdddfaf20c78161ac14b43d7edd2b49", + "name": "multidict", + "sha256": "6c9ea35b0fdf5a8b36590d23d6d25f310e2168d19d9097b0518ba9818667d40c", + "size": 171505, + "subdir": "linux-64", + "timestamp": 1539643876712, + "version": "4.4.2" + }, + "multidict-4.4.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "aaf56c9f8a2d119281df1870c11e98d9", + "name": "multidict", + "sha256": "d8de3a01d6dc3a1353ffe48dc7959adcd1e35d3b9c03d1604facb10fd5ebe84f", + "size": 171057, + "subdir": "linux-64", + "timestamp": 1539643878330, + "version": "4.4.2" + }, + "multidict-4.5.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fc4829a4acab28048ed43e5b4bab67a7", + "name": "multidict", + "sha256": "2320caccbaf23e2cb4121385499d58624b2d070f9efdae22d50a1e5b72eaa005", + "size": 145090, + "subdir": "linux-64", + "timestamp": 1543598432854, + "version": "4.5.2" + }, + "multidict-4.5.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0c9461d293b8f72330d94fb210c6b747", + "name": "multidict", + "sha256": "afbb768ab01f7c04ca13517b7c424a25586ebfa24133ca2ae6b8fdbfa0059768", + "size": 144738, + "subdir": "linux-64", + "timestamp": 1543598392698, + "version": "4.5.2" + }, + "multidict-4.5.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2ecbbbba1b263c72c10f35e330582633", + "name": "multidict", + "sha256": "e85a2549896717afb4c34f80ecf05903ddcf93f0b2a924a7bd9580e5b2f8e60f", + "size": 146029, + "subdir": "linux-64", + "timestamp": 1573120597392, + "version": "4.5.2" + }, + "multidict-4.7.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "46a678fc50c7107250f365dfce3e8765", + "name": "multidict", + "sha256": "fa184c1690d3f8892864b9558349cb3ab88f5c2bf41ddd0e8ef10a6195429ca7", + "size": 73367, + "subdir": "linux-64", + "timestamp": 1579790758065, + "version": "4.7.3" + }, + "multidict-4.7.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "51865c84d716d1108345e7c3404a9101", + "name": "multidict", + "sha256": "fd5aff83fa7299da9328e779b9ef754369d23cfa4dcb27e408cc839821ec94e1", + "size": 73352, + "subdir": "linux-64", + "timestamp": 1579790739880, + "version": "4.7.3" + }, + "multidict-4.7.3-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e67e01fe28236615cddd98992498d625", + "name": "multidict", + "sha256": "06109549bdc1f66f326a99a1099ad40920e00bdf64c728d51fe85c1cfb36c94b", + "size": 75395, + "subdir": "linux-64", + "timestamp": 1579790754522, + "version": "4.7.3" + }, + "multidict-4.7.5-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d952545944c7a00cdb443337bd40fa18", + "name": "multidict", + "sha256": "d3330e27741ac8430f093532239ba14a9fca4537d75e0d79afa76bef5c5254e3", + "size": 70994, + "subdir": "linux-64", + "timestamp": 1600445107276, + "version": "4.7.5" + }, + "multidict-4.7.5-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "659fff3b97d01f03d69d5b1dda5f4fd9", + "name": "multidict", + "sha256": "c97e1dc429b87932c008cfd7abc7317e8220097cb67ae5b80d69677c68b16fdf", + "size": 71067, + "subdir": "linux-64", + "timestamp": 1600445117264, + "version": "4.7.5" + }, + "multidict-4.7.5-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "05570d8c5947c360a025eda6fc1d32be", + "name": "multidict", + "sha256": "7eb41752fbf94bb343ee3312c9f496c074214e9c1b44419154c7cc35f320c409", + "size": 73278, + "subdir": "linux-64", + "timestamp": 1600445083986, + "version": "4.7.5" + }, + "multidict-4.7.6-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "79c65caa7ad18322498a71eadb611962", + "name": "multidict", + "sha256": "d782849a30c4ccd38a45156883d8c2f09f7f5abcd357e1a23edfa97084ae7a3b", + "size": 71032, + "subdir": "linux-64", + "timestamp": 1600456438434, + "version": "4.7.6" + }, + "multidict-4.7.6-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1ecf3d9c2243b89d2d6d5f4d7ab50463", + "name": "multidict", + "sha256": "edfe9d2f95ab16c15736adb1e71ce298f67ae0e7f52b3385a31428a8db90c7d0", + "size": 71025, + "subdir": "linux-64", + "timestamp": 1600456437105, + "version": "4.7.6" + }, + "multidict-4.7.6-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a74a0a2042330b45b7936021b511d986", + "name": "multidict", + "sha256": "fdfdd4d6a28dcb997341623c139e1b3a9c1853930ce4a2ed97ed5aba93145cf5", + "size": 73292, + "subdir": "linux-64", + "timestamp": 1600456441080, + "version": "4.7.6" + }, + "multidict-5.0.0-py36h27cfd23_2.tar.bz2": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9bd3f593b1f3663321aef5509b66b7d5", + "name": "multidict", + "sha256": "7752811aad2955ed3030ed0c615d0c88e2308d5e70f7dcb7158a5f8591cbd76f", + "size": 71105, + "subdir": "linux-64", + "timestamp": 1605111832932, + "version": "5.0.0" + }, + "multidict-5.0.0-py37h27cfd23_2.tar.bz2": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8cf3ef60a14f011db841994a993cffbb", + "name": "multidict", + "sha256": "babbc78102a9f9a2ac0399d3f1416c7ccb8d63c030b2b97b9075357f1b702294", + "size": 71147, + "subdir": "linux-64", + "timestamp": 1605111868246, + "version": "5.0.0" + }, + "multidict-5.0.0-py38h27cfd23_2.tar.bz2": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "20e3caa9c4c48761f9de8c79ecbc455b", + "name": "multidict", + "sha256": "167763eabd9d7db5af0605937fbaa98c69e83a68aa027c1c934f021d1bd02079", + "size": 73369, + "subdir": "linux-64", + "timestamp": 1605111893486, + "version": "5.0.0" + }, + "multidict-5.0.2-py36h27cfd23_2.tar.bz2": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3c7862aa9eea56af4602fe0a500d24d6", + "name": "multidict", + "sha256": "92e88f07fe80bf759b53c17660867dd508dfded6f6db93f51be21e792925d8dd", + "size": 71135, + "subdir": "linux-64", + "timestamp": 1606153631299, + "version": "5.0.2" + }, + "multidict-5.0.2-py37h27cfd23_2.tar.bz2": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "30b7bc857242686a2032e3b2070326dd", + "name": "multidict", + "sha256": "88c5634b3fd540ee4e91c7c1925416e47b950e8d2ff8862ee2ba923174512713", + "size": 71103, + "subdir": "linux-64", + "timestamp": 1606153666172, + "version": "5.0.2" + }, + "multidict-5.0.2-py38h27cfd23_2.tar.bz2": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e92a9bf276ceaf2b16d1e3cebc0a4611", + "name": "multidict", + "sha256": "f1c105fd188c6d9cd5fa37d74fc7a292d7fd172302b783dbbbf4e31ad7876a2e", + "size": 73360, + "subdir": "linux-64", + "timestamp": 1606153651519, + "version": "5.0.2" + }, + "multidict-5.0.2-py39h27cfd23_2.tar.bz2": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f5aaff5fb02ab7cf146aef7a9beab180", + "name": "multidict", + "sha256": "32fe01f4ae1a83c37ca26b4e766e8801284586737b639370b61bc4ee1dff99dd", + "size": 73266, + "subdir": "linux-64", + "timestamp": 1606153634383, + "version": "5.0.2" + }, + "multidict-5.1.0-py310h7f8727e_2.tar.bz2": { + "build": "py310h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "838fd52e80cc64deb689d877597b37d3", + "name": "multidict", + "sha256": "893a46a5c453605b519be322ac0966b7209607ccd9b0c95944823d77f5bbf9c0", + "size": 174655, + "subdir": "linux-64", + "timestamp": 1640791755611, + "version": "5.1.0" + }, + "multidict-5.1.0-py36h27cfd23_2.tar.bz2": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "37362c30ec0d87427eea848426caea35", + "name": "multidict", + "sha256": "2d7020965e4bcc061a9b25f1e3f87295c089ae1479d985912fc8d38bb89ef510", + "size": 71423, + "subdir": "linux-64", + "timestamp": 1607367811823, + "version": "5.1.0" + }, + "multidict-5.1.0-py37h27cfd23_2.tar.bz2": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ec4da04ed45cfb8ca289593941430e42", + "name": "multidict", + "sha256": "0b36cd7e9382a82be3dd98b1cdcbbcd25ef8cf4eb51ab06a6c04f4293b7ef080", + "size": 71437, + "subdir": "linux-64", + "timestamp": 1607367825144, + "version": "5.1.0" + }, + "multidict-5.1.0-py38h27cfd23_2.tar.bz2": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e709858df7b4242ad2f15f3a2be3647a", + "name": "multidict", + "sha256": "74e2483f86d09c71a006bd5911b94d362a84dbab8b29a94bd1fc5cbdf5c86386", + "size": 73593, + "subdir": "linux-64", + "timestamp": 1607367800165, + "version": "5.1.0" + }, + "multidict-5.1.0-py39h27cfd23_2.tar.bz2": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d32507508d0f16e475121c8fe228c07f", + "name": "multidict", + "sha256": "c6fb59d6051823cb9c615dab922e8a69f535db91bba5d5949bb314820c99d75e", + "size": 73650, + "subdir": "linux-64", + "timestamp": 1607367819794, + "version": "5.1.0" + }, + "multidict-5.2.0-py310h5eee18b_3.tar.bz2": { + "build": "py310h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8e952672c2f9ce585ea10f1b04a2ee7a", + "name": "multidict", + "sha256": "3f17c2dbb62119c0e8e229412485b2031541bcacd71af137158ecd4c3bd8b35c", + "size": 140670, + "subdir": "linux-64", + "timestamp": 1662369413566, + "version": "5.2.0" + }, + "multidict-5.2.0-py37h5eee18b_3.tar.bz2": { + "build": "py37h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2678408dbf01213899c629de2c8d40ad", + "name": "multidict", + "sha256": "19fd1eb533be640f9d5c5671f1c24d6efdc6cfdd1d9c6ca09320567c2292588e", + "size": 61431, + "subdir": "linux-64", + "timestamp": 1662369482239, + "version": "5.2.0" + }, + "multidict-5.2.0-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "59ea5c76192bc465f736a325d1fd79e8", + "name": "multidict", + "sha256": "fcf0198792b11e87fad685ad1b4dd149f5be3703558d41c11fd7c6cd87c5fa3a", + "size": 66654, + "subdir": "linux-64", + "timestamp": 1640703823096, + "version": "5.2.0" + }, + "multidict-5.2.0-py37h7f8727e_2.tar.bz2": { + "build": "py37h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9509abbfcd8e7fcb048cb314373de1ed", + "name": "multidict", + "sha256": "98d7fb6212a100a40b8752f5fb0f308e33a0c5bfa0a1a732d71f647770c77da0", + "size": 66639, + "subdir": "linux-64", + "timestamp": 1640703795978, + "version": "5.2.0" + }, + "multidict-5.2.0-py38h5eee18b_3.tar.bz2": { + "build": "py38h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "de00c1c80513213aafa9ee0425995bc8", + "name": "multidict", + "sha256": "1eeb8f71c6b80f280ba818001ffed2f51c53f2451f5d2134e745d1fda047408d", + "size": 63644, + "subdir": "linux-64", + "timestamp": 1662369447628, + "version": "5.2.0" + }, + "multidict-5.2.0-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5ec96c5c9ada01d119b06f27ee75d859", + "name": "multidict", + "sha256": "8e41a27abe6ed3cc9c69d742ddfceb8465d9b33beebbde8162cf836fe6f0b00b", + "size": 68891, + "subdir": "linux-64", + "timestamp": 1640703795029, + "version": "5.2.0" + }, + "multidict-5.2.0-py38h7f8727e_2.tar.bz2": { + "build": "py38h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "884467db6a1b9753e665882dcb487474", + "name": "multidict", + "sha256": "9c0db2ab18e76367af1cb73199a1608029a83fea9af5293e3a24c8480d96b0cd", + "size": 68824, + "subdir": "linux-64", + "timestamp": 1640703854037, + "version": "5.2.0" + }, + "multidict-5.2.0-py39h5eee18b_3.tar.bz2": { + "build": "py39h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5c43ab3f8e4c8e940c731ecca3ed15b6", + "name": "multidict", + "sha256": "0e5a912a33a75e09b702d78497541456e16c05d0b72999888ba6ce8f30020f39", + "size": 63271, + "subdir": "linux-64", + "timestamp": 1662369517547, + "version": "5.2.0" + }, + "multidict-5.2.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cbb67f19b523d2ba01664ebffc2e1880", + "name": "multidict", + "sha256": "b5d7926ad5aff51f0883788161dc52f37c334e563c0517337749f869e13f63cf", + "size": 68776, + "subdir": "linux-64", + "timestamp": 1640703854081, + "version": "5.2.0" + }, + "multidict-5.2.0-py39h7f8727e_2.tar.bz2": { + "build": "py39h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1f0bbc81539a2b4d4a8292b637a8a23b", + "name": "multidict", + "sha256": "31de21e1b97af88218aa78dff7844e2339a6b36acb75f6eb64d36378b23986fe", + "size": 68772, + "subdir": "linux-64", + "timestamp": 1640703827445, + "version": "5.2.0" + }, + "multidict-6.0.2-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d5640dcf4abafaffc5ec343baa3a58b6", + "name": "multidict", + "sha256": "257192e1d07b3ff2c22f1049df155b3bdb74f6c04a5e33a1a96d8554fc190f3b", + "size": 52493, + "subdir": "linux-64", + "timestamp": 1665674276559, + "version": "6.0.2" + }, + "multidict-6.0.2-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5b44f65070512e26db4d7bfea4070d85", + "name": "multidict", + "sha256": "3c56fa81cd63fe1fd45a7cd7deafc70ad76b10ac2c4e53d1246a74d510bf2982", + "size": 58115, + "subdir": "linux-64", + "timestamp": 1676825331682, + "version": "6.0.2" + }, + "multidict-6.0.2-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f3cf45ba7aa90018a981d021fb0c395d", + "name": "multidict", + "sha256": "91f5d7cedd65f59ee79c9f9e627f33ecf119ee17c014dfd69b44c458c2cfa3cf", + "size": 49934, + "subdir": "linux-64", + "timestamp": 1665674372233, + "version": "6.0.2" + }, + "multidict-6.0.2-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c85d35dcb793f0755d30daab1cd2a4e3", + "name": "multidict", + "sha256": "23762cdd7953525c58c87209b4f9d4a914d128201dfc4b15d22d7627e545b850", + "size": 52653, + "subdir": "linux-64", + "timestamp": 1665674308223, + "version": "6.0.2" + }, + "multidict-6.0.2-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ff5a785881ed1be4202e5b15a6a7def3", + "name": "multidict", + "sha256": "fbec08bcb5ca464f47bbb160aae9a4fe347b23e2ec759e81d47d5a129745957f", + "size": 52420, + "subdir": "linux-64", + "timestamp": 1665674339367, + "version": "6.0.2" + }, + "multipledispatch-0.4.9-py27h9b5f95a_0.tar.bz2": { + "build": "py27h9b5f95a_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0c12dc65109bdbf0a4bd89a6ac8b6060", + "name": "multipledispatch", + "sha256": "f4b708851bce338badfe165accbed4ecb2bee8a9c3d4db9f34d527c2254bc718", + "size": 15242, + "subdir": "linux-64", + "timestamp": 1505739911465, + "version": "0.4.9" + }, + "multipledispatch-0.4.9-py35h2ff591a_0.tar.bz2": { + "build": "py35h2ff591a_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "db92047a11378410177379a9b46a1df4", + "name": "multipledispatch", + "sha256": "442c14d8b79f9a2b2da5cf4e101ef9fa31ab7a79db744159f5f2894bbff5d94c", + "size": 15787, + "subdir": "linux-64", + "timestamp": 1505739923352, + "version": "0.4.9" + }, + "multipledispatch-0.4.9-py36h41da3fb_0.tar.bz2": { + "build": "py36h41da3fb_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "07f237a2a78fc47dad5668ed99366375", + "name": "multipledispatch", + "sha256": "edd70ec9b613d0172985abdcf83572ddd804115858000fa7602d0bc31ff617ee", + "size": 15752, + "subdir": "linux-64", + "timestamp": 1505739935395, + "version": "0.4.9" + }, + "multipledispatch-0.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "32fb7ebf5a115c6af5c508559814f3e6", + "name": "multipledispatch", + "sha256": "38c728041cd4369a47a9bc5202dd4cb07cdb7c9a4fa199dc5c27f4289b942515", + "size": 17684, + "subdir": "linux-64", + "timestamp": 1520522049366, + "version": "0.5.0" + }, + "multipledispatch-0.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "29f25515f598c5132a2fdfc573465bdb", + "name": "multipledispatch", + "sha256": "f8da3815f0c807becc0a4d377741e7c99fa458a46d1b79e1fd2eb6456d931424", + "size": 18261, + "subdir": "linux-64", + "timestamp": 1520522077556, + "version": "0.5.0" + }, + "multipledispatch-0.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fa8db1169ed81cfe770ed3efa2e0295d", + "name": "multipledispatch", + "sha256": "1118ef5d68305c01bca1275a873f722ef7277734aae343ff2ef53ca4d8c27242", + "size": 18162, + "subdir": "linux-64", + "timestamp": 1520522091066, + "version": "0.5.0" + }, + "multipledispatch-0.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "db70a468c5704c8dd1e161bb2971b3ec", + "name": "multipledispatch", + "sha256": "edfb0dfd9e1e6ed725f49b68cd49af9173dc9ace8db12af125e03452fef19090", + "size": 18011, + "subdir": "linux-64", + "timestamp": 1530771825486, + "version": "0.5.0" + }, + "multipledispatch-0.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e612a8f01413a53ee1ed877f361a7782", + "name": "multipledispatch", + "sha256": "f02505580171abdf2b3339d5aaff388232f9a798847f0400631c9a4ad5ca63b4", + "size": 21147, + "subdir": "linux-64", + "timestamp": 1534268875962, + "version": "0.6.0" + }, + "multipledispatch-0.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "259ff8ec9380cab85ccba95648beaf7a", + "name": "multipledispatch", + "sha256": "0b66e4e823b300fc65219865738ca3e7b44938f69aab1be22a4184bb63cfb3c1", + "size": 23037, + "subdir": "linux-64", + "timestamp": 1640791773703, + "version": "0.6.0" + }, + "multipledispatch-0.6.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0b185969ac2b065c27cbcc9641d93678", + "name": "multipledispatch", + "sha256": "b558b3f6c144652b5e0d26497b3ce24c318a6b9ff8ea2079113c95e5553b3cf9", + "size": 29568, + "subdir": "linux-64", + "timestamp": 1676841232463, + "version": "0.6.0" + }, + "multipledispatch-0.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d03058f131b0bc64bfa278ccfe8905a5", + "name": "multipledispatch", + "sha256": "9a486f5067029a1f2a35ff4a2539c4a1ae058696dd47b73ac3bfbd7d3e84a58b", + "size": 21806, + "subdir": "linux-64", + "timestamp": 1534268844200, + "version": "0.6.0" + }, + "multipledispatch-0.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f31fee4798decec338f347b680df4be9", + "name": "multipledispatch", + "sha256": "06ddd6362b4ceb269e4e4c06ebbd4da0ef1d67ea0c03bccbaec2251ed80aa528", + "size": 21684, + "subdir": "linux-64", + "timestamp": 1534268835630, + "version": "0.6.0" + }, + "multipledispatch-0.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bfca04b84cc25438412a17f3843d8363", + "name": "multipledispatch", + "sha256": "a420be0da6f429f596b779a7b43d996abf62a8beec66860bfaa71eeb01c316f9", + "size": 21677, + "subdir": "linux-64", + "timestamp": 1534268887580, + "version": "0.6.0" + }, + "multipledispatch-0.6.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7ccf826b74681264ec620255a556fd97", + "name": "multipledispatch", + "sha256": "a00d1f914deb4b896a3d42d2cae73097e1f5f2f4bc371dd3ceed04118eb974b4", + "size": 22859, + "subdir": "linux-64", + "timestamp": 1573120615619, + "version": "0.6.0" + }, + "multipledispatch-0.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e0db8ae050bd0db74f47edc370dbc287", + "name": "multipledispatch", + "sha256": "305313d215116fbf13a38f8a321eb635b83294871801ac63e543a59ba7de642c", + "size": 24480, + "subdir": "linux-64", + "timestamp": 1607574279743, + "version": "0.6.0" + }, + "multiprocess-0.70.12.2-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "dill >=0.2.5", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b7010596c9a472fad5ada353e1eed353", + "name": "multiprocess", + "sha256": "37bc995b5f89e04a65887f7a7005f2965a934571476eec0d399298727e905e96", + "size": 219006, + "subdir": "linux-64", + "timestamp": 1640791798215, + "version": "0.70.12.2" + }, + "multiprocess-0.70.12.2-py36h7f8727e_0.tar.bz2": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "dill >=0.2.5", + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c98c2ea99c182d69f9a3f867e952c716", + "name": "multiprocess", + "sha256": "495506399001c9c8eb864ba4b877468e864932f9adfa757d4cf0b4437da3954d", + "size": 182658, + "subdir": "linux-64", + "timestamp": 1633079305502, + "version": "0.70.12.2" + }, + "multiprocess-0.70.12.2-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "dill >=0.2.5", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "abe0de910fb5462c4dbca2d00b9a7897", + "name": "multiprocess", + "sha256": "c6c94160c17b0a1f4a9e872de833e288f70fa53f479cdef5d1005841642d4e19", + "size": 193148, + "subdir": "linux-64", + "timestamp": 1633089808201, + "version": "0.70.12.2" + }, + "multiprocess-0.70.12.2-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "dill >=0.2.5", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b3afa70e2e7d8d6bf735eb8dab24adb9", + "name": "multiprocess", + "sha256": "65fce08109ed741139cc251ad8498ad67a27e90b29320b519a0e014e245e4536", + "size": 219245, + "subdir": "linux-64", + "timestamp": 1633089748658, + "version": "0.70.12.2" + }, + "multiprocess-0.70.12.2-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "dill >=0.2.5", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "605af50208a1152952d3f83903cc3a27", + "name": "multiprocess", + "sha256": "dcebcc4ea9069ae0b2dd2141ba6866636ea9a7778a5ce439ac6bf10fd8524d34", + "size": 221526, + "subdir": "linux-64", + "timestamp": 1633089801713, + "version": "0.70.12.2" + }, + "multiprocess-0.70.14-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.6", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d21b64e437f7857c00baad70cb8697e6", + "name": "multiprocess", + "sha256": "9e8458bd686c1c8d099964083555f9e8be47a98a71e14f120063ebb98960c6e9", + "size": 227870, + "subdir": "linux-64", + "timestamp": 1668006537468, + "version": "0.70.14" + }, + "multiprocess-0.70.14-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.6", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "160f93532b0da786e12e9ac81d7b30f3", + "name": "multiprocess", + "sha256": "c167a1dfca62da5dc598bf62d8fff21f96c198b7aa8b53b8f3bf70c3c2f5f935", + "size": 326418, + "subdir": "linux-64", + "timestamp": 1676841248457, + "version": "0.70.14" + }, + "multiprocess-0.70.14-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.6", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9cdfed4ec8b7f39fa62ca0862bd0aaa2", + "name": "multiprocess", + "sha256": "cd817b71b48d173d379dd86cbc99652f97a4ad335fa96813f98fab2f1b921584", + "size": 190192, + "subdir": "linux-64", + "timestamp": 1668006507801, + "version": "0.70.14" + }, + "multiprocess-0.70.14-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.6", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e54e514998e365997f04393a75aa8aa", + "name": "multiprocess", + "sha256": "0ffcfb316b52547532de2b84c7ff46f5d6e424036d937bdac7ca9acf92b487a6", + "size": 216506, + "subdir": "linux-64", + "timestamp": 1668006567104, + "version": "0.70.14" + }, + "multiprocess-0.70.14-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.6", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d010d8ee88f66905ee57ad7e9bfb8846", + "name": "multiprocess", + "sha256": "367cbfac24b8d6872aa71d6945a0aa5aa0545390e6470bf7184338007a6d470b", + "size": 219670, + "subdir": "linux-64", + "timestamp": 1668006476656, + "version": "0.70.14" + }, + "munch-2.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "a8462efa3f5a904f59a5811ff1123d9c", + "name": "munch", + "sha256": "195eef0e6645bbae4934863768fab0d31facb714b03ac39feda060c8038c6522", + "size": 13166, + "subdir": "linux-64", + "timestamp": 1523945995706, + "version": "2.3.1" + }, + "munch-2.3.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "632c44340f6aa21b7f9404c0c45e0ca9", + "name": "munch", + "sha256": "47eed276ca76c5fca090d92db30366f9b075736ecb3ba22461e045accf8c80d4", + "size": 13471, + "subdir": "linux-64", + "timestamp": 1523946051008, + "version": "2.3.1" + }, + "munch-2.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "c02b352cb0a31a5e991410503049b54d", + "name": "munch", + "sha256": "5450e3c4e8f497ebea74c8fd572b02023891c5ed3ea0750f5cd49210bde0e05c", + "size": 13487, + "subdir": "linux-64", + "timestamp": 1523946049887, + "version": "2.3.1" + }, + "munch-2.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "3fb2d6f51b023311a888080eb78498ff", + "name": "munch", + "sha256": "0350b10c6c48d84c48c8c3dcaf6bc4097405aff51dc6d96f2327ec93a2cf32c5", + "size": 13303, + "subdir": "linux-64", + "timestamp": 1526927419920, + "version": "2.3.2" + }, + "munch-2.3.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "140af481b72d4b510083844ba689e8dc", + "name": "munch", + "sha256": "fddadfad10af367d0170ba1570a52a673ba76a7eb31e7e8abbc9f9686848a7b0", + "size": 13618, + "subdir": "linux-64", + "timestamp": 1526927438541, + "version": "2.3.2" + }, + "munch-2.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "b168a0a0e6d961345b1bb744f73ea15e", + "name": "munch", + "sha256": "9cf7da27906d2886f113c9fda709838bdfc24e620e15232f4c7095e0679c7222", + "size": 13673, + "subdir": "linux-64", + "timestamp": 1526927399962, + "version": "2.3.2" + }, + "munch-2.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "8e06ffcaec4780b4bbdefe0097c7fc30", + "name": "munch", + "sha256": "e3a0c8ad66072a8c916f1f459f07456ce94fa071547b11624b99b83e220c71b6", + "size": 13686, + "subdir": "linux-64", + "timestamp": 1530876655123, + "version": "2.3.2" + }, + "murmurhash-0.28.0-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "620ef6354ed99b4d4288f600de9b2db7", + "name": "murmurhash", + "sha256": "03aa3459244814cc1851b38a9d9b3cd77b7f362f892119c4e06f04a375c1a238", + "size": 16268, + "subdir": "linux-64", + "timestamp": 1530900581889, + "version": "0.28.0" + }, + "murmurhash-0.28.0-py35he6710b0_0.tar.bz2": { + "build": "py35he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "40c16f1855e9538de08596a87e208a1b", + "name": "murmurhash", + "sha256": "325daca934ec9fceb59628540251302a7e7b833cce5d98a1c3556f314ae49f54", + "size": 16677, + "subdir": "linux-64", + "timestamp": 1535607608868, + "version": "0.28.0" + }, + "murmurhash-0.28.0-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "174efd48e5885a4336897a39d26c0a0f", + "name": "murmurhash", + "sha256": "837a20cd85217e00a965b597b1ce6e6c5d3f997cb7ad7737b5177a47c17c28f9", + "size": 16483, + "subdir": "linux-64", + "timestamp": 1530900552760, + "version": "0.28.0" + }, + "murmurhash-0.28.0-py37hf484d3e_0.tar.bz2": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "33bbf1a47b6a4db89adce098eae7ef8f", + "name": "murmurhash", + "sha256": "3bd249d0bde4009476959de9ff01a6ff3124d3843aeac345238b7d670f96122c", + "size": 16521, + "subdir": "linux-64", + "timestamp": 1530900522633, + "version": "0.28.0" + }, + "murmurhash-1.0.1-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7cbb4078af4da14fe522b2471ba36527", + "name": "murmurhash", + "sha256": "28aad9248fc2fafce735f59be44812dd7c95b4632e63177c9d0e4481732516b1", + "size": 17786, + "subdir": "linux-64", + "timestamp": 1539719498471, + "version": "1.0.1" + }, + "murmurhash-1.0.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "bcf890ef262a73d63f44ddd2a1d89047", + "name": "murmurhash", + "sha256": "eaa74e25552d87c0c6918cd09cd3b502de70f555daac8530aeb7e641552e240f", + "size": 18897, + "subdir": "linux-64", + "timestamp": 1539719527773, + "version": "1.0.1" + }, + "murmurhash-1.0.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "927d13a65efa3f9eebd87e7798e78bf3", + "name": "murmurhash", + "sha256": "f435b084d9f77d6a811ad4b365e00a36bcbfb1b2ddbd868aebbd03f4a0a4b91e", + "size": 18946, + "subdir": "linux-64", + "timestamp": 1539719528263, + "version": "1.0.1" + }, + "murmurhash-1.0.2-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d5aa70c5a1a77116e44374c8e8f3b9cc", + "name": "murmurhash", + "sha256": "640f615b54bc2619de782eaade3951b3d4d73300b3f328837bd700c1f0ca5e31", + "size": 26938, + "subdir": "linux-64", + "timestamp": 1552438745351, + "version": "1.0.2" + }, + "murmurhash-1.0.2-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f97fc2bf9aa106c238309dc9d6865ab0", + "name": "murmurhash", + "sha256": "b082195d9f7625200d230455e067b18f1599beaaa81dbfc19757595c81f84f4f", + "size": 28252, + "subdir": "linux-64", + "timestamp": 1552438907668, + "version": "1.0.2" + }, + "murmurhash-1.0.2-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2f69357e04718ee3e4cca8ba7149f2a3", + "name": "murmurhash", + "sha256": "71bd74411af2800d9e98f19f9a2f8c15bc18f804857a11cda7b7bbdca33d5424", + "size": 28262, + "subdir": "linux-64", + "timestamp": 1552438724399, + "version": "1.0.2" + }, + "murmurhash-1.0.2-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "9bb990c2e67f280d0760d14a247cd71e", + "name": "murmurhash", + "sha256": "9b52f400b2180ea81135ad9032d09ce1ae22743ce706d27f3b3e31a034ca0056", + "size": 27283, + "subdir": "linux-64", + "timestamp": 1573120716560, + "version": "1.0.2" + }, + "murmurhash-1.0.5-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "6d7b2181b5565a4d76dbfd8d16c63f93", + "name": "murmurhash", + "sha256": "4c6a8964b1b09d93329b1fad16d80c76d0d96a7d071baa91cd9f7d41293c2db9", + "size": 72853, + "subdir": "linux-64", + "timestamp": 1640791823622, + "version": "1.0.5" + }, + "murmurhash-1.0.5-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "33425dda9e5ecbff0ab3eb96f02ccab6", + "name": "murmurhash", + "sha256": "877a1b85e10cfa398ee098b205689430244a5d5acff506a4965d0de90f9be5ee", + "size": 26069, + "subdir": "linux-64", + "timestamp": 1607456147005, + "version": "1.0.5" + }, + "murmurhash-1.0.5-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a73ea1e11237cc0b56d2db2ab3add52b", + "name": "murmurhash", + "sha256": "1372fd303508ede3b04427ec67973c5b03a57434e35e020cb3fd5ed52fb3f2cc", + "size": 26103, + "subdir": "linux-64", + "timestamp": 1607456148438, + "version": "1.0.5" + }, + "murmurhash-1.0.5-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "c5a3246c77feecc8d79fa28cf4deeb26", + "name": "murmurhash", + "sha256": "7cc6ee404811d87f552f6a30d122b0c7a7d297198ce59fcb057b672ea717b8aa", + "size": 26181, + "subdir": "linux-64", + "timestamp": 1607456150526, + "version": "1.0.5" + }, + "murmurhash-1.0.5-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "7e4db01b7090f1104b96af4ca449d3f3", + "name": "murmurhash", + "sha256": "4215a72a516861e260ed0ae9db35a6b66874763c4c4a3fde2d9f32bc053832e7", + "size": 26229, + "subdir": "linux-64", + "timestamp": 1607456184981, + "version": "1.0.5" + }, + "murmurhash-1.0.7-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "684bcfc0c3e23b0595f3381abac41b83", + "name": "murmurhash", + "sha256": "4719d294c697774f013efb63b57b5e81ecd9da6bdebd74173a74f27dc3b255c8", + "size": 72959, + "subdir": "linux-64", + "timestamp": 1651237298315, + "version": "1.0.7" + }, + "murmurhash-1.0.7-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af57a48e27dd8cad119ea6e0ada04509", + "name": "murmurhash", + "sha256": "dcffefd58374d92275e4a800867438c05ba9f0145f8c8effc0c747c97ce9f187", + "size": 27195, + "subdir": "linux-64", + "timestamp": 1676837144249, + "version": "1.0.7" + }, + "murmurhash-1.0.7-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f5e0abfe07b1bea887497055930a0a6d", + "name": "murmurhash", + "sha256": "10309adf91cd86a6b61e30aeaaaff3963d8baea2a08ec80ded7e3dd85bfe7a27", + "size": 26017, + "subdir": "linux-64", + "timestamp": 1651237254483, + "version": "1.0.7" + }, + "murmurhash-1.0.7-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2979237ddfd6aec63947b844da051302", + "name": "murmurhash", + "sha256": "c15a94eef77de0fe6b706e7d7444add15551949e53a68b46ce42cb5a3a180764", + "size": 26142, + "subdir": "linux-64", + "timestamp": 1651237222742, + "version": "1.0.7" + }, + "murmurhash-1.0.7-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb13da43741b94ea70cf11561e3065c8", + "name": "murmurhash", + "sha256": "0299a8a3d7a92d7957bc6959847aac6d0df326feb66d29d9e173cd152c432fdd", + "size": 26184, + "subdir": "linux-64", + "timestamp": 1651237330698, + "version": "1.0.7" + }, + "mxnet-1.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "libmxnet 1.0.0 hb7fadbc_0", + "py-mxnet 1.0.0 py27hf484d3e_0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "ca652ae8f4e9e3fc3c652ab9a3aa06ab", + "name": "mxnet", + "namespace": "python", + "sha256": "bd96599538b8e273059aff18d26a5492049f74c0d1168cd9e78af4c03a996bd4", + "size": 9783, + "subdir": "linux-64", + "timestamp": 1514730796091, + "version": "1.0.0" + }, + "mxnet-1.0.0-py27_nomkl_0.tar.bz2": { + "build": "py27_nomkl_0", + "build_number": 0, + "depends": [ + "libmxnet 1.0.0 nomklh2cb3ce3_0", + "py-mxnet 1.0.0 py27_nomklhf484d3e_0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "7f807f46511b46e25e6664c502e537a5", + "name": "mxnet", + "namespace": "python", + "sha256": "2df3c42fc7a85a89eb6d55329b9607ffd20628a958d7f9d0e8c32de8387dc04a", + "size": 9792, + "subdir": "linux-64", + "timestamp": 1514731634607, + "version": "1.0.0" + }, + "mxnet-1.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "libmxnet 1.0.0 hb7fadbc_0", + "py-mxnet 1.0.0 py35hf484d3e_0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "b7338de5be3aa951b14f46f46b48439e", + "name": "mxnet", + "namespace": "python", + "sha256": "8db15871cc4bf760a83642586cc3cf3579aad84596af18a5f62101aadb58e6bb", + "size": 9787, + "subdir": "linux-64", + "timestamp": 1514730803346, + "version": "1.0.0" + }, + "mxnet-1.0.0-py35_nomkl_0.tar.bz2": { + "build": "py35_nomkl_0", + "build_number": 0, + "depends": [ + "libmxnet 1.0.0 nomklh2cb3ce3_0", + "py-mxnet 1.0.0 py35_nomklhf484d3e_0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "ac1289ef2b52154713da55ee10b8b6b3", + "name": "mxnet", + "namespace": "python", + "sha256": "af62bd7d93e23d74aa4fa65e3b62a95e2b4a13633d699719cfaa4bf5b8a4708b", + "size": 9818, + "subdir": "linux-64", + "timestamp": 1514731641125, + "version": "1.0.0" + }, + "mxnet-1.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libmxnet 1.0.0 hb7fadbc_0", + "py-mxnet 1.0.0 py36hf484d3e_0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "d73958b9b1eea3b2cdc0af5537ebe59c", + "name": "mxnet", + "namespace": "python", + "sha256": "0f5148dba1f8c1d68a6764ceb4345611fd74750c01b1ec07f25e37197b1cb7e6", + "size": 9770, + "subdir": "linux-64", + "timestamp": 1514730810623, + "version": "1.0.0" + }, + "mxnet-1.0.0-py36_nomkl_0.tar.bz2": { + "build": "py36_nomkl_0", + "build_number": 0, + "depends": [ + "libmxnet 1.0.0 nomklh2cb3ce3_0", + "py-mxnet 1.0.0 py36_nomklhf484d3e_0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "8340db088f12dbbddc3000ae63458e92", + "name": "mxnet", + "namespace": "python", + "sha256": "2b4672ed321697225eb8be8cc59eddac3620effcde68ef4b2026d3db3288b214", + "size": 9798, + "subdir": "linux-64", + "timestamp": 1514731647724, + "version": "1.0.0" + }, + "mxnet-1.1.0-py27_nomklhba1e662_0.tar.bz2": { + "build": "py27_nomklhba1e662_0", + "build_number": 0, + "depends": [ + "libmxnet 1.1.0 nomklh028b6bb_0", + "py-mxnet 1.1.0 py27_nomklhf484d3e_0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "4f98e1d32183bbd244b18d1a4a62c32f", + "name": "mxnet", + "namespace": "python", + "sha256": "c6011b0889abd5de038688d175606791f0ed3555bfbd467c3489dab2b86f095b", + "size": 17053, + "subdir": "linux-64", + "timestamp": 1522953612955, + "version": "1.1.0" + }, + "mxnet-1.1.0-py27hb4372cb_0.tar.bz2": { + "build": "py27hb4372cb_0", + "build_number": 0, + "depends": [ + "libmxnet 1.1.0 h47cb24f_0", + "py-mxnet 1.1.0 py27hf484d3e_0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "663f32ad55cb2d4e4685209abbd93a6d", + "name": "mxnet", + "namespace": "python", + "sha256": "32f55b2afa60beaef1cf3cf32fab88628ba4ae217d3f24aa0f378c16288451d0", + "size": 17016, + "subdir": "linux-64", + "timestamp": 1522952825075, + "version": "1.1.0" + }, + "mxnet-1.1.0-py35_nomklhba1e662_0.tar.bz2": { + "build": "py35_nomklhba1e662_0", + "build_number": 0, + "depends": [ + "libmxnet 1.1.0 nomklh028b6bb_0", + "py-mxnet 1.1.0 py35_nomklhf484d3e_0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "5723ceba305b0798d6930af0cb01c6b0", + "name": "mxnet", + "namespace": "python", + "sha256": "11f0d663654f8bb5a713de05dbaff2d5ccd18a7b6cd3881f1a3e95b8de7dd2d8", + "size": 16930, + "subdir": "linux-64", + "timestamp": 1522953869357, + "version": "1.1.0" + }, + "mxnet-1.1.0-py35hb4372cb_0.tar.bz2": { + "build": "py35hb4372cb_0", + "build_number": 0, + "depends": [ + "libmxnet 1.1.0 h47cb24f_0", + "py-mxnet 1.1.0 py35hf484d3e_0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "a766da178e8c311d99ea0ebd7408f1f9", + "name": "mxnet", + "namespace": "python", + "sha256": "bf06366881d36c2832a77554b03c455fc11d69e48c02fb32e409b6d4d08718ce", + "size": 16918, + "subdir": "linux-64", + "timestamp": 1522953783712, + "version": "1.1.0" + }, + "mxnet-1.1.0-py36_nomklhba1e662_0.tar.bz2": { + "build": "py36_nomklhba1e662_0", + "build_number": 0, + "depends": [ + "libmxnet 1.1.0 nomklh028b6bb_0", + "py-mxnet 1.1.0 py36_nomklhf484d3e_0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "371cd35174c936474daee8ce93bdf7ae", + "name": "mxnet", + "namespace": "python", + "sha256": "f62fa84827e0176623c617fb8a9cec53979c4282a1f27e996038f3f9e94a4521", + "size": 16914, + "subdir": "linux-64", + "timestamp": 1522954188833, + "version": "1.1.0" + }, + "mxnet-1.1.0-py36hb4372cb_0.tar.bz2": { + "build": "py36hb4372cb_0", + "build_number": 0, + "depends": [ + "libmxnet 1.1.0 h47cb24f_0", + "py-mxnet 1.1.0 py36hf484d3e_0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "a8e5dc7d059a17cf42e6a14e1206be73", + "name": "mxnet", + "namespace": "python", + "sha256": "77bd97b2d4ae7e59b14d143a42ef2ed834f420bacdbc9c4ba521091b43d0a120", + "size": 16897, + "subdir": "linux-64", + "timestamp": 1522953962330, + "version": "1.1.0" + }, + "mxnet-1.2.1-h8cc8929_0.tar.bz2": { + "build": "h8cc8929_0", + "build_number": 0, + "depends": [ + "libmxnet 1.2.1.*", + "py-mxnet 1.2.1.*" + ], + "md5": "0b253e26f299a35f87e402443a072c0a", + "name": "mxnet", + "namespace": "python", + "sha256": "a97e7080283241d0f1b0c1ca00480e371f76d983ab2587f3a740482e5ea91e16", + "size": 2640, + "subdir": "linux-64", + "timestamp": 1533368926791, + "version": "1.2.1" + }, + "mxnet-1.5.0-hea8a0af_0.tar.bz2": { + "build": "hea8a0af_0", + "build_number": 0, + "depends": [ + "libmxnet 1.5.0.*", + "py-mxnet 1.5.0.*" + ], + "md5": "f1d689c26d6e3bac6c68074bae61a82f", + "name": "mxnet", + "namespace": "python", + "sha256": "8bc0c2250f435c852c07b217a931062dbbf3d38b2f63213cc6214b1a91348af7", + "size": 5507, + "subdir": "linux-64", + "timestamp": 1564770317442, + "version": "1.5.0" + }, + "mxnet-1.5.1-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libmxnet 1.5.1 openblas_h8848447_0", + "py-mxnet 1.5.1 py39h9bc9155_0" + ], + "md5": "80d19704249716c5bd5a051aef150c91", + "name": "mxnet", + "namespace": "python", + "sha256": "7ba72266af9357d7ed4621e970d6daad556c523513679260c0f45a014b7b7593", + "size": 9809, + "subdir": "linux-64", + "timestamp": 1665586798619, + "version": "1.5.1" + }, + "mxnet-1.9.1-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libmxnet 1.9.1 openblas_h8848447_0", + "py-mxnet 1.9.1 py38h4f77008_0" + ], + "md5": "e50addc83865f26bd8ba2947e6660aa0", + "name": "mxnet", + "namespace": "python", + "sha256": "e56e0f90564ffe02fb73004b0079a4c76e3a111b699bdabedc59bdeb9dce6e21", + "size": 12234, + "subdir": "linux-64", + "timestamp": 1666597083322, + "version": "1.9.1" + }, + "mxnet-gpu-1.2.1-hd441e4d_0.tar.bz2": { + "build": "hd441e4d_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.10 gpu_openblas", + "mxnet 1.2.1.*" + ], + "md5": "a0f7c696249f3b3ef4a1056bb54bb016", + "name": "mxnet-gpu", + "sha256": "1d6b699959d243ad1f8db32a99a4d578d7c7f9f259fdfb25f861f7c3256cf026", + "size": 2525, + "subdir": "linux-64", + "timestamp": 1533385632352, + "version": "1.2.1" + }, + "mxnet-gpu-1.2.1-hf82a2c8_0.tar.bz2": { + "build": "hf82a2c8_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.20 gpu_mkl", + "mxnet 1.2.1.*" + ], + "md5": "b7aabca89b703187e0237f9932292a79", + "name": "mxnet-gpu", + "sha256": "58f536319debcfeb2c6e3877c468b91c07a33001b89f3ab21ce93c1e0ae926b4", + "size": 2517, + "subdir": "linux-64", + "timestamp": 1533385628370, + "version": "1.2.1" + }, + "mxnet-gpu_mkl-1.2.1-hf82a2c8_0.tar.bz2": { + "build": "hf82a2c8_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.20 gpu_mkl", + "mxnet 1.2.1.*" + ], + "md5": "69c37fb6650968009632d2ac6d87dc0d", + "name": "mxnet-gpu_mkl", + "sha256": "9163eed3bbe0bc596e3ece20e737725492ada4607350de1769aa27e9289749b0", + "size": 2454, + "subdir": "linux-64", + "timestamp": 1533677450611, + "version": "1.2.1" + }, + "mxnet-gpu_openblas-1.2.1-hd441e4d_0.tar.bz2": { + "build": "hd441e4d_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.10 gpu_openblas", + "mxnet 1.2.1.*" + ], + "md5": "56b5e9cc3b3bdce32236ff63b1241661", + "name": "mxnet-gpu_openblas", + "sha256": "eb677a9c31ffc8324f963b58721457ffaa04466527df499758c1ba704f129916", + "size": 2438, + "subdir": "linux-64", + "timestamp": 1533677446920, + "version": "1.2.1" + }, + "mxnet-mkl-1.2.1-hd1a0b70_0.tar.bz2": { + "build": "hd1a0b70_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.40 mkl", + "mxnet 1.2.1.*" + ], + "md5": "a03c98f5befb64b924bf48044fd7c9c2", + "name": "mxnet-mkl", + "sha256": "29a457f1604bba87026ba0cd5160df46ce8d42b85cc9ea410bbece890fa05c11", + "size": 2447, + "subdir": "linux-64", + "timestamp": 1533677454252, + "version": "1.2.1" + }, + "mxnet-mkl-1.5.0-hb5687c5_0.tar.bz2": { + "build": "hb5687c5_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.40 mkl", + "mxnet 1.5.0.*" + ], + "md5": "a98a51ba18d14536a04c80f6c7bda490", + "name": "mxnet-mkl", + "sha256": "096bb3c65ee541e234b935b34f4d1c888ef66685a37a8fb4466c05043f073a8b", + "size": 5520, + "subdir": "linux-64", + "timestamp": 1564770976806, + "version": "1.5.0" + }, + "mxnet-openblas-1.2.1-h0ffc63b_0.tar.bz2": { + "build": "h0ffc63b_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.30 openblas", + "mxnet 1.2.1.*" + ], + "md5": "997ad2aa84ddfd75b078fadfd8984110", + "name": "mxnet-openblas", + "sha256": "9c310ad8cd4a5a0378fbe7140d7215724ac44ef36b0d0e8b1d14848f6bfdb34d", + "size": 2435, + "subdir": "linux-64", + "timestamp": 1533677442756, + "version": "1.2.1" + }, + "mxnet-openblas-1.5.0-h026006c_0.tar.bz2": { + "build": "h026006c_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.30 openblas", + "mxnet 1.5.0.*" + ], + "md5": "d1ba60322261b13ffe11e495593d2f07", + "name": "mxnet-openblas", + "sha256": "5229f684aa7094c6dc512fd11162a1603556b50a6229c288e1fe3477f1e799f9", + "size": 5537, + "subdir": "linux-64", + "timestamp": 1564770617404, + "version": "1.5.0" + }, + "mxnet-openblas-1.5.1-h687809c_0.tar.bz2": { + "build": "h687809c_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.50 openblas", + "libmxnet 1.5.1 openblas_h8848447_0" + ], + "md5": "727e007619b1daf194fc2a7a0ce46b99", + "name": "mxnet-openblas", + "sha256": "8b3615c423109d21bdf0e8b8118e33d4196668e2339055134d4fa911b259fac6", + "size": 9839, + "subdir": "linux-64", + "timestamp": 1665586672530, + "version": "1.5.1" + }, + "mxnet-openblas-1.9.1-h687809c_0.tar.bz2": { + "build": "h687809c_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.50 openblas", + "libmxnet 1.9.1 openblas_h8848447_0" + ], + "md5": "e3d46ed69671b4f499444d7209223e6b", + "name": "mxnet-openblas", + "sha256": "2c6e3c0d42f98eeb06decc551948fba46db2d4ad94d9a27d2691abbb4a7f10b0", + "size": 12248, + "subdir": "linux-64", + "timestamp": 1666596931909, + "version": "1.9.1" + }, + "mypy-0.550-py35heb60bfd_0.tar.bz2": { + "build": "py35heb60bfd_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.5,<3.6.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6f16a1d7d554e7e1aacbf25b0b006ef", + "name": "mypy", + "sha256": "139ba0fc94f5180c5708125a16f69888d34cdbffcbc3a193639107546a148a80", + "size": 1094192, + "subdir": "linux-64", + "timestamp": 1510777174033, + "version": "0.550" + }, + "mypy-0.550-py36hd8b1e0f_0.tar.bz2": { + "build": "py36hd8b1e0f_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff3ba2d0b002023480ecad3e24074662", + "name": "mypy", + "sha256": "596fb1737db8fc2ebbc8a164e8d25cba11e5835e92558cfaefa0ece2b0fc0dac", + "size": 1091890, + "subdir": "linux-64", + "timestamp": 1510777172356, + "version": "0.550" + }, + "mypy-0.570-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.5,<3.6.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b39b8478eea7fde6c2b7fc25bb8f96d7", + "name": "mypy", + "sha256": "e1476c2bc1ef0093c7f89a9d2ce92b9e36c97afebce5e2e49305966cbadf3607", + "size": 1154686, + "subdir": "linux-64", + "timestamp": 1520882532007, + "version": "0.570" + }, + "mypy-0.570-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2a71112f23c0a03087e6f247deb7813f", + "name": "mypy", + "sha256": "ecb7ee5493d5240d43231da0e9ce49fdead8ef18be76128359912f440b052c39", + "size": 1153643, + "subdir": "linux-64", + "timestamp": 1520882475152, + "version": "0.570" + }, + "mypy-0.580-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.5,<3.6.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a74f4e729c9bd2674a998999b2426d17", + "name": "mypy", + "sha256": "f8f09c5c057f02564a7469833f6a4312218c3563bacf2979fde5b47e756375d5", + "size": 1166599, + "subdir": "linux-64", + "timestamp": 1522715424072, + "version": "0.580" + }, + "mypy-0.580-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dccaa0f2e6b8162403474d2163bfec09", + "name": "mypy", + "sha256": "92b18512d1005bdffb5f3b3658aa3f95ed4ff2ae90c79dfdbd2217dffcd5116c", + "size": 1161430, + "subdir": "linux-64", + "timestamp": 1522715188470, + "version": "0.580" + }, + "mypy-0.590-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.5,<3.6.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "70dff0f37fbbc9562ccb7b3197183a74", + "name": "mypy", + "sha256": "3dde5bacd930a184ee74d14ba32390b00f0a3cd66f60bb69f72985fe5a190781", + "size": 1199762, + "subdir": "linux-64", + "timestamp": 1524071620517, + "version": "0.590" + }, + "mypy-0.590-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5cd193ab2f8c4285a6cb05ac9c886b0", + "name": "mypy", + "sha256": "d25bf2975a5d0c9ab732d97b71ad954e0bf422a844b9f856aa3ea43523bcc8e1", + "size": 1192890, + "subdir": "linux-64", + "timestamp": 1524071635134, + "version": "0.590" + }, + "mypy-0.600-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.5,<3.6.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37d21dfeb0b7ed4600501ddccfdd9214", + "name": "mypy", + "sha256": "904861354b8eff2064f410eeb70d405422ab0d037a9ec721fac6c69698c63719", + "size": 1208262, + "subdir": "linux-64", + "timestamp": 1526932453274, + "version": "0.600" + }, + "mypy-0.600-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db90b2e6d40480fa6138c40f27a0451c", + "name": "mypy", + "sha256": "0ff36006d2ae450e601c8779f3482f7dd9c2cf146742592822cc3291597bcd74", + "size": 1208902, + "subdir": "linux-64", + "timestamp": 1526932432627, + "version": "0.600" + }, + "mypy-0.610-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.5,<3.6.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66accc1626596c488d89b1b8f8265482", + "name": "mypy", + "sha256": "e76a7091d2a78a59cffee2956b6e14b6abfc1a59f3476c4f483fbfffad9f894c", + "size": 1254041, + "subdir": "linux-64", + "timestamp": 1529967689949, + "version": "0.610" + }, + "mypy-0.610-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce03d624e84dc27e0a21abb2fbe64f1e", + "name": "mypy", + "sha256": "fad7c80c365e34f69bf67122d74d3e18bd6805ca92eb2691abac5e952f6920f4", + "size": 1249835, + "subdir": "linux-64", + "timestamp": 1529967659326, + "version": "0.610" + }, + "mypy-0.610-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "05373d155bdfe5bfea304a5d8ca0ffd9", + "name": "mypy", + "sha256": "9877acd96381f2bd6d188da0dedb7d6a8c2b7eb9a73f38356e25a43a7e0a3683", + "size": 1250810, + "subdir": "linux-64", + "timestamp": 1530900712916, + "version": "0.610" + }, + "mypy-0.620-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.5,<3.6.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f0e4f46c63249c205c2b4513cc01eb02", + "name": "mypy", + "sha256": "bfac9826d75a36326e55a702a4ef30240c9e781e56a3561bedbb8f28532f3691", + "size": 1286808, + "subdir": "linux-64", + "timestamp": 1534665866731, + "version": "0.620" + }, + "mypy-0.620-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2fe8f94fcf5473eb2b990864c3534f3", + "name": "mypy", + "sha256": "3daec26c8321873a01663be1b684d5de503e9f708c687f66ba73b4c09eb9398a", + "size": 1282055, + "subdir": "linux-64", + "timestamp": 1534665825874, + "version": "0.620" + }, + "mypy-0.620-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0fbe6a2428b027c7cb1ed492d5cd6c05", + "name": "mypy", + "sha256": "a70bf8851e2a2c25ea5b62ef74c420854cd942b1247629dd30ae17c6e6214a92", + "size": 1281754, + "subdir": "linux-64", + "timestamp": 1534665858270, + "version": "0.620" + }, + "mypy-0.630-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.0,<0.5.0", + "psutil >=5.4.0,<5.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "709a9a277c11c1689f44cc4163b701a1", + "name": "mypy", + "sha256": "09c86edb2d5764b7a9a953a6b4453b4331e798c3b3f6f6a2c8720debf57b758c", + "size": 1357587, + "subdir": "linux-64", + "timestamp": 1538183685928, + "version": "0.630" + }, + "mypy-0.630-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.0,<0.5.0", + "psutil >=5.4.0,<5.5.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a96c407c8010224d7719ef95913161b", + "name": "mypy", + "sha256": "d58aafb21c1dd8cd440e95b455a9991a0c6ba2fc31fd0d9a68ddb1c3a7fa0f08", + "size": 1358160, + "subdir": "linux-64", + "timestamp": 1538183689931, + "version": "0.630" + }, + "mypy-0.641-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.0,<0.5.0", + "psutil >=5.4.0,<5.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "308b9579e5c55cecf3157ef89279a8b4", + "name": "mypy", + "sha256": "d5151f0da730a8221f58f129f0714d772980d2a2d39fcee9fc0bca70fbe7746b", + "size": 1332167, + "subdir": "linux-64", + "timestamp": 1540982959871, + "version": "0.641" + }, + "mypy-0.641-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.0,<0.5.0", + "psutil >=5.4.0,<5.5.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b918c7d46edc7bc20788e4d545048fa", + "name": "mypy", + "sha256": "5de7bb6b52c3dddc8db0f636571e7b008668f177a20ba2799d105e5e0a449f23", + "size": 1328803, + "subdir": "linux-64", + "timestamp": 1540982976015, + "version": "0.641" + }, + "mypy-0.650-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.0,<0.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce4b59fe704986a1cfcdb65a0be3f596", + "name": "mypy", + "sha256": "b3a11e3385e901de584337082307ce15f2ac1e69168314518e998504c3cdabe3", + "size": 1362099, + "subdir": "linux-64", + "timestamp": 1545163228599, + "version": "0.650" + }, + "mypy-0.650-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.0,<0.5.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f5210febdae3b0c1e53c0ebe0cd1e37", + "name": "mypy", + "sha256": "c42355224cf4b6bbec90e6a3df9048c25bb15a51298d85692467ef989f70ae3f", + "size": 1362751, + "subdir": "linux-64", + "timestamp": 1545163110547, + "version": "0.650" + }, + "mypy-0.660-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.0,<0.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a130a758e69e57a72c7542e9d8e57651", + "name": "mypy", + "sha256": "1824dbfdf18df272a3a9f9f0b274a8e3b7f4ce43dea55f65438e9f44f1df0e40", + "size": 1402934, + "subdir": "linux-64", + "timestamp": 1547791542788, + "version": "0.660" + }, + "mypy-0.660-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.0,<0.5.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9dc806ac58013a9d59b5e58a78577229", + "name": "mypy", + "sha256": "2dbbb6389e21cbb4efb3add2843eb3e959814ec6553b3f0a57d2753046f2f6cc", + "size": 1402862, + "subdir": "linux-64", + "timestamp": 1547791471098, + "version": "0.660" + }, + "mypy-0.981-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.3,<2", + "psutil >=4.0", + "python >=3.10,<3.11.0a0", + "toml", + "tomli >=1.1.0", + "typing_extensions >=3.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8cf7265825eeea776f5d9d3c231a8fdc", + "name": "mypy", + "sha256": "5374362a5626b40e48e7b768601e6aa7b0d99a59b8de05a9806ab859b9349020", + "size": 2606942, + "subdir": "linux-64", + "timestamp": 1668440271591, + "version": "0.981" + }, + "mypy-0.981-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.3,<2", + "psutil >=4.0", + "python >=3.11,<3.12.0a0", + "toml", + "typing_extensions >=3.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8fa398417201715a886671224b5b2e8", + "name": "mypy", + "sha256": "b1282cabcf98ef21529b74dff16df8f3df3071945f16e99da207e9f41b89aa89", + "size": 3243336, + "subdir": "linux-64", + "timestamp": 1676859841268, + "version": "0.981" + }, + "mypy-0.981-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.3,<2", + "psutil >=4.0", + "python >=3.7,<3.8.0a0", + "toml", + "tomli >=1.1.0", + "typed-ast >=1.4.0,<2", + "typing_extensions >=3.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33225778918bd17cb765a1ca10f3e903", + "name": "mypy", + "sha256": "db93bf0a8578d404d80eb87af5213e3a6fb0c911f2a6f07fb0cd14b9833391ad", + "size": 2577217, + "subdir": "linux-64", + "timestamp": 1668440382029, + "version": "0.981" + }, + "mypy-0.981-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.3,<2", + "psutil >=4.0", + "python >=3.8,<3.9.0a0", + "toml", + "tomli >=1.1.0", + "typing_extensions >=3.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "89851d1a155f6976b0b8be1db9aaf02b", + "name": "mypy", + "sha256": "067ab63920a932b732a4b5113bab3395a636fa59b1e859a76929acafe24c3a8a", + "size": 2587418, + "subdir": "linux-64", + "timestamp": 1668440345040, + "version": "0.981" + }, + "mypy-0.981-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.3,<2", + "psutil >=4.0", + "python >=3.9,<3.10.0a0", + "toml", + "tomli >=1.1.0", + "typing_extensions >=3.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "32d93d0d7a90686dc3a33cfe9f1ea83e", + "name": "mypy", + "sha256": "5d58003766286a8fea07dc36bdf41a51551e4631e83d06637eb8f54b2b1751bb", + "size": 2582584, + "subdir": "linux-64", + "timestamp": 1668440307072, + "version": "0.981" + }, + "mypy_extensions-0.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "typing" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a069aa9312132794a4ef568a81281a9", + "name": "mypy_extensions", + "sha256": "02d1bcf6741a650ccd915e0f5772a771e73abe60120aa6e64f258eac66069c1a", + "size": 7263, + "subdir": "linux-64", + "timestamp": 1530900800066, + "version": "0.3.0" + }, + "mypy_extensions-0.3.0-py27ha5a17fb_0.tar.bz2": { + "build": "py27ha5a17fb_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "typing" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc88109b828c5676bb992929687c654a", + "name": "mypy_extensions", + "sha256": "68f7ca503d27ba8840b95241cf97efdfeaf04b12426479fe4785f9fcd96e2a49", + "size": 7560, + "subdir": "linux-64", + "timestamp": 1511211977086, + "version": "0.3.0" + }, + "mypy_extensions-0.3.0-py35h319d151_0.tar.bz2": { + "build": "py35h319d151_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a2420f5864ed65b0933b0e0918aebd2e", + "name": "mypy_extensions", + "sha256": "5706262eae22bb81bb9bff992faf9a63ecf9eca118b7c05d285011a2c0d2dc1f", + "size": 7685, + "subdir": "linux-64", + "timestamp": 1511211979076, + "version": "0.3.0" + }, + "mypy_extensions-0.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e84d9365f34d7e17fd3de9b7df941051", + "name": "mypy_extensions", + "sha256": "4f1924e0259d79a631ebf74782eacec5dc6719b9f62bfff35ebc83b48cdb116b", + "size": 7367, + "subdir": "linux-64", + "timestamp": 1530900773290, + "version": "0.3.0" + }, + "mypy_extensions-0.3.0-py36h258aa37_0.tar.bz2": { + "build": "py36h258aa37_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f9ed9bc8b56eced40f33f0d93055ebf", + "name": "mypy_extensions", + "sha256": "4f13fbbf2a50411cbf1f0cf605311de488bd8d1fab0cbfffe8497fdc9fc7afbd", + "size": 7681, + "subdir": "linux-64", + "timestamp": 1511211984292, + "version": "0.3.0" + }, + "mypy_extensions-0.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d0038afe55b496f065f387b592cf849", + "name": "mypy_extensions", + "sha256": "17bce2dc74388f724e939e53381231aa639d81cf5267d78d58cd9a73d734eecc", + "size": 7382, + "subdir": "linux-64", + "timestamp": 1530900746110, + "version": "0.3.0" + }, + "mypy_extensions-0.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "typing" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b684adfa90cfb02fc400087b1644aab", + "name": "mypy_extensions", + "sha256": "81036982b218281417ce5fd1b21dc1cb777ec78c86b9fee47baeeeb7676b2142", + "size": 8197, + "subdir": "linux-64", + "timestamp": 1536113481397, + "version": "0.4.1" + }, + "mypy_extensions-0.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c0bd778710a94881ff5f865cd646696", + "name": "mypy_extensions", + "sha256": "d6d683efc7d03df3555b3b0facf872c4c1d6e89c2116a6fb25557bc097b1e36c", + "size": 8373, + "subdir": "linux-64", + "timestamp": 1536113463977, + "version": "0.4.1" + }, + "mypy_extensions-0.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "585e4a1f87f37dbceb2f7bdfc504b9f1", + "name": "mypy_extensions", + "sha256": "b4cbbc89728620c498a5e8789308dc9f991c166729949ea22452a5cbd4b222d2", + "size": 8388, + "subdir": "linux-64", + "timestamp": 1536113409242, + "version": "0.4.1" + }, + "mypy_extensions-0.4.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f18dccdeea635f039dfa280f6bd1e365", + "name": "mypy_extensions", + "sha256": "d6b0afaa166706eb383ab6d7dfe806da7d8fb4171abed93e1f6ed1e0c0f80cbc", + "size": 9110, + "subdir": "linux-64", + "timestamp": 1613558452948, + "version": "0.4.1" + }, + "mypy_extensions-0.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "daf099b2c772153c9fbe4e63dccee312", + "name": "mypy_extensions", + "sha256": "5697cbef56831f9cdeb4f27b0f5076842fc31ee30b76f426524fef3e5b2f5355", + "size": 8390, + "subdir": "linux-64", + "timestamp": 1536113509057, + "version": "0.4.1" + }, + "mypy_extensions-0.4.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bedfbdcebbca0d85a271b6f1b41892c0", + "name": "mypy_extensions", + "sha256": "4b8b574fcc2d98c08acaf131ad0de6fc54fa9538a86e36432025876a1cd8e221", + "size": 9106, + "subdir": "linux-64", + "timestamp": 1613558456770, + "version": "0.4.1" + }, + "mypy_extensions-0.4.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3696a83fee03c60b1707cf73ef4d7991", + "name": "mypy_extensions", + "sha256": "7040d4f49e57856c0d5734069284b89c2ca0e943f3abb8583ed48523ec3cdfdb", + "size": 8769, + "subdir": "linux-64", + "timestamp": 1573120731824, + "version": "0.4.1" + }, + "mypy_extensions-0.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "36680ae484e8b63ad5796bc848e392bb", + "name": "mypy_extensions", + "sha256": "51ef56a34e9f07639842198ce5bfab397fac22825b70199299f01b238d1d6681", + "size": 9138, + "subdir": "linux-64", + "timestamp": 1613558456126, + "version": "0.4.1" + }, + "mypy_extensions-0.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aad91f07076fad0f25da1805c7c77e0f", + "name": "mypy_extensions", + "sha256": "b5375aa1d1a20a9ab511bf37e9bb7cef2f1118d908e8a1a9b9063125906cd6ff", + "size": 9161, + "subdir": "linux-64", + "timestamp": 1613558326788, + "version": "0.4.1" + }, + "mypy_extensions-0.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fdbda54cd14a3060376240b9ab8bcdda", + "name": "mypy_extensions", + "sha256": "6b192ceba56f523d8aea77b87c08d698d39681cfe631cb10f8ce409969fabde7", + "size": 8740, + "subdir": "linux-64", + "timestamp": 1640791841558, + "version": "0.4.3" + }, + "mypy_extensions-0.4.3-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "235f9ad3c702efa832449e1205efabaa", + "name": "mypy_extensions", + "sha256": "6814fdc8e4e4bd8d45dbab98754a7bceaa15f583802d257ca34eb49f72b3971a", + "size": 10874, + "subdir": "linux-64", + "timestamp": 1676837158360, + "version": "0.4.3" + }, + "mypy_extensions-0.4.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a112c8cd87c62dcd3759c59a3b98174", + "name": "mypy_extensions", + "sha256": "2da6e70688481fda755096341bf6954aad054b052f13975b3c019bd039d6e7d0", + "size": 9283, + "subdir": "linux-64", + "timestamp": 1582149851383, + "version": "0.4.3" + }, + "mypy_extensions-0.4.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "24fb7514330ebde190ecab2b6c4afc64", + "name": "mypy_extensions", + "sha256": "b61ae731919d2ad241dd3ca9977b153e3f37060193f1a6a9e990a9df47ef5be9", + "size": 9299, + "subdir": "linux-64", + "timestamp": 1582149828175, + "version": "0.4.3" + }, + "mypy_extensions-0.4.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "928bd1d7affd1df0bcdf1a210133c423", + "name": "mypy_extensions", + "sha256": "c0a461061de49ac1aad68c3c17b937d7934511f59ba320fe1d258783544a100a", + "size": 9772, + "subdir": "linux-64", + "timestamp": 1640165683889, + "version": "0.4.3" + }, + "mypy_extensions-0.4.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be0bad5a30ef6fe27466207ee01f75cf", + "name": "mypy_extensions", + "sha256": "6f928d625a3db99177d570962b5813c6382908e7293b6af0e7468dee46e32b26", + "size": 9311, + "subdir": "linux-64", + "timestamp": 1582150019773, + "version": "0.4.3" + }, + "mypy_extensions-0.4.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a98729e8381c508b67103e44ee61128", + "name": "mypy_extensions", + "sha256": "73ee04ba1eebeeb2ec89a2c99d95bf2f5a35a3d8afcf7d3e982a55f3a1cb7361", + "size": 9774, + "subdir": "linux-64", + "timestamp": 1640151569197, + "version": "0.4.3" + }, + "mypy_extensions-0.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a66df523cd3c037731ff40d02847f9d7", + "name": "mypy_extensions", + "sha256": "510ee7b25a0cfcde7b041a71b62e9e68e7739a6aeffba6de34116fbcc9adefdc", + "size": 9021, + "subdir": "linux-64", + "timestamp": 1626908116886, + "version": "0.4.3" + }, + "mypy_extensions-0.4.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "763d81e8d77153a6fd3b1981d20023b1", + "name": "mypy_extensions", + "sha256": "b7a127ccc8c75894c1ec11e42ac76fdac2ca3db0956b63b76b7bd1dd5de7b89f", + "size": 9767, + "subdir": "linux-64", + "timestamp": 1640165677703, + "version": "0.4.3" + }, + "mysql-5.7.20-h55eaa98_0.tar.bz2": { + "build": "h55eaa98_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "8370ba12dab870813cb23211b1c60f30", + "name": "mysql", + "sha256": "70efc122f5cdb2a7f515206869c901afbb8c3c1be339cc9d7e790e2654c7db59", + "size": 78035840, + "subdir": "linux-64", + "timestamp": 1510510424005, + "version": "5.7.20" + }, + "mysql-5.7.22-hef7e34c_0.tar.bz2": { + "build": "hef7e34c_0", + "build_number": 0, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libedit >=3.1.20170329,<3.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "fb35b10dc7510eaef756f1089ddbc8a0", + "name": "mysql", + "sha256": "cdf802250759551a185ca1bd932ae0c415f6af06502e79b69b7ff65dc71ac8fe", + "size": 77861709, + "subdir": "linux-64", + "timestamp": 1527083722955, + "version": "5.7.22" + }, + "mysql-5.7.24-hbb652a2_0.tar.bz2": { + "build": "hbb652a2_0", + "build_number": 0, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libedit >=3.1.20170329,<3.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "5a4beaad880678888c86c8e27e39d319", + "name": "mysql", + "sha256": "d982dd5b53c9b2cb91f21ae6e959df60a43a302b1c3851515c3386a270becec4", + "size": 79478155, + "subdir": "linux-64", + "timestamp": 1541008954973, + "version": "5.7.24" + }, + "mysql-connector-c-6.1.11-h24aacaa_2.tar.bz2": { + "build": "h24aacaa_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=8.4.0", + "libstdcxx-ng >=8.4.0", + "openssl >=1.1.1m,<1.1.2a" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "be6e76097a6b085fb149092c11a389e3", + "name": "mysql-connector-c", + "sha256": "aa01505f401448bceed9c6a6aebf145d678d347919a20b68f44832a6084f0714", + "size": 2787303, + "subdir": "linux-64", + "timestamp": 1642788160502, + "version": "6.1.11" + }, + "mysql-connector-c-6.1.11-h597af5e_0.tar.bz2": { + "build": "h597af5e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "1da6521d71db68ae1f30124bbae3fef5", + "name": "mysql-connector-c", + "sha256": "9e96a2f961b05d465fd961a2fe216b805894ac38afce28cf547d4d8f453db665", + "size": 4640560, + "subdir": "linux-64", + "timestamp": 1540380766928, + "version": "6.1.11" + }, + "mysql-connector-c-6.1.11-h597af5e_1.tar.bz2": { + "build": "h597af5e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "8e73f105c69ae44e9b3300caed014451", + "name": "mysql-connector-c", + "sha256": "41525abc0b0c914d461464518702c60fa04ab6fa3c02a1bef3095e7c08d10d8f", + "size": 2818069, + "subdir": "linux-64", + "timestamp": 1579119221091, + "version": "6.1.11" + }, + "mysql-connector-c-6.1.11-hf4847fb_0.tar.bz2": { + "build": "hf4847fb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "a6021db41c4f37f5aa6f1a47f38c00ec", + "name": "mysql-connector-c", + "sha256": "4be69d842bffc16e0e5a03786d544322e05db3e0a53af89209b9252af1957e39", + "size": 4634368, + "subdir": "linux-64", + "timestamp": 1524130832622, + "version": "6.1.11" + }, + "mysql-connector-python-8.0.12-py27haf6c83e_0.tar.bz2": { + "build": "py27haf6c83e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "b1511232898e6a3bcc8eb5370b1c4089", + "name": "mysql-connector-python", + "sha256": "d598f1919caf79c50644e0ea752363661e900f31bf1afb864bcc873b3324bb82", + "size": 628320, + "subdir": "linux-64", + "timestamp": 1534744972606, + "version": "8.0.12" + }, + "mysql-connector-python-8.0.12-py35haf6c83e_0.tar.bz2": { + "build": "py35haf6c83e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "14d97cd5226289635851eb9f254d7f4c", + "name": "mysql-connector-python", + "sha256": "bd235f74d5b07097c6e5efbe4bf9671a8bead08cec0fc709aa374f4ce8e7b540", + "size": 655378, + "subdir": "linux-64", + "timestamp": 1534744961095, + "version": "8.0.12" + }, + "mysql-connector-python-8.0.12-py36haf6c83e_0.tar.bz2": { + "build": "py36haf6c83e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "b45a7f0fe2f18d0b8ac05d739b8a52ee", + "name": "mysql-connector-python", + "sha256": "eea1ccac182fa209ff0ae16a711b0b63e46d0f4a84b0c2b20ea8f08fd4932601", + "size": 662679, + "subdir": "linux-64", + "timestamp": 1534744964171, + "version": "8.0.12" + }, + "mysql-connector-python-8.0.12-py37haf6c83e_0.tar.bz2": { + "build": "py37haf6c83e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "32accb0e02e0c6f12c1e216a227caf98", + "name": "mysql-connector-python", + "sha256": "b42ad98094482d1575ee465de591584bdc66af7d79d820d93f571d43ed0adf49", + "size": 660713, + "subdir": "linux-64", + "timestamp": 1534744708435, + "version": "8.0.12" + }, + "mysql-connector-python-8.0.13-py27h9c95fcb_0.tar.bz2": { + "build": "py27h9c95fcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "f067d57f9f2b0ae9ea4aa5f6383e4d03", + "name": "mysql-connector-python", + "sha256": "2090f129df7e69029185e4f5636f0d96a9593730b2e8131c6719d6334bbb9443", + "size": 679750, + "subdir": "linux-64", + "timestamp": 1545159108356, + "version": "8.0.13" + }, + "mysql-connector-python-8.0.13-py36h9c95fcb_0.tar.bz2": { + "build": "py36h9c95fcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "d489e3fa3108a054ab7e954d4e302d46", + "name": "mysql-connector-python", + "sha256": "47d2f6b79198017df1930b54b147da07c2a944d220eef3b7556121f84b54e89a", + "size": 705859, + "subdir": "linux-64", + "timestamp": 1545159121968, + "version": "8.0.13" + }, + "mysql-connector-python-8.0.13-py37h9c95fcb_0.tar.bz2": { + "build": "py37h9c95fcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "2583cbc078bc101112c118d389772d9f", + "name": "mysql-connector-python", + "sha256": "34ebce2e0ffc5eda902bd42493ca1e57f34381a8d7ad499a82c9873b1685490b", + "size": 701756, + "subdir": "linux-64", + "timestamp": 1545159140160, + "version": "8.0.13" + }, + "mysql-connector-python-8.0.16-py27h9c95fcb_0.tar.bz2": { + "build": "py27h9c95fcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "922173f0ffe1d69e345affa4698b5155", + "name": "mysql-connector-python", + "sha256": "e4b7b2fd85d6e6b3d069db02e783e30edeb1fa9d758ec65f67cf19dc0ae3287b", + "size": 719184, + "subdir": "linux-64", + "timestamp": 1559920932706, + "version": "8.0.16" + }, + "mysql-connector-python-8.0.16-py36h9c95fcb_0.tar.bz2": { + "build": "py36h9c95fcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "c0c6890e6b4c0346088dd5dee238074d", + "name": "mysql-connector-python", + "sha256": "d53093453d5c670b2fff80d0ad1ff56a4f9f3ab0a8264c6733c8074f59faa888", + "size": 743921, + "subdir": "linux-64", + "timestamp": 1559920965339, + "version": "8.0.16" + }, + "mysql-connector-python-8.0.16-py37h9c95fcb_0.tar.bz2": { + "build": "py37h9c95fcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "97608c54ffac114422956dee60ab12dc", + "name": "mysql-connector-python", + "sha256": "29aeed1e0f86d817f1dfdbdc29c08b6d56390725d867cc965bf14f30b9cda116", + "size": 739748, + "subdir": "linux-64", + "timestamp": 1559920934011, + "version": "8.0.16" + }, + "mysql-connector-python-8.0.17-py27h9c95fcb_0.tar.bz2": { + "build": "py27h9c95fcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "ef4465f018d3c963ad171a8df7097f1a", + "name": "mysql-connector-python", + "sha256": "ee34314102ec89591c2b6d68a968bb10a073318b41314e913d4ef0a71e7d5577", + "size": 763798, + "subdir": "linux-64", + "timestamp": 1569355677287, + "version": "8.0.17" + }, + "mysql-connector-python-8.0.17-py36h9c95fcb_0.tar.bz2": { + "build": "py36h9c95fcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "f3636d25ebdd45f7d0dd65954e0a0a0e", + "name": "mysql-connector-python", + "sha256": "d486e55c57fdc15e40a5f9ad2ab7dd42e8c8c9bdd63e5f956cad2f8a650a9fc9", + "size": 754422, + "subdir": "linux-64", + "timestamp": 1569355653229, + "version": "8.0.17" + }, + "mysql-connector-python-8.0.17-py37h9c95fcb_0.tar.bz2": { + "build": "py37h9c95fcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "85ca76419a1d542bee6fdbd0a7c34c17", + "name": "mysql-connector-python", + "sha256": "92af04431663619ba3b7cd188abde94709ce1c6a96ea2a3c632c0617bea6dba9", + "size": 763626, + "subdir": "linux-64", + "timestamp": 1569355675429, + "version": "8.0.17" + }, + "mysql-connector-python-8.0.18-py27h9c95fcb_1.tar.bz2": { + "build": "py27h9c95fcb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "bf9d06279f6ea109792105f506c0ce3c", + "name": "mysql-connector-python", + "sha256": "7291d5f04ee9266de95f5e6ceefc765afb3eabb5212fa203a7147b82f109baa5", + "size": 764167, + "subdir": "linux-64", + "timestamp": 1573969142724, + "version": "8.0.18" + }, + "mysql-connector-python-8.0.18-py36h9c95fcb_1.tar.bz2": { + "build": "py36h9c95fcb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "7347eaceac1257d6941e9513ac071a60", + "name": "mysql-connector-python", + "sha256": "a7f6a431204999aefb18fe396d9653dacf925808a9f4196e0db7f220a05c45dc", + "size": 794393, + "subdir": "linux-64", + "timestamp": 1573969215703, + "version": "8.0.18" + }, + "mysql-connector-python-8.0.18-py37h9c95fcb_1.tar.bz2": { + "build": "py37h9c95fcb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "fdeaecfa24f407c64088416de30116eb", + "name": "mysql-connector-python", + "sha256": "fc455b9e21f79ea9e4db5635435035e4dcb794bd453f91d8aa653af5f0ad7e5b", + "size": 753604, + "subdir": "linux-64", + "timestamp": 1573969155664, + "version": "8.0.18" + }, + "mysql-python-1.2.5-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL", + "license_family": "GPL2", + "md5": "d6134d7c579d64856acb366f687cfa00", + "name": "mysql-python", + "sha256": "58f42129295d035b8d56f341d2c5f9b7766bfaba75c512ff87fa561212adbf7b", + "size": 205196, + "subdir": "linux-64", + "timestamp": 1557176520482, + "version": "1.2.5" + }, + "mysqlclient-1.3.12-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL 2.0", + "md5": "2ef55985de4abe7f8a3ba2dccf42e7a1", + "name": "mysqlclient", + "sha256": "18217be3cf4ae284ed95377a355909d9b59f197cfce2161c585cbe921e97a701", + "size": 86264, + "subdir": "linux-64", + "timestamp": 1524131151327, + "version": "1.3.12" + }, + "mysqlclient-1.3.12-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL 2.0", + "md5": "2437d4b70bbe0d73a865cca624a0f97e", + "name": "mysqlclient", + "sha256": "035e1c19db56993342fa6f069e1ca72d834c6bbd6663d1ef246fcd088fe97f72", + "size": 87383, + "subdir": "linux-64", + "timestamp": 1524131218646, + "version": "1.3.12" + }, + "mysqlclient-1.3.12-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2.0", + "md5": "128c4ae7b804ce4a3a3bb0ddf3b9f8ad", + "name": "mysqlclient", + "sha256": "cb765083bffff6ee343af7dad77abef0716a1376af55444697b04548613e746b", + "size": 87404, + "subdir": "linux-64", + "timestamp": 1524131212267, + "version": "1.3.12" + }, + "mysqlclient-1.3.13-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL 2.0", + "md5": "dae4050314d7c40bf90d6e8f52b67fbe", + "name": "mysqlclient", + "sha256": "3192957c2d509552d11df244d9980d6ead1e173863e58fc270dcb95be8668a5f", + "size": 86571, + "subdir": "linux-64", + "timestamp": 1530556055420, + "version": "1.3.13" + }, + "mysqlclient-1.3.13-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL 2.0", + "md5": "887c18226b2c871d5b86e988378ae3a1", + "name": "mysqlclient", + "sha256": "440e1a25966948f3048be1d8d7c699a160d0b0e350fef82d840cfb7536de8d96", + "size": 87593, + "subdir": "linux-64", + "timestamp": 1530556151194, + "version": "1.3.13" + }, + "mysqlclient-1.3.13-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2.0", + "md5": "8beda4214386c63946a046aefcac92ae", + "name": "mysqlclient", + "sha256": "5c094b481793711983302464bca60d2bbb58cd5cf63eb9f32a1ef7c31e98c92a", + "size": 87407, + "subdir": "linux-64", + "timestamp": 1530556151041, + "version": "1.3.13" + }, + "mysqlclient-1.3.13-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL 2.0", + "md5": "91543158c52bea894096d80b6373eaa4", + "name": "mysqlclient", + "sha256": "97d6dea37f2c411418791416fe17c7e55dec2df54c14fc25eb218a3fe9de638e", + "size": 87408, + "subdir": "linux-64", + "timestamp": 1530900832328, + "version": "1.3.13" + }, + "mysqlclient-1.3.14-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL 2.0", + "md5": "d49acd3cd3edbfb4db7e405d32e2809b", + "name": "mysqlclient", + "sha256": "9e40c133838cd4ba62e41d0551e2c1a98a8e01ca1c54987afb2367bda6d8710a", + "size": 87056, + "subdir": "linux-64", + "timestamp": 1545126635760, + "version": "1.3.14" + }, + "mysqlclient-1.3.14-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2.0", + "md5": "fe8be99ae8e0652861d6291416575662", + "name": "mysqlclient", + "sha256": "b344b32af444861105b27844ea0c3b4b07b564baff59ec8d596962460a07aa40", + "size": 87858, + "subdir": "linux-64", + "timestamp": 1545147363117, + "version": "1.3.14" + }, + "mysqlclient-1.3.14-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL 2.0", + "md5": "50605576d97313ab46474273bf40729b", + "name": "mysqlclient", + "sha256": "b7579837f89d671ce3d3336e96cb8cdfe3c4fedc197b217cd01b231e43a25087", + "size": 88047, + "subdir": "linux-64", + "timestamp": 1545126654703, + "version": "1.3.14" + }, + "mysqlclient-1.4.4-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "md5": "0e0b2ccc1ea1183cd8bddc13ea3b72d1", + "name": "mysqlclient", + "sha256": "53d3caed3db91ccc049919760a41fcbb7bca25d19aadb288b9a276e22485b8b8", + "size": 82790, + "subdir": "linux-64", + "timestamp": 1569434292890, + "version": "1.4.4" + }, + "mysqlclient-1.4.4-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "md5": "3c4b17722653bb9487f474416ac525bb", + "name": "mysqlclient", + "sha256": "0394ba9dfd7bace56fee4e9fc868df95ddfeb5cbf859f28294e862502f1e79bd", + "size": 83620, + "subdir": "linux-64", + "timestamp": 1569434320784, + "version": "1.4.4" + }, + "mysqlclient-1.4.4-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "md5": "b20ce300db9a60a144b2788d5ae4fbd8", + "name": "mysqlclient", + "sha256": "c583a170ede76a2704d147fbb939fad2c89cd334cdecbf4d249d7d8713be9e91", + "size": 83682, + "subdir": "linux-64", + "timestamp": 1569434323004, + "version": "1.4.4" + }, + "mysqlclient-1.4.4-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-2.0", + "md5": "12a09116b3cfb044a728871ff5246901", + "name": "mysqlclient", + "sha256": "86af5d66de464ae6d4af7c2e585209db734d445926567095dcfe5229d799a97b", + "size": 89934, + "subdir": "linux-64", + "timestamp": 1573120828657, + "version": "1.4.4" + }, + "mysqlclient-1.4.6-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "md5": "d985c276676dd667b76c5c606dc9fa84", + "name": "mysqlclient", + "sha256": "f2ade7603e9adb5baa7c3fa27db47753323540f0f5f8f219d19efa92a3e3a354", + "size": 83249, + "subdir": "linux-64", + "timestamp": 1574368354464, + "version": "1.4.6" + }, + "mysqlclient-1.4.6-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "md5": "9a72d23cd8d448b7893731ae7acbec5e", + "name": "mysqlclient", + "sha256": "b240c259883070158303e8b974c92e562ecf7931df8166a40696d3c1a9bd24ff", + "size": 84103, + "subdir": "linux-64", + "timestamp": 1574368362263, + "version": "1.4.6" + }, + "mysqlclient-1.4.6-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "md5": "b04a8d2ccba0117f25fdcca6b3c54636", + "name": "mysqlclient", + "sha256": "7d89dfff86f44253f04dd06bd5c8e385ca32ec10c1838447da71e683013d3612", + "size": 84112, + "subdir": "linux-64", + "timestamp": 1574368331932, + "version": "1.4.6" + }, + "mysqlclient-1.4.6-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-2.0", + "md5": "da85073085e3eb794d8527a743c1b1be", + "name": "mysqlclient", + "sha256": "36861aa3b1ebb6d185fb1e56341e606e913e5deaf17399ed5cbcb8ad899e70c2", + "size": 91457, + "subdir": "linux-64", + "timestamp": 1574368459887, + "version": "1.4.6" + }, + "mysqlclient-2.0.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "md5": "358c5d2dddb2217b5ee57a9c8c1c6b41", + "name": "mysqlclient", + "sha256": "ff30455e467522c53fd993187cdf1df86447fba389bbcef60c542d6856de3d64", + "size": 83972, + "subdir": "linux-64", + "timestamp": 1594308786811, + "version": "2.0.1" + }, + "mysqlclient-2.0.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "md5": "24c0409085147d9fa23803b6202597a1", + "name": "mysqlclient", + "sha256": "5a41a1bf5af33cbc9e9ab46cb5f82711290b5e85ca0843cb807a85fdba75d191", + "size": 84016, + "subdir": "linux-64", + "timestamp": 1594308796684, + "version": "2.0.1" + }, + "mysqlclient-2.0.1-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-2.0", + "md5": "2120e011c8a0698b72720c32f5f62845", + "name": "mysqlclient", + "sha256": "ce681f54ebfb974bab1d7a61faa3d823f70ff7931d83a46912a6f36e5ecad703", + "size": 84442, + "subdir": "linux-64", + "timestamp": 1594308787023, + "version": "2.0.1" + }, + "mysqlclient-2.0.2-py36h2531618_1.tar.bz2": { + "build": "py36h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "6ed7c6cc0bc5f62ce809129af536dc8a", + "name": "mysqlclient", + "sha256": "62f78c140175f829dc5e36d751690d46ca1eabb70e3e7ca9e4ed687188d4eaac", + "size": 82577, + "subdir": "linux-64", + "timestamp": 1607622877766, + "version": "2.0.2" + }, + "mysqlclient-2.0.2-py37h2531618_1.tar.bz2": { + "build": "py37h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "961c126df8fddbbc99744f8cb2274d90", + "name": "mysqlclient", + "sha256": "5e327d129b9cc1397be868c7be507a4e3a3b4293458f299135688b393628a47f", + "size": 82594, + "subdir": "linux-64", + "timestamp": 1607622885230, + "version": "2.0.2" + }, + "mysqlclient-2.0.2-py38h2531618_1.tar.bz2": { + "build": "py38h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "172711a873f8fe3a25cd85d707e0dcd2", + "name": "mysqlclient", + "sha256": "7df79e618cfb81a4d5b5eda3f75ecd784fa3393ed47812ea4a2ebc6165e629e2", + "size": 83133, + "subdir": "linux-64", + "timestamp": 1607622858120, + "version": "2.0.2" + }, + "mysqlclient-2.0.2-py39h2531618_1.tar.bz2": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "17714631a30a333ad54a1861b3512ffb", + "name": "mysqlclient", + "sha256": "dde451013dd391372d16bbde0cca77d1ad9ff2a6c5f74e94c3d65a851fde845c", + "size": 83043, + "subdir": "linux-64", + "timestamp": 1607622880709, + "version": "2.0.2" + }, + "mysqlclient-2.0.3-py310h295c915_1.tar.bz2": { + "build": "py310h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "e855b91e23af81a415d9139aa477752e", + "name": "mysqlclient", + "sha256": "7149baa1aae0aa218d50473f6d0a3e93453d80c05d218ac17235e5c023775574", + "size": 127527, + "subdir": "linux-64", + "timestamp": 1640791867333, + "version": "2.0.3" + }, + "mysqlclient-2.0.3-py311h6a678d5_1.tar.bz2": { + "build": "py311h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "1900854f16a954a49650039040623c85", + "name": "mysqlclient", + "sha256": "9958b327eea7a775fae445b2343faa086c836b8d47e34b1c095cd74ef76abb3e", + "size": 93306, + "subdir": "linux-64", + "timestamp": 1676859865384, + "version": "2.0.3" + }, + "mysqlclient-2.0.3-py36h2531618_1.tar.bz2": { + "build": "py36h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "258e1ab992548b4120ad959f03bab3e2", + "name": "mysqlclient", + "sha256": "463b5b78a71939cc10f8a7ec7847e9e67fd96ce9fcb4925d223443c5d56ac7f9", + "size": 82763, + "subdir": "linux-64", + "timestamp": 1609786267405, + "version": "2.0.3" + }, + "mysqlclient-2.0.3-py37h2531618_1.tar.bz2": { + "build": "py37h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "9a01b4c86470ab8b5a33e03e3e7e8317", + "name": "mysqlclient", + "sha256": "5ac0e7f4c66f8d7ed4f4090c7d1f2a8f7ae140089a61dd93375cecf407ef703f", + "size": 82784, + "subdir": "linux-64", + "timestamp": 1609786274255, + "version": "2.0.3" + }, + "mysqlclient-2.0.3-py38h2531618_1.tar.bz2": { + "build": "py38h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "78d358dd1a392d4b865133843c71807d", + "name": "mysqlclient", + "sha256": "1de6d641878132c5c256f07be56de06685d4adcd6c296806cf9a76a14d400c5a", + "size": 83319, + "subdir": "linux-64", + "timestamp": 1609786298550, + "version": "2.0.3" + }, + "mysqlclient-2.0.3-py39h2531618_1.tar.bz2": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "f5a7aa9193c6c9b4a46c5247a15dcc12", + "name": "mysqlclient", + "sha256": "719627bf4863d8e9446971feb18d948b315e5b1c8e737a2efe8040c8b9a2a726", + "size": 83239, + "subdir": "linux-64", + "timestamp": 1609786164943, + "version": "2.0.3" + }, + "nasm-2.13.03-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD 2-Clause", + "md5": "7a09171bb01bff4a0d140ef10780b935", + "name": "nasm", + "sha256": "3e6baf03289fd85aaf3e9bf17d696d735178affb9d50cdc492c949686960fc97", + "size": 574059, + "subdir": "linux-64", + "timestamp": 1539874298448, + "version": "2.13.03" + }, + "nasm-2.13.03-h7b6447c_1.tar.bz2": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD 2-Clause", + "md5": "f3883d4a15b203716651dab112ffb39c", + "name": "nasm", + "sha256": "71fb1a0e461ef193161519caa0f64f5218b1ebaa6aaf59573c9a9badcf8a60bf", + "size": 574480, + "subdir": "linux-64", + "timestamp": 1539877373259, + "version": "2.13.03" + }, + "natsort-5.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "04f25fd1690d563f7d58f0745eea65d4", + "name": "natsort", + "sha256": "4e5e8755b2f10763cc7a157697c01f1c81eee5ec16cd1f21095bfb3f4b51b126", + "size": 51229, + "subdir": "linux-64", + "timestamp": 1519671801675, + "version": "5.2.0" + }, + "natsort-5.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "da4b68e8cebe9430cff4b5ebe6234cc5", + "name": "natsort", + "sha256": "752afad1450cd0964466e1040d48df756dcf2186bb11d394ecb161be95bd41c0", + "size": 52906, + "subdir": "linux-64", + "timestamp": 1519671819220, + "version": "5.2.0" + }, + "natsort-5.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "5043f1901e446fbde33ae1449f75007e", + "name": "natsort", + "sha256": "6876c1d87687e5877b04fc324625044811c0d54304eff43cb15ebe400d4021b8", + "size": 52637, + "subdir": "linux-64", + "timestamp": 1519671856458, + "version": "5.2.0" + }, + "natsort-5.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "954a49ac3d8d7bb5935d9536d846030e", + "name": "natsort", + "sha256": "7e69b7a4dbb564ffef1f8c55220a0d38f787441cbb9f057b17b373de2013cfa6", + "size": 51565, + "subdir": "linux-64", + "timestamp": 1524499316524, + "version": "5.3.0" + }, + "natsort-5.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "1adc60ab18e16141132c61f8977d3a9f", + "name": "natsort", + "sha256": "b7a71962bcc3577422d9a7e6e89ed79d5b19f1a6e91e54de21454c0b8e4a1a6e", + "size": 53249, + "subdir": "linux-64", + "timestamp": 1524499317430, + "version": "5.3.0" + }, + "natsort-5.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "09f7a4433c9d34067e52b1789c14b6df", + "name": "natsort", + "sha256": "3ab05027ab8d10e9761e976fd755ca4651981e659ea608a9689ee21fb7fc2746", + "size": 53058, + "subdir": "linux-64", + "timestamp": 1524499114519, + "version": "5.3.0" + }, + "natsort-5.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "8ca6eaf993f696210b4a8a4aac68f23c", + "name": "natsort", + "sha256": "61e0be5846bd35397e263651bf6b522374fb7616b6d38ef727b3b426efeca75b", + "size": 52489, + "subdir": "linux-64", + "timestamp": 1526918528412, + "version": "5.3.2" + }, + "natsort-5.3.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "878bdb0460367a51498059f71fb29b6f", + "name": "natsort", + "sha256": "58162161030769dd317386d37f64ffebddecf3544b1aea7dd765e7bb9e396f1e", + "size": 54266, + "subdir": "linux-64", + "timestamp": 1526918539517, + "version": "5.3.2" + }, + "natsort-5.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "74d74cf0116fc38b39005f35e51f15c9", + "name": "natsort", + "sha256": "6374cd44721d2ce203fa472e6e426af0da37aa3439f78a3b0df064054828cbbd", + "size": 54039, + "subdir": "linux-64", + "timestamp": 1526918498202, + "version": "5.3.2" + }, + "natsort-5.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e976edffda8b6990ffe0689d9fc44252", + "name": "natsort", + "sha256": "c034306f3adf51adb4215f7cb4f9f6885a9857dd23181686547bc3175563220b", + "size": 51586, + "subdir": "linux-64", + "timestamp": 1530900863422, + "version": "5.3.2" + }, + "natsort-5.3.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "58b77f1803ecf70a769333ace9095fee", + "name": "natsort", + "sha256": "d0d82bc61631d4ffbc16f643f49b080daa4980ad6c1245a876795e553912d566", + "size": 54326, + "subdir": "linux-64", + "timestamp": 1532628952893, + "version": "5.3.3" + }, + "natsort-5.3.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "048498073edcd90654ecdff3826bafef", + "name": "natsort", + "sha256": "68aaadc44bb5ce6e6679368eb4811f869dc212141a9eccb065a390d3192b010e", + "size": 56243, + "subdir": "linux-64", + "timestamp": 1532629003571, + "version": "5.3.3" + }, + "natsort-5.3.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "38ee1911bccadcae14c93ee8468ec502", + "name": "natsort", + "sha256": "a5cdd15ca416a35147c3c20e4245718e8f10ac8fc56a38b142663374c2e405fe", + "size": 55955, + "subdir": "linux-64", + "timestamp": 1532629201983, + "version": "5.3.3" + }, + "natsort-5.3.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "50bdb5f5e0b7a4be62db750ace018dab", + "name": "natsort", + "sha256": "e104ae2124f6a5774e3ea3220ec0d18e30b66c65778c4c4dbf2d2431a6eebc1d", + "size": 53329, + "subdir": "linux-64", + "timestamp": 1532629015866, + "version": "5.3.3" + }, + "natsort-5.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "91beb824e6c2a80d7278c92a44a51956", + "name": "natsort", + "sha256": "fd87a9a4bcce1da15af4f21e938d41d9f2b165da0d8fba871344458140455cfe", + "size": 56937, + "subdir": "linux-64", + "timestamp": 1538181352534, + "version": "5.4.0" + }, + "natsort-5.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "bc8588ccfd344c8f3f867be847e6037e", + "name": "natsort", + "sha256": "2b69ad7632767216d4739d5c42ee9a1deabc76771601d5cd9b0d66f92aad273e", + "size": 59018, + "subdir": "linux-64", + "timestamp": 1538181335515, + "version": "5.4.0" + }, + "natsort-5.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "94ae80caebb965917a9e2627bb2d379f", + "name": "natsort", + "sha256": "b52e285f974dd4e8da00db37b3f7cb2261bbdfb6e9cbfa080fd389d3d3e681e6", + "size": 55925, + "subdir": "linux-64", + "timestamp": 1538181331853, + "version": "5.4.0" + }, + "natsort-5.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d1b70c14f5c5af05eab91a24c52eae96", + "name": "natsort", + "sha256": "c7f94a34d9e3d004fcb1af5a7cbffbc2f9df79117c96ce55c3f4d3584dc1410c", + "size": 57379, + "subdir": "linux-64", + "timestamp": 1539641077049, + "version": "5.4.1" + }, + "natsort-5.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c2d24c5a0489a54532680e1945d7bd18", + "name": "natsort", + "sha256": "0e0cae62e9fa0a6c0229df0cebb47ff36ba9ee18a28bf4c64ef6616dd9dc5664", + "size": 59140, + "subdir": "linux-64", + "timestamp": 1539641085199, + "version": "5.4.1" + }, + "natsort-5.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1e8ef3bc71cb54b780075769caf55a31", + "name": "natsort", + "sha256": "f1f814b4a18077d793ed12b02c8cf185775fe70885951063cbdad5c8f061e12b", + "size": 56368, + "subdir": "linux-64", + "timestamp": 1539641081192, + "version": "5.4.1" + }, + "natsort-5.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "cc0b058c25cc062b2feed1d3a33828c4", + "name": "natsort", + "sha256": "d52fba9d5a7d7fecb98c65b0b9467d86b11c2be28f254e27d6c318e269954ad2", + "size": 58775, + "subdir": "linux-64", + "timestamp": 1542640546532, + "version": "5.5.0" + }, + "natsort-5.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "72b3541755a34d39d2d033303f28981c", + "name": "natsort", + "sha256": "723793c72560e71ab5c445e89d10776ae5f27d07d25eec05913d673a9c65c975", + "size": 60761, + "subdir": "linux-64", + "timestamp": 1542640578796, + "version": "5.5.0" + }, + "natsort-5.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a3186d1149db4622b217259fb0558459", + "name": "natsort", + "sha256": "b717867d4230712cf7bd8f393c01bea33f595246c5b07905b9fc422347b51ae0", + "size": 57788, + "subdir": "linux-64", + "timestamp": 1542640520824, + "version": "5.5.0" + }, + "navigator-updater-0.1.0-py27h0f9cd39_0.tar.bz2": { + "build": "py27h0f9cd39_0", + "build_number": 0, + "depends": [ + "pyqt >=5.6", + "python >=2.7,<2.8.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "384bcde4bce561871f29293910e82c05", + "name": "navigator-updater", + "sha256": "793a1d0f97d4223c0606c129ecae8e42ae73d4fc73ff6e03199f25789f5e36a3", + "size": 1282434, + "subdir": "linux-64", + "timestamp": 1505852418043, + "version": "0.1.0" + }, + "navigator-updater-0.1.0-py35h2ff6758_0.tar.bz2": { + "build": "py35h2ff6758_0", + "build_number": 0, + "depends": [ + "pyqt >=5.6", + "python >=3.5,<3.6.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "ed4780b6e27af1c0c7e45d26600949c3", + "name": "navigator-updater", + "sha256": "f0eeb6e205634c01c8e6661e786e9ce954835db68b3d1be0bf932156574ec782", + "size": 1284909, + "subdir": "linux-64", + "timestamp": 1505852435849, + "version": "0.1.0" + }, + "navigator-updater-0.1.0-py36h14770f7_0.tar.bz2": { + "build": "py36h14770f7_0", + "build_number": 0, + "depends": [ + "pyqt >=5.6", + "python >=3.6,<3.7.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "1282d174a04fcb814c6d8272349c93d0", + "name": "navigator-updater", + "sha256": "07c45c5c5a5ec540ef06593c75d99a57321f17fdf8ca32b301f7fb912f566ee5", + "size": 1285487, + "subdir": "linux-64", + "timestamp": 1505852453838, + "version": "0.1.0" + }, + "navigator-updater-0.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=2.7,<2.8.0a0", + "qtpy" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "5180f33ced5b09cbe03c5934dab45dbb", + "name": "navigator-updater", + "sha256": "e23fe95efbb2c356071a306d4caa8e2b68ba9cfc3794dd15da940035eb660b50", + "size": 1301439, + "subdir": "linux-64", + "timestamp": 1524671901356, + "version": "0.2.0" + }, + "navigator-updater-0.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.5,<3.6.0a0", + "qtpy" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "485de5e3d77924218e1b5e4098051094", + "name": "navigator-updater", + "sha256": "6211b1fdb355e7bfe8a01ed07d853d4549fb4516fab3fee629ad1a73c4dfb1ae", + "size": 1303758, + "subdir": "linux-64", + "timestamp": 1524671938622, + "version": "0.2.0" + }, + "navigator-updater-0.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.6,<3.7.0a0", + "qtpy" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "40780ed3bf912164670e4c89689284a8", + "name": "navigator-updater", + "sha256": "7fa6eeae1150b25c236d29e7f80e9ab70d4fdaac76fa89355ab396df75c58f7d", + "size": 1304111, + "subdir": "linux-64", + "timestamp": 1524671976329, + "version": "0.2.0" + }, + "navigator-updater-0.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyqt >=5.6", + "python >=2.7,<2.8.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "c12308a9ba29fb41a3a73b3d3d48a3d3", + "name": "navigator-updater", + "sha256": "7cad9d0c637fa900096a950427c98249b963cc8bd460e140b964f75f1b1ecf8d", + "size": 1301874, + "subdir": "linux-64", + "timestamp": 1527013162953, + "version": "0.2.1" + }, + "navigator-updater-0.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyqt >=5.6", + "python >=3.5,<3.6.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "d21ee63d2e3a4b4484ad7fdbed9a7ae0", + "name": "navigator-updater", + "sha256": "302ec53e0914f4b13e4c4270f39b680576885759c75fa8a542e4db259b1ef5e9", + "size": 1305321, + "subdir": "linux-64", + "timestamp": 1527013238264, + "version": "0.2.1" + }, + "navigator-updater-0.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyqt >=5.6", + "python >=3.6,<3.7.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "7f5627ebb24bfd76af4cf9b9770df446", + "name": "navigator-updater", + "sha256": "d65309e81f02d1e7b91822487cb11cd1fda983a7e8b0d328b2707b001ffccfea", + "size": 1305514, + "subdir": "linux-64", + "timestamp": 1527013199875, + "version": "0.2.1" + }, + "navigator-updater-0.2.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "psutil", + "pyqt >=5.6", + "python >=3.6,<3.7.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "24017ad62af2351baa2aeb32c00aed98", + "name": "navigator-updater", + "sha256": "e3b45ed556ddcb2d1453700a00f8b692aa75f5197d794aa4850c9b01c54febd2", + "size": 1327156, + "subdir": "linux-64", + "timestamp": 1641962611409, + "version": "0.2.1" + }, + "navigator-updater-0.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyqt >=5.6", + "python >=3.7,<3.8.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "54cd705389ec842f2255c768b7bf7112", + "name": "navigator-updater", + "sha256": "7aa42c7317041b316b65f1093e45f341e5817467bdf7e08a437fe070c407ad3c", + "size": 1304546, + "subdir": "linux-64", + "timestamp": 1531492426460, + "version": "0.2.1" + }, + "navigator-updater-0.2.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "psutil", + "pyqt >=5.6", + "python >=3.7,<3.8.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "cdde04b2cf38c647b4885a2781676d54", + "name": "navigator-updater", + "sha256": "99f8d6aa4edd18b8e1d12db3b01deb891adeba749caaa3712bdc0b25d7378442", + "size": 1305902, + "subdir": "linux-64", + "timestamp": 1641965704226, + "version": "0.2.1" + }, + "navigator-updater-0.2.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pyqt >=5.6", + "python >=3.8,<3.9.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "12b7431593f7d1e17ba37d0d6b7922b9", + "name": "navigator-updater", + "sha256": "61a4010f0c754e8b23ecbcb9ee6673ba2661646614d955fca706d3255221cd25", + "size": 1344491, + "subdir": "linux-64", + "timestamp": 1593556142641, + "version": "0.2.1" + }, + "navigator-updater-0.2.1-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "psutil", + "pyqt >=5.6", + "python >=3.8,<3.9.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "410ac3b5dc5cabdbefc1f733df0cf7a3", + "name": "navigator-updater", + "sha256": "1331449970052af58663d1a96c233d7b1dc0d98dda30c9be4b213dea2222d855", + "size": 1327632, + "subdir": "linux-64", + "timestamp": 1641980718513, + "version": "0.2.1" + }, + "navigator-updater-0.2.1-py39_1.tar.bz2": { + "build": "py39_1", + "build_number": 1, + "depends": [ + "psutil", + "pyqt >=5.6", + "python >=3.9,<3.10.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "17178b9af62511d37896b45155870557", + "name": "navigator-updater", + "sha256": "ffcf6bbc5898780c6f33bdc37a9087f1895047be4cf378ed7468338f769abcd4", + "size": 1309174, + "subdir": "linux-64", + "timestamp": 1641980718266, + "version": "0.2.1" + }, + "navigator-updater-0.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt >=5.6", + "python >=3.9,<3.10.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "3f6ca1254e59b0e2e165cadd1bff5936", + "name": "navigator-updater", + "sha256": "253fdb49d3b5eb8b14224ee0105aa7c0a208b5c818fd6486c271771cbdd7d962", + "size": 1315151, + "subdir": "linux-64", + "timestamp": 1608053504297, + "version": "0.2.1" + }, + "navigator-updater-0.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=17.5.0", + "cryptography >=3.3.2", + "libxml2 >=2.9.10", + "expat >=2.2.8", + "openssl >=1.1.1k", + "urllib3 >=1.26.4" + ], + "depends": [ + "conda", + "psutil >=5.6.5", + "pyqt >=5.6,<6.0a0", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "setuptools", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "75d4c35d7e34aa9d992e5d04a1bd6873", + "name": "navigator-updater", + "sha256": "46b286d686abbd7439b5bdaabd8083573847fe6d9f4f061e0de87c5f39b40b63", + "size": 3198057, + "subdir": "linux-64", + "timestamp": 1662476055423, + "version": "0.3.0" + }, + "navigator-updater-0.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=17.5.0", + "cryptography >=3.3.2", + "libxml2 >=2.9.10", + "expat >=2.2.8", + "openssl >=1.1.1k", + "urllib3 >=1.26.4" + ], + "depends": [ + "conda", + "psutil >=5.6.5", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "setuptools", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "cd448bb0191ec2e220c8b15112a6df37", + "name": "navigator-updater", + "sha256": "47ee13cd8126bb17d7d69619c41c0f7d9da7551d947d358d6147eb468bd95d81", + "size": 3196381, + "subdir": "linux-64", + "timestamp": 1662476098419, + "version": "0.3.0" + }, + "navigator-updater-0.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=17.5.0", + "cryptography >=3.3.2", + "libxml2 >=2.9.10", + "expat >=2.2.8", + "openssl >=1.1.1k", + "urllib3 >=1.26.4" + ], + "depends": [ + "conda", + "psutil >=5.6.5", + "pyqt >=5.6,<6.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "setuptools", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "85e6d9b11476806835d37d260370a7a6", + "name": "navigator-updater", + "sha256": "1d4219ed8299a6d4f378ea7f52b435ea5c475c6f4530d077f69862459e9ddca6", + "size": 3197262, + "subdir": "linux-64", + "timestamp": 1662475991355, + "version": "0.3.0" + }, + "navigator-updater-0.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=17.5.0", + "cryptography >=3.3.2", + "libxml2 >=2.9.10", + "expat >=2.2.8", + "openssl >=1.1.1k", + "urllib3 >=1.26.4" + ], + "depends": [ + "conda", + "psutil >=5.6.5", + "pyqt >=5.6,<6.0a0", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "setuptools", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "61f81a9f998beddc5174a54117d6ecac", + "name": "navigator-updater", + "sha256": "d7d419aacac62342daf86a8dda77d699e7a64ac3f4a48685b0a9c492b640bc2f", + "size": 3197346, + "subdir": "linux-64", + "timestamp": 1662475941081, + "version": "0.3.0" + }, + "nb_anacondacloud-1.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b30a651ff2a2a7196e835ffa00f24669", + "name": "nb_anacondacloud", + "sha256": "e2a855a9115aea35cb6c3360032578738b9997bd7e947978f48735235bbd05a5", + "size": 29589, + "subdir": "linux-64", + "timestamp": 1641918412510, + "version": "1.4.0" + }, + "nb_anacondacloud-1.4.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "aa30c7947856aaae12c1e4c08b7abc40", + "name": "nb_anacondacloud", + "sha256": "de8b8af347f274baf4726f68ac781cb6aae4a09686269c6a4ba9c7a5cf774996", + "size": 36066, + "subdir": "linux-64", + "timestamp": 1676929504359, + "version": "1.4.0" + }, + "nb_anacondacloud-1.4.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "anaconda-client", + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "096af8a983e597ec86eb77b7ef9456ba", + "name": "nb_anacondacloud", + "sha256": "b59cc51e3d52948319b106a9e08ed38de1314dc32b59fb34df517e05f62f42ab", + "size": 28616, + "subdir": "linux-64", + "timestamp": 1594376401880, + "version": "1.4.0" + }, + "nb_anacondacloud-1.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "bf48f242015c2556d1fbf5bd959088ed", + "name": "nb_anacondacloud", + "sha256": "60df29c9b0c36a3d149eef1b09eee15da93ff3f6c7d4877f6f3bc00e30ddc8f8", + "size": 31399, + "subdir": "linux-64", + "timestamp": 1636039103552, + "version": "1.4.0" + }, + "nb_anacondacloud-1.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ed7deee65f0bcdc72e19f4abbc8504e6", + "name": "nb_anacondacloud", + "sha256": "e8ddd3ecd02110d23cd04407e4b7dfb5cc2a43c2133f76e0fb65f2425bf64d9f", + "size": 31473, + "subdir": "linux-64", + "timestamp": 1636039011538, + "version": "1.4.0" + }, + "nb_anacondacloud-1.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ded18d6b0711abc23f9d8c26633c36d4", + "name": "nb_anacondacloud", + "sha256": "451039c28c95ba03a015a073997d5495e1856abc806aca9e1a1662ee392e9396", + "size": 31484, + "subdir": "linux-64", + "timestamp": 1636039103612, + "version": "1.4.0" + }, + "nb_conda-2.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "15f5ed2b8216e23dd6f3f733217ed6d5", + "name": "nb_conda", + "sha256": "509d5129286b7716866a58e012e0082bcd9ddfbff0f36505def417ab0eb64d26", + "size": 33232, + "subdir": "linux-64", + "timestamp": 1530901089138, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py27hec22543_0.tar.bz2": { + "build": "py27hec22543_0", + "build_number": 0, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "bf6d0c43c6c5cf61adce43335702796f", + "name": "nb_conda", + "sha256": "4f1117c470a366703d389dad1f10f4d315e3197a47a878bc539359b69e05ec58", + "size": 33520, + "subdir": "linux-64", + "timestamp": 1505746143309, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "53904ab18dde8819354dc13530dcd19f", + "name": "nb_conda", + "sha256": "3286f5124a1b30434e602dafdede628ce4dd87c3c5b0c0fadcd07cf0a2e98f8b", + "size": 34620, + "subdir": "linux-64", + "timestamp": 1641918478473, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "35843d79de629ed638d2e4b470a4fdcd", + "name": "nb_conda", + "sha256": "e3bf263d74db8bf329a7b6ce8e9ec0bf56564b7f0249fe0e5a0550a01cb1399c", + "size": 41621, + "subdir": "linux-64", + "timestamp": 1676922449283, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py35hccc8299_0.tar.bz2": { + "build": "py35hccc8299_0", + "build_number": 0, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "md5": "288c7013c1bb6d904fa822651c3cc145", + "name": "nb_conda", + "sha256": "c786bb83297263b30c652e0b8d1ddc70b953b0b3bbebc660d415842f91f27f2d", + "size": 33998, + "subdir": "linux-64", + "timestamp": 1505746162949, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "17c36aaf49d352573125a56d72fc55dd", + "name": "nb_conda", + "sha256": "68e1036f8eddfd5d788addcee53e0bbae4d4db2e4862e6d1b9df9fcb5b74867c", + "size": 33791, + "subdir": "linux-64", + "timestamp": 1530901047099, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py36h8118bb2_0.tar.bz2": { + "build": "py36h8118bb2_0", + "build_number": 0, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f2313de32c132adb6aef02c34e3edd7c", + "name": "nb_conda", + "sha256": "67d85c307bb3f11fc4c1497ded5c9c03ee3e1968756faa1a741d5ce5df1badad", + "size": 33979, + "subdir": "linux-64", + "timestamp": 1505746183638, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "535b13f82fa3b7e6361b54124b6c0e5a", + "name": "nb_conda", + "sha256": "fd7ce0ee7d7769e56e5e7a036380ed32e00f105072cff86c644a50ac73351f79", + "size": 33913, + "subdir": "linux-64", + "timestamp": 1530901005723, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "db3fe85c8cfa27283a7d4a448392bbbb", + "name": "nb_conda", + "sha256": "e3d88c901c2ff179b3421127c6ede25ea356e542fe0d83dd5269916c509cfece", + "size": 35232, + "subdir": "linux-64", + "timestamp": 1636039129365, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "28d070152f18cc908da825b2c42382dc", + "name": "nb_conda", + "sha256": "0095c330ef05194aa8f3894e3b541702eb1b815aec7dce79ac83dc9ece049551", + "size": 35494, + "subdir": "linux-64", + "timestamp": 1597176851232, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7bda453031040986a1e821b3a8e20f82", + "name": "nb_conda", + "sha256": "260cc00b1484fd0d2bb4d973b7f94afd11086be9f11b058b59e964ffd6569bd4", + "size": 35428, + "subdir": "linux-64", + "timestamp": 1636039102878, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "3db3527f943ebf5faf8215a56d75e99d", + "name": "nb_conda", + "sha256": "729035f26585ee6c61837e81cea57afcfa521639fb2a7a57f30e0a7021024c0c", + "size": 35425, + "subdir": "linux-64", + "timestamp": 1636027104867, + "version": "2.2.1" + }, + "nb_conda_kernels-2.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7caa4a8215a5114ee263bf58d33d76f9", + "name": "nb_conda_kernels", + "sha256": "c399a81295e7f386033b10bfad188c30a65dedd4743dee53e2689868f933ed5f", + "size": 36081, + "subdir": "linux-64", + "timestamp": 1530900962715, + "version": "2.1.0" + }, + "nb_conda_kernels-2.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5573101046697677d30f1f78743fdc46", + "name": "nb_conda_kernels", + "sha256": "ee632d269f3c36ce569cfa34500fb8164a5da0433c5732d7d8e9a455ac725e4d", + "size": 36417, + "subdir": "linux-64", + "timestamp": 1530900930267, + "version": "2.1.0" + }, + "nb_conda_kernels-2.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "eca7a2045a9e59d0efa14ffb26af1b59", + "name": "nb_conda_kernels", + "sha256": "f2039dd859b92392c52aaf6f1aa0f3fc1d613707850cbc477752c0f4c4bb0107", + "size": 36488, + "subdir": "linux-64", + "timestamp": 1530900896590, + "version": "2.1.0" + }, + "nb_conda_kernels-2.1.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1388064852f1bdf076ffedb9e44e6fcf", + "name": "nb_conda_kernels", + "sha256": "4c009af9a4758f8f861d6dc50c2d9256b575db8d334b5db2ddac57abc9911f6a", + "size": 38244, + "subdir": "linux-64", + "timestamp": 1539189679365, + "version": "2.1.1" + }, + "nb_conda_kernels-2.1.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "83c8200bb96ac91b30e7576e7f208813", + "name": "nb_conda_kernels", + "sha256": "9cc04246e0aeb03ba6f3895ae3c4b60f16821b2462e6ac2e3b6abb5216c7ab29", + "size": 38596, + "subdir": "linux-64", + "timestamp": 1539189690708, + "version": "2.1.1" + }, + "nb_conda_kernels-2.1.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6962cc6da4c666b0cf833da2e55a6efa", + "name": "nb_conda_kernels", + "sha256": "cca0d6b12f339b01d667fa71851bf2e72cbe6ed861e36a3f82f9e6a7bb649afe", + "size": 38679, + "subdir": "linux-64", + "timestamp": 1539189688153, + "version": "2.1.1" + }, + "nb_conda_kernels-2.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2a5e09a82845d852ab0b9ece647aff13", + "name": "nb_conda_kernels", + "sha256": "8dcd14fc3d7893cf61363dabac370dcf3e530457ac1f1bbafcd2747090bc430b", + "size": 32470, + "subdir": "linux-64", + "timestamp": 1541446970833, + "version": "2.2.0" + }, + "nb_conda_kernels-2.2.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "59ee16065458afe134e8840045e90ad3", + "name": "nb_conda_kernels", + "sha256": "ac76464ce919361c2d1765c3f961d6974309a98710d5f056b5838c225e52a114", + "size": 37163, + "subdir": "linux-64", + "timestamp": 1549986906228, + "version": "2.2.0" + }, + "nb_conda_kernels-2.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2b71e68dff6fa2ee50adaae7a9f808b4", + "name": "nb_conda_kernels", + "sha256": "b6d7ac6ce8720a608f80d9d20a40d3d970f5be520914c0d1234c33bda9006d35", + "size": 32832, + "subdir": "linux-64", + "timestamp": 1541446995398, + "version": "2.2.0" + }, + "nb_conda_kernels-2.2.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3b8eda656d20f6dc29632e1cb9a60984", + "name": "nb_conda_kernels", + "sha256": "0b3dbee4757cad6abd17f23938d278422c9175529dbf6bc80159394c973cffcf", + "size": 37495, + "subdir": "linux-64", + "timestamp": 1549986911389, + "version": "2.2.0" + }, + "nb_conda_kernels-2.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d057a7daa9a263e867247fc1a478f6be", + "name": "nb_conda_kernels", + "sha256": "478daa525d9dc7ee825551a8a9301dd32ae35c5eb0ce4870a063dae8f525b68a", + "size": 32887, + "subdir": "linux-64", + "timestamp": 1541446954077, + "version": "2.2.0" + }, + "nb_conda_kernels-2.2.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6093cd9f9661041703dba9b283fb3e93", + "name": "nb_conda_kernels", + "sha256": "86bd9991481806f6621f14cce155f4210d3af59706f76445f37c53bd56324670", + "size": 37501, + "subdir": "linux-64", + "timestamp": 1549986892056, + "version": "2.2.0" + }, + "nb_conda_kernels-2.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2c1ec3f70113f66984fa9f1a041dfecc", + "name": "nb_conda_kernels", + "sha256": "a2f3bb12b3f9abbe4e7a6ddb9c096d1dea78203a955d3ecc71452448a1e38c46", + "size": 37341, + "subdir": "linux-64", + "timestamp": 1556291027105, + "version": "2.2.1" + }, + "nb_conda_kernels-2.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a037e06e161d9ad7747ab20c61ea89e1", + "name": "nb_conda_kernels", + "sha256": "a86c94c65f0c110c51b724fa32190b8ae623ef09bda838e39cf65ca84e08ded7", + "size": 37705, + "subdir": "linux-64", + "timestamp": 1556291055922, + "version": "2.2.1" + }, + "nb_conda_kernels-2.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cc234ec3a2e897056e2f89c8bd423a12", + "name": "nb_conda_kernels", + "sha256": "7c19007ce5a4c7a57a8797f970f446d1620e42904064c14e3bf5ed1387e2e80a", + "size": 37764, + "subdir": "linux-64", + "timestamp": 1556291024643, + "version": "2.2.1" + }, + "nb_conda_kernels-2.2.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fb66787f5481639531715f43eb27e5b4", + "name": "nb_conda_kernels", + "sha256": "ce3c8818164133247093453a07108ed4ab02615f5b7b06803ba4225fc6976cdb", + "size": 37922, + "subdir": "linux-64", + "timestamp": 1559921265476, + "version": "2.2.2" + }, + "nb_conda_kernels-2.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b5a818870d0849825ba826cc15e052a5", + "name": "nb_conda_kernels", + "sha256": "d9fe1e6ab99a1b3ca94ad034d5034ef529faa0479840a456437d20284897a5fe", + "size": 38287, + "subdir": "linux-64", + "timestamp": 1559921284807, + "version": "2.2.2" + }, + "nb_conda_kernels-2.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "41b638c3ac4bc9e56f02c2f6aadb3c9e", + "name": "nb_conda_kernels", + "sha256": "03606a6bc2cfd27f40d916afba564f6639d5922e910a9af85132723ffe62166f", + "size": 38333, + "subdir": "linux-64", + "timestamp": 1559921258304, + "version": "2.2.2" + }, + "nb_conda_kernels-2.2.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "eafb159f0233dca8dc09de9cd9e57789", + "name": "nb_conda_kernels", + "sha256": "078578818ac6db698934bd754c0fc39c3177b44bcfc3bc6c4d371fbab98f901f", + "size": 38961, + "subdir": "linux-64", + "timestamp": 1585176300019, + "version": "2.2.3" + }, + "nb_conda_kernels-2.2.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c58ed700f4f13f537101cb35924aa998", + "name": "nb_conda_kernels", + "sha256": "5671243bca1cdf69a0e51cfd24bc2eb86bcdb1e667473c2f8291f1c2343d2e19", + "size": 38999, + "subdir": "linux-64", + "timestamp": 1585176246222, + "version": "2.2.3" + }, + "nb_conda_kernels-2.2.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5b7177d86b27821fcc3167f9f313e927", + "name": "nb_conda_kernels", + "sha256": "8aca005be87c62b55c50e7b8fb04e4ca6c69ebed3286f3994d9ce3d084d7d352", + "size": 39079, + "subdir": "linux-64", + "timestamp": 1585176297827, + "version": "2.2.3" + }, + "nb_conda_kernels-2.2.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3e5b983ca2b94f1147d4b2893a9945f1", + "name": "nb_conda_kernels", + "sha256": "d1648d88ae54887e23fbc361fda1a52b3f663cdbfe7e91eb49869f0153756a73", + "size": 29255, + "subdir": "linux-64", + "timestamp": 1598624818995, + "version": "2.2.4" + }, + "nb_conda_kernels-2.2.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c2dd3d3bf269ad3b693b631a2c4d4636", + "name": "nb_conda_kernels", + "sha256": "0360505b8197aeef0edde69220558ef85d1eb3a345f620e37664460333cb8bbf", + "size": 29289, + "subdir": "linux-64", + "timestamp": 1598624835807, + "version": "2.2.4" + }, + "nb_conda_kernels-2.2.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5c9d8d2d21686204f3b87ae4971a23d6", + "name": "nb_conda_kernels", + "sha256": "fda5658e2481682c7e4372fed84a0a459653f4e56c10c2785ec7402a3d78ca58", + "size": 29325, + "subdir": "linux-64", + "timestamp": 1598624798573, + "version": "2.2.4" + }, + "nb_conda_kernels-2.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dcfe053fb73ec89d8c8c811a446f0158", + "name": "nb_conda_kernels", + "sha256": "52a3d054b480d3dbdfee58650ec560a9fb9449afeda43c198a8063647a4065ad", + "size": 25714, + "subdir": "linux-64", + "timestamp": 1600445383416, + "version": "2.3.0" + }, + "nb_conda_kernels-2.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f66b02080081fdc94a33330ad93f4186", + "name": "nb_conda_kernels", + "sha256": "1cb702917334f058c63f23ea60c68923814d15e444b389a4729ee224cb3a8bad", + "size": 25736, + "subdir": "linux-64", + "timestamp": 1600445367338, + "version": "2.3.0" + }, + "nb_conda_kernels-2.3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "31a40009087d8278a17fdeeb162a59a1", + "name": "nb_conda_kernels", + "sha256": "950c2b7ed95b22a47316b0e6399bd49d0976f325e8931f1d8e366661255acaba", + "size": 25815, + "subdir": "linux-64", + "timestamp": 1600445366743, + "version": "2.3.0" + }, + "nb_conda_kernels-2.3.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "71aa8d32a9574e9bd5ae8d15eb49b4a0", + "name": "nb_conda_kernels", + "sha256": "37bd46bdb5eb5ba44a0569a8a0efd9e4649ab309c8a29f9f5160e8f94d178b46", + "size": 27672, + "subdir": "linux-64", + "timestamp": 1640815352004, + "version": "2.3.1" + }, + "nb_conda_kernels-2.3.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "md5": "851063ff71c53e3e71ab42f98043056d", + "name": "nb_conda_kernels", + "sha256": "fc36bb42158193b0427438a4b42bb12c9f1703155e1a86481da2412c944be969", + "size": 34613, + "subdir": "linux-64", + "timestamp": 1676845038638, + "version": "2.3.1" + }, + "nb_conda_kernels-2.3.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d4243d361aebfbd34f9e386bf474b4cb", + "name": "nb_conda_kernels", + "sha256": "08d9fc634eeda535698917e203da04beaacb4e208b8e715e269b7d136e184f86", + "size": 27629, + "subdir": "linux-64", + "timestamp": 1606776021501, + "version": "2.3.1" + }, + "nb_conda_kernels-2.3.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f101f13f00fcc4277412f19164124476", + "name": "nb_conda_kernels", + "sha256": "cc8fa25787622c1a002f928e97156fcc1e509d96f23f238c57947897ee0fc130", + "size": 27635, + "subdir": "linux-64", + "timestamp": 1606776024500, + "version": "2.3.1" + }, + "nb_conda_kernels-2.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6c319e9bb44bd369e2430cb12a36514c", + "name": "nb_conda_kernels", + "sha256": "b486a74c4663f49f9f3544527c7e18bfe4c3165ff3d1ef1fc1c2103f6d9ee46e", + "size": 27683, + "subdir": "linux-64", + "timestamp": 1606775970765, + "version": "2.3.1" + }, + "nb_conda_kernels-2.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d273d93465a801af7d73dd9a56a39539", + "name": "nb_conda_kernels", + "sha256": "ddde0cf6b69b0b356265cf22779f157875309423a0aa1e3d52ce201779f54ceb", + "size": 33246, + "subdir": "linux-64", + "timestamp": 1636035820383, + "version": "2.3.1" + }, + "nbclassic-0.4.8-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9010e919faa5251bfa7c220e7b81bdf2", + "name": "nbclassic", + "sha256": "8b1b18c1a091047375e220dbd2f0458fe1d62949d1ac7b0935110626d88adb8e", + "size": 8101572, + "subdir": "linux-64", + "timestamp": 1668175216755, + "version": "0.4.8" + }, + "nbclassic-0.4.8-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "947072a516ba4bb01fb4295cc5674b8a", + "name": "nbclassic", + "sha256": "ca9239d0e27f4df6a1774bb3d8c6c18e37662a9b2b2a7ce561ec9c8b78b63bb5", + "size": 8183935, + "subdir": "linux-64", + "timestamp": 1676825366127, + "version": "0.4.8" + }, + "nbclassic-0.4.8-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6d369116b4a6716884a044b28493daa3", + "name": "nbclassic", + "sha256": "16d5e050e68248f006f875f3ed05909a2bcdd276114a5f3a414c58a614a9703d", + "size": 8117884, + "subdir": "linux-64", + "timestamp": 1668175011997, + "version": "0.4.8" + }, + "nbclassic-0.4.8-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e6196e16fdce1f78e5d23c84a6ddb554", + "name": "nbclassic", + "sha256": "0043b78b2f6e1931a752dd8a25a792d1718298db881031ca65bb91951b4a461f", + "size": 8116675, + "subdir": "linux-64", + "timestamp": 1668175149287, + "version": "0.4.8" + }, + "nbclassic-0.4.8-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "41670f7755f688e37350f90358f0b25d", + "name": "nbclassic", + "sha256": "0921ccf5f3e47654b22ce6505d82118dae40afc6357e75a5e8546e0f57b666c1", + "size": 8116186, + "subdir": "linux-64", + "timestamp": 1668175081374, + "version": "0.4.8" + }, + "nbclassic-0.5.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dd9f11192280c6588ec5a69f5ffabf97", + "name": "nbclassic", + "sha256": "3bbaee9a83b576b55e3393c68ddfc79814673fffbde7c03b1e254d25fc488c9e", + "size": 8180340, + "subdir": "linux-64", + "timestamp": 1676903214164, + "version": "0.5.2" + }, + "nbclassic-0.5.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "71db01c689cabc03d5e60ef35da18ee9", + "name": "nbclassic", + "sha256": "c3c2e264e2a2da65703036aeab64db62cac2b9397f7e58257721ea9b6e6ccecb", + "size": 8135340, + "subdir": "linux-64", + "timestamp": 1678983537685, + "version": "0.5.2" + }, + "nbclassic-0.5.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a31587af356b645375dcc18ef3cf24c7", + "name": "nbclassic", + "sha256": "e1b489b72248c8f49f15a29ef550a46c685e4933b18bc4bb4cdf8d5fda8d2dc3", + "size": 8182185, + "subdir": "linux-64", + "timestamp": 1676903058740, + "version": "0.5.2" + }, + "nbclassic-0.5.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d713d4ec574b3c1257db635480d0d3f", + "name": "nbclassic", + "sha256": "ce23aa7927da81fb73c2b2c71466fc22d7bce5654207a8ebcc4ad9395fe7b9e3", + "size": 8180874, + "subdir": "linux-64", + "timestamp": 1676902974274, + "version": "0.5.2" + }, + "nbclassic-0.5.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8839a459964a290927d84c53fc556397", + "name": "nbclassic", + "sha256": "6d0917c34948e83ccb4db2deaaf1cb04cfc9834fc8117d24f8922987135f86e1", + "size": 8165985, + "subdir": "linux-64", + "timestamp": 1676903136597, + "version": "0.5.2" + }, + "nbclassic-0.5.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.8", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8727b446c736473bfb42781f9529cae2", + "name": "nbclassic", + "sha256": "bc4f4d06e7f688840fd121ece6a68301f809d4738a3868a4b02ecf5314ece908", + "size": 8281977, + "subdir": "linux-64", + "timestamp": 1680009103075, + "version": "0.5.3" + }, + "nbclassic-0.5.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.8", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ce693ee4f00b9e2b86c44c302f2711a0", + "name": "nbclassic", + "sha256": "8e5d88c15d0e36f8533077472b9b08cc18f2684ab9283a44e357325f39f0f241", + "size": 8302386, + "subdir": "linux-64", + "timestamp": 1680008849118, + "version": "0.5.3" + }, + "nbclassic-0.5.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.8", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "37e28fa03eb32cd4e70fa419d420f276", + "name": "nbclassic", + "sha256": "eae9c11b24164bffc09f9b1d91124425fa5554aa9dcb1abbb187c78dc2db7546", + "size": 8255174, + "subdir": "linux-64", + "timestamp": 1680008932793, + "version": "0.5.3" + }, + "nbclassic-0.5.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.8", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fcc8e56b18dd810cab393d19a65da572", + "name": "nbclassic", + "sha256": "45f959dd2787ca0f3fbc80dabd147517a0abe0e0e2bf83463105368bd414126c", + "size": 8279709, + "subdir": "linux-64", + "timestamp": 1680009018302, + "version": "0.5.3" + }, + "nbclassic-0.5.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.8", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ffea3c95bad47e8985c5ac31853f2ac7", + "name": "nbclassic", + "sha256": "b735e3453cffdd0fffdf17ede78ccf8bf298dcb50f97236213dbe3ef773b1d09", + "size": 8119064, + "subdir": "linux-64", + "timestamp": 1680622955710, + "version": "0.5.4" + }, + "nbclassic-0.5.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.8", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "09af38c15c3aee2995a0061b0111f059", + "name": "nbclassic", + "sha256": "19130d4afe702dcc5863121d08a9fa6ece713227b9ade6027b40e4613641f1dc", + "size": 8174444, + "subdir": "linux-64", + "timestamp": 1680622864320, + "version": "0.5.4" + }, + "nbclassic-0.5.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.8", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "19c93f5661544f9994545215dae0f652", + "name": "nbclassic", + "sha256": "c481c5c2914fd8569fd7d5dd765948a28be0c718710e51a0ea906ac3cf2aca34", + "size": 8134649, + "subdir": "linux-64", + "timestamp": 1680623048427, + "version": "0.5.4" + }, + "nbclassic-0.5.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.8", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ab38afd7fd5a290556a198572cdb3f6d", + "name": "nbclassic", + "sha256": "09123f7aeb3e961197603bad43e9a55e7c060e3960ecd9ba9e3510736153815a", + "size": 8133358, + "subdir": "linux-64", + "timestamp": 1680622772030, + "version": "0.5.4" + }, + "nbclient-0.5.13-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=6.1.5", + "nbformat >=5.0", + "nest-asyncio", + "python >=3.10,<3.11.0a0", + "traitlets >=5.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dbb43e77b5e495a1bd256459f9dd2d76", + "name": "nbclient", + "sha256": "e98c9c94fbc68a28dff1d259f5e5a12b181644ed0461dd8939076830d4caa87e", + "size": 99326, + "subdir": "linux-64", + "timestamp": 1650290293630, + "version": "0.5.13" + }, + "nbclient-0.5.13-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=6.1.5", + "nbformat >=5.0", + "nest-asyncio", + "python >=3.11,<3.12.0a0", + "traitlets >=5.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0f30b77f2efb7e2cd6a5b3855bf93168", + "name": "nbclient", + "sha256": "84c03811f7ab111ce037f3b835646ef3bd021cb1d39ced104877b95f12700d1d", + "size": 117731, + "subdir": "linux-64", + "timestamp": 1676823727061, + "version": "0.5.13" + }, + "nbclient-0.5.13-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=6.1.5", + "nbformat >=5.0", + "nest-asyncio", + "python >=3.7,<3.8.0a0", + "traitlets >=5.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e148c667f84d8d52d2207cc914793831", + "name": "nbclient", + "sha256": "87c13592eee69e21a06c608157c3c00c5b860c2c183368b9085eaaf13e73a517", + "size": 98325, + "subdir": "linux-64", + "timestamp": 1650308409006, + "version": "0.5.13" + }, + "nbclient-0.5.13-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=6.1.5", + "nbformat >=5.0", + "nest-asyncio", + "python >=3.8,<3.9.0a0", + "traitlets >=5.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a21ae11a8a79a3c621fee4baf252f2c", + "name": "nbclient", + "sha256": "27b620c69e97894d21c2477b29b49f32146c984d89cb6506ed13d4447719d3c0", + "size": 98761, + "subdir": "linux-64", + "timestamp": 1650308401439, + "version": "0.5.13" + }, + "nbclient-0.5.13-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=6.1.5", + "nbformat >=5.0", + "nest-asyncio", + "python >=3.9,<3.10.0a0", + "traitlets >=5.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "996babe4314515ddd41008a53cb5d47f", + "name": "nbclient", + "sha256": "1b92d72b083f3350359b8fb2e3b5dc846f49650c9e46a6a74354b1b7f0d42730", + "size": 98791, + "subdir": "linux-64", + "timestamp": 1650290544347, + "version": "0.5.13" + }, + "nbconvert-5.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bleach", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_client >=4.2", + "jupyter_core", + "mistune >0.6", + "nbformat", + "pandoc", + "pandocfilters >=1.4.1", + "pygments", + "python >=2.7,<2.8.0a0", + "testpath", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "f6717a22e38b099cbe8776c91a7a911c", + "name": "nbconvert", + "sha256": "ffebd624e15aa758fc361e3ef05fe15ee7f1bd5f5ab21446ae10e055f8e9039b", + "size": 409475, + "subdir": "linux-64", + "timestamp": 1530734567194, + "version": "5.3.1" + }, + "nbconvert-5.3.1-py27he041f76_0.tar.bz2": { + "build": "py27he041f76_0", + "build_number": 0, + "depends": [ + "bleach", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_client >=4.2", + "jupyter_core", + "mistune >0.6", + "nbformat", + "pandoc", + "pandocfilters >=1.4.1", + "pygments", + "python >=2.7,<2.8.0a0", + "testpath", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "a456cc4018e83e3ce9714249b698e52e", + "name": "nbconvert", + "sha256": "a79a8fba48b6337a4feaefaebd31f96f9dedff808f902a5d6c6e9963935a838e", + "size": 404249, + "subdir": "linux-64", + "timestamp": 1506349847685, + "version": "5.3.1" + }, + "nbconvert-5.3.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bleach", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_client >=4.2", + "jupyter_core", + "mistune >0.6", + "nbformat", + "pandoc", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.5,<3.6.0a0", + "testpath", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "935eab09384f0f0418c9fdb50b5e597c", + "name": "nbconvert", + "sha256": "0acffc21600ead773ac8dd14f3ff65fa3da2c098adfdfad82670ae85478c22b3", + "size": 414453, + "subdir": "linux-64", + "timestamp": 1534350963834, + "version": "5.3.1" + }, + "nbconvert-5.3.1-py35hc5194e3_0.tar.bz2": { + "build": "py35hc5194e3_0", + "build_number": 0, + "depends": [ + "bleach", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_client >=4.2", + "jupyter_core", + "mistune >0.6", + "nbformat", + "pandoc", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.5,<3.6.0a0", + "testpath", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "8abda0ff19e83a9953138f43d993c21e", + "name": "nbconvert", + "sha256": "6242818f813de3f8d6c9ada7c33b90719b160f08e8ef1f82050b458804a9e599", + "size": 406824, + "subdir": "linux-64", + "timestamp": 1506349862073, + "version": "5.3.1" + }, + "nbconvert-5.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bleach", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_client >=4.2", + "jupyter_core", + "mistune >0.6", + "nbformat", + "pandoc", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "ee2e42cd8351b3ebe55b06978572d5ac", + "name": "nbconvert", + "sha256": "bf82b75037d915f2946f8baf05e5b8b6d492ac3f9f5b9536cf56c7d1756b6334", + "size": 415418, + "subdir": "linux-64", + "timestamp": 1530734538176, + "version": "5.3.1" + }, + "nbconvert-5.3.1-py36hb41ffb7_0.tar.bz2": { + "build": "py36hb41ffb7_0", + "build_number": 0, + "depends": [ + "bleach", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_client >=4.2", + "jupyter_core", + "mistune >0.6", + "nbformat", + "pandoc", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "3f08fc505596c0c9131c71a34f64a67c", + "name": "nbconvert", + "sha256": "c266bad216d99c804760ff8da01849ed07c591f11701d064c6d38e6b1ba73216", + "size": 407822, + "subdir": "linux-64", + "timestamp": 1506349856326, + "version": "5.3.1" + }, + "nbconvert-5.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bleach", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_client >=4.2", + "jupyter_core", + "mistune >0.6", + "nbformat", + "pandoc", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "bc636ec42df99dbf218c5612f7879fae", + "name": "nbconvert", + "sha256": "87e92ccdfce092a1b3c2fa548d4b6da5d17b99c1293ccfa1472117a9534dfe82", + "size": 414783, + "subdir": "linux-64", + "timestamp": 1530734600578, + "version": "5.3.1" + }, + "nbconvert-5.4.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1,<2.0.0", + "pandocfilters >=1.4.1", + "pygments", + "python >=2.7,<2.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "09d316cc759450a2e7c7ff7446b486b0", + "name": "nbconvert", + "sha256": "c6c484ebc2e0b78feafdd438404d7e7d1058678a5d25e43b18d6ebdca6d99e8b", + "size": 422891, + "subdir": "linux-64", + "timestamp": 1536785669537, + "version": "5.4.0" + }, + "nbconvert-5.4.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1,<2.0.0", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.5,<3.6.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "579a5c411c28f4b9a8fd4fd43a719dda", + "name": "nbconvert", + "sha256": "4bf867b3ade8ee5fe0739baa3b53e811b87c9e64f3f7feb290c2140ac593d6e2", + "size": 427420, + "subdir": "linux-64", + "timestamp": 1536786577366, + "version": "5.4.0" + }, + "nbconvert-5.4.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1,<2.0.0", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "98ddec09c9d0190b76dbf8692bbb369b", + "name": "nbconvert", + "sha256": "7c062f146eda71aeae6df8cf741f06b0c8092353c622608f19947fbb225c31dd", + "size": 426067, + "subdir": "linux-64", + "timestamp": 1536785716634, + "version": "5.4.0" + }, + "nbconvert-5.4.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1,<2.0.0", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "ef2099f130be61cb61cd509cc2f2354e", + "name": "nbconvert", + "sha256": "9eddd8d9fea87d106d093b819cd9925e8164bef6e14282d766d6f813626ebf7d", + "size": 425918, + "subdir": "linux-64", + "timestamp": 1536785660886, + "version": "5.4.0" + }, + "nbconvert-5.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1,<2.0.0", + "pandocfilters >=1.4.1", + "pygments", + "python >=2.7,<2.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "4404103caa552805c463918b6d0c2845", + "name": "nbconvert", + "sha256": "768a77f33c07de6387495a6ff56882647ad24d6737777844b492efceaaaf0a5c", + "size": 436635, + "subdir": "linux-64", + "timestamp": 1551142563791, + "version": "5.4.1" + }, + "nbconvert-5.4.1-py27_3.tar.bz2": { + "build": "py27_3", + "build_number": 3, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=2.7,<2.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "d8e0212dc7560b10e201ce0148b281c3", + "name": "nbconvert", + "sha256": "8760a13a114c5641ed099ffa3aa01f24abca572963d1a6d66af36455a3a387fe", + "size": 436392, + "subdir": "linux-64", + "timestamp": 1553303867011, + "version": "5.4.1" + }, + "nbconvert-5.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1,<2.0.0", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "7ebc94ea4348f69251ad7dc210b1a544", + "name": "nbconvert", + "sha256": "0d2382dfb1117cc5657458741d07b82211f46b036124581d033ea5bce7ce3c85", + "size": 428458, + "subdir": "linux-64", + "timestamp": 1551142602051, + "version": "5.4.1" + }, + "nbconvert-5.4.1-py36_3.tar.bz2": { + "build": "py36_3", + "build_number": 3, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "68fc37ed16e4cec108f458e6e113267a", + "name": "nbconvert", + "sha256": "fbeb3f4beb6ee67fcdf29283e49c043c5ced7942cbd732ec4c29d6148c61a4dc", + "size": 433098, + "subdir": "linux-64", + "timestamp": 1553304165737, + "version": "5.4.1" + }, + "nbconvert-5.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1,<2.0.0", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "12eef8b893e4ecd36f61612257c83905", + "name": "nbconvert", + "sha256": "4ab9d70e96638e4f947ddf078325d0f04643768e22a1078d89518454416cf98a", + "size": 428582, + "subdir": "linux-64", + "timestamp": 1551142541224, + "version": "5.4.1" + }, + "nbconvert-5.4.1-py37_3.tar.bz2": { + "build": "py37_3", + "build_number": 3, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "248bdbccc4c8cf12a35caca202b8c22e", + "name": "nbconvert", + "sha256": "06a577fb322f08b0ca8b97d0740f064abb79bb787bf678971f7cd998d3f161f3", + "size": 427926, + "subdir": "linux-64", + "timestamp": 1553304078176, + "version": "5.4.1" + }, + "nbconvert-5.6.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=2.7,<2.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "ad4c559151e3d71d56fc3865cb3b09ef", + "name": "nbconvert", + "sha256": "ffef9086e0525abbe88c384c70429e6c4fd9127140a2572274562e63bd7a3ab2", + "size": 503055, + "subdir": "linux-64", + "timestamp": 1569265834887, + "version": "5.6.0" + }, + "nbconvert-5.6.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "d40ba58f5d3e4ac5a3ab64625e5cf3c3", + "name": "nbconvert", + "sha256": "3a98358f6bc4ccf722a54a72a1f2b98a2ba9e646ed5f97c456a459c2d15c2074", + "size": 505944, + "subdir": "linux-64", + "timestamp": 1569265835117, + "version": "5.6.0" + }, + "nbconvert-5.6.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "c138a9a48b980ca905d7116669cd7022", + "name": "nbconvert", + "sha256": "37a19e71e6fd47973b6b31ecb12409ce856e1e2e0d394332512c79626084f286", + "size": 502948, + "subdir": "linux-64", + "timestamp": 1569265837533, + "version": "5.6.0" + }, + "nbconvert-5.6.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=2.7,<2.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "9fdec9c5808e3b93632184021e66277f", + "name": "nbconvert", + "sha256": "fc1944d91f74f1dbf674d6c7d99b612c1a6b565db9d081ca0f1143ce41e6c061", + "size": 498583, + "subdir": "linux-64", + "timestamp": 1573063172289, + "version": "5.6.1" + }, + "nbconvert-5.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "e11ae5b4142aceaedda5fc1123e52ec5", + "name": "nbconvert", + "sha256": "429acb4b1cca2a9fc1d078d4dd2df1bb5ee1c448b091e647844702b76f4e8f75", + "size": 504749, + "subdir": "linux-64", + "timestamp": 1573063138658, + "version": "5.6.1" + }, + "nbconvert-5.6.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "b4c92a1b2bd32a0357cb01a1c51f10bc", + "name": "nbconvert", + "sha256": "d0d30deafa8231d749ee9f338a572861f8188068a10cc860d2a4a4b98b4e5e3f", + "size": 504131, + "subdir": "linux-64", + "timestamp": 1573063116156, + "version": "5.6.1" + }, + "nbconvert-5.6.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "c6d62fa88ad32a8a876688c832b6ccee", + "name": "nbconvert", + "sha256": "a4e62c5dbebefc12d136d5cc4dc8c79495244ee1d883c65956867c5a59de042c", + "size": 501419, + "subdir": "linux-64", + "timestamp": 1594376844643, + "version": "5.6.1" + }, + "nbconvert-5.6.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "8f2e58e1616033c93a778cd36ba09231", + "name": "nbconvert", + "sha256": "5632be883aa46758b7ef8007038bead84c99943a41b4da78a6742a61c9cd78bc", + "size": 498976, + "subdir": "linux-64", + "timestamp": 1573572301607, + "version": "5.6.1" + }, + "nbconvert-6.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "0a0e45f6ec29f968519ea38a595bb39c", + "name": "nbconvert", + "sha256": "b0c9d343abd4b81a016f5a90b69e80990f5dd811fca0dbe29d7488c3e9537025", + "size": 521156, + "subdir": "linux-64", + "timestamp": 1601068915180, + "version": "6.0.3" + }, + "nbconvert-6.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "650c7bba7743140026915434e443501a", + "name": "nbconvert", + "sha256": "df74be3574f78508a9dd18f13e48fd698970e2fe9044c5f45b8863d5274f4b7b", + "size": 523487, + "subdir": "linux-64", + "timestamp": 1601068930254, + "version": "6.0.3" + }, + "nbconvert-6.0.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "a6d0aac80ea3917a66bbe4a62fc33942", + "name": "nbconvert", + "sha256": "7fa84f25396c24594ee79c6c8af9f39c0bb688cbb7854eaa1422f89ee40650f6", + "size": 528736, + "subdir": "linux-64", + "timestamp": 1601061800309, + "version": "6.0.3" + }, + "nbconvert-6.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "40f5225dd00e5dd059befeb008d4365f", + "name": "nbconvert", + "sha256": "f3ff1017c4293bf8f86c1a7fa694fa08f2f77a48af8844c24a02e75ec3e83b85", + "size": 519668, + "subdir": "linux-64", + "timestamp": 1601069248587, + "version": "6.0.4" + }, + "nbconvert-6.0.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "e64ae818b81ab90e979cff995419bfd3", + "name": "nbconvert", + "sha256": "d9b9c459ba4ba1d42ded0761dd672678a5b16b524ab312931776d2275a2125cf", + "size": 498363, + "subdir": "linux-64", + "timestamp": 1601069203621, + "version": "6.0.4" + }, + "nbconvert-6.0.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "0b4ad3bebb68c3883921405642b96b8e", + "name": "nbconvert", + "sha256": "ad5b80c7bbb700a18b3ef7131dd77773c58d46e751e007e1e42a8b62b680bb15", + "size": 526005, + "subdir": "linux-64", + "timestamp": 1601069197786, + "version": "6.0.4" + }, + "nbconvert-6.0.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "76a9b2b109162888b6638ec1671d2e06", + "name": "nbconvert", + "sha256": "805333d19250265d2fdb83f42f7e78cda14c5472aba3d5c1140e46bbe997f695", + "size": 517930, + "subdir": "linux-64", + "timestamp": 1601069247664, + "version": "6.0.5" + }, + "nbconvert-6.0.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "81c44f30b6dbe3c3278343112dde729c", + "name": "nbconvert", + "sha256": "7236489d0620bd7643d88e86d42c31b9b400e54c2fac30916cead27261b2f25d", + "size": 525002, + "subdir": "linux-64", + "timestamp": 1601069258337, + "version": "6.0.5" + }, + "nbconvert-6.0.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "fc719f8b7462432745500c745bb4b788", + "name": "nbconvert", + "sha256": "e5ca4c86c86d750ea619659c6ed7fca8b28ab9dac7bc97de3896f7ce6c3576f0", + "size": 504303, + "subdir": "linux-64", + "timestamp": 1601069244678, + "version": "6.0.5" + }, + "nbconvert-6.0.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "c730519adb1ca4cd02e1d716f9b08cb6", + "name": "nbconvert", + "sha256": "cea1b58aa0b7591e37f7888524e4d65fd74ae0b2ca01e54315d3bb76935287a8", + "size": 564806, + "subdir": "linux-64", + "timestamp": 1601069221306, + "version": "6.0.6" + }, + "nbconvert-6.0.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "55c8a036dcf13c5baf24d4efc7a42497", + "name": "nbconvert", + "sha256": "e748af7f96aee6a988433a948e848a3edba5f5a23b1977eaa40da244540d8700", + "size": 543762, + "subdir": "linux-64", + "timestamp": 1601069160773, + "version": "6.0.6" + }, + "nbconvert-6.0.6-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "5e1f27c161952d7fd909f6d052e94ac2", + "name": "nbconvert", + "sha256": "149451c0dff01b25e80e535bf320e08afd90378e5cbc44192daa2a014606e3c3", + "size": 561523, + "subdir": "linux-64", + "timestamp": 1601069235170, + "version": "6.0.6" + }, + "nbconvert-6.0.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "1056b9a8203059e2f137563aa465d71b", + "name": "nbconvert", + "sha256": "85943a308ecf02104575adbb0fbb302f684a2ec5770a8905dfb8a88028b2b37a", + "size": 561123, + "subdir": "linux-64", + "timestamp": 1601914836882, + "version": "6.0.7" + }, + "nbconvert-6.0.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "c7316612875978a2da912d8d06f9e9a0", + "name": "nbconvert", + "sha256": "a4cde74231a14d677234569c2fe795a66760fc90b08d4e7dd5d0456a68a87f22", + "size": 542893, + "subdir": "linux-64", + "timestamp": 1601914850146, + "version": "6.0.7" + }, + "nbconvert-6.0.7-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "b4961683d6671ea5b554fb7787fb8947", + "name": "nbconvert", + "sha256": "a37fcfe26ade13fd1a7913c17296862eeb743d34b9178aaf2b5bed6b1e3853dd", + "size": 569888, + "subdir": "linux-64", + "timestamp": 1601914861723, + "version": "6.0.7" + }, + "nbconvert-6.0.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.9,<3.10.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "27542a4d6d6b76d79776e60948052a8b", + "name": "nbconvert", + "sha256": "5176ef02ea8b81a66305dc04e720a675675913c3799fe469adb7f9650a8ee3c8", + "size": 568194, + "subdir": "linux-64", + "timestamp": 1607370468907, + "version": "6.0.7" + }, + "nbconvert-6.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.10,<3.11.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "027cb14b7b618a6aa3440f4efe4c8e29", + "name": "nbconvert", + "sha256": "607239245781385f88fdb3369699906b0747cc7f5d994a14e27f79dbf456d3ef", + "size": 559859, + "subdir": "linux-64", + "timestamp": 1641917120726, + "version": "6.1.0" + }, + "nbconvert-6.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5b05c0d1a12981e04ac2074c8545ef52", + "name": "nbconvert", + "sha256": "ba7b7d75050aef0bdaf60ddea96920ee11428097d6e006b1cb4c73ac2121c235", + "size": 563219, + "subdir": "linux-64", + "timestamp": 1624479119430, + "version": "6.1.0" + }, + "nbconvert-6.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "029c109117e9b82f8d9477732ef6fad5", + "name": "nbconvert", + "sha256": "e754caf47036d809900862289f41f16dec453e2507687c3447de80289e003f04", + "size": 563514, + "subdir": "linux-64", + "timestamp": 1624479089606, + "version": "6.1.0" + }, + "nbconvert-6.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.9,<3.10.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f5ab7812eb127afb4c863920af63cc07", + "name": "nbconvert", + "sha256": "56126691b4d3d5a320263bbd6a7b4a2a66f7bc140277304992711d682313296e", + "size": 563211, + "subdir": "linux-64", + "timestamp": 1624472931773, + "version": "6.1.0" + }, + "nbconvert-6.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c18393df34f60b1306ce7e808e14d29e", + "name": "nbconvert", + "sha256": "031c25f3b3cda03e96e0a36ef55689e3d07459972c3f02cb8a93a7592c569cb5", + "size": 571537, + "subdir": "linux-64", + "timestamp": 1641309285896, + "version": "6.2.0" + }, + "nbconvert-6.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e4cfc1e179794750e1561b4c8785ccd3", + "name": "nbconvert", + "sha256": "5d9f6c8a8b98bd785c80d48e76b6bce60d77b83f630f03e3c9d95fc1e91c2794", + "size": 568605, + "subdir": "linux-64", + "timestamp": 1641309221616, + "version": "6.2.0" + }, + "nbconvert-6.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.9,<3.10.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "76db1bd09ff4aac2c0208bc0bd192941", + "name": "nbconvert", + "sha256": "43809f9bc4d52e1836f1297467a22ff9cc5793dd2133c7db988e721eae393878", + "size": 568586, + "subdir": "linux-64", + "timestamp": 1641309255701, + "version": "6.2.0" + }, + "nbconvert-6.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "405626b0619320f95a0cdb8c77a48f48", + "name": "nbconvert", + "sha256": "c8c627ee45f2656d3e5b3ae3e76d4533af9f1793311e3e60e09baa4d8c159fb3", + "size": 537231, + "subdir": "linux-64", + "timestamp": 1641309221963, + "version": "6.3.0" + }, + "nbconvert-6.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9bbf961ffda46f298919b3c916168ca7", + "name": "nbconvert", + "sha256": "ecec3d57cb10389760d96b722871296f4130201d26b5ed689f9fbbd034ebcd5d", + "size": 536590, + "subdir": "linux-64", + "timestamp": 1641309285666, + "version": "6.3.0" + }, + "nbconvert-6.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.9,<3.10.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "33f23f1fa7f850dd403d79da7538f419", + "name": "nbconvert", + "sha256": "e6badc3406e5c43b1b7f1a342e4628c08f2bd5e480f16be190369945eebe2531", + "size": 536454, + "subdir": "linux-64", + "timestamp": 1641309256199, + "version": "6.3.0" + }, + "nbconvert-6.4.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.6" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.10,<3.11.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "95c8b0b93414ef51974369b4950eb7f5", + "name": "nbconvert", + "sha256": "2877d9dc49fb3c59233059533e9d697f6c9d56a7e723323e44c1c90c2740e525", + "size": 553160, + "subdir": "linux-64", + "timestamp": 1649749538297, + "version": "6.4.1" + }, + "nbconvert-6.4.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.6" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5b5608d779a50b31ae68ecaa3b596b51", + "name": "nbconvert", + "sha256": "a33637f9b4365a1e7ec727c459a5964e4e79293edb193fbb70a0c10b239444d9", + "size": 538016, + "subdir": "linux-64", + "timestamp": 1649749522352, + "version": "6.4.1" + }, + "nbconvert-6.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.6" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0b3059bea755299d4174f1ff1337b172", + "name": "nbconvert", + "sha256": "04d8cf5dfb1b2d8961eaad49168c329cac5910dac2eb2fc6e90910de42a57ce0", + "size": 564921, + "subdir": "linux-64", + "timestamp": 1649731396167, + "version": "6.4.1" + }, + "nbconvert-6.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.6" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.9,<3.10.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "445a7d2b40280a4e00b2664d7f5c8b7e", + "name": "nbconvert", + "sha256": "1827df84d1305f7ec093843545550cc20a429db2e8a7c0c5accf548484b03569", + "size": 580292, + "subdir": "linux-64", + "timestamp": 1649749524325, + "version": "6.4.1" + }, + "nbconvert-6.4.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer >=1,<1.1" + ], + "depends": [ + "beautifulsoup4", + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.10,<3.11.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "24ab3980f468b287cd0b07ccba04d9b4", + "name": "nbconvert", + "sha256": "48e41d1613f4be84f659583a5063e65eb388e4e5531d24844dd3af7ddaf436f1", + "size": 570542, + "subdir": "linux-64", + "timestamp": 1649752052948, + "version": "6.4.4" + }, + "nbconvert-6.4.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer >=1,<1.1" + ], + "depends": [ + "beautifulsoup4", + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f7987ee0d7ffd4e845c184eadcf78741", + "name": "nbconvert", + "sha256": "84a2a7d14f4d89cc45fbb66c0e8de2cbee2f94718e54e75bd68cd48ce4914ee4", + "size": 572130, + "subdir": "linux-64", + "timestamp": 1649751943602, + "version": "6.4.4" + }, + "nbconvert-6.4.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer >=1,<1.1" + ], + "depends": [ + "beautifulsoup4", + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "027a64ac454988b784fff9947c1ae1d6", + "name": "nbconvert", + "sha256": "ef2905b389ee29f9fd05c83e0f2f845e16229766b91d656747c0e0fe96eb0f80", + "size": 568315, + "subdir": "linux-64", + "timestamp": 1649751975792, + "version": "6.4.4" + }, + "nbconvert-6.4.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer >=1,<1.1" + ], + "depends": [ + "beautifulsoup4", + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.9,<3.10.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d263e3cdf799476e21315a41eaed3a89", + "name": "nbconvert", + "sha256": "949f10a2e5dc054c739765c4785e8fe13181b992fddf2adc480e57686eb9453c", + "size": 568158, + "subdir": "linux-64", + "timestamp": 1649752009070, + "version": "6.4.4" + }, + "nbconvert-6.5.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer >=1,<1.1" + ], + "depends": [ + "beautifulsoup4", + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=3.0", + "jupyter_core >=4.7", + "jupyterlab_pygments", + "lxml", + "markupsafe >=2.0", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0", + "nbformat >=5.1", + "packaging", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.10,<3.11.0a0", + "tinycss2", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a6ccc2e18be71a21400c65170c469a08", + "name": "nbconvert", + "sha256": "4ebad67463b41dfcde529483f1492a7e06c02bdee3157bc7e71060a8790ae5e0", + "size": 571994, + "subdir": "linux-64", + "timestamp": 1668450742267, + "version": "6.5.4" + }, + "nbconvert-6.5.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer >=1,<1.1" + ], + "depends": [ + "beautifulsoup4", + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=3.0", + "jupyter_core >=4.7", + "jupyterlab_pygments", + "lxml", + "markupsafe >=2.0", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0", + "nbformat >=5.1", + "packaging", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.11,<3.12.0a0", + "tinycss2", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6a7ee0d8fffca78bf2c2e37dd6a3c8af", + "name": "nbconvert", + "sha256": "fa02091b1087f3d2c66460d1ae688f413b59fa48d762f877c8cb663c1217729a", + "size": 645819, + "subdir": "linux-64", + "timestamp": 1676823867797, + "version": "6.5.4" + }, + "nbconvert-6.5.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer >=1,<1.1" + ], + "depends": [ + "beautifulsoup4", + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=3.0", + "jupyter_core >=4.7", + "jupyterlab_pygments", + "lxml", + "markupsafe >=2.0", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0", + "nbformat >=5.1", + "packaging", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "tinycss2", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e0c4bcee5d6a68b639c2e79c91a1e4b", + "name": "nbconvert", + "sha256": "e27b7fc95c8762a46a244e9e85790a706ade06c54746baf76dbd71e55efb5e7c", + "size": 572632, + "subdir": "linux-64", + "timestamp": 1668450779707, + "version": "6.5.4" + }, + "nbconvert-6.5.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer >=1,<1.1" + ], + "depends": [ + "beautifulsoup4", + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=3.0", + "jupyter_core >=4.7", + "jupyterlab_pygments", + "lxml", + "markupsafe >=2.0", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0", + "nbformat >=5.1", + "packaging", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "tinycss2", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0749fa3dad721024de2deb7b049236b4", + "name": "nbconvert", + "sha256": "e36d7263562dadee1fe702e1b4a0cc437144ef9b5b6780ec27b0a6e01389380c", + "size": 572228, + "subdir": "linux-64", + "timestamp": 1668450817218, + "version": "6.5.4" + }, + "nbconvert-6.5.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer >=1,<1.1" + ], + "depends": [ + "beautifulsoup4", + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=3.0", + "jupyter_core >=4.7", + "jupyterlab_pygments", + "lxml", + "markupsafe >=2.0", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0", + "nbformat >=5.1", + "packaging", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.9,<3.10.0a0", + "tinycss2", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1710a25086c8098367eb36b9d441448b", + "name": "nbconvert", + "sha256": "8f42419638dbfa40606e63df51232ef21f26cc674e23181eb9b6123d1eda4bf4", + "size": 569683, + "subdir": "linux-64", + "timestamp": 1668450704669, + "version": "6.5.4" + }, + "nbformat-4.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipython_genutils", + "jsonschema >=2.4,!=2.5.0", + "jupyter_core", + "python >=2.7,<2.8.0a0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "110bea4bd1327461dad472da967c4d11", + "name": "nbformat", + "sha256": "11346dca6d1845dafa98444c9982b6af14241d99563745814cf92e1d2fed75a8", + "size": 142387, + "subdir": "linux-64", + "timestamp": 1530734480977, + "version": "4.4.0" + }, + "nbformat-4.4.0-py27hed7f2b2_0.tar.bz2": { + "build": "py27hed7f2b2_0", + "build_number": 0, + "depends": [ + "ipython_genutils", + "jsonschema >=2.4,!=2.5.0", + "jupyter_core", + "python >=2.7,<2.8.0a0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "a1bf0bc88edb1b2768a73841acd19dde", + "name": "nbformat", + "sha256": "16ef9a35f0c8cbcf6d8cfa49cc269a7eb20dc17f5da42060e43fd6e9d639f965", + "size": 139357, + "subdir": "linux-64", + "timestamp": 1505672287946, + "version": "4.4.0" + }, + "nbformat-4.4.0-py35h12e6e07_0.tar.bz2": { + "build": "py35h12e6e07_0", + "build_number": 0, + "depends": [ + "ipython_genutils", + "jsonschema >=2.4,!=2.5.0", + "jupyter_core", + "python >=3.5,<3.6.0a0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "6f69b6314b51a8dd5f1dc1bdda539176", + "name": "nbformat", + "sha256": "7dbb7d6183804f7c7b42dfce4d9692b1d9cf5134dcdd575820c09ad2f835ed3f", + "size": 141107, + "subdir": "linux-64", + "timestamp": 1505672304181, + "version": "4.4.0" + }, + "nbformat-4.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython_genutils", + "jsonschema >=2.4,!=2.5.0", + "jupyter_core", + "python >=3.6,<3.7.0a0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "deb3bb936f881be109f3c63709840e07", + "name": "nbformat", + "sha256": "1379d218d4c01d447af50937998251a7dcc181d6db4ef4bf537480388ab393ed", + "size": 143923, + "subdir": "linux-64", + "timestamp": 1530734457345, + "version": "4.4.0" + }, + "nbformat-4.4.0-py36h31c9010_0.tar.bz2": { + "build": "py36h31c9010_0", + "build_number": 0, + "depends": [ + "ipython_genutils", + "jsonschema >=2.4,!=2.5.0", + "jupyter_core", + "python >=3.6,<3.7.0a0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "1055d0939899608e9df10b260c308408", + "name": "nbformat", + "sha256": "161e8b5a570f7d05fc37f7b8ca677d416dcde5a0c6303c4d3573fd9fa1024005", + "size": 140741, + "subdir": "linux-64", + "timestamp": 1505672321210, + "version": "4.4.0" + }, + "nbformat-4.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython_genutils", + "jsonschema >=2.4,!=2.5.0", + "jupyter_core", + "python >=3.7,<3.8.0a0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "b4c408874818ba2cfe24ffc08573574a", + "name": "nbformat", + "sha256": "345ecff743a6821f52bff251b528b93f3b7f6bd02f5f640c72b10106f8a7f2a7", + "size": 144051, + "subdir": "linux-64", + "timestamp": 1530734505990, + "version": "4.4.0" + }, + "nbformat-4.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipython_genutils", + "jsonschema >=2.4,!=2.5.0", + "jupyter_core", + "python >=3.8,<3.9.0a0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "63e9a4223210bcfd507c4f2be95daa40", + "name": "nbformat", + "sha256": "0630af3554467bc4beacf3ceb8fd362e6c5afd80698ebad4e196c08919cb6aab", + "size": 144998, + "subdir": "linux-64", + "timestamp": 1574414063395, + "version": "4.4.0" + }, + "nbformat-5.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.10,<3.11.0a0", + "python-fastjsonschema", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fe993f67b206f6355501d966e8d97d6b", + "name": "nbformat", + "sha256": "1a202beb2b216d4319bb137778827f13ac2a90b854f8a164ebe1b14377bbdb73", + "size": 146464, + "subdir": "linux-64", + "timestamp": 1649844967383, + "version": "5.3.0" + }, + "nbformat-5.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.7,<3.8.0a0", + "python-fastjsonschema", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "957a3df4e27f37bd9bcebd7548288bae", + "name": "nbformat", + "sha256": "10e928f76b162a8c1a04ea8b7dc033a44093716a946a9aeced0facf3f0e38731", + "size": 145632, + "subdir": "linux-64", + "timestamp": 1649844957513, + "version": "5.3.0" + }, + "nbformat-5.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.8,<3.9.0a0", + "python-fastjsonschema", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85d96c4902d044dbb8be3ecabfebf888", + "name": "nbformat", + "sha256": "dd248b18c50ad82cf827ab0f3ed1cda39bfb8b000ce8ef179a0920715b784f8b", + "size": 145894, + "subdir": "linux-64", + "timestamp": 1649827095894, + "version": "5.3.0" + }, + "nbformat-5.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.9,<3.10.0a0", + "python-fastjsonschema", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ec19ed37bf353dab10be0041eb111a1c", + "name": "nbformat", + "sha256": "f2f7d98957059b00434a07477414cba566151bb52dfe9a8338d77be7b0a392e3", + "size": 145843, + "subdir": "linux-64", + "timestamp": 1649826828066, + "version": "5.3.0" + }, + "nbformat-5.5.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.10,<3.11.0a0", + "python-fastjsonschema", + "traitlets >=5.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a9b17040a50e00552fdcdde3dfe69c4e", + "name": "nbformat", + "sha256": "79334eb9af16a10e50b944a51896759a99d5aa753496652b8bcee1c218078506", + "size": 144985, + "subdir": "linux-64", + "timestamp": 1663745091753, + "version": "5.5.0" + }, + "nbformat-5.5.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.7,<3.8.0a0", + "python-fastjsonschema", + "traitlets >=5.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "92278052455c06dcb1a9716ca133f57f", + "name": "nbformat", + "sha256": "26a49c13ffa54b4188df12469f5825ab4e29ca25fc2bb6266bac65fc474bc7ae", + "size": 144168, + "subdir": "linux-64", + "timestamp": 1663745049084, + "version": "5.5.0" + }, + "nbformat-5.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.8,<3.9.0a0", + "python-fastjsonschema", + "traitlets >=5.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "60031f11a1886535eea2d66015ddfda2", + "name": "nbformat", + "sha256": "8a37661a8153ef95ca32db87429a7ec81b8d14624c792bcde158f2640023a70a", + "size": 144204, + "subdir": "linux-64", + "timestamp": 1663744986178, + "version": "5.5.0" + }, + "nbformat-5.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.9,<3.10.0a0", + "python-fastjsonschema", + "traitlets >=5.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "de35a2705fe95b4c913c15cb0e6bc54d", + "name": "nbformat", + "sha256": "2074b952d6535dbc98038402e7c44339159995aa3b4d7f7a64b2d072a89659c5", + "size": 144242, + "subdir": "linux-64", + "timestamp": 1663745018901, + "version": "5.5.0" + }, + "nbformat-5.7.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.10,<3.11.0a0", + "python-fastjsonschema", + "traitlets >=5.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6bc6ee37ddbdef705376dde9388e1012", + "name": "nbformat", + "sha256": "47cf3dc6db8032e0e02d21fdd000529cbc405d425dd238b8a9782da89129f177", + "size": 145857, + "subdir": "linux-64", + "timestamp": 1670352459523, + "version": "5.7.0" + }, + "nbformat-5.7.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.11,<3.12.0a0", + "python-fastjsonschema", + "traitlets >=5.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0cf8289c4a26947b78380ea167f9e677", + "name": "nbformat", + "sha256": "1f8873e1a247dbb2544dd60e56b6a7d18cecd63b00677bf16835608d4903c8c8", + "size": 168614, + "subdir": "linux-64", + "timestamp": 1676823537457, + "version": "5.7.0" + }, + "nbformat-5.7.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jsonschema >=2.6", + "jupyter_core", + "python >=3.7,<3.8.0a0", + "python-fastjsonschema", + "traitlets >=5.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a959a8c1ca04cc5e4c3e1d674f0ea21b", + "name": "nbformat", + "sha256": "e8eb8b4e1b18829ba425232db2e2523278c399663dfeb82b2b9eb0af522fe2bd", + "size": 145285, + "subdir": "linux-64", + "timestamp": 1670352426079, + "version": "5.7.0" + }, + "nbformat-5.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.8,<3.9.0a0", + "python-fastjsonschema", + "traitlets >=5.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee47e3d603394a4174ffaa0864c3ab3b", + "name": "nbformat", + "sha256": "8f5385a2c13e3c7e9aa5289609e281aa3bbe05f81fcede0f6eeab6a22b40539b", + "size": 145267, + "subdir": "linux-64", + "timestamp": 1670352391322, + "version": "5.7.0" + }, + "nbformat-5.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.9,<3.10.0a0", + "python-fastjsonschema", + "traitlets >=5.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "27574cc2435d9c91d698d27b5d39a69f", + "name": "nbformat", + "sha256": "22f8ae9d50d08fe3cd1b6d2d953351e791387e06233a7e61086854cff8a8d2d9", + "size": 145289, + "subdir": "linux-64", + "timestamp": 1670352357619, + "version": "5.7.0" + }, + "nbpresent-3.0.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "4c4cfce4c67174c15cad311fe272d4d0", + "name": "nbpresent", + "sha256": "8cc024fcd873ca4be0795d045abd2e30bab98a995071d237d14124a9f92afad1", + "size": 1329593, + "subdir": "linux-64", + "timestamp": 1530901371825, + "version": "3.0.2" + }, + "nbpresent-3.0.2-py27hcce4ef4_1.tar.bz2": { + "build": "py27hcce4ef4_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "5ed34ded0f0d37bacd4f79b67c1bd785", + "name": "nbpresent", + "sha256": "2fe0227f3c2e6050b5cea82cb2b55337f3c6c7982bb4bbe363ab77cd7530617e", + "size": 1090802, + "subdir": "linux-64", + "timestamp": 1505746483006, + "version": "3.0.2" + }, + "nbpresent-3.0.2-py35h9c03491_1.tar.bz2": { + "build": "py35h9c03491_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "md5": "369c50afa54984ed28ff36e36b1aa7f4", + "name": "nbpresent", + "sha256": "1a9f0ace24fd8fdbe8d9cc9989552d4cd46b9c633a145b391f98ba00b4440672", + "size": 1090728, + "subdir": "linux-64", + "timestamp": 1505746579276, + "version": "3.0.2" + }, + "nbpresent-3.0.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a6d008915b23cbcc291ed1a2a9f0a034", + "name": "nbpresent", + "sha256": "b43a0a2a2a643649658d2d8c0aa497ff4eff1438eb1f5987a5a8f7e293cb91e1", + "size": 1331468, + "subdir": "linux-64", + "timestamp": 1530901275349, + "version": "3.0.2" + }, + "nbpresent-3.0.2-py36h5f95a39_1.tar.bz2": { + "build": "py36h5f95a39_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "8007fd290ed3c5e58d6e615ccee771b3", + "name": "nbpresent", + "sha256": "0ead6f2878f5888366e257cb05ec88da6b8e0aaa3b1d453da532caf4c657571c", + "size": 1091362, + "subdir": "linux-64", + "timestamp": 1505746671850, + "version": "3.0.2" + }, + "nbpresent-3.0.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "91ae721d98c9e611ad766028776c5c78", + "name": "nbpresent", + "sha256": "8ca530c2ede7644586e96ea13c7f58c42651d666dcfd007efff9defa6068a34b", + "size": 1331688, + "subdir": "linux-64", + "timestamp": 1530901183647, + "version": "3.0.2" + }, + "nbserverproxy-0.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b5db03e6cad5f505f9775d6a674bea9f", + "name": "nbserverproxy", + "sha256": "6e9c95e02e035cf5ebea694052eb9f33dbae445b04894f63733e1cdd54d31f70", + "size": 13625, + "subdir": "linux-64", + "timestamp": 1522699251359, + "version": "0.7" + }, + "nbserverproxy-0.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1df66284c21c2c3dbb660586866bc52f", + "name": "nbserverproxy", + "sha256": "1782dd06810e73efacba0a2f4c173b582c5b2d4d9daa39ce8c91539e84f928c4", + "size": 13640, + "subdir": "linux-64", + "timestamp": 1522699243523, + "version": "0.7" + }, + "nbserverproxy-0.8.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "32cbada427f769aa2b51354cf68fb86f", + "name": "nbserverproxy", + "sha256": "60c0612bf50c328b6f2b1de7b4ae239aa1d7c83865cc5fe96d2e0e15ba67a2b2", + "size": 15001, + "subdir": "linux-64", + "timestamp": 1526943639395, + "version": "0.8.3" + }, + "nbserverproxy-0.8.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d4bc25e612fce17ba49b898a36e538ab", + "name": "nbserverproxy", + "sha256": "526570e9e999800755a4f0840e55d03a9a4bbc08dff24e053224b37186c7fdb7", + "size": 15027, + "subdir": "linux-64", + "timestamp": 1526943497184, + "version": "0.8.3" + }, + "nbserverproxy-0.8.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3e3c3eb5f798aee13f43f617d1d2af5e", + "name": "nbserverproxy", + "sha256": "8ddca466d1967b7ac19c99643636eec73343686aa42307d5293642d9c34f6698", + "size": 15068, + "subdir": "linux-64", + "timestamp": 1530901414128, + "version": "0.8.3" + }, + "nbserverproxy-0.8.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ed2cf975a869aa28f5c7a8096292b797", + "name": "nbserverproxy", + "sha256": "63c4c9c9c7dae3912a8f7e994f253bbcd1f846c69d431bb6128f8087f7d59e72", + "size": 15868, + "subdir": "linux-64", + "timestamp": 1640815417106, + "version": "0.8.5" + }, + "nbserverproxy-0.8.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "80c0150eb6d59824338e95651a5b3603", + "name": "nbserverproxy", + "sha256": "e1cab081602d1ae42643f2e579144684d4479791aba731dff8ab8f26dd59b69d", + "size": 20163, + "subdir": "linux-64", + "timestamp": 1676859897941, + "version": "0.8.5" + }, + "nbserverproxy-0.8.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4cbee2deef49cd8ea6dc881fb2908c85", + "name": "nbserverproxy", + "sha256": "25ec5c119293f283523d321bd97704f7a37e6bb8cdf6a409fe3094937a8e4566", + "size": 15423, + "subdir": "linux-64", + "timestamp": 1540990805521, + "version": "0.8.5" + }, + "nbserverproxy-0.8.5-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d0d8570bcf12f5dbf6226025d5a24b0e", + "name": "nbserverproxy", + "sha256": "ec71d7b25bc01e9586825fd60333aedb41ce54aaba4865818139c643d7ca17d6", + "size": 17449, + "subdir": "linux-64", + "timestamp": 1613733988252, + "version": "0.8.5" + }, + "nbserverproxy-0.8.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f12301a8a83851f45a506b06a777f19f", + "name": "nbserverproxy", + "sha256": "079527dd3745b422e068ab1f845f60e447a1a12618aa8c5108ab8a99b9738000", + "size": 15395, + "subdir": "linux-64", + "timestamp": 1540990810995, + "version": "0.8.5" + }, + "nbserverproxy-0.8.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bd9bbc14e6d0eab36b9348495c686dbd", + "name": "nbserverproxy", + "sha256": "ed1c727903c71e512f917a62827ff912fc5690679a6b476cb07f9f4bad565113", + "size": 17374, + "subdir": "linux-64", + "timestamp": 1613734599440, + "version": "0.8.5" + }, + "nbserverproxy-0.8.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e380d3b5401082a4aab688ed57411f6e", + "name": "nbserverproxy", + "sha256": "f27fe17852583a71de2d73524c2c69d142e15418eba5628aeb7f2b56ac19e1b6", + "size": 17491, + "subdir": "linux-64", + "timestamp": 1613734731062, + "version": "0.8.5" + }, + "nbserverproxy-0.8.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ea7d20b2ed018413dabb0ed0917f3402", + "name": "nbserverproxy", + "sha256": "3b7899b525d6ec08e361129935bdfa224c09ec845f0f579b064d41e14878642f", + "size": 17516, + "subdir": "linux-64", + "timestamp": 1613733986098, + "version": "0.8.5" + }, + "nbserverproxy-0.8.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "482fa41951f3aefefa5933aeb929f295", + "name": "nbserverproxy", + "sha256": "5c3f099edcd3b5fde5b5230b86e557e4f11b8ca7acdc16a2f5f208be0d363f6e", + "size": 15763, + "subdir": "linux-64", + "timestamp": 1545146078007, + "version": "0.8.8" + }, + "nbserverproxy-0.8.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "026bb6c5fb0420d99287225ba2d7c5fb", + "name": "nbserverproxy", + "sha256": "a747df0e0a958ce537cfc399d4c8f31085f2fc5968f900f7a2155053804e2f14", + "size": 15714, + "subdir": "linux-64", + "timestamp": 1545130461873, + "version": "0.8.8" + }, + "nbserverproxy-0.8.8-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "363a95cad8326bd218414e1508b9feaa", + "name": "nbserverproxy", + "sha256": "9505a469d473f0c6c2515290482802f72e71bb1ddfc1a908f798d7fd8108e5da", + "size": 16220, + "subdir": "linux-64", + "timestamp": 1600445758231, + "version": "0.8.8" + }, + "nbsmoke-0.2.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "pyflakes", + "pytest >=3.1.1", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e46f8b0862c2f0512f75410f9464d11c", + "name": "nbsmoke", + "sha256": "ee04a6e1035858084d3d9f4b19edb1c129b8b7840459bf805c2239cf3f27f923", + "size": 17444, + "subdir": "linux-64", + "timestamp": 1528517095534, + "version": "0.2.7" + }, + "nbsmoke-0.2.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "pyflakes", + "pytest >=3.1.1", + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c6ce9a784fc5e4ee8df052c34020df3b", + "name": "nbsmoke", + "sha256": "a4edefd6fac5b3b599607992137329ebc7607f0c98d64a59798b449bedd2a2fa", + "size": 17661, + "subdir": "linux-64", + "timestamp": 1528517155291, + "version": "0.2.7" + }, + "nbsmoke-0.2.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "pyflakes", + "pytest >=3.1.1", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ea064016c260ae0c8360fa0bd2aee398", + "name": "nbsmoke", + "sha256": "e64651caf4d3b3d8d063722957bded8197f883cd1a87da9a9232d72af65af0e5", + "size": 17620, + "subdir": "linux-64", + "timestamp": 1528517073196, + "version": "0.2.7" + }, + "nbsmoke-0.2.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "pyflakes", + "pytest >=3.1.1", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e14160ac043fa908f71cedf3f1121fd4", + "name": "nbsmoke", + "sha256": "7c9624ddb86eae934cfb8b0b3e92ceef29a33404953676c221f37bc3d07016d8", + "size": 19780, + "subdir": "linux-64", + "timestamp": 1559058650998, + "version": "0.2.8" + }, + "nbsmoke-0.2.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "pyflakes", + "pytest >=3.1.1", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5b096df6e897016c1dda50518cc47a1e", + "name": "nbsmoke", + "sha256": "6b2dcf18c99e187727145b0cb0f132b1a495e7f6031f68861e38f797bd9b8dc3", + "size": 20074, + "subdir": "linux-64", + "timestamp": 1559058668396, + "version": "0.2.8" + }, + "nbsmoke-0.2.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "pyflakes", + "pytest >=3.1.1", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ab456e3f579c1cd85597c45f755dc8e3", + "name": "nbsmoke", + "sha256": "1846e114c5d2f8c5754b5dbee1ad314670d9f781cd1c1b71d0ea99ddaeaafa1b", + "size": 20063, + "subdir": "linux-64", + "timestamp": 1559058657506, + "version": "0.2.8" + }, + "nbsmoke-0.2.8-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "pyflakes", + "pytest >=3.1.1", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88fab415ec045b775f6d6cedb49335ba", + "name": "nbsmoke", + "sha256": "16ed7dc74acc27f1587831f1e3a3a5d74a960bf3941396d8a05fd50b52407969", + "size": 19612, + "subdir": "linux-64", + "timestamp": 1574238051624, + "version": "0.2.8" + }, + "nbsmoke-0.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "param >=1.7.0", + "pyflakes", + "pytest >=3.1.1", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f0a5d3698de9635d8ffed39e343fba1f", + "name": "nbsmoke", + "sha256": "8edb2797effcf17c93a4c3189b4556972fa57429fe44e012734412d4ae305319", + "size": 44075, + "subdir": "linux-64", + "timestamp": 1658841577604, + "version": "0.6.0" + }, + "nbsmoke-0.6.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "param >=1.7.0", + "pyflakes", + "pytest >=3.1.1", + "python >=3.11,<3.12.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "baa05a0ab5e73cef2b3bd89c25eeea41", + "name": "nbsmoke", + "sha256": "47bc421163121104fef08fe5d7e79f2a9289eab90e0183ec52d9d24c79768a17", + "size": 54223, + "subdir": "linux-64", + "timestamp": 1676859913340, + "version": "0.6.0" + }, + "nbsmoke-0.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "param >=1.7.0", + "pyflakes", + "pytest >=3.1.1", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "babdf95bc8185ae674a2a39762765c5d", + "name": "nbsmoke", + "sha256": "2e516d8356c6c20489f5afac5429201d7d7cd5c358b675efeb20250cf3dc66de", + "size": 43889, + "subdir": "linux-64", + "timestamp": 1658841687624, + "version": "0.6.0" + }, + "nbsmoke-0.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "param >=1.7.0", + "pyflakes", + "pytest >=3.1.1", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2da8a826f614c6f4dfff1176059c4f66", + "name": "nbsmoke", + "sha256": "8df4fb65712db4d6abf14dfeb1d4175d3b0c35b46d42e9c9590dbcf656fdb086", + "size": 44042, + "subdir": "linux-64", + "timestamp": 1658841651220, + "version": "0.6.0" + }, + "nbsmoke-0.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "param >=1.7.0", + "pyflakes", + "pytest >=3.1.1", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "faf88620a4b5ac7f2c208459fb77d71a", + "name": "nbsmoke", + "sha256": "1409cfe8db46f6a8a812c446e462bc5f001373286ecd3007f11ed8524855aff6", + "size": 43826, + "subdir": "linux-64", + "timestamp": 1658841616057, + "version": "0.6.0" + }, + "nccl-1.3.5-cuda10.0_0.tar.bz2": { + "build": "cuda10.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "797f0156c61480df4ea33e9a7fbd5307", + "name": "nccl", + "sha256": "b8543fe71dcec1d0ffbe7fe72460a6524c443a9737c5cf99f644b8f66330f849", + "size": 8663600, + "subdir": "linux-64", + "timestamp": 1548260767320, + "version": "1.3.5" + }, + "nccl-1.3.5-cuda9.0_0.tar.bz2": { + "build": "cuda9.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9b2a95f99b1013b64bf6bc76d11e43b7", + "name": "nccl", + "sha256": "409b7f862008ac2f224f5262c479af273e687f6fb06d55a0a1029d80e2be744c", + "size": 8973940, + "subdir": "linux-64", + "timestamp": 1523280871183, + "version": "1.3.5" + }, + "nccl-1.3.5-cuda9.2_0.tar.bz2": { + "build": "cuda9.2_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3282cf141c1c399f6d6b6e15289b6766", + "name": "nccl", + "sha256": "22f4daf013c20e782a1381d3cc50cc73e708ae1a0fd7e8251a54b39ed90d8e72", + "size": 8784997, + "subdir": "linux-64", + "timestamp": 1548262779624, + "version": "1.3.5" + }, + "nccl-2.8.3.1-h91b26fc_0.tar.bz2": { + "build": "h91b26fc_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.0|10.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "34269e22e0034a6ae37ba11d3fd47248", + "name": "nccl", + "sha256": "b01d0e8abc31ed89ee2631bfc576eaf66cfea3dab804c074aa3594418c21e551", + "size": 127026962, + "subdir": "linux-64", + "timestamp": 1610053622356, + "version": "2.8.3.1" + }, + "nccl-2.8.3.1-hcaf9a05_0.tar.bz2": { + "build": "hcaf9a05_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.1|10.1.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a25ed50f187a52341b229a4556911347", + "name": "nccl", + "sha256": "7a82f559f5e9e157f2117011a08f559fcd33d75244a6c4eb32236911a8feb773", + "size": 129245867, + "subdir": "linux-64", + "timestamp": 1610061223661, + "version": "2.8.3.1" + }, + "nccl-2.8.3.1-heaad284_0.tar.bz2": { + "build": "heaad284_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.2|9.2.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dc203485f2262da9e48475bcf06e9d66", + "name": "nccl", + "sha256": "67b77f979f0eb01b5b265df78cafa472b79564cc75f98afa59bfe46c89f0552e", + "size": 128666326, + "subdir": "linux-64", + "timestamp": 1610039477486, + "version": "2.8.3.1" + }, + "ncurses-6.0-h06874d7_1.tar.bz2": { + "build": "h06874d7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Free software (MIT-like)", + "md5": "4abb7e108c149953711010eb6a6127b5", + "name": "ncurses", + "sha256": "5b22e50dee0a8cd645b2c562993e1a3d7d6cf6f4208b092856420475fceba380", + "size": 928299, + "subdir": "linux-64", + "timestamp": 1505666443588, + "version": "6.0" + }, + "ncurses-6.0-h9df7e31_2.tar.bz2": { + "build": "h9df7e31_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Free software (MIT-like)", + "md5": "695de7c1eadb57301ee172889bb5d9d9", + "name": "ncurses", + "sha256": "97630d9527287db443ea11fa3e58027520a30725c7da7841679abfb1d8bfa371", + "size": 942264, + "subdir": "linux-64", + "timestamp": 1510350763235, + "version": "6.0" + }, + "ncurses-6.1-he6710b0_1.tar.bz2": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Free software (MIT-like)", + "md5": "f8a5abbf28b624eb2c8bbc9f70a6ff70", + "name": "ncurses", + "sha256": "8fa1f512982baa632e1b20394b502daaf8541bebe1c60e1faa1a96dfedcd2f2f", + "size": 980597, + "subdir": "linux-64", + "timestamp": 1543442069203, + "version": "6.1" + }, + "ncurses-6.1-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Free software (MIT-like)", + "md5": "9ae319a1ad7300d447ccb21f8d775cfc", + "name": "ncurses", + "sha256": "19c678a38c6cacd9702ad721ad8162d79e6279d084b4f1e32590b23f476ee639", + "size": 965967, + "subdir": "linux-64", + "timestamp": 1525867812788, + "version": "6.1" + }, + "ncurses-6.2-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Free software (MIT-like)", + "md5": "f6e715f2796ba4dad41e92399bed2a20", + "name": "ncurses", + "sha256": "52817f356608f6f43312c95d1abe1978c6f5bc19dc666a627c1becdbec2a45a5", + "size": 1146776, + "subdir": "linux-64", + "timestamp": 1582541487979, + "version": "6.2" + }, + "ncurses-6.2-he6710b0_1.tar.bz2": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Free software (MIT-like)", + "md5": "e8ca84eda38cda3b462addd143a2e7b7", + "name": "ncurses", + "sha256": "1ed6f2c2e5c4fffb883bcb7e84b69605a91e6f20e0142313fdf722d85e001959", + "size": 1116403, + "subdir": "linux-64", + "timestamp": 1588170439381, + "version": "6.2" + }, + "ncurses-6.3-h5eee18b_3.tar.bz2": { + "build": "h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "Free software (MIT-like)", + "md5": "c5ca7fea42593496aa508ba8171f53fb", + "name": "ncurses", + "sha256": "d86e416bbd48c6e862818dc790228085e4fe5ca154580999e8bca2c2eab8d4ba", + "size": 1105342, + "subdir": "linux-64", + "timestamp": 1657006248503, + "version": "6.3" + }, + "ncurses-6.3-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "Free software (MIT-like)", + "md5": "49edd2d4b100496f1099813488c8d7cb", + "name": "ncurses", + "sha256": "f59ae540e6a26521ac7c072567f4e1e2dcdf1179f618c4453b44a4bf0b563136", + "size": 1106808, + "subdir": "linux-64", + "timestamp": 1635849428122, + "version": "6.3" + }, + "ncurses-6.3-h7f8727e_2.tar.bz2": { + "build": "h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "Free software (MIT-like)", + "md5": "fca4bd4e3891aebf4fd7daf9b6d0ccfa", + "name": "ncurses", + "sha256": "0807371380965e421cb5f3f2a30d790fd5c41db11dbb6d318e14294c3b1741ed", + "size": 1083412, + "subdir": "linux-64", + "timestamp": 1636570020698, + "version": "6.3" + }, + "ncurses-6.3-heee7806_1.tar.bz2": { + "build": "heee7806_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "Free software (MIT-like)", + "md5": "0f26da2446225366c058ffd398026a6d", + "name": "ncurses", + "sha256": "08a37f9e73e25dc4ff525980cc97e1a1cf6c10ea5214d2a0126027a940930ac2", + "size": 1098158, + "subdir": "linux-64", + "timestamp": 1636114491849, + "version": "6.3" + }, + "ncurses-6.4-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT AND X11", + "license_family": "MIT", + "md5": "57ea097dc15f8d9f9eb90e1d919143b0", + "name": "ncurses", + "sha256": "1a04f65c955ea5e7c8fc2f79c80f918d7ba21e9c248757217710e48b882d9820", + "size": 1157733, + "subdir": "linux-64", + "timestamp": 1674734069410, + "version": "6.4" + }, + "ndg-httpsclient-0.4.3-py27ha68a7dc_0.tar.bz2": { + "build": "py27ha68a7dc_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "812d97867706818efe399df3afd7e6d1", + "name": "ndg-httpsclient", + "sha256": "e26088576a63158b83af31bd69815a1d3da5249dee8340710afe12689607590d", + "size": 43036, + "subdir": "linux-64", + "timestamp": 1508266085341, + "version": "0.4.3" + }, + "ndg-httpsclient-0.4.3-py35h6fea151_0.tar.bz2": { + "build": "py35h6fea151_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "544a7413438634d7a6315433262fae88", + "name": "ndg-httpsclient", + "sha256": "4603478b8a0333e20779c00b44f82885362d5add7c6b6d729336ede31347f0ba", + "size": 43761, + "subdir": "linux-64", + "timestamp": 1508266098279, + "version": "0.4.3" + }, + "ndg-httpsclient-0.4.3-py36h9c7cbca_0.tar.bz2": { + "build": "py36h9c7cbca_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "11dc2a01db696246eef6096bc81a97e4", + "name": "ndg-httpsclient", + "sha256": "1c0fd56ef284e6c652121aaff0fe09c4c8ed02ce7205282e171f0a32d708a706", + "size": 43678, + "subdir": "linux-64", + "timestamp": 1508266092583, + "version": "0.4.3" + }, + "ndg-httpsclient-0.4.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "56b4e4d2bc17598467d5a02021ee0ba5", + "name": "ndg-httpsclient", + "sha256": "6253d83762a26619b05ca064b4e612e1583e02522daf8a3a83b8af1f681c1447", + "size": 41213, + "subdir": "linux-64", + "timestamp": 1521782455744, + "version": "0.4.4" + }, + "ndg-httpsclient-0.4.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "78408d3da61723c64f56c945fa913b5c", + "name": "ndg-httpsclient", + "sha256": "ec6301c945cf037da3b6a56d012cabdde47a830b79c7f4659445283068a60a75", + "size": 41939, + "subdir": "linux-64", + "timestamp": 1521782466570, + "version": "0.4.4" + }, + "ndg-httpsclient-0.4.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8d4eb77debedbc1d390d5bc277e69dd8", + "name": "ndg-httpsclient", + "sha256": "c6733e4f2a52e0c5595f30a498884a2d7c18cbabae890c7a19e99b5bab59b5e0", + "size": 41841, + "subdir": "linux-64", + "timestamp": 1521782409785, + "version": "0.4.4" + }, + "ndg-httpsclient-0.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "49814c54c4a343b3876d28febecd3017", + "name": "ndg-httpsclient", + "sha256": "d1fd7d5b5820e9acade9b2c8bfa40223e167cf273b4ee0806356b3a4c8290f62", + "size": 42645, + "subdir": "linux-64", + "timestamp": 1526928758520, + "version": "0.5.0" + }, + "ndg-httpsclient-0.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "97f4112967eba654556d687405e78fa5", + "name": "ndg-httpsclient", + "sha256": "fbd3f9db29dce5a36cb29d1e06381d9a29396451fa318aa5067a65e0b4962875", + "size": 43323, + "subdir": "linux-64", + "timestamp": 1526928765235, + "version": "0.5.0" + }, + "ndg-httpsclient-0.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "af5b279bd6f2af0942e6582fe0cd77a6", + "name": "ndg-httpsclient", + "sha256": "50f016cc847afed6e7d2141cd5460b989211053cfe543a17edcbad726639c2b6", + "size": 43296, + "subdir": "linux-64", + "timestamp": 1526928736839, + "version": "0.5.0" + }, + "ndg-httpsclient-0.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "00b68150252113c3ba0a42aa0e0e20d5", + "name": "ndg-httpsclient", + "sha256": "639507ef9f786548716a4f8ba540ff96f4f7190accac831643ef149de2e815f9", + "size": 43480, + "subdir": "linux-64", + "timestamp": 1530901449194, + "version": "0.5.0" + }, + "ndg-httpsclient-0.5.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "82b6795faa35bcd7b510225f20466e8f", + "name": "ndg-httpsclient", + "sha256": "34770f9717cd94d40d004fd70cb4d46356738da121894bee8251ae2433e35390", + "size": 42098, + "subdir": "linux-64", + "timestamp": 1535499336972, + "version": "0.5.1" + }, + "ndg-httpsclient-0.5.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "53c3095dfafccb7ce60b43fe7b6216ba", + "name": "ndg-httpsclient", + "sha256": "b61a80e343232fdac2e66de5aa0662322aabac9d1ac44968df7e59aae7ea905f", + "size": 42828, + "subdir": "linux-64", + "timestamp": 1535499337992, + "version": "0.5.1" + }, + "ndg-httpsclient-0.5.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cc636d0534ba02a56808a95849238a18", + "name": "ndg-httpsclient", + "sha256": "af88466231d4462f4bea582c4a29bd7488079e2d841edc98968d08eec472d19b", + "size": 42717, + "subdir": "linux-64", + "timestamp": 1535499305979, + "version": "0.5.1" + }, + "ndg-httpsclient-0.5.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d38b4d05f3dada28f57a212a62bd76a2", + "name": "ndg-httpsclient", + "sha256": "481d1bb3b5672f8510c37b3881f788cac7afc69991b47b1ab663793698f2be63", + "size": 42828, + "subdir": "linux-64", + "timestamp": 1535499342238, + "version": "0.5.1" + }, + "neo4j-python-driver-1.5.3-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dea8fd8be61de6b093ce756ffde32636", + "name": "neo4j-python-driver", + "sha256": "281ceac1c77925ecb73574d22cb6c2b953219c25f689057b264475e6424d284b", + "size": 192778, + "subdir": "linux-64", + "timestamp": 1522784568924, + "version": "1.5.3" + }, + "neo4j-python-driver-1.5.3-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5c9fc852ba36be7b5baf68416828b190", + "name": "neo4j-python-driver", + "sha256": "c0f458fd956d1aa887bc7fa39c43c77633a06902d53ffc437daa8a6c60c0ad15", + "size": 193791, + "subdir": "linux-64", + "timestamp": 1522784547893, + "version": "1.5.3" + }, + "neo4j-python-driver-1.5.3-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "01c3ecb714e7def941913159d5253b44", + "name": "neo4j-python-driver", + "sha256": "42b8b4a142c026036c05417ef0e54bffa971d3ded753fba4f5de49985411f884", + "size": 199340, + "subdir": "linux-64", + "timestamp": 1522784548809, + "version": "1.5.3" + }, + "neo4j-python-driver-1.6.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "neotime", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ca44df0b10267481defc97016ead5334", + "name": "neo4j-python-driver", + "sha256": "74d1fc27c973e9e223d8822493546f0c4e6d51288e8d138f248d81dfb7e75948", + "size": 200508, + "subdir": "linux-64", + "timestamp": 1527831949357, + "version": "1.6.0" + }, + "neo4j-python-driver-1.6.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "neotime", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "152034c83048f51dee41d1e3fdd69c06", + "name": "neo4j-python-driver", + "sha256": "b8a66c1d36c2fa0a6036b9d0a97ff55c852785692e6ebb66b2edeaee27d4168d", + "size": 203348, + "subdir": "linux-64", + "timestamp": 1527832185623, + "version": "1.6.0" + }, + "neo4j-python-driver-1.6.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "neotime", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "02f3f418a99c571bd21e86fe2374468b", + "name": "neo4j-python-driver", + "sha256": "9344cae1184eb186ec8ea35fd3b2bf7e04376102686ed00df7a2706250f9ff29", + "size": 207661, + "subdir": "linux-64", + "timestamp": 1527832152601, + "version": "1.6.0" + }, + "neo4j-python-driver-1.6.0-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "neotime", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e0c1a9a2f75561e0951aab62cbd22fc0", + "name": "neo4j-python-driver", + "sha256": "1dbd0fce432e08489ac693ee85552ce667314963908eff371dcea86d0b5aa7b8", + "size": 207272, + "subdir": "linux-64", + "timestamp": 1530901522512, + "version": "1.6.0" + }, + "neo4j-python-driver-1.6.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1792226792344b8c4fdaa9f28b42bd54", + "name": "neo4j-python-driver", + "sha256": "e7986f91eed2f5248e98b600815cdfd32bf0daacc92a0397743a7518b13f937e", + "size": 200362, + "subdir": "linux-64", + "timestamp": 1535500399834, + "version": "1.6.1" + }, + "neo4j-python-driver-1.6.1-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a663f1c6d761d7e529beacf2d4c72fe3", + "name": "neo4j-python-driver", + "sha256": "c9407358a0e23d3cf6f4ae033891a79cad7a43e7c6a1b8885edd2df97d2a52d8", + "size": 203060, + "subdir": "linux-64", + "timestamp": 1535500453906, + "version": "1.6.1" + }, + "neo4j-python-driver-1.6.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "efbc5cb41310e9adfd40525209345bbd", + "name": "neo4j-python-driver", + "sha256": "30bf26816b255c586cf97bfde519a574e7d956eb0c8f8ceaf60baddbbdb814d4", + "size": 207106, + "subdir": "linux-64", + "timestamp": 1535500420985, + "version": "1.6.1" + }, + "neo4j-python-driver-1.6.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "424c4bcafca01549addd367c80a1c0e7", + "name": "neo4j-python-driver", + "sha256": "b06eadf9d5aabfca67c33bc0877e3cfcde35c6f92e414872d7567a31edaf2667", + "size": 206720, + "subdir": "linux-64", + "timestamp": 1535500467083, + "version": "1.6.1" + }, + "neo4j-python-driver-1.6.2-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fbf57bffa27add02ba1d221d8a6082f8", + "name": "neo4j-python-driver", + "sha256": "7c9496e2d5066bda9f289706a47edeff2c40cb3440bbd02374aaab3b0ba3f7df", + "size": 204006, + "subdir": "linux-64", + "timestamp": 1539648672339, + "version": "1.6.2" + }, + "neo4j-python-driver-1.6.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "42b8fc4b4d1d49dce317192c3ecbc7af", + "name": "neo4j-python-driver", + "sha256": "82347c37553794d7878fd3fba8e176fc612d564304f4cede6de2bc6c2a29ef6b", + "size": 210780, + "subdir": "linux-64", + "timestamp": 1539648697003, + "version": "1.6.2" + }, + "neo4j-python-driver-1.6.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bec17998a6047497983ea3ec7fe48c32", + "name": "neo4j-python-driver", + "sha256": "4808e8396f59bb681250d3480e0fcc901b1e87f911036acad01c5c3f918996d3", + "size": 210575, + "subdir": "linux-64", + "timestamp": 1539648694654, + "version": "1.6.2" + }, + "neo4j-python-driver-1.7.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "169e67c94d598ab5540b87b3c4768f3d", + "name": "neo4j-python-driver", + "sha256": "62423026998f814e5efecbac2e904aef5fd2ecb47a64a8a4e6aff8b539e64298", + "size": 54266, + "subdir": "linux-64", + "timestamp": 1548315598448, + "version": "1.7.1" + }, + "neo4j-python-driver-1.7.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1449ce03b55d74031b0d1dfd59eb1001", + "name": "neo4j-python-driver", + "sha256": "e72eda9c99d69bfa980168cf511678a9d2ddb1983372b1f320d62ad67a335f45", + "size": 55474, + "subdir": "linux-64", + "timestamp": 1548315616919, + "version": "1.7.1" + }, + "neo4j-python-driver-1.7.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d34acabdaa0264b6d66cebd85d79b81f", + "name": "neo4j-python-driver", + "sha256": "c9b4b946d71ba6322177f7d8fb552538f44925ab1eed040bbbb217c15a1f1ed4", + "size": 55563, + "subdir": "linux-64", + "timestamp": 1548315623095, + "version": "1.7.1" + }, + "neo4j-python-driver-1.7.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a960fc7cde47931cd3747320f581f461", + "name": "neo4j-python-driver", + "sha256": "d78c678c80bcbe54d5a60cef19be5c3a6d04ffb10abb382695e80f826965b839", + "size": 54533, + "subdir": "linux-64", + "timestamp": 1574354175105, + "version": "1.7.1" + }, + "neo4j-python-driver-4.1.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "76652b9c75ef38c3f17ffe3372d52ab5", + "name": "neo4j-python-driver", + "sha256": "b2d02422be99cf5fe309a4ec14315b93ea2c7c8960497fe1138a71259199bd80", + "size": 276946, + "subdir": "linux-64", + "timestamp": 1600446251988, + "version": "4.1.1" + }, + "neo4j-python-driver-4.1.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f98b7584e5663cccb7eda2eabfb6fe4f", + "name": "neo4j-python-driver", + "sha256": "b0d1e5e8bd795129499462e2fc668f5ef442050e2c49a1c61cdb097b598358bc", + "size": 277988, + "subdir": "linux-64", + "timestamp": 1600446236189, + "version": "4.1.1" + }, + "neo4j-python-driver-4.1.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fb49620942def1721ffd8aa16c348987", + "name": "neo4j-python-driver", + "sha256": "5e782a36f23f9ce0cdb100cbc3ea2fd8237e8e5ede441ef60bb514159a6b9de2", + "size": 278938, + "subdir": "linux-64", + "timestamp": 1600446211701, + "version": "4.1.1" + }, + "neo4j-python-driver-4.2.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3a4e7cc76a813b983c462d3224adb395", + "name": "neo4j-python-driver", + "sha256": "97c7115221c5a5a82fdf08dddf6ca3c96bb8be34324de317a4b8047aa4c8bb55", + "size": 277436, + "subdir": "linux-64", + "timestamp": 1606153805877, + "version": "4.2.0" + }, + "neo4j-python-driver-4.2.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7597fdcb8c83f55621dd102692dd343e", + "name": "neo4j-python-driver", + "sha256": "5ad67a4c4e37978e9380295009f5df82606783c081c75693f780185279656290", + "size": 277979, + "subdir": "linux-64", + "timestamp": 1606153781397, + "version": "4.2.0" + }, + "neo4j-python-driver-4.2.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ad22e24b040176114e315e059cb53e8a", + "name": "neo4j-python-driver", + "sha256": "e0b69a493cc654676ef078d0ddb147eddeb9421363411f3ca0201b3c6f7689b2", + "size": 276809, + "subdir": "linux-64", + "timestamp": 1606153762969, + "version": "4.2.0" + }, + "neo4j-python-driver-4.2.1-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9576505d14d003b7d5e3f4bc0605c1ab", + "name": "neo4j-python-driver", + "sha256": "158dd82614c455ef12db65d433915d8edd97242d9ca155d61d0325204289a0a8", + "size": 283921, + "subdir": "linux-64", + "timestamp": 1608577674836, + "version": "4.2.1" + }, + "neo4j-python-driver-4.2.1-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2560afa57cbce2bd139122dcff8b6160", + "name": "neo4j-python-driver", + "sha256": "5cf3ab0aefe09b52e601a78e8f0e7ebe438a698b54eb9afd1a248b6b8443e57f", + "size": 280730, + "subdir": "linux-64", + "timestamp": 1608577666917, + "version": "4.2.1" + }, + "neo4j-python-driver-4.2.1-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2103d38cd28cd3668aed88224befd1d5", + "name": "neo4j-python-driver", + "sha256": "848153ea9e9d272912156d55bb6713cbd74f4b2d6df0214ebeb6a32a1c1cbd59", + "size": 281301, + "subdir": "linux-64", + "timestamp": 1608577670751, + "version": "4.2.1" + }, + "neo4j-python-driver-4.2.1-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6fdf3c0e1bd15a9200a3013a93d44e74", + "name": "neo4j-python-driver", + "sha256": "eea8fb5e7d45dea8f20e3e91329cb13338623055d2926f1582560388cc16a9d7", + "size": 281839, + "subdir": "linux-64", + "timestamp": 1608579557898, + "version": "4.2.1" + }, + "neo4j-python-driver-4.3.1-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2bb9eec1f511444807e3a9028be77683", + "name": "neo4j-python-driver", + "sha256": "1fd855672806682bc90d3b07fb74d379fb2a84e6f7952d3e75f5aa0a1bfc6ec0", + "size": 299132, + "subdir": "linux-64", + "timestamp": 1622832415066, + "version": "4.3.1" + }, + "neo4j-python-driver-4.3.1-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6769288e08bba3f47d06674fd778d161", + "name": "neo4j-python-driver", + "sha256": "5edc63bfd72bee88d306a03dd553d464f3ad1d448c732b298572492f98f52b4b", + "size": 296892, + "subdir": "linux-64", + "timestamp": 1622832416379, + "version": "4.3.1" + }, + "neo4j-python-driver-4.3.1-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fe11aca78d1fce568a1961ae8de5f2bb", + "name": "neo4j-python-driver", + "sha256": "4439fad32594b8c084a824c09a4b6068f06bec45015714c96a72de4cef8357c5", + "size": 298239, + "subdir": "linux-64", + "timestamp": 1622832434431, + "version": "4.3.1" + }, + "neo4j-python-driver-4.3.1-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "91391a408a8d1fabacc98e7dece8efab", + "name": "neo4j-python-driver", + "sha256": "7ba9441900f2826da014ed5963c720c1986f0b2076885ddf58aea9590a72438b", + "size": 298969, + "subdir": "linux-64", + "timestamp": 1623056903334, + "version": "4.3.1" + }, + "neo4j-python-driver-4.3.2-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e7db1672b7ba6c99c77527cb4314e4ab", + "name": "neo4j-python-driver", + "sha256": "5366eb9e14b238be1f9cdc7dd2b897c4720954de95fd98537f55abc27e1d710e", + "size": 290725, + "subdir": "linux-64", + "timestamp": 1625816304543, + "version": "4.3.2" + }, + "neo4j-python-driver-4.3.3-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e587a1cf5e283ff3103bb23f0063319e", + "name": "neo4j-python-driver", + "sha256": "88260d8338f539044c54c4bf66724b717a3767c0584ee1215124e1fd91f57fe7", + "size": 291796, + "subdir": "linux-64", + "timestamp": 1626240217775, + "version": "4.3.3" + }, + "neo4j-python-driver-4.3.4-py36h7f8727e_0.tar.bz2": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7c0123c99a3ec3365662784f728adebe", + "name": "neo4j-python-driver", + "sha256": "9347154657325d5e8b5edf1b005b7a2192cff9898687861865c76d338b0e7cae", + "size": 297435, + "subdir": "linux-64", + "timestamp": 1632894470778, + "version": "4.3.4" + }, + "neo4j-python-driver-4.3.4-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3d7900b3b8b851604eae83860bd01f50", + "name": "neo4j-python-driver", + "sha256": "7bc8488b95e2624ced482a4564e3e1b41d0ad611ad5d1c45714774062864204c", + "size": 294520, + "subdir": "linux-64", + "timestamp": 1632894449824, + "version": "4.3.4" + }, + "neo4j-python-driver-4.3.4-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6927ae62280cff9234e180675783f786", + "name": "neo4j-python-driver", + "sha256": "410e64807e1f13d86a69721e8490e3ba13bebdb32aaa434d1fffd229b99cb087", + "size": 295002, + "subdir": "linux-64", + "timestamp": 1632884026735, + "version": "4.3.4" + }, + "neo4j-python-driver-4.3.4-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7693d5e4a8a5e41dec832ad344758eff", + "name": "neo4j-python-driver", + "sha256": "8ee7ff631a3d41aba4aac7cd32073d2b80c7c464c601c0c7ca9e8ebc66a4b69c", + "size": 292712, + "subdir": "linux-64", + "timestamp": 1628152080160, + "version": "4.3.4" + }, + "neo4j-python-driver-4.4.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e450fd57af3059990aa062ddfa174af6", + "name": "neo4j-python-driver", + "sha256": "6d9713499b2e36a446d46483b60bc16387518dca14241651c27b893efc37f693", + "size": 318970, + "subdir": "linux-64", + "timestamp": 1640809595243, + "version": "4.4.0" + }, + "neo4j-python-driver-4.4.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f0332a59b509cc60d226d80ba6dbb23c", + "name": "neo4j-python-driver", + "sha256": "ec5b6cb1673c512af4cff088c01ab3b7b33871780ca07cd05116fb29358c56ce", + "size": 439816, + "subdir": "linux-64", + "timestamp": 1676859934644, + "version": "4.4.0" + }, + "neo4j-python-driver-4.4.0-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e46248640519f11209e41a04c9e0864c", + "name": "neo4j-python-driver", + "sha256": "1ace5686ef400c9e173186f9a42e65b7b96bdabf43764788325223ff445ef4a8", + "size": 315868, + "subdir": "linux-64", + "timestamp": 1639143576396, + "version": "4.4.0" + }, + "neo4j-python-driver-4.4.0-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9c6243a28421617d7e1b4d5d600073fe", + "name": "neo4j-python-driver", + "sha256": "76e170b8fc9e5037d0ec22d78e9b27d6c8d26e60721e1177aa49f7d261147fcf", + "size": 319071, + "subdir": "linux-64", + "timestamp": 1639129998909, + "version": "4.4.0" + }, + "neo4j-python-driver-4.4.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0ad637aa74d11809afadb05a3c2fc636", + "name": "neo4j-python-driver", + "sha256": "5c189bba1baee52455a1ac097e1a433b5f654b000af1cb4d1926c0f53f25edad", + "size": 318125, + "subdir": "linux-64", + "timestamp": 1639143575346, + "version": "4.4.0" + }, + "neon-2.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=2.7,<2.8.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "227fa2e76a1c21991bec527e4de10d0d", + "name": "neon", + "sha256": "463b9daa06adfea290683479db06d5fd2d800782ef7395b8e74d4aeac800122b", + "size": 757155, + "subdir": "linux-64", + "timestamp": 1539277024446, + "version": "2.6.0" + }, + "neon-2.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=3.10,<3.11.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "130ca29d01f22ba3e2e8b3a17f5e7649", + "name": "neon", + "sha256": "e211b8234befaefe26e1ea23cd7195d9b6cf3731d7ab5ae8973af33eb242ff3c", + "size": 763806, + "subdir": "linux-64", + "timestamp": 1642516077032, + "version": "2.6.0" + }, + "neon-2.6.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=3.11,<3.12.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6cad8c6c276d9fea85b004c7a1d71e60", + "name": "neon", + "sha256": "f246d7e0e9ff0bad1ed04bb93d2f43b76c02222358419ad5a71ec77475309b7c", + "size": 949947, + "subdir": "linux-64", + "timestamp": 1676907347409, + "version": "2.6.0" + }, + "neon-2.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=3.6,<3.7.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e42f2730fd441ab4bb0e2317b9c3a057", + "name": "neon", + "sha256": "a13b85156a81405b9f2062d69499eea8f3fa7c99921c5cca7548552457275f19", + "size": 775897, + "subdir": "linux-64", + "timestamp": 1539277022823, + "version": "2.6.0" + }, + "neon-2.6.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=3.6,<3.7.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9307712cbd5f1de56bc636f2c3d1e6e1", + "name": "neon", + "sha256": "d56fa8d8c53499497ad4e1be092c27b84b3d6faeee7c6d1b4ccb70e25e345ea6", + "size": 994201, + "subdir": "linux-64", + "timestamp": 1614082820406, + "version": "2.6.0" + }, + "neon-2.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=3.7,<3.8.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2d1734343d353e5dcc4fa97db0e971d3", + "name": "neon", + "sha256": "4ab66f415e738cda8b3634695e63eca934e0ab5e2ada5bb716c6fb809036dab1", + "size": 769143, + "subdir": "linux-64", + "timestamp": 1539277032483, + "version": "2.6.0" + }, + "neon-2.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=3.7,<3.8.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e54576e094eb91b1239d6a8ddabdd194", + "name": "neon", + "sha256": "80d1083ffc6d0d1adc1f7de1fad25b97a8e75bdab8e49d5e1ecf84d05abc7446", + "size": 991770, + "subdir": "linux-64", + "timestamp": 1614082832978, + "version": "2.6.0" + }, + "neon-2.6.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=3.8,<3.9.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "17ee334ecf9166fda91fa3337b14dea6", + "name": "neon", + "sha256": "e6c69a502c59db09a64ae5ba86ae8653dacce65107f81d6c6718623fd6ac5720", + "size": 772353, + "subdir": "linux-64", + "timestamp": 1574177594889, + "version": "2.6.0" + }, + "neon-2.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=3.8,<3.9.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "143a8aa6d7ceb79f317526785e3e2a17", + "name": "neon", + "sha256": "36d52abcd7fcb1bf57b1a822423d2ffc70c35d9303753c4f277fe64cce0b0215", + "size": 994570, + "subdir": "linux-64", + "timestamp": 1614081901902, + "version": "2.6.0" + }, + "neon-2.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=3.9,<3.10.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1abc862158b3101327aa120bf2fd9f61", + "name": "neon", + "sha256": "5c1b09f65ca1d76a455f2bd99a3cf4f4db201404c423b3e5b22258b36495d80a", + "size": 989435, + "subdir": "linux-64", + "timestamp": 1614082830835, + "version": "2.6.0" + }, + "neotime-1.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "4def64320b20c67427dc58678633150f", + "name": "neotime", + "sha256": "d7f0affd16a3aecbc184b51b31892656ad8fadfff34add411bc2bcc5e12c6836", + "size": 33171, + "subdir": "linux-64", + "timestamp": 1527831764410, + "version": "1.0.0" + }, + "neotime-1.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "6d7544d2eb82e435c1e8afa101c033bc", + "name": "neotime", + "sha256": "0d98a5062f76652e7167ce1f748f14fbea555f6f639728fab0e847d44efd141f", + "size": 34270, + "subdir": "linux-64", + "timestamp": 1527831788682, + "version": "1.0.0" + }, + "neotime-1.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "0492486f928bb05e24cda4605d4c9001", + "name": "neotime", + "sha256": "4553520bc47dc4b51ab985a0e7ab3e37deaf5e5640e9240dccc0749a76588241", + "size": 34144, + "subdir": "linux-64", + "timestamp": 1527831750272, + "version": "1.0.0" + }, + "neotime-1.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "12125a649ea10ad26faef33cbb7cd17c", + "name": "neotime", + "sha256": "9ee235d258631113104af58682e45497fa50daf14f8b465040cf322dc122bfe0", + "size": 34195, + "subdir": "linux-64", + "timestamp": 1530901479876, + "version": "1.0.0" + }, + "neotime-1.7.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "01a3847ea3e49a8aeedf57c6a67959d9", + "name": "neotime", + "sha256": "df6d333b1bc7ce4f33943c077bc6aa26b02f38df1e9c4a25092cb45da4cd2aef", + "size": 35288, + "subdir": "linux-64", + "timestamp": 1539724322521, + "version": "1.7.1" + }, + "neotime-1.7.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "7aa02b8ff52f67638e35c172a646441f", + "name": "neotime", + "sha256": "ed64ffa455afcbf83abcd7441eaaf02100910342a05b210962a46e614d025b45", + "size": 36322, + "subdir": "linux-64", + "timestamp": 1539724350062, + "version": "1.7.1" + }, + "neotime-1.7.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "74e0a8be3247146a55a9f627e3309d2f", + "name": "neotime", + "sha256": "b8cf18317d8344dbac37228b8e7b8bda21e41ebea9f0c26904caa410a6b60603", + "size": 36333, + "subdir": "linux-64", + "timestamp": 1539724347621, + "version": "1.7.1" + }, + "neotime-1.7.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "787ca7e5ea986238bfe082199e177686", + "name": "neotime", + "sha256": "537567a3d038ac3aac8dca1726bb54b3b86f60c98af74d14e5a936b7aa260685", + "size": 36652, + "subdir": "linux-64", + "timestamp": 1545120408730, + "version": "1.7.4" + }, + "neotime-1.7.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "c48ddc5bbab4f3ec6d1268c6adf6e8b7", + "name": "neotime", + "sha256": "37b4a86318007fcb61719815f6a1d35612f043586c960e69b3db6b1e830ab473", + "size": 38476, + "subdir": "linux-64", + "timestamp": 1640791885711, + "version": "1.7.4" + }, + "neotime-1.7.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "5e073fa84ba45ac38c04a93debaed0de", + "name": "neotime", + "sha256": "431178baa55dbdbc29670002d7ac595487e87b91df5642c6e30dd78c4ba1dd6f", + "size": 49902, + "subdir": "linux-64", + "timestamp": 1676907365509, + "version": "1.7.4" + }, + "neotime-1.7.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "5997594190120e4f01af0ae8475fecdd", + "name": "neotime", + "sha256": "d8f1356ddb19b1fd98c027f6b4aa14698b0dcc5fa30145b11f236455f6b798e5", + "size": 37635, + "subdir": "linux-64", + "timestamp": 1545120443628, + "version": "1.7.4" + }, + "neotime-1.7.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "378534952ba4cbe7b9fecd3154c4c5b2", + "name": "neotime", + "sha256": "cd205a08d998d24e9c81a6a4d70b199fbb382262f03165607092d3059fee7270", + "size": 37646, + "subdir": "linux-64", + "timestamp": 1545120448749, + "version": "1.7.4" + }, + "neotime-1.7.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "001327f53406907b66c748bd75f5e496", + "name": "neotime", + "sha256": "f2257ea973f5a4c301f3017578320494f7a30da61efdeedfb093c84cce537dae", + "size": 38084, + "subdir": "linux-64", + "timestamp": 1573738326635, + "version": "1.7.4" + }, + "neotime-1.7.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "31ca518335426d5ad98f92d7d90e4906", + "name": "neotime", + "sha256": "92bb629064811abdc121ec1f2cca724199f549add111d050112a861d00e19abf", + "size": 248021, + "subdir": "linux-64", + "timestamp": 1608578515235, + "version": "1.7.4" + }, + "nest-asyncio-1.5.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "62a80fe0cb150e78c5b68ae3c37071f6", + "name": "nest-asyncio", + "sha256": "5c36d4b1f18f60efde355350053a0deadd66a69796d780e7446dd6698ca71365", + "size": 15636, + "subdir": "linux-64", + "timestamp": 1649830102129, + "version": "1.5.5" + }, + "nest-asyncio-1.5.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "751983aee03cd12695e4340efc808a8b", + "name": "nest-asyncio", + "sha256": "13e9bac1af5a3f85729bcfdf549ebad70a5b605f395fb7a4ca06a1813acb2c43", + "size": 15671, + "subdir": "linux-64", + "timestamp": 1677784395188, + "version": "1.5.5" + }, + "nest-asyncio-1.5.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f02ceedee3780a80303b822e94395ae5", + "name": "nest-asyncio", + "sha256": "ff5ca2f251f0c35ff27adadde70bfa831f43ceb66d73df13e26b5bcd45ad047a", + "size": 15338, + "subdir": "linux-64", + "timestamp": 1649847948369, + "version": "1.5.5" + }, + "nest-asyncio-1.5.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "0d84147b19b34ec20223f290fc0d5482", + "name": "nest-asyncio", + "sha256": "aab334f452cc1c60e75b32a8f28e2ea9e79c71eb2db72c0ffafa2ce4823290c0", + "size": 15370, + "subdir": "linux-64", + "timestamp": 1649847945010, + "version": "1.5.5" + }, + "nest-asyncio-1.5.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c5dd7c6f63fbc3dd2eeb657d32e72b02", + "name": "nest-asyncio", + "sha256": "e5b49b07ee7521c01010976903fec0c186b04372a090717494ef8946922ebc69", + "size": 15553, + "subdir": "linux-64", + "timestamp": 1649847942243, + "version": "1.5.5" + }, + "nest-asyncio-1.5.6-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "85a509faa4a3c9f1b3a3df32bab735e1", + "name": "nest-asyncio", + "sha256": "284c8c75d3c557d80d81d7861582218d9822794f24aa3ffaa1a4b6b87e141cae", + "size": 13184, + "subdir": "linux-64", + "timestamp": 1672387223720, + "version": "1.5.6" + }, + "nest-asyncio-1.5.6-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "2ecaffce0c50ea8a786a542a01349235", + "name": "nest-asyncio", + "sha256": "2a1ebd6af6c151eb938d7d73d61d77d8f5b10f64b344d118d6b8d22d6923b269", + "size": 16050, + "subdir": "linux-64", + "timestamp": 1676823394794, + "version": "1.5.6" + }, + "nest-asyncio-1.5.6-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "aafa41f0463f63467c567505df362d04", + "name": "nest-asyncio", + "sha256": "c4f864c86fbc5fe3aa4ec50a8b8de8404b2d9ba1c189344c98c5735ab64636de", + "size": 12890, + "subdir": "linux-64", + "timestamp": 1672387197034, + "version": "1.5.6" + }, + "nest-asyncio-1.5.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "839bb853e143fac8faccabe9c90ff79e", + "name": "nest-asyncio", + "sha256": "e07b5e33856bad27cb9577f79214a113163e27bfaadbac1950643141da43f0f6", + "size": 12944, + "subdir": "linux-64", + "timestamp": 1672387169775, + "version": "1.5.6" + }, + "nest-asyncio-1.5.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "bbbcbebc20a4fdcadce398d0ca04f95e", + "name": "nest-asyncio", + "sha256": "c1bf379f6530ea323debe819bd4fd1f9ddf8c70c4f514890d42e01a77af1f812", + "size": 13109, + "subdir": "linux-64", + "timestamp": 1672387143252, + "version": "1.5.6" + }, + "netcdf4-1.3.1-py27h03bd486_2.tar.bz2": { + "build": "py27h03bd486_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.5.0,<5.0a0", + "numpy >=1.14.0,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "88ad64df410104b6c934663adf70bd94", + "name": "netcdf4", + "sha256": "46541e545ed8472bc188c731c3db74000709430093786e2957d995f8d29f0b58", + "size": 746220, + "subdir": "linux-64", + "timestamp": 1518363667560, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py27h73d701b_2.tar.bz2": { + "build": "py27h73d701b_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.5.0,<5.0a0", + "numpy >=1.14.0,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "cc023eb0e753d626e285c0cacd1ad0ac", + "name": "netcdf4", + "sha256": "544a1504a4a0a115375782fd03fe0fda248559dadefa6b12c552abfc37df348a", + "size": 746314, + "subdir": "linux-64", + "timestamp": 1518363705925, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py27h7620a78_2.tar.bz2": { + "build": "py27h7620a78_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "8ff735257f6d50fcf936ad0ba0e478f0", + "name": "netcdf4", + "sha256": "74f3f8cbec4bb2539b560ee2ab692b152ec49a0f2bb128e47bdbb5c01a718df7", + "size": 744521, + "subdir": "linux-64", + "timestamp": 1511886279654, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py27hca9ce0b_2.tar.bz2": { + "build": "py27hca9ce0b_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "bfc1267b89f10ec3bf564e3afc391928", + "name": "netcdf4", + "sha256": "dd4b12e57dec4125d83110d3f0785d170e9e569f45d93fc705b5af50fbd43f03", + "size": 744607, + "subdir": "linux-64", + "timestamp": 1511886709425, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py35h03bd486_2.tar.bz2": { + "build": "py35h03bd486_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.5.0,<5.0a0", + "numpy >=1.14.0,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "8392b81eb57e4cf927a2cff6ef044778", + "name": "netcdf4", + "sha256": "c9bc2fb1bcc3fafcf3212c15242d26cda512eb0e57a49c87cce157a079be96a1", + "size": 744931, + "subdir": "linux-64", + "timestamp": 1518363694708, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py35h30e38b8_2.tar.bz2": { + "build": "py35h30e38b8_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "fdab8319ce7f3f2c77f5eb4bf360b2d4", + "name": "netcdf4", + "sha256": "cf70ef40cc7316bfd8001193783a5790f0b53f1f805be2505a7eb266d1f7b1e2", + "size": 738620, + "subdir": "linux-64", + "timestamp": 1511886713431, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py35h73d701b_2.tar.bz2": { + "build": "py35h73d701b_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.5.0,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "277b4d7e08bf4cd8856abbc023cd8faa", + "name": "netcdf4", + "sha256": "751712895f79ccab3fe4760e9befa48a63c2c6f9a25cee102a8a4329e65602da", + "size": 744943, + "subdir": "linux-64", + "timestamp": 1518363715132, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py35he671f65_2.tar.bz2": { + "build": "py35he671f65_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "3bbcfd5c7ce7fc5070d3985eb0e7464e", + "name": "netcdf4", + "sha256": "6e14ff6f5df1be8da42b77f7daa2675c67b278b42767c6775dca40b5763462b0", + "size": 738598, + "subdir": "linux-64", + "timestamp": 1511886280672, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py36h03bd486_2.tar.bz2": { + "build": "py36h03bd486_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.5.0,<5.0a0", + "numpy >=1.14.0,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "e693811bc0f67750d9d2702724a201cd", + "name": "netcdf4", + "sha256": "b3548b7cbaf6727d7fcd3c77045e60c08f477ebd0374a386749e5d45d2b1f727", + "size": 776534, + "subdir": "linux-64", + "timestamp": 1518363361651, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py36h73d701b_2.tar.bz2": { + "build": "py36h73d701b_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.5.0,<5.0a0", + "numpy >=1.14.0,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "1e1a85aefd4fe2541ed75e4bd8e1bb4c", + "name": "netcdf4", + "sha256": "713c32a6f521076d1ad676d06ba4d565eb5f60b4e34e885e5171b2466beca7da", + "size": 776726, + "subdir": "linux-64", + "timestamp": 1518363699990, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py36h771828c_2.tar.bz2": { + "build": "py36h771828c_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "e34780f8dc4b45cd006fea2b7c648e96", + "name": "netcdf4", + "sha256": "3810b38401b539481de34c4df8543f1278bf6755ffc50d06018f4d29f0c2003c", + "size": 769575, + "subdir": "linux-64", + "timestamp": 1511886732450, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py36hfd655bd_2.tar.bz2": { + "build": "py36hfd655bd_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "5b8676c2e9be13a88eee4d33139a7161", + "name": "netcdf4", + "sha256": "a3b4433d2d19398cb3fae13db37919480d04783c7896a95ec7c7283177a75306", + "size": 770120, + "subdir": "linux-64", + "timestamp": 1511886728330, + "version": "1.3.1" + }, + "netcdf4-1.4.0-py27h044acb6_1.tar.bz2": { + "build": "py27h044acb6_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "c61001e7a06463182e6642a1e8f4d9b5", + "name": "netcdf4", + "sha256": "e6357879b10c296051c87e2ef0844f85d6fcc1e60528739294f71a29fd17493a", + "size": 529579, + "subdir": "linux-64", + "timestamp": 1526241402976, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py27h0bb92ad_1.tar.bz2": { + "build": "py27h0bb92ad_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "b91fb661a8469bc19f893c8d470ef7e9", + "name": "netcdf4", + "sha256": "b466d9b4a1c7ce7ddab9641d13d58f5b78d5f12eaaf0453dc84a663dae4248d2", + "size": 531043, + "subdir": "linux-64", + "timestamp": 1530902243178, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py27ha06eab4_1.tar.bz2": { + "build": "py27ha06eab4_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "f9ea075ac768a26ed86ddfa4ed932c60", + "name": "netcdf4", + "sha256": "a5d8473fda9fd16f3c9bdf5eb027d2d14be0936e5ca4b5f154ab816f37a710a6", + "size": 530890, + "subdir": "linux-64", + "timestamp": 1530902164336, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py27hd4b6044_1.tar.bz2": { + "build": "py27hd4b6044_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "e45571fb3ce55f229c45d921b51d9d1b", + "name": "netcdf4", + "sha256": "67985b922c2f9440b93a7b7c736e3f1bb60eac60b3548c2426d59ac39b1ddfd8", + "size": 529811, + "subdir": "linux-64", + "timestamp": 1526241296747, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py35h044acb6_1.tar.bz2": { + "build": "py35h044acb6_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "936ade9011c0217ab6c5e9ecd1e89fbe", + "name": "netcdf4", + "sha256": "d416b33b7b4ce713c1f1105072faedbb945bd8889f822056a07d83202e5f8e87", + "size": 533569, + "subdir": "linux-64", + "timestamp": 1526253869871, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py35hd4b6044_1.tar.bz2": { + "build": "py35hd4b6044_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "3397ec347a8e648fc056da530f921f31", + "name": "netcdf4", + "sha256": "b323fde62947c3225416f0d61edbe7ece080151e54d21099e91f8a11c208b53a", + "size": 533646, + "subdir": "linux-64", + "timestamp": 1526254055240, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py36h044acb6_1.tar.bz2": { + "build": "py36h044acb6_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "c80f5c370680d33cb311b9ddc8a431a8", + "name": "netcdf4", + "sha256": "5c468c220ca7fa87896104d52a732f6a61ac1cbe4135361ae8ef358d0e7f7371", + "size": 548779, + "subdir": "linux-64", + "timestamp": 1526241296953, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py36h0bb92ad_1.tar.bz2": { + "build": "py36h0bb92ad_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "5a0b4a6a39d8efaedad19b65ae1f9a66", + "name": "netcdf4", + "sha256": "a3ec3b22246c8d941d37701889d8c5943b85262cdccd65131c5545700bc30ae2", + "size": 548660, + "subdir": "linux-64", + "timestamp": 1530902084874, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py36ha06eab4_1.tar.bz2": { + "build": "py36ha06eab4_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "7742983c6fe170552af19c6280801c65", + "name": "netcdf4", + "sha256": "099c824102490ec6cb835afdc8b5246cfc5ef499a80473fb567b53eaf7ca9b59", + "size": 548614, + "subdir": "linux-64", + "timestamp": 1530902000224, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py36hd4b6044_1.tar.bz2": { + "build": "py36hd4b6044_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "38be11a9f1a6be4e3bcaf75171858676", + "name": "netcdf4", + "sha256": "b868c1b8355a1029791629290b34f65d641daa6edcce07512c5415ed4508bcb8", + "size": 549011, + "subdir": "linux-64", + "timestamp": 1526241296867, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py37h0bb92ad_1.tar.bz2": { + "build": "py37h0bb92ad_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "2aca150738a36b3a8476a9280a242669", + "name": "netcdf4", + "sha256": "71f505a19467ee99c7c6e42d5e4b62c10e048308c85d9b3be802895fd54a902a", + "size": 544433, + "subdir": "linux-64", + "timestamp": 1530901915926, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py37ha06eab4_1.tar.bz2": { + "build": "py37ha06eab4_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "1283e3d6ef30a67e3f978c0b873c2335", + "name": "netcdf4", + "sha256": "10f1799f6fb7fef9ec32d67f7f9fbc95e067dd4dba64f8e64d97679ffba634bc", + "size": 544533, + "subdir": "linux-64", + "timestamp": 1530901830507, + "version": "1.4.0" + }, + "netcdf4-1.4.1-py27h083d9da_0.tar.bz2": { + "build": "py27h083d9da_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "67b83ba8c86e7f7094a076401c577bbb", + "name": "netcdf4", + "sha256": "64a5242378d386fcb2627eb6d96cdaf40af6592243dfe7fcaacfb6f843f5cb76", + "size": 527961, + "subdir": "linux-64", + "timestamp": 1535559147402, + "version": "1.4.1" + }, + "netcdf4-1.4.1-py27h4b4f87f_0.tar.bz2": { + "build": "py27h4b4f87f_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "3fb164414b7c0e7eee2a17530f6ea652", + "name": "netcdf4", + "sha256": "3799bb279bc13f016cac4652acd5deb1f7e59cb425c54736afbe7f8c4ffb9b3c", + "size": 528077, + "subdir": "linux-64", + "timestamp": 1535558849433, + "version": "1.4.1" + }, + "netcdf4-1.4.1-py35h083d9da_0.tar.bz2": { + "build": "py35h083d9da_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "820fc81fbf485bbebd888d360ab90fe1", + "name": "netcdf4", + "sha256": "fd2b51324dabccd9cd50d5092a5e4981fa898f294ad522212a23599122a9d111", + "size": 531413, + "subdir": "linux-64", + "timestamp": 1535558942685, + "version": "1.4.1" + }, + "netcdf4-1.4.1-py35h4b4f87f_0.tar.bz2": { + "build": "py35h4b4f87f_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "5ca3ff8d0627dcdcb65fa1a51a24aff4", + "name": "netcdf4", + "sha256": "ea6f078a91cf167593ee22e8cabf1b839f113aa73c51be500ccf8503717317c1", + "size": 531428, + "subdir": "linux-64", + "timestamp": 1535558791248, + "version": "1.4.1" + }, + "netcdf4-1.4.1-py36h083d9da_0.tar.bz2": { + "build": "py36h083d9da_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "d861c5518b6de4f70b266bef23ab4d32", + "name": "netcdf4", + "sha256": "8fcb0fa036e69641a999ed0b9019c0eae22f8631ab58f153853e2ffe08346e7d", + "size": 544571, + "subdir": "linux-64", + "timestamp": 1535558854959, + "version": "1.4.1" + }, + "netcdf4-1.4.1-py36h4b4f87f_0.tar.bz2": { + "build": "py36h4b4f87f_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "43c3f7b0467700dcecca62bf56f4e04f", + "name": "netcdf4", + "sha256": "5b58d2e39ba43d1a75022691daa03a5c81212bc3a0e7601b6486aa900ae5c46b", + "size": 544705, + "subdir": "linux-64", + "timestamp": 1535559054817, + "version": "1.4.1" + }, + "netcdf4-1.4.1-py37h083d9da_0.tar.bz2": { + "build": "py37h083d9da_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "c10d2a7da3db6fddb34f942b9a40ff69", + "name": "netcdf4", + "sha256": "c111a62588cc1f475ce1a1b6a5e0558cf507a558fdb72811d65d40ecf116b01a", + "size": 543884, + "subdir": "linux-64", + "timestamp": 1535559233173, + "version": "1.4.1" + }, + "netcdf4-1.4.1-py37h4b4f87f_0.tar.bz2": { + "build": "py37h4b4f87f_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "1fc5466336522a10b5857196621270a3", + "name": "netcdf4", + "sha256": "9ae0b4b18a63187ad7f4ec782dc04af235e1817da68ffb6b84d00af994005bbe", + "size": 543575, + "subdir": "linux-64", + "timestamp": 1535559258352, + "version": "1.4.1" + }, + "netcdf4-1.4.2-py27h083d9da_0.tar.bz2": { + "build": "py27h083d9da_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "589921106cba23512d481609b9bf2ed3", + "name": "netcdf4", + "sha256": "5fcab8e5c3d5cd1c9da73b024317ede9a2517e0edc9e4d91497acc9760a5d38a", + "size": 511371, + "subdir": "linux-64", + "timestamp": 1541021399962, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py27h4b4f87f_0.tar.bz2": { + "build": "py27h4b4f87f_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "c928b53264b059c00f00cf9c39643081", + "name": "netcdf4", + "sha256": "c67140ea238163b2c6be9c921e6b72bfe8875c51154164d357bd9698b0b7e1f1", + "size": 510970, + "subdir": "linux-64", + "timestamp": 1541021514725, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py27h808af73_0.tar.bz2": { + "build": "py27h808af73_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "addf6d377cfb20d3e8308821a821d029", + "name": "netcdf4", + "sha256": "bd8c9c401dfe9f656d852fd65a8c3c0405189f94315ce6519b286ef043ebbaae", + "size": 512394, + "subdir": "linux-64", + "timestamp": 1545407135615, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py36h083d9da_0.tar.bz2": { + "build": "py36h083d9da_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "cfe5c436089481e428bb722467b8439d", + "name": "netcdf4", + "sha256": "30c21a439fb20130f85a98ed42a8c983a94e1636aee9fa3f10b68b3687454fa3", + "size": 540905, + "subdir": "linux-64", + "timestamp": 1541021485723, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py36h4b4f87f_0.tar.bz2": { + "build": "py36h4b4f87f_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "42e83d469da3aaad17d3bad9a143e656", + "name": "netcdf4", + "sha256": "75b8adf1ae274a2f5fdb9284ed35b4cb1c5a3db6fd7883448b629d5724aa8c0b", + "size": 538927, + "subdir": "linux-64", + "timestamp": 1541021491591, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py36h808af73_0.tar.bz2": { + "build": "py36h808af73_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "29a7e41534c17e7b3c4882ff5bddf497", + "name": "netcdf4", + "sha256": "011c076570a7af0078dc4cc52ddd695e0bc3bf51a226b58c3a8c1d1a325135b8", + "size": 540452, + "subdir": "linux-64", + "timestamp": 1545407163532, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py36hd5c503a_0.tar.bz2": { + "build": "py36hd5c503a_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "a7c17e6ff5b2533df85022090489a976", + "name": "netcdf4", + "sha256": "ca8c5e3793483bfaea9cb27d7e3d817dfcc1fa852222a87d74b3b0f98294fa90", + "size": 471828, + "subdir": "linux-64", + "timestamp": 1613633671203, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py37h083d9da_0.tar.bz2": { + "build": "py37h083d9da_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "ba790dd07374ae21cab43238bf620f41", + "name": "netcdf4", + "sha256": "d03a5062e3b0e1c65e97fc4c5b99b3840b4a21f2548aff83f481f8059e1fc64e", + "size": 540869, + "subdir": "linux-64", + "timestamp": 1541021286037, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py37h4b4f87f_0.tar.bz2": { + "build": "py37h4b4f87f_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "41ba06eb6926847bd5622f3bb724e61f", + "name": "netcdf4", + "sha256": "d7a3451fc2092d07686f895ebf12ac05977b4d0e3191ab51dc7758e4c0ab810d", + "size": 537015, + "subdir": "linux-64", + "timestamp": 1541021366560, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py37h808af73_0.tar.bz2": { + "build": "py37h808af73_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "944e8f279aedac36967d30201519f70e", + "name": "netcdf4", + "sha256": "dcdd4c3539bcf02af608c7bef72bfc2f23cc0e496cae63475f3f5d495a469df2", + "size": 540663, + "subdir": "linux-64", + "timestamp": 1545407167170, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py37hd5c503a_0.tar.bz2": { + "build": "py37hd5c503a_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "276c3713d5c37673fd1674db20e26d77", + "name": "netcdf4", + "sha256": "880965a1f4f3cc3be7b6293e1eec07d69610d1e8d120fccc67a47c7a5178227b", + "size": 471862, + "subdir": "linux-64", + "timestamp": 1613634550762, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py38hd5c503a_0.tar.bz2": { + "build": "py38hd5c503a_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "0b9fd69f8a86bab0a2ce6c99c039a828", + "name": "netcdf4", + "sha256": "e7e08f6687811b7b7fdabfc5eadbd2094814f31e387e61fe76f58f9d8b046a54", + "size": 499572, + "subdir": "linux-64", + "timestamp": 1613634567659, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py39hd5c503a_0.tar.bz2": { + "build": "py39hd5c503a_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "342d4efe70c629896ecacefa5e139968", + "name": "netcdf4", + "sha256": "ecb944a2555a275800f95e10dd2586a1da4c8b5718795f6f8db60cf14725b86e", + "size": 504763, + "subdir": "linux-64", + "timestamp": 1613633862778, + "version": "1.4.2" + }, + "netcdf4-1.5.3-py36hbf33ddf_0.tar.bz2": { + "build": "py36hbf33ddf_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.7.3,<5.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "2a761a32d17ec3f5d11aa2faa3bb4d93", + "name": "netcdf4", + "sha256": "b801cce9cc57723ad2baf5605015f15e89d23a4d005895b92cd79a1e7e4600a8", + "size": 565334, + "subdir": "linux-64", + "timestamp": 1582227310354, + "version": "1.5.3" + }, + "netcdf4-1.5.3-py37hbf33ddf_0.tar.bz2": { + "build": "py37hbf33ddf_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.7.3,<5.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "7da89ae2aea43dd2162bcab2f1d56b69", + "name": "netcdf4", + "sha256": "7f96f1178430089a1eca9b7ccd3aa0c215c7a7ae3d127d17bca2a883b9db6bfc", + "size": 566237, + "subdir": "linux-64", + "timestamp": 1582227337484, + "version": "1.5.3" + }, + "netcdf4-1.5.3-py38hbf33ddf_0.tar.bz2": { + "build": "py38hbf33ddf_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.7.3,<5.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "8ac1a08994ab7e3b6c8576a8bf59f0e4", + "name": "netcdf4", + "sha256": "2643de4e191aa0fcc6e992634180af5812a6c7d1f621199a4f2719d10a1b1571", + "size": 598945, + "subdir": "linux-64", + "timestamp": 1582227382974, + "version": "1.5.3" + }, + "netcdf4-1.5.6-py36hd5c503a_0.tar.bz2": { + "build": "py36hd5c503a_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "cd794efb5de35ea25332230b9367bad5", + "name": "netcdf4", + "sha256": "ecdfc58afc6fd0b77b497dfff68dd72e040c732ab9eff7547065e027523d39b9", + "size": 479744, + "subdir": "linux-64", + "timestamp": 1613684297490, + "version": "1.5.6" + }, + "netcdf4-1.5.6-py37hd5c503a_0.tar.bz2": { + "build": "py37hd5c503a_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "ec5a6425ab55df12abac407520a148ac", + "name": "netcdf4", + "sha256": "37effa1c2bcae7dd8bcdb192cbf3eefb8a0c006fbbf1bfb37628a6d3601513ea", + "size": 474841, + "subdir": "linux-64", + "timestamp": 1613683560462, + "version": "1.5.6" + }, + "netcdf4-1.5.6-py38hd5c503a_0.tar.bz2": { + "build": "py38hd5c503a_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "704f54c200cfe7e93ab203d3eebe0654", + "name": "netcdf4", + "sha256": "0a80601fe70fb2c5b930c56fd6517a975531f4e5930122a02d46cfda175da5db", + "size": 508697, + "subdir": "linux-64", + "timestamp": 1613684297569, + "version": "1.5.6" + }, + "netcdf4-1.5.6-py39hd5c503a_0.tar.bz2": { + "build": "py39hd5c503a_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "9b28eb152f417a7bc88f189b068a6b6b", + "name": "netcdf4", + "sha256": "cae2cffdef8bb93b40d539fc625c10def4c3617735d0f968db0c59227f3d72ff", + "size": 509220, + "subdir": "linux-64", + "timestamp": 1613684286336, + "version": "1.5.6" + }, + "netcdf4-1.5.7-py310hf533683_0.tar.bz2": { + "build": "py310hf533683_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd3f48fd0ea4bd9f34bb0aa43d7bf645", + "name": "netcdf4", + "sha256": "1a67a8ad97aa326b2f75aff4d1d30dbaad62da18287e32edc0d6f603fd7159dd", + "size": 1940627, + "subdir": "linux-64", + "timestamp": 1640809654226, + "version": "1.5.7" + }, + "netcdf4-1.5.7-py36h0a24e14_0.tar.bz2": { + "build": "py36h0a24e14_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "733e123116de6911c81707e10805ed75", + "name": "netcdf4", + "sha256": "a2080e1fb81be4226a5f24b3fcb8e6951d5e23914eab13c9f72ffe44d5a3b3ca", + "size": 476824, + "subdir": "linux-64", + "timestamp": 1624382985181, + "version": "1.5.7" + }, + "netcdf4-1.5.7-py37h0a24e14_0.tar.bz2": { + "build": "py37h0a24e14_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "32aa92b7afa25445a4caccd84911ab95", + "name": "netcdf4", + "sha256": "2618419c618fa0274f0be3cd62c15c355da509c238a7a1c4c2360836b017fd89", + "size": 474840, + "subdir": "linux-64", + "timestamp": 1624382987458, + "version": "1.5.7" + }, + "netcdf4-1.5.7-py37ha0f2276_1.tar.bz2": { + "build": "py37ha0f2276_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.8,<4.9.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd3c39f1cb12e2677a0a1e8077f1df76", + "name": "netcdf4", + "sha256": "a7de33f8a75496c5599e38cec5cf8875b82b016481175957b893a655ac5b857b", + "size": 472332, + "subdir": "linux-64", + "timestamp": 1643311678255, + "version": "1.5.7" + }, + "netcdf4-1.5.7-py38h0a24e14_0.tar.bz2": { + "build": "py38h0a24e14_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "a0bcfaea1aec82deed31fea9089e48c0", + "name": "netcdf4", + "sha256": "4aaa2aa98e9686c5a3205140e9b71580ff666bd4cf55861433359d7abe3c9c11", + "size": 510309, + "subdir": "linux-64", + "timestamp": 1624383388525, + "version": "1.5.7" + }, + "netcdf4-1.5.7-py38ha0f2276_1.tar.bz2": { + "build": "py38ha0f2276_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.8,<4.9.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "54e856517fdb869ba630bb39c49fd3b6", + "name": "netcdf4", + "sha256": "35757876321c3dd186f36cd8dad716a51f666dd6c5766e63ea40d3247ee9d27e", + "size": 507985, + "subdir": "linux-64", + "timestamp": 1643311809468, + "version": "1.5.7" + }, + "netcdf4-1.5.7-py39h0a24e14_0.tar.bz2": { + "build": "py39h0a24e14_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "af0326e90a44b83829e0f07e71bcf2bb", + "name": "netcdf4", + "sha256": "16354f214882bc65d96931e051dd3ba627e161a36f93df7a65b539f34aa2a8b3", + "size": 512568, + "subdir": "linux-64", + "timestamp": 1624383408294, + "version": "1.5.7" + }, + "netcdf4-1.5.7-py39ha0f2276_1.tar.bz2": { + "build": "py39ha0f2276_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.8,<4.9.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77e4d560ce089126c5bdd71be4a9a12e", + "name": "netcdf4", + "sha256": "60b66f04e3dac0442dd2f496fab1a7286f3b1f36d20c2dadcb279e35ed99bcfa", + "size": 507076, + "subdir": "linux-64", + "timestamp": 1643311746646, + "version": "1.5.7" + }, + "netcdf4-1.5.7-py39he70f4c8_0.tar.bz2": { + "build": "py39he70f4c8_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.20.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4b9ec764d67ba793f0761d680ade495a", + "name": "netcdf4", + "sha256": "0641422faf7d955fb829735e6fa1eb921a0add43180290beee387208879d59db", + "size": 508100, + "subdir": "linux-64", + "timestamp": 1624439489640, + "version": "1.5.7" + }, + "netcdf4-1.6.2-py310h6d89c78_0.tar.bz2": { + "build": "py310h6d89c78_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5", + "libgcc-ng >=11.2.0", + "libnetcdf >=4.8,<4.9.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ce7dea8c221031e6eba688a777e523f", + "name": "netcdf4", + "sha256": "bc1c199569e7ae2f26d5fe33913ea840635c70a388dff3c6f91a3c95917176a8", + "size": 502275, + "subdir": "linux-64", + "timestamp": 1673455610537, + "version": "1.6.2" + }, + "netcdf4-1.6.2-py311h0e679e6_0.tar.bz2": { + "build": "py311h0e679e6_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5", + "libgcc-ng >=11.2.0", + "libnetcdf >=4.8,<4.9.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "29dfd4701640eba0d1ebf674d74d3b9d", + "name": "netcdf4", + "sha256": "b15fc9c240136e7365c01b584b0c91e471f58d5d0f974d36b478b2b21f1d91f9", + "size": 511133, + "subdir": "linux-64", + "timestamp": 1676841290599, + "version": "1.6.2" + }, + "netcdf4-1.6.2-py37h89d13dc_0.tar.bz2": { + "build": "py37h89d13dc_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5", + "libgcc-ng >=11.2.0", + "libnetcdf >=4.8,<4.9.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e632a8bd3fa985728b09bdf32a76987", + "name": "netcdf4", + "sha256": "e6c94d54dac5bdbd2c7d980c98454b58050a902c80bed20b8199889e41f823c0", + "size": 488891, + "subdir": "linux-64", + "timestamp": 1673455796585, + "version": "1.6.2" + }, + "netcdf4-1.6.2-py38h89d13dc_0.tar.bz2": { + "build": "py38h89d13dc_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5", + "libgcc-ng >=11.2.0", + "libnetcdf >=4.8,<4.9.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eaa30d439caf6de89f4c5641a1908a8b", + "name": "netcdf4", + "sha256": "6fc3d6b5481c6421db03dded3fbac02c0f92806917cbd75f9ff89edbbe9f95ff", + "size": 539752, + "subdir": "linux-64", + "timestamp": 1673455535018, + "version": "1.6.2" + }, + "netcdf4-1.6.2-py39h89d13dc_0.tar.bz2": { + "build": "py39h89d13dc_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5", + "libgcc-ng >=11.2.0", + "libnetcdf >=4.8,<4.9.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3c787ed2f6c9e152d690ccd53d8cbdf", + "name": "netcdf4", + "sha256": "e30796055e70c66132cab0e3e35c3ffa93f1925e900bd6e03d94f9d027e2eaab", + "size": 511555, + "subdir": "linux-64", + "timestamp": 1673455696733, + "version": "1.6.2" + }, + "netifaces-0.10.9-py310h7f8727e_1004.tar.bz2": { + "build": "py310h7f8727e_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb1e00f90c126fa5d071021df3ef69be", + "name": "netifaces", + "sha256": "266031b1293e0341d4f2afedd6e75a2b3cb2047deb67915db14297a6e1e1103b", + "size": 41018, + "subdir": "linux-64", + "timestamp": 1641838109030, + "version": "0.10.9" + }, + "netifaces-0.10.9-py311h5eee18b_1004.tar.bz2": { + "build": "py311h5eee18b_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "406495bbfed4b85cb2b155b8d05e0e7a", + "name": "netifaces", + "sha256": "bd8c8a2dca9c457b3cafc3e08effe3dbf2f96d47cfec45c410677b771b7a9ed1", + "size": 17859, + "subdir": "linux-64", + "timestamp": 1676859954905, + "version": "0.10.9" + }, + "netifaces-0.10.9-py36h27cfd23_1004.tar.bz2": { + "build": "py36h27cfd23_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a1216661f381fd707fb15826e256bdd", + "name": "netifaces", + "sha256": "acf02ee83d0d5f06c6e72871ad522f774f22c1c2dc5132858c9efc6ece69a412", + "size": 22259, + "subdir": "linux-64", + "timestamp": 1622235270777, + "version": "0.10.9" + }, + "netifaces-0.10.9-py37h27cfd23_1004.tar.bz2": { + "build": "py37h27cfd23_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "759e7a327b8eeb0eae3bd08f5e1a09f0", + "name": "netifaces", + "sha256": "bf3d23d6ee13541253e693c516afbf8250975090b62eae6f0c9c9906ee2c8cc1", + "size": 22220, + "subdir": "linux-64", + "timestamp": 1622230224571, + "version": "0.10.9" + }, + "netifaces-0.10.9-py38h27cfd23_1004.tar.bz2": { + "build": "py38h27cfd23_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "09024060122f09b77ec06a39fd8e4137", + "name": "netifaces", + "sha256": "c04875b4c56d62e6e775c012be69f5bbbfc1ee1358a2a1900040fcdbaf842889", + "size": 22416, + "subdir": "linux-64", + "timestamp": 1622235272564, + "version": "0.10.9" + }, + "netifaces-0.10.9-py39h27cfd23_1004.tar.bz2": { + "build": "py39h27cfd23_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37b760903bf1c86401b213802269fcef", + "name": "netifaces", + "sha256": "3c2fbfd001fa34f80a605319787b3a2d116db6365580223a1bdb962ab063fdb2", + "size": 22467, + "subdir": "linux-64", + "timestamp": 1622234877856, + "version": "0.10.9" + }, + "nettle-3.4-hb69a4c5_1.tar.bz2": { + "build": "hb69a4c5_1", + "build_number": 1, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2 and LGPL3", + "license_family": "GPL", + "md5": "92f034b774a77fcbf9fe532c0fc4ea7b", + "name": "nettle", + "sha256": "8584bee98518405568c2f72ae549bc5cd4cf9d274ac6f7ed3fac07713b80dbf8", + "size": 6718250, + "subdir": "linux-64", + "timestamp": 1576614385172, + "version": "3.4" + }, + "nettle-3.4.1-hbb512f6_0.tar.bz2": { + "build": "hbb512f6_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2 and LGPL3", + "license_family": "GPL", + "md5": "2081318a406eea7542593df884778790", + "name": "nettle", + "sha256": "4395eb656e17994f641d9b67ec3c26080f859ad672a87c6246105baa80b64cda", + "size": 6984377, + "subdir": "linux-64", + "timestamp": 1587121305131, + "version": "3.4.1" + }, + "nettle-3.7.2-hbbd107a_0.tar.bz2": { + "build": "hbbd107a_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2 and LGPL3", + "license_family": "GPL", + "md5": "c133f6303c68b02b9d071256af9f499a", + "name": "nettle", + "sha256": "301dffd9f2fb622dc9d21045fda99fd2d9c17ad5891d80a23d5fc966912b7574", + "size": 997866, + "subdir": "linux-64", + "timestamp": 1617771123412, + "version": "3.7.2" + }, + "nettle-3.7.2-hbbd107a_1.tar.bz2": { + "build": "hbbd107a_1", + "build_number": 1, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2 and LGPL3", + "license_family": "GPL", + "md5": "919d6c65911c68f0308380a5b385172b", + "name": "nettle", + "sha256": "f907f94e29ce9c5a72c61236be425d24434abdddafc61953472cd69b745c4ebe", + "size": 1035202, + "subdir": "linux-64", + "timestamp": 1617808171380, + "version": "3.7.2" + }, + "nettle-3.7.3-hbbd107a_1.tar.bz2": { + "build": "hbbd107a_1", + "build_number": 1, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0" + ], + "license": "GPL-2.0-or-later AND LGPL-3.0-or-later", + "license_family": "GPL", + "md5": "1e711a86e61920ca226b249d99dac54a", + "name": "nettle", + "sha256": "360cb724c55c938af46b8874edfcc646dcb23942bc759b2f3b743012e5ae300e", + "size": 1033191, + "subdir": "linux-64", + "timestamp": 1623151158563, + "version": "3.7.3" + }, + "networkx-1.11-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "decorator >=4.1.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4e24013493948534e041eb1d8c4db774", + "name": "networkx", + "sha256": "437f74a1427956d4f7c55615816028d9ecf7cd41af12509b2b5ea725da570f89", + "size": 1557500, + "subdir": "linux-64", + "timestamp": 1530771997213, + "version": "1.11" + }, + "networkx-1.11-py27h7358325_0.tar.bz2": { + "build": "py27h7358325_0", + "build_number": 0, + "depends": [ + "decorator >=3.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2e4d8df20c6d377d477400dd4d8c12be", + "name": "networkx", + "sha256": "a3436adabe2df99652aaa8ab0f6008396a2d3295ae9bc259a01c04c921606022", + "size": 1557509, + "subdir": "linux-64", + "timestamp": 1505740012286, + "version": "1.11" + }, + "networkx-1.11-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "decorator >=4.1.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9a810b17462696a3788752eac464db76", + "name": "networkx", + "sha256": "07fdf4c24590e09f01409d08861b405bddf9588b43df83d669cd2c417a2588f3", + "size": 1616087, + "subdir": "linux-64", + "timestamp": 1534804476350, + "version": "1.11" + }, + "networkx-1.11-py35hf333c83_0.tar.bz2": { + "build": "py35hf333c83_0", + "build_number": 0, + "depends": [ + "decorator >=3.4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bc681e781356eea5cf0736a6782ba036", + "name": "networkx", + "sha256": "8b517e5c61692fe0f21d04deaed446ac8dc51cb823c4f8978ee1c0ee0c5d91ea", + "size": 1616635, + "subdir": "linux-64", + "timestamp": 1505740052169, + "version": "1.11" + }, + "networkx-1.11-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "decorator >=4.1.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "03412e4581d83e6eebda2e3af0a8ff0b", + "name": "networkx", + "sha256": "498291c3e600e0672474233ace11b99ec184561edb825956259f88e82a2cd719", + "size": 1564198, + "subdir": "linux-64", + "timestamp": 1530772049057, + "version": "1.11" + }, + "networkx-1.11-py36hfb3574a_0.tar.bz2": { + "build": "py36hfb3574a_0", + "build_number": 0, + "depends": [ + "decorator >=3.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7bbfa82be9e94ea8f9546bc3d1ea8a23", + "name": "networkx", + "sha256": "a0a37922713611c827a891e8c5cbe9259d5d7c5e235d3653e460d508fd69a511", + "size": 1564805, + "subdir": "linux-64", + "timestamp": 1505740092966, + "version": "1.11" + }, + "networkx-1.11-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "decorator >=4.1.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "07d6edd3d062ce676bfce92ed80e15a6", + "name": "networkx", + "sha256": "16f23f267e1332a974c8d8d7bc8f5d0be6c4d99583cfb07be9f55a1f0b6db89c", + "size": 1562348, + "subdir": "linux-64", + "timestamp": 1530771955799, + "version": "1.11" + }, + "networkx-2.0-py27hfc23926_0.tar.bz2": { + "build": "py27hfc23926_0", + "build_number": 0, + "depends": [ + "decorator >=3.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "42050498acf9f966a9ca718f9b292a4c", + "name": "networkx", + "sha256": "916cc9eb402025f65fca12eb6dfac56739ddc393704be03a72bcee696579808a", + "size": 1815885, + "subdir": "linux-64", + "timestamp": 1508437240672, + "version": "2.0" + }, + "networkx-2.0-py35hc690e10_0.tar.bz2": { + "build": "py35hc690e10_0", + "build_number": 0, + "depends": [ + "decorator >=3.4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "51491ca8d208d58b85136645f995841d", + "name": "networkx", + "sha256": "3afe14f4c895370afc259927120863e7b2f02865537da563281f925d5869b4be", + "size": 1833820, + "subdir": "linux-64", + "timestamp": 1508437258628, + "version": "2.0" + }, + "networkx-2.0-py36h7e96fb8_0.tar.bz2": { + "build": "py36h7e96fb8_0", + "build_number": 0, + "depends": [ + "decorator >=3.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6dab9aa9c8528c96462479d59fd89fd5", + "name": "networkx", + "sha256": "1c627f415dc80f5b94f905e08c31ad5008945d052a856581b4e49c2229495d07", + "size": 1836936, + "subdir": "linux-64", + "timestamp": 1508437237782, + "version": "2.0" + }, + "networkx-2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator >=4.1.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fc53d9e084fe039a47b4b4c3c456abfe", + "name": "networkx", + "sha256": "d0d2c0f22703d711ac802183987284c7b31eba50275ece5cd0e427a8d07baa3f", + "size": 1899448, + "subdir": "linux-64", + "timestamp": 1516746441239, + "version": "2.1" + }, + "networkx-2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator >=4.1.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e9f26c69a417d962225295d2bfe02876", + "name": "networkx", + "sha256": "ee9fc8a8e68206d35ad6f728a7a5fa6b85d66dd10dc1795151e579ed66dafe3e", + "size": 1944010, + "subdir": "linux-64", + "timestamp": 1516746468741, + "version": "2.1" + }, + "networkx-2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator >=4.1.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1299350fce342c0048ebd87a234c36d1", + "name": "networkx", + "sha256": "901fd19737cfed807c2c048fe63f63633b69c2a69ce62bcac8b9838488237c93", + "size": 1921750, + "subdir": "linux-64", + "timestamp": 1516746467678, + "version": "2.1" + }, + "networkx-2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator >=4.1.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "312c66779d826773f8facdb456991283", + "name": "networkx", + "sha256": "662d9f8cefd6ec5e50e8e819a73643f1f9c027f5e25877c6d3e5ae8b6b1181c2", + "size": 1915333, + "subdir": "linux-64", + "timestamp": 1530772103223, + "version": "2.1" + }, + "networkx-2.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "decorator >=4.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "47524e881f008fcd96a56b7691b0828a", + "name": "networkx", + "sha256": "ecaf53f9ebe5d1dc7b3abd57844ee1592bdaf609af6c5aeb216d7c9457bfc7ef", + "size": 2048156, + "subdir": "linux-64", + "timestamp": 1538599993771, + "version": "2.2" + }, + "networkx-2.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "decorator >=4.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "450341271bfc1161006ac0f48cddb921", + "name": "networkx", + "sha256": "a23c0165ef484aa75b06d77713a6bbc1cdbe084011570e83b88393ef220f811f", + "size": 2060828, + "subdir": "linux-64", + "timestamp": 1538600029845, + "version": "2.2" + }, + "networkx-2.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "decorator >=4.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7271d07f49825b5619bf759e6d5c6814", + "name": "networkx", + "sha256": "a2dd94747fb1586127bf7df1f3fd0870c98a98ca6fff42bf59560f19b67b87be", + "size": 2059362, + "subdir": "linux-64", + "timestamp": 1538600017904, + "version": "2.2" + }, + "networkx-2.8.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5336a0ca2f191585f8ce962db82a5b6c", + "name": "networkx", + "sha256": "a1442055041b1935c776b43d1adc64a981188613ff18d651796147b86f688ede", + "size": 2863985, + "subdir": "linux-64", + "timestamp": 1657784186893, + "version": "2.8.4" + }, + "networkx-2.8.4-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "644593f2c19466bf5a6e4fd6c17740e1", + "name": "networkx", + "sha256": "41e22f72d1b567f8f03304dadb2c8849b56bcc6273cd812d9e8234f93d103a5f", + "size": 2851758, + "subdir": "linux-64", + "timestamp": 1678964406250, + "version": "2.8.4" + }, + "networkx-2.8.4-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2eca667344eee52b5ac6f5c9b3e9cd54", + "name": "networkx", + "sha256": "c242cb814fd5097dde6c6d2c36f8390acacf6468d5b8a17faaa2161cb298aefd", + "size": 3486126, + "subdir": "linux-64", + "timestamp": 1678964443436, + "version": "2.8.4" + }, + "networkx-2.8.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "61e187043e980a81623d437780504c3b", + "name": "networkx", + "sha256": "54b45b854faed26bd0a1c2232619977c63d2360d30b1a79f12305d33a8cd4849", + "size": 2849883, + "subdir": "linux-64", + "timestamp": 1657784134360, + "version": "2.8.4" + }, + "networkx-2.8.4-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "47d5abbd197d187685e16e7af575f958", + "name": "networkx", + "sha256": "a7fbd80826e9164b6c351394a2725ee25e6b4ee3e530251c21bf49cca2bd3d6a", + "size": 2845203, + "subdir": "linux-64", + "timestamp": 1678964480653, + "version": "2.8.4" + }, + "networkx-2.8.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b8b4ce1bf30b26408fc1b4f4e2403fe3", + "name": "networkx", + "sha256": "e7ed3c4b836a05c660f01a2cfecce6a6960fa1b9b7d097265429a49a81b8df55", + "size": 2847632, + "subdir": "linux-64", + "timestamp": 1657784226631, + "version": "2.8.4" + }, + "networkx-2.8.4-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7789fd7dad675402c58a0e8544bb283f", + "name": "networkx", + "sha256": "61ce059cfce17c4f949586e58b33e3e20c97105a9ba567097a7f7644b15d25ce", + "size": 2835973, + "subdir": "linux-64", + "timestamp": 1678964368614, + "version": "2.8.4" + }, + "neuralprophet-0.3.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.11.3.1", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.4.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c44def78a7f0d54eb238b89e9395f86", + "name": "neuralprophet", + "sha256": "2e030f8e6d955058a503796abb93c2d30eb4e7504a6c229f7a882e8798cccb88", + "size": 221822, + "subdir": "linux-64", + "timestamp": 1649651928650, + "version": "0.3.2" + }, + "neuralprophet-0.3.2-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.11.3.1", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.4.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1cd55a5d34ac4f00a750f496160c2dec", + "name": "neuralprophet", + "sha256": "08db16c5d50ec179b512e911003e1615436a48e7ea61c5fd659d1976a823b06f", + "size": 222256, + "subdir": "linux-64", + "timestamp": 1662379745515, + "version": "0.3.2" + }, + "neuralprophet-0.3.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.11.3.1", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.4.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "201b4ede4fd824401421a092a22ae8f9", + "name": "neuralprophet", + "sha256": "2e989f24753e9156e0fc60f0b2cee3e52692a17c07458f3702f6e1b4f29c2542", + "size": 237687, + "subdir": "linux-64", + "timestamp": 1649670049167, + "version": "0.3.2" + }, + "neuralprophet-0.3.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.11.3.1", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.4.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7abab6a2f49bac5598f4ec83e2f231b", + "name": "neuralprophet", + "sha256": "43c6a4be6b2937e4efa0f8c81288d3b4575b2a421df811a9bb3a2fc4cc45ed91", + "size": 220939, + "subdir": "linux-64", + "timestamp": 1662379544534, + "version": "0.3.2" + }, + "neuralprophet-0.3.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.11.3.1", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.4.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8b105826919944ca6a07eb594a2b0bc", + "name": "neuralprophet", + "sha256": "b88ed7b266d511aaf67eb7a32bd4b9437e8116bb48a560483233c1ae16f7aa36", + "size": 237158, + "subdir": "linux-64", + "timestamp": 1649670045219, + "version": "0.3.2" + }, + "neuralprophet-0.3.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.11.3.1", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.4.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea221852200e209f9e5bb5d6c9424b9c", + "name": "neuralprophet", + "sha256": "2f2edc431d60db0f2a1011937db656e1fadb539adcd7a4855d074735c59eb635", + "size": 220915, + "subdir": "linux-64", + "timestamp": 1662379802290, + "version": "0.3.2" + }, + "neuralprophet-0.3.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.11.3.1", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.4.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2a96fc9bd96bdf1b1382d787fb90b92c", + "name": "neuralprophet", + "sha256": "55f07fca3f784fac7365d07ad9ddaaf358ca035bb6cee7e6cb286f52b1dea9ee", + "size": 235574, + "subdir": "linux-64", + "timestamp": 1649652182557, + "version": "0.3.2" + }, + "neuralprophet-0.3.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.11.3.1", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.4.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1b70c4c8ecec8a553c1695050bd1b09", + "name": "neuralprophet", + "sha256": "e056e2fbf9498afbe8e1c98cbf1e77659c75679bfec3a22f36d5eaf4b750a2b2", + "size": 221395, + "subdir": "linux-64", + "timestamp": 1662379612883, + "version": "0.3.2" + }, + "neuralprophet-0.4.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.13", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "plotly >=4.14.3", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.8.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8404fa3c9c23bb8bdf892852248cff80", + "name": "neuralprophet", + "sha256": "134f48d6e14fe570314790172191607c97996ad688b9efe0cbfb4ea357debfdb", + "size": 309070, + "subdir": "linux-64", + "timestamp": 1675378039681, + "version": "0.4.2" + }, + "neuralprophet-0.4.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.13", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "plotly >=4.14.3", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.8.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2", + "typing_extensions >=4.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "399758c67910a4939eb795d620c87a5a", + "name": "neuralprophet", + "sha256": "78470fbbc00de33a2b3cf6b6d34ff87c83af82e5b8683ea9db37e844a6c2dbd8", + "size": 307457, + "subdir": "linux-64", + "timestamp": 1675378148234, + "version": "0.4.2" + }, + "neuralprophet-0.4.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.13", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "plotly >=4.14.3", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.8.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce90f1b5e2975c5ad5eea323871ee7d7", + "name": "neuralprophet", + "sha256": "ce9071d7e84da68103ba087fd82c77a13b6bcea609c29fd1139432e3f951614e", + "size": 307826, + "subdir": "linux-64", + "timestamp": 1675378255639, + "version": "0.4.2" + }, + "neuralprophet-0.4.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.13", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "plotly >=4.14.3", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.8.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd53adddd9d53839a9938091997c0766", + "name": "neuralprophet", + "sha256": "db3755685d86cd128c67bb6c5260ca4ece9f97784a8b79e8a1bd670121f7b766", + "size": 307894, + "subdir": "linux-64", + "timestamp": 1675378360179, + "version": "0.4.2" + }, + "nginx-1.14.2-hf7769d2_0.tar.bz2": { + "build": "hf7769d2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgd >=2.2.5,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "openssl >=1.1.1a,<1.1.2a", + "pcre >=8.42,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "27ffe62835f9e9343e96c4b9f33910de", + "name": "nginx", + "sha256": "02409fda49e23fefa79abfe84cce7f0916c117fb55ae04ac8d7852953c052c48", + "size": 537378, + "subdir": "linux-64", + "timestamp": 1547240426764, + "version": "1.14.2" + }, + "nginx-1.15.1-h2b10cb8_0.tar.bz2": { + "build": "h2b10cb8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgd >=2.2.5,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "openssl >=1.0.2p,<1.0.3a", + "pcre >=8.42,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e8a25eb4d7835634313bd84ac1acd50a", + "name": "nginx", + "sha256": "b97775ad61f2c4e6d1766dffc2b9645f1c9c76874cb0608754f7389236ad1a4a", + "size": 530946, + "subdir": "linux-64", + "timestamp": 1534495115960, + "version": "1.15.1" + }, + "nginx-1.15.1-hf7769d2_0.tar.bz2": { + "build": "hf7769d2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgd >=2.2.5,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "openssl >=1.1.1a,<1.1.2a", + "pcre >=8.42,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "53657f2f6a2582f0deb33d960b0eba71", + "name": "nginx", + "sha256": "172f89195471e436fcbd777d80a006243b5ef2260e9c6dd0f9ee1ea7634b6ea8", + "size": 547767, + "subdir": "linux-64", + "timestamp": 1540584291263, + "version": "1.15.1" + }, + "nginx-1.15.5-hf7769d2_0.tar.bz2": { + "build": "hf7769d2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgd >=2.2.5,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "openssl >=1.1.1a,<1.1.2a", + "pcre >=8.42,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "fcbd7a8c7e1e0b23a4a5266bf70eabbf", + "name": "nginx", + "sha256": "bb2544ce4d105a303fc61cb2592ea19f0b22319ace4ee41070db815a793527d6", + "size": 541990, + "subdir": "linux-64", + "timestamp": 1540591370849, + "version": "1.15.5" + }, + "nginx-1.19.10-h674efe4_0.tar.bz2": { + "build": "h674efe4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgd >=2.2.5,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "openssl >=1.1.1k,<1.1.2a", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "1f97cfb91e196c130bbda1c59ac2d002", + "name": "nginx", + "sha256": "6031f90628f4c1b3e5181b15551493787c4c950a369375e4c9e1861e012f6c04", + "size": 561562, + "subdir": "linux-64", + "timestamp": 1618347667615, + "version": "1.19.10" + }, + "nginx-1.19.2-hf7769d2_0.tar.bz2": { + "build": "hf7769d2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgd >=2.2.5,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "openssl >=1.1.1g,<1.1.2a", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a9a1a82e01a5b54b05acdae834857cbe", + "name": "nginx", + "sha256": "81b07c8b4d4d17599fbf92d9389f659361f66c1954d539720bdd1894f809b12b", + "size": 552099, + "subdir": "linux-64", + "timestamp": 1600445866811, + "version": "1.19.2" + }, + "nginx-1.19.8-h674efe4_0.tar.bz2": { + "build": "h674efe4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgd >=2.2.5,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "openssl >=1.1.1j,<1.1.2a", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "84ec98dfd75f743b1d31ca87a14356d8", + "name": "nginx", + "sha256": "23b43c3679af78fc6b45a1454783fc817c315a513f6fc5147e2bb4bd7b45c2d0", + "size": 561222, + "subdir": "linux-64", + "timestamp": 1615353459212, + "version": "1.19.8" + }, + "nginx-1.19.9-h674efe4_0.tar.bz2": { + "build": "h674efe4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgd >=2.2.5,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "openssl >=1.1.1k,<1.1.2a", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "708294144b504391d7b80ecfa5a8082c", + "name": "nginx", + "sha256": "5b00b16870fc6668a8af1fb519743bf7a016559158ca40f22ad2f02c1cca0e1e", + "size": 561049, + "subdir": "linux-64", + "timestamp": 1617132697268, + "version": "1.19.9" + }, + "nginx-1.21.6-h67d3620_1.tar.bz2": { + "build": "h67d3620_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libgd 2.3.3.*", + "libgd >=2.3.3,<2.4.0a0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxml2", + "libxslt 1.1.*", + "libxslt >=1.1.35,<2.0a0", + "openssl >=1.1.1o,<1.1.2a", + "pcre2 >=10.37,<10.38.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ed7221ec0bf1e07555a337fbe268e8fb", + "name": "nginx", + "sha256": "5155d4caa3e662e5d540e373893f29a7e8cefdc5f86140d1456b6b18674c1c6c", + "size": 543164, + "subdir": "linux-64", + "timestamp": 1656436056231, + "version": "1.21.6" + }, + "nginx-1.21.6-hd80bfc7_0.tar.bz2": { + "build": "hd80bfc7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libgd 2.2.*", + "libgd >=2.2.5,<2.3.0a0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libxml2", + "libxslt 1.1.*", + "libxslt >=1.1.34,<2.0a0", + "openssl >=1.1.1m,<1.1.2a", + "pcre2 >=10.37,<10.38.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8d9f6a52d362869ac21bf7cfa23882c8", + "name": "nginx", + "sha256": "52b8fc901acda075abf44a1e1506c742111735cf763caad96a3c637a8349006a", + "size": 562864, + "subdir": "linux-64", + "timestamp": 1646390801760, + "version": "1.21.6" + }, + "ninja-1.10.0-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8a7e5de0118cf0f49eb69911765d311d", + "name": "ninja", + "namespace": "global", + "sha256": "a5cabe1247d8531d1db6a2f0e253c54757e452beabbfd1260071f1601508c942", + "size": 2011385, + "subdir": "linux-64", + "timestamp": 1596052731355, + "version": "1.10.0" + }, + "ninja-1.10.0-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5f48de3e2e8de724334fd837a22d0ced", + "name": "ninja", + "namespace": "global", + "sha256": "f5e7e5d59f10674b082e95a088c72ec6b29c6d5b326c2c86266a3d97f6b5cf51", + "size": 2011904, + "subdir": "linux-64", + "timestamp": 1596052751078, + "version": "1.10.0" + }, + "ninja-1.10.0-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0dcf7e35bab28ae250028df4aa0d19cb", + "name": "ninja", + "namespace": "global", + "sha256": "e8bc2056a023e2e97687d5ea98650f24ac1679e1ea1dac77aa243ca0f63c9024", + "size": 2012227, + "subdir": "linux-64", + "timestamp": 1596052771755, + "version": "1.10.0" + }, + "ninja-1.10.1-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "621e00285545f86682c7a8b22f5acdf6", + "name": "ninja", + "namespace": "global", + "sha256": "bea1becfea4fd100044f38459f4543c23a18254e1606f2e92e400c18b6324966", + "size": 2015660, + "subdir": "linux-64", + "timestamp": 1599132690968, + "version": "1.10.1" + }, + "ninja-1.10.1-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "75a44ef1dd8823104c670408c337711f", + "name": "ninja", + "namespace": "global", + "sha256": "67d461c97953d46de15e84f97933e09031590adface94e0971e2e56d87928969", + "size": 2016118, + "subdir": "linux-64", + "timestamp": 1599132561156, + "version": "1.10.1" + }, + "ninja-1.10.1-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "65798a08b9ae7c30bf4aeab8dc6ebc14", + "name": "ninja", + "namespace": "global", + "sha256": "5ab0bb33446b6e4a1a616b3b39d5bfb0aba1942e5be5d6141fcd3222f7763f8f", + "size": 2016626, + "subdir": "linux-64", + "timestamp": 1599132649978, + "version": "1.10.1" + }, + "ninja-1.10.2-h06a4308_5.tar.bz2": { + "build": "h06a4308_5", + "build_number": 5, + "depends": [ + "ninja-base 1.10.2 hd09550d_5", + "python" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f4a9e0be780d872eef17429f13fa4230", + "name": "ninja", + "namespace": "global", + "sha256": "7422be64d87308191f220c5ba4a8c97eab54974f5227b11a4ebb4af433055999", + "size": 7383, + "subdir": "linux-64", + "timestamp": 1651243066654, + "version": "1.10.2" + }, + "ninja-1.10.2-h5e70eb0_2.tar.bz2": { + "build": "h5e70eb0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "15c87e17885d3745a887ff2a7fb1d110", + "name": "ninja", + "namespace": "global", + "sha256": "9d0fe3bdf7b54abc44c05728d49d40987a2f6847d2d99bd3c27d29b9f9f5d833", + "size": 2040178, + "subdir": "linux-64", + "timestamp": 1636631453946, + "version": "1.10.2" + }, + "ninja-1.10.2-hd09550d_2.tar.bz2": { + "build": "hd09550d_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b1a69182abd6ec1f0bd93f44b20a7ab3", + "name": "ninja", + "namespace": "global", + "sha256": "471d0c1be29f3bea01f98d19df975d47b15ffcd8b6e43b0735f580c3410cbb42", + "size": 2031739, + "subdir": "linux-64", + "timestamp": 1636631285248, + "version": "1.10.2" + }, + "ninja-1.10.2-hff7bd54_1.tar.bz2": { + "build": "hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2d3ac10d4ff532b79d19f7ccda9cfeea", + "name": "ninja", + "namespace": "global", + "sha256": "7fa0695a083fb61b27338d69dc6d0d27c6da82d1472054e1c73899a528ed8d95", + "size": 2017540, + "subdir": "linux-64", + "timestamp": 1617652633259, + "version": "1.10.2" + }, + "ninja-1.10.2-py310hd09550d_3.tar.bz2": { + "build": "py310hd09550d_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f4d1e92bd5269a7e917b2294d8da3aad", + "name": "ninja", + "namespace": "global", + "sha256": "aaa010c84abc53bfe72734ee9f54e9b95b0b9ec2ad605a2da2f34d669beb2461", + "size": 2031498, + "subdir": "linux-64", + "timestamp": 1640791961629, + "version": "1.10.2" + }, + "ninja-1.10.2-py36hff7bd54_0.tar.bz2": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2d220faee248ef116c951f53e27279a5", + "name": "ninja", + "namespace": "global", + "sha256": "68615df548bc5a8cfa3f8c9b1aee8dfed95640d846d6f3efc4ea69af5a4e9887", + "size": 2012027, + "subdir": "linux-64", + "timestamp": 1606603258848, + "version": "1.10.2" + }, + "ninja-1.10.2-py37h5e70eb0_3.tar.bz2": { + "build": "py37h5e70eb0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b774781f06e155ff7735fa8441554145", + "name": "ninja", + "namespace": "global", + "sha256": "583eb95da886b47ec251e503d4025c6313c35aa31ca1054334b8c7fb25744755", + "size": 2037922, + "subdir": "linux-64", + "timestamp": 1636622443378, + "version": "1.10.2" + }, + "ninja-1.10.2-py37hd09550d_3.tar.bz2": { + "build": "py37hd09550d_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "367a83a04d1d294507d85d658b722b59", + "name": "ninja", + "namespace": "global", + "sha256": "2c32d08840560fc47868b996439c1f374825bda414a70cc2dee61196e237c99f", + "size": 2031484, + "subdir": "linux-64", + "timestamp": 1636643923057, + "version": "1.10.2" + }, + "ninja-1.10.2-py37hff7bd54_0.tar.bz2": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4e837213c04e3cfe219a09ac68498c17", + "name": "ninja", + "namespace": "global", + "sha256": "bbf58ab47d4961ad21af41b2d9492a29f93e2a8b31a745d9cca461c73384d98a", + "size": 2012463, + "subdir": "linux-64", + "timestamp": 1606603235006, + "version": "1.10.2" + }, + "ninja-1.10.2-py38h5e70eb0_3.tar.bz2": { + "build": "py38h5e70eb0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0e63acdff1c2a2fec2128897aa3eda2c", + "name": "ninja", + "namespace": "global", + "sha256": "c7ba4fde3da42d9b6697d994201dc22e8fd8276c7ae58f26b47d18d9f55b08ef", + "size": 2038614, + "subdir": "linux-64", + "timestamp": 1636634758229, + "version": "1.10.2" + }, + "ninja-1.10.2-py38hd09550d_3.tar.bz2": { + "build": "py38hd09550d_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "56183105e2bfd66e011bf92f59ecb520", + "name": "ninja", + "namespace": "global", + "sha256": "c3e6c8aa3c520e2c1d27087306630695109233c6a21b3655c16b1195d91038c9", + "size": 2031400, + "subdir": "linux-64", + "timestamp": 1636643866113, + "version": "1.10.2" + }, + "ninja-1.10.2-py38hff7bd54_0.tar.bz2": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3b994165b3db04e3c4d35efe4a632a6b", + "name": "ninja", + "namespace": "global", + "sha256": "7c46b2d1e50de5b1f07a13beff66414c3e624d97e6266462b728110fe9131a73", + "size": 2012016, + "subdir": "linux-64", + "timestamp": 1606603234210, + "version": "1.10.2" + }, + "ninja-1.10.2-py39h5e70eb0_3.tar.bz2": { + "build": "py39h5e70eb0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8ed9f005e8ce66a7276257b5f6a56f8d", + "name": "ninja", + "namespace": "global", + "sha256": "f81f3d3236ecf5789436890255184ef7ea99c024a1ff628efbf1a0ef365e5356", + "size": 2038946, + "subdir": "linux-64", + "timestamp": 1636634764770, + "version": "1.10.2" + }, + "ninja-1.10.2-py39hd09550d_3.tar.bz2": { + "build": "py39hd09550d_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4a04d9ba84ee7c580d67cdd0a5343545", + "name": "ninja", + "namespace": "global", + "sha256": "81da6915719f9963c4c14c5edfc8468047000435fd653045473d947f3f172096", + "size": 2031788, + "subdir": "linux-64", + "timestamp": 1636643814099, + "version": "1.10.2" + }, + "ninja-1.10.2-py39hff7bd54_0.tar.bz2": { + "build": "py39hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "43b431df8d3a37676ddbc8e076e380f9", + "name": "ninja", + "namespace": "global", + "sha256": "342d4a097dc25d3a616248ba088903d379fed82bd2e9124d4e117b9a535b40f1", + "size": 2013071, + "subdir": "linux-64", + "timestamp": 1606603287719, + "version": "1.10.2" + }, + "ninja-1.8.2-h6bb024c_0.tar.bz2": { + "build": "h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e2ccfe5ce3a46344c08c033f418c87bd", + "name": "ninja", + "namespace": "global", + "sha256": "1b70c1bc3c74ab25bc73a23b860ca848c5a212c54da0e3114df32ef3e7b18574", + "size": 1377159, + "subdir": "linux-64", + "timestamp": 1519804730291, + "version": "1.8.2" + }, + "ninja-1.8.2-h6bb024c_1.tar.bz2": { + "build": "h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2a212142db413498f7e14e5bdf52c385", + "name": "ninja", + "namespace": "global", + "sha256": "80ded164e1cdc5fdb612b9e43cabe980ef8ef24cb64075c52f56d80ac1d6e7ae", + "size": 1376149, + "subdir": "linux-64", + "timestamp": 1522872752538, + "version": "1.8.2" + }, + "ninja-1.8.2-py27h6bb024c_1.tar.bz2": { + "build": "py27h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "34ce15ef608577b6711ad9c61a07f971", + "name": "ninja", + "namespace": "global", + "sha256": "04a08f67de8238e0ad6026eed491b5810d58913a0b2b547e21f5de08b73dfef5", + "size": 1377254, + "subdir": "linux-64", + "timestamp": 1525797627709, + "version": "1.8.2" + }, + "ninja-1.8.2-py35h6bb024c_1.tar.bz2": { + "build": "py35h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c0232e22a048f8b099d2068da300792c", + "name": "ninja", + "namespace": "global", + "sha256": "28d696058c4631a337db9fb829a7ffcafb8b76ded4d78c998c7cd4436cb82f17", + "size": 1376087, + "subdir": "linux-64", + "timestamp": 1525797716102, + "version": "1.8.2" + }, + "ninja-1.8.2-py36h6bb024c_1.tar.bz2": { + "build": "py36h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c4327a6b71d6689de22abacabb92c9a9", + "name": "ninja", + "namespace": "global", + "sha256": "cfa47ae153a3bd71b41a219fcd43209df26de9a1ca7cfbe83178fca8d5c8d060", + "size": 1376870, + "subdir": "linux-64", + "timestamp": 1525797734754, + "version": "1.8.2" + }, + "ninja-1.8.2-py37h6bb024c_1.tar.bz2": { + "build": "py37h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "61c4f760ed48e6cc4e5256726e9e1fae", + "name": "ninja", + "namespace": "global", + "sha256": "adcf874287e0edd734e75942ec93b9aab3c090d3ef5e87a077ff601277b464f1", + "size": 1376179, + "subdir": "linux-64", + "timestamp": 1530780138788, + "version": "1.8.2" + }, + "ninja-1.9.0-py27hfd86e86_0.tar.bz2": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "23ec8d4537e21833e91169b4e8b1403a", + "name": "ninja", + "namespace": "global", + "sha256": "4d6bd8f2f93214c828468cb23fd17b3a4a1befafc10a355635d9076878d9264b", + "size": 1710568, + "subdir": "linux-64", + "timestamp": 1553108598795, + "version": "1.9.0" + }, + "ninja-1.9.0-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "454d16c3865009d33184549329d6aceb", + "name": "ninja", + "namespace": "global", + "sha256": "e1c2bc470182d16081e6d9a8dfa2c170b4f6ecbefbc07bf4e0cda01731f273cc", + "size": 1711245, + "subdir": "linux-64", + "timestamp": 1553108618986, + "version": "1.9.0" + }, + "ninja-1.9.0-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9032b01272ebba4f51009f02600476fe", + "name": "ninja", + "namespace": "global", + "sha256": "9ed3c113330c77c17597a8a3061cc96e909232ce5c0dc3ec622666141589849f", + "size": 1711308, + "subdir": "linux-64", + "timestamp": 1553108582404, + "version": "1.9.0" + }, + "ninja-1.9.0-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5c0b1337b6aebf7c2fd8cdc47cb0e814", + "name": "ninja", + "namespace": "global", + "sha256": "a85c27725fa09c1c09027d8a95442dd6883906ce6bc5adde750df17e28da15e8", + "size": 1708929, + "subdir": "linux-64", + "timestamp": 1573120930543, + "version": "1.9.0" + }, + "ninja-base-1.10.2-hd09550d_5.tar.bz2": { + "build": "hd09550d_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fbb47979046951bce6399ebe0391ede8", + "name": "ninja-base", + "sha256": "a57ac58e74648f9a643660c2e916486294e284014640362e070afa870ed1f3e6", + "size": 114369, + "subdir": "linux-64", + "timestamp": 1651243065856, + "version": "1.10.2" + }, + "nlohmann_json-3.10.5-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [], + "license": "MIT", + "license_family": "MIT", + "md5": "735476c20bf8f848f5fe461019f1b1cb", + "name": "nlohmann_json", + "sha256": "ef9b0ff5bf537522ade509dc4996dfbe74de7bde665e48f0cf4bcb27b65c54e3", + "size": 109998, + "subdir": "linux-64", + "timestamp": 1645446448382, + "version": "3.10.5" + }, + "nlohmann_json-3.11.2-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [], + "license": "MIT", + "license_family": "MIT", + "md5": "709dfdf3a676424340fad7eeea714690", + "name": "nlohmann_json", + "sha256": "ae30bd04c73122c074d498da77c1fd5f116b642826b42c425ccae06d77e9da45", + "size": 113715, + "subdir": "linux-64", + "timestamp": 1680082329609, + "version": "3.11.2" + }, + "nltk-3.2.4-py27h41293c3_0.tar.bz2": { + "build": "py27h41293c3_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ef52b4c7636751c4033905581fe0e6df", + "name": "nltk", + "sha256": "ad068bf2418c82e677270705b6870513a53c93200bc2d4d20f2fc88b4c2097df", + "size": 2004157, + "subdir": "linux-64", + "timestamp": 1505746706958, + "version": "3.2.4" + }, + "nltk-3.2.4-py35h7ba7875_0.tar.bz2": { + "build": "py35h7ba7875_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d907a6fdd1d7fa37c025073a8155f85a", + "name": "nltk", + "sha256": "26266e57f954f84adfd4ef80932b52aa0d0d5ba0878f63c9a54c15e28fe3d64f", + "size": 2043545, + "subdir": "linux-64", + "timestamp": 1505746745240, + "version": "3.2.4" + }, + "nltk-3.2.4-py36h1a0979f_0.tar.bz2": { + "build": "py36h1a0979f_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "eafe3795f95aa8b85d7c4f964c0f890a", + "name": "nltk", + "sha256": "ad76ed94e2646ebf58bfb63805153ef6aa60574c74ca66c1a523da10cf6c8f85", + "size": 2054454, + "subdir": "linux-64", + "timestamp": 1505746783334, + "version": "3.2.4" + }, + "nltk-3.2.5-py27hec5f4de_0.tar.bz2": { + "build": "py27hec5f4de_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8c5f60628b7047ab2223530ec057ca63", + "name": "nltk", + "sha256": "abbac041bdc4547137287cef91147d3e47e168a20e0b259c5f0d7716657e6488", + "size": 2042112, + "subdir": "linux-64", + "timestamp": 1511297630074, + "version": "3.2.5" + }, + "nltk-3.2.5-py35h09ad193_0.tar.bz2": { + "build": "py35h09ad193_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b1dbe042482bffcc266203ad149e5c0f", + "name": "nltk", + "sha256": "21573d8bb300a71173037a3feffcac65becd215700857562dfc58b70671a02ba", + "size": 2083692, + "subdir": "linux-64", + "timestamp": 1511297648895, + "version": "3.2.5" + }, + "nltk-3.2.5-py36h7532b22_0.tar.bz2": { + "build": "py36h7532b22_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e43ccb78b0eb2f2050c5ba39e946c377", + "name": "nltk", + "sha256": "f582ee9fb1d63c094ef2076ebd074b469022dd910dc9f231600b0d04cfb4e821", + "size": 2089676, + "subdir": "linux-64", + "timestamp": 1511297656593, + "version": "3.2.5" + }, + "nltk-3.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1b7f66233aab4fc6278cb607d2bc3a9a", + "name": "nltk", + "sha256": "cd418286d9f6a7d39514a20e0f4de00d7bdccda796a4761daf78b03f9d2d77dc", + "size": 2038746, + "subdir": "linux-64", + "timestamp": 1525821329822, + "version": "3.3.0" + }, + "nltk-3.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "51fa330abb65f794e0443c470488912b", + "name": "nltk", + "sha256": "35af83f3d01f28c8b2d6aab4ff8de4dee8d7fa3f25fbe972c6cefd7a2f8872f8", + "size": 2079859, + "subdir": "linux-64", + "timestamp": 1525821367531, + "version": "3.3.0" + }, + "nltk-3.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d31a667f6a73c9b1f1a4ae1e0d28fdea", + "name": "nltk", + "sha256": "a593cf0e2bd2b4a7af3c8b68916f3171261c0520c8485df5a1de77eb5e75fbb7", + "size": 2078651, + "subdir": "linux-64", + "timestamp": 1525821341555, + "version": "3.3.0" + }, + "nltk-3.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f9cac4e15821c67e2b96b1fb45246c09", + "name": "nltk", + "sha256": "f12ef3710ea28a08800c765ac8e95126384b6e68885a8e50188f9b69693a98c3", + "size": 2071220, + "subdir": "linux-64", + "timestamp": 1530902296328, + "version": "3.3.0" + }, + "nltk-3.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gensim", + "matplotlib", + "numpy", + "pyparsing", + "python >=2.7,<2.8.0a0", + "python-crfsuite", + "requests", + "scikit-learn", + "scipy", + "six", + "twython" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "47e117bce50e04ded5202fc81d7c3ffe", + "name": "nltk", + "sha256": "d6c39f3dba6748cb99bafcf3ae529a6f6f0edffa4a5c197200e11436ddcd21c8", + "size": 2163509, + "subdir": "linux-64", + "timestamp": 1545082857509, + "version": "3.4" + }, + "nltk-3.4-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "75ca5cd068b2325f5ea5834f60ffa2da", + "name": "nltk", + "sha256": "57f50bf8e3c4ea427207f7077be90d18a734151e381145d23b00643f5842b75e", + "size": 2161855, + "subdir": "linux-64", + "timestamp": 1545271229483, + "version": "3.4" + }, + "nltk-3.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gensim", + "matplotlib", + "numpy", + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-crfsuite", + "requests", + "scikit-learn", + "scipy", + "six", + "twython" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e93dc8b5abfafbd2b13a944f4a247328", + "name": "nltk", + "sha256": "adbf7020df7a1e8a0fb87cd6398f67afd87e934862f14ba99f3e1eb515d8d124", + "size": 2181364, + "subdir": "linux-64", + "timestamp": 1545082962795, + "version": "3.4" + }, + "nltk-3.4-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3152f3f9c14174be391eedf339a6fc13", + "name": "nltk", + "sha256": "50da60616a9599898227292e5dc1cf16a87b7a2d2e451e1dc381455a7e26db75", + "size": 2188550, + "subdir": "linux-64", + "timestamp": 1545271244532, + "version": "3.4" + }, + "nltk-3.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "gensim", + "matplotlib", + "numpy", + "pyparsing", + "python >=3.7,<3.8.0a0", + "python-crfsuite", + "requests", + "scikit-learn", + "scipy", + "six", + "twython" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fe7312bbd1003cab61ed49a0d031aff9", + "name": "nltk", + "sha256": "20bad6a3d630e2fb64ad6d055bdefe2d365baf690914772a84bc6e9a3218821b", + "size": 2168822, + "subdir": "linux-64", + "timestamp": 1545095281954, + "version": "3.4" + }, + "nltk-3.4-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "797b29ca43c0937ddcd8efcdde505ee8", + "name": "nltk", + "sha256": "94eafc7a150a118d07a8deee7a5c575c06b4b2e5ee1034722d0065bdc5c97a53", + "size": 2177771, + "subdir": "linux-64", + "timestamp": 1545271239439, + "version": "3.4" + }, + "nltk-3.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b230880a2e3e2cdcc4e1c1baaee34a43", + "name": "nltk", + "sha256": "a201c558500b038ba501ffc1f262d90d652cb3e165aa5ad44304c8396ef000d5", + "size": 2200425, + "subdir": "linux-64", + "timestamp": 1555950458120, + "version": "3.4.1" + }, + "nltk-3.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "56c33c1fe033043e85940ebed22e3630", + "name": "nltk", + "sha256": "cdf10d845ac3171cdb996cf3ccfa6c058d49dbbc552008525ccc068c87863d3d", + "size": 2217739, + "subdir": "linux-64", + "timestamp": 1555950590545, + "version": "3.4.1" + }, + "nltk-3.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fd7ba289ce37bb2bfd1e14fa20c8a20d", + "name": "nltk", + "sha256": "7d7d6d2f8f2b673d188d7f4443fa059d566b88225532702beb876a806ddcea67", + "size": 2209827, + "subdir": "linux-64", + "timestamp": 1555950558879, + "version": "3.4.1" + }, + "nltk-3.4.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "118139b72182813482477dccd66cda53", + "name": "nltk", + "sha256": "f2ee830f564a4ed7b3bbbe1371d4a82203cea3b60eac4100b42bee28b51c5d76", + "size": 2209631, + "subdir": "linux-64", + "timestamp": 1562086274175, + "version": "3.4.3" + }, + "nltk-3.4.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7c3a92053abb6169e626bfc570528f74", + "name": "nltk", + "sha256": "024f7c976ca62ed492f7a8e299b701f1139711eb333d0b3185f38645e6b4321c", + "size": 2233382, + "subdir": "linux-64", + "timestamp": 1562086276480, + "version": "3.4.3" + }, + "nltk-3.4.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5eeb658a28d76a3a129b61b48dc0a1bf", + "name": "nltk", + "sha256": "05545f1c71127ed0089d1129f71ec8e838e18fecadd2bf533b03b921b32f54b4", + "size": 2219051, + "subdir": "linux-64", + "timestamp": 1562086265302, + "version": "3.4.3" + }, + "nltk-3.4.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "833f13b26b18c31b3511c1536c9861a7", + "name": "nltk", + "sha256": "0752da702bc0769d52ff4948a57f1dee053127dc877c136ed5e98628dadf50ce", + "size": 2209591, + "subdir": "linux-64", + "timestamp": 1563286242411, + "version": "3.4.4" + }, + "nltk-3.4.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f73d37d2d7c3584c6d274eb38c108c90", + "name": "nltk", + "sha256": "452c0b995de15ad3758c2890a844f0d6772c0ce42a43d21f9afd98d4027e88b5", + "size": 2227679, + "subdir": "linux-64", + "timestamp": 1563286247909, + "version": "3.4.4" + }, + "nltk-3.4.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a3670527585c63d4419ec78db70447bc", + "name": "nltk", + "sha256": "18578d2b3dc0f9fb394a2e2d727a36cb1a04cfece949cdd529154c9e2aa0ea31", + "size": 2214846, + "subdir": "linux-64", + "timestamp": 1563286243579, + "version": "3.4.4" + }, + "nltk-3.4.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0fe3a99e98f6869da35008099600f9d4", + "name": "nltk", + "sha256": "cec42de8c44f438ac8f798a605f76b44868f8dd6bc40ce340905677e2b779a2d", + "size": 2209104, + "subdir": "linux-64", + "timestamp": 1566580480929, + "version": "3.4.5" + }, + "nltk-3.4.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "191a324610a93ba34104e4fede1069f4", + "name": "nltk", + "sha256": "09ebc08c121fabef120aa068d1a0ccd162dc5df43868ecf805b75122ec628967", + "size": 2231468, + "subdir": "linux-64", + "timestamp": 1566580491576, + "version": "3.4.5" + }, + "nltk-3.4.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9892095b54b460ad00cc7cda0968a52b", + "name": "nltk", + "sha256": "e7c2378a3233f0cf0ed9ea15f57c69e4bffdd99f60cacd54097ba6086dc94eb6", + "size": 2224383, + "subdir": "linux-64", + "timestamp": 1566580469184, + "version": "3.4.5" + }, + "nltk-3.4.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8820aeaa375a33ceef5b8b2fb8983028", + "name": "nltk", + "sha256": "0f17bb74200b491f8f308aed08abec834e9d231acb168744055168e88d1216dd", + "size": 2219413, + "subdir": "linux-64", + "timestamp": 1573738348537, + "version": "3.4.5" + }, + "nodeenv-1.7.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "faae570856c99f3d7269aaac20d2fec3", + "name": "nodeenv", + "sha256": "0a669e169f0a34683c80f643a117a2e319dd15fbcad342627205815ab6bfdfbc", + "size": 44881, + "subdir": "linux-64", + "timestamp": 1663181171744, + "version": "1.7.0" + }, + "nodeenv-1.7.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c9203d970d172a1115af4df34ee9cf1e", + "name": "nodeenv", + "sha256": "f77f304655e2b6a8a030cefccc32692a1e6170a74d080f502b65a5fc5629824f", + "size": 54045, + "subdir": "linux-64", + "timestamp": 1676845054283, + "version": "1.7.0" + }, + "nodeenv-1.7.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4f25166924c41f0e56f1f9676471d682", + "name": "nodeenv", + "sha256": "af81569c3f4e1d448601d61cac5558cde4ab75dd0dd8fce65864d420760e4078", + "size": 44557, + "subdir": "linux-64", + "timestamp": 1663181224651, + "version": "1.7.0" + }, + "nodeenv-1.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b426783ffb10abaad8d7a431f0937390", + "name": "nodeenv", + "sha256": "8a9fb4949c2b39c4a3195c2e5cefbc132be5cc7782cbd87c10aac860bb199e02", + "size": 44684, + "subdir": "linux-64", + "timestamp": 1663181197761, + "version": "1.7.0" + }, + "nodeenv-1.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a02feb7ae0a381b88b1f5b9f4da0fe0f", + "name": "nodeenv", + "sha256": "6787d7a773405ee587a5f808083965c5435fd96c808ba6b6adc475b1c5566af6", + "size": 44644, + "subdir": "linux-64", + "timestamp": 1663181132273, + "version": "1.7.0" + }, + "nodejs-10.13.0-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "f321c1ade4d4c6486c2469d368a44a61", + "name": "nodejs", + "sha256": "ea93189ecdc6d8a4f6c82ea806fb7f2ffb7015bbe4fdf3395de77a1bbb09025d", + "size": 16190154, + "subdir": "linux-64", + "timestamp": 1541177751056, + "version": "10.13.0" + }, + "nodejs-14.8.0-hda19d22_0.tar.bz2": { + "build": "hda19d22_0", + "build_number": 0, + "depends": [ + "icu >=68.1,<69.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libuv >=1.40.0,<1.41.0a0", + "openssl >=1.1.1j,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "c6d42fb65125619faa86becf15fb93c6", + "name": "nodejs", + "sha256": "36ffbd552728354d3f730d55710d9e78163370e801151438c68234656e75c510", + "size": 16405627, + "subdir": "linux-64", + "timestamp": 1615888823149, + "version": "14.8.0" + }, + "nodejs-16.13.1-hb931c9a_0.tar.bz2": { + "build": "hb931c9a_0", + "build_number": 0, + "depends": [ + "icu >=68.1,<69.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libuv >=1.40.0,<1.41.0a0", + "openssl >=1.1.1l,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "05d36c77b57cfdb28928728874e4aa04", + "name": "nodejs", + "sha256": "79ab7d2c8a288f18cc94cc3a070960e0a6a8a2637335f259d43060d92c467c9c", + "size": 15890879, + "subdir": "linux-64", + "timestamp": 1638847541442, + "version": "16.13.1" + }, + "nodejs-16.6.1-hb931c9a_0.tar.bz2": { + "build": "hb931c9a_0", + "build_number": 0, + "depends": [ + "icu >=68.1,<69.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libuv >=1.40.0,<1.41.0a0", + "openssl >=1.1.1k,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "9667190aa6ed1702890265bdf59d47de", + "name": "nodejs", + "sha256": "8c9123f9507d5397bbd625f94fd29416bd73b47a5d2da07c9f9dfaed90f89cbc", + "size": 16161401, + "subdir": "linux-64", + "timestamp": 1629196936573, + "version": "16.6.1" + }, + "nodejs-18.15.0-ha637b67_0.tar.bz2": { + "build": "ha637b67_0", + "build_number": 0, + "depends": [ + "icu >=58,<59.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuv >=1.44.2,<1.45.0a0", + "openssl >=1.1.1t,<1.1.2a", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87b1b230b99ee1059be0544a8fd08a34", + "name": "nodejs", + "sha256": "c6d3c1d53e0b56c6f3a7ffcec0e9bee39d08e545897e069e445e52abba655444", + "size": 16962473, + "subdir": "linux-64", + "timestamp": 1680792375119, + "version": "18.15.0" + }, + "nodejs-6.11.2-h3db8ef7_0.tar.bz2": { + "build": "h3db8ef7_0", + "build_number": 0, + "depends": [ + "libgcc", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "ca6fab73db3f9d7ca504add4b8e04dd5", + "name": "nodejs", + "sha256": "b8124203032f21fec68a380f2222304dadd97127549cb7e1a957805a81fabf10", + "size": 11926352, + "subdir": "linux-64", + "timestamp": 1505746369243, + "version": "6.11.2" + }, + "nodejs-8.11.1-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "55601b4ad5f2610ea6c4ba18cc0e5e89", + "name": "nodejs", + "sha256": "4a12fd9f085209138e58dbdfd64da3fad0ef467168b4a36a4aec805d4bf9e58a", + "size": 15183198, + "subdir": "linux-64", + "timestamp": 1525983296113, + "version": "8.11.1" + }, + "nodejs-8.11.3-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "b4c165140febae4cbb781e36a8507dc7", + "name": "nodejs", + "sha256": "eea109cbc9dac2cdba7c018a8fe4ebfd97a73fa362157d0c57cd83e348729a93", + "size": 15183911, + "subdir": "linux-64", + "timestamp": 1531554770281, + "version": "8.11.3" + }, + "nodejs-8.11.4-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "63babd59455403c876d50205711f5ed2", + "name": "nodejs", + "sha256": "cb6a87fc4b854cd4ba8db2aac52e928718f2a71f604f1d4d80f73bd55f8ab572", + "size": 15441650, + "subdir": "linux-64", + "timestamp": 1535909408715, + "version": "8.11.4" + }, + "nodejs-8.12.0-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "7241fb719f2e29dd16ed13a4ced48447", + "name": "nodejs", + "sha256": "a7b85b5c57f91325f13ad01497bc929362d772c02e169acfea126ba4e7206f44", + "size": 15274323, + "subdir": "linux-64", + "timestamp": 1538330254726, + "version": "8.12.0" + }, + "nodejs-8.9.3-h439df22_0.tar.bz2": { + "build": "h439df22_0", + "build_number": 0, + "depends": [ + "libgcc", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "8645c8298eb0034c5c6c6e789c1b32d8", + "name": "nodejs", + "sha256": "2575fc4db622f2d7b928179940e8bb549977a9f7b15feae56ab2b258b097a94e", + "size": 15236764, + "subdir": "linux-64", + "timestamp": 1517163745353, + "version": "8.9.3" + }, + "nomkl-2.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "blas * openblas" + ], + "license": "BSD", + "md5": "49e83d6c135a5d7782a65531aa77dc99", + "name": "nomkl", + "sha256": "f764c61887cc7821757366a43fe46209c62dc7917acd894e799ca16277718bde", + "size": 2425, + "subdir": "linux-64", + "timestamp": 1525427522765, + "track_features": "", + "version": "2.0" + }, + "nomkl-3.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "blas * openblas" + ], + "license": "BSD", + "md5": "dd8bdca858ba54245790a3cab33cec32", + "name": "nomkl", + "sha256": "a4dc36c70876286efa63a15430ccdc104b692875a2e9343f2b6a9ab508de7fda", + "size": 49388, + "subdir": "linux-64", + "timestamp": 1527877217548, + "track_features": "", + "version": "3.0" + }, + "nose-1.3.7-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "LGPL-2.1", + "md5": "98a201723664aa254a260bcb3319c043", + "name": "nose", + "sha256": "78663b0c4347651ea7caada7f4dd09cb64503422655b1a834ec6ec483e8d69ef", + "size": 217601, + "subdir": "linux-64", + "timestamp": 1530695924405, + "version": "1.3.7" + }, + "nose-1.3.7-py27heec2199_2.tar.bz2": { + "build": "py27heec2199_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "LGPL-2.1", + "md5": "0e30466d222d8686cc054432d39225bd", + "name": "nose", + "sha256": "ef84af385554a903c6d9ca63394b5f0380dd8721b692b349087fe250d91c3e46", + "size": 217422, + "subdir": "linux-64", + "timestamp": 1505688871443, + "version": "1.3.7" + }, + "nose-1.3.7-py310h06a4308_1007.tar.bz2": { + "build": "py310h06a4308_1007", + "build_number": 1007, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1-only", + "md5": "ce51e6c42429bee543897c608dc2d818", + "name": "nose", + "sha256": "d9d0fa24af308bed203ec2f8ee8615287afd17d8a659bfa56bdb2bfc2b931f34", + "size": 171596, + "subdir": "linux-64", + "timestamp": 1640873180428, + "version": "1.3.7" + }, + "nose-1.3.7-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "LGPL-2.1", + "md5": "f6dd796717f0a4ee1042b6dca7b3dd93", + "name": "nose", + "sha256": "b592319266fbe1dc52a834ac979737cbb057f4b7fda68f044821b6e1709ea50a", + "size": 221122, + "subdir": "linux-64", + "timestamp": 1534345565529, + "version": "1.3.7" + }, + "nose-1.3.7-py35hdc64897_2.tar.bz2": { + "build": "py35hdc64897_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "LGPL-2.1", + "md5": "0418964c94be00b31de9eba3fe0bade6", + "name": "nose", + "sha256": "97cee89a1d8f9106689c0f7fa307b739d13c8a05cce54f2b660087c5a5afc764", + "size": 221060, + "subdir": "linux-64", + "timestamp": 1505688890606, + "version": "1.3.7" + }, + "nose-1.3.7-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "LGPL-2.1", + "md5": "60ca9af44ba2038abc310f34d26c5154", + "name": "nose", + "sha256": "e38dfd2dd433656ead979eb84900164e62e6a7571e47fdc9eaf0fb2d5896d591", + "size": 218894, + "subdir": "linux-64", + "timestamp": 1530695876499, + "version": "1.3.7" + }, + "nose-1.3.7-py36hcdf7029_2.tar.bz2": { + "build": "py36hcdf7029_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "LGPL-2.1", + "md5": "1840253466fa90e6571d033c44a869a3", + "name": "nose", + "sha256": "8db9261f2ebc73d789a0bd57d56380786335f30692c9fdb9a2e794f44546f85d", + "size": 218822, + "subdir": "linux-64", + "timestamp": 1505688910137, + "version": "1.3.7" + }, + "nose-1.3.7-py37_1004.tar.bz2": { + "build": "py37_1004", + "build_number": 1004, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "LGPL-2.1", + "md5": "34375f7538d6a127a775c2ec0607b46c", + "name": "nose", + "sha256": "a0f8aaa4ab88c54c29d1ff26fe16c101b806c059e398ab6ff10824f5db19d459", + "size": 216827, + "subdir": "linux-64", + "timestamp": 1594377700587, + "version": "1.3.7" + }, + "nose-1.3.7-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "LGPL-2.1", + "md5": "ff390a1e44d77e54914ca1a2c9e75445", + "name": "nose", + "sha256": "173aea1bb731549eef249660bab7d18c1d531b08896a4e416fb54c7eaf7e4a83", + "size": 218753, + "subdir": "linux-64", + "timestamp": 1530695903401, + "version": "1.3.7" + }, + "nose-1.3.7-py38_2.tar.bz2": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "LGPL-2.1", + "md5": "8092af36853c46e4cd61e9ffb40b51fa", + "name": "nose", + "sha256": "1430a3fce596aea539d978dfcffcc5b1e2debc26762dca4c116d037d6b7221aa", + "size": 216396, + "subdir": "linux-64", + "timestamp": 1573143550513, + "version": "1.3.7" + }, + "nose-parameterized-0.6.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "7a440e4c20c601843c085d52cfb3d390", + "name": "nose-parameterized", + "sha256": "49c6d15efa04e6c32a93e34bc9444c81fa924c8846091e343d1a4c3b038d5d05", + "size": 18974, + "subdir": "linux-64", + "timestamp": 1530917278148, + "version": "0.6.0" + }, + "nose-parameterized-0.6.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "80cdbe7de06d7879c0cf039db91ea03a", + "name": "nose-parameterized", + "sha256": "59209be470fd3b20c05fab7ede40e859f2ae0aede10eafe47eccced0ddc21a4d", + "size": 21763, + "subdir": "linux-64", + "timestamp": 1676725816241, + "version": "0.6.0" + }, + "nose-parameterized-0.6.0-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "7ab95379d4ab248cbffeda3ebb57a606", + "name": "nose-parameterized", + "sha256": "f25eed7407a992c324def2461e3d471a2ec06fe6f6a0737ce472adf041ab4995", + "size": 27864, + "subdir": "linux-64", + "timestamp": 1676859970589, + "version": "0.6.0" + }, + "nose-parameterized-0.6.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "bf6b1dd0086a259469db83fb0804bdcf", + "name": "nose-parameterized", + "sha256": "17e2700b66e10c0f69125173286d660f7bb1a491109491272922876d2636fa7e", + "size": 19514, + "subdir": "linux-64", + "timestamp": 1530917306378, + "version": "0.6.0" + }, + "nose-parameterized-0.6.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9e799b7997c41ea10f9802632fc5e50c", + "name": "nose-parameterized", + "sha256": "b3b934fc58ee0f6060ca45e7bff5c791d40e332e551f1ed2c6b4c8e116b80739", + "size": 21501, + "subdir": "linux-64", + "timestamp": 1676725791423, + "version": "0.6.0" + }, + "nose-parameterized-0.6.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "ff9546224ce7f5c7b2bac87ccc5f68fe", + "name": "nose-parameterized", + "sha256": "e377118766eb76b28d2b42608d9eebdb92778412e6a269c7736a8935c3e99f94", + "size": 19513, + "subdir": "linux-64", + "timestamp": 1530917335717, + "version": "0.6.0" + }, + "nose-parameterized-0.6.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8c09e1b7ed223ee51b5bb78c663252fb", + "name": "nose-parameterized", + "sha256": "9daf86c087c028b9c661ce9f835a60bb4bb8be00bd76aa936a951cc612749fd7", + "size": 21585, + "subdir": "linux-64", + "timestamp": 1676725767333, + "version": "0.6.0" + }, + "nose-parameterized-0.6.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ab7513c8c38374b058680bc6840ddeba", + "name": "nose-parameterized", + "sha256": "93605977985a4218ef9750f40e6149625796154a73eb91554ebf3af0cf285857", + "size": 21618, + "subdir": "linux-64", + "timestamp": 1676725840564, + "version": "0.6.0" + }, + "nosexcover-1.0.11-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "coverage >=3.4", + "nose", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3dd712297f993342b00534c48751021d", + "name": "nosexcover", + "sha256": "4210e2dcc2937c8746c2ff5cf19d56a33b791c14b1001f4f01fb476834107a48", + "size": 9301, + "subdir": "linux-64", + "timestamp": 1537199344631, + "version": "1.0.11" + }, + "nosexcover-1.0.11-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "coverage >=3.4", + "nose", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bddfde5f13894a8956d26ef53a768bf1", + "name": "nosexcover", + "sha256": "df20ea05087a8b33de7b0934b69dd50d3467581ee57bda8b845abae745fbe4c3", + "size": 9505, + "subdir": "linux-64", + "timestamp": 1537199360253, + "version": "1.0.11" + }, + "nosexcover-1.0.11-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "coverage >=3.4", + "nose", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "469588bf62e1819bcd556d8d2b11a3b9", + "name": "nosexcover", + "sha256": "e4b9ed6a7e4492ac86644130088c561f11314a4977f58c3b6bdc18b760b0a550", + "size": 9504, + "subdir": "linux-64", + "timestamp": 1537199392978, + "version": "1.0.11" + }, + "nosexcover-1.0.11-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "coverage >=3.4", + "nose", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f0899a5e581f0c401c650bd64cdcf21", + "name": "nosexcover", + "sha256": "53ba745f1033cb4cc79dfdf39a642f83a0075c9818a14d4539a17858fa0509b3", + "size": 9521, + "subdir": "linux-64", + "timestamp": 1537199323264, + "version": "1.0.11" + }, + "notebook-5.0.0-py27h3661c2b_2.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27h3661c2b_2", + "build_number": 2, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "084a21c3a2fa80c366a95228a6a78960", + "name": "notebook", + "sha256": "9b851e7b28e18f8b7d83b25a8588265e535c326e69ccafd54174a263b88e3dbd", + "size": 5917824, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1506020374312, + "type": "app", + "version": "5.0.0" + }, + "notebook-5.0.0-py35h65c930e_2.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35h65c930e_2", + "build_number": 2, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "cf288bd7403085a7e0c80a499e98e45a", + "name": "notebook", + "sha256": "c025a9bbaaf8bb8d3419c07dd6872ca4044923f30fc412e15372f30b4f2f1c7a", + "size": 5929611, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1506020402472, + "type": "app", + "version": "5.0.0" + }, + "notebook-5.0.0-py36h0b20546_2.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h0b20546_2", + "build_number": 2, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "fbae5d1642aad476a0af77abe598a046", + "name": "notebook", + "sha256": "4e303d5d3a34f3e94a88edc8db979d1c0fcb20b6a89aaf77a7a4f8eda9835210", + "size": 5938406, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1506020410740, + "type": "app", + "version": "5.0.0" + }, + "notebook-5.1.0-py27hd3eeb0d_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27hd3eeb0d_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "5fdaf21150397f3928983ed476845595", + "name": "notebook", + "sha256": "d968acf5f1c7c8dd98f71f49093e10bc92b7ce903a62ea6d65033edf52f5048b", + "size": 6819611, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1509990491201, + "type": "app", + "version": "5.1.0" + }, + "notebook-5.1.0-py35ha1dae67_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35ha1dae67_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "e6c5de0241a5e0d2c9c0ce444128b1f3", + "name": "notebook", + "sha256": "c584ff2b198201455233b510757ddce736d6500dd4914b4d7bb19678478e5341", + "size": 6842434, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1509990500195, + "type": "app", + "version": "5.1.0" + }, + "notebook-5.1.0-py36h2e4799b_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h2e4799b_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "0e9e630de9e65318a5705108f7d82119", + "name": "notebook", + "sha256": "6246429247a34988a391735289a5105622aa05467b8883527671182b330a2d1b", + "size": 6848984, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1509990480452, + "type": "app", + "version": "5.1.0" + }, + "notebook-5.2.0-py27h7e51e94_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27h7e51e94_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "7b113fbebc742c63c00076be409b21d4", + "name": "notebook", + "sha256": "34ef3f1e4803608b640c5da75f99e61d863b9c961a31bf78f0f090a7dfed4c73", + "size": 6826253, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1509991843909, + "type": "app", + "version": "5.2.0" + }, + "notebook-5.2.0-py35h8f773aa_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35h8f773aa_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "cc5b69e1630420f157141d9e187c9313", + "name": "notebook", + "sha256": "b7c741062409e12ccafb7fcb4a1345130f2965de7a5e2070eec3aad2bac46b35", + "size": 6851887, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1509991866488, + "type": "app", + "version": "5.2.0" + }, + "notebook-5.2.0-py36h840ffc4_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h840ffc4_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "bf048dff93fec8647c7eca48816e842c", + "name": "notebook", + "sha256": "26b80a0b4f4e5aa6b29f29b7697dd0cf0d85dd1d18afd66459388bd33b8dfdef", + "size": 6862068, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1509991848101, + "type": "app", + "version": "5.2.0" + }, + "notebook-5.2.1-py27h4055434_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27h4055434_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "5f5d7b685604dc04eaa047f3ff9a8ac6", + "name": "notebook", + "sha256": "0ccfefc8493f98f73f9f600f76b97fe57dc08093363c421b1903dd4cd4e45557", + "size": 6824731, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1509992476473, + "type": "app", + "version": "5.2.1" + }, + "notebook-5.2.1-py35h35fdc29_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35h35fdc29_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "a144fb379365cdd584a9df07332e5ab7", + "name": "notebook", + "sha256": "48b53293a670c6cf1e7f7bee826ada280b85d0d5cd941368a6c39021944cdf45", + "size": 6853446, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1509992472447, + "type": "app", + "version": "5.2.1" + }, + "notebook-5.2.1-py36h690a4eb_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h690a4eb_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "22719b59948b5abd8212ffa4c48777bd", + "name": "notebook", + "sha256": "fa686e068fd522c2bd18f7d20a9cec17064dda515d788b32449310984a15f471", + "size": 6860300, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1509992468606, + "type": "app", + "version": "5.2.1" + }, + "notebook-5.2.2-py27h6748267_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27h6748267_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5220dfc945f533224d59c8437e2d5e01", + "name": "notebook", + "sha256": "204dc33bed4c6c17d4ad760cdd5765b851a5f617334adf129f2bf9ceaddca946", + "size": 6823354, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1512056125257, + "type": "app", + "version": "5.2.2" + }, + "notebook-5.2.2-py35he644770_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35he644770_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4651334aac3a6d078edb232f6c8acabb", + "name": "notebook", + "sha256": "1192500b23131de4c684b56303b9395862b9d5c281d197b5fcdea66c325028fa", + "size": 6854438, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1512056138485, + "type": "app", + "version": "5.2.2" + }, + "notebook-5.2.2-py36h40a37e6_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h40a37e6_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d46c394c8a23f8fed4974dbb936ba6d4", + "name": "notebook", + "sha256": "e905d859010953b5360f1078667c409a1be2b14c9489c50aa6db7521981b6f2d", + "size": 6858246, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1512056154533, + "type": "app", + "version": "5.2.2" + }, + "notebook-5.3.1-py27_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "send2trash", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c89f1df6c222dd927e4b97f56b912619", + "name": "notebook", + "sha256": "fcaf0c70c17c2df4e3f1b76aeaa39349cb08d7cedab94e24b873e8bab8cc47d7", + "size": 6932507, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1516378987281, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py27_1.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_1", + "build_number": 1, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4bdd7b009ac10986d3bcd74ed907d52a", + "name": "notebook", + "sha256": "101669c3d7e83a0c123d962b741c6e6bc8ce07d27f98d39f5de9df8e1c270305", + "size": 6933087, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1516901002181, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py27_2.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_2", + "build_number": 2, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d14c9688d3547f39a4b1c2916dac85f4", + "name": "notebook", + "sha256": "b953c7cb5daa9f7376e7e386308b1029b93c54bb2bdb065c25ee76532d74f103", + "size": 6933429, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1517284522349, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py27_3.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_3", + "build_number": 3, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "01e386404b6bc4a80358d146f6b78dcf", + "name": "notebook", + "sha256": "0379fe6e6ba4e92fa48cd60a33e60814c16370f3c5ffa6c7903fc60ea44ceeb9", + "size": 6932542, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1517599660480, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py35_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "send2trash", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4ea75382d291b923081e094eeea40a49", + "name": "notebook", + "sha256": "05f87a033e0f9829c5da1183ada3cee771c0c66df29fdb48f0168008dd5a8771", + "size": 6947490, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1516378995284, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py35_1.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35_1", + "build_number": 1, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "82f1e7756b1aa4f87da4dfef75ff7dee", + "name": "notebook", + "sha256": "422ee38214612f2cbca7e5798ec62325c644dac5ddf6cf2609d5b3eee010102f", + "size": 6947560, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1516900994402, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py35_2.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35_2", + "build_number": 2, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6da454ba36f74cb6ca57a2c25066acd4", + "name": "notebook", + "sha256": "6c4951fa0fc5bab4700cd864cd4a38bde5026a1c369c0caa668c066dc569bcc5", + "size": 6946849, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1517284501106, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py35_3.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35_3", + "build_number": 3, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b83ffaab03a748793f4845d56a078edd", + "name": "notebook", + "sha256": "c779f1972872c0f63112ecd31d85fab4991e72279d41071f1abf263279e0ca6a", + "size": 6946062, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1517599711424, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "send2trash", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d79eb76ceadde5f30765fbb5df7b215f", + "name": "notebook", + "sha256": "5d850579a09b6614ae8590fc83652a063e9281176cd461aca95c0965cfa8538f", + "size": 6923417, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1516379018481, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py36_1.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_1", + "build_number": 1, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d6164ead90b9c4b68c6d0d1936b7954d", + "name": "notebook", + "sha256": "b735ca429e82b3eabbc05b900e001430ecf5f318255c05d25a66a287438382dd", + "size": 6921974, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1516901069049, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py36_2.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_2", + "build_number": 2, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "bd868a6bc682840b6c3cabb0a346cee8", + "name": "notebook", + "sha256": "100374993e24b358445b163766bea83b1610c7145bb80beebbeb825584d89b95", + "size": 6923254, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1517284536277, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py36_3.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_3", + "build_number": 3, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cb56d41eb2d9c4cba51ef74e09203837", + "name": "notebook", + "sha256": "f07cbc9cf41014422baf8a8240ff98106693a149d58bb2c86aa75e5ef61f29a4", + "size": 6922650, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1517599668303, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.4.0-py27_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "155014facea881ff7d60f90909c1b1cb", + "name": "notebook", + "sha256": "64c31329281910233276d078b80dc2b4b3d88927efa220c8ebfb5e15cd2aaeed", + "size": 6932705, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1517597710556, + "type": "app", + "version": "5.4.0" + }, + "notebook-5.4.0-py35_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "13334ea80c0121202b2255c646aa623c", + "name": "notebook", + "sha256": "77f54ea4a9d62bba509278c410c2b13a05318ff6ed21bb085e4bc3b25d83b751", + "size": 6947821, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1517597772373, + "type": "app", + "version": "5.4.0" + }, + "notebook-5.4.0-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "391b594103a68d5c8afd8340f0dd2bce", + "name": "notebook", + "sha256": "f9a04d5fb0a7ab014420521e7e8443bde3a3579f47f7c3aca31c5f375547ca58", + "size": 6926753, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1517597712745, + "type": "app", + "version": "5.4.0" + }, + "notebook-5.4.1-py27_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ed44193d3e0d64599d31dd5809de979b", + "name": "notebook", + "sha256": "7370208a5b7b3e29ceb27105865f6aeeee24fba10e5a8ac2a00e035757ccef92", + "size": 6933477, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1521583897536, + "type": "app", + "version": "5.4.1" + }, + "notebook-5.4.1-py35_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9006499c5dc5d50d4974229a243ef93b", + "name": "notebook", + "sha256": "49d91ccd28d0dad8f5dcbededddcc228ee59af64ac32adc226e036c7d56b88c5", + "size": 6961379, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1521583997287, + "type": "app", + "version": "5.4.1" + }, + "notebook-5.4.1-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7c7fb563636c0f2b10c1c58e14f6a410", + "name": "notebook", + "sha256": "cf8c1c84cd2b5b7e8bd8067a89fd88dee58da9758b2af6e18ac82d52c638b292", + "size": 6939646, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1521584005149, + "type": "app", + "version": "5.4.1" + }, + "notebook-5.5.0-py27_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0f256aa732f7d8e240b0ea445d4422d8", + "name": "notebook", + "sha256": "78defc26cb5e27e14b2253cfa6c4e385b5751b383ac6f70e8a9a0a66936acff0", + "size": 7343003, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1526402013440, + "type": "app", + "version": "5.5.0" + }, + "notebook-5.5.0-py35_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d345f6e783bd87dad2e5df8c8b2fad18", + "name": "notebook", + "sha256": "4ffe34aec5f88eae9ea5248214f9b7edcbc2cb39621fc57c1703ffad16a7e20d", + "size": 7301403, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1526402062117, + "type": "app", + "version": "5.5.0" + }, + "notebook-5.5.0-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "50c63bf1fdea6320f6558e666bc4c58c", + "name": "notebook", + "sha256": "1b84e80d877dd1bcd39c09a80fd67ee084fe218da8a73ff5b2fffa5f14c5672f", + "size": 7306185, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1526401999139, + "type": "app", + "version": "5.5.0" + }, + "notebook-5.5.0-py37_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "28e97897e53998c0f82999e6e894bff9", + "name": "notebook", + "sha256": "d4e64ce66519a973492286d93e9d5944721d035c8e3d41d7e3eb933661cef93c", + "size": 7298863, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1530734695114, + "type": "app", + "version": "5.5.0" + }, + "notebook-5.6.0-py27_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "fb4ce60a5038ca08dd1a58ea445295e1", + "name": "notebook", + "sha256": "54696fc68048f49e37d7c87f95fda5e6f9f94edb4d04d379ea0c5b5fb65b40a0", + "size": 7663931, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1531776180120, + "type": "app", + "version": "5.6.0" + }, + "notebook-5.6.0-py35_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.5,<3.6.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "487573312c1543f3b0f64c3801288d95", + "name": "notebook", + "sha256": "3c4de16472cbb89d9185049c51e056dd165bced25c291ecb48eaea3d6d1106b0", + "size": 7693744, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1531776242622, + "type": "app", + "version": "5.6.0" + }, + "notebook-5.6.0-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4a5c3a67faa410dee39c412c5991517b", + "name": "notebook", + "sha256": "08162a47fcf32cd2408b20f9cbe355e81ce2282c22700a7ed632a0b587e587b2", + "size": 7717707, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1531776294400, + "type": "app", + "version": "5.6.0" + }, + "notebook-5.6.0-py37_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a65c14e3e5d0a63c06ae7cbbcfc9bbf5", + "name": "notebook", + "sha256": "a60b35954bc70471862c35c13d054e7ec4354127958d71b7894bf328e4ff6367", + "size": 7721814, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1531776296525, + "type": "app", + "version": "5.6.0" + }, + "notebook-5.7.0-py27_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e4b3060fb1c992a18b54afb9a836df5f", + "name": "notebook", + "sha256": "76ae36ddf4b5e7669918b34bd61de8e9b5e7247ea4c9348a3460877599f2f4bb", + "size": 7732412, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1538589087538, + "type": "app", + "version": "5.7.0" + }, + "notebook-5.7.0-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b8253b35ed0329c192c40165a13ac99c", + "name": "notebook", + "sha256": "915c6c332b4e2703becd7676ce0b04e10fe16629ebecd1f8b2033eb8e15dc50c", + "size": 7767427, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1538589087433, + "type": "app", + "version": "5.7.0" + }, + "notebook-5.7.0-py37_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6b168917e4152f1070c757d1450b3322", + "name": "notebook", + "sha256": "fd44a1b30b36373a3dca2dbab16fb88d8df8550eb55e84738fd53f7c6c1d3fd2", + "size": 7769191, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1538589076147, + "type": "app", + "version": "5.7.0" + }, + "notebook-5.7.1-py27_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f49083138e755fb4c16c3567bd1a8d35", + "name": "notebook", + "sha256": "027e5113e472cabd33247a07fe852882628e596363e93c07793042671eae79db", + "size": 7588606, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1542407389252, + "type": "app", + "version": "5.7.1" + }, + "notebook-5.7.1-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6310adc4828cf5e337ba49ed9f71d273", + "name": "notebook", + "sha256": "878cd735c582aaa7b02ce62c9b9718443cbf00aaf22ce2715b31ed730cce9a6d", + "size": 7583560, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1542407422611, + "type": "app", + "version": "5.7.1" + }, + "notebook-5.7.1-py37_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d6c6b8efb40c2eb9971784a5e26b44f8", + "name": "notebook", + "sha256": "08da46f51d48f5c01a46f09fbf8d21a3ad8af3c3d9416e4c1eac587bc96a1ab1", + "size": 7585605, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1542407415587, + "type": "app", + "version": "5.7.1" + }, + "notebook-5.7.10-py27_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert <6.0", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2bad94e4a4785a3ae66887c6374c7a1f", + "name": "notebook", + "sha256": "318371e43260a97a7888a764394958e524c51a81b6a2848c3e1f1d8e86fc40d8", + "size": 8062547, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1595953412335, + "type": "app", + "version": "5.7.10" + }, + "notebook-5.7.10-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert <6.0", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "131614fb2ad1e76f554d2ef6e630fcc1", + "name": "notebook", + "sha256": "51aa92517b92f5f937f1e2231cbb65750e9e130d37cbc08ec8ef9499c828b903", + "size": 8075536, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1595951667014, + "type": "app", + "version": "5.7.10" + }, + "notebook-5.7.10-py37_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert <6.0", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dc0b965ea6413e637f0374ec92effbbc", + "name": "notebook", + "sha256": "6ccc95ce8a95c4aebbd0027c5415f3110724ce79f4881179802a3bba98747775", + "size": 8129221, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1595951650778, + "type": "app", + "version": "5.7.10" + }, + "notebook-5.7.10-py38_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert <6.0", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c544f18b5f97fd8e8a881fa772a9c4d7", + "name": "notebook", + "sha256": "a841a56b67b4332560caadd100b4f233a7f343688acdfa44e928408031f61186", + "size": 8086833, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1595951667522, + "type": "app", + "version": "5.7.10" + }, + "notebook-5.7.2-py27_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b90704dc63f7ad1e292302d301e2835c", + "name": "notebook", + "sha256": "fd8a3b254e8b3e778f69562688bd1831d38db7a505f282309134e47d1b27ecf9", + "size": 7600436, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1542640958808, + "type": "app", + "version": "5.7.2" + }, + "notebook-5.7.2-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "41d98099ff404c510e6287ca15a4cdb7", + "name": "notebook", + "sha256": "3671d6b3d38160e3db701511bacf15a2243463a127732e74e1b3a65aa87a7884", + "size": 7586611, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1542640982432, + "type": "app", + "version": "5.7.2" + }, + "notebook-5.7.2-py37_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c694cbe524210f906ddb2ccadbc86ccc", + "name": "notebook", + "sha256": "e57742217d4d8d7e5dd501755901a52d98a295a4fbc9feedbdabed75584a50a8", + "size": 7613118, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1542640963040, + "type": "app", + "version": "5.7.2" + }, + "notebook-5.7.4-py27_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6ee46da41f458cc0cefe4cfa980c4016", + "name": "notebook", + "sha256": "d0cfd07832a5ac506b95df2a35f6e3a7ad4e316460b4eb63c3db75921fbe1faf", + "size": 7581317, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1545057355411, + "type": "app", + "version": "5.7.4" + }, + "notebook-5.7.4-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "53bfdcd46dc4177981d7f64b099724ac", + "name": "notebook", + "sha256": "42e4a8b0e9388a60178282a2b647d7d395ab2b2d7fe52ebea64b0e6e451896b0", + "size": 7531168, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1545057383859, + "type": "app", + "version": "5.7.4" + }, + "notebook-5.7.4-py37_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b368ef34d5b0af84eba9ea199d941a5e", + "name": "notebook", + "sha256": "d547bba55cb9cbd3b2acf20fe7cf138c6a45c53f444cc59ffa614cbd6ed1dde3", + "size": 7602580, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1545057381894, + "type": "app", + "version": "5.7.4" + }, + "notebook-5.7.6-py27_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cee00de114e0ba8f3e112cdb82cecf06", + "name": "notebook", + "sha256": "b5937ef04b42f2edef641bb8e32aa35134d4f14c8090ea93c0d4cdd2de268491", + "size": 7531306, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1552325462953, + "type": "app", + "version": "5.7.6" + }, + "notebook-5.7.6-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a90b10797e2cc15311b40268fa908d7c", + "name": "notebook", + "sha256": "09b80c256ced90b8f47baaae6f070cc37d7313b70ef10b05a5db0e47c10e594c", + "size": 7588032, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1552325468150, + "type": "app", + "version": "5.7.6" + }, + "notebook-5.7.6-py37_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "950cd052eb1be576e3e53b654663c9c1", + "name": "notebook", + "sha256": "aac07310332a1d1d269e9ecb897ad9348133bd40fd7ec66708c7de7eaa1f91a1", + "size": 7598439, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1552325463940, + "type": "app", + "version": "5.7.6" + }, + "notebook-5.7.7-py27_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "08d9f52e21bc73299387fdca0bdb154e", + "name": "notebook", + "sha256": "4f580ce072c940d088ee474ca85125e455ae9fa2dae371227b2f0ef109cf4e3c", + "size": 7605185, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1553778893599, + "type": "app", + "version": "5.7.7" + }, + "notebook-5.7.7-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9683f08ddd3e5702ae942bfe2167bce4", + "name": "notebook", + "sha256": "0857d9b2eca731a22a3cd4bcebf0c6c2b5987ddc8eeaff319885667b5e7249b7", + "size": 7616519, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1553779054958, + "type": "app", + "version": "5.7.7" + }, + "notebook-5.7.7-py37_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8e704d01222ad41691d0ec05971e459e", + "name": "notebook", + "sha256": "79342dcbdbe349e043ff8414e652a9b6fbafbe2314870e606e319810e2060321", + "size": 7596271, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1553778896535, + "type": "app", + "version": "5.7.7" + }, + "notebook-5.7.8-py27_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1ae27449e65334dde708d7a70e3832ef", + "name": "notebook", + "sha256": "c46011bd94db9fded26c9783c5ed603f95fe1028c2dcf44ba2277cb92d9c62d2", + "size": 7593717, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1554133769498, + "type": "app", + "version": "5.7.8" + }, + "notebook-5.7.8-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ca1f5438452e35f7c35ccf2222f0d51d", + "name": "notebook", + "sha256": "98dcb9883d3ccc8502ef62a8428aaa3be5a2e97ff35d191bfc0d3b5746fa6d26", + "size": 7603645, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1554133780255, + "type": "app", + "version": "5.7.8" + }, + "notebook-5.7.8-py37_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d2a610b8ff9e8f5b6be8a9f07a6df96c", + "name": "notebook", + "sha256": "7985a18c14fad9f0ef0732a4d438c6f0402f8da9ff79cd17edfadcc1eb0f7a74", + "size": 7529485, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1554133790519, + "type": "app", + "version": "5.7.8" + }, + "notebook-5.7.9-py27_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert <6.0", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "884e3db78091ee4193587b5d138e458a", + "name": "notebook", + "sha256": "e9758e2b6baeb82e6027c8defeffdffadc70c2f7f809affd59003857143c2cf9", + "size": 8058055, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1588949767586, + "type": "app", + "version": "5.7.9" + }, + "notebook-5.7.9-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert <6.0", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cdd2c147dc1793f19eb950ef00d0fb8f", + "name": "notebook", + "sha256": "aa764b18cbd174068668e93745c2c6fb21f98ca08bab63391255ebba85ba3489", + "size": 8061044, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1588949779012, + "type": "app", + "version": "5.7.9" + }, + "notebook-5.7.9-py37_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert <6.0", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cf1e58c41cf506c864976f9d5a09d826", + "name": "notebook", + "sha256": "d075fe40dcb5dc80228c9fc45aa26fce5f8da57e510ede31172fd6a447f8935a", + "size": 8025231, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1588949774808, + "type": "app", + "version": "5.7.9" + }, + "notebook-5.7.9-py38_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert <6.0", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3ef3b4c71103621b06efd400be9723ec", + "name": "notebook", + "sha256": "a64a62f440c2e7869013b96f2e1e9ebdc2dd4adb7b2fa256aedbea717ead9833", + "size": 7938548, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1588949755871, + "type": "app", + "version": "5.7.9" + }, + "notebook-6.0.0-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.1", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "07b56e22098964e1b1b2017a5d06c90a", + "name": "notebook", + "sha256": "7f0c038f696edfa8074c6c9d22512155ff6aa4f83286c2a51dc678baf8a78f6c", + "size": 6339014, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1563372829054, + "type": "app", + "version": "6.0.0" + }, + "notebook-6.0.0-py37_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.1", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "26b10d1f8da76b4f797ef9aba5854831", + "name": "notebook", + "sha256": "78879d2bc74190fab8cc3ad4baab1c9c7c19c4cedbb9d39e3f835047b51a0b22", + "size": 6290019, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1563372826867, + "type": "app", + "version": "6.0.0" + }, + "notebook-6.0.1-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.1", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d445ddcf09e4eb485c158fc7ad2c45ca", + "name": "notebook", + "sha256": "7fd5e775de2516eb1295058b778bd761820087c200c7671954f1ff78a0f6e4d6", + "size": 6340333, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1568217583118, + "type": "app", + "version": "6.0.1" + }, + "notebook-6.0.1-py37_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.1", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ac3df2504ea28b20f417159ec1d612cc", + "name": "notebook", + "sha256": "ff844fbe7379ed9007cbb33b48f5ede44e296bf007bfe8911ef8a9e2f0702d8b", + "size": 6337875, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1568217598986, + "type": "app", + "version": "6.0.1" + }, + "notebook-6.0.2-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c6dd773a58fd29fa4e06232f2e5e82f8", + "name": "notebook", + "sha256": "e7c280465ce0aab5229b7f7d054066a2e6401aed7d09627daf27c41324e1361b", + "size": 6608162, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1573576088030, + "type": "app", + "version": "6.0.2" + }, + "notebook-6.0.2-py37_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f43e9d22b0a952fd4a806f9d1ccc3be8", + "name": "notebook", + "sha256": "c42dec09b4884847be5ebd91fc2d69347699f5b7e918f9c252e41b7d3babbfbd", + "size": 6591086, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1573576091832, + "type": "app", + "version": "6.0.2" + }, + "notebook-6.0.2-py38_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "af1a8468387e3e0e2e8f1b31c4742c69", + "name": "notebook", + "sha256": "6b2a339a1e772385e1f064c0a875fbb3ae3b743bf0047499bfe59c4ff874ba4e", + "size": 6579960, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1574238699415, + "type": "app", + "version": "6.0.2" + }, + "notebook-6.0.3-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ba1611d98efa598d4394391ada1099c1", + "name": "notebook", + "sha256": "228f439bcd369fd1a5c7170b0c7a0c0a40cdf6af90400f6efd3f7c5e602107e1", + "size": 6625268, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1580148794141, + "type": "app", + "version": "6.0.3" + }, + "notebook-6.0.3-py37_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eec008df1145bc7eb964a7823de702a8", + "name": "notebook", + "sha256": "d08d5156281f73397e82ae80f401cb286eece6756b97de0c83b6bd82580b6168", + "size": 6619349, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1580148806627, + "type": "app", + "version": "6.0.3" + }, + "notebook-6.0.3-py38_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1561bb9ca29fcf6af9e76e334cf8d596", + "name": "notebook", + "sha256": "5f4eb5b6b3f8935d99bd1bbb04c7d9c07bc43459f533f6a27af168276957afbf", + "size": 6550011, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1580148766770, + "type": "app", + "version": "6.0.3" + }, + "notebook-6.1.1-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f66af2347ff140872b9c1d2674ad668b", + "name": "notebook", + "sha256": "a8f32dd191190fbe5fcb8f48cc34b4f1d550cd89aa5867864e4c5e6b27df0721", + "size": 6543166, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1596838642871, + "type": "app", + "version": "6.1.1" + }, + "notebook-6.1.1-py37_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eff1d9fb52e67666585e1c5376d7290d", + "name": "notebook", + "sha256": "425e0e05c73315b03ddc3d767e413309ba1a732ed45718ac82b54e87d02f1f7a", + "size": 6549553, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1596838688558, + "type": "app", + "version": "6.1.1" + }, + "notebook-6.1.1-py38_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "959646c64f611d552d1dcde6c6681322", + "name": "notebook", + "sha256": "d09d9b98667812109fb8ce823045087a72eb4132ca7c863bbedb6fcc88115296", + "size": 6553322, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1596838674769, + "type": "app", + "version": "6.1.1" + }, + "notebook-6.1.4-py36_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f58780439b878e3ef30a47df4097b077", + "name": "notebook", + "sha256": "cf526c5f1a8f65eb551193f0ca03342d0c627b3c7f373be9aef1235e1025e0e5", + "size": 6641916, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1601501621727, + "type": "app", + "version": "6.1.4" + }, + "notebook-6.1.4-py37_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a2cb2486577fe07eb257accb4d880d5e", + "name": "notebook", + "sha256": "dfed091535b241632ef5cc031dcf9d157eadf6e6e5599c563e4bb8b841b07f30", + "size": 6579157, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1601501623496, + "type": "app", + "version": "6.1.4" + }, + "notebook-6.1.4-py38_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4afdf98730eb998d1e7780f9920c2d6b", + "name": "notebook", + "sha256": "edc9ceb0310e1bf47dd546d43d85e18852ea930d159b6d61fec9409e822ab66b", + "size": 6628375, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1601501614764, + "type": "app", + "version": "6.1.4" + }, + "notebook-6.1.4-py39h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a719dfddd712f36ecf49507f22b0c41f", + "name": "notebook", + "sha256": "05f4488ac61949abe04d969e1359e5e376f13866f3585c91cb1391af4a0e91b8", + "size": 6674192, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1607529945972, + "type": "app", + "version": "6.1.4" + }, + "notebook-6.1.5-py36h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0244ef690983229f5f2ac91e453ac69c", + "name": "notebook", + "sha256": "f2ea3634d9525d004ba163962adcdfcc2f4ca183f0df8558ac3b1500860afc5c", + "size": 6634284, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1607976391259, + "type": "app", + "version": "6.1.5" + }, + "notebook-6.1.5-py37h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff639cbd0143252f4d831943e3073d2e", + "name": "notebook", + "sha256": "683e38a7698f4bc8395c226caede45b32e396318a46376de73c73563dc21d6d8", + "size": 6611595, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1607976347603, + "type": "app", + "version": "6.1.5" + }, + "notebook-6.1.5-py38h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5dab5a63097f5e747fbbbb3a369b445f", + "name": "notebook", + "sha256": "2424f70de35f74b28c0c3f8231e21f7f60f3bff45e99c7e4ac316ef2e772a54b", + "size": 6641516, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1607976398003, + "type": "app", + "version": "6.1.5" + }, + "notebook-6.1.5-py39h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3aa12f24326bb14d254348a72a0eb4e0", + "name": "notebook", + "sha256": "36907bf8c9b6788b883f35797454c2099459a8270bcdf1a501664c57db8a66f1", + "size": 6642098, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1607976371819, + "type": "app", + "version": "6.1.5" + }, + "notebook-6.1.6-py36h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f3e8ff159e3874708089bc9657725a2c", + "name": "notebook", + "sha256": "b26ffccc31d192b12847e26c40385fe2e7a2eca2eaaa44ed4bf939d8de1a6ac0", + "size": 6605239, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1608835632177, + "type": "app", + "version": "6.1.6" + }, + "notebook-6.1.6-py37h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4120d2953565042d72d7d520eeac7038", + "name": "notebook", + "sha256": "8f3333d8efd0be895e100b176d2016b57b5c93232b29e69fc6dece69fc1ca9d1", + "size": 6524644, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1608835593876, + "type": "app", + "version": "6.1.6" + }, + "notebook-6.1.6-py38h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6345347b413e80046feaf046b1eab85e", + "name": "notebook", + "sha256": "f9fdc793d5f798a117773cbb1395c1518f09cd2eede87128635a9342d48766a0", + "size": 6651502, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1608835633388, + "type": "app", + "version": "6.1.6" + }, + "notebook-6.1.6-py39h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "49b2e964fbf080fb3fbf539627a8e7e3", + "name": "notebook", + "sha256": "20385f6c865fc17494d0aefe4301590ee22f939b992b711ef7be7a244fb816b5", + "size": 6649005, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1608835629116, + "type": "app", + "version": "6.1.6" + }, + "notebook-6.2.0-py36h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "53df0df23a9f9abc6f3648b7cb4266ae", + "name": "notebook", + "sha256": "cf70f4bc46baa3c2c277daaa4b6785258a33111bbc31e52af1e4842e01715269", + "size": 6624447, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1611341060825, + "type": "app", + "version": "6.2.0" + }, + "notebook-6.2.0-py37h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a6590412450b464274b2e8066d49427e", + "name": "notebook", + "sha256": "a7e07f0fa14342787205b8154595a1177bce237e3d3fd47f9fdeb5b9e6d2ce5c", + "size": 6632492, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1611341027352, + "type": "app", + "version": "6.2.0" + }, + "notebook-6.2.0-py38h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9100ee09f67bbbf6102fd3d09d95129b", + "name": "notebook", + "sha256": "5eae599aa3b39502e6fe8068490637d825aa606db9d859a1984eca09b0d24869", + "size": 6628485, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1611341017313, + "type": "app", + "version": "6.2.0" + }, + "notebook-6.2.0-py39h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "83545a66eab2a702a0ef74af0f8ec069", + "name": "notebook", + "sha256": "0efc5810e4b7e485f50e6eeecb0c732c1166deb3c38bdeeff80cff6c415ae31b", + "size": 6624352, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1611340611646, + "type": "app", + "version": "6.2.0" + }, + "notebook-6.3.0-py36h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0ae21f29c49a33d87590ebd56da3edb4", + "name": "notebook", + "sha256": "6925ef778e45c4db1cb9d768d44dc4006daa780fbd95544eefe31a110b8acbb9", + "size": 6619024, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1616443508688, + "type": "app", + "version": "6.3.0" + }, + "notebook-6.3.0-py37h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f76bdf8e190298b0bf058a180fa4c2e8", + "name": "notebook", + "sha256": "3314c6ae82eff3663794732d9d7faa687366d22f52425fd63bad7e138b6cfe4d", + "size": 6627144, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1616443501918, + "type": "app", + "version": "6.3.0" + }, + "notebook-6.3.0-py38h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4b83262cf1d513bc15737635b0414d83", + "name": "notebook", + "sha256": "27f49c6f2afcd3154f395ad316812226601e00287d623af517e49c816c5b3a6e", + "size": 6646142, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1616443517244, + "type": "app", + "version": "6.3.0" + }, + "notebook-6.3.0-py39h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ddd240251ed592b3e0fcfc9b35e539fd", + "name": "notebook", + "sha256": "05a6c92e6ab181c07baa4a59df2ec67bc68da8e971daf002235223e5ee14da05", + "size": 6643024, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1616443164184, + "type": "app", + "version": "6.3.0" + }, + "notebook-6.4.0-py36h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dbbe9df9e3a348d9091ba9b61f1152e1", + "name": "notebook", + "sha256": "a7a1d5d5233f4e176e77ee629382c17359ca628ab82bd84c55fa4b76d72efdcb", + "size": 6627244, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1621523718518, + "type": "app", + "version": "6.4.0" + }, + "notebook-6.4.0-py37h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8cc45b3c4937279d716cad7a28cfa965", + "name": "notebook", + "sha256": "9db4122950072176d173a323fe6eb9af24f2392a42a8b7be90f9a6dbc2460884", + "size": 6649324, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1621523716449, + "type": "app", + "version": "6.4.0" + }, + "notebook-6.4.0-py38h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88313f549e5e58c3ced5a3f7298d7a4a", + "name": "notebook", + "sha256": "a82dbb539d2a6f23a6d689f35857fcb3c62999ceece98a65a2b2d5b6ff98ee08", + "size": 6625671, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1621528398612, + "type": "app", + "version": "6.4.0" + }, + "notebook-6.4.0-py39h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88ed905ea7aa9ab1c59c37348b2fc531", + "name": "notebook", + "sha256": "f83febba90763ceefd795b78684d8b8b40cdf25c87b56a3883e0e0c03442572d", + "size": 6544180, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1621625672341, + "type": "app", + "version": "6.4.0" + }, + "notebook-6.4.1-py36h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "16d1a0ee1ff0888781f52b41a26d7b45", + "name": "notebook", + "sha256": "c33e9d928ae8f3ae42a008609e1a0bdaf166f7b10e8e8c053e6b6847609ae340", + "size": 6727373, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1628267042819, + "type": "app", + "version": "6.4.1" + }, + "notebook-6.4.1-py37h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6b9b0e61c863e61d800c8d11ce078e75", + "name": "notebook", + "sha256": "250a484d06cc74af5d44c575ee179727ea5eca7df781878ad87f9476627fdbf2", + "size": 6727278, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1628267222046, + "type": "app", + "version": "6.4.1" + }, + "notebook-6.4.1-py38h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "08ae052f54ccdda1075a429f7cdd7085", + "name": "notebook", + "sha256": "d2de2f2eae38e0da9a584b0189da90d24f447414ebdef9366819226883135c1d", + "size": 6730624, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1628267163991, + "type": "app", + "version": "6.4.1" + }, + "notebook-6.4.1-py39h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7f5be46fbe49b18679e24e225fed78c1", + "name": "notebook", + "sha256": "220126219550c0058fe8581b9c040d80ebe5e9132a15dc7fef5e10a3ae9682ec", + "size": 6664636, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1628267106277, + "type": "app", + "version": "6.4.1" + }, + "notebook-6.4.11-py310h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "14b9587d01be64c2493df5aea31a57dd", + "name": "notebook", + "sha256": "d4cb58eda4302e4e18863fd3aef6f2584748384381e66330e551a239b60ce60c", + "size": 6892256, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1651734648785, + "type": "app", + "version": "6.4.11" + }, + "notebook-6.4.11-py37h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ad108bcb80003328766a347c4d00096b", + "name": "notebook", + "sha256": "e283b95ca28d9c0a8976d03865069998186eaf9ba72cfe55e84b383329130c61", + "size": 6915441, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1651734579793, + "type": "app", + "version": "6.4.11" + }, + "notebook-6.4.11-py38h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7a4c77d281c1411f97efc940f871879f", + "name": "notebook", + "sha256": "c19786f5fe25d8d8981177339c62d802d4b206fe5b119cce22e91f5b794c7875", + "size": 6890246, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1651734703901, + "type": "app", + "version": "6.4.11" + }, + "notebook-6.4.11-py39h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ce51f8b65f7b129d6c2c6a2e1c9d4be0", + "name": "notebook", + "sha256": "dfd48ba2aec16e300ac3afa2f81430b23bb1c8b6a65c49ae2418101e58981ba2", + "size": 6868042, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1651734760641, + "type": "app", + "version": "6.4.11" + }, + "notebook-6.4.12-py310h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1ca30f163ebf2fa6a3e3aabc2111bd6e", + "name": "notebook", + "sha256": "cd4d46b95c1b2897a21aa6ba68f3c8a9dbac86051aebb375b9d7aff677c60ca8", + "size": 6891380, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1659083858285, + "type": "app", + "version": "6.4.12" + }, + "notebook-6.4.12-py37h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "45713507b25167b84cb36f3bb6fcb07a", + "name": "notebook", + "sha256": "62d5be685467d0ff9873637f0431dd4c7bf23fc8cc54f80d2ef554b22a1b1574", + "size": 6899080, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1659083924293, + "type": "app", + "version": "6.4.12" + }, + "notebook-6.4.12-py38h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "de82e922cdf8de8831595a72cb2e72a9", + "name": "notebook", + "sha256": "6e17e612b55cfdd6f09824262736c9d268617c6bebaaf06f7d53cc5ebcdf82cd", + "size": 6900423, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1659083709869, + "type": "app", + "version": "6.4.12" + }, + "notebook-6.4.12-py39h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8ac395adddf117d61eb09d929e0f7921", + "name": "notebook", + "sha256": "c11f6a7bd1a55f0b203b1f311b40013ce0478214f4dfdeb9313c89e12811e1f8", + "size": 6912826, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1659083778795, + "type": "app", + "version": "6.4.12" + }, + "notebook-6.4.2-py36h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f6fd3dd90b5a6ff5c848a50a9a5398cd", + "name": "notebook", + "sha256": "2aba48b10b8f6467fa84f0d113bcba46b1a603766603a8daa1086cf2eef26510", + "size": 6716328, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1628508027496, + "type": "app", + "version": "6.4.2" + }, + "notebook-6.4.2-py37h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e21f4e9ef567dbfee8224467e4c3a9d5", + "name": "notebook", + "sha256": "616ab5ceb14bf17e690c4ebdeee748402f39fd90efe123a309547531ea48d63c", + "size": 6770668, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1628515884642, + "type": "app", + "version": "6.4.2" + }, + "notebook-6.4.2-py38h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "295819641a53c2135f14bfa6747245dd", + "name": "notebook", + "sha256": "9e3b794422d41f8cc17bc4ec1383728a5999f88bc80198d839d836044db26e3d", + "size": 6753740, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1628516219137, + "type": "app", + "version": "6.4.2" + }, + "notebook-6.4.2-py39h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7cc56c9891667230f4012040352ae729", + "name": "notebook", + "sha256": "6478e8bb1d0de99f7750bacaaa94144776d9424a1683812e746f2f0b2dd2d288", + "size": 6752004, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1628516219423, + "type": "app", + "version": "6.4.2" + }, + "notebook-6.4.3-py36h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0be9854f2bcacc244335c1b6f36025be", + "name": "notebook", + "sha256": "e13f58d5c7243475b147ee470c3c08e73d9f3f38ee61f6c744e57bfea1951837", + "size": 6811916, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1629197269593, + "type": "app", + "version": "6.4.3" + }, + "notebook-6.4.3-py37h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "74d46a7b62ba0c1690f9bc072c83ebab", + "name": "notebook", + "sha256": "50ee3a235936df2f70d4b698ca738b79e205d328a39ac3fc23fcb491ba8bb9dc", + "size": 6909880, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1629205813957, + "type": "app", + "version": "6.4.3" + }, + "notebook-6.4.3-py38h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bc75e4170664c528c0feacc2e681bad2", + "name": "notebook", + "sha256": "118afdc96d0a9c09c56f8b68f8196858da60d713cf35a93b58c5a20466209fa2", + "size": 6852190, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1629205645590, + "type": "app", + "version": "6.4.3" + }, + "notebook-6.4.3-py39h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b5055abe2bb97b009ae70f9888f03549", + "name": "notebook", + "sha256": "0e73e591a8ef62abe131b7fd222f2800cd89e28e2010c283c086496c16a72ee1", + "size": 6873467, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1629205814578, + "type": "app", + "version": "6.4.3" + }, + "notebook-6.4.5-py37h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8494ccda9d1cd88f212609681d2699fc", + "name": "notebook", + "sha256": "8f6498eb55bb33cb5e88767f86309c5b4cfc6669f81248682a52049cf584d0f3", + "size": 6857757, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1635411689698, + "type": "app", + "version": "6.4.5" + }, + "notebook-6.4.5-py38h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8727940130b090ad45c4360b9503479f", + "name": "notebook", + "sha256": "e8d3d79310dad9dfc105217f23ccba2c8d5fe83514fc698f37ab664a672750ea", + "size": 6890089, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1635411683662, + "type": "app", + "version": "6.4.5" + }, + "notebook-6.4.5-py39h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f5e62f8a25141f921b7dd89d1b62ed58", + "name": "notebook", + "sha256": "e2cf53518dc90d5c6cdd841f53277b46dfec76969a11aabb11de2c9ee7388176", + "size": 6849232, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1635411690469, + "type": "app", + "version": "6.4.5" + }, + "notebook-6.4.6-py310h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bc9bad28df19a90ba4743fbda4853097", + "name": "notebook", + "sha256": "21b95bcb9942560344bab1b53162911080bfa642e0e40144f506d23cd2460192", + "size": 6793652, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1641917356276, + "type": "app", + "version": "6.4.6" + }, + "notebook-6.4.6-py37h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "87797f73e11ea31ffc46092a80766829", + "name": "notebook", + "sha256": "06a2bc83df7a73919e5ca49230f2be953eacc9011d4f7546e24e545614dbf0f8", + "size": 6878714, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1637161817007, + "type": "app", + "version": "6.4.6" + }, + "notebook-6.4.6-py38h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0dab15d92547859a60c7b074a76079ae", + "name": "notebook", + "sha256": "5a65c4be18dfdc5ae82c7482c4e5443bc422731616383f7e1e40f6bce9a1e68e", + "size": 6878621, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1637161821073, + "type": "app", + "version": "6.4.6" + }, + "notebook-6.4.6-py39h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f244b252377f96d29e8debe99b228852", + "name": "notebook", + "sha256": "9186aeaba587629f12104ee55c6af367f5a9ff671112b38d8c295ef1991321aa", + "size": 6882501, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1637161803717, + "type": "app", + "version": "6.4.6" + }, + "notebook-6.4.8-py310h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "389eb4e739e1dee2b138085e6c34e2f1", + "name": "notebook", + "sha256": "e9025085fa3631edf3b0dc55bee788f2197f912c07ac3f52a3848d3ed963335c", + "size": 6891288, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1645002596662, + "type": "app", + "version": "6.4.8" + }, + "notebook-6.4.8-py37h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c507c5e7c0196e854009ee3314d61dbe", + "name": "notebook", + "sha256": "60334a770dd4c927264b9534b7a48946b1a246e887ae4e0f46d86553609ba53d", + "size": 6860848, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1644986026092, + "type": "app", + "version": "6.4.8" + }, + "notebook-6.4.8-py38h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7670e8d119deb1eb015ef91684c4aed9", + "name": "notebook", + "sha256": "60251a6f00417490b19fa0cdf10819a02dd906fd003125a42c3cee49407822b0", + "size": 6895226, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1645002581081, + "type": "app", + "version": "6.4.8" + }, + "notebook-6.4.8-py39h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "98769f0900457d6c09f8828b7cf50a7f", + "name": "notebook", + "sha256": "1cf5547f8b51222b10e92874c0a2bca400b42a2bb53712cd423dc3e428fd70af", + "size": 6884032, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1645002575385, + "type": "app", + "version": "6.4.8" + }, + "notebook-6.5.2-py310h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbclassic >=0.4.7", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0147480e466cfc8d0ae8f8bec406e735", + "name": "notebook", + "sha256": "47084475f056c1fb9095657de031292297bd6d12bbeebf9cf78ac23253e9b8e6", + "size": 528015, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1668179999416, + "type": "app", + "version": "6.5.2" + }, + "notebook-6.5.2-py311h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbclassic >=0.4.7", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f2e206015798641a4857d6105d1b43e3", + "name": "notebook", + "sha256": "e05365a37ececc6a7d175c25e905a365e80264687876de7903e8d461d15311c4", + "size": 668274, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1676918975856, + "type": "app", + "version": "6.5.2" + }, + "notebook-6.5.2-py37h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbclassic >=0.4.7", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "df7e35eb6bfa6ffe60068e2bbb708d1b", + "name": "notebook", + "sha256": "6e52bee5b8f91944ff6c955993464871d51de0df02271630e1616bf92cfd2482", + "size": 522933, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1668179939557, + "type": "app", + "version": "6.5.2" + }, + "notebook-6.5.2-py38h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbclassic >=0.4.7", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "08cbbc921d4d53255deb99aa479769c4", + "name": "notebook", + "sha256": "85d3f5d41fee43cdeaab97b31e92fdedb5994c15fc9345bb0623b9e8709cd10b", + "size": 523338, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1668180059918, + "type": "app", + "version": "6.5.2" + }, + "notebook-6.5.2-py39h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbclassic >=0.4.7", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8281e36033cdf8417d49af27f0878895", + "name": "notebook", + "sha256": "2450e0c106fce4b926d038f5a6a29621bc2593c7888bf77ae627476fdc12e1c9", + "size": 523970, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1668180119805, + "type": "app", + "version": "6.5.2" + }, + "notebook-6.5.3-py310h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbclassic >=0.4.7", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "37a24d5b99be3f266c3735cca80853de", + "name": "notebook", + "sha256": "f5632471e358a59f4770fe690fb7a8f1580f39828b9b7801b140a2b5cc05f8df", + "size": 606700, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1680012183396, + "type": "app", + "version": "6.5.3" + }, + "notebook-6.5.3-py311h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbclassic >=0.4.7", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6543c92edbf10a0eb21a1359d02d9a4c", + "name": "notebook", + "sha256": "5cd55cb634439a69dd7c56901329b60b9c1bf6bc9cb38744734c5f729d89394d", + "size": 722422, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1680012055601, + "type": "app", + "version": "6.5.3" + }, + "notebook-6.5.3-py38h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbclassic >=0.4.7", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6ecb12aed3b6f7d4fd705096e8cd1ae8", + "name": "notebook", + "sha256": "4653acca2370a0629d28e488c3bd0dcae3a2d90110a808da24a1c83decb10caf", + "size": 601543, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1680012119058, + "type": "app", + "version": "6.5.3" + }, + "notebook-6.5.3-py39h06a4308_0.tar.bz2": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbclassic >=0.4.7", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4b185dc2b28b67c3185e7e400596b896", + "name": "notebook", + "sha256": "e4cd163b00d46c7bfe96e589bf3c396c0070ecb4effa475b59190c08e42a3165", + "size": 602839, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1680012246096, + "type": "app", + "version": "6.5.3" + }, + "notebook-shim-0.2.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_server >=1.8,<3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "133b837755ea8399962afb015afb561f", + "name": "notebook-shim", + "sha256": "048da58667248b6ccc7f4d9977466081e8bbf7f831abe9a922e2fe9740f8d1e3", + "size": 21992, + "subdir": "linux-64", + "timestamp": 1668160675427, + "version": "0.2.2" + }, + "notebook-shim-0.2.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_server >=1.8,<3", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c0cbed59d79e301f904b55e7f8b23353", + "name": "notebook-shim", + "sha256": "a4e5a1d828e8b3e464acce80b237f87d861aa5ebccf31cea9a8068cdeeccd3e2", + "size": 26421, + "subdir": "linux-64", + "timestamp": 1676825066023, + "version": "0.2.2" + }, + "notebook-shim-0.2.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_server >=1.8,<3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "352fa3fdb680fa9da740878d3fac363f", + "name": "notebook-shim", + "sha256": "3f2ebf41f92214b60208a685f0d49faf60996089001faae1fbb573c879e70d4c", + "size": 21938, + "subdir": "linux-64", + "timestamp": 1668160612300, + "version": "0.2.2" + }, + "notebook-shim-0.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_server >=1.8,<3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fd311495d2aca2cb0173cd3f37b36016", + "name": "notebook-shim", + "sha256": "e211f8e0dc8c60827aefd49737a3bcfb52f94acea9c38311d5fd51f3c5d8fe34", + "size": 21957, + "subdir": "linux-64", + "timestamp": 1668160706352, + "version": "0.2.2" + }, + "notebook-shim-0.2.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_server >=1.8,<3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "70db71df4ee1cdd38090c0f7b80ba61f", + "name": "notebook-shim", + "sha256": "c1d8ceadd7700fc60239c2791a8ae746b3c5e37e524e0663e8933fc71dc0d5db", + "size": 21944, + "subdir": "linux-64", + "timestamp": 1668160644514, + "version": "0.2.2" + }, + "nspr-4.22-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MPL 2", + "md5": "d8a32a533a8364f72b2aba61ce0eac8e", + "name": "nspr", + "sha256": "06d64a2331213fdec517f6fd0d8a2df999f516a3c4d135d94a31d2409b02f01d", + "size": 1713718, + "subdir": "linux-64", + "timestamp": 1588087601204, + "version": "4.22" + }, + "nspr-4.28-hdbfa776_0.tar.bz2": { + "build": "hdbfa776_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MPL-2.0", + "md5": "159588cbcb664a5f5b9b12c64811a79b", + "name": "nspr", + "sha256": "cebe8869a759f6ae233bd0d4e007ad6b24233ce07b77dd0631cf4707de78373a", + "size": 241457, + "subdir": "linux-64", + "timestamp": 1636044936217, + "version": "4.28" + }, + "nspr-4.33-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MPL-2.0", + "license_family": "OTHER", + "md5": "28808460055d2c42c58edd8639ce530c", + "name": "nspr", + "sha256": "f395b5f93de97cad3bb969e8d7f3d20d005a0d6f68295d203d5a71b775aa98ca", + "size": 236852, + "subdir": "linux-64", + "timestamp": 1643617339565, + "version": "4.33" + }, + "nss-3.46.1-hab99668_0.tar.bz2": { + "build": "hab99668_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nspr >=4.22,<5.0a0", + "sqlite >=3.31.1,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MPL 2", + "md5": "a7f2443b58fbec044e46ab91863be9bd", + "name": "nss", + "sha256": "203f64927df5f6c411c26b04516b39075188450f9277a2f8aedc4eb9b1ae254b", + "size": 1943688, + "subdir": "linux-64", + "timestamp": 1588094503330, + "version": "3.46.1" + }, + "nss-3.56-h5657611_0.tar.bz2": { + "build": "h5657611_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "nspr >=4.27", + "sqlite >=3.36.0,<4.0a0", + "zlib" + ], + "license": "MPL 2", + "md5": "b25c4b2296924d968ddb4f5c53cafd53", + "name": "nss", + "sha256": "f150142694e916cdbcee7a5c1b74a5d0b45399728ac93549ac7ad6ae145ebeeb", + "size": 2202865, + "subdir": "linux-64", + "timestamp": 1636111922987, + "version": "3.56" + }, + "nss-3.74-h0370c37_0.tar.bz2": { + "build": "h0370c37_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "nspr >=4.33,<5", + "nspr >=4.33,<5.0a0", + "sqlite >=3.37.0,<4.0a0" + ], + "license": "MPL-2.0", + "license_family": "OTHER", + "md5": "dae15373190aa3fe1a52b9f5c5846151", + "name": "nss", + "sha256": "8db7cbf84fcc743a929c8c3ff6f3e3731c56d72076ea4801158be6eb70983cec", + "size": 2226357, + "subdir": "linux-64", + "timestamp": 1644222015064, + "version": "3.74" + }, + "nsync-1.24.0-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "538c38703ef061e62ee26e8e44c560fb", + "name": "nsync", + "sha256": "5710ae43c1bd834838a0659fdcd2bef6696f90933cb1a02d3deb90804f4516b6", + "size": 50966, + "subdir": "linux-64", + "timestamp": 1622094522407, + "version": "1.24.0" + }, + "numba-0.35.0-np113py27_10.tar.bz2": { + "build": "np113py27_10", + "build_number": 10, + "depends": [ + "funcsigs", + "llvmlite 0.20.*", + "numpy 1.13*", + "python 2.7*", + "singledispatch" + ], + "license": "BSD", + "md5": "f30a707bc104f61a35d8536c380ff81d", + "name": "numba", + "sha256": "fb2acd884780e636944ce555eb0c5d3ec4f579a0e5136d50edf7754e04277e9b", + "size": 2678716, + "subdir": "linux-64", + "version": "0.35.0" + }, + "numba-0.35.0-np113py35_10.tar.bz2": { + "build": "np113py35_10", + "build_number": 10, + "depends": [ + "llvmlite 0.20.*", + "numpy 1.13*", + "python 3.5*" + ], + "license": "BSD", + "md5": "169eb5fd815e7ec20c1a7cc7bc94f8a1", + "name": "numba", + "sha256": "03af8c98e6c7b317ffb176dbf857406fff9e14994c98bfaa990960e875a59d05", + "size": 2712980, + "subdir": "linux-64", + "version": "0.35.0" + }, + "numba-0.35.0-np113py36_10.tar.bz2": { + "build": "np113py36_10", + "build_number": 10, + "depends": [ + "llvmlite 0.20.*", + "numpy 1.13*", + "python 3.6*" + ], + "license": "BSD", + "md5": "2f2bfb4d47243bf51d9e98f27feb00ae", + "name": "numba", + "sha256": "d64a3eedb07f3af00eb748efb480624724144b95e62af033c478eb509dd38900", + "size": 2695949, + "subdir": "linux-64", + "version": "0.35.0" + }, + "numba-0.36.1-np110py27h97c9c31_0.tar.bz2": { + "build": "np110py27h97c9c31_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.10,<1.11.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "d5bc91cb8d6c009d9e18747d1426cffc", + "name": "numba", + "sha256": "e56c8481b61c039b7eee62bf2e2ded7d966020bf573216b2be5cbb2592690c19", + "size": 2351968, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np110py35heb30733_0.tar.bz2": { + "build": "np110py35heb30733_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.10,<1.11.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "4d961eb375812fff91d7a248913e00b8", + "name": "numba", + "sha256": "a3cd28b98fed0d230eef1688363af199e9d309456760229b9fab6db030b686da", + "size": 2422987, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np111py27h2ed7fd9_0.tar.bz2": { + "build": "np111py27h2ed7fd9_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.11,<1.12.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "2062d649b7395191ae3797443aa82d9e", + "name": "numba", + "sha256": "c7ca59ae320338c107bdd0e3657ce56a430ac3c189596649804a52cd0bc07f7c", + "size": 2353727, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np111py35h3a0790d_0.tar.bz2": { + "build": "np111py35h3a0790d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.11,<1.12.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "a7e2bf4b896722ef2e5876aabc9b2235", + "name": "numba", + "sha256": "8b1eb8fdd71ad7a486d91f899a1d3a923b2330a8f5aa73661ad9f37e9091f5a8", + "size": 2424011, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np111py36h9f231e2_0.tar.bz2": { + "build": "np111py36h9f231e2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.11,<1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "7777b26baff48e7aaf8beff6e69a78e2", + "name": "numba", + "sha256": "7413f714164be937c25777c02b37b43d5bc30ff14dd615a2cec732a2400239c1", + "size": 2406921, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np112py27h00f7d58_0.tar.bz2": { + "build": "np112py27h00f7d58_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.12,<1.13.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "b0018a4e705a402e1c38a1260c313360", + "name": "numba", + "sha256": "f4ba856226a24f362240d690d54df67fb6f3e61b0ddef35e5b7158644cdf5864", + "size": 2345997, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np112py35he47b545_0.tar.bz2": { + "build": "np112py35he47b545_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.12,<1.13.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "5ec802fd4de47afa146a038d630b03a7", + "name": "numba", + "sha256": "1cf58f31999b049c39af924b3f3d7c2982d07a2995e9e721dd55dfa81cab265a", + "size": 2413814, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np112py36hf993da8_0.tar.bz2": { + "build": "np112py36hf993da8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.12,<1.13.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "282fc728252932184299afcb6f6e526f", + "name": "numba", + "sha256": "5a9b501949d86fdb596498877028d89279ca0c3083e49ede3225569f549b3ff9", + "size": 2397963, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np113py27hee5a248_0.tar.bz2": { + "build": "np113py27hee5a248_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.13,<1.14.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "ed10b68f005c6fced454667581ddbeba", + "name": "numba", + "sha256": "de1a9e2176e773f19d2e79ef004541896b3681c929a5e005750450986689b96f", + "size": 2345748, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np113py35hf1afa12_0.tar.bz2": { + "build": "np113py35hf1afa12_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.13,<1.14.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "9f4f923b43d559b45fd66797b2294f5c", + "name": "numba", + "sha256": "8168b8b97c028c97d77457f600b5876734a183a5be422dc82b26d38c203ae13d", + "size": 2414300, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np113py36hd14f252_0.tar.bz2": { + "build": "np113py36hd14f252_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.13,<1.14.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "ddccaf401fa285e294cb7ff67b23089b", + "name": "numba", + "sha256": "ecafe80e4470cd9e7963dc46c0995b8488275c3dfbbcad2da6e0e47cfa5c47cf", + "size": 2397940, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.2-np110py27h2a5c770_0.tar.bz2": { + "build": "np110py27h2a5c770_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.10,<1.11.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "3e3587fd6480566086e9d9c4a8d3e6d9", + "name": "numba", + "sha256": "6201e82707bf849e49a88dddb70d2ed4cba38a9dc08f8ae67717b59a783f1782", + "size": 2352338, + "subdir": "linux-64", + "timestamp": 1513741177911, + "version": "0.36.2" + }, + "numba-0.36.2-np110py35ha5fb34f_0.tar.bz2": { + "build": "np110py35ha5fb34f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.10,<1.11.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "0a986e2f18ade13d22e05ad5af80d25a", + "name": "numba", + "sha256": "4803836718e257c4d9d66c1a736320caf665b3e7dd8b52da21ae7d7d15ee0974", + "size": 2423501, + "subdir": "linux-64", + "timestamp": 1513737650048, + "version": "0.36.2" + }, + "numba-0.36.2-np111py27haafad4c_0.tar.bz2": { + "build": "np111py27haafad4c_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.11,<1.12.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "06adb84fa395905d1975a1ebc6495c35", + "name": "numba", + "sha256": "75af329e3790eaa900a64d20a9ce0cd7944d820e35bd1fc9cb8b38cefc75685e", + "size": 2353899, + "subdir": "linux-64", + "timestamp": 1513738106712, + "version": "0.36.2" + }, + "numba-0.36.2-np111py35h14f0b80_0.tar.bz2": { + "build": "np111py35h14f0b80_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.11,<1.12.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "306a0b1f0a1af2ea442d0fc87bbd4c72", + "name": "numba", + "sha256": "fd5dcfb5f35a8ff8650ce860bc134545c4ba6e4a0041cd1a45bf168989df4724", + "size": 2425837, + "subdir": "linux-64", + "timestamp": 1513738954723, + "version": "0.36.2" + }, + "numba-0.36.2-np111py36h12fd6ba_0.tar.bz2": { + "build": "np111py36h12fd6ba_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.11,<1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "e97cd8e6bb98aca93f6b474965cf5673", + "name": "numba", + "sha256": "23b9a8825e3c17873acfb0f57bafb2e8ffa2340fdc183356bf1143dcdeaba3fc", + "size": 2406106, + "subdir": "linux-64", + "timestamp": 1513739359054, + "version": "0.36.2" + }, + "numba-0.36.2-np112py27h603bb47_0.tar.bz2": { + "build": "np112py27h603bb47_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.12,<1.13.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "b1605ab4836f6679252d723aa4caa09e", + "name": "numba", + "sha256": "b3720ec1cdd9c8b8d905bc36348257b1cbe3b33f0ebf4f93237287cc2a1031d8", + "size": 2345799, + "subdir": "linux-64", + "timestamp": 1513739762361, + "version": "0.36.2" + }, + "numba-0.36.2-np112py35h68e262a_0.tar.bz2": { + "build": "np112py35h68e262a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.12,<1.13.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "8fce2a3d6478a39cf1f1b259619c1240", + "name": "numba", + "sha256": "a9bd900b28538353c1405efb069c3d37b2cb04470db7e86c0a23fbc4bbeaa5bc", + "size": 2414971, + "subdir": "linux-64", + "timestamp": 1513740751985, + "version": "0.36.2" + }, + "numba-0.36.2-np112py36hbcd2105_0.tar.bz2": { + "build": "np112py36hbcd2105_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.12,<1.13.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "9bba52a37d55646c88389e090988b7ea", + "name": "numba", + "sha256": "5c553f3319419ec97a834fb4064918c5a68048abdc33236f9fb31fa20de3ff35", + "size": 2395217, + "subdir": "linux-64", + "timestamp": 1513740272851, + "version": "0.36.2" + }, + "numba-0.36.2-np113py27h0c80d70_0.tar.bz2": { + "build": "np113py27h0c80d70_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.13,<1.14.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "a6d97d8c8c4469780c56d789614a516e", + "name": "numba", + "sha256": "a04763bfc793f6f1762e18ccfeaa76a3d5852a1f59beecef10db74ec3982b5dc", + "size": 2346145, + "subdir": "linux-64", + "timestamp": 1513738503816, + "version": "0.36.2" + }, + "numba-0.36.2-np113py35ha7cad2d_0.tar.bz2": { + "build": "np113py35ha7cad2d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.13,<1.14.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "3872fe4a8f9b725285e2d42daf4f4aa2", + "name": "numba", + "sha256": "067919ecb6403b731831734b734d702fa99c543990a1ddb8cda37b0629a70391", + "size": 2413998, + "subdir": "linux-64", + "timestamp": 1513742028593, + "version": "0.36.2" + }, + "numba-0.36.2-np113py36h7a10136_0.tar.bz2": { + "build": "np113py36h7a10136_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.13,<1.14.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "64976c0bb164dfa676502012aaf4fbd5", + "name": "numba", + "sha256": "f87e739c981320437a8213ed57d6527cad883d85bfdc438360a4eb0cc6d84023", + "size": 2395600, + "subdir": "linux-64", + "timestamp": 1513741603471, + "version": "0.36.2" + }, + "numba-0.36.2-np114py27he2868da_0.tar.bz2": { + "build": "np114py27he2868da_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.14,<1.15.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "d405c0284bb435cd08449b318da255b4", + "name": "numba", + "sha256": "9f9906168317269ab3db2061f705abcd12b48170caeb5c2f38ca82c38ca81086", + "size": 2345165, + "subdir": "linux-64", + "timestamp": 1517878246171, + "version": "0.36.2" + }, + "numba-0.36.2-np114py35ha126a20_0.tar.bz2": { + "build": "np114py35ha126a20_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.14,<1.15.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "e3fcd8a3489df2b2be0da4f0f8ca9e87", + "name": "numba", + "sha256": "161152781e7c0a4df08c226a0d2887d075f465d31ac63c25bb8dec8ee04d74be", + "size": 2415442, + "subdir": "linux-64", + "timestamp": 1517878654303, + "version": "0.36.2" + }, + "numba-0.36.2-np114py36hc6662d5_0.tar.bz2": { + "build": "np114py36hc6662d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.14,<1.15.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "503ed1ef728cf0d6fbc973e51543d6c4", + "name": "numba", + "sha256": "da6c0d21e6b3b4a297f565a4a3aa9cf63cacd932bfddc81ec17791dbb4246bf6", + "size": 2396283, + "subdir": "linux-64", + "timestamp": 1517879065668, + "version": "0.36.2" + }, + "numba-0.37.0-np110py27h105fbcc_0.tar.bz2": { + "build": "np110py27h105fbcc_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.10,<1.11.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "651bc55e8cbd3def6e2a0e5e9ff65ad2", + "name": "numba", + "sha256": "ed9f7899f3318fdeb2ccc65ecc89b76bdf2df1d976531fd626070a1ff6d11b20", + "size": 2393795, + "subdir": "linux-64", + "timestamp": 1518740978913, + "version": "0.37.0" + }, + "numba-0.37.0-np110py35h8b0d19d_0.tar.bz2": { + "build": "np110py35h8b0d19d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.10,<1.11.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "0ca1a49906f3ea50c760b952a2d5287c", + "name": "numba", + "sha256": "f72847d2b8e9c1cf366e67b340e8109998ade48f2b14cb37cc214cbfa771b6db", + "size": 2458807, + "subdir": "linux-64", + "timestamp": 1518738883168, + "version": "0.37.0" + }, + "numba-0.37.0-np111py27h2eedcfd_0.tar.bz2": { + "build": "np111py27h2eedcfd_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.11,<1.12.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "96da65fdc878c6b0086d1030a89d2e86", + "name": "numba", + "sha256": "b4c504cfdbea010579cd803769f539bd2d38bbaf36e79c7428542ed95d5aa026", + "size": 2394977, + "subdir": "linux-64", + "timestamp": 1518739770121, + "version": "0.37.0" + }, + "numba-0.37.0-np111py35h3e3e0ff_0.tar.bz2": { + "build": "np111py35h3e3e0ff_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.11,<1.12.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "08650377eae15288373ab316b8f941b4", + "name": "numba", + "sha256": "7e2ceb375e1e5fbd63192c7725baedfa15ce73b5d173a55d1d7270a601ac9edf", + "size": 2458482, + "subdir": "linux-64", + "timestamp": 1518737654461, + "version": "0.37.0" + }, + "numba-0.37.0-np111py36h8336faa_0.tar.bz2": { + "build": "np111py36h8336faa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.11,<1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "c91fd8065df5f661bd0c17011acfc298", + "name": "numba", + "sha256": "94d2b48fc920d03bdf8a7a5cf4ef2796be3eeb4dbdff79a83d29eca061ee1641", + "size": 2432482, + "subdir": "linux-64", + "timestamp": 1518740594772, + "version": "0.37.0" + }, + "numba-0.37.0-np112py27h96054c9_0.tar.bz2": { + "build": "np112py27h96054c9_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.12,<1.13.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "e13efedbb9adfdbba9a1fadb8a3af409", + "name": "numba", + "sha256": "1c551c63ca6753a07636b7da485686d485ca37632644ef202a79dbd272b261f6", + "size": 2385206, + "subdir": "linux-64", + "timestamp": 1518739289171, + "version": "0.37.0" + }, + "numba-0.37.0-np112py35h0b3d877_0.tar.bz2": { + "build": "np112py35h0b3d877_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.12,<1.13.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "dff0c1d445af4a832be971c3447ec108", + "name": "numba", + "sha256": "279dbb0bc8bdb0d27c46091c5b55d6278f34a0253d19a47107169ee5a6de1e69", + "size": 2450135, + "subdir": "linux-64", + "timestamp": 1518742332942, + "version": "0.37.0" + }, + "numba-0.37.0-np112py36ha11926f_0.tar.bz2": { + "build": "np112py36ha11926f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.12,<1.13.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "3188d3dfb117db546b5ee087031278fa", + "name": "numba", + "sha256": "c1e065dad02dc5e24fa00534fa23a2c1114dcd349ff2475311ed7be1328f3cb9", + "size": 2422611, + "subdir": "linux-64", + "timestamp": 1518738060388, + "version": "0.37.0" + }, + "numba-0.37.0-np113py27h18d2f7f_0.tar.bz2": { + "build": "np113py27h18d2f7f_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.13,<1.14.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "82a86b006b0d4b2810d860780ea252cf", + "name": "numba", + "sha256": "5ce3ba57db58cd3096032edc7a5844c0d586390079873195ddb226f5b6385ca5", + "size": 2385589, + "subdir": "linux-64", + "timestamp": 1518740174292, + "version": "0.37.0" + }, + "numba-0.37.0-np113py35h384d3fa_0.tar.bz2": { + "build": "np113py35h384d3fa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.13,<1.14.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "5c81f14a2b7a18e4be1316d672884f98", + "name": "numba", + "sha256": "0e1c4db722ba168ea1dad67d87a9627c9600420a9efa875cb467fc9cdf3f560b", + "size": 2450035, + "subdir": "linux-64", + "timestamp": 1518741405170, + "version": "0.37.0" + }, + "numba-0.37.0-np113py36ha6e7140_0.tar.bz2": { + "build": "np113py36ha6e7140_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.13,<1.14.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "219302e69f4ff43178e7ce8717afaaf2", + "name": "numba", + "sha256": "9ab181192da305ba18e8e5cd57c48e9a93069f979a24e768852fe864d78fb533", + "size": 2423963, + "subdir": "linux-64", + "timestamp": 1518738477658, + "version": "0.37.0" + }, + "numba-0.37.0-np114py27h76b0b06_0.tar.bz2": { + "build": "np114py27h76b0b06_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.14,<1.15.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "1f03df822cc11165aef50085adbe31bf", + "name": "numba", + "sha256": "9df32dd59ea8464af451879842d77f76031bbad3bb4f6c1c4d7f8731b1ebcf89", + "size": 2385403, + "subdir": "linux-64", + "timestamp": 1518736712175, + "version": "0.37.0" + }, + "numba-0.37.0-np114py35h095f75c_0.tar.bz2": { + "build": "np114py35h095f75c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.14,<1.15.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "9060ea13d8f57130078a82bfa0442d24", + "name": "numba", + "sha256": "18925a80fa6758b9581806727d291560e9f70502a0cc270e90427ef7f221b38a", + "size": 2450027, + "subdir": "linux-64", + "timestamp": 1518737209155, + "version": "0.37.0" + }, + "numba-0.37.0-np114py36h5fcf951_0.tar.bz2": { + "build": "np114py36h5fcf951_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.14,<1.15.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "8402080a6f8a1571bbf380be9301c08c", + "name": "numba", + "sha256": "77b38ebd83600f72b8cda886051ae9d9966a9a3cde891cf2ea5c523ed042b0ea", + "size": 2423697, + "subdir": "linux-64", + "timestamp": 1518741861173, + "version": "0.37.0" + }, + "numba-0.38.0-py27h637b7d7_0.tar.bz2": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.23.*", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "53ac2cfdfe1e3ce6631e665a1b4989a9", + "name": "numba", + "sha256": "cb96bc002f5f86d707ba3a68ca8b3c612f8cfcb00208c56d715e936f6db25ddd", + "size": 2449316, + "subdir": "linux-64", + "timestamp": 1526595523754, + "version": "0.38.0" + }, + "numba-0.38.0-py35h637b7d7_0.tar.bz2": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.23.*", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "8b9e96c9b61c7937b8212e6b0d7b00c1", + "name": "numba", + "sha256": "8ce146fc585293f88803ce003f8a9b9d1f8d383f128c1d667369216508782ab0", + "size": 2515457, + "subdir": "linux-64", + "timestamp": 1526595571925, + "version": "0.38.0" + }, + "numba-0.38.0-py36h637b7d7_0.tar.bz2": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.23.*", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "a559cc67cc6fb58b28306f23cace3ff6", + "name": "numba", + "sha256": "f97777b15c1038bde65046653ca1c6336f34f33da940bd050d0743de0e1d2a0b", + "size": 2500016, + "subdir": "linux-64", + "timestamp": 1526595228660, + "version": "0.38.0" + }, + "numba-0.38.1-py27h04863e7_0.tar.bz2": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.23.*", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "8d65edc0d472e4eeb3c4426025092c82", + "name": "numba", + "sha256": "a2a5e441944b05796715b28df0a8f22d95b4defb58631049ff622767829d855c", + "size": 2450672, + "subdir": "linux-64", + "timestamp": 1529658599982, + "version": "0.38.1" + }, + "numba-0.38.1-py35h04863e7_0.tar.bz2": { + "build": "py35h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.23.*", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "00b4420ebdd79757411f955423b976b6", + "name": "numba", + "sha256": "b81725e2af451d10f120676951ad1df628b0a2ef231158b374b27ce7c530f3df", + "size": 2518551, + "subdir": "linux-64", + "timestamp": 1529658623288, + "version": "0.38.1" + }, + "numba-0.38.1-py36h04863e7_0.tar.bz2": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.23.*", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "521bfde2afe0b1e5cbd91c0a23132822", + "name": "numba", + "sha256": "80689b15c17065f285ae7f105a16231903616d48820169787471a8640d5d5ce7", + "size": 2502149, + "subdir": "linux-64", + "timestamp": 1529658561894, + "version": "0.38.1" + }, + "numba-0.39.0-py27h04863e7_0.tar.bz2": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.24.*", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "d3034ff8875e8499daea6dda2f778caa", + "name": "numba", + "sha256": "dab0ee488e15a813515e178492c669b0f6eedd1ae4d4d4854950a42bcd407902", + "size": 2481068, + "subdir": "linux-64", + "timestamp": 1531257034346, + "version": "0.39.0" + }, + "numba-0.39.0-py35h04863e7_0.tar.bz2": { + "build": "py35h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite 0.24.*", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "527efeaa90ab5491fe663fda22d502db", + "name": "numba", + "sha256": "5b5371d5c28a9c87ec080cc45f633710da14517c06f253149803c5cdaf870448", + "size": 2551858, + "subdir": "linux-64", + "timestamp": 1534899392490, + "version": "0.39.0" + }, + "numba-0.39.0-py36h04863e7_0.tar.bz2": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.24.*", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "4446ad4f0d2cce2b898c74032d68c2cd", + "name": "numba", + "sha256": "b77b5bf41a0a3b51b92e46ffd28d7c8d221f5150dfbe7fbe13d807dc9b0cb9be", + "size": 2528123, + "subdir": "linux-64", + "timestamp": 1531257503034, + "version": "0.39.0" + }, + "numba-0.39.0-py37h04863e7_0.tar.bz2": { + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.24.*", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "331b4b028272e6646a53e6bddbbb64e1", + "name": "numba", + "sha256": "23cb68ed001e2e5501b6cc11dabc13d928be26f6abee14ce66bfffc9ead72f40", + "size": 2523749, + "subdir": "linux-64", + "timestamp": 1531258379379, + "version": "0.39.0" + }, + "numba-0.40.0-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.25.0,<0.26.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "bf9629eee3aa831d381fb0a203155da6", + "name": "numba", + "sha256": "33d0c266e6c61af1de82001f61737aa9c0c717321a02969deca12beebe9c44c7", + "size": 2751827, + "subdir": "linux-64", + "timestamp": 1538621953011, + "version": "0.40.0" + }, + "numba-0.40.0-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.25.0,<0.26.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "88f35ffded17fa718a0a665eb6625c36", + "name": "numba", + "sha256": "1115412f7cbe74a29b17a9b6484178bf78fc4a31bf8b09f61b950c47550d667c", + "size": 2816596, + "subdir": "linux-64", + "timestamp": 1538622249475, + "version": "0.40.0" + }, + "numba-0.40.0-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.25.0,<0.26.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "abfba06ceb924608df8899e9198d87a0", + "name": "numba", + "sha256": "899fc42b1396a3a29d37891a0f4ffb472ffaf7039f8fe242a906fbd57b6cf26a", + "size": 2815131, + "subdir": "linux-64", + "timestamp": 1538621695236, + "version": "0.40.0" + }, + "numba-0.41.0-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.26.0,<0.27.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.1" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "a57799e581d76797410313eb50a895c2", + "name": "numba", + "sha256": "2612d49461ec40e895585da99da9f4972e4ed6cb84ce95be5e57e6237144142a", + "size": 2730901, + "subdir": "linux-64", + "timestamp": 1543476833072, + "version": "0.41.0" + }, + "numba-0.41.0-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.26.0,<0.27.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.1" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "eba846e4201bef65506a12fecc3c48f6", + "name": "numba", + "sha256": "aa3ff1603944d209a808c3d7621e93e0fbf6fd4e1bf731ccde225f7803fcfa2b", + "size": 2793400, + "subdir": "linux-64", + "timestamp": 1543476762035, + "version": "0.41.0" + }, + "numba-0.41.0-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.26.0,<0.27.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.1" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "a487df1657ea3aa6001702ce475acf69", + "name": "numba", + "sha256": "3acce5b2f47f80e3b94dcdecc0a70b531cc46ca3217e04cd3e6e57b394c99f32", + "size": 2800272, + "subdir": "linux-64", + "timestamp": 1543488987403, + "version": "0.41.0" + }, + "numba-0.42.0-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.27.0,<0.28.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.1" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "b6b266723c47a8eff8887ace2ada4187", + "name": "numba", + "sha256": "8712d032cb51f2d914cd8518b48eaa6b180fc84c882079f1130a964e28b2239a", + "size": 2762327, + "subdir": "linux-64", + "timestamp": 1546601698419, + "version": "0.42.0" + }, + "numba-0.42.0-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.27.0,<0.28.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.1" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "f242f6dfdbbb3c039dc7a83a89f92f34", + "name": "numba", + "sha256": "5fa614a99deb6e02b2e649191a3fc6d01b6be503c560f705e011b453b6731b3e", + "size": 2838105, + "subdir": "linux-64", + "timestamp": 1546601712148, + "version": "0.42.0" + }, + "numba-0.42.0-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.27.0,<0.28.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.1" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "194cb3a1e4cbc01808e4a35949bbcf7c", + "name": "numba", + "sha256": "0605de2d9b75779d0c04875302790f0f3fb4ac0bb683b8e7c3c3180d824cef73", + "size": 2837604, + "subdir": "linux-64", + "timestamp": 1546601709768, + "version": "0.42.0" + }, + "numba-0.43.0-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.28.0,<0.29.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "97fe2808bda58a40f76ca58021712d4b", + "name": "numba", + "sha256": "86b796f9fa3e5f8ad5e2ab2f4fa5d5a9e59f1a4d7495958df71ed7a725ebcbcc", + "size": 2915232, + "subdir": "linux-64", + "timestamp": 1552591592478, + "version": "0.43.0" + }, + "numba-0.43.0-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.28.0,<0.29.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "8e2cfa4bffddd088fc63917e1530bc62", + "name": "numba", + "sha256": "4693a995160d416b00e0325ebcd8ea73b66eee7ca62ab34b60c84d1483798e6f", + "size": 2981440, + "subdir": "linux-64", + "timestamp": 1552591593286, + "version": "0.43.0" + }, + "numba-0.43.0-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.28.0,<0.29.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "074f5b23639ce727485bc64670fbfb1b", + "name": "numba", + "sha256": "c46857242c276b320869768ae93a17d253e6798784a374a31299d408596e3787", + "size": 2990132, + "subdir": "linux-64", + "timestamp": 1552591515345, + "version": "0.43.0" + }, + "numba-0.43.1-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.28.0,<0.29.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "c6fa9cbed46804817a102a2c9c6c1c0e", + "name": "numba", + "sha256": "18a120b3769a34c3a24f6da007704e476ac0ac1a789849a8a972fa39f541dbd5", + "size": 2918297, + "subdir": "linux-64", + "timestamp": 1553670358844, + "version": "0.43.1" + }, + "numba-0.43.1-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.28.0,<0.29.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "f0ac18616ac36d98ad2341a625fe77db", + "name": "numba", + "sha256": "df5ca4702ed043bd7af5ba78b240a2311636407b2187b7c9ed1a03365c4cc9eb", + "size": 2989228, + "subdir": "linux-64", + "timestamp": 1553670369679, + "version": "0.43.1" + }, + "numba-0.43.1-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.28.0,<0.29.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "4c1854bdc66ae31ec9c34106e267bc0a", + "name": "numba", + "sha256": "803bfdbe3fca385ad857429a23936293f16a1baaf6b43b931dc31e052514167d", + "size": 2988561, + "subdir": "linux-64", + "timestamp": 1553670336724, + "version": "0.43.1" + }, + "numba-0.44.0-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "aa7ed44a09d903b4e6bcf825995b23cd", + "name": "numba", + "sha256": "ea2928ee06e3e86a09faea49f26e0ddea0b5d7e17ae326a427780579978e601a", + "size": 2994162, + "subdir": "linux-64", + "timestamp": 1560886555594, + "version": "0.44.0" + }, + "numba-0.44.0-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "6e66e6b8d933e943db590b1988552458", + "name": "numba", + "sha256": "ffa31aed6cdb1e7e15c56f1d2848031617e9e3732609efd15b01dc9b4411ef08", + "size": 3068237, + "subdir": "linux-64", + "timestamp": 1560886567011, + "version": "0.44.0" + }, + "numba-0.44.0-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "307f260ecfc0019c1d8dabc8d897cb42", + "name": "numba", + "sha256": "688ed4bda1614724e84aa1560b0805fc8024404b69bbc4a125c1f9bc4a7373fb", + "size": 3059670, + "subdir": "linux-64", + "timestamp": 1560886484112, + "version": "0.44.0" + }, + "numba-0.44.1-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "34b050275311598304d77c98e94e0430", + "name": "numba", + "sha256": "5ceccb6dfe5cc78b2ce2c5cc4b45577b78e678d21068b68aff9bcce6e157177d", + "size": 2992069, + "subdir": "linux-64", + "timestamp": 1560889821566, + "version": "0.44.1" + }, + "numba-0.44.1-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "97b4f4ff5988947b3434586b6c62a8da", + "name": "numba", + "sha256": "75f50bdc56d671909390a1f26cb2316cc15df84ccd800fd23fdb4f1872b3c39f", + "size": 3075877, + "subdir": "linux-64", + "timestamp": 1560889853986, + "version": "0.44.1" + }, + "numba-0.44.1-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "ed40267c259ef3d65208b0761aa1eebf", + "name": "numba", + "sha256": "e3d578bce7e8ce381ad41803ae5766642a572e2f19597c14f35f3192b2f12637", + "size": 3073452, + "subdir": "linux-64", + "timestamp": 1560889940592, + "version": "0.44.1" + }, + "numba-0.45.0-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "1147158e0210efd5b6dee594cc5bc855", + "name": "numba", + "sha256": "2ad82ad941c45ebef85ac24fab99241fee2df37d9108caf37e8ba0298fc810df", + "size": 3166422, + "subdir": "linux-64", + "timestamp": 1563756517229, + "version": "0.45.0" + }, + "numba-0.45.0-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "50d668d31ed3800134cba08731c03978", + "name": "numba", + "sha256": "7b5d025e03b1218066c6b65bf74cfe5e040896a38396c3329d57aadccf27ee7f", + "size": 3249403, + "subdir": "linux-64", + "timestamp": 1563756508221, + "version": "0.45.0" + }, + "numba-0.45.0-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "6e94f85205b03a7e4f5159073784fe26", + "name": "numba", + "sha256": "aefa382894cac2da24573d6df5b51082daf36e5106c33f2db54e189889111af8", + "size": 3242668, + "subdir": "linux-64", + "timestamp": 1563756553934, + "version": "0.45.0" + }, + "numba-0.45.1-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "a72d15cccd75b2ca02cc8b31b4267776", + "name": "numba", + "sha256": "942c39986e7c23f38bd3bf7bd1ade461e5b4d60bd292032bf0479004b4a50b2f", + "size": 3171565, + "subdir": "linux-64", + "timestamp": 1565199227581, + "version": "0.45.1" + }, + "numba-0.45.1-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "aa1d6e3d90fd80b1adc987cd9045e1c9", + "name": "numba", + "sha256": "09e25c3541fe733c7b0ecc079b8a4faf513d8bbf1083c188fc41a6b804ec96d4", + "size": 3241511, + "subdir": "linux-64", + "timestamp": 1565199227300, + "version": "0.45.1" + }, + "numba-0.45.1-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "0135591c1bbfcdfeb794fbc5a05b0165", + "name": "numba", + "sha256": "fb947494f0f0633abfaf346b466fb9e77bf929461cd1d01a3d82078aa3e8da7c", + "size": 3259472, + "subdir": "linux-64", + "timestamp": 1565199223381, + "version": "0.45.1" + }, + "numba-0.46.0-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.30.0", + "llvmlite >=0.30.0,<0.31.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.8", + "setuptools" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "ab3a5c385826b0e30b6df72a54c16fea", + "name": "numba", + "sha256": "0674b5251c1f9bfc088b80a100c9f8ae636955dfaa0a77578c216cc2fb5fd4ae", + "size": 3295637, + "subdir": "linux-64", + "timestamp": 1572011783830, + "version": "0.46.0" + }, + "numba-0.46.0-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.30.0", + "llvmlite >=0.30.0,<0.31.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.8", + "setuptools" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "2c7bba6627ed6e77c6d7219ef0ba068d", + "name": "numba", + "sha256": "a9a11475361ac5d7c923db26deaa96cd7b150f49d622ce29dd8392265ae4ea00", + "size": 3377486, + "subdir": "linux-64", + "timestamp": 1572011883856, + "version": "0.46.0" + }, + "numba-0.46.0-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.30.0", + "llvmlite >=0.30.0,<0.31.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.8", + "setuptools" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "58309da0e5808a53376d32f6aad01a15", + "name": "numba", + "sha256": "b301fa2c1822d7ed6509b78fcaabf55283b847060a257d495799b904cd0c5e62", + "size": 3376675, + "subdir": "linux-64", + "timestamp": 1572011921381, + "version": "0.46.0" + }, + "numba-0.47.0-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.31.0", + "llvmlite >=0.31.0,<0.32.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.8", + "setuptools" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "219f70696bfc66831b2f89fb220da284", + "name": "numba", + "sha256": "996ddc8ef646c2e7bc62fed80b771554e43e2741b11366afb4b6b8cddc76ff40", + "size": 3462075, + "subdir": "linux-64", + "timestamp": 1579016886641, + "version": "0.47.0" + }, + "numba-0.47.0-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.31.0", + "llvmlite >=0.31.0,<0.32.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.8", + "setuptools" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "a6f5092a8d0a623a42f42a0d63810bfc", + "name": "numba", + "sha256": "7dcf57747bda8aa6cfd6e57fd1899ad0b4d51e3c366f181f0061a574751934d1", + "size": 3529574, + "subdir": "linux-64", + "timestamp": 1579016865770, + "version": "0.47.0" + }, + "numba-0.47.0-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.31.0", + "llvmlite >=0.31.0,<0.32.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.8", + "setuptools" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "fbd5d63682f82958f181376150606b46", + "name": "numba", + "sha256": "aa840711001b560d5d6e46007584a6653df4f991e6f6ed5b2d6a40f7da909161", + "size": 3531439, + "subdir": "linux-64", + "timestamp": 1579016803908, + "version": "0.47.0" + }, + "numba-0.47.0-py38h962f231_0.tar.bz2": { + "build": "py38h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.31.0", + "llvmlite >=0.31.0,<0.32.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "tbb >=2019.8", + "setuptools" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "6fa82e545782350947093e79d4b62b5a", + "name": "numba", + "sha256": "492c703e9aed1f1dfcdb117f04430e36e115b3f6535902df00493b37f4819cae", + "size": 3571070, + "subdir": "linux-64", + "timestamp": 1579101408315, + "version": "0.47.0" + }, + "numba-0.48.0-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.31.0", + "llvmlite >=0.31.0,<0.32.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "tbb >=2019.8" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "a962dfc6affa872619fe125fe49daa42", + "name": "numba", + "sha256": "d4091c131b343b3f9ba9759617b1e3b25565cff79ad0c6fb99b69269614f325a", + "size": 3562446, + "subdir": "linux-64", + "timestamp": 1580335942146, + "version": "0.48.0" + }, + "numba-0.48.0-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.31.0", + "llvmlite >=0.31.0,<0.32.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2019.8" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "c250b60dc3dfe6d7d9561d13ba94ff06", + "name": "numba", + "sha256": "217890dd063598e061615e99e61843034a12f101b4558f5656ee0103544e7c8e", + "size": 3554070, + "subdir": "linux-64", + "timestamp": 1580336151465, + "version": "0.48.0" + }, + "numba-0.48.0-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.31.0", + "llvmlite >=0.31.0,<0.32.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2019.8" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "527662546f9d70b02fd90656b62a3ef6", + "name": "numba", + "sha256": "bb7ac7da95dae7c927776af533fcd5dbfa0f93b9ac2fce02af9a410bf39917e6", + "size": 3573235, + "subdir": "linux-64", + "timestamp": 1580336141684, + "version": "0.48.0" + }, + "numba-0.49.0-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.32.0", + "llvmlite >=0.32.0,<0.33.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "cc28a5a5fd609e78d7ffafa132a09072", + "name": "numba", + "sha256": "c32009782cff79223fd90ace069b12c81b7f9c5c331f4d381e523c89a12c6931", + "size": 3642184, + "subdir": "linux-64", + "timestamp": 1587143300452, + "version": "0.49.0" + }, + "numba-0.49.0-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.32.0", + "llvmlite >=0.32.0,<0.33.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "4027337b4dd5c00eb88f8a7c34439d79", + "name": "numba", + "sha256": "1b618b70df898c519278cb169a17fc0532165ea1a3f107b9c68113fa287fad29", + "size": 3635277, + "subdir": "linux-64", + "timestamp": 1587145361780, + "version": "0.49.0" + }, + "numba-0.49.0-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.32.0", + "llvmlite >=0.32.0,<0.33.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "59e1a013d738370d0765a1c00c6ab1e0", + "name": "numba", + "sha256": "dec9c8986fa8d03a9f18b440bf7037a60eb17b364a317419731fed71b55c2955", + "size": 3658641, + "subdir": "linux-64", + "timestamp": 1587143320031, + "version": "0.49.0" + }, + "numba-0.49.1-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.32.1", + "llvmlite >=0.32.1,<0.33.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "74fbd9486f601ca0349e55ba188cc811", + "name": "numba", + "sha256": "59584631b0f667083b64a50a6c7ed119d37bd4fbffdccc8b9986332b39dc8d85", + "size": 3649845, + "subdir": "linux-64", + "timestamp": 1589294718610, + "version": "0.49.1" + }, + "numba-0.49.1-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.32.1", + "llvmlite >=0.32.1,<0.33.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "7ba01bd7cf0ad0ee9e387408052c2988", + "name": "numba", + "sha256": "8162f5bac46442756c1dfff14fda5734dfe0cf1ab38458a9892124fb8b5627d9", + "size": 3653500, + "subdir": "linux-64", + "timestamp": 1589294929656, + "version": "0.49.1" + }, + "numba-0.49.1-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.32.1", + "llvmlite >=0.32.1,<0.33.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "99d64cb7edc5d972ab7ef9369eb32820", + "name": "numba", + "sha256": "943b6c1fcbf7be3cb7254935b52ca9dea0fe5e1840e69525dcc288a1d63aa475", + "size": 3664882, + "subdir": "linux-64", + "timestamp": 1589294698909, + "version": "0.49.1" + }, + "numba-0.50.1-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.33.0", + "llvmlite >=0.33.0,<0.34.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "abe666bf004081c9cf52c0b83df84553", + "name": "numba", + "sha256": "3dfeecb7c18b69bf56348d291c37af347ee3da56ec2fa063ada7f389bd9e2174", + "size": 3681120, + "subdir": "linux-64", + "timestamp": 1593094353128, + "version": "0.50.1" + }, + "numba-0.50.1-py36h0573a6f_1.tar.bz2": { + "build": "py36h0573a6f_1", + "build_number": 1, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.33.0 *_1", + "llvmlite >=0.33.0,<0.34.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "ed392cbd68bf4cefd767592ff167f68c", + "name": "numba", + "sha256": "3bc08d0b268e19ebdf952ff6cd9f9833c9ef92a1b7708dc8d258ee6e4dd2f7b5", + "size": 3683869, + "subdir": "linux-64", + "timestamp": 1594578690688, + "version": "0.50.1" + }, + "numba-0.50.1-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.33.0", + "llvmlite >=0.33.0,<0.34.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "a99518dfa6d755c1c36ec6f8620fdf28", + "name": "numba", + "sha256": "deff0e5714605e6a93d7b9b17472547747582016f1f95dd7d93412892f75937a", + "size": 3695607, + "subdir": "linux-64", + "timestamp": 1593094392773, + "version": "0.50.1" + }, + "numba-0.50.1-py37h0573a6f_1.tar.bz2": { + "build": "py37h0573a6f_1", + "build_number": 1, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.33.0 *_1", + "llvmlite >=0.33.0,<0.34.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "49a1e79f1fb8f734dd8187634b31a051", + "name": "numba", + "sha256": "090f1405099ddceae354dd0daf05c50ae312adb0eb3fca85937290e471c181a0", + "size": 3680324, + "subdir": "linux-64", + "timestamp": 1594578656536, + "version": "0.50.1" + }, + "numba-0.50.1-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.33.0", + "llvmlite >=0.33.0,<0.34.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "e85f14b2328fde5ce8c474ea1ce9cb5c", + "name": "numba", + "sha256": "18ac47c4415c404c076bfa4874486e93c74c1e4a7c54ef8ed4d3cb1865767a03", + "size": 3702989, + "subdir": "linux-64", + "timestamp": 1593094403922, + "version": "0.50.1" + }, + "numba-0.50.1-py38h0573a6f_1.tar.bz2": { + "build": "py38h0573a6f_1", + "build_number": 1, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.33.0 *_1", + "llvmlite >=0.33.0,<0.34.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "259aaf57042e61840ce8cca9f6e63dd6", + "name": "numba", + "sha256": "7821da140e612c176ac1fb41095e64ef3ffefe5af05f577adaf53251eb444504", + "size": 3710708, + "subdir": "linux-64", + "timestamp": 1594577680090, + "version": "0.50.1" + }, + "numba-0.51.2-py36h0573a6f_1.tar.bz2": { + "build": "py36h0573a6f_1", + "build_number": 1, + "constrains": [ + "tbb >=2019.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.34.0,<0.35", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "tbb >=2020.2" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "bd149c4ffb98f5ebb166d0bdb6448a9a", + "name": "numba", + "sha256": "2a5479082ba104e9fe94640c562ff7677f23b567ff5648a143b5150c7f790a68", + "size": 3834476, + "subdir": "linux-64", + "timestamp": 1600094363539, + "version": "0.51.2" + }, + "numba-0.51.2-py37h04863e7_1.tar.bz2": { + "build": "py37h04863e7_1", + "build_number": 1, + "constrains": [ + "tbb >=2019.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.34.0,<0.35", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2020.2" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b34e1917b3386726b5f1e63946635e9b", + "name": "numba", + "sha256": "a0fef2e4fa2be90c3f6101cb49e5a5dd2bbb4a855e76723584f6f120d801e812", + "size": 3825264, + "subdir": "linux-64", + "timestamp": 1600102583223, + "version": "0.51.2" + }, + "numba-0.51.2-py37h0573a6f_1.tar.bz2": { + "build": "py37h0573a6f_1", + "build_number": 1, + "constrains": [ + "tbb >=2019.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.34.0,<0.35", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2020.2" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a1e17d1c987e7f686a299ebeab9f155b", + "name": "numba", + "sha256": "1d687153f163cf05721491de3d3c72c8264e8d1eeef58b4950f408decdecfff1", + "size": 3821448, + "subdir": "linux-64", + "timestamp": 1600094310247, + "version": "0.51.2" + }, + "numba-0.51.2-py38h0573a6f_1.tar.bz2": { + "build": "py38h0573a6f_1", + "build_number": 1, + "constrains": [ + "tbb >=2019.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.34.0,<0.35", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2020.2" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d2edf6757ede592495ad01af87083f58", + "name": "numba", + "sha256": "2c4b20a7d6f41213056c69160962cd1faabec7d3014a05b738edd0e4cc1a3167", + "size": 3857233, + "subdir": "linux-64", + "timestamp": 1600100745046, + "version": "0.51.2" + }, + "numba-0.52.0-py36ha9443f7_0.tar.bz2": { + "build": "py36ha9443f7_0", + "build_number": 0, + "constrains": [ + "scipy >=1.0", + "libopenblas !=0.3.6", + "tbb >=2019.5,<=2020.3", + "cudatoolkit >=9.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.35.0,<0.36.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c918b641e85b0c25fe6c8288811636ab", + "name": "numba", + "sha256": "a3d643745b0b2a509f1a401e7edb711a90657868632f8022dac061151a2a8f2c", + "size": 3758185, + "subdir": "linux-64", + "timestamp": 1614888223231, + "version": "0.52.0" + }, + "numba-0.52.0-py37ha9443f7_0.tar.bz2": { + "build": "py37ha9443f7_0", + "build_number": 0, + "constrains": [ + "cudatoolkit >=9.0", + "tbb >=2019.5,<=2020.3", + "libopenblas !=0.3.6", + "scipy >=1.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.35.0,<0.36.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5d18d6b6ef07f4cee51c53149a9e2d7d", + "name": "numba", + "sha256": "52e0c688914876364813e23c0cf151e7e39318b5ea330e6131ff04ba2fc07390", + "size": 3757594, + "subdir": "linux-64", + "timestamp": 1614889124183, + "version": "0.52.0" + }, + "numba-0.52.0-py38ha9443f7_0.tar.bz2": { + "build": "py38ha9443f7_0", + "build_number": 0, + "constrains": [ + "cudatoolkit >=9.0", + "libopenblas !=0.3.6", + "scipy >=1.0", + "tbb >=2019.5,<=2020.3" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.35.0,<0.36.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "015ccc1363e18db9696f136a05d0e006", + "name": "numba", + "sha256": "56b7b9fd9061b42191537cd80ba8e9f91b62bafc89e11c0d904ce85a0e4a518b", + "size": 3770198, + "subdir": "linux-64", + "timestamp": 1614888233096, + "version": "0.52.0" + }, + "numba-0.53.0-py36ha9443f7_0.tar.bz2": { + "build": "py36ha9443f7_0", + "build_number": 0, + "constrains": [ + "scipy >=1.0", + "cudatoolkit >=9.0", + "libopenblas !=0.3.6", + "tbb >=2019.5,<=2020.3" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.36.0,<0.37.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d51200b08a354572bbdf2315ccd3a4ca", + "name": "numba", + "sha256": "25b8c95901109e7cd595c6b07b4b14ddd32a0847c1e55adc513f7d9ae62e8242", + "size": 3847680, + "subdir": "linux-64", + "timestamp": 1615887492337, + "version": "0.53.0" + }, + "numba-0.53.0-py37ha9443f7_0.tar.bz2": { + "build": "py37ha9443f7_0", + "build_number": 0, + "constrains": [ + "scipy >=1.0", + "libopenblas !=0.3.6", + "tbb >=2019.5,<=2020.3", + "cudatoolkit >=9.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.36.0,<0.37.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a9ba7ee108ff219ea7dd3bae2bd8531d", + "name": "numba", + "sha256": "74d8ac55335de4cfa3ba5ac208c164c66ff05851e1ca2b1f7c5f06e0ed4fd66b", + "size": 3854963, + "subdir": "linux-64", + "timestamp": 1615889343026, + "version": "0.53.0" + }, + "numba-0.53.0-py38ha9443f7_0.tar.bz2": { + "build": "py38ha9443f7_0", + "build_number": 0, + "constrains": [ + "scipy >=1.0", + "tbb >=2019.5,<=2020.3", + "cudatoolkit >=9.0", + "libopenblas !=0.3.6" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.36.0,<0.37.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a2adf7c5fad138b4ca8fdab3807016f4", + "name": "numba", + "sha256": "8563058d0bcc3d49180c72907d252c04888d517157c2b974f0a58ea9f4bc7695", + "size": 3860464, + "subdir": "linux-64", + "timestamp": 1615889322474, + "version": "0.53.0" + }, + "numba-0.53.0-py39ha9443f7_0.tar.bz2": { + "build": "py39ha9443f7_0", + "build_number": 0, + "constrains": [ + "scipy >=1.0", + "libopenblas !=0.3.6", + "cudatoolkit >=9.0", + "tbb >=2019.5,<=2020.3" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.36.0,<0.37.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5500c0990a36b1a562100e4b08460e66", + "name": "numba", + "sha256": "c879a9f12188df1c80892a50a732242b4e72d236844f9a9b81153b7e7a307625", + "size": 3858981, + "subdir": "linux-64", + "timestamp": 1615889351510, + "version": "0.53.0" + }, + "numba-0.53.1-py36ha9443f7_0.tar.bz2": { + "build": "py36ha9443f7_0", + "build_number": 0, + "constrains": [ + "libopenblas !=0.3.6", + "cudatoolkit >=9.0", + "tbb >=2019.5,<=2020.3", + "scipy >=1.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.36.0,<0.37.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "94857f11097f834351b9de4a42275aff", + "name": "numba", + "sha256": "800b36d92eca5a657adba7ae5ec902179d94eda67403cebcd359c463c0292cec", + "size": 3858173, + "subdir": "linux-64", + "timestamp": 1616772073859, + "version": "0.53.1" + }, + "numba-0.53.1-py37ha9443f7_0.tar.bz2": { + "build": "py37ha9443f7_0", + "build_number": 0, + "constrains": [ + "tbb >=2019.5,<=2020.3", + "scipy >=1.0", + "cudatoolkit >=9.0", + "libopenblas !=0.3.6" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.36.0,<0.37.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5a762634d0b1a65c9837ca28309f1cfb", + "name": "numba", + "sha256": "2127a020555e0769589684d750ef69d8dad2f98df63aa750263ee1beea28210f", + "size": 3862805, + "subdir": "linux-64", + "timestamp": 1616774351774, + "version": "0.53.1" + }, + "numba-0.53.1-py38ha9443f7_0.tar.bz2": { + "build": "py38ha9443f7_0", + "build_number": 0, + "constrains": [ + "tbb >=2019.5,<=2020.3", + "scipy >=1.0", + "cudatoolkit >=9.0", + "libopenblas !=0.3.6" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.36.0,<0.37.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8b1ee3416138449b1902af4fb2a7d935", + "name": "numba", + "sha256": "d03553668457903fc0f3ab31cb6f6dff6c31ef0620379793999b8417f13f6ec7", + "size": 3862951, + "subdir": "linux-64", + "timestamp": 1616774133826, + "version": "0.53.1" + }, + "numba-0.53.1-py39ha9443f7_0.tar.bz2": { + "build": "py39ha9443f7_0", + "build_number": 0, + "constrains": [ + "tbb >=2019.5,<=2020.3", + "scipy >=1.0", + "libopenblas !=0.3.6", + "cudatoolkit >=9.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.36.0,<0.37.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9ef8a285a1b8dff7e223d99ab64fcd2b", + "name": "numba", + "sha256": "35d06cc07edb6b7f631bd2755df15e5e47a4e79d1a07ac0976d8274d4b99c4d8", + "size": 3868204, + "subdir": "linux-64", + "timestamp": 1616774355087, + "version": "0.53.1" + }, + "numba-0.54.1-py37h51133e4_0.tar.bz2": { + "build": "py37h51133e4_0", + "build_number": 0, + "constrains": [ + "numpy >=1.17,<1.21.0a0" + ], + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvmlite >=0.37.0,<0.38.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2021.4.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "bbdde8ace76f35ee64c798271b282248", + "name": "numba", + "sha256": "489a1a0ec4e4bf1dadf68dfd2ab0ab8e295c8ed70f3bee3515fd8daf95f078ab", + "size": 3859393, + "subdir": "linux-64", + "timestamp": 1635186008761, + "version": "0.54.1" + }, + "numba-0.54.1-py38h51133e4_0.tar.bz2": { + "build": "py38h51133e4_0", + "build_number": 0, + "constrains": [ + "numpy >=1.17,<1.21.0a0" + ], + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvmlite >=0.37.0,<0.38.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2021.4.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "4ef6b53caf47947b75331d8399539fbd", + "name": "numba", + "sha256": "5c509ac6729a7f75bf469ed7a0eb69cb5c71063b980449f1cad3b1ff03e26a76", + "size": 3879950, + "subdir": "linux-64", + "timestamp": 1635186012359, + "version": "0.54.1" + }, + "numba-0.54.1-py39h51133e4_0.tar.bz2": { + "build": "py39h51133e4_0", + "build_number": 0, + "constrains": [ + "numpy >=1.17,<1.21.0a0" + ], + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvmlite >=0.37.0,<0.38.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "tbb >=2021.4.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "cb0b04a75266595830c3132af982eab4", + "name": "numba", + "sha256": "2d26f2325d23d0248911205872b28a27485abee41a222155358912b73b5077ba", + "size": 3870174, + "subdir": "linux-64", + "timestamp": 1635174419479, + "version": "0.54.1" + }, + "numba-0.55.0-py310h00e6091_0.tar.bz2": { + "build": "py310h00e6091_0", + "build_number": 0, + "constrains": [ + "numpy >=1.18,<1.22.0a0" + ], + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvmlite >=0.38.0,<0.39.0a0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9da5e0993a220b1485fad988a78b7699", + "name": "numba", + "sha256": "0f3734cb5fb7946e5de748c08e14405bdaff3221367204548fc581e3f03a421b", + "size": 4839334, + "subdir": "linux-64", + "timestamp": 1642675246485, + "version": "0.55.0" + }, + "numba-0.55.1-py310h00e6091_0.tar.bz2": { + "build": "py310h00e6091_0", + "build_number": 0, + "constrains": [ + "cudatoolkit >=9.2", + "scipy >=1.0", + "libopenblas !=0.3.6", + "tbb >=2021.0", + "numpy >=1.18,<1.22" + ], + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvmlite >=0.38.0,<0.39.0a0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "389aac08dd601c812f67f314777db4a2", + "name": "numba", + "sha256": "5f90f0bb888b5a2fe25064eb9315c12f441d2246d56d2e7ee54264dfe93a4f17", + "size": 4847833, + "subdir": "linux-64", + "timestamp": 1648044168716, + "version": "0.55.1" + }, + "numba-0.55.1-py37h51133e4_0.tar.bz2": { + "build": "py37h51133e4_0", + "build_number": 0, + "constrains": [ + "cudatoolkit >=9.2", + "scipy >=1.0", + "libopenblas !=0.3.6", + "tbb >=2021.0", + "numpy >=1.18,<1.22" + ], + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvmlite >=0.38.0,<0.39.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "38a4719bec997b85eb687a0f116ffcf9", + "name": "numba", + "sha256": "917a1b69f4f9da3ee120f00c1f07465d88aeaf824dc185758522e7f80ad9f763", + "size": 3981829, + "subdir": "linux-64", + "timestamp": 1648042278567, + "version": "0.55.1" + }, + "numba-0.55.1-py38h51133e4_0.tar.bz2": { + "build": "py38h51133e4_0", + "build_number": 0, + "constrains": [ + "cudatoolkit >=9.2", + "scipy >=1.0", + "libopenblas !=0.3.6", + "tbb >=2021.0", + "numpy >=1.18,<1.22" + ], + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvmlite >=0.38.0,<0.39.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "1e4aa23ed16619a38328e98d5439ec43", + "name": "numba", + "sha256": "fcdc28d72bb3c6543e25887a22c590e417ee9ef9f33bb222299c405fe8e9cf6e", + "size": 3974836, + "subdir": "linux-64", + "timestamp": 1648040615744, + "version": "0.55.1" + }, + "numba-0.55.1-py39h51133e4_0.tar.bz2": { + "build": "py39h51133e4_0", + "build_number": 0, + "constrains": [ + "cudatoolkit >=9.2", + "scipy >=1.0", + "libopenblas !=0.3.6", + "tbb >=2021.0", + "numpy >=1.18,<1.22" + ], + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvmlite >=0.38.0,<0.39.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "1c1f0821f0dd2ece64844f39edcbd03f", + "name": "numba", + "sha256": "30f95c6c51ee7ca01801778b1773d8ecb57fcf06e864093f27148e1298517c20", + "size": 3982289, + "subdir": "linux-64", + "timestamp": 1648045822890, + "version": "0.55.1" + }, + "numba-0.56.3-py310h1128e8f_0.tar.bz2": { + "build": "py310h1128e8f_0", + "build_number": 0, + "constrains": [ + "libopenblas !=0.3.6", + "tbb >=2021.0, <2022", + "cuda-python >=11.6", + "scipy >=1.0", + "cudatoolkit >=10.2" + ], + "depends": [ + "_openmp_mutex >=5.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "llvmlite >=0.39.*,<0.40", + "numpy >=1.21,!=1.22.0,!=1.22.1,!=1.22.2,<1.23", + "python >=3.10,<3.11.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "1e2cee3ad9b7a98ad289e521e22fecb3", + "name": "numba", + "sha256": "b5017661389915119cba6d62d4cde0675833a546cc661cef264e4fdbf9ff5af0", + "size": 4234602, + "subdir": "linux-64", + "timestamp": 1666885262805, + "version": "0.56.3" + }, + "numba-0.56.3-py37h417a72b_0.tar.bz2": { + "build": "py37h417a72b_0", + "build_number": 0, + "constrains": [ + "libopenblas !=0.3.6", + "tbb >=2021.0, <2022", + "cuda-python >=11.6", + "scipy >=1.0", + "cudatoolkit >=10.2" + ], + "depends": [ + "_openmp_mutex >=5.1", + "importlib_metadata", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "llvmlite >=0.39.*,<0.40", + "numpy >=1.18,!=1.22.0,!=1.22.1,!=1.22.2,<1.23", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9d57dfe39328fd6c08adc7da76f1fe70", + "name": "numba", + "sha256": "071400ae58ed16e1a001eb5b26fb69228f68be328f00037bd9d9b3609a054e31", + "size": 4160353, + "subdir": "linux-64", + "timestamp": 1666882752814, + "version": "0.56.3" + }, + "numba-0.56.3-py38h417a72b_0.tar.bz2": { + "build": "py38h417a72b_0", + "build_number": 0, + "constrains": [ + "libopenblas !=0.3.6", + "tbb >=2021.0, <2022", + "cuda-python >=11.6", + "scipy >=1.0", + "cudatoolkit >=10.2" + ], + "depends": [ + "_openmp_mutex >=5.1", + "importlib_metadata", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "llvmlite >=0.39.*,<0.40", + "numpy >=1.18,!=1.22.0,!=1.22.1,!=1.22.2,<1.23", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "0ebaa27014719443032a97d58bd53097", + "name": "numba", + "sha256": "c753c08a19191996a4f42594724729c00cfdaff34762ae9bf93620aaac53ea21", + "size": 4172046, + "subdir": "linux-64", + "timestamp": 1666880537400, + "version": "0.56.3" + }, + "numba-0.56.3-py39h417a72b_0.tar.bz2": { + "build": "py39h417a72b_0", + "build_number": 0, + "constrains": [ + "libopenblas !=0.3.6", + "tbb >=2021.0, <2022", + "cuda-python >=11.6", + "scipy >=1.0", + "cudatoolkit >=10.2" + ], + "depends": [ + "_openmp_mutex >=5.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "llvmlite >=0.39.*,<0.40", + "numpy >=1.19,!=1.22.0,!=1.22.1,!=1.22.2,<1.23", + "python >=3.9,<3.10.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "41a2a0583b938149d400213d594c758a", + "name": "numba", + "sha256": "9a291d0de83b803729da31156ad9fd37b3f85a4b93b1dc05064bc2b9c6cdcbb2", + "size": 4176061, + "subdir": "linux-64", + "timestamp": 1666878316854, + "version": "0.56.3" + }, + "numba-0.56.4-py310h1128e8f_0.tar.bz2": { + "build": "py310h1128e8f_0", + "build_number": 0, + "constrains": [ + "libopenblas !=0.3.6", + "cuda-python >=11.6", + "cudatoolkit >=10.2", + "tbb >=2021.0, <2022", + "scipy >=1.0" + ], + "depends": [ + "_openmp_mutex >=5.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "llvmlite >=0.39.*,<0.40", + "numpy >=1.21,!=1.22.0,!=1.22.1,!=1.22.2,<1.24", + "python >=3.10,<3.11.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "24612fbafc2f44147a65c9b31c99a2e9", + "name": "numba", + "sha256": "bfee81e22c2858cc5ec3075d3b3339a2da0c581fe592dba7bd31705bc474ac82", + "size": 4227024, + "subdir": "linux-64", + "timestamp": 1670258389389, + "version": "0.56.4" + }, + "numba-0.56.4-py37h417a72b_0.tar.bz2": { + "build": "py37h417a72b_0", + "build_number": 0, + "constrains": [ + "libopenblas !=0.3.6", + "cuda-python >=11.6", + "cudatoolkit >=10.2", + "tbb >=2021.0, <2022", + "scipy >=1.0" + ], + "depends": [ + "_openmp_mutex >=5.1", + "importlib_metadata", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "llvmlite >=0.39.*,<0.40", + "numpy >=1.18,!=1.22.0,!=1.22.1,!=1.22.2,<1.24", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5e547144b58af4e2c5aed5430694656f", + "name": "numba", + "sha256": "1ffec674efe652e06bd13b87b3a7d6aad04ee8f264cd6a32ef18a85d0b515cac", + "size": 4150733, + "subdir": "linux-64", + "timestamp": 1670260584777, + "version": "0.56.4" + }, + "numba-0.56.4-py38h417a72b_0.tar.bz2": { + "build": "py38h417a72b_0", + "build_number": 0, + "constrains": [ + "libopenblas !=0.3.6", + "cuda-python >=11.6", + "cudatoolkit >=10.2", + "tbb >=2021.0, <2022", + "scipy >=1.0" + ], + "depends": [ + "_openmp_mutex >=5.1", + "importlib_metadata", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "llvmlite >=0.39.*,<0.40", + "numpy >=1.18,!=1.22.0,!=1.22.1,!=1.22.2,<1.24", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "4c4443eda57a9781ca0d3f52298a1c7e", + "name": "numba", + "sha256": "77a9c5876a88840d44e12fd14fb8a5ee0bc01d81a99c756a13e12aee8fe21006", + "size": 4155737, + "subdir": "linux-64", + "timestamp": 1670263041009, + "version": "0.56.4" + }, + "numba-0.56.4-py39h417a72b_0.tar.bz2": { + "build": "py39h417a72b_0", + "build_number": 0, + "constrains": [ + "libopenblas !=0.3.6", + "cuda-python >=11.6", + "cudatoolkit >=10.2", + "tbb >=2021.0, <2022", + "scipy >=1.0" + ], + "depends": [ + "_openmp_mutex >=5.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "llvmlite >=0.39.*,<0.40", + "numpy >=1.19,!=1.22.0,!=1.22.1,!=1.22.2,<1.24", + "python >=3.9,<3.10.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "615f97ff802779c6b2f4bcfabf92340a", + "name": "numba", + "sha256": "24af5141926b377cfa88f0011a7da22272cd102b3bbb3041cc5a1b0f4dc90a0b", + "size": 4158456, + "subdir": "linux-64", + "timestamp": 1670265250909, + "version": "0.56.4" + }, + "numba-dppy-0.17.4-py37h93b75d6_0.tar.bz2": { + "build": "py37h93b75d6_0", + "build_number": 0, + "depends": [ + "dpctl 0.11.*", + "dpnp 0.8.*|0.9.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvm-spirv 11.*", + "numba 0.54.*|0.55.*", + "packaging", + "python >=3.7,<3.8.0a0", + "spirv-tools" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1c0347e9511ce09f8255fddc4d20b5d6", + "name": "numba-dppy", + "sha256": "a5ee7ea850d2ba505344cf3f6231e7627b5d4171b8a5be94db0640f3dc2ace6b", + "size": 293028, + "subdir": "linux-64", + "timestamp": 1646240788568, + "version": "0.17.4" + }, + "numba-dppy-0.17.4-py38h93b75d6_0.tar.bz2": { + "build": "py38h93b75d6_0", + "build_number": 0, + "depends": [ + "dpctl 0.11.*", + "dpnp 0.8.*|0.9.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvm-spirv 11.*", + "numba 0.54.*|0.55.*", + "packaging", + "python >=3.8,<3.9.0a0", + "spirv-tools" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ea9798cf324608d2847bcd49e07f4ec8", + "name": "numba-dppy", + "sha256": "bc97d9e199615558a67505d630830c36581cb78cc18293d72853279d72726ed4", + "size": 294174, + "subdir": "linux-64", + "timestamp": 1646240997889, + "version": "0.17.4" + }, + "numba-dppy-0.17.4-py39h93b75d6_0.tar.bz2": { + "build": "py39h93b75d6_0", + "build_number": 0, + "depends": [ + "dpctl 0.11.*", + "dpnp 0.8.*|0.9.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvm-spirv 11.*", + "numba 0.54.*|0.55.*", + "packaging", + "python >=3.9,<3.10.0a0", + "spirv-tools" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "98db102865a01ac0e3d4600c7fe9775a", + "name": "numba-dppy", + "sha256": "4e2bb3c99e658c5a07c139e33d19e3ed266dd06d751f3b453f016c3bdd5fa719", + "size": 293826, + "subdir": "linux-64", + "timestamp": 1646240897251, + "version": "0.17.4" + }, + "numcodecs-0.10.2-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "entrypoints", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.10,<3.11.0a0", + "typing-extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37d63b8f367e9085528094115765a6f8", + "name": "numcodecs", + "sha256": "dc600ea6be5dc8c0f0a669e29f51a2b7b7cc0a1b1523d88dc128550d3804f504", + "size": 1056516, + "subdir": "linux-64", + "timestamp": 1669115997066, + "version": "0.10.2" + }, + "numcodecs-0.10.2-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "entrypoints", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb1a00c5fbe1af71de2ac771d8a47ec6", + "name": "numcodecs", + "sha256": "a438c83f40a55209f0bf6372ddab57f4f030c4c7a13e5b8fa4a1fe7549bbac09", + "size": 1052461, + "subdir": "linux-64", + "timestamp": 1669116107658, + "version": "0.10.2" + }, + "numcodecs-0.10.2-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "entrypoints", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0a006cc57edb221d42e97277bcd2e72", + "name": "numcodecs", + "sha256": "c6d912dc4e3becd8534ecf7556a54ff99acf6817114ba4cfecccf90b19e8171e", + "size": 1060849, + "subdir": "linux-64", + "timestamp": 1669116322382, + "version": "0.10.2" + }, + "numcodecs-0.10.2-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "entrypoints", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21e3b787e301dfed176852d2389ef8dc", + "name": "numcodecs", + "sha256": "21c932ab5ce0795c1b22a404644f549fe913f36e5e657df78ee021ae8c472e4a", + "size": 1056843, + "subdir": "linux-64", + "timestamp": 1669116217121, + "version": "0.10.2" + }, + "numcodecs-0.11.0-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "entrypoints", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64008c444baafea502317809f8ac6ec6", + "name": "numcodecs", + "sha256": "82b39a0893865a6a04be71ca56b0ebc7226b8dde71ddbedde7ea8109f47dc3cf", + "size": 1062423, + "subdir": "linux-64", + "timestamp": 1674851683153, + "version": "0.11.0" + }, + "numcodecs-0.11.0-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "entrypoints", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ab639839b7c48070ec909a4c2cd2c15", + "name": "numcodecs", + "sha256": "d68ef0b77df6b568892188993d99bee02e871ef5b51d386440a94e8b07afc338", + "size": 1092851, + "subdir": "linux-64", + "timestamp": 1676841365393, + "version": "0.11.0" + }, + "numcodecs-0.11.0-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "entrypoints", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2bcfef33e85b6239a7d43220e33814a4", + "name": "numcodecs", + "sha256": "db989beb2b634e78e451b3b20decc215399f9aca346cd72983b8d79122a9907d", + "size": 1071714, + "subdir": "linux-64", + "timestamp": 1674851576942, + "version": "0.11.0" + }, + "numcodecs-0.11.0-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "entrypoints", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f58d89b483bf19653c28471e53b50f9", + "name": "numcodecs", + "sha256": "1eab9015940736bf3fe5dfb4b7aab8218f75b93684b08ee4a4d544acd20aaa2d", + "size": 1064711, + "subdir": "linux-64", + "timestamp": 1674851470620, + "version": "0.11.0" + }, + "numcodecs-0.5.4-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "backports.lzma", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ea6f6b1b5eda9d8bc89416d608c582ac", + "name": "numcodecs", + "sha256": "93e8f1d7558e50cd1557b4292aaa0c44f91a92cd3422714f1795c42734489409", + "size": 746831, + "subdir": "linux-64", + "timestamp": 1549908522580, + "version": "0.5.4" + }, + "numcodecs-0.5.4-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "adbe32fc624f921856c02c16e53eeea3", + "name": "numcodecs", + "sha256": "1c2da25964210e9df30c419943c9a869fc11b72afa597737c8751247b1ac4eaf", + "size": 785972, + "subdir": "linux-64", + "timestamp": 1549908614445, + "version": "0.5.4" + }, + "numcodecs-0.5.4-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7845503f7064d334a5be712f15bf765d", + "name": "numcodecs", + "sha256": "5cbf702c26422f12ccf7e009fb2d50ed5325f35da49ce7a922a984efa75e1db9", + "size": 789093, + "subdir": "linux-64", + "timestamp": 1549908472673, + "version": "0.5.4" + }, + "numcodecs-0.6.2-py27he6710b0_1001.tar.bz2": { + "build": "py27he6710b0_1001", + "build_number": 1001, + "depends": [ + "backports.lzma", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "addac44934c08a2a59cba8096bee77ed", + "name": "numcodecs", + "sha256": "a8067ff045da4dc49dc58f5ff236d623458812723839f2615502afaa6387957c", + "size": 929606, + "subdir": "linux-64", + "timestamp": 1548715450184, + "version": "0.6.2" + }, + "numcodecs-0.6.2-py36he6710b0_1001.tar.bz2": { + "build": "py36he6710b0_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "79def01be4b8c9962c9ae9d6811f5a31", + "name": "numcodecs", + "sha256": "863147152607d4e7ecbf3ab35e49921e1ef3078f63bed7e2ff8662422ff64e0a", + "size": 958298, + "subdir": "linux-64", + "timestamp": 1548715512727, + "version": "0.6.2" + }, + "numcodecs-0.6.2-py37he6710b0_1001.tar.bz2": { + "build": "py37he6710b0_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "9061a19585ddc9c520503588af7a8a72", + "name": "numcodecs", + "sha256": "8dc253d83a1a25c670051fccffcf2660feff1ba04d386f59b92f4df1dd851af5", + "size": 951288, + "subdir": "linux-64", + "timestamp": 1548715525049, + "version": "0.6.2" + }, + "numcodecs-0.6.3-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "backports.lzma", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "bb63ec58fbd07c120031943dacf8973f", + "name": "numcodecs", + "sha256": "8ff1fe2bd00e3d906c5eebe0153706fb9dfabbd4985afeacdb17282e3d4a8ef5", + "size": 937727, + "subdir": "linux-64", + "timestamp": 1548973295487, + "version": "0.6.3" + }, + "numcodecs-0.6.3-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a57b21e30e15b4a83bcef1febe0e5c51", + "name": "numcodecs", + "sha256": "09c0d725003ffa39d974d33c8070b0c64aea95ea39c4633c7794a0f76667ae63", + "size": 947862, + "subdir": "linux-64", + "timestamp": 1548973232998, + "version": "0.6.3" + }, + "numcodecs-0.6.3-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "33e32cf4881a845f8812980a481d9a9b", + "name": "numcodecs", + "sha256": "8fc0fe03f7bfd7519c2c89567242187c340785f14f77416fcba0500cd5afb941", + "size": 956136, + "subdir": "linux-64", + "timestamp": 1548973223293, + "version": "0.6.3" + }, + "numcodecs-0.6.3-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "3dada9b7950b87dc0a86431ab74093c5", + "name": "numcodecs", + "sha256": "c91e1715e8e01326a5cb270b9776b339da81f3fdedbda05b3cecdf9456523c4d", + "size": 964888, + "subdir": "linux-64", + "timestamp": 1574092625500, + "version": "0.6.3" + }, + "numcodecs-0.6.4-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "backports.lzma", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "61238e4e4962fa92a75430d0df2d90a6", + "name": "numcodecs", + "sha256": "86909fc6ee60e0455b993ee9dab3f1c270a51d84364ff3dad1d1ecc0100d501b", + "size": 988835, + "subdir": "linux-64", + "timestamp": 1573969828975, + "version": "0.6.4" + }, + "numcodecs-0.6.4-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4bfa3407e0a67a630fafef1da714106b", + "name": "numcodecs", + "sha256": "5a31f0d482de453bec3c23d68716fa43e2655b7cc9dd5b8f31fef2f28e99ebbf", + "size": 1003138, + "subdir": "linux-64", + "timestamp": 1573969888309, + "version": "0.6.4" + }, + "numcodecs-0.6.4-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b0ef15cba8241aa6e339bec71dac12cb", + "name": "numcodecs", + "sha256": "6a51149927b1eed4525cb8165a108eca99f90a333814bde4abd3ab77704ef7db", + "size": 1001704, + "subdir": "linux-64", + "timestamp": 1573969887800, + "version": "0.6.4" + }, + "numcodecs-0.6.4-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "235cea6aae530352b6138a897aeac024", + "name": "numcodecs", + "sha256": "275bbe7e049d05bcec75de5ade4da0b371055092fc49312bb430361ab8d397ed", + "size": 1012716, + "subdir": "linux-64", + "timestamp": 1573969853067, + "version": "0.6.4" + }, + "numcodecs-0.7.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4bd288c3d6727c236afeaf80295ac2d7", + "name": "numcodecs", + "sha256": "d4a966698378634ff48e4c3cb25ba32a9f88fa5ec280a591d2cff4eb9125b485", + "size": 1010704, + "subdir": "linux-64", + "timestamp": 1600140385332, + "version": "0.7.1" + }, + "numcodecs-0.7.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "82d7eebe8eff4d3ce9b65242c15e772a", + "name": "numcodecs", + "sha256": "969bc17350ac661e0cc07f64c5137b86de018b09eb219f29371e84fd4a45056c", + "size": 1016270, + "subdir": "linux-64", + "timestamp": 1600140374182, + "version": "0.7.1" + }, + "numcodecs-0.7.1-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "10498b7106d6c21143b8f4058df9af5b", + "name": "numcodecs", + "sha256": "efb537d03e06a7e4c6c98cd4c50d05dbcf9ce92827beea3719af71c6482addfa", + "size": 1019388, + "subdir": "linux-64", + "timestamp": 1600140372562, + "version": "0.7.1" + }, + "numcodecs-0.7.2-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "74d9b74012162283497a0a0244c8131b", + "name": "numcodecs", + "sha256": "24c69379e7087fbd0a982aabbf2fcf45cb965a7e9a61df470d8bac3613fee4fa", + "size": 993127, + "subdir": "linux-64", + "timestamp": 1601500159695, + "version": "0.7.2" + }, + "numcodecs-0.7.2-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e81bf795eb3c31f25b5bf373beb29ece", + "name": "numcodecs", + "sha256": "2a042de22abfcf36c1ac7f0ee3cf06718525e45f2c0f097a4aaaf4553a7b56ad", + "size": 992022, + "subdir": "linux-64", + "timestamp": 1601500170441, + "version": "0.7.2" + }, + "numcodecs-0.7.2-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "854c4ed610f9b6d160f346d0417b1097", + "name": "numcodecs", + "sha256": "598f49cce273d7e800aee4bb8889d9aabb9f073a27e05c0fc7bad8b22b6b6aca", + "size": 1004086, + "subdir": "linux-64", + "timestamp": 1601500133629, + "version": "0.7.2" + }, + "numcodecs-0.7.3-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "bd53fad220796b3611c9a554bcf6570b", + "name": "numcodecs", + "sha256": "54ca6937bed7a9f7968a5cdfa303cb57ed0ce6b871c8312be1132addce1eee3c", + "size": 4297997, + "subdir": "linux-64", + "timestamp": 1640809791525, + "version": "0.7.3" + }, + "numcodecs-0.7.3-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e80cbcec0c8d635ab24f0ef6e197dda8", + "name": "numcodecs", + "sha256": "f2473bb42c7914ef2223cae8b7c5795dff4558ccc25e6c6039b33f4f8f017132", + "size": 986970, + "subdir": "linux-64", + "timestamp": 1611692474240, + "version": "0.7.3" + }, + "numcodecs-0.7.3-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c43c72442e77db81c0264aebe0e7898a", + "name": "numcodecs", + "sha256": "9f23b803afc6d20844693c8c311228af4a6422cfbcd1f7869b2010245d01710b", + "size": 992777, + "subdir": "linux-64", + "timestamp": 1611693159912, + "version": "0.7.3" + }, + "numcodecs-0.7.3-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "ba4cbdb3fbfbf659a76c1cc6149c8056", + "name": "numcodecs", + "sha256": "655d3bccc625af351cac569f74bbd19b0442d99fcbccf905f5f816d9c2c05e08", + "size": 995992, + "subdir": "linux-64", + "timestamp": 1611693157991, + "version": "0.7.3" + }, + "numcodecs-0.7.3-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "1b6da1ef96be1a232725cfd26b0bd000", + "name": "numcodecs", + "sha256": "68b3303cfa1aeee604afc8b1b9310b27f1e2790371c861f5f746ca59ea5c3ba2", + "size": 1006924, + "subdir": "linux-64", + "timestamp": 1611693133810, + "version": "0.7.3" + }, + "numcodecs-0.8.0-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "141a8335e7ce008bde486da8af7cb012", + "name": "numcodecs", + "sha256": "de9837cbe9424be4a7eeb45c5205766bd32ebb83af439e66f107e5910e25fb19", + "size": 1032418, + "subdir": "linux-64", + "timestamp": 1623875448708, + "version": "0.8.0" + }, + "numcodecs-0.8.0-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7e65f47bf748bc5e8f146f1ab2353512", + "name": "numcodecs", + "sha256": "cc4d68f53e00440b5071e0cf12af1ec744eb88ef9a24892ab2da20f06f49f58f", + "size": 1026983, + "subdir": "linux-64", + "timestamp": 1623875455723, + "version": "0.8.0" + }, + "numcodecs-0.8.0-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "f93150b03d8f0b924b088dd7584494b4", + "name": "numcodecs", + "sha256": "e8c807064be145705893336ca20fcff054ba519ee6e5f92abed45a270ed4d56f", + "size": 1047697, + "subdir": "linux-64", + "timestamp": 1623875164882, + "version": "0.8.0" + }, + "numcodecs-0.8.0-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d6231fcf8ec900133402662ddad0ba60", + "name": "numcodecs", + "sha256": "05c52099d160f7e1a7dd1ec7b2ec5d91594c0d309b26f84c54ca440015c4f169", + "size": 1046052, + "subdir": "linux-64", + "timestamp": 1623929453927, + "version": "0.8.0" + }, + "numcodecs-0.9.1-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7fb7d01c625e8f6c2ddc86e1aedafb9f", + "name": "numcodecs", + "sha256": "aab4d59c28c42312864639f4d6bf123ef66d2ee04f8ea068ae1a7707406da40f", + "size": 1054186, + "subdir": "linux-64", + "timestamp": 1640877899869, + "version": "0.9.1" + }, + "numcodecs-0.9.1-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0207b626f7b121d2422153bbd2303ed0", + "name": "numcodecs", + "sha256": "5826a6cdc7eb8a7866b0df50d10736d963b9b864dc130a391ab5c1db89729f7d", + "size": 1066757, + "subdir": "linux-64", + "timestamp": 1640878116420, + "version": "0.9.1" + }, + "numcodecs-0.9.1-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a68eb6cbd020b99154d15e2bd2352e79", + "name": "numcodecs", + "sha256": "9032b915e8c388356c161cb521357ff81ceb3dfec24d2ebd3da675d934192bbb", + "size": 1073351, + "subdir": "linux-64", + "timestamp": 1640878015151, + "version": "0.9.1" + }, + "numexpr-2.6.2-py27_nomklhd298b71_1.tar.bz2": { + "build": "py27_nomklhd298b71_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "MIT", + "md5": "890ff5a8fbf6cf360e6e23a479f62303", + "name": "numexpr", + "sha256": "ffa500d7328c9ec957338fbadb13364c5d5bbdbf24d68a6a8cbc559d3ac43f9d", + "size": 182666, + "subdir": "linux-64", + "timestamp": 1509732259384, + "version": "2.6.2" + }, + "numexpr-2.6.2-py27h9521900_2.tar.bz2": { + "build": "py27h9521900_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "414b39ab6cdc15028b6788b525bdb726", + "name": "numexpr", + "sha256": "e7acbf772e944fd827730cc40102350ba9d66d1236cef9c23b76a974a06e4687", + "size": 183208, + "subdir": "linux-64", + "timestamp": 1510243903284, + "version": "2.6.2" + }, + "numexpr-2.6.2-py27he5efce1_1.tar.bz2": { + "build": "py27he5efce1_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "21c020376f9018f04f3a8bcda9d4b14f", + "name": "numexpr", + "sha256": "c2ee3a1930265a0068590d1960a710b978f028a578e4f62714cb91bbd20c4f13", + "size": 181999, + "subdir": "linux-64", + "timestamp": 1505729208538, + "version": "2.6.2" + }, + "numexpr-2.6.2-py35_nomklhc474e42_1.tar.bz2": { + "build": "py35_nomklhc474e42_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "MIT", + "md5": "945d3a2d20f18371a7894da9664da849", + "name": "numexpr", + "sha256": "1c6365b0f049fdb72bf53f12d7cdb172497591f920a1ba994726647b8f1a2345", + "size": 185120, + "subdir": "linux-64", + "timestamp": 1509732572985, + "version": "2.6.2" + }, + "numexpr-2.6.2-py35h5f89caa_1.tar.bz2": { + "build": "py35h5f89caa_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "156b38674240c17707c21140c082fca7", + "name": "numexpr", + "sha256": "64befb669ede9c865d3eba11a9db240c2f9f31925169d041def1d7de6ff37110", + "size": 184495, + "subdir": "linux-64", + "timestamp": 1505729245198, + "version": "2.6.2" + }, + "numexpr-2.6.2-py35hf56bd38_2.tar.bz2": { + "build": "py35hf56bd38_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "6e474e7a03cf8851ee19c87d5bd4cae6", + "name": "numexpr", + "sha256": "2aefb4d7cd3cd1a4fbf89ce210e4de10eebc01dfe35c53b5e228c39912433d45", + "size": 185933, + "subdir": "linux-64", + "timestamp": 1510243938794, + "version": "2.6.2" + }, + "numexpr-2.6.2-py36_nomklhd302951_1.tar.bz2": { + "build": "py36_nomklhd302951_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "MIT", + "md5": "ff5f7b3ec542a75cf1d6af83c26298d6", + "name": "numexpr", + "sha256": "84a9ab7c77bfe921348d3b11ae0a96fd6469eb0e2a229e95f7cac15f67fae8ba", + "size": 184683, + "subdir": "linux-64", + "timestamp": 1509732583795, + "version": "2.6.2" + }, + "numexpr-2.6.2-py36hc561933_2.tar.bz2": { + "build": "py36hc561933_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "4b7cafb916e9548e0c4b98e2ab5dbd85", + "name": "numexpr", + "sha256": "8df7af086dc7effd71451e495409487c520238e1a453fa7c16b912059e1b0324", + "size": 185407, + "subdir": "linux-64", + "timestamp": 1510243793818, + "version": "2.6.2" + }, + "numexpr-2.6.2-py36hdd3393f_1.tar.bz2": { + "build": "py36hdd3393f_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "997aa134d2abf0a490e945e500821ee2", + "name": "numexpr", + "sha256": "ff0552ddac7bda9a05ebfa518dc9ee9f3fa4eff11cc7786e596a8d6fb8514f70", + "size": 184046, + "subdir": "linux-64", + "timestamp": 1505729282190, + "version": "2.6.2" + }, + "numexpr-2.6.4-py27_nomklh19cb0ea_0.tar.bz2": { + "build": "py27_nomklh19cb0ea_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "MIT", + "md5": "e621b44adbf000403989d71fd9f1bc6c", + "name": "numexpr", + "sha256": "c42d7421bfe01155f72894e67ad2f7249a46cac8094af682ae9bc0a3aaf5883d", + "size": 183395, + "subdir": "linux-64", + "timestamp": 1512072425919, + "version": "2.6.4" + }, + "numexpr-2.6.4-py27hd318778_0.tar.bz2": { + "build": "py27hd318778_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.1,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "2faf119775358522471936bd55a030c1", + "name": "numexpr", + "sha256": "cb65304040427cb23f408b0fa7d0f0db08b5c3131dd7433fa4342737605640b8", + "size": 184006, + "subdir": "linux-64", + "timestamp": 1512070836514, + "version": "2.6.4" + }, + "numexpr-2.6.4-py35_nomklh55d25e0_0.tar.bz2": { + "build": "py35_nomklh55d25e0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "MIT", + "md5": "06a2769d3b0f161a9cf1e67da16f5aa6", + "name": "numexpr", + "sha256": "d276fd559e20a3e78a6a3b01eebed841a0c28c52e5ed68a53e780daad0eada45", + "size": 185870, + "subdir": "linux-64", + "timestamp": 1512072640677, + "version": "2.6.4" + }, + "numexpr-2.6.4-py35h119f745_0.tar.bz2": { + "build": "py35h119f745_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.1,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "c5610260329a840a46fca171ea8c1912", + "name": "numexpr", + "sha256": "e91b38f40c991e72410e6b50cd3a3004e6b0427aa9681510765f283e6ec2415e", + "size": 186404, + "subdir": "linux-64", + "timestamp": 1512070836353, + "version": "2.6.4" + }, + "numexpr-2.6.4-py36_nomklh2c28f9d_0.tar.bz2": { + "build": "py36_nomklh2c28f9d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "MIT", + "md5": "26199dc573aa8d7b5f17dd1664f7710e", + "name": "numexpr", + "sha256": "9293217057aac2d1b86962d4a32984bea9632917bef524d0487097726bd78c15", + "size": 185417, + "subdir": "linux-64", + "timestamp": 1512072676863, + "version": "2.6.4" + }, + "numexpr-2.6.4-py36hc4a3f9a_0.tar.bz2": { + "build": "py36hc4a3f9a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.1,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "4098946df8f81f36c9e529dd14e1fd0a", + "name": "numexpr", + "sha256": "66a7f37778a10b02d4b153083bddd616cc4e69a00b9b3f60dc3a0ece7dccf984", + "size": 185989, + "subdir": "linux-64", + "timestamp": 1512070443051, + "version": "2.6.4" + }, + "numexpr-2.6.5-py27_nomklhaa809a4_0.tar.bz2": { + "build": "py27_nomklhaa809a4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "MIT", + "md5": "b407b959b4f7f50dfae95937676118c7", + "name": "numexpr", + "sha256": "c4c28a3e9dbd3c8168a95b770a029de8c54778919e57792f8469d4c25d7f22a2", + "size": 191603, + "subdir": "linux-64", + "timestamp": 1525808998240, + "version": "2.6.5" + }, + "numexpr-2.6.5-py27h6cfcb94_0.tar.bz2": { + "build": "py27h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "0b9dcc102e8af238c6bf1940d40d8988", + "name": "numexpr", + "sha256": "9ac29a592645b07efbfaf55f7bdeaf1833d91194cb5c6fabdb46c452e896eae5", + "size": 189634, + "subdir": "linux-64", + "timestamp": 1530739186995, + "version": "2.6.5" + }, + "numexpr-2.6.5-py27h7bf3b9c_0.tar.bz2": { + "build": "py27h7bf3b9c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "de7237206a11423552e587738d3e60a6", + "name": "numexpr", + "sha256": "8b0801f183336b53787b87d8fe887cd3582f07243c47872f8533227abda5b5ac", + "size": 191005, + "subdir": "linux-64", + "timestamp": 1525809640004, + "version": "2.6.5" + }, + "numexpr-2.6.5-py27hedc7406_0.tar.bz2": { + "build": "py27hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d7856039396b0f5d364369b6b570c29b", + "name": "numexpr", + "sha256": "cd5bdb516f690e95ae3d229e338fb26566a637bb398950b1ab6370bca1fb1712", + "size": 189198, + "subdir": "linux-64", + "timestamp": 1530739231919, + "version": "2.6.5" + }, + "numexpr-2.6.5-py35_nomklhaa809a4_0.tar.bz2": { + "build": "py35_nomklhaa809a4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "MIT", + "md5": "f39ecb93a8733af529ef5f82642f5753", + "name": "numexpr", + "sha256": "3b1e4614a382807bec2a771ef41406347667462dae91bbcbcfd0f61e6a41bf51", + "size": 193899, + "subdir": "linux-64", + "timestamp": 1525808982903, + "version": "2.6.5" + }, + "numexpr-2.6.5-py35h7bf3b9c_0.tar.bz2": { + "build": "py35h7bf3b9c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "71757aaa0c8a6f6e0b6205d4646ea4be", + "name": "numexpr", + "sha256": "e5c498f7ab3f48caa82499dd8e5a6c0736f6f0629a7aa826637ec30b5a749bcb", + "size": 193401, + "subdir": "linux-64", + "timestamp": 1525809679048, + "version": "2.6.5" + }, + "numexpr-2.6.5-py36_nomklhaa809a4_0.tar.bz2": { + "build": "py36_nomklhaa809a4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "MIT", + "md5": "ed559c4c3cbdf0ef93c01ba310d72ec7", + "name": "numexpr", + "sha256": "5949ff30ea84c2f16739947c8d3205f277bd97ad633c8526424e7f66f70e31df", + "size": 193415, + "subdir": "linux-64", + "timestamp": 1525808993075, + "version": "2.6.5" + }, + "numexpr-2.6.5-py36h6cfcb94_0.tar.bz2": { + "build": "py36h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f199cdb6c1e53ebc3f06b07131db0a89", + "name": "numexpr", + "sha256": "0a7d815e98ebe96934b19501c60ccd982091b95ce966983592531e35cc27bc56", + "size": 191724, + "subdir": "linux-64", + "timestamp": 1530739081603, + "version": "2.6.5" + }, + "numexpr-2.6.5-py36h7bf3b9c_0.tar.bz2": { + "build": "py36h7bf3b9c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "a36651def5ac683ef48c2c1ff9dcd26b", + "name": "numexpr", + "sha256": "b85da520b7232cbed9b1dfb01e6a7217aee52b5c62d8fa95269dd4e885c838a7", + "size": 192950, + "subdir": "linux-64", + "timestamp": 1525809680278, + "version": "2.6.5" + }, + "numexpr-2.6.5-py36hedc7406_0.tar.bz2": { + "build": "py36hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a6fb660990447a92864a2be421457b64", + "name": "numexpr", + "sha256": "4add6801e3b3ed364215f3ccad7ae357cb10e9e0c120752e6a3a9969f195248f", + "size": 191318, + "subdir": "linux-64", + "timestamp": 1530739142580, + "version": "2.6.5" + }, + "numexpr-2.6.5-py37h6cfcb94_0.tar.bz2": { + "build": "py37h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "0d8b614ad33a9a84e4b97ebecff6c406", + "name": "numexpr", + "sha256": "43f466c574f4a3932ae1be61a7298c20df327e5b735f041a01806bc26bdcc245", + "size": 191553, + "subdir": "linux-64", + "timestamp": 1530739277577, + "version": "2.6.5" + }, + "numexpr-2.6.5-py37hedc7406_0.tar.bz2": { + "build": "py37hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c34947c8c5e1fa0d86f0d9cedc4366b0", + "name": "numexpr", + "sha256": "7d59f83b30336c4b212210657e2967cfabb4c55d01482599fef51656efcd11a4", + "size": 191220, + "subdir": "linux-64", + "timestamp": 1530739323869, + "version": "2.6.5" + }, + "numexpr-2.6.6-py27h00253c6_0.tar.bz2": { + "build": "py27h00253c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "57c5ea0c2d433930dd958c356f67a141", + "name": "numexpr", + "sha256": "41c67784b4aba6ee47c7876c814fc6a4a5677e42ffc9c7a818c794df7aacff65", + "size": 190819, + "subdir": "linux-64", + "timestamp": 1533747298252, + "version": "2.6.6" + }, + "numexpr-2.6.6-py27h98f89e9_0.tar.bz2": { + "build": "py27h98f89e9_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "8e9e7f7474e333b619406973216dfb9c", + "name": "numexpr", + "sha256": "241d543fdde3e23253b6854a751aae561be6f44ffa3273b458a714cbf662bbbd", + "size": 191494, + "subdir": "linux-64", + "timestamp": 1533746689291, + "version": "2.6.6" + }, + "numexpr-2.6.6-py35h00253c6_0.tar.bz2": { + "build": "py35h00253c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "91ee5fe06c3b04934898061ae7696e1f", + "name": "numexpr", + "sha256": "6177c5a350a182a6cc44128bee6c264b8d98be250c7b43beca717009474ae3de", + "size": 193192, + "subdir": "linux-64", + "timestamp": 1533747372404, + "version": "2.6.6" + }, + "numexpr-2.6.6-py35h98f89e9_0.tar.bz2": { + "build": "py35h98f89e9_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "67de11d1f7c48265fb1912c01ce48da1", + "name": "numexpr", + "sha256": "021ee6c515a4f9c20c3edfb763d4813c1305f83d9e0a367883156212fc204eba", + "size": 193759, + "subdir": "linux-64", + "timestamp": 1533746789160, + "version": "2.6.6" + }, + "numexpr-2.6.6-py36h00253c6_0.tar.bz2": { + "build": "py36h00253c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6b0226422a3b67648b86d5709102ce2d", + "name": "numexpr", + "sha256": "357ac4053be3ee355b66d6fa21704df3175d163d4df3058e8a5f6bd5d05e4b0b", + "size": 192837, + "subdir": "linux-64", + "timestamp": 1533747091265, + "version": "2.6.6" + }, + "numexpr-2.6.6-py36h98f89e9_0.tar.bz2": { + "build": "py36h98f89e9_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "cc553b46af8fe0eafe5792f14c6206ea", + "name": "numexpr", + "sha256": "e9f7bae3b5049b160888dcfe73f8d3ced17a1af03c707b2a201974b8a931e450", + "size": 193324, + "subdir": "linux-64", + "timestamp": 1533746689464, + "version": "2.6.6" + }, + "numexpr-2.6.6-py37h00253c6_0.tar.bz2": { + "build": "py37h00253c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b48abea40965c41e8e2ecdd45d40ce54", + "name": "numexpr", + "sha256": "97b51194c8819b3c0007b10f4c5d35a53e3909bfc6abab3d195565e3cc44dd00", + "size": 192950, + "subdir": "linux-64", + "timestamp": 1533747390192, + "version": "2.6.6" + }, + "numexpr-2.6.6-py37h98f89e9_0.tar.bz2": { + "build": "py37h98f89e9_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8f787592cd7b1bfb96025a8fc2041ced", + "name": "numexpr", + "sha256": "85ad71dcf9317a6347823f483d50a6078aadc7e7bdca0a2bba931809b2a56f14", + "size": 193386, + "subdir": "linux-64", + "timestamp": 1533746714069, + "version": "2.6.6" + }, + "numexpr-2.6.7-py27h00253c6_0.tar.bz2": { + "build": "py27h00253c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f47e87c093ab506b5ddb22d34230f68d", + "name": "numexpr", + "sha256": "06e4571ad40237012acca5a3220be2c27fba91d53feda769634705c69bbf2c26", + "size": 191339, + "subdir": "linux-64", + "timestamp": 1534175579324, + "version": "2.6.7" + }, + "numexpr-2.6.7-py27h6cfcb94_0.tar.bz2": { + "build": "py27h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5fafce19cebae1c3b645a71d6861510f", + "name": "numexpr", + "sha256": "a959eb1236de120c95147c92f6a8e4c56e418bd50da559f3623021b5800bbe67", + "size": 192035, + "subdir": "linux-64", + "timestamp": 1534355527453, + "version": "2.6.7" + }, + "numexpr-2.6.7-py27h98f89e9_0.tar.bz2": { + "build": "py27h98f89e9_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "3acbd8648719e9110e2ffc07180dce1e", + "name": "numexpr", + "sha256": "fcb77185177169b7039c3873e856debaa78d4591dedb84b7a9d7838ebc9c4db6", + "size": 192090, + "subdir": "linux-64", + "timestamp": 1534174219578, + "version": "2.6.7" + }, + "numexpr-2.6.7-py27hbd46f51_0.tar.bz2": { + "build": "py27hbd46f51_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "6b059dd3398c6d7fbf06d5c2c64ec33b", + "name": "numexpr", + "sha256": "2ce15c81b159d1b48396b11da124a59e62a2dfb61233d10b23c47e818f9504f2", + "size": 191579, + "subdir": "linux-64", + "timestamp": 1534781214540, + "version": "2.6.7" + }, + "numexpr-2.6.7-py27hedc7406_0.tar.bz2": { + "build": "py27hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5f76987ab528b66bac5266db5551bf61", + "name": "numexpr", + "sha256": "654c24a260761452d47a771a86234df4e0277d839d0cf4832d17753cdcb60c1f", + "size": 191471, + "subdir": "linux-64", + "timestamp": 1534355584321, + "version": "2.6.7" + }, + "numexpr-2.6.7-py35h00253c6_0.tar.bz2": { + "build": "py35h00253c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "0e7f86a9ffea01c6f6b60e60855fdca8", + "name": "numexpr", + "sha256": "0c0fb528f15e102fae4a4309203d01214a800eb3a52995b111e1789c641a23a1", + "size": 193634, + "subdir": "linux-64", + "timestamp": 1534175055795, + "version": "2.6.7" + }, + "numexpr-2.6.7-py35h6cfcb94_0.tar.bz2": { + "build": "py35h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "951d1235f1aa01af412abe8c4a5c53d9", + "name": "numexpr", + "sha256": "995d7cbc8a9091d71943bc819151bd844c9ecae37a4446d09c57e068325d0e6b", + "size": 194147, + "subdir": "linux-64", + "timestamp": 1534355639955, + "version": "2.6.7" + }, + "numexpr-2.6.7-py35h98f89e9_0.tar.bz2": { + "build": "py35h98f89e9_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "4957dca452a9dccfc558a25ff36c39d0", + "name": "numexpr", + "sha256": "b5dd9f8fd838bc9ebe96c1300cab32184b5a6d2fd6f40a41ad75146529e00576", + "size": 194192, + "subdir": "linux-64", + "timestamp": 1534175106498, + "version": "2.6.7" + }, + "numexpr-2.6.7-py35hedc7406_0.tar.bz2": { + "build": "py35hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "e142b5c2808a65e8fd7477bcf95de80c", + "name": "numexpr", + "sha256": "26ff32d19e6e0cc1aadebfc1cdf098e8af2d093030ede6d8c6e002caf8348463", + "size": 193754, + "subdir": "linux-64", + "timestamp": 1534355695148, + "version": "2.6.7" + }, + "numexpr-2.6.7-py36h00253c6_0.tar.bz2": { + "build": "py36h00253c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2f3bcb650324876a9af6af430a22eb2a", + "name": "numexpr", + "sha256": "df93a6d67dd46adc2299e176bd6e176540aaa60da8eb093c65a439cbf86907dd", + "size": 193333, + "subdir": "linux-64", + "timestamp": 1534175147216, + "version": "2.6.7" + }, + "numexpr-2.6.7-py36h6cfcb94_0.tar.bz2": { + "build": "py36h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d94246954c00f939727e348cd7c2ebf5", + "name": "numexpr", + "sha256": "b0b581165e00a14235ad4b7c5fd9560d6b800a7b1378fb15d678b3722c897ab6", + "size": 193903, + "subdir": "linux-64", + "timestamp": 1534355754114, + "version": "2.6.7" + }, + "numexpr-2.6.7-py36h98f89e9_0.tar.bz2": { + "build": "py36h98f89e9_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b24e00f9b63998368bf5a4876b861154", + "name": "numexpr", + "sha256": "34a34ff8cb023b09ef8112bc83fa8283a5a5abb4f4357370255c63234fbda83f", + "size": 193880, + "subdir": "linux-64", + "timestamp": 1534174274279, + "version": "2.6.7" + }, + "numexpr-2.6.7-py36hbd46f51_0.tar.bz2": { + "build": "py36hbd46f51_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6bb392feb5aef534d35ca5c0ce06860c", + "name": "numexpr", + "sha256": "98931740fb7751ed5748d337155fcf879624063033b5fff936c0b9be1ce600f0", + "size": 193430, + "subdir": "linux-64", + "timestamp": 1534780768747, + "version": "2.6.7" + }, + "numexpr-2.6.7-py36hedc7406_0.tar.bz2": { + "build": "py36hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e9f832834f96e4972ff0ca0e5e8e0d65", + "name": "numexpr", + "sha256": "cdc20ba96d45c14fe54ba221786353c2f3cd6dbc4fcd49a0ad2f9ef65dcae3da", + "size": 193275, + "subdir": "linux-64", + "timestamp": 1534355811246, + "version": "2.6.7" + }, + "numexpr-2.6.7-py37h00253c6_0.tar.bz2": { + "build": "py37h00253c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c7f77201636b6e18a2d7e100d3f80482", + "name": "numexpr", + "sha256": "c21219dacd16386e3c1ba9eeaea5403b1b0f87621806d127fd31ed51feaf84d4", + "size": 193411, + "subdir": "linux-64", + "timestamp": 1534174291159, + "version": "2.6.7" + }, + "numexpr-2.6.7-py37h6cfcb94_0.tar.bz2": { + "build": "py37h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5f0bfa257f889f3dadf930986cf5a638", + "name": "numexpr", + "sha256": "71aa7d699fa83bfa9224d7ef045493538ff8be7e707ec5d53ea0f0b81fcc5ec5", + "size": 193882, + "subdir": "linux-64", + "timestamp": 1534355398584, + "version": "2.6.7" + }, + "numexpr-2.6.7-py37h98f89e9_0.tar.bz2": { + "build": "py37h98f89e9_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8dd5fd81dc06ea4a8e793964e12dee86", + "name": "numexpr", + "sha256": "53f6159549187ef16c85f3046758d14e7c7b77def8b7852997bf04c9c48cedd4", + "size": 193990, + "subdir": "linux-64", + "timestamp": 1534174011221, + "version": "2.6.7" + }, + "numexpr-2.6.7-py37hedc7406_0.tar.bz2": { + "build": "py37hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6b606e3a6051baa39d2e8f7445016891", + "name": "numexpr", + "sha256": "7acda1b2a99d473f88443cc5bea86ebdf1be9c1921607edf649a7068f0980fba", + "size": 193479, + "subdir": "linux-64", + "timestamp": 1534355471547, + "version": "2.6.7" + }, + "numexpr-2.6.8-py27h2ffa06c_0.tar.bz2": { + "build": "py27h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "15868da735d3830654fdfcdb57c40c07", + "name": "numexpr", + "sha256": "69a041f830c11f2b270b7ca0da7fe1432c8c07d0f81687bcc046388c275f2e40", + "size": 193699, + "subdir": "linux-64", + "timestamp": 1536942981952, + "version": "2.6.8" + }, + "numexpr-2.6.8-py27h619cd38_0.tar.bz2": { + "build": "py27h619cd38_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "1f3f5ba5dd0d5f9840fc542e71dce0fc", + "name": "numexpr", + "sha256": "31532978b7d75b7cbfbfee81453031dca502a7236885ef5092823b8206f1a957", + "size": 192666, + "subdir": "linux-64", + "timestamp": 1535416750257, + "version": "2.6.8" + }, + "numexpr-2.6.8-py27h9e4a6bb_0.tar.bz2": { + "build": "py27h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.15.4,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5792339f5c548ed2853cd4ee61f8118c", + "name": "numexpr", + "sha256": "fcd7b7dd1085d257598a4e17725aab4f77bad315ff3aa90ddc50422b5e2cb726", + "size": 196823, + "subdir": "linux-64", + "timestamp": 1544745371266, + "version": "2.6.8" + }, + "numexpr-2.6.8-py27hd89afb7_0.tar.bz2": { + "build": "py27hd89afb7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5be00ced74985831d2d6bcfe44276c3d", + "name": "numexpr", + "sha256": "1b5dffb1874a87ed645f069893ee67593a6487cb177c0349e5a8f63ec9d9c2fc", + "size": 192244, + "subdir": "linux-64", + "timestamp": 1535413543360, + "version": "2.6.8" + }, + "numexpr-2.6.8-py35h2ffa06c_0.tar.bz2": { + "build": "py35h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "b22e88d91a4a0570ba99e99fb93fcec3", + "name": "numexpr", + "sha256": "c7212402dcdb7ce1d08738b83e80dbe0b39584216ebb325ba9b169597c0c4e20", + "size": 195782, + "subdir": "linux-64", + "timestamp": 1536943012575, + "version": "2.6.8" + }, + "numexpr-2.6.8-py35h619cd38_0.tar.bz2": { + "build": "py35h619cd38_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "874b8d5e8839da15294ac0a892392268", + "name": "numexpr", + "sha256": "e0287a769f1b69aa8cabb0daba2cf805fcf8b6f3e19336c7c7a2428445ddfe83", + "size": 194914, + "subdir": "linux-64", + "timestamp": 1535414277644, + "version": "2.6.8" + }, + "numexpr-2.6.8-py35hd89afb7_0.tar.bz2": { + "build": "py35hd89afb7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "2bd1616c8fc2cc6948c123661b39c577", + "name": "numexpr", + "sha256": "ced314d04ca21811fc9ba079458f8472ab2d65ef2b82ccbed30850f61ce8e1cd", + "size": 194576, + "subdir": "linux-64", + "timestamp": 1535416841930, + "version": "2.6.8" + }, + "numexpr-2.6.8-py36h2ffa06c_0.tar.bz2": { + "build": "py36h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "07c762dc6d3ff211f2693ed907abf32e", + "name": "numexpr", + "sha256": "8de769c547c1ecfb19a25350cb60f04a662de015d72a2ab473fc23d443d13444", + "size": 195468, + "subdir": "linux-64", + "timestamp": 1536942995618, + "version": "2.6.8" + }, + "numexpr-2.6.8-py36h619cd38_0.tar.bz2": { + "build": "py36h619cd38_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1d8f5be6d6bef6a603f9436bd42c2923", + "name": "numexpr", + "sha256": "ce0f2c23996dec11d5b5c575060674a8a20efb80f0b87706797219f4b14c87a4", + "size": 194507, + "subdir": "linux-64", + "timestamp": 1535413928805, + "version": "2.6.8" + }, + "numexpr-2.6.8-py36h9e4a6bb_0.tar.bz2": { + "build": "py36h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.15.4,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "812be7b253fb48e23bfcd09225049cad", + "name": "numexpr", + "sha256": "7ffcf641ab0f97607482c782c43bc92ef0be7300ce19d2113ae0f8ec09a2bcbb", + "size": 198790, + "subdir": "linux-64", + "timestamp": 1544745511037, + "version": "2.6.8" + }, + "numexpr-2.6.8-py36hd89afb7_0.tar.bz2": { + "build": "py36hd89afb7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4c78aa6c77dbe10b7bae63c3f90f1990", + "name": "numexpr", + "sha256": "d892eb78931c7e4f54a3381edca083b927f337c07475cdd049fcce9c744dad92", + "size": 194160, + "subdir": "linux-64", + "timestamp": 1535415129709, + "version": "2.6.8" + }, + "numexpr-2.6.8-py37h2ffa06c_0.tar.bz2": { + "build": "py37h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "9fb3d41e56fa2a7d2dc7874aa2f0c2e8", + "name": "numexpr", + "sha256": "d69da7d87b26a0c0ef29bce6ee11b542c3f59f728569829d5754ed86ce5745b2", + "size": 195598, + "subdir": "linux-64", + "timestamp": 1536942982196, + "version": "2.6.8" + }, + "numexpr-2.6.8-py37h619cd38_0.tar.bz2": { + "build": "py37h619cd38_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ae8853e0ef9e6502ad621549a0b9e26c", + "name": "numexpr", + "sha256": "7e6e56f350ee51bc09c8cfac7b147456da7931daadb01243d814d7fcf500f127", + "size": 194589, + "subdir": "linux-64", + "timestamp": 1535414265636, + "version": "2.6.8" + }, + "numexpr-2.6.8-py37h9e4a6bb_0.tar.bz2": { + "build": "py37h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.15.4,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e66b9dcc47aa56ca516ff5d8303316e8", + "name": "numexpr", + "sha256": "11e658be5dddedd44d8fb9770033e19faef18319a9b772198183b80f6f1ed2d8", + "size": 198890, + "subdir": "linux-64", + "timestamp": 1544745347483, + "version": "2.6.8" + }, + "numexpr-2.6.8-py37hd89afb7_0.tar.bz2": { + "build": "py37hd89afb7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e50d4af3ec7a68167232fef4602e093b", + "name": "numexpr", + "sha256": "767d605649d36133fca023a68da745abb1e20ac115cd2d58d7abd58ed04e1472", + "size": 194161, + "subdir": "linux-64", + "timestamp": 1535415186939, + "version": "2.6.8" + }, + "numexpr-2.6.9-py27h2ffa06c_0.tar.bz2": { + "build": "py27h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b95817e9b48fc07730d407fecfbd8b67", + "name": "numexpr", + "sha256": "1f3ddaf70209964d48177c089661998aaaf2a2852c6e44084174a74479c00bc0", + "size": 197484, + "subdir": "linux-64", + "timestamp": 1547241333036, + "version": "2.6.9" + }, + "numexpr-2.6.9-py27h9e4a6bb_0.tar.bz2": { + "build": "py27h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.15.4,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7cff5ecb3635f19314e26e4eedd286c9", + "name": "numexpr", + "sha256": "474d7e9f476c27d88c8ff059379f316d8f55087a0e9e73e0a6024891b198ff35", + "size": 197154, + "subdir": "linux-64", + "timestamp": 1547241659752, + "version": "2.6.9" + }, + "numexpr-2.6.9-py36h2ffa06c_0.tar.bz2": { + "build": "py36h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2c14a43b376063adc8e3d6741e9301d7", + "name": "numexpr", + "sha256": "05f02ed40db2afd9ab6d1f91d1b8ab2ccc0754c7421003b4c19c86e009afe340", + "size": 199373, + "subdir": "linux-64", + "timestamp": 1547241393424, + "version": "2.6.9" + }, + "numexpr-2.6.9-py36h9e4a6bb_0.tar.bz2": { + "build": "py36h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.15.4,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "fff48e098d6f6ba2d1460e0bff6d5010", + "name": "numexpr", + "sha256": "00199325b49d24b1a151a5de4f7a169db5c588211cb60a2bbc36a4f00ee598fe", + "size": 198974, + "subdir": "linux-64", + "timestamp": 1547241603321, + "version": "2.6.9" + }, + "numexpr-2.6.9-py37h2ffa06c_0.tar.bz2": { + "build": "py37h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d2fd659401d01ad3d3e144390986a2e7", + "name": "numexpr", + "sha256": "8392753f7a3e8504e2feafbae73094d6677e635c50376d0b321e554241f2876d", + "size": 199480, + "subdir": "linux-64", + "timestamp": 1547241409282, + "version": "2.6.9" + }, + "numexpr-2.6.9-py37h9e4a6bb_0.tar.bz2": { + "build": "py37h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.15.4,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1e5edab47a5c5c3e4d2a3ae832e2c4bf", + "name": "numexpr", + "sha256": "b44c88ea65074a0953897d33eca5e53ea14d49bedf35f211f9b6bc2b13eafcce", + "size": 199044, + "subdir": "linux-64", + "timestamp": 1547241570608, + "version": "2.6.9" + }, + "numexpr-2.7.0-py27h2ffa06c_0.tar.bz2": { + "build": "py27h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.4,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "a93c1549fd41a793b0188597b4323a2a", + "name": "numexpr", + "sha256": "a0f7416e75f28d3abdad888c41cd70db4101db3f3324837004fa88df91c80776", + "size": 198752, + "subdir": "linux-64", + "timestamp": 1565958459923, + "version": "2.7.0" + }, + "numexpr-2.7.0-py27h9e4a6bb_0.tar.bz2": { + "build": "py27h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.4,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "72dedf8e8bd5310720cd9028910d6a6c", + "name": "numexpr", + "sha256": "43181560699cb8e25b8ad8f13e81c27c9f6b8f4b490d904c7091546c78f02aee", + "size": 198355, + "subdir": "linux-64", + "timestamp": 1565959715865, + "version": "2.7.0" + }, + "numexpr-2.7.0-py36h22eb022_0.tar.bz2": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1c326f9143ab7c769d908844d97c8a3a", + "name": "numexpr", + "sha256": "06ea16dce664fcc9ceb3d78c20cf8e2fbb53499eee24df3c6636e7a699e083a8", + "size": 200389, + "subdir": "linux-64", + "timestamp": 1580251812345, + "version": "2.7.0" + }, + "numexpr-2.7.0-py36h2ffa06c_0.tar.bz2": { + "build": "py36h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.4,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c8fb41fc7724545268754c0bdcf48679", + "name": "numexpr", + "sha256": "0da89d3843dd2cdd20cf753ef17f87aa0578edf31330299f7e1d13e9af0046e8", + "size": 200611, + "subdir": "linux-64", + "timestamp": 1565959411572, + "version": "2.7.0" + }, + "numexpr-2.7.0-py36h9e4a6bb_0.tar.bz2": { + "build": "py36h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.4,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6913a8aa15ec315d133c6d0dbe4bea35", + "name": "numexpr", + "sha256": "8b54d2f87cc42e7e4f4a89d2849fe646ecb9477d055916b5ca959ee3a163b36c", + "size": 200400, + "subdir": "linux-64", + "timestamp": 1565959902187, + "version": "2.7.0" + }, + "numexpr-2.7.0-py36hd81dba3_0.tar.bz2": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "213fe39c0b0c436681d83a4ac08cbe3b", + "name": "numexpr", + "sha256": "4cc9fe1b4396a3a500f7ad85ecf275d8369443acc6632bdf3d8dfb10004d80b7", + "size": 200130, + "subdir": "linux-64", + "timestamp": 1580251889298, + "version": "2.7.0" + }, + "numexpr-2.7.0-py37h22eb022_0.tar.bz2": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f7a797bed421ac0ebaabb84ec34548e6", + "name": "numexpr", + "sha256": "cd7a7137783073cd2addd3120af0bdfd5e7383604fb3044bc786a24e0c5cdaff", + "size": 200583, + "subdir": "linux-64", + "timestamp": 1580251728317, + "version": "2.7.0" + }, + "numexpr-2.7.0-py37h2ffa06c_0.tar.bz2": { + "build": "py37h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.4,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "409fe51dd513c7d588eeea9f03f2e630", + "name": "numexpr", + "sha256": "963e9648c7c7b8d81e7c8cf9e13a9c39afb94f63a6bac1d3757e7d9e29f7eb07", + "size": 200798, + "subdir": "linux-64", + "timestamp": 1565959535406, + "version": "2.7.0" + }, + "numexpr-2.7.0-py37h9e4a6bb_0.tar.bz2": { + "build": "py37h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.4,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e4e6b72521ee0bd7aae6fca5d46df67f", + "name": "numexpr", + "sha256": "5ed3a3f80a0eaf3378565587779b60a14292a0dd27c106e4ccb2d3d23ac1ab75", + "size": 200272, + "subdir": "linux-64", + "timestamp": 1565959658323, + "version": "2.7.0" + }, + "numexpr-2.7.0-py37hd81dba3_0.tar.bz2": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e96e73356bdbc286d838ad13ba1ad102", + "name": "numexpr", + "sha256": "214a2e3b6074b0618b95a5d1bf310b49c5fbd85a37fd6e295e0c4dc95805c6d5", + "size": 200166, + "subdir": "linux-64", + "timestamp": 1580251876620, + "version": "2.7.0" + }, + "numexpr-2.7.0-py38h22eb022_0.tar.bz2": { + "build": "py38h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "8e6353e044084fdc351f1a735d85a531", + "name": "numexpr", + "sha256": "f8effe55f414096a544ef5fd34b97651828503ec77f120e5c8a6c0b4d7db797b", + "size": 201296, + "subdir": "linux-64", + "timestamp": 1580251760326, + "version": "2.7.0" + }, + "numexpr-2.7.0-py38h2ffa06c_0.tar.bz2": { + "build": "py38h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy-base >=1.17.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "1cfe08c3bedaccbb0a945898dbafc96e", + "name": "numexpr", + "sha256": "9f617ef7bc4da7dbcdb562d281d6bf636a34a3b18a0f2e10514c09d6abf1ace0", + "size": 205163, + "subdir": "linux-64", + "timestamp": 1573738369459, + "version": "2.7.0" + }, + "numexpr-2.7.0-py38h9e4a6bb_0.tar.bz2": { + "build": "py38h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.17.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "84e55ce190dd729208d453e488641c76", + "name": "numexpr", + "sha256": "2bbeaa19f443e53d251beb57c058f84a79960eba1271b072753c0eda6deca374", + "size": 204795, + "subdir": "linux-64", + "timestamp": 1573738323688, + "version": "2.7.0" + }, + "numexpr-2.7.0-py38hd81dba3_0.tar.bz2": { + "build": "py38hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "bde6a4285b99ec7b483c9ba248afd368", + "name": "numexpr", + "sha256": "7009c3822f8c9177b32233f5c35e3ca580b649079e77b4ebee37a66a1ba8d3a8", + "size": 200912, + "subdir": "linux-64", + "timestamp": 1580251969482, + "version": "2.7.0" + }, + "numexpr-2.7.1-py36h134e634_0.tar.bz2": { + "build": "py36h134e634_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f2174971a39221e74953802cfbccc5f7", + "name": "numexpr", + "sha256": "46659a6602dd1c2ca7905eb038eae59843612c50c22c6c3979ff1de22fa6f3e9", + "size": 202443, + "subdir": "linux-64", + "timestamp": 1607693818563, + "version": "2.7.1" + }, + "numexpr-2.7.1-py36h423224d_0.tar.bz2": { + "build": "py36h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c4893a8a3e8c231fca2a91f43c99f3bb", + "name": "numexpr", + "sha256": "bf8f2017342ad6271b95948c9ec777599f30188446d695280c3bfb1666030f1a", + "size": 201756, + "subdir": "linux-64", + "timestamp": 1580839244361, + "version": "2.7.1" + }, + "numexpr-2.7.1-py36h63df603_0.tar.bz2": { + "build": "py36h63df603_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "af3909b15558ab0279fbc765df293648", + "name": "numexpr", + "sha256": "41d24e1d3bed6be2831e3fa10013fabd075ef0d5a906e2fe37f93dd819f58141", + "size": 202141, + "subdir": "linux-64", + "timestamp": 1607693826600, + "version": "2.7.1" + }, + "numexpr-2.7.1-py36h7ea95a0_0.tar.bz2": { + "build": "py36h7ea95a0_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "aa6570bbef7e359ea5b2831fe32799f6", + "name": "numexpr", + "sha256": "4992b7d319bd30e4f3cbe3f8a7ca6a899c4246ebebda0869df8c916980f47f57", + "size": 202201, + "subdir": "linux-64", + "timestamp": 1580839142640, + "version": "2.7.1" + }, + "numexpr-2.7.1-py37h134e634_0.tar.bz2": { + "build": "py37h134e634_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "cd2f36b8ac06045ae4eb576be3bba0a9", + "name": "numexpr", + "sha256": "60c6e767828a3ef99326514dd3fde6cdff585b7de625edecdd0b8f0ba808e263", + "size": 202561, + "subdir": "linux-64", + "timestamp": 1607693820365, + "version": "2.7.1" + }, + "numexpr-2.7.1-py37h423224d_0.tar.bz2": { + "build": "py37h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e5d220d65b8bf1b1e48b916ba03f1711", + "name": "numexpr", + "sha256": "73b620c7fff41958699ab2fb0651ce1da6be8ab9cd7a4dd062908b27610cf5f9", + "size": 201914, + "subdir": "linux-64", + "timestamp": 1580839210804, + "version": "2.7.1" + }, + "numexpr-2.7.1-py37h63df603_0.tar.bz2": { + "build": "py37h63df603_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7bdeffa306e5125086ae6c7f45613d8d", + "name": "numexpr", + "sha256": "f2916c2677753a691da17cb66e67241809d2780c61cea6e7c5c06e2483f79399", + "size": 202218, + "subdir": "linux-64", + "timestamp": 1607693827040, + "version": "2.7.1" + }, + "numexpr-2.7.1-py37h7ea95a0_0.tar.bz2": { + "build": "py37h7ea95a0_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "272e9901e98e151dd9a7ca00d096956d", + "name": "numexpr", + "sha256": "a84a8df7efe05e133983c0ccc6c367fe130c456bbabf95fe40b526e36e3e944c", + "size": 202240, + "subdir": "linux-64", + "timestamp": 1580839178576, + "version": "2.7.1" + }, + "numexpr-2.7.1-py38h134e634_0.tar.bz2": { + "build": "py38h134e634_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "3bde3398f9ea63bd0218f9d0abd59b1b", + "name": "numexpr", + "sha256": "12697c321f78cab212b6a11c3ce21d26e6f1e8fe12bee4522ec817cf74f425c9", + "size": 203402, + "subdir": "linux-64", + "timestamp": 1607693841113, + "version": "2.7.1" + }, + "numexpr-2.7.1-py38h423224d_0.tar.bz2": { + "build": "py38h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "9758f75b32202c80ae5802e989e5d63b", + "name": "numexpr", + "sha256": "de1cf71bf67021fa6f53959d1069e37a22e269c5a77bcc568b0e41a99cc526f4", + "size": 202596, + "subdir": "linux-64", + "timestamp": 1580839235989, + "version": "2.7.1" + }, + "numexpr-2.7.1-py38h63df603_0.tar.bz2": { + "build": "py38h63df603_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "33d0bf74e33b9f5f151fb6f8b106495c", + "name": "numexpr", + "sha256": "0627c6ec5da454cfb97818db1f15bfcfa626c20d185147ba4205acc1e601455a", + "size": 202955, + "subdir": "linux-64", + "timestamp": 1607693838018, + "version": "2.7.1" + }, + "numexpr-2.7.1-py38h7ea95a0_0.tar.bz2": { + "build": "py38h7ea95a0_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "ccfa7f5409be6f36d920523c3cf0470d", + "name": "numexpr", + "sha256": "dc4e5a5edd7ea5b2b1eae469cd88fce38691383c7e853f807046b58482b55fbb", + "size": 203023, + "subdir": "linux-64", + "timestamp": 1580839194871, + "version": "2.7.1" + }, + "numexpr-2.7.1-py39h134e634_0.tar.bz2": { + "build": "py39h134e634_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "21d32b08224acddc9bf163f2749f39b8", + "name": "numexpr", + "sha256": "0024ddaf2ca77970eadd9c947d221340e692fd601557ff22dd725f5c963d4ad8", + "size": 201079, + "subdir": "linux-64", + "timestamp": 1607693831114, + "version": "2.7.1" + }, + "numexpr-2.7.1-py39h63df603_0.tar.bz2": { + "build": "py39h63df603_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "b3664d8c54c03b163829f8a441cdd929", + "name": "numexpr", + "sha256": "79bbb867341757f7bd3786c689f631a013e91204529957d7376d43e82fe6f0ad", + "size": 199950, + "subdir": "linux-64", + "timestamp": 1607693829865, + "version": "2.7.1" + }, + "numexpr-2.7.2-py36h4be448d_0.tar.bz2": { + "build": "py36h4be448d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "212c5a9eaec06c4c710de44d3df4c794", + "name": "numexpr", + "sha256": "b2f764596485dac57e3ae344ad6b39a0fda1c4a4803f285db2837f6748b3ed9a", + "size": 199408, + "subdir": "linux-64", + "timestamp": 1609354703309, + "version": "2.7.2" + }, + "numexpr-2.7.2-py36hb2eb853_0.tar.bz2": { + "build": "py36hb2eb853_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7f691b9f482408587dfdf2718ec95aef", + "name": "numexpr", + "sha256": "5ffebbad5736cee1e7b9281f3c6b35992c470069178be1a5aa89cc2ca3337b66", + "size": 199172, + "subdir": "linux-64", + "timestamp": 1609354711703, + "version": "2.7.2" + }, + "numexpr-2.7.2-py37h4be448d_0.tar.bz2": { + "build": "py37h4be448d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f6948311b2be61b505aa2ba7b85687c2", + "name": "numexpr", + "sha256": "759513c74ddf44d797c2c955f548d42f15750191f1e2f536e33b36c9094a0878", + "size": 199518, + "subdir": "linux-64", + "timestamp": 1609354703903, + "version": "2.7.2" + }, + "numexpr-2.7.2-py37hb2eb853_0.tar.bz2": { + "build": "py37hb2eb853_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "13c3d4d5123ed4432df41728f1b32728", + "name": "numexpr", + "sha256": "c2e8ba41f362a25c6efbf9e66d54b094b2cb514cabdcf8029a308e37850a2127", + "size": 199175, + "subdir": "linux-64", + "timestamp": 1609354679943, + "version": "2.7.2" + }, + "numexpr-2.7.2-py38h4be448d_0.tar.bz2": { + "build": "py38h4be448d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "53ae7acc0d37ab95727cfec159a38011", + "name": "numexpr", + "sha256": "a2ab067cc4e5e42d6d9a05e64b70ffc4e832fa03dc47919b7e7e81c70187bef7", + "size": 200215, + "subdir": "linux-64", + "timestamp": 1609354670825, + "version": "2.7.2" + }, + "numexpr-2.7.2-py38hb2eb853_0.tar.bz2": { + "build": "py38hb2eb853_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "2f66ba428482052c6b4d8f888ae9a0c6", + "name": "numexpr", + "sha256": "0324f0542ae06ff10ac3c2da9b5a80a5ac13bfe7d79347f09e970a6d6a1fe600", + "size": 200050, + "subdir": "linux-64", + "timestamp": 1609354741932, + "version": "2.7.2" + }, + "numexpr-2.7.2-py39h4be448d_0.tar.bz2": { + "build": "py39h4be448d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "57a8581eb9ac5c3844557dd22722386a", + "name": "numexpr", + "sha256": "9931902867d0e46117b5fbfab7bc798065a1005e6ae5fa627e210acea6670734", + "size": 198066, + "subdir": "linux-64", + "timestamp": 1609354701682, + "version": "2.7.2" + }, + "numexpr-2.7.2-py39hb2eb853_0.tar.bz2": { + "build": "py39hb2eb853_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "d9d32cb24cafcf6a23cd3ff80839cabc", + "name": "numexpr", + "sha256": "3fe65eaeb520756895d5a10b157c743fcf13c4d40e1555cccb4270be904ac703", + "size": 196832, + "subdir": "linux-64", + "timestamp": 1609354727405, + "version": "2.7.2" + }, + "numexpr-2.7.3-py310hd732450_1.tar.bz2": { + "build": "py310hd732450_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "15601802201565b422c212a6f1ee79e5", + "name": "numexpr", + "sha256": "9b1a3e57ea29f06538e8d284a398ef9b81b416ab84166e066256e77fbedd0c4e", + "size": 453854, + "subdir": "linux-64", + "timestamp": 1640792037686, + "version": "2.7.3" + }, + "numexpr-2.7.3-py310hfd7a2a2_1.tar.bz2": { + "build": "py310hfd7a2a2_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "05e76a8529e59906ff1d44b2e5bf77c9", + "name": "numexpr", + "sha256": "b3e21b8c598835c4a5594098bb0459f80b13731cc44f16442ffeb7ce143e519e", + "size": 453729, + "subdir": "linux-64", + "timestamp": 1640792004468, + "version": "2.7.3" + }, + "numexpr-2.7.3-py36h22e1b3c_1.tar.bz2": { + "build": "py36h22e1b3c_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ee33a04bc680526a3cd5325cc2bf3c53", + "name": "numexpr", + "sha256": "c1787c99e4863458c4dddb273d46e562406f9b9d2f129d36400cfb9653c12a1f", + "size": 203914, + "subdir": "linux-64", + "timestamp": 1618856649034, + "version": "2.7.3" + }, + "numexpr-2.7.3-py36h4be448d_0.tar.bz2": { + "build": "py36h4be448d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "dad5ee986f550773274527f738cf62ec", + "name": "numexpr", + "sha256": "ee75425bed625ba95fa58104e430b47c56129acc17817fc12f395dd31bd38163", + "size": 200396, + "subdir": "linux-64", + "timestamp": 1614797290882, + "version": "2.7.3" + }, + "numexpr-2.7.3-py36h4be448d_1.tar.bz2": { + "build": "py36h4be448d_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2e0106c2ed7e0e24aa6b7d3b73eb1493", + "name": "numexpr", + "sha256": "6737d13eba2610b1e1be10fdf0cb6718fe0ce8b0829ec5edf95f4afde372cba7", + "size": 204181, + "subdir": "linux-64", + "timestamp": 1618853264127, + "version": "2.7.3" + }, + "numexpr-2.7.3-py36hb2eb853_0.tar.bz2": { + "build": "py36hb2eb853_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "eb3c124a67d9bc4654cd93aceb7153a1", + "name": "numexpr", + "sha256": "7081428ba8fc5dded448e61531055d2e98c72ef97c4cfe91e0703e90cebf0768", + "size": 200236, + "subdir": "linux-64", + "timestamp": 1614798606172, + "version": "2.7.3" + }, + "numexpr-2.7.3-py37h22e1b3c_1.tar.bz2": { + "build": "py37h22e1b3c_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "802a5ba426017fd9099b9d12840eea15", + "name": "numexpr", + "sha256": "71a71662cffe47ef60205de22595985721d75f81da4fb96c35657d718fcf24c0", + "size": 204040, + "subdir": "linux-64", + "timestamp": 1618856649024, + "version": "2.7.3" + }, + "numexpr-2.7.3-py37h4be448d_0.tar.bz2": { + "build": "py37h4be448d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f1f42b32d7f67d8412824c8ba3c91fcc", + "name": "numexpr", + "sha256": "63c802836f98d751f7d3562f336c722814c73cbc2860085f4edb023064579a03", + "size": 200425, + "subdir": "linux-64", + "timestamp": 1614798586381, + "version": "2.7.3" + }, + "numexpr-2.7.3-py37h4be448d_1.tar.bz2": { + "build": "py37h4be448d_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "23c7ab48f508ae73025e5003e10eb6c9", + "name": "numexpr", + "sha256": "05b0a359ece8ad23e690492f272910158518dce6822dd0617558cc2ee21f47fc", + "size": 204287, + "subdir": "linux-64", + "timestamp": 1618856601430, + "version": "2.7.3" + }, + "numexpr-2.7.3-py37hb2eb853_0.tar.bz2": { + "build": "py37hb2eb853_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "351560d191ce1914952304a9cf9f7135", + "name": "numexpr", + "sha256": "a598191d087d550cfd47cab04d1b24775681e71aa636f45647dd8844638e4379", + "size": 200263, + "subdir": "linux-64", + "timestamp": 1614798606801, + "version": "2.7.3" + }, + "numexpr-2.7.3-py38h22e1b3c_1.tar.bz2": { + "build": "py38h22e1b3c_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "0779facbb2c02de5085ffa3588da5a11", + "name": "numexpr", + "sha256": "1ca5c185955dceea8add51a63321453040d0a5143024eb54b970153b1a1e2adc", + "size": 204800, + "subdir": "linux-64", + "timestamp": 1618856281691, + "version": "2.7.3" + }, + "numexpr-2.7.3-py38h4be448d_0.tar.bz2": { + "build": "py38h4be448d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "0c5d5e07b88ec606223f789286232cf9", + "name": "numexpr", + "sha256": "d6428141ac9dc3d06abe1cc4e343008215cee7c76f392e167db3a6fad694fafd", + "size": 201215, + "subdir": "linux-64", + "timestamp": 1614798587769, + "version": "2.7.3" + }, + "numexpr-2.7.3-py38h4be448d_1.tar.bz2": { + "build": "py38h4be448d_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "6b15fe65ff42ad8dc93df65d32217a12", + "name": "numexpr", + "sha256": "653b2abd68c53f109d48d350c91190a5b5ff6f0368910f0efa1ec9a3ed91ba65", + "size": 205070, + "subdir": "linux-64", + "timestamp": 1618856595172, + "version": "2.7.3" + }, + "numexpr-2.7.3-py38hb2eb853_0.tar.bz2": { + "build": "py38hb2eb853_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "719146a04c25a6fb1b340ec111c651bc", + "name": "numexpr", + "sha256": "6264f0c1286ed1656cad8daa795d9724507c3a1dc16127e3f49f5c1c5fec287b", + "size": 200984, + "subdir": "linux-64", + "timestamp": 1614798586990, + "version": "2.7.3" + }, + "numexpr-2.7.3-py39h22e1b3c_1.tar.bz2": { + "build": "py39h22e1b3c_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "b3ab8ed268fb50c4f9b833891d796d21", + "name": "numexpr", + "sha256": "106c506740414d9497af7029ff8bab936e2fdc7d27047a1f1176e5bbe157ce2d", + "size": 201755, + "subdir": "linux-64", + "timestamp": 1618856659098, + "version": "2.7.3" + }, + "numexpr-2.7.3-py39h4be448d_0.tar.bz2": { + "build": "py39h4be448d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "6dccf0421ae75c6b7370f182045b1517", + "name": "numexpr", + "sha256": "28f3f69709418f86a5d5f3b2c0846c3d6b0cc6eac01dba2cd0a2b628b1cc6bba", + "size": 198928, + "subdir": "linux-64", + "timestamp": 1614798567566, + "version": "2.7.3" + }, + "numexpr-2.7.3-py39h4be448d_1.tar.bz2": { + "build": "py39h4be448d_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "deb6b8702283e2063a39502755b4afbb", + "name": "numexpr", + "sha256": "945b650d64372fde7ec913b651c7c9ab46466cf3e577162e86a9b888775389a8", + "size": 202830, + "subdir": "linux-64", + "timestamp": 1618856233103, + "version": "2.7.3" + }, + "numexpr-2.7.3-py39hb2eb853_0.tar.bz2": { + "build": "py39hb2eb853_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "2209ae34e38b8a139e31bb71f7751e05", + "name": "numexpr", + "sha256": "a0c660f737b65728d789ac651b45b79c99d8aca24eebb201e4bc0669899abed7", + "size": 197899, + "subdir": "linux-64", + "timestamp": 1614798573440, + "version": "2.7.3" + }, + "numexpr-2.8.1-py310h757a811_1.tar.bz2": { + "build": "py310h757a811_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "638d798b6532b590d380b9da85f2ac35", + "name": "numexpr", + "sha256": "5581e80350d1e9e55af62eecb0000a139e3c5c7b314b8455744e9a36f7ad36a2", + "size": 403081, + "subdir": "linux-64", + "timestamp": 1656068790927, + "version": "2.8.1" + }, + "numexpr-2.8.1-py310h757a811_2.tar.bz2": { + "build": "py310h757a811_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18f0a88964bcaf1ee95db80a8c696b37", + "name": "numexpr", + "sha256": "620036b1952025e804d2bc7f4ca419536ea7e709ca8c59b07903a8fca7ece8bb", + "size": 398789, + "subdir": "linux-64", + "timestamp": 1656072358446, + "version": "2.8.1" + }, + "numexpr-2.8.1-py310hcea2de6_1.tar.bz2": { + "build": "py310hcea2de6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2af5321e0f219cf6beaf7c921cebc162", + "name": "numexpr", + "sha256": "4cbf42cfd2cfaf7fc40fe2391bd6c15c056b8af2e5a92a7a3f5e986d064154e4", + "size": 403533, + "subdir": "linux-64", + "timestamp": 1656068602954, + "version": "2.8.1" + }, + "numexpr-2.8.1-py310hcea2de6_2.tar.bz2": { + "build": "py310hcea2de6_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7260f3d1d4cb0f2644b858e16c85997f", + "name": "numexpr", + "sha256": "a18258d47abcf8ce367ade41b1a8959e31759089cda536614988571abeb0578e", + "size": 398841, + "subdir": "linux-64", + "timestamp": 1656072175861, + "version": "2.8.1" + }, + "numexpr-2.8.1-py37h6abb31d_0.tar.bz2": { + "build": "py37h6abb31d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "236313dfbfe2ca8a23f8bcd7b3cefb26", + "name": "numexpr", + "sha256": "3f46817092409120a87fcd958fdcccde563f5616841ed5f7d41ef38089225912", + "size": 136297, + "subdir": "linux-64", + "timestamp": 1640704262878, + "version": "2.8.1" + }, + "numexpr-2.8.1-py37h807cd23_1.tar.bz2": { + "build": "py37h807cd23_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d910d292700c03921b9d1eb3a27eefad", + "name": "numexpr", + "sha256": "f1a785a375f2d654714718ca2949674e006bf21255dc1f6fb417ec74f308ee47", + "size": 132971, + "subdir": "linux-64", + "timestamp": 1656068491025, + "version": "2.8.1" + }, + "numexpr-2.8.1-py37h807cd23_2.tar.bz2": { + "build": "py37h807cd23_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7845c42e4675bb6abda770d6c62058d0", + "name": "numexpr", + "sha256": "5e01ff7ab17c60b554c99dbd76f7cf8cf004e5e07d06a665938d9029d01d3700", + "size": 132986, + "subdir": "linux-64", + "timestamp": 1656072016955, + "version": "2.8.1" + }, + "numexpr-2.8.1-py37hd2a5715_1.tar.bz2": { + "build": "py37hd2a5715_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dcf53d0d2d5edb4744b83249bf4db3ee", + "name": "numexpr", + "sha256": "f4e2344eae1249f60db70564f657b45e3c9a3bb6d06e114dd62448c98e5d4f00", + "size": 133111, + "subdir": "linux-64", + "timestamp": 1656068696370, + "version": "2.8.1" + }, + "numexpr-2.8.1-py37hd2a5715_2.tar.bz2": { + "build": "py37hd2a5715_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba6a903889067a3dc7ba65eb65b85f8f", + "name": "numexpr", + "sha256": "58947ae9c06daad90dda774d7edc0d6122990256781833f46739dd1807b64745", + "size": 132928, + "subdir": "linux-64", + "timestamp": 1656072221842, + "version": "2.8.1" + }, + "numexpr-2.8.1-py37hecfb737_0.tar.bz2": { + "build": "py37hecfb737_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4da91ffcb100bd920d782dac16565ac3", + "name": "numexpr", + "sha256": "82b27f6da725d7e371e27f02a8d628596f0ab617990f75695861bb895a32c4b2", + "size": 136216, + "subdir": "linux-64", + "timestamp": 1640686140004, + "version": "2.8.1" + }, + "numexpr-2.8.1-py38h6abb31d_0.tar.bz2": { + "build": "py38h6abb31d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2eca95d6ee550a5e314de57b46413961", + "name": "numexpr", + "sha256": "70b437d6697ff0ad278e948e915576380f58c3ba1b799d1d45a9ad780fff1fed", + "size": 136950, + "subdir": "linux-64", + "timestamp": 1640704277727, + "version": "2.8.1" + }, + "numexpr-2.8.1-py38h807cd23_1.tar.bz2": { + "build": "py38h807cd23_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4ffc27f05b93000975fb415b5a48e0c", + "name": "numexpr", + "sha256": "1b6e7b254c3e714873798ea48e45f177bff32bb18a005a26aeaeb08cc9051f8b", + "size": 133614, + "subdir": "linux-64", + "timestamp": 1656068540072, + "version": "2.8.1" + }, + "numexpr-2.8.1-py38h807cd23_2.tar.bz2": { + "build": "py38h807cd23_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d81444bbd2b61262d1d40f3abc0374ca", + "name": "numexpr", + "sha256": "4782440b022b7fa93604782e2cf8b13aca620a4fdc6c417e6f0d3e7743a20176", + "size": 133524, + "subdir": "linux-64", + "timestamp": 1656072114413, + "version": "2.8.1" + }, + "numexpr-2.8.1-py38hd2a5715_1.tar.bz2": { + "build": "py38hd2a5715_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "644d04f8423827613f9a4b5229aed1c4", + "name": "numexpr", + "sha256": "15472e86b0ff8f3025d79216a0008c4a9d863e4a934a01c7d3c5201b726d2781", + "size": 133572, + "subdir": "linux-64", + "timestamp": 1656068743081, + "version": "2.8.1" + }, + "numexpr-2.8.1-py38hd2a5715_2.tar.bz2": { + "build": "py38hd2a5715_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "afb99a15af2da88eda622c5047d52e20", + "name": "numexpr", + "sha256": "d47e746d27581857b271cea8f4de5b7862e9da450416f461baadb1b1dbb5e922", + "size": 133419, + "subdir": "linux-64", + "timestamp": 1656072313413, + "version": "2.8.1" + }, + "numexpr-2.8.1-py38hecfb737_0.tar.bz2": { + "build": "py38hecfb737_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d9a27e4a145a4ceda78560a6b0d1576", + "name": "numexpr", + "sha256": "8696aca250a3571137e5929025439ee181d078802c0b81115624443b2124a1d5", + "size": 136782, + "subdir": "linux-64", + "timestamp": 1640704258852, + "version": "2.8.1" + }, + "numexpr-2.8.1-py39h6abb31d_0.tar.bz2": { + "build": "py39h6abb31d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5239d8330e8bd34972fb80918dce79e7", + "name": "numexpr", + "sha256": "15a12c8bebcda45c577e61cea412d9aafaa433e39f9e91fd61bbfab66fcee3ab", + "size": 136437, + "subdir": "linux-64", + "timestamp": 1640689905588, + "version": "2.8.1" + }, + "numexpr-2.8.1-py39h807cd23_1.tar.bz2": { + "build": "py39h807cd23_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f924b4fd4bce20ad39e01eec69297b7e", + "name": "numexpr", + "sha256": "8e3c2d96eb04f9f9e3014b1ee54feb9fbbb8b5bf8dcb525beb247cff6b99d361", + "size": 132955, + "subdir": "linux-64", + "timestamp": 1656068439979, + "version": "2.8.1" + }, + "numexpr-2.8.1-py39h807cd23_2.tar.bz2": { + "build": "py39h807cd23_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "675d8564ee3b8f4b7bc4bddfdde62673", + "name": "numexpr", + "sha256": "5ee29b775636becbd4d5b8248398523060988d80ee1bfc393e36d0fdcbfe54d9", + "size": 132950, + "subdir": "linux-64", + "timestamp": 1656072066283, + "version": "2.8.1" + }, + "numexpr-2.8.1-py39hd2a5715_1.tar.bz2": { + "build": "py39hd2a5715_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eff44c87b4fb6b96d48a8fa90dd95c87", + "name": "numexpr", + "sha256": "5c176616665d74d45d3c24a41319e146e4c6a5d3319424bbc4e6bfdd4662baf5", + "size": 132966, + "subdir": "linux-64", + "timestamp": 1656068649547, + "version": "2.8.1" + }, + "numexpr-2.8.1-py39hd2a5715_2.tar.bz2": { + "build": "py39hd2a5715_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2bd42b4526fbbc02532778563447d731", + "name": "numexpr", + "sha256": "3ff1513c22e6ec4b8ec61ace50cb8de40483793bd0d92d83adbca5317236a1b3", + "size": 133001, + "subdir": "linux-64", + "timestamp": 1656072267467, + "version": "2.8.1" + }, + "numexpr-2.8.1-py39hecfb737_0.tar.bz2": { + "build": "py39hecfb737_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f3e22d3bd56b48132ed87bdf834afc8", + "name": "numexpr", + "sha256": "1e6b55245118668c9c42b8cec9171ccc18f8b874b813bbb6cc4dd926feeb9da1", + "size": 136396, + "subdir": "linux-64", + "timestamp": 1640689891396, + "version": "2.8.1" + }, + "numexpr-2.8.3-py310h757a811_0.tar.bz2": { + "build": "py310h757a811_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c971dbca826b88cbf74ddec2dca31b24", + "name": "numexpr", + "sha256": "94106f3c7be1796e4b55c70d42d1c6ba37b68c6ad6d7480dcbb40f1706db8f25", + "size": 406879, + "subdir": "linux-64", + "timestamp": 1656940629161, + "version": "2.8.3" + }, + "numexpr-2.8.3-py310hcea2de6_0.tar.bz2": { + "build": "py310hcea2de6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b04e3a837a747406bbad17a42e080a2", + "name": "numexpr", + "sha256": "ddb5d146c7fbee3cfb88c735fd4fbd53128b6bf01a4b417c202e8b05bd0783ae", + "size": 406733, + "subdir": "linux-64", + "timestamp": 1656940434352, + "version": "2.8.3" + }, + "numexpr-2.8.3-py311h802d673_0.tar.bz2": { + "build": "py311h802d673_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.22.3,<2.0a0", + "packaging", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8e66724e3ca66dfe78008d60a8b6ce1", + "name": "numexpr", + "sha256": "d8ff2bb644550b97ae2cae54b8edb515be958e27f9420c8645fa7801e05fb872", + "size": 162024, + "subdir": "linux-64", + "timestamp": 1676828163518, + "version": "2.8.3" + }, + "numexpr-2.8.3-py311hd846eea_0.tar.bz2": { + "build": "py311hd846eea_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "packaging", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37246c8f5e0ec16bd3618f4beb4daef4", + "name": "numexpr", + "sha256": "3047f74b7dd8822b200d162660d74ad314e78edf07271d8399ded40a8b439f75", + "size": 162195, + "subdir": "linux-64", + "timestamp": 1676828145252, + "version": "2.8.3" + }, + "numexpr-2.8.3-py37h807cd23_0.tar.bz2": { + "build": "py37h807cd23_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a74dcbeaca860b17e958b967b0ac4ab5", + "name": "numexpr", + "sha256": "dccaeaadf26f854fd038eae633f499e0e1f9be55ce3c43e3ddeb765b92fbcc62", + "size": 135734, + "subdir": "linux-64", + "timestamp": 1656940534830, + "version": "2.8.3" + }, + "numexpr-2.8.3-py37hd2a5715_0.tar.bz2": { + "build": "py37hd2a5715_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c51ca3aff8085448cd0f3129883d8c2", + "name": "numexpr", + "sha256": "5e8eb272905afe506aa7445ed68c7db135ce563fe4180238f574034a927d8ffc", + "size": 135664, + "subdir": "linux-64", + "timestamp": 1656940721412, + "version": "2.8.3" + }, + "numexpr-2.8.3-py38h807cd23_0.tar.bz2": { + "build": "py38h807cd23_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "154540c33deac08567cee0118fa5336f", + "name": "numexpr", + "sha256": "821210b3bddc6367a4d323e0a7bbbb227f2500f5e0f96a5f75659e2dc74a99df", + "size": 136372, + "subdir": "linux-64", + "timestamp": 1656940372231, + "version": "2.8.3" + }, + "numexpr-2.8.3-py38hd2a5715_0.tar.bz2": { + "build": "py38hd2a5715_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f1d5bd855aa891657c0df7c4491adab", + "name": "numexpr", + "sha256": "88499bd9e7582abec9b0ee74e06552bb3a0c4c79fc5b86809d1a19149b93ba25", + "size": 136143, + "subdir": "linux-64", + "timestamp": 1656940581465, + "version": "2.8.3" + }, + "numexpr-2.8.3-py39h807cd23_0.tar.bz2": { + "build": "py39h807cd23_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1311a50c9addcc1960bb6d5a8dda9d7", + "name": "numexpr", + "sha256": "9fd41a9b0456d1526e2b59f0f5ce25630166d5f7cbf8361856f0e1e816d53d9e", + "size": 135652, + "subdir": "linux-64", + "timestamp": 1656940484765, + "version": "2.8.3" + }, + "numexpr-2.8.3-py39hd2a5715_0.tar.bz2": { + "build": "py39hd2a5715_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "854304a1c6108c9536816d55577d7fe0", + "name": "numexpr", + "sha256": "8a96b9139380399729a8601a9c7f423a07207c9ad891d03c937a827fd8241ae0", + "size": 135563, + "subdir": "linux-64", + "timestamp": 1656940674781, + "version": "2.8.3" + }, + "numexpr-2.8.4-py310h757a811_0.tar.bz2": { + "build": "py310h757a811_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3baa759ce28cef24f8b029e3d6ed50c", + "name": "numexpr", + "sha256": "41a4970478045c74abf015644cb2ca994353fb6f45d7b53c8bb02e1349ccaa53", + "size": 136993, + "subdir": "linux-64", + "timestamp": 1668713944803, + "version": "2.8.4" + }, + "numexpr-2.8.4-py310h8879344_0.tar.bz2": { + "build": "py310h8879344_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "94264876f670fbea509623251295d00b", + "name": "numexpr", + "sha256": "dedbb7f8be8234c3f22fd05b001261414e2df364290e4ee28966aaa07ae01df4", + "size": 137034, + "subdir": "linux-64", + "timestamp": 1668714138771, + "version": "2.8.4" + }, + "numexpr-2.8.4-py311h802d673_0.tar.bz2": { + "build": "py311h802d673_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.22.3,<2.0a0", + "packaging", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5ade3029bdbe03f57036514d46e7d7b", + "name": "numexpr", + "sha256": "527caea07b1dba40477f97f76cd68dec49baae85279e665a738881869c892714", + "size": 162808, + "subdir": "linux-64", + "timestamp": 1679336725499, + "version": "2.8.4" + }, + "numexpr-2.8.4-py311hd846eea_0.tar.bz2": { + "build": "py311hd846eea_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "packaging", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f39b11ebedb4e12da2f2aa54c45d9e4f", + "name": "numexpr", + "sha256": "72b5ff547e26a7dbefe3fb5ad05596906a5fa42f4fbae871881620d574b6cd56", + "size": 162776, + "subdir": "linux-64", + "timestamp": 1679336696405, + "version": "2.8.4" + }, + "numexpr-2.8.4-py37hd2a5715_0.tar.bz2": { + "build": "py37hd2a5715_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "593b8427cc41df26f8e6a08e4a5de8ba", + "name": "numexpr", + "sha256": "eb8f1f224edd9518a2d085e3035a7cabc037b1c9432b8b9c661ca314a22d6b89", + "size": 136185, + "subdir": "linux-64", + "timestamp": 1668713992619, + "version": "2.8.4" + }, + "numexpr-2.8.4-py37he184ba9_0.tar.bz2": { + "build": "py37he184ba9_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f224eb5e4f3daf00302033bdf23a1379", + "name": "numexpr", + "sha256": "23508651f80b4f8a6968398f65cb3b624577575acc678b0c0309c8e351f5d53b", + "size": 136207, + "subdir": "linux-64", + "timestamp": 1668714187272, + "version": "2.8.4" + }, + "numexpr-2.8.4-py38hd2a5715_0.tar.bz2": { + "build": "py38hd2a5715_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c76ede805bdb81b1ef3044aeb409f210", + "name": "numexpr", + "sha256": "ea3a7b86eeece7e01ee1c204384b20fe145cb645c39b66b27e708824866d1bc1", + "size": 136691, + "subdir": "linux-64", + "timestamp": 1668714088102, + "version": "2.8.4" + }, + "numexpr-2.8.4-py38he184ba9_0.tar.bz2": { + "build": "py38he184ba9_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c7c4480b9a5dae9590d82da493c62af", + "name": "numexpr", + "sha256": "6bee314fffcbe8dd3d4f98f2ba57d94e6ad3f91ed9f9baa1dda4daf63690e4ed", + "size": 136743, + "subdir": "linux-64", + "timestamp": 1668714284675, + "version": "2.8.4" + }, + "numexpr-2.8.4-py39hd2a5715_0.tar.bz2": { + "build": "py39hd2a5715_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "953f88e447b7e93bfd42feaec9c018e1", + "name": "numexpr", + "sha256": "8e1d28c47030cb5f19147d6320dc48579aa002eb56057e33998e7019e38e6bc3", + "size": 136065, + "subdir": "linux-64", + "timestamp": 1668714040294, + "version": "2.8.4" + }, + "numexpr-2.8.4-py39he184ba9_0.tar.bz2": { + "build": "py39he184ba9_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d337a090ad218953b0ca70b656c01f1f", + "name": "numexpr", + "sha256": "047a6452ea87d3cd40e3e59343b7775b0b7733977edfa1abed3dde16a3116485", + "size": 136141, + "subdir": "linux-64", + "timestamp": 1668714235894, + "version": "2.8.4" + }, + "numpy-1.11.3-py27h1b885b7_8.tar.bz2": { + "build": "py27h1b885b7_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27hdbf6ddf_8", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "59a08a48752ade87ab6597731ba6235b", + "name": "numpy", + "sha256": "4bcd81c7bc5c816dcf022e1152a7af6abb792d0200a80246dc9a14a74b0a8813", + "size": 10288, + "subdir": "linux-64", + "timestamp": 1530724249473, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h1b885b7_9.tar.bz2": { + "build": "py27h1b885b7_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27h3dfced4_9", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2d36c2e6d81bc410055e1d78d77538ab", + "name": "numpy", + "sha256": "126217adbec75c50f7044ad636cac6a7ea796df83a5e5c1a8d59744886ddbe6d", + "size": 10507, + "subdir": "linux-64", + "timestamp": 1532661314859, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h1d66e8a_10.tar.bz2": { + "build": "py27h1d66e8a_10", + "build_number": 10, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py27h81de0dd_10", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a505761ee062e4a99533965c2e02800f", + "name": "numpy", + "sha256": "780cfd692ca97923a6b885473cdff32b38bd618920710a84a3c0d3876beb4ae9", + "size": 10923, + "subdir": "linux-64", + "timestamp": 1535405816018, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h28100ab_7.tar.bz2": { + "build": "py27h28100ab_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27h2b20989_7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ffdd252acf526d961fe7db62cf18ff7c", + "name": "numpy", + "sha256": "adbeb677fe310ea7dd599ffca6157368219ab48e133f9458fb424a42bdfa7405", + "size": 10582, + "subdir": "linux-64", + "timestamp": 1530380848462, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h28100ab_8.tar.bz2": { + "build": "py27h28100ab_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27h2b20989_8", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6fc92e569a810cd6b4c10a79c78d8133", + "name": "numpy", + "sha256": "01631d244bc29636badf62bae2161532f3b406c0624287ead3ee85a751818aec", + "size": 10973, + "subdir": "linux-64", + "timestamp": 1530550938484, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h2aefc1b_8.tar.bz2": { + "build": "py27h2aefc1b_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27h2b20989_8", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a40896bec3b61ffaa339ed22a000dceb", + "name": "numpy", + "sha256": "d126927c4dd20024f1220468fed5a7d2241d9c3ca2201e47488411fa9871c622", + "size": 10291, + "subdir": "linux-64", + "timestamp": 1530723986577, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h2aefc1b_9.tar.bz2": { + "build": "py27h2aefc1b_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27h7cdd4dd_9", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1ac759a09908aa7f3279008a1fe2072b", + "name": "numpy", + "sha256": "5dd69d80184585aa4e61841a572abc5d95fe012df40b22c832b8a33e0bbdbcff", + "size": 10513, + "subdir": "linux-64", + "timestamp": 1532660216708, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h3b04361_9.tar.bz2": { + "build": "py27h3b04361_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27h81de0dd_9", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4309d082727d3fe7d3dd9d718d81b6cf", + "name": "numpy", + "sha256": "d38c7533299124ed490bd37055e5ffc31c17357a08c1bf29ebcbdc232342ef3e", + "size": 10838, + "subdir": "linux-64", + "timestamp": 1535389047457, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h3dfced4_4.tar.bz2": { + "build": "py27h3dfced4_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "96b124a55cbcbc7b0a119999bb8907ff", + "name": "numpy", + "sha256": "3407b3e115ae96a9a2aee3b09eb30fcdd8527217531dbf3bb57c3ef0a18ba900", + "size": 3662844, + "subdir": "linux-64", + "timestamp": 1519835702812, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h7e9f1db_11.tar.bz2": { + "build": "py27h7e9f1db_11", + "build_number": 11, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py27hde5b4d6_11", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6d0d0635914a134624a50addb301f99b", + "name": "numpy", + "sha256": "f4cf00acf5e1df80642fe8a6486a9a708614cd953f10c7978d1dea97a3d79be0", + "size": 15761, + "subdir": "linux-64", + "timestamp": 1544632837600, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h7e9f1db_12.tar.bz2": { + "build": "py27h7e9f1db_12", + "build_number": 12, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py27hde5b4d6_12", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "874e998b6490f6c4c1dbb4ea404e37fb", + "name": "numpy", + "sha256": "d741e7c87bf8fce55ca2710e94cab6038cc8a563454f4bc4426712286d5d266a", + "size": 16267, + "subdir": "linux-64", + "timestamp": 1544763176263, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h99e49ec_10.tar.bz2": { + "build": "py27h99e49ec_10", + "build_number": 10, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py27h2f8d375_10", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3f8f3ab71055702afb6b2cdb6ccf3306", + "name": "numpy", + "sha256": "49c73ac397a660c6a4e65a13fbc32860ed895ee213d96099d0836ac0a82321db", + "size": 11187, + "subdir": "linux-64", + "timestamp": 1536892577694, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h99e49ec_11.tar.bz2": { + "build": "py27h99e49ec_11", + "build_number": 11, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py27h2f8d375_11", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ce012c21d653e38c6d2ec5ac67c1b2a7", + "name": "numpy", + "sha256": "42eddd6b3ecff85c1790896c0fc56e33d6642b821c6ec70a4ae46711f00df76a", + "size": 15766, + "subdir": "linux-64", + "timestamp": 1544631969255, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h99e49ec_12.tar.bz2": { + "build": "py27h99e49ec_12", + "build_number": 12, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py27h2f8d375_12", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7b3b03a56ad9363ce5833dc79bdd7561", + "name": "numpy", + "sha256": "9dfe03dd3fa77ba6cebe1213f2adf4b769de1fb8dd506a062c5019e24fb6b1d3", + "size": 16247, + "subdir": "linux-64", + "timestamp": 1544762982577, + "version": "1.11.3" + }, + "numpy-1.11.3-py27hb510916_10.tar.bz2": { + "build": "py27hb510916_10", + "build_number": 10, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py27h74e8950_10", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "951022cc127a850e1645f75f251aba66", + "name": "numpy", + "sha256": "0e3d824169abbc61a20efaa53855d114381365a5f1e4b1c90bdab6c6878d7bb2", + "size": 10932, + "subdir": "linux-64", + "timestamp": 1535405709187, + "version": "1.11.3" + }, + "numpy-1.11.3-py27hcd700cb_7.tar.bz2": { + "build": "py27hcd700cb_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27hdbf6ddf_7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9ec215611725fc526adda1a62acbc4f7", + "name": "numpy", + "sha256": "f7189748b24f6e31082e63ae7f401febc062ce35c591eb4735beab596e2bca1b", + "size": 10561, + "subdir": "linux-64", + "timestamp": 1530382537273, + "version": "1.11.3" + }, + "numpy-1.11.3-py27hcd700cb_8.tar.bz2": { + "build": "py27hcd700cb_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27hdbf6ddf_8", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4ab337b15443050c7ca5a99c699541d6", + "name": "numpy", + "sha256": "ebed63e194d855288f5f307c46a9a86787defa01513c9e7345fa6c11b59bb09f", + "size": 10962, + "subdir": "linux-64", + "timestamp": 1530551577594, + "version": "1.11.3" + }, + "numpy-1.11.3-py27hec00662_9.tar.bz2": { + "build": "py27hec00662_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27h74e8950_9", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fb2ac92e695097a05c208320ef005365", + "name": "numpy", + "sha256": "461e18cb582a84831989f632af97b1335e12cc72cb2a1527f02a18cb0980e01a", + "size": 10835, + "subdir": "linux-64", + "timestamp": 1535388059268, + "version": "1.11.3" + }, + "numpy-1.11.3-py35h1b885b7_8.tar.bz2": { + "build": "py35h1b885b7_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py35hdbf6ddf_8", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3ea5956fa898a75bf4a1e4e578be8249", + "name": "numpy", + "sha256": "9f66d2725a8c1fbad6f8c9c255d3c0cc8ea468dbafe92c21e33d1e0b6eebf96f", + "size": 10214, + "subdir": "linux-64", + "timestamp": 1534346268822, + "version": "1.11.3" + }, + "numpy-1.11.3-py35h1b885b7_9.tar.bz2": { + "build": "py35h1b885b7_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py35h3dfced4_9", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "614a4d3016d650e44c43bd3e77380873", + "name": "numpy", + "sha256": "a399340b0c76fe62b66b235172e59d703e65d5d14b936f565fbaf20d6d7e0e23", + "size": 10506, + "subdir": "linux-64", + "timestamp": 1532661265678, + "version": "1.11.3" + }, + "numpy-1.11.3-py35h1d66e8a_10.tar.bz2": { + "build": "py35h1d66e8a_10", + "build_number": 10, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py35h81de0dd_10", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d4d6105ee4374c8e59c68bbf002f6d9d", + "name": "numpy", + "sha256": "54de387e002c0579a1e91604fc0aea46fab99f065425f3c3b19fac3d9173cebd", + "size": 10936, + "subdir": "linux-64", + "timestamp": 1535406560073, + "version": "1.11.3" + }, + "numpy-1.11.3-py35h2aefc1b_8.tar.bz2": { + "build": "py35h2aefc1b_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py35h2b20989_8", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7a9cb1396e67ba82db7f087c14ad5e95", + "name": "numpy", + "sha256": "0e7d1145a5131f1dd6350444106da0be858b424c3de1dce9a5421897ef3f4a1b", + "size": 10214, + "subdir": "linux-64", + "timestamp": 1534346544391, + "version": "1.11.3" + }, + "numpy-1.11.3-py35h2aefc1b_9.tar.bz2": { + "build": "py35h2aefc1b_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py35h7cdd4dd_9", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1eea3d225939449e5d781243f092f776", + "name": "numpy", + "sha256": "675a270a10977b6de4d33da06876fa8e9a0a9dfd25806858c047927c1c99b81f", + "size": 10516, + "subdir": "linux-64", + "timestamp": 1532660201013, + "version": "1.11.3" + }, + "numpy-1.11.3-py35h3b04361_9.tar.bz2": { + "build": "py35h3b04361_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py35h81de0dd_9", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9abc5b6a663f85732ae23c9b8d6bdf3c", + "name": "numpy", + "sha256": "4470466fd9c0722d863ccecb391f54a81ed5f0ed6269e243a648a0bc5a14b8f8", + "size": 10837, + "subdir": "linux-64", + "timestamp": 1535389084737, + "version": "1.11.3" + }, + "numpy-1.11.3-py35h3dfced4_4.tar.bz2": { + "build": "py35h3dfced4_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "bcccda6f438709701d0a2e4242602b5a", + "name": "numpy", + "sha256": "1cf1b0f26c3b6bcada4f5b4809b15aa6dcd05640dcee95a1e80225adc3360e37", + "size": 3700004, + "subdir": "linux-64", + "timestamp": 1519835721886, + "version": "1.11.3" + }, + "numpy-1.11.3-py35h99e49ec_10.tar.bz2": { + "build": "py35h99e49ec_10", + "build_number": 10, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py35h2f8d375_10", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b665e9f79c2519d8734ac1c1d5a652a3", + "name": "numpy", + "sha256": "59191454266f1c145849099b95c07b1b409bb7d41689537e8c5b638176c7e699", + "size": 11176, + "subdir": "linux-64", + "timestamp": 1536892610447, + "version": "1.11.3" + }, + "numpy-1.11.3-py35hb510916_10.tar.bz2": { + "build": "py35hb510916_10", + "build_number": 10, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py35h74e8950_10", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8e07f89736281be91ae34de45fe8b784", + "name": "numpy", + "sha256": "d15adef4efc151e035724625192a00103329cf930f111f41a51283dec487b597", + "size": 10948, + "subdir": "linux-64", + "timestamp": 1535405683419, + "version": "1.11.3" + }, + "numpy-1.11.3-py35hec00662_9.tar.bz2": { + "build": "py35hec00662_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py35h74e8950_9", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4da5e7c92cf0b44e975b9fbee18c22df", + "name": "numpy", + "sha256": "d1ef411b647a9064adc5d15f462e08c7f712fc27530b537638ea8f6ddea5dcca", + "size": 10815, + "subdir": "linux-64", + "timestamp": 1535388398082, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h1b885b7_8.tar.bz2": { + "build": "py36h1b885b7_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36hdbf6ddf_8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2cede3dd83dcef1cfb075467358d861d", + "name": "numpy", + "sha256": "39e71b07444d450d7308f80601aa5b0e9c6e7012bd71255c83e315992e025e18", + "size": 10283, + "subdir": "linux-64", + "timestamp": 1530721953993, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h1b885b7_9.tar.bz2": { + "build": "py36h1b885b7_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36h3dfced4_9", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "22ef45a1fabe1008412a0163e2ab0fbf", + "name": "numpy", + "sha256": "1956abe09c8cfbd8e6ccefab6bf67ec32134044c6ccd830dc19a01c029b40bd2", + "size": 10496, + "subdir": "linux-64", + "timestamp": 1532661253358, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h1d66e8a_10.tar.bz2": { + "build": "py36h1d66e8a_10", + "build_number": 10, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py36h81de0dd_10", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b47d4800e2d735879cf7d4b8bad6cdd3", + "name": "numpy", + "sha256": "3e8d7a2b174ca0575279396f72e6fc41140910bad073cb979470417aa3f0f973", + "size": 10922, + "subdir": "linux-64", + "timestamp": 1535405858317, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h28100ab_7.tar.bz2": { + "build": "py36h28100ab_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36h2b20989_7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c83babd59b8ffa51c834bc1bca8259fc", + "name": "numpy", + "sha256": "1d5e7c5f230bde2dac0ac45b70ae89d57c686b987c65d4ad2c787cbc804ecdfc", + "size": 10564, + "subdir": "linux-64", + "timestamp": 1530381182235, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h28100ab_8.tar.bz2": { + "build": "py36h28100ab_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36h2b20989_8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "547ccde0f24e41e9564873e638e4887d", + "name": "numpy", + "sha256": "b86188fc76dfd4868e12b523b7e2073d9caec3b37f857f18671946304522fce8", + "size": 10953, + "subdir": "linux-64", + "timestamp": 1530551327597, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h2aefc1b_8.tar.bz2": { + "build": "py36h2aefc1b_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36h2b20989_8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "af3eb50d4d93467913e42f1d10b43f34", + "name": "numpy", + "sha256": "d31beb3e78657d9458ec3cc1ca341082bcd7b247a81736cb04e63546487d5b09", + "size": 10301, + "subdir": "linux-64", + "timestamp": 1530722232504, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h2aefc1b_9.tar.bz2": { + "build": "py36h2aefc1b_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36h7cdd4dd_9", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ab5f11942d4a829d814c2a343692f58e", + "name": "numpy", + "sha256": "290b559ac582ed1622574958981e8e3cea817ba2807f5f24d41ef4c7cff0c5fc", + "size": 10517, + "subdir": "linux-64", + "timestamp": 1532660168072, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h3b04361_9.tar.bz2": { + "build": "py36h3b04361_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36h81de0dd_9", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1f5833ea95755bee98b39a1fcdca58d0", + "name": "numpy", + "sha256": "e7eea364d3377a4165aaa2d147626bfe2d7520f643d0be7ac70258d3c1c1a9f6", + "size": 10820, + "subdir": "linux-64", + "timestamp": 1535386707413, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h3dfced4_4.tar.bz2": { + "build": "py36h3dfced4_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "5af85a0ebb3cf337d02da4b30c629c4e", + "name": "numpy", + "sha256": "b80d02cf6b813dad8dc6a1137746526a2943821a9baa1a75d757ea6cf34d8512", + "size": 3684323, + "subdir": "linux-64", + "timestamp": 1519835691560, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h7e9f1db_11.tar.bz2": { + "build": "py36h7e9f1db_11", + "build_number": 11, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py36hde5b4d6_11", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8558f12b34bb4324d844b29404260586", + "name": "numpy", + "sha256": "7a2a2594c33cd86acf530e7eebfa3dd281f745d4244f4b788385fe517c2c8545", + "size": 15762, + "subdir": "linux-64", + "timestamp": 1544632741414, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h7e9f1db_12.tar.bz2": { + "build": "py36h7e9f1db_12", + "build_number": 12, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py36hde5b4d6_12", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ee1622e4113d494b2c25c0c2f0a1d498", + "name": "numpy", + "sha256": "5da0dfdca672d05ab661053099d252279b7b20293faf2ccf457fd1581244a6ac", + "size": 16267, + "subdir": "linux-64", + "timestamp": 1544763324615, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h99e49ec_10.tar.bz2": { + "build": "py36h99e49ec_10", + "build_number": 10, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py36h2f8d375_10", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f6062af623559c805b445ce88c53f665", + "name": "numpy", + "sha256": "5584b017d7927839126628a53acf1d64aea855aad6e6c3cec571de822f079883", + "size": 11184, + "subdir": "linux-64", + "timestamp": 1536892545248, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h99e49ec_11.tar.bz2": { + "build": "py36h99e49ec_11", + "build_number": 11, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py36h2f8d375_11", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "507070f6777e683a4aa9d02be15e27f2", + "name": "numpy", + "sha256": "dd67a74e8ebb6d3fcbafbba6b8e420e9050b6941ed512245aef71f711b8c15bd", + "size": 15766, + "subdir": "linux-64", + "timestamp": 1544632137700, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h99e49ec_12.tar.bz2": { + "build": "py36h99e49ec_12", + "build_number": 12, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py36h2f8d375_12", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "28c6b919fcbbf1a3afbfcff20c63e715", + "name": "numpy", + "sha256": "3515c82f69f555de6b5e63d08da7a0e60f8926cd016df3010bac7da92d444504", + "size": 16280, + "subdir": "linux-64", + "timestamp": 1544763141894, + "version": "1.11.3" + }, + "numpy-1.11.3-py36hb510916_10.tar.bz2": { + "build": "py36hb510916_10", + "build_number": 10, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py36h74e8950_10", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2e80a474ac3e4f4eeac45002bd5081c0", + "name": "numpy", + "sha256": "dc1008f5f0b27e04923b4405a5d5596c7a4200aaf3f9a7cb68e472a1d7af698c", + "size": 10935, + "subdir": "linux-64", + "timestamp": 1535405715224, + "version": "1.11.3" + }, + "numpy-1.11.3-py36hcd700cb_7.tar.bz2": { + "build": "py36hcd700cb_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36hdbf6ddf_7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b56c8e1c3165a6daeac9e333656468bb", + "name": "numpy", + "sha256": "006ba3e14a20cc0f62bcecab162b59bf7c809b648d98d6278a21fcd00fc58e9b", + "size": 10560, + "subdir": "linux-64", + "timestamp": 1530382706962, + "version": "1.11.3" + }, + "numpy-1.11.3-py36hcd700cb_8.tar.bz2": { + "build": "py36hcd700cb_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36hdbf6ddf_8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ae587b4dd39e3776d31640de45163b6f", + "name": "numpy", + "sha256": "0950b7a5bc066834ea871477ea8880a852d3989146f57abe5dc2d13749898025", + "size": 10954, + "subdir": "linux-64", + "timestamp": 1530553796319, + "version": "1.11.3" + }, + "numpy-1.11.3-py36hec00662_9.tar.bz2": { + "build": "py36hec00662_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36h74e8950_9", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "19c57a18dacdfd17cbfd52ebd519e1a6", + "name": "numpy", + "sha256": "f9b02b5c89fdecc21d2e2d19b0fbcc0799df77a203f1eceb642cba9ecde0f08c", + "size": 10841, + "subdir": "linux-64", + "timestamp": 1535388554021, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h1b885b7_8.tar.bz2": { + "build": "py37h1b885b7_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37hdbf6ddf_8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "24273be0d8078840bb5646f1f32b966b", + "name": "numpy", + "sha256": "2cd2c92e5deb62b10115a753f7a6bdecf5e0aa66d803acfa83e696229a2fc475", + "size": 10269, + "subdir": "linux-64", + "timestamp": 1530722976531, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h1b885b7_9.tar.bz2": { + "build": "py37h1b885b7_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37h3dfced4_9", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "72c885270f50876bcc9b894766fa9891", + "name": "numpy", + "sha256": "71634c826845afec381126999a9bc89f4e4397166bc3cbf6d842b02793d7f045", + "size": 10509, + "subdir": "linux-64", + "timestamp": 1532661049249, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h1d66e8a_10.tar.bz2": { + "build": "py37h1d66e8a_10", + "build_number": 10, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py37h81de0dd_10", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3eb65bb1107fe5dc9808760974c82b40", + "name": "numpy", + "sha256": "c6074715534af0d246454757e450ffffbe7a00f90dac732194bca49be65fe87c", + "size": 10919, + "subdir": "linux-64", + "timestamp": 1535405857804, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h28100ab_7.tar.bz2": { + "build": "py37h28100ab_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37h2b20989_7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1cf1aa9bab0c18b6047ae70bdec490f1", + "name": "numpy", + "sha256": "138efbd7d4a31a47d5a0ac09b58956664399b67db4b1e90576b173e43551ccb8", + "size": 10597, + "subdir": "linux-64", + "timestamp": 1530380821757, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h28100ab_8.tar.bz2": { + "build": "py37h28100ab_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37h2b20989_8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ae95fb99281cd39203a0973497308e1d", + "name": "numpy", + "sha256": "fc1ebb63fef6498268d5e3b70a3f721758488a050678d7c21c169d4df41c54d4", + "size": 10952, + "subdir": "linux-64", + "timestamp": 1530550585429, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h2aefc1b_8.tar.bz2": { + "build": "py37h2aefc1b_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37h2b20989_8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6e13bde6c894c3e9cf685376ecdbd357", + "name": "numpy", + "sha256": "d89469f12279feee68154df38c4b126fe4bd3028a77512ee9c0e55ea8964945b", + "size": 10294, + "subdir": "linux-64", + "timestamp": 1530723225523, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h2aefc1b_9.tar.bz2": { + "build": "py37h2aefc1b_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37h7cdd4dd_9", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "981856dea35972c99df939ac7d032039", + "name": "numpy", + "sha256": "10cb1d4a3520ae1af9b4ec6cf25e71f6f4b26ab493270761347fba1d984aef30", + "size": 10518, + "subdir": "linux-64", + "timestamp": 1532660217462, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h3b04361_9.tar.bz2": { + "build": "py37h3b04361_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37h81de0dd_9", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d2b80c1eb1fa23defb2853799c303fe0", + "name": "numpy", + "sha256": "14f5207be300aa7a176db2fc71d14cdacc2392d1e726a41cda0f71c6ba23c7be", + "size": 10833, + "subdir": "linux-64", + "timestamp": 1535386889156, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h7e9f1db_11.tar.bz2": { + "build": "py37h7e9f1db_11", + "build_number": 11, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py37hde5b4d6_11", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2d91a12b45d0ce0fd782840127727a59", + "name": "numpy", + "sha256": "d4d289191d0168a6bb4f3f97c347b5b02cd5ea61c253076567a6ff85201defc6", + "size": 15758, + "subdir": "linux-64", + "timestamp": 1544632776176, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h7e9f1db_12.tar.bz2": { + "build": "py37h7e9f1db_12", + "build_number": 12, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py37hde5b4d6_12", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dab1001f1f5a057fd7518d8c178f1dfc", + "name": "numpy", + "sha256": "1475c80d1ee65a7cbc5eb4b3b7e315868921e4bff547203adde8873eba4329af", + "size": 16258, + "subdir": "linux-64", + "timestamp": 1544763258338, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h99e49ec_10.tar.bz2": { + "build": "py37h99e49ec_10", + "build_number": 10, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py37h2f8d375_10", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "09bfb88711f63f37f8222a937bf736ca", + "name": "numpy", + "sha256": "b311b938cb22d62e9794be106ce7a39d11ae8a15d84a19bcbaa9295f11c7be9d", + "size": 11192, + "subdir": "linux-64", + "timestamp": 1536892540313, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h99e49ec_11.tar.bz2": { + "build": "py37h99e49ec_11", + "build_number": 11, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py37h2f8d375_11", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "90de05455c88a8582d08b32cc956de5c", + "name": "numpy", + "sha256": "4dad7e7c3db23845eacd750e459d4a75c489159df6885d71a012f3865cfc212e", + "size": 15761, + "subdir": "linux-64", + "timestamp": 1544631865079, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h99e49ec_12.tar.bz2": { + "build": "py37h99e49ec_12", + "build_number": 12, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py37h2f8d375_12", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e5d17bdaa72b32570f1b859d7c677dcc", + "name": "numpy", + "sha256": "04c8d4b9db04d751e7ab7f466f915b2d697af9abf4f6337665b0b1f5957c2eb2", + "size": 16244, + "subdir": "linux-64", + "timestamp": 1544762979347, + "version": "1.11.3" + }, + "numpy-1.11.3-py37hb510916_10.tar.bz2": { + "build": "py37hb510916_10", + "build_number": 10, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py37h74e8950_10", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "44a3f2a8f83bd902043724b433919357", + "name": "numpy", + "sha256": "9398a3ea7998bfb42edd852fe386c41c406adc97f3360f9bf5106a3fd480a537", + "size": 10926, + "subdir": "linux-64", + "timestamp": 1535405076667, + "version": "1.11.3" + }, + "numpy-1.11.3-py37hcd700cb_7.tar.bz2": { + "build": "py37hcd700cb_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37hdbf6ddf_7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "66dbd1f666fa9c25bc4fa4c039ec2fd0", + "name": "numpy", + "sha256": "521d1169552f2d4b9a425eab61826bf69dd17d5935db9d3f8a21addf2b02b1c0", + "size": 10570, + "subdir": "linux-64", + "timestamp": 1530382720502, + "version": "1.11.3" + }, + "numpy-1.11.3-py37hcd700cb_8.tar.bz2": { + "build": "py37hcd700cb_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37hdbf6ddf_8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e9272234f2893cae7e1ef2b62290e011", + "name": "numpy", + "sha256": "a4010bfdfb3e361ad850993fe7e0845a0cb3b5b53ff0b0c698eec9e768ed83f9", + "size": 10962, + "subdir": "linux-64", + "timestamp": 1530553935444, + "version": "1.11.3" + }, + "numpy-1.11.3-py37hec00662_9.tar.bz2": { + "build": "py37hec00662_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37h74e8950_9", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8760f6428149b17505c49d29adbaec68", + "name": "numpy", + "sha256": "2002a465676654ff501bef94add558cec8213fd86f5dcf21096710b366f7a8d1", + "size": 10830, + "subdir": "linux-64", + "timestamp": 1535388451133, + "version": "1.11.3" + }, + "numpy-1.11.3-py38h7e9f1db_12.tar.bz2": { + "build": "py38h7e9f1db_12", + "build_number": 12, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.11.3 py38hde5b4d6_12", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cfc5c194f1a2cd9d51d41a0cc7ef4a57", + "name": "numpy", + "sha256": "af47ccb1df87b7849569fc55de1fc49c911cb35f15e1fe682cd556ddaf289b6b", + "size": 12472, + "subdir": "linux-64", + "timestamp": 1572609508566, + "version": "1.11.3" + }, + "numpy-1.11.3-py38h99e49ec_12.tar.bz2": { + "build": "py38h99e49ec_12", + "build_number": 12, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py38h2f8d375_12", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8192992d1d54974fc74a21615b1e0b53", + "name": "numpy", + "sha256": "9cbb0ee4c7272504a62c8e0ac789fb1711c96b932392ce42dc3eb2363b7ed54e", + "size": 12449, + "subdir": "linux-64", + "timestamp": 1572609732487, + "version": "1.11.3" + }, + "numpy-1.12.1-py27h9378851_1.tar.bz2": { + "build": "py27h9378851_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "mkl >=2018.0.0,<2019.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "e7209de0ea0131ac4f351acbfe5a2345", + "name": "numpy", + "sha256": "b5be54d742cd90755d4c23d09a39d381a77848fd4a6166cc38d54a4872e01b53", + "size": 3886499, + "subdir": "linux-64", + "timestamp": 1510000469790, + "version": "1.12.1" + }, + "numpy-1.12.1-py35hca0bb5e_1.tar.bz2": { + "build": "py35hca0bb5e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "f81e0d2a79ea57bf58fec9ab307a2201", + "name": "numpy", + "sha256": "a357b26d510f6b8083fed5726c44ba17e940b241f59b69823bb0a276131bcc8b", + "size": 3925911, + "subdir": "linux-64", + "timestamp": 1510000485112, + "version": "1.12.1" + }, + "numpy-1.12.1-py36he24570b_1.tar.bz2": { + "build": "py36he24570b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "93d603ab66045de9d953f74b1c5df3ba", + "name": "numpy", + "sha256": "9e5b4a9d60b0f5012e05c9980d98fa9cbd216307a479a37194d7533be9a8989b", + "size": 3933694, + "subdir": "linux-64", + "timestamp": 1510000486903, + "version": "1.12.1" + }, + "numpy-1.13.1-py27hd1b6e02_2.tar.bz2": { + "build": "py27hd1b6e02_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "mkl >=2018.0.0,<2019.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "50e6867cce2c0697affc0fb32f15a1c5", + "name": "numpy", + "sha256": "681975acea61bcd489837424e4068eeed4b92a4002cc817f40368b604bd6ca27", + "size": 3988799, + "subdir": "linux-64", + "timestamp": 1506013346735, + "version": "1.13.1" + }, + "numpy-1.13.1-py35h8926d81_2.tar.bz2": { + "build": "py35h8926d81_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "689e6a314d3293b7fc59af2fe4670555", + "name": "numpy", + "sha256": "f8e532becf3c54aa60e5cba130353bb48bda985da8fb478a23a538ec2968f2a2", + "size": 3995221, + "subdir": "linux-64", + "timestamp": 1506013892685, + "version": "1.13.1" + }, + "numpy-1.13.1-py36h5bc529a_2.tar.bz2": { + "build": "py36h5bc529a_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "6c82b410a46bd64f394e1a3eca1dfa84", + "name": "numpy", + "sha256": "c19eab030d86ce72708075b9bbc935e5af3f93ee68955d8457cead769e9c4128", + "size": 4037374, + "subdir": "linux-64", + "timestamp": 1506013887446, + "version": "1.13.1" + }, + "numpy-1.13.3-py27_nomklh2b20989_4.tar.bz2": { + "build": "py27_nomklh2b20989_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "b32c5f3a80000fc3c9823da23718652e", + "name": "numpy", + "sha256": "17116c9ed4ad3c02b812d3dbef8e21ee652c66e5353f5a383a0efdb0c2e6849f", + "size": 4001259, + "subdir": "linux-64", + "timestamp": 1522176769381, + "version": "1.13.3" + }, + "numpy-1.13.3-py27_nomklhfe0a00b_0.tar.bz2": { + "build": "py27_nomklhfe0a00b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "571fab3110f2ebb935354530e3f7f8fb", + "name": "numpy", + "sha256": "9db1ca423e2bdd86101468714a6eaca5798b79df5a12ac30903a83407df5eec0", + "size": 3988277, + "subdir": "linux-64", + "timestamp": 1509731938354, + "version": "1.13.3" + }, + "numpy-1.13.3-py27h3dfced4_2.tar.bz2": { + "build": "py27h3dfced4_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "c0a59cd2bdf0fff3f1f069c6ad94a396", + "name": "numpy", + "sha256": "0720eae2fafed9bc5d03a6ea2f311df31a32032e6f69586943a959caf8d9c5f7", + "size": 3990064, + "subdir": "linux-64", + "timestamp": 1516836864513, + "version": "1.13.3" + }, + "numpy-1.13.3-py27ha266831_3.tar.bz2": { + "build": "py27ha266831_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "002c7f6e714206c2cf16885a6e622910", + "name": "numpy", + "sha256": "b75db0d753f011d19ee76def7982732a5b1a4cd7ff8e61167833d5ad7be114a7", + "size": 3989721, + "subdir": "linux-64", + "timestamp": 1520447824092, + "version": "1.13.3" + }, + "numpy-1.13.3-py27hbcc08e0_0.tar.bz2": { + "build": "py27hbcc08e0_0", + "build_number": 0, + "depends": [ + "mkl >=2018.0.0,<2019.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "503945e640b4db4bed7c9d771a21899a", + "name": "numpy", + "sha256": "622ec90a17c78f8184670617d9d8051b3c70100a68d8c195357a84d97bf51c94", + "size": 3988160, + "subdir": "linux-64", + "timestamp": 1507324248605, + "version": "1.13.3" + }, + "numpy-1.13.3-py27hdbf6ddf_4.tar.bz2": { + "build": "py27hdbf6ddf_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "mkl_fft", + "mkl_random", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "05ee8fe13f0e9c6290847feeb823b271", + "name": "numpy", + "sha256": "0c8a026a77abe08df7bfae62c2f46452169b2c4c6e632be635f5f6be67d47236", + "size": 4068128, + "subdir": "linux-64", + "timestamp": 1522178718483, + "version": "1.13.3" + }, + "numpy-1.13.3-py35_nomklh2b20989_4.tar.bz2": { + "build": "py35_nomklh2b20989_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "1c6fdc09328ef08c4d32bb1ad5e541fb", + "name": "numpy", + "sha256": "d12f6f36f5eb206b4d69763316bc8a24ab2ba1b330d7f8fa49f7524a7f402ad9", + "size": 4075402, + "subdir": "linux-64", + "timestamp": 1522178211509, + "version": "1.13.3" + }, + "numpy-1.13.3-py35_nomklhb7e7d7c_0.tar.bz2": { + "build": "py35_nomklhb7e7d7c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "99dc690607b26a88b4a10597ac7dabe8", + "name": "numpy", + "sha256": "a274597bd45821bd4ca01c31ce159041df5c336a98d77c680814a4dfb03569cb", + "size": 4007419, + "subdir": "linux-64", + "timestamp": 1509732091536, + "version": "1.13.3" + }, + "numpy-1.13.3-py35h3dfced4_2.tar.bz2": { + "build": "py35h3dfced4_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "60c31f650438c0c0204f3dba1f6b0e9b", + "name": "numpy", + "sha256": "bd4a1d83051b27838e6e4706ec2ba0ff4841f55c18d38510f4a62c3cdbde2e88", + "size": 4015493, + "subdir": "linux-64", + "timestamp": 1516836901340, + "version": "1.13.3" + }, + "numpy-1.13.3-py35ha266831_3.tar.bz2": { + "build": "py35ha266831_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "a3a049f2a3275c5feea06bc17df703be", + "name": "numpy", + "sha256": "36c3d6de8f707f5b1525a18b9156d2f6336757faceb013d0768cb2bd5d4a4c96", + "size": 4016208, + "subdir": "linux-64", + "timestamp": 1520448426914, + "version": "1.13.3" + }, + "numpy-1.13.3-py35hd829ed6_0.tar.bz2": { + "build": "py35hd829ed6_0", + "build_number": 0, + "depends": [ + "mkl >=2018.0.0,<2019.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "735bc1733584b73a5f9b993b837113d2", + "name": "numpy", + "sha256": "bb419de6c08decaea12b22c02aa089ecc01c4e853634851c4d6d8f66d4aac3c6", + "size": 4006300, + "subdir": "linux-64", + "timestamp": 1507324287123, + "version": "1.13.3" + }, + "numpy-1.13.3-py35hdbf6ddf_4.tar.bz2": { + "build": "py35hdbf6ddf_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "mkl_fft", + "mkl_random", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "f3a999c02c4faca648ecafcb9e116719", + "name": "numpy", + "sha256": "03e4908a84e3224caca03347787e70f0e0ec2150a4f9bdbba09d90657fa2abb2", + "size": 4129607, + "subdir": "linux-64", + "timestamp": 1522178730625, + "version": "1.13.3" + }, + "numpy-1.13.3-py36_nomklh2b20989_4.tar.bz2": { + "build": "py36_nomklh2b20989_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "c6394aab62eb0175e8f8484902b30ecd", + "name": "numpy", + "sha256": "ce93bc04dbd28681c7255ff555cfba4fed415c5564bb934bd61847376dda212c", + "size": 4060566, + "subdir": "linux-64", + "timestamp": 1522178211202, + "version": "1.13.3" + }, + "numpy-1.13.3-py36_nomklhbef0cb9_0.tar.bz2": { + "build": "py36_nomklhbef0cb9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "35026b77efe72e555e7565eb45b9e2d4", + "name": "numpy", + "sha256": "5ed10719bb9c4ae2c6c45c273f0b2f3af778ba52cbf4d65d14b572db2a60cbbb", + "size": 4043445, + "subdir": "linux-64", + "timestamp": 1509732107063, + "version": "1.13.3" + }, + "numpy-1.13.3-py36h3dfced4_2.tar.bz2": { + "build": "py36h3dfced4_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "3dcc264ebd4aa68f02b1e865b32e59a6", + "name": "numpy", + "sha256": "2a1db34f9fc359188b1f7a9a23abc6790b509f7f16b021fb511428c5d62534d3", + "size": 4044548, + "subdir": "linux-64", + "timestamp": 1516836903302, + "version": "1.13.3" + }, + "numpy-1.13.3-py36ha12f23b_0.tar.bz2": { + "build": "py36ha12f23b_0", + "build_number": 0, + "depends": [ + "mkl >=2018.0.0,<2019.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "4ebdc7a87b9b954d0cc59d31b1c5c4b6", + "name": "numpy", + "sha256": "87ade20954b967111f02c22fea33bf7f44bef8159263f45557af66fd2be52d43", + "size": 4043525, + "subdir": "linux-64", + "timestamp": 1507324009304, + "version": "1.13.3" + }, + "numpy-1.13.3-py36ha266831_3.tar.bz2": { + "build": "py36ha266831_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "6f6f414ec27f25319879566813a6f367", + "name": "numpy", + "sha256": "d20410c6d7c8b66cec0fdf52ae747cfa2464d209562a29b0e500d4eb9157f58d", + "size": 4046889, + "subdir": "linux-64", + "timestamp": 1520451920394, + "version": "1.13.3" + }, + "numpy-1.13.3-py36hdbf6ddf_4.tar.bz2": { + "build": "py36hdbf6ddf_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "mkl_fft", + "mkl_random", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "aa28bb59ef94110d7cf99c1003664099", + "name": "numpy", + "sha256": "0453abfbae534a57a08d0f13ea963e8d15f6e07dc9faafb31a07d50992976b2c", + "size": 4121359, + "subdir": "linux-64", + "timestamp": 1522178766285, + "version": "1.13.3" + }, + "numpy-1.13.3-py38_nomklh199bd5d_4.tar.bz2": { + "build": "py38_nomklh199bd5d_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2c87582d9cd2eaf9066f71d742827166", + "name": "numpy", + "sha256": "0ee7b82004b530fc8996d479a44463e6bb9d6d26f1a0a868c1d1e78b8e85d41d", + "size": 4158331, + "subdir": "linux-64", + "timestamp": 1574354128704, + "version": "1.13.3" + }, + "numpy-1.13.3-py38he85021b_4.tar.bz2": { + "build": "py38he85021b_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "65249b101779d0351115fa9dd2a1ef7d", + "name": "numpy", + "sha256": "ec6c86fd6e12cff5d12d5f6987bf16c420d76f260d41460098a59b8a2069cb6c", + "size": 4206010, + "subdir": "linux-64", + "timestamp": 1574353842218, + "version": "1.13.3" + }, + "numpy-1.14.0-py27_nomklh7cdd4dd_0.tar.bz2": { + "build": "py27_nomklh7cdd4dd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "a6d27589183eb0a252d6d19c294b325d", + "name": "numpy", + "sha256": "3f71a791a45fe2b09a1de08aa676dae7105ae8c8ed20e2942eb837ec58a2e370", + "size": 4156892, + "subdir": "linux-64", + "timestamp": 1515516714023, + "version": "1.14.0" + }, + "numpy-1.14.0-py27h3dfced4_0.tar.bz2": { + "build": "py27h3dfced4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.1,<2019.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "77a41c3bb1bf6a0dd68554567ba3a778", + "name": "numpy", + "sha256": "e2250d6f74d03fb9e40dc62a10af7650911037c5642d578b56aecfad8c2fbf7a", + "size": 4157011, + "subdir": "linux-64", + "timestamp": 1515516267486, + "version": "1.14.0" + }, + "numpy-1.14.0-py27h3dfced4_1.tar.bz2": { + "build": "py27h3dfced4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "5068b0e6baa2998158abeebfb39a8a84", + "name": "numpy", + "sha256": "562b8398b68935f22067747d86b865cf425195a86fc103bf6390a257348c19f5", + "size": 4164312, + "subdir": "linux-64", + "timestamp": 1516832188067, + "version": "1.14.0" + }, + "numpy-1.14.0-py27ha266831_2.tar.bz2": { + "build": "py27ha266831_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "faf90d45d467428d94120195e100ceaa", + "name": "numpy", + "sha256": "b923c7dae86caea6cb558433f373b8379aeb649121af127321bee82c852a241b", + "size": 4164016, + "subdir": "linux-64", + "timestamp": 1520448374124, + "version": "1.14.0" + }, + "numpy-1.14.0-py35_nomklh7cdd4dd_0.tar.bz2": { + "build": "py35_nomklh7cdd4dd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "b88360447fdb5bee26b0c435afe539b5", + "name": "numpy", + "sha256": "a7b31c3da53dfa91c6624637180c77d068182288d1b8e5b15c1f3960feb317ce", + "size": 4169593, + "subdir": "linux-64", + "timestamp": 1515516727637, + "version": "1.14.0" + }, + "numpy-1.14.0-py35h3dfced4_0.tar.bz2": { + "build": "py35h3dfced4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.1,<2019.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "f4cfe5edb0d51582d5fb47c417920024", + "name": "numpy", + "sha256": "d4597addd2138a010b9234fa1632a99ce061c6c40af4b89f63da6675b63eade7", + "size": 4169027, + "subdir": "linux-64", + "timestamp": 1515516403173, + "version": "1.14.0" + }, + "numpy-1.14.0-py35h3dfced4_1.tar.bz2": { + "build": "py35h3dfced4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "e83e91c44388df337239194d795b888c", + "name": "numpy", + "sha256": "5d152cd67aa1510ef12a7945cab921dac4e06d1c15ec99ccd70f2c2d832d3309", + "size": 4173960, + "subdir": "linux-64", + "timestamp": 1516832230784, + "version": "1.14.0" + }, + "numpy-1.14.0-py35ha266831_2.tar.bz2": { + "build": "py35ha266831_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "2f58425a83c7d969cab10e572505ea70", + "name": "numpy", + "sha256": "1dc89ccd8d4c9f5bd1a1d60abfcb39cc9a9c77a8b8d20f7e33b7cf209eb84821", + "size": 4171548, + "subdir": "linux-64", + "timestamp": 1520448578576, + "version": "1.14.0" + }, + "numpy-1.14.0-py36_nomklh7cdd4dd_0.tar.bz2": { + "build": "py36_nomklh7cdd4dd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "f226a3aef2cb581ce6b8823f950bf8c4", + "name": "numpy", + "sha256": "732b4e51acebe8c242ba6d3628a74790aa70ebd4e5c924430915c57057ca8a40", + "size": 4216478, + "subdir": "linux-64", + "timestamp": 1515516729151, + "version": "1.14.0" + }, + "numpy-1.14.0-py36h3dfced4_0.tar.bz2": { + "build": "py36h3dfced4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.1,<2019.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "7662040e01139e1636c2e5a6ca7573d6", + "name": "numpy", + "sha256": "4680f19543f87c35bed057b9d3f3b9678e0f85c79e4863f7383f023707fce284", + "size": 4216881, + "subdir": "linux-64", + "timestamp": 1515516199405, + "version": "1.14.0" + }, + "numpy-1.14.0-py36h3dfced4_1.tar.bz2": { + "build": "py36h3dfced4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "c89a936f3e844c69a36c8f119277756f", + "name": "numpy", + "sha256": "350020161afe589375665817c977cea4513441ef6b8cdde88904f4614538ef87", + "size": 4232218, + "subdir": "linux-64", + "timestamp": 1516832315827, + "version": "1.14.0" + }, + "numpy-1.14.0-py36ha266831_2.tar.bz2": { + "build": "py36ha266831_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "5c15144faa14a266f5c739ff86f59cbc", + "name": "numpy", + "sha256": "531e0ffdeda6547ff54a117c9f7ef034ffbd248af410f8ff68cdbc5f8be73611", + "size": 4226126, + "subdir": "linux-64", + "timestamp": 1520447663083, + "version": "1.14.0" + }, + "numpy-1.14.1-py27_nomklh5cab86c_2.tar.bz2": { + "build": "py27_nomklh5cab86c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "a546b7781c17e7e76c516d46b131cff4", + "name": "numpy", + "sha256": "469668b8554c02ff65b8e35d97a35bc5af6c2f8a4b413f047a856caff1d64368", + "size": 4155640, + "subdir": "linux-64", + "timestamp": 1520453354669, + "version": "1.14.1" + }, + "numpy-1.14.1-py27_nomklh7cdd4dd_1.tar.bz2": { + "build": "py27_nomklh7cdd4dd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "40148fdba4d2932a5a8f74b8626e2f2a", + "name": "numpy", + "sha256": "dbfb442b00196bd8229e3df5737de101c75541863af5eb0f068b93c861ad040f", + "size": 4155821, + "subdir": "linux-64", + "timestamp": 1519238005628, + "version": "1.14.1" + }, + "numpy-1.14.1-py27h3dfced4_1.tar.bz2": { + "build": "py27h3dfced4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "cc049cdf04f8d5b9feae0258e9abe215", + "name": "numpy", + "sha256": "eccaa88f98cab77e8361c4483313654f7fd63707eac8c088bbb59c32bfad1e2f", + "size": 4154374, + "subdir": "linux-64", + "timestamp": 1519225906866, + "version": "1.14.1" + }, + "numpy-1.14.1-py27ha266831_2.tar.bz2": { + "build": "py27ha266831_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "a78b24dfe5c709b5f642c2832ee98d81", + "name": "numpy", + "sha256": "1457a4ce578b4e5fe85f500ac7be24ca0423bbd2bc8f74fa61f6c1eb297d76a5", + "size": 4153330, + "subdir": "linux-64", + "timestamp": 1520453527834, + "version": "1.14.1" + }, + "numpy-1.14.1-py35_nomklh5cab86c_2.tar.bz2": { + "build": "py35_nomklh5cab86c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "e9239e04a36c9d71db5731564162fa9a", + "name": "numpy", + "sha256": "a9a1fc83eae749a4db661bf22fa81f9961f94e31ddb3763a2ec27b44f8dbfd96", + "size": 4160219, + "subdir": "linux-64", + "timestamp": 1520453498981, + "version": "1.14.1" + }, + "numpy-1.14.1-py35_nomklh7cdd4dd_1.tar.bz2": { + "build": "py35_nomklh7cdd4dd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "d96cecc786b9a1f7cfe86a9841d9ad21", + "name": "numpy", + "sha256": "6b37f86b1f3a6abb3809c0799ee68d3ac5bfde7adbf17643f93ae17057d86733", + "size": 4160623, + "subdir": "linux-64", + "timestamp": 1519237980921, + "version": "1.14.1" + }, + "numpy-1.14.1-py35h3dfced4_1.tar.bz2": { + "build": "py35h3dfced4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "b816623faf5b44a3faeb9a0d19c6a842", + "name": "numpy", + "sha256": "a2b5cc2a31dc94a5f4151301dd084db1fbc3642aeb11c0c1e43e0b50d4edd0d3", + "size": 4156468, + "subdir": "linux-64", + "timestamp": 1519178485319, + "version": "1.14.1" + }, + "numpy-1.14.1-py35ha266831_2.tar.bz2": { + "build": "py35ha266831_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "e31c2ee4cb49e1c90e3047e3b5d1e1b9", + "name": "numpy", + "sha256": "924d06b65e2f9a767c4eb745a630cd51f2830896b812e37b43fd4994a422b6be", + "size": 4159158, + "subdir": "linux-64", + "timestamp": 1520453708805, + "version": "1.14.1" + }, + "numpy-1.14.1-py36_nomklh5cab86c_2.tar.bz2": { + "build": "py36_nomklh5cab86c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "538d03dcf9c295d19bc5fe189ad0e603", + "name": "numpy", + "sha256": "39cda89b957aa3948a82e129f3d74ff0066efc9c9949be910ab49f4c14112327", + "size": 4234094, + "subdir": "linux-64", + "timestamp": 1520453670284, + "version": "1.14.1" + }, + "numpy-1.14.1-py36_nomklh7cdd4dd_1.tar.bz2": { + "build": "py36_nomklh7cdd4dd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "ad4d3c21421f5b04de6573e5a222467a", + "name": "numpy", + "sha256": "28d68d4c349dd2203af40e6c0536d316d390c67d5de33c9e208c90e43312f9f5", + "size": 4234211, + "subdir": "linux-64", + "timestamp": 1519238005310, + "version": "1.14.1" + }, + "numpy-1.14.1-py36h3dfced4_1.tar.bz2": { + "build": "py36h3dfced4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "007c2dd69dc05437ba602ed86e3ddc98", + "name": "numpy", + "sha256": "e8fa44281d4cfe0f5769429d36a9d4f796033d21e8e3efee833889afaf87e79e", + "size": 4239251, + "subdir": "linux-64", + "timestamp": 1519178338176, + "version": "1.14.1" + }, + "numpy-1.14.1-py36ha266831_2.tar.bz2": { + "build": "py36ha266831_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "87cdf9762a3360a8d8f2f74d3cefd8b7", + "name": "numpy", + "sha256": "12a460e2d93e0f2671e21341a0067d7c88dd9995f9cf642e64ec641eccc0c574", + "size": 4239067, + "subdir": "linux-64", + "timestamp": 1520453600684, + "version": "1.14.1" + }, + "numpy-1.14.2-py27_nomklh2b20989_0.tar.bz2": { + "build": "py27_nomklh2b20989_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "bbb0b8e2699a472a39ac4ae57285e125", + "name": "numpy", + "sha256": "643ae4340b6e1a85aacc3e50fa3fb2485d1864b2e5061baa3d147c973b6cc812", + "size": 4154158, + "subdir": "linux-64", + "timestamp": 1520892520349, + "version": "1.14.2" + }, + "numpy-1.14.2-py27_nomklh2b20989_1.tar.bz2": { + "build": "py27_nomklh2b20989_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "030dc84c60a519d30885a494082661e2", + "name": "numpy", + "sha256": "8bb9b4cb14339533b7fb7b776d578f44bfc9c8da5272998965eba2d752e655ae", + "size": 4220847, + "subdir": "linux-64", + "timestamp": 1521814843401, + "version": "1.14.2" + }, + "numpy-1.14.2-py27hdbf6ddf_0.tar.bz2": { + "build": "py27hdbf6ddf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "fcbd96b0b00fd44712b98d8dd7406f6f", + "name": "numpy", + "sha256": "30e2966e7db91960e018ad0e88517078868c586f70c29abf4a229d43edfaec34", + "size": 4156352, + "subdir": "linux-64", + "timestamp": 1520892821484, + "version": "1.14.2" + }, + "numpy-1.14.2-py27hdbf6ddf_1.tar.bz2": { + "build": "py27hdbf6ddf_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "mkl_fft", + "mkl_random", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "a859ed490a94d41987a863c7f78597d7", + "name": "numpy", + "sha256": "1b38a9838d35ba770987899a346191a7adef7e9253a5fa7941ca320533cdea15", + "size": 4272943, + "subdir": "linux-64", + "timestamp": 1521815144772, + "version": "1.14.2" + }, + "numpy-1.14.2-py35_nomklh2b20989_0.tar.bz2": { + "build": "py35_nomklh2b20989_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "da556d3cd8f7d106fbe604974fa3995c", + "name": "numpy", + "sha256": "3417716deaf72c9d7467751f950d81a95738673148d9976c0b4f0ca2b32643ca", + "size": 4159677, + "subdir": "linux-64", + "timestamp": 1520892611584, + "version": "1.14.2" + }, + "numpy-1.14.2-py35_nomklh2b20989_1.tar.bz2": { + "build": "py35_nomklh2b20989_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "aff829254e7bf15b6f2521c14d435802", + "name": "numpy", + "sha256": "6026d458c6cf77e46c2d7677953057e2240e6eb6a416fb9d85f5bc969d96cc92", + "size": 4184458, + "subdir": "linux-64", + "timestamp": 1521814956308, + "version": "1.14.2" + }, + "numpy-1.14.2-py35hdbf6ddf_0.tar.bz2": { + "build": "py35hdbf6ddf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "cea5d37783ef2f8661681b9c29145f5f", + "name": "numpy", + "sha256": "a6e856cd031ce334f48df04f300b6d9f7670ee3770edfb8ecb86064c302cd236", + "size": 4154004, + "subdir": "linux-64", + "timestamp": 1520952936786, + "version": "1.14.2" + }, + "numpy-1.14.2-py35hdbf6ddf_1.tar.bz2": { + "build": "py35hdbf6ddf_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "mkl_fft", + "mkl_random", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "991b603a4cec512eaf59f0564f8bc3ef", + "name": "numpy", + "sha256": "8763318dc1a4f0dd06b8e84e4c4c4fe0dc0460b28c26abe78abbb682780264e5", + "size": 4266412, + "subdir": "linux-64", + "timestamp": 1521815123684, + "version": "1.14.2" + }, + "numpy-1.14.2-py36_nomklh2b20989_0.tar.bz2": { + "build": "py36_nomklh2b20989_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "5d9da683a055b859699772f4f2d52f2e", + "name": "numpy", + "sha256": "09804f0dd7a5d3619c2d7297ac9252f42ba9314ec675462a52375b12b73039f8", + "size": 4233959, + "subdir": "linux-64", + "timestamp": 1520892136072, + "version": "1.14.2" + }, + "numpy-1.14.2-py36_nomklh2b20989_1.tar.bz2": { + "build": "py36_nomklh2b20989_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "1f141c2bbf17959d80f44b6b290e786f", + "name": "numpy", + "sha256": "c76939121451c01992fd95cf610e5573f2fc8a217ad4b4a32932e7794be73079", + "size": 4241837, + "subdir": "linux-64", + "timestamp": 1521814953953, + "version": "1.14.2" + }, + "numpy-1.14.2-py36hdbf6ddf_0.tar.bz2": { + "build": "py36hdbf6ddf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "049be722f34fd6e08cd58e42a7ac1c98", + "name": "numpy", + "sha256": "14fbfe120aa2b0289b6716f01061d4fbe5007d4b4c5c0e019e3e8e1a728e19fe", + "size": 4237014, + "subdir": "linux-64", + "timestamp": 1520892861165, + "version": "1.14.2" + }, + "numpy-1.14.2-py36hdbf6ddf_1.tar.bz2": { + "build": "py36hdbf6ddf_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "mkl_fft", + "mkl_random", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "85cf86362a729dd112ed31aaebee0b1b", + "name": "numpy", + "sha256": "3d01cbadde6a39796ff36e36d2615a728031ef2285a355e28c19014e698d6e41", + "size": 4294737, + "subdir": "linux-64", + "timestamp": 1521815124384, + "version": "1.14.2" + }, + "numpy-1.14.3-py27h28100ab_1.tar.bz2": { + "build": "py27h28100ab_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.3 py27h0ea5e3f_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d2caebcffacc84a629066155ac4e8e22", + "name": "numpy", + "sha256": "73e2b92375931ef2ea87b94d4d18d5e3c0a086113bcb82b4edfe241e2eb3f039", + "size": 41686, + "subdir": "linux-64", + "timestamp": 1526858657771, + "version": "1.14.3" + }, + "numpy-1.14.3-py27hcd700cb_1.tar.bz2": { + "build": "py27hcd700cb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.3 py27h9be14a7_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4e8e2f2da6d373b221a654f858501a32", + "name": "numpy", + "sha256": "3c576966692dc69153ef6bc93bb37c9e5bd9b91d83f96b4bff7634a3ecdf29ec", + "size": 41752, + "subdir": "linux-64", + "timestamp": 1526859343221, + "version": "1.14.3" + }, + "numpy-1.14.3-py35h28100ab_1.tar.bz2": { + "build": "py35h28100ab_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.3 py35h0ea5e3f_1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b30b9e5a41effe3dd207c60563bb43b4", + "name": "numpy", + "sha256": "e44baccc7c7f334c3f1595ab2716c779e343159809e47a276eb9f4d3ce14bc91", + "size": 41706, + "subdir": "linux-64", + "timestamp": 1526858708819, + "version": "1.14.3" + }, + "numpy-1.14.3-py35hcd700cb_1.tar.bz2": { + "build": "py35hcd700cb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.3 py35h9be14a7_1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c4f81199440220e1aeb29a726e391cf0", + "name": "numpy", + "sha256": "3600c5bc1f2809751ff5fba9bdf787e1cbd430966ca524ee84b7230879e0877e", + "size": 41796, + "subdir": "linux-64", + "timestamp": 1526859360035, + "version": "1.14.3" + }, + "numpy-1.14.3-py36h28100ab_1.tar.bz2": { + "build": "py36h28100ab_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.3 py36h0ea5e3f_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1dcb494c0253371c9843ceef8289abd0", + "name": "numpy", + "sha256": "f3543f50673b172684ea3ed853de4bd7f94daae410070620bf605e71b5d5646a", + "size": 41676, + "subdir": "linux-64", + "timestamp": 1526858552443, + "version": "1.14.3" + }, + "numpy-1.14.3-py36hcd700cb_1.tar.bz2": { + "build": "py36hcd700cb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.3 py36h9be14a7_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "76eb1286be1815cee5552867d597176d", + "name": "numpy", + "sha256": "3ca565b80a4eed8dd37d130ddc4323da7b150831bdf98aeb01b50c872f450528", + "size": 41798, + "subdir": "linux-64", + "timestamp": 1526859008604, + "version": "1.14.3" + }, + "numpy-1.14.4-py27h28100ab_0.tar.bz2": { + "build": "py27h28100ab_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.4 py27h2b20989_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6d3c57388ebf057e96ac9788410fdadf", + "name": "numpy", + "sha256": "270427a63ea269102c59fab5e12a80d4933c7e69e36fc2d591ad52b632b95453", + "size": 101407, + "subdir": "linux-64", + "timestamp": 1528829253124, + "version": "1.14.4" + }, + "numpy-1.14.4-py27hcd700cb_0.tar.bz2": { + "build": "py27hcd700cb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.4 py27hdbf6ddf_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "92583d526d34fb456014c23ac4857c62", + "name": "numpy", + "sha256": "b1d1b1a400f277f389644bb3d9e075967571600e704a99d6789a7894085f49dc", + "size": 101485, + "subdir": "linux-64", + "timestamp": 1528829711977, + "version": "1.14.4" + }, + "numpy-1.14.4-py35h28100ab_0.tar.bz2": { + "build": "py35h28100ab_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.4 py35h2b20989_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "eeb64dffa24679681b90acb890dba3e1", + "name": "numpy", + "sha256": "6a145b7d3e6a3477e5ece2e6f38aa1fe22c10b80e6295626c9b95a64e65223e2", + "size": 101400, + "subdir": "linux-64", + "timestamp": 1528829305327, + "version": "1.14.4" + }, + "numpy-1.14.4-py35hcd700cb_0.tar.bz2": { + "build": "py35hcd700cb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.4 py35hdbf6ddf_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0cb10b466423926eeaeb5cdc24873748", + "name": "numpy", + "sha256": "bfb090f225845beb3b10c8af92aecce6db7489de3bc8227eaf2e6f17568d5ce5", + "size": 101469, + "subdir": "linux-64", + "timestamp": 1528829824740, + "version": "1.14.4" + }, + "numpy-1.14.4-py36h28100ab_0.tar.bz2": { + "build": "py36h28100ab_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.4 py36h2b20989_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8786e6567698da8606cb2f25a6993a60", + "name": "numpy", + "sha256": "c31060f6f55c98061a46020c4348a663bf08729395ecf5ad68963ae29442aaaf", + "size": 101403, + "subdir": "linux-64", + "timestamp": 1528829274095, + "version": "1.14.4" + }, + "numpy-1.14.4-py36hcd700cb_0.tar.bz2": { + "build": "py36hcd700cb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.4 py36hdbf6ddf_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "624f2fdd360a331dda861f19e794972e", + "name": "numpy", + "sha256": "536f20b15b3db4da05049cdcff9c6d054bb4829bd98b9da0fab9c9faaa435bdb", + "size": 101508, + "subdir": "linux-64", + "timestamp": 1528829733692, + "version": "1.14.4" + }, + "numpy-1.14.5-py27h1b885b7_4.tar.bz2": { + "build": "py27h1b885b7_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py27hdbf6ddf_4", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6977a889163bacb8fac5538b12e04d38", + "name": "numpy", + "sha256": "3446592ee2a65be8bd5acce1b0fb8b30c495a84328aaf180a5a464a6cc29b957", + "size": 36192, + "subdir": "linux-64", + "timestamp": 1531326775194, + "version": "1.14.5" + }, + "numpy-1.14.5-py27h28100ab_0.tar.bz2": { + "build": "py27h28100ab_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py27h2b20989_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bf91cb4a46f10a00912035bee04d85a4", + "name": "numpy", + "sha256": "85f1f229f5de9e3cf133dc5dbb5d104fe3b581b981406c8d04eca9e4bf8043e3", + "size": 96245, + "subdir": "linux-64", + "timestamp": 1528900955568, + "version": "1.14.5" + }, + "numpy-1.14.5-py27h28100ab_1.tar.bz2": { + "build": "py27h28100ab_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py27h2b20989_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "094cfb42fe457b2e9d7f152b1543d3de", + "name": "numpy", + "sha256": "8d52b860626990e064c1b4df4b0fc26d95384530f48099245ca1b945fca5b5d4", + "size": 95988, + "subdir": "linux-64", + "timestamp": 1530354204566, + "version": "1.14.5" + }, + "numpy-1.14.5-py27h28100ab_2.tar.bz2": { + "build": "py27h28100ab_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py27h2b20989_2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "51a0aa21a368a7b679d1e03fdde2b496", + "name": "numpy", + "sha256": "1d12ba1e3f56bde6b8198c39a9649edccf804d7489b187c56fae84750d9b06c1", + "size": 95837, + "subdir": "linux-64", + "timestamp": 1530382372341, + "version": "1.14.5" + }, + "numpy-1.14.5-py27h28100ab_3.tar.bz2": { + "build": "py27h28100ab_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py27h2b20989_3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "daa4d194e16881c4a8d2f2c33787540d", + "name": "numpy", + "sha256": "c1f729b2623ce269a6cc9ad9ce76512a7577bf206a21fb8abd13e44badcadf13", + "size": 95930, + "subdir": "linux-64", + "timestamp": 1530553808550, + "version": "1.14.5" + }, + "numpy-1.14.5-py27h2aefc1b_4.tar.bz2": { + "build": "py27h2aefc1b_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py27h2b20989_4", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6a33b03d331485652995a29b1da9941c", + "name": "numpy", + "sha256": "be2ee4294a919f7bb517a0ba137a3ece02893f77740aabf37dd2977389b24203", + "size": 36184, + "subdir": "linux-64", + "timestamp": 1531326447057, + "version": "1.14.5" + }, + "numpy-1.14.5-py27hcd700cb_0.tar.bz2": { + "build": "py27hcd700cb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py27hdbf6ddf_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a8de1dbb9a9e383cc427753aac418103", + "name": "numpy", + "sha256": "6b20a08112f67b50370786af0d85fe5db0eed834b347f7f4aa1d643ca2fd94f5", + "size": 96429, + "subdir": "linux-64", + "timestamp": 1528901280225, + "version": "1.14.5" + }, + "numpy-1.14.5-py27hcd700cb_1.tar.bz2": { + "build": "py27hcd700cb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py27hdbf6ddf_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2890b34c5f5a5ef16c11232a0233876f", + "name": "numpy", + "sha256": "386bb8aec81b7362bf19acb0c1a981fa2c016f93efd5605236684b5e015bf5a7", + "size": 96057, + "subdir": "linux-64", + "timestamp": 1530353552583, + "version": "1.14.5" + }, + "numpy-1.14.5-py27hcd700cb_2.tar.bz2": { + "build": "py27hcd700cb_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py27hdbf6ddf_2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5a42085ff31cef815e62e6fe0b0edd3e", + "name": "numpy", + "sha256": "b682b3cf2093fe463ad639f1eae38e6a8f4365e3c8060d4c854a6b9913f13a8f", + "size": 95840, + "subdir": "linux-64", + "timestamp": 1530382988516, + "version": "1.14.5" + }, + "numpy-1.14.5-py27hcd700cb_3.tar.bz2": { + "build": "py27hcd700cb_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py27hdbf6ddf_3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9e64c236d80efc8b707b22210bdd6dfc", + "name": "numpy", + "sha256": "557db028cc51d5bc8f3fb69d876c4a5c828dcaf6712f471ad258299dff2be9b5", + "size": 95977, + "subdir": "linux-64", + "timestamp": 1530554329108, + "version": "1.14.5" + }, + "numpy-1.14.5-py35h1b885b7_4.tar.bz2": { + "build": "py35h1b885b7_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py35hdbf6ddf_4", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "11a28d1dd7596d178ab9ba7ed6108093", + "name": "numpy", + "sha256": "8b2b0d5c0db7069608aeec93c25a10c18a7d31b6c4cafdf63fb1dbd9ff394de0", + "size": 36147, + "subdir": "linux-64", + "timestamp": 1534346990064, + "version": "1.14.5" + }, + "numpy-1.14.5-py35h2aefc1b_4.tar.bz2": { + "build": "py35h2aefc1b_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py35h2b20989_4", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1b195766e54cb9e57b322f06251d4623", + "name": "numpy", + "sha256": "5a872c69dc4a9f2933b802234b18d10c0850ea9dcbc10b9237bea5bc85f67597", + "size": 36138, + "subdir": "linux-64", + "timestamp": 1534347292966, + "version": "1.14.5" + }, + "numpy-1.14.5-py35hcd700cb_0.tar.bz2": { + "build": "py35hcd700cb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py35hdbf6ddf_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a2810957b376a475538102328f4d07ac", + "name": "numpy", + "sha256": "1a718460e199ba7d37f955f1b657fe4e4eaa67ee2dabb7838b840d409fdbd67c", + "size": 96342, + "subdir": "linux-64", + "timestamp": 1528901303482, + "version": "1.14.5" + }, + "numpy-1.14.5-py36h1b885b7_4.tar.bz2": { + "build": "py36h1b885b7_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py36hdbf6ddf_4", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6ef35d246be6c5999a6d6afc4d086866", + "name": "numpy", + "sha256": "5c33b01e76eb9ae1bc5c1edab3d1f53766a79774d0d1057d155fa3dcb47e6766", + "size": 36187, + "subdir": "linux-64", + "timestamp": 1531342872355, + "version": "1.14.5" + }, + "numpy-1.14.5-py36h28100ab_0.tar.bz2": { + "build": "py36h28100ab_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py36h2b20989_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a92458f5513a6866d5457827936914b0", + "name": "numpy", + "sha256": "6d2d3955fc7558fbd9e80803f5b3e2f237f9532b504c138aec45f3c6c18f6763", + "size": 96205, + "subdir": "linux-64", + "timestamp": 1528900503265, + "version": "1.14.5" + }, + "numpy-1.14.5-py36h28100ab_1.tar.bz2": { + "build": "py36h28100ab_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py36h2b20989_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f88215cddd56080efe8bafc4469be890", + "name": "numpy", + "sha256": "429277b71f2d3916ab6b769d1c200bc8ee66e672cf9b68730f981bb7b747422d", + "size": 96094, + "subdir": "linux-64", + "timestamp": 1530353095209, + "version": "1.14.5" + }, + "numpy-1.14.5-py36h28100ab_2.tar.bz2": { + "build": "py36h28100ab_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py36h2b20989_2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "39e793d33c64abdd5d2f90dd1c792ee8", + "name": "numpy", + "sha256": "8031fbe590418b8c131dbada0c5b97e41f611d748d9744d9a281e69992b4c494", + "size": 95908, + "subdir": "linux-64", + "timestamp": 1530382418267, + "version": "1.14.5" + }, + "numpy-1.14.5-py36h28100ab_3.tar.bz2": { + "build": "py36h28100ab_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py36h2b20989_3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "77ce73b7bcc67550808f061804a8190b", + "name": "numpy", + "sha256": "cc387163b79442a22223c35c463e22bc891c23853bcb9df4491064759728308a", + "size": 95865, + "subdir": "linux-64", + "timestamp": 1530552845169, + "version": "1.14.5" + }, + "numpy-1.14.5-py36h2aefc1b_4.tar.bz2": { + "build": "py36h2aefc1b_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py36h2b20989_4", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "02d34e0bcaebc39030c20db40d8ca7dd", + "name": "numpy", + "sha256": "cf4d695e1f85b57ecbc59d632f6edc784974c7ee85b72226ed0c4258266f78e3", + "size": 36230, + "subdir": "linux-64", + "timestamp": 1531327711917, + "version": "1.14.5" + }, + "numpy-1.14.5-py36hcd700cb_0.tar.bz2": { + "build": "py36hcd700cb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py36hdbf6ddf_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fab44d93c9ee556b70d86826de7f36f1", + "name": "numpy", + "sha256": "e0f5fa131654efaf3fa0c1e71905fd37f72a1ede76c2c053aa1509d06dc1441e", + "size": 96379, + "subdir": "linux-64", + "timestamp": 1528901008333, + "version": "1.14.5" + }, + "numpy-1.14.5-py36hcd700cb_1.tar.bz2": { + "build": "py36hcd700cb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py36hdbf6ddf_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a6652fc0796f4eef67658d80e8ff09b0", + "name": "numpy", + "sha256": "a0ba664c523ac31db83e81911017e5d707f9cc78eaf2412386fba41724892bda", + "size": 96242, + "subdir": "linux-64", + "timestamp": 1530353606379, + "version": "1.14.5" + }, + "numpy-1.14.5-py36hcd700cb_2.tar.bz2": { + "build": "py36hcd700cb_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py36hdbf6ddf_2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b0d715a3e0e1fc17827353aa93b62561", + "name": "numpy", + "sha256": "9702863c0a3a6b3e83587cd9da9f23bf08ee113bf32e5e4aba8a1ffdf1b2c5fd", + "size": 95955, + "subdir": "linux-64", + "timestamp": 1530383344134, + "version": "1.14.5" + }, + "numpy-1.14.5-py36hcd700cb_3.tar.bz2": { + "build": "py36hcd700cb_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py36hdbf6ddf_3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "af5ecb6adedf75e5589adc5608c34d59", + "name": "numpy", + "sha256": "0a44b5e67abe7ef63f5535c739f5f8e3a34a0f83f1aaa9c2d8525bccc5bb21b8", + "size": 95914, + "subdir": "linux-64", + "timestamp": 1530553452313, + "version": "1.14.5" + }, + "numpy-1.14.5-py37h1b885b7_4.tar.bz2": { + "build": "py37h1b885b7_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py37hdbf6ddf_4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1ec4a85e9be321fb7a2ebf65f84f3b80", + "name": "numpy", + "sha256": "09da62be3e27b9869bcf10f15fbfc5ba009a47357fc35799d6239b211f8947a0", + "size": 36180, + "subdir": "linux-64", + "timestamp": 1531327401991, + "version": "1.14.5" + }, + "numpy-1.14.5-py37h28100ab_1.tar.bz2": { + "build": "py37h28100ab_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py37h2b20989_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "aea2c28b131051de266c10f43030952c", + "name": "numpy", + "sha256": "e3ebd867203ccc208ec62214e62032b97e02c7ae46d0a4b10e05ad6fba7130cf", + "size": 95972, + "subdir": "linux-64", + "timestamp": 1530353347449, + "version": "1.14.5" + }, + "numpy-1.14.5-py37h28100ab_2.tar.bz2": { + "build": "py37h28100ab_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py37h2b20989_2", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c932ff3e9a12943d14bbdf7214562f77", + "name": "numpy", + "sha256": "0a6a7de515591169fc2044539357f7038b8e48dc0b532e4b71fb284a2f488600", + "size": 95747, + "subdir": "linux-64", + "timestamp": 1530382891686, + "version": "1.14.5" + }, + "numpy-1.14.5-py37h28100ab_3.tar.bz2": { + "build": "py37h28100ab_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py37h2b20989_3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "490ecfa75b7f928e44ec2425dc057d23", + "name": "numpy", + "sha256": "22b01a4df3fed1ca6af2648998939a4169773ef323d95ef3134e63e224666c89", + "size": 95898, + "subdir": "linux-64", + "timestamp": 1530553165211, + "version": "1.14.5" + }, + "numpy-1.14.5-py37h2aefc1b_4.tar.bz2": { + "build": "py37h2aefc1b_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py37h2b20989_4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "feff7d8d08d7da73fb28722912d8dfb1", + "name": "numpy", + "sha256": "48b936c1d910465cfffe0f0d348185e29b27492e4cf7320b5a3a1eb1e4cab276", + "size": 36233, + "subdir": "linux-64", + "timestamp": 1531327081227, + "version": "1.14.5" + }, + "numpy-1.14.5-py37hcd700cb_1.tar.bz2": { + "build": "py37hcd700cb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py37hdbf6ddf_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "eed8ef0434eafb4ba8cecb19728f50bc", + "name": "numpy", + "sha256": "86373e67e2fa8b1c703041af08fde6ba9ef103c892e364948bb3fe62c10ee12a", + "size": 96141, + "subdir": "linux-64", + "timestamp": 1530353695727, + "version": "1.14.5" + }, + "numpy-1.14.5-py37hcd700cb_2.tar.bz2": { + "build": "py37hcd700cb_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py37hdbf6ddf_2", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "45a8ff683cbffb62c15fc491eb9c12a6", + "name": "numpy", + "sha256": "42386ca0e590627a3e5d9c850975daf5e074fc5615a9927c68bc6adf25586dfe", + "size": 95868, + "subdir": "linux-64", + "timestamp": 1530383342192, + "version": "1.14.5" + }, + "numpy-1.14.5-py37hcd700cb_3.tar.bz2": { + "build": "py37hcd700cb_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py37hdbf6ddf_3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0d8314a7da2949f19c18302e3651fb42", + "name": "numpy", + "sha256": "bca0ed50b72985df5b3ab33bdd0655c6e51d7c97e04608d60e0a7d18a018129b", + "size": 95890, + "subdir": "linux-64", + "timestamp": 1530553452068, + "version": "1.14.5" + }, + "numpy-1.14.6-py27h3b04361_4.tar.bz2": { + "build": "py27h3b04361_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.6 py27h81de0dd_4", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6453bce6395d76f42a4de47b0b053837", + "name": "numpy", + "sha256": "bd0fc5226607f365bf098e4a7f2d3f661bb5206c8a542e6fa6b9a5f87e667583", + "size": 46892, + "subdir": "linux-64", + "timestamp": 1538074664403, + "version": "1.14.6" + }, + "numpy-1.14.6-py27h3b04361_5.tar.bz2": { + "build": "py27h3b04361_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.6 py27hde5b4d6_5", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a005cdf8277bf44cac03ec1cd9fbdbc1", + "name": "numpy", + "sha256": "50fff3328bd4c3333469c439d6915cf74954c57f3e46cd82afbee6d40fbd9fd6", + "size": 47433, + "subdir": "linux-64", + "timestamp": 1569339416130, + "version": "1.14.6" + }, + "numpy-1.14.6-py27hec00662_4.tar.bz2": { + "build": "py27hec00662_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.6 py27h2f8d375_4", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2a249d8c8625e53c459aeb056dd964ad", + "name": "numpy", + "sha256": "efcd0763e2ab55e9f2159bee2b666c096394fd3c1bcc21be1bee38c3ea194e11", + "size": 46824, + "subdir": "linux-64", + "timestamp": 1538074873093, + "version": "1.14.6" + }, + "numpy-1.14.6-py27hec00662_5.tar.bz2": { + "build": "py27hec00662_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.6 py27h2f8d375_5", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2fb33b5763fb89d1cd89c557446f1b63", + "name": "numpy", + "sha256": "4c1d228d70c15b89c3b0ec64106980a11f6aaedffb73fa3a91210681a6fffedb", + "size": 47428, + "subdir": "linux-64", + "timestamp": 1569339394947, + "version": "1.14.6" + }, + "numpy-1.14.6-py35h3b04361_4.tar.bz2": { + "build": "py35h3b04361_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.6 py35h81de0dd_4", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "18a9e3c674c77c73567f9da2faf87add", + "name": "numpy", + "sha256": "d8e6b19267c859c90fd12ee3435dec7d7f3153bbbfbc2961570485f439fae912", + "size": 46891, + "subdir": "linux-64", + "timestamp": 1538074936064, + "version": "1.14.6" + }, + "numpy-1.14.6-py35hec00662_4.tar.bz2": { + "build": "py35hec00662_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.6 py35h2f8d375_4", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "11dfe61a9ccd0d33cf06ad9b9a89a4eb", + "name": "numpy", + "sha256": "05e7dd989f89514862a5a4a854593f4973cce4459af4a0ccf8c229350749585a", + "size": 46871, + "subdir": "linux-64", + "timestamp": 1538074512547, + "version": "1.14.6" + }, + "numpy-1.14.6-py36h3b04361_4.tar.bz2": { + "build": "py36h3b04361_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.6 py36h81de0dd_4", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b887778ea692b34a1ebe8746618f9350", + "name": "numpy", + "sha256": "52285baf47e1450cbcd8c7cdb7f0b75e9c771c6e8c5f2b033befaa93b67641b3", + "size": 46875, + "subdir": "linux-64", + "timestamp": 1538075090719, + "version": "1.14.6" + }, + "numpy-1.14.6-py36h3b04361_5.tar.bz2": { + "build": "py36h3b04361_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.6 py36hde5b4d6_5", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1393730af8c1d12e208f5ba74e4e9cc0", + "name": "numpy", + "sha256": "8f470137fc024e4f6d56ad50749a54027e5c23e1e4ab4b29e421cabcda0fdaf0", + "size": 47424, + "subdir": "linux-64", + "timestamp": 1569339435883, + "version": "1.14.6" + }, + "numpy-1.14.6-py36hec00662_4.tar.bz2": { + "build": "py36hec00662_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.6 py36h2f8d375_4", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5d8480fdd9b5aec71e15b22c3dead2c5", + "name": "numpy", + "sha256": "0f0248a7981d924b16988171f078fb25d07fc31976c4831469c5c42794f38e2b", + "size": 46817, + "subdir": "linux-64", + "timestamp": 1538074863701, + "version": "1.14.6" + }, + "numpy-1.14.6-py36hec00662_5.tar.bz2": { + "build": "py36hec00662_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.6 py36h2f8d375_5", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c346b5e1f673403114a269be16a1b50b", + "name": "numpy", + "sha256": "ad1ce2225a741231bb5604375b1e6364f01c809163bceea077e95ec41668252d", + "size": 47384, + "subdir": "linux-64", + "timestamp": 1569339285993, + "version": "1.14.6" + }, + "numpy-1.14.6-py37h3b04361_4.tar.bz2": { + "build": "py37h3b04361_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.6 py37h81de0dd_4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9eca05d41b15118e2957f682f199d1bc", + "name": "numpy", + "sha256": "0dab170a12c17b0d052ce0c862e4dfafedbf4819015d84442f71d3240047e76e", + "size": 46878, + "subdir": "linux-64", + "timestamp": 1538074957728, + "version": "1.14.6" + }, + "numpy-1.14.6-py37h3b04361_5.tar.bz2": { + "build": "py37h3b04361_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.6 py37hde5b4d6_5", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "de2d9ab7f7daf989a97fcbc89a06272c", + "name": "numpy", + "sha256": "df3f4473b3637be3d8c695089195a0f1af51d1d70cb1efa7b017f4b19ae130ab", + "size": 47431, + "subdir": "linux-64", + "timestamp": 1569339435202, + "version": "1.14.6" + }, + "numpy-1.14.6-py37hec00662_4.tar.bz2": { + "build": "py37hec00662_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.6 py37h2f8d375_4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2e9f1fd7f89c19d0c638580126e143f2", + "name": "numpy", + "sha256": "737ef59de5ee91f975afc6c9166e69c8c9ad2dceadb4666bfda54c2e5267c44b", + "size": 46846, + "subdir": "linux-64", + "timestamp": 1538074424595, + "version": "1.14.6" + }, + "numpy-1.14.6-py37hec00662_5.tar.bz2": { + "build": "py37hec00662_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.6 py37h2f8d375_5", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "69109fe7273b9d69ead7bc51ce0bdadc", + "name": "numpy", + "sha256": "c700af9b4a351a4dde09dd68fcd966413c084649aec21fcd685c714ed99b10a4", + "size": 47386, + "subdir": "linux-64", + "timestamp": 1569339389689, + "version": "1.14.6" + }, + "numpy-1.14.6-py38h056ac22_4.tar.bz2": { + "build": "py38h056ac22_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.6 py38hde5b4d6_4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "beac68e60d1f6e15f439a47e585cca4a", + "name": "numpy", + "sha256": "3b75b6483700afcc139d6dfbd1f9cf2fc7be3d86af4d6e4f36d7379dcfa796b0", + "size": 37010, + "subdir": "linux-64", + "timestamp": 1574081552811, + "version": "1.14.6" + }, + "numpy-1.14.6-py38h1e1a116_4.tar.bz2": { + "build": "py38h1e1a116_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.6 py38h2f8d375_4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "60a1ba5fc05afd4c87a9ac3382082963", + "name": "numpy", + "sha256": "035b061d54984a5c90eaa5e962bca0c607e3222c5d7182245a7a1362d67a4f53", + "size": 37019, + "subdir": "linux-64", + "timestamp": 1574081295349, + "version": "1.14.6" + }, + "numpy-1.15.0-py27h1b885b7_0.tar.bz2": { + "build": "py27h1b885b7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.0 py27h3dfced4_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "02c46141c68732190f90203743da7f3d", + "name": "numpy", + "sha256": "c112e912ecd491e26b47f747151ecdc8166fd61b5aa0e285e39ebd079cb6626c", + "size": 36365, + "subdir": "linux-64", + "timestamp": 1532704187980, + "version": "1.15.0" + }, + "numpy-1.15.0-py27h2aefc1b_0.tar.bz2": { + "build": "py27h2aefc1b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.15.0 py27h7cdd4dd_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e73c5f8488731ed1314f433021e195b7", + "name": "numpy", + "sha256": "729e6f8fc0b1d50ea448bede048db26f9746ba5f2712676f38cf4a7eaf43b047", + "size": 36325, + "subdir": "linux-64", + "timestamp": 1532703541812, + "version": "1.15.0" + }, + "numpy-1.15.0-py35h1b885b7_0.tar.bz2": { + "build": "py35h1b885b7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.0 py35h3dfced4_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1ad79d298ead105620e482d3f0e77429", + "name": "numpy", + "sha256": "5668c38e47e0706620a65e893c5432ae6c25eb390559bd4dcfafeb6c9aaf4e7c", + "size": 36343, + "subdir": "linux-64", + "timestamp": 1532704545516, + "version": "1.15.0" + }, + "numpy-1.15.0-py35h2aefc1b_0.tar.bz2": { + "build": "py35h2aefc1b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.15.0 py35h7cdd4dd_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6231b71f898a67ef71ab4f56e1500e7d", + "name": "numpy", + "sha256": "aae9ae720efea6e761337d04ffbabc78c326eee436c45b019c432c84f9cca8a8", + "size": 36329, + "subdir": "linux-64", + "timestamp": 1532703769720, + "version": "1.15.0" + }, + "numpy-1.15.0-py36h1b885b7_0.tar.bz2": { + "build": "py36h1b885b7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.0 py36h3dfced4_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "efe856ff4c77ed18b6f28cca84635d16", + "name": "numpy", + "sha256": "45f7b0ed3cb9316efe76f798e61a32c81ec67b0e8c77a77df958db4ea28e9439", + "size": 36333, + "subdir": "linux-64", + "timestamp": 1532704518202, + "version": "1.15.0" + }, + "numpy-1.15.0-py36h2aefc1b_0.tar.bz2": { + "build": "py36h2aefc1b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.15.0 py36h7cdd4dd_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5eafb6672782223539595c17288f5265", + "name": "numpy", + "sha256": "64bab7bdcdc652869c698370e0ec7460ba2ce908854329d3d7498e923c18994d", + "size": 36345, + "subdir": "linux-64", + "timestamp": 1532703550992, + "version": "1.15.0" + }, + "numpy-1.15.0-py37h1b885b7_0.tar.bz2": { + "build": "py37h1b885b7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.0 py37h3dfced4_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2a21d208d0b0eb03994866872b4d3619", + "name": "numpy", + "sha256": "adb738273cbbd12c620269f049fdbb4fa7fb14b3c8ed0e59a22c62d2f9e102a3", + "size": 36348, + "subdir": "linux-64", + "timestamp": 1532704587756, + "version": "1.15.0" + }, + "numpy-1.15.0-py37h2aefc1b_0.tar.bz2": { + "build": "py37h2aefc1b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.15.0 py37h7cdd4dd_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4dc5b70a77ead8a562c0f10f7c16ac08", + "name": "numpy", + "sha256": "f1822cd185e5dce9b2865e7b3a574119352cbb23d8db9baa822d60896825208e", + "size": 36315, + "subdir": "linux-64", + "timestamp": 1532703757997, + "version": "1.15.0" + }, + "numpy-1.15.1-py27h1d66e8a_0.tar.bz2": { + "build": "py27h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.1 py27h81de0dd_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4b0e02db61d4f7b76fc7aa046db5ac9f", + "name": "numpy", + "sha256": "ea2a6600e2051e5061f5db3880a0b8c433df5c3e6629ae75b30c8e422ac472ea", + "size": 38052, + "subdir": "linux-64", + "timestamp": 1535407582730, + "version": "1.15.1" + }, + "numpy-1.15.1-py27h3b04361_0.tar.bz2": { + "build": "py27h3b04361_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.1 py27h81de0dd_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "714126ab54cd9c7d7f77ef7831c2b9ce", + "name": "numpy", + "sha256": "74880bdcf348e2a9396d395e5190a1ff88ffaf1ac70face26f8eaf2a11032a6b", + "size": 37960, + "subdir": "linux-64", + "timestamp": 1535389873335, + "version": "1.15.1" + }, + "numpy-1.15.1-py27h99e49ec_0.tar.bz2": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.1 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "69a21ad38430832aa162e194756b4a38", + "name": "numpy", + "sha256": "0c41097def3adacbd91a6a63c9f7af7228810306e3dd7d42dc217298c7fe598a", + "size": 38165, + "subdir": "linux-64", + "timestamp": 1536895334350, + "version": "1.15.1" + }, + "numpy-1.15.1-py27hb510916_0.tar.bz2": { + "build": "py27hb510916_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.1 py27h74e8950_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "518581d5bf0ee30be57ab61334e2769c", + "name": "numpy", + "sha256": "da8bf4995055b9dc9dd4bac9d4d01a893591d16db58e0c911628946f39c050b3", + "size": 38013, + "subdir": "linux-64", + "timestamp": 1535407056627, + "version": "1.15.1" + }, + "numpy-1.15.1-py27hec00662_0.tar.bz2": { + "build": "py27hec00662_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.15.1 py27h74e8950_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d8f2dd26a9874af1fd0fed2cec248c35", + "name": "numpy", + "sha256": "f985203d1fbba58271cef45e926d8c63ff411e27c49dd4fc614cab152de9a194", + "size": 37937, + "subdir": "linux-64", + "timestamp": 1535389548249, + "version": "1.15.1" + }, + "numpy-1.15.1-py35h1d66e8a_0.tar.bz2": { + "build": "py35h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.1 py35h81de0dd_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0e297650f8dbbc7dd0bb9a1f4ffad604", + "name": "numpy", + "sha256": "b4bb62d51eec83fa2631d15d3891258ade95f11e3ce77c449cb5213cab1a1f55", + "size": 38074, + "subdir": "linux-64", + "timestamp": 1535408278866, + "version": "1.15.1" + }, + "numpy-1.15.1-py35h3b04361_0.tar.bz2": { + "build": "py35h3b04361_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.1 py35h81de0dd_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9f8a006f90c9cd1fdc1d7b92777370ec", + "name": "numpy", + "sha256": "f54eb531c7b503704bab7a2f26ceae6e31e7be0620b1a1d99b658fb2ea4b7ede", + "size": 37976, + "subdir": "linux-64", + "timestamp": 1535389511765, + "version": "1.15.1" + }, + "numpy-1.15.1-py35h99e49ec_0.tar.bz2": { + "build": "py35h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.1 py35h2f8d375_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c9d760d19f31339ad4b34db2ed85629c", + "name": "numpy", + "sha256": "4c18af3f2aee79b55b36c7ed7d70bb0de84d53947a43f95df0f53ef43002ad6e", + "size": 38148, + "subdir": "linux-64", + "timestamp": 1536895286333, + "version": "1.15.1" + }, + "numpy-1.15.1-py35hb510916_0.tar.bz2": { + "build": "py35hb510916_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.1 py35h74e8950_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bbae3d8ad2b0ab27abdc040cf11b7a4d", + "name": "numpy", + "sha256": "140117ac50c1529ac908bd3e6e822e0939d54957ca0fc068ca9a3fff82dee421", + "size": 38072, + "subdir": "linux-64", + "timestamp": 1535407049408, + "version": "1.15.1" + }, + "numpy-1.15.1-py35hec00662_0.tar.bz2": { + "build": "py35hec00662_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.15.1 py35h74e8950_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "17053874ee224119454877092267f411", + "name": "numpy", + "sha256": "790a37d8eb5461288b66ee6e2bb1b70c9c7cf30e443e3ab151a1f3dea8904399", + "size": 37976, + "subdir": "linux-64", + "timestamp": 1535389403990, + "version": "1.15.1" + }, + "numpy-1.15.1-py36h1d66e8a_0.tar.bz2": { + "build": "py36h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.1 py36h81de0dd_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2ed762dd94be9404a3161c7c76f9705f", + "name": "numpy", + "sha256": "a8806803190091be34953e2bef4809fa1156cd50ecb1160436f193c70613f61b", + "size": 38032, + "subdir": "linux-64", + "timestamp": 1535407129597, + "version": "1.15.1" + }, + "numpy-1.15.1-py36h3b04361_0.tar.bz2": { + "build": "py36h3b04361_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.1 py36h81de0dd_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "28e7b626802c49da4c158c8861809c8b", + "name": "numpy", + "sha256": "52e4eb8ff2fe095c56424388706e495539015bc63f42ba9ab97428b173494b91", + "size": 37946, + "subdir": "linux-64", + "timestamp": 1535389881478, + "version": "1.15.1" + }, + "numpy-1.15.1-py36h99e49ec_0.tar.bz2": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.1 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7b774a1f5522344f0fc1f60b4d6fc94b", + "name": "numpy", + "sha256": "db650ed2a3801fb5d095f3371c7387fc977ea8945995e8f86d665c6c30632e90", + "size": 38139, + "subdir": "linux-64", + "timestamp": 1536895336631, + "version": "1.15.1" + }, + "numpy-1.15.1-py36hb510916_0.tar.bz2": { + "build": "py36hb510916_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.1 py36h74e8950_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c9ad82bd5939e3661b3a0b3af93f2a3c", + "name": "numpy", + "sha256": "4f869e79da21d1f56bd5d16e82a759a685bf86fdd86734e13a41512756b45062", + "size": 38014, + "subdir": "linux-64", + "timestamp": 1535407086031, + "version": "1.15.1" + }, + "numpy-1.15.1-py36hec00662_0.tar.bz2": { + "build": "py36hec00662_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.15.1 py36h74e8950_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bc130ceb4cf69eb68104cf51f7d8bb57", + "name": "numpy", + "sha256": "73b2dc6a57a4f74d8eb794eef6dff900b2c11146708fc2ccb7c048268eabdb73", + "size": 37961, + "subdir": "linux-64", + "timestamp": 1535389603433, + "version": "1.15.1" + }, + "numpy-1.15.1-py37h1d66e8a_0.tar.bz2": { + "build": "py37h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.1 py37h81de0dd_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f191c16566d9b9778c49becd86fb2d18", + "name": "numpy", + "sha256": "5c9a3f628d5d82863f2b12edf608978cae31ad88c117c123a39edba18448948d", + "size": 38036, + "subdir": "linux-64", + "timestamp": 1535408275702, + "version": "1.15.1" + }, + "numpy-1.15.1-py37h3b04361_0.tar.bz2": { + "build": "py37h3b04361_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.1 py37h81de0dd_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6b4fba2e2ada304ca57e84a93ae8c7a5", + "name": "numpy", + "sha256": "cfcfaae01867cfb8450679d458f45409798c6b3b0ceb9f49763a20c49d8bc629", + "size": 37969, + "subdir": "linux-64", + "timestamp": 1535389886591, + "version": "1.15.1" + }, + "numpy-1.15.1-py37h99e49ec_0.tar.bz2": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.1 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8507fa963a6318115964bc690c2dd29e", + "name": "numpy", + "sha256": "f6c168c118fc4911c233cd3c25774fdb331afe0f6cb10bd78d1c21538245241c", + "size": 38153, + "subdir": "linux-64", + "timestamp": 1536895340717, + "version": "1.15.1" + }, + "numpy-1.15.1-py37hb510916_0.tar.bz2": { + "build": "py37hb510916_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.1 py37h74e8950_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "74f3ec62d11d6cc413781a80a9b815db", + "name": "numpy", + "sha256": "5e2d7848bf54fcc3589511d9e7ffbe7c6e9bc9d39f9bc8650cc0519be1adbba3", + "size": 38044, + "subdir": "linux-64", + "timestamp": 1535407102337, + "version": "1.15.1" + }, + "numpy-1.15.1-py37hec00662_0.tar.bz2": { + "build": "py37hec00662_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.15.1 py37h74e8950_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "368fb77c561f30a8b13322434ceadd97", + "name": "numpy", + "sha256": "86c62564127bcbd1aedbd32e6b331547db32674bf7287fed2d73b5533b9950ae", + "size": 37955, + "subdir": "linux-64", + "timestamp": 1535389600937, + "version": "1.15.1" + }, + "numpy-1.15.2-py27h1d66e8a_0.tar.bz2": { + "build": "py27h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.2 py27h81de0dd_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c7d722fe7e2d8671ca2afc6bec6aca47", + "name": "numpy", + "sha256": "353a4aba242e71829a81d44091d38d5159180aeade98b9c6a89d6cd8c04019e0", + "size": 48447, + "subdir": "linux-64", + "timestamp": 1538073714737, + "version": "1.15.2" + }, + "numpy-1.15.2-py27h1d66e8a_1.tar.bz2": { + "build": "py27h1d66e8a_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.2 py27h81de0dd_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9364ed07b71de1e9de1df4610fb77992", + "name": "numpy", + "sha256": "99e144d9549a0699a14454e8ef70f3876fb1601dfce26ad6d707c4dce47d81de", + "size": 48946, + "subdir": "linux-64", + "timestamp": 1538500430792, + "version": "1.15.2" + }, + "numpy-1.15.2-py27h99e49ec_0.tar.bz2": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a4dbb6659ad2c08e8be4132fd9a79d75", + "name": "numpy", + "sha256": "281ee4da489bfcf4af89b5d028c1722c24686bd3a9cca7359b510461601adcf2", + "size": 48410, + "subdir": "linux-64", + "timestamp": 1538073538538, + "version": "1.15.2" + }, + "numpy-1.15.2-py27h99e49ec_1.tar.bz2": { + "build": "py27h99e49ec_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py27h2f8d375_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3ea53a99f553c74ec8273024f74b1cf4", + "name": "numpy", + "sha256": "c7c5bf048677b2ac28051dc8870833f14870da91a69ef836150bd9a894f8f7d0", + "size": 48882, + "subdir": "linux-64", + "timestamp": 1538500385303, + "version": "1.15.2" + }, + "numpy-1.15.2-py35h1d66e8a_0.tar.bz2": { + "build": "py35h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.2 py35h81de0dd_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f10c2fe8716ddc3d4406ed65644893eb", + "name": "numpy", + "sha256": "e74e66fa3b36dd9d0b5afa94b33021b17a73a565ee244ff84f6236474aa7853e", + "size": 48448, + "subdir": "linux-64", + "timestamp": 1538073738748, + "version": "1.15.2" + }, + "numpy-1.15.2-py35h99e49ec_0.tar.bz2": { + "build": "py35h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py35h2f8d375_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "666534d614638e5778626679b92fdfc2", + "name": "numpy", + "sha256": "36fa2e45b5534e84c07c23c683c924b02c164b14c9c3199c19548c757a82ab84", + "size": 48395, + "subdir": "linux-64", + "timestamp": 1538073967538, + "version": "1.15.2" + }, + "numpy-1.15.2-py36h1d66e8a_0.tar.bz2": { + "build": "py36h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.2 py36h81de0dd_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e3ffb99498c704c33ede067160cbde2a", + "name": "numpy", + "sha256": "12566de7f7cb205bb98b758b7f138cb7597abedff002c0d2793f4221c75afd7b", + "size": 48443, + "subdir": "linux-64", + "timestamp": 1538074354653, + "version": "1.15.2" + }, + "numpy-1.15.2-py36h1d66e8a_1.tar.bz2": { + "build": "py36h1d66e8a_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.2 py36h81de0dd_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "989689edf63af2fa7cd9474d7f67ca60", + "name": "numpy", + "sha256": "307158f3134963d765f7eaf26b3383b565620c70aa53c011eaab169a86929036", + "size": 48947, + "subdir": "linux-64", + "timestamp": 1538500668649, + "version": "1.15.2" + }, + "numpy-1.15.2-py36h99e49ec_0.tar.bz2": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ebaa418193b6946053ce7d6b6f9304bf", + "name": "numpy", + "sha256": "7374417d8a16225cc9d019c71ec73315578eb4db94ed3075945926c8a96faecc", + "size": 48357, + "subdir": "linux-64", + "timestamp": 1538074241440, + "version": "1.15.2" + }, + "numpy-1.15.2-py36h99e49ec_1.tar.bz2": { + "build": "py36h99e49ec_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py36h2f8d375_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6379c3dd157e61bd575040b177f04128", + "name": "numpy", + "sha256": "aa046b35a7993f442f27737a47cb5e1875c0ccd55bc8f0d44a2e5bef99908d8e", + "size": 48914, + "subdir": "linux-64", + "timestamp": 1538500379496, + "version": "1.15.2" + }, + "numpy-1.15.2-py37h1d66e8a_0.tar.bz2": { + "build": "py37h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.2 py37h81de0dd_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "126d17fff3f9ff4ff32c0de595a76292", + "name": "numpy", + "sha256": "22c33fea8da4e738a20dbcb77eb41348fdd9546c5f28e92499cba84b73e6724c", + "size": 48417, + "subdir": "linux-64", + "timestamp": 1538073682252, + "version": "1.15.2" + }, + "numpy-1.15.2-py37h1d66e8a_1.tar.bz2": { + "build": "py37h1d66e8a_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.2 py37h81de0dd_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "031c04c67ca1ff88fcb680465cc56284", + "name": "numpy", + "sha256": "6e76fd4e6328c37f6a46c009c55759d74803f26d61ef6df6e289349c4dfba521", + "size": 48945, + "subdir": "linux-64", + "timestamp": 1538504451435, + "version": "1.15.2" + }, + "numpy-1.15.2-py37h99e49ec_0.tar.bz2": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b28a28aa8dbe76a85bea2584372a0e03", + "name": "numpy", + "sha256": "575c0d329929090f28bfdf054eaebc0d37f2d900f940e8e05a915185769d9233", + "size": 48396, + "subdir": "linux-64", + "timestamp": 1538073472259, + "version": "1.15.2" + }, + "numpy-1.15.2-py37h99e49ec_1.tar.bz2": { + "build": "py37h99e49ec_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py37h2f8d375_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b8a89f6286f06db1765dcf54a5d586b0", + "name": "numpy", + "sha256": "80c145dea207eed6fd0f17f9df7d705d68ded6ff924fccdf74edd1e30b35d899", + "size": 48915, + "subdir": "linux-64", + "timestamp": 1538504550809, + "version": "1.15.2" + }, + "numpy-1.15.3-py27h1d66e8a_0.tar.bz2": { + "build": "py27h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.3 py27h81de0dd_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9095167b7aebbea9e173e6675f3c829e", + "name": "numpy", + "sha256": "f311dcf9854151f72f90220b822c01e0f6ef1e29a437338170d1714c741384af", + "size": 36458, + "subdir": "linux-64", + "timestamp": 1540314318231, + "version": "1.15.3" + }, + "numpy-1.15.3-py27h99e49ec_0.tar.bz2": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.3 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "59596b3f5df692e1157be1437f50fd2a", + "name": "numpy", + "sha256": "e5caa4011e7b5215bb143e02086bffac02091fd8d5a2c84f4538b59683eb12da", + "size": 36473, + "subdir": "linux-64", + "timestamp": 1540314067451, + "version": "1.15.3" + }, + "numpy-1.15.3-py36h1d66e8a_0.tar.bz2": { + "build": "py36h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.3 py36h81de0dd_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2399bc8a540a9d841f506311bd291d94", + "name": "numpy", + "sha256": "d8cb1b6c792a816166430dcf480be05399ded2fbcb9e2d34135562eb2615c419", + "size": 36532, + "subdir": "linux-64", + "timestamp": 1540314343193, + "version": "1.15.3" + }, + "numpy-1.15.3-py36h99e49ec_0.tar.bz2": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.3 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d8037bda8884f430584859bf9ca1b38f", + "name": "numpy", + "sha256": "fb211b8e0ee9b1b0ac2644b610d83655ace6f0413c5fd90331502099bef5023a", + "size": 36470, + "subdir": "linux-64", + "timestamp": 1540314085588, + "version": "1.15.3" + }, + "numpy-1.15.3-py37h1d66e8a_0.tar.bz2": { + "build": "py37h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.3 py37h81de0dd_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4e92ed4f995b0ed5839659d2385be4b3", + "name": "numpy", + "sha256": "1a9de056b711d2f16edfebd0c2535656b4860fa106583456e908253141c8c929", + "size": 36443, + "subdir": "linux-64", + "timestamp": 1540314556123, + "version": "1.15.3" + }, + "numpy-1.15.3-py37h99e49ec_0.tar.bz2": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.3 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1ca6f080a658ead18ee8b7fc69d3a198", + "name": "numpy", + "sha256": "8a89f7894cdb546faffd3b03137a2a3aca4fc6c60a1a1b16ff17fa02fe6fcf32", + "size": 36488, + "subdir": "linux-64", + "timestamp": 1540314120026, + "version": "1.15.3" + }, + "numpy-1.15.4-py27h1d66e8a_0.tar.bz2": { + "build": "py27h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.4 py27h81de0dd_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2a62562351b76c8f020be58e51e8ac88", + "name": "numpy", + "sha256": "bcd63d9a49b5f407b845e38e046a158cc2aadb45a177e036389af3ff5a329746", + "size": 36235, + "subdir": "linux-64", + "timestamp": 1541517021003, + "version": "1.15.4" + }, + "numpy-1.15.4-py27h7e9f1db_0.tar.bz2": { + "build": "py27h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.15.4 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9dde1f99a14aaf3f81a66d2fee4f201d", + "name": "numpy", + "sha256": "b56b119f3bca451c75f3563ff1e0e35747afd877e73e91c82a2f2cb51dd7305b", + "size": 47891, + "subdir": "linux-64", + "timestamp": 1544718236196, + "version": "1.15.4" + }, + "numpy-1.15.4-py27h99e49ec_0.tar.bz2": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.4 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c70b5f176024ebb940cc161f981fd06d", + "name": "numpy", + "sha256": "f5b9171ccae6680384fe259b4f9a029487cce71954c4f27f02b10a7233b43d11", + "size": 36223, + "subdir": "linux-64", + "timestamp": 1541516712938, + "version": "1.15.4" + }, + "numpy-1.15.4-py36h1d66e8a_0.tar.bz2": { + "build": "py36h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.4 py36h81de0dd_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c5b3d992614b29e3ce1fc1a67b0b5f09", + "name": "numpy", + "sha256": "02eafdf68e76d851191cf495aa61c614ec49227692902bc62213626b9911ebec", + "size": 36247, + "subdir": "linux-64", + "timestamp": 1541516971923, + "version": "1.15.4" + }, + "numpy-1.15.4-py36h7e9f1db_0.tar.bz2": { + "build": "py36h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.15.4 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f1f6f769bd61a461fdddd007e52b47f6", + "name": "numpy", + "sha256": "d0cf8bb5f67fd93dfbe9c4c25de13099dba546a01f52fec79ee1f1b0d085be7d", + "size": 47852, + "subdir": "linux-64", + "timestamp": 1544718317867, + "version": "1.15.4" + }, + "numpy-1.15.4-py36h99e49ec_0.tar.bz2": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.4 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "398e05574754ea944198bacc012f7922", + "name": "numpy", + "sha256": "411ad4e2cf29467ed99f3b2841743bd42c7174c1680258e5be3f5accb6240e99", + "size": 36211, + "subdir": "linux-64", + "timestamp": 1541516710496, + "version": "1.15.4" + }, + "numpy-1.15.4-py37h1d66e8a_0.tar.bz2": { + "build": "py37h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.4 py37h81de0dd_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "57db3437d6f15ff777a3579e0b564606", + "name": "numpy", + "sha256": "7f0344dfa338399b749f76e06f02c068bdbdef2e23c48e8a9ae11bd1cce3dfbe", + "size": 36244, + "subdir": "linux-64", + "timestamp": 1541516936685, + "version": "1.15.4" + }, + "numpy-1.15.4-py37h7e9f1db_0.tar.bz2": { + "build": "py37h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.15.4 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0397664ae3fe05443538e7857ad9c72f", + "name": "numpy", + "sha256": "8b3c014774ac0d2bf1c85b48df683a4998e6dcc8f5011b5197588755a62c5b58", + "size": 47870, + "subdir": "linux-64", + "timestamp": 1544718483928, + "version": "1.15.4" + }, + "numpy-1.15.4-py37h99e49ec_0.tar.bz2": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.4 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8456425047f88f25b8bc7d7a9103eb96", + "name": "numpy", + "sha256": "fca218bb888e6060e403c211a24ec03e5ef1b13341972fff75b274cf8fd8e59d", + "size": 36211, + "subdir": "linux-64", + "timestamp": 1541516556315, + "version": "1.15.4" + }, + "numpy-1.16.0-py27h7e9f1db_0.tar.bz2": { + "build": "py27h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.0 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bc73fefa72eb8875d6402aed95ba9ded", + "name": "numpy", + "sha256": "82844142888e6435b88f51934fd11de26384b9def18405511acbf2f91fc947a5", + "size": 49411, + "subdir": "linux-64", + "timestamp": 1551398152571, + "version": "1.16.0" + }, + "numpy-1.16.0-py27h7e9f1db_1.tar.bz2": { + "build": "py27h7e9f1db_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.0 py27hde5b4d6_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f02318af76c36a8c76b5bd53a4b789f3", + "name": "numpy", + "sha256": "b5b7037f258a46a0bc872193c619971be1401cd3603280eae484d159ba2af0cc", + "size": 49886, + "subdir": "linux-64", + "timestamp": 1551802058816, + "version": "1.16.0" + }, + "numpy-1.16.0-py27h99e49ec_0.tar.bz2": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bc372bca72641b2043cbc8cf04324b1b", + "name": "numpy", + "sha256": "c05c8edd11ca05f3226c2ddee7dc29cf26b9fb559a882c041040d7ac0db16b37", + "size": 49243, + "subdir": "linux-64", + "timestamp": 1551397995143, + "version": "1.16.0" + }, + "numpy-1.16.0-py27h99e49ec_1.tar.bz2": { + "build": "py27h99e49ec_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py27h2f8d375_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5162796dd885b5c530bcfc4753a6f146", + "name": "numpy", + "sha256": "aa22020d1db709cec1022df3f0d33a4aaa6a96370494ed5a49264b02704ca735", + "size": 49715, + "subdir": "linux-64", + "timestamp": 1551801711529, + "version": "1.16.0" + }, + "numpy-1.16.0-py36h7e9f1db_0.tar.bz2": { + "build": "py36h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.0 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "139dabc97468bd2bc97208082b25b964", + "name": "numpy", + "sha256": "fdebf3adb4d4433a49afc0adb0eb8acc15ee5298fc39b087154f6b63fd2a0a4c", + "size": 49412, + "subdir": "linux-64", + "timestamp": 1551398204357, + "version": "1.16.0" + }, + "numpy-1.16.0-py36h7e9f1db_1.tar.bz2": { + "build": "py36h7e9f1db_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.0 py36hde5b4d6_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d254179eb671e38f87569eeb3677545a", + "name": "numpy", + "sha256": "bae977735d98930e0573203be046899396bd50f4ec4566bd9ef35c0fbc49e2c8", + "size": 49817, + "subdir": "linux-64", + "timestamp": 1551802104144, + "version": "1.16.0" + }, + "numpy-1.16.0-py36h99e49ec_0.tar.bz2": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d3c556e2a821ff023c7c318b2ec4d723", + "name": "numpy", + "sha256": "7f18d13d6d032ee4cba4e5f532d11571c115efb139fe8a3355645f9f030d616c", + "size": 49272, + "subdir": "linux-64", + "timestamp": 1551398078821, + "version": "1.16.0" + }, + "numpy-1.16.0-py36h99e49ec_1.tar.bz2": { + "build": "py36h99e49ec_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py36h2f8d375_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a03d891b8e4b7964467669391ee1de24", + "name": "numpy", + "sha256": "838b1718dbbd195c5945b1b09102b46cfd431c97f37cc06d891e5e0f626c6550", + "size": 49708, + "subdir": "linux-64", + "timestamp": 1551801797340, + "version": "1.16.0" + }, + "numpy-1.16.0-py37h7e9f1db_0.tar.bz2": { + "build": "py37h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.0 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "347ce4cd8ece43bb2ddae9cc36f584c9", + "name": "numpy", + "sha256": "7ac0f89197596eaa6f9fb35aa4636b8c6d1a558fc6dd597875315187bdc2d3f3", + "size": 49387, + "subdir": "linux-64", + "timestamp": 1551398069626, + "version": "1.16.0" + }, + "numpy-1.16.0-py37h7e9f1db_1.tar.bz2": { + "build": "py37h7e9f1db_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.0 py37hde5b4d6_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0549b1de2e8d14c19079b9c0b91793d8", + "name": "numpy", + "sha256": "5711eb240af4784e63d4874617b8f5219db6ae57c2627266dc3f6d3a1d67f77a", + "size": 49881, + "subdir": "linux-64", + "timestamp": 1551801953198, + "version": "1.16.0" + }, + "numpy-1.16.0-py37h99e49ec_0.tar.bz2": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "45e0a9d2335c0f65bdc75a9238aee086", + "name": "numpy", + "sha256": "f3a1226e63184b946718282ed11cb3769e772a14e6ce1dd61b43db8b6cb55057", + "size": 49262, + "subdir": "linux-64", + "timestamp": 1551398033129, + "version": "1.16.0" + }, + "numpy-1.16.0-py37h99e49ec_1.tar.bz2": { + "build": "py37h99e49ec_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py37h2f8d375_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1c08db87ef550a64da29ce70d59ffab5", + "name": "numpy", + "sha256": "b3c96f10131326541bd8aa868c1227c7a79a247d923ef3f1698e031fe6eeec4b", + "size": 49707, + "subdir": "linux-64", + "timestamp": 1551801682601, + "version": "1.16.0" + }, + "numpy-1.16.1-py27h7e9f1db_0.tar.bz2": { + "build": "py27h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.1 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a9a5fa92e11024b3f526c528feea803a", + "name": "numpy", + "sha256": "5a260da5cbbe82be2c351fe3a914d5384cbaf5218ea84d88262120086c3bb188", + "size": 49536, + "subdir": "linux-64", + "timestamp": 1551457208800, + "version": "1.16.1" + }, + "numpy-1.16.1-py27h7e9f1db_1.tar.bz2": { + "build": "py27h7e9f1db_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.1 py27hde5b4d6_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5f307b3dae2d953763d2d8f00e489eeb", + "name": "numpy", + "sha256": "50990994a8d30da436ab8f9a449680bf539dac99e969191eef52fceb8b9f949c", + "size": 49910, + "subdir": "linux-64", + "timestamp": 1551468320350, + "version": "1.16.1" + }, + "numpy-1.16.1-py27h99e49ec_0.tar.bz2": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cf9fb991576a1d725a1c8f6becec2074", + "name": "numpy", + "sha256": "0db19501f6ae6351c6c1b84b96f0fe5ac798e966f74a16226b00933ed082ebaf", + "size": 49368, + "subdir": "linux-64", + "timestamp": 1551457074995, + "version": "1.16.1" + }, + "numpy-1.16.1-py27h99e49ec_1.tar.bz2": { + "build": "py27h99e49ec_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py27h2f8d375_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9aa88898ff763930b995e4ff695e19f2", + "name": "numpy", + "sha256": "23eb36c67e82d0ba8daf6650f247a4c7072dc670678b9c35c8a8ebb1d3bb71d0", + "size": 49747, + "subdir": "linux-64", + "timestamp": 1551468061464, + "version": "1.16.1" + }, + "numpy-1.16.1-py36h7e9f1db_0.tar.bz2": { + "build": "py36h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.1 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8cb442b68a6f986e6300c77b464917b0", + "name": "numpy", + "sha256": "89bae373aafda9f93596d0648e7dd0af6b04822f4c5909cc69e6df0e5e05ad3f", + "size": 49476, + "subdir": "linux-64", + "timestamp": 1551457139698, + "version": "1.16.1" + }, + "numpy-1.16.1-py36h7e9f1db_1.tar.bz2": { + "build": "py36h7e9f1db_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.1 py36hde5b4d6_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8855db7ba8cf3d72e57998a678b66213", + "name": "numpy", + "sha256": "e810f83bf79e3e2e6e5d5fc9fdc141b7196790ecbd69f7c2df3053706e46ed3b", + "size": 49870, + "subdir": "linux-64", + "timestamp": 1551468263373, + "version": "1.16.1" + }, + "numpy-1.16.1-py36h99e49ec_0.tar.bz2": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "72c3e2e0239f8850fc3689320c7740dc", + "name": "numpy", + "sha256": "749b5325079ca8f6185ab291a107217fd8da17cd752ee0cad5a40c35cb29b5b9", + "size": 49373, + "subdir": "linux-64", + "timestamp": 1551457106934, + "version": "1.16.1" + }, + "numpy-1.16.1-py36h99e49ec_1.tar.bz2": { + "build": "py36h99e49ec_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py36h2f8d375_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "204e7a69db7b92137285f8092ee5a9e6", + "name": "numpy", + "sha256": "647e012338c50c7a7545a801cbe7f68cac87d42cfb608c2acc9a9035cbfdfa7d", + "size": 49745, + "subdir": "linux-64", + "timestamp": 1551468096951, + "version": "1.16.1" + }, + "numpy-1.16.1-py37h7e9f1db_0.tar.bz2": { + "build": "py37h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.1 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "83d98d5c1447cb07f7e09b066838b0d6", + "name": "numpy", + "sha256": "5257c3d7ac78c9a33d12c5aa59652785a0efbd347c05b998ed37a6874360b340", + "size": 49502, + "subdir": "linux-64", + "timestamp": 1551457177425, + "version": "1.16.1" + }, + "numpy-1.16.1-py37h7e9f1db_1.tar.bz2": { + "build": "py37h7e9f1db_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.1 py37hde5b4d6_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "47e375aed376ca797c53b4ae262a6868", + "name": "numpy", + "sha256": "41b245a8e617a371581b443487fae65365f0734eff28d8e4727b26ab15af596f", + "size": 49902, + "subdir": "linux-64", + "timestamp": 1551468149397, + "version": "1.16.1" + }, + "numpy-1.16.1-py37h99e49ec_0.tar.bz2": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f407fde5d43b043a3fb0eb5f0c17b3ba", + "name": "numpy", + "sha256": "2239ee27297c73e6a4f25379e22eecab1e6ea1f91a24d730c561c7e891df6624", + "size": 49356, + "subdir": "linux-64", + "timestamp": 1551457034367, + "version": "1.16.1" + }, + "numpy-1.16.1-py37h99e49ec_1.tar.bz2": { + "build": "py37h99e49ec_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py37h2f8d375_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "850cfaf1811e1c23ad44411e42a04f35", + "name": "numpy", + "sha256": "1fa3b8a9889b58b12f6545d1ab67d8bdbd442fc7241752a0ecd69292fbb8e767", + "size": 49695, + "subdir": "linux-64", + "timestamp": 1551468093572, + "version": "1.16.1" + }, + "numpy-1.16.2-py27h7e9f1db_0.tar.bz2": { + "build": "py27h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.2 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3ee3fe263f437894b2cee6dcf9627c9e", + "name": "numpy", + "sha256": "7c6c3c86860cd2f9465d4e3f8ee1668719bc0fb95fbae06e129cdbfecf51134a", + "size": 49954, + "subdir": "linux-64", + "timestamp": 1551471411466, + "version": "1.16.2" + }, + "numpy-1.16.2-py27h99e49ec_0.tar.bz2": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.2 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2ec6773a98b2a978ec21e4cb309ec793", + "name": "numpy", + "sha256": "153d759c7303316619ec4edc22a320ac745c5b55aea91a01c9c4c0ea81798c95", + "size": 49789, + "subdir": "linux-64", + "timestamp": 1551471231079, + "version": "1.16.2" + }, + "numpy-1.16.2-py36h7e9f1db_0.tar.bz2": { + "build": "py36h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.2 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "810f2a564ed754fe0166e745db711eb7", + "name": "numpy", + "sha256": "6e72f621ee9c69c3dae437ea20b03cc77852f6c9b0294783c3d02013f0fbbd7a", + "size": 49949, + "subdir": "linux-64", + "timestamp": 1551471520907, + "version": "1.16.2" + }, + "numpy-1.16.2-py36h99e49ec_0.tar.bz2": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.2 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f8daf35fc153276155d89303c4c111ca", + "name": "numpy", + "sha256": "e64dd350e54057ef2ef4dbd47a8bb249bb1e154fffc9006b1db9ef38ca1d6b68", + "size": 49830, + "subdir": "linux-64", + "timestamp": 1551471220609, + "version": "1.16.2" + }, + "numpy-1.16.2-py37h7e9f1db_0.tar.bz2": { + "build": "py37h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.2 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a81651371d8bc66afb0e049ad6880cb2", + "name": "numpy", + "sha256": "d7c5380c7d7ef80cb7c859f20210186babd900c8a7fb5feda7ec620a949656dc", + "size": 49952, + "subdir": "linux-64", + "timestamp": 1551471375641, + "version": "1.16.2" + }, + "numpy-1.16.2-py37h99e49ec_0.tar.bz2": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.2 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d3eef0734825d68781a9f0f9a1c205e4", + "name": "numpy", + "sha256": "fe0e6133a45e9a5ec6595905d45b6362d399f9e0d17c2a792ec98d1bdd082f6d", + "size": 49824, + "subdir": "linux-64", + "timestamp": 1551471203547, + "version": "1.16.2" + }, + "numpy-1.16.3-py27h7e9f1db_0.tar.bz2": { + "build": "py27h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.3 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a65de56becf2dbb502df488fc25e9817", + "name": "numpy", + "sha256": "12ae295dad007a98ea00dab79b3aa032401b9c186199eee8df6f2c44aa0ef72a", + "size": 49937, + "subdir": "linux-64", + "timestamp": 1555949732605, + "version": "1.16.3" + }, + "numpy-1.16.3-py27h99e49ec_0.tar.bz2": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.3 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a8cf74532faa145e19003201c5b8ad2a", + "name": "numpy", + "sha256": "5ce854c5af3945bffff6b931ba492a37a442cf6a0969f15e3f341dde03180246", + "size": 49790, + "subdir": "linux-64", + "timestamp": 1555949431373, + "version": "1.16.3" + }, + "numpy-1.16.3-py36h7e9f1db_0.tar.bz2": { + "build": "py36h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.3 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "765d08be86b6e5e84df262429ecf2df5", + "name": "numpy", + "sha256": "c4a186643d1d990af483d263a351d5d63c46122dd6e51c179525f8fa31fc56d5", + "size": 49918, + "subdir": "linux-64", + "timestamp": 1555949759152, + "version": "1.16.3" + }, + "numpy-1.16.3-py36h99e49ec_0.tar.bz2": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.3 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "66aafe102f149222b869de0f92173c1e", + "name": "numpy", + "sha256": "eae95150aec17afd869f6627da16ce9398a21d3591840197be285d24ee2c95a8", + "size": 49836, + "subdir": "linux-64", + "timestamp": 1555949575241, + "version": "1.16.3" + }, + "numpy-1.16.3-py37h7e9f1db_0.tar.bz2": { + "build": "py37h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.3 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "721a62e7e8502746b9fbe064dcbc798f", + "name": "numpy", + "sha256": "3aa8b457cd22142f29b4cc258af77c3123a4ff54cc1cfff149574d969adf5ec6", + "size": 49923, + "subdir": "linux-64", + "timestamp": 1555949602270, + "version": "1.16.3" + }, + "numpy-1.16.3-py37h99e49ec_0.tar.bz2": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.3 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3930bf00cd676e2577d585c168e99f37", + "name": "numpy", + "sha256": "89f39ad4328518ed89348c25b31e1c6695836453e059b7ef0dd3f56a70098c83", + "size": 49766, + "subdir": "linux-64", + "timestamp": 1555949467632, + "version": "1.16.3" + }, + "numpy-1.16.4-py27h7e9f1db_0.tar.bz2": { + "build": "py27h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.4 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c524dce988863fde9094abb1a0525aa8", + "name": "numpy", + "sha256": "71afa7377abcd55e5c7a01d816290504ebf043857785378e54ac939e20b48ad8", + "size": 49993, + "subdir": "linux-64", + "timestamp": 1559140725820, + "version": "1.16.4" + }, + "numpy-1.16.4-py27h99e49ec_0.tar.bz2": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.4 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "be562665c2e58fa9fefd3e3dc248a8b1", + "name": "numpy", + "sha256": "6f84931c011eedab13391674ec872b4e7eb8140da278a7d997be245c772b4c67", + "size": 49828, + "subdir": "linux-64", + "timestamp": 1559140307867, + "version": "1.16.4" + }, + "numpy-1.16.4-py36h7e9f1db_0.tar.bz2": { + "build": "py36h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.4 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "27bb43202b372bdb1a5b64c5dabb68f5", + "name": "numpy", + "sha256": "1b0a698bab4ab770b4be1bf84ef7dd37b360ef6000fb89d1a48073afe52c5195", + "size": 49993, + "subdir": "linux-64", + "timestamp": 1559141073019, + "version": "1.16.4" + }, + "numpy-1.16.4-py36h99e49ec_0.tar.bz2": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.4 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "170bdff51460f409d0d4d7eea25d4656", + "name": "numpy", + "sha256": "50f112ca437daa569565f0f365a670f6756d430d316b51363892d22e03837ddf", + "size": 49832, + "subdir": "linux-64", + "timestamp": 1559140310232, + "version": "1.16.4" + }, + "numpy-1.16.4-py37h7e9f1db_0.tar.bz2": { + "build": "py37h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.4 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6dd737e6160dc917a791f0ccf2a8dc3b", + "name": "numpy", + "sha256": "8f56beb30edd46d4d3887e0d5fb5565b6d3057e8baeee14ec304bc9bdb4bc8e5", + "size": 50001, + "subdir": "linux-64", + "timestamp": 1559140484633, + "version": "1.16.4" + }, + "numpy-1.16.4-py37h99e49ec_0.tar.bz2": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.4 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "390b80b1e32911c9d837ee47f373a93d", + "name": "numpy", + "sha256": "0ac9a2f300f0434d4834dcb68b877777a483ddbbffe0f35924bd83fd5b741ab8", + "size": 49839, + "subdir": "linux-64", + "timestamp": 1559140377071, + "version": "1.16.4" + }, + "numpy-1.16.5-py27h7e9f1db_0.tar.bz2": { + "build": "py27h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.5 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c1e8f3094586b0ebaa8b5c144cbf3beb", + "name": "numpy", + "sha256": "7b80bc13356c69fe9b694d4bfd042815c8c2d98f5163bc9fead7044f8d7cce96", + "size": 50514, + "subdir": "linux-64", + "timestamp": 1568311621217, + "version": "1.16.5" + }, + "numpy-1.16.5-py27h99e49ec_0.tar.bz2": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.5 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cd881363e9e92a42210d097b2a33b2c2", + "name": "numpy", + "sha256": "b5da2414b13ec714dd81ab6c4fd881909645cccfcff71c9ab8c9ad959e897d2c", + "size": 50366, + "subdir": "linux-64", + "timestamp": 1568311482102, + "version": "1.16.5" + }, + "numpy-1.16.5-py36h7e9f1db_0.tar.bz2": { + "build": "py36h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.5 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7fe4713f114a832c6103d03fe0e48761", + "name": "numpy", + "sha256": "ef184319c7430ae89062093cea69270c6382d057e3a7c01c7719b8c8d788f753", + "size": 50526, + "subdir": "linux-64", + "timestamp": 1568311824177, + "version": "1.16.5" + }, + "numpy-1.16.5-py36h99e49ec_0.tar.bz2": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.5 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "48b7fdfec7b32dfe4f8411f43ce39b7e", + "name": "numpy", + "sha256": "de2abe699d4f4c75f9f289394697e2e820ae17dc278b5513e4b6c9fa49b77007", + "size": 50330, + "subdir": "linux-64", + "timestamp": 1568311463237, + "version": "1.16.5" + }, + "numpy-1.16.5-py37h7e9f1db_0.tar.bz2": { + "build": "py37h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.5 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "917e7146bd4810ef09d5bfbec4a3db8b", + "name": "numpy", + "sha256": "8ff8b525234707f9561443399671c030ef177b5f903490b90f0f42dae4779897", + "size": 50494, + "subdir": "linux-64", + "timestamp": 1568311816208, + "version": "1.16.5" + }, + "numpy-1.16.5-py37h99e49ec_0.tar.bz2": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.5 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a9ab19f86e708240fdc1e8859953e6f2", + "name": "numpy", + "sha256": "810ebaa7a6964c8c6d51ea05796a0e92b44841f173bd76cbdb9ea7dac3a3e8e3", + "size": 50372, + "subdir": "linux-64", + "timestamp": 1568311580162, + "version": "1.16.5" + }, + "numpy-1.16.6-py27h30dfecb_0.tar.bz2": { + "build": "py27h30dfecb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0ed68e9a65c10ca3c871130fa4c2bdfb", + "name": "numpy", + "sha256": "23def180c662eee510a93948b138efc3766e641f38a42a8061825f6204fe90db", + "size": 50479, + "subdir": "linux-64", + "timestamp": 1580501499365, + "version": "1.16.6" + }, + "numpy-1.16.6-py27hbc911f0_0.tar.bz2": { + "build": "py27hbc911f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.6 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bb9decea2915bf2f79dc51766480ca10", + "name": "numpy", + "sha256": "cfed2690b0593f46350f81821021ca45f4d5d4b3763c17396c0a5889ab5ae316", + "size": 50593, + "subdir": "linux-64", + "timestamp": 1580501622533, + "version": "1.16.6" + }, + "numpy-1.16.6-py36h0a8e133_3.tar.bz2": { + "build": "py36h0a8e133_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py36h41b4c56_3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6b70178af56239cb9c0645bfc31f1902", + "name": "numpy", + "sha256": "d33ca10722202bec4b5bb44f83c80f18d60a9bafbaf70f50df8b98be733b9ec9", + "size": 51879, + "subdir": "linux-64", + "timestamp": 1618845018673, + "version": "1.16.6" + }, + "numpy-1.16.6-py36h2d18471_3.tar.bz2": { + "build": "py36h2d18471_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft >=1.2.1,<2.0a0", + "mkl_random >=1.2.1,<2.0a0", + "numpy-base 1.16.6 py36hdc34a94_3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0e220cda3cf3459ca19be267ebaa4bfc", + "name": "numpy", + "sha256": "3171e9ce920805b6e54289ed01aa2df446f5cab459b9351a35f944649b2a66b8", + "size": 52040, + "subdir": "linux-64", + "timestamp": 1618845174550, + "version": "1.16.6" + }, + "numpy-1.16.6-py36h30dfecb_0.tar.bz2": { + "build": "py36h30dfecb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dccd4c6c6b56af93bb007dfe9871960d", + "name": "numpy", + "sha256": "a5f6b29eb1340bc1c5d527bf3f6f41834b720f801beedbad1df4cb8d79769647", + "size": 50109, + "subdir": "linux-64", + "timestamp": 1580488185096, + "version": "1.16.6" + }, + "numpy-1.16.6-py36hbc911f0_0.tar.bz2": { + "build": "py36hbc911f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.6 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0c7df268a43d81422372f01a5476d498", + "name": "numpy", + "sha256": "9a1389fa661d5a12262749778bc44936570acca2f5db9d69cd1dbdee969d4c06", + "size": 50278, + "subdir": "linux-64", + "timestamp": 1580488486831, + "version": "1.16.6" + }, + "numpy-1.16.6-py37h0708ffd_4.tar.bz2": { + "build": "py37h0708ffd_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.16.6 py37ha8aedfd_4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4a04a0b59c0a2731c43124a4f8eb9146", + "name": "numpy", + "sha256": "fe0b92511635da03e31e38381ffd57aeae6bab7763295f5767d0fd1ecbbe3707", + "size": 40713, + "subdir": "linux-64", + "timestamp": 1654863150786, + "version": "1.16.6" + }, + "numpy-1.16.6-py37h0a8e133_3.tar.bz2": { + "build": "py37h0a8e133_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py37h41b4c56_3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3f1b2371f816a4becd872459650f5609", + "name": "numpy", + "sha256": "614e2b6b843a58bd0df6fa85e8c1345bc59b8148d4e179507cc0df32a4bb24ae", + "size": 51899, + "subdir": "linux-64", + "timestamp": 1618844450384, + "version": "1.16.6" + }, + "numpy-1.16.6-py37h2d18471_3.tar.bz2": { + "build": "py37h2d18471_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft >=1.2.1,<2.0a0", + "mkl_random >=1.2.1,<2.0a0", + "numpy-base 1.16.6 py37hdc34a94_3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "985a0e18f531ec1088a6a1e0ad27730b", + "name": "numpy", + "sha256": "5571c576cc8fcc67ff85591e4714c1f63cf8d9009f53a3446f8cf8101c5c0b6a", + "size": 52040, + "subdir": "linux-64", + "timestamp": 1618845187107, + "version": "1.16.6" + }, + "numpy-1.16.6-py37h30dfecb_0.tar.bz2": { + "build": "py37h30dfecb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "58a31be34a795c103751cb0706000882", + "name": "numpy", + "sha256": "79bedc9422ad90db7f01394ece48bd6dea75944719d79da895967872fc077044", + "size": 50100, + "subdir": "linux-64", + "timestamp": 1580488174106, + "version": "1.16.6" + }, + "numpy-1.16.6-py37h7895c89_4.tar.bz2": { + "build": "py37h7895c89_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft >=1.2.1,<2.0a0", + "mkl_random >=1.2.1,<2.0a0", + "numpy-base 1.16.6 py37h73d599e_4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d19fb4d4b453e506023da7702fce0f2d", + "name": "numpy", + "sha256": "e2b692c980aa2aa9aaa11afa3cfba41c573d9bb73164064d8ea054297f8d007c", + "size": 40838, + "subdir": "linux-64", + "timestamp": 1654863901855, + "version": "1.16.6" + }, + "numpy-1.16.6-py37hbc911f0_0.tar.bz2": { + "build": "py37hbc911f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.6 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a9889cd1a616ee9c1a976f9ba050734a", + "name": "numpy", + "sha256": "a9a75fe73497cd5d17d2600ac7607de3df27d880e66f195a4c0b7d70b6fef872", + "size": 50251, + "subdir": "linux-64", + "timestamp": 1580488397932, + "version": "1.16.6" + }, + "numpy-1.16.6-py38h0708ffd_4.tar.bz2": { + "build": "py38h0708ffd_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.16.6 py38ha8aedfd_4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c85dc3bee09541743a56d92db1cac815", + "name": "numpy", + "sha256": "0f0fa5acf03ae649f3caa1f35072dd7908499384f113188c0ba6967ec9d7ca33", + "size": 40668, + "subdir": "linux-64", + "timestamp": 1654863587523, + "version": "1.16.6" + }, + "numpy-1.16.6-py38h0a8e133_3.tar.bz2": { + "build": "py38h0a8e133_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py38h41b4c56_3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1a73b3900add788aab31d5c94b303575", + "name": "numpy", + "sha256": "605ea2a4584cf0314e3e48931fe055326e00500697a594548f95b358eabbbd13", + "size": 51928, + "subdir": "linux-64", + "timestamp": 1618841695189, + "version": "1.16.6" + }, + "numpy-1.16.6-py38h2d18471_3.tar.bz2": { + "build": "py38h2d18471_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft >=1.2.1,<2.0a0", + "mkl_random >=1.2.1,<2.0a0", + "numpy-base 1.16.6 py38hdc34a94_3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8a89789a7e02d0f1cba2c130dec97ab7", + "name": "numpy", + "sha256": "22f0f2d9915f8d66f4a38790b6ad893999cd857db2e0b67a9abebc43d800bc02", + "size": 52083, + "subdir": "linux-64", + "timestamp": 1618845175787, + "version": "1.16.6" + }, + "numpy-1.16.6-py38h30dfecb_0.tar.bz2": { + "build": "py38h30dfecb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py38h2f8d375_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b52471bf1c130d8131dac8930b2df05c", + "name": "numpy", + "sha256": "c0e92b29e4b636553db6ef198f4087ff8534454670b1a8f2050779bf76b3a446", + "size": 50443, + "subdir": "linux-64", + "timestamp": 1580495282184, + "version": "1.16.6" + }, + "numpy-1.16.6-py38h7895c89_4.tar.bz2": { + "build": "py38h7895c89_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft >=1.2.1,<2.0a0", + "mkl_random >=1.2.1,<2.0a0", + "numpy-base 1.16.6 py38h73d599e_4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e11698ad0be4c9df3181633d3a8a8c7a", + "name": "numpy", + "sha256": "87d995d18a7ef70e850a99c623ec661193b932d2d2e2fb14903965aa55123fa2", + "size": 40866, + "subdir": "linux-64", + "timestamp": 1654864529560, + "version": "1.16.6" + }, + "numpy-1.16.6-py38hbc911f0_0.tar.bz2": { + "build": "py38hbc911f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.6 py38hde5b4d6_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "60e454cd0113c5eec77066aa169bc5a6", + "name": "numpy", + "sha256": "f576e3026e96d4d9494338035d6da529550d4d8c6141ff3a5c69ed49d41c9994", + "size": 50576, + "subdir": "linux-64", + "timestamp": 1580495343135, + "version": "1.16.6" + }, + "numpy-1.16.6-py39h0708ffd_4.tar.bz2": { + "build": "py39h0708ffd_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.16.6 py39ha8aedfd_4", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50196b371a293a13ec4b718917e815b5", + "name": "numpy", + "sha256": "2713c3da1aea946bb6e1a4a32838b9ae9b92fda5e0a360d8a90f084f115c31b9", + "size": 40699, + "subdir": "linux-64", + "timestamp": 1654863369754, + "version": "1.16.6" + }, + "numpy-1.16.6-py39h0a8e133_3.tar.bz2": { + "build": "py39h0a8e133_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py39h41b4c56_3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d9f0a06132f7a0049c9b7b6c50975a5c", + "name": "numpy", + "sha256": "8046a229168984b1af92fe2c330819d516988e2f1e313239aad5c5154831770b", + "size": 51918, + "subdir": "linux-64", + "timestamp": 1618841693744, + "version": "1.16.6" + }, + "numpy-1.16.6-py39h2d18471_3.tar.bz2": { + "build": "py39h2d18471_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft >=1.2.1,<2.0a0", + "mkl_random >=1.2.1,<2.0a0", + "numpy-base 1.16.6 py39hdc34a94_3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "afdd73bdd975eb89ebc840d98ff23f67", + "name": "numpy", + "sha256": "9f62b7a0bd106756f30776ed9ee983a6a2134bcfbe1b5be9484de81dce7440dc", + "size": 52067, + "subdir": "linux-64", + "timestamp": 1618845176540, + "version": "1.16.6" + }, + "numpy-1.16.6-py39h7895c89_4.tar.bz2": { + "build": "py39h7895c89_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft >=1.2.1,<2.0a0", + "mkl_random >=1.2.1,<2.0a0", + "numpy-base 1.16.6 py39h73d599e_4", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8b6fb7329c31e6e767a220de57135594", + "name": "numpy", + "sha256": "09dcec5d62b2a9f03a7f7c10ed55ecf5ece81cd8b7a621605801cc3a4c35194a", + "size": 40859, + "subdir": "linux-64", + "timestamp": 1654864212547, + "version": "1.16.6" + }, + "numpy-1.16.6-py39h89c1606_1.tar.bz2": { + "build": "py39h89c1606_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.6 py39h76555f2_1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e3ffc8a34efd1fcebd42be32925474fb", + "name": "numpy", + "sha256": "8117f13944d85b5889c32a9dbb7f601b5526656812367b572aaa4571f73bc29a", + "size": 50430, + "subdir": "linux-64", + "timestamp": 1607432395876, + "version": "1.16.6" + }, + "numpy-1.16.6-py39hdd937aa_1.tar.bz2": { + "build": "py39hdd937aa_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py39hfb011de_1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9e027100179a6ecda617318e92a1f0be", + "name": "numpy", + "sha256": "d8d98eec859efb4fa5e31d492647398bc52697b54311aefc2d874309e038d508", + "size": 50251, + "subdir": "linux-64", + "timestamp": 1607432252450, + "version": "1.16.6" + }, + "numpy-1.17.2-py36haad9e8e_0.tar.bz2": { + "build": "py36haad9e8e_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.17.2.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c13dc6ed73582e92f151ff6a3241075f", + "name": "numpy", + "sha256": "8a85b4c5aa607ce4a645fc47cc4d9e60bae1261a3bc9ba3649978a2a5c68e949", + "size": 4199, + "subdir": "linux-64", + "timestamp": 1569435736573, + "version": "1.17.2" + }, + "numpy-1.17.2-py36hf9bf1b6_0.tar.bz2": { + "build": "py36hf9bf1b6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.2.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1557f61bb17c9b05403e50b23615bda4", + "name": "numpy", + "sha256": "f4be775a7e58b039d36f4953f44c5d2ee41cab34b7502f1721b28c53e50de395", + "size": 4182, + "subdir": "linux-64", + "timestamp": 1569435477915, + "version": "1.17.2" + }, + "numpy-1.17.2-py37haad9e8e_0.tar.bz2": { + "build": "py37haad9e8e_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.17.2.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1f4a55a1833f37092312580a55ee1a82", + "name": "numpy", + "sha256": "96c09f06b5d08e073f343df40ed9b443557b5e5ff18c5075a052e8f2a7776029", + "size": 4207, + "subdir": "linux-64", + "timestamp": 1569436238507, + "version": "1.17.2" + }, + "numpy-1.17.2-py37hf9bf1b6_0.tar.bz2": { + "build": "py37hf9bf1b6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.2.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d08a8bfc478acf92ddc44a85584ccdc9", + "name": "numpy", + "sha256": "4c813447e8549ff473254a6fae901b8c78f645d3808f66f472256d85d1cae5fc", + "size": 4199, + "subdir": "linux-64", + "timestamp": 1569436013036, + "version": "1.17.2" + }, + "numpy-1.17.3-py36h7e8d029_0.tar.bz2": { + "build": "py36h7e8d029_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.3.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cacb6a736ee8d33e49633c037dfeba6f", + "name": "numpy", + "sha256": "3abf476e5a28697c066a6fe1d21c5b9c53335f153b1eb824a51499abf95bf7b2", + "size": 4281, + "subdir": "linux-64", + "timestamp": 1573069594490, + "version": "1.17.3" + }, + "numpy-1.17.3-py36hd14ec0e_0.tar.bz2": { + "build": "py36hd14ec0e_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.17.3.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f9700448e78d7bcf8690f7348cf497da", + "name": "numpy", + "sha256": "5b7e8082f5d2e632a83de7f705512aabe5a748f2a84c33b6962d6ec3510aa2f1", + "size": 4316, + "subdir": "linux-64", + "timestamp": 1573069514845, + "version": "1.17.3" + }, + "numpy-1.17.3-py37h7e8d029_0.tar.bz2": { + "build": "py37h7e8d029_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.3.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a03bc42dfb33d0fdebc0118d84782cd6", + "name": "numpy", + "sha256": "8edc97f39fe8678cfe554f58471b10c0659c314d614f4dd1d2069bfe3d8e6a9a", + "size": 4271, + "subdir": "linux-64", + "timestamp": 1573069602765, + "version": "1.17.3" + }, + "numpy-1.17.3-py37hd14ec0e_0.tar.bz2": { + "build": "py37hd14ec0e_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.17.3.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "da4c1ce3a61128ef620c35a349dd3618", + "name": "numpy", + "sha256": "ab3a69adde6e4a0df05ad713e988f960f62a3413fc6814caed0836e1247fbb33", + "size": 4308, + "subdir": "linux-64", + "timestamp": 1573069524877, + "version": "1.17.3" + }, + "numpy-1.17.3-py38h7e8d029_0.tar.bz2": { + "build": "py38h7e8d029_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.3.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8ffe5d14770044d1160b5b9b7040c1d5", + "name": "numpy", + "sha256": "70652adb0d6890741e75f2b5c974f0081d9b690cd6f5d02680783be0d463cb0d", + "size": 4282, + "subdir": "linux-64", + "timestamp": 1573069507535, + "version": "1.17.3" + }, + "numpy-1.17.4-py36hc1035e2_0.tar.bz2": { + "build": "py36hc1035e2_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.17.4.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "42313944819678596bd036739b8e0882", + "name": "numpy", + "sha256": "ea9894cf04d67dd0edc9fef73a43b68d1d8b8d3252e068804ed114f55499b7a6", + "size": 4329, + "subdir": "linux-64", + "timestamp": 1574868717785, + "version": "1.17.4" + }, + "numpy-1.17.4-py36hd5be1e1_0.tar.bz2": { + "build": "py36hd5be1e1_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.4.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d21e0d7991c68e708635a2314cacab82", + "name": "numpy", + "sha256": "e1e38bffe3a4585d69fdb8754dfea082de21f6fa64404cadd985612fe3786f4f", + "size": 4303, + "subdir": "linux-64", + "timestamp": 1574868452544, + "version": "1.17.4" + }, + "numpy-1.17.4-py37hc1035e2_0.tar.bz2": { + "build": "py37hc1035e2_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.17.4.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "11e8990b0e4793886421a50a21959965", + "name": "numpy", + "sha256": "9f7c6415207fd5bca452d58da08a7c274904d028b188ce3611c43d60aebd2655", + "size": 4303, + "subdir": "linux-64", + "timestamp": 1574868621830, + "version": "1.17.4" + }, + "numpy-1.17.4-py37hd5be1e1_0.tar.bz2": { + "build": "py37hd5be1e1_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.4.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "22429569b85ad1a9a02f003fff82c4d7", + "name": "numpy", + "sha256": "d83e297482253deb68b8fd8d17e2a544546000d943f5e9d2b5ab82ced932702f", + "size": 4289, + "subdir": "linux-64", + "timestamp": 1574868417879, + "version": "1.17.4" + }, + "numpy-1.17.4-py38hc1035e2_0.tar.bz2": { + "build": "py38hc1035e2_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.17.4.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "24ad0fb9a0ae0cad3331fee1dbf19420", + "name": "numpy", + "sha256": "a1ca617360d173f842bae47047606719e2171b0a116b3cb24b27845cbdaf556f", + "size": 4321, + "subdir": "linux-64", + "timestamp": 1574868659513, + "version": "1.17.4" + }, + "numpy-1.17.4-py38hd5be1e1_0.tar.bz2": { + "build": "py38hd5be1e1_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.4.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b03a2da4a03aa1951dd8ae254a969997", + "name": "numpy", + "sha256": "4bc13d8159dfaa43cd67c6e551bfe129a74a9d1c00451725b6f782635158c41a", + "size": 4300, + "subdir": "linux-64", + "timestamp": 1574868686829, + "version": "1.17.4" + }, + "numpy-1.18.1-py36h4f9e942_0.tar.bz2": { + "build": "py36h4f9e942_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.18.1.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ac9306265213d3422e174d43b1f31586", + "name": "numpy", + "sha256": "2195bca2e58f175026b7c7317d88d6c1196c43059381001932f8cc442ac26c13", + "size": 5152, + "subdir": "linux-64", + "timestamp": 1579206028849, + "version": "1.18.1" + }, + "numpy-1.18.1-py36h94c655d_0.tar.bz2": { + "build": "py36h94c655d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.1.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dcbd747056a365365f6acc6d770a43c8", + "name": "numpy", + "sha256": "0dba029ef4a45afbaf07486225ff827673eb4418777843f13365a7b072e4567d", + "size": 5107, + "subdir": "linux-64", + "timestamp": 1579205859722, + "version": "1.18.1" + }, + "numpy-1.18.1-py37h4f9e942_0.tar.bz2": { + "build": "py37h4f9e942_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.18.1.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b2cee869ff806bb654626816bdb08aeb", + "name": "numpy", + "sha256": "2094d0a464e1c362336914cb7ca4b0a801057a1c43af7d72512b45004d6ef9fa", + "size": 5138, + "subdir": "linux-64", + "timestamp": 1579205960526, + "version": "1.18.1" + }, + "numpy-1.18.1-py37h94c655d_0.tar.bz2": { + "build": "py37h94c655d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.1.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "42fb6dc4b4bf3e962606e6c324e90255", + "name": "numpy", + "sha256": "acec2866461eda639c40342faf5d92a777ac48523f9202f2368b75a243af24ed", + "size": 5150, + "subdir": "linux-64", + "timestamp": 1579205864833, + "version": "1.18.1" + }, + "numpy-1.18.1-py38h4f9e942_0.tar.bz2": { + "build": "py38h4f9e942_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.18.1.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5b5ad32e01d1616e5eccd67cadf425b8", + "name": "numpy", + "sha256": "8dc41c8c60774ab875f184145b8d8b768711f2a6415a596b70ba871394f6a524", + "size": 5135, + "subdir": "linux-64", + "timestamp": 1579206013599, + "version": "1.18.1" + }, + "numpy-1.18.1-py38h94c655d_0.tar.bz2": { + "build": "py38h94c655d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.1.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "71fcff97fedfbcb681ee352e8df0bc2d", + "name": "numpy", + "sha256": "4b44344f5891bac84a08efa214908afce9105d7e9dd687c6d1bb0fbc0fdfca1d", + "size": 5124, + "subdir": "linux-64", + "timestamp": 1579205968928, + "version": "1.18.1" + }, + "numpy-1.18.5-py36h7130bb8_0.tar.bz2": { + "build": "py36h7130bb8_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.5.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b25e5b3342e8caabbbcd94f2033a5e4b", + "name": "numpy", + "sha256": "b11b43f94ffdb2de66d1587c34ad5ef5b6ce618eb9d77d0cf2aa4aff9ad3d740", + "size": 4485, + "subdir": "linux-64", + "timestamp": 1592853196683, + "version": "1.18.5" + }, + "numpy-1.18.5-py36ha1c710e_0.tar.bz2": { + "build": "py36ha1c710e_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.18.5.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5a41829f5b55fe101cf45b7dba392506", + "name": "numpy", + "sha256": "6217298e49014757a7373a0ce5bece8198c3df76728020f63814c791095c49e5", + "size": 4497, + "subdir": "linux-64", + "timestamp": 1592853215170, + "version": "1.18.5" + }, + "numpy-1.18.5-py37h7130bb8_0.tar.bz2": { + "build": "py37h7130bb8_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.5.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4415da7f93ee8712c32d106a23cd222c", + "name": "numpy", + "sha256": "732ac4f118afbfaa5ccdf3047421836fbfe7c76f9c574ca1c6e1dbbde8c4ec66", + "size": 4469, + "subdir": "linux-64", + "timestamp": 1592853192562, + "version": "1.18.5" + }, + "numpy-1.18.5-py37ha1c710e_0.tar.bz2": { + "build": "py37ha1c710e_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.18.5.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "aa847b5c915becce1675c8569b981092", + "name": "numpy", + "sha256": "8dcfba5e16bd64b7bc7e97d848652e38ab22ff9e040ae3471c72dba0d12613d4", + "size": 4490, + "subdir": "linux-64", + "timestamp": 1592853214364, + "version": "1.18.5" + }, + "numpy-1.18.5-py38h7130bb8_0.tar.bz2": { + "build": "py38h7130bb8_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.5.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b58422d216622f3c08aac21bd23dac2d", + "name": "numpy", + "sha256": "b81cb60240dee31c3c2999d2d25f964c5754d04efa8379530e8da157334b65fa", + "size": 4473, + "subdir": "linux-64", + "timestamp": 1592853194943, + "version": "1.18.5" + }, + "numpy-1.18.5-py38ha1c710e_0.tar.bz2": { + "build": "py38ha1c710e_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.18.5.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "868f8192924b8c13e0255ce2fdf5d4a4", + "name": "numpy", + "sha256": "141ba367455835770faeaadd8241e5cdbf941bb6d623d1c29e6132ef543f7dab", + "size": 4504, + "subdir": "linux-64", + "timestamp": 1592853198106, + "version": "1.18.5" + }, + "numpy-1.19.1-py36h30dfecb_0.tar.bz2": { + "build": "py36h30dfecb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.19.1 py36h75fe3a5_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "462aaa714dad14be6ecefc23d8f9de6c", + "name": "numpy", + "sha256": "764518f40906d0d2c5b6ed2ec50997c8d19d92c3883bd7bd2998b95d4eb57165", + "size": 20596, + "subdir": "linux-64", + "timestamp": 1596233933479, + "version": "1.19.1" + }, + "numpy-1.19.1-py36hbc911f0_0.tar.bz2": { + "build": "py36hbc911f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.1 py36hfa32c7d_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2c8e7bf8049074e508d2fa26fca4191e", + "name": "numpy", + "sha256": "04da697393aef82f6083a87034fd148c0aa8151a86e6aabbf1f57dc26290656f", + "size": 20658, + "subdir": "linux-64", + "timestamp": 1596233933376, + "version": "1.19.1" + }, + "numpy-1.19.1-py37h30dfecb_0.tar.bz2": { + "build": "py37h30dfecb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.19.1 py37h75fe3a5_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "361506ca6e56f0c136da385db9373f9c", + "name": "numpy", + "sha256": "dfb8b8ae7ca2b45876f25b0fd2a4be3f2de470695576194c924c4dc2bda1cb92", + "size": 20591, + "subdir": "linux-64", + "timestamp": 1596233946674, + "version": "1.19.1" + }, + "numpy-1.19.1-py37hbc911f0_0.tar.bz2": { + "build": "py37hbc911f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.1 py37hfa32c7d_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bccb23990e40e3fe08ec89eaafb52c75", + "name": "numpy", + "sha256": "5eb2643cd5ca53e7a4b6d9503d2047dad2684eea402267c12c7e934376f70f29", + "size": 20651, + "subdir": "linux-64", + "timestamp": 1596233914614, + "version": "1.19.1" + }, + "numpy-1.19.1-py38h30dfecb_0.tar.bz2": { + "build": "py38h30dfecb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.19.1 py38h75fe3a5_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bdc4592686d6a48ad19dd040ad7f12e5", + "name": "numpy", + "sha256": "bf83da9816822b42d7de661b2b6dfe0ec5b12fca04239add6e26ba85150dbe6b", + "size": 20608, + "subdir": "linux-64", + "timestamp": 1596233926457, + "version": "1.19.1" + }, + "numpy-1.19.1-py38hbc911f0_0.tar.bz2": { + "build": "py38hbc911f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.1 py38hfa32c7d_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "55ee218ac8bceee795f11c8a4ad6edc0", + "name": "numpy", + "sha256": "de8701b1bbc1389cd3886bd9d1df918f21b565f1f6de0446527588dec857b8fe", + "size": 20671, + "subdir": "linux-64", + "timestamp": 1596233933229, + "version": "1.19.1" + }, + "numpy-1.19.2-py36h54aff64_0.tar.bz2": { + "build": "py36h54aff64_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.2 py36hfa32c7d_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cae2d87feed42ad60b50a3d211de1560", + "name": "numpy", + "sha256": "69c621fabd99dab824b9c243679a290ed5f41013550be3572de3c2acfbcc8e35", + "size": 21112, + "subdir": "linux-64", + "timestamp": 1603487994722, + "version": "1.19.2" + }, + "numpy-1.19.2-py36h6163131_0.tar.bz2": { + "build": "py36h6163131_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.19.2 py36h75fe3a5_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "75a83019cd4be0b8d40e244f750617ab", + "name": "numpy", + "sha256": "d20a1e27d8366c3bcab8a3cbf27b428e19b75222b0c0f10b8850b1d28add7656", + "size": 21094, + "subdir": "linux-64", + "timestamp": 1603483896489, + "version": "1.19.2" + }, + "numpy-1.19.2-py37h54aff64_0.tar.bz2": { + "build": "py37h54aff64_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.2 py37hfa32c7d_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e7c2c1c34803bdfeb2cd70b3e9495419", + "name": "numpy", + "sha256": "0554548acccb7567c74f5cf3a74be0d76e580b068185e1d3bd46a4b31ab9d0d2", + "size": 21118, + "subdir": "linux-64", + "timestamp": 1603479816521, + "version": "1.19.2" + }, + "numpy-1.19.2-py37h6163131_0.tar.bz2": { + "build": "py37h6163131_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.19.2 py37h75fe3a5_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4b3f51ac7319d9b536a9b83cca05053a", + "name": "numpy", + "sha256": "b27339848cce74a589388ee7eb107d5bfff43d4968c1086be9eaefb438004116", + "size": 21111, + "subdir": "linux-64", + "timestamp": 1603481052303, + "version": "1.19.2" + }, + "numpy-1.19.2-py37h7895c89_1.tar.bz2": { + "build": "py37h7895c89_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.2 py37h4c65ebe_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6e173d2b06ad42c466afee43204817e2", + "name": "numpy", + "sha256": "baf6ecb6fe3476639e23a9896273c76864711b8b52892f592a5cb325d8b10feb", + "size": 9580, + "subdir": "linux-64", + "timestamp": 1654872407155, + "version": "1.19.2" + }, + "numpy-1.19.2-py37hc896f84_1.tar.bz2": { + "build": "py37hc896f84_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.19.2 py37h21a3de8_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2600f3c175a10bce7e548296c6455fdf", + "name": "numpy", + "sha256": "247128e4c45154b8fd1b5d1b1e4efeb800af1a76b41672093b0b0c3f09886325", + "size": 9559, + "subdir": "linux-64", + "timestamp": 1654873745511, + "version": "1.19.2" + }, + "numpy-1.19.2-py38h54aff64_0.tar.bz2": { + "build": "py38h54aff64_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.2 py38hfa32c7d_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c0d4f8a99ef8e11a47f94171da2439c2", + "name": "numpy", + "sha256": "7d8e55caeca8fc79a768f422b3b33d98cb8a5113eb6e3962f931c58c61095b48", + "size": 21128, + "subdir": "linux-64", + "timestamp": 1603570674681, + "version": "1.19.2" + }, + "numpy-1.19.2-py38h6163131_0.tar.bz2": { + "build": "py38h6163131_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.19.2 py38h75fe3a5_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d6514a8cc07b4523349feee8fc6f3363", + "name": "numpy", + "sha256": "2ae695a10074b9bca2e71e9f0bda23a59d827336a1006473b6063ccea85774a1", + "size": 21092, + "subdir": "linux-64", + "timestamp": 1603479836038, + "version": "1.19.2" + }, + "numpy-1.19.2-py38h7895c89_1.tar.bz2": { + "build": "py38h7895c89_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.2 py38h4c65ebe_1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "845d400e0632f9aab18fe458ea70ebbc", + "name": "numpy", + "sha256": "7f2849da78695f9a4de0b08855548ee51b1f316dfb03ce49b643fb520fda09b2", + "size": 9573, + "subdir": "linux-64", + "timestamp": 1654873282861, + "version": "1.19.2" + }, + "numpy-1.19.2-py38hc896f84_1.tar.bz2": { + "build": "py38hc896f84_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.19.2 py38h21a3de8_1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "486a2baa446febe3466b17c0d01408ca", + "name": "numpy", + "sha256": "804c435821a0c64fe2ed3359127451399296b365f8beb0b9e588a9393fdca924", + "size": 9559, + "subdir": "linux-64", + "timestamp": 1654874610250, + "version": "1.19.2" + }, + "numpy-1.19.2-py39h7895c89_1.tar.bz2": { + "build": "py39h7895c89_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.2 py39h4c65ebe_1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1c32b310211ec90791b58c0fa6ff45b3", + "name": "numpy", + "sha256": "2a2ad36d37b0b4cd42323e128945d93e548c3b1cfa474d56bb01e6eb64a84e49", + "size": 9566, + "subdir": "linux-64", + "timestamp": 1654872832668, + "version": "1.19.2" + }, + "numpy-1.19.2-py39h87658db_0.tar.bz2": { + "build": "py39h87658db_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.19.2 py39h0f7b65f_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8ac048c1d172eea7034b81322bfc13ea", + "name": "numpy", + "sha256": "45a4cf0912962776b05a4ef7db5c22a26335d5f0ecee5b1c7ca817f25d58dfed", + "size": 21272, + "subdir": "linux-64", + "timestamp": 1607448348743, + "version": "1.19.2" + }, + "numpy-1.19.2-py39h89c1606_0.tar.bz2": { + "build": "py39h89c1606_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.2 py39h2ae0177_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1bfca6b534b6a09942f18cd82eaf8400", + "name": "numpy", + "sha256": "5bd545a75466a729b475b060f51b228893df2bc603289903eb43700cb2607ba9", + "size": 21276, + "subdir": "linux-64", + "timestamp": 1607448329201, + "version": "1.19.2" + }, + "numpy-1.19.2-py39hc896f84_1.tar.bz2": { + "build": "py39hc896f84_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.19.2 py39h21a3de8_1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "90e1a8597f9270ef49cfac7b824ee8ca", + "name": "numpy", + "sha256": "553c70061a7118cf01a2e8479028210a02573386fbf56964f1319ed11f0191ad", + "size": 9553, + "subdir": "linux-64", + "timestamp": 1654874165520, + "version": "1.19.2" + }, + "numpy-1.19.5-py37hc896f84_4.tar.bz2": { + "build": "py37hc896f84_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.19.5 py37h21a3de8_4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c00b0e3539e5a0eae9341a29ca194a9e", + "name": "numpy", + "sha256": "fc61e9b7cbde24dc0d900a1558f24bc17079d45ec3e3b9245228945f55f4baa7", + "size": 9706, + "subdir": "linux-64", + "timestamp": 1677550484352, + "version": "1.19.5" + }, + "numpy-1.19.5-py37hd5178e2_4.tar.bz2": { + "build": "py37hd5178e2_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.5 py37h622ebfc_4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "84a79b18ae612ace156d095971a05976", + "name": "numpy", + "sha256": "dc28e70fd17be0b64834c2d4854e368f9167ccc8ff123b99adbc714b957ce7be", + "size": 9721, + "subdir": "linux-64", + "timestamp": 1677551469989, + "version": "1.19.5" + }, + "numpy-1.19.5-py38hc896f84_4.tar.bz2": { + "build": "py38hc896f84_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.19.5 py38h21a3de8_4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dc804438237b8151ba0960d5bd135981", + "name": "numpy", + "sha256": "f88c64b1ff5b27cdbc9c22e8f0fcdb4e7a4a2ade12ad0368ec77627399ea5d31", + "size": 9698, + "subdir": "linux-64", + "timestamp": 1677549837210, + "version": "1.19.5" + }, + "numpy-1.19.5-py38hd5178e2_4.tar.bz2": { + "build": "py38hd5178e2_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.5 py38h622ebfc_4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "239fab419db79213afbfd8d14677cd64", + "name": "numpy", + "sha256": "b12e69e49a27a2de39a56c9de0b3d34cbc3c4f97c39f2ae0496edf06fe2f54b8", + "size": 9725, + "subdir": "linux-64", + "timestamp": 1677550816189, + "version": "1.19.5" + }, + "numpy-1.19.5-py39hc896f84_4.tar.bz2": { + "build": "py39hc896f84_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.19.5 py39h21a3de8_4", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a539c77ccae541b2d990ef23bd53fec9", + "name": "numpy", + "sha256": "b430bd46ebbb592a6cc54ec02866a47119a193babe05a98b1f2e23fa4739e060", + "size": 9705, + "subdir": "linux-64", + "timestamp": 1677550158992, + "version": "1.19.5" + }, + "numpy-1.19.5-py39hd5178e2_4.tar.bz2": { + "build": "py39hd5178e2_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.5 py39h622ebfc_4", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "30dd1df1ae04ef41484f3714545879d1", + "name": "numpy", + "sha256": "a5ccc44b779048e30a68c16bb1a832f84b9c6346b7d0efac0bcd06c6fb6d14d1", + "size": 9722, + "subdir": "linux-64", + "timestamp": 1677551143392, + "version": "1.19.5" + }, + "numpy-1.20.1-py37h5a90a98_0.tar.bz2": { + "build": "py37h5a90a98_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.20.1 py37h34387ca_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8cf90d63e9ffcc8a425cd94c6ef82c70", + "name": "numpy", + "sha256": "51b3647c69b46cdfe8bd72d75993902e445923c6c11949ccc1ba824015cd9fce", + "size": 21862, + "subdir": "linux-64", + "timestamp": 1618494317820, + "version": "1.20.1" + }, + "numpy-1.20.1-py37h93e21f0_0.tar.bz2": { + "build": "py37h93e21f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.20.1 py37h7d8b39e_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0f112a10faba1f7b877cb7e68780a70d", + "name": "numpy", + "sha256": "626e7d8539c091a34d46928a27a84fe03ac1741e84c95778bd0d2a5fc21d36cd", + "size": 21889, + "subdir": "linux-64", + "timestamp": 1618497462988, + "version": "1.20.1" + }, + "numpy-1.20.1-py38h5a90a98_0.tar.bz2": { + "build": "py38h5a90a98_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.20.1 py38h34387ca_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "40046b17b3017f3683c84d8030ca5806", + "name": "numpy", + "sha256": "baba4952922c7fc69c84c1fd36788ee997d356a647ed4f79c2a3b08cdaf3a6ad", + "size": 21890, + "subdir": "linux-64", + "timestamp": 1618497502384, + "version": "1.20.1" + }, + "numpy-1.20.1-py38h93e21f0_0.tar.bz2": { + "build": "py38h93e21f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.20.1 py38h7d8b39e_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f178c35a56f885884f088c51a4663f8b", + "name": "numpy", + "sha256": "d1f328863a66c1fd8537781c6276f076b2c330fd1c78b09b5934d646b2862c81", + "size": 21918, + "subdir": "linux-64", + "timestamp": 1618497542490, + "version": "1.20.1" + }, + "numpy-1.20.1-py39h5a90a98_0.tar.bz2": { + "build": "py39h5a90a98_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.20.1 py39h34387ca_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "345a6d89abb60964df969a3e31ec7404", + "name": "numpy", + "sha256": "0fc9d24f0b0501731042023ff15c419cdd817b2bbe7884506e81ece234b1c150", + "size": 21919, + "subdir": "linux-64", + "timestamp": 1618497490181, + "version": "1.20.1" + }, + "numpy-1.20.1-py39h93e21f0_0.tar.bz2": { + "build": "py39h93e21f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.20.1 py39h7d8b39e_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1ebab74115aad1a4a4ed48c96e336173", + "name": "numpy", + "sha256": "2830b3f791af06bba399b24c9ffbdf3eb1cf99856b7dbf160aea8a5345bc4f68", + "size": 21932, + "subdir": "linux-64", + "timestamp": 1618497546436, + "version": "1.20.1" + }, + "numpy-1.20.2-py37h2d18471_0.tar.bz2": { + "build": "py37h2d18471_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.20.2 py37hfae3a4d_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fdc7432a6a1754f4444732841f5a7311", + "name": "numpy", + "sha256": "0652730623df136954028bfe830377b445f8e4c7a9592aa0a8e45a9324dfee65", + "size": 22218, + "subdir": "linux-64", + "timestamp": 1620831425976, + "version": "1.20.2" + }, + "numpy-1.20.2-py37h62767a5_0.tar.bz2": { + "build": "py37h62767a5_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.20.2 py37he2ba247_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "072bb394f627a52eb41a5fb7c7963b7a", + "name": "numpy", + "sha256": "8e9341c5fc5ec11ab2c3524f7f6b4118fe95de90a6ffa721329c95ca26b934f4", + "size": 22151, + "subdir": "linux-64", + "timestamp": 1620831430820, + "version": "1.20.2" + }, + "numpy-1.20.2-py38h2d18471_0.tar.bz2": { + "build": "py38h2d18471_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.20.2 py38hfae3a4d_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b392bab9158dd2ce3dc229ec620f20dd", + "name": "numpy", + "sha256": "a765442021c87ea2bc178d3eebc459f5a0b9f67a04d5e3fb913f9d22be5d4683", + "size": 22208, + "subdir": "linux-64", + "timestamp": 1620831195041, + "version": "1.20.2" + }, + "numpy-1.20.2-py38h62767a5_0.tar.bz2": { + "build": "py38h62767a5_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.20.2 py38he2ba247_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8924d68dd281ad16f4945f07128a10c4", + "name": "numpy", + "sha256": "3c3f0ba9caabc71de6e26b4bacb4201c60098feafb8b1d8c713bceaa52881ce3", + "size": 22145, + "subdir": "linux-64", + "timestamp": 1620827112513, + "version": "1.20.2" + }, + "numpy-1.20.2-py39h2d18471_0.tar.bz2": { + "build": "py39h2d18471_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.20.2 py39hfae3a4d_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dadbac4b79a14be23f031ad0a21cd62b", + "name": "numpy", + "sha256": "9083bd251fcef0b1b7d5330ebd6c7df76a57a98d0ca9366d795b876320eef206", + "size": 22208, + "subdir": "linux-64", + "timestamp": 1620831436482, + "version": "1.20.2" + }, + "numpy-1.20.2-py39h62767a5_0.tar.bz2": { + "build": "py39h62767a5_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.20.2 py39he2ba247_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "501c229390fd9eaeef229dc1d15dfaec", + "name": "numpy", + "sha256": "dea160250ededb9da9d46eeb8ce83e22053499aba824df8d8fde0a089c9fc5e3", + "size": 22188, + "subdir": "linux-64", + "timestamp": 1620831419933, + "version": "1.20.2" + }, + "numpy-1.20.3-py37h3dbb7de_0.tar.bz2": { + "build": "py37h3dbb7de_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.20.3 py37h39b7dee_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f99edac8c7497fdc970a14558b4029b2", + "name": "numpy", + "sha256": "0cf9e36209e58b1ba6b542e707bda74a2a5de73c7a92e8ec85593af47caee7d8", + "size": 22450, + "subdir": "linux-64", + "timestamp": 1626272017140, + "version": "1.20.3" + }, + "numpy-1.20.3-py37hf144106_0.tar.bz2": { + "build": "py37hf144106_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.20.3 py37h74d4b33_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "515fb5efd7739fdf8d1fbae6970551a0", + "name": "numpy", + "sha256": "f64383260887874deaa2a7992e68092dfbbc9623dca826b424c8f33278d0c9c3", + "size": 22462, + "subdir": "linux-64", + "timestamp": 1626265018470, + "version": "1.20.3" + }, + "numpy-1.20.3-py38h3dbb7de_0.tar.bz2": { + "build": "py38h3dbb7de_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.20.3 py38h39b7dee_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1be0eb69a04eb5e3d9186d6a60a8664a", + "name": "numpy", + "sha256": "4eeff13e21fccb453ef592c89862139d770df5aaa138bacebb6b198b542f504f", + "size": 22446, + "subdir": "linux-64", + "timestamp": 1626272006810, + "version": "1.20.3" + }, + "numpy-1.20.3-py38hf144106_0.tar.bz2": { + "build": "py38hf144106_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.20.3 py38h74d4b33_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "65bc5e584d119d33a7f40fdae48861f8", + "name": "numpy", + "sha256": "4a11292f4b5a8f9a18c81488146dbf356357baca8c9efe4c5962c56aea91354b", + "size": 22472, + "subdir": "linux-64", + "timestamp": 1626271770716, + "version": "1.20.3" + }, + "numpy-1.20.3-py39h3dbb7de_0.tar.bz2": { + "build": "py39h3dbb7de_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.20.3 py39h39b7dee_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1ea33afd44afec10ebe4cb2b162c1834", + "name": "numpy", + "sha256": "641f1a6c8d6444f8695e43626d1b7772c08f982488f20cc846d3a9d07c6eedcb", + "size": 22442, + "subdir": "linux-64", + "timestamp": 1626272023141, + "version": "1.20.3" + }, + "numpy-1.20.3-py39hf144106_0.tar.bz2": { + "build": "py39hf144106_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.20.3 py39h74d4b33_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "125611497a061cb34b184917deef9f1e", + "name": "numpy", + "sha256": "c7c6d2fa6b782268fd2b861252c314ee39cdd9b7c77e0dc2e9c46d0a2032e04d", + "size": 22457, + "subdir": "linux-64", + "timestamp": 1626265020843, + "version": "1.20.3" + }, + "numpy-1.21.2-py310h20f2e39_0.tar.bz2": { + "build": "py310h20f2e39_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.2 py310h79a1101_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fc01f4e63a2efd1aef2ee0a8e488c57a", + "name": "numpy", + "sha256": "bb2c5afd0df94fe44268b8fe88251a05ab64673ed8b0ec585d963e9ea3e2446b", + "size": 22896, + "subdir": "linux-64", + "timestamp": 1639497139009, + "version": "1.21.2" + }, + "numpy-1.21.2-py310hd8d4704_0.tar.bz2": { + "build": "py310hd8d4704_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.21.2 py310h2b8c604_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e191d60457fce6b01e3824b2fef38494", + "name": "numpy", + "sha256": "91add15cc2a9f46dd1c83d05daa66dd5d50083dfae9910c3c6e0ea07058a6852", + "size": 22896, + "subdir": "linux-64", + "timestamp": 1639483351398, + "version": "1.21.2" + }, + "numpy-1.21.2-py37h20f2e39_0.tar.bz2": { + "build": "py37h20f2e39_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.2 py37h79a1101_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "596f2ec97658ee1fac92a5683e01b160", + "name": "numpy", + "sha256": "b1dd1d0c89231199d756a33728bba5621696b1f64ce2b0dd2e33217c6decbdae", + "size": 22588, + "subdir": "linux-64", + "timestamp": 1634106947077, + "version": "1.21.2" + }, + "numpy-1.21.2-py37hd8d4704_0.tar.bz2": { + "build": "py37hd8d4704_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.21.2 py37h2b8c604_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f2221fc95e7b241ed583a6ba0e1d0d09", + "name": "numpy", + "sha256": "bb0e32dbd02278b8986ec6698e8c746ad4583946226449ce84d1d2cc06234d9b", + "size": 22561, + "subdir": "linux-64", + "timestamp": 1634106908866, + "version": "1.21.2" + }, + "numpy-1.21.2-py38h20f2e39_0.tar.bz2": { + "build": "py38h20f2e39_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.2 py38h79a1101_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a4d0c33ee154884813f9a47e67956df1", + "name": "numpy", + "sha256": "8430a027fc4643eccc43f90b7706d3e31e4afcaf7f203276500dc18100fdf892", + "size": 22606, + "subdir": "linux-64", + "timestamp": 1634095896332, + "version": "1.21.2" + }, + "numpy-1.21.2-py38hd8d4704_0.tar.bz2": { + "build": "py38hd8d4704_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.21.2 py38h2b8c604_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d0cfad1737edfd390b2322935879d53d", + "name": "numpy", + "sha256": "a3bb10349e962645a1af5c19892613ae2a3e44f2f61182f72212ff7c445d52c0", + "size": 22520, + "subdir": "linux-64", + "timestamp": 1634106948544, + "version": "1.21.2" + }, + "numpy-1.21.2-py39h20f2e39_0.tar.bz2": { + "build": "py39h20f2e39_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.2 py39h79a1101_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "daa677eb9c57f15f4532c3779a28ca24", + "name": "numpy", + "sha256": "6bc49189fa527e489c3b988e66f9119a3df8e77a76d811e71f67d365e627cac3", + "size": 22568, + "subdir": "linux-64", + "timestamp": 1634095904852, + "version": "1.21.2" + }, + "numpy-1.21.2-py39hd8d4704_0.tar.bz2": { + "build": "py39hd8d4704_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.21.2 py39h2b8c604_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "02d8590918d26122d3344ff2db6a4639", + "name": "numpy", + "sha256": "356fe148b1bef82bf60423daf96e38005aa6e4102e4dcfdff54f350cdc158f3b", + "size": 22552, + "subdir": "linux-64", + "timestamp": 1634106936390, + "version": "1.21.2" + }, + "numpy-1.21.5-py310h1794996_3.tar.bz2": { + "build": "py310h1794996_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py310hcba007f_3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "988f960d5c5c3902ca4f5e26cb96879d", + "name": "numpy", + "sha256": "674c6755aa87c4c97f337038adec29cbcd673bd84283aca011efef9aec4ed27e", + "size": 9853, + "subdir": "linux-64", + "timestamp": 1653918973320, + "version": "1.21.5" + }, + "numpy-1.21.5-py310h4f1e569_1.tar.bz2": { + "build": "py310h4f1e569_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.21.5 py310hf2716ce_1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "80bf2fe5656c6c20acbf029e345079d3", + "name": "numpy", + "sha256": "ae564e00596d6e10dbe30e02092498962ed7090e2374191b915d92343354b987", + "size": 23768, + "subdir": "linux-64", + "timestamp": 1649783065068, + "version": "1.21.5" + }, + "numpy-1.21.5-py310h4f1e569_2.tar.bz2": { + "build": "py310h4f1e569_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.21.5 py310hf2716ce_2", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "1c31a256f06616c80b53a93147232fc4", + "name": "numpy", + "sha256": "e0feeb6418e293e61c6a0db6bdc87e3f87c71f699085af2b52ecaa7fd0954dfd", + "size": 9728, + "subdir": "linux-64", + "timestamp": 1651563875437, + "version": "1.21.5" + }, + "numpy-1.21.5-py310hac523dd_3.tar.bz2": { + "build": "py310hac523dd_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.21.5 py310h375b286_3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "bd22c90fde900ea2bbf16f8e6dae97a9", + "name": "numpy", + "sha256": "894b40372b8d4adafdecb5f78bf5300654a479854352bb6b11fdbdb533b0c487", + "size": 9819, + "subdir": "linux-64", + "timestamp": 1653916846314, + "version": "1.21.5" + }, + "numpy-1.21.5-py310hfa59a62_1.tar.bz2": { + "build": "py310hfa59a62_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py310h9585f30_1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "fc07e23022e3b9703c6560f1a617e98e", + "name": "numpy", + "sha256": "d140e7737860503445ae1b7bf644b82f1f775763312131ecec5b3bc850293383", + "size": 23819, + "subdir": "linux-64", + "timestamp": 1649783081391, + "version": "1.21.5" + }, + "numpy-1.21.5-py310hfa59a62_2.tar.bz2": { + "build": "py310hfa59a62_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py310h9585f30_2", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2e358a05b6afaa03c31c5de0a6fc4ac2", + "name": "numpy", + "sha256": "76c1dd396fd0e384c74fd56ca6b7baf3beb5f56fec761516d77db12ed9c37308", + "size": 9773, + "subdir": "linux-64", + "timestamp": 1651565851444, + "version": "1.21.5" + }, + "numpy-1.21.5-py37h6c91a56_3.tar.bz2": { + "build": "py37h6c91a56_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py37ha15fc14_3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9334d08dd55f994b6b2c07dc236c1c63", + "name": "numpy", + "sha256": "92df04664b773c172ce4216d4da9c03e788a634f0eb2fb22147c612d3fbce076", + "size": 9844, + "subdir": "linux-64", + "timestamp": 1653917887949, + "version": "1.21.5" + }, + "numpy-1.21.5-py37h7a5d4dd_1.tar.bz2": { + "build": "py37h7a5d4dd_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.21.5 py37hb8be1f0_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a5be0b434e2671b905166093417980c3", + "name": "numpy", + "sha256": "7076741e3fa353b8c1c51f0340151dda68922087f4fe314d611a1c49394bc8e0", + "size": 23768, + "subdir": "linux-64", + "timestamp": 1649782985460, + "version": "1.21.5" + }, + "numpy-1.21.5-py37h7a5d4dd_2.tar.bz2": { + "build": "py37h7a5d4dd_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.21.5 py37hb8be1f0_2", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "42f949238e2b0f1fe8a8b10a2e0135ba", + "name": "numpy", + "sha256": "e514e8fe586b9c19ea5bde9d20d60a09fddf834adc12cbe7ba981ce00c1f40f2", + "size": 9714, + "subdir": "linux-64", + "timestamp": 1651564839436, + "version": "1.21.5" + }, + "numpy-1.21.5-py37he7a7128_1.tar.bz2": { + "build": "py37he7a7128_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py37hf524024_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "623b75fe2711e0f6a40d37e60d5148f9", + "name": "numpy", + "sha256": "1c31f1634dbf2d25dab612d4602f9b7d813cd1d5984897e4ed5f70d4300abf15", + "size": 23802, + "subdir": "linux-64", + "timestamp": 1649783041597, + "version": "1.21.5" + }, + "numpy-1.21.5-py37he7a7128_2.tar.bz2": { + "build": "py37he7a7128_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py37hf524024_2", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2716960dbd70a1f08569b2ddc7b7ec57", + "name": "numpy", + "sha256": "8dedcee29f0cc5fbd7f1a57012bda9ec2080d4d8babdbe19bc3b3f6dd62b671f", + "size": 9749, + "subdir": "linux-64", + "timestamp": 1651566832823, + "version": "1.21.5" + }, + "numpy-1.21.5-py37hf838250_3.tar.bz2": { + "build": "py37hf838250_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.21.5 py37h1e6e340_3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "345e24c54bcd1c28e9d559f2f1677913", + "name": "numpy", + "sha256": "9b95ee9ef4ace21aeeb84850de99966c2178e8d9f4e37d69c3af8c42e5cbe4a0", + "size": 9777, + "subdir": "linux-64", + "timestamp": 1653915751324, + "version": "1.21.5" + }, + "numpy-1.21.5-py38h6c91a56_3.tar.bz2": { + "build": "py38h6c91a56_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py38ha15fc14_3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "66d980285c09805dc7fc6ba29e3406c6", + "name": "numpy", + "sha256": "7afee295cd61a5017e92d8fd0c204cf859fff5ade7b414c8201bac1fc70d3037", + "size": 9814, + "subdir": "linux-64", + "timestamp": 1653918415296, + "version": "1.21.5" + }, + "numpy-1.21.5-py38h7a5d4dd_1.tar.bz2": { + "build": "py38h7a5d4dd_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.21.5 py38hb8be1f0_1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7cb4bee89f3acdbd7af6cbc8460a75dc", + "name": "numpy", + "sha256": "e57d2d910fad563c1ffa1f4f3f81f74d695cf49dc471ef819e07c16f90fda5da", + "size": 23725, + "subdir": "linux-64", + "timestamp": 1649765128185, + "version": "1.21.5" + }, + "numpy-1.21.5-py38h7a5d4dd_2.tar.bz2": { + "build": "py38h7a5d4dd_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.21.5 py38hb8be1f0_2", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "09fade6deede43a6a68f3132d9854b3d", + "name": "numpy", + "sha256": "b3cd60d9d0c6f5b043723e1e336fc23585633c3cc053e484ca697af8aa0b0c22", + "size": 9721, + "subdir": "linux-64", + "timestamp": 1651565330622, + "version": "1.21.5" + }, + "numpy-1.21.5-py38he7a7128_1.tar.bz2": { + "build": "py38he7a7128_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py38hf524024_1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "501e83b4b7e3df3de9a7c0b942524821", + "name": "numpy", + "sha256": "499e255f7cc14dcdcc84ee91e0f0e8682762e2e5024d5608492c3188d3683327", + "size": 23788, + "subdir": "linux-64", + "timestamp": 1649783033088, + "version": "1.21.5" + }, + "numpy-1.21.5-py38he7a7128_2.tar.bz2": { + "build": "py38he7a7128_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py38hf524024_2", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "24cd825b1723a1eca6edd66cc4f8d193", + "name": "numpy", + "sha256": "05eac7db58bf610901a04af2bf4c302a806e8746d5b0a4dd74772b09c26d1e86", + "size": 9735, + "subdir": "linux-64", + "timestamp": 1651567321698, + "version": "1.21.5" + }, + "numpy-1.21.5-py38hf838250_3.tar.bz2": { + "build": "py38hf838250_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.21.5 py38h1e6e340_3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "0c00e92bd53018c5659379e08b51f6cb", + "name": "numpy", + "sha256": "6b50b87ef68c154d9d4f389944bc81d07cfa7a465de87733ac7725e4bce5197c", + "size": 9796, + "subdir": "linux-64", + "timestamp": 1653916278412, + "version": "1.21.5" + }, + "numpy-1.21.5-py39h6c91a56_3.tar.bz2": { + "build": "py39h6c91a56_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py39ha15fc14_3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "8439771de4d667d9083013dda96df09b", + "name": "numpy", + "sha256": "06413e11140a88a742c44bb447cea78abe5319b9ba5e440b0a5f22b872c129fc", + "size": 9835, + "subdir": "linux-64", + "timestamp": 1653919491718, + "version": "1.21.5" + }, + "numpy-1.21.5-py39h7a5d4dd_1.tar.bz2": { + "build": "py39h7a5d4dd_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.21.5 py39hb8be1f0_1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "780dbc21f81d491da0a8b7f2391c63e8", + "name": "numpy", + "sha256": "e9a18f104e3f6ea276a0e5b3d939fdb161ec38af871ff122c6daa01943c94ed2", + "size": 23785, + "subdir": "linux-64", + "timestamp": 1649764891257, + "version": "1.21.5" + }, + "numpy-1.21.5-py39h7a5d4dd_2.tar.bz2": { + "build": "py39h7a5d4dd_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.21.5 py39hb8be1f0_2", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "13fe50b94e92299f8c1c3599c8a7b3f9", + "name": "numpy", + "sha256": "5ff111d302486f5137b811c23872af40d2a716e4b110d0e75edbfd3988a6c385", + "size": 9720, + "subdir": "linux-64", + "timestamp": 1651564359036, + "version": "1.21.5" + }, + "numpy-1.21.5-py39he7a7128_1.tar.bz2": { + "build": "py39he7a7128_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py39hf524024_1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "194b07b9d7a94d88209cae74f9a51bfa", + "name": "numpy", + "sha256": "df43b33233d6a6d9ca8537343c118fb3164a3b5ac3e7c9b2fa26e40253437308", + "size": 23803, + "subdir": "linux-64", + "timestamp": 1649764892736, + "version": "1.21.5" + }, + "numpy-1.21.5-py39he7a7128_2.tar.bz2": { + "build": "py39he7a7128_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py39hf524024_2", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2bd04a53d17b21af64f413dc810b3d94", + "name": "numpy", + "sha256": "9195828a286d79621f63766a1ac1143de7b862ae17ce5e95ca0c3a5c171868a1", + "size": 9728, + "subdir": "linux-64", + "timestamp": 1651566346644, + "version": "1.21.5" + }, + "numpy-1.21.5-py39hf838250_3.tar.bz2": { + "build": "py39hf838250_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.21.5 py39h1e6e340_3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a3a122085c8047584d5555499fc9186e", + "name": "numpy", + "sha256": "525af901aab618a2179084dde463960793a1a2a295e12dcd60ba0bb5845daf8c", + "size": 9782, + "subdir": "linux-64", + "timestamp": 1653917365288, + "version": "1.21.5" + }, + "numpy-1.22.3-py310h4f1e569_0.tar.bz2": { + "build": "py310h4f1e569_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.22.3 py310hf2716ce_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "26d45507f80b1498ba0fb9fbabece5a0", + "name": "numpy", + "sha256": "c5c35d87061b24e1cf10584026f2b771774646e2d3def330ea7b677da7d197b0", + "size": 9958, + "subdir": "linux-64", + "timestamp": 1652804707113, + "version": "1.22.3" + }, + "numpy-1.22.3-py310hfa59a62_0.tar.bz2": { + "build": "py310hfa59a62_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.22.3 py310h9585f30_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7ca0065abe7f21dda202e48001dc97be", + "name": "numpy", + "sha256": "0f0090d4b68693b026e33e1d32bb5dc12becf89093d6fc5089eae40e1f2797eb", + "size": 9998, + "subdir": "linux-64", + "timestamp": 1652802638914, + "version": "1.22.3" + }, + "numpy-1.22.3-py311h5585df3_1.tar.bz2": { + "build": "py311h5585df3_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.22.3 py311hc9e7d78_1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "395214e82e21fedf9de5ae91ad5e2f0a", + "name": "numpy", + "sha256": "b54c5d0cdaafc9811782b42171c9e4f6fcf89dbcf36a676c7c01228181bdca21", + "size": 10221, + "subdir": "linux-64", + "timestamp": 1676824681962, + "version": "1.22.3" + }, + "numpy-1.22.3-py311h75bd12f_1.tar.bz2": { + "build": "py311h75bd12f_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.22.3 py311h0ff3221_1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7a58387318a2ba2f6c824b9d043eb132", + "name": "numpy", + "sha256": "88519838e30511d3b7db64f7600b8f5da622c1252446f064296f5b9ad4084159", + "size": 10280, + "subdir": "linux-64", + "timestamp": 1676824838031, + "version": "1.22.3" + }, + "numpy-1.22.3-py38h7a5d4dd_0.tar.bz2": { + "build": "py38h7a5d4dd_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.22.3 py38hb8be1f0_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "222d0f80f9038acb385618ca8679854b", + "name": "numpy", + "sha256": "8c47fbb4f14198171eb755f0c1eae7d4b2ac27473236ffb4100cb2c07a3ee440", + "size": 9926, + "subdir": "linux-64", + "timestamp": 1652805382409, + "version": "1.22.3" + }, + "numpy-1.22.3-py38he7a7128_0.tar.bz2": { + "build": "py38he7a7128_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.22.3 py38hf524024_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "53320f97439405a48a81092e033bfecd", + "name": "numpy", + "sha256": "0f998cef0e8bf9a75be8417702581861678c7020bb29e77e6f7e0c9ff00a1505", + "size": 9952, + "subdir": "linux-64", + "timestamp": 1652803331594, + "version": "1.22.3" + }, + "numpy-1.22.3-py39h7a5d4dd_0.tar.bz2": { + "build": "py39h7a5d4dd_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.22.3 py39hb8be1f0_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "aa7e177896452aa791ac35cb17309c85", + "name": "numpy", + "sha256": "658c8e03c1a7fa45473d653586eecd8bfd8ed3de3912089644d26b5cd7bb90fa", + "size": 9954, + "subdir": "linux-64", + "timestamp": 1652804015577, + "version": "1.22.3" + }, + "numpy-1.22.3-py39he7a7128_0.tar.bz2": { + "build": "py39he7a7128_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.22.3 py39hf524024_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d7bcf0b9ba2d85cf532059ec119d2750", + "name": "numpy", + "sha256": "ff8d0426c7096e086db818265c3edf4a820accbfb15afae0407ca578de151fa9", + "size": 9965, + "subdir": "linux-64", + "timestamp": 1652801901707, + "version": "1.22.3" + }, + "numpy-1.23.1-py310h1794996_0.tar.bz2": { + "build": "py310h1794996_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.1 py310hcba007f_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a9dee2cff9f7ebb88570c3e1436b3e69", + "name": "numpy", + "sha256": "9a34ae25b236a9c379553c0bffad21cac89010e4b70875cd455c1446a1e6a71f", + "size": 10624, + "subdir": "linux-64", + "timestamp": 1659435971988, + "version": "1.23.1" + }, + "numpy-1.23.1-py310hac523dd_0.tar.bz2": { + "build": "py310hac523dd_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.1 py310h375b286_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "aea4b28b0ee2dff1a93617c11266fe38", + "name": "numpy", + "sha256": "98e2724ed9a1bf4e4de710a0f177b1da5e443de6352b8346cd0883d9a7baf352", + "size": 10595, + "subdir": "linux-64", + "timestamp": 1659434130540, + "version": "1.23.1" + }, + "numpy-1.23.1-py38h6c91a56_0.tar.bz2": { + "build": "py38h6c91a56_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.1 py38ha15fc14_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e256a8f1145b2dc05aa6ff1e51cbbcec", + "name": "numpy", + "sha256": "530cc0db1fd15886e00c61a9f05b813cffb50f1472d4ac5a713eed399ccfe42b", + "size": 10572, + "subdir": "linux-64", + "timestamp": 1659435317316, + "version": "1.23.1" + }, + "numpy-1.23.1-py38hf838250_0.tar.bz2": { + "build": "py38hf838250_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.1 py38h1e6e340_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ccc2484e2747ca5f81c86e30d66f99f9", + "name": "numpy", + "sha256": "1a28ffdebfbca6920fb1a24806fa92a4f5f54786cf1a074aa886ab1e79923ed3", + "size": 10561, + "subdir": "linux-64", + "timestamp": 1659433474976, + "version": "1.23.1" + }, + "numpy-1.23.1-py39h6c91a56_0.tar.bz2": { + "build": "py39h6c91a56_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.1 py39ha15fc14_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "57a87c401ec9eb07717ec833c98b5a8d", + "name": "numpy", + "sha256": "6ebe27a286ea4b7176cc93688082ddb153521871ca327bd8288309d5d9670579", + "size": 10582, + "subdir": "linux-64", + "timestamp": 1659434725898, + "version": "1.23.1" + }, + "numpy-1.23.1-py39hf838250_0.tar.bz2": { + "build": "py39hf838250_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.1 py39h1e6e340_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "02e526bc277f6fb1759628d874aae8c1", + "name": "numpy", + "sha256": "06382bcb4462ff2f5865756a233467efbd24616d5e26a52df9ce2916b9910671", + "size": 10551, + "subdir": "linux-64", + "timestamp": 1659432884365, + "version": "1.23.1" + }, + "numpy-1.23.3-py310hac523dd_0.tar.bz2": { + "build": "py310hac523dd_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.3 py310h375b286_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "378d2c161f2c5641ae6329bde3fae937", + "name": "numpy", + "sha256": "a55c30b9c1f7dbdf2804a866b9cb376459f721df1e6bd18f3b7da318c03a00a7", + "size": 9923, + "subdir": "linux-64", + "timestamp": 1665776367315, + "version": "1.23.3" + }, + "numpy-1.23.3-py310hac523dd_1.tar.bz2": { + "build": "py310hac523dd_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.3 py310h375b286_1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0b6e1af6c9dc055e9cd3955968235a5b", + "name": "numpy", + "sha256": "9929cfde4d1a3986e73548d67bad31b02b34021e167e625f9eb0c891e96e61f0", + "size": 9951, + "subdir": "linux-64", + "timestamp": 1667234292219, + "version": "1.23.3" + }, + "numpy-1.23.3-py310hd5efca6_0.tar.bz2": { + "build": "py310hd5efca6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.3 py310h8e6c178_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "23f78c779e1cf188ccc3abde1ddb8e68", + "name": "numpy", + "sha256": "05a148c09e01a091980e83afad0e9df658bcad5a24298e625b613071287cebd3", + "size": 9955, + "subdir": "linux-64", + "timestamp": 1665774579260, + "version": "1.23.3" + }, + "numpy-1.23.3-py310hd5efca6_1.tar.bz2": { + "build": "py310hd5efca6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.3 py310h8e6c178_1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4e17fd08c344a8d1e5e43f1c60f10a9b", + "name": "numpy", + "sha256": "1512eeb8e485824330b8d3909983477860387a270481aaa0a2776a7ac21e9583", + "size": 9965, + "subdir": "linux-64", + "timestamp": 1667236111670, + "version": "1.23.3" + }, + "numpy-1.23.3-py38h14f4228_0.tar.bz2": { + "build": "py38h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.3 py38h31eccc5_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1464624e3671b8c87f0e4634d3341f5e", + "name": "numpy", + "sha256": "5837aea0e1031811b098463a4e22d513fe5bb406f4698e0c8d83036cb59990af", + "size": 9925, + "subdir": "linux-64", + "timestamp": 1665773378478, + "version": "1.23.3" + }, + "numpy-1.23.3-py38h14f4228_1.tar.bz2": { + "build": "py38h14f4228_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.3 py38h31eccc5_1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "883debc9e106e5cbec616832c93da447", + "name": "numpy", + "sha256": "e089fbecf78041dec7019e4577c29ce6f0b684c0372fecedb1b011d36cd178ff", + "size": 9930, + "subdir": "linux-64", + "timestamp": 1667235489143, + "version": "1.23.3" + }, + "numpy-1.23.3-py38hf838250_0.tar.bz2": { + "build": "py38hf838250_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.3 py38h1e6e340_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9f251a0f2ded0faea9d1d24aa86c46ba", + "name": "numpy", + "sha256": "e4d8f747120b68ab20d395041bacd3b6d765c6802cca4dbeb82ded8dbdd5de0c", + "size": 9895, + "subdir": "linux-64", + "timestamp": 1665775168971, + "version": "1.23.3" + }, + "numpy-1.23.3-py38hf838250_1.tar.bz2": { + "build": "py38hf838250_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.3 py38h1e6e340_1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "81c7feab361bf765d2b06d11fe3b04d1", + "name": "numpy", + "sha256": "ea41913746125d2325350a1eaf383d6f5915372b219c6a60ba8742859d4cefac", + "size": 9930, + "subdir": "linux-64", + "timestamp": 1667233670908, + "version": "1.23.3" + }, + "numpy-1.23.3-py39h14f4228_0.tar.bz2": { + "build": "py39h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.3 py39h31eccc5_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "02d1c44ccb24fde3f0196200998ed3fb", + "name": "numpy", + "sha256": "e1eb1869d50638f8bc4c546e51c64473778804e061466aaf96ea2e4e3cbe114f", + "size": 9914, + "subdir": "linux-64", + "timestamp": 1665773993580, + "version": "1.23.3" + }, + "numpy-1.23.3-py39h14f4228_1.tar.bz2": { + "build": "py39h14f4228_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.3 py39h31eccc5_1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2e13941118ac7e41e8ebe9da305d83bb", + "name": "numpy", + "sha256": "845e152a1a2dd9f7f240885adca64c6364db1a6e12493bade6fca4738f180983", + "size": 9938, + "subdir": "linux-64", + "timestamp": 1667236717773, + "version": "1.23.3" + }, + "numpy-1.23.3-py39hf838250_0.tar.bz2": { + "build": "py39hf838250_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.3 py39h1e6e340_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e6b4020c4d8e59e94e927ec50783ad56", + "name": "numpy", + "sha256": "b9733682be0773efcb627c0027cbf76fa28bf1a546aafa15e049cd72d112057d", + "size": 9892, + "subdir": "linux-64", + "timestamp": 1665775783481, + "version": "1.23.3" + }, + "numpy-1.23.3-py39hf838250_1.tar.bz2": { + "build": "py39hf838250_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.3 py39h1e6e340_1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1790c345011573ff1ccfd14cf3a234c", + "name": "numpy", + "sha256": "d11c154b0c51402ea955daa6161dd3f21e93e13cb54859cb4be3f123b0bf33fd", + "size": 9934, + "subdir": "linux-64", + "timestamp": 1667234889870, + "version": "1.23.3" + }, + "numpy-1.23.4-py310hac523dd_0.tar.bz2": { + "build": "py310hac523dd_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.4 py310h375b286_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "182ba5c4178a73bdb63ed7928c9b1249", + "name": "numpy", + "sha256": "534223048c67464b36778ecb785c61b5608eba98c739771a9b1d52d478594f96", + "size": 9981, + "subdir": "linux-64", + "timestamp": 1668599501101, + "version": "1.23.4" + }, + "numpy-1.23.4-py310hd5efca6_0.tar.bz2": { + "build": "py310hd5efca6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.4 py310h8e6c178_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e60d5686b16d444acf0c92ca5947517c", + "name": "numpy", + "sha256": "f80e2cf5e74dfb6147f7613a16a1ecef483c9f444c4cf19f0dd9e6c336fb3aa7", + "size": 10008, + "subdir": "linux-64", + "timestamp": 1668596137742, + "version": "1.23.4" + }, + "numpy-1.23.4-py38h14f4228_0.tar.bz2": { + "build": "py38h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.4 py38h31eccc5_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5ca60e54eba56c5a57891b40332daa24", + "name": "numpy", + "sha256": "245aee31e9b95cd8665d65416ecef48b44cc80f25428f0cff966917512e5e265", + "size": 9989, + "subdir": "linux-64", + "timestamp": 1668593966118, + "version": "1.23.4" + }, + "numpy-1.23.4-py38hf838250_0.tar.bz2": { + "build": "py38hf838250_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.4 py38h1e6e340_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a4c3e05686fab7651aed2bab2ce1e745", + "name": "numpy", + "sha256": "4a089534b107c09f3e89ae8dd42718deaee1762467e5f73ac85be96756889514", + "size": 9969, + "subdir": "linux-64", + "timestamp": 1668597230935, + "version": "1.23.4" + }, + "numpy-1.23.4-py39h14f4228_0.tar.bz2": { + "build": "py39h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.4 py39h31eccc5_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a89284784559c0c5f75792fb096637c", + "name": "numpy", + "sha256": "7d7aed137e5095b280e2ba2b2f910c6b0f2c8bbb347fc01bce23e910d7192142", + "size": 9981, + "subdir": "linux-64", + "timestamp": 1668595078110, + "version": "1.23.4" + }, + "numpy-1.23.4-py39hf838250_0.tar.bz2": { + "build": "py39hf838250_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.4 py39h1e6e340_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5749ed7c8e12599a01893035aa0cc759", + "name": "numpy", + "sha256": "6f43d69f63bf353698581cdb7f5c03f6cf0a2da4e2ea13a608becf8b73a93ee8", + "size": 9938, + "subdir": "linux-64", + "timestamp": 1668598397191, + "version": "1.23.4" + }, + "numpy-1.23.5-py310hac523dd_0.tar.bz2": { + "build": "py310hac523dd_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.5 py310h375b286_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee9c5f14a20c3ead34c3bbfda7ea1a37", + "name": "numpy", + "sha256": "9ccd9b1d9fd0dffa046310c0859a27d2fe6bdabd08c0613141270fde05f84ae6", + "size": 9987, + "subdir": "linux-64", + "timestamp": 1672337464580, + "version": "1.23.5" + }, + "numpy-1.23.5-py310hd5efca6_0.tar.bz2": { + "build": "py310hd5efca6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.5 py310h8e6c178_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dfdf96ac060e022f4e28b6bcc87b35fb", + "name": "numpy", + "sha256": "917a40d703825a479acefd49ec51ee65c00e30be03059327199b401d77aeae0a", + "size": 10016, + "subdir": "linux-64", + "timestamp": 1672340596303, + "version": "1.23.5" + }, + "numpy-1.23.5-py311h5585df3_0.tar.bz2": { + "build": "py311h5585df3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.5 py311hc9e7d78_0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3037eb9725863347e0bac4f1b6921b5f", + "name": "numpy", + "sha256": "bee583b673faf5b6a7cf224d40ddf7d60b041be65f2d7241dc9c1bcc00283fc7", + "size": 10290, + "subdir": "linux-64", + "timestamp": 1676824043754, + "version": "1.23.5" + }, + "numpy-1.23.5-py311h75bd12f_0.tar.bz2": { + "build": "py311h75bd12f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.5 py311h0ff3221_0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9f6cf137ee580c16d93e73dc24b296c8", + "name": "numpy", + "sha256": "50511336789fc9fa0f6070616eb089f8bcbe096d457fd930ca310118cc834501", + "size": 10336, + "subdir": "linux-64", + "timestamp": 1676824212689, + "version": "1.23.5" + }, + "numpy-1.23.5-py38h14f4228_0.tar.bz2": { + "build": "py38h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.5 py38h31eccc5_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "64cbd27f53b4e11f4a5c369bbbe047ae", + "name": "numpy", + "sha256": "303fd04b60b06127a061b4625ea227bbf00ab991bbeab540023453130d3c5808", + "size": 9989, + "subdir": "linux-64", + "timestamp": 1672339520917, + "version": "1.23.5" + }, + "numpy-1.23.5-py38hf838250_0.tar.bz2": { + "build": "py38hf838250_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.5 py38h1e6e340_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f1711cb6b27f0f633c304a069e86b8b8", + "name": "numpy", + "sha256": "e63fa58fdc4c9f6b1272ee03da497251558df3de5f5f4ffea3c5bec0a0358668", + "size": 9958, + "subdir": "linux-64", + "timestamp": 1672336389645, + "version": "1.23.5" + }, + "numpy-1.23.5-py39h14f4228_0.tar.bz2": { + "build": "py39h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.5 py39h31eccc5_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7713cbd8b2c15afe49aac7728ef30489", + "name": "numpy", + "sha256": "5f2c0e4fbfc939669788ab2442de2bdbd474077cc4d2d76e9556fec16da228bc", + "size": 9990, + "subdir": "linux-64", + "timestamp": 1672341605630, + "version": "1.23.5" + }, + "numpy-1.23.5-py39hf838250_0.tar.bz2": { + "build": "py39hf838250_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.5 py39h1e6e340_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c7c8b768bb216a170640402d14d3fccb", + "name": "numpy", + "sha256": "c2df2a0c7d416beaba56c7d92d6d0f88ca187203c6a09ae075482437ec429f99", + "size": 9982, + "subdir": "linux-64", + "timestamp": 1672338478940, + "version": "1.23.5" + }, + "numpy-1.9.3-py27_nomklhbee5d10_3.tar.bz2": { + "build": "py27_nomklhbee5d10_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "3c2a2ae8fd06d351e79b8c5145f9bc00", + "name": "numpy", + "sha256": "bcbe9bfb2946042a07d52153f8dfd712e2fecd525e13178f4151848b2ff08799", + "size": 3372185, + "subdir": "linux-64", + "timestamp": 1509731891180, + "version": "1.9.3" + }, + "numpy-1.9.3-py27h1b885b7_7.tar.bz2": { + "build": "py27h1b885b7_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py27hdbf6ddf_7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b53a08d4ef44d45a8b1ec74b9dd2e3b8", + "name": "numpy", + "sha256": "86d7192b9d43e39faab7546bb1b9d46169e7c347585df6d6b9fb811d2cc210c4", + "size": 9750, + "subdir": "linux-64", + "timestamp": 1534345655411, + "version": "1.9.3" + }, + "numpy-1.9.3-py27h28100ab_5.tar.bz2": { + "build": "py27h28100ab_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6e9734a04768c5a7efc03966792c61c1", + "name": "numpy", + "sha256": "e01294507f79316ad025744432c91c21f4e70a3582dd978e5b2cfc9be1999cc1", + "size": 10281, + "subdir": "linux-64", + "timestamp": 1530278937649, + "version": "1.9.3" + }, + "numpy-1.9.3-py27h28100ab_6.tar.bz2": { + "build": "py27h28100ab_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py27h2b20989_6", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2d7d3c2981455f37abb6201dd0a41ae8", + "name": "numpy", + "sha256": "1c0b1320df56799c5c211c6555bb34f0df6c678211a32cb511c738fa15bf93f7", + "size": 10085, + "subdir": "linux-64", + "timestamp": 1530379924075, + "version": "1.9.3" + }, + "numpy-1.9.3-py27h28100ab_7.tar.bz2": { + "build": "py27h28100ab_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py27h2b20989_7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "85f63c7fbd22df046d96e7687e08036e", + "name": "numpy", + "sha256": "91cdf547ce1df961a6664ce7bca438cdff3a6b3a50954792c8616c77f356d938", + "size": 10173, + "subdir": "linux-64", + "timestamp": 1530550405055, + "version": "1.9.3" + }, + "numpy-1.9.3-py27h2aefc1b_7.tar.bz2": { + "build": "py27h2aefc1b_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py27h2b20989_7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6159b91c3e383d96c71fbaf285aa549d", + "name": "numpy", + "sha256": "e3eea67e070daaa1b0c1b28c94b4fe4b79fc022628b2abb7dcd660f74f2946a7", + "size": 9762, + "subdir": "linux-64", + "timestamp": 1534345708610, + "version": "1.9.3" + }, + "numpy-1.9.3-py27h7e35acb_3.tar.bz2": { + "build": "py27h7e35acb_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "mkl >=2018.0.0,<2019.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "7dfec27d601589f3cf41f8fc2e369058", + "name": "numpy", + "sha256": "04aafd4eafbbc6a31067eec7f5e87ef66d58a92139519673fbc8deaa18975298", + "size": 3370089, + "subdir": "linux-64", + "timestamp": 1506015990456, + "version": "1.9.3" + }, + "numpy-1.9.3-py27hcd700cb_5.tar.bz2": { + "build": "py27hcd700cb_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e88dd803b12a937f316797ad96717555", + "name": "numpy", + "sha256": "c2f5a2e2441243141dae3b17b4b1f43db18706f306f927ee307e541a73dbed2a", + "size": 10269, + "subdir": "linux-64", + "timestamp": 1530279172184, + "version": "1.9.3" + }, + "numpy-1.9.3-py27hcd700cb_6.tar.bz2": { + "build": "py27hcd700cb_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py27hdbf6ddf_6", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "53785ff554ede5a41ea3a905f725b175", + "name": "numpy", + "sha256": "99f930c80fd7eb99c240413d83b3c8c0224d981ed1ff1e26303e5c1c01864819", + "size": 10073, + "subdir": "linux-64", + "timestamp": 1530382963644, + "version": "1.9.3" + }, + "numpy-1.9.3-py27hcd700cb_7.tar.bz2": { + "build": "py27hcd700cb_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py27hdbf6ddf_7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8965e9a8a287887094ab4878d3e5e183", + "name": "numpy", + "sha256": "4e135740d268090d7d9b2f66197fd64b1910b879d03a09c76dccc2bbf6641d62", + "size": 10154, + "subdir": "linux-64", + "timestamp": 1530553009302, + "version": "1.9.3" + }, + "numpy-1.9.3-py35_nomklh11ed3e2_3.tar.bz2": { + "build": "py35_nomklh11ed3e2_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "6ed4b3a9bf93a0799632f175c09c7726", + "name": "numpy", + "sha256": "2808b44e32427033eaf71c99fc84f193430b38968df01aa14d14441188faa143", + "size": 3405042, + "subdir": "linux-64", + "timestamp": 1509731487200, + "version": "1.9.3" + }, + "numpy-1.9.3-py35h1b885b7_7.tar.bz2": { + "build": "py35h1b885b7_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py35hdbf6ddf_7", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "31c8c930e62dc7927f35d9e1536fe840", + "name": "numpy", + "sha256": "cffc5d80747de35a57719490f950420c9786dda3bccdcdd8351eb61823537003", + "size": 9740, + "subdir": "linux-64", + "timestamp": 1534345875570, + "version": "1.9.3" + }, + "numpy-1.9.3-py35h28100ab_7.tar.bz2": { + "build": "py35h28100ab_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py35h2b20989_7", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "15c072abe2b8399f7488e4f0b096e629", + "name": "numpy", + "sha256": "cba8a1f15ac073a70bd9927e840b68f0c60c10f6466ed853d35ccd712e4aa753", + "size": 10164, + "subdir": "linux-64", + "timestamp": 1530694232705, + "version": "1.9.3" + }, + "numpy-1.9.3-py35h2aefc1b_7.tar.bz2": { + "build": "py35h2aefc1b_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py35h2b20989_7", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c6c9081da53e6fb3518640db875b300a", + "name": "numpy", + "sha256": "2f75be13d5f9268705c2b6dc27db0a1becc70297db398ace1c3f490ba5b49b7c", + "size": 9745, + "subdir": "linux-64", + "timestamp": 1534345932315, + "version": "1.9.3" + }, + "numpy-1.9.3-py35hcd700cb_7.tar.bz2": { + "build": "py35hcd700cb_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py35hdbf6ddf_7", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "29348b6fa9e64b1a5ae8bb65da90b691", + "name": "numpy", + "sha256": "0d093d0cbd19c7010608b665b871bb77d90a6f36075b93c883465d1f5b98a123", + "size": 10153, + "subdir": "linux-64", + "timestamp": 1530694446144, + "version": "1.9.3" + }, + "numpy-1.9.3-py35hff6eb55_3.tar.bz2": { + "build": "py35hff6eb55_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "7225aa5333f40e095a90127ec811146e", + "name": "numpy", + "sha256": "b3b2d18a401fc59da493645de40d3d04ada7db1ed51056b54168b4dc9cff2395", + "size": 3405223, + "subdir": "linux-64", + "timestamp": 1506015816757, + "version": "1.9.3" + }, + "numpy-1.9.3-py36_nomklh9e07ec8_3.tar.bz2": { + "build": "py36_nomklh9e07ec8_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "323259699b3c8b7a1d3d12dfa4a392ce", + "name": "numpy", + "sha256": "02b56fc0e06022879f3ee9a9096f69162a340708d8a05740dcfe30d32bc40ee6", + "size": 3413577, + "subdir": "linux-64", + "timestamp": 1509732019133, + "version": "1.9.3" + }, + "numpy-1.9.3-py36h1b885b7_7.tar.bz2": { + "build": "py36h1b885b7_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py36hdbf6ddf_7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3da5a875d62c9db97d24708ec39f01d6", + "name": "numpy", + "sha256": "9f34765f6a3cb3391c6c8ff7c85eeeabb0a073154af2cbeb44ad2dd4e0ec6d1a", + "size": 9750, + "subdir": "linux-64", + "timestamp": 1534345762713, + "version": "1.9.3" + }, + "numpy-1.9.3-py36h28100ab_5.tar.bz2": { + "build": "py36h28100ab_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "40266bff51fa1316a62fe23ab668e137", + "name": "numpy", + "sha256": "65437a355d975e773416c51948d3061f7cedbc08cda4f61371df59b6d31fbb38", + "size": 10282, + "subdir": "linux-64", + "timestamp": 1530278932212, + "version": "1.9.3" + }, + "numpy-1.9.3-py36h28100ab_6.tar.bz2": { + "build": "py36h28100ab_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py36h2b20989_6", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "24d266257f27376f7c1821f4bba1e3c0", + "name": "numpy", + "sha256": "0792384bd5586f27c6fc20d62992371cc8182e57685b8ea7b036f37f9205b7a5", + "size": 10091, + "subdir": "linux-64", + "timestamp": 1530380591786, + "version": "1.9.3" + }, + "numpy-1.9.3-py36h28100ab_7.tar.bz2": { + "build": "py36h28100ab_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py36h2b20989_7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "35351005d1fbe93dd8e67ee339e7ddab", + "name": "numpy", + "sha256": "3a0f00693c1029f38ac8dded98d7fc8618cf29e2a265a186a22ea6e9d8a3bdce", + "size": 10166, + "subdir": "linux-64", + "timestamp": 1530550436550, + "version": "1.9.3" + }, + "numpy-1.9.3-py36h2aefc1b_7.tar.bz2": { + "build": "py36h2aefc1b_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py36h2b20989_7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7a05c34bf5cdc2e9faea86210cfe599a", + "name": "numpy", + "sha256": "e4000a5500723ccb4af0377df66753b30153153ebbb0b0e01527329865ef8e90", + "size": 9738, + "subdir": "linux-64", + "timestamp": 1534345819227, + "version": "1.9.3" + }, + "numpy-1.9.3-py36h35fcb08_3.tar.bz2": { + "build": "py36h35fcb08_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "67c2ac340672c27b6a327a2042ac040d", + "name": "numpy", + "sha256": "16a451f517e301ebcd472555da3a9bdabd2259e4fde861f0f2d85f847b128a26", + "size": 3415454, + "subdir": "linux-64", + "timestamp": 1506016053195, + "version": "1.9.3" + }, + "numpy-1.9.3-py36hcd700cb_5.tar.bz2": { + "build": "py36hcd700cb_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ab0ac1a40fcdf319607a04b2b195235f", + "name": "numpy", + "sha256": "d1f40334b230e4b6faab3b017ddb8ef6e62d51f7df701bfda23963c7ce145245", + "size": 10275, + "subdir": "linux-64", + "timestamp": 1530279227064, + "version": "1.9.3" + }, + "numpy-1.9.3-py36hcd700cb_6.tar.bz2": { + "build": "py36hcd700cb_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py36hdbf6ddf_6", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ff3f53b516f1a7d2d193da59be4161a1", + "name": "numpy", + "sha256": "8b959da853ee775b9e6de8d1bb50e82969357e0fd03701149f4b287fde9c5bdb", + "size": 10087, + "subdir": "linux-64", + "timestamp": 1530383323079, + "version": "1.9.3" + }, + "numpy-1.9.3-py36hcd700cb_7.tar.bz2": { + "build": "py36hcd700cb_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py36hdbf6ddf_7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5a4790740ec977615c09872c818a31d7", + "name": "numpy", + "sha256": "7c72a096c201f9cd52d73a755cdb42fa9f9864c4e034f0dc114230de677578c6", + "size": 10168, + "subdir": "linux-64", + "timestamp": 1530553481359, + "version": "1.9.3" + }, + "numpy-1.9.3-py37h1b885b7_7.tar.bz2": { + "build": "py37h1b885b7_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py37hdbf6ddf_7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "752c4a5b17f50da50e8611dd6e1b0835", + "name": "numpy", + "sha256": "37285d022291baf2f3574cafcf7029582fd38f4322606638c5461669057d929a", + "size": 9733, + "subdir": "linux-64", + "timestamp": 1534345986669, + "version": "1.9.3" + }, + "numpy-1.9.3-py37h28100ab_5.tar.bz2": { + "build": "py37h28100ab_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base >=1.9.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "efc55711aa462371a795642e493a5c61", + "name": "numpy", + "sha256": "ab2fd79a031a2e9e180c29f9878c524253aab3718ade380f5943f3d5977f7a04", + "size": 10268, + "subdir": "linux-64", + "timestamp": 1530278994315, + "version": "1.9.3" + }, + "numpy-1.9.3-py37h28100ab_6.tar.bz2": { + "build": "py37h28100ab_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py37h2b20989_6", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3643f3123a47bc5adb502fefc5653338", + "name": "numpy", + "sha256": "c2df247f34b36ef48b050cc4acd17c9f7f20f5dc8247645357ceaa0df8ee2074", + "size": 10095, + "subdir": "linux-64", + "timestamp": 1530381175946, + "version": "1.9.3" + }, + "numpy-1.9.3-py37h28100ab_7.tar.bz2": { + "build": "py37h28100ab_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py37h2b20989_7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "de0ccddb7770bc3f61809634e3499d5a", + "name": "numpy", + "sha256": "f4549f27b67577d2f5cc319ad5cc8e3f0400a8116394d1316b8196bca8de7874", + "size": 10171, + "subdir": "linux-64", + "timestamp": 1530550818362, + "version": "1.9.3" + }, + "numpy-1.9.3-py37h2aefc1b_7.tar.bz2": { + "build": "py37h2aefc1b_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py37h2b20989_7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0307bed8d10110571d9db362e03b768e", + "name": "numpy", + "sha256": "aa3bf80e7e2c9a9b8be9c8b6f3bba027bd392670299fbc1f61f5bff2f4a5fdb6", + "size": 9752, + "subdir": "linux-64", + "timestamp": 1534346040768, + "version": "1.9.3" + }, + "numpy-1.9.3-py37hcd700cb_5.tar.bz2": { + "build": "py37hcd700cb_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base >=1.9.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e7af111b64eea2281b49d800cdfe4d25", + "name": "numpy", + "sha256": "4a525e8288946b34deabe33a448e39d2fd94f03a89f6a4e7606708862a5123fd", + "size": 10257, + "subdir": "linux-64", + "timestamp": 1530279184440, + "version": "1.9.3" + }, + "numpy-1.9.3-py37hcd700cb_6.tar.bz2": { + "build": "py37hcd700cb_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py37hdbf6ddf_6", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8fa9f2654c75c81002c9b71eecc045ba", + "name": "numpy", + "sha256": "9808a51e18cd5418aff3f10a014e59d3806369caa36608163655e08c6a7de6c5", + "size": 10102, + "subdir": "linux-64", + "timestamp": 1530382640595, + "version": "1.9.3" + }, + "numpy-1.9.3-py37hcd700cb_7.tar.bz2": { + "build": "py37hcd700cb_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py37hdbf6ddf_7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4059b74185f8b4649ce79ce90ae87ab0", + "name": "numpy", + "sha256": "6ff0ff15431d4b487b1aabdf72d8aee347d0880475cb7e3c30ae63cf62baf0ab", + "size": 10173, + "subdir": "linux-64", + "timestamp": 1530553569297, + "version": "1.9.3" + }, + "numpy-base-1.11.3-py27h1793315_9.tar.bz2": { + "build": "py27h1793315_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "44cb9836c77212c7a5dadee3fff8c554", + "name": "numpy-base", + "sha256": "e6071177c05463886edb0e24852bde6c3dccb1413a747676f6c2d560e77b57be", + "size": 3668348, + "subdir": "linux-64", + "timestamp": 1534775017983, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h2b20989_7.tar.bz2": { + "build": "py27h2b20989_7", + "build_number": 7, + "constrains": [ + "numpy 1.11.3 py27h28100ab_7" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "236a5c1cf21606443df3b7e9c997927d", + "name": "numpy-base", + "sha256": "14ec060dedb46f42a6f3786488705ffbd88d7baeef475f6e5ed2c61de6b66172", + "size": 3663192, + "subdir": "linux-64", + "timestamp": 1530380274899, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h2b20989_8.tar.bz2": { + "build": "py27h2b20989_8", + "build_number": 8, + "constrains": [ + "numpy 1.11.3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "3fda6b3656012f8c1ff6587dcd26032d", + "name": "numpy-base", + "sha256": "92edb0257dc06129b5f7cd16473262c6ad83e2080c5b8039aa7506f1ed052092", + "size": 3668429, + "subdir": "linux-64", + "timestamp": 1530550803630, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h2f8d375_10.tar.bz2": { + "build": "py27h2f8d375_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py27h99e49ec_10" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "68631abd723dffab520a71633c6a2f36", + "name": "numpy-base", + "sha256": "063ce5432e50d02cbd5d44186c5d78002fd19214c3a3b054cf0a57be06e35eac", + "size": 3671908, + "subdir": "linux-64", + "timestamp": 1536892560859, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h2f8d375_11.tar.bz2": { + "build": "py27h2f8d375_11", + "build_number": 11, + "constrains": [ + "numpy 1.11.3 py27h99e49ec_11" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "b4cfd11f6a7c4be8eb5ce861f0074426", + "name": "numpy-base", + "sha256": "51e513f76162fc6966545eb4599a9f0c41d5b194cbd4e55d43a236c87cb9dc1c", + "size": 3711223, + "subdir": "linux-64", + "timestamp": 1544631941844, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h2f8d375_12.tar.bz2": { + "build": "py27h2f8d375_12", + "build_number": 12, + "constrains": [ + "numpy 1.11.3 py27h99e49ec_12" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "f5131622f02a648ea82ccf00eecf7e20", + "name": "numpy-base", + "sha256": "579a21debf10fba832e8fc1a3d8c0d3b4c80e2f0a40da5fab3b56786e2cc8170", + "size": 3724167, + "subdir": "linux-64", + "timestamp": 1544762959067, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h3dfced4_9.tar.bz2": { + "build": "py27h3dfced4_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py27h1b885b7_9" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "208430097441311047663733a6a81cc2", + "name": "numpy-base", + "sha256": "332b743d241901a141062360b084688e28cf8186750a06ad70317c31092b2063", + "size": 3665927, + "subdir": "linux-64", + "timestamp": 1532661262725, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h74e8950_10.tar.bz2": { + "build": "py27h74e8950_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py27hb510916_10" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "c9fdebe63194ba1def54fa3423b26f81", + "name": "numpy-base", + "sha256": "305386769bbc1d006b17b3934d9cd1713521ad7001af9b376bcd04b60510b745", + "size": 3671669, + "subdir": "linux-64", + "timestamp": 1535405687501, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h74e8950_9.tar.bz2": { + "build": "py27h74e8950_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py27hec00662_9" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "1ce262958041a21b7d247d12e82517c3", + "name": "numpy-base", + "sha256": "152fb7e013778cde53f6618ab04ccd5ffee791bc50df8be7221e9fad79a1ea70", + "size": 3671224, + "subdir": "linux-64", + "timestamp": 1535387751989, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h7cdd4dd_9.tar.bz2": { + "build": "py27h7cdd4dd_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py27h2aefc1b_9" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "becc1e5c4e585536092567891c46d0e8", + "name": "numpy-base", + "sha256": "af83f7ddec29dda5a1fbb2aacf2c297bcb4548c8d2be077af0a50e050b8f53c9", + "size": 3664833, + "subdir": "linux-64", + "timestamp": 1532660114432, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h81de0dd_10.tar.bz2": { + "build": "py27h81de0dd_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py27h1d66e8a_10" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "6b228e97f09a12ff902bad9ae9f1a6c4", + "name": "numpy-base", + "sha256": "1eb77dd3901958e91f974e043e46c8938754cd7d36b72b6142f339746f1e64a1", + "size": 3671865, + "subdir": "linux-64", + "timestamp": 1535405784392, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h81de0dd_9.tar.bz2": { + "build": "py27h81de0dd_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py27h3b04361_9" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "a7a619a927b766766fe07be8dfac1c16", + "name": "numpy-base", + "sha256": "5f97e0a2eaf23a12216fc01d637d75199b9e5040c29a557e55e8b1e372827c59", + "size": 3672514, + "subdir": "linux-64", + "timestamp": 1535388991931, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27hc937464_9.tar.bz2": { + "build": "py27hc937464_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "78a0db36f0612283ac158e775a273cbe", + "name": "numpy-base", + "sha256": "0e70e9d517c45951b5c292a9fc3eec3f50448661b56ebb5a255f2e922c202b90", + "size": 3667949, + "subdir": "linux-64", + "timestamp": 1534775212607, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27hdbf6ddf_7.tar.bz2": { + "build": "py27hdbf6ddf_7", + "build_number": 7, + "constrains": [ + "numpy 1.11.3 py27hcd700cb_7" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "2bf0c553f08ee2bdd0753735f371f7d1", + "name": "numpy-base", + "sha256": "be70bc5f5f685c2287859169a35b22e68227e013be23630138398863c7874ff3", + "size": 3665351, + "subdir": "linux-64", + "timestamp": 1530382440543, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27hdbf6ddf_8.tar.bz2": { + "build": "py27hdbf6ddf_8", + "build_number": 8, + "constrains": [ + "numpy 1.11.3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "3445b3cb7068a411ff5053e07a09c6bb", + "name": "numpy-base", + "sha256": "752a0b0ef6d99d7b57fd5b373fe0eccd2bf5870d3d8debace88688cd3d7639d1", + "size": 3668360, + "subdir": "linux-64", + "timestamp": 1530551361837, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27hde5b4d6_11.tar.bz2": { + "build": "py27hde5b4d6_11", + "build_number": 11, + "constrains": [ + "numpy 1.11.3 py27h7e9f1db_11" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "5d28501ef138cd80b483344689d87fdb", + "name": "numpy-base", + "sha256": "fd3e66424c283dc80d0f9f12ae4627d2772061c10e06f51fb903e339d9a02280", + "size": 3725269, + "subdir": "linux-64", + "timestamp": 1544632807533, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27hde5b4d6_12.tar.bz2": { + "build": "py27hde5b4d6_12", + "build_number": 12, + "constrains": [ + "numpy 1.11.3 py27h7e9f1db_12" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "9ea928cbe2b3364787cab1e8b365e334", + "name": "numpy-base", + "sha256": "0fa12fd2458fcef5efadf1ec5f235f0da420a534914f784d9095d0c2f6ced384", + "size": 3707632, + "subdir": "linux-64", + "timestamp": 1544763149155, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35h1793315_9.tar.bz2": { + "build": "py35h1793315_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "ee71692e6e05242e084cc2c22a30f91c", + "name": "numpy-base", + "sha256": "8471f48b0e8d5e9c8b4f585b5f831d07521d212e70102c51f3c90d88223966e0", + "size": 3699610, + "subdir": "linux-64", + "timestamp": 1534774621195, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35h2b20989_8.tar.bz2": { + "build": "py35h2b20989_8", + "build_number": 8, + "constrains": [ + "numpy 1.11.3 py35h2aefc1b_8" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "5a4de3bc3a3c49552d87e8a1381f570a", + "name": "numpy-base", + "sha256": "e8a55464fef80a421608ff67a4aab69f965522749affbcfb2ac50efd64a15557", + "size": 3699213, + "subdir": "linux-64", + "timestamp": 1534346529446, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35h2f8d375_10.tar.bz2": { + "build": "py35h2f8d375_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py35h99e49ec_10" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "120923c90e027d8a88abf34eeef8ab6c", + "name": "numpy-base", + "sha256": "eeb4b72b9427ef8765f6b67790380a557e71accfee8f841ee415ed2b39118412", + "size": 3701774, + "subdir": "linux-64", + "timestamp": 1536892593528, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35h3dfced4_9.tar.bz2": { + "build": "py35h3dfced4_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py35h1b885b7_9" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "c85711737c97156ae35a9e1842e9969e", + "name": "numpy-base", + "sha256": "eda72903cb74e6c1732cccf57c7adfeb3ca19d5fbaaaa416322d7dd20e26c3bd", + "size": 3702222, + "subdir": "linux-64", + "timestamp": 1532661233988, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35h74e8950_10.tar.bz2": { + "build": "py35h74e8950_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py35hb510916_10" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "3ca6d470236e54eb592437c07764ce80", + "name": "numpy-base", + "sha256": "c68b2089d147817240e5286eaea789cdd82ea634ee845ab0a646dc62406a8cc9", + "size": 3701983, + "subdir": "linux-64", + "timestamp": 1535405666419, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35h74e8950_9.tar.bz2": { + "build": "py35h74e8950_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py35hec00662_9" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "59c97c014d8be8a9fba4c376df7d06ab", + "name": "numpy-base", + "sha256": "7e18db82b09700b7c66204038a9eb210993c5e9935d6993d60d94408e01137a8", + "size": 3701944, + "subdir": "linux-64", + "timestamp": 1535388137827, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35h7cdd4dd_9.tar.bz2": { + "build": "py35h7cdd4dd_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py35h2aefc1b_9" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "6446851790ee75172ffb4026c0c87e56", + "name": "numpy-base", + "sha256": "4050a5cc59a5c3de29535838f7658964eb228133304ac9d50b3b7c17151ad779", + "size": 3700924, + "subdir": "linux-64", + "timestamp": 1532660149698, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35h81de0dd_10.tar.bz2": { + "build": "py35h81de0dd_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py35h1d66e8a_10" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "e7456b254cd59f34823cec1cb5bec34c", + "name": "numpy-base", + "sha256": "5209345dba08fb2e0753111bceec4c2cae240e2a7be0a1ef255287778dde5829", + "size": 3701515, + "subdir": "linux-64", + "timestamp": 1535406536153, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35h81de0dd_9.tar.bz2": { + "build": "py35h81de0dd_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py35h3b04361_9" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "2d1aa6903a6939970c7dfe2c6aa19d5e", + "name": "numpy-base", + "sha256": "f0b5379b5d81ae0c30d2b53c5e871af3564d124bb41a8a9de669d9f014002ca7", + "size": 3702043, + "subdir": "linux-64", + "timestamp": 1535389029286, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35hc937464_9.tar.bz2": { + "build": "py35hc937464_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "a697568a0676c9924583e5057768954f", + "name": "numpy-base", + "sha256": "549170eb679095c1a779e478049295a609c6ba5faafeba7bab2ef468bb4f9d1a", + "size": 3699822, + "subdir": "linux-64", + "timestamp": 1534774826637, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35hdbf6ddf_8.tar.bz2": { + "build": "py35hdbf6ddf_8", + "build_number": 8, + "constrains": [ + "numpy 1.11.3 py35h1b885b7_8" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "35391468515a636a74c61ad416e94d53", + "name": "numpy-base", + "sha256": "48e3d293132530c870ec8b0ce2b762b83aac4bc778eb7ff80de45e5616fa5206", + "size": 3699820, + "subdir": "linux-64", + "timestamp": 1534346254091, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h1793315_9.tar.bz2": { + "build": "py36h1793315_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "7346cee8421eef53ae4b048fff856f63", + "name": "numpy-base", + "sha256": "b37bab5854eb2ce0bb24e890b94cd6dd6fd619125c113b373d0aa2a6eedcecb7", + "size": 3686648, + "subdir": "linux-64", + "timestamp": 1534775413388, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h2b20989_7.tar.bz2": { + "build": "py36h2b20989_7", + "build_number": 7, + "constrains": [ + "numpy 1.11.3 py36h28100ab_7" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "2ed14412a1c1503af53a959472033b42", + "name": "numpy-base", + "sha256": "69812748a139d48638935e9fcd660e2e2f3688bf9c471b1835deed7507e7f30b", + "size": 3687761, + "subdir": "linux-64", + "timestamp": 1530380580452, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h2b20989_8.tar.bz2": { + "build": "py36h2b20989_8", + "build_number": 8, + "constrains": [ + "numpy 1.11.3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "cdde3f0fd88cb6e6a7e59f992ac1ac46", + "name": "numpy-base", + "sha256": "dca245a61f7af6009909a705788c59ff73847fbde86be5e8a30d97f12c4d90e7", + "size": 3689300, + "subdir": "linux-64", + "timestamp": 1530551206974, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h2f8d375_10.tar.bz2": { + "build": "py36h2f8d375_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py36h99e49ec_10" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "8bd92cd6c080f439d6696ac9d243f133", + "name": "numpy-base", + "sha256": "cc60073a15def8453554b123c75df157f55b8e8bfd66f7767391c15b25f110a0", + "size": 3703979, + "subdir": "linux-64", + "timestamp": 1536892532401, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h2f8d375_11.tar.bz2": { + "build": "py36h2f8d375_11", + "build_number": 11, + "constrains": [ + "numpy 1.11.3 py36h99e49ec_11" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "2be02ad7e03b871fb7d43046746c7184", + "name": "numpy-base", + "sha256": "df61989344a9c47c0a16679529dc50c67423b8077eb55a6f59a1e01b1c00efa1", + "size": 3748326, + "subdir": "linux-64", + "timestamp": 1544632112739, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h2f8d375_12.tar.bz2": { + "build": "py36h2f8d375_12", + "build_number": 12, + "constrains": [ + "numpy 1.11.3 py36h99e49ec_12" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "03f788cd5d0693b48df3983909752f74", + "name": "numpy-base", + "sha256": "eba81167d865c54acba61fe620bf53fbd7bc68355967f646c0abc1743ac1be4a", + "size": 3767834, + "subdir": "linux-64", + "timestamp": 1544763110442, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h3dfced4_9.tar.bz2": { + "build": "py36h3dfced4_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py36h1b885b7_9" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "85b44f324130299656d7373fa6612fe2", + "name": "numpy-base", + "sha256": "6863bf29684d6cb1ae443a49534b15897bcddbda80bd9c0b2959b3ab31a8c176", + "size": 3686944, + "subdir": "linux-64", + "timestamp": 1532661219173, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h74e8950_10.tar.bz2": { + "build": "py36h74e8950_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py36hb510916_10" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "1a029259a7052b0da5782b458c62ea01", + "name": "numpy-base", + "sha256": "a303c672e6682ed2d2d9cf79819a80a6e6e7276da20bd32d25c6141cabf4fad5", + "size": 3703272, + "subdir": "linux-64", + "timestamp": 1535405692946, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h74e8950_9.tar.bz2": { + "build": "py36h74e8950_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py36hec00662_9" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "d9576b9cbb564c26e365da3c5720210e", + "name": "numpy-base", + "sha256": "3d01eedc0f48f1de04ed01aaf771bfc7a8a442e7337201f14f97df6621935439", + "size": 3704533, + "subdir": "linux-64", + "timestamp": 1535388291466, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h7cdd4dd_9.tar.bz2": { + "build": "py36h7cdd4dd_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py36h2aefc1b_9" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "b179bca2fee6d562410f5a50ebfb4954", + "name": "numpy-base", + "sha256": "b555f2d4f304e3294f16da007dadec1a00c6643b32b9c7b2709cebe15727cc84", + "size": 3687764, + "subdir": "linux-64", + "timestamp": 1532660117894, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h81de0dd_10.tar.bz2": { + "build": "py36h81de0dd_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py36h1d66e8a_10" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "40e7391960a6ca0a03c56921651daa01", + "name": "numpy-base", + "sha256": "32e3a7546b3d4ab0f2c2dd08026580245a8e9daff63c5fbe43e053f22b5f60fd", + "size": 3703253, + "subdir": "linux-64", + "timestamp": 1535405831143, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h81de0dd_9.tar.bz2": { + "build": "py36h81de0dd_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py36h3b04361_9" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "e81598a71be953bd683cd2cd8453f235", + "name": "numpy-base", + "sha256": "11b7582686ae88c50d8b688be3f036c790700b806879ebdeb6a14a7c042cce01", + "size": 3702803, + "subdir": "linux-64", + "timestamp": 1535386683752, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36hc937464_9.tar.bz2": { + "build": "py36hc937464_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "31b3470fe8d709b7341b51ab497dbaa1", + "name": "numpy-base", + "sha256": "2dbe794bb220be546f6abafd55c1ba13cf9a4d6d1d911ae853b8ae328aa7ff8b", + "size": 3687215, + "subdir": "linux-64", + "timestamp": 1534775614120, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36hdbf6ddf_7.tar.bz2": { + "build": "py36hdbf6ddf_7", + "build_number": 7, + "constrains": [ + "numpy 1.11.3 py36hcd700cb_7" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "68e56094004f0b0a1d6fef3e7684c94e", + "name": "numpy-base", + "sha256": "ecb2e6efbc0ad3fde2f720a7291011c1ed4833fff851392dce71daefa9ef21eb", + "size": 3689291, + "subdir": "linux-64", + "timestamp": 1530382651295, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36hdbf6ddf_8.tar.bz2": { + "build": "py36hdbf6ddf_8", + "build_number": 8, + "constrains": [ + "numpy 1.11.3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "7420ea11e9557c6f5460b0cfb63fb23a", + "name": "numpy-base", + "sha256": "b25d7174f7225c9de5a40ee14fc1bbedada61b4021976f9f149eb68a2b8a6c2c", + "size": 3689170, + "subdir": "linux-64", + "timestamp": 1530553516869, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36hde5b4d6_11.tar.bz2": { + "build": "py36hde5b4d6_11", + "build_number": 11, + "constrains": [ + "numpy 1.11.3 py36h7e9f1db_11" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "cb9b78c1705ee95df16f0e91322575db", + "name": "numpy-base", + "sha256": "6cfff3e04a10115baac763f6dad71eabce104464bfabb33744eb5f665c0e4f09", + "size": 3765171, + "subdir": "linux-64", + "timestamp": 1544632711282, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36hde5b4d6_12.tar.bz2": { + "build": "py36hde5b4d6_12", + "build_number": 12, + "constrains": [ + "numpy 1.11.3 py36h7e9f1db_12" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "957e14b5100d306fb31255f51c11738c", + "name": "numpy-base", + "sha256": "84ecf061a2308dd1f5d51b3531134d1b8a98d43c1f123d847e39be3aad2786d8", + "size": 3757703, + "subdir": "linux-64", + "timestamp": 1544763289408, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h1793315_9.tar.bz2": { + "build": "py37h1793315_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "112750cb0d64a67f839646f3fb67a908", + "name": "numpy-base", + "sha256": "9c2b49f1b3b634f122d2177dc80fdbc79acbb0c98bcf7500a95f73134bd74756", + "size": 3665537, + "subdir": "linux-64", + "timestamp": 1534775809689, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h2b20989_7.tar.bz2": { + "build": "py37h2b20989_7", + "build_number": 7, + "constrains": [ + "numpy 1.11.3 py37h28100ab_7" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "cdd3c315ffdbd7e18ebc61db4d5c86d5", + "name": "numpy-base", + "sha256": "52740f7e9b8fa2d0912165894907f418c1b27ffe971326954314ab2bf47f5972", + "size": 3666592, + "subdir": "linux-64", + "timestamp": 1530380343058, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h2b20989_8.tar.bz2": { + "build": "py37h2b20989_8", + "build_number": 8, + "constrains": [ + "numpy 1.11.3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "dd82e75ff7fa55f05052edd94e81b7c8", + "name": "numpy-base", + "sha256": "991b2ab609176e565369888299c0d4e5a01570fbb899b4f91c09b83103f79764", + "size": 3665428, + "subdir": "linux-64", + "timestamp": 1530550558653, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h2f8d375_10.tar.bz2": { + "build": "py37h2f8d375_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py37h99e49ec_10" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "c92ea34689fa104ad32da40d1eb43b42", + "name": "numpy-base", + "sha256": "287cca0b516fc82ccb3ec70b2c192c181b26a5e752f2236aed0626dc60da806e", + "size": 3682140, + "subdir": "linux-64", + "timestamp": 1536892527790, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h2f8d375_11.tar.bz2": { + "build": "py37h2f8d375_11", + "build_number": 11, + "constrains": [ + "numpy 1.11.3 py37h99e49ec_11" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "45c88461813c0fc5dabbc9757d4c06c3", + "name": "numpy-base", + "sha256": "a73badd6308c7d31d4d876f8afcf33cce55efe5a2b2ee359360ad420f21e1ded", + "size": 3728034, + "subdir": "linux-64", + "timestamp": 1544631836888, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h2f8d375_12.tar.bz2": { + "build": "py37h2f8d375_12", + "build_number": 12, + "constrains": [ + "numpy 1.11.3 py37h99e49ec_12" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "99dd85e64352a76aab13a288f1a86625", + "name": "numpy-base", + "sha256": "72725da7e28de5083b1a1ff03514b613ed972cca8235de67c10a6d180372f454", + "size": 3730317, + "subdir": "linux-64", + "timestamp": 1544762954177, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h3dfced4_9.tar.bz2": { + "build": "py37h3dfced4_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py37h1b885b7_9" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "550b8d7e950dc1599b2d0ed9a775b04e", + "name": "numpy-base", + "sha256": "52499197d189e143ef1abab73bcfcc91fee8dfe5573ce68eca631ea8b328ce2f", + "size": 3666800, + "subdir": "linux-64", + "timestamp": 1532661026067, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h74e8950_10.tar.bz2": { + "build": "py37h74e8950_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py37hb510916_10" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "a5a71a3bcd457796c554599557c7113c", + "name": "numpy-base", + "sha256": "04a0b970bb31d8d7e235222ce36bcc76bc31fcf68e9021eb25bac24e0137ef49", + "size": 3682141, + "subdir": "linux-64", + "timestamp": 1535405061702, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h74e8950_9.tar.bz2": { + "build": "py37h74e8950_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py37hec00662_9" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "5967037ce368aec8c72a2349941e2ad1", + "name": "numpy-base", + "sha256": "27f670702583364cf2b2cc4f15466ae2075ce4ade22e793a0e0e78c4a71d9e21", + "size": 3681348, + "subdir": "linux-64", + "timestamp": 1535388233877, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h7cdd4dd_9.tar.bz2": { + "build": "py37h7cdd4dd_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py37h2aefc1b_9" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "15e09615cc34bfdb2d8f391280d0ed3d", + "name": "numpy-base", + "sha256": "98043c4cce5161d8b087426228e7670971ad849096580fbb49280a12687abac6", + "size": 3665829, + "subdir": "linux-64", + "timestamp": 1532660178666, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h81de0dd_10.tar.bz2": { + "build": "py37h81de0dd_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py37h1d66e8a_10" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "fadd75234ed843434f082a46038c6935", + "name": "numpy-base", + "sha256": "778b2988d85030eef03adfbcea3d6d754fe6c813fee135b249eab3226c14689e", + "size": 3680311, + "subdir": "linux-64", + "timestamp": 1535405831166, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h81de0dd_9.tar.bz2": { + "build": "py37h81de0dd_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py37h3b04361_9" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "b8c8eb2f7aaced1b0221d223b4139b49", + "name": "numpy-base", + "sha256": "150710b57f10f9c9df45e563bedd15e31b16e8a373ba9d2de72967e70337b296", + "size": 3681108, + "subdir": "linux-64", + "timestamp": 1535386867941, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37hc937464_9.tar.bz2": { + "build": "py37hc937464_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "2debb53830d055720df67a13d996616e", + "name": "numpy-base", + "sha256": "14114564d69f62e0cb78f876b565aad9f0ae74cce90cb426e64dd21f88935f83", + "size": 3664376, + "subdir": "linux-64", + "timestamp": 1534776013494, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37hdbf6ddf_7.tar.bz2": { + "build": "py37hdbf6ddf_7", + "build_number": 7, + "constrains": [ + "numpy 1.11.3 py37hcd700cb_7" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "032e59500279f5dcdfb99a17615afe15", + "name": "numpy-base", + "sha256": "417ca61c41acade54a7af98bbf15645932a710bcad875f739eae0177be7c35d6", + "size": 3666317, + "subdir": "linux-64", + "timestamp": 1530382662622, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37hdbf6ddf_8.tar.bz2": { + "build": "py37hdbf6ddf_8", + "build_number": 8, + "constrains": [ + "numpy 1.11.3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "78e8d9bf04770095bf7fb04aafe99d3f", + "name": "numpy-base", + "sha256": "6a9f8e721b292e0fde2115157e5c4c8457eb2c80b15ed16b54151c1bfef94e69", + "size": 3665757, + "subdir": "linux-64", + "timestamp": 1530553581760, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37hde5b4d6_11.tar.bz2": { + "build": "py37hde5b4d6_11", + "build_number": 11, + "constrains": [ + "numpy 1.11.3 py37h7e9f1db_11" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "9c03daa94d31423d6caf6717371d88e2", + "name": "numpy-base", + "sha256": "b9d08de22e17a6c2a98b6b1600a6cb2f723f8253ba28d502e5dbd9f1c4abdafd", + "size": 3727112, + "subdir": "linux-64", + "timestamp": 1544632706577, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37hde5b4d6_12.tar.bz2": { + "build": "py37hde5b4d6_12", + "build_number": 12, + "constrains": [ + "numpy 1.11.3 py37h7e9f1db_12" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "78f56d09d83aa01af8d4adf39c07336a", + "name": "numpy-base", + "sha256": "9cf13018ada56a44611501d261a1675f6327ec4b32ff51800ffc57b62a962a14", + "size": 3750057, + "subdir": "linux-64", + "timestamp": 1544763230115, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py38h2f8d375_12.tar.bz2": { + "build": "py38h2f8d375_12", + "build_number": 12, + "constrains": [ + "numpy 1.11.3 py38h99e49ec_12" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "57096b45091e99124c245e5e753b1e3d", + "name": "numpy-base", + "sha256": "5f469fd15eed8e5fb2a2b51ee7759b5c180554aace7414675f7f3b290510f0ad", + "size": 3786770, + "subdir": "linux-64", + "timestamp": 1572609721493, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py38hde5b4d6_12.tar.bz2": { + "build": "py38hde5b4d6_12", + "build_number": 12, + "constrains": [ + "numpy 1.11.3 py38h7e9f1db_12" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "60f1913a6ab1834d4f7cd5f4c3efeb0c", + "name": "numpy-base", + "sha256": "741117b6b039cdbca3d832586f69f66e79a4350dc33150b80848ec5048b39182", + "size": 3786565, + "subdir": "linux-64", + "timestamp": 1572609496617, + "version": "1.11.3" + }, + "numpy-base-1.14.3-py27h0ea5e3f_1.tar.bz2": { + "build": "py27h0ea5e3f_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.3 py27h28100ab_1" + ], + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "md5": "c447941214bbbbdb29eba3f1865ad92f", + "name": "numpy-base", + "sha256": "85880df6edf70c7a5db509ba45058c34e231da8b52610f503629ccfbea8be09b", + "size": 4229316, + "subdir": "linux-64", + "timestamp": 1526858626640, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py27h2b20989_0.tar.bz2": { + "build": "py27h2b20989_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "md5": "af8870f21ae5977b1ad95e3d8ccb6945", + "name": "numpy-base", + "sha256": "a00df043c6871cf712cea044b13de1aee604dae87105ca8e89f133542347cd33", + "size": 4231242, + "subdir": "linux-64", + "timestamp": 1525977093654, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py27h9be14a7_1.tar.bz2": { + "build": "py27h9be14a7_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.3 py27hcd700cb_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "c7f440beab87e2b1b0f5a51fbb6594fb", + "name": "numpy-base", + "sha256": "658dc3285e75dcfa06bda9ebb3bc6db82f73b62393b2c4175fb4f301d813f4b5", + "size": 4273470, + "subdir": "linux-64", + "timestamp": 1526859325100, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py27hdbf6ddf_0.tar.bz2": { + "build": "py27hdbf6ddf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py", + "blas * mkl" + ], + "md5": "037fd3bfee20849178afb144b885eed0", + "name": "numpy-base", + "sha256": "9aa91577994f9c85582d22f36a05c35083c1eaa95bb378c91c21f0752f154363", + "size": 4269785, + "subdir": "linux-64", + "timestamp": 1525977377358, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py35h0ea5e3f_1.tar.bz2": { + "build": "py35h0ea5e3f_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.3 py35h28100ab_1" + ], + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "md5": "e0b390c0d2aed87345484ac8e2e5c2a8", + "name": "numpy-base", + "sha256": "8da7a2f7680e189bcc47a4779f9c37a1a84c185a5d76e5cfaf80106e875f90a8", + "size": 4190464, + "subdir": "linux-64", + "timestamp": 1526858681472, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py35h2b20989_0.tar.bz2": { + "build": "py35h2b20989_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "md5": "d89ef4c53f93527844f02bc9e6d09a98", + "name": "numpy-base", + "sha256": "7c1ba19bc3a29818d26d7e6ac940449738fbab0744d6e10d0a4c52880266d890", + "size": 4194032, + "subdir": "linux-64", + "timestamp": 1525976852270, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py35h9be14a7_1.tar.bz2": { + "build": "py35h9be14a7_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.3 py35hcd700cb_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "44d893e4c758397e4767bad0e97d227d", + "name": "numpy-base", + "sha256": "18d4e4e7a4f8d5c43fd1fe01e42b06c87951a7a847e2f98fcc4c914d9fce5a8e", + "size": 4275678, + "subdir": "linux-64", + "timestamp": 1526859339760, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py35hdbf6ddf_0.tar.bz2": { + "build": "py35hdbf6ddf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py", + "blas * mkl" + ], + "md5": "b21fdc6b2721e4d0dd16ab980cff9026", + "name": "numpy-base", + "sha256": "6d0db699c0f72affb164ec54059b929a37a6af8a39fb7f54817bf3cd91f1bd15", + "size": 4278362, + "subdir": "linux-64", + "timestamp": 1525977737239, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py36h0ea5e3f_1.tar.bz2": { + "build": "py36h0ea5e3f_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.3 py36h28100ab_1" + ], + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "md5": "f3a764b0d276431260069871ef0cdbc5", + "name": "numpy-base", + "sha256": "7adca2a326d737152bf39fdc340d2ecdfbde858f9bdcdcb209d4e292882d1ae9", + "size": 4249497, + "subdir": "linux-64", + "timestamp": 1526858435951, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py36h2b20989_0.tar.bz2": { + "build": "py36h2b20989_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "md5": "59907ce4c896fc1ee712e4321e3448a7", + "name": "numpy-base", + "sha256": "fdf63d1f3a00a461752290cdaba19a9c74d0bfb5f7bcb7d4aac1ded0ac9ab511", + "size": 4249255, + "subdir": "linux-64", + "timestamp": 1525976598624, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py36h9be14a7_1.tar.bz2": { + "build": "py36h9be14a7_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.3 py36hcd700cb_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "bab50de67d0c700c4d1e23bc28d46f4c", + "name": "numpy-base", + "sha256": "d1c8b8e5a07c1b2cf86234402ca27168e748ac877783f5df9cb726c57c3c187f", + "size": 4295508, + "subdir": "linux-64", + "timestamp": 1526858969963, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py36hdbf6ddf_0.tar.bz2": { + "build": "py36hdbf6ddf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py", + "blas * mkl" + ], + "md5": "ccd23bde4ff0e5c103686f69af20e400", + "name": "numpy-base", + "sha256": "dc3e522565abd256f5709288bdbeabc5fa6746d595a5e10f47e65ecab38075fa", + "size": 4294871, + "subdir": "linux-64", + "timestamp": 1525977061421, + "version": "1.14.3" + }, + "numpy-base-1.14.4-py27h2b20989_0.tar.bz2": { + "build": "py27h2b20989_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.4 py27h28100ab_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "9715108cda495c302a18740c3524fa12", + "name": "numpy-base", + "sha256": "daf65a6d18d770a7a93a4e769d8c905fb473c42da723e8ce13c40fc88f63cad6", + "size": 4268356, + "subdir": "linux-64", + "timestamp": 1528829162887, + "version": "1.14.4" + }, + "numpy-base-1.14.4-py27hdbf6ddf_0.tar.bz2": { + "build": "py27hdbf6ddf_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.4 py27hcd700cb_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "5e354dc2b0d0e145ac5b74056ef5de79", + "name": "numpy-base", + "sha256": "c8733362886b2c3011f0fca09221e0d6f7149e044f8f63ed6deaf730ec82e9f0", + "size": 4316501, + "subdir": "linux-64", + "timestamp": 1528829618777, + "version": "1.14.4" + }, + "numpy-base-1.14.4-py35h2b20989_0.tar.bz2": { + "build": "py35h2b20989_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.4 py35h28100ab_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "a73887b58c62e38c48e4615cae31a73f", + "name": "numpy-base", + "sha256": "44443373a8742a0c71d0a99d4015766034da58a93fd54d526cf5cc3553ab71cf", + "size": 4309408, + "subdir": "linux-64", + "timestamp": 1528829210648, + "version": "1.14.4" + }, + "numpy-base-1.14.4-py35hdbf6ddf_0.tar.bz2": { + "build": "py35hdbf6ddf_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.4 py35hcd700cb_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "99a16353b6ddc3f565a80b351173117e", + "name": "numpy-base", + "sha256": "4576ca15c661601889feb7573419772c00403957e3b50db54b5cc915894b45b8", + "size": 4386097, + "subdir": "linux-64", + "timestamp": 1528829746076, + "version": "1.14.4" + }, + "numpy-base-1.14.4-py36h2b20989_0.tar.bz2": { + "build": "py36h2b20989_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.4 py36h28100ab_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "7cbf616b53cbd5c2ebe00e02b075f836", + "name": "numpy-base", + "sha256": "6034bdb5ee1a640af5df5b72c28ea4eaa9643a54d0dca0275e8d1df953ba0562", + "size": 4308467, + "subdir": "linux-64", + "timestamp": 1528829194891, + "version": "1.14.4" + }, + "numpy-base-1.14.4-py36hdbf6ddf_0.tar.bz2": { + "build": "py36hdbf6ddf_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.4 py36hcd700cb_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "26c5de619c0d367353d4b481f3536d58", + "name": "numpy-base", + "sha256": "5145439757bfca6d20af670e9713202954aa0784eaf26ced36685afe5583264c", + "size": 4352613, + "subdir": "linux-64", + "timestamp": 1528829651825, + "version": "1.14.4" + }, + "numpy-base-1.14.5-py27h2b20989_0.tar.bz2": { + "build": "py27h2b20989_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.5 py27h28100ab_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "266a35538b37c4ffb66b92549275d387", + "name": "numpy-base", + "sha256": "390c507a35a0aca27682fa8ea584dee863dd3d1da4a389af2f8b5ca3d7cd6837", + "size": 4286696, + "subdir": "linux-64", + "timestamp": 1528900913985, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py27h2b20989_1.tar.bz2": { + "build": "py27h2b20989_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.5 py27h28100ab_1" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "5fbaf003b312fb6c463058616106e50c", + "name": "numpy-base", + "sha256": "17813817d864ce78f94c40d560e27fbe3a5e4a08856d3270d59798e8c3e26c7a", + "size": 4286335, + "subdir": "linux-64", + "timestamp": 1530354187670, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py27h2b20989_2.tar.bz2": { + "build": "py27h2b20989_2", + "build_number": 2, + "constrains": [ + "numpy 1.14.5 py27h28100ab_2" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "81614025a2aa8f6e7d86444508e5c223", + "name": "numpy-base", + "sha256": "ba9d1408b61efd4a73ab8a7dac302efa5f0f00d5ae55042d0802fe3846724563", + "size": 4286704, + "subdir": "linux-64", + "timestamp": 1530382222361, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py27h2b20989_3.tar.bz2": { + "build": "py27h2b20989_3", + "build_number": 3, + "constrains": [ + "numpy 1.14.5 py27h28100ab_3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "7f0c64e702c859fd032e27079acbda34", + "name": "numpy-base", + "sha256": "1e1133b0b625ee7d71a7af5a654d5d2cf55a71257a1b166c7eb72425243ab57d", + "size": 4286521, + "subdir": "linux-64", + "timestamp": 1530553500400, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py27h2b20989_4.tar.bz2": { + "build": "py27h2b20989_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.5 py27h2aefc1b_4" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "15a71570a653c96ee8de75b2687f87d4", + "name": "numpy-base", + "sha256": "df0326b51f1c8cf065e071b1e44524a02e16b708f219fc4552bc0b334f17f852", + "size": 4206782, + "subdir": "linux-64", + "timestamp": 1531326430685, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py27hdbf6ddf_0.tar.bz2": { + "build": "py27hdbf6ddf_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.5 py27hcd700cb_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "ce369699f2cffa575f9e4f2c4c5bb2ac", + "name": "numpy-base", + "sha256": "0f59da1678334d2b737dfa0f725edba38130a41cac509c2684e41ca09bd30517", + "size": 4320546, + "subdir": "linux-64", + "timestamp": 1528901248948, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py27hdbf6ddf_1.tar.bz2": { + "build": "py27hdbf6ddf_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.5 py27hcd700cb_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "597ebbb08ae3469ca2e40521bb22e298", + "name": "numpy-base", + "sha256": "0e4909aa1c8e69b6b469801c00fc78db67f5492fd426d90129858074bac4348a", + "size": 4318938, + "subdir": "linux-64", + "timestamp": 1530353515611, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py27hdbf6ddf_2.tar.bz2": { + "build": "py27hdbf6ddf_2", + "build_number": 2, + "constrains": [ + "numpy 1.14.5 py27hcd700cb_2" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "13542122ac865182bce25cf75b1e39a7", + "name": "numpy-base", + "sha256": "9eccb8daf732dcf9ed17e5d04ba1fc7e847aa51f2d0cf709bf462a93756f42ae", + "size": 4320139, + "subdir": "linux-64", + "timestamp": 1530382744009, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py27hdbf6ddf_3.tar.bz2": { + "build": "py27hdbf6ddf_3", + "build_number": 3, + "constrains": [ + "numpy 1.14.5 py27hcd700cb_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "66c9f6c9c43870f1b8d99fbf12d1e72b", + "name": "numpy-base", + "sha256": "bc1cd661a03ce3f8dac110a7b021b6ffb86c374220a69804f8f0e7f0c20cb1f3", + "size": 4320741, + "subdir": "linux-64", + "timestamp": 1530554161054, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py27hdbf6ddf_4.tar.bz2": { + "build": "py27hdbf6ddf_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.5 py27h1b885b7_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "6684d7fe8e0539228a355ca378abf184", + "name": "numpy-base", + "sha256": "5eeaadaed0de07286ab580597a855e996d46c90914a8d5f6954da9b49a210796", + "size": 4255373, + "subdir": "linux-64", + "timestamp": 1531326758643, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py35h2b20989_0.tar.bz2": { + "build": "py35h2b20989_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.5 py35h28100ab_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "4ee97fadd05383499f57cb17ddff753a", + "name": "numpy-base", + "sha256": "de02279b884baf834644a58d4758a616b3b6834dcecf0515a1b4f6ee56824bcd", + "size": 4251333, + "subdir": "linux-64", + "timestamp": 1528900946070, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py35h2b20989_4.tar.bz2": { + "build": "py35h2b20989_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.5 py35h2aefc1b_4" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "dd23462da6c2fe7cfc391825671a9874", + "name": "numpy-base", + "sha256": "e7eadb95e2b01663fb5975fc48f933ed0ef4bbdfa943d87fca8bc897d52bc237", + "size": 4191352, + "subdir": "linux-64", + "timestamp": 1534347276868, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py35hdbf6ddf_0.tar.bz2": { + "build": "py35hdbf6ddf_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.5 py35hcd700cb_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "c6df396d57e5a1274b53972bd31e14c6", + "name": "numpy-base", + "sha256": "359414501a3ff511e8fbd3451827c3a9c6afbb6bcb4d3c5aeebd755a31921a5f", + "size": 4340424, + "subdir": "linux-64", + "timestamp": 1528901264729, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py35hdbf6ddf_4.tar.bz2": { + "build": "py35hdbf6ddf_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.5 py35h1b885b7_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "b843a956301a4aa601a5eb40f7585526", + "name": "numpy-base", + "sha256": "c0ac01a6637503ef7fd44cee0c4c61be8a7cebf28e8b9cb8c1a495a136f18897", + "size": 4269548, + "subdir": "linux-64", + "timestamp": 1534346974730, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36h2b20989_0.tar.bz2": { + "build": "py36h2b20989_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.5 py36h28100ab_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "6bb3ead757c7335e89cf8f121c77bcf4", + "name": "numpy-base", + "sha256": "35097effcf28a617e0e00c02615cfe0a19bbd10c1536bfd08e8782051bdba55c", + "size": 4290991, + "subdir": "linux-64", + "timestamp": 1528900361631, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36h2b20989_1.tar.bz2": { + "build": "py36h2b20989_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.5 py36h28100ab_1" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "c8820dd3313fd5131d057b784a298937", + "name": "numpy-base", + "sha256": "2c31174aa81a2c4cb66b2dc98d5d57a546a481d4a3a3ed032e65e315c4273665", + "size": 4290932, + "subdir": "linux-64", + "timestamp": 1530352911359, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36h2b20989_2.tar.bz2": { + "build": "py36h2b20989_2", + "build_number": 2, + "constrains": [ + "numpy 1.14.5 py36h28100ab_2" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "1008c1a5a10987093929d31c607843ff", + "name": "numpy-base", + "sha256": "df31f840d8112e6746885c332710729338276613fbd4f68693aac803b6cdf256", + "size": 4292718, + "subdir": "linux-64", + "timestamp": 1530382306729, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36h2b20989_3.tar.bz2": { + "build": "py36h2b20989_3", + "build_number": 3, + "constrains": [ + "numpy 1.14.5 py36h28100ab_3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "2c7d0909f89bcdc514a591baa7fe6594", + "name": "numpy-base", + "sha256": "265a40cc63f937ef9535b24b4537b2aba64e8a5b106105eecafa82091d39d314", + "size": 4291739, + "subdir": "linux-64", + "timestamp": 1530552739585, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36h2b20989_4.tar.bz2": { + "build": "py36h2b20989_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.5 py36h2aefc1b_4" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "c39cd2969636b3600c0cdcfa8bc6415f", + "name": "numpy-base", + "sha256": "08e5a48e1a135a0bd48aad89fd1986ebbce48b297011be09c4fb99d47470f5c0", + "size": 4236328, + "subdir": "linux-64", + "timestamp": 1531327695065, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36hdbf6ddf_0.tar.bz2": { + "build": "py36hdbf6ddf_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.5 py36hcd700cb_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "6f2310fa695bf9ffd9eac8702179c6c9", + "name": "numpy-base", + "sha256": "add478b36c451a27713989e6343b4fcb78d52444f4b2d2f41b9f5fa69483f344", + "size": 4340858, + "subdir": "linux-64", + "timestamp": 1528900963107, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36hdbf6ddf_1.tar.bz2": { + "build": "py36hdbf6ddf_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.5 py36hcd700cb_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "596b00d4944e8c76c59bd32694d5e547", + "name": "numpy-base", + "sha256": "91e32d881f3808de227d9c5299946e985491751515d74058f04cdd49dfea08ac", + "size": 4339261, + "subdir": "linux-64", + "timestamp": 1530353566518, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36hdbf6ddf_2.tar.bz2": { + "build": "py36hdbf6ddf_2", + "build_number": 2, + "constrains": [ + "numpy 1.14.5 py36hcd700cb_2" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "eaee8234b5ac0af8d7e5cc85f07bb536", + "name": "numpy-base", + "sha256": "2fcaf705399f3996a557b2e9bde5ad39620340d6a051aa26542d8c37948b67c4", + "size": 4339138, + "subdir": "linux-64", + "timestamp": 1530383180770, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36hdbf6ddf_3.tar.bz2": { + "build": "py36hdbf6ddf_3", + "build_number": 3, + "constrains": [ + "numpy 1.14.5 py36hcd700cb_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "f08ec13d2684f95a2fba2c7fc892141d", + "name": "numpy-base", + "sha256": "e5ab4d74ce069536f83e8319e6a31ea93b7c5819551512a68e118622c2199f2c", + "size": 4339470, + "subdir": "linux-64", + "timestamp": 1530553377190, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36hdbf6ddf_4.tar.bz2": { + "build": "py36hdbf6ddf_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.5 py36h1b885b7_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "8412a1c20ca1d64ca1dd3edd9a779029", + "name": "numpy-base", + "sha256": "b0ba160be340f1fd823ad86db28729f6ff3b59d09417954331c6cea7e0c1dad9", + "size": 4286054, + "subdir": "linux-64", + "timestamp": 1531342855068, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py37h2b20989_1.tar.bz2": { + "build": "py37h2b20989_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.5 py37h28100ab_1" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "80b503fe4d4389382a37c20d5e9ec90b", + "name": "numpy-base", + "sha256": "30b1c6ce3e0512e1d715445b32799ef8e093236f80ff6902ae98deaf40d6a22f", + "size": 4285673, + "subdir": "linux-64", + "timestamp": 1530353310003, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py37h2b20989_2.tar.bz2": { + "build": "py37h2b20989_2", + "build_number": 2, + "constrains": [ + "numpy 1.14.5 py37h28100ab_2" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "19575519c034d996f5b7db5aca63d895", + "name": "numpy-base", + "sha256": "d62062c2585a0bbfffd81de53d6a8d04492e5f1ec916e4dd90d9e62afa27a3b9", + "size": 4285753, + "subdir": "linux-64", + "timestamp": 1530382719240, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py37h2b20989_3.tar.bz2": { + "build": "py37h2b20989_3", + "build_number": 3, + "constrains": [ + "numpy 1.14.5 py37h28100ab_3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "8e2938e19259597f5b1fd8e1ae026ef6", + "name": "numpy-base", + "sha256": "be1981ca777c43c97ff4425c947961046b0732b77b96a4fe13f361bb438ce1b0", + "size": 4286425, + "subdir": "linux-64", + "timestamp": 1530553106104, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py37h2b20989_4.tar.bz2": { + "build": "py37h2b20989_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.5 py37h2aefc1b_4" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "bca3d7c92ff73465f45c53e93565b58c", + "name": "numpy-base", + "sha256": "2b567f96298b50706597ce6aa68c5c8d674f2c548d5366283bde0f4e1435da9a", + "size": 4224979, + "subdir": "linux-64", + "timestamp": 1531327064346, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py37hdbf6ddf_1.tar.bz2": { + "build": "py37hdbf6ddf_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.5 py37hcd700cb_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "de694cf9e1b02fb608ee11ffd233823f", + "name": "numpy-base", + "sha256": "75fc0ad45a1ed06948dbedcbc50f12de0b4d1d92b8b6f775d73dacacdbd2c03f", + "size": 4335856, + "subdir": "linux-64", + "timestamp": 1530353639685, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py37hdbf6ddf_2.tar.bz2": { + "build": "py37hdbf6ddf_2", + "build_number": 2, + "constrains": [ + "numpy 1.14.5 py37hcd700cb_2" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "eba0ee97f7040700d5b1f94f22b66858", + "name": "numpy-base", + "sha256": "7c51215de1ab5b9bce6bb178a152d6620331900a1e7948e6c98bf068b2371770", + "size": 4336198, + "subdir": "linux-64", + "timestamp": 1530383125671, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py37hdbf6ddf_3.tar.bz2": { + "build": "py37hdbf6ddf_3", + "build_number": 3, + "constrains": [ + "numpy 1.14.5 py37hcd700cb_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "4c7205dd537478b45f16750c70ebd383", + "name": "numpy-base", + "sha256": "97b9d23daa1e731980d54d8a4eceeee4a843760cd899fa165d14febfc4cc88fe", + "size": 4335804, + "subdir": "linux-64", + "timestamp": 1530553379902, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py37hdbf6ddf_4.tar.bz2": { + "build": "py37hdbf6ddf_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.5 py37h1b885b7_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "717cdd156af6f3ad64446fef421b0899", + "name": "numpy-base", + "sha256": "90261938f0d3111bf9424f4fda609485ab5a140ca94c157938c64d257588b55a", + "size": 4282837, + "subdir": "linux-64", + "timestamp": 1531327385152, + "version": "1.14.5" + }, + "numpy-base-1.14.6-py27h2f8d375_4.tar.bz2": { + "build": "py27h2f8d375_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py27hec00662_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "bb150fb3efb5097cfe26c10d43d010d0", + "name": "numpy-base", + "sha256": "8982cea4535797094a904f4d156d2a5ecf8ddf2a497e44f32f4a1195b877910e", + "size": 4246469, + "subdir": "linux-64", + "timestamp": 1538074835750, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py27h2f8d375_5.tar.bz2": { + "build": "py27h2f8d375_5", + "build_number": 5, + "constrains": [ + "numpy 1.14.6 py27hec00662_5" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "257bcc447f42bcbc9d9dc858d3bb0ee9", + "name": "numpy-base", + "sha256": "dce6da23f063712aba7ddc0d6336e9198c9b7daad3c6dd8520258b2caf034a40", + "size": 4247117, + "subdir": "linux-64", + "timestamp": 1569339380897, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py27h81de0dd_4.tar.bz2": { + "build": "py27h81de0dd_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py27h3b04361_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "bd2fad29427710f8fb7b64e367820271", + "name": "numpy-base", + "sha256": "075181e5802735de87d0a17337ae46d60c88e9ddecb5452565a8ca88209685dc", + "size": 4279073, + "subdir": "linux-64", + "timestamp": 1538074646411, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py27hde5b4d6_5.tar.bz2": { + "build": "py27hde5b4d6_5", + "build_number": 5, + "constrains": [ + "numpy 1.14.6 py27h3b04361_5" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "9b3261b56c988bb9daf835348cae9273", + "name": "numpy-base", + "sha256": "8fe20bb51558496fee2f8bbea08930fd6bbfd9512b4942e779fe4f31971682dc", + "size": 4310323, + "subdir": "linux-64", + "timestamp": 1569339397590, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py35h2f8d375_4.tar.bz2": { + "build": "py35h2f8d375_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py35hec00662_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "f40f625fe24030d17f4aee244785a6c9", + "name": "numpy-base", + "sha256": "618da7b251ec11b46e20b5fe88095375595a647b7c2ca8de3d834a9ab40152ba", + "size": 4222975, + "subdir": "linux-64", + "timestamp": 1538074493229, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py35h81de0dd_4.tar.bz2": { + "build": "py35h81de0dd_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py35h3b04361_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "a9e5ddcf1db8e9163c386f86f7ec2f4c", + "name": "numpy-base", + "sha256": "eb163521720985fcd5e9c05f72340ec131b1e90334fc1a266b76041ee3bea8f9", + "size": 4308147, + "subdir": "linux-64", + "timestamp": 1538074906028, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py36h2f8d375_4.tar.bz2": { + "build": "py36h2f8d375_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py36hec00662_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "d2f7da1ea7247eb333bcb0e00654fc30", + "name": "numpy-base", + "sha256": "8497966cec1b2aa5b63d7f83975e65b35db6e1e80fe352cf140bddcd0cfca18b", + "size": 4257691, + "subdir": "linux-64", + "timestamp": 1538074826622, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py36h2f8d375_5.tar.bz2": { + "build": "py36h2f8d375_5", + "build_number": 5, + "constrains": [ + "numpy 1.14.6 py36hec00662_5" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "0577ef42fcacacbf3343b1cc3321a28b", + "name": "numpy-base", + "sha256": "2463e6b436299bf3f93ee9b2252c47e3ba73a1b033fd6dd1c09d81ba35b23afc", + "size": 4264466, + "subdir": "linux-64", + "timestamp": 1569339268849, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py36h81de0dd_4.tar.bz2": { + "build": "py36h81de0dd_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py36h3b04361_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "0d8d6643b98d320dd517444c89051e96", + "name": "numpy-base", + "sha256": "99f44a7a1b97a90741fcd38bc9348f80ab9f0bbb90f537069b3da84cd3dbfc9c", + "size": 4300982, + "subdir": "linux-64", + "timestamp": 1538075066840, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py36hde5b4d6_5.tar.bz2": { + "build": "py36hde5b4d6_5", + "build_number": 5, + "constrains": [ + "numpy 1.14.6 py36h3b04361_5" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "569d8c685b94664983e13b93040dc11a", + "name": "numpy-base", + "sha256": "091e7994158a620f157f8097f7aef700220a653a8ea23f089921ad2c1f02313a", + "size": 4364086, + "subdir": "linux-64", + "timestamp": 1569339416422, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py37h2f8d375_4.tar.bz2": { + "build": "py37h2f8d375_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py37hec00662_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "cd378506a65549a2b888ce86fc29215a", + "name": "numpy-base", + "sha256": "91fb3cc49f32c7d9bf93e43da4959d90ce1ccf8bc2517d7e57bbcd808949518d", + "size": 4245113, + "subdir": "linux-64", + "timestamp": 1538074406834, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py37h2f8d375_5.tar.bz2": { + "build": "py37h2f8d375_5", + "build_number": 5, + "constrains": [ + "numpy 1.14.6 py37hec00662_5" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "b498e38e122a732114f2d18a2b9116b0", + "name": "numpy-base", + "sha256": "de2f666622c6c02781e7fe51dd75ae75223945ad875fd8bea07a5f266b24f398", + "size": 4284669, + "subdir": "linux-64", + "timestamp": 1569339375784, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py37h81de0dd_4.tar.bz2": { + "build": "py37h81de0dd_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py37h3b04361_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "d8fbf08c8d27c480f2de179682a517e3", + "name": "numpy-base", + "sha256": "e628236c136d0a85bfb50566f515b0de032e8db8566c7606025d365e5ad247eb", + "size": 4293425, + "subdir": "linux-64", + "timestamp": 1538074923650, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py37hde5b4d6_5.tar.bz2": { + "build": "py37hde5b4d6_5", + "build_number": 5, + "constrains": [ + "numpy 1.14.6 py37h3b04361_5" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "4485cf68797a26523bc9c0303e8919c2", + "name": "numpy-base", + "sha256": "a41283ed8c0b177144917b0d4d94ab1e5f4453d1e31d355179b9b764cb58a970", + "size": 4310794, + "subdir": "linux-64", + "timestamp": 1569339415460, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py38h2f8d375_4.tar.bz2": { + "build": "py38h2f8d375_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py38h1e1a116_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "856484ed6b0b4972d46f1bae6cd2bdd8", + "name": "numpy-base", + "sha256": "9b764acb1c8020af61972c72745aeae4e7cd58b3b91dff7bb4798aaa5f83fc7b", + "size": 4297206, + "subdir": "linux-64", + "timestamp": 1574081282166, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py38hde5b4d6_4.tar.bz2": { + "build": "py38hde5b4d6_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py38h056ac22_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "9e2df815360a64e1245c44f5a088fd77", + "name": "numpy-base", + "sha256": "ab480a5e0f22d69a6360caec3ef539e33f7d88b35e9ad5ca20c618057cdb8c76", + "size": 4371864, + "subdir": "linux-64", + "timestamp": 1574081539538, + "version": "1.14.6" + }, + "numpy-base-1.15.0-py27h1793315_0.tar.bz2": { + "build": "py27h1793315_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "33b7704910db855ab14975af8ae4207d", + "name": "numpy-base", + "sha256": "8634bc8e31fa53d2c100971a35b5e9a1debff50149a936350b1521c688676806", + "size": 4297780, + "subdir": "linux-64", + "timestamp": 1534776841547, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py27h3dfced4_0.tar.bz2": { + "build": "py27h3dfced4_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.0 py27h1b885b7_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "f95b604a5392ffe1fb0d35e2d02a3208", + "name": "numpy-base", + "sha256": "49179665e04eecfb686172e5bab5cec41aee28519d18f6cff21d07c315e7992a", + "size": 4315275, + "subdir": "linux-64", + "timestamp": 1532704137885, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py27h7cdd4dd_0.tar.bz2": { + "build": "py27h7cdd4dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.0 py27h2aefc1b_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "4670722182bee776d9e2efa7d08af5a1", + "name": "numpy-base", + "sha256": "c365e40616b8ee10445d9555fe22e4a49f8887d13ac0bd8ff083f0158d97fa45", + "size": 4266990, + "subdir": "linux-64", + "timestamp": 1532703398020, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py27hc937464_0.tar.bz2": { + "build": "py27hc937464_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "f6e9414020773f86f55a4a88a9ce33ed", + "name": "numpy-base", + "sha256": "869fcb11748f46fbb35296673fbebc55de68cf6e5389d0c8cd5b936f5e0f8c5d", + "size": 4246873, + "subdir": "linux-64", + "timestamp": 1534777018249, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py35h1793315_0.tar.bz2": { + "build": "py35h1793315_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "cdd1045e7ec7335fa57e72510dc64f2c", + "name": "numpy-base", + "sha256": "4a0585520612aab5d143e20a6f371023051a1c025038e30d70bc56324c6cbbf1", + "size": 4390206, + "subdir": "linux-64", + "timestamp": 1534776465129, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py35h3dfced4_0.tar.bz2": { + "build": "py35h3dfced4_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.0 py35h1b885b7_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "48c81f72a2de7725e2bf5d395a13bd28", + "name": "numpy-base", + "sha256": "c2f7d840af1594a366259df4e3edf9148e53086b3c6f4fa2376a7629768d9029", + "size": 4392776, + "subdir": "linux-64", + "timestamp": 1532704512767, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py35h7cdd4dd_0.tar.bz2": { + "build": "py35h7cdd4dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.0 py35h2aefc1b_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "3d4cafb5a3e3e868f28d5579389fbbce", + "name": "numpy-base", + "sha256": "efcd45767215600de6e0c8c668b6eaca098c4e060b6eaf9d5497af89e1e2bf59", + "size": 4345788, + "subdir": "linux-64", + "timestamp": 1532703650867, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py35hc937464_0.tar.bz2": { + "build": "py35hc937464_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "16118ddc15a8dc9205ae0d4be188ec41", + "name": "numpy-base", + "sha256": "14ea1d49cf70af2453858d6ea80c006f29c3dfe2bc4d11ba5f4c5bd2c87fef6b", + "size": 4328680, + "subdir": "linux-64", + "timestamp": 1534776656915, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py36h1793315_0.tar.bz2": { + "build": "py36h1793315_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "7fb4df40480939a90c17283cf989f915", + "name": "numpy-base", + "sha256": "4cf84b3efd2274eb828e6900b602e5b48b8abbaf494f4b72691bff14f7ce222f", + "size": 4375592, + "subdir": "linux-64", + "timestamp": 1534777215714, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py36h3dfced4_0.tar.bz2": { + "build": "py36h3dfced4_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.0 py36h1b885b7_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "d29e42f9aed671a39b4c5b619943db94", + "name": "numpy-base", + "sha256": "6a2995a3354f15373107981fd1ec53e5541ecaee4b3da8c71e1e70312e723155", + "size": 4370832, + "subdir": "linux-64", + "timestamp": 1532704474927, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py36h7cdd4dd_0.tar.bz2": { + "build": "py36h7cdd4dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.0 py36h2aefc1b_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "39e79eaea87e0ef47bd261aa14b7b646", + "name": "numpy-base", + "sha256": "84a832477c98eb50d4261837fea853c0d24141ac66dc6ecd3aebb3bc8882948c", + "size": 4318102, + "subdir": "linux-64", + "timestamp": 1532703420854, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py36hc937464_0.tar.bz2": { + "build": "py36hc937464_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "ac45a15faa7c23a5b9262db1648f7f9c", + "name": "numpy-base", + "sha256": "070ea856867cf037a003d80f762eb1016b58bc5536a91de5d514d0babb73e16b", + "size": 4314676, + "subdir": "linux-64", + "timestamp": 1534777399979, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py37h1793315_0.tar.bz2": { + "build": "py37h1793315_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "9c559653c00da5efd006c0f3e9e352fb", + "name": "numpy-base", + "sha256": "684ee85be50a66d4b929d750845680d39505b623e443dde297258a2d77be1daf", + "size": 4340508, + "subdir": "linux-64", + "timestamp": 1534777593309, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py37h3dfced4_0.tar.bz2": { + "build": "py37h3dfced4_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.0 py37h1b885b7_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "01dbe6784d398bd71331101ec38049f2", + "name": "numpy-base", + "sha256": "3bfa6fe66e4825e0b80152d56a7d2bf6a8805925bd78bf80c20271eb10ca689c", + "size": 4346867, + "subdir": "linux-64", + "timestamp": 1532704521722, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py37h7cdd4dd_0.tar.bz2": { + "build": "py37h7cdd4dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.0 py37h2aefc1b_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "cb8567ae923c2134ecf53539af4f19e9", + "name": "numpy-base", + "sha256": "148ed764a5b62e620d7f3decc687954a632c9cc4f0e33c2c5a48fbf08eb10a83", + "size": 4294548, + "subdir": "linux-64", + "timestamp": 1532703654610, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py37hc937464_0.tar.bz2": { + "build": "py37hc937464_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "f32ef54cd11994f7ba3b53064d0ec843", + "name": "numpy-base", + "sha256": "827651e26844181342c310fd27d93a7986ecd67a84742a43eb66311dabe8f432", + "size": 4287101, + "subdir": "linux-64", + "timestamp": 1534777772553, + "version": "1.15.0" + }, + "numpy-base-1.15.1-py27h2f8d375_0.tar.bz2": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "a92ede86aea3e9848f8ddc1da4e11b1b", + "name": "numpy-base", + "sha256": "970d1939fb4d1ff6f85f3b78b6fb2f18df3d6a51730023839d24630c7646a891", + "size": 4284883, + "subdir": "linux-64", + "timestamp": 1536895316662, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py27h74e8950_0.tar.bz2": { + "build": "py27h74e8950_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "6c3cfc7e18ee687fb225477880287f34", + "name": "numpy-base", + "sha256": "59902449e9f6ff252f40aa18ae636af84f35ced329b082afccfc1d4041048329", + "size": 4286103, + "subdir": "linux-64", + "timestamp": 1535389394251, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py27h81de0dd_0.tar.bz2": { + "build": "py27h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "0e2a680ae4067c0da712b31e4546cb28", + "name": "numpy-base", + "sha256": "3de58ab839e2a71279e4a36ca9ca13cca7a34fa8a969e1bf1253205797a24a66", + "size": 4347169, + "subdir": "linux-64", + "timestamp": 1535389805791, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py35h2f8d375_0.tar.bz2": { + "build": "py35h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1 py35h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "e7014bfd72f04a8057b39e0973326758", + "name": "numpy-base", + "sha256": "2e64a7d7715e954e10f2259cd80aabe211eb7cdd142205d4625975f722117adc", + "size": 4354551, + "subdir": "linux-64", + "timestamp": 1536895272494, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py35h74e8950_0.tar.bz2": { + "build": "py35h74e8950_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "4d395e7a19f3e8fc80c1dfe57e5b49f6", + "name": "numpy-base", + "sha256": "918cee202b881f82ac26dfba59089ccd9f030602cd5e70d7f1fcd27a68759465", + "size": 4354707, + "subdir": "linux-64", + "timestamp": 1535389366469, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py35h81de0dd_0.tar.bz2": { + "build": "py35h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "b1da54a5d78199aad87bc7efe3fe35fd", + "name": "numpy-base", + "sha256": "6353005e81573e68c9a13198f5e9a8adae3fe71ec796c8bb8c090e13be347ab2", + "size": 4408463, + "subdir": "linux-64", + "timestamp": 1535389452640, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py36h2f8d375_0.tar.bz2": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "eb5c8d7fe3ead00b7f307b9468c73b3c", + "name": "numpy-base", + "sha256": "3173d3f49dd9d37b937165cd360bc14ec6bbaeaa5767b91fc50b2a9df3a64985", + "size": 4346577, + "subdir": "linux-64", + "timestamp": 1536895322157, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py36h74e8950_0.tar.bz2": { + "build": "py36h74e8950_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "8cec363d367579eab41c37cf583d91d5", + "name": "numpy-base", + "sha256": "8d6f0b46b8989cf87c157e8cbada29e139bb7c8c1e613522460ce138e8acf476", + "size": 4346899, + "subdir": "linux-64", + "timestamp": 1535389480468, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py36h81de0dd_0.tar.bz2": { + "build": "py36h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "2e7c54d58b3953eadf8b398a8642faeb", + "name": "numpy-base", + "sha256": "3d97eaf553b416cfce5cd8907e549fe52db062dd4d598cdf07669ebe1299868a", + "size": 4409071, + "subdir": "linux-64", + "timestamp": 1535389847620, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py37h2f8d375_0.tar.bz2": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "c93a10c9c9e854f3a7f01abd7a9ebf64", + "name": "numpy-base", + "sha256": "17ffb39fb9390863c9e531c90bea5c51b28f545454343a855758c97956d634c7", + "size": 4319777, + "subdir": "linux-64", + "timestamp": 1536895325842, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py37h74e8950_0.tar.bz2": { + "build": "py37h74e8950_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "03fb82e435dc01887070b28d09b3826f", + "name": "numpy-base", + "sha256": "48c510c531d30f0d2b5e41d8acb6494536c3e443524e0b73f1d365096ae0e222", + "size": 4320681, + "subdir": "linux-64", + "timestamp": 1535389467846, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py37h81de0dd_0.tar.bz2": { + "build": "py37h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "278a10c15496bb035f8cc8568d2ae0a6", + "name": "numpy-base", + "sha256": "3a9092795386ecaf4678e2ad10ab3092d24c8279bf50f77bf59422763861c749", + "size": 4379768, + "subdir": "linux-64", + "timestamp": 1535389845725, + "version": "1.15.1" + }, + "numpy-base-1.15.2-py27h2f8d375_0.tar.bz2": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.2 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "2081773e7babdad75cbe2df37a084fe8", + "name": "numpy-base", + "sha256": "4f998f7c80266471052ad590efa2328b2c3c06affeec69d8445823b3e4d17f13", + "size": 4283618, + "subdir": "linux-64", + "timestamp": 1538073508434, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py27h2f8d375_1.tar.bz2": { + "build": "py27h2f8d375_1", + "build_number": 1, + "constrains": [ + "numpy 1.15.2 py27h99e49ec_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "fa861db86b17af7c7b0ffbcd85f1e853", + "name": "numpy-base", + "sha256": "34789ceb9ed2d02214b019ed32658288a060bcbf189cb1218d734eb057a50a4e", + "size": 4284653, + "subdir": "linux-64", + "timestamp": 1538500374510, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py27h81de0dd_0.tar.bz2": { + "build": "py27h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.2 py27h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "564d207c39ef57485f9ecc84bb19c618", + "name": "numpy-base", + "sha256": "535caca6ada4b3c90f1f169d64ecd2cb3eb49b1a2138c5a77fcd189bb5d609f8", + "size": 4360687, + "subdir": "linux-64", + "timestamp": 1538073672738, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py27h81de0dd_1.tar.bz2": { + "build": "py27h81de0dd_1", + "build_number": 1, + "constrains": [ + "numpy 1.15.2 py27h1d66e8a_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "f660bc3360d13e3c7939dc4573701447", + "name": "numpy-base", + "sha256": "dc21c92bd2ee9cc7e879e1d030c49e28d43a5c7a0321922bba956c46eade8a40", + "size": 4361184, + "subdir": "linux-64", + "timestamp": 1538500416087, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py35h2f8d375_0.tar.bz2": { + "build": "py35h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.2 py35h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "e274c832bf757ca01f8555222bd20757", + "name": "numpy-base", + "sha256": "c4153684814d3d580abae4698a3e6d20c2374aee2ca42e70d4e01c49c6ccf350", + "size": 4354870, + "subdir": "linux-64", + "timestamp": 1538073919846, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py35h81de0dd_0.tar.bz2": { + "build": "py35h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.2 py35h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "41ddf3b690d198de5175d4404284e8cc", + "name": "numpy-base", + "sha256": "ea34fe68c5872a45eca512778467299ea80c33204afcdb800804d2cfded467be", + "size": 4406722, + "subdir": "linux-64", + "timestamp": 1538073717837, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py36h2f8d375_0.tar.bz2": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.2 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "ff9a2d7c0e917deb2fabedca4a1ec238", + "name": "numpy-base", + "sha256": "55a99685442d5c9e65048fd40218cdd5cf768efd4639e840d942d46b362594f4", + "size": 4351590, + "subdir": "linux-64", + "timestamp": 1538074191298, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py36h2f8d375_1.tar.bz2": { + "build": "py36h2f8d375_1", + "build_number": 1, + "constrains": [ + "numpy 1.15.2 py36h99e49ec_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "240c3c50c0855b8e928779e72bc1bef4", + "name": "numpy-base", + "sha256": "4a3d59e50ebe1708bbc5865a9f98810c5c0107e86f7d5e4f5c736790112f222c", + "size": 4352494, + "subdir": "linux-64", + "timestamp": 1538500368412, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py36h81de0dd_0.tar.bz2": { + "build": "py36h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.2 py36h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "2be9eae4a3d70483a1b764cbc470eb60", + "name": "numpy-base", + "sha256": "e7956581e51c2df729222134bb464ca31af3e770ca6d5e879d4c387b57b7c531", + "size": 4425068, + "subdir": "linux-64", + "timestamp": 1538074301960, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py36h81de0dd_1.tar.bz2": { + "build": "py36h81de0dd_1", + "build_number": 1, + "constrains": [ + "numpy 1.15.2 py36h1d66e8a_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "3de57105449ace37bf656f3ece0cc458", + "name": "numpy-base", + "sha256": "5410d5e3061153965a36faa40e3213d4df1cba6c5ce1145ed42d1e3264749382", + "size": 4424506, + "subdir": "linux-64", + "timestamp": 1538500643328, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py37h2f8d375_0.tar.bz2": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.2 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "0b7c945ac00cee68cd3e23cca7a54eda", + "name": "numpy-base", + "sha256": "667ed524ebfab3f8c63f049d7753f9fee98d75d4980b704ea88db6b0bef80e9a", + "size": 4339722, + "subdir": "linux-64", + "timestamp": 1538073456069, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py37h2f8d375_1.tar.bz2": { + "build": "py37h2f8d375_1", + "build_number": 1, + "constrains": [ + "numpy 1.15.2 py37h99e49ec_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "d6c8991cf98ce5d7a64d6d97777bc1d1", + "name": "numpy-base", + "sha256": "faeb0c49f243ebe74642a307e030a8bf8ab820f8c403b82fad563ff1f994516e", + "size": 4340062, + "subdir": "linux-64", + "timestamp": 1538504536351, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py37h81de0dd_0.tar.bz2": { + "build": "py37h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.2 py37h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "5b94d03e93c17a0ba094917abf49f1b7", + "name": "numpy-base", + "sha256": "456613fd34989a232c492cb95535ccc04354bec7ef6e712bb55bf0509eaa7abe", + "size": 4400656, + "subdir": "linux-64", + "timestamp": 1538073633618, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py37h81de0dd_1.tar.bz2": { + "build": "py37h81de0dd_1", + "build_number": 1, + "constrains": [ + "numpy 1.15.2 py37h1d66e8a_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "8ec0ca0688efdb9c47c8c50ac0b77639", + "name": "numpy-base", + "sha256": "9b582e08e21b6c9cf783bc994d2c398c3cd125dc0fe9fd0f0815dbce5bdee70f", + "size": 4400780, + "subdir": "linux-64", + "timestamp": 1538504438223, + "version": "1.15.2" + }, + "numpy-base-1.15.3-py27h2f8d375_0.tar.bz2": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.3 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "196dc8db9c733d601158582eebfb2fc6", + "name": "numpy-base", + "sha256": "1ca63a1f4fbb6dcd5b5ac70a94b2019a5a602d46243dc4aad98ca71f0e5e8ee8", + "size": 4277553, + "subdir": "linux-64", + "timestamp": 1540314053224, + "version": "1.15.3" + }, + "numpy-base-1.15.3-py27h81de0dd_0.tar.bz2": { + "build": "py27h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.3 py27h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "5c595f9445b38214a8a2faefad74ea1a", + "name": "numpy-base", + "sha256": "c508cd068e2094c638a28eaa7f878c43a76ef1deae6109f83b04f69f16fc5eaf", + "size": 4346733, + "subdir": "linux-64", + "timestamp": 1540314300855, + "version": "1.15.3" + }, + "numpy-base-1.15.3-py36h2f8d375_0.tar.bz2": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.3 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "19a9a170bf5f44377d448b649e1a16c9", + "name": "numpy-base", + "sha256": "5dd66a6c4d4790c336696ef84287c851dfcc753d4263960944a6e11cfb553b89", + "size": 4339468, + "subdir": "linux-64", + "timestamp": 1540314071276, + "version": "1.15.3" + }, + "numpy-base-1.15.3-py36h81de0dd_0.tar.bz2": { + "build": "py36h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.3 py36h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "98c1f6ba19cf2742929bf8fc4147e886", + "name": "numpy-base", + "sha256": "41d6b9a4807423421b73afd382e1671ffe4662369327b69f1cced496f43b3732", + "size": 4400872, + "subdir": "linux-64", + "timestamp": 1540314314048, + "version": "1.15.3" + }, + "numpy-base-1.15.3-py37h2f8d375_0.tar.bz2": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.3 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "6f9c3b013fc763829d8082ea86f2a972", + "name": "numpy-base", + "sha256": "05a4006deb02cb0fc995f740fbdf6bb6faebca2ac2a57f93edfa3ab1edad5e8c", + "size": 4318575, + "subdir": "linux-64", + "timestamp": 1540314105727, + "version": "1.15.3" + }, + "numpy-base-1.15.3-py37h81de0dd_0.tar.bz2": { + "build": "py37h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.3 py37h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "499a9d6ce5fd47e9693a707618cfac8f", + "name": "numpy-base", + "sha256": "f2a6acbff3e85ba0e21520b66c3fd85f56c02fb6b7039302f891dab55c896b4a", + "size": 4373733, + "subdir": "linux-64", + "timestamp": 1540314526322, + "version": "1.15.3" + }, + "numpy-base-1.15.4-py27h2f8d375_0.tar.bz2": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.4 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "72f0c0b6f4318d836ccb8928cdfadf42", + "name": "numpy-base", + "sha256": "35c46ffbeb0e1118702bc195b3527820a8143b2871c9ef6643156974a795c72a", + "size": 4317982, + "subdir": "linux-64", + "timestamp": 1541516682142, + "version": "1.15.4" + }, + "numpy-base-1.15.4-py27h81de0dd_0.tar.bz2": { + "build": "py27h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.4 py27h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "d5a6573fe05e99054d17d1271c78841d", + "name": "numpy-base", + "sha256": "8eb1581e83cbc7ce621cacad3011d2959ccc8362002daa3b221c013bf71f69b9", + "size": 4353779, + "subdir": "linux-64", + "timestamp": 1541516991745, + "version": "1.15.4" + }, + "numpy-base-1.15.4-py27hde5b4d6_0.tar.bz2": { + "build": "py27hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.4 py27h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "9428ad5068c1869627bfd601002b5985", + "name": "numpy-base", + "sha256": "b5dc57591e6db34b220cb87a7f3ab7585bb03de978fd64f8ffe76a35bc43bebb", + "size": 4384462, + "subdir": "linux-64", + "timestamp": 1544718119335, + "version": "1.15.4" + }, + "numpy-base-1.15.4-py36h2f8d375_0.tar.bz2": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.4 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "4d11b57d6072c0baf2bb2809a94dceb0", + "name": "numpy-base", + "sha256": "c05e5647ee1b1d71ec8b8fe2cd62696460580988477d331a3f2c965c83244d4d", + "size": 4368820, + "subdir": "linux-64", + "timestamp": 1541516682376, + "version": "1.15.4" + }, + "numpy-base-1.15.4-py36h81de0dd_0.tar.bz2": { + "build": "py36h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.4 py36h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "fe2f06386e17ebfc9668753b1928b2e6", + "name": "numpy-base", + "sha256": "9d5abda5cb72fb54831db1777ca70a1c943cb0364c6af4a7dca9fdbdcb2a497f", + "size": 4437859, + "subdir": "linux-64", + "timestamp": 1541516934789, + "version": "1.15.4" + }, + "numpy-base-1.15.4-py36hde5b4d6_0.tar.bz2": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.4 py36h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "851de03b0498ccda9e00778d5f42da9c", + "name": "numpy-base", + "sha256": "81953522c1995ceaba522df6a454bf46556faf0c282754f4b4e681370c50c3f6", + "size": 4488308, + "subdir": "linux-64", + "timestamp": 1544718180181, + "version": "1.15.4" + }, + "numpy-base-1.15.4-py37h2f8d375_0.tar.bz2": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.4 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "25ae45a0340fc2fc8105dd2042a752f4", + "name": "numpy-base", + "sha256": "ee1e1c71073ba8826651722c43bf1335f492f0faf813b44e702b7cb4cefe6538", + "size": 4389601, + "subdir": "linux-64", + "timestamp": 1541516534104, + "version": "1.15.4" + }, + "numpy-base-1.15.4-py37h81de0dd_0.tar.bz2": { + "build": "py37h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.4 py37h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "e0269cfef5f8a956b43fca44bbffa890", + "name": "numpy-base", + "sha256": "2332a4ddaf1612299e0ac71b1b5d6cea02be5323fe53b24a87b404b2712df0e1", + "size": 4407402, + "subdir": "linux-64", + "timestamp": 1541516895297, + "version": "1.15.4" + }, + "numpy-base-1.15.4-py37hde5b4d6_0.tar.bz2": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.4 py37h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "2c51126639c5efb56285b17bdac62fe3", + "name": "numpy-base", + "sha256": "771503751bebc9ccf5bb02aec17445de4411f0be15bf2a3b55b0253badb98a01", + "size": 4452359, + "subdir": "linux-64", + "timestamp": 1544718267245, + "version": "1.15.4" + }, + "numpy-base-1.16.0-py27h2f8d375_0.tar.bz2": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.0 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "b05615273b61e64a6da20d20548a42ad", + "name": "numpy-base", + "sha256": "57e0a349cb0a8ecc23430bfc29652a92ee4fb155c5c206f079ac1d3abc75ab85", + "size": 4451593, + "subdir": "linux-64", + "timestamp": 1551397975783, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py27h2f8d375_1.tar.bz2": { + "build": "py27h2f8d375_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.0 py27h99e49ec_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "7350c1c592ea28649e78e6ca78b6a04c", + "name": "numpy-base", + "sha256": "ed43b37510c1bf471b002827dffab0e73148ad9978b7b3dc3c7b66ff6ebb1c9c", + "size": 4435932, + "subdir": "linux-64", + "timestamp": 1551801641952, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py27hde5b4d6_0.tar.bz2": { + "build": "py27hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.0 py27h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "36eed1666a9c813d5c57925d5926f9bf", + "name": "numpy-base", + "sha256": "002180efcb2daef1bbddf143cdc08fc257d745301c4b6d53667ee06d59656724", + "size": 4489424, + "subdir": "linux-64", + "timestamp": 1551398126159, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py27hde5b4d6_1.tar.bz2": { + "build": "py27hde5b4d6_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.0 py27h7e9f1db_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "388a9a7ebb4c6de3a330934ef7fe916b", + "name": "numpy-base", + "sha256": "507942a7df2e26144ee26fad913554a4710fc4c1101abd9738fdf7a1f34e4ba1", + "size": 4482788, + "subdir": "linux-64", + "timestamp": 1551801971662, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py36h2f8d375_0.tar.bz2": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.0 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "e0a738375663d8826e3682bcc9506741", + "name": "numpy-base", + "sha256": "10a24234288d6ce36c2ea74e754db94c48387dc49728efbb46b9879db84860d1", + "size": 4529769, + "subdir": "linux-64", + "timestamp": 1551398059317, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py36h2f8d375_1.tar.bz2": { + "build": "py36h2f8d375_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.0 py36h99e49ec_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "180bf9244a8b9ef53c4d9d5c2d1fac0e", + "name": "numpy-base", + "sha256": "e51f51b7d26eecb5adbab2c3e01c1a4a3944a46ae8317abae2851b015870d875", + "size": 4485810, + "subdir": "linux-64", + "timestamp": 1551801724471, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py36hde5b4d6_0.tar.bz2": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.0 py36h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "87c059f1a6eefca420147bb2bb75e118", + "name": "numpy-base", + "sha256": "98daefb1bda1b57a6fda738faf35383e140612a48b9c50934e7edfbdea698102", + "size": 4556118, + "subdir": "linux-64", + "timestamp": 1551398176956, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py36hde5b4d6_1.tar.bz2": { + "build": "py36hde5b4d6_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.0 py36h7e9f1db_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "a388ebd135ed53f9170c8599a0b0d188", + "name": "numpy-base", + "sha256": "5277e8a6a2fae61a3a0e1330ab5d9f532dd0287466686a09272a23e79f4e2dd7", + "size": 4552098, + "subdir": "linux-64", + "timestamp": 1551802013064, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py37h2f8d375_0.tar.bz2": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.0 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "e620ffb8902a67d315f0faba596ed2c3", + "name": "numpy-base", + "sha256": "e46bf0b2bcfc0eb7dc3fa49e1b7e8175e7192c08ae12ff2730a4cb26f6c93790", + "size": 4480153, + "subdir": "linux-64", + "timestamp": 1551398009560, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py37h2f8d375_1.tar.bz2": { + "build": "py37h2f8d375_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.0 py37h99e49ec_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "ccb1c1c11bcb5c8ab97c381f3c5e1f0e", + "name": "numpy-base", + "sha256": "d1c31487ba7fa20e16436a50f747ec92f30218f16de193c8826aebc37ad3d014", + "size": 4497486, + "subdir": "linux-64", + "timestamp": 1551801618210, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py37hde5b4d6_0.tar.bz2": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.0 py37h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "e95a40c3057a48afbdcf42aa07f2d9e9", + "name": "numpy-base", + "sha256": "b6969b5f645abfb69285bd07f011b436efb0b91bd50eb73e725a01c208c268c5", + "size": 4525583, + "subdir": "linux-64", + "timestamp": 1551398047661, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py37hde5b4d6_1.tar.bz2": { + "build": "py37hde5b4d6_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.0 py37h7e9f1db_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "abccfeab6b5398b2238d59936a76ef17", + "name": "numpy-base", + "sha256": "2b0b99367c118523772acaac69b38472954e35c1f6561608cffa545032cf3916", + "size": 4524304, + "subdir": "linux-64", + "timestamp": 1551801861338, + "version": "1.16.0" + }, + "numpy-base-1.16.1-py27h2f8d375_0.tar.bz2": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.1 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "d4a8be63159a8a4356cf17fe71b2ffe8", + "name": "numpy-base", + "sha256": "ff4b03aa78731ee37a7e5f0a8600c92f47d8e93964ce18ded2d0979206d98094", + "size": 4460639, + "subdir": "linux-64", + "timestamp": 1551457053099, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py27h2f8d375_1.tar.bz2": { + "build": "py27h2f8d375_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.1 py27h99e49ec_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "1601d1076bcd95219669bcd899511d99", + "name": "numpy-base", + "sha256": "d34c8d04d0e64defe024e8a41b9ae84647caef4db76658974d4207ea1555a37b", + "size": 4464441, + "subdir": "linux-64", + "timestamp": 1551468046336, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py27hde5b4d6_0.tar.bz2": { + "build": "py27hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.1 py27h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "a5a163227cec61636f85126ecbfd7435", + "name": "numpy-base", + "sha256": "a4ac8ade5b22a7d2b64c085e2cd90de08656f2a1046e244653ca44c55bda97db", + "size": 4512900, + "subdir": "linux-64", + "timestamp": 1551457176464, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py27hde5b4d6_1.tar.bz2": { + "build": "py27hde5b4d6_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.1 py27h7e9f1db_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "e9fbe438f2bf51836e71fdf75bbc3a00", + "name": "numpy-base", + "sha256": "203ccf151b0b7f20a2b85e584795ec8481a0779f16f3433f0cb9deabc01c9f7b", + "size": 4508862, + "subdir": "linux-64", + "timestamp": 1551468285186, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py36h2f8d375_0.tar.bz2": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.1 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "b9bbf621ea7577f873ec877621ce7122", + "name": "numpy-base", + "sha256": "554df3ea16fac4b94c6afeca5b715193b74ad9bb7452f6f07ebdea6d569f87de", + "size": 4500925, + "subdir": "linux-64", + "timestamp": 1551457084791, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py36h2f8d375_1.tar.bz2": { + "build": "py36h2f8d375_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.1 py36h99e49ec_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "95552ca3d9706445e2b66a44dfd8df78", + "name": "numpy-base", + "sha256": "7efa78398302e423248a6d2913bddfbb2831604cf29da632c5820635251480fe", + "size": 4549113, + "subdir": "linux-64", + "timestamp": 1551468082286, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py36hde5b4d6_0.tar.bz2": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.1 py36h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "edb0c251fc659b4f06e3fb9243eb54f8", + "name": "numpy-base", + "sha256": "3f620cc2a35b190d9c29176539116606f128f80f6914ef4e58b25dca6cec2ed1", + "size": 4552807, + "subdir": "linux-64", + "timestamp": 1551457118643, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py36hde5b4d6_1.tar.bz2": { + "build": "py36hde5b4d6_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.1 py36h7e9f1db_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "5c710e1b03d61c7c0af9c3b8d16ff4cd", + "name": "numpy-base", + "sha256": "aacd1a71d234615fb2c978b11e15aad600c0b06eb4ac0289c6ed1ca3e7b1e85e", + "size": 4562102, + "subdir": "linux-64", + "timestamp": 1551468235995, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py37h2f8d375_0.tar.bz2": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.1 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "8ce7900d22b22b6f484fe037094dca5b", + "name": "numpy-base", + "sha256": "302c79ea35508600d959b3fac85def1178bfb5625a2ab10d1e5c90cd53b57444", + "size": 4479102, + "subdir": "linux-64", + "timestamp": 1551457012875, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py37h2f8d375_1.tar.bz2": { + "build": "py37h2f8d375_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.1 py37h99e49ec_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "b45ba011cf64f547dea8063b4a4da915", + "name": "numpy-base", + "sha256": "b48b6525e151c72ee6c436b8baa84da0842a4b2061c4d9f650b39d5f1133104a", + "size": 4486090, + "subdir": "linux-64", + "timestamp": 1551468076103, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py37hde5b4d6_0.tar.bz2": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.1 py37h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "910d58c3b58329d91242c8b4b342a235", + "name": "numpy-base", + "sha256": "04026082d67f37be80285db1d9191b550de0f1ee98df4e9724e03fb0644f592d", + "size": 4550122, + "subdir": "linux-64", + "timestamp": 1551457146799, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py37hde5b4d6_1.tar.bz2": { + "build": "py37hde5b4d6_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.1 py37h7e9f1db_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "19ffe9f721a5f040f755abbf04d9b3af", + "name": "numpy-base", + "sha256": "9f3d94796d113029e0ebd5d2f2a476b192cb9b5fbcb79809b551c35c9245fa3a", + "size": 4540992, + "subdir": "linux-64", + "timestamp": 1551468127269, + "version": "1.16.1" + }, + "numpy-base-1.16.2-py27h2f8d375_0.tar.bz2": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.2 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "c55309ed7af6ebe7bcc995b52040371c", + "name": "numpy-base", + "sha256": "70b7ccc3ae8f129db46cff8ddfd5309424a8508c577f1c5d52f5d6288ad1fa40", + "size": 4452726, + "subdir": "linux-64", + "timestamp": 1551471213027, + "version": "1.16.2" + }, + "numpy-base-1.16.2-py27hde5b4d6_0.tar.bz2": { + "build": "py27hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.2 py27h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "e5f6d3a40c97d6fc39acdfcbfcbd5444", + "name": "numpy-base", + "sha256": "3c9c42abcc422048e5ad421ab5426a3d5b98c7835e93adb6168d9f5e30b74103", + "size": 4526176, + "subdir": "linux-64", + "timestamp": 1551471383092, + "version": "1.16.2" + }, + "numpy-base-1.16.2-py36h2f8d375_0.tar.bz2": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.2 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "aecb080046a937f573079c7f60560af2", + "name": "numpy-base", + "sha256": "16ec93751147e8c9d4788437a643a3bbc0776cb257c24b7fcf6f6b6d9d7442ac", + "size": 4565165, + "subdir": "linux-64", + "timestamp": 1551471206893, + "version": "1.16.2" + }, + "numpy-base-1.16.2-py36hde5b4d6_0.tar.bz2": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.2 py36h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "137c897e839d93f2449ae652e6ee23c9", + "name": "numpy-base", + "sha256": "df1b939ffdfcb2be6784f5ccf53568230e71635785f681080240ce1b38dcfcde", + "size": 4613743, + "subdir": "linux-64", + "timestamp": 1551471480217, + "version": "1.16.2" + }, + "numpy-base-1.16.2-py37h2f8d375_0.tar.bz2": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.2 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "ba200e28fb9cb30ffc0d6a272cae2375", + "name": "numpy-base", + "sha256": "eb31752dc62061d1c37869dd6c3e7b5e811f2591baf83b0d22d0bca405c952f1", + "size": 4534773, + "subdir": "linux-64", + "timestamp": 1551471189642, + "version": "1.16.2" + }, + "numpy-base-1.16.2-py37hde5b4d6_0.tar.bz2": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.2 py37h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "855ed8b00ce996762175c5540c7cc254", + "name": "numpy-base", + "sha256": "f9feadbc7b157c0a881367e123caa26eac71f778c9d525caff6722be310c0bc4", + "size": 4552857, + "subdir": "linux-64", + "timestamp": 1551471345326, + "version": "1.16.2" + }, + "numpy-base-1.16.3-py27h2f8d375_0.tar.bz2": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.3 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "40a08b9b3ceb1118b9955215f3d24d21", + "name": "numpy-base", + "sha256": "3612e0f0d8ba842a0892590879eb7df1dc598d90a02ca46cee912ffffa5a3675", + "size": 4460661, + "subdir": "linux-64", + "timestamp": 1555949411522, + "version": "1.16.3" + }, + "numpy-base-1.16.3-py27hde5b4d6_0.tar.bz2": { + "build": "py27hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.3 py27h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "39247c2d31ba37ba3edff66aa7585705", + "name": "numpy-base", + "sha256": "4e55806ec443bbd51166ecb70b53f4365908482d90bf2e80b71e9baf38e730c3", + "size": 4531659, + "subdir": "linux-64", + "timestamp": 1555949690025, + "version": "1.16.3" + }, + "numpy-base-1.16.3-py36h2f8d375_0.tar.bz2": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.3 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "796c039263609919213fcdd370171c31", + "name": "numpy-base", + "sha256": "7d407ba8430b40f63c4bd990e58fc6941ae9c293be0fca4e4e544ce029099a94", + "size": 4552813, + "subdir": "linux-64", + "timestamp": 1555949536687, + "version": "1.16.3" + }, + "numpy-base-1.16.3-py36hde5b4d6_0.tar.bz2": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.3 py36h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "434418faaae4b838972a569ac05149dd", + "name": "numpy-base", + "sha256": "864aa60c26a73d2b9ec2faae949726df3f8ffa4c4e8cd1cbdee1d3e9668a8ff7", + "size": 4587348, + "subdir": "linux-64", + "timestamp": 1555949712025, + "version": "1.16.3" + }, + "numpy-base-1.16.3-py37h2f8d375_0.tar.bz2": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.3 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "50994380eeff192209b64a5ea3182364", + "name": "numpy-base", + "sha256": "497f5c37147ece9100d3b1ef6e0d208005cabad036ca88e29e4bc111eb1e29b7", + "size": 4521375, + "subdir": "linux-64", + "timestamp": 1555949433549, + "version": "1.16.3" + }, + "numpy-base-1.16.3-py37hde5b4d6_0.tar.bz2": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.3 py37h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "f6d0cc1bd2c3f31a81c1e098bd702c2b", + "name": "numpy-base", + "sha256": "bc12b48a87fe14cf644f0b5f03f2f2a53e35883ceca11ace6905cf2cbf9831df", + "size": 4560177, + "subdir": "linux-64", + "timestamp": 1555949572836, + "version": "1.16.3" + }, + "numpy-base-1.16.4-py27h2f8d375_0.tar.bz2": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.4 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "cd1d13d15396f084ce9e8231aad625d5", + "name": "numpy-base", + "sha256": "c02a30a5642d0156ed0f5c9669b4178982bc5a0fb811c13b2bdf891dc09c9ab9", + "size": 4500674, + "subdir": "linux-64", + "timestamp": 1559140281552, + "version": "1.16.4" + }, + "numpy-base-1.16.4-py27hde5b4d6_0.tar.bz2": { + "build": "py27hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.4 py27h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "d98fb225147b47d055123436d0e043bf", + "name": "numpy-base", + "sha256": "1c6674478a66080f18189e7ed41444127db50548d4ad2c19d8e20b088e9cc708", + "size": 4543753, + "subdir": "linux-64", + "timestamp": 1559140633668, + "version": "1.16.4" + }, + "numpy-base-1.16.4-py36h2f8d375_0.tar.bz2": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.4 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "7f417cd5438e64edd4c12c4ad613a4de", + "name": "numpy-base", + "sha256": "7820b4d6a0c6f2f9748f187577753f372e4ec645f1d06cb0f83ad8826888b0e7", + "size": 4532937, + "subdir": "linux-64", + "timestamp": 1559140288680, + "version": "1.16.4" + }, + "numpy-base-1.16.4-py36hde5b4d6_0.tar.bz2": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.4 py36h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "6bbf1655b056c9fc45a4dab36c129d37", + "name": "numpy-base", + "sha256": "3267cc109aaa9e1000fc856b654dae8de816c9445be33a7824253720de7bfae8", + "size": 4586208, + "subdir": "linux-64", + "timestamp": 1559141027012, + "version": "1.16.4" + }, + "numpy-base-1.16.4-py37h2f8d375_0.tar.bz2": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.4 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "a2ba4a488924a5acd75441386be66a5a", + "name": "numpy-base", + "sha256": "be9dde6c8086f2523ad200967a4d52523433c4d8012e1ffda596c364d708d083", + "size": 4519991, + "subdir": "linux-64", + "timestamp": 1559140350416, + "version": "1.16.4" + }, + "numpy-base-1.16.4-py37hde5b4d6_0.tar.bz2": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.4 py37h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "68063761820b9c0c8a1c68cb20c90b8d", + "name": "numpy-base", + "sha256": "4cf542724aba2c7c5fbc087752fc68a69a4d849a49d035d6a405455f328a0827", + "size": 4572797, + "subdir": "linux-64", + "timestamp": 1559140438644, + "version": "1.16.4" + }, + "numpy-base-1.16.5-py27h2f8d375_0.tar.bz2": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.5 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "44154769330c7638e9f4ea39fd0b1d04", + "name": "numpy-base", + "sha256": "57c840621f40667cf2c2f62187117817e5cafd9d36f01d494a71108546f651f5", + "size": 4485632, + "subdir": "linux-64", + "timestamp": 1568311456201, + "version": "1.16.5" + }, + "numpy-base-1.16.5-py27hde5b4d6_0.tar.bz2": { + "build": "py27hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.5 py27h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "1e964aaace7c529648d895858b7b1d72", + "name": "numpy-base", + "sha256": "b6dbdcfcedf79ed16c92d4413771f0b7ba1f38bc43ed3ef74278738deffea5a4", + "size": 4535458, + "subdir": "linux-64", + "timestamp": 1568311576635, + "version": "1.16.5" + }, + "numpy-base-1.16.5-py36h2f8d375_0.tar.bz2": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.5 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "c63e57aed24f4ae501f45d1332946004", + "name": "numpy-base", + "sha256": "b5e154f89656aea61b719def7ca29f9288678be17f076d1ab150c004f11fb52c", + "size": 4547112, + "subdir": "linux-64", + "timestamp": 1568311435624, + "version": "1.16.5" + }, + "numpy-base-1.16.5-py36hde5b4d6_0.tar.bz2": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.5 py36h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "a741437c7b810be5dda0a240fc14e8de", + "name": "numpy-base", + "sha256": "5e3bd806d10bc456cea4dbbf974ef15066c397c4212efda9f5f0580381cf7082", + "size": 4592523, + "subdir": "linux-64", + "timestamp": 1568311772568, + "version": "1.16.5" + }, + "numpy-base-1.16.5-py37h2f8d375_0.tar.bz2": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.5 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "0dc08f5b396df163f37708579eb025d5", + "name": "numpy-base", + "sha256": "f5ef595e850135079fc5388cea90a97f0cd0b7f0bb210818c191d21c7df2f3f5", + "size": 4557030, + "subdir": "linux-64", + "timestamp": 1568311550017, + "version": "1.16.5" + }, + "numpy-base-1.16.5-py37hde5b4d6_0.tar.bz2": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.5 py37h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "f19048326e4e89f11aacc08ff54e5465", + "name": "numpy-base", + "sha256": "0128d2d88150589df1f91724acc34fa7aade316cb683afbc6cc60dd5834fe715", + "size": 4591452, + "subdir": "linux-64", + "timestamp": 1568311765698, + "version": "1.16.5" + }, + "numpy-base-1.16.6-py27h2f8d375_0.tar.bz2": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.6 py27h30dfecb_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "5ff907db68992623679bb18eb54240f8", + "name": "numpy-base", + "sha256": "ec30f4a0f6f447fde5f2a38cca4dd00648fa73f31ecfe8766723f945d5001616", + "size": 4489865, + "subdir": "linux-64", + "timestamp": 1580501485894, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py27hde5b4d6_0.tar.bz2": { + "build": "py27hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.6 py27hbc911f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "f8f7e7aa85b5043f8fc2b40b89b70df6", + "name": "numpy-base", + "sha256": "85876eef588d87578738cad9f5fdbe8aea80689cbf4eeb4e7901caa50f4e561f", + "size": 4548579, + "subdir": "linux-64", + "timestamp": 1580501534491, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py36h2f8d375_0.tar.bz2": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.6 py36h30dfecb_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "f644b467550a1a9e4e776d877c764502", + "name": "numpy-base", + "sha256": "434a18f4e608c5caccd2fe7bffce18e61d06244ed3702dae901675c9449bfd3a", + "size": 4564875, + "subdir": "linux-64", + "timestamp": 1580488168216, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py36h41b4c56_3.tar.bz2": { + "build": "py36h41b4c56_3", + "build_number": 3, + "constrains": [ + "numpy 1.16.6 py36h0a8e133_3" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "1ed6859ca371ae7323eb3e30382169cd", + "name": "numpy-base", + "sha256": "19c8149cd9dfed882c8fe5d7eb0521b2973c4abc0e4e705d19c7795ddeb3dd37", + "size": 4575149, + "subdir": "linux-64", + "timestamp": 1618845005545, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py36hdc34a94_3.tar.bz2": { + "build": "py36hdc34a94_3", + "build_number": 3, + "constrains": [ + "numpy 1.16.6 py36h2d18471_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "7a56024fd26e4fcc8e3918cf1f0851b2", + "name": "numpy-base", + "sha256": "89db63a0490a768eb9969edaf0cd8970816e55c7715f7dd1efab1d79d4374a4b", + "size": 4603476, + "subdir": "linux-64", + "timestamp": 1618845083423, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py36hde5b4d6_0.tar.bz2": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.6 py36hbc911f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "80ce1069ce88d9d1ad0a36e01ff42c57", + "name": "numpy-base", + "sha256": "64991e82c91abd422a3b13bde5810e68b6109500d281c945db35acd343e8912a", + "size": 4622975, + "subdir": "linux-64", + "timestamp": 1580488296932, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py37h2f8d375_0.tar.bz2": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.6 py37h30dfecb_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "80d00f6811520a3cee1558cb1d885be0", + "name": "numpy-base", + "sha256": "9a87107251d4954bab80b9d764e8853a20396bc7ee3a40d2339d54004ce539df", + "size": 4552996, + "subdir": "linux-64", + "timestamp": 1580488160332, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py37h41b4c56_3.tar.bz2": { + "build": "py37h41b4c56_3", + "build_number": 3, + "constrains": [ + "numpy 1.16.6 py37h0a8e133_3" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "1d3d1103bf7af538eedf47d750e279a2", + "name": "numpy-base", + "sha256": "6a0d11eca583ddaed6c008a0c1e1875ffdbcc91e364bdf5173cbf9aa843b69f9", + "size": 4533881, + "subdir": "linux-64", + "timestamp": 1618844438290, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py37h73d599e_4.tar.bz2": { + "build": "py37h73d599e_4", + "build_number": 4, + "constrains": [ + "numpy 1.16.6 py37h7895c89_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "2510b027430f36ff58468eb90bbf1da4", + "name": "numpy-base", + "sha256": "3aa28ab704d9c43add619d1255f8e40e36578235ba94b5aa657193594ee7a7c5", + "size": 4658989, + "subdir": "linux-64", + "timestamp": 1654863824285, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py37ha8aedfd_4.tar.bz2": { + "build": "py37ha8aedfd_4", + "build_number": 4, + "constrains": [ + "numpy 1.16.6 py37h0708ffd_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "b64a045db6c8c3cc1e4440075d6a67fe", + "name": "numpy-base", + "sha256": "5d88f01ead87ace276fdb9dd90f294758502498bfe53b7af30c4f0840050d402", + "size": 4607649, + "subdir": "linux-64", + "timestamp": 1654863139695, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py37hdc34a94_3.tar.bz2": { + "build": "py37hdc34a94_3", + "build_number": 3, + "constrains": [ + "numpy 1.16.6 py37h2d18471_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "7232e04ccddde9d3f1e448890c7ba688", + "name": "numpy-base", + "sha256": "a9f3efb2c55fff892d605788af775e0f200c0c69f3ac7d7295e75427a5bf024a", + "size": 4600140, + "subdir": "linux-64", + "timestamp": 1618845091469, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py37hde5b4d6_0.tar.bz2": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.6 py37hbc911f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "650e18ddc4970b1bb46b545a413c3f2d", + "name": "numpy-base", + "sha256": "331afc332a961c181c9b2946633f051e84a38b06414dbb544d1ff8734b1af3de", + "size": 4610510, + "subdir": "linux-64", + "timestamp": 1580488260871, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py38h2f8d375_0.tar.bz2": { + "build": "py38h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.6 py38h30dfecb_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "27db0b9b5eed830c4defc4b68b927695", + "name": "numpy-base", + "sha256": "e04e0417d2eec041d56398b800643583d6c22d16bf0eda3a73c74c652e377edf", + "size": 4587486, + "subdir": "linux-64", + "timestamp": 1580495265343, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py38h41b4c56_3.tar.bz2": { + "build": "py38h41b4c56_3", + "build_number": 3, + "constrains": [ + "numpy 1.16.6 py38h0a8e133_3" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "aa8cbdcbe7082671892f7a539c26e8bf", + "name": "numpy-base", + "sha256": "08289d7fd79bd0738d5133676bba969a454a98f5be49a6b87f8091423bad8475", + "size": 4563676, + "subdir": "linux-64", + "timestamp": 1618841681824, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py38h73d599e_4.tar.bz2": { + "build": "py38h73d599e_4", + "build_number": 4, + "constrains": [ + "numpy 1.16.6 py38h7895c89_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "1a25ae5ee3a6a4a31f4b45ae5712efeb", + "name": "numpy-base", + "sha256": "4684f19f33889b37fec0e5ca24217b763683ae8577a3c9ffc443aecb5a910920", + "size": 4691333, + "subdir": "linux-64", + "timestamp": 1654864457128, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py38ha8aedfd_4.tar.bz2": { + "build": "py38ha8aedfd_4", + "build_number": 4, + "constrains": [ + "numpy 1.16.6 py38h0708ffd_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "ce25ad2d9b21ae3b5aa33d3d5ebef24a", + "name": "numpy-base", + "sha256": "beb664e8167a545572bc19e65cc5d9650de84ca5fee6f652b40f45e373e540e2", + "size": 4638257, + "subdir": "linux-64", + "timestamp": 1654863576126, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py38hdc34a94_3.tar.bz2": { + "build": "py38hdc34a94_3", + "build_number": 3, + "constrains": [ + "numpy 1.16.6 py38h2d18471_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "eb85484df8ae762fa1ff82192b923aae", + "name": "numpy-base", + "sha256": "213a5eb95c9e1f5816cb2d7dcf36d46ec8e04f9fab7d9f66bbcb09d7ededaae3", + "size": 4614199, + "subdir": "linux-64", + "timestamp": 1618845083204, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py38hde5b4d6_0.tar.bz2": { + "build": "py38hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.6 py38hbc911f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "0ebb6fba369a5be06e4cf5886004a8e9", + "name": "numpy-base", + "sha256": "27fa52d546df38e0f91ba328fedd32e077d7dc4b937ec03336e8c2e10df2fd03", + "size": 4658030, + "subdir": "linux-64", + "timestamp": 1580495253140, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py39h41b4c56_3.tar.bz2": { + "build": "py39h41b4c56_3", + "build_number": 3, + "constrains": [ + "numpy 1.16.6 py39h0a8e133_3" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "md5": "d0de3220e81180fce6e11df589c6e8a9", + "name": "numpy-base", + "sha256": "d8bea8d6bec50f7171917f93ee7fee601f270e0770b7608ec2db19994243fb0a", + "size": 4575193, + "subdir": "linux-64", + "timestamp": 1618841679997, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py39h73d599e_4.tar.bz2": { + "build": "py39h73d599e_4", + "build_number": 4, + "constrains": [ + "numpy 1.16.6 py39h7895c89_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "md5": "403e631b09b7e90a368f13b7916a61e0", + "name": "numpy-base", + "sha256": "2ffad54af649d8020397503675902f28247e942b6ea7387e068197d4ed8abdca", + "size": 4696614, + "subdir": "linux-64", + "timestamp": 1654864143849, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py39h76555f2_1.tar.bz2": { + "build": "py39h76555f2_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.6 py39h89c1606_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "md5": "488355ae95247f3ba6d821d7e321b796", + "name": "numpy-base", + "sha256": "02ab24f6ee804eb545c1c8d2c30a48d6c9858f643bc4d9e04c63abccba3220c2", + "size": 4640743, + "subdir": "linux-64", + "timestamp": 1607432304179, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py39ha8aedfd_4.tar.bz2": { + "build": "py39ha8aedfd_4", + "build_number": 4, + "constrains": [ + "numpy 1.16.6 py39h0708ffd_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "md5": "50663a2138a67f6796e6aea7a7207811", + "name": "numpy-base", + "sha256": "c1a2e83ca3256ea61cf77a6d801768100d4e98b0b96d9e7cd3325637dd658d0a", + "size": 4627162, + "subdir": "linux-64", + "timestamp": 1654863357983, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py39hdc34a94_3.tar.bz2": { + "build": "py39hdc34a94_3", + "build_number": 3, + "constrains": [ + "numpy 1.16.6 py39h2d18471_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "md5": "1d5817728386014c362a086dd1e5a643", + "name": "numpy-base", + "sha256": "48f254c2aa8bce334a1c80945e5aebcf7c113470edc6d59639affa28e245c65f", + "size": 4625068, + "subdir": "linux-64", + "timestamp": 1618845079125, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py39hfb011de_1.tar.bz2": { + "build": "py39hfb011de_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.6 py39hdd937aa_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "md5": "040d1414da958db2eda02879aa6d0c68", + "name": "numpy-base", + "sha256": "cb4e988e27458aa9b9c2617b66ef0b908d94e8d9ddb53521dc0256c1fd6b39ad", + "size": 4560187, + "subdir": "linux-64", + "timestamp": 1607432240355, + "version": "1.16.6" + }, + "numpy-base-1.17.2-py36h2f8d375_0.tar.bz2": { + "build": "py36h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "831e4df096a1c97be0e806c3c34803f2", + "name": "numpy-base", + "sha256": "e293a252e5af1c0c41e889c31366c9aa90fb87a2b45a9788c04bafd0413ba173", + "size": 5543260, + "subdir": "linux-64", + "timestamp": 1569435344110, + "version": "1.17.2" + }, + "numpy-base-1.17.2-py36hde5b4d6_0.tar.bz2": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "33a7951f9d46482382326585cb8cbb2e", + "name": "numpy-base", + "sha256": "9ca754e663620a08fceeeba99fb66f18627c046d7ef6f8d8a4e7207152d222bd", + "size": 5577217, + "subdir": "linux-64", + "timestamp": 1569435627808, + "version": "1.17.2" + }, + "numpy-base-1.17.2-py37h2f8d375_0.tar.bz2": { + "build": "py37h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9aeff827636a29216a6a8f4634a39a11", + "name": "numpy-base", + "sha256": "2673398b2412d3d6de472e713eb812654d023dff3daccb0690e10f38dc8681c9", + "size": 5499403, + "subdir": "linux-64", + "timestamp": 1569435383275, + "version": "1.17.2" + }, + "numpy-base-1.17.2-py37hde5b4d6_0.tar.bz2": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0d03ed32ff059dc13ebfde1bc2597223", + "name": "numpy-base", + "sha256": "18a1138ccedd783df5271fa695a1f97da4a8266c10b8d6040c0680e67cb1146d", + "size": 5599576, + "subdir": "linux-64", + "timestamp": 1569435627128, + "version": "1.17.2" + }, + "numpy-base-1.17.3-py36h2f8d375_0.tar.bz2": { + "build": "py36h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c44a2ac9189605932e59cfcfe194d5ac", + "name": "numpy-base", + "sha256": "db76d9fe4ca2ed3d5549c6677eb78aacebd9e1808a0e5f9579f00e8dc0f0446c", + "size": 5426266, + "subdir": "linux-64", + "timestamp": 1573063145971, + "version": "1.17.3" + }, + "numpy-base-1.17.3-py36hde5b4d6_0.tar.bz2": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "77b1551a2615f5f52e5d4808a1d93919", + "name": "numpy-base", + "sha256": "6ec63fdb7689491331ff3b54662af15095ba28a6bbcf31670dcb7e5d32484979", + "size": 5523428, + "subdir": "linux-64", + "timestamp": 1573063141627, + "version": "1.17.3" + }, + "numpy-base-1.17.3-py37h2f8d375_0.tar.bz2": { + "build": "py37h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5afd9dcdf107d6719ae398cedc44e5ce", + "name": "numpy-base", + "sha256": "2924e70ccb409a713ebc849fbb392b59ff51e5431cd93c97f60a35f23a42916a", + "size": 5433299, + "subdir": "linux-64", + "timestamp": 1573063215039, + "version": "1.17.3" + }, + "numpy-base-1.17.3-py37hde5b4d6_0.tar.bz2": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "10110619f409b777e8c303dd666b278e", + "name": "numpy-base", + "sha256": "ea306e0f3ece77c2dba4fa8cb0b3f3000e3c9aa9ad75159d819ad057278fe538", + "size": 5470921, + "subdir": "linux-64", + "timestamp": 1573063281034, + "version": "1.17.3" + }, + "numpy-base-1.17.3-py38h2f8d375_0.tar.bz2": { + "build": "py38h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fad9cf9dd0dc086d7d5f3a85c08cea04", + "name": "numpy-base", + "sha256": "8997c13d7294a7aef254a093980e00b3edbf63f3352ff33af4040e7eeb359303", + "size": 5491677, + "subdir": "linux-64", + "timestamp": 1573063156983, + "version": "1.17.3" + }, + "numpy-base-1.17.3-py38hde5b4d6_0.tar.bz2": { + "build": "py38hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "758df7b501632e220298ed5bd124ae83", + "name": "numpy-base", + "sha256": "01bf2e2ce1981432c2e8eff496e46bea4102ebb2b5e9b4f89711b1a350416fd5", + "size": 5548705, + "subdir": "linux-64", + "timestamp": 1573121176802, + "version": "1.17.3" + }, + "numpy-base-1.17.4-py36h2f8d375_0.tar.bz2": { + "build": "py36h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a3d64dacad0a304981f4c0a74d0a2d6c", + "name": "numpy-base", + "sha256": "e63688363205711f371151ce64183bd4bd1f1d3d5cb490afc8dcfbd9f58b1435", + "size": 5452120, + "subdir": "linux-64", + "timestamp": 1574868330469, + "version": "1.17.4" + }, + "numpy-base-1.17.4-py36hde5b4d6_0.tar.bz2": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2a9cbbd79b502eb19a4de9d9cd09daa4", + "name": "numpy-base", + "sha256": "17b463cf908076d84a938e4a23f21680045c972c469b6fec48eeb1e8c0999bf5", + "size": 5508005, + "subdir": "linux-64", + "timestamp": 1574868415139, + "version": "1.17.4" + }, + "numpy-base-1.17.4-py37h2f8d375_0.tar.bz2": { + "build": "py37h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "30150f1589bb3b8f75682db52ff4b7be", + "name": "numpy-base", + "sha256": "95f3fcc294336cd8e129a5c0cdeb200e920a9c386a7f63c333c2dfb6e6e238d7", + "size": 5459865, + "subdir": "linux-64", + "timestamp": 1574868347172, + "version": "1.17.4" + }, + "numpy-base-1.17.4-py37hde5b4d6_0.tar.bz2": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ceab9da310cb57ef9bf1cb7f45306017", + "name": "numpy-base", + "sha256": "0e91f4c64a6773cd1f25ed62c6e3b1c8e9aee9373096ef87d8ebe5b1e98711ce", + "size": 5482082, + "subdir": "linux-64", + "timestamp": 1574868401546, + "version": "1.17.4" + }, + "numpy-base-1.17.4-py38h2f8d375_0.tar.bz2": { + "build": "py38h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7f220a0a6ce86547a01a103d10962fa5", + "name": "numpy-base", + "sha256": "6a35c0c6df6ee7bf7bdff67c2e1850e10b90359097c1ec6bd31442fa41a773c3", + "size": 5502688, + "subdir": "linux-64", + "timestamp": 1574868323390, + "version": "1.17.4" + }, + "numpy-base-1.17.4-py38hde5b4d6_0.tar.bz2": { + "build": "py38hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "41c883ba179c1e9f66f90095b9d69c96", + "name": "numpy-base", + "sha256": "f0710d4d20a014e3e7ed3d7fb333310ec02e9fee34ec50f89cdfce9044c46497", + "size": 5533783, + "subdir": "linux-64", + "timestamp": 1574868388914, + "version": "1.17.4" + }, + "numpy-base-1.18.1-py36h2f8d375_0.tar.bz2": { + "build": "py36h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8be790c71f425cf41fb77e98f2937397", + "name": "numpy-base", + "sha256": "0d95aa2eee274c0eaddb99e3b0c022f8f6db39bf02bbab17fded15f3a312f0c2", + "size": 5500788, + "subdir": "linux-64", + "timestamp": 1579191406483, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py36h2f8d375_1.tar.bz2": { + "build": "py36h2f8d375_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "39a2b00cba194159660c2e412f90aca7", + "name": "numpy-base", + "sha256": "fcf750b21cf7a0fe706dd0b45c5c9db5eda529caf4d9dfd16ab25e533710a1a9", + "size": 5491469, + "subdir": "linux-64", + "timestamp": 1579712644823, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py36hde5b4d6_0.tar.bz2": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "854b78d1f5d245ee10ba5432359606e5", + "name": "numpy-base", + "sha256": "8c86fa374812b74625a44a4e2d3dbe7001595ea1b67340b3461ba4f70db69e3b", + "size": 5489362, + "subdir": "linux-64", + "timestamp": 1579191431300, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py36hde5b4d6_1.tar.bz2": { + "build": "py36hde5b4d6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a6c1ec98e14165a39559df4b18b8aadf", + "name": "numpy-base", + "sha256": "6608d98e2362143189f5d930d5af096348ca85e33bc88fa4976c6889ee2af02c", + "size": 5485786, + "subdir": "linux-64", + "timestamp": 1579712562571, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py37h2f8d375_0.tar.bz2": { + "build": "py37h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "101af936bc8ad959220782bf32ab828e", + "name": "numpy-base", + "sha256": "3e1fc920f516bdfd316e5a3a222b6892726e8e4b39a11d6fd41532bc883fa628", + "size": 5460284, + "subdir": "linux-64", + "timestamp": 1579191511039, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py37h2f8d375_1.tar.bz2": { + "build": "py37h2f8d375_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cd21e98cb4e34a87e1bf2d1e15ea906c", + "name": "numpy-base", + "sha256": "0cf5591c64d9b9ad30154b2a87074f5ccf60ef27b950c4066cd19203950ddc3c", + "size": 5466335, + "subdir": "linux-64", + "timestamp": 1579712542748, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py37hde5b4d6_0.tar.bz2": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9c9197f175efa7a7e5a3db1871286ac6", + "name": "numpy-base", + "sha256": "44c2452e8be76fc5aaae69181ca0979ae622bb70b0e44323467710c7cfed620c", + "size": 5467785, + "subdir": "linux-64", + "timestamp": 1579191527561, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py37hde5b4d6_1.tar.bz2": { + "build": "py37hde5b4d6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "628d06b07c3604e06f841ed5189fcc1e", + "name": "numpy-base", + "sha256": "eb4a44fe072dec1d9a290ac76862505fa42efde190676c786d92b595d714855e", + "size": 5461468, + "subdir": "linux-64", + "timestamp": 1579712522394, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py38h2f8d375_0.tar.bz2": { + "build": "py38h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "97ed099fe09a3e071ccdcf567d9fe4f9", + "name": "numpy-base", + "sha256": "6dece9343d444d734550e3b856fa0120cb57bd231f0f9f3122a6f96e7d832bfc", + "size": 5542471, + "subdir": "linux-64", + "timestamp": 1579191524637, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py38h2f8d375_1.tar.bz2": { + "build": "py38h2f8d375_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "67d53df465f2189f2928cc9e8ef514f7", + "name": "numpy-base", + "sha256": "f81f301947d8cbd6f0affc54f668b0957a268e5fbccf57382693cc0f551ef5e1", + "size": 5542539, + "subdir": "linux-64", + "timestamp": 1579712574818, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py38hde5b4d6_0.tar.bz2": { + "build": "py38hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a189f260437a65f74bfaefe2a75227e3", + "name": "numpy-base", + "sha256": "5d441a609e64ac55544da511f15ee90579233826ddfc20876787e1fce1393d0f", + "size": 5520305, + "subdir": "linux-64", + "timestamp": 1579191444410, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py38hde5b4d6_1.tar.bz2": { + "build": "py38hde5b4d6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8acc674314ab05be99241a8f9755fb51", + "name": "numpy-base", + "sha256": "b66b3ac9d2e483cb0eb252ca82370407cde1d20c1fb04a0e55eadf70cec62a3e", + "size": 5544899, + "subdir": "linux-64", + "timestamp": 1579712584895, + "version": "1.18.1" + }, + "numpy-base-1.18.5-py36h2f8d375_0.tar.bz2": { + "build": "py36h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5e9cbd7500fd9aa555b29d39db03d4ff", + "name": "numpy-base", + "sha256": "24306b59de7051eb89beeb906c3e5d9fdc59fba93f14cd21d314d2ee28f64adc", + "size": 5381787, + "subdir": "linux-64", + "timestamp": 1592509309336, + "version": "1.18.5" + }, + "numpy-base-1.18.5-py36hde5b4d6_0.tar.bz2": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "56db8f9e2b50aded6cb31dc741cbc774", + "name": "numpy-base", + "sha256": "e052745d7710b460a2c37c2be61f1905789f137e90de234f2af4c5284632cb42", + "size": 5379905, + "subdir": "linux-64", + "timestamp": 1592509293298, + "version": "1.18.5" + }, + "numpy-base-1.18.5-py37h2f8d375_0.tar.bz2": { + "build": "py37h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3def0e376cd2fd455c0e74af5265172d", + "name": "numpy-base", + "sha256": "87da1f0e030217cfe60f3e4080c0759a2a32cc691d3763648e1a839ba851324a", + "size": 5376456, + "subdir": "linux-64", + "timestamp": 1592509266354, + "version": "1.18.5" + }, + "numpy-base-1.18.5-py37hde5b4d6_0.tar.bz2": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ab2b131d9f97222312c42ea0fc39dee6", + "name": "numpy-base", + "sha256": "6bd854f2b37a30eef7e5754e9ede7990d1acb42596ec1545d717d2edb6eaf4cf", + "size": 5378413, + "subdir": "linux-64", + "timestamp": 1592509307268, + "version": "1.18.5" + }, + "numpy-base-1.18.5-py38h2f8d375_0.tar.bz2": { + "build": "py38h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "111a3b87ccf215f4205d1409f06cdf66", + "name": "numpy-base", + "sha256": "447d6c8ffb67cb5c056b50b4273fec88fdfe0aae63a926a10bcf55106d4ee113", + "size": 5430926, + "subdir": "linux-64", + "timestamp": 1592509302386, + "version": "1.18.5" + }, + "numpy-base-1.18.5-py38hde5b4d6_0.tar.bz2": { + "build": "py38hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7befe4fd6a930a55c4910dc3fa8b6709", + "name": "numpy-base", + "sha256": "5d0e0e79ebd4ef426f0ae07c7eb16891a55468997f91405f7d28bdf33f422f9f", + "size": 5416729, + "subdir": "linux-64", + "timestamp": 1592509314255, + "version": "1.18.5" + }, + "numpy-base-1.19.1-py36h75fe3a5_0.tar.bz2": { + "build": "py36h75fe3a5_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.1 py36h30dfecb_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ec2011dd3ddeee233476d8b0dae1a76f", + "name": "numpy-base", + "sha256": "635af1fa48cf2b617269076b5038fe33170b895516dfa6d5a5208012b4aef8f9", + "size": 5472173, + "subdir": "linux-64", + "timestamp": 1596233920696, + "version": "1.19.1" + }, + "numpy-base-1.19.1-py36hfa32c7d_0.tar.bz2": { + "build": "py36hfa32c7d_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.1 py36hbc911f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a5ea8eade16ca38ef16fc237e6f8cc52", + "name": "numpy-base", + "sha256": "04239487a8cd1766b7ffb6a0a2767a460729a9589ac0bee7d498dbe067f791b2", + "size": 5477609, + "subdir": "linux-64", + "timestamp": 1596233920385, + "version": "1.19.1" + }, + "numpy-base-1.19.1-py37h75fe3a5_0.tar.bz2": { + "build": "py37h75fe3a5_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.1 py37h30dfecb_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d9dd1d895db9f2a4663ae24559a5081e", + "name": "numpy-base", + "sha256": "24dcfcf6ea00cc4b59a60f393e176d9e1a483c1935f1c99dce8831d0fb27d25b", + "size": 5440782, + "subdir": "linux-64", + "timestamp": 1596233933018, + "version": "1.19.1" + }, + "numpy-base-1.19.1-py37hfa32c7d_0.tar.bz2": { + "build": "py37hfa32c7d_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.1 py37hbc911f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c496a360a8048abf89815bee9a66ca89", + "name": "numpy-base", + "sha256": "a88cc742bf36401677d99f7bc4e735c892e90ba1ad0db6de1d92587abfa6d64e", + "size": 5450082, + "subdir": "linux-64", + "timestamp": 1596233901027, + "version": "1.19.1" + }, + "numpy-base-1.19.1-py38h75fe3a5_0.tar.bz2": { + "build": "py38h75fe3a5_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.1 py38h30dfecb_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "85b813620e512b1403a4ad7e580df2b6", + "name": "numpy-base", + "sha256": "a017acfc48f12348651b61bf3f5540f2de9f3060300abb1863484d697f2eca8d", + "size": 5531840, + "subdir": "linux-64", + "timestamp": 1596233914368, + "version": "1.19.1" + }, + "numpy-base-1.19.1-py38hfa32c7d_0.tar.bz2": { + "build": "py38hfa32c7d_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.1 py38hbc911f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ed7f2a5912c1e8d44f6c85e19499c4e6", + "name": "numpy-base", + "sha256": "58315e53a89d3412630dfdd439a26881d59f73560080774fb3b0315907fa7ebd", + "size": 5536068, + "subdir": "linux-64", + "timestamp": 1596233919560, + "version": "1.19.1" + }, + "numpy-base-1.19.2-py36h75fe3a5_0.tar.bz2": { + "build": "py36h75fe3a5_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.2 py36h6163131_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d78113d6bed288608732782430ca10e9", + "name": "numpy-base", + "sha256": "20032f8721f3c6582a9e58f99463008d3255b68b7b30bc9822c97d0faaf29271", + "size": 5484653, + "subdir": "linux-64", + "timestamp": 1603483883552, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py36hfa32c7d_0.tar.bz2": { + "build": "py36hfa32c7d_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.2 py36h54aff64_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "194a3ad219f3753ad43fc15f19f21ad1", + "name": "numpy-base", + "sha256": "88cbf56f2a6778cb5f3f827ccd4538c9bc5235b9d5473e0f8844bf13bf06f52b", + "size": 5462342, + "subdir": "linux-64", + "timestamp": 1603487980556, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py37h21a3de8_1.tar.bz2": { + "build": "py37h21a3de8_1", + "build_number": 1, + "constrains": [ + "numpy 1.19.2 py37hc896f84_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "791a313f353e810177eac19d9a7685a6", + "name": "numpy-base", + "sha256": "f829669da2414ae9cce6d002b5364a5f9ff2159e677f4cf1313b5687452cd0e1", + "size": 13070559, + "subdir": "linux-64", + "timestamp": 1654873730663, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py37h4c65ebe_1.tar.bz2": { + "build": "py37h4c65ebe_1", + "build_number": 1, + "constrains": [ + "numpy 1.19.2 py37h7895c89_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "02d828379c9947194ebc98cda2534705", + "name": "numpy-base", + "sha256": "fc9b56b63dcaab05195149d2e2023e45f550077f8c572f9f94579dc02c6fdab8", + "size": 13072007, + "subdir": "linux-64", + "timestamp": 1654872390020, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py37h75fe3a5_0.tar.bz2": { + "build": "py37h75fe3a5_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.2 py37h6163131_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1ac2b7326567e2048e3a51745944ab19", + "name": "numpy-base", + "sha256": "9c55b5f83fd0791a4ad72b1097523b33a1addd5058e8d1da293585b18505cdbe", + "size": 5442486, + "subdir": "linux-64", + "timestamp": 1603481040499, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py37hfa32c7d_0.tar.bz2": { + "build": "py37hfa32c7d_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.2 py37h54aff64_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "53ba046861930f19538cb88c54910d9d", + "name": "numpy-base", + "sha256": "d6896d956f7b5b5830cc92f0353860e50dfd03fadd56269ab422dffa4a51fa7f", + "size": 5436010, + "subdir": "linux-64", + "timestamp": 1603479803658, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py38h21a3de8_1.tar.bz2": { + "build": "py38h21a3de8_1", + "build_number": 1, + "constrains": [ + "numpy 1.19.2 py38hc896f84_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c8042e8141f647520f7763774366e5d9", + "name": "numpy-base", + "sha256": "1614417b7d34e84d56293179dde6e5181a66fafeda77e61fc95dbb2daffd2eab", + "size": 13589998, + "subdir": "linux-64", + "timestamp": 1654874594865, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py38h4c65ebe_1.tar.bz2": { + "build": "py38h4c65ebe_1", + "build_number": 1, + "constrains": [ + "numpy 1.19.2 py38h7895c89_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "21d2f5724598f1cdef66e490a6255dee", + "name": "numpy-base", + "sha256": "37a492d3a2def996b0290947ed26894e3b14cd6af668d881c4f3f3bf3d78b014", + "size": 13589920, + "subdir": "linux-64", + "timestamp": 1654873267257, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py38h75fe3a5_0.tar.bz2": { + "build": "py38h75fe3a5_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.2 py38h6163131_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0d3976d0a767bc05dfde1358da6226e5", + "name": "numpy-base", + "sha256": "1946d38bf9ceb0ed2888741daa523381ebab0caa682345abc97cdd89acbb0a16", + "size": 5530513, + "subdir": "linux-64", + "timestamp": 1603479822502, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py38hfa32c7d_0.tar.bz2": { + "build": "py38hfa32c7d_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.2 py38h54aff64_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0067ab8b681b46c00877a4462e10d2a7", + "name": "numpy-base", + "sha256": "56783f4e7ef58161be4f852a93b0f6abb0ff48520885ee6897d26dd462ceb53d", + "size": 5532286, + "subdir": "linux-64", + "timestamp": 1603570661608, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py39h0f7b65f_0.tar.bz2": { + "build": "py39h0f7b65f_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.2 py39h87658db_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "69248d98e5fec43bae2e83065426cc8f", + "name": "numpy-base", + "sha256": "2cbf2c8e4428566b2fe562c10d6635c2a9f942da04bda55c8ab5afaad93a0931", + "size": 5518052, + "subdir": "linux-64", + "timestamp": 1607448334843, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py39h21a3de8_1.tar.bz2": { + "build": "py39h21a3de8_1", + "build_number": 1, + "constrains": [ + "numpy 1.19.2 py39hc896f84_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6fd9402fd97054454e4e9d965c9a93d8", + "name": "numpy-base", + "sha256": "19288209ff269807c84eec4ebdb999e945a9d3fca8653322db19e9f2fd5b8e28", + "size": 5575372, + "subdir": "linux-64", + "timestamp": 1654874153814, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py39h2ae0177_0.tar.bz2": { + "build": "py39h2ae0177_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.2 py39h89c1606_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "180578c5074742ba0a466f1bf02b47b6", + "name": "numpy-base", + "sha256": "2d0760a9eafe8bd0367251a7dae8dbaf4abf69a09339111ad3ad43a3e265d545", + "size": 5529914, + "subdir": "linux-64", + "timestamp": 1607448314407, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py39h4c65ebe_1.tar.bz2": { + "build": "py39h4c65ebe_1", + "build_number": 1, + "constrains": [ + "numpy 1.19.2 py39h7895c89_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6e8f5a40204aa8bf7a7546a7eaae1d0e", + "name": "numpy-base", + "sha256": "1e1db55118fc6a3ac84b2a319baa2bf0f57e02f9c1a6cca3a6c5438e5e3e78d0", + "size": 5574649, + "subdir": "linux-64", + "timestamp": 1654872821112, + "version": "1.19.2" + }, + "numpy-base-1.19.5-py37h21a3de8_4.tar.bz2": { + "build": "py37h21a3de8_4", + "build_number": 4, + "constrains": [ + "numpy 1.19.5 py37hc896f84_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "faeb363f107754bbb759f1ea83969eea", + "name": "numpy-base", + "sha256": "8c649a0f0fbd9b6ce786ad1cb129407082098144e33b22a26c02c17ae063aed9", + "size": 5557504, + "subdir": "linux-64", + "timestamp": 1677550472607, + "version": "1.19.5" + }, + "numpy-base-1.19.5-py37h622ebfc_4.tar.bz2": { + "build": "py37h622ebfc_4", + "build_number": 4, + "constrains": [ + "numpy 1.19.5 py37hd5178e2_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "024f6e2d2356c4c7cca39e740a653760", + "name": "numpy-base", + "sha256": "feb5f6f3110e975c60e3c41681da300dd2b3d54dd55ac72eb681c9aef3326714", + "size": 5554395, + "subdir": "linux-64", + "timestamp": 1677551457873, + "version": "1.19.5" + }, + "numpy-base-1.19.5-py38h21a3de8_4.tar.bz2": { + "build": "py38h21a3de8_4", + "build_number": 4, + "constrains": [ + "numpy 1.19.5 py38hc896f84_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6408bb01eab38be8aa12bc937a81d5c9", + "name": "numpy-base", + "sha256": "1ecc53af500ba4d94ee56a1d6986199b85224fca7ffd6ab5d5b2ac319ed86d5b", + "size": 5614901, + "subdir": "linux-64", + "timestamp": 1677549822698, + "version": "1.19.5" + }, + "numpy-base-1.19.5-py38h622ebfc_4.tar.bz2": { + "build": "py38h622ebfc_4", + "build_number": 4, + "constrains": [ + "numpy 1.19.5 py38hd5178e2_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b51c32d0123516504948ec2eea4c13c8", + "name": "numpy-base", + "sha256": "1e4815d961611f390c6fa4c4866c8f5072e1d97390735f6abeef34d52db4dfab", + "size": 5617542, + "subdir": "linux-64", + "timestamp": 1677550804067, + "version": "1.19.5" + }, + "numpy-base-1.19.5-py39h21a3de8_4.tar.bz2": { + "build": "py39h21a3de8_4", + "build_number": 4, + "constrains": [ + "numpy 1.19.5 py39hc896f84_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d23761401cd386fc90cf50a69b7b6227", + "name": "numpy-base", + "sha256": "abbb06cdc08013edd76427c14cdb27ca49122dabbcc0f7b3104bfadf01a8beac", + "size": 5589278, + "subdir": "linux-64", + "timestamp": 1677550147157, + "version": "1.19.5" + }, + "numpy-base-1.19.5-py39h622ebfc_4.tar.bz2": { + "build": "py39h622ebfc_4", + "build_number": 4, + "constrains": [ + "numpy 1.19.5 py39hd5178e2_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4e7bd2fb39ccba0b7dc0ceb87afbdc6b", + "name": "numpy-base", + "sha256": "ebe612d8295bc7990ade0914647fbb12965f9bfd3719da9e76eef6291df73fb2", + "size": 5590554, + "subdir": "linux-64", + "timestamp": 1677551131013, + "version": "1.19.5" + }, + "numpy-base-1.20.1-py37h34387ca_0.tar.bz2": { + "build": "py37h34387ca_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.1 py37h5a90a98_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6c1e167d25e6c767a98e0a8efafb6810", + "name": "numpy-base", + "sha256": "6bdda5e191e365a25423e0374a7c266ce9e9f1e654ec4a20e2ca0da161d86392", + "size": 5914719, + "subdir": "linux-64", + "timestamp": 1618494303734, + "version": "1.20.1" + }, + "numpy-base-1.20.1-py37h7d8b39e_0.tar.bz2": { + "build": "py37h7d8b39e_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.1 py37h93e21f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "573e088fcd818eafa2fc7ffd6596555b", + "name": "numpy-base", + "sha256": "3a3140d2464034885ff146a6e1950f4d396228ef2b07fe52057aaabc31e2ea28", + "size": 5937585, + "subdir": "linux-64", + "timestamp": 1618497448592, + "version": "1.20.1" + }, + "numpy-base-1.20.1-py38h34387ca_0.tar.bz2": { + "build": "py38h34387ca_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.1 py38h5a90a98_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c9d764c740d237e35ecd46c1e4501fa4", + "name": "numpy-base", + "sha256": "937d8794f5f36aee06b1103ffbeef8c9dd6a9b2f3dd71c4a3c28af9d7d138a41", + "size": 5995594, + "subdir": "linux-64", + "timestamp": 1618497488151, + "version": "1.20.1" + }, + "numpy-base-1.20.1-py38h7d8b39e_0.tar.bz2": { + "build": "py38h7d8b39e_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.1 py38h93e21f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b92d80f022674fa1d9c683bf56288cd8", + "name": "numpy-base", + "sha256": "7489f05cd2f5e5d1b500b7278535182e2ec9d7e166d6445146ba434f2c38f818", + "size": 5998415, + "subdir": "linux-64", + "timestamp": 1618497527785, + "version": "1.20.1" + }, + "numpy-base-1.20.1-py39h34387ca_0.tar.bz2": { + "build": "py39h34387ca_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.1 py39h5a90a98_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d5c71128ae64a8a2a5343920cde6ef9e", + "name": "numpy-base", + "sha256": "f0263f6f25ff74deb010c3f159514a85dfdcd81f0838d6d0ea9ea6d9c519d690", + "size": 5992579, + "subdir": "linux-64", + "timestamp": 1618497474777, + "version": "1.20.1" + }, + "numpy-base-1.20.1-py39h7d8b39e_0.tar.bz2": { + "build": "py39h7d8b39e_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.1 py39h93e21f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "38d398370646988e207b1e50dc519386", + "name": "numpy-base", + "sha256": "45ac8aafa0d1f52fc2d7bc82ab4b3030b07a14aed82148462f81ac0d4f16e0c5", + "size": 6017216, + "subdir": "linux-64", + "timestamp": 1618497530259, + "version": "1.20.1" + }, + "numpy-base-1.20.2-py37he2ba247_0.tar.bz2": { + "build": "py37he2ba247_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.2 py37h62767a5_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "83ba21532d4d4362562db50c0d8cdce0", + "name": "numpy-base", + "sha256": "859c6b643512a1d03d6c85e18812c8694e64909bdb19bd4a75addf57bd52a02f", + "size": 5927100, + "subdir": "linux-64", + "timestamp": 1620831415968, + "version": "1.20.2" + }, + "numpy-base-1.20.2-py37hfae3a4d_0.tar.bz2": { + "build": "py37hfae3a4d_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.2 py37h2d18471_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7d3a646cfbe961305187a21f7399ac29", + "name": "numpy-base", + "sha256": "c5ad544a7bfdc35c85da20430b5bfeddbc0c7c2395d5e207886b0084d6691f87", + "size": 5949775, + "subdir": "linux-64", + "timestamp": 1620831410905, + "version": "1.20.2" + }, + "numpy-base-1.20.2-py38he2ba247_0.tar.bz2": { + "build": "py38he2ba247_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.2 py38h62767a5_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5bfc102233fdd67c6c885d67e7821d74", + "name": "numpy-base", + "sha256": "2da6a23980d5f63f30306e99ccbad6a89d9ae2fa9b1e65aa6e0f6b13d40a1e69", + "size": 6020993, + "subdir": "linux-64", + "timestamp": 1620827096629, + "version": "1.20.2" + }, + "numpy-base-1.20.2-py38hfae3a4d_0.tar.bz2": { + "build": "py38hfae3a4d_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.2 py38h2d18471_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b644041d0c6825d8c069d57f02a031d3", + "name": "numpy-base", + "sha256": "045d5c5e9d02129c7494b7253548a6ab4a37381427c3a7351dc338ed41cd38bb", + "size": 6019873, + "subdir": "linux-64", + "timestamp": 1620831180574, + "version": "1.20.2" + }, + "numpy-base-1.20.2-py39he2ba247_0.tar.bz2": { + "build": "py39he2ba247_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.2 py39h62767a5_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3544987c3f5656d60c763ccd743b05da", + "name": "numpy-base", + "sha256": "c3289ca6afd0fb300e25f5cd7f7af4bb583a8448d7f0e3d264fd900ae8226b33", + "size": 6013442, + "subdir": "linux-64", + "timestamp": 1620831405549, + "version": "1.20.2" + }, + "numpy-base-1.20.2-py39hfae3a4d_0.tar.bz2": { + "build": "py39hfae3a4d_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.2 py39h2d18471_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ae6715d2008764c7662a48bfb868afa6", + "name": "numpy-base", + "sha256": "a47dcec6218c1a50a30e81461192c80e250e8eea5191a038d1902da04b5b3fc7", + "size": 6016286, + "subdir": "linux-64", + "timestamp": 1620831420619, + "version": "1.20.2" + }, + "numpy-base-1.20.3-py37h39b7dee_0.tar.bz2": { + "build": "py37h39b7dee_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.3 py37h3dbb7de_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "370360f6f5cb71ba0ca9be0a7bc8856b", + "name": "numpy-base", + "sha256": "2dbeb1624e682f0e6bc2e932fda5ab8028f03a05a5d2df315f316d63eb596717", + "size": 5951392, + "subdir": "linux-64", + "timestamp": 1626272002902, + "version": "1.20.3" + }, + "numpy-base-1.20.3-py37h74d4b33_0.tar.bz2": { + "build": "py37h74d4b33_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.3 py37hf144106_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8ea013b01f4be9a3c0ebc3ba26baa001", + "name": "numpy-base", + "sha256": "b4898daa9e775de74b123214d531e1f64aa449f02c2e637fe057744fadf83b94", + "size": 5939367, + "subdir": "linux-64", + "timestamp": 1626265002908, + "version": "1.20.3" + }, + "numpy-base-1.20.3-py38h39b7dee_0.tar.bz2": { + "build": "py38h39b7dee_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.3 py38h3dbb7de_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bce8844d6a79334f02f0fef72dbc4f3e", + "name": "numpy-base", + "sha256": "532dfe77f22a6e8c5e8757d219b39f4e8603b5084a5ad247efa7e81d1faeba0a", + "size": 6000159, + "subdir": "linux-64", + "timestamp": 1626271993406, + "version": "1.20.3" + }, + "numpy-base-1.20.3-py38h74d4b33_0.tar.bz2": { + "build": "py38h74d4b33_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.3 py38hf144106_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "68fb19b46268a5a8793ff193e756771a", + "name": "numpy-base", + "sha256": "8c9108421eacb1905943b37da3eef6a435661d3a105b5091f2ed8f86e962b200", + "size": 5996323, + "subdir": "linux-64", + "timestamp": 1626271757410, + "version": "1.20.3" + }, + "numpy-base-1.20.3-py39h39b7dee_0.tar.bz2": { + "build": "py39h39b7dee_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.3 py39h3dbb7de_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fd3061a8dcb3baa434d82ff68ee57cfe", + "name": "numpy-base", + "sha256": "7373a368025987b074de96272c4ac7c54cfb0f9079ce51893e4e41de99721c31", + "size": 5988546, + "subdir": "linux-64", + "timestamp": 1626272008985, + "version": "1.20.3" + }, + "numpy-base-1.20.3-py39h74d4b33_0.tar.bz2": { + "build": "py39h74d4b33_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.3 py39hf144106_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7bf5a7919d46332e603a6a16a517f46b", + "name": "numpy-base", + "sha256": "6de24260057432f76c94f2d512319a6db6132fef7d737f51d48b145865812917", + "size": 6010003, + "subdir": "linux-64", + "timestamp": 1626265005484, + "version": "1.20.3" + }, + "numpy-base-1.21.2-py310h2b8c604_0.tar.bz2": { + "build": "py310h2b8c604_0", + "build_number": 0, + "constrains": [ + "numpy 1.21.2 py310hd8d4704_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e7cb7e4c608d39e4f45d80ba28ef665e", + "name": "numpy-base", + "sha256": "7dea6c5a57d44a351aad8cf4cfebe01f7cf461009519ab2484c3afdd5744b23a", + "size": 15644428, + "subdir": "linux-64", + "timestamp": 1639483330093, + "version": "1.21.2" + }, + "numpy-base-1.21.2-py310h79a1101_0.tar.bz2": { + "build": "py310h79a1101_0", + "build_number": 0, + "constrains": [ + "numpy 1.21.2 py310h20f2e39_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "81379ad037619fd1931d888782e94ddb", + "name": "numpy-base", + "sha256": "bbe9f56788a46b3a938bc9826653f998ea27441b0e1f99f62fbd6d92976c854e", + "size": 15609619, + "subdir": "linux-64", + "timestamp": 1639497117707, + "version": "1.21.2" + }, + "numpy-base-1.21.2-py37h2b8c604_0.tar.bz2": { + "build": "py37h2b8c604_0", + "build_number": 0, + "constrains": [ + "numpy 1.21.2 py37hd8d4704_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7c5fbc8de8c9db832d6c00468776444b", + "name": "numpy-base", + "sha256": "7aa4394adf9338b8ceed48ea238c0ec50063a63bec24aa0f2c00a4780ee6c4ab", + "size": 6331081, + "subdir": "linux-64", + "timestamp": 1634106895827, + "version": "1.21.2" + }, + "numpy-base-1.21.2-py37h79a1101_0.tar.bz2": { + "build": "py37h79a1101_0", + "build_number": 0, + "constrains": [ + "numpy 1.21.2 py37h20f2e39_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "25603c509c33f4b5b9a8f85099aa1bb1", + "name": "numpy-base", + "sha256": "5031abd2a0d757d56a08429f07e61667081823591d0e79ebd87ed20c9d53bfd1", + "size": 6308279, + "subdir": "linux-64", + "timestamp": 1634106931400, + "version": "1.21.2" + }, + "numpy-base-1.21.2-py38h2b8c604_0.tar.bz2": { + "build": "py38h2b8c604_0", + "build_number": 0, + "constrains": [ + "numpy 1.21.2 py38hd8d4704_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "676918e768890d74709c487e6f0f3e10", + "name": "numpy-base", + "sha256": "11880cf4c309388fd02a0a9767ddff760babf592df11dab930c76e25b3da592a", + "size": 6393696, + "subdir": "linux-64", + "timestamp": 1634106932275, + "version": "1.21.2" + }, + "numpy-base-1.21.2-py38h79a1101_0.tar.bz2": { + "build": "py38h79a1101_0", + "build_number": 0, + "constrains": [ + "numpy 1.21.2 py38h20f2e39_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "921af6a1e653c47d422c9430e3e7cdfa", + "name": "numpy-base", + "sha256": "500dfdfc70fc10d6456a76dd57b204a5637c2277d37a04ddc1aafa9ef269b71a", + "size": 6389980, + "subdir": "linux-64", + "timestamp": 1634095881100, + "version": "1.21.2" + }, + "numpy-base-1.21.2-py39h2b8c604_0.tar.bz2": { + "build": "py39h2b8c604_0", + "build_number": 0, + "constrains": [ + "numpy 1.21.2 py39hd8d4704_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "19e021ef17584b70c019070042203d39", + "name": "numpy-base", + "sha256": "2f1b1be0d39f36ca70b4d9d0a366c71f0df56d0ff8ef4339ce5fcdf1fff045b6", + "size": 6407866, + "subdir": "linux-64", + "timestamp": 1634106920988, + "version": "1.21.2" + }, + "numpy-base-1.21.2-py39h79a1101_0.tar.bz2": { + "build": "py39h79a1101_0", + "build_number": 0, + "constrains": [ + "numpy 1.21.2 py39h20f2e39_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6451686c40a20e0a8c7b4e80a9646ad6", + "name": "numpy-base", + "sha256": "aa156b1aa2c948c41f5fec5d32b90b56760f702ef73110fc6f83dd6664b5c734", + "size": 6390509, + "subdir": "linux-64", + "timestamp": 1634095888862, + "version": "1.21.2" + }, + "numpy-base-1.21.5-py310h375b286_3.tar.bz2": { + "build": "py310h375b286_3", + "build_number": 3, + "constrains": [ + "numpy 1.21.5 py310hac523dd_3" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "92ff77c61efd73f2a6d5e61035edf350", + "name": "numpy-base", + "sha256": "2e0869323a2824536a99a3d65579da6b1ee0183073e1230beb1c4590a28a49c9", + "size": 16332091, + "subdir": "linux-64", + "timestamp": 1653916827576, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py310h9585f30_1.tar.bz2": { + "build": "py310h9585f30_1", + "build_number": 1, + "constrains": [ + "numpy 1.21.5 py310hfa59a62_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a362093ea518925cead8af935f883955", + "name": "numpy-base", + "sha256": "58feb3d333af26285e165e3cd568451ade0ea9e3e76c4523e1da55ced8834e34", + "size": 15652451, + "subdir": "linux-64", + "timestamp": 1649783057219, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py310h9585f30_2.tar.bz2": { + "build": "py310h9585f30_2", + "build_number": 2, + "constrains": [ + "numpy 1.21.5 py310hfa59a62_2" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "6186371f7c02658f6d8fd3071ada4256", + "name": "numpy-base", + "sha256": "ee20583430e3bfc7e7c963c4e13d3a5577db08a0f954ced81b09cf461bb3b717", + "size": 15603129, + "subdir": "linux-64", + "timestamp": 1651565832729, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py310hcba007f_3.tar.bz2": { + "build": "py310hcba007f_3", + "build_number": 3, + "constrains": [ + "numpy 1.21.5 py310h1794996_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "764ca97bddbbfcc122a10ea5e0d1b85b", + "name": "numpy-base", + "sha256": "be8f2df5a89f00751864ee46373717ea6aca495b2030c3c1153c8271df854374", + "size": 16331632, + "subdir": "linux-64", + "timestamp": 1653918954465, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py310hf2716ce_1.tar.bz2": { + "build": "py310hf2716ce_1", + "build_number": 1, + "constrains": [ + "numpy 1.21.5 py310h4f1e569_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c694bad61846fa27aab5049cd36ba712", + "name": "numpy-base", + "sha256": "e4ff7aff18f2872ba0dc2f92efb95d71320984489dcffb9a18defa7f3c911e8f", + "size": 15614094, + "subdir": "linux-64", + "timestamp": 1649783042666, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py310hf2716ce_2.tar.bz2": { + "build": "py310hf2716ce_2", + "build_number": 2, + "constrains": [ + "numpy 1.21.5 py310h4f1e569_2" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "63efcfedad5b8d174c8d2fb08552f583", + "name": "numpy-base", + "sha256": "589d4795dbb73d27077af5058e60d7b1a441385124aecfbb5a45ea0a9d07fef0", + "size": 15600685, + "subdir": "linux-64", + "timestamp": 1651563857224, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py37h1e6e340_3.tar.bz2": { + "build": "py37h1e6e340_3", + "build_number": 3, + "constrains": [ + "numpy 1.21.5 py37hf838250_3" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ae343aef09865e74dcfe66e2fa3f4421", + "name": "numpy-base", + "sha256": "575bc8b7469bf64c23d5d23152174ace26ba38fe3123f5b8269d63677b4db6fb", + "size": 6391316, + "subdir": "linux-64", + "timestamp": 1653915737686, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py37ha15fc14_3.tar.bz2": { + "build": "py37ha15fc14_3", + "build_number": 3, + "constrains": [ + "numpy 1.21.5 py37h6c91a56_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "017838aff7d6d47116dd85e4aa245fa1", + "name": "numpy-base", + "sha256": "2c0ce99d246f1adc84b2db9f665aba190be9c8f09a06d8968c86938b451912b0", + "size": 6391997, + "subdir": "linux-64", + "timestamp": 1653917873833, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py37hb8be1f0_1.tar.bz2": { + "build": "py37hb8be1f0_1", + "build_number": 1, + "constrains": [ + "numpy 1.21.5 py37h7a5d4dd_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b807aaf2b2599b0a7204ee9eb976f686", + "name": "numpy-base", + "sha256": "129d17f757c92211b1e5711ab182bf7b408dd9a1d21f4d7e5b47042fb1642df5", + "size": 6309813, + "subdir": "linux-64", + "timestamp": 1649782970693, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py37hb8be1f0_2.tar.bz2": { + "build": "py37hb8be1f0_2", + "build_number": 2, + "constrains": [ + "numpy 1.21.5 py37h7a5d4dd_2" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "1181e79fc6f12dfc4e18496dc1ede5c9", + "name": "numpy-base", + "sha256": "e6adf68c144ee145821cdfdbb7c5bc1bb01de1a32c58a5ecd0199bc0da2cb519", + "size": 6301879, + "subdir": "linux-64", + "timestamp": 1651564826085, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py37hf524024_1.tar.bz2": { + "build": "py37hf524024_1", + "build_number": 1, + "constrains": [ + "numpy 1.21.5 py37he7a7128_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "1b4efda80a00a07dfceb576302ee56e7", + "name": "numpy-base", + "sha256": "530ac550e1c67d83cec11af535c8665f3c29b9109cd6de0bbef7cffdb9044d42", + "size": 6334615, + "subdir": "linux-64", + "timestamp": 1649783024841, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py37hf524024_2.tar.bz2": { + "build": "py37hf524024_2", + "build_number": 2, + "constrains": [ + "numpy 1.21.5 py37he7a7128_2" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ec721635939acc04dc2f39d68993a4f0", + "name": "numpy-base", + "sha256": "391a2d3f53519104b6dd2358b0bb3145068c4a3901eec694fa90b98cbd00fc34", + "size": 6302483, + "subdir": "linux-64", + "timestamp": 1651566819368, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py38h1e6e340_3.tar.bz2": { + "build": "py38h1e6e340_3", + "build_number": 3, + "constrains": [ + "numpy 1.21.5 py38hf838250_3" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d6cfa0ef075abd4b35bcc4d908e46a21", + "name": "numpy-base", + "sha256": "a960a7fcf2508091184c71402c65bf38e10631edd4f938ec0a66a5a9605de5e5", + "size": 6457682, + "subdir": "linux-64", + "timestamp": 1653916264664, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py38ha15fc14_3.tar.bz2": { + "build": "py38ha15fc14_3", + "build_number": 3, + "constrains": [ + "numpy 1.21.5 py38h6c91a56_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "563314010ae2760f929e82a9a5816725", + "name": "numpy-base", + "sha256": "b973ed015f0734d2b3b6619d30edef2c885efdb9680a2d217915b5fe71f48457", + "size": 6459920, + "subdir": "linux-64", + "timestamp": 1653918401329, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py38hb8be1f0_1.tar.bz2": { + "build": "py38hb8be1f0_1", + "build_number": 1, + "constrains": [ + "numpy 1.21.5 py38h7a5d4dd_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e2b175c2cc7eb80bdd0833970fd65ed6", + "name": "numpy-base", + "sha256": "f25997785ae0b0a1feb037efd24f956d220f59fb3b8891dd94e28b776e5093f7", + "size": 6383466, + "subdir": "linux-64", + "timestamp": 1649765112899, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py38hb8be1f0_2.tar.bz2": { + "build": "py38hb8be1f0_2", + "build_number": 2, + "constrains": [ + "numpy 1.21.5 py38h7a5d4dd_2" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ef2fee744a81231901a43d6ccc6c6fb1", + "name": "numpy-base", + "sha256": "09a9c30410d51a6149754c055d39f33b8968717abd1f6011a65ffe54f84fa17f", + "size": 6384277, + "subdir": "linux-64", + "timestamp": 1651565316969, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py38hf524024_1.tar.bz2": { + "build": "py38hf524024_1", + "build_number": 1, + "constrains": [ + "numpy 1.21.5 py38he7a7128_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e590813c86feef2408de74f4d3870b28", + "name": "numpy-base", + "sha256": "c9e8a5d4280ad7f1643affe08e819d0f6ab1bff9a119c2af1bf12730e4065a22", + "size": 6391580, + "subdir": "linux-64", + "timestamp": 1649783015859, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py38hf524024_2.tar.bz2": { + "build": "py38hf524024_2", + "build_number": 2, + "constrains": [ + "numpy 1.21.5 py38he7a7128_2" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a7adb4a8a82b449d8f1f7b8acc538a1e", + "name": "numpy-base", + "sha256": "5e06ad5d3673a78b18e1a72c297cbec9c57614a724e4b96a31b1b8b43ebe5391", + "size": 6385093, + "subdir": "linux-64", + "timestamp": 1651567308031, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py39h1e6e340_3.tar.bz2": { + "build": "py39h1e6e340_3", + "build_number": 3, + "constrains": [ + "numpy 1.21.5 py39hf838250_3" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e1b679be6ddf2c54e59723dadd840912", + "name": "numpy-base", + "sha256": "eef741d4119e95de38628afcdd08b2ac14a062413c58cff04c3b43cd517a081b", + "size": 6404554, + "subdir": "linux-64", + "timestamp": 1653917351255, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py39ha15fc14_3.tar.bz2": { + "build": "py39ha15fc14_3", + "build_number": 3, + "constrains": [ + "numpy 1.21.5 py39h6c91a56_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "272b3aeecaffb5c5542c892147c35a7b", + "name": "numpy-base", + "sha256": "635b8fe6e9c2b9ae466c81a8c3892141576d62b8d94f37dd20c7a10675737161", + "size": 6404922, + "subdir": "linux-64", + "timestamp": 1653919477728, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py39hb8be1f0_1.tar.bz2": { + "build": "py39hb8be1f0_1", + "build_number": 1, + "constrains": [ + "numpy 1.21.5 py39h7a5d4dd_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "bf74d5b1f4eb2aa756676975f369603d", + "name": "numpy-base", + "sha256": "f43e92b943345f90bc8e31ecfb14c07a063eafd55c83a72b1e97a93725233833", + "size": 6445167, + "subdir": "linux-64", + "timestamp": 1649764875185, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py39hb8be1f0_2.tar.bz2": { + "build": "py39hb8be1f0_2", + "build_number": 2, + "constrains": [ + "numpy 1.21.5 py39h7a5d4dd_2" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b2ff6ff1c4b84824313a3ff11d791c2c", + "name": "numpy-base", + "sha256": "8387b2bb3bddb15c2bfc92dedd6ac1f6882b1a31f0e7b41cf6e3a4a63f62575d", + "size": 6387537, + "subdir": "linux-64", + "timestamp": 1651564345402, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py39hf524024_1.tar.bz2": { + "build": "py39hf524024_1", + "build_number": 1, + "constrains": [ + "numpy 1.21.5 py39he7a7128_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "056666c84a345e061a7b14a1dba6e854", + "name": "numpy-base", + "sha256": "627c9203a545ebaca4123c1c358cc552ae7521a9a296bf1726106b4ad2ebbf03", + "size": 6451091, + "subdir": "linux-64", + "timestamp": 1649764875885, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py39hf524024_2.tar.bz2": { + "build": "py39hf524024_2", + "build_number": 2, + "constrains": [ + "numpy 1.21.5 py39he7a7128_2" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e5666032c7865b4977e740e6f069e540", + "name": "numpy-base", + "sha256": "dbd1301d64a55552a01d74a1928d279646a97158cad3cce7e05548b6fa112338", + "size": 6385715, + "subdir": "linux-64", + "timestamp": 1651566332949, + "version": "1.21.5" + }, + "numpy-base-1.22.3-py310h9585f30_0.tar.bz2": { + "build": "py310h9585f30_0", + "build_number": 0, + "constrains": [ + "numpy 1.22.3 py310hfa59a62_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9d47c84ae5205503a3b4b6c01dd8003f", + "name": "numpy-base", + "sha256": "735d104050e9b2ca083c51a2fbbac025fd79cf1e0def76c73f9e90792a2ef8d4", + "size": 16444261, + "subdir": "linux-64", + "timestamp": 1652802619412, + "version": "1.22.3" + }, + "numpy-base-1.22.3-py310hf2716ce_0.tar.bz2": { + "build": "py310hf2716ce_0", + "build_number": 0, + "constrains": [ + "numpy 1.22.3 py310h4f1e569_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7b114d82ab924054edd00b539f5f6b2c", + "name": "numpy-base", + "sha256": "71f331e7cfa616ef9dbb392fda90b1f5fc8243d189c927f08d922affcb460ea5", + "size": 16446940, + "subdir": "linux-64", + "timestamp": 1652804688097, + "version": "1.22.3" + }, + "numpy-base-1.22.3-py311h0ff3221_1.tar.bz2": { + "build": "py311h0ff3221_1", + "build_number": 1, + "constrains": [ + "numpy 1.22.3 py311h75bd12f_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "6dd26aa6f0d0dbf3f37372869fe68338", + "name": "numpy-base", + "sha256": "27915623cc561dcabcc8dfeb1e1fa684b26bb2d1e01a1960d30f2f7770705967", + "size": 8255641, + "subdir": "linux-64", + "timestamp": 1676824824950, + "version": "1.22.3" + }, + "numpy-base-1.22.3-py311hc9e7d78_1.tar.bz2": { + "build": "py311hc9e7d78_1", + "build_number": 1, + "constrains": [ + "numpy 1.22.3 py311h5585df3_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b253f7ec64078344130b864996dff562", + "name": "numpy-base", + "sha256": "c8bdc7fce0706af87da72118463c2954cfc9f10f2ede316b670cc16b77a6070d", + "size": 8252378, + "subdir": "linux-64", + "timestamp": 1676824669303, + "version": "1.22.3" + }, + "numpy-base-1.22.3-py38hb8be1f0_0.tar.bz2": { + "build": "py38hb8be1f0_0", + "build_number": 0, + "constrains": [ + "numpy 1.22.3 py38h7a5d4dd_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "680a19610e02305e31754b11d707118a", + "name": "numpy-base", + "sha256": "d8940d27cea4c5064c5486cb88bb6d0251a5a571569fbeb41587bed29c3ec570", + "size": 7089250, + "subdir": "linux-64", + "timestamp": 1652805368194, + "version": "1.22.3" + }, + "numpy-base-1.22.3-py38hf524024_0.tar.bz2": { + "build": "py38hf524024_0", + "build_number": 0, + "constrains": [ + "numpy 1.22.3 py38he7a7128_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "326e9873702b019846d1b20df09bac59", + "name": "numpy-base", + "sha256": "2bd30bd53b68ccbedfda6056f2359d2596b4df63238a5af49c0e1b747ff7d6ca", + "size": 7091454, + "subdir": "linux-64", + "timestamp": 1652803317026, + "version": "1.22.3" + }, + "numpy-base-1.22.3-py39hb8be1f0_0.tar.bz2": { + "build": "py39hb8be1f0_0", + "build_number": 0, + "constrains": [ + "numpy 1.22.3 py39h7a5d4dd_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "5f9462a3b249fc323be190ca7d3ac278", + "name": "numpy-base", + "sha256": "229e9073db267ae63d811901a91ec89e5d9491bdb1b95b0018364070d19b52a9", + "size": 7094770, + "subdir": "linux-64", + "timestamp": 1652804001140, + "version": "1.22.3" + }, + "numpy-base-1.22.3-py39hf524024_0.tar.bz2": { + "build": "py39hf524024_0", + "build_number": 0, + "constrains": [ + "numpy 1.22.3 py39he7a7128_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e8dc29adc0282f4658e0e2f25ff207a2", + "name": "numpy-base", + "sha256": "abfdeda143b6b667d50a82ea119043fc1469ee02f094a41a2402433ff408099e", + "size": 7095882, + "subdir": "linux-64", + "timestamp": 1652801886819, + "version": "1.22.3" + }, + "numpy-base-1.23.1-py310h375b286_0.tar.bz2": { + "build": "py310h375b286_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.1 py310hac523dd_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "edcddb8077d48bcd9814e6d816bdec16", + "name": "numpy-base", + "sha256": "b728f86c863c015f43692ec07c8990f920f78fa27ec2380be442c274fcf8e923", + "size": 19655086, + "subdir": "linux-64", + "timestamp": 1659434112799, + "version": "1.23.1" + }, + "numpy-base-1.23.1-py310hcba007f_0.tar.bz2": { + "build": "py310hcba007f_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.1 py310h1794996_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "164574c0037b36965359f1b5e5e83105", + "name": "numpy-base", + "sha256": "9e5772b572fc4d4843e37288400b39a3b5ed59f69033a313f11245a3142b84f8", + "size": 19654169, + "subdir": "linux-64", + "timestamp": 1659435953834, + "version": "1.23.1" + }, + "numpy-base-1.23.1-py38h1e6e340_0.tar.bz2": { + "build": "py38h1e6e340_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.1 py38hf838250_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f5bed7f257a49dcd5434ff25eb78c29a", + "name": "numpy-base", + "sha256": "bd5e785ffab29ba6af210b1d00086f187b22a912802646f6cd791d73de8921a1", + "size": 7407891, + "subdir": "linux-64", + "timestamp": 1659433462676, + "version": "1.23.1" + }, + "numpy-base-1.23.1-py38ha15fc14_0.tar.bz2": { + "build": "py38ha15fc14_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.1 py38h6c91a56_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7d216254459967a54339aeea2cfaba3d", + "name": "numpy-base", + "sha256": "e3fcf1d5d08c21c6f09c30e678187934c6af9af6069e664502d6282943015385", + "size": 7408970, + "subdir": "linux-64", + "timestamp": 1659435304694, + "version": "1.23.1" + }, + "numpy-base-1.23.1-py39h1e6e340_0.tar.bz2": { + "build": "py39h1e6e340_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.1 py39hf838250_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "bd603c793e710951545e12011b88a0d5", + "name": "numpy-base", + "sha256": "4b42e4211e5323ef50ae80d9fab5d8b8043b7ccfa9ded8d37f4d6975a7b1526b", + "size": 7394300, + "subdir": "linux-64", + "timestamp": 1659432871716, + "version": "1.23.1" + }, + "numpy-base-1.23.1-py39ha15fc14_0.tar.bz2": { + "build": "py39ha15fc14_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.1 py39h6c91a56_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c91123b24002c4842507347e55365786", + "name": "numpy-base", + "sha256": "f5422f242f403c8cd54dac339d53c01b0d0b90998c70cbecc4a4f3c5b202a1cd", + "size": 7394771, + "subdir": "linux-64", + "timestamp": 1659434713520, + "version": "1.23.1" + }, + "numpy-base-1.23.3-py310h375b286_1.tar.bz2": { + "build": "py310h375b286_1", + "build_number": 1, + "constrains": [ + "numpy 1.23.3 py310hac523dd_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e9f1e6ac90725692082b1e6baceb28a0", + "name": "numpy-base", + "sha256": "92eb10af0cd9a7161679676ef71db10a4b587ef7742208b7795e78e0dc1c4926", + "size": 7414409, + "subdir": "linux-64", + "timestamp": 1667234277079, + "version": "1.23.3" + }, + "numpy-base-1.23.3-py310h8e6c178_1.tar.bz2": { + "build": "py310h8e6c178_1", + "build_number": 1, + "constrains": [ + "numpy 1.23.3 py310hd5efca6_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "47ba9bf74b0fd9a89df04e68b9ae1a91", + "name": "numpy-base", + "sha256": "fa1053c2e387a471eb7ba303aecee76702d09d9a650e38091c6e99efce371270", + "size": 7414143, + "subdir": "linux-64", + "timestamp": 1667236095851, + "version": "1.23.3" + }, + "numpy-base-1.23.3-py38h1e6e340_0.tar.bz2": { + "build": "py38h1e6e340_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.3 py38hf838250_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "02f77a84837d2bfa870ef5b9f5c7ce42", + "name": "numpy-base", + "sha256": "b8a937d3db0a4040ec0a7b6b2879b111196cb72ff95d22d13f71231347868e9d", + "size": 7430991, + "subdir": "linux-64", + "timestamp": 1665775154160, + "version": "1.23.3" + }, + "numpy-base-1.23.3-py38h1e6e340_1.tar.bz2": { + "build": "py38h1e6e340_1", + "build_number": 1, + "constrains": [ + "numpy 1.23.3 py38hf838250_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "81fb26ec40dade6a5ddfa0d5e4a2edfc", + "name": "numpy-base", + "sha256": "3e040a4c8a59dc91274595fd4b712ce1187e235f28b01ccbd8f675f33e58a063", + "size": 7477828, + "subdir": "linux-64", + "timestamp": 1667233656053, + "version": "1.23.3" + }, + "numpy-base-1.23.3-py38h31eccc5_0.tar.bz2": { + "build": "py38h31eccc5_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.3 py38h14f4228_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22a245465a7a84b773bfb9441f25f11f", + "name": "numpy-base", + "sha256": "7b4fcc84a3d3d22e1ae7d5883f2556fa39ce6941cf20f4df6fa1ab83773ee52e", + "size": 7431038, + "subdir": "linux-64", + "timestamp": 1665773363529, + "version": "1.23.3" + }, + "numpy-base-1.23.3-py38h31eccc5_1.tar.bz2": { + "build": "py38h31eccc5_1", + "build_number": 1, + "constrains": [ + "numpy 1.23.3 py38h14f4228_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "da30f9b315c89c31da2168c84f7150d2", + "name": "numpy-base", + "sha256": "61ce6bcb8e1776b02674a3a6a432e64a3de5b2f63830ac8a592b40e47e52692b", + "size": 7478320, + "subdir": "linux-64", + "timestamp": 1667235473997, + "version": "1.23.3" + }, + "numpy-base-1.23.3-py39h1e6e340_0.tar.bz2": { + "build": "py39h1e6e340_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.3 py39hf838250_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "af6831dda80d87c0df89036d0aed8eb1", + "name": "numpy-base", + "sha256": "8088db2ff28a959a7e0d542cd45ba5bc7daaf32851ae17289e80ab906fd3bedf", + "size": 7406622, + "subdir": "linux-64", + "timestamp": 1665775767796, + "version": "1.23.3" + }, + "numpy-base-1.23.3-py39h1e6e340_1.tar.bz2": { + "build": "py39h1e6e340_1", + "build_number": 1, + "constrains": [ + "numpy 1.23.3 py39hf838250_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3c4865d1936610851aac229c57e173b2", + "name": "numpy-base", + "sha256": "de7b9de96f8c94814cb131810992859a74fc20b44ab5b85caee234b01c36a8be", + "size": 7436214, + "subdir": "linux-64", + "timestamp": 1667234874984, + "version": "1.23.3" + }, + "numpy-base-1.23.3-py39h31eccc5_0.tar.bz2": { + "build": "py39h31eccc5_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.3 py39h14f4228_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ad9de52ffca4aa8951721a1a4aa4bd8", + "name": "numpy-base", + "sha256": "bba467b0d9cbe4421dd7983bb84a657ef60f24b21b025bc4bdcd6c4435197720", + "size": 7408468, + "subdir": "linux-64", + "timestamp": 1665773978393, + "version": "1.23.3" + }, + "numpy-base-1.23.3-py39h31eccc5_1.tar.bz2": { + "build": "py39h31eccc5_1", + "build_number": 1, + "constrains": [ + "numpy 1.23.3 py39h14f4228_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bae038890fea00617e6a82e497a88363", + "name": "numpy-base", + "sha256": "c78b7e8ee0860d9979223d16fd971930b85fc603839931273f17e051b773a9b9", + "size": 7436929, + "subdir": "linux-64", + "timestamp": 1667236702226, + "version": "1.23.3" + }, + "numpy-base-1.23.4-py310h375b286_0.tar.bz2": { + "build": "py310h375b286_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.4 py310hac523dd_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "56ff3deaefd4fdc4f34731c52671ca90", + "name": "numpy-base", + "sha256": "e09f8d0ccb8f436b6be961d5136574e06b761b812fe51ecdf3242d7ce26a8e8c", + "size": 7411947, + "subdir": "linux-64", + "timestamp": 1668599484845, + "version": "1.23.4" + }, + "numpy-base-1.23.4-py310h8e6c178_0.tar.bz2": { + "build": "py310h8e6c178_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.4 py310hd5efca6_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ebec614d76405dfc3e9074dd5140cd54", + "name": "numpy-base", + "sha256": "2ac5c6faea4321092c9e6b4dd77b9bf46276efd0e12fb32595b5dfddda75f1dd", + "size": 7412861, + "subdir": "linux-64", + "timestamp": 1668596121299, + "version": "1.23.4" + }, + "numpy-base-1.23.4-py38h1e6e340_0.tar.bz2": { + "build": "py38h1e6e340_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.4 py38hf838250_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f73bd85250e22a2becc2c9af0b0c7e11", + "name": "numpy-base", + "sha256": "9840c5809fd48e2ec3c27c6e454e6f6295e6ecd8e8dbf37169eabe091ffcccfd", + "size": 7437868, + "subdir": "linux-64", + "timestamp": 1668597215205, + "version": "1.23.4" + }, + "numpy-base-1.23.4-py38h31eccc5_0.tar.bz2": { + "build": "py38h31eccc5_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.4 py38h14f4228_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "98a76fca6def12df8b8a42173c22cec3", + "name": "numpy-base", + "sha256": "54dc400e2d585b89b49d4aa00846007833a054b92c201214f36df9e397f1851c", + "size": 7437425, + "subdir": "linux-64", + "timestamp": 1668593950327, + "version": "1.23.4" + }, + "numpy-base-1.23.4-py39h1e6e340_0.tar.bz2": { + "build": "py39h1e6e340_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.4 py39hf838250_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3493cadba04d9d6456d753c47507e281", + "name": "numpy-base", + "sha256": "4583d36b7b563caa52d9cc7d8d2f621ad6b7f0569104d533f761126bd86bed62", + "size": 7435272, + "subdir": "linux-64", + "timestamp": 1668598380771, + "version": "1.23.4" + }, + "numpy-base-1.23.4-py39h31eccc5_0.tar.bz2": { + "build": "py39h31eccc5_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.4 py39h14f4228_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ed313580352e9422fb51779aa52fb3f6", + "name": "numpy-base", + "sha256": "cc1b7f6533362d13d57cc3b62f4504da65772fa722e2aa1e67d149fbcde53bf0", + "size": 7435925, + "subdir": "linux-64", + "timestamp": 1668595062672, + "version": "1.23.4" + }, + "numpy-base-1.23.5-py310h375b286_0.tar.bz2": { + "build": "py310h375b286_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.5 py310hac523dd_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d9cd6aeedaef5f348fe0ad083d417e1d", + "name": "numpy-base", + "sha256": "d88c3b1cf90fb806168fc904f9bba81c2ff22683b0ff879581284506bf6d3e2d", + "size": 7439753, + "subdir": "linux-64", + "timestamp": 1672337449337, + "version": "1.23.5" + }, + "numpy-base-1.23.5-py310h8e6c178_0.tar.bz2": { + "build": "py310h8e6c178_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.5 py310hd5efca6_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0b83d92e243f71ca6c53c412240bc36e", + "name": "numpy-base", + "sha256": "e19b98aa257335a363b2366e5dbd4c981a1ded11a7be0b3ebeb6aca7d263bbe9", + "size": 7440271, + "subdir": "linux-64", + "timestamp": 1672340580564, + "version": "1.23.5" + }, + "numpy-base-1.23.5-py311h0ff3221_0.tar.bz2": { + "build": "py311h0ff3221_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.5 py311h75bd12f_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3f8761950e9e230c18d3767d3330c52b", + "name": "numpy-base", + "sha256": "796d75d5263462f9c41a070d3551e32fdefc5d316864475c4c07355b2ed08fa6", + "size": 8543635, + "subdir": "linux-64", + "timestamp": 1676824199179, + "version": "1.23.5" + }, + "numpy-base-1.23.5-py311hc9e7d78_0.tar.bz2": { + "build": "py311hc9e7d78_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.5 py311h5585df3_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "902290a8f963712671dbd2cf5502ac60", + "name": "numpy-base", + "sha256": "de94947da6a268a6bfb215bebcce876ba94488b63ba6403ac97d6d144d744e0e", + "size": 8543624, + "subdir": "linux-64", + "timestamp": 1676824030883, + "version": "1.23.5" + }, + "numpy-base-1.23.5-py38h1e6e340_0.tar.bz2": { + "build": "py38h1e6e340_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.5 py38hf838250_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "16fbcf318ce035c9fa868d2aa85f3612", + "name": "numpy-base", + "sha256": "6dc88cd9976c7acb77f66d28ebcfda98b28db3518dfd1202f6edf8d518ecdb85", + "size": 7472780, + "subdir": "linux-64", + "timestamp": 1672336374433, + "version": "1.23.5" + }, + "numpy-base-1.23.5-py38h31eccc5_0.tar.bz2": { + "build": "py38h31eccc5_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.5 py38h14f4228_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "863f31c1afa23990490151aecb9acc02", + "name": "numpy-base", + "sha256": "82d656441cf7edd302916406902d391f103eb9c91aed416162ca39c96da76599", + "size": 7471301, + "subdir": "linux-64", + "timestamp": 1672339505555, + "version": "1.23.5" + }, + "numpy-base-1.23.5-py39h1e6e340_0.tar.bz2": { + "build": "py39h1e6e340_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.5 py39hf838250_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4edc726414b113f2cf5c1cae085f8efc", + "name": "numpy-base", + "sha256": "30f2d898a1db33bfa9d14057ac94e494b463a22b13fdc824dcf95097d06eca6a", + "size": 7431794, + "subdir": "linux-64", + "timestamp": 1672338463726, + "version": "1.23.5" + }, + "numpy-base-1.23.5-py39h31eccc5_0.tar.bz2": { + "build": "py39h31eccc5_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.5 py39h14f4228_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a26ccab2dad237f8f99306372878e529", + "name": "numpy-base", + "sha256": "3e0ffa16e7a6c3654dfad7ba6027425c957006c26144b482748a5c417344c6a6", + "size": 7431255, + "subdir": "linux-64", + "timestamp": 1672341589882, + "version": "1.23.5" + }, + "numpy-base-1.9.3-py27h1793315_7.tar.bz2": { + "build": "py27h1793315_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "5913c42931897a1a09fe2be88cc02944", + "name": "numpy-base", + "sha256": "876681fc252fe7f07ba113abf5f4a12d63167a4c12b00334f5055343b98149f3", + "size": 3365352, + "subdir": "linux-64", + "timestamp": 1534512656226, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py27h2b20989_5.tar.bz2": { + "build": "py27h2b20989_5", + "build_number": 5, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "46684686fe26a1eac4b1dd1ace493d54", + "name": "numpy-base", + "sha256": "28294ad23aa4ffceeebcf45a7997aeeed36e34d2ad3c55c9b9b94287263158ed", + "size": 3373828, + "subdir": "linux-64", + "timestamp": 1530278910117, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py27h2b20989_6.tar.bz2": { + "build": "py27h2b20989_6", + "build_number": 6, + "constrains": [ + "numpy 1.9.3 py27h28100ab_6" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "ac67255030e874dacbb9d048a0df9ad3", + "name": "numpy-base", + "sha256": "6890bdb64c76538f110dfb4023016f4a867b83ac4c1b8254d3ab8a57c1ca4e51", + "size": 3377434, + "subdir": "linux-64", + "timestamp": 1530379403825, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py27h2b20989_7.tar.bz2": { + "build": "py27h2b20989_7", + "build_number": 7, + "constrains": [ + "numpy 1.9.3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "f8c80372008dc2816cf090023c998021", + "name": "numpy-base", + "sha256": "fded37afa60ba2d82ae82cffe387faba3de0b4bac3dc145cea53df431fb67ed9", + "size": 3374399, + "subdir": "linux-64", + "timestamp": 1530550385791, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py27hc937464_7.tar.bz2": { + "build": "py27hc937464_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "b466bc466237cc5f23819d856135a5be", + "name": "numpy-base", + "sha256": "761c24c9e306f2f6fe970cff811ef07c405750782a0fd67f7c7ae4edc29826ba", + "size": 3367514, + "subdir": "linux-64", + "timestamp": 1534773437988, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py27hdbf6ddf_5.tar.bz2": { + "build": "py27hdbf6ddf_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "a841837ffa14fe244460f9a9e9ae18d7", + "name": "numpy-base", + "sha256": "fdd338deed18e3f69dfba4f78796fa3a16a6873ccbfc4a7af1c0ff7640af09c3", + "size": 3373047, + "subdir": "linux-64", + "timestamp": 1530279148833, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py27hdbf6ddf_6.tar.bz2": { + "build": "py27hdbf6ddf_6", + "build_number": 6, + "constrains": [ + "numpy 1.9.3 py27hcd700cb_6" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "0bc5d9d9f3724e9c49cf44fde66e371f", + "name": "numpy-base", + "sha256": "f6cd1b8ec52893ac6fc71a039ccba9e8e083f834a641687da918afd8098537d9", + "size": 4745713, + "subdir": "linux-64", + "timestamp": 1530382812495, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py27hdbf6ddf_7.tar.bz2": { + "build": "py27hdbf6ddf_7", + "build_number": 7, + "constrains": [ + "numpy 1.9.3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "4149e8de2022c984d6c6d0fa90fd98b0", + "name": "numpy-base", + "sha256": "5978b0c7eb0f85db5995c93cbc20cee9743a48944fe3be9e08ca64063b9dbff8", + "size": 3373434, + "subdir": "linux-64", + "timestamp": 1530552937617, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py35h1793315_7.tar.bz2": { + "build": "py35h1793315_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "efe09249abcc4208e1c59c89f3ffe5c9", + "name": "numpy-base", + "sha256": "2b2628f223d96d9aac4c08ed4477032a6f4f9bff8caa90e0c6679fa8dee42018", + "size": 3405934, + "subdir": "linux-64", + "timestamp": 1534772969911, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py35h2b20989_7.tar.bz2": { + "build": "py35h2b20989_7", + "build_number": 7, + "constrains": [ + "numpy 1.9.3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "2933868cae8113505559f8cfd76cca34", + "name": "numpy-base", + "sha256": "7b1f733e0b63a618fe8cf0829f582a3e689c4c2f6deb8221b8e18c187962d365", + "size": 3410652, + "subdir": "linux-64", + "timestamp": 1530694195074, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py35hc937464_7.tar.bz2": { + "build": "py35hc937464_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "d34a861b76497ca68369f49dafa40a6c", + "name": "numpy-base", + "sha256": "2be27e460856986c593b23a24d398c13e68b6a458275b23d1c379b9dc937035d", + "size": 3407231, + "subdir": "linux-64", + "timestamp": 1534773213666, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py35hdbf6ddf_7.tar.bz2": { + "build": "py35hdbf6ddf_7", + "build_number": 7, + "constrains": [ + "numpy 1.9.3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "9ffe5150cc396648645a93e7c5d17160", + "name": "numpy-base", + "sha256": "674c285dfc1cf6f05698177fdbf5074fb97def85e16c063e61c03831268c595d", + "size": 3409240, + "subdir": "linux-64", + "timestamp": 1530694422519, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py36h1793315_7.tar.bz2": { + "build": "py36h1793315_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "9f78a4c68fa88f307a9d8ddacf63838a", + "name": "numpy-base", + "sha256": "02be9da2095dd7b05b2229071080963196a964a42fe31f5f678a9da9bef66217", + "size": 3420464, + "subdir": "linux-64", + "timestamp": 1534773665035, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py36h2b20989_5.tar.bz2": { + "build": "py36h2b20989_5", + "build_number": 5, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "f45b572228e4017fb4b8d3e9012f4b10", + "name": "numpy-base", + "sha256": "dacdfd75b6ad5471623adef9581166f5332c05ed510186986fd9528ef19874ea", + "size": 3417844, + "subdir": "linux-64", + "timestamp": 1530278902183, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py36h2b20989_6.tar.bz2": { + "build": "py36h2b20989_6", + "build_number": 6, + "constrains": [ + "numpy 1.9.3 py36h28100ab_6" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "0b5bf4a08b4309acedab55e27b15aab4", + "name": "numpy-base", + "sha256": "6da99811560599f4d88fdc9d05a21d9cbdb8838dbe29c3874c1a68f0564b4abc", + "size": 3416010, + "subdir": "linux-64", + "timestamp": 1530380183640, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py36h2b20989_7.tar.bz2": { + "build": "py36h2b20989_7", + "build_number": 7, + "constrains": [ + "numpy 1.9.3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "9af3cdcfc5da9bd7af6f831ba4d72ca5", + "name": "numpy-base", + "sha256": "ca086a9088af815a3182ad7c5db19de5cee5c7c951c56febb5bc73bfef4fab89", + "size": 3417462, + "subdir": "linux-64", + "timestamp": 1530550409615, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py36hc937464_7.tar.bz2": { + "build": "py36hc937464_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "97664d9e767bc8f891ea701075838d1c", + "name": "numpy-base", + "sha256": "d83ff0f957016062ad5204659e99e4d8bc6a4e8089d7f468ede73d2f62f3d5aa", + "size": 3419449, + "subdir": "linux-64", + "timestamp": 1534773898366, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py36hdbf6ddf_5.tar.bz2": { + "build": "py36hdbf6ddf_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "b95234deb63de34d7688bafdf4ecfe86", + "name": "numpy-base", + "sha256": "c50016a043c12267b78c469c1ef1af392866a8f3f01180534e04f27a250a1b41", + "size": 3417564, + "subdir": "linux-64", + "timestamp": 1530279203667, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py36hdbf6ddf_6.tar.bz2": { + "build": "py36hdbf6ddf_6", + "build_number": 6, + "constrains": [ + "numpy 1.9.3 py36hcd700cb_6" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "bf2b0f2caba9264c5b224da2dcd9e9a9", + "name": "numpy-base", + "sha256": "5f8f6de158bc621c1178a79b0ebbce2b11e0bac0b9282bc9553fe3b661e68167", + "size": 4820041, + "subdir": "linux-64", + "timestamp": 1530383205268, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py36hdbf6ddf_7.tar.bz2": { + "build": "py36hdbf6ddf_7", + "build_number": 7, + "constrains": [ + "numpy 1.9.3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "8e7c118a16988c6dd407c5d7d6d1c312", + "name": "numpy-base", + "sha256": "12a7e522f81aa6c16a7d9213a1f7709a199f79516d283c6930f8d1af187f0142", + "size": 3417447, + "subdir": "linux-64", + "timestamp": 1530553092861, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py37h1793315_7.tar.bz2": { + "build": "py37h1793315_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "8cd5f4ff34e1d33e603e790dfc4e6da5", + "name": "numpy-base", + "sha256": "410ef1648c3400215d8cd4539d80be9491a70385b614dc4222489d8b07ad5c6b", + "size": 3403440, + "subdir": "linux-64", + "timestamp": 1534774128123, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py37h2b20989_5.tar.bz2": { + "build": "py37h2b20989_5", + "build_number": 5, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "e6fd864c3d54a4d169a7f158ff2169c5", + "name": "numpy-base", + "sha256": "39611c8ae6cf34429b78fe770f8e95affe48c4b39f79ad09874027569780369c", + "size": 3404163, + "subdir": "linux-64", + "timestamp": 1530278961848, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py37h2b20989_6.tar.bz2": { + "build": "py37h2b20989_6", + "build_number": 6, + "constrains": [ + "numpy 1.9.3 py37h28100ab_6" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "5534ea4219377f61bbc69026c11d5e1a", + "name": "numpy-base", + "sha256": "4558971e2f1ef5a75d5d30dafefd60445980773038997f26d801d5ca712aae06", + "size": 3404553, + "subdir": "linux-64", + "timestamp": 1530380489567, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py37h2b20989_7.tar.bz2": { + "build": "py37h2b20989_7", + "build_number": 7, + "constrains": [ + "numpy 1.9.3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "56eccaa1fb8e04470658ee7acfcd6789", + "name": "numpy-base", + "sha256": "781eb9eb175d6881bb26e65a28be8e8450992b04e4f244a9ee62e1bf45e687fe", + "size": 3404591, + "subdir": "linux-64", + "timestamp": 1530550707727, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py37hc937464_7.tar.bz2": { + "build": "py37hc937464_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "ab77456ceec0da8f07502857270fe245", + "name": "numpy-base", + "sha256": "7d49618e32d15008d86b5646d78757198ab6264b2c6cf96087e8a7ac9d4a23a7", + "size": 3402040, + "subdir": "linux-64", + "timestamp": 1534774368143, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py37hdbf6ddf_5.tar.bz2": { + "build": "py37hdbf6ddf_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "6ab7394de0cd81f4e657a6c089cb0d47", + "name": "numpy-base", + "sha256": "4aa4faf2ea7c21253884f72be8aa42c0407a90195472d1a67149b398bfeac569", + "size": 3403840, + "subdir": "linux-64", + "timestamp": 1530279157175, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py37hdbf6ddf_6.tar.bz2": { + "build": "py37hdbf6ddf_6", + "build_number": 6, + "constrains": [ + "numpy 1.9.3 py37hcd700cb_6" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "550d1092d060133c827cc4e4571a807f", + "name": "numpy-base", + "sha256": "8a4dce2d35aa90dd627951a1e13cd1147cc5573cdf8a1dbfce596a350f58a909", + "size": 4789545, + "subdir": "linux-64", + "timestamp": 1530382457985, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py37hdbf6ddf_7.tar.bz2": { + "build": "py37hdbf6ddf_7", + "build_number": 7, + "constrains": [ + "numpy 1.9.3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "b0362ed797ae616ec57bdcb701cad785", + "name": "numpy-base", + "sha256": "dd4cb7a4375d7f136a43ad3f1f4134c82faeb2b7167cb995f4b7bf98a6e1b9c8", + "size": 3404971, + "subdir": "linux-64", + "timestamp": 1530553299002, + "version": "1.9.3" + }, + "numpy-devel-1.11.3-h025eb46_7.tar.bz2": { + "build": "h025eb46_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.11.3 py36h2b20989_7" + ], + "md5": "5d76734a3faa6aa99110af46d271de2e", + "name": "numpy-devel", + "namespace": "python", + "sha256": "01378fd6dba666892ed3d16f3705f2cbc5584bf9bb77bbdea256bfafa3f8b36b", + "size": 9389, + "subdir": "linux-64", + "timestamp": 1530381427032, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-h025eb46_8.tar.bz2": { + "build": "h025eb46_8", + "build_number": 8, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.11.3 py36h2b20989_8" + ], + "md5": "583a1d8b31ef28fba8f707d9ce024f4e", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2480d683918d315bfaf1d02076d5a429449dc10f80f105b6c0eff0977c4395d4", + "size": 9825, + "subdir": "linux-64", + "timestamp": 1530551408338, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-ha22f7c6_7.tar.bz2": { + "build": "ha22f7c6_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py37hdbf6ddf_7" + ], + "md5": "366051a6279710a822bd0a000c5bcb34", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6a2b925b5bcc2ac08fee374b3742a87700b40a8dfd47767a6843099176e32710", + "size": 9379, + "subdir": "linux-64", + "timestamp": 1530382848807, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-ha22f7c6_8.tar.bz2": { + "build": "ha22f7c6_8", + "build_number": 8, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py37hdbf6ddf_8" + ], + "md5": "19dab99ab665817879d3da73e1fa5705", + "name": "numpy-devel", + "namespace": "python", + "sha256": "8b4fc4d82fa5aa143f497e77b5f0f0605313eccb672624b2f1393a4e1b2f8dd5", + "size": 9800, + "subdir": "linux-64", + "timestamp": 1530554148759, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h008b2eb_10.tar.bz2": { + "build": "py27h008b2eb_10", + "build_number": 10, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py27h2f8d375_10", + "python >=2.7,<2.8.0a0" + ], + "md5": "b8b16344ad8d7a515ed7cb16adc13b6c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2973d46ca8b0698acfaea81c2617157c9145b847a63f524da5996bacb468a03c", + "size": 9926, + "subdir": "linux-64", + "timestamp": 1536892585777, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h008b2eb_11.tar.bz2": { + "build": "py27h008b2eb_11", + "build_number": 11, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py27h2f8d375_11", + "python >=2.7,<2.8.0a0" + ], + "md5": "dc721fd48d55a625fd7a7e88b581f8fe", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f1d0ccc8dcfcc58164ae413ec999efb064e4fd714f642237ea4b4f0ad320a1aa", + "size": 14336, + "subdir": "linux-64", + "timestamp": 1544631982195, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h008b2eb_12.tar.bz2": { + "build": "py27h008b2eb_12", + "build_number": 12, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py27h2f8d375_12", + "python >=2.7,<2.8.0a0" + ], + "md5": "f9b9c687e553563ab8cfe1c67081d512", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b451ba14b364445a153bf63439d42505a2580eb2636b188d20ea8075f9133a14", + "size": 14810, + "subdir": "linux-64", + "timestamp": 1544762994853, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h4ba5984_11.tar.bz2": { + "build": "py27h4ba5984_11", + "build_number": 11, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py27hde5b4d6_11", + "python >=2.7,<2.8.0a0" + ], + "md5": "f5a3cc81932a53467de4878017f95232", + "name": "numpy-devel", + "namespace": "python", + "sha256": "210cd4e7062db1d47b36e9bf8d2dc9b0ce7095fc5448ef10d12ecb756ff21522", + "size": 14329, + "subdir": "linux-64", + "timestamp": 1544632852352, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h4ba5984_12.tar.bz2": { + "build": "py27h4ba5984_12", + "build_number": 12, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py27hde5b4d6_12", + "python >=2.7,<2.8.0a0" + ], + "md5": "d3bb8e8e5d086c7495fddd24afb4bc7b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "bb2fc53b4a9dca345a6b4aec581b11ba4b4fb65f750afa57896066b086f83a2f", + "size": 14806, + "subdir": "linux-64", + "timestamp": 1544763191362, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h55f8cf0_10.tar.bz2": { + "build": "py27h55f8cf0_10", + "build_number": 10, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py27h74e8950_10", + "python >=2.7,<2.8.0a0" + ], + "md5": "913dba7d257e47431f1455710845bf85", + "name": "numpy-devel", + "namespace": "python", + "sha256": "53a06992d577fb2f50caed8b2b3cc5a9171959a34514c20afd222df24905f6e9", + "size": 9678, + "subdir": "linux-64", + "timestamp": 1535405721079, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h55f8cf0_9.tar.bz2": { + "build": "py27h55f8cf0_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py27h74e8950_9", + "python >=2.7,<2.8.0a0" + ], + "md5": "6ade1c3ddc38a2888d3129a44cbfc5fd", + "name": "numpy-devel", + "namespace": "python", + "sha256": "8e56dad780d2cebe00ad06ed7e6d9d59eec930720a1af6330c34d40be8712d05", + "size": 9619, + "subdir": "linux-64", + "timestamp": 1535388183373, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h6bdb83d_10.tar.bz2": { + "build": "py27h6bdb83d_10", + "build_number": 10, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py27h81de0dd_10", + "python >=2.7,<2.8.0a0" + ], + "md5": "c5c72900d756a2b9a217c72b95f4fd6d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "08973e8ddf602edfc15e8343951e365071f718e3a12ab92e1a6236741126de78", + "size": 9647, + "subdir": "linux-64", + "timestamp": 1535405844328, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h6bdb83d_9.tar.bz2": { + "build": "py27h6bdb83d_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py27h3dfced4_9", + "python >=2.7,<2.8.0a0" + ], + "md5": "e5822432ebcc80780d561c2d0d73f38f", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0c69817b74c091816425873c8b09055928b6ada3b676982b6ee216363a4a9659", + "size": 9328, + "subdir": "linux-64", + "timestamp": 1532661349366, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h8f55a68_9.tar.bz2": { + "build": "py27h8f55a68_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py27hc937464_9", + "python >=2.7,<2.8.0a0" + ], + "md5": "3e4526923ded47d7e75a805868928f94", + "name": "numpy-devel", + "namespace": "python", + "sha256": "58e721d986b13f073cdddfba0cd85df6d52deaeb2bb7f9dab5399c42db32f3fd", + "size": 9129, + "subdir": "linux-64", + "timestamp": 1534775228228, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h99ba2d1_9.tar.bz2": { + "build": "py27h99ba2d1_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py27h1793315_9", + "python >=2.7,<2.8.0a0" + ], + "md5": "6718449ab9b44127d8aa30620dd82994", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ee83a3177dbd4a69f4075eb054b6bcbc76b5967d9553d1d22d4c486ca9fd9f47", + "size": 9127, + "subdir": "linux-64", + "timestamp": 1534775035254, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27he073198_9.tar.bz2": { + "build": "py27he073198_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.11.3 py27h7cdd4dd_9", + "python >=2.7,<2.8.0a0" + ], + "md5": "97bcbf5414e5046c353ab535199cbd87", + "name": "numpy-devel", + "namespace": "python", + "sha256": "77622b6e6db95537c9c5e65fc227e1d126184c11bdcc4ad4a3d25f04018e96f0", + "size": 9337, + "subdir": "linux-64", + "timestamp": 1532660248568, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py35h008b2eb_10.tar.bz2": { + "build": "py35h008b2eb_10", + "build_number": 10, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py35h2f8d375_10", + "python >=3.5,<3.6.0a0" + ], + "md5": "84b8b368b7e14ee0a761a970b37cc15a", + "name": "numpy-devel", + "namespace": "python", + "sha256": "aa6203b361373d52213bd82b1bdbe76395ec7e9183e5f418e7440879344e9dfe", + "size": 9938, + "subdir": "linux-64", + "timestamp": 1536892619006, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py35h55f8cf0_10.tar.bz2": { + "build": "py35h55f8cf0_10", + "build_number": 10, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py35h74e8950_10", + "python >=3.5,<3.6.0a0" + ], + "md5": "ec1240331b9691d3adc3761d8826f725", + "name": "numpy-devel", + "namespace": "python", + "sha256": "56017b4ba5d2dc64c7e54d7568cad2a32c495ac4b7424da2d397991e69452bce", + "size": 9686, + "subdir": "linux-64", + "timestamp": 1535405695848, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py35h55f8cf0_9.tar.bz2": { + "build": "py35h55f8cf0_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py35h74e8950_9", + "python >=3.5,<3.6.0a0" + ], + "md5": "d70481071decb055e5356719dae875b2", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6e342448c38f7c57e63886d5cc327840dbaa6f60627d363e759834b9f19205f9", + "size": 9622, + "subdir": "linux-64", + "timestamp": 1535388581111, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py35h6bdb83d_10.tar.bz2": { + "build": "py35h6bdb83d_10", + "build_number": 10, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py35h81de0dd_10", + "python >=3.5,<3.6.0a0" + ], + "md5": "1d11951a948a472e5d84ca7a8e7ad635", + "name": "numpy-devel", + "namespace": "python", + "sha256": "8729e665d0f4163f80abf3efe372e08397b8ebe4252c34809d2d0294c9d6d898", + "size": 9649, + "subdir": "linux-64", + "timestamp": 1535406574519, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py35h6bdb83d_9.tar.bz2": { + "build": "py35h6bdb83d_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py35h3dfced4_9", + "python >=3.5,<3.6.0a0" + ], + "md5": "ad82b9d6c567bc07255a3dee33a3c588", + "name": "numpy-devel", + "namespace": "python", + "sha256": "00b40506fb67878b511ae4f9809229db00f6142cfafd3933ac388f374cd078b6", + "size": 9314, + "subdir": "linux-64", + "timestamp": 1532661311670, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py35h8f55a68_9.tar.bz2": { + "build": "py35h8f55a68_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py35hc937464_9", + "python >=3.5,<3.6.0a0" + ], + "md5": "1e47629a77791e7516710cac1e4ab293", + "name": "numpy-devel", + "namespace": "python", + "sha256": "42d3b1157910570ffd65882b61e47fcda8dcdda7b189ad932f6feac5b0cfe68d", + "size": 9146, + "subdir": "linux-64", + "timestamp": 1534774842509, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py35h99ba2d1_9.tar.bz2": { + "build": "py35h99ba2d1_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py35h1793315_9", + "python >=3.5,<3.6.0a0" + ], + "md5": "7d4caad4badbd665a164ebd177cf47be", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0186207f8ff6b07a2254a00d195ebd30f5e3cb82f74673f1e676ca6c4c2ceb4a", + "size": 9131, + "subdir": "linux-64", + "timestamp": 1534774640284, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py35he073198_9.tar.bz2": { + "build": "py35he073198_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.11.3 py35h7cdd4dd_9", + "python >=3.5,<3.6.0a0" + ], + "md5": "c522f8f089b425f71ae58b7171e8690e", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ac052b13690ecd1d52d5c5f056a9e27b3f6d97c89a816b31e1a1c13e26a4e194", + "size": 9313, + "subdir": "linux-64", + "timestamp": 1532660222243, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h008b2eb_10.tar.bz2": { + "build": "py36h008b2eb_10", + "build_number": 10, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py36h2f8d375_10", + "python >=3.6,<3.7.0a0" + ], + "md5": "7d09ebce9189ab2e24ca9de8420937eb", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b47942a199bda47d50064dfecebd58a5d8c94c276b0c0d649915a9ebc931f1a4", + "size": 9903, + "subdir": "linux-64", + "timestamp": 1536892551198, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h008b2eb_11.tar.bz2": { + "build": "py36h008b2eb_11", + "build_number": 11, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py36h2f8d375_11", + "python >=3.6,<3.7.0a0" + ], + "md5": "9f092d2af486986358bbad60efca9565", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b14bac72ec7461cf3b694e8d0f0b4567e4e304d8ddb79bf0fba24a618ad0cc8c", + "size": 14319, + "subdir": "linux-64", + "timestamp": 1544632148643, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h008b2eb_12.tar.bz2": { + "build": "py36h008b2eb_12", + "build_number": 12, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py36h2f8d375_12", + "python >=3.6,<3.7.0a0" + ], + "md5": "9c0e1afe0d4cbead34337ff7c635b2b9", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7d70dfffe173af862326ebcc4002b1b3ebbde7129dead7cd0e618efa2e6e9b67", + "size": 14800, + "subdir": "linux-64", + "timestamp": 1544763157700, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h4ba5984_11.tar.bz2": { + "build": "py36h4ba5984_11", + "build_number": 11, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py36hde5b4d6_11", + "python >=3.6,<3.7.0a0" + ], + "md5": "8985cb490c7ea46d458b8d4b070b48ee", + "name": "numpy-devel", + "namespace": "python", + "sha256": "afe97fb0cf420e292c8a60b7407cfcbfc7264039f8396671e7d4a60a86f45c92", + "size": 14333, + "subdir": "linux-64", + "timestamp": 1544632758293, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h4ba5984_12.tar.bz2": { + "build": "py36h4ba5984_12", + "build_number": 12, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py36hde5b4d6_12", + "python >=3.6,<3.7.0a0" + ], + "md5": "18e0d350a3d498b23e53fc0c4752ef5b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a7a3ff470ff66c18e4701ec00c65198e91e3d82e316eb1454a1b5553b99405bc", + "size": 14785, + "subdir": "linux-64", + "timestamp": 1544763352024, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h55f8cf0_10.tar.bz2": { + "build": "py36h55f8cf0_10", + "build_number": 10, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py36h74e8950_10", + "python >=3.6,<3.7.0a0" + ], + "md5": "7afd9950c9e52b74d2d59c131421dc29", + "name": "numpy-devel", + "namespace": "python", + "sha256": "d7b85ca746a07ef1e58648204684be2c7e2e96c1a4d1cf645abca1ba3c384074", + "size": 9669, + "subdir": "linux-64", + "timestamp": 1535405729837, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h55f8cf0_9.tar.bz2": { + "build": "py36h55f8cf0_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py36h74e8950_9", + "python >=3.6,<3.7.0a0" + ], + "md5": "ef23daec17b1b6f1864ad31435530aea", + "name": "numpy-devel", + "namespace": "python", + "sha256": "63bc769294f3cbbb67fb45dc5c62075bf7a75248f0b11011059a81dadf9c6691", + "size": 9637, + "subdir": "linux-64", + "timestamp": 1535388644978, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h6bdb83d_10.tar.bz2": { + "build": "py36h6bdb83d_10", + "build_number": 10, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py36h81de0dd_10", + "python >=3.6,<3.7.0a0" + ], + "md5": "f0a67b1bf63d2a3006fcbdea5e10d34a", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7c13ce46f108979c2928777c1851ec6c5089fb1d42580bf00f3db68ce6ecf63d", + "size": 9647, + "subdir": "linux-64", + "timestamp": 1535405871358, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h6bdb83d_9.tar.bz2": { + "build": "py36h6bdb83d_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py36h3dfced4_9", + "python >=3.6,<3.7.0a0" + ], + "md5": "0cf25a76e7e6e1b69174dc69f4c24756", + "name": "numpy-devel", + "namespace": "python", + "sha256": "c72998bf2c56fd979de27d9c7f34538afcc6ab27222731eb15bdc3da697c2f29", + "size": 9346, + "subdir": "linux-64", + "timestamp": 1532661281595, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h8f55a68_9.tar.bz2": { + "build": "py36h8f55a68_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py36hc937464_9", + "python >=3.6,<3.7.0a0" + ], + "md5": "a46448facc8bacaf18b8e888a66ddc76", + "name": "numpy-devel", + "namespace": "python", + "sha256": "22bfebb49984ebd00eadfa979ba0b19b610db61b44bfc7de449db196af63ed74", + "size": 9132, + "subdir": "linux-64", + "timestamp": 1534775629834, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h99ba2d1_9.tar.bz2": { + "build": "py36h99ba2d1_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py36h1793315_9", + "python >=3.6,<3.7.0a0" + ], + "md5": "8f1071847fbe881daa25045ee3956172", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f05720318e8e3e91eb9d0495f0d5a9f48cd26fd8234597059ae04a5532c10c9d", + "size": 9135, + "subdir": "linux-64", + "timestamp": 1534775432374, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36he073198_9.tar.bz2": { + "build": "py36he073198_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.11.3 py36h7cdd4dd_9", + "python >=3.6,<3.7.0a0" + ], + "md5": "c37e9b91ee90b969019989b62b637449", + "name": "numpy-devel", + "namespace": "python", + "sha256": "4df607e1ea2f8a0ace6635ecc4a351ed05df1b1c231c9669b1e8b33ee790efae", + "size": 9316, + "subdir": "linux-64", + "timestamp": 1532660189572, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h008b2eb_10.tar.bz2": { + "build": "py37h008b2eb_10", + "build_number": 10, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py37h2f8d375_10", + "python >=3.7,<3.8.0a0" + ], + "md5": "ecfce7adada2289641d00a9101020ff7", + "name": "numpy-devel", + "namespace": "python", + "sha256": "93f1d2e355baefed348de99f07ef14b7491a5fa0774dc477a541b4a80811fd75", + "size": 9939, + "subdir": "linux-64", + "timestamp": 1536892546190, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h008b2eb_11.tar.bz2": { + "build": "py37h008b2eb_11", + "build_number": 11, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py37h2f8d375_11", + "python >=3.7,<3.8.0a0" + ], + "md5": "2b72bcaf97a393b6d33a69fa83dbdcd8", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2c370cf7aa8e1a9fd730b592ee740ebd4f7344fbdc679773c4cd16f200f9f8e2", + "size": 14315, + "subdir": "linux-64", + "timestamp": 1544631880123, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h008b2eb_12.tar.bz2": { + "build": "py37h008b2eb_12", + "build_number": 12, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py37h2f8d375_12", + "python >=3.7,<3.8.0a0" + ], + "md5": "959966b73b56abd0ac8105e34832bd1a", + "name": "numpy-devel", + "namespace": "python", + "sha256": "bb93729fbd2d3764021fe49bbb9be3ce390fef12b3e7e420c4ef18ecca3a1191", + "size": 14803, + "subdir": "linux-64", + "timestamp": 1544762992014, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h4ba5984_11.tar.bz2": { + "build": "py37h4ba5984_11", + "build_number": 11, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py37hde5b4d6_11", + "python >=3.7,<3.8.0a0" + ], + "md5": "3cba2bc83e8107b526eaf6b3ef525350", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2f339c254df57451acc0c3762df4e7e75f405539ab8c57f8fc07cf08edb54804", + "size": 14309, + "subdir": "linux-64", + "timestamp": 1544632790474, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h4ba5984_12.tar.bz2": { + "build": "py37h4ba5984_12", + "build_number": 12, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py37hde5b4d6_12", + "python >=3.7,<3.8.0a0" + ], + "md5": "d87d5366d3e1fbd066aec300bfa6dc16", + "name": "numpy-devel", + "namespace": "python", + "sha256": "3fe531379f34c55e27c29934219627d38d380f871802c70d874cbc6ec4639276", + "size": 14803, + "subdir": "linux-64", + "timestamp": 1544763274876, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h55f8cf0_10.tar.bz2": { + "build": "py37h55f8cf0_10", + "build_number": 10, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py37h74e8950_10", + "python >=3.7,<3.8.0a0" + ], + "md5": "1f6c7b8fdd72f182fd757c420600a2ba", + "name": "numpy-devel", + "namespace": "python", + "sha256": "8f86f83bf3f9c6678f3ae6749c24cc28d48aa0b462894671c83f4ae755547388", + "size": 9672, + "subdir": "linux-64", + "timestamp": 1535405086745, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h55f8cf0_9.tar.bz2": { + "build": "py37h55f8cf0_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py37h74e8950_9", + "python >=3.7,<3.8.0a0" + ], + "md5": "6c10b2483ecbe75438cd3414f2e0c712", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e42bbdbacc97c47dc26d1a70b6628bafc15a067b4e3353c9e93c90cc340f180c", + "size": 9628, + "subdir": "linux-64", + "timestamp": 1535388607297, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h6bdb83d_10.tar.bz2": { + "build": "py37h6bdb83d_10", + "build_number": 10, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py37h81de0dd_10", + "python >=3.7,<3.8.0a0" + ], + "md5": "014ab28cbcfaa46a7d6addf0d150d11b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f6a303d2a1c07f229379b5553a5d83efc0e4fd473515b5586650d75fc45014cb", + "size": 9668, + "subdir": "linux-64", + "timestamp": 1535405871621, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h6bdb83d_9.tar.bz2": { + "build": "py37h6bdb83d_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py37h3dfced4_9", + "python >=3.7,<3.8.0a0" + ], + "md5": "eddef90268cf366bde9fa9a78e75e1dd", + "name": "numpy-devel", + "namespace": "python", + "sha256": "972f52d035e8c34a87c74c975c0b007e7d38c48c2baa2f4a0738c7c9dbf38378", + "size": 9295, + "subdir": "linux-64", + "timestamp": 1532661075280, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h8f55a68_9.tar.bz2": { + "build": "py37h8f55a68_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py37hc937464_9", + "python >=3.7,<3.8.0a0" + ], + "md5": "bb1ff328ea070e4c40b34b63242842a6", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b9cf5f586711d938619d295988288091f37cb4d6c810fa2153427e96739513a7", + "size": 9138, + "subdir": "linux-64", + "timestamp": 1534776029870, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h99ba2d1_9.tar.bz2": { + "build": "py37h99ba2d1_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py37h1793315_9", + "python >=3.7,<3.8.0a0" + ], + "md5": "5c32797ab85b11dac419aa838a7bfcaa", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6da57b154d3930d6f064312358d790c8b376f63123728e0ac7105aef1c10c932", + "size": 9139, + "subdir": "linux-64", + "timestamp": 1534775827979, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37he073198_9.tar.bz2": { + "build": "py37he073198_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.11.3 py37h7cdd4dd_9", + "python >=3.7,<3.8.0a0" + ], + "md5": "5f12b71edd9521f4e9c44145250c5567", + "name": "numpy-devel", + "namespace": "python", + "sha256": "1498fe377c948cd5090b4f10c173b461e16e6edb746e2ef9de0d54ac2a76dd3c", + "size": 9326, + "subdir": "linux-64", + "timestamp": 1532660242751, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py38h008b2eb_12.tar.bz2": { + "build": "py38h008b2eb_12", + "build_number": 12, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py38h2f8d375_12", + "python >=3.8,<3.9.0a0" + ], + "md5": "4cceb3b17fbe3c725dd61d3a303047f2", + "name": "numpy-devel", + "namespace": "python", + "sha256": "29e5f195238423e5ca1a259dd42294d34d3b02549a23bb871d1c0c05f07b3534", + "size": 11014, + "subdir": "linux-64", + "timestamp": 1572609739590, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py38h4ba5984_12.tar.bz2": { + "build": "py38h4ba5984_12", + "build_number": 12, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.11.3 py38hde5b4d6_12", + "python >=3.8,<3.9.0a0" + ], + "md5": "f527106d1109a68bb12aa3bb82e16530", + "name": "numpy-devel", + "namespace": "python", + "sha256": "fc0afdad2994b7ede24e87b4e73528595204f6097d1de6f247fd0bd6aec1d0eb", + "size": 11028, + "subdir": "linux-64", + "timestamp": 1572609516189, + "version": "1.11.3" + }, + "numpy-devel-1.14.4-py27h025eb46_0.tar.bz2": { + "build": "py27h025eb46_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.4 py27h2b20989_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "4cb7797bfb658198a8651138ee871027", + "name": "numpy-devel", + "namespace": "python", + "sha256": "740f2e4ceb9a46e5bd9995900b1d9919822ba19ae62f357b08b98f82eb97b5b7", + "size": 99892, + "subdir": "linux-64", + "timestamp": 1528829309281, + "version": "1.14.4" + }, + "numpy-devel-1.14.4-py27ha22f7c6_0.tar.bz2": { + "build": "py27ha22f7c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.4 py27hdbf6ddf_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "fab2ecc6ca482eb62335e2b2f2663f40", + "name": "numpy-devel", + "namespace": "python", + "sha256": "d530f3721726551e0cd74bb02a0db5ea4b7e4be6f6d495b9045d89404011c77e", + "size": 99987, + "subdir": "linux-64", + "timestamp": 1528829775643, + "version": "1.14.4" + }, + "numpy-devel-1.14.4-py35h025eb46_0.tar.bz2": { + "build": "py35h025eb46_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.4 py35h2b20989_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "c8366207546b64de8b9d0e924b92c322", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ea2fde253d5421af454f54445b02c05ff759525478e11c5f1183b77f1671f3e1", + "size": 99879, + "subdir": "linux-64", + "timestamp": 1528829372965, + "version": "1.14.4" + }, + "numpy-devel-1.14.4-py35ha22f7c6_0.tar.bz2": { + "build": "py35ha22f7c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.4 py35hdbf6ddf_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "cef118e95140625e44dd1de9a41557c5", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a44e0e478463018157c39fe2261fc11fb4ecfc5dcf70ce5636af87a639dafeda", + "size": 100016, + "subdir": "linux-64", + "timestamp": 1528829876956, + "version": "1.14.4" + }, + "numpy-devel-1.14.4-py36h025eb46_0.tar.bz2": { + "build": "py36h025eb46_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.4 py36h2b20989_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "ff82cab35255250bf38893df867aba0a", + "name": "numpy-devel", + "namespace": "python", + "sha256": "4fa8cc7c88f28f9ef88bdfc77ef6c9ed3794d4809c3b51aecbc2b437f701e639", + "size": 99885, + "subdir": "linux-64", + "timestamp": 1528829332530, + "version": "1.14.4" + }, + "numpy-devel-1.14.4-py36ha22f7c6_0.tar.bz2": { + "build": "py36ha22f7c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.4 py36hdbf6ddf_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "0d3c91603904fe43e7e7369611cfaec4", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6c0b7a818e77f3c324b6ce792933866d13a814f059737efcaf50ca7e6caa84c4", + "size": 100008, + "subdir": "linux-64", + "timestamp": 1528829814533, + "version": "1.14.4" + }, + "numpy-devel-1.14.5-py27h025eb46_0.tar.bz2": { + "build": "py27h025eb46_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py27h2b20989_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "bf0535833926c1e5ddd89757d3095f9f", + "name": "numpy-devel", + "namespace": "python", + "sha256": "9cc4f193cd7f43382ea70d66cc3de04a8006bc59dadff0a4005798f9f11ed36c", + "size": 94646, + "subdir": "linux-64", + "timestamp": 1528900980980, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py27h025eb46_1.tar.bz2": { + "build": "py27h025eb46_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py27h2b20989_1", + "python >=2.7,<2.8.0a0" + ], + "md5": "7544796a02f236db2836ef7e84c84d84", + "name": "numpy-devel", + "namespace": "python", + "sha256": "681327861c455a7ef61c0d72ebb9342419549d29dd5dcbadbf30ee4c1b0f1e98", + "size": 94494, + "subdir": "linux-64", + "timestamp": 1530354214761, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py27h025eb46_2.tar.bz2": { + "build": "py27h025eb46_2", + "build_number": 2, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py27h2b20989_2", + "python >=2.7,<2.8.0a0" + ], + "md5": "7b0fa848d5af0a7567fb6a91ecd47de3", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b171b246181aad5e5266132003ae9d1cca271694e715802093ca15584ba0432f", + "size": 94327, + "subdir": "linux-64", + "timestamp": 1530382407056, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py27h025eb46_3.tar.bz2": { + "build": "py27h025eb46_3", + "build_number": 3, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py27h2b20989_3", + "python >=2.7,<2.8.0a0" + ], + "md5": "e38c15517b0aa9817b6e62fbaefe751f", + "name": "numpy-devel", + "namespace": "python", + "sha256": "22775715cf09bcafa750842cefbdf4dea0465c637b9ca460e9a101f34dbffa37", + "size": 94427, + "subdir": "linux-64", + "timestamp": 1530553954780, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py27h025eb46_4.tar.bz2": { + "build": "py27h025eb46_4", + "build_number": 4, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py27h2b20989_4", + "python >=2.7,<2.8.0a0" + ], + "md5": "8741ee0e3c5cabae93ddb82b76a1ccc1", + "name": "numpy-devel", + "namespace": "python", + "sha256": "376364720037add9e00846232c367c3ad6f66ee74a6157025fd12707ec3b1ac7", + "size": 34736, + "subdir": "linux-64", + "timestamp": 1531326458226, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py27ha22f7c6_0.tar.bz2": { + "build": "py27ha22f7c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py27hdbf6ddf_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "b43600ae6ea02c4551b7cfe4da64447c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f144f8b9045fbdfbc47d90dcacf1745dc1b2450651131ed7165c66679c64b59f", + "size": 94894, + "subdir": "linux-64", + "timestamp": 1528901320875, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py27ha22f7c6_1.tar.bz2": { + "build": "py27ha22f7c6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py27hdbf6ddf_1", + "python >=2.7,<2.8.0a0" + ], + "md5": "d87f9b6bc5ad5fe73c8a475866470edb", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2c1a7426c086446bd8670fbb264bf22d359ac7eff4fb40b007dd7c375c260ddd", + "size": 94659, + "subdir": "linux-64", + "timestamp": 1530353597493, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py27ha22f7c6_2.tar.bz2": { + "build": "py27ha22f7c6_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py27hdbf6ddf_2", + "python >=2.7,<2.8.0a0" + ], + "md5": "01ba98e633d9f79153e575aa3f3c2737", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6d77f748f757bf9e0399be8a85e80a6cdd750231d5a298b1fd283d3cec14f98a", + "size": 94398, + "subdir": "linux-64", + "timestamp": 1530383269906, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py27ha22f7c6_3.tar.bz2": { + "build": "py27ha22f7c6_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py27hdbf6ddf_3", + "python >=2.7,<2.8.0a0" + ], + "md5": "8c7f3e2d1803603428bf9f81be10ddf3", + "name": "numpy-devel", + "namespace": "python", + "sha256": "421b76937711207720adc9f62c3ceadfeb8e58072a036092b57f6331f687f0ee", + "size": 94464, + "subdir": "linux-64", + "timestamp": 1530554471956, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py27ha22f7c6_4.tar.bz2": { + "build": "py27ha22f7c6_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py27hdbf6ddf_4", + "python >=2.7,<2.8.0a0" + ], + "md5": "a619ca594d2318881f2a5716821a111a", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ac7abb35caf2ee68eb2e70c39ae39eb19bebe6a32697c3cb150f1a827601b37f", + "size": 34723, + "subdir": "linux-64", + "timestamp": 1531326786348, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py35h025eb46_0.tar.bz2": { + "build": "py35h025eb46_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py35h2b20989_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "38b3bee4528d3f7268b3b517ab564f61", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ae949bdc128335d0b86aed4f7293021533173a716c870d45dc0683dda9d53ca9", + "size": 94717, + "subdir": "linux-64", + "timestamp": 1528901015458, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py35h025eb46_4.tar.bz2": { + "build": "py35h025eb46_4", + "build_number": 4, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py35h2b20989_4", + "python >=3.5,<3.6.0a0" + ], + "md5": "5ada9ad58d31ce45132d536758671071", + "name": "numpy-devel", + "namespace": "python", + "sha256": "161c56e864d4042f341b0c33a827cd942dbb45a84ad95ede5e393e3d316932e9", + "size": 34659, + "subdir": "linux-64", + "timestamp": 1534347301487, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py35ha22f7c6_0.tar.bz2": { + "build": "py35ha22f7c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py35hdbf6ddf_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "365884e383bb251b86b09b9d25d91aa3", + "name": "numpy-devel", + "namespace": "python", + "sha256": "91cf82811d1d3ebdf30e964616dd3caafb435d4274da8da865d1f208bae30483", + "size": 94876, + "subdir": "linux-64", + "timestamp": 1528901334725, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py35ha22f7c6_4.tar.bz2": { + "build": "py35ha22f7c6_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py35hdbf6ddf_4", + "python >=3.5,<3.6.0a0" + ], + "md5": "f58532e3379c8086ec77b93884047728", + "name": "numpy-devel", + "namespace": "python", + "sha256": "42e8d9d0471f85687b2feabcd99aea8d0985e3a5e16b871e447485a07f279b9f", + "size": 34705, + "subdir": "linux-64", + "timestamp": 1534347002295, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36h025eb46_0.tar.bz2": { + "build": "py36h025eb46_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py36h2b20989_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "c8cbb226470036b2d8ef61c4e1f410a0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b2cc0de7ab4fff38a478d2791d7413234fd4a00f213852e8c40ec85c21e3f213", + "size": 94812, + "subdir": "linux-64", + "timestamp": 1528900647127, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36h025eb46_1.tar.bz2": { + "build": "py36h025eb46_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py36h2b20989_1", + "python >=3.6,<3.7.0a0" + ], + "md5": "de90d0be4fda0ea1019d67c20389159e", + "name": "numpy-devel", + "namespace": "python", + "sha256": "209900a3a4cfa65f2ec31ae100c799a0f00f2737312ccaaf1ec23266c1d31a0e", + "size": 94514, + "subdir": "linux-64", + "timestamp": 1530353151260, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36h025eb46_2.tar.bz2": { + "build": "py36h025eb46_2", + "build_number": 2, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py36h2b20989_2", + "python >=3.6,<3.7.0a0" + ], + "md5": "e879f3c3bb433f82998ad1a2830be23f", + "name": "numpy-devel", + "namespace": "python", + "sha256": "5905f8f18b89f15b7cfc58c255669fc24aeaf9ae90336e961c1e57a5eadef17b", + "size": 94273, + "subdir": "linux-64", + "timestamp": 1530382490198, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36h025eb46_3.tar.bz2": { + "build": "py36h025eb46_3", + "build_number": 3, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py36h2b20989_3", + "python >=3.6,<3.7.0a0" + ], + "md5": "eb17e7b227861496b2b3edfe5f9cccd9", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7f743669d6aa761e7610d4fd1443fe376fcbf5a759b14cff297bb84a66c1fd47", + "size": 94471, + "subdir": "linux-64", + "timestamp": 1530552882038, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36h025eb46_4.tar.bz2": { + "build": "py36h025eb46_4", + "build_number": 4, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py36h2b20989_4", + "python >=3.6,<3.7.0a0" + ], + "md5": "14315eadcaf04ff53be654d58dcac11c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "df864bc8eb29a857618d729e192afd2ffcd477788ee5d8eb4be2af559e55629c", + "size": 34765, + "subdir": "linux-64", + "timestamp": 1531327723893, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36ha22f7c6_0.tar.bz2": { + "build": "py36ha22f7c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py36hdbf6ddf_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "2d73c8fe6d1fc42af2f93aa1d0a52861", + "name": "numpy-devel", + "namespace": "python", + "sha256": "00d72c1b4b63734f23894793f0304496227b2295a3ea44a53edcac6b3eeaf620", + "size": 94769, + "subdir": "linux-64", + "timestamp": 1528901040388, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36ha22f7c6_1.tar.bz2": { + "build": "py36ha22f7c6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py36hdbf6ddf_1", + "python >=3.6,<3.7.0a0" + ], + "md5": "2217540fb4661a3f82226adfb989db85", + "name": "numpy-devel", + "namespace": "python", + "sha256": "adc825084260762354acfda047ef58073aa432d06e780e1ee786d08ec73351e8", + "size": 94611, + "subdir": "linux-64", + "timestamp": 1530353627147, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36ha22f7c6_2.tar.bz2": { + "build": "py36ha22f7c6_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py36hdbf6ddf_2", + "python >=3.6,<3.7.0a0" + ], + "md5": "00d58f9303a921a3a5e0648a4199d90d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "496af5c815223b680129750db35b02ef3290193f0cfc3fe681fc293ed23255c8", + "size": 94267, + "subdir": "linux-64", + "timestamp": 1530383467294, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36ha22f7c6_3.tar.bz2": { + "build": "py36ha22f7c6_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py36hdbf6ddf_3", + "python >=3.6,<3.7.0a0" + ], + "md5": "6be25dd10095a2b63dae1335767dd8f5", + "name": "numpy-devel", + "namespace": "python", + "sha256": "eda5525c3f2b7d9fc7c51fd8c306bd8b4b980a9d1a179aa63e09d8803674fe03", + "size": 94397, + "subdir": "linux-64", + "timestamp": 1530553595265, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36ha22f7c6_4.tar.bz2": { + "build": "py36ha22f7c6_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py36hdbf6ddf_4", + "python >=3.6,<3.7.0a0" + ], + "md5": "059f433e3066085c1cb92d4d4a7db806", + "name": "numpy-devel", + "namespace": "python", + "sha256": "d696d590b8d2fe825da52c5025582be4c591d42a1e619b04fb769601ff2fb99b", + "size": 34728, + "subdir": "linux-64", + "timestamp": 1531342884738, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py37h025eb46_1.tar.bz2": { + "build": "py37h025eb46_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py37h2b20989_1", + "python >=3.7,<3.8.0a0" + ], + "md5": "92baa392e69cffdb6ed93f60b2ed90af", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2711d7ffef21eaa7c15ac18aaec7a973d244bfa5be06c08852b37bf622cfa217", + "size": 94531, + "subdir": "linux-64", + "timestamp": 1530353369729, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py37h025eb46_2.tar.bz2": { + "build": "py37h025eb46_2", + "build_number": 2, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py37h2b20989_2", + "python >=3.7,<3.8.0a0" + ], + "md5": "8c23493b5520918b80860675bbb264de", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6c70c3eee1ef162b234934b97aef6779e6162af40705d9b245f28d3c8df69e35", + "size": 94343, + "subdir": "linux-64", + "timestamp": 1530382924196, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py37h025eb46_3.tar.bz2": { + "build": "py37h025eb46_3", + "build_number": 3, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py37h2b20989_3", + "python >=3.7,<3.8.0a0" + ], + "md5": "9469ba9f7b0251390708c8fa538b88b5", + "name": "numpy-devel", + "namespace": "python", + "sha256": "fa8780691c3724a5a67943dcd326063a2b8dc70eba7ccf47e38d7d4b1c24c6ec", + "size": 94438, + "subdir": "linux-64", + "timestamp": 1530553192351, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py37h025eb46_4.tar.bz2": { + "build": "py37h025eb46_4", + "build_number": 4, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py37h2b20989_4", + "python >=3.7,<3.8.0a0" + ], + "md5": "6f8d09980c838b8595ef49a09e87efa1", + "name": "numpy-devel", + "namespace": "python", + "sha256": "61e2ff12ae4fadeb1d750947d77720fe14760d93c8e1885be77372238895a64c", + "size": 34757, + "subdir": "linux-64", + "timestamp": 1531327093064, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py37ha22f7c6_1.tar.bz2": { + "build": "py37ha22f7c6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py37hdbf6ddf_1", + "python >=3.7,<3.8.0a0" + ], + "md5": "b6b18fa9168047f9a08afc351f4d7011", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e77040a82fe589654da3aa8a8b8ac86538d0408c425d6140daaeffd44d969eda", + "size": 94626, + "subdir": "linux-64", + "timestamp": 1530353746701, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py37ha22f7c6_2.tar.bz2": { + "build": "py37ha22f7c6_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py37hdbf6ddf_2", + "python >=3.7,<3.8.0a0" + ], + "md5": "25313feac3476b2bdfd5eb873c3765a9", + "name": "numpy-devel", + "namespace": "python", + "sha256": "d9c074af18185337b697a0c56091d112ab0f36b57e05d43a8248081c2aa7f1d8", + "size": 94286, + "subdir": "linux-64", + "timestamp": 1530383471566, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py37ha22f7c6_3.tar.bz2": { + "build": "py37ha22f7c6_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py37hdbf6ddf_3", + "python >=3.7,<3.8.0a0" + ], + "md5": "3c687cdff44df183214711b6b6699641", + "name": "numpy-devel", + "namespace": "python", + "sha256": "67164fd306b2c48b6a6b06466bea9bb509bb4bc23d3b57b3df1fa4984fce9567", + "size": 94445, + "subdir": "linux-64", + "timestamp": 1530553531284, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py37ha22f7c6_4.tar.bz2": { + "build": "py37ha22f7c6_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py37hdbf6ddf_4", + "python >=3.7,<3.8.0a0" + ], + "md5": "fe60ae231167e7bfdd7b4fb10b6907a7", + "name": "numpy-devel", + "namespace": "python", + "sha256": "3d596a22620075767c79eb3b5af3b0417652e29624cf88c6f6321725c46f41ee", + "size": 34699, + "subdir": "linux-64", + "timestamp": 1531327414224, + "version": "1.14.5" + }, + "numpy-devel-1.14.6-py27h008b2eb_4.tar.bz2": { + "build": "py27h008b2eb_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.14.6 py27h2f8d375_4", + "python >=2.7,<2.8.0a0" + ], + "md5": "174b78482cc11ecf455ac035dbe433ab", + "name": "numpy-devel", + "namespace": "python", + "sha256": "397209f3a4956ff0e02746f2a0de5e3aa90386faf217bdbb52ed2f595e53f121", + "size": 45424, + "subdir": "linux-64", + "timestamp": 1538074887733, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py27h008b2eb_5.tar.bz2": { + "build": "py27h008b2eb_5", + "build_number": 5, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.14.6 py27h2f8d375_5", + "python >=2.7,<2.8.0a0" + ], + "md5": "6b6b401eb943f893ce1d0523031ab42c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "94888b09743d945ad2c86e5cbcf9c990fe8bfba8a4efb38480d0e5975be594a4", + "size": 45768, + "subdir": "linux-64", + "timestamp": 1569339402622, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py27h4ba5984_5.tar.bz2": { + "build": "py27h4ba5984_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.14.6 py27hde5b4d6_5", + "python >=2.7,<2.8.0a0" + ], + "md5": "6ac5393c606cf1a26c1e06d1ee644d68", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e1239ba0e7a23a74349279badfdc42c85b02042977f7f3976128d407ec40f081", + "size": 45852, + "subdir": "linux-64", + "timestamp": 1569339428290, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py27h6bdb83d_4.tar.bz2": { + "build": "py27h6bdb83d_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.6 py27h81de0dd_4", + "python >=2.7,<2.8.0a0" + ], + "md5": "08386766d146b9a1bbe22682b5b5db70", + "name": "numpy-devel", + "namespace": "python", + "sha256": "41a307198679254a72b478d9b69777462b51db796db064b0c44b3d7ea319ea19", + "size": 45439, + "subdir": "linux-64", + "timestamp": 1538074674706, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py35h008b2eb_4.tar.bz2": { + "build": "py35h008b2eb_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.14.6 py35h2f8d375_4", + "python >=3.5,<3.6.0a0" + ], + "md5": "d287237237558f11ff88abf4b8c82907", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a36a1e9ca5e43b783d42e35aaa72bd51ea6a996e3dda9279af95b805dbfa769f", + "size": 45388, + "subdir": "linux-64", + "timestamp": 1538074519142, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py35h6bdb83d_4.tar.bz2": { + "build": "py35h6bdb83d_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.6 py35h81de0dd_4", + "python >=3.5,<3.6.0a0" + ], + "md5": "d24f7d8c328d5ee330c3bfa8fca0aa07", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a6b244a395d0cc221fe6d9ecb40a9f877a47789ca4c52d0e5476ce272d7c13dc", + "size": 45431, + "subdir": "linux-64", + "timestamp": 1538074964408, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py36h008b2eb_4.tar.bz2": { + "build": "py36h008b2eb_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.14.6 py36h2f8d375_4", + "python >=3.6,<3.7.0a0" + ], + "md5": "4e1290eee34465a8b38515e3ba5cdd81", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e3f986b0b1394d7b69eb7e30fea64a49b0f786a1f1ee229a38560ba9f67ea601", + "size": 45407, + "subdir": "linux-64", + "timestamp": 1538074877402, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py36h008b2eb_5.tar.bz2": { + "build": "py36h008b2eb_5", + "build_number": 5, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.14.6 py36h2f8d375_5", + "python >=3.6,<3.7.0a0" + ], + "md5": "99665cc233f58e65df3d3836d7b9c5ce", + "name": "numpy-devel", + "namespace": "python", + "sha256": "486e812bc7803b3f916ddde39ed5fbdecbb734a1a641f151e274666e4396fbad", + "size": 45807, + "subdir": "linux-64", + "timestamp": 1569339295847, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py36h4ba5984_5.tar.bz2": { + "build": "py36h4ba5984_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.14.6 py36hde5b4d6_5", + "python >=3.6,<3.7.0a0" + ], + "md5": "e7dfc8063d60902c1237ad12fbd3f59a", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f541c7a66f530da0c6cca212b1b206ab67d1f5c5402578a02bd2e1c5a01bd39a", + "size": 45816, + "subdir": "linux-64", + "timestamp": 1569339447875, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py36h6bdb83d_4.tar.bz2": { + "build": "py36h6bdb83d_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.6 py36h81de0dd_4", + "python >=3.6,<3.7.0a0" + ], + "md5": "6487e890b0d1b19b75e1d7398986e9cd", + "name": "numpy-devel", + "namespace": "python", + "sha256": "fb0439494fc52af00b23ea93d46fd2ba90cc017d5d099ee9374b5e8439e35c0b", + "size": 45408, + "subdir": "linux-64", + "timestamp": 1538075108641, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py37h008b2eb_4.tar.bz2": { + "build": "py37h008b2eb_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.14.6 py37h2f8d375_4", + "python >=3.7,<3.8.0a0" + ], + "md5": "8c1dc1577569991d7c4daefcc38e51c7", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f051294f520dbf8e612bf903363eb072fa4fd4f1ffb7cf387bf77e59a3655b05", + "size": 45408, + "subdir": "linux-64", + "timestamp": 1538074432691, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py37h008b2eb_5.tar.bz2": { + "build": "py37h008b2eb_5", + "build_number": 5, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.14.6 py37h2f8d375_5", + "python >=3.7,<3.8.0a0" + ], + "md5": "f1ec14b686d0ef6997da26804bfd664c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6dd5d1841ef4df88d3cd16c0ec9362beacc2b04d4a85bee064b35c6458f2bdd0", + "size": 45762, + "subdir": "linux-64", + "timestamp": 1569339398068, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py37h4ba5984_5.tar.bz2": { + "build": "py37h4ba5984_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.14.6 py37hde5b4d6_5", + "python >=3.7,<3.8.0a0" + ], + "md5": "f1fefd5ef37c54a9dbc653aa134b3ed7", + "name": "numpy-devel", + "namespace": "python", + "sha256": "1f4a5789cddf5855b783f45e8b88bb8b03f51f3016ec0a2317ed619574c5e8bc", + "size": 45817, + "subdir": "linux-64", + "timestamp": 1569339447219, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py37h6bdb83d_4.tar.bz2": { + "build": "py37h6bdb83d_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.6 py37h81de0dd_4", + "python >=3.7,<3.8.0a0" + ], + "md5": "acff5332f5cc1e2147dcb9ce1df38d7c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f250adc4ecf9216800840eb9fcf5a4df09ac0bd4694501fea0a2e4a65f046fe1", + "size": 45400, + "subdir": "linux-64", + "timestamp": 1538074982262, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py38h008b2eb_4.tar.bz2": { + "build": "py38h008b2eb_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.14.6 py38h2f8d375_4", + "python >=3.8,<3.9.0a0" + ], + "md5": "f7cd3e65599fb39c6ea1a8dc188feab0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "d331468eac5c6e6afe2b7e104a848b026c7399c5d733cbef2c2159970db7bc1c", + "size": 35392, + "subdir": "linux-64", + "timestamp": 1574081303574, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py38h4ba5984_4.tar.bz2": { + "build": "py38h4ba5984_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.14.6 py38hde5b4d6_4", + "python >=3.8,<3.9.0a0" + ], + "md5": "28c2f26bf976beda1b6390aa20a995bd", + "name": "numpy-devel", + "namespace": "python", + "sha256": "30bf5b8b86591400bd133a190c549ffaa59fc98b284bdab1c389cec981100497", + "size": 35413, + "subdir": "linux-64", + "timestamp": 1574081562288, + "version": "1.14.6" + }, + "numpy-devel-1.15.0-py27h6bdb83d_0.tar.bz2": { + "build": "py27h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.0 py27h3dfced4_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "14796da3bda54dbd12bbbc32a6d2b5be", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2fe13fbaaa7cc9a9dc0d9e2b917fb74358645e06ea90f72c0ba355f1ef58e91a", + "size": 34953, + "subdir": "linux-64", + "timestamp": 1532704211399, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py27h8f55a68_0.tar.bz2": { + "build": "py27h8f55a68_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.0 py27hc937464_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "69f3784b32fab2b1e41bb6146ff77139", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b00d45e8e11c1db5453bd96de58c96e256686a3c346d530fcf839806a6085eb6", + "size": 36313, + "subdir": "linux-64", + "timestamp": 1534777033859, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py27h99ba2d1_0.tar.bz2": { + "build": "py27h99ba2d1_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.0 py27h1793315_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "06f8eb1e02a58b828ae0e1f7ca2ea23f", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e57190c0da77de798f2f89275150984782c5c40cb7e67749a4a702574590bbbf", + "size": 36314, + "subdir": "linux-64", + "timestamp": 1534776859741, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py27he073198_0.tar.bz2": { + "build": "py27he073198_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.15.0 py27h7cdd4dd_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "33adc23652b19d811eef3e73611a591b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "1dbce90f1da44a67664da2af68046d8b136211e8710e574eca400651e60d9d7c", + "size": 34886, + "subdir": "linux-64", + "timestamp": 1532703560130, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py35h6bdb83d_0.tar.bz2": { + "build": "py35h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.0 py35h3dfced4_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "72da23e39811d9f6ef890d5fab533f1e", + "name": "numpy-devel", + "namespace": "python", + "sha256": "26475cf79570d8c42b273b4b08a7a1490cb0b6ded0dce9c7999d4865234e89ed", + "size": 34941, + "subdir": "linux-64", + "timestamp": 1532704630272, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py35h8f55a68_0.tar.bz2": { + "build": "py35h8f55a68_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.0 py35hc937464_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "4dab701ca5093aec3c551d8bcc2e1f57", + "name": "numpy-devel", + "namespace": "python", + "sha256": "354baf5ce4525327347684cc1cca169022a8e9103ec197a5cb3f070d5858de7d", + "size": 36287, + "subdir": "linux-64", + "timestamp": 1534776673544, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py35h99ba2d1_0.tar.bz2": { + "build": "py35h99ba2d1_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.0 py35h1793315_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "ea3fbed53e60ed828bda23e2ee72093c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "adc6b320de2807369bdef28e2a43db24a826eee742af62990c0cb69b01790c8d", + "size": 36335, + "subdir": "linux-64", + "timestamp": 1534776483685, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py35he073198_0.tar.bz2": { + "build": "py35he073198_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.15.0 py35h7cdd4dd_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "2c518dda34dc6cfe16be7b9228ea7315", + "name": "numpy-devel", + "namespace": "python", + "sha256": "14f8c053be4e1189911e7ca0b08f3c52d256cf86c43556089fb7d252be16ab04", + "size": 34916, + "subdir": "linux-64", + "timestamp": 1532703797276, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py36h6bdb83d_0.tar.bz2": { + "build": "py36h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.0 py36h3dfced4_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "a655572f051d466bc849f7542e2d7524", + "name": "numpy-devel", + "namespace": "python", + "sha256": "74833f3cd2c984b3c0834167651d355f49de75871af7eb30633fcbd2f0c3c411", + "size": 34933, + "subdir": "linux-64", + "timestamp": 1532704545794, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py36h8f55a68_0.tar.bz2": { + "build": "py36h8f55a68_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.0 py36hc937464_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "de5d1d3c341d22e455338d4ed683d1b4", + "name": "numpy-devel", + "namespace": "python", + "sha256": "237b9ea22c2ac7aed27fcc7c997169c4669431311ce623b93d26396e97cffd9a", + "size": 36290, + "subdir": "linux-64", + "timestamp": 1534777416697, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py36h99ba2d1_0.tar.bz2": { + "build": "py36h99ba2d1_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.0 py36h1793315_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "a90c41ca5f9ded231eceefa91d187a19", + "name": "numpy-devel", + "namespace": "python", + "sha256": "94daaec1d7d91acf6f5bc326d4a5945b37f86c9015cd86833480553f671fd47e", + "size": 36306, + "subdir": "linux-64", + "timestamp": 1534777234407, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py36he073198_0.tar.bz2": { + "build": "py36he073198_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.15.0 py36h7cdd4dd_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "ec4da100afe7b4ee0acbd0debc351009", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7ca921cb5169f4640862f5ad5fde1fb05d2c09616b2b1f7a63217525795a04b5", + "size": 34894, + "subdir": "linux-64", + "timestamp": 1532703625362, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py37h6bdb83d_0.tar.bz2": { + "build": "py37h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.0 py37h3dfced4_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "1daeb909c94688a25bffd292d094e8e3", + "name": "numpy-devel", + "namespace": "python", + "sha256": "da1f05d474dc0ecd0fa0dd1742420f049e7def15796562ed115e4cd9de84c896", + "size": 34914, + "subdir": "linux-64", + "timestamp": 1532704715051, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py37h8f55a68_0.tar.bz2": { + "build": "py37h8f55a68_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.0 py37hc937464_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "a8e41d9622a5f0e3cf1a3ffd034c7bfb", + "name": "numpy-devel", + "namespace": "python", + "sha256": "36c8b5d4f0a3c3cfddc52b6b6b631a4b712687204535728c5d4607daf75a7b95", + "size": 36319, + "subdir": "linux-64", + "timestamp": 1534777789200, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py37h99ba2d1_0.tar.bz2": { + "build": "py37h99ba2d1_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.0 py37h1793315_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "5fa0ceb3ac0f056e3e1faae44a7d79bd", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2d1abd22227270e6d4a2a698fe338515034df0359f3f4643b111af21743b660f", + "size": 36324, + "subdir": "linux-64", + "timestamp": 1534777612071, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py37he073198_0.tar.bz2": { + "build": "py37he073198_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.15.0 py37h7cdd4dd_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "964b3fc898ff601ec17f7772d226abf6", + "name": "numpy-devel", + "namespace": "python", + "sha256": "1809101e5a62b949a65c5eebd5979b8d58d2dfd6afcaa04ae26d1fb455c2aa36", + "size": 34911, + "subdir": "linux-64", + "timestamp": 1532703779866, + "version": "1.15.0" + }, + "numpy-devel-1.15.1-py27h008b2eb_0.tar.bz2": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.1 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "82a5d9fe0d13feb844180a1b01a8efc0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0656a187ba645e2b75ef3eff12617957cdfd8c8afa91d12c827bb8c2ae029cb4", + "size": 36620, + "subdir": "linux-64", + "timestamp": 1536895342652, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py27h55f8cf0_0.tar.bz2": { + "build": "py27h55f8cf0_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.1 py27h74e8950_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "6a111bd69b8dcbcf7ee9c842e28bd259", + "name": "numpy-devel", + "namespace": "python", + "sha256": "d556995cd6d3fc87d392d603419f6e2ff8e13a7c9c3a643fa3a3734663d8534e", + "size": 36465, + "subdir": "linux-64", + "timestamp": 1535389607676, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py27h6bdb83d_0.tar.bz2": { + "build": "py27h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.1 py27h81de0dd_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "a6159cce987e7da3606d423567bb243f", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6a42fa9e1900675ed9382a439c17e935a324700e060506a065083272ca182293", + "size": 36497, + "subdir": "linux-64", + "timestamp": 1535389895270, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py35h008b2eb_0.tar.bz2": { + "build": "py35h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.1 py35h2f8d375_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "a10faa5f7a3d1cc66c07c8d2d351d0e2", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a8a0421227bed0e97475c37acfc0659c0670c20311c464fdc9026329151a16ed", + "size": 36645, + "subdir": "linux-64", + "timestamp": 1536895293110, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py35h55f8cf0_0.tar.bz2": { + "build": "py35h55f8cf0_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.1 py35h74e8950_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "451957f70dbc59d188b331efca9df64b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "c1920b5d20bbeaa4ac8b78284578edbc0d9f36f7740bf55fcfe48188759fdcce", + "size": 36503, + "subdir": "linux-64", + "timestamp": 1535389431517, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py35h6bdb83d_0.tar.bz2": { + "build": "py35h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.1 py35h81de0dd_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "5996efba60875ebc0f6d0fa7c3c5084b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "111aed0235c6e63d8f40f044e5cca40322ad43ca8629556ca0d31f750e365850", + "size": 36482, + "subdir": "linux-64", + "timestamp": 1535389587657, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py36h008b2eb_0.tar.bz2": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.1 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "e41f72ebd9805f3eeda2c088ca90ffdf", + "name": "numpy-devel", + "namespace": "python", + "sha256": "16421abe67b5b8c3665e08e14ba210387f8565017aca8c9a88109d4d90d17e09", + "size": 36644, + "subdir": "linux-64", + "timestamp": 1536895342764, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py36h55f8cf0_0.tar.bz2": { + "build": "py36h55f8cf0_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.1 py36h74e8950_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "5c930a2e7700cdd9f806803b1f401695", + "name": "numpy-devel", + "namespace": "python", + "sha256": "c166da73c91234ba3ec629ccd5465dcc897d58881ce1b7316d7e972626c44ae8", + "size": 36476, + "subdir": "linux-64", + "timestamp": 1535389651379, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py36h6bdb83d_0.tar.bz2": { + "build": "py36h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.1 py36h81de0dd_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "6e3e15a84cd776750c968e86a4f6dfb3", + "name": "numpy-devel", + "namespace": "python", + "sha256": "9ec6ebe0656fc79945a7c525eb4269da16bc548248741411cd29aad4272485a9", + "size": 36461, + "subdir": "linux-64", + "timestamp": 1535389913980, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py37h008b2eb_0.tar.bz2": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.1 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "0f297e035e74212d03e3eceb078aedca", + "name": "numpy-devel", + "namespace": "python", + "sha256": "44a6dba22e61de7c6b1946b81b0d56337527312f2e2ac3221186fec3f16565f4", + "size": 36662, + "subdir": "linux-64", + "timestamp": 1536895347153, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py37h55f8cf0_0.tar.bz2": { + "build": "py37h55f8cf0_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.1 py37h74e8950_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "34f0279620d871f059073a44e85ba719", + "name": "numpy-devel", + "namespace": "python", + "sha256": "5f39f0f88b1834cd9d25bc5589558af752510b50ee1073dab584fb88b0e2b996", + "size": 36478, + "subdir": "linux-64", + "timestamp": 1535389651114, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py37h6bdb83d_0.tar.bz2": { + "build": "py37h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.1 py37h81de0dd_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "f6f69388e07b917cb0a6df4fc3e7c04e", + "name": "numpy-devel", + "namespace": "python", + "sha256": "5c1383ecf6a314cf033c9eea6036ee29fd6903142ad9956eef58e8b8f24a4ed4", + "size": 36463, + "subdir": "linux-64", + "timestamp": 1535389915731, + "version": "1.15.1" + }, + "numpy-devel-1.15.2-py27h008b2eb_0.tar.bz2": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "abdbd599c85cacedd8b5a3c7213e0f13", + "name": "numpy-devel", + "namespace": "python", + "sha256": "097e7dba2dbac8fadcb441b298d6c12cebcfc50c6ab756f1c994eff26fe88bff", + "size": 46942, + "subdir": "linux-64", + "timestamp": 1538073550365, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py27h008b2eb_1.tar.bz2": { + "build": "py27h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py27h2f8d375_1", + "python >=2.7,<2.8.0a0" + ], + "md5": "c48a421c9e1dabcd46404b4915f14b1f", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0a007f110a1c38a0ba6fa641247ab11df6894e9a5efc0ddafb4a93681ab472e3", + "size": 47434, + "subdir": "linux-64", + "timestamp": 1538500389581, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py27h6bdb83d_0.tar.bz2": { + "build": "py27h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.2 py27h81de0dd_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "bc4f043b230900242f0cced538a9a6b2", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a1b68b962ba05017f6dea8414405f03c022411a8abfe94bc817290c6ce3a33a4", + "size": 46943, + "subdir": "linux-64", + "timestamp": 1538073738872, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py27h6bdb83d_1.tar.bz2": { + "build": "py27h6bdb83d_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.2 py27h81de0dd_1", + "python >=2.7,<2.8.0a0" + ], + "md5": "3e060edccfa9042649200a1d4bd63180", + "name": "numpy-devel", + "namespace": "python", + "sha256": "785aa1a4200851311b9df9972604708644b3ab5d39d22a9fa805317f422dc723", + "size": 47446, + "subdir": "linux-64", + "timestamp": 1538500437804, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py35h008b2eb_0.tar.bz2": { + "build": "py35h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py35h2f8d375_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "f5a85c49a960da25c86a922b871bdf20", + "name": "numpy-devel", + "namespace": "python", + "sha256": "30fca2f3569c7c502b6d193789631bb0cc2354ed9917707f37b0b3da20e14e73", + "size": 46934, + "subdir": "linux-64", + "timestamp": 1538073990461, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py35h6bdb83d_0.tar.bz2": { + "build": "py35h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.2 py35h81de0dd_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "55114c5c782191564d7d09e5c81fd464", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f3ddab83d275de10e851322096cb9f190d34a23e63a765209f918eda0a4878d9", + "size": 46936, + "subdir": "linux-64", + "timestamp": 1538073749185, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py36h008b2eb_0.tar.bz2": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "23dc3fd65616767879827f67582abaa8", + "name": "numpy-devel", + "namespace": "python", + "sha256": "c6d8b62a12cbe02730f44cd1923608d118540ec57b960b9fea378daac0108144", + "size": 46933, + "subdir": "linux-64", + "timestamp": 1538074267828, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py36h008b2eb_1.tar.bz2": { + "build": "py36h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py36h2f8d375_1", + "python >=3.6,<3.7.0a0" + ], + "md5": "a04f29ed53b31ff16b2aab9747caf358", + "name": "numpy-devel", + "namespace": "python", + "sha256": "c81583dcb1680accd3a83354c7c95877212b59b7bba9b8015b42604056b31787", + "size": 47419, + "subdir": "linux-64", + "timestamp": 1538500383705, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py36h6bdb83d_0.tar.bz2": { + "build": "py36h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.2 py36h81de0dd_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "16cefbfb1d7593861718f1c25fa30b18", + "name": "numpy-devel", + "namespace": "python", + "sha256": "8a69d0d18fa11c23016e29f1127fc2f963e780d8eec180de40bb320d6359ff31", + "size": 46937, + "subdir": "linux-64", + "timestamp": 1538074379474, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py36h6bdb83d_1.tar.bz2": { + "build": "py36h6bdb83d_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.2 py36h81de0dd_1", + "python >=3.6,<3.7.0a0" + ], + "md5": "4fa03eb1128de77d1aac3f7a47f7d520", + "name": "numpy-devel", + "namespace": "python", + "sha256": "c89d9f09e15a9fafeb5fc2f27e53a3dc22d53fc8fa2678ead117bc6ea628a3f0", + "size": 47442, + "subdir": "linux-64", + "timestamp": 1538500682431, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py37h008b2eb_0.tar.bz2": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "f933670f6dfbf2ee22df96479188a632", + "name": "numpy-devel", + "namespace": "python", + "sha256": "75c0cb75bdfc5c25e849b0acf628b1365bc7a684289cd447f0e59c825cd30947", + "size": 46927, + "subdir": "linux-64", + "timestamp": 1538073478336, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py37h008b2eb_1.tar.bz2": { + "build": "py37h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py37h2f8d375_1", + "python >=3.7,<3.8.0a0" + ], + "md5": "001c4efd451703e180edba2073273020", + "name": "numpy-devel", + "namespace": "python", + "sha256": "03c7322e90073c2d0d1a43c97ba3b5a3cfd0f5f217b07d384b446218bf7ea40f", + "size": 47429, + "subdir": "linux-64", + "timestamp": 1538504556389, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py37h6bdb83d_0.tar.bz2": { + "build": "py37h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.2 py37h81de0dd_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "9561823b6484da3c15ee4368546e31ab", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a20ffcf094288ce6bd5f5e46bfc764aec8ad47315f29328efae278e32ea0e0a3", + "size": 46929, + "subdir": "linux-64", + "timestamp": 1538073704389, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py37h6bdb83d_1.tar.bz2": { + "build": "py37h6bdb83d_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.2 py37h81de0dd_1", + "python >=3.7,<3.8.0a0" + ], + "md5": "4e82a16af45d7bb0c2e048a2c253489e", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f4b99ad8d02dbca89ebf2e70416508a61f36eab1ab51255e536a52c561066c66", + "size": 47453, + "subdir": "linux-64", + "timestamp": 1538504458472, + "version": "1.15.2" + }, + "numpy-devel-1.15.3-py27h008b2eb_0.tar.bz2": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.3 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "8d3b4cb925d588bc648fffa81a8bb948", + "name": "numpy-devel", + "namespace": "python", + "sha256": "90024357f004c671e67191bd4b8aae117a9763185cb844e04960bd05907e0171", + "size": 35002, + "subdir": "linux-64", + "timestamp": 1540314073313, + "version": "1.15.3" + }, + "numpy-devel-1.15.3-py27h6bdb83d_0.tar.bz2": { + "build": "py27h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.3 py27h81de0dd_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "74711dd981e29d9fa7ec0097f0dccea0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ae282ad5bd49b8dc8d9432554f428b27fad388196aa226cf1687280e8816a562", + "size": 35009, + "subdir": "linux-64", + "timestamp": 1540314327322, + "version": "1.15.3" + }, + "numpy-devel-1.15.3-py36h008b2eb_0.tar.bz2": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.3 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "39f53e3be74f2c9559aa8b311a7b27c5", + "name": "numpy-devel", + "namespace": "python", + "sha256": "766abe36dcc8b49c74909dbaba81fafdee8ee37ae7faee92358e202610920c15", + "size": 35020, + "subdir": "linux-64", + "timestamp": 1540314091844, + "version": "1.15.3" + }, + "numpy-devel-1.15.3-py36h6bdb83d_0.tar.bz2": { + "build": "py36h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.3 py36h81de0dd_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "af409a79d259fa42aaa2acda4153e837", + "name": "numpy-devel", + "namespace": "python", + "sha256": "dc4bd8fa3a700fa54b07614cf4d544e83ac98897ad2b16ebbe97e292aa4de6d4", + "size": 35043, + "subdir": "linux-64", + "timestamp": 1540314359646, + "version": "1.15.3" + }, + "numpy-devel-1.15.3-py37h008b2eb_0.tar.bz2": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.3 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "ccbfc8444ed4da68318ce181ae10eb61", + "name": "numpy-devel", + "namespace": "python", + "sha256": "76c4589b6ed1ddf148abf70ff15f74f827ef35c5abb06944d38721611d3bcf7e", + "size": 35010, + "subdir": "linux-64", + "timestamp": 1540314126462, + "version": "1.15.3" + }, + "numpy-devel-1.15.3-py37h6bdb83d_0.tar.bz2": { + "build": "py37h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.3 py37h81de0dd_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "2b4068fbcb22e3c4e7b0f45f010d62dd", + "name": "numpy-devel", + "namespace": "python", + "sha256": "9721846dc7d5d1f769922706663af91b4e34cdb51a44fd50592515a2c8b6a62d", + "size": 35030, + "subdir": "linux-64", + "timestamp": 1540314576526, + "version": "1.15.3" + }, + "numpy-devel-1.15.4-py27h008b2eb_0.tar.bz2": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.4 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "0a4d20c961826b9a36dcc24de9f83748", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f91053614ae66c1f377bda63cae1a9d8019b963e8aa7160fe6f63a84fcb6137b", + "size": 34705, + "subdir": "linux-64", + "timestamp": 1541516724680, + "version": "1.15.4" + }, + "numpy-devel-1.15.4-py27h4ba5984_0.tar.bz2": { + "build": "py27h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.15.4 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "c3267526a8715ba592ee22e2ceb0b4ec", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2886c9395e54083a962d2374251b7fa5eda2355efa5dfa4b49c43a77a80b308d", + "size": 46204, + "subdir": "linux-64", + "timestamp": 1544718222254, + "version": "1.15.4" + }, + "numpy-devel-1.15.4-py27h6bdb83d_0.tar.bz2": { + "build": "py27h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.4 py27h81de0dd_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "550ff8b4aa8f7ba0307c5d6367d9a711", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0de2a9f396c49029711ec8705aa48a8eef477fd3c75384a30173af37c034d7d9", + "size": 34732, + "subdir": "linux-64", + "timestamp": 1541517037044, + "version": "1.15.4" + }, + "numpy-devel-1.15.4-py36h008b2eb_0.tar.bz2": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.4 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "de303f950b686b1876f7686bb0cb5ad2", + "name": "numpy-devel", + "namespace": "python", + "sha256": "8bfc67d8f97c9238025d851c813fea233b99ea81bab03f5d14e32dfe1f7e53be", + "size": 34731, + "subdir": "linux-64", + "timestamp": 1541516723265, + "version": "1.15.4" + }, + "numpy-devel-1.15.4-py36h4ba5984_0.tar.bz2": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.15.4 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "7bc34e17aee0a8ad0687d697e2b859ce", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0d0f8b7e096caf1ceb0d9b83282c61ba06f8335e4715140bc464fb6bf39bdf52", + "size": 46187, + "subdir": "linux-64", + "timestamp": 1544718302154, + "version": "1.15.4" + }, + "numpy-devel-1.15.4-py36h6bdb83d_0.tar.bz2": { + "build": "py36h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.4 py36h81de0dd_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "a3c734a12286692a145a986a066296d8", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0b3e53b6cfb2674c85dc4dc95d4327814d0241414dad9ffdcb37d81608e3c9c4", + "size": 34715, + "subdir": "linux-64", + "timestamp": 1541516989986, + "version": "1.15.4" + }, + "numpy-devel-1.15.4-py37h008b2eb_0.tar.bz2": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.4 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "1f6804e08e1a36083d04649cc7e5b24c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "c25815785b71ba138588f44bb1caa0d0c1e10241e886f1cbd8567d3086350925", + "size": 34709, + "subdir": "linux-64", + "timestamp": 1541516567198, + "version": "1.15.4" + }, + "numpy-devel-1.15.4-py37h4ba5984_0.tar.bz2": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.15.4 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "63bc4b20f94e6ff22f5091b6d56f7e48", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f97f20fd125fb0f24007009ae2d75ed7cbfa4afe136473b4df5699d8267a31d7", + "size": 46161, + "subdir": "linux-64", + "timestamp": 1544718456532, + "version": "1.15.4" + }, + "numpy-devel-1.15.4-py37h6bdb83d_0.tar.bz2": { + "build": "py37h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.4 py37h81de0dd_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "2a1da4435ca879e3aef85e371de84ba6", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a4f203edb36519abce99ebbe1b78761ab90d3845ffa676c621b36b0a6639deb5", + "size": 34724, + "subdir": "linux-64", + "timestamp": 1541516957166, + "version": "1.15.4" + }, + "numpy-devel-1.16.0-py27h008b2eb_0.tar.bz2": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "9daad81bcd6842da54077aaab023ca9a", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a2780a9c1055544607dccf8763a18d6d1dee46e9e2968df10dcfe7722cb218a1", + "size": 47651, + "subdir": "linux-64", + "timestamp": 1551398002904, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py27h008b2eb_1.tar.bz2": { + "build": "py27h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py27h2f8d375_1", + "python >=2.7,<2.8.0a0" + ], + "md5": "9a6c9f8fc0cc68694b6d17e896fd4268", + "name": "numpy-devel", + "namespace": "python", + "sha256": "8c3f69a93998eb5905b4cee93f320fe3f0273e0c9d20ad83e38e7c4a56d9b048", + "size": 48034, + "subdir": "linux-64", + "timestamp": 1551801743153, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py27h4ba5984_0.tar.bz2": { + "build": "py27h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.0 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "d274bcc316c4bbe4a4770315fce0eaec", + "name": "numpy-devel", + "namespace": "python", + "sha256": "5091888a69d2559dc455ec7311f7a7136e3c6ab250e67294a43a36c37425f8e4", + "size": 47744, + "subdir": "linux-64", + "timestamp": 1551398142543, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py27h4ba5984_1.tar.bz2": { + "build": "py27h4ba5984_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.0 py27hde5b4d6_1", + "python >=2.7,<2.8.0a0" + ], + "md5": "61921269d4e9a0ea72ac0f556a1b6257", + "name": "numpy-devel", + "namespace": "python", + "sha256": "dab3671293a248247d4e89a9e688dd3826d2fa65ccc09d2030e45ffbc038060c", + "size": 48139, + "subdir": "linux-64", + "timestamp": 1551802022127, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py36h008b2eb_0.tar.bz2": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "bf4b76929856bd01a8c7ba5fb0d9e1d4", + "name": "numpy-devel", + "namespace": "python", + "sha256": "5ceb315c8c7fbca5adad8a102b5fdbc01b78166999f79cbf59d6273cb28d7dd6", + "size": 47595, + "subdir": "linux-64", + "timestamp": 1551398086632, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py36h008b2eb_1.tar.bz2": { + "build": "py36h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py36h2f8d375_1", + "python >=3.6,<3.7.0a0" + ], + "md5": "8490735609297d3bfb80f86c96e29996", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b66ace6754346d0a133c1599dcc4e30978c02534d7e7b62dd0f588143de2ea5e", + "size": 48065, + "subdir": "linux-64", + "timestamp": 1551801836857, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py36h4ba5984_0.tar.bz2": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.0 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "c44f6e1c9397d7816027de331fbe73a8", + "name": "numpy-devel", + "namespace": "python", + "sha256": "93fdbee35fe461231bc948e8da8f62bd438ffeed74008462f6e445c4aeff565d", + "size": 47723, + "subdir": "linux-64", + "timestamp": 1551398192914, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py36h4ba5984_1.tar.bz2": { + "build": "py36h4ba5984_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.0 py36hde5b4d6_1", + "python >=3.6,<3.7.0a0" + ], + "md5": "324174df221af7019854ebfd3c722850", + "name": "numpy-devel", + "namespace": "python", + "sha256": "18c471de70c905cd246bb8457307b9c3a2596444c2317527560183443c2051e9", + "size": 48174, + "subdir": "linux-64", + "timestamp": 1551802064861, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py37h008b2eb_0.tar.bz2": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "ada32dcf9d08653285c0ea7b00ae54fd", + "name": "numpy-devel", + "namespace": "python", + "sha256": "bce5b65d8471e376ffc0dff15abd518b1e18d3631a73a84f6a2e678feeb52c20", + "size": 47601, + "subdir": "linux-64", + "timestamp": 1551398046106, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py37h008b2eb_1.tar.bz2": { + "build": "py37h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py37h2f8d375_1", + "python >=3.7,<3.8.0a0" + ], + "md5": "5a308c6e049f26bd9131832be4b95d53", + "name": "numpy-devel", + "namespace": "python", + "sha256": "106cda9187bf0c2b6444a0cbfeaaa337fb141606d25fb3e57e7c489d71985eb5", + "size": 48035, + "subdir": "linux-64", + "timestamp": 1551801716065, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py37h4ba5984_0.tar.bz2": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.0 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "331234f16743880ff1b4725625e6107d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "652f605fc114bbc46649e7b5c6833b3ce13d68fb663248b8344391aaed9bb6e7", + "size": 47740, + "subdir": "linux-64", + "timestamp": 1551398061398, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py37h4ba5984_1.tar.bz2": { + "build": "py37h4ba5984_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.0 py37hde5b4d6_1", + "python >=3.7,<3.8.0a0" + ], + "md5": "33d4960ec8d931b859936a544fadefae", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ae6533de3cb77580b154bdbc05781d59016adb00d060491277f476c6df7d7dec", + "size": 48174, + "subdir": "linux-64", + "timestamp": 1551801917796, + "version": "1.16.0" + }, + "numpy-devel-1.16.1-py27h008b2eb_0.tar.bz2": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "083323b6f15f0259506d85fe64f8ca93", + "name": "numpy-devel", + "namespace": "python", + "sha256": "3a8129c08dbad06e4c07a15763fc0465c5266a5be0a4cacab9a6c2ec571eb3ee", + "size": 47694, + "subdir": "linux-64", + "timestamp": 1551457083243, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py27h008b2eb_1.tar.bz2": { + "build": "py27h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py27h2f8d375_1", + "python >=2.7,<2.8.0a0" + ], + "md5": "d9a3c8fc3470c9bc5f51cbc960a7a108", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a85af3538f6c1d92b68cb7378a3bf30f53cc011540e1d677a4e12d816a443547", + "size": 48068, + "subdir": "linux-64", + "timestamp": 1551468067453, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py27h4ba5984_0.tar.bz2": { + "build": "py27h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.1 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "b54957fe35ef72995001abed95f274c7", + "name": "numpy-devel", + "namespace": "python", + "sha256": "690ae7bf2f7f1d20ffe71d044930ebf956e7034fd126faf5e84272e5f1bdcc48", + "size": 47812, + "subdir": "linux-64", + "timestamp": 1551457193824, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py27h4ba5984_1.tar.bz2": { + "build": "py27h4ba5984_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.1 py27hde5b4d6_1", + "python >=2.7,<2.8.0a0" + ], + "md5": "9375c5292ddc4f10658711a0df134b96", + "name": "numpy-devel", + "namespace": "python", + "sha256": "9f6ac0154020c9d7ffca10f6e1144af7e60de5e51c5b5942e66202d2f404b1ee", + "size": 48200, + "subdir": "linux-64", + "timestamp": 1551468305901, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py36h008b2eb_0.tar.bz2": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "55e023a6c7e6fe8a8acfe2da6f4645a0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e3623e90eb0d2b931a1f19b9fee60af28e6dfe464dea4cfa00882b5aff961f51", + "size": 47718, + "subdir": "linux-64", + "timestamp": 1551457116150, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py36h008b2eb_1.tar.bz2": { + "build": "py36h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py36h2f8d375_1", + "python >=3.6,<3.7.0a0" + ], + "md5": "2522288b56ffdd4964a9561b9fe2803f", + "name": "numpy-devel", + "namespace": "python", + "sha256": "8b9f1f7f3e36616d89afdc63279a27c4b3d7636d75bad4f8a9332f92f13fbefe", + "size": 48081, + "subdir": "linux-64", + "timestamp": 1551468103681, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py36h4ba5984_0.tar.bz2": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.1 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "9dd87325ad9aa74f09acab74458b2a88", + "name": "numpy-devel", + "namespace": "python", + "sha256": "81c7a160ec84e9210909c91947f67efb161bfa906e93406a73fbed2d56552cf0", + "size": 47816, + "subdir": "linux-64", + "timestamp": 1551457131637, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py36h4ba5984_1.tar.bz2": { + "build": "py36h4ba5984_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.1 py36hde5b4d6_1", + "python >=3.6,<3.7.0a0" + ], + "md5": "9f3f77962a64e3f4bb3987eb5d407cae", + "name": "numpy-devel", + "namespace": "python", + "sha256": "469604cb1674803e28a436a3658d9b7acab759f28fbeb60c5a483a1f66c3ac10", + "size": 48168, + "subdir": "linux-64", + "timestamp": 1551468252733, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py37h008b2eb_0.tar.bz2": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "19812f4a04144bf8c6243b451c8d6de5", + "name": "numpy-devel", + "namespace": "python", + "sha256": "06adfb6ff3b0ef4e04be386d083a5c28d7a3832dcaf00fe28b61536850838619", + "size": 47708, + "subdir": "linux-64", + "timestamp": 1551457043809, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py37h008b2eb_1.tar.bz2": { + "build": "py37h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py37h2f8d375_1", + "python >=3.7,<3.8.0a0" + ], + "md5": "2ff2dd8f856d47eb12f79704ea192b12", + "name": "numpy-devel", + "namespace": "python", + "sha256": "4e3bea05b6d1638ad909e7c21658ec3c7147bc7f69973ab8ae1e7a8a9b5690d9", + "size": 48048, + "subdir": "linux-64", + "timestamp": 1551468101130, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py37h4ba5984_0.tar.bz2": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.1 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "552280811c6e87686627b35f59d1b0d4", + "name": "numpy-devel", + "namespace": "python", + "sha256": "de3483e216d12aa55266a6c20a55e1e7ced524188faedf8866254df25519d10f", + "size": 47810, + "subdir": "linux-64", + "timestamp": 1551457166349, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py37h4ba5984_1.tar.bz2": { + "build": "py37h4ba5984_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.1 py37hde5b4d6_1", + "python >=3.7,<3.8.0a0" + ], + "md5": "2d3e4021d86494e20420935b0629a56a", + "name": "numpy-devel", + "namespace": "python", + "sha256": "fcb4fb5bf4bd12b801212d2cdedfd284257b5c3f3ff113c777784b58c4658f5b", + "size": 48205, + "subdir": "linux-64", + "timestamp": 1551468140825, + "version": "1.16.1" + }, + "numpy-devel-1.16.2-py27h008b2eb_0.tar.bz2": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.2 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "80912bb184f290c18528d4a0e065ccc5", + "name": "numpy-devel", + "namespace": "python", + "sha256": "c33ad0f66c7efa13e35e4836d7d8ad0ea4139b5a3dc806af9b770572aec81085", + "size": 48140, + "subdir": "linux-64", + "timestamp": 1551471239371, + "version": "1.16.2" + }, + "numpy-devel-1.16.2-py27h4ba5984_0.tar.bz2": { + "build": "py27h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.2 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "54a7542b8ea3309c0bac2a08d24ccf54", + "name": "numpy-devel", + "namespace": "python", + "sha256": "37cb282cb4575388f57685953079cfe92f3e20a8f656a35226c12c66c6eea34e", + "size": 48273, + "subdir": "linux-64", + "timestamp": 1551471399768, + "version": "1.16.2" + }, + "numpy-devel-1.16.2-py36h008b2eb_0.tar.bz2": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.2 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "a0ffd85a12d5643342fb03117d2f7018", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ac0d2de46fae32f55828a0abd02661aa840d23eff474cd4668ec5caef2a0972d", + "size": 48140, + "subdir": "linux-64", + "timestamp": 1551471227096, + "version": "1.16.2" + }, + "numpy-devel-1.16.2-py36h4ba5984_0.tar.bz2": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.2 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "55bc42e5e409303266536bf5020da7fb", + "name": "numpy-devel", + "namespace": "python", + "sha256": "1bbed216e09f25941ffa82ea4469fc17e7e170133603bdc6cdfea9476b1c8922", + "size": 48280, + "subdir": "linux-64", + "timestamp": 1551471503420, + "version": "1.16.2" + }, + "numpy-devel-1.16.2-py37h008b2eb_0.tar.bz2": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.2 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "1b301e247ff9fd702d32b8e6868ae76f", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b3fa4d293a96f8a5bf9fe6585650a6b659ad03b66fbf139510bcf6b0c9fbb8ea", + "size": 48170, + "subdir": "linux-64", + "timestamp": 1551471210707, + "version": "1.16.2" + }, + "numpy-devel-1.16.2-py37h4ba5984_0.tar.bz2": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.2 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "f402f8cf80d9ee9ee2fb614a9532e2ce", + "name": "numpy-devel", + "namespace": "python", + "sha256": "bd872a6089d984f567931f61e89c69802ba13ad84ecf4798b170c77aa3ad960f", + "size": 48277, + "subdir": "linux-64", + "timestamp": 1551471364436, + "version": "1.16.2" + }, + "numpy-devel-1.16.3-py27h008b2eb_0.tar.bz2": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.3 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "87173ac73bec4695af24b28a383fefdb", + "name": "numpy-devel", + "namespace": "python", + "sha256": "9ee0153d4c9caa2b70feee5a132b7b0ab3a9226455ecebc1e071dbe016a37102", + "size": 48124, + "subdir": "linux-64", + "timestamp": 1555949438337, + "version": "1.16.3" + }, + "numpy-devel-1.16.3-py27h4ba5984_0.tar.bz2": { + "build": "py27h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.3,<2021.0a0", + "numpy-base 1.16.3 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "837241e360bbc3e0dc686bd14b76d3e2", + "name": "numpy-devel", + "namespace": "python", + "sha256": "71118165f3739ae8ef2034e840bc605aa2416437eb8976ef4bd575cf49b0df5b", + "size": 48229, + "subdir": "linux-64", + "timestamp": 1555949716242, + "version": "1.16.3" + }, + "numpy-devel-1.16.3-py36h008b2eb_0.tar.bz2": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.3 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "14423560e2a97d399b03d9686fa5a243", + "name": "numpy-devel", + "namespace": "python", + "sha256": "3cd52a77a3fe517840087f4dc53f93b57b352f9cadb6319a2da3d55fecb2e254", + "size": 48160, + "subdir": "linux-64", + "timestamp": 1555949594576, + "version": "1.16.3" + }, + "numpy-devel-1.16.3-py36h4ba5984_0.tar.bz2": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.3,<2021.0a0", + "numpy-base 1.16.3 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "2f35620fd23480b4d6724783bdc51b87", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a055b49aa56c2811e043221c8c84c33df4145e5c10ff8a5f7e2a82dff0d3e4d6", + "size": 48267, + "subdir": "linux-64", + "timestamp": 1555949739677, + "version": "1.16.3" + }, + "numpy-devel-1.16.3-py37h008b2eb_0.tar.bz2": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.3 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "8d03a168b3033ad4d92346a4d0710521", + "name": "numpy-devel", + "namespace": "python", + "sha256": "5703865a3a7ae5101c6eb7ede0a1cecfece75cb26b47b81c320e35e07c4e2071", + "size": 48138, + "subdir": "linux-64", + "timestamp": 1555949484170, + "version": "1.16.3" + }, + "numpy-devel-1.16.3-py37h4ba5984_0.tar.bz2": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.3,<2021.0a0", + "numpy-base 1.16.3 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "df4ea5b58c6a9df29e7623cf21ef9cc3", + "name": "numpy-devel", + "namespace": "python", + "sha256": "73bc40f8217c92dfff0bef7b09a71ef288d48ad58d9c12d6ae0c76d3f480c2f5", + "size": 48197, + "subdir": "linux-64", + "timestamp": 1555949590636, + "version": "1.16.3" + }, + "numpy-devel-1.16.4-py27h008b2eb_0.tar.bz2": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.4 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "f55509194a5319af89941c65c88a9035", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7f51f6e28d0d1c8449b1c9f426baa8522e4f4f3b4d3f346fe23661801fede7ef", + "size": 48215, + "subdir": "linux-64", + "timestamp": 1559140319110, + "version": "1.16.4" + }, + "numpy-devel-1.16.4-py27h4ba5984_0.tar.bz2": { + "build": "py27h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.3,<2021.0a0", + "numpy-base 1.16.4 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "ffa14a7e1d03811714fc235fdf130c84", + "name": "numpy-devel", + "namespace": "python", + "sha256": "21f92d836ef9a733b41d9417457c0ff557549290f05b65ab89280739b9738d1a", + "size": 48319, + "subdir": "linux-64", + "timestamp": 1559140688832, + "version": "1.16.4" + }, + "numpy-devel-1.16.4-py36h008b2eb_0.tar.bz2": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.4 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "4fd0ee7d20d011fefa52129d10adfd6d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e9dca4e57ac81ff3762a4fceb2a34f80852b6ed7abeb6ec684482f24af2abd0c", + "size": 48187, + "subdir": "linux-64", + "timestamp": 1559140322290, + "version": "1.16.4" + }, + "numpy-devel-1.16.4-py36h4ba5984_0.tar.bz2": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.3,<2021.0a0", + "numpy-base 1.16.4 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "0912f1cd27fae77fb2dc723bf2a7aa26", + "name": "numpy-devel", + "namespace": "python", + "sha256": "3f802f362d7eb54dfa966fb526a2b686be69a0d74fb66447ebc84bad3ea97f70", + "size": 48309, + "subdir": "linux-64", + "timestamp": 1559141052319, + "version": "1.16.4" + }, + "numpy-devel-1.16.4-py37h008b2eb_0.tar.bz2": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.4 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "4cb864cae97586badd204b590a8eb48b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6670a26c718c26a343501924a16af3624225f02da7abbf741da8f4310c2d13bc", + "size": 48218, + "subdir": "linux-64", + "timestamp": 1559140392135, + "version": "1.16.4" + }, + "numpy-devel-1.16.4-py37h4ba5984_0.tar.bz2": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.3,<2021.0a0", + "numpy-base 1.16.4 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "14e91107cc06e78ad5c275f752a152e3", + "name": "numpy-devel", + "namespace": "python", + "sha256": "fab41ab2421e7cd6b4b19fef340a140d7edb0a5d526c64d20296a50e7ff41ba3", + "size": 48291, + "subdir": "linux-64", + "timestamp": 1559140464153, + "version": "1.16.4" + }, + "numpy-devel-1.16.5-py27h008b2eb_0.tar.bz2": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.5 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "4820ba4763c5c08e04ea031fb05f2c08", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f75617cfdcaa1d0cbe0110ec6c722bd69e99d6ac0718cf126cc85fd7e4679ce9", + "size": 48692, + "subdir": "linux-64", + "timestamp": 1568311501259, + "version": "1.16.5" + }, + "numpy-devel-1.16.5-py27h4ba5984_0.tar.bz2": { + "build": "py27h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.16.5 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "37b5ea942de8b5d85c347fb7c36a2271", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e0afb5fe35a60726522fbff9f94b7d65ec3baa19a1ca6bcde91ae10dabe59a25", + "size": 48872, + "subdir": "linux-64", + "timestamp": 1568311601186, + "version": "1.16.5" + }, + "numpy-devel-1.16.5-py36h008b2eb_0.tar.bz2": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.5 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "ebaf53b356aa4039cee5f80f5c05e7a2", + "name": "numpy-devel", + "namespace": "python", + "sha256": "993815e463a2908157f8e49f0065c642f745a5174963a737e8fbaa89d04f6470", + "size": 48692, + "subdir": "linux-64", + "timestamp": 1568311488779, + "version": "1.16.5" + }, + "numpy-devel-1.16.5-py36h4ba5984_0.tar.bz2": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.16.5 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "677029f5d1eb9e01ccb6c48713bff645", + "name": "numpy-devel", + "namespace": "python", + "sha256": "01f4701de22d5dc3e71d8cb891a81cac11ffea393de79af6aa9b424500bd8675", + "size": 48830, + "subdir": "linux-64", + "timestamp": 1568311800208, + "version": "1.16.5" + }, + "numpy-devel-1.16.5-py37h008b2eb_0.tar.bz2": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.5 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "3bf6f7986747d16f991274bb71ddd526", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f2015eef6c67a2c1fbc680705f5266746a6fdd441a8a7ba0e0b0141f1b7c9a7b", + "size": 48697, + "subdir": "linux-64", + "timestamp": 1568311600718, + "version": "1.16.5" + }, + "numpy-devel-1.16.5-py37h4ba5984_0.tar.bz2": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.16.5 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "acab296a42e6f8a9fa506626aeb4c671", + "name": "numpy-devel", + "namespace": "python", + "sha256": "69433f6654b947e4a47e455c9f2b790b5f7f4e7607b715088e361dec91a840d4", + "size": 48805, + "subdir": "linux-64", + "timestamp": 1568311792686, + "version": "1.16.5" + }, + "numpy-devel-1.16.6-py27h008b2eb_0.tar.bz2": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "16b4c4221996f09f8c91eb026e3d1ced", + "name": "numpy-devel", + "namespace": "python", + "sha256": "38704b6447261af120f651310a0ea81da28cfcc2a3c144eb4985908014389ea8", + "size": 48772, + "subdir": "linux-64", + "timestamp": 1580501506935, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py27h4ba5984_0.tar.bz2": { + "build": "py27h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.16.6 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "cab039ad1888bd6dd5967c6e0933aee0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "c28517af4a82e73bb54ac9b0d6a0ecbdf71cb122c1c9f4b813fb8980200e2796", + "size": 48923, + "subdir": "linux-64", + "timestamp": 1580501613250, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py36h008b2eb_0.tar.bz2": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "55dbb8075026d73364b11035b01f6853", + "name": "numpy-devel", + "namespace": "python", + "sha256": "909f3380ccaf501ba7c1426c763bc4966de5ff7f0057c1316542aef89e0d16bc", + "size": 48455, + "subdir": "linux-64", + "timestamp": 1580488233101, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py36h4ba5984_0.tar.bz2": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.16.6 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "c9cef5bb087f2f2dfb3b1bc02ddaea94", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0b4276c50b7672178d2e3ec3692ba552abe643d393d4d875df4ad2bd233deb9e", + "size": 48572, + "subdir": "linux-64", + "timestamp": 1580488470902, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py36hca8f349_3.tar.bz2": { + "build": "py36hca8f349_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py36h41b4c56_3", + "python >=3.6,<3.7.0a0" + ], + "md5": "9fd42fdf614ce4c54a0eaffb5c65fc03", + "name": "numpy-devel", + "namespace": "python", + "sha256": "1e2cdcf007dfdbe170bc5861c668faf0c4b1618a4943263eb8d706cc98bb5ac2", + "size": 50192, + "subdir": "linux-64", + "timestamp": 1618845026716, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py36hef7d012_3.tar.bz2": { + "build": "py36hef7d012_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base 1.16.6 py36hdc34a94_3", + "python >=3.6,<3.7.0a0" + ], + "md5": "5348685986afd503c73dbd4c825a71cf", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ec07b8ab955dbd4e27dfddfed3178bdff64a381994ad2190306af95c4e86280c", + "size": 50379, + "subdir": "linux-64", + "timestamp": 1618845164367, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py37h008b2eb_0.tar.bz2": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "560e7ef6762d09106b43f09b6ecda2e4", + "name": "numpy-devel", + "namespace": "python", + "sha256": "04d095541a63feebae97a13e70102d6e0fcd8197c691adb18631fccad64b8d7d", + "size": 48445, + "subdir": "linux-64", + "timestamp": 1580488182345, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py37h4ba5984_0.tar.bz2": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.16.6 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "d815776590b66ce0a72f8316cf7cb907", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2b7d51492671c7785641bb436dd4a3e498e7b56f5efd3cd31788f254d1e6ca93", + "size": 48590, + "subdir": "linux-64", + "timestamp": 1580488381352, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py37hb168745_4.tar.bz2": { + "build": "py37hb168745_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.16.6 py37ha8aedfd_4", + "python >=3.7,<3.8.0a0" + ], + "md5": "9653ac110ab1b8ca7a2a2914edca5b8c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f67afe09af0f146d9d5255ceb3ff3513d9a5ee14c1e22696ff63dbc9c1f02480", + "size": 38930, + "subdir": "linux-64", + "timestamp": 1654863156474, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py37hca8f349_3.tar.bz2": { + "build": "py37hca8f349_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py37h41b4c56_3", + "python >=3.7,<3.8.0a0" + ], + "md5": "068df88a8d866d1143e8556a7f6eee1b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ffd616ebcc65f0d8ca30530bfc7971db0011308118b9f505e8488832018575c2", + "size": 50216, + "subdir": "linux-64", + "timestamp": 1618844457521, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py37hef7d012_3.tar.bz2": { + "build": "py37hef7d012_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base 1.16.6 py37hdc34a94_3", + "python >=3.7,<3.8.0a0" + ], + "md5": "33264e8fd5a6bcd1dcc2fc3040a423dc", + "name": "numpy-devel", + "namespace": "python", + "sha256": "71be3b4e167adcab645f92ea92841821aa048af6d783cb6ca7b814c484400371", + "size": 50358, + "subdir": "linux-64", + "timestamp": 1618845176561, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py37hef7d012_4.tar.bz2": { + "build": "py37hef7d012_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base 1.16.6 py37h73d599e_4", + "python >=3.7,<3.8.0a0" + ], + "md5": "324e3e042d521e101617656886dabd6b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "657a2bdcd58fcc174d5516d598ff24f77b07a797c01736231904ac8beb02d3ad", + "size": 39037, + "subdir": "linux-64", + "timestamp": 1654863894954, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py38h008b2eb_0.tar.bz2": { + "build": "py38h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py38h2f8d375_0", + "python >=3.8,<3.9.0a0" + ], + "md5": "0a1e41f731e9b6be79a5b750ef06592a", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f53fabd6ce84c959e0b0e33a07ebc303edcb4ac9e3b41f1c858b68254985b0c6", + "size": 48807, + "subdir": "linux-64", + "timestamp": 1580495292888, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py38h4ba5984_0.tar.bz2": { + "build": "py38h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.16.6 py38hde5b4d6_0", + "python >=3.8,<3.9.0a0" + ], + "md5": "126d74d1c68cbdcc9222d4b803d380a8", + "name": "numpy-devel", + "namespace": "python", + "sha256": "941c603dca97919f8ae82a95ef334bacf8b3566abc37093358c507af15713122", + "size": 48936, + "subdir": "linux-64", + "timestamp": 1580495332862, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py38hb168745_4.tar.bz2": { + "build": "py38hb168745_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.16.6 py38ha8aedfd_4", + "python >=3.8,<3.9.0a0" + ], + "md5": "e3c611f6e8fc3f486a42ce18f3019803", + "name": "numpy-devel", + "namespace": "python", + "sha256": "4f3a63351870b0763ca93766c7c36de76aa913482becc886f271c2d7ef831312", + "size": 38918, + "subdir": "linux-64", + "timestamp": 1654863593275, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py38hca8f349_3.tar.bz2": { + "build": "py38hca8f349_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py38h41b4c56_3", + "python >=3.8,<3.9.0a0" + ], + "md5": "723dc619e61e8b462703491842382ea7", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ade8d425107c60c90788c6a01f0524d1dcc68a80085d43225aa7082a22520c91", + "size": 50216, + "subdir": "linux-64", + "timestamp": 1618841703439, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py38hef7d012_3.tar.bz2": { + "build": "py38hef7d012_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base 1.16.6 py38hdc34a94_3", + "python >=3.8,<3.9.0a0" + ], + "md5": "8ffcd71756df33468385d5ec26846b25", + "name": "numpy-devel", + "namespace": "python", + "sha256": "bf8a1beb065da873d7a5e475631bc37745456fe70d7bc7ddff3d5d1f23150a38", + "size": 50367, + "subdir": "linux-64", + "timestamp": 1618845166412, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py38hef7d012_4.tar.bz2": { + "build": "py38hef7d012_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base 1.16.6 py38h73d599e_4", + "python >=3.8,<3.9.0a0" + ], + "md5": "dc00284e576d4d3b6999834781bd34d9", + "name": "numpy-devel", + "namespace": "python", + "sha256": "3be2db85dcfa882d0374ddf0a80110eec9df06388a8563c4ac22dea960a61e0b", + "size": 39019, + "subdir": "linux-64", + "timestamp": 1654864522495, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py39h1fb7909_1.tar.bz2": { + "build": "py39h1fb7909_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.16.6 py39h76555f2_1", + "python >=3.9,<3.10.0a0" + ], + "md5": "cefab3c6491c72d4158eb3f618d39f92", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6ff3e2128ddddaee57e34bfa3bbe4da9edab3f8d0aba78463d335f26b6916fde", + "size": 48692, + "subdir": "linux-64", + "timestamp": 1607432385091, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py39hb168745_4.tar.bz2": { + "build": "py39hb168745_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.16.6 py39ha8aedfd_4", + "python >=3.9,<3.10.0a0" + ], + "md5": "74eeafc4282264fc6ad31a99f4bcc180", + "name": "numpy-devel", + "namespace": "python", + "sha256": "cae1ada666f452530861ad63ffc69ee5f4a00eb14f59f2e721b07368cf76b4d5", + "size": 38955, + "subdir": "linux-64", + "timestamp": 1654863375783, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py39hca8f349_1.tar.bz2": { + "build": "py39hca8f349_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py39hfb011de_1", + "python >=3.9,<3.10.0a0" + ], + "md5": "3e9dd6d9cbb76ed2e80354439b72e624", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e3b61cc05ce7c6534e2cffa042cce90deeb498a3543fce586f5bbe70171ec0a7", + "size": 48545, + "subdir": "linux-64", + "timestamp": 1607432259550, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py39hca8f349_3.tar.bz2": { + "build": "py39hca8f349_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py39h41b4c56_3", + "python >=3.9,<3.10.0a0" + ], + "md5": "c843a6ea3e9fc0db533d13204d57129c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "4e94e2f8b8c96e63c09211415738cc36b708eff8652a4a06a9ec0574a45ca382", + "size": 50251, + "subdir": "linux-64", + "timestamp": 1618841702080, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py39hef7d012_3.tar.bz2": { + "build": "py39hef7d012_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base 1.16.6 py39hdc34a94_3", + "python >=3.9,<3.10.0a0" + ], + "md5": "84ab6664e665cb85980588a4666f5e88", + "name": "numpy-devel", + "namespace": "python", + "sha256": "c65cfbd3d50d7df0464d20fbaf0d066f65372e4fe972c9cea73a6032933140ce", + "size": 50397, + "subdir": "linux-64", + "timestamp": 1618845166738, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py39hef7d012_4.tar.bz2": { + "build": "py39hef7d012_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base 1.16.6 py39h73d599e_4", + "python >=3.9,<3.10.0a0" + ], + "md5": "b4fa0b739469012931f10e0c2d483374", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7b68bb694e9202cd14324f0b1976037bdfb1579a468606d7cfea55c4591d1ab9", + "size": 39034, + "subdir": "linux-64", + "timestamp": 1654864205468, + "version": "1.16.6" + }, + "numpy-devel-1.17.2-py36h008b2eb_0.tar.bz2": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.2 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7f67a4de2cc5743f7434e94d78041eec", + "name": "numpy-devel", + "namespace": "python", + "sha256": "35d1b5d90e65d86e56463bcbd8ea54bc5971f9e7a557136bef03f685815954a9", + "size": 65741, + "subdir": "linux-64", + "timestamp": 1569435368309, + "version": "1.17.2" + }, + "numpy-devel-1.17.2-py36h4ba5984_0.tar.bz2": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.17.2 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "13e436a74401e0f33bce7d71f1e722c9", + "name": "numpy-devel", + "namespace": "python", + "sha256": "02ea724d409327b360dc7361a7b39575bb92060a2189e820fdd963c5ddb9993d", + "size": 65583, + "subdir": "linux-64", + "timestamp": 1569435649401, + "version": "1.17.2" + }, + "numpy-devel-1.17.2-py37h008b2eb_0.tar.bz2": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.2 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8af16c206fe0d7e5c01fb48c331c807f", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0a600e17c8cd4a1406147dc757a5e94c5b07c52f92ab663cf4676e143990e4f8", + "size": 65595, + "subdir": "linux-64", + "timestamp": 1569435402742, + "version": "1.17.2" + }, + "numpy-devel-1.17.2-py37h4ba5984_0.tar.bz2": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.17.2 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6ecee78c6c278e74f721f81f57db08c8", + "name": "numpy-devel", + "namespace": "python", + "sha256": "55e23bb1b8273f38e2d972023cf247c5986c79cebd036a8774280ad64cc2174e", + "size": 65528, + "subdir": "linux-64", + "timestamp": 1569435647774, + "version": "1.17.2" + }, + "numpy-devel-1.17.3-py36h008b2eb_0.tar.bz2": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.3 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "82e7f7a5cdaec7f954069e92c857fda7", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6ce12fa2d191623249fcb8491d26aec44c3656b199e6e858845525af55e419a7", + "size": 65860, + "subdir": "linux-64", + "timestamp": 1573063161087, + "version": "1.17.3" + }, + "numpy-devel-1.17.3-py36h4ba5984_0.tar.bz2": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.17.3 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ef67b93e39ac0ea61539241827b5a781", + "name": "numpy-devel", + "namespace": "python", + "sha256": "32b54ff2c297b56b6a0f87903f025f3adfa9acbfbc9cda548423c48822431c82", + "size": 66117, + "subdir": "linux-64", + "timestamp": 1573063153731, + "version": "1.17.3" + }, + "numpy-devel-1.17.3-py37h008b2eb_0.tar.bz2": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.3 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "76878d86d098a6078333bd5e1e51f480", + "name": "numpy-devel", + "namespace": "python", + "sha256": "426021254cf2299d25abbe0332b174a7361a2c9dd72a7c5db6eccadc693c79cd", + "size": 65964, + "subdir": "linux-64", + "timestamp": 1573063231145, + "version": "1.17.3" + }, + "numpy-devel-1.17.3-py37h4ba5984_0.tar.bz2": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.17.3 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a8276e26648a84d0bc6b6b08b21e0ecd", + "name": "numpy-devel", + "namespace": "python", + "sha256": "cb0990d0695131b4516807037414d676f1d05dccf7450ea4280e45d8e70aea4c", + "size": 66125, + "subdir": "linux-64", + "timestamp": 1573063301158, + "version": "1.17.3" + }, + "numpy-devel-1.17.3-py38h008b2eb_0.tar.bz2": { + "build": "py38h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.3 py38h2f8d375_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "17ad324b2ab416e4937da42f6a627902", + "name": "numpy-devel", + "namespace": "python", + "sha256": "86c9e9526f1dbe46a2465fa9f31025ab1eee608087c4afcdbd9bbb45662b5316", + "size": 66052, + "subdir": "linux-64", + "timestamp": 1573063169423, + "version": "1.17.3" + }, + "numpy-devel-1.17.3-py38h4ba5984_0.tar.bz2": { + "build": "py38h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.17.3 py38hde5b4d6_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4ac46a2e26c65f76291ae1fad6c64fdb", + "name": "numpy-devel", + "namespace": "python", + "sha256": "191503edec6bb3af2bbe7b4ad382a7eff471e44994b7e3333dff6c44c12810f1", + "size": 53418, + "subdir": "linux-64", + "timestamp": 1573121189454, + "version": "1.17.3" + }, + "numpy-devel-1.17.4-py36h008b2eb_0.tar.bz2": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.4 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ad6a5c62399bada9ea275d98c16872c0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "9650921d6858f15755503d633ca626587137f6a355f4ec287bc7fa64c150a2a9", + "size": 66005, + "subdir": "linux-64", + "timestamp": 1574868344842, + "version": "1.17.4" + }, + "numpy-devel-1.17.4-py36h4ba5984_0.tar.bz2": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.17.4 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d70826edaaf133a5c9a4f6cf7185d774", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2bc7e5b2eab6c0a34cfda61c46925bbc354fcb8165473002164e3f01e66963f1", + "size": 65987, + "subdir": "linux-64", + "timestamp": 1574868434946, + "version": "1.17.4" + }, + "numpy-devel-1.17.4-py37h008b2eb_0.tar.bz2": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.4 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ac12b4d28644d6e0162450d0960c03c7", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0e1e6cc250cbdae6b789701cb323a2354ad25b7338f1a00cf1083db7f138f7e7", + "size": 65822, + "subdir": "linux-64", + "timestamp": 1574868360917, + "version": "1.17.4" + }, + "numpy-devel-1.17.4-py37h4ba5984_0.tar.bz2": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.17.4 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1c641a4a1da15f216662f300e282c749", + "name": "numpy-devel", + "namespace": "python", + "sha256": "728eb0973b82e8361028c17211ea9f9577bf2db8b71d257b72528cdf7b7a8b89", + "size": 66020, + "subdir": "linux-64", + "timestamp": 1574868421644, + "version": "1.17.4" + }, + "numpy-devel-1.17.4-py38h008b2eb_0.tar.bz2": { + "build": "py38h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.4 py38h2f8d375_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "938b35d404edc065b8f5fd3f53fed1d4", + "name": "numpy-devel", + "namespace": "python", + "sha256": "63120e22109792ca410985381dd460cd8cab9643bfcc496d36c7d4eab83a5c32", + "size": 66077, + "subdir": "linux-64", + "timestamp": 1574868339517, + "version": "1.17.4" + }, + "numpy-devel-1.17.4-py38h4ba5984_0.tar.bz2": { + "build": "py38h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.17.4 py38hde5b4d6_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "607de10976cbd20a8c4068b7c0f5b39b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0feafbe4c537cfbf5d25ff203b7c737cd2d2eaf7bf270ce8a54f13a9e4385621", + "size": 66024, + "subdir": "linux-64", + "timestamp": 1574868405061, + "version": "1.17.4" + }, + "numpy-devel-1.18.1-py36h008b2eb_0.tar.bz2": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.1 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7b0ab856119bb9773b4778d6d0795150", + "name": "numpy-devel", + "namespace": "python", + "sha256": "163731f60810107382c1de2b1260ae3bff5de7adb204d50a7ac6e61ccd4c2284", + "size": 27263, + "subdir": "linux-64", + "timestamp": 1579191419891, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py36h008b2eb_1.tar.bz2": { + "build": "py36h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.1 py36h2f8d375_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f0dac93578bc6fce776703f4f5c267d8", + "name": "numpy-devel", + "namespace": "python", + "sha256": "09d79986fd5759509ea48315c1ef936fa9ae5851e9c549dea139601e42b3cf1c", + "size": 26265, + "subdir": "linux-64", + "timestamp": 1579712662623, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py36h4ba5984_0.tar.bz2": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.18.1 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0d479f347ad8c165ba26ef535d733430", + "name": "numpy-devel", + "namespace": "python", + "sha256": "dcbad9cf94fd6ca2028cd37c612c5fd70be2f085ed14e52325475c101f12c49b", + "size": 27274, + "subdir": "linux-64", + "timestamp": 1579191445797, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py36h4ba5984_1.tar.bz2": { + "build": "py36h4ba5984_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.18.1 py36hde5b4d6_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "abe293dbc84e4b620b2d5ca5370be6a5", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e1875814e51dc6d9c0bd63f074f94ff73c4885490fe7b933c62bd15c03be2dbd", + "size": 26299, + "subdir": "linux-64", + "timestamp": 1579712576660, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py37h008b2eb_0.tar.bz2": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.1 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9d6797038b3b47642e1c08f6bc929cb2", + "name": "numpy-devel", + "namespace": "python", + "sha256": "43734b0d898a1d2314d7125d33cb9fd70e9761daea6da6f888e5a960c868f310", + "size": 27293, + "subdir": "linux-64", + "timestamp": 1579191529246, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py37h008b2eb_1.tar.bz2": { + "build": "py37h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.1 py37h2f8d375_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "df12c1a861b61fb83b8cf6d96a6e80ee", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ced9732093384feafbf735b6d6311c805eb525f12930fda3978d8da20a87f491", + "size": 26258, + "subdir": "linux-64", + "timestamp": 1579712556772, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py37h4ba5984_0.tar.bz2": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.18.1 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fb68ab2b1642e082fb6aa3ad86f06584", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b56142af5703e8c6dc35c7e597a4ee4f7f9508983c4ad91606e683368ec6f0b3", + "size": 27302, + "subdir": "linux-64", + "timestamp": 1579191546774, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py37h4ba5984_1.tar.bz2": { + "build": "py37h4ba5984_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.18.1 py37hde5b4d6_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "22277b95b4fac6cccfd2877e4dc1e16d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ec12be24cd37d66f48e36434513713c9fbabee81509d04d37081b733b0eadf7b", + "size": 26271, + "subdir": "linux-64", + "timestamp": 1579712536462, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py38h008b2eb_0.tar.bz2": { + "build": "py38h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.1 py38h2f8d375_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fd3916e7320ab1ca1c7656bbc150ca6d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "9f0bf487dc5b983fd3b4f3a795e2b1bde4fcdd17f9478ef7d54e9f2dc547a9eb", + "size": 27256, + "subdir": "linux-64", + "timestamp": 1579191543385, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py38h008b2eb_1.tar.bz2": { + "build": "py38h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.1 py38h2f8d375_1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d509842a4973b3bcbe6661b631c39b77", + "name": "numpy-devel", + "namespace": "python", + "sha256": "36e5f9b6a591ddeba374eae1aab764ec7be552a8531d23092955dd200f1cccbf", + "size": 26279, + "subdir": "linux-64", + "timestamp": 1579712588357, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py38h4ba5984_0.tar.bz2": { + "build": "py38h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.18.1 py38hde5b4d6_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e57671101f400acf78c70e702c1e4c15", + "name": "numpy-devel", + "namespace": "python", + "sha256": "80a915a0d9a14668e36bfc269d4584a6afbac8f993f993c3be9c2929e9edf9c1", + "size": 27312, + "subdir": "linux-64", + "timestamp": 1579191458810, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py38h4ba5984_1.tar.bz2": { + "build": "py38h4ba5984_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.18.1 py38hde5b4d6_1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5593b7af0510cf21c05cdc79ef30cf42", + "name": "numpy-devel", + "namespace": "python", + "sha256": "504a8dc8389ecfde53a2a16f768648ab630890c47a72325f1f5abd3db24d1749", + "size": 26281, + "subdir": "linux-64", + "timestamp": 1579712599872, + "version": "1.18.1" + }, + "numpy-devel-1.18.5-py36h008b2eb_0.tar.bz2": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.5 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "32e24262b0242622f69065de9522dbb1", + "name": "numpy-devel", + "namespace": "python", + "sha256": "44fda7300d18f20de2e74c71eb4f435b137cb141b0ed0a8462a3c748775e1405", + "size": 26320, + "subdir": "linux-64", + "timestamp": 1592509320518, + "version": "1.18.5" + }, + "numpy-devel-1.18.5-py36h4ba5984_0.tar.bz2": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.18.5 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2824d6e5182818c08e2113f09aff5ab9", + "name": "numpy-devel", + "namespace": "python", + "sha256": "df9304d46934e2c8d6c6403a2254d24503f0734d16c56c544efbd8fea0cdd297", + "size": 26370, + "subdir": "linux-64", + "timestamp": 1592509304550, + "version": "1.18.5" + }, + "numpy-devel-1.18.5-py37h008b2eb_0.tar.bz2": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.5 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "20c91872ee7958e94e9942ce1c9e6878", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f6e18d063acae107319f778ae4c26874ca64ddae8f59e3d6b6b760d818eb7fa7", + "size": 26325, + "subdir": "linux-64", + "timestamp": 1592509276589, + "version": "1.18.5" + }, + "numpy-devel-1.18.5-py37h4ba5984_0.tar.bz2": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.18.5 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2bbb6e10a379fb09f36a73af74171495", + "name": "numpy-devel", + "namespace": "python", + "sha256": "30756e4d9b0b25b8d473dace6e3f9827bc957cc22820a554ed8dde37d51cacca", + "size": 26355, + "subdir": "linux-64", + "timestamp": 1592509320019, + "version": "1.18.5" + }, + "numpy-devel-1.18.5-py38h008b2eb_0.tar.bz2": { + "build": "py38h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.5 py38h2f8d375_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0c8c5946f8b8b410cea95b35209397c3", + "name": "numpy-devel", + "namespace": "python", + "sha256": "583d56de0653595361ab0e6dbfc5ee4af52dc905e897f88da0b9ff2fb938ecc1", + "size": 26325, + "subdir": "linux-64", + "timestamp": 1592509314017, + "version": "1.18.5" + }, + "numpy-devel-1.18.5-py38h4ba5984_0.tar.bz2": { + "build": "py38h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.18.5 py38hde5b4d6_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b83a7fa66fbdc8253eb218cc3d985fdf", + "name": "numpy-devel", + "namespace": "python", + "sha256": "c58d487578221d44b74f9f7dab52ae74057b09d7b0cf80d6b55afd6a0120de85", + "size": 26362, + "subdir": "linux-64", + "timestamp": 1592509325986, + "version": "1.18.5" + }, + "numpy-devel-1.9.3-py27h025eb46_6.tar.bz2": { + "build": "py27h025eb46_6", + "build_number": 6, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.9.3 py27h2b20989_6", + "python >=2.7,<2.8.0a0" + ], + "md5": "dd899e6aa712ef6caac2c1625a80b6cc", + "name": "numpy-devel", + "namespace": "python", + "sha256": "cc19d834b7f62cb0631dd5dad45eef6503d444061edb6d23ccac1f1927d42b32", + "size": 8896, + "subdir": "linux-64", + "timestamp": 1530380225388, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py27h025eb46_7.tar.bz2": { + "build": "py27h025eb46_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.9.3 py27h2b20989_7", + "python >=2.7,<2.8.0a0" + ], + "md5": "b8038cca60ac12b3f9a777f57a94c17b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "5aba6394a2800c8e19007f240b507191973495ffecd1dbdda2437d8d64705174", + "size": 8961, + "subdir": "linux-64", + "timestamp": 1530550418712, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py27h8f55a68_7.tar.bz2": { + "build": "py27h8f55a68_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.9.3 py27hc937464_7", + "python >=2.7,<2.8.0a0" + ], + "md5": "188a8138fbc3e32ba14b9d4f0e1eaf07", + "name": "numpy-devel", + "namespace": "python", + "sha256": "dcc86fad45d610ee394f83a190ebf229c50a43b07cdc61308255a6a01b3132fc", + "size": 8612, + "subdir": "linux-64", + "timestamp": 1534773452166, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py27h99ba2d1_7.tar.bz2": { + "build": "py27h99ba2d1_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py27h1793315_7", + "python >=2.7,<2.8.0a0" + ], + "md5": "71dc792b1b130f9fe11f1c707c4a0b45", + "name": "numpy-devel", + "namespace": "python", + "sha256": "11aeb0545aaf2346198921fc3878c967a9e994adf3e1541e20b4071d1c103b93", + "size": 8614, + "subdir": "linux-64", + "timestamp": 1534512672825, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py27ha22f7c6_6.tar.bz2": { + "build": "py27ha22f7c6_6", + "build_number": 6, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py27hdbf6ddf_6", + "python >=2.7,<2.8.0a0" + ], + "md5": "b0debf285df8d20fce40f4cb0d87a6fe", + "name": "numpy-devel", + "namespace": "python", + "sha256": "119ce10332a43bebfea589c7da7bb670bb30de1b0b49ace4eb310daa8619c9d2", + "size": 8877, + "subdir": "linux-64", + "timestamp": 1530383301717, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py27ha22f7c6_7.tar.bz2": { + "build": "py27ha22f7c6_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py27hdbf6ddf_7", + "python >=2.7,<2.8.0a0" + ], + "md5": "aa571dacaf9e9d1efdac5b43c291ac9a", + "name": "numpy-devel", + "namespace": "python", + "sha256": "10234639de201bfc947e6c6867ee95deb994766c8ab62081204bc2780384cedf", + "size": 8970, + "subdir": "linux-64", + "timestamp": 1530553218467, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py35h025eb46_7.tar.bz2": { + "build": "py35h025eb46_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.9.3 py35h2b20989_7", + "python >=3.5,<3.6.0a0" + ], + "md5": "911f7aa65a3ca92dcf3fd0019ac9f69f", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b1893cdce383ffbca9d1e51920dd086d3bdffaeea5f162435914ec9e3b7450e1", + "size": 8965, + "subdir": "linux-64", + "timestamp": 1530694276368, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py35h8f55a68_7.tar.bz2": { + "build": "py35h8f55a68_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.9.3 py35hc937464_7", + "python >=3.5,<3.6.0a0" + ], + "md5": "4b441e3cf073e27855c9444cb241877b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ddb135f46320524d399134d8ef312292d907206fef1f4b7f7ea2b07c3295f259", + "size": 8632, + "subdir": "linux-64", + "timestamp": 1534773229138, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py35h99ba2d1_7.tar.bz2": { + "build": "py35h99ba2d1_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py35h1793315_7", + "python >=3.5,<3.6.0a0" + ], + "md5": "024eb49b2ce5662d658c480213433fb7", + "name": "numpy-devel", + "namespace": "python", + "sha256": "85e00f88f0e6a4a8c26f05180b463d8dd1bbc408426bf8e310e61bdffc8f00a4", + "size": 8613, + "subdir": "linux-64", + "timestamp": 1534772987108, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py35ha22f7c6_7.tar.bz2": { + "build": "py35ha22f7c6_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py35hdbf6ddf_7", + "python >=3.5,<3.6.0a0" + ], + "md5": "6ff8e5b0bf14966e7de9f57386fb81bd", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b959a7e721602c126168bcb429f9446a2869125d2c3fb15e4f2a94db16b85726", + "size": 8943, + "subdir": "linux-64", + "timestamp": 1530694468713, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py36h025eb46_6.tar.bz2": { + "build": "py36h025eb46_6", + "build_number": 6, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.9.3 py36h2b20989_6", + "python >=3.6,<3.7.0a0" + ], + "md5": "e0e9e19a5ba60239caea5be5338c009c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "16f79efdfc5cb14315ab9882de417302e48bf10c5d25974cbe133b918714db34", + "size": 8890, + "subdir": "linux-64", + "timestamp": 1530380885972, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py36h025eb46_7.tar.bz2": { + "build": "py36h025eb46_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.9.3 py36h2b20989_7", + "python >=3.6,<3.7.0a0" + ], + "md5": "2a67d58f9410beb79e424752e134d74d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "3e8d1c34e2fc750ea613f5437c4ca39b37bf5ffaafd933bf2c11c1c5a815d6f6", + "size": 8975, + "subdir": "linux-64", + "timestamp": 1530550449566, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py36h8f55a68_7.tar.bz2": { + "build": "py36h8f55a68_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.9.3 py36hc937464_7", + "python >=3.6,<3.7.0a0" + ], + "md5": "4eee25698db13812e095c1b36491978e", + "name": "numpy-devel", + "namespace": "python", + "sha256": "9b2d2243e6ffd12694b063d527fa38b635a1b96edce9771f2cb0a77dc91970e7", + "size": 8625, + "subdir": "linux-64", + "timestamp": 1534773913606, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py36h99ba2d1_7.tar.bz2": { + "build": "py36h99ba2d1_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py36h1793315_7", + "python >=3.6,<3.7.0a0" + ], + "md5": "9ef300559720257fc84890b94e96a1aa", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a9b04453c8d30ef63be3ba1a7937f1ce5c79aa881cf003f3c361164ac210d3ac", + "size": 8592, + "subdir": "linux-64", + "timestamp": 1534773682547, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py36ha22f7c6_6.tar.bz2": { + "build": "py36ha22f7c6_6", + "build_number": 6, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py36hdbf6ddf_6", + "python >=3.6,<3.7.0a0" + ], + "md5": "b37d863d3b5c22674151c8e6b65140a9", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0770725f67bfb015c0ad583648704381ba14e5235d10f1d81dc4f404c79d4fc5", + "size": 8871, + "subdir": "linux-64", + "timestamp": 1530383451195, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py36ha22f7c6_7.tar.bz2": { + "build": "py36ha22f7c6_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py36hdbf6ddf_7", + "python >=3.6,<3.7.0a0" + ], + "md5": "72fd2e5072e604136a09bba888740235", + "name": "numpy-devel", + "namespace": "python", + "sha256": "64e0a5e6d8c3cabfd9d55cfb624ed13bc22a9ed241ec799e9c95d8361a091631", + "size": 8962, + "subdir": "linux-64", + "timestamp": 1530553689513, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py37h025eb46_6.tar.bz2": { + "build": "py37h025eb46_6", + "build_number": 6, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.9.3 py37h2b20989_6", + "python >=3.7,<3.8.0a0" + ], + "md5": "be04ca85afbccf2d2a72440e0146e282", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6ebe06dd841eb0ee66e840ef52e7280c7812d032c5f46115e563a17c2f4cf4ab", + "size": 8895, + "subdir": "linux-64", + "timestamp": 1530381454006, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py37h025eb46_7.tar.bz2": { + "build": "py37h025eb46_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.9.3 py37h2b20989_7", + "python >=3.7,<3.8.0a0" + ], + "md5": "50ce0abdc7b4daae943cd1358330ff6b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "3b5c1d0e64f7ac6f44ef2f2a383e3200fa4f30aeecf52d8340c15511831fe02c", + "size": 8967, + "subdir": "linux-64", + "timestamp": 1530550936698, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py37h8f55a68_7.tar.bz2": { + "build": "py37h8f55a68_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.9.3 py37hc937464_7", + "python >=3.7,<3.8.0a0" + ], + "md5": "a2e3b8f47372bad337fb319b79f75476", + "name": "numpy-devel", + "namespace": "python", + "sha256": "df8e6d40288d154c861b8eaba22214af49bc435040de058ee9d3c3bbff8cce9e", + "size": 8624, + "subdir": "linux-64", + "timestamp": 1534774383503, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py37h99ba2d1_7.tar.bz2": { + "build": "py37h99ba2d1_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py37h1793315_7", + "python >=3.7,<3.8.0a0" + ], + "md5": "377c45da66dbc6175efff1da3f60a463", + "name": "numpy-devel", + "namespace": "python", + "sha256": "5e0658ba3d11dcd8dd6e3f00500a3b580e69b72dcd14092c0be5df5732ff6296", + "size": 8603, + "subdir": "linux-64", + "timestamp": 1534774147168, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py37ha22f7c6_6.tar.bz2": { + "build": "py37ha22f7c6_6", + "build_number": 6, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py37hdbf6ddf_6", + "python >=3.7,<3.8.0a0" + ], + "md5": "10d61444425012789d0c5171a8d71bda", + "name": "numpy-devel", + "namespace": "python", + "sha256": "404b4724553f8a395fb0d560f5e4b77679d3ea4ca20ee4efda3186181378e30b", + "size": 8870, + "subdir": "linux-64", + "timestamp": 1530382696081, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py37ha22f7c6_7.tar.bz2": { + "build": "py37ha22f7c6_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py37hdbf6ddf_7", + "python >=3.7,<3.8.0a0" + ], + "md5": "6978e262ff4267ecd7f99f71bb193907", + "name": "numpy-devel", + "namespace": "python", + "sha256": "71ca65d2b6d36719c32eeab3d6007516688a002f54b8af5c869a9f673e2b3cef", + "size": 8961, + "subdir": "linux-64", + "timestamp": 1530553809592, + "version": "1.9.3" + }, + "numpydoc-0.7.0-py27h9647a75_0.tar.bz2": { + "build": "py27h9647a75_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "sphinx" + ], + "license": "BSD 3-Clause", + "md5": "6929a9f0debb2f486318592c0eb2e5a5", + "name": "numpydoc", + "sha256": "a915b942ce08c23e7448c5d99f4db714088a409bec68b2e4ce1c44178a56af5a", + "size": 37946, + "subdir": "linux-64", + "timestamp": 1505747054545, + "version": "0.7.0" + }, + "numpydoc-0.7.0-py35he089a57_0.tar.bz2": { + "build": "py35he089a57_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "sphinx" + ], + "license": "BSD 3-Clause", + "md5": "9a63017a458c22c395a1f4975edaf2d3", + "name": "numpydoc", + "sha256": "ce0ae39dfed5e2403f55d3a2b6a2456b66316a9ef4b0d30034a79ccfd3fd35d5", + "size": 39029, + "subdir": "linux-64", + "timestamp": 1505747068085, + "version": "0.7.0" + }, + "numpydoc-0.7.0-py36h18f165f_0.tar.bz2": { + "build": "py36h18f165f_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "sphinx" + ], + "license": "BSD 3-Clause", + "md5": "0cbfcde4cf4b7c68abadcc3b6bce23d0", + "name": "numpydoc", + "sha256": "5ec3a32ddceff89e10734c9c869b864b8d4c001b9aafca22eca2c4cd6e875e93", + "size": 38867, + "subdir": "linux-64", + "timestamp": 1505747082188, + "version": "0.7.0" + }, + "numpydoc-0.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "sphinx" + ], + "license": "BSD 3-Clause", + "md5": "9f8cf32adf2d310f6f72321efe04d16d", + "name": "numpydoc", + "sha256": "f010ef026a4b10912739bb42ae3e4c887579b59b1b173f36d1f4a2209bc4e0ec", + "size": 42075, + "subdir": "linux-64", + "timestamp": 1522687461487, + "version": "0.8.0" + }, + "numpydoc-0.8.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "sphinx" + ], + "license": "BSD 3-Clause", + "md5": "3e97898cd5863f112d9c463638d6f139", + "name": "numpydoc", + "sha256": "b0e2102279605d6d7b8fbe001ead249c52c0a9c6a58a1b9fb87e5b56596f6e3f", + "size": 43446, + "subdir": "linux-64", + "timestamp": 1522687396508, + "version": "0.8.0" + }, + "numpydoc-0.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "sphinx" + ], + "license": "BSD 3-Clause", + "md5": "892c084bbeb5942465e5dc0323c5c474", + "name": "numpydoc", + "sha256": "fe092f6f2d6061326dbb526af6a3ba4a2b4740e78ccc990a49a0942d9ed06d26", + "size": 43139, + "subdir": "linux-64", + "timestamp": 1522687467693, + "version": "0.8.0" + }, + "numpydoc-0.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "sphinx" + ], + "license": "BSD 3-Clause", + "md5": "77b9e2aa732bf1922afb71db3f3dafd9", + "name": "numpydoc", + "sha256": "0582cd56035a1179ca8dbce5e58927ed1e628c4ea29d2becf8a4acf16eeb705c", + "size": 42991, + "subdir": "linux-64", + "timestamp": 1530733649694, + "version": "0.8.0" + }, + "numpydoc-1.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.10", + "python >=3.10,<3.11.0a0", + "sphinx >=3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fbc323192eb62f15e3d1966fa496f9da", + "name": "numpydoc", + "sha256": "a8b11327c8ef4076812fc05cf093f30ed29a54cd1e07650bafac47e98773d37a", + "size": 88861, + "subdir": "linux-64", + "timestamp": 1657530012299, + "version": "1.4.0" + }, + "numpydoc-1.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.10", + "python >=3.7,<3.8.0a0", + "sphinx >=3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e96de07fa316288a1d007dd65c35849", + "name": "numpydoc", + "sha256": "f9cbf07a357c106d3414e3debdc62c0c062dc32177afe4dc3b3a79c78aed2d9a", + "size": 87205, + "subdir": "linux-64", + "timestamp": 1657529967568, + "version": "1.4.0" + }, + "numpydoc-1.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.10", + "python >=3.8,<3.9.0a0", + "sphinx >=3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f2d55996b28cb061bb86f493ae007e2", + "name": "numpydoc", + "sha256": "dd8d891f03cb245fb9ec6e1badaba3489d7b8f36295345521ece293c75a259ac", + "size": 87391, + "subdir": "linux-64", + "timestamp": 1657529901922, + "version": "1.4.0" + }, + "numpydoc-1.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.10", + "python >=3.9,<3.10.0a0", + "sphinx >=3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e64876fdb1d77fd7d56138255a07454", + "name": "numpydoc", + "sha256": "365939ea4593c38bf6c1885f134d3bb41ae622591087498ec163374712642529", + "size": 87326, + "subdir": "linux-64", + "timestamp": 1657529935769, + "version": "1.4.0" + }, + "numpydoc-1.5.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.10", + "python >=3.10,<3.11.0a0", + "sphinx >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f08440f0102cb9e12541db0992ef9353", + "name": "numpydoc", + "sha256": "5756e87a7089bd78b4cbf4352ed274e3d989801174edb3d518340592229803d5", + "size": 89991, + "subdir": "linux-64", + "timestamp": 1668085935282, + "version": "1.5.0" + }, + "numpydoc-1.5.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.10", + "python >=3.11,<3.12.0a0", + "sphinx >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "99f73581f67ed46eadc421f4ff689730", + "name": "numpydoc", + "sha256": "c057e8613811966921e38f58c843ba759997f31e44d0f9cea8c5e446ad14a55d", + "size": 116846, + "subdir": "linux-64", + "timestamp": 1676845068929, + "version": "1.5.0" + }, + "numpydoc-1.5.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.10", + "python >=3.7,<3.8.0a0", + "sphinx >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "77e8a03630910ee0b75ce6de80f6848a", + "name": "numpydoc", + "sha256": "8ae5580d33a2e5c1f8327c896c25000502075f5460d58af3673c5733ba0831e7", + "size": 88368, + "subdir": "linux-64", + "timestamp": 1668085964369, + "version": "1.5.0" + }, + "numpydoc-1.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.10", + "python >=3.8,<3.9.0a0", + "sphinx >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "99502695a9019a2645a4bb0ec212dca9", + "name": "numpydoc", + "sha256": "4abe357c3be73709276e627e22323758c16435f6db3c2161d8ce7cd5d2de481b", + "size": 88544, + "subdir": "linux-64", + "timestamp": 1668086021357, + "version": "1.5.0" + }, + "numpydoc-1.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.10", + "python >=3.9,<3.10.0a0", + "sphinx >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6efc32ada891b152f8da47bfa8e216f0", + "name": "numpydoc", + "sha256": "1e69c2665a1d87bd9ef817f836ef6fc51814e088017f5805ce0b63f898922e0f", + "size": 88533, + "subdir": "linux-64", + "timestamp": 1668085993171, + "version": "1.5.0" + }, + "nvcc_linux-64-10.0-h91b26fc_10.tar.bz2": { + "build": "h91b26fc_10", + "build_number": 10, + "depends": [], + "license": "BSD-3-Clause", + "md5": "a6eb608f4e6f4dac96aec84fa6d2c3b5", + "name": "nvcc_linux-64", + "sha256": "d1e2de9b250a0891352ee9181ffe2abb9b43af75bc1958bcaa495efad1027fc4", + "size": 9651, + "subdir": "linux-64", + "timestamp": 1610053422395, + "version": "10.0" + }, + "nvcc_linux-64-10.1-hcaf9a05_10.tar.bz2": { + "build": "hcaf9a05_10", + "build_number": 10, + "depends": [], + "license": "BSD-3-Clause", + "md5": "c1aca2776d63602026ef6a390362b312", + "name": "nvcc_linux-64", + "sha256": "3b013d85e96a6c6fb3021d2c806f28fe2aa73fe7f9a7d50e8b410a8b4fba6de0", + "size": 9685, + "subdir": "linux-64", + "timestamp": 1610061017161, + "version": "10.1" + }, + "nvcc_linux-64-9.2-heaad284_10.tar.bz2": { + "build": "heaad284_10", + "build_number": 10, + "depends": [], + "license": "BSD-3-Clause", + "md5": "033264297aaa7fa046907238cc11a3e4", + "name": "nvcc_linux-64", + "sha256": "91366e3717ec85cac72575cbf5f506f50fb981e5504c8559a3d1eea829aacc87", + "size": 9633, + "subdir": "linux-64", + "timestamp": 1610039234021, + "version": "9.2" + }, + "oauthenticator-15.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema", + "jupyterhub >=1.2", + "python >=3.10,<3.11.0a0", + "requests", + "ruamel.yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "74517ee61cad883b945606ae3aba0d70", + "name": "oauthenticator", + "sha256": "5a16fb4529c044c49233953c124a7358b4f8924d357c5898fb93b7309e88a668", + "size": 91184, + "subdir": "linux-64", + "timestamp": 1663706821453, + "version": "15.1.0" + }, + "oauthenticator-15.1.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema", + "jupyterhub >=1.2", + "python >=3.11,<3.12.0a0", + "requests", + "ruamel.yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7cfbb1e0c665f6fcba49bc1e4f75e069", + "name": "oauthenticator", + "sha256": "1b85a61aa8a9c209834920a72fdacc6606afb3ecbd16bd9e37343361523b76d8", + "size": 117820, + "subdir": "linux-64", + "timestamp": 1679340122399, + "version": "15.1.0" + }, + "oauthenticator-15.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema", + "jupyterhub >=1.2", + "python >=3.7,<3.8.0a0", + "requests", + "ruamel.yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3c7a57b882d5ad8ea945a8eb1e3271d3", + "name": "oauthenticator", + "sha256": "443931008baf39758ce8c262d319c40c60ee28e5fa6f2929db910f0d03951d5a", + "size": 90102, + "subdir": "linux-64", + "timestamp": 1663706776707, + "version": "15.1.0" + }, + "oauthenticator-15.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema", + "jupyterhub >=1.2", + "python >=3.8,<3.9.0a0", + "requests", + "ruamel.yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9d6ac482d1838beec537699d74a05630", + "name": "oauthenticator", + "sha256": "64366c8f0833fb7d9ac27bff1bf1bb915c61afc91f764e4eaf4f7c298dee3423", + "size": 90578, + "subdir": "linux-64", + "timestamp": 1663706710659, + "version": "15.1.0" + }, + "oauthenticator-15.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema", + "jupyterhub >=1.2", + "python >=3.9,<3.10.0a0", + "requests", + "ruamel.yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "96e6522d14cca6290f41e1a58ce27b54", + "name": "oauthenticator", + "sha256": "01682486ce742f1e4d4ce866cfdaada72f3dc0700ee3d0a462c97a943d0316d1", + "size": 90504, + "subdir": "linux-64", + "timestamp": 1663706744667, + "version": "15.1.0" + }, + "oauthlib-2.0.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e4ddd326fd1884a2849f272b54ba5a2b", + "name": "oauthlib", + "sha256": "b081d968f35744be07d2c042ede96b91c11f23581f2842cbb9fc85071c404767", + "size": 121966, + "subdir": "linux-64", + "timestamp": 1525813349005, + "version": "2.0.7" + }, + "oauthlib-2.0.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bd0574014c023a9db9b3f76cd0f77615", + "name": "oauthlib", + "sha256": "4c50f706cc5be8ec89cc26aa362d4e42f7d0cb28d54530b24ca7242be99edd70", + "size": 124467, + "subdir": "linux-64", + "timestamp": 1525813627940, + "version": "2.0.7" + }, + "oauthlib-2.0.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5d2aebde00795849e7b3f5678cc59be8", + "name": "oauthlib", + "sha256": "dff211294069a9d1b6b7223d94d012df2f5dc36b2b36fbab3e8c1c9986bdb37a", + "size": 124500, + "subdir": "linux-64", + "timestamp": 1525813627094, + "version": "2.0.7" + }, + "oauthlib-2.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a8f8c4172a5ee7c6e69d82f2e3f58ece", + "name": "oauthlib", + "sha256": "c6891e7c8de2b96f1ea11a54c08411037f91d0f0546e88af2f71ac847e868dc2", + "size": 122072, + "subdir": "linux-64", + "timestamp": 1527855962685, + "version": "2.1.0" + }, + "oauthlib-2.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "83cc5af34c241595302cf5b057f66a96", + "name": "oauthlib", + "sha256": "02670c01b895e8a74ded0e4ccb099229abea5cd7923ba4a4d3b4150b24b4a135", + "size": 124431, + "subdir": "linux-64", + "timestamp": 1527855887913, + "version": "2.1.0" + }, + "oauthlib-2.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "340b662a44009527b3a07ed76d9fa109", + "name": "oauthlib", + "sha256": "59d6665f6e6223b2a0a8f82c4b0c1ac702bdefe9c7441e5f00dc32e964178ddc", + "size": 124468, + "subdir": "linux-64", + "timestamp": 1527855926813, + "version": "2.1.0" + }, + "oauthlib-2.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "608b54486e190d08fca1374b6911e675", + "name": "oauthlib", + "sha256": "85b41e2cacb58dac637c8b7f93f2ec5d343c7cd3a1a0f41e1e0ca1d18ea49760", + "size": 124823, + "subdir": "linux-64", + "timestamp": 1545089218274, + "version": "2.1.0" + }, + "oauthlib-3.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f401f7115ca440c95862b52c42954016", + "name": "oauthlib", + "sha256": "0ef3c70b3994eb16cba5696c4cafe543aeb1a8edc24b91458fa62cada282ceb0", + "size": 154630, + "subdir": "linux-64", + "timestamp": 1547792451516, + "version": "3.0.0" + }, + "oauthlib-3.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5c44d78930365ef364d18df626e5927f", + "name": "oauthlib", + "sha256": "fea891a1530e1729d571721d0e3e4d550f421c3dfff808234c6b28fe5b7edbaf", + "size": 152731, + "subdir": "linux-64", + "timestamp": 1547791686191, + "version": "3.0.0" + }, + "oauthlib-3.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5fed5f63b2ec28cda5ac965839f71dc8", + "name": "oauthlib", + "sha256": "213495de3adf9ce78c5f66460a7b4cb00ff7a5f089165b37d28984daff1a6bd3", + "size": 152412, + "subdir": "linux-64", + "timestamp": 1547791732682, + "version": "3.0.0" + }, + "oauthlib-3.2.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "blinker >=1.4.0", + "cryptography >=3.0.0", + "pyjwt >=2.0.0,<3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b3c59d1dd689581124d337dd4d644b2a", + "name": "oauthlib", + "sha256": "1a06f502a5d453ed556eab5073e0384b1908decd1cd5d2a55b3ca2522c39aa30", + "size": 229991, + "subdir": "linux-64", + "timestamp": 1665490956937, + "version": "3.2.1" + }, + "oauthlib-3.2.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "blinker >=1.4.0", + "cryptography >=3.0.0", + "pyjwt >=2.0.0,<3", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "778b4155dfafd6580c1328c200bba988", + "name": "oauthlib", + "sha256": "113bd18693a99a7bee9da4432cca3d83c71712bbc56bee53b7bc87a706eead15", + "size": 263371, + "subdir": "linux-64", + "timestamp": 1676841382173, + "version": "3.2.1" + }, + "oauthlib-3.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "blinker >=1.4.0", + "cryptography >=3.0.0", + "pyjwt >=2.0.0,<3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fab7a5959ab0addb8ca85ef8a64bb3ac", + "name": "oauthlib", + "sha256": "6ec42932cccd4e5923ec885675d9deb66c0e587cbf6a858f22e7e15baa7b4825", + "size": 228139, + "subdir": "linux-64", + "timestamp": 1665490985773, + "version": "3.2.1" + }, + "oauthlib-3.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "blinker >=1.4.0", + "cryptography >=3.0.0", + "pyjwt >=2.0.0,<3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d8097f4c45503e55ee37d5db59fa5b52", + "name": "oauthlib", + "sha256": "23c18a7a075a301db1b2daf844d255301d4ac865d48572b41832c37e8ce6a5a4", + "size": 228936, + "subdir": "linux-64", + "timestamp": 1665490926140, + "version": "3.2.1" + }, + "oauthlib-3.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "blinker >=1.4.0", + "cryptography >=3.0.0", + "pyjwt >=2.0.0,<3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "05d8603654c70c6cbc6f14e12c425e6e", + "name": "oauthlib", + "sha256": "c2df6a54b1d4843b9d40e01b192f4b3bd649b66fb7dcc0a700aa5666fc080025", + "size": 228719, + "subdir": "linux-64", + "timestamp": 1665491013966, + "version": "3.2.1" + }, + "oauthlib-3.2.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "blinker >=1.4.0", + "cryptography >=3.0.0", + "pyjwt >=2.0.0,<3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "662d78b8dafb156daef0aec61db88fe9", + "name": "oauthlib", + "sha256": "a0d3f1c48d2818c10bb2e8d3749b1b487c0caf3b950fe843a070dccf4c9b631f", + "size": 232744, + "subdir": "linux-64", + "timestamp": 1679489651614, + "version": "3.2.2" + }, + "oauthlib-3.2.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "blinker >=1.4.0", + "cryptography >=3.0.0", + "pyjwt >=2.0.0,<3", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0905fb0b9f75860a4536325de4ca1da8", + "name": "oauthlib", + "sha256": "6b05c3e1e82ed63d6713228f70bc6646fb89fcb2fd9083fa85f09a17b1f6f6af", + "size": 263172, + "subdir": "linux-64", + "timestamp": 1679489741805, + "version": "3.2.2" + }, + "oauthlib-3.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "blinker >=1.4.0", + "cryptography >=3.0.0", + "pyjwt >=2.0.0,<3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0c1a46318df07173309a57c9768d24dd", + "name": "oauthlib", + "sha256": "6f42317f61f7aa7fbf82f955323474c0ba45087e02e21b097a985ea56d121981", + "size": 231633, + "subdir": "linux-64", + "timestamp": 1679489680671, + "version": "3.2.2" + }, + "oauthlib-3.2.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "blinker >=1.4.0", + "cryptography >=3.0.0", + "pyjwt >=2.0.0,<3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "590467d4dfbc3ffd3ce29d94dd9ca6f5", + "name": "oauthlib", + "sha256": "4aaeb8071252fa7673ea7e6ed71a1c8f08c43efc858b1fbf55eea6ffaf333df2", + "size": 232718, + "subdir": "linux-64", + "timestamp": 1679489711205, + "version": "3.2.2" + }, + "objconv-2.49-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "67c239cde6d278af230b69208478d57c", + "name": "objconv", + "sha256": "ab39f650a46becde9ee3a744dec9ce67abce1371ec1f22f105def4da7c4341b1", + "size": 280508, + "subdir": "linux-64", + "timestamp": 1588116287087, + "version": "2.49" + }, + "odo-0.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "dask >=0.11.1", + "datashape >=0.5.0", + "multipledispatch >=0.4.7", + "networkx >=1.0", + "numpy >=1.7", + "pandas >=0.15.0", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7cf9a7c1ff194fc6b0a03c445caafb77", + "name": "odo", + "sha256": "6e945050e3b60bda92fc5cf994b068cae9c292bd8e2a8b380a0a082445d144f3", + "size": 202454, + "subdir": "linux-64", + "timestamp": 1530780038362, + "version": "0.5.1" + }, + "odo-0.5.1-py27h9170de3_0.tar.bz2": { + "build": "py27h9170de3_0", + "build_number": 0, + "depends": [ + "dask >=0.11.1", + "datashape >=0.5.0", + "multipledispatch >=0.4.7", + "networkx >=1.0", + "numpy >=1.7", + "pandas >=0.15.0", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6438d6669357aaa6a646cd104fd5072f", + "name": "odo", + "sha256": "e9a0a343e0711d537fa93c68bbcb14decfb166e2811314bf83b2a9c375dfb9e7", + "size": 202127, + "subdir": "linux-64", + "timestamp": 1505740114297, + "version": "0.5.1" + }, + "odo-0.5.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=0.11.1", + "datashape >=0.5.0", + "multipledispatch >=0.4.7", + "networkx >=1.0", + "numpy >=1.7", + "pandas >=0.15.0", + "python >=3.10,<3.11.0a0", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3832c51d82354c6b8cb2d3cc9eeb4cd3", + "name": "odo", + "sha256": "2d7ae76fe72b24f50d234e43d6788aa0ca00fcde5cbacb60ba13919c730dbaeb", + "size": 202422, + "subdir": "linux-64", + "timestamp": 1640812588751, + "version": "0.5.1" + }, + "odo-0.5.1-py35h102315f_0.tar.bz2": { + "build": "py35h102315f_0", + "build_number": 0, + "depends": [ + "dask >=0.11.1", + "datashape >=0.5.0", + "multipledispatch >=0.4.7", + "networkx >=1.0", + "numpy >=1.7", + "pandas >=0.15.0", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "81de894a2b1e91eac0cbdf7e49b0c202", + "name": "odo", + "sha256": "bb9e1caef87ac774000079be912e6239994e9de9e5643b604516f5b378d18b61", + "size": 200430, + "subdir": "linux-64", + "timestamp": 1505740135679, + "version": "0.5.1" + }, + "odo-0.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "dask >=0.11.1", + "datashape >=0.5.0", + "multipledispatch >=0.4.7", + "networkx >=1.0", + "numpy >=1.7", + "pandas >=0.15.0", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "601e98f46f2cf094d971f27477f27208", + "name": "odo", + "sha256": "3ba29a489236eb0d2ae107c26ba1385520e628f067274b15d77e62df0a2218fd", + "size": 198133, + "subdir": "linux-64", + "timestamp": 1530780075033, + "version": "0.5.1" + }, + "odo-0.5.1-py36h90ed295_0.tar.bz2": { + "build": "py36h90ed295_0", + "build_number": 0, + "depends": [ + "dask >=0.11.1", + "datashape >=0.5.0", + "multipledispatch >=0.4.7", + "networkx >=1.0", + "numpy >=1.7", + "pandas >=0.15.0", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a4f11c5b4f698cb9cd354ac65fbf55c", + "name": "odo", + "sha256": "4be9656592d14ba83cb22d75763711573ae2f9babbf32ac62eab991780a6da90", + "size": 197758, + "subdir": "linux-64", + "timestamp": 1505740157583, + "version": "0.5.1" + }, + "odo-0.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dask >=0.11.1", + "datashape >=0.5.0", + "multipledispatch >=0.4.7", + "networkx >=1.0", + "numpy >=1.7", + "pandas >=0.15.0", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f1236652b140980c87d2e4ff409810c0", + "name": "odo", + "sha256": "627944a9eb2a7b23b9d90930c7eadfb8cc0e6a780feb718b7dc60c86cbaa9f03", + "size": 197758, + "subdir": "linux-64", + "timestamp": 1530780006978, + "version": "0.5.1" + }, + "odo-0.5.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "dask >=0.11.1", + "datashape >=0.5.0", + "multipledispatch >=0.4.7", + "networkx >=1.0", + "numpy >=1.7", + "pandas >=0.15.0", + "python >=3.8,<3.9.0a0", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "92469dafea1678c23ee99fbecda6a020", + "name": "odo", + "sha256": "b7b7348a11669c6d951dc3309ce021c2d5c6e83e91bab72b3e97aa01717b6b9c", + "size": 199440, + "subdir": "linux-64", + "timestamp": 1574235835534, + "version": "0.5.1" + }, + "olefile-0.44-py27h4bd3e3c_0.tar.bz2": { + "build": "py27h4bd3e3c_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License 2-Clause", + "license_family": "BSD", + "md5": "69e32d3a2a75904f4425b8cbecf2997a", + "name": "olefile", + "sha256": "81d0776177b084900e4423349655c28a514af377824418915cefded0f0db5569", + "size": 53178, + "subdir": "linux-64", + "timestamp": 1505744401417, + "version": "0.44" + }, + "olefile-0.44-py35h2c86149_0.tar.bz2": { + "build": "py35h2c86149_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD License 2-Clause", + "license_family": "BSD", + "md5": "440202d9040fccd94f440ebbc4727746", + "name": "olefile", + "sha256": "37e1dc2d5393d6945599ef8171ade462787cf5b8e394a887f92bf86b8444e0c0", + "size": 53623, + "subdir": "linux-64", + "timestamp": 1505744413921, + "version": "0.44" + }, + "olefile-0.44-py36h79f9f78_0.tar.bz2": { + "build": "py36h79f9f78_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License 2-Clause", + "license_family": "BSD", + "md5": "f1ac9551dfe953125ab6f63cb2413a57", + "name": "olefile", + "sha256": "6363ae58efc5be9dbc32a0563aa1b7a3840b28eebbcf3e1ed9e6491f8b179870", + "size": 53716, + "subdir": "linux-64", + "timestamp": 1505744426115, + "version": "0.44" + }, + "olefile-0.45.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License 2-Clause", + "license_family": "BSD", + "md5": "722bb2cb295b55b3dbb6911439cf9fad", + "name": "olefile", + "sha256": "9ed332e52a58d572236fc4d8aa5e8f29d99b4580003f0e307df10e106766a313", + "size": 47979, + "subdir": "linux-64", + "timestamp": 1517331222763, + "version": "0.45.1" + }, + "olefile-0.45.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD License 2-Clause", + "license_family": "BSD", + "md5": "36afe7c368c2e61759312d653292d467", + "name": "olefile", + "sha256": "0d504c20e1a80783448aecc97b8306c7cc3246a0357c55ca4f02249252fbbb00", + "size": 48389, + "subdir": "linux-64", + "timestamp": 1517331233527, + "version": "0.45.1" + }, + "olefile-0.45.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License 2-Clause", + "license_family": "BSD", + "md5": "dd5cf656ec63ce17c6f34aafecc377dc", + "name": "olefile", + "sha256": "fec671afddd2b39fecaa14863919906985641c8d35ba80445c500ca0b46c8f77", + "size": 48368, + "subdir": "linux-64", + "timestamp": 1517331239303, + "version": "0.45.1" + }, + "olefile-0.45.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD License 2-Clause", + "license_family": "BSD", + "md5": "b49c1a44df3995d597b9147fe28482f3", + "name": "olefile", + "sha256": "b5eda18ab233e78104eb751c0e244e0bc77283cad02cd4b6c41ada799d7f353d", + "size": 48413, + "subdir": "linux-64", + "timestamp": 1530792989148, + "version": "0.45.1" + }, + "olefile-0.46-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "fbbe8978b9f9d336ddf9828df51044b5", + "name": "olefile", + "sha256": "b69647be01e81db0e4f70a4f37bce58cf2968ac53e1fa7a7a2d47b7b5fd9f939", + "size": 48981, + "subdir": "linux-64", + "timestamp": 1536697159606, + "version": "0.46" + }, + "olefile-0.46-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "25753f09146ac812a6e07c42869bce42", + "name": "olefile", + "sha256": "b5e12dc3f0b36bafbf8348bca5ce4dc48f1053ea2b49610305de1487624c8ce1", + "size": 49454, + "subdir": "linux-64", + "timestamp": 1536697215244, + "version": "0.46" + }, + "olefile-0.46-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "35b7d67a5773f51185f2cdc843594157", + "name": "olefile", + "sha256": "1705cb3cf9c71ae6556ca0bc6a09b458010746f6f0bb6fb3fcd0a55469e59e25", + "size": 49516, + "subdir": "linux-64", + "timestamp": 1536697214297, + "version": "0.46" + }, + "olefile-0.46-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "66eccdf0f485e5ee525ef3becd423067", + "name": "olefile", + "sha256": "42a65662c9f757848eb1ac9e30b37713b3b40df46fd4ec071eafacb4f676b199", + "size": 49475, + "subdir": "linux-64", + "timestamp": 1536697142672, + "version": "0.46" + }, + "omniscidb-5.6.2-h2b6add4_0_cpu.tar.bz2": { + "build": "h2b6add4_0_cpu", + "build_number": 0, + "depends": [ + "arrow-cpp >=2.0.0,<2.0.1.0a0", + "blosc >=1.21.0,<2.0a0", + "boost-cpp >=1.73.0,<1.73.1.0a0", + "bzip2", + "double-conversion", + "gxx_linux-64", + "libarchive >=3.4.2,<3.5.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libclang-cpp <12", + "libgcc-ng >=8.4.0", + "libgdal >=3.0.2,<3.1.0a0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "librdkafka >=1.6.0,<1.7.0a0", + "libstdcxx-ng >=8.4.0", + "libthrift >=0.13.0,<0.14.0a0", + "ncurses", + "omniscidb-common >=5.6.2,<5.6.3.0a0", + "openjdk 8.*", + "openssl >=1.1.1k,<1.1.2a", + "snappy >=1.1.8,<2.0a0", + "tbb >=2021.2.0", + "xz", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "636e452f2efe9b05018c6e49e3821adf", + "name": "omniscidb", + "sha256": "37cff8b665a820d0031332c0d6e784600b9bef7204d96f3938c8297a71095f0f", + "size": 16855413, + "subdir": "linux-64", + "timestamp": 1626375037313, + "version": "5.6.2" + }, + "omniscidb-5.7.0-h244a1a9_0_cpu.tar.bz2": { + "build": "h244a1a9_0_cpu", + "build_number": 0, + "depends": [ + "arrow-cpp >=2.0.0,<2.0.1.0a0", + "blosc >=1.21.0,<2.0a0", + "boost-cpp >=1.73.0,<1.73.1.0a0", + "bzip2", + "double-conversion", + "gxx_linux-64", + "libarchive >=3.4.2,<3.5.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libclang-cpp <12", + "libgcc-ng >=9.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "librdkafka >=1.6.0,<1.7.0a0", + "libstdcxx-ng >=9.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "ncurses", + "omniscidb-common >=5.7.0,<5.7.1.0a0", + "openjdk 8.*", + "openssl >=1.1.1l,<1.1.2a", + "snappy >=1.1.8,<2.0a0", + "tbb >=2021.3.0", + "xz", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "26cbfafdd0e15c716c19e5eddbc752ae", + "name": "omniscidb", + "sha256": "237c69a1c7d25276fed956d7cb0aee8d1943700e9945428cc2c90ec44bcb8984", + "size": 17415989, + "subdir": "linux-64", + "timestamp": 1630620642504, + "version": "5.7.0" + }, + "omniscidb-5.7.1-h244a1a9_0_cpu.tar.bz2": { + "build": "h244a1a9_0_cpu", + "build_number": 0, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "blosc >=1.21.0,<2.0a0", + "boost-cpp >=1.73.0,<1.73.1.0a0", + "bzip2", + "double-conversion", + "fmt >=7.1.3,<8.0a0", + "gxx_linux-64", + "libarchive >=3.4.2,<3.5.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libclang-cpp <12", + "libgcc-ng >=9.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "librdkafka >=1.6.0,<1.7.0a0", + "libstdcxx-ng >=9.3.0", + "libthrift >=0.14.2,<0.14.3.0a0", + "ncurses", + "omniscidb-common >=5.7.1,<5.7.2.0a0", + "openjdk 8.*", + "openssl >=1.1.1l,<1.1.2a", + "snappy >=1.1.8,<2.0a0", + "tbb >=2021.3.0", + "xz", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "04f88f91ab663bd9f67f5a008760f4f6", + "name": "omniscidb", + "sha256": "8bef4bca60c84248ce69cc586ec1dff0c4f9694e13354c1b3272c4874957a39c", + "size": 17425568, + "subdir": "linux-64", + "timestamp": 1632952651465, + "version": "5.7.1" + }, + "omniscidb-common-5.10.1-hc204824_0.tar.bz2": { + "build": "hc204824_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=9.3.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5e6d4541c273fdc32c43658cd32b94c6", + "name": "omniscidb-common", + "sha256": "b44142ca11a585b30fa283103596e69de2184d9034f780a671a37952cb6c2036", + "size": 74379289, + "subdir": "linux-64", + "timestamp": 1658969685920, + "version": "5.10.1" + }, + "omniscidb-common-5.6.2-hd589b2d_0.tar.bz2": { + "build": "hd589b2d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=8.4.0", + "libstdcxx-ng >=8.4.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a2aaf9da3b8d7911373f82d0825fe811", + "name": "omniscidb-common", + "sha256": "7f6634f3da6dfe0909c5899b51c386d5bbac8c0e40547ee3ffccf1537684bdfe", + "size": 70430253, + "subdir": "linux-64", + "timestamp": 1626374412309, + "version": "5.6.2" + }, + "omniscidb-common-5.7.0-hfd7591c_0.tar.bz2": { + "build": "hfd7591c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7cee7b7f1091c4a58aaac9e45a5f82c7", + "name": "omniscidb-common", + "sha256": "dc75d558a4db3cbecd15b59ee43e2c0f1c191734ea906b86f394293123626431", + "size": 69762806, + "subdir": "linux-64", + "timestamp": 1630620400840, + "version": "5.7.0" + }, + "omniscidb-common-5.7.1-hfd7591c_0.tar.bz2": { + "build": "hfd7591c_0", + "build_number": 0, + "depends": [ + "fmt >=7.1.3,<8.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "77c429554b208af54908f70be9cdb47c", + "name": "omniscidb-common", + "sha256": "262175fca184e0590fa4db9a25cb8e38c34c8c53d01b007b461592b88e09e41a", + "size": 78833955, + "subdir": "linux-64", + "timestamp": 1632952410634, + "version": "5.7.1" + }, + "omniscidbe-5.10.1-py310h65c4a83_0.tar.bz2": { + "build": "py310h65c4a83_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "double-conversion >=3.1.5,<3.3.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "gxx_linux-64", + "icu >=58.2,<59.0a0", + "libarchive >=3.5.2,<3.6.0a0", + "libgcc-ng >=11.2.0", + "libgcc-ng >=9.3.0", + "libgcc-ng >=9.4.0", + "libgdal >=3.4.1,<3.5.0a0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libstdcxx-ng >=9.4.0", + "libthrift >=0.15.0,<0.15.1.0a0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "ncurses", + "numpy >=1.16,<2.0a0", + "omniscidb-common 5.10.1 hc204824_0", + "openjdk 8.*", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.10,<3.11.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "tbb >=2021.5.0", + "utf8proc", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e0fb288a58ceefbe6a38798f1af26364", + "name": "omniscidbe", + "sha256": "9eca94afe4d41d00ec11647e307bf455c360a36b62be96884f558e31386fd740", + "size": 39279731, + "subdir": "linux-64", + "timestamp": 1658970110706, + "version": "5.10.1" + }, + "omniscidbe-5.10.1-py37h7744c1e_0.tar.bz2": { + "build": "py37h7744c1e_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "double-conversion >=3.1.5,<3.3.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "gxx_linux-64", + "icu >=58.2,<59.0a0", + "libarchive >=3.5.2,<3.6.0a0", + "libgcc-ng >=11.2.0", + "libgcc-ng >=9.3.0", + "libgcc-ng >=9.4.0", + "libgdal >=3.4.1,<3.5.0a0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libstdcxx-ng >=9.4.0", + "libthrift >=0.15.0,<0.15.1.0a0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "ncurses", + "numpy >=1.16,<2.0a0", + "omniscidb-common 5.10.1 hc204824_0", + "openjdk 8.*", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.7,<3.8.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "tbb >=2021.5.0", + "utf8proc", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e894fdc69697cfa445068abe446515d4", + "name": "omniscidbe", + "sha256": "a53bbfd8b133ce4f16dbfc373a718ad041acde24bf5dc66e062c83f1e27be3fc", + "size": 39276952, + "subdir": "linux-64", + "timestamp": 1658969919735, + "version": "5.10.1" + }, + "omniscidbe-5.10.1-py38h7744c1e_0.tar.bz2": { + "build": "py38h7744c1e_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "double-conversion >=3.1.5,<3.3.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "gxx_linux-64", + "icu >=58.2,<59.0a0", + "libarchive >=3.5.2,<3.6.0a0", + "libgcc-ng >=11.2.0", + "libgcc-ng >=9.3.0", + "libgcc-ng >=9.4.0", + "libgdal >=3.4.1,<3.5.0a0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libstdcxx-ng >=9.4.0", + "libthrift >=0.15.0,<0.15.1.0a0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "ncurses", + "numpy >=1.16,<2.0a0", + "omniscidb-common 5.10.1 hc204824_0", + "openjdk 8.*", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.8,<3.9.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "tbb >=2021.5.0", + "utf8proc", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "59f0e719c798b6574a6ca8595c382135", + "name": "omniscidbe", + "sha256": "8b1bf8d77b9c5d4b4e2effe69586953a5912475dcea8687bf6c4fd9eb8bb6273", + "size": 39280786, + "subdir": "linux-64", + "timestamp": 1658970014477, + "version": "5.10.1" + }, + "omniscidbe-5.10.1-py39h7744c1e_0.tar.bz2": { + "build": "py39h7744c1e_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "double-conversion >=3.1.5,<3.3.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "gxx_linux-64", + "icu >=58.2,<59.0a0", + "libarchive >=3.5.2,<3.6.0a0", + "libgcc-ng >=11.2.0", + "libgcc-ng >=9.3.0", + "libgcc-ng >=9.4.0", + "libgdal >=3.4.1,<3.5.0a0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libstdcxx-ng >=9.4.0", + "libthrift >=0.15.0,<0.15.1.0a0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "ncurses", + "numpy >=1.16,<2.0a0", + "omniscidb-common 5.10.1 hc204824_0", + "openjdk 8.*", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.9,<3.10.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "tbb >=2021.5.0", + "utf8proc", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "258a19ad5816f04c74b2d1ddba11c01b", + "name": "omniscidbe", + "sha256": "37e9044e81285d809966b17dd809526ce8f45323dae44affa0cbf41638b40116", + "size": 39283943, + "subdir": "linux-64", + "timestamp": 1658969827395, + "version": "5.10.1" + }, + "omniscidbe-5.7.0-h7185ff3_0_cpu.tar.bz2": { + "build": "h7185ff3_0_cpu", + "build_number": 0, + "depends": [ + "arrow-cpp >=2.0.0,<2.0.1.0a0", + "blosc >=1.21.0,<2.0a0", + "boost-cpp >=1.73.0,<1.73.1.0a0", + "bzip2", + "double-conversion", + "gxx_linux-64", + "libarchive >=3.4.2,<3.5.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libclang-cpp <12", + "libgcc-ng >=9.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "librdkafka", + "libstdcxx-ng >=9.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "ncurses", + "omniscidb-common >=5.7.0,<5.7.1.0a0", + "openjdk 8.*", + "snappy", + "tbb >=2021.3.0", + "xz", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a4574ecb167e7ee7ad892e398fa6c554", + "name": "omniscidbe", + "sha256": "f9b7710b70a5a494dd3436297e31ade813f737be010b5dee48d966cffaf33333", + "size": 6750525, + "subdir": "linux-64", + "timestamp": 1630620825344, + "version": "5.7.0" + }, + "omniscidbe-5.7.1-h7185ff3_0_cpu.tar.bz2": { + "build": "h7185ff3_0_cpu", + "build_number": 0, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "blosc >=1.21.0,<2.0a0", + "boost-cpp >=1.73.0,<1.73.1.0a0", + "bzip2", + "double-conversion", + "fmt >=7.1.3,<8.0a0", + "gxx_linux-64", + "libarchive >=3.4.2,<3.5.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libclang-cpp <12", + "libgcc-ng >=9.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "librdkafka", + "libstdcxx-ng >=9.3.0", + "libthrift >=0.14.2,<0.14.3.0a0", + "ncurses", + "omniscidb-common >=5.7.1,<5.7.2.0a0", + "openjdk 8.*", + "snappy", + "tbb >=2021.3.0", + "xz", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "673810cc61962d15f6db05e41cae953f", + "name": "omniscidbe", + "sha256": "5ced67b71203dcc5aea4265ae29a211e54618262fa27d9b69a1c7394bb7c1dde", + "size": 6758464, + "subdir": "linux-64", + "timestamp": 1632952834421, + "version": "5.7.1" + }, + "oneccl-devel-2021.3.0-h06a4308_343.tar.bz2": { + "build": "h06a4308_343", + "build_number": 343, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "b3e9c374afcb99fda48706e9678cc649", + "name": "oneccl-devel", + "sha256": "728c27dc41bee5342047c066b8f4ecec31b79f0724294796edfef760e61406cb", + "size": 11006709, + "subdir": "linux-64", + "timestamp": 1626976054533, + "version": "2021.3.0" + }, + "oneccl-devel-2021.4.0-h06a4308_433.tar.bz2": { + "build": "h06a4308_433", + "build_number": 433, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "8212ae252b5cc12198d6f1b9732888c9", + "name": "oneccl-devel", + "sha256": "fc2c36b3ab81779a20dee889de3a205d12eea85d20b3d97a5b51a4ba37defa94", + "size": 8553841, + "subdir": "linux-64", + "timestamp": 1641816034296, + "version": "2021.4.0" + }, + "oneccl-devel-2021.5.0-h06a4308_478.tar.bz2": { + "build": "h06a4308_478", + "build_number": 478, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "b0ad8d3973c4e35f7f715b72bf8e4899", + "name": "oneccl-devel", + "sha256": "874932b5f12e3535b0cbd2529ae1c862531e55859e87b4ab1b748eedaffbe00e", + "size": 6479404, + "subdir": "linux-64", + "timestamp": 1642778518809, + "version": "2021.5.0" + }, + "oneccl-devel-2021.8.0-h06a4308_25371.tar.bz2": { + "build": "h06a4308_25371", + "build_number": 25371, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "6b49dfa5ee7218c3d72bd2134b8b1189", + "name": "oneccl-devel", + "sha256": "734ffa16eded7093157499d81ae6f78979737fd961002e04bb2dab7c27ec2463", + "size": 8059165, + "subdir": "linux-64", + "timestamp": 1679614950758, + "version": "2021.8.0" + }, + "oniguruma-6.9.3-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD 2-Clause", + "md5": "1c6e31a4b6206ea2822ba8f84c48c40c", + "name": "oniguruma", + "sha256": "2785206d8c18aea2697eb6675aa4c33b8ea90f509482b29ed301bb3cc6deb784", + "size": 408991, + "subdir": "linux-64", + "timestamp": 1604334840254, + "version": "6.9.3" + }, + "oniguruma-6.9.6-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "md5": "2aefc89fd6dd23d11dd693441963a085", + "name": "oniguruma", + "sha256": "11fbe9548d7930ead2c86a059790a784ce0071afbc7a6280edad48efadf8f55d", + "size": 454878, + "subdir": "linux-64", + "timestamp": 1611951807244, + "version": "6.9.6" + }, + "oniguruma-6.9.7-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "md5": "4a0c9ab5df29bee79499f388c0178c40", + "name": "oniguruma", + "sha256": "f0f06b7cc4fd880c7daa84f54e8573b0703152eb25826e66d2f358213956ad8b", + "size": 437500, + "subdir": "linux-64", + "timestamp": 1618437041421, + "version": "6.9.7" + }, + "oniguruma-6.9.7.1-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "md5": "3630ba78f2e3c1131279cbccf663f598", + "name": "oniguruma", + "sha256": "1d47ebcdd13e948bed98432d9835ce29cf05d936529beb466755216f55b13edd", + "size": 463209, + "subdir": "linux-64", + "timestamp": 1618609977611, + "version": "6.9.7.1" + }, + "onnx-1.10.2-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf >=3.19.1,<3.20.0a0", + "libprotobuf >=3.19.1,<4.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.17.0,<2.0a0", + "protobuf >=3.12.2", + "python >=3.7,<3.8.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d0eecc54cce696961d043c88a678871e", + "name": "onnx", + "sha256": "1d6724bff5f178de9f1c3056896417836e7e4e29a8eba9c7080cb3d2630dd782", + "size": 8848561, + "subdir": "linux-64", + "timestamp": 1643910764413, + "version": "1.10.2" + }, + "onnx-1.10.2-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf >=3.19.1,<3.20.0a0", + "libprotobuf >=3.19.1,<4.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "protobuf >=3.12.2", + "python >=3.8,<3.9.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74820ee76149dae612836a7a2c83e50a", + "name": "onnx", + "sha256": "10f99b318e5aa0ae488357a39f1cb4a416b781f53332e60b20384a98ab8df6c5", + "size": 8992586, + "subdir": "linux-64", + "timestamp": 1643912874094, + "version": "1.10.2" + }, + "onnx-1.10.2-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf >=3.19.1,<3.20.0a0", + "libprotobuf >=3.19.1,<4.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "protobuf >=3.12.2", + "python >=3.9,<3.10.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0aef07c41d46807f0fca8a6fc9d89977", + "name": "onnx", + "sha256": "0f4859bd0f860f48e2e5f374f87757c8fd72d2c13c5350bbf8757b530c248c7e", + "size": 8884031, + "subdir": "linux-64", + "timestamp": 1643928881132, + "version": "1.10.2" + }, + "onnx-1.12.0-py310h38ec052_0.tar.bz2": { + "build": "py310h38ec052_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libprotobuf >=3.20.1,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "protobuf", + "python >=3.10,<3.11.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "702a8e464020c3281ee4430c46b0cfcd", + "name": "onnx", + "sha256": "296c844ce8f1c9cef03267d332286619612542801a19bebff9c9bfaadf15d324", + "size": 9156912, + "subdir": "linux-64", + "timestamp": 1661366730619, + "version": "1.12.0" + }, + "onnx-1.12.0-py310h38ec052_1.tar.bz2": { + "build": "py310h38ec052_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libprotobuf >=3.20.1,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "protobuf", + "python >=3.10,<3.11.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14887752e980ed3f46efe734e7f137ec", + "name": "onnx", + "sha256": "4d6f06869607b75965965bef24ac5cd38cba13eb7d8cb5391b60d4146314b51c", + "size": 9134543, + "subdir": "linux-64", + "timestamp": 1672851194693, + "version": "1.12.0" + }, + "onnx-1.12.0-py37h6736146_0.tar.bz2": { + "build": "py37h6736146_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libprotobuf >=3.20.1,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "protobuf", + "python >=3.7,<3.8.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83514c2d51e66a721b0bece6a029c964", + "name": "onnx", + "sha256": "a507fd37f6940e85739bd0773aaac6c420d3d164d506000b7ff53cd6198a872a", + "size": 9132371, + "subdir": "linux-64", + "timestamp": 1661366489328, + "version": "1.12.0" + }, + "onnx-1.12.0-py37h6736146_1.tar.bz2": { + "build": "py37h6736146_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libprotobuf >=3.20.1,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "protobuf", + "python >=3.7,<3.8.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "636c9d395865d8bdcbda62b5881d263e", + "name": "onnx", + "sha256": "8a992ac129562448e105eeb7c21f3fadacf5d62fe80a435c2327f9647c6918d7", + "size": 9173932, + "subdir": "linux-64", + "timestamp": 1672850528128, + "version": "1.12.0" + }, + "onnx-1.12.0-py38h6736146_0.tar.bz2": { + "build": "py38h6736146_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libprotobuf >=3.20.1,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "protobuf", + "python >=3.8,<3.9.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9feb9f12cc61ba9cd58a5025c08ac4dc", + "name": "onnx", + "sha256": "85ae86f9831a77aca3645fb12190b384ee1133b87cf7caa7496e96ac550fed7b", + "size": 9127376, + "subdir": "linux-64", + "timestamp": 1661366255958, + "version": "1.12.0" + }, + "onnx-1.12.0-py38h6736146_1.tar.bz2": { + "build": "py38h6736146_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libprotobuf >=3.20.1,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "protobuf", + "python >=3.8,<3.9.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af05dc070d7cd7664379340db10c8eeb", + "name": "onnx", + "sha256": "5cf47a06977d0a430d9bbefd9f7fca5353f5718f61b3f31755e224b8f340e970", + "size": 9141815, + "subdir": "linux-64", + "timestamp": 1672850973550, + "version": "1.12.0" + }, + "onnx-1.12.0-py39h6736146_0.tar.bz2": { + "build": "py39h6736146_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libprotobuf >=3.20.1,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "protobuf", + "python >=3.9,<3.10.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18e01250151503a161195e4a6f75846e", + "name": "onnx", + "sha256": "fa753d6f61e0bbee5e9aad7af0625c7a0d6181a557e7a6fbac5f040743fd6d14", + "size": 9130242, + "subdir": "linux-64", + "timestamp": 1661366027849, + "version": "1.12.0" + }, + "onnx-1.12.0-py39h6736146_1.tar.bz2": { + "build": "py39h6736146_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libprotobuf >=3.20.1,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "protobuf", + "python >=3.9,<3.10.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "218350be8e2297117a62708c936f9b57", + "name": "onnx", + "sha256": "f0fe1b67077a33d9884877f0e30a3e4beefca666cfda8fb6dd1d24faf7ab6b6e", + "size": 9182728, + "subdir": "linux-64", + "timestamp": 1672850752083, + "version": "1.12.0" + }, + "onnx-1.13.0-py310h12ddb61_0.tar.bz2": { + "build": "py310h12ddb61_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libprotobuf >=3.20.3,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "protobuf >=3.20.2,<4", + "python >=3.10,<3.11.0a0", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4502502dc3bc0930e431257aa939db56", + "name": "onnx", + "sha256": "7661258b6b418e09b2223fd1438f26647b256dfa6e66fd66afeb8b321b786a51", + "size": 9594090, + "subdir": "linux-64", + "timestamp": 1675284619737, + "version": "1.13.0" + }, + "onnx-1.13.0-py311h12ddb61_1.tar.bz2": { + "build": "py311h12ddb61_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libprotobuf >=3.20.3,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "protobuf >=3.20.2,<4", + "python >=3.11,<3.12.0a0", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d1c5d221c975a8fc4aa3c28eb4e5f2d5", + "name": "onnx", + "sha256": "9f2277ec818a902ba57c3d3443fc2064ac80611ee04a1c50bd628d9e1ce40f12", + "size": 9690804, + "subdir": "linux-64", + "timestamp": 1676837309971, + "version": "1.13.0" + }, + "onnx-1.13.0-py37h12ddb61_0.tar.bz2": { + "build": "py37h12ddb61_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libprotobuf >=3.20.3,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "protobuf >=3.20.2,<4", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1561e53556784e7aac5aa6a7e85fe35", + "name": "onnx", + "sha256": "50f13342ce7146c86da738b9cc15f267c9b883dfc8916b18438d7ae276a96523", + "size": 9588224, + "subdir": "linux-64", + "timestamp": 1675284435684, + "version": "1.13.0" + }, + "onnx-1.13.0-py38h12ddb61_0.tar.bz2": { + "build": "py38h12ddb61_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libprotobuf >=3.20.3,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "protobuf >=3.20.2,<4", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d6ce61b5e8ba8063f0f980657a001858", + "name": "onnx", + "sha256": "db101ddd7747047ea0af8aa22dd28a43a8d3e98100375b0bdf0d6e5417a5b6ba", + "size": 9582775, + "subdir": "linux-64", + "timestamp": 1675284802907, + "version": "1.13.0" + }, + "onnx-1.13.0-py39h12ddb61_0.tar.bz2": { + "build": "py39h12ddb61_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libprotobuf >=3.20.3,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "protobuf >=3.20.2,<4", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b20dbf76a016c763554cca565a83c6b", + "name": "onnx", + "sha256": "77e4ed87ce19a3d3e4422aa2af9c3d4b0728548ec53c90bdf065770bf830ef10", + "size": 9586776, + "subdir": "linux-64", + "timestamp": 1675284989363, + "version": "1.13.0" + }, + "onnxconverter-common-1.13.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "onnx", + "packaging", + "protobuf", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab4b0c17075e0689a643ab2d1b9cad96", + "name": "onnxconverter-common", + "sha256": "5de740325ff759ec352ea65ce8cef0954b1ef918db99cb4f02c9466d75cd915d", + "size": 143834, + "subdir": "linux-64", + "timestamp": 1671635177613, + "version": "1.13.0" + }, + "onnxconverter-common-1.13.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "onnx", + "packaging", + "protobuf", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a697f8d11d9f77f703f2ab55cce26789", + "name": "onnxconverter-common", + "sha256": "d94ced27cdd45b399ed1274d5eadf4d481f588d23ed54611511b4e87191a10ab", + "size": 200910, + "subdir": "linux-64", + "timestamp": 1676841401270, + "version": "1.13.0" + }, + "onnxconverter-common-1.13.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "onnx", + "packaging", + "protobuf", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "84f67486fafde347edf3cf1eb4db52dc", + "name": "onnxconverter-common", + "sha256": "58859aa553e29befa521f7fd1ef749cc050dddfb7671e5a09969d652f3efe7bc", + "size": 142277, + "subdir": "linux-64", + "timestamp": 1671635103505, + "version": "1.13.0" + }, + "onnxconverter-common-1.13.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "onnx", + "packaging", + "protobuf", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9898e647f6cc4c1c6f0083af9b8819ae", + "name": "onnxconverter-common", + "sha256": "7fa87df60e167868a050741033cfae0c59952fa5c3168e545f4ea7765adf6e11", + "size": 142664, + "subdir": "linux-64", + "timestamp": 1671635153893, + "version": "1.13.0" + }, + "onnxconverter-common-1.13.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "onnx", + "packaging", + "protobuf", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c7d1d63fa6a34e2337d9fa5b882860c2", + "name": "onnxconverter-common", + "sha256": "04ab841a964b3708a329dff91250f4359bd9aa0bdbd835c88a167608278fc627", + "size": 142637, + "subdir": "linux-64", + "timestamp": 1671635129844, + "version": "1.13.0" + }, + "onnxmltools-1.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "onnx", + "python >=3.10,<3.11.0a0", + "skl2onnx" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e542904e69b72b5f303b8254e44cfd5d", + "name": "onnxmltools", + "sha256": "9a8e292c72f01fc240afed589673a565688d37594263478e8619ff1fb9594c34", + "size": 302789, + "subdir": "linux-64", + "timestamp": 1671721331834, + "version": "1.11.0" + }, + "onnxmltools-1.11.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "onnx", + "python >=3.7,<3.8.0a0", + "skl2onnx" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4dfa757b695b454e57475828bbdc8b2b", + "name": "onnxmltools", + "sha256": "63d056bc4cc10a57321c53bc7950766f1d1da4caf1f9fb6f78748d4fb25456f1", + "size": 297073, + "subdir": "linux-64", + "timestamp": 1671721256666, + "version": "1.11.0" + }, + "onnxmltools-1.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "onnx", + "python >=3.8,<3.9.0a0", + "skl2onnx" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c442a31fc649bb27b6e4028434c798b6", + "name": "onnxmltools", + "sha256": "c2b826bd6d216e9a7271ed5257b028fd33b2ad922520a6ddce74bf5fca1b8f71", + "size": 301393, + "subdir": "linux-64", + "timestamp": 1671721294415, + "version": "1.11.0" + }, + "onnxmltools-1.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "onnx", + "python >=3.9,<3.10.0a0", + "skl2onnx" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d7059c77bf7ade65dbb1320a0dc08c99", + "name": "onnxmltools", + "sha256": "6c0662ccbf712dae96b0039452ee1460270ac7a22d67a9bb713c21d4b004f7ab", + "size": 302096, + "subdir": "linux-64", + "timestamp": 1671721211794, + "version": "1.11.0" + }, + "onnxruntime-1.12.1-py310h2c1dd4f_0.tar.bz2": { + "build": "py310h2c1dd4f_0", + "build_number": 0, + "depends": [ + "coloredlogs", + "libcurl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "protobuf", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "re2 >=2022.4.1,<2022.4.2.0a0", + "sympy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e902ca26a029bb4cfcd8e7f90dac6588", + "name": "onnxruntime", + "sha256": "7584dd6355f14e82fab439f253db8a94089c2a4863c2eba79cbb51da5ae7471a", + "size": 5634596, + "subdir": "linux-64", + "timestamp": 1664951063779, + "version": "1.12.1" + }, + "onnxruntime-1.12.1-py37h8de7196_0.tar.bz2": { + "build": "py37h8de7196_0", + "build_number": 0, + "depends": [ + "coloredlogs", + "libcurl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "re2 >=2022.4.1,<2022.4.2.0a0", + "sympy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e0d2bf93edb6a0430e30ec5af05524f", + "name": "onnxruntime", + "sha256": "4aece2fe748aa77e07b93307b9d696014f682d6ea3db347875c7b71809f62fe4", + "size": 5820237, + "subdir": "linux-64", + "timestamp": 1664950030425, + "version": "1.12.1" + }, + "onnxruntime-1.12.1-py38h8de7196_0.tar.bz2": { + "build": "py38h8de7196_0", + "build_number": 0, + "depends": [ + "coloredlogs", + "libcurl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "re2 >=2022.4.1,<2022.4.2.0a0", + "sympy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc58f6772f995aa0783811dba5b76f56", + "name": "onnxruntime", + "sha256": "1f4bfbf21fc91209a768ad3e747b83da5502701d4ac9de8950134a0e06bea89f", + "size": 5796894, + "subdir": "linux-64", + "timestamp": 1664952097768, + "version": "1.12.1" + }, + "onnxruntime-1.12.1-py39h8de7196_0.tar.bz2": { + "build": "py39h8de7196_0", + "build_number": 0, + "depends": [ + "coloredlogs", + "libcurl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "re2 >=2022.4.1,<2022.4.2.0a0", + "sympy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d8834b6fa0768148f3ee5ea184bd436", + "name": "onnxruntime", + "sha256": "b181a67d6c115f6c2599f43d87eaf0c167b403bd2c8d1502223c49f4341f3523", + "size": 5788278, + "subdir": "linux-64", + "timestamp": 1664953133854, + "version": "1.12.1" + }, + "onnxruntime-novec-1.12.1-py310hab7e82e_0.tar.bz2": { + "build": "py310hab7e82e_0", + "build_number": 0, + "constrains": [ + "onnxruntime <0a0" + ], + "depends": [ + "coloredlogs", + "libcurl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "protobuf", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "re2 >=2022.4.1,<2022.4.2.0a0", + "sympy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b46051a7558f5bb1d17fb900ba418f8", + "name": "onnxruntime-novec", + "sha256": "f26fc5029f725810ee8e4733ed446e91742bee35e63aadb42f72f914916f4e90", + "size": 5571625, + "subdir": "linux-64", + "timestamp": 1664955128613, + "version": "1.12.1" + }, + "onnxruntime-novec-1.12.1-py37ha761a4e_0.tar.bz2": { + "build": "py37ha761a4e_0", + "build_number": 0, + "constrains": [ + "onnxruntime <0a0" + ], + "depends": [ + "coloredlogs", + "libcurl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "re2 >=2022.4.1,<2022.4.2.0a0", + "sympy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "093fb49c43538c3eb9149e19dbd3bba7", + "name": "onnxruntime-novec", + "sha256": "1bbbe0ae58acde0a4a7d5576567a99da43ab9eb3c039b1ae2e252d0dc5eab50b", + "size": 5740958, + "subdir": "linux-64", + "timestamp": 1664954134168, + "version": "1.12.1" + }, + "onnxruntime-novec-1.12.1-py38ha761a4e_0.tar.bz2": { + "build": "py38ha761a4e_0", + "build_number": 0, + "constrains": [ + "onnxruntime <0a0" + ], + "depends": [ + "coloredlogs", + "libcurl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "re2 >=2022.4.1,<2022.4.2.0a0", + "sympy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1742c2ffc8922c85cb659bdfdb253c0d", + "name": "onnxruntime-novec", + "sha256": "d633336b2fb51a7419f44f736a53596309a672b669694cdcfcd527862c44118a", + "size": 5719232, + "subdir": "linux-64", + "timestamp": 1664956122930, + "version": "1.12.1" + }, + "onnxruntime-novec-1.12.1-py39ha761a4e_0.tar.bz2": { + "build": "py39ha761a4e_0", + "build_number": 0, + "constrains": [ + "onnxruntime <0a0" + ], + "depends": [ + "coloredlogs", + "libcurl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "re2 >=2022.4.1,<2022.4.2.0a0", + "sympy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8ca814dd4857acd4e5ab1eea26dc599", + "name": "onnxruntime-novec", + "sha256": "d3af444ec5418d39b0985147b7834d1f032699565d1fea3166057e5e445e094e", + "size": 5709918, + "subdir": "linux-64", + "timestamp": 1664957116362, + "version": "1.12.1" + }, + "openblas-0.2.20-4.tar.bz2": { + "build": "4", + "build_number": 4, + "depends": [ + "libopenblas >=0.2.20,<0.2.21.0a0", + "openblas-devel >=0.2.20,<0.2.21.0a0" + ], + "license": "BSD", + "md5": "71e29d01b6ddf7c3f1ef23437f38c908", + "name": "openblas", + "sha256": "e1868ac875eea21a35001fbadea7c54b9292efd2cdd5e83b7c99c6899c4ad760", + "size": 4728, + "subdir": "linux-64", + "timestamp": 1515516241962, + "version": "0.2.20" + }, + "openblas-0.2.20-7.tar.bz2": { + "build": "7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "openblas-devel >=0.2.20,<0.2.21.0a0" + ], + "license": "BSD", + "md5": "37ebb2ceffc93fbda4eaf06322bff4f4", + "name": "openblas", + "sha256": "9288692863e26a384f73d2f6c0b3c696b3e84481e92db6c523dcf0ed6f3e9ac7", + "size": 49812, + "subdir": "linux-64", + "timestamp": 1527877219124, + "version": "0.2.20" + }, + "openblas-0.2.20-h9b22ed0_3.tar.bz2": { + "build": "h9b22ed0_3", + "build_number": 3, + "depends": [ + "openblas-devel >=0.2.20,<0.2.21.0a0" + ], + "license": "BSD", + "md5": "3de68a377d25b65081336b52eb3755e2", + "name": "openblas", + "sha256": "ec3cafce352d1b2ae81121a91c6eab6e91715ab11f410bcef75562a6c6ca86c1", + "size": 4769, + "subdir": "linux-64", + "timestamp": 1509731037394, + "version": "0.2.20" + }, + "openblas-0.3.10-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.10 h5a2b251_0", + "nomkl 3.0 0", + "openblas-devel 0.3.10 0" + ], + "license": "BSD", + "md5": "24aebe7652ca138aa2fa0fe4d6f645fe", + "name": "openblas", + "sha256": "ef8515e9b2e3f77ac36f6d439d148e00276ce7d8752bb6389d1c1d0771356b8d", + "size": 20388, + "subdir": "linux-64", + "timestamp": 1594191958270, + "version": "0.3.10" + }, + "openblas-0.3.13-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.13 h4367d64_0", + "nomkl 3.0 0", + "openblas-devel 0.3.13 h06a4308_0" + ], + "license": "BSD", + "md5": "5b2c7837ce7eb1f6d94b93c22e024efc", + "name": "openblas", + "sha256": "682eef087d6abeb8fe89c49a82d2b8f3469055c145704f81f6deceaed65f0575", + "size": 21445, + "subdir": "linux-64", + "timestamp": 1616438153633, + "version": "0.3.13" + }, + "openblas-0.3.17-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.17 hf726d26_1", + "nomkl 3.0 0", + "openblas-devel 0.3.17 h06a4308_1" + ], + "license": "BSD-3-clause", + "md5": "ce69e33a5385d56383f43e3c2c3ca04c", + "name": "openblas", + "sha256": "4928fdb9ca6c996582f0545ee4bc274c16a51d795410b2628a6ebe9e84c83ffd", + "size": 11881, + "subdir": "linux-64", + "timestamp": 1643995262210, + "version": "0.3.17" + }, + "openblas-0.3.18-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.18 hf726d26_0", + "nomkl 3.0 0", + "openblas-devel 0.3.18 h06a4308_0" + ], + "license": "BSD-3-clause", + "md5": "56be80265b01f023ce80eead8cb72756", + "name": "openblas", + "sha256": "02d64bddd020dbf6e51839f2107a3222cfca13f0b51dd5a17fda85c8a2febeb7", + "size": 12063, + "subdir": "linux-64", + "timestamp": 1649691298201, + "version": "0.3.18" + }, + "openblas-0.3.2-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "openblas-devel >=0.3.2,<0.3.3.0a0" + ], + "license": "BSD", + "md5": "636e076f4fbd55a49234c5efe84af40a", + "name": "openblas", + "sha256": "5794892db311deef2412a220a8d66f2408a0dd02034c3c327e17ec5d3e5f4af7", + "size": 6971, + "subdir": "linux-64", + "timestamp": 1534770596667, + "version": "0.3.2" + }, + "openblas-0.3.2-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "nomkl 3.0 0", + "openblas-devel >=0.3.2,<0.3.3.0a0" + ], + "license": "BSD", + "md5": "e1ebfb0b652ff3171ff62b0a9d740867", + "name": "openblas", + "sha256": "5c1d771cb48f50bfadc3b8cd1fde2c06f926bec224fdf44842009c430b35137d", + "size": 7273, + "subdir": "linux-64", + "timestamp": 1534782572073, + "version": "0.3.2" + }, + "openblas-0.3.20-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.20 h043d6bf_0", + "nomkl 3.0 0", + "openblas-devel 0.3.20 h06a4308_0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "952495234432869cf98f65f00309584c", + "name": "openblas", + "sha256": "6ffabdb771c08d82f0a7a7de9ab1918296acd1842014ced35f2abade28b9dabc", + "size": 12127, + "subdir": "linux-64", + "timestamp": 1652995324540, + "version": "0.3.20" + }, + "openblas-0.3.20-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.20 h043d6bf_1", + "nomkl 3.0 0", + "openblas-devel 0.3.20 h06a4308_1" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "e52b2611bb2ea0dc1cb1e27a534da29e", + "name": "openblas", + "sha256": "dd3519fabcd54a9ae0f082dff5bd4636818e4181a9f2c6edf9c00bdc1891f8c9", + "size": 12127, + "subdir": "linux-64", + "timestamp": 1653477019211, + "version": "0.3.20" + }, + "openblas-0.3.21-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.21 h043d6bf_0", + "nomkl 3.0 0", + "openblas-devel 0.3.21 h06a4308_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "650e5dcd4eafe4b9d4d55b985316dd67", + "name": "openblas", + "sha256": "c2e6bf644267c76e2f1e3b0537a9d1db4c23823df140e2728855b5856fe276ae", + "size": 12129, + "subdir": "linux-64", + "timestamp": 1664897205817, + "version": "0.3.21" + }, + "openblas-0.3.3-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.3 h5a2b251_1", + "nomkl 3.0 0", + "openblas-devel 0.3.3 1" + ], + "license": "BSD", + "md5": "82a789f0a289906a7f18b5b94104267f", + "name": "openblas", + "sha256": "2c91d0021bbd7a8ba6a23af97615c0041634bef3db67391572671876f6101f2d", + "size": 7425, + "subdir": "linux-64", + "timestamp": 1536076222460, + "version": "0.3.3" + }, + "openblas-0.3.3-2.tar.bz2": { + "build": "2", + "build_number": 2, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.3 h5a2b251_2", + "nomkl 3.0 0", + "openblas-devel 0.3.3 2" + ], + "license": "BSD", + "md5": "2155ac437ef9acea3283821f7c5e9dcd", + "name": "openblas", + "sha256": "d2f8e61a553cd067e1702eaaa043c50f35389816ccdd7ead5812c849be2d3919", + "size": 12048, + "subdir": "linux-64", + "timestamp": 1536889165159, + "version": "0.3.3" + }, + "openblas-0.3.3-3.tar.bz2": { + "build": "3", + "build_number": 3, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.3 h5a2b251_3", + "nomkl 3.0 0", + "openblas-devel 0.3.3 3" + ], + "license": "BSD", + "md5": "af42751ff682ecc481ae135ad2cf5530", + "name": "openblas", + "sha256": "a46d74b9cbeeeece45cace773942a19292ee020c54ea3412cf44cfe2e0106bf5", + "size": 8250, + "subdir": "linux-64", + "timestamp": 1537472801522, + "version": "0.3.3" + }, + "openblas-0.3.6-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.6 h5a2b251_0", + "nomkl 3.0 0", + "openblas-devel 0.3.6 0" + ], + "license": "BSD", + "md5": "b09b1ea98983c5fb6c595f89af5376e1", + "name": "openblas", + "sha256": "237ffb048188a88cdf4620ae81d5cfa065b407303368a8b17191ca80f6d056a5", + "size": 18269, + "subdir": "linux-64", + "timestamp": 1559239840450, + "version": "0.3.6" + }, + "openblas-0.3.6-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.6 h5a2b251_1", + "nomkl 3.0 0", + "openblas-devel 0.3.6 1" + ], + "license": "BSD", + "md5": "a36e89d2977c45498c87be70f8a5366e", + "name": "openblas", + "sha256": "b1e0bcef46c45092c22524088c2cc4bbc16e34ebaf9cb19989cf43530ee70a14", + "size": 19327, + "subdir": "linux-64", + "timestamp": 1563464699545, + "version": "0.3.6" + }, + "openblas-0.3.6-2.tar.bz2": { + "build": "2", + "build_number": 2, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.6 h5a2b251_2", + "nomkl 3.0 0", + "openblas-devel 0.3.6 2" + ], + "license": "BSD", + "md5": "342db2c5624d2ee103e5807052f9ef2a", + "name": "openblas", + "sha256": "2a968d400a62bb15f805eb325f4bb4c9c669e25869ce8fce1e2e447bc4ea18eb", + "size": 19861, + "subdir": "linux-64", + "timestamp": 1573061093949, + "version": "0.3.6" + }, + "openblas-devel-0.2.20-4.tar.bz2": { + "build": "4", + "build_number": 4, + "depends": [ + "libopenblas >=0.2.20,<0.2.21.0a0", + "blas * openblas" + ], + "md5": "5f41ed642c478d6f10fdbc2baf9f29a1", + "name": "openblas-devel", + "sha256": "b466ddea4e55fa9aa4dc25684db96c28242998cd89c17abc5dfbe89d8c2b7e2b", + "size": 59059, + "subdir": "linux-64", + "timestamp": 1515516241238, + "version": "0.2.20" + }, + "openblas-devel-0.2.20-7.tar.bz2": { + "build": "7", + "build_number": 7, + "depends": [ + "libopenblas >=0.2.20,<0.2.21.0a0", + "blas * openblas" + ], + "md5": "8f07076303d679a8cddd9924bbe66a44", + "name": "openblas-devel", + "sha256": "132654dfb3845d62df8db54a64c5b01ca7b51cd70730e875f0c4ae42d63f3d3c", + "size": 103756, + "subdir": "linux-64", + "timestamp": 1527877218186, + "version": "0.2.20" + }, + "openblas-devel-0.2.20-h1e4b922_3.tar.bz2": { + "build": "h1e4b922_3", + "build_number": 3, + "depends": [ + "libopenblas >=0.2.20,<0.2.21.0a0", + "blas * openblas" + ], + "md5": "5e60ae78050490d695d6e63300b44e90", + "name": "openblas-devel", + "sha256": "56c85c31564772b443eba4f590efd5b1620dfa6796fd3cdbdd623340db996891", + "size": 59110, + "subdir": "linux-64", + "timestamp": 1509731031975, + "version": "0.2.20" + }, + "openblas-devel-0.3.10-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "libopenblas 0.3.10 h5a2b251_0", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "f723dec5673237218a57e221380f76e0", + "name": "openblas-devel", + "sha256": "67c6a5165a4f94df85b6e8ca9a16f83da6e77c73615be3339830f253db32e19e", + "size": 53733, + "subdir": "linux-64", + "timestamp": 1594191957081, + "version": "0.3.10" + }, + "openblas-devel-0.3.13-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libopenblas 0.3.13 h4367d64_0", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "227654614bbded0bd1f8b179ca546774", + "name": "openblas-devel", + "sha256": "4dc7a2d9f450adab1f691ce9d2bfedf9e53985caf2a5b2ee889ec9b912e53744", + "size": 55359, + "subdir": "linux-64", + "timestamp": 1616438152528, + "version": "0.3.13" + }, + "openblas-devel-0.3.17-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [ + "libopenblas 0.3.17 hf726d26_1", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "c94b22483b6004c5529effd2a2fd5495", + "name": "openblas-devel", + "sha256": "0cba935a9c7315540a11d494052abf580ef46cd8bddfb40eab502db769c665c7", + "size": 69289, + "subdir": "linux-64", + "timestamp": 1643995261367, + "version": "0.3.17" + }, + "openblas-devel-0.3.18-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libopenblas 0.3.18 hf726d26_0", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "e5ddff8d25d1803434ade9c84db0dd77", + "name": "openblas-devel", + "sha256": "bdc6df6eef1c3db868605a6c322f30e2e8ada70650fb6522cd7eb41152fc8275", + "size": 70017, + "subdir": "linux-64", + "timestamp": 1649691297331, + "version": "0.3.18" + }, + "openblas-devel-0.3.2-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "libopenblas >=0.3.2,<0.3.3.0a0", + "blas * openblas" + ], + "md5": "dd3529d7db7701e3cba4e859b5e05840", + "name": "openblas-devel", + "sha256": "d4b6ef7e44163c722ab320cf1ffadceb01c4cebae76ff1467e2a6c8c7c0efff8", + "size": 62631, + "subdir": "linux-64", + "timestamp": 1534770595903, + "version": "0.3.2" + }, + "openblas-devel-0.3.2-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "libopenblas >=0.3.2,<0.3.3.0a0", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "4418cb5005f71368b54743ce4cdc4859", + "name": "openblas-devel", + "sha256": "18d2a57259a2549761dded950a0206463cc0921e0976959a6db5bb2a68e77d2f", + "size": 62982, + "subdir": "linux-64", + "timestamp": 1534782570252, + "version": "0.3.2" + }, + "openblas-devel-0.3.20-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libopenblas 0.3.20 h043d6bf_0", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "6625644e334ade65209ddd1cfb00295e", + "name": "openblas-devel", + "sha256": "04855e8a6b8dd618c82d97b6708980d9be7d2d8f8bdde5b25858c360713746bf", + "size": 69894, + "subdir": "linux-64", + "timestamp": 1652995323660, + "version": "0.3.20" + }, + "openblas-devel-0.3.20-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [ + "libopenblas 0.3.20 h043d6bf_1", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "3b6b0d9a520bddbb9abb8e77c8a94dc5", + "name": "openblas-devel", + "sha256": "2184a8882bc9798f9ae66f15810496ef869eb0ddb64c246a71e06074779f510a", + "size": 69628, + "subdir": "linux-64", + "timestamp": 1653477018322, + "version": "0.3.20" + }, + "openblas-devel-0.3.21-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libopenblas 0.3.21 h043d6bf_0", + "nomkl 3.0 0", + "blas * openblas" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8303e0c5925b72aa1df4bba6e14aed2d", + "name": "openblas-devel", + "sha256": "a119466bb329435fcb35895ecd09292466f0232e0af836685d6a0a58de4d0776", + "size": 77374, + "subdir": "linux-64", + "timestamp": 1664897204906, + "version": "0.3.21" + }, + "openblas-devel-0.3.3-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "libopenblas 0.3.3 h5a2b251_1", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "2eda7040aed6274655e230d4d2bc684b", + "name": "openblas-devel", + "sha256": "d51f6a0a9b6b0c4e1bac561d2a28a3db666c68ffb2fcfe2b9cf5073a48b8b802", + "size": 63062, + "subdir": "linux-64", + "timestamp": 1536076221867, + "version": "0.3.3" + }, + "openblas-devel-0.3.3-2.tar.bz2": { + "build": "2", + "build_number": 2, + "depends": [ + "libopenblas 0.3.3 h5a2b251_2", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "8b7361cd2d4121b98dfb73cf56c8d234", + "name": "openblas-devel", + "sha256": "04ad8af318c1450503e7b5472e089d2e22eb99cd9d64ce91711810618ebe5e38", + "size": 67961, + "subdir": "linux-64", + "timestamp": 1536889164288, + "version": "0.3.3" + }, + "openblas-devel-0.3.3-3.tar.bz2": { + "build": "3", + "build_number": 3, + "depends": [ + "libopenblas 0.3.3 h5a2b251_3", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "d8483de6fe34fc7c842cb5296fc2dbfd", + "name": "openblas-devel", + "sha256": "86ca7d690558fa7c90c61e7ace95b000e0eadda472d636e8dd998b234919aaa3", + "size": 63954, + "subdir": "linux-64", + "timestamp": 1537472800225, + "version": "0.3.3" + }, + "openblas-devel-0.3.6-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "libopenblas 0.3.6 h5a2b251_0", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "7c75be3990bf0bdb02c11157a5d26282", + "name": "openblas-devel", + "sha256": "e55e319fab4417b16d523fa2341c4f78d0b71a994380879b2e155290e26c4549", + "size": 74996, + "subdir": "linux-64", + "timestamp": 1559239838833, + "version": "0.3.6" + }, + "openblas-devel-0.3.6-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "libopenblas 0.3.6 h5a2b251_1", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "d604bd9e137da5b6ce82c053e0d9d69a", + "name": "openblas-devel", + "sha256": "c668857b0efafae1bfe354d0d431f4c7a04031feecb20dbda4faadfb6466bc52", + "size": 76539, + "subdir": "linux-64", + "timestamp": 1563464697763, + "version": "0.3.6" + }, + "openblas-devel-0.3.6-2.tar.bz2": { + "build": "2", + "build_number": 2, + "depends": [ + "libopenblas 0.3.6 h5a2b251_2", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "5b7008e31822f88863b2a6aa25a05f57", + "name": "openblas-devel", + "sha256": "6ee483802c4060948a2552409a744e065cba2b272305a2df94afb7f8204111aa", + "size": 75732, + "subdir": "linux-64", + "timestamp": 1573061092520, + "version": "0.3.6" + }, + "opencensus-context-0.1.2-py310h06a4308_4.tar.bz2": { + "build": "py310h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "c0b50bfc9668fecdcaabcb6969936842", + "name": "opencensus-context", + "sha256": "b617c3307361e814271599c4ef8eea45ec36422d3a72cfbae2b78d440cf660d1", + "size": 13756, + "subdir": "linux-64", + "timestamp": 1640792058678, + "version": "0.1.2" + }, + "opencensus-context-0.1.2-py311h06a4308_4.tar.bz2": { + "build": "py311h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "md5": "9c9406f3b25b852d00442a80c7bfcab9", + "name": "opencensus-context", + "sha256": "852645df583c50736b5503f86ea12f7817026b7230b3a2e5e69f3b1e0e10f7f9", + "size": 15733, + "subdir": "linux-64", + "timestamp": 1676860081535, + "version": "0.1.2" + }, + "opencensus-context-0.1.2-py36h06a4308_4.tar.bz2": { + "build": "py36h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "6ee31c78cee3fb49c8269f8d5718540f", + "name": "opencensus-context", + "sha256": "3226b6371ed5f21a2eb0616e87e1e39f6d84582b9958d107b9aeef3e9ab999c1", + "size": 15258, + "subdir": "linux-64", + "timestamp": 1621432726614, + "version": "0.1.2" + }, + "opencensus-context-0.1.2-py37h06a4308_4.tar.bz2": { + "build": "py37h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "aed831fb60e94210a29ed6f38d27b1de", + "name": "opencensus-context", + "sha256": "2cab7919e5c514a06848284d60d3a86031367d37f35e9ca5a31495a92f650988", + "size": 15244, + "subdir": "linux-64", + "timestamp": 1621432651704, + "version": "0.1.2" + }, + "opencensus-context-0.1.2-py38h06a4308_4.tar.bz2": { + "build": "py38h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "8acc6ec187d75642d5a56cc9e1061f0c", + "name": "opencensus-context", + "sha256": "0d8a4d13aa9dcb20ebdc9f889212ccdfcaa8a8a06b0cd132d4f3c5c048ad4f57", + "size": 15302, + "subdir": "linux-64", + "timestamp": 1621432715172, + "version": "0.1.2" + }, + "opencensus-context-0.1.2-py39h06a4308_4.tar.bz2": { + "build": "py39h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "cf84919a366977209bbc4ba0bfe0f6ff", + "name": "opencensus-context", + "sha256": "60ffab75c8b79a0a8f8387ecd2e735036d152b644d04841843df6ed8970a8214", + "size": 15351, + "subdir": "linux-64", + "timestamp": 1621432709715, + "version": "0.1.2" + }, + "opencv-3.3.1-py27h17fce66_0.tar.bz2": { + "build": "py27h17fce66_0", + "build_number": 0, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1183db6330d0f0f95b6d9c53552b6dc0", + "name": "opencv", + "sha256": "70d3026cb167b67958d5ce534bab4058aed27f90763a7e1b3063864825067434", + "size": 40795494, + "subdir": "linux-64", + "timestamp": 1512494740979, + "version": "3.3.1" + }, + "opencv-3.3.1-py27h61133dd_2.tar.bz2": { + "build": "py27h61133dd_2", + "build_number": 2, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5544fa2c22e9c3b7960790ee285bfba2", + "name": "opencv", + "sha256": "b6f71a9dc26831a7295b77af1267a7fc2cc197e5764bb4eea27dab67c8e68dc6", + "size": 40795195, + "subdir": "linux-64", + "timestamp": 1525315569501, + "version": "3.3.1" + }, + "opencv-3.3.1-py27h6cbbc71_1.tar.bz2": { + "build": "py27h6cbbc71_1", + "build_number": 1, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6860d5fb38c3c9691cda511dcf4054c0", + "name": "opencv", + "sha256": "c5263e8673c39b509ca5767347303bfa08fd7938a292f9da11812889fb6734a2", + "size": 40792844, + "subdir": "linux-64", + "timestamp": 1512682656517, + "version": "3.3.1" + }, + "opencv-3.3.1-py27h9248ab4_2.tar.bz2": { + "build": "py27h9248ab4_2", + "build_number": 2, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f7a512e76b946eb2e862c3d182a9235e", + "name": "opencv", + "sha256": "709617a90449ce96277b591ca32303dbe49c1b8fa78c606ecaaf9c7e36f71175", + "size": 40795984, + "subdir": "linux-64", + "timestamp": 1525315896087, + "version": "3.3.1" + }, + "opencv-3.3.1-py27h9bb06ff_1.tar.bz2": { + "build": "py27h9bb06ff_1", + "build_number": 1, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e3f3069a8a9476218d2cd81e287888da", + "name": "opencv", + "sha256": "20686ff9ce865671a2ce5c16b2302ce0a012d67df61a6b953990e327105e6ea6", + "size": 40795472, + "subdir": "linux-64", + "timestamp": 1512682684211, + "version": "3.3.1" + }, + "opencv-3.3.1-py27hdcf4849_0.tar.bz2": { + "build": "py27hdcf4849_0", + "build_number": 0, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a682dc97c78397d2668c9e54061297ec", + "name": "opencv", + "sha256": "27a05cc08a7c9f890b37c86ff3e0c564ab455cfecd3f64524a7f3e55b169cff1", + "size": 40797989, + "subdir": "linux-64", + "timestamp": 1512494698106, + "version": "3.3.1" + }, + "opencv-3.3.1-py35h0b7da17_0.tar.bz2": { + "build": "py35h0b7da17_0", + "build_number": 0, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1541de61eccc48b516b09e28db9ad88e", + "name": "opencv", + "sha256": "a2db7a3276092e805b10d906e70d0ef364b025568d19d98a84eb21a0758c033f", + "size": 40804454, + "subdir": "linux-64", + "timestamp": 1512494765659, + "version": "3.3.1" + }, + "opencv-3.3.1-py35h61133dd_2.tar.bz2": { + "build": "py35h61133dd_2", + "build_number": 2, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f64147048f46a8728467063c571c6cb4", + "name": "opencv", + "sha256": "1ef939dadf2ce288c94ee933daed0ef8298f3b6b4a640128073ba322c2f491a7", + "size": 40793939, + "subdir": "linux-64", + "timestamp": 1525315399780, + "version": "3.3.1" + }, + "opencv-3.3.1-py35h6cbbc71_1.tar.bz2": { + "build": "py35h6cbbc71_1", + "build_number": 1, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "83ff121cf2874055a2883141685ed135", + "name": "opencv", + "sha256": "d660b7027e50728e4dce9f26f0b4db216d01aab8fe49ae29087afa7135044e19", + "size": 40797870, + "subdir": "linux-64", + "timestamp": 1512682922592, + "version": "3.3.1" + }, + "opencv-3.3.1-py35h9248ab4_2.tar.bz2": { + "build": "py35h9248ab4_2", + "build_number": 2, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6d1451dfe375211a3b4e9195dc7cf4be", + "name": "opencv", + "sha256": "21847dff1f42039224630f5fb99aa3ac1922de44432be2895f87cb1c4a927681", + "size": 40792175, + "subdir": "linux-64", + "timestamp": 1525315574859, + "version": "3.3.1" + }, + "opencv-3.3.1-py35h9bb06ff_1.tar.bz2": { + "build": "py35h9bb06ff_1", + "build_number": 1, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ba041805d315b86cc0cfad325ff8e117", + "name": "opencv", + "sha256": "c4aa24d0be776c0e83cac28c7e67a17989e4464490ff7510de242509a11c1de9", + "size": 40795946, + "subdir": "linux-64", + "timestamp": 1512682916826, + "version": "3.3.1" + }, + "opencv-3.3.1-py35hb7523de_0.tar.bz2": { + "build": "py35hb7523de_0", + "build_number": 0, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d42969e3e0744e13591720e47b00205e", + "name": "opencv", + "sha256": "55e3b9a78b868ff1deec3312056fb3ffcfe139e9976a1070a8c6fe82eae465a9", + "size": 40795642, + "subdir": "linux-64", + "timestamp": 1512494771435, + "version": "3.3.1" + }, + "opencv-3.3.1-py36h0a11808_0.tar.bz2": { + "build": "py36h0a11808_0", + "build_number": 0, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "aea9a090841bc954ac2338cec3893393", + "name": "opencv", + "sha256": "1c5e61901a52cc7f7ee9b09aa7ae07ed2e0f943bcebe5e5354066720a8e31819", + "size": 40795683, + "subdir": "linux-64", + "timestamp": 1512494267015, + "version": "3.3.1" + }, + "opencv-3.3.1-py36h0f6f1c3_0.tar.bz2": { + "build": "py36h0f6f1c3_0", + "build_number": 0, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "50c0d2e7872f2ad08c79890ba56d2ba4", + "name": "opencv", + "sha256": "bd940a4539d716407a5579d913cbc8382bc4d3bbb3709635abb6770c4cb1098e", + "size": 40795547, + "subdir": "linux-64", + "timestamp": 1512494609806, + "version": "3.3.1" + }, + "opencv-3.3.1-py36h61133dd_2.tar.bz2": { + "build": "py36h61133dd_2", + "build_number": 2, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8ea2432c976ce0712ba782bfa5417f25", + "name": "opencv", + "sha256": "c4e9954a7fea332d5634edcaac69698d85b9b86019815f57b3b2c4d8570da777", + "size": 40790083, + "subdir": "linux-64", + "timestamp": 1525315883852, + "version": "3.3.1" + }, + "opencv-3.3.1-py36h6cbbc71_1.tar.bz2": { + "build": "py36h6cbbc71_1", + "build_number": 1, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7eae13bd5be524406d580fef7394b3d7", + "name": "opencv", + "sha256": "b406fb2b125bc25f52f313905f693b95c35f1243adb4aa8cc3b6b338a462aa0a", + "size": 40795903, + "subdir": "linux-64", + "timestamp": 1512688232234, + "version": "3.3.1" + }, + "opencv-3.3.1-py36h9248ab4_2.tar.bz2": { + "build": "py36h9248ab4_2", + "build_number": 2, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "88baa2e04fb0508a7708be093a6b865c", + "name": "opencv", + "sha256": "7f910fb8a6d2891388f4c387768e5d60c4c14d35f607c2d956aa6364c941a0c3", + "size": 40794073, + "subdir": "linux-64", + "timestamp": 1525315846671, + "version": "3.3.1" + }, + "opencv-3.3.1-py36h9bb06ff_1.tar.bz2": { + "build": "py36h9bb06ff_1", + "build_number": 1, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "648153d6f239202110dc9ad54b4261ce", + "name": "opencv", + "sha256": "eca94252b41e4360fef5a5ff96fff8f96afee24445fb66eeb24e9f88cbcd0f59", + "size": 40793001, + "subdir": "linux-64", + "timestamp": 1512682624333, + "version": "3.3.1" + }, + "opencv-3.4.1-py27h40b0b35_1.tar.bz2": { + "build": "py27h40b0b35_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d6e80578bbb3f1405bae6dc59b035e74", + "name": "opencv", + "sha256": "94c3637d2e7c09df3ff8bf7f5bbe778956f69fa2d9b53add9c8684ed391c0988", + "size": 7099, + "subdir": "linux-64", + "timestamp": 1527006897288, + "version": "3.4.1" + }, + "opencv-3.4.1-py27h40b0b35_2.tar.bz2": { + "build": "py27h40b0b35_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "py-opencv 3.4.1 py27hf78e8e8_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ba2236052199bb225d63c1f800fe4218", + "name": "opencv", + "sha256": "4bf8ec8683d015d2cb1617f3d852151509b06533a91552c749f2221364a93bd6", + "size": 7234, + "subdir": "linux-64", + "timestamp": 1527006897288, + "version": "3.4.1" + }, + "opencv-3.4.1-py27h40b0b35_3.tar.bz2": { + "build": "py27h40b0b35_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "py-opencv 3.4.1 py27he6673a0_3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c314b5d13c581d394f5ca93178a4dc7b", + "name": "opencv", + "sha256": "8f42047c7327201849dfa36e126b0877f85790430382a26c9427f48b12566b64", + "size": 7800, + "subdir": "linux-64", + "timestamp": 1530792749940, + "version": "3.4.1" + }, + "opencv-3.4.1-py27h6fd60c2_1.tar.bz2": { + "build": "py27h6fd60c2_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1feb39fff0dbcda286c709ad780e03de", + "name": "opencv", + "sha256": "2d623acc372a99076ac7adab3f50465ef078a14150d126a8e6c869faf1b5f838", + "size": 7102, + "subdir": "linux-64", + "timestamp": 1527005982683, + "version": "3.4.1" + }, + "opencv-3.4.1-py27h6fd60c2_2.tar.bz2": { + "build": "py27h6fd60c2_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.1 py27h0676e08_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d3ef09743c8fe649d4287784849da8f6", + "name": "opencv", + "sha256": "14b7ee181fdce1344b7ae8176ff9b20289b7d4930c0da236f8703ebe64c6b0f8", + "size": 7161, + "subdir": "linux-64", + "timestamp": 1527005982683, + "version": "3.4.1" + }, + "opencv-3.4.1-py27h6fd60c2_3.tar.bz2": { + "build": "py27h6fd60c2_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.1 py27h8fa1ad8_3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f5e14dd3ce1ec56212f3b2544bea7792", + "name": "opencv", + "sha256": "a66abbb81d4b48a4d8c4d2b1d95d875ded51a3f37e4f6cfe40dc23bdb597e101", + "size": 7798, + "subdir": "linux-64", + "timestamp": 1530791079672, + "version": "3.4.1" + }, + "opencv-3.4.1-py35h40b0b35_1.tar.bz2": { + "build": "py35h40b0b35_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dd1623e0285f6b4c95835863e7d7925b", + "name": "opencv", + "sha256": "f7faf0b8823eac4000a9c83b639126d7dc0da83e276cbb359e819b02bf16b851", + "size": 7107, + "subdir": "linux-64", + "timestamp": 1527006917343, + "version": "3.4.1" + }, + "opencv-3.4.1-py35h40b0b35_2.tar.bz2": { + "build": "py35h40b0b35_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "py-opencv 3.4.1 py35hf78e8e8_1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c9a927c1d5deae4afe4fac2797dd4972", + "name": "opencv", + "sha256": "934f93675cd232345a21f8661bc50772e55ea5f8317db8283bbfed0382079baa", + "size": 7174, + "subdir": "linux-64", + "timestamp": 1527006917343, + "version": "3.4.1" + }, + "opencv-3.4.1-py35h6fd60c2_1.tar.bz2": { + "build": "py35h6fd60c2_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f5bb9dbc0aedb402581bab676f2d5631", + "name": "opencv", + "sha256": "b20c362c2cea586fb8c260031339df682b625efba1da2018135f65c1160054be", + "size": 7124, + "subdir": "linux-64", + "timestamp": 1527006004741, + "version": "3.4.1" + }, + "opencv-3.4.1-py35h6fd60c2_2.tar.bz2": { + "build": "py35h6fd60c2_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.1 py35h0676e08_1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "765f0c5f64123b5e7bdfc79fe9e38d13", + "name": "opencv", + "sha256": "3580d20fa5a1f1f2788df90d6313e3a2b4135312a702a331a37c33b379e7766b", + "size": 7180, + "subdir": "linux-64", + "timestamp": 1527006004741, + "version": "3.4.1" + }, + "opencv-3.4.1-py36h40b0b35_1.tar.bz2": { + "build": "py36h40b0b35_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "20f0b53d306be1f3f0406b7d0e549730", + "name": "opencv", + "sha256": "3478366d9ee6c7d6c00179f6802bd6376edf55c9861112ebd8d12a9eeee743dc", + "size": 7102, + "subdir": "linux-64", + "timestamp": 1527006937301, + "version": "3.4.1" + }, + "opencv-3.4.1-py36h40b0b35_2.tar.bz2": { + "build": "py36h40b0b35_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "py-opencv 3.4.1 py36hf78e8e8_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a852842c24ab59af407405b9b7aefe7c", + "name": "opencv", + "sha256": "31eb8413dc7c6ca37398d9db55fd0d13744c853c3b0b66a00ed7236301765583", + "size": 7174, + "subdir": "linux-64", + "timestamp": 1527006937301, + "version": "3.4.1" + }, + "opencv-3.4.1-py36h40b0b35_3.tar.bz2": { + "build": "py36h40b0b35_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "py-opencv 3.4.1 py36he6673a0_3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "fc75cab29caed6e654b4e8e97ab3c3cc", + "name": "opencv", + "sha256": "6509498ebfc357682cd40f66c743d307d3f433ef978631d36d60d9ae126744e9", + "size": 7805, + "subdir": "linux-64", + "timestamp": 1530792763321, + "version": "3.4.1" + }, + "opencv-3.4.1-py36h6fd60c2_1.tar.bz2": { + "build": "py36h6fd60c2_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a9f8693be279b2e09402ea62880342b6", + "name": "opencv", + "sha256": "2dd482f7b5cc724a5d7a48f5d4f5236e2d7afac94bcfc0fdf4bec32c0824f7d6", + "size": 7125, + "subdir": "linux-64", + "timestamp": 1527006026877, + "version": "3.4.1" + }, + "opencv-3.4.1-py36h6fd60c2_2.tar.bz2": { + "build": "py36h6fd60c2_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.1 py36h0676e08_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b8f954762e4f17014edf206c33895d1c", + "name": "opencv", + "sha256": "574e7910207a02eeff989c355199b22bb0c7eab06f2e318ebbc33c0b567721a9", + "size": 7166, + "subdir": "linux-64", + "timestamp": 1527006026877, + "version": "3.4.1" + }, + "opencv-3.4.1-py36h6fd60c2_3.tar.bz2": { + "build": "py36h6fd60c2_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.1 py36h8fa1ad8_3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9d74150e575b0efed0588d4dfea08a3f", + "name": "opencv", + "sha256": "a5ccac5d7316646144982587d59052c6885884b10ebb5df880c5dcfdedfe97a1", + "size": 7791, + "subdir": "linux-64", + "timestamp": 1530791092728, + "version": "3.4.1" + }, + "opencv-3.4.1-py37h40b0b35_3.tar.bz2": { + "build": "py37h40b0b35_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "py-opencv 3.4.1 py37he6673a0_3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "fe7a1869780b6c2a762067d42724530c", + "name": "opencv", + "sha256": "80a2c120ca6da9bd8f78105af2b6a09cdf64eb2dc863d7cc5619e684e875cba7", + "size": 7813, + "subdir": "linux-64", + "timestamp": 1530792776415, + "version": "3.4.1" + }, + "opencv-3.4.1-py37h6fd60c2_3.tar.bz2": { + "build": "py37h6fd60c2_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.1 py37h8fa1ad8_3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "19cf1b81349e13f29693c7d8c8b27661", + "name": "opencv", + "sha256": "c82fa5266ee5dd37cb4b44369d01aa4eef471b145c8df9bc6f4c261ad0ff4b4a", + "size": 7799, + "subdir": "linux-64", + "timestamp": 1530791106090, + "version": "3.4.1" + }, + "opencv-3.4.2-py27h40b0b35_0.tar.bz2": { + "build": "py27h40b0b35_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "py-opencv 3.4.2 py27he6673a0_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0daa7f780c6847f447fc711298ae7e24", + "name": "opencv", + "sha256": "98d700cfdf517ce661a38a9f351ee38400c840f0ec58001eb3837aa16879b4ee", + "size": 10258, + "subdir": "linux-64", + "timestamp": 1533644313336, + "version": "3.4.2" + }, + "opencv-3.4.2-py27h40b0b35_1.tar.bz2": { + "build": "py27h40b0b35_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "py-opencv 3.4.2 py27h765d7f9_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e14ee0ab2b3a5dc7550b8db70a079ea5", + "name": "opencv", + "sha256": "81c2df4f28ed963b8160e9e406c68ed8a1cc80f22bb7abcc7d31288d83aa2ead", + "size": 10918, + "subdir": "linux-64", + "timestamp": 1535562135112, + "version": "3.4.2" + }, + "opencv-3.4.2-py27h6fd60c2_0.tar.bz2": { + "build": "py27h6fd60c2_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.2 py27h8fa1ad8_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a0ac54212daca55a35d96e3d3db61c20", + "name": "opencv", + "sha256": "780fe0c659ad90e63140c791411957e4ac6e3b87df3389c5298fec878e5642ac", + "size": 10251, + "subdir": "linux-64", + "timestamp": 1533642756899, + "version": "3.4.2" + }, + "opencv-3.4.2-py27h6fd60c2_1.tar.bz2": { + "build": "py27h6fd60c2_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.2 py27hb342d67_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f3f0750446853cee666bc54b81b7b6a6", + "name": "opencv", + "sha256": "47c0ead996c809139e13f6513d46d9fd49732597822bd8e85cfbe3d34bbdcd22", + "size": 10932, + "subdir": "linux-64", + "timestamp": 1535562153929, + "version": "3.4.2" + }, + "opencv-3.4.2-py35h40b0b35_0.tar.bz2": { + "build": "py35h40b0b35_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "py-opencv 3.4.2 py35he6673a0_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2ed36dd75ac380a50f7037f14bb1c9e0", + "name": "opencv", + "sha256": "40dacd047a2fcc3c148f1e96162d89cae97b71e83ce9b232bc4212077f2b3415", + "size": 10259, + "subdir": "linux-64", + "timestamp": 1533644338585, + "version": "3.4.2" + }, + "opencv-3.4.2-py35h40b0b35_1.tar.bz2": { + "build": "py35h40b0b35_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "py-opencv 3.4.2 py35h765d7f9_1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6454f0aac508dddba99fb772237dd9b3", + "name": "opencv", + "sha256": "20d3153ee8b8cdf834c8c73aefbd2456b21c7e47bdb4ecb354060347a9a5c796", + "size": 10915, + "subdir": "linux-64", + "timestamp": 1535562154008, + "version": "3.4.2" + }, + "opencv-3.4.2-py35h6fd60c2_0.tar.bz2": { + "build": "py35h6fd60c2_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.2 py35h8fa1ad8_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a8f96877705e000d82f48732d9cb3920", + "name": "opencv", + "sha256": "0650e00aab0d94d61ee53773ff61e66308a594beab45f70304653d7075171b57", + "size": 10264, + "subdir": "linux-64", + "timestamp": 1533642780993, + "version": "3.4.2" + }, + "opencv-3.4.2-py35h6fd60c2_1.tar.bz2": { + "build": "py35h6fd60c2_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.2 py35hb342d67_1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4c4654e98fd4ae1179db051e7750d1d4", + "name": "opencv", + "sha256": "bda90d8b83e9c47c8bd620cb5aa6fa9d2c6509cb5eb4b993847734a08c234787", + "size": 10901, + "subdir": "linux-64", + "timestamp": 1535562135510, + "version": "3.4.2" + }, + "opencv-3.4.2-py36h40b0b35_0.tar.bz2": { + "build": "py36h40b0b35_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "py-opencv 3.4.2 py36he6673a0_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b8376eb73ebd4b176f2d8aa18931d6fa", + "name": "opencv", + "sha256": "e6737883ed870304d16e0fde9dc8685af79330a254b2d4127986261c7b17d078", + "size": 10262, + "subdir": "linux-64", + "timestamp": 1533644389237, + "version": "3.4.2" + }, + "opencv-3.4.2-py36h40b0b35_1.tar.bz2": { + "build": "py36h40b0b35_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "py-opencv 3.4.2 py36h765d7f9_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a2c4b8352cb9800811ed6800a0b03513", + "name": "opencv", + "sha256": "3afdf0ff57efbff8ebb5883455f642bca6c4a5b2787cab0c0a62475a93744f92", + "size": 10894, + "subdir": "linux-64", + "timestamp": 1535562175449, + "version": "3.4.2" + }, + "opencv-3.4.2-py36h6fd60c2_0.tar.bz2": { + "build": "py36h6fd60c2_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.2 py36h8fa1ad8_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ba90eca695b273b306c6394d924515c8", + "name": "opencv", + "sha256": "0078b15953df27457f4d9589dc6715145f9a76d27d532fd6c917da77d60201ca", + "size": 10244, + "subdir": "linux-64", + "timestamp": 1533642829270, + "version": "3.4.2" + }, + "opencv-3.4.2-py36h6fd60c2_1.tar.bz2": { + "build": "py36h6fd60c2_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.2 py36hb342d67_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dbd9d65fbbf38a23904d1114ae21992f", + "name": "opencv", + "sha256": "7b21c56f81ca82865ebabbf726882e65c3cec4b8cc7602007bb53446a2540076", + "size": 10910, + "subdir": "linux-64", + "timestamp": 1535562175359, + "version": "3.4.2" + }, + "opencv-3.4.2-py37h40b0b35_0.tar.bz2": { + "build": "py37h40b0b35_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "py-opencv 3.4.2 py37he6673a0_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ac9b8578179483456b265b07d67af5cf", + "name": "opencv", + "sha256": "0fbc820659d44bb83770a127213ebee5a3a17d8253ab89194734c0ce60cd35fb", + "size": 10274, + "subdir": "linux-64", + "timestamp": 1533644363950, + "version": "3.4.2" + }, + "opencv-3.4.2-py37h40b0b35_1.tar.bz2": { + "build": "py37h40b0b35_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "py-opencv 3.4.2 py37h765d7f9_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "558e3dbaa987680271ea591cc53639da", + "name": "opencv", + "sha256": "712d6243254282cb51a74f722a7fba3eec0563aa1b441eaa841f3b31598a29c3", + "size": 10923, + "subdir": "linux-64", + "timestamp": 1535562198809, + "version": "3.4.2" + }, + "opencv-3.4.2-py37h6fd60c2_0.tar.bz2": { + "build": "py37h6fd60c2_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.2 py37h8fa1ad8_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "27d4819f48f82e611ed3ee8428eff1a5", + "name": "opencv", + "sha256": "407a8ba171ca9ec3c25c4abdec12559b3fa806bfc3eb74cbc4c7a2125d0dd67d", + "size": 10249, + "subdir": "linux-64", + "timestamp": 1533642805044, + "version": "3.4.2" + }, + "opencv-3.4.2-py37h6fd60c2_1.tar.bz2": { + "build": "py37h6fd60c2_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.2 py37hb342d67_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ca927bfff5f56d9c6ee3e5ffecfb04ae", + "name": "opencv", + "sha256": "044fad3d3e883ad22cca27f62e9ec7fe35f32d387f93889e99046be1592b2024", + "size": 10921, + "subdir": "linux-64", + "timestamp": 1535562198646, + "version": "3.4.2" + }, + "opencv-4.5.4-py310h15b3d91_1.tar.bz2": { + "build": "py310h15b3d91_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "numpy 1.21.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2486cc615b8d7d2c5e23c10f075767e9", + "name": "opencv", + "sha256": "ab7b984e28b16af34d569fb9daef16a557b16d23ed61fc32194e5c8fcd47e4f5", + "size": 35790823, + "subdir": "linux-64", + "timestamp": 1647367605599, + "version": "4.5.4" + }, + "opencv-4.5.4-py310h3dbb160_2.tar.bz2": { + "build": "py310h3dbb160_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.21.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "36b8f2dcd3b46459aee3681a225d3f7f", + "name": "opencv", + "sha256": "fdcb5ccbd4017569219e41ca228281e37863e1ba41febc9df4744eb8f9d9151a", + "size": 35731437, + "subdir": "linux-64", + "timestamp": 1648815666835, + "version": "4.5.4" + }, + "opencv-4.5.4-py310h3dbb160_3.tar.bz2": { + "build": "py310h3dbb160_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.21.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7e1017a2cf3faad5c73cc3b29882afc5", + "name": "opencv", + "sha256": "8dd896d1d38cc6b4c42e82c81cae33ac41877ee7048d058062235d1b3478a156", + "size": 35721062, + "subdir": "linux-64", + "timestamp": 1648891298823, + "version": "4.5.4" + }, + "opencv-4.5.4-py37h7f95952_1.tar.bz2": { + "build": "py37h7f95952_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0ec26757d112dd7339c60c81bebf8ed1", + "name": "opencv", + "sha256": "d31b2fc62918806c6da73240c95f929f03655a7ad6be640f716cf9b826af93d3", + "size": 35781492, + "subdir": "linux-64", + "timestamp": 1647369750936, + "version": "4.5.4" + }, + "opencv-4.5.4-py37hbeebcbe_2.tar.bz2": { + "build": "py37hbeebcbe_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "50f9d12b43dd1f0242fea6949ab91d64", + "name": "opencv", + "sha256": "6e391d5fdf528e91af0f25fe6e932dab40a9b53486d2916ebc1d4058951b4dba", + "size": 35695175, + "subdir": "linux-64", + "timestamp": 1648833791234, + "version": "4.5.4" + }, + "opencv-4.5.4-py37hbeebcbe_3.tar.bz2": { + "build": "py37hbeebcbe_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "88c0ab3fe0a00fed24beb9d76780532b", + "name": "opencv", + "sha256": "64470498375dfe842e7623d1712534fbd7e37f4c6313d39773f4b7f3e1d93f0a", + "size": 35728548, + "subdir": "linux-64", + "timestamp": 1648891342337, + "version": "4.5.4" + }, + "opencv-4.5.4-py38h7f95952_1.tar.bz2": { + "build": "py38h7f95952_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f0fdb3b3ebb610c465ba28b865a59887", + "name": "opencv", + "sha256": "2c5b64fc5a6e02eb57b03a4e92103ec4c8c416918caead39ed33afbed883407d", + "size": 35790147, + "subdir": "linux-64", + "timestamp": 1647368488365, + "version": "4.5.4" + }, + "opencv-4.5.4-py38hbeebcbe_2.tar.bz2": { + "build": "py38hbeebcbe_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0e4e1b47b79024c69a935b5845a8e15f", + "name": "opencv", + "sha256": "262f09b882ccf2eac40c2ff6993dd4d998451793d3577c899c4c659e2a51883c", + "size": 35741152, + "subdir": "linux-64", + "timestamp": 1648815890308, + "version": "4.5.4" + }, + "opencv-4.5.4-py38hbeebcbe_3.tar.bz2": { + "build": "py38hbeebcbe_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2f2e92b36ce4b604cbccee341ad5a112", + "name": "opencv", + "sha256": "2af05cca82ecc37a0c0bb4e1ebaac54bd3a5c5765c567544fda16b2bf7bfc230", + "size": 35777213, + "subdir": "linux-64", + "timestamp": 1648873187215, + "version": "4.5.4" + }, + "opencv-4.5.4-py39h7f95952_1.tar.bz2": { + "build": "py39h7f95952_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "71fe11f479e0bfa75b9d31ab876b7886", + "name": "opencv", + "sha256": "7a01073a46a561330ff832f3bd78e10e65cfcbf91d20669d911263629ac0fd3c", + "size": 35785814, + "subdir": "linux-64", + "timestamp": 1647366707123, + "version": "4.5.4" + }, + "opencv-4.5.4-py39hbeebcbe_2.tar.bz2": { + "build": "py39hbeebcbe_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ca77167d37458d436c0401694d4b97e7", + "name": "opencv", + "sha256": "7a290c32e5d61ea6501b3b30c915f4df3f1057e78b57a642a4efa61b75091b82", + "size": 35680479, + "subdir": "linux-64", + "timestamp": 1648833805801, + "version": "4.5.4" + }, + "opencv-4.5.4-py39hbeebcbe_3.tar.bz2": { + "build": "py39hbeebcbe_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cc7ed9b1477f9423d1819605fc33c641", + "name": "opencv", + "sha256": "1d6f56add079de37ea8fd517d80b0d56c68da8d8c1e87e999394b5b972f32c06", + "size": 35673203, + "subdir": "linux-64", + "timestamp": 1648873442169, + "version": "4.5.4" + }, + "opencv-4.5.5-py310h496257e_3.tar.bz2": { + "build": "py310h496257e_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.21.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d9737d10bcca52ec32fd6e55dbf1c3d9", + "name": "opencv", + "sha256": "36ce5351922b7b0da1ad0c941f36103d94c4d7570209960afa3f0742de0141a7", + "size": 37042716, + "subdir": "linux-64", + "timestamp": 1656607995829, + "version": "4.5.5" + }, + "opencv-4.5.5-py310h496257e_4.tar.bz2": { + "build": "py310h496257e_4", + "build_number": 4, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.21.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt-main >=5.15,<6", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.7,<6", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7599bd8e3230d5a2155125e06e39a930", + "name": "opencv", + "sha256": "d65958ee7e3e3684743c99cbd09b5de94035f81e0e54ca372f0c49f89325e580", + "size": 36982386, + "subdir": "linux-64", + "timestamp": 1659979471169, + "version": "4.5.5" + }, + "opencv-4.5.5-py310hd7713a7_2.tar.bz2": { + "build": "py310hd7713a7_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.21.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f39309b468b6ee051a4246bd53deee1b", + "name": "opencv", + "sha256": "70b3fdc1c5d7f2e26a71e15863683ae351368a4287edbd0404fd7783c0a65936", + "size": 36919136, + "subdir": "linux-64", + "timestamp": 1656001417112, + "version": "4.5.5" + }, + "opencv-4.5.5-py310hf7f654e_0.tar.bz2": { + "build": "py310hf7f654e_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.18,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.21.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "267742c9787eaaf553864a06e3b1700b", + "name": "opencv", + "sha256": "ed78d235624a89e29bbec4da2ae0c855010f861f6f74b625a2c2ed6452d8ab8f", + "size": 36527456, + "subdir": "linux-64", + "timestamp": 1652958456683, + "version": "4.5.5" + }, + "opencv-4.5.5-py310hf7f654e_1.tar.bz2": { + "build": "py310hf7f654e_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.21.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d6bbe48bd8da70b72b3e7b65003eef92", + "name": "opencv", + "sha256": "d6605e1bfcd34aed6e38011e9f6574bdb067c87665b0c6de725e8c0dfc4462eb", + "size": 36380526, + "subdir": "linux-64", + "timestamp": 1655910131926, + "version": "4.5.5" + }, + "opencv-4.5.5-py37h1ca2c5e_3.tar.bz2": { + "build": "py37h1ca2c5e_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9b56d362f63f0b56026809c96e13533a", + "name": "opencv", + "sha256": "03adda2f503d055b9389a95086f2e9e21d317aa79c2e32820d948db05afd7937", + "size": 37027445, + "subdir": "linux-64", + "timestamp": 1656607291090, + "version": "4.5.5" + }, + "opencv-4.5.5-py37h1ca2c5e_4.tar.bz2": { + "build": "py37h1ca2c5e_4", + "build_number": 4, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt-main >=5.15,<6", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.7,<6", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "51ea34580946eb140102491748feb2b8", + "name": "opencv", + "sha256": "b71ab49bbeac9e3a6ee5e46ee16383a593b0397b1a04b4f748b7c59295d06d03", + "size": 37007977, + "subdir": "linux-64", + "timestamp": 1659978027699, + "version": "4.5.5" + }, + "opencv-4.5.5-py37h905f02f_0.tar.bz2": { + "build": "py37h905f02f_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.18,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2a5fee19edef547b473d10b26bd64fed", + "name": "opencv", + "sha256": "78ec42e90e529bc7500f8366322e8cce20893026880351175cb9a565de3b8df3", + "size": 36519754, + "subdir": "linux-64", + "timestamp": 1652956655549, + "version": "4.5.5" + }, + "opencv-4.5.5-py37h905f02f_1.tar.bz2": { + "build": "py37h905f02f_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "06882366d3fb7c5afb9a6441073c6379", + "name": "opencv", + "sha256": "fb4175a384f1a235d158445934e880ccf9d5566f73f59e959621791cdbc86a0e", + "size": 36376256, + "subdir": "linux-64", + "timestamp": 1655908945619, + "version": "4.5.5" + }, + "opencv-4.5.5-py37ha5a2927_2.tar.bz2": { + "build": "py37ha5a2927_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "24b04b331267d3b41e9754ecdf3a690a", + "name": "opencv", + "sha256": "24396264039afa151bd3d1be461998954241bcbc0a1e454a4bf9dd882a1c4d23", + "size": 36884338, + "subdir": "linux-64", + "timestamp": 1656000357038, + "version": "4.5.5" + }, + "opencv-4.5.5-py38h1ca2c5e_3.tar.bz2": { + "build": "py38h1ca2c5e_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e61993f8bd400dc35345abe36c0687c9", + "name": "opencv", + "sha256": "0f5537156b5456146285d308f27a18a77b4eda8a14331bb116fe134665d23a7f", + "size": 37031427, + "subdir": "linux-64", + "timestamp": 1656608704410, + "version": "4.5.5" + }, + "opencv-4.5.5-py38h1ca2c5e_4.tar.bz2": { + "build": "py38h1ca2c5e_4", + "build_number": 4, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt-main >=5.15,<6", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.7,<6", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9c160cb629fae4dd588bd2b8e84789f4", + "name": "opencv", + "sha256": "c5a1af4383e52646c2961df50ab1b7aac50f0df0bd8b48f4584e41a3a7b88e88", + "size": 37002461, + "subdir": "linux-64", + "timestamp": 1659976576164, + "version": "4.5.5" + }, + "opencv-4.5.5-py38h905f02f_0.tar.bz2": { + "build": "py38h905f02f_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.18,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b8a42d05b017ef536df3606e9695a0a4", + "name": "opencv", + "sha256": "b6414899f7b91caf8372c4ee8ec7d0fb48eb2b90db25f104974ef2b0fd01dd33", + "size": 36525160, + "subdir": "linux-64", + "timestamp": 1652957868579, + "version": "4.5.5" + }, + "opencv-4.5.5-py38h905f02f_1.tar.bz2": { + "build": "py38h905f02f_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "581767fadf62af2a04c433547af57314", + "name": "opencv", + "sha256": "f2883908772ac0bb07e17a53b2f34b2e78b7a0a1ca46490ac392f8fc240152f3", + "size": 36379526, + "subdir": "linux-64", + "timestamp": 1655908283048, + "version": "4.5.5" + }, + "opencv-4.5.5-py38ha5a2927_2.tar.bz2": { + "build": "py38ha5a2927_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5fe7879f04ebd4ab4c33f70fb1e72982", + "name": "opencv", + "sha256": "f801c9baa1849c081bcab5cae601c6a40ccde84ca6bee72619eb9b0cb1e1f031", + "size": 36890096, + "subdir": "linux-64", + "timestamp": 1656003300384, + "version": "4.5.5" + }, + "opencv-4.5.5-py39h1ca2c5e_3.tar.bz2": { + "build": "py39h1ca2c5e_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0b76493348b4c14dde1c409a3f57c7df", + "name": "opencv", + "sha256": "6402fa536de8beeade6d4a9f3844e664c181f25269608f19497a48c772bad753", + "size": 37045173, + "subdir": "linux-64", + "timestamp": 1656609367575, + "version": "4.5.5" + }, + "opencv-4.5.5-py39h1ca2c5e_4.tar.bz2": { + "build": "py39h1ca2c5e_4", + "build_number": 4, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt-main >=5.15,<6", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.7,<6", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0bac0c751ffa99cf0c4804d7f9950ebd", + "name": "opencv", + "sha256": "a5fac882a003d1f6e0333277f74ce9692582b9062b02b7ebd59d7bf8f8579a4a", + "size": 36985199, + "subdir": "linux-64", + "timestamp": 1659975074509, + "version": "4.5.5" + }, + "opencv-4.5.5-py39h905f02f_0.tar.bz2": { + "build": "py39h905f02f_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.18,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b49c4e35141e490398a40e1306a32b94", + "name": "opencv", + "sha256": "e0cde77efdd53bbdb5254cc198db750c4044a50c64fdb00dff5740ae21c2b384", + "size": 36525651, + "subdir": "linux-64", + "timestamp": 1652957283086, + "version": "4.5.5" + }, + "opencv-4.5.5-py39h905f02f_1.tar.bz2": { + "build": "py39h905f02f_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9738c6fe0a4ff30ed188a5f834ed160b", + "name": "opencv", + "sha256": "c8c66c77b50b6a6f0a99f2cdeb3ed2c856c507ed570a711a4d60d371504036d8", + "size": 36378424, + "subdir": "linux-64", + "timestamp": 1655909536144, + "version": "4.5.5" + }, + "opencv-4.5.5-py39ha5a2927_2.tar.bz2": { + "build": "py39ha5a2927_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "baf0c829fb0d3496cef79846636537d4", + "name": "opencv", + "sha256": "a65627012fd525c518d5cdce5aa3c14961ce3284e2ed3108a7647f74392549d2", + "size": 36921045, + "subdir": "linux-64", + "timestamp": 1656002366809, + "version": "4.5.5" + }, + "opencv-4.6.0-py310h1128e8f_3.tar.bz2": { + "build": "py310h1128e8f_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen >=3.3.7", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy >=1.21,<2", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt-main >=5.15,<6", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.7,<6", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b165fec9e16afe3ca44a1728d1d785de", + "name": "opencv", + "sha256": "20db3c89175072806ecbc1304dd5f9b8be6c4990a4c336e786a83b336b80b015", + "size": 37233841, + "subdir": "linux-64", + "timestamp": 1676456401234, + "version": "4.6.0" + }, + "opencv-4.6.0-py310hefb4dc4_0.tar.bz2": { + "build": "py310hefb4dc4_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f995c07d651cd080c10ea33d49b09440", + "name": "opencv", + "sha256": "bf44bcf766ff0747d623d4d02fd3b129c6974e65aaa2e291de0adc58b74c6de1", + "size": 37133637, + "subdir": "linux-64", + "timestamp": 1663875553489, + "version": "4.6.0" + }, + "opencv-4.6.0-py310hefb4dc4_1.tar.bz2": { + "build": "py310hefb4dc4_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ff87650dee52b69fb35bef3db2c3db25", + "name": "opencv", + "sha256": "3b018e863c397b586c8e9b2feac3cafcd9ff70dd0d3a0d712f023e32f38e6290", + "size": 37285777, + "subdir": "linux-64", + "timestamp": 1664377432589, + "version": "4.6.0" + }, + "opencv-4.6.0-py310hefb4dc4_2.tar.bz2": { + "build": "py310hefb4dc4_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2bff54ced1a71e2a2c7e0ea79bb274d5", + "name": "opencv", + "sha256": "b099e8c395235b9089b8a9a289ae260e1eb0addd1130c262726d6c1154459d4f", + "size": 37207015, + "subdir": "linux-64", + "timestamp": 1664553442251, + "version": "4.6.0" + }, + "opencv-4.6.0-py311hba01205_3.tar.bz2": { + "build": "py311hba01205_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen >=3.3.7", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy >=1.22,<2", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.11,<3.12.0a0", + "qt-main >=5.15,<6", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.7,<6", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6329dfcde69a48eb18f9d9fa29fba161", + "name": "opencv", + "sha256": "c01455d4bcabc32bbada790114de32889dbb956863f72c0a42af8f9d992792d1", + "size": 37358391, + "subdir": "linux-64", + "timestamp": 1676838441014, + "version": "4.6.0" + }, + "opencv-4.6.0-py37h417a72b_3.tar.bz2": { + "build": "py37h417a72b_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen >=3.3.7", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy >=1.16,<2", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt-main >=5.15,<6", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.7,<6", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fdc9c9572a055f3a15f532233cbb036b", + "name": "opencv", + "sha256": "8fe4f39722b86a39b6171a410b4dca4ac08256dc056d5b948e9a2f5b185bf313", + "size": 37215601, + "subdir": "linux-64", + "timestamp": 1676454953747, + "version": "4.6.0" + }, + "opencv-4.6.0-py37hd653453_0.tar.bz2": { + "build": "py37hd653453_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e1102569cfd7b855674f07f48fade165", + "name": "opencv", + "sha256": "dca88a90b51a0b2b18d2ff0413bbfec28160dca4722931bf4ef8528839bd84d6", + "size": 37143505, + "subdir": "linux-64", + "timestamp": 1663873983878, + "version": "4.6.0" + }, + "opencv-4.6.0-py37hd653453_1.tar.bz2": { + "build": "py37hd653453_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "78efb3870f3b4b8941042583edf4c4e4", + "name": "opencv", + "sha256": "488a29951d5832c220f70b7782d3ee1c5cb1f8608015f7a17158ab50e2cfa6af", + "size": 37275086, + "subdir": "linux-64", + "timestamp": 1664372632937, + "version": "4.6.0" + }, + "opencv-4.6.0-py37hd653453_2.tar.bz2": { + "build": "py37hd653453_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "725a4ba8ae1a84a2db2ba8496b486a23", + "name": "opencv", + "sha256": "3c982f40dcfb12253585c566ce6206d21cd40fa660b3f25957387a3359601e48", + "size": 37198586, + "subdir": "linux-64", + "timestamp": 1664551770288, + "version": "4.6.0" + }, + "opencv-4.6.0-py38h417a72b_3.tar.bz2": { + "build": "py38h417a72b_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen >=3.3.7", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy >=1.16,<2", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt-main >=5.15,<6", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.7,<6", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "911e65b8b931f731dd28452d731faa5d", + "name": "opencv", + "sha256": "da8735d27764dec8187a02e71866989e02c26391a43354b2954dcab749e78385", + "size": 37217976, + "subdir": "linux-64", + "timestamp": 1676453464489, + "version": "4.6.0" + }, + "opencv-4.6.0-py38hd653453_0.tar.bz2": { + "build": "py38hd653453_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f4484abdd8077c76281579576040775e", + "name": "opencv", + "sha256": "31352795ae5887670aa160b5858060b0007f598361ec4d7f158d41559996dbd1", + "size": 37149525, + "subdir": "linux-64", + "timestamp": 1663878510122, + "version": "4.6.0" + }, + "opencv-4.6.0-py38hd653453_1.tar.bz2": { + "build": "py38hd653453_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c156bc7df6134758f2c46839b0c1afc7", + "name": "opencv", + "sha256": "e7bad64dfeddefcd917818f63306ecb8f2381db56c46890431d4e7f2a10a25ae", + "size": 37282490, + "subdir": "linux-64", + "timestamp": 1664375863510, + "version": "4.6.0" + }, + "opencv-4.6.0-py38hd653453_2.tar.bz2": { + "build": "py38hd653453_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1efe96e9dd5ce8bdeac4d5857f257dca", + "name": "opencv", + "sha256": "81e95268f9e3488dd6014e2a697180ccdaabdd2d48b9e8250ec443ddda9a6902", + "size": 37199693, + "subdir": "linux-64", + "timestamp": 1664555102998, + "version": "4.6.0" + }, + "opencv-4.6.0-py39h417a72b_3.tar.bz2": { + "build": "py39h417a72b_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen >=3.3.7", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy >=1.16,<2", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt-main >=5.15,<6", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.7,<6", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c746a3b571289e13f69c42d3f97893a4", + "name": "opencv", + "sha256": "ccc2564ea3e23dd61567f0cdaeb35226dfcd1b894243c4857d78b9b0d9d1dd34", + "size": 37231088, + "subdir": "linux-64", + "timestamp": 1676457842931, + "version": "4.6.0" + }, + "opencv-4.6.0-py39hd653453_0.tar.bz2": { + "build": "py39hd653453_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "476ee7e84d9cfd5d374306e0499e9d8e", + "name": "opencv", + "sha256": "da53bf521f5118e8e8218e8b98df32c0e8280976ac558a924db99302076d91d7", + "size": 37126635, + "subdir": "linux-64", + "timestamp": 1663877058409, + "version": "4.6.0" + }, + "opencv-4.6.0-py39hd653453_1.tar.bz2": { + "build": "py39hd653453_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8ba1f3816eb9f5abcf304296f168f5de", + "name": "opencv", + "sha256": "bc2d16f45812adae502e2c64c12c625ca0f9d48f94a7b584fbe9e90005256b07", + "size": 37288126, + "subdir": "linux-64", + "timestamp": 1664374281016, + "version": "4.6.0" + }, + "opencv-4.6.0-py39hd653453_2.tar.bz2": { + "build": "py39hd653453_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ebb0c06990635e76cd137cf32a981779", + "name": "opencv", + "sha256": "c4569edb3ef144285176a750aef59314402680cb26d62f77319dba00f9ed2ab1", + "size": 37209108, + "subdir": "linux-64", + "timestamp": 1664550050489, + "version": "4.6.0" + }, + "openh264-1.8.0-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "939ee5026bbe35ace9a4dbe93f7caff0", + "name": "openh264", + "sha256": "016bdc2b4d66acc54e056f0d1d7b3a98587f94327b98e222ca0d3b3073193a74", + "size": 1445169, + "subdir": "linux-64", + "timestamp": 1576633242115, + "version": "1.8.0" + }, + "openh264-2.1.0-hd408876_0.tar.bz2": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e0bf690cb6618ae2767b482d2ddbba41", + "name": "openh264", + "sha256": "625b7ad90ee37f654cea8ae1ae27b15bf8a6367ce94a7a6278ce387dfe4a72fd", + "size": 1572452, + "subdir": "linux-64", + "timestamp": 1587147185809, + "version": "2.1.0" + }, + "openh264-2.1.1-h4ff587b_0.tar.bz2": { + "build": "h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b25b510a3be22cd8feea30015ea8f33c", + "name": "openh264", + "sha256": "bf24f2cc2d61877b40aa5f87caae1ef668dbdaab07d9b8a2f6fd2c5c672ec6bd", + "size": 1613105, + "subdir": "linux-64", + "timestamp": 1640014414497, + "version": "2.1.1" + }, + "openjdk-11.0.13-h87a67e3_0.tar.bz2": { + "build": "h87a67e3_0", + "build_number": 0, + "depends": [ + "dbus", + "expat", + "freetype", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libxcb", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-only", + "license_family": "GPL", + "md5": "d0b22e3690b67adff05096a7d459257b", + "name": "openjdk", + "sha256": "12f23c84bb87bb55adbf45a1fc8225edf48a2321d97a6879c5c91df3966bd8c6", + "size": 429861594, + "subdir": "linux-64", + "timestamp": 1642156521678, + "version": "11.0.13" + }, + "openjdk-8.0.152-h46b5887_1.tar.bz2": { + "build": "h46b5887_1", + "build_number": 1, + "depends": [], + "license": "GPLv2", + "license_family": "GPL", + "md5": "f62a8ce38240210b7c41df733d84aefe", + "name": "openjdk", + "sha256": "1065a47ca5981d6615e16801a8c5aacb7a965574de1e6ba3b9e000c70e90173d", + "size": 134875576, + "subdir": "linux-64", + "timestamp": 1511651164872, + "track_features": "", + "version": "8.0.152" + }, + "openjdk-8.0.152-h6bedd7e_0.tar.bz2": { + "build": "h6bedd7e_0", + "build_number": 0, + "depends": [], + "license": "GPLv2", + "license_family": "GPL", + "md5": "0a7cb107ec9ccece2c9a1149f7f93aad", + "name": "openjdk", + "sha256": "6fef60ac0e2613bc3c02a75e3e40d4b51e02916eeed60cfe2a63ef9ff7e9110f", + "size": 74104722, + "subdir": "linux-64", + "timestamp": 1510575278043, + "track_features": "", + "version": "8.0.152" + }, + "openjdk-8.0.152-h7b6447c_2.tar.bz2": { + "build": "h7b6447c_2", + "build_number": 2, + "depends": [], + "license": "GPLv2", + "license_family": "GPL", + "md5": "a158cf306c8f7e2ab16268525c1c0769", + "name": "openjdk", + "sha256": "db90fe3c66209f1ec4195fc7207068451b85a41871ef06f3030745310033ff30", + "size": 135419170, + "subdir": "linux-64", + "timestamp": 1581437462341, + "track_features": "", + "version": "8.0.152" + }, + "openjdk-8.0.152-h7b6447c_3.tar.bz2": { + "build": "h7b6447c_3", + "build_number": 3, + "depends": [], + "license": "GPLv2", + "license_family": "GPL", + "md5": "b3a0cc294b4f50d7be934551fc83e27e", + "name": "openjdk", + "sha256": "ae6668d091290eeca2305bb0e00c99eb7e60225d5fc27723979db919d69967de", + "size": 134759010, + "subdir": "linux-64", + "timestamp": 1581682020627, + "track_features": "", + "version": "8.0.152" + }, + "openjpeg-2.2.0-h622c3cc_2.tar.bz2": { + "build": "h622c3cc_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.8,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 2-clauses", + "md5": "36c8a8c76c43ec9b654a44eb103a7b48", + "name": "openjpeg", + "sha256": "40fbc62c41183374289edd5afb7889855a667839c0297193309496aac9a93a38", + "size": 433271, + "subdir": "linux-64", + "timestamp": 1510610341685, + "version": "2.2.0" + }, + "openjpeg-2.2.0-hdc6a14e_1.tar.bz2": { + "build": "hdc6a14e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.8,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 2-clauses", + "md5": "265d562471a6b69be1ea17e37257fa0a", + "name": "openjpeg", + "sha256": "2adb8a6a23d56cabffc504a111000ad28fd52039615e790f9ffa2d36d8788ed0", + "size": 433012, + "subdir": "linux-64", + "timestamp": 1507908083481, + "version": "2.2.0" + }, + "openjpeg-2.3.0-h05c96fa_1.tar.bz2": { + "build": "h05c96fa_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 2-Clause", + "md5": "0d0103ce1db01d8ad932515fd750387b", + "name": "openjpeg", + "sha256": "b24f57edab22909a28d99c582b5530121e7b6cd0bf25c4ca5ca8e799c0281444", + "size": 467392, + "subdir": "linux-64", + "timestamp": 1527098564255, + "version": "2.3.0" + }, + "openjpeg-2.3.0-hef292c2_0.tar.bz2": { + "build": "hef292c2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 2-Clause", + "md5": "9083f3a2a109d7e3a31128c9fc167e0a", + "name": "openjpeg", + "sha256": "bc77ac9e57ab8effe1dd91524aaeefc51a7e1f06df040c4445b0aa5d2974e26b", + "size": 465452, + "subdir": "linux-64", + "timestamp": 1522877116711, + "version": "2.3.0" + }, + "openjpeg-2.4.0-h3ad879b_0.tar.bz2": { + "build": "h3ad879b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0" + ], + "license": "BSD 2-Clause", + "md5": "b0afe23033c8c5344640bc25225fa579", + "name": "openjpeg", + "sha256": "128890b4fc4124ba4221a0073187119d5f4824f150edf7b7647bd8c4eb566117", + "size": 516994, + "subdir": "linux-64", + "timestamp": 1630084830020, + "version": "2.4.0" + }, + "openldap-2.4.57-he2b52b7_0.tar.bz2": { + "build": "he2b52b7_0", + "build_number": 0, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "OLDAP-2.8", + "license_family": "BSD", + "md5": "63cc970d672fed0e43bc5f2d00e6eb42", + "name": "openldap", + "sha256": "7d817981ff7ed0551eb6c2950b3db9749d1aad6b0a1ab1c1454881d35b2dd254", + "size": 1381404, + "subdir": "linux-64", + "timestamp": 1611875242859, + "version": "2.4.57" + }, + "openldap-2.4.58-h8242995_1.tar.bz2": { + "build": "h8242995_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1q,<1.1.2a" + ], + "license": "OLDAP-2.8", + "license_family": "BSD", + "md5": "8bf1508a3501dbe0b2df8e5e91f3ccb9", + "name": "openldap", + "sha256": "0395576b92143964e964870adfd197709e6dee2ea4cb98c4d3481cb6634a9379", + "size": 1380699, + "subdir": "linux-64", + "timestamp": 1659704810080, + "version": "2.4.58" + }, + "openldap-2.4.58-he2b52b7_0.tar.bz2": { + "build": "he2b52b7_0", + "build_number": 0, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "OLDAP-2.8", + "license_family": "BSD", + "md5": "8992672ef66d021fed13bc4c24ab9a40", + "name": "openldap", + "sha256": "afa335fba50c2e6cc58a58b8fe1ef357b0ae8ef3caacadf81deb492df346b9eb", + "size": 1392878, + "subdir": "linux-64", + "timestamp": 1615922801332, + "version": "2.4.58" + }, + "openldap-2.5.4-he2b52b7_0.tar.bz2": { + "build": "he2b52b7_0", + "build_number": 0, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "OLDAP-2.8", + "license_family": "BSD", + "md5": "5018b13f15514d63146f1edb773fd4d0", + "name": "openldap", + "sha256": "3f7369b6fe174949210494cefcf5fc55653c512965cc2d04c6137a9b9f2f12ff", + "size": 1411017, + "subdir": "linux-64", + "timestamp": 1619733284631, + "version": "2.5.4" + }, + "openldap-2.5.5-h2aa78c0_1.tar.bz2": { + "build": "h2aa78c0_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.27,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1o,<1.1.2a" + ], + "license": "OLDAP-2.8", + "license_family": "BSD", + "md5": "fb2f512fd9ab830669c522183b204663", + "name": "openldap", + "sha256": "85252fff0cba7e9c1be4a8593779b577bbd89a48febe74eda81f0d058e6efe01", + "size": 1424500, + "subdir": "linux-64", + "timestamp": 1656412108864, + "version": "2.5.5" + }, + "openldap-2.5.5-he2b52b7_0.tar.bz2": { + "build": "he2b52b7_0", + "build_number": 0, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "OLDAP-2.8", + "license_family": "BSD", + "md5": "3f9624a9027dddb31f7ed8117d4fdf40", + "name": "openldap", + "sha256": "3bdd1b75ee267f13f528f2d345f92bc119c4f912fa91b94710ac2249bfa7c13a", + "size": 1368959, + "subdir": "linux-64", + "timestamp": 1622827467285, + "version": "2.5.5" + }, + "openmpi-4.0.2-hb1b8bf9_1.tar.bz2": { + "build": "hb1b8bf9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mpi 1.0 openmpi", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ff752a024ab43df123225e69c800bf05", + "name": "openmpi", + "sha256": "e473b79fc6554aa33b7240938af70f16e81087218529e0fada4dc8ace923601b", + "size": 4131149, + "subdir": "linux-64", + "timestamp": 1575396999134, + "version": "4.0.2" + }, + "openmpi-mpicc-4.0.2-h7b6447c_1.tar.bz2": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "gcc_linux-64 7.3.0.*", + "openmpi 4.0.2 hb1b8bf9_1" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7e953ab18194abbeaf8b9718f064d3de", + "name": "openmpi-mpicc", + "sha256": "8cc22a20842847bfe4f778756318c5fbc4caa207f13e6c212a81d1e4c4654081", + "size": 17316, + "subdir": "linux-64", + "timestamp": 1575397006405, + "version": "4.0.2" + }, + "openmpi-mpicxx-4.0.2-hfd86e86_1.tar.bz2": { + "build": "hfd86e86_1", + "build_number": 1, + "depends": [ + "gxx_linux-64 7.3.0.*", + "openmpi 4.0.2 hb1b8bf9_1" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "073767e79854b3f0098946d32a8f989d", + "name": "openmpi-mpicxx", + "sha256": "fe4b6fe6bafd681c2cf589ac9866cd7dbb8ee7066e0d81a913ecd062fc86c9b3", + "size": 17353, + "subdir": "linux-64", + "timestamp": 1575397009893, + "version": "4.0.2" + }, + "openmpi-mpifort-4.0.2-h84218bc_1.tar.bz2": { + "build": "h84218bc_1", + "build_number": 1, + "depends": [ + "gfortran_linux-64 7.3.0.*", + "openmpi 4.0.2 hb1b8bf9_1" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "50bc076ccc9cc7fc2e12b63df418888b", + "name": "openmpi-mpifort", + "sha256": "a3463b639008abe8773c8c13980b8f0d4fd05e047c7bbb551abba568f0a361a4", + "size": 17391, + "subdir": "linux-64", + "timestamp": 1575397013408, + "version": "4.0.2" + }, + "openpyxl-2.4.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ecbb7f0ea52656622aa84363ebe8e439", + "name": "openpyxl", + "sha256": "152dd8b56fe6e0f90092f09e990be212349185c57b06e20cbbabb8c95363ac53", + "size": 297718, + "subdir": "linux-64", + "timestamp": 1516746832586, + "version": "2.4.10" + }, + "openpyxl-2.4.10-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4fcaee76f3f9190b1b70a21736f98012", + "name": "openpyxl", + "sha256": "5872c9e0671a25f37f0adb59acc7e0c5d6ed66bb0fdd7a3ab73db7651213f24b", + "size": 305245, + "subdir": "linux-64", + "timestamp": 1516746859319, + "version": "2.4.10" + }, + "openpyxl-2.4.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ede89dbcc2ff1f8304dabf2e374db48", + "name": "openpyxl", + "sha256": "e5b1480b4bd0854603d1b1c6196bbe13b1b1d933ff0a6e8ed3eb39f43ce8a831", + "size": 304682, + "subdir": "linux-64", + "timestamp": 1516746864583, + "version": "2.4.10" + }, + "openpyxl-2.4.8-py27h9f0c937_1.tar.bz2": { + "build": "py27h9f0c937_1", + "build_number": 1, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a786936d77443fde308e414a42ba7a4", + "name": "openpyxl", + "sha256": "6495d4a34cd26fc10a058a6be617afd44725374cf9e98fbbe2d5ba0a54ce4b35", + "size": 295421, + "subdir": "linux-64", + "timestamp": 1506047880224, + "version": "2.4.8" + }, + "openpyxl-2.4.8-py35hd6c89d3_1.tar.bz2": { + "build": "py35hd6c89d3_1", + "build_number": 1, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "75951870b0490a5458d88bb2a3bb47a3", + "name": "openpyxl", + "sha256": "51a7b752ddbe1af1e1a1a7970243274fde17fe4702a160a09c0e28c45fc3089b", + "size": 302735, + "subdir": "linux-64", + "timestamp": 1506047904578, + "version": "2.4.8" + }, + "openpyxl-2.4.8-py36h41dd2a8_1.tar.bz2": { + "build": "py36h41dd2a8_1", + "build_number": 1, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "29e98cf5d2abe66666c08a60a8f8e222", + "name": "openpyxl", + "sha256": "f0240f23cd896488cb66aa1406574311c12c23c277d6eb08348b00ea527717af", + "size": 302459, + "subdir": "linux-64", + "timestamp": 1506047929116, + "version": "2.4.8" + }, + "openpyxl-2.4.9-py27hb67eb42_0.tar.bz2": { + "build": "py27hb67eb42_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ce9bc853d167074718c181d136cbbc2", + "name": "openpyxl", + "sha256": "9c100915c4a2d47333f535027c90c5e78b1792ce28da9e4ebc16a27d80278c27", + "size": 297177, + "subdir": "linux-64", + "timestamp": 1512057513932, + "version": "2.4.9" + }, + "openpyxl-2.4.9-py35h1699e3f_0.tar.bz2": { + "build": "py35h1699e3f_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9086f0e2f5affb1f898c060d2aa2be2", + "name": "openpyxl", + "sha256": "b7b9d59a86ff3b55494be681c7726161a5d3028834a4cd7f052d778a39b6e620", + "size": 304633, + "subdir": "linux-64", + "timestamp": 1512057516672, + "version": "2.4.9" + }, + "openpyxl-2.4.9-py36hb5dfbf6_0.tar.bz2": { + "build": "py36hb5dfbf6_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6fe4011c36881fc63e7a7f305c696b9", + "name": "openpyxl", + "sha256": "c3dbde402286802ca12cfd807a16bfea2b8f0d8e98ab7529f6bf36cf5b771464", + "size": 304227, + "subdir": "linux-64", + "timestamp": 1512057528614, + "version": "2.4.9" + }, + "openpyxl-2.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd8c6090c101e6c6a113b57fbe52d4b7", + "name": "openpyxl", + "sha256": "402ddb5854e01b69c9282a23f094b4757a758de49e89a5e21d84793aba3f320f", + "size": 321678, + "subdir": "linux-64", + "timestamp": 1519151867854, + "version": "2.5.0" + }, + "openpyxl-2.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "081a50b3fd32094db598cb5af38c45e7", + "name": "openpyxl", + "sha256": "8c99517083df4f0edc92adc6f72ecb775f7275bf660d6de70387c32584f73bb5", + "size": 326506, + "subdir": "linux-64", + "timestamp": 1519151909957, + "version": "2.5.0" + }, + "openpyxl-2.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "44061ad748168b6126c77f0acfa60b46", + "name": "openpyxl", + "sha256": "6b2e84f04c8ee151fb00cb137ffd2c4dc1c001835898bcb4135efb552ecb05b0", + "size": 327186, + "subdir": "linux-64", + "timestamp": 1519151868129, + "version": "2.5.0" + }, + "openpyxl-2.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f652461cba793113cafc60a0ae6f641c", + "name": "openpyxl", + "sha256": "f70216209a38b8c80bd295f32c0495670d534d69654e46d130ad19dbc4531aba", + "size": 322187, + "subdir": "linux-64", + "timestamp": 1521568256821, + "version": "2.5.1" + }, + "openpyxl-2.5.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66b4764f4efa0fa1db3804daedbbd893", + "name": "openpyxl", + "sha256": "ec781155150143593db01fc75c1959321a0e1993c9be61d4bbb2efda202c9683", + "size": 327046, + "subdir": "linux-64", + "timestamp": 1521568376572, + "version": "2.5.1" + }, + "openpyxl-2.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "342b357c96623c9cc11179f282c27c4c", + "name": "openpyxl", + "sha256": "fe3b78f26195a811d10bb4ddb19e10dde55002c6726f987f10f884b980deb273", + "size": 326917, + "subdir": "linux-64", + "timestamp": 1521568377110, + "version": "2.5.1" + }, + "openpyxl-2.5.11-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "82c440ad40bd503bea7ccbf60238d286", + "name": "openpyxl", + "sha256": "d75c5d5fe621f09e606641864ecc73f7f56058420b74ea235466e5ba1b806ed7", + "size": 349256, + "subdir": "linux-64", + "timestamp": 1543601685454, + "version": "2.5.11" + }, + "openpyxl-2.5.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd218ceb6631ef17e2ae577f94542b28", + "name": "openpyxl", + "sha256": "dd9672d510e12acba1578a9a803a84c46909d6db21d29f63ff6aba803bedc2be", + "size": 347911, + "subdir": "linux-64", + "timestamp": 1543601703430, + "version": "2.5.11" + }, + "openpyxl-2.5.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23e287d56df6c00f4c5d077deae78580", + "name": "openpyxl", + "sha256": "64328bf98afbbf24fe4fc9b2202ee114907053261544bd7628db3e2495b9135e", + "size": 346981, + "subdir": "linux-64", + "timestamp": 1543601689696, + "version": "2.5.11" + }, + "openpyxl-2.5.12-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dac66c35588cf44e8c9e7df0bb8ca5b2", + "name": "openpyxl", + "sha256": "6b512ef9a26ddb3e0f43e623deee9973a6182cacc66d700a5b94aadfb74e50e8", + "size": 345737, + "subdir": "linux-64", + "timestamp": 1545076401837, + "version": "2.5.12" + }, + "openpyxl-2.5.12-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad917110e093e414b35d0233036c2805", + "name": "openpyxl", + "sha256": "ba837febdc39efbd520a41aa0463ca0faadb6c5fa65ed4ee617fc52a7a4e4fca", + "size": 345425, + "subdir": "linux-64", + "timestamp": 1545076430836, + "version": "2.5.12" + }, + "openpyxl-2.5.12-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31f98fafc0fc0651c550b3980297e686", + "name": "openpyxl", + "sha256": "bfeb696b1218f58e438059d6bf9dcf9b6a5d8901a8b1bbd709a7c751e87de358", + "size": 345693, + "subdir": "linux-64", + "timestamp": 1545076434860, + "version": "2.5.12" + }, + "openpyxl-2.5.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "661adc0cab5128987c2e63bc7876bcca", + "name": "openpyxl", + "sha256": "428315291f644a7bd18fcfa2d93c89509e03841044436586dd210431c579335c", + "size": 324010, + "subdir": "linux-64", + "timestamp": 1523291597403, + "version": "2.5.2" + }, + "openpyxl-2.5.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "680d519dcd817ed452adbc15d1c66293", + "name": "openpyxl", + "sha256": "fe126fd7a05cad99efbede4c394a67d7208f56eb99a3845db999e100b3ff30b4", + "size": 329345, + "subdir": "linux-64", + "timestamp": 1523291616242, + "version": "2.5.2" + }, + "openpyxl-2.5.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "985149c81f08fab8ad92046059aca77e", + "name": "openpyxl", + "sha256": "e677e3d469b32a3955725d823c063583b00f501d14aa9d2fb24d1308b7d46787", + "size": 329365, + "subdir": "linux-64", + "timestamp": 1523291623719, + "version": "2.5.2" + }, + "openpyxl-2.5.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5aeae84e56f320566d9496f11dd074fb", + "name": "openpyxl", + "sha256": "c38f414b3be41ef8a11225572c24e310572f3c94c926235b38c0b559de3240a8", + "size": 323881, + "subdir": "linux-64", + "timestamp": 1524229244641, + "version": "2.5.3" + }, + "openpyxl-2.5.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5faa9f436603dae51fd8abaa1d5f2126", + "name": "openpyxl", + "sha256": "af46b6b7d90fb67585e4d311183fa1cfd088aefb1668fbf73a2e8757828db42f", + "size": 328533, + "subdir": "linux-64", + "timestamp": 1524229292445, + "version": "2.5.3" + }, + "openpyxl-2.5.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "28c3d456e1056b06fd75c67f4fc5b8f9", + "name": "openpyxl", + "sha256": "04bff6095f9fc845725ba5cc4fc084f1130e1deda15483172de8532758d00d3d", + "size": 329498, + "subdir": "linux-64", + "timestamp": 1524229284409, + "version": "2.5.3" + }, + "openpyxl-2.5.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9f2b2a722d2227e20cd2fdfbfc40955", + "name": "openpyxl", + "sha256": "129bc5d552bf272a7f738b11c6c684ed7c9d7be60a89b0da11bd3f035a7bbaa4", + "size": 324988, + "subdir": "linux-64", + "timestamp": 1528907433508, + "version": "2.5.4" + }, + "openpyxl-2.5.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49507421fbef55c6d61952f65e653f79", + "name": "openpyxl", + "sha256": "427e204190cf71b8e155176e2b06fb750dc62b03e62dbfcfdce60babe3e4d5a7", + "size": 329994, + "subdir": "linux-64", + "timestamp": 1528907473191, + "version": "2.5.4" + }, + "openpyxl-2.5.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "29801d345e72899e629514335b54d387", + "name": "openpyxl", + "sha256": "9506e0e52b5c403e89dc7f676eea847289088545485053f700470021fc38bdb1", + "size": 329872, + "subdir": "linux-64", + "timestamp": 1528907421082, + "version": "2.5.4" + }, + "openpyxl-2.5.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9becce4d197af586fe7b7a93558bd8c", + "name": "openpyxl", + "sha256": "f422933239fffaf5ea0548dacbab7411ad43987989502deaee22cd215a2d14ab", + "size": 328398, + "subdir": "linux-64", + "timestamp": 1530736092680, + "version": "2.5.4" + }, + "openpyxl-2.5.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "75984de2885da2f34ec0b36b08f39d55", + "name": "openpyxl", + "sha256": "0d3af81d194c049992f966dac7eddae9ab9d600af908855eb1dda8b3ddc43303", + "size": 334569, + "subdir": "linux-64", + "timestamp": 1533750994215, + "version": "2.5.5" + }, + "openpyxl-2.5.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "484b4c5bb8a600d5cb8f1f6142e50ac7", + "name": "openpyxl", + "sha256": "f65c599ca9b8b232d2f7b09375fac1e7d91c4c80455d0c9a8c6e97c1c1e10bb7", + "size": 334620, + "subdir": "linux-64", + "timestamp": 1533751032438, + "version": "2.5.5" + }, + "openpyxl-2.5.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4272bd2352311a6341eade49a1cd7f29", + "name": "openpyxl", + "sha256": "8a6e665ee6cff5db01f02295ef37f4df3257db69108adf189f61c01bc2e8a365", + "size": 334964, + "subdir": "linux-64", + "timestamp": 1533750984811, + "version": "2.5.5" + }, + "openpyxl-2.5.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b257b3e946f8ab8aafb51c81e2bea629", + "name": "openpyxl", + "sha256": "6f175dd5c49076e6cf80d4968609762bdcd3a89a49e1510465c6eecae735d4da", + "size": 332477, + "subdir": "linux-64", + "timestamp": 1533750963943, + "version": "2.5.5" + }, + "openpyxl-2.5.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01b7fdf2dea2b2870cf64c43895148d8", + "name": "openpyxl", + "sha256": "8cf539735227cc19c1501ceaf8126aa1feb9cabc0904d1eb3d06ffba0345e708", + "size": 338963, + "subdir": "linux-64", + "timestamp": 1536078441351, + "version": "2.5.6" + }, + "openpyxl-2.5.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "373c30cd51a53d880bffa45a08d83c3a", + "name": "openpyxl", + "sha256": "1203dd0a7cc8c3754dbf8347b32d33f96046b257ca910bdf3fd232e5b2e43c99", + "size": 339142, + "subdir": "linux-64", + "timestamp": 1536078461422, + "version": "2.5.6" + }, + "openpyxl-2.5.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "055318fe9f009067938e800cf7157fd9", + "name": "openpyxl", + "sha256": "b78f39d77bcc107a2c71ccd346f1ff1cc8f9621655de57be10269c94ff944ed4", + "size": 337971, + "subdir": "linux-64", + "timestamp": 1536078396678, + "version": "2.5.6" + }, + "openpyxl-2.5.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1219d567b42560244307a1034f036f13", + "name": "openpyxl", + "sha256": "c3ee7ae66321e0389c2661989dda73d9bb58c7ed224ae473c30254704ef00f6a", + "size": 337140, + "subdir": "linux-64", + "timestamp": 1536078471901, + "version": "2.5.6" + }, + "openpyxl-2.5.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ee578add8629d480d378724aa22205a", + "name": "openpyxl", + "sha256": "7c78b6ad8ac36e21accc158dcc710094c34bd0a8c70fc8ca6de7cc93e5987a4e", + "size": 346133, + "subdir": "linux-64", + "timestamp": 1538160093858, + "version": "2.5.8" + }, + "openpyxl-2.5.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e7d9790756e35328a9b9696f2423674", + "name": "openpyxl", + "sha256": "558a01222a2ab63cf3203027aa9fda78558d75ba78450500f0b2194421776540", + "size": 345471, + "subdir": "linux-64", + "timestamp": 1538160118163, + "version": "2.5.8" + }, + "openpyxl-2.5.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "051be9ebb3aa23fba2f3b5cc3951a0d5", + "name": "openpyxl", + "sha256": "d374219056f7f4b3b3a37a65569985f0bf1bee918cef13e90852a93a1eadb01d", + "size": 343413, + "subdir": "linux-64", + "timestamp": 1538160095530, + "version": "2.5.8" + }, + "openpyxl-2.5.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2a11b943ff2d36aca143f783bc454b8e", + "name": "openpyxl", + "sha256": "38912fdd83cd225a439ddfef8caa460880ef8e10027a49d06d9cd31c55e35e5c", + "size": 346652, + "subdir": "linux-64", + "timestamp": 1540234630662, + "version": "2.5.9" + }, + "openpyxl-2.5.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5569b689153a4244236221808f185a64", + "name": "openpyxl", + "sha256": "b51a2d7ff483783e195acb743ff4a482fe3f68c627c866e166928366aa86f324", + "size": 346306, + "subdir": "linux-64", + "timestamp": 1540234652147, + "version": "2.5.9" + }, + "openpyxl-2.5.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bcd7712e2b273e6dff1a062a25451c30", + "name": "openpyxl", + "sha256": "83b8da38e6f3dd42a8cf06dfdeffa6338a49080664de1d764cb8d714cf83092c", + "size": 344488, + "subdir": "linux-64", + "timestamp": 1540234660102, + "version": "2.5.9" + }, + "openpyxl-2.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8d822ec0330da1c24c825012f80ee19", + "name": "openpyxl", + "sha256": "e4e0a8cd2e3e67e13548fe453f886a12684b8b807b549cc4803c55f489158c6f", + "size": 351765, + "subdir": "linux-64", + "timestamp": 1550350185615, + "version": "2.6.0" + }, + "openpyxl-2.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef37fd6c4f7d881e87988523a6c517fd", + "name": "openpyxl", + "sha256": "1379cb678d980eb6c1fc388c2de082e6e85ee811646370f4a593a3fb71e4e418", + "size": 349187, + "subdir": "linux-64", + "timestamp": 1550350192342, + "version": "2.6.0" + }, + "openpyxl-2.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f73f4f18908a32c2ab02f25c73b7361", + "name": "openpyxl", + "sha256": "df03801f1f58ec470c3755d803529261e1882af38710bad0036611291df05043", + "size": 348649, + "subdir": "linux-64", + "timestamp": 1550350128637, + "version": "2.6.0" + }, + "openpyxl-2.6.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3dfb70af4c6abf2c9c20652928b2b422", + "name": "openpyxl", + "sha256": "421f86a127e68ca68aea724a893f1253c82639d1385345c80bb3cc3eb459a38d", + "size": 352657, + "subdir": "linux-64", + "timestamp": 1553289356750, + "version": "2.6.1" + }, + "openpyxl-2.6.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aaf89ffc43b8c7802a018b3cd3477b05", + "name": "openpyxl", + "sha256": "21d939210aa455203bf13a3f355dce739cb19922ede14e2b3cb7fbf523438b36", + "size": 351620, + "subdir": "linux-64", + "timestamp": 1553289474048, + "version": "2.6.1" + }, + "openpyxl-2.6.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23de7694ea3459b34487f9eb6c10db22", + "name": "openpyxl", + "sha256": "929e12e229119f471aa8d0cd3418f42572e61d4988ba3e7f2f9ed9fd8437e211", + "size": 350094, + "subdir": "linux-64", + "timestamp": 1553289247402, + "version": "2.6.1" + }, + "openpyxl-3.0.10-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12c1475d2d0572c8f376324a3ca140a1", + "name": "openpyxl", + "sha256": "a2db8ccc6dcb7151db046dc9d1b4d1e56323d944e06a85d9fe01bbaddabbe2dc", + "size": 1465595, + "subdir": "linux-64", + "timestamp": 1657175766078, + "version": "3.0.10" + }, + "openpyxl-3.0.10-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5c8277aaccd4711ce63dc32c0cbfc1c", + "name": "openpyxl", + "sha256": "c99649ed84361d4c0f5d4e25626ceeb8dc04439e638f3950e7995e734e4da715", + "size": 680090, + "subdir": "linux-64", + "timestamp": 1676841431143, + "version": "3.0.10" + }, + "openpyxl-3.0.10-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71c2ab2f1aa99ca82f6a24604141796e", + "name": "openpyxl", + "sha256": "f060a149da1ea7e74f8870975dfbb16dcf498e4d8e06ab2b8ac059b010bb68cc", + "size": 564508, + "subdir": "linux-64", + "timestamp": 1657175708597, + "version": "3.0.10" + }, + "openpyxl-3.0.10-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d28042a83b833f66f465a0c03791e3fa", + "name": "openpyxl", + "sha256": "dabde4348e30497fd40d6edc4d69a5033e858e041a987d3478362377d5ba8fb4", + "size": 580370, + "subdir": "linux-64", + "timestamp": 1657175662545, + "version": "3.0.10" + }, + "openpyxl-3.0.10-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13ca0f46e1721fa3cb1e2a69f523300f", + "name": "openpyxl", + "sha256": "5ad1ded727ac813d62ee6b0358ecd292b6592bfbc14437014818c088b2e82522", + "size": 575038, + "subdir": "linux-64", + "timestamp": 1657175616466, + "version": "3.0.10" + }, + "openresty-1.13.6.2-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "luajit", + "openssl >=1.1.1a,<1.1.2a", + "pcre >=8.42,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "multiple", + "md5": "4d61e8fc84a986e459a856f3dee7653a", + "name": "openresty", + "sha256": "bc6bb8fe2ad7bd4de00ee368f2c195697a0e0431d63ab1fbce503fb0c42cb75c", + "size": 2763257, + "subdir": "linux-64", + "timestamp": 1545963349735, + "version": "1.13.6.2" + }, + "openresty-1.15.8.3-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "f403364a5025a286e2b446b2ca5ae057", + "name": "openresty", + "sha256": "3556ea823a649a8f087a8019a21338d0a20c442562b20bf44f7789988a7b18e7", + "size": 5877844, + "subdir": "linux-64", + "timestamp": 1599153184266, + "version": "1.15.8.3" + }, + "openresty-1.15.8.3-h20c2e04_1.tar.bz2": { + "build": "h20c2e04_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "910e958d4cb4587f3c5c42e8b3bb02dd", + "name": "openresty", + "sha256": "dc0ff76aa78962a570fd13fea0d8b2cf767b68da2fa0bf50a3733cf5cc2b00ff", + "size": 5873492, + "subdir": "linux-64", + "timestamp": 1599603324250, + "version": "1.15.8.3" + }, + "openresty-1.17.8.1-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "b1ac1e007f2de3d0108ea9d65fe0b027", + "name": "openresty", + "sha256": "8921dc126183c54972fd5af309d7e965dfab2da6b0b554fde9490f2dff052e0f", + "size": 5894829, + "subdir": "linux-64", + "timestamp": 1599847694434, + "version": "1.17.8.1" + }, + "openresty-1.17.8.2-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "7e602ecd1503cd916b77b2a3621dfd7e", + "name": "openresty", + "sha256": "57b3c63caa19f26c9cc90e7c6bc2dbb8bd2faf3646f0d9394f8f55a7bb10d381", + "size": 5882754, + "subdir": "linux-64", + "timestamp": 1600481598300, + "version": "1.17.8.2" + }, + "openresty-1.19.3.1-h303737a_0.tar.bz2": { + "build": "h303737a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "54eef358bc747b599573a1c6e88fedd9", + "name": "openresty", + "sha256": "33ff7ae926a5097011e2bcad64ec81ea31f63228790edbb2fc14e7deb1734088", + "size": 5982200, + "subdir": "linux-64", + "timestamp": 1605119113461, + "version": "1.19.3.1" + }, + "openresty-1.19.9.1-h0b77cf5_0.tar.bz2": { + "build": "h0b77cf5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openssl >=1.1.1k,<1.1.2a", + "pcre >=8.45,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "c782379235bb5c16d3ee572dfd70221b", + "name": "openresty", + "sha256": "1cb28f692243c15c5b0a726bb8b13b5f925e9e8b22d4230a8406595fadfdcb1f", + "size": 6010071, + "subdir": "linux-64", + "timestamp": 1629117052298, + "version": "1.19.9.1" + }, + "openssl-1.0.2l-h077ae2c_5.tar.bz2": { + "build": "h077ae2c_5", + "build_number": 5, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "b0b90d5c91399533c84a40c14bc44759", + "name": "openssl", + "sha256": "d81c895bc78c20930a85e25efc073d176adf69175ee91b31b7852b79275b8adf", + "size": 3592798, + "subdir": "linux-64", + "timestamp": 1508174907958, + "version": "1.0.2l" + }, + "openssl-1.0.2l-h9d1a558_3.tar.bz2": { + "build": "h9d1a558_3", + "build_number": 3, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "6a50e77df5f26802b5fbcd0b216e4702", + "name": "openssl", + "sha256": "6db2e5812e3d9873f45d2492ad0a9651e5c4890650e1540e3eaf9aedfb9d581b", + "size": 3592154, + "subdir": "linux-64", + "timestamp": 1505862551189, + "version": "1.0.2l" + }, + "openssl-1.0.2l-hd940f6d_1.tar.bz2": { + "build": "hd940f6d_1", + "build_number": 1, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "e608fd3f0add65ba0c9ef83c10b1727a", + "name": "openssl", + "sha256": "6202a1a78d45f8455c7f5b3c26c256283a9934bded0493e4f69dbb2c0240ceff", + "size": 3593553, + "subdir": "linux-64", + "timestamp": 1505666977729, + "version": "1.0.2l" + }, + "openssl-1.0.2m-h26d622b_1.tar.bz2": { + "build": "h26d622b_1", + "build_number": 1, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "b895cfbc4f4b884c4047cc97e31b7f85", + "name": "openssl", + "sha256": "b6e8169b117d333b77223036439994b184b86764d4926e219ca1ffbad78a14dc", + "size": 3609526, + "subdir": "linux-64", + "timestamp": 1510610580577, + "version": "1.0.2m" + }, + "openssl-1.0.2m-h8cfc7e7_0.tar.bz2": { + "build": "h8cfc7e7_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "3f4a898b7df0544b872e733ae04253a0", + "name": "openssl", + "sha256": "dc70272a06c778eef39cd8118a5320ae2b2834858e6cb7d9c0b21e247d18b7e6", + "size": 3609383, + "subdir": "linux-64", + "timestamp": 1509743095949, + "version": "1.0.2m" + }, + "openssl-1.0.2n-hb7f436b_0.tar.bz2": { + "build": "hb7f436b_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "619bae6d962df790328928db81fbafc8", + "name": "openssl", + "sha256": "df92dc48c51931c9c44cdb7de392541f19563507272a103a5d3729bb0ec5e513", + "size": 3612059, + "subdir": "linux-64", + "timestamp": 1512662607716, + "version": "1.0.2n" + }, + "openssl-1.0.2o-h14c3975_1.tar.bz2": { + "build": "h14c3975_1", + "build_number": 1, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "12681d45bb6b7cc57c7b19631f7a665f", + "name": "openssl", + "sha256": "10dedca850dc65242fcdc9c07e7cb1ec24d0ed5da5262ec394ff73e19b93cf9e", + "size": 3611346, + "subdir": "linux-64", + "timestamp": 1533231765655, + "version": "1.0.2o" + }, + "openssl-1.0.2o-h20670df_0.tar.bz2": { + "build": "h20670df_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "200d7c017fc7eba894f0d6ddaa3174c8", + "name": "openssl", + "sha256": "9fa39e40343b26301b6455754c35f1b0eabc7f4751963200bf91cd7aef247300", + "size": 3610760, + "subdir": "linux-64", + "timestamp": 1522162879001, + "version": "1.0.2o" + }, + "openssl-1.0.2p-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "a8c786dd6f250cea5c273afd78ac426a", + "name": "openssl", + "sha256": "6bdea200151c2c0af00404d30605525ffccd3a71d34e2fdc0f2bd2cd3f5d96d9", + "size": 3619073, + "subdir": "linux-64", + "timestamp": 1534253690735, + "version": "1.0.2p" + }, + "openssl-1.0.2q-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "f54dea10faf04a6be2cc2db43b63f855", + "name": "openssl", + "sha256": "ee12884cab995605a332321183fc3b3f15905d8a62ad48d6ec1df654c034955d", + "size": 3307551, + "subdir": "linux-64", + "timestamp": 1551219164928, + "version": "1.0.2q" + }, + "openssl-1.0.2r-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "3a801e2bdbc7c71a319c8e35fc822c8c", + "name": "openssl", + "sha256": "c2c801680ccdfe1999b489fbac94181af59e8b4ca33576daf102ccdf502cc7d4", + "size": 3310155, + "subdir": "linux-64", + "timestamp": 1551220820214, + "version": "1.0.2r" + }, + "openssl-1.0.2s-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "adeab64e5c2b2acfac50cfb697d4d3a8", + "name": "openssl", + "sha256": "1aa125f17e5720514efee5f5a0c4c7c4962331f10a5817175110620b0551917d", + "size": 3292304, + "subdir": "linux-64", + "timestamp": 1559070442483, + "version": "1.0.2s" + }, + "openssl-1.0.2t-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "c7b21989501312d1d62ceb13e960db1a", + "name": "openssl", + "sha256": "bd875b79a3dc063643e79747fca9eae6abb07b4d8d7eaede6c55b58bbfd1c382", + "size": 3716278, + "subdir": "linux-64", + "timestamp": 1568211667259, + "version": "1.0.2t" + }, + "openssl-1.0.2t-h7b6447c_1.tar.bz2": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "a19cca9ec3306d7461e3a12b3372fd11", + "name": "openssl", + "sha256": "93ae11606b65d8ccf8716e62ff12a7d2ac34078185d9bf02d0db2c235aed223b", + "size": 3297718, + "subdir": "linux-64", + "timestamp": 1568298632304, + "version": "1.0.2t" + }, + "openssl-1.0.2u-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "30742f1123554cd0925aaef2793f23f4", + "name": "openssl", + "sha256": "5aae81e8618986b37a2d0e79ec2378a534e03b7880273e8cd3f01436923d9c06", + "size": 3300349, + "subdir": "linux-64", + "timestamp": 1576852237184, + "version": "1.0.2u" + }, + "openssl-1.1.1a-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "4cd3d8b9ee3d0da9ded05d0c2dd3767f", + "name": "openssl", + "sha256": "2c95e75a1cd069216186757b10779622e34873a448744693641fc959a4502af5", + "size": 5279598, + "subdir": "linux-64", + "timestamp": 1542740345038, + "version": "1.1.1a" + }, + "openssl-1.1.1b-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "32981897e86c7ad819d29d03d4216de0", + "name": "openssl", + "sha256": "cea9957e2e623ce7a9889230c50933fd172920a7494b2c99c6639a010254ec18", + "size": 4161536, + "subdir": "linux-64", + "timestamp": 1551214768361, + "version": "1.1.1b" + }, + "openssl-1.1.1b-h7b6447c_1.tar.bz2": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "6124a2c7ec4fa5a6502fb02345b49a55", + "name": "openssl", + "sha256": "b3e72f5a41798d610d740a2814b1a7c5dda454c68e320bfcfc1e05d768852591", + "size": 4160471, + "subdir": "linux-64", + "timestamp": 1551973352851, + "version": "1.1.1b" + }, + "openssl-1.1.1c-h7b6447c_1.tar.bz2": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "87dd7a5f8b4174c1456e4851d3faecf4", + "name": "openssl", + "sha256": "d504aec07a6864c1eb6fd8209adf8e16419a68db6de8116a6179fe4bcd475e48", + "size": 3974121, + "subdir": "linux-64", + "timestamp": 1559152830804, + "version": "1.1.1c" + }, + "openssl-1.1.1d-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "fb2fd32dad51359235e4fff3e1d1385a", + "name": "openssl", + "sha256": "12528e064f0420ca5e55a42f8a5c26b8fbf0556c5bf359071ce2b382fbd84d7d", + "size": 3911642, + "subdir": "linux-64", + "timestamp": 1568192113265, + "version": "1.1.1d" + }, + "openssl-1.1.1d-h7b6447c_1.tar.bz2": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "0b87c8422cfc57e8c4b27d72feb425a3", + "name": "openssl", + "sha256": "d5a5d63f08af12076288ea16556d9b768094ff574ea306b6f75969d82cf3ef7d", + "size": 3926232, + "subdir": "linux-64", + "timestamp": 1568287441501, + "version": "1.1.1d" + }, + "openssl-1.1.1d-h7b6447c_2.tar.bz2": { + "build": "h7b6447c_2", + "build_number": 2, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "2fd6ddb904f8838a8b84a65cdf25adf7", + "name": "openssl", + "sha256": "8b18731fec35c4838bcfccfde61eb4c7f0e54619f266430bb0b5d52db169155a", + "size": 3919183, + "subdir": "linux-64", + "timestamp": 1569594008754, + "version": "1.1.1d" + }, + "openssl-1.1.1d-h7b6447c_3.tar.bz2": { + "build": "h7b6447c_3", + "build_number": 3, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "43fcce0c54c9f401ea7eb814c4483e46", + "name": "openssl", + "sha256": "faceb4fecd07a79af6a2c03540337dbe3b02a4b24776b09306808c7032367368", + "size": 3916133, + "subdir": "linux-64", + "timestamp": 1571239236113, + "version": "1.1.1d" + }, + "openssl-1.1.1d-h7b6447c_4.tar.bz2": { + "build": "h7b6447c_4", + "build_number": 4, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "c9ba30858153e243b46bc8ade5a6e53a", + "name": "openssl", + "sha256": "e3262afbf5d419d3bea3b558bd0dc50ceeec570686c1724494241137c7d8d705", + "size": 3928607, + "subdir": "linux-64", + "timestamp": 1581354302002, + "version": "1.1.1d" + }, + "openssl-1.1.1e-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "0792eb4906c7487134835feca10bd76a", + "name": "openssl", + "sha256": "bc44ce2e6a1b3aeef2ccf26830d5c873ae14cb52b87f8fddc4e83f5aac011f21", + "size": 3972430, + "subdir": "linux-64", + "timestamp": 1584465134548, + "version": "1.1.1e" + }, + "openssl-1.1.1f-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "bb2b5c441c97030b9e7e4dd12cc1c533", + "name": "openssl", + "sha256": "2b1ecd7da18d28c6d4da696bbb3322f2f10e862e1be4ac0599be1c0802b6b9ff", + "size": 3997547, + "subdir": "linux-64", + "timestamp": 1585661946070, + "version": "1.1.1f" + }, + "openssl-1.1.1g-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "c6c1c43a0d45b83aa31a4f3a2d7839bd", + "name": "openssl", + "sha256": "c7b6be1d54c75962e3398925fb8f6c151f6ffd86b0b14ae9786aeb51b82eb5fe", + "size": 3975903, + "subdir": "linux-64", + "timestamp": 1587477157134, + "version": "1.1.1g" + }, + "openssl-1.1.1h-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "4602410a1a538cb0e3a2dff8d9fecfca", + "name": "openssl", + "sha256": "1ac49bea6400ea9585b0e0f35c3c52557ef4866e3a9bc8dd4ffc0c725b3666f0", + "size": 3993621, + "subdir": "linux-64", + "timestamp": 1600781555948, + "version": "1.1.1h" + }, + "openssl-1.1.1i-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "bc3f2ecaede01ae47cc87365f88fbe2c", + "name": "openssl", + "sha256": "fb096eab67c82ba3951e43ca9fbbe96375c629403886e585ad820a56a688a020", + "size": 3986642, + "subdir": "linux-64", + "timestamp": 1607536520614, + "version": "1.1.1i" + }, + "openssl-1.1.1j-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "487b112f7780e8b541f96b5ad7c840c3", + "name": "openssl", + "sha256": "ce6b19da3781eed27c92e71d537ddcb38aed777ab87d501518765ef7b84bd332", + "size": 4014200, + "subdir": "linux-64", + "timestamp": 1613667958104, + "version": "1.1.1j" + }, + "openssl-1.1.1k-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "ce1162e605898e7d6a69e025a26f7706", + "name": "openssl", + "sha256": "e52e5211a21d2728b55a8883f6725fafb5e331aaf4953b276e795461aeb2853b", + "size": 3981587, + "subdir": "linux-64", + "timestamp": 1616684152302, + "version": "1.1.1k" + }, + "openssl-1.1.1l-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.5.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "991c8f07775e59c214a21a776fb9ed94", + "name": "openssl", + "sha256": "5c9e375ad2b112684810f554845d8f8efdb46c70b445d486750e7f9c7960ba52", + "size": 3982804, + "subdir": "linux-64", + "timestamp": 1630591938970, + "version": "1.1.1l" + }, + "openssl-1.1.1m-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.5.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "9c1695b8dd0befbf13df3a0f88aba4b1", + "name": "openssl", + "sha256": "4941c013c6d384d1c4c52eca7f7f0ea0d57631ae0a585680b065fd7da42904b6", + "size": 3989621, + "subdir": "linux-64", + "timestamp": 1641962265267, + "version": "1.1.1m" + }, + "openssl-1.1.1n-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.5.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "047bdb92ae3c222578c3cf8e947ab92b", + "name": "openssl", + "sha256": "c266560d495394b38009214748e7195baadaa4d0dd8ddc98101b38363dbe2195", + "size": 3988856, + "subdir": "linux-64", + "timestamp": 1647850792453, + "version": "1.1.1n" + }, + "openssl-1.1.1o-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.5.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "f883a656f558e3aab32bc3630d93c708", + "name": "openssl", + "sha256": "26f362d6660387a99381729896758afe4bb2c68f4eed80dfb2fe574b13574275", + "size": 3969265, + "subdir": "linux-64", + "timestamp": 1652103194742, + "version": "1.1.1o" + }, + "openssl-1.1.1p-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=11.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "8e582e42aa13ee981d628db632d110e4", + "name": "openssl", + "sha256": "6f10cba4b4d9ae171d72eaaf522e5cd988b0a5005c8c23293b314dfd77dcbf15", + "size": 3962933, + "subdir": "linux-64", + "timestamp": 1656430278347, + "version": "1.1.1p" + }, + "openssl-1.1.1q-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.5.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "ad51928702694e3f6d25b7d4229c84e6", + "name": "openssl", + "sha256": "47eeba70c814116a5284eadf5caa1e0bb20a43798176b1226d571aa649181655", + "size": 3981589, + "subdir": "linux-64", + "timestamp": 1657551292835, + "version": "1.1.1q" + }, + "openssl-1.1.1s-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.5.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "2c7c8f2e5325a18c8c9ea7c9d7663792", + "name": "openssl", + "sha256": "049a4d5e9216e722aa7da431b81219eb726adb8ba641dd5acdaeef794bdcfd94", + "size": 3989932, + "subdir": "linux-64", + "timestamp": 1667573681602, + "version": "1.1.1s" + }, + "openssl-1.1.1t-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.5.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "7a71a3732182a38f5685e63733584a67", + "name": "openssl", + "sha256": "ec2e3b582083ccedde007cc8e128e47e1e9efec0f1acb49e3479175e2cb17cc6", + "size": 3983794, + "subdir": "linux-64", + "timestamp": 1676330616325, + "version": "1.1.1t" + }, + "opentracing-1.2.2-py27he997089_0.tar.bz2": { + "build": "py27he997089_0", + "build_number": 0, + "depends": [ + "futures", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c528221b09f172675fb27e92db0847ed", + "name": "opentracing", + "sha256": "2d7d4d920c169af8d165f462758f021131d27bf0a552d661b9d98677c7a5d3b6", + "size": 19306, + "subdir": "linux-64", + "timestamp": 1507653757575, + "version": "1.2.2" + }, + "opentracing-1.2.2-py35hce244ff_0.tar.bz2": { + "build": "py35hce244ff_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa888a1997db6b6f0ca8b5a59c7b97e2", + "name": "opentracing", + "sha256": "2a9f8bf30baf48c1a01173a0215bd00d482c610badf3dff23e2301f3752cabf8", + "size": 19687, + "subdir": "linux-64", + "timestamp": 1507653786061, + "version": "1.2.2" + }, + "opentracing-1.2.2-py36hee76fbe_0.tar.bz2": { + "build": "py36hee76fbe_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16b8b8ecc0f106fa8b90f75c80c18d96", + "name": "opentracing", + "sha256": "549442b0815e94003fdefcad19d56a652f667c0572f615280a75831140d4db07", + "size": 19712, + "subdir": "linux-64", + "timestamp": 1507653788827, + "version": "1.2.2" + }, + "opentracing-1.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "29a42ba727817b8ca150fde2dd817869", + "name": "opentracing", + "sha256": "8802ff090795367c491c91a1cd91ce89af07928ad1f81dc81acc64fa85bb793c", + "size": 21628, + "subdir": "linux-64", + "timestamp": 1519152830083, + "version": "1.3.0" + }, + "opentracing-1.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c424de697ad6e86a907d536188502af2", + "name": "opentracing", + "sha256": "d9f71c9425ce9015343c8d5805bbafda9560aeeead83df2a9f56b5c06eec851e", + "size": 21987, + "subdir": "linux-64", + "timestamp": 1519152858937, + "version": "1.3.0" + }, + "opentracing-1.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4efda3e4293a1504e2393bb0c4180041", + "name": "opentracing", + "sha256": "02a13c27e505bc5fe9ceaf0babec1b1826d7cb04339d0d9ef64bedbdf7051b8d", + "size": 21985, + "subdir": "linux-64", + "timestamp": 1519152798757, + "version": "1.3.0" + }, + "opentracing-1.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2be46210f8e0fcb5dd75b72ea032f37", + "name": "opentracing", + "sha256": "41e1a050aaec9dc0bacabdf464f4ce77bccbd9dd0ea8cd913a838481953d877c", + "size": 21960, + "subdir": "linux-64", + "timestamp": 1530902329643, + "version": "1.3.0" + }, + "opentracing-2.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e99de90eeaa7c11587be6fa2076491e9", + "name": "opentracing", + "sha256": "b542807ff2897b9a90fd52137c49a0e2ba4755268b8536566a9e544b3d8545e4", + "size": 43715, + "subdir": "linux-64", + "timestamp": 1535427912273, + "version": "2.0.0" + }, + "opentracing-2.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e61306331f416e4f7cf15adcd59cb5ff", + "name": "opentracing", + "sha256": "d07d4f906e08ef256042b20950561bb99320c3dcd8e26bd11ea92b46fef28f9f", + "size": 44909, + "subdir": "linux-64", + "timestamp": 1535428016227, + "version": "2.0.0" + }, + "opentracing-2.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0060bd6e824a776f0cf0ecd0d6bf80f0", + "name": "opentracing", + "sha256": "a03f27a871c9e58cf586494086247bf7cf28caa87d2bb51a27a53c5bcfadbe84", + "size": 44981, + "subdir": "linux-64", + "timestamp": 1535427982502, + "version": "2.0.0" + }, + "opentracing-2.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1bd335112381b347be862cb0c6d8f39d", + "name": "opentracing", + "sha256": "842a586a3dddd8114fcefb91e2011e11c7a147319e0a2aab658741ca675b7ded", + "size": 45046, + "subdir": "linux-64", + "timestamp": 1535427934979, + "version": "2.0.0" + }, + "opentracing-2.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6eb0e796125f2a7d973af1c04e2197b9", + "name": "opentracing", + "sha256": "3b23d4b75991c0eafd72cea7107ef4b2651f0457bbfadcae3e5eb62b1bd81663", + "size": 49891, + "subdir": "linux-64", + "timestamp": 1559058764248, + "version": "2.2.0" + }, + "opentracing-2.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ddb0b20693510bf85c62d452150530c", + "name": "opentracing", + "sha256": "0d7b8caa8bb1bed5abfe3bd6cc49f22cf2b5025b65f0a167ff627fdbeb8a68fb", + "size": 51109, + "subdir": "linux-64", + "timestamp": 1559058730287, + "version": "2.2.0" + }, + "opentracing-2.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a7fb4ba8d0bb48245da19e6c0c2be75", + "name": "opentracing", + "sha256": "1ce0c839caf77cfa0042b10b241209d184eb44325a01b7322490e99bc644eb53", + "size": 51147, + "subdir": "linux-64", + "timestamp": 1559058732890, + "version": "2.2.0" + }, + "opentracing-2.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "03b83cec8690d22d9e21bb8f3a1514a6", + "name": "opentracing", + "sha256": "d71532ad97245ebfb74d716b222ac9d2f35a9d64d6891d7bd5f0e11cf665905d", + "size": 49966, + "subdir": "linux-64", + "timestamp": 1573489421259, + "version": "2.2.0" + }, + "opentracing-2.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9b687e17d1cdc79f9377f2fc2134c53", + "name": "opentracing", + "sha256": "da3b0a346456ccee07cb3fb3643634a17fd17cd23eb6b4f479e45a874117ef83", + "size": 50745, + "subdir": "linux-64", + "timestamp": 1601500374437, + "version": "2.3.0" + }, + "opentracing-2.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8492b06a31bf261019c7f5f14a8d5fbf", + "name": "opentracing", + "sha256": "0a9a9501f7d2f989e764ef5ddf2c493fecdf92d7149b6b1610707513fc9ed174", + "size": 50742, + "subdir": "linux-64", + "timestamp": 1601500392025, + "version": "2.3.0" + }, + "opentracing-2.3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbcba2a5b222a31709a568212d90d78c", + "name": "opentracing", + "sha256": "11f3d313e0ff0cb17e13f41dbc961112ad84fd6401bac9da7e9a14dfa17bed7f", + "size": 51027, + "subdir": "linux-64", + "timestamp": 1601500387552, + "version": "2.3.0" + }, + "opentracing-2.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df32bf3661c6bdad2a96f9b3c6cd4565", + "name": "opentracing", + "sha256": "429e3dc91e3e694068228760fa2c24582b9fb3cac786282a4880a1ef492a777b", + "size": 51396, + "subdir": "linux-64", + "timestamp": 1640792076441, + "version": "2.4.0" + }, + "opentracing-2.4.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a04b7fa77c95aa419c59cd53d525ae2", + "name": "opentracing", + "sha256": "2a1353c32cbc12564a9892e267af452881b2d8484817f9c969fe95608d622943", + "size": 61190, + "subdir": "linux-64", + "timestamp": 1676845084785, + "version": "2.4.0" + }, + "opentracing-2.4.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebb404e890f270acb7fba988b4b0314a", + "name": "opentracing", + "sha256": "f02b09ef0c52346fb4fdf1b722279b2222f46dfc1afc1930ecc3396cfe6bfcc9", + "size": 50831, + "subdir": "linux-64", + "timestamp": 1606154039439, + "version": "2.4.0" + }, + "opentracing-2.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a187c7ed0a0691f6a4d684a5ee3c2314", + "name": "opentracing", + "sha256": "6b062763827c3b89a8493baae2858241607dd4d70ded6765ee4c995467ee61df", + "size": 50964, + "subdir": "linux-64", + "timestamp": 1606154057264, + "version": "2.4.0" + }, + "opentracing-2.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c77e125a2cf5c6d34e0172cadc183ef4", + "name": "opentracing", + "sha256": "5df6c1c299a6d56aa231578fba529cfcabd98f531c00789a53b32ee53863443a", + "size": 51100, + "subdir": "linux-64", + "timestamp": 1606154067433, + "version": "2.4.0" + }, + "opentracing-2.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "38520d0f0053d863274d76a03509f33e", + "name": "opentracing", + "sha256": "a4943b11d52177cc5e8576d020316db030fc07be7c6f60852957da4790ca963c", + "size": 51111, + "subdir": "linux-64", + "timestamp": 1606154039490, + "version": "2.4.0" + }, + "opentracing_instrumentation-2.3.0-py27hd1289c1_0.tar.bz2": { + "build": "py27hd1289c1_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "futures", + "opentracing >=1.1,<1.3", + "python >=2.7,<2.8.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "267f0996d7e6e605943e32ccf931737c", + "name": "opentracing_instrumentation", + "sha256": "35c5297f8905dad7fdf2a42cedfd125d11857bcdc4c22771ee363dcafc292e1f", + "size": 34086, + "subdir": "linux-64", + "timestamp": 1510720292740, + "version": "2.3.0" + }, + "opentracing_instrumentation-2.3.0-py35h1954a9b_0.tar.bz2": { + "build": "py35h1954a9b_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<1.3", + "python >=3.5,<3.6.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd501ec58c6de9061c7762c58e4b687c", + "name": "opentracing_instrumentation", + "sha256": "85236403042ce0c5c0a76a5265b1f612f45499fe9f84ad2ac6606a7f069f7e35", + "size": 35170, + "subdir": "linux-64", + "timestamp": 1510720297498, + "version": "2.3.0" + }, + "opentracing_instrumentation-2.3.0-py36h1c37d0f_0.tar.bz2": { + "build": "py36h1c37d0f_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<1.3", + "python >=3.6,<3.7.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b2bc4ee99696572fd1d3aa3a31b264e", + "name": "opentracing_instrumentation", + "sha256": "a10102a92158264af82ae25a4817a65dce08df87a1f8fcb16cac22a3ac0008d6", + "size": 35080, + "subdir": "linux-64", + "timestamp": 1510720308140, + "version": "2.3.0" + }, + "opentracing_instrumentation-2.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "futures", + "opentracing >=1.1,<1.3", + "python >=2.7,<2.8.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d1fd5f6debe969a76d2e943eb418bf0f", + "name": "opentracing_instrumentation", + "sha256": "27744ccda0b356672f569964a088758d68a4f4a9f32c28f31550564e46345a80", + "size": 34532, + "subdir": "linux-64", + "timestamp": 1519485873094, + "version": "2.4.0" + }, + "opentracing_instrumentation-2.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<1.3", + "python >=3.5,<3.6.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "44ab19ace97c82d8f79e9322749d5c84", + "name": "opentracing_instrumentation", + "sha256": "e1ce6eb7cd50b3aa09a888cad6637a8ebdb159fcda1661c5fcebdee4bebb4ecb", + "size": 35539, + "subdir": "linux-64", + "timestamp": 1519485896266, + "version": "2.4.0" + }, + "opentracing_instrumentation-2.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<1.3", + "python >=3.6,<3.7.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5693d103e89cfb507c312c13985d71e1", + "name": "opentracing_instrumentation", + "sha256": "e04cfc19f6340054acc485ffd0fa5f2143df56a4d8e904139e9bd676075a4f7b", + "size": 35386, + "subdir": "linux-64", + "timestamp": 1519485864780, + "version": "2.4.0" + }, + "opentracing_instrumentation-2.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "futures", + "opentracing >=1.1,<1.3", + "python >=2.7,<2.8.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "575556c058e774036e01dfb7c6db138c", + "name": "opentracing_instrumentation", + "sha256": "6007e6bd08b4f19b56ecd7155bb5d10d44ff701bf64bf2d80ae0e5275f79116e", + "size": 34540, + "subdir": "linux-64", + "timestamp": 1524509922856, + "version": "2.4.1" + }, + "opentracing_instrumentation-2.4.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "contextlib2", + "future", + "futures", + "opentracing >=1.1,<2", + "python >=2.7,<2.8.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12bcef450325f27ce58ac50219e27149", + "name": "opentracing_instrumentation", + "sha256": "bcb27bdb9ef1be5baeba563281091d28189f741da451b8bec33dc4ef0202aad6", + "size": 34421, + "subdir": "linux-64", + "timestamp": 1530902419670, + "version": "2.4.1" + }, + "opentracing_instrumentation-2.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<1.3", + "python >=3.5,<3.6.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f06fb86bddf61d526b5c741c65baea89", + "name": "opentracing_instrumentation", + "sha256": "1ffaaa4836c88b5280beb91fc9bf2a4007487bd927eca79d1247670b660eccf2", + "size": 35527, + "subdir": "linux-64", + "timestamp": 1524509930924, + "version": "2.4.1" + }, + "opentracing_instrumentation-2.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<1.3", + "python >=3.6,<3.7.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d7cf72eac7de4ab83ad1f546ec10b6a2", + "name": "opentracing_instrumentation", + "sha256": "0afef1d010c8b1199b93c99b45b28d8917a7f7681152d65a1ef39c9ce8dfb4ad", + "size": 35443, + "subdir": "linux-64", + "timestamp": 1524509932161, + "version": "2.4.1" + }, + "opentracing_instrumentation-2.4.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<2", + "python >=3.6,<3.7.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51d0d44b579beb8bb017c52f1001e186", + "name": "opentracing_instrumentation", + "sha256": "c245dc67663b75993871782b29b91edae87401b03ba5413a9de2f8664c9b3a53", + "size": 35374, + "subdir": "linux-64", + "timestamp": 1530902390175, + "version": "2.4.1" + }, + "opentracing_instrumentation-2.4.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<2", + "python >=3.7,<3.8.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2aa8ffc5453e5c100c3ebd3f4ba0251f", + "name": "opentracing_instrumentation", + "sha256": "e4ffaacbb9d05c3205133668589e9aba8daa2c3482e887047ef71876be49f77c", + "size": 35379, + "subdir": "linux-64", + "timestamp": 1530902359937, + "version": "2.4.1" + }, + "opentracing_instrumentation-2.4.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<2", + "python >=2.7,<2.8.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1bb6032e26335125542f56b729e53c20", + "name": "opentracing_instrumentation", + "sha256": "ec9283324ecda078ce9ab1b30b3123fd1c3fffde8618315ef0d08283689275cb", + "size": 36099, + "subdir": "linux-64", + "timestamp": 1536110353858, + "version": "2.4.3" + }, + "opentracing_instrumentation-2.4.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<2", + "python >=3.5,<3.6.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e257fd51988b8c3c8908e0deee538060", + "name": "opentracing_instrumentation", + "sha256": "70c4912e8ebb27877408b64c2c5c417127ce1b08f31a706136b98b8d384a496c", + "size": 37127, + "subdir": "linux-64", + "timestamp": 1536110422853, + "version": "2.4.3" + }, + "opentracing_instrumentation-2.4.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<2", + "python >=3.6,<3.7.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d298455a4f8ba221ad97bf1c39e6b56", + "name": "opentracing_instrumentation", + "sha256": "ea77ec971f4e5f69ce41e85fc574babd685c36dfd4e2cd6905f409a17d168176", + "size": 37016, + "subdir": "linux-64", + "timestamp": 1536110328929, + "version": "2.4.3" + }, + "opentracing_instrumentation-2.4.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<2", + "python >=3.7,<3.8.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e64b70760a5f12ee7017b969a9051396", + "name": "opentracing_instrumentation", + "sha256": "6191b1e2eb57a856be48dc50bcf56df67abf23a9c4356cace4939a189d799f75", + "size": 37079, + "subdir": "linux-64", + "timestamp": 1536110406492, + "version": "2.4.3" + }, + "opentracing_instrumentation-3.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "futures", + "opentracing >=2,<3", + "python >=2.7,<2.8.0a0", + "six", + "tornado >=4.1,<5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "429b424694d478039a279127251fef19", + "name": "opentracing_instrumentation", + "sha256": "1014a51cbcee78e6b50b0f48b1dbcd8478fcf897513fce758e8728a3e080913a", + "size": 41068, + "subdir": "linux-64", + "timestamp": 1559921574029, + "version": "3.0.1" + }, + "opentracing_instrumentation-3.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=2,<3", + "python >=3.6,<3.7.0a0", + "six", + "tornado >=4.1,<5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a4e56c15171dfc3068b106e1dd9b36c", + "name": "opentracing_instrumentation", + "sha256": "8bc201e52eaa3f26cc43b99f3840a601727b09d3ff451149106d43bf05ad6014", + "size": 42088, + "subdir": "linux-64", + "timestamp": 1559921567107, + "version": "3.0.1" + }, + "opentracing_instrumentation-3.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=2,<3", + "python >=3.7,<3.8.0a0", + "six", + "tornado >=4.1,<5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e6cf964aaa3a16ee0a125bb7699fa66", + "name": "opentracing_instrumentation", + "sha256": "04721a3eab25923353ab9acf4eac22b565afaaaa863d3f9d390ebd033e4559d6", + "size": 42143, + "subdir": "linux-64", + "timestamp": 1559921556782, + "version": "3.0.1" + }, + "opentracing_instrumentation-3.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "futures", + "opentracing >=2,<3", + "python >=2.7,<2.8.0a0", + "six", + "tornado >=4.1,<5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "27bf97f679863d5a1f359f7b5b1bceee", + "name": "opentracing_instrumentation", + "sha256": "e0e083ddffe16352419f20f523eaf999110767809382c6fa92ca00e2bb921c3f", + "size": 45547, + "subdir": "linux-64", + "timestamp": 1564682602850, + "version": "3.1.1" + }, + "opentracing_instrumentation-3.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=2,<3", + "python >=3.6,<3.7.0a0", + "six", + "tornado >=4.1,<5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "38a45fd68e421b7481321a39b6c0e7b5", + "name": "opentracing_instrumentation", + "sha256": "1e79612c03fd090769c07244103ed79d2c802136dd401c1c1c29662332fc2409", + "size": 46825, + "subdir": "linux-64", + "timestamp": 1564682689268, + "version": "3.1.1" + }, + "opentracing_instrumentation-3.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=2,<3", + "python >=3.7,<3.8.0a0", + "six", + "tornado >=4.1,<5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "632c1b75cd1a27f87fc7781c27e504a4", + "name": "opentracing_instrumentation", + "sha256": "9c598f6cc7265350b85ed59a0c58780bb77111a52ecad0e1bcde47771ec76b4d", + "size": 46859, + "subdir": "linux-64", + "timestamp": 1564682529383, + "version": "3.1.1" + }, + "opentsne-0.3.11-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.38.1", + "numpy >=1.14.6,<2.0a0", + "pynndescent >=0.3", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "82d4af96a51fb3f6d2b0a32c43810536", + "name": "opentsne", + "sha256": "48d8064902c347890978aa4506ef539ec2095f446846b28d3ecf61bedfd02fbb", + "size": 519354, + "subdir": "linux-64", + "timestamp": 1568037207773, + "version": "0.3.11" + }, + "opentsne-0.3.11-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.38.1", + "numpy >=1.14.6,<2.0a0", + "pynndescent >=0.3", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fe88f12491c496a44c8cf6b3ed0272f4", + "name": "opentsne", + "sha256": "acca13af58d9d0783aa4064f6bbbe0b4da6b22d78fdc13e11a50d95d23e48c10", + "size": 530642, + "subdir": "linux-64", + "timestamp": 1568037036621, + "version": "0.3.11" + }, + "opentsne-0.3.11-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.38.1", + "numpy >=1.14.6,<2.0a0", + "pynndescent >=0.3", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "134f77240c654a12430c8952ce04bef3", + "name": "opentsne", + "sha256": "bbfadc5709f7e256d9e5b5fc10c4d8d790e982fcd617c187ba44346aed6891b0", + "size": 407844, + "subdir": "linux-64", + "timestamp": 1574087201489, + "version": "0.3.11" + }, + "opentsne-0.4.3-py36hfd86e86_1.tar.bz2": { + "build": "py36hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numba >=0.38.1", + "numpy >=1.14.6,<2.0a0", + "pynndescent >=0.3", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f27ad8e3f61449764859e30880659e62", + "name": "opentsne", + "sha256": "a0c086047ae8b81bfdb89bc33a5f0a70aa8b84e4d7683d5c49c7c094f777ccb7", + "size": 660098, + "subdir": "linux-64", + "timestamp": 1594138770328, + "version": "0.4.3" + }, + "opentsne-0.4.3-py37hfd86e86_1.tar.bz2": { + "build": "py37hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numba >=0.38.1", + "numpy >=1.14.6,<2.0a0", + "pynndescent >=0.3", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f48eb0f0bf499f90f192fa29711fb6b", + "name": "opentsne", + "sha256": "81f8c7405b39d0d760c32f781cf91dc03e0634b35c7dd36eddb8a6f0edba7a8c", + "size": 640062, + "subdir": "linux-64", + "timestamp": 1594138766260, + "version": "0.4.3" + }, + "opentsne-0.4.3-py38hfd86e86_1.tar.bz2": { + "build": "py38hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numba >=0.38.1", + "numpy >=1.14.6,<2.0a0", + "pynndescent >=0.3", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7c4bcf1b6566919d900d8308c3fac490", + "name": "opentsne", + "sha256": "85373eac44f4c1f3c9487861ddf9c7176195179b37275c2b614e247fe2974b50", + "size": 661304, + "subdir": "linux-64", + "timestamp": 1594138775855, + "version": "0.4.3" + }, + "opentsne-0.6.2-py310h3c18c91_0.tar.bz2": { + "build": "py310h3c18c91_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "fftw", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ade5823e012326022baddd95aff524ed", + "name": "opentsne", + "sha256": "144446f14b274ec5c4e1355e81eeb64943b5142d56a040e21a55027bc89812a5", + "size": 2731162, + "subdir": "linux-64", + "timestamp": 1659348862208, + "version": "0.6.2" + }, + "opentsne-0.6.2-py311heed92f4_0.tar.bz2": { + "build": "py311heed92f4_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "fftw", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.11,<3.12.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b4f98c5b2e39596fe411b34d5e424506", + "name": "opentsne", + "sha256": "de5c1f2b6325dc39dface98cfb17bc99b9b908366e49e38d3043fc4bb5e978ec", + "size": 515936, + "subdir": "linux-64", + "timestamp": 1676860128095, + "version": "0.6.2" + }, + "opentsne-0.6.2-py37h79cecc1_0.tar.bz2": { + "build": "py37h79cecc1_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "fftw", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2258e6a402728282f44747822b48378b", + "name": "opentsne", + "sha256": "6408e302ccbeade5ed6f21f5aaa38cedf67700b3a0c6212605d00fa1c61d5c54", + "size": 507025, + "subdir": "linux-64", + "timestamp": 1659348667991, + "version": "0.6.2" + }, + "opentsne-0.6.2-py38h79cecc1_0.tar.bz2": { + "build": "py38h79cecc1_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "fftw", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d2160854cda07bdace1aedf08fafb0eb", + "name": "opentsne", + "sha256": "d5adade5478cc34bd41d3e0a1fc57de3354048396563b3f5879418bbed131317", + "size": 515764, + "subdir": "linux-64", + "timestamp": 1659348579553, + "version": "0.6.2" + }, + "opentsne-0.6.2-py39h79cecc1_0.tar.bz2": { + "build": "py39h79cecc1_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "fftw", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1d200f63d504c04066bc4d5a81246b10", + "name": "opentsne", + "sha256": "1b31c59248837860c5472abdd47c56fd9a2519f17a32c4d97752b3cf80e9fac2", + "size": 519742, + "subdir": "linux-64", + "timestamp": 1659348754424, + "version": "0.6.2" + }, + "optax-0.1.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "chex >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.21,<2", + "python >=3.10,<3.11.0a0", + "typing_extensions >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c7280b0aa3a2bc10b472cb522740d3bc", + "name": "optax", + "sha256": "d9604a713939b2b13232c7741245ff247e8a8a5092985331ad9ea3fa36bbf311", + "size": 211097, + "subdir": "linux-64", + "timestamp": 1670009662821, + "version": "0.1.4" + }, + "optax-0.1.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "chex >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.21,<2", + "python >=3.11,<3.12.0a0", + "typing_extensions >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "78f706b4633b2e116f4e25b7b8f0cc2f", + "name": "optax", + "sha256": "886422a45abbd5616fdf78bf98fc9b2ae962d7a361639e657ff5040e38a5b9b3", + "size": 284239, + "subdir": "linux-64", + "timestamp": 1676860145693, + "version": "0.1.4" + }, + "optax-0.1.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "chex >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.20,<2", + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ed0e235a4ac3c48c97963cc53147df63", + "name": "optax", + "sha256": "071272097ce6b7456c9e1fe26ba1c12e991ecb9ab6674141a7fed900c36c6913", + "size": 207507, + "subdir": "linux-64", + "timestamp": 1670009632057, + "version": "0.1.4" + }, + "optax-0.1.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "chex >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.20,<2", + "python >=3.8,<3.9.0a0", + "typing_extensions >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5c7667b3d760b289c03221b2ef00e879", + "name": "optax", + "sha256": "992f9b8e66f9e91ed768b98b68ebe85dde91f5356a9c008044725a3e9c33c2e5", + "size": 209591, + "subdir": "linux-64", + "timestamp": 1670009566717, + "version": "0.1.4" + }, + "optax-0.1.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "chex >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.20,<2", + "python >=3.9,<3.10.0a0", + "typing_extensions >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ac8abfa121ccef9f736df6ea8276364f", + "name": "optax", + "sha256": "cbf83d4bf16b9a8038b08386d2db28ff019a6e26c0d9628475b252d1da67b05e", + "size": 209167, + "subdir": "linux-64", + "timestamp": 1670009600947, + "version": "0.1.4" + }, + "optimum-1.4.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "coloredlogs", + "huggingface_hub >=0.8.0", + "numpy", + "packaging", + "python >=3.10,<3.11.0a0", + "pytorch >=1.9", + "sympy", + "transformers >=4.20.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3213a0791239483846b97ab915bcb30c", + "name": "optimum", + "sha256": "47cf05185526ce31d2df8ef4e97fced55a158f542739415a365f409fcce59ace", + "size": 174695, + "subdir": "linux-64", + "timestamp": 1668102540890, + "version": "1.4.1" + }, + "optimum-1.4.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "coloredlogs", + "huggingface_hub >=0.8.0", + "numpy", + "packaging", + "python >=3.7,<3.8.0a0", + "pytorch >=1.9", + "sympy", + "transformers >=4.20.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d29455af009caa95adb3e7ef289df014", + "name": "optimum", + "sha256": "1605587449c265d0d8a64f43f63ab8f59818c6aac5ac9686fdf737efe76a9e4c", + "size": 171797, + "subdir": "linux-64", + "timestamp": 1668102615946, + "version": "1.4.1" + }, + "optimum-1.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "coloredlogs", + "huggingface_hub >=0.8.0", + "numpy", + "packaging", + "python >=3.8,<3.9.0a0", + "pytorch >=1.9", + "sympy", + "transformers >=4.20.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d8d4db5f327e7963d7a0ef38acee0e06", + "name": "optimum", + "sha256": "753de597ae37af9386950c871b0255819a94da980ad214475064c859683d85b4", + "size": 172891, + "subdir": "linux-64", + "timestamp": 1668102499926, + "version": "1.4.1" + }, + "optimum-1.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "coloredlogs", + "huggingface_hub >=0.8.0", + "numpy", + "packaging", + "python >=3.9,<3.10.0a0", + "pytorch >=1.9", + "sympy", + "transformers >=4.20.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "99b49782e9b5e3ae63be92920c99a2c8", + "name": "optimum", + "sha256": "8bccc4f73959bf752e2ab6601b47c00ee4956f72ab1f44a553b3e72816c0daf6", + "size": 172940, + "subdir": "linux-64", + "timestamp": 1668102578234, + "version": "1.4.1" + }, + "optional-lite-3.5.0-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSL-1.0", + "license_family": "Other", + "md5": "2c6c561c3134c8092d64af6a9aefe1db", + "name": "optional-lite", + "sha256": "d6a70d3cf10e09e0749749f06650e27a544743e244aea1ae4c279ee5aab0d4aa", + "size": 16089, + "subdir": "linux-64", + "timestamp": 1659013253086, + "version": "3.5.0" + }, + "orange-canvas-core-0.1.27-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "cachecontrol >=0.12.6", + "commonmark >=0.8.1", + "dictdiffer", + "docutils", + "importlib_metadata", + "lockfile >=0.9", + "pip >=18.0", + "pyqt", + "python >=3.10,<3.11.0a0", + "qasync", + "requests", + "setuptools", + "wheel" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "806adfa119acfb606e2e676f12f30377", + "name": "orange-canvas-core", + "sha256": "080bfc59c1b0546c98a993b18abfa3dcbfaf39d7026e4c21d5d1fa33379000d3", + "size": 766932, + "subdir": "linux-64", + "timestamp": 1659464138544, + "version": "0.1.27" + }, + "orange-canvas-core-0.1.27-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "cachecontrol >=0.12.6", + "commonmark >=0.8.1", + "dictdiffer", + "docutils", + "importlib_metadata", + "lockfile >=0.9", + "pip >=18.0", + "pyqt", + "python >=3.11,<3.12.0a0", + "qasync", + "requests", + "setuptools", + "wheel" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "36db7d0f06473e79517f44a501bf1b76", + "name": "orange-canvas-core", + "sha256": "504ed51a77b43a7ef951f6c4f418e400ce2af100287c8041b286e0990980da52", + "size": 1019786, + "subdir": "linux-64", + "timestamp": 1676845102500, + "version": "0.1.27" + }, + "orange-canvas-core-0.1.27-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "cachecontrol >=0.12.6", + "commonmark >=0.8.1", + "dictdiffer", + "docutils", + "importlib_metadata", + "lockfile >=0.9", + "pip >=18.0", + "pyqt", + "python >=3.7,<3.8.0a0", + "qasync", + "requests", + "setuptools", + "wheel" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "ea9fc7e6c0a0a8bcac25117882f7be4a", + "name": "orange-canvas-core", + "sha256": "e6e4f10d4c030d9a9c6cb20d60ae5443516c15a62802d90448346ee1fd11e0a6", + "size": 758118, + "subdir": "linux-64", + "timestamp": 1659464174151, + "version": "0.1.27" + }, + "orange-canvas-core-0.1.27-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "cachecontrol >=0.12.6", + "commonmark >=0.8.1", + "dictdiffer", + "docutils", + "importlib_metadata", + "lockfile >=0.9", + "pip >=18.0", + "pyqt", + "python >=3.8,<3.9.0a0", + "qasync", + "requests", + "setuptools", + "wheel" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "d9ae38a3bf6485277dd323dbcfefd08f", + "name": "orange-canvas-core", + "sha256": "235aaeee2cc970afd2f34802c69274f160ce06dd2d38d02965d92a5d37df8a55", + "size": 761059, + "subdir": "linux-64", + "timestamp": 1659464191740, + "version": "0.1.27" + }, + "orange-canvas-core-0.1.27-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "cachecontrol >=0.12.6", + "commonmark >=0.8.1", + "dictdiffer", + "docutils", + "importlib_metadata", + "lockfile >=0.9", + "pip >=18.0", + "pyqt", + "python >=3.9,<3.10.0a0", + "qasync", + "requests", + "setuptools", + "wheel" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "fb5508e724811a0205a4207e379fbc3b", + "name": "orange-canvas-core", + "sha256": "d36e58565a226ae84391148a5531fd7e61bf85d009943690638a31519412e1d6", + "size": 761085, + "subdir": "linux-64", + "timestamp": 1659464156200, + "version": "0.1.27" + }, + "orange-widget-base-4.17.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "matplotlib-base", + "orange-canvas-core >=0.1.20,<0.2a", + "pyqtgraph", + "python >=3.10,<3.11.0a0", + "typing_extensions >=3.7.4.3" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "e12b9dd00b2ab0ae4cd3b5710417b859", + "name": "orange-widget-base", + "sha256": "b9530f0c8adcfbee029ab963501990181a2b1aa6d3cc60e14278fdaf00a2e40e", + "size": 423537, + "subdir": "linux-64", + "timestamp": 1659466969371, + "version": "4.17.0" + }, + "orange-widget-base-4.17.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "matplotlib-base", + "orange-canvas-core >=0.1.20,<0.2a", + "pyqtgraph", + "python >=3.11,<3.12.0a0", + "typing_extensions >=3.7.4.3" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "8ef9abba59d3a90e35f5044dcc224936", + "name": "orange-widget-base", + "sha256": "3391a8d25ca37bd62feed3da9dbabda0fd1df45928818c3842d9682002c436af", + "size": 561594, + "subdir": "linux-64", + "timestamp": 1676860161609, + "version": "4.17.0" + }, + "orange-widget-base-4.17.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "matplotlib-base", + "orange-canvas-core >=0.1.20,<0.2a", + "pyqtgraph", + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.7.4.3" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "b6392a05dd536d914d9f22d2d44457c3", + "name": "orange-widget-base", + "sha256": "93402747cc5f4fdb44dbd641f71267b97c6d48b097d7bf8da3e966fffcc999a6", + "size": 417941, + "subdir": "linux-64", + "timestamp": 1659466863726, + "version": "4.17.0" + }, + "orange-widget-base-4.17.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "matplotlib-base", + "orange-canvas-core >=0.1.20,<0.2a", + "pyqtgraph", + "python >=3.8,<3.9.0a0", + "typing_extensions >=3.7.4.3" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "270cae66d9bf461a80c0c88aa7660754", + "name": "orange-widget-base", + "sha256": "86d8ebee18e2a7d84928cf388df0487aaff9b0c2eecda71fa439660c61eb8c20", + "size": 418995, + "subdir": "linux-64", + "timestamp": 1659466925421, + "version": "4.17.0" + }, + "orange-widget-base-4.17.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "matplotlib-base", + "orange-canvas-core >=0.1.20,<0.2a", + "pyqtgraph", + "python >=3.9,<3.10.0a0", + "typing_extensions >=3.7.4.3" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "7cb4c386123c3b7c88990cd91ffa0979", + "name": "orange-widget-base", + "sha256": "4ac6ab776ea86ed0ded7628b1b6ec87633d85bb997d3c63b1366e394c6d5f50c", + "size": 420270, + "subdir": "linux-64", + "timestamp": 1659466894211, + "version": "4.17.0" + }, + "orange3-3.11.0-py35h637b7d7_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "anyqt", + "bottleneck", + "chardet >=2.3.0", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pip", + "pyqtgraph", + "python >=3.5,<3.6.0a0", + "scikit-learn >=0.18.1", + "scipy", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "4918969f0b6f9f642cb14aa8df4c0960", + "name": "orange3", + "sha256": "e28ac9e998202f2f4df0c35d512a0161aad41d6b5e6f96ce79cad21d9df17fcf", + "size": 4546535, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1521131534635, + "type": "app", + "version": "3.11.0" + }, + "orange3-3.11.0-py36h637b7d7_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "anyqt", + "bottleneck", + "chardet >=2.3.0", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pip", + "pyqtgraph", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.18.1", + "scipy", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "38d834a31d4ed272bfd9e3cbd8658d53", + "name": "orange3", + "sha256": "b0dd4277191c3012d0ccf283e744ba74e063d748cbb01a6caed3436eac61b62d", + "size": 4570130, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1521131536175, + "type": "app", + "version": "3.11.0" + }, + "orange3-3.13.0-py35h637b7d7_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.5,<3.6.0a0", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "9bce43808fd26060d52da4a041c938b6", + "name": "orange3", + "sha256": "c891e73b941d90050f1dd96e63ad63b1549af782ddd37a0a8fdb1a67bd38d563", + "size": 4558440, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1524107994339, + "type": "app", + "version": "3.13.0" + }, + "orange3-3.13.0-py36h04863e7_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "c530f2e947816e4f4b2c96564f198e06", + "name": "orange3", + "sha256": "153c0444de314c7f74e2bd05e871bf3cae563d0241a30776c313b94804d18c88", + "size": 4953087, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1530903101534, + "type": "app", + "version": "3.13.0" + }, + "orange3-3.13.0-py36h637b7d7_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "8caa5f0b141e1cde12c6ad01cfa45515", + "name": "orange3", + "sha256": "c5b3ebb2c50622e39d683ab81ac217bc5f92f7a28bbd7cbe44ccfb72d3bc5c08", + "size": 4579424, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1524108263804, + "type": "app", + "version": "3.13.0" + }, + "orange3-3.13.0-py37h04863e7_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "9b11ed865855b998bda70a292ed4aa97", + "name": "orange3", + "sha256": "51cc8c5ebed890f1f808bf576cc52766a9f0e7e3877b116104a0aa0c1aef5217", + "size": 4948994, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1530902922503, + "type": "app", + "version": "3.13.0" + }, + "orange3-3.15.0-py35h962f231_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py35h962f231_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.5,<3.6.0a0", + "python-louvain", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "884ec8f97982093e3fa6a88d9a793f42", + "name": "orange3", + "sha256": "d41ce197c18c10847102bef85eaf4ddfb6b5204f47b9d8aedc410d4cb3ded004", + "size": 5012302, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1535786763979, + "type": "app", + "version": "3.15.0" + }, + "orange3-3.15.0-py36h962f231_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "python-louvain", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "f0a1102306a75662cda587886367d82e", + "name": "orange3", + "sha256": "81935707ef082ea9073f430dd7ee2f4f795ddefe6523d64af15b026035e68a02", + "size": 5011535, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1535786606782, + "type": "app", + "version": "3.15.0" + }, + "orange3-3.15.0-py37h962f231_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.7,<3.8.0a0", + "python-louvain", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "242540c896269ec60b694e3bd63b03e1", + "name": "orange3", + "sha256": "cfe81ad765a2fedab2b64c8f0b5a6ce8ea21cf91f0de3ab10641ddf028dd7f85", + "size": 5008418, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1535786796366, + "type": "app", + "version": "3.15.0" + }, + "orange3-3.16.0-py35h962f231_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py35h962f231_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.5,<3.6.0a0", + "python-louvain", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "2f0537b1a6fada040c20731eb72beca8", + "name": "orange3", + "sha256": "a52331f48d6b90e47dbc8a617d508ed8e7cd14173b3498c9c2e874d4c7f51682", + "size": 5059766, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1537908859565, + "type": "app", + "version": "3.16.0" + }, + "orange3-3.16.0-py36h962f231_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "python-louvain", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "ef1bb3bbad85c871a8f5d442bcd1965a", + "name": "orange3", + "sha256": "01245fd5b6a1af9b6e6c6eb31f68f2d8af06c6b1e85e6bfc7493eedcc92f9bf0", + "size": 5056003, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1537908863361, + "type": "app", + "version": "3.16.0" + }, + "orange3-3.16.0-py37h962f231_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.7,<3.8.0a0", + "python-louvain", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "b369ffb47f0c9db395a0337d16252dd7", + "name": "orange3", + "sha256": "ba1152777885c98740e7624221115807e2e9279752274d41a2242be0f4c593ff", + "size": 5047492, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1537908849558, + "type": "app", + "version": "3.16.0" + }, + "orange3-3.17.0-py36h962f231_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "python-louvain", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "48ea3a4f953dcde81f63dffbaae92b7d", + "name": "orange3", + "sha256": "8d93226aecdd7368d9099a0b168d5f64df10acec52bd4dd98590c97b0f58d806", + "size": 4965390, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1540994059488, + "type": "app", + "version": "3.17.0" + }, + "orange3-3.17.0-py37h962f231_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.7,<3.8.0a0", + "python-louvain", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "05f695bc436a40283c975f5283e8639a", + "name": "orange3", + "sha256": "eb9adb3052590c41f2115e27653afa5894c107f17ac368cd7143d857b64eb0dd", + "size": 4946507, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1540994053348, + "type": "app", + "version": "3.17.0" + }, + "orange3-3.19.0-py36he6710b0_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "docutils", + "fasttsne >=0.2.12", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.15.4,<2.0a0", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "python-louvain", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "dca62b1619bf9610895a019a129c9ca1", + "name": "orange3", + "sha256": "1ec3fa085ea7a68f41db49c44e124dbeb14080c54b3e68195321501f1e4438cf", + "size": 5076341, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1547969636997, + "type": "app", + "version": "3.19.0" + }, + "orange3-3.19.0-py37he6710b0_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "docutils", + "fasttsne >=0.2.12", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.15.4,<2.0a0", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.7,<3.8.0a0", + "python-louvain", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "6f6b77bb9ad51569528ed5a1bbe2241c", + "name": "orange3", + "sha256": "03df0507fe1fd40b5f4a352713144acbfe6bd93cc11f7735cadf7eb22c52a565", + "size": 5076175, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1547970744129, + "type": "app", + "version": "3.19.0" + }, + "orange3-3.23.0-py36he6710b0_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.16.4,<2.0a0", + "opentsne >=0.3.11", + "orange-canvas-core >=0.1.3,<0.2a", + "orange-widget-base >=4.0a,<4.1a", + "pandas", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "python-louvain >=0.13", + "pyyaml", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "5e617b3d96d5a065af8061d816057992", + "name": "orange3", + "sha256": "4d3a95f45e7c9140d98d2ffeec694b016520a248b1f4c496b00d08116f46b3c4", + "size": 3626460, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1568037694709, + "type": "app", + "version": "3.23.0" + }, + "orange3-3.23.0-py36he6710b0_1.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py36he6710b0_1", + "build_number": 1, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.17.2,<2.0a0", + "opentsne >=0.3.11", + "orange-canvas-core >=0.1.3,<0.2a", + "orange-widget-base >=4.0a,<4.1a", + "pandas", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "python-louvain >=0.13", + "pyyaml", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "9f5abe256b731def654e12fd0a77022e", + "name": "orange3", + "sha256": "9a67480a2ae967394d3157a8d11de82c4241484731fefa87a703dc6864b63feb", + "size": 3606346, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1569601384893, + "type": "app", + "version": "3.23.0" + }, + "orange3-3.23.0-py37he6710b0_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.16.4,<2.0a0", + "opentsne >=0.3.11", + "orange-canvas-core >=0.1.3,<0.2a", + "orange-widget-base >=4.0a,<4.1a", + "pandas", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.7,<3.8.0a0", + "python-louvain >=0.13", + "pyyaml", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "169f8077d0c97ed0a6291307e9262a6d", + "name": "orange3", + "sha256": "124490d55d03049f070ea630ede5129f024da303eeea32dd60a4002004714b53", + "size": 3601667, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1568037870683, + "type": "app", + "version": "3.23.0" + }, + "orange3-3.23.0-py37he6710b0_1.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py37he6710b0_1", + "build_number": 1, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.17.2,<2.0a0", + "opentsne >=0.3.11", + "orange-canvas-core >=0.1.3,<0.2a", + "orange-widget-base >=4.0a,<4.1a", + "pandas", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.7,<3.8.0a0", + "python-louvain >=0.13", + "pyyaml", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "5a6b0bb073fd48a50c24b271436d29a5", + "name": "orange3", + "sha256": "2af64849dc952467caf1fdc3edd70e368484c4a09e2d8fd4ab00a27704fd949e", + "size": 3584264, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1569601381548, + "type": "app", + "version": "3.23.0" + }, + "orange3-3.23.1-py36he6710b0_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx", + "numpy >=1.17.2,<2.0a0", + "opentsne >=0.3.11", + "orange-canvas-core >=0.1.7,<0.2a", + "orange-widget-base >=4.0a,<4.1a", + "pandas", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "python-louvain >=0.13", + "pyyaml", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "69d2687027e888087ea60310a4c44d0b", + "name": "orange3", + "sha256": "a3583c3a8d8899d3ce3e865d79e08421ac199102c22230b03571c942e7f230d0", + "size": 3623209, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1571239216002, + "type": "app", + "version": "3.23.1" + }, + "orange3-3.23.1-py37he6710b0_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx", + "numpy >=1.17.2,<2.0a0", + "opentsne >=0.3.11", + "orange-canvas-core >=0.1.7,<0.2a", + "orange-widget-base >=4.0a,<4.1a", + "pandas", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.7,<3.8.0a0", + "python-louvain >=0.13", + "pyyaml", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "830b55b064bf24fc97587a8200be3884", + "name": "orange3", + "sha256": "fe49d3317d7d992c4a5753f85292ad7c304a05592b2719a7cdaebb15b954d645", + "size": 3634332, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1571239232235, + "type": "app", + "version": "3.23.1" + }, + "orange3-3.26.0-py36he6710b0_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "baycomp >=1.0.2", + "bottleneck >=1.0.0", + "cachecontrol >=0.12.6", + "chardet >=3.0.2", + "docutils", + "httpx >=0.12", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.18.5,<2.0a0", + "openpyxl", + "opentsne >=0.3.11", + "orange-canvas-core >=0.1.15,<0.2a", + "orange-widget-base >=4.6.0", + "pandas", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "python-louvain >=0.13", + "pyyaml", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "994f4393241e02926d730b0f59e4601a", + "name": "orange3", + "sha256": "829b230aa4dead2a561ba2fcbe1c719d9f98043d54fe7361ffe4944d965394b0", + "size": 4006084, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1594070730847, + "type": "app", + "version": "3.26.0" + }, + "orange3-3.26.0-py37he6710b0_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "baycomp >=1.0.2", + "bottleneck >=1.0.0", + "cachecontrol >=0.12.6", + "chardet >=3.0.2", + "docutils", + "httpx >=0.12", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.18.5,<2.0a0", + "openpyxl", + "opentsne >=0.3.11", + "orange-canvas-core >=0.1.15,<0.2a", + "orange-widget-base >=4.6.0", + "pandas", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.7,<3.8.0a0", + "python-louvain >=0.13", + "pyyaml", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "9909faccae535eb9e269924edd690ea3", + "name": "orange3", + "sha256": "eeb6ea87b51165828ba7d40c2bdb28cd734e12cdc8c793305d62d9fc5fa6596d", + "size": 3990603, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1594070739034, + "type": "app", + "version": "3.26.0" + }, + "orange3-3.26.0-py38he6710b0_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "baycomp >=1.0.2", + "bottleneck >=1.0.0", + "cachecontrol >=0.12.6", + "chardet >=3.0.2", + "docutils", + "httpx >=0.12", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.18.5,<2.0a0", + "openpyxl", + "opentsne >=0.3.11", + "orange-canvas-core >=0.1.15,<0.2a", + "orange-widget-base >=4.6.0", + "pandas", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.8,<3.9.0a0", + "python-louvain >=0.13", + "pyyaml", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "3277c4ea8d178c02ced86df796a1d55e", + "name": "orange3", + "sha256": "83f28d40e8897d5e571efe7df9265e3a14f6cc8afc5b5a3799fe870ed45adf8f", + "size": 4043531, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1594070755049, + "type": "app", + "version": "3.26.0" + }, + "orange3-3.32.0-py310h1128e8f_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py310h1128e8f_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.13", + "baycomp >=1.0.2", + "bottleneck >=1.3.2", + "catboost !=1.0.0", + "chardet >=3.0.2", + "httpx >=0.21", + "ipykernel !=6.11.0", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.5", + "networkx", + "numpy >=1.17.3", + "numpy >=1.21.5,<2.0a0", + "openpyxl", + "opentsne >=0.6.1", + "orange-canvas-core >=0.1.24,<0.2a", + "orange-widget-base >=4.16.1", + "pandas >=1.3.0", + "pip >=18.0", + "pygments >=2.8.0", + "pyqt >=5.12,!=5.15.1", + "pyqtgraph >=0.11.1,!=0.12.4", + "pyqtwebengine >=5.12", + "python >=3.10,<3.11.0a0", + "python-louvain >=0.13", + "pyyaml", + "qtconsole >=4.7.2", + "requests", + "scikit-learn >=1.0.1", + "scipy >=1.3.1", + "serverfiles", + "setuptools >=41.0.0", + "xgboost", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0-or-later", + "md5": "f960df377d1223e4be546280e7709943", + "name": "orange3", + "sha256": "ca0b087303df6241208ff67f61487fe48505d109f05eff98249276c52c1a5285", + "size": 30264374, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1659557086796, + "type": "app", + "version": "3.32.0" + }, + "orange3-3.32.0-py37h417a72b_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py37h417a72b_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.13", + "baycomp >=1.0.2", + "bottleneck >=1.3.2", + "catboost !=1.0.0", + "chardet >=3.0.2", + "httpx >=0.21", + "ipykernel !=6.11.0", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.5", + "networkx", + "numpy >=1.16.6,<2.0a0", + "numpy >=1.17.3", + "openpyxl", + "opentsne >=0.6.1", + "orange-canvas-core >=0.1.24,<0.2a", + "orange-widget-base >=4.16.1", + "pandas >=1.3.0", + "pip >=18.0", + "pygments >=2.8.0", + "pyqt >=5.12,!=5.15.1", + "pyqtgraph >=0.11.1,!=0.12.4", + "pyqtwebengine >=5.12", + "python >=3.7,<3.8.0a0", + "python-louvain >=0.13", + "pyyaml", + "qtconsole >=4.7.2", + "requests", + "scikit-learn >=1.0.1", + "scipy >=1.3.1", + "serverfiles", + "setuptools >=41.0.0", + "xgboost", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0-or-later", + "md5": "202a1fcf619f564535e9ff4563683d3c", + "name": "orange3", + "sha256": "7058dc330dda12298af753bf8e5fb95d6ba86f3726835537fdf277959c5f000e", + "size": 28372781, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1659556942333, + "type": "app", + "version": "3.32.0" + }, + "orange3-3.32.0-py38h417a72b_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py38h417a72b_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.13", + "baycomp >=1.0.2", + "bottleneck >=1.3.2", + "catboost !=1.0.0", + "chardet >=3.0.2", + "httpx >=0.21", + "ipykernel !=6.11.0", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.5", + "networkx", + "numpy >=1.16.6,<2.0a0", + "numpy >=1.17.3", + "openpyxl", + "opentsne >=0.6.1", + "orange-canvas-core >=0.1.24,<0.2a", + "orange-widget-base >=4.16.1", + "pandas >=1.3.0", + "pip >=18.0", + "pygments >=2.8.0", + "pyqt >=5.12,!=5.15.1", + "pyqtgraph >=0.11.1,!=0.12.4", + "pyqtwebengine >=5.12", + "python >=3.8,<3.9.0a0", + "python-louvain >=0.13", + "pyyaml", + "qtconsole >=4.7.2", + "requests", + "scikit-learn >=1.0.1", + "scipy >=1.3.1", + "serverfiles", + "setuptools >=41.0.0", + "xgboost", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0-or-later", + "md5": "fe1f6e1500fb09b4a30e8be599af2deb", + "name": "orange3", + "sha256": "b6d357ea803a59b4ffafe3ab28b5a18a526ff958ac9071da35bce78a6d6d91b2", + "size": 28407387, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1659557212846, + "type": "app", + "version": "3.32.0" + }, + "orange3-3.32.0-py39h417a72b_0.tar.bz2": { + "app_entry": "orange-canvas", + "build": "py39h417a72b_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.13", + "baycomp >=1.0.2", + "bottleneck >=1.3.2", + "catboost !=1.0.0", + "chardet >=3.0.2", + "httpx >=0.21", + "ipykernel !=6.11.0", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.5", + "networkx", + "numpy >=1.16.6,<2.0a0", + "numpy >=1.17.3", + "openpyxl", + "opentsne >=0.6.1", + "orange-canvas-core >=0.1.24,<0.2a", + "orange-widget-base >=4.16.1", + "pandas >=1.3.0", + "pip >=18.0", + "pygments >=2.8.0", + "pyqt >=5.12,!=5.15.1", + "pyqtgraph >=0.11.1,!=0.12.4", + "pyqtwebengine >=5.12", + "python >=3.9,<3.10.0a0", + "python-louvain >=0.13", + "pyyaml", + "qtconsole >=4.7.2", + "requests", + "scikit-learn >=1.0.1", + "scipy >=1.3.1", + "serverfiles", + "setuptools >=41.0.0", + "xgboost", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0-or-later", + "md5": "544a7601b0c11094dfac4ffc40b45ff7", + "name": "orange3", + "sha256": "71aca6c805477e2a1d446ca60c10ce803741c9bcbdd632321a8dda502ac1266e", + "size": 28412555, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1659557338480, + "type": "app", + "version": "3.32.0" + }, + "orc-1.4.3-hdbcaa40_0.tar.bz2": { + "build": "hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "protobuf", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "4dbec0d7397c1f23f7e8fd5e48c31e89", + "name": "orc", + "sha256": "198ac5c2705fc6bf55e068b5c779dede306a268d1c0ddfabac667fe8834f2c78", + "size": 1198270, + "subdir": "linux-64", + "timestamp": 1529458834856, + "version": "1.4.3" + }, + "orc-1.5.1-hdbcaa40_0.tar.bz2": { + "build": "hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "protobuf", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "7a7839ebe33ed8d926d33889ace416c5", + "name": "orc", + "sha256": "a5022514c58ea5aecdf5477f65dba8eb5844aa6cb8df070c9035f631b75e08f7", + "size": 3255768, + "subdir": "linux-64", + "timestamp": 1529508837719, + "version": "1.5.1" + }, + "orc-1.5.6-h45e4b6e_0.tar.bz2": { + "build": "h45e4b6e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f1a61461c7d3175cd6f0119ea4dc88b8", + "name": "orc", + "sha256": "18ceebf3cde80073eaa8da405f4c36e328f50b5f76055ba92fd5eaf500f31a67", + "size": 3455138, + "subdir": "linux-64", + "timestamp": 1567109684474, + "version": "1.5.6" + }, + "orc-1.6.2-h69b9f2a_0.tar.bz2": { + "build": "h69b9f2a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "02be9b3385e7fe522749d9201dc983d6", + "name": "orc", + "sha256": "c79d2125b0c794807770b9a4ccededa40f186e280cfad9ffc5b4b36ce563dcc4", + "size": 4718444, + "subdir": "linux-64", + "timestamp": 1585309488741, + "version": "1.6.2" + }, + "orc-1.6.2-h69b9f2a_1.tar.bz2": { + "build": "h69b9f2a_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5a5e07c349cf7f9ca1f45df6d24891e1", + "name": "orc", + "sha256": "43ab1065319ae4e34fe8810f0749b4aba8fc07ff1c6b11dba095dbd124859692", + "size": 4703752, + "subdir": "linux-64", + "timestamp": 1580397676085, + "version": "1.6.2" + }, + "orc-1.6.2-hf484d3e_1.tar.bz2": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.4,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7b550966b4c7676c9ba74e702f7ebcdb", + "name": "orc", + "sha256": "1f49439d2c94a2c0f1f68d0cf6730587c9686237590555ae7290f5f8ea0a61b2", + "size": 4702379, + "subdir": "linux-64", + "timestamp": 1585309599304, + "version": "1.6.2" + }, + "orc-1.6.4-h69b9f2a_0.tar.bz2": { + "build": "h69b9f2a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b92144c6ccb803accd174f3ecb697f9d", + "name": "orc", + "sha256": "2d9da2f63563e3b074c7b7df841146be404b8085b93ba875536b337cb103d6ee", + "size": 5098116, + "subdir": "linux-64", + "timestamp": 1601509287869, + "version": "1.6.4" + }, + "orc-1.6.4-hc68dd99_0.tar.bz2": { + "build": "hc68dd99_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4a4a13c22494cc8c6a563255ae10521e", + "name": "orc", + "sha256": "e969a6acf7d401708dd601d315e59d2787efc43349f0920206d9e74be4bce608", + "size": 5129132, + "subdir": "linux-64", + "timestamp": 1601509344313, + "version": "1.6.4" + }, + "orc-1.6.5-h31f52df_2.tar.bz2": { + "build": "h31f52df_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "snappy >=1.1.8,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e4a36c5fc36b7050226ae2752356380e", + "name": "orc", + "sha256": "b278dd2c97df551bec9b8d517339e21a0dfcf0ffb1351a389cd4d64aa9ae6021", + "size": 705336, + "subdir": "linux-64", + "timestamp": 1607217205492, + "version": "1.6.5" + }, + "orc-1.6.5-h973521d_1.tar.bz2": { + "build": "h973521d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "snappy >=1.1.8,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3f840ab1dba41c65077c6c6f4ac730f1", + "name": "orc", + "sha256": "b1a623281d0deb6fb283d643ca893db0dff579beaae56664d70bbeba85690045", + "size": 690585, + "subdir": "linux-64", + "timestamp": 1607048310084, + "version": "1.6.5" + }, + "orc-1.6.7-h973521d_2.tar.bz2": { + "build": "h973521d_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "snappy >=1.1.8,<2.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ce4459058a7a9cd79a2e42b0fbeea46a", + "name": "orc", + "sha256": "b75f8a4605fbed3541e188f14fc214a2da97c518d4d53b00ed8bab6e4107d32d", + "size": 752109, + "subdir": "linux-64", + "timestamp": 1619508612546, + "version": "1.6.7" + }, + "orc-1.6.8-h973521d_2.tar.bz2": { + "build": "h973521d_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "snappy >=1.1.8,<2.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fc37797112d09a10a57e4c508e474490", + "name": "orc", + "sha256": "7da63b47c0603649930e974bdd6e34dc098584c63df1677cac8ad0350bf9fec5", + "size": 754033, + "subdir": "linux-64", + "timestamp": 1623089849857, + "version": "1.6.8" + }, + "orc-1.6.9-h14377d0_2.tar.bz2": { + "build": "h14377d0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "snappy >=1.1.8,<2.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "075d1ac4ca1c755e6637ffcbaeef701f", + "name": "orc", + "sha256": "764992da2389c8566ba34dd9d3248d0f68e0abbe06a75a66f81bbaab12bda4fc", + "size": 751249, + "subdir": "linux-64", + "timestamp": 1625642988664, + "version": "1.6.9" + }, + "orc-1.6.9-ha97a36c_3.tar.bz2": { + "build": "ha97a36c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "snappy >=1.1.8,<2.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "296e321c4140642ba7fe80cc7894b8ea", + "name": "orc", + "sha256": "9909949aad8972a19483f1f4380ab3775cb9c6495afe865e5b0086716ecfd907", + "size": 745944, + "subdir": "linux-64", + "timestamp": 1631219336906, + "version": "1.6.9" + }, + "orc-1.7.4-h07ed6aa_0.tar.bz2": { + "build": "h07ed6aa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "snappy >=1.1.9,<2.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "88771cfe87ffe0ef6641f73a4282bee0", + "name": "orc", + "sha256": "567f715a20d2fc9612ad375583a9202fffbea498d8ba971a8a2f148e1dd75ba3", + "size": 1143954, + "subdir": "linux-64", + "timestamp": 1652942927748, + "version": "1.7.4" + }, + "orc-1.7.4-hb3bc3d3_1.tar.bz2": { + "build": "hb3bc3d3_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "lz4-c >=1.9.4,<1.10.0a0", + "snappy >=1.1.9,<2.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "56057ed323f733bdcf262468682d0358", + "name": "orc", + "sha256": "9618addfc1b940c048372ffb2c8500d4b44d02455a9bd1f411e530ed5e09b8d5", + "size": 1132661, + "subdir": "linux-64", + "timestamp": 1676482768554, + "version": "1.7.4" + }, + "orderedmultidict-0.7.11-py27hb58a934_0.tar.bz2": { + "build": "py27hb58a934_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "a1a22c1de2534c9f632feb79ebb6ee25", + "name": "orderedmultidict", + "sha256": "1756c7428e050f9784c89e332edd09b2a551ec5da194402ef89370fa118e01ba", + "size": 18335, + "subdir": "linux-64", + "timestamp": 1505743234283, + "version": "0.7.11" + }, + "orderedmultidict-0.7.11-py35hc76afa9_0.tar.bz2": { + "build": "py35hc76afa9_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "b867e299b5fc38938168eeb86752f7d4", + "name": "orderedmultidict", + "sha256": "6f5adfcb30650c0e39341dd595f9f18213c725e736402210b66c4b34080f8d41", + "size": 19059, + "subdir": "linux-64", + "timestamp": 1505743246068, + "version": "0.7.11" + }, + "orderedmultidict-0.7.11-py36h9635bf0_0.tar.bz2": { + "build": "py36h9635bf0_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "a670b1be13148be739cafff549a75d46", + "name": "orderedmultidict", + "sha256": "42905e6d1d74534c96e63da0cef400bedbcfd0f77b90fc34e39f99af04ee86c4", + "size": 18980, + "subdir": "linux-64", + "timestamp": 1505743257914, + "version": "0.7.11" + }, + "orderedmultidict-1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "c12cec08a10ae2890d2cb3e1ab9402fb", + "name": "orderedmultidict", + "sha256": "5e63ea1312fcf6039bfca58af4055c02523bf2e53d134cd9773fa7acee89afeb", + "size": 18619, + "subdir": "linux-64", + "timestamp": 1529446165134, + "version": "1.0" + }, + "orderedmultidict-1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "769700087985403419ac62620958653a", + "name": "orderedmultidict", + "sha256": "ba83b4b47fd06d25c2cad75ef525daaa693552c4dc8dcbc4ecebf59f475c1eee", + "size": 19329, + "subdir": "linux-64", + "timestamp": 1529446193582, + "version": "1.0" + }, + "orderedmultidict-1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "bf214541660ca526e466403cf6d56159", + "name": "orderedmultidict", + "sha256": "611db1925d20e0ad0dbbd99511098f6e60de0577cefa40b563db314c17e15088", + "size": 19286, + "subdir": "linux-64", + "timestamp": 1529446156871, + "version": "1.0" + }, + "orderedmultidict-1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "e6957ef3c8dac2b4fd3f240c02b7b74d", + "name": "orderedmultidict", + "sha256": "5df5d11e68a34c8c560601a4a68df98d748fae21e7700a2f11a0d89cdd249c05", + "size": 19319, + "subdir": "linux-64", + "timestamp": 1530879350823, + "version": "1.0" + }, + "orderedmultidict-1.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "e311b9ed823c29662e7a8ee3196c184d", + "name": "orderedmultidict", + "sha256": "c8d1d40a1cb90435c5367faf3305752bf8592d2ca3e35391d1e15848eab00b96", + "size": 20489, + "subdir": "linux-64", + "timestamp": 1564686106187, + "version": "1.0.1" + }, + "orderedmultidict-1.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "fed8cf900b4eed9aab575c4b3e4bcd30", + "name": "orderedmultidict", + "sha256": "8ef6274c9b4ba84b83a934bbc6c2ef5cd5be586e9713caae95d943e30d018133", + "size": 20766, + "subdir": "linux-64", + "timestamp": 1640792094543, + "version": "1.0.1" + }, + "orderedmultidict-1.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "010af499d018e2d296efc746422b3c41", + "name": "orderedmultidict", + "sha256": "076913fa342ee76dff6c0c584d9f5a782efd4f669f7ad40a22341ec9c2b4d156", + "size": 26091, + "subdir": "linux-64", + "timestamp": 1676825389920, + "version": "1.0.1" + }, + "orderedmultidict-1.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "d016cc11e2e4b97ffc404590f7dd32e2", + "name": "orderedmultidict", + "sha256": "14d609c3c5b2c5249fe2a1b67718bf04df450f51bdfdc99fb2e69b0c76e84e86", + "size": 21205, + "subdir": "linux-64", + "timestamp": 1564686351726, + "version": "1.0.1" + }, + "orderedmultidict-1.0.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "d26b8cbd6b0faa03e46d38618c814691", + "name": "orderedmultidict", + "sha256": "c0e1b5d61398ef3ea5613a0018a7fc390c9f1a9471b6f6e7e9991af61258d422", + "size": 21182, + "subdir": "linux-64", + "timestamp": 1632894679908, + "version": "1.0.1" + }, + "orderedmultidict-1.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "6c8f2eb34bf15ee8bbc0dba881926de5", + "name": "orderedmultidict", + "sha256": "99a7f2f46ecba0916fb5cc418c9ec55408f17bb15fa7294f888fed50f3378886", + "size": 21184, + "subdir": "linux-64", + "timestamp": 1564686304048, + "version": "1.0.1" + }, + "orderedmultidict-1.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "072fb23ec1abafa05bccc632868c25df", + "name": "orderedmultidict", + "sha256": "e95e385d1d4278299b1cc50d5a1dc45cdcb391a7814240748efb2518650875ea", + "size": 21175, + "subdir": "linux-64", + "timestamp": 1632884238634, + "version": "1.0.1" + }, + "orderedmultidict-1.0.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "bb45b706c499163a50cf05c8ec06fbdd", + "name": "orderedmultidict", + "sha256": "330b3229695b4253c379c52a196c6156c6f8d6797cc45faa54d15e9007626aed", + "size": 20794, + "subdir": "linux-64", + "timestamp": 1573738386222, + "version": "1.0.1" + }, + "orderedmultidict-1.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "f8f24be9687db62aaedf51ae0b4beb4f", + "name": "orderedmultidict", + "sha256": "09960fa61f753413a0a1abbf08a4584c3417e0be3e2bd2f88d5ce4cf7839fa02", + "size": 21197, + "subdir": "linux-64", + "timestamp": 1632884224511, + "version": "1.0.1" + }, + "orderedmultidict-1.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "a9ae5bb1f56cb6e39100b8bde5a8713a", + "name": "orderedmultidict", + "sha256": "55136b636f8d3e41b83e7ac89c2deff4763758c8ff3cf6e35d3be44ce102c019", + "size": 21185, + "subdir": "linux-64", + "timestamp": 1632894657844, + "version": "1.0.1" + }, + "orjson-3.7.8-py310h52d8a92_0.tar.bz2": { + "build": "py310h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cc89be492b6134dd240bb94c9bd0b920", + "name": "orjson", + "sha256": "6a83641dd15f4d0675c98e106d4ffadd650d4e0ddad1a14ba62054682b6d004e", + "size": 282141, + "subdir": "linux-64", + "timestamp": 1668613228119, + "version": "3.7.8" + }, + "orjson-3.7.8-py311h52d8a92_0.tar.bz2": { + "build": "py311h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5aec09db6348c74584e9dcd63910c5fd", + "name": "orjson", + "sha256": "d9a5ab984309334429e2d1134b5aa2b150922354432476331dca4289adeebb38", + "size": 282751, + "subdir": "linux-64", + "timestamp": 1676860255067, + "version": "3.7.8" + }, + "orjson-3.7.8-py37h52d8a92_0.tar.bz2": { + "build": "py37h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "00ca18a93ebd8c24386d517e71581179", + "name": "orjson", + "sha256": "c10c16ffc98f260c20a7fb7241131b06e1d3acd6659c27311245c8233e8c0fe2", + "size": 281458, + "subdir": "linux-64", + "timestamp": 1668613358075, + "version": "3.7.8" + }, + "orjson-3.7.8-py38h52d8a92_0.tar.bz2": { + "build": "py38h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "69e399964345a99ea67ca4d3c33b48bf", + "name": "orjson", + "sha256": "fbc7cacc2c58c2500f583b505ef092fb0b5fb514334cb671c84fb28760062180", + "size": 281931, + "subdir": "linux-64", + "timestamp": 1668612968449, + "version": "3.7.8" + }, + "orjson-3.7.8-py39h52d8a92_0.tar.bz2": { + "build": "py39h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "62be68216c2145960fc2c39f04892a36", + "name": "orjson", + "sha256": "a7df5644065028fb3409fc1f81c25d728f544c758566def25fbe2389d5805ad8", + "size": 281761, + "subdir": "linux-64", + "timestamp": 1668613098313, + "version": "3.7.8" + }, + "owslib-0.15.0-py27hebf82df_0.tar.bz2": { + "build": "py27hebf82df_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "requests" + ], + "license": "BSD 3-Clause", + "md5": "2c541695897428633265ebf86685550f", + "name": "owslib", + "sha256": "8c041029e1d3cb55aa975e3d888d905e4988da4351544846e1de65ba2b602c03", + "size": 237060, + "subdir": "linux-64", + "timestamp": 1511989948398, + "version": "0.15.0" + }, + "owslib-0.15.0-py35h75c690b_0.tar.bz2": { + "build": "py35h75c690b_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "requests" + ], + "license": "BSD 3-Clause", + "md5": "7f2c477ca722d637cca581acbb900722", + "name": "owslib", + "sha256": "7c90caf7c89d295ade9664000daba6fe275800dfe6ee348b09089ee44519a3d5", + "size": 240402, + "subdir": "linux-64", + "timestamp": 1511990092008, + "version": "0.15.0" + }, + "owslib-0.15.0-py36h143ed5c_0.tar.bz2": { + "build": "py36h143ed5c_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "requests" + ], + "license": "BSD 3-Clause", + "md5": "9190f17c90bce9fb9afbf715888fe9a4", + "name": "owslib", + "sha256": "6780dbe43f2b81065aa04395bc27e59783cdce165eb5c9d0c070c1fbcf349555", + "size": 238462, + "subdir": "linux-64", + "timestamp": 1511990190686, + "version": "0.15.0" + }, + "owslib-0.16.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=2.7,<2.8.0a0", + "python-dateutil >=1.5", + "pytz", + "requests >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "8425262d7a95fe90753deb56868aeba8", + "name": "owslib", + "sha256": "c1fd97c84ac5e87a9b8239ab11f78cdb5f7c127b379d57c2408d433d8dd973cf", + "size": 233343, + "subdir": "linux-64", + "timestamp": 1519484579159, + "version": "0.16.0" + }, + "owslib-0.16.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=3.5,<3.6.0a0", + "python-dateutil >=1.5", + "pytz", + "requests >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "c181f60e2fd4041a90e11379723bc050", + "name": "owslib", + "sha256": "0bfd6f16ac27c26ceb6bf9982d3dd4018756db476e65bb66a5014669eb865827", + "size": 244478, + "subdir": "linux-64", + "timestamp": 1519484606194, + "version": "0.16.0" + }, + "owslib-0.16.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=3.6,<3.7.0a0", + "python-dateutil >=1.5", + "pytz", + "requests >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "46aa22ce758e0d0a843a4e4079c46a71", + "name": "owslib", + "sha256": "8a953e2d25c37403d601206d9209016e4330a880cf400d460569d64024f3cd1f", + "size": 240562, + "subdir": "linux-64", + "timestamp": 1519484540543, + "version": "0.16.0" + }, + "owslib-0.16.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=3.7,<3.8.0a0", + "python-dateutil >=1.5", + "pytz", + "requests >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "e1db85ea53100170e8fbcf80f1f5a782", + "name": "owslib", + "sha256": "c8ecd9ad9b9d4a4c6b319b52779e392c68b92ff670c3236400d8403296505098", + "size": 243400, + "subdir": "linux-64", + "timestamp": 1530811367806, + "version": "0.16.0" + }, + "owslib-0.17.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=2.7,<2.8.0a0", + "python-dateutil >=1.5", + "pytz", + "requests >=1.0" + ], + "license": "BSD-3-Clause", + "md5": "a96948c50da839e277105d269c9329d6", + "name": "owslib", + "sha256": "ddb1d02aa0ea224236da352d0a3317c99b07ac1680ed4158a37818dcc3f1e62f", + "size": 272987, + "subdir": "linux-64", + "timestamp": 1539655659457, + "version": "0.17.0" + }, + "owslib-0.17.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=3.6,<3.7.0a0", + "python-dateutil >=1.5", + "pytz", + "requests >=1.0" + ], + "license": "BSD-3-Clause", + "md5": "72e87425032a7b17ca92445649fd985f", + "name": "owslib", + "sha256": "6bd4685eab107fb2652d898ba5f1d65ed02658342fe2700b6aecc2814e3f9748", + "size": 282267, + "subdir": "linux-64", + "timestamp": 1539655681616, + "version": "0.17.0" + }, + "owslib-0.17.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=3.7,<3.8.0a0", + "python-dateutil >=1.5", + "pytz", + "requests >=1.0" + ], + "license": "BSD-3-Clause", + "md5": "59ecdbf16376ffca56b008ba646f8e0a", + "name": "owslib", + "sha256": "48657f7c02d02c039b8c740bc532b07563b77ae7802c4bc2eb5b98868713d4fb", + "size": 282704, + "subdir": "linux-64", + "timestamp": 1539655695903, + "version": "0.17.0" + }, + "p7zip-16.02-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "LGPL-2.0-or-later AND LicenseRef-scancode-rar-winrar-eula", + "license_family": "Other", + "md5": "87739026b89f1cf9adef8cea594a8658", + "name": "p7zip", + "sha256": "f4f72778b9e34f19a507c4c6808a745054624f5bbe14cf389601a7851f4ddf69", + "size": 2236910, + "subdir": "linux-64", + "timestamp": 1668093866783, + "version": "16.02" + }, + "packaging-16.8-py27h5e07c7c_1.tar.bz2": { + "build": "py27h5e07c7c_1", + "build_number": 1, + "depends": [ + "pyparsing", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "26f1db62d4d081cda64f1f086a7e991e", + "name": "packaging", + "sha256": "3d9b9bb7c42ccadd71c4024dffbb4b65ce4fb18006b83367bdb5e26b73efc7bc", + "size": 31377, + "subdir": "linux-64", + "timestamp": 1505747167646, + "version": "16.8" + }, + "packaging-16.8-py35h2260b46_1.tar.bz2": { + "build": "py35h2260b46_1", + "build_number": 1, + "depends": [ + "pyparsing", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "66cba2e2e0dc74f2cc5505d4d2f544a2", + "name": "packaging", + "sha256": "1464e7830449815b6b2e0b74f1c9b21b691b29e8fbe3bb7e36bc4ad524ce3e3e", + "size": 32298, + "subdir": "linux-64", + "timestamp": 1505747180870, + "version": "16.8" + }, + "packaging-16.8-py36ha668100_1.tar.bz2": { + "build": "py36ha668100_1", + "build_number": 1, + "depends": [ + "pyparsing", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "c3b77ede6ee2a065699a350bed1b22bd", + "name": "packaging", + "sha256": "af58bd91c06b6172827133805484a2c62d81cbac609ce1d998a45dc425d19479", + "size": 32169, + "subdir": "linux-64", + "timestamp": 1505747194122, + "version": "16.8" + }, + "packaging-17.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "25595364da59aafd318135621f39ed18", + "name": "packaging", + "sha256": "9b87f400db92ed5d3461fa2c40a3f2522a7d7063f848b59636caeac758f1f062", + "size": 32748, + "subdir": "linux-64", + "timestamp": 1520366655881, + "version": "17.1" + }, + "packaging-17.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "8fc441ee6cada7e2542f49982fdc32a6", + "name": "packaging", + "sha256": "383528a31be4b827fc91dc7b969822b7dc53e70169c47b6e5a7671ac03a5283b", + "size": 33659, + "subdir": "linux-64", + "timestamp": 1520366661130, + "version": "17.1" + }, + "packaging-17.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "121bc6fc88628810b99e006a0499ba55", + "name": "packaging", + "sha256": "9620ac420f36a922672b4b6892c70a15cc8fc8cc50eaa6a757b5102f894fd2c2", + "size": 33546, + "subdir": "linux-64", + "timestamp": 1520366670313, + "version": "17.1" + }, + "packaging-17.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "5e2494e1b5653a92ebba48b513f25647", + "name": "packaging", + "sha256": "1c5371ccaf0cb259533d9859e7cc8e3b39517055bf2c6e9bff635fe5e17bfa00", + "size": 33889, + "subdir": "linux-64", + "timestamp": 1530694961123, + "version": "17.1" + }, + "packaging-18.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "d6b333369d6831c8c9f38a95dc77c38f", + "name": "packaging", + "sha256": "93957889a5edfbdb3ee96cd333cbbbfddc0c4d2ecbc2a30cd7197c36f5ac5864", + "size": 33329, + "subdir": "linux-64", + "timestamp": 1538580176942, + "version": "18.0" + }, + "packaging-18.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "ca43c5fe867345051a3f9507c03d6992", + "name": "packaging", + "sha256": "19ac29f7650244bed1d24a3f99aef02c1db3a6c737442b915cbd029893b0d533", + "size": 34151, + "subdir": "linux-64", + "timestamp": 1538580176512, + "version": "18.0" + }, + "packaging-18.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "cf0163305375b33a433a2ba30b6a2d12", + "name": "packaging", + "sha256": "77d28df99ebbdd2f14191e2c94eef6424fb92db9a14438fd6b608225730dcd73", + "size": 34156, + "subdir": "linux-64", + "timestamp": 1538580155562, + "version": "18.0" + }, + "packaging-19.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "b6a12a51bd79980bc2e4b90c31882339", + "name": "packaging", + "sha256": "c1addb38772b504b826cde1145f38d93864080d0c817e548b1357a4757e29e47", + "size": 37753, + "subdir": "linux-64", + "timestamp": 1549321738149, + "version": "19.0" + }, + "packaging-19.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "997388f594abc2b0cc629f77b3ff51fb", + "name": "packaging", + "sha256": "ef334466a277a52cdd541f026fc7a1cf982be4c7bd6c67e8e2072c4bba8f7a93", + "size": 38552, + "subdir": "linux-64", + "timestamp": 1549321777314, + "version": "19.0" + }, + "packaging-19.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "4524096123330d184e6ed190719f6da2", + "name": "packaging", + "sha256": "1e3cb95706a4479245cddb2c31033978929402f6973605d15a1739aea710280e", + "size": 38581, + "subdir": "linux-64", + "timestamp": 1549321715241, + "version": "19.0" + }, + "packaging-19.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "8ff6cdfd256e3b35ea567ddd49b1223b", + "name": "packaging", + "sha256": "e789afcc9a3140cc1b3a94053b906ea41fffad18b6c67c4d828cd6e6b7565602", + "size": 46299, + "subdir": "linux-64", + "timestamp": 1565898857152, + "version": "19.1" + }, + "packaging-19.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "1a390919e716e79940d6321f7312f6ad", + "name": "packaging", + "sha256": "b0ea016ac41481f63f948e3805c6faece0a4d2d137dc4638c250e1405997a880", + "size": 47057, + "subdir": "linux-64", + "timestamp": 1565898810376, + "version": "19.1" + }, + "packaging-19.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "8b0da651af05bb9ef82851da161a919b", + "name": "packaging", + "sha256": "7979e1caacd017043fc8af4396145d815a7aeace7bebefc73263d4d1e35d5d67", + "size": 47060, + "subdir": "linux-64", + "timestamp": 1565898790660, + "version": "19.1" + }, + "packaging-22.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 or BSD-2-Clause", + "license_family": "Apache", + "md5": "4919603e33bc33d6a1d06007121b9ea4", + "name": "packaging", + "sha256": "f93d69743ae545ae1d3d9de7d230a5f65e495e1f072b7c562c98e12c45b9e4e9", + "size": 65107, + "subdir": "linux-64", + "timestamp": 1671697443717, + "version": "22.0" + }, + "packaging-22.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0 or BSD-2-Clause", + "license_family": "Apache", + "md5": "6f869af2d84bd6ef3bc8b89098c602ef", + "name": "packaging", + "sha256": "a8433ca266ef9365e9326b4d726df8af7e89967da2ac792128761b57922cd0eb", + "size": 83784, + "subdir": "linux-64", + "timestamp": 1676822659145, + "version": "22.0" + }, + "packaging-22.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 or BSD-2-Clause", + "license_family": "Apache", + "md5": "be1df6f6bd57e8cce809b4776c62105b", + "name": "packaging", + "sha256": "91abe4d20bc31279beb6dedd76b8811c9d4f9ad97e2e8c024a8cb97e7915d685", + "size": 64091, + "subdir": "linux-64", + "timestamp": 1671697469527, + "version": "22.0" + }, + "packaging-22.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 or BSD-2-Clause", + "license_family": "Apache", + "md5": "9b1bcda3c8207f773a80824daf68c3a5", + "name": "packaging", + "sha256": "75229c6ccc46f336773eaf32a41165fefeb36a28a08dc3a3cb818250ebd2d2df", + "size": 64348, + "subdir": "linux-64", + "timestamp": 1671697494995, + "version": "22.0" + }, + "packaging-22.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 or BSD-2-Clause", + "license_family": "Apache", + "md5": "44262604143262e2e1fe5962b427a969", + "name": "packaging", + "sha256": "0255fc3950d8ec2cf6ee414622ab6d684d289b180c1e6f211c8b9a9dfac573c3", + "size": 64318, + "subdir": "linux-64", + "timestamp": 1671697520700, + "version": "22.0" + }, + "packaging-23.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 or BSD-2-Clause", + "license_family": "Apache", + "md5": "b63140e9c01861d01643acde9e2fd0f6", + "name": "packaging", + "sha256": "7681359f2f9b695921c29ac8b9f1f498f89f9aac7a60e8d2bfc1afbb5930836d", + "size": 65759, + "subdir": "linux-64", + "timestamp": 1678965365352, + "version": "23.0" + }, + "packaging-23.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0 or BSD-2-Clause", + "license_family": "Apache", + "md5": "ce5dbdc15e0ed3aa4fbd2798cc985e72", + "name": "packaging", + "sha256": "037973adc6fcb3db1d988d92186e996f7b303347dd8afa582011e11554530bb2", + "size": 84168, + "subdir": "linux-64", + "timestamp": 1678965391422, + "version": "23.0" + }, + "packaging-23.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 or BSD-2-Clause", + "license_family": "Apache", + "md5": "8dcd23e822b7a8885b694185f2fc9c2d", + "name": "packaging", + "sha256": "f38d224847ff6e6362b3936dbc8f7f559360b0706a72f907d3a77b92b14ac601", + "size": 65042, + "subdir": "linux-64", + "timestamp": 1678965417418, + "version": "23.0" + }, + "packaging-23.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 or BSD-2-Clause", + "license_family": "Apache", + "md5": "5273c8a11efdb3e93c666b97098db423", + "name": "packaging", + "sha256": "e958083568fef0139a309379485feb67e5ade4ebe33f8e62b51c1f76df73c225", + "size": 65128, + "subdir": "linux-64", + "timestamp": 1678965339154, + "version": "23.0" + }, + "pamela-0.3.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "4c273af4f004fd53935976bcafbfa18b", + "name": "pamela", + "sha256": "0286f2bf7fa8b3f09557e97dadd2702e1656d98313b7366170bcb6197713d2c5", + "size": 14601, + "subdir": "linux-64", + "timestamp": 1540558189653, + "version": "0.3.0" + }, + "pamela-0.3.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d3c6d9b55e79038e72577385c8fce7f0", + "name": "pamela", + "sha256": "3d04dd9b672e50c394953322ca770896ad9830d7137d091e12fd1a1c2362f31c", + "size": 14832, + "subdir": "linux-64", + "timestamp": 1540558210176, + "version": "0.3.0" + }, + "pamela-0.3.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6970362dc3ceb44252bb858bc2cd41cb", + "name": "pamela", + "sha256": "0b8fa22ede7a5024132b0591a1b05b2e813156898313bef523a13367ead79142", + "size": 14822, + "subdir": "linux-64", + "timestamp": 1540558191399, + "version": "0.3.0" + }, + "pandarallel-1.6.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.1", + "pandas >=1", + "psutil", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "73fcaf7b651a6433505a1871c51405b8", + "name": "pandarallel", + "sha256": "db1429761d9df6d04951ef28334ad9d0cf9b703003671549c6806362a81bb134", + "size": 32557, + "subdir": "linux-64", + "timestamp": 1674548655076, + "version": "1.6.4" + }, + "pandarallel-1.6.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.1", + "pandas >=1", + "psutil", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4b00d07c88bdd834fe33f6fd204f9777", + "name": "pandarallel", + "sha256": "d444a568a02ae4242626881f4677840cd21d967af062dac7750974cf642dd209", + "size": 42608, + "subdir": "linux-64", + "timestamp": 1676860272705, + "version": "1.6.4" + }, + "pandarallel-1.6.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.1", + "pandas >=1", + "psutil", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c659f41b0bda51dff2511502eb5c2ce4", + "name": "pandarallel", + "sha256": "68f750deeff83c9312a773b717fe31bbbe871d211ff7036bd5819ddbd19b35fa", + "size": 31749, + "subdir": "linux-64", + "timestamp": 1674548607203, + "version": "1.6.4" + }, + "pandarallel-1.6.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.1", + "pandas >=1", + "psutil", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "248e008f24ae94863b9c80f3de486fee", + "name": "pandarallel", + "sha256": "ec3c1b09a09470a3fb73bbca3e49647bc4e7e77f510c09ce533a210def2467e0", + "size": 32052, + "subdir": "linux-64", + "timestamp": 1674548505846, + "version": "1.6.4" + }, + "pandarallel-1.6.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.1", + "pandas >=1", + "psutil", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "01b220198167f318bddef4ef59b49569", + "name": "pandarallel", + "sha256": "81e46dc8c7c848f5da86e4f3ecd6ddf082f69e458ba918e02b16bd9089bd6b85", + "size": 32158, + "subdir": "linux-64", + "timestamp": 1674548558152, + "version": "1.6.4" + }, + "pandas-0.20.3-py27h820b67f_2.tar.bz2": { + "build": "py27h820b67f_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "d846c5f62fc49e97f22dfe51a9b17628", + "name": "pandas", + "sha256": "1c43975536b0fd3b04ab468a32e7f2823acb4235e6026c00d723975c39a30f5a", + "size": 10327696, + "subdir": "linux-64", + "timestamp": 1505726159262, + "version": "0.20.3" + }, + "pandas-0.20.3-py27hfd1eabf_2.tar.bz2": { + "build": "py27hfd1eabf_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "7c050051003515bd6698967ad50fc148", + "name": "pandas", + "sha256": "62d37a6bbb6bcb04a691928601cd9adc20849c077fe3d8ae230f119eadba444f", + "size": 10327716, + "subdir": "linux-64", + "timestamp": 1509790431578, + "version": "0.20.3" + }, + "pandas-0.20.3-py35h85c2c75_2.tar.bz2": { + "build": "py35h85c2c75_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "c89314b67e05fdfe859419e0335c61d3", + "name": "pandas", + "sha256": "de4ae420a46f771cc6487cd66ef3ddddcb244a4345a7d674c6044c84a16e8298", + "size": 10287928, + "subdir": "linux-64", + "timestamp": 1505726630344, + "version": "0.20.3" + }, + "pandas-0.20.3-py35hd2a53da_2.tar.bz2": { + "build": "py35hd2a53da_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "ed43297476d5d65974c7bbcdb8ceefeb", + "name": "pandas", + "sha256": "d6cef464371239bd9e0a86ee4e4c34f5a3c2ea86b82c056fb2cfd7fafc231640", + "size": 10288376, + "subdir": "linux-64", + "timestamp": 1509790912478, + "version": "0.20.3" + }, + "pandas-0.20.3-py36h6022372_2.tar.bz2": { + "build": "py36h6022372_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "71bfcd00194038cc0194da73c592421e", + "name": "pandas", + "sha256": "a8c6833f95ffd7419bcef579b69b2d9c487f45a5e3e7d4357d6cbfe1d537464a", + "size": 10344533, + "subdir": "linux-64", + "timestamp": 1509791421335, + "version": "0.20.3" + }, + "pandas-0.20.3-py36h842e28d_2.tar.bz2": { + "build": "py36h842e28d_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "1dec0c38ac0ee39d009e5e2b14de056f", + "name": "pandas", + "sha256": "a4eaa238eb5d14f9a584c3084594c1ada364ca790b59eb3eca239ab59b0a007c", + "size": 10345877, + "subdir": "linux-64", + "timestamp": 1505727113870, + "version": "0.20.3" + }, + "pandas-0.21.0-py27he307072_1.tar.bz2": { + "build": "py27he307072_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "e3d990e9d9a02ab26e27baef2ae052dc", + "name": "pandas", + "sha256": "9488b52877c74a67e925af25a53a09c254a505c4c13a55274fcf8b396e8b6675", + "size": 11010325, + "subdir": "linux-64", + "timestamp": 1509936158807, + "version": "0.21.0" + }, + "pandas-0.21.0-py35hee8c687_1.tar.bz2": { + "build": "py35hee8c687_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "d63b0bc3c6dce6a9585bcf012c006763", + "name": "pandas", + "sha256": "fd73b818f817bcc36d281eefbe99dccafc78dcaba3869b252dd2a7e5336fcbfa", + "size": 11048450, + "subdir": "linux-64", + "timestamp": 1509936147894, + "version": "0.21.0" + }, + "pandas-0.21.0-py36h78bd809_1.tar.bz2": { + "build": "py36h78bd809_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "8f3ec28b7308b6c3b418c45dbd2b95ba", + "name": "pandas", + "sha256": "ea85f701dbd043f2cdfdc27fe1c1149aec5225a2e4bf4213f97bfed4cc6d994d", + "size": 11120019, + "subdir": "linux-64", + "timestamp": 1509936175170, + "version": "0.21.0" + }, + "pandas-0.21.1-py27h38cdd7d_0.tar.bz2": { + "build": "py27h38cdd7d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "275cf3b278d5e313c3d4a15664a41ec0", + "name": "pandas", + "sha256": "2c7c241bc00ebebf64938551b7019081fa686fef1c33ea18f77db489b088fe36", + "size": 11021953, + "subdir": "linux-64", + "timestamp": 1513100665293, + "version": "0.21.1" + }, + "pandas-0.21.1-py35h20b78c2_0.tar.bz2": { + "build": "py35h20b78c2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "07bf38ba02eee60b8cbf9ea29c1fa635", + "name": "pandas", + "sha256": "85fad399c6111b4da2706aa506417f7d1389af25e6db5f74fb5aee7eea6317de", + "size": 11095516, + "subdir": "linux-64", + "timestamp": 1513100676956, + "version": "0.21.1" + }, + "pandas-0.21.1-py36h20b78c2_0.tar.bz2": { + "build": "py36h20b78c2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "f6517cd2c05cb5bdf2218853254a8521", + "name": "pandas", + "sha256": "7528aedab6abba9f43f8efc47f931babcbe88144bb4ba3ac58005287efa74951", + "size": 11163457, + "subdir": "linux-64", + "timestamp": 1513100703036, + "version": "0.21.1" + }, + "pandas-0.22.0-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "6be7e7fd037b19c48d5a0305e6f12a25", + "name": "pandas", + "sha256": "6a9f012cea739e66733071936c2d37a133def96612c92a1ef0811303c8414e48", + "size": 10976970, + "subdir": "linux-64", + "timestamp": 1514667573488, + "version": "0.22.0" + }, + "pandas-0.22.0-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "f361e1157ac24aa67c44944da0dcc1a9", + "name": "pandas", + "sha256": "01fbc37e35cafbd36af521a7312321ff46472219073e8ce31b0e1d05fe55dea1", + "size": 11121513, + "subdir": "linux-64", + "timestamp": 1514667587794, + "version": "0.22.0" + }, + "pandas-0.22.0-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "ef3840d0e79433294137c377dbcf0cde", + "name": "pandas", + "sha256": "c4374db7e3b38e9488768c18ff71bbc6c104ff9a764de08374cbf296f2272b65", + "size": 11161956, + "subdir": "linux-64", + "timestamp": 1514667404610, + "version": "0.22.0" + }, + "pandas-0.23.0-py27h637b7d7_0.tar.bz2": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "a40cc766f7b5cff70caec07f48e9c5e2", + "name": "pandas", + "sha256": "e3406c0f91368ed8b2500359d279c99fb38407e2dce58f5e4cd90e639a370de1", + "size": 12378862, + "subdir": "linux-64", + "timestamp": 1526491814198, + "version": "0.23.0" + }, + "pandas-0.23.0-py35h637b7d7_0.tar.bz2": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "1af775be5ac393287cdec84f3bbfa561", + "name": "pandas", + "sha256": "07aff1c6be4e1c2a7843fc3126dbd5376b4f390210128b2753f3197433e1d5ef", + "size": 12334564, + "subdir": "linux-64", + "timestamp": 1526491815687, + "version": "0.23.0" + }, + "pandas-0.23.0-py36h637b7d7_0.tar.bz2": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "3a26696abb706d4a3545acb8ae5a9d93", + "name": "pandas", + "sha256": "07df4e720a19c93e4bb94b817f1ee4f8f1eb5c4a9591969e8fdac7559171d3cb", + "size": 12424605, + "subdir": "linux-64", + "timestamp": 1526491828878, + "version": "0.23.0" + }, + "pandas-0.23.1-py27h637b7d7_0.tar.bz2": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "6efed2fdc8d9064794396b137cc9a321", + "name": "pandas", + "sha256": "4500b71eb45a93c13f2da23ef6b40121ea42a01cecfdc6b1a32b5ccbe249316a", + "size": 12409354, + "subdir": "linux-64", + "timestamp": 1528897380256, + "version": "0.23.1" + }, + "pandas-0.23.1-py35h637b7d7_0.tar.bz2": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "1747ed43ecaf916884a4bcc90aab05c8", + "name": "pandas", + "sha256": "3b996585359b2c0a5f1873b21bcd5f6e0711ec2df513135f0fe640e40249c5f8", + "size": 12340113, + "subdir": "linux-64", + "timestamp": 1528897408045, + "version": "0.23.1" + }, + "pandas-0.23.1-py36h637b7d7_0.tar.bz2": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "68f98193449c4b9ab874c8dab059a1d0", + "name": "pandas", + "sha256": "f60d73ad055b0a94794f8546838cc2f7446c9f1ac61d4bf62c38d4f1c74d0bbd", + "size": 12434504, + "subdir": "linux-64", + "timestamp": 1528897417163, + "version": "0.23.1" + }, + "pandas-0.23.2-py27h04863e7_0.tar.bz2": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "d7568062b1e855c0ca2c4f557bb2f5aa", + "name": "pandas", + "sha256": "21094599c0acb5788b351c16b2fc363f564309d77a4ed31cb5e69e03190eb72f", + "size": 10510415, + "subdir": "linux-64", + "timestamp": 1531087183978, + "version": "0.23.2" + }, + "pandas-0.23.2-py36h04863e7_0.tar.bz2": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "1adc0f5e53132a8de503cb523360a8e5", + "name": "pandas", + "sha256": "b18fd8c2100769b7e3d1b66537562a1a5cbfc619831f7fcf65e3e858442ebcc4", + "size": 10544429, + "subdir": "linux-64", + "timestamp": 1531087844536, + "version": "0.23.2" + }, + "pandas-0.23.2-py37h04863e7_0.tar.bz2": { + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "5317d6f21fcfd23255891d3df62cd678", + "name": "pandas", + "sha256": "1c19abf79c281b1cf148ea5b973e039170f5ef14ac28663efae762b9e6bb9113", + "size": 10517763, + "subdir": "linux-64", + "timestamp": 1531088501052, + "version": "0.23.2" + }, + "pandas-0.23.3-py27h04863e7_0.tar.bz2": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "b6cd74f9560fe52b7cbfad8387ce98d8", + "name": "pandas", + "sha256": "5157c7f80d9cf3b8fd8278190db70724011997e71923d3bd1647afbc3a4542a5", + "size": 10512477, + "subdir": "linux-64", + "timestamp": 1531786060347, + "version": "0.23.3" + }, + "pandas-0.23.3-py35h04863e7_0.tar.bz2": { + "build": "py35h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "d1e5c0f35aabb46c3c69d0960aa270e1", + "name": "pandas", + "sha256": "d3d0d7fec49dc00b1231f79fedb35b92514a445a95d486bcb5b651a3282b29d0", + "size": 10457429, + "subdir": "linux-64", + "timestamp": 1531785968368, + "version": "0.23.3" + }, + "pandas-0.23.3-py36h04863e7_0.tar.bz2": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "3c9c11731fa7f2c33a3e784fc0fb5787", + "name": "pandas", + "sha256": "7b6997027f15c3857577f214eee379d562e412e6e4a17cb0b380084766f93516", + "size": 10539308, + "subdir": "linux-64", + "timestamp": 1531786113306, + "version": "0.23.3" + }, + "pandas-0.23.3-py37h04863e7_0.tar.bz2": { + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "287fba833a100254ed8b0865133941c1", + "name": "pandas", + "sha256": "e20e55ced44ddcdf1ebbcada6f3469cf1e5d6ee09827080384497a4bbe34647f", + "size": 10509971, + "subdir": "linux-64", + "timestamp": 1531786074078, + "version": "0.23.3" + }, + "pandas-0.23.4-py27h04863e7_0.tar.bz2": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "9735dad69cf0ff7f4ce1a3fc70acb389", + "name": "pandas", + "sha256": "77a56d470ee32bdc36f3d43cafdf7af9cef7832224a6064b8313b5004d8fc8da", + "size": 10513183, + "subdir": "linux-64", + "timestamp": 1533666814551, + "version": "0.23.4" + }, + "pandas-0.23.4-py35h04863e7_0.tar.bz2": { + "build": "py35h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "b603fa5b109a826ee3568929f453fe64", + "name": "pandas", + "sha256": "5fc6ab323a5fd2fe3b6dddaf1a7cd67c8e54d451fa9f2a5ec72f78a64d563ab2", + "size": 10458767, + "subdir": "linux-64", + "timestamp": 1533666819351, + "version": "0.23.4" + }, + "pandas-0.23.4-py36h04863e7_0.tar.bz2": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "49f315ccb81f49260c21822ebe168a93", + "name": "pandas", + "sha256": "c988916bc46d506c46c4934768b5d0623a41f9bb5200dfe225d59958d2a652e3", + "size": 10548155, + "subdir": "linux-64", + "timestamp": 1533666327713, + "version": "0.23.4" + }, + "pandas-0.23.4-py37h04863e7_0.tar.bz2": { + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "ead8a7e78a594a4143a559a094ffa17a", + "name": "pandas", + "sha256": "54cc81194b20cbc6385b3aaa1d8f76fc1617d27096335937e0b8ea05b78e4acc", + "size": 10516618, + "subdir": "linux-64", + "timestamp": 1533666819586, + "version": "0.23.4" + }, + "pandas-0.24.0-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.12.1,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "15896568fd6796f25704a868f28be441", + "name": "pandas", + "sha256": "091c6a66df55b272311422321d49d81e07e8f3fd31223cf3ddd680a5a80f6c0d", + "size": 11437256, + "subdir": "linux-64", + "timestamp": 1548457280868, + "version": "0.24.0" + }, + "pandas-0.24.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.12.1,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "2125b28e03ca9f08a3f52fc168fa06ad", + "name": "pandas", + "sha256": "2426324fa0526f03f4eec103447834481421ef3c4f6a4709269bb74a88840d43", + "size": 11612490, + "subdir": "linux-64", + "timestamp": 1548457329616, + "version": "0.24.0" + }, + "pandas-0.24.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "d0140709b8834bd20d4c6f6c804d21e2", + "name": "pandas", + "sha256": "4b02b5225dac8a439b07e00077c6f61c60f7edeb0dd6ed3a5ec5d982baf5ac21", + "size": 11550921, + "subdir": "linux-64", + "timestamp": 1548457189389, + "version": "0.24.0" + }, + "pandas-0.24.1-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.12.1,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "500b18ba72e9f99cfffd90a36050ccc2", + "name": "pandas", + "sha256": "ec21131e889358b5012114ec9c600d1ad30218f1d48fdc9638435ae7e7ddc2fa", + "size": 11445171, + "subdir": "linux-64", + "timestamp": 1549300849344, + "version": "0.24.1" + }, + "pandas-0.24.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.12.1,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "1bcee72145a89cbee1127b541ac39c93", + "name": "pandas", + "sha256": "a1fdf41996eb462273b78a206def6043ce9d1c6407a8e4ae6ce5f32020ef5bb6", + "size": 11598414, + "subdir": "linux-64", + "timestamp": 1549301027196, + "version": "0.24.1" + }, + "pandas-0.24.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "e562a7442b525147f82bb192d6f0fb1d", + "name": "pandas", + "sha256": "c4e34d764440fcb29292509158adddf8b3c9f9229f51e0e3a08f4674a4f4ec02", + "size": 11566326, + "subdir": "linux-64", + "timestamp": 1549315967046, + "version": "0.24.1" + }, + "pandas-0.24.2-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.12.1,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "a034031f3680b9f57353d36b0e287a3d", + "name": "pandas", + "sha256": "b2f2c79c63babc5617c2ad83ee674052997068929fb3fcb91da1a3bef23cbb80", + "size": 11453501, + "subdir": "linux-64", + "timestamp": 1552578744199, + "version": "0.24.2" + }, + "pandas-0.24.2-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.12.1,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "6169715bc0066cd7691b7e803c5a16de", + "name": "pandas", + "sha256": "72c30a85642f766dd74b78a97ef61ad29ef32d4f8425de92329183cfd0942ffd", + "size": 11639609, + "subdir": "linux-64", + "timestamp": 1552578747529, + "version": "0.24.2" + }, + "pandas-0.24.2-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "804e8259f6978185149004270cb888ea", + "name": "pandas", + "sha256": "8c172d07738e997d1634e1994daf12350bbfb9f06f5d6206a14a854564599e9b", + "size": 11591072, + "subdir": "linux-64", + "timestamp": 1552578741555, + "version": "0.24.2" + }, + "pandas-0.25.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "f7a54c7ea32b360ad02b6ac4f2ab4096", + "name": "pandas", + "sha256": "7e92b22b52aa171ce7ec51afa264b2bf88de7e3535a7cda8de7368e4446e34a5", + "size": 11986533, + "subdir": "linux-64", + "timestamp": 1564515269660, + "version": "0.25.0" + }, + "pandas-0.25.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "5bd331585d87ba97dd4d042e8ec4d62a", + "name": "pandas", + "sha256": "dcb427ca6c0c9fce1b99c0618587310205678927dcaffa08a8620fc1a4cef608", + "size": 11928084, + "subdir": "linux-64", + "timestamp": 1564515534654, + "version": "0.25.0" + }, + "pandas-0.25.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "7fe525693c4b685ce425c441c310fcb7", + "name": "pandas", + "sha256": "ca89695e2c06be666e100b26cfc81d58c62cf8890b44a4a03fec333a03f110c0", + "size": 11987522, + "subdir": "linux-64", + "timestamp": 1566830699639, + "version": "0.25.1" + }, + "pandas-0.25.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "1c6e2ac6e49b35633d661238182bcf7c", + "name": "pandas", + "sha256": "ed24b16fdf8763a0bd8ad1a9ee21c5daf0a2491697c8903ae10497ed14839888", + "size": 11961543, + "subdir": "linux-64", + "timestamp": 1566830216094, + "version": "0.25.1" + }, + "pandas-0.25.2-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "738f454b34535f54a41cad197fa353ca", + "name": "pandas", + "sha256": "c5a0b9f9e9cd0166fa3865df2fe6da319ed7531f21706f1498f515f3f292da56", + "size": 12004789, + "subdir": "linux-64", + "timestamp": 1571668870283, + "version": "0.25.2" + }, + "pandas-0.25.2-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "66f5924cb296d89102d353a6f8206998", + "name": "pandas", + "sha256": "2e8eff504decc170acee615a1e5cf0826f8afad9e7396e2791e6d46189d6fa1e", + "size": 11980667, + "subdir": "linux-64", + "timestamp": 1571668951270, + "version": "0.25.2" + }, + "pandas-0.25.3-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "e2f58d27f2ef63ae74c51fdcd8bc5d23", + "name": "pandas", + "sha256": "c155edfa0c09c4eddca5a636448c14052e668cfeb671698dd3e248974b9ca0cd", + "size": 12015369, + "subdir": "linux-64", + "timestamp": 1573939970712, + "version": "0.25.3" + }, + "pandas-0.25.3-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "53d730f78f37ae23a1ab890c55fc7964", + "name": "pandas", + "sha256": "837d7ebe832e3b30cb1d4b930edd34477e96bb93b7c657484e9bf554340aa7ec", + "size": 11984537, + "subdir": "linux-64", + "timestamp": 1573939648528, + "version": "0.25.3" + }, + "pandas-0.25.3-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "64a49b81780a6c18a0e1199d2bf8e234", + "name": "pandas", + "sha256": "169b1a354767aeb91d39062d4d2070b7f5eba0004401ca46ea2d2784f2a01574", + "size": 12408039, + "subdir": "linux-64", + "timestamp": 1574355206652, + "version": "0.25.3" + }, + "pandas-1.0.0-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "bfbd56a317205be0ca62227b2b8d6e3d", + "name": "pandas", + "sha256": "e81ca2e18d3f8fd1e91364ac2b4732d1d388a39ec8af4ae8e37fb24415b1e1b4", + "size": 11642328, + "subdir": "linux-64", + "timestamp": 1580340113810, + "version": "1.0.0" + }, + "pandas-1.0.0-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "d105d40f033d3ec153291ccd89217c81", + "name": "pandas", + "sha256": "722b3dd1f41d462dd6287093114e164febfe6910407d013988017a7fa3086562", + "size": 11623077, + "subdir": "linux-64", + "timestamp": 1580340387906, + "version": "1.0.0" + }, + "pandas-1.0.0-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "699005685415b76623a7959e65dfce76", + "name": "pandas", + "sha256": "41dddb019a4718d3c80bce19428ebe4216c69dfb2f23df53fbd44efebb9ced2c", + "size": 11968471, + "subdir": "linux-64", + "timestamp": 1580340413520, + "version": "1.0.0" + }, + "pandas-1.0.1-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "dfa942ca0af09756046c2fc8bb7380f7", + "name": "pandas", + "sha256": "21922d51237c1267e8d9f662d8f161aad46da453cf35edb71b40f047b4bef65d", + "size": 11663872, + "subdir": "linux-64", + "timestamp": 1581352600432, + "version": "1.0.1" + }, + "pandas-1.0.1-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "1f8c62fe8c559fad1aa835bca956fc4b", + "name": "pandas", + "sha256": "b01cde208048cfb6f6bb64e23b2e1febfb49ee83d253bdcc04a9668efaeaeb45", + "size": 11645837, + "subdir": "linux-64", + "timestamp": 1581355941398, + "version": "1.0.1" + }, + "pandas-1.0.1-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "1a76a59bfeac2ccb04047dfc379a5067", + "name": "pandas", + "sha256": "0a21ea96bcd5d612fd5774b12b6cc4d1afbd9f4774e7cf0221688bd91d8c51c2", + "size": 11972201, + "subdir": "linux-64", + "timestamp": 1581352573955, + "version": "1.0.1" + }, + "pandas-1.0.2-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "ca96fbfdc5d030fa669d640c4c6bc9fd", + "name": "pandas", + "sha256": "a643ab7d1d317e41d466377f192a05344b92ec9d0a7373a4d68fb69f8fb77e56", + "size": 11685627, + "subdir": "linux-64", + "timestamp": 1584457653469, + "version": "1.0.2" + }, + "pandas-1.0.2-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "bc9596eeb508538d7751ac8f390dd2c8", + "name": "pandas", + "sha256": "f469d8536e7ab664678972e9f7042bc241ffcfde97e0f2df43fd90c4920295b5", + "size": 11643687, + "subdir": "linux-64", + "timestamp": 1584457796445, + "version": "1.0.2" + }, + "pandas-1.0.2-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "1e419d3e09d5dad57bba388c87cb269d", + "name": "pandas", + "sha256": "d27e89ee8a86a319d4c4a9ed288c4ca2c3dfa94acd6c3985a014b3d94cfa2454", + "size": 12023618, + "subdir": "linux-64", + "timestamp": 1584457660255, + "version": "1.0.2" + }, + "pandas-1.0.3-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "c76a5fc6d0586e19f2bcd10677af484c", + "name": "pandas", + "sha256": "6e674f78e97363ee5cc37cb677aa1c967e6b03ea5405c48ceebbe5a3d1be8ba0", + "size": 11672641, + "subdir": "linux-64", + "timestamp": 1584976709198, + "version": "1.0.3" + }, + "pandas-1.0.3-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "2aa8f49f94d28fac95b5a2cb27680a44", + "name": "pandas", + "sha256": "64c7443d4de4d7827aaba99807e2e4a3bea6bfe7490bae1f13b39a0d7cc5f102", + "size": 11653983, + "subdir": "linux-64", + "timestamp": 1584976707684, + "version": "1.0.3" + }, + "pandas-1.0.3-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "6ed1100f6ce0f045aeb464bce185e614", + "name": "pandas", + "sha256": "79bea200183a04d8123cafcbd7ab33a349749e71c844385b7ea97d29abc793b9", + "size": 12035170, + "subdir": "linux-64", + "timestamp": 1584976788170, + "version": "1.0.3" + }, + "pandas-1.0.4-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "258c1ceabea9fe10d304afafd15f8a53", + "name": "pandas", + "sha256": "be941474bc270efab5f1f8285b252acae47c561fbdb970da94ae39be39de0515", + "size": 11657867, + "subdir": "linux-64", + "timestamp": 1592321713322, + "version": "1.0.4" + }, + "pandas-1.0.4-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "f755eb822c7a854c2406bde75067384d", + "name": "pandas", + "sha256": "d704fe032ecc705789c65d536b2dba435df7145e5ec6b6a5ad5c897b2a987a74", + "size": 11671173, + "subdir": "linux-64", + "timestamp": 1592321705109, + "version": "1.0.4" + }, + "pandas-1.0.4-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "e7bb65a417206ed8c32584174834e1b7", + "name": "pandas", + "sha256": "5607e91414513869bccb28506f24442887b965729ddb2d61c7280cd62172f8fc", + "size": 12042838, + "subdir": "linux-64", + "timestamp": 1592321709740, + "version": "1.0.4" + }, + "pandas-1.0.5-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "63ea0bf89c8ebc021c8d89f84be6d85c", + "name": "pandas", + "sha256": "4359988bf6e5aaa3cc03c72d83f4bdce0c87a1f5003de1a034c66e857647d9cf", + "size": 10610763, + "subdir": "linux-64", + "timestamp": 1592842330819, + "version": "1.0.5" + }, + "pandas-1.0.5-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "0777f55a644b4f7f71ac0a4fd7469e59", + "name": "pandas", + "sha256": "40007cc960a83833ffc454fb13d2c5ef13a6514dad63ef75feab2c94648c3b2d", + "size": 10603525, + "subdir": "linux-64", + "timestamp": 1592842287392, + "version": "1.0.5" + }, + "pandas-1.0.5-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "065249717a7606ecc7cecab8f70bb470", + "name": "pandas", + "sha256": "1ded7ca41b80907c1faf8241d23f6b62aa3861d8ecb7f3f02580767542dd76f5", + "size": 10988384, + "subdir": "linux-64", + "timestamp": 1592842302472, + "version": "1.0.5" + }, + "pandas-1.1.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "da45992a0f5d39df27ef960fae6a791d", + "name": "pandas", + "sha256": "d35851b733d082190028b821409303e6de7f77c249cbfa7f6bc2709fffef9d78", + "size": 11052406, + "subdir": "linux-64", + "timestamp": 1596826510442, + "version": "1.1.0" + }, + "pandas-1.1.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "8e6b13c18531c959de7a7ef6dd453ec4", + "name": "pandas", + "sha256": "7002bf7a473b924ec3959968b52ca8e7acea96286a7d4bf03c93c0a94529aa6a", + "size": 11036060, + "subdir": "linux-64", + "timestamp": 1596826453837, + "version": "1.1.0" + }, + "pandas-1.1.0-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "fea2a483710cae18d55be11b1c2c507d", + "name": "pandas", + "sha256": "f228e209578b94b15e0f0571edc683d640053fae7c6b0e58e1ca3defb6a12e3f", + "size": 11405877, + "subdir": "linux-64", + "timestamp": 1596826504079, + "version": "1.1.0" + }, + "pandas-1.1.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "a234823fc3b6ca9f02c216aab4468622", + "name": "pandas", + "sha256": "777804c244ceecb07a2482979dadb92da8d9cc693c3e0ecbaa18be08dbba4e6a", + "size": 11041557, + "subdir": "linux-64", + "timestamp": 1598372172205, + "version": "1.1.1" + }, + "pandas-1.1.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "83ce4da029a31e14021244b295985900", + "name": "pandas", + "sha256": "41a52f9567a74068fcdfc865f73aa72b9026b29ba5dec69aee812683be5e91cc", + "size": 11038522, + "subdir": "linux-64", + "timestamp": 1598372242604, + "version": "1.1.1" + }, + "pandas-1.1.1-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "59cbe3ee7d9f51bbfd3e8c3e1616f955", + "name": "pandas", + "sha256": "308b3380a3d3393534aaf5884a5a2c6b4343696adcb5e22eedfa651615edddc1", + "size": 11402583, + "subdir": "linux-64", + "timestamp": 1598372147405, + "version": "1.1.1" + }, + "pandas-1.1.2-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "11379c984b477ca471b40bec2fd60596", + "name": "pandas", + "sha256": "40f32a072215b6d2a39e0903086a28275e6a3c855f76bb1d0fe46ff4f61031a2", + "size": 11033395, + "subdir": "linux-64", + "timestamp": 1601567910257, + "version": "1.1.2" + }, + "pandas-1.1.2-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "55575685e74dbe6d5720b35ec016f18b", + "name": "pandas", + "sha256": "f7e52b3f1d6076d9e341b1a3f3a26b1e4fdefc0d82342e2562b65545e64bc663", + "size": 10993094, + "subdir": "linux-64", + "timestamp": 1601567896094, + "version": "1.1.2" + }, + "pandas-1.1.2-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "d42a4b6c3ef272aed3f5412245a525d1", + "name": "pandas", + "sha256": "6d4112a4414fa15ff1c506a5013b81d93c4fbaa8b3d69ca95ad8bce5864e335f", + "size": 11388324, + "subdir": "linux-64", + "timestamp": 1601567875750, + "version": "1.1.2" + }, + "pandas-1.1.3-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "93047c9082ccf41f8f89067797ebe129", + "name": "pandas", + "sha256": "c5bfe143f6bdbedd5b5100ec83c3de26e7e761f8ab26e3d77288a05ada49e48e", + "size": 11055983, + "subdir": "linux-64", + "timestamp": 1602088788707, + "version": "1.1.3" + }, + "pandas-1.1.3-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "f2c6216f19971c4f3905657c16f328a8", + "name": "pandas", + "sha256": "0e44cf5906597284b3c536ca9013c2c6667f4ed11f40ccee4fbc85754afa2c40", + "size": 11030309, + "subdir": "linux-64", + "timestamp": 1602088724846, + "version": "1.1.3" + }, + "pandas-1.1.3-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "e1008a89186024eac5aca09337b722a8", + "name": "pandas", + "sha256": "750762538dd1c9b1cdff07a4b8ee2b2e6058c207ef498b0a76d98dad98b05f70", + "size": 11404689, + "subdir": "linux-64", + "timestamp": 1602088720000, + "version": "1.1.3" + }, + "pandas-1.1.3-py39h31985d5_0.tar.bz2": { + "build": "py39h31985d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "6fa52ff670db41a21e10df9b8196213e", + "name": "pandas", + "sha256": "56924fb4692d0f64a07d24439de3ef457e2430d02311a38026a882f1b6b0f6e5", + "size": 11437525, + "subdir": "linux-64", + "timestamp": 1607707828292, + "version": "1.1.3" + }, + "pandas-1.1.5-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "bb067cc1845c066b7301b69532877869", + "name": "pandas", + "sha256": "4b6fa358d0bc34c24b574a8e7ee4d7f3741fb2a748e72849d248fa49f97e8859", + "size": 11013973, + "subdir": "linux-64", + "timestamp": 1608056777263, + "version": "1.1.5" + }, + "pandas-1.1.5-py36ha9443f7_0.tar.bz2": { + "build": "py36ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "4df0d2489ab1d8749b9c445309e43c18", + "name": "pandas", + "sha256": "1c8e056a02d8cf10c4b8bf9a2b09325da4150f05646a3269fe91b5bbd9262f26", + "size": 11024945, + "subdir": "linux-64", + "timestamp": 1608063725977, + "version": "1.1.5" + }, + "pandas-1.1.5-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "2b2d872542547d9be112c798f333334d", + "name": "pandas", + "sha256": "d7d6ce0c99ba6b9986dc525b64dfed5482d5ea0e8a81e24def9d1623ea3f0676", + "size": 11020039, + "subdir": "linux-64", + "timestamp": 1608056794708, + "version": "1.1.5" + }, + "pandas-1.1.5-py37ha9443f7_0.tar.bz2": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "6de4664b9490d13b51d89a8be75fa5f4", + "name": "pandas", + "sha256": "d7854ae2b88f798f7fd1f5b5b86f26b594de0e83c5324b1ac4ac9d005acfaa73", + "size": 10985730, + "subdir": "linux-64", + "timestamp": 1608063717675, + "version": "1.1.5" + }, + "pandas-1.1.5-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "83ba10a4d874b86229dca238cff54de4", + "name": "pandas", + "sha256": "b2deb8607c7abc0bbef6abbd19909b8e75c6a825d58d77b814fe72b4777bff67", + "size": 11376100, + "subdir": "linux-64", + "timestamp": 1608056834110, + "version": "1.1.5" + }, + "pandas-1.1.5-py38ha9443f7_0.tar.bz2": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "eb856541a365211bfb033782f5e25c2d", + "name": "pandas", + "sha256": "c0cb7221cdf0084d3b366690510f7a7ad6b4669fef60f2b7dbb1e83ab2e96744", + "size": 11375157, + "subdir": "linux-64", + "timestamp": 1608063718803, + "version": "1.1.5" + }, + "pandas-1.1.5-py39ha9443f7_0.tar.bz2": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "2e5347a9d4ec9805723f9a1bbf56e553", + "name": "pandas", + "sha256": "a7ad36dd269a03a05c8c8b0f3e2ef99549e3037c45112fd5c58a0c3dc4ebd944", + "size": 11362427, + "subdir": "linux-64", + "timestamp": 1608063705625, + "version": "1.1.5" + }, + "pandas-1.2.0-py37ha9443f7_0.tar.bz2": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "c77afcf595b3b6983409a8916368fe10", + "name": "pandas", + "sha256": "a9208b06f54074cbb9dab2bd5dd0d226bb82a8df3297a7bee3b715b7cc2d97d1", + "size": 11515520, + "subdir": "linux-64", + "timestamp": 1609008050945, + "version": "1.2.0" + }, + "pandas-1.2.0-py38ha9443f7_0.tar.bz2": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "2c883dbc04bb39c43059df90c512705b", + "name": "pandas", + "sha256": "6856fcb7cadc3c412a403fecd3fb2f94f1ef02ea0086d42560345113bf311a35", + "size": 11894761, + "subdir": "linux-64", + "timestamp": 1609008290138, + "version": "1.2.0" + }, + "pandas-1.2.0-py39ha9443f7_0.tar.bz2": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "e92203aa86513306d655ec1ed4472cff", + "name": "pandas", + "sha256": "ed9de0f9406eed33512237d6c50bf774f0a23f5c1a270f97f7036b604d6138ee", + "size": 11885969, + "subdir": "linux-64", + "timestamp": 1609862877025, + "version": "1.2.0" + }, + "pandas-1.2.1-py37ha9443f7_0.tar.bz2": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "87d647a98168917b88c12e1ee335adc1", + "name": "pandas", + "sha256": "34873f29e0d973d8f75b8be4378e10da36b1007283c567c5e26b73948924aa4f", + "size": 11492579, + "subdir": "linux-64", + "timestamp": 1611171734357, + "version": "1.2.1" + }, + "pandas-1.2.1-py38ha9443f7_0.tar.bz2": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "deb44bbb3910c306d4b998c6eb83fde9", + "name": "pandas", + "sha256": "6af449fbdc384ecf366415d180c06dfce3f7b83101158b60eb4cd70bc216f134", + "size": 11881789, + "subdir": "linux-64", + "timestamp": 1611171696418, + "version": "1.2.1" + }, + "pandas-1.2.1-py39ha9443f7_0.tar.bz2": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "67313901115949406dd251f27870c2e9", + "name": "pandas", + "sha256": "c07160813eef13615d8611eea46e4549de325fa93521f77145321e0bc4f9f11a", + "size": 11916666, + "subdir": "linux-64", + "timestamp": 1611243180289, + "version": "1.2.1" + }, + "pandas-1.2.2-py37ha9443f7_0.tar.bz2": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "b672088266fc4e25397cb94733ec2990", + "name": "pandas", + "sha256": "7ba4a81168e188f342b7f86a04271be30043fbc4db61fb648f1245ac0a4214a7", + "size": 11524711, + "subdir": "linux-64", + "timestamp": 1613685195915, + "version": "1.2.2" + }, + "pandas-1.2.2-py38ha9443f7_0.tar.bz2": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "07ef1f85fb1565110f8498698966e527", + "name": "pandas", + "sha256": "f6b19292a89fd1a316c4771ebc882ab052c9a8c05419f5ea7c9914b3782eef6d", + "size": 11890456, + "subdir": "linux-64", + "timestamp": 1613685218390, + "version": "1.2.2" + }, + "pandas-1.2.2-py39ha9443f7_0.tar.bz2": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "1bbf78c1a266a7bbaa9c99ff3da77320", + "name": "pandas", + "sha256": "64c953a68cdab3457a8c89be0ffa0c9d973f0a8e0dfd9aad09da4bdfd6846d0d", + "size": 11915187, + "subdir": "linux-64", + "timestamp": 1613685209438, + "version": "1.2.2" + }, + "pandas-1.2.3-py37ha9443f7_0.tar.bz2": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "b6a2657b26792e380ebb7f2c996c2897", + "name": "pandas", + "sha256": "ca0065418cd08f4556b4abd67691599e8fa9879772737e395e1afd28d7320fee", + "size": 11514781, + "subdir": "linux-64", + "timestamp": 1614711206706, + "version": "1.2.3" + }, + "pandas-1.2.3-py38ha9443f7_0.tar.bz2": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "d6585dacf7977f38994ae4f021f0cdab", + "name": "pandas", + "sha256": "40471836e75f76a35e0592d1e89645ea60c5322bc262c43b32b755b11515fee5", + "size": 11895447, + "subdir": "linux-64", + "timestamp": 1614711502960, + "version": "1.2.3" + }, + "pandas-1.2.3-py39ha9443f7_0.tar.bz2": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "770e0dc39cca114fd5c0a78dbd737ab5", + "name": "pandas", + "sha256": "ce22361ff5a4818053ba25c282f78b7c45fa5ef3a5fb832f21679c4b5fcfae33", + "size": 11919140, + "subdir": "linux-64", + "timestamp": 1614711479927, + "version": "1.2.3" + }, + "pandas-1.2.4-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "md5": "fff684066683e9f28db38a2a08ce412b", + "name": "pandas", + "sha256": "d94898dcff385a755796df9acf1318352c749ff31a731a38a6772b0e435bce83", + "size": 11521842, + "subdir": "linux-64", + "timestamp": 1618365739112, + "version": "1.2.4" + }, + "pandas-1.2.4-py37ha9443f7_0.tar.bz2": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "a194d05ce625c87ce142752acb18f445", + "name": "pandas", + "sha256": "86b6241f159861bf191771a1a4c97710323c6a212c4daf24d7ce740bf3e1c329", + "size": 11536632, + "subdir": "linux-64", + "timestamp": 1618261562729, + "version": "1.2.4" + }, + "pandas-1.2.4-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "md5": "b786700b4e23e10a099dd970be4b676b", + "name": "pandas", + "sha256": "912f93a9810d57a368d95dabfea64d60a54bf40bff5f333a2f0c2c681d3f35ad", + "size": 11874502, + "subdir": "linux-64", + "timestamp": 1618365707232, + "version": "1.2.4" + }, + "pandas-1.2.4-py38ha9443f7_0.tar.bz2": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "22162ae2e1dae6cdeb89767ea2ba153f", + "name": "pandas", + "sha256": "f27c04c35095e0b28363a464f553ab35d61b410556c4dc56f3624d2c9027f18b", + "size": 11918831, + "subdir": "linux-64", + "timestamp": 1618264582354, + "version": "1.2.4" + }, + "pandas-1.2.4-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "md5": "47ed9d1363e5b0a328aeeb79dfefa4be", + "name": "pandas", + "sha256": "727549f319e4ea4c05cb4cf40ba6eb7c28f41906bcd7cf490ede2fe9e7f3f169", + "size": 11907290, + "subdir": "linux-64", + "timestamp": 1618362639771, + "version": "1.2.4" + }, + "pandas-1.2.4-py39ha9443f7_0.tar.bz2": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "5d17d93dafac72423c7694f6c566f960", + "name": "pandas", + "sha256": "58c475f59c12b679d8f5ce34c0f88e8d93b60ea9c95ff919c88245ee363397f0", + "size": 11944304, + "subdir": "linux-64", + "timestamp": 1618264415749, + "version": "1.2.4" + }, + "pandas-1.2.5-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20.2,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "md5": "82d29491a096ee67d0f733a2d98244de", + "name": "pandas", + "sha256": "51cdf0ae10b64458da8d6e9546a80fb6ead22cedcbd03ab737cf63b089cf63a3", + "size": 11529805, + "subdir": "linux-64", + "timestamp": 1624383818563, + "version": "1.2.5" + }, + "pandas-1.2.5-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "md5": "ac471cb84661b1e404b4e5565768af67", + "name": "pandas", + "sha256": "a295b092551a39f4986ef0ac91d58a9457a8772eb83ac197512c19e797eaba6d", + "size": 11881460, + "subdir": "linux-64", + "timestamp": 1624383783215, + "version": "1.2.5" + }, + "pandas-1.2.5-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.6.8", + "numpy >=1.20.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "58489ffc1b33e139e8b58288eaee7aef", + "name": "pandas", + "sha256": "b38bcc8c988a92a0b207656757f93f9117b26c95209c25269aaa30758049718e", + "size": 11918579, + "subdir": "linux-64", + "timestamp": 1624465755690, + "version": "1.2.5" + }, + "pandas-1.3.0-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "constrains": [], + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.20.3,<2.0a0", + "python >=3.7.1,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ec1af8ae6b5dcdf212b096de685e4d05", + "name": "pandas", + "sha256": "9bccb83271337e700e8559725f87f9d05ff0859aab02e79237a90635d07fb915", + "size": 12486267, + "subdir": "linux-64", + "timestamp": 1626783937717, + "version": "1.3.0" + }, + "pandas-1.3.0-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "constrains": [], + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.20.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "da4cbb371c078b31ae6dd6d55f0cbe6f", + "name": "pandas", + "sha256": "19d272b1c3e093ebc4706cdf583a7f84afb7614a87787750d0e83e1322cd7b91", + "size": 12898739, + "subdir": "linux-64", + "timestamp": 1626777057769, + "version": "1.3.0" + }, + "pandas-1.3.0-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "constrains": [], + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.20.3,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4bdc82ea7d6a29377f8f151d75cdacb6", + "name": "pandas", + "sha256": "4175c17da73c624c844cac2b12d14fee83f5288dd8179c831a221bbbaf4b3a3b", + "size": 12929593, + "subdir": "linux-64", + "timestamp": 1626784423334, + "version": "1.3.0" + }, + "pandas-1.3.1-py37h8c16a72_0.tar.bz2": { + "build": "py37h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "33111fda5f1748069e1eb8e8cc829152", + "name": "pandas", + "sha256": "9164673547748f7ec168f96c9a4917a35ed3e1544aa7a5188f61a7739fb7fe09", + "size": 12492025, + "subdir": "linux-64", + "timestamp": 1627570482091, + "version": "1.3.1" + }, + "pandas-1.3.1-py38h8c16a72_0.tar.bz2": { + "build": "py38h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d77759efeeed6f0e78df50af18e0c6cd", + "name": "pandas", + "sha256": "c1b6b794cd70a6fe0e3eb1350aad6ea6ac1f903103710bdefeabd6c6718cbdf0", + "size": 12890674, + "subdir": "linux-64", + "timestamp": 1627562754555, + "version": "1.3.1" + }, + "pandas-1.3.1-py39h8c16a72_0.tar.bz2": { + "build": "py39h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "db69403bcc4b886496cb2e07a11269bd", + "name": "pandas", + "sha256": "68410d3c0d5eaccb34d3474a8daed6fedf4df8145aa6a287579ff1617f45ba08", + "size": 12887611, + "subdir": "linux-64", + "timestamp": 1627570429844, + "version": "1.3.1" + }, + "pandas-1.3.2-py37h8c16a72_0.tar.bz2": { + "build": "py37h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d3abbcd6c36f2b8968a52ec372408188", + "name": "pandas", + "sha256": "a14658ee17912d9a6028bdfe8bb4ea8e613d30803a4edbdcd75e7b8faeab3c68", + "size": 12479826, + "subdir": "linux-64", + "timestamp": 1629682488712, + "version": "1.3.2" + }, + "pandas-1.3.2-py38h8c16a72_0.tar.bz2": { + "build": "py38h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dba8e361823c652875b2046e337bc234", + "name": "pandas", + "sha256": "dca68b91e814c6837bf4b8d1ac75c99ae40683e16a1ab4c516ae0ec6a681112b", + "size": 12882255, + "subdir": "linux-64", + "timestamp": 1629673829678, + "version": "1.3.2" + }, + "pandas-1.3.2-py39h8c16a72_0.tar.bz2": { + "build": "py39h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c732322a6c481def08374c8f68b26c83", + "name": "pandas", + "sha256": "e4bc0a0856948e07fe12dee7394156db7bde50575c08e0204c3afb1cf7e88b32", + "size": 12912827, + "subdir": "linux-64", + "timestamp": 1629682619870, + "version": "1.3.2" + }, + "pandas-1.3.3-py37h8c16a72_0.tar.bz2": { + "build": "py37h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bca1635f07d443c6354fd158d67f1efc", + "name": "pandas", + "sha256": "d8ef59be141ed3a510be6ede53b05b56e2a874f32e4b558ea04926d5d577fb5a", + "size": 12493287, + "subdir": "linux-64", + "timestamp": 1632912537903, + "version": "1.3.3" + }, + "pandas-1.3.3-py38h8c16a72_0.tar.bz2": { + "build": "py38h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "db75a0cd4bb856c0cf3a4eea5314d408", + "name": "pandas", + "sha256": "6a273314ffa670fa0ac4e00782c5a525a915ec4c0303a0d4c54ce7566354b831", + "size": 12884815, + "subdir": "linux-64", + "timestamp": 1632924654473, + "version": "1.3.3" + }, + "pandas-1.3.3-py39h8c16a72_0.tar.bz2": { + "build": "py39h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b7e83664f9a46a6b40ade4722c15b5b5", + "name": "pandas", + "sha256": "a96edfdb989dbd90d171bfce52ec79899c6edc8c274fafd6bcb39be1e0f718be", + "size": 12888816, + "subdir": "linux-64", + "timestamp": 1632920172098, + "version": "1.3.3" + }, + "pandas-1.3.4-py37h8c16a72_0.tar.bz2": { + "build": "py37h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "681a45b7330cb4d509ab84dc05e139c4", + "name": "pandas", + "sha256": "963a031e72a3e832a61b4d1f78d6608d1a9dbeae9b3fd0840980dd08a6642788", + "size": 12484969, + "subdir": "linux-64", + "timestamp": 1635495066877, + "version": "1.3.4" + }, + "pandas-1.3.4-py38h8c16a72_0.tar.bz2": { + "build": "py38h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3dd70b3ddd1aaa2fd7ae28baa1ab2f1c", + "name": "pandas", + "sha256": "d822f08ccec3c122d70d4f69370328fa4acee41a0615a30e139ddf66867dd157", + "size": 12885251, + "subdir": "linux-64", + "timestamp": 1635506815901, + "version": "1.3.4" + }, + "pandas-1.3.4-py39h8c16a72_0.tar.bz2": { + "build": "py39h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e2dd5a141637373b7ba0186c2e4430ef", + "name": "pandas", + "sha256": "d2c62354e718d07b7b85471bd1960a62634c17fae55cbe9a4f75dba903fe76dd", + "size": 12918350, + "subdir": "linux-64", + "timestamp": 1635506799285, + "version": "1.3.4" + }, + "pandas-1.3.5-py37h8c16a72_0.tar.bz2": { + "build": "py37h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "40b907c9f7a0fa51d0d2f2f1e28ec5f0", + "name": "pandas", + "sha256": "dd688606bb0740691d8460168eba85ac5f04ac02087a32ba710d110f0ab6b57d", + "size": 12511779, + "subdir": "linux-64", + "timestamp": 1641461400562, + "version": "1.3.5" + }, + "pandas-1.3.5-py38h8c16a72_0.tar.bz2": { + "build": "py38h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e034743503afe301e28d05643bb703d7", + "name": "pandas", + "sha256": "782e43bce03c78e838b215bd1ddf1daa9358448fe19556ef6a33b3ac70fe6831", + "size": 12899827, + "subdir": "linux-64", + "timestamp": 1641461402605, + "version": "1.3.5" + }, + "pandas-1.3.5-py39h8c16a72_0.tar.bz2": { + "build": "py39h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "241b9c7efe66955ac6af7714ba9a54be", + "name": "pandas", + "sha256": "61a4b4a6c26def1038957d35968f7a46d830aa44cf76dd5d760bf04e48f19fa4", + "size": 12925559, + "subdir": "linux-64", + "timestamp": 1641467043208, + "version": "1.3.5" + }, + "pandas-1.4.1-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.1", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f1310ed259dc6cea4a6f13252428f27f", + "name": "pandas", + "sha256": "7944040f943d52aaa15013608e2ab3912dae43ca6665b1599fd91e88bef3ed4a", + "size": 35183781, + "subdir": "linux-64", + "timestamp": 1644984497698, + "version": "1.4.1" + }, + "pandas-1.4.1-py310h295c915_1.tar.bz2": { + "build": "py310h295c915_1", + "build_number": 1, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.1", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "518ce0705abd069f0ae507f1d95e7bf5", + "name": "pandas", + "sha256": "5ee68a87a0c3e5e7caf8519a2fd7c5dad0c6e59e5a431ea206ad6f0d686e774e", + "size": 35195412, + "subdir": "linux-64", + "timestamp": 1647937090026, + "version": "1.4.1" + }, + "pandas-1.4.1-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "81b8d4d9f6944363f96524d93c549bef", + "name": "pandas", + "sha256": "9cc041126ced9e8e4c8e5b261eeb2336082f126ef996b86ff476f7cbd67369c0", + "size": 13197581, + "subdir": "linux-64", + "timestamp": 1645002573229, + "version": "1.4.1" + }, + "pandas-1.4.1-py38h295c915_1.tar.bz2": { + "build": "py38h295c915_1", + "build_number": 1, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88985c41b2d176ac82174d205538e704", + "name": "pandas", + "sha256": "81f31abe0c2baf7d0d780377097698738c890b632cbc698b14cfa3a3685649ee", + "size": 13203843, + "subdir": "linux-64", + "timestamp": 1647937039276, + "version": "1.4.1" + }, + "pandas-1.4.1-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b54c389eccae35346377e53f57c6cede", + "name": "pandas", + "sha256": "0b2f49726aa76dc47019115ea7d6dae1122f7e86579b32b6b408141d3b81346c", + "size": 13235081, + "subdir": "linux-64", + "timestamp": 1645003633433, + "version": "1.4.1" + }, + "pandas-1.4.1-py39h295c915_1.tar.bz2": { + "build": "py39h295c915_1", + "build_number": 1, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7742ec92081867540ae238e7b61fdd56", + "name": "pandas", + "sha256": "6aef7b43dd6a8623ec12c5b33be1d9c0cd607db4dbebe752e7a8bfd6d3e6bbd1", + "size": 13200494, + "subdir": "linux-64", + "timestamp": 1647955127812, + "version": "1.4.1" + }, + "pandas-1.4.2-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.1", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "721ffb229e89749055bb7e11df71f93a", + "name": "pandas", + "sha256": "8b0a47627fdc2fd665e861a23ecd1b1f2abfde4fcfc17a0239c264e3da477946", + "size": 35190591, + "subdir": "linux-64", + "timestamp": 1650622912131, + "version": "1.4.2" + }, + "pandas-1.4.2-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4a328a03bb845af54566748b6a766806", + "name": "pandas", + "sha256": "85044491c56df3934c69d447311cfd65acc5c26980a6990811c60ddf92e352dd", + "size": 13219784, + "subdir": "linux-64", + "timestamp": 1650622643018, + "version": "1.4.2" + }, + "pandas-1.4.2-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "97ef7e1fe923d22a8e2307f3f39a92d5", + "name": "pandas", + "sha256": "e7a0abb0f00a94000876f2095f0cf531ad3803ffbd868a780b3f06816b54492c", + "size": 13221005, + "subdir": "linux-64", + "timestamp": 1650622404234, + "version": "1.4.2" + }, + "pandas-1.4.3-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.1", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5fa293bda4c08be17fe91e64c9306e20", + "name": "pandas", + "sha256": "c1ef808c29e3ff2700743cb55b17825dcd8b75eed44e466f13c72317d29faf94", + "size": 36964844, + "subdir": "linux-64", + "timestamp": 1657538987413, + "version": "1.4.3" + }, + "pandas-1.4.3-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c4b45b6d30ee9e80a51373e565e9dc46", + "name": "pandas", + "sha256": "16e2161ad548f9ec8a51a2ea9757002ebca47dd1f5420a6471c52502c7b4fe00", + "size": 13252137, + "subdir": "linux-64", + "timestamp": 1657538461962, + "version": "1.4.3" + }, + "pandas-1.4.3-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1bd58a0c08f2e66684eccb3eab870226", + "name": "pandas", + "sha256": "3392aa02ddabd54c77d880334becdb86b8476a85964058a99a64599629fc07a1", + "size": 13119905, + "subdir": "linux-64", + "timestamp": 1657538708888, + "version": "1.4.3" + }, + "pandas-1.4.4-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.1", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "10d9d389575ba38146940dc2e7e3a4de", + "name": "pandas", + "sha256": "46bf3fbab314cec693492bf30c5af972fd4ca7ee35ca24c0567a0732f7d61951", + "size": 36958563, + "subdir": "linux-64", + "timestamp": 1663773730637, + "version": "1.4.4" + }, + "pandas-1.4.4-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "99d5c57fa174a054ca27b0d5edb7b6e5", + "name": "pandas", + "sha256": "f907552884524270a12757e671f4dad0f0a00d59aeb8f2ee79bfb4c957c0c948", + "size": 13253665, + "subdir": "linux-64", + "timestamp": 1663773208909, + "version": "1.4.4" + }, + "pandas-1.4.4-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "52ab906448f09ab3f424ac156ade715e", + "name": "pandas", + "sha256": "35adc93d0fde9abfa7bcbaf68f024926031a6b05dcd7edfd83a7f6398c4d2843", + "size": 13151705, + "subdir": "linux-64", + "timestamp": 1663773447154, + "version": "1.4.4" + }, + "pandas-1.5.1-py310h1128e8f_0.tar.bz2": { + "build": "py310h1128e8f_0", + "build_number": 0, + "constrains": [ + "brotli >=0.7.0", + "numba >=0.53.1", + "tzdata >=2022a", + "blosc >=1.21.0", + "sqlalchemy >=1.4.16", + "matplotlib-base >=3.3.2", + "gcsfs >=2021.7.0", + "jinja2 >=3.0.0", + "pyxlsb >=1.0.8", + "beautifulsoup4 >=4.9.3", + "xlrd >=2.0.1", + "zstandard >=0.15.2", + "html5lib >=1.1", + "fastparquet >=0.4.0", + "scipy >=1.7.1", + "psycopg2 >=2.8.6", + "pymysql >=1.0.2", + "xlsxwriter >=1.4.3", + "pyreadstat >=1.1.2", + "s3fs >=2021.08.0", + "lxml >=4.6.3", + "pyarrow >=1.0.1", + "tabulate >=0.8.9", + "python-snappy >=0.6.0", + "pytables >=3.6.1", + "fsspec >=2021.7.0", + "xlwt >=1.3.0", + "pandas-gbq >=0.15.0", + "xarray >=0.19.0", + "openpyxl >=3.0.7" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.21,<2.0a0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2bb68ca985dd503eb2c2c0c3d7c78560", + "name": "pandas", + "sha256": "4feda84827cbfc600d8afe58571116e9c6eab9cb0e3f0386e2ace4327c8ccbf0", + "size": 13676095, + "subdir": "linux-64", + "timestamp": 1668628783900, + "version": "1.5.1" + }, + "pandas-1.5.1-py38h417a72b_0.tar.bz2": { + "build": "py38h417a72b_0", + "build_number": 0, + "constrains": [ + "brotli >=0.7.0", + "numba >=0.53.1", + "tzdata >=2022a", + "blosc >=1.21.0", + "sqlalchemy >=1.4.16", + "matplotlib-base >=3.3.2", + "gcsfs >=2021.7.0", + "jinja2 >=3.0.0", + "pyxlsb >=1.0.8", + "beautifulsoup4 >=4.9.3", + "xlrd >=2.0.1", + "zstandard >=0.15.2", + "html5lib >=1.1", + "fastparquet >=0.4.0", + "scipy >=1.7.1", + "psycopg2 >=2.8.6", + "pymysql >=1.0.2", + "xlsxwriter >=1.4.3", + "pyreadstat >=1.1.2", + "s3fs >=2021.08.0", + "lxml >=4.6.3", + "pyarrow >=1.0.1", + "tabulate >=0.8.9", + "python-snappy >=0.6.0", + "pytables >=3.6.1", + "fsspec >=2021.7.0", + "xlwt >=1.3.0", + "pandas-gbq >=0.15.0", + "xarray >=0.19.0", + "openpyxl >=3.0.7" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.16,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e19c9dc086e285465874255d38917cbe", + "name": "pandas", + "sha256": "5603af2d980a87dcef1671d50e326f9854cc50955fac3ec2f5f9c32b2efe28e9", + "size": 13901323, + "subdir": "linux-64", + "timestamp": 1668629301789, + "version": "1.5.1" + }, + "pandas-1.5.1-py39h417a72b_0.tar.bz2": { + "build": "py39h417a72b_0", + "build_number": 0, + "constrains": [ + "brotli >=0.7.0", + "numba >=0.53.1", + "tzdata >=2022a", + "blosc >=1.21.0", + "sqlalchemy >=1.4.16", + "matplotlib-base >=3.3.2", + "gcsfs >=2021.7.0", + "jinja2 >=3.0.0", + "pyxlsb >=1.0.8", + "beautifulsoup4 >=4.9.3", + "xlrd >=2.0.1", + "zstandard >=0.15.2", + "html5lib >=1.1", + "fastparquet >=0.4.0", + "scipy >=1.7.1", + "psycopg2 >=2.8.6", + "pymysql >=1.0.2", + "xlsxwriter >=1.4.3", + "pyreadstat >=1.1.2", + "s3fs >=2021.08.0", + "lxml >=4.6.3", + "pyarrow >=1.0.1", + "tabulate >=0.8.9", + "python-snappy >=0.6.0", + "pytables >=3.6.1", + "fsspec >=2021.7.0", + "xlwt >=1.3.0", + "pandas-gbq >=0.15.0", + "xarray >=0.19.0", + "openpyxl >=3.0.7" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.16,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "912ef32ffd41df82468b24f6c05c0fca", + "name": "pandas", + "sha256": "637ff40d4dcad3019832724e8db762542a214cc9123930f6037df5c5bcb4c7a3", + "size": 13758042, + "subdir": "linux-64", + "timestamp": 1668629820909, + "version": "1.5.1" + }, + "pandas-1.5.2-py310h1128e8f_0.tar.bz2": { + "build": "py310h1128e8f_0", + "build_number": 0, + "constrains": [ + "xlrd >=2.0.1", + "fsspec >=2021.7.0", + "pytables >=3.6.1", + "beautifulsoup4 >=4.9.3", + "psycopg2 >=2.8.6", + "numba >=0.53.1", + "pyarrow >=1.0.1", + "pyxlsb >=1.0.8", + "tabulate >=0.8.9", + "sqlalchemy >=1.4.16", + "xarray >=0.19.0", + "fastparquet >=0.4.0", + "html5lib >=1.1", + "jinja2 >=3.0.0", + "matplotlib-base >=3.3.2", + "blosc >=1.21.0", + "openpyxl >=3.0.7", + "xlsxwriter >=1.4.3", + "xlwt >=1.3.0", + "pyreadstat >=1.1.2", + "python-snappy >=0.6.0", + "brotli >=0.7.0", + "pymysql >=1.0.2", + "zstandard >=0.15.2", + "gcsfs >=2021.7.0", + "lxml >=4.6.3", + "scipy >=1.7.1", + "s3fs >=2021.08.0", + "pandas-gbq >=0.15.0", + "tzdata >=2022a" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.21,<2.0a0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e06883f2593b4e30b19f7e50c2ff27e9", + "name": "pandas", + "sha256": "45d496116d7c3c2e9a7d197c2de5abc5a0d5ffb598f0734b9058ba9040ca26be", + "size": 13661989, + "subdir": "linux-64", + "timestamp": 1670425513958, + "version": "1.5.2" + }, + "pandas-1.5.2-py311hba01205_0.tar.bz2": { + "build": "py311hba01205_0", + "build_number": 0, + "constrains": [ + "psycopg2 >=2.8.6", + "matplotlib-base >=3.3.2", + "lxml >=4.6.3", + "s3fs >=2021.08.0", + "pyxlsb >=1.0.8", + "tzdata >=2022a", + "pymysql >=1.0.2", + "beautifulsoup4 >=4.9.3", + "python-snappy >=0.6.0", + "xlsxwriter >=1.4.3", + "gcsfs >=2021.7.0", + "blosc >=1.21.0", + "scipy >=1.7.1", + "xlrd >=2.0.1", + "pytables >=3.6.1", + "tabulate >=0.8.9", + "xarray >=0.19.0", + "numba >=0.53.1", + "brotli >=0.7.0", + "fastparquet >=0.4.0", + "fsspec >=2021.7.0", + "jinja2 >=3.0.0", + "pandas-gbq >=0.15.0", + "zstandard >=0.15.2", + "xlwt >=1.3.0", + "html5lib >=1.1", + "pyarrow >=1.0.1", + "pyreadstat >=1.1.2", + "sqlalchemy >=1.4.16", + "openpyxl >=3.0.7" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.23,<2.0a0", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b29e15e989f5207f6750ac74dfb824b7", + "name": "pandas", + "sha256": "156358924f91d692f43618f7ad22877d22144e87764652434c25a7445dd71ce8", + "size": 16366386, + "subdir": "linux-64", + "timestamp": 1676828679137, + "version": "1.5.2" + }, + "pandas-1.5.2-py38h417a72b_0.tar.bz2": { + "build": "py38h417a72b_0", + "build_number": 0, + "constrains": [ + "xlrd >=2.0.1", + "fsspec >=2021.7.0", + "pytables >=3.6.1", + "beautifulsoup4 >=4.9.3", + "psycopg2 >=2.8.6", + "numba >=0.53.1", + "pyarrow >=1.0.1", + "pyxlsb >=1.0.8", + "tabulate >=0.8.9", + "sqlalchemy >=1.4.16", + "xarray >=0.19.0", + "fastparquet >=0.4.0", + "html5lib >=1.1", + "jinja2 >=3.0.0", + "matplotlib-base >=3.3.2", + "blosc >=1.21.0", + "openpyxl >=3.0.7", + "xlsxwriter >=1.4.3", + "xlwt >=1.3.0", + "pyreadstat >=1.1.2", + "python-snappy >=0.6.0", + "brotli >=0.7.0", + "pymysql >=1.0.2", + "zstandard >=0.15.2", + "gcsfs >=2021.7.0", + "lxml >=4.6.3", + "scipy >=1.7.1", + "s3fs >=2021.08.0", + "pandas-gbq >=0.15.0", + "tzdata >=2022a" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.16,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "78b2365d492243d91d81820024ee71c4", + "name": "pandas", + "sha256": "ca5ffd4acc13e48ff2e7b5b1dac06923f38c2d7c4c41e71685041e92873abf82", + "size": 13908909, + "subdir": "linux-64", + "timestamp": 1670426433193, + "version": "1.5.2" + }, + "pandas-1.5.2-py39h417a72b_0.tar.bz2": { + "build": "py39h417a72b_0", + "build_number": 0, + "constrains": [ + "xlrd >=2.0.1", + "fsspec >=2021.7.0", + "pytables >=3.6.1", + "beautifulsoup4 >=4.9.3", + "psycopg2 >=2.8.6", + "numba >=0.53.1", + "pyarrow >=1.0.1", + "pyxlsb >=1.0.8", + "tabulate >=0.8.9", + "sqlalchemy >=1.4.16", + "xarray >=0.19.0", + "fastparquet >=0.4.0", + "html5lib >=1.1", + "jinja2 >=3.0.0", + "matplotlib-base >=3.3.2", + "blosc >=1.21.0", + "openpyxl >=3.0.7", + "xlsxwriter >=1.4.3", + "xlwt >=1.3.0", + "pyreadstat >=1.1.2", + "python-snappy >=0.6.0", + "brotli >=0.7.0", + "pymysql >=1.0.2", + "zstandard >=0.15.2", + "gcsfs >=2021.7.0", + "lxml >=4.6.3", + "scipy >=1.7.1", + "s3fs >=2021.08.0", + "pandas-gbq >=0.15.0", + "tzdata >=2022a" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.16,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0893bf8e4ae9e34d7c7769bf36b2525a", + "name": "pandas", + "sha256": "1c229af1d9d41aaa3a476e8fcb418ec479c880f1e48275a37691b83159bb4037", + "size": 13708584, + "subdir": "linux-64", + "timestamp": 1670425963917, + "version": "1.5.2" + }, + "pandas-1.5.3-py310h1128e8f_0.tar.bz2": { + "build": "py310h1128e8f_0", + "build_number": 0, + "constrains": [ + "xarray >=0.19.0", + "matplotlib-base >=3.3.2", + "fastparquet >=0.4.0", + "numba >=0.53.1", + "xlsxwriter >=1.4.3", + "lxml >=4.6.3", + "pytables >=3.6.1", + "scipy >=1.7.1", + "blosc >=1.21.0", + "pandas-gbq >=0.15.0", + "zstandard >=0.15.2", + "xlwt >=1.3.0", + "html5lib >=1.1", + "xlrd >=2.0.1", + "psycopg2 >=2.8.6", + "openpyxl >=3.0.7", + "pyreadstat >=1.1.2", + "gcsfs >=2021.7.0", + "pyxlsb >=1.0.8", + "tzdata >=2022a", + "python-snappy >=0.6.0", + "fsspec >=2021.7.0", + "sqlalchemy >=1.4.16", + "pyarrow >=1.0.1", + "s3fs >=2021.08.0", + "pymysql >=1.0.2", + "tabulate >=0.8.9", + "beautifulsoup4 >=4.9.3", + "brotli >=0.7.0", + "jinja2 >=3.0.0" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.21,<2.0a0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "adf96d4813dfac8b4b0610ef871c92c9", + "name": "pandas", + "sha256": "e3db6ee59a85ef7d3ec74789a89bdcbc9b3dda454e3ae5ce5f36ce090f3ed71a", + "size": 13679830, + "subdir": "linux-64", + "timestamp": 1677836477780, + "version": "1.5.3" + }, + "pandas-1.5.3-py311hba01205_0.tar.bz2": { + "build": "py311hba01205_0", + "build_number": 0, + "constrains": [ + "s3fs >=2021.08.0", + "tabulate >=0.8.9", + "pyreadstat >=1.1.2", + "pyarrow >=1.0.1", + "numba >=0.53.1", + "python-snappy >=0.6.0", + "openpyxl >=3.0.7", + "pandas-gbq >=0.15.0", + "gcsfs >=2021.7.0", + "blosc >=1.21.0", + "html5lib >=1.1", + "matplotlib-base >=3.3.2", + "scipy >=1.7.1", + "xlrd >=2.0.1", + "xlwt >=1.3.0", + "lxml >=4.6.3", + "brotli >=0.7.0", + "fsspec >=2021.7.0", + "xarray >=0.19.0", + "jinja2 >=3.0.0", + "xlsxwriter >=1.4.3", + "pymysql >=1.0.2", + "zstandard >=0.15.2", + "pytables >=3.6.1", + "tzdata >=2022a", + "pyxlsb >=1.0.8", + "psycopg2 >=2.8.6", + "fastparquet >=0.4.0", + "beautifulsoup4 >=4.9.3", + "sqlalchemy >=1.4.16" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.23,<2.0a0", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "adda1ce04005b14d0498983e45d9dffa", + "name": "pandas", + "sha256": "83b9325e8fe5ded1acaf2789dc9b53b94df4d58020e68c68b5f4146ac95fe9f7", + "size": 16387593, + "subdir": "linux-64", + "timestamp": 1679337148903, + "version": "1.5.3" + }, + "pandas-1.5.3-py38h417a72b_0.tar.bz2": { + "build": "py38h417a72b_0", + "build_number": 0, + "constrains": [ + "xarray >=0.19.0", + "matplotlib-base >=3.3.2", + "fastparquet >=0.4.0", + "numba >=0.53.1", + "xlsxwriter >=1.4.3", + "lxml >=4.6.3", + "pytables >=3.6.1", + "scipy >=1.7.1", + "blosc >=1.21.0", + "pandas-gbq >=0.15.0", + "zstandard >=0.15.2", + "xlwt >=1.3.0", + "html5lib >=1.1", + "xlrd >=2.0.1", + "psycopg2 >=2.8.6", + "openpyxl >=3.0.7", + "pyreadstat >=1.1.2", + "gcsfs >=2021.7.0", + "pyxlsb >=1.0.8", + "tzdata >=2022a", + "python-snappy >=0.6.0", + "fsspec >=2021.7.0", + "sqlalchemy >=1.4.16", + "pyarrow >=1.0.1", + "s3fs >=2021.08.0", + "pymysql >=1.0.2", + "tabulate >=0.8.9", + "beautifulsoup4 >=4.9.3", + "brotli >=0.7.0", + "jinja2 >=3.0.0" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.20.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ae0c17ae4b81998382ca50e84ead99c5", + "name": "pandas", + "sha256": "4c934fb2200a7ccf76bc8186a1e9af020e74804443ea26236bd29ebe68c36828", + "size": 13895571, + "subdir": "linux-64", + "timestamp": 1677836949366, + "version": "1.5.3" + }, + "pandas-1.5.3-py39h417a72b_0.tar.bz2": { + "build": "py39h417a72b_0", + "build_number": 0, + "constrains": [ + "xarray >=0.19.0", + "matplotlib-base >=3.3.2", + "fastparquet >=0.4.0", + "numba >=0.53.1", + "xlsxwriter >=1.4.3", + "lxml >=4.6.3", + "pytables >=3.6.1", + "scipy >=1.7.1", + "blosc >=1.21.0", + "pandas-gbq >=0.15.0", + "zstandard >=0.15.2", + "xlwt >=1.3.0", + "html5lib >=1.1", + "xlrd >=2.0.1", + "psycopg2 >=2.8.6", + "openpyxl >=3.0.7", + "pyreadstat >=1.1.2", + "gcsfs >=2021.7.0", + "pyxlsb >=1.0.8", + "tzdata >=2022a", + "python-snappy >=0.6.0", + "fsspec >=2021.7.0", + "sqlalchemy >=1.4.16", + "pyarrow >=1.0.1", + "s3fs >=2021.08.0", + "pymysql >=1.0.2", + "tabulate >=0.8.9", + "beautifulsoup4 >=4.9.3", + "brotli >=0.7.0", + "jinja2 >=3.0.0" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.20.3,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8d167fb003b79a5571513d97730842bc", + "name": "pandas", + "sha256": "f8afac5a65550c7470395013244fdfa8a567a799a1882b9259782794f30ff157", + "size": 13725775, + "subdir": "linux-64", + "timestamp": 1677836026367, + "version": "1.5.3" + }, + "pandas-datareader-0.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "lxml", + "pandas >=0.19.2", + "python >=2.7,<2.8.0a0", + "requests >=2.3.0", + "requests-file", + "requests-ftp", + "wrapt" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "612e5ec55539124a8b0b1e3813d17b0d", + "name": "pandas-datareader", + "sha256": "43c51d4bebf670cab2722f42a6fd0f99c6ba9f6dadb1ee179b0b7a157c775e92", + "size": 134644, + "subdir": "linux-64", + "timestamp": 1519364631254, + "version": "0.6.0" + }, + "pandas-datareader-0.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lxml", + "pandas >=0.19.2", + "python >=3.5,<3.6.0a0", + "requests >=2.3.0", + "requests-file", + "requests-ftp", + "wrapt" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "d5bbad01c77151544bce06b8efce741a", + "name": "pandas-datareader", + "sha256": "bed42fcff85c279a130d2417a85df470391e52378e0eb9e5f7821a19aa36fd2b", + "size": 138049, + "subdir": "linux-64", + "timestamp": 1519364651302, + "version": "0.6.0" + }, + "pandas-datareader-0.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lxml", + "pandas >=0.19.2", + "python >=3.6,<3.7.0a0", + "requests >=2.3.0", + "requests-file", + "requests-ftp", + "wrapt" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "18ee8ada90a63c694248ab1dc26bc3bb", + "name": "pandas-datareader", + "sha256": "3de97da77e5e395db4e048bc73977822a12102f1f0c27f5cb4573d811be0f2a3", + "size": 137463, + "subdir": "linux-64", + "timestamp": 1519364587829, + "version": "0.6.0" + }, + "pandas-datareader-0.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lxml", + "pandas >=0.19.2", + "python >=3.7,<3.8.0a0", + "requests >=2.3.0", + "requests-file", + "requests-ftp", + "wrapt" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "9089f08dca3e2d91a015b5296b9703e4", + "name": "pandas-datareader", + "sha256": "b3b9019144860ce243d54e4c07f1fd0786f5abfd8baa82b94bd37a3b34a79d41", + "size": 137999, + "subdir": "linux-64", + "timestamp": 1530904697740, + "version": "0.6.0" + }, + "pandas-datareader-0.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "lxml", + "pandas >=0.19.2", + "python >=2.7,<2.8.0a0", + "requests >=2.3.0", + "wrapt" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "6cd536827a2a372d0b07c82611d301ca", + "name": "pandas-datareader", + "sha256": "cf6a08fe4edc0a03703f5101d825a64048f412684793907a6316c61582589be0", + "size": 142032, + "subdir": "linux-64", + "timestamp": 1539713945539, + "version": "0.7.0" + }, + "pandas-datareader-0.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lxml", + "pandas >=0.19.2", + "python >=3.6,<3.7.0a0", + "requests >=2.3.0", + "wrapt" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "a116aacf93cb7bbc8b7d91c27e35dd5d", + "name": "pandas-datareader", + "sha256": "315dcef79fc6c7a74880c1f55cdb2fa8ce706dd0c0179b161c04e6563f75df8d", + "size": 145176, + "subdir": "linux-64", + "timestamp": 1539713959188, + "version": "0.7.0" + }, + "pandas-datareader-0.7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lxml", + "pandas >=0.19.2", + "python >=3.7,<3.8.0a0", + "requests >=2.3.0", + "wrapt" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "8e6494d6ff62e26459ae052e069f2c16", + "name": "pandas-datareader", + "sha256": "a34fc2293b8bf0d65f9022d69747b08278451c10b6de2c82904ba80c603122b4", + "size": 145194, + "subdir": "linux-64", + "timestamp": 1539713961167, + "version": "0.7.0" + }, + "pandas-profiling-1.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.8", + "matplotlib >=1.4", + "pandas >=0.19", + "python >=2.7,<2.8.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "486adab6c6b5bed3f7276044b63665f6", + "name": "pandas-profiling", + "sha256": "2d1596eafad7e9003b00ab0f55da77642e43e33112293520dd2204cfb4485f91", + "size": 40069, + "subdir": "linux-64", + "timestamp": 1522775496116, + "version": "1.4.1" + }, + "pandas-profiling-1.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.8", + "matplotlib >=1.4", + "pandas >=0.19", + "python >=3.5,<3.6.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15a1d5522ec72987a2a4f812b6346662", + "name": "pandas-profiling", + "sha256": "56e2a90e4aa1b10027bf5bca41afc07744ac82cf73f81b293ac50953dd6858ca", + "size": 40423, + "subdir": "linux-64", + "timestamp": 1522775535414, + "version": "1.4.1" + }, + "pandas-profiling-1.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.8", + "matplotlib >=1.4", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e7af2b7192092b2d03dbbf44eb20be1e", + "name": "pandas-profiling", + "sha256": "d882cccd4861fd6b5deca8b25ffafe94a050860045d536e48d181c8d3735b3c9", + "size": 40197, + "subdir": "linux-64", + "timestamp": 1522775535395, + "version": "1.4.1" + }, + "pandas-profiling-1.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.8", + "matplotlib >=1.4", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c053ef7987d6b1ecd0c1be21197738df", + "name": "pandas-profiling", + "sha256": "12191f6f5bf88c509c3cecff9a912530a54f8e6fc806e5e90cf94445cb38f747", + "size": 40078, + "subdir": "linux-64", + "timestamp": 1530904733349, + "version": "1.4.1" + }, + "pandas-profiling-1.4.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.8", + "matplotlib >=1.4", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8ac45047ac9612267cfb4d52a2ada9f", + "name": "pandas-profiling", + "sha256": "8eb582d8103e1ca52bb609389c54a5932fd079d9daf87758ee041466cfb0045b", + "size": 40655, + "subdir": "linux-64", + "timestamp": 1574169723462, + "version": "1.4.1" + }, + "pandas-profiling-3.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "htmlmin >=0.1.12", + "htmlmin >=0.1.12", + "imagehash", + "jinja2 >=2.11.1", + "joblib >=1.0.1,<1.1.0", + "markupsafe >=2.0.1,<2.1.0", + "matplotlib-base >=3.2.0", + "missingno >=0.4.2", + "multimethod >=1.4", + "numpy >=1.16.0", + "pandas >=0.25.3,!=1.0.1,!=1.0.0,!=1.0.2,!=1.1.0", + "phik >=0.11.1", + "pydantic >=1.8.1", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.0.0", + "requests >=2.24.0", + "scipy >=1.4.1", + "seaborn >=0.10.1", + "tangled-up-in-unicode 0.1.0.*", + "tqdm >=4.48.2", + "visions 0.7.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "42421e480c41aade60a728c3564268df", + "name": "pandas-profiling", + "sha256": "fe1f4da905b7cab0a99a0f8af489f11fc21e87258075cdd67f1a4892aba6b120", + "size": 255713, + "subdir": "linux-64", + "timestamp": 1650891183179, + "version": "3.1.0" + }, + "pandas-profiling-3.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "htmlmin >=0.1.12", + "htmlmin >=0.1.12", + "imagehash", + "jinja2 >=2.11.1", + "joblib >=1.0.1,<1.1.0", + "markupsafe >=2.0.1,<2.1.0", + "matplotlib-base >=3.2.0", + "missingno >=0.4.2", + "multimethod >=1.4", + "numpy >=1.16.0", + "pandas >=0.25.3,!=1.0.1,!=1.0.0,!=1.0.2,!=1.1.0", + "phik >=0.11.1", + "pydantic >=1.8.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.0.0", + "requests >=2.24.0", + "scipy >=1.4.1", + "seaborn >=0.10.1", + "tangled-up-in-unicode 0.1.0.*", + "tqdm >=4.48.2", + "visions 0.7.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2786351120e2cbedc04bd1206fe25919", + "name": "pandas-profiling", + "sha256": "d0af714ff00c551830771dd3d47ad973e906041771d247d2160575db2aa49301", + "size": 252644, + "subdir": "linux-64", + "timestamp": 1650891303711, + "version": "3.1.0" + }, + "pandas-profiling-3.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "htmlmin >=0.1.12", + "htmlmin >=0.1.12", + "imagehash", + "jinja2 >=2.11.1", + "joblib >=1.0.1,<1.1.0", + "markupsafe >=2.0.1,<2.1.0", + "matplotlib-base >=3.2.0", + "missingno >=0.4.2", + "multimethod >=1.4", + "numpy >=1.16.0", + "pandas >=0.25.3,!=1.0.1,!=1.0.0,!=1.0.2,!=1.1.0", + "phik >=0.11.1", + "pydantic >=1.8.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.0.0", + "requests >=2.24.0", + "scipy >=1.4.1", + "seaborn >=0.10.1", + "tangled-up-in-unicode 0.1.0.*", + "tqdm >=4.48.2", + "visions 0.7.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "478acab38140a4dd8a78f6b83ab1c2c2", + "name": "pandas-profiling", + "sha256": "1b6f297796384981aa6c28af6b202cdafa7ff3ae50e8949eb5d410a6afebb180", + "size": 251659, + "subdir": "linux-64", + "timestamp": 1650891245426, + "version": "3.1.0" + }, + "pandas-profiling-3.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "htmlmin >=0.1.12", + "htmlmin >=0.1.12", + "imagehash", + "jinja2 >=2.11.1", + "joblib >=1.0.1,<1.1.0", + "markupsafe >=2.0.1,<2.1.0", + "matplotlib-base >=3.2.0", + "missingno >=0.4.2", + "multimethod >=1.4", + "numpy >=1.16.0", + "pandas >=0.25.3,!=1.0.1,!=1.0.0,!=1.0.2,!=1.1.0", + "phik >=0.11.1", + "pydantic >=1.8.1", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.0.0", + "requests >=2.24.0", + "scipy >=1.4.1", + "seaborn >=0.10.1", + "tangled-up-in-unicode 0.1.0.*", + "tqdm >=4.48.2", + "visions 0.7.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d03829e481e6afe29ae40f2b46cb719e", + "name": "pandas-profiling", + "sha256": "2ed5d92c99c6aaa83490ea26a5b7ef4d2ca775bb18cc2b703c02e8d891b3c57a", + "size": 251536, + "subdir": "linux-64", + "timestamp": 1650891098653, + "version": "3.1.0" + }, + "pandas-profiling-3.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-core >=4.6.3", + "tangled-up-in-unicode==0.2.0", + "jupyter-client >=5.3.4", + "ipywidgets >=7.5.1" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.6", + "missingno >=0.4.2,<0.6", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "adb85e665fae02d1c4557fee52f0a9ed", + "name": "pandas-profiling", + "sha256": "a340c149d963ebaa4d0dd2005a2e65104acd2cb6b287d323f7e47bae0084c73a", + "size": 297488, + "subdir": "linux-64", + "timestamp": 1668630237540, + "version": "3.4.0" + }, + "pandas-profiling-3.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-core >=4.6.3", + "tangled-up-in-unicode==0.2.0", + "jupyter-client >=5.3.4", + "ipywidgets >=7.5.1" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.6", + "missingno >=0.4.2,<0.6", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f58b9f8af7f150f13ee97aba5250f6c8", + "name": "pandas-profiling", + "sha256": "150cfeb337865a932ff29f6a136ae0d119a66e6e272362d6dea123a303651e78", + "size": 292876, + "subdir": "linux-64", + "timestamp": 1668630347200, + "version": "3.4.0" + }, + "pandas-profiling-3.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-core >=4.6.3", + "tangled-up-in-unicode==0.2.0", + "jupyter-client >=5.3.4", + "ipywidgets >=7.5.1" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.6", + "missingno >=0.4.2,<0.6", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3cd4875820b3b1b8727c9851633067cb", + "name": "pandas-profiling", + "sha256": "bfb09d9653ff134db73933ce4411926303e707cd81035087bc150e10fb22418f", + "size": 295318, + "subdir": "linux-64", + "timestamp": 1668630178029, + "version": "3.4.0" + }, + "pandas-profiling-3.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-core >=4.6.3", + "tangled-up-in-unicode==0.2.0", + "jupyter-client >=5.3.4", + "ipywidgets >=7.5.1" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.6", + "missingno >=0.4.2,<0.6", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b622e929d86d8aa569534c9889a4a5e", + "name": "pandas-profiling", + "sha256": "c9100c1acc70481eb81bab3be1908af54d63d787f2704baa04de7fe9dd3ebf1c", + "size": 295153, + "subdir": "linux-64", + "timestamp": 1668630293674, + "version": "3.4.0" + }, + "pandas-profiling-3.6.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-client >=5.3.4", + "ipywidgets >=7.5.1", + "tangled-up-in-unicode==0.2.0", + "jupyter-core >=4.6.3" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.7", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "typeguard >=2.13.2,<2.14", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "88e25e0b8df25fa0aca4d8c6f701a79a", + "name": "pandas-profiling", + "sha256": "310f421eea3c28d4576225802840faa542f38f904dd7f595514e164f88f9c733", + "size": 295447, + "subdir": "linux-64", + "timestamp": 1674806970052, + "version": "3.6.3" + }, + "pandas-profiling-3.6.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-client >=5.3.4", + "ipywidgets >=7.5.1", + "tangled-up-in-unicode==0.2.0", + "jupyter-core >=4.6.3" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.7", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "typeguard >=2.13.2,<2.14", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "539f962ace4774aaa9c6f94e83296698", + "name": "pandas-profiling", + "sha256": "b7c244f77785a1630b2fe3cd9dbafe3546c68468b9c7c5ce5ccb5f18b795be71", + "size": 296296, + "subdir": "linux-64", + "timestamp": 1674806855357, + "version": "3.6.3" + }, + "pandas-profiling-3.6.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-client >=5.3.4", + "ipywidgets >=7.5.1", + "tangled-up-in-unicode==0.2.0", + "jupyter-core >=4.6.3" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.7", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "typeguard >=2.13.2,<2.14", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8bff60cfd865e68079a67f619a6f37ef", + "name": "pandas-profiling", + "sha256": "4e134d5c719ffbff80e7c4a05cce94c9126c479bd09f6d3629a2506f8b11e1c4", + "size": 297676, + "subdir": "linux-64", + "timestamp": 1674806916980, + "version": "3.6.3" + }, + "pandas-profiling-3.6.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-client >=5.3.4", + "ipywidgets >=7.5.1", + "tangled-up-in-unicode==0.2.0", + "jupyter-core >=4.6.3" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.7", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "typeguard >=2.13.2,<2.14", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51d7175d487e919d86cd3eeb687fca96", + "name": "pandas-profiling", + "sha256": "0ae0df38f3b63978a134b59061a18de7bcb51765842269edd7d8a2839a65ae29", + "size": 292335, + "subdir": "linux-64", + "timestamp": 1674807024179, + "version": "3.6.3" + }, + "pandas-stubs-1.5.0.221003-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "types-pytz >=2022.1.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9630f018830704d2bc8b164b0163f229", + "name": "pandas-stubs", + "sha256": "61c9a1d7c1ef738bbf6c0ee19933c97db117fbc73dec420ba7d2d2a436d77e2f", + "size": 79902, + "subdir": "linux-64", + "timestamp": 1665524533902, + "version": "1.5.0.221003" + }, + "pandas-stubs-1.5.0.221003-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "types-pytz >=2022.1.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fc2f35a84438744d22516430bf0c8d60", + "name": "pandas-stubs", + "sha256": "9d45aa1c995a519e95af9de3e826c2aa5af19cfb4b452ef2967af834fcd5ab1b", + "size": 80009, + "subdir": "linux-64", + "timestamp": 1665524570743, + "version": "1.5.0.221003" + }, + "pandas-stubs-1.5.0.221003-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "types-pytz >=2022.1.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e76aada405842f6e0699210eeb0d4b9e", + "name": "pandas-stubs", + "sha256": "cb23b7acb6c58b835122e6b03a7cdb6788f32e1382c563dcd7379f7ce357669b", + "size": 79906, + "subdir": "linux-64", + "timestamp": 1665524605440, + "version": "1.5.0.221003" + }, + "pandas-stubs-1.5.3.230203-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "types-pytz >=2022.1.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fea9e1dd81dc70abafd121e2de0b14ee", + "name": "pandas-stubs", + "sha256": "017a1adc4633fe36a6a0901edd8a143605707fc7019607221169a84259ccaac4", + "size": 84547, + "subdir": "linux-64", + "timestamp": 1676319918008, + "version": "1.5.3.230203" + }, + "pandas-stubs-1.5.3.230203-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "types-pytz >=2022.1.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9f6d3ab7250da38eea4af7ef14c76b66", + "name": "pandas-stubs", + "sha256": "5326cb561cd42715afd09785564265ebf12e40522a31b9256ce2b10683528d25", + "size": 85093, + "subdir": "linux-64", + "timestamp": 1676907413988, + "version": "1.5.3.230203" + }, + "pandas-stubs-1.5.3.230203-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "types-pytz >=2022.1.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9eb2d9f88ef39f8c39747f473f59699a", + "name": "pandas-stubs", + "sha256": "198da8dd571d205e76173482cc2dd71f29fa7b64f142b5a7ea1e619827973dc2", + "size": 84433, + "subdir": "linux-64", + "timestamp": 1676319831352, + "version": "1.5.3.230203" + }, + "pandas-stubs-1.5.3.230203-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "types-pytz >=2022.1.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f8aabfe92c741a3535f4bac545edbce0", + "name": "pandas-stubs", + "sha256": "d80569c547443b4b9b433ce227157ce0bdeae795ca2d9fb8b7f6002a7db7c85a", + "size": 84472, + "subdir": "linux-64", + "timestamp": 1676319874569, + "version": "1.5.3.230203" + }, + "pandasql-0.7.3-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "6f74c841b3d649610fcc98f08ae1e9b2", + "name": "pandasql", + "sha256": "65e9f9c8a02a084a51531e63528d7fd59b87a3c6f620fc6c6a3aa4fa259c9ee1", + "size": 31089, + "subdir": "linux-64", + "timestamp": 1537831835158, + "version": "0.7.3" + }, + "pandasql-0.7.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.10,<3.11.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "f3f0287d8208aaa9f2408bb02c3455ac", + "name": "pandasql", + "sha256": "e67662ea3b193b98007bce57d994ac39bae649a62b94fe898d39b1e2842bef94", + "size": 32444, + "subdir": "linux-64", + "timestamp": 1640809871669, + "version": "0.7.3" + }, + "pandasql-0.7.3-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.11,<3.12.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "740f667b38d2400eaa8194c78630af62", + "name": "pandasql", + "sha256": "e815f9f7d5e978485e688445539dab71cc73350887852ca381cc868ca7fe0c8e", + "size": 36440, + "subdir": "linux-64", + "timestamp": 1676907429920, + "version": "0.7.3" + }, + "pandasql-0.7.3-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.5,<3.6.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "04b58d3cfc021a7e9955137ee1734c1e", + "name": "pandasql", + "sha256": "baca98c21996df8a92de2d7d32ceaaffcd732b8a02724ca6e30c9367bd9bf76a", + "size": 31386, + "subdir": "linux-64", + "timestamp": 1537831897349, + "version": "0.7.3" + }, + "pandasql-0.7.3-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "96c3f374c73ba9baf2a8b6120cccee70", + "name": "pandasql", + "sha256": "5c83cecb238afb1afdc321cdfd979e0314d60b5fe622a79bb24fd2023a2295b8", + "size": 31366, + "subdir": "linux-64", + "timestamp": 1537831893000, + "version": "0.7.3" + }, + "pandasql-0.7.3-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "60c0153e8c2bfdc476e7d807a035be05", + "name": "pandasql", + "sha256": "d3ba5d6bbdb14061a4ce1421a16fac7d8d85c16478b35cd29f9e0da422551501", + "size": 302157, + "subdir": "linux-64", + "timestamp": 1632894686605, + "version": "0.7.3" + }, + "pandasql-0.7.3-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "108d53dbcfb5c84a1f2043e291d6341a", + "name": "pandasql", + "sha256": "3cd327090b8b3cbb1bd692ca083110c897d5f8489429f4e479388c1bfc8387b6", + "size": 31403, + "subdir": "linux-64", + "timestamp": 1537831818283, + "version": "0.7.3" + }, + "pandasql-0.7.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "ca80136fe808bc77c83e73eb2b33e1bf", + "name": "pandasql", + "sha256": "19e7208bb7688e0869514282cd9f6fdb0e6955dc24d4d6620e7af1aaab833c2e", + "size": 302565, + "subdir": "linux-64", + "timestamp": 1632893905416, + "version": "0.7.3" + }, + "pandasql-0.7.3-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.8,<3.9.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "eef0d7cf6d2cc481ff2f6632b75e38e5", + "name": "pandasql", + "sha256": "246b1ee80c304bb8e32b33af42c529c742530034d5e8301a7f53296d9290f115", + "size": 32263, + "subdir": "linux-64", + "timestamp": 1574169746251, + "version": "0.7.3" + }, + "pandasql-0.7.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.8,<3.9.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "a2b7e10866ccbbdd1dace428040be2e5", + "name": "pandasql", + "sha256": "055009151f791c7b1de52efcc749d1c4cbeb6ba7185c5ab6a5753ef7f51edef0", + "size": 302855, + "subdir": "linux-64", + "timestamp": 1632894663260, + "version": "0.7.3" + }, + "pandasql-0.7.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.9,<3.10.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "bcddb642bf6b77673ae10c048d06da40", + "name": "pandasql", + "sha256": "2fd0e362f4ae0377a292c7adce1093d0e9b010d49ee0d973abec59f025199220", + "size": 303008, + "subdir": "linux-64", + "timestamp": 1632893903189, + "version": "0.7.3" + }, + "pandoc-1.19.2.1-hea2e7c5_1.tar.bz2": { + "build": "hea2e7c5_1", + "build_number": 1, + "depends": [ + "gmp", + "zlib" + ], + "license": "GPL-2.0", + "md5": "83db0c0c452af928c4665512f4e3c3d6", + "name": "pandoc", + "sha256": "7ea1e1bf5d762e33c862f6b834e1e316a259ee6cb184bbc95708d729a5955014", + "size": 18714232, + "subdir": "linux-64", + "timestamp": 1505690017009, + "version": "1.19.2.1" + }, + "pandoc-2.10-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "2bc8e77ab6581e0d85549408737766a1", + "name": "pandoc", + "sha256": "b99cb3f590a137902065134c55df2544d1568cf8fccbc23e49fa744fcfe2fafc", + "size": 19850397, + "subdir": "linux-64", + "timestamp": 1594828065281, + "version": "2.10" + }, + "pandoc-2.10.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "7b5bad7ccdbc2c74ce0e467d902e5366", + "name": "pandoc", + "sha256": "e1be081cf633fb701ef39f1304373ed541b0bf6275c6ae3864b87f0eb33de190", + "size": 20271069, + "subdir": "linux-64", + "timestamp": 1597465289006, + "version": "2.10.1" + }, + "pandoc-2.11-hb0f4dca_0.tar.bz2": { + "build": "hb0f4dca_0", + "build_number": 0, + "depends": [], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "2b9c70dc32117b72325c063a937542a8", + "name": "pandoc", + "sha256": "ce82f3df39f8998899000f3c0923ec5df2cd3e0745c86cf3b620da316b19faaf", + "size": 13094235, + "subdir": "linux-64", + "timestamp": 1602698657595, + "version": "2.11" + }, + "pandoc-2.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "ac2e8bbe67741ce1491e873033944ff0", + "name": "pandoc", + "sha256": "dc9d5eaa667e757bb7a6dc6b20ae60771849770272e2b3075c333ec5d4daf085", + "size": 12966114, + "subdir": "linux-64", + "timestamp": 1615916811730, + "version": "2.12" + }, + "pandoc-2.12-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "376c245e1e096cef20b3189ad3552fa7", + "name": "pandoc", + "sha256": "2eca6ec43fe25923a64b80a9a756fd0044c38e87fad925fd6b739eaa5940ebe6", + "size": 12957598, + "subdir": "linux-64", + "timestamp": 1669357485464, + "version": "2.12" + }, + "pandoc-2.12-h06a4308_3.tar.bz2": { + "build": "h06a4308_3", + "build_number": 3, + "depends": [], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "82bd82d1c2037a4bb712619c0e336957", + "name": "pandoc", + "sha256": "6ff476d6dcc9b5d7979206f1dbba837b32a3b78202ec5922089a5ec28b71431d", + "size": 12963129, + "subdir": "linux-64", + "timestamp": 1677512220201, + "version": "2.12" + }, + "pandoc-2.2.1-h629c226_0.tar.bz2": { + "build": "h629c226_0", + "build_number": 0, + "depends": [ + "gmp", + "zlib" + ], + "license": "GPL-2.0", + "md5": "826395b8b9174abe1bd3aef09f1460de", + "name": "pandoc", + "sha256": "c670b9e964cb595930a85b6ff43abeca3c3bf1c9592d69d0a55d5c0e2c2a892e", + "size": 22027974, + "subdir": "linux-64", + "timestamp": 1529960076437, + "version": "2.2.1" + }, + "pandoc-2.2.3.2-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "gmp", + "zlib" + ], + "license": "GPL-2.0", + "md5": "1732f3c7f5300ae2616cdf46fa61c768", + "name": "pandoc", + "sha256": "58ac2b686a6dd8ff07d2c12a0403bff4c38002493cf7ec663206ab6136fd813b", + "size": 21778766, + "subdir": "linux-64", + "timestamp": 1535414070085, + "version": "2.2.3.2" + }, + "pandoc-2.9.2.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "208b210f2d8ed3b3069b22d03c4c7923", + "name": "pandoc", + "sha256": "155191ffa21406fb8a2455588c88b3137a4d5513f2fa2c4ab435a602de467f96", + "size": 19580027, + "subdir": "linux-64", + "timestamp": 1593119933618, + "version": "2.9.2.1" + }, + "pandocfilters-1.4.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0fef1d331e9b15afdf9a41d091f240bf", + "name": "pandocfilters", + "sha256": "9fc163220df6afea356ac3575243650ccf3344b924475b1cc12716a388b3a4ba", + "size": 12898, + "subdir": "linux-64", + "timestamp": 1530734410710, + "version": "1.4.2" + }, + "pandocfilters-1.4.2-py27h428e1e5_1.tar.bz2": { + "build": "py27h428e1e5_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "61954742d70be1f88e68051336a01498", + "name": "pandocfilters", + "sha256": "ee2f25b46a3c0b8d7ff13b83bc4549473f6c87d92ef7f39226ba04660f2ec5f8", + "size": 12539, + "subdir": "linux-64", + "timestamp": 1505957316103, + "version": "1.4.2" + }, + "pandocfilters-1.4.2-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cc42cbcad92d8e338ac8dca6baed680f", + "name": "pandocfilters", + "sha256": "4f950efc054461ffe0020aa81c36634657d2b287948b9a4519c2f36713c16277", + "size": 12976, + "subdir": "linux-64", + "timestamp": 1534350928442, + "version": "1.4.2" + }, + "pandocfilters-1.4.2-py35h1565a15_1.tar.bz2": { + "build": "py35h1565a15_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bef849924e25a307918eda37932ff997", + "name": "pandocfilters", + "sha256": "b943a212cffe5a0ea3f6ce1066f571a3ce688ce992bc752ee1091e5e334284bc", + "size": 12716, + "subdir": "linux-64", + "timestamp": 1505957330485, + "version": "1.4.2" + }, + "pandocfilters-1.4.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "92c0c8f98e221e807e1ad3538d4a38d4", + "name": "pandocfilters", + "sha256": "5e3c9bc173c79e1c9bc0ad7e940a6439eabd991a43536c87228ba26850e17b1c", + "size": 13010, + "subdir": "linux-64", + "timestamp": 1530734390903, + "version": "1.4.2" + }, + "pandocfilters-1.4.2-py36ha6701b7_1.tar.bz2": { + "build": "py36ha6701b7_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "13a064fde3c70435f1b817d7d0e7dd60", + "name": "pandocfilters", + "sha256": "4ac8fea8f4cfc8e4ebe400bfd3d332746c9cb7d24f334d83ad56d48d7d1bb179", + "size": 12675, + "subdir": "linux-64", + "timestamp": 1505957345027, + "version": "1.4.2" + }, + "pandocfilters-1.4.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d22136bc6403573477b61e4745996058", + "name": "pandocfilters", + "sha256": "7723227b60424a1dafeacaaa7118fd817cb7410ba8ddd7a0eca8ce3ef23d18af", + "size": 13049, + "subdir": "linux-64", + "timestamp": 1530734431114, + "version": "1.4.2" + }, + "pandocfilters-1.4.2-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "40e3e0eccb1b553be8baeedc3ffd5d4d", + "name": "pandocfilters", + "sha256": "bf4423583e8a4df9eaf0c13e45a48f4ebbf8ab8a1f9db94aa4661b510f598655", + "size": 13823, + "subdir": "linux-64", + "timestamp": 1573489436104, + "version": "1.4.2" + }, + "pandocfilters-1.4.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22af23a74317178a09f94374ac5a2eed", + "name": "pandocfilters", + "sha256": "f2dfd2126722546886e58b485288f6791b0df5575ececd3590052c5800c7519e", + "size": 14169, + "subdir": "linux-64", + "timestamp": 1641916309204, + "version": "1.4.3" + }, + "pandocfilters-1.4.3-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3685a4b95f289a3735cea7a775e62cbd", + "name": "pandocfilters", + "sha256": "0b4dd64ad868ba1af871db8921cdd479d2b9b5e8d451a9d3e41f25d2e52e3630", + "size": 16515, + "subdir": "linux-64", + "timestamp": 1676823740667, + "version": "1.4.3" + }, + "pandocfilters-1.4.3-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a5d0639f0823b0b2bfb17677fcd7c949", + "name": "pandocfilters", + "sha256": "c738af4a5a21e2831252b72ccaacf18485533881c16d5676637440a587d809ea", + "size": 14226, + "subdir": "linux-64", + "timestamp": 1605120971185, + "version": "1.4.3" + }, + "pandocfilters-1.4.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8e25cdd9609a63e72a8f6f770ffa3066", + "name": "pandocfilters", + "sha256": "4f294d66abdbf4a02880f768921fd3fc81c180642784d541d577520d9a26a350", + "size": 14238, + "subdir": "linux-64", + "timestamp": 1605120477845, + "version": "1.4.3" + }, + "pandocfilters-1.4.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5ed14428e58005d10c66899f20755cc4", + "name": "pandocfilters", + "sha256": "b2c8ebfc1ae48dbbd96815e18b0af40e0f1ce284932cb96640d69a98e2fb0df5", + "size": 14259, + "subdir": "linux-64", + "timestamp": 1605120495561, + "version": "1.4.3" + }, + "pandocfilters-1.4.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1ecc7aa4e27fe60b9bac6be77c90d353", + "name": "pandocfilters", + "sha256": "1af45a8acd4a572178ea4ec5cf0f07148dea46b2344388050c7f6a24cd969332", + "size": 14260, + "subdir": "linux-64", + "timestamp": 1605120938890, + "version": "1.4.3" + }, + "panel-0.13.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4", + "requests", + "tqdm >=4.48.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "70f671d4704e322431095a651667e772", + "name": "panel", + "sha256": "1d4acae6f47a993c6487bca46a5e20b1fea5107e694f1bd98ebb27d288626291", + "size": 13362190, + "subdir": "linux-64", + "timestamp": 1650637296449, + "version": "0.13.0" + }, + "panel-0.13.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4", + "requests", + "tqdm >=4.48.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bf8be806c62d694e47802aa0b44a6733", + "name": "panel", + "sha256": "02a46cd0ca6ee32f6345d95cb983861c44b7949d017011d903d58e883ca4c5b9", + "size": 13364037, + "subdir": "linux-64", + "timestamp": 1650637773946, + "version": "0.13.0" + }, + "panel-0.13.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4", + "requests", + "tqdm >=4.48.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6a07d64fd1839a4ef9da2588da50d9ef", + "name": "panel", + "sha256": "c4d58dff94e15b8c9f8f310d24c283336157f2841d89f6c662462d2feb416c3b", + "size": 13360633, + "subdir": "linux-64", + "timestamp": 1650637620405, + "version": "0.13.0" + }, + "panel-0.13.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4", + "requests", + "tqdm >=4.48.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aecbaf94d34250864e40815d6bfec6a5", + "name": "panel", + "sha256": "cb27076c8c059b76167825f602f87e431895c16f029c53dce4cc96423aca928b", + "size": 13361732, + "subdir": "linux-64", + "timestamp": 1650637471138, + "version": "0.13.0" + }, + "panel-0.13.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4", + "requests", + "tqdm >=4.48.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eb9547c26365936ef3ab034f1c97f7b2", + "name": "panel", + "sha256": "c0d105fd228ec5466622e0be6ff73a0b998168fad94106227e09f55593b60b67", + "size": 13361882, + "subdir": "linux-64", + "timestamp": 1658134048959, + "version": "0.13.1" + }, + "panel-0.13.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4", + "requests", + "tqdm >=4.48.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4440950cc395d3cd323b9d83434d5c42", + "name": "panel", + "sha256": "04fd4876a59fd4f2d2582d6c1f762d2b8389ff15458c8423a41962318ca7c44b", + "size": 13300015, + "subdir": "linux-64", + "timestamp": 1658134278280, + "version": "0.13.1" + }, + "panel-0.13.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4", + "requests", + "tqdm >=4.48.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb55e2b89e63ad064118690902a07f09", + "name": "panel", + "sha256": "488ef473c509723f4c8dce5968ec01393464000c0295c9ab8695afc7fb1a78f7", + "size": 13325790, + "subdir": "linux-64", + "timestamp": 1658134158814, + "version": "0.13.1" + }, + "panel-0.13.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4", + "requests", + "tqdm >=4.48.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6c56cc18d0f596992e115bcbfc0dd218", + "name": "panel", + "sha256": "128c65dd978e7a167d2df69a0350be76b19328286ff1a214fe4c6f60ea3ffbd6", + "size": 13357391, + "subdir": "linux-64", + "timestamp": 1658133926009, + "version": "0.13.1" + }, + "panel-0.14.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b328bac358fb9f1fbdab2786ca18bc5a", + "name": "panel", + "sha256": "e0ce248a32e659f5e276608f50214a112ce5b82dd14d21696d280b4725831262", + "size": 14778735, + "subdir": "linux-64", + "timestamp": 1668084708518, + "version": "0.14.1" + }, + "panel-0.14.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "655e3f81484e287aac7aee283f2b798b", + "name": "panel", + "sha256": "ad72fdb63375844e42414a0f996767f74d80ec921825a47f2d6fbb1232079f4e", + "size": 14785423, + "subdir": "linux-64", + "timestamp": 1668084942299, + "version": "0.14.1" + }, + "panel-0.14.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d1de64c469842f37c7a922c5c6932a5c", + "name": "panel", + "sha256": "f0210beae8d454c82ca769fefbcc2e8bd7c607aa037021711ec583cdb7f16451", + "size": 14795888, + "subdir": "linux-64", + "timestamp": 1668085057464, + "version": "0.14.1" + }, + "panel-0.14.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9f698bd93707333ac23f5c703d12db06", + "name": "panel", + "sha256": "09d967c99c2c6b338036416cea047ce50b4802645cfb655f0acfdcbafa75c417", + "size": 14822514, + "subdir": "linux-64", + "timestamp": 1668084824094, + "version": "0.14.1" + }, + "panel-0.14.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dbc96bd13b236cec8a7d785f0daf946c", + "name": "panel", + "sha256": "81eebcb20a5b13ba9da438e4e4d22520c647c59faa6f5e7b4a41835cad8ed6e6", + "size": 14737661, + "subdir": "linux-64", + "timestamp": 1674166520094, + "version": "0.14.2" + }, + "panel-0.14.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.11,<3.12.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c5a01051fb27d6ad46b556b4677211f6", + "name": "panel", + "sha256": "f6028ef200bd29acb2c5dfe9c286850a4f80dd7173326dde46b57bb188fab906", + "size": 15060247, + "subdir": "linux-64", + "timestamp": 1676841576119, + "version": "0.14.2" + }, + "panel-0.14.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f65434192bdbb335b3a53ad9c7c8562b", + "name": "panel", + "sha256": "bfd50b621a89383dd58910c98eb3512c1a0993082467d924857c5c42d943be4e", + "size": 14733316, + "subdir": "linux-64", + "timestamp": 1674166635856, + "version": "0.14.2" + }, + "panel-0.14.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b81cdd08b72a8b46ddb55abc08c88370", + "name": "panel", + "sha256": "19135e906e87137bc981a3e2ff055da09a7090e41b71d17a5840ec542780b5ea", + "size": 14721406, + "subdir": "linux-64", + "timestamp": 1674166747950, + "version": "0.14.2" + }, + "panel-0.14.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a308592402d86b13550e135e8a7d0aa9", + "name": "panel", + "sha256": "e02b014487ed5391de3ff5dda9e46c98ae772f23ff9c12cc394da527eba52b2c", + "size": 14717860, + "subdir": "linux-64", + "timestamp": 1674166403057, + "version": "0.14.2" + }, + "panel-0.14.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "holoviews >1.14.1" + ], + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38d315540dd820d0c5982c3491182d2e", + "name": "panel", + "sha256": "f0736d7b759129952e028fd791b9c662e37f034cfbfd321103197cf74bc771d4", + "size": 14736179, + "subdir": "linux-64", + "timestamp": 1676380048816, + "version": "0.14.3" + }, + "panel-0.14.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "holoviews >1.14.1" + ], + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.11,<3.12.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e8a4f983a46981566e72053d17d93389", + "name": "panel", + "sha256": "092b62d56ff7c16045a7969fc8d878b43092aefb62f21d0ef18bd792dea2d0b8", + "size": 15038819, + "subdir": "linux-64", + "timestamp": 1679337269721, + "version": "0.14.3" + }, + "panel-0.14.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "holoviews >1.14.1" + ], + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2319e2ba7d15db8e33ddfd645c3f4fd4", + "name": "panel", + "sha256": "3c4fd5058cb4fbfa76b62bff7339c52cf7a6bc4de47f8caa1522cca70653aa6d", + "size": 14721316, + "subdir": "linux-64", + "timestamp": 1676379926530, + "version": "0.14.3" + }, + "panel-0.14.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "holoviews >1.14.1" + ], + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a470d76e3094fd0bcf94b754dc3ce6e9", + "name": "panel", + "sha256": "81b92007035c18155c02bbb619777329a6eb2871749a6e542ab961f61e48e98b", + "size": 14718023, + "subdir": "linux-64", + "timestamp": 1676379688150, + "version": "0.14.3" + }, + "panel-0.14.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "holoviews >1.14.1" + ], + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "871b65444733b7da5823ee0dc9826722", + "name": "panel", + "sha256": "49fdb57b2ed2ce4d6bb7a2c5adec36ba59522518a41fb941f9e39a9f43750cc5", + "size": 14712394, + "subdir": "linux-64", + "timestamp": 1676379803902, + "version": "0.14.3" + }, + "pango-1.40.11-h8191d47_0.tar.bz2": { + "build": "h8191d47_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.4,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "653e8fbc53772c0b23aa10f27bd49872", + "name": "pango", + "sha256": "10d3e00c974840b571245e6cd4396971ea429513f32674e92eb1ca96ca357601", + "size": 539484, + "subdir": "linux-64", + "timestamp": 1507908473485, + "version": "1.40.11" + }, + "pango-1.40.11-hedb6d6b_0.tar.bz2": { + "build": "hedb6d6b_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.4,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "5b219094d9a8528ebe4b2c7cf12a1cc7", + "name": "pango", + "sha256": "f1a7ead67d8ee9b84fc8430026b912a5283882f3081b8c4ad274a863a4749deb", + "size": 538601, + "subdir": "linux-64", + "timestamp": 1505852505434, + "version": "1.40.11" + }, + "pango-1.41.0-hd475d92_0.tar.bz2": { + "build": "hd475d92_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.4,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.7.4,<2.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "cbced454823534e353a84a2d6ed6ffe9", + "name": "pango", + "sha256": "d1d5feadbf1e9fe4a7b3688dff658f898e38c574082c7fb2aa17dd532a6abafb", + "size": 542241, + "subdir": "linux-64", + "timestamp": 1516745276300, + "version": "1.41.0" + }, + "pango-1.42.0-h377f3fa_0.tar.bz2": { + "build": "h377f3fa_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.12.6,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "fribidi >=1.0.2,<2.0a0", + "glib >=2.53.6,<3.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "88598f6055d5e181ddcc39047abaed73", + "name": "pango", + "sha256": "7d9b7e979ab919acf2347cfe58c3faeb040261875ec9e9c697c5e7d71d6d2e8b", + "size": 530043, + "subdir": "linux-64", + "timestamp": 1522873317442, + "version": "1.42.0" + }, + "pango-1.42.0-h8589676_1.tar.bz2": { + "build": "h8589676_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.2,<2.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.11,<2.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "pcre >=8.42,<9.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "eadc943ae46f0881614e841e26355b4f", + "name": "pango", + "sha256": "6556b67ab56fcfbc7f38b506abe2d5f7bb7f07845fc776afc5f52c4477d27a2d", + "size": 529575, + "subdir": "linux-64", + "timestamp": 1527929593648, + "version": "1.42.0" + }, + "pango-1.42.1-h8589676_0.tar.bz2": { + "build": "h8589676_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.2,<2.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.11,<2.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "pcre >=8.42,<9.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "bca7d30ca6a77ea8fe6aa5d45af9243f", + "name": "pango", + "sha256": "0e16c31176176cd83e617cef63b706bfd5001da9e587195447c120632e7fc1fd", + "size": 529731, + "subdir": "linux-64", + "timestamp": 1528214360282, + "version": "1.42.1" + }, + "pango-1.42.2-h8589676_0.tar.bz2": { + "build": "h8589676_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.4,<2.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.11,<2.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "pcre >=8.42,<9.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "0557a6c1eddf3e17b939f3655847ddc9", + "name": "pango", + "sha256": "645cd1ecc6b967ca575ed24ad3b28259aea9bda34b6672f7d5b67dbf729c896d", + "size": 544011, + "subdir": "linux-64", + "timestamp": 1532888443830, + "version": "1.42.2" + }, + "pango-1.42.3-h8589676_0.tar.bz2": { + "build": "h8589676_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.4,<2.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.11,<2.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "pcre >=8.42,<9.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "f3dafc296024627c2ffcc54fc25866b4", + "name": "pango", + "sha256": "fe538e0b20ea2efb1495996a73b6ef211af3159f0335ef19a152566ea449558c", + "size": 534321, + "subdir": "linux-64", + "timestamp": 1534390752714, + "version": "1.42.3" + }, + "pango-1.42.4-h049681c_0.tar.bz2": { + "build": "h049681c_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.4,<2.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.12,<2.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.34,<1.7.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "pcre >=8.42,<9.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "c641855587a88a2ac48bbafac84f98d7", + "name": "pango", + "sha256": "13d9052ff9ec3da7c343bab9fa51c0eb00dbc137510e73754430d71e3aea72d0", + "size": 540429, + "subdir": "linux-64", + "timestamp": 1535469857531, + "version": "1.42.4" + }, + "pango-1.42.4-h145f868_1.tar.bz2": { + "build": "h145f868_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.5,<2.0a0", + "glib >=2.63.1,<3.0a0", + "graphite2 >=1.3.14,<2.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "icu >=58.2,<59.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.10,<2.10.0a0", + "pcre >=8.44,<9.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "559c7bbd070d45a2a54181587f030f30", + "name": "pango", + "sha256": "67d25f44cd86b40c09e8556ce161cbee8dbdedc6ca9927714365625219e98fa2", + "size": 537744, + "subdir": "linux-64", + "timestamp": 1593125051973, + "version": "1.42.4" + }, + "pango-1.42.4-h5aa6e80_1.tar.bz2": { + "build": "h5aa6e80_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.5,<2.0a0", + "glib >=2.63.1,<3.0a0", + "graphite2 >=1.3.13,<2.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.9,<2.10.0a0", + "pcre >=8.43,<9.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "73990c4e76395a2b018c2f04a53e8923", + "name": "pango", + "sha256": "8cf772667ca82788a20cdc8ac5b906150c90d56ce7c797eb53a79612f0771d1d", + "size": 541332, + "subdir": "linux-64", + "timestamp": 1589913721138, + "version": "1.42.4" + }, + "pango-1.45.3-hd140c19_0.tar.bz2": { + "build": "hd140c19_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.9,<2.0a0", + "glib >=2.65.0,<3.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "md5": "fee5f119eb4bcebbbf7eea550aabda9c", + "name": "pango", + "sha256": "95829eb4b810c80ebe53287272bdd3078d215db01387ef3a81481f205c73c12e", + "size": 386634, + "subdir": "linux-64", + "timestamp": 1593480756047, + "version": "1.45.3" + }, + "pango-1.50.7-h05da053_0.tar.bz2": { + "build": "h05da053_0", + "build_number": 0, + "depends": [ + "cairo >=1.12.10", + "cairo >=1.16.0,<2.0a0", + "fontconfig >=2.13.0", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "fribidi >=1.0.10,<2.0a0", + "fribidi >=1.0.6", + "glib >=2.62,<3.0a0", + "glib >=2.69.1,<3.0a0", + "harfbuzz >=2.6.0", + "harfbuzz >=4.3.0,<5.0a0", + "libgcc-ng >=11.2.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "8a011d72c656d02f0f5d2e5c802b1815", + "name": "pango", + "sha256": "79214865abf02ebae4e4d18451a790845e67d7edd504b6087da241492c1f0b45", + "size": 469883, + "subdir": "linux-64", + "timestamp": 1656532965838, + "version": "1.50.7" + }, + "param-1.12.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c8bd947978d0574f4b1f99cd9f386ba0", + "name": "param", + "sha256": "7baffc262d54a820bb7498e41c3ffa1499e5ff76736ea796694270ca7757a970", + "size": 141820, + "subdir": "linux-64", + "timestamp": 1668767082637, + "version": "1.12.2" + }, + "param-1.12.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1f6fa1cb60dcd84fa8425bd47d1d6a62", + "name": "param", + "sha256": "9183ae7eb59abdaf1b619770d055f2e8b0daed3942f29085e4bef045cc64e7b6", + "size": 140095, + "subdir": "linux-64", + "timestamp": 1668767007047, + "version": "1.12.2" + }, + "param-1.12.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cb52d63f21954d23787aeab73307e1cd", + "name": "param", + "sha256": "e1ddee47ecfc412b18f760142342561bf553ba69efae0842df581da11b708864", + "size": 140839, + "subdir": "linux-64", + "timestamp": 1668767057479, + "version": "1.12.2" + }, + "param-1.12.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c59cd25905d82ee3edde0ead7e314d02", + "name": "param", + "sha256": "a36b4daeb71027f1acd3a6fedad5f2931ea5a20918a0b8cc1801205555a02040", + "size": 140685, + "subdir": "linux-64", + "timestamp": 1668767032285, + "version": "1.12.2" + }, + "param-1.12.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee63f3f0c1e97c6c791bc68130394539", + "name": "param", + "sha256": "9590ff42a4c013def20c3cf740d9b03910ce6266ec1695d3ed6cc2ac87f5235d", + "size": 142013, + "subdir": "linux-64", + "timestamp": 1671697451287, + "version": "1.12.3" + }, + "param-1.12.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "be3f9eafbf52eeeaa182167955398bc8", + "name": "param", + "sha256": "687887c1d72361bbead32b00fc7cade1d58713aaf5e43d16d7c71f13a768a2eb", + "size": 185834, + "subdir": "linux-64", + "timestamp": 1676828710669, + "version": "1.12.3" + }, + "param-1.12.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6a7144c494b6aa9efd67c64bc62ebb2e", + "name": "param", + "sha256": "299422e2c7d4fd52d5a6f3564968be1a2255f1c323ab78bb6530b432171c7376", + "size": 140672, + "subdir": "linux-64", + "timestamp": 1671697527583, + "version": "1.12.3" + }, + "param-1.12.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "24ec3a2ab815f759b41bf0ad9c3c38ab", + "name": "param", + "sha256": "c1aeb512d6538eac5e9b47a295ae172c0df554d1e11cd5062cff70adc07858a4", + "size": 141156, + "subdir": "linux-64", + "timestamp": 1671697502039, + "version": "1.12.3" + }, + "param-1.12.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "48e5246d80ecbc817291e6f256fb1e2d", + "name": "param", + "sha256": "48faf8536461b3150ff43e1e3eb0a398dee4a6d62dce0126e01d0bc2021cbf26", + "size": 140904, + "subdir": "linux-64", + "timestamp": 1671697476694, + "version": "1.12.3" + }, + "param-1.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6027dffb277f10b5332bdb77937716e3", + "name": "param", + "sha256": "017fc22b127c4bce18d9dda73863c94ce10923bf7021990545832b34bfe5bce5", + "size": 96681, + "subdir": "linux-64", + "timestamp": 1522952104793, + "version": "1.6.0" + }, + "param-1.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "26db9d85543b472f701069eaa3a65711", + "name": "param", + "sha256": "85c5f672df502c11540470dc0999c847e8c0eaaeeaabce0c646d90d6ca943845", + "size": 99130, + "subdir": "linux-64", + "timestamp": 1522952125797, + "version": "1.6.0" + }, + "param-1.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb6978b3b4a3974eeff275cd880ad064", + "name": "param", + "sha256": "ad46ca59120eeacb812a654b0e4d933f7e593ea3b65c0cded60dcbc2ac987707", + "size": 98950, + "subdir": "linux-64", + "timestamp": 1522952125542, + "version": "1.6.0" + }, + "param-1.6.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ca95fa770566793ddc0359c27e0b5795", + "name": "param", + "sha256": "7d25d7c894a3be2c20999cd079f27b0de0a38e23cec7c5d7ddd06059728adca0", + "size": 87614, + "subdir": "linux-64", + "timestamp": 1524842416193, + "version": "1.6.1" + }, + "param-1.6.1-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7eb7d94cc8dfef64703845f1ca451fe3", + "name": "param", + "sha256": "6f5ea10117f473341e04224a728d4a75d5b377a503be11b1093bef9620c507d7", + "size": 88166, + "subdir": "linux-64", + "timestamp": 1530872794637, + "version": "1.6.1" + }, + "param-1.6.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "68f882fe6675b033443f24099f0eca92", + "name": "param", + "sha256": "e99adac8f5cf0ba2d51d960892ba20390811ce9c78c105871abc4869b4fedd48", + "size": 90154, + "subdir": "linux-64", + "timestamp": 1524842431738, + "version": "1.6.1" + }, + "param-1.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5d3042542bf3fed3a00a22cc7d578eec", + "name": "param", + "sha256": "f63efb20e3c0e7247b37bc2f2badc53777fe476cf79d0b82250b5570b3a7fdc9", + "size": 89940, + "subdir": "linux-64", + "timestamp": 1524842379659, + "version": "1.6.1" + }, + "param-1.6.1-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9c5711dd9f25f429d8ad7d63caec07f3", + "name": "param", + "sha256": "78f5883c05b4947b21f2e1a29d933a3ca942eb86e3d302a5286633a0d898bc7b", + "size": 90463, + "subdir": "linux-64", + "timestamp": 1530872845835, + "version": "1.6.1" + }, + "param-1.6.1-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1224556d0d3968e61393e08eb9de3a4e", + "name": "param", + "sha256": "6bbe4a093c76c4b5de524c2bd3e098d8a34a7a69155082113f772eff7673b851", + "size": 90443, + "subdir": "linux-64", + "timestamp": 1530872819934, + "version": "1.6.1" + }, + "param-1.7.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1580b2337fc1fb3f051cb36a59176208", + "name": "param", + "sha256": "bbe694f21453735aec7a19ff9a7b87cb375ece9327aa4eb2a487268793986c55", + "size": 91003, + "subdir": "linux-64", + "timestamp": 1532441649453, + "version": "1.7.0" + }, + "param-1.7.0-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ba3dcad5c17f8e72f4ca83b85e029e6f", + "name": "param", + "sha256": "1261c6dd2906b2d9df18d699e7c852e9a5d1842047e54849419020183b497c98", + "size": 93657, + "subdir": "linux-64", + "timestamp": 1532441993533, + "version": "1.7.0" + }, + "param-1.7.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "acaab43d4ad53bf026500eeba7ed28e9", + "name": "param", + "sha256": "a67f096a1e225eaef8bf44ed77ff379262e97a57dc4a75082278625596c8550a", + "size": 93362, + "subdir": "linux-64", + "timestamp": 1532441908614, + "version": "1.7.0" + }, + "param-1.7.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f5c7a1eb081838b7ee265ef98c49a0df", + "name": "param", + "sha256": "c92305b55d4373d632d8475899b4ac9e828c82a86ce3ca716fd373ab09a61017", + "size": 93335, + "subdir": "linux-64", + "timestamp": 1532442041636, + "version": "1.7.0" + }, + "param-1.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cc0f44a9f9d5f0165a91f6424c40e9e4", + "name": "param", + "sha256": "5bea231f2c0830fcdedfde20c10ae28e748315a2209bfca60249808a1d24a21b", + "size": 101618, + "subdir": "linux-64", + "timestamp": 1539643622888, + "version": "1.8.1" + }, + "param-1.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d38a71ed3c0596b666369210efd676b0", + "name": "param", + "sha256": "54acd0ba835e0c21228fb66ae83f6fb2646122e28765bb6bdd0b085968f348f1", + "size": 104137, + "subdir": "linux-64", + "timestamp": 1539643635858, + "version": "1.8.1" + }, + "param-1.8.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6b51d1278b9a396d6eb8e77a97e471c2", + "name": "param", + "sha256": "bd843e748e04bc20ad7d609b7db216ee04e00a1d3106fcaaa3f085f7f77f228d", + "size": 104179, + "subdir": "linux-64", + "timestamp": 1539643627485, + "version": "1.8.1" + }, + "parameterized-0.6.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8cd9ae93719751c9bcffd0b50dafc9d0", + "name": "parameterized", + "sha256": "75f7b50bcdddf60f48fee399c00f76dcfc70c47e6135e71421d5b69c0198e670", + "size": 21567, + "subdir": "linux-64", + "timestamp": 1515150775409, + "version": "0.6.1" + }, + "parameterized-0.6.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "34ae5b60014a365d9637ae8cca983d12", + "name": "parameterized", + "sha256": "442dfbf212d88f7c14708af9b65ee6deccf88653f93d13068e3cbf4be7165be8", + "size": 22167, + "subdir": "linux-64", + "timestamp": 1515150790432, + "version": "0.6.1" + }, + "parameterized-0.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "aefe46decc911b3946d04736d9de1d8e", + "name": "parameterized", + "sha256": "a1721f918d3ff4b771c2295e56c1dd9ef4b0023c2a19ba06de8598d0a206f819", + "size": 22178, + "subdir": "linux-64", + "timestamp": 1515150790049, + "version": "0.6.1" + }, + "parameterized-0.6.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "6fec2559eb2b5fcf5c6d649aba8cd7b3", + "name": "parameterized", + "sha256": "d3886e15e63eb7c23df80e11e315a41bffe4bf0dd1b93741b6a44ba9fd3047a9", + "size": 21978, + "subdir": "linux-64", + "timestamp": 1530904768202, + "version": "0.6.1" + }, + "parameterized-0.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "713023c2a07ea710b94d815116b463f1", + "name": "parameterized", + "sha256": "ba779a6863c20d014af3f095b24efbfb186991fd5f62325d2947e35f97668bfb", + "size": 29135, + "subdir": "linux-64", + "timestamp": 1552440030279, + "version": "0.7.0" + }, + "parameterized-0.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "6256a60098f5db77454fd2d1ddeeb454", + "name": "parameterized", + "sha256": "a9b252c44f2f3c6711a1189774c90376b97180b6cf82de41fd196075b82a4825", + "size": 29903, + "subdir": "linux-64", + "timestamp": 1552440047346, + "version": "0.7.0" + }, + "parameterized-0.7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "13707d619ac9fb21bc6a67fc341ff0e9", + "name": "parameterized", + "sha256": "489eebb804c7188279c4528b4285b1c3f14da137fca86103d873173761013035", + "size": 29903, + "subdir": "linux-64", + "timestamp": 1552439959819, + "version": "0.7.0" + }, + "parameterized-0.7.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "73ac3908ed5661592c9331589c3421ca", + "name": "parameterized", + "sha256": "4bf9e1b9e98ac855df522852cb9f896e252a979e524fff656cc9a59d23c1b12b", + "size": 29295, + "subdir": "linux-64", + "timestamp": 1573489454709, + "version": "0.7.0" + }, + "paramiko-1.18.4-py27hdc62b2d_0.tar.bz2": { + "build": "py27hdc62b2d_0", + "build_number": 0, + "depends": [ + "ecdsa >=0.11,<2.0", + "pycrypto >=2.1,!=2.4,<3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "bcb9b4cebec06771b60d7ca74ca2bc5f", + "name": "paramiko", + "sha256": "38da61388a34feb39afef7e2f348b5a38ed1c2d6f7d875653933f10176025674", + "size": 227558, + "subdir": "linux-64", + "timestamp": 1511040514375, + "version": "1.18.4" + }, + "paramiko-1.18.4-py35h49e6b62_0.tar.bz2": { + "build": "py35h49e6b62_0", + "build_number": 0, + "depends": [ + "ecdsa >=0.11,<2.0", + "pycrypto >=2.1,!=2.4,<3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "59fd2342f80fe95386a7be8da22dfc47", + "name": "paramiko", + "sha256": "bdf4c3c28665bac4e34f83745824663208392424aa6fbd9aa398b9ad992602e5", + "size": 235245, + "subdir": "linux-64", + "timestamp": 1511040521925, + "version": "1.18.4" + }, + "paramiko-1.18.4-py36h0d01e40_0.tar.bz2": { + "build": "py36h0d01e40_0", + "build_number": 0, + "depends": [ + "ecdsa >=0.11,<2.0", + "pycrypto >=2.1,!=2.4,<3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "1766d065631f34b3e90f8cb572eb282f", + "name": "paramiko", + "sha256": "e9f06268d0a55378c18142395136cfe3cee01581d2f835090deb8b49f86e1b26", + "size": 232399, + "subdir": "linux-64", + "timestamp": 1511040524071, + "version": "1.18.4" + }, + "paramiko-2.4.0-py27hc00b698_0.tar.bz2": { + "build": "py27hc00b698_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "6c709146ac5b3411cc273543eb137056", + "name": "paramiko", + "sha256": "64d7ecd7d2c39b8e72634669a25e4ce061e861d79e9d9d93791e3536317269c7", + "size": 241999, + "subdir": "linux-64", + "timestamp": 1511038405357, + "version": "2.4.0" + }, + "paramiko-2.4.0-py35h25c86cb_0.tar.bz2": { + "build": "py35h25c86cb_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "f30c003cb068df2fcb8bcb4947dcea88", + "name": "paramiko", + "sha256": "8ad878ee890cb4e2bf4816d88b31e49bf3e059900ae6dd1701736b2eb4a9b8e6", + "size": 248087, + "subdir": "linux-64", + "timestamp": 1511038402836, + "version": "2.4.0" + }, + "paramiko-2.4.0-py36hd285e23_0.tar.bz2": { + "build": "py36hd285e23_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "d5b0f818d29d17a76df9f6686645bcf4", + "name": "paramiko", + "sha256": "95bf5a1d8073be34fda1c2406ee027ee668101e2ed6262d72c48721ab1b1946c", + "size": 245117, + "subdir": "linux-64", + "timestamp": 1511038408968, + "version": "2.4.0" + }, + "paramiko-2.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "68d1f7ffb1587ad3e5fbcc00482052f6", + "name": "paramiko", + "sha256": "b0693cafd75267dcbb753a24c6c6da2a8cec637ec4b315cc11afb53f71f825bf", + "size": 243484, + "subdir": "linux-64", + "timestamp": 1521614258685, + "version": "2.4.1" + }, + "paramiko-2.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "f0d6fddc73aa379c1be91cccad2092b5", + "name": "paramiko", + "sha256": "6c987d3a91a735931a881423850ef71531536e315de75f8f42faf9f425f124a1", + "size": 250690, + "subdir": "linux-64", + "timestamp": 1521614268202, + "version": "2.4.1" + }, + "paramiko-2.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "1bc6f9292e47c19980121a22e55fa227", + "name": "paramiko", + "sha256": "1b558fdc866a1d64c0ad3f01ca1e277c4d5fa999ac7faed841ca40e26ef79394", + "size": 246688, + "subdir": "linux-64", + "timestamp": 1521614225438, + "version": "2.4.1" + }, + "paramiko-2.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "90af32b53ae3b3bb5747f28ded5af12b", + "name": "paramiko", + "sha256": "568f910a7825bd6e54d006809569688d8cad5c614445333a6bae918bee3261d3", + "size": 246611, + "subdir": "linux-64", + "timestamp": 1530876169938, + "version": "2.4.1" + }, + "paramiko-2.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "de707a2b7771e21810d7d6169a308466", + "name": "paramiko", + "sha256": "f5f41dc47a2b8765b58cec2aaa253c3acadfd8e8e0ac5e2d5c258b5f0aee4ddc", + "size": 242721, + "subdir": "linux-64", + "timestamp": 1539637529220, + "version": "2.4.2" + }, + "paramiko-2.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "70dfeeff0e54e35d12378989b47de1fe", + "name": "paramiko", + "sha256": "765849af9a3c5dac485c2c7602bf2dc9535579892f2c3e55667734c5fdad426e", + "size": 246105, + "subdir": "linux-64", + "timestamp": 1539637548905, + "version": "2.4.2" + }, + "paramiko-2.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "63f94ed7612d9a74befc79f32cd11f7c", + "name": "paramiko", + "sha256": "376c560b2315775e9afb3ea91d450aa206997d14cddfd4486bddd3a9014c727a", + "size": 246194, + "subdir": "linux-64", + "timestamp": 1539637550485, + "version": "2.4.2" + }, + "paramiko-2.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=2.5", + "pynacl >=1.0.1", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "811e198aed5d0e8fbe1a517db91b2778", + "name": "paramiko", + "sha256": "9992a282948b0d2803a1782a7650e794d94f46eb4482f292071aba327679b3fd", + "size": 278098, + "subdir": "linux-64", + "timestamp": 1568312009074, + "version": "2.6.0" + }, + "paramiko-2.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=2.5", + "pynacl >=1.0.1", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "13bff89d0d8e29881bd37bffde180586", + "name": "paramiko", + "sha256": "6f80b5e654e31891d64b2be6242109f37f2840ec068006c0f10774131c123bd3", + "size": 287969, + "subdir": "linux-64", + "timestamp": 1568312057643, + "version": "2.6.0" + }, + "paramiko-2.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=2.5", + "pynacl >=1.0.1", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "ad44a76b936ab3f4eaa69261c220a847", + "name": "paramiko", + "sha256": "1bc9672068302d12cd485e03b0a2280cd920c3be8c8c37a4338b3ac2a2874bd8", + "size": 275050, + "subdir": "linux-64", + "timestamp": 1568312082227, + "version": "2.6.0" + }, + "paramiko-2.6.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=2.5", + "pynacl >=1.0.1", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "58c3bc01a2b981b66f1e54b04f63e970", + "name": "paramiko", + "sha256": "94ed6932e5f781568b176684add088f48e7a3444311a004ea5a7d4539fa8c67c", + "size": 272329, + "subdir": "linux-64", + "timestamp": 1574169767277, + "version": "2.6.0" + }, + "parquet-cpp-1.4.0-h3238a2a_0.tar.bz2": { + "build": "h3238a2a_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.9.0,<0.10.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "thrift-cpp >=0.11.0,<0.12.0a0" + ], + "license": "Apache 2.0", + "md5": "078972184fbc793756579dc01b1bdb53", + "name": "parquet-cpp", + "sha256": "1e4768e0f4347b31e25d707e669f494ce19c85f3da5bdc910d571b906edd6203", + "size": 1317351, + "subdir": "linux-64", + "timestamp": 1529459998939, + "version": "1.4.0" + }, + "parsedatetime-2.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c2758df8074bf47f2323a0b0d508347b", + "name": "parsedatetime", + "sha256": "4999a7add1679b09061f51bb9e2afc293105b4f749a39ea883b424331b401365", + "size": 63425, + "subdir": "linux-64", + "timestamp": 1530735654045, + "version": "2.4" + }, + "parsedatetime-2.4-py27h48d1ce5_0.tar.bz2": { + "build": "py27h48d1ce5_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "61a8f7540e82e4863c7a1a0532be5020", + "name": "parsedatetime", + "sha256": "87905244072bc01b9bb05264e494f2bd93d812c763681e571681cb9949d96ade", + "size": 63182, + "subdir": "linux-64", + "timestamp": 1505747208352, + "version": "2.4" + }, + "parsedatetime-2.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e2bfdb6fc2d9de28bc392b52806f95ba", + "name": "parsedatetime", + "sha256": "169c9b3361c4e2480d68673249dccf8e438a2d75bea2b7b3a79770006281178c", + "size": 64244, + "subdir": "linux-64", + "timestamp": 1640806646685, + "version": "2.4" + }, + "parsedatetime-2.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ae9035e2f1d6f836da97ba2180572a49", + "name": "parsedatetime", + "sha256": "c9b1d9eec3f7d55256c9146dcc3b3829747ec33f0592a5dfbe85adc2d25edb95", + "size": 83016, + "subdir": "linux-64", + "timestamp": 1676838520102, + "version": "2.4" + }, + "parsedatetime-2.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "39fed0001aa04ea7337ac7bdc4e99837", + "name": "parsedatetime", + "sha256": "e70c1e943934b52f6c9573247c7a758b434c67ffcc3655e57a99e5601c53ea5c", + "size": 63684, + "subdir": "linux-64", + "timestamp": 1534352018290, + "version": "2.4" + }, + "parsedatetime-2.4-py35he51eadf_0.tar.bz2": { + "build": "py35he51eadf_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f00080dd26e426b58f04d676e5a1a22b", + "name": "parsedatetime", + "sha256": "1885247c214fae6408ae88c43b9a889eb6cc94a8ca80547ae0a940aef3cd634c", + "size": 63549, + "subdir": "linux-64", + "timestamp": 1505747221904, + "version": "2.4" + }, + "parsedatetime-2.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d52349d475a631096b4e10075b3087db", + "name": "parsedatetime", + "sha256": "6e4fde394e3d43ae57a6b7fd4546b736a41a56046b924b0c510ca609569a8c80", + "size": 62896, + "subdir": "linux-64", + "timestamp": 1530735633065, + "version": "2.4" + }, + "parsedatetime-2.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ed4d2b814eab22e009c79937052d109e", + "name": "parsedatetime", + "sha256": "4ad94cfec72544e62cdd435fffafd845e988f09d241ef05a123429adc337979f", + "size": 64649, + "subdir": "linux-64", + "timestamp": 1613733957229, + "version": "2.4" + }, + "parsedatetime-2.4-py36ha668ad1_0.tar.bz2": { + "build": "py36ha668ad1_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2f293fa4434a06d16c982e69fb965a0e", + "name": "parsedatetime", + "sha256": "80496137857b23e93bbdb598899f62899a86ca45672a9e92b52e700479cd1db7", + "size": 62754, + "subdir": "linux-64", + "timestamp": 1505747235613, + "version": "2.4" + }, + "parsedatetime-2.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "00f1f7a065d58c894b4dade738d29135", + "name": "parsedatetime", + "sha256": "a1bf82fdb790fe3631fcec5d269e8c184f1f4b82d53016bd414dd9756d18f228", + "size": 62824, + "subdir": "linux-64", + "timestamp": 1530735675865, + "version": "2.4" + }, + "parsedatetime-2.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4bcee888c23b6512a65a8f16fba196b3", + "name": "parsedatetime", + "sha256": "ac4f5a77403d86deafd7e639027797afe3905b719c6daa523669dcf372815c7c", + "size": 64565, + "subdir": "linux-64", + "timestamp": 1613733967071, + "version": "2.4" + }, + "parsedatetime-2.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "404141209afd347ff3742d11a49549ae", + "name": "parsedatetime", + "sha256": "2b378d601510a990122c29a8e565ab384c8992aaa6ade0a57b49dfd628ff33da", + "size": 63752, + "subdir": "linux-64", + "timestamp": 1573489476815, + "version": "2.4" + }, + "parsedatetime-2.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "32df5b6c44ef96ce778be7cbaa677748", + "name": "parsedatetime", + "sha256": "09ccc306971f9973279abf758b6959090123806d9b257df017629bd9ba3c1e35", + "size": 64877, + "subdir": "linux-64", + "timestamp": 1613733966370, + "version": "2.4" + }, + "parsedatetime-2.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3bf9a30ea8a0fdaa64132c8a2ccf1863", + "name": "parsedatetime", + "sha256": "0f3f3e09c679c37332f131161fb7d021566ea364044ee13a37bbc200124810f0", + "size": 64654, + "subdir": "linux-64", + "timestamp": 1613733209068, + "version": "2.4" + }, + "parsedatetime-2.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "eb62f0470794a377a2ccd346236324b6", + "name": "parsedatetime", + "sha256": "ac3c0bf7d49b78cb3315f52f6334d4481b44665d503b10075eebc2098fb72d3b", + "size": 64708, + "subdir": "linux-64", + "timestamp": 1599891671908, + "version": "2.5" + }, + "parsedatetime-2.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "27fd33004f2ccbc9383a721d6cf136b7", + "name": "parsedatetime", + "sha256": "e8c7c40afdf382934521f3edc627b9f1ab305924c327931b75a1aa0b9c459538", + "size": 64669, + "subdir": "linux-64", + "timestamp": 1599891696781, + "version": "2.5" + }, + "parsedatetime-2.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e979897b204881b1a52f5a4deec034a2", + "name": "parsedatetime", + "sha256": "e94362684591428a7a2e638c093c7e1544f2b30f2960846341f665297c3e4e35", + "size": 65078, + "subdir": "linux-64", + "timestamp": 1599891685477, + "version": "2.5" + }, + "parsedatetime-2.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a9fe397b43f3e4e6b7ba93a3e464cd07", + "name": "parsedatetime", + "sha256": "e5af67c645e08157f03071088410414b28821fe1ebbf6d4e2498343f82053faf", + "size": 64590, + "subdir": "linux-64", + "timestamp": 1599892098261, + "version": "2.6" + }, + "parsedatetime-2.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "23606d068cedd6078aeb3606f2aad1bf", + "name": "parsedatetime", + "sha256": "ac23425d7e7b9304889dae600b3fe93fc35e5f49f6a6467304848f6ca8b4e43f", + "size": 64540, + "subdir": "linux-64", + "timestamp": 1599892064680, + "version": "2.6" + }, + "parsedatetime-2.6-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0657145d375e157f818e2f97ad3f314a", + "name": "parsedatetime", + "sha256": "e7635baa2505e9f33b6d8b809a0fe6fcaa2e48b03fe360d4292b820de31c10f6", + "size": 64942, + "subdir": "linux-64", + "timestamp": 1599892098617, + "version": "2.6" + }, + "parsel-1.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml >=2.3", + "pytest-runner", + "python >=2.7,<2.8.0a0", + "six >=1.5.2", + "w3lib >=1.8.0" + ], + "license": "BSD", + "md5": "e6a6a3560cd24240f4952bcf0a702bbf", + "name": "parsel", + "sha256": "b37f36342e1e28c09a20c85bc44bd3406fb4edc03528a52f372c1684f4cade77", + "size": 27271, + "subdir": "linux-64", + "timestamp": 1519759470222, + "version": "1.4.0" + }, + "parsel-1.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml >=2.3", + "pytest-runner", + "python >=3.5,<3.6.0a0", + "six >=1.5.2", + "w3lib >=1.8.0" + ], + "license": "BSD", + "md5": "e37b590ab35e8bec769d7f48a531fa89", + "name": "parsel", + "sha256": "d6af2bc0d5629a018f868b44b0b10980bffd766f3a3c4c9168ff84a030fcd2ca", + "size": 27870, + "subdir": "linux-64", + "timestamp": 1519759459952, + "version": "1.4.0" + }, + "parsel-1.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml >=2.3", + "pytest-runner", + "python >=3.6,<3.7.0a0", + "six >=1.5.2", + "w3lib >=1.8.0" + ], + "license": "BSD", + "md5": "7616a99e521cd66b2f59da1ef6114f39", + "name": "parsel", + "sha256": "9d424365c80cb165d9e7079f6363e29b222e068bdb62757a47a80abcd10c97d4", + "size": 27822, + "subdir": "linux-64", + "timestamp": 1519759454248, + "version": "1.4.0" + }, + "parsel-1.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml >=2.3", + "pytest-runner", + "python >=3.7,<3.8.0a0", + "six >=1.5.2", + "w3lib >=1.8.0" + ], + "license": "BSD", + "md5": "82dc2aab8f219acb4a5562946f469d78", + "name": "parsel", + "sha256": "609ea3a2bf32a9bafe059a7ddc4d8461018e3dd4ce3fc6d51a00fa9914f76d81", + "size": 27783, + "subdir": "linux-64", + "timestamp": 1530904832243, + "version": "1.4.0" + }, + "parsel-1.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "functools32", + "lxml >=2.3", + "pytest-runner", + "python >=2.7,<2.8.0a0", + "six >=1.5.2", + "w3lib >=1.8.0" + ], + "license": "BSD", + "md5": "9b34104dd5248b5d17ad9e8de40acc12", + "name": "parsel", + "sha256": "cd26a9ff4b7e838b74f9bbbaf7d4b05b27ad88fc361055ac5f35a8e5098179e7", + "size": 28112, + "subdir": "linux-64", + "timestamp": 1532552155377, + "version": "1.5.0" + }, + "parsel-1.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml >=2.3", + "pytest-runner", + "python >=3.5,<3.6.0a0", + "six >=1.5.2", + "w3lib >=1.8.0" + ], + "license": "BSD", + "md5": "78e5fa083b5e4308117c758771a3fdb5", + "name": "parsel", + "sha256": "f205dfa923d62394eb575f854b5d82ff932bc4f813d26ee2cebf9526695bddc8", + "size": 28732, + "subdir": "linux-64", + "timestamp": 1532552169418, + "version": "1.5.0" + }, + "parsel-1.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml >=2.3", + "pytest-runner", + "python >=3.6,<3.7.0a0", + "six >=1.5.2", + "w3lib >=1.8.0" + ], + "license": "BSD", + "md5": "7745a752359d1c16a6181cbd55dc628e", + "name": "parsel", + "sha256": "7d075cb776736377f01f7e5e2712edc5d3c1907050f4336cd6ac613acc753e83", + "size": 28717, + "subdir": "linux-64", + "timestamp": 1532552112984, + "version": "1.5.0" + }, + "parsel-1.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml >=2.3", + "pytest-runner", + "python >=3.7,<3.8.0a0", + "six >=1.5.2", + "w3lib >=1.8.0" + ], + "license": "BSD", + "md5": "e36976ba255fdd149660ada93517af57", + "name": "parsel", + "sha256": "999a334e1756024e19d6f44f719d2ed7c919d60c2168119e317725f5ee81e51a", + "size": 28703, + "subdir": "linux-64", + "timestamp": 1532552180464, + "version": "1.5.0" + }, + "parsel-1.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "functools32", + "lxml >=2.3", + "pytest-runner", + "python >=2.7,<2.8.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "8fce89aadb622c73c19cce177bd80352", + "name": "parsel", + "sha256": "72dbae60471323d1d0fa2b4d8d09b599290e63f9a02af0ba3c0c784b83b3c166", + "size": 28751, + "subdir": "linux-64", + "timestamp": 1541008836876, + "version": "1.5.1" + }, + "parsel-1.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml >=2.3", + "pytest-runner", + "python >=3.6,<3.7.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "3ca967f0a83d964236ee1e9616008c91", + "name": "parsel", + "sha256": "eb223d173af1339f76496903221e8777ac397e928952ea4d1e05f4f8f570b46c", + "size": 29312, + "subdir": "linux-64", + "timestamp": 1541008882556, + "version": "1.5.1" + }, + "parsel-1.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml >=2.3", + "pytest-runner", + "python >=3.7,<3.8.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "06370bd3a283c90f3d79ff8a3d9bbef1", + "name": "parsel", + "sha256": "ec27ca870a93c9f5180c8e188f49eddd73c7212f99b8969cbc3ad7e2c9d6fc5d", + "size": 29378, + "subdir": "linux-64", + "timestamp": 1541008811908, + "version": "1.5.1" + }, + "parsel-1.5.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "functools32", + "lxml", + "pytest-runner", + "python >=2.7,<2.8.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "192908612bbd209606fc2db110f80d19", + "name": "parsel", + "sha256": "761b187f8476bd104e37557f021c280e7ebb6bf70be74dcc10038279c25a81a0", + "size": 176424, + "subdir": "linux-64", + "timestamp": 1569347409099, + "version": "1.5.2" + }, + "parsel-1.5.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "pytest-runner", + "python >=3.10,<3.11.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "caeab39cc99454086b5bdb7f5c2ffcca", + "name": "parsel", + "sha256": "5aa5e2869237d79735b823f8a16ad953ca0a13e6a303120be70c33c00b98abc3", + "size": 31574, + "subdir": "linux-64", + "timestamp": 1640809891624, + "version": "1.5.2" + }, + "parsel-1.5.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "pytest-runner", + "python >=3.6,<3.7.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "162431687290ef69f82309722801bb3f", + "name": "parsel", + "sha256": "fa45250b4aafb661524ed308bf9efd2aa46b87b49e6029d938a22d0f6987761a", + "size": 177192, + "subdir": "linux-64", + "timestamp": 1569347389690, + "version": "1.5.2" + }, + "parsel-1.5.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "pytest-runner", + "python >=3.6,<3.7.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "2d8eaa54aff5437d3e49dc3204658c2f", + "name": "parsel", + "sha256": "795106b2c389628a41653377df2e13ded25cf27232f73d028f921ba7ff67deb4", + "size": 248443, + "subdir": "linux-64", + "timestamp": 1613041296771, + "version": "1.5.2" + }, + "parsel-1.5.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "pytest-runner", + "python >=3.7,<3.8.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "44a4c7189ecdfe2293e35177067e5d28", + "name": "parsel", + "sha256": "af8e8a2c2d335ac1bd078e7f37a708816333082e7aab4a8e727ccca2eb615ee1", + "size": 177067, + "subdir": "linux-64", + "timestamp": 1569347423540, + "version": "1.5.2" + }, + "parsel-1.5.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "pytest-runner", + "python >=3.7,<3.8.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "452c349144920231a4606581cbeca024", + "name": "parsel", + "sha256": "97e9bef6d7d37550813e56987091f715beefc01d8b8ccfd07ed1f73c03cb7395", + "size": 250238, + "subdir": "linux-64", + "timestamp": 1613041616115, + "version": "1.5.2" + }, + "parsel-1.5.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "pytest-runner", + "python >=3.8,<3.9.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "00de9503ef21daeb831f1d5fc090c645", + "name": "parsel", + "sha256": "28581ec3cfd5d985cc59b7c149604b7cc907dc6a35dbe7ea905b359abf256442", + "size": 31411, + "subdir": "linux-64", + "timestamp": 1574177616060, + "version": "1.5.2" + }, + "parsel-1.5.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "pytest-runner", + "python >=3.8,<3.9.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "14a06f34e4233a87d7c7bf435a13f58c", + "name": "parsel", + "sha256": "275e5526162d4fff118c501b5507ef0d2971952199c56df968c5f21774cfa496", + "size": 247920, + "subdir": "linux-64", + "timestamp": 1613041627763, + "version": "1.5.2" + }, + "parsel-1.5.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "pytest-runner", + "python >=3.9,<3.10.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "eec52eeaa0693b1c53fb1aa2da825ed8", + "name": "parsel", + "sha256": "23f70ac91f48ea78d4922cf799dc8fd08b9bff80f7e157bd269e907ec1b8b38b", + "size": 250544, + "subdir": "linux-64", + "timestamp": 1613042427785, + "version": "1.5.2" + }, + "parsel-1.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "python >=3.10,<3.11.0a0", + "six >=1.6.0", + "w3lib >=1.19.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d8b8038a6bdceab36244ead3d84a8e31", + "name": "parsel", + "sha256": "59b9d948efb0d89244caa74600193c196f91e0977fea58f3ec80de02989fa292", + "size": 332779, + "subdir": "linux-64", + "timestamp": 1646740004884, + "version": "1.6.0" + }, + "parsel-1.6.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "python >=3.11,<3.12.0a0", + "six >=1.6.0", + "w3lib >=1.19.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8d67fb1d58f8409f3ec3199a1395d37d", + "name": "parsel", + "sha256": "f9c31022eb5a7b0d8b66a150904dd6a07c72ee539a90348710df7d86d9cfe3aa", + "size": 38267, + "subdir": "linux-64", + "timestamp": 1676905952775, + "version": "1.6.0" + }, + "parsel-1.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "python >=3.7,<3.8.0a0", + "six >=1.6.0", + "w3lib >=1.19.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "585ecb7d9edff255fa64c8d3de6a0bf3", + "name": "parsel", + "sha256": "c1fdd535c239d335d1735bdc8b12a60cc2ac01c5968601e66f48c54f49393b77", + "size": 332741, + "subdir": "linux-64", + "timestamp": 1646721868412, + "version": "1.6.0" + }, + "parsel-1.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "python >=3.8,<3.9.0a0", + "six >=1.6.0", + "w3lib >=1.19.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2b461d78560251067a51e842ea8e272b", + "name": "parsel", + "sha256": "ee189584a5a9cee79e7d64095f2fffed42aaadb15d914f1af618a48f89faeec3", + "size": 333021, + "subdir": "linux-64", + "timestamp": 1646739993580, + "version": "1.6.0" + }, + "parsel-1.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "python >=3.9,<3.10.0a0", + "six >=1.6.0", + "w3lib >=1.19.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0aa04dd4fb0258cdc759954955990600", + "name": "parsel", + "sha256": "2e14b5441eec2e97b7da86cf4c1a4e9c4b720a15072bc05d434b8f83f9adf131", + "size": 330090, + "subdir": "linux-64", + "timestamp": 1646722560868, + "version": "1.6.0" + }, + "parso-0.1.0-py27h04a9d95_0.tar.bz2": { + "build": "py27h04a9d95_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "7a187edf3fe83a0e89aa63835adc8b27", + "name": "parso", + "sha256": "6fee9ad46b9409fe7c2d48cfa79803e83fb21be01c80b6eab75d43edced865a0", + "size": 116690, + "subdir": "linux-64", + "timestamp": 1512058743385, + "version": "0.1.0" + }, + "parso-0.1.0-py35ha74fa24_0.tar.bz2": { + "build": "py35ha74fa24_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "dd5c5e3dcf83c271e14dfa85d2107276", + "name": "parso", + "sha256": "6084388aeaee0566fb22b7e1251dc859184f56e0298c42f2508c9278ab29a5c7", + "size": 119859, + "subdir": "linux-64", + "timestamp": 1512058746177, + "version": "0.1.0" + }, + "parso-0.1.0-py36h2b61f4d_0.tar.bz2": { + "build": "py36h2b61f4d_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "58f77b68a564dbc46734573f54a7c300", + "name": "parso", + "sha256": "14e0f99b578b320bfbafcdea42d6ba4ecec5dec322afe9ae326fa2b98cb12c83", + "size": 119469, + "subdir": "linux-64", + "timestamp": 1512058740045, + "version": "0.1.0" + }, + "parso-0.1.1-py27h718acc2_0.tar.bz2": { + "build": "py27h718acc2_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "f0b654b76f9b526ab914f542b738883e", + "name": "parso", + "sha256": "18b0fbd5fb18e2a6d8f8a4f42b979819f0dff27a00c1977e0e6b872024325b72", + "size": 117354, + "subdir": "linux-64", + "timestamp": 1512061040687, + "version": "0.1.1" + }, + "parso-0.1.1-py35h1b200a3_0.tar.bz2": { + "build": "py35h1b200a3_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "41afd5c395cf44450ef2b11c7df498fb", + "name": "parso", + "sha256": "686eeccfedd5fce73245f2fcebe551aee41547f82d7646180e981467144c08b3", + "size": 120668, + "subdir": "linux-64", + "timestamp": 1512061082892, + "version": "0.1.1" + }, + "parso-0.1.1-py36h35f843b_0.tar.bz2": { + "build": "py36h35f843b_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "28aa4c2867f5057a54643eb5f06865b8", + "name": "parso", + "sha256": "fb1778b81f512b30f27adf2fc2bcb6793fe7dcec9c62460c8839dd1395ad061e", + "size": 120457, + "subdir": "linux-64", + "timestamp": 1512061097157, + "version": "0.1.1" + }, + "parso-0.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc8a90fc056e83a4569ff2e2816ea37d", + "name": "parso", + "sha256": "4ef23dc908d0a7558aaa201890ffc197f419e4c1c35ed2cf1619b930117a9a0d", + "size": 116535, + "subdir": "linux-64", + "timestamp": 1523908483796, + "version": "0.2.0" + }, + "parso-0.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1ea54abb7fd20ff70781954887d799f", + "name": "parso", + "sha256": "fc1f9e682269410db9d2d76ede13170c65340497195b59fb8996156ad8e61690", + "size": 119781, + "subdir": "linux-64", + "timestamp": 1523908576129, + "version": "0.2.0" + }, + "parso-0.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1415d98ca446b76dd4849e4580c0d08c", + "name": "parso", + "sha256": "e30617062be26f0e43200598e2947d626eb302b08ba761b0d39670fb24e3b704", + "size": 119250, + "subdir": "linux-64", + "timestamp": 1523908472081, + "version": "0.2.0" + }, + "parso-0.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e7a86733d6699a5394361dead1172a2", + "name": "parso", + "sha256": "42612cee4eebdb65aa1b27afed53cf01ed576658c37b5524b26d1072cb3525c4", + "size": 118249, + "subdir": "linux-64", + "timestamp": 1527827411093, + "version": "0.2.1" + }, + "parso-0.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "76980be68761da58c32a6c9ed832c5ac", + "name": "parso", + "sha256": "b94c1fcdd81bd0ee805ed6f4f4061de4b5c7d9e44f96f9ce547ed227ea5f5aec", + "size": 121508, + "subdir": "linux-64", + "timestamp": 1527827433773, + "version": "0.2.1" + }, + "parso-0.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9bf06f3d375ca49bea89b20b5b633ed8", + "name": "parso", + "sha256": "3c7532859194d61040daa2d1f9bd3000e60653931ce98580a1720e0b2522a43d", + "size": 120989, + "subdir": "linux-64", + "timestamp": 1527827715671, + "version": "0.2.1" + }, + "parso-0.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d1fb54ed23038f28c56063868b72ca36", + "name": "parso", + "sha256": "5b4ebd28e3d4f44e06618b5b898942600d30709158cd7b9cc3c154d2f3c390cb", + "size": 120463, + "subdir": "linux-64", + "timestamp": 1530694801920, + "version": "0.2.1" + }, + "parso-0.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "676c89d0f4d1a7d65ce72091ba34fa31", + "name": "parso", + "sha256": "9435764414cbe47dc69c32e3cb6b4b7aecd5cc0df41ddab5d9083587f4f7a481", + "size": 114541, + "subdir": "linux-64", + "timestamp": 1531849970262, + "version": "0.3.0" + }, + "parso-0.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ffba6c53f2b81bca89c71dfeb9874b56", + "name": "parso", + "sha256": "229c103a4791550e03d330177b4aeb5046e8fef193abcb89361182d24ef7ed9c", + "size": 117568, + "subdir": "linux-64", + "timestamp": 1531850037547, + "version": "0.3.0" + }, + "parso-0.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0ed1f2dc8ec970da5ad907eb581b7d2b", + "name": "parso", + "sha256": "aaba039a293a57af7a881c0eead753c06fea2526a774e8450042ae7185fb1434", + "size": 117011, + "subdir": "linux-64", + "timestamp": 1531850040932, + "version": "0.3.0" + }, + "parso-0.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0c9d84ca54116e79b09289678819039", + "name": "parso", + "sha256": "27c88395db0bf8ee5adef6211ba94c2f64d466c43f6f9bb9b6143dc43a96be73", + "size": 116498, + "subdir": "linux-64", + "timestamp": 1531849993318, + "version": "0.3.0" + }, + "parso-0.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9510ec6cd72f501646bc5467320a6d13", + "name": "parso", + "sha256": "bc73315442465253d687343b39ce4325471bd877acedf960e776b1bbe0622226", + "size": 114605, + "subdir": "linux-64", + "timestamp": 1532364925798, + "version": "0.3.1" + }, + "parso-0.3.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2021a2382783b29f619022a3a5f62e3c", + "name": "parso", + "sha256": "b119df22dbd51b099c545dccb8f88a7428337111aed65860e019fc88456c5741", + "size": 117674, + "subdir": "linux-64", + "timestamp": 1532364967412, + "version": "0.3.1" + }, + "parso-0.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ec3178479f895381585bef1d28fb4cc", + "name": "parso", + "sha256": "d7ff252816a87119496dc2e10cf198453f5c1d1e656c9f86d5f23c6af31e85c9", + "size": 117083, + "subdir": "linux-64", + "timestamp": 1532364847610, + "version": "0.3.1" + }, + "parso-0.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cbd9deb1c68e3ffc09d55183dba0c7cb", + "name": "parso", + "sha256": "ddfb3a8400696ec995d11bc7f9a9951bbd46284044fe377383e8270c9501020a", + "size": 116596, + "subdir": "linux-64", + "timestamp": 1532364967554, + "version": "0.3.1" + }, + "parso-0.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e481459c4b46e4359ffdefe65a06d13d", + "name": "parso", + "sha256": "6fe69efc9dc3a17b1074227b93f64d196a9a35cf10cf835bc596a193877917f8", + "size": 119300, + "subdir": "linux-64", + "timestamp": 1549324552541, + "version": "0.3.2" + }, + "parso-0.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a47c80108b9792b2c394354647b84022", + "name": "parso", + "sha256": "329bbc678243dd19cf9069f7512ebe3eed319cd00617b59e34e7c2ef44a8aedf", + "size": 121920, + "subdir": "linux-64", + "timestamp": 1549324307792, + "version": "0.3.2" + }, + "parso-0.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e82dfffdb44ee3b9b56b9223093a696", + "name": "parso", + "sha256": "20e65496d37d4b1eb13c931206d649637edb0a6be848aed8e9b1cc679f7e81af", + "size": 121313, + "subdir": "linux-64", + "timestamp": 1549324237762, + "version": "0.3.2" + }, + "parso-0.3.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3929fedb0fe4bf07bbdcd5ba15f0007c", + "name": "parso", + "sha256": "56fed70444008eacd954d3063b66de6d372bb002d96f2ddca21b0ad3cb2bee8e", + "size": 121153, + "subdir": "linux-64", + "timestamp": 1551142932472, + "version": "0.3.4" + }, + "parso-0.3.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b3cd68383b9c29c370455ef7ca10dc2", + "name": "parso", + "sha256": "167398ea86bb9de7751a78ab5f860e6883228c46e8cc4c97214da8902a52af3c", + "size": 123676, + "subdir": "linux-64", + "timestamp": 1551142943781, + "version": "0.3.4" + }, + "parso-0.3.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de8c72b0c7bd4a6cd4d7238c5e90c003", + "name": "parso", + "sha256": "9f9c9f02ddf685e8a90db91a1e8e76dd69235d46931f36feffe474f7973d6922", + "size": 123084, + "subdir": "linux-64", + "timestamp": 1551142907675, + "version": "0.3.4" + }, + "partd-0.3.10-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "locket", + "python >=2.7,<2.8.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "4e5aee5c9b480007567643a4c8a5c5f6", + "name": "partd", + "sha256": "a77bb3ce68c78c141c9053be32ebfa0e36796d5683acc33b67e4f351ad8be44a", + "size": 34163, + "subdir": "linux-64", + "timestamp": 1553289287582, + "version": "0.3.10" + }, + "partd-0.3.10-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "locket", + "python >=3.6,<3.7.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "683fd047855f3ccbc5e94b754aa01583", + "name": "partd", + "sha256": "65985dcc11060cfc397b10427ba245107f10bcacb665dbef45569a219940d094", + "size": 35109, + "subdir": "linux-64", + "timestamp": 1553289762500, + "version": "0.3.10" + }, + "partd-0.3.10-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "locket", + "python >=3.7,<3.8.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "e1a90c1beeb8ac532e246840b37b3d2b", + "name": "partd", + "sha256": "89f49f57f05f248c09804f32f5db7ad799e1268f7616874f37a3406ae8a17575", + "size": 35199, + "subdir": "linux-64", + "timestamp": 1553289424927, + "version": "0.3.10" + }, + "partd-0.3.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "locket", + "python >=2.7,<2.8.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "a8f64ab65a3a39144e71b17749a046d3", + "name": "partd", + "sha256": "cc5751ca3600a4fd6cc7e4cb063e44cdc8b075ab547cf0a02cffa5b6b9375df6", + "size": 30553, + "subdir": "linux-64", + "timestamp": 1530741822140, + "version": "0.3.8" + }, + "partd-0.3.8-py27h4e55004_0.tar.bz2": { + "build": "py27h4e55004_0", + "build_number": 0, + "depends": [ + "locket", + "python >=2.7,<2.8.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "493f68e9f00b55a9e719092b44dd8102", + "name": "partd", + "sha256": "70a29d7ec7a12d97b16297ceec2c4d2a29f9b81c1a4f4a13e68c7bc11bdef89f", + "size": 30469, + "subdir": "linux-64", + "timestamp": 1505732816039, + "version": "0.3.8" + }, + "partd-0.3.8-py35h68187f2_0.tar.bz2": { + "build": "py35h68187f2_0", + "build_number": 0, + "depends": [ + "locket", + "python >=3.5,<3.6.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "7c9960f0c0a369a9acfadedd38a39e97", + "name": "partd", + "sha256": "28d597b985318ba606b64044a5d81722ea998f12c51e7e07fcdada1c6037408f", + "size": 31361, + "subdir": "linux-64", + "timestamp": 1505732828325, + "version": "0.3.8" + }, + "partd-0.3.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "locket", + "python >=3.6,<3.7.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "6b6af28b2776191b4a4bf833b7dc18f8", + "name": "partd", + "sha256": "51ce35aee799c663780bb13c1cdc6a63ef0f55443b08c888ae18e7d1e9a07548", + "size": 31467, + "subdir": "linux-64", + "timestamp": 1530741799311, + "version": "0.3.8" + }, + "partd-0.3.8-py36h36fd896_0.tar.bz2": { + "build": "py36h36fd896_0", + "build_number": 0, + "depends": [ + "locket", + "python >=3.6,<3.7.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "d08986bc3f492969815a31cf3ae64f17", + "name": "partd", + "sha256": "c431054468662cb509285a0ba789c83cd9f6bd0c7103daaa240626ad164ed663", + "size": 31342, + "subdir": "linux-64", + "timestamp": 1505732840860, + "version": "0.3.8" + }, + "partd-0.3.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "locket", + "python >=3.7,<3.8.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "32a2fdaa8b9b4b1cfba10c379685ad1f", + "name": "partd", + "sha256": "de9bb22fa9df5c3385672d0b3449fa3b946ad322cc9825ca3594b1bcae8689d2", + "size": 31536, + "subdir": "linux-64", + "timestamp": 1530741846053, + "version": "0.3.8" + }, + "partd-0.3.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "locket", + "python >=2.7,<2.8.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "ecd1172a1d7d5c1c23e7dd07b558a17a", + "name": "partd", + "sha256": "156f2a34127da74e81b74c5f7ca49b0420985924971641a3753a6480d034fcbc", + "size": 32361, + "subdir": "linux-64", + "timestamp": 1539635289776, + "version": "0.3.9" + }, + "partd-0.3.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "locket", + "python >=3.6,<3.7.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "378ab4fa52fb3e58318c563ad8ea3dc9", + "name": "partd", + "sha256": "c789d1e0ba3d35b646196e413a380e1df0d3ea59bfe9c1ff1aac55b7f1b018a7", + "size": 33218, + "subdir": "linux-64", + "timestamp": 1539635313058, + "version": "0.3.9" + }, + "partd-0.3.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "locket", + "python >=3.7,<3.8.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "5ffef0377d95b4e840c672e8e51f5273", + "name": "partd", + "sha256": "a5c783916954f93acfb582a4582f19b04d08baf81d66aba2be1fb55e3a5c15db", + "size": 33302, + "subdir": "linux-64", + "timestamp": 1539635316139, + "version": "0.3.9" + }, + "passlib-1.7.1-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "argon2_cffi >=16.2", + "bcrypt >=3.1.0", + "cryptography", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3ae5dc98551308154e2740e301997b4f", + "name": "passlib", + "sha256": "02bbc6ec5f51ae7fd7e6387f486fd27cd53a92383a805f7acb675d99f9aea03c", + "size": 701893, + "subdir": "linux-64", + "timestamp": 1530736322052, + "version": "1.7.1" + }, + "passlib-1.7.1-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "argon2_cffi >=16.2", + "bcrypt >=3.1.0", + "cryptography", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7a4af61fe562165ad186617b38f680a8", + "name": "passlib", + "sha256": "a1d12ca7735939d0da06314eff55b0155887e37b9843c8bae7f1d33c0ca586a6", + "size": 716995, + "subdir": "linux-64", + "timestamp": 1534352263944, + "version": "1.7.1" + }, + "passlib-1.7.1-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "argon2_cffi >=16.2", + "bcrypt >=3.1.0", + "cryptography", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6f3ac45a530ceedfc25c806784ced51e", + "name": "passlib", + "sha256": "c7f37bceaa9be3d2cce4b6edfea6bc9bc2c686d23cf2d183a536aa082e813438", + "size": 714780, + "subdir": "linux-64", + "timestamp": 1530736295447, + "version": "1.7.1" + }, + "passlib-1.7.1-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "argon2_cffi >=16.2", + "bcrypt >=3.1.0", + "cryptography", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "20c83b51642164ec5309232c2c8e41f8", + "name": "passlib", + "sha256": "b0024efaea982b7390513c70972ac64b6f45f6cdb3e05f83c5799150e80885ed", + "size": 709373, + "subdir": "linux-64", + "timestamp": 1530736352217, + "version": "1.7.1" + }, + "paste-2.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "7923bad3554f9302eea903088c1a85e3", + "name": "paste", + "sha256": "05de991f9080ba96fb6d629173b60d7a8c32213a8ba38e3a51ffae5b6b0e4e5e", + "size": 711021, + "subdir": "linux-64", + "timestamp": 1530892747444, + "version": "2.0.3" + }, + "paste-2.0.3-py27h6ae3614_0.tar.bz2": { + "build": "py27h6ae3614_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "edd751c4edc4335047602f98cc4cce4c", + "name": "paste", + "sha256": "47fab869034f566379bdc4d5403d01d2fa63156cad6fcf7731d6d0e9203e637d", + "size": 711267, + "subdir": "linux-64", + "timestamp": 1507872935529, + "version": "2.0.3" + }, + "paste-2.0.3-py35hc7cf8aa_0.tar.bz2": { + "build": "py35hc7cf8aa_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "7d174bd5a976696c4416d0fc8133be5e", + "name": "paste", + "sha256": "3d9db3a98215573bac8d51443209f825ea9eb48e0d9a16802d39447a661d34da", + "size": 731622, + "subdir": "linux-64", + "timestamp": 1507872943089, + "version": "2.0.3" + }, + "paste-2.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "eecd31cd3c7b928491cbeee5fd746448", + "name": "paste", + "sha256": "db0a57944dc425a52258b5290e69766f754559ea7a8d365bfc93f0558114b128", + "size": 729221, + "subdir": "linux-64", + "timestamp": 1530892715996, + "version": "2.0.3" + }, + "paste-2.0.3-py36h9fb3c17_0.tar.bz2": { + "build": "py36h9fb3c17_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "89587840d019aea3e0ab4d12a6d8693b", + "name": "paste", + "sha256": "8fe0f1fbbc9e7b812bd9e146829b8bbfb094b78cf50c49ae96ab0a4507519285", + "size": 729284, + "subdir": "linux-64", + "timestamp": 1507872945963, + "version": "2.0.3" + }, + "paste-2.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "9b10416ac68a8881e72e9deed0b2f38f", + "name": "paste", + "sha256": "9e8e5262290656756fc57c43be1c4781ab4a9f5b6489ccb1cb2df3897887139a", + "size": 727604, + "subdir": "linux-64", + "timestamp": 1530892680953, + "version": "2.0.3" + }, + "paste-3.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "852ab21f4001859c8a9ccb151deafa48", + "name": "paste", + "sha256": "87214712a078622ad06a87c8f531525b008ee238b7f43d2bc67010724414f589", + "size": 754708, + "subdir": "linux-64", + "timestamp": 1541185719171, + "version": "3.0.2" + }, + "paste-3.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "540d8e45c350d23a1e06960a82e8aabf", + "name": "paste", + "sha256": "a2ab32429a40d3d03ec546e63d80d980a6b1f0748f093f5b57d536f2a629de7a", + "size": 767734, + "subdir": "linux-64", + "timestamp": 1541185700413, + "version": "3.0.2" + }, + "paste-3.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "1e177f89f66c9510bb9781c563b9fdef", + "name": "paste", + "sha256": "416a637b7e1d5050b58b78f7dab83ec0df62f88ed2ffb4395cf64c7c4d88ef98", + "size": 739818, + "subdir": "linux-64", + "timestamp": 1541185677177, + "version": "3.0.2" + }, + "paste-3.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "b1af6752d3ed9471acc6de59d906eaf8", + "name": "paste", + "sha256": "44a5612ffd0d5501b31baca67b387cd820acd8daf524d74eae8d076b5bc8c552", + "size": 758964, + "subdir": "linux-64", + "timestamp": 1541448245408, + "version": "3.0.3" + }, + "paste-3.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "4b1d5a6e81a399cf088b6f842834d78c", + "name": "paste", + "sha256": "6e1ad08dfe0f7a7afd68b6f13d433f4ab3487f3b9ffdb93a1419539e5dac518a", + "size": 754487, + "subdir": "linux-64", + "timestamp": 1541448279347, + "version": "3.0.3" + }, + "paste-3.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "358c4800009ddba817432a3ca1ca4f28", + "name": "paste", + "sha256": "7f8ed9aa4febf16c5ae12938af97e8d11a9ea4d1e6a5a9f1bddb80c87a41232e", + "size": 738006, + "subdir": "linux-64", + "timestamp": 1541448229338, + "version": "3.0.3" + }, + "paste-3.0.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "a0e739b0d36337cae64222d9ae73a230", + "name": "paste", + "sha256": "c262385fc55a4337596fde453fa726b525d4c18a8c6f624672f9fe76b70703b8", + "size": 759012, + "subdir": "linux-64", + "timestamp": 1542083346593, + "version": "3.0.4" + }, + "paste-3.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "bbde2b6e66aa26fef1fc05e01657d50e", + "name": "paste", + "sha256": "67961a6f1417b2b4a702cba01393d2da0ebf379c28f21739f978c604a33bdce3", + "size": 746183, + "subdir": "linux-64", + "timestamp": 1542083314798, + "version": "3.0.4" + }, + "paste-3.0.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "e12af56581f73114cbca08fb1bb3dca6", + "name": "paste", + "sha256": "3bff6eed1c2f675fe31bc344aa5b0b82ea546cafdea34fb3526ce2e614be32f4", + "size": 761899, + "subdir": "linux-64", + "timestamp": 1542083307221, + "version": "3.0.4" + }, + "paste-3.0.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "bae50323b18858a62f42e6fcbee0f1a6", + "name": "paste", + "sha256": "443b9709173f2320d289f98cd1c2447a98627e22e18c949cf56fbdd918ca468f", + "size": 754320, + "subdir": "linux-64", + "timestamp": 1545117918364, + "version": "3.0.5" + }, + "paste-3.0.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "ac7298f3b4fccf699c2d0761f94fb4c2", + "name": "paste", + "sha256": "7d1bea1579756708a0a5d191e2e232f057884e6178dcf881d6391134debad549", + "size": 771012, + "subdir": "linux-64", + "timestamp": 1545117944185, + "version": "3.0.5" + }, + "paste-3.0.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "bf6c1cededd8b2ed4dfc39f04d5153c1", + "name": "paste", + "sha256": "92d85d5a10500b1c7f35bd7ebed218f7b2816d8a61470af42efae71cf38193e3", + "size": 740259, + "subdir": "linux-64", + "timestamp": 1545117944438, + "version": "3.0.5" + }, + "paste-3.0.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "0fc8359ab10f3348b2f413947b97adce", + "name": "paste", + "sha256": "abbed81a455f711033568fce00408437d36cf056f07f435d13ca869b39a7057d", + "size": 761126, + "subdir": "linux-64", + "timestamp": 1547243981876, + "version": "3.0.6" + }, + "paste-3.0.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "145353a0a8adea54350f3b9b9e84bde8", + "name": "paste", + "sha256": "d2f874e59e3b4e62a72103eccfcd95f7d1fd0933b3d9c8aa27e257e269e75ab8", + "size": 747671, + "subdir": "linux-64", + "timestamp": 1547243992566, + "version": "3.0.6" + }, + "paste-3.0.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "e598b33c8e29dffce20f1cd25addb22d", + "name": "paste", + "sha256": "0f355732c69b5da04ef65ce4633130ee73c085bc677d960df2503775a1d49637", + "size": 765429, + "subdir": "linux-64", + "timestamp": 1547243970009, + "version": "3.0.6" + }, + "paste-3.0.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "22f4d29c2dab359b6e2dc7d86e827655", + "name": "paste", + "sha256": "607daec97022f7608e91ed7e9816eca3096790d1eb6f928701ca59cd4daade11", + "size": 769166, + "subdir": "linux-64", + "timestamp": 1552362758857, + "version": "3.0.8" + }, + "paste-3.0.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "2e260b34efbeace3ca13ecc7063752f3", + "name": "paste", + "sha256": "4dd12c7c1b6833e333624967106f2fe9cef7b71e14eb77b7f0851fb048a15d11", + "size": 766186, + "subdir": "linux-64", + "timestamp": 1552362835179, + "version": "3.0.8" + }, + "paste-3.0.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "48f98983f8ef24e640fd76a7040ccb0a", + "name": "paste", + "sha256": "dd825b8dac47fbc44b4573555e678a4ca601385f25e683ed9185e28dc75f103e", + "size": 762586, + "subdir": "linux-64", + "timestamp": 1552362731446, + "version": "3.0.8" + }, + "paste-3.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "bfd77e2eb35746bf5e0cc9b3bbf4665c", + "name": "paste", + "sha256": "40f07c14ab29fa0b55976c5db32b549747358b6e4715ed24a431267c1690121e", + "size": 767073, + "subdir": "linux-64", + "timestamp": 1564686694288, + "version": "3.1.0" + }, + "paste-3.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "d0fb35ae59cd95b64d27a611c410f21e", + "name": "paste", + "sha256": "18e792bd833b6f1d260e4c62c5635a48c43f9bf18d54f96bcde36cd5d811498a", + "size": 775665, + "subdir": "linux-64", + "timestamp": 1564686774636, + "version": "3.1.0" + }, + "paste-3.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "3a04cac23d810949dc9d959053316b65", + "name": "paste", + "sha256": "71773341810a9501fdaf1f4778e67f3dad7def729d169996d8295115dab4af00", + "size": 769503, + "subdir": "linux-64", + "timestamp": 1564686611445, + "version": "3.1.0" + }, + "paste-3.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "cf00f60fd1e0ff70e168913c8fd8820b", + "name": "paste", + "sha256": "5e97c4068785ac25e782bcb3b5488d332ecf67734344625c4d36274130ffe826", + "size": 762831, + "subdir": "linux-64", + "timestamp": 1569369279124, + "version": "3.2.0" + }, + "paste-3.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "a03a7c525bfc98d6c9675f70fc2cb913", + "name": "paste", + "sha256": "2db6700e48d2b9a00499df1a34ef7e56daf65cf22f902ce254b965b26508cadd", + "size": 759448, + "subdir": "linux-64", + "timestamp": 1569369282308, + "version": "3.2.0" + }, + "paste-3.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "9aaae3372836bc101bd70fcfa517e8a2", + "name": "paste", + "sha256": "5443acb1e187b81accc15106c7593128aac79ff89ddcc83af4801cb4343a64b1", + "size": 750937, + "subdir": "linux-64", + "timestamp": 1569369270485, + "version": "3.2.0" + }, + "paste-3.2.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "dd6975d5a407e4cee7d4c9b8b3aee25f", + "name": "paste", + "sha256": "a453b13999d4de7d2b63cefb0ffb9151595de81fade58348bab77bf35840eae2", + "size": 764557, + "subdir": "linux-64", + "timestamp": 1573970237133, + "version": "3.2.2" + }, + "paste-3.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "e2b905f4f265f1cdd6e7e04947ad6ba0", + "name": "paste", + "sha256": "bb4ac7e404e8e1b0216fb7c163cde3a09f132dc8c8b72168329deed4fb1a8ce1", + "size": 775541, + "subdir": "linux-64", + "timestamp": 1573970241154, + "version": "3.2.2" + }, + "paste-3.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "42c50617918bab855cc4cd60476dd107", + "name": "paste", + "sha256": "f3195369e97bd6ceddb312d0bde794c0cbbceace3fc33e31ab95719905864406", + "size": 768415, + "subdir": "linux-64", + "timestamp": 1573970183926, + "version": "3.2.2" + }, + "paste-3.2.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "d2f63e730627f0a4510fd115d7be5a96", + "name": "paste", + "sha256": "5451e5c72d73e3bc4dba7b7117554ef57c0e90399f4ca721c4de3e38b52b669f", + "size": 778213, + "subdir": "linux-64", + "timestamp": 1573970275669, + "version": "3.2.2" + }, + "paste-3.4.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "ee80210de3cdc0df67bbccc024c841f1", + "name": "paste", + "sha256": "eda09b2fd33f3e652a6a2904f6f75e24e1395a71661e1b1a57c07c8115db03b4", + "size": 774402, + "subdir": "linux-64", + "timestamp": 1600967841807, + "version": "3.4.5" + }, + "paste-3.4.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "35a605eebe5391d87d42282ae49e05f9", + "name": "paste", + "sha256": "86e99bfd48d8273980929fc408233b1119b8b86a315c323f4719ebb382904599", + "size": 771974, + "subdir": "linux-64", + "timestamp": 1600965735369, + "version": "3.4.5" + }, + "paste-3.4.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "88db2ad43e424848dd83254de24033d4", + "name": "paste", + "sha256": "f6d7764d971696b73106d300f5477a9ceeab8a68ad7a1f20ee84909fc7deda7e", + "size": 771121, + "subdir": "linux-64", + "timestamp": 1600967893836, + "version": "3.4.5" + }, + "paste-3.4.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "c5a55c76b20c54d4ddb54b6a8a1e9527", + "name": "paste", + "sha256": "f563f46d08ae6c309efa1b6529db59d6c27a6cb595bb2db0008c4ce753484e32", + "size": 749165, + "subdir": "linux-64", + "timestamp": 1601051418355, + "version": "3.4.6" + }, + "paste-3.4.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "41626c2bb1732f8d6aaf18401544b355", + "name": "paste", + "sha256": "730415440d4415838481c1b0a75d5ad7710325fa418d79348ce4081c269ee943", + "size": 768021, + "subdir": "linux-64", + "timestamp": 1601051388540, + "version": "3.4.6" + }, + "paste-3.4.6-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "1aed1baba6adf322d370093c3a41bf1a", + "name": "paste", + "sha256": "289d25ddcaf06498d3aa4167f1857844bb4bc128dc22ec8c2f26881e9aac24c9", + "size": 775024, + "subdir": "linux-64", + "timestamp": 1601052184604, + "version": "3.4.6" + }, + "paste-3.5.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "de3a0610984e08ab134600322ca4f63a", + "name": "paste", + "sha256": "53cdd6feee529e9ed7927c963a16810e6c80f162e2951fcb3aeb9a430d3ae598", + "size": 758509, + "subdir": "linux-64", + "timestamp": 1640806667577, + "version": "3.5.0" + }, + "paste-3.5.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "13380c54e4e115e6860ba3fe180cfb1a", + "name": "paste", + "sha256": "575c8b45fdb538a1435b6200730c7280f8afd03cf26f2fd6085bcb2f84ada467", + "size": 900057, + "subdir": "linux-64", + "timestamp": 1676860296484, + "version": "3.5.0" + }, + "paste-3.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "b40f8c351b9302ff147a388a04dd8fa8", + "name": "paste", + "sha256": "61a9ef729ddbb6c8e2ff5d389933ffbca68cb7490eec07817fd6495195db6d29", + "size": 777550, + "subdir": "linux-64", + "timestamp": 1602614439779, + "version": "3.5.0" + }, + "paste-3.5.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "337b80c0bfde7775f71308645eedf7f3", + "name": "paste", + "sha256": "69a52adb58f9bb4ff2cd272af3ced7667838b2a8ff5b132a2604380be3599448", + "size": 774779, + "subdir": "linux-64", + "timestamp": 1615981301651, + "version": "3.5.0" + }, + "paste-3.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "296e8997733f26732b6e5c8f5d5f0c6b", + "name": "paste", + "sha256": "0435bf7858676213a359f8037aeeb92a587c439f32a7a7b470c14a5389cf1117", + "size": 772822, + "subdir": "linux-64", + "timestamp": 1602614436527, + "version": "3.5.0" + }, + "paste-3.5.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "3006b4901b43228cdc2964ad68d89e13", + "name": "paste", + "sha256": "7264b418640c23358047e60a5769ca764c7afe4b0b0d3edc13932ac574deee36", + "size": 767771, + "subdir": "linux-64", + "timestamp": 1615979747682, + "version": "3.5.0" + }, + "paste-3.5.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "8a79266feef596cf3b2682dec5fab960", + "name": "paste", + "sha256": "07af9c28c20f88735f8bc73d8a41ab4fd404537580c7714e5517639cce909518", + "size": 774352, + "subdir": "linux-64", + "timestamp": 1602614420497, + "version": "3.5.0" + }, + "paste-3.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "04e9e9a6ce4b02efd5115bd37993f9cd", + "name": "paste", + "sha256": "bb2cf891dbc20779cedd81b59d2e832ef1152588abec3471e9baf2b34b9a9767", + "size": 777855, + "subdir": "linux-64", + "timestamp": 1615981642125, + "version": "3.5.0" + }, + "paste-3.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "f2c723ac68bfbb4d3e19517fed8d8ab7", + "name": "paste", + "sha256": "0b39ba6e4906c93dd239da71821bf18c0984fa676df1bc9a142cbdf46f8b37d3", + "size": 771863, + "subdir": "linux-64", + "timestamp": 1615981634333, + "version": "3.5.0" + }, + "pastedeploy-1.5.2-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "182f6ee2a6ca4fe5b214c96e23c10e13", + "name": "pastedeploy", + "sha256": "eea997782ba8ba98982e41a62e6410cf9468cf414953e9b0b20b3e9508b15ea6", + "size": 27817, + "subdir": "linux-64", + "timestamp": 1530025619316, + "version": "1.5.2" + }, + "pastedeploy-1.5.2-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc6200828dfbf28ba39f3a08eed34709", + "name": "pastedeploy", + "sha256": "7420b77b84f928d237990596953acc71ae1366d24f299d3a8482747afce53d17", + "size": 28524, + "subdir": "linux-64", + "timestamp": 1530025687874, + "version": "1.5.2" + }, + "pastedeploy-1.5.2-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a273fd22e3f50790473e26dc8754db93", + "name": "pastedeploy", + "sha256": "93e84bb6424ba8286e6db7ec7107584a26c2bf08bbfa0d1f61eebe738931e390", + "size": 28361, + "subdir": "linux-64", + "timestamp": 1530025400784, + "version": "1.5.2" + }, + "pastedeploy-1.5.2-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "140ec070ed1f330e50125d2325d17bbf", + "name": "pastedeploy", + "sha256": "ab25231c7073e2169eb8439894337b717844917743de7f8761b914cb59a1323e", + "size": 28362, + "subdir": "linux-64", + "timestamp": 1530875201238, + "version": "1.5.2" + }, + "pastedeploy-2.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f98876241f48751043bd65cc7936e29c", + "name": "pastedeploy", + "sha256": "a4401e232fa3485eaa7f0e86cf9aa9badde2726098018ed3a148b9f3e751569b", + "size": 28353, + "subdir": "linux-64", + "timestamp": 1545166742215, + "version": "2.0.1" + }, + "pastedeploy-2.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "783c69a19eaf3c157fc71b6957b3138b", + "name": "pastedeploy", + "sha256": "05e3924cd88fd5ab9971cf9433632abf072c3a8b4aa16661cec78a9cd6cc14f7", + "size": 29244, + "subdir": "linux-64", + "timestamp": 1640806688502, + "version": "2.0.1" + }, + "pastedeploy-2.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "261236d8efd3e05369ea50cfeaed491c", + "name": "pastedeploy", + "sha256": "a0ec234b44c9e24f12b2f5403b68dd49d9ccaf5d26443fca088dfcde9fd06f3f", + "size": 38324, + "subdir": "linux-64", + "timestamp": 1676903959453, + "version": "2.0.1" + }, + "pastedeploy-2.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1f330642cc761be370a21109fc97a15", + "name": "pastedeploy", + "sha256": "b39b20e7c2e486ee11798e1be1249ba60001241624a9fb4625064946ce6b80e4", + "size": 28860, + "subdir": "linux-64", + "timestamp": 1545166792208, + "version": "2.0.1" + }, + "pastedeploy-2.0.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a207fcc74d550d92a4d4b698b69609cb", + "name": "pastedeploy", + "sha256": "0cc559c8cba47e0de9d50568fd816f6b12a0ce53c112d6dea799dc27f1c473aa", + "size": 247830, + "subdir": "linux-64", + "timestamp": 1613160048009, + "version": "2.0.1" + }, + "pastedeploy-2.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbfd5d4df73f4bf7b7b61c9c569d1523", + "name": "pastedeploy", + "sha256": "314dbd9aa359c12c477667dbea3d75cf07f80fef75d41f418d0c9ce486db799f", + "size": 28883, + "subdir": "linux-64", + "timestamp": 1545166790640, + "version": "2.0.1" + }, + "pastedeploy-2.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eaa0f74672409ec0b8fcfb87080a4f31", + "name": "pastedeploy", + "sha256": "a37b8a32050d6880b7ff69a3d94e309ce1869a6e71ab26e2fd0c97a2a4210dbb", + "size": 248084, + "subdir": "linux-64", + "timestamp": 1613160043223, + "version": "2.0.1" + }, + "pastedeploy-2.0.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "32741ad77e392ed4f01d7f0a531bdadf", + "name": "pastedeploy", + "sha256": "8c859ff4a50216199912b5d7228e16f6fa204eda515dfdfe655c537113f1a365", + "size": 29339, + "subdir": "linux-64", + "timestamp": 1574355278108, + "version": "2.0.1" + }, + "pastedeploy-2.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14d0e52dd43278f5a719c5d863f8d0a6", + "name": "pastedeploy", + "sha256": "df5766f3da9fd31adbc769b2a017aec838cde0f1c372946ae747cdaa432a846a", + "size": 245402, + "subdir": "linux-64", + "timestamp": 1613159689292, + "version": "2.0.1" + }, + "pastedeploy-2.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a47b56813adab77063496e3da8db8e2a", + "name": "pastedeploy", + "sha256": "93edd218f680e82a040a37d60ff0a2684993c0cabe126ae9a8325a519aa5e9ba", + "size": 247876, + "subdir": "linux-64", + "timestamp": 1613159582761, + "version": "2.0.1" + }, + "patch-2.7.5-h5000ff1_0.tar.bz2": { + "build": "h5000ff1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "4e0e187040ec1b58e86e08178721fc31", + "name": "patch", + "sha256": "87b888df15d8b5d904558a65791248fa7e71ebea2362708d85252307110e3995", + "size": 117082, + "subdir": "linux-64", + "timestamp": 1505747276104, + "version": "2.7.5" + }, + "patch-2.7.6-h1bed415_0.tar.bz2": { + "build": "h1bed415_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "8799799aa838bdcd29da07dc25229f2f", + "name": "patch", + "sha256": "0a81e5a6f5af1ab443ba78aa37edfb5e9f4450afaa7526dff4a365c24d411d2a", + "size": 126193, + "subdir": "linux-64", + "timestamp": 1524180098707, + "version": "2.7.6" + }, + "patch-2.7.6-h7b6447c_1001.tar.bz2": { + "build": "h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL 3", + "md5": "cabafb11dc83bcea5aa8031dc35ae405", + "name": "patch", + "sha256": "bf36fc1e0ad7a81f34ebe9f4eb53b22541e589470c79be9993f9e0b31ceb1bc5", + "size": 124863, + "subdir": "linux-64", + "timestamp": 1573953235116, + "version": "2.7.6" + }, + "patchelf-0.10-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL 3", + "md5": "ffc176fc7b02ade0f99cff1a8fcf754e", + "name": "patchelf", + "sha256": "0bbabefe7bc4bd919841633a044edad28a9fc9eff33688079b278f99d8f1d60f", + "size": 80004, + "subdir": "linux-64", + "timestamp": 1573939748444, + "version": "0.10" + }, + "patchelf-0.11-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0-or-later", + "md5": "13f35436645c030cc95e26a4db58ba39", + "name": "patchelf", + "sha256": "0bb46d09ae01bc0063c3e53a0d3bff97912dccdb606e63f79df76edfcd6ea8c2", + "size": 81125, + "subdir": "linux-64", + "timestamp": 1605302153390, + "version": "0.11" + }, + "patchelf-0.11-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0-or-later", + "md5": "1af81c9ad2dedd919eb6c5519a8955bf", + "name": "patchelf", + "sha256": "13f8bf0a88639063c3ca8492cd10749604dc1180c5faf25ecabc1501a5a8cea0", + "size": 81127, + "subdir": "linux-64", + "timestamp": 1592415053365, + "version": "0.11" + }, + "patchelf-0.12-h2531618_1.tar.bz2": { + "build": "h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0-or-later", + "md5": "397d56524e124b469e3c088e27527f9e", + "name": "patchelf", + "sha256": "6ce28b5bb9d0323f619f7a4d18a74891edcd3c9c2d2ce36bc810c981e5ade4f9", + "size": 94453, + "subdir": "linux-64", + "timestamp": 1607736113848, + "version": "0.12" + }, + "patchelf-0.12-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0-or-later", + "md5": "bb8acba1fe5105ba4ead521f7a83d58f", + "name": "patchelf", + "sha256": "913bf4f0ca6a9c5b37987a84b34061a6578fd9540bfe85dfbe2ab1bc619a64fa", + "size": 88555, + "subdir": "linux-64", + "timestamp": 1602272538593, + "version": "0.12" + }, + "patchelf-0.13-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "GPL-3.0-or-later", + "md5": "bb0960dcf647493326c8fbdbf0e2f840", + "name": "patchelf", + "sha256": "46d694ce97b5e704b701aec43bd76dce86354ef93c3bb3c6c170378953c8d3f5", + "size": 92171, + "subdir": "linux-64", + "timestamp": 1631287810666, + "version": "0.13" + }, + "patchelf-0.15.0-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "df2a861bfac1eefac1f88797b7c1368e", + "name": "patchelf", + "sha256": "876e71d6129d242380dd3501cccba23147d39ae8dba5fe86c03852a919d1b584", + "size": 95078, + "subdir": "linux-64", + "timestamp": 1669245116075, + "version": "0.15.0" + }, + "patchelf-0.17.2-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "ebc53723b0041ab0dbafeb52b905bbb8", + "name": "patchelf", + "sha256": "bb8547cff97248cb7fa09f8266eaf3717d4edcafd8f417538474e2ca7e47449b", + "size": 97217, + "subdir": "linux-64", + "timestamp": 1675208106638, + "version": "0.17.2" + }, + "patchelf-0.9-he6710b0_3.tar.bz2": { + "build": "he6710b0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL 3", + "md5": "a892e7f856afa858b9b3e06f9a2689bd", + "name": "patchelf", + "sha256": "e6cc8493d9585c62c62f52c762f0feb9dcf167986c4accbc97bd47e19be4b2df", + "size": 72429, + "subdir": "linux-64", + "timestamp": 1539357188942, + "version": "0.9" + }, + "patchelf-0.9-hf484d3e_2.tar.bz2": { + "build": "hf484d3e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "f53900f3db8a5a34a961a2f562c15fb0", + "name": "patchelf", + "sha256": "3a57eb88e75b61bb2d70f26a4a38ab4a364b9091e9f870cb1b500b03b7bb2f24", + "size": 69307, + "subdir": "linux-64", + "timestamp": 1530813663930, + "version": "0.9" + }, + "patchelf-0.9-hf79760b_2.tar.bz2": { + "build": "hf79760b_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "581e7d4272c645f7c67908cf69be9de5", + "name": "patchelf", + "sha256": "9c62ea8c7aaa8743057464bdfc50aedd4285207898c848f36a6ce94b5d6c8361", + "size": 70656, + "subdir": "linux-64", + "timestamp": 1505742063357, + "version": "0.9" + }, + "path-13.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c95b1cc5c3af2a67c79b9712e0b4b17e", + "name": "path", + "sha256": "6615e3d2812d08f52f1546e43aa80dfbc102386be97013e48e728a4d3e4c9c47", + "size": 36195, + "subdir": "linux-64", + "timestamp": 1576515154502, + "version": "13.1.0" + }, + "path-13.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "79a4d38ad292a2de6ab3008b1003d24b", + "name": "path", + "sha256": "7222e76735f43c62e994d600790d416e34ad60755c66d1f4c1935533a075f9af", + "size": 36322, + "subdir": "linux-64", + "timestamp": 1576515171745, + "version": "13.1.0" + }, + "path-13.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31af4f658eb180b22b94ae185f903432", + "name": "path", + "sha256": "44fd394fb10648eb005a9548e56ab9a91bb919bcf97e9e6930b1f6ba814c0967", + "size": 36434, + "subdir": "linux-64", + "timestamp": 1576515224748, + "version": "13.1.0" + }, + "path-13.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ba27c5828df5806f7a8b6b292cfdf88", + "name": "path", + "sha256": "b502f03749141f9d10eb9ba5f297d4855f8f0b50f95b4b79c7b3a78536f623d3", + "size": 37129, + "subdir": "linux-64", + "timestamp": 1585316285296, + "version": "13.2.0" + }, + "path-13.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a61bedaf5b7212bdd76b636a5e2a689a", + "name": "path", + "sha256": "8e863fea1913851235def1d80ceac3584585dc0e321b73309676026815910f47", + "size": 37235, + "subdir": "linux-64", + "timestamp": 1585316332572, + "version": "13.2.0" + }, + "path-13.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3028e15f4bfe4b325b8ec6eba52ed356", + "name": "path", + "sha256": "1d7778abcf48206caf335d27781a4e6c4b79da5fdec4a556401f05ec28b03808", + "size": 37351, + "subdir": "linux-64", + "timestamp": 1585316365159, + "version": "13.2.0" + }, + "path-14.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d747eb61171be97cb44db0159f3c8a69", + "name": "path", + "sha256": "f7773fe5f5006e81c82c26d52c297cdda7a2e4ed6fdae8111d5c284b57b9ad7f", + "size": 39691, + "subdir": "linux-64", + "timestamp": 1592331199331, + "version": "14.0.1" + }, + "path-14.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0fbcca2ff4cbe3416b00a0a53742b0d", + "name": "path", + "sha256": "b7fd3d3c2ec7a6097787f956dcf3a02425dc36007f8539945df739863717df84", + "size": 39732, + "subdir": "linux-64", + "timestamp": 1592331198807, + "version": "14.0.1" + }, + "path-14.0.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "61dddc8438f0367e373304361a3dc470", + "name": "path", + "sha256": "4b54b51b0f4e42f5d7de229f280698928cb5ec2f3961c14f0980fc4d44d3fcac", + "size": 39894, + "subdir": "linux-64", + "timestamp": 1592331166810, + "version": "14.0.1" + }, + "path-15.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d839376e6d32a814df5df5b812107061", + "name": "path", + "sha256": "2e389a0d22cca5129252504ff66a17c59289151274f277a83691dbeb8143b4d0", + "size": 39967, + "subdir": "linux-64", + "timestamp": 1598376517166, + "version": "15.0.0" + }, + "path-15.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8004f641b409218d4a28070bef624124", + "name": "path", + "sha256": "22b2f6c68b9665654217745749dccbffd53094129764fc56a81ad04900dd5edf", + "size": 37732, + "subdir": "linux-64", + "timestamp": 1596907237237, + "version": "15.0.0" + }, + "path-15.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d8c9fba435329659fb6a305b5fb9560", + "name": "path", + "sha256": "2478fa83a5564255f814fb8d8eb073de0c8be36b6438a82509ef9635f414d8d6", + "size": 40165, + "subdir": "linux-64", + "timestamp": 1598376541054, + "version": "15.0.0" + }, + "path-15.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4192b1539630970b6c31ca2dfef59055", + "name": "path", + "sha256": "a1748c3104b6a656cc136bc8591dc779b990e8a132f629af47a4e23c3f958b2b", + "size": 40312, + "subdir": "linux-64", + "timestamp": 1607027120950, + "version": "15.0.0" + }, + "path-15.0.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9d6f191e2387e288f5fdfbcfe937e47", + "name": "path", + "sha256": "ec0287341d13f194a5d0ca21a6b37df26b2756747b54e2845e74a256b1ea18b1", + "size": 38326, + "subdir": "linux-64", + "timestamp": 1607537266102, + "version": "15.0.1" + }, + "path-15.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b0ce67678bcb6a2269667cc6b850bbe9", + "name": "path", + "sha256": "3671aefbd119d5c5db6e59e6a356f5cdebeed3b78cdc448f424e2d68f5cf76b6", + "size": 38381, + "subdir": "linux-64", + "timestamp": 1607537257215, + "version": "15.0.1" + }, + "path-15.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f4ce7e4c1511aa40844248bfe30fd5b8", + "name": "path", + "sha256": "e8863dfea310710058e4b4779d975e14622d3d603b5d9ae952abde1a652177d0", + "size": 38551, + "subdir": "linux-64", + "timestamp": 1607537263633, + "version": "15.0.1" + }, + "path-15.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eab497ad1d76670b9e6eee656e78b1d2", + "name": "path", + "sha256": "28be09decb49a408355708aea076635a386b19c17d05a88159570ed14c949ab1", + "size": 38596, + "subdir": "linux-64", + "timestamp": 1607537225044, + "version": "15.0.1" + }, + "path-15.1.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8e0fc60b23f438391ffa2da97257563", + "name": "path", + "sha256": "cf0fac3139c806ee0c796dcc961c5eea92e3e910dc4884c551d2a01aa53d03fd", + "size": 38517, + "subdir": "linux-64", + "timestamp": 1611952384575, + "version": "15.1.0" + }, + "path-15.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f3f7e5160902df71e65e2e66d19d98a", + "name": "path", + "sha256": "4eabef49099ef29dd734d0f4a17d46f92c5d0588ac72e5921f0d8a306d96ea66", + "size": 38655, + "subdir": "linux-64", + "timestamp": 1611952370728, + "version": "15.1.0" + }, + "path-15.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8abf04c1fcc52b0c4252b92f8d85cf0e", + "name": "path", + "sha256": "bd331afb7ebfde2904d3788c100b1c46b642ec7562adb6dd6e0c248e287a404a", + "size": 38774, + "subdir": "linux-64", + "timestamp": 1611952403087, + "version": "15.1.0" + }, + "path-15.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ff1373915a1d66fa12343a614a88339", + "name": "path", + "sha256": "f34c230ced456e8c8a3b72186ee67917a61e524f55147f58db77bf0c79a19941", + "size": 38870, + "subdir": "linux-64", + "timestamp": 1611952414004, + "version": "15.1.0" + }, + "path-15.1.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "208610b1bb6916c18104f3c89a40d8fa", + "name": "path", + "sha256": "93adca5c139d9d6218d3f5ea5267635d57399829da758eab7370eeaf17fec1ac", + "size": 38549, + "subdir": "linux-64", + "timestamp": 1613935753928, + "version": "15.1.1" + }, + "path-15.1.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "78b2c6076cbc70dfabace900a19ce0af", + "name": "path", + "sha256": "978f1aadd87c3b50cc3bdf18e9d1c4b0428c9850e5ccfcd812daeb5b33f4fac7", + "size": 38632, + "subdir": "linux-64", + "timestamp": 1613935750981, + "version": "15.1.1" + }, + "path-15.1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f94a3a743608583cb3f972c547de9b89", + "name": "path", + "sha256": "91470fd6426ed499f0f5eb45eff6e8f09e4ef4ece7202182ed4944886c971ef1", + "size": 38749, + "subdir": "linux-64", + "timestamp": 1613935765371, + "version": "15.1.1" + }, + "path-15.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92534f7896aba54f31165dd1f74fab01", + "name": "path", + "sha256": "61184d8d2ba67277c5c310b9ee70716e8eab7101d8dc313d14d5a3478d9e266e", + "size": 38854, + "subdir": "linux-64", + "timestamp": 1613934905572, + "version": "15.1.1" + }, + "path-15.1.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51c2f585eb1921bde30c90bbbbd3875c", + "name": "path", + "sha256": "3b1b13fb6336a3acfc0251857e57ec2a1ada9ef0ceea43807f6a615d63d41b2a", + "size": 38539, + "subdir": "linux-64", + "timestamp": 1614022264613, + "version": "15.1.2" + }, + "path-15.1.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7656bf9ec2e17f45d8b2817614982c19", + "name": "path", + "sha256": "0e280b3618433a014af115328f01ed6c8d0d9e32c7f06bababa30c10fb935620", + "size": 38605, + "subdir": "linux-64", + "timestamp": 1614022253169, + "version": "15.1.2" + }, + "path-15.1.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ffb7f243db7e7a23ef7c064edf0e8a4", + "name": "path", + "sha256": "8046dc55bd8f8332b490c7123847ee8be0611961cea89149209c14c3c09b713c", + "size": 38733, + "subdir": "linux-64", + "timestamp": 1614022254139, + "version": "15.1.2" + }, + "path-15.1.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ceed7c1220cf3999da3e6b646b18c690", + "name": "path", + "sha256": "47d06b74a8682707927f7ab7a2658e1e226be88088b9e9ed70cbe0c48dd6a431", + "size": 38883, + "subdir": "linux-64", + "timestamp": 1614022253105, + "version": "15.1.2" + }, + "path-16.0.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8bf7c35ae33ffe20073e960f43819371", + "name": "path", + "sha256": "c563cbc60613fcc47ed7062a24024000f614dc15c0dfc7bdbff904a619f8d591", + "size": 38339, + "subdir": "linux-64", + "timestamp": 1623603921621, + "version": "16.0.0" + }, + "path-16.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e31242c163fd7599262041c4a43c4241", + "name": "path", + "sha256": "89761154be62f0351dafa3bb1ad089e0c8525b47fc903f1418e6d5fce783a71e", + "size": 38337, + "subdir": "linux-64", + "timestamp": 1623598197165, + "version": "16.0.0" + }, + "path-16.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc341ec5fe0eebef4ee6bb0362c299de", + "name": "path", + "sha256": "03de37781bbd8d36d6349642444fa78b2e7ae3f667c58422e41f46a2911514bc", + "size": 38516, + "subdir": "linux-64", + "timestamp": 1623603900649, + "version": "16.0.0" + }, + "path-16.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "73694873150ea1d762067694cc491d1a", + "name": "path", + "sha256": "1dfdb7681cbf5b68e7d1b89b1dd7980e6ffd91f7914b21b922fe2935a815e68a", + "size": 38617, + "subdir": "linux-64", + "timestamp": 1623603444292, + "version": "16.0.0" + }, + "path.py-10.3.1-py27hc258cac_0.tar.bz2": { + "build": "py27hc258cac_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f2701f843981473e9d72d36921a867e2", + "name": "path.py", + "sha256": "e05944aa406200bddda550c1ee463fc802bdfba8fb2edabce54458da4b6c588b", + "size": 51274, + "subdir": "linux-64", + "timestamp": 1505747289147, + "version": "10.3.1" + }, + "path.py-10.3.1-py35hb82cfee_0.tar.bz2": { + "build": "py35hb82cfee_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "189bfedba0219f6b7a2d3fe726f7b13d", + "name": "path.py", + "sha256": "5b11cb45cf39c603604c537f0cd76c80660fe307bb94cdb5d73f3ac8c9b5e4a6", + "size": 52871, + "subdir": "linux-64", + "timestamp": 1505747301722, + "version": "10.3.1" + }, + "path.py-10.3.1-py36he0c6f6d_0.tar.bz2": { + "build": "py36he0c6f6d_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0590768167021c213ca5feef94874e56", + "name": "path.py", + "sha256": "f19c25c62d8b7d74298fcad39b72d48468c3d49e6aa41a76b62451d416eca48f", + "size": 52707, + "subdir": "linux-64", + "timestamp": 1505747314417, + "version": "10.3.1" + }, + "path.py-10.5-py27hefe4bee_0.tar.bz2": { + "build": "py27hefe4bee_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "788ec1e4449b543519e13fab87b5d481", + "name": "path.py", + "sha256": "1dad1c64446da0199c87f584b69c1a0f82728033fc3506326c8500f0b7457d4e", + "size": 52013, + "subdir": "linux-64", + "timestamp": 1511835103535, + "version": "10.5" + }, + "path.py-10.5-py35h39c98c1_0.tar.bz2": { + "build": "py35h39c98c1_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "bd0412082de974b8ef9055cda1a8241b", + "name": "path.py", + "sha256": "9d4bcbc2aa29571a8e705c7bd0327772dd1b8c36e57d102de24011d0ca49e3f0", + "size": 53874, + "subdir": "linux-64", + "timestamp": 1511835112475, + "version": "10.5" + }, + "path.py-10.5-py36h55ceabb_0.tar.bz2": { + "build": "py36h55ceabb_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "30b4dd4e9da5441eb1fe593023b45f85", + "name": "path.py", + "sha256": "439a0400e55dc2d3983d39febd6a0afa7f029fc3489be6add3539d3e6930b0e1", + "size": 53515, + "subdir": "linux-64", + "timestamp": 1511835113517, + "version": "10.5" + }, + "path.py-11.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7f04b146d9cd720828afcf160262b0a6", + "name": "path.py", + "sha256": "c66aac6b387ea7f4988553f85cf0770f20f93733289d901050ce541e742fe383", + "size": 52706, + "subdir": "linux-64", + "timestamp": 1519067206640, + "version": "11.0" + }, + "path.py-11.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "530be1e6db5095101071cb9c9fd13cb1", + "name": "path.py", + "sha256": "e00c128cdddb57a5f98461245ba10636a932c10b71ab135b4ac6c59ead3319c2", + "size": 54290, + "subdir": "linux-64", + "timestamp": 1519067234606, + "version": "11.0" + }, + "path.py-11.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8804bf8fbc871695b48a8637ff3ca1c2", + "name": "path.py", + "sha256": "9a6a5c86e8aed238fe4a6031fa4b2b040c5268933f2307c8208716d893626de0", + "size": 54135, + "subdir": "linux-64", + "timestamp": 1519067233938, + "version": "11.0" + }, + "path.py-11.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "fb935c345ee53ac5c9cb488126e9713e", + "name": "path.py", + "sha256": "aa9068b289db4ece5dc0cfa8a1f5d38c817dd764f10f1f7cbb7babab0aaeb28a", + "size": 52709, + "subdir": "linux-64", + "timestamp": 1522691281678, + "version": "11.0.1" + }, + "path.py-11.0.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "0b3cf2b48b0b161b4c82aff259378c5d", + "name": "path.py", + "sha256": "62a31727873c50bd298a93dc13551ac56d7416701967a2492f32e86053b4b38a", + "size": 54380, + "subdir": "linux-64", + "timestamp": 1522691381956, + "version": "11.0.1" + }, + "path.py-11.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6c14f706dc206a0346b9464dd8ebf0b3", + "name": "path.py", + "sha256": "d1dcfdd4900e1a66e0ed573f5e419d68c9770fcef3b2d934f9f2775687260a8e", + "size": 54160, + "subdir": "linux-64", + "timestamp": 1522691386144, + "version": "11.0.1" + }, + "path.py-11.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "0915f2851f6ad7151afc18ac4f0ba784", + "name": "path.py", + "sha256": "e1fe648641ebdafc3e76cc768b62b3728f797cbd954ccb5b706090cfac8e9ea7", + "size": 54214, + "subdir": "linux-64", + "timestamp": 1530904864039, + "version": "11.0.1" + }, + "path.py-11.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "a18305f1190cff63eb79ebd2c1d3e4c2", + "name": "path.py", + "sha256": "73a40a5a5618ccef33d0a4229c36e410e2fef7bc6e44df60198a63fca4043c6e", + "size": 53195, + "subdir": "linux-64", + "timestamp": 1536078153768, + "version": "11.1.0" + }, + "path.py-11.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "d8905ee1179f900858adcbfb3fb82837", + "name": "path.py", + "sha256": "91655b3a803ef71344b80677b460e08d13d7d89a3f5a88037c01c9b0bc6fa5dd", + "size": 54944, + "subdir": "linux-64", + "timestamp": 1536078175267, + "version": "11.1.0" + }, + "path.py-11.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "69c7a0d007c5da8788ff5162fde33e1f", + "name": "path.py", + "sha256": "c0dd881681e7be36f94cba689a0a6d3a0fe09c2c0525160afe7a1308af88ef02", + "size": 54683, + "subdir": "linux-64", + "timestamp": 1536078111972, + "version": "11.1.0" + }, + "path.py-11.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "cb65f25c50dc5b6e67d6ad75c8f712ad", + "name": "path.py", + "sha256": "02f8303bdd2056933496984fb0cb2c74b2d4dabefdbecea04e3e0efaa7a893e4", + "size": 54779, + "subdir": "linux-64", + "timestamp": 1536078174085, + "version": "11.1.0" + }, + "path.py-11.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.os", + "importlib_metadata >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "bb661eb112efe89ef7b42dbe38fdbc92", + "name": "path.py", + "sha256": "5b743393ce6eff57a737b2fc5c3e470de134555097e2c36963cec55b55309a91", + "size": 55167, + "subdir": "linux-64", + "timestamp": 1539704237344, + "version": "11.5.0" + }, + "path.py-11.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backports.os", + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b108e3e1a8ec35cba4765e0f7f81d6ae", + "name": "path.py", + "sha256": "3c01b5c06112dedc64d474265daf48b255ae8e24a3cbbea269cada341e8a24c1", + "size": 56636, + "subdir": "linux-64", + "timestamp": 1539703409465, + "version": "11.5.0" + }, + "path.py-11.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "backports.os", + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3786777532a4938a0fc35f9e59b17756", + "name": "path.py", + "sha256": "81a03297a1ad8fd637795c8918e5b0e5dac690919e23410971d3630f42cba271", + "size": 56750, + "subdir": "linux-64", + "timestamp": 1539704277974, + "version": "11.5.0" + }, + "pathlib-1.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d5b4d796b19fce3fe201b76ff0b6f223", + "name": "pathlib", + "sha256": "61cdc5a918bc70716676131fbde57dd5284aabadb72e59b2c0a396d437777fb9", + "size": 27576, + "subdir": "linux-64", + "timestamp": 1531088626342, + "version": "1.0.1" + }, + "pathlib-1.0.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de89d9aa67890383a8c86a2a48bb0c71", + "name": "pathlib", + "sha256": "e4b6b9e896f45dd4e6afca77bdc81988bcf2a82e9f8e1dc53ad82ca87d2a72f1", + "size": 27757, + "subdir": "linux-64", + "timestamp": 1539187056033, + "version": "1.0.1" + }, + "pathlib-1.0.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "50624460a86961cffc8252a9a8586e0a", + "name": "pathlib", + "sha256": "2d1b118bb6c314ca69b44798e6132d2ac51dc5ae9c7f61aacb8cb7001c348101", + "size": 28660, + "subdir": "linux-64", + "timestamp": 1539187066880, + "version": "1.0.1" + }, + "pathlib-1.0.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ae46e138393fb5f0f4e67fc400b19ca8", + "name": "pathlib", + "sha256": "35ebe84a1cdaf8373708f597ec34925ce2c08d9acc1a6402b4acbf31672eb536", + "size": 28646, + "subdir": "linux-64", + "timestamp": 1539187068635, + "version": "1.0.1" + }, + "pathlib-1.0.1-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21bf042cb326e2a1a28bd5ef72e98d4d", + "name": "pathlib", + "sha256": "ab0ac0f14ad0b0478686eece663a98d19bf470ee24d4df4c2a182cbf86c0cde3", + "size": 3506, + "subdir": "linux-64", + "timestamp": 1594381414622, + "version": "1.0.1" + }, + "pathlib2-2.3.0-py27h6e9d198_0.tar.bz2": { + "build": "py27h6e9d198_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "scandir", + "six" + ], + "license": "MIT", + "md5": "2289c7b2df9b353f00fd1989300c20b7", + "name": "pathlib2", + "sha256": "f51dd95d1673575a650da542ca0516233056163dd59053b9b3de968bdec79dcb", + "size": 31430, + "subdir": "linux-64", + "timestamp": 1505688567061, + "version": "2.3.0" + }, + "pathlib2-2.3.0-py35hd637de4_0.tar.bz2": { + "build": "py35hd637de4_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "9ef98304e0da945b9f9b792794ea72ff", + "name": "pathlib2", + "sha256": "7abde4842af819dc4e2627b264975c3d71aafee20aa8a690d74b9f507c4a76d8", + "size": 32615, + "subdir": "linux-64", + "timestamp": 1505688577838, + "version": "2.3.0" + }, + "pathlib2-2.3.0-py36h49efa8e_0.tar.bz2": { + "build": "py36h49efa8e_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "48c497335ce45c3aa0d04ecd692ec176", + "name": "pathlib2", + "sha256": "9390947fc87a6a293fba7fd3ccc84a68ae1071c407242a0ea59de1f8fcce3e1d", + "size": 32578, + "subdir": "linux-64", + "timestamp": 1505688588892, + "version": "2.3.0" + }, + "pathlib2-2.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "scandir", + "six" + ], + "license": "MIT", + "md5": "1eb25754f547b256ba8ea49204a0ed88", + "name": "pathlib2", + "sha256": "bc6bb793681008b0c5bed7e1bfdae770c9e1403c8d0ba7841389853dd2bcb1ee", + "size": 31705, + "subdir": "linux-64", + "timestamp": 1524228904691, + "version": "2.3.2" + }, + "pathlib2-2.3.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "10ab897f645cf15d401d79e01279ad93", + "name": "pathlib2", + "sha256": "900a5930226ae846be2b50aad9106e737658d3afbccbbd9d9ce53c1916ae04fb", + "size": 32944, + "subdir": "linux-64", + "timestamp": 1524228959014, + "version": "2.3.2" + }, + "pathlib2-2.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "a28de823bf597a2e8910d2b0558f1cfa", + "name": "pathlib2", + "sha256": "39a5564a08e2802bbfa70d265a3755c7bcb3eb63584a9cb537cc5b0a5f333cca", + "size": 32784, + "subdir": "linux-64", + "timestamp": 1524228958716, + "version": "2.3.2" + }, + "pathlib2-2.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "779643f39882aa5154c8008fc37b1d3c", + "name": "pathlib2", + "sha256": "d7cb0c57364492564bd657ece888d6d4f7e26328511114c51dc420c31455b131", + "size": 32641, + "subdir": "linux-64", + "timestamp": 1530735374606, + "version": "2.3.2" + }, + "pathlib2-2.3.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "scandir", + "six" + ], + "license": "MIT", + "md5": "4056e39b98e78acf1b5e724083bae5f9", + "name": "pathlib2", + "sha256": "9a35a4336b731a63bbc5551a061920285a504eefe33f1a7a76516eee9506d29a", + "size": 31831, + "subdir": "linux-64", + "timestamp": 1545075901250, + "version": "2.3.3" + }, + "pathlib2-2.3.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "8910d1b7bafb8cf9ae643ce1e1b8f3bf", + "name": "pathlib2", + "sha256": "090e2739982ae089c68e60c65de3ce3913c90d6af6c5a496d76db7616c87e9de", + "size": 32920, + "subdir": "linux-64", + "timestamp": 1545075939285, + "version": "2.3.3" + }, + "pathlib2-2.3.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "d61775e947e19391f5525ee6606bd9e3", + "name": "pathlib2", + "sha256": "2eac6c5b0f1b78b220e81115478e1c30934b93b2a803a34202a2831735ddff4f", + "size": 32819, + "subdir": "linux-64", + "timestamp": 1545075940918, + "version": "2.3.3" + }, + "pathlib2-2.3.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "scandir", + "six" + ], + "license": "MIT", + "md5": "59ab55993f9d3467701932313669330d", + "name": "pathlib2", + "sha256": "8a158ed2dcff910313187ee79d32e6c2619ec79c837f64418649d8bc671153d1", + "size": 36208, + "subdir": "linux-64", + "timestamp": 1562085533512, + "version": "2.3.4" + }, + "pathlib2-2.3.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "f4af2b280140f983c179ef506ffe40a5", + "name": "pathlib2", + "sha256": "a0e0d546ad7c1c5a152877eac7eb6540ec06f93c98bf2b218d2a0c9aa5e594fa", + "size": 37280, + "subdir": "linux-64", + "timestamp": 1562085530712, + "version": "2.3.4" + }, + "pathlib2-2.3.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "84c7cc0686deb71f0640a24c90f5784a", + "name": "pathlib2", + "sha256": "8fb88160c68a4b7c45b070beb2a5184ac5545a51fae71e78e8506583d57cf6f9", + "size": 37322, + "subdir": "linux-64", + "timestamp": 1562085495388, + "version": "2.3.4" + }, + "pathlib2-2.3.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "scandir", + "six" + ], + "license": "MIT", + "md5": "b8b819e075b1680f2c3e069140196eea", + "name": "pathlib2", + "sha256": "1abe73a2a07171cf201f9410f3a2a2f870495b30c12c7e3eb41d161ba33fc823", + "size": 36534, + "subdir": "linux-64", + "timestamp": 1569855091937, + "version": "2.3.5" + }, + "pathlib2-2.3.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "3b82a1b280f6a9ed42363fe7ed9f9e0e", + "name": "pathlib2", + "sha256": "c7a3b6c5ceedab6812ef8ef1d5e2d9ebfa794d523eecb0f2e10971765c64b17e", + "size": 37602, + "subdir": "linux-64", + "timestamp": 1569855095642, + "version": "2.3.5" + }, + "pathlib2-2.3.5-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "de1e9da403abadaa8f03a8530db23efb", + "name": "pathlib2", + "sha256": "fd4f6ad1555b72e2f2acefe3451691a3feca9f8512a52e3da7fe4dfa88f09854", + "size": 37893, + "subdir": "linux-64", + "timestamp": 1607024988505, + "version": "2.3.5" + }, + "pathlib2-2.3.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "6684739990fa74385be306320effe2cb", + "name": "pathlib2", + "sha256": "23815d701da807dbc61eac681545891f79cc971d16859427854eaea36bd7eded", + "size": 37536, + "subdir": "linux-64", + "timestamp": 1569855086726, + "version": "2.3.5" + }, + "pathlib2-2.3.5-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "fd0eb7aed4219369ed569c787769cd0f", + "name": "pathlib2", + "sha256": "81056f80a8e1b36ee8231e7ce5afa9b09a710c34fc31b0b28f9fb6be94f743a0", + "size": 35073, + "subdir": "linux-64", + "timestamp": 1594380999505, + "version": "2.3.5" + }, + "pathlib2-2.3.5-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "2356889b3ac508e82df0515f03a2a683", + "name": "pathlib2", + "sha256": "a2f06561333dafc613614c0b0b5ad77be52674fac90308dc029dffc17652a0df", + "size": 37911, + "subdir": "linux-64", + "timestamp": 1607025004893, + "version": "2.3.5" + }, + "pathlib2-2.3.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "md5": "99b1c7df1cae3854789934372b582ba6", + "name": "pathlib2", + "sha256": "f3c66bb6b6aa097e470e641585566218a40f4d1402a4c76f7798cb38da539918", + "size": 35892, + "subdir": "linux-64", + "timestamp": 1573738466914, + "version": "2.3.5" + }, + "pathlib2-2.3.5-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "md5": "39b2f9bea11cd58dcd6e0c237af1c0d8", + "name": "pathlib2", + "sha256": "7f09872a0cabb048a523ebd95b1dd3dc7defabd55aed88d6ee682a57e3bc15e2", + "size": 38090, + "subdir": "linux-64", + "timestamp": 1607025015486, + "version": "2.3.5" + }, + "pathlib2-2.3.5-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "md5": "407b28267cd3b30322e52ffc1e4ef9bc", + "name": "pathlib2", + "sha256": "c3649f62b2f1c98f15b75370214289264e2353f5e86d96ea2df80d4c203fc182", + "size": 38177, + "subdir": "linux-64", + "timestamp": 1607024979439, + "version": "2.3.5" + }, + "pathlib2-2.3.6-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd2aa91e201f253dc37fafcec449bd25", + "name": "pathlib2", + "sha256": "cc78e8c0970e9c7a6782dbd5c424d921725c6d53e5363598ffac3cb34c953eb1", + "size": 36763, + "subdir": "linux-64", + "timestamp": 1640792253378, + "version": "2.3.6" + }, + "pathlib2-2.3.6-py311h06a4308_2.tar.bz2": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c24a0f84e3a22bceb5d4e558396ebe4", + "name": "pathlib2", + "sha256": "4bbc4c176a129e50139683807f3735587dda01bede6a27ce43501e3f484105ea", + "size": 48318, + "subdir": "linux-64", + "timestamp": 1676841608362, + "version": "2.3.6" + }, + "pathlib2-2.3.6-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c655604083b15660117cdf6fc9a6d7c", + "name": "pathlib2", + "sha256": "3f6c02cc5257b670e2dd70f99b9ad9b53d3b42ae03b311803eb5dbb6bb2d13f2", + "size": 36173, + "subdir": "linux-64", + "timestamp": 1625585351481, + "version": "2.3.6" + }, + "pathlib2-2.3.6-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ad3717b7a12555ce1c58f92b48a52f7", + "name": "pathlib2", + "sha256": "c570cfe09b59d7b849532719b540c00183198eea9a2a1f3afe4de3f4740b4da2", + "size": 36212, + "subdir": "linux-64", + "timestamp": 1625578972879, + "version": "2.3.6" + }, + "pathlib2-2.3.6-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f440a4ab7cc33800d5ba02e2da97ba17", + "name": "pathlib2", + "sha256": "2dafbcc40c74dbf09db3b25bceb024afd89296cac44a0227d2475b01467d2924", + "size": 36398, + "subdir": "linux-64", + "timestamp": 1625585703464, + "version": "2.3.6" + }, + "pathlib2-2.3.6-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ed4c4255931d5100856615b3e9577f11", + "name": "pathlib2", + "sha256": "5f9b52c55375d4541485591fe2f43fdd448f46f0349272c6eb972e67d4d6d684", + "size": 36425, + "subdir": "linux-64", + "timestamp": 1625585724675, + "version": "2.3.6" + }, + "pathspec-0.10.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "54eaa449944bf3b80b12e869c982db78", + "name": "pathspec", + "sha256": "a8c9dbe70724a2155e33a07d0f9cf8babea3ccf3ac3583c1300254a43d74738f", + "size": 48008, + "subdir": "linux-64", + "timestamp": 1674681590611, + "version": "0.10.3" + }, + "pathspec-0.10.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "5170fffdbb712419b735673c4ac7a317", + "name": "pathspec", + "sha256": "2dc037d04fb7cdbde8797764375f21b0cdd577db04112446258768fdd4c2d7a3", + "size": 55491, + "subdir": "linux-64", + "timestamp": 1679337308390, + "version": "0.10.3" + }, + "pathspec-0.10.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "59ffb1f2e70d70eafd1a4b83e0ecedf7", + "name": "pathspec", + "sha256": "e6204c0eaca2ad65098bb62968798bf1d27f3c5f75575169b30110251d41009e", + "size": 47729, + "subdir": "linux-64", + "timestamp": 1674681669753, + "version": "0.10.3" + }, + "pathspec-0.10.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "e1223cb92beed747aecb53ff7b34bb0d", + "name": "pathspec", + "sha256": "e7d7c538e337440a0dfbb15de5ddaf1d5f0d25e009b9041dc25d28eff4715428", + "size": 47894, + "subdir": "linux-64", + "timestamp": 1674681643001, + "version": "0.10.3" + }, + "pathspec-0.10.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "307c1ee81d47d2576024382ba40c7131", + "name": "pathspec", + "sha256": "60462491233e7a2c47efb3d511b0d01a76ca4be529e27abc9c6524c4dacee77c", + "size": 47794, + "subdir": "linux-64", + "timestamp": 1674681616718, + "version": "0.10.3" + }, + "pathspec-0.9.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "a506b7b48001c890f28e0545d7c73b3f", + "name": "pathspec", + "sha256": "ee6672cb6444083b8516045744e22a502938dbf6dd0763f953c1a85e7b640312", + "size": 49580, + "subdir": "linux-64", + "timestamp": 1659627207596, + "version": "0.9.0" + }, + "pathspec-0.9.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "f414febcdcaac2bb2dc0d9f99dd7faad", + "name": "pathspec", + "sha256": "c5656fd606218b151c49ca2a52834a278cb3a9ab403202e473fce2f125bb3c06", + "size": 58936, + "subdir": "linux-64", + "timestamp": 1676822816239, + "version": "0.9.0" + }, + "pathspec-0.9.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "ff1c13b311a97822bb344374ecd4d3df", + "name": "pathspec", + "sha256": "fd78f9fd86afda208f67cd595caa257138ceec9b01f546a7386dde5edf94df76", + "size": 49270, + "subdir": "linux-64", + "timestamp": 1659627152968, + "version": "0.9.0" + }, + "pathspec-0.9.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "b8da17f1078ba2d725b8fb739b314c45", + "name": "pathspec", + "sha256": "a440ca5753df40bdcfd9bf999456af6cec2a160a7f10b80f921da3a89c1197f2", + "size": 49413, + "subdir": "linux-64", + "timestamp": 1659627229424, + "version": "0.9.0" + }, + "pathspec-0.9.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "d08161b34bb2ec2963ecb25b342e1df8", + "name": "pathspec", + "sha256": "58f58da914b1dc31b630990a0b09638c79dbf75df3875a322539dd3bdb74f410", + "size": 49298, + "subdir": "linux-64", + "timestamp": 1659627175364, + "version": "0.9.0" + }, + "pathy-0.10.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "smart_open >=5.2.1,<7.0.0", + "typer >=0.3.0,<1.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1a31e0de32263faab07d296568e07dc5", + "name": "pathy", + "sha256": "e2770b22c05eafc95a37fcaa981be40ed136c4ae5ff80662b0f121cd57195c46", + "size": 81878, + "subdir": "linux-64", + "timestamp": 1674586021226, + "version": "0.10.1" + }, + "pathy-0.10.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "smart_open >=5.2.1,<7.0.0", + "typer >=0.3.0,<1.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "091204373fc7c32c73cd6171f2fb8814", + "name": "pathy", + "sha256": "0a1967efbfd102edcf77e7d101b1bad18709e38c78535fbb98ebc5500a061897", + "size": 111071, + "subdir": "linux-64", + "timestamp": 1676845119436, + "version": "0.10.1" + }, + "pathy-0.10.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "smart_open >=5.2.1,<7.0.0", + "typer >=0.3.0,<1.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f2d3bd9060082ab5707df9ce4632ccc5", + "name": "pathy", + "sha256": "e15c4caa78f045f67f16c8a46c29ce97b91ffb1a057f18ad9227ce0ed8a3d707", + "size": 80629, + "subdir": "linux-64", + "timestamp": 1674585969739, + "version": "0.10.1" + }, + "pathy-0.10.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "smart_open >=5.2.1,<7.0.0", + "typer >=0.3.0,<1.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3cd7335623d0d8a16877dc9b44b7f886", + "name": "pathy", + "sha256": "336b233cf83f824ec3ba4c9a94523579b631361019eda09607522c7eaea9c1db", + "size": 80979, + "subdir": "linux-64", + "timestamp": 1674585943671, + "version": "0.10.1" + }, + "pathy-0.10.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "smart_open >=5.2.1,<7.0.0", + "typer >=0.3.0,<1.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a65ea2faf326104259dc095c3879ab5f", + "name": "pathy", + "sha256": "2d513e58d6c64524b83bb276d23ec622772c6bef1c137b5f49fbeada15907e55", + "size": 80835, + "subdir": "linux-64", + "timestamp": 1674585995548, + "version": "0.10.1" + }, + "pathy-0.6.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "smart_open >=5.0.0,<6.0.0", + "typer >=0.3.0,<1.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2bc164441a57808f8faccf3408deaa39", + "name": "pathy", + "sha256": "726a7a67d875986b7efde439faeddd02c29f2897a1169a7ca22dfa73c0a5ce18", + "size": 73918, + "subdir": "linux-64", + "timestamp": 1651566281816, + "version": "0.6.1" + }, + "pathy-0.6.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "smart_open >=5.0.0,<6.0.0", + "typer >=0.3.0,<1.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "52362cd9486a1045c791f8e8cd238c9c", + "name": "pathy", + "sha256": "b232f5b6c47279ef9cc58fa1f09c51021b9e7562fb1b9e50158adcc05940dafb", + "size": 72614, + "subdir": "linux-64", + "timestamp": 1651566312040, + "version": "0.6.1" + }, + "pathy-0.6.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "smart_open >=5.0.0,<6.0.0", + "typer >=0.3.0,<1.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "509349124d656aa379515c6cac942fc8", + "name": "pathy", + "sha256": "299faa1f8c8fc1b4570c2fde85f934155f36856622e5a6331841173a8c1b3ed1", + "size": 73040, + "subdir": "linux-64", + "timestamp": 1651566207206, + "version": "0.6.1" + }, + "pathy-0.6.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "smart_open >=5.0.0,<6.0.0", + "typer >=0.3.0,<1.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "04e4a5c9f1c2cb8327cb5fa78922ef5d", + "name": "pathy", + "sha256": "31538709289638d7a7e33de2e000acd053abf41f35be300c2970e897c8f8282c", + "size": 72873, + "subdir": "linux-64", + "timestamp": 1651566240562, + "version": "0.6.1" + }, + "patsy-0.4.1-py27hd1cf8c0_0.tar.bz2": { + "build": "py27hd1cf8c0_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=2.7,<2.8.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "d3b0a1f5a186eecc918d04bb797aeacd", + "name": "patsy", + "sha256": "e4c08b999de9da3bc801c8da5e9dc4207997c4e05b84e698d64256618b39d4d6", + "size": 305656, + "subdir": "linux-64", + "timestamp": 1505750859899, + "version": "0.4.1" + }, + "patsy-0.4.1-py35h51b66d5_0.tar.bz2": { + "build": "py35h51b66d5_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.5,<3.6.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "057c77da9abdfb8528dab08746ea10ab", + "name": "patsy", + "sha256": "a9275c44758f99598a181bccbb3f4ef24c6528d2d1896968573a7b7d1aa4a25b", + "size": 326810, + "subdir": "linux-64", + "timestamp": 1505750875629, + "version": "0.4.1" + }, + "patsy-0.4.1-py36ha3be15e_0.tar.bz2": { + "build": "py36ha3be15e_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.6,<3.7.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "e7c8ddda1b66c445d99dc1311c933548", + "name": "patsy", + "sha256": "757f27c33b42fcee9d24737444ed3163b73addf23bf0f89aab34a07ede6c2148", + "size": 330684, + "subdir": "linux-64", + "timestamp": 1505750891697, + "version": "0.4.1" + }, + "patsy-0.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=2.7,<2.8.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "9dbc8b98c8f1c2c5eac9825c5815379f", + "name": "patsy", + "sha256": "616aa3d2aab334e0e999591f753c5df3883900f6b37ceb40eb41a3e64610ae68", + "size": 309259, + "subdir": "linux-64", + "timestamp": 1515791337598, + "version": "0.5.0" + }, + "patsy-0.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.5,<3.6.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "33165ec6775f924ea84418d86c329efb", + "name": "patsy", + "sha256": "55097a983a4eb7e0f5cc93862076d89053f0044190cc6fd95812d9cd41507dd6", + "size": 329249, + "subdir": "linux-64", + "timestamp": 1515791501104, + "version": "0.5.0" + }, + "patsy-0.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.6,<3.7.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "8e649417044aa5e765b89c94a62746f4", + "name": "patsy", + "sha256": "c8366cb8bc5c8e536614a83a144b400f864bf53fd9c4e4f225b49b3b509e8e8f", + "size": 329441, + "subdir": "linux-64", + "timestamp": 1515791277570, + "version": "0.5.0" + }, + "patsy-0.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.7,<3.8.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "32deced5e8a8cde3a08d9f74ac886b5a", + "name": "patsy", + "sha256": "fa4f00e33472cbf55c900383594a3326ef3a1b840e4e5ade9167c45ddea1a0ed", + "size": 328327, + "subdir": "linux-64", + "timestamp": 1530904896409, + "version": "0.5.0" + }, + "patsy-0.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=2.7,<2.8.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "0840f89af3aa790bfffc3c5f488193d2", + "name": "patsy", + "sha256": "05dafe5b90c2f79c7e6a8f9d25bc1730c3d8540c97487f539c5905ffdcd49e7d", + "size": 384134, + "subdir": "linux-64", + "timestamp": 1540996270545, + "version": "0.5.1" + }, + "patsy-0.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.6,<3.7.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "28668aa69ee8dde06026fcc03ba30803", + "name": "patsy", + "sha256": "cd982c6d0d71ea300e28c37b55bab2231eec4fc8d7e66495e75fd41c782eab50", + "size": 388969, + "subdir": "linux-64", + "timestamp": 1540996289343, + "version": "0.5.1" + }, + "patsy-0.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.7,<3.8.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "b938a671c6a324e0349017093aa4133b", + "name": "patsy", + "sha256": "c257c92dde11b6187267cf3cb7acd18a8beec83a0af9e4e74bec267c1b6d6386", + "size": 383643, + "subdir": "linux-64", + "timestamp": 1540996298710, + "version": "0.5.1" + }, + "patsy-0.5.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.8,<3.9.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "5d30bcde4ffdd1ce1adc6f06d3ce1bff", + "name": "patsy", + "sha256": "2d92d16d2241612d02c1fb080765846511ed4e4404bfab80b7e3ac21d1385890", + "size": 389570, + "subdir": "linux-64", + "timestamp": 1574355293115, + "version": "0.5.1" + }, + "patsy-0.5.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.9,<3.10.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "8f66a31aa516ada28e3a66a07bdc24fa", + "name": "patsy", + "sha256": "e62b98953ea6f48406b7af3fbf48e590093e70adbcc2018ad59bd3a47df20829", + "size": 385877, + "subdir": "linux-64", + "timestamp": 1607693805630, + "version": "0.5.1" + }, + "patsy-0.5.2-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "numpy >=1.4.0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "d7370988b4ae8f1c73984afb6fb988cf", + "name": "patsy", + "sha256": "67b75812d7cdbc5e0012106aa40872672dbe2571da25a237e69a87833394c86c", + "size": 392956, + "subdir": "linux-64", + "timestamp": 1644379659690, + "version": "0.5.2" + }, + "patsy-0.5.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.7,<3.8.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "3a646886db77598b57293aaa5b8c1dbd", + "name": "patsy", + "sha256": "fb37031bb962acb2df145b6997b1233f94622c7099fe202c0779e2663ef9e528", + "size": 387822, + "subdir": "linux-64", + "timestamp": 1633530142070, + "version": "0.5.2" + }, + "patsy-0.5.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "numpy >=1.4.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "dd0d3242ec86f625e0217f7dca125359", + "name": "patsy", + "sha256": "8de25e934957ca06bb590ab7b136a991fa175d4f3c1b887dc36a72b0c2b6c462", + "size": 386432, + "subdir": "linux-64", + "timestamp": 1644395890850, + "version": "0.5.2" + }, + "patsy-0.5.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.8,<3.9.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "91152648749e38c33583492458cb74fc", + "name": "patsy", + "sha256": "ae8f6cb4fbe5a4685142dabc5d14ce8ca29cf9344562819e4dc1c1078b9afca4", + "size": 385576, + "subdir": "linux-64", + "timestamp": 1633530136234, + "version": "0.5.2" + }, + "patsy-0.5.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "numpy >=1.4.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "6d4b20b24bf24cd6c36d917e87a811d4", + "name": "patsy", + "sha256": "6ea6058d88712cb000e8a1aaf59ff6664a8af2c09ac0cbdaa5afb6b566296eb1", + "size": 392219, + "subdir": "linux-64", + "timestamp": 1644377767224, + "version": "0.5.2" + }, + "patsy-0.5.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.9,<3.10.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "cf8ae315d294ccda8047de0818303516", + "name": "patsy", + "sha256": "c966fed8764432a856ed272bc1daa6b9254f27dce19e77b8aad856c21a2485fa", + "size": 388075, + "subdir": "linux-64", + "timestamp": 1633529464107, + "version": "0.5.2" + }, + "patsy-0.5.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "numpy >=1.4.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "b5403cba77edaa4404117745222cb82b", + "name": "patsy", + "sha256": "9dd001ad2d67d61cd3534fa0c42981f80434d6d0b9ffac98572ff9f5297599e9", + "size": 386861, + "subdir": "linux-64", + "timestamp": 1644395888965, + "version": "0.5.2" + }, + "patsy-0.5.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "fe813685f709261d93e29895035b53de", + "name": "patsy", + "sha256": "810ef9214ae2305edf2cd85c17475554ed8bc366bc8807892630234c231b001f", + "size": 390550, + "subdir": "linux-64", + "timestamp": 1674585981372, + "version": "0.5.3" + }, + "patsy-0.5.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "b42c5e10afa94b846eaf4a05d577d9c9", + "name": "patsy", + "sha256": "83916d884b8bec2be6021fc879ad04f7dd5cfe9cdc468ef6eccbac7daf86c09a", + "size": 457699, + "subdir": "linux-64", + "timestamp": 1676841622771, + "version": "0.5.3" + }, + "patsy-0.5.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "7bc653ffab99645b047bd841b851cf49", + "name": "patsy", + "sha256": "9394be9ea8c7f7365bc91b1822be193aadd2b9e93bfc64d7375ff58b4965385d", + "size": 388303, + "subdir": "linux-64", + "timestamp": 1674586012398, + "version": "0.5.3" + }, + "patsy-0.5.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "c6b23f355231924849479961a964f1cc", + "name": "patsy", + "sha256": "278f16ae438641231aed912c511db6f68ec736a4a5543de827996824b0b3e971", + "size": 389338, + "subdir": "linux-64", + "timestamp": 1674585918087, + "version": "0.5.3" + }, + "patsy-0.5.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "27954ad0b7d03f841ff86941a3336a58", + "name": "patsy", + "sha256": "8ed64b9135c1fc1f103cc53a44a4337f3d79fa83e77b0a19d52f5c2accba471d", + "size": 388671, + "subdir": "linux-64", + "timestamp": 1674585951087, + "version": "0.5.3" + }, + "pbkdf2-1.3-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "dcfa387a269c95e4c70a2d6b895b5bbb", + "name": "pbkdf2", + "sha256": "db333f795a884079acf1d173d8dff15588776e95a41682133bac8ab40682d2dc", + "size": 12966, + "subdir": "linux-64", + "timestamp": 1540356021429, + "version": "1.3" + }, + "pbkdf2-1.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "b9e26b7cc44e1b8d8300347b658bb2bc", + "name": "pbkdf2", + "sha256": "66fb3cea568e03c7be03ae8a89f1b375cc0b59be88e4c2cdef1c1ec7679bbe28", + "size": 13559, + "subdir": "linux-64", + "timestamp": 1640792271352, + "version": "1.3" + }, + "pbkdf2-1.3-py311h06a4308_2.tar.bz2": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "97360b46c1022589b0c6cfaa0e625a23", + "name": "pbkdf2", + "sha256": "7147933323660e5716af900c7bae3d8cab1909c4339a4025ca3a19efb52d6de8", + "size": 16611, + "subdir": "linux-64", + "timestamp": 1676906097043, + "version": "1.3" + }, + "pbkdf2-1.3-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "004c25d5f2c9271f648a981e49f42a0a", + "name": "pbkdf2", + "sha256": "4cadc445f313294a770aab1482c1eb92be4b810a4c631b8b6911618c981e9947", + "size": 13166, + "subdir": "linux-64", + "timestamp": 1540356034499, + "version": "1.3" + }, + "pbkdf2-1.3-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a6d9f1048ff181c7095e3210f2076ff7", + "name": "pbkdf2", + "sha256": "8fd3ee39a7ed9a47447bb687508f03931b47eb80a05bd171d46ff9f4af82fea8", + "size": 233488, + "subdir": "linux-64", + "timestamp": 1614007679761, + "version": "1.3" + }, + "pbkdf2-1.3-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "56fbbabc3e42b9b0f3717e16a858e79b", + "name": "pbkdf2", + "sha256": "c90171a613cac4a5a3850b6d755ebf9646c4989e4cac46f84713a831204cc061", + "size": 13184, + "subdir": "linux-64", + "timestamp": 1540356035705, + "version": "1.3" + }, + "pbkdf2-1.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "65903703a11fc860039e4ae7ed8a2f0c", + "name": "pbkdf2", + "sha256": "e9d906c0213d41d20f69a39c99cc4a7bf4a3ad8c40ffe3ccc907a303d9deabdf", + "size": 234001, + "subdir": "linux-64", + "timestamp": 1614006796696, + "version": "1.3" + }, + "pbkdf2-1.3-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "aa6b28b0caa4ac7a02e6583dfba3e80d", + "name": "pbkdf2", + "sha256": "a20aa329912a118120c38b3372795e1582d4a237c6cee7773e504cd3e8f6fd36", + "size": 13452, + "subdir": "linux-64", + "timestamp": 1573489507429, + "version": "1.3" + }, + "pbkdf2-1.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "f291b5eb48aadfd5c9a15476e0e66ee6", + "name": "pbkdf2", + "sha256": "91f21cfaf999dc0b15c56ad6455d05ae83aedce33c31d0d3d64f6583e2e7affc", + "size": 233549, + "subdir": "linux-64", + "timestamp": 1614007686092, + "version": "1.3" + }, + "pbkdf2-1.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "723c52a20033b7aef91c187f61c09dfd", + "name": "pbkdf2", + "sha256": "50a02316581e4da4e01a0d9ee6dd1d159b54d86cf3139dc519649deea765a5e5", + "size": 13696, + "subdir": "linux-64", + "timestamp": 1607007507799, + "version": "1.3" + }, + "pbr-3.1.1-py27hf64632f_0.tar.bz2": { + "build": "py27hf64632f_0", + "build_number": 0, + "depends": [ + "pip", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8580521ea48403290a72e9ca2d6e95fc", + "name": "pbr", + "sha256": "87538855dea3a913fe895a22623af5658e23cbd1321a94408efa3eaf67c3648e", + "size": 112623, + "subdir": "linux-64", + "timestamp": 1505691190625, + "version": "3.1.1" + }, + "pbr-3.1.1-py35hdfb5056_0.tar.bz2": { + "build": "py35hdfb5056_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8e777c63cbfb575fc765eb803a3d9733", + "name": "pbr", + "sha256": "acbaa140caa43ad625250d6d04ecf5585acb720ec89648656b01cb062fbea5ca", + "size": 115075, + "subdir": "linux-64", + "timestamp": 1505691204523, + "version": "3.1.1" + }, + "pbr-3.1.1-py36hb5f6b33_0.tar.bz2": { + "build": "py36hb5f6b33_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bd281dd4c6945422f273ce0a1f0572cc", + "name": "pbr", + "sha256": "4d0edaa35c7a7cdc510fad0d27e7a8120c7b979058999f71e557bf27719ddd30", + "size": 114851, + "subdir": "linux-64", + "timestamp": 1505691218732, + "version": "3.1.1" + }, + "pbr-4.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pip", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "42c7896bb792081fcff8f6f9b67cc303", + "name": "pbr", + "sha256": "85670b16076beea98fbb54a2d77d975f9800e83697a5cec0372aaf0261744aab", + "size": 113231, + "subdir": "linux-64", + "timestamp": 1522784725287, + "version": "4.0.0" + }, + "pbr-4.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b8af96c5fd50076459978ce0f78ee6ec", + "name": "pbr", + "sha256": "e86862efb560d590d861ef7c5d69e17d09842388481be1e75f34f9b08bd09f27", + "size": 115815, + "subdir": "linux-64", + "timestamp": 1522784726643, + "version": "4.0.0" + }, + "pbr-4.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "922d838521813d1111b0863e36139892", + "name": "pbr", + "sha256": "63d30eb4d2c9c994b5434d9957cd3f93e7e4649e115c3985cb4b630229629c25", + "size": 115485, + "subdir": "linux-64", + "timestamp": 1522784710281, + "version": "4.0.0" + }, + "pbr-4.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pip", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5030c8ae8d1718f47617f9a48960310e", + "name": "pbr", + "sha256": "a59d8be32f41a2be506be012e5c50607ed1cd63b7777783f0c1df0df3e842794", + "size": 113791, + "subdir": "linux-64", + "timestamp": 1524071873069, + "version": "4.0.2" + }, + "pbr-4.0.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "febc579df3dd89a4f2e714670f54f90b", + "name": "pbr", + "sha256": "ccfb286774b79ba4a5cddb00034c21148f77c871b838893a8e315d82dd4dac06", + "size": 116266, + "subdir": "linux-64", + "timestamp": 1524071876476, + "version": "4.0.2" + }, + "pbr-4.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0bfbf73325cbda64c516428af9e402a1", + "name": "pbr", + "sha256": "f2156de3e9803e17c3cdf7e3603bad6d6551cb3250016a503963982204e4ef2a", + "size": 115949, + "subdir": "linux-64", + "timestamp": 1524071876058, + "version": "4.0.2" + }, + "pbr-4.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pip", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d969d32b6f9036f639dfa79ce9104399", + "name": "pbr", + "sha256": "21eb2cfba906f134871234b93cfd3a1cd9c01273fc87964f201bab4da2219e49", + "size": 116557, + "subdir": "linux-64", + "timestamp": 1526930542535, + "version": "4.0.3" + }, + "pbr-4.0.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dd23906ba69714f1e4e84d7c434980cb", + "name": "pbr", + "sha256": "d9c34bac589db2d583f98f309d3fa63bf909535adb81bf1cc2da4d7ef3cbc261", + "size": 119045, + "subdir": "linux-64", + "timestamp": 1526930563790, + "version": "4.0.3" + }, + "pbr-4.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9e58972dba1be3b36e2203cd096cb40d", + "name": "pbr", + "sha256": "9282f93ce98b967917f48543062284c4025206d979755471c83486b019efe43c", + "size": 118694, + "subdir": "linux-64", + "timestamp": 1526930507554, + "version": "4.0.3" + }, + "pbr-4.0.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pip", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "255511e6ead6732aebbf55e2006b41c2", + "name": "pbr", + "sha256": "ad50489270db2e3bf6039ab63028b7d9e55e958b88fa58ae9404c875b7496779", + "size": 116780, + "subdir": "linux-64", + "timestamp": 1529429830780, + "version": "4.0.4" + }, + "pbr-4.0.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "61c589410672297c50687546dd5de088", + "name": "pbr", + "sha256": "f97200ae62c0ae677fe9c3236fe5a6802137b79fc49e116785d5e1e289981b72", + "size": 119201, + "subdir": "linux-64", + "timestamp": 1529429867723, + "version": "4.0.4" + }, + "pbr-4.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ed71d6959898cd8f0937c2ee1d41ee8b", + "name": "pbr", + "sha256": "acd03c6e08c5296e4720eaaf17546e8b1a2d06fbf3c886098eed34a4e9bc6f48", + "size": 118856, + "subdir": "linux-64", + "timestamp": 1529429774328, + "version": "4.0.4" + }, + "pbr-4.0.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ddd59b791b8b92aaa369142b8735f81c", + "name": "pbr", + "sha256": "ef3189a6bf576bd636e26141452f83e1590b76fbbf1a3a972707d243d230bdd5", + "size": 118787, + "subdir": "linux-64", + "timestamp": 1530727990716, + "version": "4.0.4" + }, + "pbr-4.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pip", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "447bb1a0de5624682f5c8e12f2fbd530", + "name": "pbr", + "sha256": "fc28d9374c877bc34333869f33840dea42b7bc878f43871fc5774921caa0ab91", + "size": 118668, + "subdir": "linux-64", + "timestamp": 1532883560547, + "version": "4.2.0" + }, + "pbr-4.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fdac57e1ac27f6e65889c9e15ec02f36", + "name": "pbr", + "sha256": "64a44939670d248e6305700d35c4a0bc4c1051c3910f5e3f7e71d663bd189fec", + "size": 121205, + "subdir": "linux-64", + "timestamp": 1532883591757, + "version": "4.2.0" + }, + "pbr-4.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b3b3355e5a292957451f6fe97732a468", + "name": "pbr", + "sha256": "9b100d4aa93df17b9fb0ce7473c2ac7b308ba142131ebc9a4a4e87e2cc3b9f91", + "size": 120853, + "subdir": "linux-64", + "timestamp": 1532883517218, + "version": "4.2.0" + }, + "pbr-4.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "57282d8b5166dd3ab8b97d9d31ddc899", + "name": "pbr", + "sha256": "1472afb7bf7e42fdd923acd39997dbc882f27b131bc3ba754554d9bb755d917e", + "size": 120649, + "subdir": "linux-64", + "timestamp": 1532883584370, + "version": "4.2.0" + }, + "pbr-4.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pip", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7e0c72196adc0f841e49ab3509999391", + "name": "pbr", + "sha256": "e820a9b86f7ed1355c9abe3d377c8ac62c769dbb5453124c4d6f02281f167353", + "size": 123547, + "subdir": "linux-64", + "timestamp": 1539652335586, + "version": "4.3.0" + }, + "pbr-4.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0f4fd1762a16ca9b8d78f269230b3e0c", + "name": "pbr", + "sha256": "926f746535b456203eeefa69e737a7796e4a7eda0b994c6d1d6509694aaf2ee5", + "size": 125370, + "subdir": "linux-64", + "timestamp": 1539652356149, + "version": "4.3.0" + }, + "pbr-4.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6818208e565d7fb6b7f8cd9ca4e9d8b8", + "name": "pbr", + "sha256": "51bbac76200f892a5408a295c4fd995dc631118a9e285dd69fec95837bfeb548", + "size": 125244, + "subdir": "linux-64", + "timestamp": 1539652351087, + "version": "4.3.0" + }, + "pbr-5.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pip", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "501f0ef2fd2a9b4d0c07a95fb6d2f78d", + "name": "pbr", + "sha256": "fe8063d1deb93049eaf242ba61d4daae2e9b38414e55b5bf5ee78595ff611960", + "size": 123580, + "subdir": "linux-64", + "timestamp": 1540997142618, + "version": "5.1.0" + }, + "pbr-5.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ba4d37d0236313441e9b0aef1f7ef75b", + "name": "pbr", + "sha256": "c7e1b042c76c60e5659fe963f91fe869428e7faaf18c9732b0336e65036ec2ab", + "size": 125230, + "subdir": "linux-64", + "timestamp": 1540997160915, + "version": "5.1.0" + }, + "pbr-5.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "92f357389b414ca9724d37ea0f604b88", + "name": "pbr", + "sha256": "0f74199dfa01699e67ce4f1e7da9c664d09ea117a2ea5cc60b9fe20599b98016", + "size": 125139, + "subdir": "linux-64", + "timestamp": 1540997117298, + "version": "5.1.0" + }, + "pbr-5.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pip", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5989fb162b40cffd0719683193af1e78", + "name": "pbr", + "sha256": "4a3b293389c2019c6156ed695baa0554f7b3e005c1620da4b22aad7e9b2ab777", + "size": 123410, + "subdir": "linux-64", + "timestamp": 1542083670674, + "version": "5.1.1" + }, + "pbr-5.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b0e072db8d088c0977a46e6745c2d51f", + "name": "pbr", + "sha256": "8df33ca5a6adf0f73a2247ee6de8b64d0185149f26081d81c67c77837bef046e", + "size": 125200, + "subdir": "linux-64", + "timestamp": 1542083709549, + "version": "5.1.1" + }, + "pbr-5.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "94955262c79eb241fb45e823e23336b8", + "name": "pbr", + "sha256": "23d7ee528b794dc393a10b1119011ee09799e98fd49b8fa891e458b972a385f6", + "size": 125155, + "subdir": "linux-64", + "timestamp": 1542083647488, + "version": "5.1.1" + }, + "pcre-8.41-hc27e229_1.tar.bz2": { + "build": "hc27e229_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "047c7aec4f91b1090e90e2c8aff63909", + "name": "pcre", + "sha256": "1cab5248ba7e094d40fb7afe257a23fafb6d72b7e0897110883cb21ac797082a", + "size": 256747, + "subdir": "linux-64", + "timestamp": 1510610241348, + "version": "8.41" + }, + "pcre-8.41-hc71a17e_0.tar.bz2": { + "build": "hc71a17e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c979c852dd26d2e3de370a51d9fc0856", + "name": "pcre", + "sha256": "7d3e1db4ea2e5749c333b6d4362ab5ce166455109e6567d32d0679fb4a0bdfc8", + "size": 256056, + "subdir": "linux-64", + "timestamp": 1505734397623, + "version": "8.41" + }, + "pcre-8.42-h439df22_0.tar.bz2": { + "build": "h439df22_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a97eeaf9611a4f4c74019db226ec0eff", + "name": "pcre", + "sha256": "342aa84ef4ff06dd75c2fb0d4122e92e2ea7d678d3c61748a56315fc9e8aebed", + "size": 256798, + "subdir": "linux-64", + "timestamp": 1523631954672, + "version": "8.42" + }, + "pcre-8.43-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9df225e404f4ea30bed1da3986e703ad", + "name": "pcre", + "sha256": "f5fe8c4427ce772adad5a41871d3c287ec1988b1e55914309095cd8ebc33cabc", + "size": 266295, + "subdir": "linux-64", + "timestamp": 1552419679242, + "version": "8.43" + }, + "pcre-8.44-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "50cc854152beb1dfb6dbd492ccf8cc1c", + "name": "pcre", + "sha256": "300953c53b5e062bae9bfe59f4af0941f4da0ec325442abe06a9291bddaafe08", + "size": 275679, + "subdir": "linux-64", + "timestamp": 1593049055043, + "version": "8.44" + }, + "pcre-8.45-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4bac8a874e62f41ebab8345ca6076eb6", + "name": "pcre", + "sha256": "4881cc5e0d5b20335bcfba4eaf29fdc95dedf2607903aabecdacffb64d3407d4", + "size": 263308, + "subdir": "linux-64", + "timestamp": 1624477853289, + "version": "8.45" + }, + "pcre2-10.35-h14c3975_1.tar.bz2": { + "build": "h14c3975_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bbb2760be40690acac30563433985241", + "name": "pcre2", + "sha256": "cab77674eec407bd9b8cabf2851d342b5c73e7650bc662d6ac3b85b8a3351c71", + "size": 619808, + "subdir": "linux-64", + "timestamp": 1601274249294, + "version": "10.35" + }, + "pcre2-10.35-h86c1b69_1.tar.bz2": { + "build": "h86c1b69_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d3ea41b0f41abc847b4b4244c7f12f57", + "name": "pcre2", + "sha256": "d692e8b3fb6c56bee32986161a7270018a3c54fa8d28b944af6a74994a8caf85", + "size": 623893, + "subdir": "linux-64", + "timestamp": 1601274215857, + "version": "10.35" + }, + "pcre2-10.37-he7ceb23_1.tar.bz2": { + "build": "he7ceb23_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e4045830821b30220cde347dff25e772", + "name": "pcre2", + "sha256": "32e6b17eae868e5df43991be8af3cfe786fbab470100b20f756786e10b5c265d", + "size": 1149759, + "subdir": "linux-64", + "timestamp": 1641403802629, + "version": "10.37" + }, + "pdm-2.2.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "blinker", + "cachecontrol >=0.12.11", + "certifi >=2022.6.15", + "findpython >=0.2.0", + "packaging >=20.9", + "pdm-pep517 <2.0.0,>=1.0.0", + "pep517 >=0.11.0", + "platformdirs", + "python >=3.10,<3.11.0a0", + "python-dotenv >=0.15", + "python-installer <0.6,>=0.5.1", + "requests-toolbelt", + "resolvelib <0.9,>=0.8", + "rich >=12.3.0", + "shellingham >=1.3.2", + "tomli >=1.1.0", + "tomlkit <1,>=0.11.1", + "unearth >=0.6.0", + "virtualenv >=20" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "423c79935a6a9e59842b097f76f351aa", + "name": "pdm", + "sha256": "914f19912f4b7371cd753e52cb7d33734572759a00345d88240c5df604e89144", + "size": 287847, + "subdir": "linux-64", + "timestamp": 1670440572140, + "version": "2.2.1" + }, + "pdm-2.2.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "blinker", + "cachecontrol >=0.12.11", + "certifi >=2022.6.15", + "findpython >=0.2.0", + "packaging >=20.9", + "pdm-pep517 <2.0.0,>=1.0.0", + "pep517 >=0.11.0", + "platformdirs", + "python >=3.11,<3.12.0a0", + "python-dotenv >=0.15", + "python-installer <0.6,>=0.5.1", + "requests-toolbelt", + "resolvelib <0.9,>=0.8", + "rich >=12.3.0", + "shellingham >=1.3.2", + "tomlkit <1,>=0.11.1", + "unearth >=0.6.0", + "virtualenv >=20" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12963821546a26b47822ff3ebd397b21", + "name": "pdm", + "sha256": "440945b59287e9fb3c6e6adcbddf822b60c6097ee81fbb05b1afec62939b8936", + "size": 389538, + "subdir": "linux-64", + "timestamp": 1676845134948, + "version": "2.2.1" + }, + "pdm-2.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "blinker", + "cachecontrol >=0.12.11", + "certifi >=2022.6.15", + "findpython >=0.2.0", + "importlib-metadata >=3.6", + "packaging >=20.9", + "pdm-pep517 <2.0.0,>=1.0.0", + "pep517 >=0.11.0", + "platformdirs", + "python >=3.7,<3.8.0a0", + "python-dotenv >=0.15", + "python-installer <0.6,>=0.5.1", + "requests-toolbelt", + "resolvelib <0.9,>=0.8", + "rich >=12.3.0", + "shellingham >=1.3.2", + "tomli >=1.1.0", + "tomlkit <1,>=0.11.1", + "typing-extensions", + "unearth >=0.6.0", + "virtualenv >=20" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0f71965f3d400c323e2b94ded75bd55", + "name": "pdm", + "sha256": "b685428bf5f8fc24c9a329c28e91064c90a0ade37b90e52877a3633203491c6e", + "size": 281463, + "subdir": "linux-64", + "timestamp": 1670440509102, + "version": "2.2.1" + }, + "pdm-2.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "blinker", + "cachecontrol >=0.12.11", + "certifi >=2022.6.15", + "findpython >=0.2.0", + "importlib-metadata >=3.6", + "packaging >=20.9", + "pdm-pep517 <2.0.0,>=1.0.0", + "pep517 >=0.11.0", + "platformdirs", + "python >=3.8,<3.9.0a0", + "python-dotenv >=0.15", + "python-installer <0.6,>=0.5.1", + "requests-toolbelt", + "resolvelib <0.9,>=0.8", + "rich >=12.3.0", + "shellingham >=1.3.2", + "tomli >=1.1.0", + "tomlkit <1,>=0.11.1", + "unearth >=0.6.0", + "virtualenv >=20" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9312f033bcdbaba64c78a35e89a242ca", + "name": "pdm", + "sha256": "0bb3c930f6bd86e084fcb6ac9f605bda5c672ab6121444ab497c8d853ca1feb0", + "size": 283545, + "subdir": "linux-64", + "timestamp": 1670440602828, + "version": "2.2.1" + }, + "pdm-2.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "blinker", + "cachecontrol >=0.12.11", + "certifi >=2022.6.15", + "findpython >=0.2.0", + "importlib-metadata >=3.6", + "packaging >=20.9", + "pdm-pep517 <2.0.0,>=1.0.0", + "pep517 >=0.11.0", + "platformdirs", + "python >=3.9,<3.10.0a0", + "python-dotenv >=0.15", + "python-installer <0.6,>=0.5.1", + "requests-toolbelt", + "resolvelib <0.9,>=0.8", + "rich >=12.3.0", + "shellingham >=1.3.2", + "tomli >=1.1.0", + "tomlkit <1,>=0.11.1", + "unearth >=0.6.0", + "virtualenv >=20" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1da52d80b9aca491f3c387726d3bad62", + "name": "pdm", + "sha256": "e9ad353b4db989549317eae781ff2469a58d30527ca110c3352126ae813ce2d1", + "size": 283611, + "subdir": "linux-64", + "timestamp": 1670440541111, + "version": "2.2.1" + }, + "pdm-pep517-1.0.6-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "220c915950b3fa5ee26d04da8adcfa5c", + "name": "pdm-pep517", + "sha256": "1a8a3574856a29cb92cba450dc9f5df9718796034e4af9708dfc7cc0a763e016", + "size": 465213, + "subdir": "linux-64", + "timestamp": 1669763773491, + "version": "1.0.6" + }, + "pdm-pep517-1.0.6-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "114acf22e6f8268792457abf14c9dbef", + "name": "pdm-pep517", + "sha256": "94ad719b562041cbedb3f97df795f49b374c665ba0e061f7fc615095d0322d81", + "size": 584675, + "subdir": "linux-64", + "timestamp": 1676827348051, + "version": "1.0.6" + }, + "pdm-pep517-1.0.6-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98be86990a570f08e63360f191e98202", + "name": "pdm-pep517", + "sha256": "410ac3a7a022d5b976ce200658bab11afa5b1f3a2c443c4aba421d2ca024af5a", + "size": 457889, + "subdir": "linux-64", + "timestamp": 1669763799098, + "version": "1.0.6" + }, + "pdm-pep517-1.0.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c528ea1580c208736b4fbf80c3b5a3e", + "name": "pdm-pep517", + "sha256": "cfea92e952e1eb43df868cfa12127789985b2993a36c92011ecf11df918a086a", + "size": 460309, + "subdir": "linux-64", + "timestamp": 1669763722441, + "version": "1.0.6" + }, + "pdm-pep517-1.0.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4c99735c3ea810c2662f1060790a137f", + "name": "pdm-pep517", + "sha256": "4644b53c57e50ab4440ccb8cc4771a0d6629a820d40734d191f32d9a207a00f0", + "size": 461497, + "subdir": "linux-64", + "timestamp": 1669763747917, + "version": "1.0.6" + }, + "pefile-2022.5.30-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc6281c640f2b5c62cf25adfd36d2a79", + "name": "pefile", + "sha256": "ed2327a84ba0fe030a205f22b5ed3ac14248d4042ee99196768a197cae1796a9", + "size": 120102, + "subdir": "linux-64", + "timestamp": 1670877403937, + "version": "2022.5.30" + }, + "pefile-2022.5.30-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e1d4f112447586e05783dd671f8cd16", + "name": "pefile", + "sha256": "dc342ca1fea7b81d0ec10d7339cc65e3045a90c81fe3ab8c8ca84003e80cb9ff", + "size": 158664, + "subdir": "linux-64", + "timestamp": 1676860313730, + "version": "2022.5.30" + }, + "pefile-2022.5.30-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef0ff93de0e3dffa985433f7ef4cb3b9", + "name": "pefile", + "sha256": "1760a619084c3afc9b4781f25673e41558f4b31c2c718f478871f3300ea15366", + "size": 115695, + "subdir": "linux-64", + "timestamp": 1670877373486, + "version": "2022.5.30" + }, + "pefile-2022.5.30-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a01452a41b1f4c626dbb7f705d82b743", + "name": "pefile", + "sha256": "cdadc53b8958ed5a23e03f98eb348c81dc11be3454e17647c53be6026b463ffd", + "size": 116438, + "subdir": "linux-64", + "timestamp": 1670877342899, + "version": "2022.5.30" + }, + "pefile-2022.5.30-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18490f75556caef915228c9929c6e499", + "name": "pefile", + "sha256": "d86735db400e34e19f6b183a0a5fccf30c71ca48a28371a6800108beb17e2e07", + "size": 115962, + "subdir": "linux-64", + "timestamp": 1670877434248, + "version": "2022.5.30" + }, + "pegen-0.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5a6d518a7c4c387d0efc7a7bebc08fcd", + "name": "pegen", + "sha256": "f2850657e3e5011ebc4d8726e0713a74015cf86255786bdf3fc0ba7b374f2a94", + "size": 59569, + "subdir": "linux-64", + "timestamp": 1678308899710, + "version": "0.2.0" + }, + "pegen-0.2.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14bcd6bd5d7bb7308df3339cca5f8398", + "name": "pegen", + "sha256": "a19ea1f0ad43e25d74d4350a2b93a64ed57bd4bf84039047159278c00badef32", + "size": 79296, + "subdir": "linux-64", + "timestamp": 1679340576353, + "version": "0.2.0" + }, + "pegen-0.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "32306c4eace0bd1a2661885ec7f622ff", + "name": "pegen", + "sha256": "ca0d69c023fc787e634bf43ce13d4ff34f170b717aecc8a6d4daf4f1f9afa1d1", + "size": 58563, + "subdir": "linux-64", + "timestamp": 1678308927976, + "version": "0.2.0" + }, + "pegen-0.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "421a2a50bbdf52ae6b7edf3873154829", + "name": "pegen", + "sha256": "c4a52d809ba20575631ed31d6bed6f8fc8e6d75a40cca03321797be3534e29c2", + "size": 58606, + "subdir": "linux-64", + "timestamp": 1678308956370, + "version": "0.2.0" + }, + "pendulum-1.4.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytzdata", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d0752c2eb946543f070e070771e79fa0", + "name": "pendulum", + "sha256": "4c075b8980788d0b590280fefabf911a7946ab24e838cbd81d22896649aaaf6d", + "size": 139608, + "subdir": "linux-64", + "timestamp": 1579634504836, + "version": "1.4.4" + }, + "pendulum-1.4.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytzdata", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a181c8f3b448009cc219f5553a8da648", + "name": "pendulum", + "sha256": "2d8657c103fe0d9b4a840fabeb4f49fbfb83919055e404c68384d7ffed94e820", + "size": 140920, + "subdir": "linux-64", + "timestamp": 1579634445614, + "version": "1.4.4" + }, + "pendulum-1.4.4-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytzdata", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f6042094b56bf2e2c20454d66a5b9ce", + "name": "pendulum", + "sha256": "f7a0b8f510f3cb3844bad35b85d6916ad5babf66d7b0744f514b119b008a3cdd", + "size": 417154, + "subdir": "linux-64", + "timestamp": 1632893916671, + "version": "1.4.4" + }, + "pendulum-1.4.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytzdata", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8853ad2ea8b9eeeb909589eac19351ef", + "name": "pendulum", + "sha256": "135141c25f5ed97026a11170811593d9c17e702ccd41305588c2b46225341f9b", + "size": 140862, + "subdir": "linux-64", + "timestamp": 1579634557456, + "version": "1.4.4" + }, + "pendulum-1.4.4-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytzdata", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d983213a7b3920eeea601786863461b2", + "name": "pendulum", + "sha256": "04f0444f8c9434687f5a95b4130b2aca6a12e922f20da5567ebb981c5fb092b2", + "size": 417221, + "subdir": "linux-64", + "timestamp": 1632884230206, + "version": "1.4.4" + }, + "pendulum-1.4.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil", + "pytzdata", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3042487e5372ff114db66a68e4d15007", + "name": "pendulum", + "sha256": "7b60ecf4a3abd2d299c5eaeb0d1d7efc34d1f0ed87717af6f103e35f93d1c1bb", + "size": 141772, + "subdir": "linux-64", + "timestamp": 1579634521153, + "version": "1.4.4" + }, + "pendulum-1.4.4-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil", + "pytzdata", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "76e44a2a71543b0718c51f71124d0b34", + "name": "pendulum", + "sha256": "1e810e7a96c35c8a46bcf3a356fa9ff84b1708d585131ba17a806e524709c6ea", + "size": 409612, + "subdir": "linux-64", + "timestamp": 1632894666895, + "version": "1.4.4" + }, + "pendulum-1.4.4-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil", + "pytzdata", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "787a4c5edd66478f6633dcbec8ecb873", + "name": "pendulum", + "sha256": "b8ba8e0f2d490c6d660b0bcc3308fa2914727e4f815c3f06801b42cfe4b8527c", + "size": 417016, + "subdir": "linux-64", + "timestamp": 1632894649820, + "version": "1.4.4" + }, + "pendulum-2.0.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6,<3.0", + "pytzdata >=2018.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "adb560bfaec71c4a8dc47cc775d6bb0f", + "name": "pendulum", + "sha256": "c923e08536eb5fe98c08d71e28af23730b5f983a22ae901f546e872d5dd8ceae", + "size": 133603, + "subdir": "linux-64", + "timestamp": 1592416820148, + "version": "2.0.5" + }, + "pendulum-2.0.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6,<3.0", + "pytzdata >=2018.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e84f655a6e5658659562598fcca56539", + "name": "pendulum", + "sha256": "3dbbf0218ca33df0db88f39eefccd64821c8296f2dd765501436b10190ffc657", + "size": 133789, + "subdir": "linux-64", + "timestamp": 1592416812580, + "version": "2.0.5" + }, + "pendulum-2.0.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6,<3.0", + "pytzdata >=2018.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bdff3b7e9b20c3f5451777f95703be08", + "name": "pendulum", + "sha256": "f748c9a757c2c28cb2afcaf78c75d963ab1d9e2ce9b55e2823d7bf432a665b42", + "size": 134759, + "subdir": "linux-64", + "timestamp": 1592416820162, + "version": "2.0.5" + }, + "pendulum-2.1.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6,<3.0", + "pytzdata >=2018.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c20131fb431973d7f7cfd3fefad80218", + "name": "pendulum", + "sha256": "08e9508bc4681f19897927b70f18f940cdde963cc528a94c64c9ba4215364313", + "size": 143050, + "subdir": "linux-64", + "timestamp": 1585316327073, + "version": "2.1.0" + }, + "pendulum-2.1.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6,<3.0", + "pytzdata >=2018.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e0acae59b7b5d73eca7a8d2ac4bc9fc", + "name": "pendulum", + "sha256": "7d4d3129ce0f5cb43e9473f7ac0d6c82cbf1ca882d64d54c6c8d258165d7eb26", + "size": 143383, + "subdir": "linux-64", + "timestamp": 1585316268912, + "version": "2.1.0" + }, + "pendulum-2.1.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6,<3.0", + "pytzdata >=2018.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "25ec1fece7cca25c9cb79c50ffeb77a6", + "name": "pendulum", + "sha256": "120aa82b3e10fbd040a36d6c7b7cca9453624ae80c371455fdabb5fcb634c085", + "size": 144391, + "subdir": "linux-64", + "timestamp": 1585316336878, + "version": "2.1.0" + }, + "pendulum-2.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6,<3.0", + "pytzdata >=2020.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "590fc6b6f705eb596702b786e07fd669", + "name": "pendulum", + "sha256": "2ca7e939f126fc6b20680bef144db81fb45366da17eba963fa101b9cc23291c5", + "size": 146453, + "subdir": "linux-64", + "timestamp": 1597791238308, + "version": "2.1.2" + }, + "pendulum-2.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6,<3.0", + "pytzdata >=2020.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f43ee6d5752b6c755456b461c312971", + "name": "pendulum", + "sha256": "f8148ffa7a3c8394de1f6b85c0908da986c54b8bf9ec4988d1aaf1cbbc8e7b8c", + "size": 146629, + "subdir": "linux-64", + "timestamp": 1597791234705, + "version": "2.1.2" + }, + "pendulum-2.1.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6,<3.0", + "pytzdata >=2020.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "67561dc879422b22256bea86c1f3aff1", + "name": "pendulum", + "sha256": "89896b2bafaae8aebd7da4f342b5bbbb5158fad295e509cbfec872b29a08380b", + "size": 147526, + "subdir": "linux-64", + "timestamp": 1597791217882, + "version": "2.1.2" + }, + "pep517-0.12.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f64c5ae9fc6fbce3a42e0f7e3256c025", + "name": "pep517", + "sha256": "ca38b803de3986e9f1e906a1197a3f2026e8b10a809653cce87d62765248cfd2", + "size": 33175, + "subdir": "linux-64", + "timestamp": 1640809920511, + "version": "0.12.0" + }, + "pep517-0.12.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e181bd66ccde203e4017970039e4fd36", + "name": "pep517", + "sha256": "5b84a6cb21c255a20fe543c4bdb133e5b1a47e02d4190979fa063f4a09d6b46e", + "size": 43197, + "subdir": "linux-64", + "timestamp": 1676825079787, + "version": "0.12.0" + }, + "pep517-0.12.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "tomli >=1.1.0", + "zipp" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48b2a5a1a44aae7adda8def09ae7504a", + "name": "pep517", + "sha256": "d197aa49d34b40054d919b180bce510b77dd90fbc1fe568b6a58f12011643a8e", + "size": 35331, + "subdir": "linux-64", + "timestamp": 1637318599281, + "version": "0.12.0" + }, + "pep517-0.12.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85127cc7a47e3ae55db998e323417419", + "name": "pep517", + "sha256": "8510aedb6934d06c6b863edf65a2257cd25170b54e257a545ebb92191fba6c76", + "size": 35489, + "subdir": "linux-64", + "timestamp": 1637318439229, + "version": "0.12.0" + }, + "pep517-0.12.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21053307d0cffe9d1b704be70339f0ca", + "name": "pep517", + "sha256": "ba734a04b997674aa967abe3096096ddf16d2dd2d4b88faf08055aeebc5956cf", + "size": 35660, + "subdir": "linux-64", + "timestamp": 1637305781059, + "version": "0.12.0" + }, + "pep8-1.7.0-py27h444351c_0.tar.bz2": { + "build": "py27h444351c_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "709234e3f3778d66a329af7bb9859809", + "name": "pep8", + "sha256": "c253e652f6617c792c3352ef70e79319986d8cc1b3131ed7c4c9a413f2273b68", + "size": 51707, + "subdir": "linux-64", + "timestamp": 1505750905892, + "version": "1.7.0" + }, + "pep8-1.7.0-py35hee76f29_0.tar.bz2": { + "build": "py35hee76f29_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "b9b4f84cb2ce2cf579f9f4c2b2e9afda", + "name": "pep8", + "sha256": "c20e412e0807ba15bbce1c0a463065923d2ebd17d7a3cd1e646963616a3fb3f3", + "size": 52591, + "subdir": "linux-64", + "timestamp": 1505750918586, + "version": "1.7.0" + }, + "pep8-1.7.0-py36h26ade29_0.tar.bz2": { + "build": "py36h26ade29_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "24555da2e90afb0d16435d68d6c21edf", + "name": "pep8", + "sha256": "219c1ac203837face7e9b8e6249a294784f535e3f497123fc3d17ce2129fac31", + "size": 52360, + "subdir": "linux-64", + "timestamp": 1505750931677, + "version": "1.7.0" + }, + "pep8-1.7.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "a84daa8f1d67794b15774682b7119f63", + "name": "pep8", + "sha256": "c82ebbd115292bf0ac27189ba01f4604bf2d56feb49ae7115654e467121d9f8a", + "size": 52306, + "subdir": "linux-64", + "timestamp": 1515707146020, + "version": "1.7.1" + }, + "pep8-1.7.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "b3d372926816c94b87a22951609dc7ed", + "name": "pep8", + "sha256": "74a53dac6655449a64d506f456eb105c4e390dc0fb0cf89abd62a6a8475a4573", + "size": 53355, + "subdir": "linux-64", + "timestamp": 1640792289291, + "version": "1.7.1" + }, + "pep8-1.7.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "abb84b8a45f00f4aa59ffc4cbee74b63", + "name": "pep8", + "sha256": "282ab16bfd1d13446eaded340eabfa18276e84c043fdb5f8ae8cb274784fb920", + "size": 53519, + "subdir": "linux-64", + "timestamp": 1657175636754, + "version": "1.7.1" + }, + "pep8-1.7.1-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49ac4033f952c041ae482874e8fffa33", + "name": "pep8", + "sha256": "3a84d9491e08215b15c3fec24eddf684c7ca6c053fefd345cb87e7dcf63897d0", + "size": 69037, + "subdir": "linux-64", + "timestamp": 1676860328959, + "version": "1.7.1" + }, + "pep8-1.7.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "994cd87082c0b898c0bb9d34bc47e00c", + "name": "pep8", + "sha256": "37129a400fd57147619d0658a5763b151cc5f86f795f9ba37fc8a2d25e7725fe", + "size": 53135, + "subdir": "linux-64", + "timestamp": 1515707263905, + "version": "1.7.1" + }, + "pep8-1.7.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "72de2b04d62396ef2b536c6c7a52e6d5", + "name": "pep8", + "sha256": "4e56a8d589c1619c3dae42ea4d7501f89c5b79ee5d8d2fdd8a32e1180deddfd7", + "size": 52869, + "subdir": "linux-64", + "timestamp": 1515707060611, + "version": "1.7.1" + }, + "pep8-1.7.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "618444b507dd5ad292850ce346d36987", + "name": "pep8", + "sha256": "7460fc1285dd0f20f14978d1d0a4013b9e4d4711e347af79a20b4c701e54af80", + "size": 52727, + "subdir": "linux-64", + "timestamp": 1530904927231, + "version": "1.7.1" + }, + "pep8-1.7.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5dde8e5f4d93d1243c3a858423d52009", + "name": "pep8", + "sha256": "0f1b2b8fd7151c25170f1eb3259f465d19459503601a7f75e95aae35511289c5", + "size": 53150, + "subdir": "linux-64", + "timestamp": 1657175568184, + "version": "1.7.1" + }, + "pep8-1.7.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "6c29ec857b3a8c46b249b134b7393f81", + "name": "pep8", + "sha256": "49176d190dd2dc5807c9ddf0dee087570f0eb6e9752f1324a653a39c671f80f9", + "size": 53334, + "subdir": "linux-64", + "timestamp": 1573489521707, + "version": "1.7.1" + }, + "pep8-1.7.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "753c5ac843e78babf7cc76c0b07af053", + "name": "pep8", + "sha256": "f3d9b1bfb9907a0bcfb9bed5ed1cb665592fea25e7fcc659a38d76e6f1d308c6", + "size": 53231, + "subdir": "linux-64", + "timestamp": 1657175540509, + "version": "1.7.1" + }, + "pep8-1.7.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "ea48747e829238dcb184361a66c35636", + "name": "pep8", + "sha256": "65ead540c04dd6a45ddddf8a9149d29d719f272bb0be30facd879b70d277911c", + "size": 54491, + "subdir": "linux-64", + "timestamp": 1607573999361, + "version": "1.7.1" + }, + "pep8-1.7.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1299a3a878345266f95746fc7d639618", + "name": "pep8", + "sha256": "88feed667f3e386eaaa4dd2e8a2667ad8939b60071f58303fa356511c25aeb84", + "size": 53115, + "subdir": "linux-64", + "timestamp": 1657175597438, + "version": "1.7.1" + }, + "pep8-naming-0.11.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3715d80a1ce6e13afe4474cee7931fb9", + "name": "pep8-naming", + "sha256": "d6bb386ca255036d174221f0d398f60ab7d7660d7ee228c6e18ab98bf61196f7", + "size": 18394, + "subdir": "linux-64", + "timestamp": 1600457461276, + "version": "0.11.1" + }, + "pep8-naming-0.11.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d20ee73f6c5e7ef9ce55394de342d0e3", + "name": "pep8-naming", + "sha256": "8335634b8af14d0b5e3ec1c37a513d60a7edb8ae242d0189dd6c26566fdc6187", + "size": 18352, + "subdir": "linux-64", + "timestamp": 1600457428850, + "version": "0.11.1" + }, + "pep8-naming-0.11.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d53a68c46e19125a61c03e755907dced", + "name": "pep8-naming", + "sha256": "002af3ac5c20c65f350b31b1f06fd8fe7892b1080cbb4d5cdbb910b25ce19a22", + "size": 18411, + "subdir": "linux-64", + "timestamp": 1600457472599, + "version": "0.11.1" + }, + "pep8-naming-0.12.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flake8 >=3.9.1", + "flake8-polyfill >=1.0.2,<2", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4a94d42062cf5026f6ecaff96aa7db1c", + "name": "pep8-naming", + "sha256": "5f05a6a66a22f42c6a2520b2a0a38974f96342fa367672d43a27fb3aa99e1d02", + "size": 19336, + "subdir": "linux-64", + "timestamp": 1642517395105, + "version": "0.12.0" + }, + "pep8-naming-0.12.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flake8 >=3.9.1", + "flake8-polyfill >=1.0.2,<2", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4d99d1cd2a6e389a8f28f65675dc303", + "name": "pep8-naming", + "sha256": "56a5369e54148c564f7c262bbc43094f30ee1f6619ca755bdedcd119587fca19", + "size": 24315, + "subdir": "linux-64", + "timestamp": 1677697086323, + "version": "0.12.0" + }, + "pep8-naming-0.12.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "flake8 >=3.9.1", + "flake8-polyfill >=1.0.2,<2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5fb765a378072b956f20a6a9024ae4c6", + "name": "pep8-naming", + "sha256": "98fca465e305ca1c6c88fc6a33bd74b8a9857dabdd64851558a11020cba0d4f4", + "size": 18971, + "subdir": "linux-64", + "timestamp": 1626239146985, + "version": "0.12.0" + }, + "pep8-naming-0.12.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flake8 >=3.9.1", + "flake8-polyfill >=1.0.2,<2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e1bf43338e2e34b6d05f317c91b7b1f7", + "name": "pep8-naming", + "sha256": "99069af7a38adc92b04537a8876756c4dc215ebeee5e11b149d2664095ae1e3c", + "size": 19017, + "subdir": "linux-64", + "timestamp": 1626246191159, + "version": "0.12.0" + }, + "pep8-naming-0.12.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flake8 >=3.9.1", + "flake8-polyfill >=1.0.2,<2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd511618f943a3b644ada504dbed3133", + "name": "pep8-naming", + "sha256": "0c4c8890de34bc992b8943e72c771ed2927e17159bac8330fd5cd002514d983d", + "size": 19029, + "subdir": "linux-64", + "timestamp": 1626246053073, + "version": "0.12.0" + }, + "pep8-naming-0.12.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flake8 >=3.9.1", + "flake8-polyfill >=1.0.2,<2", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "97822da63d3f393b2e3e37433847095a", + "name": "pep8-naming", + "sha256": "3d9535f7716b52acf4201ca9cd08fb9b12b12adaa3f7131549447a1ceca0e051", + "size": 18973, + "subdir": "linux-64", + "timestamp": 1626246204478, + "version": "0.12.0" + }, + "pep8-naming-0.4.1-py27h7a85148_0.tar.bz2": { + "build": "py27h7a85148_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aebb29d8ab711c32b4ada9fc247cbcb6", + "name": "pep8-naming", + "sha256": "8231b13d76d5788ea9c0d82780c4f7c137c60dbdee040f8339e9f6c5a528571f", + "size": 12132, + "subdir": "linux-64", + "timestamp": 1505750944907, + "version": "0.4.1" + }, + "pep8-naming-0.4.1-py35h8375fd2_0.tar.bz2": { + "build": "py35h8375fd2_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "76fb573e2654b299ae78c3f5c6f8c2c4", + "name": "pep8-naming", + "sha256": "721d31cbe61ad155d17f768fb86bc3ae29009e087af6db2fa131453d2fd8dfec", + "size": 12416, + "subdir": "linux-64", + "timestamp": 1505750957202, + "version": "0.4.1" + }, + "pep8-naming-0.4.1-py36h11f6f4a_0.tar.bz2": { + "build": "py36h11f6f4a_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eeec6436541f8bdc9b6b1d5791b6d829", + "name": "pep8-naming", + "sha256": "d0714f01e81b13f3c70c10415e24b07e30ff33d275996318851ba5d27edf38d6", + "size": 12306, + "subdir": "linux-64", + "timestamp": 1505750970278, + "version": "0.4.1" + }, + "pep8-naming-0.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "88b3d1eae5fae7085c066031888ade54", + "name": "pep8-naming", + "sha256": "f6fa252aae86e383ee4df909b39ecc1b197f617691f53e25bb42b58bf64e3b8e", + "size": 12414, + "subdir": "linux-64", + "timestamp": 1524096797138, + "version": "0.5.0" + }, + "pep8-naming-0.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "86a3f9d4906e76661438f33a40733823", + "name": "pep8-naming", + "sha256": "32d6a1d6ad7df7a221c11f079a38c64e0b6b38f2d89727b43f263cfbd7b4d58b", + "size": 12717, + "subdir": "linux-64", + "timestamp": 1524096341968, + "version": "0.5.0" + }, + "pep8-naming-0.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fcaca3e38948717bab01a0eccbcefbfe", + "name": "pep8-naming", + "sha256": "a25c88f6f7876ac26ef9073d0217f7d70de12af8dfffb5fbec02c952a2ae01a7", + "size": 12614, + "subdir": "linux-64", + "timestamp": 1524096837080, + "version": "0.5.0" + }, + "pep8-naming-0.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7d018143f935f6b991a637b8f8f95040", + "name": "pep8-naming", + "sha256": "a799db54d83be2f52bc5f0c9117d4874c0d0482add01c641699599a74e625692", + "size": 14231, + "subdir": "linux-64", + "timestamp": 1526940289890, + "version": "0.7.0" + }, + "pep8-naming-0.7.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ab38dbccb763646d2350da9a253b260", + "name": "pep8-naming", + "sha256": "2136528a2f7825c87516c0e31026f5b2d2a9045295647c3c4c5dfcd128404091", + "size": 14556, + "subdir": "linux-64", + "timestamp": 1526940315519, + "version": "0.7.0" + }, + "pep8-naming-0.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9f3b5a16c93f746163d296bb167f350", + "name": "pep8-naming", + "sha256": "6ea56cdc1ad5a1bd73a7c2e68da62f841fcd44bd0d51adff41e573128ea214e3", + "size": 14453, + "subdir": "linux-64", + "timestamp": 1526940264744, + "version": "0.7.0" + }, + "pep8-naming-0.7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba3036e30bb1f067f016e44779648373", + "name": "pep8-naming", + "sha256": "bc6b8bb05c3c6d313334f722abe7098dd8f31fe31ff83e3d120076395b427742", + "size": 14507, + "subdir": "linux-64", + "timestamp": 1530904958779, + "version": "0.7.0" + }, + "pep8-naming-0.8.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "174209f8890d74c4865895eed780a9f1", + "name": "pep8-naming", + "sha256": "a8e0b8795e6ace226397332842cec6f39ddaad5ae4b37c0c4dc2bb06fe3a190e", + "size": 20098, + "subdir": "linux-64", + "timestamp": 1552440350766, + "version": "0.8.2" + }, + "pep8-naming-0.8.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef404fce9877217d6271360fdb703e77", + "name": "pep8-naming", + "sha256": "dbd770f3b95a56fdadc5fa2093af7e8c9c48e42594f3f1694139a2dfc3f4a925", + "size": 20394, + "subdir": "linux-64", + "timestamp": 1552440537016, + "version": "0.8.2" + }, + "pep8-naming-0.8.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6ff5c513fbe3d30b25a6bcc824f222f", + "name": "pep8-naming", + "sha256": "a95154585f3781abec2eae15eec82f02cc039c56bbcac96d43ee09cfaaf1083e", + "size": 20762, + "subdir": "linux-64", + "timestamp": 1613557188999, + "version": "0.8.2" + }, + "pep8-naming-0.8.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dfe4780467c27f1faeacdfad80ac5a44", + "name": "pep8-naming", + "sha256": "fb26adf96048b4fae897fc4ed278f06084df772ffe3ad90e6c7e43519edee522", + "size": 20394, + "subdir": "linux-64", + "timestamp": 1552440355993, + "version": "0.8.2" + }, + "pep8-naming-0.8.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3a44536a44c295799690c32e43415ff", + "name": "pep8-naming", + "sha256": "fb1e051fd93b5471cfae2d5f75a4ddd1f52a9176e56351d4cca846d272fc3388", + "size": 20817, + "subdir": "linux-64", + "timestamp": 1613557176000, + "version": "0.8.2" + }, + "pep8-naming-0.8.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fefd46b4158a448191dc1a984751e94a", + "name": "pep8-naming", + "sha256": "1047746ffa223983eba767cdbaec5fa7ef8c218810750723402a34e22d71a8ed", + "size": 16873, + "subdir": "linux-64", + "timestamp": 1574177627575, + "version": "0.8.2" + }, + "pep8-naming-0.8.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "545f1f3d7bf21b367e1dcc10d93a5a02", + "name": "pep8-naming", + "sha256": "c61eb8b0a92308368ab07d72e04d3745442c8b66d744fd1d0de11a6e6844cfee", + "size": 20814, + "subdir": "linux-64", + "timestamp": 1613557179541, + "version": "0.8.2" + }, + "pep8-naming-0.8.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f7fcc5cea62a9080c53f01b0b012948", + "name": "pep8-naming", + "sha256": "874157e1cb92ca99ed683d5f2e6ad3b6b4266a6416acab86e3c53a87e7659565", + "size": 20835, + "subdir": "linux-64", + "timestamp": 1613557191379, + "version": "0.8.2" + }, + "perf-1.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six", + "statistics" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "8bbab955d1df83b6010b30779a041327", + "name": "perf", + "sha256": "b9502b56b455a27fda3f879d01fd049eef864dd9781841c6dd401447c02d2b2b", + "size": 140124, + "subdir": "linux-64", + "timestamp": 1531066797639, + "version": "1.5.1" + }, + "perf-1.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "80730877d0dba12d49ae08dd7a6b0527", + "name": "perf", + "sha256": "9796c61e0d43f510745b1454963e216454c5b4659502f3daf6c4d8948ce494ea", + "size": 143379, + "subdir": "linux-64", + "timestamp": 1531066723689, + "version": "1.5.1" + }, + "perf-1.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "cf51995b2221e70106f2b4c565907307", + "name": "perf", + "sha256": "139e86e35e7ae7488c2f0ee6aae7d7ebb3ed76c24cd8eea1d4d48f9c6abe7ed4", + "size": 143157, + "subdir": "linux-64", + "timestamp": 1531066761202, + "version": "1.5.1" + }, + "performance-0.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "perf", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "27b6258611e1d9fbaa42832fead4998c", + "name": "performance", + "sha256": "3b114c9f90f8f513d3476773cb8744f5447507f9ca4c73b54061fc97b6e3d13e", + "size": 2517361, + "subdir": "linux-64", + "timestamp": 1531066838299, + "version": "0.6.1" + }, + "performance-0.6.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "perf", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "77a21f11327cda05486b7c3ca6dba018", + "name": "performance", + "sha256": "2377049f8a2e0fe84b97bd148278118cbb0deff03455b474b81259cfa8821e49", + "size": 2517583, + "subdir": "linux-64", + "timestamp": 1531066879194, + "version": "0.6.1" + }, + "performance-0.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "perf", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "9d115b80396f992244deea0fbc86f52b", + "name": "performance", + "sha256": "01c0f8ebda40c4d44abfc94e3ed0264dc89644b7e52127d30ff9c149987d01e7", + "size": 2538229, + "subdir": "linux-64", + "timestamp": 1545167681307, + "version": "0.7.0" + }, + "performance-0.7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "perf", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "f191cc5dcabf40e7b38e2b8adbcf8e6f", + "name": "performance", + "sha256": "32aa82660fb573f9cd7768b45a35090e64168bf6b97dcfbdb31c05b73ba2f0b0", + "size": 2588365, + "subdir": "linux-64", + "timestamp": 1545167715195, + "version": "0.7.0" + }, + "perl-5.26.0-hae598fd_0.tar.bz2": { + "build": "hae598fd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "Perl", + "license_family": "Other", + "md5": "67431063eeed843dab2b1d0efe80b5c1", + "name": "perl", + "sha256": "ed73ea7cd38ba83d72b4f266b6441fcd649ca6d07628cd6ecf5e0fa6914f811d", + "size": 16597843, + "subdir": "linux-64", + "timestamp": 1505666299464, + "version": "5.26.0" + }, + "perl-5.26.2-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "Perl Artistic", + "license_family": "Other", + "md5": "b1704ba8a704dad758e14808869c913a", + "name": "perl", + "sha256": "f0ee43d855b3754857b1b08536d782183b52d26cf08523cf9eb9ad44d344369e", + "size": 16649883, + "subdir": "linux-64", + "timestamp": 1527832845796, + "version": "5.26.2" + }, + "perl-5.32.1-0_h5eee18b_perl5.tar.bz2": { + "build": "0_h5eee18b_perl5", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libnsl >=2.0.0,<2.1.0a0" + ], + "license": "GPL-1.0-or-later OR Artistic-1.0-Perl", + "license_family": "Other", + "md5": "ce5a0deaa92b068604b457c875b4afec", + "name": "perl", + "sha256": "aa5732a06aac87fa347b04f3f12d13e46183c6b031e9ae127ebc7e65cc1809f0", + "size": 15112963, + "subdir": "linux-64", + "timestamp": 1667421052418, + "version": "5.32.1" + }, + "perl-5.34.0-h5eee18b_1.tar.bz2": { + "build": "h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "GPL-1.0-or-later OR Artistic-1.0-Perl", + "license_family": "Other", + "md5": "1a1c2f67361c6dabf5ad647c50d0a0e5", + "name": "perl", + "sha256": "c2fbeb25cb58d34d98da3a8f13b965b7be4ac4d063dd0047252cc59724cb34b2", + "size": 13921257, + "subdir": "linux-64", + "timestamp": 1667810458984, + "version": "5.34.0" + }, + "perl-5.34.0-h5eee18b_2.tar.bz2": { + "build": "h5eee18b_2", + "build_number": 2, + "depends": [ + "gdbm >=1.18", + "gdbm >=1.18,<1.19.0a0", + "libgcc-ng >=11.2.0" + ], + "license": "GPL-1.0-or-later OR Artistic-1.0-Perl", + "license_family": "Other", + "md5": "a89c3565efda58a9001138bc7ad10119", + "name": "perl", + "sha256": "9c2e72e567ae42670ac71d20b9dd8585de0d39d1b3b9827481cbccdd6c7bfbc6", + "size": 13896466, + "subdir": "linux-64", + "timestamp": 1667922215060, + "version": "5.34.0" + }, + "perl-xml-parser-2.44_01-pl5340hf309648_0.tar.bz2": { + "build": "pl5340hf309648_0", + "build_number": 0, + "depends": [ + "expat >=2.4.9,<3.0a0", + "libgcc-ng >=11.2.0", + "perl" + ], + "license": "Artistic-1.0-Perl", + "license_family": "Other", + "md5": "6e71cd4d39c17b745125b0fa3ea96b0d", + "name": "perl-xml-parser", + "sha256": "9d607126090f3a2a0582fbdea8ffe4790571a6f5c2ba6bb21128b657e04949cd", + "size": 159895, + "subdir": "linux-64", + "timestamp": 1667973093517, + "version": "2.44_01" + }, + "persistent-4.2.4.2-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "522e966dccbf3ce41ae2e625db2af5b2", + "name": "persistent", + "sha256": "6209d1ef7dc5cc18986efc85b8d2f85367a6ad3feead09f92d175cb045763b61", + "size": 138152, + "subdir": "linux-64", + "timestamp": 1524234019051, + "version": "4.2.4.2" + }, + "persistent-4.2.4.2-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "683a1ba67202a4b2432ed0462100d059", + "name": "persistent", + "sha256": "0815b88781ecb7da7bda4772cd19dce841d6039cf84ba68a5154820e8bf5261b", + "size": 143351, + "subdir": "linux-64", + "timestamp": 1524234019054, + "version": "4.2.4.2" + }, + "persistent-4.2.4.2-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "41aa7ec22c16accd9f7044dfb3cb966b", + "name": "persistent", + "sha256": "a98ba1a626b880570bfe4dc4d54d6bb3cfbc8f09816d6ba8608ba9b64eb7806e", + "size": 143037, + "subdir": "linux-64", + "timestamp": 1524233955220, + "version": "4.2.4.2" + }, + "persistent-4.2.4.2-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "42375654c906b846d765c9acd9c8758d", + "name": "persistent", + "sha256": "41517c98d3d12ec4a1c9d249d7061e0e250fb98b7af132e17deee1eee6e8dff6", + "size": 142599, + "subdir": "linux-64", + "timestamp": 1530875289185, + "version": "4.2.4.2" + }, + "persistent-4.4.2-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "856a87d7521bbc0fc851f96ea0b436cd", + "name": "persistent", + "sha256": "b4b86e76e85a102277e74464409df1f9d9448c2396c38f29570f6dcf0ded6c2c", + "size": 144795, + "subdir": "linux-64", + "timestamp": 1536263262663, + "version": "4.4.2" + }, + "persistent-4.4.2-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "2291e5304628bb932e913d5225f54f47", + "name": "persistent", + "sha256": "171b2086797230a8e75c57522eafc836ca985bff4bd4816f33640a1a98995392", + "size": 150148, + "subdir": "linux-64", + "timestamp": 1536263306125, + "version": "4.4.2" + }, + "persistent-4.4.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "6bca76cd305f8c6ae06f41cd2ed6dff0", + "name": "persistent", + "sha256": "75e1b0d87e60a287526a2c5fa4f917a3d798b97ece318c13cf4d4fd777ed045b", + "size": 149850, + "subdir": "linux-64", + "timestamp": 1536263204267, + "version": "4.4.2" + }, + "persistent-4.4.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "ad7a4c971526804706d4efbf42b2072d", + "name": "persistent", + "sha256": "5377efa1fd0dbce5c60a94b0267f05fdacafee82f0accc30a91b812598f3b3bf", + "size": 149521, + "subdir": "linux-64", + "timestamp": 1536263320102, + "version": "4.4.2" + }, + "persistent-4.4.3-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "fd3f8b2c129a85669a67595bcab6b965", + "name": "persistent", + "sha256": "d1c43468924d3d437b3c63ad6e4a8322e50be6c95fdc85bf9b66d14ed2db2a5d", + "size": 146087, + "subdir": "linux-64", + "timestamp": 1540998348216, + "version": "4.4.3" + }, + "persistent-4.4.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "c391818ff717894d3a8a00206cf40c02", + "name": "persistent", + "sha256": "8af124068cff12c8bcd689d5089a1adb20e53d3947077159bb73bd17ef493407", + "size": 151598, + "subdir": "linux-64", + "timestamp": 1540998355528, + "version": "4.4.3" + }, + "persistent-4.4.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "a39b3bf05a9960e63c02c7506f8d1cf8", + "name": "persistent", + "sha256": "5e2d1896236882c16344aa368657935a8d110acb92db4cc6762dd8eecba2ce0c", + "size": 151231, + "subdir": "linux-64", + "timestamp": 1540998372160, + "version": "4.4.3" + }, + "persistent-4.5.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "55840643d8d4360290607d4f9d5a54ec", + "name": "persistent", + "sha256": "0ba7c568229a9410335330bfb671e9fe658a14471d6c54800cb0ef8a28b7ed0a", + "size": 303410, + "subdir": "linux-64", + "timestamp": 1569438664504, + "version": "4.5.0" + }, + "persistent-4.5.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "b5b6ba6deb1b7e0ec56ffad9e1cfba18", + "name": "persistent", + "sha256": "d87c47674bd0bd16111b6b5acd3014db810c6474f025df33100657242802366e", + "size": 371538, + "subdir": "linux-64", + "timestamp": 1613040224459, + "version": "4.5.0" + }, + "persistent-4.5.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "47c481f5e39a5f60949cfcafad1f56c6", + "name": "persistent", + "sha256": "7a916b775468e526e4f2486eeec9923494805242a2abe378932be1da391673d1", + "size": 307493, + "subdir": "linux-64", + "timestamp": 1569438674435, + "version": "4.5.0" + }, + "persistent-4.5.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "bf3436b1cdf514f962d6282fb01b951a", + "name": "persistent", + "sha256": "cc7d5f5470656cfda928a05b8de74a5b68ee0fff5a57ea35dcba7e4c03202b69", + "size": 373418, + "subdir": "linux-64", + "timestamp": 1613040208234, + "version": "4.5.0" + }, + "persistent-4.5.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "f7c81ab50651fa59024c61470dbe094b", + "name": "persistent", + "sha256": "d3445f53a66d64882e6f38c82e0d1c6ee2f568155a6be104abf9ef8b7f1409ac", + "size": 307325, + "subdir": "linux-64", + "timestamp": 1569438659883, + "version": "4.5.0" + }, + "persistent-4.5.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "b82e5d0f847894bf0926ea5e8fbd696a", + "name": "persistent", + "sha256": "5cf07d17139a011f44e1ae225af002abe907390e075d8bf9e26662d2a7eb6800", + "size": 372924, + "subdir": "linux-64", + "timestamp": 1613039811451, + "version": "4.5.0" + }, + "persistent-4.6.4-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "e621078179f7af3e1677539bc5bdbe0d", + "name": "persistent", + "sha256": "d751afbe4c76097347c3c653eeda245b01cfa77de25a8b318fee72bbc7de776c", + "size": 255014, + "subdir": "linux-64", + "timestamp": 1640812656341, + "version": "4.6.4" + }, + "persistent-4.6.4-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "cd355f5555106fd6644ff22c2a04516a", + "name": "persistent", + "sha256": "dfcb991989f546e97426f01c76143b7a3074c18c974fbc3850cee9f91d330e6b", + "size": 207931, + "subdir": "linux-64", + "timestamp": 1676906120262, + "version": "4.6.4" + }, + "persistent-4.6.4-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "479949115fe5f4859d08baf068bed37a", + "name": "persistent", + "sha256": "d087daa44d0023ce667b889a1285e05b5c7eae783d45b78090968b36844f2ef5", + "size": 393163, + "subdir": "linux-64", + "timestamp": 1613041347028, + "version": "4.6.4" + }, + "persistent-4.6.4-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "2a3a654b4db54c2616af7069947a4703", + "name": "persistent", + "sha256": "160314b18464fdaf5b2e1becccbae36074b98918dd698b4ab6659708e491670e", + "size": 385462, + "subdir": "linux-64", + "timestamp": 1613041334596, + "version": "4.6.4" + }, + "persistent-4.6.4-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "1206c0f66162a97dbe4895b647a04143", + "name": "persistent", + "sha256": "b4de0564559d2565b72360e93fb977f79b1dfa4a29fe657b95128a0420062297", + "size": 398638, + "subdir": "linux-64", + "timestamp": 1613041344151, + "version": "4.6.4" + }, + "persistent-4.6.4-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "0363038916e1747c7822ec9eff6d6615", + "name": "persistent", + "sha256": "eb3f5c71d764b56b14728ec5f869fc730c1807061f8c74df1297bebf1e68b1f8", + "size": 390149, + "subdir": "linux-64", + "timestamp": 1613041050150, + "version": "4.6.4" + }, + "petl-1.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c843d37e36e3cd99bcb2c952369f3be7", + "name": "petl", + "sha256": "a19b7bac7bb39c1f90022c4e84f3a3be6aa28486928f14ddad96dedb7a55b37d", + "size": 284726, + "subdir": "linux-64", + "timestamp": 1530904996412, + "version": "1.1.1" + }, + "petl-1.1.1-py27h32202ed_0.tar.bz2": { + "build": "py27h32202ed_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "1ef9e6e3aa642e551911426574829959", + "name": "petl", + "sha256": "ac23ef4415c46ab5d50b17c9e8041247427a2b0395bd0b7316c3736aa99c19e2", + "size": 284785, + "subdir": "linux-64", + "timestamp": 1511754968082, + "version": "1.1.1" + }, + "petl-1.1.1-py35h8d510cf_0.tar.bz2": { + "build": "py35h8d510cf_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "6229dc876c2f896e9299d31eb132d33a", + "name": "petl", + "sha256": "e85f00d57ba0674cf587ec143b7316df0689f9cf20e8ba638e80cbde0d5e2f6b", + "size": 295089, + "subdir": "linux-64", + "timestamp": 1511754975943, + "version": "1.1.1" + }, + "petl-1.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "28cc7028f6335c34518d09063c2da11a", + "name": "petl", + "sha256": "90cfc371c9c477d5a7c67fa377c1cdc23cd564e82f16f06943c46a99d82e17bc", + "size": 293513, + "subdir": "linux-64", + "timestamp": 1530905031810, + "version": "1.1.1" + }, + "petl-1.1.1-py36h13e1632_0.tar.bz2": { + "build": "py36h13e1632_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "23316ca1e5448cef9ca0a0f8fafa0cd0", + "name": "petl", + "sha256": "b13dbfeb48693c4b748d3441cb252cec405241f8d472d0f4d353e2304b5e3344", + "size": 293272, + "subdir": "linux-64", + "timestamp": 1511754977165, + "version": "1.1.1" + }, + "petl-1.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f6e3b85fc2e375b3570b8dfa8704bbe5", + "name": "petl", + "sha256": "91506308a13944dd3aa415aef9fae7d48b64d807a6e560264b0f8bf1054fdec4", + "size": 282932, + "subdir": "linux-64", + "timestamp": 1530905066819, + "version": "1.1.1" + }, + "petl-1.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "61845acb4f62c0019ddd8878ca68cad6", + "name": "petl", + "sha256": "7683abd7ec28729faf8cd0f483cc4c93bacea2a84b933e49e86c78e2e2a1b2d8", + "size": 277204, + "subdir": "linux-64", + "timestamp": 1535503111514, + "version": "1.2.0" + }, + "petl-1.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "e173850ecb238c6138d2e68d7691b60e", + "name": "petl", + "sha256": "47451fb99e2f7730aff2bd080d25cf1e2ab19c369c90ed1f2408226d81d9d4d5", + "size": 286995, + "subdir": "linux-64", + "timestamp": 1535503132343, + "version": "1.2.0" + }, + "petl-1.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "97ccf347bfb1ec8b28194c2b97eaf86b", + "name": "petl", + "sha256": "bd3013eb35bdf0a7c60222accf232a9ca6bc0f451f0a3412dc508e1ba0509ca5", + "size": 285577, + "subdir": "linux-64", + "timestamp": 1535503060091, + "version": "1.2.0" + }, + "petl-1.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "756bc6e4dda22064a5b7f71072e7f121", + "name": "petl", + "sha256": "59cab266f2d5bc0faa5abea2dcb517edf1bf5489112555760afed0202a3812a6", + "size": 275379, + "subdir": "linux-64", + "timestamp": 1535503161531, + "version": "1.2.0" + }, + "pexpect-4.2.1-py27hcf82287_0.tar.bz2": { + "build": "py27hcf82287_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "d80a3af58ce5665807c2f286bb39ccff", + "name": "pexpect", + "sha256": "89a65c27dd4d8e85a4f3fb5cf0a5dfbf4d4ac9a506957b432143ca1022908652", + "size": 70647, + "subdir": "linux-64", + "timestamp": 1505690249749, + "version": "4.2.1" + }, + "pexpect-4.2.1-py35h8b56cb4_0.tar.bz2": { + "build": "py35h8b56cb4_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "3f527b09fde1eed5059ce13451c822ef", + "name": "pexpect", + "sha256": "f16dbd42c5d2d37617380265f54057f30cbfdad5b2c86a9c06cbd2995c62359f", + "size": 73280, + "subdir": "linux-64", + "timestamp": 1505690261284, + "version": "4.2.1" + }, + "pexpect-4.2.1-py36h3b9d41b_0.tar.bz2": { + "build": "py36h3b9d41b_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "7fc7892974f8a102140e696c13991e34", + "name": "pexpect", + "sha256": "24afb18b7834532343a8ef3965d95f2b9ead8c684301d3e6022f61ed28ba0d51", + "size": 73176, + "subdir": "linux-64", + "timestamp": 1505690272959, + "version": "4.2.1" + }, + "pexpect-4.3.0-py27hdeba8d9_0.tar.bz2": { + "build": "py27hdeba8d9_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "7c3163d4c908c80c90242c3f09bf88a1", + "name": "pexpect", + "sha256": "a6c7cc2245522265487ca7a88d0d2a3479f3d756b00da145faba3c8d3cabca37", + "size": 71646, + "subdir": "linux-64", + "timestamp": 1511841205793, + "version": "4.3.0" + }, + "pexpect-4.3.0-py35hf410859_0.tar.bz2": { + "build": "py35hf410859_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "c66a391cd624e0057910e73dbeb83f06", + "name": "pexpect", + "sha256": "c0deb69d74cf3343f3c01b69c96107c150e1065f64b3ab691e36811022cc3085", + "size": 74279, + "subdir": "linux-64", + "timestamp": 1511841241715, + "version": "4.3.0" + }, + "pexpect-4.3.0-py36h673ed17_0.tar.bz2": { + "build": "py36h673ed17_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "4c1c09a95c26ab60b3a68bcae7c2e25a", + "name": "pexpect", + "sha256": "908e021457cd9b605e69840c8be422b272580dee0cb2b5ad4b61f7de13b05236", + "size": 74184, + "subdir": "linux-64", + "timestamp": 1511841221450, + "version": "4.3.0" + }, + "pexpect-4.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "944fae11aab03b80ce82b8b0d1b77a54", + "name": "pexpect", + "sha256": "47ea05e89d2cd018b23fdfe79892cae1334b49d8658d8b3dedb97d87f69bffa5", + "size": 71487, + "subdir": "linux-64", + "timestamp": 1515707134531, + "version": "4.3.1" + }, + "pexpect-4.3.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "103d671c245f4e46456bb89c422d22d5", + "name": "pexpect", + "sha256": "251ccba8f4ed2821fdea7741c4f2c39ae586b6f1f860b11a924637321f0133f9", + "size": 74124, + "subdir": "linux-64", + "timestamp": 1515707263999, + "version": "4.3.1" + }, + "pexpect-4.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "1a918ca66c5534faaaedbf76b4dbc022", + "name": "pexpect", + "sha256": "a3269f24f73da853fe864c88ab20cd78367a8465748136fac6dff8c7bdc1d6d6", + "size": 74046, + "subdir": "linux-64", + "timestamp": 1515707046838, + "version": "4.3.1" + }, + "pexpect-4.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "583d3d29ef1ea514e83f0ae54a13d65a", + "name": "pexpect", + "sha256": "af96df1477a5c2fc8ded90ba75c916c43ad3b58d7844aa169bd86f4fb695fd71", + "size": 71928, + "subdir": "linux-64", + "timestamp": 1519148005297, + "version": "4.4.0" + }, + "pexpect-4.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "25bf36d6fd09805deea87c8e384f9dd2", + "name": "pexpect", + "sha256": "da86e9c25bf22c5ed24b6d0f2e2a58fb26a64099fea7e71ddae79c4c41ab4bb5", + "size": 74513, + "subdir": "linux-64", + "timestamp": 1519148040547, + "version": "4.4.0" + }, + "pexpect-4.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "66f80e73a691361439f662e62375c9f9", + "name": "pexpect", + "sha256": "795c6f0d63ff1c57b15510c888338a6e57a6024bf5b0accd55068dcf68cb62c4", + "size": 74425, + "subdir": "linux-64", + "timestamp": 1519148032012, + "version": "4.4.0" + }, + "pexpect-4.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "77a4e0bc46355c7ff1420a0716969297", + "name": "pexpect", + "sha256": "be993db6c4baad14e2980af9fd989e8aa12bf332670f157a426eb93fa24eef17", + "size": 74704, + "subdir": "linux-64", + "timestamp": 1523907815124, + "version": "4.5.0" + }, + "pexpect-4.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "36ffaec8ee7d8278ae8c50bef5e2f663", + "name": "pexpect", + "sha256": "6d8554852e27069397c969c7d69546d20edaef18fbf2b3fd46a07999d415106d", + "size": 77260, + "subdir": "linux-64", + "timestamp": 1523907936265, + "version": "4.5.0" + }, + "pexpect-4.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "b52003f575b80cd149d3dfe5fca6f6bf", + "name": "pexpect", + "sha256": "c6bdb49bf4218b5bec1c10c6009f5118c35546a7515ff715c527f1fd847d6a23", + "size": 77131, + "subdir": "linux-64", + "timestamp": 1523907819876, + "version": "4.5.0" + }, + "pexpect-4.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "80a0300148e04483f4d6af2b24cc25ed", + "name": "pexpect", + "sha256": "5610a1e4c6113aa0712c2c7e903551bef5d804c7471feac5d3bd78fe9573fa9d", + "size": 76138, + "subdir": "linux-64", + "timestamp": 1527826477402, + "version": "4.6.0" + }, + "pexpect-4.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "ed601a88ce99afd3453b13c583fae15e", + "name": "pexpect", + "sha256": "1faf2d9b3ebda6f3f38afd8780e7a77190b9a37d4e984b63c06fdefa66255eb0", + "size": 78785, + "subdir": "linux-64", + "timestamp": 1527826506177, + "version": "4.6.0" + }, + "pexpect-4.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "e8c2b11a0ef2c252978eaa9adf3b14cb", + "name": "pexpect", + "sha256": "e120fb4bdd31cccf8fc8cdb225dac82ba4fe86a00ff555766c355ca192fef046", + "size": 78672, + "subdir": "linux-64", + "timestamp": 1527826457979, + "version": "4.6.0" + }, + "pexpect-4.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "b7ad11f8ac11cfbd3a5605102a92e477", + "name": "pexpect", + "sha256": "9b290e60288523c9d53bb27ca060a9a5ef6d8e2b400dbdc57f5995dffe568e44", + "size": 78692, + "subdir": "linux-64", + "timestamp": 1530694759457, + "version": "4.6.0" + }, + "pexpect-4.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "691576123acf6d667998a9bae110ca9a", + "name": "pexpect", + "sha256": "ebc027cf169374117aeeb4cc9046be1816159ab43f3504584d860e2fa30fcb42", + "size": 81541, + "subdir": "linux-64", + "timestamp": 1555427841602, + "version": "4.7.0" + }, + "pexpect-4.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "30dbd55a7fde25c7b6412d70a03ada38", + "name": "pexpect", + "sha256": "a59722db5c7ba988b64d91986bb4132b6f324207f6ca7e74c5ba8c3a744854e3", + "size": 84333, + "subdir": "linux-64", + "timestamp": 1555428003756, + "version": "4.7.0" + }, + "pexpect-4.7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "98847999fb34af9b8837bf84b3550665", + "name": "pexpect", + "sha256": "cfb1e65a8320bdbf1dac85b3a4c4e57a7a67d55b3ed4a284092730b464d70ecf", + "size": 84295, + "subdir": "linux-64", + "timestamp": 1555427971652, + "version": "4.7.0" + }, + "pexpect-4.7.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "24f15eaec959a19db1682b8ddb82b6f8", + "name": "pexpect", + "sha256": "ff842f7ed48eecd7e703202e96b9bcde0ecb58b2ff0c8535bae8d1acdc30ae9a", + "size": 81156, + "subdir": "linux-64", + "timestamp": 1573469456924, + "version": "4.7.0" + }, + "pexpect-4.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "3a57bbcf9a2f32390159749ac4a1d6a9", + "name": "pexpect", + "sha256": "b72f377d853deaf451f2089f0854c9fb3a7a979f6dac59dd7cfe6a04c69ef075", + "size": 85748, + "subdir": "linux-64", + "timestamp": 1580151337466, + "version": "4.8.0" + }, + "pexpect-4.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "472f30582be8ec48dbaed801ea6719b4", + "name": "pexpect", + "sha256": "68deef0d90ec68fcdb93354b2e0a76012172737f15faa972ed254e7435c2c174", + "size": 85823, + "subdir": "linux-64", + "timestamp": 1580151296597, + "version": "4.8.0" + }, + "pexpect-4.8.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "ptyprocess >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "753c654d2913398e2d863faace1f6e79", + "name": "pexpect", + "sha256": "079312df557552e75e78196fe81b43b4453324b03d0a8db19505255b4c21a34d", + "size": 81284, + "subdir": "linux-64", + "timestamp": 1594383347774, + "version": "4.8.0" + }, + "pexpect-4.8.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "42a66ddcdf09e4ce7b4644870329f86a", + "name": "pexpect", + "sha256": "3493173ca913e7fe547fecdc0a2d4eca233b395fc3063fca670248bf8060268d", + "size": 85949, + "subdir": "linux-64", + "timestamp": 1580151297821, + "version": "4.8.0" + }, + "phik-0.12.2-py310hdb19cb5_0.tar.bz2": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "joblib >=0.14.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.3", + "numpy >=1.18.0", + "pandas >=0.25.1", + "python >=3.10,<3.11.0a0", + "scipy >=1.5.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "865fda3dd05a11e2b322f8c6c4f3fddd", + "name": "phik", + "sha256": "5a865cb5a664e57f33f9c27787637f329d5ec78483a5e156e7713b31b3f52485", + "size": 697505, + "subdir": "linux-64", + "timestamp": 1668544895753, + "version": "0.12.2" + }, + "phik-0.12.2-py37hdb19cb5_0.tar.bz2": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "joblib >=0.14.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.3", + "numpy >=1.18.0", + "pandas >=0.25.1", + "python >=3.7,<3.8.0a0", + "scipy >=1.5.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d3546393b8b5b2a525a120d941be65f9", + "name": "phik", + "sha256": "8bc0247649e3ac44921506deaa0b28160f15bddd9d5a5be741c2fc4088770b32", + "size": 696129, + "subdir": "linux-64", + "timestamp": 1668544786611, + "version": "0.12.2" + }, + "phik-0.12.2-py38hdb19cb5_0.tar.bz2": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "joblib >=0.14.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.3", + "numpy >=1.18.0", + "pandas >=0.25.1", + "python >=3.8,<3.9.0a0", + "scipy >=1.5.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7a15de938c0e7a37ed05e64e2b33d0e8", + "name": "phik", + "sha256": "8b48f3c3d105af3660c0c4d49afff4664d702cc4c55e9854fb41006070190e50", + "size": 696345, + "subdir": "linux-64", + "timestamp": 1668544726557, + "version": "0.12.2" + }, + "phik-0.12.2-py39hdb19cb5_0.tar.bz2": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "joblib >=0.14.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.3", + "numpy >=1.18.0", + "pandas >=0.25.1", + "python >=3.9,<3.10.0a0", + "scipy >=1.5.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "86e020067932b5f2ed0891cf0f18839f", + "name": "phik", + "sha256": "688ba82f2a98e8ee722e12b6029edccee73c3c54050b22996f2de36117d57b8d", + "size": 696538, + "subdir": "linux-64", + "timestamp": 1668544841611, + "version": "0.12.2" + }, + "phik-0.12.3-py310hdb19cb5_0.tar.bz2": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "joblib >=0.14.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.3", + "numpy >=1.18.0", + "pandas >=0.25.1", + "python >=3.10,<3.11.0a0", + "scipy >=1.5.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "396c2481b35384de02c468e8bbb1afac", + "name": "phik", + "sha256": "21947423b2bb03cef1b15573b2c63c6442769500ae2e4d592a496543b6f17192", + "size": 702158, + "subdir": "linux-64", + "timestamp": 1670955853084, + "version": "0.12.3" + }, + "phik-0.12.3-py311hdb19cb5_0.tar.bz2": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "joblib >=0.14.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.3", + "numpy >=1.18.0", + "pandas >=0.25.1", + "python >=3.11,<3.12.0a0", + "scipy >=1.5.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8f77292f187449843519981568c9332a", + "name": "phik", + "sha256": "e762dea4c31b607f32f1bea280f08799ee38ebaa186092c069644a0ed29ef6cc", + "size": 713093, + "subdir": "linux-64", + "timestamp": 1676845164532, + "version": "0.12.3" + }, + "phik-0.12.3-py37hdb19cb5_0.tar.bz2": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "joblib >=0.14.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.3", + "numpy >=1.18.0", + "pandas >=0.25.1", + "python >=3.7,<3.8.0a0", + "scipy >=1.5.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4526ed079657a9fad199107a66b18f8c", + "name": "phik", + "sha256": "ef75c0bbe12fb3dab6251d2b06f696fefa0642c10b8f43ba3548e64882fd63b4", + "size": 701858, + "subdir": "linux-64", + "timestamp": 1670955964411, + "version": "0.12.3" + }, + "phik-0.12.3-py38hdb19cb5_0.tar.bz2": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "joblib >=0.14.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.3", + "numpy >=1.18.0", + "pandas >=0.25.1", + "python >=3.8,<3.9.0a0", + "scipy >=1.5.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3fe3852d0fe20ad6189c53f0e7b6f15b", + "name": "phik", + "sha256": "ef10fda9e0ddfbf7f55eed5a457416b3362743b09c62a123ec76b66c0c9f7bff", + "size": 700626, + "subdir": "linux-64", + "timestamp": 1670956017415, + "version": "0.12.3" + }, + "phik-0.12.3-py39hdb19cb5_0.tar.bz2": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "joblib >=0.14.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.3", + "numpy >=1.18.0", + "pandas >=0.25.1", + "python >=3.9,<3.10.0a0", + "scipy >=1.5.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0375b6458883e880f786eac0d072f165", + "name": "phik", + "sha256": "a7f3311108076ed4830b382d0c4b6e8401cc25e5bc41d038a9d7e692da06bfca", + "size": 698462, + "subdir": "linux-64", + "timestamp": 1670955910775, + "version": "0.12.3" + }, + "phonenumbers-8.10.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "82cfc67d4dda07756c124031ed785694", + "name": "phonenumbers", + "sha256": "56f670d87f9d2c6125e9b5d0fdbdac47f1d130c86bfb21523aea9f04845f23ea", + "size": 4516758, + "subdir": "linux-64", + "timestamp": 1542408111438, + "version": "8.10.0" + }, + "phonenumbers-8.10.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6c110ebbf2156f678b371bcf23ba355d", + "name": "phonenumbers", + "sha256": "41c38fe1caaf8c8a40270936575a66378913084fd92833ef7ba55c6e83714500", + "size": 3805067, + "subdir": "linux-64", + "timestamp": 1542408135746, + "version": "8.10.0" + }, + "phonenumbers-8.10.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7811d1793d312802c84587fd78baa4ce", + "name": "phonenumbers", + "sha256": "518d33bbd135d7afa18f4d5d1370d013fe4b00baa6769a5cd23e452ec45f6ead", + "size": 3810032, + "subdir": "linux-64", + "timestamp": 1542408115481, + "version": "8.10.0" + }, + "phonenumbers-8.10.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ab708c38defb0db06ab3cbb54f5619ba", + "name": "phonenumbers", + "sha256": "f4f8cbfed7c565e364152ca9a8a162446966c1f2b22830e22c97a504e18215d4", + "size": 4522776, + "subdir": "linux-64", + "timestamp": 1543602329663, + "version": "8.10.1" + }, + "phonenumbers-8.10.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fdf20038d1c2dce87d8ad88252f0a696", + "name": "phonenumbers", + "sha256": "b83d4294fbcaa9158635dd02e630923bb782a0e68ec7903662b4d26d04d57c29", + "size": 3815483, + "subdir": "linux-64", + "timestamp": 1543602334049, + "version": "8.10.1" + }, + "phonenumbers-8.10.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8aa0277dc9b600716dabddc7bbfc0f17", + "name": "phonenumbers", + "sha256": "4cf5f43bd4a550986d50941a0e1c39e2096a4b394453d4a952a800dcc7d14358", + "size": 3812444, + "subdir": "linux-64", + "timestamp": 1543602352549, + "version": "8.10.1" + }, + "phonenumbers-8.10.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "831ad6be3823812d790d6a7f14570f93", + "name": "phonenumbers", + "sha256": "4f5e8c290a3b3eaf79f72548cbb52f8574d77fd26980314a8f2ff8c094b7d9c3", + "size": 4503694, + "subdir": "linux-64", + "timestamp": 1545142518590, + "version": "8.10.2" + }, + "phonenumbers-8.10.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "03e3b12c97cc777845bb510bfa6e936f", + "name": "phonenumbers", + "sha256": "11cc7007bf77872aed6b2786de1bc17e7aa99d54257f890be71f3df80a4c284e", + "size": 3812921, + "subdir": "linux-64", + "timestamp": 1545126151557, + "version": "8.10.2" + }, + "phonenumbers-8.10.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f95bdac7c8378b726a3070e54e0cbac6", + "name": "phonenumbers", + "sha256": "6334d9b3da623af1682cfbce7e857d1be5633e474bea60be822fc2f283fbbc20", + "size": 3804889, + "subdir": "linux-64", + "timestamp": 1545142487786, + "version": "8.10.2" + }, + "phonenumbers-8.10.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c745bbcf672639df265d11358b356451", + "name": "phonenumbers", + "sha256": "2ed1565cd187d5cea63bcdb07ff31ab8d7d881366f1e15265d75aa5190b7ff21", + "size": 4472246, + "subdir": "linux-64", + "timestamp": 1550350624589, + "version": "8.10.5" + }, + "phonenumbers-8.10.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "df2a0f76487360d507428646c4ee9ca0", + "name": "phonenumbers", + "sha256": "aae35f2a9929984b4ba7369a9739d596711ee909cd09e433a1f62fce2c7d3891", + "size": 3768004, + "subdir": "linux-64", + "timestamp": 1550350732422, + "version": "8.10.5" + }, + "phonenumbers-8.10.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f30d9cbc63a3a5c35c29daea5a65a36e", + "name": "phonenumbers", + "sha256": "e45c1d119e80d3efbd77d1e555f5120ba6aed760279980435071461d5f3b6c50", + "size": 3770972, + "subdir": "linux-64", + "timestamp": 1550350551443, + "version": "8.10.5" + }, + "phonenumbers-8.8.0-py27h8056f28_0.tar.bz2": { + "build": "py27h8056f28_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6cd7258c273292c0fbec99b0cf9632fb", + "name": "phonenumbers", + "sha256": "4b4e91d6beace437146fcdfa7ad3616e74268c26a461537113db4276812c6642", + "size": 3636907, + "subdir": "linux-64", + "timestamp": 1505751016381, + "version": "8.8.0" + }, + "phonenumbers-8.8.0-py35h01792f9_0.tar.bz2": { + "build": "py35h01792f9_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9ee8ab5195d4eb85dd6382b81d309106", + "name": "phonenumbers", + "sha256": "65ec777cba18b13cb5fd9e552266e68d8781aa1d53f74317a36d790740caacf9", + "size": 3646993, + "subdir": "linux-64", + "timestamp": 1505751092664, + "version": "8.8.0" + }, + "phonenumbers-8.8.0-py36h078def6_0.tar.bz2": { + "build": "py36h078def6_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "feddfabef3c5abb0d6157e37cf2bec0f", + "name": "phonenumbers", + "sha256": "beeb7af3d516cb37d42df2be9c9f96d7c2eb86e9f4aefdb5a8a7c872f1b8e09c", + "size": 3050131, + "subdir": "linux-64", + "timestamp": 1505751166757, + "version": "8.8.0" + }, + "phonenumbers-8.8.6-py27h05b9aca_0.tar.bz2": { + "build": "py27h05b9aca_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "14520f7c625852d760f5e3c19962eb03", + "name": "phonenumbers", + "sha256": "6a74849857efb872b681aa3a318e58552f2e39b2ad7d515160a071aef3b80233", + "size": 4207486, + "subdir": "linux-64", + "timestamp": 1511323104705, + "version": "8.8.6" + }, + "phonenumbers-8.8.6-py35ha0406aa_0.tar.bz2": { + "build": "py35ha0406aa_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b4383f6d71686b6aef5d2519a294a916", + "name": "phonenumbers", + "sha256": "7ad35b47f8addba9d48b942e613baaa865315a36fbd6cbb41f33b51f479e0b2e", + "size": 4192601, + "subdir": "linux-64", + "timestamp": 1511323129136, + "version": "8.8.6" + }, + "phonenumbers-8.8.6-py36h7f468f6_0.tar.bz2": { + "build": "py36h7f468f6_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6852c775e96bd5451d4805f0bc458069", + "name": "phonenumbers", + "sha256": "c76ba96c45d86209d89eef1611e980255b112c89191c4bfee0f2144fdbdae0cd", + "size": 3475787, + "subdir": "linux-64", + "timestamp": 1511323128311, + "version": "8.8.6" + }, + "phonenumbers-8.9.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cc3941dacd3f236104b56fb55df1ce68", + "name": "phonenumbers", + "sha256": "264562faa5ad3cc9d666c8885915347bcb6734806bb14c7fdf30999465b1e47c", + "size": 4219363, + "subdir": "linux-64", + "timestamp": 1520909954754, + "version": "8.9.1" + }, + "phonenumbers-8.9.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "28a839ceacea66862032835983608919", + "name": "phonenumbers", + "sha256": "db79ee358b44428a88064550881523694a0d793f890c622b0e2503d9d0977374", + "size": 4216934, + "subdir": "linux-64", + "timestamp": 1520910005476, + "version": "8.9.1" + }, + "phonenumbers-8.9.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4dc3c721965643ef2acc98141d1c6d23", + "name": "phonenumbers", + "sha256": "ba48977101b926ac56bc496f56a26118732fb9d4c0e613ab0ff80127e5940aaa", + "size": 3509991, + "subdir": "linux-64", + "timestamp": 1520909936194, + "version": "8.9.1" + }, + "phonenumbers-8.9.11-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3189b1e8f0178188a4efdd3908db1ca9", + "name": "phonenumbers", + "sha256": "a79f207c5c286981590b96554e6bfa2270ba71d72edb788f37c2e04e543e1f0d", + "size": 4328130, + "subdir": "linux-64", + "timestamp": 1535509305649, + "version": "8.9.11" + }, + "phonenumbers-8.9.11-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5957b49bbb29b3f3a6d6d8875f43c7ff", + "name": "phonenumbers", + "sha256": "2aef3afd8689bfc7b64887c9625098590c26b00afa37c6770d8c1b39ec8c0b85", + "size": 4328601, + "subdir": "linux-64", + "timestamp": 1535509403452, + "version": "8.9.11" + }, + "phonenumbers-8.9.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b71459abdee2ef0e231185068898b35b", + "name": "phonenumbers", + "sha256": "34ea70a6a0c03daab6a8953e25bc5659ba796aa055ff92a9439537b7f33e6728", + "size": 3603037, + "subdir": "linux-64", + "timestamp": 1535509347196, + "version": "8.9.11" + }, + "phonenumbers-8.9.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "819d462d08b3e16151dd45a48b82eea7", + "name": "phonenumbers", + "sha256": "bfce0d53a94b7b92105c1e11ecca4bb821f764513bd0d87afdf9dd4d70c3ac8b", + "size": 3585756, + "subdir": "linux-64", + "timestamp": 1535509419225, + "version": "8.9.11" + }, + "phonenumbers-8.9.15-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ad92f5eb4bdd08d67af6f230dacf62a2", + "name": "phonenumbers", + "sha256": "b0f476db2e1935d19ffd2b61669f04221deec021c9f5c92bb21bac03674bede1", + "size": 4330143, + "subdir": "linux-64", + "timestamp": 1539656165147, + "version": "8.9.15" + }, + "phonenumbers-8.9.15-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "892d06cbf6cf46d852d7270ae17b42c3", + "name": "phonenumbers", + "sha256": "fb73274f285d80b172883647d82b46bf3bce81189e8308f10ccbe72e18b426fe", + "size": 3622828, + "subdir": "linux-64", + "timestamp": 1539656199637, + "version": "8.9.15" + }, + "phonenumbers-8.9.15-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e252dc133e66aeb16a5e8b6b23eb0d96", + "name": "phonenumbers", + "sha256": "1ce447c1ad763cdf2b1196bfc009b7bfa1cdc12b9edd6fd67a3c0d5591aa0abd", + "size": 3598714, + "subdir": "linux-64", + "timestamp": 1539656197508, + "version": "8.9.15" + }, + "phonenumbers-8.9.16-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1f8823c6ffc632a8d455b2f34884afa4", + "name": "phonenumbers", + "sha256": "c3645387246c0ce1e4f207fd1d5af60355ac277f80ca92fec4f0939fdc4293c1", + "size": 4557422, + "subdir": "linux-64", + "timestamp": 1540998982424, + "version": "8.9.16" + }, + "phonenumbers-8.9.16-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "09418aeae55eb0a0f0b128b757f38676", + "name": "phonenumbers", + "sha256": "c685e23225804740aa0251ab318209f3be0c48fe7ba3fb09f0c615327ff28b19", + "size": 3825472, + "subdir": "linux-64", + "timestamp": 1540999007512, + "version": "8.9.16" + }, + "phonenumbers-8.9.16-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "11146467536092f2deb099f50fdab76f", + "name": "phonenumbers", + "sha256": "bf2d32eac640578ec694efb471a2fb96962ecc4336a94466250eb50b5a47337f", + "size": 3818419, + "subdir": "linux-64", + "timestamp": 1540999062123, + "version": "8.9.16" + }, + "phonenumbers-8.9.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cb796576a6173e229baa15938f74d296", + "name": "phonenumbers", + "sha256": "f4f6cc8f51f4b5af77fc9a854a063e8873ff55f5a799a79c8f59a52d1241613a", + "size": 4222011, + "subdir": "linux-64", + "timestamp": 1522786083984, + "version": "8.9.2" + }, + "phonenumbers-8.9.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ae5b5cf3e27923fd085fd2fd8c9846cf", + "name": "phonenumbers", + "sha256": "27da993f00ad8b8ff0cc771002c0276550850da3a0a1c0d63d906bf449f1f906", + "size": 4218273, + "subdir": "linux-64", + "timestamp": 1522786146723, + "version": "8.9.2" + }, + "phonenumbers-8.9.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6c4b610a6b5c15c532c9fa709bc94292", + "name": "phonenumbers", + "sha256": "93bc7ebeea3f21e67048c5d599301f3a3e1aeb06d57d6b87bf5194bc33dcea9f", + "size": 3510489, + "subdir": "linux-64", + "timestamp": 1522786151753, + "version": "8.9.2" + }, + "phonenumbers-8.9.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fab4f9fe4dd9d229400b13c14909f6fb", + "name": "phonenumbers", + "sha256": "30c689834dc540811b806d95b84fd687c9101b5eaaa7bb4cececade481acdbd1", + "size": 4241258, + "subdir": "linux-64", + "timestamp": 1524085400970, + "version": "8.9.4" + }, + "phonenumbers-8.9.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1aad1b8c70e44d30de872212559936bd", + "name": "phonenumbers", + "sha256": "fc76335ed0e225aa95f7afcc338eb968a5aff436650d5d8a8c1a1ce9aed9e76b", + "size": 4229741, + "subdir": "linux-64", + "timestamp": 1524085374486, + "version": "8.9.4" + }, + "phonenumbers-8.9.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1706d1cba188dfd61f80659da1818d93", + "name": "phonenumbers", + "sha256": "021f658bc73434d9c77fc1f61d866ba8705febe3430c7144a0216e112b86419f", + "size": 3522778, + "subdir": "linux-64", + "timestamp": 1524085421159, + "version": "8.9.4" + }, + "phonenumbers-8.9.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1d8a514617d580afeae605e774591b60", + "name": "phonenumbers", + "sha256": "f1434df3da316911e6d4e3915803d50cd9bb28f33850f58eb2972c31f72cc173", + "size": 4271893, + "subdir": "linux-64", + "timestamp": 1526937858316, + "version": "8.9.6" + }, + "phonenumbers-8.9.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a4c7dce13b9721846d99db9dc1c8c6da", + "name": "phonenumbers", + "sha256": "7eb8a795c8b90516c227073390dfc483ad9712364520dae81dfbc40a01dd17e7", + "size": 4264853, + "subdir": "linux-64", + "timestamp": 1526937878515, + "version": "8.9.6" + }, + "phonenumbers-8.9.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ce75dd92a174b8dd5789d97d218896b0", + "name": "phonenumbers", + "sha256": "14dc74b9655d85a4409802f5d23a05a3ff6e3cc4d70e0b32934d759c382c2d2b", + "size": 3554533, + "subdir": "linux-64", + "timestamp": 1526937861338, + "version": "8.9.6" + }, + "phonenumbers-8.9.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8ca05822a3713a7262c307ea78f88715", + "name": "phonenumbers", + "sha256": "5f94580ebde6cf15635037d726f156d23171660e47b6647ca4b9591f8624079c", + "size": 4339733, + "subdir": "linux-64", + "timestamp": 1528218934064, + "version": "8.9.7" + }, + "phonenumbers-8.9.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1289e90f10538377b5adad23c3e17e8e", + "name": "phonenumbers", + "sha256": "e36e038ad7e36f310d17816728110bf60e38544eded52f8b1cc1231a523dc5b1", + "size": 4342598, + "subdir": "linux-64", + "timestamp": 1528218969597, + "version": "8.9.7" + }, + "phonenumbers-8.9.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "915ecf94d0f6f0b066203c972adb7cef", + "name": "phonenumbers", + "sha256": "882b806bdbdd7dc695ce3cbdab79abcd5c9997bfaf4af1712aeb9f53d9ead465", + "size": 3614199, + "subdir": "linux-64", + "timestamp": 1528218896421, + "version": "8.9.7" + }, + "phonenumbers-8.9.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "28cd0e8822c3167224bd9284675a39aa", + "name": "phonenumbers", + "sha256": "803f5eb51d94f359a70f73d42c440c155bbdaf4129d7e342e5395b413235d54e", + "size": 4359656, + "subdir": "linux-64", + "timestamp": 1529438190517, + "version": "8.9.8" + }, + "phonenumbers-8.9.8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a7263b35bc286dc5ea292560a6374da8", + "name": "phonenumbers", + "sha256": "d534c8c8c7d1c1ec7a1834f8937cdf3bb055815a82d48f75322599814be586fa", + "size": 4373448, + "subdir": "linux-64", + "timestamp": 1529438508035, + "version": "8.9.8" + }, + "phonenumbers-8.9.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0e7f879cc680407bc4130678f138a38e", + "name": "phonenumbers", + "sha256": "020b0c28479a607a3837fc84c601a594b2314c207cebcee62a453cfa9c9793d8", + "size": 3628580, + "subdir": "linux-64", + "timestamp": 1529438483522, + "version": "8.9.8" + }, + "phonenumbers-8.9.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6d6b83a096a45db905b7653601bb34ef", + "name": "phonenumbers", + "sha256": "b5366e6a1f0fcdd18576a4d36f3db41e7fc029f5e2530a1fb621a68a497d541e", + "size": 3620123, + "subdir": "linux-64", + "timestamp": 1530905142616, + "version": "8.9.8" + }, + "picklable-itertools-0.1.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "5fb3682d5624f2c4558d67985fceace9", + "name": "picklable-itertools", + "sha256": "84927d259e8ccae97e928184e3ff6550ed4bc28502e77365404151c244d31cd3", + "size": 24909, + "subdir": "linux-64", + "timestamp": 1537278625690, + "version": "0.1.1" + }, + "picklable-itertools-0.1.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "c0daa0b7bdd6ea8b4cc6831570f1df03", + "name": "picklable-itertools", + "sha256": "c62ec0897befdc835d417a77655faf4b3521d6f59f491f342a1e92502f157262", + "size": 28946, + "subdir": "linux-64", + "timestamp": 1643113051939, + "version": "0.1.1" + }, + "picklable-itertools-0.1.1-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "ac8624259f7df2d75befdc8656520582", + "name": "picklable-itertools", + "sha256": "967c8a9f15a9e5700a2552827018e87d45fa357ac56564f6c9eae5ea4078e939", + "size": 33569, + "subdir": "linux-64", + "timestamp": 1676906138640, + "version": "0.1.1" + }, + "picklable-itertools-0.1.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "a1c7b92d681318af39d0a6b2e968d938", + "name": "picklable-itertools", + "sha256": "35945310b9dfb1b454ec1d3cbb445c8b90dfcc57571448bb707f8b0e1e7c73b3", + "size": 25613, + "subdir": "linux-64", + "timestamp": 1537278630993, + "version": "0.1.1" + }, + "picklable-itertools-0.1.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "bcba6552005a3aab475459e67beb6c1c", + "name": "picklable-itertools", + "sha256": "938e7812bded9ea3ce740c0fd3205bdedc287477e7652d9609020a47d1744276", + "size": 25546, + "subdir": "linux-64", + "timestamp": 1537278645296, + "version": "0.1.1" + }, + "picklable-itertools-0.1.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "df945461dff17a8749e1248028076512", + "name": "picklable-itertools", + "sha256": "9be6eb76a74ee7007a4ab7c3d3cc117398bb37db90072552cad03f8db436a527", + "size": 246648, + "subdir": "linux-64", + "timestamp": 1613553932758, + "version": "0.1.1" + }, + "picklable-itertools-0.1.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "ea47768ea7c9081ca7b6dada8bfa6202", + "name": "picklable-itertools", + "sha256": "806b103cef576bed3547b9dd43614889d9a6667e2a9e7ebb427a5142b64478e1", + "size": 25629, + "subdir": "linux-64", + "timestamp": 1537278581841, + "version": "0.1.1" + }, + "picklable-itertools-0.1.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "d78e2d08488d4637c820ba87bb017434", + "name": "picklable-itertools", + "sha256": "b585785dc36f28e12ac67c1ff802d34cbcaabde5b570178888928651aeb420d3", + "size": 244280, + "subdir": "linux-64", + "timestamp": 1613553923873, + "version": "0.1.1" + }, + "picklable-itertools-0.1.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "49783fc130a694f9ea70429269d68c07", + "name": "picklable-itertools", + "sha256": "6b23c6f05c5cf6c3c496b9368ae2083b2bc905dfd1d8c74b3d6a5351f43e44f7", + "size": 246456, + "subdir": "linux-64", + "timestamp": 1613553931327, + "version": "0.1.1" + }, + "picklable-itertools-0.1.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "44133fec4a4eb34b7cf8277b7686bec6", + "name": "picklable-itertools", + "sha256": "e17914e5151709e5b51c7b09c8ee93e92566b89e095e00bda3feef7811842dff", + "size": 246755, + "subdir": "linux-64", + "timestamp": 1613553921168, + "version": "0.1.1" + }, + "pickle5-0.0.11-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-2.0", + "md5": "756846bf40f73a899bb11bab8dfe7a17", + "name": "pickle5", + "sha256": "52342d1a0dfc6bf1fbdf108cae50a8881522cded909f31a05259e38eed22adfe", + "size": 181796, + "subdir": "linux-64", + "timestamp": 1621432720502, + "version": "0.0.11" + }, + "pickle5-0.0.11-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "md5": "caefa5902501d8314df70e7d807c05c1", + "name": "pickle5", + "sha256": "8eefbb674b164982bb60914f5d29be4eaeb651c00df0ad87f3f9ae1e6bd44f89", + "size": 181376, + "subdir": "linux-64", + "timestamp": 1621428095016, + "version": "0.0.11" + }, + "pickleshare-0.7.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pathlib2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5beb99cdc220c20c783b1f8f887f0d67", + "name": "pickleshare", + "sha256": "9d1ad97be778d54af597e7d885ebf9cea3438fefb383eab1c92f5a068880a770", + "size": 11580, + "subdir": "linux-64", + "timestamp": 1530733913904, + "version": "0.7.4" + }, + "pickleshare-0.7.4-py27h09770e1_0.tar.bz2": { + "build": "py27h09770e1_0", + "build_number": 0, + "depends": [ + "pathlib2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "63dd946d096ca17a17e9a4243e1f0751", + "name": "pickleshare", + "sha256": "3bfb2488c982544f326bfef397e1b87dbb399ea7374adc41e21d8398cca58385", + "size": 11419, + "subdir": "linux-64", + "timestamp": 1505690117722, + "version": "0.7.4" + }, + "pickleshare-0.7.4-py35hd57304d_0.tar.bz2": { + "build": "py35hd57304d_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "d044a0b9f019284d70210383ba23f065", + "name": "pickleshare", + "sha256": "be7a8551c80718e5d6504f7a36d954aea4a0848528f666e3b35e133002a6ebc4", + "size": 11731, + "subdir": "linux-64", + "timestamp": 1505690128538, + "version": "0.7.4" + }, + "pickleshare-0.7.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0d9febb59b59c8febee189689b9de211", + "name": "pickleshare", + "sha256": "aeac8da2061f2bfd6c3d92f6b23bc8867282c376d36a29dd1d89d02627470cff", + "size": 11831, + "subdir": "linux-64", + "timestamp": 1530733894410, + "version": "0.7.4" + }, + "pickleshare-0.7.4-py36h63277f8_0.tar.bz2": { + "build": "py36h63277f8_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f1963de9dee08aa7151260cf947a1268", + "name": "pickleshare", + "sha256": "84c1ee7f09d6f194ca445ea7526fe464bd083cf04fcc4b664c0be0ffcaccc81b", + "size": 11675, + "subdir": "linux-64", + "timestamp": 1505690139442, + "version": "0.7.4" + }, + "pickleshare-0.7.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b3c39a9c00672cfe77a7ae2acf1358d1", + "name": "pickleshare", + "sha256": "08c0db82f840059776af694cde5335e0cc32f32b34067f2696a2ec28a16c69e8", + "size": 11827, + "subdir": "linux-64", + "timestamp": 1530733933953, + "version": "0.7.4" + }, + "pickleshare-0.7.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pathlib2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "50aab6b4376f7ebbf31b2b23dac8bf59", + "name": "pickleshare", + "sha256": "066d3c0d1e795e82368a82304f7c3aeda80a2f4981850803be8c91e02b2f3493", + "size": 12587, + "subdir": "linux-64", + "timestamp": 1538597743403, + "version": "0.7.5" + }, + "pickleshare-0.7.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6315af5d1aa85e6c0ff4d05477a9c019", + "name": "pickleshare", + "sha256": "d36ce0b12da2b603286f0783c2dc8be4e2581ccc903da73c5480a2bbc63aa311", + "size": 12876, + "subdir": "linux-64", + "timestamp": 1538597773015, + "version": "0.7.5" + }, + "pickleshare-0.7.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "9ae7569c6a498f159fa0730a8af760e8", + "name": "pickleshare", + "sha256": "0b0abe1b1736fadb0b64e5317aa2514c216674181c9241b1cf448d2b4aa52baf", + "size": 12900, + "subdir": "linux-64", + "timestamp": 1538597722845, + "version": "0.7.5" + }, + "pickleshare-0.7.5-py37_1001.tar.bz2": { + "build": "py37_1001", + "build_number": 1001, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8116cfb11f8016ed9fcacb0d401f3f1b", + "name": "pickleshare", + "sha256": "aac846b3f4218d2f382bc575bd64ad04d6ccf53ee59502311de6ed9d7bad0625", + "size": 13065, + "subdir": "linux-64", + "timestamp": 1594384104043, + "version": "0.7.5" + }, + "pickleshare-0.7.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "423f6273afcc6c43c43bde5be22ea261", + "name": "pickleshare", + "sha256": "64f038d47f34e91dde7e143638432e82a53bc23562e93cfc79eb6f98517a6090", + "size": 15927, + "subdir": "linux-64", + "timestamp": 1575498328366, + "version": "0.7.5" + }, + "pickleshare-0.7.5-py38_1000.tar.bz2": { + "build": "py38_1000", + "build_number": 1000, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "3478cad3049423f5bc4154627ec5aa52", + "name": "pickleshare", + "sha256": "e00f585c2303fa398ed6918c4bcf45fd5bf40461bf5dc4fb253828bad5bed48e", + "size": 13703, + "subdir": "linux-64", + "timestamp": 1573489536066, + "version": "0.7.5" + }, + "pigz-2.4-h84994c4_0.tar.bz2": { + "build": "h84994c4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "zlib", + "license_family": "other", + "md5": "eb6fab8da6f9937420be11f5bb402a85", + "name": "pigz", + "sha256": "56be8ca3d771a663a622bb25089af82feab6d6cd15f233d14a83b4c663211430", + "size": 81238, + "subdir": "linux-64", + "timestamp": 1529594787590, + "version": "2.4" + }, + "pigz-2.6-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0", + "zlib >=1.2.6" + ], + "license": "zlib", + "license_family": "other", + "md5": "23738a43a7b58c1a7dc7f532328d846e", + "name": "pigz", + "sha256": "851f2eca7db23f1356792fc3808f2cacfab3a6b1e199d72ff22dda8005c074ec", + "size": 88859, + "subdir": "linux-64", + "timestamp": 1623153770630, + "version": "2.6" + }, + "pigz-2.6-h8f29fe8_0.tar.bz2": { + "build": "h8f29fe8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "zlib", + "license_family": "other", + "md5": "9e6bc012af75a8ee7ce83577a902c2fb", + "name": "pigz", + "sha256": "dad918d7a1e4103286d1128d60c25faa45549f3d9c9134ac01c3978b96173a60", + "size": 89130, + "subdir": "linux-64", + "timestamp": 1623072335564, + "version": "2.6" + }, + "pillow-4.2.1-py27h7cd2321_0.tar.bz2": { + "build": "py27h7cd2321_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.8,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "0bcf0ce0e4871c35092e2a9e09974e7a", + "name": "pillow", + "sha256": "3f4de32b36e7d2e09654aa8d714b9ef85851ef4ab1d26b674df11e11b27935d7", + "size": 557695, + "subdir": "linux-64", + "timestamp": 1505744454000, + "version": "4.2.1" + }, + "pillow-4.2.1-py35h03abc04_0.tar.bz2": { + "build": "py35h03abc04_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.8,<5.0a0", + "olefile", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "6d0acdf3f54be943161f84e12b4fedad", + "name": "pillow", + "sha256": "47209e63a69ad80801cdd2fea1c576f413840b276b8c13fae0e21c1d98c3f62a", + "size": 558744, + "subdir": "linux-64", + "timestamp": 1505744486716, + "version": "4.2.1" + }, + "pillow-4.2.1-py36h9119f52_0.tar.bz2": { + "build": "py36h9119f52_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.8,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "2aba6aa29792720fac27ebdc26d0b439", + "name": "pillow", + "sha256": "a871459146d458b37d359bf20c3dd22dfd0cf2423676df6ceadad231381980d2", + "size": 561314, + "subdir": "linux-64", + "timestamp": 1505744519253, + "version": "4.2.1" + }, + "pillow-4.3.0-py27h353bd0c_1.tar.bz2": { + "build": "py27h353bd0c_1", + "build_number": 1, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "42028615fbe817511173a836f21a2655", + "name": "pillow", + "sha256": "028c5831db4cde91120bec4232ad3c6890074d9b2af3d20a33025edb54a708f2", + "size": 576088, + "subdir": "linux-64", + "timestamp": 1512163198571, + "version": "4.3.0" + }, + "pillow-4.3.0-py35h550890c_1.tar.bz2": { + "build": "py35h550890c_1", + "build_number": 1, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.5,<3.6.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "4e56912864fe9cc7bfb8c00b446100b4", + "name": "pillow", + "sha256": "563be09be23afccf939465f06af5c995546cb09e0a61c5cea83928ae4e39fadd", + "size": 579198, + "subdir": "linux-64", + "timestamp": 1512163149461, + "version": "4.3.0" + }, + "pillow-4.3.0-py36h6f462bf_1.tar.bz2": { + "build": "py36h6f462bf_1", + "build_number": 1, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "614a5f03f9b25c6ddc1750a4f2312a2c", + "name": "pillow", + "sha256": "5cbce7053e1ec95d342e0f4d6a08a658dc8059dae57133edad7ad0a480155b93", + "size": 573357, + "subdir": "linux-64", + "timestamp": 1512163229153, + "version": "4.3.0" + }, + "pillow-5.0.0-py27h3deb7b8_0.tar.bz2": { + "build": "py27h3deb7b8_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "c697b35f757b0c370deb9f5933311667", + "name": "pillow", + "sha256": "940daf3f6be443486a4adfebaf0b25dadff478e9ef63b9738a5c321cc8ebc725", + "size": 569821, + "subdir": "linux-64", + "timestamp": 1515097663552, + "version": "5.0.0" + }, + "pillow-5.0.0-py35h3deb7b8_0.tar.bz2": { + "build": "py35h3deb7b8_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.5,<3.6.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "93191a821c4492ebeb5dfef4a6d3e10c", + "name": "pillow", + "sha256": "043c5db1eb1486071bc4c6b874c3de12e4a782e2b2e57edcdb3cb872cfbdf886", + "size": 574830, + "subdir": "linux-64", + "timestamp": 1515097703212, + "version": "5.0.0" + }, + "pillow-5.0.0-py36h3deb7b8_0.tar.bz2": { + "build": "py36h3deb7b8_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "d1f4f90d27f801cd7df95245c2ab56dd", + "name": "pillow", + "sha256": "c44942437df2409a4f21cc8fdea0c5cbc0a10348c81894acad886646807af78f", + "size": 574072, + "subdir": "linux-64", + "timestamp": 1515097744186, + "version": "5.0.0" + }, + "pillow-5.1.0-py27h3deb7b8_0.tar.bz2": { + "build": "py27h3deb7b8_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "76907c64bee33da9b1260a21c0ea68ac", + "name": "pillow", + "sha256": "4dd95e0b17630d610f6aeaeb9e307980f0fb62c39d713b5d5cf10fa72e5a0009", + "size": 590990, + "subdir": "linux-64", + "timestamp": 1523904277268, + "version": "5.1.0" + }, + "pillow-5.1.0-py27heded4f4_0.tar.bz2": { + "build": "py27heded4f4_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "dcd9686fe30b321d0a2bcd543f2b2d9e", + "name": "pillow", + "sha256": "52b36e77e9e692a792bbda8342739405dec307e4c171c97d85dff9b1e8103978", + "size": 590883, + "subdir": "linux-64", + "timestamp": 1530793030619, + "version": "5.1.0" + }, + "pillow-5.1.0-py35h3deb7b8_0.tar.bz2": { + "build": "py35h3deb7b8_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.5,<3.6.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "94097fe5346a3d412af66d184d57577a", + "name": "pillow", + "sha256": "a3347d83ed1027ca6af23d87afceb76adc0be79503d6fe4c7d3060bb52b79000", + "size": 596768, + "subdir": "linux-64", + "timestamp": 1523904291956, + "version": "5.1.0" + }, + "pillow-5.1.0-py36h3deb7b8_0.tar.bz2": { + "build": "py36h3deb7b8_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "9e48c1c1d054dda1f9994a638f19b339", + "name": "pillow", + "sha256": "28b6a4442246394b27e0303350374cc6edee730834e78a1d6a17d094a895847e", + "size": 595931, + "subdir": "linux-64", + "timestamp": 1523904286416, + "version": "5.1.0" + }, + "pillow-5.1.0-py36heded4f4_0.tar.bz2": { + "build": "py36heded4f4_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "6bc83684bf4439f9139191ba1ff391bf", + "name": "pillow", + "sha256": "4d1e70f1e42a95af6ba4ba8394d42414ab7f0011f04eca5449c851bbc42d70c5", + "size": 594651, + "subdir": "linux-64", + "timestamp": 1530793073367, + "version": "5.1.0" + }, + "pillow-5.1.0-py37heded4f4_0.tar.bz2": { + "build": "py37heded4f4_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "fee8fb22d23546576e44634db8d25555", + "name": "pillow", + "sha256": "f8dfd85b95d16be439fddfb9298b2e41b1abb54e29e9846760a1cd9f13ec7d18", + "size": 593432, + "subdir": "linux-64", + "timestamp": 1530793115839, + "version": "5.1.0" + }, + "pillow-5.2.0-py27heded4f4_0.tar.bz2": { + "build": "py27heded4f4_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "97b7c3deb6ff3e7f63f94b436bf07811", + "name": "pillow", + "sha256": "d69a03518f7af264885887649439f22db0a921444e66b5ba8c414b4bdbd3480b", + "size": 597305, + "subdir": "linux-64", + "timestamp": 1532639726822, + "version": "5.2.0" + }, + "pillow-5.2.0-py35heded4f4_0.tar.bz2": { + "build": "py35heded4f4_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.5,<3.6.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "6c4d7288dc196ff77f630d0224f1f488", + "name": "pillow", + "sha256": "fa612215e8ba75a3b178d0fb993148bcf91a99add10e314c3e938c6eea373fc8", + "size": 603538, + "subdir": "linux-64", + "timestamp": 1532639672983, + "version": "5.2.0" + }, + "pillow-5.2.0-py36heded4f4_0.tar.bz2": { + "build": "py36heded4f4_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "abedcfbd04058f48ae8a42f8b15d1121", + "name": "pillow", + "sha256": "351bf77786fc9e39ac2f685a77916eec8f2a88865aaa610c7065fa4698853d2b", + "size": 600191, + "subdir": "linux-64", + "timestamp": 1532639727788, + "version": "5.2.0" + }, + "pillow-5.2.0-py37heded4f4_0.tar.bz2": { + "build": "py37heded4f4_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "1f72d77302c7ba3fd815f6c5c2d2784c", + "name": "pillow", + "sha256": "0a40f373654f81cba5eb7dea03b7b1d3bedfef6d5ad02c896c3e1548cc8af894", + "size": 596772, + "subdir": "linux-64", + "timestamp": 1532639677480, + "version": "5.2.0" + }, + "pillow-5.3.0-py27h34e0f95_0.tar.bz2": { + "build": "py27h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "59fb08bf25db59aa4c3f587da1cac9c4", + "name": "pillow", + "sha256": "aed2ef690830d7756f3c03fc0a92e5724a794d679842439b6045f02a68cfb719", + "size": 607772, + "subdir": "linux-64", + "timestamp": 1538496183948, + "version": "5.3.0" + }, + "pillow-5.3.0-py36h34e0f95_0.tar.bz2": { + "build": "py36h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "ddc5fa19e9cde53e7dc075ed0834f474", + "name": "pillow", + "sha256": "4362863e205c8db256ca5b0b7a9ac6dd2b9065337a20938f4f4224a05d270d19", + "size": 613606, + "subdir": "linux-64", + "timestamp": 1538496219175, + "version": "5.3.0" + }, + "pillow-5.3.0-py37h34e0f95_0.tar.bz2": { + "build": "py37h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "d1bbc37a2bfce34a8e02772e4c9ccb7a", + "name": "pillow", + "sha256": "73fcbb6909437b3606a5bf8ec8a12663714e7a9dd7ba630cd46f011a975e50ce", + "size": 609278, + "subdir": "linux-64", + "timestamp": 1538496194003, + "version": "5.3.0" + }, + "pillow-5.4.1-py27h34e0f95_0.tar.bz2": { + "build": "py27h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "e81891ff6a1cb55b1cab761f30761209", + "name": "pillow", + "sha256": "c4bc54ef8a4f38897c8024f13bd2ff4a0c21cbcfc0202c7eeb3fd49e2e3a7149", + "size": 633208, + "subdir": "linux-64", + "timestamp": 1547244966387, + "version": "5.4.1" + }, + "pillow-5.4.1-py36h34e0f95_0.tar.bz2": { + "build": "py36h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "2a4ff2cde6f511a98694db4c40fa2337", + "name": "pillow", + "sha256": "36aea374e446884faeabb3adbe83b9a9d823c858e2f498a1a3fc658fc171d2a0", + "size": 642180, + "subdir": "linux-64", + "timestamp": 1547244967043, + "version": "5.4.1" + }, + "pillow-5.4.1-py37h34e0f95_0.tar.bz2": { + "build": "py37h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "eecadcdee88850d634e6e3404c186f5e", + "name": "pillow", + "sha256": "ace17e7d0980a77b479120f411ef702f18fd60e48f99d62482f203e0ded41147", + "size": 631283, + "subdir": "linux-64", + "timestamp": 1547244975725, + "version": "5.4.1" + }, + "pillow-6.0.0-py27h34e0f95_0.tar.bz2": { + "build": "py27h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "99cefca181efda568c46194cc3119c0b", + "name": "pillow", + "sha256": "52544f5461e7a84f5253cab3e88380864affd04a3ccc386650dd7df51fc21dfc", + "size": 640967, + "subdir": "linux-64", + "timestamp": 1555451330581, + "version": "6.0.0" + }, + "pillow-6.0.0-py36h34e0f95_0.tar.bz2": { + "build": "py36h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "742f253ec8352640442ed4fdfd08855f", + "name": "pillow", + "sha256": "054a10d4e840e0c1b955e501acc7b5c4c06c68412d334da6d2c7312f7f281943", + "size": 641355, + "subdir": "linux-64", + "timestamp": 1555451367343, + "version": "6.0.0" + }, + "pillow-6.0.0-py37h34e0f95_0.tar.bz2": { + "build": "py37h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "4c87a39352bd2543f1b2437c1fde530a", + "name": "pillow", + "sha256": "0dd47b49a17d8b2ed77110d1ac98d0c52f1119b08f450136a5049c552f7539c4", + "size": 639044, + "subdir": "linux-64", + "timestamp": 1555451330116, + "version": "6.0.0" + }, + "pillow-6.1.0-py27h34e0f95_0.tar.bz2": { + "build": "py27h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "308caea1b9279d8442479ca18050ef54", + "name": "pillow", + "sha256": "43a6e0fe6c39cf2c074b23c7122f3edce4a1d19b54df61ad5a69cc5ccb51e164", + "size": 646017, + "subdir": "linux-64", + "timestamp": 1563206526992, + "version": "6.1.0" + }, + "pillow-6.1.0-py36h34e0f95_0.tar.bz2": { + "build": "py36h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "e4410cba34a05f1ca7ceaad9d4da053d", + "name": "pillow", + "sha256": "783ac075e0973da87fcb381a3ae374fb8f47e80155bc1f867bb027e60592fbee", + "size": 657881, + "subdir": "linux-64", + "timestamp": 1563206550131, + "version": "6.1.0" + }, + "pillow-6.1.0-py37h34e0f95_0.tar.bz2": { + "build": "py37h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "c5fb7980dbcfc5aaa5e4b610d94a7bf8", + "name": "pillow", + "sha256": "344241b32e7b7453263677b4bd68261cf468c28b94fad235778d83a6616f7e28", + "size": 649799, + "subdir": "linux-64", + "timestamp": 1563206560457, + "version": "6.1.0" + }, + "pillow-6.2.0-py27h34e0f95_0.tar.bz2": { + "build": "py27h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "dca0d536ff8281d1ba0730fc15473af4", + "name": "pillow", + "sha256": "3612960355b711e65bcc7772d9fc6e5f7379d6d7a52eaa07366505ea3fa64b58", + "size": 657677, + "subdir": "linux-64", + "timestamp": 1570463231728, + "version": "6.2.0" + }, + "pillow-6.2.0-py36h34e0f95_0.tar.bz2": { + "build": "py36h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "c866b45609ac931b02512c033a27c8b0", + "name": "pillow", + "sha256": "1c85ac31b5aa1e43aacde2b8fa490588682b677c76db3ed1bb853592a30941c1", + "size": 662409, + "subdir": "linux-64", + "timestamp": 1570463244088, + "version": "6.2.0" + }, + "pillow-6.2.0-py37h34e0f95_0.tar.bz2": { + "build": "py37h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "14c0123719a619bebf0d6a7c6aac3b33", + "name": "pillow", + "sha256": "086283ab137333f902e0b77bf1ae1f366ae953c4fe1aeef4a586654ef7c2586d", + "size": 658654, + "subdir": "linux-64", + "timestamp": 1570463239077, + "version": "6.2.0" + }, + "pillow-6.2.1-py27h34e0f95_0.tar.bz2": { + "build": "py27h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "5d7960fe8b5b4c67f5d7b7b37b1cff7a", + "name": "pillow", + "sha256": "4f1a19ea07d389227b619c638c24ee1892e3268a55482d93ca3a2df3c9d6dee1", + "size": 648025, + "subdir": "linux-64", + "timestamp": 1573052428728, + "version": "6.2.1" + }, + "pillow-6.2.1-py36h34e0f95_0.tar.bz2": { + "build": "py36h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "45c316eb4f5a9abcf26057d0bb670bd7", + "name": "pillow", + "sha256": "774b17a8d85e918e026878adf4e965a23bcd5583b06e522f192a69bae9aa918d", + "size": 654980, + "subdir": "linux-64", + "timestamp": 1573052444776, + "version": "6.2.1" + }, + "pillow-6.2.1-py37h34e0f95_0.tar.bz2": { + "build": "py37h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "7b4048f6325773d4eeab2a79e8a8e6a4", + "name": "pillow", + "sha256": "4e0db98430843be474351107a8c4df001883b14715b7a1fc4304d01a471514fa", + "size": 657979, + "subdir": "linux-64", + "timestamp": 1573052442682, + "version": "6.2.1" + }, + "pillow-6.2.1-py38h34e0f95_0.tar.bz2": { + "build": "py38h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "5e7f1bdba6b225c729a84973478bedcf", + "name": "pillow", + "sha256": "5249d5027b249a454c3ea886a86e393765d5a788b7d9508fa2790c2ebe96c41b", + "size": 654537, + "subdir": "linux-64", + "timestamp": 1573469573595, + "version": "6.2.1" + }, + "pillow-7.0.0-py36hb39fc2d_0.tar.bz2": { + "build": "py36hb39fc2d_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "40056b7d37580a41d949f0a683cb434d", + "name": "pillow", + "sha256": "f006229f7a9b923000c785ce300199115978dff4e5795a9c2a1c85561a20eea0", + "size": 667981, + "subdir": "linux-64", + "timestamp": 1578413332351, + "version": "7.0.0" + }, + "pillow-7.0.0-py37hb39fc2d_0.tar.bz2": { + "build": "py37hb39fc2d_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "dff939fc3b48bdac3dd9317c842e6dde", + "name": "pillow", + "sha256": "5a6ed9fa2a7bcc266f5d29ab538d00b4ffefb196aef2366225baf5c4cbade1ca", + "size": 672825, + "subdir": "linux-64", + "timestamp": 1578413343899, + "version": "7.0.0" + }, + "pillow-7.0.0-py38hb39fc2d_0.tar.bz2": { + "build": "py38hb39fc2d_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "c19af6d11eb74c66901361a4bd705de9", + "name": "pillow", + "sha256": "8f2b2a02b5be517317fd69b7d9e670e08c8c8a6975fd73e14ca34e7cc873cfa1", + "size": 680251, + "subdir": "linux-64", + "timestamp": 1578413341200, + "version": "7.0.0" + }, + "pillow-7.1.2-py36hb39fc2d_0.tar.bz2": { + "build": "py36hb39fc2d_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "6792c4c811a72c893f11ffe0ce391624", + "name": "pillow", + "sha256": "47cabf075ddc6e8cda9d155404fdb64034beeb7afa509a6bb7cb405d0fc1f708", + "size": 680989, + "subdir": "linux-64", + "timestamp": 1588471882757, + "version": "7.1.2" + }, + "pillow-7.1.2-py37hb39fc2d_0.tar.bz2": { + "build": "py37hb39fc2d_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "c85184b2f4da12ff2a525a94d34b5946", + "name": "pillow", + "sha256": "f82281c54f95e5f2b362b216ed002212cb9bc5957edc8506979bd0053a9b014a", + "size": 677666, + "subdir": "linux-64", + "timestamp": 1588471882131, + "version": "7.1.2" + }, + "pillow-7.1.2-py38hb39fc2d_0.tar.bz2": { + "build": "py38hb39fc2d_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "0ff0945f03dfbf96bdcfc562bdc98b9e", + "name": "pillow", + "sha256": "1d4bc241ff08f36f5c7c408bf428958bee1570ee114f1092cf28212b912ae8ff", + "size": 673628, + "subdir": "linux-64", + "timestamp": 1588471881910, + "version": "7.1.2" + }, + "pillow-7.2.0-py36hb39fc2d_0.tar.bz2": { + "build": "py36hb39fc2d_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.10,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "dcd5d9b2628324557ac0934166468a00", + "name": "pillow", + "sha256": "65feb2c84b2d916573d75d0ef4e091432c79fb868142fbd39043c2948aca1942", + "size": 688943, + "subdir": "linux-64", + "timestamp": 1594307365389, + "version": "7.2.0" + }, + "pillow-7.2.0-py37hb39fc2d_0.tar.bz2": { + "build": "py37hb39fc2d_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.10,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "79a4e03941d9e05c7f427b8f945f795b", + "name": "pillow", + "sha256": "3b9bc94d17c52e2b760fcd95fbabc9c88376f4cf48d80c12e15e823c47eeaf92", + "size": 690908, + "subdir": "linux-64", + "timestamp": 1594307398305, + "version": "7.2.0" + }, + "pillow-7.2.0-py38hb39fc2d_0.tar.bz2": { + "build": "py38hb39fc2d_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk >=8.6.10,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "a8fcfc5ea51da0ed33c6372e30470648", + "name": "pillow", + "sha256": "2f9c8fed35d56a95540bb8cc535fe9884742b12cbfde53d2958406e2c31edc39", + "size": 691756, + "subdir": "linux-64", + "timestamp": 1594307358675, + "version": "7.2.0" + }, + "pillow-8.0.0-py36h9a89aac_0.tar.bz2": { + "build": "py36h9a89aac_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.3,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "55b05ff2b4e8c0ea528d81aa5216bdf9", + "name": "pillow", + "sha256": "a4e5de0470d97f68a727343b1a8f81f772ccffe500a11e1dcc7e62557242f457", + "size": 691642, + "subdir": "linux-64", + "timestamp": 1602788773457, + "version": "8.0.0" + }, + "pillow-8.0.0-py37h9a89aac_0.tar.bz2": { + "build": "py37h9a89aac_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.3,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "bd65782a1e1a0f6d7c8da62d710f5ca0", + "name": "pillow", + "sha256": "a5dfd727229aa8ec3db0ff476a91c3164b844551932058fcdb26c40deafbc022", + "size": 702298, + "subdir": "linux-64", + "timestamp": 1602788761871, + "version": "8.0.0" + }, + "pillow-8.0.0-py38h9a89aac_0.tar.bz2": { + "build": "py38h9a89aac_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.3,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "1e320d782355db0811ba57a8efa840bc", + "name": "pillow", + "sha256": "a61f0d5e30b58cc436ac36135afdc95b1cb1418b34c5c7b52ce56e3eca237971", + "size": 696492, + "subdir": "linux-64", + "timestamp": 1602788778754, + "version": "8.0.0" + }, + "pillow-8.0.1-py36h9a89aac_0.tar.bz2": { + "build": "py36h9a89aac_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "77aece02d8210a5f6aa1a04da8d991b8", + "name": "pillow", + "sha256": "5513cf9b189627b7105f3d0db19bc5377d42c651db45ee3a44de8a2da5cb9211", + "size": 693229, + "subdir": "linux-64", + "timestamp": 1603478914834, + "version": "8.0.1" + }, + "pillow-8.0.1-py36he98fc37_0.tar.bz2": { + "build": "py36he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "aa09aa5c1d6c483d59d0303c7dfd0b96", + "name": "pillow", + "sha256": "8d107175ad79abdcd698933e6be046268f69988b6090276a7fe8ce556bc716c6", + "size": 704868, + "subdir": "linux-64", + "timestamp": 1603822302635, + "version": "8.0.1" + }, + "pillow-8.0.1-py37h9a89aac_0.tar.bz2": { + "build": "py37h9a89aac_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "c85a8cbfee08e0763ad8080e471eaf2a", + "name": "pillow", + "sha256": "32841bc919d91fba83684aba5fcf7750488de4b896c6af5b33a5576583b7ffef", + "size": 694544, + "subdir": "linux-64", + "timestamp": 1603478874893, + "version": "8.0.1" + }, + "pillow-8.0.1-py37he98fc37_0.tar.bz2": { + "build": "py37he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "f552703bd137d3f8c89f8a8ac443ca6c", + "name": "pillow", + "sha256": "a7989ef39de2400a9fbcd0569dbb891771fc9ce4b1f2eda0627d31fe3701388d", + "size": 690577, + "subdir": "linux-64", + "timestamp": 1603822320358, + "version": "8.0.1" + }, + "pillow-8.0.1-py38h9a89aac_0.tar.bz2": { + "build": "py38h9a89aac_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "05c9b65a9dab0cb8fad0b5843cb4972d", + "name": "pillow", + "sha256": "69a79da549c3dd896af17e3ce3dca19a1dbdfe99edf76f80c218fce28798a527", + "size": 699689, + "subdir": "linux-64", + "timestamp": 1603395998038, + "version": "8.0.1" + }, + "pillow-8.0.1-py38he98fc37_0.tar.bz2": { + "build": "py38he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "c9d5c492fd7c7d30b06908eb331f6e81", + "name": "pillow", + "sha256": "defff42e3f8b72d845fcd4cfd7fd8804ab1bbe2b6a543c8e24aaa8ea4951893d", + "size": 695917, + "subdir": "linux-64", + "timestamp": 1603822320887, + "version": "8.0.1" + }, + "pillow-8.0.1-py39he98fc37_0.tar.bz2": { + "build": "py39he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "c0348b12e4ea3a3cb5b8511de5e0d8e3", + "name": "pillow", + "sha256": "1fb6fa3bfb0b1ec3864feb2b8a9d28d023c6786ddd8f33f41c8d2597fd4d6a3b", + "size": 721779, + "subdir": "linux-64", + "timestamp": 1607027453668, + "version": "8.0.1" + }, + "pillow-8.1.0-py36he98fc37_0.tar.bz2": { + "build": "py36he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "3fa6ca3d5bfa401e31b2b5c4209f64b6", + "name": "pillow", + "sha256": "a3a4c52b090cc7831f11be7031e7ab1b4b29c5964134a8d2fdd080b68c247998", + "size": 693304, + "subdir": "linux-64", + "timestamp": 1609786801229, + "version": "8.1.0" + }, + "pillow-8.1.0-py37he98fc37_0.tar.bz2": { + "build": "py37he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "d3a21a6052573181e09fe7f2d998f793", + "name": "pillow", + "sha256": "c2dd4834fe30afcd30d01f7ad8106ff25c555297ba5d2424dabbed9be0e87971", + "size": 698054, + "subdir": "linux-64", + "timestamp": 1609786803984, + "version": "8.1.0" + }, + "pillow-8.1.0-py38he98fc37_0.tar.bz2": { + "build": "py38he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "1247c08aca9f0d289cc92d94dfe4d09c", + "name": "pillow", + "sha256": "aaf89a2a86e09baf6adccb62e185efcc9b07bc056e7acb83a185d0dd673ef40b", + "size": 696480, + "subdir": "linux-64", + "timestamp": 1609786851026, + "version": "8.1.0" + }, + "pillow-8.1.0-py39he98fc37_0.tar.bz2": { + "build": "py39he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "bbf9041e0a201f1f1d373b0fd661ab32", + "name": "pillow", + "sha256": "1120dda6120caa0beb45a7e752b97bd6a0d6cc97d96b630e1144d6a7f6784320", + "size": 712404, + "subdir": "linux-64", + "timestamp": 1609786718844, + "version": "8.1.0" + }, + "pillow-8.1.1-py36he98fc37_0.tar.bz2": { + "build": "py36he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "fba57a61177e2148c6c94dc7c814e237", + "name": "pillow", + "sha256": "569e106ea0326d2f37243fe586207967d1888a23a1aef4db12399fd58fb258e8", + "size": 694763, + "subdir": "linux-64", + "timestamp": 1614711496822, + "version": "8.1.1" + }, + "pillow-8.1.1-py37he98fc37_0.tar.bz2": { + "build": "py37he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "4d1108699ed6e42a63edc39658f99245", + "name": "pillow", + "sha256": "455df82b7ea21371f447a82cb31c1559792363dfe2189d72a91ef8b2b6fc8fd6", + "size": 693392, + "subdir": "linux-64", + "timestamp": 1614711502015, + "version": "8.1.1" + }, + "pillow-8.1.1-py38he98fc37_0.tar.bz2": { + "build": "py38he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "16d04e3f70c753c9ed713cc223f2d740", + "name": "pillow", + "sha256": "b026b30b1d74a9cf8efd8759755335a8cd2a1fb1a10db7b1d749b2406b9616d1", + "size": 699726, + "subdir": "linux-64", + "timestamp": 1614711506646, + "version": "8.1.1" + }, + "pillow-8.1.1-py39he98fc37_0.tar.bz2": { + "build": "py39he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "3fef11b2be54ae641fea46402aad7685", + "name": "pillow", + "sha256": "abde0a05b914fca262afc40f14caae1b007c162c20d196fda90361a0e09b86a1", + "size": 707958, + "subdir": "linux-64", + "timestamp": 1614711493006, + "version": "8.1.1" + }, + "pillow-8.1.2-py36he98fc37_0.tar.bz2": { + "build": "py36he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "b50586e93a318efb6d4812e42f8d7132", + "name": "pillow", + "sha256": "4471854df47977dd30a87a4afa05005dd816c35fda9c501e76eb75438fd9fd50", + "size": 702526, + "subdir": "linux-64", + "timestamp": 1615224097587, + "version": "8.1.2" + }, + "pillow-8.1.2-py37he98fc37_0.tar.bz2": { + "build": "py37he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "3ff1994a751ad3fa92272a71764ce9dc", + "name": "pillow", + "sha256": "5461b094eb55ab15b1509c9d52a1d74d66fc962400ac120fcd48b91c80084c9c", + "size": 699770, + "subdir": "linux-64", + "timestamp": 1615057420609, + "version": "8.1.2" + }, + "pillow-8.1.2-py38he98fc37_0.tar.bz2": { + "build": "py38he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "d0a298cfd74770d51c2cfba8d0de5191", + "name": "pillow", + "sha256": "648d8463ca7bc68b4716f40baaf070fad4298731e563544dfe948316d4dea418", + "size": 699636, + "subdir": "linux-64", + "timestamp": 1615224161236, + "version": "8.1.2" + }, + "pillow-8.1.2-py39he98fc37_0.tar.bz2": { + "build": "py39he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "f66ad09f08498506ce5fcc8f7269a6cc", + "name": "pillow", + "sha256": "d8323b78aad7fe438c2c3e1e978efd0d759a18300524677f6159dd829d73658b", + "size": 704634, + "subdir": "linux-64", + "timestamp": 1615224163037, + "version": "8.1.2" + }, + "pillow-8.2.0-py36he98fc37_0.tar.bz2": { + "build": "py36he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "2297744e88e8a36a9dcb7087eadeee91", + "name": "pillow", + "sha256": "fe9b3a61838566bc294e047d743232bb0a178be3b0f5f54a763ef82ab80be945", + "size": 705304, + "subdir": "linux-64", + "timestamp": 1617386230630, + "version": "8.2.0" + }, + "pillow-8.2.0-py37he98fc37_0.tar.bz2": { + "build": "py37he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "cd06d462391ebfe5c81523ae073a8abb", + "name": "pillow", + "sha256": "f05ce3f33b47eb7578999c68a12abe812120ad371355af36953dabd8ba49db33", + "size": 701543, + "subdir": "linux-64", + "timestamp": 1617386228468, + "version": "8.2.0" + }, + "pillow-8.2.0-py38he98fc37_0.tar.bz2": { + "build": "py38he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "6d1429114e42384257cd0bfd7fd7b493", + "name": "pillow", + "sha256": "42ecea46210fa6028fdd0bde77696f15df824c82898399a86afaed579daf4776", + "size": 695490, + "subdir": "linux-64", + "timestamp": 1617383653613, + "version": "8.2.0" + }, + "pillow-8.2.0-py39he98fc37_0.tar.bz2": { + "build": "py39he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "965ff2a6facb97fb71d0c80b9ed27536", + "name": "pillow", + "sha256": "52940a17f7db431fe20ba017cbc188500211e8f89795c281b457e717ffc9c608", + "size": 717785, + "subdir": "linux-64", + "timestamp": 1617385642760, + "version": "8.2.0" + }, + "pillow-8.3.1-py36h2c7a002_0.tar.bz2": { + "build": "py36h2c7a002_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.6,<3.7.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "67bcf67f1e82e429d5dfadf8803c5e33", + "name": "pillow", + "sha256": "ec592dd47cda92d62b8070325f881190b6a2cbfd089be5c1feaf31bcf9d3043e", + "size": 711302, + "subdir": "linux-64", + "timestamp": 1625649151492, + "version": "8.3.1" + }, + "pillow-8.3.1-py36h5aabda8_0.tar.bz2": { + "build": "py36h5aabda8_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "f50153750148a6bcd569dbc6ff047750", + "name": "pillow", + "sha256": "3804600200edd0540b00c6b14f444a63c79ad3c621aa29b0eb3048c6f9522508", + "size": 707680, + "subdir": "linux-64", + "timestamp": 1625670720843, + "version": "8.3.1" + }, + "pillow-8.3.1-py37h2c7a002_0.tar.bz2": { + "build": "py37h2c7a002_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "17b2b68d94111121d393ae13a1b13a43", + "name": "pillow", + "sha256": "a80a8e6f217dc9127ce2d08799e59640ba7734851bca9409b16ceb80df667d42", + "size": 707257, + "subdir": "linux-64", + "timestamp": 1625655892328, + "version": "8.3.1" + }, + "pillow-8.3.1-py37h5aabda8_0.tar.bz2": { + "build": "py37h5aabda8_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "76f124289a8d0519cb6cebeb4f6cef03", + "name": "pillow", + "sha256": "2dc2cb5afca488b306f6f7764e7d9a90dab7cf29dde7c197b172a6635e07336e", + "size": 706169, + "subdir": "linux-64", + "timestamp": 1625670702141, + "version": "8.3.1" + }, + "pillow-8.3.1-py38h2c7a002_0.tar.bz2": { + "build": "py38h2c7a002_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "3e8a46301c861eea2bae99e050a73d0c", + "name": "pillow", + "sha256": "c899833bd98447a1d0df9bf5477b08417d83fdb4a468a236cab0499b8ef1af8a", + "size": 721761, + "subdir": "linux-64", + "timestamp": 1625655892412, + "version": "8.3.1" + }, + "pillow-8.3.1-py38h5aabda8_0.tar.bz2": { + "build": "py38h5aabda8_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "de3a577f54317a10804111631d3a4581", + "name": "pillow", + "sha256": "060284c1b6b447d0f5410004a2aa5054e4a6db963e0551c2589de2335b423eab", + "size": 715357, + "subdir": "linux-64", + "timestamp": 1625670696790, + "version": "8.3.1" + }, + "pillow-8.3.1-py39h2c7a002_0.tar.bz2": { + "build": "py39h2c7a002_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "eb8067e8f470e1c3e7e2594bee8d59f4", + "name": "pillow", + "sha256": "88ab0e96265864fd43353f561128b716755aa3441703aa3c03e2c12aa92f4b35", + "size": 727559, + "subdir": "linux-64", + "timestamp": 1625655490878, + "version": "8.3.1" + }, + "pillow-8.3.1-py39h5aabda8_0.tar.bz2": { + "build": "py39h5aabda8_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "olefile", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "1d9981c9bcc19d3a3cacc08fc2734cfb", + "name": "pillow", + "sha256": "1ccf8df3b2d6d723220bfe89254d0e90e8d2dc2ca983d72af3012660bd642262", + "size": 722339, + "subdir": "linux-64", + "timestamp": 1625670421468, + "version": "8.3.1" + }, + "pillow-8.4.0-py310h63577eb_0.tar.bz2": { + "build": "py310h63577eb_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=8.4.0", + "libstdcxx-ng >=8.4.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "olefile", + "python >=3.10,<3.11.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "12da557244b3bcd7fe752749ef4903f3", + "name": "pillow", + "sha256": "b97479b993b03e668624e1ebcd5112c5f940a393c21d00108e9b6ecbfa0ae2b2", + "size": 1469249, + "subdir": "linux-64", + "timestamp": 1643111226093, + "version": "8.4.0" + }, + "pillow-8.4.0-py37h5aabda8_0.tar.bz2": { + "build": "py37h5aabda8_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "3593be24a3e8dd5295e232a28a5f42d8", + "name": "pillow", + "sha256": "8741ed52b625bb0f9d2ec8ce74fc3ee36e9aa4c81809c29b25d7f07dda6718f6", + "size": 718676, + "subdir": "linux-64", + "timestamp": 1634549384212, + "version": "8.4.0" + }, + "pillow-8.4.0-py38h5aabda8_0.tar.bz2": { + "build": "py38h5aabda8_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "3cb925ddf49b27d41a3e3f2259576707", + "name": "pillow", + "sha256": "122b31a239469fb08610e6943efdb6e8f0b3051d36c2a2b2716b784184b1a346", + "size": 720293, + "subdir": "linux-64", + "timestamp": 1634538125138, + "version": "8.4.0" + }, + "pillow-8.4.0-py39h5aabda8_0.tar.bz2": { + "build": "py39h5aabda8_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "olefile", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "bbd9b94d7720f71faae716701fba06b0", + "name": "pillow", + "sha256": "ab3ac58519fdc4276ec525e64bd7a8802392ab6448ee0981927a952639fddd55", + "size": 730376, + "subdir": "linux-64", + "timestamp": 1634549388954, + "version": "8.4.0" + }, + "pillow-9.0.1-py310h22f2fdc_0.tar.bz2": { + "build": "py310h22f2fdc_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.10,<3.11.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "d2c2bc0c866b0605b74f2a9977d0f70a", + "name": "pillow", + "sha256": "ee09fb4a72b37685c9c4e16eda990f402e52878d54c24a6160d0c6a6ea8528ac", + "size": 1368886, + "subdir": "linux-64", + "timestamp": 1646325112795, + "version": "9.0.1" + }, + "pillow-9.0.1-py37h22f2fdc_0.tar.bz2": { + "build": "py37h22f2fdc_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "310fbf5604a29bb07e363adfac874e1a", + "name": "pillow", + "sha256": "cccb21414a52e4a317fa771d2e8997ab334d6f1901ff74b57068df28683b863c", + "size": 730599, + "subdir": "linux-64", + "timestamp": 1646325091733, + "version": "9.0.1" + }, + "pillow-9.0.1-py38h22f2fdc_0.tar.bz2": { + "build": "py38h22f2fdc_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "ece067a13def0fb55fcf2f6f7ad128b1", + "name": "pillow", + "sha256": "4e2faa1845386c77f6a7a7b67d1283b1d2139e2a979f2c852e3c6f770b7b59cf", + "size": 732913, + "subdir": "linux-64", + "timestamp": 1646306967387, + "version": "9.0.1" + }, + "pillow-9.0.1-py39h22f2fdc_0.tar.bz2": { + "build": "py39h22f2fdc_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "b7689507fb5f879dc766aaa8a4c37351", + "name": "pillow", + "sha256": "8bcb1c67693f42a3170eb77ef4cdbb81b605fdf40816953e69a33a065c101638", + "size": 734566, + "subdir": "linux-64", + "timestamp": 1646325095608, + "version": "9.0.1" + }, + "pillow-9.2.0-py310hace64e9_0.tar.bz2": { + "build": "py310hace64e9_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.10,<3.11.0a0", + "tk", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "4f66a844c7c13972076c1f0d822e38bf", + "name": "pillow", + "sha256": "92496a7e72890d8e87ff145309341f344f19ae5281cd8fe250f8fa7ca52907fd", + "size": 1407881, + "subdir": "linux-64", + "timestamp": 1657724329870, + "version": "9.2.0" + }, + "pillow-9.2.0-py310hace64e9_1.tar.bz2": { + "build": "py310hace64e9_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.10,<3.11.0a0", + "tk", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "8dd1b4e9aead84393d0e5b1dbe19566b", + "name": "pillow", + "sha256": "7ebf84b53694860a8d26ffd5481c6d8498841eb631e626463be93d39153c7355", + "size": 1407368, + "subdir": "linux-64", + "timestamp": 1657829171881, + "version": "9.2.0" + }, + "pillow-9.2.0-py37hace64e9_0.tar.bz2": { + "build": "py37hace64e9_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "a463416ace16ed1d7d41d226e006cac2", + "name": "pillow", + "sha256": "96161daa0965330121274f7d6e56e0ef5e83ee941a4f0472527de7a2adfd259c", + "size": 740088, + "subdir": "linux-64", + "timestamp": 1657724434199, + "version": "9.2.0" + }, + "pillow-9.2.0-py37hace64e9_1.tar.bz2": { + "build": "py37hace64e9_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "95203320339b80b8d871e2ff4ad34bc2", + "name": "pillow", + "sha256": "6024bbc91c2883ec485a02a257830737ed15014a4851286799d07ab33bbb6012", + "size": 731796, + "subdir": "linux-64", + "timestamp": 1657829271742, + "version": "9.2.0" + }, + "pillow-9.2.0-py38hace64e9_0.tar.bz2": { + "build": "py38hace64e9_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "c7aa22287d5440820c10659cff502854", + "name": "pillow", + "sha256": "fec28eb1eaf96cc60f20906bfa7941be11b4fca4435d382b1aeeedc0bccacaee", + "size": 742231, + "subdir": "linux-64", + "timestamp": 1657724485955, + "version": "9.2.0" + }, + "pillow-9.2.0-py38hace64e9_1.tar.bz2": { + "build": "py38hace64e9_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "a09b89b5ee6270e7de439917c7833121", + "name": "pillow", + "sha256": "0b7cb43869ec60a5b0fa444581d83cd892132cbb404307df98b250feb711032f", + "size": 732946, + "subdir": "linux-64", + "timestamp": 1657828928919, + "version": "9.2.0" + }, + "pillow-9.2.0-py39hace64e9_0.tar.bz2": { + "build": "py39hace64e9_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "02e8df91e6ceef8c68ef4653b15ca50d", + "name": "pillow", + "sha256": "82d45c99fb7941219f66fde639202cdef865be26edae51af6f5afc0a0e48cd08", + "size": 746248, + "subdir": "linux-64", + "timestamp": 1657724381965, + "version": "9.2.0" + }, + "pillow-9.2.0-py39hace64e9_1.tar.bz2": { + "build": "py39hace64e9_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "f916184be2f9f18cb1add691f7588d57", + "name": "pillow", + "sha256": "842c04a9976fa7ed6f409c399608b8f40c50bb3c01529dc6371279854da89563", + "size": 737611, + "subdir": "linux-64", + "timestamp": 1657829034677, + "version": "9.2.0" + }, + "pillow-9.3.0-py310h6a678d5_2.tar.bz2": { + "build": "py310h6a678d5_2", + "build_number": 2, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.10,<3.11.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "8d5fb665ef200ba6a7f471aaac72c53f", + "name": "pillow", + "sha256": "4f1c9cb7ca7bbefef101cf8e91a7287ad95ed56063cc6eaa60d93f4801030334", + "size": 750080, + "subdir": "linux-64", + "timestamp": 1675358421882, + "version": "9.3.0" + }, + "pillow-9.3.0-py310hace64e9_0.tar.bz2": { + "build": "py310hace64e9_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.10,<3.11.0a0", + "tk", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "d32c3eba4abd4212092ab50ed641ab7b", + "name": "pillow", + "sha256": "b025e0e3ca8a8ce078e74c6c3978e14a553a8d9cd82f3dbbd8e87427301d9268", + "size": 742561, + "subdir": "linux-64", + "timestamp": 1671482912279, + "version": "9.3.0" + }, + "pillow-9.3.0-py310hace64e9_1.tar.bz2": { + "build": "py310hace64e9_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.10,<3.11.0a0", + "tk", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "9652e5c4e7a325a9261884f742ab0b27", + "name": "pillow", + "sha256": "873f5b67f8bd4195af3f688a2dfd4ff31278b21b8575862163e85df93fdf91dc", + "size": 756661, + "subdir": "linux-64", + "timestamp": 1671656565302, + "version": "9.3.0" + }, + "pillow-9.3.0-py311h6a678d5_2.tar.bz2": { + "build": "py311h6a678d5_2", + "build_number": 2, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.11,<3.12.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "ffb682d553645e1e83227b968b55857a", + "name": "pillow", + "sha256": "38e55defe1eeff3a7b5e9868f24bc71f9b93a5778ad5b506a367edf117033a94", + "size": 896331, + "subdir": "linux-64", + "timestamp": 1676827382376, + "version": "9.3.0" + }, + "pillow-9.3.0-py37h6a678d5_2.tar.bz2": { + "build": "py37h6a678d5_2", + "build_number": 2, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.7,<3.8.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "024ef8d3e5dfe72a519958ff54af63f2", + "name": "pillow", + "sha256": "1a627b05c7bb54c8cc99fcd93d4ab95d906269c19c5dcf5c09b8ba0cfb01a337", + "size": 741189, + "subdir": "linux-64", + "timestamp": 1675358280680, + "version": "9.3.0" + }, + "pillow-9.3.0-py37hace64e9_0.tar.bz2": { + "build": "py37hace64e9_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "d61f24675838ab1d805669cbc8a46b8a", + "name": "pillow", + "sha256": "347a0bfa4fc7ccae4746348e0cc4dcf2b1bcbf647e4bf878b2fdbdf1a69521be", + "size": 733754, + "subdir": "linux-64", + "timestamp": 1671482820612, + "version": "9.3.0" + }, + "pillow-9.3.0-py37hace64e9_1.tar.bz2": { + "build": "py37hace64e9_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "ecafa8cbffcefbb86796d92314416e4c", + "name": "pillow", + "sha256": "666c6b0d45fb200f8b3f71a33e9fd096c52007aa49531b5f46403118d358ed14", + "size": 747350, + "subdir": "linux-64", + "timestamp": 1671656528687, + "version": "9.3.0" + }, + "pillow-9.3.0-py38h6a678d5_2.tar.bz2": { + "build": "py38h6a678d5_2", + "build_number": 2, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.8,<3.9.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "d9f94eb1266d022d525dabc7361d1f06", + "name": "pillow", + "sha256": "8e18f86a90cedb604b6dfc724aeb23fcb49a83f353af1eb33e9649c25b57f875", + "size": 743653, + "subdir": "linux-64", + "timestamp": 1675358375012, + "version": "9.3.0" + }, + "pillow-9.3.0-py38hace64e9_0.tar.bz2": { + "build": "py38hace64e9_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "ee1fe13048a7701fa49cdf820ad28b1b", + "name": "pillow", + "sha256": "7b5f60b64f5d25050fadf9a8857b0ea205d506b70afa0529a91386e5d9754563", + "size": 734600, + "subdir": "linux-64", + "timestamp": 1671482774617, + "version": "9.3.0" + }, + "pillow-9.3.0-py38hace64e9_1.tar.bz2": { + "build": "py38hace64e9_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "445ce5c91b0122e269bc0942f8ba722b", + "name": "pillow", + "sha256": "c7222b1a1d95e6e0de12c5a9c51fb82e55c025fe3a98acf7983b910eab3af099", + "size": 748729, + "subdir": "linux-64", + "timestamp": 1671656454338, + "version": "9.3.0" + }, + "pillow-9.3.0-py39h6a678d5_2.tar.bz2": { + "build": "py39h6a678d5_2", + "build_number": 2, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.9,<3.10.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "92a957598027ddaa32ef02ef6590999a", + "name": "pillow", + "sha256": "1afcd9ec9aa403303b1d77b7c21c15dc70fa92d45b7ec96417706f9f42cefd6f", + "size": 744248, + "subdir": "linux-64", + "timestamp": 1675358328194, + "version": "9.3.0" + }, + "pillow-9.3.0-py39hace64e9_0.tar.bz2": { + "build": "py39hace64e9_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "dade09d7f06446fb761e354d1743c6ee", + "name": "pillow", + "sha256": "05c5073bdf810f2f9c58f930ba17d53911447ace7f03ad28f2ffb280a6cebf70", + "size": 739221, + "subdir": "linux-64", + "timestamp": 1671482866313, + "version": "9.3.0" + }, + "pillow-9.3.0-py39hace64e9_1.tar.bz2": { + "build": "py39hace64e9_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "76d47ddc53a7278917f4e92bcc4944e7", + "name": "pillow", + "sha256": "02e376868e46620af3cb9c8a7b5fedc69b7c5598029213d91c368df2c0e11fe7", + "size": 753061, + "subdir": "linux-64", + "timestamp": 1671656491261, + "version": "9.3.0" + }, + "pillow-9.4.0-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.10,<3.11.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "66b706ed3cc4a9ec0fb78577b659b6a1", + "name": "pillow", + "sha256": "5e026a2cf2d80b29e8bb32d0fe6032cd2dc2a0194f3e4cc09129224efc479436", + "size": 741151, + "subdir": "linux-64", + "timestamp": 1677510429171, + "version": "9.4.0" + }, + "pillow-9.4.0-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.11,<3.12.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "7eae455268113ca397dc0c00853f7320", + "name": "pillow", + "sha256": "398f8bc6f115dba32da80d47fcf64e15832b271a8ec0aeec8737115a98cd6ee9", + "size": 905477, + "subdir": "linux-64", + "timestamp": 1679337355357, + "version": "9.4.0" + }, + "pillow-9.4.0-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.7,<3.8.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "d9e0e2196b4613cb2d1692c062bef2ac", + "name": "pillow", + "sha256": "318e2799c9854515baf21ae634896ac6b73aae7bf9dedfbf7530fcf5fa7ac23f", + "size": 731446, + "subdir": "linux-64", + "timestamp": 1677510384427, + "version": "9.4.0" + }, + "pillow-9.4.0-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.8,<3.9.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "b6d56d0fbf6e4e5fb1b1d01a030f2c7b", + "name": "pillow", + "sha256": "895983bfc24a412ddc25518d70810b5627365fddde12d8ed3c427589a99d5977", + "size": 734034, + "subdir": "linux-64", + "timestamp": 1677510473765, + "version": "9.4.0" + }, + "pillow-9.4.0-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.9,<3.10.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "4a7d592e5bfedf1a17ef56c4d3a31637", + "name": "pillow", + "sha256": "1d77601c747554ed27105a1d9f71aef8e68e06d467440d97633148707facccab", + "size": 738150, + "subdir": "linux-64", + "timestamp": 1677510338846, + "version": "9.4.0" + }, + "pip-10.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "10ed289fbce43e59ec314a7a16e85c7a", + "name": "pip", + "sha256": "50f0c336af0f95e53b1509c5fad7e2f0a57ad79061659d18a1569c519f227114", + "size": 1815804, + "subdir": "linux-64", + "timestamp": 1524226843245, + "version": "10.0.1" + }, + "pip-10.0.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc876f472d0634a72023f2bcace5c567", + "name": "pip", + "sha256": "414e765a6d91054f1de518aec95037461e43a70c3b799de1be7a46dd1d6c6d54", + "size": 1890197, + "subdir": "linux-64", + "timestamp": 1524226856853, + "version": "10.0.1" + }, + "pip-10.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34e8b3a54de3808a0f37ec36b9cda41d", + "name": "pip", + "sha256": "53adf8eff3da63e72137b674e2ee59b49d7b624bfc34794d210ca74a7b4aa55d", + "size": 1877337, + "subdir": "linux-64", + "timestamp": 1524226858887, + "version": "10.0.1" + }, + "pip-10.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f168496fad2470c033314ce19de0c4dc", + "name": "pip", + "sha256": "5bd95d8f2a80eff6e401d77218b90084d0978d6a327fcc87a8877bdbfacd7dd4", + "size": 1808071, + "subdir": "linux-64", + "timestamp": 1530212750848, + "version": "10.0.1" + }, + "pip-18.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4915958b9854062c43b1ea40ac53b1de", + "name": "pip", + "sha256": "175d31deb3572f2986609dd9b1ce2126097f5c10f03e5139ccc54e15b3649d72", + "size": 1871974, + "subdir": "linux-64", + "timestamp": 1541177326945, + "version": "18.1" + }, + "pip-18.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96f92b96b4ba3596ffbdd1e68244a0cb", + "name": "pip", + "sha256": "8024598fa37e2c6ac2d52a5ef11fd8ac5229fb26ae3a63eef7c513b470268dda", + "size": 1888470, + "subdir": "linux-64", + "timestamp": 1541177346323, + "version": "18.1" + }, + "pip-18.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80db5656e6d50a15770304072d15367d", + "name": "pip", + "sha256": "d1d4a2ce1c1f6e1a8661d6181e1c3804dc6cb043fcaf20145b258dd26cdd6d46", + "size": 1818315, + "subdir": "linux-64", + "timestamp": 1541177320708, + "version": "18.1" + }, + "pip-19.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9eb88601ccf0af22e2b7a373f4137f8", + "name": "pip", + "sha256": "a8b0a347610c8150afbcee93c19e341d018f27d52efac9817630d306766a607c", + "size": 1920281, + "subdir": "linux-64", + "timestamp": 1549297898985, + "version": "19.0.1" + }, + "pip-19.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "28eaca5af6cd7ca58175f6511cd73877", + "name": "pip", + "sha256": "e14f097fd5614c12ea8531e3fa4d152f465ff0e6648984b6e7ec98e5b415214a", + "size": 1936024, + "subdir": "linux-64", + "timestamp": 1549297926302, + "version": "19.0.1" + }, + "pip-19.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8faf985c48155de568b9a84f68a45346", + "name": "pip", + "sha256": "09e86c3777d8b209b10bb518c46c3c0337fa76c9cdc91689c9cabbe6a78f4723", + "size": 1861337, + "subdir": "linux-64", + "timestamp": 1549297862788, + "version": "19.0.1" + }, + "pip-19.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "777db651c4f4841d035243d3a1df9fc4", + "name": "pip", + "sha256": "33f4bdb2ef964e0960a146aa852e090f88cd29e702a1a610b1b1a333ebf498ad", + "size": 1930195, + "subdir": "linux-64", + "timestamp": 1551143702790, + "version": "19.0.3" + }, + "pip-19.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a79e54dd00c0531eb7f444505f7f8f1", + "name": "pip", + "sha256": "6d1facc5f9d6398ba3c561c38e0be2984a7122dae86ddcabbfe6e881211c2ceb", + "size": 1969837, + "subdir": "linux-64", + "timestamp": 1551143731304, + "version": "19.0.3" + }, + "pip-19.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3825abb75c5695cac45ad66c5d35d1e9", + "name": "pip", + "sha256": "17158288721464fe8bae6ceb7cdfa6019817e2cca78227ac8766766506cd6502", + "size": 1878035, + "subdir": "linux-64", + "timestamp": 1551143673935, + "version": "19.0.3" + }, + "pip-19.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "661888bd998c8f7214ed3e825e98d825", + "name": "pip", + "sha256": "48f84f85b9ae6ba11a377e4b9faf7b05acbeb1ee2b0e79689cd2c1e489ce2b84", + "size": 1922487, + "subdir": "linux-64", + "timestamp": 1556290044671, + "version": "19.1" + }, + "pip-19.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "043c7d67ab9b4fe69f102d91d302ae4f", + "name": "pip", + "sha256": "1adf4bb33e5ec538ef68698b71cde3e3947666a3698ecfa31a243f4374c912c4", + "size": 1946642, + "subdir": "linux-64", + "timestamp": 1556290127488, + "version": "19.1" + }, + "pip-19.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6dcf6a7340666756fe531d7c47f393ae", + "name": "pip", + "sha256": "7769200ed7e81b532def3806f47caafcac79c8ac56fa843770b32f46c55c1959", + "size": 1881013, + "subdir": "linux-64", + "timestamp": 1556289956939, + "version": "19.1" + }, + "pip-19.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "719b2372b691bea142f2aa55d7ef5dbe", + "name": "pip", + "sha256": "79334112c5d29e61f18b2336caa8aa8cdce3c89cf0bd68873ec79c10b03c26ef", + "size": 1924182, + "subdir": "linux-64", + "timestamp": 1557501831795, + "version": "19.1.1" + }, + "pip-19.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "410916d6443b959e522a7c87c806a9a5", + "name": "pip", + "sha256": "19a57fc2438ad347772402df89006be384f87b6b913b7d1f10d5a2600b50f43c", + "size": 1987589, + "subdir": "linux-64", + "timestamp": 1557501846964, + "version": "19.1.1" + }, + "pip-19.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7d8801e8724e9bef2b874caef3971a92", + "name": "pip", + "sha256": "e88755e30400d1a9145e7e3725859dc308cb5ee5ef3a9e1e8b67262c68b31145", + "size": 1872519, + "subdir": "linux-64", + "timestamp": 1557501803017, + "version": "19.1.1" + }, + "pip-19.2.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eff53d7df1f032d43b931aa404763bba", + "name": "pip", + "sha256": "87e66922280ff6da9d3c9e87f7e50e7deb297a1a045d6085434de98d28dd8aab", + "size": 2005270, + "subdir": "linux-64", + "timestamp": 1565895085184, + "version": "19.2.2" + }, + "pip-19.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d3cb474561813165984faafdcf755d3", + "name": "pip", + "sha256": "3c1e0a314c38fe2482719a91315630092dae74239bcfeda53f7f72c39f75a4ab", + "size": 2004442, + "subdir": "linux-64", + "timestamp": 1565895140527, + "version": "19.2.2" + }, + "pip-19.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6354a2b394347e189d22a22ab3922b51", + "name": "pip", + "sha256": "8505160b92956fe8a0ee9a69a7f792cbbf1982f2f9df1f1c967ba3473b496fb4", + "size": 1982074, + "subdir": "linux-64", + "timestamp": 1565895028559, + "version": "19.2.2" + }, + "pip-19.2.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eeaa45bf90c9ca2920628570fcfcdd06", + "name": "pip", + "sha256": "8d55626b664c919153f736246a0eb6efc73ea0d71c3310d0efea22b6beb49696", + "size": 2028387, + "subdir": "linux-64", + "timestamp": 1569332241670, + "version": "19.2.3" + }, + "pip-19.2.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b56fd4a4ab4ea04eff22dafa673dbf5", + "name": "pip", + "sha256": "fb689e4502763c568756b38b64652a031c36411e2008c8c3533481be0e6f25b6", + "size": 2004310, + "subdir": "linux-64", + "timestamp": 1569332269804, + "version": "19.2.3" + }, + "pip-19.2.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a86d08ddf5544cd00aaa6ccae60c726a", + "name": "pip", + "sha256": "2c6d941a8e37a3206a33e64f7f2a987731b9dd93a588e7ebe8fd0de79e05a896", + "size": 1957318, + "subdir": "linux-64", + "timestamp": 1569332239100, + "version": "19.2.3" + }, + "pip-19.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8303196dd035fc825ca205edebefc0d8", + "name": "pip", + "sha256": "915f082013c7f341d7f871a93eba4c8e7efbd4cdae11173d4dce578a47ef1432", + "size": 1984415, + "subdir": "linux-64", + "timestamp": 1571668699362, + "version": "19.3.1" + }, + "pip-19.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c48c4a6e1c817545c577149a25903bd3", + "name": "pip", + "sha256": "55e3b64cc2dfbc19ac1b180aed4b4cd5506ec7545de89bd9b53463dc20cbed59", + "size": 2001817, + "subdir": "linux-64", + "timestamp": 1571668731567, + "version": "19.3.1" + }, + "pip-19.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "30aeda09c7b0a8e96c908a4b0c0a43c5", + "name": "pip", + "sha256": "8cda30ee6dc3304e00db6598e1466ee7649a21d9d209fc029a54791e49b3cf4b", + "size": 1974789, + "subdir": "linux-64", + "timestamp": 1571668699607, + "version": "19.3.1" + }, + "pip-19.3.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3a608c9809e478b807483bda4b21589", + "name": "pip", + "sha256": "4cc40df8d0c773057e83a0005e30489f6075ed4039276df5b0d92b982225b485", + "size": 1957964, + "subdir": "linux-64", + "timestamp": 1571958776067, + "version": "19.3.1" + }, + "pip-20.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b773d5c6283f1339caed313751438639", + "name": "pip", + "sha256": "8e29651d34de7c1d98b3c4c001959246c0bd64db194344b0e176de1f1f75fac6", + "size": 2024915, + "subdir": "linux-64", + "timestamp": 1580148298627, + "version": "20.0.2" + }, + "pip-20.0.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2130aef1538c46f0ea68384ed6fdc2ca", + "name": "pip", + "sha256": "cb0f8e5ef9a9fa52347f762ef1d1efc46423a4ee42140b5a574c15aa2899f725", + "size": 2024433, + "subdir": "linux-64", + "timestamp": 1580397114520, + "version": "20.0.2" + }, + "pip-20.0.2-py36_3.tar.bz2": { + "build": "py36_3", + "build_number": 3, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f4fd555e3183e424290ef15267b7fd36", + "name": "pip", + "sha256": "71df6c2e72db4879b22ac546f2c20b2f1950f3119999f9166048bf6183123ca6", + "size": 2034100, + "subdir": "linux-64", + "timestamp": 1588890272451, + "version": "20.0.2" + }, + "pip-20.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11a69f42b3a4c106c3df2ae4004679ee", + "name": "pip", + "sha256": "0307e8180077abd970dd4c5edca2ba55968f2489dcf4d3212fdd6c1dfbe1610a", + "size": 1964566, + "subdir": "linux-64", + "timestamp": 1580148260135, + "version": "20.0.2" + }, + "pip-20.0.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c560a9f713166d244a6cfe17365b3174", + "name": "pip", + "sha256": "3693478c9c017e10e047417f7b83ca8fd863511fe8e979574636dabef33d928e", + "size": 1969670, + "subdir": "linux-64", + "timestamp": 1580397126321, + "version": "20.0.2" + }, + "pip-20.0.2-py37_3.tar.bz2": { + "build": "py37_3", + "build_number": 3, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4a2ec10c0a0f5ec23f737adcb1ca428e", + "name": "pip", + "sha256": "4b97a5f7ea65987c741d6994c72c7bb0c49395b42764885b4c3196a7cf904857", + "size": 1969926, + "subdir": "linux-64", + "timestamp": 1588890230766, + "version": "20.0.2" + }, + "pip-20.0.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e869039fbc267341d70e83df1116dd35", + "name": "pip", + "sha256": "24ca50c011c86f341dc3e9329b4b1de32a4477ec790e661fdd407810a283d4b3", + "size": 2001084, + "subdir": "linux-64", + "timestamp": 1580148306521, + "version": "20.0.2" + }, + "pip-20.0.2-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e4690750106678dcce773d583ad71a4", + "name": "pip", + "sha256": "b05986b34f645fec9a9cc7c6f32e4be1a91a6bf39bf5cff14c87f4f9fe94973b", + "size": 1980226, + "subdir": "linux-64", + "timestamp": 1580397180562, + "version": "20.0.2" + }, + "pip-20.0.2-py38_3.tar.bz2": { + "build": "py38_3", + "build_number": 3, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a649ca8f138de7f10de3ee6f78408803", + "name": "pip", + "sha256": "01d878cc465cdeb14b126ffa1756fee394f7853957c9799026572ed9db63728d", + "size": 1977685, + "subdir": "linux-64", + "timestamp": 1588890253231, + "version": "20.0.2" + }, + "pip-20.1.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16335bbcf9b2ad0470ea9738721ffae0", + "name": "pip", + "sha256": "629c9ddbc18bc174831ef014c6c9ba2bf2cf2bd324f769ace75a8a8bdbcdfb08", + "size": 2111908, + "subdir": "linux-64", + "timestamp": 1592322693602, + "version": "20.1.1" + }, + "pip-20.1.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa675d72c5584007513973ded4eb32ae", + "name": "pip", + "sha256": "6f784e87fa3ea9fc9e9ae627841acdcb85042ea3a6681a61aa35c065284e26b3", + "size": 2056076, + "subdir": "linux-64", + "timestamp": 1592322688722, + "version": "20.1.1" + }, + "pip-20.1.1-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2d14778bdf876a6bdebc02817ae99a7", + "name": "pip", + "sha256": "2f0c41b4af433e46b3f061b450b7494725bc5f7a5a007defdbf942d3721ac0e7", + "size": 2040654, + "subdir": "linux-64", + "timestamp": 1592322703559, + "version": "20.1.1" + }, + "pip-20.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b73d86e0715685b39951c4c1de396d91", + "name": "pip", + "sha256": "bfee47ff3e42497927d7ccc3886297fcb69c23647c945945395d02a7824e7384", + "size": 2132853, + "subdir": "linux-64", + "timestamp": 1596834015769, + "version": "20.2.1" + }, + "pip-20.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3754bcc39b14ff71d39a501317ddc7de", + "name": "pip", + "sha256": "ea98d9b51db085d02c201c0009d076e46e3dbb17f17a7fd8d6d6247c2d8bdf69", + "size": 2066675, + "subdir": "linux-64", + "timestamp": 1596834010148, + "version": "20.2.1" + }, + "pip-20.2.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0285e6720d6ae3b46678723699241f45", + "name": "pip", + "sha256": "5b33eddc80659a0c53215426eb896e95e6c3266dbd9fa9a39e409d639430052a", + "size": 2071040, + "subdir": "linux-64", + "timestamp": 1596834007825, + "version": "20.2.1" + }, + "pip-20.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f246bd8103409292962157f8005e72b", + "name": "pip", + "sha256": "7f210082d1b659f183abfe1fabba07725a77836a1b974a088795dd057b27cd6d", + "size": 2144648, + "subdir": "linux-64", + "timestamp": 1597262895015, + "version": "20.2.2" + }, + "pip-20.2.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74f6065799a4b58ce020c223b9bb8a91", + "name": "pip", + "sha256": "214b88c0fd9cf8d873cea026e1c9caf6d685471a524530ac01e2a09a0772b650", + "size": 2135798, + "subdir": "linux-64", + "timestamp": 1604430520304, + "version": "20.2.2" + }, + "pip-20.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd793abb77f288a0264ca5ad5d7ed14c", + "name": "pip", + "sha256": "95f94da557663da244e77ecddb70af99a09f968cc483f0c78bed0aa178383114", + "size": 2091539, + "subdir": "linux-64", + "timestamp": 1597262848633, + "version": "20.2.2" + }, + "pip-20.2.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2cee1491663bb2ee98e702a20e650935", + "name": "pip", + "sha256": "248449fe60b5f7bd1a0977c1ebb7309587d07ad082d9dbc971291e958b2b20b9", + "size": 2064902, + "subdir": "linux-64", + "timestamp": 1604430532351, + "version": "20.2.2" + }, + "pip-20.2.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13ca2627e53324531a3bff6eb20a7dcb", + "name": "pip", + "sha256": "27027a8d93050a135043af1422001c3d803df6e7984eaa77ca34ad945f0785e7", + "size": 2073346, + "subdir": "linux-64", + "timestamp": 1597262890229, + "version": "20.2.2" + }, + "pip-20.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "517ff5bd8193b9e8b4a58de5cf031d42", + "name": "pip", + "sha256": "989d4dfd1643422a93894d46bed7da7c7ab53fd9e3548960bb00585b62cd127c", + "size": 2083670, + "subdir": "linux-64", + "timestamp": 1604430517386, + "version": "20.2.2" + }, + "pip-20.2.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a47268977a8a1c658765003b85450230", + "name": "pip", + "sha256": "93b1ec8db58d79c729f6de2b19f37cc7992064ec463810c28f9b317e98c594bf", + "size": 2082018, + "subdir": "linux-64", + "timestamp": 1604430523247, + "version": "20.2.2" + }, + "pip-20.2.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d773039d28e6d83b25c635e0d0d3951c", + "name": "pip", + "sha256": "c5f8bda616f320a4951d478e0af1caf3784f9238c32bd2a14ae89f7cf5a8de74", + "size": 2127014, + "subdir": "linux-64", + "timestamp": 1601587525402, + "version": "20.2.3" + }, + "pip-20.2.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "439807630df295bac71e135668cbc886", + "name": "pip", + "sha256": "afdad139eab331b9e6eb9f944e5ad7670b11dad0a1bd3163e4ea6e395328e20b", + "size": 2125967, + "subdir": "linux-64", + "timestamp": 1604432556774, + "version": "20.2.3" + }, + "pip-20.2.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2054f3cca49ce4290b0521355196a20f", + "name": "pip", + "sha256": "2fa8115b188e8806fa26c162b668931b9326f87f7f76539c0ab397c2113b4717", + "size": 2083174, + "subdir": "linux-64", + "timestamp": 1601587554748, + "version": "20.2.3" + }, + "pip-20.2.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5eacd6c43689168e113fd7e02b536357", + "name": "pip", + "sha256": "1d365974fe677a218ffeda213c6beaed6199e5b857e45232af715d95a184ff94", + "size": 2079493, + "subdir": "linux-64", + "timestamp": 1604432765288, + "version": "20.2.3" + }, + "pip-20.2.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f60c3b5890cef13a4ed46fd250653be6", + "name": "pip", + "sha256": "cd03b6ce90a299f75595d7fa61827d9b1e830f4c75ef69bd2d705a94e7719727", + "size": 2079175, + "subdir": "linux-64", + "timestamp": 1601587558921, + "version": "20.2.3" + }, + "pip-20.2.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6240b79fdf6812331a39cacc1a999906", + "name": "pip", + "sha256": "4df67738399fe8240eb9f0570af51ddf1097c5c32f4f7186e12886715716fab6", + "size": 2069612, + "subdir": "linux-64", + "timestamp": 1604432791179, + "version": "20.2.3" + }, + "pip-20.2.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16281204bd5468de4b6d3cf88721d75a", + "name": "pip", + "sha256": "2289ee27439caae53d57274c5ae5336e1e5f127744fbccb7d12b12dfa2f4bf12", + "size": 2082489, + "subdir": "linux-64", + "timestamp": 1604432572958, + "version": "20.2.3" + }, + "pip-20.2.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff2b2ff00f2bf75713450650369216c4", + "name": "pip", + "sha256": "60a4f84e457038bed6cf34305a0e83c57c411c6be0a51bd31235339cc1108c8e", + "size": 2110952, + "subdir": "linux-64", + "timestamp": 1603217526804, + "version": "20.2.4" + }, + "pip-20.2.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5ec22e49563c66df68e59cab1c4ef6f", + "name": "pip", + "sha256": "4f353e6b8427da1eb6bbaf8dc3d586df15a44dd2f62a5424ecadef9bc89b4a1d", + "size": 2161805, + "subdir": "linux-64", + "timestamp": 1604432667397, + "version": "20.2.4" + }, + "pip-20.2.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f0726696328d68f9b174d5db1bcfaa4", + "name": "pip", + "sha256": "98f81ceb227633fd3b6094a4c7633a388d4ecd71f902cda05f5617257b74cd9c", + "size": 2055596, + "subdir": "linux-64", + "timestamp": 1603217557609, + "version": "20.2.4" + }, + "pip-20.2.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "440b0b44e4adbc3421a9226afbb65255", + "name": "pip", + "sha256": "3f01eaaea18e30e29728d1d851df07683900c6de4a842c3a8d862e6c257452b4", + "size": 2066726, + "subdir": "linux-64", + "timestamp": 1604432624932, + "version": "20.2.4" + }, + "pip-20.2.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "588d0c83cd74064b6b288df7a32e5fae", + "name": "pip", + "sha256": "190660eb454e2933c39d43522f332c85353afe39d918259374c8ae2029688aa4", + "size": 2074524, + "subdir": "linux-64", + "timestamp": 1603217563508, + "version": "20.2.4" + }, + "pip-20.2.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "245f8a1c06c64686858927538d1edf98", + "name": "pip", + "sha256": "547cdf676db4f57bc166bdcae19bfede1e4264e26882252e23e35dfb610173a3", + "size": 2073016, + "subdir": "linux-64", + "timestamp": 1604432649478, + "version": "20.2.4" + }, + "pip-20.2.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8527cf90e17455a1a4f51efa52c8047", + "name": "pip", + "sha256": "18ce751c22d2f78be3b3ba0189dfaf8af0a9757655c5cbdfc34f47fedc356ff6", + "size": 2068025, + "subdir": "linux-64", + "timestamp": 1604432669174, + "version": "20.2.4" + }, + "pip-20.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b53b8ab72bd817cd920ba0215b2a2fa8", + "name": "pip", + "sha256": "a19d694204fe1d0be43d3df36fafa1729791a99004f05cef56d361f0f4c51bf4", + "size": 2134515, + "subdir": "linux-64", + "timestamp": 1606776240577, + "version": "20.3" + }, + "pip-20.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1121fa9c15eb9a2b19eb5e7dac0418e", + "name": "pip", + "sha256": "03f8b1dfe21d51fbefea18f0d893b42480be539eb516380c3e2cb65b970a41c7", + "size": 2092257, + "subdir": "linux-64", + "timestamp": 1606776218804, + "version": "20.3" + }, + "pip-20.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c6590981ca914705d1284932ee38307", + "name": "pip", + "sha256": "6f4252481bcee53b934ff42be7743da43eb35e7b38e2a7835b468aa98e4f21e5", + "size": 2097188, + "subdir": "linux-64", + "timestamp": 1606776256928, + "version": "20.3" + }, + "pip-20.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4a48789d3098ebbfdb7077d1e80208b", + "name": "pip", + "sha256": "536105548674a0da9471f0fb499b1321f5fefcef845c0c24d83c432359ad7ffe", + "size": 2089073, + "subdir": "linux-64", + "timestamp": 1606776278577, + "version": "20.3" + }, + "pip-20.3.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90de749ae35b0fedc544c914a3970c2f", + "name": "pip", + "sha256": "9cf5c2af2abdaef9f85c2fa984cd3e26f691fc1fd92c6c323f414a3be5145746", + "size": 2145972, + "subdir": "linux-64", + "timestamp": 1607368431017, + "version": "20.3.1" + }, + "pip-20.3.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f135096c876ff5bbb3c7e5c47e51a3cd", + "name": "pip", + "sha256": "270bb53fe40c824f09a9d106e0c4d7aa3519b034ff797aeb4893f0b7cfed9aad", + "size": 2103370, + "subdir": "linux-64", + "timestamp": 1607368436399, + "version": "20.3.1" + }, + "pip-20.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "91b6e1a7583dc49c1c431edc17220dcb", + "name": "pip", + "sha256": "ecf66ec38c9b005d732b06cd7194a570eac71496213824fcaa2f0fa09c5afb1d", + "size": 2090641, + "subdir": "linux-64", + "timestamp": 1607368410638, + "version": "20.3.1" + }, + "pip-20.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "408eef1e0fa048fe5a2a563bfb55452d", + "name": "pip", + "sha256": "f29bbd937eb51b5e9cc962faf4f876f933d3d6229238b34268a261a03a188ab9", + "size": 2093505, + "subdir": "linux-64", + "timestamp": 1607368440154, + "version": "20.3.1" + }, + "pip-20.3.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "65761b36fc424c91ee391a3fe7263641", + "name": "pip", + "sha256": "81711fd0cb209cd0d7319da6ab9e8b4edf88c49a9dbd056b123fc6dc2d634200", + "size": 2147109, + "subdir": "linux-64", + "timestamp": 1608057587060, + "version": "20.3.3" + }, + "pip-20.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6a78fbcd22ef0844c1bc730882b3ec8", + "name": "pip", + "sha256": "beaeba39117332ef278bdaa83dacf57926ce69c93bf01a7d4f223a0a0b686a93", + "size": 2087897, + "subdir": "linux-64", + "timestamp": 1608057597059, + "version": "20.3.3" + }, + "pip-20.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "519b3f4dcc2a98f6054d7fd09326b8eb", + "name": "pip", + "sha256": "f755c88cb61a133f8f247128bd5806c67851ac8e38d0edd51c43c6d7ff89169d", + "size": 2102968, + "subdir": "linux-64", + "timestamp": 1608057593405, + "version": "20.3.3" + }, + "pip-20.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f09809d85abc04f8e517254c1c033f4", + "name": "pip", + "sha256": "efb7c77f560b4ebecc2cf41b06db6af3d4b8892fc92fefca9ea34248c60f6215", + "size": 2103244, + "subdir": "linux-64", + "timestamp": 1608057589642, + "version": "20.3.3" + }, + "pip-21.0.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c7ae4ad5d206c7d86b7fcbdd7ffe720", + "name": "pip", + "sha256": "1185a6d28822a7499f1b4a22bdce5e9cd3bd84587b5c98cd8204709c5f0f66ff", + "size": 2144682, + "subdir": "linux-64", + "timestamp": 1613684917668, + "version": "21.0.1" + }, + "pip-21.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2635b818bf72d998023316c87cb03b2a", + "name": "pip", + "sha256": "7fb9dff8d0b7695aa5b13b2cf3581f0d178583b9d778e284d24776996463f7b3", + "size": 2079482, + "subdir": "linux-64", + "timestamp": 1613685632198, + "version": "21.0.1" + }, + "pip-21.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "afcb24e6b57945056716ca6cde500afd", + "name": "pip", + "sha256": "d51a92191384725d6b85251dd77bcbdfcb2ff4cb27e067c5c6d45413ce71c3f6", + "size": 2089143, + "subdir": "linux-64", + "timestamp": 1613685638502, + "version": "21.0.1" + }, + "pip-21.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c0d46f2f8139a888a71bced5d03a0a3", + "name": "pip", + "sha256": "68a1d7ff3908213494c406d097bf54ec8bd0f46a274f295d895c84c12d6b5f6f", + "size": 2086653, + "subdir": "linux-64", + "timestamp": 1613685627054, + "version": "21.0.1" + }, + "pip-21.1.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "671aa2a61bab2f70fd0efd790837a18a", + "name": "pip", + "sha256": "9704fd15bab2ef31d7d3b483ffd813615fa54a81fcc27bd0e2a74cca51546614", + "size": 2156585, + "subdir": "linux-64", + "timestamp": 1621540043926, + "version": "21.1.1" + }, + "pip-21.1.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "afb894ef96f8353f72c727a9755dd1b8", + "name": "pip", + "sha256": "394862f1efeb9130f48ba71dc12a2833195903abdddae968674d3fc36283f073", + "size": 2103163, + "subdir": "linux-64", + "timestamp": 1621539896415, + "version": "21.1.1" + }, + "pip-21.1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02a5d722537792d038d13640b8312fa9", + "name": "pip", + "sha256": "b3bbf6e618ac1839a6e6dde2a2e35c4162fa5998570a1f3c986105ec9f52429d", + "size": 2105619, + "subdir": "linux-64", + "timestamp": 1621535355834, + "version": "21.1.1" + }, + "pip-21.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c00faa3cbe3523ddd956960c14f9e0b8", + "name": "pip", + "sha256": "d33b27d184b22eb9733df7fb3c9e3b02310fe725a1bfdb26a6ae9bb86cad07e5", + "size": 2114317, + "subdir": "linux-64", + "timestamp": 1621540043503, + "version": "21.1.1" + }, + "pip-21.1.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8e987c211869d434f21c478f5f94eb9", + "name": "pip", + "sha256": "1a9505100c7681bbd1cbe325f3c2a2e4cfdc58d5ced6925540471d08c50f4c34", + "size": 2165295, + "subdir": "linux-64", + "timestamp": 1623077847294, + "version": "21.1.2" + }, + "pip-21.1.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f51b0157395604fca640fb4c5ece586", + "name": "pip", + "sha256": "6b7c7d3f75098bfefff9e7a9f21f2c36d9446a93b7129f958155d015de53ae00", + "size": 2097979, + "subdir": "linux-64", + "timestamp": 1623077853443, + "version": "21.1.2" + }, + "pip-21.1.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bfc9b7a3ee28d405d146bf7a6494033d", + "name": "pip", + "sha256": "46694414f1f80e1225bad764c515852f169810e61025f6de38ab3955337dafd6", + "size": 2127675, + "subdir": "linux-64", + "timestamp": 1623077854746, + "version": "21.1.2" + }, + "pip-21.1.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c19227ff0901d342deea9822f7e9a8eb", + "name": "pip", + "sha256": "77c6c6fd642b68c193cb1cbdea35b63acde988bbfbde7ff48afd9ef334dab9e9", + "size": 2099362, + "subdir": "linux-64", + "timestamp": 1623077799379, + "version": "21.1.2" + }, + "pip-21.1.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ffa50ebfad2aab590348cff27322d32", + "name": "pip", + "sha256": "2afdcd9af7e3054c543aea09e00643aaafdca1dcc8aa5da79901082aa90cca30", + "size": 2165190, + "subdir": "linux-64", + "timestamp": 1624898116904, + "version": "21.1.3" + }, + "pip-21.1.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2dc44b35c3087f329bd86e283e0c9e9a", + "name": "pip", + "sha256": "3c0008764660267397473770b23372789246e820c0f6ad0153392244333cdfd2", + "size": 2102630, + "subdir": "linux-64", + "timestamp": 1624898091371, + "version": "21.1.3" + }, + "pip-21.1.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db682321a819b8aefe5c10de6397a281", + "name": "pip", + "sha256": "4eb873e4c99e5f61edad9001bd09b6d7ffceb44902e6caa0f5250a13bed0e4a2", + "size": 2101365, + "subdir": "linux-64", + "timestamp": 1624898105171, + "version": "21.1.3" + }, + "pip-21.1.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e37ace094c36285bb70f3a7162fdd5ed", + "name": "pip", + "sha256": "e5f1f14cab0816047458ee467aeb8fd66af448c738481a485c35d9cce96c74f3", + "size": 2118325, + "subdir": "linux-64", + "timestamp": 1624898103032, + "version": "21.1.3" + }, + "pip-21.2.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3493ad07cf6101cba17accb34c7ee18b", + "name": "pip", + "sha256": "08a799110044ac4fb0df80936e8113dad3cfd8a6252e1ce76681a4f637dfdfd3", + "size": 2181044, + "subdir": "linux-64", + "timestamp": 1627796648423, + "version": "21.2.2" + }, + "pip-21.2.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ddc02a53153e67560964c0624c31739a", + "name": "pip", + "sha256": "82c6284161114061fd9ee8cb1c76abb754823573624014bde5752b0e10415cb7", + "size": 2126642, + "subdir": "linux-64", + "timestamp": 1627796631586, + "version": "21.2.2" + }, + "pip-21.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c8ed310ccdfa52ff2c2db0596887a2bd", + "name": "pip", + "sha256": "21c9f71f8c9e1556ab7f25117380593567982c6c5b71ac6d80c529d61e8578f6", + "size": 2131469, + "subdir": "linux-64", + "timestamp": 1627796630757, + "version": "21.2.2" + }, + "pip-21.2.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "386c7163cb68b841960727c12be7e040", + "name": "pip", + "sha256": "f15e63f28af219b1a4226dc1930ac294470da48a3bbe8c1c33d442dfe9e5d9bf", + "size": 2138495, + "subdir": "linux-64", + "timestamp": 1627796597623, + "version": "21.2.2" + }, + "pip-21.2.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ebb98b9a53e8329984529aa9600533c", + "name": "pip", + "sha256": "91701de28243b24233897eeb134ec41f29275608f5071677c77d21d7df5c6128", + "size": 2123817, + "subdir": "linux-64", + "timestamp": 1628716206449, + "version": "21.2.3" + }, + "pip-21.2.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4cadf5e4fd9a98e8bc3022db57fa3e13", + "name": "pip", + "sha256": "9d3cff18ffdcc80c1e1ecc1ba23d5a99bc20a4e074575dc466e18235ecdc70bc", + "size": 2124700, + "subdir": "linux-64", + "timestamp": 1628716202684, + "version": "21.2.3" + }, + "pip-21.2.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea94381c3424b8cfae67a3b8345b1ac7", + "name": "pip", + "sha256": "09a558d4368a3e47836624926a6896170f8e685ba3093327ef198327609bef2f", + "size": 2139531, + "subdir": "linux-64", + "timestamp": 1628716200710, + "version": "21.2.3" + }, + "pip-21.2.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12f8b9d78cdada68b5b790910dbe2930", + "name": "pip", + "sha256": "3687cacaeb92ba4815780a7193df07a1e4599bb1c087ce9f2ed2372416ad23e8", + "size": 2144722, + "subdir": "linux-64", + "timestamp": 1628707881908, + "version": "21.2.3" + }, + "pip-21.2.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2adbe96d9f7076f5c093dfc3462202db", + "name": "pip", + "sha256": "29ab504ffa78dc21cc60f04e92735c3e7376cb6569e9a419dcd937638c4516ec", + "size": 2196441, + "subdir": "linux-64", + "timestamp": 1633509621201, + "version": "21.2.4" + }, + "pip-21.2.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a4068bfe877374ce0082a509871509e", + "name": "pip", + "sha256": "8e8cc950d1810a716cdcb1d963d62024d38ffea15d2208bad7687c4618da9978", + "size": 2136977, + "subdir": "linux-64", + "timestamp": 1629205793868, + "version": "21.2.4" + }, + "pip-21.2.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c9c8fcfb9fbf6eabbd71594d798202c", + "name": "pip", + "sha256": "efaa905acae344512a4a22ba72528a25f5bc032b23c9f78999ec84f2a76f0aee", + "size": 2140964, + "subdir": "linux-64", + "timestamp": 1633498705574, + "version": "21.2.4" + }, + "pip-21.2.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1784d8ead44611187bd6455b801f0ac", + "name": "pip", + "sha256": "074904df323637c2b7aca5e63b7aebbc15ffd73d64444a94e3ed1332722f841b", + "size": 2152793, + "subdir": "linux-64", + "timestamp": 1633509590979, + "version": "21.2.4" + }, + "pip-22.1.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "158b148903519dc463af4b58043a5602", + "name": "pip", + "sha256": "07599e9462e03e427b3f91a20dcbf1d822f3f0eab079d2796871cfc38664f058", + "size": 3111242, + "subdir": "linux-64", + "timestamp": 1655220797041, + "version": "22.1.2" + }, + "pip-22.1.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc77c9a4d7f928b276542ab1cd8f3804", + "name": "pip", + "sha256": "9c97c085413b725ed4d1bf1aa7ac101f74d0c6fbe05614e23b85a08c7f980600", + "size": 2992374, + "subdir": "linux-64", + "timestamp": 1655220896199, + "version": "22.1.2" + }, + "pip-22.1.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cff5a4c97132b63337613bd91884aba4", + "name": "pip", + "sha256": "9445d18e2a2a0dd8ab8597af37e7ff15e152439b1c9002a1b76f1ee08f5e1c41", + "size": 3003030, + "subdir": "linux-64", + "timestamp": 1655220829757, + "version": "22.1.2" + }, + "pip-22.1.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b64a88c719bbdac8d60467d4d8c2b0a", + "name": "pip", + "sha256": "45c564a5419a31b64d17316ebf5d88c4cdd52376e23724b77b4e3ae28238559d", + "size": 3005175, + "subdir": "linux-64", + "timestamp": 1655220863056, + "version": "22.1.2" + }, + "pip-22.2.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5daa4f30ddc15713e31d7828ffc93cc9", + "name": "pip", + "sha256": "11a0c53c91e1c444917987cf959dc43a601208cd9369cb8a5a91428338c32041", + "size": 2939742, + "subdir": "linux-64", + "timestamp": 1664552837524, + "version": "22.2.2" + }, + "pip-22.2.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14044799da27e0e23766234033aaa87a", + "name": "pip", + "sha256": "b4b108abb0022a871bf39e0fc0be7b80c9b89d385f6b2d3d7aa15a3a5a91f4a7", + "size": 3600728, + "subdir": "linux-64", + "timestamp": 1669778796770, + "version": "22.2.2" + }, + "pip-22.2.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb4a7c5c1c682831868a5c881cdca081", + "name": "pip", + "sha256": "3a652c551f8912572f608c181180b1654741e43bc0421515c0308d4daabcc71d", + "size": 2840031, + "subdir": "linux-64", + "timestamp": 1664552773764, + "version": "22.2.2" + }, + "pip-22.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ac9f1cfec65a1e4ef00cc0132ecd753", + "name": "pip", + "sha256": "7b392117e68e513794d36ef6bed084fd8cfb703e505c556d2c5f8b152d6e7df7", + "size": 2849993, + "subdir": "linux-64", + "timestamp": 1664552878795, + "version": "22.2.2" + }, + "pip-22.2.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02ba8af5f151b7c026987be70c9813a3", + "name": "pip", + "sha256": "c0b03b5b6de6860e2e5ac03acdbc3b13a31b0da5df21421d27cd162ec3a93e45", + "size": 2854256, + "subdir": "linux-64", + "timestamp": 1664552732381, + "version": "22.2.2" + }, + "pip-22.3.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff0aaaab309703192db843844a7e5ea5", + "name": "pip", + "sha256": "63af4f4d8bc264fdf0a48b1baa3bb39af18504081b468c117365ebfa5e78dd54", + "size": 2940429, + "subdir": "linux-64", + "timestamp": 1670597508832, + "version": "22.3.1" + }, + "pip-22.3.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95e619743026cb485abd4faf7dc1b6c4", + "name": "pip", + "sha256": "efeff5e88f9703f8ee3b96052d9a4498e41857af79222a841808e1cd02feeb82", + "size": 3587286, + "subdir": "linux-64", + "timestamp": 1676822509382, + "version": "22.3.1" + }, + "pip-22.3.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1341d21f92261566849402d345a3d504", + "name": "pip", + "sha256": "776c3853b229929d42367c7d12dea72b98436ec8b131f9510936b583accbdfb7", + "size": 2798823, + "subdir": "linux-64", + "timestamp": 1670597444069, + "version": "22.3.1" + }, + "pip-22.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e2330aabf72c6dd993ebce67a5a07f5f", + "name": "pip", + "sha256": "c4198ee713536b97d32779c64ef3d2cd6121a3b81238d4bc821fa0ac03f989e3", + "size": 2814956, + "subdir": "linux-64", + "timestamp": 1670597539231, + "version": "22.3.1" + }, + "pip-22.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a64f49eb18dac373847bc9dd04b27f56", + "name": "pip", + "sha256": "e99dc358f2e6d7a1ec8f37534e707f8c968a609f343ca39097205145d50b9923", + "size": 2827538, + "subdir": "linux-64", + "timestamp": 1670597477663, + "version": "22.3.1" + }, + "pip-23.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95e9e68787b0389b3d57a48fe8de068c", + "name": "pip", + "sha256": "bd17d36697e468d3f0b8e2d6a4e65f817d68c4a45ca2568e85c57fedc501d51c", + "size": 2676291, + "subdir": "linux-64", + "timestamp": 1678181441092, + "version": "23.0.1" + }, + "pip-23.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3965130f0d23107caa1c637dfc3376f", + "name": "pip", + "sha256": "38ce8990f0d74940db6b9c6033c76ce8147746fe66a890285c4aff85fe3763f2", + "size": 3354826, + "subdir": "linux-64", + "timestamp": 1679337383184, + "version": "23.0.1" + }, + "pip-23.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd1a66cdf0809721b2d36378798d50d5", + "name": "pip", + "sha256": "afc0537865679b584afda3f8ed7cbdbf71fb840511daf438346ed422fd47b6b8", + "size": 2582092, + "subdir": "linux-64", + "timestamp": 1678181371709, + "version": "23.0.1" + }, + "pip-23.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec3cf7da6d2418054439102129f4c83d", + "name": "pip", + "sha256": "22e7b04bb4a2c9145f5f453f0b2962031a8f50a6b556eb1279a525e305fea8ab", + "size": 2587693, + "subdir": "linux-64", + "timestamp": 1678181406206, + "version": "23.0.1" + }, + "pip-9.0.1-py27_5.tar.bz2": { + "build": "py27_5", + "build_number": 5, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7febf94e94ebcbfa17a2bee59f35fa73", + "name": "pip", + "sha256": "cc78e847f59f99ba6e75020c02df144c2015a656d5f70126ed14ed4c733e5eaf", + "size": 2356125, + "subdir": "linux-64", + "timestamp": 1519845766230, + "version": "9.0.1" + }, + "pip-9.0.1-py27h4c18a59_2.tar.bz2": { + "build": "py27h4c18a59_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d71cde7747894237dfc60c7b35bc616f", + "name": "pip", + "sha256": "627e34e445254ba829c96b72b99abe4b9e7cc9ffa16115125463f195be494b9b", + "size": 1743005, + "subdir": "linux-64", + "timestamp": 1505671923748, + "version": "9.0.1" + }, + "pip-9.0.1-py27ha730c48_4.tar.bz2": { + "build": "py27ha730c48_4", + "build_number": 4, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c41de7482caf1f71da40015126371a11", + "name": "pip", + "sha256": "c6f2f7a80a8a0ca00f267cfc67adfee42a67b44b501ace798051f1812492cf3e", + "size": 2354655, + "subdir": "linux-64", + "timestamp": 1509124762500, + "version": "9.0.1" + }, + "pip-9.0.1-py27hbf658b2_3.tar.bz2": { + "build": "py27hbf658b2_3", + "build_number": 3, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7701febf3d0b89305ee3b8215bceea36", + "name": "pip", + "sha256": "8ce6702f416edd83c3ccc319c9d7747e6133890c0ac10c03d94f2577bf76f4bb", + "size": 1745487, + "subdir": "linux-64", + "timestamp": 1506357742693, + "version": "9.0.1" + }, + "pip-9.0.1-py35_5.tar.bz2": { + "build": "py35_5", + "build_number": 5, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c13253cd2c6c58a02a1fc4ff4ed4e365", + "name": "pip", + "sha256": "79f6a33d6df05d9e6bc344e6f2e87a323597de7361e353e376807b5a062809f0", + "size": 2279200, + "subdir": "linux-64", + "timestamp": 1519845811319, + "version": "9.0.1" + }, + "pip-9.0.1-py35h7e7da9d_4.tar.bz2": { + "build": "py35h7e7da9d_4", + "build_number": 4, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3051d1c568c2b0545a21e49788f7986d", + "name": "pip", + "sha256": "570bfd320e7182b1618c3c6afd2397a8823c8d594df36f039f5db57f38c7fd9a", + "size": 2279601, + "subdir": "linux-64", + "timestamp": 1509124771925, + "version": "9.0.1" + }, + "pip-9.0.1-py35haa8ec2a_3.tar.bz2": { + "build": "py35haa8ec2a_3", + "build_number": 3, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb3b2c3b2ab45d955a4587b10cc0accc", + "name": "pip", + "sha256": "549454e10121a4743efff5fe020d31551afe95ef370c8f4c2ab8e21a0426465e", + "size": 1776324, + "subdir": "linux-64", + "timestamp": 1506357769885, + "version": "9.0.1" + }, + "pip-9.0.1-py35he1b8d41_2.tar.bz2": { + "build": "py35he1b8d41_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d5e58e8f8ff52b6b27a232a28aa9073b", + "name": "pip", + "sha256": "4039b0158c8f2194025943134dfc8cd1dca0d8c151c06e2f05a51e263f8ee254", + "size": 1775911, + "subdir": "linux-64", + "timestamp": 1505671952867, + "version": "9.0.1" + }, + "pip-9.0.1-py36_5.tar.bz2": { + "build": "py36_5", + "build_number": 5, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "685d3becb8c8c0c1ffb66d5bb9e2a752", + "name": "pip", + "sha256": "a15c6b5e43be76f12e2a5d6d2dea4ffe419cb29a0ffecfee0229fb16dea6b9eb", + "size": 2294051, + "subdir": "linux-64", + "timestamp": 1519845805656, + "version": "9.0.1" + }, + "pip-9.0.1-py36h30f8307_2.tar.bz2": { + "build": "py36h30f8307_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "89f4c9f104dc57b6b1802803c6deb226", + "name": "pip", + "sha256": "d3a58544719bd21d859bb7a1aa382036e5545cc71c2baea0c17e136ba1072f9e", + "size": 1751838, + "subdir": "linux-64", + "timestamp": 1505671982188, + "version": "9.0.1" + }, + "pip-9.0.1-py36h6c6f9ce_4.tar.bz2": { + "build": "py36h6c6f9ce_4", + "build_number": 4, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8633ce8966cace06b656398873529a4d", + "name": "pip", + "sha256": "183cbba62fdbb0e04c8aed82fa830e5475a4dffdc6e0c05d5b781f7f5c83df6f", + "size": 2291514, + "subdir": "linux-64", + "timestamp": 1509124780144, + "version": "9.0.1" + }, + "pip-9.0.1-py36h8ec8b28_3.tar.bz2": { + "build": "py36h8ec8b28_3", + "build_number": 3, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "54e8e805953b255bce3d44cad92924af", + "name": "pip", + "sha256": "8e5c2f1fc8abafe7c04331499f4d4336ee49025339eabca020509bbc1137bbb0", + "size": 1754976, + "subdir": "linux-64", + "timestamp": 1506357774387, + "version": "9.0.1" + }, + "pip-9.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ac8d19949254503e4a0bc0a2ca4af84f", + "name": "pip", + "sha256": "6484f609601229c44212c88a1602787385f1a378d4bc160fffedc2d0a9e75526", + "size": 2502121, + "subdir": "linux-64", + "timestamp": 1522444269703, + "version": "9.0.3" + }, + "pip-9.0.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80fcd5eda8aef8489460bd51d9a95476", + "name": "pip", + "sha256": "631df3fb3eb2d09cdf1a687791384ba28a08746d324d1dbb225957a3b0180fb1", + "size": 2433314, + "subdir": "linux-64", + "timestamp": 1522444297467, + "version": "9.0.3" + }, + "pip-9.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d96c6b8b4a5f2fe1e856b6b7a18c4887", + "name": "pip", + "sha256": "50eb626cb3ff8eac94b48a527f013b7d4270ede9ba40b58ecd489d32b74708fc", + "size": 2397012, + "subdir": "linux-64", + "timestamp": 1522444316409, + "version": "9.0.3" + }, + "pipenv-2022.7.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "pip >=22.0.4", + "python >=3.10,<3.11.0a0", + "setuptools >=36.2.1", + "virtualenv", + "virtualenv-clone >=0.2.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8990b327ab68596ecb177fc02017298f", + "name": "pipenv", + "sha256": "e842b3af9cfce73dcd6f2763dd7d8c196a450ebb024e905e50ed6f13b0e06752", + "size": 5030911, + "subdir": "linux-64", + "timestamp": 1657899500849, + "version": "2022.7.4" + }, + "pipenv-2022.7.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "pip >=22.0.4", + "python >=3.11,<3.12.0a0", + "setuptools >=36.2.1", + "virtualenv", + "virtualenv-clone >=0.2.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51a54ee94f25431e4976b8adcba3e127", + "name": "pipenv", + "sha256": "db9c5f77ee4c8022daf0971f19114af125469169f3ad033899d0c5af17ce55a1", + "size": 6449746, + "subdir": "linux-64", + "timestamp": 1676845191963, + "version": "2022.7.4" + }, + "pipenv-2022.7.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "pip >=22.0.4", + "python >=3.7,<3.8.0a0", + "setuptools >=36.2.1", + "virtualenv", + "virtualenv-clone >=0.2.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ffc355175f6a596f31c55feca8bcca46", + "name": "pipenv", + "sha256": "1c076b34c184dc7e8f0711b186ff2c9488d75464eaa28f99ad339def4de8ccfc", + "size": 4966649, + "subdir": "linux-64", + "timestamp": 1657899253227, + "version": "2022.7.4" + }, + "pipenv-2022.7.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "pip >=22.0.4", + "python >=3.8,<3.9.0a0", + "setuptools >=36.2.1", + "virtualenv", + "virtualenv-clone >=0.2.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e79048597a479c78b01d64023341999b", + "name": "pipenv", + "sha256": "f4cdbd7ab2fd81463daea82186c7778a2df4797dbd6ffc3d4f7dad3bd1d82297", + "size": 4993161, + "subdir": "linux-64", + "timestamp": 1657899146628, + "version": "2022.7.4" + }, + "pipenv-2022.7.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "pip >=22.0.4", + "python >=3.9,<3.10.0a0", + "setuptools >=36.2.1", + "virtualenv", + "virtualenv-clone >=0.2.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "513e63efd0a2b3ede25bc097f62beba3", + "name": "pipenv", + "sha256": "b41c53bd3c6064e87965e8794e8a0dd3cf2faddcf4d7e97b934115c4f8b21be9", + "size": 4994969, + "subdir": "linux-64", + "timestamp": 1657899359700, + "version": "2022.7.4" + }, + "pivottablejs-0.9.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "9a01a9b25e7ca25d33934956ffeb6ecb", + "name": "pivottablejs", + "sha256": "7c9a998025d35308a6945eec7a587d7b94d54bf71c50bdf004cb8efdf640326d", + "size": 7504, + "subdir": "linux-64", + "timestamp": 1519198348354, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "e51711d435b9be07e8b3add0ce13b1d4", + "name": "pivottablejs", + "sha256": "b1a1182e5cdedea0df1335454f13b0dbc2757a8c1b1620f7768cd75991b21c8b", + "size": 7760, + "subdir": "linux-64", + "timestamp": 1640812675303, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "fad278cb864916fc81b11c02e4b1c8c7", + "name": "pivottablejs", + "sha256": "ac59919bab103aad2326159d17a5b0e88969884e2402299d49eafda408bbaed2", + "size": 8459, + "subdir": "linux-64", + "timestamp": 1676907445871, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "372dd795a7cee642964dac9fcc9ae1f3", + "name": "pivottablejs", + "sha256": "24006f24aa83350f92170fdd9fbd09eb0ba9041f5f3f1a6179f4b0ccb1246426", + "size": 7532, + "subdir": "linux-64", + "timestamp": 1519198371825, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "cfe5900e5a487b8d6f080605d8502b89", + "name": "pivottablejs", + "sha256": "9f9f8e3613148f9d5d7e6c4fcc93078fe143f1219f7a161c4c0c300ecabf61c0", + "size": 7550, + "subdir": "linux-64", + "timestamp": 1519198333222, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "5c534f28fe5f27eed2773d7e1780597f", + "name": "pivottablejs", + "sha256": "a2ca2559cf55c38645c11bde13b041bbb9895ff698cc03dc1745a4d826f54e71", + "size": 227891, + "subdir": "linux-64", + "timestamp": 1614011670321, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "9e73f9b29914cef373e5f9713ad9d358", + "name": "pivottablejs", + "sha256": "67bb62ed5366fa2f36a5a0aeef3553f9589f56a660f9e3121fdc514c8957bbc7", + "size": 7505, + "subdir": "linux-64", + "timestamp": 1530905184520, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "3bcd34574c4a2e03b2bc0e29df867118", + "name": "pivottablejs", + "sha256": "41a1ee790f1f77d5cde67315a418345a8fdb3ff298aa8f9147ed26952a8ec981", + "size": 227506, + "subdir": "linux-64", + "timestamp": 1614011461083, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "76a7ce84b56745f28a61fda0c352ac25", + "name": "pivottablejs", + "sha256": "c428460160ba25a484cc6fa5ac4d75dd3bfda531c88b860b2dfada14d503ec90", + "size": 7914, + "subdir": "linux-64", + "timestamp": 1574235848226, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "96dfa35c7a93cd64681253689f0a5b7d", + "name": "pivottablejs", + "sha256": "70243f00353591df13308b2a6a1b3d70d6d8608ac3f6d1c58a1f43f173d6fcc6", + "size": 228286, + "subdir": "linux-64", + "timestamp": 1614011674570, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "5494b97153c1ebc6a3c1253b742392d2", + "name": "pivottablejs", + "sha256": "2108c9ab56f19eacbb0339ef345e0d35f12c6f9dded44b1421c2bf79b9a3334f", + "size": 228482, + "subdir": "linux-64", + "timestamp": 1614011467121, + "version": "0.9.0" + }, + "pivottablejs-airgap-2.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "58627fb2877298ddd9fb8baa0fd66a95", + "name": "pivottablejs-airgap", + "sha256": "5fe7f3ac6c97404b6ba6f04b037929b71ac21e58cae166c3c4b80570bd59d833", + "size": 278103, + "subdir": "linux-64", + "timestamp": 1519194992067, + "version": "2.1.0" + }, + "pivottablejs-airgap-2.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "96bf139c056b4c35292bd3d2d39419f0", + "name": "pivottablejs-airgap", + "sha256": "2f5175b6e92b80d1318dedee42035989c2c5460c1c97fbc8b32a38d00a981fdd", + "size": 278198, + "subdir": "linux-64", + "timestamp": 1519195005735, + "version": "2.1.0" + }, + "pivottablejs-airgap-2.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0289b41ca4ac20f2b9df89cd34bc0a91", + "name": "pivottablejs-airgap", + "sha256": "123d69c627e96a5a84518824ef8aadaa2d62e59ce328c2dbb2186e281b25420f", + "size": 278119, + "subdir": "linux-64", + "timestamp": 1519195095409, + "version": "2.1.0" + }, + "pivottablejs-airgap-2.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d1758bd459a9080a3243379ac4c7beaf", + "name": "pivottablejs-airgap", + "sha256": "af6cd152a8458e9dafbc7472a7ddc61a68a14f441233fc81ed3ba82f1ce4b83b", + "size": 301163, + "subdir": "linux-64", + "timestamp": 1519199258557, + "version": "2.7.0" + }, + "pivottablejs-airgap-2.7.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "141f8fae85dd621d7f2ea5ee0dc01423", + "name": "pivottablejs-airgap", + "sha256": "e9b736df9d2bd957269183c387930b026cf28094e75b1f4f4595d439319ef063", + "size": 312828, + "subdir": "linux-64", + "timestamp": 1640815436937, + "version": "2.7.0" + }, + "pivottablejs-airgap-2.7.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "218ef3c6ca224d0c1964e729c317c43e", + "name": "pivottablejs-airgap", + "sha256": "64bdcb2f4b678f07d35d49fa47f81af3c8d1c6305d3e8011dd0d813ce2143a75", + "size": 301317, + "subdir": "linux-64", + "timestamp": 1519199273714, + "version": "2.7.0" + }, + "pivottablejs-airgap-2.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1ccbbb6144e677ef2c0e59366b7ad6d9", + "name": "pivottablejs-airgap", + "sha256": "d7b4716a7785948910a51ce82d096a345675a82afd63b7259b75db39861e987d", + "size": 301828, + "subdir": "linux-64", + "timestamp": 1519199249503, + "version": "2.7.0" + }, + "pivottablejs-airgap-2.7.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d82c4055648c283adb5e4200bbdbe5ee", + "name": "pivottablejs-airgap", + "sha256": "7c1e8882145b1b098291aab283e378dc621ad6e6443ad6b95a0ea04fe80fb1cb", + "size": 533741, + "subdir": "linux-64", + "timestamp": 1614013206011, + "version": "2.7.0" + }, + "pivottablejs-airgap-2.7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "869c41b40a1ebb04651632008c769df4", + "name": "pivottablejs-airgap", + "sha256": "d4a257ed7eccb4986e858a0778e3712de7bf95e3d24f42a04f49d98bb3ed0bd0", + "size": 301747, + "subdir": "linux-64", + "timestamp": 1530905219425, + "version": "2.7.0" + }, + "pivottablejs-airgap-2.7.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ec9f24ee15b69e72e1c4becb2e8d7e77", + "name": "pivottablejs-airgap", + "sha256": "306270f36d9d55877ce44194df2f75ff6f6b613a7de5a1a2b85f5672f0416cff", + "size": 522189, + "subdir": "linux-64", + "timestamp": 1614014090644, + "version": "2.7.0" + }, + "pivottablejs-airgap-2.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "e1c70ef31a1327775c3afe99a65b2dce", + "name": "pivottablejs-airgap", + "sha256": "a0955070ec7aa9612b46ef9005f1c0d849c26dbf5eeb4c7030d084d8a11d7be4", + "size": 525154, + "subdir": "linux-64", + "timestamp": 1614014096991, + "version": "2.7.0" + }, + "pivottablejs-airgap-2.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "ebaf78322f3efbafdc521a1155716962", + "name": "pivottablejs-airgap", + "sha256": "c8d7cd3ec3b45da880d3b1e864f2ce16d84c8fa0852a8585afad40f24f357b37", + "size": 535576, + "subdir": "linux-64", + "timestamp": 1614013651239, + "version": "2.7.0" + }, + "pixman-0.34.0-h83dc358_2.tar.bz2": { + "build": "h83dc358_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "4b4a55572b6b425c69158382019a94a5", + "name": "pixman", + "sha256": "7db69aaf6d26cd68459b890059a611dc2c96b0e5c5a613efad5cb2e021c38fcc", + "size": 611807, + "subdir": "linux-64", + "timestamp": 1507907681204, + "version": "0.34.0" + }, + "pixman-0.34.0-ha72d70b_1.tar.bz2": { + "build": "ha72d70b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "d9ef0d50b7fce4034b41b5cac4b536a7", + "name": "pixman", + "sha256": "23335ba3faf1cb6ca4e09973961d6c6ee44b59c14d11c6409b132de5d2c8828c", + "size": 610932, + "subdir": "linux-64", + "timestamp": 1505741726054, + "version": "0.34.0" + }, + "pixman-0.34.0-hceecf20_3.tar.bz2": { + "build": "hceecf20_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "050defa45c191c108fca9cb82f251461", + "name": "pixman", + "sha256": "9758ea0a03fde34432afcb546a87325bfe58a0544c99809e6642a9cd435ca1db", + "size": 611869, + "subdir": "linux-64", + "timestamp": 1510175761788, + "version": "0.34.0" + }, + "pixman-0.36.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "md5": "d101473e2188b3bdcf5ee5f956d09f07", + "name": "pixman", + "sha256": "ee6f0d71d646b7e5431dc7943ae8e96c40d10c8a4e66a7186e8bb8d165d0c355", + "size": 628497, + "subdir": "linux-64", + "timestamp": 1547245646019, + "version": "0.36.0" + }, + "pixman-0.38.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "md5": "6978159e1f1d00fec8e86612370af212", + "name": "pixman", + "sha256": "63a59bbf5d33a2428a5976cde4600c31809506ae97ecc8006c953362fdb73bcd", + "size": 632614, + "subdir": "linux-64", + "timestamp": 1552420972972, + "version": "0.38.0" + }, + "pixman-0.40.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "md5": "bb906197b503ff0389a830bb828b7651", + "name": "pixman", + "sha256": "6002c5ea41e875be16aee45ffdd6cadb08caf315454e05e43d79cf27b0d8017e", + "size": 642711, + "subdir": "linux-64", + "timestamp": 1592924281332, + "version": "0.40.0" + }, + "pixman-0.40.0-h7f8727e_0.tar.bz2": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "MIT", + "md5": "59467d7f0ee1d544980d97e649042f6e", + "name": "pixman", + "sha256": "4afa72ae457df9b6b0dac69b86875d35d0f60f2c7e1d5457b0fca7d4334fc2aa", + "size": 632666, + "subdir": "linux-64", + "timestamp": 1632408724146, + "version": "0.40.0" + }, + "pixman-0.40.0-h7f8727e_1.tar.bz2": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "MIT", + "md5": "c197093127a4cca3bb3227aab1a68573", + "name": "pixman", + "sha256": "e0f6c86339e683ea9e3f7e4ce743df653103209aedf995b5e674c148cb349ed8", + "size": 645031, + "subdir": "linux-64", + "timestamp": 1632711422664, + "version": "0.40.0" + }, + "pkg-config-0.29.2-h1bed415_7.tar.bz2": { + "build": "h1bed415_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 2", + "md5": "68860ee02ba7ba1b661cb0a5363ff8cf", + "name": "pkg-config", + "sha256": "d5ce672407c77ef24cefd4fb69d3fb3b336a3f33007e63090cbea368faef3bca", + "size": 438141, + "subdir": "linux-64", + "timestamp": 1516189720680, + "version": "0.29.2" + }, + "pkg-config-0.29.2-h1bed415_8.tar.bz2": { + "build": "h1bed415_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 2", + "md5": "b3165258ae86c7e235a8a171eda1c0a9", + "name": "pkg-config", + "sha256": "470ccf2c99fb9333414da5fd284920a8a0225d686cbbf5ed3248bfcbd842e57e", + "size": 279466, + "subdir": "linux-64", + "timestamp": 1523306120929, + "version": "0.29.2" + }, + "pkg-config-0.29.2-h4878432_4.tar.bz2": { + "build": "h4878432_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 2", + "md5": "b21d272f5f6b8a81fb221fa9997a955d", + "name": "pkg-config", + "sha256": "1c8bdd342375fd7407564d877e408fef8abb24a248f15a22e283b381d122bfe7", + "size": 436158, + "subdir": "linux-64", + "timestamp": 1505666393261, + "version": "0.29.2" + }, + "pkg-config-0.29.2-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2", + "md5": "6b73ef67c98295a22b89fdfff78177e0", + "name": "pkg-config", + "sha256": "7ebce6dc3c6d596f79a21ba1e11580f48413f2a6535e88b0fb14f93d90bf7ef0", + "size": 131924, + "subdir": "linux-64", + "timestamp": 1596130841706, + "version": "0.29.2" + }, + "pkg-config-0.29.2-he821fa1_6.tar.bz2": { + "build": "he821fa1_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 2", + "md5": "20160cf3cccc477bbb95bc557d65881a", + "name": "pkg-config", + "sha256": "c6f3a19006b8cdb25601c7fca26f7ce49ec5985464be234fe47880d810374892", + "size": 438121, + "subdir": "linux-64", + "timestamp": 1511643221202, + "version": "0.29.2" + }, + "pkg-config-0.29.2-hf7364cd_5.tar.bz2": { + "build": "hf7364cd_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 2", + "md5": "5fd4437cd9f2bc9cc463361dcd2755ee", + "name": "pkg-config", + "sha256": "ecc28559d5a0075dfa43c02b76237ab304455ca57d38cdd987b4af37ab72ddaa", + "size": 437542, + "subdir": "linux-64", + "timestamp": 1507907493288, + "version": "0.29.2" + }, + "pkgconfig-1.2.2-py27h48ab9b6_1.tar.bz2": { + "build": "py27h48ab9b6_1", + "build_number": 1, + "depends": [ + "pkg-config", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2e23638983f101b37ebcb700dbac576", + "name": "pkgconfig", + "sha256": "88b30058095b472deb1eda6220c510f29f75b2dce4522764273289032b869cec", + "size": 9267, + "subdir": "linux-64", + "timestamp": 1505732162964, + "version": "1.2.2" + }, + "pkgconfig-1.2.2-py35hd3dfabb_1.tar.bz2": { + "build": "py35hd3dfabb_1", + "build_number": 1, + "depends": [ + "pkg-config", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "076ad5e983a6e9dfbf590e2d6813df44", + "name": "pkgconfig", + "sha256": "81df5d3ad32f2a6b2c7f307bfa6c9f5b6e5d85c29ed078333034fa1bc7e20538", + "size": 9520, + "subdir": "linux-64", + "timestamp": 1505732173915, + "version": "1.2.2" + }, + "pkgconfig-1.2.2-py36h08d3f6d_1.tar.bz2": { + "build": "py36h08d3f6d_1", + "build_number": 1, + "depends": [ + "pkg-config", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe1094d9672b806d589b56b02b661359", + "name": "pkgconfig", + "sha256": "ed50794c09ddb56c2bbc4f7010ff4343320fd324d6a319bca9aba7f89dbd2ea4", + "size": 9487, + "subdir": "linux-64", + "timestamp": 1505732184986, + "version": "1.2.2" + }, + "pkgconfig-1.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5f8f0054a9f3229e796a23030900275", + "name": "pkgconfig", + "sha256": "aba5d086412154ab4c457f892c359e74d56676072586ff699d52082ad38b6fee", + "size": 10359, + "subdir": "linux-64", + "timestamp": 1522192646457, + "version": "1.3.1" + }, + "pkgconfig-1.3.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6feb58070976d1912dde1b59ec606b0d", + "name": "pkgconfig", + "sha256": "7833a9e8706ad44513c785c6d3e011a6974b79d70b2911acd89782f373f0c288", + "size": 10549, + "subdir": "linux-64", + "timestamp": 1522192720375, + "version": "1.3.1" + }, + "pkgconfig-1.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37a50502bfafa9ca23a50ef5e07c524e", + "name": "pkgconfig", + "sha256": "36036b89fa895c8479541e8ec621b6f995d702583f25c8865bcd27b1ef1feea9", + "size": 10480, + "subdir": "linux-64", + "timestamp": 1522192721840, + "version": "1.3.1" + }, + "pkgconfig-1.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e04f7e0d4b20c765c69042df4f799f5", + "name": "pkgconfig", + "sha256": "81c7a1058cb4b59c2b32b7ffc8953f6dcc201a7a30f6e9fb90182c5365c15274", + "size": 10692, + "subdir": "linux-64", + "timestamp": 1530770962237, + "version": "1.3.1" + }, + "pkgconfig-1.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e2e42d40f95244382d99d94e4185375", + "name": "pkgconfig", + "sha256": "56f47863edae3c6d5bfb8842511acdfe257c915f11b31b954bf05f1a3a14ccae", + "size": 10995, + "subdir": "linux-64", + "timestamp": 1536262689439, + "version": "1.4.0" + }, + "pkgconfig-1.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c319e41857a075da6c475c1b17061cc", + "name": "pkgconfig", + "sha256": "91d88f0e99037d7c2366f86c9396b4becf90c244ca1958b4506b2f41018ad58b", + "size": 11205, + "subdir": "linux-64", + "timestamp": 1536262734216, + "version": "1.4.0" + }, + "pkgconfig-1.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ae88d9c3be3007b599a7477c549aa444", + "name": "pkgconfig", + "sha256": "9f2d8875f997ebe2f7d7a71eeb3ab396ec1469c7424d3bf4c8406c6203434f0a", + "size": 11188, + "subdir": "linux-64", + "timestamp": 1536262615889, + "version": "1.4.0" + }, + "pkgconfig-1.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9d1c100e91b52deb14e255ee065be64", + "name": "pkgconfig", + "sha256": "3595521ef8a949fa5c80f364d436c05aecf77f73e5326e931754b73e7f0ab4b0", + "size": 11184, + "subdir": "linux-64", + "timestamp": 1536262768462, + "version": "1.4.0" + }, + "pkgconfig-1.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ed91dfcfc41158704e0b95cdbc9bc54", + "name": "pkgconfig", + "sha256": "f26b03afcf612b6701c1f52a48e281ae5dbc4716d6c78697a135970b2043f9f2", + "size": 11860, + "subdir": "linux-64", + "timestamp": 1573489557510, + "version": "1.4.0" + }, + "pkgconfig-1.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "581d4adc85ef799429d85a021041bc88", + "name": "pkgconfig", + "sha256": "04899544f82573f7b32d575a35198f78a756e8d8eb9ece3b7bbb5df5ee627311", + "size": 13583, + "subdir": "linux-64", + "timestamp": 1607465348836, + "version": "1.4.0" + }, + "pkgconfig-1.5.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9037e5e19829b72bafb679d606e1f5e", + "name": "pkgconfig", + "sha256": "45fbe76e93744274e6adf81ce6bbb0e1abb6bc2f93051ce7affeece6310a86a5", + "size": 13263, + "subdir": "linux-64", + "timestamp": 1613764525145, + "version": "1.5.2" + }, + "pkgconfig-1.5.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08599f166a59c72fc342c26618e40aa7", + "name": "pkgconfig", + "sha256": "9182ee265f99343615d3c55432bfb5c9115fe6015a42fd702cca9951c132c6a5", + "size": 13257, + "subdir": "linux-64", + "timestamp": 1613763741175, + "version": "1.5.2" + }, + "pkgconfig-1.5.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aab3c63e619e1623e1f5c0bf1ed2d7e7", + "name": "pkgconfig", + "sha256": "e5930361dec03652b1f2ea4122cf699efc26bfd723e15ec59203bbf3fb59ecae", + "size": 13302, + "subdir": "linux-64", + "timestamp": 1613764531926, + "version": "1.5.2" + }, + "pkgconfig-1.5.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "36fcea5d039d042e2761002fccaa4049", + "name": "pkgconfig", + "sha256": "3e6305e9e56843a4d680912daf93577583697529e0aff175001cb386e90f9bdb", + "size": 13913, + "subdir": "linux-64", + "timestamp": 1640887309137, + "version": "1.5.4" + }, + "pkgconfig-1.5.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "59a9bc5e12f6741609dc8dd62c2264f6", + "name": "pkgconfig", + "sha256": "f5bfa418d6b3208fdaef122f768f9050282fc23e4675ecec11a0f9e9bf7cfaf2", + "size": 16615, + "subdir": "linux-64", + "timestamp": 1676903868004, + "version": "1.5.4" + }, + "pkgconfig-1.5.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1a6023879d88e26ef4eca9b68d2235c", + "name": "pkgconfig", + "sha256": "ec22025856d052a4b5de662306a903c1ada26c1a12eaef4684c85cd7d11f331c", + "size": 13729, + "subdir": "linux-64", + "timestamp": 1623158605892, + "version": "1.5.4" + }, + "pkgconfig-1.5.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6db422802f2bf4637e383ca5ecb48b86", + "name": "pkgconfig", + "sha256": "a5a00c58a4bc670a821295ee6c77e7cbdcea8b96d1b7b8536e3013d9d7f09c7c", + "size": 13726, + "subdir": "linux-64", + "timestamp": 1623164120839, + "version": "1.5.4" + }, + "pkgconfig-1.5.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1289b6ab37e604fd47c97c3c73db4708", + "name": "pkgconfig", + "sha256": "f937ba705403d7413a5ce21a1be43e296854c598f8bca2cf571e5054fb05554f", + "size": 13775, + "subdir": "linux-64", + "timestamp": 1623164118648, + "version": "1.5.4" + }, + "pkgconfig-1.5.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "185d00b08e20ec557dc8b26cc9092b36", + "name": "pkgconfig", + "sha256": "f135fb7d5912fab591820a1187abf029089a06468175506d7bd33a00a21a25a5", + "size": 13981, + "subdir": "linux-64", + "timestamp": 1623249728276, + "version": "1.5.4" + }, + "pkgconfig-1.5.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4337d513a0728b78aecb40aa611b1837", + "name": "pkgconfig", + "sha256": "05076a238e914c973c0e2036f1f2b2e7d21b9f9f44492d6f6792a98dfd16d196", + "size": 13666, + "subdir": "linux-64", + "timestamp": 1640037467869, + "version": "1.5.5" + }, + "pkgconfig-1.5.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "375a896e825072b04bf9e934d5aaab2b", + "name": "pkgconfig", + "sha256": "6d65ce7865dd94b7093af495a90a336ea3511614aa15dcc8f53457d785e2c30e", + "size": 13674, + "subdir": "linux-64", + "timestamp": 1640037435929, + "version": "1.5.5" + }, + "pkgconfig-1.5.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "118cd8ccccc4f5022299f10478ee8abf", + "name": "pkgconfig", + "sha256": "ee0934e46e4b1354cbdaacea742fe9c661ca52219d9c6ad6ddf27fbad693e176", + "size": 13718, + "subdir": "linux-64", + "timestamp": 1640037502702, + "version": "1.5.5" + }, + "pkginfo-1.4.1-py27hee1a9ad_1.tar.bz2": { + "build": "py27hee1a9ad_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "395d468dd45cd56eac7a0c6d7c79b45e", + "name": "pkginfo", + "sha256": "ca5f528adc3df000f27095a195ca85a3fa3b2793f6873c790a6dfa94d3f8975b", + "size": 38009, + "subdir": "linux-64", + "timestamp": 1505742271904, + "version": "1.4.1" + }, + "pkginfo-1.4.1-py35hb526c55_1.tar.bz2": { + "build": "py35hb526c55_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a9eda6b16280037134a7fce1370b0caf", + "name": "pkginfo", + "sha256": "02bc796738945dd5479117287fc327647a2626d7ef425abaa276514a85da0a48", + "size": 39627, + "subdir": "linux-64", + "timestamp": 1505742285395, + "version": "1.4.1" + }, + "pkginfo-1.4.1-py36h215d178_1.tar.bz2": { + "build": "py36h215d178_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0860306844f4e0ab3b3948ccc6069ede", + "name": "pkginfo", + "sha256": "b8e2fc96901252fe41434b6338b50324b1af4aca9a20b45d34bea5bafc18ab77", + "size": 39502, + "subdir": "linux-64", + "timestamp": 1505742299170, + "version": "1.4.1" + }, + "pkginfo-1.4.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c4b4fbd9cbacb45fb438fdb4f493983", + "name": "pkginfo", + "sha256": "d462ce84ccc193c7974c6530fa9c78facb1d3842a8f0e456ebc18ca3baae3ef7", + "size": 38406, + "subdir": "linux-64", + "timestamp": 1522082489840, + "version": "1.4.2" + }, + "pkginfo-1.4.2-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c752dfbcdbe488772f05c9e240cef5c1", + "name": "pkginfo", + "sha256": "a683d4a51c3c5cb0b36be77116509e7af8ba565e68a47644ab6e5bb55a4917ae", + "size": 39894, + "subdir": "linux-64", + "timestamp": 1522082490769, + "version": "1.4.2" + }, + "pkginfo-1.4.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2045d1e8a9285835ea87dbbf07bc4b26", + "name": "pkginfo", + "sha256": "e670bf532564c9124d2d5a7be9e2fc936d528f60743f827b83b59aef13b3aa35", + "size": 39789, + "subdir": "linux-64", + "timestamp": 1522082490754, + "version": "1.4.2" + }, + "pkginfo-1.4.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c049a8b16f278dc7e67236d995ca8158", + "name": "pkginfo", + "sha256": "d79fd3aeedecdcb1c2b9d74cfa7862e699d981c853dc6835b05270f58d036c57", + "size": 39607, + "subdir": "linux-64", + "timestamp": 1530813565309, + "version": "1.4.2" + }, + "pkginfo-1.5.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc13819b8f330d10a2afa3d021683f78", + "name": "pkginfo", + "sha256": "ebcc8955bc562265c84765ab41f2844646cc3a112e5860c11da688c3863fd7a6", + "size": 42129, + "subdir": "linux-64", + "timestamp": 1547907454507, + "version": "1.5.0.1" + }, + "pkginfo-1.5.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d6351ff53573e8bb181b593457092ebb", + "name": "pkginfo", + "sha256": "a71cc631258c37fe6d2e4c8e6306472c99453a3191daf2018fb840bb290dc7ae", + "size": 43674, + "subdir": "linux-64", + "timestamp": 1547907473434, + "version": "1.5.0.1" + }, + "pkginfo-1.5.0.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6fd9268627e1ecda6ba86eacafbfc55e", + "name": "pkginfo", + "sha256": "da1a4b43f16cb731127400ded518bfec3ccc41bac0a555f841e5a30b409cef94", + "size": 43899, + "subdir": "linux-64", + "timestamp": 1605300309430, + "version": "1.5.0.1" + }, + "pkginfo-1.5.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e39f776eddf20d9be258d66bc67b983", + "name": "pkginfo", + "sha256": "06a56af375758b1b2ac5d7f688afdc00b4cfd265121051844292335ece2cafee", + "size": 43690, + "subdir": "linux-64", + "timestamp": 1547907471808, + "version": "1.5.0.1" + }, + "pkginfo-1.5.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c458e54216f6563e84c6cdd7d592b84", + "name": "pkginfo", + "sha256": "a06d954c49a33fe890502f8375fa84ef73f3b5c681677cf2d16c00f838690267", + "size": 43890, + "subdir": "linux-64", + "timestamp": 1605300329910, + "version": "1.5.0.1" + }, + "pkginfo-1.5.0.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1463921f2a7c50728dd59038cbcfee34", + "name": "pkginfo", + "sha256": "db15e691d50f601f6084389512565914d67177367541c575b0d93e7e732f2d1d", + "size": 42276, + "subdir": "linux-64", + "timestamp": 1573040570315, + "version": "1.5.0.1" + }, + "pkginfo-1.5.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "942a64cfc6f82720457d77adc97f06a4", + "name": "pkginfo", + "sha256": "705e2f96c8d8bc03d40a8778826099f6eabe2df46e19ef01ecce54f80c7823c8", + "size": 44110, + "subdir": "linux-64", + "timestamp": 1605300342094, + "version": "1.5.0.1" + }, + "pkginfo-1.5.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b283945573ac43cb6c5718db2821d777", + "name": "pkginfo", + "sha256": "1d87cd7f8bbcd9dffec6afc38b74e9e27574490e528ae2648994e6e696303a3f", + "size": 44246, + "subdir": "linux-64", + "timestamp": 1605300324374, + "version": "1.5.0.1" + }, + "pkginfo-1.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9814e7109ec8e2af6b6afb9e79561aa8", + "name": "pkginfo", + "sha256": "5aaa61d6e7e4006fec9e9735ce4998061ecde7f2c224c9faf6a93b8fcb75c561", + "size": 42049, + "subdir": "linux-64", + "timestamp": 1603217627866, + "version": "1.6.0" + }, + "pkginfo-1.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1cc679f12782ad94a873d23786284c0e", + "name": "pkginfo", + "sha256": "a952b6ba13627ba57233351fcb3899e6ea6753518832dbe1016c6be102b71e58", + "size": 42072, + "subdir": "linux-64", + "timestamp": 1603217581672, + "version": "1.6.0" + }, + "pkginfo-1.6.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e3e1176145140798435b9f707c320849", + "name": "pkginfo", + "sha256": "cccfe1e82279a733d694eb4964285218f4dc576af135354e74e81ac95ae92b64", + "size": 42318, + "subdir": "linux-64", + "timestamp": 1603217605775, + "version": "1.6.0" + }, + "pkginfo-1.6.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4be0dc1222016a9898a0682e061f9d9b", + "name": "pkginfo", + "sha256": "d409362f26581c3d6c33826434b0f4d2f9e61fff5c5b5ea97486f42b154405ce", + "size": 42117, + "subdir": "linux-64", + "timestamp": 1605121962492, + "version": "1.6.1" + }, + "pkginfo-1.6.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "27bc5a021a8b7004a24f564213faaac9", + "name": "pkginfo", + "sha256": "ad665edead4fb1827cb4aea4ae79390bf3d4ea428a10d335608dee964ab781a4", + "size": 42177, + "subdir": "linux-64", + "timestamp": 1605121726724, + "version": "1.6.1" + }, + "pkginfo-1.6.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c98af2ebb80f732ac448a0b2fa3b1422", + "name": "pkginfo", + "sha256": "6bfd33f6939e78f052545929e1e0c2342fa60ad5b1d2b39911e6dd988fe8819a", + "size": 42329, + "subdir": "linux-64", + "timestamp": 1605121743728, + "version": "1.6.1" + }, + "pkginfo-1.6.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47853c33ed92987b30556e95d9a43652", + "name": "pkginfo", + "sha256": "d3ac7f78c8a47074542d8b91febee0a1e9e2bc69c5ad7db8e46b7c9a3f5e13ab", + "size": 42473, + "subdir": "linux-64", + "timestamp": 1605121739116, + "version": "1.6.1" + }, + "pkginfo-1.7.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "906e6ed7b8cd08e2ce1b4f6aa4954a49", + "name": "pkginfo", + "sha256": "3552630ad6299b12caa3099134731fa5361d0acf50e01400a3283931b94b4741", + "size": 42139, + "subdir": "linux-64", + "timestamp": 1610825011306, + "version": "1.7.0" + }, + "pkginfo-1.7.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a69077a2c01a350f80191db227bb9141", + "name": "pkginfo", + "sha256": "ead72818ab852867433280d9886af88b99182ffe9a5ede679d6c8757606b9cf5", + "size": 42128, + "subdir": "linux-64", + "timestamp": 1610825025755, + "version": "1.7.0" + }, + "pkginfo-1.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "229dc4be786513a7afb3b9cd36cf99b1", + "name": "pkginfo", + "sha256": "e5e12a4dfb8d652f78cb88bd1304efeef19efef9e2dfcdfbccf5d6b9b466aea3", + "size": 42350, + "subdir": "linux-64", + "timestamp": 1610824368841, + "version": "1.7.0" + }, + "pkginfo-1.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a7ff4c96a80ae3ff7d0f3636d0b7f48e", + "name": "pkginfo", + "sha256": "c4338acecec8aa1d677ba34731196dcbfeee8cef820b955aa1c5a31335464a03", + "size": 42533, + "subdir": "linux-64", + "timestamp": 1610825012244, + "version": "1.7.0" + }, + "pkginfo-1.7.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f633197d2f610eb07f8a1d2732b0f3c7", + "name": "pkginfo", + "sha256": "574403978243c085a8a83e288794139bd511c99b144bc806193e6bec9614fed3", + "size": 42774, + "subdir": "linux-64", + "timestamp": 1640792393578, + "version": "1.7.1" + }, + "pkginfo-1.7.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83eb639881259a20017aa5f67bac98cf", + "name": "pkginfo", + "sha256": "e87c43b7e716bde2c7ad36f2864cbe237884759fa4c17ac6988f6920d47c09cf", + "size": 41915, + "subdir": "linux-64", + "timestamp": 1626087089553, + "version": "1.7.1" + }, + "pkginfo-1.7.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "38021fb438d314a997d5f3424ce7873e", + "name": "pkginfo", + "sha256": "f07f9d2a345f81957b70ceafc1de63be91ab123579c772022ce67de1125f3b61", + "size": 41963, + "subdir": "linux-64", + "timestamp": 1626087188353, + "version": "1.7.1" + }, + "pkginfo-1.7.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13944f85ac1520aa978592cb7e9efd59", + "name": "pkginfo", + "sha256": "98026075b69eada3de355a4288366fafea998e08444ce0c86a69d014667a1e1a", + "size": 42128, + "subdir": "linux-64", + "timestamp": 1626087187000, + "version": "1.7.1" + }, + "pkginfo-1.7.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "78ef83743e3abe5e75c62d312c0a7066", + "name": "pkginfo", + "sha256": "5da65908324311ceaeb9fe544d20571e9ecb0f1ddf06c22f809e1871ed5b8c36", + "size": 42263, + "subdir": "linux-64", + "timestamp": 1626087203997, + "version": "1.7.1" + }, + "pkginfo-1.8.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "accbfb24974a14461dc8d70383fcd6b3", + "name": "pkginfo", + "sha256": "fd054aaad40efbfc3aee856d17b81139047eae5809e4e3051f18f2a94b17d97f", + "size": 46064, + "subdir": "linux-64", + "timestamp": 1666725148021, + "version": "1.8.3" + }, + "pkginfo-1.8.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b9080086db81d9a81604056eea3ff29", + "name": "pkginfo", + "sha256": "4582aefe63da00f169868f0900ddb7de4d6112a14c5c502d636c05a26c0f795a", + "size": 60190, + "subdir": "linux-64", + "timestamp": 1676823189855, + "version": "1.8.3" + }, + "pkginfo-1.8.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2cf577e8fd84065a95c803c9bfa15b5a", + "name": "pkginfo", + "sha256": "edd7e5f15f04b7112c4002c161e7d205d9dc743c63cded797c378c2c40e2581f", + "size": 45246, + "subdir": "linux-64", + "timestamp": 1666725121594, + "version": "1.8.3" + }, + "pkginfo-1.8.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e79015c20971cb3abd526383f05835db", + "name": "pkginfo", + "sha256": "049b967bda2e30a65ce25e55cb141969a8424f55496ab9ffa62489bc0c75619c", + "size": 45523, + "subdir": "linux-64", + "timestamp": 1666725096028, + "version": "1.8.3" + }, + "pkginfo-1.8.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bdfaf78779617044844802fcf8d148eb", + "name": "pkginfo", + "sha256": "e85850736b474731b35f146a1bb6011f84733bb3dcf8b7921c7f10c8849de00e", + "size": 45681, + "subdir": "linux-64", + "timestamp": 1666725070643, + "version": "1.8.3" + }, + "pkginfo-1.9.6-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1e9f31dbca0a1af9c8f4db35a721836", + "name": "pkginfo", + "sha256": "556cf63582e40d06294e6d3403b3294692cdeff4e34998f72c8dbb927c167ff7", + "size": 48200, + "subdir": "linux-64", + "timestamp": 1679431242816, + "version": "1.9.6" + }, + "pkginfo-1.9.6-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "99c4222cfef1761b7e039180b98f7438", + "name": "pkginfo", + "sha256": "7f34069e828125f48c74482b8b2ef738e7d64f87439c4875117045900966d405", + "size": 61618, + "subdir": "linux-64", + "timestamp": 1679431191344, + "version": "1.9.6" + }, + "pkginfo-1.9.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb0c8dac538b859a19e0398184d37ec1", + "name": "pkginfo", + "sha256": "5867ec9fd40dfd293af9f547d16dcd2f53b122bbe21447b750d8373e674772fe", + "size": 47698, + "subdir": "linux-64", + "timestamp": 1679431216864, + "version": "1.9.6" + }, + "pkginfo-1.9.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1736a5f70983b7056b77b57f034f3d3", + "name": "pkginfo", + "sha256": "8fa0d26372a93172bf8c233aef00250d6916cc2ec862434c421acd5c0a97d909", + "size": 47775, + "subdir": "linux-64", + "timestamp": 1679431267143, + "version": "1.9.6" + }, + "pkgutil-resolve-name-1.3.10-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT AND PSF-2.0", + "license_family": "PSF", + "md5": "ab7093b61ca090021cffb2fc8ccc7abc", + "name": "pkgutil-resolve-name", + "sha256": "80588ec6854014dafbeeb7b372ffdf0f450dfb21a8f1d9ea83c49cff198e9643", + "size": 9770, + "subdir": "linux-64", + "timestamp": 1661463378870, + "version": "1.3.10" + }, + "pkgutil-resolve-name-1.3.10-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT AND PSF-2.0", + "license_family": "PSF", + "md5": "eef230cabc54459c3b9c52938028e376", + "name": "pkgutil-resolve-name", + "sha256": "3253e3b4e00197f39259501fc30ee45ca37fedea540d096140feebe793a242e0", + "size": 9765, + "subdir": "linux-64", + "timestamp": 1661463353650, + "version": "1.3.10" + }, + "plac-0.9.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "54a15b173be857c1e643c55105bdb889", + "name": "plac", + "sha256": "1d63a2e8bbc87ae5ef96434c827de93fab58dba0822646c68bed24a33a2306e6", + "size": 36130, + "subdir": "linux-64", + "timestamp": 1530961286861, + "version": "0.9.6" + }, + "plac-0.9.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9ce82155b4d5c24905a978f45fa49fc6", + "name": "plac", + "sha256": "fd79ed9500298a5d36110cc51ccb22d2a96d0c48ba14ea55670c119f50908330", + "size": 37312, + "subdir": "linux-64", + "timestamp": 1535606045360, + "version": "0.9.6" + }, + "plac-0.9.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f6be392dda7131ae2ced5b312bd1a09c", + "name": "plac", + "sha256": "472daaf72341c9b74852b22dac16542e1066ba3e60b68ee3fe927451fce1f209", + "size": 37080, + "subdir": "linux-64", + "timestamp": 1530961316923, + "version": "0.9.6" + }, + "plac-0.9.6-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "19b9a2b3766d7913159651578d40e554", + "name": "plac", + "sha256": "1828152fc05e493046ba48cdc3851e8e5b397cb7b738ea2360a971503f5b7540", + "size": 39077, + "subdir": "linux-64", + "timestamp": 1594261930547, + "version": "0.9.6" + }, + "plac-0.9.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a5157596fd5f29e1d07b035c791acd99", + "name": "plac", + "sha256": "e95f118cd4234d0f6d681a29db3ee8575472faf46d4174fe64d1ff439398b763", + "size": 37117, + "subdir": "linux-64", + "timestamp": 1530961347417, + "version": "0.9.6" + }, + "plac-0.9.6-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "1bd9254eb6e993fcb24409a840371795", + "name": "plac", + "sha256": "4237acfee63f585b1ec60fd385b70871820c57643140fb06de1758c5e918fab0", + "size": 39151, + "subdir": "linux-64", + "timestamp": 1594261938051, + "version": "0.9.6" + }, + "plac-0.9.6-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "41dd03e9dbdb9623889b8ef10e8e00ed", + "name": "plac", + "sha256": "06c45d2b16e49b2bf2fc4c25d3eadad4337cb5dea01758890a608200c87970dd", + "size": 39302, + "subdir": "linux-64", + "timestamp": 1594261929297, + "version": "0.9.6" + }, + "plac-1.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7549aa504ab5ede4684977b884e807ed", + "name": "plac", + "sha256": "bf44944e99e871ce6c55f4f568ba351149dc07b34c7471c29fe4eca0e0ac17d6", + "size": 36456, + "subdir": "linux-64", + "timestamp": 1534617727354, + "version": "1.0.0" + }, + "plac-1.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c545bf4f03cf244997a5a24ea7bbb426", + "name": "plac", + "sha256": "49b7f2321645ce4602164b6dbb9dc8b6be55375a9a8c21ba13a3ab6cb12c3d87", + "size": 37556, + "subdir": "linux-64", + "timestamp": 1534617700791, + "version": "1.0.0" + }, + "plac-1.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "1eadd218b6f04cd33e5f3a68777cd5f8", + "name": "plac", + "sha256": "22b4f2ce138b2f2228c9c3c565e8761cbf62b2d24588ec7fbecc87f894a6a578", + "size": 37384, + "subdir": "linux-64", + "timestamp": 1534617713692, + "version": "1.0.0" + }, + "plac-1.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "55aa57e7be63ae8b73483d13931105e9", + "name": "plac", + "sha256": "ce326a6073a5f678d4cf518a55fc0da86f6fe813dd2137409472a97e564699ee", + "size": 37472, + "subdir": "linux-64", + "timestamp": 1534617777702, + "version": "1.0.0" + }, + "plac-1.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "cbe7b0a86c95bc3f71d2fe6c590ff19e", + "name": "plac", + "sha256": "20a07c955e5e2b66ef069d2ffb59edb78931e2e28557e994f390a99c882f1f84", + "size": 38894, + "subdir": "linux-64", + "timestamp": 1569351450133, + "version": "1.1.0" + }, + "plac-1.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3d61dbfd13fdd221f37297ce9f5d02cf", + "name": "plac", + "sha256": "7ad12decb395d241bac242cabff6cd38741f73b592e1d28f11fd8389dc39571d", + "size": 39803, + "subdir": "linux-64", + "timestamp": 1569351447912, + "version": "1.1.0" + }, + "plac-1.1.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "fa563d1485c306ae0454faa833f4440d", + "name": "plac", + "sha256": "7e58bdf1c56954a5287360365fbbc973638a6cfd48b92c158cf6fe2ed7908436", + "size": 39978, + "subdir": "linux-64", + "timestamp": 1594260037860, + "version": "1.1.0" + }, + "plac-1.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "19c8f5684a890d13507e416c10a713f4", + "name": "plac", + "sha256": "0938c9030b50f8ec08cc6ba9ba02f655fa5c405b9237264ffc88a45c07475821", + "size": 39799, + "subdir": "linux-64", + "timestamp": 1569351512919, + "version": "1.1.0" + }, + "plac-1.1.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "6fe90db7ead25d15b0f54ea53f409f04", + "name": "plac", + "sha256": "7d85eb1bf8d5ef458ce1593d156f5915222c87dfb75f737c29b65db00ce32bf6", + "size": 39991, + "subdir": "linux-64", + "timestamp": 1594259996483, + "version": "1.1.0" + }, + "plac-1.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "16f0af326212e5a0d82a333b735f4fc8", + "name": "plac", + "sha256": "90bc19c8f86731778ba169d01040b68096703e358a992e69fe3a8822f8099b18", + "size": 39221, + "subdir": "linux-64", + "timestamp": 1573040633995, + "version": "1.1.0" + }, + "plac-1.1.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "864458cc923ec440960648e4386cb764", + "name": "plac", + "sha256": "1d7ab5fd61d520ccd48f7679fc5402fa0f67b88cb223661a260fd3326a6bfa04", + "size": 40188, + "subdir": "linux-64", + "timestamp": 1594259996417, + "version": "1.1.0" + }, + "plac-1.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "88e7f958d594ef75d921bf4042a0ffde", + "name": "plac", + "sha256": "c349b340acaf9d4caf8a816de6a90fde85044590ee115c90d94c05446f8194e0", + "size": 40407, + "subdir": "linux-64", + "timestamp": 1608239075931, + "version": "1.1.0" + }, + "plac-1.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "14a0b4fb410d1383a27083f59775e523", + "name": "plac", + "sha256": "d7a2c9b20dbfcd9a7b5d0698992b1b223aab80e94894f164ebd6ff80e950010c", + "size": 41310, + "subdir": "linux-64", + "timestamp": 1594261196294, + "version": "1.2.0" + }, + "plac-1.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "380f80a1bb7b0d2b7cf32a289bdc606a", + "name": "plac", + "sha256": "4275f14067fef01550be3b6d49a7b1e65a695498a9ff44f7551f753c491b2a76", + "size": 41350, + "subdir": "linux-64", + "timestamp": 1594261193524, + "version": "1.2.0" + }, + "plac-1.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b66731ac214e04855e559a108650f694", + "name": "plac", + "sha256": "2d9f1938d3afff36f0d5889d823ec963461696870a057fffd6889f5c00af2e37", + "size": 41492, + "subdir": "linux-64", + "timestamp": 1594261193134, + "version": "1.2.0" + }, + "plac-1.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "01c228987a4bcca81c920eca7d343c6a", + "name": "plac", + "sha256": "1d2daa7ae475acf9fb5b2f11f6421372d7af054cf9b00c06cae3d9976396a765", + "size": 41806, + "subdir": "linux-64", + "timestamp": 1608234238061, + "version": "1.2.0" + }, + "plac-1.3.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "fc69d5b759da37e189417b2c1d9688fe", + "name": "plac", + "sha256": "7d303c234968eec96a6ef1f324f961c8e0a3ea82b938265e1852292015d89b28", + "size": 40601, + "subdir": "linux-64", + "timestamp": 1609094540905, + "version": "1.3.0" + }, + "plac-1.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d0a18ae37d5d225c1c377e0a2ba3741b", + "name": "plac", + "sha256": "44a80fba487af5c65c69ae7b88ce8491b462aab0b6a6e0370e68b45283dd57c5", + "size": 40645, + "subdir": "linux-64", + "timestamp": 1609094537703, + "version": "1.3.0" + }, + "plac-1.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "035c6742972a59d7e7ee1121a4d86ecc", + "name": "plac", + "sha256": "e90e6eafbf1139698cfcb947e535785d4dcbc8043013714bc534d3769afb66d7", + "size": 40809, + "subdir": "linux-64", + "timestamp": 1609094531036, + "version": "1.3.0" + }, + "plac-1.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "17e12a84ced7a148cc198319cf1ae1e1", + "name": "plac", + "sha256": "7387f701d90ad71451e0cd6ac72801c7ad4834767aa019d0a7988537037ac0ef", + "size": 40841, + "subdir": "linux-64", + "timestamp": 1609094547936, + "version": "1.3.0" + }, + "plac-1.3.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5ee6dde50265d49d2ba953d13d977f96", + "name": "plac", + "sha256": "bf5afeb17509dfdc9f2f49e6864ec32153f082205cefb05bce2d402a23e3b10b", + "size": 41709, + "subdir": "linux-64", + "timestamp": 1610305918611, + "version": "1.3.1" + }, + "plac-1.3.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "684189be44d0ea7452ddeea785b5f36c", + "name": "plac", + "sha256": "999446e483c1b054d846cc0f55c3b6f35e99764c54a89df397071f4867a66239", + "size": 42973, + "subdir": "linux-64", + "timestamp": 1610482751205, + "version": "1.3.1" + }, + "plac-1.3.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "11a72ee99cfca99779156a111aa982f9", + "name": "plac", + "sha256": "d7aa05361c7d77e5218d45fd40390d05673797b42e31c0374af5f766baf752ac", + "size": 41668, + "subdir": "linux-64", + "timestamp": 1610305919988, + "version": "1.3.1" + }, + "plac-1.3.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "6db025ed551b21e43d2e39e2373fd9b5", + "name": "plac", + "sha256": "49b2c424640e59926d34979f7b9024f65a9c29b2812014887494ba60b9f6d852", + "size": 43022, + "subdir": "linux-64", + "timestamp": 1610482748749, + "version": "1.3.1" + }, + "plac-1.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7bca526a26129b4a48054a56085b69d8", + "name": "plac", + "sha256": "a38460c7b8517ddb56c3422cd3b6057f3a071e579185833ba4b99f37f43c931e", + "size": 41898, + "subdir": "linux-64", + "timestamp": 1610305936647, + "version": "1.3.1" + }, + "plac-1.3.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e14505a25696142333798bd0ced85ef3", + "name": "plac", + "sha256": "9c9ecc7e59061c062a0d26188f549e26f0fa96fc44dea27aa77316a8e423247b", + "size": 43163, + "subdir": "linux-64", + "timestamp": 1610482741508, + "version": "1.3.1" + }, + "plac-1.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "0166c6f7b8066255b7f557be7d95ac9a", + "name": "plac", + "sha256": "65eb1445b37b1e821688eba87a76bf37a238f348832cf5a97e07cf0236f9c98f", + "size": 41968, + "subdir": "linux-64", + "timestamp": 1610305906701, + "version": "1.3.1" + }, + "plac-1.3.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3807dffc0f36fa0b89b4c2d7303f44ac", + "name": "plac", + "sha256": "1a479122d97a918fc509f832f6b1553acdf67f02b920eb70f1a276a8e7fbd94e", + "size": 43259, + "subdir": "linux-64", + "timestamp": 1610482284886, + "version": "1.3.1" + }, + "plac-1.3.2-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "825f995622da1785afe5b96d8443b285", + "name": "plac", + "sha256": "409708065f99bbe44a70eade24e46b5c6f9adf798fc6b920cd5b411e35f3278f", + "size": 42475, + "subdir": "linux-64", + "timestamp": 1642499657111, + "version": "1.3.2" + }, + "plac-1.3.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "be6375c050f4046473d9ad65a83de3fe", + "name": "plac", + "sha256": "4253d9a0db507da6cda26f772935cb2fd53d333d44c735bf88b43393b31c701a", + "size": 41869, + "subdir": "linux-64", + "timestamp": 1613763288531, + "version": "1.3.2" + }, + "plac-1.3.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d39e41374fc32e3d0fb5dcf72f0e0cb5", + "name": "plac", + "sha256": "a38e36ef930f854bedb9475be13c54d3ceb6bbe521f5bedc5693a57155ce96e6", + "size": 41912, + "subdir": "linux-64", + "timestamp": 1613763963548, + "version": "1.3.2" + }, + "plac-1.3.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "6fb4bee8a95ef734c5a0d970018bd282", + "name": "plac", + "sha256": "223d361a7438c2ba44cc13ff9a9554e9fbae8313ee1e9278d0870fa7cab84e85", + "size": 42086, + "subdir": "linux-64", + "timestamp": 1613763973206, + "version": "1.3.2" + }, + "plac-1.3.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "945a4958cef02ff05c6084d117a5b4c0", + "name": "plac", + "sha256": "e23c8a00b5250d64add170e04c7370d0dfb5f89f87d8a4ffe269d64ed68c4788", + "size": 42113, + "subdir": "linux-64", + "timestamp": 1613763975623, + "version": "1.3.2" + }, + "plac-1.3.3-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "81681d05127608d79c1d374ffcbe941d", + "name": "plac", + "sha256": "022a80461c49c2177225e04726ee5fc9ec3dfbf85d9a2963695f614acf6ff71e", + "size": 41913, + "subdir": "linux-64", + "timestamp": 1616529588892, + "version": "1.3.3" + }, + "plac-1.3.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a496556b49a77235e1265148ce765d5f", + "name": "plac", + "sha256": "7ddd35222bc364320ba697a4909e8eda6d4c3a5e8bd514c7bb81e11942ec608e", + "size": 41936, + "subdir": "linux-64", + "timestamp": 1616527547348, + "version": "1.3.3" + }, + "plac-1.3.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "0160fbc0aed6ef7639174a6d5d290fc6", + "name": "plac", + "sha256": "b7db2be83f8f2a97cc028e9251616479c37aec3030c462d00bdbe4582242550b", + "size": 42125, + "subdir": "linux-64", + "timestamp": 1616529705369, + "version": "1.3.3" + }, + "plac-1.3.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8ef939f23d83405d28774c9aadf234b2", + "name": "plac", + "sha256": "dc93f7bdff388178c20747ec410172206f9c9ba16b985b118e56e87061155178", + "size": 42156, + "subdir": "linux-64", + "timestamp": 1616529697700, + "version": "1.3.3" + }, + "plaster-1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "04e573ab66fca9169dffb16131e0ab34", + "name": "plaster", + "sha256": "683a6984c3ff20d11b3ab705eb6bfc21d35555b2a15a75405dfeefd43a36fb8d", + "size": 16928, + "subdir": "linux-64", + "timestamp": 1530025602486, + "version": "1.0" + }, + "plaster-1.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1238ad3b394f14c4df50b0079bf6fd66", + "name": "plaster", + "sha256": "68b013a55d72efb1cffb9b8afd743b6710d3d892b1c2707a8378c2a3ac3fd5a6", + "size": 16632, + "subdir": "linux-64", + "timestamp": 1530029413270, + "version": "1.0" + }, + "plaster-1.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "07f366098f4c69f986c4a9471e19334f", + "name": "plaster", + "sha256": "fbb33f4729bbbc2d00a4a70f47bad12296d4298d0d4c90325df16d4730a6e0f6", + "size": 17410, + "subdir": "linux-64", + "timestamp": 1640792411549, + "version": "1.0" + }, + "plaster-1.0-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58f1b619cf9cc6422ac8169fa66b29a8", + "name": "plaster", + "sha256": "93f30836f9d50fe898afa51022ff2bce16211efd0e5a86bd7d80148f1005fd64", + "size": 20665, + "subdir": "linux-64", + "timestamp": 1676903973648, + "version": "1.0" + }, + "plaster-1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a2c02233684417138d039bcabdb39027", + "name": "plaster", + "sha256": "c50e58f9cb4f1741fcb7e9a8961018f76587d53fa8eac43830e2486acaad7bb4", + "size": 17297, + "subdir": "linux-64", + "timestamp": 1530025663010, + "version": "1.0" + }, + "plaster-1.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8f5ae0c18da2e66ad4b711031a48dfd", + "name": "plaster", + "sha256": "b7324c360c04fb3eee2c12b2ff3b89ded18434d86e4a3509b1609fea89a00c93", + "size": 17028, + "subdir": "linux-64", + "timestamp": 1530029422783, + "version": "1.0" + }, + "plaster-1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "88a1d2ff31dfd38ec6d218b40127c1f2", + "name": "plaster", + "sha256": "2fd8c99b7004ba1a6c7db239d05486f07d931b2d825b69ee4ba468e5a48f7029", + "size": 17365, + "subdir": "linux-64", + "timestamp": 1530025482145, + "version": "1.0" + }, + "plaster-1.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb31e36b909f54d187f037eb9e770ef7", + "name": "plaster", + "sha256": "9479cc6b1be6902ed12f3c0951fcde76712fe1c84b9b6d4d6b2d09f603b81743", + "size": 17030, + "subdir": "linux-64", + "timestamp": 1530029363625, + "version": "1.0" + }, + "plaster-1.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc13b5b37f2f9b7fe0e1b8eda5ac3fbd", + "name": "plaster", + "sha256": "8ff896af4d63bbaf0a0d7edcb68b8a8a2f61c41579d152cc5cba510fedf0a3be", + "size": 234593, + "subdir": "linux-64", + "timestamp": 1613559648912, + "version": "1.0" + }, + "plaster-1.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b3867526250da71c5049808ebc5db458", + "name": "plaster", + "sha256": "be10bf4e72671e790fe610b332c46654b93fe8fc8b14ad0c215cc09411bebd5a", + "size": 17086, + "subdir": "linux-64", + "timestamp": 1530875228065, + "version": "1.0" + }, + "plaster-1.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "19f0be9bc3d68773bce61f4b403d1c4e", + "name": "plaster", + "sha256": "0ebf27bfef0d360b4e94a2a0a0382f7d0f47fd125686cd2143a34ebce3137825", + "size": 234738, + "subdir": "linux-64", + "timestamp": 1613560715473, + "version": "1.0" + }, + "plaster-1.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c758f5b149ac287f8dd9f9464638814", + "name": "plaster", + "sha256": "b5bff9bff4e2366a5bd6e5b2a4c472651d94ef1cdaf853d3da29a8ddf2464e5c", + "size": 17581, + "subdir": "linux-64", + "timestamp": 1574273614453, + "version": "1.0" + }, + "plaster-1.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8a9cb3ab330d322a157beb5abdd34de", + "name": "plaster", + "sha256": "b1a830f73689fed6b1accbfe939bb93a40d8570b9d42274a256adedfeb0281ab", + "size": 236739, + "subdir": "linux-64", + "timestamp": 1613560597146, + "version": "1.0" + }, + "plaster-1.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c7f576ef24750170e62d1a6c1ff87f2", + "name": "plaster", + "sha256": "cf864b5568a9941203963b1f2464a41f8ae51afbf2d5e6450bf056a824b0803a", + "size": 235358, + "subdir": "linux-64", + "timestamp": 1613560324599, + "version": "1.0" + }, + "plaster_pastedeploy-0.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b9c72fb0affb0b9348188e6a031787f", + "name": "plaster_pastedeploy", + "sha256": "f83fd941b965992c79d0ee0fa6344a84c707f622ff5659e2bee319fe0ee8b105", + "size": 11958, + "subdir": "linux-64", + "timestamp": 1530027728433, + "version": "0.5" + }, + "plaster_pastedeploy-0.5-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "72b4ffbfb2090f737a6953617c961698", + "name": "plaster_pastedeploy", + "sha256": "9c796ca5893a83557eb636178a307c07eec6ac09b03f0ae5c55405ae6fdf30ab", + "size": 11498, + "subdir": "linux-64", + "timestamp": 1530031909194, + "version": "0.5" + }, + "plaster_pastedeploy-0.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23eff70c108aaa0aa32bffacd36cf71e", + "name": "plaster_pastedeploy", + "sha256": "4f40a89e2afe2cdf30971974b7a8805fcf8f1c7844b49cbe7c0b19cb96b81902", + "size": 12125, + "subdir": "linux-64", + "timestamp": 1530027157828, + "version": "0.5" + }, + "plaster_pastedeploy-0.5-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bfddb5389f3a28c442547d9ec281f04a", + "name": "plaster_pastedeploy", + "sha256": "6adf6bd532e53a3f1f17ac2be4a26260b735b8d68b5aeb061f3d4ba7daff9f12", + "size": 11673, + "subdir": "linux-64", + "timestamp": 1530031951619, + "version": "0.5" + }, + "plaster_pastedeploy-0.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "821c0bc26591fca1d0feae81ced16234", + "name": "plaster_pastedeploy", + "sha256": "bfdbbbb90af95ba0cb104f1ad9dd6989652a3e1f9fac306841e72355ce582240", + "size": 11495, + "subdir": "linux-64", + "timestamp": 1530027761994, + "version": "0.5" + }, + "plaster_pastedeploy-0.5-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7a6de1ea33be6aeca8d863a1781a9b55", + "name": "plaster_pastedeploy", + "sha256": "46982566a54ffe43c6e134a694d747a396bf2eb67cb5fd7f9fa436c8834fa26a", + "size": 11677, + "subdir": "linux-64", + "timestamp": 1530031903762, + "version": "0.5" + }, + "plaster_pastedeploy-0.5-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b72b88653b327337527cd912a88f9245", + "name": "plaster_pastedeploy", + "sha256": "37cd114578a6781d93a64071aa95b03b178cd9358b35a037025f076905533065", + "size": 11667, + "subdir": "linux-64", + "timestamp": 1530875254810, + "version": "0.5" + }, + "plaster_pastedeploy-0.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad07b26846e838d64b9971b859344d77", + "name": "plaster_pastedeploy", + "sha256": "6d0dcadbc7a1e2e46404fdd2695a08f618d6656962d322298df9f716b455d472", + "size": 11632, + "subdir": "linux-64", + "timestamp": 1535513610816, + "version": "0.6" + }, + "plaster_pastedeploy-0.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "875141dbc920257e35f35810d839d333", + "name": "plaster_pastedeploy", + "sha256": "a971ed7a6d9d1e4804fd390f974c7bb6a5afaa9e52a8f367d833c04419c2221b", + "size": 11792, + "subdir": "linux-64", + "timestamp": 1535513635052, + "version": "0.6" + }, + "plaster_pastedeploy-0.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b8a6ac4ea1d07b0e208291804f65c80", + "name": "plaster_pastedeploy", + "sha256": "d1d2bdb999dc7e2d6bcc2df33041b7686f0ba54c6ebf47e9651b811e31d55f44", + "size": 11758, + "subdir": "linux-64", + "timestamp": 1535513590544, + "version": "0.6" + }, + "plaster_pastedeploy-0.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d56c2fb906b52c97d1555d3a09d505dc", + "name": "plaster_pastedeploy", + "sha256": "6dcb9f46523893a7b370050168bccd0ce58bd540b45ceb3d1be4b1a1400f4a71", + "size": 11795, + "subdir": "linux-64", + "timestamp": 1535513625682, + "version": "0.6" + }, + "plaster_pastedeploy-0.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "81c7ea5306c5a2bbed1a35cb33113a5c", + "name": "plaster_pastedeploy", + "sha256": "479c0a689845c4a0f2f9246d77724960dff6273a6278ada070bde5444fa3dff8", + "size": 153071, + "subdir": "linux-64", + "timestamp": 1564702865473, + "version": "0.7" + }, + "plaster_pastedeploy-0.7-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17625213e415f0bfc62276bcf38018c0", + "name": "plaster_pastedeploy", + "sha256": "c358829c4d2d53c7db7b2a073fbc2242dd19e53ebc9b80d4497d1995966689c9", + "size": 12096, + "subdir": "linux-64", + "timestamp": 1640809938698, + "version": "0.7" + }, + "plaster_pastedeploy-0.7-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f65ccc983ad28329281b04cdbe1b6d89", + "name": "plaster_pastedeploy", + "sha256": "511bccac7951daa839218056fe6b9369d591a806c5f4ee6cce5d1afca707144e", + "size": 13982, + "subdir": "linux-64", + "timestamp": 1676904124628, + "version": "0.7" + }, + "plaster_pastedeploy-0.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6628a080b26875d3b0ac94456296744", + "name": "plaster_pastedeploy", + "sha256": "ded06392fd9b8adda914bbb66ab8e2132b0c683269c9a73fb78b1b8851ca0b90", + "size": 153136, + "subdir": "linux-64", + "timestamp": 1564703241115, + "version": "0.7" + }, + "plaster_pastedeploy-0.7-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bcec2504f9fb0a9f3fa768d112bec0b7", + "name": "plaster_pastedeploy", + "sha256": "df697636ae74017c793c6c588896872a4541c81aa1f064010e0abb6640b11619", + "size": 230324, + "subdir": "linux-64", + "timestamp": 1613564906289, + "version": "0.7" + }, + "plaster_pastedeploy-0.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "99979cfba25fcd978813c7b3263381c7", + "name": "plaster_pastedeploy", + "sha256": "9440800091e03eaefacd4dd542772f0a0f1cb7857a020e974414fd3356f7b20a", + "size": 153183, + "subdir": "linux-64", + "timestamp": 1564703214317, + "version": "0.7" + }, + "plaster_pastedeploy-0.7-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e3c569ff1681143ad3b5d1ee28e07ff6", + "name": "plaster_pastedeploy", + "sha256": "9ea6b019229b7585801d3968c89806c530a749d4fff6094459990e5d5176b398", + "size": 229122, + "subdir": "linux-64", + "timestamp": 1613564889042, + "version": "0.7" + }, + "plaster_pastedeploy-0.7-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17c2e33065365f16b178ffd50353eb0b", + "name": "plaster_pastedeploy", + "sha256": "d2d16249ae877bdc2da0883351d9c6849de81b2458e90a67c69e0a12411e455c", + "size": 12333, + "subdir": "linux-64", + "timestamp": 1574169832084, + "version": "0.7" + }, + "plaster_pastedeploy-0.7-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db690873a6fde89adf05be43ef03588c", + "name": "plaster_pastedeploy", + "sha256": "d4c45c103eff8b6a84d9fe741bc10f6f2ae06e5d0da676f863209ae12646e876", + "size": 229395, + "subdir": "linux-64", + "timestamp": 1613564866046, + "version": "0.7" + }, + "plaster_pastedeploy-0.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9945f8b29d2d4c4618e4ef66380a238e", + "name": "plaster_pastedeploy", + "sha256": "a638999328d61e430043244cd4c14744a45a64ed932d2a8d81e246caeac32331", + "size": 230658, + "subdir": "linux-64", + "timestamp": 1613564886325, + "version": "0.7" + }, + "platformdirs-2.5.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3fe57c4b428ddd2f2774a93c277cb1d1", + "name": "platformdirs", + "sha256": "40206346f3f2b2fd2a62ec19417e1299e06b530d556763618028314cc7a5e5e3", + "size": 23474, + "subdir": "linux-64", + "timestamp": 1662711483860, + "version": "2.5.2" + }, + "platformdirs-2.5.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "887f38307e5c897953531b5af4cb3a3b", + "name": "platformdirs", + "sha256": "512d5cb0f82496c4059486772c8f4420bf6314aeac744f04f037b4f38f5e9fe2", + "size": 28137, + "subdir": "linux-64", + "timestamp": 1676823068357, + "version": "2.5.2" + }, + "platformdirs-2.5.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "344c5f72b29a2c8d6b0bc5edc7e3ec1a", + "name": "platformdirs", + "sha256": "8259ea5f450fa7ebb8e6667cfa9c50387944c9a5ec609a0a0ad357b5bc27c516", + "size": 23251, + "subdir": "linux-64", + "timestamp": 1662711415444, + "version": "2.5.2" + }, + "platformdirs-2.5.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11e6b24a0bfac100be4305e755ba22fd", + "name": "platformdirs", + "sha256": "568bc0c7b0e39ac74dbfe4d854b4d517e1f89187c5194e81817d6a34fd5bc2f8", + "size": 23302, + "subdir": "linux-64", + "timestamp": 1662711442793, + "version": "2.5.2" + }, + "platformdirs-2.5.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f63c002eb6d388263c9df043fdcb973", + "name": "platformdirs", + "sha256": "d7c41567436853c601f450abf829c4392fb74ae2a8eb983489c5f237b059adb4", + "size": 23284, + "subdir": "linux-64", + "timestamp": 1662711511953, + "version": "2.5.2" + }, + "plotly-2.0.15-py27h139127e_0.tar.bz2": { + "build": "py27h139127e_0", + "build_number": 0, + "depends": [ + "decorator", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "9a3c57c875c0499f0f6fd869bad51b02", + "name": "plotly", + "sha256": "229da89127025a7cfbd4fd50e6e6345e90962e93096d0c89059eb691f2902011", + "size": 963438, + "subdir": "linux-64", + "timestamp": 1505727187734, + "version": "2.0.15" + }, + "plotly-2.0.15-py35h43bf465_0.tar.bz2": { + "build": "py35h43bf465_0", + "build_number": 0, + "depends": [ + "decorator", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "e22de989f10b53fc761e0d21becf1e20", + "name": "plotly", + "sha256": "c0c1da2a2696b2d72883f5746d4c2942f983d623ee05867307a603ccd4827b5e", + "size": 966835, + "subdir": "linux-64", + "timestamp": 1505727205158, + "version": "2.0.15" + }, + "plotly-2.0.15-py36hd032def_0.tar.bz2": { + "build": "py36hd032def_0", + "build_number": 0, + "depends": [ + "decorator", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "a5d8dee6e97a32707ff7a63e327ff465", + "name": "plotly", + "sha256": "80aa899667eda101ea34c95452ebe9727e0d1549cabe12d92c198e80bbeb02c8", + "size": 968135, + "subdir": "linux-64", + "timestamp": 1505727222680, + "version": "2.0.15" + }, + "plotly-2.1.0-py27h77e25ac_0.tar.bz2": { + "build": "py27h77e25ac_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "six" + ], + "license": "MIT", + "md5": "b3d151f98263f94550ade3f2ee9dd4a0", + "name": "plotly", + "sha256": "847389a911c38838b6406d73769ada2ebf16bb620a6193ee416e4303e4d599be", + "size": 975284, + "subdir": "linux-64", + "timestamp": 1507755452718, + "version": "2.1.0" + }, + "plotly-2.1.0-py35hac5c16f_0.tar.bz2": { + "build": "py35hac5c16f_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "six" + ], + "license": "MIT", + "md5": "d40261e5424b165a801a671f20989e2a", + "name": "plotly", + "sha256": "2eeb76a804b819070816a9123f68370b85cfe1eef327d8f01a7984689f2e2236", + "size": 979499, + "subdir": "linux-64", + "timestamp": 1507755448474, + "version": "2.1.0" + }, + "plotly-2.1.0-py36h56a57e5_0.tar.bz2": { + "build": "py36h56a57e5_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "six" + ], + "license": "MIT", + "md5": "21e58bc30cac1bab54166b0bf5d607b5", + "name": "plotly", + "sha256": "7f80563260bbdc8e89b2a5381c0e52f56eeb20c6828e2cf65dcb774a16c9c147", + "size": 981640, + "subdir": "linux-64", + "timestamp": 1507755463997, + "version": "2.1.0" + }, + "plotly-2.2.2-py27hb784091_0.tar.bz2": { + "build": "py27hb784091_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "six" + ], + "license": "MIT", + "md5": "eacde5701eeadac6fb4b2dfa51c6c0a1", + "name": "plotly", + "sha256": "8a0d2d64d8a9f166129624ad08cba38af60fdb957ad8749ac78ec5917151360e", + "size": 998697, + "subdir": "linux-64", + "timestamp": 1511841140859, + "version": "2.2.2" + }, + "plotly-2.2.2-py35h6d67e38_0.tar.bz2": { + "build": "py35h6d67e38_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "six" + ], + "license": "MIT", + "md5": "9c160e36f5b4e3c8b05719655ae2d3c0", + "name": "plotly", + "sha256": "24ef8cdf0804056c32e910dd3b45b624d7fa21a144b297c224855a3807d43a57", + "size": 1001813, + "subdir": "linux-64", + "timestamp": 1511841173025, + "version": "2.2.2" + }, + "plotly-2.2.2-py36hd7be514_0.tar.bz2": { + "build": "py36hd7be514_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "six" + ], + "license": "MIT", + "md5": "7b948fe8f4c2e7306c5b63fd33a5dfd3", + "name": "plotly", + "sha256": "66e300448a815c8ba36eb4a533133b6c6965a934d70794f00833298d73038d7e", + "size": 1001222, + "subdir": "linux-64", + "timestamp": 1511841175739, + "version": "2.2.2" + }, + "plotly-2.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "ea2679b611111c078e9a980d2a32fe37", + "name": "plotly", + "sha256": "80f72916ea9efbd347dfac92e64c6bbc469fc4f8c945996a05f556205b89a305", + "size": 1042929, + "subdir": "linux-64", + "timestamp": 1519156199172, + "version": "2.4.0" + }, + "plotly-2.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "7c3965c9d8c165a5bc59086bcab973a4", + "name": "plotly", + "sha256": "e27951e3e0a876bd9d2718c125e21995cc0f0c029f44acf109cd667c51e4455f", + "size": 1050569, + "subdir": "linux-64", + "timestamp": 1519156219718, + "version": "2.4.0" + }, + "plotly-2.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "fa55a64f32a28798a6897cda0dda893f", + "name": "plotly", + "sha256": "b1d8d95f4cf67aabb4edf0647ae1b1bd2879ffb5f292c9b2238ebf4e4b5c110f", + "size": 1050025, + "subdir": "linux-64", + "timestamp": 1519156185274, + "version": "2.4.0" + }, + "plotly-2.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "b0ded20a237d71a7e1c32c937bc29c75", + "name": "plotly", + "sha256": "03c5af0b423d04b75331d45213f6d09a6409ff0d8a0e8e5a59dc30d4d145127a", + "size": 20862881, + "subdir": "linux-64", + "timestamp": 1519752654163, + "version": "2.4.1" + }, + "plotly-2.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "e9e4db1a4aae690b0c41bedb0789ec1c", + "name": "plotly", + "sha256": "9b4611f3786d7d029f26537c53b4fc29731b7c526c7a868aa11aea8e05e04e28", + "size": 20920751, + "subdir": "linux-64", + "timestamp": 1519752692176, + "version": "2.4.1" + }, + "plotly-2.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "b59069fc9380eefb65c1b865551eccea", + "name": "plotly", + "sha256": "6ea5d65704b030539930d40dca8004aacf7893ea4a4364f676f7568f94b6f897", + "size": 20955035, + "subdir": "linux-64", + "timestamp": 1519752644872, + "version": "2.4.1" + }, + "plotly-2.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "34051d1d1b10d5fbae562a9c26812859", + "name": "plotly", + "sha256": "6caf2b2a397b358f51b367773714857cb08913b968891c6f3ce556e538854808", + "size": 20861990, + "subdir": "linux-64", + "timestamp": 1522360535732, + "version": "2.5.1" + }, + "plotly-2.5.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "85a3aed8c203e92071c6ad54ba7093f6", + "name": "plotly", + "sha256": "04203a3dd13e84c3be5078bbde0a3c5169169a9d85d0b72b3b9f4bfee9eeef4e", + "size": 20894456, + "subdir": "linux-64", + "timestamp": 1522360585808, + "version": "2.5.1" + }, + "plotly-2.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "b0d8c665f6c295498ae84fcbd2fc2732", + "name": "plotly", + "sha256": "0400648ef49ce47c7c17af7e62bac75a437cb5a97b9ce81d4a452cce44318da7", + "size": 20912207, + "subdir": "linux-64", + "timestamp": 1522360555199, + "version": "2.5.1" + }, + "plotly-2.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "a8916af4fe1b3435cda78c7a650db5eb", + "name": "plotly", + "sha256": "6aeb10b9c3199b1b7ce601abb1e9d1e9f7b9a0fab7eb1698ff71238b18c08f5b", + "size": 20945771, + "subdir": "linux-64", + "timestamp": 1526915214605, + "version": "2.6.0" + }, + "plotly-2.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "97ce2b192b024754377f329858c9d4b6", + "name": "plotly", + "sha256": "400dd621f86367d20f26d00ededfe2f3efd6cd3a6ad96d0aa6cf5df263d89bce", + "size": 20914984, + "subdir": "linux-64", + "timestamp": 1526915303473, + "version": "2.6.0" + }, + "plotly-2.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "8abe5739aca009f3f7ce5c7f74c1f98d", + "name": "plotly", + "sha256": "943e2166520f274a183c4f14dc88efa9479fe5c305b92759fe22c97cb380a0e3", + "size": 20889302, + "subdir": "linux-64", + "timestamp": 1526915194567, + "version": "2.6.0" + }, + "plotly-2.7.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "a298905cd98d573ac7fea2485480cae5", + "name": "plotly", + "sha256": "9b581aa9de2d6989c1921f54fd0988c670f88f69694fa5f7b9f531beb0d50631", + "size": 20970846, + "subdir": "linux-64", + "timestamp": 1527630714145, + "version": "2.7.0" + }, + "plotly-2.7.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "13d00f904efd64c28bc4e4d156b19dec", + "name": "plotly", + "sha256": "84720e9351ce14e38424a01ee668496034ed400f19c493ac328b6f465419b35e", + "size": 20977841, + "subdir": "linux-64", + "timestamp": 1527630755206, + "version": "2.7.0" + }, + "plotly-2.7.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "e466646f7db7f2c2c625af0cd662ba90", + "name": "plotly", + "sha256": "971e2d481bd8266b7dfd2881ab653077d4fc40081df67353a2face2e8016c98b", + "size": 20937355, + "subdir": "linux-64", + "timestamp": 1527630733463, + "version": "2.7.0" + }, + "plotly-2.7.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "1916a788f7f716bc27d4f9a3f0125464", + "name": "plotly", + "sha256": "7bce7b440d61dcec72ae9609d0f1b43fd1d8e553c4264d2e9926991fa7a3d34d", + "size": 20943095, + "subdir": "linux-64", + "timestamp": 1530738619458, + "version": "2.7.0" + }, + "plotly-3.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "e4c5ac4a00f871df629624fef7834f09", + "name": "plotly", + "sha256": "0c2490784b894ec489cf9d90731bec6e356eda131079844f3da1763e2a60085a", + "size": 28761980, + "subdir": "linux-64", + "timestamp": 1532536734163, + "version": "3.1.0" + }, + "plotly-3.1.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "1109f2d82d256561f76d98eac83ca64a", + "name": "plotly", + "sha256": "6ee5db66e310e452f4bf81997cdb0803fb9be6e61c1181227009d8b6a62f83a3", + "size": 28753633, + "subdir": "linux-64", + "timestamp": 1534353846187, + "version": "3.1.0" + }, + "plotly-3.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "d84bdc34b08efb339133c2d1293018e6", + "name": "plotly", + "sha256": "c3ac43e30a791cf6d8e913308d5fa668cb3d56457e6fc7add2210cf345b22615", + "size": 28750048, + "subdir": "linux-64", + "timestamp": 1532537304958, + "version": "3.1.0" + }, + "plotly-3.1.0-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "2df757bcd5d91f7b629c7c845a6fdacb", + "name": "plotly", + "sha256": "f90fa6a23c11c2ca64f81771a8706e400dfa127e85f514d043d45903b5a40159", + "size": 28776341, + "subdir": "linux-64", + "timestamp": 1534354443667, + "version": "3.1.0" + }, + "plotly-3.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "8b930ce0ad81fdfa5d643f3f7eadaa7e", + "name": "plotly", + "sha256": "54cb32f38f6587725fdad4fc55c0eebe2a16a78037191c1c1e43fe4f37d155c8", + "size": 28687958, + "subdir": "linux-64", + "timestamp": 1532537892336, + "version": "3.1.0" + }, + "plotly-3.1.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "1d44740c29b0b28b680bade27b6d077b", + "name": "plotly", + "sha256": "40400be408808e8ac688dd4265ee8c04b20966fa3d721b1a3f7bece8ae9232b6", + "size": 28714183, + "subdir": "linux-64", + "timestamp": 1534355034872, + "version": "3.1.0" + }, + "plotly-3.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "1c824acab6f6ea3799df10e03e8e0bf6", + "name": "plotly", + "sha256": "76bb4e10900d2a3a71a2ba4cfe6d850887f921626158fd6f710b67359b63c6c3", + "size": 28672017, + "subdir": "linux-64", + "timestamp": 1532537202334, + "version": "3.1.0" + }, + "plotly-3.1.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "b0f3a3adc9643f03db9a5331b1eb9529", + "name": "plotly", + "sha256": "4b9b3c8b7e0d6ec5f20b0236faf09a8293babc6b3822555d797671f014611a1d", + "size": 28729266, + "subdir": "linux-64", + "timestamp": 1534353429440, + "version": "3.1.0" + }, + "plotly-3.1.1-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "135d6d87d2e78758687b622ac5501e29", + "name": "plotly", + "sha256": "a56c657005d8d195312cd37e87d2a89a2ee2af2d5e7094e301199679dd3cc495", + "size": 28764457, + "subdir": "linux-64", + "timestamp": 1534656888250, + "version": "3.1.1" + }, + "plotly-3.1.1-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "86febe453f42dfb201068fe69b7c6b3b", + "name": "plotly", + "sha256": "2fd8641463a5efbe03f494e5650008547d3497255b7a09f109e37c91fe8082e8", + "size": 28754848, + "subdir": "linux-64", + "timestamp": 1534657158817, + "version": "3.1.1" + }, + "plotly-3.1.1-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "fa7fcb7fcb3ce7f457db61a03059ebfd", + "name": "plotly", + "sha256": "69666ebd214f0b8f4386ef5eceb9a1519682cd15f1abbec8a5bb805608de1478", + "size": 28689125, + "subdir": "linux-64", + "timestamp": 1534657164405, + "version": "3.1.1" + }, + "plotly-3.1.1-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "3edba081fb28cf3217532931fa732504", + "name": "plotly", + "sha256": "9b524471d8a65449a1ace7c0b06f6aec20cbf3d40ce14618eb56ecbfa089dd6e", + "size": 28667109, + "subdir": "linux-64", + "timestamp": 1534657154294, + "version": "3.1.1" + }, + "plotly-3.2.1-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "e1c5a654221d1458b30268e1ba3690d9", + "name": "plotly", + "sha256": "b396a4a86d3d283fbbb14296e51882656bd29f7384ea54edc000eaf6d6e49b26", + "size": 28898938, + "subdir": "linux-64", + "timestamp": 1537470817056, + "version": "3.2.1" + }, + "plotly-3.2.1-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "b451b87b45a74f871eb1f0e7db1d5474", + "name": "plotly", + "sha256": "f5f36daa005ad3c6af4ac12b74b5dc39b02b3bd9494fc121409c871fddedbeee", + "size": 28771247, + "subdir": "linux-64", + "timestamp": 1537470997881, + "version": "3.2.1" + }, + "plotly-3.2.1-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "15bd6aead109934df08c074c971ceb3d", + "name": "plotly", + "sha256": "d588053a0361c9b74c3db036a5574f8f0e88f6bd6fa8b8955e914e8ee7fdf673", + "size": 28836985, + "subdir": "linux-64", + "timestamp": 1537471249779, + "version": "3.2.1" + }, + "plotly-3.2.1-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "7217f153096a00d00e26044b6d9862b7", + "name": "plotly", + "sha256": "4c37a2da62b9661ea490388d6c50c62bd1e9f04300253ec063cea98fb90f7345", + "size": 28828683, + "subdir": "linux-64", + "timestamp": 1537471186606, + "version": "3.2.1" + }, + "plotly-3.3.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "5322a8343ff7e7f993ce3d95ef961b75", + "name": "plotly", + "sha256": "73f5b46596e9115c2c926f682f58b1ef2bb4b05ff652eae999542223284d7206", + "size": 28911455, + "subdir": "linux-64", + "timestamp": 1538365694807, + "version": "3.3.0" + }, + "plotly-3.3.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "63b69a15682e04eeaf28627598e6e353", + "name": "plotly", + "sha256": "0c664e57e5ecea88ad30c2b8387d1862d590831d609a232c1f92ef2adb763ef2", + "size": 29074983, + "subdir": "linux-64", + "timestamp": 1538365854027, + "version": "3.3.0" + }, + "plotly-3.3.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "908be0a0e39916cf5076780424e9bd99", + "name": "plotly", + "sha256": "5f03fe8d26f4659b129b5c6ff75d8ebc2ab00d34a2232fcf946f4ae1981ac682", + "size": 29027836, + "subdir": "linux-64", + "timestamp": 1538365847564, + "version": "3.3.0" + }, + "plotly-3.4.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "a172362b98d9bbd7efc0b05d58c6744f", + "name": "plotly", + "sha256": "8db087c851b65c7ef47599dfa5049fb391d6fd68e553a9fec11b1691d9d015a5", + "size": 29212372, + "subdir": "linux-64", + "timestamp": 1541439401400, + "version": "3.4.0" + }, + "plotly-3.4.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "4566072a402b633f0b7c212f3b0ddd4a", + "name": "plotly", + "sha256": "22802e1bfb141bcffb626689142132e119eaffc95f130e1cb2f9630ee503c8f2", + "size": 29091892, + "subdir": "linux-64", + "timestamp": 1541439334244, + "version": "3.4.0" + }, + "plotly-3.4.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "31aadad045757a66820ebaf47a4ef533", + "name": "plotly", + "sha256": "601dbedf4e6d8f2150c09fcafc5463e58eda7cc94bcfbe8aa7db870cec149658", + "size": 29045062, + "subdir": "linux-64", + "timestamp": 1541439369313, + "version": "3.4.0" + }, + "plotly-3.4.1-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "769ae1d047a01335dfeca8108b31962d", + "name": "plotly", + "sha256": "479f371c974b0c096462dd0eedc45b2409867969f09331f03a8fed73ccec0ab6", + "size": 29093092, + "subdir": "linux-64", + "timestamp": 1542084409103, + "version": "3.4.1" + }, + "plotly-3.4.1-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "313d698dc0617b8ddbe822e2c56ac400", + "name": "plotly", + "sha256": "c16fe94045c2f268dff04a9186d77e2fe05a65f89a0e6859793a877da90df214", + "size": 29022625, + "subdir": "linux-64", + "timestamp": 1542084377371, + "version": "3.4.1" + }, + "plotly-3.4.1-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "d40af780c0f51ec3fba1dcef2230d470", + "name": "plotly", + "sha256": "0953d227bf7f2af63d86788770e9f813ecdce7c95ffb59d54a9a9541588021c3", + "size": 29258698, + "subdir": "linux-64", + "timestamp": 1542084374710, + "version": "3.4.1" + }, + "plotly-3.4.2-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "403d22bafd0ceebf6dee548a1a3ecb5d", + "name": "plotly", + "sha256": "58505e42abc64d0f651da1263a7e9f90f1230228c52cbfcaaed43f39cf3b514a", + "size": 29115454, + "subdir": "linux-64", + "timestamp": 1543606439060, + "version": "3.4.2" + }, + "plotly-3.4.2-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "3a92c61091c9782f1aaa7ac258b65cca", + "name": "plotly", + "sha256": "9f4a60b68260254dd4343c7b550ba38b7732abaea9a244ddbc7a09765a73be15", + "size": 29112347, + "subdir": "linux-64", + "timestamp": 1543606548117, + "version": "3.4.2" + }, + "plotly-3.4.2-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "ce37b68e17d0e42479e4a5d4ff9c6eb7", + "name": "plotly", + "sha256": "70215320538ca05a85101835c417954f693a751aeac664aea05e03ca845c2cf0", + "size": 29214103, + "subdir": "linux-64", + "timestamp": 1543606530104, + "version": "3.4.2" + }, + "plotly-3.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "fa5e8422c5e84fda2034b51014546fb3", + "name": "plotly", + "sha256": "ce2f86fb9ee9391867f8a66f38da07f0e4e58a87e935e243b8c2b1418155ce07", + "size": 29336546, + "subdir": "linux-64", + "timestamp": 1547926120383, + "version": "3.5.0" + }, + "plotly-3.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "9f70f7907d8c1daa270c7742f567cb6a", + "name": "plotly", + "sha256": "d7d6a7335ea94ae4242d02a3ab1c9a9dbb8f03da2b763ce1a7f2350f31c89b00", + "size": 29466984, + "subdir": "linux-64", + "timestamp": 1547926142204, + "version": "3.5.0" + }, + "plotly-3.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "b58c57de4d27dc1fc3282762c28de7fc", + "name": "plotly", + "sha256": "9184e88186260363b0b2fa228186ecdd74e0a2f8fa28b4c9c315756ee7e001c5", + "size": 29414975, + "subdir": "linux-64", + "timestamp": 1547926134097, + "version": "3.5.0" + }, + "plotly-3.6.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "c2641301b2397af45241169020749649", + "name": "plotly", + "sha256": "a48b8bf5c6e6b0503cb98c6c0329050ea41aac7231f3261a9dddb8d57ec9a1cf", + "size": 29459321, + "subdir": "linux-64", + "timestamp": 1550351504166, + "version": "3.6.1" + }, + "plotly-3.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "3cdae38b529fc87ef94b27344e186cb9", + "name": "plotly", + "sha256": "22bca73a66a1907fb7aff403361a31aafc37ab0e1d3bbae2869acfac3a6108c0", + "size": 29459378, + "subdir": "linux-64", + "timestamp": 1550351623342, + "version": "3.6.1" + }, + "plotly-3.6.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "e039c11749500a6f39abb177032d0645", + "name": "plotly", + "sha256": "97f54716647845575f854ffa46d2de68493967a9ba8873cf18e41c8b0c4365c7", + "size": 29461488, + "subdir": "linux-64", + "timestamp": 1550351584658, + "version": "3.6.1" + }, + "plotly-5.9.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "tenacity >=6.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "99c62c48d5f904983e9f8086a5c5c792", + "name": "plotly", + "sha256": "aa8b3b52a7afbd5749fd1d4d35f73a4d45ad678edfe51f045e466f0317f880a2", + "size": 9599551, + "subdir": "linux-64", + "timestamp": 1658160435387, + "version": "5.9.0" + }, + "plotly-5.9.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "tenacity >=6.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "05ef02350833144cbb04093c1dbd804f", + "name": "plotly", + "sha256": "5e2f48c60805ecdd55c18b6f80361b0eb4f75f3e14e78be6f5ed942dbbbf4f04", + "size": 10139320, + "subdir": "linux-64", + "timestamp": 1676841735198, + "version": "5.9.0" + }, + "plotly-5.9.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "tenacity >=6.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e16e0c2f2b211ef2c11ee428151b835", + "name": "plotly", + "sha256": "907f01e55de39a74fbcc348f4e224200fc6a6359c733ed11d72ace5d73b542cd", + "size": 9538002, + "subdir": "linux-64", + "timestamp": 1658160216909, + "version": "5.9.0" + }, + "plotly-5.9.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "tenacity >=6.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43c4515b5659d2aee3a55553c05611a3", + "name": "plotly", + "sha256": "5f922b42ec2f488c31974a02f1848cd3b34725473ba2fadbaa21e12e1bb80b5a", + "size": 9547174, + "subdir": "linux-64", + "timestamp": 1658160841728, + "version": "5.9.0" + }, + "plotly-5.9.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "tenacity >=6.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2542231c982bcd691df7752ac59fa386", + "name": "plotly", + "sha256": "5df6f15dc245c053b98badbd4ac966951c0adca2e6535f6cfbb226542773d21c", + "size": 9556458, + "subdir": "linux-64", + "timestamp": 1658160642488, + "version": "5.9.0" + }, + "pluggy-0.13.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "915ffc421ea232f20ed1a61b6b9b57c5", + "name": "pluggy", + "sha256": "fce30d94a26a0bcc310fe26a4377f16c5d2a806e8f073450ceffb919f692be05", + "size": 31570, + "subdir": "linux-64", + "timestamp": 1569265817646, + "version": "0.13.0" + }, + "pluggy-0.13.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c81159b10a5d7f7f15221ebb7bef3d67", + "name": "pluggy", + "sha256": "48d311ff978bdf898578f3979e91324e282de7617db3524cef9b65b0f1928ca0", + "size": 32166, + "subdir": "linux-64", + "timestamp": 1569265838961, + "version": "0.13.0" + }, + "pluggy-0.13.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8eaee9ceb8662d61488d7453dba5347b", + "name": "pluggy", + "sha256": "e80e5a267ac83397d052419a68fc50336a2a5eb6fe7820b27135b8195a46649b", + "size": 32217, + "subdir": "linux-64", + "timestamp": 1569265767466, + "version": "0.13.0" + }, + "pluggy-0.13.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b84e558c7e3db6407b0e42db9cd8551", + "name": "pluggy", + "sha256": "98c5cb2e6c6cbebffff48dd5b1df92d81ad59dae901a2301933560206c613509", + "size": 29719, + "subdir": "linux-64", + "timestamp": 1572609212685, + "version": "0.13.0" + }, + "pluggy-0.13.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "86bd706e95295a7db7e68c4996a6750e", + "name": "pluggy", + "sha256": "c971a648b3af96121be7bd0c620d0a9e160bb54b766437c1a396b1eab86144c8", + "size": 32329, + "subdir": "linux-64", + "timestamp": 1574699625975, + "version": "0.13.1" + }, + "pluggy-0.13.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9dce92ad4a6cf0304ec6e04d2277f84", + "name": "pluggy", + "sha256": "d699642371677d6bccc7f5f0eb0dc1e0745389543c9278ef86f263effbd493e0", + "size": 30365, + "subdir": "linux-64", + "timestamp": 1642499759971, + "version": "0.13.1" + }, + "pluggy-0.13.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ce44204cbfcb6d9e1c2bd01e63efc5b", + "name": "pluggy", + "sha256": "2698e5a9182a539f59222ea413c08e978853e450d34f4f6f74beb9e3629d2d4d", + "size": 32967, + "subdir": "linux-64", + "timestamp": 1574699642985, + "version": "0.13.1" + }, + "pluggy-0.13.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f58a0f5d193c61b652dd36bbb4e4bb54", + "name": "pluggy", + "sha256": "a2de18a7d1b6599075c91bce16d57e69b270aff0922f31c71ad509bb91903231", + "size": 33268, + "subdir": "linux-64", + "timestamp": 1615976356156, + "version": "0.13.1" + }, + "pluggy-0.13.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea7b3e5e66e686eed4b611fa6a87254d", + "name": "pluggy", + "sha256": "4d039d62fb753fa5e08e730289f7236f5ddfff06c606835e7de9412a523cc74d", + "size": 33015, + "subdir": "linux-64", + "timestamp": 1574699614689, + "version": "0.13.1" + }, + "pluggy-0.13.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31b0df103670db281ba730505109c626", + "name": "pluggy", + "sha256": "39a428faead2a781a8dbc7bb877edc8f136537dfda39eedaae12a5b9bfb14927", + "size": 33316, + "subdir": "linux-64", + "timestamp": 1615976347734, + "version": "0.13.1" + }, + "pluggy-0.13.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15436bcd5f084480d16af74d0201da7f", + "name": "pluggy", + "sha256": "26775ac7e8376715b17a14b10179f5cefea4f4c19b3b2ece7494a0b9fbdcf17c", + "size": 33093, + "subdir": "linux-64", + "timestamp": 1574699695602, + "version": "0.13.1" + }, + "pluggy-0.13.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e0fef8df1a6bd1f56dcdd8c9b994dc8", + "name": "pluggy", + "sha256": "e7d2f85b6a71690d73b84f06b389d71124477690310b6f9c4241c2bf6053dd94", + "size": 33358, + "subdir": "linux-64", + "timestamp": 1615976360217, + "version": "0.13.1" + }, + "pluggy-0.13.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92c3db0cb343b99c28326e1841faa610", + "name": "pluggy", + "sha256": "7841c57e9051ab831390b807ca4e1b3641eba1426ff26cb74f1d913bb27d0487", + "size": 33395, + "subdir": "linux-64", + "timestamp": 1615976364098, + "version": "0.13.1" + }, + "pluggy-0.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7aac18dc8f2d0292857b821f40aa79fd", + "name": "pluggy", + "sha256": "4087e02e81222b528248092613c9885691b88336911faea1eb6228c244aa50a7", + "size": 22250, + "subdir": "linux-64", + "timestamp": 1530693699401, + "version": "0.6.0" + }, + "pluggy-0.6.0-py27h1f4f128_0.tar.bz2": { + "build": "py27h1f4f128_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2f296267b78c488aefad61f0850870d", + "name": "pluggy", + "sha256": "f24ba56f1342422c54c9ddb11375c6246b1efb111b7a79d46123c918a426f77f", + "size": 22632, + "subdir": "linux-64", + "timestamp": 1511930208362, + "version": "0.6.0" + }, + "pluggy-0.6.0-py35hb428803_0.tar.bz2": { + "build": "py35hb428803_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e488cae1a1234cfbe25fc64908879179", + "name": "pluggy", + "sha256": "3ecf1789d9857809b0719fc94639c2322d0f6da5b4131b02f0362a057c0fc79e", + "size": 23278, + "subdir": "linux-64", + "timestamp": 1511930197503, + "version": "0.6.0" + }, + "pluggy-0.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc0072f538743d33aaf8a0c60fc3f98d", + "name": "pluggy", + "sha256": "40684318c3a65520229d357b83eeefd243c0145f4555a65660cdcc3329ed3ec3", + "size": 22774, + "subdir": "linux-64", + "timestamp": 1530693661709, + "version": "0.6.0" + }, + "pluggy-0.6.0-py36hb689045_0.tar.bz2": { + "build": "py36hb689045_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe49da994608d7eaec9c37d5da2968d4", + "name": "pluggy", + "sha256": "ad789594f10b61321067d2f3d567462926a58cc2e7bdedabc3b92a4798ee9688", + "size": 23132, + "subdir": "linux-64", + "timestamp": 1511930242042, + "version": "0.6.0" + }, + "pluggy-0.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13a9ea9161d4440970aa7497658c7859", + "name": "pluggy", + "sha256": "8f91395ba4fefbca6e5f93e39c23ddf4f8f3d623cf3c5e28c22c2f8758389850", + "size": 22808, + "subdir": "linux-64", + "timestamp": 1530693681008, + "version": "0.6.0" + }, + "pluggy-0.7.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef68d4140cd69971e3b6d562bc533b4d", + "name": "pluggy", + "sha256": "d6a03d318f351c113b77971728ebacdd66d1cb4bc22bed3e72a551b9b0b4669f", + "size": 24985, + "subdir": "linux-64", + "timestamp": 1532976798483, + "version": "0.7.1" + }, + "pluggy-0.7.1-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d2de9876e7260b8bdd39be7c280be29", + "name": "pluggy", + "sha256": "6aaea8c7f772cc780001119b42c4d5ddddbc4595caf12a280d5e01ca62fbe3e7", + "size": 25010, + "subdir": "linux-64", + "timestamp": 1534344865406, + "version": "0.7.1" + }, + "pluggy-0.7.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "530fde33297e3eed3ff88bdc573d405d", + "name": "pluggy", + "sha256": "c0120b5e8f0df494e1939557e5a3b19fa2953cfdbc8faa2837e7451f231ef397", + "size": 25683, + "subdir": "linux-64", + "timestamp": 1532976908613, + "version": "0.7.1" + }, + "pluggy-0.7.1-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0032f465079930e813d5e3dc3769fea3", + "name": "pluggy", + "sha256": "db75d2996b98a6cc280e43357c0dd61707a48c1da7e8084f4a799ca489e66d61", + "size": 25726, + "subdir": "linux-64", + "timestamp": 1534344913031, + "version": "0.7.1" + }, + "pluggy-0.7.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "72ebf0a4f5635228e02cc51e59cf5472", + "name": "pluggy", + "sha256": "09bdf5a32150e13703e91fa9dc9096a843eeb81cde0d675cb564f77e20663746", + "size": 25613, + "subdir": "linux-64", + "timestamp": 1532976697992, + "version": "0.7.1" + }, + "pluggy-0.7.1-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "880c12d7f69a5f9420eef2098325c5ab", + "name": "pluggy", + "sha256": "e12ebc56b0b9d59cf80d0cb4d2df3951e9346ed1bc77e34ec08f55023bd9d781", + "size": 25587, + "subdir": "linux-64", + "timestamp": 1534344888868, + "version": "0.7.1" + }, + "pluggy-0.7.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "549f3dfb0d7da832b6fe09585c14de3f", + "name": "pluggy", + "sha256": "a169c49b5eb2ffbebe443bf3a38c4daf786b43139a8f1c52eb19643c9d03fad0", + "size": 25685, + "subdir": "linux-64", + "timestamp": 1532977009932, + "version": "0.7.1" + }, + "pluggy-0.7.1-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f8cf44edb08f017c3da0082701c2842", + "name": "pluggy", + "sha256": "24742233a0104d6bd1da8d3afca83e35e78079709ed5e9a8ae693abbe72a383d", + "size": 25625, + "subdir": "linux-64", + "timestamp": 1534344937158, + "version": "0.7.1" + }, + "pluggy-0.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6941a5c554b0cf2a039e903d49d3683e", + "name": "pluggy", + "sha256": "bd8512f090f00e1ca8e2f13162745bcdd54904edadb154daa402155de1b7b6d7", + "size": 28114, + "subdir": "linux-64", + "timestamp": 1540234292369, + "version": "0.8.0" + }, + "pluggy-0.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a93ce60c6071b353a98cb57c1d446a09", + "name": "pluggy", + "sha256": "2eb1f0cbecd8d5bb2db69e9e5bd5e6397c8ece6c0f730b19b8a6763b6be33cc8", + "size": 28709, + "subdir": "linux-64", + "timestamp": 1540234348329, + "version": "0.8.0" + }, + "pluggy-0.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56c85bf32d8b642da8d84ea0a5a64458", + "name": "pluggy", + "sha256": "2ad3d25e2364709af6aea39bb7e2c412a283a5fb82dff6fde40c221e0ae6622c", + "size": 28735, + "subdir": "linux-64", + "timestamp": 1540234321571, + "version": "0.8.0" + }, + "pluggy-0.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2adf5bd68d9821311f289f677ba35227", + "name": "pluggy", + "sha256": "705bbcb54109ac41f4ea37435b1de904cce787247c5126b5211fde245ecb5b6e", + "size": 29788, + "subdir": "linux-64", + "timestamp": 1547753132826, + "version": "0.8.1" + }, + "pluggy-0.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4eeb0d0a686c7299c29bd62c254b7b6", + "name": "pluggy", + "sha256": "59bfdcdce2ff3e6384df712625e0c0c35b8d486520b8212679056a9d40c4f4eb", + "size": 30396, + "subdir": "linux-64", + "timestamp": 1547753154702, + "version": "0.8.1" + }, + "pluggy-0.8.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "599c47d975509b68a73d2fbd2f96818e", + "name": "pluggy", + "sha256": "79cd7057409c9550c56103d1d9c04dc44fe10442bb9c1f4c6f632dece10ea548", + "size": 30473, + "subdir": "linux-64", + "timestamp": 1547753198233, + "version": "0.8.1" + }, + "pluggy-0.9.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d1ffa0db1fa1bbe26f5b45bad0c8f02", + "name": "pluggy", + "sha256": "a568cac0ef88c862c6c466eee60d40512821f1a837f69ee781b88c46f42b202d", + "size": 30359, + "subdir": "linux-64", + "timestamp": 1551144146727, + "version": "0.9.0" + }, + "pluggy-0.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77b3b3d709ce71d821112e1045ecac79", + "name": "pluggy", + "sha256": "5e9ae5b880deb33db986e642517a2bca1cfd8cff54ae53c83a359ff34d69c43a", + "size": 30944, + "subdir": "linux-64", + "timestamp": 1551144166686, + "version": "0.9.0" + }, + "pluggy-0.9.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cf336a483f06adad2c35f3b982a83f93", + "name": "pluggy", + "sha256": "850bc5d5c2fb652cc4e5dd8a7b7ced5b08054ed4b8f62a70c2cab90afec8a7f3", + "size": 31000, + "subdir": "linux-64", + "timestamp": 1551144116309, + "version": "0.9.0" + }, + "pluggy-1.0.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62c36b23393fb4da3abe0ecde5aa631a", + "name": "pluggy", + "sha256": "d12b39bce6db4ad1afd4c08c904901fad50d8d03a02bb8598f4fabdd9a08eb0a", + "size": 28944, + "subdir": "linux-64", + "timestamp": 1648024755502, + "version": "1.0.0" + }, + "pluggy-1.0.0-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3aa702e440ce2fe9f606b3bde5c1c13b", + "name": "pluggy", + "sha256": "28796a5e9486a2a43d922c34ffca1826f175df5968602699405074aa5fb0d86d", + "size": 32649, + "subdir": "linux-64", + "timestamp": 1676822832891, + "version": "1.0.0" + }, + "pluggy-1.0.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "26061abc69011baa4b901d7a43c830ac", + "name": "pluggy", + "sha256": "d923c8eb378face173cfec7511cdfc6d5ad6daa975ae7bbd026c1b1a1829925f", + "size": 28399, + "subdir": "linux-64", + "timestamp": 1633704415683, + "version": "1.0.0" + }, + "pluggy-1.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4aff930275961c32d48fb95880ddee8a", + "name": "pluggy", + "sha256": "f70f8bfe7424a03dd2b22ce049934657fa3ccf8690320546a8e8c7a189f654ad", + "size": 28456, + "subdir": "linux-64", + "timestamp": 1633715242220, + "version": "1.0.0" + }, + "pluggy-1.0.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata >=0.12", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "902754ada24012ec56ac705d2a2d9de5", + "name": "pluggy", + "sha256": "a72bc28f28f47b6ebc2c440d0e6aeb0838a7fec42d9dcfe032302259ab88cc4f", + "size": 28708, + "subdir": "linux-64", + "timestamp": 1648042607519, + "version": "1.0.0" + }, + "pluggy-1.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d1a3b1fbc3a7f0c8e959bf222de88ff", + "name": "pluggy", + "sha256": "93fe062451c818d9890e9ff01dac345913afc257a414727633eb8bede616e23e", + "size": 28499, + "subdir": "linux-64", + "timestamp": 1633715082877, + "version": "1.0.0" + }, + "pluggy-1.0.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "582343620086a5e22bf2d887d2daf4fc", + "name": "pluggy", + "sha256": "0f9c483481f156b7478479405eed13b0216fd02726af0c06b4d33e564f38d45b", + "size": 28771, + "subdir": "linux-64", + "timestamp": 1648042603024, + "version": "1.0.0" + }, + "pluggy-1.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "955639634208b6731bbdfbd21230f993", + "name": "pluggy", + "sha256": "9937adec0742be3aa24115cf25e7861a6412c383028bbef91204874cd9e570b7", + "size": 28560, + "subdir": "linux-64", + "timestamp": 1633715241414, + "version": "1.0.0" + }, + "pluggy-1.0.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "849312a6fc71d4a78052e484b4f5fabc", + "name": "pluggy", + "sha256": "ae2f4ebecd8a6d7b20f53a643e2bd8c72e201cc7e160baf40a467c83a796ac57", + "size": 28790, + "subdir": "linux-64", + "timestamp": 1648024480363, + "version": "1.0.0" + }, + "ply-3.10-py27hd6d9ae5_0.tar.bz2": { + "build": "py27hd6d9ae5_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "70d29118b35ecb8f4bb8e5c357175b11", + "name": "ply", + "sha256": "dc9bf5eba6575537b7501bc2ae7e6aed0cdc9bb1d7d6b00c162c13deee59a6e5", + "size": 79938, + "subdir": "linux-64", + "timestamp": 1505751193645, + "version": "3.10" + }, + "ply-3.10-py35h459f1a0_0.tar.bz2": { + "build": "py35h459f1a0_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9553c3b703d6c990b6647f09fbf63109", + "name": "ply", + "sha256": "4b01eae22f8ac1576c9d3e70da14077bc3e30f7a5ca333f078adfd48b9578731", + "size": 81382, + "subdir": "linux-64", + "timestamp": 1505751206621, + "version": "3.10" + }, + "ply-3.10-py36hed35086_0.tar.bz2": { + "build": "py36hed35086_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0bd1d423f81742a0067ab5de09d21a62", + "name": "ply", + "sha256": "1759b35097119eaf3dc31c98cd5fd8ee96b65bb2b8ea6a1adf7010f4cee6932a", + "size": 80824, + "subdir": "linux-64", + "timestamp": 1505751219980, + "version": "3.10" + }, + "ply-3.11-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d0dd84ccd6c4ca640a15a35fb76194f1", + "name": "ply", + "sha256": "df6c5398f22022f379d1d8a44de339270b3b160b63aebfab9cb8d827514503ca", + "size": 80455, + "subdir": "linux-64", + "timestamp": 1519148046159, + "version": "3.11" + }, + "ply-3.11-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e0409553f4fd69c47962c41a23762b4c", + "name": "ply", + "sha256": "3e46f53009ccedd197716d43231c36cce930e075ac480fe78dbd0d1d90cc2d6b", + "size": 81758, + "subdir": "linux-64", + "timestamp": 1640792429668, + "version": "3.11" + }, + "ply-3.11-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "262064c348f1846011c650ad8a6cd793", + "name": "ply", + "sha256": "786a4a57db582b66de12bd7e03eae83caa939136dabd8b53049cadeabc0beb6f", + "size": 111320, + "subdir": "linux-64", + "timestamp": 1676824981885, + "version": "3.11" + }, + "ply-3.11-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7668da36580c988cf84f5bd2b14601d1", + "name": "ply", + "sha256": "e4fc9c126ecc9b2585af9d57bcdb2cf29ec8f1f741adc4610079593722057a8c", + "size": 81753, + "subdir": "linux-64", + "timestamp": 1519148093111, + "version": "3.11" + }, + "ply-3.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "763020297fbd071d60f48069dfab0030", + "name": "ply", + "sha256": "f7bb8c7d4bc234ecdfdaf10515de635daca4e5addd2ef5e3db7505d9234b43a8", + "size": 81331, + "subdir": "linux-64", + "timestamp": 1519148094947, + "version": "3.11" + }, + "ply-3.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c45dfa912d7b6e17369921a3c64a556a", + "name": "ply", + "sha256": "dc79e569effaed88aa43d43bb61db2564324f064c4fff88208df24c6d36cb28d", + "size": 81281, + "subdir": "linux-64", + "timestamp": 1530873685472, + "version": "3.11" + }, + "ply-3.11-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cdc32d4656069ea380a3e0bbc7fe30ed", + "name": "ply", + "sha256": "6b4f491231fa495844cc86334292575ebceccd87eba0b67ccb24838112452bbf", + "size": 81502, + "subdir": "linux-64", + "timestamp": 1573040646911, + "version": "3.11" + }, + "ply-3.11-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "290fd05d75d8e816a9b0f29e10ea4063", + "name": "ply", + "sha256": "a38e6d2ba251c6456849a7e2529a7d30150d7345abc8ee6d0afeba6c7173ac7a", + "size": 82191, + "subdir": "linux-64", + "timestamp": 1607029370982, + "version": "3.11" + }, + "plyvel-1.4.0-py310hdb19cb5_0.tar.bz2": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "57cdb7c437a99d230b9ce077da51575e", + "name": "plyvel", + "sha256": "e6facec96e8d9d84ae1cbe8656e7edafe75e4868fa6597a20c1a78658fdb1207", + "size": 499280, + "subdir": "linux-64", + "timestamp": 1659776194651, + "version": "1.4.0" + }, + "plyvel-1.4.0-py37hdb19cb5_0.tar.bz2": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "52c6d83844ece113c76a864fe425773c", + "name": "plyvel", + "sha256": "a89810f8af55b22f1e5e4548540ec59a1165761678e07c408b443008851df1a8", + "size": 470756, + "subdir": "linux-64", + "timestamp": 1659776229514, + "version": "1.4.0" + }, + "plyvel-1.4.0-py38hdb19cb5_0.tar.bz2": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b2a706f36888cfaf2ab4b45feacaa2dd", + "name": "plyvel", + "sha256": "72ebf17e0ad8b0ecac74a48b603e9fe1ab22aab14d22463b23771dc17af5f52a", + "size": 508403, + "subdir": "linux-64", + "timestamp": 1659776148855, + "version": "1.4.0" + }, + "plyvel-1.4.0-py39hdb19cb5_0.tar.bz2": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c632089869d25b54cfb9548021280c3b", + "name": "plyvel", + "sha256": "0fe5f58cb89e527ff29f179d5bba71d71a240063d2337ab1bdbe13fd329a3599", + "size": 499407, + "subdir": "linux-64", + "timestamp": 1659776114234, + "version": "1.4.0" + }, + "plyvel-1.5.0-py310hdb19cb5_0.tar.bz2": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e11754523f118a7581436286ef33bd4", + "name": "plyvel", + "sha256": "2b4da515dd47a4afa817e457f856eaa3f94b61650e49f236c939f0e942733f0a", + "size": 494290, + "subdir": "linux-64", + "timestamp": 1676300872330, + "version": "1.5.0" + }, + "plyvel-1.5.0-py311hdb19cb5_0.tar.bz2": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "95b2d0db8b38efa1db479a4b9c1c8e4c", + "name": "plyvel", + "sha256": "d40d00b57938676fb22d355cb0bd0612327ce9fc781fcd41c0ff33d3142ae743", + "size": 518044, + "subdir": "linux-64", + "timestamp": 1676860386562, + "version": "1.5.0" + }, + "plyvel-1.5.0-py37hdb19cb5_0.tar.bz2": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7148645f5703fd02fd857d413bee78d5", + "name": "plyvel", + "sha256": "247758df9259772e70c71edeb955b436c6aba7591fd8f4ab743bf4d36b3ed0ee", + "size": 474153, + "subdir": "linux-64", + "timestamp": 1676300766616, + "version": "1.5.0" + }, + "plyvel-1.5.0-py38hdb19cb5_0.tar.bz2": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7a47947b651bfb4717edb21a12aa01f7", + "name": "plyvel", + "sha256": "fdf3488aa035959e01b7c6d020ee8281bf75cf010da8a675eb0f19b51eef2510", + "size": 511610, + "subdir": "linux-64", + "timestamp": 1676300837391, + "version": "1.5.0" + }, + "plyvel-1.5.0-py39hdb19cb5_0.tar.bz2": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1f946f9ceb6a954641dcadd798ceb7e6", + "name": "plyvel", + "sha256": "9cda6b63be52f7b8b859ab85ce32fe2a88ee157f2823903988ac054f89e8a3d4", + "size": 500855, + "subdir": "linux-64", + "timestamp": 1676300801495, + "version": "1.5.0" + }, + "pmdarima-1.8.5-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "cython >=0.29,!=0.29.18", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "numpy >=1.21.5,<2.0a0", + "pandas >=0.19", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.22", + "scipy >=1.3.2", + "setuptools >=38.6.0,!=50.0.0", + "statsmodels >=0.11,!=0.12.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce9192698df83bc15086d7b2794b330a", + "name": "pmdarima", + "sha256": "0d84cc80dbf090ac0658244fb7ebedb2e3aca6f2bca6e810f2b728a59463d12f", + "size": 1545581, + "subdir": "linux-64", + "timestamp": 1650013596746, + "version": "1.8.5" + }, + "pmdarima-1.8.5-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "cython >=0.29,!=0.29.18", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "numpy >=1.20.3,<2.0a0", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.22", + "scipy >=1.3.2", + "setuptools >=38.6.0,!=50.0.0", + "statsmodels >=0.11,!=0.12.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de5354ca30020e9231a7ac63691f0bdc", + "name": "pmdarima", + "sha256": "c0d60b9c2d66889a8bccfab2e048c3a403a6ddd3f9ea23f0b7bd09c4b9ef9449", + "size": 639687, + "subdir": "linux-64", + "timestamp": 1650031723249, + "version": "1.8.5" + }, + "pmdarima-1.8.5-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "cython >=0.29,!=0.29.18", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "numpy >=1.20.3,<2.0a0", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.22", + "scipy >=1.3.2", + "setuptools >=38.6.0,!=50.0.0", + "statsmodels >=0.11,!=0.12.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1aadc1cb13fa6d77b8349c9b9c337b65", + "name": "pmdarima", + "sha256": "2b0cab631b88f8d75a6b550030269017505e94c89afcea0abdb15da70d6b119f", + "size": 670670, + "subdir": "linux-64", + "timestamp": 1650031710573, + "version": "1.8.5" + }, + "pmdarima-1.8.5-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "cython >=0.29,!=0.29.18", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "numpy >=1.20.3,<2.0a0", + "pandas >=0.19", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.22", + "scipy >=1.3.2", + "setuptools >=38.6.0,!=50.0.0", + "statsmodels >=0.11,!=0.12.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2001f50817f4d5ecab90a5005125396", + "name": "pmdarima", + "sha256": "0ea20fad8fc0629be2bec041fa47f40ebbe0369eb42735664d99227dc8004d12", + "size": 690303, + "subdir": "linux-64", + "timestamp": 1650013844620, + "version": "1.8.5" + }, + "poetry-1.0.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.7.6,<0.8.0", + "clikit >=0.4.2,<0.5.0", + "html5lib >=1.0,<2.0", + "importlib_metadata >=1.1.3,<1.2.0", + "jsonschema >=3.1,<4.0", + "keyring >=18.0.1,<19.0.0", + "lockfile >=0.9", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.8.0,<0.9.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.5.11,<0.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "09a75f2ed3a6ab25feecfdfb476d25cc", + "name": "poetry", + "sha256": "b26928f3786e3b83abf69b738dc9b8b3262e58c14ce469ad976b9ec49005dddb", + "size": 323952, + "subdir": "linux-64", + "timestamp": 1597354612487, + "version": "1.0.10" + }, + "poetry-1.0.10-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.7.6,<0.8.0", + "clikit >=0.4.2,<0.5.0", + "html5lib >=1.0,<2.0", + "importlib_metadata >=1.1.3,<1.2.0", + "jsonschema >=3.1,<4.0", + "keyring >=18.0.1,<19.0.0", + "lockfile >=0.9", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.8.0,<0.9.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.5.11,<0.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "860c1cc87d1df0bb6738c4e13cb25462", + "name": "poetry", + "sha256": "8c3685cd9e8090bfe91fb60f6ca809bbb01684450074b3fb7e7bb244ee8bf4b5", + "size": 323532, + "subdir": "linux-64", + "timestamp": 1597354609906, + "version": "1.0.10" + }, + "poetry-1.0.10-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.7.6,<0.8.0", + "clikit >=0.4.2,<0.5.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=18.0.1,<19.0.0", + "lockfile >=0.9", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.8.0,<0.9.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.5.11,<0.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af0f77ba2978fade8ad0deb3ae0c9564", + "name": "poetry", + "sha256": "6037e8231a02ec3dce4efab5194b3dfacb9396ec54f77409f33c559d39556737", + "size": 323900, + "subdir": "linux-64", + "timestamp": 1597354627799, + "version": "1.0.10" + }, + "poetry-1.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.7.6,<0.8.0", + "clikit >=0.4.1,<0.5.0", + "functools32 >=3.2.3,<3.3", + "glob2 >=0.6,<1", + "html5lib >=1.0,<2.0", + "importlib_metadata >=0.23,<1", + "jsonschema >=3.1,<4.0", + "keyring >=18.0,<19", + "lockfile >=0.9", + "pathlib2 >=2.3,<3", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.8.0,<0.9.0", + "shellingham >=1.1,<2.0", + "subprocess32 >=3.5,<4", + "tomlkit >=0.5.8,<0.6.0", + "typing >=3.6,<4", + "virtualenv >=16.0,<17" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ecbf8e2f7d430c7d216b1d9f4657f1e3", + "name": "poetry", + "sha256": "bb04b0b5cbc84ebc368c1f00bc8cb88e8fefa6eae83b3e0181c994bb0fc1ff70", + "size": 307035, + "subdir": "linux-64", + "timestamp": 1579616106381, + "version": "1.0.2" + }, + "poetry-1.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.7.6,<0.8.0", + "clikit >=0.4.1,<0.5.0", + "html5lib >=1.0,<2.0", + "importlib_metadata >=0.23,<1", + "jsonschema >=3.1,<4.0", + "keyring >=19.0,<20", + "lockfile >=0.9", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.8.0,<0.9.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.5.8,<0.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4116a9a052d90977da26f41c0221a32c", + "name": "poetry", + "sha256": "86b9e873bdfd3e3597e59063c17ab13be1eb612ecd66648068eac4e4355ba420", + "size": 314671, + "subdir": "linux-64", + "timestamp": 1579615985886, + "version": "1.0.2" + }, + "poetry-1.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.7.6,<0.8.0", + "clikit >=0.4.1,<0.5.0", + "html5lib >=1.0,<2.0", + "importlib_metadata >=0.23,<1", + "jsonschema >=3.1,<4.0", + "keyring >=19.0,<20", + "lockfile >=0.9", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.8.0,<0.9.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.5.8,<0.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ff9cbad9b273496c465ff08747afba6", + "name": "poetry", + "sha256": "5587319a8cc4f94b873295f3e4bb89b16de7e45337b45b9aea73d5717282a527", + "size": 314774, + "subdir": "linux-64", + "timestamp": 1579616023382, + "version": "1.0.2" + }, + "poetry-1.0.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.7.6,<0.8.0", + "clikit >=0.4.2,<0.5.0", + "html5lib >=1.0,<2.0", + "importlib_metadata >=1.1.3,<1.2.0", + "jsonschema >=3.1,<4.0", + "keyring >=18.0.1,<19.0.0", + "lockfile >=0.9", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.8.0,<0.9.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.5.11,<0.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02e3c52cba1fe22e6b8d6eeb783dfb5a", + "name": "poetry", + "sha256": "ff302d84ffb1da228218937992b908708e91e7990577d89621ff26140475768e", + "size": 320261, + "subdir": "linux-64", + "timestamp": 1594845777440, + "version": "1.0.9" + }, + "poetry-1.0.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.7.6,<0.8.0", + "clikit >=0.4.2,<0.5.0", + "html5lib >=1.0,<2.0", + "importlib_metadata >=1.1.3,<1.2.0", + "jsonschema >=3.1,<4.0", + "keyring >=18.0.1,<19.0.0", + "lockfile >=0.9", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.8.0,<0.9.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.5.11,<0.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62330fcf5cd9911ffb25a5c1e77ed0d6", + "name": "poetry", + "sha256": "6037e435fe7c9b405318bc7de1fe185dd473e16291c340bf4ade959a41b2e8dd", + "size": 320901, + "subdir": "linux-64", + "timestamp": 1594843317744, + "version": "1.0.9" + }, + "poetry-1.0.9-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.7.6,<0.8.0", + "clikit >=0.4.2,<0.5.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=18.0.1,<19.0.0", + "lockfile >=0.9", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.8.0,<0.9.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.5.11,<0.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8524b1f2a2b7ffeeac26349d6db7b6a2", + "name": "poetry", + "sha256": "c182f0c0196d3d9f0347112eab106104f5f2fcfde8408e12b59343f2045d582f", + "size": 322265, + "subdir": "linux-64", + "timestamp": 1594845488448, + "version": "1.0.9" + }, + "poetry-1.1.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "importlib-metadata >=1.6.0,<2.0.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66828efb6acb0c2e6db7ded631deeeea", + "name": "poetry", + "sha256": "a0c74c9776ee956eca6b0d32696e80e6b559e1ce135acadbf1a49057a141f1d2", + "size": 239981, + "subdir": "linux-64", + "timestamp": 1606170917842, + "version": "1.1.4" + }, + "poetry-1.1.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "importlib-metadata >=1.6.0,<2.0.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ea49b1875a8ddc89c7e03ced5cca952", + "name": "poetry", + "sha256": "0242782e7f77b98338831e645a8ada935927702d35f72cb406e8763b5e909312", + "size": 238355, + "subdir": "linux-64", + "timestamp": 1606170906002, + "version": "1.1.4" + }, + "poetry-1.1.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9dc8bf2d30e8b118312ff1ff39501a38", + "name": "poetry", + "sha256": "ac14237fcebd5b6f91339a3d2e62f1653d68fba8189d69854b663ad7150b6a7e", + "size": 240111, + "subdir": "linux-64", + "timestamp": 1606170910231, + "version": "1.1.4" + }, + "poetry-1.1.5-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "importlib-metadata >=1.6.0,<2.0.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8cfcf653d7d352ba811a569c257d7f8c", + "name": "poetry", + "sha256": "6bc765b9a9d4fe534d2fa79d0c4b1bbaff66073e765b4701e126e3c9eadeb6d2", + "size": 242896, + "subdir": "linux-64", + "timestamp": 1615562463498, + "version": "1.1.5" + }, + "poetry-1.1.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "importlib-metadata >=1.6.0,<2.0.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "060ca22ea92513974935a3fdcc036d67", + "name": "poetry", + "sha256": "dfd7d6a0a2b6da7a06a9b83cf51d2280e88192fd3885036678cab70c96e14bce", + "size": 243542, + "subdir": "linux-64", + "timestamp": 1615564131393, + "version": "1.1.5" + }, + "poetry-1.1.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6cfc4ede0fab1ca1a3d97f3614af7359", + "name": "poetry", + "sha256": "629326da2976f7b859e82d51f8cbae0a66671d6027e8080a6bbc198f3fc2d57c", + "size": 241003, + "subdir": "linux-64", + "timestamp": 1615564129949, + "version": "1.1.5" + }, + "poetry-1.1.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "910439555a6835fe066d0065673c9f31", + "name": "poetry", + "sha256": "40543e1fd5a08d724ffdd79443f3ed21599d57d683930e230507a26d682d2682", + "size": 240098, + "subdir": "linux-64", + "timestamp": 1615563728165, + "version": "1.1.5" + }, + "poetry-1.1.6-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "importlib-metadata >=1.6.0,<2.0.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1203009c6a691bbefe9e9b75e88dc15b", + "name": "poetry", + "sha256": "c2e7d1439b31c5d3dd7e52dd7502b04459efd9dcb4b945aff18a0777de656878", + "size": 240251, + "subdir": "linux-64", + "timestamp": 1618437316981, + "version": "1.1.6" + }, + "poetry-1.1.6-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "importlib-metadata >=1.6.0,<2.0.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e26680b9a986ad3d0861d910e7a313c", + "name": "poetry", + "sha256": "e31b5657032ac3c700ecc70e1d4a6cc338d9cb510c986502de293d4f7c8b5205", + "size": 241598, + "subdir": "linux-64", + "timestamp": 1618434209548, + "version": "1.1.6" + }, + "poetry-1.1.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "738dfc26f4420ef55e4a24dd14902b82", + "name": "poetry", + "sha256": "de04ba64fe5525df6676f5c02146fb98e92376f289d1640bad7855a239885e5a", + "size": 241304, + "subdir": "linux-64", + "timestamp": 1618437316492, + "version": "1.1.6" + }, + "poetry-1.1.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "716aecc95135c047d84c423fb03bbeb9", + "name": "poetry", + "sha256": "694c82ad236fbc41d86f77030c53a742475637794a828698562b25274f1d8c80", + "size": 240753, + "subdir": "linux-64", + "timestamp": 1618437326569, + "version": "1.1.6" + }, + "poetry-1.1.7-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "crashtest >=0.3.0,<0.4.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<24.0.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.19.0", + "python >=3.10,<3.11.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "205ac28861853e079bc739c0f81cad44", + "name": "poetry", + "sha256": "87ee9dd0319d38a3dffbd53dd8e47475387602f7406ddc59d222f321aa23cbcb", + "size": 246910, + "subdir": "linux-64", + "timestamp": 1640887217130, + "version": "1.1.7" + }, + "poetry-1.1.7-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "crashtest >=0.3.0,<0.4.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<24.0.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "platformdirs >=2,<3", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.19.0", + "python >=3.10,<3.11.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a9580abe566e6fefbaccd073071b8c27", + "name": "poetry", + "sha256": "f50645115cbc38353941066767e5207d8bd4f7eb1c0998f184560d452e23bf7e", + "size": 246851, + "subdir": "linux-64", + "timestamp": 1663171923600, + "version": "1.1.7" + }, + "poetry-1.1.7-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "crashtest >=0.3.0,<0.4.0", + "html5lib >=1.0,<2.0", + "importlib-metadata >=1.6.0,<2.0.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<24.0.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "platformdirs >=2,<3", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.19.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7fb711fce004dbc696d578f71ad56f7d", + "name": "poetry", + "sha256": "7d3b585405b9e1368a431299cf35bc18bfb84669f87ec918b56106d3f18d827c", + "size": 242420, + "subdir": "linux-64", + "timestamp": 1663171874369, + "version": "1.1.7" + }, + "poetry-1.1.7-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "crashtest >=0.3.0,<0.4.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<24.0.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "platformdirs >=2,<3", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.19.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15330ace668badf5628fa26764b24a2e", + "name": "poetry", + "sha256": "87c5043a393a756422a5cbc3bd746086ef8d921223d24e941b745dd2579975e8", + "size": 244511, + "subdir": "linux-64", + "timestamp": 1663171958157, + "version": "1.1.7" + }, + "poetry-1.1.7-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "crashtest >=0.3.0,<0.4.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<24.0.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "platformdirs >=2,<3", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.19.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c65b38d349418e15510b85c4c76ccb5", + "name": "poetry", + "sha256": "2769efe7ebf51a5fde6ab111304ab4b148e3f313209129a30bfff404d92edceb", + "size": 245697, + "subdir": "linux-64", + "timestamp": 1663171835751, + "version": "1.1.7" + }, + "poetry-1.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "cachecontrol-with-filecache >=0.12.9,<0.13.0" + ], + "depends": [ + "cachecontrol >=0.12.9,<0.13.0", + "cleo >=2.0.0,<3.0.0", + "crashtest >=0.4.1,<0.5.0", + "dulwich >=0.21.2,<0.22.0", + "filelock >=3.8.0", + "filelock >=3.8.0,<4.0.0", + "html5lib >=1.0,<2.0", + "jsonschema >=4.10.0,<5.0.0", + "keyring >=23.9.0,<24.0.0", + "lockfile >=0.12.2,<0.13.0", + "packaging >=20.4", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.9.4,<2.0", + "platformdirs >=2.5.2,<3.0.0", + "poetry-core 1.5.1.*", + "poetry-plugin-export >=1.3.0,<2.0.0", + "pyproject_hooks >=1.0.0,<2.0.0", + "python >=3.10,<3.11.0a0", + "python-build >=0.10.0,<0.11.0", + "python-installer >=0.6.0,<0.7.0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.11.0", + "shellingham >=1.5,<2.0", + "tomli >=2.0.1,<3.0.0", + "tomlkit >=0.11.1,<1.0.0,!=0.11.2,!=0.11.3", + "trove-classifiers >=2022.5.19", + "urllib3 >=1.26.0,<2.0.0", + "virtualenv >=20.4.3,<21.0.0,!=20.4.5,!=20.4.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52207ed535b24e15f13aaefcf4354d74", + "name": "poetry", + "sha256": "77aa987560b55e0f28b790ea0566b9bf413725df54ceedebb91f4c03b9945eca", + "size": 315365, + "subdir": "linux-64", + "timestamp": 1680193285231, + "version": "1.4.0" + }, + "poetry-1.4.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "cachecontrol-with-filecache >=0.12.9,<0.13.0" + ], + "depends": [ + "cachecontrol >=0.12.9,<0.13.0", + "cleo >=2.0.0,<3.0.0", + "crashtest >=0.4.1,<0.5.0", + "dulwich >=0.21.2,<0.22.0", + "filelock >=3.8.0", + "filelock >=3.8.0,<4.0.0", + "html5lib >=1.0,<2.0", + "jsonschema >=4.10.0,<5.0.0", + "keyring >=23.9.0,<24.0.0", + "lockfile >=0.12.2,<0.13.0", + "packaging >=20.4", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.9.4,<2.0", + "platformdirs >=2.5.2,<3.0.0", + "poetry-core 1.5.1.*", + "poetry-plugin-export >=1.3.0,<2.0.0", + "pyproject_hooks >=1.0.0,<2.0.0", + "python >=3.11,<3.12.0a0", + "python-build >=0.10.0,<0.11.0", + "python-installer >=0.6.0,<0.7.0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.11.0", + "shellingham >=1.5,<2.0", + "tomlkit >=0.11.1,<1.0.0,!=0.11.2,!=0.11.3", + "trove-classifiers >=2022.5.19", + "urllib3 >=1.26.0,<2.0.0", + "virtualenv >=20.4.3,<21.0.0,!=20.4.5,!=20.4.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a0bc769cff72b7629c12f0b51273872", + "name": "poetry", + "sha256": "bf7e2b3bd6ad92fada6cb397447ca053d8ad7c2b4f872f7c40a7b42a01536d0b", + "size": 423814, + "subdir": "linux-64", + "timestamp": 1680193213423, + "version": "1.4.0" + }, + "poetry-1.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "cachecontrol-with-filecache >=0.12.9,<0.13.0" + ], + "depends": [ + "cachecontrol >=0.12.9,<0.13.0", + "cleo >=2.0.0,<3.0.0", + "crashtest >=0.4.1,<0.5.0", + "dulwich >=0.21.2,<0.22.0", + "filelock >=3.8.0", + "filelock >=3.8.0,<4.0.0", + "html5lib >=1.0,<2.0", + "importlib-metadata >=4.4", + "jsonschema >=4.10.0,<5.0.0", + "keyring >=23.9.0,<24.0.0", + "lockfile >=0.12.2,<0.13.0", + "packaging >=20.4", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.9.4,<2.0", + "platformdirs >=2.5.2,<3.0.0", + "poetry-core 1.5.1.*", + "poetry-plugin-export >=1.3.0,<2.0.0", + "pyproject_hooks >=1.0.0,<2.0.0", + "python >=3.8,<3.9.0a0", + "python-build >=0.10.0,<0.11.0", + "python-installer >=0.6.0,<0.7.0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.11.0", + "shellingham >=1.5,<2.0", + "tomli >=2.0.1,<3.0.0", + "tomlkit >=0.11.1,<1.0.0,!=0.11.2,!=0.11.3", + "trove-classifiers >=2022.5.19", + "urllib3 >=1.26.0,<2.0.0", + "virtualenv >=20.4.3,<21.0.0,!=20.4.5,!=20.4.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0ac813e04d9628094a3b5e60f7602be1", + "name": "poetry", + "sha256": "5889cc429cbc6e216d819b53fe4df98d4a50fdde608dd44f36d36de5b117949b", + "size": 309496, + "subdir": "linux-64", + "timestamp": 1680193249495, + "version": "1.4.0" + }, + "poetry-1.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "cachecontrol-with-filecache >=0.12.9,<0.13.0" + ], + "depends": [ + "cachecontrol >=0.12.9,<0.13.0", + "cleo >=2.0.0,<3.0.0", + "crashtest >=0.4.1,<0.5.0", + "dulwich >=0.21.2,<0.22.0", + "filelock >=3.8.0", + "filelock >=3.8.0,<4.0.0", + "html5lib >=1.0,<2.0", + "importlib-metadata >=4.4", + "jsonschema >=4.10.0,<5.0.0", + "keyring >=23.9.0,<24.0.0", + "lockfile >=0.12.2,<0.13.0", + "packaging >=20.4", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.9.4,<2.0", + "platformdirs >=2.5.2,<3.0.0", + "poetry-core 1.5.1.*", + "poetry-plugin-export >=1.3.0,<2.0.0", + "pyproject_hooks >=1.0.0,<2.0.0", + "python >=3.9,<3.10.0a0", + "python-build >=0.10.0,<0.11.0", + "python-installer >=0.6.0,<0.7.0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.11.0", + "shellingham >=1.5,<2.0", + "tomli >=2.0.1,<3.0.0", + "tomlkit >=0.11.1,<1.0.0,!=0.11.2,!=0.11.3", + "trove-classifiers >=2022.5.19", + "urllib3 >=1.26.0,<2.0.0", + "virtualenv >=20.4.3,<21.0.0,!=20.4.5,!=20.4.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7a9542a1996c52e54c718e03e91f5bd4", + "name": "poetry", + "sha256": "a39bcb9487a5e597010dddb34b39815a15dd26e69f19ac917f4a7c450c129c79", + "size": 311122, + "subdir": "linux-64", + "timestamp": 1680193176329, + "version": "1.4.0" + }, + "poetry-core-1.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e92bd884faca84bff5c2ca70466c1b9", + "name": "poetry-core", + "sha256": "d6c806ab84f61636165f394049680164c63017f6f584611c9efa1bef5a15ff26", + "size": 875185, + "subdir": "linux-64", + "timestamp": 1670361555024, + "version": "1.4.0" + }, + "poetry-core-1.4.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01c184136a15716ee5b4cb1ebe61ee5a", + "name": "poetry-core", + "sha256": "9401292eee897375fb8702fde3eda494c903a79fe037382e307caf1b075e0825", + "size": 1149417, + "subdir": "linux-64", + "timestamp": 1676823085585, + "version": "1.4.0" + }, + "poetry-core-1.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata >=1.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ffa8de392f88745453290eb42deb8616", + "name": "poetry-core", + "sha256": "1ac2a63a92b02a5049fc102681a95cd70093cb63132faaafae3c82b6baeb0eef", + "size": 861349, + "subdir": "linux-64", + "timestamp": 1670361644259, + "version": "1.4.0" + }, + "poetry-core-1.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d0b77aaffa3f851481a552d8a18444de", + "name": "poetry-core", + "sha256": "c75ab6410c53e6c713f3e0aa05da3e36f11245d0cd3e1dea0bbd9b25f8b686af", + "size": 865256, + "subdir": "linux-64", + "timestamp": 1670361584444, + "version": "1.4.0" + }, + "poetry-core-1.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6cbb06362eec648b7e3bb48e7dabdad", + "name": "poetry-core", + "sha256": "b1182f34c032853a1c4368b9b6a91c51b5c40cf929f4101b94b449558eded8f8", + "size": 864187, + "subdir": "linux-64", + "timestamp": 1670361614193, + "version": "1.4.0" + }, + "poetry-core-1.5.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c0b3ccfdaa9a286fe37503250fb5f92", + "name": "poetry-core", + "sha256": "a380de3e9f994d4f4727679ab57a63206160bed40e8a9d7f20159ef6a3489fa8", + "size": 718409, + "subdir": "linux-64", + "timestamp": 1680018708577, + "version": "1.5.1" + }, + "poetry-core-1.5.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ec729d8f6dcfe524e4d7a31d1ab66ae", + "name": "poetry-core", + "sha256": "6ad02f21f36804a50f281f9ad3f24de3cd7a5bf931c981c5d891425987ea4611", + "size": 946106, + "subdir": "linux-64", + "timestamp": 1680018678812, + "version": "1.5.1" + }, + "poetry-core-1.5.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cfcb35e6d4e3ecb6cb56f2c395a48f25", + "name": "poetry-core", + "sha256": "16f17a5be68b8c2dc3df8cc788a3955c7a65038079b60fff44f3ab8b0e31aae5", + "size": 708513, + "subdir": "linux-64", + "timestamp": 1680018737763, + "version": "1.5.1" + }, + "poetry-core-1.5.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22bd61a4821ba996db98d44852cb9b3b", + "name": "poetry-core", + "sha256": "8f0567424e814972c91ee24a9e9e245bc7be04d6c0f35d4561499cb4db625d25", + "size": 708607, + "subdir": "linux-64", + "timestamp": 1680018766098, + "version": "1.5.1" + }, + "poetry-core-1.5.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a871c5e80c059ec967b0ea374f22c5a4", + "name": "poetry-core", + "sha256": "2af769204acbbf1c3fd8c2fae77e1a9875c0ccc1b4d8b80c3e9a3ab5c8fdeb23", + "size": 717450, + "subdir": "linux-64", + "timestamp": 1678914396360, + "version": "1.5.2" + }, + "poetry-core-1.5.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d157d440cb37f26e796b0f73fb065e7b", + "name": "poetry-core", + "sha256": "998e88d12e2784396de1211b613702f429d02d0d5a1573b425d611003838b686", + "size": 948018, + "subdir": "linux-64", + "timestamp": 1678914427188, + "version": "1.5.2" + }, + "poetry-core-1.5.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "09afbfc9e31fd66779638365f0013937", + "name": "poetry-core", + "sha256": "ec371f1c1dc91db6fda66ba6264073f6b3cfeb21d08659e41811ad7661569909", + "size": 709593, + "subdir": "linux-64", + "timestamp": 1678914365915, + "version": "1.5.2" + }, + "poetry-core-1.5.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1fc2c7d00e9f52b24ce824dd3ddfedf6", + "name": "poetry-core", + "sha256": "70e84ba654a6a92b6c09a5435ddd38919ffa2013cc19161d6e028ca086713195", + "size": 707269, + "subdir": "linux-64", + "timestamp": 1678914335881, + "version": "1.5.2" + }, + "poetry-plugin-export-1.3.0-py310h4849bfd_0.tar.bz2": { + "build": "py310h4849bfd_0", + "build_number": 0, + "constrains": [ + "poetry >=1.3.0,<2.0.0" + ], + "depends": [ + "poetry-core >=1.3.0,<2.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b454fd8a8cd6d1ca5339f415d92a420", + "name": "poetry-plugin-export", + "sha256": "ed782af2e8eddc8586566b09a561e761c7423736adff899c0f369c3386c6e36b", + "size": 20489, + "subdir": "linux-64", + "timestamp": 1680122890921, + "version": "1.3.0" + }, + "poetry-plugin-export-1.3.0-py311h4849bfd_0.tar.bz2": { + "build": "py311h4849bfd_0", + "build_number": 0, + "constrains": [ + "poetry >=1.3.0,<2.0.0" + ], + "depends": [ + "poetry-core >=1.3.0,<2.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4635e928203a7bef510336f6f3ce8e2", + "name": "poetry-plugin-export", + "sha256": "4dd193bff94ac56d8a4514999343d59e53a16fde3f8f4d17cd46a81194cc5c32", + "size": 24971, + "subdir": "linux-64", + "timestamp": 1680122815077, + "version": "1.3.0" + }, + "poetry-plugin-export-1.3.0-py38h4849bfd_0.tar.bz2": { + "build": "py38h4849bfd_0", + "build_number": 0, + "constrains": [ + "poetry >=1.3.0,<2.0.0" + ], + "depends": [ + "poetry-core >=1.3.0,<2.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6bad70b3a02d35250da339f98cffa51d", + "name": "poetry-plugin-export", + "sha256": "ad46b4e707b87c1cd66f3d98613f9220dfc1bf658d7091fd2d40576a2660eab5", + "size": 20418, + "subdir": "linux-64", + "timestamp": 1680122865048, + "version": "1.3.0" + }, + "poetry-plugin-export-1.3.0-py39h4849bfd_0.tar.bz2": { + "build": "py39h4849bfd_0", + "build_number": 0, + "constrains": [ + "poetry >=1.3.0,<2.0.0" + ], + "depends": [ + "poetry-core >=1.3.0,<2.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "247fe215c2f075ea794b623d1e665fa6", + "name": "poetry-plugin-export", + "sha256": "b0bc4639a93704d51bbd58579dec7ac2c560a65bfe55d409d3206856f5ddc3f2", + "size": 20401, + "subdir": "linux-64", + "timestamp": 1680122839548, + "version": "1.3.0" + }, + "pomegranate-0.10.0-py27hdd07704_0.tar.bz2": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "afc3f09c097593000cc7d57721ea6647", + "name": "pomegranate", + "sha256": "da6c04c6b8e3d1a5c8e555220f9ab20882f0dd3e04f446c441bb82fb4da22cdf", + "size": 3658966, + "subdir": "linux-64", + "timestamp": 1536116473216, + "version": "0.10.0" + }, + "pomegranate-0.10.0-py35hdd07704_0.tar.bz2": { + "build": "py35hdd07704_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f09915f26d2df9cb3f4d136468de0af", + "name": "pomegranate", + "sha256": "dc574fe468ac4ab78e8c0a71500bf1e8952cf455f202526d1b33c8d2631b38d9", + "size": 3624219, + "subdir": "linux-64", + "timestamp": 1536116445794, + "version": "0.10.0" + }, + "pomegranate-0.10.0-py36hdd07704_0.tar.bz2": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "50a59bded02a741c7916ce8fa5425c56", + "name": "pomegranate", + "sha256": "6b9b5e8a626b224810d045ea550b21e0760e6ca06c8a69dd6d438d003ed47475", + "size": 3686352, + "subdir": "linux-64", + "timestamp": 1536116475560, + "version": "0.10.0" + }, + "pomegranate-0.10.0-py37hdd07704_0.tar.bz2": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "20f70ccbf231e21c174f29b9505ae3f5", + "name": "pomegranate", + "sha256": "d525d6886a222bd16028f65ac2af064aacfdf51343eac4ab07f432f59e2c2280", + "size": 3664430, + "subdir": "linux-64", + "timestamp": 1536116473928, + "version": "0.10.0" + }, + "pomegranate-0.11.0-py27hdd07704_0.tar.bz2": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "782e2447b1a13b9e79c491e6e45959ea", + "name": "pomegranate", + "sha256": "249f8e4fa523c7c9cef27770aa3aa4eb1d23f568c8b9734af6c8bced388d432e", + "size": 3738159, + "subdir": "linux-64", + "timestamp": 1568318232726, + "version": "0.11.0" + }, + "pomegranate-0.11.0-py36hdd07704_0.tar.bz2": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f319bbf43f8dc41af1dbc3933c6d061a", + "name": "pomegranate", + "sha256": "065c413cced373dfc09fad222f8ff9ffc22b360425e0cd6c33570dcfb3c0ef99", + "size": 3835518, + "subdir": "linux-64", + "timestamp": 1568318234780, + "version": "0.11.0" + }, + "pomegranate-0.11.0-py37hdd07704_0.tar.bz2": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "168ada9353ca5aeabedcea9a20ff863c", + "name": "pomegranate", + "sha256": "819c113f74154205e1277c8247cbab0b462a108f985f3ff3b697071df7b3b22a", + "size": 3816954, + "subdir": "linux-64", + "timestamp": 1568318240636, + "version": "0.11.0" + }, + "pomegranate-0.11.1-py27ha516724_0.tar.bz2": { + "build": "py27ha516724_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a00708f5588d68828577de8b756f7e42", + "name": "pomegranate", + "sha256": "e014515912f46b5d542b972222e782a39dc7e48c080b5ef8a733b53698eccb6c", + "size": 3691715, + "subdir": "linux-64", + "timestamp": 1569434642545, + "version": "0.11.1" + }, + "pomegranate-0.11.1-py36ha516724_0.tar.bz2": { + "build": "py36ha516724_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bf15935a31bca44260a550d4d568a60c", + "name": "pomegranate", + "sha256": "300407dd7f07173a99e4057e63b30798fa7a80021fa382737a13e826b8150391", + "size": 3747525, + "subdir": "linux-64", + "timestamp": 1569434544641, + "version": "0.11.1" + }, + "pomegranate-0.11.1-py37ha516724_0.tar.bz2": { + "build": "py37ha516724_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec600fa10383a65348fb68f923225462", + "name": "pomegranate", + "sha256": "55d10a5735a45233788cd44877fbf05902b050526cf8a169256c97dc4a7f0fb1", + "size": 3737947, + "subdir": "linux-64", + "timestamp": 1569434595092, + "version": "0.11.1" + }, + "pomegranate-0.11.1-py38ha516724_0.tar.bz2": { + "build": "py38ha516724_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e54b354a3b00f3cdf4d554965e848640", + "name": "pomegranate", + "sha256": "5550d18b46184bad9d4bceafaf380e58501dc79e3ba015db84b3570b8ebec6e2", + "size": 3863506, + "subdir": "linux-64", + "timestamp": 1574170213594, + "version": "0.11.1" + }, + "pomegranate-0.13.4-py36ha516724_0.tar.bz2": { + "build": "py36ha516724_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0298e950956e51f24e80bcfac911fbd2", + "name": "pomegranate", + "sha256": "0b31e80ce2f07e748c21846ba54e5bc8fd74024ebcb47f36873591a0f021272d", + "size": 3773158, + "subdir": "linux-64", + "timestamp": 1601588027865, + "version": "0.13.4" + }, + "pomegranate-0.13.4-py37ha516724_0.tar.bz2": { + "build": "py37ha516724_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "034118c20fb9a75c39e9103aa064c9c3", + "name": "pomegranate", + "sha256": "4ced4234d1cb8aaa24c8f937d5aec43d2bd0000ec399d6c00062fb04daab918d", + "size": 3752249, + "subdir": "linux-64", + "timestamp": 1601587983253, + "version": "0.13.4" + }, + "pomegranate-0.13.4-py38ha516724_0.tar.bz2": { + "build": "py38ha516724_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab93c50df7b8e322c74394b3dbe31c46", + "name": "pomegranate", + "sha256": "7284b7864c9dd8e10f649779baeac9cb97ec775c79165c19011268419b591fd8", + "size": 3876696, + "subdir": "linux-64", + "timestamp": 1601587987653, + "version": "0.13.4" + }, + "pomegranate-0.13.5-py36ha3f3c68_0.tar.bz2": { + "build": "py36ha3f3c68_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8532e6771085680f0cd936e5a20a3866", + "name": "pomegranate", + "sha256": "4fde4343969c03a09923bf467b7e2b9a1563f59e14cd667c99b430030833d833", + "size": 5334221, + "subdir": "linux-64", + "timestamp": 1602607112015, + "version": "0.13.5" + }, + "pomegranate-0.13.5-py37ha3f3c68_0.tar.bz2": { + "build": "py37ha3f3c68_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b04b2d509b720b408665c0b3442044ec", + "name": "pomegranate", + "sha256": "865d71421faa933dad82543209160d44de02e0f5260366d95246d442480fbddd", + "size": 5314561, + "subdir": "linux-64", + "timestamp": 1602607107495, + "version": "0.13.5" + }, + "pomegranate-0.13.5-py38ha3f3c68_0.tar.bz2": { + "build": "py38ha3f3c68_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da9168f775d885f78e01377a13696a9c", + "name": "pomegranate", + "sha256": "7e3d0f6932316a644a5ca2b27c7825b07dca3e448c92b0def3a94873d16129a4", + "size": 5453318, + "subdir": "linux-64", + "timestamp": 1602607093132, + "version": "0.13.5" + }, + "pomegranate-0.14.0-py36h9a67853_0.tar.bz2": { + "build": "py36h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3cfc866504e79cb05eb7c5c5b89540e3", + "name": "pomegranate", + "sha256": "dd9379100484760951e3b028c09095a483fafe78bd123d58c2b02632a13a27ce", + "size": 5636192, + "subdir": "linux-64", + "timestamp": 1612291602750, + "version": "0.14.0" + }, + "pomegranate-0.14.0-py37h9a67853_0.tar.bz2": { + "build": "py37h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3cd39e7c91ea79b508b5e1b5bbd7c283", + "name": "pomegranate", + "sha256": "aa2fe43a8421f155cf5c855c56b5df11eaddc3e38157eac92ad13a3bca51981c", + "size": 5622818, + "subdir": "linux-64", + "timestamp": 1612292128943, + "version": "0.14.0" + }, + "pomegranate-0.14.0-py38h9a67853_0.tar.bz2": { + "build": "py38h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47b3ff43062672b4eb0ab30e3a1b816c", + "name": "pomegranate", + "sha256": "9cd8a444b62fa85fedc99fce23c309bb95a6dbcaf2e250c6b35787bd694ebdf6", + "size": 5799490, + "subdir": "linux-64", + "timestamp": 1612293197670, + "version": "0.14.0" + }, + "pomegranate-0.14.0-py39h9a67853_0.tar.bz2": { + "build": "py39h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "193994428a5d2e760cd9b89d441e41cf", + "name": "pomegranate", + "sha256": "72d75e36b56dc6be6b940fec4154f9358a580db270daa1dfff51bf2af3ebfa9c", + "size": 5812242, + "subdir": "linux-64", + "timestamp": 1612293235746, + "version": "0.14.0" + }, + "pomegranate-0.14.2-py36h9a67853_0.tar.bz2": { + "build": "py36h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0435210a60df828d39d25eddf9160c97", + "name": "pomegranate", + "sha256": "b58d33bb5aabd00bfe11ceaa4ac3ef9e533ab443ccfc5d6970eed308c41aa8ed", + "size": 5542519, + "subdir": "linux-64", + "timestamp": 1613765768126, + "version": "0.14.2" + }, + "pomegranate-0.14.2-py37h9a67853_0.tar.bz2": { + "build": "py37h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5a00192b7e899ab5979d87b88789bb93", + "name": "pomegranate", + "sha256": "13e5dc04a690596b725081a00f8a3e61e2fba1363b6f3ac72020472f03d59895", + "size": 5517905, + "subdir": "linux-64", + "timestamp": 1613764974006, + "version": "0.14.2" + }, + "pomegranate-0.14.2-py38h9a67853_0.tar.bz2": { + "build": "py38h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab3d6db6164e08a5a0b2e9d0d1248c0b", + "name": "pomegranate", + "sha256": "8c375390232649b7df9ecc5483695fae91b2119b21671d3eff27f60429b5f186", + "size": 5728504, + "subdir": "linux-64", + "timestamp": 1613765769950, + "version": "0.14.2" + }, + "pomegranate-0.14.2-py39h9a67853_0.tar.bz2": { + "build": "py39h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4a9e3a6c753e6ddc663fed3f1b183b2", + "name": "pomegranate", + "sha256": "9550f0235b9f5b5799ca01c029c82130182a867d20a1154e0bb2c88c24cd5201", + "size": 5707736, + "subdir": "linux-64", + "timestamp": 1613765784078, + "version": "0.14.2" + }, + "pomegranate-0.14.3-py310h2571103_0.tar.bz2": { + "build": "py310h2571103_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8deed6c515b9bdb22444ba6a967a95a", + "name": "pomegranate", + "sha256": "2a51363ec85484301d4abe6b9fffe07e30cdcc3aabf9f80f5173b0a1e58a4589", + "size": 15002337, + "subdir": "linux-64", + "timestamp": 1641556985679, + "version": "0.14.3" + }, + "pomegranate-0.14.3-py36h9a67853_0.tar.bz2": { + "build": "py36h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21291b6bebb48b68ab2c013979521bc5", + "name": "pomegranate", + "sha256": "46df1e78dc67fffc0663905406bfc16a62dadb700b247004ae5827c089f84c36", + "size": 5471584, + "subdir": "linux-64", + "timestamp": 1616184157204, + "version": "0.14.3" + }, + "pomegranate-0.14.3-py37h9a67853_0.tar.bz2": { + "build": "py37h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "30b95c4b201bdc3d99a2966954aca653", + "name": "pomegranate", + "sha256": "cf7b2314c5b6140bfbe9dc978c507482801d5183b089283a583cc9bea1c3d5b0", + "size": 5460259, + "subdir": "linux-64", + "timestamp": 1616182162144, + "version": "0.14.3" + }, + "pomegranate-0.14.3-py38h9a67853_0.tar.bz2": { + "build": "py38h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d2c9e549a0140aefa28534568e7062f", + "name": "pomegranate", + "sha256": "2351cccfe183086dfe7d248ea8cf10dc7ab8e357ca017cec1c9534c648ea5ea7", + "size": 5625162, + "subdir": "linux-64", + "timestamp": 1616183276077, + "version": "0.14.3" + }, + "pomegranate-0.14.3-py39h9a67853_0.tar.bz2": { + "build": "py39h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd2ec675856121c24a8fd0b36258913e", + "name": "pomegranate", + "sha256": "e62ac64e7aa4d3725d531de128a027a088e44c4e537df3e567625c7f252f2567", + "size": 5624824, + "subdir": "linux-64", + "timestamp": 1616183271653, + "version": "0.14.3" + }, + "pomegranate-0.14.4-py36h9a67853_0.tar.bz2": { + "build": "py36h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d7ba0b9422b8ef1dc7b4068ab98b068", + "name": "pomegranate", + "sha256": "b0a678f42ea2c29e27dae7c8e4f798e410fb29eda676a6654c57de21f8b664c9", + "size": 5481153, + "subdir": "linux-64", + "timestamp": 1617209185554, + "version": "0.14.4" + }, + "pomegranate-0.14.4-py37h9a67853_0.tar.bz2": { + "build": "py37h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8bace469035c3cf4377b8f45548ec603", + "name": "pomegranate", + "sha256": "56360341c22791ca235622c83a6427b145f421a82588e0c5b215417b5441bc85", + "size": 5438545, + "subdir": "linux-64", + "timestamp": 1617211452363, + "version": "0.14.4" + }, + "pomegranate-0.14.4-py38h9a67853_0.tar.bz2": { + "build": "py38h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "93ea6a563469c72c04ff6c8643848e2d", + "name": "pomegranate", + "sha256": "089adfe518a0da965fb85d5d0ec0d7d92d7a1325223c7c96d090ac28436e53f4", + "size": 5589249, + "subdir": "linux-64", + "timestamp": 1617211685298, + "version": "0.14.4" + }, + "pomegranate-0.14.4-py39h9a67853_0.tar.bz2": { + "build": "py39h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "afea598d8eaed2b8b96faa9917fcc76c", + "name": "pomegranate", + "sha256": "7dd2e0e968776db853155dd5a1f229651fabe84b515d1358630262560ad3d278", + "size": 5612395, + "subdir": "linux-64", + "timestamp": 1617211699378, + "version": "0.14.4" + }, + "pomegranate-0.8.0-py27h0eee2d8_0.tar.bz2": { + "build": "py27h0eee2d8_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e2c6a3ad2f7cf72d226d0ab3a0186d2", + "name": "pomegranate", + "sha256": "b9e48d8ceb0669c613e336d8bf8a5e9ae9dbc6fcf555bb6f3bae446dbea77ca5", + "size": 3365248, + "subdir": "linux-64", + "timestamp": 1508967527450, + "version": "0.8.0" + }, + "pomegranate-0.8.0-py35hef112b0_0.tar.bz2": { + "build": "py35hef112b0_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08f8653d6f5e13c95779f67fb9752cf0", + "name": "pomegranate", + "sha256": "6f6e9f427f8db3c6b03fc5d6033e2f141e4a1828b65725e4c10b938df1afd3d5", + "size": 3304443, + "subdir": "linux-64", + "timestamp": 1508967660421, + "version": "0.8.0" + }, + "pomegranate-0.8.0-py36ha26ad33_0.tar.bz2": { + "build": "py36ha26ad33_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1135371efff4750f4db16e7530ad86fd", + "name": "pomegranate", + "sha256": "89571adf6e26894ed659bbbd698f48ac1b249e3cc11d04b11e40bf8d2b1fe192", + "size": 3340532, + "subdir": "linux-64", + "timestamp": 1508967670885, + "version": "0.8.0" + }, + "pomegranate-0.8.1-py27h8df36fd_0.tar.bz2": { + "build": "py27h8df36fd_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4477132ea297c42a5c1ce10c90acdcfe", + "name": "pomegranate", + "sha256": "3217d4666d93bd7ddee65b670003c6927743c812806bb601d91c69afc8744772", + "size": 3281425, + "subdir": "linux-64", + "timestamp": 1511844799955, + "version": "0.8.1" + }, + "pomegranate-0.8.1-py35h5d3529e_0.tar.bz2": { + "build": "py35h5d3529e_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ed810f1e467142f07fa24d25f7090fff", + "name": "pomegranate", + "sha256": "0c5c1473bef18853630a312dce291f271b7f5f079b9b08b3470b6d56aa4f3df7", + "size": 3209175, + "subdir": "linux-64", + "timestamp": 1511844795628, + "version": "0.8.1" + }, + "pomegranate-0.8.1-py36h0cb749a_0.tar.bz2": { + "build": "py36h0cb749a_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "04c1b7979802c6a9c13eeac8a926d511", + "name": "pomegranate", + "sha256": "9120a395482625a40f89ee3e404a3982b699131da792df4640389b88d215b60f", + "size": 3276342, + "subdir": "linux-64", + "timestamp": 1511844718798, + "version": "0.8.1" + }, + "pomegranate-0.9.0-py27h035aef0_0.tar.bz2": { + "build": "py27h035aef0_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "30cb914a539ef1cf2536735ff0158d51", + "name": "pomegranate", + "sha256": "bf5ccad01fe8b3be625836736961b16b0da54dedaf5ace2a9cfff1d165aa00e6", + "size": 3365991, + "subdir": "linux-64", + "timestamp": 1530905437733, + "version": "0.9.0" + }, + "pomegranate-0.9.0-py27h3010b51_0.tar.bz2": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d3e1756f69d3bf5b06ad5e9fa4ac729d", + "name": "pomegranate", + "sha256": "c365d0273dc81944dadec467bc7b157d82a48bcbc237f8f61ab62b8ab4821cd1", + "size": 3365665, + "subdir": "linux-64", + "timestamp": 1519365663091, + "version": "0.9.0" + }, + "pomegranate-0.9.0-py35h3010b51_0.tar.bz2": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.14.1,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63ba28b09b7544ac963cbc51a6afcb0a", + "name": "pomegranate", + "sha256": "b51dc729a1e0933e82daee047096f3e7ced56732922f36f3eea35c4a0d78ff66", + "size": 3299979, + "subdir": "linux-64", + "timestamp": 1519365598539, + "version": "0.9.0" + }, + "pomegranate-0.9.0-py36h035aef0_0.tar.bz2": { + "build": "py36h035aef0_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4fcfeaaf1d3e5416c2d7f6022cb2d68d", + "name": "pomegranate", + "sha256": "02b75347cdad58fed63ad37c5c90f500f59670e888611f94fbe77b3571f919d3", + "size": 3378363, + "subdir": "linux-64", + "timestamp": 1530905654528, + "version": "0.9.0" + }, + "pomegranate-0.9.0-py36h3010b51_0.tar.bz2": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "054a29281e4517e1c905153cd4b14cfa", + "name": "pomegranate", + "sha256": "372e6d4262016f982abcc747e9c20bdc7764a5cc229324151d6a208d5fde0aaf", + "size": 3368504, + "subdir": "linux-64", + "timestamp": 1519365530525, + "version": "0.9.0" + }, + "pomegranate-0.9.0-py37h035aef0_0.tar.bz2": { + "build": "py37h035aef0_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f386125f74f2dbb1f177b6fab22b18d0", + "name": "pomegranate", + "sha256": "486fdcd1e1ad2038af35496c5237b65d0337930eb7e884a7017785427b436de3", + "size": 3359433, + "subdir": "linux-64", + "timestamp": 1530905868584, + "version": "0.9.0" + }, + "poppler-0.60.1-hc909a00_0.tar.bz2": { + "build": "hc909a00_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.10,<2.0a0", + "curl", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.8,<5.0a0", + "libxcb >=1.12,<2.0a0", + "openjpeg >=2.2.0,<3.0a0", + "poppler-data >=0.4.8", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPLv2", + "license_family": "GPL", + "md5": "4019c29a8f643768cdcf50ef74af526a", + "name": "poppler", + "sha256": "6f901cfab0ec4472873538a12392d8ac47db5556a683f7426c44fd8d5287f3a5", + "size": 6957653, + "subdir": "linux-64", + "timestamp": 1507908143347, + "version": "0.60.1" + }, + "poppler-0.65.0-h581218d_1.tar.bz2": { + "build": "h581218d_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.1,<3.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxcb >=1.13,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "poppler-data >=0.4.9", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPLv2", + "license_family": "GPL", + "md5": "d279c720cd8a9847611d38e2a960844a", + "name": "poppler", + "sha256": "246a0e25b0ae0be4bc0ac4185f6beda164b7e4149ba718b7201ab63ef81e3c05", + "size": 1652030, + "subdir": "linux-64", + "timestamp": 1527261451326, + "version": "0.65.0" + }, + "poppler-0.65.0-ha54bb34_0.tar.bz2": { + "build": "ha54bb34_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.12.6,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.56.1,<3.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxcb >=1.13,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "poppler-data >=0.4.9", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPLv2", + "license_family": "GPL", + "md5": "d7131ab8a2427310d8e04eefb3dd922f", + "name": "poppler", + "sha256": "2e833bbd6e90cbc90099c9e86c5c90e6b9463e3ce251b73818460112cdce1eb5", + "size": 1651183, + "subdir": "linux-64", + "timestamp": 1527192438417, + "version": "0.65.0" + }, + "poppler-0.81.0-h01f5e8b_2.tar.bz2": { + "build": "h01f5e8b_2", + "build_number": 2, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "curl", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.68.2,<3.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "openjpeg >=2.3.0,<3.0a0", + "poppler-data", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPLv2", + "license_family": "GPL", + "md5": "d1d02486a56bddedb4789c0802d67f18", + "name": "poppler", + "sha256": "9a5ad9ed809ea6cd5b11ff992519e2b1cffaf14e63e0d345c589270e9ea181f9", + "size": 13295029, + "subdir": "linux-64", + "timestamp": 1623340073756, + "version": "0.81.0" + }, + "poppler-0.81.0-ha7185a5_2.tar.bz2": { + "build": "ha7185a5_2", + "build_number": 2, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "curl", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.65.0,<3.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "openjpeg >=2.3.0,<3.0a0", + "poppler-data", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPLv2", + "license_family": "GPL", + "md5": "7db87597fdf8805f19503eb740e31294", + "name": "poppler", + "sha256": "5563cd2280ec7342469869c07b8b851a85bfc421f28f803a12283e85b5048d86", + "size": 13225252, + "subdir": "linux-64", + "timestamp": 1622310181985, + "version": "0.81.0" + }, + "poppler-0.81.0-he6a58d2_1.tar.bz2": { + "build": "he6a58d2_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "curl", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.10.2,<3.0a0", + "glib >=2.65.0,<3.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libxcb >=1.14,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "poppler-data", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPLv2", + "license_family": "GPL", + "md5": "952a78d8c9b4cca0144cd9edf015d47c", + "name": "poppler", + "sha256": "7bbed058ffd99aa4c66baed817fc4ccdee26ffdafb41736965da4238effa0667", + "size": 13009767, + "subdir": "linux-64", + "timestamp": 1597158499539, + "version": "0.81.0" + }, + "poppler-21.11.0-h9f6c795_0.tar.bz2": { + "build": "h9f6c795_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "curl", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "jpeg >=9d,<10a", + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "openjpeg >=2.4.0,<3.0a0", + "poppler-data", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPLv2", + "license_family": "GPL", + "md5": "5d417d05455af5bb2542607223a6a9c0", + "name": "poppler", + "sha256": "9dc1c6271f81daa45f76cb848bfffde3722b8f03b9939d6b9d42a1117f4b4de5", + "size": 14849453, + "subdir": "linux-64", + "timestamp": 1643108724400, + "version": "21.11.0" + }, + "poppler-22.12.0-h381b16e_0.tar.bz2": { + "build": "h381b16e_0", + "build_number": 0, + "depends": [ + "boost-cpp >=1.73.0,<2.0a0", + "cairo >=1.16.0,<2.0a0", + "fontconfig >=2.14.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libcurl >=7.86.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libiconv >=1.16,<2.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "nspr >=4.33,<5.0a0", + "nss >=3.74,<4.0a0", + "openjpeg >=2.3.0,<3.0a0", + "poppler-data", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-only", + "license_family": "GPL", + "md5": "08b1e68ef59bf2e63e2987d2b905f8a3", + "name": "poppler", + "sha256": "9bd6a33d2a39c9568524f96325c9c8bdcc40f0f7dfd30c311a4a2ac3829297f2", + "size": 20498935, + "subdir": "linux-64", + "timestamp": 1674032114468, + "version": "22.12.0" + }, + "poppler-data-0.4.10-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "Adobe+GPLv2", + "license_family": "GPL", + "md5": "8f95e5498bed3224da5197c44c0727cb", + "name": "poppler-data", + "sha256": "1a97f62db3e0e3774fd1770ad2389ab2d815f2d17680ec24e02297b6e8f30ed4", + "size": 3894987, + "subdir": "linux-64", + "timestamp": 1603822302896, + "version": "0.4.10" + }, + "poppler-data-0.4.11-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "GPL-2.0-or-later and GPL-3.0-or-later and BSD-3-Clause", + "license_family": "GPL", + "md5": "50df6ed3f41fc8562878b5b4c893e478", + "name": "poppler-data", + "sha256": "7b70a808ecfa7d22d1ffd6dd3580fb63e282bca985af1ca6672ddadbd696a74c", + "size": 3805707, + "subdir": "linux-64", + "timestamp": 1644332583277, + "version": "0.4.11" + }, + "poppler-data-0.4.11-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "GPL-2.0-or-later and GPL-3.0-or-later and BSD-3-Clause", + "license_family": "GPL", + "md5": "3e4df7dd4cb1e7fc2415c39951ebf4a4", + "name": "poppler-data", + "sha256": "cb8da35b87b1a486e8bb35a8978dcedc93a6d3cc9f9909665267d5fe5d1f93b2", + "size": 3894636, + "subdir": "linux-64", + "timestamp": 1673863550016, + "version": "0.4.11" + }, + "poppler-data-0.4.8-hf2eda46_0.tar.bz2": { + "build": "hf2eda46_0", + "build_number": 0, + "depends": [], + "license": "Adobe+GPLv2", + "license_family": "GPL", + "md5": "cbfac75d5649b5ccd9e7278758fe3de8", + "name": "poppler-data", + "sha256": "cb20d8c5ac7d9d9609fca5922673935a16a44a9b06c51f3e096f482e2e04914b", + "size": 3710735, + "subdir": "linux-64", + "timestamp": 1507908048306, + "version": "0.4.8" + }, + "poppler-data-0.4.9-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "Adobe+GPLv2", + "license_family": "GPL", + "md5": "a502191d5112f6e7fca5bb1746f18dbc", + "name": "poppler-data", + "sha256": "a898420749957a72f74763143cb8081dfe68bdceff4626f160aa175c4718f3ab", + "size": 3709183, + "subdir": "linux-64", + "timestamp": 1527172404757, + "version": "0.4.9" + }, + "poppler-qt-22.12.0-h381b16e_0.tar.bz2": { + "build": "h381b16e_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "fontconfig >=2.14.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libcurl >=7.86.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libiconv >=1.16,<2.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "nspr >=4.33,<5.0a0", + "nss >=3.74,<4.0a0", + "openjpeg >=2.3.0,<3.0a0", + "poppler 22.12.0 h381b16e_0", + "qt-main >=5.15.2,<5.16.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-only", + "license_family": "GPL", + "md5": "0b8c6a959897e51ffa137d7205ba63c5", + "name": "poppler-qt", + "sha256": "1a8704c8090c219c9c50ec46d446522baedcdbbef8644027d84db5ed1dbf2327", + "size": 5930381, + "subdir": "linux-64", + "timestamp": 1674032167087, + "version": "22.12.0" + }, + "portalocker-1.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "466d622b4be8aa5af04fa68258e7a037", + "name": "portalocker", + "sha256": "5fb61d2e8432f994c77bd444c63970f0210f2102a9c045a76e3256ea1851b42e", + "size": 19657, + "subdir": "linux-64", + "timestamp": 1569509988703, + "version": "1.5.1" + }, + "portalocker-1.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "f7177de83da6944275ace117027d95d2", + "name": "portalocker", + "sha256": "b5f720417f8f91d95ae3bc6ddc997a042674c1200f895207de0fc8f193ad1db0", + "size": 19912, + "subdir": "linux-64", + "timestamp": 1569509984982, + "version": "1.5.1" + }, + "portalocker-1.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "44cb26375f280e0c631b2ad0404d97c6", + "name": "portalocker", + "sha256": "6a938e440b0d8b16771dd6c9a9d8df4c1df05af547c4d7faa5cffd88f128ce90", + "size": 19914, + "subdir": "linux-64", + "timestamp": 1569509989315, + "version": "1.5.1" + }, + "portalocker-1.5.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "6a58a7654e17e4014412c2187f6f7107", + "name": "portalocker", + "sha256": "a2cd165915d98b9b314138c4a3d21e787737467ca8bdf79d7a33b469dfee0fe7", + "size": 20046, + "subdir": "linux-64", + "timestamp": 1574370831513, + "version": "1.5.2" + }, + "portalocker-1.5.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "b3ba91c253c134bb74276ed7d0acafb3", + "name": "portalocker", + "sha256": "338d8dc92b12191d01f479654ef14276f87f5a256afac2b1113f2a49d6931245", + "size": 20311, + "subdir": "linux-64", + "timestamp": 1574370802801, + "version": "1.5.2" + }, + "portalocker-1.5.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "e600fefee0e9112a176ec24f4476936b", + "name": "portalocker", + "sha256": "bb13d991ea055adc711b1c881bac5e75e3eacf78c72f7ad06cf2c779c7d9d9ed", + "size": 20321, + "subdir": "linux-64", + "timestamp": 1574370851107, + "version": "1.5.2" + }, + "portalocker-1.5.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "ca3fb8cc00b86d5725e6596d352567f0", + "name": "portalocker", + "sha256": "4350f39dc189cf5e4592076d80b7cf48d69d1cecbfad2060f61f6275051e3f9a", + "size": 20364, + "subdir": "linux-64", + "timestamp": 1574370890943, + "version": "1.5.2" + }, + "portalocker-1.7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "d4529f0bcfa9256d7176e48a635a22d3", + "name": "portalocker", + "sha256": "3dce374178ba35197d6277d0c9bfae5791002669a970367e1d4be5af4f50aaff", + "size": 18981, + "subdir": "linux-64", + "timestamp": 1596941269669, + "version": "1.7.0" + }, + "portalocker-1.7.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "69d5f0a2cb4d51735cff6eaf039883e2", + "name": "portalocker", + "sha256": "91a3c3f88490b3b4ee3e9186e2cf3bc27d23a214c8b35038dfe42f38caa93712", + "size": 23324, + "subdir": "linux-64", + "timestamp": 1596476623649, + "version": "1.7.1" + }, + "portalocker-1.7.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "60f01cd313241d5b56f51a0d43cb29c7", + "name": "portalocker", + "sha256": "dfec68a443a3ade3e51af5f6300a43821ea14df76d97c75ce2d88d9434555280", + "size": 23366, + "subdir": "linux-64", + "timestamp": 1596576521174, + "version": "1.7.1" + }, + "portalocker-1.7.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "75a7b0db986945a9d97bbc4a7a4dbe55", + "name": "portalocker", + "sha256": "eaf1c4135f233bbc6075249e402f8171a298f6b4042942bf5e6f64d428b96713", + "size": 23388, + "subdir": "linux-64", + "timestamp": 1596576539542, + "version": "1.7.1" + }, + "portalocker-2.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "6afe9940419c8cb7d84725faa1a9fc74", + "name": "portalocker", + "sha256": "45e81769ea3fa3c44201fe7d02fe69e3c357d6d440d3a31ac17e10123f78b92e", + "size": 25374, + "subdir": "linux-64", + "timestamp": 1597348445279, + "version": "2.0.0" + }, + "portalocker-2.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "6d26a7f8a9faf8447cffaf26e953c23f", + "name": "portalocker", + "sha256": "f5317866d5692d34810e201921223b08c2c5235b74ced1ada91bf79b45e7b482", + "size": 25368, + "subdir": "linux-64", + "timestamp": 1597348442837, + "version": "2.0.0" + }, + "portalocker-2.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "e9c7acf8d9a86f1bacda17063bb1ec1a", + "name": "portalocker", + "sha256": "2d87efe25f12b90d09d78c1e625571aced38d0d33f1c195e1b8c60dfaac2e122", + "size": 25423, + "subdir": "linux-64", + "timestamp": 1597348450297, + "version": "2.0.0" + }, + "portalocker-2.1.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "18a7b43937854289b36c70729e75aff4", + "name": "portalocker", + "sha256": "63b79d00e1515a1420289a244c099c87b023b069ac7d9f17196f773140a5d995", + "size": 25104, + "subdir": "linux-64", + "timestamp": 1611516841364, + "version": "2.1.0" + }, + "portalocker-2.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "b021096a7f463547d8e8fc6ad7067c03", + "name": "portalocker", + "sha256": "152c9051583783bff434a3e71635c693b7a2cb799fa3c8f9f0300577d937686a", + "size": 25177, + "subdir": "linux-64", + "timestamp": 1611516804532, + "version": "2.1.0" + }, + "portalocker-2.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "6970fcaebfaa17824922f2e8c03b1e98", + "name": "portalocker", + "sha256": "fa8c48a0bf7cace1c3c2d03b8479fc13eab23365cca5242ab23d15852757ebe1", + "size": 25283, + "subdir": "linux-64", + "timestamp": 1611516847354, + "version": "2.1.0" + }, + "portalocker-2.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "93d4fa003460f3a5cc3146e3bf34e552", + "name": "portalocker", + "sha256": "72bc594b5f2f248d647365b40b35e4bcb4844be6aa2e45b5d3de89139d019ea4", + "size": 25357, + "subdir": "linux-64", + "timestamp": 1611516809131, + "version": "2.1.0" + }, + "portalocker-2.2.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "b6ed04607c6f1153001ea4360f311177", + "name": "portalocker", + "sha256": "3c10941d2be1494c3bc2bcd80ac9d54b423339d42e904bd57acec05c3ac02fd0", + "size": 28243, + "subdir": "linux-64", + "timestamp": 1612295805671, + "version": "2.2.0" + }, + "portalocker-2.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "1dbc185b428d66e04335d23d81db13b5", + "name": "portalocker", + "sha256": "e9f3ae1732670a6403dbd9e7c350163a1a780b5dad7fb167fffa3e4ba4b93d06", + "size": 28324, + "subdir": "linux-64", + "timestamp": 1612296003664, + "version": "2.2.0" + }, + "portalocker-2.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "36506e9b69a4970ef5f58e2101498b63", + "name": "portalocker", + "sha256": "b060988398f9a44b81e2dbb6cd117cb4f8e2fc3bc7acca6dfe376f300eb73725", + "size": 28430, + "subdir": "linux-64", + "timestamp": 1612296011993, + "version": "2.2.0" + }, + "portalocker-2.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "62ded7db50f8de6aa6543fb4af5409ca", + "name": "portalocker", + "sha256": "ca2eb05156bf5690c9f8207c73f46a79e72b09ed63493e43db71441b9b5d68b7", + "size": 28539, + "subdir": "linux-64", + "timestamp": 1612295976238, + "version": "2.2.0" + }, + "portalocker-2.2.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "877a93906f6042fd9b35a9be31b5602c", + "name": "portalocker", + "sha256": "dd2b1857c34f88af1faa730c0b07486937a30912f6ae2b4a2e9c907295455557", + "size": 28244, + "subdir": "linux-64", + "timestamp": 1613764168396, + "version": "2.2.1" + }, + "portalocker-2.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "2fdef898ebb229312ba8ee17ca89317b", + "name": "portalocker", + "sha256": "e10dd61b26c87b6cc3074a3abf9342f03dcf9314fff83fbee6544868cb516717", + "size": 28301, + "subdir": "linux-64", + "timestamp": 1613764176523, + "version": "2.2.1" + }, + "portalocker-2.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "fd4992e9313728cc26b5d86f45330386", + "name": "portalocker", + "sha256": "6ed9a49bced340c810a12d74659a5cc3301c2f2169c480328cfd78eedcc7e4b1", + "size": 28404, + "subdir": "linux-64", + "timestamp": 1613764162610, + "version": "2.2.1" + }, + "portalocker-2.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "b9a1fb7456bfee745ca510ff6006ae33", + "name": "portalocker", + "sha256": "11e2bd9e8811b1f8529ee14e6a6511fdfdee602b8240c809b154ba052b380a55", + "size": 28478, + "subdir": "linux-64", + "timestamp": 1613763398576, + "version": "2.2.1" + }, + "portalocker-2.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "1c3db5be7b40c4da6324b4f7a5274f1b", + "name": "portalocker", + "sha256": "05a27b1f0e56e7779913b1de4aa28098777dfcfebff0a97ea9d3d14ff6fe53e5", + "size": 28694, + "subdir": "linux-64", + "timestamp": 1640806843265, + "version": "2.3.0" + }, + "portalocker-2.3.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "7022931753558a6aa61ec3649e2b0026", + "name": "portalocker", + "sha256": "ed5e567771bc75dfd731a71d6dae9e4b19f2db8ffa51923e944afa095ea6adb5", + "size": 35198, + "subdir": "linux-64", + "timestamp": 1676860427341, + "version": "2.3.0" + }, + "portalocker-2.3.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "f7af8d16692c7f033632dad0e2065dee", + "name": "portalocker", + "sha256": "9b42188e9b1d2698b662abd542b184039f085c31cb7ecc9f185ddba87d0d8941", + "size": 28297, + "subdir": "linux-64", + "timestamp": 1617135593719, + "version": "2.3.0" + }, + "portalocker-2.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "537ae0b538c63e1b817883ab45503e03", + "name": "portalocker", + "sha256": "402d70ce68e2743500b16f42723df1b9b6fa9aefb27d90028d52dbf8ff4ddfdf", + "size": 28427, + "subdir": "linux-64", + "timestamp": 1617135583140, + "version": "2.3.0" + }, + "portalocker-2.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "95d371235ca8dd08d94e1fb26872454c", + "name": "portalocker", + "sha256": "1af215f10d00719f1dad98693ef461c75ef5b07d29bb961c3fd51505381e4355", + "size": 28514, + "subdir": "linux-64", + "timestamp": 1617135589491, + "version": "2.3.0" + }, + "portalocker-2.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "d1e3c0e112aa5d382ab2454ae950cce1", + "name": "portalocker", + "sha256": "edcaa8dfbb942ba904fb52d47a30ba090abf3a95c92d91c6edea3c4cc7d95d42", + "size": 28589, + "subdir": "linux-64", + "timestamp": 1617133107238, + "version": "2.3.0" + }, + "portaudio-19.6.0-h14c3975_2.tar.bz2": { + "build": "h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "e8a9279e87a94424cd811eae06f1005d", + "name": "portaudio", + "sha256": "5a8fbc41dbe1ac865cd2a688e59d298b119f1242028d1271219811f9a9924d31", + "size": 80309, + "subdir": "linux-64", + "timestamp": 1530906545584, + "version": "19.6.0" + }, + "portaudio-19.6.0-h7b6447c_4.tar.bz2": { + "build": "h7b6447c_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "md5": "8682e5492603e9ce1a27fe996ae80f47", + "name": "portaudio", + "sha256": "96b0291e5167a65cb0c05dd256245791d61c6f2f35276fda511f19430c274708", + "size": 134853, + "subdir": "linux-64", + "timestamp": 1583787621961, + "version": "19.6.0" + }, + "portend-2.2-py27h1a604f0_0.tar.bz2": { + "build": "py27h1a604f0_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "tempora >=1.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c789562a61da068cd700dbaf49ea4bd", + "name": "portend", + "sha256": "170d7ee684cbd5f1b18e6f11d94a42d197500c263d5a223d6632600fa4a46e80", + "size": 9656, + "subdir": "linux-64", + "timestamp": 1507585901772, + "version": "2.2" + }, + "portend-2.2-py35h7ec60bb_0.tar.bz2": { + "build": "py35h7ec60bb_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "tempora >=1.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45b90bafb7904c026e0a77666dfa1b78", + "name": "portend", + "sha256": "fef3b6fcfd9ac3e4e8b5d74f0b8afe700c3ab749c4e2fd9d2d3ff20fa160564c", + "size": 9779, + "subdir": "linux-64", + "timestamp": 1507585916146, + "version": "2.2" + }, + "portend-2.2-py36h36a8bbd_0.tar.bz2": { + "build": "py36h36a8bbd_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "tempora >=1.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e12198c515860b6d6591fe9eec5ef77", + "name": "portend", + "sha256": "25cf2f87e215420c737cb9ab1f1b8af8070723897fe931aa9d4480952984d892", + "size": 9762, + "subdir": "linux-64", + "timestamp": 1507585905873, + "version": "2.2" + }, + "portend-2.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "tempora >=1.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17516f178339fe12e4cb5d0a420eee63", + "name": "portend", + "sha256": "09a6b367e4ae7e39b4dc4fe121564504c87a17c77b0f08b94c4e334e03f66b5c", + "size": 9372, + "subdir": "linux-64", + "timestamp": 1529425079822, + "version": "2.3" + }, + "portend-2.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "tempora >=1.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8dc501f1435af51eea727778546c7bd", + "name": "portend", + "sha256": "bf0d4a1d2d07d4674e0ffff1063eaddc29acc64dad30fe6ababd084da2af8623", + "size": 9489, + "subdir": "linux-64", + "timestamp": 1529425173969, + "version": "2.3" + }, + "portend-2.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "tempora >=1.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c093ca456656569ef3d088af232eda3", + "name": "portend", + "sha256": "13212bf55f51bc3cd10da5315ccb632584d1a126cd423f679751fc275d8dfd04", + "size": 9485, + "subdir": "linux-64", + "timestamp": 1529425084211, + "version": "2.3" + }, + "portend-2.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "tempora >=1.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b081a008b6cea194a1c05da9726bea1", + "name": "portend", + "sha256": "b18fb83cb359f9d6063043955f247de086f38edb17df6bde903dec87c53f25b8", + "size": 9491, + "subdir": "linux-64", + "timestamp": 1530812087791, + "version": "2.3" + }, + "portpicker-1.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "ad02383f8730df422a2378151768acdf", + "name": "portpicker", + "sha256": "1cd6a1a7125fc58d6c087d0409fd0346f07df8386a0a6d9cac478c33666fbcc6", + "size": 17142, + "subdir": "linux-64", + "timestamp": 1530905906624, + "version": "1.2.0" + }, + "portpicker-1.2.0-py27h86e0a49_0.tar.bz2": { + "build": "py27h86e0a49_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "faa4b8fbc993f373057c1cad4db5235e", + "name": "portpicker", + "sha256": "b9492579acc0f65abfe6cd44e599789eec60f1af7e47cf7fac04b38105f698c7", + "size": 16473, + "subdir": "linux-64", + "timestamp": 1508267238017, + "version": "1.2.0" + }, + "portpicker-1.2.0-py35h8f64c34_0.tar.bz2": { + "build": "py35h8f64c34_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "313b19225c5def336d5d383913434268", + "name": "portpicker", + "sha256": "408a127a694dcb638d35bd06dc7d7f4eff4c87d439cb6d0b3d77d1216cd1b9dd", + "size": 19613, + "subdir": "linux-64", + "timestamp": 1508267246844, + "version": "1.2.0" + }, + "portpicker-1.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "a26b0f7f39882559212e9a5dce2cca70", + "name": "portpicker", + "sha256": "61e41ddddbaa5051795400d01b92cb52ca3a2c7ff404ad7142351e428b0b6b60", + "size": 20287, + "subdir": "linux-64", + "timestamp": 1530905934867, + "version": "1.2.0" + }, + "portpicker-1.2.0-py36h7b3aa6a_0.tar.bz2": { + "build": "py36h7b3aa6a_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "44bdc9e0beef0daae0cff57ffd312102", + "name": "portpicker", + "sha256": "242ebad7fd11177d72eb6b005eba261e094751ee4459b929dcaf78da4557ee11", + "size": 19608, + "subdir": "linux-64", + "timestamp": 1508267236125, + "version": "1.2.0" + }, + "portpicker-1.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "2902b80f043323062dd434f4737107b8", + "name": "portpicker", + "sha256": "d8a2462c840a7e2593a6a64dd968eeb6c7839e103e1c1fce8fcc7f9ce4496bdb", + "size": 20311, + "subdir": "linux-64", + "timestamp": 1530905962010, + "version": "1.2.0" + }, + "portpicker-1.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "9a596b68192db03dba1702b89d07161f", + "name": "portpicker", + "sha256": "1f2d92a4917e6ae6343bdaddb40ef0b3fdad0db5ff1e73fad4a5a7394a3214ba", + "size": 150147, + "subdir": "linux-64", + "timestamp": 1548089723848, + "version": "1.3.0" + }, + "portpicker-1.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "5b675e03aee26b051f4d8d95fa749275", + "name": "portpicker", + "sha256": "35f258a43e1b92c29cc8b97e647a80e2a6a8486dfdf2802f4172753ddf3e7b1d", + "size": 155175, + "subdir": "linux-64", + "timestamp": 1548089729671, + "version": "1.3.0" + }, + "portpicker-1.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "ecc576ae46f1d097c9e60c5b2286f8a8", + "name": "portpicker", + "sha256": "03595a4005025d905aaec3dd7cc8070872eef08ceec946f17cdeb84960356721", + "size": 155219, + "subdir": "linux-64", + "timestamp": 1548089727595, + "version": "1.3.0" + }, + "portpicker-1.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "f3cec78eda69696a37d70e37866ad361", + "name": "portpicker", + "sha256": "e2694306893ca1f2e2769d52b38c486fd123c1b58b1cb745284fc6b269259ef2", + "size": 158020, + "subdir": "linux-64", + "timestamp": 1552363480705, + "version": "1.3.1" + }, + "portpicker-1.3.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "b0b29f4dcf047cb9f74c386e312dcec0", + "name": "portpicker", + "sha256": "167a3d8e866d23c0cc67827e536399420e45c8cdbd19dee979ecf43c85c31dce", + "size": 27586, + "subdir": "linux-64", + "timestamp": 1640792488530, + "version": "1.3.1" + }, + "portpicker-1.3.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "21335e90892eafaa2082f125d6d5d6c7", + "name": "portpicker", + "sha256": "309553d3e3ae3c874a1046ad0be89d0688ee9fb0b83e14f477290e077382468e", + "size": 29945, + "subdir": "linux-64", + "timestamp": 1676904140042, + "version": "1.3.1" + }, + "portpicker-1.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "0301e88c05d7104f4a7d64576ed9515e", + "name": "portpicker", + "sha256": "88e9f2f725eaba200a8b441a17b6ad9fbe521e78aa22a87144b2b4eff1770a84", + "size": 163003, + "subdir": "linux-64", + "timestamp": 1552363509921, + "version": "1.3.1" + }, + "portpicker-1.3.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "6b49464365a8fb9054599908d43d902f", + "name": "portpicker", + "sha256": "94b8997b4279a9bcb7cf9fd38d38e026172a2a5a13da3d22f0f1460defd73f48", + "size": 247242, + "subdir": "linux-64", + "timestamp": 1613556405245, + "version": "1.3.1" + }, + "portpicker-1.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "56a4f059fde667d3dc713574c65819b5", + "name": "portpicker", + "sha256": "6bfac086231df82e7519fe9ef2b09743b1606e2cdc9254e1e5442f409d7d2212", + "size": 163496, + "subdir": "linux-64", + "timestamp": 1552363417679, + "version": "1.3.1" + }, + "portpicker-1.3.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "cbe0c4cb39407b3e62009a1489df1a44", + "name": "portpicker", + "sha256": "eb10b6395cbe76a7e70776a6dd90ce1972f8a83efc8d22d581123e7c3eab59c9", + "size": 246375, + "subdir": "linux-64", + "timestamp": 1613555733670, + "version": "1.3.1" + }, + "portpicker-1.3.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "b08cc53dde1d45f6936196373d350fc4", + "name": "portpicker", + "sha256": "376cb2c0872efaaae74053f9ade00008242b66604e6dedc57e289672cb89a80c", + "size": 27919, + "subdir": "linux-64", + "timestamp": 1573040658515, + "version": "1.3.1" + }, + "portpicker-1.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "bc73af1fa7dbab5d78f269d103bfd612", + "name": "portpicker", + "sha256": "3fb4257bb233801bd37fbfcdaa4296f884bb6ea5627ea0c4c5cf00a1c707ee45", + "size": 247420, + "subdir": "linux-64", + "timestamp": 1613556402027, + "version": "1.3.1" + }, + "portpicker-1.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "98de4820b195a20536ce2080aee49597", + "name": "portpicker", + "sha256": "6466074388757200a276ffe8660b1a60b280fff054a383c84205a69f1b8eb496", + "size": 27894, + "subdir": "linux-64", + "timestamp": 1607007507295, + "version": "1.3.1" + }, + "portpicker-1.5.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "752f3ff94f128f4c0b436c60ff0996e1", + "name": "portpicker", + "sha256": "7477e56cb4a54277c2fc4da84dd4bf507e71611a059eb7f5fab166e3f51e1518", + "size": 26446, + "subdir": "linux-64", + "timestamp": 1679925940633, + "version": "1.5.2" + }, + "portpicker-1.5.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6754bbb4283514bcbeb9700732dfa01c", + "name": "portpicker", + "sha256": "3fcfbb5be3b52b098ce35c231aa5c134b86d4027a3a5aafe4009235a44bad302", + "size": 28462, + "subdir": "linux-64", + "timestamp": 1679925915698, + "version": "1.5.2" + }, + "portpicker-1.5.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a3c08f08242c831c1eccfb67cd78bb77", + "name": "portpicker", + "sha256": "fd7335d4d3cb3832a1c29a89067f83783eb1ae47a59eb07a36cfa091cac61390", + "size": 26383, + "subdir": "linux-64", + "timestamp": 1679925965040, + "version": "1.5.2" + }, + "portpicker-1.5.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dea60e0522e1ae253c236f2766888f1e", + "name": "portpicker", + "sha256": "9c0a48ba26ded433fc56644cc1b9d6b0a4a8becf4233c30573ed6e5dae943672", + "size": 26437, + "subdir": "linux-64", + "timestamp": 1679925988735, + "version": "1.5.2" + }, + "posix_ipc-1.0.4-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "8fb5477646ca49d5860c62181cf059ea", + "name": "posix_ipc", + "sha256": "d6fcb4ab4d1299eb13b505ee19abc1cd58c85bc20eecd6f6eb8be0b6bfa75f8a", + "size": 15599, + "subdir": "linux-64", + "timestamp": 1527110167598, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "b313e5baacbec049d958703ea109004d", + "name": "posix_ipc", + "sha256": "4ab77eb9e0544cb74d632d92c0c7ff46b727ba5e33d427b6aa00a126abe4a9a1", + "size": 155209, + "subdir": "linux-64", + "timestamp": 1560789526659, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "cdc4e28d62b4204ae5536b3ecdc51226", + "name": "posix_ipc", + "sha256": "16f84e81885ef0ad2f8e932c220fbb7c1730a5ba4618c1aebb3e5af3b0764ebb", + "size": 49559, + "subdir": "linux-64", + "timestamp": 1640792512526, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "md5": "6158ea203c2dfca80df249d71f87ce86", + "name": "posix_ipc", + "sha256": "05e44d99af986d8b8212f7fa258402e842e27ae9af4deb8e33a4a9b0d6516d9c", + "size": 16480, + "subdir": "linux-64", + "timestamp": 1676907489981, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "b5896d16297b8a5fcbdf441119ccead7", + "name": "posix_ipc", + "sha256": "675508713420ea25bdb46b6e98e01ad4be8532e46f2ef550a9740d6c0bcf0d11", + "size": 15921, + "subdir": "linux-64", + "timestamp": 1527110152421, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "c09c483008e8aeda9e19b45b69860115", + "name": "posix_ipc", + "sha256": "28f342283f2dd7f90ae81b38c53509ac725417a1f5738aa7922eca4c70ff23fc", + "size": 15906, + "subdir": "linux-64", + "timestamp": 1527110157355, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "c5353e59781a91c866e1e205ade85a77", + "name": "posix_ipc", + "sha256": "bdcd2f1ef4ba3adeb7306702cc37eade813b551a77012a3f25f5c5293efe556c", + "size": 234036, + "subdir": "linux-64", + "timestamp": 1613555754244, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "cf22c8b95ab2abee06638273bd7bfbb0", + "name": "posix_ipc", + "sha256": "1f0cc29c1bc0cc3a257f8a0f87d90ca4eb42b68da9d12abb08b948e783855f88", + "size": 155440, + "subdir": "linux-64", + "timestamp": 1560789545855, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "d6cb3faf372861a173ae2dc72b532ed3", + "name": "posix_ipc", + "sha256": "d4f2a8f95860d99b565a899a2a98ef3ae965a732560dfa2541d65656fca5ccf3", + "size": 233697, + "subdir": "linux-64", + "timestamp": 1613556406756, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "30862e9aded0bf662ba13417d6b377aa", + "name": "posix_ipc", + "sha256": "96c614dbc7efea4597370dbb206f816ddc4a72f0c62f2762b05373b601281ae1", + "size": 155569, + "subdir": "linux-64", + "timestamp": 1560789509638, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "20cad44fcb040541b130b92678edabd5", + "name": "posix_ipc", + "sha256": "9352285d5a9abe1ab5af84ffae0b01739a757036ea329c738f49e39a1ca18702", + "size": 233893, + "subdir": "linux-64", + "timestamp": 1613556415152, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "d62be0ac630ca311adbde04f71f78480", + "name": "posix_ipc", + "sha256": "c5a97d91f4aac653368bc3555d16ef1d4df1e1d3fd33df4c3efa48f59f4ccd83", + "size": 23270, + "subdir": "linux-64", + "timestamp": 1573730236889, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "f5a5fdd206986d8166097446207e6d95", + "name": "posix_ipc", + "sha256": "986094a4cf4e6e416844ba3f0fb734e372a11e6a68c470e9144d1ab093b59b13", + "size": 234153, + "subdir": "linux-64", + "timestamp": 1613556356672, + "version": "1.0.4" + }, + "postgresql-10.3-h1ad7b7a_0.tar.bz2": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16,<1.17.0a0", + "libgcc-ng >=7.2.0", + "libpq 10.3 h1ad7b7a_0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "99d2eaa5426466c914dc2957fd37117f", + "name": "postgresql", + "sha256": "c0f32c1e97ed089289238d535a2e53655e6ee4921b4a3ca0c80f8d3cd2c63599", + "size": 4294147, + "subdir": "linux-64", + "timestamp": 1522426575765, + "version": "10.3" + }, + "postgresql-10.4-h1ad7b7a_0.tar.bz2": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.2.0", + "libpq 10.4 h1ad7b7a_0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "f2d0b8dfc599451c32be7a339a9607fe", + "name": "postgresql", + "sha256": "e9f7bda49c4df541c40114d0df4ecea6a2a0f179e4b1b148f0f1fbc16cbf33ff", + "size": 4297401, + "subdir": "linux-64", + "timestamp": 1532852660167, + "version": "10.4" + }, + "postgresql-10.5-h1ad7b7a_0.tar.bz2": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.2.0", + "libpq 10.5 h1ad7b7a_0", + "openssl >=1.0.2p,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "db273d64bf2bbdcfd88577b9cb94c46d", + "name": "postgresql", + "sha256": "8b004923ded2c53db5bbb4d69c45e7f2105a87b387988c89623b50eaeb90f345", + "size": 4305564, + "subdir": "linux-64", + "timestamp": 1534395012602, + "version": "10.5" + }, + "postgresql-11.1-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libpq 11.1 h20c2e04_0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "a526060d999eb94dc44b57de980e7134", + "name": "postgresql", + "sha256": "f1bf12c7f39581f56ac3e21149119f8fee301fafb4f9202dfe352e28725b566f", + "size": 4559879, + "subdir": "linux-64", + "timestamp": 1545233729193, + "version": "11.1" + }, + "postgresql-11.2-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libpq 11.2 h20c2e04_0", + "openssl >=1.1.1b,<1.1.2a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "d8cf607b84847736cd27b83ed02586d2", + "name": "postgresql", + "sha256": "3cf036cbcb7b887c185e4734057ddc44c985021ead104a3a3dcbcbff96d87e47", + "size": 4449906, + "subdir": "linux-64", + "timestamp": 1552511065718, + "version": "11.2" + }, + "postgresql-12.2-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.17.1,<1.18.0a0", + "libgcc-ng >=7.3.0", + "libpq 12.2 h20c2e04_0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "04fac2cff6ce8aa1d317a4da9df77d72", + "name": "postgresql", + "sha256": "543da5c3ddb9c6def897672f0a42d3ec7942dcb1904660192f747fd04fb4d7a4", + "size": 4658657, + "subdir": "linux-64", + "timestamp": 1582128112417, + "version": "12.2" + }, + "postgresql-12.2-h553bfba_1.tar.bz2": { + "build": "h553bfba_1", + "build_number": 1, + "depends": [ + "krb5 >=1.19.1,<1.20.0a0", + "libgcc-ng >=7.3.0", + "libpq 12.2 h553bfba_1", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "6c2b888333a5d398c9e2f2b13cf4ac01", + "name": "postgresql", + "sha256": "c127a8e50c5c14fdae6384f11e4a2541c893cbaab64631f48754a492ba3e3b4f", + "size": 4649569, + "subdir": "linux-64", + "timestamp": 1621644128584, + "version": "12.2" + }, + "postgresql-12.9-h16c4e8d_3.tar.bz2": { + "build": "h16c4e8d_3", + "build_number": 3, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libpq 12.9 h16c4e8d_3", + "openssl >=1.1.1o,<1.1.2a", + "readline >=8.0,<9.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "md5": "657192cf31b8465101fb200916c7a5e2", + "name": "postgresql", + "sha256": "f15a2a023dfee3c4b32728e295bba8e0695211b6d5601c4482c22ed5335a83ea", + "size": 4595598, + "subdir": "linux-64", + "timestamp": 1656062959900, + "version": "12.9" + }, + "postgresql-12.9-hc2c5182_1.tar.bz2": { + "build": "hc2c5182_1", + "build_number": 1, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "libpq 12.9 hc2c5182_1", + "openssl >=1.1.1l,<1.1.2a", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "caa324d5cbb653be48211036b93b6dcb", + "name": "postgresql", + "sha256": "236f55953267222f3b16b56f0f6585f547c897db5d8d5d59f1fd401890168e12", + "size": 4674921, + "subdir": "linux-64", + "timestamp": 1638892716446, + "version": "12.9" + }, + "postgresql-12.9-hc2c5182_2.tar.bz2": { + "build": "hc2c5182_2", + "build_number": 2, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "libpq 12.9 hc2c5182_2", + "openssl >=1.1.1o,<1.1.2a", + "readline >=8.0,<9.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "md5": "a91d46176425cbd64206a31d696d9dcd", + "name": "postgresql", + "sha256": "2e6109769808b537545a1ac21c9c32e218e713f985ab6681b097e0f9a1fdb975", + "size": 4668205, + "subdir": "linux-64", + "timestamp": 1655472407217, + "version": "12.9" + }, + "postgresql-9.5.10-hc58ae56_0.tar.bz2": { + "build": "hc58ae56_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PostgreSQL", + "md5": "08f05b76f08960afb1db4d5154c9cde4", + "name": "postgresql", + "sha256": "85c4dd4e4f5523a5a95e58aaa59eced3035bc66e2de8ed61f694a4b1858ae5cd", + "size": 6851583, + "subdir": "linux-64", + "timestamp": 1510350812412, + "version": "9.5.10" + }, + "postgresql-9.6.5-hc049884_0.tar.bz2": { + "build": "hc049884_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2l,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PostgreSQL", + "md5": "a0a4064c43e7340905eba47eaf0d9c8a", + "name": "postgresql", + "sha256": "92c609cf15cf631b7546784133efc22abd6fb07baa5c205e2edee16f3f0ed64b", + "size": 7108370, + "subdir": "linux-64", + "timestamp": 1509502830242, + "version": "9.6.5" + }, + "postgresql-9.6.6-h14fc437_0.tar.bz2": { + "build": "h14fc437_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PostgreSQL", + "md5": "fad242676bdcea37948481f057946ff6", + "name": "postgresql", + "sha256": "ad355c5a3630e80cce8144861f1116d5a8a0d9c2e871508ba43967b34e0f2eb5", + "size": 7116971, + "subdir": "linux-64", + "timestamp": 1510610870969, + "version": "9.6.6" + }, + "postgresql-9.6.6-h55bab6d_0.tar.bz2": { + "build": "h55bab6d_0", + "build_number": 0, + "depends": [ + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PostgreSQL", + "md5": "c2b97922c949b2955228a2acded620cd", + "name": "postgresql", + "sha256": "6dd0ccd6c25d16f3ef8b6ea15ee0b22604da704c560d000055d25588ed4a2bbc", + "size": 7121645, + "subdir": "linux-64", + "timestamp": 1511386757152, + "version": "9.6.6" + }, + "postgresql-9.6.6-h95429c6_1.tar.bz2": { + "build": "h95429c6_1", + "build_number": 1, + "depends": [ + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PostgreSQL", + "md5": "b85ffab9adad02d356d73af6e09fc2f7", + "name": "postgresql", + "sha256": "057408a693218a22038c6b150ee1851af402de2ce37021904638a547160cb8e4", + "size": 7118153, + "subdir": "linux-64", + "timestamp": 1511816990411, + "version": "9.6.6" + }, + "pre-commit-2.20.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cfgv >=2.0.0", + "identify >=1.0.0", + "nodeenv >=0.11.1", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.1", + "toml", + "virtualenv >=20.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d4c78fbece1552ccb766b52a2836281", + "name": "pre-commit", + "sha256": "d921a12911eaedbf2f6bccbbf90dad76bb69ec8a627ab00c76765ae4fc5d3297", + "size": 239603, + "subdir": "linux-64", + "timestamp": 1663261435133, + "version": "2.20.0" + }, + "pre-commit-2.20.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cfgv >=2.0.0", + "identify >=1.0.0", + "nodeenv >=0.11.1", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.1", + "toml", + "virtualenv >=20.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f6759bd1829d92821a3a5c1a80510fe", + "name": "pre-commit", + "sha256": "07dd6c221d1cbbc7a738433761b727d48e2a81f3ab1c3a872068641b3d83eac0", + "size": 281111, + "subdir": "linux-64", + "timestamp": 1676860444360, + "version": "2.20.0" + }, + "pre-commit-2.20.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cfgv >=2.0.0", + "identify >=1.0.0", + "importlib_metadata", + "nodeenv >=0.11.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "toml", + "virtualenv >=20.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14a96ea1eb4f326c8eec61ee9479346b", + "name": "pre-commit", + "sha256": "3b961be83bd318acce4847be1a364d0d4f55e4057310ff6e5fa3dfa92c981c11", + "size": 236524, + "subdir": "linux-64", + "timestamp": 1663261463918, + "version": "2.20.0" + }, + "pre-commit-2.20.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cfgv >=2.0.0", + "identify >=1.0.0", + "nodeenv >=0.11.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "toml", + "virtualenv >=20.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4545afa82fdadda7e74699d99bc864d", + "name": "pre-commit", + "sha256": "0b1493c6e72dc825f875a4931ee1c69317595654e2d3fbce04246ac7e30551f9", + "size": 237487, + "subdir": "linux-64", + "timestamp": 1663261490955, + "version": "2.20.0" + }, + "pre-commit-2.20.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cfgv >=2.0.0", + "identify >=1.0.0", + "nodeenv >=0.11.1", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "toml", + "virtualenv >=20.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96f200eade5effac19e540361652eee1", + "name": "pre-commit", + "sha256": "2796580f49ab25eaf9b7fcd4bbe712cdbdd7006ac65289cc4a62df516673b79f", + "size": 237853, + "subdir": "linux-64", + "timestamp": 1663261517105, + "version": "2.20.0" + }, + "pre-commit-3.2.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cfgv >=2.0.0", + "identify >=1.0.0", + "nodeenv >=0.11.1", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.1", + "virtualenv >=20.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ae3c07a63e615fce8f9410a124d6ed5b", + "name": "pre-commit", + "sha256": "890005f2b7ffbc300828a272d3fe672c46bae0c6753d065b4b62157abb600939", + "size": 245493, + "subdir": "linux-64", + "timestamp": 1679988375222, + "version": "3.2.1" + }, + "pre-commit-3.2.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cfgv >=2.0.0", + "identify >=1.0.0", + "nodeenv >=0.11.1", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.1", + "virtualenv >=20.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7368e089345318835722245194652335", + "name": "pre-commit", + "sha256": "15ac5b0d124c9218eb6e70982724524173b648d9c7792c076c9cb17b1608703a", + "size": 286265, + "subdir": "linux-64", + "timestamp": 1679988336496, + "version": "3.2.1" + }, + "pre-commit-3.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cfgv >=2.0.0", + "identify >=1.0.0", + "nodeenv >=0.11.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "virtualenv >=20.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d177a98f74a6b061389e3b375e5f651", + "name": "pre-commit", + "sha256": "0a4ae62471b252eebde13109bf141fbf2fd535c5419ccad87be5ee11bcefb192", + "size": 243596, + "subdir": "linux-64", + "timestamp": 1679988294944, + "version": "3.2.1" + }, + "pre-commit-3.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cfgv >=2.0.0", + "identify >=1.0.0", + "nodeenv >=0.11.1", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "virtualenv >=20.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d4f5b2a78582f1e8f8b93b0b074d477", + "name": "pre-commit", + "sha256": "821f68a7571bcace53e9d1d82672f3af0833be2c61aebbcdd69e23e1e5563b69", + "size": 243908, + "subdir": "linux-64", + "timestamp": 1679988412331, + "version": "3.2.1" + }, + "preshed-1.0.0-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7e799c4108c004ef9bee3c2e8c66f213", + "name": "preshed", + "sha256": "7c62dc94199c795b0a30f3c9b0e74cfe15476ba65f18a195530f7f2d5fd0efd6", + "size": 81402, + "subdir": "linux-64", + "timestamp": 1530905998666, + "version": "1.0.0" + }, + "preshed-1.0.0-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b9fb86c47c88210dc6f7743d8f73783f", + "name": "preshed", + "sha256": "ca2d2975108985d3249ea8a5bc3e483bf588dff9551957cb1ba14aa206bf0f4a", + "size": 85003, + "subdir": "linux-64", + "timestamp": 1530906036306, + "version": "1.0.0" + }, + "preshed-1.0.0-py37hf484d3e_0.tar.bz2": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "35631318cfc68be6f38fdb6d19ebc74e", + "name": "preshed", + "sha256": "8de3f1184ce295d02147b82d9c83504124b51338552dc81bdad8ea0ebfd21fb6", + "size": 84709, + "subdir": "linux-64", + "timestamp": 1530906074434, + "version": "1.0.0" + }, + "preshed-1.0.1-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "544bcef03b36086fd2e8abbbd7e8c4a7", + "name": "preshed", + "sha256": "8eeda7e48ab52cd757c9cb8b9c74b1db3cbfc6f58412c54c5ab80028c5076f19", + "size": 80945, + "subdir": "linux-64", + "timestamp": 1535508980980, + "version": "1.0.1" + }, + "preshed-1.0.1-py35he6710b0_0.tar.bz2": { + "build": "py35he6710b0_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "01befd27ac2907931bc61d0638b39c72", + "name": "preshed", + "sha256": "804b81ff2252ea5d067b9c6887b5542a03cccc19a5590d461d03ed6e04eccb11", + "size": 85339, + "subdir": "linux-64", + "timestamp": 1535509026447, + "version": "1.0.1" + }, + "preshed-1.0.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "821f6f0c6549a36d235a1a30a431e53b", + "name": "preshed", + "sha256": "c3076a4d5f7d098d691f2541f831d51eae2b3b48d07ef94178a0edd74a036f88", + "size": 85390, + "subdir": "linux-64", + "timestamp": 1535508954037, + "version": "1.0.1" + }, + "preshed-1.0.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1c497eb4215b95008f3bf6764ba0ddc3", + "name": "preshed", + "sha256": "ff0b9caeedc3866644e99f9644a336199bb7f57d548d6de8c090a44b33d9bc04", + "size": 84933, + "subdir": "linux-64", + "timestamp": 1535508992974, + "version": "1.0.1" + }, + "preshed-2.0.1-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "dc20e18ae085b021fd50b683a168f767", + "name": "preshed", + "sha256": "2c990551c10fc2b1b13bf28e10e83f363bbe2804310e10be742d470f8a872b3c", + "size": 81557, + "subdir": "linux-64", + "timestamp": 1539718732584, + "version": "2.0.1" + }, + "preshed-2.0.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "328dbcf5999296bf30bda7f08eed5b0c", + "name": "preshed", + "sha256": "a26e7e0d7c13837d0ceafecf714b61689e0ae6bc7983b80a5a130cd0ea9ab895", + "size": 86023, + "subdir": "linux-64", + "timestamp": 1539718741547, + "version": "2.0.1" + }, + "preshed-2.0.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "cd68c9932af89376063f8ff78a3eb070", + "name": "preshed", + "sha256": "26559ab093d08d499372d5791337f9fe5eb87444d379792b5a3b74a72e753e00", + "size": 85610, + "subdir": "linux-64", + "timestamp": 1539718749468, + "version": "2.0.1" + }, + "preshed-2.0.1-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "90807e979d170ad3cb01803d4fcd745c", + "name": "preshed", + "sha256": "e10cf378314470f241ffa718b0750727cc4ed93547e051579d8218d9032e5d75", + "size": 98745, + "subdir": "linux-64", + "timestamp": 1573469607260, + "version": "2.0.1" + }, + "preshed-3.0.2-py27he6710b0_1.tar.bz2": { + "build": "py27he6710b0_1", + "build_number": 1, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash <1.1.0,>=0.28.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "55e88ddcf2aebd4e0e5092afd4e03caa", + "name": "preshed", + "sha256": "b569596f0c116cb661f111972476cc241dcbd82c851633ec8f5285942bb2a26b", + "size": 124731, + "subdir": "linux-64", + "timestamp": 1574380699024, + "version": "3.0.2" + }, + "preshed-3.0.2-py36he6710b0_1.tar.bz2": { + "build": "py36he6710b0_1", + "build_number": 1, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash <1.1.0,>=0.28.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e2feadec4027a013b8c05d7ffe734654", + "name": "preshed", + "sha256": "369dff0919a3fac37f41736366c1a925b0d9b8152c76063655d83ba404d4064e", + "size": 128657, + "subdir": "linux-64", + "timestamp": 1574380711991, + "version": "3.0.2" + }, + "preshed-3.0.2-py37he6710b0_1.tar.bz2": { + "build": "py37he6710b0_1", + "build_number": 1, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash <1.1.0,>=0.28.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "9b7daf99541e957d9f4d45979233e16f", + "name": "preshed", + "sha256": "b886a0377af0df866cac50d03ebdd8d65d2607fb213131d7a1bacc310b8f23c4", + "size": 128109, + "subdir": "linux-64", + "timestamp": 1574380705293, + "version": "3.0.2" + }, + "preshed-3.0.2-py38he6710b0_1.tar.bz2": { + "build": "py38he6710b0_1", + "build_number": 1, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash <1.1.0,>=0.28.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "1d675e0c1d2dcc65608c4c5554c48961", + "name": "preshed", + "sha256": "089d284216b21c765b98ad2afd1fffab7a07d5d1641b02a09a12efbae3af8560", + "size": 142312, + "subdir": "linux-64", + "timestamp": 1574380766960, + "version": "3.0.2" + }, + "preshed-3.0.2-py39h2531618_1.tar.bz2": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash <1.1.0,>=0.28.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "eea40caa5d6ed0f9e115773cbc40fe9a", + "name": "preshed", + "sha256": "26862450806e6f65b2ae531650172e3dd16c3bcb0db0761f1b9eb30c598cf83a", + "size": 133950, + "subdir": "linux-64", + "timestamp": 1608237194543, + "version": "3.0.2" + }, + "preshed-3.0.5-py310h295c915_4.tar.bz2": { + "build": "py310h295c915_4", + "build_number": 4, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "bf3b45fd9612b56845953aa8aaac1dab", + "name": "preshed", + "sha256": "d3f758850cded564338db9b21d8edb34945cc3c9d6312b71690d37af27d3257b", + "size": 540687, + "subdir": "linux-64", + "timestamp": 1640810023024, + "version": "3.0.5" + }, + "preshed-3.0.5-py36h2531618_1.tar.bz2": { + "build": "py36h2531618_1", + "build_number": 1, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f4c2f35da215ca69150a175e50606d68", + "name": "preshed", + "sha256": "5c7709d6d3b0adf384270fe2b25afe4d71b36fd7d7beefd6a16f5cfd80dbde06", + "size": 118280, + "subdir": "linux-64", + "timestamp": 1620312834704, + "version": "3.0.5" + }, + "preshed-3.0.5-py36h2531618_2.tar.bz2": { + "build": "py36h2531618_2", + "build_number": 2, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4770a77153a946025f7b432ff450f1b9", + "name": "preshed", + "sha256": "12ba5cb2cd75f366a53bb62b6a801cadcc96e8d7d3f1d9e1854a2ebfc42b6033", + "size": 118260, + "subdir": "linux-64", + "timestamp": 1620314209566, + "version": "3.0.5" + }, + "preshed-3.0.5-py36h2531618_4.tar.bz2": { + "build": "py36h2531618_4", + "build_number": 4, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b51a07ea797935d2bf3b1ae58d4ad692", + "name": "preshed", + "sha256": "24de78745810e3a41ccaab58fea6f0722cba650da72f8555d3b05c1478c0ac98", + "size": 121582, + "subdir": "linux-64", + "timestamp": 1621860918987, + "version": "3.0.5" + }, + "preshed-3.0.5-py37h2531618_1.tar.bz2": { + "build": "py37h2531618_1", + "build_number": 1, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7bc11d6fa0165438b2db61bad2cc458c", + "name": "preshed", + "sha256": "44d33f7fdc5d872e72282e073188ace6bbee9510311c8f84c13162685b6f6b32", + "size": 118495, + "subdir": "linux-64", + "timestamp": 1620313708320, + "version": "3.0.5" + }, + "preshed-3.0.5-py37h2531618_2.tar.bz2": { + "build": "py37h2531618_2", + "build_number": 2, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8953987386795a9c3d8e1ab5e0aad34b", + "name": "preshed", + "sha256": "bdd42f5507d8d67c2c853a129ee704a18eb7b7cac1fa31f84a26b3b2039c2bd7", + "size": 118487, + "subdir": "linux-64", + "timestamp": 1620314208660, + "version": "3.0.5" + }, + "preshed-3.0.5-py37h2531618_4.tar.bz2": { + "build": "py37h2531618_4", + "build_number": 4, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7ed499f157326f5c4acc42a28dd20aa3", + "name": "preshed", + "sha256": "4cb0e80c10662646fbe48f0e504921dfbc4724bd0dcde35b5f4e4ceceb7894b5", + "size": 121713, + "subdir": "linux-64", + "timestamp": 1621856053369, + "version": "3.0.5" + }, + "preshed-3.0.5-py38h2531618_1.tar.bz2": { + "build": "py38h2531618_1", + "build_number": 1, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "88487360db35c3f65112ad1731076f5d", + "name": "preshed", + "sha256": "1487d69d5ab7ecf3b573ac81075f5be19afa02d4adfd9ecf75de798fe8825a48", + "size": 125428, + "subdir": "linux-64", + "timestamp": 1620309640979, + "version": "3.0.5" + }, + "preshed-3.0.5-py38h2531618_2.tar.bz2": { + "build": "py38h2531618_2", + "build_number": 2, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "b50abeb3613b7cd3d206b0e924897cf9", + "name": "preshed", + "sha256": "072bb04c0fd1771f8c4b7c8fd24099b16ec430d849b978b0e72e3213c4ff67c8", + "size": 125319, + "subdir": "linux-64", + "timestamp": 1620314202802, + "version": "3.0.5" + }, + "preshed-3.0.5-py38h2531618_4.tar.bz2": { + "build": "py38h2531618_4", + "build_number": 4, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "72a5f106e8aeba89b5a24dd8e1c3d254", + "name": "preshed", + "sha256": "fc89a7ab650b7b31947db5a051064d6177e7fe2f1be6f49c115275a200186447", + "size": 128745, + "subdir": "linux-64", + "timestamp": 1621860912002, + "version": "3.0.5" + }, + "preshed-3.0.5-py39h2531618_1.tar.bz2": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "71229a7b856e9668cc14293d06950a5b", + "name": "preshed", + "sha256": "156a0e055c30cb83b96d00f135eee4c7a40dedb11df810fcbe80ecb6946bb255", + "size": 124942, + "subdir": "linux-64", + "timestamp": 1620313711272, + "version": "3.0.5" + }, + "preshed-3.0.5-py39h2531618_2.tar.bz2": { + "build": "py39h2531618_2", + "build_number": 2, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "34aff205b68d5314dace3b01550d7dfc", + "name": "preshed", + "sha256": "b89dc250876ae66d8ec8de83e6074fb68fc0e79df0981d0ae6832846e91a4f24", + "size": 124991, + "subdir": "linux-64", + "timestamp": 1620313283003, + "version": "3.0.5" + }, + "preshed-3.0.5-py39h2531618_4.tar.bz2": { + "build": "py39h2531618_4", + "build_number": 4, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "dd8959b06870e760793581e846152d45", + "name": "preshed", + "sha256": "7336494032d17a0e0b3f256ba04f90d0f2ce6b552b5f4722e2574f0726d3492f", + "size": 128325, + "subdir": "linux-64", + "timestamp": 1621860918873, + "version": "3.0.5" + }, + "preshed-3.0.6-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "53ad3eec646e705f9a9938b13328949e", + "name": "preshed", + "sha256": "bb2b8a61c1f12edaccf67da8497d280bc25e6578f94d9dcf411d8e976a4a1da4", + "size": 541498, + "subdir": "linux-64", + "timestamp": 1651241041994, + "version": "3.0.6" + }, + "preshed-3.0.6-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "586ca516919af39a44109be9c3ae1418", + "name": "preshed", + "sha256": "23c198a35ba098e78c49208cc8036055bdadb42bab0c3ceb35f0f3136552890d", + "size": 120003, + "subdir": "linux-64", + "timestamp": 1676841803335, + "version": "3.0.6" + }, + "preshed-3.0.6-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c6b6bfae91f1387c93e957a3c4186472", + "name": "preshed", + "sha256": "a1fa721caafbafa96a60603b692b104683d07a406b49270e73c112b667318bdf", + "size": 118677, + "subdir": "linux-64", + "timestamp": 1651241119985, + "version": "3.0.6" + }, + "preshed-3.0.6-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2591bdd9e75ffbd47fd2a4201df00877", + "name": "preshed", + "sha256": "189ed591b089b19dabb1bf64f2859bbd4e67300551f65dfba7b8b4bee8005880", + "size": 125495, + "subdir": "linux-64", + "timestamp": 1651240988092, + "version": "3.0.6" + }, + "preshed-3.0.6-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f22ab676b5246a3dd26446c267377daa", + "name": "preshed", + "sha256": "c08a651c9fde039ba836c4afe8c9e10a8e1873da93d1db187d6b55599538641b", + "size": 125283, + "subdir": "linux-64", + "timestamp": 1651241081118, + "version": "3.0.6" + }, + "pretend-1.0.8-py27hed95a35_0.tar.bz2": { + "build": "py27hed95a35_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1f96f7fccccb2c490b2e0aab951df9cb", + "name": "pretend", + "sha256": "f2d2eb7d8c7ddc35c518e194f5b779c8e764298c92d83079a16dbaa2ed9480d2", + "size": 8700, + "subdir": "linux-64", + "timestamp": 1505691929052, + "version": "1.0.8" + }, + "pretend-1.0.8-py35h155362e_0.tar.bz2": { + "build": "py35h155362e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6060b6b9e8dc9ed8c8131fb11db8db33", + "name": "pretend", + "sha256": "1560150f15eab7c1d3353d8b9fd078a207e1793736842d891d3b5f307b0626df", + "size": 8933, + "subdir": "linux-64", + "timestamp": 1505691939581, + "version": "1.0.8" + }, + "pretend-1.0.8-py36h6e1c97c_0.tar.bz2": { + "build": "py36h6e1c97c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d591780a30bfa48300e33410deccd839", + "name": "pretend", + "sha256": "e2f2ae0d87f778e08ed45c2cc9f0584c43fd43eacc196c5f66876d9e37454819", + "size": 8950, + "subdir": "linux-64", + "timestamp": 1505691950271, + "version": "1.0.8" + }, + "pretend-1.0.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0ed0c4cde90ffaf63cb4d6027ac0fae6", + "name": "pretend", + "sha256": "ad18c4bf9503219e4f3beaff3ff2e43108cf19c24d2fb24819abb91d01298859", + "size": 9089, + "subdir": "linux-64", + "timestamp": 1524087177661, + "version": "1.0.9" + }, + "pretend-1.0.9-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "07398efc0a0685f13c4d23b46aadacac", + "name": "pretend", + "sha256": "66f223fb52b3f2f4bda1fac40b8f73f494a4b832e642cdfa4bf36eff5a785a1d", + "size": 9516, + "subdir": "linux-64", + "timestamp": 1640792530803, + "version": "1.0.9" + }, + "pretend-1.0.9-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c9a39f89b8d7909780b89c6171bbf116", + "name": "pretend", + "sha256": "2779136b1709d8ec8cfe98e51ca5fc01ea47e69c592b24251d988b4532ec9f00", + "size": 11037, + "subdir": "linux-64", + "timestamp": 1676860459614, + "version": "1.0.9" + }, + "pretend-1.0.9-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7aac98268c624e163a47ea4a07b5227b", + "name": "pretend", + "sha256": "1017843ec20897c5bc2b5a034ba41b82e89eec11986a9890a2f1f59dae39c2bc", + "size": 9325, + "subdir": "linux-64", + "timestamp": 1524087148691, + "version": "1.0.9" + }, + "pretend-1.0.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "26d51759bd9a97997de9ea0c4ce4ab2b", + "name": "pretend", + "sha256": "e1354aed98c39f149dfcbde6c6f6d3cca95dd33cee5440bd9762a206610a645b", + "size": 9304, + "subdir": "linux-64", + "timestamp": 1524087207108, + "version": "1.0.9" + }, + "pretend-1.0.9-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "54e80ba0abfb1f7c5691f7a424fe3474", + "name": "pretend", + "sha256": "5349e5e9c8b64f6e7820ae9e4585f0710b752397342f45c1078c302d96eb313d", + "size": 10715, + "subdir": "linux-64", + "timestamp": 1605213669292, + "version": "1.0.9" + }, + "pretend-1.0.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "096675cdd022eac2f6640e49fbbd9e57", + "name": "pretend", + "sha256": "75893fb18489172cdc00f5d50738ef8e85848ee05798a31c48fea6901114904f", + "size": 9200, + "subdir": "linux-64", + "timestamp": 1530732963809, + "version": "1.0.9" + }, + "pretend-1.0.9-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "46d46c2d582110470a6668f8029ef17b", + "name": "pretend", + "sha256": "131f63342429c0829e28b2dd2f043c30227035d67f656ece4e44b2ca7ce97eb5", + "size": 10695, + "subdir": "linux-64", + "timestamp": 1605213685419, + "version": "1.0.9" + }, + "pretend-1.0.9-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fc6d7ce9a8be759b3d28658a222ddb14", + "name": "pretend", + "sha256": "5fbc3ad9231a1a1f611dbdfe846c206bd2cf662ff8c3cb29f93cbcac4c12bfc9", + "size": 9708, + "subdir": "linux-64", + "timestamp": 1573040669550, + "version": "1.0.9" + }, + "pretend-1.0.9-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5edc36ab53b01693030221299760b241", + "name": "pretend", + "sha256": "477fbff3473eda33ea95bf5588e5fa0db4d68eb0e8557f543351c56759da18d0", + "size": 10761, + "subdir": "linux-64", + "timestamp": 1605213727891, + "version": "1.0.9" + }, + "pretend-1.0.9-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dec10144d6fa115be1f1165a4b4f3882", + "name": "pretend", + "sha256": "39edc0ed34fa2885f24e204635542d62580b3bb653c0dfccbcdd1e2dce0da098", + "size": 10697, + "subdir": "linux-64", + "timestamp": 1605213720193, + "version": "1.0.9" + }, + "prettytable-3.5.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "ptable >=9999" + ], + "depends": [ + "python >=3.10,<3.11.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c97b8199730da4ac9f3173da116b0158", + "name": "prettytable", + "sha256": "634c9f69fbd2a336264d18ee0262ae911b11fcb44c01e2e53dcc9e1536c28881", + "size": 47320, + "subdir": "linux-64", + "timestamp": 1671655718202, + "version": "3.5.0" + }, + "prettytable-3.5.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "ptable >=9999" + ], + "depends": [ + "python >=3.11,<3.12.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7d15c0f73f62c097f3d6e61a498e2846", + "name": "prettytable", + "sha256": "d1a14c03ae48be716c1cb2cb120ff73e2fbc0115eb5e249f172b57efad280fb5", + "size": 60156, + "subdir": "linux-64", + "timestamp": 1676845213650, + "version": "3.5.0" + }, + "prettytable-3.5.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "ptable >=9999" + ], + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "51debb0a0f71c9cc2826b32b6bacfb9a", + "name": "prettytable", + "sha256": "6e9c9f97402c4dd30a4f2aefce5500fc622da2d8f4944c4d53ebc099c85241c5", + "size": 47148, + "subdir": "linux-64", + "timestamp": 1671655696079, + "version": "3.5.0" + }, + "prettytable-3.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "ptable >=9999" + ], + "depends": [ + "python >=3.8,<3.9.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fc3de468085982e53fe70f6dc9745eb3", + "name": "prettytable", + "sha256": "fefb2366a6946f18cc3b3432d267bdb09429952d477ef6e83f4a8a2d2d8ab423", + "size": 47184, + "subdir": "linux-64", + "timestamp": 1671655739953, + "version": "3.5.0" + }, + "prettytable-3.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "ptable >=9999" + ], + "depends": [ + "python >=3.9,<3.10.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "67bb00a5e4ddaacb688818368dbae971", + "name": "prettytable", + "sha256": "b27d8414bde0b47f4a45ff125bd7989ae3072423122f982f2614ac7871a2ced5", + "size": 47109, + "subdir": "linux-64", + "timestamp": 1671655673437, + "version": "3.5.0" + }, + "priority-1.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "0b2df3e96b58418c75233d6c934a56fe", + "name": "priority", + "sha256": "8d2ecc0bffe8fecf6572dedcdbce22072a2d7fd732b316d59a739d1888831590", + "size": 15863, + "subdir": "linux-64", + "timestamp": 1530919398155, + "version": "1.3.0" + }, + "priority-1.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "7253164fd4d453c03c48284e1b32a83f", + "name": "priority", + "sha256": "0f4ffe8306ce6b2c2c0ee030796e36960fa068a6df28c82bfcb83f5144e2d53c", + "size": 16419, + "subdir": "linux-64", + "timestamp": 1640792548420, + "version": "1.3.0" + }, + "priority-1.3.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "ea202b11de5b1e10ed50b362d26f2a95", + "name": "priority", + "sha256": "d32e5712386b024f121e0b7df281a1f9bc6550a8f0232ec1ffba45c67380d503", + "size": 19117, + "subdir": "linux-64", + "timestamp": 1676907504452, + "version": "1.3.0" + }, + "priority-1.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "5c4a2d4b780b758e050d2d2bfb8feb98", + "name": "priority", + "sha256": "26ec92b66872a59e7d6e0c0d31def57177829b6c32bdc44c206179fdbd3e0c7e", + "size": 16128, + "subdir": "linux-64", + "timestamp": 1530919342367, + "version": "1.3.0" + }, + "priority-1.3.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "b24598bc9171a7166d443414a409129c", + "name": "priority", + "sha256": "6232d19eb4c2c87fed783646b43e0740e7dbbdb7093ce2154821da38ad1ae0cf", + "size": 238100, + "subdir": "linux-64", + "timestamp": 1614082674243, + "version": "1.3.0" + }, + "priority-1.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "739dd0884cf967db13c4ddb8ba54dbca", + "name": "priority", + "sha256": "28b1b9a8710cdc30b291b954bd835ec1837a5914803853d7759f245cf834a080", + "size": 16148, + "subdir": "linux-64", + "timestamp": 1530919370497, + "version": "1.3.0" + }, + "priority-1.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "a5b9428150efe80ed1a10a889e754221", + "name": "priority", + "sha256": "8e7eb3d0447d58da6e26f55f4954741570b54074304d341e47752ef2c2a65b81", + "size": 240150, + "subdir": "linux-64", + "timestamp": 1614082662374, + "version": "1.3.0" + }, + "priority-1.3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "f0400f11f9aefffe1764756ca5264c30", + "name": "priority", + "sha256": "eec284fbd21a9c13e2457f42686746da8583724393a91c5493e2609f15698235", + "size": 16638, + "subdir": "linux-64", + "timestamp": 1573040681352, + "version": "1.3.0" + }, + "priority-1.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "d87ee752e2138e291295ded6002b32a8", + "name": "priority", + "sha256": "5528a15c07359e350ec3aaf5eca0063d5d4ecec0654384e955f61f85bddd73d7", + "size": 239891, + "subdir": "linux-64", + "timestamp": 1614082668971, + "version": "1.3.0" + }, + "priority-1.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "27bfd1b4210c88e8ce517e4b0d860f9b", + "name": "priority", + "sha256": "2967ee59fa377285fad8f5a00ad0bcdf4dce16e189034534af24936b0bd888e0", + "size": 16576, + "subdir": "linux-64", + "timestamp": 1607007516530, + "version": "1.3.0" + }, + "prison-0.2.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "requests", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be867916b4c1a9c1e1dd999c34608a1a", + "name": "prison", + "sha256": "95f27e1d5436f122e6166c4bc0a05eafbf01e8d7ae918a0733e98be79065d333", + "size": 14007, + "subdir": "linux-64", + "timestamp": 1659783360869, + "version": "0.2.1" + }, + "prison-0.2.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "requests", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "19c122adf0671cda8481d22e95a9e2de", + "name": "prison", + "sha256": "509fa00716c0c0097fc3bdef63ed36360739dc2422d76826bf12717b89c027cf", + "size": 17256, + "subdir": "linux-64", + "timestamp": 1676828724805, + "version": "0.2.1" + }, + "prison-0.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd5218eaf630bb24df1bebbc85a061d2", + "name": "prison", + "sha256": "5ed007d7f35cd30fc84cd98d3b438c4a7d6fe34c1a0a339ff724ea0ba833cf9e", + "size": 13941, + "subdir": "linux-64", + "timestamp": 1659783259511, + "version": "0.2.1" + }, + "prison-0.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f6517093e52c2e121c7665b6767590f", + "name": "prison", + "sha256": "97009af6b609e82b12e74171649d821f79d3d102abd731e243fb987de937b584", + "size": 13920, + "subdir": "linux-64", + "timestamp": 1659783287459, + "version": "0.2.1" + }, + "prison-0.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11976a88927ffcea2f1eb449a8aeb4fa", + "name": "prison", + "sha256": "9f33509776257fef6b85ce6b45bfef303b2702cb1d540671b0d8f85f2a60d925", + "size": 13913, + "subdir": "linux-64", + "timestamp": 1659783319459, + "version": "0.2.1" + }, + "progress-1.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "6f511b16511f46ad224dd638a65783ff", + "name": "progress", + "sha256": "482f1c0f27e3f40a1c927223e5b0694c0580f908df051978a3b5e6295113a55f", + "size": 12673, + "subdir": "linux-64", + "timestamp": 1529956628447, + "version": "1.4" + }, + "progress-1.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "95d653b2a1e2d4a85bf8e597458a1fc4", + "name": "progress", + "sha256": "390fd30ba1d1be7cc5abd90e5aad5b4c33a446af813425dc2b8313bb12a7bde5", + "size": 13042, + "subdir": "linux-64", + "timestamp": 1529956635825, + "version": "1.4" + }, + "progress-1.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "d72b2a7464bb845582d870505715c27f", + "name": "progress", + "sha256": "0cfeef2cd581374f04f9cbcf48afbc0f6565292aa25d964884805eb7d1044c28", + "size": 13030, + "subdir": "linux-64", + "timestamp": 1529956595228, + "version": "1.4" + }, + "progress-1.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "b9b5d62fc846b3a6f3614ef3939ff81e", + "name": "progress", + "sha256": "fd1adcf848ece6d54ca8677ce2cc18c7492e9b6d2c018aef9ec3bf7eaa460b68", + "size": 12926, + "subdir": "linux-64", + "timestamp": 1530906105333, + "version": "1.4" + }, + "progress-1.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "1a5928dd732c81107603e0ee56a62e9c", + "name": "progress", + "sha256": "17e74653962659a27b68b0800974f74c15d96dc1b01b67cb324a4cb966ac5771", + "size": 13814, + "subdir": "linux-64", + "timestamp": 1552441014220, + "version": "1.5" + }, + "progress-1.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "0a4f5c64ba07e779833249ca0133b5b5", + "name": "progress", + "sha256": "9a94030c24c3a3e66756eef5b1731f4b6dae1abf67cd36f8bb7772bf7db99a8e", + "size": 13999, + "subdir": "linux-64", + "timestamp": 1640792566008, + "version": "1.5" + }, + "progress-1.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "614712a51d5a9b1d64e1af585e67b6c1", + "name": "progress", + "sha256": "910c3ceabae3a078aba66538dfc7aca71dc5f3d09b96adbb1c3eb7ac79c73425", + "size": 16864, + "subdir": "linux-64", + "timestamp": 1676860475772, + "version": "1.5" + }, + "progress-1.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "8e9d1701a713fa09911639b9834a6c4c", + "name": "progress", + "sha256": "7907fb67ab1887819d6f3099b2f56126517cf36cce907dc62b948d6b7f0ae4af", + "size": 14171, + "subdir": "linux-64", + "timestamp": 1552441180624, + "version": "1.5" + }, + "progress-1.5-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "11361bc2cb320dca8ef5af7954d1b99f", + "name": "progress", + "sha256": "75103f475ad1639d2c3cee681cf84cecd6fda82ba66ff77888285473b3824a9f", + "size": 14602, + "subdir": "linux-64", + "timestamp": 1614269530733, + "version": "1.5" + }, + "progress-1.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "27d4137619b21cee4a10e41af9d74dbc", + "name": "progress", + "sha256": "dda1b8aa2e1a01399b75f63bda650593a3e1dbfa9c7483a221de461a865bba9f", + "size": 14111, + "subdir": "linux-64", + "timestamp": 1552440998896, + "version": "1.5" + }, + "progress-1.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "5d4cd94749ac29bdafbbdf4d39ae3032", + "name": "progress", + "sha256": "ad62d74610424cb9ffe341de089685bc949a20e09e6319e2e109164dcfffb22e", + "size": 14523, + "subdir": "linux-64", + "timestamp": 1614270550861, + "version": "1.5" + }, + "progress-1.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "b3a155e92ead05db8dcfab463ae9e558", + "name": "progress", + "sha256": "9c065767e27982c61a7d20d7c6d5ef2699f3283541d10241747069cf763d7402", + "size": 13790, + "subdir": "linux-64", + "timestamp": 1573040695412, + "version": "1.5" + }, + "progress-1.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "05e9a15efe1bce5284ea2ef1a80e69d5", + "name": "progress", + "sha256": "c4cdb588566ef0f4bf43e2cacc64224010b7c6e8041d010a150ee87d94356fcc", + "size": 14609, + "subdir": "linux-64", + "timestamp": 1614270556092, + "version": "1.5" + }, + "progress-1.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "81e1948b13debaab1f2e2b7b54f3ac3b", + "name": "progress", + "sha256": "a1c077ae2b00b72120470169c4dbcc43633cdc2271c5e4ce54bd561f28ef9cd4", + "size": 14585, + "subdir": "linux-64", + "timestamp": 1614270555094, + "version": "1.5" + }, + "progressbar2-3.34.3-py27h93d0879_0.tar.bz2": { + "build": "py27h93d0879_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=2.7,<2.8.0a0", + "python-utils" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "685b5b1445eb9d163d1582282ed265da", + "name": "progressbar2", + "sha256": "13f85c60394706187a376ee3581072b068d2f67eeaf869284eb93c574a79174f", + "size": 38287, + "subdir": "linux-64", + "timestamp": 1511984437951, + "version": "3.34.3" + }, + "progressbar2-3.34.3-py35h6582cdf_0.tar.bz2": { + "build": "py35h6582cdf_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.5,<3.6.0a0", + "python-utils" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6e0bd5d16cbdbcd99086a2f24a86e80c", + "name": "progressbar2", + "sha256": "9532f07ee876851caa2df1ae1351352673108bb1c445e110e2872fd632d1d9b8", + "size": 38882, + "subdir": "linux-64", + "timestamp": 1511984460632, + "version": "3.34.3" + }, + "progressbar2-3.34.3-py36h0413d66_0.tar.bz2": { + "build": "py36h0413d66_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.6,<3.7.0a0", + "python-utils" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "da87829a22be8a4fcf05826cb9e54745", + "name": "progressbar2", + "sha256": "026301533c717c2e1030437b5a9465af60ecdd1a4d71d7ee6f0a69fc6ea3cb51", + "size": 38804, + "subdir": "linux-64", + "timestamp": 1511984433486, + "version": "3.34.3" + }, + "progressbar2-3.35.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=2.7,<2.8.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "99152c280933b538385a133e8b395548", + "name": "progressbar2", + "sha256": "71c1fb479dcb7e2ad6dc1c20b55b11b1391b74716169023a711dd4804eaf15be", + "size": 33723, + "subdir": "linux-64", + "timestamp": 1519674277466, + "version": "3.35.2" + }, + "progressbar2-3.35.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.5,<3.6.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9b7104e0bc888d1c5bb41f28f038ffe1", + "name": "progressbar2", + "sha256": "48fc9e1c7abbc2b290e96c4c36c68102ab40dfdd205a910ce86ec85c171409c8", + "size": 34356, + "subdir": "linux-64", + "timestamp": 1519674278206, + "version": "3.35.2" + }, + "progressbar2-3.35.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.6,<3.7.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88eafa78f52c600c3372e410fcafe01e", + "name": "progressbar2", + "sha256": "6df74c67ef84601c921edfa52d60ea0dfa5f70abac29aff2a1244e870cf69c09", + "size": 34321, + "subdir": "linux-64", + "timestamp": 1519674348862, + "version": "3.35.2" + }, + "progressbar2-3.36.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=2.7,<2.8.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6e08e4b99c970f231667178e831b5689", + "name": "progressbar2", + "sha256": "1a739bed8c311ba07ca1e7eea143b1192b5f88189b939e59916e7316e4fc2060", + "size": 34145, + "subdir": "linux-64", + "timestamp": 1522785670242, + "version": "3.36.0" + }, + "progressbar2-3.36.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.5,<3.6.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a5db02e8c3d6af0b62f1835178e1486b", + "name": "progressbar2", + "sha256": "fc3ea19612e317b3b54a65da90fb5b7522e511cf3719abdad229d75e0cda3117", + "size": 34675, + "subdir": "linux-64", + "timestamp": 1522785703552, + "version": "3.36.0" + }, + "progressbar2-3.36.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.6,<3.7.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8ee05cc9da8668770a6a6bf5d6b07b7e", + "name": "progressbar2", + "sha256": "b0eca75896dc6c096e1bc33553bd8a2e9e77c41b1e4f476194cc4aa719ff6358", + "size": 34645, + "subdir": "linux-64", + "timestamp": 1522785677616, + "version": "3.36.0" + }, + "progressbar2-3.37.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=2.7,<2.8.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d74579269a5fcfe8ffd421579c7f6283", + "name": "progressbar2", + "sha256": "985a372d7d239f6bdbc3be97a7780b75928f7ffb74b751ef780c774877fdec29", + "size": 34807, + "subdir": "linux-64", + "timestamp": 1524082444850, + "version": "3.37.1" + }, + "progressbar2-3.37.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.10,<3.11.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3a5c01c335b20c96c39bf84ed637cf0a", + "name": "progressbar2", + "sha256": "89b66b1ad36d27db53f8fd95652a383e40c3997b89c0e9eff57e2c92d296fd82", + "size": 35896, + "subdir": "linux-64", + "timestamp": 1640810044350, + "version": "3.37.1" + }, + "progressbar2-3.37.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.5,<3.6.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1b6f19ed1b388333942a8b2b3e5530ea", + "name": "progressbar2", + "sha256": "ade013464de9759bd8ad9602d1f6a046dfabe1b4b04b939a31f4d4b6fc398b7d", + "size": 35428, + "subdir": "linux-64", + "timestamp": 1524082574301, + "version": "3.37.1" + }, + "progressbar2-3.37.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.6,<3.7.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e28bf42842c02c9cacde6c329ac7382f", + "name": "progressbar2", + "sha256": "fadd3b811274be7a77e022dc27fb2bd7363dd20a0bbcea3bcd4490c2524f6066", + "size": 35389, + "subdir": "linux-64", + "timestamp": 1524082458600, + "version": "3.37.1" + }, + "progressbar2-3.37.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.6,<3.7.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1f63afaae765d5d90877cb80ac32675e", + "name": "progressbar2", + "sha256": "cafbfc73ae037e9c2db3a4447f8146a90926bb0e8ced0ce4cef60bed18ac69b2", + "size": 36989, + "subdir": "linux-64", + "timestamp": 1614270279032, + "version": "3.37.1" + }, + "progressbar2-3.37.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.7,<3.8.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2cb3ef67f9b668eca861e84eeffa67c3", + "name": "progressbar2", + "sha256": "e55c9f09ba6e2b4b2e20c8489b309c8cc42d788991a6957d3ad25c53c8d58abd", + "size": 35328, + "subdir": "linux-64", + "timestamp": 1530906170405, + "version": "3.37.1" + }, + "progressbar2-3.37.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.7,<3.8.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d2c714609772e5e70d7f5502fe5c4100", + "name": "progressbar2", + "sha256": "0c00c6f4f11c7fc8be154af502e70c1c6c76a98a8452bed9c27fd65f4c14c8ed", + "size": 37053, + "subdir": "linux-64", + "timestamp": 1614270566719, + "version": "3.37.1" + }, + "progressbar2-3.37.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.8,<3.9.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dbe02f67497904915be9afd9190d807b", + "name": "progressbar2", + "sha256": "3bde4bd8d2516e7fd2cbb6c4080b9a0669f34bde1762e0b59785f41cba09e796", + "size": 35981, + "subdir": "linux-64", + "timestamp": 1574177645058, + "version": "3.37.1" + }, + "progressbar2-3.37.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.8,<3.9.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9b9ef0c9dd0e62d960e01cfa9bf4e1de", + "name": "progressbar2", + "sha256": "0e3859580d617d8cad77eacb7d98f52c2a74a8a7e4c1380562fc2cfe50b8759b", + "size": 37211, + "subdir": "linux-64", + "timestamp": 1614270554387, + "version": "3.37.1" + }, + "progressbar2-3.37.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.9,<3.10.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4c7cb283e0d4c01b8f542a95cd43da3e", + "name": "progressbar2", + "sha256": "a65266e58f002dbbd6e1b9329d25434a50024d3439b538dd5462b44cca1d2325", + "size": 37201, + "subdir": "linux-64", + "timestamp": 1614270556826, + "version": "3.37.1" + }, + "progressbar2-4.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-utils >=3.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cdddd5d05cc47b34b867ae75cdc378eb", + "name": "progressbar2", + "sha256": "8274de8c0d34a0c4a47da0afe3408a647c0697bbed6a82971e7b6fffab7049dd", + "size": 48649, + "subdir": "linux-64", + "timestamp": 1676902998730, + "version": "4.2.0" + }, + "progressbar2-4.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-utils >=3.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "73da1cdccc6a766ef2d87fb5b2119906", + "name": "progressbar2", + "sha256": "9c3886a78133ac0dee7bdd91cd0ed15d2fbbd7f2f509bc6ac7ab2d60692eb42b", + "size": 47963, + "subdir": "linux-64", + "timestamp": 1676902950249, + "version": "4.2.0" + }, + "progressbar2-4.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-utils >=3.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c035e902a3ff38300cc105d032fa5893", + "name": "progressbar2", + "sha256": "6495cfb5d80a464ac226c1a2d58c2989df109581d4389e9bd1844dd408c8fe4e", + "size": 48157, + "subdir": "linux-64", + "timestamp": 1676902973997, + "version": "4.2.0" + }, + "progressbar2-4.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-utils >=3.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "adba93d183c4dfc3988ee6113a0db377", + "name": "progressbar2", + "sha256": "1cf9c50de2a6ed33f3c32437340aa94f28e6e4b9d3cd28af024b99834ebd01b7", + "size": 48098, + "subdir": "linux-64", + "timestamp": 1676903023981, + "version": "4.2.0" + }, + "proj-6.2.1-h05a3930_0.tar.bz2": { + "build": "h05a3930_0", + "build_number": 0, + "constrains": [ + "proj4 ==999999999999" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "sqlite >=3.37.0,<4.0a0" + ], + "license": "MIT", + "md5": "675fbf1eb0b5d8631be148dbfdd76942", + "name": "proj", + "sha256": "4fc2839540e89f0b4b408fc07d4ea7f4e57ad8d84ca8c117df0622a165470301", + "size": 10659620, + "subdir": "linux-64", + "timestamp": 1643031993108, + "version": "6.2.1" + }, + "proj-6.2.1-haa6030c_0.tar.bz2": { + "build": "haa6030c_0", + "build_number": 0, + "constrains": [ + "proj4 ==999999999999" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "sqlite >=3.30.1,<4.0a0" + ], + "license": "MIT", + "md5": "436aa44ea9a435be6c97d43c200a50c8", + "name": "proj", + "sha256": "8fcda2055518f9a2ab2df22fe31a3abdbe473537a54cf791d903b9ed58c691db", + "size": 10659087, + "subdir": "linux-64", + "timestamp": 1573143179535, + "version": "6.2.1" + }, + "proj-7.0.0-h59a7b90_1.tar.bz2": { + "build": "h59a7b90_1", + "build_number": 1, + "constrains": [ + "proj4 ==999999999999" + ], + "depends": [ + "libcurl >=7.69.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "sqlite >=3.31.1,<4.0a0" + ], + "license": "MIT", + "md5": "8d1f699ff32bc396082573b5e2dcf352", + "name": "proj", + "sha256": "6de00e30f7993991e61a435125aa14ba99eff4f5ed4dd612ae8761f069fef0ad", + "size": 3881401, + "subdir": "linux-64", + "timestamp": 1585316604123, + "version": "7.0.0" + }, + "proj-7.0.1-h59a7b90_1.tar.bz2": { + "build": "h59a7b90_1", + "build_number": 1, + "constrains": [ + "proj4 ==999999999999" + ], + "depends": [ + "libcurl >=7.69.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "sqlite >=3.31.1,<4.0a0" + ], + "license": "MIT", + "md5": "bd147666b8a3eae65cd065c4273affc7", + "name": "proj", + "sha256": "fc165aa7c3a0175e904dab725ec56d741106578f26ccc390cffc0235abf08972", + "size": 3874071, + "subdir": "linux-64", + "timestamp": 1590571836312, + "version": "7.0.1" + }, + "proj-7.2.0-h1217e81_1.tar.bz2": { + "build": "h1217e81_1", + "build_number": 1, + "constrains": [ + "proj4 ==999999999999" + ], + "depends": [ + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "sqlite >=3.37.0,<4.0a0" + ], + "license": "MIT", + "md5": "7579b99abad46a1f95fe4c00a1ec63ab", + "name": "proj", + "sha256": "6aa8ef9f7d5eeca1212c82e316a6aa6fdee09cd649acfd3fabdcc05edf4c7717", + "size": 3080251, + "subdir": "linux-64", + "timestamp": 1642790878513, + "version": "7.2.0" + }, + "proj-8.0.1-h1217e81_0.tar.bz2": { + "build": "h1217e81_0", + "build_number": 0, + "constrains": [ + "proj4 ==999999999999" + ], + "depends": [ + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "sqlite >=3.37.0,<4.0a0" + ], + "license": "MIT", + "md5": "f7a674a4fc2b55449579b0160cfb0d40", + "name": "proj", + "sha256": "ad77e0415dcb4f2194ebb4e76e972725640e1455e0a491394e6be2523b68831b", + "size": 3168058, + "subdir": "linux-64", + "timestamp": 1643032942314, + "version": "8.0.1" + }, + "proj-8.2.1-ha227179_0.tar.bz2": { + "build": "ha227179_0", + "build_number": 0, + "constrains": [ + "proj4 ==999999999999" + ], + "depends": [ + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "sqlite >=3.11", + "sqlite >=3.37.2,<4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0aed49d094a63dca24e68f608ae26216", + "name": "proj", + "sha256": "0494d16f73f1424e46a71a7aa75b8c67bb3d273a3d37e596f7f332f66374746a", + "size": 3016920, + "subdir": "linux-64", + "timestamp": 1644419771726, + "version": "8.2.1" + }, + "proj4-4.9.3-h95c2755_7.tar.bz2": { + "build": "h95c2755_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "650c21ecc8178e1eceacbceabd3df9f8", + "name": "proj4", + "sha256": "13cdcf85248d30126e3db23a95b9d85124b803b8eb051d76a2dcbf7a15d9e10a", + "size": 3309151, + "subdir": "linux-64", + "timestamp": 1510610376350, + "version": "4.9.3" + }, + "proj4-4.9.3-ha04b9cc_6.tar.bz2": { + "build": "ha04b9cc_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "d66c520cd7ed3540253010f966cf5862", + "name": "proj4", + "sha256": "893f7f8293ca11572065317dee457ed95b846a14e5e8f504ea55f62c6c93ad4c", + "size": 3310105, + "subdir": "linux-64", + "timestamp": 1509379066831, + "version": "4.9.3" + }, + "proj4-4.9.3-hc8507d1_7.tar.bz2": { + "build": "hc8507d1_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "aa398a18e4562e84c96c779b26421765", + "name": "proj4", + "sha256": "af002b747b7d7873977e14504755fb1b90d81ba82e8574aa748179e61001b4c8", + "size": 3309247, + "subdir": "linux-64", + "timestamp": 1510629153987, + "version": "4.9.3" + }, + "proj4-5.0.1-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "e8085090e0753beace5adeb0e9001ae1", + "name": "proj4", + "sha256": "958c840cc6ff8beb9fa68e6e4f104748c2a9f3cd426e204e4a9c6878278fbdd3", + "size": 7385231, + "subdir": "linux-64", + "timestamp": 1527741136659, + "version": "5.0.1" + }, + "proj4-5.1.0-h14c3975_1.tar.bz2": { + "build": "h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "1babcb3ff914bd2d9f14615efe6bbece", + "name": "proj4", + "sha256": "13794ef83f8f9b63e13a30405b327305a796318ab084141a815fbd8ba85c5a23", + "size": 7388837, + "subdir": "linux-64", + "timestamp": 1532641674089, + "version": "5.1.0" + }, + "proj4-5.2.0-h295c915_1001.tar.bz2": { + "build": "h295c915_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "md5": "2e3a2058b47b60dd71ae809217641734", + "name": "proj4", + "sha256": "03c136b97b49b4c696446a96868d2fdd32dfdceef8c52d0b876d4850fd330f80", + "size": 7389340, + "subdir": "linux-64", + "timestamp": 1643033751822, + "version": "5.2.0" + }, + "proj4-5.2.0-he6710b0_1.tar.bz2": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "15fd14cdd47a71215146a7abbf4436cc", + "name": "proj4", + "sha256": "888b70f730ff6f8baac051a838dd556db5cf1c1c34ae38a895199c225438601c", + "size": 7384340, + "subdir": "linux-64", + "timestamp": 1545255198719, + "version": "5.2.0" + }, + "prometheus_client-0.14.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "02e7296fb89eadc1d5b8f6afcca292d1", + "name": "prometheus_client", + "sha256": "acf569ca3e503deaaf44343cad7311d56554b3390cc695e1253c04059d50b023", + "size": 92080, + "subdir": "linux-64", + "timestamp": 1659455234403, + "version": "0.14.1" + }, + "prometheus_client-0.14.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "66a6818307261b1a28ab12d1b7776fdf", + "name": "prometheus_client", + "sha256": "e2a0e2a618aa33f0beff9583c7dc510b8d0737b023117346676aacbad33970d8", + "size": 121454, + "subdir": "linux-64", + "timestamp": 1679340540306, + "version": "0.14.1" + }, + "prometheus_client-0.14.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c1fbdfee54bcb06776f64987aa615be2", + "name": "prometheus_client", + "sha256": "bf2b23db8cdff86ced6b54240b449ccac4438430235ba0bdfca9758aaf8a57a5", + "size": 90772, + "subdir": "linux-64", + "timestamp": 1659455181292, + "version": "0.14.1" + }, + "prometheus_client-0.14.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4718ad7bf83e664525c13ce1ded14c84", + "name": "prometheus_client", + "sha256": "fe048f508881e6f69ea1781ece59102037d83c102778669e8caf390009b20d74", + "size": 91025, + "subdir": "linux-64", + "timestamp": 1659455269732, + "version": "0.14.1" + }, + "prometheus_client-0.14.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "44d2a857d13bdf9d99aaac039a249d47", + "name": "prometheus_client", + "sha256": "88ae4ca590c895606bfed52b57baf531d858f3bee7374965485e3788bf0c894d", + "size": 91137, + "subdir": "linux-64", + "timestamp": 1659455142164, + "version": "0.14.1" + }, + "prometheus_client-0.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5f348edde85ad59cb24416421f26eaf8", + "name": "prometheus_client", + "sha256": "ecd9cc00abd3372d69ebadd9f015117c3ec1b72eeb5846f1fca8a016acd9161f", + "size": 49817, + "subdir": "linux-64", + "timestamp": 1531775839437, + "version": "0.2.0" + }, + "prometheus_client-0.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c7a6ccf43a1c3ed183f5331e655ec5e4", + "name": "prometheus_client", + "sha256": "6f8a0a95db5e1e82900a1136ba892e6780d8a8ce0cde3fbf19a620b88f4ca80c", + "size": 51134, + "subdir": "linux-64", + "timestamp": 1531775855886, + "version": "0.2.0" + }, + "prometheus_client-0.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c1c3092511f2553cb10913ecfbfde109", + "name": "prometheus_client", + "sha256": "e4a8761b26bc236163a6bee028e87efaf94660ebc33c907b4dabe36ecc28249b", + "size": 50954, + "subdir": "linux-64", + "timestamp": 1531775872107, + "version": "0.2.0" + }, + "prometheus_client-0.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ec2867823e15055d4b4e96e256b512c9", + "name": "prometheus_client", + "sha256": "a89d5b7c2c46057a4eb4e4a965064e4a50f2da423e48d86b587236b4c8990366", + "size": 51014, + "subdir": "linux-64", + "timestamp": 1531775869208, + "version": "0.2.0" + }, + "prometheus_client-0.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f3dfc3472b79e8360c5faf4f458980e0", + "name": "prometheus_client", + "sha256": "0100cd97331d41d6019128d1c41f9c465d0769602e5100ce425c7d9e6c66316c", + "size": 51487, + "subdir": "linux-64", + "timestamp": 1532527304528, + "version": "0.3.0" + }, + "prometheus_client-0.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "523926d4131ec1f9f1e586eb93c83349", + "name": "prometheus_client", + "sha256": "955ffd41c927391a716bbf6d16cb49c89b7620c49b010209f9154cd78b4302b4", + "size": 52836, + "subdir": "linux-64", + "timestamp": 1532527400388, + "version": "0.3.0" + }, + "prometheus_client-0.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8763b29af869537416c031eec65dec11", + "name": "prometheus_client", + "sha256": "88fad04093f2e419cbb282a4d4379535e2f7ffff7620c95439c88851efba9d0f", + "size": 52581, + "subdir": "linux-64", + "timestamp": 1532527267473, + "version": "0.3.0" + }, + "prometheus_client-0.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0a5ca5f0b9d08ad18a53b2236a461f18", + "name": "prometheus_client", + "sha256": "d0047973dbc1e98ca391055390940ca4c1c1c8ea5e81e69d1635032c5cbc5cd2", + "size": 52627, + "subdir": "linux-64", + "timestamp": 1532527401900, + "version": "0.3.0" + }, + "prometheus_client-0.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cb2a3c3d50d2465aba5746a5326e2bf6", + "name": "prometheus_client", + "sha256": "7fb5601cc6640a2e6d56d617b5ac8177af003a16046bb2cfa027f7545dbcf272", + "size": 51701, + "subdir": "linux-64", + "timestamp": 1532977042612, + "version": "0.3.1" + }, + "prometheus_client-0.3.1-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b78b9b54e13929d89e360636509dca5f", + "name": "prometheus_client", + "sha256": "ee52374f144c7db68f1b93e60e10a7c9010753661b38f18d94169a14272ae1ff", + "size": 51759, + "subdir": "linux-64", + "timestamp": 1534351243232, + "version": "0.3.1" + }, + "prometheus_client-0.3.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "df7fe689eaf38c3a5d168c3ee21ae8b1", + "name": "prometheus_client", + "sha256": "9417371238281ed195b72261ffae613db3ba78cea90fea33048561b6f677538e", + "size": 52949, + "subdir": "linux-64", + "timestamp": 1532977068347, + "version": "0.3.1" + }, + "prometheus_client-0.3.1-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "35dec0bf8282a1202e459dba5abedc0b", + "name": "prometheus_client", + "sha256": "1ff8b3751f82012b351c4b2b2f3f5b98c1758009a04f96ea36bf6f6081b52304", + "size": 52954, + "subdir": "linux-64", + "timestamp": 1534351274476, + "version": "0.3.1" + }, + "prometheus_client-0.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ecce7bcddb34e86c81b05c394f40d459", + "name": "prometheus_client", + "sha256": "9cc51a6407540db3fee081747d3575db76646603cb7ffcc0c2868a35b7985145", + "size": 52709, + "subdir": "linux-64", + "timestamp": 1532977858504, + "version": "0.3.1" + }, + "prometheus_client-0.3.1-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c6336d8e7ad7c765803fa6ef284574b3", + "name": "prometheus_client", + "sha256": "d2085275fc276c486988b4690e555c47c6e0e38fdc8c8ffcc4304943162ccb03", + "size": 52814, + "subdir": "linux-64", + "timestamp": 1534351305979, + "version": "0.3.1" + }, + "prometheus_client-0.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8cef08d96dce857250ae9b4a51e1de84", + "name": "prometheus_client", + "sha256": "f3a5bfc582d346a11473562bca1f7c7cb99fa262589fd585d6fc56010023766a", + "size": 52861, + "subdir": "linux-64", + "timestamp": 1532977096560, + "version": "0.3.1" + }, + "prometheus_client-0.3.1-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a917ea88bcb6d7b6dd3b31734f6d3e99", + "name": "prometheus_client", + "sha256": "c3019e2fa687aa62579807768b8f2ecda31dcad912dc90056cd774657e36aed5", + "size": 52907, + "subdir": "linux-64", + "timestamp": 1534351215035, + "version": "0.3.1" + }, + "prometheus_client-0.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7d062076f03f9b87ad6f27d9ecc89c8c", + "name": "prometheus_client", + "sha256": "f987b27fd4b4d2ebbc179cbc66daa381d6f6b2aadb93bf65fab90d19eb7dfe9b", + "size": 63556, + "subdir": "linux-64", + "timestamp": 1539022699731, + "version": "0.4.0" + }, + "prometheus_client-0.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a9908bad453cbe8ef5c8321f13ed6a42", + "name": "prometheus_client", + "sha256": "2830654ca96a39b01da2ba28bcde37333b90a01e712e56901cf80fcea03aeaea", + "size": 64845, + "subdir": "linux-64", + "timestamp": 1539022715464, + "version": "0.4.0" + }, + "prometheus_client-0.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e96a708d5808fad6fe56322c4699f5db", + "name": "prometheus_client", + "sha256": "cd6e12c5743584e8ffe7b80d184db363fae39b4ba8186fad14ac8486a8d3f703", + "size": 64818, + "subdir": "linux-64", + "timestamp": 1539022685106, + "version": "0.4.0" + }, + "prometheus_client-0.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "be7616a808f4d64c427eebad19865fa6", + "name": "prometheus_client", + "sha256": "a684f27f161a7d6b4744536e3b5eb4e0d5df32db3945bc668b5f8ade243eae5a", + "size": 63795, + "subdir": "linux-64", + "timestamp": 1539636151790, + "version": "0.4.2" + }, + "prometheus_client-0.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "819d60493d395314c8d16b5fa91216b6", + "name": "prometheus_client", + "sha256": "8f9b975bcacdfd57b8b95b3b11a10414fcbb3af1203e9fc254eb92a567918bd4", + "size": 65171, + "subdir": "linux-64", + "timestamp": 1539636185368, + "version": "0.4.2" + }, + "prometheus_client-0.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6db424889694f23bce3932e88ba49e1b", + "name": "prometheus_client", + "sha256": "eaaf67bae97ee692e6be0188bf042dc065a3394b48aa5288c0e3d26a5f45be31", + "size": 65092, + "subdir": "linux-64", + "timestamp": 1539636180340, + "version": "0.4.2" + }, + "prometheus_client-0.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "35c885f263d9c37695110a30001a769b", + "name": "prometheus_client", + "sha256": "613fa69c00fb60a1d222b80f8c6a041e3bf24bad77889c824365ebde78579e9e", + "size": 67604, + "subdir": "linux-64", + "timestamp": 1545082278434, + "version": "0.5.0" + }, + "prometheus_client-0.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a4c39ea76a9e5d3807c03878decdcb66", + "name": "prometheus_client", + "sha256": "e254d3eda65bae34cd29b4abadcb98161f201e338dd6e0f7598dccbcc6725e6e", + "size": 68530, + "subdir": "linux-64", + "timestamp": 1545082310494, + "version": "0.5.0" + }, + "prometheus_client-0.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2c2fa39ef3371abf7c613559a9ff780b", + "name": "prometheus_client", + "sha256": "c835f4249764612187c48d00180c1763e0882a32ac83b2ab2c2661e1c4b83dfb", + "size": 68598, + "subdir": "linux-64", + "timestamp": 1545082314018, + "version": "0.5.0" + }, + "prometheus_client-0.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "713490185615d50095c270c484b47962", + "name": "prometheus_client", + "sha256": "940647a36fd84f4e44771dcba4f18ce7c81c3488e3d3df79d7f4888ece9523e5", + "size": 70289, + "subdir": "linux-64", + "timestamp": 1551144511451, + "version": "0.6.0" + }, + "prometheus_client-0.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "15c44f3a7ec1e9f62604cf051ce6d35d", + "name": "prometheus_client", + "sha256": "cfd58823bd057b9a9385e954d871503008d96a3008775f40b191cbe07a99afc7", + "size": 71192, + "subdir": "linux-64", + "timestamp": 1551144532597, + "version": "0.6.0" + }, + "prometheus_client-0.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f0046da47892af892e0e9924feb011bd", + "name": "prometheus_client", + "sha256": "32f07fc67b564799b477e95ce42ed6d2f230a15e3d79689e802b6112977ba454", + "size": 71299, + "subdir": "linux-64", + "timestamp": 1551144508050, + "version": "0.6.0" + }, + "promise-2.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six", + "typing" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "69dbebc81bbe921f2b06a6d38c54d0f8", + "name": "promise", + "sha256": "254a17cd9c0a536d1dc4ae638ab4eb853cfe760ac193ac68098ff70a089d9832", + "size": 36469, + "subdir": "linux-64", + "timestamp": 1567009387330, + "version": "2.2.1" + }, + "promise-2.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "041d7e08c92ace9a62bdf8a0da39e8c4", + "name": "promise", + "sha256": "dbd1234baa7edaf66daf9e34787aa679825806d90f26840dd7a5f8961bf70aa7", + "size": 37071, + "subdir": "linux-64", + "timestamp": 1567009407756, + "version": "2.2.1" + }, + "promise-2.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c97283a0b4daaaff37d4353dcf1a041", + "name": "promise", + "sha256": "8dedb0bd0ac8dee0b65cbb2a6ceeaca97bf98ab69fe0166bcf7d1ef18b3b91f7", + "size": 37195, + "subdir": "linux-64", + "timestamp": 1567009416427, + "version": "2.2.1" + }, + "promise-2.2.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4fffc9b901db6590efb7f49f70841dd1", + "name": "promise", + "sha256": "568d1968f1cb7fc40ce890d1201c91c9f330169a27d04fec3022182c2c6cc560", + "size": 36123, + "subdir": "linux-64", + "timestamp": 1574092672934, + "version": "2.2.1" + }, + "promise-2.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b96d5de7c8caac1a86aad7c5475d27d9", + "name": "promise", + "sha256": "9e8ef1ce73c714e8a767dbb2994e5b199c18ce3c126ebbd30385b998cf1eb788", + "size": 36723, + "subdir": "linux-64", + "timestamp": 1640792583813, + "version": "2.3" + }, + "promise-2.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95fbe6778ab557671781150cbc46d701", + "name": "promise", + "sha256": "2f0bd4234b633a85a909f6f8171b6235a7b1ae19cb96b84f5ccabdc742216e97", + "size": 46286, + "subdir": "linux-64", + "timestamp": 1676860507132, + "version": "2.3" + }, + "promise-2.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "687f3d5087644c1f81e8967007e386d8", + "name": "promise", + "sha256": "0bac26bb6896c6fcbbe793319846b22f448ed2bcaaf3e1b07202b802bd8c94b7", + "size": 37629, + "subdir": "linux-64", + "timestamp": 1598040874913, + "version": "2.3" + }, + "promise-2.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b5a7fc16f6452862ed32054803de046", + "name": "promise", + "sha256": "c920fe2f2be7a7178a040adb0aa5c84989799e47dafcf4fe8e5511d52e1d951f", + "size": 37746, + "subdir": "linux-64", + "timestamp": 1614011682294, + "version": "2.3" + }, + "promise-2.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d349f95b6a6a49219288028ffeb2895", + "name": "promise", + "sha256": "b87c31f0a4b10df1d8d5144d3ec7805fbc6bc405d0f0d730af6a4d1ebbbd20a2", + "size": 37785, + "subdir": "linux-64", + "timestamp": 1598040891942, + "version": "2.3" + }, + "promise-2.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0bd061f49238bd074bb7bb4a69b101f2", + "name": "promise", + "sha256": "560f23c617b121081ff9c549613448daa961a6d099495392435ade168c130bf1", + "size": 37761, + "subdir": "linux-64", + "timestamp": 1614011672476, + "version": "2.3" + }, + "promise-2.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0e7a571806b3098511825054dc8dacd9", + "name": "promise", + "sha256": "41c65962e7ae38a5a199ee2a77174762f774e1601c4d7224c5e0909a3b6ec43e", + "size": 38042, + "subdir": "linux-64", + "timestamp": 1598040879817, + "version": "2.3" + }, + "promise-2.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f5a1f16609ffcb088aaa4ab52662e30a", + "name": "promise", + "sha256": "6cf8be27494f6455e4dd00e0ac520c4961a14ab9e492179e1acd57ff90b60cbd", + "size": 38128, + "subdir": "linux-64", + "timestamp": 1614011671895, + "version": "2.3" + }, + "promise-2.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eefea3f29d4b81362ff5f383fefc66a3", + "name": "promise", + "sha256": "edc0b96f8488607afe167c10df19ca52b47d265e23384ba43e17c8a9e1ba65f1", + "size": 38050, + "subdir": "linux-64", + "timestamp": 1614011677561, + "version": "2.3" + }, + "prompt-toolkit-3.0.36-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "prompt_toolkit 3.0.36" + ], + "depends": [ + "python >=3.10,<3.11.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ef68e03bc5a6817d90d8a9517efd5f50", + "name": "prompt-toolkit", + "sha256": "07901e769b841cd002b264c4d12bbf3a052f31ed17dea6ac621af292b62948fe", + "size": 600626, + "subdir": "linux-64", + "timestamp": 1672387422560, + "version": "3.0.36" + }, + "prompt-toolkit-3.0.36-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "prompt_toolkit 3.0.36" + ], + "depends": [ + "python >=3.11,<3.12.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c33323a7bcaf89a69c01f41fde72b028", + "name": "prompt-toolkit", + "sha256": "4156b76c4f0dce19e4be2d65727d49de25648a46d7b85a1f30d03a805e7e2cc1", + "size": 784952, + "subdir": "linux-64", + "timestamp": 1676824871153, + "version": "3.0.36" + }, + "prompt-toolkit-3.0.36-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "prompt_toolkit 3.0.36" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "497f551ffa18180487541b13df6718be", + "name": "prompt-toolkit", + "sha256": "b5836e3209b1276d1710f501055fa537de47544463bedb0f2def33063257e4be", + "size": 575223, + "subdir": "linux-64", + "timestamp": 1672387367483, + "version": "3.0.36" + }, + "prompt-toolkit-3.0.36-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "prompt_toolkit 3.0.36" + ], + "depends": [ + "python >=3.8,<3.9.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "76ffbcff7bf187c82475bf7bfa427178", + "name": "prompt-toolkit", + "sha256": "5206b4d6c7196f5a250d0ac786b41ba7243a89e190e089f7f680af3c8a30f561", + "size": 580511, + "subdir": "linux-64", + "timestamp": 1672387395908, + "version": "3.0.36" + }, + "prompt-toolkit-3.0.36-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "prompt_toolkit 3.0.36" + ], + "depends": [ + "python >=3.9,<3.10.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eb899a739d9b58dd747f1f6bd52d4cf3", + "name": "prompt-toolkit", + "sha256": "385b2ac10ea3f96df9afb5088f8e773885c1e88a34831e42a083927049ac6511", + "size": 579771, + "subdir": "linux-64", + "timestamp": 1672387338600, + "version": "3.0.36" + }, + "prompt_toolkit-1.0.15-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "b60eadf95934970b588643889f7d9bed", + "name": "prompt_toolkit", + "sha256": "6432532175d8b19e22ea2bb3cc32b68e0c18c3eac56a7ea0601d86283ea04e52", + "size": 341397, + "subdir": "linux-64", + "timestamp": 1530733844862, + "version": "1.0.15" + }, + "prompt_toolkit-1.0.15-py27h1b593e1_0.tar.bz2": { + "build": "py27h1b593e1_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "657aff474dd320785bae8e75693add53", + "name": "prompt_toolkit", + "sha256": "2ea504f5ceff5de715c423914f9e0738d545395d24c6c48dfa168b4d5123cd0a", + "size": 341007, + "subdir": "linux-64", + "timestamp": 1505690322202, + "version": "1.0.15" + }, + "prompt_toolkit-1.0.15-py35hc09de7a_0.tar.bz2": { + "build": "py35hc09de7a_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.5,<3.6.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "070fee45a0542abd99178326e92b6af1", + "name": "prompt_toolkit", + "sha256": "d41a2d845310f677dd7e44f8be3cde8a6692f1b4b60f0dfc6dbd27433245ca31", + "size": 351229, + "subdir": "linux-64", + "timestamp": 1505690339946, + "version": "1.0.15" + }, + "prompt_toolkit-1.0.15-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "741dd35c7800bf886604dda603fb3268", + "name": "prompt_toolkit", + "sha256": "5da71dda455045911bbe347a66549e417ca3590d3fc68c47e006800c1d78b4c2", + "size": 346887, + "subdir": "linux-64", + "timestamp": 1530733819749, + "version": "1.0.15" + }, + "prompt_toolkit-1.0.15-py36h17d85b1_0.tar.bz2": { + "build": "py36h17d85b1_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "24c94cefef6f82bac07de84890209f86", + "name": "prompt_toolkit", + "sha256": "23d86d126a176d9aa231ead36118fabf19c5eb389f00c7f37842c2dbfe8d9e24", + "size": 347055, + "subdir": "linux-64", + "timestamp": 1505690357987, + "version": "1.0.15" + }, + "prompt_toolkit-1.0.15-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "afe0f6c754b7469bb5c8ffda8a7cfd60", + "name": "prompt_toolkit", + "sha256": "2bb238cd49a20a9aab734a9cc39d4f7d75f92a4f618cfd5c14089589213b4f61", + "size": 343421, + "subdir": "linux-64", + "timestamp": 1530733872047, + "version": "1.0.15" + }, + "prompt_toolkit-2.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "50f551472d1e1c55f952fdc7b5c880ad", + "name": "prompt_toolkit", + "sha256": "5ce5eea279e999139388f105731e9f2d297a10b2b63f9b9f4f7720431a7c3342", + "size": 446584, + "subdir": "linux-64", + "timestamp": 1528213645297, + "version": "2.0.2" + }, + "prompt_toolkit-2.0.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.5,<3.6.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "a18ede82f74add0960619adc8a85a078", + "name": "prompt_toolkit", + "sha256": "c5c7e9705f2bf5c36d80eacdaa1ed8011b2a274aa8ff4ed62e52906714ec4d7c", + "size": 456206, + "subdir": "linux-64", + "timestamp": 1528213787695, + "version": "2.0.2" + }, + "prompt_toolkit-2.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "9773914c8c881c8a46871ff121286f88", + "name": "prompt_toolkit", + "sha256": "fd896cbb5b5ae94f6117215d05695b1641b83911c17a65bc50aece95e5e943a3", + "size": 452162, + "subdir": "linux-64", + "timestamp": 1528213773178, + "version": "2.0.2" + }, + "prompt_toolkit-2.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "6c5dd829dee68b4d0c0286da87d741c8", + "name": "prompt_toolkit", + "sha256": "f01135f9b3732568bb4b598bebb1c920c743623fbbd738d9f91b0848151010a0", + "size": 447534, + "subdir": "linux-64", + "timestamp": 1528896624244, + "version": "2.0.3" + }, + "prompt_toolkit-2.0.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.5,<3.6.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "783f448e1e55ef612a23899223137907", + "name": "prompt_toolkit", + "sha256": "00cf1e70a4609297c6da4562e97e2bc7ea75dc4d38ee5225255c7effa814c684", + "size": 456007, + "subdir": "linux-64", + "timestamp": 1528896660367, + "version": "2.0.3" + }, + "prompt_toolkit-2.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "e48534c982543297409aac51ae7bec2f", + "name": "prompt_toolkit", + "sha256": "b0d6fff217e2d3c1ee410b54db2ffeb226bb494424860489197c40d22be8e806", + "size": 452890, + "subdir": "linux-64", + "timestamp": 1528895937303, + "version": "2.0.3" + }, + "prompt_toolkit-2.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "2f1aec551da504f370ec3c60579b3ea6", + "name": "prompt_toolkit", + "sha256": "541b1582f883f82b556d3e9b33e676d75e93e1e252df68ef7f79b4c8c60ce82e", + "size": 450201, + "subdir": "linux-64", + "timestamp": 1530733789839, + "version": "2.0.3" + }, + "prompt_toolkit-2.0.4-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "3ae99691e7f214d8cf95178b666ad6f6", + "name": "prompt_toolkit", + "sha256": "30600f4eadd80e118f6f0eb47188e52998a47dac48470cdaf30905da9018156e", + "size": 462553, + "subdir": "linux-64", + "timestamp": 1532371108087, + "version": "2.0.4" + }, + "prompt_toolkit-2.0.4-py27h28b3542_2.tar.bz2": { + "build": "py27h28b3542_2", + "build_number": 2, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "81ec3f5819c9fe09af2224f74ee3a046", + "name": "prompt_toolkit", + "sha256": "730451f0622c097abbed41284ac3f60e73606cf3bc98d097380b1bdaeafa9794", + "size": 455527, + "subdir": "linux-64", + "timestamp": 1534350742231, + "version": "2.0.4" + }, + "prompt_toolkit-2.0.4-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "pygments", + "python >=3.5,<3.6.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "4d4d0d905f55a0911af408c31adf9a26", + "name": "prompt_toolkit", + "sha256": "94edc32b124d696010b22febf3745684e87afe3076353ed8db3c205fc6bbe5f4", + "size": 469671, + "subdir": "linux-64", + "timestamp": 1532371105480, + "version": "2.0.4" + }, + "prompt_toolkit-2.0.4-py35h28b3542_2.tar.bz2": { + "build": "py35h28b3542_2", + "build_number": 2, + "depends": [ + "pygments", + "python >=3.5,<3.6.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "6cfd351cf84ce4897845ae7c69b12914", + "name": "prompt_toolkit", + "sha256": "9cd0462c89a303a2057f72ad23125cf7030d7c0753cec43690d4713b74afaed4", + "size": 461229, + "subdir": "linux-64", + "timestamp": 1534350773955, + "version": "2.0.4" + }, + "prompt_toolkit-2.0.4-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "4cfdf9b31ce8bef1c76ba28ce26d79a9", + "name": "prompt_toolkit", + "sha256": "9e9fd89cd7f1c3a72568565b6a97b26b4abe76e21650e6acf4d3cf7092fe487b", + "size": 466381, + "subdir": "linux-64", + "timestamp": 1532371101118, + "version": "2.0.4" + }, + "prompt_toolkit-2.0.4-py36h28b3542_2.tar.bz2": { + "build": "py36h28b3542_2", + "build_number": 2, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "d404fbab2b3e5a531eb47adf947a6fc4", + "name": "prompt_toolkit", + "sha256": "649f33a0a9e0a9f635159bc073b83e422c63e1fad7d2bc0f2abcfd088b9f1377", + "size": 457240, + "subdir": "linux-64", + "timestamp": 1534350806919, + "version": "2.0.4" + }, + "prompt_toolkit-2.0.4-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "92c3e157c83f20cabda0516b6d1b0209", + "name": "prompt_toolkit", + "sha256": "c770f7188a447c4cdf16fc70a4155d09725c68ff25bb2cafdb4e20d88081c587", + "size": 461883, + "subdir": "linux-64", + "timestamp": 1532371123728, + "version": "2.0.4" + }, + "prompt_toolkit-2.0.4-py37h28b3542_2.tar.bz2": { + "build": "py37h28b3542_2", + "build_number": 2, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "561d296fd466516c596930de7d8effab", + "name": "prompt_toolkit", + "sha256": "52e2e404910e82b8a326bc5fb8bd7466caa11bb56bbb59468f15080213cce8be", + "size": 454865, + "subdir": "linux-64", + "timestamp": 1534350713990, + "version": "2.0.4" + }, + "prompt_toolkit-2.0.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "97821c3cef72688910188cb9f642f0cf", + "name": "prompt_toolkit", + "sha256": "41a8dd8f2396309a72749ddb2f29f96b325a24df21212a8435007e758d2fa730", + "size": 469877, + "subdir": "linux-64", + "timestamp": 1538595199112, + "version": "2.0.5" + }, + "prompt_toolkit-2.0.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "843dec5fce1bcdb58f7ca53519dbf9df", + "name": "prompt_toolkit", + "sha256": "ca3d0744f3eb2a5963b2b3e22324847d19bff74773deac6fbaf116ed13cf4f05", + "size": 472333, + "subdir": "linux-64", + "timestamp": 1538595223900, + "version": "2.0.5" + }, + "prompt_toolkit-2.0.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "4ab4258c1f0a36ccba02c4cd5310c417", + "name": "prompt_toolkit", + "sha256": "d158987cf847c30c716491dc24f0657cae570b4e15e56a69b927a46a587f7c95", + "size": 468761, + "subdir": "linux-64", + "timestamp": 1538595185531, + "version": "2.0.5" + }, + "prompt_toolkit-2.0.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "def571c43056a8fcb27378f5a50989ca", + "name": "prompt_toolkit", + "sha256": "dd4389b9eaae21248b5597af53d02a96b2fce67c492f6aac165a099fa9e9bcfc", + "size": 472989, + "subdir": "linux-64", + "timestamp": 1539632255267, + "version": "2.0.6" + }, + "prompt_toolkit-2.0.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "d69027210489798890b0697646502533", + "name": "prompt_toolkit", + "sha256": "94719b991f2e82c8e4818fb9522564d5b2570bbf47ce3ad72f52e764e310aecf", + "size": 477163, + "subdir": "linux-64", + "timestamp": 1539632267003, + "version": "2.0.6" + }, + "prompt_toolkit-2.0.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "af2e0013a4a8780df72c557f12cd4526", + "name": "prompt_toolkit", + "sha256": "38dee70c0e7c7ef9fab9aa2abcd7ff8f35d0588584bb549c13a804677ce05aef", + "size": 473155, + "subdir": "linux-64", + "timestamp": 1539632262910, + "version": "2.0.6" + }, + "prompt_toolkit-2.0.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "64832c0110e4f1238a6ec90f342adac9", + "name": "prompt_toolkit", + "sha256": "68613d082847a313e42007c07210afd8e259be55fa520d5e8141b2f1a587100f", + "size": 489213, + "subdir": "linux-64", + "timestamp": 1541000121255, + "version": "2.0.7" + }, + "prompt_toolkit-2.0.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "0f92e96abfb02306e1cfd3528cefc5f8", + "name": "prompt_toolkit", + "sha256": "602ff20d3e923222055c0bcb3abf7699ee2972244106a6f277bb0062dc2e421a", + "size": 493406, + "subdir": "linux-64", + "timestamp": 1541000156868, + "version": "2.0.7" + }, + "prompt_toolkit-2.0.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "51445693cf6982e8cf6a928aae135bbb", + "name": "prompt_toolkit", + "sha256": "4e25b98c3b62af1d05b8f587058fda596fc5aaf381c57b4ae925b19f215f0def", + "size": 490335, + "subdir": "linux-64", + "timestamp": 1541000167199, + "version": "2.0.7" + }, + "prompt_toolkit-2.0.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "d2a72ff7b6d2cda362147cac2fefb551", + "name": "prompt_toolkit", + "sha256": "5ee9d046b77dd234c57dc604326400d43a332dc1f0b3012b91cde73bd2836c0b", + "size": 501097, + "subdir": "linux-64", + "timestamp": 1551145013935, + "version": "2.0.9" + }, + "prompt_toolkit-2.0.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "f7d016775eef276d9e91a1a4e812682f", + "name": "prompt_toolkit", + "sha256": "1190097e95fabd7baf4c0b5eec9b8d82b2454a2ba33c54b8cba3356a0e0b4d1c", + "size": 505059, + "subdir": "linux-64", + "timestamp": 1551145062794, + "version": "2.0.9" + }, + "prompt_toolkit-2.0.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "8d394fbc19066c56948a6c457a4e7450", + "name": "prompt_toolkit", + "sha256": "4270cfd5f7ae4e331e3cb2d9b68a643bbe76214cc652771d55e9921ea162bc40", + "size": 500258, + "subdir": "linux-64", + "timestamp": 1551145007370, + "version": "2.0.9" + }, + "prophet-1.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "cython >=0.22", + "holidays >=0.10.2", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.21.2,<2.0a0", + "pandas >=1.0.4", + "pystan ~=2.19.1.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.0", + "setuptools-git >=1.2", + "tqdm >=4.36.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3bd1b12503ef5e99e13284b78f763a0a", + "name": "prophet", + "sha256": "4d7f628a023dba3c94c1dfa150e18c8b62b0828125d7fe04062310010cdf483b", + "size": 682639, + "subdir": "linux-64", + "timestamp": 1646670019631, + "version": "1.0.1" + }, + "prophet-1.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "cython >=0.22", + "holidays >=0.10.2", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.21.2,<2.0a0", + "pandas >=1.0.4", + "pystan ~=2.19.1.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.0", + "setuptools-git >=1.2", + "tqdm >=4.36.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2bb8d2ca294c8bead2fd6d6b9d50116", + "name": "prophet", + "sha256": "fea95e7a2f97d3619496d7016bae5b9858e7d4b6a74185584955f944f8119591", + "size": 694232, + "subdir": "linux-64", + "timestamp": 1646669769688, + "version": "1.0.1" + }, + "prophet-1.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "cython >=0.22", + "holidays >=0.10.2", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.21.2,<2.0a0", + "pandas >=1.0.4", + "pystan ~=2.19.1.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.0", + "setuptools-git >=1.2", + "tqdm >=4.36.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8cae0539ca44f421c1cc41de76cb9d07", + "name": "prophet", + "sha256": "a9b79116db0c9831dac2c5d31930de786a4c1347b249444689a0caf61ec729db", + "size": 692542, + "subdir": "linux-64", + "timestamp": 1646669536273, + "version": "1.0.1" + }, + "proto-plus-1.22.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.19.0,<5.0.0dev", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "557854692af78eb9d0d3bf43beedf2cb", + "name": "proto-plus", + "sha256": "f4a869bef52b7c2329299ae2f5745d726b2eebc82188edbf89050fa362d2409d", + "size": 58017, + "subdir": "linux-64", + "timestamp": 1663770687255, + "version": "1.22.1" + }, + "proto-plus-1.22.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.19.0,<5.0.0dev", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "45fbc2c1b923ee0a81baf18a6d1a78bb", + "name": "proto-plus", + "sha256": "4bdfd9f084e83014545b07aca132fa7383afa384d92b4b3a8a6ca2c83b9cdcb4", + "size": 72319, + "subdir": "linux-64", + "timestamp": 1676860522132, + "version": "1.22.1" + }, + "proto-plus-1.22.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.19.0,<5.0.0dev", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d5cd9fa86469ca842e69bd3d6ce46860", + "name": "proto-plus", + "sha256": "73b74b0c40c5637cf1a04958c7026689312512eb6c0d213fbb6ce7248c8821e3", + "size": 57272, + "subdir": "linux-64", + "timestamp": 1663770621501, + "version": "1.22.1" + }, + "proto-plus-1.22.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.19.0,<5.0.0dev", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "751b74563be633e7db471f1b6f2aa2e6", + "name": "proto-plus", + "sha256": "c5583732900a91bcfcbe3bcbf98590f9fc026b1eaff530d14e4a171e8c23a691", + "size": 57614, + "subdir": "linux-64", + "timestamp": 1663770595753, + "version": "1.22.1" + }, + "proto-plus-1.22.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.19.0,<5.0.0dev", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "567939b99f5be70f8198a6ab976c9507", + "name": "proto-plus", + "sha256": "98f473a9ac78bad917505d0f8bdc5083ae18eba77212f95e493d5e27062b072d", + "size": 57642, + "subdir": "linux-64", + "timestamp": 1663770648489, + "version": "1.22.1" + }, + "protobuf-3.10.1-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.10.1.*", + "libprotobuf >=3.10.1,<3.11.0a0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8c5fe83d465702a19490fc5ee4511de5", + "name": "protobuf", + "sha256": "5ccbd5f980329d66d27599573671364a7fdede06f09c740a9fc3b9d7954859ea", + "size": 718367, + "subdir": "linux-64", + "timestamp": 1573967328838, + "version": "3.10.1" + }, + "protobuf-3.10.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.10.1.*", + "libprotobuf >=3.10.1,<3.11.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4e4ddabb35d4dd2e321171fdf34f1ea4", + "name": "protobuf", + "sha256": "a1fc4a4fbc96035ee7cb963bd33dd13ee2cad15e068bcd9d7bb2242e816591d6", + "size": 720726, + "subdir": "linux-64", + "timestamp": 1573967332028, + "version": "3.10.1" + }, + "protobuf-3.10.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.10.1.*", + "libprotobuf >=3.10.1,<3.11.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bf4264d4a19544fdaaebd3eb8e6a9a88", + "name": "protobuf", + "sha256": "4df344777d54c3121a6615f8c9b013ad909e7af4d53b7119f0aa2168c9fe2a79", + "size": 725255, + "subdir": "linux-64", + "timestamp": 1573967351342, + "version": "3.10.1" + }, + "protobuf-3.10.1-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.10.1.*", + "libprotobuf >=3.10.1,<3.11.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e64b15ad87a9d616d924e2fbcc2f5702", + "name": "protobuf", + "sha256": "a1a0241f9536ae683585cfd777a6f0092e03bb3fcaef4ded64159727bb9ce46e", + "size": 735281, + "subdir": "linux-64", + "timestamp": 1573967365887, + "version": "3.10.1" + }, + "protobuf-3.11.2-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.2.*", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a499ddaa38adc418357be2c0af19091e", + "name": "protobuf", + "sha256": "9634eaa066740e77e754d0b65c896f3fd59731e72bfb8c9ac3b2145503e6baea", + "size": 723624, + "subdir": "linux-64", + "timestamp": 1576541978932, + "version": "3.11.2" + }, + "protobuf-3.11.2-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.2.*", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "97089f196a54fd9e42a5dc6c69226ae7", + "name": "protobuf", + "sha256": "a211af862529c11c10f6dca72f62100161a1e85af57f4b46c6ccf2315c916f5e", + "size": 724871, + "subdir": "linux-64", + "timestamp": 1576541982274, + "version": "3.11.2" + }, + "protobuf-3.11.2-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.2.*", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d56d3103fcdf8091eaec98a6c958f006", + "name": "protobuf", + "sha256": "07ee60789fa2b1885e4e7fc261b1a62283a0f5ca1e665708c4d4615a1bdb0148", + "size": 726215, + "subdir": "linux-64", + "timestamp": 1576541961397, + "version": "3.11.2" + }, + "protobuf-3.11.2-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.2.*", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "419ef12f9338d7327fec07ede92d1b36", + "name": "protobuf", + "sha256": "7f1ba635d65cc0cc7182d40b668efffc0bfcb4ea2a25f7f7d133ef7e8745c3e9", + "size": 735402, + "subdir": "linux-64", + "timestamp": 1576542000389, + "version": "3.11.2" + }, + "protobuf-3.11.3-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.3.*", + "libprotobuf >=3.11.3,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6fca280bd2bf144b5222136d3c55c57f", + "name": "protobuf", + "sha256": "f9bec3e2ab4c1a7ccb5157d58e39ef10d102679057090641d8b1077fc4f1a6f6", + "size": 723589, + "subdir": "linux-64", + "timestamp": 1581544436423, + "version": "3.11.3" + }, + "protobuf-3.11.3-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.3.*", + "libprotobuf >=3.11.3,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1a8e69f03be4a115d330753bc6ea9f56", + "name": "protobuf", + "sha256": "4570195a3478e0f6a54b0e818c82686ff077fb153c0da842b3577f77c383c044", + "size": 726545, + "subdir": "linux-64", + "timestamp": 1581544414798, + "version": "3.11.3" + }, + "protobuf-3.11.3-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.3.*", + "libprotobuf >=3.11.3,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "439590970064e2d365a06de9f134ce04", + "name": "protobuf", + "sha256": "0e4a954db7a962cda3c817e648207bab3d6e32bc0b6e25e651a0ab6ea1804ee3", + "size": 730895, + "subdir": "linux-64", + "timestamp": 1581544410834, + "version": "3.11.3" + }, + "protobuf-3.11.4-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.4.*", + "libprotobuf >=3.11.4,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5ffb8aa814074cc597743287c72bb453", + "name": "protobuf", + "sha256": "91b87f8dc8328b31e007e44da863b2c896311fdef2d0a21a976307822d34f32f", + "size": 728312, + "subdir": "linux-64", + "timestamp": 1581952699444, + "version": "3.11.4" + }, + "protobuf-3.11.4-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.4.*", + "libprotobuf >=3.11.4,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "853251ec51198a370addbf4816273ed6", + "name": "protobuf", + "sha256": "b5302812180fe0327e114624bbd0f4837cc00b0995950e02305dbc5fe7d20a2b", + "size": 728242, + "subdir": "linux-64", + "timestamp": 1581952684639, + "version": "3.11.4" + }, + "protobuf-3.11.4-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.4.*", + "libprotobuf >=3.11.4,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cd5a096b7f1fcb9ee2e0ab745522e342", + "name": "protobuf", + "sha256": "39946ac2656dc536065bce9b471d96cb52ba8fd60cf2373817ce03ef7742f5eb", + "size": 731038, + "subdir": "linux-64", + "timestamp": 1581952695124, + "version": "3.11.4" + }, + "protobuf-3.12.3-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.12.3.*", + "libprotobuf >=3.12.3,<3.13.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dbd2d3eddda84e485c718af3b390cd93", + "name": "protobuf", + "sha256": "d1c0dd8d1fe63440264f171b703904095af5f5e415894463589e77935eafa243", + "size": 725223, + "subdir": "linux-64", + "timestamp": 1591841173835, + "version": "3.12.3" + }, + "protobuf-3.12.3-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.12.3.*", + "libprotobuf >=3.12.3,<3.13.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "32dbdb2ee999f533d0f72d7946fd326c", + "name": "protobuf", + "sha256": "24ecb9295c82ac0d4c696a1893c639f1a008293f9e2b630e7ebf8900fec6ea05", + "size": 727863, + "subdir": "linux-64", + "timestamp": 1591841183875, + "version": "3.12.3" + }, + "protobuf-3.12.3-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.12.3.*", + "libprotobuf >=3.12.3,<3.13.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "76e808dd3765acd4ecbc686267206b33", + "name": "protobuf", + "sha256": "138e37289116e9340bf9f90e251e1e481383424a56808d36afb5767a8b3057ab", + "size": 732901, + "subdir": "linux-64", + "timestamp": 1591841189162, + "version": "3.12.3" + }, + "protobuf-3.12.4-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.12.4.*", + "libprotobuf >=3.12.4,<3.13.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e98132d10356ca9c563d9076039b8ce0", + "name": "protobuf", + "sha256": "2a9db2b3081bda7c3602a388fa1eb00f48d661c6085cd93c5de63e59b10fa11a", + "size": 733199, + "subdir": "linux-64", + "timestamp": 1597437996877, + "version": "3.12.4" + }, + "protobuf-3.12.4-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.12.4.*", + "libprotobuf >=3.12.4,<3.13.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f6951ac9555d956a03eef255dbaa5315", + "name": "protobuf", + "sha256": "2aa3523cce780a3947843f1f72db85dde59736b46573c0688dc6bf09bd420795", + "size": 740058, + "subdir": "linux-64", + "timestamp": 1597437998970, + "version": "3.12.4" + }, + "protobuf-3.12.4-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.12.4.*", + "libprotobuf >=3.12.4,<3.13.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1d1b7f7ed7dd4ccac0e46cdac7d994df", + "name": "protobuf", + "sha256": "2ddbd9f53f0ae735fa8aad7cae04e305e6434f1cbd63a9d576a363441922fc09", + "size": 744077, + "subdir": "linux-64", + "timestamp": 1597437967055, + "version": "3.12.4" + }, + "protobuf-3.13.0-py36he6710b0_1.tar.bz2": { + "build": "py36he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.13.0.*", + "libprotobuf >=3.13.0,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4a6e48da7704d365494e552773a44ad5", + "name": "protobuf", + "sha256": "10b27d033ca8f0dbc6ffc7544fd7ac52a31b25bc27a28968683fb829bea34461", + "size": 735463, + "subdir": "linux-64", + "timestamp": 1601504435864, + "version": "3.13.0" + }, + "protobuf-3.13.0-py37he6710b0_1.tar.bz2": { + "build": "py37he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.13.0.*", + "libprotobuf >=3.13.0,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "46887d8010b0a8d2521fd250219c3dc4", + "name": "protobuf", + "sha256": "347da4b16379271901967a9167fce885bbec86afbbcadd5e7ef625bea790044d", + "size": 743841, + "subdir": "linux-64", + "timestamp": 1601504421885, + "version": "3.13.0" + }, + "protobuf-3.13.0-py37hf484d3e_0.tar.bz2": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.13.0.*", + "libprotobuf >=3.13.0,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "09b7a82c21df2faaac0110fb8d099868", + "name": "protobuf", + "sha256": "3f7a2539e6bb85b8cc20c9e487c52a455559ef379a7aab7e484b1c7c92064070", + "size": 714928, + "subdir": "linux-64", + "timestamp": 1597940347337, + "version": "3.13.0" + }, + "protobuf-3.13.0-py37hf484d3e_1.tar.bz2": { + "build": "py37hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.13.0.*", + "libprotobuf >=3.13.0,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "acf1da21e0224c14af8f9a059a42ec58", + "name": "protobuf", + "sha256": "a617bf7b445fd52cb0352ceb3be3229c7345c5a9bebc778bc9b1401b0c13aa95", + "size": 728674, + "subdir": "linux-64", + "timestamp": 1601504492451, + "version": "3.13.0" + }, + "protobuf-3.13.0-py38he6710b0_1.tar.bz2": { + "build": "py38he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.13.0.*", + "libprotobuf >=3.13.0,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "303bd4a5fefe11db5d18be123c7c2837", + "name": "protobuf", + "sha256": "b336831825a9eea301bcf40b517ab912b532e30cf5f5ab46cd61cb5bd2df4609", + "size": 738306, + "subdir": "linux-64", + "timestamp": 1601504465955, + "version": "3.13.0" + }, + "protobuf-3.13.0.1-py36he6710b0_1.tar.bz2": { + "build": "py36he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.13.0.1.*", + "libprotobuf >=3.13.0.1,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e482268505959f00c409a910ebc62f31", + "name": "protobuf", + "sha256": "3bdc581c863c1a768b3ed9c305e3aeabb91d887170bf24888f35def780d084b7", + "size": 714724, + "subdir": "linux-64", + "timestamp": 1602616332348, + "version": "3.13.0.1" + }, + "protobuf-3.13.0.1-py37he6710b0_1.tar.bz2": { + "build": "py37he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.13.0.1.*", + "libprotobuf >=3.13.0.1,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6868c8463992cff37f0854e4cbfa3f6c", + "name": "protobuf", + "sha256": "6b710cfde8d4546109d2cef9156d674ed7287aa1349f7ebda3a8bf6688a9dd73", + "size": 716508, + "subdir": "linux-64", + "timestamp": 1602616335335, + "version": "3.13.0.1" + }, + "protobuf-3.13.0.1-py38he6710b0_1.tar.bz2": { + "build": "py38he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.13.0.1.*", + "libprotobuf >=3.13.0.1,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c857bac794a88df0e772b8efc9e17675", + "name": "protobuf", + "sha256": "b1bdf5f8e1cef1c11276303fbe97074f85b0d142a0449bf572e70702ffb011ea", + "size": 718751, + "subdir": "linux-64", + "timestamp": 1602616340549, + "version": "3.13.0.1" + }, + "protobuf-3.14.0-py36h2531618_1.tar.bz2": { + "build": "py36h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.14.0.*", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4ef41a27ab22678b7261beb1f3d8fcea", + "name": "protobuf", + "sha256": "b650b33d7723bceeef0b3cd41535893577f168f548857ecba82311e437b7622b", + "size": 343411, + "subdir": "linux-64", + "timestamp": 1612296164599, + "version": "3.14.0" + }, + "protobuf-3.14.0-py37h2531618_1.tar.bz2": { + "build": "py37h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.14.0.*", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a9168e535a48e260b8a8b0bedc27ae1", + "name": "protobuf", + "sha256": "7f96a7dbf4e05edae4079e3d3865e2387253521d1bc81d2a172f49684eaab731", + "size": 343624, + "subdir": "linux-64", + "timestamp": 1612296151228, + "version": "3.14.0" + }, + "protobuf-3.14.0-py38h2531618_1.tar.bz2": { + "build": "py38h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.14.0.*", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a8c50279bf368a151e6bc546f603568c", + "name": "protobuf", + "sha256": "fb44a1b05486a41cee81a506790272adbb201c458eeb7362335951532da61f63", + "size": 343366, + "subdir": "linux-64", + "timestamp": 1612296159855, + "version": "3.14.0" + }, + "protobuf-3.14.0-py39h2531618_1.tar.bz2": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.14.0.*", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "99a3b7d8d3b5962872c5beffbb3a760f", + "name": "protobuf", + "sha256": "ecd4d6c547300a3ac2307124dcff631a559aa6eebd9bdb74ee8e710733f421bc", + "size": 346988, + "subdir": "linux-64", + "timestamp": 1612296162097, + "version": "3.14.0" + }, + "protobuf-3.17.2-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.17.2.*", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1dceadc08996c648274e0a4e995a402", + "name": "protobuf", + "sha256": "d3963199d213844e29fe3cb56f9cc5e12394b3c3304b6f74d8590163c62b2eda", + "size": 1746106, + "subdir": "linux-64", + "timestamp": 1640792625757, + "version": "3.17.2" + }, + "protobuf-3.17.2-py36h295c915_0.tar.bz2": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.17.2.*", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d8ffd19f09f0215d476833c4d5a0d995", + "name": "protobuf", + "sha256": "eff620f30b6f9cc5aa487adc0ff78ace033fcd955a52e137326b8e41d1df9a10", + "size": 362875, + "subdir": "linux-64", + "timestamp": 1626459552333, + "version": "3.17.2" + }, + "protobuf-3.17.2-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.17.2.*", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9e5d64fee1f6528bdc68ead808d11117", + "name": "protobuf", + "sha256": "804fae0df62dd59d6972fad0b467a59efd07130febbc2688979b8e9a43aaca52", + "size": 356082, + "subdir": "linux-64", + "timestamp": 1626452361906, + "version": "3.17.2" + }, + "protobuf-3.17.2-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.17.2.*", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7ef2e13b20b4472f34b615c24ebcebd5", + "name": "protobuf", + "sha256": "86ba4e64c6bb446591ba4673e2bb97af0daa5c98f263cba386593b8a936a2dbd", + "size": 365010, + "subdir": "linux-64", + "timestamp": 1626459534541, + "version": "3.17.2" + }, + "protobuf-3.17.2-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.17.2.*", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "481f08649981350469ce69787106722e", + "name": "protobuf", + "sha256": "f03c155a12891bc6b094a6e4449884cdcda81b8cef36e604182dc3d5553de1c6", + "size": 359679, + "subdir": "linux-64", + "timestamp": 1626459555773, + "version": "3.17.2" + }, + "protobuf-3.19.1-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.19.1.*", + "libprotobuf >=3.19.1,<3.20.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2b2945ece1a1e6200e02eddfcec5fa48", + "name": "protobuf", + "sha256": "42a56e8561cc9e10cf3defbee9ef5e1f53300bbc29360e9e1caa7fee053e205b", + "size": 1752302, + "subdir": "linux-64", + "timestamp": 1655800227805, + "version": "3.19.1" + }, + "protobuf-3.19.1-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.19.1.*", + "libprotobuf >=3.19.1,<3.20.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "89acbebcdbb90b2e58945645ac58bf29", + "name": "protobuf", + "sha256": "7d930d94254680ac595bcb581258ffb61b8f56c722a223dbf7229b44413a77a0", + "size": 340039, + "subdir": "linux-64", + "timestamp": 1641480716434, + "version": "3.19.1" + }, + "protobuf-3.19.1-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.19.1.*", + "libprotobuf >=3.19.1,<3.20.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "73ae63ea2736e1d8c3ff4582e2671896", + "name": "protobuf", + "sha256": "fcb0a710af88ef79f0cc95ef06bf197072a496d9f4bed2dffe752c5433c46a60", + "size": 353655, + "subdir": "linux-64", + "timestamp": 1641495490725, + "version": "3.19.1" + }, + "protobuf-3.19.1-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.19.1.*", + "libprotobuf >=3.19.1,<3.20.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0c0835fe6f9e9709d203ce761ab6c80f", + "name": "protobuf", + "sha256": "07fc666106719ebb55dd2a6c2b7d02c6cfc56d26b78a6d780da5fbcae941e6ac", + "size": 353421, + "subdir": "linux-64", + "timestamp": 1641480715429, + "version": "3.19.1" + }, + "protobuf-3.19.6-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.19.6.*", + "libprotobuf >=3.19.6,<3.20.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d2bf3b98a827a64372346ea150ac0910", + "name": "protobuf", + "sha256": "647b76717d6ba91966759f985409de04d1f430b4cf6aaaa99dc9fe17c432c3c3", + "size": 355376, + "subdir": "linux-64", + "timestamp": 1675281662997, + "version": "3.19.6" + }, + "protobuf-3.19.6-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.19.6.*", + "libprotobuf >=3.19.6,<3.20.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3c44b6db162fd4b589585c8a5da789f4", + "name": "protobuf", + "sha256": "f4103cbb3d4cbe5856d360ba6501b498a398a6ca1ce725115570862b542e4d77", + "size": 350878, + "subdir": "linux-64", + "timestamp": 1675281619494, + "version": "3.19.6" + }, + "protobuf-3.19.6-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.19.6.*", + "libprotobuf >=3.19.6,<3.20.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f1617c7cdae48a928f7dfc3e4d705c9c", + "name": "protobuf", + "sha256": "099bd57c1c0e172eb1ab243fefba5d339f90963b84b170425cd41c601c904e31", + "size": 353493, + "subdir": "linux-64", + "timestamp": 1675281749521, + "version": "3.19.6" + }, + "protobuf-3.19.6-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.19.6.*", + "libprotobuf >=3.19.6,<3.20.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c51d47c9808ba17a7509550a2f0d873a", + "name": "protobuf", + "sha256": "dda468180567c2a02204e0be33ef4e833e0acd5648448c732988e31ce2ebecce", + "size": 353222, + "subdir": "linux-64", + "timestamp": 1675281706197, + "version": "3.19.6" + }, + "protobuf-3.20.1-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.20.1.*", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3749a4fc5a0b9292be342ba05fc5b40c", + "name": "protobuf", + "sha256": "be920ab88498093d5dc88031e241b9a3785cc7830896ab6a2f82fd46695b4c49", + "size": 1784095, + "subdir": "linux-64", + "timestamp": 1652441733428, + "version": "3.20.1" + }, + "protobuf-3.20.1-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.20.1.*", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "466449c88b84d345ef21fb2b92bdf29c", + "name": "protobuf", + "sha256": "a68ec41bcaf5bbe903e31d6d943fa39c216c675d07164ee4b1ca68e774d89d32", + "size": 333195, + "subdir": "linux-64", + "timestamp": 1652441616116, + "version": "3.20.1" + }, + "protobuf-3.20.1-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.20.1.*", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c63518c0036eac2603dedb9a841f9e4b", + "name": "protobuf", + "sha256": "d76e4efbf7a0c602fb49469eef96e5236a3cab6aca745177f10a53a53d33e0c4", + "size": 336034, + "subdir": "linux-64", + "timestamp": 1652441531461, + "version": "3.20.1" + }, + "protobuf-3.20.1-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.20.1.*", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f8e19d966a77fe5d738fb8b4d5a3e7c9", + "name": "protobuf", + "sha256": "2d0828f564110175dde409471114ad9a8aa1935d8ab151f24664bf070df7eab2", + "size": 336043, + "subdir": "linux-64", + "timestamp": 1652441824198, + "version": "3.20.1" + }, + "protobuf-3.20.3-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.20.3.*", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4f0c0b5bcf17da3353117e50d6749dcd", + "name": "protobuf", + "sha256": "f97e7b2536ec3cdd0865e9d4f3e90cc01a701d5519e63b51da54f4a3c20ab520", + "size": 347650, + "subdir": "linux-64", + "timestamp": 1675281211637, + "version": "3.20.3" + }, + "protobuf-3.20.3-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.20.3.*", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8ada7b3871e90cae4ce536b49fe863f9", + "name": "protobuf", + "sha256": "78928b740f12ff38402025dee33a108bae2deb45a00b3eca7e87c8f9042cb19d", + "size": 409280, + "subdir": "linux-64", + "timestamp": 1676828758195, + "version": "3.20.3" + }, + "protobuf-3.20.3-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.20.3.*", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fb932fedfbe1e51d87cac0eebdf8fd82", + "name": "protobuf", + "sha256": "4af4b48c75886e0461250fdeb8f2cf5b576df43d58c6e931b272865ce5527806", + "size": 342992, + "subdir": "linux-64", + "timestamp": 1675281298966, + "version": "3.20.3" + }, + "protobuf-3.20.3-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.20.3.*", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5e1627e4ab69cd3a49c29c1b211bbfdb", + "name": "protobuf", + "sha256": "38f21462127c6a9002c9f07c13205c9116228d7643d42c6a0629c66f2b9d6551", + "size": 345753, + "subdir": "linux-64", + "timestamp": 1675281255438, + "version": "3.20.3" + }, + "protobuf-3.20.3-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.20.3.*", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ad6c2c57261372132fd546d567fbe118", + "name": "protobuf", + "sha256": "cc05721ad81cc6b54b3119706a7d8ec4f13fac64849fdd5d1c5273415bc25e53", + "size": 345537, + "subdir": "linux-64", + "timestamp": 1675281342341, + "version": "3.20.3" + }, + "protobuf-3.4.1-py27h2ba6a9c_0.tar.bz2": { + "build": "py27h2ba6a9c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "New BSD License", + "license_family": "BSD", + "md5": "801f66cc5a102d3a6f704383efdfdae3", + "name": "protobuf", + "sha256": "b7c8abee606d6f58daa025a0633a61cab5706aa8902370e042a0898c1ab38e18", + "size": 580682, + "subdir": "linux-64", + "timestamp": 1510782604119, + "version": "3.4.1" + }, + "protobuf-3.4.1-py35he6b9134_0.tar.bz2": { + "build": "py35he6b9134_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "New BSD License", + "license_family": "BSD", + "md5": "31a8ae92122e1a2d862bdd7b7a1b92c2", + "name": "protobuf", + "sha256": "b1d73ab1a3ee7c2d76b4fc7f86b03b9e3760c66ef8a6510137c7f4d7a3f389b8", + "size": 589648, + "subdir": "linux-64", + "timestamp": 1510782633634, + "version": "3.4.1" + }, + "protobuf-3.4.1-py36h306e679_0.tar.bz2": { + "build": "py36h306e679_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "New BSD License", + "license_family": "BSD", + "md5": "faa5fec84595e027f09b7f083bb65d7b", + "name": "protobuf", + "sha256": "08700acc1473b38b608ede88c26f953ccdddfef5e03ac8a0713e35cdc78c44c4", + "size": 593748, + "subdir": "linux-64", + "timestamp": 1510782634408, + "version": "3.4.1" + }, + "protobuf-3.5.1-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "New BSD License", + "license_family": "BSD", + "md5": "ef7ea948a90f6075f5a058a4a10977b0", + "name": "protobuf", + "sha256": "fc5a977e3679a2d289e5af06148e47e8941bfc3a76d83210d8dd2e3c08447fff", + "size": 603463, + "subdir": "linux-64", + "timestamp": 1519948869259, + "version": "3.5.1" + }, + "protobuf-3.5.1-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "New BSD License", + "license_family": "BSD", + "md5": "06aede2555d49fe468cf041f7905d416", + "name": "protobuf", + "sha256": "63337bf5f5bf700eef3b2dba650e943d92eec35a908054a1b96a7ebc43de5b8f", + "size": 613668, + "subdir": "linux-64", + "timestamp": 1519948917107, + "version": "3.5.1" + }, + "protobuf-3.5.1-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "New BSD License", + "license_family": "BSD", + "md5": "ca3cc3d3267449b389f8cb6be9fd58ec", + "name": "protobuf", + "sha256": "ecd1f68b27b233c370945f4f36f979865e0db0db2f823eab277a25ffb99b81c2", + "size": 611639, + "subdir": "linux-64", + "timestamp": 1519951148379, + "version": "3.5.1" + }, + "protobuf-3.5.2-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a2d8ecc9908547d4522a71a520a223ae", + "name": "protobuf", + "sha256": "5c246b5b48661ad4b37e513595ec8d84d677d687d107e626360f12d4f0868622", + "size": 617876, + "subdir": "linux-64", + "timestamp": 1523041714162, + "version": "3.5.2" + }, + "protobuf-3.5.2-py27hf484d3e_1.tar.bz2": { + "build": "py27hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "46e3e79757897417b47915c15acec8bf", + "name": "protobuf", + "sha256": "34c5e6c5a1f9c7ee999b0d0bd98876180bf43edb18d73236eb639617e2e4b764", + "size": 618647, + "subdir": "linux-64", + "timestamp": 1530782452752, + "version": "3.5.2" + }, + "protobuf-3.5.2-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "646a95e181c5376010bd934a17fea1f1", + "name": "protobuf", + "sha256": "fc529a750e325207dfc068df3f6dc65a23f59738e84d3a94f6b3f6515d9e4655", + "size": 627175, + "subdir": "linux-64", + "timestamp": 1523041757204, + "version": "3.5.2" + }, + "protobuf-3.5.2-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5475c2ae1a09af4cc8ea266f2d7a9218", + "name": "protobuf", + "sha256": "fb496888498a9e1048d7fc44d912d6563181c2645b45abf84e6d28decedce63f", + "size": 624824, + "subdir": "linux-64", + "timestamp": 1523041758796, + "version": "3.5.2" + }, + "protobuf-3.5.2-py36hf484d3e_1.tar.bz2": { + "build": "py36hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8c93011f741bfb4edeeef478be71117e", + "name": "protobuf", + "sha256": "11f996e8f606c49b5b1853db7d6d5892a4cf39db3e21b17e0d8b9d64f40e79e8", + "size": 624563, + "subdir": "linux-64", + "timestamp": 1530782526319, + "version": "3.5.2" + }, + "protobuf-3.5.2-py37hf484d3e_1.tar.bz2": { + "build": "py37hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "200e03f032ef04449040b48b47c9d7fd", + "name": "protobuf", + "sha256": "10e884d7528c51e450a30e0eb118de2ea2d598e62e41246999520bcf25372148", + "size": 624868, + "subdir": "linux-64", + "timestamp": 1530782597373, + "version": "3.5.2" + }, + "protobuf-3.6.0-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6495422f8bed96b14d2ec25d10125385", + "name": "protobuf", + "sha256": "154dff7fa6afe2291962b4d841196075aceb963873af4b5eb614139a392306c8", + "size": 618404, + "subdir": "linux-64", + "timestamp": 1534346112937, + "version": "3.6.0" + }, + "protobuf-3.6.0-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "820176aa9be0fce7d46d3aba9bd8e931", + "name": "protobuf", + "sha256": "01de07c7e09b333b8f205c5da79d968f8a2e42316af2f37c9c96e199d311f195", + "size": 629979, + "subdir": "linux-64", + "timestamp": 1534346126750, + "version": "3.6.0" + }, + "protobuf-3.6.0-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ad8ad50af4136b0f97eae31137e6de5b", + "name": "protobuf", + "sha256": "f386b4a4622053db28ed6d8e8226f0648600010c585c57b3b11d2d4ec2e34f2d", + "size": 624217, + "subdir": "linux-64", + "timestamp": 1534346128872, + "version": "3.6.0" + }, + "protobuf-3.6.0-py37hf484d3e_0.tar.bz2": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6e72444cc634fe795c8650d83ffc5469", + "name": "protobuf", + "sha256": "e7ef76bed58c4a932170ff304d4233ce2787335b0e2c9f09276b08527f4cdfd5", + "size": 623851, + "subdir": "linux-64", + "timestamp": 1534346195097, + "version": "3.6.0" + }, + "protobuf-3.6.1-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.1,<3.6.2.0a0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a2788ef5105c4650bfaad8bd269986a5", + "name": "protobuf", + "sha256": "e2ddd42d44e0c09e3ff19fc0524539e1465bd80278972d7b772d1426f70bb39e", + "size": 634995, + "subdir": "linux-64", + "timestamp": 1541097908950, + "version": "3.6.1" + }, + "protobuf-3.6.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.1,<3.6.2.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a0a6477ff31d2dd1ab4708bbf0141391", + "name": "protobuf", + "sha256": "ca4cd36cfa9892a84ae3db26df28121fb99c8fbaa3f33f99e87b28f99febc9eb", + "size": 630280, + "subdir": "linux-64", + "timestamp": 1541097946270, + "version": "3.6.1" + }, + "protobuf-3.6.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.1,<3.6.2.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c34b4eb432f654a50e8356ceda7c05a9", + "name": "protobuf", + "sha256": "d873dad81e6e77fa5062fc14b3b224baa769d6e21e82c9e9b34ad5d618197dd7", + "size": 629916, + "subdir": "linux-64", + "timestamp": 1541097926829, + "version": "3.6.1" + }, + "protobuf-3.7.1-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.7.1,<3.8.0a0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e9d1b11e2d183d9625407b6bcdb47dd1", + "name": "protobuf", + "sha256": "6755b7e77e69e365d048bb4cec0dbf74b8782da9f58d17dcf8325286ff18f889", + "size": 673266, + "subdir": "linux-64", + "timestamp": 1556566035184, + "version": "3.7.1" + }, + "protobuf-3.7.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.7.1,<3.8.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fcf7359aec2b8abadb957611620c393b", + "name": "protobuf", + "sha256": "d9304c71ceff3f17b7129f407aac6f6c189c15edf09226ea625d939ea5e007db", + "size": 671409, + "subdir": "linux-64", + "timestamp": 1556566035093, + "version": "3.7.1" + }, + "protobuf-3.7.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.7.1,<3.8.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "13032cad8f1ea735e253a40d6fd00b7b", + "name": "protobuf", + "sha256": "1997e58285f409f5a982c77bc1fd11cf866b36a814771b05c9c331fbcf65fd0b", + "size": 665232, + "subdir": "linux-64", + "timestamp": 1556565986563, + "version": "3.7.1" + }, + "protobuf-3.8.0-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.8.0.*", + "libprotobuf >=3.8.0,<3.9.0a0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3b4373da61f1295e906c6222c7101e2b", + "name": "protobuf", + "sha256": "0cb077ceebdf8abec9b835936023356a907a9b11aaa1000c51b8098af27f66c5", + "size": 709644, + "subdir": "linux-64", + "timestamp": 1559918960273, + "version": "3.8.0" + }, + "protobuf-3.8.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.8.0.*", + "libprotobuf >=3.8.0,<3.9.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "769883f8d6fbde5069b8d5b4c19e57f2", + "name": "protobuf", + "sha256": "8fed58015f41a4a77355c90eee13821fb42d63c8ae6fc7581153fa8a5cec273b", + "size": 706272, + "subdir": "linux-64", + "timestamp": 1559918946891, + "version": "3.8.0" + }, + "protobuf-3.8.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.8.0.*", + "libprotobuf >=3.8.0,<3.9.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8aeebd78ae8dc4a575028ffc6b5e7c46", + "name": "protobuf", + "sha256": "a623499a72d354afe6d3ac54f2246d643133510a232a232720ab62ecf644bcbf", + "size": 709192, + "subdir": "linux-64", + "timestamp": 1559918951632, + "version": "3.8.0" + }, + "protobuf-3.9.2-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.9.2.*", + "libprotobuf >=3.9.2,<3.10.0a0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4d91e5539202373a00abdf2768758fc9", + "name": "protobuf", + "sha256": "8fce584cf599b7119dbc09a82ee92fbad10db567a83ed11acf17783b82e548da", + "size": 713981, + "subdir": "linux-64", + "timestamp": 1569267604069, + "version": "3.9.2" + }, + "protobuf-3.9.2-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.9.2.*", + "libprotobuf >=3.9.2,<3.10.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "091ac203c17129beb46e5b5256425d58", + "name": "protobuf", + "sha256": "1d899cf9161972e824a1678e09defbe2126da3b50bcd05d37aeac7d9963fa953", + "size": 718326, + "subdir": "linux-64", + "timestamp": 1569267603633, + "version": "3.9.2" + }, + "protobuf-3.9.2-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.9.2.*", + "libprotobuf >=3.9.2,<3.10.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ac4115542e2c75a672ba06b2df64949c", + "name": "protobuf", + "sha256": "e032d8aff8248f32129233c5ca14154d2ab9e66b277b4bbc8124148bc5a8130a", + "size": 717954, + "subdir": "linux-64", + "timestamp": 1569267602123, + "version": "3.9.2" + }, + "protobuf-3.9.2-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.9.2.*", + "libprotobuf >=3.9.2,<3.10.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6be7d2fdc21a06cb5f111524c28b5162", + "name": "protobuf", + "sha256": "101c85aeec2497579a6f9c92834d56a713172389d3ab2573b8b62cf0373aa53d", + "size": 721807, + "subdir": "linux-64", + "timestamp": 1573469677508, + "version": "3.9.2" + }, + "pscript-0.5.5-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "d71ed095c0d219f19f63b34ea48523fc", + "name": "pscript", + "sha256": "a3c9c01ab70848e81d082c112f44a45f2c85e02af989ab47837f6a34d0e47469", + "size": 122810, + "subdir": "linux-64", + "timestamp": 1531495030190, + "version": "0.5.5" + }, + "pscript-0.5.5-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "1f7f0c482c6de28af27b64c57581f05d", + "name": "pscript", + "sha256": "5fe369b670a9d676f14ade70831f18cab64537f6bb7187abb77fa63dea9884ab", + "size": 123769, + "subdir": "linux-64", + "timestamp": 1531495038652, + "version": "0.5.5" + }, + "pscript-0.5.5-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "f9aa0a9ce9ceca6865dd89b65f0d6a29", + "name": "pscript", + "sha256": "408cb35aa7447f0699ba7abd83267fedc6efab08f8598350a1669ed9535a1bc2", + "size": 123310, + "subdir": "linux-64", + "timestamp": 1531495105848, + "version": "0.5.5" + }, + "pscript-0.5.5-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "6e3828487220de45be9016694f0c65a4", + "name": "pscript", + "sha256": "ac3b0b6cd070c0a24e25835c343aac4f6d9a1bf6fe9cc802cc4e8b1fed52aa83", + "size": 123028, + "subdir": "linux-64", + "timestamp": 1531495045718, + "version": "0.5.5" + }, + "pscript-0.6.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "f3cb69e62f451a3d334da14388ef722c", + "name": "pscript", + "sha256": "9a5466c594f4706b7e06ff4de9ca42e16bdf68573e84053d5a081923fb6f8dd6", + "size": 122208, + "subdir": "linux-64", + "timestamp": 1535512096894, + "version": "0.6.0" + }, + "pscript-0.6.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "5e4e6f0a236e662996e561a856ff4dca", + "name": "pscript", + "sha256": "6c0d6d14eb38e699325f09212a4e89d17022316da9cb03170f6cac14b3009c2e", + "size": 123228, + "subdir": "linux-64", + "timestamp": 1535512103651, + "version": "0.6.0" + }, + "pscript-0.6.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "8cc78ad172e6a8abd06b62fd4eb7cbea", + "name": "pscript", + "sha256": "9fd0831edcda28f5ca14ce2aef4de7bca9d039b4001177dcb330772b586c2346", + "size": 122817, + "subdir": "linux-64", + "timestamp": 1535512061070, + "version": "0.6.0" + }, + "pscript-0.6.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "628cc3bd898cef4b1be9fcd6156f29d7", + "name": "pscript", + "sha256": "824f9e3e5e539f35392659dd2bea790a47e9ef3e9da8b820cacc6eb7a52f38a0", + "size": 122238, + "subdir": "linux-64", + "timestamp": 1535512038148, + "version": "0.6.0" + }, + "pscript-0.6.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "8bdd22c5250dcfdb81cfef46957e38dd", + "name": "pscript", + "sha256": "e9c9fe0c7ae7a64300b3e1d9c67c4d64293fff45a142fa936b4e7e869aa343ae", + "size": 123716, + "subdir": "linux-64", + "timestamp": 1538364765716, + "version": "0.6.1" + }, + "pscript-0.6.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "eb571029493d88b2edaa5f8318d58267", + "name": "pscript", + "sha256": "0b47e888158e35322583948a2e8948c22e7b8256fa481953d40261496f4b1861", + "size": 125467, + "subdir": "linux-64", + "timestamp": 1538364801801, + "version": "0.6.1" + }, + "pscript-0.6.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "018893f3a26168b42328f89f1d835ab6", + "name": "pscript", + "sha256": "a5861d902dc642598514efd37558ba8a4055622bfe66f07482ff36c48ba0c758", + "size": 124866, + "subdir": "linux-64", + "timestamp": 1538364719363, + "version": "0.6.1" + }, + "pscript-0.6.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "9a5a8bc8fe2bf3e899a9fcebdc79f779", + "name": "pscript", + "sha256": "8c9ce90198c62109a2fb87e111d1e9e459c389ab0c2ac06c6feb0d2098bc0074", + "size": 124360, + "subdir": "linux-64", + "timestamp": 1541000758386, + "version": "0.6.2" + }, + "pscript-0.6.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "2b63793f66056522a47791ed2b9a857f", + "name": "pscript", + "sha256": "bbd8c443afe691f2505bf72095c860330d1e0b997de632f4a7a20c0dc7b86119", + "size": 124948, + "subdir": "linux-64", + "timestamp": 1541000787802, + "version": "0.6.2" + }, + "pscript-0.6.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "4fc17ffe6b50c0d4e48cbac8dcfbc3cf", + "name": "pscript", + "sha256": "0a4ae4cc8702a37aaac61dbeca8ab0bccc8ca34a7a03a2dc32dde4c7f063705c", + "size": 125339, + "subdir": "linux-64", + "timestamp": 1541000819705, + "version": "0.6.2" + }, + "pscript-0.6.3-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "fbb253f5b555e53b440c956f39597e53", + "name": "pscript", + "sha256": "274001ac5652b7554175bafbede83f60b1f43e94b421b3dcbaebbcd74840aeea", + "size": 124259, + "subdir": "linux-64", + "timestamp": 1541175412475, + "version": "0.6.3" + }, + "pscript-0.6.3-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "cbc65ee35f72179bb2bf5d1c42e3d01e", + "name": "pscript", + "sha256": "605d0dcd0e11ef86b5bb53718862cdbd5184f26036a05aae76280f58309a27a1", + "size": 124889, + "subdir": "linux-64", + "timestamp": 1541175426339, + "version": "0.6.3" + }, + "pscript-0.6.3-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "a00588d2251341752e66383f5877eb5b", + "name": "pscript", + "sha256": "33860825f0208be233b2754d27719becd8f25b1f50f1c15758bd0f86c61f0ab9", + "size": 124292, + "subdir": "linux-64", + "timestamp": 1541175390859, + "version": "0.6.3" + }, + "pscript-0.7.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "6c53eb3eafb3cede90cdaefbe2ab4ec9", + "name": "pscript", + "sha256": "ca0b46d1a12180218c7f08bb809b0bee53d212daa28580fadd930c6e417730ee", + "size": 125420, + "subdir": "linux-64", + "timestamp": 1542085136319, + "version": "0.7.0" + }, + "pscript-0.7.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "30dc20c7e9ec0be7c50d17df61703c34", + "name": "pscript", + "sha256": "6e99e7433300929d4251d1a8e9e8a98c9e5839a8f92acf0a37dd0793b33f92e7", + "size": 126147, + "subdir": "linux-64", + "timestamp": 1542085162367, + "version": "0.7.0" + }, + "pscript-0.7.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "099712a4fe4f876afa685223cf859bcc", + "name": "pscript", + "sha256": "08b1e869e220fe223a0ec0a87176e8614e563f437941ce38010c305bf10fa9e0", + "size": 126561, + "subdir": "linux-64", + "timestamp": 1542085117000, + "version": "0.7.0" + }, + "psqlodbc-13.00-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "LGPL-2.0", + "license_family": "GPL", + "md5": "721f6d27794c5da84249f3c69bae8513", + "name": "psqlodbc", + "sha256": "35ec5632197250fe7dde9b6066276f0ccdbfb4287905f1e24c538cc8bc9c8d7f", + "size": 446995, + "subdir": "linux-64", + "timestamp": 1612297900989, + "version": "13.00" + }, + "psqlodbc-13.01-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "LGPL-2.0", + "license_family": "GPL", + "md5": "a33837d1bff0057453a3f98af69ae5eb", + "name": "psqlodbc", + "sha256": "c166647bce4c8119a7ead8c901759fe2a407855ba6558e549ba9c46a4f2d5cea", + "size": 447647, + "subdir": "linux-64", + "timestamp": 1620071698526, + "version": "13.01" + }, + "psutil-5.2.2-py27h9b5ba61_0.tar.bz2": { + "build": "py27h9b5ba61_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c5010a4ab9cd9c2b5ed386ec2fb3ac31", + "name": "psutil", + "sha256": "1570ce4335999994c06541424b5d7abfc050f72fc5563fccede6b4b5288bfd5e", + "size": 252123, + "subdir": "linux-64", + "timestamp": 1505733101999, + "version": "5.2.2" + }, + "psutil-5.2.2-py35h75e6a48_0.tar.bz2": { + "build": "py35h75e6a48_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4d183039c997f4d0795a5d5c472fbf5d", + "name": "psutil", + "sha256": "6536f8d88801d958a74afdfd23f7fc0f2b49c6ae3f27cd173cc51fa0875a3a2f", + "size": 259215, + "subdir": "linux-64", + "timestamp": 1505733119236, + "version": "5.2.2" + }, + "psutil-5.2.2-py36h74c8701_0.tar.bz2": { + "build": "py36h74c8701_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "aa86eb8f8ae6da569e0bbc7f07b0beee", + "name": "psutil", + "sha256": "db13e6871a7122f601e7091fcf352fbb518862f18e792fc1262dfece6bb0bbf6", + "size": 255016, + "subdir": "linux-64", + "timestamp": 1505733136390, + "version": "5.2.2" + }, + "psutil-5.3.1-py27h4c169b4_0.tar.bz2": { + "build": "py27h4c169b4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2c723d324170c9c7b66cbb6ea9a1a7b4", + "name": "psutil", + "sha256": "099204942a20796be12fc067c7fa4ded124081bd77c3b7840a4c21d8887e1fbb", + "size": 288725, + "subdir": "linux-64", + "timestamp": 1507234353221, + "version": "5.3.1" + }, + "psutil-5.3.1-py35h6e9e629_0.tar.bz2": { + "build": "py35h6e9e629_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6564701f2fd90be0c8c22f60add905ef", + "name": "psutil", + "sha256": "620bd75db5acf88323ecce94eb03b0d03ccf04d07c78eb38329644e73ea6a93e", + "size": 297259, + "subdir": "linux-64", + "timestamp": 1507231337345, + "version": "5.3.1" + }, + "psutil-5.3.1-py36h0e357b8_0.tar.bz2": { + "build": "py36h0e357b8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "909221503100b73e778fa9132feb74e1", + "name": "psutil", + "sha256": "1d0a8bf8a714c87eaec26924700f52d22e9ce55d9bf52c2f75ad79eca4496f6f", + "size": 294716, + "subdir": "linux-64", + "timestamp": 1507229148439, + "version": "5.3.1" + }, + "psutil-5.4.0-py27h7da3062_0.tar.bz2": { + "build": "py27h7da3062_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d4efe320e7be25d447869922ad4dcb1b", + "name": "psutil", + "sha256": "2d825851a4e34f47a2e0a6e50b234f28428a81a5ef3e869ff2e84bf5a8c75319", + "size": 296775, + "subdir": "linux-64", + "timestamp": 1508449438610, + "version": "5.4.0" + }, + "psutil-5.4.0-py35ha5baf80_0.tar.bz2": { + "build": "py35ha5baf80_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7fe09dbcb9f47cc0bd0414ddd9a93a59", + "name": "psutil", + "sha256": "8d6c4d523e7ec4608dba48967d24f238df86faaafa64bc5e5a41995a37ba01c2", + "size": 304236, + "subdir": "linux-64", + "timestamp": 1508449389898, + "version": "5.4.0" + }, + "psutil-5.4.0-py36h84c53db_0.tar.bz2": { + "build": "py36h84c53db_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5f0cf3621f8ae29e1f6a76e32c44f5b4", + "name": "psutil", + "sha256": "f23adde77d9e2186535ca6dae9675fba487c6dac0fab085af04091c3b0b60d62", + "size": 303538, + "subdir": "linux-64", + "timestamp": 1508449440841, + "version": "5.4.0" + }, + "psutil-5.4.1-py27h61c8946_0.tar.bz2": { + "build": "py27h61c8946_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6a2cd5547756b8c9d3a097544d2b5504", + "name": "psutil", + "sha256": "3a40777ff2abb3ed06fbb06634550f30a7709412e58a99b27afa38934b4f4d88", + "size": 297989, + "subdir": "linux-64", + "timestamp": 1511830596621, + "version": "5.4.1" + }, + "psutil-5.4.1-py35h2e39a06_0.tar.bz2": { + "build": "py35h2e39a06_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c39f3b8a0d0084739f4240724516edbb", + "name": "psutil", + "sha256": "667b927e01a29937a20bd74144aae2d99e1566cefd8b4952843998f813b1393f", + "size": 305189, + "subdir": "linux-64", + "timestamp": 1511830600352, + "version": "5.4.1" + }, + "psutil-5.4.1-py36hecd8e42_0.tar.bz2": { + "build": "py36hecd8e42_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e414b4f6ab949df4247513c0f1ff72e0", + "name": "psutil", + "sha256": "e7b35b8d4c6a1f8df516c4d103f30d2f07d41df57c739d685980835b35385c18", + "size": 304581, + "subdir": "linux-64", + "timestamp": 1511830602974, + "version": "5.4.1" + }, + "psutil-5.4.3-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0a29341ef7e8e1c11a07cd85bda34e4f", + "name": "psutil", + "sha256": "ac8e12ad23f14ac9a3d949fe92c6be9663bb0f85971c4495775a9281ec9a6aa9", + "size": 300967, + "subdir": "linux-64", + "timestamp": 1515707223055, + "version": "5.4.3" + }, + "psutil-5.4.3-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dd7e0261f8858b4a599223e6fb2590ad", + "name": "psutil", + "sha256": "a6ef1be92d0396d31d6200c8086c116697fbcf2490caf23d355b2724ff8f9038", + "size": 308060, + "subdir": "linux-64", + "timestamp": 1515707274118, + "version": "5.4.3" + }, + "psutil-5.4.3-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c96e790c7a056a82c9354b6b9be39972", + "name": "psutil", + "sha256": "a9b94d3314a50d4cec31064b63d048c88723167dd2073361b8c96ceeaaca7b61", + "size": 307180, + "subdir": "linux-64", + "timestamp": 1515707077799, + "version": "5.4.3" + }, + "psutil-5.4.5-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8818ddeebd6c1afc29e7442af9993f73", + "name": "psutil", + "sha256": "b7b40fe8f352cf14d61ebc7b947f9166ce011984fcf69482ba08ee7f470435fc", + "size": 304404, + "subdir": "linux-64", + "timestamp": 1523906406386, + "version": "5.4.5" + }, + "psutil-5.4.5-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5805e79626a5de9bce44976d8279f8c7", + "name": "psutil", + "sha256": "79265755fe518ce2861aaef8f744b192f44e8cf034d46f4f4f355ea0bc2bd33e", + "size": 311150, + "subdir": "linux-64", + "timestamp": 1523906472086, + "version": "5.4.5" + }, + "psutil-5.4.5-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c885852680595fea0ce2003caefe4474", + "name": "psutil", + "sha256": "7c3e4fc2f2cb49e044092aec82a4232abe6f1b0ce3d2e987f6934105edae21ae", + "size": 310063, + "subdir": "linux-64", + "timestamp": 1523906471758, + "version": "5.4.5" + }, + "psutil-5.4.6-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "41acdc558cfdfb53a1f6111212dd662b", + "name": "psutil", + "sha256": "0fa03b97378b62463fd66966ccff518e8bbd6b78624ca4b5005256f4bc10ff29", + "size": 303960, + "subdir": "linux-64", + "timestamp": 1528894952118, + "version": "5.4.6" + }, + "psutil-5.4.6-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dd35f7e919a94d30b5d6938242007a91", + "name": "psutil", + "sha256": "605199f34cf834316c66d6107b9b91c90b52029c273797dfb238baf1ed555d89", + "size": 311243, + "subdir": "linux-64", + "timestamp": 1528894870942, + "version": "5.4.6" + }, + "psutil-5.4.6-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "84fbc2886c189007d15482a7b350c85f", + "name": "psutil", + "sha256": "9e6a10c2465c794abc472df0b484c49832c0f0b1e24486a8d23a9e8875732e65", + "size": 310449, + "subdir": "linux-64", + "timestamp": 1528894789364, + "version": "5.4.6" + }, + "psutil-5.4.6-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "23d932d5c06da5dd8da45d7e95bb958e", + "name": "psutil", + "sha256": "bd954cd05623c7b597d8c208809ab6b9278ce4b9f3e211ade9453047a5193cbc", + "size": 309755, + "subdir": "linux-64", + "timestamp": 1530736450228, + "version": "5.4.6" + }, + "psutil-5.4.7-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "14a9230f3736e4c8ef6d80e6357d4d42", + "name": "psutil", + "sha256": "cd3672fe0e87599a804009b984f04f4c71d6026c0df0c819758955188ebac88e", + "size": 306475, + "subdir": "linux-64", + "timestamp": 1534945421867, + "version": "5.4.7" + }, + "psutil-5.4.7-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "324c7fbf9d085fcf68098d8af4279e44", + "name": "psutil", + "sha256": "6dfa918c91186d11742f63245342f5d6a717400b972d33bae5d98b3bba894246", + "size": 313402, + "subdir": "linux-64", + "timestamp": 1534945423546, + "version": "5.4.7" + }, + "psutil-5.4.7-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "367b9b7bc6d570b0ff41a9ae21e173b8", + "name": "psutil", + "sha256": "fac299ad0fead99b1308341c5382896b29ddd08756b2ce2da5c003c384bdeb93", + "size": 312012, + "subdir": "linux-64", + "timestamp": 1534944967787, + "version": "5.4.7" + }, + "psutil-5.4.7-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3096ee14f03cf0d4027f51dbd74513c8", + "name": "psutil", + "sha256": "1d3bfc8767eea7d3d8ff26c2109b13dbdf776f8b3b7b8038979d4119e92cb416", + "size": 312034, + "subdir": "linux-64", + "timestamp": 1534945424444, + "version": "5.4.7" + }, + "psutil-5.4.8-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c36718798c35a55cd6b27c4d9ef2e175", + "name": "psutil", + "sha256": "3b91815f06118e9af97ae10761a4d7fb4560981a7970eeb8142a32bfb4c0bf8c", + "size": 313860, + "subdir": "linux-64", + "timestamp": 1541001167115, + "version": "5.4.8" + }, + "psutil-5.4.8-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "91e72f6852a9d4ff17d574db27a1da5f", + "name": "psutil", + "sha256": "ed31057104fc60aced96029213545f0b93703df2e1031c2d7bf892036f17f4e8", + "size": 318850, + "subdir": "linux-64", + "timestamp": 1541001187068, + "version": "5.4.8" + }, + "psutil-5.4.8-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "adc71bb92665ad8535c9877f4883102e", + "name": "psutil", + "sha256": "3725f08e801595121235b7c9d2407a1a4eced30189af0e9eaf3de220ed842535", + "size": 320755, + "subdir": "linux-64", + "timestamp": 1541001179834, + "version": "5.4.8" + }, + "psutil-5.5.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9233aa0e2dd583a69dc259ad26946341", + "name": "psutil", + "sha256": "7c289a5acb800040571766e9af22085495cd7ad7d609c16ee3352a6e526f4103", + "size": 313834, + "subdir": "linux-64", + "timestamp": 1549323659789, + "version": "5.5.0" + }, + "psutil-5.5.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2a37cb5e8417d5ee7e6cd01d93dd1d0f", + "name": "psutil", + "sha256": "becb6dd727c1f97adc1d82ffbaf7beba1184350a9a5b6b21e24aa2699debb67c", + "size": 318900, + "subdir": "linux-64", + "timestamp": 1549323725888, + "version": "5.5.0" + }, + "psutil-5.5.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "24ca726750557c88117ac0b276e64ab9", + "name": "psutil", + "sha256": "e6f49f6d8e1216ccc3e69696365e8678d904f562a602439971f9912a6c3f383f", + "size": 322488, + "subdir": "linux-64", + "timestamp": 1549323631911, + "version": "5.5.0" + }, + "psutil-5.6.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "19ee5ee35eacf7e36db33de332ec86cc", + "name": "psutil", + "sha256": "338bf9599d25e022f2c7b0ab27bb93950b3a308a00678f28c70f09dfdcc21455", + "size": 324415, + "subdir": "linux-64", + "timestamp": 1552339276670, + "version": "5.6.0" + }, + "psutil-5.6.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3700b6aa7052af8fedc5d378bd3513cd", + "name": "psutil", + "sha256": "131cc634fb508298313961b7d298a77abfa15aec510510e745c401293ee0ded6", + "size": 327382, + "subdir": "linux-64", + "timestamp": 1552339301712, + "version": "5.6.0" + }, + "psutil-5.6.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c0d61c85d78a14132223c828cf01ee37", + "name": "psutil", + "sha256": "5839dd9c1ba3babf35404a1d3d0b37ffb42f8bdf83a5f75ba4249ce9f066ce41", + "size": 326321, + "subdir": "linux-64", + "timestamp": 1552339267076, + "version": "5.6.0" + }, + "psutil-5.6.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8bac0b79ca294f67650a4c4eeb079636", + "name": "psutil", + "sha256": "d1a4ecd08ddd4f85561db396f24bfa71abbedbc87b3aeb042d194136a95c3266", + "size": 323791, + "subdir": "linux-64", + "timestamp": 1552341714832, + "version": "5.6.1" + }, + "psutil-5.6.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "35054f0960850e0f03aec4c63b3f4809", + "name": "psutil", + "sha256": "1e9564c9b0759f47fe13f4352323fb15cc169d872136a18b71d33d604d1c4e9a", + "size": 329711, + "subdir": "linux-64", + "timestamp": 1552341779424, + "version": "5.6.1" + }, + "psutil-5.6.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "257c39d26ee452a385597d797b68aeb2", + "name": "psutil", + "sha256": "62be7f29ac50f4e0bbbc53fdd599e1fa3a0f04f9ecfadc216e266b37a6bce312", + "size": 329821, + "subdir": "linux-64", + "timestamp": 1552341739302, + "version": "5.6.1" + }, + "psutil-5.6.2-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d3d67c5acc1118d1305ac0a1272790c6", + "name": "psutil", + "sha256": "58c26898603317a704401311a40bc32722c35457d7362f0cdb4f305109eea110", + "size": 327251, + "subdir": "linux-64", + "timestamp": 1556550657297, + "version": "5.6.2" + }, + "psutil-5.6.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "57279ef225e305204946a4119c3062d4", + "name": "psutil", + "sha256": "94a7fd8a5ca80a61ab289372c723439242ee52ac14e3ae2e901a68221dc71492", + "size": 333238, + "subdir": "linux-64", + "timestamp": 1556550710527, + "version": "5.6.2" + }, + "psutil-5.6.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2edd7142e437aa1f1ce8d2b5c80902e1", + "name": "psutil", + "sha256": "a0c5ffeca04c175a8f3895f66279505b3621680c2145c609297af2b32e461c7c", + "size": 334107, + "subdir": "linux-64", + "timestamp": 1556550660366, + "version": "5.6.2" + }, + "psutil-5.6.3-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9d081ade273a6bdcac6c2530fbec5f25", + "name": "psutil", + "sha256": "8764d2d448c6b44c73cbd4b93cb0a7838255791c9bae205ebafda8494fb62934", + "size": 329097, + "subdir": "linux-64", + "timestamp": 1562079562432, + "version": "5.6.3" + }, + "psutil-5.6.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c292a0713015367449a824bf2393280f", + "name": "psutil", + "sha256": "2b85d062cf1fa9716871aee5f1073b08c1dc19462db5cef62237caa77c5f774c", + "size": 335568, + "subdir": "linux-64", + "timestamp": 1562079573258, + "version": "5.6.3" + }, + "psutil-5.6.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9c5ea262d9517b6476667265fafaee3c", + "name": "psutil", + "sha256": "bf1c56d0a5b1dd02eec03d9f55ff21299ed55facac8a297187e1fdfe95da48d6", + "size": 336268, + "subdir": "linux-64", + "timestamp": 1562079552762, + "version": "5.6.3" + }, + "psutil-5.6.3-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d51c5e0d055789065a5605ab11db5620", + "name": "psutil", + "sha256": "87a0e3203adb5c164edea5c0f7fea5e7b3ffe992d37e19c5935406fcb6c05198", + "size": 336086, + "subdir": "linux-64", + "timestamp": 1573040778759, + "version": "5.6.3" + }, + "psutil-5.6.5-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "50aa6ce295b209637b0cd56a0ece692a", + "name": "psutil", + "sha256": "5249890d7c74635c3543ab0533ec818a064cfbd6f0b2ece4d56015e7efeb4821", + "size": 329813, + "subdir": "linux-64", + "timestamp": 1573251818978, + "version": "5.6.5" + }, + "psutil-5.6.5-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "36a80ba02a53670e36a895c26ad15a16", + "name": "psutil", + "sha256": "7e6137e0cfad4e873fa7271949b41fbdf7d0080cc932389a55efb5d1e09c16fa", + "size": 337183, + "subdir": "linux-64", + "timestamp": 1573251891526, + "version": "5.6.5" + }, + "psutil-5.6.5-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4c7b0814e02f2d0206f27086661728f6", + "name": "psutil", + "sha256": "1843a0031323829a3ed48b0938230403273a4c347d595d47aa9bcb2343cd7be9", + "size": 336045, + "subdir": "linux-64", + "timestamp": 1573251811026, + "version": "5.6.5" + }, + "psutil-5.6.5-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "16da0bc8c771e9b5859e8be2f95043cd", + "name": "psutil", + "sha256": "7f0513aa8903dc8c2f2a813b865d257aee28e018146e0a48fb3332e53e2f6204", + "size": 346686, + "subdir": "linux-64", + "timestamp": 1573251927219, + "version": "5.6.5" + }, + "psutil-5.6.7-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "12b655d2225b49e3ee564d1f8b6cbaf7", + "name": "psutil", + "sha256": "9d6e43bc7fbb2dccfde892e4b838c4ca47dc2c2454950d7a20d52f190408daf0", + "size": 327811, + "subdir": "linux-64", + "timestamp": 1575391191482, + "version": "5.6.7" + }, + "psutil-5.6.7-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5982f2208cb57996a00e1f4754e59538", + "name": "psutil", + "sha256": "1a2df00f4dec38ae5c69768a84ba7b328641acfd6d076ad4a8d262b9cf47bcc6", + "size": 336377, + "subdir": "linux-64", + "timestamp": 1575391215774, + "version": "5.6.7" + }, + "psutil-5.6.7-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "53c7cba5f4cb34c3ed98c6e6a66bb348", + "name": "psutil", + "sha256": "8ca98971c9ca5eeb707e4006025d79e215dca5504887ffaf63444c6672e2228a", + "size": 337093, + "subdir": "linux-64", + "timestamp": 1575391169241, + "version": "5.6.7" + }, + "psutil-5.6.7-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9cc182397140469e2141d75265b0f3df", + "name": "psutil", + "sha256": "fe10ba81dd4375278f32fd4ffe5a9e82dd1cfc9b792150048a1b202ce41c1a54", + "size": 344402, + "subdir": "linux-64", + "timestamp": 1575391227103, + "version": "5.6.7" + }, + "psutil-5.7.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7996fba0eae6596d1410774d3760c42b", + "name": "psutil", + "sha256": "a9cf0d7a7db83b4647df08d54ae4f11439b41d1d97923a52c226ff16c9ca4dda", + "size": 340021, + "subdir": "linux-64", + "timestamp": 1584038020947, + "version": "5.7.0" + }, + "psutil-5.7.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f3b660a9d74cf53c380dc789306ec4e3", + "name": "psutil", + "sha256": "e83700017734abacba66164e316f1f7f9dd45fa4be19b8ea549eccf6e564cb08", + "size": 340960, + "subdir": "linux-64", + "timestamp": 1584038013108, + "version": "5.7.0" + }, + "psutil-5.7.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cb5d82d33f0b23dd22241c550b1b49c1", + "name": "psutil", + "sha256": "f8bb9a31698c4f8c2cc480f0e8995ee65dceb9a297dd095b68fa27ccd8d5792b", + "size": 340925, + "subdir": "linux-64", + "timestamp": 1584038046109, + "version": "5.7.0" + }, + "psutil-5.7.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8fa9e0f61341306f8db89cedb0a805c7", + "name": "psutil", + "sha256": "27648c0c085d0d264d68adea1125f723e1b07a18dd7b624d1edac1175746c822", + "size": 350634, + "subdir": "linux-64", + "timestamp": 1598370307874, + "version": "5.7.2" + }, + "psutil-5.7.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d38ac46170d67580c665949107d51cd", + "name": "psutil", + "sha256": "cc309c31d45ee9b4c93342de1639329607aa550ef5861eadd2c315604e0eb8c5", + "size": 350472, + "subdir": "linux-64", + "timestamp": 1598370291656, + "version": "5.7.2" + }, + "psutil-5.7.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "562d3def9da7d3b8c39157f4c4b48f4e", + "name": "psutil", + "sha256": "3b9a476ee6cde051a6e35d1620a3574a3aa6217637381fed11564ed13d1ac684", + "size": 351379, + "subdir": "linux-64", + "timestamp": 1598370307763, + "version": "5.7.2" + }, + "psutil-5.7.2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "820b1d0e76d4677a29c6c62c37807899", + "name": "psutil", + "sha256": "97fa8acc6ce616309a7c61ecdf674e80d31fce3ddaac5d4019ce4ad9abef68ca", + "size": 353736, + "subdir": "linux-64", + "timestamp": 1607027338983, + "version": "5.7.2" + }, + "psutil-5.8.0-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0166f0d92de7dd688ea527168ca9dea4", + "name": "psutil", + "sha256": "41f2a918ac201c093e4673d9bccbee6f53c540db25bd678961b1559372bd1507", + "size": 402345, + "subdir": "linux-64", + "timestamp": 1640792653691, + "version": "5.8.0" + }, + "psutil-5.8.0-py311h5eee18b_1.tar.bz2": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "51cfe94896a1bafdd02655773a225f6d", + "name": "psutil", + "sha256": "48e2a7e877dd383a9342aea998fbd0615e82c306c65be9da81c63ebc13183919", + "size": 489877, + "subdir": "linux-64", + "timestamp": 1676825001707, + "version": "5.8.0" + }, + "psutil-5.8.0-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dda6b83be52ae8631a9b8aedd8c79b9c", + "name": "psutil", + "sha256": "e4ef0a91edfe52862e7d1a099e7df3d7fbb0845e7b0164a3926f3ed52ec7044d", + "size": 350223, + "subdir": "linux-64", + "timestamp": 1612297669545, + "version": "5.8.0" + }, + "psutil-5.8.0-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3ea837d2dac8e3efc1b9b9ddbdf27616", + "name": "psutil", + "sha256": "1023d33739aa555057c40bfc0c59a372d57cacdb93bc5dfe1b6f66c2c4920f90", + "size": 349340, + "subdir": "linux-64", + "timestamp": 1612298060797, + "version": "5.8.0" + }, + "psutil-5.8.0-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "79ae56161fb6b23fc900f4bf6943e031", + "name": "psutil", + "sha256": "5a7da09bd13cfe53da03da7bbcd1a982b0200f53b00137bff3d3c24a6e860054", + "size": 351263, + "subdir": "linux-64", + "timestamp": 1612298067868, + "version": "5.8.0" + }, + "psutil-5.8.0-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a924535045fb356e23e7a3cc8116b638", + "name": "psutil", + "sha256": "6973cfe0565ba3b5ad6d1de9e34848fbbadd78b507b2e23e1c079636b8f8f317", + "size": 350026, + "subdir": "linux-64", + "timestamp": 1612298042840, + "version": "5.8.0" + }, + "psutil-5.9.0-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ea6ee93562a9c94d730b0e2dcfb68941", + "name": "psutil", + "sha256": "d7501cd6012bb906574da7792b3c66d9a31bfabb1497882818e0d6976b686e5d", + "size": 393604, + "subdir": "linux-64", + "timestamp": 1656431395375, + "version": "5.9.0" + }, + "psutil-5.9.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2d57bf8eacf3f291db845928241f724c", + "name": "psutil", + "sha256": "96482b49191fdac59580a95e69508367083e1f7600145e11d7c2db634337eb26", + "size": 490805, + "subdir": "linux-64", + "timestamp": 1679337420563, + "version": "5.9.0" + }, + "psutil-5.9.0-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "32a55415ee3c37bbd5f6fc253ba4d7b5", + "name": "psutil", + "sha256": "d7277d155884b4f239f3b0a71ed3f43d97d1a3e553b0b7eba357329355614b7a", + "size": 351536, + "subdir": "linux-64", + "timestamp": 1656431320563, + "version": "5.9.0" + }, + "psutil-5.9.0-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38b4a8eb4ece574a3db5b1dafeb10bd7", + "name": "psutil", + "sha256": "cdb9ea9d076f82f3d266806ff90c4bafeb3533958abb5bd14cbc3702c433b924", + "size": 352826, + "subdir": "linux-64", + "timestamp": 1656431426074, + "version": "5.9.0" + }, + "psutil-5.9.0-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2cb2ad8315f68f4339b9416bd9ab115e", + "name": "psutil", + "sha256": "a760d6c9fca08c09ff0bc9a33946188e2ea5deed2443d4acb360ce55ce36ee43", + "size": 353437, + "subdir": "linux-64", + "timestamp": 1656431352923, + "version": "5.9.0" + }, + "psycopg2-2.7.3.1-py27h1368252_0.tar.bz2": { + "build": "py27h1368252_0", + "build_number": 0, + "depends": [ + "libpq", + "openssl 1.0.*", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "9c25a2ed1525a76d99e0c560f5e0d5a1", + "name": "psycopg2", + "sha256": "30a537a5829b6898a18e859cbd26c8ea31dee68a69707a3fb1a3da5e18563e12", + "size": 293527, + "subdir": "linux-64", + "timestamp": 1507670558694, + "version": "2.7.3.1" + }, + "psycopg2-2.7.3.1-py35h11414ae_0.tar.bz2": { + "build": "py35h11414ae_0", + "build_number": 0, + "depends": [ + "libpq", + "openssl 1.0.*", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "0480c9e228deca38ea4784200fbe01be", + "name": "psycopg2", + "sha256": "c83ccc30dc6ff4b6a785826c36e00b02495974b182b6c7657fd21f5244355be1", + "size": 298773, + "subdir": "linux-64", + "timestamp": 1507670629753, + "version": "2.7.3.1" + }, + "psycopg2-2.7.3.1-py36h369a60c_0.tar.bz2": { + "build": "py36h369a60c_0", + "build_number": 0, + "depends": [ + "libpq", + "openssl 1.0.*", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "bfeafc7f0a5081a236e83b7d2e99bf11", + "name": "psycopg2", + "sha256": "22ab21cc65adcd2fbe3b98b33c96d4f5f68111d10aa0106477a29565a8c15665", + "size": 297413, + "subdir": "linux-64", + "timestamp": 1507670628450, + "version": "2.7.3.1" + }, + "psycopg2-2.7.3.2-py27h6397e30_0.tar.bz2": { + "build": "py27h6397e30_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq", + "libpq >=9.6.6", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "6a4fc7b8c5e2cfd875fbd24469cfe1e7", + "name": "psycopg2", + "sha256": "8d60e8df1aef68cc6f99d4c2c5119edf40137376367b84e7d897e9ce8b05dc2e", + "size": 293904, + "subdir": "linux-64", + "timestamp": 1512073747201, + "version": "2.7.3.2" + }, + "psycopg2-2.7.3.2-py35hcc7b94d_0.tar.bz2": { + "build": "py35hcc7b94d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq", + "libpq >=9.6.6", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "9dd4b59dd3067cdf0803f408061ebf9c", + "name": "psycopg2", + "sha256": "0ffca690b2b309d8f20f001a74f2f1d47cf0609d2b9fa4f816c350ae0c4e2621", + "size": 299077, + "subdir": "linux-64", + "timestamp": 1512073779084, + "version": "2.7.3.2" + }, + "psycopg2-2.7.3.2-py36h2b1659c_0.tar.bz2": { + "build": "py36h2b1659c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq", + "libpq >=9.6.6", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "8b84b1f0a278ecf50dccea3726f3297e", + "name": "psycopg2", + "sha256": "f36430ef7200ed52143e8c113d8ccd7cc98940330c99467e026b948afb8858a2", + "size": 297771, + "subdir": "linux-64", + "timestamp": 1512073781810, + "version": "2.7.3.2" + }, + "psycopg2-2.7.4-py27hb7f436b_0.tar.bz2": { + "build": "py27hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq >=9.6.6", + "openssl >=1.0.2n,<1.0.3a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "3e0883fe860222107ee686a2b50bfc4f", + "name": "psycopg2", + "sha256": "5246f39e7c2349975ddd3df2fd5d5f5cfc96f7e8c44836da66355473e1c95897", + "size": 294444, + "subdir": "linux-64", + "timestamp": 1519749132477, + "version": "2.7.4" + }, + "psycopg2-2.7.4-py35hb7f436b_0.tar.bz2": { + "build": "py35hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq >=9.6.6", + "openssl >=1.0.2n,<1.0.3a", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "6077b96d99ac27863a3c4dbc158b8e88", + "name": "psycopg2", + "sha256": "d89260cc0aa44ac38dbed52054a954cc63669b7095408ae06c00fa5dbd540d60", + "size": 299790, + "subdir": "linux-64", + "timestamp": 1519749158437, + "version": "2.7.4" + }, + "psycopg2-2.7.4-py36hb7f436b_0.tar.bz2": { + "build": "py36hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq >=9.6.6", + "openssl >=1.0.2n,<1.0.3a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "bc3ec7b731cc46b3272071022880a106", + "name": "psycopg2", + "sha256": "ed58ec89990e0c89a08096be6c7f789709e697fc25294de6a2efba304a0fb000", + "size": 298649, + "subdir": "linux-64", + "timestamp": 1519749101681, + "version": "2.7.4" + }, + "psycopg2-2.7.5-py27hb7f436b_0.tar.bz2": { + "build": "py27hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq >=10.3,<11.0a0", + "openssl >=1.0.2o,<1.0.3a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "8aa26c2862cf16e62b73817be840adf5", + "name": "psycopg2", + "sha256": "51498739802900e4ce13665b8c019e8374dfff7046aaa09af7490bfd82997bcc", + "size": 297597, + "subdir": "linux-64", + "timestamp": 1529567676370, + "version": "2.7.5" + }, + "psycopg2-2.7.5-py35hb7f436b_0.tar.bz2": { + "build": "py35hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq >=10.3,<11.0a0", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "c999688e4c29da32a0c3df9baececa99", + "name": "psycopg2", + "sha256": "fde953965b570620de9766334ab73370cc5e2e754a3e1ea5a1cce9801ecf2f7c", + "size": 302861, + "subdir": "linux-64", + "timestamp": 1529567735239, + "version": "2.7.5" + }, + "psycopg2-2.7.5-py36hb7f436b_0.tar.bz2": { + "build": "py36hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq >=10.3,<11.0a0", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "f1dfa45645970958854b06fcc9a0b369", + "name": "psycopg2", + "sha256": "c1a087a6b262a7bfdbcafeb20793d5f4b7a4aa28a0b63e9ea6c263058d98873f", + "size": 301447, + "subdir": "linux-64", + "timestamp": 1529567670536, + "version": "2.7.5" + }, + "psycopg2-2.7.5-py37hb7f436b_0.tar.bz2": { + "build": "py37hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq >=10.3,<11.0a0", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "859ef3f8b55c75afb4e11762147814c6", + "name": "psycopg2", + "sha256": "b34597f1cb2d17805499fc6eab4ccd08476d7b985ff746816db20b3dafc96ce2", + "size": 299871, + "subdir": "linux-64", + "timestamp": 1530873224976, + "version": "2.7.5" + }, + "psycopg2-2.7.6.1-py27h1ba5d50_0.tar.bz2": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.1,<12.0a0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "b84d3f8c63199665090102ae6e748158", + "name": "psycopg2", + "sha256": "2ba468998566a767415453ab7b1fcf8318337a10fcc867bf6d2baed14a09fcfd", + "size": 304854, + "subdir": "linux-64", + "timestamp": 1545240146256, + "version": "2.7.6.1" + }, + "psycopg2-2.7.6.1-py36h1ba5d50_0.tar.bz2": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.1,<12.0a0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "ff8a4682c06450803ef2336d11965cb9", + "name": "psycopg2", + "sha256": "b65531ffd173ff4b22d3e68fcd393773519a6e4b18ff1a8858781a5bde78767d", + "size": 316804, + "subdir": "linux-64", + "timestamp": 1545240170243, + "version": "2.7.6.1" + }, + "psycopg2-2.7.6.1-py37h1ba5d50_0.tar.bz2": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.1,<12.0a0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "227093cd8d49d3823f063a096e22b097", + "name": "psycopg2", + "sha256": "6426eacb5ad67fe0205c6bd63b2fac643a99dab0cff44dbacd6bfd8c831abdf1", + "size": 315438, + "subdir": "linux-64", + "timestamp": 1545240186919, + "version": "2.7.6.1" + }, + "psycopg2-2.8.3-py27h1ba5d50_0.tar.bz2": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.2,<12.0a0", + "openssl >=1.1.1d,<1.1.2a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "84da3d79a6c22144ae562f72039904e0", + "name": "psycopg2", + "sha256": "6c9687ad920d5b4ffea67955c4bf17e6fce9a9dfa85fee66cd39047d0fd3f14e", + "size": 173571, + "subdir": "linux-64", + "timestamp": 1569267908465, + "version": "2.8.3" + }, + "psycopg2-2.8.3-py36h1ba5d50_0.tar.bz2": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.2,<12.0a0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "d484290f9d944951c8fdc9b3de39f7a0", + "name": "psycopg2", + "sha256": "a70e1bf79cb4294ceb89dab82494e7f4f0a78813770a25ea0d94d3b9ce614179", + "size": 174844, + "subdir": "linux-64", + "timestamp": 1569267908241, + "version": "2.8.3" + }, + "psycopg2-2.8.3-py37h1ba5d50_0.tar.bz2": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.2,<12.0a0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "b89caa3c840821b9b045ef6824a4025e", + "name": "psycopg2", + "sha256": "f89f7aed0986705031c44f30daf2d34e74ae082ad6470fa318b91dbaf9353559", + "size": 175088, + "subdir": "linux-64", + "timestamp": 1569267901452, + "version": "2.8.3" + }, + "psycopg2-2.8.4-py27h1ba5d50_0.tar.bz2": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.2,<12.0a0", + "openssl >=1.1.1d,<1.1.2a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "7d20a2eab10febd6027b208d15a8aaba", + "name": "psycopg2", + "sha256": "bca10b428952e4660e0326859063398a7651e75f6cde8b46b313b7382a70c0bd", + "size": 174063, + "subdir": "linux-64", + "timestamp": 1573224741345, + "version": "2.8.4" + }, + "psycopg2-2.8.4-py36h1ba5d50_0.tar.bz2": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.2,<12.0a0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "b3b5fe2c69d33ec5a6dc0f540c6cbaf3", + "name": "psycopg2", + "sha256": "ffe330e782cbb138d395fa487cf7ddb0a5ed3fab133a3064592aeb945a482759", + "size": 175240, + "subdir": "linux-64", + "timestamp": 1573224774680, + "version": "2.8.4" + }, + "psycopg2-2.8.4-py37h1ba5d50_0.tar.bz2": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.2,<12.0a0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "756e2e2e810b82fb6dffb8834a40969d", + "name": "psycopg2", + "sha256": "1f91559a65707eb877043b89a52e9274d86ae2310c07f4a1a4e1171726201ef6", + "size": 175431, + "subdir": "linux-64", + "timestamp": 1573224727000, + "version": "2.8.4" + }, + "psycopg2-2.8.4-py38h1ba5d50_0.tar.bz2": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.2,<12.0a0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "09c264fddff76e7e3d7aa611723a9df1", + "name": "psycopg2", + "sha256": "f9857c990789423ba0beaa109e80fafa3eba80c34619bad10e47aac29d96b885", + "size": 185330, + "subdir": "linux-64", + "timestamp": 1573224807574, + "version": "2.8.4" + }, + "psycopg2-2.8.5-py36h1ba5d50_0.tar.bz2": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "54cd41a0bdd4d07318476956506af029", + "name": "psycopg2", + "sha256": "02f549383cd6b80739f4694532fafb988192143ef4436c2e7bc26a640e6eef7d", + "size": 176236, + "subdir": "linux-64", + "timestamp": 1594305176865, + "version": "2.8.5" + }, + "psycopg2-2.8.5-py36h3c74f83_1.tar.bz2": { + "build": "py36h3c74f83_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "4623a8aa95ea41312c579cb3fd018985", + "name": "psycopg2", + "sha256": "9be88440b5afcb53f0533d973d348b3bb1443c028d5425339311389e6708aeb4", + "size": 176634, + "subdir": "linux-64", + "timestamp": 1608147629467, + "version": "2.8.5" + }, + "psycopg2-2.8.5-py37h1ba5d50_0.tar.bz2": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "26cb53653dfd83dbf811d55f641f7f0b", + "name": "psycopg2", + "sha256": "dfc4ec35229dbab4a78a85a286be56279605bc6f848ece0c5a31bae610ee1b97", + "size": 176348, + "subdir": "linux-64", + "timestamp": 1594305174294, + "version": "2.8.5" + }, + "psycopg2-2.8.5-py37h3c74f83_1.tar.bz2": { + "build": "py37h3c74f83_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "ee15a51f4b3a7f5cfaf5b30523484360", + "name": "psycopg2", + "sha256": "41e72331303366149b0fbcf4e605ec81a28205f3e4d17741733d8603a23e6df4", + "size": 176813, + "subdir": "linux-64", + "timestamp": 1608147623088, + "version": "2.8.5" + }, + "psycopg2-2.8.5-py38h1ba5d50_0.tar.bz2": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "29fbd358aee17171bae186abd0afb271", + "name": "psycopg2", + "sha256": "587aa3ea53a9027b25cfb8fbafaa98094c9a174551e4a255969b500002c0eb5c", + "size": 179476, + "subdir": "linux-64", + "timestamp": 1594305156932, + "version": "2.8.5" + }, + "psycopg2-2.8.5-py38h3c74f83_1.tar.bz2": { + "build": "py38h3c74f83_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "6ba02cec084efa3eacb732e8bb06788a", + "name": "psycopg2", + "sha256": "a77f41d25139e1b08ed7150322a6940ed24570f307b1d0cfd3ac35b64d79bffb", + "size": 179847, + "subdir": "linux-64", + "timestamp": 1608147642932, + "version": "2.8.5" + }, + "psycopg2-2.8.5-py39h3c74f83_1.tar.bz2": { + "build": "py39h3c74f83_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "00a026e18bb06a2fd7c1c77e8a851228", + "name": "psycopg2", + "sha256": "ed761e3bca329799d81077c46bf1a2df97f7ed5598434154f9658d360482305a", + "size": 179746, + "subdir": "linux-64", + "timestamp": 1608147659540, + "version": "2.8.5" + }, + "psycopg2-2.8.6-py310h37d81fd_2.tar.bz2": { + "build": "py310h37d81fd_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libpq >=12.9,<13.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0-or-later AND Other", + "license_family": "LGPL", + "md5": "3e26fef22a07ced2cc175e52e166021c", + "name": "psycopg2", + "sha256": "babac2bf4e82db065b5aaa73b7372304331ebebaba7f387d56f91ad2e3c42612", + "size": 463210, + "subdir": "linux-64", + "timestamp": 1662147837297, + "version": "2.8.6" + }, + "psycopg2-2.8.6-py310h8f2d780_1.tar.bz2": { + "build": "py310h8f2d780_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libpq >=12.9,<13.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "f78faacbce150c4f5077f4b669d69385", + "name": "psycopg2", + "sha256": "df1761754c135c38e51fb4857566a31d80e7e845c5afdb5626598c0c41337514", + "size": 455568, + "subdir": "linux-64", + "timestamp": 1640792685730, + "version": "2.8.6" + }, + "psycopg2-2.8.6-py36h3c74f83_1.tar.bz2": { + "build": "py36h3c74f83_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "febae0d86b822f9a8177b0e0782930d4", + "name": "psycopg2", + "sha256": "37d78cc17e220008265fe0b3b745cf3371e43ed0eacb315fd90c9a93d2ee0435", + "size": 171382, + "subdir": "linux-64", + "timestamp": 1612298666200, + "version": "2.8.6" + }, + "psycopg2-2.8.6-py37h37d81fd_2.tar.bz2": { + "build": "py37h37d81fd_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libpq >=12.9,<13.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0-or-later AND Other", + "license_family": "LGPL", + "md5": "d9a8b4799ee34558295e81da0f71beef", + "name": "psycopg2", + "sha256": "a5b1a42897b20a7ae8d2bb95941acfa24f6757c1580044e7c9fd5074e6d48b45", + "size": 175127, + "subdir": "linux-64", + "timestamp": 1662147710561, + "version": "2.8.6" + }, + "psycopg2-2.8.6-py37h3c74f83_1.tar.bz2": { + "build": "py37h3c74f83_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "4dfda371b69253b2f196151240f6a7bd", + "name": "psycopg2", + "sha256": "a70c7a9ceb38c1cf725f2a991b39a1688cd8d8785eb6d3e6e5f073eb537a05b7", + "size": 171464, + "subdir": "linux-64", + "timestamp": 1612298630248, + "version": "2.8.6" + }, + "psycopg2-2.8.6-py38h37d81fd_2.tar.bz2": { + "build": "py38h37d81fd_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libpq >=12.9,<13.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0-or-later AND Other", + "license_family": "LGPL", + "md5": "7339776d5ef438800957b1006100be4a", + "name": "psycopg2", + "sha256": "d4e4ab7180c89fff39a4dfe528c71ed1d19098216685f6cff86e194389e85ed3", + "size": 177373, + "subdir": "linux-64", + "timestamp": 1662147783986, + "version": "2.8.6" + }, + "psycopg2-2.8.6-py38h3c74f83_1.tar.bz2": { + "build": "py38h3c74f83_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "815a8f6449a379232fa607e3fff7a8d3", + "name": "psycopg2", + "sha256": "3880d69505aaa851c66883fbba05ede93a87d8a866782a671f6a8968f92766ac", + "size": 174621, + "subdir": "linux-64", + "timestamp": 1612298201840, + "version": "2.8.6" + }, + "psycopg2-2.8.6-py39h37d81fd_2.tar.bz2": { + "build": "py39h37d81fd_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libpq >=12.9,<13.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0-or-later AND Other", + "license_family": "LGPL", + "md5": "78c564c39fce4fe3f8d611d5c39f74d0", + "name": "psycopg2", + "sha256": "8d78c7d2f7298db4bb35439e4936da628687dabb8a548fd580d292fa80e39183", + "size": 177107, + "subdir": "linux-64", + "timestamp": 1662147748321, + "version": "2.8.6" + }, + "psycopg2-2.8.6-py39h3c74f83_1.tar.bz2": { + "build": "py39h3c74f83_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "589e7a3bd072a0e5947e2a3d667acd05", + "name": "psycopg2", + "sha256": "55af20917d68fb5e4498c908fe51d21eadffd6605bb725b23ae5a13d73c98061", + "size": 174395, + "subdir": "linux-64", + "timestamp": 1612298650628, + "version": "2.8.6" + }, + "psycopg2-2.9.3-py310h37d81fd_0.tar.bz2": { + "build": "py310h37d81fd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libpq >=12.9,<13.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "62e15b46e68f0659f6dfa3c31e31e1f4", + "name": "psycopg2", + "sha256": "a50224bbe438e736d55aa154d4bce30cbd3c05ef24771455e52d710755f00630", + "size": 186240, + "subdir": "linux-64", + "timestamp": 1666817566994, + "version": "2.9.3" + }, + "psycopg2-2.9.3-py311h37d81fd_0.tar.bz2": { + "build": "py311h37d81fd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libpq >=12.9,<13.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "e7093ce89936c32e534a59ab3246a9f1", + "name": "psycopg2", + "sha256": "b87a70350caa400126625900668a035744bb834f2ae963b5f1a73ba40f0483c0", + "size": 203518, + "subdir": "linux-64", + "timestamp": 1676845237768, + "version": "2.9.3" + }, + "psycopg2-2.9.3-py37h37d81fd_0.tar.bz2": { + "build": "py37h37d81fd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libpq >=12.9,<13.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "ec9c07a6e27513f7fd951fe8185bfedd", + "name": "psycopg2", + "sha256": "8dc1b46a1893be3180e61373e1d95dd224ccade787fb934b2c2d45b06ce066dc", + "size": 183778, + "subdir": "linux-64", + "timestamp": 1666817496835, + "version": "2.9.3" + }, + "psycopg2-2.9.3-py38h37d81fd_0.tar.bz2": { + "build": "py38h37d81fd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libpq >=12.9,<13.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "7f4d52a4d0f983df977318ee078d609e", + "name": "psycopg2", + "sha256": "440c1b2e4bfecdc071f02ab1d96f23f171a5ff278795bcc0f8ff47a5c988bb7f", + "size": 185859, + "subdir": "linux-64", + "timestamp": 1666817601837, + "version": "2.9.3" + }, + "psycopg2-2.9.3-py39h37d81fd_0.tar.bz2": { + "build": "py39h37d81fd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libpq >=12.9,<13.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "0ca571d3348dc74ee721d1bdb89631d3", + "name": "psycopg2", + "sha256": "7922474372317eb5363b5bc1efdff8753155cb54a9b0145e57815dfe840b95f7", + "size": 185553, + "subdir": "linux-64", + "timestamp": 1666817531722, + "version": "2.9.3" + }, + "pthread-stubs-0.3-h0ce48e5_1.tar.bz2": { + "build": "h0ce48e5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de7d258a4efcd8a63df73099c8e5d954", + "name": "pthread-stubs", + "sha256": "a0dd2e926abb989d755d196c803b0e3aff3f375eeccb329468e96d00387db929", + "size": 4895, + "subdir": "linux-64", + "timestamp": 1505733967605, + "version": "0.3" + }, + "ptyprocess-0.5.2-py27h4ccb14c_0.tar.bz2": { + "build": "py27h4ccb14c_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "0c917568637fd5ab2e0d071650c312a0", + "name": "ptyprocess", + "sha256": "25b8ece5d072f9108580707a4670e96eac6e547a41fd5b646542cb3c1cbe62ff", + "size": 22091, + "subdir": "linux-64", + "timestamp": 1505690216282, + "version": "0.5.2" + }, + "ptyprocess-0.5.2-py35h38ce0a3_0.tar.bz2": { + "build": "py35h38ce0a3_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "ab11f16a560fe4d289b90175c9b4981f", + "name": "ptyprocess", + "sha256": "9686ff9b2bb81cfbf9a3baf9520bfd57bf2a0cc831ef24e68657a018f6325ff3", + "size": 22615, + "subdir": "linux-64", + "timestamp": 1505690227056, + "version": "0.5.2" + }, + "ptyprocess-0.5.2-py36h69acd42_0.tar.bz2": { + "build": "py36h69acd42_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "01dd6297fdd8f5d56c978b9d9ef50ae1", + "name": "ptyprocess", + "sha256": "7aebd3a596408c2ae79b2ef23f6bb3515cff53585b663e811455169409659864", + "size": 22558, + "subdir": "linux-64", + "timestamp": 1505690237910, + "version": "0.5.2" + }, + "ptyprocess-0.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "be452d40f176616bf35246ed994a362e", + "name": "ptyprocess", + "sha256": "dac4e1c3c6d9de099685c52ec11e0526cf2fc2008b125f595a1d25d16b601033", + "size": 22710, + "subdir": "linux-64", + "timestamp": 1529940995642, + "version": "0.6.0" + }, + "ptyprocess-0.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "9a0e6dbecebc4a84c0853a9c7ee30c7c", + "name": "ptyprocess", + "sha256": "be498159abee7c4ebac48a15430682d5a7394e95d6cc76ae13c504b72042df47", + "size": 23240, + "subdir": "linux-64", + "timestamp": 1529941006472, + "version": "0.6.0" + }, + "ptyprocess-0.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "b037b3268569b310d15136134d883c72", + "name": "ptyprocess", + "sha256": "76df0af0bb438d62311dd54d56d708495eb05bcd61cf0b909937d945c3d68d2c", + "size": 23284, + "subdir": "linux-64", + "timestamp": 1529940952792, + "version": "0.6.0" + }, + "ptyprocess-0.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "1742c71b043249516ea6e3808860ec76", + "name": "ptyprocess", + "sha256": "26378c0250037ddf8030d75426e24df027381b296a70851636a5d06fd7c83602", + "size": 23104, + "subdir": "linux-64", + "timestamp": 1530694737919, + "version": "0.6.0" + }, + "ptyprocess-0.6.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "1660e8fe2b2b386dd92f17a86dbb9a9b", + "name": "ptyprocess", + "sha256": "bc2a623793c10cf35236a06eeba6a2be09e8e565e05672ad023c6cc203f160f9", + "size": 23645, + "subdir": "linux-64", + "timestamp": 1573040795975, + "version": "0.6.0" + }, + "pugixml-1.11.4-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "176bf1f3e94bdc899cf7231f079ae93a", + "name": "pugixml", + "sha256": "b5944027dc1599c9ff43463c6a99e63eb17d7f260fb7def937e3f4b2f07387f2", + "size": 118007, + "subdir": "linux-64", + "timestamp": 1641920820198, + "version": "1.11.4" + }, + "pugixml-1.11.4-h295c915_1.tar.bz2": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3bcda0007675cc355fc9e368add7edea", + "name": "pugixml", + "sha256": "47a058e5952245321537574603d065be28252261904b1abbc2dce9f02e166b1a", + "size": 117982, + "subdir": "linux-64", + "timestamp": 1644215826526, + "version": "1.11.4" + }, + "pure-sasl-0.4.0-py27h6e92d2f_0.tar.bz2": { + "build": "py27h6e92d2f_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "be5b7004c169c8e28225e9afcd2b1d22", + "name": "pure-sasl", + "sha256": "a5ece55e7f16af12f21763a4f81e40bf757b7d7f7cc7d5eeecd02f9c7f5e39f8", + "size": 19684, + "subdir": "linux-64", + "timestamp": 1512152747066, + "version": "0.4.0" + }, + "pure-sasl-0.4.0-py35h3910ffa_0.tar.bz2": { + "build": "py35h3910ffa_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "39dcbcbb02c70870f0d5495fab37e98b", + "name": "pure-sasl", + "sha256": "f0b8da16c746b164e737045e1e060ff7b9ffbc4c8d0ef416f4e988ef644932e2", + "size": 20198, + "subdir": "linux-64", + "timestamp": 1512152768267, + "version": "0.4.0" + }, + "pure-sasl-0.4.0-py36h4dcc5df_0.tar.bz2": { + "build": "py36h4dcc5df_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b0fd2df8a99fc2fc335a17b95e0b4ac2", + "name": "pure-sasl", + "sha256": "f54bcc52849173f7d6446d40a0f138cf782010b0d5eff0af93f9ec418b8b2a4f", + "size": 20153, + "subdir": "linux-64", + "timestamp": 1512152784226, + "version": "0.4.0" + }, + "pure-sasl-0.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e76ff11eab5694f1e0a0e500c390d6c8", + "name": "pure-sasl", + "sha256": "f64e06c9a8ad6dc5ea80e0ae65b8828af5814f315dc7033c9b8cf93a441aef4e", + "size": 20323, + "subdir": "linux-64", + "timestamp": 1522103965645, + "version": "0.5.0" + }, + "pure-sasl-0.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "4be5845db910e7d29ed53e3c083d321d", + "name": "pure-sasl", + "sha256": "86b8666ba5e1dfb5296ee87a1c5e6d2bcfc21f07ad0c24e29e39570084f0a089", + "size": 20799, + "subdir": "linux-64", + "timestamp": 1522103972629, + "version": "0.5.0" + }, + "pure-sasl-0.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9942ebdb0e76d3949cbd0f8540956cc1", + "name": "pure-sasl", + "sha256": "57104cfa6a8b0e7d062ed8981fc7054fb1557b4458fd5d3906cc470d2a62a2fc", + "size": 20705, + "subdir": "linux-64", + "timestamp": 1522103976657, + "version": "0.5.0" + }, + "pure-sasl-0.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c7930b7f3b4abb91ea39e4a947fbe560", + "name": "pure-sasl", + "sha256": "13cf9d2e649c5330d3a72574d058935645e2134072a7112a4827e04158cdae0d", + "size": 20867, + "subdir": "linux-64", + "timestamp": 1527851855605, + "version": "0.5.1" + }, + "pure-sasl-0.5.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "e1c7790b840809e9e7b18f3d241925a0", + "name": "pure-sasl", + "sha256": "bacd1efdd5c5ad92991a855a8530c939f3284d9117ca5195964adcf54b39c12f", + "size": 21324, + "subdir": "linux-64", + "timestamp": 1527851868541, + "version": "0.5.1" + }, + "pure-sasl-0.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d1fa22b7878ece3a39d553b49492b43f", + "name": "pure-sasl", + "sha256": "58edca55d663f72d675a4fe985b70e6ad00b123815c78f994004138139ad4f7a", + "size": 21253, + "subdir": "linux-64", + "timestamp": 1527851811771, + "version": "0.5.1" + }, + "pure-sasl-0.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "42fa6e443ffb39b93fc0ab94547bcbe4", + "name": "pure-sasl", + "sha256": "8ec3ed873cad0bca06b6693148970715d8115f62cf984d65b32114840008b40b", + "size": 21353, + "subdir": "linux-64", + "timestamp": 1530906201675, + "version": "0.5.1" + }, + "py-1.4.34-py27he5894e4_1.tar.bz2": { + "build": "py27he5894e4_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "dabc4ddd298606a624440f6c476d19ae", + "name": "py", + "sha256": "aa8ed47734c1599160f97bfd4a9c72982d84ffc71c08ac450fb25256c8ba256a", + "size": 133746, + "subdir": "linux-64", + "timestamp": 1505688184827, + "version": "1.4.34" + }, + "py-1.4.34-py35hd71111f_1.tar.bz2": { + "build": "py35hd71111f_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "365e7f57b5e7f04c43e4220eca2fa256", + "name": "py", + "sha256": "119d1513fdce77b0abc7d03f9b302098dcf574e6fd2a05d30231eabc61e26810", + "size": 137739, + "subdir": "linux-64", + "timestamp": 1505688197893, + "version": "1.4.34" + }, + "py-1.4.34-py36h0712aa3_1.tar.bz2": { + "build": "py36h0712aa3_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b3670d4af39828f9f50d5f4cb4e68028", + "name": "py", + "sha256": "f19561f81823eb7fc7dc16eeb0a19dcf2b2f08a271de77c6e8c54723e13df0e9", + "size": 136970, + "subdir": "linux-64", + "timestamp": 1505688211014, + "version": "1.4.34" + }, + "py-1.5.2-py27h203d672_0.tar.bz2": { + "build": "py27h203d672_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "045ba9914c555b5601983393e21fe3af", + "name": "py", + "sha256": "ad8d348def264ee77458f3dac759c924a157088e1129460a9fa993179861e813", + "size": 134895, + "subdir": "linux-64", + "timestamp": 1511322549308, + "version": "1.5.2" + }, + "py-1.5.2-py35hfe8c5ce_0.tar.bz2": { + "build": "py35hfe8c5ce_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "979c60dec64ff9bd62c880f1c91bd741", + "name": "py", + "sha256": "2c94d5dab9093f9033ca40d5519d48bb644d59848ae346c597bc0f738fc95a5b", + "size": 139385, + "subdir": "linux-64", + "timestamp": 1511322563707, + "version": "1.5.2" + }, + "py-1.5.2-py36h29bf505_0.tar.bz2": { + "build": "py36h29bf505_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7d74da74d91d50412bd90b93cb020c9f", + "name": "py", + "sha256": "3993bd5690d85f6219e259b1bfdfcb320d442c942d7e3afa69147fad4a79ae6d", + "size": 138268, + "subdir": "linux-64", + "timestamp": 1511322565174, + "version": "1.5.2" + }, + "py-1.5.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "86b8960b5b563e30c95e02703cab5334", + "name": "py", + "sha256": "0b7cb9b5851e7a5ff50c70d2ee852fce208a872ffc331e3f54537928b1917747", + "size": 135125, + "subdir": "linux-64", + "timestamp": 1522163180006, + "version": "1.5.3" + }, + "py-1.5.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "06dcda49b46f53a128bd7364a4289f95", + "name": "py", + "sha256": "5b2225295397fb8ebfab8a18fe7892709d451d10815eab4703bfa470c20c1dc9", + "size": 139018, + "subdir": "linux-64", + "timestamp": 1522163218363, + "version": "1.5.3" + }, + "py-1.5.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2b5af5e208c7148dc9591b9e1cdbfee3", + "name": "py", + "sha256": "0e1a9dd08c7880b711437786232291f0e0be58d35b661b539113997a0a5d6103", + "size": 138307, + "subdir": "linux-64", + "timestamp": 1522163217552, + "version": "1.5.3" + }, + "py-1.5.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "151c7911e6883550e7bc8e6c38ab37ab", + "name": "py", + "sha256": "cd26cb25003b0d3135070c6f52f4bfa6d5e407a08672b7a8da15dfbff7665fad", + "size": 138129, + "subdir": "linux-64", + "timestamp": 1530693620778, + "version": "1.5.3" + }, + "py-1.5.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "0bae10f25768e332c97e6962522af6f0", + "name": "py", + "sha256": "655d2948efa5a487ccba11696e1f9e3bfa5df1c65986a8a717e45eb7cb9e815e", + "size": 137451, + "subdir": "linux-64", + "timestamp": 1531784091229, + "version": "1.5.4" + }, + "py-1.5.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "0a2a7d92d23873d13cef8a3e5a05258f", + "name": "py", + "sha256": "87440171650b2e29dd32d376ccfb35eebd33375fb86b59e230fbff5917489afa", + "size": 141740, + "subdir": "linux-64", + "timestamp": 1531784133541, + "version": "1.5.4" + }, + "py-1.5.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b48f448a64d6b3ae3b57a4002412895c", + "name": "py", + "sha256": "25d18c187e115781e6c127f4c1c0e7921b19c730cae38be5dc51dc3da7e97ec7", + "size": 140696, + "subdir": "linux-64", + "timestamp": 1531784016590, + "version": "1.5.4" + }, + "py-1.5.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e905c1b81f395813752696be5fba432a", + "name": "py", + "sha256": "b4ecbf54d66e763f0b69f83168af9ba1074b5ea021f1f31846fe69085c741134", + "size": 140688, + "subdir": "linux-64", + "timestamp": 1531784192329, + "version": "1.5.4" + }, + "py-1.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "0fcc7c1302409d9b1e50c120c21019b1", + "name": "py", + "sha256": "860b83303361637ab21f3fd6cfd45a4e6f6fe4dc2c04f6d698c3ba7b8b1b97e5", + "size": 135877, + "subdir": "linux-64", + "timestamp": 1536073016853, + "version": "1.6.0" + }, + "py-1.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "127cad1d137a484eb63c10e1fd2aeb04", + "name": "py", + "sha256": "5b90e9bac971058dbbf155fe1c65a4ff65eda42c12a3cadf502d3d143363cfa2", + "size": 139987, + "subdir": "linux-64", + "timestamp": 1536073016853, + "version": "1.6.0" + }, + "py-1.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9dd891eb8d7953f29aef2b8034ace7e8", + "name": "py", + "sha256": "a4a5eabd0cac58907e8228d71986f678dce01438323b29499e38a6771850d748", + "size": 139182, + "subdir": "linux-64", + "timestamp": 1536072989027, + "version": "1.6.0" + }, + "py-1.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "620b5a051e0b64cc23a0b7adc41d0f2b", + "name": "py", + "sha256": "5aee4e8b4ef3b0a86ffaf2ada7f446a198a72c4fdc21bd9d345680410955811d", + "size": 139220, + "subdir": "linux-64", + "timestamp": 1536073044758, + "version": "1.6.0" + }, + "py-1.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "60b0e963fd58dea1ed019c3646e3b4dd", + "name": "py", + "sha256": "bb2be5d3774961f9fc4c3afe1a4565e12ad04b09882aadb543e37b2bbdd0243d", + "size": 138479, + "subdir": "linux-64", + "timestamp": 1539631993187, + "version": "1.7.0" + }, + "py-1.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "55030158ae5d13960f9004926fdec403", + "name": "py", + "sha256": "b19af3c55e80f6a33d233d9551ee727f584e6e12d59eff224a79767c9661e215", + "size": 141777, + "subdir": "linux-64", + "timestamp": 1539632007428, + "version": "1.7.0" + }, + "py-1.7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "921fb4ed0c827a18c044d911516c0802", + "name": "py", + "sha256": "228b379cb016dcc94ca95df3ddf9371eabf7830d60a43ea67e9839678248d614", + "size": 141682, + "subdir": "linux-64", + "timestamp": 1539631998253, + "version": "1.7.0" + }, + "py-1.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "3cbb112e728bd40e8b3ef11b8a7e2df3", + "name": "py", + "sha256": "e25f354dda00a281de625de5550d443c5428e912178a8371c4e4e807bcc465a6", + "size": 140302, + "subdir": "linux-64", + "timestamp": 1551146090097, + "version": "1.8.0" + }, + "py-1.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8abc2df801a047d8f20a4f0e76fade26", + "name": "py", + "sha256": "614f68db4c173d9afd40288f6c04b1cd957b480a7331f78744ac44eac2e15150", + "size": 143573, + "subdir": "linux-64", + "timestamp": 1551146107081, + "version": "1.8.0" + }, + "py-1.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f39111b2f7a2e07dea92624a49557031", + "name": "py", + "sha256": "88944c33d687090da504bdfddf52b4f241fcedf59e259886d459bb1c6ba0aaf8", + "size": 143426, + "subdir": "linux-64", + "timestamp": 1551146067263, + "version": "1.8.0" + }, + "py-boost-1.65.1-py27h3b928e7_3.tar.bz2": { + "build": "py27h3b928e7_3", + "build_number": 3, + "depends": [ + "libboost 1.65.1 h4055789_3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Boost-1.0", + "md5": "d77e54920ade2669f358bd947f52601e", + "name": "py-boost", + "sha256": "de5e8d701f87132cd016411ca998ff31933d4d1d2d5fd5bd766c8000df31696d", + "size": 303649, + "subdir": "linux-64", + "timestamp": 1508786716540, + "version": "1.65.1" + }, + "py-boost-1.65.1-py27hf484d3e_4.tar.bz2": { + "build": "py27hf484d3e_4", + "build_number": 4, + "depends": [ + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "Boost-1.0", + "md5": "ff178654e58ac1d8dea2ed6a8150ae0a", + "name": "py-boost", + "sha256": "518bd5330c32f31ddaa580b8c176ec2c70453ff7c6e6e33c5181a9578e8f016d", + "size": 308166, + "subdir": "linux-64", + "timestamp": 1515095659386, + "version": "1.65.1" + }, + "py-boost-1.65.1-py35hdf000e1_3.tar.bz2": { + "build": "py35hdf000e1_3", + "build_number": 3, + "depends": [ + "libboost 1.65.1 h4055789_3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Boost-1.0", + "md5": "df43efd4ad7200af5f80cac0f6d8182d", + "name": "py-boost", + "sha256": "9f0631356f075bdc98327b8b10a9600ce25d6b1597d9349e600abfad29479f11", + "size": 303648, + "subdir": "linux-64", + "timestamp": 1508786699581, + "version": "1.65.1" + }, + "py-boost-1.65.1-py35hf484d3e_4.tar.bz2": { + "build": "py35hf484d3e_4", + "build_number": 4, + "depends": [ + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "Boost-1.0", + "md5": "359d931c76e850f22a443472451b3992", + "name": "py-boost", + "sha256": "a3fe62b6a82a8f800929a8207e190438bfb46f9dbe4c3b5bf0c9e989069b91d2", + "size": 304199, + "subdir": "linux-64", + "timestamp": 1515095557209, + "version": "1.65.1" + }, + "py-boost-1.65.1-py36hf484d3e_4.tar.bz2": { + "build": "py36hf484d3e_4", + "build_number": 4, + "depends": [ + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "474a9bc5f99143f1b2aa72529de57b20", + "name": "py-boost", + "sha256": "413a5c957316492555d65a4d7dfff44bbf2a8de51694b129ce67fb78e62c4c9c", + "size": 304366, + "subdir": "linux-64", + "timestamp": 1515095440777, + "version": "1.65.1" + }, + "py-boost-1.65.1-py36hff4598c_3.tar.bz2": { + "build": "py36hff4598c_3", + "build_number": 3, + "depends": [ + "libboost 1.65.1 h4055789_3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Boost-1.0", + "md5": "1ae806b06c8e0e6d77c74756029bf0b7", + "name": "py-boost", + "sha256": "02fd142e78ee896dc7b764b3725d2c4a9dda2de16863fb678c8a49ddfa695f1a", + "size": 303704, + "subdir": "linux-64", + "timestamp": 1508786733552, + "version": "1.65.1" + }, + "py-boost-1.67.0-py27h04863e7_4.tar.bz2": { + "build": "py27h04863e7_4", + "build_number": 4, + "depends": [ + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "Boost-1.0", + "md5": "899a33fbe392af92bfcbd3022e762944", + "name": "py-boost", + "sha256": "c5db7757ea523e6e476b56240918cc28ce5777512a37a21fd4bf0dbb3ead4ee1", + "size": 313073, + "subdir": "linux-64", + "timestamp": 1530782153386, + "version": "1.67.0" + }, + "py-boost-1.67.0-py35h04863e7_4.tar.bz2": { + "build": "py35h04863e7_4", + "build_number": 4, + "depends": [ + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "Boost-1.0", + "md5": "04c3f2a9c89dc718b631285ef421e7a5", + "name": "py-boost", + "sha256": "648ab054776836a3fe4fe5f026ae4d20341c2c8ed7395b5c6c9e108c48b08ad7", + "size": 315728, + "subdir": "linux-64", + "timestamp": 1534944641004, + "version": "1.67.0" + }, + "py-boost-1.67.0-py36h04863e7_4.tar.bz2": { + "build": "py36h04863e7_4", + "build_number": 4, + "depends": [ + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "2e146234ae5d86e9c2078585c0ed07a7", + "name": "py-boost", + "sha256": "4ac3791fb181e11afefdc7eef19217e2987ea6a7ea79b41dd8c6302d90788624", + "size": 309252, + "subdir": "linux-64", + "timestamp": 1530782210803, + "version": "1.67.0" + }, + "py-boost-1.67.0-py37h04863e7_4.tar.bz2": { + "build": "py37h04863e7_4", + "build_number": 4, + "depends": [ + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "f6f0613aed2fe1e2c52caf7fef7f3e70", + "name": "py-boost", + "sha256": "d10fee5387bcd5a6296fc9adb74247f765e8fcd179baab8461a585e1cd109699", + "size": 309287, + "subdir": "linux-64", + "timestamp": 1530782267799, + "version": "1.67.0" + }, + "py-boost-1.71.0-py310h00e6091_0.tar.bz2": { + "build": "py310h00e6091_0", + "build_number": 0, + "depends": [ + "libboost >=1.71.0,<1.71.1.0a0 haf77d95_0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Boost-1.0", + "md5": "4be7baeb5d4d1be634e700e690035a8e", + "name": "py-boost", + "sha256": "b0672d4e6c87b069009063f35e440c35ae3d243a4dc44d7d85af1723adf08dbf", + "size": 29599, + "subdir": "linux-64", + "timestamp": 1640823523168, + "version": "1.71.0" + }, + "py-boost-1.71.0-py310h00e6091_1.tar.bz2": { + "build": "py310h00e6091_1", + "build_number": 1, + "depends": [ + "libboost >=1.71.0,<1.71.1.0a0 haf77d95_1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Boost-1.0", + "md5": "f58007a34b60485b12ef1ae0c791ee6c", + "name": "py-boost", + "sha256": "b67668467afc9173d7803f994f0efc74b71c6c51bad30d3cc978f3f837e6554e", + "size": 264324, + "subdir": "linux-64", + "timestamp": 1642511533168, + "version": "1.71.0" + }, + "py-boost-1.71.0-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libboost >=1.71.0,<1.71.1.0a0 h97c9712_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "60d669da63e39f4f5fb44678557d482f", + "name": "py-boost", + "sha256": "085e0557048e2e0ae97336469b79e63a8ef8f6f082933b549a154f694b9fc52c", + "size": 265638, + "subdir": "linux-64", + "timestamp": 1597485868536, + "version": "1.71.0" + }, + "py-boost-1.71.0-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libboost >=1.71.0,<1.71.1.0a0 h97c9712_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "b9d95376da866998156551b18258deb3", + "name": "py-boost", + "sha256": "2ff315e8a68cd8c9e78b56acbea8763bfb42e8d838c44fc73d7f6339bd0c70d3", + "size": 265661, + "subdir": "linux-64", + "timestamp": 1597485989217, + "version": "1.71.0" + }, + "py-boost-1.71.0-py37h51133e4_1.tar.bz2": { + "build": "py37h51133e4_1", + "build_number": 1, + "depends": [ + "libboost >=1.71.0,<1.71.1.0a0 haf77d95_1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "7f0b60a7132549f79fc82dd1d039c862", + "name": "py-boost", + "sha256": "4f892f658f5e2956ab01c998eeaa16249ba9cb28a50cae1aedb716cde7fd8db1", + "size": 254754, + "subdir": "linux-64", + "timestamp": 1642425120003, + "version": "1.71.0" + }, + "py-boost-1.71.0-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libboost >=1.71.0,<1.71.1.0a0 h97c9712_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "ffa391af5d24e802da1e3d8e180ea121", + "name": "py-boost", + "sha256": "d9422b9e14274b2bb4d37efd072d535550334691f4fabfa8011258963e1b0966", + "size": 287148, + "subdir": "linux-64", + "timestamp": 1597486057870, + "version": "1.71.0" + }, + "py-boost-1.71.0-py38h51133e4_1.tar.bz2": { + "build": "py38h51133e4_1", + "build_number": 1, + "depends": [ + "libboost >=1.71.0,<1.71.1.0a0 haf77d95_1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "e66fd2bd2b600a69a64f3ddb91784642", + "name": "py-boost", + "sha256": "2c78986d99c92b0570dda4dbd5a8cba144d236d7d61e176ece9d2b8a34517b23", + "size": 272935, + "subdir": "linux-64", + "timestamp": 1642425231565, + "version": "1.71.0" + }, + "py-boost-1.71.0-py38h962f231_0.tar.bz2": { + "build": "py38h962f231_0", + "build_number": 0, + "depends": [ + "libboost >=1.71.0,<1.71.1.0a0 h97c9712_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "7d2d1a833c97d5ef359ce9f24f75d965", + "name": "py-boost", + "sha256": "242a48d9194c158fc8a279095fbd4118ac6b8bd1877d545e4099d2645cabec2d", + "size": 278945, + "subdir": "linux-64", + "timestamp": 1572611048021, + "version": "1.71.0" + }, + "py-boost-1.71.0-py39h51133e4_1.tar.bz2": { + "build": "py39h51133e4_1", + "build_number": 1, + "depends": [ + "libboost >=1.71.0,<1.71.1.0a0 haf77d95_1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Boost-1.0", + "md5": "be228f54bd51133459b6930f3c7e145e", + "name": "py-boost", + "sha256": "73b3d722e9624b41675f100698a22b24a0f90f08d87d727aa16cbd58cae2a8f5", + "size": 272790, + "subdir": "linux-64", + "timestamp": 1642425158617, + "version": "1.71.0" + }, + "py-boost-1.73.0-py310h00e6091_12.tar.bz2": { + "build": "py310h00e6091_12", + "build_number": 12, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h28710b8_12", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "73c81d845f0aece7b976567b8d5b6edc", + "name": "py-boost", + "sha256": "2e86c8c7d53aac671ea9d26526c2f0dacae8f4f0aec1af5d026a80a77e7abff3", + "size": 265068, + "subdir": "linux-64", + "timestamp": 1655880116025, + "version": "1.73.0" + }, + "py-boost-1.73.0-py36h962f231_10.tar.bz2": { + "build": "py36h962f231_10", + "build_number": 10, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h37e3b65_10", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "0b34a469ff9b0b9db2256b279c9182bc", + "name": "py-boost", + "sha256": "d56ba62a9a97fd6e3f5c922f8cf21019cc4d09e669af926d20e74ed16c1d5a56", + "size": 260874, + "subdir": "linux-64", + "timestamp": 1601386269954, + "version": "1.73.0" + }, + "py-boost-1.73.0-py36h962f231_11.tar.bz2": { + "build": "py36h962f231_11", + "build_number": 11, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h37e3b65_11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "25f1c7b4d4e876124baad52782e9cc8c", + "name": "py-boost", + "sha256": "a37c967832d2007e9e131e4f60ad861468989ca0f7d698dc96a2a8435514e781", + "size": 264692, + "subdir": "linux-64", + "timestamp": 1601470652659, + "version": "1.73.0" + }, + "py-boost-1.73.0-py36ha9443f7_11.tar.bz2": { + "build": "py36ha9443f7_11", + "build_number": 11, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h3ff78a5_11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "d455c6173db10dfe9be021978993f7d9", + "name": "py-boost", + "sha256": "ce68520aae5ae37240790364b841c0377614d5d0fa1b1d57382c9e07b9cecbde", + "size": 261849, + "subdir": "linux-64", + "timestamp": 1611677407946, + "version": "1.73.0" + }, + "py-boost-1.73.0-py37h04863e7_10.tar.bz2": { + "build": "py37h04863e7_10", + "build_number": 10, + "depends": [ + "libboost 1.73.0 hf484d3e_10", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "4ae305c36d6614684acd1057bf4e1a84", + "name": "py-boost", + "sha256": "263e5e0b79ff529c1796d443eadf48eca278271a97698fc6d38ef9d2e27f701e", + "size": 249361, + "subdir": "linux-64", + "timestamp": 1601386877440, + "version": "1.73.0" + }, + "py-boost-1.73.0-py37h04863e7_11.tar.bz2": { + "build": "py37h04863e7_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 hf484d3e_11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "0af8fe192bd8edc4792dfadf56e69e90", + "name": "py-boost", + "sha256": "1713c7a6299f9ae5445d12168d8d8b945e6706cdad8ac764217d3287e15bd698", + "size": 256508, + "subdir": "linux-64", + "timestamp": 1601471397180, + "version": "1.73.0" + }, + "py-boost-1.73.0-py37h51133e4_12.tar.bz2": { + "build": "py37h51133e4_12", + "build_number": 12, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h28710b8_12", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "f680d7f2187b699547f80901a32271bb", + "name": "py-boost", + "sha256": "83343414ccf4fac4e7cf786cdfd3c522d854532f5692bd7f780e67ed68c77195", + "size": 241431, + "subdir": "linux-64", + "timestamp": 1655880058187, + "version": "1.73.0" + }, + "py-boost-1.73.0-py37h962f231_10.tar.bz2": { + "build": "py37h962f231_10", + "build_number": 10, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h37e3b65_10", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "a366c83d5b7b95e5c1157dcfae84431a", + "name": "py-boost", + "sha256": "17b4ad6f9298e5415d20a5fc6c678bd809d986227a09397ab24d69555d50213f", + "size": 261015, + "subdir": "linux-64", + "timestamp": 1601386147926, + "version": "1.73.0" + }, + "py-boost-1.73.0-py37h962f231_11.tar.bz2": { + "build": "py37h962f231_11", + "build_number": 11, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h37e3b65_11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "a6c4263b3eca69e0b152ffecd7d856cc", + "name": "py-boost", + "sha256": "4edbd28ab88b584ca910ce58cb0c2dc7c42882ba7087f04015e1f461da9b5212", + "size": 264583, + "subdir": "linux-64", + "timestamp": 1601470803246, + "version": "1.73.0" + }, + "py-boost-1.73.0-py37ha9443f7_11.tar.bz2": { + "build": "py37ha9443f7_11", + "build_number": 11, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h3ff78a5_11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "f5f8b8d73cbd292b8215dcd31d9cd8a8", + "name": "py-boost", + "sha256": "4365bdb1db84984c4919dbd93b6f25af0896ca44f7c808b6db7eb5f6ee94b6cc", + "size": 261754, + "subdir": "linux-64", + "timestamp": 1611677214668, + "version": "1.73.0" + }, + "py-boost-1.73.0-py38h51133e4_12.tar.bz2": { + "build": "py38h51133e4_12", + "build_number": 12, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h28710b8_12", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "357fbfd3399271a49249cfb965262d7e", + "name": "py-boost", + "sha256": "803fcd4556e65520c770d691980c802fffc7082476ba191bd5f06332f185b7cb", + "size": 265255, + "subdir": "linux-64", + "timestamp": 1655879943412, + "version": "1.73.0" + }, + "py-boost-1.73.0-py38h962f231_10.tar.bz2": { + "build": "py38h962f231_10", + "build_number": 10, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h37e3b65_10", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "b875756548bf2ef0b7ce6e2cfcca9e11", + "name": "py-boost", + "sha256": "9381bda13ef5318e453d204e3b4c8b55d13132721eaba895e78618b1995651eb", + "size": 281569, + "subdir": "linux-64", + "timestamp": 1601386209473, + "version": "1.73.0" + }, + "py-boost-1.73.0-py38h962f231_11.tar.bz2": { + "build": "py38h962f231_11", + "build_number": 11, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h37e3b65_11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "7c7047b8262a3509899d9c1837b73865", + "name": "py-boost", + "sha256": "07380ed277ef4c52addae1a5db4e6155e23c4de02a9806b887caba4a9178a749", + "size": 285104, + "subdir": "linux-64", + "timestamp": 1601470741827, + "version": "1.73.0" + }, + "py-boost-1.73.0-py38ha9443f7_11.tar.bz2": { + "build": "py38ha9443f7_11", + "build_number": 11, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h3ff78a5_11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "51d11889383337505c553ec2e3fd3173", + "name": "py-boost", + "sha256": "b07cf712f6131d45d01adf81a62b6ef2990593bef7305c53f5efa250f4135100", + "size": 279262, + "subdir": "linux-64", + "timestamp": 1611677313741, + "version": "1.73.0" + }, + "py-boost-1.73.0-py39h51133e4_12.tar.bz2": { + "build": "py39h51133e4_12", + "build_number": 12, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h28710b8_12", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "f5e8d068b4ad46b35f72d1022aaceb23", + "name": "py-boost", + "sha256": "cab348d52813f0bb2905bfec07721c9906a2c0ae823f370c5002e87dd65f01d9", + "size": 265125, + "subdir": "linux-64", + "timestamp": 1655880000921, + "version": "1.73.0" + }, + "py-boost-1.73.0-py39ha9443f7_11.tar.bz2": { + "build": "py39ha9443f7_11", + "build_number": 11, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h3ff78a5_11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Boost-1.0", + "md5": "7a259e7a5518f4f7b6dd2f3b7e47f933", + "name": "py-boost", + "sha256": "12a421dc0e2b7f232e4f10ade7711a31d19e338acd884fdc40736513864bbfbc", + "size": 279334, + "subdir": "linux-64", + "timestamp": 1611677499056, + "version": "1.73.0" + }, + "py-cpuinfo-4.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f05083e97164f115dc406e16266d4e7a", + "name": "py-cpuinfo", + "sha256": "e092f64c3ecf38c762b7a2d819af5735034836674aabfeb0aa93d5114560988e", + "size": 36013, + "subdir": "linux-64", + "timestamp": 1529238993098, + "version": "4.0.0" + }, + "py-cpuinfo-4.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1931ed445eb9ab44feb7c0ea3e2be87e", + "name": "py-cpuinfo", + "sha256": "5616bbb9f928177efad43d839ea89e8861bfa635414a56f71b7ef8212111134d", + "size": 36813, + "subdir": "linux-64", + "timestamp": 1529239005706, + "version": "4.0.0" + }, + "py-cpuinfo-4.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ae35c504bcfad6b3eaa53c044c1d2208", + "name": "py-cpuinfo", + "sha256": "7e78df0837695a29b1d0871c9db807c4590a7e64b2fb83c7a0c483b03926aaf0", + "size": 36167, + "subdir": "linux-64", + "timestamp": 1529238981525, + "version": "4.0.0" + }, + "py-cpuinfo-4.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5083c6a1ceed3a4c07cddf262a68e7f4", + "name": "py-cpuinfo", + "sha256": "2b738a66f1094f04ca1b756953f21f96c44daa35e5efe6170743637ee7cb8604", + "size": 36059, + "subdir": "linux-64", + "timestamp": 1530872912884, + "version": "4.0.0" + }, + "py-lief-0.10.1-py310h295c915_1.tar.bz2": { + "build": "py310h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "liblief 0.10.1 h295c915_1", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "91f8e39f046d7bf553c26a5bb2af7392", + "name": "py-lief", + "sha256": "27b5304766030dcdff3de42fb369863cd8b46f6efc9cde5db46572c6ba17a98a", + "size": 1370014, + "subdir": "linux-64", + "timestamp": 1640821620380, + "version": "0.10.1" + }, + "py-lief-0.10.1-py36h403a769_0.tar.bz2": { + "build": "py36h403a769_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.10.1 he6710b0_0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7b7304bd9195cfddb0fe299899735bb0", + "name": "py-lief", + "sha256": "31894baf850cb06dabab9a29269b26f12cff8d4c9b8ff9ddc4b73c8e5ee12da4", + "size": 1209529, + "subdir": "linux-64", + "timestamp": 1588594572525, + "version": "0.10.1" + }, + "py-lief-0.10.1-py37h403a769_0.tar.bz2": { + "build": "py37h403a769_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.10.1 he6710b0_0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "af8bd3fca554e95be90771f388127f76", + "name": "py-lief", + "sha256": "e52d79c5e3b1f3d6679dcecce5fb616bd1801ec1d4836c86643afd8020c41353", + "size": 1208369, + "subdir": "linux-64", + "timestamp": 1588594250064, + "version": "0.10.1" + }, + "py-lief-0.10.1-py38h403a769_0.tar.bz2": { + "build": "py38h403a769_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.10.1 he6710b0_0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7437e7418060dfef082db5fca9538503", + "name": "py-lief", + "sha256": "b46211d533fda4ddaf68b0769007638a9ebc08493b5dfbd3152390a3d9a1dd2f", + "size": 1378538, + "subdir": "linux-64", + "timestamp": 1588594034625, + "version": "0.10.1" + }, + "py-lief-0.10.1-py39h2531618_1.tar.bz2": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.10.1 h2531618_1", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "93054af47209ae773d2d3f3a853265c2", + "name": "py-lief", + "sha256": "a4f669d8a5a477470e83d4f12372696345340742d79ee353be2079d586e2e869", + "size": 1377550, + "subdir": "linux-64", + "timestamp": 1607402088727, + "version": "0.10.1" + }, + "py-lief-0.11.5-py310h295c915_1.tar.bz2": { + "build": "py310h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "liblief 0.11.5 h295c915_1", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e4b73814bb066e3ae8833f0eadf4fbb0", + "name": "py-lief", + "sha256": "92c0e5a6d6babb9808e19871d1ed88102ccd1b8de0a0623505ffc7ee69019a21", + "size": 1462431, + "subdir": "linux-64", + "timestamp": 1648524414384, + "version": "0.11.5" + }, + "py-lief-0.11.5-py37h295c915_1.tar.bz2": { + "build": "py37h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "liblief 0.11.5 h295c915_1", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d1de97f1f3cfbf3e2f641332e488a3fd", + "name": "py-lief", + "sha256": "9346dce762d0939ab492a096e9ece12be95197c6c996f7e44768183d76eeb9c8", + "size": 1299700, + "subdir": "linux-64", + "timestamp": 1648523895595, + "version": "0.11.5" + }, + "py-lief-0.11.5-py38h295c915_1.tar.bz2": { + "build": "py38h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "liblief 0.11.5 h295c915_1", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "45978df7064d6d8ac38a322e3f1c8617", + "name": "py-lief", + "sha256": "092f03860c06351011f241fb852bc59635fd909f263149fd6de0d5bc522fcb3b", + "size": 1464018, + "subdir": "linux-64", + "timestamp": 1648524154796, + "version": "0.11.5" + }, + "py-lief-0.11.5-py39h295c915_1.tar.bz2": { + "build": "py39h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "liblief 0.11.5 h295c915_1", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cd8fbbdeb49ec00a4914112c7c374d69", + "name": "py-lief", + "sha256": "87728965e7cd82e521b6b442cc063883498951120b71a1ee7611b673b775c1e2", + "size": 1466360, + "subdir": "linux-64", + "timestamp": 1648524673212, + "version": "0.11.5" + }, + "py-lief-0.12.3-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "liblief 0.12.3 h6a678d5_0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f7eab3344fa8aa390b62b5600ea0319d", + "name": "py-lief", + "sha256": "b807506d88cffb5f36f3c6da9d94ffb54e51c350d995b99dd267bd098aa8f0b2", + "size": 1781396, + "subdir": "linux-64", + "timestamp": 1670880875825, + "version": "0.12.3" + }, + "py-lief-0.12.3-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "liblief 0.12.3 h6a678d5_0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7ababa10958b1d42c99889f58bce84fb", + "name": "py-lief", + "sha256": "dfbdabcb2e11cdb9a91fed727859f4b9f66442629e995e6ca2781eb82195d3ad", + "size": 1772304, + "subdir": "linux-64", + "timestamp": 1676841196631, + "version": "0.12.3" + }, + "py-lief-0.12.3-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "liblief 0.12.3 h6a678d5_0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0b496e60c80e670be3bb4b0fe7d89a2f", + "name": "py-lief", + "sha256": "6f003a7bd8696b9111c5d6c73cb63e2bf9042969617a236fb68766c295567f97", + "size": 1705392, + "subdir": "linux-64", + "timestamp": 1670878757521, + "version": "0.12.3" + }, + "py-lief-0.12.3-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "liblief 0.12.3 h6a678d5_0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b4bc1af42c90999234f3edb2f3f9877b", + "name": "py-lief", + "sha256": "2223998e46fc66820e13e0d5e6abaa8b679a909b840db0a35a934921812ddb56", + "size": 1779033, + "subdir": "linux-64", + "timestamp": 1670879818783, + "version": "0.12.3" + }, + "py-lief-0.12.3-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "liblief 0.12.3 h6a678d5_0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6513e5c3712ba9db9624435fc7ace6d6", + "name": "py-lief", + "sha256": "05501a580cd368d5a8e10d453b76ac28dc431ccb5f0a36cc35284c9fc56f53bc", + "size": 1793713, + "subdir": "linux-64", + "timestamp": 1670877648423, + "version": "0.12.3" + }, + "py-lief-0.8.3-py27h1532aa0_0.tar.bz2": { + "build": "py27h1532aa0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "liblief 0.8.3 h1532aa0_0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3592427d364481582aec5c66d42c8779", + "name": "py-lief", + "sha256": "e7229a11e53d98670e6932b61a0c0707ed34892f2028ee9aaeab7a7a4a5e805d", + "size": 2521345, + "subdir": "linux-64", + "timestamp": 1528207748961, + "version": "0.8.3" + }, + "py-lief-0.8.3-py35h1532aa0_0.tar.bz2": { + "build": "py35h1532aa0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "liblief 0.8.3 h1532aa0_0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d8b767f2c56cc89b2475ef8ab591395c", + "name": "py-lief", + "sha256": "0232b6c69e7bc82cefb49c793b53465c5c7d883b8a61531304815e6e38160b04", + "size": 2504831, + "subdir": "linux-64", + "timestamp": 1528207136652, + "version": "0.8.3" + }, + "py-lief-0.8.3-py36h1532aa0_0.tar.bz2": { + "build": "py36h1532aa0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "liblief 0.8.3 h1532aa0_0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "876daa437a03aae2716b1a91e9fc0484", + "name": "py-lief", + "sha256": "1860b97adb7d7997659bf9464ce3b1c4a6eb840681d9f41cffaa74872477b0f3", + "size": 2503909, + "subdir": "linux-64", + "timestamp": 1528207444282, + "version": "0.8.3" + }, + "py-lief-0.9.0-py27h1532aa0_0.tar.bz2": { + "build": "py27h1532aa0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "liblief 0.9.0 h1532aa0_0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "722907c7f6419d3c3a6ce07ad0ce50fc", + "name": "py-lief", + "sha256": "d709bc46bff5b5b74eeebbb621af89084e6d7700ad69d303b4cfc28163e2ef37", + "size": 3149646, + "subdir": "linux-64", + "timestamp": 1528676064407, + "version": "0.9.0" + }, + "py-lief-0.9.0-py27h7725739_1.tar.bz2": { + "build": "py27h7725739_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.9.0 h7725739_1", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bfd75ed7db62a134c4bd59ef54fb4c48", + "name": "py-lief", + "sha256": "871732493621aff030eeda44b59b31de3f28b8ba4111364a0436429acff710f2", + "size": 3292551, + "subdir": "linux-64", + "timestamp": 1541029497560, + "version": "0.9.0" + }, + "py-lief-0.9.0-py27h7725739_2.tar.bz2": { + "build": "py27h7725739_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.9.0 h7725739_2", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "55b86a7ec41fe4e27eacec00340fbdf1", + "name": "py-lief", + "sha256": "05e5b88520044b7a3342f5fdf1fbae6b3b3bc12d2321e5be21f095383c08108b", + "size": 1644740, + "subdir": "linux-64", + "timestamp": 1547592380460, + "version": "0.9.0" + }, + "py-lief-0.9.0-py35h1532aa0_0.tar.bz2": { + "build": "py35h1532aa0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "liblief 0.9.0 h1532aa0_0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bc8fc086e3c27b39cf3ac305fe455d69", + "name": "py-lief", + "sha256": "dded10a7ab915239ad268e620cf0310cfd6dd2789c01d13537edd18956e08096", + "size": 3126882, + "subdir": "linux-64", + "timestamp": 1528676824186, + "version": "0.9.0" + }, + "py-lief-0.9.0-py36h1532aa0_0.tar.bz2": { + "build": "py36h1532aa0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "liblief 0.9.0 h1532aa0_0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ce982b9e5d16d38d3451555f89a705ad", + "name": "py-lief", + "sha256": "767f4cd4e2561a96a202768099459923de77ae32f84402dcf69f1cf6786e5e4a", + "size": 3127362, + "subdir": "linux-64", + "timestamp": 1528676443833, + "version": "0.9.0" + }, + "py-lief-0.9.0-py36h7725739_1.tar.bz2": { + "build": "py36h7725739_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.9.0 h7725739_1", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b24e392ef91ec8d5eca3a89e03217ce2", + "name": "py-lief", + "sha256": "3f3bbbfee78d3a03480dbcf39bbd72ef68f67557e902d4d2b10fee199fd4172f", + "size": 3254354, + "subdir": "linux-64", + "timestamp": 1541029008879, + "version": "0.9.0" + }, + "py-lief-0.9.0-py36h7725739_2.tar.bz2": { + "build": "py36h7725739_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.9.0 h7725739_2", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "80185aa6a4791628093bd1a32dec47fc", + "name": "py-lief", + "sha256": "4e1922d6bbdc1d2e65f78b5f960f3258093fd549e369d1357d4154ad2ef7bd9c", + "size": 1616717, + "subdir": "linux-64", + "timestamp": 1547592894374, + "version": "0.9.0" + }, + "py-lief-0.9.0-py37h1532aa0_0.tar.bz2": { + "build": "py37h1532aa0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "liblief 0.9.0 h1532aa0_0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "70d5cc08159fa5ff3a183b571a8b04f2", + "name": "py-lief", + "sha256": "4f03855aa22945c7cb146b83365cd5e61a25b7e0c42bd614d46656c5184d1c82", + "size": 3125942, + "subdir": "linux-64", + "timestamp": 1531770257700, + "version": "0.9.0" + }, + "py-lief-0.9.0-py37h7725739_1.tar.bz2": { + "build": "py37h7725739_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.9.0 h7725739_1", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9283801b688f1cb8fbd72013b30ba908", + "name": "py-lief", + "sha256": "f46e7b566ce1cc7b7a7c5431a321a2a4881d080cc9d69e150fa86959d3bd06eb", + "size": 3253869, + "subdir": "linux-64", + "timestamp": 1541029256807, + "version": "0.9.0" + }, + "py-lief-0.9.0-py37h7725739_2.tar.bz2": { + "build": "py37h7725739_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.9.0 h7725739_2", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7b0789ba6236b04723a7577c084b9daf", + "name": "py-lief", + "sha256": "73071d89b9a7415beb90dda09e51e9ff7a78757e3bc485f2adc58fcd68b7dd4d", + "size": 1617643, + "subdir": "linux-64", + "timestamp": 1547593382791, + "version": "0.9.0" + }, + "py-mxnet-1.0.0-py27_nomklhf484d3e_0.tar.bz2": { + "build": "py27_nomklhf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.0.0 nomklh2cb3ce3_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "efdd3f1eed5d3b485759dac7015af4f7", + "name": "py-mxnet", + "sha256": "e6d7d9dceaf58efbc62040411ca475a4aabc28936caae5c7eb6b489f33f3d2c0", + "size": 586289, + "subdir": "linux-64", + "timestamp": 1514731518019, + "version": "1.0.0" + }, + "py-mxnet-1.0.0-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.0.0 hb7fadbc_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "a2645e79397dd806434a733a65796e4e", + "name": "py-mxnet", + "sha256": "b498f2c593575c5ee23d5efcd254080ba57d2962edfa0058bedf0d42809a1773", + "size": 745791, + "subdir": "linux-64", + "timestamp": 1514730658321, + "version": "1.0.0" + }, + "py-mxnet-1.0.0-py35_nomklhf484d3e_0.tar.bz2": { + "build": "py35_nomklhf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.0.0 nomklh2cb3ce3_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=3.5,<3.6.0a0", + "requests >=2.18.4,<3", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "d9dffb9d7d2fe739272fcc2c0cac819d", + "name": "py-mxnet", + "sha256": "d932b8c0ebdf68b4f1ecbe2ea3ce73461b9ccb8c0ea217839e2386e2df878359", + "size": 611195, + "subdir": "linux-64", + "timestamp": 1514731560600, + "version": "1.0.0" + }, + "py-mxnet-1.0.0-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.0.0 hb7fadbc_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=3.5,<3.6.0a0", + "requests >=2.18.4,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "be5423ebbc76c785f821078bcc4360f7", + "name": "py-mxnet", + "sha256": "7063a4d1ca0f57538b4ef0b14504536aceefe3577eab1595d893761c7c3c32eb", + "size": 765996, + "subdir": "linux-64", + "timestamp": 1514730730868, + "version": "1.0.0" + }, + "py-mxnet-1.0.0-py36_nomklhf484d3e_0.tar.bz2": { + "build": "py36_nomklhf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.0.0 nomklh2cb3ce3_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "b0208c2957fba1a66f796234dd9012c1", + "name": "py-mxnet", + "sha256": "00ae1ed3a571f0c880afa7a75d1bbb1fcb1efe5c24c2b4216697377e8bc081f4", + "size": 617755, + "subdir": "linux-64", + "timestamp": 1514731605997, + "version": "1.0.0" + }, + "py-mxnet-1.0.0-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.0.0 hb7fadbc_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "f8903d72da2c018f72957e747a11b7a8", + "name": "py-mxnet", + "sha256": "fd6877a85b8651afe07671a723cbb48080610233bb9618ea76593649c0716e78", + "size": 769347, + "subdir": "linux-64", + "timestamp": 1514730772242, + "version": "1.0.0" + }, + "py-mxnet-1.1.0-py27_nomklhf484d3e_0.tar.bz2": { + "build": "py27_nomklhf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.1.0 nomklh028b6bb_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "ea30e6df43a4569088093f5075fd51a7", + "name": "py-mxnet", + "sha256": "a78705e8d503d4cacb8a3a7a5ae19339107868092f1a240fcd9a2976167560ad", + "size": 638760, + "subdir": "linux-64", + "timestamp": 1522953592864, + "version": "1.1.0" + }, + "py-mxnet-1.1.0-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.1.0 h47cb24f_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "1993de81eef5290eec278e2af8d3b3b8", + "name": "py-mxnet", + "sha256": "a555fc5592f5eeb9eaba1bf834ee253806aba0a7c6ee3bd91ddf5f81bc4fb631", + "size": 825381, + "subdir": "linux-64", + "timestamp": 1522952820011, + "version": "1.1.0" + }, + "py-mxnet-1.1.0-py35_nomklhf484d3e_0.tar.bz2": { + "build": "py35_nomklhf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.1.0 nomklh028b6bb_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=3.5,<3.6.0a0", + "requests >=2.18.4,<3", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "13e04dadc4ddec5fd2c95e7e73ec4030", + "name": "py-mxnet", + "sha256": "b6c935df85203f85489770be510e085d5f2241e2599bb2e99f0297c23bb487de", + "size": 652824, + "subdir": "linux-64", + "timestamp": 1522953866320, + "version": "1.1.0" + }, + "py-mxnet-1.1.0-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.1.0 h47cb24f_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=3.5,<3.6.0a0", + "requests >=2.18.4,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "bd9207968000e683355be42d8dd5199d", + "name": "py-mxnet", + "sha256": "269cd297589256a7f8d28c6962f2293e1cc6762cf1925ea4a560ba6aa0f1dcdd", + "size": 652816, + "subdir": "linux-64", + "timestamp": 1522953780746, + "version": "1.1.0" + }, + "py-mxnet-1.1.0-py36_nomklhf484d3e_0.tar.bz2": { + "build": "py36_nomklhf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.1.0 nomklh028b6bb_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "307d7e196d3ed7f07d7dae35fc22239e", + "name": "py-mxnet", + "sha256": "77d888ee7b72b69cf76c82f826725069572616ad619c324464bc26435af9e1d2", + "size": 652498, + "subdir": "linux-64", + "timestamp": 1522954169169, + "version": "1.1.0" + }, + "py-mxnet-1.1.0-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.1.0 h47cb24f_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "e57a07b27ed1c10a52c3aab56e9ea057", + "name": "py-mxnet", + "sha256": "f5fe2c4c0e10b1eecad0a0d89bb74b0d067e552627ad5cbea4f38d3cf647fe04", + "size": 652299, + "subdir": "linux-64", + "timestamp": 1522953958863, + "version": "1.1.0" + }, + "py-mxnet-1.2.1-py27h6c82189_0.tar.bz2": { + "build": "py27h6c82189_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.2.1.*", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.15.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<2.19.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "400737c2c7f64c6cbebb5ab61de664fb", + "name": "py-mxnet", + "sha256": "dd54e657c1c2d9acea95df35298129da95d56291021965b8d3fbfb6707a0b13f", + "size": 748198, + "subdir": "linux-64", + "timestamp": 1533367722763, + "version": "1.2.1" + }, + "py-mxnet-1.2.1-py35h6c82189_0.tar.bz2": { + "build": "py35h6c82189_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.2.1.*", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.15.0", + "python >=3.5,<3.6.0a0", + "requests >=2.18.4,<2.19.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "decc2dbb8e15d08f1b71372f6e6d12bf", + "name": "py-mxnet", + "sha256": "b6124d807c6ceb7bc758646a57333be5b4dc2c6c6cc2af954c105658f7d49517", + "size": 752215, + "subdir": "linux-64", + "timestamp": 1533368042029, + "version": "1.2.1" + }, + "py-mxnet-1.2.1-py36h6c82189_0.tar.bz2": { + "build": "py36h6c82189_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.2.1.*", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.15.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<2.19.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "0149b8741912a55fb9e6c088f8b9fc1c", + "name": "py-mxnet", + "sha256": "debfa10b640e1f7a3394a78432e8dd69c1711deaab115bbaea48bf57dcb3ff70", + "size": 746188, + "subdir": "linux-64", + "timestamp": 1533368181477, + "version": "1.2.1" + }, + "py-mxnet-1.5.0-py27hc738527_0.tar.bz2": { + "build": "py27hc738527_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libmxnet 1.5.0.*", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.0,<=2.0.0", + "python >=2.7,<2.8.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "7c11a26eba4e856f14a725b6144d69c2", + "name": "py-mxnet", + "sha256": "7fc24fd55c0bcc6c52c4d4356f75a078d6d9f648bd8b411e6884664a34b2bdcb", + "size": 1296927, + "subdir": "linux-64", + "timestamp": 1564770063957, + "version": "1.5.0" + }, + "py-mxnet-1.5.0-py310h72e8b00_0.tar.bz2": { + "build": "py310h72e8b00_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=9.3.0", + "libmxnet 1.5.0.*", + "libstdcxx-ng >=9.3.0", + "numpy >=1.16.0,<=2.0.0", + "python >=3.10,<3.11.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "c7c94a43d4ccdb4caabf8db22cf902a9", + "name": "py-mxnet", + "sha256": "3fa70d4c6007b2e4997915aad65b5459d3053fed364191f9f2553856d3efa83f", + "size": 1795811, + "subdir": "linux-64", + "timestamp": 1640822283950, + "version": "1.5.0" + }, + "py-mxnet-1.5.0-py36hc738527_0.tar.bz2": { + "build": "py36hc738527_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libmxnet 1.5.0.*", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.0,<=2.0.0", + "python >=3.6,<3.7.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "b711640b4fdd1d06af05172cca12e40e", + "name": "py-mxnet", + "sha256": "a5642c46bb68629060b045c78020d0fe685c878a446e10bf2afa3f71f94073c5", + "size": 1353539, + "subdir": "linux-64", + "timestamp": 1564770123849, + "version": "1.5.0" + }, + "py-mxnet-1.5.0-py37hc738527_0.tar.bz2": { + "build": "py37hc738527_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libmxnet 1.5.0.*", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.0,<=2.0.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "7ed4bbe3861aefd431e2ae19268499c3", + "name": "py-mxnet", + "sha256": "ba7501f28c2eb765bc282dce749edd2995a3542f312827489601462c9b1fb092", + "size": 1366643, + "subdir": "linux-64", + "timestamp": 1564770024855, + "version": "1.5.0" + }, + "py-mxnet-1.5.0-py37hf6b7f80_0.tar.bz2": { + "build": "py37hf6b7f80_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmxnet 1.5.0.*", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.0,<=2.0.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "91906ed0758dd4ad22d46708a79ff3eb", + "name": "py-mxnet", + "sha256": "39eedb127812dabd9704e0ff8cdbad893ff62ae711b526fddb1e9b0e42d96e11", + "size": 1329120, + "subdir": "linux-64", + "timestamp": 1633671754550, + "version": "1.5.0" + }, + "py-mxnet-1.5.0-py38hf6b7f80_0.tar.bz2": { + "build": "py38hf6b7f80_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmxnet 1.5.0.*", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "26cc9268e1bf5944aae910978b2eb6fb", + "name": "py-mxnet", + "sha256": "580aa22c9003c0f4be245b8ed90ba1231b0175c94e2a473e6e7c4e4fd274da2f", + "size": 1340652, + "subdir": "linux-64", + "timestamp": 1633682563997, + "version": "1.5.0" + }, + "py-mxnet-1.5.0-py39hf6b7f80_0.tar.bz2": { + "build": "py39hf6b7f80_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmxnet 1.5.0.*", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.0,<=2.0.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "6b351939a6435be8dd3e11ef44a09c55", + "name": "py-mxnet", + "sha256": "5c5d16f3ca3a2fc7baae6c1404406cfc7b5d9347fe8083e68312a1f441b98988", + "size": 1291088, + "subdir": "linux-64", + "timestamp": 1633682554818, + "version": "1.5.0" + }, + "py-mxnet-1.5.1-py310h9bc9155_0.tar.bz2": { + "build": "py310h9bc9155_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libmxnet 1.5.1 openblas_h8848447_0", + "libstdcxx-ng >=11.2.0", + "numpy >1.16.0,<=2.0.0", + "python >=3.10,<3.11.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "26c8af386fbb8f1385249a4aa52793ae", + "name": "py-mxnet", + "sha256": "750105db1a537d83427973532920213d2a6abc6d8073a737134cf5dd2baae653", + "size": 1337981, + "subdir": "linux-64", + "timestamp": 1665586706822, + "version": "1.5.1" + }, + "py-mxnet-1.5.1-py311h9bc9155_0.tar.bz2": { + "build": "py311h9bc9155_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libmxnet 1.5.1 openblas_h8848447_0", + "libstdcxx-ng >=11.2.0", + "numpy >1.16.0,<=2.0.0", + "python >=3.11,<3.12.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "825391c14e0a050bc6ffb25b7ee69f0d", + "name": "py-mxnet", + "sha256": "8d75db185b9197c97c66983ed8001686299629da1ec36d6425ea5ea786c107b1", + "size": 1602858, + "subdir": "linux-64", + "timestamp": 1676859809739, + "version": "1.5.1" + }, + "py-mxnet-1.5.1-py37h9bc9155_0.tar.bz2": { + "build": "py37h9bc9155_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libmxnet 1.5.1 openblas_h8848447_0", + "libstdcxx-ng >=11.2.0", + "numpy >1.16.0,<=2.0.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "05a54e24417a34af34bfb3c985532712", + "name": "py-mxnet", + "sha256": "841bea24ba4cc2a618d08f0ddeae72b15517d8dad7939f5d7507317a40818230", + "size": 1359993, + "subdir": "linux-64", + "timestamp": 1665586765912, + "version": "1.5.1" + }, + "py-mxnet-1.5.1-py38h9bc9155_0.tar.bz2": { + "build": "py38h9bc9155_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libmxnet 1.5.1 openblas_h8848447_0", + "libstdcxx-ng >=11.2.0", + "numpy >1.16.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "6960cd75b94725a1dafbc30932a9aab5", + "name": "py-mxnet", + "sha256": "dbe1a6e7a17ede1d8c19db7ce7e51045453d4c40e18006d3d408a60cab1c55ca", + "size": 1341215, + "subdir": "linux-64", + "timestamp": 1665586736472, + "version": "1.5.1" + }, + "py-mxnet-1.5.1-py39h9bc9155_0.tar.bz2": { + "build": "py39h9bc9155_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libmxnet 1.5.1 openblas_h8848447_0", + "libstdcxx-ng >=11.2.0", + "numpy >1.16.0,<=2.0.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "745fb00e49cae2977dd210960ae18b12", + "name": "py-mxnet", + "sha256": "38dd2773e2a9f878311b29ac560a8c0fb81563b16acb50af355e86528bfb3e90", + "size": 1338176, + "subdir": "linux-64", + "timestamp": 1665586795485, + "version": "1.5.1" + }, + "py-mxnet-1.9.1-py310h04ad4eb_0.tar.bz2": { + "build": "py310h04ad4eb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libmxnet 1.9.1 openblas_h8848447_0", + "libstdcxx-ng >=11.2.0", + "numpy >1.16.0,<=2.0.0", + "python >=3.10,<3.11.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "7b46e306173c06e911d27615186a5a14", + "name": "py-mxnet", + "sha256": "24acc2e80706a497d28020530164e69ff5238563fcebb9b1839e8682a98c81fd", + "size": 1927948, + "subdir": "linux-64", + "timestamp": 1666597041573, + "version": "1.9.1" + }, + "py-mxnet-1.9.1-py37h4f77008_0.tar.bz2": { + "build": "py37h4f77008_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libmxnet 1.9.1 openblas_h8848447_0", + "libstdcxx-ng >=11.2.0", + "numpy >1.16.0,<=2.0.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "7f8ebda84be1a688aa4dd83595cceccb", + "name": "py-mxnet", + "sha256": "79ec1b427d7ccc1cf21e5d25b98d582e068177ae806847019473e11e39b09ccd", + "size": 1989253, + "subdir": "linux-64", + "timestamp": 1666596971096, + "version": "1.9.1" + }, + "py-mxnet-1.9.1-py38h4f77008_0.tar.bz2": { + "build": "py38h4f77008_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libmxnet 1.9.1 openblas_h8848447_0", + "libstdcxx-ng >=11.2.0", + "numpy >1.16.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "e58b7b618327cd9ad37c9bcf75e407b0", + "name": "py-mxnet", + "sha256": "1985aab88c455d9d58aab1bc70df84b57ba78f0070afd3508a2702ffc1539254", + "size": 1922958, + "subdir": "linux-64", + "timestamp": 1666597077129, + "version": "1.9.1" + }, + "py-mxnet-1.9.1-py39h4f77008_0.tar.bz2": { + "build": "py39h4f77008_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libmxnet 1.9.1 openblas_h8848447_0", + "libstdcxx-ng >=11.2.0", + "numpy >1.16.0,<=2.0.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "64c02b0d99145f52044662539b9a469c", + "name": "py-mxnet", + "sha256": "7bb0a80122a7d65c6ff7e02562bb6909e2706e45f2d9e7f7ead79d0d837ce4e6", + "size": 1918188, + "subdir": "linux-64", + "timestamp": 1666597006232, + "version": "1.9.1" + }, + "py-opencv-3.4.1-py27h0676e08_1.tar.bz2": { + "build": "py27h0676e08_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 h1a3b859_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8c03d7d5d7201cdc416bdb0d0e84925e", + "name": "py-opencv", + "sha256": "36c23c51f28940cdfd5fe8ed4f7622644f7306647e9ee063a9fc1f8147b0893d", + "size": 1235717, + "subdir": "linux-64", + "timestamp": 1527005759652, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py27h8fa1ad8_3.tar.bz2": { + "build": "py27h8fa1ad8_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 h8fa1ad8_3", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2fc9664eda03bbae7cffc89b34addb26", + "name": "py-opencv", + "sha256": "1d3664414ae4122a5ce92771f9496410a13ee37dbd90b7d375f1d284b73ff551", + "size": 1236587, + "subdir": "linux-64", + "timestamp": 1530790886299, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py27he6673a0_3.tar.bz2": { + "build": "py27he6673a0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 he6673a0_3", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a0f41a97fdbeb7a302f3e31541ed9c11", + "name": "py-opencv", + "sha256": "0423da7f3f6cc1a87ee52ea64fb611df35f0017ba53a5f35a8fd5672624bd1cb", + "size": 1236448, + "subdir": "linux-64", + "timestamp": 1530792554092, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py27hf78e8e8_1.tar.bz2": { + "build": "py27hf78e8e8_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 h62359dd_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "08bc5a7345f0f1c7530c2aaa2371875c", + "name": "py-opencv", + "sha256": "5932ec6d085f46fb2a9e303867a6619cff0892eb6ddd3af7591c80558127b65b", + "size": 1235726, + "subdir": "linux-64", + "timestamp": 1527006680556, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py35h0676e08_1.tar.bz2": { + "build": "py35h0676e08_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 h1a3b859_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d9ebb627ff89c637bf0d1fddf04e84ef", + "name": "py-opencv", + "sha256": "fc0a5df073bcebbdd3edf51b10bef94ceacf121c8f73fc5d144151a573976726", + "size": 1235403, + "subdir": "linux-64", + "timestamp": 1527005926299, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py35hf78e8e8_1.tar.bz2": { + "build": "py35hf78e8e8_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 h62359dd_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "aac3c098e2a8638360aea6568bbb5141", + "name": "py-opencv", + "sha256": "e8f9fd222dd9136872a1eec2d64c730b8e063b6037d197b6b152e69cb40a31ce", + "size": 1235380, + "subdir": "linux-64", + "timestamp": 1527006842927, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py36h0676e08_1.tar.bz2": { + "build": "py36h0676e08_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 h1a3b859_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3821c32c8ccc560ce1be0ec158a6aa58", + "name": "py-opencv", + "sha256": "df9dfdca217c85c073f8e2e538039cbd061b685d4809ab36ea48879f6a1aa54e", + "size": 1235488, + "subdir": "linux-64", + "timestamp": 1527005958807, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py36h8fa1ad8_3.tar.bz2": { + "build": "py36h8fa1ad8_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 h8fa1ad8_3", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "298c92cd8273d01fea16ab4a6e322995", + "name": "py-opencv", + "sha256": "e42605d8b3ae083bba624daf903b0ff843f3a44f321b67992642ae9b77b05e45", + "size": 1237279, + "subdir": "linux-64", + "timestamp": 1530791034625, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py36he6673a0_3.tar.bz2": { + "build": "py36he6673a0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 he6673a0_3", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6ca8433c6aede3760e7701ca32745a9c", + "name": "py-opencv", + "sha256": "3d3974599457a1126531b535fafcde47a2550513257d760e22e027ec41bc53f9", + "size": 1238146, + "subdir": "linux-64", + "timestamp": 1530792701758, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py36hf78e8e8_1.tar.bz2": { + "build": "py36hf78e8e8_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 h62359dd_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a4150bf9c5e85cea89f168eafbf397c9", + "name": "py-opencv", + "sha256": "e10fae5463f175cc04e9f7039bfafd829523994abbd593e0c4eb6228c6e0fc0a", + "size": 1235440, + "subdir": "linux-64", + "timestamp": 1527006875624, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py37h8fa1ad8_3.tar.bz2": { + "build": "py37h8fa1ad8_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 h8fa1ad8_3", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4150218866bcec884dda4b60887495a5", + "name": "py-opencv", + "sha256": "0309d5b4d7067a51c992546735a84d1bcc7db8d7b1091276fd9686982e21f533", + "size": 1237285, + "subdir": "linux-64", + "timestamp": 1530791065886, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py37he6673a0_3.tar.bz2": { + "build": "py37he6673a0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 he6673a0_3", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c822927dc4556f8749d43688ab1b1a81", + "name": "py-opencv", + "sha256": "b26f74293a25198401a49d850527d534c5addfa4061476b1d35e5217fa19f14c", + "size": 1238100, + "subdir": "linux-64", + "timestamp": 1530792734396, + "version": "3.4.1" + }, + "py-opencv-3.4.2-py27h765d7f9_1.tar.bz2": { + "build": "py27h765d7f9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libopencv 3.4.2 h765d7f9_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "610b2a044c426a80b89e88ee906faeac", + "name": "py-opencv", + "sha256": "f51467f0093e56d80e8916c0b8f8281fbe521d2183f7a811c94f12d8b1caf9ec", + "size": 1274240, + "subdir": "linux-64", + "timestamp": 1535561441982, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py27h8fa1ad8_0.tar.bz2": { + "build": "py27h8fa1ad8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.2 h8fa1ad8_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8c8606f092b51ff8edb61dcd227c67ca", + "name": "py-opencv", + "sha256": "35c198d7ae592c926478e5f2f369194405d01225bf552867cf8e8de99427afeb", + "size": 1266311, + "subdir": "linux-64", + "timestamp": 1533642253333, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py27hb342d67_1.tar.bz2": { + "build": "py27hb342d67_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libopencv 3.4.2 hb342d67_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ab713cd204b800dc62c3613c1ca43645", + "name": "py-opencv", + "sha256": "966562f3449746df9e834a1a590f4f78a39adf39e723a0628065d288453259c1", + "size": 1273506, + "subdir": "linux-64", + "timestamp": 1535561687028, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py27he6673a0_0.tar.bz2": { + "build": "py27he6673a0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.2 he6673a0_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a04cf9776a799d9be51add71c2373e27", + "name": "py-opencv", + "sha256": "956e630fb59458375384c686e5e3e2cd2e130f40be9d8c609ac26a6fe1532f72", + "size": 1265722, + "subdir": "linux-64", + "timestamp": 1533643809922, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py35h765d7f9_1.tar.bz2": { + "build": "py35h765d7f9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libopencv 3.4.2 h765d7f9_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0250bcea0899efd9ea986c4eea36d66e", + "name": "py-opencv", + "sha256": "192c7311440c9d4b1b1b31093c07ab44b30ed9ab7dc030fa153cbb6e62e2e272", + "size": 1273533, + "subdir": "linux-64", + "timestamp": 1535561687060, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py35h8fa1ad8_0.tar.bz2": { + "build": "py35h8fa1ad8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.2 h8fa1ad8_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7128a11b3b1abb06ac247f22aa8129cd", + "name": "py-opencv", + "sha256": "82500798f8bb8af35e32012b3f13c3e7608af0b14e6539f1755c4404e79b6c73", + "size": 1266555, + "subdir": "linux-64", + "timestamp": 1533642412096, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py35hb342d67_1.tar.bz2": { + "build": "py35hb342d67_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libopencv 3.4.2 hb342d67_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7848a1901bdd6d90c5465b951a0bcb35", + "name": "py-opencv", + "sha256": "5a97041fc7840180af7439b387e8aef61f55c0259e3245bbd0f34bf30c6ffc7e", + "size": 1273138, + "subdir": "linux-64", + "timestamp": 1535561590213, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py35he6673a0_0.tar.bz2": { + "build": "py35he6673a0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.2 he6673a0_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "87431c9a47ea62a867cd2af95d756363", + "name": "py-opencv", + "sha256": "1d4353c388a86d483a2f4666ab0ca7287a4dba88a5cfcd6929347d79dc742f05", + "size": 1266327, + "subdir": "linux-64", + "timestamp": 1533643968899, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py36h765d7f9_1.tar.bz2": { + "build": "py36h765d7f9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libopencv 3.4.2 h765d7f9_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e3c935759523684681f2ba43e98c2198", + "name": "py-opencv", + "sha256": "fb3cf930a3b1655075c6df2c7d7a349ac05c9c8124b97391af249f36f084f187", + "size": 1273802, + "subdir": "linux-64", + "timestamp": 1535561875879, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py36h8fa1ad8_0.tar.bz2": { + "build": "py36h8fa1ad8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.2 h8fa1ad8_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "84ccd4a969f1b5a730c349dd0088ada7", + "name": "py-opencv", + "sha256": "b18eabdf6ef44bcecb1ce16ded8fb8b0b95908be666121e16741d25edadd790f", + "size": 1266508, + "subdir": "linux-64", + "timestamp": 1533642731575, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py36hb342d67_1.tar.bz2": { + "build": "py36hb342d67_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libopencv 3.4.2 hb342d67_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b56bfb2f6e727be9f881c821c2ac53a4", + "name": "py-opencv", + "sha256": "ba7653b9ac9bdc256cad0c9683482ba3df097e5c36db29c9ef0bc3d47cf8dab0", + "size": 1273135, + "subdir": "linux-64", + "timestamp": 1535561875789, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py36he6673a0_0.tar.bz2": { + "build": "py36he6673a0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.2 he6673a0_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "65d33cd2260acaa301b1d7f61d3f0262", + "name": "py-opencv", + "sha256": "2358b128cbd3dda04e9aa7ede185f288738c2b96b2f8350b1102d243a6a5d5b4", + "size": 1266459, + "subdir": "linux-64", + "timestamp": 1533644286844, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py37h765d7f9_1.tar.bz2": { + "build": "py37h765d7f9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libopencv 3.4.2 h765d7f9_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "66426fd12d7e26e9cbd4bd46563b19e4", + "name": "py-opencv", + "sha256": "eb483867ecc6475c40f22ac38048a4489727ddfab73333996a3c371932f1ca44", + "size": 1273856, + "subdir": "linux-64", + "timestamp": 1535562094538, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py37h8fa1ad8_0.tar.bz2": { + "build": "py37h8fa1ad8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.2 h8fa1ad8_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "af05d6d75043f644c628e64913437b35", + "name": "py-opencv", + "sha256": "e7135127237b902dd46e3f8dae9383bd0159c72e0644526422efd76b994fb5dd", + "size": 1266602, + "subdir": "linux-64", + "timestamp": 1533642571120, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py37hb342d67_1.tar.bz2": { + "build": "py37hb342d67_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libopencv 3.4.2 hb342d67_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "829be55bba1c8e756c8cfc81aa780c1b", + "name": "py-opencv", + "sha256": "62c5197953ef717589c28e30b856daaa97869e72b2608c5a946bd5cd07aa5df6", + "size": 1273097, + "subdir": "linux-64", + "timestamp": 1535562103938, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py37he6673a0_0.tar.bz2": { + "build": "py37he6673a0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.2 he6673a0_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ada6809dea35614a0354c0fa3f7972ec", + "name": "py-opencv", + "sha256": "13a3a6b350e13d6f6fa41753f44323ab8769e0dabd997790ee9b186f7719f1a7", + "size": 1266459, + "subdir": "linux-64", + "timestamp": 1533644127838, + "version": "3.4.2" + }, + "py-opencv-4.5.4-h06a4308_2.tar.bz2": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [ + "opencv >=4.5.4,<5.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2f00381d45ccdd291d2665a3b2d80e68", + "name": "py-opencv", + "sha256": "9f93efabf45ad8ee6ccffc9ebc24415d7608f4b77d7f7a1683669f4213fc748a", + "size": 30405, + "subdir": "linux-64", + "timestamp": 1648833862634, + "version": "4.5.4" + }, + "py-opencv-4.5.4-h06a4308_3.tar.bz2": { + "build": "h06a4308_3", + "build_number": 3, + "depends": [ + "opencv 4.5.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "da6151f75c2fd5bf1348297eac11e066", + "name": "py-opencv", + "sha256": "b8ffa3d5dc13243904e63e25f4513c7da9f19c0ab1da7c997f64ffd84e0d15a2", + "size": 30701, + "subdir": "linux-64", + "timestamp": 1648873511303, + "version": "4.5.4" + }, + "py-opencv-4.5.5-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8f28ca1c300a51f27175efc2e2e2de37", + "name": "py-opencv", + "sha256": "864b1d8790ce90393ae0c1cd15157c9be96ab3c3d9f40f047721f2d5970a2e0a", + "size": 10316, + "subdir": "linux-64", + "timestamp": 1652956711521, + "version": "4.5.5" + }, + "py-opencv-4.5.5-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3f31782f600280238b68b8a26915cd85", + "name": "py-opencv", + "sha256": "97e128a4e1bcd2fbad55a4689c2a7b67597e579eac38ca0719c3f02ab04ee158", + "size": 10471, + "subdir": "linux-64", + "timestamp": 1655908341712, + "version": "4.5.5" + }, + "py-opencv-4.5.5-h06a4308_2.tar.bz2": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0c687f5b7de555b490b1a1bf43f3c498", + "name": "py-opencv", + "sha256": "a57e2daf83156610a5a55791a9d975c9deee3a03f169d4a889d74de028b9bb3b", + "size": 10523, + "subdir": "linux-64", + "timestamp": 1656000414609, + "version": "4.5.5" + }, + "py-opencv-4.5.5-h06a4308_3.tar.bz2": { + "build": "h06a4308_3", + "build_number": 3, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f167676638124ec5a1f6ae3d43277568", + "name": "py-opencv", + "sha256": "3e7fc4c9cc72f90aa7e8e76a0921c742d480f31e82fd06f1839d5b4e81c0bd97", + "size": 14200, + "subdir": "linux-64", + "timestamp": 1656607349016, + "version": "4.5.5" + }, + "py-opencv-4.5.5-h06a4308_4.tar.bz2": { + "build": "h06a4308_4", + "build_number": 4, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "663b12723c905a1631151283d3b0f9f2", + "name": "py-opencv", + "sha256": "714089fc1e135b78fad5fd30768dc17ee342e5f323773cb14fb6543f124db627", + "size": 14229, + "subdir": "linux-64", + "timestamp": 1659975133503, + "version": "4.5.5" + }, + "py-opencv-4.6.0-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "opencv 4.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "26ef80327f9faea18c4c84df69ef6ffe", + "name": "py-opencv", + "sha256": "f4c1529371892ec3290551c8291287268d5d49a1574ae6374c64ea9a4efef126", + "size": 12593, + "subdir": "linux-64", + "timestamp": 1663874042899, + "version": "4.6.0" + }, + "py-opencv-4.6.0-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [ + "opencv 4.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f6ae721eb57c78f28bf9c0646f0f540c", + "name": "py-opencv", + "sha256": "ae86cbe932690ed162c28036ba1d18ef22977ccc6c20be39d76df6309192680e", + "size": 12650, + "subdir": "linux-64", + "timestamp": 1664372699808, + "version": "4.6.0" + }, + "py-opencv-4.6.0-h06a4308_2.tar.bz2": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [ + "opencv 4.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7787383c1c42218aa05277fe718b9ea2", + "name": "py-opencv", + "sha256": "c6115b8adf2e297f8aba56efe34f498535ce4f120933f577b8ab7fd19c817ad9", + "size": 12610, + "subdir": "linux-64", + "timestamp": 1664550122536, + "version": "4.6.0" + }, + "py-opencv-4.6.0-h06a4308_3.tar.bz2": { + "build": "h06a4308_3", + "build_number": 3, + "depends": [ + "opencv 4.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f57e6456ba0c143c7f570fa8edcd5403", + "name": "py-opencv", + "sha256": "793f78d1a78489065bb1e6e1aa627eae4cd060f04d129422cca0dfab393f7c85", + "size": 12796, + "subdir": "linux-64", + "timestamp": 1676453528679, + "version": "4.6.0" + }, + "py-spy-0.3.11-hadfb35e_1.tar.bz2": { + "build": "hadfb35e_1", + "build_number": 1, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "libgcc-ng >=7.5.0", + "libunwind >=1.5.0,<2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "848c3212444201a52969cf1e31ae06f3", + "name": "py-spy", + "sha256": "329273a0a654802644fd45a3d2123573ec1b27062e7c4c9e80e0586a4a9c0a0e", + "size": 1655045, + "subdir": "linux-64", + "timestamp": 1640799872281, + "version": "0.3.11" + }, + "py-spy-0.3.14-h52d8a92_0.tar.bz2": { + "build": "h52d8a92_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "libgcc-ng >=11.2.0", + "libunwind >=1.5.0,<2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5586bd359b098136febc63f89e16756f", + "name": "py-spy", + "sha256": "20de15cd5d95b4a7f2765f5bd79be5b600871abebb572d224e5dec9d311853e4", + "size": 1648495, + "subdir": "linux-64", + "timestamp": 1677738359658, + "version": "0.3.14" + }, + "py-xgboost-0.7-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxgboost 0.7 hf484d3e_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "913fe981ccc9d9c370405ef06d101019", + "name": "py-xgboost", + "sha256": "f92da651ab5651e27cae43ca388dfcbc13b26f71fedb0d8f8443547382c9573e", + "size": 1507034, + "subdir": "linux-64", + "timestamp": 1521481044382, + "version": "0.7" + }, + "py-xgboost-0.7-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxgboost 0.7 hf484d3e_0", + "numpy", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy" + ], + "md5": "f24b8a2e9fc70c7b2abbda57cec186b8", + "name": "py-xgboost", + "sha256": "b989f3b03e0cbc0915867e0fb88f8aeba8d00e89b3ab50109f81f3ae995d272d", + "size": 1507157, + "subdir": "linux-64", + "timestamp": 1521481006463, + "version": "0.7" + }, + "py-xgboost-0.7-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxgboost 0.7 hf484d3e_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "dd5802fdd7a040e52aec0f9c2d85f79b", + "name": "py-xgboost", + "sha256": "24cee726c161d3fadf8c8a21a3592bcefade689fdff953beca4bb0c6eb15fa39", + "size": 1507864, + "subdir": "linux-64", + "timestamp": 1521481025571, + "version": "0.7" + }, + "py-xgboost-0.71-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxgboost 0.71 hf484d3e_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "11e3bc8490ee1d1259adbdb549a9bdb2", + "name": "py-xgboost", + "sha256": "327012ff6c141dff543c6446af9d7b094831ec2b2cd239c7a944367b68fd9922", + "size": 1595994, + "subdir": "linux-64", + "timestamp": 1525821737512, + "version": "0.71" + }, + "py-xgboost-0.71-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxgboost 0.71 hf484d3e_0", + "numpy", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy" + ], + "md5": "ce8bc6953c449a6011d07ac3957dc5c3", + "name": "py-xgboost", + "sha256": "128dc8acf7bccebbd0cb54a4b729ec4274a0cff2e5d537977c5ea093e7c988cf", + "size": 1593854, + "subdir": "linux-64", + "timestamp": 1525821761246, + "version": "0.71" + }, + "py-xgboost-0.71-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxgboost 0.71 hf484d3e_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "888af2016fe3aa35c4d4e8ae55db364a", + "name": "py-xgboost", + "sha256": "a7f7e7077fab211c95609d89f19a646b231d1194b1267f113079f02bfd7226a1", + "size": 1593885, + "subdir": "linux-64", + "timestamp": 1525821783911, + "version": "0.71" + }, + "py-xgboost-0.72-py27h83be7fe_0.tar.bz2": { + "build": "py27h83be7fe_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 8.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.72 h83be7fe_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "48ab51a35f0758a39f9726c55c0cdd02", + "name": "py-xgboost", + "sha256": "6660efe9490102ba6287564b44af320249ce8f3bb5c30044e40d085b8930f30f", + "size": 4772037, + "subdir": "linux-64", + "timestamp": 1530222959531, + "version": "0.72" + }, + "py-xgboost-0.72-py27h87a4715_0.tar.bz2": { + "build": "py27h87a4715_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.72 h87a4715_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "02d17006da793519cf7d20f270bc6392", + "name": "py-xgboost", + "sha256": "e3c667f565912138609e841df897191fb22e36891370f22e38ab7a3c66e407b7", + "size": 5184570, + "subdir": "linux-64", + "timestamp": 1530223654550, + "version": "0.72" + }, + "py-xgboost-0.72-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxgboost 0.72 hf484d3e_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "b0c49990c090b28079e0e07d53914569", + "name": "py-xgboost", + "sha256": "69b3118d7acd05cf979fac239c1ac6b6cea3339507fb9e2d85368afa998aa617", + "size": 1698322, + "subdir": "linux-64", + "timestamp": 1530218280279, + "version": "0.72" + }, + "py-xgboost-0.72-py35h83be7fe_0.tar.bz2": { + "build": "py35h83be7fe_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 8.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.72 h83be7fe_0", + "numpy", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy" + ], + "md5": "e0a069d70e0170b2bea2ef20210dbfbe", + "name": "py-xgboost", + "sha256": "5fe06150626e99ead6d3a585bb35e1e5d869dec9f99ff9d963693931e6cafd72", + "size": 4770036, + "subdir": "linux-64", + "timestamp": 1530223003800, + "version": "0.72" + }, + "py-xgboost-0.72-py35h87a4715_0.tar.bz2": { + "build": "py35h87a4715_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.72 h87a4715_0", + "numpy", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy" + ], + "md5": "4bb4a15ced996b56119815e7202bb7b4", + "name": "py-xgboost", + "sha256": "3726496f0e3e2d2fbd6c5f527b8dffe15dc4ab96d33a1b62e98acc01efe6b525", + "size": 5175689, + "subdir": "linux-64", + "timestamp": 1530223633126, + "version": "0.72" + }, + "py-xgboost-0.72-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxgboost 0.72 hf484d3e_0", + "numpy", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy" + ], + "md5": "0bf9292ddc21668636b39e17498c0884", + "name": "py-xgboost", + "sha256": "9f691545cd3b771212c766bca0bb2c095fc910a26b1bbe44e9597db755aa252f", + "size": 1698862, + "subdir": "linux-64", + "timestamp": 1530218305177, + "version": "0.72" + }, + "py-xgboost-0.72-py36h83be7fe_0.tar.bz2": { + "build": "py36h83be7fe_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 8.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.72 h83be7fe_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "9f247ca9aae05da67198db964c00f150", + "name": "py-xgboost", + "sha256": "f75bfa21019f64c42340398572d932724ed97d4f61d6c52a8400f04d11382cb8", + "size": 4768351, + "subdir": "linux-64", + "timestamp": 1530222982082, + "version": "0.72" + }, + "py-xgboost-0.72-py36h87a4715_0.tar.bz2": { + "build": "py36h87a4715_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.72 h87a4715_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "5c7fd38fe056d3f19b8d6cd63c403c7a", + "name": "py-xgboost", + "sha256": "8f5397f901474d73ff3422b9b68432b1d90554f7b35f2f36d55be10586aef41f", + "size": 5173230, + "subdir": "linux-64", + "timestamp": 1530223676433, + "version": "0.72" + }, + "py-xgboost-0.72-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxgboost 0.72 hf484d3e_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "5fffd4691e4592af37e13ab068e79b0b", + "name": "py-xgboost", + "sha256": "41ac1988ca7bcccea16e217989a7f4dae52c58fc18b79fc5fcc5d3fdb427a08b", + "size": 1699490, + "subdir": "linux-64", + "timestamp": 1530218327979, + "version": "0.72" + }, + "py-xgboost-0.80-py27h51060c3_0.tar.bz2": { + "build": "py27h51060c3_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 8.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.80 h51060c3_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "e07310a209e9c6077297b747896f3ae2", + "name": "py-xgboost", + "sha256": "900ee98692fe50aad970b8ad70907be053ba1c3efe0334ee3354c762f77332ec", + "size": 6942765, + "subdir": "linux-64", + "timestamp": 1541468890399, + "version": "0.80" + }, + "py-xgboost-0.80-py27h6cbba54_0.tar.bz2": { + "build": "py27h6cbba54_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 9.2.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.80 h6cbba54_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "ec10be4bb1348d99f00c3983232b2f2c", + "name": "py-xgboost", + "sha256": "e68d2e453eb3fd416668ca0ad7b67a2f39e4b63a9406745b05c3ac4540f9be1a", + "size": 7666375, + "subdir": "linux-64", + "timestamp": 1541450174629, + "version": "0.80" + }, + "py-xgboost-0.80-py27h6edc907_0.tar.bz2": { + "build": "py27h6edc907_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.80 h6edc907_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "caba376243e79b858a62f8dff5ebf4f9", + "name": "py-xgboost", + "sha256": "6ffc314fd8bc3fa20367f85cfcd7e94697c2cbd6b01f248acf5df0f33bf15c28", + "size": 7552600, + "subdir": "linux-64", + "timestamp": 1541451157424, + "version": "0.80" + }, + "py-xgboost-0.80-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.80 he6710b0_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "b4d796660fb3ff50abe355bef49cb2d3", + "name": "py-xgboost", + "sha256": "56d159feb2143335dbc6ebeda41603e7f00880ead7ae74fcae45dac18c28be22", + "size": 1736964, + "subdir": "linux-64", + "timestamp": 1540835374604, + "version": "0.80" + }, + "py-xgboost-0.80-py36h51060c3_0.tar.bz2": { + "build": "py36h51060c3_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 8.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.80 h51060c3_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "3a228c4f60f4a551622b980b4796c73a", + "name": "py-xgboost", + "sha256": "5fef1445601ca60684f805d9976866435692ad7e1443a076c09ace41b9d20386", + "size": 6938129, + "subdir": "linux-64", + "timestamp": 1541468916503, + "version": "0.80" + }, + "py-xgboost-0.80-py36h6cbba54_0.tar.bz2": { + "build": "py36h6cbba54_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 9.2.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.80 h6cbba54_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "9c67ae08e8e340e14441946ffc50938b", + "name": "py-xgboost", + "sha256": "7f8fa0d78e33766b0feee0110ad5d0f51e32a5d96d3b329bb9da6fb021feb1d4", + "size": 7703943, + "subdir": "linux-64", + "timestamp": 1541450122239, + "version": "0.80" + }, + "py-xgboost-0.80-py36h6edc907_0.tar.bz2": { + "build": "py36h6edc907_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.80 h6edc907_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "654fa44214df43d46997202421bf8806", + "name": "py-xgboost", + "sha256": "603995b205e418aeba3a43765f19ef402e864e605a53c16ddf50a1af17ffd6f9", + "size": 7551772, + "subdir": "linux-64", + "timestamp": 1541451100572, + "version": "0.80" + }, + "py-xgboost-0.80-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.80 he6710b0_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "bf640d8091a887e62464da478b3cb60c", + "name": "py-xgboost", + "sha256": "8e5938a06bd0e9ca7b2c5589408cddd0986631ac3b1a755f5a65fd784fd31e68", + "size": 1741944, + "subdir": "linux-64", + "timestamp": 1540835348915, + "version": "0.80" + }, + "py-xgboost-0.80-py37h51060c3_0.tar.bz2": { + "build": "py37h51060c3_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 8.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.80 h51060c3_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "a5f46bb3529281fd5ffb749bf4ae5219", + "name": "py-xgboost", + "sha256": "1b59d459fcc8f4f38e4fa231033c30abf32a23c4bc6fb5a28e93b79d0d4b58ef", + "size": 6938312, + "subdir": "linux-64", + "timestamp": 1541468864376, + "version": "0.80" + }, + "py-xgboost-0.80-py37h6cbba54_0.tar.bz2": { + "build": "py37h6cbba54_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 9.2.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.80 h6cbba54_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "a7b8e8c9b9dc028accbd38bbd70c8d50", + "name": "py-xgboost", + "sha256": "4939b5c14c91d8e621ae7ce3e2e8fffb32ac56d47156abd5b6d8dfec27a98095", + "size": 7696591, + "subdir": "linux-64", + "timestamp": 1541450148152, + "version": "0.80" + }, + "py-xgboost-0.80-py37h6edc907_0.tar.bz2": { + "build": "py37h6edc907_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.80 h6edc907_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "e569b5b306c187ae7bd2940b548c4932", + "name": "py-xgboost", + "sha256": "5d92972c96f36b8e2c523ac165f1a2d17b89bc88c7a7c44fe89dc8b5df6baadc", + "size": 7551176, + "subdir": "linux-64", + "timestamp": 1541451129429, + "version": "0.80" + }, + "py-xgboost-0.80-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.80 he6710b0_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "84181803a0279d630dddbc9fd2fe2893", + "name": "py-xgboost", + "sha256": "e10631172b8fc41f67aa2f6243e27bdcc9a30dad86094c417652f9fcbd277232", + "size": 1737689, + "subdir": "linux-64", + "timestamp": 1540835400111, + "version": "0.80" + }, + "py-xgboost-0.90-py27h4d71fd4_0.tar.bz2": { + "build": "py27h4d71fd4_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 h4d71fd4_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "45cd06d7e492c089f7054a5a2c043360", + "name": "py-xgboost", + "sha256": "c81073ef261a04d387f23529ea97b67d2a893f91f268ab823370781dc5ea3575", + "size": 15202162, + "subdir": "linux-64", + "timestamp": 1560802346388, + "version": "0.90" + }, + "py-xgboost-0.90-py27h688424c_0.tar.bz2": { + "build": "py27h688424c_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 h688424c_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "5ed5f119ccee0d5c70cb8720485ad157", + "name": "py-xgboost", + "sha256": "a3bc4c129aa80239cbe15f883650b0bbf2359bcd6f84e75f59699bd9c18d6313", + "size": 16846005, + "subdir": "linux-64", + "timestamp": 1560801163198, + "version": "0.90" + }, + "py-xgboost-0.90-py27h6edc907_0.tar.bz2": { + "build": "py27h6edc907_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit >=9.0,<9.1.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.90 h6edc907_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "e4daecda5ccbc7c95f039799d4163fa0", + "name": "py-xgboost", + "sha256": "1a89a388bf851ceaf71ebb39b1b1bbc32d6c37e00371486b6ddea47c1545af5b", + "size": 11584445, + "subdir": "linux-64", + "timestamp": 1560804953735, + "version": "0.90" + }, + "py-xgboost-0.90-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 he6710b0_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "1d4987a28b62afd12f20c19ba91f2b9b", + "name": "py-xgboost", + "sha256": "946492217ebb94d290efc6f518e34f1cd7645da8cf871661a382e316c94cf8c8", + "size": 1875030, + "subdir": "linux-64", + "timestamp": 1559931238194, + "version": "0.90" + }, + "py-xgboost-0.90-py310h295c915_1.tar.bz2": { + "build": "py310h295c915_1", + "build_number": 1, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libxgboost 0.90 h295c915_1", + "numpy", + "python >=3.10,<3.11.0a0", + "scikit-learn", + "scipy" + ], + "md5": "d0f5da9f9c6192a352fdddac37bdd366", + "name": "py-xgboost", + "sha256": "00875305c8ec7ba481c8d3dced257127aad9437f71f239a7f5e16cf1533065e4", + "size": 80020, + "subdir": "linux-64", + "timestamp": 1642675488455, + "version": "0.90" + }, + "py-xgboost-0.90-py36h4d71fd4_0.tar.bz2": { + "build": "py36h4d71fd4_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 h4d71fd4_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "fa2b0240166235c64038ecce80f740a2", + "name": "py-xgboost", + "sha256": "e07dbf083f74a9e60d2aed12219a7015df0a1090b39829cca25fef4cb2e38534", + "size": 15211199, + "subdir": "linux-64", + "timestamp": 1560802305503, + "version": "0.90" + }, + "py-xgboost-0.90-py36h688424c_0.tar.bz2": { + "build": "py36h688424c_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 h688424c_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "4453222f2811164c9cac7e5966bb8ef7", + "name": "py-xgboost", + "sha256": "83ec01e7a8744a6b5799aef178bd5c2cba5ee313e51c920cb78351bfe3a6a0eb", + "size": 16869963, + "subdir": "linux-64", + "timestamp": 1560801119508, + "version": "0.90" + }, + "py-xgboost-0.90-py36h6edc907_0.tar.bz2": { + "build": "py36h6edc907_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit >=9.0,<9.1.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.90 h6edc907_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "9aaf3294544ffb544bef0d4c7ea418f2", + "name": "py-xgboost", + "sha256": "274b128284c9f4d8faf150f2db1e344c3d3ba7f1b4ce0c8dcc1893fabec7a655", + "size": 11628678, + "subdir": "linux-64", + "timestamp": 1560804882247, + "version": "0.90" + }, + "py-xgboost-0.90-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 he6710b0_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "7f38514ef62a45d8cb0bd25fe5e5843c", + "name": "py-xgboost", + "sha256": "d08ea5af04103cd89c0c806ad70fa10ddfe2e3c357d861eebddcb28a42a3800f", + "size": 1878827, + "subdir": "linux-64", + "timestamp": 1559931214505, + "version": "0.90" + }, + "py-xgboost-0.90-py36he6710b0_1.tar.bz2": { + "build": "py36he6710b0_1", + "build_number": 1, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 he6710b0_1", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "fc123007486a052a4295a433f9cbdecf", + "name": "py-xgboost", + "sha256": "2ea194f3add9744f55f6ff24b8ef7b456924c549fae6ef14a302eff54d386a8e", + "size": 78515, + "subdir": "linux-64", + "timestamp": 1572481322489, + "version": "0.90" + }, + "py-xgboost-0.90-py36hf484d3e_1.tar.bz2": { + "build": "py36hf484d3e_1", + "build_number": 1, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 0.90 hf484d3e_1", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "3cf740e4020e29a0a46d1cf72b9e6fc7", + "name": "py-xgboost", + "sha256": "04a946909296d2fc5f02c0f1a87b237276bd2dab16db7a4f8ab58fc0caa2438c", + "size": 75511, + "subdir": "linux-64", + "timestamp": 1572476427471, + "version": "0.90" + }, + "py-xgboost-0.90-py37h4d71fd4_0.tar.bz2": { + "build": "py37h4d71fd4_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 h4d71fd4_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "18c47f8860a43bcd1d250c2e92975431", + "name": "py-xgboost", + "sha256": "0b3fea38e67c4ea39295e31abc5f90ae6da6389dfa257b6321429785b3b3fe1c", + "size": 15179665, + "subdir": "linux-64", + "timestamp": 1560802389367, + "version": "0.90" + }, + "py-xgboost-0.90-py37h688424c_0.tar.bz2": { + "build": "py37h688424c_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 h688424c_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "33e22f122bed23f9c880a09bfe770975", + "name": "py-xgboost", + "sha256": "29cd5d49c70b1ed53f61cf09f0c13e197cecc3824ee521a885091ffe08ff2926", + "size": 16869018, + "subdir": "linux-64", + "timestamp": 1560801212287, + "version": "0.90" + }, + "py-xgboost-0.90-py37h6edc907_0.tar.bz2": { + "build": "py37h6edc907_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit >=9.0,<9.1.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.90 h6edc907_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "b6eca53ce1b6db00654378857f960cbb", + "name": "py-xgboost", + "sha256": "3c673c1b6be487741dbf0860307c82515016c5533ae9a437c7100a98df76a0bb", + "size": 11625446, + "subdir": "linux-64", + "timestamp": 1560804918838, + "version": "0.90" + }, + "py-xgboost-0.90-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 he6710b0_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "43aac54dfb4f369c125add1c3264369a", + "name": "py-xgboost", + "sha256": "3d986b8c2a3cb3c8d63aed194a8988d25072314d60274a2fdfd505d89703dcff", + "size": 1877033, + "subdir": "linux-64", + "timestamp": 1559931263195, + "version": "0.90" + }, + "py-xgboost-0.90-py37he6710b0_1.tar.bz2": { + "build": "py37he6710b0_1", + "build_number": 1, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 he6710b0_1", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "347f350853c02e7ee5cee28a1d484a79", + "name": "py-xgboost", + "sha256": "aaf9fe0f9b62986a935b16b149f3b5286920f1d02b252165225c5c90ffc0b052", + "size": 78571, + "subdir": "linux-64", + "timestamp": 1572481336959, + "version": "0.90" + }, + "py-xgboost-0.90-py37hf484d3e_1.tar.bz2": { + "build": "py37hf484d3e_1", + "build_number": 1, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 0.90 hf484d3e_1", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "d4ce6c69c44d613123f8d1d7cca33108", + "name": "py-xgboost", + "sha256": "be521b6ebff9c410e28d87358dd4b195928b85654a246a6ee14cd1b0a5506d6b", + "size": 75569, + "subdir": "linux-64", + "timestamp": 1572476594188, + "version": "0.90" + }, + "py-xgboost-1.3.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.3.3 h2531618_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "md5": "c2c9e7700859b8db23bc34de58f49fa6", + "name": "py-xgboost", + "sha256": "6c754b4e7f4dc7cc0e0d4a5db16def85cce06f0d4ff39ac3263bfbd3abb1fb06", + "size": 139049, + "subdir": "linux-64", + "timestamp": 1619724757433, + "version": "1.3.3" + }, + "py-xgboost-1.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.3.3 h2531618_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "md5": "790d901ffa55a3df7e5b3a8e936eb58d", + "name": "py-xgboost", + "sha256": "b63882c44bc5a5e5058d3e9b71938f37377841b9abf513050a85d8a571bbc54f", + "size": 139196, + "subdir": "linux-64", + "timestamp": 1619724744921, + "version": "1.3.3" + }, + "py-xgboost-1.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.3.3 h2531618_0", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "md5": "814ea8980e3bf556eae12748d47cf353", + "name": "py-xgboost", + "sha256": "4caf4f188d12d0daa8a4f4385c788ead610835ec3838b3a1c9063196034bc6ad", + "size": 139706, + "subdir": "linux-64", + "timestamp": 1619724770153, + "version": "1.3.3" + }, + "py-xgboost-1.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.3.3 h2531618_0", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "md5": "7f3bdf341222e3f48b14a555af0a24ba", + "name": "py-xgboost", + "sha256": "3cf9f3a02df314811469ea6a85cf77abf3a1320b5da27ebdc465ee1e17a15086", + "size": 139795, + "subdir": "linux-64", + "timestamp": 1619724732387, + "version": "1.3.3" + }, + "py-xgboost-1.5.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.0 h295c915_1", + "numpy", + "python >=3.10,<3.11.0a0", + "scikit-learn", + "scipy", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "c93e3fad4ea2ccb6606a6b749ad60608", + "name": "py-xgboost", + "sha256": "6f9df953014c841747f71cb969cc016045bd3dc32544f8756dc12d1aeeb8d074", + "size": 158518, + "subdir": "linux-64", + "timestamp": 1640814318695, + "version": "1.5.0" + }, + "py-xgboost-1.5.0-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.0 h6a678d5_2", + "numpy", + "python >=3.10,<3.11.0a0", + "scikit-learn", + "scipy", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "c29f786aba25ad8e4139d180967b4148", + "name": "py-xgboost", + "sha256": "fc39686508742da1d9ee99fbe25729ababf960f1a8cc2ec6cd65f8a3ef0c90e2", + "size": 159094, + "subdir": "linux-64", + "timestamp": 1659549314254, + "version": "1.5.0" + }, + "py-xgboost-1.5.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.0 h295c915_1", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "19bfe06f7cd3311e4f352177b8cb7a8a", + "name": "py-xgboost", + "sha256": "525ae87591836d96e350541ee8ca99a77e94d7f8af88aefec24883d45183ee8e", + "size": 166463, + "subdir": "linux-64", + "timestamp": 1638290192696, + "version": "1.5.0" + }, + "py-xgboost-1.5.0-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.0 h6a678d5_2", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "8dfdb927c312bec494fbcdf4f17d1f4b", + "name": "py-xgboost", + "sha256": "f18e55e3d7b7f2d7bf40d00ad067e00f8f98071842ae258dd38bf4b0f0e94493", + "size": 155897, + "subdir": "linux-64", + "timestamp": 1659549326958, + "version": "1.5.0" + }, + "py-xgboost-1.5.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.0 h295c915_1", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "fc25448c56e9726c012684f55f1d8932", + "name": "py-xgboost", + "sha256": "641362b00965985770cfa45afdb2aefbefe4d73a79302430c3759ec755c2db22", + "size": 167620, + "subdir": "linux-64", + "timestamp": 1638290173733, + "version": "1.5.0" + }, + "py-xgboost-1.5.0-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.0 h6a678d5_2", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "68baa5a81473a0c2d1b76898d7193ae9", + "name": "py-xgboost", + "sha256": "bc1b344b1a1604d4feb0627d1c0bcebadbe91c3a84e378481e80018797701309", + "size": 156869, + "subdir": "linux-64", + "timestamp": 1659549287829, + "version": "1.5.0" + }, + "py-xgboost-1.5.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.0 h295c915_1", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn", + "scipy", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "771a4258629f21587a068bd9fa9ad72a", + "name": "py-xgboost", + "sha256": "46d1c41d1b79497162b3dae4fc83db188db8e9dcc4f9884c7c6fe4718f89070f", + "size": 167375, + "subdir": "linux-64", + "timestamp": 1638290183183, + "version": "1.5.0" + }, + "py-xgboost-1.5.0-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.0 h6a678d5_2", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn", + "scipy", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "970640466a67b60e83e80bee24978c54", + "name": "py-xgboost", + "sha256": "b6e6d59f173d148c370b0c1bbb5ba18e7116ed42a8d456f3735b631b831a6c39", + "size": 156767, + "subdir": "linux-64", + "timestamp": 1659549301055, + "version": "1.5.0" + }, + "py-xgboost-1.5.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.1 h6a678d5_0", + "numpy", + "python >=3.10,<3.11.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "967be9281b67c169435c64a3477583b6", + "name": "py-xgboost", + "sha256": "d4f56445d2d3d11ce8bfc607a0f9a1046425fca4b3d94e214c378eb9a6f792c7", + "size": 159049, + "subdir": "linux-64", + "timestamp": 1675119992057, + "version": "1.5.1" + }, + "py-xgboost-1.5.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.1 h6a678d5_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5dcbfe2baaea76c2b887c26ca1b73b9c", + "name": "py-xgboost", + "sha256": "9e4fe007c2f8bbbb3fb75306a58e3cc87eb3ac3f0ea86ac0ac4306255a2ea72d", + "size": 156143, + "subdir": "linux-64", + "timestamp": 1675119981595, + "version": "1.5.1" + }, + "py-xgboost-1.5.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.1 h6a678d5_0", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6ccbf6349283eae8aac3fbb81eddbb2a", + "name": "py-xgboost", + "sha256": "1346654d36906c4c06c71b783dea9fb7e151774c33eeac7a19265a2659701e25", + "size": 156777, + "subdir": "linux-64", + "timestamp": 1675119960677, + "version": "1.5.1" + }, + "py-xgboost-1.5.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.1 h6a678d5_0", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3ecfb9ee8942fec0b4bacc9b602f9cf0", + "name": "py-xgboost", + "sha256": "0b52b1052c7ef1a130e9a770eb26fdc5f84c7a8f538171517790ceb1eb47f14c", + "size": 157062, + "subdir": "linux-64", + "timestamp": 1675119971238, + "version": "1.5.1" + }, + "py-xgboost-1.7.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.7.3 h6a678d5_0", + "numpy", + "python >=3.10,<3.11.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c6c72d61ed896239b9efd6c1531cd8d0", + "name": "py-xgboost", + "sha256": "75b3ed13cc6d12c82ab48105e9d4c858ebed4486fe0453d7b641d40dab37bae3", + "size": 203583, + "subdir": "linux-64", + "timestamp": 1675458048077, + "version": "1.7.3" + }, + "py-xgboost-1.7.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.7.3 h6a678d5_0", + "numpy", + "python >=3.11,<3.12.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c7db26d8c0abbf76c100d2f908961d8d", + "name": "py-xgboost", + "sha256": "2a233f4f41b78b55ea76245229d69182968651c34e0832ce4adfbe396ffe8c21", + "size": 286661, + "subdir": "linux-64", + "timestamp": 1676922101332, + "version": "1.7.3" + }, + "py-xgboost-1.7.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.7.3 h6a678d5_0", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "21d1d5f9fa0fd558b0cd685ae2eb4daf", + "name": "py-xgboost", + "sha256": "1ebff5bb0fe07fdebe9424b82a57c48dac024b9ecb496a73c9d4e4e6197dc01b", + "size": 200389, + "subdir": "linux-64", + "timestamp": 1675458768612, + "version": "1.7.3" + }, + "py-xgboost-1.7.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.7.3 h6a678d5_0", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "10dd7e81ee2824d214a9309175a4bf18", + "name": "py-xgboost", + "sha256": "6e600797602f17993b89ff856f26fdee7132a413b9cfb2b1a52265ab8576d100", + "size": 200083, + "subdir": "linux-64", + "timestamp": 1675458551510, + "version": "1.7.3" + }, + "py-xgboost-cpu-0.72-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.72 py27hf484d3e_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "45656a2d6ce00a68b4a24e11cfe1f329", + "name": "py-xgboost-cpu", + "sha256": "1810c57f3e53f3eaddc257212049d803a345fae03e1067f72f435c25ba89cbbd", + "size": 8962, + "subdir": "linux-64", + "timestamp": 1530218540635, + "version": "0.72" + }, + "py-xgboost-cpu-0.72-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.72 py35hf484d3e_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "e92efcaba3f3617f87daa029a05c6272", + "name": "py-xgboost-cpu", + "sha256": "fcfbc6aab377d95fd10644df5155a011288926bdd6896ac74395835a8401b170", + "size": 8957, + "subdir": "linux-64", + "timestamp": 1530218549298, + "version": "0.72" + }, + "py-xgboost-cpu-0.72-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.72 py36hf484d3e_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "b103119b34c459da42239aca6cc4182b", + "name": "py-xgboost-cpu", + "sha256": "b6b67d684c48e5bd20f1f5d016e557a44cab6ac07b9206b904d7377ff7afc1ec", + "size": 8949, + "subdir": "linux-64", + "timestamp": 1530218558358, + "version": "0.72" + }, + "py-xgboost-cpu-0.80-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py27he6710b0_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "487487c3e758248efb25ca881d2ec971", + "name": "py-xgboost-cpu", + "sha256": "054100aa35658f569a2c9ce1bf62391f380bb7dcb4c6a83ec5d462bbfcacbe03", + "size": 11115, + "subdir": "linux-64", + "timestamp": 1540835620936, + "version": "0.80" + }, + "py-xgboost-cpu-0.80-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py36he6710b0_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "86409db2670b098ff2d4f98ade2041ea", + "name": "py-xgboost-cpu", + "sha256": "9ef49e75d0ab9f89de84f00eb8b3b7bec829b6038f5c2c1aa813b530a2027bf3", + "size": 11121, + "subdir": "linux-64", + "timestamp": 1540835608437, + "version": "0.80" + }, + "py-xgboost-cpu-0.80-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py37he6710b0_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "a4bbf4064f3ef111e53e631df1493c91", + "name": "py-xgboost-cpu", + "sha256": "66d45dfff6367135bc33fd7f90bb4f2f692d05a7f9147bbda9fe4c3b28b654f1", + "size": 11108, + "subdir": "linux-64", + "timestamp": 1540835634197, + "version": "0.80" + }, + "py-xgboost-cpu-0.90-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py27he6710b0_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "596dadbf6f121ad4b90aafaaeaa159ac", + "name": "py-xgboost-cpu", + "sha256": "60837afcf6d5287ee5d18ddea82d4451c211e4f792a9b934fbb93002cb3bc55b", + "size": 11390, + "subdir": "linux-64", + "timestamp": 1559931474125, + "version": "0.90" + }, + "py-xgboost-cpu-0.90-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "py-xgboost 0.90 py310h295c915_1", + "python >=3.10,<3.11.0a0" + ], + "md5": "e4727d1f436152461cfdcd7e4cffc2ec", + "name": "py-xgboost-cpu", + "sha256": "284b5fbd5c848e565ccbc527603dd32ee3a4a5adb74516ff6d40053f43d139b6", + "size": 11775, + "subdir": "linux-64", + "timestamp": 1642675566289, + "version": "0.90" + }, + "py-xgboost-cpu-0.90-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py36he6710b0_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "b838fb51ac7e606d25ec59be5fb1f6a5", + "name": "py-xgboost-cpu", + "sha256": "a6dbcec28ddf33eb098eb5602e6abc4ee8f8c03575ec35aa20018eb2d1159564", + "size": 11388, + "subdir": "linux-64", + "timestamp": 1559931467012, + "version": "0.90" + }, + "py-xgboost-cpu-0.90-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "py-xgboost 0.90 py36he6710b0_1", + "python >=3.6,<3.7.0a0" + ], + "md5": "e9d4d140f63a874b5d28db8ec154fe3c", + "name": "py-xgboost-cpu", + "sha256": "7029dfa7a82f6b12409fa778255b8c8d94aba149b44e68fadba1d844f83ea7eb", + "size": 11629, + "subdir": "linux-64", + "timestamp": 1572481791836, + "version": "0.90" + }, + "py-xgboost-cpu-0.90-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py37he6710b0_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "2ab416da6393315539f3d0d0d333d913", + "name": "py-xgboost-cpu", + "sha256": "30b7c41ab7b268a71b7d66e4757c5f2b8e257ae1485be3f7a7a94e9440d27162", + "size": 11389, + "subdir": "linux-64", + "timestamp": 1559931481691, + "version": "0.90" + }, + "py-xgboost-cpu-0.90-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "py-xgboost 0.90 py37he6710b0_1", + "python >=3.7,<3.8.0a0" + ], + "md5": "dbfcfa0c45ff49d7abf8cc3e092a86b6", + "name": "py-xgboost-cpu", + "sha256": "122d1cacf08deab9a7a7fdf8011928792987ec6dbeede41a463dd5edeb50dc15", + "size": 11617, + "subdir": "linux-64", + "timestamp": 1572481799295, + "version": "0.90" + }, + "py-xgboost-cpu-1.3.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.3.3 py36h06a4308_0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "7114989ae3d1ae2e908e7c8c88e0bfae", + "name": "py-xgboost-cpu", + "sha256": "dcce88617a1955ca81f8462aaaf87de5c37ce846aac4c92c94ec05969f841135", + "size": 22874, + "subdir": "linux-64", + "timestamp": 1619725002020, + "version": "1.3.3" + }, + "py-xgboost-cpu-1.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.3.3 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "0018c247d2d5b5f4b804b116ae6b2487", + "name": "py-xgboost-cpu", + "sha256": "7f4116e99778df20f4838245c79b060badd65c925bf6bfd316b5535d4cfe73e0", + "size": 22850, + "subdir": "linux-64", + "timestamp": 1619724982811, + "version": "1.3.3" + }, + "py-xgboost-cpu-1.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.3.3 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "a0184498419d809a0ccb5e2b09df97b9", + "name": "py-xgboost-cpu", + "sha256": "7699ffc1afea13f08fdce8fe0f24b41fa80186888c635ff5ea0aa37d0bbec564", + "size": 22864, + "subdir": "linux-64", + "timestamp": 1619725021019, + "version": "1.3.3" + }, + "py-xgboost-cpu-1.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.3.3 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "d3a95d71c6cfe599dc62c36b4925cdaa", + "name": "py-xgboost-cpu", + "sha256": "76bb2a06681f25831f9640bda0734cf6c8bc61d53c7dce6f8ecec4848d1a6c17", + "size": 22910, + "subdir": "linux-64", + "timestamp": 1619724956436, + "version": "1.3.3" + }, + "py-xgboost-cpu-1.5.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "py-xgboost 1.5.0 py310h06a4308_1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "575d406e6fddfca2328456d76d8126a3", + "name": "py-xgboost-cpu", + "sha256": "f301afb67be7918f4fb23b1803a961fced91812db324b884131e9584567cc1e4", + "size": 14423, + "subdir": "linux-64", + "timestamp": 1641558639316, + "version": "1.5.0" + }, + "py-xgboost-cpu-1.5.0-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "py-xgboost 1.5.0 py310h06a4308_2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "96516d04d57df76bed75bb359c6a1763", + "name": "py-xgboost-cpu", + "sha256": "00eccde852257d909c45094d98ea7ede59ef855e99bfb7880be965bf607d18bc", + "size": 14991, + "subdir": "linux-64", + "timestamp": 1659549521322, + "version": "1.5.0" + }, + "py-xgboost-cpu-1.5.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "py-xgboost 1.5.0 py37h06a4308_1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "ccb24210fbba3ee8ced784b9757d4e73", + "name": "py-xgboost-cpu", + "sha256": "86f363b8fe04e669b24a2949dc7740f357f97cccbe3f593d111b33792ed6c2d3", + "size": 24869, + "subdir": "linux-64", + "timestamp": 1638290409529, + "version": "1.5.0" + }, + "py-xgboost-cpu-1.5.0-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "py-xgboost 1.5.0 py37h06a4308_2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "aed51ef7257e146c89aaa79194fd55e9", + "name": "py-xgboost-cpu", + "sha256": "0a213ee9e182b20027a847560c0608cfc4028d14e64898d1703eaa84f768578a", + "size": 14943, + "subdir": "linux-64", + "timestamp": 1659549537132, + "version": "1.5.0" + }, + "py-xgboost-cpu-1.5.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "py-xgboost 1.5.0 py38h06a4308_1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "860b94db2e52b29a579c8d3d3d4d5289", + "name": "py-xgboost-cpu", + "sha256": "ab92e89cd7de6f61bbc87d5c3d0eca4aa2d5fa9b2a451681898f20ceebcc564e", + "size": 24894, + "subdir": "linux-64", + "timestamp": 1638290371679, + "version": "1.5.0" + }, + "py-xgboost-cpu-1.5.0-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "py-xgboost 1.5.0 py38h06a4308_2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "6889820bf1043c44bee037cc985b5be0", + "name": "py-xgboost-cpu", + "sha256": "890a689786e6af2a42ba32d734d4be3728cc57302a5b7de7da492a9ecfc0e155", + "size": 14940, + "subdir": "linux-64", + "timestamp": 1659549492102, + "version": "1.5.0" + }, + "py-xgboost-cpu-1.5.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "py-xgboost 1.5.0 py39h06a4308_1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "9d735f71fa57d3d9c09a354a82fcdf97", + "name": "py-xgboost-cpu", + "sha256": "87f3b0ea494c220c8b1f13cf5fc320c081f7993753eae74c27dbba222ad4c716", + "size": 24884, + "subdir": "linux-64", + "timestamp": 1638290386388, + "version": "1.5.0" + }, + "py-xgboost-cpu-1.5.0-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "py-xgboost 1.5.0 py39h06a4308_2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "c82962da2a26f772a707153987537e93", + "name": "py-xgboost-cpu", + "sha256": "be3085035efb836865d23550d16b454af049287f497b86b24114859977017404", + "size": 14962, + "subdir": "linux-64", + "timestamp": 1659549506056, + "version": "1.5.0" + }, + "py-xgboost-cpu-1.5.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.5.1 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8016b52fc86475df1a595bdd5067139e", + "name": "py-xgboost-cpu", + "sha256": "b7521770039e1d7de8e1c0a91535dab9eddc73dd09acbea64df50ec091f2c8e4", + "size": 13828, + "subdir": "linux-64", + "timestamp": 1675120186314, + "version": "1.5.1" + }, + "py-xgboost-cpu-1.5.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.5.1 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b3f2bb3b84b0ca9013930ab5fab93874", + "name": "py-xgboost-cpu", + "sha256": "0b10b8dc9cf80ecffc9917c642b7b9e1388ef856574471c90f2bb76b232e374c", + "size": 13786, + "subdir": "linux-64", + "timestamp": 1675120173130, + "version": "1.5.1" + }, + "py-xgboost-cpu-1.5.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.5.1 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3913f6bf5642efff1d1a88d8ef89a564", + "name": "py-xgboost-cpu", + "sha256": "42ecac0121ee64e974660a561e196c60ac5862e303e873ec6bcab9a3cd637b3a", + "size": 13786, + "subdir": "linux-64", + "timestamp": 1675120143758, + "version": "1.5.1" + }, + "py-xgboost-cpu-1.5.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.5.1 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dc455517fe5ed1b5041fae025db93633", + "name": "py-xgboost-cpu", + "sha256": "fc44454bb19601aaab04d3d943d7bb8d38140065ce89cba207ba6abdf1137f4f", + "size": 13810, + "subdir": "linux-64", + "timestamp": 1675120158205, + "version": "1.5.1" + }, + "py-xgboost-cpu-1.7.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.7.3 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4ec358440b6fdc7421a6d3010fe8ab02", + "name": "py-xgboost-cpu", + "sha256": "2d653d9392f42187b8ebcb39a0599c8b8be706f2947d0c23da547f3c6d1e9eac", + "size": 11503, + "subdir": "linux-64", + "timestamp": 1675458316362, + "version": "1.7.3" + }, + "py-xgboost-cpu-1.7.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.7.3 py311h06a4308_0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "85ab2e0ab90b347a2c84700119b0a051", + "name": "py-xgboost-cpu", + "sha256": "d3bc5308545aac81b2f8c5eb305536caa87e91d9606aa1e94a0dc6e3060b7a63", + "size": 11827, + "subdir": "linux-64", + "timestamp": 1676922342105, + "version": "1.7.3" + }, + "py-xgboost-cpu-1.7.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.7.3 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "87f1a8a2443bd9120655233554725e9c", + "name": "py-xgboost-cpu", + "sha256": "6dd0b93e3b268e937e5af1b8c09942c7daeefe4c6403c303980a10e30a655fe2", + "size": 11477, + "subdir": "linux-64", + "timestamp": 1675458781236, + "version": "1.7.3" + }, + "py-xgboost-cpu-1.7.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.7.3 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "23b43ec16b0c3b35b918eb318c067016", + "name": "py-xgboost-cpu", + "sha256": "b0ae505ec42293939e15487ac7890d09384ee83d460b5466ec7b408d0bbfd77c", + "size": 11499, + "subdir": "linux-64", + "timestamp": 1675458564271, + "version": "1.7.3" + }, + "py-xgboost-gpu-0.72-py27h895cc61_0.tar.bz2": { + "build": "py27h895cc61_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.72 py27h83be7fe_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "1a96907cc34f61da5c8b4669df3128f6", + "name": "py-xgboost-gpu", + "sha256": "adf1ea99dd953f7cd12343b949c05c23ea1b37a85111d55d5c327e8c1d97b96e", + "size": 7584, + "subdir": "linux-64", + "timestamp": 1530223015221, + "version": "0.72" + }, + "py-xgboost-gpu-0.72-py27hbd78df6_0.tar.bz2": { + "build": "py27hbd78df6_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.72 py27h87a4715_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "62773ff7ed3c46ec0342a170611208f1", + "name": "py-xgboost-gpu", + "sha256": "41e3024b0f5c1ca5bf13e6e74e0f040fa3f1f3b36068bce225fdeadd2bd99e3e", + "size": 7651, + "subdir": "linux-64", + "timestamp": 1530223693659, + "version": "0.72" + }, + "py-xgboost-gpu-0.72-py35h895cc61_0.tar.bz2": { + "build": "py35h895cc61_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.72 py35h83be7fe_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "e31eb0a879cf1d1044b3ce56f7a693ba", + "name": "py-xgboost-gpu", + "sha256": "316fd52ec256fe30407971e71ac6cfea3cd0ae1d9d9c5a149af0023f42601544", + "size": 7577, + "subdir": "linux-64", + "timestamp": 1530223029161, + "version": "0.72" + }, + "py-xgboost-gpu-0.72-py35hbd78df6_0.tar.bz2": { + "build": "py35hbd78df6_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.72 py35h87a4715_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "047a45a136d6b8473c789fdf0f7fb6c6", + "name": "py-xgboost-gpu", + "sha256": "fded49acad2846f414264b5d66f8a91a4c025a3627c4fca673b6030f4554cd23", + "size": 7645, + "subdir": "linux-64", + "timestamp": 1530223687424, + "version": "0.72" + }, + "py-xgboost-gpu-0.72-py36h895cc61_0.tar.bz2": { + "build": "py36h895cc61_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.72 py36h83be7fe_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "9384b6296db8d3c8abd6f73a85e07499", + "name": "py-xgboost-gpu", + "sha256": "2ad35edc7a16ecd8d007f8261e850aea1952444317373814fea6f89f2f30370d", + "size": 7581, + "subdir": "linux-64", + "timestamp": 1530223022396, + "version": "0.72" + }, + "py-xgboost-gpu-0.72-py36hbd78df6_0.tar.bz2": { + "build": "py36hbd78df6_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.72 py36h87a4715_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "58b06c26eeaba86ce8b8748a9b52b6be", + "name": "py-xgboost-gpu", + "sha256": "4619c5de23d1c6e64244bfd1b6b066990aa131e822128b80cce8341e51516c9c", + "size": 7644, + "subdir": "linux-64", + "timestamp": 1530223700830, + "version": "0.72" + }, + "py-xgboost-gpu-0.80-py27h895cc61_0.tar.bz2": { + "build": "py27h895cc61_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py27h51060c3_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "8072ccf8ec7f2e3544b577df6a15ab65", + "name": "py-xgboost-gpu", + "sha256": "f8fec6cce5023396aa8aab84313ae8a0468791542fa62727b7e90e3371f9284f", + "size": 7394, + "subdir": "linux-64", + "timestamp": 1541468942352, + "version": "0.80" + }, + "py-xgboost-gpu-0.80-py27hbd78df6_0.tar.bz2": { + "build": "py27hbd78df6_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py27h6edc907_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "e7a789f790f165e74261be9d9ee92174", + "name": "py-xgboost-gpu", + "sha256": "3e9328ccd839f2b200ca225aba66049de2b8e7e9432f0fc76691f00a14b72c01", + "size": 7519, + "subdir": "linux-64", + "timestamp": 1541451192428, + "version": "0.80" + }, + "py-xgboost-gpu-0.80-py27hc51cea8_0.tar.bz2": { + "build": "py27hc51cea8_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py27h6cbba54_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "38aa713693920a7a94bb7aaae491bfe7", + "name": "py-xgboost-gpu", + "sha256": "ec629b031c4501394c7b4fbf8aae5471bc6420c5f37a44c8cb8f02b89964a005", + "size": 7481, + "subdir": "linux-64", + "timestamp": 1541450205986, + "version": "0.80" + }, + "py-xgboost-gpu-0.80-py36h895cc61_0.tar.bz2": { + "build": "py36h895cc61_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py36h51060c3_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "24018e1ef262b2d662f96e616982fca8", + "name": "py-xgboost-gpu", + "sha256": "ac3b39decb027194c00de2d6c6231d44d15f2f13cccf0355690b5a2a421676f6", + "size": 7383, + "subdir": "linux-64", + "timestamp": 1541468949333, + "version": "0.80" + }, + "py-xgboost-gpu-0.80-py36hbd78df6_0.tar.bz2": { + "build": "py36hbd78df6_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py36h6edc907_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "958dae01df21bc14b39385b640ec4d0d", + "name": "py-xgboost-gpu", + "sha256": "bc7037b9a6d66c977270190aa49f450c7d71862c7e0771964a87fa12ffb5a3d0", + "size": 7527, + "subdir": "linux-64", + "timestamp": 1541451178563, + "version": "0.80" + }, + "py-xgboost-gpu-0.80-py36hc51cea8_0.tar.bz2": { + "build": "py36hc51cea8_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py36h6cbba54_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "920c5ca2a9a720bdb11ffeaeb1c5e241", + "name": "py-xgboost-gpu", + "sha256": "486cb6b78a5e5a49b0a0826364542d7cc7b65f079e27ff57c9ca1120059f76b0", + "size": 7479, + "subdir": "linux-64", + "timestamp": 1541450192167, + "version": "0.80" + }, + "py-xgboost-gpu-0.80-py37h895cc61_0.tar.bz2": { + "build": "py37h895cc61_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py37h51060c3_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "64d1a4627811c976025ebce1570da9bf", + "name": "py-xgboost-gpu", + "sha256": "6ea1c53e97ab24a329d100a994cffd3ff2d40054651c031b315c9c11287954df", + "size": 7418, + "subdir": "linux-64", + "timestamp": 1541468935782, + "version": "0.80" + }, + "py-xgboost-gpu-0.80-py37hbd78df6_0.tar.bz2": { + "build": "py37hbd78df6_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py37h6edc907_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "e4ecc23a3e717f48f67d6f250f9b646e", + "name": "py-xgboost-gpu", + "sha256": "ec23124667889b8abbc3300b5023f85070b7fb17af83ef0fcbc10b66e733a81c", + "size": 7530, + "subdir": "linux-64", + "timestamp": 1541451185653, + "version": "0.80" + }, + "py-xgboost-gpu-0.80-py37hc51cea8_0.tar.bz2": { + "build": "py37hc51cea8_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py37h6cbba54_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "27da0da0c1e2b80aa6aecc727cd29707", + "name": "py-xgboost-gpu", + "sha256": "4ab32687134a1ea2d2c13c2e9e28dbb73e337ca165b0ebd33d7994aa54b4a7f1", + "size": 7483, + "subdir": "linux-64", + "timestamp": 1541450199236, + "version": "0.80" + }, + "py-xgboost-gpu-0.90-py27h28bbb66_0.tar.bz2": { + "build": "py27h28bbb66_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py27h688424c_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "f0f5170d3d574a8d2ec7ce163dff2ec5", + "name": "py-xgboost-gpu", + "sha256": "f49c82708c7b3026a2ee316481724ad07627581cd5448d6c67c885cf137c2710", + "size": 7837, + "subdir": "linux-64", + "timestamp": 1560801253423, + "version": "0.90" + }, + "py-xgboost-gpu-0.90-py27hbd78df6_0.tar.bz2": { + "build": "py27hbd78df6_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py27h6edc907_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "7019e69732f2120a9eb22ceea84aea45", + "name": "py-xgboost-gpu", + "sha256": "5c210a46f1a7ee5d977d397c7f048d4ee08f31bb1fae37c51416e79e48f588fe", + "size": 7828, + "subdir": "linux-64", + "timestamp": 1560804989567, + "version": "0.90" + }, + "py-xgboost-gpu-0.90-py27hc51cea8_0.tar.bz2": { + "build": "py27hc51cea8_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py27h4d71fd4_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "0eb38495f42c66f6ec5027a909526903", + "name": "py-xgboost-gpu", + "sha256": "d4704d9f5e475d3ad6b0ec140dc0116cec9195478a17f84bc2e986b4796b8098", + "size": 7836, + "subdir": "linux-64", + "timestamp": 1560802425854, + "version": "0.90" + }, + "py-xgboost-gpu-0.90-py36h28bbb66_0.tar.bz2": { + "build": "py36h28bbb66_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py36h688424c_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "c58f3d7e2a1398e5bce82ddb01c22c23", + "name": "py-xgboost-gpu", + "sha256": "bbf65feb778f456e35d76e152ff49f0cbfd5d6d09483cb449c94e8ea439b1024", + "size": 7838, + "subdir": "linux-64", + "timestamp": 1560801248378, + "version": "0.90" + }, + "py-xgboost-gpu-0.90-py36hbd78df6_0.tar.bz2": { + "build": "py36hbd78df6_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py36h6edc907_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "adb904568da62747faa9b2dd5a59790e", + "name": "py-xgboost-gpu", + "sha256": "b0a61b8ad6c882dce9863235e7e661e943b7b3fd30433a67a1e6815e02a0351c", + "size": 7824, + "subdir": "linux-64", + "timestamp": 1560804980242, + "version": "0.90" + }, + "py-xgboost-gpu-0.90-py36hc51cea8_0.tar.bz2": { + "build": "py36hc51cea8_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py36h4d71fd4_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "ee4d2c3ab1384f73b03b6d7b6e719de0", + "name": "py-xgboost-gpu", + "sha256": "f51b7a7dd16e696e5df6f457f36cdd59b35e1106ed6d80d9f783e52f13a02c75", + "size": 7849, + "subdir": "linux-64", + "timestamp": 1560802420681, + "version": "0.90" + }, + "py-xgboost-gpu-0.90-py37h28bbb66_0.tar.bz2": { + "build": "py37h28bbb66_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py37h688424c_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "5fda8a7adeb1edf38cdb4ecd17340e70", + "name": "py-xgboost-gpu", + "sha256": "50396b28586dce89c9fc2291245e0603c840572ec784c8310bdf0204842b5b1f", + "size": 7827, + "subdir": "linux-64", + "timestamp": 1560801258742, + "version": "0.90" + }, + "py-xgboost-gpu-0.90-py37hbd78df6_0.tar.bz2": { + "build": "py37hbd78df6_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py37h6edc907_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "97f809c6264e33bbc1aba66b56ac2271", + "name": "py-xgboost-gpu", + "sha256": "f5b4d85404cd91337f06381c8c4ac98def4cfd4cdd81637598da1e9e9ac2da1e", + "size": 7836, + "subdir": "linux-64", + "timestamp": 1560804985019, + "version": "0.90" + }, + "py-xgboost-gpu-0.90-py37hc51cea8_0.tar.bz2": { + "build": "py37hc51cea8_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py37h4d71fd4_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "621f788bcc1859b0f601ee94cbf60617", + "name": "py-xgboost-gpu", + "sha256": "27306d328fce1ad201c4ab93f95ca5729aa3a4cb5ab5735e5609f9ba7c2e631d", + "size": 7840, + "subdir": "linux-64", + "timestamp": 1560802431006, + "version": "0.90" + }, + "py4j-0.10.6-py27h23eb7b3_1.tar.bz2": { + "build": "py27h23eb7b3_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7f8f87dcf93936b2bd6cdffafc527c32", + "name": "py4j", + "sha256": "c3e104cd9a6b3a4ede984836a5701b8d461b735a7d5e9f645dc301dce74cbd2a", + "size": 240744, + "subdir": "linux-64", + "timestamp": 1505751237293, + "version": "0.10.6" + }, + "py4j-0.10.6-py35h59e76d9_1.tar.bz2": { + "build": "py35h59e76d9_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f7d2cc3044d3ce6e7f4cb2c1c20824ea", + "name": "py4j", + "sha256": "b92aea64cd45a9e68a22ec6a4253eaf0e05eae5f4a82a6a17e9b512de96f17f8", + "size": 246195, + "subdir": "linux-64", + "timestamp": 1505751252785, + "version": "0.10.6" + }, + "py4j-0.10.6-py36hf94ae02_1.tar.bz2": { + "build": "py36hf94ae02_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cbfdf15deb279a751b1c9d5517997d18", + "name": "py4j", + "sha256": "a560cae8a8af0bf985565ab080f26285018f4093e1db66d2754c2a74174b74c2", + "size": 245705, + "subdir": "linux-64", + "timestamp": 1505751268410, + "version": "0.10.6" + }, + "py4j-0.10.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "06da7eb311787ede2cde505960c60052", + "name": "py4j", + "sha256": "b0b9c135381458b02c9e26497b38ff5fa86d7eed872314cd23326a2fc054c9b8", + "size": 251817, + "subdir": "linux-64", + "timestamp": 1526075945304, + "version": "0.10.7" + }, + "py4j-0.10.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7ef2d46878f0433372b176781c3387f7", + "name": "py4j", + "sha256": "45552fbb16c368a438dffc5b0072515a903be13c3bd3bca8a9d29989d1d96234", + "size": 257071, + "subdir": "linux-64", + "timestamp": 1526076138149, + "version": "0.10.7" + }, + "py4j-0.10.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "118d74a6ca89067a87f7535d01266d3d", + "name": "py4j", + "sha256": "ef6a1009aa405c9c02dde385964f7ffd21074832b9f27c9e1234dcad1b6fc843", + "size": 256544, + "subdir": "linux-64", + "timestamp": 1526075947876, + "version": "0.10.7" + }, + "py4j-0.10.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9714f838b7098d75032509e20774192a", + "name": "py4j", + "sha256": "74726d24f964f6a461b9ed8d3f9cad92b194a83676ea6dfd4469d1fdaf2be28a", + "size": 257023, + "subdir": "linux-64", + "timestamp": 1530898277927, + "version": "0.10.7" + }, + "py4j-0.10.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d2f0a5578d7d4ef14928e55812fb767c", + "name": "py4j", + "sha256": "5bb8c38ccf6e2c6ffea0250ac9805e81199e3095a3472db34d2da9116b665f3c", + "size": 249856, + "subdir": "linux-64", + "timestamp": 1541001759032, + "version": "0.10.8.1" + }, + "py4j-0.10.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0373fad5a5cf7396b9057a05ee0d8541", + "name": "py4j", + "sha256": "6fcb6e6862cbb791e704b013fcb3a001db04f7de26a6362e3b2bb0efc109189e", + "size": 254516, + "subdir": "linux-64", + "timestamp": 1541001741606, + "version": "0.10.8.1" + }, + "py4j-0.10.8.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "15c0a5797440a1717cce02f9880a6d67", + "name": "py4j", + "sha256": "bf1e0ab5d0ef72431fca24271f41ca331a4257151ccde82dff8c06585b3d0e84", + "size": 255011, + "subdir": "linux-64", + "timestamp": 1541001731425, + "version": "0.10.8.1" + }, + "py4j-0.10.8.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "363f7556052cfe514e31a407073b6c0b", + "name": "py4j", + "sha256": "6e4532f3ae1948cebbf1c4a20b3c4f24383cf4befd19bbe73c52196ff8e9daa4", + "size": 256296, + "subdir": "linux-64", + "timestamp": 1573662629288, + "version": "0.10.8.1" + }, + "py4j-0.10.9.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f83366a930ae059f98f190fff60f934e", + "name": "py4j", + "sha256": "ba601ac06745d8c7df737c18f4aa8657d98c79ff13ec1c8e75d282b1af10880a", + "size": 261949, + "subdir": "linux-64", + "timestamp": 1669626900609, + "version": "0.10.9.3" + }, + "py4j-0.10.9.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4a2036af5c4340e36b03939e45a0ac6f", + "name": "py4j", + "sha256": "a91598aeda500ef4a7e473139fab339b462025c819361fe1e8c16196ba596366", + "size": 305686, + "subdir": "linux-64", + "timestamp": 1676845253989, + "version": "0.10.9.3" + }, + "py4j-0.10.9.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "756ae85b3799de31d0244d2f0692803e", + "name": "py4j", + "sha256": "779d5f37658b4d8097bef6bda24257c4c804b315315160a76a6cd7002d8732f9", + "size": 258788, + "subdir": "linux-64", + "timestamp": 1669626851136, + "version": "0.10.9.3" + }, + "py4j-0.10.9.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ea3dcacfe0694e6ca4f21951bca4528b", + "name": "py4j", + "sha256": "4d44f9af11ee388808066735e3c484b99ff2432697bc89e85ad560db72761640", + "size": 259931, + "subdir": "linux-64", + "timestamp": 1669626924859, + "version": "0.10.9.3" + }, + "py4j-0.10.9.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "86bc25f944ba9e85c279b09f2b47d148", + "name": "py4j", + "sha256": "126bfb0d6ac3f9aa32288e8782d7a8788d9abccc19b78d4e9f5d866db7437eee", + "size": 260208, + "subdir": "linux-64", + "timestamp": 1669626875768, + "version": "0.10.9.3" + }, + "pyamg-3.3.2-py27h41dcbd8_0.tar.bz2": { + "build": "py27h41dcbd8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest >=2", + "python >=2.7,<2.8.0a0", + "scipy >=0.12.0,<1.8", + "zlib", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "1f863e3788f7e78a217a6ae810294c84", + "name": "pyamg", + "sha256": "816a97e46b77fba102ea1886034ff6939e685f7f40ee646b9e7aca18dc57aed4", + "size": 1061125, + "subdir": "linux-64", + "timestamp": 1509088514589, + "version": "3.3.2" + }, + "pyamg-3.3.2-py27h54d9346_0.tar.bz2": { + "build": "py27h54d9346_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest >=2", + "python >=2.7,<2.8.0a0", + "scipy >=0.12.0,<1.8", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "f04ba45e0f9b78616e98b9bfdad4a966", + "name": "pyamg", + "sha256": "7f32d827edfd788b8140ee1d680219782ab3ec76113ea406ae33564aa5ca3690", + "size": 1060642, + "subdir": "linux-64", + "timestamp": 1530906260320, + "version": "3.3.2" + }, + "pyamg-3.3.2-py35hc0f34cd_0.tar.bz2": { + "build": "py35hc0f34cd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest >=2", + "python >=3.5,<3.6.0a0", + "scipy >=0.12.0,<1.8", + "zlib", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "99099af5e8f86eecb08d8c795fe835f4", + "name": "pyamg", + "sha256": "768d794289b6b9d261301193173cae55e41b145112c61aa885a0c5159739a0f3", + "size": 1065225, + "subdir": "linux-64", + "timestamp": 1509088597637, + "version": "3.3.2" + }, + "pyamg-3.3.2-py36h54d9346_0.tar.bz2": { + "build": "py36h54d9346_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest >=2", + "python >=3.6,<3.7.0a0", + "scipy >=0.12.0,<1.8", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "21750db62d1a3268e0d55f0bc4436544", + "name": "pyamg", + "sha256": "b239dc90d8225405688844dc64fc414f88759d81c92d9407c3b4ce6c622ae08e", + "size": 1054459, + "subdir": "linux-64", + "timestamp": 1530906350330, + "version": "3.3.2" + }, + "pyamg-3.3.2-py36ha1d9e31_0.tar.bz2": { + "build": "py36ha1d9e31_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest >=2", + "python >=3.6,<3.7.0a0", + "scipy >=0.12.0,<1.8", + "zlib", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "bea3184a1a27282f1f177efe19fed84b", + "name": "pyamg", + "sha256": "8921241c9ffeaf2306dc363cd952ceec2d24704ce33edf1b47147a6c9d01e1df", + "size": 1053506, + "subdir": "linux-64", + "timestamp": 1509088328312, + "version": "3.3.2" + }, + "pyamg-3.3.2-py37h54d9346_0.tar.bz2": { + "build": "py37h54d9346_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest >=2", + "python >=3.7,<3.8.0a0", + "scipy >=0.12.0,<1.8", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "d8ab1b666dd0518553491a42b7e541ad", + "name": "pyamg", + "sha256": "6daf11279635ccfb5ebb3e9a70a20f94d0cc74010906610c40a846ef374bb560", + "size": 1047117, + "subdir": "linux-64", + "timestamp": 1530906439644, + "version": "3.3.2" + }, + "pyamg-4.0.0-py27ha516724_0.tar.bz2": { + "build": "py27ha516724_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "7aa65c606a9f85af85080b62e6ae7fea", + "name": "pyamg", + "sha256": "c6f2ee5198ddcfa1037126cc719fd8b68f1f7dc3fb4296f8515481e031391491", + "size": 1377096, + "subdir": "linux-64", + "timestamp": 1536513555060, + "version": "4.0.0" + }, + "pyamg-4.0.0-py35ha516724_0.tar.bz2": { + "build": "py35ha516724_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "df734849ea2d27521119f41dc91a3da0", + "name": "pyamg", + "sha256": "5de8cf8c62949273f170de1e2b6d6753904c051907bb73789a3ab1cf15219909", + "size": 1380436, + "subdir": "linux-64", + "timestamp": 1536513776970, + "version": "4.0.0" + }, + "pyamg-4.0.0-py36ha516724_0.tar.bz2": { + "build": "py36ha516724_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "f531093230f83c0da7ebfd280269efb0", + "name": "pyamg", + "sha256": "0b2041814f300fb994f2f9e9de09cb1eeba385f4fec40099cb874155a32e4c60", + "size": 1396277, + "subdir": "linux-64", + "timestamp": 1536513802990, + "version": "4.0.0" + }, + "pyamg-4.0.0-py37ha516724_0.tar.bz2": { + "build": "py37ha516724_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "c2c874afeb3ede6aa8950080e974a711", + "name": "pyamg", + "sha256": "e93b62da012bacc3d7fd241238c6227e2d753d120c8ecd50965e71117c4b66af", + "size": 1395466, + "subdir": "linux-64", + "timestamp": 1536513716615, + "version": "4.0.0" + }, + "pyamg-4.0.0-py38ha516724_0.tar.bz2": { + "build": "py38ha516724_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "a8ba3628c0db483718262ad0c6662aea", + "name": "pyamg", + "sha256": "928cdc5811a994555de20b7d2c3e43ffe0e595c8e009ffffc9e391422af6229a", + "size": 1359057, + "subdir": "linux-64", + "timestamp": 1574170355622, + "version": "4.0.0" + }, + "pyamg-4.1.0-py310h2571103_0.tar.bz2": { + "build": "py310h2571103_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "118d11c408485c5c1dfc2ee1d458d834", + "name": "pyamg", + "sha256": "08f4fe9a969d47308b91d5e242739a4088e13e53993d60458dc4e6f0e54758e1", + "size": 7645188, + "subdir": "linux-64", + "timestamp": 1640810142029, + "version": "4.1.0" + }, + "pyamg-4.1.0-py36h9a67853_0.tar.bz2": { + "build": "py36h9a67853_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "606f6c86d377ca81d3c861e4753b1e5c", + "name": "pyamg", + "sha256": "82c442181b035e280e6658a77cbacf91ec02670f871931f5a026951dc64844f3", + "size": 1408214, + "subdir": "linux-64", + "timestamp": 1618088926568, + "version": "4.1.0" + }, + "pyamg-4.1.0-py37h9a67853_0.tar.bz2": { + "build": "py37h9a67853_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "afef867bd0a3c977a24e555710e270f6", + "name": "pyamg", + "sha256": "6819a8d03c31d67711e027692bbc021eb5d24f720e56823e4d5a0ac03a23d424", + "size": 1421492, + "subdir": "linux-64", + "timestamp": 1618088613504, + "version": "4.1.0" + }, + "pyamg-4.1.0-py38h9a67853_0.tar.bz2": { + "build": "py38h9a67853_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "e2b377707c78bc215facc55ac6db135f", + "name": "pyamg", + "sha256": "98aa9d2418861506a4710a85a499856f3a8773aabd522bf8643af94176304dc6", + "size": 1442308, + "subdir": "linux-64", + "timestamp": 1618088892453, + "version": "4.1.0" + }, + "pyamg-4.1.0-py39h9a67853_0.tar.bz2": { + "build": "py39h9a67853_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "884938571b44f82105b39a702dcaaaca", + "name": "pyamg", + "sha256": "76ab5737a4d3283c3ad8303a88f9029e72fb41d13b3752ffca998e65f2fd8e8a", + "size": 1428357, + "subdir": "linux-64", + "timestamp": 1618085959655, + "version": "4.1.0" + }, + "pyamg-4.2.3-py310h3c18c91_0.tar.bz2": { + "build": "py310h3c18c91_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=0.12.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4e9f3e12666576dafacb187731999a0", + "name": "pyamg", + "sha256": "75972c0d48500bc517f8b8b04b613334c40bf3b228a68058f50107e3eb40e8d6", + "size": 1571752, + "subdir": "linux-64", + "timestamp": 1665482260104, + "version": "4.2.3" + }, + "pyamg-4.2.3-py311heed92f4_0.tar.bz2": { + "build": "py311heed92f4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0", + "scipy >=0.12.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "beb32b7899191da53998a8a91d9ed854", + "name": "pyamg", + "sha256": "115409c77992e3c5c6c7a1663b2fa35d214ffa9701b0479a43621982bc665939", + "size": 1694014, + "subdir": "linux-64", + "timestamp": 1676860600240, + "version": "4.2.3" + }, + "pyamg-4.2.3-py37h79cecc1_0.tar.bz2": { + "build": "py37h79cecc1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.12.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1792511c7d12f71c5a3357df5e3398b", + "name": "pyamg", + "sha256": "d9c00aecfe0fcde2d54856e12b04cd6c5501bed095df924a44584052be264353", + "size": 1536598, + "subdir": "linux-64", + "timestamp": 1665482387499, + "version": "4.2.3" + }, + "pyamg-4.2.3-py38h79cecc1_0.tar.bz2": { + "build": "py38h79cecc1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.12.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2fc48ddf2fee59e7b6f6e14491bf8df8", + "name": "pyamg", + "sha256": "e7373fc7664f4b2bedb00881c7fa486e1ee3c7826e21e7b64408f1ad73b80b8f", + "size": 1559663, + "subdir": "linux-64", + "timestamp": 1665482004716, + "version": "4.2.3" + }, + "pyamg-4.2.3-py39h79cecc1_0.tar.bz2": { + "build": "py39h79cecc1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.12.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4c5a423bb8f48f20093f021778642b4", + "name": "pyamg", + "sha256": "b42e9d0251088a2cbe82d53fe3c574e5232473f41612e1704a4dfd355222e614", + "size": 1581069, + "subdir": "linux-64", + "timestamp": 1665482137873, + "version": "4.2.3" + }, + "pyaml-18.11.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pyyaml" + ], + "license": "WTFPL", + "md5": "213b9d424da61a426b4f55e061816a35", + "name": "pyaml", + "sha256": "ea1d8267e5ac156ff8b79c56e77340e38f82042400c8eb5f4dcf6f7d181fe408", + "size": 29421, + "subdir": "linux-64", + "timestamp": 1543386785329, + "version": "18.11.0" + }, + "pyaml-18.11.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml" + ], + "license": "WTFPL", + "md5": "7c9ca08d4053d53700eafc6b4e9df5ce", + "name": "pyaml", + "sha256": "99e5c424aa3edf987592754def5bd7774660f1e048e767c3f82610c332d0e398", + "size": 29647, + "subdir": "linux-64", + "timestamp": 1543386802670, + "version": "18.11.0" + }, + "pyaml-18.11.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml" + ], + "license": "WTFPL", + "md5": "4a551539b89bd6b2fbb49d1d16695ce1", + "name": "pyaml", + "sha256": "745a38e5609ba36b0d2b3bd9c9f7a3253ab577a6f05063ddb547ba4de97ad498", + "size": 29668, + "subdir": "linux-64", + "timestamp": 1543386785188, + "version": "18.11.0" + }, + "pyarrow-0.11.0-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.11.0,<0.12.0a0", + "futures", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.2,<2.0a0", + "pandas", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "Apache 2.0", + "md5": "bbef448d3bee797cc3d4f70de9e459c4", + "name": "pyarrow", + "sha256": "d725d96b484fac8c3fcb629d8cf7f67a85070179cb3ee7f9d133a4872dd0d40b", + "size": 1974846, + "subdir": "linux-64", + "timestamp": 1539968045849, + "version": "0.11.0" + }, + "pyarrow-0.11.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.11.0,<0.12.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.2,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache 2.0", + "md5": "263a7167bea2557e5bf5c7bf836d05e3", + "name": "pyarrow", + "sha256": "2ea658ff16e5c91150624bd71e864321c4578eaa175bb8e9b732aab9aea10c5a", + "size": 2025026, + "subdir": "linux-64", + "timestamp": 1539998724556, + "version": "0.11.0" + }, + "pyarrow-0.11.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.11.0,<0.12.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.2,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "Apache 2.0", + "md5": "febd1b0a6f06b59a0ca2d74704396d14", + "name": "pyarrow", + "sha256": "acd451b7990b203d631e0249594495d1371c38a4108cab7cd4ad916854cb8d60", + "size": 2004781, + "subdir": "linux-64", + "timestamp": 1539968220904, + "version": "0.11.0" + }, + "pyarrow-0.11.1-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.11.1,<0.12.0a0", + "futures", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.3,<2.0a0", + "pandas", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "Apache 2.0", + "md5": "2a0a68c60673ce7b3e6702ac47782f6f", + "name": "pyarrow", + "sha256": "cd54dfa81af232505be8ad275d4235194339c1eb1bece9e99680cdf60339a366", + "size": 1978215, + "subdir": "linux-64", + "timestamp": 1541002378882, + "version": "0.11.1" + }, + "pyarrow-0.11.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.11.1,<0.12.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.3,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache 2.0", + "md5": "4d88f0b69420e1729d3d23470729415c", + "name": "pyarrow", + "sha256": "5ad03428391291020fbbf4ca0e32ad120144db138ad431de1076a3ba229eda48", + "size": 1992170, + "subdir": "linux-64", + "timestamp": 1541002382910, + "version": "0.11.1" + }, + "pyarrow-0.11.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.11.1,<0.12.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.3,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "Apache 2.0", + "md5": "3deda6969e9c1ef485ae3670bb50df15", + "name": "pyarrow", + "sha256": "260d7b680c1b93906bd457c165839932ca970018f5301d8aa2c9fbfdf5e1c0dc", + "size": 2006620, + "subdir": "linux-64", + "timestamp": 1541002386860, + "version": "0.11.1" + }, + "pyarrow-0.13.0-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.13.0,<0.14.0a0", + "arrow-cpp >=0.13.0,<1.0a0", + "boost-cpp", + "futures", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14,<2.0a0", + "pandas", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "md5": "89fac515e22af34ebc9cfabfc8fff48e", + "name": "pyarrow", + "sha256": "f49252369bcaf2c60a4453079e1bfc6130c07be763f9d61b2cc243d01c94cb1e", + "size": 2281006, + "subdir": "linux-64", + "timestamp": 1567110538602, + "version": "0.13.0" + }, + "pyarrow-0.13.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.13.0,<0.14.0a0", + "arrow-cpp >=0.13.0,<1.0a0", + "boost-cpp", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "md5": "be1e7c9edbefea6f718146722708e0c5", + "name": "pyarrow", + "sha256": "956c205040a39fe4881d1d33f20211116d484515553255885a623ba14a686d26", + "size": 2304769, + "subdir": "linux-64", + "timestamp": 1567110786008, + "version": "0.13.0" + }, + "pyarrow-0.13.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.13.0,<0.14.0a0", + "arrow-cpp >=0.13.0,<1.0a0", + "boost-cpp", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "md5": "7328928746fd9b307346f7e3fd672fcd", + "name": "pyarrow", + "sha256": "eda2e443fad4f2cbf5b9372690cf534ec02844a86458153c0eaf72f82ec912e9", + "size": 2320040, + "subdir": "linux-64", + "timestamp": 1567111012547, + "version": "0.13.0" + }, + "pyarrow-0.13.0-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.13.0,<0.14.0a0", + "arrow-cpp >=0.13.0,<1.0a0", + "boost-cpp", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14,<2.0a0", + "pandas", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache 2.0", + "md5": "456992d7455fe1b77121ea8a8f78f9ea", + "name": "pyarrow", + "sha256": "24e9e10dce8048fa7d4e4be2747474be8e5f12263e8ca016184276946ca009ff", + "size": 2359165, + "subdir": "linux-64", + "timestamp": 1574413029677, + "version": "0.13.0" + }, + "pyarrow-0.15.1-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.15.1,<0.15.2.0a0", + "arrow-cpp >=0.15.1,<1.0a0", + "boost-cpp", + "glog", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "0f6af323788994e49053217795ba814b", + "name": "pyarrow", + "sha256": "b2cab00be15ccb83e2dd33c542da59e5c05bc62baef075435ffe5ec12c4bd980", + "size": 3455396, + "subdir": "linux-64", + "timestamp": 1582573753026, + "version": "0.15.1" + }, + "pyarrow-0.15.1-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.15.1,<0.15.2.0a0", + "arrow-cpp >=0.15.1,<1.0a0", + "boost-cpp", + "glog", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "f8c5173aace5232f0ad7f44d9ea3dc80", + "name": "pyarrow", + "sha256": "b3d8900e907871edfb115c7b7e6f9fe735c70a0a4d25b4638e8d7d7160717f3c", + "size": 3443080, + "subdir": "linux-64", + "timestamp": 1580504702305, + "version": "0.15.1" + }, + "pyarrow-0.15.1-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.15.1,<0.15.2.0a0", + "arrow-cpp >=0.15.1,<1.0a0", + "boost-cpp", + "glog", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "b4820a95865341b631cec87d7a71d222", + "name": "pyarrow", + "sha256": "7961ba918cdfccf09f66e996cfbaa7cc339486833cd980c949f31f2aceeb9cc8", + "size": 3411688, + "subdir": "linux-64", + "timestamp": 1582573734465, + "version": "0.15.1" + }, + "pyarrow-0.15.1-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.15.1,<0.15.2.0a0", + "arrow-cpp >=0.15.1,<1.0a0", + "boost-cpp", + "glog", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "1fae1b8ea950f533ef58f016ddf8d1dd", + "name": "pyarrow", + "sha256": "77920129c8cfafd075c79a0690a46eace8e39d2897d59ef5df3a5c183c657f8b", + "size": 3399754, + "subdir": "linux-64", + "timestamp": 1580504633622, + "version": "0.15.1" + }, + "pyarrow-0.15.1-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.15.1,<0.15.2.0a0", + "arrow-cpp >=0.15.1,<1.0a0", + "boost-cpp", + "glog", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.8,<3.9.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "45907f4a9a0d1d234a73b7e29b6258b2", + "name": "pyarrow", + "sha256": "db2631f8e66e6080ab23af211f345fed898abc845bf7c1b81b8f34ae07bff618", + "size": 3350871, + "subdir": "linux-64", + "timestamp": 1582573729376, + "version": "0.15.1" + }, + "pyarrow-0.15.1-py38h962f231_0.tar.bz2": { + "build": "py38h962f231_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.15.1,<0.15.2.0a0", + "arrow-cpp >=0.15.1,<1.0a0", + "boost-cpp", + "glog", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.8,<3.9.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "f9406375223cae2887a75072b67e60e8", + "name": "pyarrow", + "sha256": "2c52bc44e13c69836e7a53ce50b7c72435bffa987f25c5d97033a77817fca9dd", + "size": 3342186, + "subdir": "linux-64", + "timestamp": 1580504694269, + "version": "0.15.1" + }, + "pyarrow-0.9.0-py27hfc40096_2.tar.bz2": { + "build": "py27hfc40096_2", + "build_number": 2, + "depends": [ + "arrow-cpp >=0.9.0,<0.10.0a0", + "futures", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "parquet-cpp >=1.4.0,<1.5.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "Apache 2.0", + "md5": "246af6f846cf36d601d0c14693e13783", + "name": "pyarrow", + "sha256": "39ec256b9302f2b15dc177e25819446efa22fa42e5b6b7a774315eab3df06168", + "size": 1184455, + "subdir": "linux-64", + "timestamp": 1529460484415, + "version": "0.9.0" + }, + "pyarrow-0.9.0-py35hfc40096_2.tar.bz2": { + "build": "py35hfc40096_2", + "build_number": 2, + "depends": [ + "arrow-cpp >=0.9.0,<0.10.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "parquet-cpp >=1.4.0,<1.5.0a0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "Apache 2.0", + "md5": "1d00077082454f41866b086047677f10", + "name": "pyarrow", + "sha256": "4041946ab647fbfc107a421c546b2aeb3f3879482835dff7dfed7370481483bd", + "size": 1185215, + "subdir": "linux-64", + "timestamp": 1529460605015, + "version": "0.9.0" + }, + "pyarrow-0.9.0-py36hfc40096_2.tar.bz2": { + "build": "py36hfc40096_2", + "build_number": 2, + "depends": [ + "arrow-cpp >=0.9.0,<0.10.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "parquet-cpp >=1.4.0,<1.5.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache 2.0", + "md5": "f455099d621eed497c74639f1b69a191", + "name": "pyarrow", + "sha256": "8d46a75c90384f86ee656dd6864cdf34c320edad8ed4b15654ae0b237b8c003f", + "size": 1202441, + "subdir": "linux-64", + "timestamp": 1529460539021, + "version": "0.9.0" + }, + "pyarrow-10.0.1-py310h468efa6_0.tar.bz2": { + "build": "py310h468efa6_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=10.0.1,<10.0.2.0a0", + "boost-cpp", + "gflags", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1c11e42660634d4ed351439811936c26", + "name": "pyarrow", + "sha256": "5e65100aa683a4e51cca31f7ec92c32ccb1dff7e7b8991c5ef5fbfce04063d99", + "size": 5825220, + "subdir": "linux-64", + "timestamp": 1680270607402, + "version": "10.0.1" + }, + "pyarrow-10.0.1-py311hd8e8d9b_0.tar.bz2": { + "build": "py311hd8e8d9b_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=10.0.1,<10.0.2.0a0", + "boost-cpp", + "gflags", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ee9c5e23cc4b6fc592b0c185e46ed29e", + "name": "pyarrow", + "sha256": "1b4ce0100482f06f02c47d1e22530cb2f08f0a63a061ff01fb36cd1e4a117d02", + "size": 5783860, + "subdir": "linux-64", + "timestamp": 1680269956999, + "version": "10.0.1" + }, + "pyarrow-10.0.1-py38h992f0b0_0.tar.bz2": { + "build": "py38h992f0b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=10.0.1,<10.0.2.0a0", + "boost-cpp", + "gflags", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "629116d946f3d01d995e7eeba9375ce8", + "name": "pyarrow", + "sha256": "2879051331b8f59041dc8414d740c7352c3c1a3a516a86b33d0b1b671fe253d0", + "size": 5923008, + "subdir": "linux-64", + "timestamp": 1680270287113, + "version": "10.0.1" + }, + "pyarrow-10.0.1-py39h992f0b0_0.tar.bz2": { + "build": "py39h992f0b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=10.0.1,<10.0.2.0a0", + "boost-cpp", + "gflags", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cf05f195839db57a91ca32c6a54e8cb8", + "name": "pyarrow", + "sha256": "ca7a267b924ffb9e8bd8c0ff6f30481b1f38561e72efa8d713ff6acc5637ab60", + "size": 5910764, + "subdir": "linux-64", + "timestamp": 1680270929091, + "version": "10.0.1" + }, + "pyarrow-2.0.0-py36he0739d4_0.tar.bz2": { + "build": "py36he0739d4_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=2.0.0,<2.0.1.0a0", + "arrow-cpp >=2.0.0,<3.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "1c16a6125e7f2c50378b3d9b790df4c3", + "name": "pyarrow", + "sha256": "cd5bbd1492ac7b8d4e5c14d48e04dcf568aa366eea064b85c9cea7630015b488", + "size": 3161160, + "subdir": "linux-64", + "timestamp": 1612021302356, + "version": "2.0.0" + }, + "pyarrow-2.0.0-py37he0739d4_0.tar.bz2": { + "build": "py37he0739d4_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=2.0.0,<2.0.1.0a0", + "arrow-cpp >=2.0.0,<3.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "b5baa593817d088de88c47091f03d1fd", + "name": "pyarrow", + "sha256": "6f04c8e1b48773f2b7e1cb69d114418377163d4dc9e49ed7db7e7102cafe54bf", + "size": 3123459, + "subdir": "linux-64", + "timestamp": 1612021325310, + "version": "2.0.0" + }, + "pyarrow-2.0.0-py38he0739d4_0.tar.bz2": { + "build": "py38he0739d4_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=2.0.0,<2.0.1.0a0", + "arrow-cpp >=2.0.0,<3.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.8,<3.9.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "180bfc5109824fe540dcb0a81bb1f48e", + "name": "pyarrow", + "sha256": "df1571e4ba756ada20dcb722c2c7445e13d69a1d107612f933a74cbab49e42c8", + "size": 3166403, + "subdir": "linux-64", + "timestamp": 1612021344334, + "version": "2.0.0" + }, + "pyarrow-2.0.0-py39he0739d4_0.tar.bz2": { + "build": "py39he0739d4_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=2.0.0,<2.0.1.0a0", + "arrow-cpp >=2.0.0,<3.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.9,<3.10.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "918f2673b0e177ba72352c334846390d", + "name": "pyarrow", + "sha256": "e310b2994b59090eb68e6808d23696ee7dfaaecb732279dce9445c6cb7cc89ce", + "size": 2975445, + "subdir": "linux-64", + "timestamp": 1612020683263, + "version": "2.0.0" + }, + "pyarrow-3.0.0-py36he0739d4_0.tar.bz2": { + "build": "py36he0739d4_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "06a394ccb09742f3c91493dfebe4b4cc", + "name": "pyarrow", + "sha256": "997ddcf7a4e2c859562b7edf0f463748a6790e9b8efe98297b42db3446405d60", + "size": 3231942, + "subdir": "linux-64", + "timestamp": 1612122443882, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py36he0739d4_1.tar.bz2": { + "build": "py36he0739d4_1", + "build_number": 1, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "dfeaf15b394a7fd98cefd32ad36eb26e", + "name": "pyarrow", + "sha256": "41a7cbb02c9b7e9d24f99375ba5b500598cc3468e19283a3b45a9cf0487e8e9f", + "size": 2339615, + "subdir": "linux-64", + "timestamp": 1613152191451, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py36he0739d4_3.tar.bz2": { + "build": "py36he0739d4_3", + "build_number": 3, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "a6fa30177c973f42ce97890fde754e9c", + "name": "pyarrow", + "sha256": "1bb2d28fcaae6644cbe2655fd71b0c0dbf4493d996da42ad3bad6c11979c7cee", + "size": 2308284, + "subdir": "linux-64", + "timestamp": 1615279127904, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py37he0739d4_0.tar.bz2": { + "build": "py37he0739d4_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "5dc791d518e781c0e9b0703a30514bae", + "name": "pyarrow", + "sha256": "29cd6d474f350dfc1d8d6b4c207b702ffb9ae1aa712912b8cb3a22b2a73510dd", + "size": 3175816, + "subdir": "linux-64", + "timestamp": 1612122943156, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py37he0739d4_1.tar.bz2": { + "build": "py37he0739d4_1", + "build_number": 1, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "187048713e20650d978c04d9350af861", + "name": "pyarrow", + "sha256": "7ceb95e9ad8b99424dd0717bfd7049934162e5fc12d5aab6f692c8bf996d1039", + "size": 2337830, + "subdir": "linux-64", + "timestamp": 1613152627779, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py37he0739d4_3.tar.bz2": { + "build": "py37he0739d4_3", + "build_number": 3, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "6c1114f177d6ec82b9990a80dde2f1e0", + "name": "pyarrow", + "sha256": "617db5528fed7ac53f80ef898d0ac55d7e2f6e2507829d13c174bd9ad27188e7", + "size": 2322171, + "subdir": "linux-64", + "timestamp": 1615279458144, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py38he0739d4_0.tar.bz2": { + "build": "py38he0739d4_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.8,<3.9.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "aab8b28608815244126857c985673df4", + "name": "pyarrow", + "sha256": "135b612b8add822ff26981edef0c8033205c456292b8f418b6b808cae5c08893", + "size": 3263872, + "subdir": "linux-64", + "timestamp": 1612122928064, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py38he0739d4_1.tar.bz2": { + "build": "py38he0739d4_1", + "build_number": 1, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.8,<3.9.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "e97f02dc9adba76ae7a8c9b155f6935b", + "name": "pyarrow", + "sha256": "fd5f7100248c27ab53f43e2278ab3ef2a61f5e8bc6e4a2f23232161c673abc8b", + "size": 2412509, + "subdir": "linux-64", + "timestamp": 1613152652177, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py38he0739d4_3.tar.bz2": { + "build": "py38he0739d4_3", + "build_number": 3, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.8,<3.9.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "f5d165c0c083359ca8ff2b96a7372a5b", + "name": "pyarrow", + "sha256": "a625ede7505d3ccbf88f018ed2cda5a171c5b703b5b6962fe24a3e54169e2387", + "size": 2414455, + "subdir": "linux-64", + "timestamp": 1615279367389, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py39he0739d4_0.tar.bz2": { + "build": "py39he0739d4_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.9,<3.10.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "10a344c1380f2f65b69d21b8ca608285", + "name": "pyarrow", + "sha256": "b9e11a9bbc828f367ed12b9e60d02e74dd0be7a17a617d5175ba578ea9cc030b", + "size": 3046584, + "subdir": "linux-64", + "timestamp": 1612122906419, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py39he0739d4_1.tar.bz2": { + "build": "py39he0739d4_1", + "build_number": 1, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.9,<3.10.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "be9dab3ef4aaee6c8f205e0158d76992", + "name": "pyarrow", + "sha256": "c73102ce2d6cb09b1ddda7aa5987a857a4c74a7127e2547aa9455dcada127681", + "size": 2396232, + "subdir": "linux-64", + "timestamp": 1613152631344, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py39he0739d4_3.tar.bz2": { + "build": "py39he0739d4_3", + "build_number": 3, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.9,<3.10.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "acfce00a6eaf94f97dda3537ad934a72", + "name": "pyarrow", + "sha256": "d1772b89ce47b99fad0bae47599eb87000895c764c211f31d0e86f096f579afe", + "size": 2393438, + "subdir": "linux-64", + "timestamp": 1615279423127, + "version": "3.0.0" + }, + "pyarrow-4.0.1-py36he0739d4_3.tar.bz2": { + "build": "py36he0739d4_3", + "build_number": 3, + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "arrow-cpp >=4.0.1,<5.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "cc765acdfda55464cdd1ec293f4e4e2c", + "name": "pyarrow", + "sha256": "458d65b38bdc4a0d300a86e4fcae118e95e075e7243e9da41d82b297f4702138", + "size": 2460468, + "subdir": "linux-64", + "timestamp": 1623164905824, + "version": "4.0.1" + }, + "pyarrow-4.0.1-py37he0739d4_3.tar.bz2": { + "build": "py37he0739d4_3", + "build_number": 3, + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "arrow-cpp >=4.0.1,<5.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "a6ef17176b93e0ef065536a48156f742", + "name": "pyarrow", + "sha256": "dfa37331d08be566fc100b9b785ace578629da49c2b300af060db6de1a996190", + "size": 2437666, + "subdir": "linux-64", + "timestamp": 1623174344326, + "version": "4.0.1" + }, + "pyarrow-4.0.1-py38he0739d4_3.tar.bz2": { + "build": "py38he0739d4_3", + "build_number": 3, + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "arrow-cpp >=4.0.1,<5.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.8,<3.9.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "6a13b7e3ecc306344b3cf347a0b96c15", + "name": "pyarrow", + "sha256": "8def5287701f4a4cd91ec466e6ba427662bdad16cd703ed3cdaa8f3a4d1f7b20", + "size": 2549724, + "subdir": "linux-64", + "timestamp": 1623164893443, + "version": "4.0.1" + }, + "pyarrow-4.0.1-py39he0739d4_3.tar.bz2": { + "build": "py39he0739d4_3", + "build_number": 3, + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "arrow-cpp >=4.0.1,<5.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pandas", + "python >=3.9,<3.10.0a0", + "six", + "snappy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cef1c2aa03d9c58a2c802d5fafbcfe4e", + "name": "pyarrow", + "sha256": "b94f913c3b228d28beb150ce9b8f0fa23bcfee355ddae5a1b8da7f2362c37f22", + "size": 2550310, + "subdir": "linux-64", + "timestamp": 1623236297252, + "version": "4.0.1" + }, + "pyarrow-8.0.0-py310h468efa6_0.tar.bz2": { + "build": "py310h468efa6_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=8.0.0,<8.0.1.0a0", + "arrow-cpp >=8.0.0,<9.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.10,<3.11.0a0", + "snappy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ca373d078fd8a83457496005d935c904", + "name": "pyarrow", + "sha256": "8a04286eabc76444101f63c42773cba2e52c3561a696cc50719ac1c35e4e64b6", + "size": 3333457, + "subdir": "linux-64", + "timestamp": 1657263889195, + "version": "8.0.0" + }, + "pyarrow-8.0.0-py311h4eef722_0.tar.bz2": { + "build": "py311h4eef722_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=8.0.0,<8.0.1.0a0", + "arrow-cpp >=8.0.0,<9.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.11,<3.12.0a0", + "snappy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7a830119a3b49a37347f7d2f27d6b5c2", + "name": "pyarrow", + "sha256": "a5da18a25f9a476a43f7de4c4e13e0d420f515fa6a8ccdb071de1b8db61192ea", + "size": 3339269, + "subdir": "linux-64", + "timestamp": 1676842038681, + "version": "8.0.0" + }, + "pyarrow-8.0.0-py37h992f0b0_0.tar.bz2": { + "build": "py37h992f0b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=8.0.0,<8.0.1.0a0", + "arrow-cpp >=8.0.0,<9.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "snappy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "13dcb2fb7f4a815d4bdaad7e8fdbc6f9", + "name": "pyarrow", + "sha256": "f3424f8646724510d5165475059936ff6677c23c8ced71262f5ae94ea82b0d19", + "size": 3350249, + "subdir": "linux-64", + "timestamp": 1657264242131, + "version": "8.0.0" + }, + "pyarrow-8.0.0-py38h992f0b0_0.tar.bz2": { + "build": "py38h992f0b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=8.0.0,<8.0.1.0a0", + "arrow-cpp >=8.0.0,<9.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "snappy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8dc0f4cba4578c48ac0fab82d4f1b46a", + "name": "pyarrow", + "sha256": "fd698d1ab98dba408cd459eab9d6a93d94391f3554ce5e661b9e4104a709ae48", + "size": 3440300, + "subdir": "linux-64", + "timestamp": 1657264577008, + "version": "8.0.0" + }, + "pyarrow-8.0.0-py39h992f0b0_0.tar.bz2": { + "build": "py39h992f0b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=8.0.0,<8.0.1.0a0", + "arrow-cpp >=8.0.0,<9.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "snappy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8f7706dae01ab190106db03b4d8727aa", + "name": "pyarrow", + "sha256": "bfdc9eea633ca96134751664d1038e345989061a02b5d41fc76ac909b094bed2", + "size": 3427902, + "subdir": "linux-64", + "timestamp": 1657264915458, + "version": "8.0.0" + }, + "pyasn1-0.3.7-py27haf6b024_0.tar.bz2": { + "build": "py27haf6b024_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a6fe261734e216335ec27cac024da252", + "name": "pyasn1", + "sha256": "4a3de1ee3cdcd7ce6386838be623a509737ba45ae4d62c19e73d321c166d249e", + "size": 91952, + "subdir": "linux-64", + "timestamp": 1507699147990, + "version": "0.3.7" + }, + "pyasn1-0.3.7-py35h2fee745_0.tar.bz2": { + "build": "py35h2fee745_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d25b472d0f27403009dde61b408c01e5", + "name": "pyasn1", + "sha256": "c31408eee6033d13b48b35be1391959be8977df34e8b46526efc5b870a466fe4", + "size": 96005, + "subdir": "linux-64", + "timestamp": 1507699158410, + "version": "0.3.7" + }, + "pyasn1-0.3.7-py36h0f28794_0.tar.bz2": { + "build": "py36h0f28794_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "349e6a7e58e1ea9cbf94f680cf72354f", + "name": "pyasn1", + "sha256": "b8afcd311d087e38969fe225f4b52d9509f3aa29edcde01b223c7eda12e357e1", + "size": 95266, + "subdir": "linux-64", + "timestamp": 1507699160557, + "version": "0.3.7" + }, + "pyasn1-0.4.2-py27h1564b0d_0.tar.bz2": { + "build": "py27h1564b0d_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "99a00962b89c71d0aa4e637ca5d27d00", + "name": "pyasn1", + "sha256": "40af5b50c74633f02bc948705fc4c811c37fe5dfcf48fdf524c5b1fae91bd662", + "size": 99834, + "subdir": "linux-64", + "timestamp": 1512020060836, + "version": "0.4.2" + }, + "pyasn1-0.4.2-py35h8f845f4_0.tar.bz2": { + "build": "py35h8f845f4_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "2936831e0c0de42def51f9ec36462ea4", + "name": "pyasn1", + "sha256": "138ce75550cf0900d25044dd37e878ee62f71110b787e01a26b732de25561bfa", + "size": 103917, + "subdir": "linux-64", + "timestamp": 1512020078577, + "version": "0.4.2" + }, + "pyasn1-0.4.2-py36h4d1db45_0.tar.bz2": { + "build": "py36h4d1db45_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c9f0f10ec6e0bac7d88df0711946f7bd", + "name": "pyasn1", + "sha256": "1ce69b490f9aba414d05ba53c47fb8dfb95cca95d2cee5e401c64a7bf6262023", + "size": 103221, + "subdir": "linux-64", + "timestamp": 1512020073821, + "version": "0.4.2" + }, + "pyasn1-0.4.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "009f29533396bc51878a47d4e74df22f", + "name": "pyasn1", + "sha256": "7ba66faad779a47adc67d57b92b7f88301ce9a0f8640a799afd2b158da3d11d5", + "size": 99307, + "subdir": "linux-64", + "timestamp": 1527630313230, + "version": "0.4.3" + }, + "pyasn1-0.4.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "bed6d6819f462f3539cfc911f08f2f77", + "name": "pyasn1", + "sha256": "0f39f38fca26fbea441a323f53c46b7c4fdff7c9b27f1c847a6b634ce6cf6c38", + "size": 103498, + "subdir": "linux-64", + "timestamp": 1527630331626, + "version": "0.4.3" + }, + "pyasn1-0.4.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c4e3ec6c849e9d998403758e8354a035", + "name": "pyasn1", + "sha256": "82e986121e059317cf1ee91a37f406cc9b23232d28668f0a7d92b7083e6a6142", + "size": 102780, + "subdir": "linux-64", + "timestamp": 1527630287450, + "version": "0.4.3" + }, + "pyasn1-0.4.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9642f4788293a468ec81a81d9595f238", + "name": "pyasn1", + "sha256": "0542f33f66b7dfe152b5ea8215f1f0963652e9aae4ed25eb567144f7682c1392", + "size": 103274, + "subdir": "linux-64", + "timestamp": 1530875982901, + "version": "0.4.3" + }, + "pyasn1-0.4.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b23dcb4fc4f90c7b37849c691d0670e1", + "name": "pyasn1", + "sha256": "5b0998ad61eadc20f726cff8806ac87eca48d006afb0d38ffb3a891b3fc72b5b", + "size": 99748, + "subdir": "linux-64", + "timestamp": 1532994013386, + "version": "0.4.4" + }, + "pyasn1-0.4.4-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "06aab28a2f1b926492740d92b8f7bd90", + "name": "pyasn1", + "sha256": "1af9fc5d19baf13c2407f8159d338e77ba8cd5d65eae3e98a18921bd65283ee4", + "size": 99734, + "subdir": "linux-64", + "timestamp": 1534351048068, + "version": "0.4.4" + }, + "pyasn1-0.4.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "641b03ad2b97a39d8ec79277cf013313", + "name": "pyasn1", + "sha256": "b0313116e0edd0683530a955af19a207e1a6a25482ab8cbe2bed626732128b2a", + "size": 103741, + "subdir": "linux-64", + "timestamp": 1532994016677, + "version": "0.4.4" + }, + "pyasn1-0.4.4-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9098bac552ef231ec506b223467ad4fb", + "name": "pyasn1", + "sha256": "69f1c086c515e7a168f8dbba82e319cc0a16dd6a82ee0f7c4a4f8f8b7e8e8acc", + "size": 103843, + "subdir": "linux-64", + "timestamp": 1534351071898, + "version": "0.4.4" + }, + "pyasn1-0.4.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "186ebc1aafc62e76d2291ac183576711", + "name": "pyasn1", + "sha256": "b073dc39ea9c9a4df02dfd6f1f09e82e2772f120fce9a8c7f3055deb42448602", + "size": 103176, + "subdir": "linux-64", + "timestamp": 1532993933710, + "version": "0.4.4" + }, + "pyasn1-0.4.4-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a291e3815ca3d89bac7a6f357d18e436", + "name": "pyasn1", + "sha256": "5afcfe6c33478712d5b4ae9f29c5fad06600c598f21acfe6c3411d3571d749c0", + "size": 103550, + "subdir": "linux-64", + "timestamp": 1534351096601, + "version": "0.4.4" + }, + "pyasn1-0.4.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "81ac5e5550e69b7220cded76922adc31", + "name": "pyasn1", + "sha256": "0a887b06a03f8cf296e2f17d676cae4246d786fa0fa930524b7c101f454a7426", + "size": 103687, + "subdir": "linux-64", + "timestamp": 1532994161555, + "version": "0.4.4" + }, + "pyasn1-0.4.4-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "96a0cb7c189926020709400b98a375a5", + "name": "pyasn1", + "sha256": "38d45f2a49c28678f5c47bce82d143545b7c2cf4b9660ff2d8799fccaea98176", + "size": 103458, + "subdir": "linux-64", + "timestamp": 1534351025433, + "version": "0.4.4" + }, + "pyasn1-modules-0.2.1-py27h997e151_0.tar.bz2": { + "build": "py27h997e151_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "348d0786bef84b604a56ad360fd4a00f", + "name": "pyasn1-modules", + "sha256": "ccf611740b3a23305497c1301d7abf1e8a4d28f0351aeef0f35ca39cfccc047d", + "size": 84556, + "subdir": "linux-64", + "timestamp": 1512021376366, + "version": "0.2.1" + }, + "pyasn1-modules-0.2.1-py35h00c9b8e_0.tar.bz2": { + "build": "py35h00c9b8e_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "0c3bd8c363406e04012ecb3605425e8b", + "name": "pyasn1-modules", + "sha256": "ea2b2b56ecc7088aece0b019d11a45b65d69f3634d074bfc6631e6ffa4857044", + "size": 87372, + "subdir": "linux-64", + "timestamp": 1512021423900, + "version": "0.2.1" + }, + "pyasn1-modules-0.2.1-py36hc893066_0.tar.bz2": { + "build": "py36hc893066_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "71f7e8b4f7a39871d73029d8672d1bf8", + "name": "pyasn1-modules", + "sha256": "73d0d356c9bb58b82b318eeeb58c8584375c7208fd8abd1ac61b1aa789e6787e", + "size": 87983, + "subdir": "linux-64", + "timestamp": 1512021426347, + "version": "0.2.1" + }, + "pyasn1-modules-0.2.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "13317196a18140441592e06457be122a", + "name": "pyasn1-modules", + "sha256": "103e77e8c27d2037123c6a364dfb4d2d4d701ee19986f6c8bbe9185e383074c1", + "size": 84796, + "subdir": "linux-64", + "timestamp": 1530555748057, + "version": "0.2.2" + }, + "pyasn1-modules-0.2.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7caafd734353f88f07bd017fc3204f75", + "name": "pyasn1-modules", + "sha256": "7e2ad0854e2985726758fc1c07fd3841265442443605e4b26ce4a8ed4c89c64b", + "size": 87591, + "subdir": "linux-64", + "timestamp": 1530555730388, + "version": "0.2.2" + }, + "pyasn1-modules-0.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "da6f98b697195ef28547aa9fdfbdaeaa", + "name": "pyasn1-modules", + "sha256": "2df8e894c092bc07df8f7b9ff6e0326457155974b45ed4787dcbd5ac620790b6", + "size": 88265, + "subdir": "linux-64", + "timestamp": 1530555725302, + "version": "0.2.2" + }, + "pyasn1-modules-0.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "326a9ce215ea545d8c61f007b3387c55", + "name": "pyasn1-modules", + "sha256": "d2e24af65d6b947291dfabc1947be2b4284b0a76afa1d5e5420e46eadf5b0924", + "size": 87492, + "subdir": "linux-64", + "timestamp": 1530906503510, + "version": "0.2.2" + }, + "pyasn1-modules-0.2.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7b7baec1129a1f691e1dda5b2f2a0013", + "name": "pyasn1-modules", + "sha256": "ae7d8bf5bedf0fc81fbc150c492bde5dc004a8e517345361f917d41e051d3fbb", + "size": 88634, + "subdir": "linux-64", + "timestamp": 1547247284016, + "version": "0.2.3" + }, + "pyasn1-modules-0.2.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "0a39bbc7faac51ebc6327a43ac053662", + "name": "pyasn1-modules", + "sha256": "40d30b9d90634982750905c2f1fbfc81036434aa664c5f0865b0ce45a0676f69", + "size": 92072, + "subdir": "linux-64", + "timestamp": 1547247310354, + "version": "0.2.3" + }, + "pyasn1-modules-0.2.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "bbc0857b6925a1b997e4fb85639de6e7", + "name": "pyasn1-modules", + "sha256": "18dbe82108161c44c60a12a6919fdd10ed37fa9228594c260a395106494db04a", + "size": 91317, + "subdir": "linux-64", + "timestamp": 1547247312605, + "version": "0.2.3" + }, + "pyasn1-modules-0.2.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "1aef06be3037df778664d0887253b74a", + "name": "pyasn1-modules", + "sha256": "2935b6de51d27835dfee4fcb01a27f7291139ffca748bcc225c2ed70b2416323", + "size": 90153, + "subdir": "linux-64", + "timestamp": 1550351773780, + "version": "0.2.4" + }, + "pyasn1-modules-0.2.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "fbba7d73b545235a95b0fd8229a2c5ac", + "name": "pyasn1-modules", + "sha256": "c4e1d0fb3e69950e30b53d6d24c586d564cc7d8958bffcf054e1d308e01b6eb1", + "size": 93682, + "subdir": "linux-64", + "timestamp": 1550351801685, + "version": "0.2.4" + }, + "pyasn1-modules-0.2.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8f7e4e7fa8f92e4f37cc1a52df1fe726", + "name": "pyasn1-modules", + "sha256": "3e92aea37270c254ef94f77e5c20bdb1a98f945ebafa5a502d8f167de5013e23", + "size": 92818, + "subdir": "linux-64", + "timestamp": 1550351714947, + "version": "0.2.4" + }, + "pyasn1-modules-0.2.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d5f006b71fa23c9810d0969e05777200", + "name": "pyasn1-modules", + "sha256": "7042b036b25df3e52dd4277ba83a19f02351a3f5ad6b8187e06822deb42b2f67", + "size": 121916, + "subdir": "linux-64", + "timestamp": 1564681994673, + "version": "0.2.6" + }, + "pyasn1-modules-0.2.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "0426df389dbacad9c5c41469085928ff", + "name": "pyasn1-modules", + "sha256": "c2fd3303172c0d02a1a7763f698fbce995e97332ed51142724cc6c9bb323fc44", + "size": 121695, + "subdir": "linux-64", + "timestamp": 1564682099461, + "version": "0.2.6" + }, + "pyasn1-modules-0.2.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e40c51afefb2e921919bf3e5633c1d95", + "name": "pyasn1-modules", + "sha256": "ba6fb3fc6bf187bfcdd269a494835b7c98f6bce8257729c32eeb8ad0dbf58440", + "size": 120671, + "subdir": "linux-64", + "timestamp": 1564681973092, + "version": "0.2.6" + }, + "pyasn1-modules-0.2.6-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "80d11b8466572b71c5a712ebd4255709", + "name": "pyasn1-modules", + "sha256": "7f7a941947a4bb3115607fc2b6e7959ca0db764a40fdb1bcf825383a6e68b441", + "size": 119805, + "subdir": "linux-64", + "timestamp": 1573469696231, + "version": "0.2.6" + }, + "pyaudio-0.2.11-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "81e924c039d98d771465d3bea8c874ae", + "name": "pyaudio", + "sha256": "7b5677fe8794d69efe2a64415b6574092abab6006140445243e963ff4671fa2c", + "size": 69336, + "subdir": "linux-64", + "timestamp": 1530915515954, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py27h14c3975_1.tar.bz2": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "portaudio", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "427adae912839fc8a81b757f33d9e103", + "name": "pyaudio", + "sha256": "eea166a1af4d27d559e8d9b33ebda383e562b7c81525f1ee176f03d071b7d0be", + "size": 70084, + "subdir": "linux-64", + "timestamp": 1533481567078, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py27h7b6447c_2.tar.bz2": { + "build": "py27h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "portaudio", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "60ffe2f0fd17e4991b7faf2c51139b80", + "name": "pyaudio", + "sha256": "d76c739fd4286ebde91842fc95687a67d73138fa621286f3f46d8817641e2621", + "size": 191742, + "subdir": "linux-64", + "timestamp": 1584482883206, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py310h7f8727e_2.tar.bz2": { + "build": "py310h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "portaudio", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "abc68087524dd39016a1210a631e384a", + "name": "pyaudio", + "sha256": "8bef7e358a9b8f1b8bd58d13e2c492ddc510688004b2b162a5ad2bf5b421e5d3", + "size": 63225, + "subdir": "linux-64", + "timestamp": 1640792717845, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py311h5eee18b_2.tar.bz2": { + "build": "py311h5eee18b_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "portaudio", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "fd8a5b49b80fe99332f1b177577e8c52", + "name": "pyaudio", + "sha256": "8932cb9ac66e1c2f693828060e1f9c35d99ef62b3881c7db8049f369b137438d", + "size": 36844, + "subdir": "linux-64", + "timestamp": 1676907521780, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py35h14c3975_1.tar.bz2": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "portaudio", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "317b11e45b4a883e53cbd4a057ecd1d3", + "name": "pyaudio", + "sha256": "79b5f723c01598865c229936408f68edd8e178287cca5cb4b143758f4f76f6b5", + "size": 70553, + "subdir": "linux-64", + "timestamp": 1533481569057, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "218d7a0d5357f4dc8ed4387927eefeb9", + "name": "pyaudio", + "sha256": "0a99983afad04af31f8e4b55f6b147425076639f150f92ec04e03c3850562a0c", + "size": 69402, + "subdir": "linux-64", + "timestamp": 1530906693981, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py36h14c3975_1.tar.bz2": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "portaudio", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e141412aa2863642916a08f25475562b", + "name": "pyaudio", + "sha256": "94cd2987cb1f500cb467223720c546b78b46e46dc0c7ed01d6d940eaa6992dce", + "size": 70436, + "subdir": "linux-64", + "timestamp": 1533481488544, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py36h7b6447c_2.tar.bz2": { + "build": "py36h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "portaudio", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "65fe1bf5eeaf093499a6e5381aa100d9", + "name": "pyaudio", + "sha256": "71f328d71937ca5dcea9f176e7ec1a2f66ae0a1edc7e54d4fef5cdc039a2cb9c", + "size": 192139, + "subdir": "linux-64", + "timestamp": 1584480229141, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "217ebfd376ce68431fa98508f1786f32", + "name": "pyaudio", + "sha256": "7b5d3c2c1f08ae4679a5c727e22fd77a06c5ef2504067d25f430157b915d8336", + "size": 69387, + "subdir": "linux-64", + "timestamp": 1530906723118, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py37h14c3975_1.tar.bz2": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "portaudio", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c6e2d62d8150aa6fc177a7a6b10c6716", + "name": "pyaudio", + "sha256": "293709c0bc20a9f0c09bf89ac7af3558efe5178355b9e4996cb20693ac21b37b", + "size": 70424, + "subdir": "linux-64", + "timestamp": 1533481690025, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py37h7b6447c_2.tar.bz2": { + "build": "py37h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "portaudio", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "bec7f8e777bcac6cb910b7c6acc78ffc", + "name": "pyaudio", + "sha256": "d153b39696408a0fe55b5f1feb8751627080b41ebd85bb5af28efa175a553f28", + "size": 192177, + "subdir": "linux-64", + "timestamp": 1584480220237, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "portaudio", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "3a16c7f08c4e52d6c585269170a8ce1e", + "name": "pyaudio", + "sha256": "4ac4f16ce3faacd0178b59a51bbd5a5fb66c0ea17474b7218c49c1c3a0caf94c", + "size": 79413, + "subdir": "linux-64", + "timestamp": 1573662654233, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py38h7b6447c_2.tar.bz2": { + "build": "py38h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "portaudio", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "d9b2ef9359e4922acf53e9db9f6f26f1", + "name": "pyaudio", + "sha256": "5793ebd7a15ae703ee6a1119d746039ac0bb8471b58ec43e17fa9ee4ca4b3c61", + "size": 192260, + "subdir": "linux-64", + "timestamp": 1584480242358, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py39h27cfd23_2.tar.bz2": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "portaudio", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "a761af91dfa957941c3304fe6e3f57b4", + "name": "pyaudio", + "sha256": "2ee31320a1639c0b3ce589ad27cee78053403a413ee1791a2058c04f174d7da6", + "size": 34122, + "subdir": "linux-64", + "timestamp": 1607007539987, + "version": "0.2.11" + }, + "pybind11-2.10.1-py310hdb19cb5_0.tar.bz2": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pybind11-global 2.10.1 py310hdb19cb5_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1fce20ad9e1b21eb9c0d59212ab1a9dd", + "name": "pybind11", + "sha256": "d523fb60c55b3bc3e83aee3026cc514c0d8538b76c030a2af05df6427087b642", + "size": 168453, + "subdir": "linux-64", + "timestamp": 1668512310349, + "version": "2.10.1" + }, + "pybind11-2.10.1-py311hdb19cb5_0.tar.bz2": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pybind11-global 2.10.1 py311hdb19cb5_0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f2d60b885f8ee8140364120a7d0a2950", + "name": "pybind11", + "sha256": "cbb320d8860309a6f71155a4df7643ca0fd36002dbc150928275cf1a37dd182c", + "size": 174458, + "subdir": "linux-64", + "timestamp": 1676825114502, + "version": "2.10.1" + }, + "pybind11-2.10.1-py37hdb19cb5_0.tar.bz2": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pybind11-global 2.10.1 py37hdb19cb5_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5aa5cac2e8c6be90e2b401a7db81e88a", + "name": "pybind11", + "sha256": "12406e1db59eeaee6fc83d8a9a2f2cb4b4c745bbf57d4d7ff1fb6c30ddc8ea4b", + "size": 168063, + "subdir": "linux-64", + "timestamp": 1668512294566, + "version": "2.10.1" + }, + "pybind11-2.10.1-py38hdb19cb5_0.tar.bz2": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pybind11-global 2.10.1 py38hdb19cb5_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f9682a5c8aace7e4a12d831a9017fb66", + "name": "pybind11", + "sha256": "feaa86e5bcd0cc7aef8d11a880c374893abebb332b5c7a75eba2a14475c394c7", + "size": 168467, + "subdir": "linux-64", + "timestamp": 1668512341407, + "version": "2.10.1" + }, + "pybind11-2.10.1-py39hdb19cb5_0.tar.bz2": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pybind11-global 2.10.1 py39hdb19cb5_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fd7d40089ea62595a6c83923b6d20323", + "name": "pybind11", + "sha256": "9283868eca2d2ab9671dbe9585b3325b19a875a0fa71478aba2d71a6694ca696", + "size": 168200, + "subdir": "linux-64", + "timestamp": 1668512325930, + "version": "2.10.1" + }, + "pybind11-2.2.3-py27hfd86e86_0.tar.bz2": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f7b419bac8270fcdebeac92e34072bca", + "name": "pybind11", + "sha256": "ed8f8929dde2218497a7d869a9b389b6950a79d863f7d7df4a0e5f2dfaa93931", + "size": 116307, + "subdir": "linux-64", + "timestamp": 1536510858912, + "version": "2.2.3" + }, + "pybind11-2.2.3-py35hfd86e86_0.tar.bz2": { + "build": "py35hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a899a1c358fbfef969f84ea7ee1adaf4", + "name": "pybind11", + "sha256": "9c54eec6539a8b56b75ff3602fc16d02a99e4e7dd6b83309da8b6934bc8b6188", + "size": 116369, + "subdir": "linux-64", + "timestamp": 1536510910109, + "version": "2.2.3" + }, + "pybind11-2.2.3-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4a723ea8c6d892cc23d8194c0bf65cfa", + "name": "pybind11", + "sha256": "8d3466513a92e2d9156fb8efc03eda69ae8be3501f5ae6b87b2c77c013165420", + "size": 116387, + "subdir": "linux-64", + "timestamp": 1536510993256, + "version": "2.2.3" + }, + "pybind11-2.2.3-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "16a20ec69337aed35c830feb9f8bcecb", + "name": "pybind11", + "sha256": "bc948d84cfad569a7ee92f3ffaba5281b25729a57fdda9bd4dd57b8f6de72d1e", + "size": 116383, + "subdir": "linux-64", + "timestamp": 1536510822610, + "version": "2.2.3" + }, + "pybind11-2.2.4-py27hfd86e86_0.tar.bz2": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d03cd33410be0a7d54e35b719019a8ae", + "name": "pybind11", + "sha256": "120adb62d605b447d294d8a66cdcc3da23c75503a2aed1ad85fbac0ea5806dce", + "size": 116978, + "subdir": "linux-64", + "timestamp": 1539658007441, + "version": "2.2.4" + }, + "pybind11-2.2.4-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ba73efc9397841dc28449edcb1878e96", + "name": "pybind11", + "sha256": "4e4cfbb6d951bc8de133692be539ed106719516a3f11b53ea4229530b3fe9751", + "size": 117114, + "subdir": "linux-64", + "timestamp": 1539658034601, + "version": "2.2.4" + }, + "pybind11-2.2.4-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "25ba83cb193548deafbaea4b7759a979", + "name": "pybind11", + "sha256": "593f9b9c530d032de9796b3ae065ab20831e1368b716a9e8e441d3f114232b8b", + "size": 117128, + "subdir": "linux-64", + "timestamp": 1539658018456, + "version": "2.2.4" + }, + "pybind11-2.4.2-py27hfd86e86_0.tar.bz2": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8c730654e2efa336fca44d416aa0ea61", + "name": "pybind11", + "sha256": "6f3e29eba3da6ae5209f60e4b192e4ea78d1cde292d40495322116408da99441", + "size": 125843, + "subdir": "linux-64", + "timestamp": 1569426205840, + "version": "2.4.2" + }, + "pybind11-2.4.2-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f668632e3ce599083309b50709011ecc", + "name": "pybind11", + "sha256": "5185e0c4cafa3978cef07d4b776bd2a2286a519fe4539493f4ed2a6e665c8328", + "size": 126309, + "subdir": "linux-64", + "timestamp": 1569426177414, + "version": "2.4.2" + }, + "pybind11-2.4.2-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9310428dfa39193eb02eccb1361bd210", + "name": "pybind11", + "sha256": "7ffa66f5522caadef756fd87d061cbb17f8c9b5058cb8ccdae4e33c059a26f87", + "size": 126316, + "subdir": "linux-64", + "timestamp": 1569426202685, + "version": "2.4.2" + }, + "pybind11-2.4.2-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5134bfb36625f993cb909cc837ee59f4", + "name": "pybind11", + "sha256": "1afbd7324fe91f93eaee72ef4c94185ca63a2144d1babf27570e58666460fd14", + "size": 129765, + "subdir": "linux-64", + "timestamp": 1573662685529, + "version": "2.4.2" + }, + "pybind11-2.4.3-py27hfd86e86_0.tar.bz2": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4ddf7bf2575a92abdc3fdae064a8472c", + "name": "pybind11", + "sha256": "2208f455f6e55def6513c273d4e14af2c0ff4a00ec553e4204b0ac940705027b", + "size": 126582, + "subdir": "linux-64", + "timestamp": 1573970600933, + "version": "2.4.3" + }, + "pybind11-2.4.3-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1f1491f003f0dd41de6227aeefafc012", + "name": "pybind11", + "sha256": "3fb10a420acb91288a8ceeb63739c6e52d25102a6ba0b5dce7695f19d5390e4b", + "size": 126688, + "subdir": "linux-64", + "timestamp": 1573970574341, + "version": "2.4.3" + }, + "pybind11-2.4.3-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fda0f0118f751c60e1cf3ef9cd206eee", + "name": "pybind11", + "sha256": "c0579937b5d5297e75b976e8382a63aeb5110a77409920b9c61d8376d7be892b", + "size": 126699, + "subdir": "linux-64", + "timestamp": 1573970584192, + "version": "2.4.3" + }, + "pybind11-2.4.3-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5e20e2d18cddbe24469965f924feb3e2", + "name": "pybind11", + "sha256": "e569400a039408835d21ba3e7273d9a3f9b8dc27b558cef3802538ef0ed641dc", + "size": 133805, + "subdir": "linux-64", + "timestamp": 1573970614238, + "version": "2.4.3" + }, + "pybind11-2.5.0-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "589d9db7c30e9f39d783fa09a9f85876", + "name": "pybind11", + "sha256": "3069c8279681e350e950e1892c129c2e46e68a748a5a5a0f0f02e207efc8fb19", + "size": 174815, + "subdir": "linux-64", + "timestamp": 1595273568877, + "version": "2.5.0" + }, + "pybind11-2.5.0-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "cc183526256b8be275d236d331353350", + "name": "pybind11", + "sha256": "cac6ca12e4a53eaeb1a08f3295679e471a587a66f3077951011885b07469bef5", + "size": 164103, + "subdir": "linux-64", + "timestamp": 1595274121409, + "version": "2.5.0" + }, + "pybind11-2.5.0-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c047c62b5ddd498b0252623ffd1de72f", + "name": "pybind11", + "sha256": "c3f4c405b2a91e62eedeb4ebc2fe76a9cd63f995b8c62dd79f4cd0bf52d93297", + "size": 169383, + "subdir": "linux-64", + "timestamp": 1595274109313, + "version": "2.5.0" + }, + "pybind11-2.5.0-py39hff7bd54_1.tar.bz2": { + "build": "py39hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "83e674ca1ef06bbbbc19804a92beae13", + "name": "pybind11", + "sha256": "b84ac3a2367b29851a6290b4cb896044fe4279c222f694c06394f986bfdb3167", + "size": 172724, + "subdir": "linux-64", + "timestamp": 1607613286833, + "version": "2.5.0" + }, + "pybind11-2.6.2-py36hff7bd54_1.tar.bz2": { + "build": "py36hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "89585064819928df5a4e7d422edddb89", + "name": "pybind11", + "sha256": "6f52be230de1db7564ae080f6e44019a0e417e8a7671a680c39e76aa0203ea9c", + "size": 201196, + "subdir": "linux-64", + "timestamp": 1621869757013, + "version": "2.6.2" + }, + "pybind11-2.6.2-py37hff7bd54_1.tar.bz2": { + "build": "py37hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ea0d58905a0e2db9eb27614c25a61184", + "name": "pybind11", + "sha256": "f9a6705004bcd43cfaf22f812158468e2239ff59963ec9d60d7591b61aede39d", + "size": 193662, + "subdir": "linux-64", + "timestamp": 1621865107627, + "version": "2.6.2" + }, + "pybind11-2.6.2-py38hff7bd54_1.tar.bz2": { + "build": "py38hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "02c3681d180f42163a32bae42631c156", + "name": "pybind11", + "sha256": "18507ef7e472c50e06c75e1683559abbea2927437a38c70726358b41203a9f1f", + "size": 192480, + "subdir": "linux-64", + "timestamp": 1621869965988, + "version": "2.6.2" + }, + "pybind11-2.6.2-py39hff7bd54_1.tar.bz2": { + "build": "py39hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "04a7245afc4722462171da52adc44bee", + "name": "pybind11", + "sha256": "0b61df82ff606ae94d2bf604a793ad08deb8550314c5af2e3a42266aa2c1530e", + "size": 195948, + "subdir": "linux-64", + "timestamp": 1621869954156, + "version": "2.6.2" + }, + "pybind11-2.7.0-py310hd09550d_1.tar.bz2": { + "build": "py310hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3fcdff2aa6675a4ae26c348784c1dc35", + "name": "pybind11", + "sha256": "486dc7fb4d0aff8dbfbad3a22f2a816efe23af3806d5a0663125c570b52b9d67", + "size": 205359, + "subdir": "linux-64", + "timestamp": 1640792745049, + "version": "2.7.0" + }, + "pybind11-2.7.0-py36hd09550d_1.tar.bz2": { + "build": "py36hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "637913bb3c449acf5550ed6a1fb062cb", + "name": "pybind11", + "sha256": "e64c6f37b2bccccb149691e5ac73f872e48725ce4e9b3124146a9fcd9d085ac4", + "size": 194961, + "subdir": "linux-64", + "timestamp": 1627054043127, + "version": "2.7.0" + }, + "pybind11-2.7.0-py37hd09550d_1.tar.bz2": { + "build": "py37hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c681d810dabc56b5fc16f7dcfb4d6b4f", + "name": "pybind11", + "sha256": "0c5cc83e40036b2bfa7d601563768373ab2717dc7e061ac2e9f1b1a3a195772b", + "size": 200149, + "subdir": "linux-64", + "timestamp": 1627061497506, + "version": "2.7.0" + }, + "pybind11-2.7.0-py38hd09550d_1.tar.bz2": { + "build": "py38hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3291d8d78942e876b9fd70fb216867b0", + "name": "pybind11", + "sha256": "dac3dba59e8f0aaa348842c7f479749df2ba84d8cef3acb4b91aee75577cec78", + "size": 203791, + "subdir": "linux-64", + "timestamp": 1627061498816, + "version": "2.7.0" + }, + "pybind11-2.7.0-py39hd09550d_1.tar.bz2": { + "build": "py39hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2534849c03f3d466df94fa28c74faa6d", + "name": "pybind11", + "sha256": "98299c50b89775ea1e757be27358742eaf2194e0b80a2ae56f8c10c89af263e4", + "size": 200507, + "subdir": "linux-64", + "timestamp": 1627061511421, + "version": "2.7.0" + }, + "pybind11-2.8.1-py37hd09550d_0.tar.bz2": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "12f403e4a377d7e674c2191a15fcaa36", + "name": "pybind11", + "sha256": "3e00f6e1896d861615fa65651cc301fc8280beebac662854b8552aa5d19ea0c2", + "size": 212460, + "subdir": "linux-64", + "timestamp": 1638777346026, + "version": "2.8.1" + }, + "pybind11-2.8.1-py38hd09550d_0.tar.bz2": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1b20459ab2341306d6a1c935d8394e86", + "name": "pybind11", + "sha256": "00154f0427fb85aae0aec73ed581f177220d4993b2806d7dfd572a067205c0f7", + "size": 211795, + "subdir": "linux-64", + "timestamp": 1638795463877, + "version": "2.8.1" + }, + "pybind11-2.8.1-py39hd09550d_0.tar.bz2": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "82e7d769a764587bdf4bdfbcab360311", + "name": "pybind11", + "sha256": "2644b8d65289f2b25af578a8a07114a634eafa6699526ae34f4aa1390c3d08ca", + "size": 219367, + "subdir": "linux-64", + "timestamp": 1638795472356, + "version": "2.8.1" + }, + "pybind11-2.9.1-py310h2571103_0.tar.bz2": { + "build": "py310h2571103_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a98e142177783a2284badbf53a6522ac", + "name": "pybind11", + "sha256": "4b4139f855d105340432edecdf55b9f9f3101e2d92f6ade0b1d6d63bd4a7bbec", + "size": 218705, + "subdir": "linux-64", + "timestamp": 1646325328343, + "version": "2.9.1" + }, + "pybind11-2.9.1-py37hae6d005_0.tar.bz2": { + "build": "py37hae6d005_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "534bf610a4ae8e24f256faa14cc3c08c", + "name": "pybind11", + "sha256": "6a8410cf873cca9695a1869d445f6dd09d664df725d85dce1605d61c571f650b", + "size": 223859, + "subdir": "linux-64", + "timestamp": 1646308126914, + "version": "2.9.1" + }, + "pybind11-2.9.1-py38hae6d005_0.tar.bz2": { + "build": "py38hae6d005_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "847e374f186c784d0c2419817226462c", + "name": "pybind11", + "sha256": "38692f24f9a8420297bbc9c4ac7b13f6c1f83389321250c9e5c0e47452501ff3", + "size": 228973, + "subdir": "linux-64", + "timestamp": 1646307197943, + "version": "2.9.1" + }, + "pybind11-2.9.1-py39hae6d005_0.tar.bz2": { + "build": "py39hae6d005_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "025b4f0c7bee55025d3c7bc7926e457d", + "name": "pybind11", + "sha256": "53e5375e479d167fe264aa850c0cb88baf50bf3edda46ea72940e8b5c0acb2c8", + "size": 227378, + "subdir": "linux-64", + "timestamp": 1646325340448, + "version": "2.9.1" + }, + "pybind11-2.9.2-py310h3c18c91_0.tar.bz2": { + "build": "py310h3c18c91_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "99ac727025c4319f326478e48b0d1767", + "name": "pybind11", + "sha256": "b6ac6f571b85fe1b64939ebe795cd5dc7401cb17eb41d66a6d848f43a3e5e7d7", + "size": 212050, + "subdir": "linux-64", + "timestamp": 1661448098701, + "version": "2.9.2" + }, + "pybind11-2.9.2-py37h79cecc1_0.tar.bz2": { + "build": "py37h79cecc1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6e1190d061fa9037377a141b61268db2", + "name": "pybind11", + "sha256": "06f3604247b20a691ca2dbac36602dc9e078d0896e9af281ff3b99b9bd01baa4", + "size": 216850, + "subdir": "linux-64", + "timestamp": 1661447361907, + "version": "2.9.2" + }, + "pybind11-2.9.2-py38h79cecc1_0.tar.bz2": { + "build": "py38h79cecc1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3ecf9b400c77d1316a7c59c81732efbb", + "name": "pybind11", + "sha256": "10578a6cb8e44337ebebaf575d7693d5e2b6df6585a4397b4e14efef76b01a76", + "size": 215275, + "subdir": "linux-64", + "timestamp": 1661447604951, + "version": "2.9.2" + }, + "pybind11-2.9.2-py39h79cecc1_0.tar.bz2": { + "build": "py39h79cecc1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6708babbac9e8de465984e6728ae05f5", + "name": "pybind11", + "sha256": "d79fef6756ee30a23cc7c3a2070edaaba6fa03014ad89b72a95629977b9bc11f", + "size": 216726, + "subdir": "linux-64", + "timestamp": 1661447853546, + "version": "2.9.2" + }, + "pybind11-global-2.10.1-py310hdb19cb5_0.tar.bz2": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e5e9f5d9b4b3357b4f33e181edcb0242", + "name": "pybind11-global", + "sha256": "a828458fde024281f0427bedad99279c5ad21aa1bdb600ea93e531f7fa7e9689", + "size": 199755, + "subdir": "linux-64", + "timestamp": 1668512247581, + "version": "2.10.1" + }, + "pybind11-global-2.10.1-py311hdb19cb5_0.tar.bz2": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0c78c5fb20a2c5a00a3bd4bcb2ccf70c", + "name": "pybind11-global", + "sha256": "e646b6fe695d6c885cc5e788537d831248dd220de50c2608f7ab03a8cb7980d4", + "size": 202342, + "subdir": "linux-64", + "timestamp": 1676825101996, + "version": "2.10.1" + }, + "pybind11-global-2.10.1-py37hdb19cb5_0.tar.bz2": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "11927e38b549b4aa63bc5f5f8387b65c", + "name": "pybind11-global", + "sha256": "c9524801921dfa6a09e7172729098f77c78494911aabfa806201f12879c785cd", + "size": 199298, + "subdir": "linux-64", + "timestamp": 1668512231295, + "version": "2.10.1" + }, + "pybind11-global-2.10.1-py38hdb19cb5_0.tar.bz2": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2cfce8252090479ce5ee437156213ecb", + "name": "pybind11-global", + "sha256": "fde9bd4fdf43bd786c092261e0b2d419534d2a825654bda271eb13d921a5b5f8", + "size": 200222, + "subdir": "linux-64", + "timestamp": 1668512278985, + "version": "2.10.1" + }, + "pybind11-global-2.10.1-py39hdb19cb5_0.tar.bz2": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "169164b6378fb5ba5a5deeef125ddbfd", + "name": "pybind11-global", + "sha256": "ec0149554f99a4eeb16ae6690c443f73a2e87eb88e4ca5b7ee69b608d8ef84c2", + "size": 199913, + "subdir": "linux-64", + "timestamp": 1668512263281, + "version": "2.10.1" + }, + "pycairo-1.13.3-py27h44fc0e4_1.tar.bz2": { + "build": "py27h44fc0e4_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.10,<2.0a0", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "8d5dd262afa9e207b1a886e552c5b43f", + "name": "pycairo", + "sha256": "ad990e7683c61a2563ceee5be8c9bf6c013fb1c4a9e753e73a6a71afa8df021b", + "size": 55872, + "subdir": "linux-64", + "timestamp": 1510610244580, + "version": "1.13.3" + }, + "pycairo-1.13.3-py27hea6d626_0.tar.bz2": { + "build": "py27hea6d626_0", + "build_number": 0, + "depends": [ + "cairo 1.14.*", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "dc7b0994e67552d4319f90e44fc04eaa", + "name": "pycairo", + "sha256": "95ff58e267da46570d72cea58d097024366fdc57163bd0f8b7f92ab8112a31fd", + "size": 55409, + "subdir": "linux-64", + "timestamp": 1505751289291, + "version": "1.13.3" + }, + "pycairo-1.13.3-py35h77ace0a_1.tar.bz2": { + "build": "py35h77ace0a_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.10,<2.0a0", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "c72c17ea2880500d018a8ccf5c4cac75", + "name": "pycairo", + "sha256": "0115e593369c603512b2bc08549828e11520f9f37cf35b987f6d58a2fc2fee8d", + "size": 56313, + "subdir": "linux-64", + "timestamp": 1510610245931, + "version": "1.13.3" + }, + "pycairo-1.13.3-py36h8764da6_1.tar.bz2": { + "build": "py36h8764da6_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.10,<2.0a0", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "50c3dc9e81dc4ca145ad3788891fcbb7", + "name": "pycairo", + "sha256": "8845815f73822572f6566705b831f6f9dc2fa51d9666cd2aab3fbc0dec3a8635", + "size": 56284, + "subdir": "linux-64", + "timestamp": 1510610243337, + "version": "1.13.3" + }, + "pycairo-1.15.4-py27h1b9232e_1.tar.bz2": { + "build": "py27h1b9232e_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.10,<2.0a0", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "24c46fba0be4c4b92f0479dd7b11fbbf", + "name": "pycairo", + "sha256": "77764b57d74589df9137700f549b986c944ca08bffd9c40258a1db468eb61dc9", + "size": 68707, + "subdir": "linux-64", + "timestamp": 1515723963587, + "version": "1.15.4" + }, + "pycairo-1.15.4-py35h1b9232e_1.tar.bz2": { + "build": "py35h1b9232e_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.10,<2.0a0", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "e0489bacc40d09b7f751153ab48bdcaa", + "name": "pycairo", + "sha256": "5160573fb228615b5401def0f3dbb39ee1a04fe4ffdefe7d0418555736b60750", + "size": 68986, + "subdir": "linux-64", + "timestamp": 1515723968008, + "version": "1.15.4" + }, + "pycairo-1.15.4-py36h1b9232e_1.tar.bz2": { + "build": "py36h1b9232e_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.10,<2.0a0", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "29054c7c481c887a1c7cb22ae314e238", + "name": "pycairo", + "sha256": "c24ab8e4483bd9bb561b0b0e6a8b53af0b883b42038672af5906bb6c99c0015f", + "size": 68962, + "subdir": "linux-64", + "timestamp": 1515723939461, + "version": "1.15.4" + }, + "pycairo-1.15.4-py37h1b9232e_1.tar.bz2": { + "build": "py37h1b9232e_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "684a024d86cc7cd23ec47497e3854712", + "name": "pycairo", + "sha256": "d6fb09d69e18ae74dda95aa620e306198afdfc91d879d4d3a81be2bec107002d", + "size": 68867, + "subdir": "linux-64", + "timestamp": 1530915555865, + "version": "1.15.4" + }, + "pycairo-1.17.1-py27h2a1e443_0.tar.bz2": { + "build": "py27h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "caf12b8a59e804fcfb4f621386a8df8e", + "name": "pycairo", + "sha256": "3f6c41465ba09eb9e494c1c76dc9c0831eac3faded2f25b2afaa942f597b80a7", + "size": 75203, + "subdir": "linux-64", + "timestamp": 1535474309628, + "version": "1.17.1" + }, + "pycairo-1.17.1-py35h2a1e443_0.tar.bz2": { + "build": "py35h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "e8af765f45a7adc1f2fb31a8652fe1c8", + "name": "pycairo", + "sha256": "bf97faa1b61319d9ee59b102740205bba94d800879261bfae6543144d1b3f6bb", + "size": 75156, + "subdir": "linux-64", + "timestamp": 1535474400887, + "version": "1.17.1" + }, + "pycairo-1.17.1-py36h2a1e443_0.tar.bz2": { + "build": "py36h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "26d10c5f56afca52a01fb417c73d4e94", + "name": "pycairo", + "sha256": "0d6b37a78352ad93d06fa7bd003c92b182105bfe15c6118e0e2f322198903a03", + "size": 75193, + "subdir": "linux-64", + "timestamp": 1535474196292, + "version": "1.17.1" + }, + "pycairo-1.17.1-py37h2a1e443_0.tar.bz2": { + "build": "py37h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "b32a452773487e7345aad39c8bda9228", + "name": "pycairo", + "sha256": "23eef293c98acbcb17511296e617fc60f367174aca66039a77f40d3f69697c3f", + "size": 75296, + "subdir": "linux-64", + "timestamp": 1535474402327, + "version": "1.17.1" + }, + "pycairo-1.18.0-py27h2a1e443_0.tar.bz2": { + "build": "py27h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "ad47532f5bdbfae71ada2bc544180792", + "name": "pycairo", + "sha256": "8725552ca66ae4e841455acc5d31fa0e820af10b172e342ec90d169a54547657", + "size": 76145, + "subdir": "linux-64", + "timestamp": 1541440813892, + "version": "1.18.0" + }, + "pycairo-1.18.0-py36h2a1e443_0.tar.bz2": { + "build": "py36h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "115e22bf8af5c5e3632772697b7869e9", + "name": "pycairo", + "sha256": "9a736bf58fb038e64b766668133d97cc93baad9de16b6456bdc692a492ba5e60", + "size": 76210, + "subdir": "linux-64", + "timestamp": 1541440813346, + "version": "1.18.0" + }, + "pycairo-1.18.0-py37h2a1e443_0.tar.bz2": { + "build": "py37h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "1bbf469a065d4fe744292c37df9754de", + "name": "pycairo", + "sha256": "8bc29bc12979a0697fd8d992789daa72ee117f1af0cda0058ab4b476a9a8fc43", + "size": 76264, + "subdir": "linux-64", + "timestamp": 1541440788081, + "version": "1.18.0" + }, + "pycairo-1.18.1-py27h2a1e443_0.tar.bz2": { + "build": "py27h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "eed917e0ed3e42c8d240095cab62ed67", + "name": "pycairo", + "sha256": "b1c173b68068e5e4fc30ccda41b97a5322367dae8bf52fbb6f5a2f887a739de5", + "size": 77375, + "subdir": "linux-64", + "timestamp": 1555954983602, + "version": "1.18.1" + }, + "pycairo-1.18.1-py36h2a1e443_0.tar.bz2": { + "build": "py36h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "626f103d4f2c66c35879cb2f95fdba52", + "name": "pycairo", + "sha256": "9002b17bfef5b01456e243b2b6ee33847fa3e301c42e6bcf68ac542601157ef5", + "size": 77590, + "subdir": "linux-64", + "timestamp": 1555955003640, + "version": "1.18.1" + }, + "pycairo-1.18.1-py37h2a1e443_0.tar.bz2": { + "build": "py37h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "3bb862de97d1426f7175b8b002532190", + "name": "pycairo", + "sha256": "c5e301216fcde9c523ad7c85160e45c73f4dc0552586f77981dab195126c6c45", + "size": 77596, + "subdir": "linux-64", + "timestamp": 1555954992079, + "version": "1.18.1" + }, + "pycairo-1.18.2-py27h2a1e443_0.tar.bz2": { + "build": "py27h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "ed71055e7b416c0c404e2e9fc83637eb", + "name": "pycairo", + "sha256": "6792e3229450ce76798503e65bf0f2362f328f00b2ce400a17f0562fe4810f21", + "size": 78246, + "subdir": "linux-64", + "timestamp": 1573081357553, + "version": "1.18.2" + }, + "pycairo-1.18.2-py36h2a1e443_0.tar.bz2": { + "build": "py36h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "c0207b7cb48a80d37944e28d8a12d694", + "name": "pycairo", + "sha256": "a78cadbd9aaa5f3a7e06873a28b8c5449314e7d4eedd67ae91af7d90c7e8d16a", + "size": 78490, + "subdir": "linux-64", + "timestamp": 1573081029073, + "version": "1.18.2" + }, + "pycairo-1.18.2-py37h2a1e443_0.tar.bz2": { + "build": "py37h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "75c9f869acd47e53f1c8939eae5c717b", + "name": "pycairo", + "sha256": "b9acff2c77fc252132152cd5b3bcf8df651585e121c3963cd6210c4a2e5c907e", + "size": 78438, + "subdir": "linux-64", + "timestamp": 1573081382169, + "version": "1.18.2" + }, + "pycairo-1.18.2-py38h2a1e443_0.tar.bz2": { + "build": "py38h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "8262007771d4ed9b6287df85ca4d5ef2", + "name": "pycairo", + "sha256": "d3974729922b935a62a120f2b92a0cb0360fa8a340ff1be8b67c707aa7d65ea1", + "size": 79187, + "subdir": "linux-64", + "timestamp": 1573081554699, + "version": "1.18.2" + }, + "pycairo-1.19.0-py36h2a1e443_0.tar.bz2": { + "build": "py36h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "821f0f35234a08f40af26ccd74d12a77", + "name": "pycairo", + "sha256": "42e5c898e2d60b8bd48f43375976c247eee1d621ffa325d3ea8c79f18aeabbc0", + "size": 78530, + "subdir": "linux-64", + "timestamp": 1580838524187, + "version": "1.19.0" + }, + "pycairo-1.19.0-py37h2a1e443_0.tar.bz2": { + "build": "py37h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "de5dd780627e1953dd393e7823e386de", + "name": "pycairo", + "sha256": "e62a547b2dffc3f69220eea6ef81db7231e22fcbfbf6beb141325f93bc9ebfec", + "size": 78540, + "subdir": "linux-64", + "timestamp": 1580838500441, + "version": "1.19.0" + }, + "pycairo-1.19.0-py38h2a1e443_0.tar.bz2": { + "build": "py38h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "0685d01467a29f0dffea2ad9455848e6", + "name": "pycairo", + "sha256": "37e5b99c8bbec392b28acab0f180e96aab777687cd51bc8fc80e1d30a2eec270", + "size": 79208, + "subdir": "linux-64", + "timestamp": 1580838624031, + "version": "1.19.0" + }, + "pycairo-1.19.1-py310he41a700_0.tar.bz2": { + "build": "py310he41a700_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "86cc3df285a49ae09da465bf0fd61afd", + "name": "pycairo", + "sha256": "4cc36233f2cefe9ed9881aad89120fceb0fd24502f2479de9cade40c95712274", + "size": 227244, + "subdir": "linux-64", + "timestamp": 1640792776581, + "version": "1.19.1" + }, + "pycairo-1.19.1-py36h2a1e443_0.tar.bz2": { + "build": "py36h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "613d3f8e67f181af27cb430ed0950af4", + "name": "pycairo", + "sha256": "e720b9bf2870f8c603be5735a3187c9ab43d34bddaad16fb8aee3b86d0ba3d7e", + "size": 78623, + "subdir": "linux-64", + "timestamp": 1593109585977, + "version": "1.19.1" + }, + "pycairo-1.19.1-py36h708ec4a_0.tar.bz2": { + "build": "py36h708ec4a_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "85c59e063006008e8d031a58b7a9fa5d", + "name": "pycairo", + "sha256": "961899314e3b97bb1135dec6d2f59b0b3ecb5d5966c81b2fad7f6bac738974f6", + "size": 78816, + "subdir": "linux-64", + "timestamp": 1614246496330, + "version": "1.19.1" + }, + "pycairo-1.19.1-py37h2a1e443_0.tar.bz2": { + "build": "py37h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "326192cb62411af2f183e024f82c97ad", + "name": "pycairo", + "sha256": "8b9fd0c68f1c87cae3e6af4aec7a7edd2e41a125b152eb9740c325b7c2dd75e2", + "size": 78547, + "subdir": "linux-64", + "timestamp": 1593109592234, + "version": "1.19.1" + }, + "pycairo-1.19.1-py37h708ec4a_0.tar.bz2": { + "build": "py37h708ec4a_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "ba9378e6a69af6f1bca9f6bd60da9adc", + "name": "pycairo", + "sha256": "9d294a72547b796c44b0457e4c4a6d7ced57ae1bd8ede6d231fed3461a1827d4", + "size": 78822, + "subdir": "linux-64", + "timestamp": 1614247356550, + "version": "1.19.1" + }, + "pycairo-1.19.1-py38h2a1e443_0.tar.bz2": { + "build": "py38h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "bda40fbe6b0196a5e452cc752bfdee20", + "name": "pycairo", + "sha256": "601c5604cb719726b2a6b989aa3cbd6346c9d8286fe4982c034f05045e5d931f", + "size": 79169, + "subdir": "linux-64", + "timestamp": 1593109594395, + "version": "1.19.1" + }, + "pycairo-1.19.1-py38h708ec4a_0.tar.bz2": { + "build": "py38h708ec4a_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "74e26b769e1615c3e66f72d2133a218e", + "name": "pycairo", + "sha256": "c99e00c0ec5157f9e5c0bc18fb04cb996075d3c58fa4bc6f2405d9649b0a021e", + "size": 79357, + "subdir": "linux-64", + "timestamp": 1614247360963, + "version": "1.19.1" + }, + "pycairo-1.19.1-py39h708ec4a_0.tar.bz2": { + "build": "py39h708ec4a_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "4c48cc79d19833b59ba41abeebe4e2c8", + "name": "pycairo", + "sha256": "35889a771df9bd2e992f2438f688810d62a40c9feec6f7a5c9ab24886f50962c", + "size": 79465, + "subdir": "linux-64", + "timestamp": 1614247353534, + "version": "1.19.1" + }, + "pycairo-1.21.0-py310h287db57_0.tar.bz2": { + "build": "py310h287db57_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1-only OR MPL-1.1", + "license_family": "LGPL", + "md5": "832b536dffbedc5d6bc0e72a99ade7e8", + "name": "pycairo", + "sha256": "0320c531409187682346fc7aad170e40b6662a0d25b1bf5a0b04a4c3a14ebbee", + "size": 127882, + "subdir": "linux-64", + "timestamp": 1656618788946, + "version": "1.21.0" + }, + "pycairo-1.21.0-py311h287db57_0.tar.bz2": { + "build": "py311h287db57_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.1-only OR MPL-1.1", + "license_family": "LGPL", + "md5": "b22ef8e446e92e76b9d3b926456dc6f0", + "name": "pycairo", + "sha256": "767b8ed73e622d578e960db3b28de89d2dd99911a6e3605414d8e8bbf06ace68", + "size": 128550, + "subdir": "linux-64", + "timestamp": 1676860629114, + "version": "1.21.0" + }, + "pycairo-1.21.0-py37h287db57_0.tar.bz2": { + "build": "py37h287db57_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-only OR MPL-1.1", + "license_family": "LGPL", + "md5": "8f2421095a24071b76df84352d061bb5", + "name": "pycairo", + "sha256": "8e460427018c0c0a0c822ab6e411ff9f8da4598043420185743d3aab2d606e30", + "size": 127554, + "subdir": "linux-64", + "timestamp": 1656618689680, + "version": "1.21.0" + }, + "pycairo-1.21.0-py38h287db57_0.tar.bz2": { + "build": "py38h287db57_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-only OR MPL-1.1", + "license_family": "LGPL", + "md5": "dd2aefa5163623876ae8e8717eddc5a6", + "name": "pycairo", + "sha256": "205a226691a7af79f902bf04f5dd5e6023dd41892017d4f58266b869c45d2ea3", + "size": 127955, + "subdir": "linux-64", + "timestamp": 1656618833017, + "version": "1.21.0" + }, + "pycairo-1.21.0-py39h287db57_0.tar.bz2": { + "build": "py39h287db57_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-only OR MPL-1.1", + "license_family": "LGPL", + "md5": "ecc4ee340efe368ff357ec0bc1f48647", + "name": "pycairo", + "sha256": "d6ac4a3a4eac5d4c60c909f2a95ba7e77bc0c5cdebe2785771e5f7cc1b374ad2", + "size": 127641, + "subdir": "linux-64", + "timestamp": 1656618733221, + "version": "1.21.0" + }, + "pycairo-1.23.0-py310hd1222b9_0.tar.bz2": { + "build": "py310hd1222b9_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1-only OR MPL-1.1", + "license_family": "LGPL", + "md5": "51d0fd019530626b26f40749849a96be", + "name": "pycairo", + "sha256": "3170bd582b63bb733fde34a6f3cad877f55a149f02832a39782a909e58046b7e", + "size": 129090, + "subdir": "linux-64", + "timestamp": 1680531122418, + "version": "1.23.0" + }, + "pycairo-1.23.0-py311hd1222b9_0.tar.bz2": { + "build": "py311hd1222b9_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.1-only OR MPL-1.1", + "license_family": "LGPL", + "md5": "f40a42a55be317198f991252d6c42435", + "name": "pycairo", + "sha256": "bc49d15daf8590cda91fbf6ab2b4ea3f7d3c0e981b44ef55132b78ff49e528c6", + "size": 129416, + "subdir": "linux-64", + "timestamp": 1680531170228, + "version": "1.23.0" + }, + "pycairo-1.23.0-py38hd1222b9_0.tar.bz2": { + "build": "py38hd1222b9_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-only OR MPL-1.1", + "license_family": "LGPL", + "md5": "5d698b024b756e35147294f9ede52b27", + "name": "pycairo", + "sha256": "c6a7ed99a5214723a738826738335ed72a42c0791b156a2081f7ac51b23c288a", + "size": 129137, + "subdir": "linux-64", + "timestamp": 1680531263366, + "version": "1.23.0" + }, + "pycairo-1.23.0-py39hd1222b9_0.tar.bz2": { + "build": "py39hd1222b9_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-only OR MPL-1.1", + "license_family": "LGPL", + "md5": "464dfe7eacc4d9f828287703b683ecd6", + "name": "pycairo", + "sha256": "01b9ba79ecc808c887388b4b5694ab37f20c6e5af7ddd91af431c1848deba838", + "size": 129199, + "subdir": "linux-64", + "timestamp": 1680531216512, + "version": "1.23.0" + }, + "pycares-3.1.1-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d8cfc47411c8f981f6ece1e1c73c286", + "name": "pycares", + "sha256": "bf44003bf0c4f331c1f6c922dc1ff5ed45880c6f3e8bda65f4e3b7577c322896", + "size": 85538, + "subdir": "linux-64", + "timestamp": 1613479115305, + "version": "3.1.1" + }, + "pycares-3.1.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f8e52f8914fb6ac60192e8ef3b71460", + "name": "pycares", + "sha256": "c83a4f42220601b946187efdb2861dd8996027f4d2f6eb3be36788d045c0ea57", + "size": 85406, + "subdir": "linux-64", + "timestamp": 1592521957201, + "version": "3.1.1" + }, + "pycares-3.1.1-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "67c4ce2dcb5cddc514b7c26db7180a47", + "name": "pycares", + "sha256": "55d418c4164873bb74a9d6883ba08162875a31a60b1b4b3e211f3163516dab7d", + "size": 85520, + "subdir": "linux-64", + "timestamp": 1613479867001, + "version": "3.1.1" + }, + "pycares-3.1.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd1f74f1d03ef43ef7be3568d78df365", + "name": "pycares", + "sha256": "6a7633c362f9f365c83f311cc2947f7999b75f36a86915ef537b0328b7e3d49d", + "size": 85499, + "subdir": "linux-64", + "timestamp": 1592521918294, + "version": "3.1.1" + }, + "pycares-3.1.1-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "24ff253153cd07ec993f1fbde0405129", + "name": "pycares", + "sha256": "293ca2036f231fda2d812306e8a2d557fd9f6dbe68df7adc5616c7d0e877299e", + "size": 85573, + "subdir": "linux-64", + "timestamp": 1613479245027, + "version": "3.1.1" + }, + "pycares-3.1.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5483c411350d2730165b0d672456ee78", + "name": "pycares", + "sha256": "ec52c5e680bab0f392dfe343196c9bacbb194ed36a4bd7f8d895ac152fb7fe52", + "size": 85464, + "subdir": "linux-64", + "timestamp": 1592521957352, + "version": "3.1.1" + }, + "pycares-3.1.1-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a965f7606239e1d140fd7cf5d91537f1", + "name": "pycares", + "sha256": "9307c074c2fa38594a5bb51291201e366dee8c95cbd385b3309f869b041c731c", + "size": 85487, + "subdir": "linux-64", + "timestamp": 1613479872247, + "version": "3.1.1" + }, + "pycares-4.0.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "idna >=2.1", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cf50062fb783cd34b6b902516c70cdba", + "name": "pycares", + "sha256": "14aeef7d4801ea910e335f04d237671fa5de958ce6a1a5952493692b366dcc5d", + "size": 268779, + "subdir": "linux-64", + "timestamp": 1640810233019, + "version": "4.0.0" + }, + "pycares-4.0.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "idna >=2.1", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d5d5cccc88f7848e2a20ce05d4b9fae", + "name": "pycares", + "sha256": "424e9eeb02de8a2b1bddda40a6c7055a793597934d4b6a5e7e0ee2f8d9dda322", + "size": 102397, + "subdir": "linux-64", + "timestamp": 1676842064910, + "version": "4.0.0" + }, + "pycares-4.0.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d0b369b8436d7d9ffa240d8074c923e6", + "name": "pycares", + "sha256": "0ef1094d5589c907aa65a6176ed1d46c57cd11cc41519d479c9b305e0218a779", + "size": 94128, + "subdir": "linux-64", + "timestamp": 1621340186943, + "version": "4.0.0" + }, + "pycares-4.0.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ea2ee445eb8c3d215a8d10ae629a0f1", + "name": "pycares", + "sha256": "119e2e3302db8f1524c0798ad5c41bbaf1b42cdffa47a954b4b072d063673697", + "size": 94010, + "subdir": "linux-64", + "timestamp": 1621340192654, + "version": "4.0.0" + }, + "pycares-4.0.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e7cc1472d79e23d6e69a3eaba42804c", + "name": "pycares", + "sha256": "3e4df09976a10612e50ccbc945e849f4edefd5b154fefb81b181fc25837913a8", + "size": 94008, + "subdir": "linux-64", + "timestamp": 1621340195661, + "version": "4.0.0" + }, + "pycares-4.0.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a2b5fb7062621f0975e7c87598cf5932", + "name": "pycares", + "sha256": "d6a505591a997e25b210ad4afca7ebbb7f7e5b6ae33934d1b718d9cac7803ace", + "size": 94343, + "subdir": "linux-64", + "timestamp": 1621340191496, + "version": "4.0.0" + }, + "pyclipper-1.2.0-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dcfab4b6f3278203159ee6e0d3892207", + "name": "pyclipper", + "sha256": "6b9f7d4f3db355c16888f3cc256311e6ec91290be6f0899572bdc932ef1c1621", + "size": 128129, + "subdir": "linux-64", + "timestamp": 1605228006458, + "version": "1.2.0" + }, + "pyclipper-1.2.0-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "04017ba39752b287f8d088d8fd9dbc92", + "name": "pyclipper", + "sha256": "0df3b73e445d06d1b34f04f6ad891f74ecfa10af0d142f9fee488b17d7e3d7c2", + "size": 127865, + "subdir": "linux-64", + "timestamp": 1605227994047, + "version": "1.2.0" + }, + "pyclipper-1.2.0-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "20e8a673a0d16d0cd95819b506c0aaf1", + "name": "pyclipper", + "sha256": "91d8b9e8cbf9127a31422b9c1c8d765d9e893cb2667d54a9484af153a7797729", + "size": 130301, + "subdir": "linux-64", + "timestamp": 1605228002321, + "version": "1.2.0" + }, + "pyclipper-1.2.1-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b03f04d2594f9e410bde93e2038ef05e", + "name": "pyclipper", + "sha256": "369d0dfb29ddf49f3952379a3b48ecb2afeba9a9ae356f42af8743210977c4f5", + "size": 126336, + "subdir": "linux-64", + "timestamp": 1609094854639, + "version": "1.2.1" + }, + "pyclipper-1.2.1-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a228740c8651ede252869aecf34f4b2", + "name": "pyclipper", + "sha256": "52f861fb244ad5a7fee4a099382debc1ce958677f8cf4c53c366c2f0a4331f20", + "size": 126024, + "subdir": "linux-64", + "timestamp": 1609094860691, + "version": "1.2.1" + }, + "pyclipper-1.2.1-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b26c2f64cd5007aa0c5e57ee68e1c03", + "name": "pyclipper", + "sha256": "4a047c3c29e5130088de5ad1ec19e642962c1c5786a67f5b399d08f53a277677", + "size": 128405, + "subdir": "linux-64", + "timestamp": 1609094865680, + "version": "1.2.1" + }, + "pyclipper-1.2.1-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d89e6b37b6e877364d582bb66e91d77", + "name": "pyclipper", + "sha256": "4482122e2f3128b4fe26cfd23706b80bb50f9d1ebdf854c6c3367c278b9966d4", + "size": 128276, + "subdir": "linux-64", + "timestamp": 1609094833590, + "version": "1.2.1" + }, + "pyclipper-1.3.0-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ec81b9fd460beef0a0b64fffabd2b7b", + "name": "pyclipper", + "sha256": "eb5fc7e0e7c600385d88da463b759b9e78dcc8a5f6a767839e636c759104a2d2", + "size": 615519, + "subdir": "linux-64", + "timestamp": 1640792809393, + "version": "1.3.0" + }, + "pyclipper-1.3.0-py36h295c915_0.tar.bz2": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "794ba3c501379c0d665fc1e871cab854", + "name": "pyclipper", + "sha256": "1e4bce1bef7ce3a1926a6ad7a92ff647353f15711923beb98800a2da2e87a959", + "size": 125084, + "subdir": "linux-64", + "timestamp": 1626196801309, + "version": "1.3.0" + }, + "pyclipper-1.3.0-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "29081c5500dfab1d70405f5ebf7a2e52", + "name": "pyclipper", + "sha256": "ad0963fceed953962d00c6c80f0cdf24f969beaab8eff6a651b91822539e80e2", + "size": 124802, + "subdir": "linux-64", + "timestamp": 1626203816846, + "version": "1.3.0" + }, + "pyclipper-1.3.0-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "096e51632f861bbef0dfe6ee46bc0423", + "name": "pyclipper", + "sha256": "7e102b2da4a112fdb7b67e5931049ab1612a3fa32a3189ac1ce59ce2ae9809b3", + "size": 126791, + "subdir": "linux-64", + "timestamp": 1626203815262, + "version": "1.3.0" + }, + "pyclipper-1.3.0-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa094529b8d4f10088e658dfac33ebdb", + "name": "pyclipper", + "sha256": "d58771100a4dacbd28fac330d32228c4257f8ca2f34ef7e9b996e928f1bb9407", + "size": 126551, + "subdir": "linux-64", + "timestamp": 1626203528114, + "version": "1.3.0" + }, + "pyclipper-1.3.0.post3-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT and BSL-1.0", + "license_family": "MIT", + "md5": "9d0c991f10d1c89762445031bcfbd1c3", + "name": "pyclipper", + "sha256": "6c71f158a4ffc8edd2b009f88c8ca1f646e14ee74df2b2f5fc7a42abaabf4810", + "size": 789636, + "subdir": "linux-64", + "timestamp": 1664521741703, + "version": "1.3.0.post3" + }, + "pyclipper-1.3.0.post3-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT and BSL-1.0", + "license_family": "MIT", + "md5": "7e64ac2f0cf65cbd7b8de684571ff12a", + "name": "pyclipper", + "sha256": "25fe8cdfb80180c6f2c369f74256a8829b1815d7799605fbc6f62f7bfce24b8a", + "size": 129754, + "subdir": "linux-64", + "timestamp": 1676860654563, + "version": "1.3.0.post3" + }, + "pyclipper-1.3.0.post3-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT and BSL-1.0", + "license_family": "MIT", + "md5": "c8160f27c81559e79ed9d7da80e0deb6", + "name": "pyclipper", + "sha256": "86d5458142ef841d60189ce66b67550bea0a84ee9981c70da6ae8e2607262324", + "size": 129143, + "subdir": "linux-64", + "timestamp": 1664521681509, + "version": "1.3.0.post3" + }, + "pyclipper-1.3.0.post3-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT and BSL-1.0", + "license_family": "MIT", + "md5": "08c561f3b3731652314950e9a2355643", + "name": "pyclipper", + "sha256": "146c273d890ecbeeb4bd9ef3e039e42dd4132575fc2611e03bb99bc1c48ef489", + "size": 130527, + "subdir": "linux-64", + "timestamp": 1664521640441, + "version": "1.3.0.post3" + }, + "pyclipper-1.3.0.post3-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT and BSL-1.0", + "license_family": "MIT", + "md5": "6e8de16a9a7d0444342a3338e6c163b7", + "name": "pyclipper", + "sha256": "8d4df7e1c5a6d640590c3d732c9d2e106a12b2048c3775e55e2df9305b9e31a7", + "size": 129514, + "subdir": "linux-64", + "timestamp": 1664521783891, + "version": "1.3.0.post3" + }, + "pycodestyle-2.10.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "907f1ef7c9d6b0be61475b6278086eb5", + "name": "pycodestyle", + "sha256": "1d9134f8dc1fcd80753a829334451b305340d57a2e80124191232254606b9621", + "size": 64313, + "subdir": "linux-64", + "timestamp": 1674267300744, + "version": "2.10.0" + }, + "pycodestyle-2.10.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "afa2d002a66f3af1280c48d4a44feef7", + "name": "pycodestyle", + "sha256": "36626de874cb37dc20c8ff14f6ec3f91b55c9ed86868fae7339de431a6b7cbbd", + "size": 81784, + "subdir": "linux-64", + "timestamp": 1677708807333, + "version": "2.10.0" + }, + "pycodestyle-2.10.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1fc3516a1ffaed536eaa08e85ff1c56d", + "name": "pycodestyle", + "sha256": "2502d33b041b757f4d6bcff356baef99532236f2abe4c7f793404188b0bcacfe", + "size": 63909, + "subdir": "linux-64", + "timestamp": 1674267325646, + "version": "2.10.0" + }, + "pycodestyle-2.10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a4fa91ca0de724869ffed264ae99a63f", + "name": "pycodestyle", + "sha256": "4069ef4de0838d63470676e5b54c08ea371fee3be2fdd0737dcc69726fc97b29", + "size": 64143, + "subdir": "linux-64", + "timestamp": 1674267250691, + "version": "2.10.0" + }, + "pycodestyle-2.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "748bae50318b6b4ae477d211f8eb9eba", + "name": "pycodestyle", + "sha256": "2ebc377f9cdeefd5bf593c9f62355c1096bce977de73a3e24f14cb16249f01db", + "size": 64082, + "subdir": "linux-64", + "timestamp": 1674267275705, + "version": "2.10.0" + }, + "pycodestyle-2.3.1-py27h904819d_0.tar.bz2": { + "build": "py27h904819d_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "46b97d28b6c97612f829801921b1f027", + "name": "pycodestyle", + "sha256": "66dff1ee48ba47ade5b378e86382ae591fdecc7996e55ba81cdbaa3106f9cdd0", + "size": 55464, + "subdir": "linux-64", + "timestamp": 1505743034562, + "version": "2.3.1" + }, + "pycodestyle-2.3.1-py35h8d2105a_0.tar.bz2": { + "build": "py35h8d2105a_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a5cbf835ea513ab718e5a2bf68bd8007", + "name": "pycodestyle", + "sha256": "8bc82614de20309d353452af736be2556a0d1b3e5344dfc4f7bc1fae02a6dd75", + "size": 56233, + "subdir": "linux-64", + "timestamp": 1505743046270, + "version": "2.3.1" + }, + "pycodestyle-2.3.1-py36hf609f19_0.tar.bz2": { + "build": "py36hf609f19_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45e5192f0865debba2bbbf1c4f5838aa", + "name": "pycodestyle", + "sha256": "e87d228817bef1863db2a211316a73cc75c1b184576924a1f53d02cead5cc965", + "size": 55985, + "subdir": "linux-64", + "timestamp": 1505743058118, + "version": "2.3.1" + }, + "pycodestyle-2.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8163a87fb69b1d994a4fe7d7fde32e37", + "name": "pycodestyle", + "sha256": "930dfd3e5604611bfc4633a2576d107ee3f91fa0f4967c8f16652a31c6d2c41b", + "size": 59409, + "subdir": "linux-64", + "timestamp": 1523431231057, + "version": "2.4.0" + }, + "pycodestyle-2.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a15d5b53739e63c78369b751277eada4", + "name": "pycodestyle", + "sha256": "4dac03c7de0ac34c4fd4a6887af335c5757e918ab5c5a39fcc4cc13ae84b6280", + "size": 60278, + "subdir": "linux-64", + "timestamp": 1523431419456, + "version": "2.4.0" + }, + "pycodestyle-2.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "369b7996d05cc827508b85e6e717a961", + "name": "pycodestyle", + "sha256": "ee340cfc37f5e14e1ce5c5556b7943dbf20a365e91aeaf92b64f58e0f8d65728", + "size": 60061, + "subdir": "linux-64", + "timestamp": 1523431292755, + "version": "2.4.0" + }, + "pycodestyle-2.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4a6b841cc114c7d1b5db157ea38f9e8e", + "name": "pycodestyle", + "sha256": "08113740fae51305ee9c5a277c7d4daf43abfe610cfe516921be71a94d4ea9cb", + "size": 59799, + "subdir": "linux-64", + "timestamp": 1530812671772, + "version": "2.4.0" + }, + "pycodestyle-2.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba3a2cb4ce4d9a5152d3b33d3f5fba1d", + "name": "pycodestyle", + "sha256": "10de60a3c2e1eab793f632887b58af721b1595854dc5e95ec999588bfe5a42cf", + "size": 61229, + "subdir": "linux-64", + "timestamp": 1549337982411, + "version": "2.5.0" + }, + "pycodestyle-2.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ac4332be7f738ab3188c55cdb0ce80af", + "name": "pycodestyle", + "sha256": "7c77b28d6afd3ac9c68a60abecf4ac5732585054f44a16f6b7290f3606908628", + "size": 61710, + "subdir": "linux-64", + "timestamp": 1549328766162, + "version": "2.5.0" + }, + "pycodestyle-2.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c77c3e8d732e7c383bf0ad7d63292c5", + "name": "pycodestyle", + "sha256": "dde1ba79d2c49735114118c5fc9c2e73401d490c164f08ccec6fb84814628a87", + "size": 61508, + "subdir": "linux-64", + "timestamp": 1549337996211, + "version": "2.5.0" + }, + "pycodestyle-2.5.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4df02821768a934e2177420fda5ed7b8", + "name": "pycodestyle", + "sha256": "0984c252660e1601803480f635a0e7fe360d2ca4e3526f96c476b9135351e2fe", + "size": 61934, + "subdir": "linux-64", + "timestamp": 1573662738408, + "version": "2.5.0" + }, + "pycosat-0.6.2-py27h1cf261c_1.tar.bz2": { + "build": "py27h1cf261c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "305686a4b7f2fae3ca6786a7cd9083c6", + "name": "pycosat", + "sha256": "244851531c02b6f7145385475c7e5c478ad1a72d87bf6652fdddf7e62e927c04", + "size": 105815, + "subdir": "linux-64", + "timestamp": 1505742082091, + "version": "0.6.2" + }, + "pycosat-0.6.2-py35h9693557_1.tar.bz2": { + "build": "py35h9693557_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "12d7766424cdf2670cf3494c61306938", + "name": "pycosat", + "sha256": "031cd6e2819dc49fa824d624715d0d19efb839fc455167794cde703f6ae73d9c", + "size": 106335, + "subdir": "linux-64", + "timestamp": 1505742100736, + "version": "0.6.2" + }, + "pycosat-0.6.2-py36h1a0ea17_1.tar.bz2": { + "build": "py36h1a0ea17_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3129e14e67fea728c64c2dd882d5a0af", + "name": "pycosat", + "sha256": "1420c4869fa2a5dcb1b8fdb27d9f79a1429a35357502081824d006964ac12f06", + "size": 106560, + "subdir": "linux-64", + "timestamp": 1505742119471, + "version": "0.6.2" + }, + "pycosat-0.6.3-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "38298e902f033d650e4c7defe156c06f", + "name": "pycosat", + "sha256": "0a550784a13267ea8c4981068180b442736f5dcf64591a2f5f9c888f838dec02", + "size": 105808, + "subdir": "linux-64", + "timestamp": 1530812765823, + "version": "0.6.3" + }, + "pycosat-0.6.3-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e8ec4a7cd42ee451c9b7d1fcb03b1759", + "name": "pycosat", + "sha256": "cd4ec071d95da395942984979ef74c639f9db23d383834b96f4dd01c037e6fbc", + "size": 109687, + "subdir": "linux-64", + "timestamp": 1576875191844, + "version": "0.6.3" + }, + "pycosat-0.6.3-py27ha4109ae_0.tar.bz2": { + "build": "py27ha4109ae_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9d84f1e6668e64fe41a8861f8cccf0fc", + "name": "pycosat", + "sha256": "1045c5d24f8d22c65a5a944e96a94dca810e09a8b867a22d4fd4fc934ff81fd4", + "size": 105938, + "subdir": "linux-64", + "timestamp": 1509357302743, + "version": "0.6.3" + }, + "pycosat-0.6.3-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "0c6dad59a3dc0fa29feb4e0da5389d4f", + "name": "pycosat", + "sha256": "bde8491e7ed9a137355b963d3556f3c6916b07517811b7512073c23b9763521d", + "size": 210750, + "subdir": "linux-64", + "timestamp": 1640792835472, + "version": "0.6.3" + }, + "pycosat-0.6.3-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "9aaf69a9fbd7cb0c6731e9cc7ebfa1bb", + "name": "pycosat", + "sha256": "6319827013714b6e1aae98cf648da52addc3dc4ba57fc878c62e07c67791458c", + "size": 107441, + "subdir": "linux-64", + "timestamp": 1535130168795, + "version": "0.6.3" + }, + "pycosat-0.6.3-py35h6b6bb97_0.tar.bz2": { + "build": "py35h6b6bb97_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "eedc9a02666fa213f8168c2b68759b6e", + "name": "pycosat", + "sha256": "d96163536032c9c7493a01a8c99365137d0e87f1ee753877d68ab6491c65ee7f", + "size": 106911, + "subdir": "linux-64", + "timestamp": 1509357322619, + "version": "0.6.3" + }, + "pycosat-0.6.3-py36h0a5515d_0.tar.bz2": { + "build": "py36h0a5515d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "25c65a127368d11fb9d6b8ffeee1b050", + "name": "pycosat", + "sha256": "1106edce84606061209a0ea4ca9d22d1462d1bc435be08f3d77f7c24fbae4c4c", + "size": 106631, + "subdir": "linux-64", + "timestamp": 1509357342673, + "version": "0.6.3" + }, + "pycosat-0.6.3-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "795f6d33bec5a4dacbe476c95464d76d", + "name": "pycosat", + "sha256": "9c8a040ffd2a9f144f528be979b8269ae450fcd2b17898dab35809b657435dae", + "size": 106026, + "subdir": "linux-64", + "timestamp": 1530812821149, + "version": "0.6.3" + }, + "pycosat-0.6.3-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "af4be58d42bf50fb20fb03faa5a2da75", + "name": "pycosat", + "sha256": "a1f94f7dab507a25dad02f65c58db17afca555c6bc0749616cfa998b31742233", + "size": 110058, + "subdir": "linux-64", + "timestamp": 1605545868440, + "version": "0.6.3" + }, + "pycosat-0.6.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2e9ade6c221471fff4d060c9fd8215a4", + "name": "pycosat", + "sha256": "336f37e59fac3c1ebdba6d16f395c5bea47797b423c0af4c8c118618574358c7", + "size": 109486, + "subdir": "linux-64", + "timestamp": 1576875237881, + "version": "0.6.3" + }, + "pycosat-0.6.3-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2011c86dd3774e1853cca627f4495f0e", + "name": "pycosat", + "sha256": "9019910221d47de9bc8786d64cc3abbc44d3582cde33adcd9583627c480c3be5", + "size": 107368, + "subdir": "linux-64", + "timestamp": 1530812793022, + "version": "0.6.3" + }, + "pycosat-0.6.3-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b0c60213bc5cdaa1c607b5dbffed0460", + "name": "pycosat", + "sha256": "abbd8f7b4f64d665f7e4b50e7d647aed8b8eabc8d009d7101c26208ab1083500", + "size": 110625, + "subdir": "linux-64", + "timestamp": 1605545871945, + "version": "0.6.3" + }, + "pycosat-0.6.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "0ac4745aa31bc15ea5999f86b601b293", + "name": "pycosat", + "sha256": "b7835c96f699060b306856158a3857ad75e8cb5f31450dd2e68e3bfe9c296ecb", + "size": 109427, + "subdir": "linux-64", + "timestamp": 1576875211158, + "version": "0.6.3" + }, + "pycosat-0.6.3-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "bf3b021b38eb5c01df3e7ce0b08420e7", + "name": "pycosat", + "sha256": "98411c652de061f520608579fbb603cbc31b24803cfe8497b04143340191a549", + "size": 109952, + "subdir": "linux-64", + "timestamp": 1605545859253, + "version": "0.6.3" + }, + "pycosat-0.6.3-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "601c563def7cba51c0d788e5f54fa908", + "name": "pycosat", + "sha256": "7256058bb185c5ceb6e6708939b8405b0419831d66ff6b8eaa401ae8ed930880", + "size": 115827, + "subdir": "linux-64", + "timestamp": 1573668802680, + "version": "0.6.3" + }, + "pycosat-0.6.3-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "aa60e2397c45873d233be8f41ad22ede", + "name": "pycosat", + "sha256": "f16635bfe19e0f6c18992c6789107773fddea16a167c72a413c84343cb73a0d6", + "size": 109687, + "subdir": "linux-64", + "timestamp": 1588116986637, + "version": "0.6.3" + }, + "pycosat-0.6.3-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "cdb27dc2c863469bab93d23c26ea56bc", + "name": "pycosat", + "sha256": "e869acea479240f7a943e56018792d27708ee3d3bd0d0b6f42cb99b411db7d58", + "size": 111019, + "subdir": "linux-64", + "timestamp": 1605545841785, + "version": "0.6.3" + }, + "pycosat-0.6.4-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef1aed8b8feea95b9232abbf20abec4b", + "name": "pycosat", + "sha256": "a98d330c751b5df39eac642b74b454c46b1f335a36d9db61045b6c2a0b5af672", + "size": 110053, + "subdir": "linux-64", + "timestamp": 1666805641437, + "version": "0.6.4" + }, + "pycosat-0.6.4-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7f0f23d42490df5f7be95bb9dd7e6a4", + "name": "pycosat", + "sha256": "2a41822bef492951df98a957165d6634706844d284b5cd4895f2f00d59467c68", + "size": 114538, + "subdir": "linux-64", + "timestamp": 1676838542087, + "version": "0.6.4" + }, + "pycosat-0.6.4-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2bda984e1a348e915a62d8bad370ac01", + "name": "pycosat", + "sha256": "d790befa636f02aece4f560f35f7e2d557b137cc725a73aed671bd3dc6ec4273", + "size": 112583, + "subdir": "linux-64", + "timestamp": 1666805610529, + "version": "0.6.4" + }, + "pycosat-0.6.4-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c76d63966b1cd65ceb03b048bcb967dd", + "name": "pycosat", + "sha256": "4a0fa8a526eb9e757d6e5153203cf204adb982253797c7751dc97737ba0270e5", + "size": 112539, + "subdir": "linux-64", + "timestamp": 1666805578320, + "version": "0.6.4" + }, + "pycosat-0.6.4-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "50189110546f2dff3a03958320481dd3", + "name": "pycosat", + "sha256": "17d27b67232c6891f95e3a9ab89f840822b7a716030659f29f7d8c737ad56156", + "size": 112199, + "subdir": "linux-64", + "timestamp": 1666805546234, + "version": "0.6.4" + }, + "pycparser-2.18-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "42a8ace49e004c2d83171bb3942d5c1d", + "name": "pycparser", + "sha256": "bff860f32fe96c67eb0417755e3726f88117771ec8a23d5dd22befb80c301dd9", + "size": 171220, + "subdir": "linux-64", + "timestamp": 1530694140145, + "version": "2.18" + }, + "pycparser-2.18-py27hefa08c5_1.tar.bz2": { + "build": "py27hefa08c5_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "bdcdd42dfc0ffe1c524e384170d6c71b", + "name": "pycparser", + "sha256": "8ac4468dc70960f23b5955c06baa7c6869b99e9b6aea6d41aef04abe43d7ad7e", + "size": 170870, + "subdir": "linux-64", + "timestamp": 1505691615710, + "version": "2.18" + }, + "pycparser-2.18-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1ed3754ee0011d5fd73dbc9f86a81c89", + "name": "pycparser", + "sha256": "3bfacb9d7e9ca3a954509fda55ce854a5859c1dcffb2619c38fc1a790dbc40c4", + "size": 174084, + "subdir": "linux-64", + "timestamp": 1534345125332, + "version": "2.18" + }, + "pycparser-2.18-py35h61b3040_1.tar.bz2": { + "build": "py35h61b3040_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4fecf6510d34e313dcdfe6c6efa68c40", + "name": "pycparser", + "sha256": "3d85cfbecbfd4453bfdfb8206f6159db5c06ecf3e2820483cd5de329336dce8f", + "size": 173785, + "subdir": "linux-64", + "timestamp": 1505691628432, + "version": "2.18" + }, + "pycparser-2.18-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a7129033f1916ca4d4a03c76d0131169", + "name": "pycparser", + "sha256": "6fd916f954a0891ae2dbaa553bf9e0bd07269ec7573fc200658658c30c299220", + "size": 173063, + "subdir": "linux-64", + "timestamp": 1530694101212, + "version": "2.18" + }, + "pycparser-2.18-py36hf9f622e_1.tar.bz2": { + "build": "py36hf9f622e_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e001dd2f049ea6d6c77cfe37b73ff3be", + "name": "pycparser", + "sha256": "5be7482ef3012ad6025e56e7e604b825999b6ae8f5f45888b692971fc5de347b", + "size": 172731, + "subdir": "linux-64", + "timestamp": 1505691641245, + "version": "2.18" + }, + "pycparser-2.18-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "354ca0a54d9e79d5160025911d95fa6c", + "name": "pycparser", + "sha256": "815ef28e80b36c40a6bdb8f1a971970d24bc9d4f536d4d23545211a8ade4c09b", + "size": 171296, + "subdir": "linux-64", + "timestamp": 1530694121331, + "version": "2.18" + }, + "pycparser-2.19-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "59eac17b5f6649970db3e74df69fd904", + "name": "pycparser", + "sha256": "b35f35e3ca46a875cc93566ee37151e3bdb0c52ca10c4ac9e3c2896dd251f378", + "size": 177054, + "subdir": "linux-64", + "timestamp": 1538230997120, + "version": "2.19" + }, + "pycparser-2.19-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "599c2e1af451a246d65c5eaeb351db05", + "name": "pycparser", + "sha256": "f8e929d43e4a9a89db804fbe6433077ebc310fbdb85d34c1cd9259105fee8594", + "size": 179574, + "subdir": "linux-64", + "timestamp": 1538231045384, + "version": "2.19" + }, + "pycparser-2.19-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a67637e5b9c21342fd0b1a83e4db11e6", + "name": "pycparser", + "sha256": "1f5a90fa8780ccf2f9515f70a5bd944f5e9845b20c018ee54a8038bd9f2051d2", + "size": 177865, + "subdir": "linux-64", + "timestamp": 1538231037307, + "version": "2.19" + }, + "pycparser-2.19-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f67eb9676934cd89cda7e090fa2401d1", + "name": "pycparser", + "sha256": "633017ab7b064e2333cb74e9382ae5d64ae048ec17b1204969b4813371e9736d", + "size": 175967, + "subdir": "linux-64", + "timestamp": 1538231005324, + "version": "2.19" + }, + "pycrypto-2.6.1-py27h14c3975_7.tar.bz2": { + "build": "py27h14c3975_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "md5": "3b75041a6a2e7eabb95acdad1fb89b1c", + "name": "pycrypto", + "sha256": "395411d8d67796a2b5d3635b547010f48c0bbe1a5a5a37d37ede2bd43f90b02f", + "size": 471584, + "subdir": "linux-64", + "timestamp": 1518031831449, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py27h14c3975_8.tar.bz2": { + "build": "py27h14c3975_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "md5": "e6427a17703c1bf85fb130ed95bcfc15", + "name": "pycrypto", + "sha256": "40cd2da437a8c61b9c00ac591490e7737d380b9fd0040b5cf640a10999d1b260", + "size": 471470, + "subdir": "linux-64", + "timestamp": 1525880640238, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py27h14c3975_9.tar.bz2": { + "build": "py27h14c3975_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "md5": "9c4df2a5f04b6bbda297d702842330ef", + "name": "pycrypto", + "sha256": "fcaf0fc0a1844068bd58af8de6287b405b57bb87997a732bdf965c9917b6ee86", + "size": 471459, + "subdir": "linux-64", + "timestamp": 1530915799669, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py27h9abbf5c_1.tar.bz2": { + "build": "py27h9abbf5c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "md5": "04252d7a682872047d20d78c3e30f40e", + "name": "pycrypto", + "sha256": "852cac6d1530ae5b308b64c4a136194ee76102a0892eb41e14cf0334462fa3f3", + "size": 472264, + "subdir": "linux-64", + "timestamp": 1505751432811, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py310h7f8727e_10.tar.bz2": { + "build": "py310h7f8727e_10", + "build_number": 10, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Public Domain", + "md5": "9b84aacb3633ba57a5143e5359df3284", + "name": "pycrypto", + "sha256": "67a717692dea749ba0746ec11593989b2e23f07080aa30d547065e76fb90aac8", + "size": 702615, + "subdir": "linux-64", + "timestamp": 1640792876112, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py35h14c3975_7.tar.bz2": { + "build": "py35h14c3975_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain", + "md5": "8942ebff773ec47452575746b742384b", + "name": "pycrypto", + "sha256": "e46df67abe333319680664a8664c580d60ac718cdc6a835b13bd23822e89d177", + "size": 482036, + "subdir": "linux-64", + "timestamp": 1518031025722, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py35h14c3975_8.tar.bz2": { + "build": "py35h14c3975_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain", + "md5": "06c17c36ac1e7a5d4f693da292750402", + "name": "pycrypto", + "sha256": "bffac4a87431e2fc69c6430870df1020ab70fd02c22bf84d025113f03aaa5449", + "size": 476795, + "subdir": "linux-64", + "timestamp": 1525880791275, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py35h9852db7_1.tar.bz2": { + "build": "py35h9852db7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain", + "md5": "0c934ccb321a5f73255b1a1bd81b9ec5", + "name": "pycrypto", + "sha256": "794f2beab26b5ec9d176dafc5bbbbeb746a709b1073df27f93de7e5f1963d0ee", + "size": 481919, + "subdir": "linux-64", + "timestamp": 1505751519886, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py36h14c3975_7.tar.bz2": { + "build": "py36h14c3975_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "md5": "8e908832b801c316d19f73188e77c02c", + "name": "pycrypto", + "sha256": "81139b4f6aaad04f141e4e2904b800d256a37fd97f4b9b6c8fc6936fb41b5c6d", + "size": 481723, + "subdir": "linux-64", + "timestamp": 1518032255619, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py36h14c3975_8.tar.bz2": { + "build": "py36h14c3975_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "md5": "3a5df8b855ae4d2501d203ab4858fabe", + "name": "pycrypto", + "sha256": "0198d368fd5e3e93473160c7864bcc194117191d6bb51fef30612132e8161df5", + "size": 477554, + "subdir": "linux-64", + "timestamp": 1525880560244, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py36h14c3975_9.tar.bz2": { + "build": "py36h14c3975_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "md5": "b82a8a7991f545b4082383f07a0225f5", + "name": "pycrypto", + "sha256": "9c20d10022652055c5c5be48a2caccd3a9783cba0e68758222a51a3cf15e6341", + "size": 476560, + "subdir": "linux-64", + "timestamp": 1530915872715, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py36h6998063_1.tar.bz2": { + "build": "py36h6998063_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "md5": "18aadcc30e776de841f0361fcb8c1767", + "name": "pycrypto", + "sha256": "3c8e4027e100dfdbdd46dfa9c996b4bf7d7a74d160347e1b4e4159deb960640d", + "size": 482040, + "subdir": "linux-64", + "timestamp": 1505751622581, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py36h7b6447c_10.tar.bz2": { + "build": "py36h7b6447c_10", + "build_number": 10, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "md5": "d6f394ff1b4360647b4ba5c36e63fd01", + "name": "pycrypto", + "sha256": "c9c06b5777a4b09b86b71c76c4f6d17748157023893cd26e5a7a91d5bc6db3d9", + "size": 533759, + "subdir": "linux-64", + "timestamp": 1592300573143, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py37h14c3975_9.tar.bz2": { + "build": "py37h14c3975_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain", + "md5": "006de193fb90ca2854712ac7d0edcbd0", + "name": "pycrypto", + "sha256": "39bec451b0f16d9a7e61b747736bd2b77f3ee0e7b28b14084694be35f37907f9", + "size": 460890, + "subdir": "linux-64", + "timestamp": 1530915641052, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py37h7b6447c_10.tar.bz2": { + "build": "py37h7b6447c_10", + "build_number": 10, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain", + "md5": "8973f3836c1d6071d2d4e3918a947b2a", + "name": "pycrypto", + "sha256": "2fc6200158865fd8dceb177f7a308dee145e15fb85003e0f789bb4787f748df4", + "size": 508777, + "subdir": "linux-64", + "timestamp": 1592300557782, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py38h7b6447c_10.tar.bz2": { + "build": "py38h7b6447c_10", + "build_number": 10, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain", + "md5": "1d48291dea47280a3449fb72462ed284", + "name": "pycrypto", + "sha256": "caf2328e27325676828cb7b4fa848fc9092840a9e3a71e0915a8bdff1fb1ffe1", + "size": 511823, + "subdir": "linux-64", + "timestamp": 1592300524865, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py39h27cfd23_10.tar.bz2": { + "build": "py39h27cfd23_10", + "build_number": 10, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Public Domain", + "md5": "5eeec564feab7cc1c5fcf5abf927e191", + "name": "pycrypto", + "sha256": "1fc99013be16d52ad58ed1919e03b65b69c5e1c694c593af381a712897688345", + "size": 487092, + "subdir": "linux-64", + "timestamp": 1608509342519, + "version": "2.6.1" + }, + "pycryptodome-3.10.1-py310hdd9d17f_0.tar.bz2": { + "build": "py310hdd9d17f_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "78d9071be55e36e78e1bf4098454c65a", + "name": "pycryptodome", + "sha256": "21ea0cf03518a53c9eb5d99668cfafd9d5727c5cff8cc4c73867d0a479bdeb82", + "size": 1866121, + "subdir": "linux-64", + "timestamp": 1640792917597, + "version": "3.10.1" + }, + "pycryptodome-3.10.1-py36h3dc18e1_0.tar.bz2": { + "build": "py36h3dc18e1_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "04c0d39161f71930dd1337544c751229", + "name": "pycryptodome", + "sha256": "53bb1f533c5c440c43f65c3983b5616c6d32ab8e12cc36847e59e2ceffe574fb", + "size": 1635879, + "subdir": "linux-64", + "timestamp": 1613764662992, + "version": "3.10.1" + }, + "pycryptodome-3.10.1-py37h3dc18e1_0.tar.bz2": { + "build": "py37h3dc18e1_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "fd16e30f70974f9ef4b063c00c9f383f", + "name": "pycryptodome", + "sha256": "08e611d2dce864d4b8cc98b558a1dc41e665c3c71d04cca99acd46c5592aebe3", + "size": 1597573, + "subdir": "linux-64", + "timestamp": 1613763878003, + "version": "3.10.1" + }, + "pycryptodome-3.10.1-py38h3dc18e1_0.tar.bz2": { + "build": "py38h3dc18e1_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "3b3e00d58706be0170b4fc58b2444001", + "name": "pycryptodome", + "sha256": "bdf62360cd2e4baef0d3a69fc530c810fa7632b21b13d2108e56e344d23f336f", + "size": 1598958, + "subdir": "linux-64", + "timestamp": 1613764643100, + "version": "3.10.1" + }, + "pycryptodome-3.10.1-py39h3dc18e1_0.tar.bz2": { + "build": "py39h3dc18e1_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "9e2c0652e6df5cbd8150fd85a04695ea", + "name": "pycryptodome", + "sha256": "23fc391dd49dc0df385f195e7b0edbb5f39f3e42926bf0b7bb00744aa082ef74", + "size": 1602415, + "subdir": "linux-64", + "timestamp": 1613764661809, + "version": "3.10.1" + }, + "pycryptodome-3.12.0-py37hdd9d17f_0.tar.bz2": { + "build": "py37hdd9d17f_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause AND Unlicense", + "license_family": "BSD", + "md5": "fbfc3c8e1b5e5c890cacc0573fc6ccd5", + "name": "pycryptodome", + "sha256": "7053782acc5b18757692de22bdca14150f0e4ccfbc6f232c8b05c7eb58dba61b", + "size": 1638108, + "subdir": "linux-64", + "timestamp": 1641468817030, + "version": "3.12.0" + }, + "pycryptodome-3.12.0-py38hdd9d17f_0.tar.bz2": { + "build": "py38hdd9d17f_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause AND Unlicense", + "license_family": "BSD", + "md5": "a01129578779d8b9f9cf9d8de58e99b6", + "name": "pycryptodome", + "sha256": "86c35456ea6fb45297ae4c7aa3bc5d0749aa795b3570c5f4f7859b52733c9aa3", + "size": 1633201, + "subdir": "linux-64", + "timestamp": 1641468826979, + "version": "3.12.0" + }, + "pycryptodome-3.12.0-py39hdd9d17f_0.tar.bz2": { + "build": "py39hdd9d17f_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause AND Unlicense", + "license_family": "BSD", + "md5": "26df3d28b106b936cc5e6835980c2d08", + "name": "pycryptodome", + "sha256": "3c25bc7e482b797ad928cf59358b7eda8f36cab673b669a2897f2212ef810bca", + "size": 1626076, + "subdir": "linux-64", + "timestamp": 1641468814807, + "version": "3.12.0" + }, + "pycryptodome-3.15.0-py310h276157c_0.tar.bz2": { + "build": "py310h276157c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause AND Unlicense", + "license_family": "BSD", + "md5": "020e4cc23bdeeb295ee27d819e3eea0d", + "name": "pycryptodome", + "sha256": "e112907f30f8fde5276ccfe15f3f2bbeec1d977a6808da13d1678ca339ce199e", + "size": 2083400, + "subdir": "linux-64", + "timestamp": 1658311109929, + "version": "3.15.0" + }, + "pycryptodome-3.15.0-py311h276157c_0.tar.bz2": { + "build": "py311h276157c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause AND Unlicense", + "license_family": "BSD", + "md5": "0a64d48ebcbcd7d220e3dc3ae3498235", + "name": "pycryptodome", + "sha256": "dba51ae110ee4977ba9b3dc8d13e8b6ba8f27f483baeb103b31a4fa8c7bf1b18", + "size": 1882901, + "subdir": "linux-64", + "timestamp": 1676842099194, + "version": "3.15.0" + }, + "pycryptodome-3.15.0-py37h276157c_0.tar.bz2": { + "build": "py37h276157c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause AND Unlicense", + "license_family": "BSD", + "md5": "2577e599c1571eee703a8b62ec6057bb", + "name": "pycryptodome", + "sha256": "360b5f0d0c0b6c1b4405ff11db52f9ff39ae6caf2a3394989bbca80593aa8712", + "size": 1709284, + "subdir": "linux-64", + "timestamp": 1658311052169, + "version": "3.15.0" + }, + "pycryptodome-3.15.0-py38h276157c_0.tar.bz2": { + "build": "py38h276157c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause AND Unlicense", + "license_family": "BSD", + "md5": "f783be0e4081bd49ee51038fe3e771e2", + "name": "pycryptodome", + "sha256": "45703cdd846a78d52c54565cac13e924bd5bb0ca2317800280b3d30c0ce8a995", + "size": 1707506, + "subdir": "linux-64", + "timestamp": 1658311204402, + "version": "3.15.0" + }, + "pycryptodome-3.15.0-py39h276157c_0.tar.bz2": { + "build": "py39h276157c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause AND Unlicense", + "license_family": "BSD", + "md5": "36770ab090d0e03e7c86feb76b1f44f4", + "name": "pycryptodome", + "sha256": "951f79dd50107346045a31e7f5670e02f9c750d8a0240a8645e7d663a417432a", + "size": 1701813, + "subdir": "linux-64", + "timestamp": 1658311156796, + "version": "3.15.0" + }, + "pycryptodome-3.6.6-py27hb69a4c5_0.tar.bz2": { + "build": "py27hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "d457d57b7cebd3a3733a8f8cf2cfa355", + "name": "pycryptodome", + "sha256": "c75372b584ffabcce1faeb564b5f4849fd34781fdd3cfb24ea31db42e901846a", + "size": 6158474, + "subdir": "linux-64", + "timestamp": 1539803850892, + "version": "3.6.6" + }, + "pycryptodome-3.6.6-py36hb69a4c5_0.tar.bz2": { + "build": "py36hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "8c2749d89f116431e118d46943aff8c7", + "name": "pycryptodome", + "sha256": "7b1f2020a3d93c25f23c453735ab5f5398335ab8735c774f230658bd2b2094a7", + "size": 6219654, + "subdir": "linux-64", + "timestamp": 1539809133235, + "version": "3.6.6" + }, + "pycryptodome-3.6.6-py37hb69a4c5_0.tar.bz2": { + "build": "py37hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "df4273d63776cd12900f7ce49671f322", + "name": "pycryptodome", + "sha256": "8406ce9218e047ff4afe68ec1ce22de16d3544d5bd884d03d7d35a17010ca22e", + "size": 6100141, + "subdir": "linux-64", + "timestamp": 1539803880819, + "version": "3.6.6" + }, + "pycryptodome-3.7.0-py27hb69a4c5_0.tar.bz2": { + "build": "py27hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "edfbe55bf5aa4afe9732d36c7c047077", + "name": "pycryptodome", + "sha256": "acc8211fbf6b96a35db91e68dec373f31134a3bd5c4f43babe7b570a9d64c2eb", + "size": 6175813, + "subdir": "linux-64", + "timestamp": 1541018531531, + "version": "3.7.0" + }, + "pycryptodome-3.7.0-py36hb69a4c5_0.tar.bz2": { + "build": "py36hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "4b366413b230517a6a4bd3985632fda3", + "name": "pycryptodome", + "sha256": "aa835061d071077d06e95b8b45892d9744154d0f9d57cbe2865d8e932bb9de57", + "size": 6169573, + "subdir": "linux-64", + "timestamp": 1541018587880, + "version": "3.7.0" + }, + "pycryptodome-3.7.0-py37hb69a4c5_0.tar.bz2": { + "build": "py37hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "bdd341c6e0ceb3161cea31c32ce5619b", + "name": "pycryptodome", + "sha256": "c4364c4fa7ce9d60dfd45593d33f49f80d8b82f0c5dfc659865e4d400aecba22", + "size": 6249654, + "subdir": "linux-64", + "timestamp": 1541018482890, + "version": "3.7.0" + }, + "pycryptodome-3.7.2-py27hb69a4c5_0.tar.bz2": { + "build": "py27hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "4483f9ce535aeec95cfcefedee1c069d", + "name": "pycryptodome", + "sha256": "34531f314da2f29f5107e25e63bac200821f88790fa21ff014df9221c24a599e", + "size": 6198735, + "subdir": "linux-64", + "timestamp": 1545131988090, + "version": "3.7.2" + }, + "pycryptodome-3.7.2-py36hb69a4c5_0.tar.bz2": { + "build": "py36hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "4b8f2194ebbd5827e4e079512896cdd7", + "name": "pycryptodome", + "sha256": "fa66fd9b86acfd1994f1164066f57f95d0fe2147718574fbdccf2e2f5f3243a1", + "size": 6285403, + "subdir": "linux-64", + "timestamp": 1545132038746, + "version": "3.7.2" + }, + "pycryptodome-3.7.2-py37hb69a4c5_0.tar.bz2": { + "build": "py37hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "60886b5dbce68abc374372a279710ccf", + "name": "pycryptodome", + "sha256": "acf1afeb8d213441c6a22ae3c4568aa5d7c7c4bf08da0fe9820063e2a179791b", + "size": 6183364, + "subdir": "linux-64", + "timestamp": 1545132036566, + "version": "3.7.2" + }, + "pycryptodome-3.7.3-py27hb69a4c5_0.tar.bz2": { + "build": "py27hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "e89b456d4c87b6aaf8648230eb5b8c1a", + "name": "pycryptodome", + "sha256": "42ba09fede14e6ff466170c79a289b6d09f45773aec5af75f16970c3d3339dbb", + "size": 6221008, + "subdir": "linux-64", + "timestamp": 1552441507805, + "version": "3.7.3" + }, + "pycryptodome-3.7.3-py36hb69a4c5_0.tar.bz2": { + "build": "py36hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "b4a0ed84cd9b3179ef71c6850514e597", + "name": "pycryptodome", + "sha256": "d65600d2ad09193b84f32be4add72bfa3072a7964904f67c82b54a90a82006d2", + "size": 6291679, + "subdir": "linux-64", + "timestamp": 1552441805644, + "version": "3.7.3" + }, + "pycryptodome-3.7.3-py37hb69a4c5_0.tar.bz2": { + "build": "py37hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "cfac4e7c4032538a39c5e28cf77818ce", + "name": "pycryptodome", + "sha256": "68ba2f8508403eff806558c48530f39ba8d99c66a5de22d32ff9ed06c0793747", + "size": 6141822, + "subdir": "linux-64", + "timestamp": 1552441470185, + "version": "3.7.3" + }, + "pycryptodome-3.8.2-py27hb69a4c5_0.tar.bz2": { + "build": "py27hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "4a3b6987d9382e820e41fcf0966329c3", + "name": "pycryptodome", + "sha256": "c73dc3eefe75dff4181e328e5c8a7fb9d75ac1b2f04e87bdbade59fcf6f37a79", + "size": 8182441, + "subdir": "linux-64", + "timestamp": 1569426661925, + "version": "3.8.2" + }, + "pycryptodome-3.8.2-py36hb69a4c5_0.tar.bz2": { + "build": "py36hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "2664f0b00a74df30b1bd25ccdd796b71", + "name": "pycryptodome", + "sha256": "fe7c785ca512dbb3f293042285a8717c99aff7fd89745fa57bd87d4682821da7", + "size": 8296690, + "subdir": "linux-64", + "timestamp": 1569426661913, + "version": "3.8.2" + }, + "pycryptodome-3.8.2-py37hb69a4c5_0.tar.bz2": { + "build": "py37hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "40b17945c2b2a755c9072bad8ea6c488", + "name": "pycryptodome", + "sha256": "09c19f2c0ced7fa236530534801b21c490d95141c08a6c6d5b6ddf617fd9423d", + "size": 8175848, + "subdir": "linux-64", + "timestamp": 1569426637685, + "version": "3.8.2" + }, + "pycryptodome-3.8.2-py38hb69a4c5_0.tar.bz2": { + "build": "py38hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "1d0b176df4c2c46b1d7546573fd9e7a7", + "name": "pycryptodome", + "sha256": "224da6442341200294ce9e2eec3505f69c65663ed8b32d14d15f02c479137855", + "size": 8188493, + "subdir": "linux-64", + "timestamp": 1573668891783, + "version": "3.8.2" + }, + "pycryptodome-3.9.8-py36hb69a4c5_0.tar.bz2": { + "build": "py36hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "481d74565516d78406564c4b77e57146", + "name": "pycryptodome", + "sha256": "d4bd4bb1a27249b3366cf324b232c72df830d3d31cf736e17066b0b25f2ee348", + "size": 12081963, + "subdir": "linux-64", + "timestamp": 1599232795358, + "version": "3.9.8" + }, + "pycryptodome-3.9.8-py37hb69a4c5_0.tar.bz2": { + "build": "py37hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "b457a228763eef3bb544abc811a87c6d", + "name": "pycryptodome", + "sha256": "50b5f8e4a32c668ae6ed0d020804248a7cf6a013a067bdfc186358736899fc66", + "size": 12020672, + "subdir": "linux-64", + "timestamp": 1599232787795, + "version": "3.9.8" + }, + "pycryptodome-3.9.8-py38hb69a4c5_0.tar.bz2": { + "build": "py38hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "95c8a4b242b5fa5b217b8458eda8effc", + "name": "pycryptodome", + "sha256": "773e7bea3f787ce9bf9e31be3b11786cbe9163849b9e80e5d51568ea6ff49475", + "size": 11946532, + "subdir": "linux-64", + "timestamp": 1599232772670, + "version": "3.9.8" + }, + "pycryptodome-3.9.9-py36h3dc18e1_0.tar.bz2": { + "build": "py36h3dc18e1_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "9572529bc1fbc7c986520c21123cb9e3", + "name": "pycryptodome", + "sha256": "a956007866b95cacf67eb294593ed2f37a677b0cd9713089c417eda458e715d3", + "size": 12037271, + "subdir": "linux-64", + "timestamp": 1606344657300, + "version": "3.9.9" + }, + "pycryptodome-3.9.9-py37h3dc18e1_0.tar.bz2": { + "build": "py37h3dc18e1_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "4922cf023736549ccef92eb20200b639", + "name": "pycryptodome", + "sha256": "f3ed3d22fe785fe4a8f5651ca952766c8ea92a272e3842fbf3f96d8fbb7d8191", + "size": 11995169, + "subdir": "linux-64", + "timestamp": 1606344681392, + "version": "3.9.9" + }, + "pycryptodome-3.9.9-py38h3dc18e1_0.tar.bz2": { + "build": "py38h3dc18e1_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "448168d72292a12180f39087ef4ed570", + "name": "pycryptodome", + "sha256": "cd8f02f81eaa6292806300d392e342b6b33f6a87f41f0aaec360709222d10c25", + "size": 12012864, + "subdir": "linux-64", + "timestamp": 1606344679486, + "version": "3.9.9" + }, + "pycryptodome-3.9.9-py39h3dc18e1_0.tar.bz2": { + "build": "py39h3dc18e1_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "076be5d317ce6249a47440c2fa8ef0fa", + "name": "pycryptodome", + "sha256": "c00ce2c8cbc0ee89167c7711219c21193b11d090e575342e2962245607a1503a", + "size": 11978138, + "subdir": "linux-64", + "timestamp": 1606344688074, + "version": "3.9.9" + }, + "pycryptodomex-3.10.1-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "cb5c7b2490c57e36ce559aa5acce0df2", + "name": "pycryptodomex", + "sha256": "656b38b16b67010fab30ca7b1a6f33dc97362e517670d163f3311edbea632933", + "size": 1854840, + "subdir": "linux-64", + "timestamp": 1640792959074, + "version": "3.10.1" + }, + "pycryptodomex-3.10.1-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "1e94a03af756595145ba579a6e6a6c72", + "name": "pycryptodomex", + "sha256": "a908e8a35410d83d8e6acaef3b58739287dc2d8421cfcc0e610add8094335f71", + "size": 1636360, + "subdir": "linux-64", + "timestamp": 1613763958000, + "version": "3.10.1" + }, + "pycryptodomex-3.10.1-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "22434bbbb01fb857e65339ddc894da0e", + "name": "pycryptodomex", + "sha256": "f277dc5ab45efb29bfacbac1e95ff3170363577a3848eeafd2e359d38a045346", + "size": 1595461, + "subdir": "linux-64", + "timestamp": 1613764703991, + "version": "3.10.1" + }, + "pycryptodomex-3.10.1-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "81732cb43412a98e3d70119f77b3e22e", + "name": "pycryptodomex", + "sha256": "4a28570741e5879c6b149c020f16b3f973d8721a8a0858d1ec7867b22351c799", + "size": 1595963, + "subdir": "linux-64", + "timestamp": 1613763955910, + "version": "3.10.1" + }, + "pycryptodomex-3.10.1-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "aeca38d1a7f36652fbbe99f324229ecc", + "name": "pycryptodomex", + "sha256": "039b235742ed2981ce11d567fff2251be62266b948b9e98fd376c235b32a3a37", + "size": 1592958, + "subdir": "linux-64", + "timestamp": 1613764704747, + "version": "3.10.1" + }, + "pycryptodomex-3.15.0-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "6e61a9e282512aa9fad052ec173f63a9", + "name": "pycryptodomex", + "sha256": "3609fee722a8037b402e5f76885a4a723f9aa5b242f8a11da3bfc4521a0c3b42", + "size": 2096664, + "subdir": "linux-64", + "timestamp": 1661450313401, + "version": "3.15.0" + }, + "pycryptodomex-3.15.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "2afb8a5d657a249b50cda5eb31a07834", + "name": "pycryptodomex", + "sha256": "4a4ddb080711ab10a735931b0e6951437fe5100988a68f1d8e25b15e1dc38187", + "size": 1870598, + "subdir": "linux-64", + "timestamp": 1676845284621, + "version": "3.15.0" + }, + "pycryptodomex-3.15.0-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "d774d39920458cd41fe4eb23a17eca94", + "name": "pycryptodomex", + "sha256": "6027068aed6fb2db5a5b9e52ea4c41d197500236a2fad8a20710ced9d006403b", + "size": 1705170, + "subdir": "linux-64", + "timestamp": 1661450353999, + "version": "3.15.0" + }, + "pycryptodomex-3.15.0-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "e4969975c8bec2d7b527320e90044ddd", + "name": "pycryptodomex", + "sha256": "1013934ca9a29b40df8bd33257ac6061733b9aabae6d578ecd6405bc155d8653", + "size": 1706470, + "subdir": "linux-64", + "timestamp": 1661450396386, + "version": "3.15.0" + }, + "pycryptodomex-3.15.0-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "f557c886809c9362bedb8e68c915485a", + "name": "pycryptodomex", + "sha256": "4d4f1046748745100983a102e72645bf5dacf4d069ce9012ef0228aaf033b8d2", + "size": 1698879, + "subdir": "linux-64", + "timestamp": 1661450257217, + "version": "3.15.0" + }, + "pycryptodomex-3.4.7-py27h7bd1586_0.tar.bz2": { + "build": "py27h7bd1586_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "552066b3052f410d34fe519cd17d1b68", + "name": "pycryptodomex", + "sha256": "0ea022ba3053278c8e958b341a1ae57b61f701a4ccf71366444758246dcd88b0", + "size": 5628529, + "subdir": "linux-64", + "timestamp": 1512920609224, + "version": "3.4.7" + }, + "pycryptodomex-3.4.7-py35h7a9f3d7_0.tar.bz2": { + "build": "py35h7a9f3d7_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "e52d301fcd7f3743f06b7e4ceae29a84", + "name": "pycryptodomex", + "sha256": "5e8e032ec8eeed975ab5a333c4d5de28af05218ce9ef57047dc22fc973a06573", + "size": 5670382, + "subdir": "linux-64", + "timestamp": 1512920707640, + "version": "3.4.7" + }, + "pycryptodomex-3.4.7-py36h7a9f3d7_0.tar.bz2": { + "build": "py36h7a9f3d7_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "254573d93ce65f651734e43afd6efa94", + "name": "pycryptodomex", + "sha256": "1e18fa36cf2a3250252956d8078c9cebd4626da822ff1e4a8d2f1d99aa2d7f1b", + "size": 5727244, + "subdir": "linux-64", + "timestamp": 1512920707964, + "version": "3.4.7" + }, + "pycryptodomex-3.5.1-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "41517792831f0932483e831cf6f14d9c", + "name": "pycryptodomex", + "sha256": "85bd7ec508668d4f68a724debaba2a60ad3254512a12afc42a617263a84534f6", + "size": 5703992, + "subdir": "linux-64", + "timestamp": 1521000325396, + "version": "3.5.1" + }, + "pycryptodomex-3.5.1-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "e32209b56c6e9a1e9a38a2b28699e038", + "name": "pycryptodomex", + "sha256": "34b8b1716aeec8ddc23c0fd31a912c8014cfaa87aabd01cd21d7ac089f76165b", + "size": 5695148, + "subdir": "linux-64", + "timestamp": 1521000363980, + "version": "3.5.1" + }, + "pycryptodomex-3.5.1-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "ff32164917b2311d1077c0ae961ededf", + "name": "pycryptodomex", + "sha256": "9565a6268a2d325b0c23c719cea26733086e674b5011c797e3dbc621aa55d509", + "size": 5714278, + "subdir": "linux-64", + "timestamp": 1521000358680, + "version": "3.5.1" + }, + "pycryptodomex-3.6.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "84f065052333f1097df020a7b75de2b0", + "name": "pycryptodomex", + "sha256": "acb55b28a80ee1d471e5f939ab226912dd7bfbd6d76799fe4a36d1ebccb338bd", + "size": 5813904, + "subdir": "linux-64", + "timestamp": 1523431477372, + "version": "3.6.0" + }, + "pycryptodomex-3.6.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "32ea95cf6bd7a96a2582c1b5425693c5", + "name": "pycryptodomex", + "sha256": "4a8710f71c250bae28974bca0cf9feafd22694ea529ad7fcb1ce0a2cbc12f7f5", + "size": 5769553, + "subdir": "linux-64", + "timestamp": 1523431429681, + "version": "3.6.0" + }, + "pycryptodomex-3.6.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "809611b6781da435780799df412020e0", + "name": "pycryptodomex", + "sha256": "ef068638223ab82d85c289bd2067736919b2a9065cfe173d946f2f8262c9e3c6", + "size": 5848600, + "subdir": "linux-64", + "timestamp": 1523431420323, + "version": "3.6.0" + }, + "pycryptodomex-3.6.1-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "183d5edbe7fbeacfa719e068ddef10ce", + "name": "pycryptodomex", + "sha256": "0d4e62fca5071a6cdcdac0c9106122613c0771942cc0140e91455faad22a6bd7", + "size": 6176504, + "subdir": "linux-64", + "timestamp": 1524516470678, + "version": "3.6.1" + }, + "pycryptodomex-3.6.1-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "28c86bf9579605989c48ba829deb905b", + "name": "pycryptodomex", + "sha256": "d2d40d1eb52236dd05f8d2ca3090de53723c40c6ed27e5d4aef72d97588f77a1", + "size": 6199558, + "subdir": "linux-64", + "timestamp": 1524516212110, + "version": "3.6.1" + }, + "pycryptodomex-3.6.1-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "254ef618282292d86151fac9285782e6", + "name": "pycryptodomex", + "sha256": "64544a1c01a905e59b011e6d1ac1a0f3ea9e7d5aef5d707de72b5d71a47c28f7", + "size": 6218747, + "subdir": "linux-64", + "timestamp": 1524516751806, + "version": "3.6.1" + }, + "pycryptodomex-3.6.3-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "944fbd2e4ff723359e7089ff3c9d5c71", + "name": "pycryptodomex", + "sha256": "c964dc27a84286a60b708a6de7054893bf2f54390ea216267d408ba2e0942959", + "size": 6227976, + "subdir": "linux-64", + "timestamp": 1529956986873, + "version": "3.6.3" + }, + "pycryptodomex-3.6.3-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "5e7743e73a89df72e9926537ceb877c1", + "name": "pycryptodomex", + "sha256": "4e677263051dd3161e2449432bc9ecf6fb343221c1a915f7e0e5a0e8ad57c3df", + "size": 6238884, + "subdir": "linux-64", + "timestamp": 1529957011975, + "version": "3.6.3" + }, + "pycryptodomex-3.6.3-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "8848b3a7c390ef7fd9b5d28a254d0309", + "name": "pycryptodomex", + "sha256": "3cc98019fe6c12de9936953e4e204b568fe3d02534d7d709a8e248a7c7cf368a", + "size": 6262194, + "subdir": "linux-64", + "timestamp": 1529957335934, + "version": "3.6.3" + }, + "pycryptodomex-3.6.3-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "018cb1e54053537474172c466c8aa553", + "name": "pycryptodomex", + "sha256": "207da07ba637519e9acf11e40f68082dd5742e98c4c08c0ed78602695e5ea4c4", + "size": 6175849, + "subdir": "linux-64", + "timestamp": 1530915946733, + "version": "3.6.3" + }, + "pycryptodomex-3.6.4-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "2744b6fb8cddfbf82c65d8143472f19f", + "name": "pycryptodomex", + "sha256": "c07e554e36777768e2d0950359dfa0101a7220cec1693a4f79b020c9aa24efe8", + "size": 6221744, + "subdir": "linux-64", + "timestamp": 1535429260814, + "version": "3.6.4" + }, + "pycryptodomex-3.6.4-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "77548d91707977136a55ca9524d08849", + "name": "pycryptodomex", + "sha256": "627e4729d94da1fd60e49ac1b0e5b88c40974a14d4396a0f3d688f76b7323a64", + "size": 6223045, + "subdir": "linux-64", + "timestamp": 1535429381750, + "version": "3.6.4" + }, + "pycryptodomex-3.6.4-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "739a46510ee09fd519b731e740ad7bdf", + "name": "pycryptodomex", + "sha256": "41fb48b25ff222d7a968bc865d9a0a2df52df3e90e922e2126cc891e0333137e", + "size": 6255301, + "subdir": "linux-64", + "timestamp": 1535429320871, + "version": "3.6.4" + }, + "pycryptodomex-3.6.4-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "7d40bd994168b91bf01671474f22ab2f", + "name": "pycryptodomex", + "sha256": "0f155eca527443c7e6b09eac55a7c5f31d9b38662e8c59a577abfa6c1d1b16c6", + "size": 6168722, + "subdir": "linux-64", + "timestamp": 1535429380919, + "version": "3.6.4" + }, + "pycryptodomex-3.6.6-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "67056622812f68f8c873687ab319173f", + "name": "pycryptodomex", + "sha256": "67cea958aa57e3b274cc0f49f8f04238d34dc6734c3f9eba5584e76368a1507d", + "size": 6226135, + "subdir": "linux-64", + "timestamp": 1536263990536, + "version": "3.6.6" + }, + "pycryptodomex-3.6.6-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "ca5a113816052c0af3975992c82f87ac", + "name": "pycryptodomex", + "sha256": "5a46898d4381473ab4bc01f4dfab4890e2741a134196133959ba5be831e1b8a5", + "size": 6225461, + "subdir": "linux-64", + "timestamp": 1536264036449, + "version": "3.6.6" + }, + "pycryptodomex-3.6.6-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "99783de857ca8299a26d68ee88345040", + "name": "pycryptodomex", + "sha256": "57813c4c4100b10c8f31ea9442cf13edd5ce11323defa0c106e88005039881b3", + "size": 6250289, + "subdir": "linux-64", + "timestamp": 1536263974173, + "version": "3.6.6" + }, + "pycryptodomex-3.6.6-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "9c3d5ea8ed456b9718ded5aa760af9fe", + "name": "pycryptodomex", + "sha256": "71a69241589200721a6d60c97f03342a241c5e199f1ca033610b1b98dcdf70f4", + "size": 6179856, + "subdir": "linux-64", + "timestamp": 1536264014294, + "version": "3.6.6" + }, + "pycryptodomex-3.7.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "e00af8644b6adea4716ff58b2241c628", + "name": "pycryptodomex", + "sha256": "c928b5ebb1d322ffb3c73dc4d716b99045fb896d3146c861de324a8f55618315", + "size": 6197410, + "subdir": "linux-64", + "timestamp": 1541020448493, + "version": "3.7.0" + }, + "pycryptodomex-3.7.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "8107e6b416367b9ec7cd688a5bfc9edb", + "name": "pycryptodomex", + "sha256": "d275e8b10be395b5f1f9e7561ebeffa72c339fcc4b024757215cab8c3d8a1256", + "size": 6246832, + "subdir": "linux-64", + "timestamp": 1541020432219, + "version": "3.7.0" + }, + "pycryptodomex-3.7.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "63e215f152fe48190f0ac21ab3f1d248", + "name": "pycryptodomex", + "sha256": "abf89b93099ebd46036a9e0cc1c70f1c674577e357a3511b831a4bfb003cd6c6", + "size": 6221420, + "subdir": "linux-64", + "timestamp": 1541020406321, + "version": "3.7.0" + }, + "pycryptodomex-3.7.2-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "2a366981117dd53cc1bedb0059405b6e", + "name": "pycryptodomex", + "sha256": "efdac6263c634779b828f40970550e25539c8198ff8c4be4a0e30e11a8559e59", + "size": 6304903, + "subdir": "linux-64", + "timestamp": 1545167269030, + "version": "3.7.2" + }, + "pycryptodomex-3.7.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "e3745833f572701d4c57cdf096055ae1", + "name": "pycryptodomex", + "sha256": "6d1cc03a29736ef119e206058d6d18a88392b2e759bdb47a27a4b7c28da04bdf", + "size": 6312706, + "subdir": "linux-64", + "timestamp": 1545167221690, + "version": "3.7.2" + }, + "pycryptodomex-3.7.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "967c98d94bb802630dd29a2692da24d4", + "name": "pycryptodomex", + "sha256": "f1df71a264dc5f2419ee979dfec025c1a805f40205f9239fee5e57c7f96005b4", + "size": 6291982, + "subdir": "linux-64", + "timestamp": 1545167318806, + "version": "3.7.2" + }, + "pycryptodomex-3.8.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "5319af621eae24130b666c5f2c6b9f2b", + "name": "pycryptodomex", + "sha256": "a177861de1f0a6bfa8cbf0625414ded59c82faf1de1e0e2342ed2a174ebafe35", + "size": 8280941, + "subdir": "linux-64", + "timestamp": 1556085015923, + "version": "3.8.1" + }, + "pycryptodomex-3.8.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "1363bfc102edde5e1946c3280b76ab26", + "name": "pycryptodomex", + "sha256": "e49c6bb95bdbf77ddd001e0be8370b67ee37c1a1878e7ea5c4e3aefa8ad47e4a", + "size": 8182310, + "subdir": "linux-64", + "timestamp": 1556085034629, + "version": "3.8.1" + }, + "pycryptodomex-3.8.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "5c853713649b203da57609a4ec9011a7", + "name": "pycryptodomex", + "sha256": "1e7eb702c14677777bb49f3bba21b1efd585978861483a0bb996c5fa7d3864d4", + "size": 8274927, + "subdir": "linux-64", + "timestamp": 1556085012113, + "version": "3.8.1" + }, + "pycryptodomex-3.9.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "34b5f986d8266d8d87450d13558e8e0b", + "name": "pycryptodomex", + "sha256": "f41018864d94b1103119147e3693e9e82191cdfb20fd046560125baca1ab4339", + "size": 8311514, + "subdir": "linux-64", + "timestamp": 1569419712299, + "version": "3.9.0" + }, + "pycryptodomex-3.9.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "0b2dfd923fcadfa2a49b7dc7baa7d598", + "name": "pycryptodomex", + "sha256": "ca9ecc73914399c27e1dfb0a7ca9c377f38ab688367354315972343aeb8b0274", + "size": 8312202, + "subdir": "linux-64", + "timestamp": 1569419712729, + "version": "3.9.0" + }, + "pycryptodomex-3.9.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "d32e214450ada7907847129ff780456d", + "name": "pycryptodomex", + "sha256": "4d3bc14b1b29e198b1c1e71943a466dd3a39d783ff9763e3cf9d8921fae2d42b", + "size": 8308490, + "subdir": "linux-64", + "timestamp": 1569419721576, + "version": "3.9.0" + }, + "pycryptodomex-3.9.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "0daaa5df809c0034476467635f303ef6", + "name": "pycryptodomex", + "sha256": "1d87b43843027846ab8cd990e32c2b32acec2934f56ec28182eec0000fe12065", + "size": 8295541, + "subdir": "linux-64", + "timestamp": 1573668962729, + "version": "3.9.0" + }, + "pycryptodomex-3.9.3-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "d465f2b4ee217c25c9ed6aa017d1e172", + "name": "pycryptodomex", + "sha256": "411e1d51b41d80f806b755de99b114419d06b084614cce4d2402ed267f2052b8", + "size": 8273403, + "subdir": "linux-64", + "timestamp": 1573971277735, + "version": "3.9.3" + }, + "pycryptodomex-3.9.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "48bff51d73b94f7ae71b634c9bff0147", + "name": "pycryptodomex", + "sha256": "66ea4e82ec2feec08937b7e75769ba7ad9e52452d77d5cfb2946cbc869fdd1f3", + "size": 8237839, + "subdir": "linux-64", + "timestamp": 1573971235113, + "version": "3.9.3" + }, + "pycryptodomex-3.9.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "c1a68740f3ab8e28e669646f0405e56e", + "name": "pycryptodomex", + "sha256": "272294b678b318c76c02f3c4491689860984bcf992d3ba8b82035e71c17fc34e", + "size": 8227642, + "subdir": "linux-64", + "timestamp": 1573971277624, + "version": "3.9.3" + }, + "pycryptodomex-3.9.3-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "76e635a86b84bd8888626dec2bf9dca6", + "name": "pycryptodomex", + "sha256": "ba6582bcd74c412659ba85a0254a77ab3ca63bae62062ad1bd857097d6e24362", + "size": 8282825, + "subdir": "linux-64", + "timestamp": 1573971263795, + "version": "3.9.3" + }, + "pycryptodomex-3.9.4-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "bcffa31e5846de29e964dd856b5cc446", + "name": "pycryptodomex", + "sha256": "2c6ff804345c908561019930ac0aeb5469a81a5364fffe12e54cce6bb13b8780", + "size": 8275386, + "subdir": "linux-64", + "timestamp": 1574369080248, + "version": "3.9.4" + }, + "pycryptodomex-3.9.4-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "0553da353d2e9f48aa6e4c75c4327f5f", + "name": "pycryptodomex", + "sha256": "95e886bc602582afcf67dc759113e215e13bcd1639c8d6dc55272fbe9653f3a2", + "size": 8291460, + "subdir": "linux-64", + "timestamp": 1574369026161, + "version": "3.9.4" + }, + "pycryptodomex-3.9.4-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "bcb48208983f211ef465b23cfeb6139e", + "name": "pycryptodomex", + "sha256": "eeb9e94364466fb946ae5c51804b4ca3c596385b119c183ed2313cda51d121a1", + "size": 8211219, + "subdir": "linux-64", + "timestamp": 1574369078578, + "version": "3.9.4" + }, + "pycryptodomex-3.9.4-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "10603772549af6db63e769a6543ef165", + "name": "pycryptodomex", + "sha256": "970fbcf0373d88eb16a98fffcab832d1ded47058e2c0c90c3ce7a3e7e7852ec5", + "size": 8207471, + "subdir": "linux-64", + "timestamp": 1574369083751, + "version": "3.9.4" + }, + "pycryptodomex-3.9.7-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "339944910409bef16fac824573929d39", + "name": "pycryptodomex", + "sha256": "38bba73c0cf1e73a808e7917c3d82588d81771f84641819ffc707547c8c1d02d", + "size": 11994303, + "subdir": "linux-64", + "timestamp": 1588595738822, + "version": "3.9.7" + }, + "pycryptodomex-3.9.7-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "f5b8f2bf006adac5269da84f3b57ed21", + "name": "pycryptodomex", + "sha256": "7614cdf7732b83bad01419666e7216e86d46db4e8f614749d96b501ebc9d7206", + "size": 12034877, + "subdir": "linux-64", + "timestamp": 1588595716620, + "version": "3.9.7" + }, + "pycryptodomex-3.9.7-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "1eec7491ddd448383e64f0ae84d6651b", + "name": "pycryptodomex", + "sha256": "4b78498076382c7e245fd33b29a2291ec3c113f5f8f55e1c827f81761a469118", + "size": 11998508, + "subdir": "linux-64", + "timestamp": 1588595739806, + "version": "3.9.7" + }, + "pycryptodomex-3.9.8-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "b5bfb446790833692705e6ebe1aa56a5", + "name": "pycryptodomex", + "sha256": "6c8691217b605a5dbe19041445a5ebf87f7df76a0c70ab2335819cd5be0f08b9", + "size": 12108616, + "subdir": "linux-64", + "timestamp": 1593483503615, + "version": "3.9.8" + }, + "pycryptodomex-3.9.8-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "72c0235568cd339461cfe5301f00db89", + "name": "pycryptodomex", + "sha256": "f190184eccdc404673f8c41183e51faf8c71e9c8dd65c4acf23756447026ddc0", + "size": 11963424, + "subdir": "linux-64", + "timestamp": 1593483527021, + "version": "3.9.8" + }, + "pycryptodomex-3.9.8-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "6bf5dcce1c19dca9817e0682681d309b", + "name": "pycryptodomex", + "sha256": "1a1ca17b871fada96148b5d68d204e0fafbb4630616a5607a60deb6008333f2f", + "size": 12042791, + "subdir": "linux-64", + "timestamp": 1593483505833, + "version": "3.9.8" + }, + "pycryptodomex-3.9.9-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "62202954e428f80d4ac5f1603acf7eb4", + "name": "pycryptodomex", + "sha256": "ec16b3231222a28732b15cd92cb7cf55021664db0f325b50251d7f0882193f24", + "size": 12084424, + "subdir": "linux-64", + "timestamp": 1605123956629, + "version": "3.9.9" + }, + "pycryptodomex-3.9.9-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "bc08fe14d70a8374ba524efe6936956b", + "name": "pycryptodomex", + "sha256": "0da1c7a2008a3a62f71b17d16f81bb3ae6a7178c4d3d9a265dd14d49637b733f", + "size": 11991862, + "subdir": "linux-64", + "timestamp": 1605123932709, + "version": "3.9.9" + }, + "pycryptodomex-3.9.9-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "1c709d17cd9a3bc9ab54f3aa54eee635", + "name": "pycryptodomex", + "sha256": "a66b768324f46a8d02809c9e8ae100de2978dbe034cb099516468f4935681fca", + "size": 12064685, + "subdir": "linux-64", + "timestamp": 1605123929892, + "version": "3.9.9" + }, + "pycryptosat-5.6.6-py27h0e08187_0.tar.bz2": { + "build": "py27h0e08187_0", + "build_number": 0, + "depends": [ + "libcryptominisat 5.6.6 h0e08187_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f871a6fe7a00ec58e2852a730585283", + "name": "pycryptosat", + "sha256": "86388d20e7c0ce7754d1193bd09f9bf594a39681e6276a4ffc6067a832503e0f", + "size": 99573, + "subdir": "linux-64", + "timestamp": 1548446984129, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py310h3826bc1_0.tar.bz2": { + "build": "py310h3826bc1_0", + "build_number": 0, + "depends": [ + "libcryptominisat 5.6.6 h3826bc1_0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "zlib" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3907ff6ac20e7d42eaa50f59344d0faa", + "name": "pycryptosat", + "sha256": "c5d8f72aa39ce016d12acae64e4cd1172651f15f7dab094af168695b4fd241c3", + "size": 92640, + "subdir": "linux-64", + "timestamp": 1641901808399, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py310h9e868ea_1.tar.bz2": { + "build": "py310h9e868ea_1", + "build_number": 1, + "depends": [ + "libcryptominisat 5.6.6 h9e868ea_1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "493f840584403a1a4d5c4f32db37ebb6", + "name": "pycryptosat", + "sha256": "bce42749575313d0b4274748a824c2bbb97de6bc3d4e6fe871f4ce6524b6d746", + "size": 24708, + "subdir": "linux-64", + "timestamp": 1676726369899, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py310h9e868ea_2.tar.bz2": { + "build": "py310h9e868ea_2", + "build_number": 2, + "depends": [ + "libcryptominisat 5.6.6 h9e868ea_2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7324f350f9c89d68434e4305f2d10764", + "name": "pycryptosat", + "sha256": "73033668b9fba7853ddea927bfba013f135346bc25ba7b96eccfbf57edba5c73", + "size": 24943, + "subdir": "linux-64", + "timestamp": 1679313547349, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py311h9e868ea_1.tar.bz2": { + "build": "py311h9e868ea_1", + "build_number": 1, + "depends": [ + "libcryptominisat 5.6.6 h9e868ea_1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "54c96cfa59d366e9cdf98ed3e6f28aa1", + "name": "pycryptosat", + "sha256": "77e2ae899ac07b3c1041c0c7649c7c7d4f39554a8d54a01813701ce4f41d9ba3", + "size": 25064, + "subdir": "linux-64", + "timestamp": 1676851762487, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py311h9e868ea_2.tar.bz2": { + "build": "py311h9e868ea_2", + "build_number": 2, + "depends": [ + "libcryptominisat 5.6.6 h9e868ea_2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f40feabbffc376db36a035945f70a497", + "name": "pycryptosat", + "sha256": "cd19993a65148c0083e378f83954f3c251607635ecd93fcb030a332218b38172", + "size": 24928, + "subdir": "linux-64", + "timestamp": 1679313761399, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py36h0e08187_0.tar.bz2": { + "build": "py36h0e08187_0", + "build_number": 0, + "depends": [ + "libcryptominisat 5.6.6 h0e08187_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "253f797a130a8cebc43dd9150f397f97", + "name": "pycryptosat", + "sha256": "d1fc7eddfc212b810b1a39fcec5757aae166937874676c0aec4bec31c89d271c", + "size": 97304, + "subdir": "linux-64", + "timestamp": 1548447080868, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py36hc0fe6c6_0.tar.bz2": { + "build": "py36hc0fe6c6_0", + "build_number": 0, + "depends": [ + "libcryptominisat 5.6.6 hc0fe6c6_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b9029feb9cbb8e77a207f8b063a84b6", + "name": "pycryptosat", + "sha256": "ff4860f5832a7df51d9a7b0accc979150c3ef5ffddb2649f689462902a903b53", + "size": 98627, + "subdir": "linux-64", + "timestamp": 1611760492942, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py37h0e08187_0.tar.bz2": { + "build": "py37h0e08187_0", + "build_number": 0, + "depends": [ + "libcryptominisat 5.6.6 h0e08187_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5010bf0ce282c9455c6ed9ed81c19cc", + "name": "pycryptosat", + "sha256": "852f738707129a973c158fd222167e69b565e384977421f3e38d3f9b79821863", + "size": 98254, + "subdir": "linux-64", + "timestamp": 1548447284391, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py37h9e868ea_1.tar.bz2": { + "build": "py37h9e868ea_1", + "build_number": 1, + "depends": [ + "libcryptominisat 5.6.6 h9e868ea_1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "801ac3b4e43369c1f03787afd4ee25cd", + "name": "pycryptosat", + "sha256": "4f2675758b8821c996e11c1f18cddadc1eb46904028163f297c1f93899a08db5", + "size": 103297, + "subdir": "linux-64", + "timestamp": 1676726271564, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py37hc0fe6c6_0.tar.bz2": { + "build": "py37hc0fe6c6_0", + "build_number": 0, + "depends": [ + "libcryptominisat 5.6.6 hc0fe6c6_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3eb85371f95dda33181a774d962026c2", + "name": "pycryptosat", + "sha256": "31d949dab91aa6601220d7683a84e70ec85b89d5807a18d06f9e95acf1fc1bdf", + "size": 99480, + "subdir": "linux-64", + "timestamp": 1611760411725, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py38h9e868ea_1.tar.bz2": { + "build": "py38h9e868ea_1", + "build_number": 1, + "depends": [ + "libcryptominisat 5.6.6 h9e868ea_1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f9ea6aafeb3653ef03b4b1551821f21", + "name": "pycryptosat", + "sha256": "6c8049ff2ab77309804eef439f414737537e5d8a1de6abca44680cb01dd5d8d5", + "size": 104141, + "subdir": "linux-64", + "timestamp": 1676726173531, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py38h9e868ea_2.tar.bz2": { + "build": "py38h9e868ea_2", + "build_number": 2, + "depends": [ + "libcryptominisat 5.6.6 h9e868ea_2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7903f61ea8c07d0be7c0121554e25ac", + "name": "pycryptosat", + "sha256": "45ba953d3bbeaf35e1ba09bc19a5dcc1e1eae66fbf600cb34f0f7ac6dbd647a4", + "size": 104385, + "subdir": "linux-64", + "timestamp": 1679313661138, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py38hc0fe6c6_0.tar.bz2": { + "build": "py38hc0fe6c6_0", + "build_number": 0, + "depends": [ + "libcryptominisat 5.6.6 hc0fe6c6_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zlib" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87c4706ceee2b4b344b605eaa672c4e6", + "name": "pycryptosat", + "sha256": "1cfa39ebdfaaeda3b2d80eb9e0c5d614728019b757d1c836553506a9cccab1cb", + "size": 100197, + "subdir": "linux-64", + "timestamp": 1611760405141, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py39h9e868ea_1.tar.bz2": { + "build": "py39h9e868ea_1", + "build_number": 1, + "depends": [ + "libcryptominisat 5.6.6 h9e868ea_1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "769bc472d6946a9babb5cd94edfc18cb", + "name": "pycryptosat", + "sha256": "464cedfdc03f487343a0205b2a7afe1f650588cc3e0baca176b366532a405f88", + "size": 103725, + "subdir": "linux-64", + "timestamp": 1676726061171, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py39h9e868ea_2.tar.bz2": { + "build": "py39h9e868ea_2", + "build_number": 2, + "depends": [ + "libcryptominisat 5.6.6 h9e868ea_2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95297a01f8e28906bd7a4a9c1dc9c058", + "name": "pycryptosat", + "sha256": "bdc3100dfda870737c9e8199ab06d7e0057deb720dcbd064eef3c9620a3529c0", + "size": 103954, + "subdir": "linux-64", + "timestamp": 1679313859841, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py39hc0fe6c6_0.tar.bz2": { + "build": "py39hc0fe6c6_0", + "build_number": 0, + "depends": [ + "libcryptominisat 5.6.6 hc0fe6c6_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "zlib" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "07d8c8cfbaf0e267a92494056e68a37d", + "name": "pycryptosat", + "sha256": "ef7d63145ae2cd13b9d45bd6824fd68c2066b9587c956fda17fa1554246e32a6", + "size": 99271, + "subdir": "linux-64", + "timestamp": 1611760486040, + "version": "5.6.6" + }, + "pyct-0.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "6603f3208f35c312b39711afa0397361", + "name": "pyct", + "sha256": "c226410fc3ceeeeaa4b76f9564756ed0de765828b5a7b8908b2885f5bb051ec8", + "size": 14257, + "subdir": "linux-64", + "timestamp": 1527635899999, + "version": "0.4.2" + }, + "pyct-0.4.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "63f83830166642148fa175e88dfd1356", + "name": "pyct", + "sha256": "9d2ca5ace64ee2a341dd4cc0f214a5591c60288c0d34ab32a860b2e1c284807a", + "size": 14538, + "subdir": "linux-64", + "timestamp": 1527635896722, + "version": "0.4.2" + }, + "pyct-0.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "d33d1d810e82b442eb44f8d1c79cb5a2", + "name": "pyct", + "sha256": "018a4fa872b65b49a2d21af7320c2f7ebdcd141b5fcf93720a4f2c3551d297f4", + "size": 14374, + "subdir": "linux-64", + "timestamp": 1527635820462, + "version": "0.4.2" + }, + "pyct-0.4.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5fcea72f1b5c47c3d851c90173b6cc86", + "name": "pyct", + "sha256": "554bf760af0adfe09e0430c40e6cfa7a8b8ee163c8075bedbff3a6d71e55cdbe", + "size": 16101, + "subdir": "linux-64", + "timestamp": 1529429092910, + "version": "0.4.3" + }, + "pyct-0.4.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ca1427c0e176e0c5cce806f75fcd6ad4", + "name": "pyct", + "sha256": "b532c64c6b6f0421465035020e714b07103b87b8f2642dff1ac2f7637076556c", + "size": 16361, + "subdir": "linux-64", + "timestamp": 1529429114475, + "version": "0.4.3" + }, + "pyct-0.4.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ef132f48e6e1792b752138063e86deb4", + "name": "pyct", + "sha256": "ac768dc56ffaa8541ad6b1f91e7511e5ea78a012c1cdcdf0a0119bfb6c320ddc", + "size": 16248, + "subdir": "linux-64", + "timestamp": 1529429071487, + "version": "0.4.3" + }, + "pyct-0.4.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f6a14e76f0a07a74ff28213cfd3d7d6b", + "name": "pyct", + "sha256": "5f8ad57bd90b4f53e6c14b203d3e172de85d5ad63bace17558ae424ef71549fb", + "size": 16970, + "subdir": "linux-64", + "timestamp": 1535603264919, + "version": "0.4.5" + }, + "pyct-0.4.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.5,<3.6.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "abadc53a1f22df5589ab2966c6f6457d", + "name": "pyct", + "sha256": "7700f333526c9f3ff8a15e576c95ed8206e0aab20c093485ffd06c67ccb05540", + "size": 17248, + "subdir": "linux-64", + "timestamp": 1535603319768, + "version": "0.4.5" + }, + "pyct-0.4.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fb24ca5a0b60efd99e903fdd3f571525", + "name": "pyct", + "sha256": "c192162df3fb05f752d4d6767bf0c38b0dabbe1eac3e0a6af048ebd6a56eecf3", + "size": 17215, + "subdir": "linux-64", + "timestamp": 1535603287506, + "version": "0.4.5" + }, + "pyct-0.4.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4e4a31f93af0c1a6b96a5cc8dc0fe6a7", + "name": "pyct", + "sha256": "381e58ac267fafce620d33448b48f016ee96b14c85cb91fe226acd9b2f5c6259", + "size": 17240, + "subdir": "linux-64", + "timestamp": 1535603332544, + "version": "0.4.5" + }, + "pyct-0.4.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d0cf1b1df083657aa3ac931f14b949fa", + "name": "pyct", + "sha256": "1914868ff621a746e0ca107151a307c29e4d1898fbf7705a39c9b96926d47c93", + "size": 23222, + "subdir": "linux-64", + "timestamp": 1545119462828, + "version": "0.4.6" + }, + "pyct-0.4.6-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.10,<3.11.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aa9ad56200e926157d63cc80750f5359", + "name": "pyct", + "sha256": "d0c26dc8bd4471bfad71523767ca4a996b8996c3cf4b10e72e61276762b5941a", + "size": 23947, + "subdir": "linux-64", + "timestamp": 1640810252981, + "version": "0.4.6" + }, + "pyct-0.4.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5f2857e0a2f4c89f2152c265132e9ea4", + "name": "pyct", + "sha256": "fcc0f0d6199fe16aabc07911cda265f20f65b92478777494b15de5f3c0844c94", + "size": 23444, + "subdir": "linux-64", + "timestamp": 1545119449898, + "version": "0.4.6" + }, + "pyct-0.4.6-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f2d0df92648ef17fa96c75097d9d3d7e", + "name": "pyct", + "sha256": "443b1716e02673806f5dc26e5e1fce898e1d43baa3c17044b58e69101d0891e1", + "size": 24405, + "subdir": "linux-64", + "timestamp": 1613411592459, + "version": "0.4.6" + }, + "pyct-0.4.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ad5846d9f1cdfe27bb0de045b0fc69cb", + "name": "pyct", + "sha256": "ebcd72c5278bd25a7dc0e60c33f8af7daff63f3bb221108ab45ab478ac1a309f", + "size": 23462, + "subdir": "linux-64", + "timestamp": 1545119486906, + "version": "0.4.6" + }, + "pyct-0.4.6-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e4c72df9ca30872b9ff447ce80cc213e", + "name": "pyct", + "sha256": "a9a058955a8fa269e560fca60282b0231cff758cf182e22023c7ff06c55d4ab1", + "size": 24420, + "subdir": "linux-64", + "timestamp": 1613410998908, + "version": "0.4.6" + }, + "pyct-0.4.6-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "96d4d733dc8d7d52e341c174dd3b4737", + "name": "pyct", + "sha256": "32fa6a8bd6fbd696fa8d210f1120c2dcdca3d689abe5d1679a6470694790f698", + "size": 23804, + "subdir": "linux-64", + "timestamp": 1574238730555, + "version": "0.4.6" + }, + "pyct-0.4.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d7350ea532107b7330c6449f85380404", + "name": "pyct", + "sha256": "4e210021f1cfeb89f7ef88d0adf4ed551849b3aec59233f44a1bd2e9945e89de", + "size": 24465, + "subdir": "linux-64", + "timestamp": 1613411592966, + "version": "0.4.6" + }, + "pyct-0.4.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4cb3d2b2e054cfb09f1b37a5742bb292", + "name": "pyct", + "sha256": "9333f10cd25521e5549b6bb095b6d837e08dc3aecbec793cfb5e875223881668", + "size": 24515, + "subdir": "linux-64", + "timestamp": 1613411592963, + "version": "0.4.6" + }, + "pyct-0.4.8-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "param >=1.7.0", + "python >=3.10,<3.11.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "11e1b146d94100ec753dbd6dad60ee87", + "name": "pyct", + "sha256": "784ca190af81eb40f3897135ada674d081299033dc842b5229911a69bdb63bd1", + "size": 29948, + "subdir": "linux-64", + "timestamp": 1658500434083, + "version": "0.4.8" + }, + "pyct-0.4.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c6f16fedf60e95870be35850de61bd63", + "name": "pyct", + "sha256": "2083b9b30b51ffcb9b01c576e72b53ab407a615d003f7fa374dfc0acf793233f", + "size": 28663, + "subdir": "linux-64", + "timestamp": 1600458321091, + "version": "0.4.8" + }, + "pyct-0.4.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c70bc87247a9a486d1869e15ef6ce026", + "name": "pyct", + "sha256": "7b8ac5faad0a39057b26a993252e3f7a0aa079a8c9bc3e515c60c8374aa791cf", + "size": 28731, + "subdir": "linux-64", + "timestamp": 1600458312557, + "version": "0.4.8" + }, + "pyct-0.4.8-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "param >=1.7.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c55ae1c0b322ab875e6fc1840f026c4f", + "name": "pyct", + "sha256": "4f01efc346590cac90cf06a43fa72337141ea677f0a01461c64a42013698d75b", + "size": 29688, + "subdir": "linux-64", + "timestamp": 1658500370660, + "version": "0.4.8" + }, + "pyct-0.4.8-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f255b2fa130c35ed3449f5493976861c", + "name": "pyct", + "sha256": "4a7e200a4f6d1fb91d32084c4fcfed2eb1bc9241b7c0cc3dfcfc5631839e03d6", + "size": 28807, + "subdir": "linux-64", + "timestamp": 1600458313779, + "version": "0.4.8" + }, + "pyct-0.4.8-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "param >=1.7.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5a1d7125560845033737853f39082328", + "name": "pyct", + "sha256": "c59074cf21d9088e104e424f39d442431ac96093ad42ed6b3971ff9166f7e89e", + "size": 29747, + "subdir": "linux-64", + "timestamp": 1658500396865, + "version": "0.4.8" + }, + "pyct-0.4.8-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "param >=1.7.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7af45281c120891a401ec2ef6a92f830", + "name": "pyct", + "sha256": "a518564ebe5b6c1d689556fb99f1ed2ef933665d302e92c6ec8627bfbc97ffcc", + "size": 29784, + "subdir": "linux-64", + "timestamp": 1658500343635, + "version": "0.4.8" + }, + "pyct-0.5.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.10,<3.11.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2b2a9be6bf17df2c01ceb1e622de6fab", + "name": "pyct", + "sha256": "f28841b5157e89b26186c8e6f941e4f601a0bbb20807245d88a6af6dcca800cd", + "size": 29492, + "subdir": "linux-64", + "timestamp": 1675441593109, + "version": "0.5.0" + }, + "pyct-0.5.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.11,<3.12.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb56c0358b65665f4dd509a4635f6f3c", + "name": "pyct", + "sha256": "eb75b4417565d25e2d1006db75aa8bd9da6b6c72a929954b01a31b9bf5f8b42e", + "size": 37802, + "subdir": "linux-64", + "timestamp": 1676838557935, + "version": "0.5.0" + }, + "pyct-0.5.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e02e36449b587f406b576d1270fc044a", + "name": "pyct", + "sha256": "552da686c02c4617530d7e61ac480105fa250daab42cd10baea1d8724fda2e6b", + "size": 29186, + "subdir": "linux-64", + "timestamp": 1675441538333, + "version": "0.5.0" + }, + "pyct-0.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b09b43fc9f274c994af65adefa36279f", + "name": "pyct", + "sha256": "dd70dbec022d1fca1fb2168bb81eeb2d970d53494f4bb4ce36751d70ce960b79", + "size": 29267, + "subdir": "linux-64", + "timestamp": 1675441565524, + "version": "0.5.0" + }, + "pyct-0.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f36ecb722522cbe2e3737424edf1b5e1", + "name": "pyct", + "sha256": "53fa6ed14cb22b8cb879f0ecf45cca8f3013b8ebcfa89456c85b3947ce4ab109", + "size": 29312, + "subdir": "linux-64", + "timestamp": 1675441510984, + "version": "0.5.0" + }, + "pyct-core-0.4.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "pyct 0.4.5" + ], + "depends": [ + "param >=1.7.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8dc5886493713b3133acb5af638da067", + "name": "pyct-core", + "sha256": "684575dd5f72c2733a884c34cab7347506ef5ed53df013198cd766a36087ccec", + "size": 17260, + "subdir": "linux-64", + "timestamp": 1540061215476, + "version": "0.4.5" + }, + "pyct-core-0.4.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pyct 0.4.5" + ], + "depends": [ + "param >=1.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b386822bda15ddc2820858a165c707b3", + "name": "pyct-core", + "sha256": "32cad7f80d29f19c9c7ec60e41c20ed155d4fd9625eb1029da38230a1a863260", + "size": 17418, + "subdir": "linux-64", + "timestamp": 1540061219564, + "version": "0.4.5" + }, + "pyct-core-0.4.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pyct 0.4.5" + ], + "depends": [ + "param >=1.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "34dd80675dde9878ebb7e11224545803", + "name": "pyct-core", + "sha256": "eb34d768049be8898745436e40aa1cbbab14cad6cee0e04e938ee20716c331b8", + "size": 17484, + "subdir": "linux-64", + "timestamp": 1540061225902, + "version": "0.4.5" + }, + "pycurl-7.43.0-py27hcf8ebea_3.tar.bz2": { + "build": "py27hcf8ebea_3", + "build_number": 3, + "depends": [ + "curl 7.55.*", + "libgcc-ng >=7.2.0", + "openssl 1.0.2*", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "2a4da8d7ed2c0e515facd4c044b4354f", + "name": "pycurl", + "sha256": "81f7e990ea6766b441ad7b4868bb6e181793e77796e6723990db24e7cc1ffe67", + "size": 56496, + "subdir": "linux-64", + "timestamp": 1505751642893, + "version": "7.43.0" + }, + "pycurl-7.43.0-py35h7a9665c_3.tar.bz2": { + "build": "py35h7a9665c_3", + "build_number": 3, + "depends": [ + "curl 7.55.*", + "libgcc-ng >=7.2.0", + "openssl 1.0.2*", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "037fba0a6d02345d3e682993eced1955", + "name": "pycurl", + "sha256": "d390ee25ba4d89f02776327a7b206902553a175b05cbea1259b3c21ebc33d261", + "size": 56569, + "subdir": "linux-64", + "timestamp": 1505751661748, + "version": "7.43.0" + }, + "pycurl-7.43.0-py36h5e72054_3.tar.bz2": { + "build": "py36h5e72054_3", + "build_number": 3, + "depends": [ + "curl 7.55.*", + "libgcc-ng >=7.2.0", + "openssl 1.0.2*", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "c5a2e1b88e71979dbad1eab287f77f3e", + "name": "pycurl", + "sha256": "949c127c6546cc05d815e14e08c58e8da06ddaa32a699b5c1a16183b49ded680", + "size": 56556, + "subdir": "linux-64", + "timestamp": 1505751681035, + "version": "7.43.0" + }, + "pycurl-7.43.0.1-py27hb7f436b_0.tar.bz2": { + "build": "py27hb7f436b_0", + "build_number": 0, + "depends": [ + "curl >=7.55.1,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2n,<1.0.3a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "228bf4342ac56b1a338031e5d3fffcc6", + "name": "pycurl", + "sha256": "c4ba54cecc2e85be9b541c8f67f37b7c6f3e73744b8ab1713eaea0306cf2ebb9", + "size": 58478, + "subdir": "linux-64", + "timestamp": 1515725591739, + "version": "7.43.0.1" + }, + "pycurl-7.43.0.1-py35hb7f436b_0.tar.bz2": { + "build": "py35hb7f436b_0", + "build_number": 0, + "depends": [ + "curl >=7.55.1,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2n,<1.0.3a", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "0e277a645114132cf39a00852517aff9", + "name": "pycurl", + "sha256": "0f9b16f6489248d810ec5e70d473da9cd42bf5223a146f0bd0a5eb8994f6a6bc", + "size": 58613, + "subdir": "linux-64", + "timestamp": 1515725600173, + "version": "7.43.0.1" + }, + "pycurl-7.43.0.1-py36hb7f436b_0.tar.bz2": { + "build": "py36hb7f436b_0", + "build_number": 0, + "depends": [ + "curl >=7.55.1,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2n,<1.0.3a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "b6d2c158bdf07f3a372b09d1ca264c90", + "name": "pycurl", + "sha256": "1fa3dea06bdef44428653f647451655c4e794f450fb6293d67f1bd16ad0ee64e", + "size": 58580, + "subdir": "linux-64", + "timestamp": 1515725732105, + "version": "7.43.0.1" + }, + "pycurl-7.43.0.2-py27h1ba5d50_0.tar.bz2": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.63.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "bbb756beecb0034e035cb7134a9f668d", + "name": "pycurl", + "sha256": "d2574589d852dbe91dd0a285f790458774740601a41f06ed4bf804ffadc1a117", + "size": 188726, + "subdir": "linux-64", + "timestamp": 1545162535004, + "version": "7.43.0.2" + }, + "pycurl-7.43.0.2-py27hb7f436b_0.tar.bz2": { + "build": "py27hb7f436b_0", + "build_number": 0, + "depends": [ + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "e1c73acb93ed8808e074eaa0590260e8", + "name": "pycurl", + "sha256": "7528678443621cc4151ded33c0a598bef4315c324a96c02661ce6aceb93ce74f", + "size": 61627, + "subdir": "linux-64", + "timestamp": 1528213398878, + "version": "7.43.0.2" + }, + "pycurl-7.43.0.2-py35hb7f436b_0.tar.bz2": { + "build": "py35hb7f436b_0", + "build_number": 0, + "depends": [ + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "94e8d8238d2fc3b84d6a4a1dbcd920f5", + "name": "pycurl", + "sha256": "bd063423b1100fc8b55613324aff82d4d4ee8c59226ce5eb94c9351e01e0eeed", + "size": 61937, + "subdir": "linux-64", + "timestamp": 1528213418287, + "version": "7.43.0.2" + }, + "pycurl-7.43.0.2-py36h1ba5d50_0.tar.bz2": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.63.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "7888f85a24515945a71ca22e45407249", + "name": "pycurl", + "sha256": "0e0a7a1fa03985a8b8463a63ec92bc16599470e12abbd14af99c71aeb3a89ecf", + "size": 189041, + "subdir": "linux-64", + "timestamp": 1545162637336, + "version": "7.43.0.2" + }, + "pycurl-7.43.0.2-py36hb7f436b_0.tar.bz2": { + "build": "py36hb7f436b_0", + "build_number": 0, + "depends": [ + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "66e791037ca68c8f73040535dd39f048", + "name": "pycurl", + "sha256": "189e5549b51951630641c78c4691491a044fa7522a77d47a6a9416c22a2a7730", + "size": 61937, + "subdir": "linux-64", + "timestamp": 1528213315569, + "version": "7.43.0.2" + }, + "pycurl-7.43.0.2-py37h1ba5d50_0.tar.bz2": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.63.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "bdfa00eb7bf42b9c8c9b66299d18591a", + "name": "pycurl", + "sha256": "e6b285196f5bd56310fcfa2297319c61e602fb836d1a6f47d8b52a7b9e4d49f9", + "size": 189047, + "subdir": "linux-64", + "timestamp": 1545162939702, + "version": "7.43.0.2" + }, + "pycurl-7.43.0.2-py37hb7f436b_0.tar.bz2": { + "build": "py37hb7f436b_0", + "build_number": 0, + "depends": [ + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "c48935b91294dfc7f987b692eafc8983", + "name": "pycurl", + "sha256": "7ce41e36899361f235faf37103eb3728f0cce33ec02abda70a6388ec7a7eb6ed", + "size": 61961, + "subdir": "linux-64", + "timestamp": 1530915992695, + "version": "7.43.0.2" + }, + "pycurl-7.43.0.3-py27h1ba5d50_0.tar.bz2": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.64.1,<8.0a0", + "openssl >=1.1.1c,<1.1.2a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "afec8bc8dff9836ce69f813c5289ad69", + "name": "pycurl", + "sha256": "ac28c672de416293d0ddefe8d596d20c8fe38352ecd6c42f73d533ca055aacbd", + "size": 71060, + "subdir": "linux-64", + "timestamp": 1562091279544, + "version": "7.43.0.3" + }, + "pycurl-7.43.0.3-py36h1ba5d50_0.tar.bz2": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.64.1,<8.0a0", + "openssl >=1.1.1c,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "18886edbe3753b78e0e0e7de2545f936", + "name": "pycurl", + "sha256": "6f67f06fdc3eb4d3bad23e0c6e0333fcfb3e30dd2a0133cdfe9abcf4067d6ce1", + "size": 71415, + "subdir": "linux-64", + "timestamp": 1562091280074, + "version": "7.43.0.3" + }, + "pycurl-7.43.0.3-py37h1ba5d50_0.tar.bz2": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.64.1,<8.0a0", + "openssl >=1.1.1c,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "2fb6e6e72e328124aa4b56f9b51261c2", + "name": "pycurl", + "sha256": "d5ad8bb5c0f442dcf3981d728d14185a34422131611f6f101a182c4aa9272739", + "size": 71427, + "subdir": "linux-64", + "timestamp": 1562091277542, + "version": "7.43.0.3" + }, + "pycurl-7.43.0.3-py38h1ba5d50_0.tar.bz2": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.65.3,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "91196d7243ee0b7147151472ec5ed6d9", + "name": "pycurl", + "sha256": "00e9ff3b79fa1cfc07dcb60401c1c9c08b508fdb43685813400725e5226e1948", + "size": 79769, + "subdir": "linux-64", + "timestamp": 1573669040897, + "version": "7.43.0.3" + }, + "pycurl-7.43.0.4-py36h1ba5d50_0.tar.bz2": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.67.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "2e54c2cea5009d2baebdd69df238d422", + "name": "pycurl", + "sha256": "9c1cfd1e43274ae69fdf9a3437e0670d6dac4fce62e94e055397773c33cddeea", + "size": 72792, + "subdir": "linux-64", + "timestamp": 1580152703579, + "version": "7.43.0.4" + }, + "pycurl-7.43.0.4-py37h1ba5d50_0.tar.bz2": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.67.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "afa5850db1484fae2c9bbe24ef3871ff", + "name": "pycurl", + "sha256": "93576eb0785a4f76c7f34cac2c770bbe48415134ccda0d750920ab411b363e89", + "size": 72841, + "subdir": "linux-64", + "timestamp": 1580152789061, + "version": "7.43.0.4" + }, + "pycurl-7.43.0.4-py38h1ba5d50_0.tar.bz2": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.67.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "ba1272ef1496966345dc28f3a3b47a73", + "name": "pycurl", + "sha256": "3f652b1f5830f5cd77b81be92a1dbf38ba7c4ac81ef2dbbe6773684b869be20d", + "size": 74723, + "subdir": "linux-64", + "timestamp": 1580152811239, + "version": "7.43.0.4" + }, + "pycurl-7.43.0.5-py36h1ba5d50_0.tar.bz2": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.67.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "b7ca8ac4d61f3310fe9c5d7802627ace", + "name": "pycurl", + "sha256": "32e6dbf2ce3b243e2f4007cdc6673d30fee9211ed8a9875a3fc548f590fe2175", + "size": 73205, + "subdir": "linux-64", + "timestamp": 1580835694226, + "version": "7.43.0.5" + }, + "pycurl-7.43.0.5-py37h1ba5d50_0.tar.bz2": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.67.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "19bcad77154719d3d24d5f6c60cf0668", + "name": "pycurl", + "sha256": "04bc63575c990e10986d4c6f884cce0da4c86b4ea1f2e3c08195c11f4e4327d4", + "size": 73221, + "subdir": "linux-64", + "timestamp": 1580835662761, + "version": "7.43.0.5" + }, + "pycurl-7.43.0.5-py38h1ba5d50_0.tar.bz2": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.67.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "12c6fcd6973ed4153f55ca747d69d369", + "name": "pycurl", + "sha256": "3ff895ffb9497ae653dff683824bea691e0f93a5f3d72306f2e244264043b816", + "size": 75050, + "subdir": "linux-64", + "timestamp": 1580835669530, + "version": "7.43.0.5" + }, + "pycurl-7.43.0.6-py36h1ba5d50_0.tar.bz2": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "9b5c7dc075fc084ecc76bd9c3f86f5ac", + "name": "pycurl", + "sha256": "3de03c2c404f8d94aa4c249f5f21897d79d6e34e8e84c3575899b67b2fa605a9", + "size": 71030, + "subdir": "linux-64", + "timestamp": 1602278726855, + "version": "7.43.0.6" + }, + "pycurl-7.43.0.6-py37h1ba5d50_0.tar.bz2": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "542558efef0fad17324facbc259b1b22", + "name": "pycurl", + "sha256": "269f661f579ca0af78db6c2ff446d166cd952e97f579dd41ff513b240960f1f0", + "size": 70994, + "subdir": "linux-64", + "timestamp": 1602278691793, + "version": "7.43.0.6" + }, + "pycurl-7.43.0.6-py38h1ba5d50_0.tar.bz2": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "f621d3504d2e7ff8f292f334a7d59884", + "name": "pycurl", + "sha256": "18e6c2d285c51a3bf08b3d350a8208d7b579f2d91a004a8d16e84f22b7621cea", + "size": 72647, + "subdir": "linux-64", + "timestamp": 1602278720983, + "version": "7.43.0.6" + }, + "pycurl-7.43.0.6-py39h8b3b800_0.tar.bz2": { + "build": "py39h8b3b800_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "4e1196db5e9c7fe5b2b0136a03de2db9", + "name": "pycurl", + "sha256": "721be6f19ddbfa1a749fa69cf02fafdea6344b1f6322f773aea28ec997ac2442", + "size": 75267, + "subdir": "linux-64", + "timestamp": 1608015764035, + "version": "7.43.0.6" + }, + "pycurl-7.44.0-py37h8f2d780_0.tar.bz2": { + "build": "py37h8f2d780_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1k,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "86690aba018c5c69eabb38a8da072481", + "name": "pycurl", + "sha256": "8147aa2f5da690d63a0129cd38bf48bda3007e5d6be728cd8fcdb0ab6ca61a66", + "size": 71183, + "subdir": "linux-64", + "timestamp": 1628603911835, + "version": "7.44.0" + }, + "pycurl-7.44.0-py38h8f2d780_0.tar.bz2": { + "build": "py38h8f2d780_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1k,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "8cab4359253b486af3c22839a63d47be", + "name": "pycurl", + "sha256": "65a6b91eafd540385e3889b99b30c56fc66d1425eb413b5304c352042093d913", + "size": 72931, + "subdir": "linux-64", + "timestamp": 1628603913317, + "version": "7.44.0" + }, + "pycurl-7.44.0-py39h8f2d780_0.tar.bz2": { + "build": "py39h8f2d780_0", + "build_number": 0, + "depends": [ + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1k,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "28ffe99a8c6eea13b16357e3d4554573", + "name": "pycurl", + "sha256": "1b6ca785a5a2941bdb3b35067ebd00dc279fae8ca6858abc3ba52cf45fe57e4d", + "size": 73153, + "subdir": "linux-64", + "timestamp": 1629128040148, + "version": "7.44.0" + }, + "pycurl-7.44.1-py310h8f2d780_1.tar.bz2": { + "build": "py310h8f2d780_1", + "build_number": 1, + "depends": [ + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "f611e21c50ad44c120be1721ff11a11c", + "name": "pycurl", + "sha256": "7dbc6321223c0c8b06b42c232ed378c0dfe65bf0d2448f8c43216259662508ad", + "size": 287022, + "subdir": "linux-64", + "timestamp": 1640792988557, + "version": "7.44.1" + }, + "pycurl-7.44.1-py36h8f2d780_1.tar.bz2": { + "build": "py36h8f2d780_1", + "build_number": 1, + "depends": [ + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "da6b8bdd10800add1dfd2d013b2926d4", + "name": "pycurl", + "sha256": "727b0b215fe642a43844338f55744564ae617761ee0dd99cd9f76077a8c53845", + "size": 74325, + "subdir": "linux-64", + "timestamp": 1632849190636, + "version": "7.44.1" + }, + "pycurl-7.44.1-py37h8f2d780_1.tar.bz2": { + "build": "py37h8f2d780_1", + "build_number": 1, + "depends": [ + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "cf017e0b01a1c66983cadb4f200223bf", + "name": "pycurl", + "sha256": "23aad60f3fdbe371bb066aab70ef006db42be51e29889a5995e446dc6e954043", + "size": 74364, + "subdir": "linux-64", + "timestamp": 1632859590278, + "version": "7.44.1" + }, + "pycurl-7.44.1-py38h8f2d780_1.tar.bz2": { + "build": "py38h8f2d780_1", + "build_number": 1, + "depends": [ + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "5ded7370f7dc9bd7127f06e609a278a0", + "name": "pycurl", + "sha256": "d675c6740f9f4dce3d53dac410f1fb882228ade07c68add55530fe3892aaae7e", + "size": 75858, + "subdir": "linux-64", + "timestamp": 1632859494562, + "version": "7.44.1" + }, + "pycurl-7.44.1-py39h8f2d780_0.tar.bz2": { + "build": "py39h8f2d780_0", + "build_number": 0, + "depends": [ + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1k,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "d86e530547974441d828605e8b744d09", + "name": "pycurl", + "sha256": "fa0bc084f98c1108456e06b432c427c66b0b48a8f7657dc7ba15230e89f7b23b", + "size": 73097, + "subdir": "linux-64", + "timestamp": 1629215444775, + "version": "7.44.1" + }, + "pycurl-7.44.1-py39h8f2d780_1.tar.bz2": { + "build": "py39h8f2d780_1", + "build_number": 1, + "depends": [ + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "e523261f87b0ba6d1cb27d8030eb3ea5", + "name": "pycurl", + "sha256": "d454f3da046dd7451740ec202ad3fcc9f0fd0bc032e65298f49f9252ce418ff3", + "size": 76172, + "subdir": "linux-64", + "timestamp": 1632859583395, + "version": "7.44.1" + }, + "pycurl-7.45.1-py310h8f2d780_0.tar.bz2": { + "build": "py310h8f2d780_0", + "build_number": 0, + "depends": [ + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1o,<1.1.2a", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1-only, MIT", + "license_family": "LGPL", + "md5": "c672637611a354a23eaea9c86ac67566", + "name": "pycurl", + "sha256": "a1c033c7112fafd56482243f491118f2e3b8b5195d4e3ccedf2c489741272741", + "size": 297255, + "subdir": "linux-64", + "timestamp": 1655908752847, + "version": "7.45.1" + }, + "pycurl-7.45.1-py311h37d81fd_0.tar.bz2": { + "build": "py311h37d81fd_0", + "build_number": 0, + "depends": [ + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.1-only, MIT", + "license_family": "LGPL", + "md5": "c9359108bf3e238763d715264aa6c3ab", + "name": "pycurl", + "sha256": "eff6c15ab36c14148d26991bf15fd08be7cea785bcaebacb90c84b440af416bf", + "size": 77136, + "subdir": "linux-64", + "timestamp": 1676860706354, + "version": "7.45.1" + }, + "pycurl-7.45.1-py37h8f2d780_0.tar.bz2": { + "build": "py37h8f2d780_0", + "build_number": 0, + "depends": [ + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1o,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-only, MIT", + "license_family": "LGPL", + "md5": "a990063caeb59dbce47250ece3f40f35", + "name": "pycurl", + "sha256": "2de21baa038a025d948240fb5bcd22a5822f4bbee7f5cd5c120b46f37cbe101a", + "size": 131069, + "subdir": "linux-64", + "timestamp": 1655908608678, + "version": "7.45.1" + }, + "pycurl-7.45.1-py38h8f2d780_0.tar.bz2": { + "build": "py38h8f2d780_0", + "build_number": 0, + "depends": [ + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1o,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-only, MIT", + "license_family": "LGPL", + "md5": "6e019eb25a527199422c4549438bc59e", + "name": "pycurl", + "sha256": "3512e885e361f6de44be4de99c3afed0e6c2b2be94111bb5725613280a96c08b", + "size": 133172, + "subdir": "linux-64", + "timestamp": 1655908795989, + "version": "7.45.1" + }, + "pycurl-7.45.1-py39h8f2d780_0.tar.bz2": { + "build": "py39h8f2d780_0", + "build_number": 0, + "depends": [ + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1o,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-only, MIT", + "license_family": "LGPL", + "md5": "557b4f67b9ad51b8a54a15d9a9e0d497", + "name": "pycurl", + "sha256": "1d454d4fd909b58011e800b0f492a63221400ff5567de6b4eb1673a49da41a7d", + "size": 132939, + "subdir": "linux-64", + "timestamp": 1655908671219, + "version": "7.45.1" + }, + "pycurl-7.45.2-py310h37d81fd_0.tar.bz2": { + "build": "py310h37d81fd_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1-or-later OR MIT", + "license_family": "LGPL", + "md5": "ea293d4bd48a1e218338e6d472a01c98", + "name": "pycurl", + "sha256": "3f96fb23951f25158dd4353507bb5921ab494b7a0e061888b8a090b7bb5a1661", + "size": 133665, + "subdir": "linux-64", + "timestamp": 1678832660507, + "version": "7.45.2" + }, + "pycurl-7.45.2-py311h37d81fd_0.tar.bz2": { + "build": "py311h37d81fd_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.1-or-later OR MIT", + "license_family": "LGPL", + "md5": "0289f98335c537f3a948c35857fb7fad", + "name": "pycurl", + "sha256": "310937b2eaad46625272565968d11fe56efa87d3f8eed7ddce75909f3a05806b", + "size": 144534, + "subdir": "linux-64", + "timestamp": 1679337454892, + "version": "7.45.2" + }, + "pycurl-7.45.2-py38h37d81fd_0.tar.bz2": { + "build": "py38h37d81fd_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-or-later OR MIT", + "license_family": "LGPL", + "md5": "a801ff737c33c80745e013b12a40d3c9", + "name": "pycurl", + "sha256": "bcca73327815733dbaf2c809fffca6ac3d5a6e36ec5d64ef7198b404b77d3b75", + "size": 134071, + "subdir": "linux-64", + "timestamp": 1678832627454, + "version": "7.45.2" + }, + "pycurl-7.45.2-py39h37d81fd_0.tar.bz2": { + "build": "py39h37d81fd_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-or-later OR MIT", + "license_family": "LGPL", + "md5": "26448857c4e0e87954fbcd2e66776087", + "name": "pycurl", + "sha256": "75f8398e2280a39ce086c0c9ae33708f4544fb20f2fb2d31beb202645fa2af15", + "size": 133247, + "subdir": "linux-64", + "timestamp": 1678832691432, + "version": "7.45.2" + }, + "pydantic-1.10.2-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "constrains": [ + "email-validator >=1.0.3" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "typing-extensions >=4.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cec1bee310c9ae7f1271b0e2ee242eea", + "name": "pydantic", + "sha256": "60006cfeb15a8673df0a965bac3ffd5637e18627d633fe5a2ef7468db8c62117", + "size": 2559841, + "subdir": "linux-64", + "timestamp": 1667416260903, + "version": "1.10.2" + }, + "pydantic-1.10.2-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "constrains": [ + "email-validator >=1.0.3" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "typing-extensions >=4.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7764c33f2da9c380171da99aba52b1ba", + "name": "pydantic", + "sha256": "52c6dc298e86cf40b1e3850763b90c2db137807e61ce652787389755bdcb1236", + "size": 2640710, + "subdir": "linux-64", + "timestamp": 1676842212759, + "version": "1.10.2" + }, + "pydantic-1.10.2-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "constrains": [ + "email-validator >=1.0.3" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=4.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ab8937a500e1962b3844a68910bb7a3", + "name": "pydantic", + "sha256": "ff4ca186f0d4e55be693e694a5a6e7740c95f878d18d03f77227d4fa16fe78b8", + "size": 2504127, + "subdir": "linux-64", + "timestamp": 1667416409878, + "version": "1.10.2" + }, + "pydantic-1.10.2-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "constrains": [ + "email-validator >=1.0.3" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=4.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bace505f784a28e1585f5ac00f3ff751", + "name": "pydantic", + "sha256": "879c2d406958f68520ad7b83ecfc0acd877caa9df5ffcec6c22fb51e65632f90", + "size": 2648579, + "subdir": "linux-64", + "timestamp": 1667416679727, + "version": "1.10.2" + }, + "pydantic-1.10.2-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "constrains": [ + "email-validator >=1.0.3" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=4.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "797097002cd95da6924014e379d76d30", + "name": "pydantic", + "sha256": "4535d1340eec94c48cadaac1e3b2e02f15cabefcf6d1f560852c3d8629173baf", + "size": 2596122, + "subdir": "linux-64", + "timestamp": 1667416539819, + "version": "1.10.2" + }, + "pydantic-1.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "dataclasses >=0.6", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6faa27421d8cbf781d7cbf00f7f3f6e", + "name": "pydantic", + "sha256": "d5731d6b27c17e62812a49635d13e8901239b7e4ca2c05930c62343c2f95f191", + "size": 1850114, + "subdir": "linux-64", + "timestamp": 1585084118123, + "version": "1.2" + }, + "pydantic-1.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b4158edb588b858147beceb4cda88f1", + "name": "pydantic", + "sha256": "8eddad0755cd8a1208faa12e017adbcfb56001440cc8e896c6ee1924a4e4bf34", + "size": 1844758, + "subdir": "linux-64", + "timestamp": 1585084130415, + "version": "1.2" + }, + "pydantic-1.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d46a60ffdcb07e787e315d995597a73", + "name": "pydantic", + "sha256": "d2ed97aa513790a190367e5ed2283d775982e048bfbf244f7ed37d1145a2eae6", + "size": 1960855, + "subdir": "linux-64", + "timestamp": 1585084089957, + "version": "1.2" + }, + "pydantic-1.4-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "dataclasses >=0.6", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a4a64bca03c487b46f1f4048f2c25d3c", + "name": "pydantic", + "sha256": "d58df9fc01900462beaa2ffe7dfa0b17dc39537e7cd56f2f2e95d7b573f760f7", + "size": 1960581, + "subdir": "linux-64", + "timestamp": 1585074386678, + "version": "1.4" + }, + "pydantic-1.4-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e378dbe2dc2cfdc5be3955562c4d5531", + "name": "pydantic", + "sha256": "01f5f9d68f1e87bf97e164bde52ddbeafd1edee943a84a4dd4d455d8f38fe5c8", + "size": 1963336, + "subdir": "linux-64", + "timestamp": 1585074328718, + "version": "1.4" + }, + "pydantic-1.4-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee6efc2bdeb73fc9a6ae8de2b56f8051", + "name": "pydantic", + "sha256": "47d37e38f81eafcf2bed2b2842d1a6281c088e5e16331ebc4016df0e8ad95fa2", + "size": 2049891, + "subdir": "linux-64", + "timestamp": 1585074373480, + "version": "1.4" + }, + "pydantic-1.5.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "dataclasses >=0.6", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5704e5a5a89d643a2e9aa4af9f33fa1d", + "name": "pydantic", + "sha256": "5143735ee47a9de5845271d1c945a5763ff3211bd3a3a51c932823e7b3de2679", + "size": 2050534, + "subdir": "linux-64", + "timestamp": 1588598361540, + "version": "1.5.1" + }, + "pydantic-1.5.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "016c87870635e68b4d11f3bf50c70971", + "name": "pydantic", + "sha256": "9a07f9b47bec300bcc96b03afe78400a786adfed3e241332f3df57bd821e1d04", + "size": 2047654, + "subdir": "linux-64", + "timestamp": 1588598359134, + "version": "1.5.1" + }, + "pydantic-1.5.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7451bcfb86e1e67cdb63574317942d5d", + "name": "pydantic", + "sha256": "78636a10f49806d00504bd5bfa7cf99e3bd528af8510160aa85a229771e89292", + "size": 2153244, + "subdir": "linux-64", + "timestamp": 1588598363544, + "version": "1.5.1" + }, + "pydantic-1.6.1-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3deb44aa2aafe00f60cc696c79b72dce", + "name": "pydantic", + "sha256": "d4387feddf26a39a56bee20f5032d7e0de40aa1a3b0d293c8b60f3e32ddd5434", + "size": 1807458, + "subdir": "linux-64", + "timestamp": 1596916379757, + "version": "1.6.1" + }, + "pydantic-1.7.1-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "dataclasses >=0.6", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "adae158c61f822eea2017c026dfd7c86", + "name": "pydantic", + "sha256": "a504b8ae9b69ceeb821307acd16c0a442dfd0bc8cd144a09aba11715fea1b3a9", + "size": 1934107, + "subdir": "linux-64", + "timestamp": 1604103145142, + "version": "1.7.1" + }, + "pydantic-1.7.1-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d3df490c204c960fab22ac032ed44b2", + "name": "pydantic", + "sha256": "681a3920a0f47c0e8553bac1780381250418b2b1b1ed4992ba7dad4c3b879857", + "size": 1920484, + "subdir": "linux-64", + "timestamp": 1604103154126, + "version": "1.7.1" + }, + "pydantic-1.7.1-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f25e5b92a094763f8bd20d081c37d244", + "name": "pydantic", + "sha256": "4d2f09e358ba5c351450417f2fe30dd2476ae3e3284554c800270e3986576c03", + "size": 2039715, + "subdir": "linux-64", + "timestamp": 1604103149089, + "version": "1.7.1" + }, + "pydantic-1.7.2-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "dataclasses >=0.6", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "119ba386ad07733f8c7518a9a586f84d", + "name": "pydantic", + "sha256": "a086e32e02e2c64427bd4b47c7d4aa4e37d27a49ca85f89d394077fd8edbcb23", + "size": 1934490, + "subdir": "linux-64", + "timestamp": 1604416568501, + "version": "1.7.2" + }, + "pydantic-1.7.2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1bc456b858bba0d4985d6e90cc5fddf", + "name": "pydantic", + "sha256": "5a098e70b682913d6fe1a7a1dcc0477abfeef91ec55cba2c666ceb4a75bfa275", + "size": 1924967, + "subdir": "linux-64", + "timestamp": 1604416568118, + "version": "1.7.2" + }, + "pydantic-1.7.2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01503041ecfd8e087d0fda74d0b538dc", + "name": "pydantic", + "sha256": "5e54ab0f6cd3db978dffb6309a312619911e7d82ab7dbeb00c622ca2583e7164", + "size": 2037210, + "subdir": "linux-64", + "timestamp": 1604416587426, + "version": "1.7.2" + }, + "pydantic-1.7.3-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "dataclasses >=0.6", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63d32edeb60142e0ed97ea803ebf7f4f", + "name": "pydantic", + "sha256": "110eef76dc0ab795ee16a633aa31a13d37250343b09be24aaa62629ddbca1a8b", + "size": 1938819, + "subdir": "linux-64", + "timestamp": 1606863552216, + "version": "1.7.3" + }, + "pydantic-1.7.3-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5908e11bda729bfc302159ba0b879b03", + "name": "pydantic", + "sha256": "3955d8d25105a1212fa1191facea1c04f092a04b2eefa62aa999f7e97b180082", + "size": 1932904, + "subdir": "linux-64", + "timestamp": 1606863517154, + "version": "1.7.3" + }, + "pydantic-1.7.3-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71c0768d1eed09b968313f41d7e683bc", + "name": "pydantic", + "sha256": "01b1a2b2c0955215be67b8479f45270a296f0e29b1d10523290559ba26b8995e", + "size": 2040530, + "subdir": "linux-64", + "timestamp": 1606863499583, + "version": "1.7.3" + }, + "pydantic-1.7.3-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bfce2843b676a7b742a540b60e469324", + "name": "pydantic", + "sha256": "7fcb7d5d3a79998efc853615d61dfcdf51d1957e94b2bf68276bd63eca31fe9e", + "size": 2043689, + "subdir": "linux-64", + "timestamp": 1606863558234, + "version": "1.7.3" + }, + "pydantic-1.8.1-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "dataclasses >=0.6", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3c8c05d5928da0db356ff2ab81c0da8", + "name": "pydantic", + "sha256": "d60efe4e389f4bbafb056b2c51cafbb7e2a412227f4afa6111b87868d847edcd", + "size": 2155521, + "subdir": "linux-64", + "timestamp": 1620662252092, + "version": "1.8.1" + }, + "pydantic-1.8.1-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f45dc5a96a9b34ae16ae51004762350c", + "name": "pydantic", + "sha256": "5d17313ab8c4164278f74cb76916c7a332f23c434fdc31ab7ca16dfade888bbe", + "size": 2154778, + "subdir": "linux-64", + "timestamp": 1620658035448, + "version": "1.8.1" + }, + "pydantic-1.8.1-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ae91ae5f64d34db4e05fd01a15e19906", + "name": "pydantic", + "sha256": "6a6f479f0722f111acaa3ccdbe1efa7b9a8b82a9fd738190c2654c6ebca079a3", + "size": 2287258, + "subdir": "linux-64", + "timestamp": 1620662258973, + "version": "1.8.1" + }, + "pydantic-1.8.1-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f688c87e8f34ae041a0b948bb4115675", + "name": "pydantic", + "sha256": "039159d3c44bd069609e135645ce7b1e7755cf223e16979f3146e9c74a0cdbbf", + "size": 2276554, + "subdir": "linux-64", + "timestamp": 1620662264805, + "version": "1.8.1" + }, + "pydantic-1.8.2-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "61e823ca73506c585bce7160a263bce4", + "name": "pydantic", + "sha256": "133b85134bd4573f73a1e13c4dba874b9a55978e06312f0274d33f486e73e8b9", + "size": 8567264, + "subdir": "linux-64", + "timestamp": 1640793125671, + "version": "1.8.2" + }, + "pydantic-1.8.2-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b66d1b841c9f34308c2a72cff1566522", + "name": "pydantic", + "sha256": "ef2299698e34c682b5b240ae2db86e64611af13fd783da52895d3d1c46b8130c", + "size": 2161043, + "subdir": "linux-64", + "timestamp": 1621547129405, + "version": "1.8.2" + }, + "pydantic-1.8.2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8fcc765bb006f7e6e23a6dbe25fb6f77", + "name": "pydantic", + "sha256": "333ce4e8fb1b808f35610e986304e1df7c78770abaf499f340b2c4ef77b5e205", + "size": 2165378, + "subdir": "linux-64", + "timestamp": 1621547110283, + "version": "1.8.2" + }, + "pydantic-1.8.2-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1cb0eb17d560289df02f01802d662533", + "name": "pydantic", + "sha256": "eba14ed4631473f98190efb1a1698818521d5ab0b84b0aa4d971ae156670c94b", + "size": 2161808, + "subdir": "linux-64", + "timestamp": 1636618185236, + "version": "1.8.2" + }, + "pydantic-1.8.2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0ad5e0754832eec50b15734d50fd7352", + "name": "pydantic", + "sha256": "01aa190f7665ca21cc6965f66862c794cdd5ce0566499ca40679730f7dc82260", + "size": 2277491, + "subdir": "linux-64", + "timestamp": 1621546992647, + "version": "1.8.2" + }, + "pydantic-1.8.2-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "72badb75c1006239a7f8938fa76a0ac8", + "name": "pydantic", + "sha256": "fb5b3c571050ecb128bdb9e58532ecf7be2cb8a896aeb0367f7c117c6f4688c5", + "size": 2285450, + "subdir": "linux-64", + "timestamp": 1636618051173, + "version": "1.8.2" + }, + "pydantic-1.8.2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80911c60394778cf1fd8fb42af22780e", + "name": "pydantic", + "sha256": "874310a6ac4cf1e867eeda12d281c0ea3e7aab00e65c77fbb49be72a961608af", + "size": 2277895, + "subdir": "linux-64", + "timestamp": 1621542418020, + "version": "1.8.2" + }, + "pydantic-1.8.2-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a71c20880bcf7059531efb6b1ca2258", + "name": "pydantic", + "sha256": "4adc01872a6dd9a93ded2df93d3e0cf31bb4bd1a0f0bd489fa959fd663ba09c4", + "size": 2285307, + "subdir": "linux-64", + "timestamp": 1636618317790, + "version": "1.8.2" + }, + "pydantic-1.9.0-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d7272cf6e50ac0a518a1ddbc3b66513", + "name": "pydantic", + "sha256": "4426637e8af08a4b1f56d8d81c68345007833c88d564216bbee064f8f6102c71", + "size": 9326881, + "subdir": "linux-64", + "timestamp": 1651219097258, + "version": "1.9.0" + }, + "pydantic-1.9.0-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c4175dd9a6dbca9a4c5019d7cefbf37", + "name": "pydantic", + "sha256": "4476de46155686ac8448b9482e614b6e608b4e4e14170b991345b5fe1f2302e3", + "size": 2342822, + "subdir": "linux-64", + "timestamp": 1643622963313, + "version": "1.9.0" + }, + "pydantic-1.9.0-py37h7f8727e_1.tar.bz2": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af481d3d25bf609c9a3a8a9c078f3441", + "name": "pydantic", + "sha256": "eec9fedb39e4c54bc3b0a8be5dcdbb98acea216b5ea79bfa77f245ba079034b2", + "size": 2318975, + "subdir": "linux-64", + "timestamp": 1651219404512, + "version": "1.9.0" + }, + "pydantic-1.9.0-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "093f25b7f6f9b509217ed4258cb2fb2b", + "name": "pydantic", + "sha256": "29a9e0adffb74858a08a557248540ee95a078acbe1f579ca840206c5e2276d30", + "size": 2489136, + "subdir": "linux-64", + "timestamp": 1643622671619, + "version": "1.9.0" + }, + "pydantic-1.9.0-py38h7f8727e_1.tar.bz2": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c00a592b703b8e1794f6efc12d6c3c2", + "name": "pydantic", + "sha256": "7ee9653d099d65a36d9680cc0969fa99b6bf0271cab57cec608177d569812fc2", + "size": 2455327, + "subdir": "linux-64", + "timestamp": 1651219250121, + "version": "1.9.0" + }, + "pydantic-1.9.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "641988e062444aeda6484c98e0f33ddb", + "name": "pydantic", + "sha256": "f58015a3f574fb323ac0c3948812e3eec77effd9e3542ac5ee41c0b3e4d7a6b8", + "size": 2487581, + "subdir": "linux-64", + "timestamp": 1643622816941, + "version": "1.9.0" + }, + "pydantic-1.9.0-py39h7f8727e_1.tar.bz2": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43e6bdb9064567c8134a9bce7faf9c4b", + "name": "pydantic", + "sha256": "12014560bcac5055105d9cd440c18adc7203f05ca5ebda2d1dc2d9251af45f7e", + "size": 2453455, + "subdir": "linux-64", + "timestamp": 1651218896618, + "version": "1.9.0" + }, + "pydeck-0.7.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=5.1.2", + "ipywidgets >=7.0.0", + "jinja2 >=2.10.1", + "numpy", + "python >=3.10,<3.11.0a0", + "traitlets >=4.3.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "220b626e50652d279daee6df998524ee", + "name": "pydeck", + "sha256": "374899e8ccc10cf8c74a51d5d115a8c8bf4b5ec27fddebb85e5a78c8747bf394", + "size": 3704961, + "subdir": "linux-64", + "timestamp": 1657894752269, + "version": "0.7.1" + }, + "pydeck-0.7.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=5.1.2", + "ipywidgets >=7.0.0", + "jinja2 >=2.10.1", + "numpy", + "python >=3.11,<3.12.0a0", + "traitlets >=4.3.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3494161582cfa8d01ba427515aa13a31", + "name": "pydeck", + "sha256": "9db0af0dfc0c45686f769110e7be5c8efc7dc1e3d74ce9ab6cc0805f76c845c5", + "size": 3713041, + "subdir": "linux-64", + "timestamp": 1676845304848, + "version": "0.7.1" + }, + "pydeck-0.7.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=5.1.2", + "ipywidgets >=7.0.0", + "jinja2 >=2.10.1", + "numpy", + "python >=3.7,<3.8.0a0", + "traitlets >=4.3.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aaa9831d05ae9826c116997709772a77", + "name": "pydeck", + "sha256": "01e23a33d8ed1e04626c6bbf303cc4c9ae7bfec25648917cd725ba4ab414c9c9", + "size": 3702759, + "subdir": "linux-64", + "timestamp": 1657894695494, + "version": "0.7.1" + }, + "pydeck-0.7.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=5.1.2", + "ipywidgets >=7.0.0", + "jinja2 >=2.10.1", + "numpy", + "python >=3.8,<3.9.0a0", + "traitlets >=4.3.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aec9088ac1455086b490be03fadec4c0", + "name": "pydeck", + "sha256": "11bf16fc4b9d62eea81fed6ad5a8d63d8a72c1475e61ed502c071c7e817fac9e", + "size": 3704728, + "subdir": "linux-64", + "timestamp": 1657894648482, + "version": "0.7.1" + }, + "pydeck-0.7.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=5.1.2", + "ipywidgets >=7.0.0", + "jinja2 >=2.10.1", + "numpy", + "python >=3.9,<3.10.0a0", + "traitlets >=4.3.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ffa581ee92954d58d888802a0c4b6a4d", + "name": "pydeck", + "sha256": "0def297571d741abd62b40327b5051bd6d8fcb9b84ba1eefe3fb574d5eff36c0", + "size": 3703283, + "subdir": "linux-64", + "timestamp": 1657894602244, + "version": "0.7.1" + }, + "pydispatcher-2.0.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "763a3267dc3d35e3984c8f795417ed7c", + "name": "pydispatcher", + "sha256": "d45447e9e1a6144d5dca009fc01a40f807a1933637c5065ef9ce4fee7d8792b9", + "size": 19083, + "subdir": "linux-64", + "timestamp": 1530959784466, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "793ace6125e41cefe0b1be2bd349da48", + "name": "pydispatcher", + "sha256": "1b81fc71b5ac41f7280152db5911233a298a4dcc30af0742ce490eef61414bda", + "size": 19189, + "subdir": "linux-64", + "timestamp": 1537810516037, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6ce886b5ef5023dc8cff2bdfe06abdf5", + "name": "pydispatcher", + "sha256": "bbdeb9ebc7ab779672e9e896593db97c4b95116c6906e2495fac4d79adddd0cf", + "size": 19785, + "subdir": "linux-64", + "timestamp": 1640793148678, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "31854ec10790256327b3daa331a86fe0", + "name": "pydispatcher", + "sha256": "f8dd41bf50e705f154a1f0d6defcede7fcd08e377f0685b50f0e692ac3bb4f0b", + "size": 20524, + "subdir": "linux-64", + "timestamp": 1646654909576, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py311h06a4308_2.tar.bz2": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3c5b5e61947b464426782d2a061ce440", + "name": "pydispatcher", + "sha256": "2b4eb0cdffe8c77c13f8955fa258c22940e793597bd39496fd9388179fd74c10", + "size": 24505, + "subdir": "linux-64", + "timestamp": 1676845322535, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "daabac0d566a64294b7db502e046fc95", + "name": "pydispatcher", + "sha256": "1f11b6e4dc46a9b85d905033e0662540bebaaa7813c040f557ad249eed5cd211", + "size": 19545, + "subdir": "linux-64", + "timestamp": 1537810814144, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "28c15b5ace5c38018c1fec5ccfbcb7af", + "name": "pydispatcher", + "sha256": "b7e210f21b1fd7f73a55ba3c722568f9dac1ff40d6f0670545b0b1470e6c5840", + "size": 19366, + "subdir": "linux-64", + "timestamp": 1530959814780, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3dc3bed50f552ee87d3de9f570257207", + "name": "pydispatcher", + "sha256": "3fab6ea622416c318dacdb3735f7a5bc4450590b79e86776444a856f7376b66d", + "size": 19480, + "subdir": "linux-64", + "timestamp": 1537810506376, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4efdf333a5f60672c3768d7d97095528", + "name": "pydispatcher", + "sha256": "2ab2309c15e0998366a4a4be9f672eb1299735479a8e0d83eb66e6ae5fdd6775", + "size": 20493, + "subdir": "linux-64", + "timestamp": 1613165924319, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ce0b8abe02080b8c7cf5f6ffbd1d6c72", + "name": "pydispatcher", + "sha256": "6767bc200dacf9376a98448f68e03e4e423dbfd37cc452a04f7aa2228a515421", + "size": 19378, + "subdir": "linux-64", + "timestamp": 1530959845272, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1282c40a2b8180f34db20488b2848e6e", + "name": "pydispatcher", + "sha256": "d46ca9baac96a719d20e27877e41857afa42fdeac3d7f9c001cfaa680c6cad92", + "size": 19498, + "subdir": "linux-64", + "timestamp": 1537810490559, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c5a4d8c419bfa56bcec9d1d42b0d60a2", + "name": "pydispatcher", + "sha256": "efce6509d6fd4a6513937e91cb6a71cf6dcf7352bf0da37dca54d6b3b7edcd99", + "size": 20551, + "subdir": "linux-64", + "timestamp": 1613164147110, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "41bd97161f556343401ae3419edc14c8", + "name": "pydispatcher", + "sha256": "efccf2a73efc29b0c138dba001464061177c802d437b614328217296f33c58eb", + "size": 20475, + "subdir": "linux-64", + "timestamp": 1646654894329, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "90190bc4441629cb2acb66aed66e2474", + "name": "pydispatcher", + "sha256": "195dab1c4ec6c311bb85e5fdd06ce4cb928892360553ab26e2a2ab9aa055db45", + "size": 19835, + "subdir": "linux-64", + "timestamp": 1573669058188, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d51e17508d5b00b08518480afc6f5017", + "name": "pydispatcher", + "sha256": "585208a5619d0237ece1cf2df779186ad25816b6a5da66758ddaff11ef6389af", + "size": 20519, + "subdir": "linux-64", + "timestamp": 1613165800610, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f9c997e376d452c9da966c38e7cf4eb8", + "name": "pydispatcher", + "sha256": "4f762792a6c49e9e85411bb99220364420f566ff64ebf8b1c3eabfd70549a2de", + "size": 20437, + "subdir": "linux-64", + "timestamp": 1646654892433, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f0f91695e6305e8b1579f25fe594bfcb", + "name": "pydispatcher", + "sha256": "44763cb83d7324a3dd1bcab90fa7ea86be06ed67f9fc43173ed81f0ebfbf3601", + "size": 20535, + "subdir": "linux-64", + "timestamp": 1613164150745, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "61da9167dd1835f4fcb7496511d852e7", + "name": "pydispatcher", + "sha256": "64161810aaea1df8c49e1f25b587e55e2dbc40af89bba6791b9a87850c49b16b", + "size": 20426, + "subdir": "linux-64", + "timestamp": 1646636769245, + "version": "2.0.5" + }, + "pydocstyle-2.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser", + "python >=2.7,<2.8.0a0", + "six", + "snowballstemmer" + ], + "license": "MIT", + "md5": "7e0a3cd47d17ff53e28dc955120df860", + "name": "pydocstyle", + "sha256": "79a854aa93b9ec8c35599e615af3c0e19c174d3c6e00ba2845fd595c661a010b", + "size": 51041, + "subdir": "linux-64", + "timestamp": 1536861200466, + "version": "2.1.1" + }, + "pydocstyle-2.1.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six", + "snowballstemmer" + ], + "license": "MIT", + "md5": "9efb8175162a7a4ad3e6084868bed449", + "name": "pydocstyle", + "sha256": "d47a43a9702623de171011c6e2180f17be3dae9ba3518a3969a27990b4168fcc", + "size": 52092, + "subdir": "linux-64", + "timestamp": 1536861363898, + "version": "2.1.1" + }, + "pydocstyle-2.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six", + "snowballstemmer" + ], + "license": "MIT", + "md5": "b9ce827b4262f9c5885adc86ef11d5fa", + "name": "pydocstyle", + "sha256": "0348ddcd415bba3fde18fe7ed0120937166f9ea77f3c72426ae0c6ff4e5cef78", + "size": 51908, + "subdir": "linux-64", + "timestamp": 1536861369802, + "version": "2.1.1" + }, + "pydocstyle-2.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six", + "snowballstemmer" + ], + "license": "MIT", + "md5": "ebb0a66d61acae92b498cda0f84e93c6", + "name": "pydocstyle", + "sha256": "4e8df88cecb35200a3d2235bfe840ad981d5620020837c06a30c5cf2af3a0df7", + "size": 51809, + "subdir": "linux-64", + "timestamp": 1536861138849, + "version": "2.1.1" + }, + "pydocstyle-3.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser", + "python >=2.7,<2.8.0a0", + "six", + "snowballstemmer" + ], + "license": "MIT", + "md5": "4a9901baa9370fec3e91fa6f3757a37f", + "name": "pydocstyle", + "sha256": "3c5c0c466c36d5689aeabb9e398d49f87cf2764e8fc67a42c90734afd5dd0dcc", + "size": 52660, + "subdir": "linux-64", + "timestamp": 1539658355026, + "version": "3.0.0" + }, + "pydocstyle-3.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six", + "snowballstemmer" + ], + "license": "MIT", + "md5": "5d62a5a41448f80c06c379bd326b88a4", + "name": "pydocstyle", + "sha256": "13cc5d6da54d8634cbdfbaae753ceaabee92f4909e0bd4ec02e3dafb18ec73de", + "size": 53514, + "subdir": "linux-64", + "timestamp": 1539658370582, + "version": "3.0.0" + }, + "pydocstyle-3.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six", + "snowballstemmer" + ], + "license": "MIT", + "md5": "0c7c1d753d806262412c041b3b93b8d7", + "name": "pydocstyle", + "sha256": "1852283403f1796d48d774da169cdd377570fd54c124d0c8218274e59192c5ab", + "size": 53435, + "subdir": "linux-64", + "timestamp": 1539658375336, + "version": "3.0.0" + }, + "pydocstyle-6.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "snowballstemmer >=2.2.0", + "tomli >=1.2.3" + ], + "license": "MIT", + "md5": "831bf5f53e268ec0dc61d1bd686d5f6c", + "name": "pydocstyle", + "sha256": "785e50a2c14e9e7760984a86ee465bde94cb796a217a9bc2e27393f09153fca3", + "size": 67290, + "subdir": "linux-64", + "timestamp": 1675221698919, + "version": "6.3.0" + }, + "pydocstyle-6.3.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "snowballstemmer >=2.2.0" + ], + "license": "MIT", + "md5": "6431210f38c3f8deddccd055ee597949", + "name": "pydocstyle", + "sha256": "fe8c80ef62ef598bba0632dc549db9a9016fe45ce0a1c24426652835276dee79", + "size": 87003, + "subdir": "linux-64", + "timestamp": 1677708733025, + "version": "6.3.0" + }, + "pydocstyle-6.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata >=2.0.0,<5.0.0", + "python >=3.7,<3.8.0a0", + "snowballstemmer >=2.2.0", + "tomli >=1.2.3" + ], + "license": "MIT", + "md5": "3f3ced72c2c8627537142044a3c27eb5", + "name": "pydocstyle", + "sha256": "ac7c23c95c1a55aac92a93b17b6ae65cf0efedc6e6ba1ed3a411728a36e36e14", + "size": 66206, + "subdir": "linux-64", + "timestamp": 1675221752043, + "version": "6.3.0" + }, + "pydocstyle-6.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "snowballstemmer >=2.2.0", + "tomli >=1.2.3" + ], + "license": "MIT", + "md5": "59700f47a0fb3f6513a144a4c18aac76", + "name": "pydocstyle", + "sha256": "ec42cfe5c5cdf73f53f4f9ec8c375328db993ca98b25811c0dd7f8b2d9d9f6e9", + "size": 66531, + "subdir": "linux-64", + "timestamp": 1675221725015, + "version": "6.3.0" + }, + "pydocstyle-6.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "snowballstemmer >=2.2.0", + "tomli >=1.2.3" + ], + "license": "MIT", + "md5": "6287d7c0db895365192b8220afc07e2a", + "name": "pydocstyle", + "sha256": "5bbe7e176a3ec3af88a9a6404c82e1c765be5f2aac31fd255c1eae50fb1294ad", + "size": 66572, + "subdir": "linux-64", + "timestamp": 1675221778227, + "version": "6.3.0" + }, + "pydot-1.2.3-py27h55c791f_0.tar.bz2": { + "build": "py27h55c791f_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "2a3e774145cc9c4593ed47a070d6d7ec", + "name": "pydot", + "sha256": "a6526e3b2744db5dc567148e7e1337f9973cc9a9bdf2014776991ac2d926fcff", + "size": 36891, + "subdir": "linux-64", + "timestamp": 1512149128346, + "version": "1.2.3" + }, + "pydot-1.2.3-py35hf778598_0.tar.bz2": { + "build": "py35hf778598_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "72243b88548765d9008147a06f7fd590", + "name": "pydot", + "sha256": "0dabb15997c88a2a9ba97e2e0822df9eea420caaa98488ea4e44b4be8a9d02ea", + "size": 37662, + "subdir": "linux-64", + "timestamp": 1512149133814, + "version": "1.2.3" + }, + "pydot-1.2.3-py36h2c9da84_0.tar.bz2": { + "build": "py36h2c9da84_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ef228b5bcbb5fdb73c9e211037dfc202", + "name": "pydot", + "sha256": "261af3c29f20132a80412a29454e5e84b68ae4430506ae60407a5886bd8e126a", + "size": 37518, + "subdir": "linux-64", + "timestamp": 1512149078464, + "version": "1.2.3" + }, + "pydot-1.2.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "bb7526a7060a5951a8ce2893f5d37bcf", + "name": "pydot", + "sha256": "8e80719fb05abba80e2182c2706ecbe0646a21f8786f99a85e2c8fd329a667a1", + "size": 37602, + "subdir": "linux-64", + "timestamp": 1519832679748, + "version": "1.2.4" + }, + "pydot-1.2.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "baaf71915db581ba893a4c2ede93b8ec", + "name": "pydot", + "sha256": "c5e526917a2b6fa1b82e5b678687dacdc568ee0ca2e6f4e408ee1298dfac2ab0", + "size": 38423, + "subdir": "linux-64", + "timestamp": 1519832693397, + "version": "1.2.4" + }, + "pydot-1.2.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c6f8d98406fa505241ab3ea1711ba580", + "name": "pydot", + "sha256": "c54c3aac6f7054fdfe0aa9d0798627d5457246090314c3b57895f196b3d6189c", + "size": 38334, + "subdir": "linux-64", + "timestamp": 1519832666979, + "version": "1.2.4" + }, + "pydot-1.2.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a0e8f86f2fa9abf5c3e6219c7b53aff4", + "name": "pydot", + "sha256": "dd88d0b3d5c93d1bc39a699cfec7113a964cf6667dd228f45baaf46b389d3e48", + "size": 38294, + "subdir": "linux-64", + "timestamp": 1530916025811, + "version": "1.2.4" + }, + "pydot-1.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c03a08034333efa82164c0055dcd69ee", + "name": "pydot", + "sha256": "821f79c6ebc4be47508cea088cfbf09e6aa5bbbbfb11eee7df49c89e593a0421", + "size": 37785, + "subdir": "linux-64", + "timestamp": 1542641557279, + "version": "1.3.0" + }, + "pydot-1.3.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "0dc8bdb8ac6e147ff85ecbed9ad2cf3a", + "name": "pydot", + "sha256": "d41b900e0257cefcb2090304c630801799962a374854513e97290c453b7b78ff", + "size": 40001, + "subdir": "linux-64", + "timestamp": 1543604291650, + "version": "1.3.0" + }, + "pydot-1.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "52c141e74aaafb5c41b6431c67822819", + "name": "pydot", + "sha256": "8e2f795d07fa9c4ef04ad45689436255a85b1a66ad03d3aec81a1cdb72857c8e", + "size": 38506, + "subdir": "linux-64", + "timestamp": 1542641565443, + "version": "1.3.0" + }, + "pydot-1.3.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c3450f4808d891fb152b16801c7b983a", + "name": "pydot", + "sha256": "d393fa2ee4c0bf387b9837ded10d3c1c862cd29d92c951b0494154db74652153", + "size": 40714, + "subdir": "linux-64", + "timestamp": 1543604333423, + "version": "1.3.0" + }, + "pydot-1.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "853410f9b90098a28d8e8da424f4c33a", + "name": "pydot", + "sha256": "66b89e8ede599c610a21fb38a2126364b214dab8e9b2c9f84afa426fd1e44246", + "size": 38501, + "subdir": "linux-64", + "timestamp": 1542641542956, + "version": "1.3.0" + }, + "pydot-1.3.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7f2fb11fd2202c9f9f70c12d46e3ae4e", + "name": "pydot", + "sha256": "3d231e2646d756e756d09359c5b19b5e6f2b3463e8abb26b27c5a45a8c927d98", + "size": 40692, + "subdir": "linux-64", + "timestamp": 1543604276682, + "version": "1.3.0" + }, + "pydot-1.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "4dada20899f63609a4ef86ff9a4f73be", + "name": "pydot", + "sha256": "8cc37ebd4086836e7abdb5777550845657dbc3f5c8fe3d2ebbb9195c8a54d7d0", + "size": 43108, + "subdir": "linux-64", + "timestamp": 1556070495453, + "version": "1.4.1" + }, + "pydot-1.4.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "23f48ab956a8f2c0d406be7854f6bca6", + "name": "pydot", + "sha256": "a33b13318f63851db2398a0757126e273d2442ec09757b3e49b6fd8082afff06", + "size": 41519, + "subdir": "linux-64", + "timestamp": 1640793166772, + "version": "1.4.1" + }, + "pydot-1.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "68f7e398306c49044a95588e83281b29", + "name": "pydot", + "sha256": "58f8839a65d69927353e41005874deebcd71ed1a6b1c9e6d268eef612e0ebd07", + "size": 43878, + "subdir": "linux-64", + "timestamp": 1556070381872, + "version": "1.4.1" + }, + "pydot-1.4.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "466f2f2c82009c2fb8abcc20389c3010", + "name": "pydot", + "sha256": "1ed7e897f270b98b71b5e4c019f6f500e60369d8fa88c1a0156e8791c63d4eb8", + "size": 44010, + "subdir": "linux-64", + "timestamp": 1615393420568, + "version": "1.4.1" + }, + "pydot-1.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ebbe2cab246c2461604b9279db08a7fd", + "name": "pydot", + "sha256": "ac2cb7dbb8fd215a0cc46f056d4ab210dfeff6880c659a7955766a26f7b5afed", + "size": 43849, + "subdir": "linux-64", + "timestamp": 1556070479672, + "version": "1.4.1" + }, + "pydot-1.4.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b67cc4806fd3ebb56b81709ecb97189f", + "name": "pydot", + "sha256": "322bc30b12957ca3a38cb06db7e0f5b98c2250a63e63c1e620b67d96cb4a9c95", + "size": 43951, + "subdir": "linux-64", + "timestamp": 1615394995867, + "version": "1.4.1" + }, + "pydot-1.4.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "511ea7a442249bf4bb545ffec575cfa3", + "name": "pydot", + "sha256": "12e814d1fdc55eb9aa8a5e98e3d636c5aee9c8382fb5dbf4d957b9be173b4634", + "size": 41571, + "subdir": "linux-64", + "timestamp": 1573469717589, + "version": "1.4.1" + }, + "pydot-1.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "fb2438047e5305ad8919554de96b25e5", + "name": "pydot", + "sha256": "ebae174449c93010bff68969335215ac3300018c5d403a16b4c1e6242067c9c1", + "size": 44167, + "subdir": "linux-64", + "timestamp": 1615395011326, + "version": "1.4.1" + }, + "pydot-1.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "48659a1bc3180ce9f94a8ffa4d92000d", + "name": "pydot", + "sha256": "e59498d32facbaad61ce77c29df28872f66e42f418b0fe2a07b537b19714aed0", + "size": 43905, + "subdir": "linux-64", + "timestamp": 1615393420123, + "version": "1.4.1" + }, + "pydot-1.4.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3", + "pyparsing >=2.1.4,<3", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02a732d45c2c10ea163b6f2beb10e93b", + "name": "pydot", + "sha256": "e3e0bc0efa18f4a5515ef9ead7a6d8dae733279f4003a823000dda35c8c47da6", + "size": 43679, + "subdir": "linux-64", + "timestamp": 1671046303576, + "version": "1.4.2" + }, + "pydot-1.4.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3", + "pyparsing >=2.1.4,<3", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b8b040247391fce8a35c4f49f98a498", + "name": "pydot", + "sha256": "33921bb984fa462e4e50f5e75673bc68f791619da199ae4d774a4677f0b3425c", + "size": 56637, + "subdir": "linux-64", + "timestamp": 1676860722094, + "version": "1.4.2" + }, + "pydot-1.4.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3", + "pyparsing >=2.1.4,<3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "67eb06b86ca4040619f5a8093f202b89", + "name": "pydot", + "sha256": "2dc494787119e3f44e296888a8b72fd4d6af9b142b7301e4a60a5d1e9e1ac134", + "size": 43505, + "subdir": "linux-64", + "timestamp": 1671046366524, + "version": "1.4.2" + }, + "pydot-1.4.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3", + "pyparsing >=2.1.4,<3", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab40a8e6e772f1c895a4b2f8307d1329", + "name": "pydot", + "sha256": "a17ad814dc6c79ff16579dd8260eb749ea0e09657908a6210f87278237e42723", + "size": 43766, + "subdir": "linux-64", + "timestamp": 1671046396655, + "version": "1.4.2" + }, + "pydot-1.4.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3", + "pyparsing >=2.1.4,<3", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b20ef8ab217fb8906d8622ff52f2045a", + "name": "pydot", + "sha256": "2e81643c51f8112a9e7e9169a0139c208e7e383fef55939fc035945793f392c5", + "size": 43491, + "subdir": "linux-64", + "timestamp": 1671046335981, + "version": "1.4.2" + }, + "pydotplus-2.0.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pyparsing >=2.0.1", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "186fc064b64b1b4bcfa4f72706c4e338", + "name": "pydotplus", + "sha256": "8c8bafe612cd88283f1966f072adb96c783899b8b0cb01bcc25b71364720f9a0", + "size": 42010, + "subdir": "linux-64", + "timestamp": 1539183187884, + "version": "2.0.2" + }, + "pydotplus-2.0.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pyparsing >=2.0.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1b858f5a25a5037f8c7c7b89d47a3c3", + "name": "pydotplus", + "sha256": "d48e979951ee578e4e7785035b818590debd9640f676c378c0352fe62cc684ba", + "size": 42677, + "subdir": "linux-64", + "timestamp": 1539183193318, + "version": "2.0.2" + }, + "pydotplus-2.0.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pyparsing >=2.0.1", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9cb42ba476afb250dae8bf9ee4eba76", + "name": "pydotplus", + "sha256": "2e0675bbad0d6486b5be75263b3206f262f062feb172dc920dca4c6a3709d9ca", + "size": 42603, + "subdir": "linux-64", + "timestamp": 1539183206663, + "version": "2.0.2" + }, + "pyee-8.2.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "208e9b81c7571d745db9a781b3dda64d", + "name": "pyee", + "sha256": "4882161c1aaca16f633402c79f52c7bc5f1827da5c3fe02dee98a2de125fadfa", + "size": 21435, + "subdir": "linux-64", + "timestamp": 1679385311004, + "version": "8.2.2" + }, + "pyee-8.2.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa1292d0e8972bee0ce1ce6aa1801325", + "name": "pyee", + "sha256": "73f2b9ecba3f85085c14d4bea5ee02be66e10713af88e4c7dc16c2472564f0b4", + "size": 25100, + "subdir": "linux-64", + "timestamp": 1679385385567, + "version": "8.2.2" + }, + "pyee-8.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "568f88ead72655042aa9119decdf48d9", + "name": "pyee", + "sha256": "4cf2e4a3407288ffeea02ad79937adc4683490906aecb1f9a3d53377a33e31b6", + "size": 21216, + "subdir": "linux-64", + "timestamp": 1679385336025, + "version": "8.2.2" + }, + "pyee-8.2.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b60fbf0730af8f25558bca1e8abd8372", + "name": "pyee", + "sha256": "0b45a131b4d52c6a7923e65533dd4d5b01f1fc7b26d0535eb77bd40976c80dc5", + "size": 21324, + "subdir": "linux-64", + "timestamp": 1679385360078, + "version": "8.2.2" + }, + "pyee-9.0.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2aedfb33df461efe2a2bd62b90121d08", + "name": "pyee", + "sha256": "9a1d6b907c951d96275208f2479f7b38f62490c42bd8ad0dded9fb8735b0fc47", + "size": 25822, + "subdir": "linux-64", + "timestamp": 1679327051640, + "version": "9.0.4" + }, + "pyee-9.0.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d52411924e1cd30d5e6d062d13cd5c7d", + "name": "pyee", + "sha256": "3cfb5c64f76d2bfba7b11a54df9a901f6895f2b759aa6576a7b9452662fc6f5a", + "size": 31344, + "subdir": "linux-64", + "timestamp": 1679327130229, + "version": "9.0.4" + }, + "pyee-9.0.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "449445c02c7699b07c4bf28a9099de63", + "name": "pyee", + "sha256": "8f2ae265d637c56a604660d98b1668a40ba9df206193bc6a6ca200f323badddc", + "size": 25484, + "subdir": "linux-64", + "timestamp": 1679327103085, + "version": "9.0.4" + }, + "pyee-9.0.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8043d3d18817ff8a11d231248f6f051f", + "name": "pyee", + "sha256": "714efbff28868574a6af61b4d951166f9cc9f899c4743fc46e7a07664dcd1ac9", + "size": 25553, + "subdir": "linux-64", + "timestamp": 1679327076640, + "version": "9.0.4" + }, + "pyemd-0.4.4-py27h8619c78_0.tar.bz2": { + "build": "py27h8619c78_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "a565f4372c9315ab074802fd4806a809", + "name": "pyemd", + "sha256": "fb161a3a49d8593a4d932f5b934da1441ac4b461359aabb7b6e211793204c248", + "size": 62371, + "subdir": "linux-64", + "timestamp": 1519494938565, + "version": "0.4.4" + }, + "pyemd-0.4.4-py27hb35e8e7_0.tar.bz2": { + "build": "py27hb35e8e7_0", + "build_number": 0, + "depends": [ + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "8c18967a8a6a0e3feb858af068fb1993", + "name": "pyemd", + "sha256": "59616ea0143204c24f9bc01f8ca458cf8c86f919a736f9f7037b0d43d9fc478e", + "size": 62760, + "subdir": "linux-64", + "timestamp": 1508795089466, + "version": "0.4.4" + }, + "pyemd-0.4.4-py35h8619c78_0.tar.bz2": { + "build": "py35h8619c78_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "97c2d793d9fc32f04147ce778d75fd2a", + "name": "pyemd", + "sha256": "e0f872f1ba16b32bf3af0d0e3fe8186e02ac3616ea4fb8591fd35996247cb4f5", + "size": 55798, + "subdir": "linux-64", + "timestamp": 1519495229755, + "version": "0.4.4" + }, + "pyemd-0.4.4-py35h94a5058_0.tar.bz2": { + "build": "py35h94a5058_0", + "build_number": 0, + "depends": [ + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "14f801dbc26528cb92cb7bf10fcfc867", + "name": "pyemd", + "sha256": "7480f5fe2ecaa4ef30a9f153ff83180fae8c3bce378ca34b0a2fd5977e3c226c", + "size": 56153, + "subdir": "linux-64", + "timestamp": 1508795014676, + "version": "0.4.4" + }, + "pyemd-0.4.4-py36h6632698_0.tar.bz2": { + "build": "py36h6632698_0", + "build_number": 0, + "depends": [ + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "36f69b8455113efaf0cf6f293f4a47a0", + "name": "pyemd", + "sha256": "c80e3a7490bff7aa353d8b6b74db944ea91a27fdba8fb600f2e901c85cc81223", + "size": 56465, + "subdir": "linux-64", + "timestamp": 1508795139309, + "version": "0.4.4" + }, + "pyemd-0.4.4-py36h8619c78_0.tar.bz2": { + "build": "py36h8619c78_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e86fad28c96743456ba8a87ee7ce6d3c", + "name": "pyemd", + "sha256": "066e99ea82d2b4d22a6e1199acdae999e9480e774baa2e98f2977586ff2cef70", + "size": 56126, + "subdir": "linux-64", + "timestamp": 1519495482135, + "version": "0.4.4" + }, + "pyemd-0.5.1-py27h8619c78_0.tar.bz2": { + "build": "py27h8619c78_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "89ac0a8fae261f38e7bb01b8585ac31b", + "name": "pyemd", + "sha256": "906394c1e25ff9fc68394dea3281ca5f298725230846a64ca86a72cf3ebee4f9", + "size": 80632, + "subdir": "linux-64", + "timestamp": 1522807723274, + "version": "0.5.1" + }, + "pyemd-0.5.1-py27ha8d69ae_0.tar.bz2": { + "build": "py27ha8d69ae_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "be14fc13d70a460a3ec6547dcc6aec9d", + "name": "pyemd", + "sha256": "1d3e2eef2ab3b7019c19f6d424a420d25ad7fedc842c57214ee6e58091aff576", + "size": 80559, + "subdir": "linux-64", + "timestamp": 1530879574399, + "version": "0.5.1" + }, + "pyemd-0.5.1-py310h2571103_0.tar.bz2": { + "build": "py310h2571103_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "a86d12f45b80316cac381eecc5c6b49a", + "name": "pyemd", + "sha256": "e2cfdc1d7d6ed53dddabe6369d965e8d53f8b4dc894fe986a427af7ee3ec0ac4", + "size": 399512, + "subdir": "linux-64", + "timestamp": 1640793197104, + "version": "0.5.1" + }, + "pyemd-0.5.1-py310hdb19cb5_1.tar.bz2": { + "build": "py310hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "430c2fc3fb9961c157ff18629a0bc1a9", + "name": "pyemd", + "sha256": "63ab6ad686a15bdde94f5da58e2f3bd7ee10a266ffb573de263979849485eb48", + "size": 80409, + "subdir": "linux-64", + "timestamp": 1676993835693, + "version": "0.5.1" + }, + "pyemd-0.5.1-py311hdb19cb5_1.tar.bz2": { + "build": "py311hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c75e383f53d374cf847271a7c4645be", + "name": "pyemd", + "sha256": "20dd37e04fb221f8f667c1f9c4e0fd2d37428826defa419b8cc33e9168ce5579", + "size": 74505, + "subdir": "linux-64", + "timestamp": 1677014527464, + "version": "0.5.1" + }, + "pyemd-0.5.1-py35h8619c78_0.tar.bz2": { + "build": "py35h8619c78_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "05cc9a039a1a641783d1fc2fa2af87be", + "name": "pyemd", + "sha256": "639ad066ecf4c2280b1ad1e31d7cdaef9751896abc9806943f82102ace155f11", + "size": 74704, + "subdir": "linux-64", + "timestamp": 1522807727333, + "version": "0.5.1" + }, + "pyemd-0.5.1-py36h3b6f4ec_0.tar.bz2": { + "build": "py36h3b6f4ec_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "db142749979d58254a72581d7f4f7f69", + "name": "pyemd", + "sha256": "a8cafe74c80a49b70639a8d05cd74fd296c36bf7d2bd93b5e336f34bc8930176", + "size": 77417, + "subdir": "linux-64", + "timestamp": 1592382034223, + "version": "0.5.1" + }, + "pyemd-0.5.1-py36h8619c78_0.tar.bz2": { + "build": "py36h8619c78_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c4bfff25f8da405c16672cf75337fc52", + "name": "pyemd", + "sha256": "e7cbf3ade2e1d5ee8d3f23b47196473b643ce15af7b4646e97efb08200094f76", + "size": 76059, + "subdir": "linux-64", + "timestamp": 1522807722975, + "version": "0.5.1" + }, + "pyemd-0.5.1-py36h9a67853_0.tar.bz2": { + "build": "py36h9a67853_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "756bf68a6b31ed160bd6bdfca0d1703e", + "name": "pyemd", + "sha256": "60d783f9dab252f81a04356f142b1d459292a83d330773d36f244bff21bcbe94", + "size": 77294, + "subdir": "linux-64", + "timestamp": 1613411038471, + "version": "0.5.1" + }, + "pyemd-0.5.1-py36ha8d69ae_0.tar.bz2": { + "build": "py36ha8d69ae_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "63075c875f82405c667cc2b32c166fc7", + "name": "pyemd", + "sha256": "7c88045952beaa6a3276d03408b486efd1e0d1b64286c7950a8d6db214a34cf3", + "size": 75976, + "subdir": "linux-64", + "timestamp": 1530879533567, + "version": "0.5.1" + }, + "pyemd-0.5.1-py37h3b6f4ec_0.tar.bz2": { + "build": "py37h3b6f4ec_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "bef6a9579c5dcc8e73ad8d6ca3477680", + "name": "pyemd", + "sha256": "4cb8075f7be77fa30522daa4cc6227f7c6bc48a89349799418eb005b3e07d805", + "size": 77441, + "subdir": "linux-64", + "timestamp": 1592382029711, + "version": "0.5.1" + }, + "pyemd-0.5.1-py37h9a67853_0.tar.bz2": { + "build": "py37h9a67853_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6aa881389a0430f0c3d234b16bfa97a2", + "name": "pyemd", + "sha256": "7edae5c5b118b5d6f0f12253bdc62972dafe241c68ae16f4d802054efe29054b", + "size": 77420, + "subdir": "linux-64", + "timestamp": 1613411261832, + "version": "0.5.1" + }, + "pyemd-0.5.1-py37ha8d69ae_0.tar.bz2": { + "build": "py37ha8d69ae_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4024ba9944b86bcb2e92404f3b29fe10", + "name": "pyemd", + "sha256": "5ca76b90d63917d88b67827bd316b6366126b7368f131f3f846586e161518ca2", + "size": 76089, + "subdir": "linux-64", + "timestamp": 1530879489501, + "version": "0.5.1" + }, + "pyemd-0.5.1-py37hdb19cb5_1.tar.bz2": { + "build": "py37hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6eda2d7f3a976a4c5375fb8eae640b0b", + "name": "pyemd", + "sha256": "ba4b8c46aff71bb02cc0d593137a88fbce9a313364b84c0c70a992396c09a0e8", + "size": 79568, + "subdir": "linux-64", + "timestamp": 1676993921765, + "version": "0.5.1" + }, + "pyemd-0.5.1-py38h3b6f4ec_0.tar.bz2": { + "build": "py38h3b6f4ec_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "96f17874a2b956a031b4faabd98e2805", + "name": "pyemd", + "sha256": "fc58a8b156964b455610053c66a97679a82b83db2e5055b5f18ed0ed07fa388c", + "size": 79317, + "subdir": "linux-64", + "timestamp": 1592382036163, + "version": "0.5.1" + }, + "pyemd-0.5.1-py38h9a67853_0.tar.bz2": { + "build": "py38h9a67853_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "1e735a1eb4b41f359b6e5a8905ed66b9", + "name": "pyemd", + "sha256": "7a5554ef5c17d6d9fa56e14f25dc8551f8d54141b350cdd23fd77ce4b1ee9d75", + "size": 79218, + "subdir": "linux-64", + "timestamp": 1613411627749, + "version": "0.5.1" + }, + "pyemd-0.5.1-py38ha516724_0.tar.bz2": { + "build": "py38ha516724_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "c24fb89fb3b6ae059763d356e47f80a6", + "name": "pyemd", + "sha256": "50009f75ee23a3c31112462a66409f18f19826d3741209c2a13865a02534000f", + "size": 85423, + "subdir": "linux-64", + "timestamp": 1573469787358, + "version": "0.5.1" + }, + "pyemd-0.5.1-py38hdb19cb5_1.tar.bz2": { + "build": "py38hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8ef03e8681183c007eda9c7061a7b46", + "name": "pyemd", + "sha256": "a58e81f6863143dd545a81cd0652b3494b32b1db9925387ad8d0ca9df09f21f8", + "size": 81904, + "subdir": "linux-64", + "timestamp": 1676993878194, + "version": "0.5.1" + }, + "pyemd-0.5.1-py39h9a67853_0.tar.bz2": { + "build": "py39h9a67853_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "f6c9f8c7e694c8288577d6eeefde3267", + "name": "pyemd", + "sha256": "9f1504c9154545bc10850e2857a8994a5f548f15b1569004c1e372ec19b79f09", + "size": 79144, + "subdir": "linux-64", + "timestamp": 1613411634996, + "version": "0.5.1" + }, + "pyemd-0.5.1-py39hdb19cb5_1.tar.bz2": { + "build": "py39hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc553f1d4feb3a3c0c8376a48f1165d3", + "name": "pyemd", + "sha256": "b95cc408808c822f02eaf3b66601ab498597f660de7c348f90f2db5cab88f040", + "size": 80202, + "subdir": "linux-64", + "timestamp": 1676993965009, + "version": "0.5.1" + }, + "pyepsg-0.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "1c6c326c02c33df5dd74f3c5b0d4e0e7", + "name": "pyepsg", + "sha256": "b71c6c1acd2a244a312caaa447c5f87a9014d9329a6b79c8fc0b986963bd296d", + "size": 12199, + "subdir": "linux-64", + "timestamp": 1530811395708, + "version": "0.3.2" + }, + "pyepsg-0.3.2-py27h7a8771c_0.tar.bz2": { + "build": "py27h7a8771c_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "2a5e43bb86fc029f8ee7b5b77f8b664f", + "name": "pyepsg", + "sha256": "f70bd5215d005e869006c3fdc3267e1148570061521283068ab7fe199026c894", + "size": 12595, + "subdir": "linux-64", + "timestamp": 1511990043501, + "version": "0.3.2" + }, + "pyepsg-0.3.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "eb39d3ed928e4cb57672701a29c2eefb", + "name": "pyepsg", + "sha256": "5f6b015411482f7a47a2ffeaf9420ed323f40489eb9791bf00037a9eae5bd04b", + "size": 12576, + "subdir": "linux-64", + "timestamp": 1535129662321, + "version": "0.3.2" + }, + "pyepsg-0.3.2-py35h026859c_0.tar.bz2": { + "build": "py35h026859c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "f825eef6e59f8456b75c588b7ea71328", + "name": "pyepsg", + "sha256": "4abace258e30012f91fb882a3bd238ef319cc999d0f8029e5cfcc23f23df6bda", + "size": 12924, + "subdir": "linux-64", + "timestamp": 1511990132954, + "version": "0.3.2" + }, + "pyepsg-0.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "36042a95fac6d0042d952ff8878c3a34", + "name": "pyepsg", + "sha256": "f0b5786bad396d0056bbf1fba2fd41faddd36cb24126d46c5843a243ca194551", + "size": 12475, + "subdir": "linux-64", + "timestamp": 1530811445075, + "version": "0.3.2" + }, + "pyepsg-0.3.2-py36h1c26317_0.tar.bz2": { + "build": "py36h1c26317_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "753c8bb61585fead365e38dbc9f099b6", + "name": "pyepsg", + "sha256": "f51865bec44917df28bba310e7e2038a31c9c3469fcaa08d857e15978914c289", + "size": 12880, + "subdir": "linux-64", + "timestamp": 1511990191126, + "version": "0.3.2" + }, + "pyepsg-0.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "7cf4c11ec0dd0e1bb599f8b2526e6c4b", + "name": "pyepsg", + "sha256": "fea02402e0c324f823e7956034e1e3cf9fcc33f8aa61584782844ff762bb1831", + "size": 12480, + "subdir": "linux-64", + "timestamp": 1530811420284, + "version": "0.3.2" + }, + "pyepsg-0.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "848f2f00b9a6b2da973500cf12141eae", + "name": "pyepsg", + "sha256": "f1c58252bae0715dbd534f49b471f154165717fd108afb7b76da070377133a1b", + "size": 23975, + "subdir": "linux-64", + "timestamp": 1545146972739, + "version": "0.4.0" + }, + "pyepsg-0.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "d545f2922878ade8a696ce1e21ba9c02", + "name": "pyepsg", + "sha256": "e634abf5b8cef4e791f763bf814ad9d821575c4690b07e6daa6934dc5c4bda1f", + "size": 24308, + "subdir": "linux-64", + "timestamp": 1545147063759, + "version": "0.4.0" + }, + "pyepsg-0.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "7a6ab31123834828c4efdefb2c1e27ef", + "name": "pyepsg", + "sha256": "9441f5130c886140ab561983983611c88d50ae74c61307cd2530238f69ca4bb2", + "size": 24300, + "subdir": "linux-64", + "timestamp": 1545125278184, + "version": "0.4.0" + }, + "pyerfa-1.7.1.1-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ebdfc39a78fc900d2cb887f10b930b67", + "name": "pyerfa", + "sha256": "b8b3f75e97150344ef42e174352b50db3ec1e293d7927fd3fb9ee734286eaa23", + "size": 377035, + "subdir": "linux-64", + "timestamp": 1606860306790, + "version": "1.7.1.1" + }, + "pyerfa-1.7.1.1-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ece953d9fbe4ce60b5e2e4bdc3b26052", + "name": "pyerfa", + "sha256": "f6c74031b7f7b2946905a7f8f800d84cc05f3b9718bc6134dbe8b8f81fad0382", + "size": 380062, + "subdir": "linux-64", + "timestamp": 1606860306313, + "version": "1.7.1.1" + }, + "pyerfa-1.7.1.1-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "78f9dd4f9fb8c46711c9c251fa9a5f21", + "name": "pyerfa", + "sha256": "78c0b5e9dafa64346881c4ca2fecb09b8fd9b74e08bd415fa1a6d8dd53af245d", + "size": 380049, + "subdir": "linux-64", + "timestamp": 1606860302981, + "version": "1.7.1.1" + }, + "pyerfa-1.7.1.1-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9aabca895e318650c465d0b94dc0d430", + "name": "pyerfa", + "sha256": "45c6282bad1941db92b2f6fb8704d890ef90a5892273c533f35b4268b8d9e054", + "size": 375685, + "subdir": "linux-64", + "timestamp": 1607623045221, + "version": "1.7.1.1" + }, + "pyerfa-1.7.2-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8abe47fcbb229170cea78c2e861a9a75", + "name": "pyerfa", + "sha256": "462555729d25cc13d4c25764ef4d231ef3a4d2dc708326cf44d01705ccd0e442", + "size": 372942, + "subdir": "linux-64", + "timestamp": 1613849612675, + "version": "1.7.2" + }, + "pyerfa-1.7.2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3470a473e9abc93fecf52d7cf676eede", + "name": "pyerfa", + "sha256": "fc6a13fcf825db28715d201e8f78ca8b918a0babd3c3dd5601a8a175a897b388", + "size": 374859, + "subdir": "linux-64", + "timestamp": 1613848803610, + "version": "1.7.2" + }, + "pyerfa-1.7.2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0c669417ea1076313100d02233303798", + "name": "pyerfa", + "sha256": "6924a887079cef02c0c4fe7df7ac85209704ce6feb48c69ae5d1867fd1cf91d8", + "size": 392504, + "subdir": "linux-64", + "timestamp": 1613849144833, + "version": "1.7.2" + }, + "pyerfa-1.7.2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c1e7dbcbbd27feab6f396858c12cfb6d", + "name": "pyerfa", + "sha256": "a766aab1992ca3b117e650ca870675abcdd161943f6dfd713bc6c5979393a4c2", + "size": 392433, + "subdir": "linux-64", + "timestamp": 1613849616241, + "version": "1.7.2" + }, + "pyerfa-1.7.3-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "363cd8332545da5573d4416a215e76cd", + "name": "pyerfa", + "sha256": "b5f4622cf8279c847fb904ea37afe841fa96b17212c794fb673da0fd01dfc1c5", + "size": 391353, + "subdir": "linux-64", + "timestamp": 1619390728193, + "version": "1.7.3" + }, + "pyerfa-1.7.3-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fbe4ca43a72d6aa486a752f0499ab2be", + "name": "pyerfa", + "sha256": "7c6ee19110daf2c033da18fd23274ab9a57364e2092e80da07b5cb37179c2d83", + "size": 391860, + "subdir": "linux-64", + "timestamp": 1619390992038, + "version": "1.7.3" + }, + "pyerfa-1.7.3-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.20.1,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b68cda3174ea3ffbcb4576da72acb586", + "name": "pyerfa", + "sha256": "cc97b406b67f3192ac35bbbda163dcd0d8b0fc2e475a8345c80df031a10362c7", + "size": 393213, + "subdir": "linux-64", + "timestamp": 1619390988215, + "version": "1.7.3" + }, + "pyerfa-1.7.3-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.20.1,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb7d363fded13f50ea9dddb56e4bba7d", + "name": "pyerfa", + "sha256": "3ff937fa58fff92fe62198f429deb4198d741773af10eb61f7ed1fa9f4a608e0", + "size": 393175, + "subdir": "linux-64", + "timestamp": 1619390989810, + "version": "1.7.3" + }, + "pyerfa-2.0.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.20.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5ffbeb8516d06f9f787b5eaa8929bd28", + "name": "pyerfa", + "sha256": "0e0dc2ba453b1bcec898ed31f017bbc7102de0c27cf569f322193675b96b911f", + "size": 763555, + "subdir": "linux-64", + "timestamp": 1640793251993, + "version": "2.0.0" + }, + "pyerfa-2.0.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.20.2,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bc1550d893fa072c5ab0a575c64f0dab", + "name": "pyerfa", + "sha256": "ddd4004c1d501b2ebeb04bd4ddef28b337ac90ba4d72ab141693edc972cbafa2", + "size": 488255, + "subdir": "linux-64", + "timestamp": 1676838599904, + "version": "2.0.0" + }, + "pyerfa-2.0.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.20.2,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "efc995b03b3d7a727a258df504675794", + "name": "pyerfa", + "sha256": "24894543155e71dbc44378cd1fac82325be6eb23206f0460678c741788a78053", + "size": 460523, + "subdir": "linux-64", + "timestamp": 1621560271233, + "version": "2.0.0" + }, + "pyerfa-2.0.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.20.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb8c1d567dbd7159f2d91883238f7e5f", + "name": "pyerfa", + "sha256": "7199b775d91c6060a35664415e3863aa0b0910d9fdedc2039e8121361430bdb6", + "size": 463130, + "subdir": "linux-64", + "timestamp": 1621560894490, + "version": "2.0.0" + }, + "pyerfa-2.0.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.20.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c23cccf18ebf16a57fa39b45be83a6fc", + "name": "pyerfa", + "sha256": "f40c10b27e25762d09e10bb11520ed9ce93e4d8ac8246434bd8ef2ddcfe9c8f4", + "size": 450799, + "subdir": "linux-64", + "timestamp": 1621556205918, + "version": "2.0.0" + }, + "pyface-6.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c9c6082726a093fa07c7d471f88a93d3", + "name": "pyface", + "sha256": "d5ae907ecce8414945e07074ee21f9e31b684be9f3c2b61bc108be327e35ff8a", + "size": 1013003, + "subdir": "linux-64", + "timestamp": 1524522519182, + "version": "6.0.0" + }, + "pyface-6.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.5,<3.6.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dd330679b64ba1c0a5d0be3827f79ea9", + "name": "pyface", + "sha256": "46eb6a908dfad38b08fede0729d4652ee55d2b8a0a56e3edb78789cdcae0e8a7", + "size": 1041880, + "subdir": "linux-64", + "timestamp": 1524522591572, + "version": "6.0.0" + }, + "pyface-6.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "91fcc8f8771887b67c8578bd2e1bc345", + "name": "pyface", + "sha256": "dbafc7520bbf4241b7d1f31f96cfe37bbc9dc92b45696461a00c0b07f26be852", + "size": 1036456, + "subdir": "linux-64", + "timestamp": 1524522607459, + "version": "6.0.0" + }, + "pyface-6.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4db2d82508dc398fc8d3dd97d9ba664b", + "name": "pyface", + "sha256": "417c9f343ae5ddd093627dbdb770871fbf65416046b24c173446d9c8dc1126b6", + "size": 1054710, + "subdir": "linux-64", + "timestamp": 1530874038957, + "version": "6.0.0" + }, + "pyface-6.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f87d5f989b9f211eb7767d65f836f28d", + "name": "pyface", + "sha256": "d098381cb2f15b42aca6f6440094b4f10dafc87dcb3da0f3f9156d68b3049f99", + "size": 1104825, + "subdir": "linux-64", + "timestamp": 1564703480825, + "version": "6.1.2" + }, + "pyface-6.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3008a741a9e41f56284f10ead3ba6c10", + "name": "pyface", + "sha256": "3c4bec0cc110a981d416287171b6ae27a999a1d6166231f7a4aa4324cf50ce27", + "size": 1100501, + "subdir": "linux-64", + "timestamp": 1564703478324, + "version": "6.1.2" + }, + "pyface-6.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "083c5789a895327315b0eefe30771203", + "name": "pyface", + "sha256": "4020bd76a44ed1f47ac50930749cd9db47355fda14506cba8acd99411a053ed8", + "size": 1096520, + "subdir": "linux-64", + "timestamp": 1564753572173, + "version": "6.1.2" + }, + "pyface-6.1.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.8,<3.9.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "388dab0252a6fd3024d790ef89b34fa0", + "name": "pyface", + "sha256": "4d03d9ff1688813c0359a900bfdfdc2cb18b8728672acec14f47c61f0ce06e2b", + "size": 1091695, + "subdir": "linux-64", + "timestamp": 1574170435158, + "version": "6.1.2" + }, + "pyface-7.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "pyqt", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e784badb818bbc14a69ab0cc3157dd95", + "name": "pyface", + "sha256": "646eba2f82eba1c55778778a998277784de192c6ab13d0bb069f1c870e2f0893", + "size": 1158016, + "subdir": "linux-64", + "timestamp": 1595348035327, + "version": "7.0.1" + }, + "pyface-7.0.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3dc6e3d9931597127c2e202fa10bc8d9", + "name": "pyface", + "sha256": "8c44975b890b1dfa488f257f590b548755f956c9c6ee265d0263b51f953f83bf", + "size": 1155643, + "subdir": "linux-64", + "timestamp": 1595438021361, + "version": "7.0.1" + }, + "pyface-7.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cd8c2add8670ec7f0848ac5afcfc877b", + "name": "pyface", + "sha256": "776086ed29b6c117023e5aeed730393029796415b31a3a69c21bcaac39d277d8", + "size": 1150771, + "subdir": "linux-64", + "timestamp": 1595348048518, + "version": "7.0.1" + }, + "pyface-7.0.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8695ef0a80e078edf82663fb13c44c6b", + "name": "pyface", + "sha256": "56452e44926496a7c60aa4f7f172b74877adad1f8c095e186ddab27feaa3ddc8", + "size": 1152830, + "subdir": "linux-64", + "timestamp": 1595438016341, + "version": "7.0.1" + }, + "pyface-7.0.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pygments", + "pyqt", + "python >=3.8,<3.9.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e65ad88448ecd62bc1c2808f685ed7f3", + "name": "pyface", + "sha256": "b724dff2591ad00faeb43aa9c982692126a9f55a22f3ab70fd54e01b5699cc33", + "size": 1155185, + "subdir": "linux-64", + "timestamp": 1595347440939, + "version": "7.0.1" + }, + "pyface-7.0.1-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.8,<3.9.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2c71dab1904dff55f6994d2121459b26", + "name": "pyface", + "sha256": "5969ca4db0652bb8f032f90f6019ada340f9fabff2b1a0a34cae8ea67fc4a822", + "size": 1153185, + "subdir": "linux-64", + "timestamp": 1595438028979, + "version": "7.0.1" + }, + "pyface-7.1.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a62cc272f4241af6120e80eed9c86e1a", + "name": "pyface", + "sha256": "ef658a0a1cf334fe6e3ddf4dcc6ad86e0dd00566c3fca4d753de978079835e50", + "size": 1266654, + "subdir": "linux-64", + "timestamp": 1603218562121, + "version": "7.1.0" + }, + "pyface-7.1.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0c42966c6fb695bbfb69fdc9119822fd", + "name": "pyface", + "sha256": "de86704bacded2b36180a43b0d5c6cceac5b481e305a642eef58a257791be6be", + "size": 1273437, + "subdir": "linux-64", + "timestamp": 1603218558298, + "version": "7.1.0" + }, + "pyface-7.1.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.8,<3.9.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dab2bb7f85336249621a05756e2b42d5", + "name": "pyface", + "sha256": "5fc97cc3b5b4ec7150b856d75a80d1751441eac4c5d723a5403d7a9f963ac63d", + "size": 1275625, + "subdir": "linux-64", + "timestamp": 1603218516554, + "version": "7.1.0" + }, + "pyface-7.2.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c8a2e01caa5831dac9cb37ca22bf92fb", + "name": "pyface", + "sha256": "2c2162115f20f33d592ba10b0ae97f510b8d4bb3562ba789961e7bafbc3ca0fc", + "size": 1304106, + "subdir": "linux-64", + "timestamp": 1607623408971, + "version": "7.2.0" + }, + "pyface-7.2.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "520de58a9dce22a630e6143cef410b41", + "name": "pyface", + "sha256": "2a75e7e5c55b99b831af7edc8813ec09ba4ec8f489dddf782ef801138a12dd1d", + "size": 1298532, + "subdir": "linux-64", + "timestamp": 1607623406599, + "version": "7.2.0" + }, + "pyface-7.2.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.8,<3.9.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e6795aac2ef24a06ad056112615bf64a", + "name": "pyface", + "sha256": "7b217f4efe6bd14fe1ad4020bc2f4b69d7422f7adc62f858cd9976e8e3944865", + "size": 1290735, + "subdir": "linux-64", + "timestamp": 1607623382991, + "version": "7.2.0" + }, + "pyface-7.3.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.10,<3.11.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8f2610d16c555edcdf7976b02eaa3071", + "name": "pyface", + "sha256": "ee3e1ea614ee704cdad6776a8d4717a3b1ff9f9d7887abf588ab52c420995b7d", + "size": 1329733, + "subdir": "linux-64", + "timestamp": 1640810281106, + "version": "7.3.0" + }, + "pyface-7.3.0-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.11,<3.12.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1919ef95d061fffbc28c03dc635ae9d9", + "name": "pyface", + "sha256": "ae4b04519c3ba2cf46b9a67e5f4d67745fb08bdf1272627a93305c56c043eed7", + "size": 1642752, + "subdir": "linux-64", + "timestamp": 1676860764724, + "version": "7.3.0" + }, + "pyface-7.3.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6c339e7017e6f6e4e22b142262e40e44", + "name": "pyface", + "sha256": "8c439fa0f493893669abf1855cffe144ccfe8a6fc42a7088698e514a41cb89fd", + "size": 1312991, + "subdir": "linux-64", + "timestamp": 1614365830516, + "version": "7.3.0" + }, + "pyface-7.3.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "db12fa9c949d791c08ced88f73109c5d", + "name": "pyface", + "sha256": "088157a1ef2f444789586fe63ff54c71f7f0547dae4a9c45ef487893a434d26d", + "size": 1295037, + "subdir": "linux-64", + "timestamp": 1614365893514, + "version": "7.3.0" + }, + "pyface-7.3.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.8,<3.9.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b887ea450341be628369335c6d3428a3", + "name": "pyface", + "sha256": "1208392d86273755f6750bc525083bcfba8cf13a6288fd102b00e2980707c2c9", + "size": 1302404, + "subdir": "linux-64", + "timestamp": 1614364756846, + "version": "7.3.0" + }, + "pyface-7.3.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.9,<3.10.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "bb1fbea7cde9d734abaa82b054bd92e9", + "name": "pyface", + "sha256": "c8d8ffd746a80aded97c3ae428d3a24d421ae87b2dfc904c90c11f01daaaa385", + "size": 1313789, + "subdir": "linux-64", + "timestamp": 1614365897950, + "version": "7.3.0" + }, + "pyflakes-1.5.0-py27hfba2528_1.tar.bz2": { + "build": "py27hfba2528_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5326a254f5aa23c135bca58a41519c0f", + "name": "pyflakes", + "sha256": "574d82c7dac8f4a906418e194c89705070f888b8cfd4e484053095c43aa582b0", + "size": 81308, + "subdir": "linux-64", + "timestamp": 1505743071531, + "version": "1.5.0" + }, + "pyflakes-1.5.0-py35h06f3f26_1.tar.bz2": { + "build": "py35h06f3f26_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6294edf23e6e2413253c1bac7efbd231", + "name": "pyflakes", + "sha256": "f6131895c6ca28df57fa099b20030926b8e881f6f5eb53f5e089d2e6e2a34481", + "size": 85693, + "subdir": "linux-64", + "timestamp": 1505743084876, + "version": "1.5.0" + }, + "pyflakes-1.5.0-py36h5510808_1.tar.bz2": { + "build": "py36h5510808_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0730e795f2cffed613c51c5801f81108", + "name": "pyflakes", + "sha256": "911d6cdd89ba1eadef7df25b4376762049d275c4335cb86f31b402a1478308f5", + "size": 85422, + "subdir": "linux-64", + "timestamp": 1505743098324, + "version": "1.5.0" + }, + "pyflakes-1.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8986439cbdf984bd5ab87beaa3c8ed00", + "name": "pyflakes", + "sha256": "3b87afb8ba873d20c45a6fb4c589c326b88d0abf14f556860234898b7d4cc7bc", + "size": 83987, + "subdir": "linux-64", + "timestamp": 1530812569534, + "version": "1.6.0" + }, + "pyflakes-1.6.0-py27h904a57d_0.tar.bz2": { + "build": "py27h904a57d_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ac704b97fb93fb7995ae47b152fbf027", + "name": "pyflakes", + "sha256": "49acc58b0e90dc59e3b30d551e096b0d5349ab57dfadf04cc93da3a075b42752", + "size": 82837, + "subdir": "linux-64", + "timestamp": 1506627173930, + "version": "1.6.0" + }, + "pyflakes-1.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b7135691cbcf45c360b9fdb26552ae9", + "name": "pyflakes", + "sha256": "86d03c6bc2f550ae0592f1683a10943dffcd8273eb09b40d48eb8060092d9d13", + "size": 88548, + "subdir": "linux-64", + "timestamp": 1535130133437, + "version": "1.6.0" + }, + "pyflakes-1.6.0-py35hd1da72e_0.tar.bz2": { + "build": "py35hd1da72e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8227767d65f7e60edcf210330b0b408", + "name": "pyflakes", + "sha256": "1b386ab511a9d37144d9c69ee30ee1460a55727b3fae0f848b39b59fa2fcb5ea", + "size": 87178, + "subdir": "linux-64", + "timestamp": 1506627178847, + "version": "1.6.0" + }, + "pyflakes-1.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0173221e4e2942461e78c6507a8e4b1", + "name": "pyflakes", + "sha256": "b676718f2abd93728e75d003b6007613d55dabc96f421bc9b3fd64b5a78e49ad", + "size": 88193, + "subdir": "linux-64", + "timestamp": 1530812620265, + "version": "1.6.0" + }, + "pyflakes-1.6.0-py36h7bd6a15_0.tar.bz2": { + "build": "py36h7bd6a15_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3fe82ea41cef596d57d4724dbcc8f9f3", + "name": "pyflakes", + "sha256": "acd764a6c46150ca741114a9877f7bdb5ce4c017d5375c1c1d808a8de183d4e8", + "size": 86985, + "subdir": "linux-64", + "timestamp": 1506627156746, + "version": "1.6.0" + }, + "pyflakes-1.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "371081f62ccc62bc93589578af27fced", + "name": "pyflakes", + "sha256": "d79529fde1f4119a369b26a45479264f40cae23291f3bcdcb6d87ac5f5665b6b", + "size": 87901, + "subdir": "linux-64", + "timestamp": 1530812594652, + "version": "1.6.0" + }, + "pyflakes-2.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "99aaa41ca25900ee339205304ecb574f", + "name": "pyflakes", + "sha256": "787874ffcf4af331f331430bbbec0780a7fbea8906f73aa5596982a82f78e304", + "size": 85465, + "subdir": "linux-64", + "timestamp": 1527827562346, + "version": "2.0.0" + }, + "pyflakes-2.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "718d3cb7aa00b213fab68cfd432b4e52", + "name": "pyflakes", + "sha256": "d8532f10dc65e084ab7db44b2e34c4ff0b50484b49cee980f96239beea4597d2", + "size": 89795, + "subdir": "linux-64", + "timestamp": 1527828787448, + "version": "2.0.0" + }, + "pyflakes-2.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d4ced1092a1c2571cf67dd5ca3ae349e", + "name": "pyflakes", + "sha256": "ab3ba7ae02361a79b7a7fd28acf1a5044886623f8c849f274a232a5cf0bd203a", + "size": 89737, + "subdir": "linux-64", + "timestamp": 1527827506545, + "version": "2.0.0" + }, + "pyflakes-2.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f45b4a3100387de693c0e31e9855137", + "name": "pyflakes", + "sha256": "036496d9fced79e2c7cbf4a4ac9cc4e0ec88a9ab0900c1484de4d8a32389d53e", + "size": 89456, + "subdir": "linux-64", + "timestamp": 1530812646407, + "version": "2.0.0" + }, + "pyflakes-2.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "242ab219be6c28293557dd30fb3ef4f6", + "name": "pyflakes", + "sha256": "06845ebd1264571a94a9b38d7b7220d09cb32c9dcb357aa56ba469a0362cd974", + "size": 98685, + "subdir": "linux-64", + "timestamp": 1549329839774, + "version": "2.1.0" + }, + "pyflakes-2.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "682aa12c9d6b1593ecff27743b355068", + "name": "pyflakes", + "sha256": "88fb7b2e8834a75ac3d2a79c49e06d277d79c1ee980d559ea00de9a00bd914a2", + "size": 103995, + "subdir": "linux-64", + "timestamp": 1549329871095, + "version": "2.1.0" + }, + "pyflakes-2.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ca192f85cd8f62a05e2c8936189f471", + "name": "pyflakes", + "sha256": "836177c7d81e27362215fa8a6502c89dc1c896c62811278404dcd142deb3a31e", + "size": 103635, + "subdir": "linux-64", + "timestamp": 1549337980776, + "version": "2.1.0" + }, + "pyflakes-2.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b0affe2abc135a14f9a73f1c313b399", + "name": "pyflakes", + "sha256": "587fbe003ec1baf90c9929ca0ac4b65b4b028efd9aba5763880718826dbd6bc1", + "size": 102438, + "subdir": "linux-64", + "timestamp": 1552332345499, + "version": "2.1.1" + }, + "pyflakes-2.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d55c6f1a34dbcd04dee026af5ede0d9e", + "name": "pyflakes", + "sha256": "ca3d90977b0df8ca199218c7aa4b6668f259f87b5e49932f4deb93c1ed251454", + "size": 107751, + "subdir": "linux-64", + "timestamp": 1552332426907, + "version": "2.1.1" + }, + "pyflakes-2.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "881de1295f6a1590d58a67e30f6f13bd", + "name": "pyflakes", + "sha256": "3d4e2b639856ccdcf454838a3f0af8bcd2164155497eed52249377390a959809", + "size": 107444, + "subdir": "linux-64", + "timestamp": 1552332355490, + "version": "2.1.1" + }, + "pyflakes-2.1.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe20c5a4c0f1698d89faa2229b60d4f1", + "name": "pyflakes", + "sha256": "67db9efdfadb71109627a5d8d8b853aea7cf2347aa807ac8d0ce69a1a75db4e3", + "size": 104783, + "subdir": "linux-64", + "timestamp": 1573669072299, + "version": "2.1.1" + }, + "pyflakes-3.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3012ba9c907dc94cddd1bbfd04e48367", + "name": "pyflakes", + "sha256": "471abeee7a226f7b73ca51c0c539f047bf65b28a4e8d6989ca8232f16ca55aef", + "size": 112905, + "subdir": "linux-64", + "timestamp": 1674165233355, + "version": "3.0.1" + }, + "pyflakes-3.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "127c4b970f7ca75fc097805ff279ba87", + "name": "pyflakes", + "sha256": "7ed24624a2100bf263413bf02c6aede67ca738ece62c79d8ccb99d527279be2d", + "size": 143137, + "subdir": "linux-64", + "timestamp": 1677708674088, + "version": "3.0.1" + }, + "pyflakes-3.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c1bb7064653c2b01f3be070598add3a", + "name": "pyflakes", + "sha256": "ad5128c378ee161a60cbf62472081fac6c6f85816b4b4d5d6cc610e9a746063c", + "size": 110414, + "subdir": "linux-64", + "timestamp": 1674165158153, + "version": "3.0.1" + }, + "pyflakes-3.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e877f5c7f7f0bd3556d6135c2dac7c1", + "name": "pyflakes", + "sha256": "ce251e0ee9b8e5049a3b6a4ed1087dc6a66f9c063b81d70080a67ce8c6460db8", + "size": 110992, + "subdir": "linux-64", + "timestamp": 1674165208299, + "version": "3.0.1" + }, + "pyflakes-3.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85f1a56ecd0ac9643b6e3a4dd546d889", + "name": "pyflakes", + "sha256": "89207d81f0501d90a871c78bf6ad07708ea83511419d37134740705e09997d7c", + "size": 111512, + "subdir": "linux-64", + "timestamp": 1674165183337, + "version": "3.0.1" + }, + "pygments-2.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "b60f0106ab8c60ee78156bb6464108d4", + "name": "pygments", + "sha256": "f2d38b78ae66fc6833f635b1d6c1a6e046a2cdb76c09c6b2dabb1e2eff2e4bb9", + "size": 1405132, + "subdir": "linux-64", + "timestamp": 1530695559113, + "version": "2.2.0" + }, + "pygments-2.2.0-py27h4a8b6f5_0.tar.bz2": { + "build": "py27h4a8b6f5_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "6f80dc7adc1ad4d70dc97ff4d5374320", + "name": "pygments", + "sha256": "bc43958e258a3535c22ffc09aaf02341124234007135c1924819490197bd5314", + "size": 1403082, + "subdir": "linux-64", + "timestamp": 1505688802373, + "version": "2.2.0" + }, + "pygments-2.2.0-py35h0f41973_0.tar.bz2": { + "build": "py35h0f41973_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "bb61e1ddd98f48cee743cc3bf066c2c6", + "name": "pygments", + "sha256": "793d9ae48106e9c5b8b101b8a53691220e94b789f7a57e42a3e4be2793d5d0e2", + "size": 1397571, + "subdir": "linux-64", + "timestamp": 1505688828032, + "version": "2.2.0" + }, + "pygments-2.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "b1a311e110003108ea7d21019909f09e", + "name": "pygments", + "sha256": "f9d960eafe65ee4c909571fa3a285e447c4d4accbaa2fa146004f5bec428f8e2", + "size": 1399962, + "subdir": "linux-64", + "timestamp": 1530695494450, + "version": "2.2.0" + }, + "pygments-2.2.0-py36h0d3125c_0.tar.bz2": { + "build": "py36h0d3125c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "ce25508dbdfa0c7f1c12fb8ac021e564", + "name": "pygments", + "sha256": "b1be4a9d6a26f1f2b49379777cd54a5cfc242af66f090ae56960be84e8fc5d89", + "size": 1398174, + "subdir": "linux-64", + "timestamp": 1505688854125, + "version": "2.2.0" + }, + "pygments-2.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "999183d69c8b800b3eed9d05c85a4f18", + "name": "pygments", + "sha256": "2c7c8cd5df79d70155b8831d4a98a6925fdc2f56d73bbda26a496b1ed9855c43", + "size": 1340445, + "subdir": "linux-64", + "timestamp": 1530695529344, + "version": "2.2.0" + }, + "pygments-2.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "f14ab11dea0a2e6a2eb1c7d66aca491f", + "name": "pygments", + "sha256": "84869611f9c406c043dd755585a0fd0f0deb6b42699cbebee58da6c15d9248ee", + "size": 1456977, + "subdir": "linux-64", + "timestamp": 1545073717958, + "version": "2.3.1" + }, + "pygments-2.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "a823b6161a098ee13bc5ef63a1590b8f", + "name": "pygments", + "sha256": "c2480fd99e1e0dd1ee88dd911bc38455509c681e6e11da6605cc7f1620027f01", + "size": 1430508, + "subdir": "linux-64", + "timestamp": 1545073748583, + "version": "2.3.1" + }, + "pygments-2.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "c2a0a020b2d3a172c74a6bc2e5078b80", + "name": "pygments", + "sha256": "43a02f3a259b9c153b77ad5a8e84ad0581623b9a4706485539608b29cd2c8e14", + "size": 1384820, + "subdir": "linux-64", + "timestamp": 1545073730168, + "version": "2.3.1" + }, + "pygpu-0.7.5-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpuarray 0.7.5", + "mako", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "ISC", + "md5": "9e7968ce2f66817095b61770ac8bd2b1", + "name": "pygpu", + "sha256": "27f57fb7876cbe58343f4848a11f8d838b2b287506f1d2ee2b8b78c8403eee86", + "size": 687445, + "subdir": "linux-64", + "timestamp": 1515142640972, + "version": "0.7.5" + }, + "pygpu-0.7.5-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpuarray 0.7.5", + "mako", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "ISC", + "md5": "11d01c0bcea36ac48d0f4827d34e4d4c", + "name": "pygpu", + "sha256": "1039532e3972a67748e0341b7f2bdda8f53297778f1dd47343433dbbfb9c08b1", + "size": 704196, + "subdir": "linux-64", + "timestamp": 1515142921842, + "version": "0.7.5" + }, + "pygpu-0.7.5-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpuarray 0.7.5", + "mako", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "ISC", + "md5": "5ded6769ec950adb0edf86b834aaac2f", + "name": "pygpu", + "sha256": "a14e1e1828a0924bb9f429e40ca9f32bd3ed060688af1c44822b21ca281efcdc", + "size": 706226, + "subdir": "linux-64", + "timestamp": 1515142916990, + "version": "0.7.5" + }, + "pygpu-0.7.6-py27h035aef0_0.tar.bz2": { + "build": "py27h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "ISC", + "md5": "3d58f4951fac1ab0a80d2002138ad21e", + "name": "pygpu", + "sha256": "7f09b06d4a644d6f58b5e566b9d7d4cb43a4271a2f9dbeead5927c5af3368383", + "size": 701626, + "subdir": "linux-64", + "timestamp": 1530916147912, + "version": "0.7.6" + }, + "pygpu-0.7.6-py27h3010b51_0.tar.bz2": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "ISC", + "md5": "d6e996314e488555ed9b6d53aca48cfd", + "name": "pygpu", + "sha256": "7856a6b18b7d684be630f944b4e22ead1ede423fe4c5fbadb29d7b8859a4ff15", + "size": 700003, + "subdir": "linux-64", + "timestamp": 1526496744742, + "version": "0.7.6" + }, + "pygpu-0.7.6-py310h9102076_0.tar.bz2": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "ISC", + "md5": "fdbaf93ddcc53f92303e48ccab072071", + "name": "pygpu", + "sha256": "c8bfd675a8ab977d072177b6fecce131574d3321207e47f410c231356396a016", + "size": 1484364, + "subdir": "linux-64", + "timestamp": 1640793295140, + "version": "0.7.6" + }, + "pygpu-0.7.6-py311hbed6279_1.tar.bz2": { + "build": "py311hbed6279_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libgpuarray 0.7.6", + "mako >=0.7", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "ISC", + "md5": "bfd6ee698b8a4f34b783725911f601a1", + "name": "pygpu", + "sha256": "f410ab87a421e6b4e9a0e614eb3e5621746bc2e5dd44db96080cf792a25c3841", + "size": 665926, + "subdir": "linux-64", + "timestamp": 1676860799985, + "version": "0.7.6" + }, + "pygpu-0.7.6-py35h3010b51_0.tar.bz2": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "ISC", + "md5": "23fb83a8d9a1f11bffe5228da264c2d8", + "name": "pygpu", + "sha256": "0ac1046eb7e7f04f2805f434f5a0c7884f62f6428f404fccc0b9cac73b409e5d", + "size": 716494, + "subdir": "linux-64", + "timestamp": 1526495951693, + "version": "0.7.6" + }, + "pygpu-0.7.6-py36h035aef0_0.tar.bz2": { + "build": "py36h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "ISC", + "md5": "03a7111b7f63fd31867cb1ffc9fcf3dd", + "name": "pygpu", + "sha256": "d20a69948d8a35d1e8b7f74401e96b79bdc369df55085a6dcb509a2df5008ebf", + "size": 718445, + "subdir": "linux-64", + "timestamp": 1530916206065, + "version": "0.7.6" + }, + "pygpu-0.7.6-py36h3010b51_0.tar.bz2": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "ISC", + "md5": "8f5c5f5ba4cb73d8abdb39e2d77f0e58", + "name": "pygpu", + "sha256": "d2af46656a8a9c43939aef262a7249bf781547547c8cf741772ed44431155871", + "size": 718429, + "subdir": "linux-64", + "timestamp": 1526495734174, + "version": "0.7.6" + }, + "pygpu-0.7.6-py36heb32a55_0.tar.bz2": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "ISC", + "md5": "8e7b8b4d13f7b6dccf19fd839d6802f9", + "name": "pygpu", + "sha256": "1b1b0c319c2400e7b12e8059905253064c5842cdd1ac314702b055acfe809da5", + "size": 660275, + "subdir": "linux-64", + "timestamp": 1592405454504, + "version": "0.7.6" + }, + "pygpu-0.7.6-py37h035aef0_0.tar.bz2": { + "build": "py37h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "ISC", + "md5": "bdf91db09fea3e228f7577fe61b20514", + "name": "pygpu", + "sha256": "890208a0f025b3edbe1ab76805da5fcc58a72ae81de0b666a56acce8e6e31f5c", + "size": 716411, + "subdir": "linux-64", + "timestamp": 1530916087910, + "version": "0.7.6" + }, + "pygpu-0.7.6-py37hce1f21e_1.tar.bz2": { + "build": "py37hce1f21e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libgpuarray 0.7.6", + "mako >=0.7", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "ISC", + "md5": "e4f300cde1fa54d74fb0187efb62b973", + "name": "pygpu", + "sha256": "f7c96e1394679110ee5d4f6b1b76a63d9b730edbffa5ac03a750ef16be355748", + "size": 648147, + "subdir": "linux-64", + "timestamp": 1643631298338, + "version": "0.7.6" + }, + "pygpu-0.7.6-py37heb32a55_0.tar.bz2": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "ISC", + "md5": "e7d62038e3962b7a9b4d702a2b9f168f", + "name": "pygpu", + "sha256": "1dd5bfd6fb44863699b123a9aae648a40222b50bc79c9e83ae029376fff8bfbf", + "size": 658821, + "subdir": "linux-64", + "timestamp": 1592405457398, + "version": "0.7.6" + }, + "pygpu-0.7.6-py38hce1f21e_1.tar.bz2": { + "build": "py38hce1f21e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libgpuarray 0.7.6", + "mako >=0.7", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "ISC", + "md5": "0e4b59c8f76df062154a71d95af3fe08", + "name": "pygpu", + "sha256": "ef2e7e355682498e3549d8f43854a69c83f3843a9b7c9291aa96eb4cd93ab6a4", + "size": 656425, + "subdir": "linux-64", + "timestamp": 1643631399188, + "version": "0.7.6" + }, + "pygpu-0.7.6-py38heb32a55_0.tar.bz2": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "ISC", + "md5": "2334ef20dd57aad7b784bfd2a104cd3d", + "name": "pygpu", + "sha256": "d9c95efd5502c3671d749a1a17e1a6a6956ffa5a58bd9eaba1b7c368376f0cf5", + "size": 656977, + "subdir": "linux-64", + "timestamp": 1592405465875, + "version": "0.7.6" + }, + "pygpu-0.7.6-py39hce1f21e_1.tar.bz2": { + "build": "py39hce1f21e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libgpuarray 0.7.6", + "mako >=0.7", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "ISC", + "md5": "85f2448e60bc416abe0ed14897bc4380", + "name": "pygpu", + "sha256": "7ae8db158a0a07f3d6b7b8407711621e83a4c4615622259ccbbfbc7ba49cc4a5", + "size": 656387, + "subdir": "linux-64", + "timestamp": 1643631351357, + "version": "0.7.6" + }, + "pygraphviz-1.3-py27h14c3975_1.tar.bz2": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "graphviz", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "68c004f84a80df8888c0dfcefa713fa9", + "name": "pygraphviz", + "sha256": "6a9c0e0ccbcd21b5bdb817816ff9cddd62e5f1e9a965ebdd8f1c18f198b117f2", + "size": 111748, + "subdir": "linux-64", + "timestamp": 1530916807132, + "version": "1.3" + }, + "pygraphviz-1.3-py27hac024dc_0.tar.bz2": { + "build": "py27hac024dc_0", + "build_number": 0, + "depends": [ + "graphviz 2.38.*", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ff4e3f45980dbce3826de87e8ccef51d", + "name": "pygraphviz", + "sha256": "d468c6ddadacd3a3980734e27ade2442263dee2770a169bd583896b240ea2b60", + "size": 112258, + "subdir": "linux-64", + "timestamp": 1513663608768, + "version": "1.3" + }, + "pygraphviz-1.3-py35hd6187a3_0.tar.bz2": { + "build": "py35hd6187a3_0", + "build_number": 0, + "depends": [ + "graphviz 2.38.*", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1380e30a865305f1e0d665c1484764f7", + "name": "pygraphviz", + "sha256": "e10cb2477b2a96208863e5a65ee2432d31fb94a18763bcd7b7a366994e385d10", + "size": 113354, + "subdir": "linux-64", + "timestamp": 1513663683695, + "version": "1.3" + }, + "pygraphviz-1.3-py36h14c3975_1.tar.bz2": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "graphviz", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5dabd2ea330db8da79c6ba22d00219c8", + "name": "pygraphviz", + "sha256": "5422b2e673a2a731f52585727620691f7828bff7971109ddd0fd312f2f55aa8b", + "size": 112690, + "subdir": "linux-64", + "timestamp": 1530916508026, + "version": "1.3" + }, + "pygraphviz-1.3-py36hd547939_0.tar.bz2": { + "build": "py36hd547939_0", + "build_number": 0, + "depends": [ + "graphviz 2.38.*", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3efa1d7137445b6b253c95671e876623", + "name": "pygraphviz", + "sha256": "cf287697ee977f9b33e7aa9aab2ce1e506f84b1fbe0d5322764d61ee583af126", + "size": 113190, + "subdir": "linux-64", + "timestamp": 1513663573715, + "version": "1.3" + }, + "pygraphviz-1.3-py37h14c3975_1.tar.bz2": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "graphviz", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "159cf2550aad288db1ebd1e252347865", + "name": "pygraphviz", + "sha256": "5494312f5e19603fe4a8266643c71cd70934364fd4aafa509c928dd89a6a8a5e", + "size": 112918, + "subdir": "linux-64", + "timestamp": 1530916246327, + "version": "1.3" + }, + "pygraphviz-1.7-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "graphviz", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "80b0e1b0d328502ba8c36cfa5413f4f8", + "name": "pygraphviz", + "sha256": "7202cab5991acfd756940c37f617ebc7aac8d5bf7225b43e1d95cddb77412d3d", + "size": 197125, + "subdir": "linux-64", + "timestamp": 1640793328084, + "version": "1.7" + }, + "pygraphviz-1.9-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "graphviz >=2.42", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "592b59bb466951d4add703401be6a0b1", + "name": "pygraphviz", + "sha256": "bb4c4690997f01fdc1e7d92a176fa70417fcd204860152358fcd01ef0de33797", + "size": 203261, + "subdir": "linux-64", + "timestamp": 1657200609677, + "version": "1.9" + }, + "pygraphviz-1.9-py310h5eee18b_1.tar.bz2": { + "build": "py310h5eee18b_1", + "build_number": 1, + "depends": [ + "graphviz >=2.42,<3", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a0c8739145a3296b87e078463f40fe61", + "name": "pygraphviz", + "sha256": "d0b624c4a11c2c3ca5ecae956eb198c1fbd8d9d7bbcfa8f5986f6e14de878a72", + "size": 129829, + "subdir": "linux-64", + "timestamp": 1671045723983, + "version": "1.9" + }, + "pygraphviz-1.9-py311h5eee18b_1.tar.bz2": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "graphviz >=2.42,<3", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d94e651be2fbf6115fc080001f82cf57", + "name": "pygraphviz", + "sha256": "0a8d1650768ac66e98e702db97c50c243fead50fb844f4d4ed3c200a88a6bc01", + "size": 151242, + "subdir": "linux-64", + "timestamp": 1676860826409, + "version": "1.9" + }, + "pygraphviz-1.9-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "graphviz >=2.42", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bfff5b631dbf9cfee0bde7a3c59f52e9", + "name": "pygraphviz", + "sha256": "d8c9b4fbf2d23ee0f6c4d28402d74ec2325e521636b3f766e453274463bc5b44", + "size": 129780, + "subdir": "linux-64", + "timestamp": 1657200653651, + "version": "1.9" + }, + "pygraphviz-1.9-py38h5eee18b_1.tar.bz2": { + "build": "py38h5eee18b_1", + "build_number": 1, + "depends": [ + "graphviz >=2.42,<3", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f1252ad6c3fb5b9c9a5d07030811681", + "name": "pygraphviz", + "sha256": "84baee728606e8bfa8943ee0650a24c2977d75b590037312375175acdfb6181a", + "size": 129876, + "subdir": "linux-64", + "timestamp": 1671045630216, + "version": "1.9" + }, + "pygraphviz-1.9-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "graphviz >=2.42", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0ebf5f187e6692816294ea4eb60664bb", + "name": "pygraphviz", + "sha256": "3c1603d4ffe7559a9020b3532b093e384f03413a0759b747427762c02362e41a", + "size": 129700, + "subdir": "linux-64", + "timestamp": 1657200699161, + "version": "1.9" + }, + "pygraphviz-1.9-py39h5eee18b_1.tar.bz2": { + "build": "py39h5eee18b_1", + "build_number": 1, + "depends": [ + "graphviz >=2.42,<3", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "15a7faddd9d1b91f0ba8ef4a876e852e", + "name": "pygraphviz", + "sha256": "1842b0307cbcb94bce1144c185b5e747b09e4df692a167fa8b16273fc290a050", + "size": 129867, + "subdir": "linux-64", + "timestamp": 1671045677169, + "version": "1.9" + }, + "pyhamcrest-1.9.0-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "213af4da34dffefe9867d03ebbd74ca2", + "name": "pyhamcrest", + "sha256": "5751106a5d9b6307b710e06cc4cc623f6f2a197d153991b2d4d06ed4e47a0a69", + "size": 46689, + "subdir": "linux-64", + "timestamp": 1539712622614, + "version": "1.9.0" + }, + "pyhamcrest-1.9.0-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "5aac86f2418c96de8b73dcfb89317332", + "name": "pyhamcrest", + "sha256": "cd5b9d8ed5572730e8f98e438e5cc1fb537f4d93df0f5e8a8ab6662366ead2a9", + "size": 47770, + "subdir": "linux-64", + "timestamp": 1539712643753, + "version": "1.9.0" + }, + "pyhamcrest-1.9.0-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "dbb2f15d29ebc48a7b551d702bbb2587", + "name": "pyhamcrest", + "sha256": "b436cfd20cb3a5dc9c1fa50fa8aac6fe885eb64fffaa2cf8ed740999a20bbb9a", + "size": 47828, + "subdir": "linux-64", + "timestamp": 1539712625005, + "version": "1.9.0" + }, + "pyhive-0.5.0-py27h9f55a9b_0.tar.bz2": { + "build": "py27h9f55a9b_0", + "build_number": 0, + "depends": [ + "future", + "python >=2.7,<2.8.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "0c414901fbd14a816ad249067390da3b", + "name": "pyhive", + "sha256": "7192a5e8434687bdb1d3b9752f370115647e9482fc5e39019f301108414eab81", + "size": 76848, + "subdir": "linux-64", + "timestamp": 1512160066928, + "version": "0.5.0" + }, + "pyhive-0.5.0-py35hc170076_0.tar.bz2": { + "build": "py35hc170076_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.5,<3.6.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "7cc147ac4d6e6864ebea57e2ec6e7dfc", + "name": "pyhive", + "sha256": "0fb8cfa00112d748bf0e2a5611030637e030c6e541b48506291399efedb8fa2d", + "size": 81617, + "subdir": "linux-64", + "timestamp": 1512160072569, + "version": "0.5.0" + }, + "pyhive-0.5.0-py36h4c6b8b4_0.tar.bz2": { + "build": "py36h4c6b8b4_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.6,<3.7.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "96dc2fbbbbdc20b91b527334d15f09c9", + "name": "pyhive", + "sha256": "119ab4dccc160a8bd3d18a189920af3238ab240605ad69284cbbea45091f3082", + "size": 81084, + "subdir": "linux-64", + "timestamp": 1512160090214, + "version": "0.5.0" + }, + "pyhive-0.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "future", + "python >=2.7,<2.8.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "098762021c0bd5d8b8ff607da2d9b880", + "name": "pyhive", + "sha256": "49ce5655c09175d263eb9c8ffddbbf664a36400f16e9fa0386ef54dc4e0471b1", + "size": 76964, + "subdir": "linux-64", + "timestamp": 1520832370605, + "version": "0.5.1" + }, + "pyhive-0.5.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.5,<3.6.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "18994d15f9f253e683fe6cbcb0f5be03", + "name": "pyhive", + "sha256": "2768f8b005c24f3e76f71f2e1f031209000c39e6672e558fb5c51c9dd8f8b748", + "size": 81733, + "subdir": "linux-64", + "timestamp": 1520832382616, + "version": "0.5.1" + }, + "pyhive-0.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.6,<3.7.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "06321ee21291f7b9919a593b4851dcdd", + "name": "pyhive", + "sha256": "a9b345877a8ea197422f01c422761c29644882892449084472ff33724de24f37", + "size": 81265, + "subdir": "linux-64", + "timestamp": 1520832354286, + "version": "0.5.1" + }, + "pyhive-0.5.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "future", + "python >=2.7,<2.8.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "183ae00a54b83fe2862a95fe2593e76e", + "name": "pyhive", + "sha256": "c8e2cee755b79585597fbf873c59d7fde7143685d381ae7dcced3683eac75368", + "size": 76693, + "subdir": "linux-64", + "timestamp": 1527698739954, + "version": "0.5.2" + }, + "pyhive-0.5.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.5,<3.6.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "5ad55fae6a0009bf5202cababbdebbfb", + "name": "pyhive", + "sha256": "8e3818ab9591fa144747ec67fc1b4d60cc48081339c5e522972dcdbf6222adb8", + "size": 81361, + "subdir": "linux-64", + "timestamp": 1527698770783, + "version": "0.5.2" + }, + "pyhive-0.5.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.6,<3.7.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "a9c6314203b1e905688a3f6d9dd31689", + "name": "pyhive", + "sha256": "41bb94b312df0a23af3e0a74df10ff004b165b421077cbda0a779cb7b3be2731", + "size": 80899, + "subdir": "linux-64", + "timestamp": 1527698723507, + "version": "0.5.2" + }, + "pyhive-0.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "future", + "python >=2.7,<2.8.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "c0c338115ccf8a47a3f03814f87f7fd1", + "name": "pyhive", + "sha256": "05a5345a055b55df87c9092934fe48b61fd2fb88998c97d87f5eabcffaace312", + "size": 79083, + "subdir": "linux-64", + "timestamp": 1529423848643, + "version": "0.6.0" + }, + "pyhive-0.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.5,<3.6.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "e119b332d91249dac6263ea0d380ffb3", + "name": "pyhive", + "sha256": "4410273655f22a5a1cbe876efc2c82ed1cc956b56a89a4927b04d384b0a4d340", + "size": 83385, + "subdir": "linux-64", + "timestamp": 1529423843029, + "version": "0.6.0" + }, + "pyhive-0.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.6,<3.7.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "31c79ac014f4c863a5daba921c09195e", + "name": "pyhive", + "sha256": "a4e5a4d5a2bf09a66f95ba0addd1c7e03d380dccb8334bc607ad41a794e53a66", + "size": 82917, + "subdir": "linux-64", + "timestamp": 1529423836660, + "version": "0.6.0" + }, + "pyhive-0.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.7,<3.8.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "7fe098b27dcee1e0e0d338cee7ab1c6b", + "name": "pyhive", + "sha256": "efa74795a3dba8b4d33f298941ea63dc002a14342bf3d0c3acf2a744e7828af3", + "size": 83096, + "subdir": "linux-64", + "timestamp": 1530917075591, + "version": "0.6.0" + }, + "pyhive-0.6.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "future", + "python >=2.7,<2.8.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "4fd9d941d20a326a16fa7b84ca800c48", + "name": "pyhive", + "sha256": "3ca16ca9541fa57952eb8967b050f561e86eef281aa6f6b43a1fd53c143dc09e", + "size": 79162, + "subdir": "linux-64", + "timestamp": 1539724861765, + "version": "0.6.1" + }, + "pyhive-0.6.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.10,<3.11.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "a48321c58c10a324009fad9e6fc04dbb", + "name": "pyhive", + "sha256": "d87d8013fdbd88a3819833afb9d40b1b1fccc979ab80f5996bdc26c401c9434d", + "size": 84506, + "subdir": "linux-64", + "timestamp": 1640812694771, + "version": "0.6.1" + }, + "pyhive-0.6.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.11,<3.12.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "1b202707dd47c79ce446d5105380ca5d", + "name": "pyhive", + "sha256": "db8b9bb8ceb6a50906a8f590be27ab8630f64aeb1ea9f155f7f0d3cf47e655f6", + "size": 115325, + "subdir": "linux-64", + "timestamp": 1676907553271, + "version": "0.6.1" + }, + "pyhive-0.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.6,<3.7.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "4d2270234bde02b7537d4caaa65c0a32", + "name": "pyhive", + "sha256": "41d69227f8a1cc358f5aa61213f8558ac90ab3c37d77bbd252aeffd856ca749a", + "size": 83081, + "subdir": "linux-64", + "timestamp": 1539724890724, + "version": "0.6.1" + }, + "pyhive-0.6.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.6,<3.7.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "ef706658b7e6816aca75d1c0cd3669df", + "name": "pyhive", + "sha256": "e6d9985dd6a1484593e7c128f676e674eafaa21e902f5064afd2ac966c552a84", + "size": 354451, + "subdir": "linux-64", + "timestamp": 1632742520028, + "version": "0.6.1" + }, + "pyhive-0.6.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.7,<3.8.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "830f6d8ec7ec60e775c0b431a324b1cb", + "name": "pyhive", + "sha256": "6a6f3f0631011929d0c41c7bcab8c7cc11e3eb2d0594d7d243c09b4ef078b328", + "size": 83150, + "subdir": "linux-64", + "timestamp": 1539724883143, + "version": "0.6.1" + }, + "pyhive-0.6.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.7,<3.8.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "a1cd3999d054feb96adc9f4cb5b17fed", + "name": "pyhive", + "sha256": "79de61619229fe1edcb9e00499a9c45a85f33bd4abde4e4dbf2875bdea328078", + "size": 357879, + "subdir": "linux-64", + "timestamp": 1632742518478, + "version": "0.6.1" + }, + "pyhive-0.6.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.8,<3.9.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "44546030693ac2db93e6753f4f1320ef", + "name": "pyhive", + "sha256": "780f0eb999ae61ee428828a7eeb34d4ea4a572577482118cb344d7909759a18f", + "size": 256903, + "subdir": "linux-64", + "timestamp": 1592405415768, + "version": "0.6.1" + }, + "pyhive-0.6.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.8,<3.9.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "682ceefac1e819438711bd6d5de8c075", + "name": "pyhive", + "sha256": "88f8a4f7b8fd37b71a1da4ca9b39df598e9c7e3721fc98d6a1aa1469190d0684", + "size": 356435, + "subdir": "linux-64", + "timestamp": 1632732149701, + "version": "0.6.1" + }, + "pyhive-0.6.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.9,<3.10.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "9a5913e99e1af205068b9fcc14c6cb9f", + "name": "pyhive", + "sha256": "18634d39ebdb9bbdc439f28051c6255571c4153f9f35c952e8fa502238e2d91e", + "size": 356919, + "subdir": "linux-64", + "timestamp": 1632732148932, + "version": "0.6.1" + }, + "pyicu-2.7.4-py310h83be7ef_0.tar.bz2": { + "build": "py310h83be7ef_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "07bfcebb9cdfa2a37ad8e50bc6d77783", + "name": "pyicu", + "sha256": "2e3654e0ac1b9c5f143d8bc8f5d385ee22e8aaf27a0891dd4726357ee0e702f2", + "size": 1234700, + "subdir": "linux-64", + "timestamp": 1640793375383, + "version": "2.7.4" + }, + "pyicu-2.7.4-py311h94c2ce2_0.tar.bz2": { + "build": "py311h94c2ce2_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e04d0eb35304b18a4846eb11cec289cf", + "name": "pyicu", + "sha256": "7f0cace254297d1d48498522c88ec16b588b96e7183f5c602c730f2ea5a085d6", + "size": 360388, + "subdir": "linux-64", + "timestamp": 1676860867778, + "version": "2.7.4" + }, + "pyicu-2.7.4-py37h83be7ef_0.tar.bz2": { + "build": "py37h83be7ef_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7d7dc25e0ee378f848f2b3644d04207e", + "name": "pyicu", + "sha256": "3786b84c2f7dbf8727b959cf2adde87e4575220b0eab6c26a1cb2ed2018ff687", + "size": 330770, + "subdir": "linux-64", + "timestamp": 1634899235056, + "version": "2.7.4" + }, + "pyicu-2.7.4-py38h83be7ef_0.tar.bz2": { + "build": "py38h83be7ef_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d0b800746e1dac8ec711666c71deb248", + "name": "pyicu", + "sha256": "0456c9b12fc30d022a7ef96ff2c132ac7b9f0d3b1dd032a6d11e2174641684e7", + "size": 334023, + "subdir": "linux-64", + "timestamp": 1634899226943, + "version": "2.7.4" + }, + "pyicu-2.7.4-py39h83be7ef_0.tar.bz2": { + "build": "py39h83be7ef_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b275f69a34787529b44ef2ae1d0d574d", + "name": "pyicu", + "sha256": "f4a90e7fc0296f7a71cbb570b4dc44f3557f888903fac3a7b02c03c58bee2e77", + "size": 333193, + "subdir": "linux-64", + "timestamp": 1634899238604, + "version": "2.7.4" + }, + "pyinotify-0.9.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "28cca22f40b3b41fff61eab7ebd827c1", + "name": "pyinotify", + "sha256": "ba41b300255381f40dae232be626b8ae0be9df10f732de399878cd80fa8e89c9", + "size": 42712, + "subdir": "linux-64", + "timestamp": 1523040264589, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "199a89a84e7130aebed6a0c1015fad73", + "name": "pyinotify", + "sha256": "f4f6f17a0cb2758ca110f23c11788e1402a9f4e90623fdf0dc45a62350a5dab0", + "size": 44132, + "subdir": "linux-64", + "timestamp": 1640793393897, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "917b09a477d11a2af67c6fb3a42e10c7", + "name": "pyinotify", + "sha256": "2dc0dc19320e2a7e3d99339671642ccb5b78289f6e6b4eefb9af5423e663036b", + "size": 56113, + "subdir": "linux-64", + "timestamp": 1676845337584, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e22d876dcd4131db059e3620a8ee0bec", + "name": "pyinotify", + "sha256": "7e3ef2da0acdbd0a6b5335ab04bd81967245edba1b8f776aa8e5c537f15f9555", + "size": 43471, + "subdir": "linux-64", + "timestamp": 1523040276809, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98ee56161d4c62c959267b492b8aca90", + "name": "pyinotify", + "sha256": "ba96b1a797c5637447c31b81a75327e3da8de0bb59c1c9e1f0c1d5d1e51b7c53", + "size": 43259, + "subdir": "linux-64", + "timestamp": 1523040349406, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4b362c5f07d1672bcda372dea268c397", + "name": "pyinotify", + "sha256": "1078278babd13cab344b7c806de3cb1d2d6749ac6029dd1dba522f244affda09", + "size": 45014, + "subdir": "linux-64", + "timestamp": 1613485535399, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "32f49cd70d9e94e96e75d5256ca81d79", + "name": "pyinotify", + "sha256": "34fcc21d1338dd829ca347b9e29cb8a0a7b1dca44ee59d584f67a238d4251ac9", + "size": 43265, + "subdir": "linux-64", + "timestamp": 1530873473229, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f6501479a168500f68cc0afb3e642b7", + "name": "pyinotify", + "sha256": "b3cebbb05bcd6598fac73d3287cd24fd885559b468be87b7de89cdffac15245b", + "size": 45141, + "subdir": "linux-64", + "timestamp": 1613484912899, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "acd27cb7584194a16551aa734bedce39", + "name": "pyinotify", + "sha256": "0e6c6f65f95ac54c593a7eb158fc70d239386ffb469a91e23d8726877a92100a", + "size": 43915, + "subdir": "linux-64", + "timestamp": 1573669085013, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7d93894379bc9deb74ad6f378090ecbe", + "name": "pyinotify", + "sha256": "04d938726c8381466620d12d653d0454e956bd6ec76e41bb72c3aea7c27193c4", + "size": 45325, + "subdir": "linux-64", + "timestamp": 1613485551409, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b0cb2462c0743eb8a743b6bada4ab30", + "name": "pyinotify", + "sha256": "726170a1f70cc4b2c2b4e6dea3d02ac86bedf6a2d18c65c6bd015856e358d493", + "size": 45370, + "subdir": "linux-64", + "timestamp": 1613485157752, + "version": "0.9.6" + }, + "pyinstaller-3.4-py36hbc83047_1.tar.bz2": { + "build": "py36hbc83047_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycrypto", + "python >=3.6,<3.7.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 2", + "md5": "85984f498e29259f1f6a347483c7bce5", + "name": "pyinstaller", + "sha256": "ea3681f1f7e6b1e4ff99f067316a30b3e7449861d9d2e8cc164eef49b259d0d9", + "size": 2614514, + "subdir": "linux-64", + "timestamp": 1561613279064, + "version": "3.4" + }, + "pyinstaller-3.4-py37hbc83047_1.tar.bz2": { + "build": "py37hbc83047_1", + "build_number": 1, + "depends": [ + "macholib >=1.8", + "pycrypto", + "python >=3.7,<3.8.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 2", + "md5": "823e66b827d19c91b0c5cd629d4a0ec7", + "name": "pyinstaller", + "sha256": "f7a82661533a83c7aace8a809c4842f3e1e133b86543a15cc3046b22a1aed779", + "size": 2522106, + "subdir": "linux-64", + "timestamp": 1561614320718, + "version": "3.4" + }, + "pyinstaller-3.5-py27hbc83047_0.tar.bz2": { + "build": "py27hbc83047_0", + "build_number": 0, + "depends": [ + "dis3", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycrypto", + "python >=2.7,<2.8.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 2", + "md5": "31a99095437ca0080e0388312b3d6417", + "name": "pyinstaller", + "sha256": "1383ef48525f98a1de16b21d31898bf607ccccab040fff8824258727e3872332", + "size": 2482158, + "subdir": "linux-64", + "timestamp": 1568127081858, + "version": "3.5" + }, + "pyinstaller-3.5-py36hbc83047_0.tar.bz2": { + "build": "py36hbc83047_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycrypto", + "python >=3.6,<3.7.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 2", + "md5": "4ead2ac557bf5b96cec4249aadff845c", + "name": "pyinstaller", + "sha256": "4b7e568dd6aa70d906885d3200c7e81381aedd3427de324990e9458d0eda06cf", + "size": 2644919, + "subdir": "linux-64", + "timestamp": 1568127094368, + "version": "3.5" + }, + "pyinstaller-3.5-py37hbc83047_0.tar.bz2": { + "build": "py37hbc83047_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycrypto", + "python >=3.7,<3.8.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 2", + "md5": "1512306b2330509c8fa299b8d6318676", + "name": "pyinstaller", + "sha256": "51afc2c85d91989bab495bd61d25847d3d5a79f3836a4093bdde75b2b39624b6", + "size": 2575958, + "subdir": "linux-64", + "timestamp": 1568127093309, + "version": "3.5" + }, + "pyinstaller-3.6-py310h1ccaba5_6.tar.bz2": { + "build": "py310h1ccaba5_6", + "build_number": 6, + "depends": [ + "altgraph", + "libgcc-ng >=7.5.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.10,<3.11.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "592d37ea31c67ae80fc73a1b9a8ff60e", + "name": "pyinstaller", + "sha256": "b3f6e8af872dfa34eb7505dde4d6a8e1a8c48fd3db6a03b5b46105d46d756b86", + "size": 1576490, + "subdir": "linux-64", + "timestamp": 1640810317195, + "version": "3.6" + }, + "pyinstaller-3.6-py36h8f29fe8_6.tar.bz2": { + "build": "py36h8f29fe8_6", + "build_number": 6, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.6,<3.7.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "560ffdae57d23eb9319d40f438cb4146", + "name": "pyinstaller", + "sha256": "5c4d492d800f8bd77f4a3c1a781ca0ec7d1b291b645585a8fb9b03aa5a639904", + "size": 1754644, + "subdir": "linux-64", + "timestamp": 1615968551485, + "version": "3.6" + }, + "pyinstaller-3.6-py36hbc83047_1.tar.bz2": { + "build": "py36hbc83047_1", + "build_number": 1, + "constrains": [ + "setuptools <45.0" + ], + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 2", + "md5": "73a4ec46aa38bf262601bb16cb08de5a", + "name": "pyinstaller", + "sha256": "9cc9fde8cec65376defbe545f42f34e4d243ce060a65392091cddb1ba48619dc", + "size": 2648327, + "subdir": "linux-64", + "timestamp": 1580758834141, + "version": "3.6" + }, + "pyinstaller-3.6-py36hbc83047_2.tar.bz2": { + "build": "py36hbc83047_2", + "build_number": 2, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "f448edd736a23cacdc7be23b031ac7ca", + "name": "pyinstaller", + "sha256": "e6619feae4a0d92c64205c0e4892f8d1f48f4808d7d505f3149d39dd65068aa1", + "size": 1752282, + "subdir": "linux-64", + "timestamp": 1589194500353, + "version": "3.6" + }, + "pyinstaller-3.6-py36hbc83047_4.tar.bz2": { + "build": "py36hbc83047_4", + "build_number": 4, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "2915a832e88a0674ab65ce5f6a9891c1", + "name": "pyinstaller", + "sha256": "03e61e5098490bce6fe5b801eb2a8778432488cabf45632085f181024b8a9b5f", + "size": 1600090, + "subdir": "linux-64", + "timestamp": 1589376275508, + "version": "3.6" + }, + "pyinstaller-3.6-py36hbc83047_5.tar.bz2": { + "build": "py36hbc83047_5", + "build_number": 5, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "0d7b075ca7eb8e6c5e4e481775c9f83a", + "name": "pyinstaller", + "sha256": "1c34b4483816648449e9a7ebe03aeb52f69970d8ebcffcc525f173019bee2a36", + "size": 1575455, + "subdir": "linux-64", + "timestamp": 1589567799109, + "version": "3.6" + }, + "pyinstaller-3.6-py37h8f29fe8_6.tar.bz2": { + "build": "py37h8f29fe8_6", + "build_number": 6, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.7,<3.8.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "fb27b01281ca8e204a98d211671eb2a9", + "name": "pyinstaller", + "sha256": "69a91fd830d8cbb585df581d2bdd75659f3bdf64bf1667f6ab49cc1430f60973", + "size": 1741735, + "subdir": "linux-64", + "timestamp": 1615968558482, + "version": "3.6" + }, + "pyinstaller-3.6-py37hbc83047_1.tar.bz2": { + "build": "py37hbc83047_1", + "build_number": 1, + "constrains": [ + "setuptools <45.0" + ], + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 2", + "md5": "bbac6117001340133985b15a4e4956e0", + "name": "pyinstaller", + "sha256": "db177928d6bb5ebd8bfea2f429e12eee1b474e74f916c81e500ec9ac20b9dcb6", + "size": 2527141, + "subdir": "linux-64", + "timestamp": 1580758840903, + "version": "3.6" + }, + "pyinstaller-3.6-py37hbc83047_2.tar.bz2": { + "build": "py37hbc83047_2", + "build_number": 2, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "47ae4a2bba6ce43463d65ef10a839676", + "name": "pyinstaller", + "sha256": "89cfca4721f5947045aac6c1b3a33ea2b7eb7fd6c0807e537bd7bfd03e4dde23", + "size": 1719855, + "subdir": "linux-64", + "timestamp": 1589194453042, + "version": "3.6" + }, + "pyinstaller-3.6-py37hbc83047_4.tar.bz2": { + "build": "py37hbc83047_4", + "build_number": 4, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "4292274b680b7ba372eea3e05ce434ca", + "name": "pyinstaller", + "sha256": "8513fb11e7dccac094dd62c9767a51bb6b76cd0851c920ddc7015a29826305c2", + "size": 1712763, + "subdir": "linux-64", + "timestamp": 1589376295588, + "version": "3.6" + }, + "pyinstaller-3.6-py37hbc83047_5.tar.bz2": { + "build": "py37hbc83047_5", + "build_number": 5, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "ea6b94b6c6b14ee70de7a5f9ebac1a7f", + "name": "pyinstaller", + "sha256": "dd094c1bdfc72858ea00c17e00a0d6b0354acbcf386e8386a2b3712bf8332f12", + "size": 1688976, + "subdir": "linux-64", + "timestamp": 1589567799154, + "version": "3.6" + }, + "pyinstaller-3.6-py38h8f29fe8_6.tar.bz2": { + "build": "py38h8f29fe8_6", + "build_number": 6, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.8,<3.9.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "01f8c559064317d11f69ec77367f979f", + "name": "pyinstaller", + "sha256": "753476fbd5620a15dd5e3cd41a4b1862099753fd28780b4f9876ad068301d43e", + "size": 1563292, + "subdir": "linux-64", + "timestamp": 1615966688592, + "version": "3.6" + }, + "pyinstaller-3.6-py38hbc83047_1.tar.bz2": { + "build": "py38hbc83047_1", + "build_number": 1, + "constrains": [ + "setuptools <45.0" + ], + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 2", + "md5": "1f112ef253a0e49bb897782bd0ebc48b", + "name": "pyinstaller", + "sha256": "67e9b7960dc3dc8b7603fa6b9c88348d7be017b6e9419588817fc32d48d98dfe", + "size": 2790634, + "subdir": "linux-64", + "timestamp": 1580758837000, + "version": "3.6" + }, + "pyinstaller-3.6-py38hbc83047_2.tar.bz2": { + "build": "py38hbc83047_2", + "build_number": 2, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "37698e58510f69a059ce9183dcb72f64", + "name": "pyinstaller", + "sha256": "7be7a0776a84374b3d4372943eda9a77f6748b7fbc7334e29cfaba4ba1ad4ee8", + "size": 1594145, + "subdir": "linux-64", + "timestamp": 1589194505863, + "version": "3.6" + }, + "pyinstaller-3.6-py38hbc83047_4.tar.bz2": { + "build": "py38hbc83047_4", + "build_number": 4, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "d0629e2674503e0e22c515f3e033607e", + "name": "pyinstaller", + "sha256": "232666399d4c1468e18000abf7ef28351433b0d8806c2769f1ca38e5fda918e8", + "size": 1689692, + "subdir": "linux-64", + "timestamp": 1589376281329, + "version": "3.6" + }, + "pyinstaller-3.6-py38hbc83047_5.tar.bz2": { + "build": "py38hbc83047_5", + "build_number": 5, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "994cff6c03a12a35ef46be00febb1069", + "name": "pyinstaller", + "sha256": "f5622be20fde3255451833e15a3a0309cf833991cb470d583da83460922f5211", + "size": 1702222, + "subdir": "linux-64", + "timestamp": 1589567814026, + "version": "3.6" + }, + "pyinstaller-3.6-py39h8f29fe8_6.tar.bz2": { + "build": "py39h8f29fe8_6", + "build_number": 6, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.9,<3.10.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "4e7ff9176f798691feb049f336843685", + "name": "pyinstaller", + "sha256": "9cb5ab89161445376b8891648bfb37fc949a419ba2a95a9070b3716a4e7e6227", + "size": 1612889, + "subdir": "linux-64", + "timestamp": 1615968540512, + "version": "3.6" + }, + "pyinstaller-4.8-py37h1ccaba5_0.tar.bz2": { + "build": "py37h1ccaba5_0", + "build_number": 0, + "depends": [ + "altgraph", + "importlib-metadata >=0.8", + "libgcc-ng >=7.5.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.7,<3.8.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "ad0de212990197f8981c45758348b5cd", + "name": "pyinstaller", + "sha256": "56f700ef9749efae95c4072389436b0099fb400061a401bad6db338e0e873624", + "size": 1763677, + "subdir": "linux-64", + "timestamp": 1643735863060, + "version": "4.8" + }, + "pyinstaller-4.8-py38h1ccaba5_0.tar.bz2": { + "build": "py38h1ccaba5_0", + "build_number": 0, + "depends": [ + "altgraph", + "libgcc-ng >=7.5.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.8,<3.9.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "6840b9e68b0ed0e7cfa882a8ce85ec09", + "name": "pyinstaller", + "sha256": "93e923c4033ea115fc3cf8b6b4bbe34959f38e0296a1f04a6041571c0ec75b73", + "size": 1710800, + "subdir": "linux-64", + "timestamp": 1643735789299, + "version": "4.8" + }, + "pyinstaller-4.8-py39h1ccaba5_0.tar.bz2": { + "build": "py39h1ccaba5_0", + "build_number": 0, + "depends": [ + "altgraph", + "libgcc-ng >=7.5.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.9,<3.10.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "658fcb2a79af66ee13f2933c950f9c49", + "name": "pyinstaller", + "sha256": "f6da1ad570cf42c57c58a925797938afd8c23263d00dc90842b338f15d7a85a9", + "size": 1715045, + "subdir": "linux-64", + "timestamp": 1643735686533, + "version": "4.8" + }, + "pyinstaller-5.6.2-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "altgraph", + "libgcc-ng >=11.2.0", + "pyinstaller-hooks-contrib >=2021.4", + "python >=3.10,<3.11.0a0", + "setuptools >=42.0.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "14c400570a34a5cb7cd00e0ee909e9e7", + "name": "pyinstaller", + "sha256": "781aea99be275d94fe87727c37058690360484d3b6dac1dab914d6720203898f", + "size": 1100446, + "subdir": "linux-64", + "timestamp": 1670881215226, + "version": "5.6.2" + }, + "pyinstaller-5.6.2-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "altgraph", + "libgcc-ng >=11.2.0", + "pyinstaller-hooks-contrib >=2021.4", + "python >=3.11,<3.12.0a0", + "setuptools >=42.0.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "5916d186fd97548d230004afa4ea2f18", + "name": "pyinstaller", + "sha256": "a2e9b72f927f271cd43a4a93a711aff309f9134894aebd06ff20947e97ceb815", + "size": 1321365, + "subdir": "linux-64", + "timestamp": 1676842243683, + "version": "5.6.2" + }, + "pyinstaller-5.6.2-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "altgraph", + "importlib-metadata >=0.8", + "libgcc-ng >=11.2.0", + "pyinstaller-hooks-contrib >=2021.4", + "python >=3.7,<3.8.0a0", + "setuptools >=42.0.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "748e6a0f9ebb2907cfad0934f80ee6f1", + "name": "pyinstaller", + "sha256": "9b762a2d9ec08f555ad9fa05470f4663411e3dcd8fbc9bd59b3ee9bfeecce6e0", + "size": 1113244, + "subdir": "linux-64", + "timestamp": 1670881104102, + "version": "5.6.2" + }, + "pyinstaller-5.6.2-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "altgraph", + "libgcc-ng >=11.2.0", + "pyinstaller-hooks-contrib >=2021.4", + "python >=3.8,<3.9.0a0", + "setuptools >=42.0.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "eea5bd1ff985c91b75afc4ad3e28ea59", + "name": "pyinstaller", + "sha256": "b5ddf0467f446b2add587d75dd79af6b79d98f8e27435baea5febf204b0350ba", + "size": 1102771, + "subdir": "linux-64", + "timestamp": 1670881159577, + "version": "5.6.2" + }, + "pyinstaller-5.6.2-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "altgraph", + "libgcc-ng >=11.2.0", + "pyinstaller-hooks-contrib >=2021.4", + "python >=3.9,<3.10.0a0", + "setuptools >=42.0.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "894e8eeef17961cea6bc596b6f89bfe2", + "name": "pyinstaller", + "sha256": "cc6ce4c47fc8453616e0c34644019dc40c39bdb3362622d3f351a0702dd1ef30", + "size": 1114557, + "subdir": "linux-64", + "timestamp": 1670881270699, + "version": "5.6.2" + }, + "pyinstaller-hooks-contrib-2022.14-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 OR GPL-2.0-or-later", + "license_family": "Other", + "md5": "e8106420aa7c58362ec1650b47390ef0", + "name": "pyinstaller-hooks-contrib", + "sha256": "64d0bdbdad185d208e94627c5593e2791f7a29791a8bb3906beae2a4e1d6064a", + "size": 160422, + "subdir": "linux-64", + "timestamp": 1670877378809, + "version": "2022.14" + }, + "pyinstaller-hooks-contrib-2022.14-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0 OR GPL-2.0-or-later", + "license_family": "Other", + "md5": "2938f4437fafd80c066263ca8eb7c4b2", + "name": "pyinstaller-hooks-contrib", + "sha256": "dcc929cbfa1901b5d9dcde9d83a6885d8ca9c18a3c34742ed56e0d12907146b4", + "size": 180925, + "subdir": "linux-64", + "timestamp": 1676838616985, + "version": "2022.14" + }, + "pyinstaller-hooks-contrib-2022.14-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 OR GPL-2.0-or-later", + "license_family": "Other", + "md5": "76bd71e094af768d2a4e0ab00259a027", + "name": "pyinstaller-hooks-contrib", + "sha256": "c3fbbd13411bfc34b152ac161ca96ca2525981e33fab87b8e3d74ae67c77573c", + "size": 160138, + "subdir": "linux-64", + "timestamp": 1670877444911, + "version": "2022.14" + }, + "pyinstaller-hooks-contrib-2022.14-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 OR GPL-2.0-or-later", + "license_family": "Other", + "md5": "dc73c8a2e6dac826ff6851c8b0197595", + "name": "pyinstaller-hooks-contrib", + "sha256": "b16831ab57b23e971a633771d6aae4b33c2bca0522eb9bcaec2f6fd8e85a686b", + "size": 162464, + "subdir": "linux-64", + "timestamp": 1670877411581, + "version": "2022.14" + }, + "pyinstaller-hooks-contrib-2022.14-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 OR GPL-2.0-or-later", + "license_family": "Other", + "md5": "02daefb7553a9db710813b6acfe8c954", + "name": "pyinstaller-hooks-contrib", + "sha256": "cc6905b02385715eb69204fe7f561c473e67008d9135c68c02fbfac9d1aac874", + "size": 159826, + "subdir": "linux-64", + "timestamp": 1670877345283, + "version": "2022.14" + }, + "pyjsparser-2.7.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f7d890093c8e41c2a0884fac22b43657", + "name": "pyjsparser", + "sha256": "fb8d792b1d163a4de77156d800b3e6bbc9311725a2065a5c0aca4e918d4b7f6d", + "size": 52310, + "subdir": "linux-64", + "timestamp": 1663891697787, + "version": "2.7.1" + }, + "pyjsparser-2.7.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bf75789462265f12f05fd0c830acdcf7", + "name": "pyjsparser", + "sha256": "e2e4f20aa44d31b4b1a5384ca82a4b02ee6ada55e4f84dd4416df4a0221c816e", + "size": 70247, + "subdir": "linux-64", + "timestamp": 1679339576401, + "version": "2.7.1" + }, + "pyjsparser-2.7.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d53ed93355bda17ff89d948c27b2dbc4", + "name": "pyjsparser", + "sha256": "95ffa72908c8a6773703501b525d3a148a7305b47414344f7151e13537de596f", + "size": 51767, + "subdir": "linux-64", + "timestamp": 1663891747107, + "version": "2.7.1" + }, + "pyjsparser-2.7.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "992154b9f04f826ac1b2391316539185", + "name": "pyjsparser", + "sha256": "6b368716b1d4409d59da38739e648360a5afef3a80417a371703427eb1292cb8", + "size": 51874, + "subdir": "linux-64", + "timestamp": 1663891722286, + "version": "2.7.1" + }, + "pyjsparser-2.7.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "271e4b7d61255eda40b65cb1b6824a26", + "name": "pyjsparser", + "sha256": "bb8d46e971981de35890f935267760078c93ee0c14fe7a2d1f32baa6170512c4", + "size": 51833, + "subdir": "linux-64", + "timestamp": 1663891660130, + "version": "2.7.1" + }, + "pyjwt-1.5.2-py27h95ba21f_0.tar.bz2": { + "build": "py27h95ba21f_0", + "build_number": 0, + "depends": [ + "cryptography >=1.0", + "flake8", + "flake8-import-order", + "pep8-naming", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dec405b4b85a40230923884d092a2b10", + "name": "pyjwt", + "sha256": "1f54cab0be8c481c344191f8d8ec6755c00f5465c9b99632c7c1e65e3979b23a", + "size": 28231, + "subdir": "linux-64", + "timestamp": 1505751694920, + "version": "1.5.2" + }, + "pyjwt-1.5.2-py35he0f1d84_0.tar.bz2": { + "build": "py35he0f1d84_0", + "build_number": 0, + "depends": [ + "cryptography >=1.0", + "flake8", + "flake8-import-order", + "pep8-naming", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ddd79ce6899c67245bacbb849b995b2", + "name": "pyjwt", + "sha256": "cb43035d9e1820aabb93d8451c7320785762f0f4c4e8184b31818d482d48d547", + "size": 28945, + "subdir": "linux-64", + "timestamp": 1505751708204, + "version": "1.5.2" + }, + "pyjwt-1.5.2-py36h0aab684_0.tar.bz2": { + "build": "py36h0aab684_0", + "build_number": 0, + "depends": [ + "cryptography >=1.0", + "flake8", + "flake8-import-order", + "pep8-naming", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a50b90f9468c6f38d61a0e87d5b451c7", + "name": "pyjwt", + "sha256": "6173e8340ee4651ff1a782b3ae2d13edb70271800a4376924111aab83cd09f56", + "size": 28738, + "subdir": "linux-64", + "timestamp": 1505751721336, + "version": "1.5.2" + }, + "pyjwt-1.5.3-py27h579140f_0.tar.bz2": { + "build": "py27h579140f_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37e4c2b6ec28d99a662057b0feeaab12", + "name": "pyjwt", + "sha256": "32937e19397780a57df7dc33dd636754838f813775c48c5b35cf06c6622efbd7", + "size": 28446, + "subdir": "linux-64", + "timestamp": 1506866376243, + "version": "1.5.3" + }, + "pyjwt-1.5.3-py35h3a18609_0.tar.bz2": { + "build": "py35h3a18609_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "676c487aed75eaa29a72122982f50a8f", + "name": "pyjwt", + "sha256": "85659c11d6304b8b0393a0d351f7bff595191076e7cad995d54690620358dab1", + "size": 29111, + "subdir": "linux-64", + "timestamp": 1506866352183, + "version": "1.5.3" + }, + "pyjwt-1.5.3-py36h7b51858_0.tar.bz2": { + "build": "py36h7b51858_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ee9f5f89660246156c7bfc44985b678", + "name": "pyjwt", + "sha256": "a20942abbe328626ea9511ff3d3d2f27da446609fa34dad220c956a5d4b1794a", + "size": 28979, + "subdir": "linux-64", + "timestamp": 1506866395193, + "version": "1.5.3" + }, + "pyjwt-1.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "812e2c90502e6d5066962fecc6366d16", + "name": "pyjwt", + "sha256": "c893af55f5f841f0864a7c0fa61174917e2cfab5bbbde003dfdd8510d12a79a6", + "size": 28458, + "subdir": "linux-64", + "timestamp": 1520836872514, + "version": "1.6.0" + }, + "pyjwt-1.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c7f71c0125a9747bcbcb3c1e60c84ac7", + "name": "pyjwt", + "sha256": "0d70531f15b9f1e3414a30441ea776900f3b7f5c7dc2f8aca7466de55537965a", + "size": 29124, + "subdir": "linux-64", + "timestamp": 1520836887530, + "version": "1.6.0" + }, + "pyjwt-1.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be3d1592eaa592848d1d10e9f34c7099", + "name": "pyjwt", + "sha256": "9c5b417f9bdf4a2204c2851b091cd7c5e9e55605e4d8c618649bfb7a1a66bf73", + "size": 29025, + "subdir": "linux-64", + "timestamp": 1520836858463, + "version": "1.6.0" + }, + "pyjwt-1.6.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa174d27ef70552f4a77619829b6f94c", + "name": "pyjwt", + "sha256": "af62a83acbff264e57c6538d6e718a23e127dff444b9109947f532320ba1c0e9", + "size": 28537, + "subdir": "linux-64", + "timestamp": 1522714757846, + "version": "1.6.1" + }, + "pyjwt-1.6.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9cc4fc3a77fbd8e26ff8a545147a454e", + "name": "pyjwt", + "sha256": "cb86de88d578380f135a70d358a483fd92c0736d8a9f50c23c3fdb87f721800d", + "size": 29236, + "subdir": "linux-64", + "timestamp": 1522723142251, + "version": "1.6.1" + }, + "pyjwt-1.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8d650807c79610106266484340012eb", + "name": "pyjwt", + "sha256": "7f9fefdd763a6752734c09b1cd153c9506fda2652ade323a167ffc5eab24de5b", + "size": 29156, + "subdir": "linux-64", + "timestamp": 1522714813172, + "version": "1.6.1" + }, + "pyjwt-1.6.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2fe7f1e06055045f0d52b50efff80961", + "name": "pyjwt", + "sha256": "96b26ad1db82112d85cac8d3a5905a63e16bf2b2876a7937c1719e0052af8198", + "size": 30742, + "subdir": "linux-64", + "timestamp": 1526927868865, + "version": "1.6.3" + }, + "pyjwt-1.6.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8b9491d4f676094eb50d19c47d1203e0", + "name": "pyjwt", + "sha256": "97e46ec089c16e16cb82d14d0391cda341083f80796381a92ef52c1fde56a8e9", + "size": 31422, + "subdir": "linux-64", + "timestamp": 1526927891742, + "version": "1.6.3" + }, + "pyjwt-1.6.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3b414a533dd37c2c355b72db2e4765e", + "name": "pyjwt", + "sha256": "e9f4535f42ced82c2d3dc5fce8b16a5ac70a4d131ce5ad8aa203bd0b479f163b", + "size": 31330, + "subdir": "linux-64", + "timestamp": 1526927848547, + "version": "1.6.3" + }, + "pyjwt-1.6.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bbf6fb26d164c75df8944aa0fa272068", + "name": "pyjwt", + "sha256": "ad601fe4af4bdb84fd9a67bb76ee77ed50411d6054841bdd854480e7c4dc49db", + "size": 30735, + "subdir": "linux-64", + "timestamp": 1527642725964, + "version": "1.6.4" + }, + "pyjwt-1.6.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "539f444e00f0017a19f26ef61d59d0e2", + "name": "pyjwt", + "sha256": "4f5e25aa5460cb15d4fc787b32bd11f1dccb9176a40136623a845c821a048ad1", + "size": 31396, + "subdir": "linux-64", + "timestamp": 1527642743726, + "version": "1.6.4" + }, + "pyjwt-1.6.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7dec0132abddcecae327314be4b93d77", + "name": "pyjwt", + "sha256": "7bf96c837dd54e9d6179866e4a90b90cfa1e2ca2e922842a24806b8ec8738575", + "size": 31320, + "subdir": "linux-64", + "timestamp": 1527642686915, + "version": "1.6.4" + }, + "pyjwt-1.6.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3fc23adea3322f13bc04d7cbe9acb686", + "name": "pyjwt", + "sha256": "e3a0059badc6ec044ee63322b90613d10932dd33781d1807338b09c40688cdb7", + "size": 31376, + "subdir": "linux-64", + "timestamp": 1530917110889, + "version": "1.6.4" + }, + "pyjwt-1.7.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cf6a8624da0eb81ecd83f2f7938ba2bf", + "name": "pyjwt", + "sha256": "3dff7a8bc2cfa5de2b17bdcff2ae031a7f70dbfd2ebf286765ea926eb4ca1f01", + "size": 31816, + "subdir": "linux-64", + "timestamp": 1545102533870, + "version": "1.7.1" + }, + "pyjwt-1.7.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f21cb0f8a5c19f3bbc91ed4146a3b989", + "name": "pyjwt", + "sha256": "cbc46661449dd76aa393f8dbb4d48a0706338d374d76e830a949a2d4c9652bd6", + "size": 32424, + "subdir": "linux-64", + "timestamp": 1545102590602, + "version": "1.7.1" + }, + "pyjwt-1.7.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "210fbfd027993cd26f1e2a6c0735677d", + "name": "pyjwt", + "sha256": "d084e6aade0b021c63645e7e92bda59f8539f6c98a7c379e56220506fa71ea6b", + "size": 32415, + "subdir": "linux-64", + "timestamp": 1545102590311, + "version": "1.7.1" + }, + "pyjwt-1.7.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96f396786fe2b6f377874e34b70c51cc", + "name": "pyjwt", + "sha256": "4b51189cc714fa2278b541780024abf7c1408903239765bb37b94030233e082b", + "size": 32814, + "subdir": "linux-64", + "timestamp": 1574170452617, + "version": "1.7.1" + }, + "pyjwt-2.0.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6,<3.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce17159bd5a6b1a1a0f060418310f8e1", + "name": "pyjwt", + "sha256": "cc617470478fce8c6818bb9524a4a07d7aa49b2a996f3ea95a3669d6c13c6ee8", + "size": 30177, + "subdir": "linux-64", + "timestamp": 1608676281259, + "version": "2.0.0" + }, + "pyjwt-2.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6,<3.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4bdb3cacbf1494d9f6017b34578a61cc", + "name": "pyjwt", + "sha256": "982de15bd8c50509de453f565406b9d9fbc2e8e0b42a69a64d7ae8bdb14a0fd5", + "size": 30247, + "subdir": "linux-64", + "timestamp": 1608676264124, + "version": "2.0.0" + }, + "pyjwt-2.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6,<3.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e6bcd29718cb960127ec19f57230359", + "name": "pyjwt", + "sha256": "7919d05a6f3b05be7a6d2cf4250ab17c2382e27a1522625264180c48f72f8f4e", + "size": 30446, + "subdir": "linux-64", + "timestamp": 1608676277488, + "version": "2.0.0" + }, + "pyjwt-2.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6,<3.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5421608847d183987ccc8823fb5dc01d", + "name": "pyjwt", + "sha256": "7bd898b164a7fa66b85d828b807f2b740d66123316c2b754e7d41d674b83f1b8", + "size": 30419, + "subdir": "linux-64", + "timestamp": 1608676270571, + "version": "2.0.0" + }, + "pyjwt-2.0.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6,<3.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7277938e01c288bb13dcfe1274d76153", + "name": "pyjwt", + "sha256": "1d7985e4d371439fc0f1d483aa8002a4e591dc662f0a02817e49bc8850d55df2", + "size": 30245, + "subdir": "linux-64", + "timestamp": 1610910662777, + "version": "2.0.1" + }, + "pyjwt-2.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6,<3.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2eb7550a472abe5b71f0a4217125be2e", + "name": "pyjwt", + "sha256": "3e79759c85ad1800e8cebeb23101cb8f3fae92cd79f07bc59b22ae197f78cfe1", + "size": 30227, + "subdir": "linux-64", + "timestamp": 1610911346466, + "version": "2.0.1" + }, + "pyjwt-2.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6,<3.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23804b10534ad8b1e929d4946cf96303", + "name": "pyjwt", + "sha256": "f9c0905f826655cf46688be6ceb77a4069cb6b5c11ad203579ee73afc3785313", + "size": 30442, + "subdir": "linux-64", + "timestamp": 1610911342467, + "version": "2.0.1" + }, + "pyjwt-2.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6,<3.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43b50ccf8214006cf6cedb8d943e2036", + "name": "pyjwt", + "sha256": "e2ad67190626a4e43883c2bbccd71bbf056a1c27126c8a9ecb4360d11aff42b2", + "size": 30398, + "subdir": "linux-64", + "timestamp": 1610911346742, + "version": "2.0.1" + }, + "pyjwt-2.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1,<4.0.0" + ], + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d57074a6568ef086c57f069023d35fc2", + "name": "pyjwt", + "sha256": "87b8c30306b6c506ae94382548c12e4d89f06e04b41d64893780ca725614be26", + "size": 32303, + "subdir": "linux-64", + "timestamp": 1640812719524, + "version": "2.1.0" + }, + "pyjwt-2.1.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1,<4.0.0" + ], + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b0551c9f70d9de0ef12f89df8bce0258", + "name": "pyjwt", + "sha256": "2adf0a2df940fee035bf46a89cba981d60530e3fe3a25fb305fd466e70ec78d8", + "size": 31633, + "subdir": "linux-64", + "timestamp": 1619651662286, + "version": "2.1.0" + }, + "pyjwt-2.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1,<4.0.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce6980cc7ff52063750c682f2fcc3a80", + "name": "pyjwt", + "sha256": "128b4f4fc64a964811fbce86d08e271be9075af0c466ae5cf49b07e4a858b90b", + "size": 31682, + "subdir": "linux-64", + "timestamp": 1619651659552, + "version": "2.1.0" + }, + "pyjwt-2.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1,<4.0.0" + ], + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4eb0567ef65a9a649be8b40354d0e498", + "name": "pyjwt", + "sha256": "0f77c39e372fbdc92c1302c3066d0bd21326535f96e7fcfb0cc0733c0e322c59", + "size": 31892, + "subdir": "linux-64", + "timestamp": 1619651677344, + "version": "2.1.0" + }, + "pyjwt-2.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1,<4.0.0" + ], + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e04239f5e2cc50898cb0b361f058214", + "name": "pyjwt", + "sha256": "ff50e2404bc8bd2ce89ed37d1255dcca6887f4df07526643a25d57721385e12e", + "size": 31984, + "subdir": "linux-64", + "timestamp": 1619682520712, + "version": "2.1.0" + }, + "pyjwt-2.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1" + ], + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a83647bccc3898e9e6fab00e23f23b03", + "name": "pyjwt", + "sha256": "0955efd91d2aa931a58a0fb2fab804bc04b7d9fe57c5da2eb27c5e05b196e4ef", + "size": 34757, + "subdir": "linux-64", + "timestamp": 1657544749938, + "version": "2.4.0" + }, + "pyjwt-2.4.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1" + ], + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0641e33d345e560c4ede6e7e8adf6835", + "name": "pyjwt", + "sha256": "70f3f2f64cb1fda9ed6e92c9b913b9c65c846382bf84f12df7c4b54698eec3e4", + "size": 45214, + "subdir": "linux-64", + "timestamp": 1676827398906, + "version": "2.4.0" + }, + "pyjwt-2.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1" + ], + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22291c5c61558dcf5ab48a318c18dc14", + "name": "pyjwt", + "sha256": "fa29c91e37690ce150352a51b3ad70c90d1be402809dfbc2584b0337b318f82e", + "size": 34306, + "subdir": "linux-64", + "timestamp": 1657544710378, + "version": "2.4.0" + }, + "pyjwt-2.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1" + ], + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "052509e5999b19da4d2538a0600b6f49", + "name": "pyjwt", + "sha256": "8e67e94911a782462db3328688c7457aa76dad0aa94f5384332bac14695c8329", + "size": 34561, + "subdir": "linux-64", + "timestamp": 1657544683058, + "version": "2.4.0" + }, + "pyjwt-2.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1" + ], + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bbd93eeef9ba13faa2a656a19ad71428", + "name": "pyjwt", + "sha256": "3a0b81c4571e9aebff1ca4eb4daa4812abf9def7f42ec393022a1c79613e1414", + "size": 34504, + "subdir": "linux-64", + "timestamp": 1657544645989, + "version": "2.4.0" + }, + "pykdtree-1.3.1-py27hdd07704_2.tar.bz2": { + "build": "py27hdd07704_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "md5": "277bdec989842514f307ed54e939fa63", + "name": "pykdtree", + "sha256": "7d0cf7e5bb87ce896528361a1cd6df2325fa2f2c3ad1fc496ab13507f102abfa", + "size": 71117, + "subdir": "linux-64", + "timestamp": 1545159138956, + "version": "1.3.1" + }, + "pykdtree-1.3.1-py36hdd07704_2.tar.bz2": { + "build": "py36hdd07704_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "md5": "c2dc99aef53cdc6df948bea0364aa865", + "name": "pykdtree", + "sha256": "ec1ef471586d8d32ee3832712ae04cd20d43ec3ebbfa0f2ea3479fd31fd7bfe4", + "size": 66449, + "subdir": "linux-64", + "timestamp": 1545159060411, + "version": "1.3.1" + }, + "pykdtree-1.3.1-py37hdd07704_2.tar.bz2": { + "build": "py37hdd07704_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "md5": "4745f5f7d0ce2991c4471655d474bd03", + "name": "pykdtree", + "sha256": "c593443c40d7dd47ef82c9cda11778fbb7e5d3ac4d4f5db824e9b8a824e710d2", + "size": 66195, + "subdir": "linux-64", + "timestamp": 1545159926249, + "version": "1.3.1" + }, + "pykdtree-1.3.1-py38hdd07704_1002.tar.bz2": { + "build": "py38hdd07704_1002", + "build_number": 1002, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0", + "md5": "79ac24d170aa2e6cce30451edabba430", + "name": "pykdtree", + "sha256": "7c841b10e5487ce3e943fdc091a4e22254fde35915d9ad8b3580d98fbd33de01", + "size": 77366, + "subdir": "linux-64", + "timestamp": 1573469878062, + "version": "1.3.1" + }, + "pykdtree-1.3.4-py310h9102076_1002.tar.bz2": { + "build": "py310h9102076_1002", + "build_number": 1002, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0", + "md5": "6a06009981c7d2a58c209859af4657d7", + "name": "pykdtree", + "sha256": "9e2ae9859b56f03ed5694655c2b155f5c961c1a9abd2e5f8e0426ab830d75ad4", + "size": 209942, + "subdir": "linux-64", + "timestamp": 1640793423364, + "version": "1.3.4" + }, + "pykdtree-1.3.4-py36h6323ea4_1002.tar.bz2": { + "build": "py36h6323ea4_1002", + "build_number": 1002, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "md5": "ff118f9ae595dfb861969f2ba8053cf0", + "name": "pykdtree", + "sha256": "09fae23b7abda4e14e279b058743f2913c0ae3c4158b4ffd39bcda5458ffe65b", + "size": 71077, + "subdir": "linux-64", + "timestamp": 1612299341729, + "version": "1.3.4" + }, + "pykdtree-1.3.4-py37h6323ea4_1002.tar.bz2": { + "build": "py37h6323ea4_1002", + "build_number": 1002, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "md5": "7d36ec0ce2db0d4b87b827eb7125d6ef", + "name": "pykdtree", + "sha256": "c2581027af6421651800aea77d39a904a2de1a66b0869d5a2cbf760b3ec4d4ad", + "size": 70379, + "subdir": "linux-64", + "timestamp": 1612298828810, + "version": "1.3.4" + }, + "pykdtree-1.3.4-py38h6323ea4_1002.tar.bz2": { + "build": "py38h6323ea4_1002", + "build_number": 1002, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0", + "md5": "36ddb0df5a56f772f4868f3f163205dc", + "name": "pykdtree", + "sha256": "52fe83d153af4eb964bdb8d49c43652a9620a749d920c229a69db95a842731c0", + "size": 73307, + "subdir": "linux-64", + "timestamp": 1612299363469, + "version": "1.3.4" + }, + "pykdtree-1.3.4-py39h6323ea4_1002.tar.bz2": { + "build": "py39h6323ea4_1002", + "build_number": 1002, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0", + "md5": "696ab3c5a0d076afdfc19c6ea2970087", + "name": "pykdtree", + "sha256": "19ce60efb0e5d4b9a8cc99a8143da8b5974dd26c209703cba6ee27292cc82954", + "size": 71163, + "subdir": "linux-64", + "timestamp": 1612299361438, + "version": "1.3.4" + }, + "pykdtree-1.3.6-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "da6aab9ed515cd60ba93de9868071166", + "name": "pykdtree", + "sha256": "4c071416c461677a72e8690111d4de2275633ec01924ed2a67274edfc55f9c35", + "size": 72171, + "subdir": "linux-64", + "timestamp": 1676300839216, + "version": "1.3.6" + }, + "pykdtree-1.3.6-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "libgcc-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "1ce3a9421bcd70f970767a4a3a68d90c", + "name": "pykdtree", + "sha256": "f607909885e23ba3b022dadaffb53ec15deaf204f9665e68e7092532cd5cda91", + "size": 74213, + "subdir": "linux-64", + "timestamp": 1676860890675, + "version": "1.3.6" + }, + "pykdtree-1.3.6-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "libgcc-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "cdc616245306cded3dd316dda8edc3d2", + "name": "pykdtree", + "sha256": "83b29719c5047f1715db4b8d668416037d5c6d1cac565bb4f07d74e7b0453ee7", + "size": 73408, + "subdir": "linux-64", + "timestamp": 1676300722726, + "version": "1.3.6" + }, + "pykdtree-1.3.6-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "libgcc-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "6e5dedfab1efe83b73b0d5383894bfb6", + "name": "pykdtree", + "sha256": "5decc6e13c91ac9a23a29e06cc4e34c8db8bab179b7ce83f9b48edf8e0097cb0", + "size": 75814, + "subdir": "linux-64", + "timestamp": 1676300800300, + "version": "1.3.6" + }, + "pykdtree-1.3.6-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "libgcc-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "bfd9d79e5487b1e5c826986e1bc1e728", + "name": "pykdtree", + "sha256": "edb92482b3dec01667ff9a8bc10fe38c81423f9aaf574e3154a6334d362f0390", + "size": 73177, + "subdir": "linux-64", + "timestamp": 1676300761443, + "version": "1.3.6" + }, + "pykerberos-1.1.14-py27h2de3caf_2.tar.bz2": { + "build": "py27h2de3caf_2", + "build_number": 2, + "depends": [ + "krb5", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache", + "md5": "51a514fe6b06bb31d9c4e57f15f1caba", + "name": "pykerberos", + "sha256": "6463ac11fb82df72d70257a7003c2876d16f0c6348e39efcbad57da382e39434", + "size": 22048, + "subdir": "linux-64", + "timestamp": 1505851501450, + "version": "1.1.14" + }, + "pykerberos-1.1.14-py35h589a6a4_2.tar.bz2": { + "build": "py35h589a6a4_2", + "build_number": 2, + "depends": [ + "krb5", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache", + "md5": "bc392778f9bbd744ec7ad9b924b2ee9b", + "name": "pykerberos", + "sha256": "a241bbd512dc6440f91b324f55784626328017054177111cc63dc2370166f8f7", + "size": 22191, + "subdir": "linux-64", + "timestamp": 1505851515587, + "version": "1.1.14" + }, + "pykerberos-1.1.14-py36h84109d8_2.tar.bz2": { + "build": "py36h84109d8_2", + "build_number": 2, + "depends": [ + "krb5", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache", + "md5": "03879afd265d53a0a69c856871e0e8dd", + "name": "pykerberos", + "sha256": "c75b12373f0da4f702a6252db6b974a9db1f5f77c9917e279a533f267e19b46c", + "size": 22184, + "subdir": "linux-64", + "timestamp": 1505851529775, + "version": "1.1.14" + }, + "pykerberos-1.2.1-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "krb5", + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache", + "md5": "8686e64ba6e3f90557aa61cd220ec44f", + "name": "pykerberos", + "sha256": "ae2f37ce3d0398a798e56620c4281dffac56a76c94043c6e1c62c9d70ee9a7cf", + "size": 25064, + "subdir": "linux-64", + "timestamp": 1519491544901, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py310h7f8727e_3.tar.bz2": { + "build": "py310h7f8727e_3", + "build_number": 3, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "42e5dfa6b6b58b278defff0ecbe423b9", + "name": "pykerberos", + "sha256": "5b0aa9a7d65c4108d74f45ab267d5052fa42ca47546a2f3ed63ee4b77f707635", + "size": 72120, + "subdir": "linux-64", + "timestamp": 1640793448595, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py311h5eee18b_3.tar.bz2": { + "build": "py311h5eee18b_3", + "build_number": 3, + "depends": [ + "krb5 >=1.19.4,<1.20.0a0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e13e33c597c933e67e25f0e787e49e6b", + "name": "pykerberos", + "sha256": "b10de6c6a7dc1ddb5baae3068e5a738214099682fa7f5c4d1a9fac4642b56d7d", + "size": 25765, + "subdir": "linux-64", + "timestamp": 1676838635814, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "krb5", + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache", + "md5": "223d7e9e96427e10698c3bb7f4cf0e6c", + "name": "pykerberos", + "sha256": "16df90fead73e8bb1f7094b6ee23194c85824d1e7ba82b59db0fdd6c84631d2f", + "size": 25183, + "subdir": "linux-64", + "timestamp": 1519491558272, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "krb5", + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache", + "md5": "8c86791617122b41de6934f1a851b9fb", + "name": "pykerberos", + "sha256": "0cd1ba5cf6645d47d53d3e961a8c67a420f915addaea070e62788d8520e6c5f7", + "size": 25132, + "subdir": "linux-64", + "timestamp": 1519491543474, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py36h27cfd23_2.tar.bz2": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache", + "md5": "d5528dd6bfc6d5e90a957814bae841c8", + "name": "pykerberos", + "sha256": "b0ca63a6c1597b26fca5305c74e2820683942c00e5275b78173a51295fb67ae9", + "size": 242548, + "subdir": "linux-64", + "timestamp": 1613408386672, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py36h680d80a_2.tar.bz2": { + "build": "py36h680d80a_2", + "build_number": 2, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache", + "md5": "b3dddb52dbc69b80ecef7fc51eb0a948", + "name": "pykerberos", + "sha256": "2ab7ef83f2eb2178d462bb0d9cde8c318cbdc10fac9e3265ec8e503c67d3e840", + "size": 197948, + "subdir": "linux-64", + "timestamp": 1594997421098, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py36ha6b2b2b_1.tar.bz2": { + "build": "py36ha6b2b2b_1", + "build_number": 1, + "depends": [ + "krb5 >=1.17.1,<1.18.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache", + "md5": "ca5bf048c250d89e98a5f5ea0335728d", + "name": "pykerberos", + "sha256": "05e249a115e0a062a25c810f5d9b3e3faf9ceb3c00db2e0474f5af8ff33baa2e", + "size": 197938, + "subdir": "linux-64", + "timestamp": 1595000249188, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache", + "md5": "1e55948353f3486fa1d8b5892a0ddb30", + "name": "pykerberos", + "sha256": "bbdf5c2a0e4deb60999e69aa9ae3e3059dad6a3164df48ca3ac680407f4cb718", + "size": 25114, + "subdir": "linux-64", + "timestamp": 1530917144269, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py37h27cfd23_2.tar.bz2": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache", + "md5": "a84f971121e4081565dae6de850b74f8", + "name": "pykerberos", + "sha256": "9ec0de429d8ce8ba6beb54c2ec52510dd9ca4f72e552c1f22725478ebd8dcc83", + "size": 243930, + "subdir": "linux-64", + "timestamp": 1613408374671, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py37h680d80a_2.tar.bz2": { + "build": "py37h680d80a_2", + "build_number": 2, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache", + "md5": "b1bed4514e4822cb5bc0fe9dbc1acf68", + "name": "pykerberos", + "sha256": "a7ec5dfb485fea33fc88082152621431e921c491f3df617e8380840b1d12c1dd", + "size": 197913, + "subdir": "linux-64", + "timestamp": 1595000390949, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py37h7f8727e_3.tar.bz2": { + "build": "py37h7f8727e_3", + "build_number": 3, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a0846e6d171ad1c46341ad5a43a794ad", + "name": "pykerberos", + "sha256": "b45f89389449a6b1e3ee2ff091b1db60f50e866283819bff9fb48722001f90fb", + "size": 28203, + "subdir": "linux-64", + "timestamp": 1634868615941, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py37ha6b2b2b_1.tar.bz2": { + "build": "py37ha6b2b2b_1", + "build_number": 1, + "depends": [ + "krb5 >=1.17.1,<1.18.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache", + "md5": "8d3a8807a9ccf4f43819716f2cbfb424", + "name": "pykerberos", + "sha256": "f4475aefc30dbc4380ad9ba8dcf44d1bb7bdf0f8d5613f65e2c9ed5937b0e43e", + "size": 197956, + "subdir": "linux-64", + "timestamp": 1595000249296, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py38h27cfd23_2.tar.bz2": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache", + "md5": "ff6fd98786c4c37fb2f7405ba02661b5", + "name": "pykerberos", + "sha256": "4a0a200f0739ada09680e3605bd29caad238a50f2c6515a8e6f82f86d96ec40b", + "size": 243845, + "subdir": "linux-64", + "timestamp": 1613407791392, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py38h680d80a_2.tar.bz2": { + "build": "py38h680d80a_2", + "build_number": 2, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache", + "md5": "21a9a30d69bbc27ceb84cd8b1710ab6f", + "name": "pykerberos", + "sha256": "8c3ea9e6d54664244d7cdc85bf8e9b84cf6c0a819e739215f6e054036342c8a3", + "size": 197911, + "subdir": "linux-64", + "timestamp": 1595000777311, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache", + "md5": "14bf0107ca75b4feb0ad79b21356f7ce", + "name": "pykerberos", + "sha256": "5475acc86bc550555e8a44c39725a623b41281d180971ae636c7c39b7da741f8", + "size": 32692, + "subdir": "linux-64", + "timestamp": 1573670007122, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py38h7f8727e_3.tar.bz2": { + "build": "py38h7f8727e_3", + "build_number": 3, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "33ecc48d80591a3bfaa1ea43f584848a", + "name": "pykerberos", + "sha256": "895a0f8e87af18a71f2c9f6dd83510da4319bc60dfbabc58c328ebcc2aeffc16", + "size": 28242, + "subdir": "linux-64", + "timestamp": 1634880050512, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py38ha6b2b2b_1.tar.bz2": { + "build": "py38ha6b2b2b_1", + "build_number": 1, + "depends": [ + "krb5 >=1.17.1,<1.18.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache", + "md5": "128a2098bc52295c2d9addbd24d747fb", + "name": "pykerberos", + "sha256": "c5d997b3b4dd6d63d6969256dbf560f03ce71c48ef6a6ecf185145f107cce85c", + "size": 197929, + "subdir": "linux-64", + "timestamp": 1594996891602, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py39h27cfd23_2.tar.bz2": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache", + "md5": "ff80692ba8e509975697c86fc6198d32", + "name": "pykerberos", + "sha256": "4b6c19be94ee553e795207e2b6c502b4da5e2cd047fabe01b5e71de82b619d26", + "size": 25715, + "subdir": "linux-64", + "timestamp": 1607007559788, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py39h7f8727e_3.tar.bz2": { + "build": "py39h7f8727e_3", + "build_number": 3, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5fe019db7046e5af77001c6cd2745f54", + "name": "pykerberos", + "sha256": "09f51c9d4d4c4692d964645c44e52f67fcd312091034eb5950eaea0ca6bcfe3c", + "size": 28229, + "subdir": "linux-64", + "timestamp": 1634880044425, + "version": "1.2.1" + }, + "pylint-1.7.2-py27h77e98c6_0.tar.bz2": { + "build": "py27h77e98c6_0", + "build_number": 0, + "depends": [ + "astroid >=1.5.1", + "backports.functools_lru_cache", + "configparser", + "isort >=4.2.5", + "mccabe", + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "GPL", + "md5": "39fd487616f6599ef7fb7791ffe92c83", + "name": "pylint", + "sha256": "8133c2d2d29e51d3bf24a32e5d436fe91258fce0be6a60fc1a59f2842619012c", + "size": 692719, + "subdir": "linux-64", + "timestamp": 1505751756145, + "version": "1.7.2" + }, + "pylint-1.7.2-py35hc802fb1_0.tar.bz2": { + "build": "py35hc802fb1_0", + "build_number": 0, + "depends": [ + "astroid >=1.5.1", + "isort >=4.2.5", + "mccabe", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "GPL", + "md5": "a02875a13b27bd9b92b6c9c5e35b80c8", + "name": "pylint", + "sha256": "0f15b8c40199e79044655fbbe35952ae225e3f0d5cc257f7c0cc181b94ea5871", + "size": 710378, + "subdir": "linux-64", + "timestamp": 1505751808379, + "version": "1.7.2" + }, + "pylint-1.7.2-py36h484ab97_0.tar.bz2": { + "build": "py36h484ab97_0", + "build_number": 0, + "depends": [ + "astroid >=1.5.1", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "GPL", + "md5": "d2f2797afe7afd6e5ceb084c4744cb05", + "name": "pylint", + "sha256": "72f5265a5de3e8706ade08fcfee4101a0e74abbe21f47369bf6aef145e2b2830", + "size": 707008, + "subdir": "linux-64", + "timestamp": 1505751861090, + "version": "1.7.2" + }, + "pylint-1.7.4-py27h6bc7935_0.tar.bz2": { + "build": "py27h6bc7935_0", + "build_number": 0, + "depends": [ + "astroid >=1.5.1", + "backports.functools_lru_cache", + "configparser", + "isort >=4.2.5", + "mccabe", + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "GPL", + "md5": "d7feea578d74993da70787303f2c5793", + "name": "pylint", + "sha256": "4278c71fba9867c5c555efbedcf478eb21741c0d2bd4cc9998a9b97b86d143ac", + "size": 691490, + "subdir": "linux-64", + "timestamp": 1507663897432, + "version": "1.7.4" + }, + "pylint-1.7.4-py35h319e60b_0.tar.bz2": { + "build": "py35h319e60b_0", + "build_number": 0, + "depends": [ + "astroid >=1.5.1", + "isort >=4.2.5", + "mccabe", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "GPL", + "md5": "b186c67be16070f6828d9c3b51b055c8", + "name": "pylint", + "sha256": "9139ec937c3ea68a2783610a65a85aa5bac4857c83334359f25347281133696e", + "size": 707965, + "subdir": "linux-64", + "timestamp": 1507663919382, + "version": "1.7.4" + }, + "pylint-1.7.4-py36hb9d4533_0.tar.bz2": { + "build": "py36hb9d4533_0", + "build_number": 0, + "depends": [ + "astroid >=1.5.1", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "GPL", + "md5": "929881c393c7bf01be60d25f7b01b01b", + "name": "pylint", + "sha256": "731cc55d6277c88af4f94969a20ec85564d5061004e209f37b860c2f98fe9588", + "size": 706238, + "subdir": "linux-64", + "timestamp": 1507663921338, + "version": "1.7.4" + }, + "pylint-1.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astroid >=1.5.1", + "backports.functools_lru_cache", + "configparser", + "isort >=4.2.5", + "mccabe", + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "GPL", + "md5": "86ae691859da772b190d1b707227c0f7", + "name": "pylint", + "sha256": "8ab05e8cda01945263fb3694b73d4b70231a6be2faa42c5d6974fab173b05ec1", + "size": 738149, + "subdir": "linux-64", + "timestamp": 1515723916529, + "version": "1.8.1" + }, + "pylint-1.8.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astroid >=1.5.1", + "isort >=4.2.5", + "mccabe", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "GPL", + "md5": "92c66bd6ea4eae40ed1448132f1e32ac", + "name": "pylint", + "sha256": "88e274268ae0411b4fe0dcd74b1024054c4c698770eae67737cd4db698f738f4", + "size": 760606, + "subdir": "linux-64", + "timestamp": 1515723971117, + "version": "1.8.1" + }, + "pylint-1.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=1.5.1", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "GPL", + "md5": "550743f8414e4376582c8c9f19eee29c", + "name": "pylint", + "sha256": "4f3051dbbfa94cd8c7e819b9088c948d37facf8d4fa9e2afb7edbbb403f92019", + "size": 762607, + "subdir": "linux-64", + "timestamp": 1515723848359, + "version": "1.8.1" + }, + "pylint-1.8.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "backports.functools_lru_cache", + "configparser", + "isort >=4.2.5", + "mccabe", + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "GPL", + "md5": "5d9337d2925771f3281adebde16b5695", + "name": "pylint", + "sha256": "30107be15ea8bcde918c61327f382631e6c570da4fda4b008ef6a0902c5237f5", + "size": 740114, + "subdir": "linux-64", + "timestamp": 1517330103090, + "version": "1.8.2" + }, + "pylint-1.8.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "GPL", + "md5": "12b81024397d9eb3c105a01891f176a4", + "name": "pylint", + "sha256": "8ce7300a1d401a3d94304dec98c24a002b9692664353b59a557705ba090ca672", + "size": 761410, + "subdir": "linux-64", + "timestamp": 1517330169459, + "version": "1.8.2" + }, + "pylint-1.8.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "GPL", + "md5": "6409047b9210e29b6008182500318622", + "name": "pylint", + "sha256": "269deb1413b4a9232d495b029f653b1828fe88d7525bb4104f0f083654657de8", + "size": 764538, + "subdir": "linux-64", + "timestamp": 1517330143745, + "version": "1.8.2" + }, + "pylint-1.8.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "backports.functools_lru_cache", + "configparser", + "isort >=4.2.5", + "mccabe", + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "GPL", + "md5": "72e0303ab512fc80f6088cb475d3a8f5", + "name": "pylint", + "sha256": "ca43f41854f942565ff7b2d4688b440641e3801eee2b84d756430ca50472857a", + "size": 741226, + "subdir": "linux-64", + "timestamp": 1521493909572, + "version": "1.8.3" + }, + "pylint-1.8.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "GPL", + "md5": "c538e96219fbf7579aa8fc418b5f5fde", + "name": "pylint", + "sha256": "f68c220e5532e4685c784b61eb0be281b63a2a34eb15c57127686f4ede9ccb0a", + "size": 763542, + "subdir": "linux-64", + "timestamp": 1521493932816, + "version": "1.8.3" + }, + "pylint-1.8.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "GPL", + "md5": "154d3e89b7883d29fa0d42ba983a3b2b", + "name": "pylint", + "sha256": "f964f986710c231e8f9bf661b20d32e56eebcc7d13c40b2ffd78a507b3703589", + "size": 766930, + "subdir": "linux-64", + "timestamp": 1521493865068, + "version": "1.8.3" + }, + "pylint-1.8.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "backports.functools_lru_cache", + "configparser", + "isort >=4.2.5", + "mccabe", + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "GPL", + "md5": "2dd96e112e2f46d46a0cd4f440571acd", + "name": "pylint", + "sha256": "ac55195b4700d3c6998b33bef6a1424a30d03ecb6078990def5b0767451df2e3", + "size": 742342, + "subdir": "linux-64", + "timestamp": 1523130513382, + "version": "1.8.4" + }, + "pylint-1.8.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "GPL", + "md5": "30fcf09486003a047f048e2845bdf20c", + "name": "pylint", + "sha256": "82e583e7d4740743ea618fcb45e6da9862b82c2dbdeb398da504eb8ea5862fe7", + "size": 765441, + "subdir": "linux-64", + "timestamp": 1523130537727, + "version": "1.8.4" + }, + "pylint-1.8.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "GPL", + "md5": "16bd9b18ee303c8d9f49afa6fa8de5dc", + "name": "pylint", + "sha256": "6c700420fde05e72d327a52664704436d88201a55301c69b38a9850ed03082ff", + "size": 766268, + "subdir": "linux-64", + "timestamp": 1523130537502, + "version": "1.8.4" + }, + "pylint-1.9.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "backports.functools_lru_cache", + "configparser", + "isort >=4.2.5", + "mccabe", + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "GPL", + "md5": "3b0ef1187a39e04bc40921bc9d3cd802", + "name": "pylint", + "sha256": "7026802621d1386f76e878a8a58dcbe0f49e9461eba38033a31ee2114dac4a64", + "size": 790499, + "subdir": "linux-64", + "timestamp": 1527828666463, + "version": "1.9.1" + }, + "pylint-1.9.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "GPL", + "md5": "bb1b266dd0d652dce962867888cd2b6d", + "name": "pylint", + "sha256": "204c9964851a1c6787eeac890eb61eb752c687a60fa88eaf65e3a5be424c51cc", + "size": 807353, + "subdir": "linux-64", + "timestamp": 1527828748833, + "version": "1.9.1" + }, + "pylint-1.9.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "GPL", + "md5": "af79053b8bd7b0dc760324f3a878cc49", + "name": "pylint", + "sha256": "d857ae08c7f0bf5d57be468d10d36b6456667aec70310f70b8849494ba8eff26", + "size": 810534, + "subdir": "linux-64", + "timestamp": 1527828712319, + "version": "1.9.1" + }, + "pylint-1.9.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "backports.functools_lru_cache", + "configparser", + "isort >=4.2.5", + "mccabe", + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "GPL", + "md5": "60b90c68e1a2b43eb007f3db6d9bb0a7", + "name": "pylint", + "sha256": "8dd3546d73edacbd177a68e561b8d532f4a464a002b1bb1a4cade3b2f4fc2c84", + "size": 790372, + "subdir": "linux-64", + "timestamp": 1528899388109, + "version": "1.9.2" + }, + "pylint-1.9.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "GPL", + "md5": "7c18e29e7e3b042c763346804eb822c5", + "name": "pylint", + "sha256": "e21e9cb80c7e788c0ec180c8bffb93907f82e2ad329972fbd33d29ce325cc389", + "size": 808397, + "subdir": "linux-64", + "timestamp": 1528899766814, + "version": "1.9.2" + }, + "pylint-1.9.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "GPL", + "md5": "9d507a69fe6f6dd650198aac53526007", + "name": "pylint", + "sha256": "e3ee2f5321a81e8767e9b764b0893565b78dfc9937d4d37fc65a11277171033b", + "size": 811385, + "subdir": "linux-64", + "timestamp": 1528899663538, + "version": "1.9.2" + }, + "pylint-1.9.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "GPL", + "md5": "1cc54e4c53e7ba419b20655b5a85285f", + "name": "pylint", + "sha256": "8f5d93a1b85517d17542509051242505bbfbedde2faed26cb2195f38a97d3491", + "size": 795008, + "subdir": "linux-64", + "timestamp": 1530917214191, + "version": "1.9.2" + }, + "pylint-2.1.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astroid >=2.0.0", + "isort >=4.2.5", + "mccabe", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL", + "md5": "864816867700be9fe9aba96a1fe3dfbb", + "name": "pylint", + "sha256": "d67821f711b35c12aa1ee17d561edc5224b75b6e78fffe98f2385387f65fcfc0", + "size": 819005, + "subdir": "linux-64", + "timestamp": 1533749855454, + "version": "2.1.1" + }, + "pylint-2.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.0.0", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL", + "md5": "60e344cee3a20c5d6e2086cdfe5705b5", + "name": "pylint", + "sha256": "54d75c76bbc818db0c5ae58249c3cd89ac7909402c95011d9eff954015c5b72c", + "size": 813807, + "subdir": "linux-64", + "timestamp": 1533749781258, + "version": "2.1.1" + }, + "pylint-2.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.0.0", + "isort >=4.2.5", + "mccabe", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL", + "md5": "bf85e5643d0dc6374ece20fa259762cc", + "name": "pylint", + "sha256": "2b8befeefb7d8d0bb5ff05d0d8d0ddc9b36d0e02569259c9253d2863e318cfa3", + "size": 809229, + "subdir": "linux-64", + "timestamp": 1533749926549, + "version": "2.1.1" + }, + "pylint-2.12.2-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.9.0,<2.10", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.10,<3.11.0a0", + "toml >=0.9.2", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "c4daa937f8c43e135978e7e29a94dc4e", + "name": "pylint", + "sha256": "bb41c06aacf65ebfee421dfc58b352a80eb4fe3ea0f538ae8c580ccf8bec7273", + "size": 591031, + "subdir": "linux-64", + "timestamp": 1647959929255, + "version": "2.12.2" + }, + "pylint-2.12.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.9.0,<2.10", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "platformdirs >=2.2.0", + "python >=3.7,<3.8.0a0", + "toml >=0.9.2", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "b2602e5e0fc431ba849c4a7a4027a67a", + "name": "pylint", + "sha256": "8e02e1722b09b84aa12602cf68851c4bcf18ab0c3efadbbbea0b639ae0301b38", + "size": 586951, + "subdir": "linux-64", + "timestamp": 1639632506335, + "version": "2.12.2" + }, + "pylint-2.12.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.9.0,<2.10", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.7,<3.8.0a0", + "toml >=0.9.2", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "7dd29e804fe82c450a3eb8311485939b", + "name": "pylint", + "sha256": "17edb84d202c58ae7344752df531e370247a29d424fa3913a80770f47817a78f", + "size": 581515, + "subdir": "linux-64", + "timestamp": 1647942053245, + "version": "2.12.2" + }, + "pylint-2.12.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.9.0,<2.10", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "platformdirs >=2.2.0", + "python >=3.8,<3.9.0a0", + "toml >=0.9.2", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "d543f03f59aadce0d9fd14dee68dedc5", + "name": "pylint", + "sha256": "0cb67ce866f2363c81f071f2453538c434112deb3b563426b661c91d066bde2a", + "size": 582090, + "subdir": "linux-64", + "timestamp": 1639650628766, + "version": "2.12.2" + }, + "pylint-2.12.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.9.0,<2.10", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.8,<3.9.0a0", + "toml >=0.9.2", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "4afbb7b41aa2faaec6babf263ade800d", + "name": "pylint", + "sha256": "bc08a700d77e3f4764bf4f538c190995db6980df14014aada8187afe85eb1eea", + "size": 586299, + "subdir": "linux-64", + "timestamp": 1647941783970, + "version": "2.12.2" + }, + "pylint-2.12.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.9.0,<2.10", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "platformdirs >=2.2.0", + "python >=3.9,<3.10.0a0", + "toml >=0.9.2", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "7d174d269afad48876c4ef6889663649", + "name": "pylint", + "sha256": "697e38fc224413b637861f6ade7fe13ebeeb3690be3ea8ebce344050b703771d", + "size": 586161, + "subdir": "linux-64", + "timestamp": 1639650625612, + "version": "2.12.2" + }, + "pylint-2.12.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.9.0,<2.10", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.9,<3.10.0a0", + "toml >=0.9.2", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "51c5c62a3143472ae860527eee60ae80", + "name": "pylint", + "sha256": "6d90bc6e3b942fd638d303b82e67231eabeffe5d789e991ffc43330e0ba0f7d6", + "size": 586309, + "subdir": "linux-64", + "timestamp": 1647941882980, + "version": "2.12.2" + }, + "pylint-2.14.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.11.6,<2.12.0", + "dill >=0.2", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.10,<3.11.0a0", + "tomli >=1.1.0", + "tomlkit >=0.10.1", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "ff331d95cb944af73e27c71ef67847d9", + "name": "pylint", + "sha256": "05e0ffeaac414f42975bb5a596c54054370b9aeefb2eda3bd2be5fd2ba76d6e2", + "size": 694716, + "subdir": "linux-64", + "timestamp": 1659110529816, + "version": "2.14.5" + }, + "pylint-2.14.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.11.6,<2.12.0", + "dill >=0.2", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.7,<3.8.0a0", + "tomli >=1.1.0", + "tomlkit >=0.10.1", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "db6c17729046ba1060acba03d884dc38", + "name": "pylint", + "sha256": "9057a967fed5dc16b644e44b7a92ae9e75fba16279ab2ee60abfacea76e02834", + "size": 686744, + "subdir": "linux-64", + "timestamp": 1659110436108, + "version": "2.14.5" + }, + "pylint-2.14.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.11.6,<2.12.0", + "dill >=0.2", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.8,<3.9.0a0", + "tomli >=1.1.0", + "tomlkit >=0.10.1", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "6b5ed65f3b30c425f95a7f1f40a2526c", + "name": "pylint", + "sha256": "da3fde01519ab2395f65c4aa91156eefef82bc2bd39710eb82a4345c7069ac84", + "size": 685357, + "subdir": "linux-64", + "timestamp": 1659110476157, + "version": "2.14.5" + }, + "pylint-2.14.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.11.6,<2.12.0", + "dill >=0.2", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.9,<3.10.0a0", + "tomli >=1.1.0", + "tomlkit >=0.10.1", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "e765b902c6f2b3b369719f5ecf5e6aa0", + "name": "pylint", + "sha256": "559297ebb07ad5a8548e3d1b479b29e817840c077cec3ec66163b26832c43559", + "size": 685105, + "subdir": "linux-64", + "timestamp": 1659110390260, + "version": "2.14.5" + }, + "pylint-2.16.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.14.2,<=2.16.0", + "colorama >=0.4.5", + "dill >=0.2", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.10,<3.11.0a0", + "tomli >=1.1.0", + "tomlkit >=0.10.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "e0a8d4edd2aa54458b92370e030a9276", + "name": "pylint", + "sha256": "7a50222b2aec959c241e66e4490f67dd23c6ea84be6d78f584da1c7b0d2d3abe", + "size": 752943, + "subdir": "linux-64", + "timestamp": 1676919962719, + "version": "2.16.2" + }, + "pylint-2.16.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.14.2,<=2.16.0", + "colorama >=0.4.5", + "dill >=0.3.6", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.11,<3.12.0a0", + "tomlkit >=0.10.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "4c0bd7015e33dec5e2ce2a5a02825635", + "name": "pylint", + "sha256": "2fba9825728b080b3124f1a2f34da44d0ffd82c9f91a0bd26344b93e406ecadd", + "size": 973089, + "subdir": "linux-64", + "timestamp": 1676921014466, + "version": "2.16.2" + }, + "pylint-2.16.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.14.2,<=2.16.0", + "colorama >=0.4.5", + "dill >=0.2", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.7,<3.8.0a0", + "tomli >=1.1.0", + "tomlkit >=0.10.1", + "typing_extensions >=3.10.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "ba58e04c3e71f2f6ef8b7ab8c9c1be26", + "name": "pylint", + "sha256": "3859d663f60d9b83514e0637d2dfabea057a815f756dc2bce69f592106291444", + "size": 736506, + "subdir": "linux-64", + "timestamp": 1676919929651, + "version": "2.16.2" + }, + "pylint-2.16.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.14.2,<=2.16.0", + "colorama >=0.4.5", + "dill >=0.2", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.8,<3.9.0a0", + "tomli >=1.1.0", + "tomlkit >=0.10.1", + "typing_extensions >=3.10.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "b5247750aaf84cc318f1a9ef5d990240", + "name": "pylint", + "sha256": "6441c0af5c18fe42898836881d28637d37f680ff59e1b799215791f5a4038a09", + "size": 742261, + "subdir": "linux-64", + "timestamp": 1676919995638, + "version": "2.16.2" + }, + "pylint-2.16.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.14.2,<=2.16.0", + "colorama >=0.4.5", + "dill >=0.2", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.9,<3.10.0a0", + "tomli >=1.1.0", + "tomlkit >=0.10.1", + "typing_extensions >=3.10.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "b1d0b1369a72a1e509f4ec32204ef73c", + "name": "pylint", + "sha256": "90b20f58e6698c7650b2e56a3cc3ffccd413802861737b9229bcb958c05ccccb", + "size": 740322, + "subdir": "linux-64", + "timestamp": 1676920028979, + "version": "2.16.2" + }, + "pylint-2.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.0.0", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL", + "md5": "2890cd89d1ef1a9d873e93486234dc83", + "name": "pylint", + "sha256": "93d1e7cb21cc23fbdf75d976281cca7e25e64f64db32c17d2ae0cd365f3edfc8", + "size": 848215, + "subdir": "linux-64", + "timestamp": 1543609106263, + "version": "2.2.2" + }, + "pylint-2.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.0.0", + "isort >=4.2.5", + "mccabe", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL", + "md5": "8ffbbbc9c619c1abc63ecc714745f310", + "name": "pylint", + "sha256": "70e2f1937c140ff57d14cf39038f783380a4c9e115f1434e30e743c59f3994c6", + "size": 830167, + "subdir": "linux-64", + "timestamp": 1543609087125, + "version": "2.2.2" + }, + "pylint-2.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL", + "md5": "a010f0aed08a1ed8d345bc6ebd64e20b", + "name": "pylint", + "sha256": "9022d1b0dbe0efd06f8c5e484b87b9538e571f8c360fd2c3c7b8f84e38fadbc1", + "size": 844320, + "subdir": "linux-64", + "timestamp": 1552332067523, + "version": "2.3.1" + }, + "pylint-2.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL", + "md5": "eb2b3ac915aed22acb553feab06dace8", + "name": "pylint", + "sha256": "4a89fa6721108b2e728574301bb6fef5a40df3ccb05d6f117fdf8fd4390871de", + "size": 848846, + "subdir": "linux-64", + "timestamp": 1552331990252, + "version": "2.3.1" + }, + "pylint-2.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.3.0,<2.4", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2", + "md5": "270bcd683a84b7500d99a3cdaa4b704e", + "name": "pylint", + "sha256": "d2bd3e592b7af1bbf57a51d31b72ecd10ecead83b02930f0bb30367bacb56b69", + "size": 441183, + "subdir": "linux-64", + "timestamp": 1569854754247, + "version": "2.4.2" + }, + "pylint-2.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.3.0,<2.4", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL 2", + "md5": "0bc3a152deacef64f7a74ce8ab970822", + "name": "pylint", + "sha256": "2e2015880e86b52b34037af3b14ac3bf4f7efc0df3922497efc5af32d0b2d5bd", + "size": 439382, + "subdir": "linux-64", + "timestamp": 1569854782103, + "version": "2.4.2" + }, + "pylint-2.4.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.3.0,<2.4", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2", + "md5": "99473fc21f0feb0b567a92fd0a2be91e", + "name": "pylint", + "sha256": "0cb23638842e4e13bf8793b1f5f9a62737cdca31ee3d8b3247eb8f6813c39a88", + "size": 442767, + "subdir": "linux-64", + "timestamp": 1571761133950, + "version": "2.4.3" + }, + "pylint-2.4.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.3.0,<2.4", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL 2", + "md5": "f83d13a2b7bf7de50add0b72f9c16c60", + "name": "pylint", + "sha256": "22af134167e239956673a606ef1eafadbb160a000f2174c91fe64391de79c920", + "size": 436016, + "subdir": "linux-64", + "timestamp": 1571761125724, + "version": "2.4.3" + }, + "pylint-2.4.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.3.0,<2.4", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2", + "md5": "ad4fe4f85089f8c2251db9ee93cfbef0", + "name": "pylint", + "sha256": "418cd348abef8c432efb73e50028541dfce9c01870e8862ce04b5cb412129718", + "size": 444104, + "subdir": "linux-64", + "timestamp": 1573939943157, + "version": "2.4.4" + }, + "pylint-2.4.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.3.0,<2.4", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL 2", + "md5": "340143207c4204fb051d5974d05b1a0c", + "name": "pylint", + "sha256": "50fd619e360aab6e9a1355897cb3c16d85b9a8bd2b545a872c250cf347db731e", + "size": 441968, + "subdir": "linux-64", + "timestamp": 1573939898588, + "version": "2.4.4" + }, + "pylint-2.4.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "astroid >=2.3.0,<2.4", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL 2", + "md5": "7ca92408c10881d92ab126109cfe989f", + "name": "pylint", + "sha256": "960caeaad7edf15f901b5f35a342037f84699c515b8d4922cf32df060cf906ec", + "size": 431792, + "subdir": "linux-64", + "timestamp": 1574169745448, + "version": "2.4.4" + }, + "pylint-2.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL 2", + "md5": "df29b7cb0c269b6759937c3868807bf9", + "name": "pylint", + "sha256": "f527fe1973567e20971bc2fd0ab625301175cac2a7946ff7f75c95765f1f803a", + "size": 478532, + "subdir": "linux-64", + "timestamp": 1588207489708, + "version": "2.5.0" + }, + "pylint-2.5.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "1615407777ab6ce4dcc0f6ba74488423", + "name": "pylint", + "sha256": "bc8d633ad0dd98cf1049f6d9d74c66078992c52d2eddf804de38fe25501acd90", + "size": 469500, + "subdir": "linux-64", + "timestamp": 1588624073175, + "version": "2.5.0" + }, + "pylint-2.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL 2", + "md5": "5a020f81d2873d044f482bde6f6c284f", + "name": "pylint", + "sha256": "2abe88830b05aaa9831ef9cbc7323a6b85e9ecfdfba23a4e20840fa662985350", + "size": 470630, + "subdir": "linux-64", + "timestamp": 1588207475925, + "version": "2.5.0" + }, + "pylint-2.5.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "8f677db18ad1966319065ceb9f38c38b", + "name": "pylint", + "sha256": "3c01a75c718c7539b9f25c1fd3634fc812d8795d1d6ae14ebfd73e80905d59b7", + "size": 465687, + "subdir": "linux-64", + "timestamp": 1588624065036, + "version": "2.5.0" + }, + "pylint-2.5.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL 2", + "md5": "98fc230359cd8522e8bd2f14ab25fe70", + "name": "pylint", + "sha256": "73f0981759eed3dddb2daab10188b8612f7ac80e62ab8e34a8e760faa45f8bb2", + "size": 474525, + "subdir": "linux-64", + "timestamp": 1588207489491, + "version": "2.5.0" + }, + "pylint-2.5.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "413e40b92efbc297580e772dcf532542", + "name": "pylint", + "sha256": "fdf6276da6a0ff7f6a5ba2276efacee95c00a207142d4b5582172c9521be8d94", + "size": 474343, + "subdir": "linux-64", + "timestamp": 1588624042023, + "version": "2.5.0" + }, + "pylint-2.5.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "c4446688343e4687d0532ef6456ee0d6", + "name": "pylint", + "sha256": "79d745f52aef5f3583a390c787d9d77526089a324b3d55d1c11dc40e77378501", + "size": 472537, + "subdir": "linux-64", + "timestamp": 1590117501935, + "version": "2.5.2" + }, + "pylint-2.5.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "c6fb1f83fb1700245c7345124e96fe26", + "name": "pylint", + "sha256": "be6943e03599f3d148e43383a30d72fe004f7c230b0b03c30c405b2a7db33cc2", + "size": 476107, + "subdir": "linux-64", + "timestamp": 1590117496267, + "version": "2.5.2" + }, + "pylint-2.5.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "601b6c6adde36dd33e6befd8c3951415", + "name": "pylint", + "sha256": "c900c8dc50d2a9d89cd903b68968a50f5c52d0d7ce34ab13f38fb64bb03029c4", + "size": 471144, + "subdir": "linux-64", + "timestamp": 1590117502799, + "version": "2.5.2" + }, + "pylint-2.5.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "3f23112d10f46c8ad12385cbe8204ec5", + "name": "pylint", + "sha256": "7453e96f9f6203b4e064f3fe2297a86cedbb77f7a90bc3ab13cc8c668755f6ba", + "size": 473538, + "subdir": "linux-64", + "timestamp": 1592496051938, + "version": "2.5.3" + }, + "pylint-2.5.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "99ef84fdab86013c13214944c6353b84", + "name": "pylint", + "sha256": "14ecaf14bf8c9d815c538203cebce625eb9efdffcb3552d31a074aee0df5364b", + "size": 476388, + "subdir": "linux-64", + "timestamp": 1592496075781, + "version": "2.5.3" + }, + "pylint-2.5.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "d2fa52746b557350f95e915a1ddebd7c", + "name": "pylint", + "sha256": "bd6b8fa06193352a00582523d8174506b46709845565cec916fb7bdef69ddcef", + "size": 478139, + "subdir": "linux-64", + "timestamp": 1592496086842, + "version": "2.5.3" + }, + "pylint-2.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "5388f382e22df6909296b6a9007a413f", + "name": "pylint", + "sha256": "ec4cdeff5d93700666a29194d2a20b63eb1ec372c6caf38dd10315a930c01344", + "size": 469461, + "subdir": "linux-64", + "timestamp": 1598624067394, + "version": "2.6.0" + }, + "pylint-2.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "1460cbfa1375a9d9d6fdeca6eddb9c31", + "name": "pylint", + "sha256": "feb9a30ec8e16cb5eca37f82bf2e65e0c2228d9f7da459e610b633b4839b318f", + "size": 464538, + "subdir": "linux-64", + "timestamp": 1598624077301, + "version": "2.6.0" + }, + "pylint-2.6.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "d98ddc3d16e57dc3bd62fa2b961993a6", + "name": "pylint", + "sha256": "4622c297fa7c55f8ff4714efb2a152520e645fb0eaf19462de2a3a9c4c5191e8", + "size": 466048, + "subdir": "linux-64", + "timestamp": 1598624027873, + "version": "2.6.0" + }, + "pylint-2.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "9a65b48d54ca7e693133a605623432a5", + "name": "pylint", + "sha256": "77579518e3059a7410ed2407bcd8babe67d83ebb79245bda3bd38e27b0dbdddc", + "size": 464493, + "subdir": "linux-64", + "timestamp": 1607716724505, + "version": "2.6.0" + }, + "pylint-2.7.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "b707dac8a4c1a665c081569713f534b8", + "name": "pylint", + "sha256": "813f5bb290386a6741f8069ad8ad4c811aed5aa6c0b4da60817f0cfc74820dec", + "size": 485617, + "subdir": "linux-64", + "timestamp": 1614008056902, + "version": "2.7.0" + }, + "pylint-2.7.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "07af1cd4e2996eca9fda2b93263a1b11", + "name": "pylint", + "sha256": "c940f60e530b5639b149cc407856757d0c223d2221af559697dd6b135fadc867", + "size": 483552, + "subdir": "linux-64", + "timestamp": 1614008048588, + "version": "2.7.0" + }, + "pylint-2.7.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "8ab6156e1ee4aa78143ad2ce5c96bd80", + "name": "pylint", + "sha256": "af4b974cacd06fbffc9205979cad1f8b60dd8747f0dd40e5da874b4bb2ee1661", + "size": 481070, + "subdir": "linux-64", + "timestamp": 1614008038301, + "version": "2.7.0" + }, + "pylint-2.7.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "3c7249783ee1067e8108af867a177b04", + "name": "pylint", + "sha256": "009acd2ddb0c6f0901ed071939fdab2e953b04e0a78ddb98fd2a17bbe9d6ea18", + "size": 481501, + "subdir": "linux-64", + "timestamp": 1614008042816, + "version": "2.7.0" + }, + "pylint-2.7.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "9e6012de9b6265cacaca88fa9d903821", + "name": "pylint", + "sha256": "ff352b306af1cc269a115f362a74330787e7091cd645ebff02219253ccc38579", + "size": 477782, + "subdir": "linux-64", + "timestamp": 1614365900828, + "version": "2.7.1" + }, + "pylint-2.7.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "1949b72cf02db418aa36f3e9131adc45", + "name": "pylint", + "sha256": "d63db39c4684b592e3d6b782d4c7306a26cd592a31ab8217c2c8471e314f71e1", + "size": 477817, + "subdir": "linux-64", + "timestamp": 1614365898788, + "version": "2.7.1" + }, + "pylint-2.7.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "2808c1490f52bc69c504f4bec3dd9285", + "name": "pylint", + "sha256": "28094816a9565ca5f7def7d6fc84041f8de9eb2664931c35e751b9752bbf4f3a", + "size": 481511, + "subdir": "linux-64", + "timestamp": 1614365403469, + "version": "2.7.1" + }, + "pylint-2.7.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "f0fb640f98ff29f938e1af9bcce5081e", + "name": "pylint", + "sha256": "7f86d7ae21e8c379952933a3cc1c7410870f994655e76da453efa171bcd4338a", + "size": 477790, + "subdir": "linux-64", + "timestamp": 1614365887942, + "version": "2.7.1" + }, + "pylint-2.7.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "a4133fbab42d6e42cbae4c4dcb9f0d84", + "name": "pylint", + "sha256": "670716e4c8166eb2f885d67da4d35dac80447875a6ccef664bff997f157200cd", + "size": 484435, + "subdir": "linux-64", + "timestamp": 1614971293918, + "version": "2.7.2" + }, + "pylint-2.7.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "159d730b0a4c0c6fd9c76f9243d94fd5", + "name": "pylint", + "sha256": "087b2ba69b85d63d744ab5fdb2127b6cd44c59ae044e3ab4aa420defe42f27f0", + "size": 486542, + "subdir": "linux-64", + "timestamp": 1614971274936, + "version": "2.7.2" + }, + "pylint-2.7.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "889414a0fe4d8f909f5a1c5f739a0f68", + "name": "pylint", + "sha256": "8d0fa80fc2f522c5026c920ce7536cca9c60f144c1c377d2f1b6de88d04d1276", + "size": 483565, + "subdir": "linux-64", + "timestamp": 1614971281878, + "version": "2.7.2" + }, + "pylint-2.7.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "697f32c76f0b0b06ef5f770cfc3f01b7", + "name": "pylint", + "sha256": "5e2a8a04c8ef5d248178a506ec9f6c7431bd8ff03289d46df889a0885daa4c65", + "size": 485214, + "subdir": "linux-64", + "timestamp": 1614969898406, + "version": "2.7.2" + }, + "pylint-2.7.4-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "8b468792f30ca21839ce40ce9ffe093e", + "name": "pylint", + "sha256": "1e68f9c0d91f246a69d9b140c197e390af43bd7b96c7b0f4941c601b91764f94", + "size": 488261, + "subdir": "linux-64", + "timestamp": 1617133411642, + "version": "2.7.4" + }, + "pylint-2.7.4-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "870dcb547e558af708982452b2d04427", + "name": "pylint", + "sha256": "ec22a5e6f0c67ad5ce94774a564760c03155196dff0d35d1abf2dda327854d98", + "size": 491684, + "subdir": "linux-64", + "timestamp": 1617135870198, + "version": "2.7.4" + }, + "pylint-2.7.4-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "2a8dc558d460faa9c3908ad0e25c614c", + "name": "pylint", + "sha256": "c09e0978e38a41737f04c92ac660652bf37c2ac21cf5927afb8ad5a02b327cc4", + "size": 484508, + "subdir": "linux-64", + "timestamp": 1617135871877, + "version": "2.7.4" + }, + "pylint-2.7.4-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "717a3737b5f939b5f50c2dabd2584df9", + "name": "pylint", + "sha256": "bbe64e0ba59cd9046110b347d5e123d35b5165ee418e12931db184966507d904", + "size": 486085, + "subdir": "linux-64", + "timestamp": 1617135873586, + "version": "2.7.4" + }, + "pylint-2.8.3-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.5.8,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "b7c1be9c7920d0dbb5e87ebca1e60d08", + "name": "pylint", + "sha256": "7854577bc7308e58247782280abfe541073a5163006c135806c15c4ed6f6e286", + "size": 511252, + "subdir": "linux-64", + "timestamp": 1623400266820, + "version": "2.8.3" + }, + "pylint-2.8.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.5.8,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "0aefc67242e4a4e9730f8aba6530acf7", + "name": "pylint", + "sha256": "2efedc81720062bfa74cc9f7a44aaf6d2ae0b5756029bdac58b9f094d995f0ce", + "size": 501776, + "subdir": "linux-64", + "timestamp": 1623399641046, + "version": "2.8.3" + }, + "pylint-2.8.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.5.8,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "f949a83b1893a39f56494d3eb12cf3e6", + "name": "pylint", + "sha256": "37d4d84a37937a9abc40c6964e0cd128165a1ec3525f9a892549f5a97fb98b03", + "size": 502386, + "subdir": "linux-64", + "timestamp": 1623394621614, + "version": "2.8.3" + }, + "pylint-2.8.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.5.8,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "417df2e6273e80b30ff4a2909bc9d867", + "name": "pylint", + "sha256": "861f35fa13849b0bef6478ff396eb345da724e3c0a1d59091eee8a3b7c95bee8", + "size": 500898, + "subdir": "linux-64", + "timestamp": 1623400260239, + "version": "2.8.3" + }, + "pylint-2.9.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.2,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "a8b77790172b08f3d142f27d0cc4adae", + "name": "pylint", + "sha256": "cc52c37ef767cafe819b608fdf807f37f3f8f5d6f53b243b8c32e59cf819d54e", + "size": 524398, + "subdir": "linux-64", + "timestamp": 1625158570052, + "version": "2.9.1" + }, + "pylint-2.9.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.2,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "6e4ffe34bcdf4746d905f373e35da56c", + "name": "pylint", + "sha256": "686242be0c51cb89da8fa609ad97c7fef67e348ef393ecc1377a11f12654d62a", + "size": 521516, + "subdir": "linux-64", + "timestamp": 1625158854767, + "version": "2.9.1" + }, + "pylint-2.9.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.2,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "d4b73c2b2c6fe7f894f20e81a9074d16", + "name": "pylint", + "sha256": "f0f2d735bd8222bbfa0c1efed6fcfbd5d7552f23ae78aa7c02ffc16763b832a4", + "size": 521614, + "subdir": "linux-64", + "timestamp": 1625158856007, + "version": "2.9.1" + }, + "pylint-2.9.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.2,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "061ec6f9acbb2a3937a9d793d2da2289", + "name": "pylint", + "sha256": "e454333ffccc00fc991b51d2dd97198471e802075bc6bc06462a742fc08b33f5", + "size": 521681, + "subdir": "linux-64", + "timestamp": 1625152351393, + "version": "2.9.1" + }, + "pylint-2.9.3-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.2,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "9f1405c02212e8718b8d58d73188c778", + "name": "pylint", + "sha256": "8f9559bb438265981cbdcf3c6ad2380b717b4b049e7b90b7150f2d6a359d5159", + "size": 525559, + "subdir": "linux-64", + "timestamp": 1625467737702, + "version": "2.9.3" + }, + "pylint-2.9.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.2,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "d6bcc123dca8a498f44b130dac10b75f", + "name": "pylint", + "sha256": "1a72a383930fb0d593c1e5e1fded1da8accdac1191f4bd67a7190b994bbcb177", + "size": 525290, + "subdir": "linux-64", + "timestamp": 1625467017728, + "version": "2.9.3" + }, + "pylint-2.9.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.2,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "a38ff75062997a90dcf5911f05aab747", + "name": "pylint", + "sha256": "46ae091f3767f1113dd3a5709b14a42566a3937a0827528c75084af7204017bd", + "size": 517397, + "subdir": "linux-64", + "timestamp": 1625461048864, + "version": "2.9.3" + }, + "pylint-2.9.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.2,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "61c96651c0940e5335053c15958ab125", + "name": "pylint", + "sha256": "8f631c0789ce6b20bcef6d23396b0fa54fff0f8a1635c2ef7ab611b833762d64", + "size": 525958, + "subdir": "linux-64", + "timestamp": 1625467035211, + "version": "2.9.3" + }, + "pylint-2.9.5-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.5,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "055a20467cff8059cc2d623d6d218fcf", + "name": "pylint", + "sha256": "bdbabacc9d54f247aff9087baacc9677780be6c3698c70448d92a733972a4cf3", + "size": 528519, + "subdir": "linux-64", + "timestamp": 1627038111569, + "version": "2.9.5" + }, + "pylint-2.9.5-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.5,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "79d2e08b2b5f39e3db184aac4d8e488e", + "name": "pylint", + "sha256": "23fb390d60a7eafbbc614382ea49ac9ed13e5046001513c8e1806061b28e22dd", + "size": 528569, + "subdir": "linux-64", + "timestamp": 1627038009067, + "version": "2.9.5" + }, + "pylint-2.9.5-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.5,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "9a61ed82890fcbe09b96eddc26ad8025", + "name": "pylint", + "sha256": "73ca965e4a07c00f1f8e20d00f28af582a3be145211e51a0cf40c0d272c7d7aa", + "size": 526341, + "subdir": "linux-64", + "timestamp": 1627030626845, + "version": "2.9.5" + }, + "pylint-2.9.5-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.5,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "64c3203c2acded7e5d035397dc9e0343", + "name": "pylint", + "sha256": "e1e8fcaded299c9f21b5548ffb619476f6701f1cef652faa4cef9f6a1f5b6c54", + "size": 525444, + "subdir": "linux-64", + "timestamp": 1627038111350, + "version": "2.9.5" + }, + "pylint-2.9.6-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.5,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.10,<3.11.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "13927ce2d1b95bef62834d9e226a0853", + "name": "pylint", + "sha256": "378fdd03ccceaf9ee7297f8c9486e524d4fc855159f318c64152ff10330ba55e", + "size": 531356, + "subdir": "linux-64", + "timestamp": 1640812743292, + "version": "2.9.6" + }, + "pylint-2.9.6-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.5,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "b68e5f16b6a3a79069a8e21f47ce67b8", + "name": "pylint", + "sha256": "80bc61b89a66c936e60c359b363be1be939741d700f4d58bcef95d818368724f", + "size": 530227, + "subdir": "linux-64", + "timestamp": 1627536556719, + "version": "2.9.6" + }, + "pylint-2.9.6-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.5,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "fae4e2bc54266384d12bb04f6797c08f", + "name": "pylint", + "sha256": "95800ff7b2b07a0002a9e526aacdd9de9edd38e3610ed765cf81557c6958853f", + "size": 528340, + "subdir": "linux-64", + "timestamp": 1627529101991, + "version": "2.9.6" + }, + "pylint-2.9.6-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.5,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "7ae70831d236d2db8f264e989dc6de9d", + "name": "pylint", + "sha256": "b76dc1d971c1ea2b7504683712c4c1ed1af2926091aa092cf137cbf5e51d6a75", + "size": 528881, + "subdir": "linux-64", + "timestamp": 1627536822859, + "version": "2.9.6" + }, + "pylint-2.9.6-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.5,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "91189af985f921d2bc008c887b3331a9", + "name": "pylint", + "sha256": "37b7ea9db93e8ff4cba5dcda9a395b52dd0fa18d0e877f8234e0040cc817d7dd", + "size": 522036, + "subdir": "linux-64", + "timestamp": 1627536836894, + "version": "2.9.6" + }, + "pylint-venv-2.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01627f14361c597dc1a4b1c3636ac29e", + "name": "pylint-venv", + "sha256": "fc18d3a29b85aa602e80dd3c23fb29eb9a582d82b26627b8280cfd7d535322f1", + "size": 10866, + "subdir": "linux-64", + "timestamp": 1673990208620, + "version": "2.3.0" + }, + "pylint-venv-2.3.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a56c81172f2ded4117e11bf6e4ca436e", + "name": "pylint-venv", + "sha256": "cf9c7023a3e614f0f85f52bc75b10b3539887f44678da9645fe2b1c989f58bf4", + "size": 12075, + "subdir": "linux-64", + "timestamp": 1677706419368, + "version": "2.3.0" + }, + "pylint-venv-2.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8df93090477cea315c7482f737b0ec1d", + "name": "pylint-venv", + "sha256": "035f900862a5934783a39fa1f8aff978372384881f5e76ab0cc434c0fe67922c", + "size": 10846, + "subdir": "linux-64", + "timestamp": 1673990235298, + "version": "2.3.0" + }, + "pylint-venv-2.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d4726b07f4fca306378f8ab493bd065a", + "name": "pylint-venv", + "sha256": "dd9a2215f7ed7cecce007256601518887aa9ae6793494667a37b19176a19f7a6", + "size": 10811, + "subdir": "linux-64", + "timestamp": 1673990182936, + "version": "2.3.0" + }, + "pylint-venv-2.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52030e5ad3c6cc4f3c67e4ff9a359976", + "name": "pylint-venv", + "sha256": "7b6fbde12b3f37f803acef390e3ee9406fe4b1fa655a24baefd89a404e04af52", + "size": 10832, + "subdir": "linux-64", + "timestamp": 1673990157512, + "version": "2.3.0" + }, + "pymc-2.3.7-py27h2761b3c_0.tar.bz2": { + "build": "py27h2761b3c_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "matplotlib", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "AFL-3.0", + "license_family": "OTHER", + "md5": "49145aafa31b116b2335d5c12d6efc47", + "name": "pymc", + "sha256": "d720c5ab7fdf2d60e9cc582dff34e0f7fa3064bf367515bbeef79ff5f58344f0", + "size": 973065, + "subdir": "linux-64", + "timestamp": 1555694755698, + "version": "2.3.7" + }, + "pymc-2.3.7-py36h2761b3c_0.tar.bz2": { + "build": "py36h2761b3c_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "matplotlib", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "AFL-3.0", + "license_family": "OTHER", + "md5": "10edd2abd9c29cd6405a1f840815e1c2", + "name": "pymc", + "sha256": "17bafdd84f00e30b05fd2bf5fb7340aeca34cd33d968877bff6e0578ae272673", + "size": 980219, + "subdir": "linux-64", + "timestamp": 1555694756724, + "version": "2.3.7" + }, + "pymc-2.3.8-py36h13841d7_0.tar.bz2": { + "build": "py36h13841d7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "numpy-devel 1.14.*", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "AFL-3.0", + "license_family": "OTHER", + "md5": "b1d8e374d8cdde474bddaf24417647be", + "name": "pymc", + "sha256": "301759951bbbc7aaa7749c40239ef3f2a22015db88e53b60344a2290221ef312", + "size": 973671, + "subdir": "linux-64", + "timestamp": 1598647536727, + "version": "2.3.8" + }, + "pymc-2.3.8-py37h13841d7_0.tar.bz2": { + "build": "py37h13841d7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "numpy-devel 1.14.*", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "AFL-3.0", + "license_family": "OTHER", + "md5": "068505a461af3b1c161d349ae74a97d2", + "name": "pymc", + "sha256": "5f7a8ce57d744ef7b659bc658834059b7ce021df794fe57cb382fd1f9c446f48", + "size": 981917, + "subdir": "linux-64", + "timestamp": 1598647470643, + "version": "2.3.8" + }, + "pymc-2.3.8-py38h13841d7_0.tar.bz2": { + "build": "py38h13841d7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "numpy-devel 1.14.*", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "AFL-3.0", + "license_family": "OTHER", + "md5": "c1becfc51610a40fee626ddd2e277db7", + "name": "pymc", + "sha256": "d194829532a4fbad61ae14aaf831281cee2490beabf5104bac0b11472b2de1f6", + "size": 973211, + "subdir": "linux-64", + "timestamp": 1598647514572, + "version": "2.3.8" + }, + "pymc3-3.11.4-py310hd09550d_0.tar.bz2": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "arviz >=0.11.0", + "cachetools >=4.2.1", + "dill", + "fastprogress >=0.2.0", + "gxx_linux-64 7.5.0.*", + "mkl-service", + "numpy >=1.15.0", + "pandas >=0.24.0", + "patsy >=0.5.1", + "python >=3.10,<3.11.0a0", + "scipy >=1.2.0", + "semver", + "theano-pymc 1.1.2", + "typing-extensions >=3.7.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3e80f3555732eea8e488cb5f667c3507", + "name": "pymc3", + "sha256": "80059d7ea75db0cfc021ac947e16349cd64c69c72d82e557fb0419af8f1c9335", + "size": 1119479, + "subdir": "linux-64", + "timestamp": 1642513113095, + "version": "3.11.4" + }, + "pymc3-3.11.4-py37hb070fc8_0.tar.bz2": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "arviz >=0.11.0", + "cachetools >=4.2.1", + "dill", + "fastprogress >=0.2.0", + "numpy >=1.16.6,<2.0a0", + "pandas >=0.24.0", + "patsy >=0.5.1", + "python >=3.7,<3.8.0a0", + "scipy >=1.2.0", + "semver >=2.13.0", + "theano-pymc 1.1.2", + "typing-extensions >=3.7.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "95b7362865114a2eaa210c4ca67409a2", + "name": "pymc3", + "sha256": "3af4c9791f0ec579394269f45546ae836a3a220f48f0995193183da2e26cbb8c", + "size": 1111435, + "subdir": "linux-64", + "timestamp": 1634803319665, + "version": "3.11.4" + }, + "pymc3-3.11.4-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "arviz >=0.11.0", + "cachetools >=4.2.1", + "dill", + "fastprogress >=0.2.0", + "numpy >=1.16.6,<2.0a0", + "pandas >=0.24.0", + "patsy >=0.5.1", + "python >=3.8,<3.9.0a0", + "scipy >=1.2.0", + "semver >=2.13.0", + "theano-pymc 1.1.2", + "typing-extensions >=3.7.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "224630a590f1dafdfdb51dff7eee21d7", + "name": "pymc3", + "sha256": "a3925afb106196e2244456b9ba98d2f30c9db119d70a3bb8ec37be62bce04a90", + "size": 1116958, + "subdir": "linux-64", + "timestamp": 1634803317783, + "version": "3.11.4" + }, + "pymc3-3.11.4-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "arviz >=0.11.0", + "cachetools >=4.2.1", + "dill", + "fastprogress >=0.2.0", + "numpy >=1.16.6,<2.0a0", + "pandas >=0.24.0", + "patsy >=0.5.1", + "python >=3.9,<3.10.0a0", + "scipy >=1.2.0", + "semver >=2.13.0", + "theano-pymc 1.1.2", + "typing-extensions >=3.7.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1f4eedeee3ac4e1676ea9d0f76145f30", + "name": "pymc3", + "sha256": "a5d73b665b30d5724c2ada412ed705921f3e6d3afa958af5a6d5ffc7b270262a", + "size": 1119078, + "subdir": "linux-64", + "timestamp": 1634803314585, + "version": "3.11.4" + }, + "pymc3-3.2-py27he296173_0.tar.bz2": { + "build": "py27he296173_0", + "build_number": 0, + "depends": [ + "enum34 >=1.1.6", + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.11.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=0.9", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0ae416abf8a3429a1ef136c4f4bd8b0c", + "name": "pymc3", + "sha256": "9b2b7d3725215e014e635a33847ed1bc85399692ad514580b4adb137c2a0ca0e", + "size": 1213942, + "subdir": "linux-64", + "timestamp": 1508438259846, + "version": "3.2" + }, + "pymc3-3.2-py35h9f7775c_0.tar.bz2": { + "build": "py35h9f7775c_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.11.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.5,<3.6.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=0.9", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bed7198aa55bcbddddd265b3c868cc71", + "name": "pymc3", + "sha256": "072106354df33379b3598ce13da2b1af72c7010911abb5c837050210f81d116d", + "size": 1230039, + "subdir": "linux-64", + "timestamp": 1508438277064, + "version": "3.2" + }, + "pymc3-3.2-py36h89408ba_0.tar.bz2": { + "build": "py36h89408ba_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.11.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=0.9", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a359088917617d659eaf105eeed96f8c", + "name": "pymc3", + "sha256": "98b31e31254956094a5dd210909cf925176c3bbc66f9ee68740de3e16cb26647", + "size": 1226422, + "subdir": "linux-64", + "timestamp": 1508438278033, + "version": "3.2" + }, + "pymc3-3.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34 >=1.1.6", + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.11.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "db8de72b9ff3d4d39fc7c8fbd84fe256", + "name": "pymc3", + "sha256": "b47d3b2ef5ce7677cdf217adba52c879905b01a5c973d2406ecd01a8faa4460a", + "size": 1221760, + "subdir": "linux-64", + "timestamp": 1519192499856, + "version": "3.3" + }, + "pymc3-3.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.11.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.5,<3.6.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b1f9094939769cf3ae888aee78eaa1e2", + "name": "pymc3", + "sha256": "75fa6dc149392d08eec789c297e097b95ed191e7c15122249d1cdc8ae34bef6b", + "size": 1243453, + "subdir": "linux-64", + "timestamp": 1519192519543, + "version": "3.3" + }, + "pymc3-3.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.11.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e392230ed54c52f77a8d49009b62e643", + "name": "pymc3", + "sha256": "f50b8dc7726254e94fcd67da2d80b8febf404a65f06b960859a2b37fe757944b", + "size": 1238300, + "subdir": "linux-64", + "timestamp": 1519192492466, + "version": "3.3" + }, + "pymc3-3.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34 >=1.1.6", + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "841e36cb7c3b2223d99ef67d7bb15b79", + "name": "pymc3", + "sha256": "8001e17e3b9d8217639307f0b4c8eb05c34d12d3769ae85007c7500e7e81a8c9", + "size": 1274156, + "subdir": "linux-64", + "timestamp": 1526497921544, + "version": "3.4.1" + }, + "pymc3-3.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.5,<3.6.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dbe344d276dda3a7b16d1f1534a2b7d1", + "name": "pymc3", + "sha256": "ec5679d790af432af0d104c81eeb58f00445bfb7bac5f1d90559c718d0dc450f", + "size": 1293701, + "subdir": "linux-64", + "timestamp": 1526498029382, + "version": "3.4.1" + }, + "pymc3-3.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ed0f7461136be4588ee440d2dcc1687d", + "name": "pymc3", + "sha256": "657e4b711081650e0d7bc1c6e1800c7430f03bcf1fcc32d1a55219b7036c3482", + "size": 1294009, + "subdir": "linux-64", + "timestamp": 1526497928572, + "version": "3.4.1" + }, + "pymc3-3.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.7,<3.8.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f9fc88d2c6d370d525088b7e8efedd9e", + "name": "pymc3", + "sha256": "dce0d266ded1cdc3166ef52003b3e232a9e6688fc9f05ed19214f0f4e8288714", + "size": 1280107, + "subdir": "linux-64", + "timestamp": 1530917837616, + "version": "3.4.1" + }, + "pymc3-3.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34 >=1.1.6", + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4645df5c697a5db116d6bb096aa297fa", + "name": "pymc3", + "sha256": "39ed61b20edaa0ecca855aaf220b6bad38d6510a6119be289cbe8da345cff848", + "size": 1313164, + "subdir": "linux-64", + "timestamp": 1534608317482, + "version": "3.5" + }, + "pymc3-3.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.5,<3.6.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0a9310735e3c35aa99361c5a966639aa", + "name": "pymc3", + "sha256": "7260ab249eeb54efc33b9c3e4397bf1bbba8e5d51f1ea6ae50860c2c76d23e59", + "size": 1327207, + "subdir": "linux-64", + "timestamp": 1534609769572, + "version": "3.5" + }, + "pymc3-3.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "46783e96493648024e582418d5669106", + "name": "pymc3", + "sha256": "5c9608809e3f402318cb0d57c19eb6d7697f1af46b3e9821b4d88e744ee8a07b", + "size": 1321930, + "subdir": "linux-64", + "timestamp": 1534608315055, + "version": "3.5" + }, + "pymc3-3.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.7,<3.8.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b880c6970653f77faf054e2109370695", + "name": "pymc3", + "sha256": "f3bf400e6ec2f188e15dc8fd9ac6a9f93d3970831236b2a187e8f5f33e7f9987", + "size": 1318865, + "subdir": "linux-64", + "timestamp": 1534608479790, + "version": "3.5" + }, + "pymc3-3.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34 >=1.1.6", + "h5py >=2.7.0", + "joblib <0.13.0", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "642717888afbd083fc678ab7129fbb1f", + "name": "pymc3", + "sha256": "47bd58600e0c15d0effff4ae01a0b4f9292727eaad0660561774d45849d78915", + "size": 1064994, + "subdir": "linux-64", + "timestamp": 1546016640783, + "version": "3.6" + }, + "pymc3-3.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib <0.13.0", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b41b85b2b3e8fd374888b5a46f1c6613", + "name": "pymc3", + "sha256": "a17fb66ac68154152f5437b517ff48b931ae289868c3efd4624e34d79931c606", + "size": 1074240, + "subdir": "linux-64", + "timestamp": 1546016703527, + "version": "3.6" + }, + "pymc3-3.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib <0.13.0", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.7,<3.8.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e2a08e3da85049bba4e9c8b4845bd628", + "name": "pymc3", + "sha256": "f3bead36c792a11d9bd3837802da20e950bb6ec2201d1e8a34f474d3d82b4195", + "size": 1083543, + "subdir": "linux-64", + "timestamp": 1546016622738, + "version": "3.6" + }, + "pymongo-3.10.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "85993515a51ff22834e06403bb441d8e", + "name": "pymongo", + "sha256": "eb53eb355fc92abaf1deedc45670a983074c19ae8919e1a0df19ffae234d111d", + "size": 1151482, + "subdir": "linux-64", + "timestamp": 1597255092548, + "version": "3.10.1" + }, + "pymongo-3.10.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "a0dfe915ee1ba4cfc0b88c18611c64dd", + "name": "pymongo", + "sha256": "2a3241e832a5ef12d93ae1188711fb113ff5513059525054ec8427ac291484ca", + "size": 1165431, + "subdir": "linux-64", + "timestamp": 1597250905511, + "version": "3.10.1" + }, + "pymongo-3.10.1-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "e58791e9b50f91c63fb21ef62df49481", + "name": "pymongo", + "sha256": "c58572942014bfa616effa9862963ec0672fa2bda1bdaec815f55dcdc8a9728d", + "size": 1175140, + "subdir": "linux-64", + "timestamp": 1597255383877, + "version": "3.10.1" + }, + "pymongo-3.11.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "747f7578a5f828f378e5c0ae77b12d51", + "name": "pymongo", + "sha256": "3345454e950be1b58d437f545a179b3088996e5def4a7d93eae258c0196babe5", + "size": 1285151, + "subdir": "linux-64", + "timestamp": 1597245245922, + "version": "3.11.0" + }, + "pymongo-3.11.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "c02d7023004af710bb745f67d5c5fa0f", + "name": "pymongo", + "sha256": "9c3d1568088317c95fd974c05a1a8a1ec17ee3def4e4ffd8d62e69b3b3018770", + "size": 1268291, + "subdir": "linux-64", + "timestamp": 1597245192376, + "version": "3.11.0" + }, + "pymongo-3.11.0-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "7cbe88acf8dfb8c5e4fb8b5dc35660ba", + "name": "pymongo", + "sha256": "9e5d849c9d3c63de83ccc21c75fd2065f192ee36c361698bbb497b54e57995b8", + "size": 1262888, + "subdir": "linux-64", + "timestamp": 1597245229836, + "version": "3.11.0" + }, + "pymongo-3.11.1-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "5aca43ca2e584b24759386b1315f596e", + "name": "pymongo", + "sha256": "a813adeb1e7f196bd202e2c16fe6bd13eea56dac0bbe1f6ca72f4f7ba6ffc0c4", + "size": 1292718, + "subdir": "linux-64", + "timestamp": 1606344910198, + "version": "3.11.1" + }, + "pymongo-3.11.1-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "3b570282700a794b9c7620f6515534c7", + "name": "pymongo", + "sha256": "49506eb1aa9e9e59658f32de734b3b271d3b8d0984d88485e0028ce917287235", + "size": 1278784, + "subdir": "linux-64", + "timestamp": 1606344868991, + "version": "3.11.1" + }, + "pymongo-3.11.1-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "abfb1af276d2520a651e9c7184e2f7de", + "name": "pymongo", + "sha256": "01af702b58a7fa319dfe78952c4401bdca4ebbc05ef861c4f22ae36ffc5405a4", + "size": 1295320, + "subdir": "linux-64", + "timestamp": 1606344908183, + "version": "3.11.1" + }, + "pymongo-3.11.1-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "09f84f734c9e8a5022d6046b49ac9711", + "name": "pymongo", + "sha256": "3cdc70536dace44342dbda2c7ade8a1d2e76d7220f57531fedb76e4192a146fb", + "size": 1298125, + "subdir": "linux-64", + "timestamp": 1606344914953, + "version": "3.11.1" + }, + "pymongo-3.11.2-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "2a97072a38ed410249a5c0a8f0e54f32", + "name": "pymongo", + "sha256": "10f35e2e9ecfe0e24cfe635bd9252f2604df9f6487c4274950d8963fb0475336", + "size": 1282847, + "subdir": "linux-64", + "timestamp": 1607369066477, + "version": "3.11.2" + }, + "pymongo-3.11.2-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "446da52f78f1251508934360859b767f", + "name": "pymongo", + "sha256": "0229ffbac6bb7ae5ad818afc8d3db1d79bb1febe3c4f9e4ddc72cc48750f7659", + "size": 1276544, + "subdir": "linux-64", + "timestamp": 1607369060844, + "version": "3.11.2" + }, + "pymongo-3.11.2-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "7d217b4999ed18242dc0544ff3e20463", + "name": "pymongo", + "sha256": "39a220576b5dfdb3814f4668828ba374c12fe3571606e4d38fb21cd70035a630", + "size": 1283173, + "subdir": "linux-64", + "timestamp": 1607369069440, + "version": "3.11.2" + }, + "pymongo-3.11.2-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "39d67112e5fee50d00ff59a26d4290a0", + "name": "pymongo", + "sha256": "e57ae70c066e696256a57babf0f80160edf047bb87ec5d5884614e4c20408c75", + "size": 1284352, + "subdir": "linux-64", + "timestamp": 1607369108523, + "version": "3.11.2" + }, + "pymongo-3.11.3-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "f183e9c0854aeeff5698804021588a4f", + "name": "pymongo", + "sha256": "afb9beb833aa2015800af02873af18ad9f5d2f2ad3f04ad11a47434718f02b1a", + "size": 1279367, + "subdir": "linux-64", + "timestamp": 1613849355565, + "version": "3.11.3" + }, + "pymongo-3.11.3-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "1d82ad748a081648e95b9c5936d0dff9", + "name": "pymongo", + "sha256": "e6b32dcf297abc3927d2ab58ca7798c796e618ea8c5b289ed7f8d98d5167c0fe", + "size": 1296361, + "subdir": "linux-64", + "timestamp": 1613849839138, + "version": "3.11.3" + }, + "pymongo-3.11.3-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "754a296297bc9ec0bff2764bc2e2286c", + "name": "pymongo", + "sha256": "8ea14b5386d216c5d9105b66fdff30a423f17af8cdbd7a579fb6a04bc5b9548f", + "size": 1271971, + "subdir": "linux-64", + "timestamp": 1613849037215, + "version": "3.11.3" + }, + "pymongo-3.11.3-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "ef75a9fceccc2635f8cc840d8f1e3a9f", + "name": "pymongo", + "sha256": "b9d9294d80c5adfed9c5569285a79cfda9b32f0d4a516b66943254e394b17c56", + "size": 1312975, + "subdir": "linux-64", + "timestamp": 1613849834675, + "version": "3.11.3" + }, + "pymongo-3.11.4-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "4affedf7ea61f38237201149694cb807", + "name": "pymongo", + "sha256": "64e919f7050744c958a2e1715d7bea6d868432473c44cc915f00504f4743d314", + "size": 1268931, + "subdir": "linux-64", + "timestamp": 1620214177014, + "version": "3.11.4" + }, + "pymongo-3.11.4-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "a4a258dec4541f71829e72eeab2a37ac", + "name": "pymongo", + "sha256": "9df02b8446b72f5948d079b5b5708b9db223cb88f147936b8f7052247a0437a2", + "size": 1289733, + "subdir": "linux-64", + "timestamp": 1620214172294, + "version": "3.11.4" + }, + "pymongo-3.11.4-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "5c5ba257da9f0f6127be67660becc6d1", + "name": "pymongo", + "sha256": "9ea49beba73121bb387f91a2eb2a21230b6c7cad0da657f8fc080b020db656ca", + "size": 1313737, + "subdir": "linux-64", + "timestamp": 1620214172090, + "version": "3.11.4" + }, + "pymongo-3.11.4-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "ea27e9a3fcbf31ea6ef093d2f9fffed9", + "name": "pymongo", + "sha256": "44aef66f8f110c28606a43c0295f6205b51a8e177f381a9085f76a5ba9f0cbd0", + "size": 1273639, + "subdir": "linux-64", + "timestamp": 1620213543617, + "version": "3.11.4" + }, + "pymongo-3.12.0-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "62251f05496454dd59c0302f9e262149", + "name": "pymongo", + "sha256": "70717b19c2ff10842cc9aec5dd95220474c288cb7e33f460f0de6dcd177022ad", + "size": 1713018, + "subdir": "linux-64", + "timestamp": 1640793474521, + "version": "3.12.0" + }, + "pymongo-3.12.0-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b394a80ec59852b5ff0a762ce338e7b6", + "name": "pymongo", + "sha256": "a65d20610812a1d2f506cf2f3082dfd46c90be88162eec528fbd578b72428692", + "size": 1772118, + "subdir": "linux-64", + "timestamp": 1676860947762, + "version": "3.12.0" + }, + "pymongo-3.12.0-py36h295c915_0.tar.bz2": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "a2a59d93720580580e54cabebd3b5db7", + "name": "pymongo", + "sha256": "8e5c07a3e2dbfd0a78c574eb61e70e24978c4b527b9074a9f50d73e542b23b87", + "size": 1343149, + "subdir": "linux-64", + "timestamp": 1626240803207, + "version": "3.12.0" + }, + "pymongo-3.12.0-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "572b50b2160380d56e3d5b003d22ca60", + "name": "pymongo", + "sha256": "62d9c8d041d7e01b29a44f46981f5117028e7aee5b800593eb1ba3c736789014", + "size": 1358489, + "subdir": "linux-64", + "timestamp": 1626234191346, + "version": "3.12.0" + }, + "pymongo-3.12.0-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "52f67f8db98163f9c9168d82cd67ad5a", + "name": "pymongo", + "sha256": "32608ae03fffee2b835af4ea20f396b7b741f347fe0147a397f7d15364e81037", + "size": 1381794, + "subdir": "linux-64", + "timestamp": 1626241240358, + "version": "3.12.0" + }, + "pymongo-3.12.0-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ef4afacfe99637c8ed9621371c483902", + "name": "pymongo", + "sha256": "7c892d666b7154725254200a697a60af4d2fea835266ac4520335382f99fd3b3", + "size": 1333122, + "subdir": "linux-64", + "timestamp": 1626309445823, + "version": "3.12.0" + }, + "pymongo-3.7.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "7fa4d6a38e36be58d7ea9fe718430ca0", + "name": "pymongo", + "sha256": "cb2fd13564d2688de94757f05e146f9a627c2b9dff2e50fa6a95430a6784eaa9", + "size": 1126464, + "subdir": "linux-64", + "timestamp": 1530900432983, + "version": "3.7.0" + }, + "pymongo-3.7.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "0603875f95574ce1aff8661dd4480d75", + "name": "pymongo", + "sha256": "0fb032de45d03071fc0fdbeda88e1e90efddd9febf9cc6e4db6f4d55001b2fd3", + "size": 1136951, + "subdir": "linux-64", + "timestamp": 1530900366926, + "version": "3.7.0" + }, + "pymongo-3.7.0-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "09e2bc767277477d6d9e75919912495c", + "name": "pymongo", + "sha256": "e2a1bb90d032ba03a9c5dae1516f1f757b45deaf675c42020e92d1a0e72329f3", + "size": 1136755, + "subdir": "linux-64", + "timestamp": 1530900297485, + "version": "3.7.0" + }, + "pymongo-3.7.1-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "fecceb370d06e6a2b644829165c11839", + "name": "pymongo", + "sha256": "c179c52034f552bbcdc12d5d8bacbddc2b92e37c0c304c775b81149d581f7e18", + "size": 998604, + "subdir": "linux-64", + "timestamp": 1535891529137, + "version": "3.7.1" + }, + "pymongo-3.7.1-py35he6710b0_0.tar.bz2": { + "build": "py35he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "48d113bac023d049dae014839093e41a", + "name": "pymongo", + "sha256": "2c461af4543a4864c04805aeab8d25a043f0b44c39400406d1fb94a625a73cbc", + "size": 997616, + "subdir": "linux-64", + "timestamp": 1535891525536, + "version": "3.7.1" + }, + "pymongo-3.7.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "6cf3681a01dbd3505e06ef24a07bdfc6", + "name": "pymongo", + "sha256": "91516ef33327736e729030cf7e1c04ffb2958a5938ab0afa6c146bec32acb17e", + "size": 1004091, + "subdir": "linux-64", + "timestamp": 1535891476344, + "version": "3.7.1" + }, + "pymongo-3.7.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "8c13ee24d2ccbf1981ca70183c1d9519", + "name": "pymongo", + "sha256": "aec1bb1509cae5201182e573947c687592ea86f158e3725ab10a11437c631fad", + "size": 1004311, + "subdir": "linux-64", + "timestamp": 1535891518427, + "version": "3.7.1" + }, + "pymongo-3.7.2-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "fca7bf4ee3af17414c5c556826c63691", + "name": "pymongo", + "sha256": "a9ad2dc712a69b446e71627faad7462d0c0eb778d73bb5d65ba51c9d7a871d3f", + "size": 982675, + "subdir": "linux-64", + "timestamp": 1539729988104, + "version": "3.7.2" + }, + "pymongo-3.7.2-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "39626b8672ecafbbe1b863d4c3cdd8af", + "name": "pymongo", + "sha256": "99bed2b67f8acfb7a5b6ecbeb15d88a072e498a839d599f9cb940e3b6ef334b4", + "size": 1004216, + "subdir": "linux-64", + "timestamp": 1539729997572, + "version": "3.7.2" + }, + "pymongo-3.7.2-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "d0118abbf59e483404852b1b27167570", + "name": "pymongo", + "sha256": "662ccd07104fdb36fc241de4a3a1fe9d9d56a6fabb2baf426da8e25f0191642c", + "size": 1004684, + "subdir": "linux-64", + "timestamp": 1539729997652, + "version": "3.7.2" + }, + "pymongo-3.8.0-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "e39a7c86bb29fc76e7bc557c534b4cce", + "name": "pymongo", + "sha256": "69f7fa257faf9d2e234977dacb8346aa488dc125de4d7003e019b75d6e3e2b3b", + "size": 995494, + "subdir": "linux-64", + "timestamp": 1559921910825, + "version": "3.8.0" + }, + "pymongo-3.8.0-py27he6710b0_1.tar.bz2": { + "build": "py27he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "3df34b746f1a9a9a30f99650765a9c11", + "name": "pymongo", + "sha256": "03e3bfa1d72a6f9cc13517186f253f22704ef031eccc0a47c996b967342b0913", + "size": 977326, + "subdir": "linux-64", + "timestamp": 1561563817442, + "version": "3.8.0" + }, + "pymongo-3.8.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "f9840bfb08e419dd9f0d4ea6af4e32f0", + "name": "pymongo", + "sha256": "c08a45d7e449d066619bc8f08ec0fcea7c06ffdcca95873dae1e537558603ed8", + "size": 988318, + "subdir": "linux-64", + "timestamp": 1559921922455, + "version": "3.8.0" + }, + "pymongo-3.8.0-py36he6710b0_1.tar.bz2": { + "build": "py36he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "7f864aa21966851df230cf3c2d5fa2e8", + "name": "pymongo", + "sha256": "df79ae15c4e3a16174c7362cc88c052e2237181f99d9b4d781a5e4bb40853ce3", + "size": 1014500, + "subdir": "linux-64", + "timestamp": 1561563826449, + "version": "3.8.0" + }, + "pymongo-3.8.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "326cb3dc50a23c1e9ef4ba3474428d44", + "name": "pymongo", + "sha256": "ea928c6761cc31cc32702b85c3ad547c4c0feb02e23fab3883ffeb5cfd848b7e", + "size": 1037137, + "subdir": "linux-64", + "timestamp": 1559921890468, + "version": "3.8.0" + }, + "pymongo-3.8.0-py37he6710b0_1.tar.bz2": { + "build": "py37he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "2094998cf04c80e9da28a3d34f15cc17", + "name": "pymongo", + "sha256": "021bf395c9095e740d0d935fcd81c1715466b6066c8d732337f5d7ddc18f7ccf", + "size": 995763, + "subdir": "linux-64", + "timestamp": 1561563823452, + "version": "3.8.0" + }, + "pymongo-3.9.0-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "9d655fa6833c8d8be3d3628986b8d45f", + "name": "pymongo", + "sha256": "276b2d8ccbbee523de12aaaec158b6d1d4210f96424875cfed93c50b727b53be", + "size": 1137368, + "subdir": "linux-64", + "timestamp": 1569345366070, + "version": "3.9.0" + }, + "pymongo-3.9.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "d8007de727d58a225164217a2b811212", + "name": "pymongo", + "sha256": "01ff2280da8c2d3706e50b090e4583c855df0defee926ba790d4455dbaa6d6b4", + "size": 1160330, + "subdir": "linux-64", + "timestamp": 1569345402666, + "version": "3.9.0" + }, + "pymongo-3.9.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "5c316038944fe7943826bed90f5618ae", + "name": "pymongo", + "sha256": "6938332215403da938492348d01d5629d768d4638ea23ce48c97ba835eeb0d79", + "size": 1156983, + "subdir": "linux-64", + "timestamp": 1569345394987, + "version": "3.9.0" + }, + "pymongo-3.9.0-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "6c3dd0006da57c6cd4869b18abe47b78", + "name": "pymongo", + "sha256": "3fa4db766f9c185e4b1fac918a4c0aa2c230d777bdeae9b7ed1dac331aff25fb", + "size": 1182777, + "subdir": "linux-64", + "timestamp": 1573670045504, + "version": "3.9.0" + }, + "pympler-0.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "a124e4ff84a523369770c8d495bb4d8f", + "name": "pympler", + "sha256": "1b294a259ac5637304a61e61a0d616beee597b4b65316373e963274be78feb81", + "size": 250586, + "subdir": "linux-64", + "timestamp": 1530917880276, + "version": "0.5" + }, + "pympler-0.5-py27h8aa4898_0.tar.bz2": { + "build": "py27h8aa4898_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "9ee811bc83141c4560735d96f1be2f3d", + "name": "pympler", + "sha256": "528f4c5dc5c09feff8331614cd5bbe3677ef03ca24cc8e3b11631b8150bc59ab", + "size": 250812, + "subdir": "linux-64", + "timestamp": 1507743720855, + "version": "0.5" + }, + "pympler-0.5-py35hc09b5c8_0.tar.bz2": { + "build": "py35hc09b5c8_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "dc682394b473257619abab002f37d39d", + "name": "pympler", + "sha256": "b9909993a70937fc1b57ca0a649da93cef47992c42f852c9b78bb61311118740", + "size": 254782, + "subdir": "linux-64", + "timestamp": 1507743728477, + "version": "0.5" + }, + "pympler-0.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "492415169d4ad9c552407e216608ef24", + "name": "pympler", + "sha256": "2c06f373e485ec2d82ac23ed8682d2c0610b86b5a2e4ce858c385a869e340e84", + "size": 251119, + "subdir": "linux-64", + "timestamp": 1530917937882, + "version": "0.5" + }, + "pympler-0.5-py36h6b12e4d_0.tar.bz2": { + "build": "py36h6b12e4d_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "c75dde384dcf8fac74c8d0c17d3701da", + "name": "pympler", + "sha256": "f46f75549f97fad8feb557fdf24e1228331d561084b648268db7662127c838e7", + "size": 251329, + "subdir": "linux-64", + "timestamp": 1507743724941, + "version": "0.5" + }, + "pympler-0.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "6577c30185d4b739dfd8bc10849a76b5", + "name": "pympler", + "sha256": "2477d5c35d464164c707277493f02579d8503c1524f69fab1207520940031837", + "size": 250978, + "subdir": "linux-64", + "timestamp": 1530917997694, + "version": "0.5" + }, + "pymssql-2.1.4-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "freetds >=1.0.91,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "2b997e86402b07a5d0f9f353269655d9", + "name": "pymssql", + "sha256": "99abc641d6f6e95a9bd7d30597996a0514d3b9083f6a2e6aa1c9a306a9f297f6", + "size": 249986, + "subdir": "linux-64", + "timestamp": 1535519287587, + "version": "2.1.4" + }, + "pymssql-2.1.4-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "d4cde3aeca19f73e67b67ffa1e5b8195", + "name": "pymssql", + "sha256": "91b7c9afe0738a8135f05043aa5870b2f2c334ad2cbd00730b3f8fd7c7a0be3a", + "size": 1033841, + "subdir": "linux-64", + "timestamp": 1640793515944, + "version": "2.1.4" + }, + "pymssql-2.1.4-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "freetds >=1.0.91,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "d0a1627fba4ef8ec959720be640960bc", + "name": "pymssql", + "sha256": "a9ffedde85dc6f5628964b9fa5d312f8f4d3335195caa3f6d217531f84dd4bba", + "size": 251854, + "subdir": "linux-64", + "timestamp": 1535519338919, + "version": "2.1.4" + }, + "pymssql-2.1.4-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "freetds >=1.0.91,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "e829c1f260e52a8b4d2f5fbd2f881d9f", + "name": "pymssql", + "sha256": "631eff3961696082867ed22e69dae51b2294d279e8d07ea653d4db83c9e797a4", + "size": 255234, + "subdir": "linux-64", + "timestamp": 1535519235632, + "version": "2.1.4" + }, + "pymssql-2.1.4-py36h7f8727e_0.tar.bz2": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "freetds >=1.3,<2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "906b27e07700333ecb945aabb5d5a842", + "name": "pymssql", + "sha256": "b6883feb72b02ca1fda74f36df0af775ed5ac4dcbc84aadfccd2bc067cdba1b1", + "size": 230959, + "subdir": "linux-64", + "timestamp": 1632894728011, + "version": "2.1.4" + }, + "pymssql-2.1.4-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "freetds >=1.0.91,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "24b206b1e6f9e5f0ff8936bd2b326254", + "name": "pymssql", + "sha256": "3f3d8854cb1f2a75bb60c2a66296d9f4da0bcb47cd7eb764e0c6e05e14f14f25", + "size": 254617, + "subdir": "linux-64", + "timestamp": 1535519339861, + "version": "2.1.4" + }, + "pymssql-2.1.4-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "freetds >=1.3,<2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "10c8704839c74a84c3f4ed74fbe88717", + "name": "pymssql", + "sha256": "a93a1d46fd5e11c1dae571656f9b0b72270d7c8578dc8cf278ef08a82b0e94a9", + "size": 230711, + "subdir": "linux-64", + "timestamp": 1632894694278, + "version": "2.1.4" + }, + "pymssql-2.1.4-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "freetds >=1.0.97,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "8947fcb4a0316ad10f1359c00e810885", + "name": "pymssql", + "sha256": "fb032a31a1384947642e05086066cb496e5bb184fa26ea1658eb8d447a9863a5", + "size": 284259, + "subdir": "linux-64", + "timestamp": 1592330817634, + "version": "2.1.4" + }, + "pymssql-2.1.4-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "freetds >=1.3,<2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "cd69ef9de29761e714fe276966e46d7b", + "name": "pymssql", + "sha256": "3148cd719ecfe0dfae8b1883e1eae5392f474e97b2b663f8449b4b3eeccbd3e2", + "size": 246683, + "subdir": "linux-64", + "timestamp": 1632894699185, + "version": "2.1.4" + }, + "pymssql-2.1.4-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "freetds >=1.3,<2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "4fb5357a01bdebaccba8e6072a68e7d2", + "name": "pymssql", + "sha256": "48d599e2d9d3653b456f5376ebb172f3eaf814aa4dbae8d5d99a058104971636", + "size": 247690, + "subdir": "linux-64", + "timestamp": 1632893961373, + "version": "2.1.4" + }, + "pymssql-2.1.5-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "freetds >=1.0.97,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "3eba727d83ae516ecc7f55b88bcc0246", + "name": "pymssql", + "sha256": "7e83c8fcb42249619b37203c9ba1e7dd2f50b29d054eb51a854f87afc0f892be", + "size": 234786, + "subdir": "linux-64", + "timestamp": 1602602757831, + "version": "2.1.5" + }, + "pymssql-2.1.5-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "freetds >=1.0.97,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "39603d3e64f94d26c478e0b97c566134", + "name": "pymssql", + "sha256": "6cd04d78792fa694e738484c36d75894d5ec7f99ce5d89fde49c33dfc252159d", + "size": 233651, + "subdir": "linux-64", + "timestamp": 1602604632556, + "version": "2.1.5" + }, + "pymssql-2.1.5-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "freetds >=1.0.97,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "52cc615a7c8b26107e2569e172521615", + "name": "pymssql", + "sha256": "deba3c7d1dad4c6203c5af615c7a0f6d1201921f6d5ffbcb470a2b298710c58b", + "size": 249904, + "subdir": "linux-64", + "timestamp": 1602602726091, + "version": "2.1.5" + }, + "pymssql-2.2.3-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "d661e2855ab88abfffc51ad111ec5430", + "name": "pymssql", + "sha256": "7fe06aafc0d2c7d9db4834080808c184aca80ca68395728a116cf75b339e6d6e", + "size": 256817, + "subdir": "linux-64", + "timestamp": 1676860982198, + "version": "2.2.3" + }, + "pymssql-2.2.3-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "f74abcdb1f79fb09dcbc4ca70f2e6ac7", + "name": "pymssql", + "sha256": "fe810d4e8445b7ec6aafd6644a6a07fc12da3ad27b4b30ec7e02d946a6fd59d4", + "size": 244287, + "subdir": "linux-64", + "timestamp": 1642624768445, + "version": "2.2.3" + }, + "pymssql-2.2.3-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "024988cd1e03dc9ae39f8ea218529904", + "name": "pymssql", + "sha256": "86c4dd894f26f3f948521a2aa49f5ee5ac38f40b94d80ecf664a52fdde9980d7", + "size": 262200, + "subdir": "linux-64", + "timestamp": 1642624770107, + "version": "2.2.3" + }, + "pymssql-2.2.3-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "53556462a9f05bc629f1163686ff1122", + "name": "pymssql", + "sha256": "3f5ae1e70ce12ddeaa4ef95fc2827a85dc4476d54fb2b709671a835fbc838d4b", + "size": 262293, + "subdir": "linux-64", + "timestamp": 1642624766267, + "version": "2.2.3" + }, + "pymssql-2.2.5-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "8ea4338d0a9dffb012b6e98b91cae48d", + "name": "pymssql", + "sha256": "22f3222d44bab9d77f8c1b78266d4361cec7a80e60e263d289ea99613fb5fd25", + "size": 1259262, + "subdir": "linux-64", + "timestamp": 1663178763835, + "version": "2.2.5" + }, + "pymssql-2.2.5-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "97c76dd1d4b0e632b74c89ff93660e73", + "name": "pymssql", + "sha256": "97ab4ffbae25d531414244d9ab651e717973e927e10b8ee972aac9ef2fea1ecf", + "size": 256149, + "subdir": "linux-64", + "timestamp": 1679337497397, + "version": "2.2.5" + }, + "pymssql-2.2.5-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "a3e7a9aa238f04ae960be4fa69ea8cce", + "name": "pymssql", + "sha256": "d8193d732d4bc82763330cadf2372aeee46d898e110c5e5217ec00bd9a2f7ea3", + "size": 249472, + "subdir": "linux-64", + "timestamp": 1663178705608, + "version": "2.2.5" + }, + "pymssql-2.2.5-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "06fc78fe93d89f713cdfa1cccf2777eb", + "name": "pymssql", + "sha256": "49a0d355a037d19d0db7993bc9be65ede0469527b9cb341b2491740dd41fa5a9", + "size": 265959, + "subdir": "linux-64", + "timestamp": 1663178619527, + "version": "2.2.5" + }, + "pymssql-2.2.5-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "5c23bef97eea8ebc5857d010dd3ebdfa", + "name": "pymssql", + "sha256": "6a79095f1104a537da59cc4a63726e3717dc79a93a1fc205b38e9b6e8beaa1bd", + "size": 260407, + "subdir": "linux-64", + "timestamp": 1663178661586, + "version": "2.2.5" + }, + "pymysql-0.10.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71f2a4306a33321aa7335e95f6af0d51", + "name": "pymysql", + "sha256": "5e4659c3c508000dc6ac100fdb270cf6e43b40c7c0228937955eebfa2edbef83", + "size": 84009, + "subdir": "linux-64", + "timestamp": 1601588912775, + "version": "0.10.1" + }, + "pymysql-0.10.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fcad117ede3a62e47549e6c7e1b29371", + "name": "pymysql", + "sha256": "85a900ba56c2a4424349b7286c4a066d9c1c7e7df6798e1b2f3d33f6e05ff1a4", + "size": 84005, + "subdir": "linux-64", + "timestamp": 1601588882616, + "version": "0.10.1" + }, + "pymysql-0.10.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b37fc14c0f2bb35ce04e2904e972243e", + "name": "pymysql", + "sha256": "efeb05c45dbcaf5d73c778bce58137c0a92882420e588a486f514e62e497d4d8", + "size": 84196, + "subdir": "linux-64", + "timestamp": 1601588874444, + "version": "0.10.1" + }, + "pymysql-0.7.11-py27ha7233d9_0.tar.bz2": { + "build": "py27ha7233d9_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "08fe3c9a6f783226d0a1f9c65f740791", + "name": "pymysql", + "sha256": "799743a1ebf29df5115337219e95a934fcd1b3f06507f5567598c00936c83064", + "size": 128598, + "subdir": "linux-64", + "timestamp": 1507787387247, + "version": "0.7.11" + }, + "pymysql-0.7.11-py35h9a3333c_0.tar.bz2": { + "build": "py35h9a3333c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "eed2a83f928dd85ae439690ee204d419", + "name": "pymysql", + "sha256": "77f3c6b4ee53b5a1a3714b0313bb6ac0e823af57d63772c01cb06066e79c2ca0", + "size": 131736, + "subdir": "linux-64", + "timestamp": 1507787391378, + "version": "0.7.11" + }, + "pymysql-0.7.11-py36he04d08f_0.tar.bz2": { + "build": "py36he04d08f_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "969b82fa41181f3843f6ea6f8a3224ce", + "name": "pymysql", + "sha256": "167cbe618706ecfc595564647ac2a940aa5e8002ea1326aabc4f862bb1409acf", + "size": 131455, + "subdir": "linux-64", + "timestamp": 1507787392933, + "version": "0.7.11" + }, + "pymysql-0.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b67ce2786805dbd0e3949a47b6daae0", + "name": "pymysql", + "sha256": "85ded7b7353c10e2b155243e185155c0934f65c356cd684f9444e2224d707fee", + "size": 129604, + "subdir": "linux-64", + "timestamp": 1519674086704, + "version": "0.8.0" + }, + "pymysql-0.8.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "103d2f1cd493a1fbb0fd1bd1a3dac81b", + "name": "pymysql", + "sha256": "803ebe9f5d42079bb30d1bf59213c743ff4c4f59d257b611fa349d6224c4586c", + "size": 133300, + "subdir": "linux-64", + "timestamp": 1519674124830, + "version": "0.8.0" + }, + "pymysql-0.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8a3499f37ad1c46b710ffa8171a6a26", + "name": "pymysql", + "sha256": "9e59945bbeca7cb0d4a24ba2cbe0cef4fb4f14074394131d47ed4c02673c616b", + "size": 133105, + "subdir": "linux-64", + "timestamp": 1519674221314, + "version": "0.8.0" + }, + "pymysql-0.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f50e40e201e6a9962d65f3b2b94b4417", + "name": "pymysql", + "sha256": "b3cce43b565342518567ca59581fd594ba15203b24af5377663ab91c84ccdda3", + "size": 133802, + "subdir": "linux-64", + "timestamp": 1526497804582, + "version": "0.8.1" + }, + "pymysql-0.8.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a390c8a4665257ff8fa90a8d889ac87", + "name": "pymysql", + "sha256": "d82f8f5fb827a8c94f7e4cd1b170fbca5a9945138020561bdd23f26d665ed922", + "size": 137925, + "subdir": "linux-64", + "timestamp": 1526498615704, + "version": "0.8.1" + }, + "pymysql-0.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "613510ff9c85457d8f1ea453e4814317", + "name": "pymysql", + "sha256": "792ff7cc599ac89ffaa205f27575e6b657d9d15adc372d416cfa1456480a7630", + "size": 137255, + "subdir": "linux-64", + "timestamp": 1526497767336, + "version": "0.8.1" + }, + "pymysql-0.9.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1049b0b0f07443ec834d6b6bd50c8f9d", + "name": "pymysql", + "sha256": "870dcd266c2f15b3a03df72815d9db6957de10582afc1ebf187002c4e2b1322e", + "size": 138762, + "subdir": "linux-64", + "timestamp": 1530556629619, + "version": "0.9.1" + }, + "pymysql-0.9.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47106c82f2d88433df627d84f8b1797e", + "name": "pymysql", + "sha256": "e0f9064c41c5879332dbd162767c646b75f4df82a415366b3f93eb65dc77b575", + "size": 142851, + "subdir": "linux-64", + "timestamp": 1530556646574, + "version": "0.9.1" + }, + "pymysql-0.9.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fcc8b294e6370c053a340a9da8f7a068", + "name": "pymysql", + "sha256": "232cd5eaff24ba3b2a9892e22f0bca8a317e2e4578feddf79728411bee486c4f", + "size": 142133, + "subdir": "linux-64", + "timestamp": 1530556658873, + "version": "0.9.1" + }, + "pymysql-0.9.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "becd3cec4aa9064efed2e0eee7cd9e25", + "name": "pymysql", + "sha256": "5be23bc1bdbad4ccc55420d4432b26765f605943e805a1537d0f12dd9e9a8874", + "size": 141679, + "subdir": "linux-64", + "timestamp": 1530918060354, + "version": "0.9.1" + }, + "pymysql-0.9.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47fcf8d7a11284bd13b6b00d049676d4", + "name": "pymysql", + "sha256": "88a835debabd7345560c3b0fad842602220615166f5c4b151fdfcf5be41dadc9", + "size": 82550, + "subdir": "linux-64", + "timestamp": 1532541532285, + "version": "0.9.2" + }, + "pymysql-0.9.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2de5933a1ab82076cf572f1e55766afe", + "name": "pymysql", + "sha256": "bd1815d811d042d58ef9a456fa5337e39b4db4c665b395825beaf5266ef4df53", + "size": 83985, + "subdir": "linux-64", + "timestamp": 1532541570744, + "version": "0.9.2" + }, + "pymysql-0.9.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b438b10f60de6fa3e580d84e29a7ba73", + "name": "pymysql", + "sha256": "871b73bb8636ad27e9f039c71558df95eef00683bde9462d3aebd4fe2c7cc347", + "size": 83921, + "subdir": "linux-64", + "timestamp": 1532541455716, + "version": "0.9.2" + }, + "pymysql-0.9.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a77568266e9ec81a105ee4786166b65f", + "name": "pymysql", + "sha256": "229d741be4ed088eb42f23d1c7312cbe1413eb2e6dca8d53bd2995158a4e7097", + "size": 83859, + "subdir": "linux-64", + "timestamp": 1532541551289, + "version": "0.9.2" + }, + "pymysql-0.9.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb3d26b2af17c448f12c5dd22411099f", + "name": "pymysql", + "sha256": "09c540e0ad20f846c6bc8acb1ddb1900565f7ed16727ae4aa9acb6d61e4b0f7a", + "size": 84621, + "subdir": "linux-64", + "timestamp": 1574169767301, + "version": "0.9.2" + }, + "pymysql-0.9.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0c3cd74b0f2971369865f193d3510e3", + "name": "pymysql", + "sha256": "33ffedd810395c5a5f683705196bdd42c202171d49250fe3fffb289ba52c154f", + "size": 83476, + "subdir": "linux-64", + "timestamp": 1547248960631, + "version": "0.9.3" + }, + "pymysql-0.9.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ae4c564f8775f5e09d86fdb37c13fd05", + "name": "pymysql", + "sha256": "d13db53b5c91afdb91ffc8a8ec24283ac0e4fd1b30a50e9fe1b1b6d578e50088", + "size": 84785, + "subdir": "linux-64", + "timestamp": 1547249018189, + "version": "0.9.3" + }, + "pymysql-0.9.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f6b70e29c181ff5e5a623324105dc6c", + "name": "pymysql", + "sha256": "ee85da41364b192eb35567cf4e92a803fa1b323fa2df684303cd1a9dc68113ea", + "size": 84711, + "subdir": "linux-64", + "timestamp": 1547249015300, + "version": "0.9.3" + }, + "pymysql-1.0.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3de1fccba8e07da2ed336b5f0abc036e", + "name": "pymysql", + "sha256": "dfa5b029ed09b80a449267e684c422fa68cd038d24c23b9c289b7ffd2b7a6aee", + "size": 77831, + "subdir": "linux-64", + "timestamp": 1610132832731, + "version": "1.0.1" + }, + "pymysql-1.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2dbd794703bf9bc49cffdfcd14b037df", + "name": "pymysql", + "sha256": "1189befeb6b96851afe083b5794366c24833f1196f490e716918aca3e0c2c8e9", + "size": 77758, + "subdir": "linux-64", + "timestamp": 1610133121297, + "version": "1.0.1" + }, + "pymysql-1.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d5b6ce5fa676a4a630e49162d62178be", + "name": "pymysql", + "sha256": "12f5d4ef222c282b046dc325460516944171dc974f2e52b1c5c9e14b5538b83f", + "size": 78055, + "subdir": "linux-64", + "timestamp": 1610133123949, + "version": "1.0.1" + }, + "pymysql-1.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e10d4791398e6f7e6013ae70d4cc8f53", + "name": "pymysql", + "sha256": "eabc44c494608c77e583ba0c234210e2a8d4083ae7d13c47d22a217f3158c194", + "size": 78083, + "subdir": "linux-64", + "timestamp": 1610133131750, + "version": "1.0.1" + }, + "pymysql-1.0.2-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe83a4f66aa36e61e4800f571eef0761", + "name": "pymysql", + "sha256": "07bedb7e5062db88bd7b887cb424732e5953181c1255cbabbc0cef8480940c14", + "size": 78315, + "subdir": "linux-64", + "timestamp": 1640812762632, + "version": "1.0.2" + }, + "pymysql-1.0.2-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b23ecc82c37a49937a38b37ad838dc9", + "name": "pymysql", + "sha256": "af03fc2214fac6c65a2162eca0dda2a3d62bb778f298e7e3dfc1a6fc68702fdb", + "size": 99774, + "subdir": "linux-64", + "timestamp": 1676845352174, + "version": "1.0.2" + }, + "pymysql-1.0.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12933fb6838198b88d82baecc8fa29c5", + "name": "pymysql", + "sha256": "99d6c0a464affd5b5f0374054b28293af36652dd9cbad9ab8c33abf77b93af95", + "size": 77853, + "subdir": "linux-64", + "timestamp": 1610306260268, + "version": "1.0.2" + }, + "pymysql-1.0.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "30a3f7d49b10914bb2cfe3ec25633959", + "name": "pymysql", + "sha256": "2a6433dd0030566ec9683ad3d0eee26e8cd2a7673ca68e9d21c3e874a58ea479", + "size": 79493, + "subdir": "linux-64", + "timestamp": 1610482444959, + "version": "1.0.2" + }, + "pymysql-1.0.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb5481e1c0de0dfabc0b47ea3585b9d3", + "name": "pymysql", + "sha256": "36f829c5372a3ba5421a3dc46f1be34e5876765292f3f8a5e3f37a47300118cb", + "size": 77791, + "subdir": "linux-64", + "timestamp": 1610306267643, + "version": "1.0.2" + }, + "pymysql-1.0.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a504b3e4913486a62bc51434f8835e8", + "name": "pymysql", + "sha256": "e47e27bbb4297ce9c5f88667e1d95c0b7a259f97ee8e11ebde58bbdaf194dbba", + "size": 79296, + "subdir": "linux-64", + "timestamp": 1610482930069, + "version": "1.0.2" + }, + "pymysql-1.0.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2209661f0b42c9f3fac05fa7c4d4611", + "name": "pymysql", + "sha256": "88192d5c6de289b583e958412b880bffb42d419b09fbf7ff145b91306c4e3184", + "size": 78086, + "subdir": "linux-64", + "timestamp": 1610306270755, + "version": "1.0.2" + }, + "pymysql-1.0.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48b745de9b8360834ab38cd1edc30436", + "name": "pymysql", + "sha256": "4a30d528dec01cb5560d65276748d41fa981c21ee3d2b66ae5da079fe5ad1da7", + "size": 79604, + "subdir": "linux-64", + "timestamp": 1610482902483, + "version": "1.0.2" + }, + "pymysql-1.0.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1e66f83083c7da40af2bf4915d4c5cb", + "name": "pymysql", + "sha256": "aba81bb04a8c8ada0ae6b9c40755f98787cf15c07d821c7e9b641715d864b877", + "size": 78054, + "subdir": "linux-64", + "timestamp": 1610306236904, + "version": "1.0.2" + }, + "pymysql-1.0.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "615680ad006163e23d55e73d0171a077", + "name": "pymysql", + "sha256": "88b77274680c8151401c95cf6a4772bf9f55d05663ab3889b5412a0082fb9d4d", + "size": 79555, + "subdir": "linux-64", + "timestamp": 1610482941194, + "version": "1.0.2" + }, + "pynacl-1.2.0-py27hefb0b17_0.tar.bz2": { + "build": "py27hefb0b17_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9cd077c089c35909fffb9c985735fd45", + "name": "pynacl", + "sha256": "4d806d7651022d75abc02b81d8099f6458be2e0716ce52cf3ffecd01e437ad37", + "size": 1461639, + "subdir": "linux-64", + "timestamp": 1511037349389, + "version": "1.2.0" + }, + "pynacl-1.2.0-py35h9037bf7_0.tar.bz2": { + "build": "py35h9037bf7_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cfc2aa45cca533c8302914dc55299856", + "name": "pynacl", + "sha256": "d6da6793e73ffce3788c86fde316bdeb9203668eb5416c165b0f3fe1484ec02d", + "size": 1461166, + "subdir": "linux-64", + "timestamp": 1511037323666, + "version": "1.2.0" + }, + "pynacl-1.2.0-py36hb6d7a8d_0.tar.bz2": { + "build": "py36hb6d7a8d_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1ec148d1bcb055a4dc7205e0f0372575", + "name": "pynacl", + "sha256": "1466d33f0707e78931a184f0b02ca9f925049e99ba64ed52379b396b8258a585", + "size": 1461145, + "subdir": "linux-64", + "timestamp": 1511037348956, + "version": "1.2.0" + }, + "pynacl-1.2.1-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "474fa3fcfd9d422a0898bbfb77e217d5", + "name": "pynacl", + "sha256": "1267f30c6b196e83cccc0f1e3b0ad3e8c643de04b753b89e245dd80cae2c7bb9", + "size": 1312453, + "subdir": "linux-64", + "timestamp": 1522217633325, + "version": "1.2.1" + }, + "pynacl-1.2.1-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3c2823e2af9280314f20a23836bdf868", + "name": "pynacl", + "sha256": "7e49f2755910fae285fcdfe2becb1db50844a48a77c481d1d00000a3962f175e", + "size": 1312922, + "subdir": "linux-64", + "timestamp": 1522217729246, + "version": "1.2.1" + }, + "pynacl-1.2.1-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9c44ebbad36786256e2519d3f817a8a1", + "name": "pynacl", + "sha256": "fd30121e7d95d0498cf9be5e35e6443a0b5f36b7eb691255552935c27301d1e6", + "size": 1312540, + "subdir": "linux-64", + "timestamp": 1522217793044, + "version": "1.2.1" + }, + "pynacl-1.2.1-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "75fe009ce2fd2b1b937159084b347f47", + "name": "pynacl", + "sha256": "12e3b871f9d7901d6c882219bc2b992eb671f4c9409a303287bd7114a86fc398", + "size": 1314343, + "subdir": "linux-64", + "timestamp": 1530876018049, + "version": "1.2.1" + }, + "pynacl-1.3.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8d14de934e51f53750de4fc18cbef8f1", + "name": "pynacl", + "sha256": "87c06405e15b94ac1e05c1c51b6df3bae4ee875d5a6a63edb2c852c21049fe7e", + "size": 1369082, + "subdir": "linux-64", + "timestamp": 1539896370365, + "version": "1.3.0" + }, + "pynacl-1.3.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3d7edea401f545f64f5bffaf1ff5f341", + "name": "pynacl", + "sha256": "87796ad089642e88dfe840c4ea17ae6d34c0ba5f6294abf6117fefe17eb09b05", + "size": 1371492, + "subdir": "linux-64", + "timestamp": 1539896395373, + "version": "1.3.0" + }, + "pynacl-1.3.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6acf2509498e3a1047281f544dd7e3dc", + "name": "pynacl", + "sha256": "0602fe2008986d0f2b52d3fb922254d60dd35dee9814d84fcae5d5e2ddcc110b", + "size": 1371330, + "subdir": "linux-64", + "timestamp": 1539896397775, + "version": "1.3.0" + }, + "pynacl-1.3.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1c31002c74f0196e7763a0d02141a919", + "name": "pynacl", + "sha256": "81f663130ba92d5e6c08ea9ec58d61eea1b01a7c748be3239d598532d2db9a3e", + "size": 1374877, + "subdir": "linux-64", + "timestamp": 1574273734485, + "version": "1.3.0" + }, + "pynacl-1.4.0-py310h5eee18b_2.tar.bz2": { + "build": "py310h5eee18b_2", + "build_number": 2, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=11.2.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c7a51a42bdb75487d52adfbd44c2fc3c", + "name": "pynacl", + "sha256": "badc47b2abbbc6820ff482bcfae89052fd7db71429fe1425f11ad5d51f15dc32", + "size": 1453987, + "subdir": "linux-64", + "timestamp": 1659594701141, + "version": "1.4.0" + }, + "pynacl-1.4.0-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.5.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2bd8a06ea6665214304c2a1958c8fdcb", + "name": "pynacl", + "sha256": "5b8e9a0e661165a1a01cecb10161d08d364dfa66fec93a8c8c1c337d08b1f53c", + "size": 1470603, + "subdir": "linux-64", + "timestamp": 1640810354945, + "version": "1.4.0" + }, + "pynacl-1.4.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b3b6d612f997427c7a35f8029c066b72", + "name": "pynacl", + "sha256": "b5f0ff6843cf6a891216963a3e94da90b6e37905b2830e3e7ac3ef0a49ecfc00", + "size": 1405286, + "subdir": "linux-64", + "timestamp": 1593121752975, + "version": "1.4.0" + }, + "pynacl-1.4.0-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9fc8ed9d00be43c4091691b0f57495f5", + "name": "pynacl", + "sha256": "0626f62fa36d66bb27137a085897495d93b938751f2e8b2ffcd22f6d87b207f9", + "size": 1403028, + "subdir": "linux-64", + "timestamp": 1595009154590, + "version": "1.4.0" + }, + "pynacl-1.4.0-py37h5eee18b_2.tar.bz2": { + "build": "py37h5eee18b_2", + "build_number": 2, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=11.2.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fb04c12017b6fd6fdbe5f00b1e3f800d", + "name": "pynacl", + "sha256": "d71d2ef573e77b8b50e3b5c395e192213f5ab87ad8ffb14147bfb608cf82f728", + "size": 1387919, + "subdir": "linux-64", + "timestamp": 1659594745934, + "version": "1.4.0" + }, + "pynacl-1.4.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b2ff0dc8eb5c865a1398b78804cd7ff0", + "name": "pynacl", + "sha256": "757fbc87b2a726bb932f4497199b75cb9596be47a5ef6df63cdf7de27b3fe6cf", + "size": 1411107, + "subdir": "linux-64", + "timestamp": 1593121740259, + "version": "1.4.0" + }, + "pynacl-1.4.0-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "688d320fa654ce8934bcd600f2ba7315", + "name": "pynacl", + "sha256": "2311d442ead5c79860a58103a60411c6f9076eb96e312beff4670d6964f07937", + "size": 1392900, + "subdir": "linux-64", + "timestamp": 1595009192922, + "version": "1.4.0" + }, + "pynacl-1.4.0-py38h5eee18b_2.tar.bz2": { + "build": "py38h5eee18b_2", + "build_number": 2, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=11.2.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a98ce3c217829b4c2925e816c0c589c4", + "name": "pynacl", + "sha256": "e6d096038114c3cf2450603447aa8b06f7ebf1dd3548b7e2505fee68172fc508", + "size": 1386299, + "subdir": "linux-64", + "timestamp": 1659594790707, + "version": "1.4.0" + }, + "pynacl-1.4.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6ebc1a8b2b198cef0ca5698b5e04e3d3", + "name": "pynacl", + "sha256": "2a5787fd2f8a4dace1fe04215725533eeaaef645d854b03d97e3cfe0a71ca37e", + "size": 1389303, + "subdir": "linux-64", + "timestamp": 1593121760320, + "version": "1.4.0" + }, + "pynacl-1.4.0-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "924b3559e9cf94ff7c1ac2acfeed9043", + "name": "pynacl", + "sha256": "e20cd48b26a33dcb062b7540050c94a961210b7f3ecf29fcf1e2fc488da8b080", + "size": 1397354, + "subdir": "linux-64", + "timestamp": 1595009178996, + "version": "1.4.0" + }, + "pynacl-1.4.0-py39h5eee18b_2.tar.bz2": { + "build": "py39h5eee18b_2", + "build_number": 2, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=11.2.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f5fa9550530ad968d25c472fec3ca57e", + "name": "pynacl", + "sha256": "dfa0a5ed5c442c405eebeadeba27d6d31c921ea94893c2cbbf8d8bf9fe5f7a44", + "size": 1386538, + "subdir": "linux-64", + "timestamp": 1659594646221, + "version": "1.4.0" + }, + "pynacl-1.4.0-py39he8ac12f_1.tar.bz2": { + "build": "py39he8ac12f_1", + "build_number": 1, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b7934cb2ad2e6332f4faece69a4fb654", + "name": "pynacl", + "sha256": "a6d657cfd10bb280aabf91cbd02be4fef66212300a8df6b8816b178e4dc3c696", + "size": 1386880, + "subdir": "linux-64", + "timestamp": 1607611518057, + "version": "1.4.0" + }, + "pynacl-1.5.0-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=11.2.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a22e9bc6c41db8cd71b1d8e9cea5d12c", + "name": "pynacl", + "sha256": "4cc70242f4bb884d8cecc67b8b7d24e25db57b1cabcaf8e8e11283c61e34f7c5", + "size": 1484578, + "subdir": "linux-64", + "timestamp": 1659620748265, + "version": "1.5.0" + }, + "pynacl-1.5.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=11.2.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "823a60a2ef3566a98ce39155789f9dac", + "name": "pynacl", + "sha256": "4e395879f91ade054686bc683d0b6f0db960372b5cf3b31629096544781f83c6", + "size": 1423171, + "subdir": "linux-64", + "timestamp": 1676842280496, + "version": "1.5.0" + }, + "pynacl-1.5.0-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=11.2.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7907869b5945bc5b8192c2f8f02f9908", + "name": "pynacl", + "sha256": "a2341e076b7831e445f0a89630b8462f6efe32b5fa45fe2ad9226b6d82c86f08", + "size": 1418322, + "subdir": "linux-64", + "timestamp": 1659620841208, + "version": "1.5.0" + }, + "pynacl-1.5.0-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=11.2.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "991b648103227ae016ffeae7eadf44e1", + "name": "pynacl", + "sha256": "c5b581f6e54295c3da478b46c00b176ffcc5f5d2a8de97da3b7c7a5feb86b6e6", + "size": 1418292, + "subdir": "linux-64", + "timestamp": 1659620793306, + "version": "1.5.0" + }, + "pynacl-1.5.0-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=11.2.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ee893774b812746c15bbe8b58bb840e5", + "name": "pynacl", + "sha256": "d75089818bf8c932761124a6d44f1fae0a583f830d5dfc452e045f30550fa336", + "size": 1417843, + "subdir": "linux-64", + "timestamp": 1659620690810, + "version": "1.5.0" + }, + "pynio-1.5.0-py27h34504d7_1.tar.bz2": { + "build": "py27h34504d7_1", + "build_number": 1, + "depends": [ + "g2clib >=1.6.0,<1.7.0a0", + "jasper >=1.900.1,<2.0a0", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "proj4 >=4.9.3,<4.9.4.0a0", + "python >=2.7,<2.8.0a0", + "util-linux" + ], + "license": "BSD 3-clause", + "md5": "039980fc5442042d9ec23ae1f4591ebf", + "name": "pynio", + "sha256": "b7b95552690566de640dc99e2efbf48da292c35c7cc793e814217aa574800def", + "size": 2708456, + "subdir": "linux-64", + "timestamp": 1512149490790, + "version": "1.5.0" + }, + "pynio-1.5.0-py27h546be6d_1.tar.bz2": { + "build": "py27h546be6d_1", + "build_number": 1, + "depends": [ + "g2clib >=1.6.0,<1.7.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jasper >=2.0.14,<3.0a0", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "a6c5e514f0900791ddc27354ae7ba55c", + "name": "pynio", + "sha256": "46bc5dbe2d6ca1a2c6759410449453e4e99b7f38c89fc6d114fd9878b26ef226", + "size": 2708225, + "subdir": "linux-64", + "timestamp": 1531092851178, + "version": "1.5.0" + }, + "pynio-1.5.0-py27hce281da_1.tar.bz2": { + "build": "py27hce281da_1", + "build_number": 1, + "depends": [ + "g2clib >=1.6.0,<1.7.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jasper >=1.900.1,<2.0a0", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "b7ec95b09cf28584b22e7f93fa46eb48", + "name": "pynio", + "sha256": "bc493d058ad21d1c0c1582a9a87e5f2484084e1c8678c1c12fcea4895e75df39", + "size": 2704342, + "subdir": "linux-64", + "timestamp": 1530918727542, + "version": "1.5.0" + }, + "pynio-1.5.0-py27hd0d9455_1.tar.bz2": { + "build": "py27hd0d9455_1", + "build_number": 1, + "depends": [ + "g2clib >=1.6.0,<1.7.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=2.0.14,<3.0a0", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "305103179afa6bc41204150db20f6fc6", + "name": "pynio", + "sha256": "0144b71b2c829335ac5188b7cc3bda3f96fa196cfdf3905becda19528d9e389d", + "size": 2708193, + "subdir": "linux-64", + "timestamp": 1531093005190, + "version": "1.5.0" + }, + "pynio-1.5.0-py27hd2b2c5b_1.tar.bz2": { + "build": "py27hd2b2c5b_1", + "build_number": 1, + "depends": [ + "g2clib >=1.6.0,<1.7.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "jasper >=2.0.14,<3.0a0", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libgfortran-ng >=7,<8.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.35,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "proj4 >=5.2.0,<5.2.1.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "112848d3f98610763481ee5c0eb539cd", + "name": "pynio", + "sha256": "115f5d11ea100cc3f831832d577798ef4d4897d930cf5c1614e86cf77d75c124", + "size": 2725987, + "subdir": "linux-64", + "timestamp": 1545418834633, + "version": "1.5.0" + }, + "pynio-1.5.0-py27hf712402_1.tar.bz2": { + "build": "py27hf712402_1", + "build_number": 1, + "depends": [ + "g2clib >=1.6.0,<1.7.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=1.900.1,<2.0a0", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "fe244df68970a6be46f7b258058bd4ae", + "name": "pynio", + "sha256": "cc83d7ee7f8a23b03ac21cff73960319208d01e1fa6c3d9b660e7b4ebe0c808b", + "size": 2705159, + "subdir": "linux-64", + "timestamp": 1530918578369, + "version": "1.5.0" + }, + "pyo3-pack-0.3.6-h04498ad_0.tar.bz2": { + "build": "h04498ad_0", + "build_number": 0, + "depends": [], + "md5": "20bb52afb92131d84571414ecfc8b8f5", + "name": "pyo3-pack", + "sha256": "be409a64171a7344fdf79c6fea10e5c2b7de2a804d4c8f25f6f01c5c3bd5dc13", + "size": 3495169, + "subdir": "linux-64", + "timestamp": 1538425971869, + "version": "0.3.6" + }, + "pyodbc-4.0.17-py27h7f7627d_0.tar.bz2": { + "build": "py27h7f7627d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "unixodbc 2.3.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64149cd5e38c890e4d1a46b9a645eac6", + "name": "pyodbc", + "sha256": "f57f521e8739d16ec2f7b5d115b7a2161361a340f00b218c88152030d16b0d70", + "size": 59819, + "subdir": "linux-64", + "timestamp": 1505751926066, + "version": "4.0.17" + }, + "pyodbc-4.0.17-py35h89a430b_0.tar.bz2": { + "build": "py35h89a430b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "unixodbc 2.3.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f7a3e89dfcae347c10fa0e359cbed13c", + "name": "pyodbc", + "sha256": "8d211094911060d60853048865fee5c8f5e03762f16a891fd40806c1c72fff39", + "size": 58387, + "subdir": "linux-64", + "timestamp": 1505751946791, + "version": "4.0.17" + }, + "pyodbc-4.0.17-py36h999153c_0.tar.bz2": { + "build": "py36h999153c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "unixodbc 2.3.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d79f917905879214823610ba64dc0253", + "name": "pyodbc", + "sha256": "76c11456eb4f2a11c804e2fb4a0898140ce9645a0da7ef0ea1f8df2f23adc9bd", + "size": 58367, + "subdir": "linux-64", + "timestamp": 1505751967657, + "version": "4.0.17" + }, + "pyodbc-4.0.21-py27h5bedd64_0.tar.bz2": { + "build": "py27h5bedd64_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "unixodbc 2.3.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8b8b390dd76121982fa9628dabf7de84", + "name": "pyodbc", + "sha256": "9682be55969c7e0ecf1f7e1686c0dd6adf65aad5857017de9a7dee1e038816d2", + "size": 66579, + "subdir": "linux-64", + "timestamp": 1511322366620, + "version": "4.0.21" + }, + "pyodbc-4.0.21-py35hc2e132f_0.tar.bz2": { + "build": "py35hc2e132f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "unixodbc 2.3.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56e3f74af5361454bef1cadfffa05a7b", + "name": "pyodbc", + "sha256": "8a255d4248f5c4ea7c9c489fb93eb5762aaf418d5abc89799b993db95d05fc65", + "size": 64637, + "subdir": "linux-64", + "timestamp": 1511322447523, + "version": "4.0.21" + }, + "pyodbc-4.0.21-py36h083aac6_0.tar.bz2": { + "build": "py36h083aac6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "unixodbc 2.3.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef2fffd553b5678ff8b523d1dee89a65", + "name": "pyodbc", + "sha256": "b08d64fba2c7691d2de886e81521d79008e13c28f4076684f250f1c5d6d01dda", + "size": 64624, + "subdir": "linux-64", + "timestamp": 1511322447204, + "version": "4.0.21" + }, + "pyodbc-4.0.22-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "unixodbc 2.3.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48de6b81094d6e472b8f5f125de29f6c", + "name": "pyodbc", + "sha256": "1a879d45edc1a363e8480d79984968e0e8b12a5b5a7746836f7b35eba12ccad6", + "size": 66973, + "subdir": "linux-64", + "timestamp": 1516746939740, + "version": "4.0.22" + }, + "pyodbc-4.0.22-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "unixodbc 2.3.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9cf95a6a088a35e3410ce3ac98b98da", + "name": "pyodbc", + "sha256": "f12daeb3d5ec07d931d22299ee83f5bf653dacd4ba825ad00dc9c2fd8d9cbf6e", + "size": 65292, + "subdir": "linux-64", + "timestamp": 1516746963512, + "version": "4.0.22" + }, + "pyodbc-4.0.22-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "unixodbc 2.3.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f79c5b7762b79c44b1a65f55ad997837", + "name": "pyodbc", + "sha256": "d6818eefdff379a00b2a523546acae4c8e216b6cb46c2308473586f6d997fd7b", + "size": 65267, + "subdir": "linux-64", + "timestamp": 1516746980450, + "version": "4.0.22" + }, + "pyodbc-4.0.23-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb54d67b6cb4dcbe1be0507663714304", + "name": "pyodbc", + "sha256": "5e6b1c89ab60e7370de6bb6a46c7fcc947a025125bba444b8744f0a25a84ff02", + "size": 66401, + "subdir": "linux-64", + "timestamp": 1522880522569, + "version": "4.0.23" + }, + "pyodbc-4.0.23-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f4db42fab413a259742b37fa4b8e2dd", + "name": "pyodbc", + "sha256": "2698a5e601989d92f1e30dc3765db9b184eb0369bd438a0d5b7a05082ff041fb", + "size": 64465, + "subdir": "linux-64", + "timestamp": 1522880536387, + "version": "4.0.23" + }, + "pyodbc-4.0.23-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "610375d17a2e14a12fd8b2c80e472c97", + "name": "pyodbc", + "sha256": "45024291e70025d162a54b42362b977268e1fb719a07cf1b82b2bf9a2c01cc49", + "size": 64451, + "subdir": "linux-64", + "timestamp": 1522880574533, + "version": "4.0.23" + }, + "pyodbc-4.0.23-py37hf484d3e_0.tar.bz2": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "72e1b2f681e9511a5d7947fe305257fb", + "name": "pyodbc", + "sha256": "f3483b65c8e82f666d1c405d2d3f1d947cbfe0d775ef347ffdec53dee9204490", + "size": 64327, + "subdir": "linux-64", + "timestamp": 1530918779123, + "version": "4.0.23" + }, + "pyodbc-4.0.24-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "04e2b4098f587aded7e0dfb60775e703", + "name": "pyodbc", + "sha256": "f802e683c3093159d521593003808fc6de9413ad0d7a68460f6400f2e022ad03", + "size": 69369, + "subdir": "linux-64", + "timestamp": 1534951088153, + "version": "4.0.24" + }, + "pyodbc-4.0.24-py35he6710b0_0.tar.bz2": { + "build": "py35he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58ae19b33b2e8a70c8d46275dc7b8c68", + "name": "pyodbc", + "sha256": "41bf091600fd7fc25fce14fb4b69a41633431c23f3d6df2f551af58732bb83d3", + "size": 67217, + "subdir": "linux-64", + "timestamp": 1534954938387, + "version": "4.0.24" + }, + "pyodbc-4.0.24-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e528daf1456944ae5799fd69b7604bf5", + "name": "pyodbc", + "sha256": "03f559c6ddfd57cffa22a97518d2094fe2b44a0c6cd4e081ff779c92cf7bd538", + "size": 67195, + "subdir": "linux-64", + "timestamp": 1534951070979, + "version": "4.0.24" + }, + "pyodbc-4.0.24-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d087aebae5f853d1ce091cd6ff0fa0c", + "name": "pyodbc", + "sha256": "eb753c2907c2258a3501f637defb1b07ffa5057584f3ad32f3ea7f2ba5aaffc5", + "size": 67203, + "subdir": "linux-64", + "timestamp": 1534951057444, + "version": "4.0.24" + }, + "pyodbc-4.0.25-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c75a5a4661807c5f832ea006b3f6ab5", + "name": "pyodbc", + "sha256": "aa77116239a13591bfb9af556152e28810e5c3506cfa0a1dcd6879baf9b10d43", + "size": 72110, + "subdir": "linux-64", + "timestamp": 1545077265517, + "version": "4.0.25" + }, + "pyodbc-4.0.25-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "36b844c7f3c2d630c1d1a8826e933139", + "name": "pyodbc", + "sha256": "212ea23fd1240cc93de3fa054f559c118d78e854c70b03d7592c26f04957c1c1", + "size": 69950, + "subdir": "linux-64", + "timestamp": 1545077297172, + "version": "4.0.25" + }, + "pyodbc-4.0.25-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "289bfc2cb4b3efb955725e85675fe007", + "name": "pyodbc", + "sha256": "77a6b880c02709797faab5389622c53d6c5eaa1fa26b018eae6cb0392ecedfdf", + "size": 70027, + "subdir": "linux-64", + "timestamp": 1545077307772, + "version": "4.0.25" + }, + "pyodbc-4.0.26-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90461c7ab6c5850e5a02a87633ae7683", + "name": "pyodbc", + "sha256": "01e899fa67f32eb0bb3c4268453fc662f5e662965aefa6fe9d62b08d0cea4862", + "size": 72983, + "subdir": "linux-64", + "timestamp": 1551146584867, + "version": "4.0.26" + }, + "pyodbc-4.0.26-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4adf456087932b1fddece5630185e0b2", + "name": "pyodbc", + "sha256": "074b5c8a5c1aef83ff434a0366314213e600dfa0223e0a4136f8e39ad930044e", + "size": 70852, + "subdir": "linux-64", + "timestamp": 1551146600830, + "version": "4.0.26" + }, + "pyodbc-4.0.26-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ffacd642797a5640ba766fc9a5953a43", + "name": "pyodbc", + "sha256": "28fda17961b284c133890f247a195035352a3b885b410475fda5ada06018f580", + "size": 70874, + "subdir": "linux-64", + "timestamp": 1551146564456, + "version": "4.0.26" + }, + "pyodbc-4.0.27-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f11274444c74daed964d23d7546e023", + "name": "pyodbc", + "sha256": "e9c173492edfb9e2a71cec45992d087ad807208208966ea230c7a20f8ea378e4", + "size": 73737, + "subdir": "linux-64", + "timestamp": 1565963835447, + "version": "4.0.27" + }, + "pyodbc-4.0.27-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "65f53375947299d0c189b7aaad740c3d", + "name": "pyodbc", + "sha256": "42fa2179e3f593c32935752562936f40a8fcbe55bec883735e529d331b5534ac", + "size": 71675, + "subdir": "linux-64", + "timestamp": 1565963989813, + "version": "4.0.27" + }, + "pyodbc-4.0.27-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c873393e806522c34b1c15ec490a76e0", + "name": "pyodbc", + "sha256": "1f6ef638fae112fa996f0f94aeac861e5f82846340dfdc9484df94218ebeda04", + "size": 71668, + "subdir": "linux-64", + "timestamp": 1565963985104, + "version": "4.0.27" + }, + "pyodbc-4.0.27-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a86aef5527505075a07c1dcfe75a6de4", + "name": "pyodbc", + "sha256": "3aae4496daea0f68a63f39eab43e43b604d18ea5bb0aa79172e0a1cc7022e584", + "size": 78962, + "subdir": "linux-64", + "timestamp": 1573670109815, + "version": "4.0.27" + }, + "pyodbc-4.0.28-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c20897026b72aa903932a98ea5186d9f", + "name": "pyodbc", + "sha256": "9bfd59fe2682814547b441c638d5c954fc28997b475e4011d603a2e5fd14985a", + "size": 73308, + "subdir": "linux-64", + "timestamp": 1580401127207, + "version": "4.0.28" + }, + "pyodbc-4.0.28-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49e4f6e4134a8aa77ea1b8ba0bc2f8a2", + "name": "pyodbc", + "sha256": "43d287447ea11764a3a4f53e103d7af5ee4f81fa21cb124a463d336fbd12554e", + "size": 73331, + "subdir": "linux-64", + "timestamp": 1580401107573, + "version": "4.0.28" + }, + "pyodbc-4.0.28-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c684341747c7cbf8ac25f5311817fffa", + "name": "pyodbc", + "sha256": "d8600c4761c87584ff7a27bd2cf722cd2856153c961690e1f7c5bd2f14010a60", + "size": 74370, + "subdir": "linux-64", + "timestamp": 1580401183672, + "version": "4.0.28" + }, + "pyodbc-4.0.30-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c729f25fc60a072c6aa92b791ee4c3af", + "name": "pyodbc", + "sha256": "06b623d70c50587e2aa1bc8da42ab8afe33fc137a0f3299a55d2b471bd1e5df1", + "size": 73890, + "subdir": "linux-64", + "timestamp": 1581353547221, + "version": "4.0.30" + }, + "pyodbc-4.0.30-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "894979815505b9c9445fa49546b54efa", + "name": "pyodbc", + "sha256": "4eba3dffd2d03b9a4d596111c45b7ad9c06607fc8d8976f39b953403dadea235", + "size": 73963, + "subdir": "linux-64", + "timestamp": 1581353584710, + "version": "4.0.30" + }, + "pyodbc-4.0.30-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8670f92d430f74326b0b3552148227c6", + "name": "pyodbc", + "sha256": "c06358d2fa278b3d297b742b56ab8c973645cf37aacbaf31d04a1e4aebd20717", + "size": 74931, + "subdir": "linux-64", + "timestamp": 1581353596961, + "version": "4.0.30" + }, + "pyodbc-4.0.30-py39h66f3464_0.tar.bz2": { + "build": "py39h66f3464_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ef3958ea0468f6ae46951d8be2f0951", + "name": "pyodbc", + "sha256": "5dd6bcfa70d87a0c04bb9e16a0bffd530a09d46c0e7328c3f608ca3fd65f9dbe", + "size": 75206, + "subdir": "linux-64", + "timestamp": 1607570751918, + "version": "4.0.30" + }, + "pyodbc-4.0.31-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "151cc63b249939691a5e5de9df171ae5", + "name": "pyodbc", + "sha256": "064927527f8cf00794e80419ece11b5354204e633484ed6663cb2438a0f5ebba", + "size": 287837, + "subdir": "linux-64", + "timestamp": 1640793550702, + "version": "4.0.31" + }, + "pyodbc-4.0.31-py36h295c915_0.tar.bz2": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f98cbabb3217bada8a6b5536c22fb30", + "name": "pyodbc", + "sha256": "a3e21bbc79407bcdc79c92c1fdcad230c6871f0a66d625aeec132e260e9f78a9", + "size": 74155, + "subdir": "linux-64", + "timestamp": 1625471279763, + "version": "4.0.31" + }, + "pyodbc-4.0.31-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e91518cd53f25c9ca3a650dbcce5a11b", + "name": "pyodbc", + "sha256": "6bf753a0a96c2aaea314e1dc722caa7b584ca8895dad7ee7cd477036f7418ab1", + "size": 74182, + "subdir": "linux-64", + "timestamp": 1625471294263, + "version": "4.0.31" + }, + "pyodbc-4.0.31-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0aad8f01630e4db9d4f50eaf292471cc", + "name": "pyodbc", + "sha256": "3bf6b0e39169c942b8d3a62572cdd279a889d61d3071782ac743a1014ffc3f5b", + "size": 75276, + "subdir": "linux-64", + "timestamp": 1625471297274, + "version": "4.0.31" + }, + "pyodbc-4.0.31-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21e4652c9643356cd092cbc25ff33b60", + "name": "pyodbc", + "sha256": "6672f4289919d578f9da2cb10b58dd35719a1859f45fe806e81804e18aebd153", + "size": 75115, + "subdir": "linux-64", + "timestamp": 1625464635434, + "version": "4.0.31" + }, + "pyodbc-4.0.32-py310h295c915_1.tar.bz2": { + "build": "py310h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "144d14855edce7dca2b95c16aa730690", + "name": "pyodbc", + "sha256": "fcb849a873aa3fdae50722c2b61ce7aed02a7a1886485d7af0668d2f8dedb5b7", + "size": 291762, + "subdir": "linux-64", + "timestamp": 1647425958247, + "version": "4.0.32" + }, + "pyodbc-4.0.32-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "81ad0943f7990b761ccf1d98819ef607", + "name": "pyodbc", + "sha256": "577284d7143a7a28571bcd5ca3045ea3450f5c2cd38490521648457445af557f", + "size": 74981, + "subdir": "linux-64", + "timestamp": 1639688264356, + "version": "4.0.32" + }, + "pyodbc-4.0.32-py37h295c915_1.tar.bz2": { + "build": "py37h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb546627d80cebcc740c18f99aa45146", + "name": "pyodbc", + "sha256": "ddb5f1e25884cb4346ba93a8f957a710cfa12dc74ffd4b150aa333a361289e3f", + "size": 79650, + "subdir": "linux-64", + "timestamp": 1647425941458, + "version": "4.0.32" + }, + "pyodbc-4.0.32-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f48ea1f19ae8d0040e25287d7504083d", + "name": "pyodbc", + "sha256": "2ae7b0151c3b5eb923ca060871475e32235f7c3897e483ea983f875cc4d695fc", + "size": 76187, + "subdir": "linux-64", + "timestamp": 1639688294913, + "version": "4.0.32" + }, + "pyodbc-4.0.32-py38h295c915_1.tar.bz2": { + "build": "py38h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4485f6605ded630ee1768f4699284ce6", + "name": "pyodbc", + "sha256": "81f3c6ed8e90484cdb0d69a088ebde185d18b97e9963f4a31d0389de85225b71", + "size": 80716, + "subdir": "linux-64", + "timestamp": 1647408164471, + "version": "4.0.32" + }, + "pyodbc-4.0.32-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "55fe93958d5e56d633879dd00b22f38c", + "name": "pyodbc", + "sha256": "dce95ff9b09e06a1fd62d9630ef03c40fbd90b432e606686b70429589ab102f0", + "size": 75923, + "subdir": "linux-64", + "timestamp": 1639688233271, + "version": "4.0.32" + }, + "pyodbc-4.0.32-py39h295c915_1.tar.bz2": { + "build": "py39h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f50c95cfbc240dcc1e3d2f668d5fbfa4", + "name": "pyodbc", + "sha256": "35d2613d9af65e39eef342bf81b3f52e928a6bb6878b7844a280f3c1da2e0425", + "size": 80539, + "subdir": "linux-64", + "timestamp": 1647425941244, + "version": "4.0.32" + }, + "pyodbc-4.0.34-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT-0", + "license_family": "MIT", + "md5": "dd46683dce5bc0f82b0cb236d3b90f04", + "name": "pyodbc", + "sha256": "5cec950667adb05343b0b819106fd06527cca324a5f62d836035d96db91f76cb", + "size": 312998, + "subdir": "linux-64", + "timestamp": 1659513877591, + "version": "4.0.34" + }, + "pyodbc-4.0.34-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "unixodbc >=2.3.11,<2.4.0a0" + ], + "license": "MIT-0", + "license_family": "MIT", + "md5": "8b8fba0ba37bf6e20931bd12ef9a6968", + "name": "pyodbc", + "sha256": "ddc16587102b7167dcb5d5df70d06b623e42a9d0dd39e80942f910256b071622", + "size": 79134, + "subdir": "linux-64", + "timestamp": 1676861009230, + "version": "4.0.34" + }, + "pyodbc-4.0.34-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT-0", + "license_family": "MIT", + "md5": "67d09d4c065ee30126b60c6153c1eb7f", + "name": "pyodbc", + "sha256": "73524407238a1f6f524ae91bbb803a88994ea886fe96625d4641b3d636e57d7e", + "size": 78392, + "subdir": "linux-64", + "timestamp": 1659514004441, + "version": "4.0.34" + }, + "pyodbc-4.0.34-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT-0", + "license_family": "MIT", + "md5": "a7c429872ac8ce742137285afee0211c", + "name": "pyodbc", + "sha256": "4d23a00cca713b6273ea24a02e357450fbd52590a78e08dbb01e058f3b91cf4f", + "size": 79488, + "subdir": "linux-64", + "timestamp": 1659513919352, + "version": "4.0.34" + }, + "pyodbc-4.0.34-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT-0", + "license_family": "MIT", + "md5": "10e8d85f18c1def81bf465d5f33dc180", + "name": "pyodbc", + "sha256": "d78877dc193ae5c3a518114dc19479fb5e286c44e9914d6f71afd1d9684d5b33", + "size": 79536, + "subdir": "linux-64", + "timestamp": 1659513961362, + "version": "4.0.34" + }, + "pyomniscidb-5.6.2-py36hbca4264_0.tar.bz2": { + "build": "py36hbca4264_0", + "build_number": 0, + "depends": [ + "numpy >=1.16,<2.0a0", + "packaging >=20.0", + "python >=3.6,<3.7.0a0", + "rbc >=0.2.2", + "requests", + "setuptools", + "sqlalchemy >=1.3", + "thrift 0.13.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2899c9e9ff0c79fbb8cc37d5050c5a3c", + "name": "pyomniscidb", + "sha256": "3298f34db125185cec0ac1cec6f0bdfe73d543ade1830bd87dc0dc0758a5cf32", + "size": 504357, + "subdir": "linux-64", + "timestamp": 1626374470731, + "version": "5.6.2" + }, + "pyomniscidb-5.6.2-py37hbca4264_0.tar.bz2": { + "build": "py37hbca4264_0", + "build_number": 0, + "depends": [ + "numpy >=1.16,<2.0a0", + "packaging >=20.0", + "python >=3.7,<3.8.0a0", + "rbc >=0.2.2", + "requests", + "setuptools", + "sqlalchemy >=1.3", + "thrift 0.13.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "89c289e5465cf3102fa30e84abd616c5", + "name": "pyomniscidb", + "sha256": "faf4af195ce994870d1c7e095911b8c7b5824c0ec9db6308a8377f70111a7c78", + "size": 504361, + "subdir": "linux-64", + "timestamp": 1626374454149, + "version": "5.6.2" + }, + "pyomniscidb-5.6.2-py38hbca4264_0.tar.bz2": { + "build": "py38hbca4264_0", + "build_number": 0, + "depends": [ + "numpy >=1.16,<2.0a0", + "packaging >=20.0", + "python >=3.8,<3.9.0a0", + "rbc >=0.2.2", + "requests", + "setuptools", + "sqlalchemy >=1.3", + "thrift 0.13.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "469bc728cf0f9694240907f9b5504129", + "name": "pyomniscidb", + "sha256": "f0e8fca462eb2bf4363d8315bed37631f8a95ceb1b3384412a3a4fdc068f6e78", + "size": 508071, + "subdir": "linux-64", + "timestamp": 1626374505936, + "version": "5.6.2" + }, + "pyomniscidb-5.6.2-py39hbca4264_0.tar.bz2": { + "build": "py39hbca4264_0", + "build_number": 0, + "depends": [ + "numpy >=1.16,<2.0a0", + "packaging >=20.0", + "python >=3.9,<3.10.0a0", + "rbc >=0.2.2", + "requests", + "setuptools", + "sqlalchemy >=1.3", + "thrift 0.13.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7ea212e47e29f0625639ff9eec23807a", + "name": "pyomniscidb", + "sha256": "61460cc5854ab2bb52e160ea13b7da7e52ca8ea604a27a28505664371a3f14c8", + "size": 507902, + "subdir": "linux-64", + "timestamp": 1626374490939, + "version": "5.6.2" + }, + "pyomniscidb-5.7.0-py36hbca4264_0.tar.bz2": { + "build": "py36hbca4264_0", + "build_number": 0, + "depends": [ + "numpy >=1.16,<2.0a0", + "packaging >=20.0", + "python >=3.6,<3.7.0a0", + "requests", + "setuptools", + "sqlalchemy >=1.3", + "thrift 0.13.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3aa7eb3e9eca300f7dbb46d1ac82cf47", + "name": "pyomniscidb", + "sha256": "638654213adb71c3544e55e02a0c440eb5c376ec4199efea5446b00bfdd8be47", + "size": 145540, + "subdir": "linux-64", + "timestamp": 1630620428317, + "version": "5.7.0" + }, + "pyomniscidb-5.7.0-py37hbca4264_0.tar.bz2": { + "build": "py37hbca4264_0", + "build_number": 0, + "depends": [ + "numpy >=1.16,<2.0a0", + "packaging >=20.0", + "python >=3.7,<3.8.0a0", + "requests", + "setuptools", + "sqlalchemy >=1.3", + "thrift 0.13.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4ed800a5dd8f71d739e4ef6fafe2bab0", + "name": "pyomniscidb", + "sha256": "2ca84d1ae5a739356cf6e1ae8bb5fd26dc321beef99a437abc4ecf3bc3be0764", + "size": 145596, + "subdir": "linux-64", + "timestamp": 1630620436375, + "version": "5.7.0" + }, + "pyomniscidb-5.7.0-py38hbca4264_0.tar.bz2": { + "build": "py38hbca4264_0", + "build_number": 0, + "depends": [ + "numpy >=1.16,<2.0a0", + "packaging >=20.0", + "python >=3.8,<3.9.0a0", + "requests", + "setuptools", + "sqlalchemy >=1.3", + "thrift 0.13.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1138755c6ab0bf27d1163d847a52ebaf", + "name": "pyomniscidb", + "sha256": "7e0f89d68eb0bf727c2e42786ba9f932e5db866bc43dbae67bb08d28f019b9ab", + "size": 145400, + "subdir": "linux-64", + "timestamp": 1630620452790, + "version": "5.7.0" + }, + "pyomniscidb-5.7.0-py39hbca4264_0.tar.bz2": { + "build": "py39hbca4264_0", + "build_number": 0, + "depends": [ + "numpy >=1.16,<2.0a0", + "packaging >=20.0", + "python >=3.9,<3.10.0a0", + "requests", + "setuptools", + "sqlalchemy >=1.3", + "thrift 0.13.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "234dfb0a00717310ac998691897a905a", + "name": "pyomniscidb", + "sha256": "ca212d8501b5824611d945398a535fda2a1ecbbcc1dbbdf32bf8aea2dd674e2e", + "size": 145596, + "subdir": "linux-64", + "timestamp": 1630620444594, + "version": "5.7.0" + }, + "pyomniscidbe-5.10.1-py310h65c4a83_0.tar.bz2": { + "build": "py310h65c4a83_0", + "build_number": 0, + "constrains": [ + "pyarrow ==6.0.1" + ], + "depends": [ + "gflags >=2.2.2,<2.3.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.4.0", + "numpy >=1.16,<2.0a0", + "omniscidbe 5.10.1 py310h65c4a83_0", + "python >=3.10,<3.11.0a0", + "tbb4py", + "utf8proc" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "d8e6764422f3290c9bdf810f21b8eb5b", + "name": "pyomniscidbe", + "sha256": "e98492b144ddfa168981c47ed5b8a3d4fd6a56b9885585357c03d3c8cb45ce3d", + "size": 7905741, + "subdir": "linux-64", + "timestamp": 1658970383490, + "version": "5.10.1" + }, + "pyomniscidbe-5.10.1-py37h7744c1e_0.tar.bz2": { + "build": "py37h7744c1e_0", + "build_number": 0, + "constrains": [ + "pyarrow ==6.0.1" + ], + "depends": [ + "gflags >=2.2.2,<2.3.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.4.0", + "numpy >=1.16,<2.0a0", + "omniscidbe 5.10.1 py37h7744c1e_0", + "python >=3.7,<3.8.0a0", + "tbb4py", + "utf8proc" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "def0273b9657914b90d1fe89c60a1519", + "name": "pyomniscidbe", + "sha256": "fcc6d0ce26f58c3694102cf5f2c76ba192685c9d648a2dfd4e88bebda172f3c8", + "size": 7889255, + "subdir": "linux-64", + "timestamp": 1658970258957, + "version": "5.10.1" + }, + "pyomniscidbe-5.10.1-py38h7744c1e_0.tar.bz2": { + "build": "py38h7744c1e_0", + "build_number": 0, + "constrains": [ + "pyarrow ==6.0.1" + ], + "depends": [ + "gflags >=2.2.2,<2.3.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.4.0", + "numpy >=1.16,<2.0a0", + "omniscidbe 5.10.1 py38h7744c1e_0", + "python >=3.8,<3.9.0a0", + "tbb4py", + "utf8proc" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6400e2c0d664c296e8ffc61e18752eb2", + "name": "pyomniscidbe", + "sha256": "c4b6e13cecccd545d06a18d5c07c97621bf8cd840aa39718a2b066beb146d58f", + "size": 7992188, + "subdir": "linux-64", + "timestamp": 1658970322214, + "version": "5.10.1" + }, + "pyomniscidbe-5.10.1-py39h7744c1e_0.tar.bz2": { + "build": "py39h7744c1e_0", + "build_number": 0, + "constrains": [ + "pyarrow ==6.0.1" + ], + "depends": [ + "gflags >=2.2.2,<2.3.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.4.0", + "numpy >=1.16,<2.0a0", + "omniscidbe 5.10.1 py39h7744c1e_0", + "python >=3.9,<3.10.0a0", + "tbb4py", + "utf8proc" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c18957255727c50cda1e0eac807119c4", + "name": "pyomniscidbe", + "sha256": "027e19e2cf9aca3829094f338eb11790515fc4b9e6f15f545d99ef7ada165ec9", + "size": 7985876, + "subdir": "linux-64", + "timestamp": 1658970197374, + "version": "5.10.1" + }, + "pyomniscidbe-5.7.0-py36h14b4db5_0_cpu.tar.bz2": { + "build": "py36h14b4db5_0_cpu", + "build_number": 0, + "depends": [ + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "omniscidbe 5.7.0 h7185ff3_0_cpu", + "pyarrow 2.*", + "python >=3.6,<3.7.0a0", + "tbb >=2021.3.0", + "tbb4py" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "4b2bb486767b21cc37840bcbe4cffbd8", + "name": "pyomniscidbe", + "sha256": "bb0bfc79dfe324928e5577f6890185cc222e240481377a0e27b21671719692a8", + "size": 1997034, + "subdir": "linux-64", + "timestamp": 1630620897528, + "version": "5.7.0" + }, + "pyomniscidbe-5.7.0-py37h14b4db5_0_cpu.tar.bz2": { + "build": "py37h14b4db5_0_cpu", + "build_number": 0, + "depends": [ + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "omniscidbe 5.7.0 h7185ff3_0_cpu", + "pyarrow 2.*", + "python >=3.7,<3.8.0a0", + "tbb >=2021.3.0", + "tbb4py" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9c4186ce9089be1d1ae866ded2510811", + "name": "pyomniscidbe", + "sha256": "ab8acfea19809a4ff77fadc72d20f219e60e9128699c39b6baa9f3308c5178e8", + "size": 1994413, + "subdir": "linux-64", + "timestamp": 1630620961153, + "version": "5.7.0" + }, + "pyomniscidbe-5.7.0-py38h14b4db5_0_cpu.tar.bz2": { + "build": "py38h14b4db5_0_cpu", + "build_number": 0, + "depends": [ + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "omniscidbe 5.7.0 h7185ff3_0_cpu", + "pyarrow 2.*", + "python >=3.8,<3.9.0a0", + "tbb >=2021.3.0", + "tbb4py" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "007a52994109a64a8e82f73ca0cfed35", + "name": "pyomniscidbe", + "sha256": "b0a2161453ad51322d75f5ced1671ce0ca06eb07913301e27c8b9741126658ee", + "size": 2027266, + "subdir": "linux-64", + "timestamp": 1630621089097, + "version": "5.7.0" + }, + "pyomniscidbe-5.7.0-py39h14b4db5_0_cpu.tar.bz2": { + "build": "py39h14b4db5_0_cpu", + "build_number": 0, + "depends": [ + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "omniscidbe 5.7.0 h7185ff3_0_cpu", + "pyarrow 2.*", + "python >=3.9,<3.10.0a0", + "tbb >=2021.3.0", + "tbb4py" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "007ca037bf215e3ff16afecc4a95542e", + "name": "pyomniscidbe", + "sha256": "311d86cd298c69dec84214c99d1fd0143f034bba458f8b8c95c2b1405576050e", + "size": 2012490, + "subdir": "linux-64", + "timestamp": 1630621025165, + "version": "5.7.0" + }, + "pyomniscidbe-5.7.1-py36h14b4db5_0_cpu.tar.bz2": { + "build": "py36h14b4db5_0_cpu", + "build_number": 0, + "depends": [ + "fmt >=7.1.3,<8.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "omniscidbe 5.7.1 h7185ff3_0_cpu", + "pyarrow 3.*", + "python >=3.6,<3.7.0a0", + "tbb >=2021.3.0", + "tbb4py" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e4cd83d7ef850495ec05d0506e71e683", + "name": "pyomniscidbe", + "sha256": "edcbc11b1fbe5a446bf2e9878b0b261fad8bb874b332ed6796f369774c769d80", + "size": 1999381, + "subdir": "linux-64", + "timestamp": 1632952967572, + "version": "5.7.1" + }, + "pyomniscidbe-5.7.1-py37h14b4db5_0_cpu.tar.bz2": { + "build": "py37h14b4db5_0_cpu", + "build_number": 0, + "depends": [ + "fmt >=7.1.3,<8.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "omniscidbe 5.7.1 h7185ff3_0_cpu", + "pyarrow 3.*", + "python >=3.7,<3.8.0a0", + "tbb >=2021.3.0", + "tbb4py" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "0f2e0db8eab6d1723db23dea8dc06fc6", + "name": "pyomniscidbe", + "sha256": "78c40faef7c5dbaa7b83fdf8ff68e9c03f9b0b3604d813082f2e8063f18a53bc", + "size": 1997622, + "subdir": "linux-64", + "timestamp": 1632953094578, + "version": "5.7.1" + }, + "pyomniscidbe-5.7.1-py38h14b4db5_0_cpu.tar.bz2": { + "build": "py38h14b4db5_0_cpu", + "build_number": 0, + "depends": [ + "fmt >=7.1.3,<8.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "omniscidbe 5.7.1 h7185ff3_0_cpu", + "pyarrow 3.*", + "python >=3.8,<3.9.0a0", + "tbb >=2021.3.0", + "tbb4py" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b6a85953f12327ba90c1d51e8b6a7f8b", + "name": "pyomniscidbe", + "sha256": "3f9d47ee06fbbed1235dede69dd9e626427e103905f9c85d96a93bdf85c4f8be", + "size": 2017549, + "subdir": "linux-64", + "timestamp": 1632952904217, + "version": "5.7.1" + }, + "pyomniscidbe-5.7.1-py39h14b4db5_0_cpu.tar.bz2": { + "build": "py39h14b4db5_0_cpu", + "build_number": 0, + "depends": [ + "fmt >=7.1.3,<8.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "omniscidbe 5.7.1 h7185ff3_0_cpu", + "pyarrow 3.*", + "python >=3.9,<3.10.0a0", + "tbb >=2021.3.0", + "tbb4py" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ea5ecca684fa791a1a19c46b00886249", + "name": "pyomniscidbe", + "sha256": "8d3618fc0aff5bfc29d0f2978f7777353982a2d268308d8bdd9ea52823b56bb2", + "size": 2011563, + "subdir": "linux-64", + "timestamp": 1632953031135, + "version": "5.7.1" + }, + "pyopengl-3.1.1a1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-like", + "md5": "8e1a5fb749143508dea620799fa07170", + "name": "pyopengl", + "sha256": "daf000726c968c8d38032c0cbf4ec5767338ace4791a34a23e9a234344142357", + "size": 1350896, + "subdir": "linux-64", + "timestamp": 1530892135745, + "version": "3.1.1a1" + }, + "pyopengl-3.1.1a1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-like", + "md5": "5e11291b09f85aa3361ed27a7dfc6c55", + "name": "pyopengl", + "sha256": "24406dd10248ffa30aadf0cafa847cfe5c3dbb926430b243228bf858577a95aa", + "size": 1375774, + "subdir": "linux-64", + "timestamp": 1640793582866, + "version": "3.1.1a1" + }, + "pyopengl-3.1.1a1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-like", + "md5": "b24a27a8e6b5dc3302e7be0bbe6fcd0a", + "name": "pyopengl", + "sha256": "bfdd0f2b85af81c660e930e941d8f7356ce776da58a0759fd78e41c81daf53ed", + "size": 1601941, + "subdir": "linux-64", + "timestamp": 1676845382000, + "version": "3.1.1a1" + }, + "pyopengl-3.1.1a1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-like", + "md5": "1c1c452ce2bbbf6123b50e4c686194bb", + "name": "pyopengl", + "sha256": "ad30567551ff9353773657b868ec3ab0b5a0334f3a94b43859d5cfe2df7ea57f", + "size": 1315694, + "subdir": "linux-64", + "timestamp": 1530892009190, + "version": "3.1.1a1" + }, + "pyopengl-3.1.1a1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-like", + "md5": "80a6a6f5bd7d8a42efe678e8fff12b52", + "name": "pyopengl", + "sha256": "df2be137ebef370dfd3dc4e516272a387fb67bef280e51d7f4f4ff1a94ccb6ea", + "size": 1359330, + "subdir": "linux-64", + "timestamp": 1614326562182, + "version": "3.1.1a1" + }, + "pyopengl-3.1.1a1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-like", + "md5": "49929cfe8499cac893893e1849d74d31", + "name": "pyopengl", + "sha256": "90bbb66068e863996455d53aafaae55522582d776b5a722d6745d0f4c39f919d", + "size": 1319810, + "subdir": "linux-64", + "timestamp": 1530891820241, + "version": "3.1.1a1" + }, + "pyopengl-3.1.1a1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-like", + "md5": "16ca0a2c7dac8f47961914977c1646d2", + "name": "pyopengl", + "sha256": "262ede8028bc6ce0ec3a62641c62a429a49fcbb6eb7aa117e5e77aa36fd3687c", + "size": 1371325, + "subdir": "linux-64", + "timestamp": 1614326544799, + "version": "3.1.1a1" + }, + "pyopengl-3.1.1a1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-like", + "md5": "6c8aee338ee96b8d720c39375f2ac73b", + "name": "pyopengl", + "sha256": "21538af490ff94c47f719699d703b6717a55c28f160bef079999bfe041455846", + "size": 1375795, + "subdir": "linux-64", + "timestamp": 1573670156130, + "version": "3.1.1a1" + }, + "pyopengl-3.1.1a1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-like", + "md5": "0881cda25be87739ea1e8776ad7a68f4", + "name": "pyopengl", + "sha256": "3b88912ea532cd1aff7be01f05fa2ad2ac827b664bda49456d9baa2d8e88449f", + "size": 1362238, + "subdir": "linux-64", + "timestamp": 1614325984758, + "version": "3.1.1a1" + }, + "pyopengl-3.1.1a1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-like", + "md5": "425ff320c8a82fc9e1eb50b5f77ea2b8", + "name": "pyopengl", + "sha256": "ecd836429f06ee5d913fd498aa01d1fc4d7aa4c52ba2b71e4ea757fd5680392f", + "size": 1369551, + "subdir": "linux-64", + "timestamp": 1614325982261, + "version": "3.1.1a1" + }, + "pyopengl-accelerate-3.1.3b1-py27hdd07704_0.tar.bz2": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "freeglut", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pyopengl", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "0f52e89ec871311e0a75ace87f0df592", + "name": "pyopengl-accelerate", + "sha256": "bf7fd5d6caa72d533d509c477a23c17ec0d8b6294e399c1710f901919e2debb5", + "size": 373067, + "subdir": "linux-64", + "timestamp": 1539301235180, + "version": "3.1.3b1" + }, + "pyopengl-accelerate-3.1.3b1-py36hdd07704_0.tar.bz2": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "freeglut", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pyopengl", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "b9f223e4e355b3ce3d7b126b73577f6a", + "name": "pyopengl-accelerate", + "sha256": "d5afbf98b4a856ef927de9db80cd45818c5e0ca8237e4f3afe1bfafbd1d88d36", + "size": 391444, + "subdir": "linux-64", + "timestamp": 1539301216807, + "version": "3.1.3b1" + }, + "pyopengl-accelerate-3.1.3b1-py37hdd07704_0.tar.bz2": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "freeglut", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pyopengl", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "3c4f4c79acd0aef2c73bd531159baf16", + "name": "pyopengl-accelerate", + "sha256": "9aa7d30c4785051cfd30231ad3fe6955a05730975f38e7327b1ffd9532cb33ca", + "size": 391290, + "subdir": "linux-64", + "timestamp": 1539301215501, + "version": "3.1.3b1" + }, + "pyopengl-accelerate-3.1.3b1-py38hdd07704_0.tar.bz2": { + "build": "py38hdd07704_0", + "build_number": 0, + "depends": [ + "freeglut", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pyopengl", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "74a0af8260cdfc4e2c918537977eef2a", + "name": "pyopengl-accelerate", + "sha256": "086dee0e37069301d24636ed2444fceeacd732bfc20308ff30ab946b7c37ed9e", + "size": 420564, + "subdir": "linux-64", + "timestamp": 1574094218622, + "version": "3.1.3b1" + }, + "pyopenssl-17.2.0-py27h189ff3b_0.tar.bz2": { + "build": "py27h189ff3b_0", + "build_number": 0, + "depends": [ + "cryptography >=1.9", + "python >=2.7,<2.8.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7520979aecc8eaf5ffe4c833eb0892ff", + "name": "pyopenssl", + "sha256": "dbcdb478b7d48f44138899ec882bac4675ebe7e3af5ed041a63f72bfc86beefc", + "size": 77457, + "subdir": "linux-64", + "timestamp": 1505692953929, + "version": "17.2.0" + }, + "pyopenssl-17.2.0-py35h1d2a76c_0.tar.bz2": { + "build": "py35h1d2a76c_0", + "build_number": 0, + "depends": [ + "cryptography >=1.9", + "python >=3.5,<3.6.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "95783e719ab13ccfbebe6ac786695afd", + "name": "pyopenssl", + "sha256": "2ff7e5e291bbd8c8d4add836281375ca7561ff4f2a0b4897def5b87efbbd8d06", + "size": 79803, + "subdir": "linux-64", + "timestamp": 1505692966094, + "version": "17.2.0" + }, + "pyopenssl-17.2.0-py36h5cc804b_0.tar.bz2": { + "build": "py36h5cc804b_0", + "build_number": 0, + "depends": [ + "cryptography >=1.9", + "python >=3.6,<3.7.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d920a5cb1cdad2f9aa829d077f699c96", + "name": "pyopenssl", + "sha256": "3aa64ac266b16813154fb07c6cebebe68a8bebeb63f45bbd5f1e4beb058712dc", + "size": 79750, + "subdir": "linux-64", + "timestamp": 1505692978201, + "version": "17.2.0" + }, + "pyopenssl-17.4.0-py27h3149609_0.tar.bz2": { + "build": "py27h3149609_0", + "build_number": 0, + "depends": [ + "cryptography >=1.9", + "python >=2.7,<2.8.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e9b787c9595a62602e9effac732f11db", + "name": "pyopenssl", + "sha256": "c132fd9a0689ff957758934e6556c5d927227e9196a1fafce6ade7522f37b83d", + "size": 77477, + "subdir": "linux-64", + "timestamp": 1512039538759, + "version": "17.4.0" + }, + "pyopenssl-17.4.0-py35hb50ab36_0.tar.bz2": { + "build": "py35hb50ab36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.9", + "python >=3.5,<3.6.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1f109217a72a9987231b01016ba087ce", + "name": "pyopenssl", + "sha256": "e157c22ee0ef2827da1aafd1b6b84e8151b609b225bb62e09f91123bd1b2f2c4", + "size": 80058, + "subdir": "linux-64", + "timestamp": 1512039539051, + "version": "17.4.0" + }, + "pyopenssl-17.4.0-py36ha353062_0.tar.bz2": { + "build": "py36ha353062_0", + "build_number": 0, + "depends": [ + "cryptography >=1.9", + "python >=3.6,<3.7.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d82399bb042f8765338b1515b7ed2311", + "name": "pyopenssl", + "sha256": "8ca8d2f27def97b4e49e4e6688a202a3b69efd74ba91cb4274cc3414a9aca58e", + "size": 79692, + "subdir": "linux-64", + "timestamp": 1512039577326, + "version": "17.4.0" + }, + "pyopenssl-17.5.0-py27hcee3be0_0.tar.bz2": { + "build": "py27hcee3be0_0", + "build_number": 0, + "depends": [ + "cryptography >=2.1.4", + "python >=2.7,<2.8.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7089d938b3a9fc3e47723e61caad08ba", + "name": "pyopenssl", + "sha256": "41a9ac61bde8be9fc7935ed81109f362f9ad489fd97c9897bd7a566462dd0454", + "size": 78911, + "subdir": "linux-64", + "timestamp": 1512209094217, + "version": "17.5.0" + }, + "pyopenssl-17.5.0-py35h4f8b8c8_0.tar.bz2": { + "build": "py35h4f8b8c8_0", + "build_number": 0, + "depends": [ + "cryptography >=2.1.4", + "python >=3.5,<3.6.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "39ff34584d2d13a749c9812cb5b159bf", + "name": "pyopenssl", + "sha256": "e6aa10334c40e0af3101f4f25402fe5ac347a38a72c41f317604ccb4730fa3f9", + "size": 81067, + "subdir": "linux-64", + "timestamp": 1512209100107, + "version": "17.5.0" + }, + "pyopenssl-17.5.0-py36h20ba746_0.tar.bz2": { + "build": "py36h20ba746_0", + "build_number": 0, + "depends": [ + "cryptography >=2.1.4", + "python >=3.6,<3.7.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0ad9d3084995a4789a238141488282f4", + "name": "pyopenssl", + "sha256": "9e20bb5324b69d7e6fdf6a1ccc709e512754036c42ada88fa125dc6ed2810e8a", + "size": 81098, + "subdir": "linux-64", + "timestamp": 1512209109137, + "version": "17.5.0" + }, + "pyopenssl-18.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=2.2.1", + "python >=2.7,<2.8.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5ae067ce9da3f2a4c2f967d50cdf1257", + "name": "pyopenssl", + "sha256": "1881772681e4ad3c24122bda5b87cc37119d64319c47968b82968b2b3adfdfc8", + "size": 82138, + "subdir": "linux-64", + "timestamp": 1526617759133, + "version": "18.0.0" + }, + "pyopenssl-18.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography >=2.2.1", + "python >=3.5,<3.6.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "66ee4618c682354aee72626dd320cf44", + "name": "pyopenssl", + "sha256": "6219317640f9d7ac99c15610e154f60aadfc9aed5f844b4b95ac75400691198a", + "size": 84417, + "subdir": "linux-64", + "timestamp": 1526617799379, + "version": "18.0.0" + }, + "pyopenssl-18.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=2.2.1", + "python >=3.6,<3.7.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "df336513485c6a8f6d32bee9ef33e31d", + "name": "pyopenssl", + "sha256": "c13d6a01c3a9cb69cc9b7a1eedba6ee3173efaf263a7de1ae222d0f0bf85dc7a", + "size": 84345, + "subdir": "linux-64", + "timestamp": 1526617732222, + "version": "18.0.0" + }, + "pyopenssl-18.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=2.2.1", + "python >=3.7,<3.8.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ac5faaec2307b393c88604278a5cff75", + "name": "pyopenssl", + "sha256": "f25671d0d2b05a20210bbe574501dd9740c9148fcd720e3e51a86319d86b0674", + "size": 84406, + "subdir": "linux-64", + "timestamp": 1530733418334, + "version": "18.0.0" + }, + "pyopenssl-19.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=2.2.1", + "python >=2.7,<2.8.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "72951b25d31b76be78b03550ff24e36e", + "name": "pyopenssl", + "sha256": "b9c84769ff5b313f2beb67da6ccac062694f2e09dfe4c9bd9f29e4d5d614a606", + "size": 81437, + "subdir": "linux-64", + "timestamp": 1549324484847, + "version": "19.0.0" + }, + "pyopenssl-19.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=2.2.1", + "python >=3.6,<3.7.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6170bca0eba42d03cd864d8817da4503", + "name": "pyopenssl", + "sha256": "c59ed0567c44aab7e3b1be06c6ea8517127353c2c92f492c3bd1f369cb059d92", + "size": 83568, + "subdir": "linux-64", + "timestamp": 1549320612156, + "version": "19.0.0" + }, + "pyopenssl-19.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=2.2.1", + "python >=3.7,<3.8.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0bd4b0d483870a0e53066b4833ec57bf", + "name": "pyopenssl", + "sha256": "10b6c6785b25ad28542956cb9bff01c9f26d1b46709fae955b8237e5a6d2995c", + "size": 83770, + "subdir": "linux-64", + "timestamp": 1549320564648, + "version": "19.0.0" + }, + "pyopenssl-19.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cryptography >=2.2.1", + "python >=3.8,<3.9.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3fdfa57a8aeb70fadb76728d5d825ec7", + "name": "pyopenssl", + "sha256": "0efb050dd3006f99f91c50e98aea69cd3937d3fcdbc5b60b5048bc78c068afdb", + "size": 85651, + "subdir": "linux-64", + "timestamp": 1572857247102, + "version": "19.0.0" + }, + "pyopenssl-19.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=2.8", + "python >=2.7,<2.8.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "778c0e0f8c28d9e7ba75b8da45527419", + "name": "pyopenssl", + "sha256": "f81d89a13fef7f5108ce46f8275e396c4fcef1515cf4f281053349a9448b996b", + "size": 86609, + "subdir": "linux-64", + "timestamp": 1574266649282, + "version": "19.1.0" + }, + "pyopenssl-19.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=2.8", + "python >=3.6,<3.7.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "356b21322b72eaff03c26f0abdb658d7", + "name": "pyopenssl", + "sha256": "efc9ed461c086aab72e91c52778cbd78fc6afb3ef9ba670334ef195b30dde9e7", + "size": 88828, + "subdir": "linux-64", + "timestamp": 1574266587937, + "version": "19.1.0" + }, + "pyopenssl-19.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=2.8", + "python >=3.7,<3.8.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ed50bdd4a6a9c3045062170b43cecb3e", + "name": "pyopenssl", + "sha256": "6c72c92ce9ba91af2ed6f551a761e4ba3eec744b4a1665b411ec9873fd310ae1", + "size": 88985, + "subdir": "linux-64", + "timestamp": 1574266655259, + "version": "19.1.0" + }, + "pyopenssl-19.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cryptography >=2.8", + "python >=3.8,<3.9.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "656916205de2fb023778672ccf8baa8a", + "name": "pyopenssl", + "sha256": "6760bd4a7b28166574e37cd94699f8a7414ba6897cdf0e59d48d37072b2089e0", + "size": 89235, + "subdir": "linux-64", + "timestamp": 1574266592248, + "version": "19.1.0" + }, + "pyopenssl-23.0.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=38.0.0,<40", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2ec32c4ef40155b121377a5237de1dea", + "name": "pyopenssl", + "sha256": "a7204f9b3b4c5ca2f4e114429cdc9b2c9ab1bedeeceb214dbcde2d2387ac32f1", + "size": 91800, + "subdir": "linux-64", + "timestamp": 1677607766376, + "version": "23.0.0" + }, + "pyopenssl-23.0.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=38.0.0,<40", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e8e863853122726cc50b425ee26af8f3", + "name": "pyopenssl", + "sha256": "af64d5c432e9357d6bcdff52c2d23f276745955a110844942b78c21b10bdb436", + "size": 113885, + "subdir": "linux-64", + "timestamp": 1678965327040, + "version": "23.0.0" + }, + "pyopenssl-23.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=38.0.0,<40", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1b8e8997eae24265e31ac4a099aa82f6", + "name": "pyopenssl", + "sha256": "2e05ddc0b3fcaf9e4adfe4536264c4fe3c007a13183db6f15619d71ec13e6034", + "size": 90889, + "subdir": "linux-64", + "timestamp": 1677607715479, + "version": "23.0.0" + }, + "pyopenssl-23.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=38.0.0,<40", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "27f52f2baba92143b1c310c6c499a572", + "name": "pyopenssl", + "sha256": "a61e0f565dba800a08cd22305f24df6de63eda1ae0131da7e4684771a0036e1d", + "size": 91575, + "subdir": "linux-64", + "timestamp": 1677607791388, + "version": "23.0.0" + }, + "pyopenssl-23.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=38.0.0,<40", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a880f1c36bd82c146bad4e3467686688", + "name": "pyopenssl", + "sha256": "4eb83dfcb9a3d0fcff4138fcee28bfb643dffa7915f88865c9202b71f7b8c001", + "size": 91293, + "subdir": "linux-64", + "timestamp": 1677607740909, + "version": "23.0.0" + }, + "pypandoc-1.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pandoc", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f1365495e5879a9c3e6a9ce0ac6a2cd0", + "name": "pypandoc", + "sha256": "ae6b3608ec0451642610dba51db6d8118beb25ad3869c948b8b51b7da153a57d", + "size": 23510, + "subdir": "linux-64", + "timestamp": 1530919978851, + "version": "1.4" + }, + "pypandoc-1.4-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pandoc", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "799a8a4d08e6ccd60dd33123b4d0f2ae", + "name": "pypandoc", + "sha256": "1b8c0f06ed3b223009fae5b2d570dab9e118cb54f821fdbfee218451bf580f0c", + "size": 26244, + "subdir": "linux-64", + "timestamp": 1539183960017, + "version": "1.4" + }, + "pypandoc-1.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pandoc", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "77ac2bf91c5fc41542b71c0bf2196811", + "name": "pypandoc", + "sha256": "2765c6a007c89332ae3a15300570be0d8db9810e4d6510c4cd258ab2441f1e74", + "size": 23678, + "subdir": "linux-64", + "timestamp": 1530919921131, + "version": "1.4" + }, + "pypandoc-1.4-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pandoc", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "42e32e9eded6987bdadea8655fc842fa", + "name": "pypandoc", + "sha256": "ff85b2d40880ae7c832b0b85398c84ca7a4d3b9320a7237a829a1df6a8bfbd2e", + "size": 26389, + "subdir": "linux-64", + "timestamp": 1539183989457, + "version": "1.4" + }, + "pypandoc-1.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pandoc", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7e8704bdae4d5a0ed275e16c0582dfbd", + "name": "pypandoc", + "sha256": "1d5675bf0a3c3e4d5b79e0c3c1c0dfcd6479f05caa3374e7c05f3c7475bb6548", + "size": 23672, + "subdir": "linux-64", + "timestamp": 1530919950280, + "version": "1.4" + }, + "pypandoc-1.4-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pandoc", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f55c19ff1d0ac6bad07b961eec25ef03", + "name": "pypandoc", + "sha256": "8cd778ec3c90150f20d74c60dd0b303f3dac799c5b7e753916e8114df4d05173", + "size": 26399, + "subdir": "linux-64", + "timestamp": 1539183982358, + "version": "1.4" + }, + "pyparsing-2.2.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "3b3d9b874901c5cf360396e3d9fb6d43", + "name": "pyparsing", + "sha256": "0b6fcef3f21631e0e04cd92d35473397b76865c610f193bf1ae0fb97b2cd1a3e", + "size": 95882, + "subdir": "linux-64", + "timestamp": 1530694938918, + "version": "2.2.0" + }, + "pyparsing-2.2.0-py27hf1513f8_1.tar.bz2": { + "build": "py27hf1513f8_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "30370cc591a29eb1422b8ad50edfe220", + "name": "pyparsing", + "sha256": "4fa60d62c3779f911d3e99e876f15712a71e6135e2dd74aa914b86f352405c1c", + "size": 95658, + "subdir": "linux-64", + "timestamp": 1505733480948, + "version": "2.2.0" + }, + "pyparsing-2.2.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "0082f8285ce3941426e116b285099d5a", + "name": "pyparsing", + "sha256": "6d4d713adc687aef854bd68fa77e04fe59a8e9f6220b612fc521de9ee73373bd", + "size": 98481, + "subdir": "linux-64", + "timestamp": 1534345458213, + "version": "2.2.0" + }, + "pyparsing-2.2.0-py35h041ed72_1.tar.bz2": { + "build": "py35h041ed72_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "a9695e3291b6e7cd439e8de6611e5b68", + "name": "pyparsing", + "sha256": "4b4bdd268252f74cd05020fec28fe0b88c777dc4d45329ff819551fd7e21ca66", + "size": 98280, + "subdir": "linux-64", + "timestamp": 1505733492733, + "version": "2.2.0" + }, + "pyparsing-2.2.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "5f8817d96f72769f0bdb3d4ed288f5a2", + "name": "pyparsing", + "sha256": "9e8c70bda12653c9e235297af99289e50829130c95012b2286b7aca624f52d6c", + "size": 98296, + "subdir": "linux-64", + "timestamp": 1530694901316, + "version": "2.2.0" + }, + "pyparsing-2.2.0-py36hee85983_1.tar.bz2": { + "build": "py36hee85983_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4ae513648760e5c23a1f57c79a39bff5", + "name": "pyparsing", + "sha256": "657a8106cdd112a7516e3f907ea14e06e4b9086faeb918a32932a5d0662faa05", + "size": 98120, + "subdir": "linux-64", + "timestamp": 1505733504669, + "version": "2.2.0" + }, + "pyparsing-2.2.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6e34589dc03fde23876a23431df16885", + "name": "pyparsing", + "sha256": "ece119027e9c00d4a6f2509e65c766c654964d377e521e5dc6bcecdcbef1beac", + "size": 98557, + "subdir": "linux-64", + "timestamp": 1530694920560, + "version": "2.2.0" + }, + "pyparsing-2.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "1b1bddb69932ddb06e7f614e6a8dc615", + "name": "pyparsing", + "sha256": "dc60b79e862adc248d4dc5de5780f90d0f4da692a9008fa74f93b3a01d8cab27", + "size": 95295, + "subdir": "linux-64", + "timestamp": 1538231886832, + "version": "2.2.1" + }, + "pyparsing-2.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "679c89e521298b3e14db4075528129a6", + "name": "pyparsing", + "sha256": "171742d0d5f8ffa04f7f48a831a75ae502e1494dbd3bd2ef7c8fef81015f416b", + "size": 97839, + "subdir": "linux-64", + "timestamp": 1538231896327, + "version": "2.2.1" + }, + "pyparsing-2.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b0d2f3f057952e3b7a16d22804a8b403", + "name": "pyparsing", + "sha256": "ad2d81062b64e4f095156b55c7548e4158cda53a6689a6563f7f7deaefef6705", + "size": 97897, + "subdir": "linux-64", + "timestamp": 1538231882848, + "version": "2.2.1" + }, + "pyparsing-2.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a0bff36947052732b6ba024b67227ab0", + "name": "pyparsing", + "sha256": "0347b8d8bfc04a6ba9a8a2f1906a0cfb4ccf78589b74553b8d68e61c206bcb71", + "size": 98063, + "subdir": "linux-64", + "timestamp": 1538231849801, + "version": "2.2.1" + }, + "pyparsing-2.2.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "96af6f24238fc74eb63692d943dfd59a", + "name": "pyparsing", + "sha256": "ec1927359d5885491fa7918ee4cdd5306825f9c36235fac965e8796fcbc7728d", + "size": 97141, + "subdir": "linux-64", + "timestamp": 1539023711959, + "version": "2.2.2" + }, + "pyparsing-2.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9f7b0f6cad4222dfe96c3a7593fdea4b", + "name": "pyparsing", + "sha256": "1365aa98a0b5ecfeb11dd2f4fb8d9189b5bc2f967c445c9c7d39c2d28098f6a3", + "size": 99666, + "subdir": "linux-64", + "timestamp": 1539023732310, + "version": "2.2.2" + }, + "pyparsing-2.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "0e1b7c4eef6ad80deff4af982e3910f0", + "name": "pyparsing", + "sha256": "75b1f3ccacce725e85989726ab4c0a12b10b1106dd447219385a018cac051d14", + "size": 99838, + "subdir": "linux-64", + "timestamp": 1539023673569, + "version": "2.2.2" + }, + "pyparsing-2.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d37d04c020dab4d3b30ea0013c29aa71", + "name": "pyparsing", + "sha256": "82b41f3d86bd136200edbec5b6dc9243de4b15a3333221ab20171b47cd86ed64", + "size": 100971, + "subdir": "linux-64", + "timestamp": 1541449664875, + "version": "2.3.0" + }, + "pyparsing-2.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b7a721c832e24b6656342437930870a3", + "name": "pyparsing", + "sha256": "3be37df3d71afd525673242779e60cf0f9e22daa37afb69a936191a71b84850a", + "size": 103783, + "subdir": "linux-64", + "timestamp": 1541449692701, + "version": "2.3.0" + }, + "pyparsing-2.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3949d5a5126c1b39234cbb6f5d7794bb", + "name": "pyparsing", + "sha256": "49f2fff14dee24ce8706ba92f5ac4c38414ec2227a4c4fea150e58cd02a30c8a", + "size": 103679, + "subdir": "linux-64", + "timestamp": 1541449615610, + "version": "2.3.0" + }, + "pyparsing-2.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f89154a257fd8a3dc29ebaaa33867394", + "name": "pyparsing", + "sha256": "b176f7610f5cb682d6638d799a138dcb687553dd2aa4edf8fd6075806b77fe84", + "size": 104641, + "subdir": "linux-64", + "timestamp": 1547905235180, + "version": "2.3.1" + }, + "pyparsing-2.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7ca0b7d65aa83355ed785fd453522454", + "name": "pyparsing", + "sha256": "0d3dc9e9f5801ad2fb520f0e0583c024ef761a2214d05a3bd76f15cf46b7a1c8", + "size": 107824, + "subdir": "linux-64", + "timestamp": 1547905283848, + "version": "2.3.1" + }, + "pyparsing-2.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ed36dce12d90dc1d5e107552735cbe8e", + "name": "pyparsing", + "sha256": "6bb439c4e0b451234a5fdc650d7b727f5e6b4ef729f9032dd93e4373b58a4f47", + "size": 107431, + "subdir": "linux-64", + "timestamp": 1547905315034, + "version": "2.3.1" + }, + "pyparsing-3.0.9-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "683beb480351e058d66b538273fbfb8a", + "name": "pyparsing", + "sha256": "853b025e248d71d2f09ec9422b76c09cb46fdedd9a065295dd9305dac36aa286", + "size": 158193, + "subdir": "linux-64", + "timestamp": 1661452647484, + "version": "3.0.9" + }, + "pyparsing-3.0.9-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b1ac40e0df3673d33b7f4c4f93ae1ef", + "name": "pyparsing", + "sha256": "ad219924e362ce7af458fa6547660181579e9a50e5aed1ffd9268cbe7c2650e3", + "size": 207338, + "subdir": "linux-64", + "timestamp": 1677811584327, + "version": "3.0.9" + }, + "pyparsing-3.0.9-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f8ea27b7b51728ea29d1712d96d1006", + "name": "pyparsing", + "sha256": "5805af147cb6766a97219062a4008bda1db3db41c0c00b1080d8cb6f6c7c65bb", + "size": 155385, + "subdir": "linux-64", + "timestamp": 1661452674259, + "version": "3.0.9" + }, + "pyparsing-3.0.9-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b47e7fcdef58cc3b2b8d920c73819e19", + "name": "pyparsing", + "sha256": "97972579f3c079aab5fb9a58855caded3b268bf90c0afdf5e6f39d75edd9a699", + "size": 156616, + "subdir": "linux-64", + "timestamp": 1661452605147, + "version": "3.0.9" + }, + "pyparsing-3.0.9-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ffceed627867508d73af1636ab5ebf42", + "name": "pyparsing", + "sha256": "a26d077b2439153277868702c690ae2f61a9bac7254a39c70094d522fafc329d", + "size": 156324, + "subdir": "linux-64", + "timestamp": 1661452578573, + "version": "3.0.9" + }, + "pypdf2-2.10.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2074ecfcc3dbed51b0d5b7f964a26987", + "name": "pypdf2", + "sha256": "f1dd6690467d9df2eaae4ad071922515947174fb863a47edc0df5192b3afa1b6", + "size": 474861, + "subdir": "linux-64", + "timestamp": 1662469771462, + "version": "2.10.5" + }, + "pypdf2-2.10.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "613a3625e3fb2a1d3de9d13b9bad10b6", + "name": "pypdf2", + "sha256": "ff6c9fdeb59d9546bb98154c557abd13a6ddf7d88b679ff37df79e6b303f1dd4", + "size": 561178, + "subdir": "linux-64", + "timestamp": 1679340434145, + "version": "2.10.5" + }, + "pypdf2-2.10.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.10" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8ae0a8b7d7b3c865cbbb390642e0fd04", + "name": "pypdf2", + "sha256": "228e24118fce2ff1998d2fe7d4413a98866cc6d1bddf23c395e66e140fcaedfd", + "size": 396771, + "subdir": "linux-64", + "timestamp": 1662469834085, + "version": "2.10.5" + }, + "pypdf2-2.10.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "typing_extensions >=3.10" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "632e819cefd88f3f728bd5ce61d5ea48", + "name": "pypdf2", + "sha256": "4c5cac61d300c9fc3cb0304f4d42de3613671ad54bb38ea06965b8531b3c8638", + "size": 397863, + "subdir": "linux-64", + "timestamp": 1662469719719, + "version": "2.10.5" + }, + "pypdf2-2.10.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "typing_extensions >=3.10" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6383c7c5ef0a8f6f1cfe599c8b1b38f1", + "name": "pypdf2", + "sha256": "1f377f738d0cba2e753da453617b96284f1d06d2519b31617778a3cd1da962cf", + "size": 397167, + "subdir": "linux-64", + "timestamp": 1662469803867, + "version": "2.10.5" + }, + "pyppmd-0.16.1-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ac228fe82f111cbc023ae935824b6165", + "name": "pyppmd", + "sha256": "cf208c169949dc66f92295b5a6fbbce6d7a1f0379d9bdd5d5cc2c4d05e36505f", + "size": 114970, + "subdir": "linux-64", + "timestamp": 1640810432412, + "version": "0.16.1" + }, + "pyppmd-0.16.1-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e26d3dc8fb4b94858245680dd3240d96", + "name": "pyppmd", + "sha256": "74e7a1303c7b2bf75afbef23d41ffdd9f0c791febd6db56834ed540430edbeb3", + "size": 46969, + "subdir": "linux-64", + "timestamp": 1676861044874, + "version": "0.16.1" + }, + "pyppmd-0.16.1-py36h295c915_0.tar.bz2": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d576bd15b2b5d7d44f6b03d134496c54", + "name": "pyppmd", + "sha256": "bbb2b8ee32edb443603e2f1707c15bc3b3bbe2fd7950ac478ca9210557338914", + "size": 45338, + "subdir": "linux-64", + "timestamp": 1633095397290, + "version": "0.16.1" + }, + "pyppmd-0.16.1-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "28c1489d257832259dc074f375f2d600", + "name": "pyppmd", + "sha256": "862f202de5844bafaebdfb32307517a075df289d43c641e4e733c15b4e48ed03", + "size": 45274, + "subdir": "linux-64", + "timestamp": 1633084854596, + "version": "0.16.1" + }, + "pyppmd-0.16.1-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "02bf82e3daf2f42c77549616792d2828", + "name": "pyppmd", + "sha256": "51267a048ad1dfda95b3cb38aff4b9e0e123c82364a6d41198aee2affdf28422", + "size": 45528, + "subdir": "linux-64", + "timestamp": 1633095378665, + "version": "0.16.1" + }, + "pyppmd-0.16.1-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "dc9e581a60b0e4946d2432c113ceade2", + "name": "pyppmd", + "sha256": "7084d25b5927d16956182161d1094ac86e20b741fa092504d52ea06925adfcf0", + "size": 45499, + "subdir": "linux-64", + "timestamp": 1633095372072, + "version": "0.16.1" + }, + "pyprof2calltree-1.4.3-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "qcachegrind" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5618612fb01f6b178f14dc40b71f9b49", + "name": "pyprof2calltree", + "sha256": "1b5af828510083d855ec1ea25f07803d60a173a99c69a1bb97d14bf18bc932f2", + "size": 14931, + "subdir": "linux-64", + "timestamp": 1539290058904, + "version": "1.4.3" + }, + "pyprof2calltree-1.4.3-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "qcachegrind" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "30d7330a34118b20e6e34554cc55a96d", + "name": "pyprof2calltree", + "sha256": "165ad4f606a423abab9825503163d63288ec2598281e000434ab47ee238da46c", + "size": 14992, + "subdir": "linux-64", + "timestamp": 1539290066597, + "version": "1.4.3" + }, + "pyprof2calltree-1.4.3-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "qcachegrind" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d305bb7749201bf838f8823f5047267e", + "name": "pyprof2calltree", + "sha256": "97b0a692c81478f949f54016a14ce4fa8873303744c8361e54f233990a3325e3", + "size": 15041, + "subdir": "linux-64", + "timestamp": 1539290064193, + "version": "1.4.3" + }, + "pyprof2calltree-1.4.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "qcachegrind" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a4544cb5216be4670c44e837612895d", + "name": "pyprof2calltree", + "sha256": "4808d9f500d9a1d1fa362130551bcbb97a4b6adce886a8bae0f4feb11f2798dc", + "size": 15487, + "subdir": "linux-64", + "timestamp": 1541026740920, + "version": "1.4.4" + }, + "pyprof2calltree-1.4.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "qcachegrind" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c83f14c3b855d4778fa97f887e53610", + "name": "pyprof2calltree", + "sha256": "de8012c71a5bdba02161dafb26c6bf7708d97a75ac0c9b0982e45e91fd98648a", + "size": 16067, + "subdir": "linux-64", + "timestamp": 1640793604784, + "version": "1.4.4" + }, + "pyprof2calltree-1.4.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "qcachegrind" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f3e7a1c77e9497b808f744122910311", + "name": "pyprof2calltree", + "sha256": "2fd60eb475505862c3e407f379f64aab5cda65f9dbb89cbe267834d36599e8b1", + "size": 19550, + "subdir": "linux-64", + "timestamp": 1676907569065, + "version": "1.4.4" + }, + "pyprof2calltree-1.4.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "qcachegrind" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f5c2e8ebbca48ec15c0e356737e30b3", + "name": "pyprof2calltree", + "sha256": "2901bf0ca97ea6075246f6aadfe0f65ec25728f90ed536f30027512b86ba33ed", + "size": 15567, + "subdir": "linux-64", + "timestamp": 1541026717011, + "version": "1.4.4" + }, + "pyprof2calltree-1.4.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "qcachegrind" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa13d89afe4043e49a3731141bdfb1ec", + "name": "pyprof2calltree", + "sha256": "48cf622b15ee9230d76516864e5304e98cc298011efbcf7ea4143c15955dd435", + "size": 15537, + "subdir": "linux-64", + "timestamp": 1541026734883, + "version": "1.4.4" + }, + "pyprof2calltree-1.4.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "qcachegrind" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "99be767bd9d19b94ddda7dccdec9990c", + "name": "pyprof2calltree", + "sha256": "aa26b497afab8bf4f0aea1554423d769425a2b8376a3ae7f2e8deefb8ad63e41", + "size": 15830, + "subdir": "linux-64", + "timestamp": 1573200338885, + "version": "1.4.4" + }, + "pyprof2calltree-1.4.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "qcachegrind" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f644fd20d26c40882def31c3828909b3", + "name": "pyprof2calltree", + "sha256": "0ec52c4ab2d7550ce26167c9197b08dd5f29cb7bfbdcb1b792dcf7762544e96b", + "size": 16114, + "subdir": "linux-64", + "timestamp": 1607007544024, + "version": "1.4.4" + }, + "pyproj-1.9.5.1-py27h14380d9_1.tar.bz2": { + "build": "py27h14380d9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "proj4 >=5.2.0,<5.2.1.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "OSI", + "md5": "f19dd88fd8fb9d5cfc280fb9b3e13214", + "name": "pyproj", + "sha256": "3a2f03eaa37d691c54660c27f6dadecc7657a49ced5efb53c0c08196d528868e", + "size": 63791, + "subdir": "linux-64", + "timestamp": 1545264719413, + "version": "1.9.5.1" + }, + "pyproj-1.9.5.1-py27h7b21b82_1.tar.bz2": { + "build": "py27h7b21b82_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy", + "proj4 >=5.0.1,<5.0.2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "OSI", + "md5": "d2fba31e9c90e44335b461d679320662", + "name": "pyproj", + "sha256": "ff92995dc17a9e1311cbf6d35a7f4f750fed08d017a24a2752937a8f9df2704e", + "size": 64463, + "subdir": "linux-64", + "timestamp": 1530811272907, + "version": "1.9.5.1" + }, + "pyproj-1.9.5.1-py35h7b21b82_1.tar.bz2": { + "build": "py35h7b21b82_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "proj4 >=5.1.0,<5.1.1.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "OSI", + "md5": "722ba78bb8f30ac9c687461864cf9d84", + "name": "pyproj", + "sha256": "314ed911a9ac29ae61467e99d21e691bb08b7b4ccf8f4d801ff269a977b302a9", + "size": 65305, + "subdir": "linux-64", + "timestamp": 1535129635135, + "version": "1.9.5.1" + }, + "pyproj-1.9.5.1-py35h9d585cc_1.tar.bz2": { + "build": "py35h9d585cc_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "proj4 >=5.1.0,<5.1.1.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "OSI", + "md5": "8b5008094a671e9d4ef838daed45b3bb", + "name": "pyproj", + "sha256": "eb5659061d5949a57686ad5e0d5d94f65304f15f66db3ee50f16b448166ecc66", + "size": 65239, + "subdir": "linux-64", + "timestamp": 1536267996442, + "version": "1.9.5.1" + }, + "pyproj-1.9.5.1-py36h14380d9_1.tar.bz2": { + "build": "py36h14380d9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "proj4 >=5.2.0,<5.2.1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "OSI", + "md5": "003bbac963ab73c347ce1d10f7b52208", + "name": "pyproj", + "sha256": "7c32dd5b3cff2d7c450bc4816e94a1779b417c352757929ca34ac90d91b11c76", + "size": 65955, + "subdir": "linux-64", + "timestamp": 1545264826743, + "version": "1.9.5.1" + }, + "pyproj-1.9.5.1-py36h7b21b82_1.tar.bz2": { + "build": "py36h7b21b82_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy", + "proj4 >=5.0.1,<5.0.2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "OSI", + "md5": "1249c665eafa23a766cfc054320004e9", + "name": "pyproj", + "sha256": "e89b07e903bf07296f66272545970cb23f38946cc224d4fbb6e237a8fe012560", + "size": 65649, + "subdir": "linux-64", + "timestamp": 1530811336911, + "version": "1.9.5.1" + }, + "pyproj-1.9.5.1-py37h14380d9_1.tar.bz2": { + "build": "py37h14380d9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "proj4 >=5.2.0,<5.2.1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "OSI", + "md5": "51515adf191d2b774c1fb8bf59a95b0f", + "name": "pyproj", + "sha256": "670eb71a4f8a0dee3a9f0cf04e2e80e5960d30faeb6e7726bf7caf85b6d2bb14", + "size": 65970, + "subdir": "linux-64", + "timestamp": 1545264825228, + "version": "1.9.5.1" + }, + "pyproj-1.9.5.1-py37h7b21b82_1.tar.bz2": { + "build": "py37h7b21b82_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy", + "proj4 >=5.0.1,<5.0.2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "OSI", + "md5": "75c1b884432c77be6482ea815436bb05", + "name": "pyproj", + "sha256": "bb2ce7e66d1a8a65fee52a737519e9a6535513661e88d98300fda7ea68fed78a", + "size": 65480, + "subdir": "linux-64", + "timestamp": 1530811304720, + "version": "1.9.5.1" + }, + "pyproj-1.9.6-py27h14380d9_0.tar.bz2": { + "build": "py27h14380d9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "proj4 >=5.2.0,<5.2.1.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "OSI", + "md5": "4f4a3a12c5d654a1d019c5532cb5e0f3", + "name": "pyproj", + "sha256": "632696a4810cfa83a051b858d5c1485419e5b4a9b09695b0f52dc7f1e20e26f2", + "size": 77450, + "subdir": "linux-64", + "timestamp": 1547929493227, + "version": "1.9.6" + }, + "pyproj-1.9.6-py36h14380d9_0.tar.bz2": { + "build": "py36h14380d9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "proj4 >=5.2.0,<5.2.1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "OSI", + "md5": "7ca5050b83dd35640e255cdaddef6b6c", + "name": "pyproj", + "sha256": "7f5ac70f2789f1f734afdbd3c2ed48f7522159d5edfae058a9c45b49ea865cbe", + "size": 77969, + "subdir": "linux-64", + "timestamp": 1547929495830, + "version": "1.9.6" + }, + "pyproj-1.9.6-py37h14380d9_0.tar.bz2": { + "build": "py37h14380d9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "proj4 >=5.2.0,<5.2.1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "OSI", + "md5": "e508c59ac0276e2bc12dc22f5b5213c4", + "name": "pyproj", + "sha256": "0de145a506d1353b5b3b170baa7c7bdfb9cfd9e7611eaef746c52894e24f3c23", + "size": 77750, + "subdir": "linux-64", + "timestamp": 1547929489831, + "version": "1.9.6" + }, + "pyproj-1.9.6-py38h14380d9_0.tar.bz2": { + "build": "py38h14380d9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "proj4 >=5.2.0,<5.2.1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "OSI", + "md5": "4ceb93141cab478826abd2cbcbf944bb", + "name": "pyproj", + "sha256": "0003ed3de3b378354e5e36bde115e6a19c63cb2814a9db562c502e433bec79ec", + "size": 80274, + "subdir": "linux-64", + "timestamp": 1574094254122, + "version": "1.9.6" + }, + "pyproj-2.4.1-py36h2ea87da_0.tar.bz2": { + "build": "py36h2ea87da_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "OSI", + "md5": "d94c7ad0c35df652bccaa22421d1c269", + "name": "pyproj", + "sha256": "111ac1dccf442faf314fa7d480567a3aefc406e2b442228d16b7cc54932bcfc7", + "size": 371208, + "subdir": "linux-64", + "timestamp": 1573751373007, + "version": "2.4.1" + }, + "pyproj-2.4.1-py37h2ea87da_0.tar.bz2": { + "build": "py37h2ea87da_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "OSI", + "md5": "eefa324f116d5878b2e55f70fc561d70", + "name": "pyproj", + "sha256": "a1ea4eda03d8ac9b5d13d194ab465faa6ba092ac8a3f4f887ca7c625acd9ab99", + "size": 358579, + "subdir": "linux-64", + "timestamp": 1573751237144, + "version": "2.4.1" + }, + "pyproj-2.4.1-py38h2ea87da_0.tar.bz2": { + "build": "py38h2ea87da_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "OSI", + "md5": "4f5b7b37bde104ab42f9d9c49c721335", + "name": "pyproj", + "sha256": "ff0bb10cac0ff4b6c66f8a76e38a714e07540024d546463a05c806d1f5634626", + "size": 385638, + "subdir": "linux-64", + "timestamp": 1573751370019, + "version": "2.4.1" + }, + "pyproj-2.6.0-py36hd003209_1.tar.bz2": { + "build": "py36hd003209_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "OSI", + "md5": "c55d09f7369fcfbe0e1f7b7b67ca1824", + "name": "pyproj", + "sha256": "a99cb952bf56c2208fc33d98c464805e1c4e278b0092414a95d210e9f29f9460", + "size": 443710, + "subdir": "linux-64", + "timestamp": 1587483323404, + "version": "2.6.0" + }, + "pyproj-2.6.0-py37hd003209_1.tar.bz2": { + "build": "py37hd003209_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "OSI", + "md5": "2b5df6e9a23c365ad06631c4f39f3993", + "name": "pyproj", + "sha256": "6719381b51dd8e969af95717057ee356ea63b1d511588d0dad1fa4d63d51c4d2", + "size": 451418, + "subdir": "linux-64", + "timestamp": 1587483302569, + "version": "2.6.0" + }, + "pyproj-2.6.0-py38hd003209_1.tar.bz2": { + "build": "py38hd003209_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "OSI", + "md5": "b7c18505361a4fdcaca121385eb6f93f", + "name": "pyproj", + "sha256": "c60268b205467f703936c358d04287c74a6bad11af338320aa27c3345b6b11b1", + "size": 464847, + "subdir": "linux-64", + "timestamp": 1587483784616, + "version": "2.6.0" + }, + "pyproj-2.6.1.post1-py36h61f852b_1.tar.bz2": { + "build": "py36h61f852b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=7.0.1,<7.0.2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "49963d74178ffa070b2cf920860565b5", + "name": "pyproj", + "sha256": "e0ae0ed9ad6d9e24955d2d6da39901007deac0c1bdb2679d029fe8464839b764", + "size": 447473, + "subdir": "linux-64", + "timestamp": 1590593838575, + "version": "2.6.1.post1" + }, + "pyproj-2.6.1.post1-py36hb3025e9_1.tar.bz2": { + "build": "py36hb3025e9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7a304a4079eaf5f03eda097cb7375b25", + "name": "pyproj", + "sha256": "eb712c1a9ebe2c2a6f64631cf2111f4cf53dad1f69a674edef6d51f2fe18c0da", + "size": 471177, + "subdir": "linux-64", + "timestamp": 1614278005995, + "version": "2.6.1.post1" + }, + "pyproj-2.6.1.post1-py36hd003209_1.tar.bz2": { + "build": "py36hd003209_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d2fcd3d315c098dad02713df15e7eb3f", + "name": "pyproj", + "sha256": "2cd697b843a2327c2a5adb380cf4b413c9562771c488cf940349f50c2f5287fc", + "size": 471341, + "subdir": "linux-64", + "timestamp": 1590593860486, + "version": "2.6.1.post1" + }, + "pyproj-2.6.1.post1-py37h61f852b_1.tar.bz2": { + "build": "py37h61f852b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=7.0.1,<7.0.2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "855f7e0173564a61d22acd56f1008ac2", + "name": "pyproj", + "sha256": "67c8f467147b59da5957443b040988469a548a585d83d95cc0483f8b60e3ca8b", + "size": 460259, + "subdir": "linux-64", + "timestamp": 1590593830850, + "version": "2.6.1.post1" + }, + "pyproj-2.6.1.post1-py37hb3025e9_1.tar.bz2": { + "build": "py37hb3025e9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "adc7f05823ac9b2e9ff3e47005cb0733", + "name": "pyproj", + "sha256": "575aabfe5ac843175468b7e2bb76d5262777931f15718b10f0d2a155ab7d8788", + "size": 456765, + "subdir": "linux-64", + "timestamp": 1614277992716, + "version": "2.6.1.post1" + }, + "pyproj-2.6.1.post1-py37hd003209_1.tar.bz2": { + "build": "py37hd003209_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4fe2ce84c8c7c188423a44616659b914", + "name": "pyproj", + "sha256": "291a33a0104e5e7daac13876c439d4eba2403046ff9d1d3ead537bc5834d949e", + "size": 456586, + "subdir": "linux-64", + "timestamp": 1590593829647, + "version": "2.6.1.post1" + }, + "pyproj-2.6.1.post1-py38h61f852b_1.tar.bz2": { + "build": "py38h61f852b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=7.0.1,<7.0.2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "318265d99ec63dda9abf24235f516ed5", + "name": "pyproj", + "sha256": "bfaa12ab0fb60c6be70faae0a87d3a6c19abc629338a6b0d1598cf9459c49ba6", + "size": 466024, + "subdir": "linux-64", + "timestamp": 1590593829569, + "version": "2.6.1.post1" + }, + "pyproj-2.6.1.post1-py38hb3025e9_1.tar.bz2": { + "build": "py38hb3025e9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "5ea29d28879ed23adea37d26809a274e", + "name": "pyproj", + "sha256": "1db7b0212a027d883426d4c36cc8f9bf4c56232a97fe46cd373bec44b1c63ba6", + "size": 464988, + "subdir": "linux-64", + "timestamp": 1614278003311, + "version": "2.6.1.post1" + }, + "pyproj-2.6.1.post1-py38hd003209_1.tar.bz2": { + "build": "py38hd003209_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "7bdafd4642e14a7d907dfe60fe2eb592", + "name": "pyproj", + "sha256": "f9a090bec57f3fb80605251b6216baf13f7fe84d6a0a8deefd734462c7b2300f", + "size": 466657, + "subdir": "linux-64", + "timestamp": 1590593825586, + "version": "2.6.1.post1" + }, + "pyproj-2.6.1.post1-py39hb3025e9_1.tar.bz2": { + "build": "py39hb3025e9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "23ee5a4da0eb5e6d5b71c1bb3d87d28d", + "name": "pyproj", + "sha256": "d8ff34615b3820802ccc87bf5ed8c7033fbd742cb382ccae1cfa413141d2b62a", + "size": 477417, + "subdir": "linux-64", + "timestamp": 1614276971595, + "version": "2.6.1.post1" + }, + "pyproj-3.1.0-py310he0da13a_4.tar.bz2": { + "build": "py310he0da13a_4", + "build_number": 4, + "depends": [ + "certifi", + "libgcc-ng >=7.5.0", + "proj >=7.2.0,<7.2.1.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "4ff0901d762432fa57263769ca8ea845", + "name": "pyproj", + "sha256": "a8b77dcb52877ec26933ec8635f8340e1b417da3ffa60411909b458f641ee28c", + "size": 1755601, + "subdir": "linux-64", + "timestamp": 1643015537854, + "version": "3.1.0" + }, + "pyproj-3.3.0-py310h162314d_0.tar.bz2": { + "build": "py310h162314d_0", + "build_number": 0, + "depends": [ + "certifi", + "libgcc-ng >=7.5.0", + "proj >=8.2.1", + "proj >=8.2.1,<8.2.2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "38ef6087192d6b735de728a566337f35", + "name": "pyproj", + "sha256": "75d6e0ff362aabf64de25ba4a21eeb47debd2dddf8e9488ade59514f50457367", + "size": 1674585, + "subdir": "linux-64", + "timestamp": 1644492078711, + "version": "3.3.0" + }, + "pyproj-3.3.0-py38h6de3afc_0.tar.bz2": { + "build": "py38h6de3afc_0", + "build_number": 0, + "depends": [ + "certifi", + "libgcc-ng >=7.5.0", + "proj >=8.2.1", + "proj >=8.2.1,<8.2.2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9aa786546cf0e4bb8fa780ae7a6edb54", + "name": "pyproj", + "sha256": "0a5eb2bd2f166ba79daad3636bb0af3d28e0bd1eac822b1e62fb0fd31d9810f8", + "size": 538452, + "subdir": "linux-64", + "timestamp": 1644493881126, + "version": "3.3.0" + }, + "pyproj-3.3.0-py39h6de3afc_0.tar.bz2": { + "build": "py39h6de3afc_0", + "build_number": 0, + "depends": [ + "certifi", + "libgcc-ng >=7.5.0", + "proj >=8.2.1", + "proj >=8.2.1,<8.2.2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13754dd43caebc873e61da9dd0e33fe7", + "name": "pyproj", + "sha256": "c4d20bbc88c6e02a5b58eac89d9265f1b54ddb066f78fe06e6b50a659aac00fd", + "size": 541626, + "subdir": "linux-64", + "timestamp": 1644510184590, + "version": "3.3.0" + }, + "pyproj-3.4.1-py310h49a4818_0.tar.bz2": { + "build": "py310h49a4818_0", + "build_number": 0, + "depends": [ + "certifi", + "libgcc-ng >=11.2.0", + "proj >=8.2.1", + "proj >=8.2.1,<8.2.2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e269b90e094f110769b2d7a29fd9ec77", + "name": "pyproj", + "sha256": "1ca55a23b111f9ce5fe0eeb4b92d0a6536b7497ee5f9d93da197d9d4991a682a", + "size": 483910, + "subdir": "linux-64", + "timestamp": 1675244305076, + "version": "3.4.1" + }, + "pyproj-3.4.1-py311h93e2b2c_0.tar.bz2": { + "build": "py311h93e2b2c_0", + "build_number": 0, + "depends": [ + "certifi", + "libgcc-ng >=11.2.0", + "proj >=8.2.1", + "proj >=8.2.1,<8.2.2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab1f6c78dc4f723f8ce8ec611e52d535", + "name": "pyproj", + "sha256": "e91bf8bf092bba01fd6b09934bca8fa6a8a5ee54dc050aa27b72fead69e40e52", + "size": 516569, + "subdir": "linux-64", + "timestamp": 1676842317633, + "version": "3.4.1" + }, + "pyproj-3.4.1-py38hb83c990_0.tar.bz2": { + "build": "py38hb83c990_0", + "build_number": 0, + "depends": [ + "certifi", + "libgcc-ng >=11.2.0", + "proj >=8.2.1", + "proj >=8.2.1,<8.2.2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bcd0e10800c014937aebab07a2861ad4", + "name": "pyproj", + "sha256": "6490383696dbce20087d3d3300dacaf6e3a1d583adf4f565e34cbf1226cc5b53", + "size": 485143, + "subdir": "linux-64", + "timestamp": 1675244384710, + "version": "3.4.1" + }, + "pyproj-3.4.1-py39hb83c990_0.tar.bz2": { + "build": "py39hb83c990_0", + "build_number": 0, + "depends": [ + "certifi", + "libgcc-ng >=11.2.0", + "proj >=8.2.1", + "proj >=8.2.1,<8.2.2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9cb3cd7b43eb74b4d3af163253139c5d", + "name": "pyproj", + "sha256": "37d71f7c60353185d46dc46fd10a211394d89e0f362b1c806f85be052af541ed", + "size": 480514, + "subdir": "linux-64", + "timestamp": 1675244222905, + "version": "3.4.1" + }, + "pyproject-metadata-0.6.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "353ab198e8be909a7c35c9a38904573c", + "name": "pyproject-metadata", + "sha256": "a5082063727679d58072152f414acd9dd2a6599177c985cee37d12525a1abaa2", + "size": 17142, + "subdir": "linux-64", + "timestamp": 1660078336813, + "version": "0.6.1" + }, + "pyproject-metadata-0.6.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ee6e7c9f539aa6f7f7c92009e916c68", + "name": "pyproject-metadata", + "sha256": "290fd799583208739ea20982e9b259ff1de150524f2ea883172debe01c7c351a", + "size": 22154, + "subdir": "linux-64", + "timestamp": 1676845404472, + "version": "0.6.1" + }, + "pyproject-metadata-0.6.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "306b6e6a7d15471370ec909a9072dede", + "name": "pyproject-metadata", + "sha256": "3560b8bbb484e200e55239fc65d1b7ff299ca81dae6f70e3c30125fcfdf1bbdd", + "size": 16996, + "subdir": "linux-64", + "timestamp": 1660078235935, + "version": "0.6.1" + }, + "pyproject-metadata-0.6.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01033a4cfb2b9f881c50b1752b94c61f", + "name": "pyproject-metadata", + "sha256": "a6befa4092594214ea8acf28807d560bf5177bf4b5bbeba07eb341d4baa287b6", + "size": 17066, + "subdir": "linux-64", + "timestamp": 1660078295748, + "version": "0.6.1" + }, + "pyproject-metadata-0.6.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9e9611d665bd9606b4fe25d6db7d687", + "name": "pyproject-metadata", + "sha256": "a85048c5f940a7f914183995f50cc7931c39863c85e6c7744abf8afbf9ca7549", + "size": 17046, + "subdir": "linux-64", + "timestamp": 1660078268117, + "version": "0.6.1" + }, + "pyproject-metadata-0.7.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a68f09246c6d26c6af6f979f82cdc9a4", + "name": "pyproject-metadata", + "sha256": "2cff265a3bc4b7be175135a6e4e2589b98d8272e6a91478fec3d2052b777547f", + "size": 21571, + "subdir": "linux-64", + "timestamp": 1679672900904, + "version": "0.7.1" + }, + "pyproject-metadata-0.7.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e203b1a49c9950639c297d4ec99f1ac", + "name": "pyproject-metadata", + "sha256": "f91213c2cb2b7bc1f5b7099557a4d87706e7ab314e03ee083a10da549f8a9110", + "size": 26215, + "subdir": "linux-64", + "timestamp": 1679672847301, + "version": "0.7.1" + }, + "pyproject-metadata-0.7.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "81b26ade9673a3733f24d640e13f2665", + "name": "pyproject-metadata", + "sha256": "880f7868ad0fb44cf7f91dbc6306f3de99d37ababc31bc4efbdde29b1a4ceeb8", + "size": 21462, + "subdir": "linux-64", + "timestamp": 1679672873858, + "version": "0.7.1" + }, + "pyproject-metadata-0.7.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fcd1f92e36d973f974441ebc66e843d1", + "name": "pyproject-metadata", + "sha256": "5822dc3d9f4e89b7ac06a993e3efc9f03d33262fa07f73b2b890420872f8f6af", + "size": 21465, + "subdir": "linux-64", + "timestamp": 1679672820354, + "version": "0.7.1" + }, + "pyproject_hooks-1.0.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e14291d004308c27629e085a6098b584", + "name": "pyproject_hooks", + "sha256": "84807fbca9e65164558acfc9c4d1fab3c10fac52b6ca8a4696e56ea43b3bd13a", + "size": 19199, + "subdir": "linux-64", + "timestamp": 1679584441968, + "version": "1.0.0" + }, + "pyproject_hooks-1.0.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c70f67f173dbd3a92b93158b2359ba29", + "name": "pyproject_hooks", + "sha256": "2949d84024b88f57b647c796490dcafda7f3a96e631889a5ca584e557fd8bda2", + "size": 23528, + "subdir": "linux-64", + "timestamp": 1679584514958, + "version": "1.0.0" + }, + "pyproject_hooks-1.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7e495b783abb52ee6fb24855418b9a6", + "name": "pyproject_hooks", + "sha256": "09927d1d5933550140b53651b01416d3a7e76150ccbb8ee21279aa4e5f70c695", + "size": 19041, + "subdir": "linux-64", + "timestamp": 1679584466547, + "version": "1.0.0" + }, + "pyproject_hooks-1.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f176a686b76797b58325eab00028727", + "name": "pyproject_hooks", + "sha256": "1a1337d5ed6977f081af941e1b4ecb580a18089abdac1d03af743aa7a97b4803", + "size": 19124, + "subdir": "linux-64", + "timestamp": 1679584490005, + "version": "1.0.0" + }, + "pyqt-5.15.7-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt5-sip 12.11.0 py310h6a678d5_0", + "python >=3.10,<3.11.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "fa45e17d1db1ff203db3fb03544755c7", + "name": "pyqt", + "sha256": "db13e3f83d9c72fc872214806c55d59690a672e70a52d06b53723b490d447245", + "size": 6603284, + "subdir": "linux-64", + "timestamp": 1659277022459, + "version": "5.15.7" + }, + "pyqt-5.15.7-py310h6a678d5_1.tar.bz2": { + "build": "py310h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt5-sip 12.11.0 py310h6a678d5_1", + "python >=3.10,<3.11.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "b0b8c963586f30ed4db9fc35ee458c03", + "name": "pyqt", + "sha256": "c4378432bc8498974e0017c9e5d30cf5e0d51857b1e034915bb8b6374d95a2a8", + "size": 6579021, + "subdir": "linux-64", + "timestamp": 1659387924109, + "version": "5.15.7" + }, + "pyqt-5.15.7-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt5-sip 12.11.0 py311h6a678d5_0", + "python >=3.11,<3.12.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "12614cd9462b67e3eed557299e4e6e34", + "name": "pyqt", + "sha256": "23c852279ac691de0b557384b6ed0bf9a30e4ff511aa4169b116244afd90ae1f", + "size": 6626279, + "subdir": "linux-64", + "timestamp": 1676826744474, + "version": "5.15.7" + }, + "pyqt-5.15.7-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt5-sip 12.11.0 py37h6a678d5_0", + "python >=3.7,<3.8.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "07d84a79bf4dfbfbae3c724b4a5653fb", + "name": "pyqt", + "sha256": "d806033ae3da86b1a08b6aa5d770710037406f611523d04494cda858440c16ac", + "size": 6607676, + "subdir": "linux-64", + "timestamp": 1659280679415, + "version": "5.15.7" + }, + "pyqt-5.15.7-py37h6a678d5_1.tar.bz2": { + "build": "py37h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt5-sip 12.11.0 py37h6a678d5_1", + "python >=3.7,<3.8.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "d5f0a2a23194ed4ec3889d294be24a23", + "name": "pyqt", + "sha256": "d2ae92f3baae9eed81e9bf9cc4be8319251d96c05d27a8e576841ed9d7a0fdea", + "size": 6616277, + "subdir": "linux-64", + "timestamp": 1659389270968, + "version": "5.15.7" + }, + "pyqt-5.15.7-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt5-sip 12.11.0 py38h6a678d5_0", + "python >=3.8,<3.9.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "478850b2c3315ee8bb1831db554fcf85", + "name": "pyqt", + "sha256": "9419b31376b0350fa2e105e09f7d9cc545356de858efa69fc5c0382505e0bcd2", + "size": 6602087, + "subdir": "linux-64", + "timestamp": 1659275209198, + "version": "5.15.7" + }, + "pyqt-5.15.7-py38h6a678d5_1.tar.bz2": { + "build": "py38h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt5-sip 12.11.0 py38h6a678d5_1", + "python >=3.8,<3.9.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "d71c6b1f518ee59a4223f650eb785b7a", + "name": "pyqt", + "sha256": "c201c7ceec075ca4e1738e0070c9f9af5a0f4a9266edc6ba89c6806d92b2f0ec", + "size": 6574679, + "subdir": "linux-64", + "timestamp": 1659388597307, + "version": "5.15.7" + }, + "pyqt-5.15.7-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt5-sip 12.11.0 py39h6a678d5_0", + "python >=3.9,<3.10.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "eaa7e24322eabac8a25a823b09e1a251", + "name": "pyqt", + "sha256": "de98c4e0a8177b8920d456e95f5ccbd9d8916036d6ac7a0da14f0c96b8a1a064", + "size": 6598635, + "subdir": "linux-64", + "timestamp": 1659278848931, + "version": "5.15.7" + }, + "pyqt-5.15.7-py39h6a678d5_1.tar.bz2": { + "build": "py39h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt5-sip 12.11.0 py39h6a678d5_1", + "python >=3.9,<3.10.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "1511da4d867811944791a4b31c599677", + "name": "pyqt", + "sha256": "df1dec7bd990ced36337ed00192ae6eaaaa242f198731c76650c414f772a0802", + "size": 6574703, + "subdir": "linux-64", + "timestamp": 1659389943675, + "version": "5.15.7" + }, + "pyqt-5.6.0-py27h22d08a2_6.tar.bz2": { + "build": "py27h22d08a2_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "qt 5.6.*", + "sip 4.18.*" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "55ae07c674b5de49d946bf4e098ff268", + "name": "pyqt", + "sha256": "2eaad851d1d4f5be1bdf478f7d50aac7be94a8eb0602cb02787961ca672b1dc7", + "size": 5522684, + "subdir": "linux-64", + "timestamp": 1530796317530, + "version": "5.6.0" + }, + "pyqt-5.6.0-py27h4b1e83c_5.tar.bz2": { + "build": "py27h4b1e83c_5", + "build_number": 5, + "depends": [ + "dbus >=1.10.22,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "qt 5.6.*", + "sip 4.18.*" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "8a9eca99ce0b78cfefbb9faca4db793a", + "name": "pyqt", + "sha256": "b063d9cb90409b4f800e7941140ca273d42078c14b25c8fe53f63016a20ac0cc", + "size": 5524409, + "subdir": "linux-64", + "timestamp": 1505738242615, + "version": "5.6.0" + }, + "pyqt-5.6.0-py35h0e41ada_5.tar.bz2": { + "build": "py35h0e41ada_5", + "build_number": 5, + "depends": [ + "dbus >=1.10.22,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "qt 5.6.*", + "sip 4.18.*" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "b951dab563683ed93fa0503a93270f19", + "name": "pyqt", + "sha256": "43fae35b2ccb1ff3e80fa89b79b8320f121e6a2de9165d006a3092b0fe9e3333", + "size": 5705773, + "subdir": "linux-64", + "timestamp": 1505738707849, + "version": "5.6.0" + }, + "pyqt-5.6.0-py35h22d08a2_6.tar.bz2": { + "build": "py35h22d08a2_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "qt 5.6.*", + "qt >=5.6.3,<5.7.0a0", + "sip 4.18.*" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "ecad85f111b9db13214b92fc208b1841", + "name": "pyqt", + "sha256": "12aeeeabd17611c15a949b54294efd9805f800b83a2f4ce5f378ee85638edd96", + "size": 5700539, + "subdir": "linux-64", + "timestamp": 1535129366886, + "version": "5.6.0" + }, + "pyqt-5.6.0-py36h0386399_5.tar.bz2": { + "build": "py36h0386399_5", + "build_number": 5, + "depends": [ + "dbus >=1.10.22,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "qt 5.6.*", + "sip 4.18.*" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "b1624f76a6bba705869f849f7456bd39", + "name": "pyqt", + "sha256": "b37f144a5c2349b1c58ef17a663cb79086a1f2f49e35503e4f411f6f698cee1a", + "size": 5715107, + "subdir": "linux-64", + "timestamp": 1505739175210, + "version": "5.6.0" + }, + "pyqt-5.6.0-py36h22d08a2_6.tar.bz2": { + "build": "py36h22d08a2_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "qt 5.6.*", + "sip 4.18.*" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "2aabc691976aaee211c46c68c4343749", + "name": "pyqt", + "sha256": "420f8d7a765e1016724136b0473499c56053808717101051f34cfbff4be89ca2", + "size": 5704091, + "subdir": "linux-64", + "timestamp": 1530796931852, + "version": "5.6.0" + }, + "pyqt-5.6.0-py37h22d08a2_6.tar.bz2": { + "build": "py37h22d08a2_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "qt 5.6.*", + "sip 4.18.*" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "ef55421b85fea4872a4cf8c7bb495d87", + "name": "pyqt", + "sha256": "02d0704cb097992789f8742c426c1920ddb8cba897e8f03878d3efcd7b796346", + "size": 5702526, + "subdir": "linux-64", + "timestamp": 1530797543010, + "version": "5.6.0" + }, + "pyqt-5.9.2-py27h05f1152_2.tar.bz2": { + "build": "py27h05f1152_2", + "build_number": 2, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "2da8e2e0ad6f0eab1546f82a8024f7e6", + "name": "pyqt", + "sha256": "999239e84ec2163de3094909cd4c05dd18fa28182a03bead3f5f3c4e9f853f58", + "size": 5623072, + "subdir": "linux-64", + "timestamp": 1537388927459, + "version": "5.9.2" + }, + "pyqt-5.9.2-py27h22d08a2_0.tar.bz2": { + "build": "py27h22d08a2_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "35b3679fc896bfe6205573497b85246f", + "name": "pyqt", + "sha256": "ea7dbc9978022330f92e87529a9ec1978f06611804a436dbe745fcda26cff654", + "size": 5938342, + "subdir": "linux-64", + "timestamp": 1530794131757, + "version": "5.9.2" + }, + "pyqt-5.9.2-py27h22d08a2_1.tar.bz2": { + "build": "py27h22d08a2_1", + "build_number": 1, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "71863b638e25bb171cae5854e2b0ba73", + "name": "pyqt", + "sha256": "71d10c05deabee7bf2004d79d5045d8b70847196db58a725ae5e361bfe05fbce", + "size": 5621459, + "subdir": "linux-64", + "timestamp": 1535101431715, + "version": "5.9.2" + }, + "pyqt-5.9.2-py27h751905a_0.tar.bz2": { + "build": "py27h751905a_0", + "build_number": 0, + "depends": [ + "dbus >=1.12.2,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "qt 5.9.*", + "qt >=5.9.4,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "27390b95debad35501b00633cbea9663", + "name": "pyqt", + "sha256": "9574fbc1ee0a2dfb6c524d584098d85472d7a97e3058a988214486512f18a1d8", + "size": 5940999, + "subdir": "linux-64", + "timestamp": 1521807306718, + "version": "5.9.2" + }, + "pyqt-5.9.2-py310h295c915_6.tar.bz2": { + "build": "py310h295c915_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "qt 5.9.*", + "qt >=5.9.7,<5.10.0a0", + "sip 4.19.13.*" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "497af8e2e2d0a1a98b043d838b18b671", + "name": "pyqt", + "sha256": "c394d355943b0163498da897e68e28e3b792bbb41665fc88a2e768f3e0f88e38", + "size": 5994655, + "subdir": "linux-64", + "timestamp": 1643115118542, + "version": "5.9.2" + }, + "pyqt-5.9.2-py35h05f1152_2.tar.bz2": { + "build": "py35h05f1152_2", + "build_number": 2, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "c1061dc6744a38800329163916bdb647", + "name": "pyqt", + "sha256": "3d7bf3a4407328ffbf2f46d0e0e21b59f9e063935e25bbbef28b0cfc7d11cf44", + "size": 5833540, + "subdir": "linux-64", + "timestamp": 1537389093699, + "version": "5.9.2" + }, + "pyqt-5.9.2-py35h22d08a2_1.tar.bz2": { + "build": "py35h22d08a2_1", + "build_number": 1, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "23c789101d1fa52b31fedcd0f56d5a2a", + "name": "pyqt", + "sha256": "3d05261baf5b558b91d105f23b99639500602668ab8cd256e0e55b7b066dd9f9", + "size": 5832996, + "subdir": "linux-64", + "timestamp": 1535102766048, + "version": "5.9.2" + }, + "pyqt-5.9.2-py35h751905a_0.tar.bz2": { + "build": "py35h751905a_0", + "build_number": 0, + "depends": [ + "dbus >=1.12.2,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "qt 5.9.*", + "qt >=5.9.4,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "f15bb31b52759b19d6d9d2af41b1a849", + "name": "pyqt", + "sha256": "e1ac24d6400e88c571b412acb52359c85789b4c7f01215e3dbc4985c605a9035", + "size": 6152116, + "subdir": "linux-64", + "timestamp": 1521807900545, + "version": "5.9.2" + }, + "pyqt-5.9.2-py36h05f1152_2.tar.bz2": { + "build": "py36h05f1152_2", + "build_number": 2, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "de43b5a8bd046b6bd94d9ffe24c7e496", + "name": "pyqt", + "sha256": "ecc85ad3822f7cf7e64d8d60573232bbb82c0f7a5ab8f901c6fc9bf40892f32e", + "size": 5830553, + "subdir": "linux-64", + "timestamp": 1537389093760, + "version": "5.9.2" + }, + "pyqt-5.9.2-py36h22d08a2_0.tar.bz2": { + "build": "py36h22d08a2_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "f56772f5ffb61a4a9613c0d581e64010", + "name": "pyqt", + "sha256": "8e6b17754ffba44e2167c06507d9675e2079fdd6681946a347fafc53b5ba96f2", + "size": 6150109, + "subdir": "linux-64", + "timestamp": 1530794852052, + "version": "5.9.2" + }, + "pyqt-5.9.2-py36h22d08a2_1.tar.bz2": { + "build": "py36h22d08a2_1", + "build_number": 1, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "75dd1238cea37f52c6a95e4e209baed4", + "name": "pyqt", + "sha256": "591422feb5f8fee9cd60b0ec9ffe59307fa93142fd85f7a93de42475593f0fc5", + "size": 5829602, + "subdir": "linux-64", + "timestamp": 1535102100281, + "version": "5.9.2" + }, + "pyqt-5.9.2-py36h751905a_0.tar.bz2": { + "build": "py36h751905a_0", + "build_number": 0, + "depends": [ + "dbus >=1.12.2,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "qt 5.9.*", + "qt >=5.9.4,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "d1064d7c03aa785c49e65b9412ed8d63", + "name": "pyqt", + "sha256": "5c34823797200e1e2e02b39c7238d839ef3691da2a66c1de86f7e94bccca7a96", + "size": 6151528, + "subdir": "linux-64", + "timestamp": 1521808500120, + "version": "5.9.2" + }, + "pyqt-5.9.2-py37h05f1152_2.tar.bz2": { + "build": "py37h05f1152_2", + "build_number": 2, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "747f0dc5b8cf8ef5a16c7bf56383961c", + "name": "pyqt", + "sha256": "b448f0c777ad6f493b7f4a5bc1b01302fad2cd3c8b7eb3225faec07a916979a4", + "size": 5829207, + "subdir": "linux-64", + "timestamp": 1537384246300, + "version": "5.9.2" + }, + "pyqt-5.9.2-py37h22d08a2_0.tar.bz2": { + "build": "py37h22d08a2_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "66c2d1a2b1b529a7d577ab0c97acb991", + "name": "pyqt", + "sha256": "c5c26651a25e250f1622a6b8245a1b3f4cee3c9c60ed7835660387223da075d0", + "size": 6150629, + "subdir": "linux-64", + "timestamp": 1530795563644, + "version": "5.9.2" + }, + "pyqt-5.9.2-py37h22d08a2_1.tar.bz2": { + "build": "py37h22d08a2_1", + "build_number": 1, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "41f9ab1cc079564605b8017355b46eac", + "name": "pyqt", + "sha256": "00f44ea8dd0d6bf0b157cbe2e544faf06bd44c1d6d3cea0e4842371afaf444f1", + "size": 5831164, + "subdir": "linux-64", + "timestamp": 1535112124759, + "version": "5.9.2" + }, + "pyqt-5.9.2-py38h05f1152_4.tar.bz2": { + "build": "py38h05f1152_4", + "build_number": 4, + "depends": [ + "dbus >=1.13.12,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "qt 5.9.*", + "qt >=5.9.7,<5.10.0a0", + "sip >=4.19.13,<=4.19.14" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "e7b317dce079dd05a350c706e720b1f6", + "name": "pyqt", + "sha256": "7a26b1b6270a9134319d3f68f50f73b913f9d9f2dae086ef647d096d484b43b1", + "size": 5807907, + "subdir": "linux-64", + "timestamp": 1574449202654, + "version": "5.9.2" + }, + "pyqt-5.9.2-py39h2531618_6.tar.bz2": { + "build": "py39h2531618_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "qt 5.9.*", + "qt >=5.9.7,<5.10.0a0", + "sip 4.19.13.*" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "3eda4bcc31b66fd5002817def97cd129", + "name": "pyqt", + "sha256": "c96502aca0df082c457f31d9e6202419aa86f24e1c699c3a34d02602f7a42812", + "size": 6010734, + "subdir": "linux-64", + "timestamp": 1607697278482, + "version": "5.9.2" + }, + "pyqt-builder-1.13.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "packaging", + "python >=3.10,<3.11.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "3429263d585139c13bdc4e2a4c955b19", + "name": "pyqt-builder", + "sha256": "3196d56de19de7061238718e9c63754096488c84f946bfe1e8235bb983a5de2f", + "size": 3740682, + "subdir": "linux-64", + "timestamp": 1659018142373, + "version": "1.13.0" + }, + "pyqt-builder-1.13.0-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "packaging", + "python >=3.11,<3.12.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "1ac90c0a42d884c450822446c7526425", + "name": "pyqt-builder", + "sha256": "514674dbf73cd37d8247383e4bd66ea766e139d3c54cd5d4fd4ac1302c4a95fa", + "size": 3774859, + "subdir": "linux-64", + "timestamp": 1676825437931, + "version": "1.13.0" + }, + "pyqt-builder-1.13.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "packaging", + "python >=3.7,<3.8.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "81e5251dff90ca164bd048eb0f40d0f7", + "name": "pyqt-builder", + "sha256": "2bdfb250edeebb5a6e10913bdd06c7ade2c0ada6877f8a2cbad93d1861d3f6a9", + "size": 3741044, + "subdir": "linux-64", + "timestamp": 1659018081877, + "version": "1.13.0" + }, + "pyqt-builder-1.13.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "packaging", + "python >=3.8,<3.9.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "250c759ef46952aba59159bc3d83c591", + "name": "pyqt-builder", + "sha256": "39ad19b5317bd39fb3391753056a76e9069375719c86c4748ef55049e610c30c", + "size": 3741280, + "subdir": "linux-64", + "timestamp": 1659018234237, + "version": "1.13.0" + }, + "pyqt-builder-1.13.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "packaging", + "python >=3.9,<3.10.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "a7e642ea4b91cf99cdf52410d69d829e", + "name": "pyqt-builder", + "sha256": "df5305ccdce2b9a1db3ce95538d14c03bdf8d061cdee9745e88aa42d4b25f8c1", + "size": 3740813, + "subdir": "linux-64", + "timestamp": 1659018189435, + "version": "1.13.0" + }, + "pyqt5-sip-12.11.0-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.10,<3.11.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "6441475ea7bae5c202b212b44dc2189f", + "name": "pyqt5-sip", + "sha256": "336af5457bbc2c0efb4740dab555ea963979adb74d4e9102fae8a7144a81e4cf", + "size": 323253, + "subdir": "linux-64", + "timestamp": 1659273332169, + "version": "12.11.0" + }, + "pyqt5-sip-12.11.0-py310h6a678d5_1.tar.bz2": { + "build": "py310h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.10,<3.11.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "476c4859b1644df160d5efffe8a0656e", + "name": "pyqt5-sip", + "sha256": "f840ad4e97966db45584186a0a60a5deb9a2b752dd9022827398396b3a7688b8", + "size": 326553, + "subdir": "linux-64", + "timestamp": 1659387165573, + "version": "12.11.0" + }, + "pyqt5-sip-12.11.0-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.11,<3.12.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "524dd8aa43684aaed0f255a76fc4345d", + "name": "pyqt5-sip", + "sha256": "d10a73c6da04270285e773821d0f53e81d5b972ce706bea4d2f044d3049a4e19", + "size": 88971, + "subdir": "linux-64", + "timestamp": 1676825504497, + "version": "12.11.0" + }, + "pyqt5-sip-12.11.0-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.7,<3.8.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "1f0be9791085cbcee3c14845330c08a3", + "name": "pyqt5-sip", + "sha256": "b172f19373d5fd20c324f05fc5488729fea8bf30966e0023405ea81434462789", + "size": 88054, + "subdir": "linux-64", + "timestamp": 1659273385307, + "version": "12.11.0" + }, + "pyqt5-sip-12.11.0-py37h6a678d5_1.tar.bz2": { + "build": "py37h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.7,<3.8.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "91864b515f8c02ee96e72deca0c01d95", + "name": "pyqt5-sip", + "sha256": "03480af76941cccb1b230f130f02e422bef059f8a53073b4383e82c6e52be939", + "size": 90941, + "subdir": "linux-64", + "timestamp": 1659387229000, + "version": "12.11.0" + }, + "pyqt5-sip-12.11.0-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.8,<3.9.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "18ad76a2ed81fc94fcacd5d7a0370dc9", + "name": "pyqt5-sip", + "sha256": "a0152968940aacebe1b639bd7d6457c0d3153f8d7c3f7de4036035c0ab4f2e8a", + "size": 89003, + "subdir": "linux-64", + "timestamp": 1659273304812, + "version": "12.11.0" + }, + "pyqt5-sip-12.11.0-py38h6a678d5_1.tar.bz2": { + "build": "py38h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.8,<3.9.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "a5a6df6e48dcc43024e8e3ce14e2fe99", + "name": "pyqt5-sip", + "sha256": "18a33220a7131d8f0c64771942ecc4b54d8c244e195657a258428b24c3b5ec02", + "size": 91834, + "subdir": "linux-64", + "timestamp": 1659387197256, + "version": "12.11.0" + }, + "pyqt5-sip-12.11.0-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.9,<3.10.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "390c73beb16489697513e63541389af4", + "name": "pyqt5-sip", + "sha256": "45361de366423055e21cd183b506e777b61d3e8df41bf8b3d3efba9d705ce229", + "size": 88845, + "subdir": "linux-64", + "timestamp": 1659273358985, + "version": "12.11.0" + }, + "pyqt5-sip-12.11.0-py39h6a678d5_1.tar.bz2": { + "build": "py39h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.9,<3.10.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "a08853d6949beecfacc19147255d8ee5", + "name": "pyqt5-sip", + "sha256": "85f940a5dc42b3186d2e5a6773d64c1ab2460a7e6fe475889c8515cc43a81b25", + "size": 91800, + "subdir": "linux-64", + "timestamp": 1659387261071, + "version": "12.11.0" + }, + "pyqtchart-5.15.7-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.10,<3.11.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "2e12044091daea4c303535b5a51791e2", + "name": "pyqtchart", + "sha256": "71198958e01d46ce7fff87c447a77a26b027ae9b4c7b68cab865fc6302f2ed49", + "size": 253145, + "subdir": "linux-64", + "timestamp": 1659280910728, + "version": "5.15.7" + }, + "pyqtchart-5.15.7-py310h6a678d5_1.tar.bz2": { + "build": "py310h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.10,<3.11.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "545fbec64cda16ef2592f03cf22bd4c9", + "name": "pyqtchart", + "sha256": "f392ff61516a3086f352700bbb8addd423627e4260ae90ef34699c9c1b810b76", + "size": 258027, + "subdir": "linux-64", + "timestamp": 1659390012217, + "version": "5.15.7" + }, + "pyqtchart-5.15.7-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.11,<3.12.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "ec76c8554842f0579e611701866cb171", + "name": "pyqtchart", + "sha256": "cd070e089e6b8321ad1821a1c517cdcc3df2e2e3619d65bdcb7d1b86b6851fc6", + "size": 253320, + "subdir": "linux-64", + "timestamp": 1676826830390, + "version": "5.15.7" + }, + "pyqtchart-5.15.7-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.7,<3.8.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "e60854409a4f402229b6b18d2e13f299", + "name": "pyqtchart", + "sha256": "1420c29e58755e15af939e11980543c49c33aa24f8e0b0bd8ce8199142f9272e", + "size": 251621, + "subdir": "linux-64", + "timestamp": 1659281130174, + "version": "5.15.7" + }, + "pyqtchart-5.15.7-py37h6a678d5_1.tar.bz2": { + "build": "py37h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.7,<3.8.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "f54b7c132141a026f981ba933f831ba9", + "name": "pyqtchart", + "sha256": "9eec60192e94e436f3b6b6497e7d1a184ab8fc9a20b575b2ef2f746ddaeadf07", + "size": 257549, + "subdir": "linux-64", + "timestamp": 1659390137294, + "version": "5.15.7" + }, + "pyqtchart-5.15.7-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.8,<3.9.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "8afa8a5f283d51a238812e379b63d994", + "name": "pyqtchart", + "sha256": "befc0c38c528cef97097f5866d5b61348f56472a21bad639cc708b471a4b7064", + "size": 253133, + "subdir": "linux-64", + "timestamp": 1659280797999, + "version": "5.15.7" + }, + "pyqtchart-5.15.7-py38h6a678d5_1.tar.bz2": { + "build": "py38h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.8,<3.9.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "233f6e6a443e598b2eced3b5efb79b8f", + "name": "pyqtchart", + "sha256": "65d24bb840069a7b955615c456fd3ae5e57fb05177e500cb334789578bcddcd7", + "size": 257642, + "subdir": "linux-64", + "timestamp": 1659390075005, + "version": "5.15.7" + }, + "pyqtchart-5.15.7-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.9,<3.10.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "37d11413bcacec85ae99be75613b6d9c", + "name": "pyqtchart", + "sha256": "9f3856d54bda8bc29ddb5c25b65999a9a8e8f2d56cce74d9f92f27e434232eb0", + "size": 252953, + "subdir": "linux-64", + "timestamp": 1659281019588, + "version": "5.15.7" + }, + "pyqtchart-5.15.7-py39h6a678d5_1.tar.bz2": { + "build": "py39h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.9,<3.10.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "9fe0a967c2ede945a6b03333709fe708", + "name": "pyqtchart", + "sha256": "51663e36eeb9e560529906990974a92046985ef54e9352283e02854f69709316", + "size": 257800, + "subdir": "linux-64", + "timestamp": 1659390200578, + "version": "5.15.7" + }, + "pyqtgraph-0.10.0-py27h28b3542_3.tar.bz2": { + "build": "py27h28b3542_3", + "build_number": 3, + "depends": [ + "numpy", + "pyqt", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8783eea862f437a0973fd0b3845f9c8f", + "name": "pyqtgraph", + "sha256": "f9eb934ddbfce3a2eac1311d2c8b0fadfb23b84a1b8bc7cfc7902ce5f6f5d30e", + "size": 1005371, + "subdir": "linux-64", + "timestamp": 1530902770761, + "version": "0.10.0" + }, + "pyqtgraph-0.10.0-py35h28b3542_3.tar.bz2": { + "build": "py35h28b3542_3", + "build_number": 3, + "depends": [ + "numpy", + "pyqt", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "28b7756baefa0a3f7113d40e5f5fad0f", + "name": "pyqtgraph", + "sha256": "0a0139df3049172b2715d2571803da4001448e898becfcdb9c92af97553d0346", + "size": 1021384, + "subdir": "linux-64", + "timestamp": 1537851461118, + "version": "0.10.0" + }, + "pyqtgraph-0.10.0-py36h28b3542_3.tar.bz2": { + "build": "py36h28b3542_3", + "build_number": 3, + "depends": [ + "numpy", + "pyqt", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9cf19813283d3b5e3d90b5e993c3494", + "name": "pyqtgraph", + "sha256": "a4b80c53589e10d6efe6bd2ef8a948058a973b6f314896941a89042ab1697b25", + "size": 1019204, + "subdir": "linux-64", + "timestamp": 1530902720268, + "version": "0.10.0" + }, + "pyqtgraph-0.10.0-py37h28b3542_3.tar.bz2": { + "build": "py37h28b3542_3", + "build_number": 3, + "depends": [ + "numpy", + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f953215dc79076ee92f37d697482498", + "name": "pyqtgraph", + "sha256": "d8d6779621bb12522773077b32b29e2c72af053256f1eaeaddbf30c7ee989f34", + "size": 1018795, + "subdir": "linux-64", + "timestamp": 1530902661230, + "version": "0.10.0" + }, + "pyqtgraph-0.12.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "pyside2 >=5.12", + "pyqt >=5.12" + ], + "depends": [ + "numpy", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebd1800a26208cd559cd90c4fc6daa3a", + "name": "pyqtgraph", + "sha256": "6ab5ae216207b58a00db8c02545f28666b51bc44891ee9c3b148da3b1c1d26c9", + "size": 1331586, + "subdir": "linux-64", + "timestamp": 1659341271623, + "version": "0.12.3" + }, + "pyqtgraph-0.12.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyside2 >=5.12", + "pyqt >=5.12" + ], + "depends": [ + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d817b92e7e506a0eb744e0d4fc28d950", + "name": "pyqtgraph", + "sha256": "9080e23e97886c079dc194faa3e4f4e914b46d12abfeeb2edf34ac77d7e21461", + "size": 1319328, + "subdir": "linux-64", + "timestamp": 1659341228606, + "version": "0.12.3" + }, + "pyqtgraph-0.12.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyside2 >=5.12", + "pyqt >=5.12" + ], + "depends": [ + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c3be511cb828f088f499a3f6efe5838", + "name": "pyqtgraph", + "sha256": "65049630829f16a1fe864348efbf6a3e4aa38426e2dcd786786690753db971c8", + "size": 1317162, + "subdir": "linux-64", + "timestamp": 1659341167268, + "version": "0.12.3" + }, + "pyqtgraph-0.12.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyside2 >=5.12", + "pyqt >=5.12" + ], + "depends": [ + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d6393d2855c20da36ce965ea160ca38", + "name": "pyqtgraph", + "sha256": "98e348b677f86e0a14a705c5f55eea2de8ed9e404e0984fa9938b0a69816cdc7", + "size": 1321579, + "subdir": "linux-64", + "timestamp": 1659341197417, + "version": "0.12.3" + }, + "pyqtgraph-0.13.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "pyside2 >=5.15", + "pyqt >=5.15" + ], + "depends": [ + "numpy >=1.20.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "908d5674b962324d42392d4411f4df6d", + "name": "pyqtgraph", + "sha256": "78b2125889e677335a9506a11c156794c8fce968e9013a9f129fa53086649074", + "size": 1345917, + "subdir": "linux-64", + "timestamp": 1673550109315, + "version": "0.13.1" + }, + "pyqtgraph-0.13.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "pyside2 >=5.15", + "pyqt >=5.15" + ], + "depends": [ + "numpy >=1.20.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f70ad8550166291a7a417eb9aa4aab5f", + "name": "pyqtgraph", + "sha256": "a1db6e9c03157fb6086173a232e7259a8eca2f4d5c9705f3253bea956ed4170e", + "size": 1717901, + "subdir": "linux-64", + "timestamp": 1676845423774, + "version": "0.13.1" + }, + "pyqtgraph-0.13.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyside2 >=5.15", + "pyqt >=5.15" + ], + "depends": [ + "numpy >=1.20.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a35faf0b375f249b4351a3cacf88b18", + "name": "pyqtgraph", + "sha256": "bb0412efb9c50d4b8f06eb0e2dc0e4f91a527c81c27112e756f855e022b73b34", + "size": 1333076, + "subdir": "linux-64", + "timestamp": 1673550071795, + "version": "0.13.1" + }, + "pyqtgraph-0.13.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyside2 >=5.15", + "pyqt >=5.15" + ], + "depends": [ + "numpy >=1.20.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bffb96672b674184dda2a09dd5ef91c5", + "name": "pyqtgraph", + "sha256": "59daddac3a019cfa0da0befbaee36c2f1ef37f15e904e990c0a4e4e9a39f8efd", + "size": 1334448, + "subdir": "linux-64", + "timestamp": 1673550144493, + "version": "0.13.1" + }, + "pyqtwebengine-5.15.7-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.10,<3.11.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "58820f56fc16f0245e825aedf786160d", + "name": "pyqtwebengine", + "sha256": "5a3f66260964831046c6bdc993ab275fe11be57dcc0274cd152bca0afcbac4da", + "size": 175295, + "subdir": "linux-64", + "timestamp": 1659281353779, + "version": "5.15.7" + }, + "pyqtwebengine-5.15.7-py310h6a678d5_1.tar.bz2": { + "build": "py310h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.10,<3.11.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "bcdae15c39a73b0b4410f98745c356d1", + "name": "pyqtwebengine", + "sha256": "73454d8f9a93e80636a69d643e3c3c6818bbb27ee180625166d7ce7f2baab928", + "size": 178494, + "subdir": "linux-64", + "timestamp": 1659390278283, + "version": "5.15.7" + }, + "pyqtwebengine-5.15.7-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.11,<3.12.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "7bcc72a0d447f2933b9c505cd4d9c7e9", + "name": "pyqtwebengine", + "sha256": "5dccf62de66bcaccafa2ea51c54a0bfa75e8aa4747d1278d84a6cd6736e16d2d", + "size": 174924, + "subdir": "linux-64", + "timestamp": 1676826911618, + "version": "5.15.7" + }, + "pyqtwebengine-5.15.7-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.7,<3.8.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "e78eefb0874e1945b4c2cbded08c804b", + "name": "pyqtwebengine", + "sha256": "be3314fefd0d96825e0ef065f97c2e55e314644e5cc2c477c268605d48dcd405", + "size": 174459, + "subdir": "linux-64", + "timestamp": 1659281578609, + "version": "5.15.7" + }, + "pyqtwebengine-5.15.7-py37h6a678d5_1.tar.bz2": { + "build": "py37h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.7,<3.8.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "4413eb81ab5f6565c4dcf8b9ba5898dd", + "name": "pyqtwebengine", + "sha256": "bbb1b369fd2ed17f75cd8b2974967f8ad0d121fafc4345ba9fe5f9b008c8e1af", + "size": 177871, + "subdir": "linux-64", + "timestamp": 1659390432594, + "version": "5.15.7" + }, + "pyqtwebengine-5.15.7-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.8,<3.9.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "84e9c5b5c0b4b9fa77549ccb3f41a1bf", + "name": "pyqtwebengine", + "sha256": "6e25da607ccca4c02050aec2d80006c984281c8c7e5f3474d4eb5f995368fbb6", + "size": 174820, + "subdir": "linux-64", + "timestamp": 1659281243424, + "version": "5.15.7" + }, + "pyqtwebengine-5.15.7-py38h6a678d5_1.tar.bz2": { + "build": "py38h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.8,<3.9.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "847fae7d62957430417fd90b8584847e", + "name": "pyqtwebengine", + "sha256": "2f572eec651388a3cf5045feaf4f5c8ab72861cc08bbb43b188ea30528bf06fe", + "size": 178355, + "subdir": "linux-64", + "timestamp": 1659390354179, + "version": "5.15.7" + }, + "pyqtwebengine-5.15.7-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.9,<3.10.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "f3166778bed2cf2451acac4f0761d852", + "name": "pyqtwebengine", + "sha256": "3f472ad54882c8c06c91896bb3b024da47a5fb320d498ca9856085f511c43871", + "size": 175075, + "subdir": "linux-64", + "timestamp": 1659281466545, + "version": "5.15.7" + }, + "pyqtwebengine-5.15.7-py39h6a678d5_1.tar.bz2": { + "build": "py39h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.9,<3.10.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "5b90a4b91eeb1d3060cc467c3e36b916", + "name": "pyqtwebengine", + "sha256": "fa3946b0055a979e86b1e76a232cd448efb5e9cf1ba3d96ba9521a36dfb858bb", + "size": 178232, + "subdir": "linux-64", + "timestamp": 1659390511115, + "version": "5.15.7" + }, + "pyquery-1.2.17-py27h0ca9866_0.tar.bz2": { + "build": "py27h0ca9866_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2c49e79666c7fab09692eff804ab7470", + "name": "pyquery", + "sha256": "f875ea63b310215c9933bb69ac4dbccb2f1d9c238c23d5abc555647337403b6c", + "size": 36032, + "subdir": "linux-64", + "timestamp": 1506925342346, + "version": "1.2.17" + }, + "pyquery-1.2.17-py35hdc30f01_0.tar.bz2": { + "build": "py35hdc30f01_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "90d7c11ad05565aa867ca8f9b72baa99", + "name": "pyquery", + "sha256": "49c1e8996dccefe4552f05d417c613a4a0df67c7de1c7c95cf4b130a4ac9ef6b", + "size": 37421, + "subdir": "linux-64", + "timestamp": 1506925350251, + "version": "1.2.17" + }, + "pyquery-1.2.17-py36h44e87f9_0.tar.bz2": { + "build": "py36h44e87f9_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5bbdfb4c128342431f7af0d17689197a", + "name": "pyquery", + "sha256": "79f92d91d72e09e513f69317f4a263adfa4019d6925a7573b80797546d70c5c8", + "size": 37196, + "subdir": "linux-64", + "timestamp": 1506925363209, + "version": "1.2.17" + }, + "pyquery-1.3.0-py27hc741669_0.tar.bz2": { + "build": "py27hc741669_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a3e0bc3ffdc574162d998726ef7f547a", + "name": "pyquery", + "sha256": "2e66ac7e214f732d16cf77e80867377ae791bd207592f40cabe9c0dad2310f49", + "size": 34174, + "subdir": "linux-64", + "timestamp": 1511321967730, + "version": "1.3.0" + }, + "pyquery-1.3.0-py35h19d6a88_0.tar.bz2": { + "build": "py35h19d6a88_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "88fb0445ad5b81085a7ec3725b63fbac", + "name": "pyquery", + "sha256": "bf5eddc8b530afb0680696284f84c93441c2b9a90e4af432d326a091a417c489", + "size": 35499, + "subdir": "linux-64", + "timestamp": 1511321976521, + "version": "1.3.0" + }, + "pyquery-1.3.0-py36h459d551_0.tar.bz2": { + "build": "py36h459d551_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3e92240c1217946c00db43109ee2e7cd", + "name": "pyquery", + "sha256": "8f0574c273293c6f2690d289f3a391f19dad21e49082796f7ce78fc0a6d148dd", + "size": 35297, + "subdir": "linux-64", + "timestamp": 1511321977746, + "version": "1.3.0" + }, + "pyquery-1.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "afb5c7a68a859ae80f44cd772e0ad233", + "name": "pyquery", + "sha256": "3ca8347dc338b6042b6af295e5dc55c45b8075dede734d3d29a33f2f32d422b6", + "size": 36540, + "subdir": "linux-64", + "timestamp": 1519365710199, + "version": "1.4.0" + }, + "pyquery-1.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5ea4288a1c9fb8a9617025007aa4ed49", + "name": "pyquery", + "sha256": "00c6f5300662e95135ce6270ccc2fadb77dff1c441d13890b766afa88dc2be17", + "size": 37813, + "subdir": "linux-64", + "timestamp": 1519365763444, + "version": "1.4.0" + }, + "pyquery-1.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4601a38b6a1282ce19460c128a8d7d04", + "name": "pyquery", + "sha256": "9d3cb46ec9dc57f90f894e5692838dbb691eb0f49e06fe1f3c008e6af0b8dd9f", + "size": 37595, + "subdir": "linux-64", + "timestamp": 1519365669956, + "version": "1.4.0" + }, + "pyquery-1.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e2b1ee35a500fd968ee1dae04b3b3f79", + "name": "pyquery", + "sha256": "5090621403b0abc9b683322379795cb57c08d5cc92d35e2f340e4cb8725e808d", + "size": 37574, + "subdir": "linux-64", + "timestamp": 1530875640864, + "version": "1.4.0" + }, + "pyquery-1.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2a0d2eb39995158c00f98dfc4061df01", + "name": "pyquery", + "sha256": "5afe972559b506da00b334065adbca3fbe910dcc9f12efe891ace59ecd03a1c0", + "size": 38180, + "subdir": "linux-64", + "timestamp": 1574094323298, + "version": "1.4.0" + }, + "pyquery-1.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e9bba1a478d3c2c1bf006b4ce9a6c692", + "name": "pyquery", + "sha256": "c0c9a122393f981b0fb082d3595cb2f0fa43dbef24e03eb26f78e69716768d32", + "size": 41188, + "subdir": "linux-64", + "timestamp": 1601589135216, + "version": "1.4.1" + }, + "pyquery-1.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9ffcee1b8fb8ae04089555f690984c5d", + "name": "pyquery", + "sha256": "d076e1b4984a04395a8ed62f1651246ce84d2f71d92d22a3064eb99e59a84ba5", + "size": 41290, + "subdir": "linux-64", + "timestamp": 1601589150135, + "version": "1.4.1" + }, + "pyquery-1.4.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a490ea43259336ca5a79949f7d995025", + "name": "pyquery", + "sha256": "1ee30199e1823bde8d92d2901496af553b12e04c89b41d39785844bbae10d0cc", + "size": 41425, + "subdir": "linux-64", + "timestamp": 1601589161808, + "version": "1.4.1" + }, + "pyquery-1.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8f4a454defc418630422f5f4913324ad", + "name": "pyquery", + "sha256": "773b1a6e26ba74af0f43e33041622d96dc7e0fa52afa1a9c193f6538121492f3", + "size": 40694, + "subdir": "linux-64", + "timestamp": 1640810456791, + "version": "1.4.3" + }, + "pyquery-1.4.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c34b733b349d960f3e962625bcad6956", + "name": "pyquery", + "sha256": "d393b640d701cb21f286ab129398f205e09faf37af4cfd6dcd0726489ceb92ef", + "size": 53298, + "subdir": "linux-64", + "timestamp": 1676861060126, + "version": "1.4.3" + }, + "pyquery-1.4.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cc199f970f960b7b6ebd46d1e463e2d1", + "name": "pyquery", + "sha256": "df2c59e96dc722147c5f2f79cecdfa4175c34bf2a0f5f185ec334ab965ed750d", + "size": 40370, + "subdir": "linux-64", + "timestamp": 1606843690457, + "version": "1.4.3" + }, + "pyquery-1.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9133595916512b637a675ef1a097bc2a", + "name": "pyquery", + "sha256": "7cf057aecc90f7663e7508f41fce57f1227a26a98ca1778104a8c7d48e3f2490", + "size": 40408, + "subdir": "linux-64", + "timestamp": 1606431079440, + "version": "1.4.3" + }, + "pyquery-1.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7944edb9682762440a6d7a24ec97f879", + "name": "pyquery", + "sha256": "01bb7ab7bc75a2c777f842ad88b8fd1da3c7b5f424d54b64b86dfa243a8bf6d2", + "size": 40498, + "subdir": "linux-64", + "timestamp": 1606431106291, + "version": "1.4.3" + }, + "pyquery-1.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "03a74e03d151a679c1ddf019f318ddac", + "name": "pyquery", + "sha256": "5db69f0987f5477565852b8cd0ce6d0ccbe2c2dac7864f3bedf111e48232d445", + "size": 41217, + "subdir": "linux-64", + "timestamp": 1613162206143, + "version": "1.4.3" + }, + "pyramid-1.10.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=2.7,<2.8.0a0", + "repoze.lru >=0.4", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "9acf868f2dd66356d0e4bcc41e4c54ba", + "name": "pyramid", + "sha256": "30793e816dce9c87f7fc528e3c986e497f6293dc1071cfa44deea4284ef4cfeb", + "size": 412945, + "subdir": "linux-64", + "timestamp": 1545149801318, + "version": "1.10.1" + }, + "pyramid-1.10.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.6,<3.7.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "1cc064b428addec06897f259aa337bab", + "name": "pyramid", + "sha256": "916a591bd0a84303a7a2d76c38bf7efe7e63273b2d6bc5cf1798adf56a13ced6", + "size": 406937, + "subdir": "linux-64", + "timestamp": 1545149813317, + "version": "1.10.1" + }, + "pyramid-1.10.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.7,<3.8.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "b688ca56c062d0c6e0a0d036d0728225", + "name": "pyramid", + "sha256": "4c045557f0dc06d694b44024c9de98364699eb3b2604916d449f40636acf47d6", + "size": 416527, + "subdir": "linux-64", + "timestamp": 1545149814864, + "version": "1.10.1" + }, + "pyramid-1.10.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=2.7,<2.8.0a0", + "repoze.lru >=0.4", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "0014d29f1b7034bf812704af22b3d302", + "name": "pyramid", + "sha256": "092b7001867d6405e3d6fe771eecbdefb4bdb27b63c2746659f0da98ea7e338c", + "size": 547068, + "subdir": "linux-64", + "timestamp": 1552446158397, + "version": "1.10.2" + }, + "pyramid-1.10.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.6,<3.7.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "58076d9be54c5195da7b2981f433f679", + "name": "pyramid", + "sha256": "bfdb6b9daa8f6effe8596e0841941a3ec2149602fd42c4440d31ac67e4ccd9d6", + "size": 558253, + "subdir": "linux-64", + "timestamp": 1552446139221, + "version": "1.10.2" + }, + "pyramid-1.10.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.7,<3.8.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "93a125435e0896da0d6169fc67e0e8a8", + "name": "pyramid", + "sha256": "3e8b0eb8756af3ac59237d86c4126d623fc93c40ccc9a5d2ae080ef6664f5a48", + "size": 544605, + "subdir": "linux-64", + "timestamp": 1552446140514, + "version": "1.10.2" + }, + "pyramid-1.10.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=2.7,<2.8.0a0", + "repoze.lru >=0.4", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "944110f4f4494daa995e7821b9a1f122", + "name": "pyramid", + "sha256": "c5f9855510431743a3a5df7e7a6b5560533997b0d6bbe2146efc67f17a443158", + "size": 552570, + "subdir": "linux-64", + "timestamp": 1564680354695, + "version": "1.10.4" + }, + "pyramid-1.10.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.10,<3.11.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "efd41b0216129a1a566b53fc1bf73d49", + "name": "pyramid", + "sha256": "db2f23392c5681420e981011696b4fee8bfa59efdab4fb18fc3df2a68e25885d", + "size": 412638, + "subdir": "linux-64", + "timestamp": 1642513151488, + "version": "1.10.4" + }, + "pyramid-1.10.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.11,<3.12.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "06a733f1f43115cc611378d8586c46da", + "name": "pyramid", + "sha256": "0316106ac678cc5a7e337a29b53ca421ef7a51a22a4db0efd40b6594796e0504", + "size": 506060, + "subdir": "linux-64", + "timestamp": 1676905972623, + "version": "1.10.4" + }, + "pyramid-1.10.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.6,<3.7.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "ade595309ac236ae3537179c85b405cd", + "name": "pyramid", + "sha256": "e790b364e411757b852db5ddb1f0762eb22df18adf94757fa508d7e3ce099202", + "size": 578357, + "subdir": "linux-64", + "timestamp": 1564680023283, + "version": "1.10.4" + }, + "pyramid-1.10.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.6,<3.7.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "a8aa14b81d1b4ca2d68d576dc4a191ed", + "name": "pyramid", + "sha256": "6274a92b58041d2f1abf44a3405dc99ea4d7d85f5881c2e5734b98f713fa6c21", + "size": 646285, + "subdir": "linux-64", + "timestamp": 1614249814028, + "version": "1.10.4" + }, + "pyramid-1.10.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.7,<3.8.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "508b7858a4bb7f2cd61d0cd78e03eef9", + "name": "pyramid", + "sha256": "1779f2c2c98a1563c8eae7f3b437f3340c0548af3c2cbfa02f4f203b376b16b0", + "size": 552442, + "subdir": "linux-64", + "timestamp": 1564679935359, + "version": "1.10.4" + }, + "pyramid-1.10.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.7,<3.8.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "97faed8a353bf65a322b033919f40903", + "name": "pyramid", + "sha256": "90b206170c374f7aae4f6e55fa2941f97dcd181197197eee9308402325e20b9f", + "size": 640872, + "subdir": "linux-64", + "timestamp": 1614249742382, + "version": "1.10.4" + }, + "pyramid-1.10.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.8,<3.9.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "fd72c7744a5a55a6a62a6fa994031344", + "name": "pyramid", + "sha256": "c557d7b23818b2fc6b5541464a8d4e2b9b68c3d2d66decf8ee126c0f7046108c", + "size": 416632, + "subdir": "linux-64", + "timestamp": 1574177665640, + "version": "1.10.4" + }, + "pyramid-1.10.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.8,<3.9.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "a23d74bef63cfc7a3c8f0ed668b16503", + "name": "pyramid", + "sha256": "7034127d947034e348fab49beb851cc0809c9a68cebf16b9a99773b02b61fae6", + "size": 646995, + "subdir": "linux-64", + "timestamp": 1614249829973, + "version": "1.10.4" + }, + "pyramid-1.10.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.9,<3.10.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "f54be8ea4bf3621a1cfd7ee3ed0aa248", + "name": "pyramid", + "sha256": "3473026f6390bc48fa1c8f7b5d58928767f3d9fb518436a700279eedf4a9010b", + "size": 648897, + "subdir": "linux-64", + "timestamp": 1614249827472, + "version": "1.10.4" + }, + "pyramid-1.9.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "hupper", + "pastedeploy >=1.5.0", + "plaster", + "plaster_pastedeploy", + "python >=2.7,<2.8.0a0", + "repoze.lru >=0.4", + "translationstring >=0.4", + "venusian >=1.0a3", + "webob >=1.7.0", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "d75f26b27ec8f44695d214dde4155508", + "name": "pyramid", + "sha256": "f5287248749ad1e5f7f4158919873fc032059b565754563cfba75cd00fe494da", + "size": 830712, + "subdir": "linux-64", + "timestamp": 1530028472643, + "version": "1.9.2" + }, + "pyramid-1.9.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "hupper", + "pastedeploy >=1.5.0", + "plaster", + "plaster_pastedeploy", + "python >=3.5,<3.6.0a0", + "repoze.lru >=0.4", + "translationstring >=0.4", + "venusian >=1.0a3", + "webob >=1.7.0", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "fe60e4fff686a45cff31362d2aea60bd", + "name": "pyramid", + "sha256": "2619597826e28186b77cdf0cf4f65ba3fa48d292aa1b1ae12650d5437c52b85e", + "size": 858045, + "subdir": "linux-64", + "timestamp": 1530028077955, + "version": "1.9.2" + }, + "pyramid-1.9.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "hupper", + "pastedeploy >=1.5.0", + "plaster", + "plaster_pastedeploy", + "python >=3.6,<3.7.0a0", + "repoze.lru >=0.4", + "translationstring >=0.4", + "venusian >=1.0a3", + "webob >=1.7.0", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "70d8294bae065feaedb6d2a07f4d5c03", + "name": "pyramid", + "sha256": "439ca7d38a423d7c470a242acab06fdb6bde90c3e9df035f7567799e5a80321c", + "size": 851721, + "subdir": "linux-64", + "timestamp": 1530027991580, + "version": "1.9.2" + }, + "pyramid-1.9.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "hupper", + "pastedeploy >=1.5.0", + "plaster", + "plaster_pastedeploy", + "python >=3.7,<3.8.0a0", + "repoze.lru >=0.4", + "translationstring >=0.4", + "venusian >=1.0a3", + "webob >=1.7.0", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "256db1475f6a6ce4a6e81f8310d3f589", + "name": "pyramid", + "sha256": "5fa36a76c27e481d6fe355e5d6a344a2a075515d2ef0ffd3f624df0083db7888", + "size": 853032, + "subdir": "linux-64", + "timestamp": 1530875797499, + "version": "1.9.2" + }, + "pyramid-2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "hupper >=1.5", + "plaster", + "plaster_pastedeploy", + "python >=3.9,<3.10.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "LicenseRef-Pylons", + "license_family": "BSD", + "md5": "4e7de0e7a3f32286e42163f1b9312537", + "name": "pyramid", + "sha256": "ca74af462f202476fa636f8b1174c897e1a91c6379a47105c2a57ee057080608", + "size": 362861, + "subdir": "linux-64", + "timestamp": 1619444200052, + "version": "2.0" + }, + "pyramid_debugtoolbar-4.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "pygments", + "pyramid >=1.4", + "pyramid_mako >=0.3.1", + "python >=2.7,<2.8.0a0", + "repoze.lru" + ], + "license": "BSD", + "md5": "f8fd38c5c03836efdc2d37b0c67c61e9", + "name": "pyramid_debugtoolbar", + "sha256": "057d5a7696e1aa32dab08e6e32cf5e845fe19e4d6a39c78a6b3d3ad736a0b126", + "size": 340241, + "subdir": "linux-64", + "timestamp": 1530035442856, + "version": "4.4" + }, + "pyramid_debugtoolbar-4.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pygments", + "pyramid >=1.4", + "pyramid_mako >=0.3.1", + "python >=3.5,<3.6.0a0", + "repoze.lru" + ], + "license": "BSD", + "md5": "672383053d21b49b071db621019493cd", + "name": "pyramid_debugtoolbar", + "sha256": "178c46b7628cc009477db0a17ea5de34cc1c1e8458b39a50237759be655834ca", + "size": 342054, + "subdir": "linux-64", + "timestamp": 1530035470572, + "version": "4.4" + }, + "pyramid_debugtoolbar-4.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "pyramid >=1.4", + "pyramid_mako >=0.3.1", + "python >=3.6,<3.7.0a0", + "repoze.lru" + ], + "license": "BSD", + "md5": "43a4ed079c22aa284a8f31b5b2988f8f", + "name": "pyramid_debugtoolbar", + "sha256": "b6eddb0002421061a8e78122f4576aa2931a75106f5f1061f6839473636ffd7b", + "size": 341881, + "subdir": "linux-64", + "timestamp": 1530035415820, + "version": "4.4" + }, + "pyramid_debugtoolbar-4.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "pygments", + "pyramid >=1.4", + "pyramid_mako >=0.3.1", + "python >=2.7,<2.8.0a0", + "repoze.lru" + ], + "license": "BSD", + "md5": "c34ff6ca00ba5af8456a3c0d470c0ba0", + "name": "pyramid_debugtoolbar", + "sha256": "c1d76ccc197ecc04ed687a5dafc7de8db73683560e547c414a459721b05ebaea", + "size": 509763, + "subdir": "linux-64", + "timestamp": 1569442543331, + "version": "4.5" + }, + "pyramid_debugtoolbar-4.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pygments", + "pyramid >=1.4", + "pyramid_mako >=0.3.1", + "python >=3.10,<3.11.0a0", + "repoze.lru" + ], + "license": "BSD", + "md5": "3e721332648727d1abb5f5cf86e914b4", + "name": "pyramid_debugtoolbar", + "sha256": "d2d1fe48d87192a1e47eaa92da312cfb8bde93c8748f69a1d237e64d84e7c72e", + "size": 350128, + "subdir": "linux-64", + "timestamp": 1640810475403, + "version": "4.5" + }, + "pyramid_debugtoolbar-4.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "pyramid >=1.4", + "pyramid_mako >=0.3.1", + "python >=3.6,<3.7.0a0", + "repoze.lru" + ], + "license": "BSD", + "md5": "2379d620145e0c2b2cf5bea883d3573b", + "name": "pyramid_debugtoolbar", + "sha256": "7d55e9fdf36a3ca1c09d19bac9eb261e9879659acb5b96e7426dec283af7dacf", + "size": 498870, + "subdir": "linux-64", + "timestamp": 1569442546230, + "version": "4.5" + }, + "pyramid_debugtoolbar-4.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "pyramid >=1.4", + "pyramid_mako >=0.3.1", + "python >=3.7,<3.8.0a0", + "repoze.lru" + ], + "license": "BSD", + "md5": "82c1defca84aac8c934cc4b721376762", + "name": "pyramid_debugtoolbar", + "sha256": "9ea4052deb56435e34e99fe27caeb793529000c9cfab8db21e6c4129c91fdd30", + "size": 503105, + "subdir": "linux-64", + "timestamp": 1569442598839, + "version": "4.5" + }, + "pyramid_debugtoolbar-4.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pygments", + "pyramid >=1.4", + "pyramid_mako >=0.3.1", + "python >=3.8,<3.9.0a0", + "repoze.lru" + ], + "license": "BSD", + "md5": "59da629f473e27a46b6d1b165e33d01c", + "name": "pyramid_debugtoolbar", + "sha256": "c467575c40184a9f5e1f6090e024b07c6ae5cdb54266ce4b0060f8599404302e", + "size": 354043, + "subdir": "linux-64", + "timestamp": 1574238067583, + "version": "4.5" + }, + "pyramid_jinja2-2.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.5.0", + "markupsafe", + "pyramid >=1.3.0", + "python >=2.7,<2.8.0a0", + "zope.deprecation" + ], + "license": "BSD", + "md5": "5e4e72920e75047d1eef52fe6e95c033", + "name": "pyramid_jinja2", + "sha256": "2b11fbb54fddb95fcf24cce01199c0bd905e5ca295e32614ff70d073a794408d", + "size": 70083, + "subdir": "linux-64", + "timestamp": 1530034886508, + "version": "2.7" + }, + "pyramid_jinja2-2.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.5.0", + "markupsafe", + "pyramid >=1.3.0", + "python >=3.5,<3.6.0a0", + "zope.deprecation" + ], + "license": "BSD", + "md5": "ee6af7d89636a6d2d985d085e154b1cb", + "name": "pyramid_jinja2", + "sha256": "fc844ace0f372a8bdf01eaabbfd29d713ad7d2bf7b4ea4f58e55e23eae4aa32f", + "size": 71952, + "subdir": "linux-64", + "timestamp": 1530034913805, + "version": "2.7" + }, + "pyramid_jinja2-2.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.5.0", + "markupsafe", + "pyramid >=1.3.0", + "python >=3.6,<3.7.0a0", + "zope.deprecation" + ], + "license": "BSD", + "md5": "4ec69cfed0fbe6dfe2139c0b312b9de2", + "name": "pyramid_jinja2", + "sha256": "8313b225135bc022fd612df0a3b2e8c12d633723aa118be4d6ccf1c2f08bf850", + "size": 71771, + "subdir": "linux-64", + "timestamp": 1530034862322, + "version": "2.7" + }, + "pyramid_mako-1.0.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "mako >=0.8", + "pyramid", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "03ebf34e8780aa79e61867c25704d9e1", + "name": "pyramid_mako", + "sha256": "1f99ac4fe1b6cee410ba418054b2328e4a91e5731d5068b14d43338ed1ec4f0a", + "size": 21436, + "subdir": "linux-64", + "timestamp": 1530035132147, + "version": "1.0.2" + }, + "pyramid_mako-1.0.2-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "mako >=0.8", + "pyramid", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "4124936e53ae6c638f45b7d885903e52", + "name": "pyramid_mako", + "sha256": "4183d6a57e356fa5a2cb191581a8bd2fdaabc6acd66eeb9a278a2af4e81a9383", + "size": 22207, + "subdir": "linux-64", + "timestamp": 1530035147948, + "version": "1.0.2" + }, + "pyramid_mako-1.0.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "mako >=0.8", + "pyramid", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "4d769959ac72d4419ed9d93dd7c20780", + "name": "pyramid_mako", + "sha256": "0bad4c03031f1aea74b0b9e8b6e0ad1c01810dd57b750c3ef86a5ee4af7731d2", + "size": 22164, + "subdir": "linux-64", + "timestamp": 1530035100315, + "version": "1.0.2" + }, + "pyramid_mako-1.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako >=1.1.0", + "pyramid", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "0c8c9877255cc5a3b130002ff5145985", + "name": "pyramid_mako", + "sha256": "67f6f54009c6229948bb07b98f03e214190ce068298414df1ca45cea437cf09e", + "size": 171340, + "subdir": "linux-64", + "timestamp": 1569442388991, + "version": "1.1.0" + }, + "pyramid_mako-1.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "mako >=1.1.0", + "pyramid", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "3519cb93d1510cf4575bcbee837abaf2", + "name": "pyramid_mako", + "sha256": "b400da77f356d2dbb77cb0603ca51482277576d5b15aa766fd8191c1884d0b54", + "size": 26503, + "subdir": "linux-64", + "timestamp": 1640793629612, + "version": "1.1.0" + }, + "pyramid_mako-1.1.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "mako >=1.1.0", + "pyramid", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "md5": "18d2661e51fedf4cc9493daea32c2dc5", + "name": "pyramid_mako", + "sha256": "26e46512038e8f6876b0701912be79d88da61925f73b00484d2ee2106fb413ca", + "size": 33719, + "subdir": "linux-64", + "timestamp": 1676906158023, + "version": "1.1.0" + }, + "pyramid_mako-1.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako >=1.1.0", + "pyramid", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "a9aede93cc9e30f5209e54a0ab154aef", + "name": "pyramid_mako", + "sha256": "e9bccb6e8a4b6d9a51466b1f73ff0f6db0763b411c5fdcd436309345f611d6bc", + "size": 172078, + "subdir": "linux-64", + "timestamp": 1569442391086, + "version": "1.1.0" + }, + "pyramid_mako-1.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako >=1.1.0", + "pyramid", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "556c428e77212af787b31830bfb565f5", + "name": "pyramid_mako", + "sha256": "5bfeafbd709a858c73e87d43425b807f24f8ac9fd81a273be566b02e6bed3e39", + "size": 172144, + "subdir": "linux-64", + "timestamp": 1569442384259, + "version": "1.1.0" + }, + "pyramid_mako-1.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "mako >=1.1.0", + "pyramid", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "e1a17ec1539aeea14d9eea86b548d225", + "name": "pyramid_mako", + "sha256": "18f12462737f4151109c9811fdbdd7e1bb09e9745a622242f66b8bafeda088a2", + "size": 26305, + "subdir": "linux-64", + "timestamp": 1574183905707, + "version": "1.1.0" + }, + "pyramid_tm-2.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyramid >=1.5", + "python >=2.7,<2.8.0a0", + "transaction >=2.0" + ], + "license": "BSD", + "md5": "bcd3daf03edfd3e5cc1e024232f1decc", + "name": "pyramid_tm", + "sha256": "300ae74f55c84747a6b5a718002d54bc5b4189d82b84944ba7a53710ab54ba78", + "size": 26561, + "subdir": "linux-64", + "timestamp": 1530036153619, + "version": "2.2" + }, + "pyramid_tm-2.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyramid >=1.5", + "python >=3.5,<3.6.0a0", + "transaction >=2.0" + ], + "license": "BSD", + "md5": "c4561ebddffeb1f394a6fa66270e6514", + "name": "pyramid_tm", + "sha256": "a4a4f513c9642b6fa7728c277772117149939968d0fb02925f805b10130ffb07", + "size": 27747, + "subdir": "linux-64", + "timestamp": 1530036167802, + "version": "2.2" + }, + "pyramid_tm-2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyramid >=1.5", + "python >=3.6,<3.7.0a0", + "transaction >=2.0" + ], + "license": "BSD", + "md5": "f4d88da26528ad541f80ebbb342f8b56", + "name": "pyramid_tm", + "sha256": "25047f25ec0524d84848e1b1f332b1b9b1c14f1456c69e54655cb556fdbad11e", + "size": 27736, + "subdir": "linux-64", + "timestamp": 1530036132802, + "version": "2.2" + }, + "pyramid_tm-2.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyramid >=1.5", + "python >=2.7,<2.8.0a0", + "transaction >=2.0" + ], + "license": "BSD", + "md5": "74f82ca117f458588e58074c419a4d0a", + "name": "pyramid_tm", + "sha256": "2bdb6f979edf73f4c8787aa830e8370edb8b5d6d469ac36f56c33aaa7747ccee", + "size": 26834, + "subdir": "linux-64", + "timestamp": 1541033398016, + "version": "2.2.1" + }, + "pyramid_tm-2.2.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pyramid >=1.5", + "python >=3.10,<3.11.0a0", + "transaction >=2.0" + ], + "license": "BSD", + "md5": "d77fcb1fbf21269efe2fed35fd3d2e78", + "name": "pyramid_tm", + "sha256": "aa23a6e8abf6fc4b8b149256316420a8a971258c8f5ff79e72f6f7b4aefc1923", + "size": 28647, + "subdir": "linux-64", + "timestamp": 1640813612815, + "version": "2.2.1" + }, + "pyramid_tm-2.2.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pyramid >=1.5", + "python >=3.11,<3.12.0a0", + "transaction >=2.0" + ], + "license": "BSD", + "md5": "7f48c3704e135305d31acac40b1718ae", + "name": "pyramid_tm", + "sha256": "d743942007cab54089541c3537211768d4f1b6d200cfa60082124b19c92760f7", + "size": 35777, + "subdir": "linux-64", + "timestamp": 1676907600136, + "version": "2.2.1" + }, + "pyramid_tm-2.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyramid >=1.5", + "python >=3.6,<3.7.0a0", + "transaction >=2.0" + ], + "license": "BSD", + "md5": "62f93221e0fbeeca5beefaa54fb03b26", + "name": "pyramid_tm", + "sha256": "b4ad30f1e04861a8217795e8ad0ee324aad5b0c5b46ff5e76f58171cc002f799", + "size": 28041, + "subdir": "linux-64", + "timestamp": 1541033429031, + "version": "2.2.1" + }, + "pyramid_tm-2.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyramid >=1.5", + "python >=3.7,<3.8.0a0", + "transaction >=2.0" + ], + "license": "BSD", + "md5": "31fbff1ffa1c91c67696cffd99e3b347", + "name": "pyramid_tm", + "sha256": "6f1ac14371e2aea60dd15663155139cd501f4297cfbb85aec0134eb8cdcf683e", + "size": 28121, + "subdir": "linux-64", + "timestamp": 1541033382358, + "version": "2.2.1" + }, + "pyramid_tm-2.2.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pyramid >=1.5", + "python >=3.8,<3.9.0a0", + "transaction >=2.0" + ], + "license": "BSD", + "md5": "9425347b0118b69ce524ef00afaa5ab3", + "name": "pyramid_tm", + "sha256": "42c6bafbc4135b9472c307e45355cafc5515eb3c96093744f492bd16bb7a2ac7", + "size": 28624, + "subdir": "linux-64", + "timestamp": 1574235860908, + "version": "2.2.1" + }, + "pyrsistent-0.14.11-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71fb81665e9c143202ca4c46c0e71c57", + "name": "pyrsistent", + "sha256": "87de58223a7a3cdb3b9635ba62cade474d34c4e52ec0acdd01a1baeacc6a0068", + "size": 89898, + "subdir": "linux-64", + "timestamp": 1552335705303, + "version": "0.14.11" + }, + "pyrsistent-0.14.11-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7536a335cc804b701e4e314b2641fb9c", + "name": "pyrsistent", + "sha256": "5495ce8130fe8ebdad0ad652141ca5e4c78fd30bcc487effef2fc2ab0b8d3ded", + "size": 94812, + "subdir": "linux-64", + "timestamp": 1615492147738, + "version": "0.14.11" + }, + "pyrsistent-0.14.11-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90551c2076a435a4c784a795eb07f4bd", + "name": "pyrsistent", + "sha256": "a01f83b2d3f6cf7bbc206dd02e0dc2efadb9fa1a95d2139d8b9650726fac370d", + "size": 92120, + "subdir": "linux-64", + "timestamp": 1552335753747, + "version": "0.14.11" + }, + "pyrsistent-0.14.11-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f020a99e795453da3acd0aa4b83c262c", + "name": "pyrsistent", + "sha256": "4c1cb4c181e61cd40526aca36e0e20c65328214af42e9fafc66b115a06ec52f6", + "size": 94804, + "subdir": "linux-64", + "timestamp": 1615493771112, + "version": "0.14.11" + }, + "pyrsistent-0.14.11-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ce465ebc5e66689f15f8cd4cba565cb", + "name": "pyrsistent", + "sha256": "03dea960574b6e0d30c3ca5e4fcb9baeb213957bcb6d3fa0d1611b9e61a6a9a1", + "size": 91891, + "subdir": "linux-64", + "timestamp": 1552335694793, + "version": "0.14.11" + }, + "pyrsistent-0.14.11-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "06b8feba2168655a4fe9f403e854cf14", + "name": "pyrsistent", + "sha256": "008dfeaf156a07b4c5817f9f6b19a5e694ba29846d2b8c974eee1589766c88da", + "size": 95402, + "subdir": "linux-64", + "timestamp": 1615493775819, + "version": "0.14.11" + }, + "pyrsistent-0.14.11-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8bdc93218c8f3c3c4e63d31e68ee4f47", + "name": "pyrsistent", + "sha256": "0822f30b5e789ebd691165e654ea3d0fc93ef679ddebb53d1ce10910154a222c", + "size": 92523, + "subdir": "linux-64", + "timestamp": 1594843798058, + "version": "0.14.11" + }, + "pyrsistent-0.14.11-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ad07e69ca135c27bedebbaf303a0ea4", + "name": "pyrsistent", + "sha256": "5e06578e85075af611be826bc374a8ca22038c2cda11a64bbef555452d7a0296", + "size": 95243, + "subdir": "linux-64", + "timestamp": 1615493772411, + "version": "0.14.11" + }, + "pyrsistent-0.15.4-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3305a2644ca6daee7da605ebab58a427", + "name": "pyrsistent", + "sha256": "eb5182d27b675ca4b066251e44b42d2c877f0fc5af085a2de80ef8433305e8ad", + "size": 92262, + "subdir": "linux-64", + "timestamp": 1569427177560, + "version": "0.15.4" + }, + "pyrsistent-0.15.4-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc0213715c7e6f3de3163d5abe67df76", + "name": "pyrsistent", + "sha256": "27975a8176e80bd5670ba5958f7ea02c6afe008b77564bbd22abccabde66fcb8", + "size": 94533, + "subdir": "linux-64", + "timestamp": 1569427169167, + "version": "0.15.4" + }, + "pyrsistent-0.15.4-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74d1a50047611b985611b9cf45fbb784", + "name": "pyrsistent", + "sha256": "4cd43be994a38832ebea43f1ebc2aa6aff424ff9ffc96a1df725898884de74e5", + "size": 94460, + "subdir": "linux-64", + "timestamp": 1569427193644, + "version": "0.15.4" + }, + "pyrsistent-0.15.4-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "611510e15b29da1a550216d053366029", + "name": "pyrsistent", + "sha256": "eb438b089c184446907c21e75c653f4e4abad44025105eb92868eb24d37f8bf3", + "size": 99413, + "subdir": "linux-64", + "timestamp": 1574092704931, + "version": "0.15.4" + }, + "pyrsistent-0.15.5-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d74dbd38937be876286f44a4c0e33eb", + "name": "pyrsistent", + "sha256": "0031aafd70240af8447dbf2039ea9d9fcff766156c5ed232c275092588bcf2bb", + "size": 92948, + "subdir": "linux-64", + "timestamp": 1573940662796, + "version": "0.15.5" + }, + "pyrsistent-0.15.5-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6442e9892a12c2b0056a04c37e975b0d", + "name": "pyrsistent", + "sha256": "fc23caf8ecef6f37695d0916109c8caac51b48d4344c4fa1a6eb4d7be5ed8122", + "size": 94843, + "subdir": "linux-64", + "timestamp": 1573940684003, + "version": "0.15.5" + }, + "pyrsistent-0.15.5-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c1062b3c4ba601a721b2a965e2d739e", + "name": "pyrsistent", + "sha256": "138b56c28a46daefdae1708d812c9f735a98aa4a41471f68a76da2413abc539b", + "size": 94777, + "subdir": "linux-64", + "timestamp": 1573940670837, + "version": "0.15.5" + }, + "pyrsistent-0.15.5-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0ab3d7cedf9b9e52b516b7579238d5c2", + "name": "pyrsistent", + "sha256": "3ecce6019ea777e0e25fe5c885d241b2ab87f56904a974b3c504818f98a7deca", + "size": 102410, + "subdir": "linux-64", + "timestamp": 1573940647946, + "version": "0.15.5" + }, + "pyrsistent-0.15.6-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "28d792c4a0f16d30a7c17e3be6336fec", + "name": "pyrsistent", + "sha256": "4a6190634327af8554bf71682eb87f95b661be28cd87a04d49b892378117925b", + "size": 92909, + "subdir": "linux-64", + "timestamp": 1574700015614, + "version": "0.15.6" + }, + "pyrsistent-0.15.6-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ec5fd19a99e9b34562a524c157fc703", + "name": "pyrsistent", + "sha256": "e05a17053e28da248eaa18af19e94599943e1e48545253f78a3b557c8f95fa59", + "size": 94891, + "subdir": "linux-64", + "timestamp": 1574700013653, + "version": "0.15.6" + }, + "pyrsistent-0.15.6-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9db043861af7bdae60719cf66d8e0e7c", + "name": "pyrsistent", + "sha256": "8790f39826ccf8b0c814f3bf5bd0c3bee86ea79f02847da5b6bf03cf0cac92eb", + "size": 95048, + "subdir": "linux-64", + "timestamp": 1574699995091, + "version": "0.15.6" + }, + "pyrsistent-0.15.6-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e063f0308af487ebb985f2df7e4a754c", + "name": "pyrsistent", + "sha256": "a2bd624139c988fd966e9aa6cd41a502e251e1d539612d94cd3da465d9c1906d", + "size": 102487, + "subdir": "linux-64", + "timestamp": 1574700028216, + "version": "0.15.6" + }, + "pyrsistent-0.15.7-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "04a0c8155e9badca3ced3da1236b3058", + "name": "pyrsistent", + "sha256": "cb7cb581f7da3c8331112ba0b08e8681d3c716a1c6977a29bbe7328c9d1d41de", + "size": 95188, + "subdir": "linux-64", + "timestamp": 1580153830865, + "version": "0.15.7" + }, + "pyrsistent-0.15.7-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f8957168cc798817a457c9242ab38c8", + "name": "pyrsistent", + "sha256": "aa23b8ccd917e39ce2277e683c5f1d6b42aac5744ec551ff55de4f603f3d4a9b", + "size": 95145, + "subdir": "linux-64", + "timestamp": 1580153809946, + "version": "0.15.7" + }, + "pyrsistent-0.15.7-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a3d7812f546c21fb6f341d844d164d4", + "name": "pyrsistent", + "sha256": "a418b1005b37f0ca3a92e19e3efd12c161ac05e2016f7e42a51b2478ab25cd03", + "size": 95582, + "subdir": "linux-64", + "timestamp": 1580153876832, + "version": "0.15.7" + }, + "pyrsistent-0.16.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71c4e531d80c48c729007b49b2770a63", + "name": "pyrsistent", + "sha256": "feca90cbedc8db50abc67e67367e7963d538a84fcdf91d95e4172687ec8a8acc", + "size": 95585, + "subdir": "linux-64", + "timestamp": 1585588106217, + "version": "0.16.0" + }, + "pyrsistent-0.16.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5988cfc145c124f8c8856a6809561a62", + "name": "pyrsistent", + "sha256": "41dc5390d4b518de9dd608abfc30820723f98ebafb712c78df281808dff71483", + "size": 95608, + "subdir": "linux-64", + "timestamp": 1585588063894, + "version": "0.16.0" + }, + "pyrsistent-0.16.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4af654a1c97842bcea4f83d1cac660af", + "name": "pyrsistent", + "sha256": "c5487e90ebbc38e37f8fcd9e947c1c02ea9601cb5b13d75c0314087fbfacd172", + "size": 96183, + "subdir": "linux-64", + "timestamp": 1585588114895, + "version": "0.16.0" + }, + "pyrsistent-0.17.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "007308ffd0a27472efe89d6ff46a43ca", + "name": "pyrsistent", + "sha256": "13a1cb8969cb092b60d9d9651cea48d4e39f0f12519047e5061be60b9ee574ba", + "size": 91172, + "subdir": "linux-64", + "timestamp": 1600141762698, + "version": "0.17.3" + }, + "pyrsistent-0.17.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a649f8b15b3b3c115e79c148c5a82054", + "name": "pyrsistent", + "sha256": "f62ea34204f1d15eef918248322852e6f895a6eb1d17b0faec7e31065d5075f4", + "size": 91172, + "subdir": "linux-64", + "timestamp": 1600141741298, + "version": "0.17.3" + }, + "pyrsistent-0.17.3-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "164b315516f526d700664abe6c92cd76", + "name": "pyrsistent", + "sha256": "67507f89dedbc2acb8d00a8fba4ff4184f098a01d3a79f11e89c066c32942806", + "size": 91753, + "subdir": "linux-64", + "timestamp": 1600141756807, + "version": "0.17.3" + }, + "pyrsistent-0.17.3-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "335e4702f3b1707f1fab0fa132b2fac9", + "name": "pyrsistent", + "sha256": "5ab18b79dcf7e1900882756a82a82444c68f97cf384b526e40c8723f7ff5e6d5", + "size": 96190, + "subdir": "linux-64", + "timestamp": 1607365214229, + "version": "0.17.3" + }, + "pyrsistent-0.18.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa93b46d0393c943b54aa9a01669b651", + "name": "pyrsistent", + "sha256": "e5362c4925b888dc7ca4ca8378663c473b2279b2643b76e182b977f0f9363d2d", + "size": 124226, + "subdir": "linux-64", + "timestamp": 1640807221148, + "version": "0.18.0" + }, + "pyrsistent-0.18.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c5fe7ad7d1ba957643071f3dcdee538", + "name": "pyrsistent", + "sha256": "ee2b60e207a4fffeed9b9222a2dbe4c4fd98e89e741b6a87e4f03498961bdacc", + "size": 118209, + "subdir": "linux-64", + "timestamp": 1676823106025, + "version": "0.18.0" + }, + "pyrsistent-0.18.0-py37heee7806_0.tar.bz2": { + "build": "py37heee7806_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2597d4de7f4831c906b810e17e2a610c", + "name": "pyrsistent", + "sha256": "b31c59106b9dc526dc195aa76bbc1045ca7731d644dcfeca4e2398c41f361e0a", + "size": 96722, + "subdir": "linux-64", + "timestamp": 1636098940720, + "version": "0.18.0" + }, + "pyrsistent-0.18.0-py38heee7806_0.tar.bz2": { + "build": "py38heee7806_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7528db4bd42c5b961b3bf7fd41b028a1", + "name": "pyrsistent", + "sha256": "cdb902390f42cd9eeab33f1d55cf6b09baa7f9e4b00be46cb29ff7bd94d1e613", + "size": 97208, + "subdir": "linux-64", + "timestamp": 1636110987189, + "version": "0.18.0" + }, + "pyrsistent-0.18.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31553251c017c628b2d8130c97b8b97c", + "name": "pyrsistent", + "sha256": "465d50dbaccbf7dc4aa137c468d4fb1e041473d0891a70a14cd79df837034e62", + "size": 92322, + "subdir": "linux-64", + "timestamp": 1625052376849, + "version": "0.18.0" + }, + "pyrsistent-0.18.0-py39heee7806_0.tar.bz2": { + "build": "py39heee7806_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0e3341a4fe434167bf74b613eb6afd81", + "name": "pyrsistent", + "sha256": "1eefce8974d25a42d989e1ca817b0f829192fcb0cfc72f921e7d2c3075d7c06f", + "size": 97194, + "subdir": "linux-64", + "timestamp": 1636110999719, + "version": "0.18.0" + }, + "pysal-1.14.2-py27heb65aa2_1.tar.bz2": { + "build": "py27heb65aa2_1", + "build_number": 1, + "depends": [ + "numpy >=1.3", + "python >=2.7,<2.8.0a0", + "scipy >=0.11" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5170d1e0d2925a46e9e0a55b51ae640a", + "name": "pysal", + "sha256": "55a620fa7188ce56a2edcf95d46fb35a7f1a2a740bace4ff4afd4950505a99c7", + "size": 15596630, + "subdir": "linux-64", + "timestamp": 1507871246955, + "version": "1.14.2" + }, + "pysal-1.14.2-py35hb2d4b38_1.tar.bz2": { + "build": "py35hb2d4b38_1", + "build_number": 1, + "depends": [ + "numpy >=1.3", + "python >=3.5,<3.6.0a0", + "scipy >=0.11" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c3e45307c97bbff24d8aebe69e40ee0d", + "name": "pysal", + "sha256": "284a927940d35b3a5020dcb1bbb0e30743b991e476346ef9b55afadb6f1bacc3", + "size": 15562614, + "subdir": "linux-64", + "timestamp": 1507871293238, + "version": "1.14.2" + }, + "pysal-1.14.2-py36h29f3eb4_1.tar.bz2": { + "build": "py36h29f3eb4_1", + "build_number": 1, + "depends": [ + "numpy >=1.3", + "python >=3.6,<3.7.0a0", + "scipy >=0.11" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7a695877efe9460cc963c51f486c652d", + "name": "pysal", + "sha256": "174eff4c13ad6621c9fa62ee3867f61ac1aecc60db1f6863b451bd718b69e88b", + "size": 15560715, + "subdir": "linux-64", + "timestamp": 1507871301139, + "version": "1.14.2" + }, + "pysal-1.14.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.3", + "python >=2.7,<2.8.0a0", + "scipy >=0.11" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c51517b1d88fde16fcdc69c8f585c1df", + "name": "pysal", + "sha256": "11e7d66a4e39ffdec387c2d85f135d315ee0eec2ebf80f3dfdd61474c9e41fbe", + "size": 15604798, + "subdir": "linux-64", + "timestamp": 1520778670048, + "version": "1.14.3" + }, + "pysal-1.14.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.3", + "python >=3.5,<3.6.0a0", + "scipy >=0.11" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2ff50c7f664573a06d2966d919075174", + "name": "pysal", + "sha256": "7f608db4a331de99c8188a5cb216152a391de8e7bfa3ff807ef0bbebd77260fc", + "size": 15613898, + "subdir": "linux-64", + "timestamp": 1520778749189, + "version": "1.14.3" + }, + "pysal-1.14.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.3", + "python >=3.6,<3.7.0a0", + "scipy >=0.11" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c26b8079fc1c4d99226346db4469d88a", + "name": "pysal", + "sha256": "5e614c6005418643ed997f9e1b06a8e30f476af01cc08e54b1a93f5deadb604c", + "size": 15583062, + "subdir": "linux-64", + "timestamp": 1520778732027, + "version": "1.14.3" + }, + "pysal-1.14.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.3", + "python >=3.7,<3.8.0a0", + "scipy >=0.11" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5c72d5a812a2adb32d00309a9f0ae254", + "name": "pysal", + "sha256": "c2cf20e344ad18729ac7bf076777e7169560a3f640cf1cab5b1e8ab6dc079194", + "size": 15591863, + "subdir": "linux-64", + "timestamp": 1530890282570, + "version": "1.14.3" + }, + "pysal-1.14.4.post1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "numpy", + "python >=2.7,<2.8.0a0", + "scipy >=0.11" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "edb72280212c29d0df3498e88909c0ef", + "name": "pysal", + "sha256": "319a9e5a7245ddf87a2739f6d9a6c8518403f43555b2100ea91cca69413b5883", + "size": 15660953, + "subdir": "linux-64", + "timestamp": 1533000138479, + "version": "1.14.4.post1" + }, + "pysal-1.14.4.post1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "numpy", + "python >=3.5,<3.6.0a0", + "scipy >=0.11" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "707da4574af31090d526d5ca07613a12", + "name": "pysal", + "sha256": "b23a59221d3fa3ff4befc0adffa98ac9ac03d8a91203be1a4aa2aaf2fa76e49b", + "size": 15642412, + "subdir": "linux-64", + "timestamp": 1533000211011, + "version": "1.14.4.post1" + }, + "pysal-1.14.4.post1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "numpy", + "python >=3.6,<3.7.0a0", + "scipy >=0.11" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "95de973bad3ac90463ac9fde275b14da", + "name": "pysal", + "sha256": "a08ee845597a215b5d582578a00443fbd1db0e66844cac1727feaf93c50ffbcb", + "size": 15628112, + "subdir": "linux-64", + "timestamp": 1533000154874, + "version": "1.14.4.post1" + }, + "pysal-1.14.4.post1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "numpy", + "python >=3.7,<3.8.0a0", + "scipy >=0.11" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a70b8e3c783fd9f8c51399457b2abe16", + "name": "pysal", + "sha256": "625da0cb7b8275d08ac46454bb0e051ff8261949294c96e79742ddc860cfd191", + "size": 15618743, + "subdir": "linux-64", + "timestamp": 1533000198490, + "version": "1.14.4.post1" + }, + "pyserial-3.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "bed020959f5a761b61ace6eaba07fbdd", + "name": "pyserial", + "sha256": "3e2ba4d7cddae7ce325259d993d51b88bcd012c7511725e25c3fe076f8efcb15", + "size": 117747, + "subdir": "linux-64", + "timestamp": 1530918871110, + "version": "3.4" + }, + "pyserial-3.4-py27h0de3e6d_0.tar.bz2": { + "build": "py27h0de3e6d_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "13afb2328fc3174d3ac918a08096df30", + "name": "pyserial", + "sha256": "be0c785954dae9d9094c9c1896528c884596b21f7acce2de2bb3c897e940f35e", + "size": 118000, + "subdir": "linux-64", + "timestamp": 1507875888715, + "version": "3.4" + }, + "pyserial-3.4-py35h84edd1e_0.tar.bz2": { + "build": "py35h84edd1e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "md5": "957915104b735695206a9018618dc293", + "name": "pyserial", + "sha256": "aff7d50299af0df687530e41fb815c049c78c9fefe337b649368f8befab67220", + "size": 120931, + "subdir": "linux-64", + "timestamp": 1507875917663, + "version": "3.4" + }, + "pyserial-3.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7b89f51e37104fddbd982fa24faedafa", + "name": "pyserial", + "sha256": "12e51d7cf3e8138d65b2544f2ccfe430b05684d1be0ace2d19e359a0d1a4ff72", + "size": 120701, + "subdir": "linux-64", + "timestamp": 1530918812709, + "version": "3.4" + }, + "pyserial-3.4-py36h08da44b_0.tar.bz2": { + "build": "py36h08da44b_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a7e2992374f2eaa8a386e61be0fed9d4", + "name": "pyserial", + "sha256": "ce0a63b0c65a6da9ae8fba35c6029d707ffef69b699137ca7249309796cf4669", + "size": 120969, + "subdir": "linux-64", + "timestamp": 1507875923447, + "version": "3.4" + }, + "pyserial-3.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "37ac1474b653d0785ce5d2ae015e6477", + "name": "pyserial", + "sha256": "05c64e9f2600ad075d4872ec37af9e85c6e6ca5eefb82daaabb12fc3efae06c9", + "size": 120544, + "subdir": "linux-64", + "timestamp": 1530918842525, + "version": "3.4" + }, + "pyserial-3.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "5b361b7572b3cfb347d415967fd85572", + "name": "pyserial", + "sha256": "cce89d6179a92e38d0bf714e971356a2d52ebefb8dc76391ccda28f29c8f2d74", + "size": 121368, + "subdir": "linux-64", + "timestamp": 1573200358996, + "version": "3.4" + }, + "pyserial-3.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a4d1464f3e9f6dce1d751a535a128782", + "name": "pyserial", + "sha256": "854e791a5db38c13d72a4b4725700ef82090e5417799f0a290f1f6cdc4e2859e", + "size": 129477, + "subdir": "linux-64", + "timestamp": 1642499906645, + "version": "3.5" + }, + "pyserial-3.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "02552e394671361991860deaffe6dc8c", + "name": "pyserial", + "sha256": "d41be15cbaf155ffefd5d7195daf4014887a4670a9a503931c0e69202f5d2528", + "size": 173803, + "subdir": "linux-64", + "timestamp": 1676861074301, + "version": "3.5" + }, + "pyserial-3.5-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "51673fa32cf096af47d653d93c1604dd", + "name": "pyserial", + "sha256": "05ce538e51b30962f2f5043337ae85af023423fdeb2a85e0d495b790fbe100b6", + "size": 128157, + "subdir": "linux-64", + "timestamp": 1606431141801, + "version": "3.5" + }, + "pyserial-3.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a700dab316f777443ed5e6fd3445fa94", + "name": "pyserial", + "sha256": "191b40ec4be199f59ac70f7a25e0451cb1bcb723b4c96d9f7c4f6791dd16498e", + "size": 127980, + "subdir": "linux-64", + "timestamp": 1606431150386, + "version": "3.5" + }, + "pyserial-3.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d8183e23ad5e1b1adb47b265ed464e5c", + "name": "pyserial", + "sha256": "56b6c9bee11e74c4cc38aac80850f5bbcda6d5e35de55bdfcea1265ac38755bd", + "size": 128333, + "subdir": "linux-64", + "timestamp": 1606431151118, + "version": "3.5" + }, + "pyserial-3.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "4cd6a8bfe634a57a2a16bb3150c49ea4", + "name": "pyserial", + "sha256": "bb725fc6a77d711733f930bf9e09f537efa472ce10073f0c6a88b8e879db97f0", + "size": 128403, + "subdir": "linux-64", + "timestamp": 1606431149231, + "version": "3.5" + }, + "pyshp-1.2.12-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "37d179d80516b62abc66adba4183e207", + "name": "pyshp", + "sha256": "8d0cdc2b1573329d84aad4024d9460d782b6c91e9dbd36f0c006109b737a0fe1", + "size": 35409, + "subdir": "linux-64", + "timestamp": 1530811614612, + "version": "1.2.12" + }, + "pyshp-1.2.12-py27h4b1cd21_0.tar.bz2": { + "build": "py27h4b1cd21_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "514ce220193ec61c4e82d2176eb055f5", + "name": "pyshp", + "sha256": "f60e453062392a80c4732fe76925be4f6d774f8ddee34ea6171e7092d2b24bcf", + "size": 35762, + "subdir": "linux-64", + "timestamp": 1511990085595, + "version": "1.2.12" + }, + "pyshp-1.2.12-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "f81eaeceeaeb6c8f36e7ffbbed993da1", + "name": "pyshp", + "sha256": "7506ba4c46a49540bf4eb8aeba7fac45a7bc6f1afa477975a80caef0bc73c542", + "size": 36144, + "subdir": "linux-64", + "timestamp": 1535129740912, + "version": "1.2.12" + }, + "pyshp-1.2.12-py35h9dba027_0.tar.bz2": { + "build": "py35h9dba027_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "d126dc0d8d8c3d8745bbd8baf57814d8", + "name": "pyshp", + "sha256": "12ff8fd41440c25df286ca852f1cdfdd00b187f3aa6c191fd43c3c8463463165", + "size": 36497, + "subdir": "linux-64", + "timestamp": 1511990061213, + "version": "1.2.12" + }, + "pyshp-1.2.12-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e19fdfc6f9235beb1a41bffd5862bc36", + "name": "pyshp", + "sha256": "fdd03b8bec884ccfe9fe4c26da5a514b8b79e3fc02d8e267c03148a87b27858a", + "size": 35984, + "subdir": "linux-64", + "timestamp": 1530811663159, + "version": "1.2.12" + }, + "pyshp-1.2.12-py36h04d6e4e_0.tar.bz2": { + "build": "py36h04d6e4e_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "facc54da4095cf81833850810b690201", + "name": "pyshp", + "sha256": "023274132367d306f1b92433646bec32fec07f71b42d097abd1044cff32b039f", + "size": 36344, + "subdir": "linux-64", + "timestamp": 1511990129354, + "version": "1.2.12" + }, + "pyshp-1.2.12-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7f7046cefedf2185e36f3d5d45e1cb85", + "name": "pyshp", + "sha256": "4217135e2b40348577874bf9d3c24e6d58999d128772c8ad9befb5e173ae7c6a", + "size": 35970, + "subdir": "linux-64", + "timestamp": 1530811638463, + "version": "1.2.12" + }, + "pyshp-2.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "75aa8a2a0e65bc509b73ea5fea1dac87", + "name": "pyshp", + "sha256": "ce698945dfed4ff2f6e1af75ecc3b6b3e17b4b664a363d4fb0db6bf8716c0f4a", + "size": 47611, + "subdir": "linux-64", + "timestamp": 1545102059800, + "version": "2.0.1" + }, + "pyshp-2.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e443cb87cd94926480288f774c181a5d", + "name": "pyshp", + "sha256": "44283d0323e2fc3f6522f03129d21700c432c33ba22fffa37bcc16c5ca185e50", + "size": 48377, + "subdir": "linux-64", + "timestamp": 1545102080194, + "version": "2.0.1" + }, + "pyshp-2.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "41eb74f4cb6aeb2ee8200e01ad8b4db1", + "name": "pyshp", + "sha256": "79f824a95ef1de06d7820e32d954ded0849b52eb5fb56ed1db33535e2b10facb", + "size": 48331, + "subdir": "linux-64", + "timestamp": 1545102069150, + "version": "2.0.1" + }, + "pysmi-0.1.4-py27h12e9649_0.tar.bz2": { + "build": "py27h12e9649_0", + "build_number": 0, + "depends": [ + "ply", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "92f9f03e6db0984027683412779a300e", + "name": "pysmi", + "sha256": "d8232f1383d0839bd9ba0e105b66bac0318e6abdd3de96cf530037876ff267e9", + "size": 99882, + "subdir": "linux-64", + "timestamp": 1509140584942, + "version": "0.1.4" + }, + "pysmi-0.1.4-py35h9877fdf_0.tar.bz2": { + "build": "py35h9877fdf_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "cb5f7c992ba7e550137dd436f08cc442", + "name": "pysmi", + "sha256": "165482322ad4600f2784baebd97bdb2f418ad842c9864acd3a75c6b96583a6d3", + "size": 103079, + "subdir": "linux-64", + "timestamp": 1509140602351, + "version": "0.1.4" + }, + "pysmi-0.1.4-py36ha4c3b21_0.tar.bz2": { + "build": "py36ha4c3b21_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7571d9bc26741d783c65226d0c3aa92a", + "name": "pysmi", + "sha256": "ae25367281c57d5156c7907c5f695a9ceeffd5a4c26c007501712da71d1e2393", + "size": 102485, + "subdir": "linux-64", + "timestamp": 1509140601495, + "version": "0.1.4" + }, + "pysmi-0.2.2-py27hefb46da_0.tar.bz2": { + "build": "py27hefb46da_0", + "build_number": 0, + "depends": [ + "ply", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "1eb515d3e97ccca3f53a793a3603cc3b", + "name": "pysmi", + "sha256": "ba308d12266497718704979512d4379b696641bbdd4276acf4e1b57bff3eb5b4", + "size": 101235, + "subdir": "linux-64", + "timestamp": 1511322143254, + "version": "0.2.2" + }, + "pysmi-0.2.2-py35hfe9e08f_0.tar.bz2": { + "build": "py35hfe9e08f_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "76a0485dcc4f9122e8091c8d645cc2d9", + "name": "pysmi", + "sha256": "dc188b228650f7e73a5cfd1842846fbc0cc51c71595bfffb2a1f79156781d71c", + "size": 104355, + "subdir": "linux-64", + "timestamp": 1511322146247, + "version": "0.2.2" + }, + "pysmi-0.2.2-py36h46a7435_0.tar.bz2": { + "build": "py36h46a7435_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "bb9b2566a0651f047be7a3da9ed06e38", + "name": "pysmi", + "sha256": "c1191c2de07106122c969303eb273e74146609f3a025a87b4cb2b7222679f55c", + "size": 103792, + "subdir": "linux-64", + "timestamp": 1511322151645, + "version": "0.2.2" + }, + "pysmi-0.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ply", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "cc61d27ee0d4fef3d8709e801cdd9241", + "name": "pysmi", + "sha256": "fa3e5373254b8bcd799cb825c7e07e777ed4e48c8a55ca94d565622b5fdbef5a", + "size": 106518, + "subdir": "linux-64", + "timestamp": 1526122923843, + "version": "0.3.0" + }, + "pysmi-0.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ca36fbc2690537986a12fc1843bc0b71", + "name": "pysmi", + "sha256": "5e7dc13a6724fde1c3fa76b72440264be4904340714abd35f7586ede4d19a1ce", + "size": 109396, + "subdir": "linux-64", + "timestamp": 1526121861955, + "version": "0.3.0" + }, + "pysmi-0.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "29f2e64f99d1ec865fb552351c42b13d", + "name": "pysmi", + "sha256": "b14a027997e43dc9357325a9a42804b4f2548a0dd550676257eda1b5878ccf30", + "size": 108821, + "subdir": "linux-64", + "timestamp": 1526121778316, + "version": "0.3.0" + }, + "pysmi-0.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ply", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3c8ebfc15d51a455fc2b114b04ed0b93", + "name": "pysmi", + "sha256": "198e7d8fc3dad07e048786d9d93600f963d17f42e4a157de2ab596b49575da9f", + "size": 106090, + "subdir": "linux-64", + "timestamp": 1529425826596, + "version": "0.3.1" + }, + "pysmi-0.3.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a49b4e37b021390e722e64fd499e626c", + "name": "pysmi", + "sha256": "2229a2f19646281c09b70ab92326678bad7bb27f1212050c09b491ab0e728c94", + "size": 109345, + "subdir": "linux-64", + "timestamp": 1529425840327, + "version": "0.3.1" + }, + "pysmi-0.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8ab049b57c133c2bd70525ce8584c79d", + "name": "pysmi", + "sha256": "aec2a72d5044a524e5dbccec2a7d9096f6560f8e9cd4ac1762fb71814986e4d4", + "size": 108796, + "subdir": "linux-64", + "timestamp": 1529425809027, + "version": "0.3.1" + }, + "pysmi-0.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "14a97b28a389e27d3aeb85b996eea730", + "name": "pysmi", + "sha256": "91afcd5eafacbe4f2d4557221a5359878bb4ba769792440e40358ee815b7c9bc", + "size": 107986, + "subdir": "linux-64", + "timestamp": 1530918904316, + "version": "0.3.1" + }, + "pysmi-0.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ply", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "aba139d4361828905cde8174a2db62e9", + "name": "pysmi", + "sha256": "acd1241c020e485aa82551530e8c7e9176133626f95e193dabec2348bae565b6", + "size": 106707, + "subdir": "linux-64", + "timestamp": 1541034462136, + "version": "0.3.2" + }, + "pysmi-0.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "81ff5fc268685eddf0fe66eca4f26aae", + "name": "pysmi", + "sha256": "84e63ece3f63c57d4f1dffd27170350eb3abb255e00f24703acd4360b96505d8", + "size": 108983, + "subdir": "linux-64", + "timestamp": 1541034512076, + "version": "0.3.2" + }, + "pysmi-0.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "de3b5dac303869c8af978e6955b32861", + "name": "pysmi", + "sha256": "d9252eff88f2ed5229e57c04338c3b3d0f0b06bf3ca6ff37bd737e25e0c09794", + "size": 108327, + "subdir": "linux-64", + "timestamp": 1541034468938, + "version": "0.3.2" + }, + "pysmi-0.3.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ply", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9e05a355de3e4aff136e50e0cf3a1252", + "name": "pysmi", + "sha256": "16de4c8547246f89cec053da75ab681ad718a8e20614ca76f5b6894262d52bed", + "size": 107965, + "subdir": "linux-64", + "timestamp": 1547249575167, + "version": "0.3.3" + }, + "pysmi-0.3.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f6623c17df6f88d7b80578ba55396b7e", + "name": "pysmi", + "sha256": "2c1080156f71bf511e0334fd1c56853f50b57ebf986896f055023a65f7e40bf8", + "size": 110493, + "subdir": "linux-64", + "timestamp": 1547249610575, + "version": "0.3.3" + }, + "pysmi-0.3.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "94243f29325481e91977861a7919d323", + "name": "pysmi", + "sha256": "fe52ab5642129f265633ff2903c3826042e2f06b5e669bc2737c2424c075b8f1", + "size": 109848, + "subdir": "linux-64", + "timestamp": 1547249586293, + "version": "0.3.3" + }, + "pysnmp-4.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=2.7,<2.8.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "acd64fac559204213fdca3f75073a194", + "name": "pysnmp", + "sha256": "7d49ebf03b7ff9fa25b98675ca82e90c893a055d11e97205d8dc3c9343ae45ef", + "size": 353776, + "subdir": "linux-64", + "timestamp": 1513015784351, + "version": "4.4.2" + }, + "pysnmp-4.4.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.5,<3.6.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "74bb98c015d524c5ac847761865139db", + "name": "pysnmp", + "sha256": "02d2bcae6ec1fd8345b1a9bd3291401c56662a8214469e07d6d7895c0eccab42", + "size": 362278, + "subdir": "linux-64", + "timestamp": 1513015793253, + "version": "4.4.2" + }, + "pysnmp-4.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.6,<3.7.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f8ee64b2075c95647835581eda7a00d9", + "name": "pysnmp", + "sha256": "3a325dd825c43b2deb25ff5a74e59982c8db480e4b00eabd1435d1cefb1a8082", + "size": 356193, + "subdir": "linux-64", + "timestamp": 1513015818325, + "version": "4.4.2" + }, + "pysnmp-4.4.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=2.7,<2.8.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "258f442d5fac143a059e318f0ee4084e", + "name": "pysnmp", + "sha256": "0aefa682d5eed627bf9997288a8a03d04dea65412493f812d5d7fc2ac78f7ce7", + "size": 352717, + "subdir": "linux-64", + "timestamp": 1520835671081, + "version": "4.4.4" + }, + "pysnmp-4.4.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.5,<3.6.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b0c14b93ac079cb9142e2e542f824635", + "name": "pysnmp", + "sha256": "6f95e444dc65135d0ba2e6f300720c6becbee40de7e5cb09aa6f5739cea14b27", + "size": 361550, + "subdir": "linux-64", + "timestamp": 1520835691668, + "version": "4.4.4" + }, + "pysnmp-4.4.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.6,<3.7.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b8a80d8fc7e5739d470327c4b1890d7e", + "name": "pysnmp", + "sha256": "d3f5bba75744356bdf0448f2b3806e14fd290846710b3c968956cbc49c721df7", + "size": 355563, + "subdir": "linux-64", + "timestamp": 1520835665029, + "version": "4.4.4" + }, + "pysnmp-4.4.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.7,<3.8.0a0", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "4549b40a3df05f79bd73124ddfd59cbb", + "name": "pysnmp", + "sha256": "28c6a2ef494e1bae0081caaef33d222b3a9e9a5b50f39416a71c0293d043673c", + "size": 354473, + "subdir": "linux-64", + "timestamp": 1530919886810, + "version": "4.4.4" + }, + "pysnmp-4.4.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=2.7,<2.8.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "71ad7bc5836f5e2a32c76b65aa1eb2e5", + "name": "pysnmp", + "sha256": "ed27f82e5901bbaa1ad69f5516a87d666ea79da1b0818d68a4f8682f1caa3aae", + "size": 355658, + "subdir": "linux-64", + "timestamp": 1536257734590, + "version": "4.4.5" + }, + "pysnmp-4.4.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.5,<3.6.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "6e0cb3de215bc308a8ad5d83a160319d", + "name": "pysnmp", + "sha256": "391070158dbefc486e52d978a522685e141c635043127a27482501c7e55590ca", + "size": 365366, + "subdir": "linux-64", + "timestamp": 1536260831814, + "version": "4.4.5" + }, + "pysnmp-4.4.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.6,<3.7.0a0", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "6e095e93755d5560887514d39753c3da", + "name": "pysnmp", + "sha256": "3287774a655e0a3b7047df73102edcc589058e30d7a75e129751f28f26a1557a", + "size": 360812, + "subdir": "linux-64", + "timestamp": 1536257673672, + "version": "4.4.5" + }, + "pysnmp-4.4.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.7,<3.8.0a0", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8e8e6be8b66388bff028f994aee507d0", + "name": "pysnmp", + "sha256": "8bc860cbfb6a2c826910bfb9a7676b80e328605ccf8056cbd2f538a02d1540bd", + "size": 359884, + "subdir": "linux-64", + "timestamp": 1536257775851, + "version": "4.4.5" + }, + "pysnmp-4.4.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=2.7,<2.8.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c7e40d7a3e84a6df5391114684f7bb7e", + "name": "pysnmp", + "sha256": "fc4f982ab9667d400b4802c2671df5ef2b489262fc8556308bbcc2633e52459b", + "size": 355899, + "subdir": "linux-64", + "timestamp": 1539646975908, + "version": "4.4.6" + }, + "pysnmp-4.4.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.6,<3.7.0a0", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "fbb531e062fe31d69d1d8fea93ca499f", + "name": "pysnmp", + "sha256": "4cc46dd761600c70921adc9ed16e7309b016b9120127d1d863927c6039b49389", + "size": 362002, + "subdir": "linux-64", + "timestamp": 1539646987285, + "version": "4.4.6" + }, + "pysnmp-4.4.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.7,<3.8.0a0", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "865159b9db6a0b600879a79b450b938a", + "name": "pysnmp", + "sha256": "75bf634bdf17fb0e2e82349dc8b0d35f4710b9a4783fdb5df8772da7fe7351dd", + "size": 360895, + "subdir": "linux-64", + "timestamp": 1539646971182, + "version": "4.4.6" + }, + "pysnmp-4.4.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=2.7,<2.8.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8d0c2a801e21229e17fa1d69680838e5", + "name": "pysnmp", + "sha256": "42befc71dadb8939fbaf3e0df29f3455d6076103cbaca29d32b57ea82ae0cd29", + "size": 378716, + "subdir": "linux-64", + "timestamp": 1547250137082, + "version": "4.4.8" + }, + "pysnmp-4.4.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.6,<3.7.0a0", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d17723901edeaf5ae533fa8283d31914", + "name": "pysnmp", + "sha256": "8ab2bad843181fe19b87dcf7bbbd489e176517058c5be67a0eb988c83e2c53df", + "size": 385611, + "subdir": "linux-64", + "timestamp": 1547250107947, + "version": "4.4.8" + }, + "pysnmp-4.4.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.7,<3.8.0a0", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ca51b79065d7a5e49bd51211c13b21aa", + "name": "pysnmp", + "sha256": "385fe3a44b9163b99e26aa68e0e16db416fe60745aacd213a6b2ddd22bd099ce", + "size": 378794, + "subdir": "linux-64", + "timestamp": 1547250146119, + "version": "4.4.8" + }, + "pysnmp-4.4.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=2.7,<2.8.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "6678e8326e5965391f7e352ef4528831", + "name": "pysnmp", + "sha256": "cf256cf200f43d0c57582d090b70ffaccd1ad2fc86ba5c9fda025c5d2fc77bd7", + "size": 377182, + "subdir": "linux-64", + "timestamp": 1550352757382, + "version": "4.4.9" + }, + "pysnmp-4.4.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.6,<3.7.0a0", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d92a5916204221356a9071a0c18a4a57", + "name": "pysnmp", + "sha256": "debf6656a816e588ef87decb22e86710bac7297d53f900b664faef2f0e6d3fe6", + "size": 387118, + "subdir": "linux-64", + "timestamp": 1550352803771, + "version": "4.4.9" + }, + "pysnmp-4.4.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.7,<3.8.0a0", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c3bd3dda503dca876b9c4712deee5d4f", + "name": "pysnmp", + "sha256": "9bbd2257c4b1f740c3b977fa7511d1e7288baa878fda8482c62e69157deb76db", + "size": 381487, + "subdir": "linux-64", + "timestamp": 1550352737723, + "version": "4.4.9" + }, + "pysocks-1.6.7-py27he2db6d2_1.tar.bz2": { + "build": "py27he2db6d2_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c595aece629c642a62c2280b5cf7ef50", + "name": "pysocks", + "sha256": "a019269288944cffc09297085106d3a524fa87891fc5873f314e3e4837fea458", + "size": 22159, + "subdir": "linux-64", + "timestamp": 1505692990681, + "version": "1.6.7" + }, + "pysocks-1.6.7-py35h6aefbb0_1.tar.bz2": { + "build": "py35h6aefbb0_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "df1062f00a91bd148b247cd19ab6cd36", + "name": "pysocks", + "sha256": "97dd563b89eabe2467e56a1bd57921e25ada49c1d51a745f70b68b72a2f98086", + "size": 22702, + "subdir": "linux-64", + "timestamp": 1505693001886, + "version": "1.6.7" + }, + "pysocks-1.6.7-py36hd97a5b1_1.tar.bz2": { + "build": "py36hd97a5b1_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "041efc6b0326de560070094b4f1bc06b", + "name": "pysocks", + "sha256": "173c5c9a5e7a00a979ae72249db83a8cbb7a2b97e791f13f053f9f9eea7c5fec", + "size": 22597, + "subdir": "linux-64", + "timestamp": 1505693013263, + "version": "1.6.7" + }, + "pysocks-1.6.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "89b5047703f68a5db1a44b1a896738f8", + "name": "pysocks", + "sha256": "a33171b82898ef8b0f2a1528a8b0a587388fe11501128f1333a3e351b80b221f", + "size": 22522, + "subdir": "linux-64", + "timestamp": 1519749372651, + "version": "1.6.8" + }, + "pysocks-1.6.8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "88aba1fed89ee86165b75235df8b4f94", + "name": "pysocks", + "sha256": "8a4ac7922468e3d715866aedfd3698bdf6c5be66e9957078dc0d1f502020984d", + "size": 23006, + "subdir": "linux-64", + "timestamp": 1519749383502, + "version": "1.6.8" + }, + "pysocks-1.6.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9e7d936399e8a4ca4912e586f1756976", + "name": "pysocks", + "sha256": "d9fd42efd82f247441dc22b227854591b4a22167f8dc170bb0b8c50f197ed765", + "size": 22946, + "subdir": "linux-64", + "timestamp": 1519749335733, + "version": "1.6.8" + }, + "pysocks-1.6.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "de454ecc067eb29b75f290018a2a4563", + "name": "pysocks", + "sha256": "9212f980b2e56f42767271a33b28b0ba9d7f2a971730ae1dbda468a146528a30", + "size": 22908, + "subdir": "linux-64", + "timestamp": 1530733440464, + "version": "1.6.8" + }, + "pysocks-1.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e17d65c4ccd7cba10ca3a1c41e8da7c6", + "name": "pysocks", + "sha256": "2fb16450a1d2d7cbd77fde1ca113928149f0083187e1b11b2dcb6af1ba2cedf3", + "size": 29662, + "subdir": "linux-64", + "timestamp": 1557856220196, + "version": "1.7.0" + }, + "pysocks-1.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bf1ab71339219993d91eafb2c7f749bd", + "name": "pysocks", + "sha256": "adc425f413a919786d632f5edaac4e030552ec20083e113452489c4f2879883e", + "size": 30136, + "subdir": "linux-64", + "timestamp": 1557856250917, + "version": "1.7.0" + }, + "pysocks-1.7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c5e46175a912cae8a17a2b21e7e46692", + "name": "pysocks", + "sha256": "e151c663e84a0105bf5634adff68a07412f0449b7b3bf6ab506ebb6045616b50", + "size": 30163, + "subdir": "linux-64", + "timestamp": 1557856209609, + "version": "1.7.0" + }, + "pysocks-1.7.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9e6397ce0ce95d1754070a7145f435fb", + "name": "pysocks", + "sha256": "4d75e52c88d99935142e14550f9c36ef29936ac17a98047e0628051e6cd311d2", + "size": 30414, + "subdir": "linux-64", + "timestamp": 1569264607885, + "version": "1.7.1" + }, + "pysocks-1.7.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5ad7b13cb48fc3f12d94907489550019", + "name": "pysocks", + "sha256": "d01fa02148ff1717b3c13b3afc1d9f7189fa7b15d1a612d79793f6c1534875d7", + "size": 28253, + "subdir": "linux-64", + "timestamp": 1640793693853, + "version": "1.7.1" + }, + "pysocks-1.7.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2458e92683cc68671a6c8e1b86ce8817", + "name": "pysocks", + "sha256": "114b55e00f4622c90fd2b404b21ad5f94a10283fcaaf86a42174b8d39b0a3e98", + "size": 35850, + "subdir": "linux-64", + "timestamp": 1676822725516, + "version": "1.7.1" + }, + "pysocks-1.7.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "87279173326d098c2706b14959e64954", + "name": "pysocks", + "sha256": "31bf629cccb451fec71fd1d469592b8987deea3b7f1fe46b18c71d237787f724", + "size": 30870, + "subdir": "linux-64", + "timestamp": 1569264610669, + "version": "1.7.1" + }, + "pysocks-1.7.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "821069a4a6cdac2657cf85d323bc60e3", + "name": "pysocks", + "sha256": "b0d48ac1e368ee1f5494a360ce97ad6ba34ed9639cc611cb2a4e6b5a0aa3e52e", + "size": 31165, + "subdir": "linux-64", + "timestamp": 1605305791334, + "version": "1.7.1" + }, + "pysocks-1.7.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ff439b77e46862803e5264c07a5c8cbd", + "name": "pysocks", + "sha256": "67d63646a1bbf9d85951832749171c9f5dd6eef038ae139a68bcc6c1549c34dc", + "size": 30853, + "subdir": "linux-64", + "timestamp": 1569264610199, + "version": "1.7.1" + }, + "pysocks-1.7.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ed9a2fb08846250c279c0a3b691c1602", + "name": "pysocks", + "sha256": "1997cb29af5a908bd237e6504690676340dc460ebb3084eb52f745949b7fc670", + "size": 27345, + "subdir": "linux-64", + "timestamp": 1594394604963, + "version": "1.7.1" + }, + "pysocks-1.7.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3ddd21b8a7b32f5d52eac15fafc1307d", + "name": "pysocks", + "sha256": "4971eac27bc52570a5c72de04b37ecffaf324232341d7df404856a9bcf0b6ca9", + "size": 31186, + "subdir": "linux-64", + "timestamp": 1605305820900, + "version": "1.7.1" + }, + "pysocks-1.7.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5fe976f37976a7a2199bea982d7cde6e", + "name": "pysocks", + "sha256": "a4ae245f2e8d359272ab621a114b85f5d6ffead07cf955a0712eb03af1f4fb98", + "size": 28112, + "subdir": "linux-64", + "timestamp": 1573200379215, + "version": "1.7.1" + }, + "pysocks-1.7.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3ec9d5960a2ea2ba666008fdfc9d0084", + "name": "pysocks", + "sha256": "0d1c9fb08b326f1292b74373b942b739bb99dd4ec54d2be09e5072503300b2a8", + "size": 31276, + "subdir": "linux-64", + "timestamp": 1605305807726, + "version": "1.7.1" + }, + "pysocks-1.7.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c5f3f7f10ad30f0945e75252615ab6e5", + "name": "pysocks", + "sha256": "5eb7130d2f345d4a4fd7ccfc10bc9ba5f1235eaabc22536b9a20736087be106e", + "size": 31331, + "subdir": "linux-64", + "timestamp": 1605305847037, + "version": "1.7.1" + }, + "pyspark-2.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.6.*", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "9ecbf0ace6a0a5c94002600cf74af84e", + "name": "pyspark", + "sha256": "5d2bc87d41b2e4c24ec9116aa77b2234a077eb19a797accf7ece5a1767694762", + "size": 211931325, + "subdir": "linux-64", + "timestamp": 1520534061360, + "version": "2.3.0" + }, + "pyspark-2.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.6.*", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "6a9b7e87f54f957a165e5b8fed80ebfc", + "name": "pyspark", + "sha256": "237186babdabdf5316a5fd9cf295827312be64e580182f3c108c7254623fcaa7", + "size": 211930862, + "subdir": "linux-64", + "timestamp": 1520534149093, + "version": "2.3.0" + }, + "pyspark-2.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.6.*", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "d0893590dce320873ee58094f084cd10", + "name": "pyspark", + "sha256": "a80f60beb45eb9f7de293727ec3c8855992c7d5db80c2c1ec610c09c8314835e", + "size": 211926856, + "subdir": "linux-64", + "timestamp": 1520534057073, + "version": "2.3.0" + }, + "pyspark-2.3.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "34ec85dcfc6fc8c664cd78a1462f317d", + "name": "pyspark", + "sha256": "6cdb9b4c461b5390b2a41345541bea3a64e82d621e5f6faf89abd444911ff335", + "size": 211983540, + "subdir": "linux-64", + "timestamp": 1528748498889, + "version": "2.3.1" + }, + "pyspark-2.3.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "af64d19f36ffc8873065812b0914509d", + "name": "pyspark", + "sha256": "7501f02008b7f68c8f0552b237d599541780460ee9ee38fed1d63fc83a7ea651", + "size": 212006498, + "subdir": "linux-64", + "timestamp": 1528748969511, + "version": "2.3.1" + }, + "pyspark-2.3.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "d7d005a49f12cd577170cb28f77bf872", + "name": "pyspark", + "sha256": "e8e3064cbf3ec2b2e459acb9b4b0acdd7c426061382d8f07e9f46da2eb97e819", + "size": 211987211, + "subdir": "linux-64", + "timestamp": 1528748992153, + "version": "2.3.1" + }, + "pyspark-2.3.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "76ad06f076aaaad2186bdc603841d3b1", + "name": "pyspark", + "sha256": "baec9ff9925892aa206ff457960f47bb89ad597da4c9853be1c5da54aef7a44d", + "size": 211972188, + "subdir": "linux-64", + "timestamp": 1530920030907, + "version": "2.3.1" + }, + "pyspark-2.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "09b5b686a9f8cc6a49e5de8f38305371", + "name": "pyspark", + "sha256": "c3126839819cb3e139bf1421156fe50e15e3e24bd98bb1f1804a7c6322a727e6", + "size": 212074625, + "subdir": "linux-64", + "timestamp": 1539639191754, + "version": "2.3.2" + }, + "pyspark-2.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "e7bcb1ee74ec1f6cd6720c76ad6efc9a", + "name": "pyspark", + "sha256": "2b8960813d38187bb21deb1fd0f510d7f812de55064bd17b3d4d53105a2bebd6", + "size": 212084846, + "subdir": "linux-64", + "timestamp": 1539639169744, + "version": "2.3.2" + }, + "pyspark-2.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "c749362b855db69d78f69d2ef6af7424", + "name": "pyspark", + "sha256": "47231fef662363a9d30a5a5effff19401a38ce1db957eb3dff18360319a93826", + "size": 212063692, + "subdir": "linux-64", + "timestamp": 1539639241181, + "version": "2.3.2" + }, + "pyspark-2.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "3555336dd2ab347926236f55296125a5", + "name": "pyspark", + "sha256": "895cf963330b1e4347f3f6fba76f81329d4e97cd308bf9afa86e64f32491c033", + "size": 213311548, + "subdir": "linux-64", + "timestamp": 1541442097023, + "version": "2.4.0" + }, + "pyspark-2.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "02c64c3939c060c69a97add44ab1e87a", + "name": "pyspark", + "sha256": "d2e9783fa0abe91fb5526437d97a00d626d90b342f5e72472ead66ad5e597589", + "size": 213332901, + "subdir": "linux-64", + "timestamp": 1541442157442, + "version": "2.4.0" + }, + "pyspark-2.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "5b6827cb5243546c4cfcab08112a7373", + "name": "pyspark", + "sha256": "5420a5ad43cab5d2ec87fc3ae29f5402fa410d851d8ad071974eb24e8c2ade60", + "size": 213324698, + "subdir": "linux-64", + "timestamp": 1541442130621, + "version": "2.4.0" + }, + "pyspark-3.2.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14", + "pandas >=0.23.2", + "py4j 0.10.9.3", + "pyarrow >=1.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e40278a5cb9a5ef3c07f3292bf96f94a", + "name": "pyspark", + "sha256": "32baca7bb41ce6669e569a4ebaf1e565837dddf359d74d4874dd0bd919431773", + "size": 282035976, + "subdir": "linux-64", + "timestamp": 1670256414556, + "version": "3.2.1" + }, + "pyspark-3.2.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14", + "pandas >=0.23.2", + "py4j 0.10.9.3", + "pyarrow >=1.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "557b697ff6d6ae96349c314295cc8bab", + "name": "pyspark", + "sha256": "553273b6671813451a5b55956cc3104d45bb8bcb78ebe1d64b38dc27040d8cf3", + "size": 282372853, + "subdir": "linux-64", + "timestamp": 1676861111197, + "version": "3.2.1" + }, + "pyspark-3.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14", + "pandas >=0.23.2", + "py4j 0.10.9.3", + "pyarrow >=1.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c6f4b40acf7db453aebb9e5de3af350e", + "name": "pyspark", + "sha256": "232f2835a8ba0332f3196f5a9602debf95c97e349331e33b656d79a3f05c4a45", + "size": 282025317, + "subdir": "linux-64", + "timestamp": 1670256198845, + "version": "3.2.1" + }, + "pyspark-3.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14", + "pandas >=0.23.2", + "py4j 0.10.9.3", + "pyarrow >=1.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2fc2d59c691040f3c67084cc1969fa63", + "name": "pyspark", + "sha256": "aaa9934ca57b2cc9b4e5b7c8016bf73e61456dd3916d95e7548c129594d88584", + "size": 282039936, + "subdir": "linux-64", + "timestamp": 1670256832687, + "version": "3.2.1" + }, + "pyspark-3.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14", + "pandas >=0.23.2", + "py4j 0.10.9.3", + "pyarrow >=1.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cf21fb7826746fa1aa7589a5b35fb314", + "name": "pyspark", + "sha256": "53e3c6503f5ee1ebac14ccc881b038580a82681d4783ab88004c8c4f1c481f9a", + "size": 281998788, + "subdir": "linux-64", + "timestamp": 1670256622608, + "version": "3.2.1" + }, + "pyspnego-0.3.1-py310h5eee18b_2.tar.bz2": { + "build": "py310h5eee18b_2", + "build_number": 2, + "depends": [ + "cryptography", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea7e4e2358c037c1c128c94bf9c342ca", + "name": "pyspnego", + "sha256": "4a52685307a2549a6fab70623954c6afc35b6ea9591ea8e0b253714ec7e58e19", + "size": 163317, + "subdir": "linux-64", + "timestamp": 1662368652256, + "version": "0.3.1" + }, + "pyspnego-0.3.1-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "constrains": [ + "python-gssapi >=1.5.0" + ], + "depends": [ + "cryptography", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "md5": "7c959f2f681fb4d0053c6a21740e54e9", + "name": "pyspnego", + "sha256": "afa5b35f7fed6467d9942f65c26400382cafb0944d05425cf53cd7185527939b", + "size": 163203, + "subdir": "linux-64", + "timestamp": 1641550961076, + "version": "0.3.1" + }, + "pyspnego-0.3.1-py311h5eee18b_2.tar.bz2": { + "build": "py311h5eee18b_2", + "build_number": 2, + "depends": [ + "cryptography", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "09e1b65e479d5683138ef1a2638af99f", + "name": "pyspnego", + "sha256": "6c598ccf7be890de36cb24530a5455665b71ef355ee59c10e4f70fde61df26d9", + "size": 213322, + "subdir": "linux-64", + "timestamp": 1676861257231, + "version": "0.3.1" + }, + "pyspnego-0.3.1-py37h5eee18b_2.tar.bz2": { + "build": "py37h5eee18b_2", + "build_number": 2, + "depends": [ + "cryptography", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7eaa75563c0e535daf3d9ea0fa523050", + "name": "pyspnego", + "sha256": "37ee1f209065bc8dbeb2ed594a2af9a41bf6b7cc8e4dbd1d6422a0f1e56dd79d", + "size": 160467, + "subdir": "linux-64", + "timestamp": 1662368752557, + "version": "0.3.1" + }, + "pyspnego-0.3.1-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "cryptography", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e943d537c751a2083ad0f192a63eaf74", + "name": "pyspnego", + "sha256": "d4f8e9cfccdf2c72c8472ae770f00eb940de30812fca8f19970c5191152c0db6", + "size": 164149, + "subdir": "linux-64", + "timestamp": 1640321105778, + "version": "0.3.1" + }, + "pyspnego-0.3.1-py38h5eee18b_2.tar.bz2": { + "build": "py38h5eee18b_2", + "build_number": 2, + "depends": [ + "cryptography", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1eb5d4c90fbd54c7c498ce5abd79fc48", + "name": "pyspnego", + "sha256": "a08b8ac6d488c64890a25583ee18ac1485479464ab03aed6d8e9552f3169bbbc", + "size": 161198, + "subdir": "linux-64", + "timestamp": 1662368684787, + "version": "0.3.1" + }, + "pyspnego-0.3.1-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "cryptography", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0773fe3aa12b3574d9f919eec87bd8d", + "name": "pyspnego", + "sha256": "f42de6fe62b7baa1bab830d54c9f085c111037d144bd0b9b67e3b96e58f8ea2d", + "size": 164972, + "subdir": "linux-64", + "timestamp": 1640339582941, + "version": "0.3.1" + }, + "pyspnego-0.3.1-py39h5eee18b_2.tar.bz2": { + "build": "py39h5eee18b_2", + "build_number": 2, + "depends": [ + "cryptography", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ac7b78ceb4d823b8ad105e22e7feed7", + "name": "pyspnego", + "sha256": "44a502b6cb989498572e3cd66bd24c9a49273f0e171851d67e57071b3ef46d14", + "size": 161565, + "subdir": "linux-64", + "timestamp": 1662368718996, + "version": "0.3.1" + }, + "pyspnego-0.3.1-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "cryptography", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02f82803b4ff3e740179bb72df04b8c8", + "name": "pyspnego", + "sha256": "5740835b4aab6d9959e9286db70d37dd1d7b0826105b16c6f5a677aae7be73b5", + "size": 164767, + "subdir": "linux-64", + "timestamp": 1640325019333, + "version": "0.3.1" + }, + "pyspnego-0.3.1-py39h7f8727e_1.tar.bz2": { + "build": "py39h7f8727e_1", + "build_number": 1, + "constrains": [ + "python-gssapi >=1.5.0" + ], + "depends": [ + "cryptography", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "md5": "cccd87f3c6aeb1dfce2924136b7b5606", + "name": "pyspnego", + "sha256": "54a0c45304f9ecd0ad89fe9219cb0b55859942e5bdfac6fc3753de4cf61cefcc", + "size": 161407, + "subdir": "linux-64", + "timestamp": 1642516252903, + "version": "0.3.1" + }, + "pyspnego-0.8.0-py310h5eee18b_2.tar.bz2": { + "build": "py310h5eee18b_2", + "build_number": 2, + "depends": [ + "cryptography", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e1db57f2fa91e46ced26748f070cddf", + "name": "pyspnego", + "sha256": "b712a1c1b92fc68ff4f98a85376cb2eeb694f64615675b58e6148a51cba1f52e", + "size": 195535, + "subdir": "linux-64", + "timestamp": 1678831714668, + "version": "0.8.0" + }, + "pyspnego-0.8.0-py311h5eee18b_2.tar.bz2": { + "build": "py311h5eee18b_2", + "build_number": 2, + "depends": [ + "cryptography", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d07ed6d0f7ffbdb77d90615c4461809", + "name": "pyspnego", + "sha256": "73cab16cec00533f55b03c31cbe6dbeb302153c5d9da32aea09090633b827319", + "size": 267849, + "subdir": "linux-64", + "timestamp": 1679337612765, + "version": "0.8.0" + }, + "pyspnego-0.8.0-py38h5eee18b_2.tar.bz2": { + "build": "py38h5eee18b_2", + "build_number": 2, + "depends": [ + "cryptography", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a57583b980c69680b2164a69fd71ed9", + "name": "pyspnego", + "sha256": "d429bfc275414d4fa4dccee0875cbf6ded5ec13e544dcc316cd7635ddfa92538", + "size": 193486, + "subdir": "linux-64", + "timestamp": 1678831680382, + "version": "0.8.0" + }, + "pyspnego-0.8.0-py39h5eee18b_2.tar.bz2": { + "build": "py39h5eee18b_2", + "build_number": 2, + "depends": [ + "cryptography", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7d8b9d3e5e5cfc2376d4589224e6f98a", + "name": "pyspnego", + "sha256": "a08a601e1db624cb01acecefe7347e5647cd1f88c83db9d2db9adf1f22a5b16c", + "size": 193379, + "subdir": "linux-64", + "timestamp": 1678831748032, + "version": "0.8.0" + }, + "pystan-2.17.0.0-py27hb25f4fb_0.tar.bz2": { + "build": "py27hb25f4fb_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64", + "gxx_linux-64", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPLv3", + "md5": "d7e79549e5dc30b38d3d0ac6527b919b", + "name": "pystan", + "sha256": "0df945f968786e981d8528e255c1826c68d89e690cadadbef0f3e0b8d2926237", + "size": 15117058, + "subdir": "linux-64", + "timestamp": 1510950482174, + "version": "2.17.0.0" + }, + "pystan-2.17.0.0-py35h541c666_0.tar.bz2": { + "build": "py35h541c666_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64", + "gxx_linux-64", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPLv3", + "md5": "9b498f03c6700e5fc21e14b39d3d39ba", + "name": "pystan", + "sha256": "7b6a742dc3a12998143814cabbecefa8c1fcfc1806da2f947f922dafb438c364", + "size": 15129072, + "subdir": "linux-64", + "timestamp": 1510950683017, + "version": "2.17.0.0" + }, + "pystan-2.17.0.0-py36hec2f369_0.tar.bz2": { + "build": "py36hec2f369_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64", + "gxx_linux-64", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPLv3", + "md5": "bc89ed3f4b61e2e2995bed0674148d56", + "name": "pystan", + "sha256": "044918350cc328f40d425a31faeb8fad17970d7af2c29448f55b5031dfbf0c6b", + "size": 15133641, + "subdir": "linux-64", + "timestamp": 1510950696285, + "version": "2.17.0.0" + }, + "pystan-2.17.1.0-py27h04863e7_0.tar.bz2": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64", + "gxx_linux-64", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPLv3", + "md5": "e850f3c5978e6678c5991cb93ed6eff2", + "name": "pystan", + "sha256": "c1b6f698db9948a7a3994e89139562420c2d17da9dd6b0f9efb6e40300742182", + "size": 15204114, + "subdir": "linux-64", + "timestamp": 1530921989010, + "version": "2.17.1.0" + }, + "pystan-2.17.1.0-py27h637b7d7_0.tar.bz2": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64", + "gxx_linux-64", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPLv3", + "md5": "326ae24febcee2f5f24af1a76a7c4d11", + "name": "pystan", + "sha256": "c7cda49251e25afe25cf811555743227d9f360c94349f7face8bec292ab56869", + "size": 15191251, + "subdir": "linux-64", + "timestamp": 1520787936395, + "version": "2.17.1.0" + }, + "pystan-2.17.1.0-py35h637b7d7_0.tar.bz2": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64", + "gxx_linux-64", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPLv3", + "md5": "334cf4f8532adb444771fa808cb21e4d", + "name": "pystan", + "sha256": "32e687d06115fb54299cd2645f2e626bd6f3c063ad10e616436111774b1ba4c1", + "size": 15205283, + "subdir": "linux-64", + "timestamp": 1520787923676, + "version": "2.17.1.0" + }, + "pystan-2.17.1.0-py36h04863e7_0.tar.bz2": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64", + "gxx_linux-64", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPLv3", + "md5": "e387d1b31b29859457efabc9ea20a321", + "name": "pystan", + "sha256": "16731b3f64b113cc99fa58952e93a40383c907835a97a60ab640de9e07723646", + "size": 15201593, + "subdir": "linux-64", + "timestamp": 1530920693619, + "version": "2.17.1.0" + }, + "pystan-2.17.1.0-py36h637b7d7_0.tar.bz2": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64", + "gxx_linux-64", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPLv3", + "md5": "21504f2fbb8945374431562e3099715d", + "name": "pystan", + "sha256": "84811dd01061a65a2fe76fca537e063c05bbe298c6b4ecdd7f417711400cdda2", + "size": 15206372, + "subdir": "linux-64", + "timestamp": 1520787898231, + "version": "2.17.1.0" + }, + "pystan-2.17.1.0-py37h04863e7_0.tar.bz2": { + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64", + "gxx_linux-64", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPLv3", + "md5": "ceeab0dcf35330a7219bf435497c922a", + "name": "pystan", + "sha256": "aa7bef6e62490dfa488d676cc73b8fbf7667e43237f41668336eb4b6646d45ae", + "size": 15201166, + "subdir": "linux-64", + "timestamp": 1530921346882, + "version": "2.17.1.0" + }, + "pystan-2.18.0.0-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPLv3", + "md5": "877f2673317ecb6672372cc280c760bb", + "name": "pystan", + "sha256": "f9805c142d50f60264e390036cdbc8d5aa8c8b85976544b89ffacfbcb874bcf8", + "size": 19197417, + "subdir": "linux-64", + "timestamp": 1536530356974, + "version": "2.18.0.0" + }, + "pystan-2.18.0.0-py35h962f231_0.tar.bz2": { + "build": "py35h962f231_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPLv3", + "md5": "0260ca053235ae8f21b8aec042d36d34", + "name": "pystan", + "sha256": "53be7b7e4341b5c81962677a0d22a2e5323182e20643bfe2a673675fdb1963c5", + "size": 19083034, + "subdir": "linux-64", + "timestamp": 1536530333787, + "version": "2.18.0.0" + }, + "pystan-2.18.0.0-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPLv3", + "md5": "eadb961dec0d93e1b57da5379a0cb78b", + "name": "pystan", + "sha256": "145e5da6274c0760171865096eed41cf620d3322b13bbb1ecf169d84e0e64c57", + "size": 19100524, + "subdir": "linux-64", + "timestamp": 1536530636626, + "version": "2.18.0.0" + }, + "pystan-2.18.0.0-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPLv3", + "md5": "f7db171582bfcd3161fb2497fe6f0f0c", + "name": "pystan", + "sha256": "f10831936642987d4c973b4841ddac4ef50c28a2906741b658fea02f85ed7a5d", + "size": 19104169, + "subdir": "linux-64", + "timestamp": 1536530650394, + "version": "2.18.0.0" + }, + "pystan-2.18.0.0-py38h962f231_0.tar.bz2": { + "build": "py38h962f231_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPLv3", + "md5": "d5d324b67279c70c0879e38c472a9973", + "name": "pystan", + "sha256": "1306a6235cbdf25a0d39e7c1473580ca7fbd2f60b38e656be3ede153d9787971", + "size": 18093522, + "subdir": "linux-64", + "timestamp": 1574170748158, + "version": "2.18.0.0" + }, + "pystan-2.19.0.0-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPLv3", + "md5": "be7dd7214001d220829bc7eb07b251cc", + "name": "pystan", + "sha256": "5bda7b0fc9fba16cd10eeebdd9aeb0b646268b6d7a6c0f93ae4782364721da57", + "size": 17337631, + "subdir": "linux-64", + "timestamp": 1563481289833, + "version": "2.19.0.0" + }, + "pystan-2.19.0.0-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPLv3", + "md5": "2e32302cbe8e8039921d8e8ab69316ac", + "name": "pystan", + "sha256": "8524b895bd298f245d1c6240bf34945e34917184f05c44f9cecd191f9c44609d", + "size": 17379880, + "subdir": "linux-64", + "timestamp": 1563481285038, + "version": "2.19.0.0" + }, + "pystan-2.19.0.0-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPLv3", + "md5": "ecb949832e99eec781caf9e0e8857bf8", + "name": "pystan", + "sha256": "adc85ac7ae98b5b6ce8f68ea32a5c79aa3c38e02dc1ad14b019ad47c6316eced", + "size": 17385771, + "subdir": "linux-64", + "timestamp": 1563481463955, + "version": "2.19.0.0" + }, + "pystan-2.19.1.1-py36ha9443f7_0.tar.bz2": { + "build": "py36ha9443f7_0", + "build_number": 0, + "depends": [ + "arviz", + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy", + "setuptools" + ], + "license": "GPLv3", + "md5": "6ea23d634025b470d98f745782ee05c2", + "name": "pystan", + "sha256": "8e86dac207f247251cac91a8d4c988af9492f89b0c03115dc621fd4a89f9d060", + "size": 18092456, + "subdir": "linux-64", + "timestamp": 1613565599192, + "version": "2.19.1.1" + }, + "pystan-2.19.1.1-py37ha9443f7_0.tar.bz2": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "arviz", + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy", + "setuptools" + ], + "license": "GPLv3", + "md5": "5f7a08f31c5a689bd6eb6be12fde57cc", + "name": "pystan", + "sha256": "e98a79ba55cde335d6fb38397bedcccc1b7058ac89f3e9ee7e6c6280d9133700", + "size": 18124001, + "subdir": "linux-64", + "timestamp": 1613565512910, + "version": "2.19.1.1" + }, + "pystan-2.19.1.1-py38ha9443f7_0.tar.bz2": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "arviz", + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy", + "setuptools" + ], + "license": "GPLv3", + "md5": "6dcf931666896de5c4f5f1cf4f2e6761", + "name": "pystan", + "sha256": "b61a761057a9ceab9e11cb3b6090ed795901bfd3014d70dd8036ec429afdb4e5", + "size": 18079718, + "subdir": "linux-64", + "timestamp": 1613565517517, + "version": "2.19.1.1" + }, + "pystan-2.19.1.1-py39ha9443f7_0.tar.bz2": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "arviz", + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy", + "setuptools" + ], + "license": "GPLv3", + "md5": "a200a7da03d73c9e333d0da663ee9e61", + "name": "pystan", + "sha256": "7d0a9b2c982cf8d561c7ecfa639ca92c66131bc38e82e965312eb82a7dc2c9fe", + "size": 18067720, + "subdir": "linux-64", + "timestamp": 1613639972578, + "version": "2.19.1.1" + }, + "pytables-3.4.2-py27h1f7bffc_2.tar.bz2": { + "build": "py27h1f7bffc_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "281a12c1643733c19e27defc11b4740d", + "name": "pytables", + "sha256": "fb32591f384f03d9cd05257c7bcad039a7d289fd39acaa5b3ad4539df1664880", + "size": 2460594, + "subdir": "linux-64", + "timestamp": 1506562047979, + "version": "3.4.2" + }, + "pytables-3.4.2-py27h62dd165_2.tar.bz2": { + "build": "py27h62dd165_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "640dbc2da2290edf572239a8d227d239", + "name": "pytables", + "sha256": "e7cd5ea02b16868aad59bca07e78170cae922166165fb0cefcb91655b6b71c8e", + "size": 2462941, + "subdir": "linux-64", + "timestamp": 1506561784688, + "version": "3.4.2" + }, + "pytables-3.4.2-py27ha79ee23_1.tar.bz2": { + "build": "py27ha79ee23_1", + "build_number": 1, + "depends": [ + "hdf5", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo 2.*", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7d959300ec649c3bd4309703283f1eab", + "name": "pytables", + "sha256": "0573074309a69306c6864fb07826393cacf37942429944eb1f9dbec3c4e670e8", + "size": 2457592, + "subdir": "linux-64", + "timestamp": 1505731220939, + "version": "3.4.2" + }, + "pytables-3.4.2-py35h68a732d_2.tar.bz2": { + "build": "py35h68a732d_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "35f0e9d3bb37ca276a0af348223c10e0", + "name": "pytables", + "sha256": "e5d18fc320656001d0ddd351786ee0365dfc88d7777e08177cf28875da3cf9ec", + "size": 2489162, + "subdir": "linux-64", + "timestamp": 1506561857022, + "version": "3.4.2" + }, + "pytables-3.4.2-py35hc74b6c3_1.tar.bz2": { + "build": "py35hc74b6c3_1", + "build_number": 1, + "depends": [ + "hdf5", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo 2.*", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a68afd3930387662a9e66dea95a40fd7", + "name": "pytables", + "sha256": "a63802109a8a2b57443687f746d86d0ddcc56ec972541f7d6cd7e3ceadd38285", + "size": 2484033, + "subdir": "linux-64", + "timestamp": 1505731580458, + "version": "3.4.2" + }, + "pytables-3.4.2-py35hfa98db7_2.tar.bz2": { + "build": "py35hfa98db7_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9bdc4e6a76e0124f9f0841048bbf37df", + "name": "pytables", + "sha256": "8a31101e0086305a92463b1875126c6c0bce59ba32b9089558a25b77d1a823ad", + "size": 2483108, + "subdir": "linux-64", + "timestamp": 1506561893204, + "version": "3.4.2" + }, + "pytables-3.4.2-py36h3b5282a_2.tar.bz2": { + "build": "py36h3b5282a_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "670c62acf6f2325fb9a2128cdda8ebfa", + "name": "pytables", + "sha256": "a06e89af1fd03bb87710293794f18f2dd0bc6261f935161b53854b5024bf4cde", + "size": 2482459, + "subdir": "linux-64", + "timestamp": 1506562218012, + "version": "3.4.2" + }, + "pytables-3.4.2-py36hc5f0ea4_2.tar.bz2": { + "build": "py36hc5f0ea4_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a26b7f1328186a5aa4d11ce7c60b1cf4", + "name": "pytables", + "sha256": "ed47c54ed9db951a114e49a90971bfcff4c0f07d21ebeb9af7ebf9ee414cefab", + "size": 2487087, + "subdir": "linux-64", + "timestamp": 1506562220717, + "version": "3.4.2" + }, + "pytables-3.4.2-py36hdce54c9_1.tar.bz2": { + "build": "py36hdce54c9_1", + "build_number": 1, + "depends": [ + "hdf5", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo 2.*", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "73ad5bb8e9a9ee8f179729fb1429a3cd", + "name": "pytables", + "sha256": "f9ea39d55fa0c90837a36fdda337f6e88de8b0515cd18c2f4299679ee561fea9", + "size": 2478827, + "subdir": "linux-64", + "timestamp": 1505731929302, + "version": "3.4.2" + }, + "pytables-3.4.3-py27h02b9ad4_0.tar.bz2": { + "build": "py27h02b9ad4_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "232a0d1f92973ddc52bf688c4dc6fe4f", + "name": "pytables", + "sha256": "3b75e043e122efe6d85cb418756a4608b27dfdb8d85959fa27b8d166b755f828", + "size": 1522050, + "subdir": "linux-64", + "timestamp": 1524593507590, + "version": "3.4.3" + }, + "pytables-3.4.3-py27h02b9ad4_2.tar.bz2": { + "build": "py27h02b9ad4_2", + "build_number": 2, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "834adcdc2e8c07f830c9723681fea724", + "name": "pytables", + "sha256": "0901f650bbc96eba356a7cb5e64bdb68c1895796b3ce83eda69caa0661c547e3", + "size": 1521538, + "subdir": "linux-64", + "timestamp": 1527021667141, + "version": "3.4.3" + }, + "pytables-3.4.3-py27h68a8fdc_0.tar.bz2": { + "build": "py27h68a8fdc_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "950867d0671bef5893603bd426231398", + "name": "pytables", + "sha256": "4694200ef3bcbb3b2fa641993fd290618455107d232880b2484ca2e25dff0311", + "size": 1522088, + "subdir": "linux-64", + "timestamp": 1524594308960, + "version": "3.4.3" + }, + "pytables-3.4.3-py27h68a8fdc_2.tar.bz2": { + "build": "py27h68a8fdc_2", + "build_number": 2, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "960bc804c844d655c8c7fe1c993bd074", + "name": "pytables", + "sha256": "ccccd80919354bfa151162e82d8b6dc3a9140618a69d2beba5f51f8396b1d8b2", + "size": 1521967, + "subdir": "linux-64", + "timestamp": 1527021669571, + "version": "3.4.3" + }, + "pytables-3.4.3-py35h02b9ad4_0.tar.bz2": { + "build": "py35h02b9ad4_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "94e94bfe4abd18623e3c6979774b9ad7", + "name": "pytables", + "sha256": "893d2243eb6b4546debe0ffa61d3a92f80c20e9ac3202b38e976b8a6f86e8626", + "size": 1555038, + "subdir": "linux-64", + "timestamp": 1524594287356, + "version": "3.4.3" + }, + "pytables-3.4.3-py35h02b9ad4_2.tar.bz2": { + "build": "py35h02b9ad4_2", + "build_number": 2, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d4a7f348f95f8d0eff5fda04db55103c", + "name": "pytables", + "sha256": "cc6421e80007dd70ff397217f52d7969b76f0859127ed6355443966939a09ba3", + "size": 1556306, + "subdir": "linux-64", + "timestamp": 1527021670655, + "version": "3.4.3" + }, + "pytables-3.4.3-py35h68a8fdc_0.tar.bz2": { + "build": "py35h68a8fdc_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a554c9014afdaca321ffe710a0a7f1d9", + "name": "pytables", + "sha256": "ada0c9b197d9077b6e745e0673cd976c55b3d7f8e34320e27ec9b78c998344b6", + "size": 1555902, + "subdir": "linux-64", + "timestamp": 1524594480403, + "version": "3.4.3" + }, + "pytables-3.4.3-py35h68a8fdc_2.tar.bz2": { + "build": "py35h68a8fdc_2", + "build_number": 2, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1017be014ee92df6205fd84b131cb7d0", + "name": "pytables", + "sha256": "e3085293d4356e31c8083ed528e3ac0ac64c822f858f69a8d0157a652cfd1516", + "size": 1555917, + "subdir": "linux-64", + "timestamp": 1527021096123, + "version": "3.4.3" + }, + "pytables-3.4.3-py36h02b9ad4_0.tar.bz2": { + "build": "py36h02b9ad4_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "15a7c60e5fe3a0d3c1a0a388453d5154", + "name": "pytables", + "sha256": "99cdb6293323e3d307082e709d754cb2e1a0831df3038e36966c5b60132913b3", + "size": 1554241, + "subdir": "linux-64", + "timestamp": 1524594472050, + "version": "3.4.3" + }, + "pytables-3.4.3-py36h02b9ad4_2.tar.bz2": { + "build": "py36h02b9ad4_2", + "build_number": 2, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1e407a9ad12cf5d6d10b66d0c2b96414", + "name": "pytables", + "sha256": "a7b1456d27e829b9a56300bea4a789776227cd0f0441005eb2624439612c155d", + "size": 1555302, + "subdir": "linux-64", + "timestamp": 1527021664907, + "version": "3.4.3" + }, + "pytables-3.4.3-py36h68a8fdc_0.tar.bz2": { + "build": "py36h68a8fdc_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "892ecbff56a6cb8201a575675a69b84c", + "name": "pytables", + "sha256": "44021765effa3d013047bf92334654eabad9512fec43e833b08d271cc8e95b06", + "size": 1553673, + "subdir": "linux-64", + "timestamp": 1524593536342, + "version": "3.4.3" + }, + "pytables-3.4.3-py36h68a8fdc_2.tar.bz2": { + "build": "py36h68a8fdc_2", + "build_number": 2, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7b99faea8766dc17808a90b7f07dafa3", + "name": "pytables", + "sha256": "7a4a0a78e51d5b631826dbc17134cea822cd21bdba37b661097afae91e8f60e5", + "size": 1554349, + "subdir": "linux-64", + "timestamp": 1527021080930, + "version": "3.4.3" + }, + "pytables-3.4.4-py27h02b9ad4_0.tar.bz2": { + "build": "py27h02b9ad4_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c44104a11d7f10070e6b83626def5eda", + "name": "pytables", + "sha256": "26cff80ba389b89694012a0d9f3cf4625092852ea283848cd33f3c87d5081418", + "size": 1521367, + "subdir": "linux-64", + "timestamp": 1529061949337, + "version": "3.4.4" + }, + "pytables-3.4.4-py27h68a8fdc_0.tar.bz2": { + "build": "py27h68a8fdc_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "494d3509658725090b42b1ede07a2966", + "name": "pytables", + "sha256": "62151a68b903fb2617fd4f446a007c03c781f0b87a79f812606a70f6708a4988", + "size": 1521734, + "subdir": "linux-64", + "timestamp": 1529061956406, + "version": "3.4.4" + }, + "pytables-3.4.4-py27h71ec239_0.tar.bz2": { + "build": "py27h71ec239_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.4,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c9b044b1537e8ffaec61ca99388b6884", + "name": "pytables", + "sha256": "0964b5acae1f27cc3f0270f7d9224712435e28349c671d820bd0d2e05c889853", + "size": 1469996, + "subdir": "linux-64", + "timestamp": 1545405733588, + "version": "3.4.4" + }, + "pytables-3.4.4-py27ha205bf6_0.tar.bz2": { + "build": "py27ha205bf6_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6212cc9abcdbb3ee0d428496334fae95", + "name": "pytables", + "sha256": "bd2a32517344d4a6740214d2ceeb988947e2cafe5c981d29726c8bb7e513dcac", + "size": 1521066, + "subdir": "linux-64", + "timestamp": 1530740309087, + "version": "3.4.4" + }, + "pytables-3.4.4-py27he1c29e1_0.tar.bz2": { + "build": "py27he1c29e1_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "91eea1d86cbcd76464e0ac20ca439434", + "name": "pytables", + "sha256": "e1eb5cf73a262696a9fd5524b11afbefbe5c254fb7a51d23d10ba786b789f1ea", + "size": 1521905, + "subdir": "linux-64", + "timestamp": 1530740009204, + "version": "3.4.4" + }, + "pytables-3.4.4-py35h02b9ad4_0.tar.bz2": { + "build": "py35h02b9ad4_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0231a6405d7e888eb7c97badf8d9b243", + "name": "pytables", + "sha256": "7a7a72a746ded99f36edd739f64132b0a11c433f3f296fb4e592a55d693b77c4", + "size": 1554574, + "subdir": "linux-64", + "timestamp": 1529062099025, + "version": "3.4.4" + }, + "pytables-3.4.4-py35h68a8fdc_0.tar.bz2": { + "build": "py35h68a8fdc_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "105680b6c57cd76a7fef199049c77955", + "name": "pytables", + "sha256": "7e03ac398265db850154b5ab9f498ccb7e457e2661af126a0476a95d0e8e32ac", + "size": 1554519, + "subdir": "linux-64", + "timestamp": 1529062072704, + "version": "3.4.4" + }, + "pytables-3.4.4-py35ha205bf6_0.tar.bz2": { + "build": "py35ha205bf6_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "57e967cfcdf7334113bf1f8b9f9abfb4", + "name": "pytables", + "sha256": "a12157f150008d1db38c6d0a1557b6ac3547d28065241bf31d6cd0cb66f13919", + "size": 1548776, + "subdir": "linux-64", + "timestamp": 1534356246555, + "version": "3.4.4" + }, + "pytables-3.4.4-py35he1c29e1_0.tar.bz2": { + "build": "py35he1c29e1_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9950567fcb3aae92c85220be0efb9fdf", + "name": "pytables", + "sha256": "dd0ab971fb8422c41487cce86c46b8f5d462ce32b33fdf034bd89a99529b61f5", + "size": 1549828, + "subdir": "linux-64", + "timestamp": 1534355938771, + "version": "3.4.4" + }, + "pytables-3.4.4-py36h02b9ad4_0.tar.bz2": { + "build": "py36h02b9ad4_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dcd99d84d45a06536bdb41ac941b06d2", + "name": "pytables", + "sha256": "649364e2f4d92392698de7f29a7d0e02cf70e691148dca88bc77840300328d9e", + "size": 1554748, + "subdir": "linux-64", + "timestamp": 1529061582603, + "version": "3.4.4" + }, + "pytables-3.4.4-py36h68a8fdc_0.tar.bz2": { + "build": "py36h68a8fdc_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e545a1d6adb26e008d857afadf853032", + "name": "pytables", + "sha256": "7fb9006ada99bb6751b8a29850fcc9885d2c571d272ffd9220d908ead0e98518", + "size": 1553254, + "subdir": "linux-64", + "timestamp": 1529061754009, + "version": "3.4.4" + }, + "pytables-3.4.4-py36h71ec239_0.tar.bz2": { + "build": "py36h71ec239_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.4,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c92d62cb47c91bd8865475a6923b3ca1", + "name": "pytables", + "sha256": "6c5b7fff63ce1d3224c5e33648e51ad439272c08be437be3beb81c9397989ec0", + "size": 1529937, + "subdir": "linux-64", + "timestamp": 1545405839121, + "version": "3.4.4" + }, + "pytables-3.4.4-py36ha205bf6_0.tar.bz2": { + "build": "py36ha205bf6_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "310e1cfa718095093efb031e590e33dc", + "name": "pytables", + "sha256": "1945208abae6b476c2dd86110250f52be2e8b8103ebe8dbfeef8f5e45533f696", + "size": 1554307, + "subdir": "linux-64", + "timestamp": 1530739700858, + "version": "3.4.4" + }, + "pytables-3.4.4-py36he1c29e1_0.tar.bz2": { + "build": "py36he1c29e1_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f7ede3ad93b0e67ef9abf0b8a93d1281", + "name": "pytables", + "sha256": "848e9c95c352e9afe49d7b91d63b0f33dabd0c4a0bc13211073da6d964164153", + "size": 1552822, + "subdir": "linux-64", + "timestamp": 1530739419495, + "version": "3.4.4" + }, + "pytables-3.4.4-py37h71ec239_0.tar.bz2": { + "build": "py37h71ec239_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.4,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9a411324fb8dff3a693089241e3c829e", + "name": "pytables", + "sha256": "5c9894138c07adcb8b4e18cff2618eef1ccf8b2cee9849a8f18e9d34eea54d3e", + "size": 1510421, + "subdir": "linux-64", + "timestamp": 1545405839969, + "version": "3.4.4" + }, + "pytables-3.4.4-py37ha205bf6_0.tar.bz2": { + "build": "py37ha205bf6_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "64016e853c6a69bc26b8fa3bb62492c4", + "name": "pytables", + "sha256": "ba405cc8bf81abc87d87be59c6373ead524a53a2ef0711d1319bad3ac4a9c49e", + "size": 1545524, + "subdir": "linux-64", + "timestamp": 1530740912745, + "version": "3.4.4" + }, + "pytables-3.4.4-py37he1c29e1_0.tar.bz2": { + "build": "py37he1c29e1_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "df71720125a5a8daba03873edd46d12e", + "name": "pytables", + "sha256": "6e38cfd52eeef1a7cf5eb8df53579beb6b485e6cd6e978d7303ba10977af1ec1", + "size": 1543532, + "subdir": "linux-64", + "timestamp": 1530740643663, + "version": "3.4.4" + }, + "pytables-3.5.1-py27h71ec239_0.tar.bz2": { + "build": "py27h71ec239_0", + "build_number": 0, + "depends": [ + "blosc >=1.15.0,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "989e40ce8d8cd0bf9e75d5bfc72ff9f7", + "name": "pytables", + "sha256": "aef101e5f7e1dbccc57788a9180f6f15f0c5355e24c3ee45f435bd7b2369f0a8", + "size": 1485947, + "subdir": "linux-64", + "timestamp": 1552930186620, + "version": "3.5.1" + }, + "pytables-3.5.1-py36h71ec239_0.tar.bz2": { + "build": "py36h71ec239_0", + "build_number": 0, + "depends": [ + "blosc >=1.15.0,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0f83be83e4f644c829714ce978f2f81c", + "name": "pytables", + "sha256": "735b74b93355ab30c9a96eef9b9d069a240205148c42178547ca553bdfd89204", + "size": 1541816, + "subdir": "linux-64", + "timestamp": 1552930182748, + "version": "3.5.1" + }, + "pytables-3.5.1-py37h71ec239_0.tar.bz2": { + "build": "py37h71ec239_0", + "build_number": 0, + "depends": [ + "blosc >=1.15.0,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9fd3b5ecfa6cbe0d19998a7959a5c973", + "name": "pytables", + "sha256": "b69c1ae7efa3b00667043401cde684f5488a78bc8b6fa4b0a67aae00822f9728", + "size": 1517109, + "subdir": "linux-64", + "timestamp": 1552930030908, + "version": "3.5.1" + }, + "pytables-3.5.2-py27h71ec239_1.tar.bz2": { + "build": "py27h71ec239_1", + "build_number": 1, + "depends": [ + "blosc >=1.16.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b6d27a21f515d1b8ed218db95b499ac3", + "name": "pytables", + "sha256": "62a8140305f7ce94de90e1918733fee9fb37ceb8bb7ab1bde23a226c4e4c2cb9", + "size": 1488845, + "subdir": "linux-64", + "timestamp": 1559922805225, + "version": "3.5.2" + }, + "pytables-3.5.2-py36h71ec239_1.tar.bz2": { + "build": "py36h71ec239_1", + "build_number": 1, + "depends": [ + "blosc >=1.16.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "af7a3ac0b52397fd9618a5bd63b3a226", + "name": "pytables", + "sha256": "d847c5bb47ce21ecf6c7a404fb460e1a338f77bbfd2abd25c30595d2047126de", + "size": 1535248, + "subdir": "linux-64", + "timestamp": 1559922810996, + "version": "3.5.2" + }, + "pytables-3.5.2-py37h71ec239_1.tar.bz2": { + "build": "py37h71ec239_1", + "build_number": 1, + "depends": [ + "blosc >=1.16.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "74554d0dc5f4d5dccc68d8f8139c1613", + "name": "pytables", + "sha256": "3dde87221f4b59a739c5946d08c24f4c77913708732524c7239d4a61dfb79abf", + "size": 1535365, + "subdir": "linux-64", + "timestamp": 1559922653201, + "version": "3.5.2" + }, + "pytables-3.6.1-py310hadd16c1_1.tar.bz2": { + "build": "py310hadd16c1_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr", + "python >=3.10,<3.11.0a0", + "six", + "zlib" + ], + "license": "BSD 3-Clause", + "md5": "f83efa95d49002b14118b9743d0ebe1f", + "name": "pytables", + "sha256": "d9ab31fffdb7a487ec6a56cf06cee06821f4f26a6a86d2beb18c2dc7690a4121", + "size": 3465385, + "subdir": "linux-64", + "timestamp": 1641403702071, + "version": "3.6.1" + }, + "pytables-3.6.1-py36h71ec239_0.tar.bz2": { + "build": "py36h71ec239_0", + "build_number": 0, + "depends": [ + "blosc >=1.16.3,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8645398414eb0b09aef1884d434dab97", + "name": "pytables", + "sha256": "4279b5cf093a8243d92f6408f855bf9afa9667030b5ee2773ae6ad32f076591a", + "size": 1540798, + "subdir": "linux-64", + "timestamp": 1573080058184, + "version": "3.6.1" + }, + "pytables-3.6.1-py37h71ec239_0.tar.bz2": { + "build": "py37h71ec239_0", + "build_number": 0, + "depends": [ + "blosc >=1.16.3,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f997aedfd87201a82fe9846054ecd24f", + "name": "pytables", + "sha256": "2ff6c33562e0c0b93cc96a21dc3b74bcfc0092d0b85164c4d4bf6ac7f1988eb7", + "size": 1521068, + "subdir": "linux-64", + "timestamp": 1573080078715, + "version": "3.6.1" + }, + "pytables-3.6.1-py38h9fd0a39_0.tar.bz2": { + "build": "py38h9fd0a39_0", + "build_number": 0, + "depends": [ + "blosc >=1.16.3,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c6adb784aeac0ca88890b7c48463589c", + "name": "pytables", + "sha256": "bb95c20956f2c668e8c41380c40e3ebdebaac491cd0482c2c1e5fcd9d9a1c359", + "size": 1566294, + "subdir": "linux-64", + "timestamp": 1580255489176, + "version": "3.6.1" + }, + "pytables-3.6.1-py39h77479fe_1.tar.bz2": { + "build": "py39h77479fe_1", + "build_number": 1, + "depends": [ + "blosc >=1.20.1,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "six", + "zlib" + ], + "license": "BSD 3-Clause", + "md5": "7ad210971e969062b598877d5e130af7", + "name": "pytables", + "sha256": "41db31725d01dfbb72dd900cc82b398315aba4a3370eb5fe717b7a9dc3d0d98b", + "size": 1579173, + "subdir": "linux-64", + "timestamp": 1607975491140, + "version": "3.6.1" + }, + "pytables-3.7.0-py310h9da3b7f_0.tar.bz2": { + "build": "py310h9da3b7f_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "blosc >=1.4.1", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.12.1,<1.12.2.0a0", + "hdf5 >=1.8.15", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr >=2.6.2", + "numpy >=1.21.2,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0", + "zlib" + ], + "license": "BSD-3-Clause", + "md5": "f26a02175eab63e796b59fa896ae1297", + "name": "pytables", + "sha256": "cf7311fa25fdcb11a83fe547e12693cb149b5b6214f7c185b428f51bf5d263d4", + "size": 3998407, + "subdir": "linux-64", + "timestamp": 1647579641224, + "version": "3.7.0" + }, + "pytables-3.7.0-py310hf19a122_1.tar.bz2": { + "build": "py310hf19a122_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "blosc >=1.4.1", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "hdf5 >=1.8.15", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr >=2.6.2", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0", + "zlib" + ], + "license": "BSD-3-Clause", + "md5": "1f0e1566e0abdfaeff7d8333fb9e9ec1", + "name": "pytables", + "sha256": "8db30f6bdfda03ea846430d0ec7247810ae5ab9f935fd1c1af88e28f552869ad", + "size": 1994743, + "subdir": "linux-64", + "timestamp": 1673968099316, + "version": "3.7.0" + }, + "pytables-3.7.0-py311hf19a122_1.tar.bz2": { + "build": "py311hf19a122_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "blosc >=1.4.1", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "hdf5 >=1.8.15", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr >=2.6.2", + "numpy >=1.23.5,<2.0a0", + "packaging", + "python >=3.11,<3.12.0a0", + "zlib" + ], + "license": "BSD-3-Clause", + "md5": "614a6df5f7ecca8e3bf270f1e4aa42f5", + "name": "pytables", + "sha256": "643e48e4578a25e3867ed14ef7eb5c4a8228682fa3d1cb2eca7dfffe86a49d4f", + "size": 2252919, + "subdir": "linux-64", + "timestamp": 1676845476062, + "version": "3.7.0" + }, + "pytables-3.7.0-py37h9da3b7f_0.tar.bz2": { + "build": "py37h9da3b7f_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "blosc >=1.4.1", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.12.1,<1.12.2.0a0", + "hdf5 >=1.8.15", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr >=2.6.2", + "numpy >=1.19.2,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0", + "zlib" + ], + "license": "BSD-3-Clause", + "md5": "90399ce9fb155ae3723c898519706864", + "name": "pytables", + "sha256": "83fd55bba89baf4ee1a4964e55ca999f2653d93673b73636a6dfbe30359aa316", + "size": 1977418, + "subdir": "linux-64", + "timestamp": 1647597739850, + "version": "3.7.0" + }, + "pytables-3.7.0-py37hf19a122_1.tar.bz2": { + "build": "py37hf19a122_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "blosc >=1.4.1", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "hdf5 >=1.8.15", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr >=2.6.2", + "numpy >=1.19.2,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0", + "zlib" + ], + "license": "BSD-3-Clause", + "md5": "7b00d93c8cb1978d2d87c21c84fc29f6", + "name": "pytables", + "sha256": "30d18bc733fb523d1fa04f6a9b270459b3ae2350114a8be6b913917ee5e50368", + "size": 1984401, + "subdir": "linux-64", + "timestamp": 1673968292560, + "version": "3.7.0" + }, + "pytables-3.7.0-py38h9da3b7f_0.tar.bz2": { + "build": "py38h9da3b7f_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "blosc >=1.4.1", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.12.1,<1.12.2.0a0", + "hdf5 >=1.8.15", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr >=2.6.2", + "numpy >=1.19.2,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0", + "zlib" + ], + "license": "BSD-3-Clause", + "md5": "0a2a928187c649e7fff377301ac1c72e", + "name": "pytables", + "sha256": "7bb8f43afa81159e65561a0923470197640206eeb3585d5c1be05f95bf7913a1", + "size": 2020933, + "subdir": "linux-64", + "timestamp": 1647579872277, + "version": "3.7.0" + }, + "pytables-3.7.0-py38hf19a122_1.tar.bz2": { + "build": "py38hf19a122_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "blosc >=1.4.1", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "hdf5 >=1.8.15", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr >=2.6.2", + "numpy >=1.19.2,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0", + "zlib" + ], + "license": "BSD-3-Clause", + "md5": "b0e186d18443e1e8658f936cb5641b5e", + "name": "pytables", + "sha256": "782583653b1490bd67ae904f4bb181b36952333105b4be209fd9af6391d28cee", + "size": 2007916, + "subdir": "linux-64", + "timestamp": 1673967913201, + "version": "3.7.0" + }, + "pytables-3.7.0-py39h9da3b7f_0.tar.bz2": { + "build": "py39h9da3b7f_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "blosc >=1.4.1", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.12.1,<1.12.2.0a0", + "hdf5 >=1.8.15", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr >=2.6.2", + "numpy >=1.19.2,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0", + "zlib" + ], + "license": "BSD-3-Clause", + "md5": "6c2e92a414d3609fa93a9df87dcc511a", + "name": "pytables", + "sha256": "91b5199f9556a63369d477d101c971fe26dedb1b25e149400108ba2a1d98a953", + "size": 2004188, + "subdir": "linux-64", + "timestamp": 1647597737936, + "version": "3.7.0" + }, + "pytables-3.7.0-py39hf19a122_1.tar.bz2": { + "build": "py39hf19a122_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "blosc >=1.4.1", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "hdf5 >=1.8.15", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr >=2.6.2", + "numpy >=1.19.2,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0", + "zlib" + ], + "license": "BSD-3-Clause", + "md5": "436013285d6b2e8308ee425e71cd3211", + "name": "pytables", + "sha256": "b9a4b320d99981ee59a34d36096d6b2162ddc984f9cf9391e5451cdf461cccc6", + "size": 1992257, + "subdir": "linux-64", + "timestamp": 1673967724543, + "version": "3.7.0" + }, + "pytesseract-0.3.10-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=21.3", + "pillow >=8.0.0", + "python >=3.10,<3.11.0a0", + "tesseract" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4cb8d33cb4e1ab9cb82d1a78056f8fa3", + "name": "pytesseract", + "sha256": "342e5ecf51bcdc741a189e1def117073db01c9119f29baa291d8350417d11ff9", + "size": 44708, + "subdir": "linux-64", + "timestamp": 1666335192153, + "version": "0.3.10" + }, + "pytesseract-0.3.10-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=21.3", + "pillow >=8.0.0", + "python >=3.11,<3.12.0a0", + "tesseract" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f491a7b1eba4c0c00adfb07407247fea", + "name": "pytesseract", + "sha256": "47145a68dc6b15fcdc99287721c795175fffdb6a92b721e3ba8f25e27ee451ff", + "size": 50334, + "subdir": "linux-64", + "timestamp": 1676861272572, + "version": "0.3.10" + }, + "pytesseract-0.3.10-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=21.3", + "pillow >=8.0.0", + "python >=3.7,<3.8.0a0", + "tesseract" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4d3151cc740af55f6aabecceb77dab26", + "name": "pytesseract", + "sha256": "a8427ecf6550d8745fd441a70a4b4f3a260d115f9741a8d15b05d655826d958a", + "size": 44312, + "subdir": "linux-64", + "timestamp": 1666335230865, + "version": "0.3.10" + }, + "pytesseract-0.3.10-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=21.3", + "pillow >=8.0.0", + "python >=3.8,<3.9.0a0", + "tesseract" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "92ff2724346f751a0b534cc1aaadd691", + "name": "pytesseract", + "sha256": "85ab9841b7820a7f55958a8fa5dadd4f24b99a93cadec525570c8ad299fbc756", + "size": 44452, + "subdir": "linux-64", + "timestamp": 1666335102088, + "version": "0.3.10" + }, + "pytesseract-0.3.10-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=21.3", + "pillow >=8.0.0", + "python >=3.9,<3.10.0a0", + "tesseract" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9a1b3a0b006dc1c3a859102e8650de72", + "name": "pytesseract", + "sha256": "02fa9facaa9ae51027da122279ea3409394c8652288dc8104f2dbd758d2fcd7c", + "size": 44491, + "subdir": "linux-64", + "timestamp": 1666335154214, + "version": "0.3.10" + }, + "pytest-3.10.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "c3bb7100253a403cbd04bac2e31060fd", + "name": "pytest", + "sha256": "9c6427eaf49826f104982b9dfbebacdbdf668aad6874b917de08377a31f8a583", + "size": 340932, + "subdir": "linux-64", + "timestamp": 1541443244078, + "version": "3.10.0" + }, + "pytest-3.10.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "577b013dea4bc6bee0bc01d3ccb299fd", + "name": "pytest", + "sha256": "9c16f3ea5f51dd3b44807dc6a4f585afbdbf5df352663920b71db729f7a52bfb", + "size": 341964, + "subdir": "linux-64", + "timestamp": 1541443287912, + "version": "3.10.0" + }, + "pytest-3.10.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "bcf0b6f7c4216443a57c66605472c42b", + "name": "pytest", + "sha256": "3bba59b8ec3492b6c88b51ea11ab1cfd9b3ffbffc122024b603baffa1f08a3a5", + "size": 342360, + "subdir": "linux-64", + "timestamp": 1541443241820, + "version": "3.10.0" + }, + "pytest-3.10.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "bca4363732125bc0fded4da019afcd13", + "name": "pytest", + "sha256": "12024e43c456ba5037c505957a266bfb68f5ec538133a0e895667fd1676e7adf", + "size": 341593, + "subdir": "linux-64", + "timestamp": 1542086576311, + "version": "3.10.1" + }, + "pytest-3.10.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "0f2d70b98bc47d4c93dd2dfeb409586c", + "name": "pytest", + "sha256": "da39bd8ee0071423b97128bf2a4bd74ca436f76a37e21d7a9b88217ca3e1f1cb", + "size": 347155, + "subdir": "linux-64", + "timestamp": 1542086561902, + "version": "3.10.1" + }, + "pytest-3.10.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "0781b130c289860bd7c866cc6f29f128", + "name": "pytest", + "sha256": "1b7229aac8a9ff5aabd690fb1f3de20fb2430ca50db20bc6b8fcd10fde688486", + "size": 347338, + "subdir": "linux-64", + "timestamp": 1542086558384, + "version": "3.10.1" + }, + "pytest-3.2.1-py27h98000ae_1.tar.bz2": { + "build": "py27h98000ae_1", + "build_number": 1, + "depends": [ + "py >=1.4.33", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "26ee616e4a343b5762da0ec97221207e", + "name": "pytest", + "sha256": "1f00c79202d561abe7682aea331c9275886f1438f190f71d4870718cd479215d", + "size": 282149, + "subdir": "linux-64", + "timestamp": 1505688259990, + "version": "3.2.1" + }, + "pytest-3.2.1-py35hc97c719_1.tar.bz2": { + "build": "py35hc97c719_1", + "build_number": 1, + "depends": [ + "py >=1.4.33", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "2982dd8ba6d4697e80232af89449b519", + "name": "pytest", + "sha256": "c3401d7c9c8f719b9ce50530f9bc61b1466e0b3b4d3dd2aedad431b8d350b194", + "size": 290460, + "subdir": "linux-64", + "timestamp": 1505688274722, + "version": "3.2.1" + }, + "pytest-3.2.1-py36h11ad3bb_1.tar.bz2": { + "build": "py36h11ad3bb_1", + "build_number": 1, + "depends": [ + "py >=1.4.33", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "d4e7acb95787bf00b1d9ce53e8e9bbfe", + "name": "pytest", + "sha256": "d2b7d144fe698ea38d7e9d8a85bb2a5309ca77ff1834aacb6a42682de397e46e", + "size": 289189, + "subdir": "linux-64", + "timestamp": 1505688289543, + "version": "3.2.1" + }, + "pytest-3.2.5-py27hfc7e320_0.tar.bz2": { + "build": "py27hfc7e320_0", + "build_number": 0, + "depends": [ + "py >=1.4.33", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "32c9d2bd2f583b78ed20dd5eba7a8655", + "name": "pytest", + "sha256": "2367d902b6a188c62ab6974b5a07b3c855a9c2e13a5ea0037c9c3d7c526f95ff", + "size": 284796, + "subdir": "linux-64", + "timestamp": 1511321610858, + "version": "3.2.5" + }, + "pytest-3.2.5-py35h18d855a_0.tar.bz2": { + "build": "py35h18d855a_0", + "build_number": 0, + "depends": [ + "py >=1.4.33", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "1c4eec08db9effda0b8fc545abfc1898", + "name": "pytest", + "sha256": "9635d58137264bb90c34169becf65698d777880a77f2b5a54ba7be07989c54ff", + "size": 292788, + "subdir": "linux-64", + "timestamp": 1511321622171, + "version": "3.2.5" + }, + "pytest-3.2.5-py36h288962d_0.tar.bz2": { + "build": "py36h288962d_0", + "build_number": 0, + "depends": [ + "py >=1.4.33", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "781e99f495f10fc23d1307e681854cc3", + "name": "pytest", + "sha256": "ebd254280cf4ee3c9634c3cbc99db2e198434d4b383d00ad8eddf73ce28fb6d3", + "size": 291298, + "subdir": "linux-64", + "timestamp": 1511321627683, + "version": "3.2.5" + }, + "pytest-3.3.0-py27h0742b9d_0.tar.bz2": { + "build": "py27h0742b9d_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "funcsigs", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "89a18a67c2b938bcb406eced6f4c7271", + "name": "pytest", + "sha256": "33b817867d5fd815691b00a6312fb10143a9e19d44fec1d574ee98b5c290c40b", + "size": 278956, + "subdir": "linux-64", + "timestamp": 1511931424928, + "version": "3.3.0" + }, + "pytest-3.3.0-py35h5c08cda_0.tar.bz2": { + "build": "py35h5c08cda_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "af3300c5c2c8b0a8d760d14c99c806ad", + "name": "pytest", + "sha256": "b42da3356f486c62184bd78bc901547333676aba6350970b168887a21bc847ef", + "size": 287807, + "subdir": "linux-64", + "timestamp": 1511931423972, + "version": "3.3.0" + }, + "pytest-3.3.0-py36h23ce9bc_0.tar.bz2": { + "build": "py36h23ce9bc_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "daa70d4f6226aa82edad4737f00695b7", + "name": "pytest", + "sha256": "37b622f41bba5ffb36c38b958f9e0b35a2174c255644802bda9489a82c6c21dc", + "size": 287063, + "subdir": "linux-64", + "timestamp": 1511931484525, + "version": "3.3.0" + }, + "pytest-3.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs", + "funcsigs", + "pluggy", + "py >=1.4.33", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "fdf8887b990d72bb53b62a8a12d726a7", + "name": "pytest", + "sha256": "4aa1aaa8f1e8965661764b87ab59833175792bd57d1f1e158325a92dbc891021", + "size": 280305, + "subdir": "linux-64", + "timestamp": 1515725591680, + "version": "3.3.2" + }, + "pytest-3.3.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs", + "pluggy", + "py >=1.4.33", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "cee8cbe30380ed5b134ec3779a217e3d", + "name": "pytest", + "sha256": "b75dd2512f2808b2efb8cd4fcb4577ccd3bbad3234c3fada82259ccbaa7ec59f", + "size": 288375, + "subdir": "linux-64", + "timestamp": 1515725240611, + "version": "3.3.2" + }, + "pytest-3.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs", + "pluggy", + "py >=1.4.33", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "925feeb6c2894d7891fbb47c6560c0e3", + "name": "pytest", + "sha256": "5e667d4f77015310bff8d6b92c712d0960d9bbd741874e44fa4c1e4697c69f35", + "size": 287520, + "subdir": "linux-64", + "timestamp": 1515725594020, + "version": "3.3.2" + }, + "pytest-3.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "funcsigs", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "f7a115225d21866270aeee4a0a5c15bd", + "name": "pytest", + "sha256": "74b6113a34fa37861bf8dc92c34891cb53fdec903c4a736ba1c02fc255fa3990", + "size": 284687, + "subdir": "linux-64", + "timestamp": 1519112337973, + "version": "3.4.0" + }, + "pytest-3.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "8ab3b49237e220321f4a48bb7b162b7c", + "name": "pytest", + "sha256": "c43b96fca6b26f7b2ea8a00af1d89f775c8fc522d2c706e119d29aa1f04ad4ad", + "size": 292850, + "subdir": "linux-64", + "timestamp": 1519112352201, + "version": "3.4.0" + }, + "pytest-3.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "610dc02f8565b44ee00c51c0018994d9", + "name": "pytest", + "sha256": "ea27f0afd0e987da4829341b26348f93e99b276d442b304063b786b876ebfe31", + "size": 291408, + "subdir": "linux-64", + "timestamp": 1519112348471, + "version": "3.4.0" + }, + "pytest-3.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "funcsigs", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "3a8e6d083c79d10df5190a7e81f60aee", + "name": "pytest", + "sha256": "dc114a7c21411682783c55460c6fe752791f008adefe91d3f32e17cd02e3cd55", + "size": 285527, + "subdir": "linux-64", + "timestamp": 1519747428626, + "version": "3.4.1" + }, + "pytest-3.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "87cd912515eeaa81c758c7655de5d551", + "name": "pytest", + "sha256": "6e52b3ad66bbb515b3b7f8bbd89d47b6cedfa0f9cc673151a8c519883476ea67", + "size": 293343, + "subdir": "linux-64", + "timestamp": 1519747449115, + "version": "3.4.1" + }, + "pytest-3.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "669e87d26e97eb42e7a9f4feb0b19d51", + "name": "pytest", + "sha256": "74f58e71af00233865126bbb5d41b4058702cf94d3cd0bf627a2ec2a77518777", + "size": 292191, + "subdir": "linux-64", + "timestamp": 1519747418396, + "version": "3.4.1" + }, + "pytest-3.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "funcsigs", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "dd74e8fe0c5d43c82ab0fed553d3d4e0", + "name": "pytest", + "sha256": "be04bf08921abbcab5cd1531d5d538b1563ad5b00291b1f40f1fae542b8267ab", + "size": 285676, + "subdir": "linux-64", + "timestamp": 1520367036018, + "version": "3.4.2" + }, + "pytest-3.4.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "bc4f52d4a639fdc82806141feb1ef9f0", + "name": "pytest", + "sha256": "a41c901bafae0ee29eab711b19f8815cc917a1aea52b8775288b01d214db162e", + "size": 293718, + "subdir": "linux-64", + "timestamp": 1520367267083, + "version": "3.4.2" + }, + "pytest-3.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "1a3c26b3d2d48ffdbbe8985d5879e9bf", + "name": "pytest", + "sha256": "fb2e854b7545cc857272abeb6d8850ab05aee93fdce9a2f75679a26134a685a9", + "size": 292429, + "subdir": "linux-64", + "timestamp": 1520367292349, + "version": "3.4.2" + }, + "pytest-3.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "dabb56ba7eeff2edf4090508c04ac99a", + "name": "pytest", + "sha256": "db09352e1d23692be28c95d609168fe2d9b4ec4a1073181db1ac5e56875e4140", + "size": 293778, + "subdir": "linux-64", + "timestamp": 1522186564622, + "version": "3.5.0" + }, + "pytest-3.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "868f82cd8dc8134e7ae001473d1bceb4", + "name": "pytest", + "sha256": "acaa29bc1be5cb74325b73183034b26c7bc2a49923b976a8bee242265154e639", + "size": 300537, + "subdir": "linux-64", + "timestamp": 1522186596454, + "version": "3.5.0" + }, + "pytest-3.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "f3beb4200e96200bb3c0f47481bdaee6", + "name": "pytest", + "sha256": "0a8569f8cfa68362dfc3b9bb978c8ee30b02f2fa2a7c45aa25bdc388197cbfea", + "size": 299553, + "subdir": "linux-64", + "timestamp": 1522186590067, + "version": "3.5.0" + }, + "pytest-3.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "271037ef693b52e1df0bf7788383f106", + "name": "pytest", + "sha256": "be823040996b9f72b536188f74ade88d807da2813fb2df36c08a6510df7cc5d8", + "size": 294227, + "subdir": "linux-64", + "timestamp": 1525118540346, + "version": "3.5.1" + }, + "pytest-3.5.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "c9b82a52a43bccd4096e069b2a02fcc6", + "name": "pytest", + "sha256": "a30f8975bfa961949090f917e7d9c1e5c67a38a99e604d73c70bdd6f2b0ba78f", + "size": 300895, + "subdir": "linux-64", + "timestamp": 1525118559288, + "version": "3.5.1" + }, + "pytest-3.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "2f49daeddd3b91987ff1eb9051bdc1d4", + "name": "pytest", + "sha256": "312aaad901924eab5ee48f2f431527f8b3aaef4b1c80fdb06a114ec4505e8f9b", + "size": 299295, + "subdir": "linux-64", + "timestamp": 1525118596150, + "version": "3.5.1" + }, + "pytest-3.6.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "538555ec500f7cced7f9542495018117", + "name": "pytest", + "sha256": "f57b7094c0d2667523800b9d99ff08ad0e578ff6123b9eeaba230a4a21e3097f", + "size": 299301, + "subdir": "linux-64", + "timestamp": 1527822410451, + "version": "3.6.0" + }, + "pytest-3.6.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "8d629a9445ec289282b6c00546effc24", + "name": "pytest", + "sha256": "cc75c31a4152a0e3eef3072d731105024eed5654c16edc8ff1003b61ca25c1d8", + "size": 305559, + "subdir": "linux-64", + "timestamp": 1527822430538, + "version": "3.6.0" + }, + "pytest-3.6.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "bb5f13102c23294ae2182e6c4d1f18ce", + "name": "pytest", + "sha256": "b8c3a68c2ece6545d50cc00155838687d585ecc0d493f87aa7e259f7c952086f", + "size": 304818, + "subdir": "linux-64", + "timestamp": 1527822362732, + "version": "3.6.0" + }, + "pytest-3.6.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "cf8d5e74682145db1647973da7a69fc1", + "name": "pytest", + "sha256": "3b51a4e20348dad240c16935b895601aa2670ed41ddcde6eecd90e2b7dc1d106", + "size": 299445, + "subdir": "linux-64", + "timestamp": 1528894537985, + "version": "3.6.1" + }, + "pytest-3.6.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "79359e3b1a52fc6839fb299816978959", + "name": "pytest", + "sha256": "040f6f2e2de1091382692dc730c38e46f6b70c8b417617b2cd4e4bc1ef83705f", + "size": 305140, + "subdir": "linux-64", + "timestamp": 1528894567230, + "version": "3.6.1" + }, + "pytest-3.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "5392082b56bd857c127ae51efbadb192", + "name": "pytest", + "sha256": "18cd17fe2925546c43e521e417b6a8d0b1fdc8480ac99fc2d73ed8ab86a36a84", + "size": 304639, + "subdir": "linux-64", + "timestamp": 1528894501498, + "version": "3.6.1" + }, + "pytest-3.6.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "f7887ec72702da047fde2897f1b80fb1", + "name": "pytest", + "sha256": "2ea68aab2d46cfbf9db71a2db10383b1349f34c75f070f589354c11de3404632", + "size": 300298, + "subdir": "linux-64", + "timestamp": 1529939484773, + "version": "3.6.2" + }, + "pytest-3.6.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "6642fe6811b8e432380c551cdd5ab059", + "name": "pytest", + "sha256": "60a88698737dfb23c35bf19b19fea6f493afa63f99af70224c26c49acbf7addf", + "size": 309440, + "subdir": "linux-64", + "timestamp": 1529939524499, + "version": "3.6.2" + }, + "pytest-3.6.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "131599e9ceabf523648430de4364240e", + "name": "pytest", + "sha256": "393e8f544d84dbca7b1771ddd22c7f5afc241727bdb4042b8a37d1dd7b413c92", + "size": 306736, + "subdir": "linux-64", + "timestamp": 1529939465457, + "version": "3.6.2" + }, + "pytest-3.6.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "d9f26fdd4abc39294b977bf5efc19c3c", + "name": "pytest", + "sha256": "a3ade1ccc23b013ee037203e1b774fdfab2a93a1e6097ca4552fa22716a413d3", + "size": 307152, + "subdir": "linux-64", + "timestamp": 1530212797676, + "version": "3.6.2" + }, + "pytest-3.6.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "cb5537b7b0c9ee3d7ebee3c2750cd6db", + "name": "pytest", + "sha256": "20d5cfc2c94f081e9b20f3a89dbd177e380d0b7abfa18a8c89f9d5eeefef68ec", + "size": 300169, + "subdir": "linux-64", + "timestamp": 1531850289641, + "version": "3.6.3" + }, + "pytest-3.6.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "6e224af2c9862e36e0e4bdac92b9e038", + "name": "pytest", + "sha256": "5887de1fcd8e099c664ddcd6655669f4046d89f0d16491eb5c09493238d863ec", + "size": 309742, + "subdir": "linux-64", + "timestamp": 1531850227949, + "version": "3.6.3" + }, + "pytest-3.6.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "46e3e7fd7ad27b472315308653b90cbe", + "name": "pytest", + "sha256": "476519fbeb3821007536b52e5b7fd0dc907334111bc26245a39eec24ebeb1834", + "size": 307124, + "subdir": "linux-64", + "timestamp": 1531850324222, + "version": "3.6.3" + }, + "pytest-3.6.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "1a4b331b834118ac0a01f1fa7720b4a7", + "name": "pytest", + "sha256": "bfd3641bced03969c4330ed4949a2d27386d45cb9b56c61a793b252a49d3bab9", + "size": 307274, + "subdir": "linux-64", + "timestamp": 1531850327263, + "version": "3.6.3" + }, + "pytest-3.6.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "fd0e69b5647b82a2c6d3fe6c4b789fd6", + "name": "pytest", + "sha256": "7be2c00b143e6c3d7c27ffd36e10eef35e170ef98a0d067649179e24ecd1b96d", + "size": 300647, + "subdir": "linux-64", + "timestamp": 1532972930230, + "version": "3.6.4" + }, + "pytest-3.6.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "49d833be389c7a74216ad31155061af6", + "name": "pytest", + "sha256": "71ac6facc2e50620d36a67d5368e2d4527d6c10e5f778c0ea045ac5644fea3d7", + "size": 309079, + "subdir": "linux-64", + "timestamp": 1532972947170, + "version": "3.6.4" + }, + "pytest-3.6.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "9fa2a305b3b8f0b5ee7e59b95ad97dac", + "name": "pytest", + "sha256": "62cfe1e8d65e1429b3f5b2eec9c4500876b6bab2fce2aba6d00b164ad3a808d7", + "size": 307485, + "subdir": "linux-64", + "timestamp": 1532972878266, + "version": "3.6.4" + }, + "pytest-3.6.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "a3f2257d997821cb428d0691a87a99d9", + "name": "pytest", + "sha256": "d922d96ba130479818c3e89ed6422a734a1362f10e7d5f4bf021918ccd4c1505", + "size": 308221, + "subdir": "linux-64", + "timestamp": 1532973008669, + "version": "3.6.4" + }, + "pytest-3.7.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "04892ea66215ccd2a489ae8bbb9cf4d0", + "name": "pytest", + "sha256": "410bc308997dc1f91e684965b74ad4ddf45fc3beca8d4a878b31c689ebb78677", + "size": 306753, + "subdir": "linux-64", + "timestamp": 1533738856946, + "version": "3.7.1" + }, + "pytest-3.7.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "eed65ca348fed4fb2e45686b76707468", + "name": "pytest", + "sha256": "c24531bba05d392fcf5c2a6ce4784991aad01c3784dcc70828c7a6d3af211636", + "size": 316172, + "subdir": "linux-64", + "timestamp": 1533738867703, + "version": "3.7.1" + }, + "pytest-3.7.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "98f4ae50dcc6c84ba63a02d714ed1104", + "name": "pytest", + "sha256": "abde5df4559b4a72fdb964a5686a021f49cd0e1cffcb13ab197f893120f4fc3e", + "size": 316132, + "subdir": "linux-64", + "timestamp": 1533738821583, + "version": "3.7.1" + }, + "pytest-3.7.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "120b69980fc9029d80a57bef7b12a47e", + "name": "pytest", + "sha256": "498f0e8a09de1928c3497324ed0e9471783da60b82070b43afd3fd17c8751d31", + "size": 315498, + "subdir": "linux-64", + "timestamp": 1533738872911, + "version": "3.7.1" + }, + "pytest-3.7.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "68ceeb4c6f304b514f4503a04977e17d", + "name": "pytest", + "sha256": "f3323d7a864813a762bdba525ec0e5f11cd41d67f35c750b8a343a7f55085f74", + "size": 307049, + "subdir": "linux-64", + "timestamp": 1534944828655, + "version": "3.7.2" + }, + "pytest-3.7.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "c954db97bb328d031bc84ca27c191163", + "name": "pytest", + "sha256": "e1ea70828ab089e9f89a91e95bba6e8eaae841af98abeac8512330d357b1cafa", + "size": 317076, + "subdir": "linux-64", + "timestamp": 1534944923565, + "version": "3.7.2" + }, + "pytest-3.7.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "dcc357a44a50f9b5b6485232a4b3f1cf", + "name": "pytest", + "sha256": "1dd794ecebe55c17a497749e6aef2cb9565ca971121b021c0255902feed9e765", + "size": 315916, + "subdir": "linux-64", + "timestamp": 1534944783317, + "version": "3.7.2" + }, + "pytest-3.7.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "3748cbbc34ee8a656127d9b74f86a859", + "name": "pytest", + "sha256": "1c99201669d0059d3cf9fec2559ea936dc0e2142e48591d5dcd34bc8f8b96090", + "size": 315446, + "subdir": "linux-64", + "timestamp": 1534944833064, + "version": "3.7.2" + }, + "pytest-3.7.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "f28e23b315d1f5effca88e7ee2f3d95f", + "name": "pytest", + "sha256": "9c7715ae99179ec9c3f2c43e4ba5277720495e8b26fbcf1b97ee531826640606", + "size": 308588, + "subdir": "linux-64", + "timestamp": 1535377167673, + "version": "3.7.3" + }, + "pytest-3.7.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "2780d13efcd86550d4b99710c559197b", + "name": "pytest", + "sha256": "63b1140f8233562abec2f361f881d9442d6a890407b7d817e8e0bcf8ea99ceec", + "size": 318181, + "subdir": "linux-64", + "timestamp": 1535377234016, + "version": "3.7.3" + }, + "pytest-3.7.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "3e4a0d1f55f760ca6dd9d8b5fe320fa8", + "name": "pytest", + "sha256": "dad7a004a9ad5d1b5f9d55f024059d04b20feea5bb7b4f9b4d05c22785039a70", + "size": 316896, + "subdir": "linux-64", + "timestamp": 1535377136395, + "version": "3.7.3" + }, + "pytest-3.7.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "1b5b751d02fd78de56c1d462f383a03e", + "name": "pytest", + "sha256": "0210dc4fb818a508166da2d0bc1e582b5602cff36b5ab8b7ee809fa95ad634bd", + "size": 317893, + "subdir": "linux-64", + "timestamp": 1535377175267, + "version": "3.7.3" + }, + "pytest-3.7.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "5719f65cb9cd42db9ae53df91bde3e6d", + "name": "pytest", + "sha256": "c1b6fd5c44d18cbc29de09d87f9710f88e1aac42d9b9ce1467e82eafa59ed947", + "size": 308871, + "subdir": "linux-64", + "timestamp": 1536072443344, + "version": "3.7.4" + }, + "pytest-3.7.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "ac74f7c2b6bde4693362f883dd6be330", + "name": "pytest", + "sha256": "6587235ae6a6911b91d412f8029ee7f9674943e5140c407da9e08c9cf720ebd4", + "size": 318378, + "subdir": "linux-64", + "timestamp": 1536072518913, + "version": "3.7.4" + }, + "pytest-3.7.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "67fa83cf04879b4264783538e316b89b", + "name": "pytest", + "sha256": "f2eeacdc20345ea74c330af3b81dfa745fa1ee243d504a4081c1c3b26beb67ad", + "size": 317567, + "subdir": "linux-64", + "timestamp": 1536072422223, + "version": "3.7.4" + }, + "pytest-3.7.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "c836274e451543493e080f2553dfdc8b", + "name": "pytest", + "sha256": "efd01003dd8db546e1296651c6e7cb6f901d9e38b17ae699a99def4d4669ff1a", + "size": 316364, + "subdir": "linux-64", + "timestamp": 1536072535242, + "version": "3.7.4" + }, + "pytest-3.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "b749ea687e41eefb8bdcf2fa2c27b8b5", + "name": "pytest", + "sha256": "964062c0ae1b9da5b6a615664e63cb20bcaa4ae4fc71ad3a9367ac402400a320", + "size": 315747, + "subdir": "linux-64", + "timestamp": 1536696876208, + "version": "3.8.0" + }, + "pytest-3.8.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "6d53a1521afbc19bd73e6e50a3d19b3d", + "name": "pytest", + "sha256": "ea24c36fbe3517546c3e893e6121ea35e93c323f0f8cc392a83e2f799a980a27", + "size": 323549, + "subdir": "linux-64", + "timestamp": 1536696896481, + "version": "3.8.0" + }, + "pytest-3.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "ca5a4179a9ab7bf5ff6f2c3b1de33a35", + "name": "pytest", + "sha256": "d9f0c7bc87758fe64b9f1fd32ef129493089045f6575c931597aeec098c7d2a8", + "size": 324230, + "subdir": "linux-64", + "timestamp": 1536696926927, + "version": "3.8.0" + }, + "pytest-3.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "83e5724a1fba37232d2021e2d3a3f79a", + "name": "pytest", + "sha256": "482c834ea7de7704ea20771fcc23b2381eb268c81f826ed139007ab50fd5ecca", + "size": 324592, + "subdir": "linux-64", + "timestamp": 1536696852762, + "version": "3.8.0" + }, + "pytest-3.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "60301a614c03734cfa0d79317937654b", + "name": "pytest", + "sha256": "f3a6b6cd3cd480dc898b0cbab366810e5b8b107506562cf0227198cf5650942d", + "size": 317212, + "subdir": "linux-64", + "timestamp": 1538151932806, + "version": "3.8.1" + }, + "pytest-3.8.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "4988523e09d7ed3957ce4a60d286bc2f", + "name": "pytest", + "sha256": "339fa673410eb87bd83c8bc240bc442265819be5134a3605e8a77a8f9b366a55", + "size": 324030, + "subdir": "linux-64", + "timestamp": 1538151994761, + "version": "3.8.1" + }, + "pytest-3.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "aa7f97bbe1ee0d861bb238c9f09f8b08", + "name": "pytest", + "sha256": "5d9ce559ea43d94956faa5c216c0cab563e102c86ec91141585e6711e4ebca52", + "size": 325242, + "subdir": "linux-64", + "timestamp": 1538151975780, + "version": "3.8.1" + }, + "pytest-3.8.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "6239b9eae22a552dde06a09b382ba27e", + "name": "pytest", + "sha256": "6c37008f32863fd4a24b71d61c331896756e71cdc8a9b1a15124a98b5c5c2232", + "size": 325627, + "subdir": "linux-64", + "timestamp": 1538151934307, + "version": "3.8.1" + }, + "pytest-3.8.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "39063db615e41af1968da3bab71990ce", + "name": "pytest", + "sha256": "4b730bd1161e37407ee1eb9abf29ccbdd9ba3248eb3e3bb7ba5e23400d5811a4", + "size": 328976, + "subdir": "linux-64", + "timestamp": 1538866921966, + "version": "3.8.2" + }, + "pytest-3.8.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "d9c7bacb34177b233dd2b2686490c52c", + "name": "pytest", + "sha256": "3aac62efa64769967c45f3a0cec4a5cc5977fca7b6ea67c0b940ad501ecee27e", + "size": 330166, + "subdir": "linux-64", + "timestamp": 1538866948616, + "version": "3.8.2" + }, + "pytest-3.8.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "addd6fa246f2b20e22c6ae2be5066bd5", + "name": "pytest", + "sha256": "a14eec8f2fa532559a1e5e1f9b168260262925f65c8558ac9a8562b8ab100616", + "size": 335458, + "subdir": "linux-64", + "timestamp": 1538866924297, + "version": "3.8.2" + }, + "pytest-3.9.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "d595503a7b58d78a27675a2a15d5a8f5", + "name": "pytest", + "sha256": "e59eed69b2f33931216f15eb594412e142910609cdf8e5c00384a7d6cb4faf3a", + "size": 324153, + "subdir": "linux-64", + "timestamp": 1540230084517, + "version": "3.9.1" + }, + "pytest-3.9.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "4cc61f5ae82f8fa743197e1920c91a6e", + "name": "pytest", + "sha256": "b9e335d8ea14bb9d5d8fa08019172f0a13817774caa38725e2c88526e1ebf3af", + "size": 331177, + "subdir": "linux-64", + "timestamp": 1540230111741, + "version": "3.9.1" + }, + "pytest-3.9.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "c8f8f99daa75c88c38e90a4830e9a347", + "name": "pytest", + "sha256": "3a5040923727f5315abaa34cb11f947f431b4f30a4691dbb30e0ef55909895fb", + "size": 331464, + "subdir": "linux-64", + "timestamp": 1540230099639, + "version": "3.9.1" + }, + "pytest-3.9.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "52cf083b685966767fc1bb46351f62e3", + "name": "pytest", + "sha256": "0c8ac922ee0ba3856f94e93c6da3cc11270e8bb05f2bd75e793c21a19875f65d", + "size": 335714, + "subdir": "linux-64", + "timestamp": 1541035610840, + "version": "3.9.3" + }, + "pytest-3.9.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "5de415b57c5623ff0109b1be1d746a4b", + "name": "pytest", + "sha256": "44a3886fdb0eaca2572329fabc3d97fcd3594dad36d40932c176484dcf97af22", + "size": 338299, + "subdir": "linux-64", + "timestamp": 1541035593432, + "version": "3.9.3" + }, + "pytest-3.9.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "ab1ecd5a9b922ad7328cd0fa2b516379", + "name": "pytest", + "sha256": "67a64c73864796084bf3c8e876635888d011796c8817927f982a70efaa93f296", + "size": 344018, + "subdir": "linux-64", + "timestamp": 1541035600527, + "version": "3.9.3" + }, + "pytest-4.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "a83323984def841431d172b24cd27fb7", + "name": "pytest", + "sha256": "973195c8a31e1e8d10a165c9733e38e9f3de1b9524872d5bbcfa5b0a46b0a5e6", + "size": 341802, + "subdir": "linux-64", + "timestamp": 1542390848128, + "version": "4.0.0" + }, + "pytest-4.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "6ebefd1542f08e15a91b62edb089d73d", + "name": "pytest", + "sha256": "f120dda9b007d7777989b40e9580e074caabd492529c25aff2246bf89d7f29c2", + "size": 342589, + "subdir": "linux-64", + "timestamp": 1542390851335, + "version": "4.0.0" + }, + "pytest-4.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "fc2e8252c55be1a9f2b55171247f19d3", + "name": "pytest", + "sha256": "886de47e803ed3926ac269bd7c1e9e9b5850eead8adab3ba78686bba57c6b433", + "size": 342850, + "subdir": "linux-64", + "timestamp": 1542390843554, + "version": "4.0.0" + }, + "pytest-4.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "b503d5153af24d5acfd4e732dbac81ad", + "name": "pytest", + "sha256": "d1758bcf6d870d25330ad223975039d0598ee1f3c3ebc3842ce89074f015195c", + "size": 348568, + "subdir": "linux-64", + "timestamp": 1543609539562, + "version": "4.0.1" + }, + "pytest-4.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "5d5705496d4a98ff15c5c6572ea84ae3", + "name": "pytest", + "sha256": "4ea7ba8e3ea118a55c4077034b38a542bc8c04027dbea52a2ebcfd88d565bef7", + "size": 356493, + "subdir": "linux-64", + "timestamp": 1543609509343, + "version": "4.0.1" + }, + "pytest-4.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "ad0be18cc809af03d4b48eeb728ff6f5", + "name": "pytest", + "sha256": "c6da40f0c13ca6f009a76d62ddcff1975df119240120f96ef997b342ad301a9c", + "size": 356552, + "subdir": "linux-64", + "timestamp": 1543609469952, + "version": "4.0.1" + }, + "pytest-4.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "8f351c26a7b3c3a0d494340f8fc50604", + "name": "pytest", + "sha256": "81035b3bbb90a31b0f0a2a29ac55155b79c7cbb3734a20bc3d422f079257048d", + "size": 340359, + "subdir": "linux-64", + "timestamp": 1545073220251, + "version": "4.0.2" + }, + "pytest-4.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "a77d27cc9c643198a06a63705002ce69", + "name": "pytest", + "sha256": "2fa73cf2e6c0f9e45402de83150eb846f7606d53b9b4a4c5c701c24c33bc60fb", + "size": 343028, + "subdir": "linux-64", + "timestamp": 1545073252648, + "version": "4.0.2" + }, + "pytest-4.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "dfde84c43c2a090fbcdd7f3b3faadfff", + "name": "pytest", + "sha256": "8afa9382b78e07e20706d949c1ebbb87c7c2d46bf41f7aa32dd65b4983ddd61b", + "size": 343236, + "subdir": "linux-64", + "timestamp": 1545073238987, + "version": "4.0.2" + }, + "pytest-4.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "12565ff7f9e44991974bda54a819a1b0", + "name": "pytest", + "sha256": "7476da9d755ff02d6d0803400597e85f3ace772d157564ae973ba7e82d181781", + "size": 347078, + "subdir": "linux-64", + "timestamp": 1547476469341, + "version": "4.1.0" + }, + "pytest-4.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "5073d0704e79c13776091473495d27b0", + "name": "pytest", + "sha256": "91b85d269f6f2db81984783753bbc1609fb6a64e769f7a201d26833ced49ccde", + "size": 352956, + "subdir": "linux-64", + "timestamp": 1547476512018, + "version": "4.1.0" + }, + "pytest-4.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "a9fad825ce764920a8f6d0e89b48f6ff", + "name": "pytest", + "sha256": "dd713eb29e2c78fe49d50c614c8734c9c6eb01650e0c2ef9e300635b03a6e3c8", + "size": 353204, + "subdir": "linux-64", + "timestamp": 1547476491586, + "version": "4.1.0" + }, + "pytest-4.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "a765182225ad1e68c22b14d17895400c", + "name": "pytest", + "sha256": "18f39cbaa78ca43688b23383b2e77f6acccef6ccd322c6c8e334abfef8d45571", + "size": 345857, + "subdir": "linux-64", + "timestamp": 1547905255484, + "version": "4.1.1" + }, + "pytest-4.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "96fff55c97e482fbacc0c8937707d5c0", + "name": "pytest", + "sha256": "d75b558eb7d2bda94c093ff932de0fcfc0379dd8954e1cdc5e4be5d680b6e6a8", + "size": 349558, + "subdir": "linux-64", + "timestamp": 1547905304389, + "version": "4.1.1" + }, + "pytest-4.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "9cc1f449015795866c010d4b6f2ec05f", + "name": "pytest", + "sha256": "17987f0a1d5cd57b1144021d6063d6fb659c5cdec014fe7c05f9faaf91389e9c", + "size": 348870, + "subdir": "linux-64", + "timestamp": 1547904824482, + "version": "4.1.1" + }, + "pytest-4.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "c2795bf3da285ec076851ab229803a47", + "name": "pytest", + "sha256": "34e147b09018c7d1246c7293d1bd9c1c419257a688ade3a9df792d851b06cad9", + "size": 341209, + "subdir": "linux-64", + "timestamp": 1549322996784, + "version": "4.2.0" + }, + "pytest-4.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "9a1d205d1ea1e498ec1626353d868d4c", + "name": "pytest", + "sha256": "8fa27526a0430cca7b6f71afde9206bb18870a08302c33a783f3e0ad18ee5e1a", + "size": 349412, + "subdir": "linux-64", + "timestamp": 1549323037194, + "version": "4.2.0" + }, + "pytest-4.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "f5b0c1dd7702b84055bfe15531e3e1fb", + "name": "pytest", + "sha256": "2bad6fd1e2496c36d86a11464a72f8551a428492fdaec1684c7ed85a2c5eedb6", + "size": 349192, + "subdir": "linux-64", + "timestamp": 1549322981019, + "version": "4.2.0" + }, + "pytest-4.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "553a6c16384928cf07e5d12d0185e472", + "name": "pytest", + "sha256": "a5fa68b6dd8b19209fa12235f408b617d40113b385bf264e7a368c6d13917d50", + "size": 352531, + "subdir": "linux-64", + "timestamp": 1550354944773, + "version": "4.2.1" + }, + "pytest-4.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "2bb7a2542a2ee498ecdf021b0a942f28", + "name": "pytest", + "sha256": "074a840fe16763cf8aa6806087cd85c1d791fe1c347b4176233a669ddf594b46", + "size": 358519, + "subdir": "linux-64", + "timestamp": 1550354969951, + "version": "4.2.1" + }, + "pytest-4.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "9fb473ada92d754d3cac1e4bba250f15", + "name": "pytest", + "sha256": "1d8fc3eb7abb4dabfacc2ad9c99035dc62c8b678ca7530d10a8f0e9313f57ca8", + "size": 355355, + "subdir": "linux-64", + "timestamp": 1550354892131, + "version": "4.2.1" + }, + "pytest-4.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "more-itertools >=4.0,<6.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "81010d8f636832163bd645fc0dd92244", + "name": "pytest", + "sha256": "851a3832f118638dc36f6d645f42e4239f20cea8d1ee6b5d475b4b048fbc5f17", + "size": 354430, + "subdir": "linux-64", + "timestamp": 1551146952503, + "version": "4.3.0" + }, + "pytest-4.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "5862459fac6c6f892c77ec82b5b040d1", + "name": "pytest", + "sha256": "bc0ecdc09938e94d9c4c4959b892a78022cee96ddce243bc4ad30521558f202f", + "size": 360486, + "subdir": "linux-64", + "timestamp": 1551146972362, + "version": "4.3.0" + }, + "pytest-4.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "604ddb49aac8b4ed1ae1fc9612ec4946", + "name": "pytest", + "sha256": "6c4d9b329be00573c20f343b66fbc3822f58bb0b9c4937b4679f1c2542a92f51", + "size": 356903, + "subdir": "linux-64", + "timestamp": 1551146946468, + "version": "4.3.0" + }, + "pytest-4.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "more-itertools >=4.0,<6.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "857a86082b2affae3076b01cce5c013a", + "name": "pytest", + "sha256": "3670b41d61b4ad9d91e6a535bc3373255b919839c8f9abb889cd250b4b7a3151", + "size": 354064, + "subdir": "linux-64", + "timestamp": 1552926736533, + "version": "4.3.1" + }, + "pytest-4.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "61474d35e0115d8584d997a22b6677f2", + "name": "pytest", + "sha256": "a00d4ced2479afc121abebdc04f62706f800491860d84aefc9d0c151befd820d", + "size": 361065, + "subdir": "linux-64", + "timestamp": 1552926773068, + "version": "4.3.1" + }, + "pytest-4.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "9dfe114618630347953b68a541029870", + "name": "pytest", + "sha256": "2bfa3cecfb026c4db840bc90b30c7ca0ee063d70b3c55e3357be691fe5d995f0", + "size": 357057, + "subdir": "linux-64", + "timestamp": 1552926652317, + "version": "4.3.1" + }, + "pytest-4.4.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs >=1.0", + "more-itertools >=4.0", + "more-itertools >=4.0,<6.0", + "pathlib2 >=2.2.0", + "pluggy >=0.9", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "564da7694f204449eeab395b0913bb6c", + "name": "pytest", + "sha256": "4a56e9e405f7f2ccc44a03eede60fb9b3dd9e2fd108472f53d92c866fc3855a6", + "size": 359018, + "subdir": "linux-64", + "timestamp": 1555084777159, + "version": "4.4.0" + }, + "pytest-4.4.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.9", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "2e65553450936b97effcddbbb8118641", + "name": "pytest", + "sha256": "083560ddb5d3c2b9773f588d074aa5e53a2ccedffb4a3b54614f4d91298884c3", + "size": 367128, + "subdir": "linux-64", + "timestamp": 1555084787120, + "version": "4.4.0" + }, + "pytest-4.4.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.9", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "386172eeb3335421efccd6ed8f0077c5", + "name": "pytest", + "sha256": "503f9131b2bb02def8049ab05dc03f1c9c5946c958a61bdac28d46922f5a08e5", + "size": 367499, + "subdir": "linux-64", + "timestamp": 1555084762668, + "version": "4.4.0" + }, + "pytest-4.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs >=1.0", + "more-itertools >=4.0", + "more-itertools >=4.0,<6.0", + "pathlib2 >=2.2.0", + "pluggy >=0.9", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "2ba537c02b650742cfae6386381caf46", + "name": "pytest", + "sha256": "0393086423b292e91c33731693f58624c79b69dca25730c4d006a759667e33ec", + "size": 359342, + "subdir": "linux-64", + "timestamp": 1555950341360, + "version": "4.4.1" + }, + "pytest-4.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.9", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "296db4f620744d1a2207abb0514af273", + "name": "pytest", + "sha256": "342557e69fd128ce939588d806bc1c13c721e88ea7cdfd5a9bb0a36ff7d3d92d", + "size": 362068, + "subdir": "linux-64", + "timestamp": 1555950343429, + "version": "4.4.1" + }, + "pytest-4.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.9", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "eb3ec73ad424b2ccf76b73ae80fc365f", + "name": "pytest", + "sha256": "8c368467f4ed25d4b78adaee8d89a65226055911719863498f6c44d443f178c2", + "size": 364448, + "subdir": "linux-64", + "timestamp": 1555950329949, + "version": "4.4.1" + }, + "pytest-4.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs >=1.0", + "more-itertools >=4.0", + "more-itertools >=4.0,<6.0", + "pathlib2 >=2.2.0", + "pluggy >=0.9", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "3d76bc09a07625d2e6bc758398e7f496", + "name": "pytest", + "sha256": "0e27f4789e050cd05fc10e897c7db6f95d138ee8f9cef75889ed937b4607b5ce", + "size": 358799, + "subdir": "linux-64", + "timestamp": 1557502971221, + "version": "4.4.2" + }, + "pytest-4.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.9", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "174fc92c153c04c33500b622f96a4d40", + "name": "pytest", + "sha256": "48c454c2fc0412b64572296a1010e6ac0323e1f4c309853f76f5d783f47aad70", + "size": 368336, + "subdir": "linux-64", + "timestamp": 1557502983700, + "version": "4.4.2" + }, + "pytest-4.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.9", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "60c2dc8f99ca0eddeef2af46422fb2ca", + "name": "pytest", + "sha256": "99b50e4ee6d354137ef24fcc303f1f69295208dc873f969b64ff4e01ddeb79e4", + "size": 367192, + "subdir": "linux-64", + "timestamp": 1557502917168, + "version": "4.4.2" + }, + "pytest-4.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs >=1.0", + "more-itertools >=4.0", + "more-itertools >=4.0,<6.0", + "pathlib2 >=2.2.0", + "pluggy >=0.9,!=0.10,<1.0", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0", + "wcwidth" + ], + "license": "MIT", + "md5": "ac468581d0083d1db9b92b08318029fb", + "name": "pytest", + "sha256": "b30c245f5df23862a1c692f87d6765df4aae434082294ac5090e5144e58e63c0", + "size": 366354, + "subdir": "linux-64", + "timestamp": 1557856610358, + "version": "4.5.0" + }, + "pytest-4.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.9,!=0.10,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0", + "wcwidth" + ], + "license": "MIT", + "md5": "d0fd927d659114bab01736f3c6c2a3ba", + "name": "pytest", + "sha256": "22d684fa1015b422e2cb84b010529a7c8c154a989f04376f8f21c8188fbbde34", + "size": 367775, + "subdir": "linux-64", + "timestamp": 1557856674188, + "version": "4.5.0" + }, + "pytest-4.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.9,!=0.10,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0", + "wcwidth" + ], + "license": "MIT", + "md5": "5738dc426ba5c006e0ad43761da030b5", + "name": "pytest", + "sha256": "dd32ea14a68e91a06ebb4cd35a54820fc0d4638e3e7a4dde1296bcb27efc6628", + "size": 372748, + "subdir": "linux-64", + "timestamp": 1557856645702, + "version": "4.5.0" + }, + "pytest-4.6.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0", + "wcwidth" + ], + "license": "MIT", + "md5": "eec78c5734f71dc0b61fee6444db0f8a", + "name": "pytest", + "sha256": "8540cad68f17ed2bbdaf24cbd282fef674c3470227418b7076e81d8c85eb1ccf", + "size": 376225, + "subdir": "linux-64", + "timestamp": 1594257241668, + "version": "4.6.11" + }, + "pytest-4.6.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0", + "wcwidth" + ], + "license": "MIT", + "md5": "3593e926b2812e7435e46ce0d74df08f", + "name": "pytest", + "sha256": "4736583261461eb10d8a4f3fd3b35e1fa1fc0460e9fa787a753a912d042415c3", + "size": 376182, + "subdir": "linux-64", + "timestamp": 1594257270739, + "version": "4.6.11" + }, + "pytest-4.6.11-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "six >=1.10.0", + "wcwidth" + ], + "license": "MIT", + "md5": "b21256d1377cc8f0e0717c2585fb4852", + "name": "pytest", + "sha256": "44db4eb3244dd0149ef36c0275597cfe3db275f3f08c6cc42fe6871ece8f3f45", + "size": 380683, + "subdir": "linux-64", + "timestamp": 1594257244479, + "version": "4.6.11" + }, + "pytest-4.6.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs >=1.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "more-itertools >=4.0,<6.0", + "packaging", + "pathlib2 >=2.2.0", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0", + "wcwidth" + ], + "license": "MIT", + "md5": "6bd8366c179c147f8deea1ab77829d77", + "name": "pytest", + "sha256": "cfa9ab5b9393f7e1e72260bc5408577bde53617cbc36e913cec5e9b617b17c1d", + "size": 367082, + "subdir": "linux-64", + "timestamp": 1559660004887, + "version": "4.6.2" + }, + "pytest-4.6.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0", + "wcwidth" + ], + "license": "MIT", + "md5": "c00ba1b9cf5398dcce9c77f81f594c6f", + "name": "pytest", + "sha256": "f86c4cf84d670a5490b19b58081a7e4fea4ba651f3aeec7f1b9b658f65f5255e", + "size": 376531, + "subdir": "linux-64", + "timestamp": 1559660037414, + "version": "4.6.2" + }, + "pytest-4.6.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0", + "wcwidth" + ], + "license": "MIT", + "md5": "e901825b0557f19d77010d84c139db22", + "name": "pytest", + "sha256": "63556a9f337f6ca8fb106825ebef6c3d2d200c288f0e9c09ced4430e9982d084", + "size": 375081, + "subdir": "linux-64", + "timestamp": 1559660016271, + "version": "4.6.2" + }, + "pytest-5.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "7885348ffc9ce021632e39ac340f1657", + "name": "pytest", + "sha256": "a0dbaa91815d2194765c241363050d1de591fd9f0a6e95f9065cffefed5f1802", + "size": 363925, + "subdir": "linux-64", + "timestamp": 1562078849023, + "version": "5.0.0" + }, + "pytest-5.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "b864f86862c5e39c8292c08c438c4301", + "name": "pytest", + "sha256": "80370d887f5504c84bf2e4b7ecf7dad7cad929347e63597994bf825fc38cc1f2", + "size": 364165, + "subdir": "linux-64", + "timestamp": 1562078540913, + "version": "5.0.0" + }, + "pytest-5.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "2032817b55da02c41941c7a0d2c0a72d", + "name": "pytest", + "sha256": "85129ba52e83afd55b415c22d0f0f94c3e1621ccfc09c10bbf8376ba0924eebc", + "size": 367629, + "subdir": "linux-64", + "timestamp": 1594255673564, + "version": "5.0.0" + }, + "pytest-5.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "1d5978560a424eebd7c32928e2f243f0", + "name": "pytest", + "sha256": "79ead063f5651d69b95c4f532b8a4fcf4c8b0e85072a8fd09b89fe2aae102ac7", + "size": 361827, + "subdir": "linux-64", + "timestamp": 1563206731269, + "version": "5.0.1" + }, + "pytest-5.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "5cee757e86e98ffac986297d831b082b", + "name": "pytest", + "sha256": "587d487221fcb4d769fc631692665123f7a6a340127ece0a98b352deb5598f4a", + "size": 364242, + "subdir": "linux-64", + "timestamp": 1563206730572, + "version": "5.0.1" + }, + "pytest-5.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "1cb3851d7c2e74fff13729c5b1fa6c14", + "name": "pytest", + "sha256": "8aab8d6b09c15f2c4acb05564a9360e0d34c471dcd2734046d798d31f936218d", + "size": 371476, + "subdir": "linux-64", + "timestamp": 1569264129454, + "version": "5.1.2" + }, + "pytest-5.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "657596c09dd9699c69969eadb7bfb9c2", + "name": "pytest", + "sha256": "31a4fd86cd895644b3928d4eaf864ca0a868b80ef45069d123fd59fcee54416d", + "size": 371812, + "subdir": "linux-64", + "timestamp": 1569264120783, + "version": "5.1.2" + }, + "pytest-5.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "61e361fa6c6808646892d76b96c567e6", + "name": "pytest", + "sha256": "1df6c75440f86aadec373362c18c05dbf3acb98c9338c5e858b91f16dd7a7e98", + "size": 369871, + "subdir": "linux-64", + "timestamp": 1569854916207, + "version": "5.2.0" + }, + "pytest-5.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "cecea855ad8c0403710be367e4e8ce73", + "name": "pytest", + "sha256": "15fe74d41ed64c6acd368d04bdee8f60e3f0e8dd34f1314f5428aa9d94379c5c", + "size": 374834, + "subdir": "linux-64", + "timestamp": 1569854920216, + "version": "5.2.0" + }, + "pytest-5.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "6d5d1ee1034ae082d11c73e101900765", + "name": "pytest", + "sha256": "33f94477714232326c4ec76b02f4067d990702debf90790d3bba6e5a0c31bbef", + "size": 375187, + "subdir": "linux-64", + "timestamp": 1570463198594, + "version": "5.2.1" + }, + "pytest-5.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "76bee9ea5e129cb10be2332ffcb6af15", + "name": "pytest", + "sha256": "b8ad6e939cc1f17ec249bd23577aef5c44ddec720209bb6ccee9877032973285", + "size": 372458, + "subdir": "linux-64", + "timestamp": 1570463211692, + "version": "5.2.1" + }, + "pytest-5.2.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "538721ccbcb544532912e556e838f7c2", + "name": "pytest", + "sha256": "f3d462502c052da49bc513a681c086020695eb051e0ac8e826ea01d15d3defea", + "size": 361099, + "subdir": "linux-64", + "timestamp": 1572609251263, + "version": "5.2.1" + }, + "pytest-5.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "00ec34ad8d6280917b07c6dc14247556", + "name": "pytest", + "sha256": "a86da60c8477421df2ae0d738bac433d4a82d223170008486adfa88cbe30e00d", + "size": 370829, + "subdir": "linux-64", + "timestamp": 1572457266932, + "version": "5.2.2" + }, + "pytest-5.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "4b05475c0ada0094b746f17570bab6f0", + "name": "pytest", + "sha256": "cab8acf4836de1531fa19aed8c9682bdf2961ba4bc19460b19935403f6be6a9c", + "size": 373462, + "subdir": "linux-64", + "timestamp": 1572457239063, + "version": "5.2.2" + }, + "pytest-5.2.4-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pathlib2 >=2.2.0", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "74ea923f8af9f4a72118cf6c9043f65f", + "name": "pytest", + "sha256": "09ab7d78a06f8f765e1dbf430668a3cef0d4b29e8644f0888aa8db8aaedbae85", + "size": 374037, + "subdir": "linux-64", + "timestamp": 1573941489484, + "version": "5.2.4" + }, + "pytest-5.2.4-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pathlib2 >=2.2.0", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "0e4281c9c980e63062a7f44858f42fe1", + "name": "pytest", + "sha256": "dc7b08242f00fb74c12714f5330298e7c44f0341992587f5d20ed7d0d071bd98", + "size": 371623, + "subdir": "linux-64", + "timestamp": 1573941474066, + "version": "5.2.4" + }, + "pytest-5.2.4-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "cb276c000ce86aed3536decf9aa27f0f", + "name": "pytest", + "sha256": "9cffe4abc3a512092e79260a76846bf4fab13ebea2e0b049c05f769c9f55173e", + "size": 378567, + "subdir": "linux-64", + "timestamp": 1573941483335, + "version": "5.2.4" + }, + "pytest-5.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "31df82f9e0ec27252063a65adfa2362a", + "name": "pytest", + "sha256": "17ffde9f83a6f9d02fe8bc5ca96a7a27bf8eb76a57b9baf8760cb06e1d19655a", + "size": 386763, + "subdir": "linux-64", + "timestamp": 1574699106650, + "version": "5.3.0" + }, + "pytest-5.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "8dee33bfc33bda59af03cb2a275480bf", + "name": "pytest", + "sha256": "bdc367477c9e35897dd1c9918515215891aa7353b5584be2af54ebe10b431a13", + "size": 388550, + "subdir": "linux-64", + "timestamp": 1574699079802, + "version": "5.3.0" + }, + "pytest-5.3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "366e09bdb4b13fdb8b24f066c016b1e5", + "name": "pytest", + "sha256": "747139d309852fa8ba5ea835018a46394d8d0940c75eced74a9190be01626830", + "size": 389260, + "subdir": "linux-64", + "timestamp": 1574699169471, + "version": "5.3.0" + }, + "pytest-5.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "97b213a9b98fe3c0ee509288ff246674", + "name": "pytest", + "sha256": "bee929ea36e5de0980a88c12cf75683adc21f9f7bb6f20e0be6c0b3c60bc744b", + "size": 386687, + "subdir": "linux-64", + "timestamp": 1575390373668, + "version": "5.3.1" + }, + "pytest-5.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "982772b55f564e37d40cec5827e5212d", + "name": "pytest", + "sha256": "e9a4387f6749030de053890e037dbb86fe3fba88ceff18889217366a3d6068e2", + "size": 387724, + "subdir": "linux-64", + "timestamp": 1575390318722, + "version": "5.3.1" + }, + "pytest-5.3.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "82c59de35a15e2c8330d794cdd05ce2c", + "name": "pytest", + "sha256": "93a69a66be38e10869dad546177f14371cf503e4bdb54df3940bc7b677ac3c5e", + "size": 386296, + "subdir": "linux-64", + "timestamp": 1575390410985, + "version": "5.3.1" + }, + "pytest-5.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "2baaaa1290dfc1b83ab2cd45e55ff077", + "name": "pytest", + "sha256": "b9ac747eaf9377f4b9e2d5dc8bdbc585bc47b567671c21d6d867e82ca8bfc949", + "size": 386804, + "subdir": "linux-64", + "timestamp": 1576512420466, + "version": "5.3.2" + }, + "pytest-5.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "1702ec68882934156f5dd45c1faf71ab", + "name": "pytest", + "sha256": "69f77f39571fdc3ff40b0d684009cc737c34250d18b0332ac74313af7ec0ceaf", + "size": 384749, + "subdir": "linux-64", + "timestamp": 1576512367394, + "version": "5.3.2" + }, + "pytest-5.3.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "0ef04b7274da5989d95a4360ab360263", + "name": "pytest", + "sha256": "2ccf9d0071255d4132ccf7cd6adbcca9dcc9979d1337fd2408ae0337ce6bfe46", + "size": 388147, + "subdir": "linux-64", + "timestamp": 1576512422153, + "version": "5.3.2" + }, + "pytest-5.3.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "020573a7454f2cc64e1b9e263a46ef7c", + "name": "pytest", + "sha256": "4ac55f3e473c573cbe8786d6d832d970334f8bcbd30ce053c2090a8d447f8cb0", + "size": 391702, + "subdir": "linux-64", + "timestamp": 1580150799644, + "version": "5.3.4" + }, + "pytest-5.3.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "570166e5adb0c778662241bfb05ed54b", + "name": "pytest", + "sha256": "230b1fac0f0df199102dcf235544588bd0dd62dab731187059f58281d3ccc731", + "size": 391380, + "subdir": "linux-64", + "timestamp": 1580150781443, + "version": "5.3.4" + }, + "pytest-5.3.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "b9e656471f2282c40ed283b195dc1aae", + "name": "pytest", + "sha256": "f9b973efd4b5c59e240dc7950ca471bc893824e19a6b9fa1fc1931135868fb32", + "size": 390235, + "subdir": "linux-64", + "timestamp": 1580150782961, + "version": "5.3.4" + }, + "pytest-5.3.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "07755b8ae40adcd812c12d726b416e46", + "name": "pytest", + "sha256": "bd1e925d5157b7058e890359cfaaf0b74b8cb2814170b46cdd4843a3cf291a44", + "size": 389531, + "subdir": "linux-64", + "timestamp": 1580834472108, + "version": "5.3.5" + }, + "pytest-5.3.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "64963738e7731dd1bd67f7a1847a316a", + "name": "pytest", + "sha256": "d18436a9c4895ab100187f7f6b428a43ebb20f701a940f278c09c9ccbf572c99", + "size": 388896, + "subdir": "linux-64", + "timestamp": 1580834436620, + "version": "5.3.5" + }, + "pytest-5.3.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "ef3ddf85d74d1d98407bd62f10a5910e", + "name": "pytest", + "sha256": "8d06156a4a8572f3c9154082263dafaaefd2c49cfbfb179abf2ac2305be398ff", + "size": 389636, + "subdir": "linux-64", + "timestamp": 1580834469399, + "version": "5.3.5" + }, + "pytest-5.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "7cf87cee2efebed619e25300dbe53d61", + "name": "pytest", + "sha256": "08d5ca8c1d6d88a12ba01ef3d7d110284210af5d6b5cd6a69554cef1371896f7", + "size": 402744, + "subdir": "linux-64", + "timestamp": 1584457062473, + "version": "5.4.1" + }, + "pytest-5.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "87b0e4d041dd125fa0f997d0d68ab323", + "name": "pytest", + "sha256": "bed22963f964cc93803563b0b571eddafe999d3a47bf99765546d26656f1b3cb", + "size": 401270, + "subdir": "linux-64", + "timestamp": 1584457006510, + "version": "5.4.1" + }, + "pytest-5.4.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "e8fcf5edebf69008676b07c892f36604", + "name": "pytest", + "sha256": "aa9540f95d9dd18eaec2e3dd9974c22eabbc1b5953abaee01750014199e1a74c", + "size": 403864, + "subdir": "linux-64", + "timestamp": 1584457083580, + "version": "5.4.1" + }, + "pytest-5.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "888a54fc0d91b145ec4b4696c4a2187e", + "name": "pytest", + "sha256": "7e43c5008df1dd070276e5d3d98715acda20ae51f9c8da0bb0d70e804b60684c", + "size": 403427, + "subdir": "linux-64", + "timestamp": 1589495632781, + "version": "5.4.2" + }, + "pytest-5.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "065807ff084df4653d19f5c724ec07b7", + "name": "pytest", + "sha256": "6d53fe66cab63a76871a9ac455451d87427bf8be70484d41b2166f30a9db7917", + "size": 403176, + "subdir": "linux-64", + "timestamp": 1589495589496, + "version": "5.4.2" + }, + "pytest-5.4.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "f1bccf4f66d4b334e58c343217c6c2a6", + "name": "pytest", + "sha256": "e817c0ee37008e22a64452b3a9ef50dd5d5f8f4902778de1d57272fb29d8a9d2", + "size": 406182, + "subdir": "linux-64", + "timestamp": 1589495594123, + "version": "5.4.2" + }, + "pytest-5.4.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "ebccd91758f7ee4e12364471e2e4db1a", + "name": "pytest", + "sha256": "a9f5fe814f7434705fa70020bdad96d817d2c1ab024ce6d4907d0c41c2606957", + "size": 404469, + "subdir": "linux-64", + "timestamp": 1592322954043, + "version": "5.4.3" + }, + "pytest-5.4.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "c74674c52de1d83e85b161ef86f24636", + "name": "pytest", + "sha256": "a9dbb0281b5696d932eb709ed4cfe8d0963b02ac733916e6222c7c809881e12c", + "size": 405568, + "subdir": "linux-64", + "timestamp": 1605213691860, + "version": "5.4.3" + }, + "pytest-5.4.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "82f02abdd33d9373602f401dd00608d8", + "name": "pytest", + "sha256": "7d2ee71a910f0e6ff02ad56ecfd7248506e8d3db7ee4b421d97145d354cf1a52", + "size": 407553, + "subdir": "linux-64", + "timestamp": 1592322984624, + "version": "5.4.3" + }, + "pytest-5.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "e3fda1f4671cde4608d4ed6e001a793e", + "name": "pytest", + "sha256": "f7722ebd3f51c8579f2f93d65e426e99ec32ab0ffaff8500e66f11e0c6ac521e", + "size": 404783, + "subdir": "linux-64", + "timestamp": 1605213677706, + "version": "5.4.3" + }, + "pytest-5.4.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "1dc3472ae5fb12ee7d35d82f9fa7d9fa", + "name": "pytest", + "sha256": "13cbab87a7cd36551dc609a2315f54d5ba3822ef1ce463c3ef75d891a9928bb7", + "size": 406344, + "subdir": "linux-64", + "timestamp": 1592322958800, + "version": "5.4.3" + }, + "pytest-5.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "eba917e3f57b2f1a0024f696b65fd01b", + "name": "pytest", + "sha256": "1b7950ef986b3bab32bef94dfc383b59dd28f3604e0a59faf77eac90e68a6ab0", + "size": 407665, + "subdir": "linux-64", + "timestamp": 1605213719053, + "version": "5.4.3" + }, + "pytest-5.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.9,<3.10.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "22c11d915ad9457e2eb3bf57dea95cc4", + "name": "pytest", + "sha256": "fe54141878c656e2104a1b97941ded85c2ec5d2c5e679e678423b7f9255b2b86", + "size": 409806, + "subdir": "linux-64", + "timestamp": 1605213693526, + "version": "5.4.3" + }, + "pytest-6.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "6198e3179150c61c05e75269b193727e", + "name": "pytest", + "sha256": "1254b8dcaab756317622d63d484cdf869347a4574da9bb329161e5636084aede", + "size": 439667, + "subdir": "linux-64", + "timestamp": 1596838663879, + "version": "6.0.1" + }, + "pytest-6.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "9fb912c9eeb905ca50663d78ae3daf24", + "name": "pytest", + "sha256": "b35cf9e6976298a36fe70a063daa561ca2c96649517e975aa389a7c86586f90f", + "size": 442899, + "subdir": "linux-64", + "timestamp": 1596838660986, + "version": "6.0.1" + }, + "pytest-6.0.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "6fb21d2679bf43afa7e2b116eedaa812", + "name": "pytest", + "sha256": "18e41bb7ab3ecc5ddeff57bdbbb0f487dd03c06982b6fb8635f8627b28cfab72", + "size": 444034, + "subdir": "linux-64", + "timestamp": 1596838638788, + "version": "6.0.1" + }, + "pytest-6.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "cb08dae80fc3b82c28f6e01d7f0a660c", + "name": "pytest", + "sha256": "f4977fc6d7059dd4875bdb32f721d44ca2b1060dd68ac9c78fd302b22bd908e7", + "size": 426493, + "subdir": "linux-64", + "timestamp": 1600278297253, + "version": "6.0.2" + }, + "pytest-6.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "5bae14a0bb0b2df2eb9f3e46f9bad41e", + "name": "pytest", + "sha256": "545212a323fd254c4ce67e215b0a965a5336c96991506a6cafa6a69bf8ea7e96", + "size": 425720, + "subdir": "linux-64", + "timestamp": 1600278332198, + "version": "6.0.2" + }, + "pytest-6.0.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "579a2ead9dc0457d056b94bff8c6882a", + "name": "pytest", + "sha256": "32e75d9b9d6c24974c607758b806574d9061fd105676ea5d28dffd741f33a9d0", + "size": 428772, + "subdir": "linux-64", + "timestamp": 1600278301742, + "version": "6.0.2" + }, + "pytest-6.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "5e2fdfd27645efde3c79af6b6e6c2386", + "name": "pytest", + "sha256": "66396c9932420a83f0bce1849510a136980c24662dab71d9225a94e7d3051c1a", + "size": 427236, + "subdir": "linux-64", + "timestamp": 1601657664463, + "version": "6.1.0" + }, + "pytest-6.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "c6d230a6b31a3f0910bfe14d77291f69", + "name": "pytest", + "sha256": "0c07bbb48fb6ae404e011d8f855ae3b42765a01a6da87fe4c38c935a39f22b73", + "size": 427734, + "subdir": "linux-64", + "timestamp": 1601657635000, + "version": "6.1.0" + }, + "pytest-6.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "2d6940278499912465ad074bdf48cbd8", + "name": "pytest", + "sha256": "4faa75f205fb2d257d97d61cb6c6ed992f34279d57d77533bc529a01e93ed474", + "size": 429563, + "subdir": "linux-64", + "timestamp": 1601657687093, + "version": "6.1.0" + }, + "pytest-6.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "0070ed4ef80c94f5b210bd38c7de6b63", + "name": "pytest", + "sha256": "65a24b53cc8b7b28ad75233520e5426dd0cf5740cebfa14b50856ba19a9c50e1", + "size": 426971, + "subdir": "linux-64", + "timestamp": 1602184471504, + "version": "6.1.1" + }, + "pytest-6.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "7b706fed57f83fbc2bcd9d8f35ed5be6", + "name": "pytest", + "sha256": "e25c15919a57a9cd54f498c599ce58babe88f2f1aeb1297edba1663e03b57d80", + "size": 427567, + "subdir": "linux-64", + "timestamp": 1602184471388, + "version": "6.1.1" + }, + "pytest-6.1.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "d0678f4969823f3449c9c7361e9550a8", + "name": "pytest", + "sha256": "5058c1466a4d267a8a5d3f0073118be52655a3bd9c6322e82abf0eaa5cb37c48", + "size": 429501, + "subdir": "linux-64", + "timestamp": 1602184471487, + "version": "6.1.1" + }, + "pytest-6.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "md5": "64ed0547af50395a82e4f4f50ca3ce6d", + "name": "pytest", + "sha256": "10f60c7dfc3ba0fe36c9297eec7677f591452c5b1bf1304bcceddb5ec4a300a7", + "size": 444265, + "subdir": "linux-64", + "timestamp": 1606832201488, + "version": "6.1.1" + }, + "pytest-6.1.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "e0f7df7b48c550f7191f360cd7d715b1", + "name": "pytest", + "sha256": "fab80734753fb9c1753078aa6d11f15fb211811b10c34ea5096d66a0bd9e580a", + "size": 427930, + "subdir": "linux-64", + "timestamp": 1606846768924, + "version": "6.1.2" + }, + "pytest-6.1.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "aa5400e79e76cdee24649dd451658c0d", + "name": "pytest", + "sha256": "a0cc99305ad58e8a423f2ce749bba0a201c28f41944560ba721cb982d72b31d9", + "size": 428775, + "subdir": "linux-64", + "timestamp": 1606846760187, + "version": "6.1.2" + }, + "pytest-6.1.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "2d6f6c9dda496946936c5ae73a01b667", + "name": "pytest", + "sha256": "206de02e8436f2b95a1c6c0904b779438c22704c82ad72e5208b1cfaf5e54722", + "size": 430943, + "subdir": "linux-64", + "timestamp": 1606846742497, + "version": "6.1.2" + }, + "pytest-6.1.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "md5": "1364af27e2e2820ac4ca55474fbca3bc", + "name": "pytest", + "sha256": "7ae869581ceb885042c944d770209d821bae331900afd172aaf7f0b8ed3e534b", + "size": 430774, + "subdir": "linux-64", + "timestamp": 1606846771925, + "version": "6.1.2" + }, + "pytest-6.2.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "fe6619b313e07ef191bd5e0e2dedb316", + "name": "pytest", + "sha256": "4e89560c2422318b8200325643a3058f0d821296c7e40814bb6b3a704669a60d", + "size": 440017, + "subdir": "linux-64", + "timestamp": 1607972301538, + "version": "6.2.0" + }, + "pytest-6.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "a70e63eee53a8bc4db93477373b5c635", + "name": "pytest", + "sha256": "853e0f53b1c3fa311c67cc7f1e05ee93a748a1f90cc0ee713abb7c42cceca277", + "size": 440683, + "subdir": "linux-64", + "timestamp": 1607972290045, + "version": "6.2.0" + }, + "pytest-6.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "0dd1628b74976bfd434f47f9de85827c", + "name": "pytest", + "sha256": "e90ecf700d2ca2d92c7e77c463fb13a3d25165447d30ea1cb1b4cc134768a45d", + "size": 442659, + "subdir": "linux-64", + "timestamp": 1607972302272, + "version": "6.2.0" + }, + "pytest-6.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "md5": "e14d4daa34c9a91c1583e10a99d5cd72", + "name": "pytest", + "sha256": "789de49be45eb6a8f821540a8be3d9522f933c2d41c339d76765470c07d70feb", + "size": 444180, + "subdir": "linux-64", + "timestamp": 1607972305013, + "version": "6.2.0" + }, + "pytest-6.2.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "fd2a76c4b7820122e188f4478f32f93c", + "name": "pytest", + "sha256": "7eb19c895acaca1533a521dbb7ef9a2615d2363e68dd39b2a3d8bf52fe629538", + "size": 440068, + "subdir": "linux-64", + "timestamp": 1608058132032, + "version": "6.2.1" + }, + "pytest-6.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "1cad9c00b28fa8eb249e1b12bce82ea0", + "name": "pytest", + "sha256": "f0bcedc9f0eb674fa7675171b00e4c4286787dd2fb1c601da91f9e65ebab53ef", + "size": 442025, + "subdir": "linux-64", + "timestamp": 1608058112351, + "version": "6.2.1" + }, + "pytest-6.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "48fed119e4f6bcdfa865b5712a7d2674", + "name": "pytest", + "sha256": "cdf321e2eb78b8b5f6724cd07255cd45eccf24cfdf47b3a2a4e8db193406e979", + "size": 442726, + "subdir": "linux-64", + "timestamp": 1608058148767, + "version": "6.2.1" + }, + "pytest-6.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "md5": "f5b91eac461a61185fa7bd23218a4f53", + "name": "pytest", + "sha256": "db17548fe787c0659d74246d50b39e3b294281655f3688dea3b277771df89edf", + "size": 443248, + "subdir": "linux-64", + "timestamp": 1608058134120, + "version": "6.2.1" + }, + "pytest-6.2.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "4f690e2436178a777d36410c9720596a", + "name": "pytest", + "sha256": "985f27bdb3af401e7fd6c5f742b114516ff79ea79004d9f7720e8f7a4d2bf3c5", + "size": 440281, + "subdir": "linux-64", + "timestamp": 1611693854222, + "version": "6.2.2" + }, + "pytest-6.2.2-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "697f7c7943438c679a7c211f5aa61724", + "name": "pytest", + "sha256": "351c3f31e0949582941a0e405fab3f091fd9f22cf0d7890969c90f2bf9cf296f", + "size": 461671, + "subdir": "linux-64", + "timestamp": 1611855270543, + "version": "6.2.2" + }, + "pytest-6.2.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "1431ad8e64301a2403839ea1803bbc11", + "name": "pytest", + "sha256": "aeb1ad18fe3b310b97ae3204c28c587af8c65891e589e772599ff097c9f38444", + "size": 442941, + "subdir": "linux-64", + "timestamp": 1611693844208, + "version": "6.2.2" + }, + "pytest-6.2.2-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "f3bf065d9d7a9f19dc82bdbef88c6aef", + "name": "pytest", + "sha256": "df34f04aa2057e291209fca6cbdfc54b2258275d9ca29831290c0d1c338f3db1", + "size": 463607, + "subdir": "linux-64", + "timestamp": 1611855304175, + "version": "6.2.2" + }, + "pytest-6.2.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "4c28463d4b687ed4c34b441cc33c2abb", + "name": "pytest", + "sha256": "d5b864bc3a7df65f8e8741a9f17da2f09c7d86c8571030f323656478d5c4c130", + "size": 442122, + "subdir": "linux-64", + "timestamp": 1611693819667, + "version": "6.2.2" + }, + "pytest-6.2.2-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "7a444cf92eb6102cd0e38a1f641889c7", + "name": "pytest", + "sha256": "03119fd3d78530a85d5d363dd19b6cdc403d37f5fd001ad54659df3c1c74e9a0", + "size": 465231, + "subdir": "linux-64", + "timestamp": 1611855301733, + "version": "6.2.2" + }, + "pytest-6.2.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "md5": "ab2d3f6cbc14431d9857f44d6fdf58f9", + "name": "pytest", + "sha256": "0b23e75f937c6975a81d2a697dedb71f79aba9b5b82f2a8d8869581156b231af", + "size": 444160, + "subdir": "linux-64", + "timestamp": 1611693840337, + "version": "6.2.2" + }, + "pytest-6.2.2-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "md5": "0d937f130462f1e37bd7398e72f08dfb", + "name": "pytest", + "sha256": "7a6d3519cb3840704bf80315682e2cd44de65f01688c188190591c9a05001f11", + "size": 458934, + "subdir": "linux-64", + "timestamp": 1611855303310, + "version": "6.2.2" + }, + "pytest-6.2.3-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "fddd192f0a1852fd47acfe846f294169", + "name": "pytest", + "sha256": "dd924f1e622d45d70796842f95d8adec2f183959675c78454e1212f03e0a98b8", + "size": 441616, + "subdir": "linux-64", + "timestamp": 1617569117137, + "version": "6.2.3" + }, + "pytest-6.2.3-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "ddb813f66b044bee372829ad0cd1be47", + "name": "pytest", + "sha256": "df3d7619d37d6fa5965a572e5a9bb5231277f01092ba04c5fa97cca395865863", + "size": 441513, + "subdir": "linux-64", + "timestamp": 1617569617604, + "version": "6.2.3" + }, + "pytest-6.2.3-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "7c539897dc949b01aa2447e3fc902389", + "name": "pytest", + "sha256": "2ec1aa4d74832d97d3298a0d77143b9c431d8f40e95dc8717c7e70c88fd044d0", + "size": 443966, + "subdir": "linux-64", + "timestamp": 1617569614994, + "version": "6.2.3" + }, + "pytest-6.2.3-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "md5": "1f30e7ac3d1ad5765c2a7e5332f62017", + "name": "pytest", + "sha256": "e68408495d7d7fe3daddb0b5c922dc171abb6cef2254342b49d976fd5c52f1e8", + "size": 443003, + "subdir": "linux-64", + "timestamp": 1617569616744, + "version": "6.2.3" + }, + "pytest-6.2.4-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.10,<3.11.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bcffd16361ae1393604e6022629bdbb0", + "name": "pytest", + "sha256": "4dc9f3eaf3f8adf4525709ae4485955b9d2b3f100a1d5b190c6655fc847cc0b7", + "size": 448590, + "subdir": "linux-64", + "timestamp": 1640793712353, + "version": "6.2.4" + }, + "pytest-6.2.4-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a99af42411a3b2948b0b3af8786d026c", + "name": "pytest", + "sha256": "e1d3c8d757947458c5001cf600dc5c967b49c57df65011f023076c8c2a200536", + "size": 440648, + "subdir": "linux-64", + "timestamp": 1623322016547, + "version": "6.2.4" + }, + "pytest-6.2.4-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0bbbafcd557dc2785d56c0203fee83b3", + "name": "pytest", + "sha256": "da3ed9c17b2e149ca8c97bdf2eb8c574d39606b4a75bd48c0e75b942638facf8", + "size": 442734, + "subdir": "linux-64", + "timestamp": 1623321968159, + "version": "6.2.4" + }, + "pytest-6.2.4-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b013da580eb539cf21d6a5bf2b968abd", + "name": "pytest", + "sha256": "8b664e018eda1fe531dd801334616eea993ab8d445686e482176c17de4024b86", + "size": 442716, + "subdir": "linux-64", + "timestamp": 1623321995693, + "version": "6.2.4" + }, + "pytest-6.2.4-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb9cd585f96676f5b4ccb3bff4dce146", + "name": "pytest", + "sha256": "5d10d5d10a04a71e52a72f99fc8048d88df976e94beb98be7fe5f53b5fdf53e6", + "size": 444002, + "subdir": "linux-64", + "timestamp": 1623322006098, + "version": "6.2.4" + }, + "pytest-6.2.5-py311h06a4308_3.tar.bz2": { + "build": "py311h06a4308_3", + "build_number": 3, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.11,<3.12.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a4f23f22da150bdb718ffa07f5e6fcc", + "name": "pytest", + "sha256": "12efd17d367e4647278fda1267f1825809a8b74693a1bd0edc0101e3a44bce42", + "size": 613516, + "subdir": "linux-64", + "timestamp": 1676822891783, + "version": "6.2.5" + }, + "pytest-6.2.5-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e2af65c4a9105c71842591a8fed462cd", + "name": "pytest", + "sha256": "8618f2e517505ff84db551a7ffbad39f18e31295508df8e95a6d61f7ad6748cc", + "size": 442930, + "subdir": "linux-64", + "timestamp": 1637677152135, + "version": "6.2.5" + }, + "pytest-6.2.5-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebbb6e92444d5be1f5abd81ca9f2f378", + "name": "pytest", + "sha256": "71df1fb057dc43c0201177880e9353423565beb6884e5b3845356f08e56de3e2", + "size": 444119, + "subdir": "linux-64", + "timestamp": 1637677204411, + "version": "6.2.5" + }, + "pytest-6.2.5-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ef0276833908722bcf7e9b490ec3394", + "name": "pytest", + "sha256": "fb4e0d40b17b916accfd6156042df11ed7946aa9f02978af4a32a3bd4bd5fb8e", + "size": 443877, + "subdir": "linux-64", + "timestamp": 1637677180596, + "version": "6.2.5" + }, + "pytest-7.1.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "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" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "213ff459ff1d88665603379389e07ca9", + "name": "pytest", + "sha256": "162ad094d39401aeb7567133db64e0413360d3c480d79b80e2f1f468cb914be7", + "size": 500239, + "subdir": "linux-64", + "timestamp": 1649048810463, + "version": "7.1.1" + }, + "pytest-7.1.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "tomli >=1.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b15e7dde88c9a131b40513f6b0cebadd", + "name": "pytest", + "sha256": "e5a2f20bda35d7e456285b3455bbb4c6b917d862ceb16e23cc3d8104dfec76e5", + "size": 483417, + "subdir": "linux-64", + "timestamp": 1649066920070, + "version": "7.1.1" + }, + "pytest-7.1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "tomli >=1.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85dad3f7a003b4ed7e955cc41b0ae110", + "name": "pytest", + "sha256": "4e47d6f124c4916c1399aabc464a1d8a82f5d80d60e15fd987e06ad9ce1521e2", + "size": 493395, + "subdir": "linux-64", + "timestamp": 1649049057963, + "version": "7.1.1" + }, + "pytest-7.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "tomli >=1.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8adf2271fad23508d70f145e833a5549", + "name": "pytest", + "sha256": "b82ab76172f6854c8f5d64a8d4677d51c76f2c8ab5c9cf6c2f739ad0e6f6b20a", + "size": 488372, + "subdir": "linux-64", + "timestamp": 1649066921124, + "version": "7.1.1" + }, + "pytest-7.1.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "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" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "97f5741745406fec23fb3839b22def48", + "name": "pytest", + "sha256": "f91c6853ac803695c5c92309cec4cc557ccc37e1f26c783ee85e06c1141fdd56", + "size": 475435, + "subdir": "linux-64", + "timestamp": 1654685073860, + "version": "7.1.2" + }, + "pytest-7.1.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.11,<3.12.0a0", + "tomli >=1.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "76733a0dba9654bde34a35e95d0bad7b", + "name": "pytest", + "sha256": "9d46f63bf47d5e3c09f24b936f172824ad198ca663d23e1b627e764dfe382c89", + "size": 642561, + "subdir": "linux-64", + "timestamp": 1676822875677, + "version": "7.1.2" + }, + "pytest-7.1.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "tomli >=1.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5a7ee21be55a02719725f3f0b9264df5", + "name": "pytest", + "sha256": "cb15694e84e41c8c11546d0bf2d252336c849a6dc34e9b998b5ada67c68e2b98", + "size": 469261, + "subdir": "linux-64", + "timestamp": 1654685034307, + "version": "7.1.2" + }, + "pytest-7.1.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "tomli >=1.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2b190e23bf607edf6bd3fe76d667b32", + "name": "pytest", + "sha256": "241a1eedd141ab2fb6a601fbfa629dcbeb484a5d84a1dcbd6fe4c910d9c4d2f0", + "size": 469426, + "subdir": "linux-64", + "timestamp": 1654685099260, + "version": "7.1.2" + }, + "pytest-7.1.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "tomli >=1.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b19707e24055e4b0e1db8af9e1381568", + "name": "pytest", + "sha256": "4dd51727f952a659d829a8e776f7205907977abaf5512f9b942eb4409c94a278", + "size": 469235, + "subdir": "linux-64", + "timestamp": 1654685005949, + "version": "7.1.2" + }, + "pytest-arraydiff-0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "0038c46dfd34e9276b378a1876db618b", + "name": "pytest-arraydiff", + "sha256": "8e3d6954a081884a425d5243bb04d6c5b7044c32becfc48a9d7ade3e18468cbb", + "size": 14073, + "subdir": "linux-64", + "timestamp": 1518731542120, + "version": "0.2" + }, + "pytest-arraydiff-0.2-py27h39e3cac_0.tar.bz2": { + "build": "py27h39e3cac_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "eeee150c2b2622ea8cd574b8b6066e51", + "name": "pytest-arraydiff", + "sha256": "0ad780284ca25f64657b196dfee54784541d56c1863c9a9b4975f542c530735f", + "size": 14224, + "subdir": "linux-64", + "timestamp": 1530738101761, + "version": "0.2" + }, + "pytest-arraydiff-0.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD", + "md5": "4b903d9527b99e17943f9f8443ae2c4b", + "name": "pytest-arraydiff", + "sha256": "b477ba3535652d1ab2c558bfc239150496dc5d6a1359cf8291af859b2922fbd6", + "size": 14204, + "subdir": "linux-64", + "timestamp": 1518731622023, + "version": "0.2" + }, + "pytest-arraydiff-0.2-py35h39e3cac_0.tar.bz2": { + "build": "py35h39e3cac_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD", + "md5": "009c3917375ff56cb4d9da1e7c46cec6", + "name": "pytest-arraydiff", + "sha256": "dc1c081f3cd36f7acecf62adb117736d2ba9a4df818ba31574598114c74b97ef", + "size": 14298, + "subdir": "linux-64", + "timestamp": 1534352902159, + "version": "0.2" + }, + "pytest-arraydiff-0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "b7cd0215e6c65c56d6d09afb571e896e", + "name": "pytest-arraydiff", + "sha256": "5fd91bde9729f4f7dc7cc9cf09ca748bd3dae0441f9db252965f895fb1a1f05e", + "size": 14180, + "subdir": "linux-64", + "timestamp": 1518731452843, + "version": "0.2" + }, + "pytest-arraydiff-0.2-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "516b7b2b1f917ca4080425e396e7e82f", + "name": "pytest-arraydiff", + "sha256": "05958baea107f3da82de735ff5af8acdecda9258cdb3f60d8c6f26fd4b26838f", + "size": 14309, + "subdir": "linux-64", + "timestamp": 1530738076573, + "version": "0.2" + }, + "pytest-arraydiff-0.2-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD", + "md5": "f66844be3c2fc20d352eeb8588f1632b", + "name": "pytest-arraydiff", + "sha256": "f4b32ae4a5f0f2033868ff4949a31112de0f335c4c1fc0fa6c961bd6b2c4198a", + "size": 14334, + "subdir": "linux-64", + "timestamp": 1530738127892, + "version": "0.2" + }, + "pytest-arraydiff-0.2-py38h39e3cac_0.tar.bz2": { + "build": "py38h39e3cac_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD", + "md5": "5b72d0b3a5c3cbc2672481d7de26f82f", + "name": "pytest-arraydiff", + "sha256": "870797ef797682e60c44f783dcc9f29f3d87ebefe589febf7fa6f94cc9988a38", + "size": 15342, + "subdir": "linux-64", + "timestamp": 1574170812302, + "version": "0.2" + }, + "pytest-arraydiff-0.3-py27h39e3cac_0.tar.bz2": { + "build": "py27h39e3cac_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "3f74aeda614fd182964124da30edd44b", + "name": "pytest-arraydiff", + "sha256": "60988900c303d9de4b49be7b502dc23982b98133500b83a9fb4dced6c3683a2b", + "size": 15090, + "subdir": "linux-64", + "timestamp": 1545232325236, + "version": "0.3" + }, + "pytest-arraydiff-0.3-py310h2f386ee_0.tar.bz2": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD", + "md5": "b6b7cc5e3f2db0b38638a8bc2bbb9047", + "name": "pytest-arraydiff", + "sha256": "688102734f32b7fea3f020b4bb427f6c498d637236ee95282a148c33a8a46ac0", + "size": 15689, + "subdir": "linux-64", + "timestamp": 1640810503536, + "version": "0.3" + }, + "pytest-arraydiff-0.3-py311h6410fe4_0.tar.bz2": { + "build": "py311h6410fe4_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "BSD", + "md5": "82ceabdec991470c9bfe7dbc83ec16ab", + "name": "pytest-arraydiff", + "sha256": "44010aa47c0e1c5c6891524c879a382c7aa40d63b4d5bf304742560c18dd670f", + "size": 18963, + "subdir": "linux-64", + "timestamp": 1676845496139, + "version": "0.3" + }, + "pytest-arraydiff-0.3-py36h39e3cac_0.tar.bz2": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "7974d3917048f2b29ce274c2617e0479", + "name": "pytest-arraydiff", + "sha256": "fd26c648bbe75afb47312c214568b1f086362db98588c64b420f8c472b9ae4f3", + "size": 15198, + "subdir": "linux-64", + "timestamp": 1545232348769, + "version": "0.3" + }, + "pytest-arraydiff-0.3-py37h39e3cac_0.tar.bz2": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD", + "md5": "ea58eeaa4fec8ee0cd2d88f1b4e6183d", + "name": "pytest-arraydiff", + "sha256": "20d86e7a1c6b0c281beb0808f1597002a33f4f97ae864fc18989f9929e8946b7", + "size": 15187, + "subdir": "linux-64", + "timestamp": 1545232142851, + "version": "0.3" + }, + "pytest-arraydiff-0.3-py37hb070fc8_0.tar.bz2": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD", + "md5": "3e0305e5d17eefb573db67e38a4ea346", + "name": "pytest-arraydiff", + "sha256": "5d580f8e3a303a62b1ceddcc2eb84adcf2d57d05e9afa6ad6881250a54c5364a", + "size": 16363, + "subdir": "linux-64", + "timestamp": 1636110895721, + "version": "0.3" + }, + "pytest-arraydiff-0.3-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD", + "md5": "c279c47e79f7e06fb1cefb3bfbdeb296", + "name": "pytest-arraydiff", + "sha256": "3eac42c8915f7ef04ec69a2b87dc1a67655d9ee5ba67f534342eab26a9828343", + "size": 16334, + "subdir": "linux-64", + "timestamp": 1636110882228, + "version": "0.3" + }, + "pytest-arraydiff-0.3-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD", + "md5": "3adc29040df230bc380805493eae6f85", + "name": "pytest-arraydiff", + "sha256": "737954b806d3abb92b8d0be91dc44fc9b00310e7681ff8a3449332d44d0b5a8f", + "size": 16633, + "subdir": "linux-64", + "timestamp": 1607625837100, + "version": "0.3" + }, + "pytest-astropy-0.10.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "hypothesis >=5.1", + "pytest >=4.6", + "pytest-arraydiff >=0.1", + "pytest-astropy-header >=0.1.2", + "pytest-cov >=2.3.1", + "pytest-doctestplus >=0.11.0", + "pytest-filter-subpackage >=0.1", + "pytest-mock >=2.0", + "pytest-openfiles >=0.3.1", + "pytest-remotedata >=0.3.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a7a9dc0a311f5743d8cd46811801f78a", + "name": "pytest-astropy", + "sha256": "b07e6800ad0495562f6f015ab652021558d3eb310e5c42366c6902d12c34fad2", + "size": 9903, + "subdir": "linux-64", + "timestamp": 1657529889875, + "version": "0.10.0" + }, + "pytest-astropy-0.10.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "hypothesis >=5.1", + "pytest >=4.6", + "pytest-arraydiff >=0.1", + "pytest-astropy-header >=0.1.2", + "pytest-cov >=2.3.1", + "pytest-doctestplus >=0.11.0", + "pytest-filter-subpackage >=0.1", + "pytest-mock >=2.0", + "pytest-openfiles >=0.3.1", + "pytest-remotedata >=0.3.1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "324745f4bc682e4da8c196cef59bd04a", + "name": "pytest-astropy", + "sha256": "75664997b89d1dd4a414bc20bafeadccd8a0bdf7f0bc6eaf045d5e51d1714346", + "size": 10713, + "subdir": "linux-64", + "timestamp": 1676861289068, + "version": "0.10.0" + }, + "pytest-astropy-0.10.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "hypothesis >=5.1", + "pytest >=4.6", + "pytest-arraydiff >=0.1", + "pytest-astropy-header >=0.1.2", + "pytest-cov >=2.3.1", + "pytest-doctestplus >=0.11.0", + "pytest-filter-subpackage >=0.1", + "pytest-mock >=2.0", + "pytest-openfiles >=0.3.1", + "pytest-remotedata >=0.3.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d6caf29f94559aaad24fc66e29b00e59", + "name": "pytest-astropy", + "sha256": "dfe82e7a22dd40d649cd6ba8ec0edd7921089e30d58b06d9a9c8e48313c399cb", + "size": 9875, + "subdir": "linux-64", + "timestamp": 1657529837637, + "version": "0.10.0" + }, + "pytest-astropy-0.10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "hypothesis >=5.1", + "pytest >=4.6", + "pytest-arraydiff >=0.1", + "pytest-astropy-header >=0.1.2", + "pytest-cov >=2.3.1", + "pytest-doctestplus >=0.11.0", + "pytest-filter-subpackage >=0.1", + "pytest-mock >=2.0", + "pytest-openfiles >=0.3.1", + "pytest-remotedata >=0.3.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2bf217ac675e307f8e5ad84e842f2675", + "name": "pytest-astropy", + "sha256": "7e236910d6181ac8dfc9d1c0ea1d62efff1e1f823603eb05af6d5d29bcf655fb", + "size": 9858, + "subdir": "linux-64", + "timestamp": 1657529962430, + "version": "0.10.0" + }, + "pytest-astropy-0.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "hypothesis >=5.1", + "pytest >=4.6", + "pytest-arraydiff >=0.1", + "pytest-astropy-header >=0.1.2", + "pytest-cov >=2.3.1", + "pytest-doctestplus >=0.11.0", + "pytest-filter-subpackage >=0.1", + "pytest-mock >=2.0", + "pytest-openfiles >=0.3.1", + "pytest-remotedata >=0.3.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d98bc813262a3dddc225f9c5c9661259", + "name": "pytest-astropy", + "sha256": "3d666927290cef87426d465bcf6868d73b6d38500b35c1dd43000c6b4b60230b", + "size": 9860, + "subdir": "linux-64", + "timestamp": 1657529926198, + "version": "0.10.0" + }, + "pytest-astropy-0.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.2", + "pytest-openfiles >=0.2", + "pytest-remotedata >=0.2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "2668bf01fbde4a6ec28b75e1e3b85b60", + "name": "pytest-astropy", + "sha256": "2bfd6776616639f2376fc47b728871f3aafa65e16bea54886ef5af9ae48f1dca", + "size": 5487, + "subdir": "linux-64", + "timestamp": 1518797675599, + "version": "0.2.1" + }, + "pytest-astropy-0.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.2", + "pytest-openfiles >=0.2", + "pytest-remotedata >=0.2", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "d9d46ad1f6c0b9da378a54996aaed69d", + "name": "pytest-astropy", + "sha256": "8b5d305c038df19e1ad95ad11951043360e1eb0e57f651a3c6dcccef938437ca", + "size": 5493, + "subdir": "linux-64", + "timestamp": 1518797835181, + "version": "0.2.1" + }, + "pytest-astropy-0.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.2", + "pytest-openfiles >=0.2", + "pytest-remotedata >=0.2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "1f9637465f5908ac66d03ebda1f10fb5", + "name": "pytest-astropy", + "sha256": "7fab10b26efce0a5f1febef4e6155bc43b519048eba2dc21d055353839a76621", + "size": 5470, + "subdir": "linux-64", + "timestamp": 1518797843724, + "version": "0.2.1" + }, + "pytest-astropy-0.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.1.0", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.3", + "pytest-openfiles >=0.3.0", + "pytest-remotedata >=0.2.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "02e3f35982eb1e0379b6fc8fa5d6e3c4", + "name": "pytest-astropy", + "sha256": "3b16b8252895af832e451ff4ec4234fa5ea72d6dd7f1b89b4095da47440fac6f", + "size": 5327, + "subdir": "linux-64", + "timestamp": 1524580704177, + "version": "0.3.0" + }, + "pytest-astropy-0.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.1.0", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.3", + "pytest-openfiles >=0.3.0", + "pytest-remotedata >=0.2.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "bc9416d0b8cd413794556e1127b2cd72", + "name": "pytest-astropy", + "sha256": "738d5e83fde371207679c453499bf4a65b5d30ad394c218c4d8941e33c19bafc", + "size": 5323, + "subdir": "linux-64", + "timestamp": 1524580751965, + "version": "0.3.0" + }, + "pytest-astropy-0.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.1.0", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.3", + "pytest-openfiles >=0.3.0", + "pytest-remotedata >=0.2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "78d47137cfd5a94dc12be419449453b4", + "name": "pytest-astropy", + "sha256": "b6e3836b33c3a9fa3c01f4c2cb306bdd6d6cdce3e93467f00e91d1e3b12c078f", + "size": 5338, + "subdir": "linux-64", + "timestamp": 1524580734459, + "version": "0.3.0" + }, + "pytest-astropy-0.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.3", + "pytest-openfiles >=0.3", + "pytest-remotedata >=0.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "2e7177c70717bdffecebc7c7ec8c4cc3", + "name": "pytest-astropy", + "sha256": "bc4d43dd70370b3ee73ef8d11b7cde1406aff9dc5bd51651b3d94c7db71e2826", + "size": 5371, + "subdir": "linux-64", + "timestamp": 1528150063921, + "version": "0.4.0" + }, + "pytest-astropy-0.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.3", + "pytest-openfiles >=0.3", + "pytest-remotedata >=0.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "efe97ab7c9d603ffb948a27e1635e6e5", + "name": "pytest-astropy", + "sha256": "9b8e9f2460f4b6631b3de5fc0d3a4ffbee16a923a95f2ed0f36737ba67e58187", + "size": 5361, + "subdir": "linux-64", + "timestamp": 1528150041100, + "version": "0.4.0" + }, + "pytest-astropy-0.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.3", + "pytest-openfiles >=0.3", + "pytest-remotedata >=0.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "f10dfb2ea4b1fc9a1717ec7b4673d196", + "name": "pytest-astropy", + "sha256": "e051f67b51a2584e045da1a770ec6a3c11cabd92cd08dd65186fc3dab4f9b44e", + "size": 5358, + "subdir": "linux-64", + "timestamp": 1528149979261, + "version": "0.4.0" + }, + "pytest-astropy-0.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.3", + "pytest-openfiles >=0.3", + "pytest-remotedata >=0.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "bc618efce24fd23f0762c67f9d837c6f", + "name": "pytest-astropy", + "sha256": "93e7a62d64ce18455e2eb12973f1941231ad9a7f481e0227313c1969bf9aff14", + "size": 5325, + "subdir": "linux-64", + "timestamp": 1530738179260, + "version": "0.4.0" + }, + "pytest-astropy-0.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.2.0", + "pytest-openfiles >=0.3.1", + "pytest-remotedata >=0.3.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "d79e7a7d027b7af951aada175ef2ff4e", + "name": "pytest-astropy", + "sha256": "a0735226fc2c9d81f51be31c0f0f62c81925314255a20d4181c287966f36da72", + "size": 6435, + "subdir": "linux-64", + "timestamp": 1545121425923, + "version": "0.5.0" + }, + "pytest-astropy-0.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.2.0", + "pytest-openfiles >=0.3.1", + "pytest-remotedata >=0.3.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "fa73ee2b2c18d003d7ead5f6b1467133", + "name": "pytest-astropy", + "sha256": "813eacc51ab5e97d74208030ce778357206e5bfe038384c01ff6c1237fa0007f", + "size": 6418, + "subdir": "linux-64", + "timestamp": 1545121457649, + "version": "0.5.0" + }, + "pytest-astropy-0.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.2.0", + "pytest-openfiles >=0.3.1", + "pytest-remotedata >=0.3.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "aef831841c63983510b4f964fa0e426e", + "name": "pytest-astropy", + "sha256": "5883924d7fc5606a69b28713fcbd43798b3fd10c6d8c7dc320d56627f080d814", + "size": 6417, + "subdir": "linux-64", + "timestamp": 1545121456286, + "version": "0.5.0" + }, + "pytest-astropy-0.5.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.2.0", + "pytest-openfiles >=0.3.1", + "pytest-remotedata >=0.3.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "684b94a412c56ebdb68821308c4f0a8d", + "name": "pytest-astropy", + "sha256": "1a4736f54a6b0526ead3b91a0871e4d906745da3f2df2d0f1d0178d46f804556", + "size": 6649, + "subdir": "linux-64", + "timestamp": 1574087049100, + "version": "0.5.0" + }, + "pytest-asyncio-0.10.0-py36_1000.tar.bz2": { + "build": "py36_1000", + "build_number": 1000, + "depends": [ + "pytest >=3.0.6", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "887acc037fa114763ef7fba6e33a0a9e", + "name": "pytest-asyncio", + "sha256": "49f9bb624c85cf1283951a415e091653bacb585ea2d21adac3c48cfce1a1b924", + "size": 18529, + "subdir": "linux-64", + "timestamp": 1552446372252, + "version": "0.10.0" + }, + "pytest-asyncio-0.10.0-py36h06a4308_1000.tar.bz2": { + "build": "py36h06a4308_1000", + "build_number": 1000, + "depends": [ + "pytest >=3.0.6", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "996c9269116f188e2722eec73f5c8762", + "name": "pytest-asyncio", + "sha256": "f07abad4533d38cb2e7e43c619edf4f58d0df14f57da4e6188a422eeffb0c98b", + "size": 18958, + "subdir": "linux-64", + "timestamp": 1611771733694, + "version": "0.10.0" + }, + "pytest-asyncio-0.10.0-py37_1000.tar.bz2": { + "build": "py37_1000", + "build_number": 1000, + "depends": [ + "pytest >=3.0.6", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "abcdc9c498262d5d221b20875844240a", + "name": "pytest-asyncio", + "sha256": "a2299b4d1b3ee8dd6e65709356e97cad2540c23ea67bc6afb63269e196d4d8ac", + "size": 18510, + "subdir": "linux-64", + "timestamp": 1552484109533, + "version": "0.10.0" + }, + "pytest-asyncio-0.10.0-py37h06a4308_1000.tar.bz2": { + "build": "py37h06a4308_1000", + "build_number": 1000, + "depends": [ + "pytest >=3.0.6", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "8f8c9c540419573c2592b2847dd9461b", + "name": "pytest-asyncio", + "sha256": "ff6a11e29d3430f32876c03de776968aba512fbe7fca68ca56df3db5ad3444d3", + "size": 18942, + "subdir": "linux-64", + "timestamp": 1611771728641, + "version": "0.10.0" + }, + "pytest-asyncio-0.10.0-py38_1000.tar.bz2": { + "build": "py38_1000", + "build_number": 1000, + "depends": [ + "pytest >=3.0.6", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "b372d690404b97bc5f26c45b358388cc", + "name": "pytest-asyncio", + "sha256": "6d6d1fdfe2cc884a3e9683873312f8b5616a0e783c82f16aa955699b3cf403a9", + "size": 17144, + "subdir": "linux-64", + "timestamp": 1574170824176, + "version": "0.10.0" + }, + "pytest-asyncio-0.10.0-py38h06a4308_1000.tar.bz2": { + "build": "py38h06a4308_1000", + "build_number": 1000, + "depends": [ + "pytest >=3.0.6", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "97d6b6249edbfd54e2683956b33d587c", + "name": "pytest-asyncio", + "sha256": "d292f1c3ebebfb497f8a59906156160f786717e6b168e7b62abcf287029a7806", + "size": 18976, + "subdir": "linux-64", + "timestamp": 1611771714438, + "version": "0.10.0" + }, + "pytest-asyncio-0.10.0-py39h06a4308_1000.tar.bz2": { + "build": "py39h06a4308_1000", + "build_number": 1000, + "depends": [ + "pytest >=3.0.6", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "dc598aa5d668caba910cc9ff6bd4c7f0", + "name": "pytest-asyncio", + "sha256": "1054a8d39c8ce2ab30f89b35d0c4acc5591603f8ad5a0c2dac56c41a5a6ef94d", + "size": 19045, + "subdir": "linux-64", + "timestamp": 1611771712435, + "version": "0.10.0" + }, + "pytest-asyncio-0.12.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "73258fe4170191f135023ebe6e905166", + "name": "pytest-asyncio", + "sha256": "bdce05846a02bd2782ab1e66cbe7b5b1384baecdb43384f776a4ecdd4c8c68d9", + "size": 17603, + "subdir": "linux-64", + "timestamp": 1594394999758, + "version": "0.12.0" + }, + "pytest-asyncio-0.14.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "acd25b173a09fd267dad0ee11a3d1c93", + "name": "pytest-asyncio", + "sha256": "3dd4d66460fb485df766995f6d8682893a418df153a1e167906a4bb4ea577c38", + "size": 18848, + "subdir": "linux-64", + "timestamp": 1600459011187, + "version": "0.14.0" + }, + "pytest-asyncio-0.14.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "93d8b2098377b15190c8ae53bb23c3b6", + "name": "pytest-asyncio", + "sha256": "d05dc1530b5cb4039cd89cacd4eebe3b5af5d2ac83e717cb57722c31a0decdf6", + "size": 21831, + "subdir": "linux-64", + "timestamp": 1615906731302, + "version": "0.14.0" + }, + "pytest-asyncio-0.14.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "1563a0c63650072e8bd54766ff7ea20e", + "name": "pytest-asyncio", + "sha256": "fad7591a20d815999fede459ca2a99389d25452c2695a663aca440d6e2f9e53a", + "size": 18857, + "subdir": "linux-64", + "timestamp": 1600459003842, + "version": "0.14.0" + }, + "pytest-asyncio-0.14.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "3b6d80e4f1d4f349579e2954abcb8434", + "name": "pytest-asyncio", + "sha256": "14a1a7ba87194802960360479f28354a65648117d5cab235d62347fe812cf775", + "size": 21823, + "subdir": "linux-64", + "timestamp": 1615907356691, + "version": "0.14.0" + }, + "pytest-asyncio-0.14.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "53561a59d0400de6909104478eca19e8", + "name": "pytest-asyncio", + "sha256": "9fcfb38b84d357db30924c2089008431b6834931355c720155dbed9dbfa93896", + "size": 18921, + "subdir": "linux-64", + "timestamp": 1600459020586, + "version": "0.14.0" + }, + "pytest-asyncio-0.14.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "b913b3edc0f54ea182b0629610fd4966", + "name": "pytest-asyncio", + "sha256": "5a4839c5b589a01a210964f54d48c259fcb1559708cc73c131390e5ef377833d", + "size": 21911, + "subdir": "linux-64", + "timestamp": 1615907374660, + "version": "0.14.0" + }, + "pytest-asyncio-0.14.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "cef7bf4017567ccf4f51bd10008d5907", + "name": "pytest-asyncio", + "sha256": "79633eb543f730862b6cdde493eabda71f01c2a2428fb8d15aba37efd276e3ef", + "size": 21911, + "subdir": "linux-64", + "timestamp": 1615907361396, + "version": "0.14.0" + }, + "pytest-asyncio-0.15.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "bedccddeae6a14c502537630fab23cac", + "name": "pytest-asyncio", + "sha256": "aa581b44cf50d54a2e8890ecb20f4a0ab3bfa1251b0fecfe6a2aebc05405d449", + "size": 18992, + "subdir": "linux-64", + "timestamp": 1618866151102, + "version": "0.15.0" + }, + "pytest-asyncio-0.15.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "887a8a0128d0439aadcd11d092cfe4d7", + "name": "pytest-asyncio", + "sha256": "f4da13d0e2030d593c5a3a01918ccb28640d4eb5a42ae49d4e65d526c6fd29d3", + "size": 18979, + "subdir": "linux-64", + "timestamp": 1618869493987, + "version": "0.15.0" + }, + "pytest-asyncio-0.15.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "efb6917a08b7b492adaab8f670d71bcc", + "name": "pytest-asyncio", + "sha256": "e123a9a90bb791a8dda7411054634f7b9c354fbb8984edf5a6351b582b6c0e0b", + "size": 19062, + "subdir": "linux-64", + "timestamp": 1618869495577, + "version": "0.15.0" + }, + "pytest-asyncio-0.15.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "9039458deacb823fcfc482fdf3715154", + "name": "pytest-asyncio", + "sha256": "1b31983fa644c8eed37280dfff2b62db5b8f945898a2fe43b3b12b0731a22c34", + "size": 19079, + "subdir": "linux-64", + "timestamp": 1618906077120, + "version": "0.15.0" + }, + "pytest-asyncio-0.15.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "5457d17921dd1692e9d8aa42c2047905", + "name": "pytest-asyncio", + "sha256": "00e92de522c5d6c348b8e961666567d3d24db3fdc92b63734a2f5de8bfe74f13", + "size": 22091, + "subdir": "linux-64", + "timestamp": 1636022743624, + "version": "0.15.1" + }, + "pytest-asyncio-0.15.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "8b29fc4e92f12cbea037a9ea6cff77f0", + "name": "pytest-asyncio", + "sha256": "31b991f07dfd990b8c6574b3723c9e88820dd31c6c3ae79e9909a4edbfa3c0a2", + "size": 22145, + "subdir": "linux-64", + "timestamp": 1636034750396, + "version": "0.15.1" + }, + "pytest-asyncio-0.15.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "23eac1e8542909f136d31327f8f9856b", + "name": "pytest-asyncio", + "sha256": "de94ca7c6df0b45ee339092a5e99bf3f7696ffe803c5128f0edc25aaa59d4bbb", + "size": 19228, + "subdir": "linux-64", + "timestamp": 1619450354361, + "version": "0.15.1" + }, + "pytest-asyncio-0.15.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "55e5e22f7230dfbfbcc1a5cbc3b70059", + "name": "pytest-asyncio", + "sha256": "990a2726e38fa905512dc8a29ecd4e5ea8a9bed58508d9001649fb80755eed05", + "size": 19210, + "subdir": "linux-64", + "timestamp": 1619305790747, + "version": "0.15.1" + }, + "pytest-asyncio-0.16.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.4.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7b8fc96b5a6c3f9ea14e8c60ff7f02ce", + "name": "pytest-asyncio", + "sha256": "cae372d5d3040c8e6e75b05022f9fcbfb7c2be1d4a24a981e8661def6a6b6d7c", + "size": 19318, + "subdir": "linux-64", + "timestamp": 1640810521926, + "version": "0.16.0" + }, + "pytest-asyncio-0.16.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "34a1909c4cdcc177b4d4f93b9ad3ea32", + "name": "pytest-asyncio", + "sha256": "b200aa0a32195a6e6ba51071b50e2232c52ef5e5ab3379c3a17d20e53ef17f1d", + "size": 18970, + "subdir": "linux-64", + "timestamp": 1639142045279, + "version": "0.16.0" + }, + "pytest-asyncio-0.16.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eff2bc490fbb854344206b593a959ec9", + "name": "pytest-asyncio", + "sha256": "53502ccd6105a7cb8da0f8b2a1f8c88d583fe4a60f451712ce3cf2505072234d", + "size": 19070, + "subdir": "linux-64", + "timestamp": 1639128465875, + "version": "0.16.0" + }, + "pytest-asyncio-0.16.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c2a688c558778fa7bc965fad166f9e8a", + "name": "pytest-asyncio", + "sha256": "be0ac8e90e8ffaa5cd04db092a92e323d1d0429c67338560322f5524e8e297a5", + "size": 19033, + "subdir": "linux-64", + "timestamp": 1639142045175, + "version": "0.16.0" + }, + "pytest-asyncio-0.20.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=6.1.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a41410d2789226f756f48a9a4eaf2fe2", + "name": "pytest-asyncio", + "sha256": "b487eb43514034f474275ff45984151c3defc08157de833cdb6b27aede19bf4a", + "size": 30081, + "subdir": "linux-64", + "timestamp": 1678971540265, + "version": "0.20.3" + }, + "pytest-asyncio-0.20.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=6.1.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9ece23a93ec1953251364ad23a3f59ff", + "name": "pytest-asyncio", + "sha256": "d27807e54b189d58bf228e37f1ba33f2cac8f1775aec9a1ca3308d7e5c239ed7", + "size": 34425, + "subdir": "linux-64", + "timestamp": 1678971465456, + "version": "0.20.3" + }, + "pytest-asyncio-0.20.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=6.1.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "57a29b06bcdefa9102178370b4acc6a2", + "name": "pytest-asyncio", + "sha256": "72baaa8593f2ee0dbbce982be147e0030817df87de4f750b825f3f246a2b28aa", + "size": 29813, + "subdir": "linux-64", + "timestamp": 1678971574105, + "version": "0.20.3" + }, + "pytest-asyncio-0.20.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=6.1.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d50d489cd67e5c78ab86b26f6c77d7dd", + "name": "pytest-asyncio", + "sha256": "78ae51268c9a92830569047d4f84800cb5241e7a0cddd324d739e9b262de4145", + "size": 29903, + "subdir": "linux-64", + "timestamp": 1678971506328, + "version": "0.20.3" + }, + "pytest-asyncio-0.8.0-py35hf603743_0.tar.bz2": { + "build": "py35hf603743_0", + "build_number": 0, + "depends": [ + "pytest >=3.0.2", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "a11d8892803b1c55f137e0b9ff228f76", + "name": "pytest-asyncio", + "sha256": "d18dc12855f5b2d0ecff2ca1d864b7c36fed61e2f388bd86cc1863bb67d75534", + "size": 12277, + "subdir": "linux-64", + "timestamp": 1511935956324, + "version": "0.8.0" + }, + "pytest-asyncio-0.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "272a421e85840b59f8bd7d66f993a7f8", + "name": "pytest-asyncio", + "sha256": "4ce572eafa88b0110f323db0910eada4b9ed03417c8c7a375cb0e0d33074a6af", + "size": 11854, + "subdir": "linux-64", + "timestamp": 1530922150927, + "version": "0.8.0" + }, + "pytest-asyncio-0.8.0-py36h0795122_0.tar.bz2": { + "build": "py36h0795122_0", + "build_number": 0, + "depends": [ + "pytest >=3.0.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "4f5c5311d5af1722a5a48739b94674e3", + "name": "pytest-asyncio", + "sha256": "35433a8dc7b0abe192dc87b03c2f0455ebcfe9b24ee2eb48e1541d9213b3d4a9", + "size": 12246, + "subdir": "linux-64", + "timestamp": 1511935966543, + "version": "0.8.0" + }, + "pytest-asyncio-0.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.0.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "cfb7808c546502ca52f32ed39952070d", + "name": "pytest-asyncio", + "sha256": "972460f7a40ff4d522a1fcf25491ce49f60687d7be954635cf66ba2502a5cfe2", + "size": 11854, + "subdir": "linux-64", + "timestamp": 1530922185325, + "version": "0.8.0" + }, + "pytest-asyncio-0.9.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0.2", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "46a12d8661ba5a29f58a948be1e51483", + "name": "pytest-asyncio", + "sha256": "07d3ab5093649254cad14a20dede80b910f6f2e7c30a831f57a0230eee8a49d1", + "size": 11782, + "subdir": "linux-64", + "timestamp": 1535420686082, + "version": "0.9.0" + }, + "pytest-asyncio-0.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "6d3b76f1030863782bf353ba1ae9cf97", + "name": "pytest-asyncio", + "sha256": "7555403f90a6c9ad6b0b7d4701d1c4610457fd4bf45b390a3da5e0874f3cf3bc", + "size": 11748, + "subdir": "linux-64", + "timestamp": 1535420548813, + "version": "0.9.0" + }, + "pytest-asyncio-0.9.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.0.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "a3be1b07477d91d8ca03343afa87b267", + "name": "pytest-asyncio", + "sha256": "05a30738f1732c5a6569bafa15d0015c4f873f0064a4ff5b07cdff70d20e2f0b", + "size": 11785, + "subdir": "linux-64", + "timestamp": 1535420687113, + "version": "0.9.0" + }, + "pytest-base-url-1.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=2.7,<2.8.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "41a9cbe4efabd1b70a5c166eb0244c23", + "name": "pytest-base-url", + "sha256": "73f83e704ad55d7538fc9615f176f8f90df6fdd06d34b10e91df622d72d2dd20", + "size": 8246, + "subdir": "linux-64", + "timestamp": 1518721311536, + "version": "1.4.1" + }, + "pytest-base-url-1.4.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.10,<3.11.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "96b24e13db60ed539968710d6475fa80", + "name": "pytest-base-url", + "sha256": "2c0d3966f06a9fcc125323b792f018973827851f4628231e23273e092a43a7e0", + "size": 8465, + "subdir": "linux-64", + "timestamp": 1640810544887, + "version": "1.4.1" + }, + "pytest-base-url-1.4.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.11,<3.12.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "35214a7cb9a61546837fd9ca1c779c00", + "name": "pytest-base-url", + "sha256": "f01b00db3328f3c94f563e153e16899c1f77c305abe7eaf576de443a7c400e1d", + "size": 9476, + "subdir": "linux-64", + "timestamp": 1676861320804, + "version": "1.4.1" + }, + "pytest-base-url-1.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.5,<3.6.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "5c40093013b9a7a97f9e9277a1e2e8c3", + "name": "pytest-base-url", + "sha256": "89937559f53b919ea4b4ff9dc9f7007f49a872b06ffe5ec7f1f80897c17914b8", + "size": 8266, + "subdir": "linux-64", + "timestamp": 1518721383768, + "version": "1.4.1" + }, + "pytest-base-url-1.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.6,<3.7.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "1a905c2f73bc926e2f2d0c6318bd2859", + "name": "pytest-base-url", + "sha256": "a5e2508ba9ab66e1ce4175b7e35e4c02a26eabb3cdbc69abbe2685dd7185817f", + "size": 8223, + "subdir": "linux-64", + "timestamp": 1518721354470, + "version": "1.4.1" + }, + "pytest-base-url-1.4.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.6,<3.7.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "a83217bcc3c131c62fd1033bb661d18d", + "name": "pytest-base-url", + "sha256": "74d8bbbfe092b94c71e8759b4599eb5715ae2bf47af4c28fefa7d5eb173c636d", + "size": 9213, + "subdir": "linux-64", + "timestamp": 1611771713539, + "version": "1.4.1" + }, + "pytest-base-url-1.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.7,<3.8.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "ca3297965318a9ddca9aa0bda66ba9dd", + "name": "pytest-base-url", + "sha256": "5d5fdfafde1a69c7d0d19d88f2c5112ad9d77c3f4232b059130158d5fa40f4d7", + "size": 8136, + "subdir": "linux-64", + "timestamp": 1530922225036, + "version": "1.4.1" + }, + "pytest-base-url-1.4.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.7,<3.8.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "b6d83336118537107256f0d29196798d", + "name": "pytest-base-url", + "sha256": "817bc19f6adaa9b471574712d0eaa1cd0af13fb9133e4e81b01c458238b1132d", + "size": 9210, + "subdir": "linux-64", + "timestamp": 1611771691013, + "version": "1.4.1" + }, + "pytest-base-url-1.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.8,<3.9.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "c92097b450c69edc94fc14136824dd87", + "name": "pytest-base-url", + "sha256": "cf597d7a84dba6274d98ec80fab0be4f6e670980e84d6a236faac8cbf6bf80f0", + "size": 9226, + "subdir": "linux-64", + "timestamp": 1611771698083, + "version": "1.4.1" + }, + "pytest-base-url-1.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.9,<3.10.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "31bd41f401bbace79c97f31e336fec9e", + "name": "pytest-base-url", + "sha256": "820786b14efca820c5e82359e4a611453611d20b0fa61e8876bb241558f628f7", + "size": 9278, + "subdir": "linux-64", + "timestamp": 1611771516002, + "version": "1.4.1" + }, + "pytest-base-url-1.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.6,<3.7.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "0b7bc63e50f7541ff2abbaefb5359956", + "name": "pytest-base-url", + "sha256": "3c9eaff2d0d8150204053a3a0bd156135360e135f5aae2c0e3c65110b5de91b2", + "size": 8587, + "subdir": "linux-64", + "timestamp": 1600459068054, + "version": "1.4.2" + }, + "pytest-base-url-1.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.7,<3.8.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "4a4ae7d5a10e699568ca0ecd59452060", + "name": "pytest-base-url", + "sha256": "c4833dc78b67c3a897327975b91965e878e869593cae7e1200bdb87791fdf202", + "size": 8615, + "subdir": "linux-64", + "timestamp": 1600459088608, + "version": "1.4.2" + }, + "pytest-base-url-1.4.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.8,<3.9.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "4efb7d143e047e7d7f4076b5c5d0669f", + "name": "pytest-base-url", + "sha256": "3cfa4bb99a24ba39fef7b91f6d5743180138339d3841d997eaecf28585c8519a", + "size": 8614, + "subdir": "linux-64", + "timestamp": 1600459086650, + "version": "1.4.2" + }, + "pytest-benchmark-3.0.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pytest >=2.6", + "python >=2.7,<2.8.0a0", + "setuptools", + "statistics" + ], + "license": "BSD 2-clause", + "md5": "c6fc228bc753bb613ca64c24641ad13d", + "name": "pytest-benchmark", + "sha256": "2033fcd156a2ba13d4f2ae8bc3afe038828b2bc817df813bac8fc623ae6eb632", + "size": 55523, + "subdir": "linux-64", + "timestamp": 1520379176944, + "version": "3.0.0" + }, + "pytest-benchmark-3.0.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "pytest >=2.6", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "9bc629e85b4a75707e705f426680c07b", + "name": "pytest-benchmark", + "sha256": "d430439f69ac8f4260869d6efcc309937ef86eeccc7f1edb014e7e01609f4c85", + "size": 56571, + "subdir": "linux-64", + "timestamp": 1520379062555, + "version": "3.0.0" + }, + "pytest-benchmark-3.0.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pytest >=2.6", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "6cc0b9fa2911163aa8acddfcdbe6ad79", + "name": "pytest-benchmark", + "sha256": "e1cfd42fc73030a8a684b4e4e30413aa376a5ea08f0498b8d755b3e8628450b7", + "size": 56172, + "subdir": "linux-64", + "timestamp": 1520379009424, + "version": "3.0.0" + }, + "pytest-benchmark-3.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pathlib", + "py-cpuinfo", + "pytest >=2.8", + "python >=2.7,<2.8.0a0", + "statistics" + ], + "license": "BSD 2-clause", + "md5": "10e2f9b45d60d9152f6dd703b2ff398b", + "name": "pytest-benchmark", + "sha256": "48fb29eecf661086b71fa4774980aed74db0a5d25932d8b1ddbe568ef7045c09", + "size": 78331, + "subdir": "linux-64", + "timestamp": 1529239379383, + "version": "3.1.1" + }, + "pytest-benchmark-3.1.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pathlib2", + "py-cpuinfo", + "pytest >=2.8", + "python >=2.7,<2.8.0a0", + "statistics" + ], + "license": "BSD 2-clause", + "md5": "d483b25d611c21af3d1e69b7159e37d7", + "name": "pytest-benchmark", + "sha256": "ceec86d37f39b96ff3d3b936ba5a5ac3bc62919b2119748b27a5adce8229475a", + "size": 77662, + "subdir": "linux-64", + "timestamp": 1530872939605, + "version": "3.1.1" + }, + "pytest-benchmark-3.1.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=2.8", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-clause", + "md5": "c954efd9fddcd40337e9f1fb0b76000c", + "name": "pytest-benchmark", + "sha256": "ef5e1a320c1ef49b1941e7bbf444963c9b2f0dbbe56103240d628619fd42d5c5", + "size": 80059, + "subdir": "linux-64", + "timestamp": 1529239336385, + "version": "3.1.1" + }, + "pytest-benchmark-3.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=2.8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "md5": "6b14930a8efdffc2a98cfac84f0464fa", + "name": "pytest-benchmark", + "sha256": "3b6f51eb5c1dc17cf5d5f2d6568dcee531edbf6d2f4e15ef454f5b86c964588d", + "size": 79513, + "subdir": "linux-64", + "timestamp": 1529238997287, + "version": "3.1.1" + }, + "pytest-benchmark-3.1.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "py-cpuinfo", + "pytest >=2.8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "md5": "81a6fe83001594b92c302cd6f9b5d995", + "name": "pytest-benchmark", + "sha256": "8d06a88e360f76180176b698fb5e65ebd6ba17e29b38f5848c071ed64d770445", + "size": 78814, + "subdir": "linux-64", + "timestamp": 1530872995515, + "version": "3.1.1" + }, + "pytest-benchmark-3.1.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "py-cpuinfo", + "pytest >=2.8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "md5": "490f34cddb8dea60d2a9250f2ea6343a", + "name": "pytest-benchmark", + "sha256": "3bb59a00042a9946f0376389e7d15a5e18ac211306cae08b4fc39ec8c204898e", + "size": 78726, + "subdir": "linux-64", + "timestamp": 1530872968150, + "version": "3.1.1" + }, + "pytest-benchmark-3.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pathlib2", + "py-cpuinfo", + "pytest >=2.8", + "python >=2.7,<2.8.0a0", + "statistics" + ], + "license": "BSD 2-clause", + "md5": "32c5230b52603657d701dca2c09be86f", + "name": "pytest-benchmark", + "sha256": "ba0fe3dba8509bd342a368822bb5595dc29d9b992b7a6206d0376fd624cd2121", + "size": 80116, + "subdir": "linux-64", + "timestamp": 1547477048996, + "version": "3.2.0" + }, + "pytest-benchmark-3.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=2.8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "md5": "9ea240b196a234b77cea5e3ee532057a", + "name": "pytest-benchmark", + "sha256": "29dc76b595da7c3c72685d3b4446335b276eebdd79e52892d5d2c9750fb015c5", + "size": 81282, + "subdir": "linux-64", + "timestamp": 1547477111459, + "version": "3.2.0" + }, + "pytest-benchmark-3.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=2.8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "md5": "fd8436721195ce59a35efef87380b8ed", + "name": "pytest-benchmark", + "sha256": "3c4034afb0b5bab73cb12c7591798bc15004c79c40d7856d8ca27cff52d248db", + "size": 81241, + "subdir": "linux-64", + "timestamp": 1547477101955, + "version": "3.2.0" + }, + "pytest-benchmark-3.2.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pathlib2", + "py-cpuinfo", + "pytest >=3.8", + "python >=2.7,<2.8.0a0", + "statistics" + ], + "license": "BSD 2-clause", + "md5": "fd472a72faeb4878e3e7f451aad8c6f2", + "name": "pytest-benchmark", + "sha256": "fe354bcd197175a5508ae4577393f201e185907925efb9d4def56d49064175e0", + "size": 80830, + "subdir": "linux-64", + "timestamp": 1552446310136, + "version": "3.2.2" + }, + "pytest-benchmark-3.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "md5": "d83b193378ce6135c4c4ebb18fc8a8e7", + "name": "pytest-benchmark", + "sha256": "ba2b7289d8bc8c01e5f05b201e15ecb43ce0ad9d4b2a448108ec48a3c17f3f19", + "size": 81974, + "subdir": "linux-64", + "timestamp": 1552447020204, + "version": "3.2.2" + }, + "pytest-benchmark-3.2.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "md5": "fed3bcc243ae635a0440e66b68a9951a", + "name": "pytest-benchmark", + "sha256": "574269cc3a2e3c562ae839d20157df290c8cd639d87faacf215ff2bc328dd979", + "size": 82082, + "subdir": "linux-64", + "timestamp": 1613163826741, + "version": "3.2.2" + }, + "pytest-benchmark-3.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "md5": "aec4c5c67c2800f9c4a54e827034117b", + "name": "pytest-benchmark", + "sha256": "f3a2dec24fbf2f802b1a2f8955abd969abc41d561f6d66bc899a6627c4285b52", + "size": 81827, + "subdir": "linux-64", + "timestamp": 1552446952890, + "version": "3.2.2" + }, + "pytest-benchmark-3.2.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "md5": "ac829d7c021631dc7757a87aa949a9fe", + "name": "pytest-benchmark", + "sha256": "9bd761f903957d001a21ffb99796805fc621ca3d228e4307b0589fa9178ac471", + "size": 82016, + "subdir": "linux-64", + "timestamp": 1613164612005, + "version": "3.2.2" + }, + "pytest-benchmark-3.2.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-clause", + "md5": "fcd287cfaa94a40eeb5faff765bcbde4", + "name": "pytest-benchmark", + "sha256": "506ef91c47eb75a7b93bf9403eddc32f83620d57349dc739333a9701d7aefe9b", + "size": 81160, + "subdir": "linux-64", + "timestamp": 1574170838070, + "version": "3.2.2" + }, + "pytest-benchmark-3.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-clause", + "md5": "1a38df5ed6390612d70d0af281e894ff", + "name": "pytest-benchmark", + "sha256": "0a94d2375e867673c6120e80baa0ab8e2c0f4aa4f69f9dcff3989c4045d6aa3f", + "size": 82434, + "subdir": "linux-64", + "timestamp": 1613163829403, + "version": "3.2.2" + }, + "pytest-benchmark-3.2.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-clause", + "md5": "7976b9b9612299f4bedafc6f8fa92447", + "name": "pytest-benchmark", + "sha256": "9e0dffa932dcfeb3b2709beb5101d3f13e4b6ac03a42feaa31dfbd5039f2349f", + "size": 82437, + "subdir": "linux-64", + "timestamp": 1613164615523, + "version": "3.2.2" + }, + "pytest-benchmark-3.2.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "md5": "67976b9495d1461698e951d2ccdf5ba5", + "name": "pytest-benchmark", + "sha256": "68fc1c1d30a8fae69aa770670a8bcf8c3d3e706098deff2ca795cb88887a55bf", + "size": 81079, + "subdir": "linux-64", + "timestamp": 1600459127589, + "version": "3.2.3" + }, + "pytest-benchmark-3.2.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "md5": "f6676d2b03f59970525f004fe93b1408", + "name": "pytest-benchmark", + "sha256": "374d32390adc8d3696c7537e54fcd8511ce6ca6d2ce5d1f9786e560677760d47", + "size": 81025, + "subdir": "linux-64", + "timestamp": 1600459121140, + "version": "3.2.3" + }, + "pytest-benchmark-3.2.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-clause", + "md5": "38a2c2e26f93a3c27737c958ebdd58bd", + "name": "pytest-benchmark", + "sha256": "d22c7bb8e68b065612e478363d37ff23e7745eb82d98ba7a922420cbfaee237e", + "size": 81405, + "subdir": "linux-64", + "timestamp": 1600459127947, + "version": "3.2.3" + }, + "pytest-benchmark-3.4.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 2-clause", + "md5": "02989a54cac76dcba697632f6168cc2f", + "name": "pytest-benchmark", + "sha256": "b4ca663c3954cb084c817e8ddb10c87a30875a0d7c99a6881b2e0e8c9e0b29de", + "size": 83097, + "subdir": "linux-64", + "timestamp": 1640810563931, + "version": "3.4.1" + }, + "pytest-benchmark-3.4.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "4d13e3ad31ab00432c1993da8b389d6f", + "name": "pytest-benchmark", + "sha256": "a71c66c60d8956072ba077a37c117b142399fd5d1aa946ba9f3c4721b1b5d522", + "size": 85293, + "subdir": "linux-64", + "timestamp": 1651851675841, + "version": "3.4.1" + }, + "pytest-benchmark-3.4.1-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "3d69f8c53be9e53a502d0a33b5fc8698", + "name": "pytest-benchmark", + "sha256": "85b7a0394881bda99b6f0011f02b02305ce08c9237c5f2c28688294d4f4fd970", + "size": 113382, + "subdir": "linux-64", + "timestamp": 1676861334935, + "version": "3.4.1" + }, + "pytest-benchmark-3.4.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "md5": "d87fa2ce7bb98d97c1c7b81dd95ff756", + "name": "pytest-benchmark", + "sha256": "620ae61d573c3574824ba7dabb4c1644c879010e56fbc4f3544d25e4746cc790", + "size": 82146, + "subdir": "linux-64", + "timestamp": 1618692374755, + "version": "3.4.1" + }, + "pytest-benchmark-3.4.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "md5": "39e0dc58c78ab49bc96ea805ba9f852e", + "name": "pytest-benchmark", + "sha256": "d7812f7073b8a14ef236851da05c312ae839fb0cf75cfe80982ca7e7070ab25f", + "size": 82072, + "subdir": "linux-64", + "timestamp": 1618695618616, + "version": "3.4.1" + }, + "pytest-benchmark-3.4.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a2cfd98701521cbfd47296749d4ff0de", + "name": "pytest-benchmark", + "sha256": "eb5765c1508e92f16e873e9c86f6534355d4e101e8f14079c7b3d581c0769795", + "size": 84122, + "subdir": "linux-64", + "timestamp": 1651851663674, + "version": "3.4.1" + }, + "pytest-benchmark-3.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-clause", + "md5": "3ba0128dbbbc478e9a7f4bfe66b20099", + "name": "pytest-benchmark", + "sha256": "6cc606698bf62443cf9ae7a8566ff98f94712430a8f40513b5d96790f753cad0", + "size": 82496, + "subdir": "linux-64", + "timestamp": 1618695628820, + "version": "3.4.1" + }, + "pytest-benchmark-3.4.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "2b84e843fdb49054bd9b20875cace603", + "name": "pytest-benchmark", + "sha256": "1c45278d88f090ce9045e72ecbf129066f6d63f0e12286661597b49aef091866", + "size": 84641, + "subdir": "linux-64", + "timestamp": 1651833815272, + "version": "3.4.1" + }, + "pytest-benchmark-3.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-clause", + "md5": "0bce29c4cc15fac506d1126c7fbec1c8", + "name": "pytest-benchmark", + "sha256": "0b654e9414de12c562082fa2da06de18998d234baff54622a9ff4d94185c9c8b", + "size": 82532, + "subdir": "linux-64", + "timestamp": 1618798834629, + "version": "3.4.1" + }, + "pytest-benchmark-3.4.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "23a37742f5fbe590795e16d8e83d651e", + "name": "pytest-benchmark", + "sha256": "f7672f5bc069e7c96b3055e96a87f512fe8838463746d5893f569e33c42d9baf", + "size": 84679, + "subdir": "linux-64", + "timestamp": 1651851663504, + "version": "3.4.1" + }, + "pytest-cache-1.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "execnet >=1.1.dev1", + "pytest >=2.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f6db172459a2d4fe63a5b13e4be0804e", + "name": "pytest-cache", + "sha256": "50e17072edb173001b00d5446441bf6eabd1f6a9ce12762d5e9addaefcc38e84", + "size": 13269, + "subdir": "linux-64", + "timestamp": 1537811930920, + "version": "1.0" + }, + "pytest-cache-1.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "execnet >=1.1.dev1", + "pytest >=2.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "33e6577e68d5195876404e0d904ffe52", + "name": "pytest-cache", + "sha256": "1637792bf986cec2c234a02df82671831a996569818393bc675f066c03c3bced", + "size": 13469, + "subdir": "linux-64", + "timestamp": 1537811954796, + "version": "1.0" + }, + "pytest-cache-1.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "execnet >=1.1.dev1", + "pytest >=2.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b55f8933f620c229b1caf62350cdda90", + "name": "pytest-cache", + "sha256": "57b30adeb2f8864d9b380acfac4d2a6fcb4cea1bbcadcb3f608560d7de4b5014", + "size": 13441, + "subdir": "linux-64", + "timestamp": 1537811978772, + "version": "1.0" + }, + "pytest-cache-1.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "execnet >=1.1.dev1", + "pytest >=2.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ca76e154bcd229a8e7f5af266234bbd9", + "name": "pytest-cache", + "sha256": "66276d8878b956f375078ece3592e7b2b1e56c41d91926a8d3fcfa7c4f88ebdc", + "size": 13441, + "subdir": "linux-64", + "timestamp": 1537811889325, + "version": "1.0" + }, + "pytest-cov-2.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "615d9876585201f324b9065bf1ee8be3", + "name": "pytest-cov", + "sha256": "9c6b2ce247c043138ac1b156731974966041ccd77a375cbf468f9b98522ff9a5", + "size": 24740, + "subdir": "linux-64", + "timestamp": 1530694080682, + "version": "2.5.1" + }, + "pytest-cov-2.5.1-py27hc4181bb_0.tar.bz2": { + "build": "py27hc4181bb_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ed2b3467edf10d0a4250d20af07fb5fe", + "name": "pytest-cov", + "sha256": "02f1a914baeb530ed9468657d3e1f4eda30a94cafb2b7100cb5a3881e0301a8a", + "size": 24564, + "subdir": "linux-64", + "timestamp": 1505752481977, + "version": "2.5.1" + }, + "pytest-cov-2.5.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b3a9cc9e1d863b310a0401061ae9c859", + "name": "pytest-cov", + "sha256": "ceeb3fc32c49d19cde078ebaf8ec87a39a4a3bfca1db1736910283234cee80a6", + "size": 25144, + "subdir": "linux-64", + "timestamp": 1534345098490, + "version": "2.5.1" + }, + "pytest-cov-2.5.1-py35h9d7ae03_0.tar.bz2": { + "build": "py35h9d7ae03_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e1df0d111494914990f37a05a25e4f3", + "name": "pytest-cov", + "sha256": "5456ad22434246ddc4dfe850508fd2eb29a39108c3d4f90d6eda02dcac8584f3", + "size": 24963, + "subdir": "linux-64", + "timestamp": 1505752495777, + "version": "2.5.1" + }, + "pytest-cov-2.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0cdb34988a11c193976a0ba3169f1549", + "name": "pytest-cov", + "sha256": "1646fda6fa89fb9e042b25045a68513ffe97fdb260e7cf505a9f235757003562", + "size": 25081, + "subdir": "linux-64", + "timestamp": 1530694040525, + "version": "2.5.1" + }, + "pytest-cov-2.5.1-py36hd4733f3_0.tar.bz2": { + "build": "py36hd4733f3_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebace2a4eaa1b3d9a1e4c82cfb7d647e", + "name": "pytest-cov", + "sha256": "8d7f5279f07564d83490d8cd37065f1a0faa11728a1a015b5a97dfd7e0b0ce45", + "size": 24956, + "subdir": "linux-64", + "timestamp": 1505752509617, + "version": "2.5.1" + }, + "pytest-cov-2.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb5b4e6a632999ef7e8d7659e4257944", + "name": "pytest-cov", + "sha256": "cbbb87f771c432546689aea7d98944362783f871d5c68c051c7937d266b9f693", + "size": 25105, + "subdir": "linux-64", + "timestamp": 1530694060426, + "version": "2.5.1" + }, + "pytest-cov-2.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a1250ae1896aafe62c9e9d2f94fff433", + "name": "pytest-cov", + "sha256": "8e4ae98e308d3214e37f20d5ae097a347ccbee9661c9ac5643c02d18afdcedd7", + "size": 24369, + "subdir": "linux-64", + "timestamp": 1536102753293, + "version": "2.6.0" + }, + "pytest-cov-2.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "658acbc4bb336324572291ce134620e1", + "name": "pytest-cov", + "sha256": "3aaa8f92504a9c53d3802263187e95a235733ecbe547aa1d0c6ab192bb9064f4", + "size": 24825, + "subdir": "linux-64", + "timestamp": 1536102780247, + "version": "2.6.0" + }, + "pytest-cov-2.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e279c0acd19486055eb058a651c2915", + "name": "pytest-cov", + "sha256": "9f89a14c313de4d5a8b0ee73ba925ddd72f2056a0e7f6d7b8b03e15e947fba82", + "size": 24770, + "subdir": "linux-64", + "timestamp": 1536102703276, + "version": "2.6.0" + }, + "pytest-cov-2.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d79685281d84c638a842e56196a7fa13", + "name": "pytest-cov", + "sha256": "e9d6f2319bf56329b520f6a14c5345a497d19239cf57e4d42fe9f5c4a79f8b85", + "size": 24837, + "subdir": "linux-64", + "timestamp": 1536102787775, + "version": "2.6.0" + }, + "pytest-cov-2.6.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "963d94d7e0a3f553bb54a17f32120680", + "name": "pytest-cov", + "sha256": "2a4f7756b10ce537e15666cfdbc5499480f9db952bfdac94fa5f5dc5883118bd", + "size": 28800, + "subdir": "linux-64", + "timestamp": 1547477633871, + "version": "2.6.1" + }, + "pytest-cov-2.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "760e85aab19acd8b424b3165b7a7968c", + "name": "pytest-cov", + "sha256": "68adbae5122ef3a8509871468bc02b3693e3bfd4f2c62d2009c534550bb25894", + "size": 29217, + "subdir": "linux-64", + "timestamp": 1547477636508, + "version": "2.6.1" + }, + "pytest-cov-2.6.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9e140b6ee87b45935857059169028c3", + "name": "pytest-cov", + "sha256": "bb286cd146985315cd1db4471b6921007c6cf6578b975123d76d29fe0248b0ea", + "size": 29273, + "subdir": "linux-64", + "timestamp": 1547477674715, + "version": "2.6.1" + }, + "pytest-cov-4.0.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "coverage >=5.2.1", + "pytest >=4.6", + "python >=3.10,<3.11.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef21afdb3ad7eb4d7f5269c62de904d4", + "name": "pytest-cov", + "sha256": "cf99dc25a97d2e16c730f1fd9203ca6028767949a014a3d6029d15e54c2143b6", + "size": 33789, + "subdir": "linux-64", + "timestamp": 1680092847221, + "version": "4.0.0" + }, + "pytest-cov-4.0.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "coverage >=5.2.1", + "pytest >=4.6", + "python >=3.11,<3.12.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b66634c97dca593ba1f7859a0b14f4d5", + "name": "pytest-cov", + "sha256": "f8c8f7cfbeeb4465301f5e12d516b1fb38ab6b85d3e48e030a12e9996d308126", + "size": 41053, + "subdir": "linux-64", + "timestamp": 1680092789858, + "version": "4.0.0" + }, + "pytest-cov-4.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "coverage >=5.2.1", + "pytest >=4.6", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f7b52528266188334d4d9f1eb99c0b8", + "name": "pytest-cov", + "sha256": "6c10ce533cb622978384dcda3e9afa27710303c58cdef99f3bec681c13ce5e05", + "size": 33595, + "subdir": "linux-64", + "timestamp": 1680092760933, + "version": "4.0.0" + }, + "pytest-cov-4.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "coverage >=5.2.1", + "pytest >=4.6", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f00c57ea1cf6103ede66db822a1cecaa", + "name": "pytest-cov", + "sha256": "582097ebe1dae0364221816c3b89d96157777f2d7394bf453d4d9f0f20e01c7b", + "size": 33677, + "subdir": "linux-64", + "timestamp": 1680092818162, + "version": "4.0.0" + }, + "pytest-describe-2.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=4.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e50c15e91611a2b7ed01f51e58e63f72", + "name": "pytest-describe", + "sha256": "40a029c32e836a8b270d32057a817a828fb499270f576ce888ef83dd410db594", + "size": 14368, + "subdir": "linux-64", + "timestamp": 1669142581329, + "version": "2.0.1" + }, + "pytest-describe-2.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=4.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c8b4686d3574c8c93b152dc0109fa9b7", + "name": "pytest-describe", + "sha256": "7016ecf3ef513bce6a9b5d2ccd2ea4c2dcca736561d1b3a0a3ca99872b27a006", + "size": 16304, + "subdir": "linux-64", + "timestamp": 1676861351275, + "version": "2.0.1" + }, + "pytest-describe-2.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc7d108e1fda4d398022d12b191a7eb3", + "name": "pytest-describe", + "sha256": "f63f2ad7a0d506b34c94c08b99c7ef926ebe24913a1495b93d8c1b44510009e8", + "size": 14308, + "subdir": "linux-64", + "timestamp": 1669142636846, + "version": "2.0.1" + }, + "pytest-describe-2.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74557bda995247ea4df4c723d5643c9c", + "name": "pytest-describe", + "sha256": "2738c67c407765c5cda3eeaa74e35f9eae978261b92e63dd248860f1280f1f02", + "size": 14322, + "subdir": "linux-64", + "timestamp": 1669142609023, + "version": "2.0.1" + }, + "pytest-describe-2.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=4.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9eabd2a78fbcef38fb0aff20f85804bd", + "name": "pytest-describe", + "sha256": "7e95d0bbe5ba103ba3f0bce42eee16ddcb388cf6e0edb0e12c1eccccb878a885", + "size": 14350, + "subdir": "linux-64", + "timestamp": 1669142664717, + "version": "2.0.1" + }, + "pytest-doctestplus-0.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.8", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "8be8199c937cc1182e37cb67f743d97f", + "name": "pytest-doctestplus", + "sha256": "2d299d54af8d398f3bfb906c913f7846438e526a105e9eaf1ebe5b21f0991258", + "size": 19396, + "subdir": "linux-64", + "timestamp": 1518731379551, + "version": "0.1.2" + }, + "pytest-doctestplus-0.1.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.8", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD", + "md5": "9c40153350d52e22d38d033ee036614e", + "name": "pytest-doctestplus", + "sha256": "68c33ddd3045ad8b9cb620334cee7457d00f5c382b24f279102c2ccacb2cc0bd", + "size": 19704, + "subdir": "linux-64", + "timestamp": 1518731403282, + "version": "0.1.2" + }, + "pytest-doctestplus-0.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.8", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "f1013caecbde8ce8a61a6d3703733d2b", + "name": "pytest-doctestplus", + "sha256": "a165a8b1fc3c8297e77245b235dce92225b3ef6502cf5e6504cd277b973b913b", + "size": 19613, + "subdir": "linux-64", + "timestamp": 1518731401037, + "version": "0.1.2" + }, + "pytest-doctestplus-0.1.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "1a848d1c9fc7d149c3a00648936d6c73", + "name": "pytest-doctestplus", + "sha256": "38bd986383a0e715a39857c4c8b26bd6f060674a95281dc132f7bc07eef9c0cc", + "size": 19339, + "subdir": "linux-64", + "timestamp": 1524577919992, + "version": "0.1.3" + }, + "pytest-doctestplus-0.1.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD", + "md5": "90984218f082207d35c1facc985b056f", + "name": "pytest-doctestplus", + "sha256": "ebe3de7aff440053a9060acc72c797df2b85b9e4a520a33041e92c4034b4c5ec", + "size": 19644, + "subdir": "linux-64", + "timestamp": 1524577975550, + "version": "0.1.3" + }, + "pytest-doctestplus-0.1.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "86a18b5b8cf39c283c56e8cb356bd1da", + "name": "pytest-doctestplus", + "sha256": "4d2fcabd17b5016a22c5a8a2b3c68929f8d914518ebc76c599fe8d12415f89e8", + "size": 19613, + "subdir": "linux-64", + "timestamp": 1524577923044, + "version": "0.1.3" + }, + "pytest-doctestplus-0.1.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD", + "md5": "36042342bdfee65ec0e38178d2a9b173", + "name": "pytest-doctestplus", + "sha256": "2f198123a5204a29f34a6a25df69f9275cde659334ca9fb6a94c8e80a02b23c4", + "size": 19859, + "subdir": "linux-64", + "timestamp": 1530738047938, + "version": "0.1.3" + }, + "pytest-doctestplus-0.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "975751a96222d71607745a4b42165951", + "name": "pytest-doctestplus", + "sha256": "2351f26ff6c3e609d63e416befeac3b4d7347499a517aaa59bc0245153df1bc7", + "size": 21227, + "subdir": "linux-64", + "timestamp": 1542391318146, + "version": "0.2.0" + }, + "pytest-doctestplus-0.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "cedf278bcad206321b8ff26f7831c39c", + "name": "pytest-doctestplus", + "sha256": "a312831917bd0887273dbe09f7d2fe1e8db1bf51cb1b27111d1d5ce9b38ce315", + "size": 21463, + "subdir": "linux-64", + "timestamp": 1542391312634, + "version": "0.2.0" + }, + "pytest-doctestplus-0.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD", + "md5": "6ef206e5f6686f449c1f48beb735e08e", + "name": "pytest-doctestplus", + "sha256": "a565f14cee3325d44bd67224228654c9f27475dbde670aadd3f255ddb16faf98", + "size": 21556, + "subdir": "linux-64", + "timestamp": 1542391281847, + "version": "0.2.0" + }, + "pytest-doctestplus-0.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "e0547d0152872515d417084891d22d14", + "name": "pytest-doctestplus", + "sha256": "f4e0cfec2c2ad6e14a3a52b2d525344ad81e7a4c0f3a52c83da861928154a4e2", + "size": 23543, + "subdir": "linux-64", + "timestamp": 1552446376918, + "version": "0.3.0" + }, + "pytest-doctestplus-0.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "41621ef15385f36e83037b70c8f4533b", + "name": "pytest-doctestplus", + "sha256": "7f170896492abf0253ae89b7c0f6182be121909c33bd87549c82b4bc06f283e8", + "size": 23807, + "subdir": "linux-64", + "timestamp": 1552446330592, + "version": "0.3.0" + }, + "pytest-doctestplus-0.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD", + "md5": "7efee68784a2c26dd3e72958b1e77bae", + "name": "pytest-doctestplus", + "sha256": "adb850c623102e6c9135dba37d1dd05b149ead35e58b45ae1e463b5d809b2fa6", + "size": 23867, + "subdir": "linux-64", + "timestamp": 1552446829802, + "version": "0.3.0" + }, + "pytest-forked-0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "65957a9b24affe3e99ef4f49904743f9", + "name": "pytest-forked", + "sha256": "b4826ed8a79a43a3b9a6824adecbac4d6a5c2c5154681e4833a910ac3064f629", + "size": 8243, + "subdir": "linux-64", + "timestamp": 1530727774984, + "version": "0.2" + }, + "pytest-forked-0.2-py27h9339617_0.tar.bz2": { + "build": "py27h9339617_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "3c9766be8931ba8b8ac893906b354b3e", + "name": "pytest-forked", + "sha256": "c45c4cdf4ccfef62df7958ac740d1738d74efd409ce1093ddb949064c0cb51eb", + "size": 8879, + "subdir": "linux-64", + "timestamp": 1511987650545, + "version": "0.2" + }, + "pytest-forked-0.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "087a23228ef698446d02e96faee2476a", + "name": "pytest-forked", + "sha256": "7c38b5cac9a149644eb7ccea281d612351531a1f95b080000f399f93d304a0ec", + "size": 8310, + "subdir": "linux-64", + "timestamp": 1534347509642, + "version": "0.2" + }, + "pytest-forked-0.2-py35hc748f2f_0.tar.bz2": { + "build": "py35hc748f2f_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "e12ae125683a4253060560443d6aa660", + "name": "pytest-forked", + "sha256": "5c916f51081cb84108a806729e2f976c2eea5febf758783c4b928420d7c954de", + "size": 8976, + "subdir": "linux-64", + "timestamp": 1511987644628, + "version": "0.2" + }, + "pytest-forked-0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "79db8a09519208076f9380970f3fad56", + "name": "pytest-forked", + "sha256": "6e212d7c9f83a65dc22e0970b25fdb29c730b00fe43bf4b1913250c4c03e12a6", + "size": 8339, + "subdir": "linux-64", + "timestamp": 1530727817342, + "version": "0.2" + }, + "pytest-forked-0.2-py36h09594ab_0.tar.bz2": { + "build": "py36h09594ab_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "5caf5fe9e89346d85c18798e2c38ee95", + "name": "pytest-forked", + "sha256": "f3d01542a289c3dd213bc06d83155ceb11fe41abbcf3e8be4b5544624733cf53", + "size": 8917, + "subdir": "linux-64", + "timestamp": 1511987666358, + "version": "0.2" + }, + "pytest-forked-0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5a2871bb3372428af1df41ea0e45fd10", + "name": "pytest-forked", + "sha256": "826c24cd749f4b5cf1925d0de8db322d29e76a442ad85a83e149e90289de2af9", + "size": 8363, + "subdir": "linux-64", + "timestamp": 1530727795784, + "version": "0.2" + }, + "pytest-forked-1.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "01e2119d81e5ee8a5b12fdec75ce8510", + "name": "pytest-forked", + "sha256": "4800937a95c689dff09aed3017dfd277095ab880f557cdd53ea4ba6da8ff49e4", + "size": 10138, + "subdir": "linux-64", + "timestamp": 1550355075044, + "version": "1.0.2" + }, + "pytest-forked-1.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "028c9941b2ed6347f320fa5f4dd09cb0", + "name": "pytest-forked", + "sha256": "0dc8d3b9c96465501bbc3cea993283df1b0267c348415dd7b1988f7a5c4a3d25", + "size": 10222, + "subdir": "linux-64", + "timestamp": 1550355066607, + "version": "1.0.2" + }, + "pytest-forked-1.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1a23389f310890bc2660e47391c1d8f3", + "name": "pytest-forked", + "sha256": "595a2355b08b9ee0585b67cd0ffc51d7b4d045d44e140de50b806f82b828da71", + "size": 10238, + "subdir": "linux-64", + "timestamp": 1550355022471, + "version": "1.0.2" + }, + "pytest-html-1.16.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "2b97c3f1580e1add19c0a74455b80e69", + "name": "pytest-html", + "sha256": "6176afd8fd756a47fa65c6cd32628890dcdfb91a1bce8cc69fc72a984a14eee4", + "size": 22162, + "subdir": "linux-64", + "timestamp": 1518721499130, + "version": "1.16.0" + }, + "pytest-html-1.16.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "d92e5d071b8185739db6faa5029225b0", + "name": "pytest-html", + "sha256": "302e68d07b08225503a252e3e995b5dadad8f0d3231213a24305d801a8849cfd", + "size": 22542, + "subdir": "linux-64", + "timestamp": 1518721704476, + "version": "1.16.0" + }, + "pytest-html-1.16.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "f350a246a2db0d53b444fd2a645f3012", + "name": "pytest-html", + "sha256": "f9bf22b613262e03f68fc3760b256f190bff0421c4bf28d27ee2207994167dd9", + "size": 22441, + "subdir": "linux-64", + "timestamp": 1518721478800, + "version": "1.16.0" + }, + "pytest-html-1.16.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "eddb0d1001e026de8128b7185ebfb937", + "name": "pytest-html", + "sha256": "2da91ae2618d420ce54304078b9afb3a0723746d39722aba299d4e04771ec06a", + "size": 22325, + "subdir": "linux-64", + "timestamp": 1522194660182, + "version": "1.16.1" + }, + "pytest-html-1.16.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "92d8347997593811034a4e9ca0944b27", + "name": "pytest-html", + "sha256": "8c9687dfee0f436d40f6ddd9dc9a1a2628371843df72727ffac84cd9162634ee", + "size": 22673, + "subdir": "linux-64", + "timestamp": 1522194662618, + "version": "1.16.1" + }, + "pytest-html-1.16.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "e252f5164a4e9e0add0bfe1cfb54236c", + "name": "pytest-html", + "sha256": "e9c2c2b9bc350b8a8d5f5487e390135dd31d1c541708e10fe64c380bbd976c81", + "size": 22641, + "subdir": "linux-64", + "timestamp": 1522194662861, + "version": "1.16.1" + }, + "pytest-html-1.17.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "a20752a62c721c103c0817035649e9a6", + "name": "pytest-html", + "sha256": "ceeada93dc9319fd585c359bbe5fa007393443c63ba4731256b5363693d20bb1", + "size": 23171, + "subdir": "linux-64", + "timestamp": 1524086590598, + "version": "1.17.0" + }, + "pytest-html-1.17.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "4672229a67d435c5ac94076626a2f85a", + "name": "pytest-html", + "sha256": "a414f2067b9882660070c88ea7f2ca86b1669c140f821d5b50f9eb32af03b6c7", + "size": 23537, + "subdir": "linux-64", + "timestamp": 1524086610474, + "version": "1.17.0" + }, + "pytest-html-1.17.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "dc51152e35ed148170991201e50c28f4", + "name": "pytest-html", + "sha256": "c39f41268caadb66564871e079ba4c85119fbb8b90554d47503ed69806bfbc47", + "size": 23471, + "subdir": "linux-64", + "timestamp": 1524086530808, + "version": "1.17.0" + }, + "pytest-html-1.18.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "1dcb34d1e2fbfc68f4f9258ef1ab208d", + "name": "pytest-html", + "sha256": "a6d49620fbef529f4dca3501c14e1e8d1faea7f497eb2d5aeb221a8be6f2ee61", + "size": 23719, + "subdir": "linux-64", + "timestamp": 1527702082988, + "version": "1.18.0" + }, + "pytest-html-1.18.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "e794e467c34bcc1cfc844b9548717a68", + "name": "pytest-html", + "sha256": "8744c5fece250fb4cdea7deeb5a35d09102754fb265017b5dbdc81410fc5f393", + "size": 24079, + "subdir": "linux-64", + "timestamp": 1527702114061, + "version": "1.18.0" + }, + "pytest-html-1.18.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "fe90d3d530b73c3a5273e8affd1ae305", + "name": "pytest-html", + "sha256": "66304f4fa92b500fe639c06becde2b9d769433222d084a9efa8d78d733b32e4b", + "size": 24112, + "subdir": "linux-64", + "timestamp": 1527702060977, + "version": "1.18.0" + }, + "pytest-html-1.19.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "b9344f40b16ffc05150efcea8c9d7160", + "name": "pytest-html", + "sha256": "3e0fde79a33801141b32341abcf48852e515629897bc322bb63cffd0104fb8de", + "size": 23948, + "subdir": "linux-64", + "timestamp": 1528148538647, + "version": "1.19.0" + }, + "pytest-html-1.19.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "8c64a4cf4fd45c33fbb35169a1a892b1", + "name": "pytest-html", + "sha256": "b84f2ad1497a91264cbb15a1d7db1f6420a414cb667930d4dca33ddbc8ba1ff9", + "size": 24421, + "subdir": "linux-64", + "timestamp": 1528148619742, + "version": "1.19.0" + }, + "pytest-html-1.19.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "9d8d8c217d26f995684dd4b556ea6420", + "name": "pytest-html", + "sha256": "48cd7ac1d254f6b13d89778cd50380341bf2dfa252c8d685fca28b576516b11e", + "size": 24383, + "subdir": "linux-64", + "timestamp": 1528148563447, + "version": "1.19.0" + }, + "pytest-html-1.19.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "d3eb17032bfba03e8b847a764be4586f", + "name": "pytest-html", + "sha256": "abf9d44de56beec137df481c11060d186bf5812303ad8372677364990fa49026", + "size": 24376, + "subdir": "linux-64", + "timestamp": 1530922303764, + "version": "1.19.0" + }, + "pytest-html-1.20.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "86fa65993f254883a645083907790b2e", + "name": "pytest-html", + "sha256": "4133651eb5f7ac838fc426a8a1948c4f8a67240c6e8f2029eff26abe40e0d599", + "size": 26580, + "subdir": "linux-64", + "timestamp": 1552447406739, + "version": "1.20.0" + }, + "pytest-html-1.20.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "a322a22b140bb7344b7c0b8a8316ea62", + "name": "pytest-html", + "sha256": "510eb35a7e19f44d7e44b2779f578ea90586b525afe1cb480fcf7436b6c3df5c", + "size": 26937, + "subdir": "linux-64", + "timestamp": 1552447260263, + "version": "1.20.0" + }, + "pytest-html-1.20.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "8cc02d5c6030a0222239d32f04de5009", + "name": "pytest-html", + "sha256": "4ffdc9e3ad6a44e6ace24145154030300858c5ae4fd8d7263931a71969cd5d1b", + "size": 26967, + "subdir": "linux-64", + "timestamp": 1552446806409, + "version": "1.20.0" + }, + "pytest-json-0.4.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pytest >=2.3", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8da3587e04893d67519bad378479d7b7", + "name": "pytest-json", + "sha256": "3871c7e38209d840e9568fff4a53584f00e2a79c7886e189fcc91a1570357dc7", + "size": 11953, + "subdir": "linux-64", + "timestamp": 1536866441633, + "version": "0.4.0" + }, + "pytest-json-0.4.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "pytest >=2.3", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "395fcdc9e672e02db4057df5f29a2fad", + "name": "pytest-json", + "sha256": "163a193af6cfd6d5e010c4b2e9adf2142c7275d408e81318c51b33e1b2448c7d", + "size": 12137, + "subdir": "linux-64", + "timestamp": 1536866501808, + "version": "0.4.0" + }, + "pytest-json-0.4.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pytest >=2.3", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c65ad5d1cd72be8503779a74f7f54f6", + "name": "pytest-json", + "sha256": "7981354f430db5ab4b3f40498dfd95adde83dccea788f4b8cc2ecf00d79ed6bd", + "size": 12114, + "subdir": "linux-64", + "timestamp": 1536866499032, + "version": "0.4.0" + }, + "pytest-json-0.4.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pytest >=2.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4cba1166051cfd175ba0b589595c5e1", + "name": "pytest-json", + "sha256": "eecf40084e3f2f9169f2b3d71979a9b0840d369ccb8d23853f296ba260a92cc4", + "size": 12129, + "subdir": "linux-64", + "timestamp": 1536866441111, + "version": "0.4.0" + }, + "pytest-jupyter-0.6.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "ipykernel >=6.14", + "jupyter_client >=7.4.0", + "jupyter_server >=1.21", + "nbformat >=5.3" + ], + "depends": [ + "jupyter_core", + "pytest", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "441892a7780de8b5323173a27b4df3cc", + "name": "pytest-jupyter", + "sha256": "6d041a321396b39941633eb89cf1e09fdf3931e671e520c0f13705729dc08ebf", + "size": 28103, + "subdir": "linux-64", + "timestamp": 1680012155002, + "version": "0.6.2" + }, + "pytest-jupyter-0.6.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "ipykernel >=6.14", + "jupyter_client >=7.4.0", + "jupyter_server >=1.21", + "nbformat >=5.3" + ], + "depends": [ + "jupyter_core", + "pytest", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dde49c69936f3698b1bff6102ae81af9", + "name": "pytest-jupyter", + "sha256": "ef1c89803434594df15ee567ff6296e99255bce70c5a5a70285c9ebe000e826d", + "size": 33634, + "subdir": "linux-64", + "timestamp": 1680011992860, + "version": "0.6.2" + }, + "pytest-jupyter-0.6.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "ipykernel >=6.14", + "jupyter_client >=7.4.0", + "jupyter_server >=1.21", + "nbformat >=5.3" + ], + "depends": [ + "jupyter_core", + "pytest", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6bc5a89ef153fb9c08b4af94ec1de49c", + "name": "pytest-jupyter", + "sha256": "d87a7301faed70f656b18ad399e17045699e15dc78b9f25005e6bf2c66872025", + "size": 27892, + "subdir": "linux-64", + "timestamp": 1680012072100, + "version": "0.6.2" + }, + "pytest-jupyter-0.6.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "ipykernel >=6.14", + "jupyter_client >=7.4.0", + "jupyter_server >=1.21", + "nbformat >=5.3" + ], + "depends": [ + "jupyter_core", + "pytest", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "632d220ae5b580f4c89d5e426de28604", + "name": "pytest-jupyter", + "sha256": "a0370491f0f0ea6fa6a8a8a843e3d3512080c47bc121c93c26e1823c4d1012ea", + "size": 27926, + "subdir": "linux-64", + "timestamp": 1680011910846, + "version": "0.6.2" + }, + "pytest-jupyter-client-0.6.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "jupyter_client >=7.4.0", + "pytest-jupyter >=0.6.2,<0.6.3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b4a37edd98418e4d4d605e5eecfb63fd", + "name": "pytest-jupyter-client", + "sha256": "9582f87c5b66ce8727f027a70fc718e7c8bc2554b4d108037fe23a622a6d0cf6", + "size": 5961, + "subdir": "linux-64", + "timestamp": 1680012161729, + "version": "0.6.2" + }, + "pytest-jupyter-client-0.6.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "jupyter_client >=7.4.0", + "pytest-jupyter >=0.6.2,<0.6.3.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5e0eeec91cc9f734727623e443c54692", + "name": "pytest-jupyter-client", + "sha256": "450ff4c3f81272ea1aa32644e86838198a6e8d11568e4d3f1043717d91f1e8d6", + "size": 5969, + "subdir": "linux-64", + "timestamp": 1680011999786, + "version": "0.6.2" + }, + "pytest-jupyter-client-0.6.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "jupyter_client >=7.4.0", + "pytest-jupyter >=0.6.2,<0.6.3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "19d6bb559fa2f33811aa530232e62fd1", + "name": "pytest-jupyter-client", + "sha256": "08ab9f4402e35b8a4e8512c0ed3a70b28d856872f56e5b190eba8e37842a997d", + "size": 5936, + "subdir": "linux-64", + "timestamp": 1680012078416, + "version": "0.6.2" + }, + "pytest-jupyter-client-0.6.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "jupyter_client >=7.4.0", + "pytest-jupyter >=0.6.2,<0.6.3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e0be92892cee3acc09a148ce94c77aa4", + "name": "pytest-jupyter-client", + "sha256": "7471cdef6b5f135c8de04bb6f33e9f0eae035cf31e47e5bcfda5c2f6efef4404", + "size": 5905, + "subdir": "linux-64", + "timestamp": 1680011917415, + "version": "0.6.2" + }, + "pytest-jupyter-server-0.6.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_server >=1.21", + "nbformat >=5.3", + "pytest-jupyter-client >=0.6.2,<0.6.3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "542ca1cab2983531eb07d518ffc6272f", + "name": "pytest-jupyter-server", + "sha256": "35b9a6ff23c81c8ef1ed874170a6a27dcdf98cca9ecd328ec2b732320e74de1b", + "size": 7096, + "subdir": "linux-64", + "timestamp": 1680012168386, + "version": "0.6.2" + }, + "pytest-jupyter-server-0.6.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_server >=1.21", + "nbformat >=5.3", + "pytest-jupyter-client >=0.6.2,<0.6.3.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2f00ed0091b8d47b58a1210986f3240b", + "name": "pytest-jupyter-server", + "sha256": "a4b644b89ec8db6825b6630feb5ac6a07258b093a698ff0ea2da5079705f7da8", + "size": 7121, + "subdir": "linux-64", + "timestamp": 1680012006602, + "version": "0.6.2" + }, + "pytest-jupyter-server-0.6.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_server >=1.21", + "nbformat >=5.3", + "pytest-jupyter-client >=0.6.2,<0.6.3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7bb7bf68e0034ea615ad5556b43b9127", + "name": "pytest-jupyter-server", + "sha256": "44c756e6d47d79bf474575e5764e5fb70bb8c444d55dde83b3996d3b547b8fe7", + "size": 7088, + "subdir": "linux-64", + "timestamp": 1680012084612, + "version": "0.6.2" + }, + "pytest-jupyter-server-0.6.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_server >=1.21", + "nbformat >=5.3", + "pytest-jupyter-client >=0.6.2,<0.6.3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b7b2ef48c9020a3a2ee8503c081e4c9a", + "name": "pytest-jupyter-server", + "sha256": "3bd0f2b43285073e782cc571789d853c498b9b33183f03d10bf6cc44d27050ca", + "size": 7091, + "subdir": "linux-64", + "timestamp": 1680011923653, + "version": "0.6.2" + }, + "pytest-metadata-1.10.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "a0ccf6e72242365a081cb795482d10f1", + "name": "pytest-metadata", + "sha256": "f1ecf41a807797adc7e12f9ac2817f9bd51ce00cef63baad5add940c7d14a06a", + "size": 13909, + "subdir": "linux-64", + "timestamp": 1593444339680, + "version": "1.10.0" + }, + "pytest-metadata-1.10.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "90cb754672e76f1a546af4b75292c11e", + "name": "pytest-metadata", + "sha256": "2eeb15f626dce347f998834492a29d681ec5da8e9ffff3e440d4a3146cafc986", + "size": 13925, + "subdir": "linux-64", + "timestamp": 1593444348742, + "version": "1.10.0" + }, + "pytest-metadata-1.10.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "38cdbe699f917183c239e429d05423f6", + "name": "pytest-metadata", + "sha256": "d136875d6946f0300e0cab1432e6e220fcc53f942cad6d7343e7b11c920d770d", + "size": 13941, + "subdir": "linux-64", + "timestamp": 1593444328796, + "version": "1.10.0" + }, + "pytest-metadata-1.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "1e06b0c724e3c859856a6863805e7afe", + "name": "pytest-metadata", + "sha256": "bee380749815306d4a263b6a03e3ef298d897a5991a0183b60ef22eb626cbc36", + "size": 13211, + "subdir": "linux-64", + "timestamp": 1640810584664, + "version": "1.11.0" + }, + "pytest-metadata-1.11.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "37b382c2a76a21ba33a64188eac3c038", + "name": "pytest-metadata", + "sha256": "6accb96b98065f4a033b614dc34b1f1f94557422d245b78f9caa00523e35f46c", + "size": 14837, + "subdir": "linux-64", + "timestamp": 1676861366412, + "version": "1.11.0" + }, + "pytest-metadata-1.11.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "512b6b1b34336eb0141d4d5a5157d7fd", + "name": "pytest-metadata", + "sha256": "4f0faece1aa3960a208df454d854f67edfad716cecfbf20ffab654f254e42632", + "size": 13396, + "subdir": "linux-64", + "timestamp": 1606518013213, + "version": "1.11.0" + }, + "pytest-metadata-1.11.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "5a5eda1739cf84e4fcbc40804c6ee3e5", + "name": "pytest-metadata", + "sha256": "5e4a553899e0a8ba5633a1e0f20ee347384d04d381b26754691dd06b549d23da", + "size": 13368, + "subdir": "linux-64", + "timestamp": 1606517992092, + "version": "1.11.0" + }, + "pytest-metadata-1.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "eeb83e7663b1aed3c670a5aedb447e5f", + "name": "pytest-metadata", + "sha256": "c332adcfa9f8a6c643c8ac57e36adbdbfa279565ad2220931b522af5c0719b46", + "size": 13355, + "subdir": "linux-64", + "timestamp": 1606518038858, + "version": "1.11.0" + }, + "pytest-metadata-1.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "381a99b5947766344be275a8e94c957b", + "name": "pytest-metadata", + "sha256": "29731342c8093555a3137fb8e7b4ea74a44352b74935f96cebb16e9c388b6c67", + "size": 13248, + "subdir": "linux-64", + "timestamp": 1606518029640, + "version": "1.11.0" + }, + "pytest-metadata-1.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "cbc440dfb2e5f5e0c590e1000a70fd96", + "name": "pytest-metadata", + "sha256": "55608efe22cff22113efc412b44f4a5a20e05eb6f2564f3f706ec45ddd8dda6e", + "size": 11134, + "subdir": "linux-64", + "timestamp": 1518721209565, + "version": "1.5.1" + }, + "pytest-metadata-1.5.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "e64f9c8769e3ab1d46e1a4b6d5674ad4", + "name": "pytest-metadata", + "sha256": "206d691e0d1264956251cef1c16833edc368541e6c418bd55f854298d008be12", + "size": 11315, + "subdir": "linux-64", + "timestamp": 1518721361019, + "version": "1.5.1" + }, + "pytest-metadata-1.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "dd0275e1cc578b15614f5e153f241fe6", + "name": "pytest-metadata", + "sha256": "8e83dbfd62072207943b1a2ae14aba22d5bc236ec8020fb13b91c332c7435403", + "size": 11302, + "subdir": "linux-64", + "timestamp": 1518721284902, + "version": "1.5.1" + }, + "pytest-metadata-1.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "3364738b3c4194c7f0866cf54353661f", + "name": "pytest-metadata", + "sha256": "2817835f5cdd9dce2c5b1d85b19293662bf24430942b8b59f584f11491031e10", + "size": 11342, + "subdir": "linux-64", + "timestamp": 1519482810078, + "version": "1.6.0" + }, + "pytest-metadata-1.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "369551d7b81e7348927b49a2a5958457", + "name": "pytest-metadata", + "sha256": "d228b4c5ac2122fb2571de17c9edf685176fe523edf1154fcdd7aba36f66862f", + "size": 11528, + "subdir": "linux-64", + "timestamp": 1519482837012, + "version": "1.6.0" + }, + "pytest-metadata-1.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "46bbdcaf272cda9fd26b2049d27a2ad3", + "name": "pytest-metadata", + "sha256": "df9ef890de9601402d4823cbfd0e8300fccdcf78dfa7503a581e34e7abb02e59", + "size": 11523, + "subdir": "linux-64", + "timestamp": 1519482768516, + "version": "1.6.0" + }, + "pytest-metadata-1.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "e07cbb27cea13db1fbb25e94df093bfe", + "name": "pytest-metadata", + "sha256": "733b5a7982603b37dcea03c209fb686040fbe38367a4ad6899f917f6c9e6f8b5", + "size": 11799, + "subdir": "linux-64", + "timestamp": 1524086416406, + "version": "1.7.0" + }, + "pytest-metadata-1.7.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "cf3eac371b5db3714c9ec79ab1a14321", + "name": "pytest-metadata", + "sha256": "b055274a2ef284d5e650090d4acf77f05be4abdf2cc8ed2e2285db2bc497b717", + "size": 11995, + "subdir": "linux-64", + "timestamp": 1524086441748, + "version": "1.7.0" + }, + "pytest-metadata-1.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "126ff5d224521236c0644bf366bf4c24", + "name": "pytest-metadata", + "sha256": "91b3aa335ee79225843251281f521e78e04bb7e5f662778d0c196614d1426f13", + "size": 11982, + "subdir": "linux-64", + "timestamp": 1524086368315, + "version": "1.7.0" + }, + "pytest-metadata-1.7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "15d1969aaa9838b31576950f8ad8dab2", + "name": "pytest-metadata", + "sha256": "898add4b70e118c8173876bd0cbaeecd0d9ee6b9b7fdfd6342f7e1fdded5b0b9", + "size": 11913, + "subdir": "linux-64", + "timestamp": 1530922264829, + "version": "1.7.0" + }, + "pytest-metadata-1.7.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "d5f684895857946e1eb72924d76f2405", + "name": "pytest-metadata", + "sha256": "d15e7c9e5e5f7390326661e10c234bd706465555816f6701def25c36b737113b", + "size": 12421, + "subdir": "linux-64", + "timestamp": 1574169740680, + "version": "1.7.0" + }, + "pytest-metadata-1.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "dd9a7a99e90856c4c6930e82d0636551", + "name": "pytest-metadata", + "sha256": "631287ef5eff8c84917aad86dc5f35e9cb450893894e581e4c37ad829b7c6ebb", + "size": 13718, + "subdir": "linux-64", + "timestamp": 1547478090243, + "version": "1.8.0" + }, + "pytest-metadata-1.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "cd1f7db5851c29157b0fe7d553fb6222", + "name": "pytest-metadata", + "sha256": "30a476bfd81dbbaec3d42dac7b3bcc205dd4fcd197ff42e5570b9065c0b81975", + "size": 13887, + "subdir": "linux-64", + "timestamp": 1547478161945, + "version": "1.8.0" + }, + "pytest-metadata-1.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "382554774b5b8ecb7f51ff7be0388d65", + "name": "pytest-metadata", + "sha256": "dd8d0c85a8de0d8f10c2608318606fd2695c3e0ddb856c526b609c1cae300fec", + "size": 13894, + "subdir": "linux-64", + "timestamp": 1547478159235, + "version": "1.8.0" + }, + "pytest-mock-1.10.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mock", + "pytest >=2.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "dce73351c00a44e77d2b832b123bf4bf", + "name": "pytest-mock", + "sha256": "0b30588f338dae4cdad40b00d2c86e839a5f837b57fa5fe6e6c7d4c6dbf17103", + "size": 18224, + "subdir": "linux-64", + "timestamp": 1526919160559, + "version": "1.10.0" + }, + "pytest-mock-1.10.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "71ae69aa8e674ea5253ff59bfc0b5b8b", + "name": "pytest-mock", + "sha256": "a6d396aa77db1408d9c05afc5d2de510c847c3d73f0ba65a987ac441c4113bec", + "size": 18434, + "subdir": "linux-64", + "timestamp": 1526919208136, + "version": "1.10.0" + }, + "pytest-mock-1.10.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8bb890a9401380f66292e7e8b78d36a6", + "name": "pytest-mock", + "sha256": "277b9fbe795a272f6e2173d9eb93d095001f0237dadeba6028634d6ba40ba9c9", + "size": 18426, + "subdir": "linux-64", + "timestamp": 1526919132331, + "version": "1.10.0" + }, + "pytest-mock-1.10.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ced2868c2e49a7b13befb297f545adaf", + "name": "pytest-mock", + "sha256": "828c62ba02aa2d5f79b4b90f551619961a6279c3d0901362268df6bc23a2151c", + "size": 18510, + "subdir": "linux-64", + "timestamp": 1530922343673, + "version": "1.10.0" + }, + "pytest-mock-1.10.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mock", + "pytest >=2.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "03fefad5f6d43c9b552e491d4dc4fd58", + "name": "pytest-mock", + "sha256": "4ba4eb0736ad432100a78523b6d97b467d2e017b1397a1dfdb19d724b8a5a1c2", + "size": 22363, + "subdir": "linux-64", + "timestamp": 1552364878001, + "version": "1.10.1" + }, + "pytest-mock-1.10.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7128dc2e26c84d31eb0d4e9c8d2c84d3", + "name": "pytest-mock", + "sha256": "a28bf330359a2ad2697bca16888889a610fadd3c2104fcbcd789c452c8225965", + "size": 22578, + "subdir": "linux-64", + "timestamp": 1552364905673, + "version": "1.10.1" + }, + "pytest-mock-1.10.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2a6009c29cadd00b91acfd8393733cae", + "name": "pytest-mock", + "sha256": "5f285a3140deb1903cba1017f5147ccaa9419176dcf3e4fc33dcc058ff64f81d", + "size": 22602, + "subdir": "linux-64", + "timestamp": 1552364808991, + "version": "1.10.1" + }, + "pytest-mock-1.10.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mock", + "pytest >=2.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "51b85657c32b0c533fe68d82394cae25", + "name": "pytest-mock", + "sha256": "7387410df064f4880aed74395e101de0e36366d113f1966a7303827c3c95f1c8", + "size": 23361, + "subdir": "linux-64", + "timestamp": 1556071736194, + "version": "1.10.4" + }, + "pytest-mock-1.10.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e44d82f3a9b1c36f73b6414b11765cfb", + "name": "pytest-mock", + "sha256": "71f508a0d086c8b521b32b41d9ff576fcbe8b7eb266ac90f3e6d28dc4ff9413b", + "size": 23552, + "subdir": "linux-64", + "timestamp": 1556071612830, + "version": "1.10.4" + }, + "pytest-mock-1.10.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8bb97b8b62415158663127d62f04aaa5", + "name": "pytest-mock", + "sha256": "70971be18f203f6d0895e827fb4ad0c8074a3ec576c6fecc38c6f59c7c87c82c", + "size": 23619, + "subdir": "linux-64", + "timestamp": 1556071576206, + "version": "1.10.4" + }, + "pytest-mock-1.11.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mock", + "pytest >=2.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f89e99b035384a2cbeac9bf2ca83e1ba", + "name": "pytest-mock", + "sha256": "5b3f4bd6e6848de0ff855aee2f36f28571d86e09b55551e857d1a4fe04b5ca6c", + "size": 25458, + "subdir": "linux-64", + "timestamp": 1573237710161, + "version": "1.11.2" + }, + "pytest-mock-1.11.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d324b5b9570aae64ad1a1eec877e7801", + "name": "pytest-mock", + "sha256": "d928433d7df5bf43b6312a5b509487a27ef9f508404f9161c84d419c2b3bbe2c", + "size": 25778, + "subdir": "linux-64", + "timestamp": 1573237712757, + "version": "1.11.2" + }, + "pytest-mock-1.11.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1bcbee42da17ebd1775fb8bedb38b683", + "name": "pytest-mock", + "sha256": "25f962d7878560d793ce6a56d4863ce42c0f6847b4eaad2caed0a5476da74dcc", + "size": 25791, + "subdir": "linux-64", + "timestamp": 1573237706976, + "version": "1.11.2" + }, + "pytest-mock-1.11.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "ad35aa860c18d0dd02d9ef63a32bea39", + "name": "pytest-mock", + "sha256": "1ad51a2361eafa50c46803c18600d46f3df4b73e2be80526347f6dd06dcb7497", + "size": 25823, + "subdir": "linux-64", + "timestamp": 1573237699231, + "version": "1.11.2" + }, + "pytest-mock-1.13.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mock", + "pytest >=2.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e1647be50896ad00bbee808882bcab7a", + "name": "pytest-mock", + "sha256": "3c97e39d029a05d22043f12ab0fa7708fc85a8a834e7461477f4ca2feda0174c", + "size": 26259, + "subdir": "linux-64", + "timestamp": 1576541116259, + "version": "1.13.0" + }, + "pytest-mock-1.13.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9a9cd788eae2811b7b4b6fdca3fb341c", + "name": "pytest-mock", + "sha256": "41b004b411af23a2c26aa8165742e153f8ecb4c7aa18c4a86a31f171ca009d00", + "size": 26526, + "subdir": "linux-64", + "timestamp": 1576541121168, + "version": "1.13.0" + }, + "pytest-mock-1.13.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "62fc35ebfd4c0f6fb2c916e8f8e8396e", + "name": "pytest-mock", + "sha256": "c2d41637f0c40dd87bcc5dfa1bb8297d90b00a3742f239339b50a0601e8f1a6d", + "size": 26566, + "subdir": "linux-64", + "timestamp": 1576541173968, + "version": "1.13.0" + }, + "pytest-mock-1.13.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "38b7ce55904bc1d5c041051815d76c5f", + "name": "pytest-mock", + "sha256": "1cf3aea6f0f6e394a9bab8f06cdf65752bcd2b7324dd20bff8b14254f81068d3", + "size": 26600, + "subdir": "linux-64", + "timestamp": 1576541211079, + "version": "1.13.0" + }, + "pytest-mock-1.6.3-py27hb287f53_1.tar.bz2": { + "build": "py27hb287f53_1", + "build_number": 1, + "depends": [ + "mock", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "241a7d6751ef7bdaf3b6e173bb1ef22e", + "name": "pytest-mock", + "sha256": "2a1575852274523d397a1917300c4597361df45df77cd33b52418aff14599316", + "size": 17785, + "subdir": "linux-64", + "timestamp": 1508969114054, + "version": "1.6.3" + }, + "pytest-mock-1.6.3-py35hc252d58_1.tar.bz2": { + "build": "py35hc252d58_1", + "build_number": 1, + "depends": [ + "pytest", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "2613ed37137b6340716af0abb4156f6e", + "name": "pytest-mock", + "sha256": "11fa9a6115ac1272f438fae52ef851e92613e975fb9f3cb50dd1d5f26d4c1e8e", + "size": 17967, + "subdir": "linux-64", + "timestamp": 1508969111246, + "version": "1.6.3" + }, + "pytest-mock-1.6.3-py36h4eecd68_1.tar.bz2": { + "build": "py36h4eecd68_1", + "build_number": 1, + "depends": [ + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "127e221763397d368e093554e423434d", + "name": "pytest-mock", + "sha256": "af3b4631ca33c3f30100f164ff214639ebdea867999ea1cae75382bf8abc8bc8", + "size": 17921, + "subdir": "linux-64", + "timestamp": 1508969113418, + "version": "1.6.3" + }, + "pytest-mock-1.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mock", + "pytest >=2.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "299af5b8457228f4c40735113d2ca44c", + "name": "pytest-mock", + "sha256": "ca9f547865399e11f6020d2e765f5cd067fe4cbf3f5ddd6fd1b0605a8a529e00", + "size": 17938, + "subdir": "linux-64", + "timestamp": 1519150651584, + "version": "1.7.0" + }, + "pytest-mock-1.7.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "9f334889fd5c5f2ad54e3973bbc408d9", + "name": "pytest-mock", + "sha256": "a7e520c8ddaa4d7387981545aa590da909a886d33492551a6ca2843860ed820b", + "size": 18155, + "subdir": "linux-64", + "timestamp": 1519150664000, + "version": "1.7.0" + }, + "pytest-mock-1.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d8f85184df0724cf128953cd97b0824d", + "name": "pytest-mock", + "sha256": "00b35f838dbebce88ada5ac9ba5a08c887143a794372b2c2097c5ec10f6d40b8", + "size": 18148, + "subdir": "linux-64", + "timestamp": 1519150667300, + "version": "1.7.0" + }, + "pytest-mock-1.7.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mock", + "pytest >=2.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "74031c9137d306544fc837243dacb2d9", + "name": "pytest-mock", + "sha256": "3972ed45839ffef17301e7a20b3395e8d5fc2285886d214bb3567253f36ab61b", + "size": 18001, + "subdir": "linux-64", + "timestamp": 1522194209704, + "version": "1.7.1" + }, + "pytest-mock-1.7.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "eb07395fb368f02371f7ec308d6b7190", + "name": "pytest-mock", + "sha256": "22c2b45cace6aebfd2eafb9e881d912c98fcd13cf36bd79f4af896691bffffd5", + "size": 18200, + "subdir": "linux-64", + "timestamp": 1522194380280, + "version": "1.7.1" + }, + "pytest-mock-1.7.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "eef89da49defe805ddbe19d55e60c6d3", + "name": "pytest-mock", + "sha256": "908ae95e414f409331a9d1aa12802bbefc9983d0d5df84e822bd707e7f265acc", + "size": 18172, + "subdir": "linux-64", + "timestamp": 1522193935843, + "version": "1.7.1" + }, + "pytest-mock-1.9.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mock", + "pytest >=2.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "87f124e5f8568dd43942be0d5ebd6734", + "name": "pytest-mock", + "sha256": "103c49d915e1cdbdf99bcb2b965ba8726c81e3e391b8ce8f60d93871dbda48f1", + "size": 18059, + "subdir": "linux-64", + "timestamp": 1524012068144, + "version": "1.9.0" + }, + "pytest-mock-1.9.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "4b6c002687a366eb036085902a22ded9", + "name": "pytest-mock", + "sha256": "f73ef6010df63ed1e8a36948f9f3559cdb269e1bf0b2c3f9eb634e8ed444636a", + "size": 18267, + "subdir": "linux-64", + "timestamp": 1524012029003, + "version": "1.9.0" + }, + "pytest-mock-1.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3e7dd2291006223c31f85cbbf50520b9", + "name": "pytest-mock", + "sha256": "065fcdee07a1b5afccfe707203d8d4cca0cd1fbeffaf029de734979fc88ff001", + "size": 18273, + "subdir": "linux-64", + "timestamp": 1524012080246, + "version": "1.9.0" + }, + "pytest-mock-3.10.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6de50d44ea1a6a4116286f0970585c0a", + "name": "pytest-mock", + "sha256": "1ffcd8be1a75ebe7334001b40c195ba719e28b72b9426f41f9d323c188552e6c", + "size": 24922, + "subdir": "linux-64", + "timestamp": 1674590368197, + "version": "3.10.0" + }, + "pytest-mock-3.10.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31058620a7353c5d83a99d8bcd0c4c89", + "name": "pytest-mock", + "sha256": "3d0221aebb0f53471a68d6431b44027f19315b44bc1b584f388efe4b73e52fbe", + "size": 29696, + "subdir": "linux-64", + "timestamp": 1676845510709, + "version": "3.10.0" + }, + "pytest-mock-3.10.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebfe4cf355ee4b62c4aefd3229eef017", + "name": "pytest-mock", + "sha256": "c302f042a121bf825d27deb7465927c703553aa31225e3c9050570d4de1c4184", + "size": 24633, + "subdir": "linux-64", + "timestamp": 1674590338970, + "version": "3.10.0" + }, + "pytest-mock-3.10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "59abc217681033f8094e90f9f993102e", + "name": "pytest-mock", + "sha256": "5db6e427612bb787f313ab12ddd1c113928762a1ceb74ec0bac0cc74c8293044", + "size": 24720, + "subdir": "linux-64", + "timestamp": 1674590397128, + "version": "3.10.0" + }, + "pytest-mock-3.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "35d9f3f6f5e590514a9127145ee18469", + "name": "pytest-mock", + "sha256": "5137d0cc2e74236e7ce8bc063f0032e56fd9b8bd8dcf9fca34b2c27b68fd4dd6", + "size": 24772, + "subdir": "linux-64", + "timestamp": 1674590426547, + "version": "3.10.0" + }, + "pytest-mock-3.7.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce8d3513a099f6d5aa8a318fc8f98829", + "name": "pytest-mock", + "sha256": "cf926e8f2759ab5576629eb87ed0647870b105c574f124ba7da1a8bc1284c6ed", + "size": 26999, + "subdir": "linux-64", + "timestamp": 1655844737252, + "version": "3.7.0" + }, + "pytest-mock-3.7.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "82349866cb0ee773097b514c74f3863e", + "name": "pytest-mock", + "sha256": "1998b11346791f90764f7e77ce32ee5b05d16958d83d09f4d60d5ccd65ba2a97", + "size": 26750, + "subdir": "linux-64", + "timestamp": 1655844832806, + "version": "3.7.0" + }, + "pytest-mock-3.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9856355cba612e46cf9c86ced08cd957", + "name": "pytest-mock", + "sha256": "6b41b510061ec1287121dba4f135302dd169d8e3cf25091e105e92a0395a43c5", + "size": 26854, + "subdir": "linux-64", + "timestamp": 1655844767760, + "version": "3.7.0" + }, + "pytest-mock-3.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "374b3b8ac26e54a28593fbd03113188d", + "name": "pytest-mock", + "sha256": "f8d64b8571a805be05695090bb2a50b33542e70405c821eda47f514d53fa6072", + "size": 26881, + "subdir": "linux-64", + "timestamp": 1655844799740, + "version": "3.7.0" + }, + "pytest-openfiles-0.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=3.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "3adbb56668a9e734612aa28dc5f40327", + "name": "pytest-openfiles", + "sha256": "0e3a7d7ef2bdd0976d9d12fbbe93b812e2388a8de71738609e5660fe2ce5dd48", + "size": 9128, + "subdir": "linux-64", + "timestamp": 1518731273336, + "version": "0.2.0" + }, + "pytest-openfiles-0.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=3.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "5bf333762cd94b9a1c963688239ccb2a", + "name": "pytest-openfiles", + "sha256": "e6af161128a92bde1670a625f4de4a60adf4d0241c4274c9c187081e14eeece3", + "size": 9239, + "subdir": "linux-64", + "timestamp": 1518731316263, + "version": "0.2.0" + }, + "pytest-openfiles-0.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=3.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "d8fd8f046cf07369b9b7db16ce8b81e9", + "name": "pytest-openfiles", + "sha256": "c8a4a9926dcdff1dec4505281f11f84eabe224eddd78d732716b82ee6ae037d4", + "size": 9195, + "subdir": "linux-64", + "timestamp": 1518731314377, + "version": "0.2.0" + }, + "pytest-openfiles-0.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "9be30a38bdeae75fcd685bc05921e84a", + "name": "pytest-openfiles", + "sha256": "14af400e420d12f7fa2f0bdce00fdb917f9b3da9cbae4441a03a53f7021d30ee", + "size": 8845, + "subdir": "linux-64", + "timestamp": 1524578577612, + "version": "0.3.0" + }, + "pytest-openfiles-0.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "a073afa5dc7bad8ab61cd4d7e3d86213", + "name": "pytest-openfiles", + "sha256": "a57f78b61a86d6f290c22508a5104d2483f524f2be03b50efe9c0549e7e32ba3", + "size": 8994, + "subdir": "linux-64", + "timestamp": 1524578504000, + "version": "0.3.0" + }, + "pytest-openfiles-0.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "2cb3bde1697a4b46b6ef3e63292f7559", + "name": "pytest-openfiles", + "sha256": "08ffce506b8c69b80064d84823c29cd7f6ccd0f91a7d0124d708c3afb368e000", + "size": 8958, + "subdir": "linux-64", + "timestamp": 1524578579487, + "version": "0.3.0" + }, + "pytest-openfiles-0.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "41111b3ad2df736ed1d538b5354efd08", + "name": "pytest-openfiles", + "sha256": "1a5ed5682b8efded5d1a5d1460d2dc15b2f1db293cdb80d92034bbc1eac081cf", + "size": 9121, + "subdir": "linux-64", + "timestamp": 1530738153150, + "version": "0.3.0" + }, + "pytest-openfiles-0.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "fd150e02ac3acfc316c3e0eaead6b974", + "name": "pytest-openfiles", + "sha256": "4ffa8a7b19cf4089576cf4627e1e8a46c5b547dd806af7deae94cce3ad65ebaa", + "size": 11189, + "subdir": "linux-64", + "timestamp": 1543610637984, + "version": "0.3.1" + }, + "pytest-openfiles-0.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "febe0460da03d87241e556b7573f5962", + "name": "pytest-openfiles", + "sha256": "9a182902e6338071e4638caca2c351503ca4599099d3607ac4f7adc4df731723", + "size": 11268, + "subdir": "linux-64", + "timestamp": 1543610615341, + "version": "0.3.1" + }, + "pytest-openfiles-0.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "716cc492448ad635c06c87a4768aefe3", + "name": "pytest-openfiles", + "sha256": "53c2cf42d083f91e6310b6f1579bd75550559a5d82c66b80aa73538582716327", + "size": 11278, + "subdir": "linux-64", + "timestamp": 1543610620090, + "version": "0.3.1" + }, + "pytest-openfiles-0.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "5e32956d950d7532a774665bf920820c", + "name": "pytest-openfiles", + "sha256": "37b54f10e482d07e56a0a29f4bd5b619f86df6ea3a0c8dec6b5f6f4b3591d37f", + "size": 11426, + "subdir": "linux-64", + "timestamp": 1547478674386, + "version": "0.3.2" + }, + "pytest-openfiles-0.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "eac1cba1aea05d0d92f03f5226b38072", + "name": "pytest-openfiles", + "sha256": "be0dfb3b5f04360f732a2c4e039fa8bd7261e7bd7d06dbe3c5a8c5d350435ae9", + "size": 11524, + "subdir": "linux-64", + "timestamp": 1547478650418, + "version": "0.3.2" + }, + "pytest-openfiles-0.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "1f384d726bead65a10f4f5b7d9828c47", + "name": "pytest-openfiles", + "sha256": "59071bee80541d9e32c183acc0c1d0b2d9cceb5036ba0e7c1c83006d4f8eff41", + "size": 11534, + "subdir": "linux-64", + "timestamp": 1547478684510, + "version": "0.3.2" + }, + "pytest-pep8-1.0.6-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pep8 >=1.3", + "pytest >=2.4.2", + "pytest-cache", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e52277ccb904c86724f907d40f82c7c9", + "name": "pytest-pep8", + "sha256": "179ca4663de6e8d67c289fb690e974b41d690dd76b746c6da7201a6a633f92fa", + "size": 10477, + "subdir": "linux-64", + "timestamp": 1537826902517, + "version": "1.0.6" + }, + "pytest-pep8-1.0.6-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "pep8 >=1.3", + "pytest >=2.4.2", + "pytest-cache", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "5bab4e652f19e462717914b1f7f95b93", + "name": "pytest-pep8", + "sha256": "9e2991fa905717b43afa052a8aafe4316e89cda10add5fc8e59aa993bc6fb70d", + "size": 10657, + "subdir": "linux-64", + "timestamp": 1537826940133, + "version": "1.0.6" + }, + "pytest-pep8-1.0.6-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pep8 >=1.3", + "pytest >=2.4.2", + "pytest-cache", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "dd98b2af5d7d93ae9eaa986ea6236fce", + "name": "pytest-pep8", + "sha256": "43ec35f78bf8a86b8bd1125b6d916f42b1264dad51c3014455faf4074b2a9e9b", + "size": 10655, + "subdir": "linux-64", + "timestamp": 1537826939028, + "version": "1.0.6" + }, + "pytest-pep8-1.0.6-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pep8 >=1.3", + "pytest >=2.4.2", + "pytest-cache", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "535f91d501e1e1709e5bafa57d4d9e77", + "name": "pytest-pep8", + "sha256": "a5dbfe419e5f9369c75dff6595f8853819d560c62a0905480cf0451907fc7173", + "size": 10645, + "subdir": "linux-64", + "timestamp": 1537826858325, + "version": "1.0.6" + }, + "pytest-remotedata-0.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "ec625a9ff8d77d8d9eb742145f550c8b", + "name": "pytest-remotedata", + "sha256": "10a2233b80d1250cfd35b3e96953df88cc1188aaf64949c87c18d622b11bb321", + "size": 16103, + "subdir": "linux-64", + "timestamp": 1518731322957, + "version": "0.2.0" + }, + "pytest-remotedata-0.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD", + "md5": "ac19a70f72ea7abfa70abe813914c25c", + "name": "pytest-remotedata", + "sha256": "90d0f1768246d19f00327e462fa945795bfae2698ef381723d69e2996e8858e2", + "size": 16310, + "subdir": "linux-64", + "timestamp": 1518731311711, + "version": "0.2.0" + }, + "pytest-remotedata-0.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "9ca9991faca00c448d45c1e00d03db27", + "name": "pytest-remotedata", + "sha256": "e8665a59dbdf09208fb0a77db68ff674a196bcfcd9ba63fabe4e156f75a59f8d", + "size": 16224, + "subdir": "linux-64", + "timestamp": 1518731308750, + "version": "0.2.0" + }, + "pytest-remotedata-0.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "54397e3655c0d1b5ca1aa4aa3a145fcc", + "name": "pytest-remotedata", + "sha256": "d5004900b232a49190feeb44957975d209bff5ae0a3e3d798d9a91f38dfcd30d", + "size": 11395, + "subdir": "linux-64", + "timestamp": 1524578574776, + "version": "0.2.1" + }, + "pytest-remotedata-0.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD", + "md5": "4181d8681d06c950be39665d16790c6f", + "name": "pytest-remotedata", + "sha256": "5d1ef0769201cdd014ee2b847a5559bc0b3a1c0b62af6de6e297ded11bf72514", + "size": 11495, + "subdir": "linux-64", + "timestamp": 1524578501340, + "version": "0.2.1" + }, + "pytest-remotedata-0.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "475911ff158398febcbc83ba5c206158", + "name": "pytest-remotedata", + "sha256": "2205f93d73ab909fff382f1d0c6ed59e9a9995e399e054617a5091a4ae9269b9", + "size": 11441, + "subdir": "linux-64", + "timestamp": 1524578580243, + "version": "0.2.1" + }, + "pytest-remotedata-0.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "ff463fc84274abe49d772539cf8187b9", + "name": "pytest-remotedata", + "sha256": "bd90cf3cd6f61017e58cf969c1c44606c313617bcb2affd590e9072c72de46f0", + "size": 12257, + "subdir": "linux-64", + "timestamp": 1528149810466, + "version": "0.3.0" + }, + "pytest-remotedata-0.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD", + "md5": "3f6cd76e47153ace8e6f00c78315ccf9", + "name": "pytest-remotedata", + "sha256": "268e00fa5380050fbc422bf396367ea169f548a380a5f0ac37d94e23a7b27121", + "size": 12402, + "subdir": "linux-64", + "timestamp": 1528149822373, + "version": "0.3.0" + }, + "pytest-remotedata-0.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "16430eabb2950d8d2112842545c20bf5", + "name": "pytest-remotedata", + "sha256": "826cfce652774fec1695c29c4edfdfdde11ac0c064729c6a4c855d880b316be8", + "size": 12385, + "subdir": "linux-64", + "timestamp": 1528149769942, + "version": "0.3.0" + }, + "pytest-remotedata-0.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD", + "md5": "0107d366ce79de0477a5ecae85780728", + "name": "pytest-remotedata", + "sha256": "84405eba0123cd5dbc49436c185d75c5807d0f57ab9f60057ecb777c6d25e008", + "size": 12379, + "subdir": "linux-64", + "timestamp": 1530738022655, + "version": "0.3.0" + }, + "pytest-remotedata-0.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "402cace6bea4df62b0ad2c5a6af34caa", + "name": "pytest-remotedata", + "sha256": "ccde915eec2a70e576310b412f508507c7e901ef14c2ec8e585c72fd063855ce", + "size": 13476, + "subdir": "linux-64", + "timestamp": 1541036694238, + "version": "0.3.1" + }, + "pytest-remotedata-0.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "75dd691eebbfe06a8b630c5a1dbc5a3b", + "name": "pytest-remotedata", + "sha256": "597fe2a2594c57cc82812f0cbe70bcb74e2c59796ec2cf9a8124efe07bcb0f30", + "size": 13580, + "subdir": "linux-64", + "timestamp": 1541036708622, + "version": "0.3.1" + }, + "pytest-remotedata-0.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD", + "md5": "b84f49696c6b6092f7ee0acc7872c517", + "name": "pytest-remotedata", + "sha256": "c327c0e15644012e56bf04583558d53e90df234f8262d17c9d9eff6eeb6153c8", + "size": 13612, + "subdir": "linux-64", + "timestamp": 1541036669142, + "version": "0.3.1" + }, + "pytest-remotedata-0.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "ea50fbcde043268024f27cb6e3ad9691", + "name": "pytest-remotedata", + "sha256": "a04cb20aa2118ff504f14eb2450d163b9eaca48cd706a87b9caa976b97cb94c3", + "size": 14858, + "subdir": "linux-64", + "timestamp": 1564704264904, + "version": "0.3.2" + }, + "pytest-remotedata-0.3.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD", + "md5": "dbb89873ef997c9a90eef0ee3fd17a26", + "name": "pytest-remotedata", + "sha256": "f2c6b0a0dbc144f3fadc0e91f50aa6acb7f9bd862d696ebc9fa06803d042304c", + "size": 14058, + "subdir": "linux-64", + "timestamp": 1640810602845, + "version": "0.3.2" + }, + "pytest-remotedata-0.3.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "BSD", + "md5": "2105309dd55c371090ab68fe6ec8f4d9", + "name": "pytest-remotedata", + "sha256": "6b582429a775cbe3fdd24f85a9d265223ab9007356fdf7ac7742a27fcef8697e", + "size": 16456, + "subdir": "linux-64", + "timestamp": 1676845526578, + "version": "0.3.2" + }, + "pytest-remotedata-0.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "241b38014044585884276f689eba399c", + "name": "pytest-remotedata", + "sha256": "10b3eeeaa5147ee370d828fc5f4f7338fea07175dcc8acf590f30a76ab793bcb", + "size": 14987, + "subdir": "linux-64", + "timestamp": 1564704312589, + "version": "0.3.2" + }, + "pytest-remotedata-0.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD", + "md5": "7e0a6d708d85b1587e3d086362b8a392", + "name": "pytest-remotedata", + "sha256": "bcf2257ba8c92546e7abd671195c6009ff36562c20b87d74834c5a620ee0bd86", + "size": 15029, + "subdir": "linux-64", + "timestamp": 1564704282978, + "version": "0.3.2" + }, + "pytest-remotedata-0.3.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD", + "md5": "f5143a5fffb4e048415e09066f697e83", + "name": "pytest-remotedata", + "sha256": "e236c4f0ae51f0e5ff7647031e165a7769f136ed99cdef53b19e8b3774455174", + "size": 13889, + "subdir": "linux-64", + "timestamp": 1574169784282, + "version": "0.3.2" + }, + "pytest-remotedata-0.3.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD", + "md5": "6f06b91f245d0a4d1bd8bb9ba3613689", + "name": "pytest-remotedata", + "sha256": "f9f7d6d4933f419cc85e91568715eec1117d980046db079b63de63e51d93c656", + "size": 15475, + "subdir": "linux-64", + "timestamp": 1607625798550, + "version": "0.3.2" + }, + "pytest-runner-2.11.1-py27he057ec9_0.tar.bz2": { + "build": "py27he057ec9_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3ad53b12ab6ae1bb96ebcebc8d5dfbe", + "name": "pytest-runner", + "sha256": "6d6e3661ec5f1e5a89a676ab718b5008c52f463995ef1fbc376bf9350c4bb8f7", + "size": 10965, + "subdir": "linux-64", + "timestamp": 1505691537032, + "version": "2.11.1" + }, + "pytest-runner-2.11.1-py35hed12c2c_0.tar.bz2": { + "build": "py35hed12c2c_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "702df75a1578c1aac70cca9f8b9b07f3", + "name": "pytest-runner", + "sha256": "4fd527203d318fd1a0cf74984e1afe72885dbd6d0c6b302251b4367845aec4b0", + "size": 11099, + "subdir": "linux-64", + "timestamp": 1505691548081, + "version": "2.11.1" + }, + "pytest-runner-2.11.1-py36h66b2b85_0.tar.bz2": { + "build": "py36h66b2b85_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9fd1fe6ed4a6641bdb8459ab75854a6a", + "name": "pytest-runner", + "sha256": "3304b6fa8b26e856aabf15749712f8452cc0211bb59fa78fed44e55680eac988", + "size": 11090, + "subdir": "linux-64", + "timestamp": 1505691559188, + "version": "2.11.1" + }, + "pytest-runner-3.0-py27h9dcb770_0.tar.bz2": { + "build": "py27h9dcb770_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8be4e187afcebd449dcd8d0f342f64bc", + "name": "pytest-runner", + "sha256": "04dfe9f924f04061648562995edb116cf1ef1333e44a65068bbcd56a93588654", + "size": 11704, + "subdir": "linux-64", + "timestamp": 1509208000887, + "version": "3.0" + }, + "pytest-runner-3.0-py35h57e6dd6_0.tar.bz2": { + "build": "py35h57e6dd6_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71e9d135a9e371cc0d7b9e93ed5017ac", + "name": "pytest-runner", + "sha256": "63c55d5050225daf84294b9385d85de8a96dc4ee1324a472da428d8ef17f5617", + "size": 11846, + "subdir": "linux-64", + "timestamp": 1509207983729, + "version": "3.0" + }, + "pytest-runner-3.0-py36hd5415d6_0.tar.bz2": { + "build": "py36hd5415d6_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc4fc54b51e9e1084ed7a13df240f745", + "name": "pytest-runner", + "sha256": "4e413074268bce940d926d2571e60b02b67fcc2af7ae9d123ba8a4d6e75ce3b9", + "size": 11772, + "subdir": "linux-64", + "timestamp": 1509207983855, + "version": "3.0" + }, + "pytest-runner-4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62e6337959ba829805fdf1096e605a8d", + "name": "pytest-runner", + "sha256": "f20aad527854f60a015d615239483739d85aa6dd1a514e11b37fa5d6eb7531e2", + "size": 10979, + "subdir": "linux-64", + "timestamp": 1519071844523, + "version": "4.0" + }, + "pytest-runner-4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "05d0031f0980166938fe01bcfd24a5e5", + "name": "pytest-runner", + "sha256": "87bd57af7a9950e57ec277d8cc478bca195b10324476b5c7785397b3a081be79", + "size": 11093, + "subdir": "linux-64", + "timestamp": 1519071856587, + "version": "4.0" + }, + "pytest-runner-4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c548cf3e87c85c9696657d8aee94cd6d", + "name": "pytest-runner", + "sha256": "71b3b2a43d16762cd198400012ac3ab308f9ccb484577f58f88d11be19acd65b", + "size": 11038, + "subdir": "linux-64", + "timestamp": 1519071858643, + "version": "4.0" + }, + "pytest-runner-4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0222aa55f8a36dbb88f9aa410210341a", + "name": "pytest-runner", + "sha256": "5d7be4d65cc393a4c4bd367e392b5484939e881f333a65aa313c9db4d3195230", + "size": 11390, + "subdir": "linux-64", + "timestamp": 1522194025006, + "version": "4.2" + }, + "pytest-runner-4.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d730e2847bd4be39fe98a916dacc1296", + "name": "pytest-runner", + "sha256": "83a79afaaf48bfe6799945c7c245f01a7e20ea25a888b35b73ee167d682556c1", + "size": 11502, + "subdir": "linux-64", + "timestamp": 1522194394243, + "version": "4.2" + }, + "pytest-runner-4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9dac478c19dbbaa8178a625077c838ff", + "name": "pytest-runner", + "sha256": "d904ca79eba062b7b66ea59d94ed61a789118e6882805bcf84c301661cde92d9", + "size": 11424, + "subdir": "linux-64", + "timestamp": 1522194029097, + "version": "4.2" + }, + "pytest-runner-4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87a266adb95ac8104601a110475d51f2", + "name": "pytest-runner", + "sha256": "89d0f85b0b1995fe0184c325c967b2a375eaf6d176651e3b23eab5d214df69c7", + "size": 11293, + "subdir": "linux-64", + "timestamp": 1530733488016, + "version": "4.2" + }, + "pytest-runner-6.0.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.10,<3.11.0a0", + "setuptools >=56" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "802b0b182f85e2eb096410a279b22993", + "name": "pytest-runner", + "sha256": "91c97bb16fa514139c9b3c9abaca23c0e180e5a6f5f5d7d47ad7c64f2306915c", + "size": 13582, + "subdir": "linux-64", + "timestamp": 1668612112060, + "version": "6.0.0" + }, + "pytest-runner-6.0.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.11,<3.12.0a0", + "setuptools >=56" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6cde9eaf0ba7901def541d3fe17f4b09", + "name": "pytest-runner", + "sha256": "1124a4f40296fbbad9f1faacc3be28cbc9066d5a92fb31c5cb0105dd8000ab11", + "size": 15827, + "subdir": "linux-64", + "timestamp": 1676823008358, + "version": "6.0.0" + }, + "pytest-runner-6.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.7,<3.8.0a0", + "setuptools >=56" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2118b35541416cdf4803d43c94a6d898", + "name": "pytest-runner", + "sha256": "46f5142558d606c6955b6bbda2a8c9f302c887f99b40cdbab935a621ecabbfd8", + "size": 13448, + "subdir": "linux-64", + "timestamp": 1668612025028, + "version": "6.0.0" + }, + "pytest-runner-6.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.8,<3.9.0a0", + "setuptools >=56" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6137f73a188e741177e820a0e5b82055", + "name": "pytest-runner", + "sha256": "a666a81e092780b7a430d9684e6f92df31cfd02414dcffb53bd8ccfb57020f09", + "size": 13507, + "subdir": "linux-64", + "timestamp": 1668612054270, + "version": "6.0.0" + }, + "pytest-runner-6.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.9,<3.10.0a0", + "setuptools >=56" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f928be6d4bb94824fec706ad9270ebc7", + "name": "pytest-runner", + "sha256": "aa7c78e69866661d81255d84679fedb7eeb8499afecd4a652bebd26cc66a5669", + "size": 13518, + "subdir": "linux-64", + "timestamp": 1668612083172, + "version": "6.0.0" + }, + "pytest-selenium-1.11.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=2.7,<2.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "a09e653582ad73b17a9a47ffd2e794d2", + "name": "pytest-selenium", + "sha256": "6f3b66012f663982774715fa2338511e5de64315c69297aeddb5e573f9aef043", + "size": 27188, + "subdir": "linux-64", + "timestamp": 1518721768978, + "version": "1.11.1" + }, + "pytest-selenium-1.11.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.5,<3.6.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "66348343909b7e14d4d01d1cca8f7c7b", + "name": "pytest-selenium", + "sha256": "b134d76cc743b0fc593fb674ef5b008e78dbee2ccbb036cb6c259758fdf53d69", + "size": 27830, + "subdir": "linux-64", + "timestamp": 1518721955524, + "version": "1.11.1" + }, + "pytest-selenium-1.11.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.6,<3.7.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "29c595b511f3b1182fa936ec119c6c4d", + "name": "pytest-selenium", + "sha256": "06c3edfe0688ffd9be01a6f01f14dbade0863864a2f0d3896ae83d98e66b2467", + "size": 27581, + "subdir": "linux-64", + "timestamp": 1518721819976, + "version": "1.11.1" + }, + "pytest-selenium-1.12.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=2.7,<2.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "a29bb8ac62bb8c2e4712762e353b9597", + "name": "pytest-selenium", + "sha256": "898f9651942363b52fc5e0fa151c5a985db5e79ecb12089eafe5560bb2c9e555", + "size": 28022, + "subdir": "linux-64", + "timestamp": 1522194675628, + "version": "1.12.0" + }, + "pytest-selenium-1.12.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.5,<3.6.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "f947be740760b2d6d7dff2717002b80f", + "name": "pytest-selenium", + "sha256": "52e025d81ac08ea6c0df04caceadc795e5ce6b216ab866e121a283b6d88eaf81", + "size": 28557, + "subdir": "linux-64", + "timestamp": 1522194670181, + "version": "1.12.0" + }, + "pytest-selenium-1.12.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.6,<3.7.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "02f427d6920ca53227610c0269310189", + "name": "pytest-selenium", + "sha256": "5b3025603d1e4512484fdba6788c0f55cb5274ffce00d378c4e84ed48c1f8db2", + "size": 28357, + "subdir": "linux-64", + "timestamp": 1522194681223, + "version": "1.12.0" + }, + "pytest-selenium-1.13.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=2.7,<2.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "211a82c89012593d10cf76e851820259", + "name": "pytest-selenium", + "sha256": "5a2da711f1c2131d6d88c7e9a37d0fe921314accb8dcd6792dd78761fae80347", + "size": 30291, + "subdir": "linux-64", + "timestamp": 1527875963888, + "version": "1.13.0" + }, + "pytest-selenium-1.13.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.5,<3.6.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "be9cadee3385e45541717da2d977fcd9", + "name": "pytest-selenium", + "sha256": "fafd8b7ff95b89779b075654bd8da7e1e8429d73c7701145c057f10a3c5460ae", + "size": 30923, + "subdir": "linux-64", + "timestamp": 1527876007287, + "version": "1.13.0" + }, + "pytest-selenium-1.13.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.6,<3.7.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "10b274df89f088c856e6c5d5fafb0831", + "name": "pytest-selenium", + "sha256": "c6a6e70ce6884216d95ec9c1a3756cb589f082ff0bf12c340eb3d3f47e2ebe3d", + "size": 30724, + "subdir": "linux-64", + "timestamp": 1527875939070, + "version": "1.13.0" + }, + "pytest-selenium-1.13.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.7,<3.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "b914a9f4e4dd39c2a9b1d9f1aa18e79e", + "name": "pytest-selenium", + "sha256": "88c254f3360648d6049c6bbaf431769968fd402840356f314b18320fc181492b", + "size": 30710, + "subdir": "linux-64", + "timestamp": 1530922469547, + "version": "1.13.0" + }, + "pytest-selenium-1.14.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=2.7,<2.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "f7f3623e419a4321554cfc5acf1e2d43", + "name": "pytest-selenium", + "sha256": "0c5efecd47827878c5d84ed64a96645c36cc81c449de789e112aac1f364c991a", + "size": 29928, + "subdir": "linux-64", + "timestamp": 1535420662637, + "version": "1.14.0" + }, + "pytest-selenium-1.14.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.5,<3.6.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "123e1ab83c5ab848c8ea2518d6ad0557", + "name": "pytest-selenium", + "sha256": "5e1d06607f8ace1fa4b6faeceab7477d34d2937f7e29210c8a02d0956acef8a2", + "size": 30549, + "subdir": "linux-64", + "timestamp": 1535420795795, + "version": "1.14.0" + }, + "pytest-selenium-1.14.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.6,<3.7.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "7d8d497ee586264ce5089f623ca8198a", + "name": "pytest-selenium", + "sha256": "4d67e5bbd42e75b46b19455f8a10cc8ae7d247c1770431880a999611b2bf4be3", + "size": 30321, + "subdir": "linux-64", + "timestamp": 1535420759890, + "version": "1.14.0" + }, + "pytest-selenium-1.14.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.7,<3.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "d9c7515cfa8496a925cca0bfcd7bdf5e", + "name": "pytest-selenium", + "sha256": "22ae51d8405990e07e7b51fc0692fbf461773be26f80808b05cdc26d24f89dfc", + "size": 30368, + "subdir": "linux-64", + "timestamp": 1535420665891, + "version": "1.14.0" + }, + "pytest-selenium-1.15.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=2.7,<2.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "d6f030577921b6899e5933cf2ff17f0a", + "name": "pytest-selenium", + "sha256": "ffcefa6efd7143880c8de8664d61ae9fe83b3c9220443fd5c8b9e4b633f3b976", + "size": 33722, + "subdir": "linux-64", + "timestamp": 1547479297350, + "version": "1.15.1" + }, + "pytest-selenium-1.15.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.6,<3.7.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "7b5faf227bd926fe13ec737fcb3b471e", + "name": "pytest-selenium", + "sha256": "9235db40c7af21263e0bc91f1cbf30cfaec0453bc37e44b3b732c86395014fbe", + "size": 34234, + "subdir": "linux-64", + "timestamp": 1547479293374, + "version": "1.15.1" + }, + "pytest-selenium-1.15.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.7,<3.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "ddf51e7f1e83c72a17ea48a89e0fb5b2", + "name": "pytest-selenium", + "sha256": "4bd82e1db70dc77a86a600fd9e1a6a91ab0dcd527eba111484d2df8fbc46f2ae", + "size": 34249, + "subdir": "linux-64", + "timestamp": 1547479288329, + "version": "1.15.1" + }, + "pytest-selenium-1.16.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=2.7,<2.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "2db229691e89ce007d52fe3276651f52", + "name": "pytest-selenium", + "sha256": "c69e85a7ff8ce6c7245564e2828d85ed9ecd9b83d94e1176030c71c205ff30ab", + "size": 33416, + "subdir": "linux-64", + "timestamp": 1550355248170, + "version": "1.16.0" + }, + "pytest-selenium-1.16.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.6,<3.7.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "858f098f4711557904d0e398ebba8b24", + "name": "pytest-selenium", + "sha256": "0b6849fc5d62bf1662e2f3e7ef77cefb8ab96b55ce109d539e73b711e6c5eb41", + "size": 33780, + "subdir": "linux-64", + "timestamp": 1550355278921, + "version": "1.16.0" + }, + "pytest-selenium-1.16.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.7,<3.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "ef729b038ce37cdcfc797115d8800915", + "name": "pytest-selenium", + "sha256": "74f224cd3c90d5e83a64510c28bf03a002107841fe4091580efda70027048061", + "size": 33823, + "subdir": "linux-64", + "timestamp": 1550355177564, + "version": "1.16.0" + }, + "pytest-timeout-1.2.0-py27h5d547cd_0.tar.bz2": { + "build": "py27h5d547cd_0", + "build_number": 0, + "depends": [ + "pytest >=2.8.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d3d1399213ce831a5e38b9f9f8087975", + "name": "pytest-timeout", + "sha256": "29f2c6eb984a6d0fb8f0b46691d4c72bc74075d1b15fa79db5e509901f986a41", + "size": 14643, + "subdir": "linux-64", + "timestamp": 1508215980964, + "version": "1.2.0" + }, + "pytest-timeout-1.2.0-py35h96a0e9c_0.tar.bz2": { + "build": "py35h96a0e9c_0", + "build_number": 0, + "depends": [ + "pytest >=2.8.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "20fdc22c7d7fbc21e3bad49df21bc807", + "name": "pytest-timeout", + "sha256": "8f7b63fde3dc7eec75ba0a40fcc137926ae38e10926275847c3e22642655779c", + "size": 14737, + "subdir": "linux-64", + "timestamp": 1508215899467, + "version": "1.2.0" + }, + "pytest-timeout-1.2.0-py36h0fa9b50_0.tar.bz2": { + "build": "py36h0fa9b50_0", + "build_number": 0, + "depends": [ + "pytest >=2.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d38cb17e4bef14272edadc7ee1de6512", + "name": "pytest-timeout", + "sha256": "17dbae01e4d1c93624a107dad1dea104d4c59e4c8f5706dfd6f2ef7aa68e355d", + "size": 14690, + "subdir": "linux-64", + "timestamp": 1508215552917, + "version": "1.2.0" + }, + "pytest-timeout-1.2.1-py27h0aba353_0.tar.bz2": { + "build": "py27h0aba353_0", + "build_number": 0, + "depends": [ + "pytest >=2.8.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "02a5318a7f1df27b478878fc06b644a7", + "name": "pytest-timeout", + "sha256": "9b34bc09135dda53267e190893fd4980a30cc0be6cd247c2fe8d60e01c6518e2", + "size": 14885, + "subdir": "linux-64", + "timestamp": 1512066331468, + "version": "1.2.1" + }, + "pytest-timeout-1.2.1-py35h6d119eb_0.tar.bz2": { + "build": "py35h6d119eb_0", + "build_number": 0, + "depends": [ + "pytest >=2.8.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "dc37787a1702226793d05fbcde9986fb", + "name": "pytest-timeout", + "sha256": "8a822686f8883ff22a8c46cf477596207be002ddb84d2a1e8f037d6eb285ac77", + "size": 15040, + "subdir": "linux-64", + "timestamp": 1512066337113, + "version": "1.2.1" + }, + "pytest-timeout-1.2.1-py36hf4a559a_0.tar.bz2": { + "build": "py36hf4a559a_0", + "build_number": 0, + "depends": [ + "pytest >=2.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e8b256be625eb2c39064dd05d6b0f183", + "name": "pytest-timeout", + "sha256": "5509951c4bdd39e736a03b8d11c2ce134c9aa922420a67863516bfbfaa8e80b8", + "size": 14965, + "subdir": "linux-64", + "timestamp": 1512066342649, + "version": "1.2.1" + }, + "pytest-timeout-1.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "2bdcbbd230799ab4da7f1b5111b17527", + "name": "pytest-timeout", + "sha256": "af57129c747e6b80483a4560aec24dfbc27f5ac6b9e014b7144f0ecdc4930d33", + "size": 16046, + "subdir": "linux-64", + "timestamp": 1529422873605, + "version": "1.3.0" + }, + "pytest-timeout-1.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "614125b904aea566913b1ba898065203", + "name": "pytest-timeout", + "sha256": "b2c32b67f25b31d76a87c262de232be8fe447de9c4c3240809d0a8def821fca2", + "size": 16163, + "subdir": "linux-64", + "timestamp": 1529422873964, + "version": "1.3.0" + }, + "pytest-timeout-1.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "46642bb6bca087b27f181262838e968d", + "name": "pytest-timeout", + "sha256": "a01a998f0c42854679991cb454d0581db635972f92ac96fd7cf04617d7ccd138", + "size": 16097, + "subdir": "linux-64", + "timestamp": 1529422848580, + "version": "1.3.0" + }, + "pytest-timeout-1.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e88047612b925fefdaf62a22a38f0e48", + "name": "pytest-timeout", + "sha256": "6294ff5c4e4525d7bf9b883c1c80b89ac56b09a814c91d50cd35cc3f148ceab9", + "size": 16110, + "subdir": "linux-64", + "timestamp": 1530922507213, + "version": "1.3.0" + }, + "pytest-timeout-1.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "2353961077e476cfac46165bf329549d", + "name": "pytest-timeout", + "sha256": "015cc65db0b6e73ac5292708abfaa97127b749d728f83678dc874502d25ce844", + "size": 15953, + "subdir": "linux-64", + "timestamp": 1535421046530, + "version": "1.3.2" + }, + "pytest-timeout-1.3.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "7119071572334c56425866fd7843892d", + "name": "pytest-timeout", + "sha256": "a46e1a252c0ab61cc3c2509931b2268ce7c324f6133871f35281f9a9ad787c94", + "size": 16024, + "subdir": "linux-64", + "timestamp": 1535420986044, + "version": "1.3.2" + }, + "pytest-timeout-1.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f5a16c4774477f5b6b02d6da139ed44d", + "name": "pytest-timeout", + "sha256": "633b31916573f956028e0310b9e880a7911e99d6638fb0a53bdfb0a2b4861974", + "size": 15978, + "subdir": "linux-64", + "timestamp": 1535421033730, + "version": "1.3.2" + }, + "pytest-timeout-1.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1bdcdd4f7a9fbdecdf5cabb946895fde", + "name": "pytest-timeout", + "sha256": "78ebe0a26b633fddcbec358a2f7cd240c4063e44d77a6ce6d608ee48317710fb", + "size": 16029, + "subdir": "linux-64", + "timestamp": 1535421051104, + "version": "1.3.2" + }, + "pytest-timeout-1.3.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "855468fc143dc03611986e680725f0d8", + "name": "pytest-timeout", + "sha256": "c88199e0ca8748047301caa391a02c68bdd169da8098bbb1a9cae7efefe7a991", + "size": 16850, + "subdir": "linux-64", + "timestamp": 1542408590606, + "version": "1.3.3" + }, + "pytest-timeout-1.3.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a60db05de56ebc050e3fe03fbbe1ead2", + "name": "pytest-timeout", + "sha256": "64f8d2bb2fe1fc7b67c07ba3b8a6de367a4045e3706c12806dbfe39cf2d64446", + "size": 16925, + "subdir": "linux-64", + "timestamp": 1542408614791, + "version": "1.3.3" + }, + "pytest-timeout-1.3.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8d609a0e3af281fcff131489571df4eb", + "name": "pytest-timeout", + "sha256": "3420f7fc9fac048a9c93f84237799e26da70560fdb8ff328936dfd5a291d8b6d", + "size": 16955, + "subdir": "linux-64", + "timestamp": 1542408561305, + "version": "1.3.3" + }, + "pytest-timeout-1.3.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "58eb27e12b4e988bd2c174f3cc3dc6d9", + "name": "pytest-timeout", + "sha256": "fb536648dacbe457e5bc9edd7b7af6dc22cde919544c7b922db1b5b9a07896aa", + "size": 17252, + "subdir": "linux-64", + "timestamp": 1574169799097, + "version": "1.3.3" + }, + "pytest-tornado-0.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=2.7,<2.8.0a0", + "tornado >=4" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2798b5efb9c928fbe5797a18eade7131", + "name": "pytest-tornado", + "sha256": "9e97760ebc0fcd7a35e43ae015a89f122fdb7e1126b919fd63c2b056d2a0867f", + "size": 14796, + "subdir": "linux-64", + "timestamp": 1536857589244, + "version": "0.5.0" + }, + "pytest-tornado-0.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.5,<3.6.0a0", + "tornado >=4" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a72ea76c5f8296ff2c09d2221de51aee", + "name": "pytest-tornado", + "sha256": "7b394142d53cd71aa6ce33679a5ba583a432b213e939769cc32f955a84155dbc", + "size": 14988, + "subdir": "linux-64", + "timestamp": 1536857688719, + "version": "0.5.0" + }, + "pytest-tornado-0.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e5cebb8f4a6f3dcd84ce90238d4d3c29", + "name": "pytest-tornado", + "sha256": "1bdebc6676b7f329018ceb5ad7bbe1ec3ab8aa6ab74b84bd9db8413653128733", + "size": 14984, + "subdir": "linux-64", + "timestamp": 1536857706114, + "version": "0.5.0" + }, + "pytest-tornado-0.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.7,<3.8.0a0", + "tornado >=4" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "69400f173668bd524d5fc5b47bc8a30a", + "name": "pytest-tornado", + "sha256": "3b531de5892bdd47679a5cc4b984e78bb4b715697d902c2050234e6380481e44", + "size": 15029, + "subdir": "linux-64", + "timestamp": 1536857564438, + "version": "0.5.0" + }, + "pytest-variables-1.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "7845b2cb22598b79660950352eef2f4c", + "name": "pytest-variables", + "sha256": "99552f042f4b411a7450f99895dffd898b34e8a27ac6a30ee78ec454a62a9acb", + "size": 9002, + "subdir": "linux-64", + "timestamp": 1518721219631, + "version": "1.7.0" + }, + "pytest-variables-1.7.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "45551076f7a5dc07fafa10ecc580f1be", + "name": "pytest-variables", + "sha256": "8d9572959a09636184dfe806ad41b586b8898bdc90ef4118d8763e4c94a427c5", + "size": 9084, + "subdir": "linux-64", + "timestamp": 1518721293798, + "version": "1.7.0" + }, + "pytest-variables-1.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "9f8f29684ebf39699e47f162334fd818", + "name": "pytest-variables", + "sha256": "23190f171b39ec9cc52a0861f3f22977aaa0282a54a6567365153eda58ad14e7", + "size": 9046, + "subdir": "linux-64", + "timestamp": 1518721293301, + "version": "1.7.0" + }, + "pytest-variables-1.7.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "a3060a996b7945802d4da0b29465815c", + "name": "pytest-variables", + "sha256": "a1eb8d4105e98c3bcf9cabeac9579db2b72ac30063254df779934e1913aa3496", + "size": 8800, + "subdir": "linux-64", + "timestamp": 1522790830613, + "version": "1.7.1" + }, + "pytest-variables-1.7.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "b920f19b7e8fee08f1429a46a2cf1483", + "name": "pytest-variables", + "sha256": "b87a0c359a9c52776231eee9a2d07a258293bcf6b5bad3442db3dba4120c971d", + "size": 8887, + "subdir": "linux-64", + "timestamp": 1522790876113, + "version": "1.7.1" + }, + "pytest-variables-1.7.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "08c473971659b91ff0ed3967a00ce7eb", + "name": "pytest-variables", + "sha256": "efb4c15792e4745c84de5c8b61b3b03795b35029509d33354d4641e567b09e15", + "size": 8886, + "subdir": "linux-64", + "timestamp": 1522790879252, + "version": "1.7.1" + }, + "pytest-variables-1.7.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "6d86da7aedd6b1f73668dcc28ddf2253", + "name": "pytest-variables", + "sha256": "7a74484e7515267f7bb7f6cee49116e35e0f7e46da73e233e48138db579ec81f", + "size": 8790, + "subdir": "linux-64", + "timestamp": 1530922384762, + "version": "1.7.1" + }, + "pytest-variables-1.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "bdcb857f9f85d0aab3fbd5865fdd5aeb", + "name": "pytest-variables", + "sha256": "c5fa1ecf95e516c3eb3bde9613258b6be3812a5d9f2779f0ccf08892779eca2f", + "size": 10465, + "subdir": "linux-64", + "timestamp": 1569375948230, + "version": "1.8.0" + }, + "pytest-variables-1.8.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "92fbc6cee7050414cf2ebf9d53f9bce2", + "name": "pytest-variables", + "sha256": "4f92fc7f8ec45aeb8f1b6d9b312fb0bac0f4382e96ade134e625c1c0bc905202", + "size": 9652, + "subdir": "linux-64", + "timestamp": 1640810623505, + "version": "1.8.0" + }, + "pytest-variables-1.8.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "672d9471b226b254c0d2d8a7fb394ae6", + "name": "pytest-variables", + "sha256": "25ee6a81ad9927855e474d42977729110c00571f6b6f81242509e194a3ed2f17", + "size": 11350, + "subdir": "linux-64", + "timestamp": 1676861382639, + "version": "1.8.0" + }, + "pytest-variables-1.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "55c288455fcc6379c69e7a4b851fa6d5", + "name": "pytest-variables", + "sha256": "02441d79bc5cdb45245c1ab26788ab767af30180cb0dff9e87660571fdefb5ce", + "size": 10521, + "subdir": "linux-64", + "timestamp": 1569375959473, + "version": "1.8.0" + }, + "pytest-variables-1.8.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "09e4d2285051bb35755c2c7e08cdb111", + "name": "pytest-variables", + "sha256": "7498bc7a4ebe971db18f841c4de1b204f588bf3d5b0c81c4cbe6e31cde6cd422", + "size": 10549, + "subdir": "linux-64", + "timestamp": 1611764499306, + "version": "1.8.0" + }, + "pytest-variables-1.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "31daaaf5a5c5924312662ca98f26a34a", + "name": "pytest-variables", + "sha256": "aa23a700f8b197ca6142d8c89f0b8a32fde74ccdeb53e34729e33a9e8824d86b", + "size": 10542, + "subdir": "linux-64", + "timestamp": 1569375958422, + "version": "1.8.0" + }, + "pytest-variables-1.8.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "e0257c4ebc338d2648bd7ca650dae1e9", + "name": "pytest-variables", + "sha256": "094a5e8354eaa24e1e9c5fc69e326dd67037cded7f4e22075c3a2e1fb932971d", + "size": 10553, + "subdir": "linux-64", + "timestamp": 1611763155049, + "version": "1.8.0" + }, + "pytest-variables-1.8.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "688bbf9b01546d4feeb2268e025f934f", + "name": "pytest-variables", + "sha256": "9f3962e75052870f16d7132437933480149f32deab1e903cbf983ca88a22f628", + "size": 9864, + "subdir": "linux-64", + "timestamp": 1574169813212, + "version": "1.8.0" + }, + "pytest-variables-1.8.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "3b6903d29a80908bd7bd1179a636a34a", + "name": "pytest-variables", + "sha256": "5cc5ee2aed3cfecfcee5346fe9b26b487e00fae2754958ad1122a9c09b9eb0bb", + "size": 10590, + "subdir": "linux-64", + "timestamp": 1611764482593, + "version": "1.8.0" + }, + "pytest-variables-1.8.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "460287f5b86f49b03f0507285be9bcb4", + "name": "pytest-variables", + "sha256": "02d477042e85649fad6d754c744f8c380a21c34a2af382455b8bf64f151f19fc", + "size": 10626, + "subdir": "linux-64", + "timestamp": 1611764052599, + "version": "1.8.0" + }, + "pytest-variables-1.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "6285dc57ef4bf5a10bcb011772afaf5d", + "name": "pytest-variables", + "sha256": "cbc393408674b795dd552d20e558beda2246db6abe1bd09158c9e112c0790590", + "size": 9813, + "subdir": "linux-64", + "timestamp": 1600459505531, + "version": "1.9.0" + }, + "pytest-variables-1.9.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "24d4587d16059a1bde39cf5d9df2fdfd", + "name": "pytest-variables", + "sha256": "670c09ea7aff12bc8c5a026dcd23a76ee95f8064e0ac14df4a5f59433c9775ee", + "size": 9823, + "subdir": "linux-64", + "timestamp": 1600459526919, + "version": "1.9.0" + }, + "pytest-variables-1.9.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "0d36a8e6a882458d4824297bcd3563b1", + "name": "pytest-variables", + "sha256": "c3e59baccd0d496323ac88cd87517c3001049fee69b59081651b789f6783c53f", + "size": 9862, + "subdir": "linux-64", + "timestamp": 1600459512644, + "version": "1.9.0" + }, + "pytest-xdist-1.20.1-py27h6b1c668_0.tar.bz2": { + "build": "py27h6b1c668_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "85255134abfaa7e9674a48d35d39d9d7", + "name": "pytest-xdist", + "sha256": "b6d72589458dfa3e46d94887f872040be2946996ca0cbe41a1a0a346d2f709c7", + "size": 48184, + "subdir": "linux-64", + "timestamp": 1511990092900, + "version": "1.20.1" + }, + "pytest-xdist-1.20.1-py35h5ef5961_0.tar.bz2": { + "build": "py35h5ef5961_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "4144de1bb55984c0d7f221af97f9dfed", + "name": "pytest-xdist", + "sha256": "68501e29858017e22e980ba4d9a32de3081114e3090156a519458deab09f2ae7", + "size": 49127, + "subdir": "linux-64", + "timestamp": 1511990142725, + "version": "1.20.1" + }, + "pytest-xdist-1.20.1-py36hd594dc5_0.tar.bz2": { + "build": "py36hd594dc5_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "561404b6a82d801b9c796cea4dffdd6e", + "name": "pytest-xdist", + "sha256": "4e0de89e17d4655c6186c2b41ae12be22da3c84b0ac8c4bc3b385ad3638b8af7", + "size": 49013, + "subdir": "linux-64", + "timestamp": 1511990142638, + "version": "1.20.1" + }, + "pytest-xdist-1.22.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "dceb021ad088e31d428e173b6dfebd08", + "name": "pytest-xdist", + "sha256": "ca84bb1662d6b943b97f4d5c294b1c1fe45d0133c91133b8bd1a042295e40cb6", + "size": 48715, + "subdir": "linux-64", + "timestamp": 1519364616378, + "version": "1.22.1" + }, + "pytest-xdist-1.22.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "75b0ebf6db2d47861425c4c46f25bbaf", + "name": "pytest-xdist", + "sha256": "8b25fa1d4453f225f412f4718bdaaae39685cc6ccde320e1e9a30886eaf4db0f", + "size": 49527, + "subdir": "linux-64", + "timestamp": 1519364647680, + "version": "1.22.1" + }, + "pytest-xdist-1.22.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "18b59621fcb98fdbf83147544347c947", + "name": "pytest-xdist", + "sha256": "7445ae869615653a2a38cb4a866e5b60a9078686672e9a4625e6b03608203d4f", + "size": 49431, + "subdir": "linux-64", + "timestamp": 1519364534914, + "version": "1.22.1" + }, + "pytest-xdist-1.22.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "0e7c5ec628b0e82b9c0974464d51dfac", + "name": "pytest-xdist", + "sha256": "0f8eec38697df916de880a08e60ca28b247e49d562600516abca60a83f95c58f", + "size": 48960, + "subdir": "linux-64", + "timestamp": 1522363252424, + "version": "1.22.2" + }, + "pytest-xdist-1.22.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "304169bb9aeb325e3fa2ac57f83b3432", + "name": "pytest-xdist", + "sha256": "bd367b37578a7efa963d42a81eea21ebc73b7570331005333b111adabb8f07ad", + "size": 49766, + "subdir": "linux-64", + "timestamp": 1522363271774, + "version": "1.22.2" + }, + "pytest-xdist-1.22.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8c1936c797c242b51ffb72d133363930", + "name": "pytest-xdist", + "sha256": "395c1dff1f42716e8097044375aa46aba97d66d245770a380d79b5bccbe78e44", + "size": 49643, + "subdir": "linux-64", + "timestamp": 1522363284373, + "version": "1.22.2" + }, + "pytest-xdist-1.22.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "75e21023a4414f0f9b3ed40b681cd869", + "name": "pytest-xdist", + "sha256": "ac6da59cab7b1337ebbbfbc5752beb7ce6fb36cfa7b8b9709b697da2872b13ab", + "size": 50821, + "subdir": "linux-64", + "timestamp": 1530727964475, + "version": "1.22.2" + }, + "pytest-xdist-1.22.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "80c42f9980751c856c3193920bfe9fea", + "name": "pytest-xdist", + "sha256": "1e07dada75678c97cbcf7cb233245feda557fdfa6d4e7887901faab7598dcea2", + "size": 49967, + "subdir": "linux-64", + "timestamp": 1532998023214, + "version": "1.22.5" + }, + "pytest-xdist-1.22.5-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "dc9818a99eae71c74bd9fd47e2da86bd", + "name": "pytest-xdist", + "sha256": "5463b2929657125d0980114e0e1c347798206414f36ed252fc351f445939712c", + "size": 50077, + "subdir": "linux-64", + "timestamp": 1534347591326, + "version": "1.22.5" + }, + "pytest-xdist-1.22.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "fef94016690b88279abd8d1e22dd534b", + "name": "pytest-xdist", + "sha256": "2d24af6e18889a1c8b712e2b90946fd8e4006627a2c04ad5f488f6f3352e7205", + "size": 51055, + "subdir": "linux-64", + "timestamp": 1532998156271, + "version": "1.22.5" + }, + "pytest-xdist-1.22.5-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "a033c932b553d61d2b1383db5bfa7e44", + "name": "pytest-xdist", + "sha256": "e0e4d22bc44c536925135c99419947cafa890ae2539b8c6752454a5d1b01ef20", + "size": 51014, + "subdir": "linux-64", + "timestamp": 1534347649123, + "version": "1.22.5" + }, + "pytest-xdist-1.22.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "50cacc31c815231d5412a4d2cf622754", + "name": "pytest-xdist", + "sha256": "6552519228819a237ecd6878c73aa7f32a9185609d53b7f070629be6af8a8e4e", + "size": 50880, + "subdir": "linux-64", + "timestamp": 1532997966102, + "version": "1.22.5" + }, + "pytest-xdist-1.22.5-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "af8396c22efa4e640189953b8ec9623a", + "name": "pytest-xdist", + "sha256": "902da10b2493b8ae3fce149d5cb5049c43155ad43af814d912c63f7ad50be326", + "size": 50821, + "subdir": "linux-64", + "timestamp": 1534347620440, + "version": "1.22.5" + }, + "pytest-xdist-1.22.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "8e50da5a4dff1e712a32bb3bf8a4ca58", + "name": "pytest-xdist", + "sha256": "5c8135a22750f5df3505d63fb80ceb79604bf501e5cd5c9f0ece2a4da1ba697f", + "size": 50926, + "subdir": "linux-64", + "timestamp": 1532998108711, + "version": "1.22.5" + }, + "pytest-xdist-1.22.5-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "c23ac1d780ac6fe34b95ffcefd587ab6", + "name": "pytest-xdist", + "sha256": "f50842514e691acd05775dd6d47a65983635399f38e6fc6407babfdb2f6d7824", + "size": 50956, + "subdir": "linux-64", + "timestamp": 1534347677005, + "version": "1.22.5" + }, + "pytest-xdist-1.23.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "4f19181663d86b5437c0660e7e59ba65", + "name": "pytest-xdist", + "sha256": "d95c9828aefaab214f793b469d4779681c0af4e8bcb13ffad53724e305bb688d", + "size": 49028, + "subdir": "linux-64", + "timestamp": 1535421334390, + "version": "1.23.0" + }, + "pytest-xdist-1.23.0-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "fe21a950dcd8bf9c015081eb3a89ccb2", + "name": "pytest-xdist", + "sha256": "ce9246cd28e05ea4652e351fa3150c9870096d7fddd7efec0017ca99837427ec", + "size": 50075, + "subdir": "linux-64", + "timestamp": 1535421381978, + "version": "1.23.0" + }, + "pytest-xdist-1.23.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "e34feb9f1f2ed57762b85c49f671be16", + "name": "pytest-xdist", + "sha256": "8749b6dbe03ac8bab9ad9dbcf992a60d5fa6fbca1ee8e6ce3ccada27a08b92b9", + "size": 49864, + "subdir": "linux-64", + "timestamp": 1535421317912, + "version": "1.23.0" + }, + "pytest-xdist-1.23.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "58069ead3226af7bfd78300fb52c8d46", + "name": "pytest-xdist", + "sha256": "1e428b7974fe308e63ef50b7b46e487a9a1ce843bc6864ff42c204308c64743b", + "size": 49979, + "subdir": "linux-64", + "timestamp": 1535421354053, + "version": "1.23.0" + }, + "pytest-xdist-1.23.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "be6a839bb913876fa90cfdd1c091116d", + "name": "pytest-xdist", + "sha256": "e1c14a2543451890a2bf20875a7073b846f69ce7ff9850a8bc13bbe7282e7e00", + "size": 50714, + "subdir": "linux-64", + "timestamp": 1539638012664, + "version": "1.23.2" + }, + "pytest-xdist-1.23.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "a05b81bf5dc339ddf696769efcdec1e3", + "name": "pytest-xdist", + "sha256": "eec7a57babb05faf7c833606a9f62b6e742bd1138365cf3b6e0979eb8e04881f", + "size": 51514, + "subdir": "linux-64", + "timestamp": 1539638034493, + "version": "1.23.2" + }, + "pytest-xdist-1.23.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "39e988305d7f4d4c6818d4fbe3b58605", + "name": "pytest-xdist", + "sha256": "7041643459925e77aa6a26087ba46f019c0f31900d63fdcb9e62276cd05ffee3", + "size": 51617, + "subdir": "linux-64", + "timestamp": 1539638028335, + "version": "1.23.2" + }, + "pytest-xdist-1.24.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "853665187a996f5a55951f57613638bb", + "name": "pytest-xdist", + "sha256": "6d32ef775fea426a270bea091c62fdb90256aee76d8538cdd771655393a4f43b", + "size": 50785, + "subdir": "linux-64", + "timestamp": 1541037732425, + "version": "1.24.0" + }, + "pytest-xdist-1.24.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "07965ec69450b352e743a2becadb6fb5", + "name": "pytest-xdist", + "sha256": "45de73af86678b40efba46ed4a80a4be0dc9d4939c365f6f0f64291d5fa5ac83", + "size": 51606, + "subdir": "linux-64", + "timestamp": 1541037787307, + "version": "1.24.0" + }, + "pytest-xdist-1.24.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "bc2159436f64106cdf78781e7481c37e", + "name": "pytest-xdist", + "sha256": "cf12a195a9bff7e997639d1959e29a1cd4150c7148ec170d1460022f55667b3d", + "size": 51706, + "subdir": "linux-64", + "timestamp": 1541037749977, + "version": "1.24.0" + }, + "pytest-xdist-1.24.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "79580bf96fc1075cadf8c27de093b1fc", + "name": "pytest-xdist", + "sha256": "092d8dc65edb2b2c54b09b9fbe2c1f9c0811e895849cff4daecb49b035929d6e", + "size": 51003, + "subdir": "linux-64", + "timestamp": 1542087052314, + "version": "1.24.1" + }, + "pytest-xdist-1.24.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "249dac44cf99a76d6a3792b21d5d7c6a", + "name": "pytest-xdist", + "sha256": "ec02c284bb298b5437a24e663a06305a1f68d1480d44ef008095e63a64ac9b28", + "size": 51797, + "subdir": "linux-64", + "timestamp": 1542087035766, + "version": "1.24.1" + }, + "pytest-xdist-1.24.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "c0a6b12d41d47cbf99f26708783b7177", + "name": "pytest-xdist", + "sha256": "8338096b5689b0fcd18f462fcef6d7caba709906ab7c4a7a4f663dcf36317fb9", + "size": 51936, + "subdir": "linux-64", + "timestamp": 1542087036347, + "version": "1.24.1" + }, + "pytest-xdist-1.25.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "7a54143b2e4fb91834c4e796289eb95f", + "name": "pytest-xdist", + "sha256": "e9b0357b2bf3edc0702d892edbd7bff3639d3e3a4cbf3b767064a01b052f6ce7", + "size": 51170, + "subdir": "linux-64", + "timestamp": 1545092750408, + "version": "1.25.0" + }, + "pytest-xdist-1.25.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "646b1b15581ebd80d745957a46406932", + "name": "pytest-xdist", + "sha256": "3896176b417bb9c46dcdd96dc59ba1209e601081a8b2c135a0ffdb68071aa514", + "size": 51932, + "subdir": "linux-64", + "timestamp": 1545092778715, + "version": "1.25.0" + }, + "pytest-xdist-1.25.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "036d230e9a619e3061267c5fa2edb9fa", + "name": "pytest-xdist", + "sha256": "dd95a7c5cb77c7389b21c3eb632fae75e882fa1f1afa53e4d4b7a93edd42bca2", + "size": 52014, + "subdir": "linux-64", + "timestamp": 1545092754408, + "version": "1.25.0" + }, + "pytest-xdist-1.26.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "7f60f82210f5ca714fa6db973d7b744b", + "name": "pytest-xdist", + "sha256": "e2f534cff3e26b6d725e823857c6c471cee228330dcadb72b06a0207c9a93a4b", + "size": 55742, + "subdir": "linux-64", + "timestamp": 1547924969933, + "version": "1.26.0" + }, + "pytest-xdist-1.26.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "0b7e42584130cff3ef84ac37344b7f3d", + "name": "pytest-xdist", + "sha256": "fb722f78aa319d0ede100680029d8fced60f294e614d58c5ecc9189f3785789f", + "size": 56443, + "subdir": "linux-64", + "timestamp": 1547925027301, + "version": "1.26.0" + }, + "pytest-xdist-1.26.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "d3d7ceed0811fd88e2bb917246e121f0", + "name": "pytest-xdist", + "sha256": "aab7e9b8a0bb9a6154e015a8f1c77bc343346d72a60ec7fbd6568ede883e06b2", + "size": 56574, + "subdir": "linux-64", + "timestamp": 1547925028577, + "version": "1.26.0" + }, + "pytest-xdist-1.26.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "bde3d9a0933c1133117cbf52026fff91", + "name": "pytest-xdist", + "sha256": "7e795c333e2dede7036e9b4743c49e268677d66fd66d336b0c55cdc37c0938b8", + "size": 56168, + "subdir": "linux-64", + "timestamp": 1550355388445, + "version": "1.26.1" + }, + "pytest-xdist-1.26.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "cf0b26bda1213b0413709eb7164fcbc5", + "name": "pytest-xdist", + "sha256": "b9f2bd29eea462f2267376dd0afffbd87c98b7a528aa4f2ebca2936ec5107782", + "size": 56762, + "subdir": "linux-64", + "timestamp": 1550355391969, + "version": "1.26.1" + }, + "pytest-xdist-1.26.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "609476986e7376e0b09e7f6758cfda87", + "name": "pytest-xdist", + "sha256": "6627fb0929436c5e2172378974337b8d1d0a954b79b662a04cfec06ac0cff882", + "size": 56799, + "subdir": "linux-64", + "timestamp": 1550355335375, + "version": "1.26.1" + }, + "python-2.7.13-hac47a24_15.tar.bz2": { + "build": "hac47a24_15", + "build_number": 15, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "2fa1d0c654d517d7532d1ea77b1801df", + "name": "python", + "sha256": "af2ab360a9d08d87da6c4ed6dd5b4582a3bf1e48bdfa3ed21ff2b9bcda2945c9", + "size": 10610392, + "subdir": "linux-64", + "timestamp": 1506704236597, + "version": "2.7.13" + }, + "python-2.7.13-heccc3f1_16.tar.bz2": { + "build": "heccc3f1_16", + "build_number": 16, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "f04d5ad55faa63687352027612cef3c9", + "name": "python", + "sha256": "92db30a9d0130549bd0c971a936d046e0804478f2bdcbb74302f1913686d373b", + "size": 10613762, + "subdir": "linux-64", + "timestamp": 1506795306306, + "version": "2.7.13" + }, + "python-2.7.13-hfff3488_13.tar.bz2": { + "build": "hfff3488_13", + "build_number": 13, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "2f1dc0c30e0ad8af774a6c8eaaff5601", + "name": "python", + "sha256": "6335e131661c506c571996443a52cb75971bc743a160e5ed3d7b9b400711b4bf", + "size": 10003184, + "subdir": "linux-64", + "timestamp": 1506041363459, + "version": "2.7.13" + }, + "python-2.7.14-h1571d57_29.tar.bz2": { + "build": "h1571d57_29", + "build_number": 29, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2n,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "a50773e999a719b41772be12b62056b6", + "name": "python", + "sha256": "7bf761efbffa9e115a81947641acef07de528d669f864b9ef6ffc51a7c7ae78e", + "size": 12345855, + "subdir": "linux-64", + "timestamp": 1512666438450, + "version": "2.7.14" + }, + "python-2.7.14-h1571d57_30.tar.bz2": { + "build": "h1571d57_30", + "build_number": 30, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2n,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.22.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "c5b15ca818d7d23a65332188d8643dbf", + "name": "python", + "sha256": "96092113c8ffa3e8f5e17a7d7d84c39a186eced1bd3c3124f95679e5b249d6a1", + "size": 12351375, + "subdir": "linux-64", + "timestamp": 1520858379596, + "version": "2.7.14" + }, + "python-2.7.14-h1571d57_31.tar.bz2": { + "build": "h1571d57_31", + "build_number": 31, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.22.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "674acb012c562692df048a8e29dc3a01", + "name": "python", + "sha256": "40e77f41a973521d30c0951fd2ce87456e8b0c585ae3f9debbe97ad76df9efec", + "size": 12351614, + "subdir": "linux-64", + "timestamp": 1522171961654, + "version": "2.7.14" + }, + "python-2.7.14-h1aa7481_19.tar.bz2": { + "build": "h1aa7481_19", + "build_number": 19, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "3283b97c9bd14e13e6c9527cb4ee75c9", + "name": "python", + "sha256": "75e8dd2e17a2c60a04ee054eabb3339f784b4d19dd0772b904846eda945cc6df", + "size": 10628482, + "subdir": "linux-64", + "timestamp": 1507188548940, + "version": "2.7.14" + }, + "python-2.7.14-h435b27a_18.tar.bz2": { + "build": "h435b27a_18", + "build_number": 18, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "011dffda6cc1478143ffc4b77d4868f1", + "name": "python", + "sha256": "a21d3eb8576a947b26ef5ef8bf06a36dbb2a3426d40c73d328ab3a425035d693", + "size": 10627736, + "subdir": "linux-64", + "timestamp": 1507137677248, + "version": "2.7.14" + }, + "python-2.7.14-h89e7a4a_22.tar.bz2": { + "build": "h89e7a4a_22", + "build_number": 22, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "openssl >=1.0.2l,<1.0.3a", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "e82112ee7ae10f866f95425d9b3c1f4f", + "name": "python", + "sha256": "0d0c0b89b1db24f4443bbb3a99a221a64a3b22c314e4dc6c4f81ef050d10b42f", + "size": 12361284, + "subdir": "linux-64", + "timestamp": 1509128586269, + "version": "2.7.14" + }, + "python-2.7.14-h91f54f5_26.tar.bz2": { + "build": "h91f54f5_26", + "build_number": 26, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "5ccb6d055f501f159478a5d1fed24f60", + "name": "python", + "sha256": "9d535ae47f9eb9034c807a02df247c7548c02fd76844ef3095ea7c206d0f279d", + "size": 12339109, + "subdir": "linux-64", + "timestamp": 1512430790165, + "version": "2.7.14" + }, + "python-2.7.14-h931c8b0_15.tar.bz2": { + "build": "h931c8b0_15", + "build_number": 15, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "6d557821483db1c89afb8a820590d3c1", + "name": "python", + "sha256": "de8200cbb06a12abd3d150a878496af850fd0be5a8d6023abc182e9f1a3fc180", + "size": 10624976, + "subdir": "linux-64", + "timestamp": 1506702652145, + "version": "2.7.14" + }, + "python-2.7.14-h9b67528_20.tar.bz2": { + "build": "h9b67528_20", + "build_number": 20, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "3347eada8954bfd197a7a03e82af992d", + "name": "python", + "sha256": "e48ed3a2ad4a3a0075efad42a5ca969cc71690b00e4b7c978a7ca619a9f7a7e8", + "size": 10634161, + "subdir": "linux-64", + "timestamp": 1507891744641, + "version": "2.7.14" + }, + "python-2.7.14-ha6fc286_23.tar.bz2": { + "build": "ha6fc286_23", + "build_number": 23, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "7aea6b3a5bba4b92cb5701bf23d668c6", + "name": "python", + "sha256": "2114dd87b0ce96d94343d1b2817a33ee10ec5f467edea4a2c22f7a643152d970", + "size": 12360810, + "subdir": "linux-64", + "timestamp": 1510181182550, + "version": "2.7.14" + }, + "python-2.7.14-hc2b0042_21.tar.bz2": { + "build": "hc2b0042_21", + "build_number": 21, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "openssl >=1.0.2l,<1.0.3a", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "18482d250db258093e840b43fedfd4a8", + "name": "python", + "sha256": "e0563adc2d5d40459fddeec67a1241c3936b8f02b0e3dd4bcf8bf69beb0f79f7", + "size": 10634233, + "subdir": "linux-64", + "timestamp": 1508175073462, + "version": "2.7.14" + }, + "python-2.7.14-hdd48546_24.tar.bz2": { + "build": "hdd48546_24", + "build_number": 24, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "2ebd84d3ba4f228a9da02f69393301bc", + "name": "python", + "sha256": "3412f0371757ab0c2fd0723bb3b568c725bdac4d6c07b8ff5fee73257d1b102b", + "size": 12361332, + "subdir": "linux-64", + "timestamp": 1511201179756, + "version": "2.7.14" + }, + "python-2.7.14-hf918d8d_16.tar.bz2": { + "build": "hf918d8d_16", + "build_number": 16, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "e79cc967d4063c9ec4f46d96f743318f", + "name": "python", + "sha256": "17d9f1c6d48d50070685124c5480ed44be6fe55133403be5cd0979bd5dc8c4fe", + "size": 10627123, + "subdir": "linux-64", + "timestamp": 1506795597446, + "version": "2.7.14" + }, + "python-2.7.15-h1571d57_0.tar.bz2": { + "build": "h1571d57_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.23.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "f22cf90f817a14e966c6caf4cbfc0d00", + "name": "python", + "sha256": "640263203a76e15632468d682c6f2f643b76be21d8cfcf894daae43092d6446b", + "size": 12639652, + "subdir": "linux-64", + "timestamp": 1525217741641, + "version": "2.7.15" + }, + "python-2.7.15-h77bded6_1.tar.bz2": { + "build": "h77bded6_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.0.2p,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "ae9500a98aa088a86651e4a56dddc9dc", + "name": "python", + "sha256": "a1748057b636807addf3ba15d839d14a4f3f81c448175232ee97f0cbddd0322f", + "size": 12462822, + "subdir": "linux-64", + "timestamp": 1539099171800, + "version": "2.7.15" + }, + "python-2.7.15-h77bded6_2.tar.bz2": { + "build": "h77bded6_2", + "build_number": 2, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.0.2p,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "7aceb3235d08f48a39a702fde65cdc93", + "name": "python", + "sha256": "4ebbc22a519d3d91b9fac3349a01a337226bac22edbbfb9e4da6550db660d67e", + "size": 12479790, + "subdir": "linux-64", + "timestamp": 1539207228950, + "version": "2.7.15" + }, + "python-2.7.15-h9bab390_2.tar.bz2": { + "build": "h9bab390_2", + "build_number": 2, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "2e9d24206f81be355e77f5a55ce6fe8c", + "name": "python", + "sha256": "575149a99957701b7872a4318fc7fc068439b4a9f2ac54e710d4f86c0f873f65", + "size": 13359590, + "subdir": "linux-64", + "timestamp": 1540319579377, + "version": "2.7.15" + }, + "python-2.7.15-h9bab390_4.tar.bz2": { + "build": "h9bab390_4", + "build_number": 4, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "23c22a86e3a7ce3e62bfea5a969d48b3", + "name": "python", + "sha256": "7d0bb15df38e4d70a2c448f0be619b93590cc5243fc6b46a452d0e881d46773d", + "size": 13383528, + "subdir": "linux-64", + "timestamp": 1542150485045, + "version": "2.7.15" + }, + "python-2.7.15-h9bab390_6.tar.bz2": { + "build": "h9bab390_6", + "build_number": 6, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.3,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "1609879592e045c548823f062750a003", + "name": "python", + "sha256": "d614c561f893ed93a3431cc1af1a3307831bab99e63fae16cf19d47beb561c18", + "size": 13383470, + "subdir": "linux-64", + "timestamp": 1544814391379, + "version": "2.7.15" + }, + "python-2.7.16-h8b3fad2_1.tar.bz2": { + "build": "h8b3fad2_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1c,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "b3ef8f46fcc34e7b5416839a144c96f3", + "name": "python", + "sha256": "44a612d17484cad83f0b053c76d922f50870426866e6ba486937e8ab5e10ac05", + "size": 13152462, + "subdir": "linux-64", + "timestamp": 1565562890512, + "version": "2.7.16" + }, + "python-2.7.16-h8b3fad2_2.tar.bz2": { + "build": "h8b3fad2_2", + "build_number": 2, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1c,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "eae01f7f71074a4330c73ddec885da21", + "name": "python", + "sha256": "cfd68f815e1aa412b89e02e713dd586c9ef1a2b8e7785b877183f383733ab3ca", + "size": 13139819, + "subdir": "linux-64", + "timestamp": 1565715580622, + "version": "2.7.16" + }, + "python-2.7.16-h8b3fad2_3.tar.bz2": { + "build": "h8b3fad2_3", + "build_number": 3, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1c,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "e3411de9c1da50165bc7d3cb5e964191", + "name": "python", + "sha256": "a9ad899abd3c65473c0359bbed34c66a3e1ab7b2eaed3b9e1ec3de04897f9aa8", + "size": 13191472, + "subdir": "linux-64", + "timestamp": 1565911177341, + "version": "2.7.16" + }, + "python-2.7.16-h8b3fad2_4.tar.bz2": { + "build": "h8b3fad2_4", + "build_number": 4, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1c,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "15b59effbcd077b5c0f91b8584b98677", + "name": "python", + "sha256": "3e2156bad242c602a94d2d438a345aab7c66a56e072659d793120e882c79e989", + "size": 13186053, + "subdir": "linux-64", + "timestamp": 1566258829079, + "version": "2.7.16" + }, + "python-2.7.16-h8b3fad2_5.tar.bz2": { + "build": "h8b3fad2_5", + "build_number": 5, + "depends": [ + "ca-certificates", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1c,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "0df93b0f34b8fccdad90ac789eae1f65", + "name": "python", + "sha256": "96c44e09a3367bdd2bda84df1ee93d30ec8172153d25e565abe87535038be636", + "size": 13194737, + "subdir": "linux-64", + "timestamp": 1566489773327, + "version": "2.7.16" + }, + "python-2.7.16-h9bab390_0.tar.bz2": { + "build": "h9bab390_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1b,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.27.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "99da7b596c1da27ac5b66cd5fa9990f6", + "name": "python", + "sha256": "e3980f4e93cc869d0a0dd5edcfa15b865424a89cd98d78dbf20a21f79c2e119b", + "size": 13396798, + "subdir": "linux-64", + "timestamp": 1552597353705, + "version": "2.7.16" + }, + "python-2.7.16-h9bab390_6.tar.bz2": { + "build": "h9bab390_6", + "build_number": 6, + "depends": [ + "ca-certificates", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "64b9707c154aeeef6776c85f19113b74", + "name": "python", + "sha256": "7611c8544f9680d9e923d4d1ebb99463d4cff8397c98b5d8e502abbdb4230d9b", + "size": 13105949, + "subdir": "linux-64", + "timestamp": 1569342486929, + "version": "2.7.16" + }, + "python-2.7.16-h9bab390_7.tar.bz2": { + "build": "h9bab390_7", + "build_number": 7, + "depends": [ + "ca-certificates", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "50f741640c1d7cc647ec9a5902b33d20", + "name": "python", + "sha256": "0f4e1ff435773766edc5d41a417a1f6f9b6aaf17d34136dfb8d5ab21c564cb81", + "size": 13053707, + "subdir": "linux-64", + "timestamp": 1569361971965, + "version": "2.7.16" + }, + "python-2.7.17-h9bab390_0.tar.bz2": { + "build": "h9bab390_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.30.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "79b2e21699e12ff0520c020f793daad9", + "name": "python", + "sha256": "9a3612df96401689b0585fe91b5d96349ab4ca65070d7f16dbb473edfbba118d", + "size": 13162752, + "subdir": "linux-64", + "timestamp": 1571685442704, + "version": "2.7.17" + }, + "python-2.7.18-h02575d3_0.tar.bz2": { + "build": "h02575d3_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "b04c126fedd41c19297d8912c6c391b0", + "name": "python", + "sha256": "788843c2246efa31c8b9791ba4d3026ffd53aee851ab214e18dcdaa35472a6fe", + "size": 13254180, + "subdir": "linux-64", + "timestamp": 1587680414901, + "version": "2.7.18" + }, + "python-2.7.18-h15b4118_1.tar.bz2": { + "build": "h15b4118_1", + "build_number": 1, + "depends": [ + "ca-certificates", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "966e8ba2baae0c4079d407f83811b7aa", + "name": "python", + "sha256": "2e0329ec40a89f8fe28dcf2cebe15a638e5c95e5aae36afef8272126824e60c5", + "size": 13289142, + "subdir": "linux-64", + "timestamp": 1587681905468, + "version": "2.7.18" + }, + "python-2.7.18-h42bf7aa_3.tar.bz2": { + "build": "h42bf7aa_3", + "build_number": 3, + "depends": [ + "ca-certificates", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.0,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "4d40c9ca63ebdc0f9d28ab5817722f8d", + "name": "python", + "sha256": "9dd9ee7c5228b2e74ca7bd76d14a8b43d63b154c7218c038c05c033b28f508a3", + "size": 13397291, + "subdir": "linux-64", + "timestamp": 1669357703766, + "version": "2.7.18" + }, + "python-2.7.18-ha1903f6_2.tar.bz2": { + "build": "ha1903f6_2", + "build_number": 2, + "depends": [ + "ca-certificates", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "readline >=8.0,<9.0a0", + "sqlite >=3.35.4,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "fdce5830464dbf2059a9b1a645949e32", + "name": "python", + "sha256": "57f2c1b197a6536734143f887dc45f216a56396e8af6f36422c48c8fe401435c", + "size": 13251004, + "subdir": "linux-64", + "timestamp": 1622818147285, + "version": "2.7.18" + }, + "python-3.10.0-h12debd9_0.tar.bz2": { + "build": "h12debd9_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libuuid >=1.0.3,<2.0a0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1l,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.36.0,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "b04c09b73ba54d61b656e2dba79dea3a", + "name": "python", + "sha256": "7871af0e712a416fb9680d481a26bc9fe9841f9d99b77ae8f2ada0acaa5eec50", + "size": 24635323, + "subdir": "linux-64", + "timestamp": 1633415473532, + "version": "3.10.0" + }, + "python-3.10.0-h12debd9_1.tar.bz2": { + "build": "h12debd9_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libuuid >=1.0.3,<2.0a0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1l,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.36.0,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "457e8eff272edbdd3dddc17fceb59f19", + "name": "python", + "sha256": "7e855cd30efac2267eca44190bdf6f79bbac318891c7d8882d58fd7f094df2cf", + "size": 24684108, + "subdir": "linux-64", + "timestamp": 1633606523982, + "version": "3.10.0" + }, + "python-3.10.0-h12debd9_2.tar.bz2": { + "build": "h12debd9_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libuuid >=1.0.3,<2.0a0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1l,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.36.0,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "a9c6446816e3a84f3cc54a7e09bb4a28", + "name": "python", + "sha256": "0f9f63fbecaca54415c0430fe4814d86713dfdee09f79f8412e80c0a90f4e152", + "size": 24645434, + "subdir": "linux-64", + "timestamp": 1636442347592, + "version": "3.10.0" + }, + "python-3.10.0-h12debd9_4.tar.bz2": { + "build": "h12debd9_4", + "build_number": 4, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libuuid >=1.0.3,<2.0a0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1l,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.36.0,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "db5d61faa5698cda579565de78dc64ea", + "name": "python", + "sha256": "eb6117944acbc08a4e30b5582b3e5645e18c476e6d950839bbd399bd27849b2c", + "size": 24678438, + "subdir": "linux-64", + "timestamp": 1640094504757, + "version": "3.10.0" + }, + "python-3.10.0-h12debd9_5.tar.bz2": { + "build": "h12debd9_5", + "build_number": 5, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libuuid >=1.0.3,<2.0a0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1m,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.37.2,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "2116d6fb19d79f1d457c452ac42200a9", + "name": "python", + "sha256": "db43b6ab4b0e414ced3602bfb1ec6ef8b1a266ac68f2b403c862b3c34f0867d0", + "size": 24618824, + "subdir": "linux-64", + "timestamp": 1646302104644, + "version": "3.10.0" + }, + "python-3.10.0-h151d27f_3.tar.bz2": { + "build": "h151d27f_3", + "build_number": 3, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libuuid >=1.0.3,<2.0a0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1l,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.36.0,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "96bf2bff78130660ef18df2117a66875", + "name": "python", + "sha256": "ea2112a657b59512e311083efcf065fd986a66281b8a9c4c5d1fcddd6f851ac7", + "size": 24630161, + "subdir": "linux-64", + "timestamp": 1636572485779, + "version": "3.10.0" + }, + "python-3.10.10-h7a1cb2a_2.tar.bz2": { + "build": "h7a1cb2a_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "ncurses >=6.4,<7.0a0", + "openssl >=1.1.1t,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.41.1,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "1aa023cd35336b14b11e21ffd80a189b", + "name": "python", + "sha256": "8dec8191ba7ea2350685858facf2db1998d5699bd4893319371e4843f2d90a81", + "size": 29204663, + "subdir": "linux-64", + "timestamp": 1679425028925, + "version": "3.10.10" + }, + "python-3.10.3-h12debd9_5.tar.bz2": { + "build": "h12debd9_5", + "build_number": 5, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libuuid >=1.0.3,<2.0a0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1n,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.38.0,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "22856f566b2502f56cba0e2aee8fbceb", + "name": "python", + "sha256": "d43ec167c9fe9c2c931715bd8e2324ccd25313274bf34309dd7aa8fcef829f86", + "size": 25427895, + "subdir": "linux-64", + "timestamp": 1648460465568, + "version": "3.10.3" + }, + "python-3.10.4-h12debd9_0.tar.bz2": { + "build": "h12debd9_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libuuid >=1.0.3,<2.0a0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1n,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.38.0,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "f931504bb2eeaf18f20388fd0ad44be4", + "name": "python", + "sha256": "3ac2d9165dbc89e4b309a2fa192c01f7e65a2fd47fad588bad44c66c19ad9af8", + "size": 25334822, + "subdir": "linux-64", + "timestamp": 1648716756622, + "version": "3.10.4" + }, + "python-3.10.6-haa1d7c7_0.tar.bz2": { + "build": "haa1d7c7_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.0.3,<2.0a0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1q,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.39.3,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "de35274226bc16604a91fb18316b1397", + "name": "python", + "sha256": "d7f385ed05a548d70552b828f32be87d8684bc024e59fdf8fe96989904ea177f", + "size": 29045809, + "subdir": "linux-64", + "timestamp": 1665174682954, + "version": "3.10.6" + }, + "python-3.10.6-haa1d7c7_1.tar.bz2": { + "build": "haa1d7c7_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.0.3,<2.0a0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1q,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.39.3,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "5df83d51835cbafbc1f82f483bd9c98a", + "name": "python", + "sha256": "de6e9bee6a4b08e0e23ae5845edaa1bd39fb2bc3f436cc46e14bfeabe7f4987d", + "size": 29019442, + "subdir": "linux-64", + "timestamp": 1666628368918, + "version": "3.10.6" + }, + "python-3.10.8-h7a1cb2a_1.tar.bz2": { + "build": "h7a1cb2a_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.0,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "bde7a51884941bb9be08f8ff7f3038f9", + "name": "python", + "sha256": "18fa9febf5697f3e7ee37eec1c66749e32eb4ec6d656545de0d67f2dc8292019", + "size": 29080192, + "subdir": "linux-64", + "timestamp": 1669299911491, + "version": "3.10.8" + }, + "python-3.10.8-haa1d7c7_0.tar.bz2": { + "build": "haa1d7c7_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.0.3,<2.0a0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1q,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.39.3,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "5038bc52190dba991e9f939aac8d53b1", + "name": "python", + "sha256": "4e4e7e92cecf53b38b712b76d9f27bc9093ce0f2ead3bb2a8a873ed69901ab0e", + "size": 29086648, + "subdir": "linux-64", + "timestamp": 1667570391768, + "version": "3.10.8" + }, + "python-3.10.9-h7a1cb2a_0.tar.bz2": { + "build": "h7a1cb2a_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.1,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.8,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "fe790eb0b0694dc3910e6387bc34afe5", + "name": "python", + "sha256": "01348760c3d68e2720c36ed92302220151ba02def512ae1d9410c16875b7795e", + "size": 29062002, + "subdir": "linux-64", + "timestamp": 1673451212565, + "version": "3.10.9" + }, + "python-3.10.9-h7a1cb2a_1.tar.bz2": { + "build": "h7a1cb2a_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "ncurses >=6.4,<7.0a0", + "openssl >=1.1.1t,<1.1.2a", + "readline >=8.0,<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" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "835bc7eb60d2e5d7d37fa80c39309c17", + "name": "python", + "sha256": "84ea24cc92f730552425682b40892346fadb25762f1e15656d0f15a07b5f4049", + "size": 29088004, + "subdir": "linux-64", + "timestamp": 1677695690580, + "version": "3.10.9" + }, + "python-3.10.9-h7a1cb2a_2.tar.bz2": { + "build": "h7a1cb2a_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "ncurses >=6.4,<7.0a0", + "openssl >=1.1.1t,<1.1.2a", + "readline >=8.0,<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" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "8d2aeb8c2eab7e3da9bb5974e6fd7d2d", + "name": "python", + "sha256": "7d6d303e40cfa689d1e7c56fed228d90f695488e0e01dea3e8cca0ba2914028a", + "size": 29109689, + "subdir": "linux-64", + "timestamp": 1678273132220, + "version": "3.10.9" + }, + "python-3.11.0-h7a1cb2a_2.tar.bz2": { + "build": "h7a1cb2a_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.1,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.8,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "43f479766b80dd8a822b507964c7d82a", + "name": "python", + "sha256": "c138a5a6b233e7e28b5e65a54718141cb051c7bf118f0a99a2170109107a15cb", + "size": 35940468, + "subdir": "linux-64", + "timestamp": 1673879759715, + "version": "3.11.0" + }, + "python-3.11.0-h7a1cb2a_3.tar.bz2": { + "build": "h7a1cb2a_3", + "build_number": 3, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "ncurses >=6.4,<7.0a0", + "openssl >=1.1.1t,<1.1.2a", + "readline >=8.0,<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" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "d62b60f4a14b032813efb9e0528d8d2a", + "name": "python", + "sha256": "ed61d375d5fd29510b3d3489221ef72d472816b2757bde3b6be4027c1a4f0a56", + "size": 35882421, + "subdir": "linux-64", + "timestamp": 1677696154057, + "version": "3.11.0" + }, + "python-3.11.2-h7a1cb2a_0.tar.bz2": { + "build": "h7a1cb2a_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "ncurses >=6.4,<7.0a0", + "openssl >=1.1.1t,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.41.1,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "0199a5c41fc6b08f9e1bc21bcfcc2cc1", + "name": "python", + "sha256": "ea3bbd3888ed8b70b371e105e2e254e69e8255e6da998a89c167863c6f26b6bb", + "size": 36049067, + "subdir": "linux-64", + "timestamp": 1679961522693, + "version": "3.11.2" + }, + "python-3.5.4-h00c01ad_19.tar.bz2": { + "build": "h00c01ad_19", + "build_number": 19, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "53a4884fd90439fa14266a81b6645835", + "name": "python", + "sha256": "7d45705df80434961b795372553e9fef188a2f165fe1e3ac2701bfcdedd3708b", + "size": 27542089, + "subdir": "linux-64", + "timestamp": 1507190766612, + "version": "3.5.4" + }, + "python-3.5.4-h0b4c808_22.tar.bz2": { + "build": "h0b4c808_22", + "build_number": 22, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "openssl >=1.0.2l,<1.0.3a", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "6d1f2c82c4f4112b11629631056b756f", + "name": "python", + "sha256": "220212180400b8b96e4369503f5fc685731f9799f501007e88a4e3a108c1b300", + "size": 29321796, + "subdir": "linux-64", + "timestamp": 1509739610720, + "version": "3.5.4" + }, + "python-3.5.4-h2170f06_12.tar.bz2": { + "build": "h2170f06_12", + "build_number": 12, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "07e1ba5942069197577566364a435753", + "name": "python", + "sha256": "7682d21ccaccb63b65b35b05ee35b30a3f24b6e5ee3bbfb9b869e9eabad89a12", + "size": 26915319, + "subdir": "linux-64", + "timestamp": 1506043755839, + "version": "3.5.4" + }, + "python-3.5.4-h3075507_18.tar.bz2": { + "build": "h3075507_18", + "build_number": 18, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "062343576084dfc16e697d0a139fb06a", + "name": "python", + "sha256": "a9552a7ddd67b2559a5cd3379e7489420ba615e214c7e47d47abe88882acfab8", + "size": 27553509, + "subdir": "linux-64", + "timestamp": 1507151058414, + "version": "3.5.4" + }, + "python-3.5.4-h417fded_24.tar.bz2": { + "build": "h417fded_24", + "build_number": 24, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "7bdd4e10ce41f2e255f1163f13d55a1d", + "name": "python", + "sha256": "d1ce5f157e6f54f4154f6cf8d7ebbbc7acbad63156d01fc748752f7e6f17bfeb", + "size": 29670120, + "subdir": "linux-64", + "timestamp": 1511203805545, + "version": "3.5.4" + }, + "python-3.5.4-h56e0582_23.tar.bz2": { + "build": "h56e0582_23", + "build_number": 23, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "95d0fd49ca76ec60e5948f90869cac81", + "name": "python", + "sha256": "3a41863c3cc352088d982a3e6872431f7e291e039d7991cb9fa468c0f874b25b", + "size": 29323857, + "subdir": "linux-64", + "timestamp": 1510188259673, + "version": "3.5.4" + }, + "python-3.5.4-h72f0b78_15.tar.bz2": { + "build": "h72f0b78_15", + "build_number": 15, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "789359be3d2b615e62929137a741e060", + "name": "python", + "sha256": "20d48de209f6a47f5080ee4eea0acf5db5e8a0ccdbabb67012b5d072f61fb62c", + "size": 27535098, + "subdir": "linux-64", + "timestamp": 1506797197209, + "version": "3.5.4" + }, + "python-3.5.4-hb43c6bb_21.tar.bz2": { + "build": "hb43c6bb_21", + "build_number": 21, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "openssl >=1.0.2l,<1.0.3a", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "b001776082630adff8f489d861878245", + "name": "python", + "sha256": "e7ca2dd5bde805f8339747c54985fc3dbb8e009994d21d6b239ee21d879ff987", + "size": 29312544, + "subdir": "linux-64", + "timestamp": 1509131065647, + "version": "3.5.4" + }, + "python-3.5.4-hc053d89_14.tar.bz2": { + "build": "hc053d89_14", + "build_number": 14, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "021cc5388c1fe7a4617e969d340530f3", + "name": "python", + "sha256": "85437808f9a7bee60b1f8b27abbf3e5a6fcf85b8c5f0f44ab8f8da07c93db87e", + "size": 27536491, + "subdir": "linux-64", + "timestamp": 1506726125431, + "version": "3.5.4" + }, + "python-3.5.4-hc3d631a_27.tar.bz2": { + "build": "hc3d631a_27", + "build_number": 27, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2n,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.22.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "8c344ba27dc00debe335d22da3e7a80a", + "name": "python", + "sha256": "9f7de9e5cb73d3da2bda631ff5aa21e46405003d42e323fda897eb8f83719cf3", + "size": 29670650, + "subdir": "linux-64", + "timestamp": 1519038264770, + "version": "3.5.4" + }, + "python-3.5.4-he2c66cf_20.tar.bz2": { + "build": "he2c66cf_20", + "build_number": 20, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "adb3583d64fc48abebc994bb39322a53", + "name": "python", + "sha256": "a324aa15f199f5a1eb86a4c426c47785a23e2eab3085afe347f38aa687f0abb1", + "size": 27557362, + "subdir": "linux-64", + "timestamp": 1507894095668, + "version": "3.5.4" + }, + "python-3.5.5-hc3d631a_0.tar.bz2": { + "build": "hc3d631a_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2n,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.22.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "4d5f715cdb66e3c0a726afb2e0075df9", + "name": "python", + "sha256": "a06bad4c9d092d89805fd22ca6468c92b0ebc2ff21bca5b3feb3473d303bf9de", + "size": 29659357, + "subdir": "linux-64", + "timestamp": 1520625443196, + "version": "3.5.5" + }, + "python-3.5.5-hc3d631a_1.tar.bz2": { + "build": "hc3d631a_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2n,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.22.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "29a83922027e3320530ac686e7e03e89", + "name": "python", + "sha256": "cb6276904ee90f7f6c67b22c915107628692714aa6d6b0bf0c2179e8d562e104", + "size": 29656837, + "subdir": "linux-64", + "timestamp": 1520896715488, + "version": "3.5.5" + }, + "python-3.5.5-hc3d631a_3.tar.bz2": { + "build": "hc3d631a_3", + "build_number": 3, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.23.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "ea6ff70dbc72d523772c54233132013f", + "name": "python", + "sha256": "6dbc56059e3efd4028a2a178b540c1a38d54cd334e60caa60ea5b2f043164daf", + "size": 29641682, + "subdir": "linux-64", + "timestamp": 1524750804737, + "version": "3.5.5" + }, + "python-3.5.5-hc3d631a_4.tar.bz2": { + "build": "hc3d631a_4", + "build_number": 4, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.23.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "9bb03796d8bfa9f3f2387eaf75e595ec", + "name": "python", + "sha256": "f5f80bc15406ea2d50b8ae9e8bdd08e9076ba9942af4c4ff222e286c0272f075", + "size": 29664054, + "subdir": "linux-64", + "timestamp": 1526246306539, + "version": "3.5.5" + }, + "python-3.5.6-h12debd9_1.tar.bz2": { + "build": "h12debd9_1", + "build_number": 1, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.35.4,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "36044397aacc455aab3c55d41d35d740", + "name": "python", + "sha256": "d128a67a57a1ebbbb5f68312d6c4c742b37dc9885c8bda5ef0cf8861b75e37fe", + "size": 29291912, + "subdir": "linux-64", + "timestamp": 1622833206425, + "version": "3.5.6" + }, + "python-3.5.6-hc3d631a_0.tar.bz2": { + "build": "hc3d631a_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.0.2p,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.24.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "3b1e09ea0bbeadcf1dd6eceb3705fe80", + "name": "python", + "sha256": "d6cff424aa2a3222fcc6115b73ece0ea85c4d155ca97d87f8725c8b6575daef4", + "size": 29653034, + "subdir": "linux-64", + "timestamp": 1535320076551, + "version": "3.5.6" + }, + "python-3.6.10-h0371630_0.tar.bz2": { + "build": "h0371630_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.30.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "d5727f0017399fcd9fb481e9d4651e2e", + "name": "python", + "sha256": "6abd570f65a52453dcea48168642d2f31bc267e15b8e01199b2e039701c56050", + "size": 35585148, + "subdir": "linux-64", + "timestamp": 1578431905715, + "version": "3.6.10" + }, + "python-3.6.10-h191fe78_1.tar.bz2": { + "build": "h191fe78_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1e,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "304f520d029e90f78adafa03429dd9f4", + "name": "python", + "sha256": "121caeb37b5930fe2a92e40b78373faa44f2fb7e4d04be94e3f75f7970c0a426", + "size": 35554455, + "subdir": "linux-64", + "timestamp": 1585005552723, + "version": "3.6.10" + }, + "python-3.6.10-h7579374_2.tar.bz2": { + "build": "h7579374_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "95404bcb9634836a992d7da0b8ce6149", + "name": "python", + "sha256": "93637a34c3318f1e7c60007df262ce1ccd4d7ee978da9e7aef6be59b2a34160b", + "size": 35580114, + "subdir": "linux-64", + "timestamp": 1588906830006, + "version": "3.6.10" + }, + "python-3.6.10-hcf32534_1.tar.bz2": { + "build": "hcf32534_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1e,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "79c138eff21260e467430a87ee79e4b0", + "name": "python", + "sha256": "831418a8fc6fe098dfe258b633778313bfb690bb748df2100f457cbd5bee6699", + "size": 35549575, + "subdir": "linux-64", + "timestamp": 1585180542090, + "version": "3.6.10" + }, + "python-3.6.12-hcff3b4d_2.tar.bz2": { + "build": "hcff3b4d_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "7b6e189509353e47817eb5d9b3a3b8c0", + "name": "python", + "sha256": "c2531805416de74eb387f97a3d9276a3f539a4de79c7f85e64311289b9b10c04", + "size": 35644546, + "subdir": "linux-64", + "timestamp": 1599606857668, + "version": "3.6.12" + }, + "python-3.6.13-h12debd9_1.tar.bz2": { + "build": "h12debd9_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.35.4,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "83abe27f1d8410b1c7cd0cb790ca757d", + "name": "python", + "sha256": "c2a9f988c3ea097a2753164689efbd3a2488d8fa4577852e4c161d4772f31b2c", + "size": 34059963, + "subdir": "linux-64", + "timestamp": 1622834903023, + "version": "3.6.13" + }, + "python-3.6.13-hdb3f193_0.tar.bz2": { + "build": "hdb3f193_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1j,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "fa70ea5a70ec488c63df5e21b7692d68", + "name": "python", + "sha256": "aa64373238378ea15ea8bbeb6b124f21f8cfb6ec7074d2397121074185c6132c", + "size": 35502540, + "subdir": "linux-64", + "timestamp": 1614115100251, + "version": "3.6.13" + }, + "python-3.6.2-h02fb82a_12.tar.bz2": { + "build": "h02fb82a_12", + "build_number": 12, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "97669d1bb19358a35f18c9b134e572ff", + "name": "python", + "sha256": "5c8d5217088b833bd2e736f6a7b1823b6e388c208f88f5a40ae45a67bcdb2721", + "size": 27680668, + "subdir": "linux-64", + "timestamp": 1506046126344, + "version": "3.6.2" + }, + "python-3.6.2-h0b30769_14.tar.bz2": { + "build": "h0b30769_14", + "build_number": 14, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "e089cec7dab2bc33f6ceaddab10f5bfa", + "name": "python", + "sha256": "d0e5c2fb30cf7a13ea662fd69eb731e6ae26c9ccfa50ac08c6809d76baf8dfd8", + "size": 28287085, + "subdir": "linux-64", + "timestamp": 1506708228841, + "version": "3.6.2" + }, + "python-3.6.2-h33255ae_18.tar.bz2": { + "build": "h33255ae_18", + "build_number": 18, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "e31a6732fa4b226f145ebb68f25f0f9e", + "name": "python", + "sha256": "4fafe721641fc6427aa68b6925978aa59e66e27dbd9d3efbe862ac1c78b41e38", + "size": 28292992, + "subdir": "linux-64", + "timestamp": 1507146137504, + "version": "3.6.2" + }, + "python-3.6.2-hca45abc_19.tar.bz2": { + "build": "hca45abc_19", + "build_number": 19, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "bdc6db1adbe7268e3ecbae13ec02066f", + "name": "python", + "sha256": "0b77f7c1f88f9b9dff2d25ab2c65b76ea37eb2fbc3eeab59e74a47b7a61ab20c", + "size": 28300090, + "subdir": "linux-64", + "timestamp": 1507190714034, + "version": "3.6.2" + }, + "python-3.6.2-hdfe5801_15.tar.bz2": { + "build": "hdfe5801_15", + "build_number": 15, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "d2e3a115fa9d29f468cd6b0373e5a4a0", + "name": "python", + "sha256": "00c32bd99be0fa1bc66cfe8ba0df5a50390d085bf35001df647b439b8ec905c5", + "size": 28300423, + "subdir": "linux-64", + "timestamp": 1506797324550, + "version": "3.6.2" + }, + "python-3.6.3-h0ef2715_3.tar.bz2": { + "build": "h0ef2715_3", + "build_number": 3, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "openssl >=1.0.2l,<1.0.3a", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "de1058457d9807126d04d420b6af6114", + "name": "python", + "sha256": "7eec75d7af71ca0781d6ae59dcf8d39204125fcc86058044ee2c0016c4a31285", + "size": 30394317, + "subdir": "linux-64", + "timestamp": 1509737092796, + "version": "3.6.3" + }, + "python-3.6.3-h1284df2_4.tar.bz2": { + "build": "h1284df2_4", + "build_number": 4, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "7f4b82649f8277a5b2b7a5770b547580", + "name": "python", + "sha256": "d757629cc685c8918b5e02bef1a2d2d4f33d8a9e36aafab842963e776e692fea", + "size": 30421566, + "subdir": "linux-64", + "timestamp": 1510187069024, + "version": "3.6.3" + }, + "python-3.6.3-h6c0c0dc_5.tar.bz2": { + "build": "h6c0c0dc_5", + "build_number": 5, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "26df305909b574f66a94d679dcf05cd3", + "name": "python", + "sha256": "3ef46f98cdec937c7dd292e7c05a08b4cc201d64a11b1f6f6721f3cab402cd87", + "size": 30412686, + "subdir": "linux-64", + "timestamp": 1511210831882, + "version": "3.6.3" + }, + "python-3.6.3-hc9025b9_1.tar.bz2": { + "build": "hc9025b9_1", + "build_number": 1, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "d51ec205d22100fe47c27354d4d0f7ed", + "name": "python", + "sha256": "6d1b80008eab9c57f3b1845dd3eb8690a4bca046d8fda92e0bef3694e0f44cfd", + "size": 28330815, + "subdir": "linux-64", + "timestamp": 1507896496429, + "version": "3.6.3" + }, + "python-3.6.3-hcad60d5_0.tar.bz2": { + "build": "hcad60d5_0", + "build_number": 0, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "15871f24d85a686f139f8126d4933856", + "name": "python", + "sha256": "32e1141372bd7e8641ee7f46373b7c9e47e78881b4b345ce5a71c5270e0e006e", + "size": 28333874, + "subdir": "linux-64", + "timestamp": 1507310424228, + "version": "3.6.3" + }, + "python-3.6.3-hefd0734_2.tar.bz2": { + "build": "hefd0734_2", + "build_number": 2, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "openssl >=1.0.2l,<1.0.3a", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "adef47273ea6b0a338fe0b72579a990f", + "name": "python", + "sha256": "aab674c18a35f8929f317d2b69465d2a23ad5d6e1bb4a2572ad1b4e7a66016a9", + "size": 30125117, + "subdir": "linux-64", + "timestamp": 1509133600291, + "version": "3.6.3" + }, + "python-3.6.4-hc3d631a_0.tar.bz2": { + "build": "hc3d631a_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2n,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "69192c5576b2790171b24463884076ae", + "name": "python", + "sha256": "2682dcd3cffba9ffd5ae2ea2b2813a02caa9e684d706fe9df2ab3afc57584471", + "size": 30492913, + "subdir": "linux-64", + "timestamp": 1513892816662, + "version": "3.6.4" + }, + "python-3.6.4-hc3d631a_1.tar.bz2": { + "build": "hc3d631a_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2n,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "2c7beb64b0de961886a4c1e0ecc8440f", + "name": "python", + "sha256": "d165ae3ece6d2382cd13f0098aebf82530aff89eac7b9edd751ad5c0714795e9", + "size": 30526792, + "subdir": "linux-64", + "timestamp": 1516126521222, + "version": "3.6.4" + }, + "python-3.6.4-hc3d631a_3.tar.bz2": { + "build": "hc3d631a_3", + "build_number": 3, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2n,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.22.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "0d6590c00ef27680ed520456c9f70568", + "name": "python", + "sha256": "2484d00166413917e6d03a8d83c4bd24494fa7006a729268d26661f61a65baf7", + "size": 30538077, + "subdir": "linux-64", + "timestamp": 1520904128584, + "version": "3.6.4" + }, + "python-3.6.5-hc3d631a_0.tar.bz2": { + "build": "hc3d631a_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.22.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "f78bb70f8ccea9da6e2da56be8125a4c", + "name": "python", + "sha256": "d3f837fa7b14323df6734054ca7204532d1a2747d05a719a17c13b84ad480516", + "size": 30826334, + "subdir": "linux-64", + "timestamp": 1522348060704, + "version": "3.6.5" + }, + "python-3.6.5-hc3d631a_1.tar.bz2": { + "build": "hc3d631a_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.23.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "fcd93c2321d2ebec1b7496e343c68a7f", + "name": "python", + "sha256": "a8bb03da6d235505f5aae49c4c8ba36294ff103071a1199573cb07287d70c801", + "size": 30827778, + "subdir": "linux-64", + "timestamp": 1524750765703, + "version": "3.6.5" + }, + "python-3.6.5-hc3d631a_2.tar.bz2": { + "build": "hc3d631a_2", + "build_number": 2, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.23.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "8462dd867b9174d46dc8a8054cc87898", + "name": "python", + "sha256": "c6e6364296d06fdb2903e8bd962f2c4d739c99bcd0fb6e784cd3738d6b77bf4c", + "size": 30828818, + "subdir": "linux-64", + "timestamp": 1525018835206, + "version": "3.6.5" + }, + "python-3.6.6-h6e4f718_2.tar.bz2": { + "build": "h6e4f718_2", + "build_number": 2, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.0.2p,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "6612f6a89ac8267625c5cb8205f2e497", + "name": "python", + "sha256": "39af54e6c2d2b2bb5af0755e702d15aabf97970bf0a1cc85957805ba379daa5a", + "size": 30282043, + "subdir": "linux-64", + "timestamp": 1539088676561, + "version": "3.6.6" + }, + "python-3.6.6-hc3d631a_0.tar.bz2": { + "build": "hc3d631a_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.24.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "3c51cb35c13c2fe1cd79b1df378ed89f", + "name": "python", + "sha256": "b7aa47e8a9e91ac3ab36ce9e0e1bf6d90abbbc06ebe507c6fa0b8fb4249affb3", + "size": 30786008, + "subdir": "linux-64", + "timestamp": 1530206464179, + "version": "3.6.6" + }, + "python-3.6.7-h0371630_0.tar.bz2": { + "build": "h0371630_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "c996a2587604c0c7623575dc1d92d202", + "name": "python", + "sha256": "bafd7b4e06ed25c2a6abb22715dd68ed8c0fd6ce937cc05297e903842474e5ac", + "size": 35954120, + "subdir": "linux-64", + "timestamp": 1540322594538, + "version": "3.6.7" + }, + "python-3.6.8-h0371630_0.tar.bz2": { + "build": "h0371630_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.26.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "50686622ccec367e3e704a186faaba89", + "name": "python", + "sha256": "b4011f450a94615322f1c85366d578ee453234815856981212ecb0ade6521064", + "size": 36094923, + "subdir": "linux-64", + "timestamp": 1546133334399, + "version": "3.6.8" + }, + "python-3.6.9-h265db76_0.tar.bz2": { + "build": "h265db76_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1c,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "009a6b92c1c9b232d3917c989d0fee4d", + "name": "python", + "sha256": "454d351d43c49b914d1bcec569323acfa7c4e71f0a2a4e961b0a4f2ac7217e1f", + "size": 36110803, + "subdir": "linux-64", + "timestamp": 1564514018352, + "version": "3.6.9" + }, + "python-3.7.0-h6e4f718_3.tar.bz2": { + "build": "h6e4f718_3", + "build_number": 3, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.0.2p,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "69a7ee432af6f459218c408a0ffe481b", + "name": "python", + "sha256": "d352dfeaa4eb0302701f660397f7c113cc2353c4e81909a7a0630ad97ff9f434", + "size": 32038518, + "subdir": "linux-64", + "timestamp": 1539081483538, + "version": "3.7.0" + }, + "python-3.7.0-hc3d631a_0.tar.bz2": { + "build": "hc3d631a_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.24.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "9e95dfd4a45b7c82b83b97632d015d43", + "name": "python", + "sha256": "f6d1fc33e97a2f37802415f4b09fd0b6be9ce52bf2f9dd0fb8e0dbb6fb844ce3", + "size": 33226619, + "subdir": "linux-64", + "timestamp": 1530192595411, + "version": "3.7.0" + }, + "python-3.7.1-h0371630_3.tar.bz2": { + "build": "h0371630_3", + "build_number": 3, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "9b8ac05022a43b277484cf23fdf2aeb0", + "name": "python", + "sha256": "022097da855271026b6f4238a38c7ca1df296a49984a0494a148f0cfdda4519d", + "size": 38138028, + "subdir": "linux-64", + "timestamp": 1540322940495, + "version": "3.7.1" + }, + "python-3.7.1-h0371630_7.tar.bz2": { + "build": "h0371630_7", + "build_number": 7, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.3,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "297e2547f11548bc7b3bba3b1988cbbf", + "name": "python", + "sha256": "68f53c43fde9fe929e1dabe5823e98d4fc942b089222d58d3e94bda32b863a3d", + "size": 38183536, + "subdir": "linux-64", + "timestamp": 1544816275665, + "version": "3.7.1" + }, + "python-3.7.10-h12debd9_4.tar.bz2": { + "build": "h12debd9_4", + "build_number": 4, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.35.4,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "e26025a8db486c30904bfd3a78285c52", + "name": "python", + "sha256": "a9fab32d57e4581c9c5937c104e8abac4b43dd1919d4f9632fbc0a6bbbae164b", + "size": 53761441, + "subdir": "linux-64", + "timestamp": 1622836409615, + "version": "3.7.10" + }, + "python-3.7.10-hdb3f193_0.tar.bz2": { + "build": "hdb3f193_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1j,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "b8a002c279540af6e1613f071ceaa2e0", + "name": "python", + "sha256": "973bb30d2d0fa3ec29f86bea023fbba3ab895f4bfbdce5ab353e4d686d3a3035", + "size": 55288664, + "subdir": "linux-64", + "timestamp": 1614365716095, + "version": "3.7.10" + }, + "python-3.7.11-h12debd9_0.tar.bz2": { + "build": "h12debd9_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.36.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "3c064546329604100ef3ca7fdb32defc", + "name": "python", + "sha256": "5aa56a9ef335bbee951c4c9ca800492375c0c373d8070746c70362605aac441f", + "size": 55433059, + "subdir": "linux-64", + "timestamp": 1627396740863, + "version": "3.7.11" + }, + "python-3.7.13-h12debd9_0.tar.bz2": { + "build": "h12debd9_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1n,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.38.0,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "ca2e24b817b66cfe8e389762cb9dc340", + "name": "python", + "sha256": "963b5eb8f22efbae90fca09ce2d56c802d05b149e3f9368baf7bb53d06266f3a", + "size": 56117484, + "subdir": "linux-64", + "timestamp": 1648538617113, + "version": "3.7.13" + }, + "python-3.7.13-haa1d7c7_1.tar.bz2": { + "build": "haa1d7c7_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1q,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.39.3,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "1b374c76aedcbdb3a2e0f81a0d3568b1", + "name": "python", + "sha256": "41b5976495ab7326a11631d13c736cd712a3b8295446baf22ad3980e9368067f", + "size": 48678970, + "subdir": "linux-64", + "timestamp": 1666119764107, + "version": "3.7.13" + }, + "python-3.7.15-h7a1cb2a_1.tar.bz2": { + "build": "h7a1cb2a_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.0,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "ed748d955722c39057564a0414eea56b", + "name": "python", + "sha256": "5b8d5a14d1fc4bd92a45701bbf4581ed4fcb9caa42d8ff40a7384a9dd3ae2e5c", + "size": 48781858, + "subdir": "linux-64", + "timestamp": 1669324854204, + "version": "3.7.15" + }, + "python-3.7.15-haa1d7c7_0.tar.bz2": { + "build": "haa1d7c7_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.39.3,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "475f1483d4f64491de0c7cd4d78c1095", + "name": "python", + "sha256": "44ecd13209bdcf8537cd32ac5499ef32f8e407cb081589030d69d620545c5361", + "size": 48758757, + "subdir": "linux-64", + "timestamp": 1667858896956, + "version": "3.7.15" + }, + "python-3.7.16-h7a1cb2a_0.tar.bz2": { + "build": "h7a1cb2a_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.1,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "c196b1fe041b979405ecf05a34e54f12", + "name": "python", + "sha256": "e151c370b49bc7b8970ada28d3094bab8c4b0be0a8a0771e6de19f414bd258a6", + "size": 48726514, + "subdir": "linux-64", + "timestamp": 1673994356396, + "version": "3.7.16" + }, + "python-3.7.2-h0371630_0.tar.bz2": { + "build": "h0371630_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.26.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "ca360a54846b1a5156a461b29f2d1c26", + "name": "python", + "sha256": "2dd7cd2d73fdc6fd1515ff4b152d5539bc8368aa709806dc6644daa3d8022b73", + "size": 38218595, + "subdir": "linux-64", + "timestamp": 1546065063536, + "version": "3.7.2" + }, + "python-3.7.3-h0371630_0.tar.bz2": { + "build": "h0371630_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1b,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.27.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "785d85ff35093ab40bb73ba40b80c012", + "name": "python", + "sha256": "997b40637935ef4b926fed30b80da15994f06e0e1be339e561e97a4f6ab370f4", + "size": 38435024, + "subdir": "linux-64", + "timestamp": 1553725190732, + "version": "3.7.3" + }, + "python-3.7.4-h265db76_0.tar.bz2": { + "build": "h265db76_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1c,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "d20fafb08a15fd787be39dbe94c91a44", + "name": "python", + "sha256": "952650c7ad4917e49585232ba1091567d35bc658a5dece40cb3356255249511f", + "size": 37706645, + "subdir": "linux-64", + "timestamp": 1565378393884, + "version": "3.7.4" + }, + "python-3.7.4-h265db76_1.tar.bz2": { + "build": "h265db76_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1c,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "4329cded9c604f0cf9083479d8562ba3", + "name": "python", + "sha256": "cd7b5e1ebd31e451045959d5f8b3e02209a3d71f06e8aa8dff2c1ed035290ff5", + "size": 38268617, + "subdir": "linux-64", + "timestamp": 1565729005546, + "version": "3.7.4" + }, + "python-3.7.5-h0371630_0.tar.bz2": { + "build": "h0371630_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.30.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "fe3e26ffedee176f3c305508daedde6e", + "name": "python", + "sha256": "7c86aee6e00fa3d420a96ceb97cc2b88d7b6dda19d634f0b461dcbe1cd91c9b5", + "size": 38488890, + "subdir": "linux-64", + "timestamp": 1572019430090, + "version": "3.7.5" + }, + "python-3.7.6-h0371630_2.tar.bz2": { + "build": "h0371630_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.30.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "318ec0cfc87f3a88dfb91dddf6e598e7", + "name": "python", + "sha256": "e04f0195c2b85cda81aeceee329d8af6249d2b0af2b0c1dca166fb3acf152c7f", + "size": 54944167, + "subdir": "linux-64", + "timestamp": 1578514009503, + "version": "3.7.6" + }, + "python-3.7.7-h191fe78_0_cpython.tar.bz2": { + "build": "h191fe78_0_cpython", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1e,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "4ba0e4ecccdaf1293f72cb4e78887e79", + "name": "python", + "sha256": "58c71ba6c863520e1c08f8165950f7e30b16e7e2474d11e3ef50f0efc473eb61", + "size": 55131333, + "subdir": "linux-64", + "timestamp": 1585003409864, + "version": "3.7.7" + }, + "python-3.7.7-hcf32534_0_cpython.tar.bz2": { + "build": "hcf32534_0_cpython", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1e,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "e3221557c8897d1dbee1cb19941afe16", + "name": "python", + "sha256": "73218b465d6eb0d3945c971514db3bde771db0f00ad07b53dcd9f70cfcdddea9", + "size": 55061923, + "subdir": "linux-64", + "timestamp": 1585238182589, + "version": "3.7.7" + }, + "python-3.7.7-hcff3b4d_4.tar.bz2": { + "build": "hcff3b4d_4", + "build_number": 4, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "ebcaa42d2f484e9ed1d490a67281ee8c", + "name": "python", + "sha256": "d83a31078f6155dd6431bbbbed1bf6c6f11a23cb9e2c6660cabc0bb7c48e1200", + "size": 55200215, + "subdir": "linux-64", + "timestamp": 1588761071659, + "version": "3.7.7" + }, + "python-3.7.7-hcff3b4d_5.tar.bz2": { + "build": "hcff3b4d_5", + "build_number": 5, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "1af06415ad233abde08d16f1b3049620", + "name": "python", + "sha256": "18b4c520a80eadf2a54b4590819aca982b900c8cb89b4e76d7952379b6526c59", + "size": 55189878, + "subdir": "linux-64", + "timestamp": 1588887403215, + "version": "3.7.7" + }, + "python-3.7.9-h7579374_0.tar.bz2": { + "build": "h7579374_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "b07ce242931d2ed81e6fdbe35c78fc6a", + "name": "python", + "sha256": "d807f10c16747cb0539deade55fa741f14d1ae8585917ec5efed1330f30a1a3b", + "size": 55316278, + "subdir": "linux-64", + "timestamp": 1598878258314, + "version": "3.7.9" + }, + "python-3.8.0-h0371630_0.tar.bz2": { + "build": "h0371630_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.30.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "a3807855d03205c1b27f00c30e8e4aa9", + "name": "python", + "sha256": "4c71365c9470dd5a9566e8f97ffccfb9257ca0ef8806f2d8553ca89cf724f8e7", + "size": 49817467, + "subdir": "linux-64", + "timestamp": 1571930141605, + "version": "3.8.0" + }, + "python-3.8.0-h0371630_1.tar.bz2": { + "build": "h0371630_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.30.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "e0bb5b28271d3605c3fed41f356475ba", + "name": "python", + "sha256": "3b90c0f8ae485f4ca3ac69dda08f8859de4f084127b174c2c9a0a82a7aece35c", + "size": 49780294, + "subdir": "linux-64", + "timestamp": 1572633250137, + "version": "3.8.0" + }, + "python-3.8.0-h0371630_2.tar.bz2": { + "build": "h0371630_2", + "build_number": 2, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.30.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "6e23accbc74a11af0a20ebfd2e83f714", + "name": "python", + "sha256": "7db1d28c8dee195b5eb5d19ac684198fb18d0861ba2df5291bb22d44cb720832", + "size": 41553890, + "subdir": "linux-64", + "timestamp": 1573077459493, + "version": "3.8.0" + }, + "python-3.8.1-h0371630_1.tar.bz2": { + "build": "h0371630_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.30.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "4d960e71bd5756a89a31b2977368efaa", + "name": "python", + "sha256": "fef7f2a2c5c716c67006037e2377eafed2b21921c6b72d1abdfc538e4942fe8a", + "size": 60583459, + "subdir": "linux-64", + "timestamp": 1578522827542, + "version": "3.8.1" + }, + "python-3.8.10-h12debd9_8.tar.bz2": { + "build": "h12debd9_8", + "build_number": 8, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.35.4,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "ba5ae2057847cc77f0718742fd68df74", + "name": "python", + "sha256": "e4aefa1d2b90c9297db81c6ec12da6da43c7d0c32cacb843b86a1ecebe9f32e1", + "size": 60515074, + "subdir": "linux-64", + "timestamp": 1622837512057, + "version": "3.8.10" + }, + "python-3.8.10-hdb3f193_7.tar.bz2": { + "build": "hdb3f193_7", + "build_number": 7, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.35.4,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "38bde3bde518a4e825276bea9d01d3a3", + "name": "python", + "sha256": "356cf9b1f14f42f6be98c1c2bd2c9e4a3a32a63e93c28ae017f786636e5fe16f", + "size": 61101498, + "subdir": "linux-64", + "timestamp": 1621447816581, + "version": "3.8.10" + }, + "python-3.8.11-h12debd9_0_cpython.tar.bz2": { + "build": "h12debd9_0_cpython", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.36.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "1161e20279cbd13a564675d3473a8f0e", + "name": "python", + "sha256": "18d6fdd23d56cf6c0aae137c986e91c75ec7900c6671760b3e523d6bb240845c", + "size": 23225585, + "subdir": "linux-64", + "timestamp": 1628004030042, + "version": "3.8.11" + }, + "python-3.8.12-h12debd9_0.tar.bz2": { + "build": "h12debd9_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1l,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.36.0,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "c8e445996a0b84db1cc6e2a087615e09", + "name": "python", + "sha256": "963bdbbe1974f274193fca120e89409d82e00b64d5a78fe9291e0f0ecc4d304d", + "size": 23226771, + "subdir": "linux-64", + "timestamp": 1634047242806, + "version": "3.8.12" + }, + "python-3.8.13-h12debd9_0.tar.bz2": { + "build": "h12debd9_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1n,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.38.0,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "747f76169a205d14310fab31a7ed5f31", + "name": "python", + "sha256": "92d4fb3683a4be042f37b39cc5b0999ee1443e9df80dc1131ebf858c69146831", + "size": 23831626, + "subdir": "linux-64", + "timestamp": 1648468088026, + "version": "3.8.13" + }, + "python-3.8.13-haa1d7c7_1.tar.bz2": { + "build": "haa1d7c7_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1q,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.39.3,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "2df219e49e72bbd898dd22eb27e0ae89", + "name": "python", + "sha256": "2b57c5f5aa232fc60cb94c8182b59d76d31c14975afb68b1e133619c100f48e3", + "size": 25506913, + "subdir": "linux-64", + "timestamp": 1666396970498, + "version": "3.8.13" + }, + "python-3.8.15-h3fd9d12_0.tar.bz2": { + "build": "h3fd9d12_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.2,<9.0a0", + "sqlite >=3.39.3,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "aefe780c1ef200517c616f7eb4b95387", + "name": "python", + "sha256": "63ddf0126f6b21339c4dd40a51ff4bf35b4947b3e98e54f12e28f69e02489f74", + "size": 25513908, + "subdir": "linux-64", + "timestamp": 1667596292234, + "version": "3.8.15" + }, + "python-3.8.15-h7a1cb2a_2.tar.bz2": { + "build": "h7a1cb2a_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.0,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "4b2d86f63c31cef731b0c9abc95117b7", + "name": "python", + "sha256": "88bcd64d29376454a0a3595717cbd5ec24395fe6666f4024fbba8e1144535f75", + "size": 25578124, + "subdir": "linux-64", + "timestamp": 1669303847922, + "version": "3.8.15" + }, + "python-3.8.16-h7a1cb2a_2.tar.bz2": { + "build": "h7a1cb2a_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.1,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "f5ff30168b485e102dfab730929a30ad", + "name": "python", + "sha256": "9d0767f094be43b4f9680c33bc69569a42f6d91f9daf03af1eb56560d8750b41", + "size": 25609984, + "subdir": "linux-64", + "timestamp": 1673997772390, + "version": "3.8.16" + }, + "python-3.8.16-h7a1cb2a_3.tar.bz2": { + "build": "h7a1cb2a_3", + "build_number": 3, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.4,<7.0a0", + "openssl >=1.1.1t,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.1,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "79a5f282b7b4ad40d3f8f084be914b5c", + "name": "python", + "sha256": "367a3f197a367cf144438d33d8a48c49fc93e96630c80116b7707f379d42b282", + "size": 25460051, + "subdir": "linux-64", + "timestamp": 1677727904099, + "version": "3.8.16" + }, + "python-3.8.2-h191fe78_0.tar.bz2": { + "build": "h191fe78_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1e,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "cce96497418c92f46118418ec010bddf", + "name": "python", + "sha256": "ab3f02ed7c4cce8c484b4e3cd72723d9e2218fc3fa026c5cdb09f13968ed1884", + "size": 60708741, + "subdir": "linux-64", + "timestamp": 1585156155228, + "version": "3.8.2" + }, + "python-3.8.2-hcf32534_0.tar.bz2": { + "build": "hcf32534_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1e,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "28a1cbe3360bc3c06c17bfbde5aea489", + "name": "python", + "sha256": "7c929d1121ff526c87e437d4d0b895bd53237059985ce95a19d347e21d90f8fa", + "size": 60641340, + "subdir": "linux-64", + "timestamp": 1585238239959, + "version": "3.8.2" + }, + "python-3.8.2-hcff3b4d_13.tar.bz2": { + "build": "hcff3b4d_13", + "build_number": 13, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "48829c2a338f4ee97afbddc2d45b4680", + "name": "python", + "sha256": "29d7783986d560a1f2412ced882a6a8591be1016231d19baa6fe0493504bdadf", + "size": 60014477, + "subdir": "linux-64", + "timestamp": 1588751930438, + "version": "3.8.2" + }, + "python-3.8.2-hcff3b4d_14.tar.bz2": { + "build": "hcff3b4d_14", + "build_number": 14, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "676561e7f03ba1d6716b9dae8be6d879", + "name": "python", + "sha256": "c3e5b35905c5859bc75cbe80500ad0ea7e6972159abf3dc79f9994ae78f51824", + "size": 60080515, + "subdir": "linux-64", + "timestamp": 1588882023313, + "version": "3.8.2" + }, + "python-3.8.3-hcff3b4d_0.tar.bz2": { + "build": "hcff3b4d_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "66f94373cc8f3dc090110feeff50d94b", + "name": "python", + "sha256": "4094516de53b018f1e7ac5e98e43a15478de352cb1182e4e628a15ffba0ab958", + "size": 60096409, + "subdir": "linux-64", + "timestamp": 1589914298793, + "version": "3.8.3" + }, + "python-3.8.3-hcff3b4d_2.tar.bz2": { + "build": "hcff3b4d_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.32.3,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "021f108496bae8c9fbf4feb0128b28eb", + "name": "python", + "sha256": "596dfada6d4dbcea387278d824732e087a3bde9351a9d8e3f71e6b0b2cf36d4d", + "size": 60106630, + "subdir": "linux-64", + "timestamp": 1593707215190, + "version": "3.8.3" + }, + "python-3.8.5-h7579374_1.tar.bz2": { + "build": "h7579374_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "bfd552aa67ef4585a6e87305b25aad52", + "name": "python", + "sha256": "950d6803a259b05e7ea02845d91674c8b17d5de2bd3f6df15660a5ea5cdb2edd", + "size": 60188156, + "subdir": "linux-64", + "timestamp": 1599204963050, + "version": "3.8.5" + }, + "python-3.8.5-hcff3b4d_0.tar.bz2": { + "build": "hcff3b4d_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.32.3,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "879880f6aca1f99fd1c2bad2f5d54041", + "name": "python", + "sha256": "258f86d49b5d10cd2e75bb1beab47ad80a6e53fbf223b72712e1fa19a0c4f09d", + "size": 60194504, + "subdir": "linux-64", + "timestamp": 1596616980258, + "version": "3.8.5" + }, + "python-3.8.8-hdb3f193_4.tar.bz2": { + "build": "hdb3f193_4", + "build_number": 4, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1j,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "239813f378963b56eba689d3527a3491", + "name": "python", + "sha256": "151302619364d7a3488c8d169d7ee1e12cd35854d1a4392814cd219b86e0c88d", + "size": 61064969, + "subdir": "linux-64", + "timestamp": 1614203523008, + "version": "3.8.8" + }, + "python-3.8.8-hdb3f193_5.tar.bz2": { + "build": "hdb3f193_5", + "build_number": 5, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.35.4,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "3d77f20e4ccf448fe23d9a52ac94d25d", + "name": "python", + "sha256": "47d46f7b17b2018615ffe5ee793607fc5ffbeced6af8fefdc999aa97ff9f6a0d", + "size": 61015482, + "subdir": "linux-64", + "timestamp": 1618344138833, + "version": "3.8.8" + }, + "python-3.9.0-hcff3b4d_1.tar.bz2": { + "build": "hcff3b4d_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1h,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "47b79698f55c2c96edc7f6d91221e025", + "name": "python", + "sha256": "16c7db720786896058ea4f5f9ed96331bccfb0a5c7733d039f2336dac3f56ca6", + "size": 25226309, + "subdir": "linux-64", + "timestamp": 1603370132569, + "version": "3.9.0" + }, + "python-3.9.0-hdb3f193_2.tar.bz2": { + "build": "hdb3f193_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1h,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "c41106cbdbb91690ac78ecaab01bc15f", + "name": "python", + "sha256": "17eac96572c5ee0abc6c72024eb20499baac530af8a14f00a158cfa9057b99f4", + "size": 25249955, + "subdir": "linux-64", + "timestamp": 1605451274209, + "version": "3.9.0" + }, + "python-3.9.1-hdb3f193_2.tar.bz2": { + "build": "hdb3f193_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1i,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "f69fcb407a2353ce0a2311ba0bb4fea2", + "name": "python", + "sha256": "055d5e5f6b10a1b0783058b3f211ca275a4e58e441d9b7c226a38605e823172a", + "size": 23792119, + "subdir": "linux-64", + "timestamp": 1607697715126, + "version": "3.9.1" + }, + "python-3.9.11-h12debd9_1.tar.bz2": { + "build": "h12debd9_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1n,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.38.0,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "d4f9f2baa76f7162a0acc8f2b7e86ab6", + "name": "python", + "sha256": "acdf77543fe3ff4978ad497968d4f1f49f756e6f800974ff7f14855dfc79f2c4", + "size": 24547837, + "subdir": "linux-64", + "timestamp": 1648462858132, + "version": "3.9.11" + }, + "python-3.9.11-h12debd9_2.tar.bz2": { + "build": "h12debd9_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1n,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.38.0,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "a0526f43acc4e94cedc93260ebb6b8c6", + "name": "python", + "sha256": "3ca8c3f10aa6e824dc963e733649cfeda7d9017772ab141c9bbbc5c17d86c152", + "size": 24548190, + "subdir": "linux-64", + "timestamp": 1648581530575, + "version": "3.9.11" + }, + "python-3.9.12-h12debd9_0.tar.bz2": { + "build": "h12debd9_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1n,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.38.2,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "1748a26013cb648ccc14e74e4d4ba79a", + "name": "python", + "sha256": "fdfc1fbc60e37843231ca731824c850287ca4a48d065eab0cd4ebba0b999ec34", + "size": 24513027, + "subdir": "linux-64", + "timestamp": 1649142442563, + "version": "3.9.12" + }, + "python-3.9.12-h12debd9_1.tar.bz2": { + "build": "h12debd9_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1o,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.38.3,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "bb118745c9b08fc5028f45e77f371e68", + "name": "python", + "sha256": "c4b9e332a6f2b7524e8c88e2b39a2568a48e556fd9a44c30759c43611d4d023d", + "size": 24553777, + "subdir": "linux-64", + "timestamp": 1654084160832, + "version": "3.9.12" + }, + "python-3.9.13-haa1d7c7_1.tar.bz2": { + "build": "haa1d7c7_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1q,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.39.2,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "19b599ad36b65ad4fdb59b5237cdf8b1", + "name": "python", + "sha256": "08c6645d4f26f23cb8faf9ba59eca3399817df9238bd6105061897710b1ec445", + "size": 26875757, + "subdir": "linux-64", + "timestamp": 1661470658566, + "version": "3.9.13" + }, + "python-3.9.13-haa1d7c7_2.tar.bz2": { + "build": "haa1d7c7_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1q,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.39.3,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "4307f18508dd545ed03237a67f9f2d8c", + "name": "python", + "sha256": "eb6ee81efc6bff31e38f0a2af1b27fa9763008e181e5ea6528339d6e5d473e19", + "size": 26866018, + "subdir": "linux-64", + "timestamp": 1665696352828, + "version": "3.9.13" + }, + "python-3.9.15-h7a1cb2a_2.tar.bz2": { + "build": "h7a1cb2a_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.0,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "6ed0f80128684c6b1cc3d9f06690c83d", + "name": "python", + "sha256": "8877bdd586fb587506d5a9583ab487ed0127049416f1ac7e2e166ac96892832f", + "size": 26876626, + "subdir": "linux-64", + "timestamp": 1669300943987, + "version": "3.9.15" + }, + "python-3.9.15-haa1d7c7_0.tar.bz2": { + "build": "haa1d7c7_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1q,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.39.3,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "b48b9ecf81239dc6f0a6688087c3f400", + "name": "python", + "sha256": "0dd1f0c252b37c10e1d40cbf9b967ae3bc6fc137988cfac02689bcc6aa1a25cb", + "size": 26892691, + "subdir": "linux-64", + "timestamp": 1667579086368, + "version": "3.9.15" + }, + "python-3.9.16-h7a1cb2a_0.tar.bz2": { + "build": "h7a1cb2a_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.1,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.8,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "5a5dc80bee79b7d5bc6a2fdf12c55a80", + "name": "python", + "sha256": "6d2e1f281380b34b49378d3a0da3341c6cb9ca224eaaf4f92863b0b45349832c", + "size": 26867473, + "subdir": "linux-64", + "timestamp": 1673453819331, + "version": "3.9.16" + }, + "python-3.9.16-h7a1cb2a_1.tar.bz2": { + "build": "h7a1cb2a_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.4,<7.0a0", + "openssl >=1.1.1t,<1.1.2a", + "readline >=8.0,<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" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "11b093c06ddbe84b8f536e24d2a7d298", + "name": "python", + "sha256": "48ad9eded00b0e76fd4424a31453bbb51893d14b4a6e760475796f350e48e83e", + "size": 26913493, + "subdir": "linux-64", + "timestamp": 1677695587313, + "version": "3.9.16" + }, + "python-3.9.16-h7a1cb2a_2.tar.bz2": { + "build": "h7a1cb2a_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.4,<7.0a0", + "openssl >=1.1.1t,<1.1.2a", + "readline >=8.0,<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" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "658358564a6660c92ce5c5e156ac6fe4", + "name": "python", + "sha256": "3efad1ec0d30de2c0c86180efc0ddedc2c560fc1acae382244f54b7c9e7a9cb9", + "size": 26836768, + "subdir": "linux-64", + "timestamp": 1678284637555, + "version": "3.9.16" + }, + "python-3.9.2-hdb3f193_0.tar.bz2": { + "build": "hdb3f193_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1j,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "d95af4888e1fa41c4636303e720556f2", + "name": "python", + "sha256": "c517990047d790281de27d125f294148d51fc565e4893b69156a0278ac701a08", + "size": 23900788, + "subdir": "linux-64", + "timestamp": 1614802478495, + "version": "3.9.2" + }, + "python-3.9.4-hdb3f193_0.tar.bz2": { + "build": "hdb3f193_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.35.4,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "c088adb4457e96f9049ce38a49c0364e", + "name": "python", + "sha256": "74052f919128e35341852fb25a255bdc995d860ba7cabdb38781a5a7e97b4aa0", + "size": 23922547, + "subdir": "linux-64", + "timestamp": 1617986779944, + "version": "3.9.4" + }, + "python-3.9.5-h12debd9_4.tar.bz2": { + "build": "h12debd9_4", + "build_number": 4, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.35.4,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "eb1bc6ccb2cbb43adb5a09e5802efef8", + "name": "python", + "sha256": "7fc98fe684cb716a8d19cf20a77ccce3cda3f6da968abaade63edbe006d8f3ba", + "size": 23740654, + "subdir": "linux-64", + "timestamp": 1622828217909, + "version": "3.9.5" + }, + "python-3.9.5-hdb3f193_3.tar.bz2": { + "build": "hdb3f193_3", + "build_number": 3, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.35.4,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "f83a35be417fd414cb16ba3ae03208e5", + "name": "python", + "sha256": "1377d540c3fa4c891ef8a9531bbff303a88e3a457e06bb73de9f9e7e9a589db5", + "size": 23847689, + "subdir": "linux-64", + "timestamp": 1621367201947, + "version": "3.9.5" + }, + "python-3.9.6-h12debd9_0.tar.bz2": { + "build": "h12debd9_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.36.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "0bebbec5a1e78960517abe647da36d6d", + "name": "python", + "sha256": "6010e1d4cc4e7a01849469b989877eee68fc8266e918594dc6d4d482121b75f0", + "size": 23822320, + "subdir": "linux-64", + "timestamp": 1627663625551, + "version": "3.9.6" + }, + "python-3.9.6-h12debd9_1.tar.bz2": { + "build": "h12debd9_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.36.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "c3f8cbc43113cda48436ec24758f79c7", + "name": "python", + "sha256": "e3488e4b737f8cebca072fb549ba72bf553c0034a8948952773902b36c2754d0", + "size": 23764484, + "subdir": "linux-64", + "timestamp": 1629316126728, + "version": "3.9.6" + }, + "python-3.9.7-h12debd9_1.tar.bz2": { + "build": "h12debd9_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1l,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.36.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "e38749b62bfe8328710dda42a747053d", + "name": "python", + "sha256": "1fc166004cfbba0bd28f8c18ff95c39936ac34db9cd8af8a1492702c89e22ee9", + "size": 23930925, + "subdir": "linux-64", + "timestamp": 1631798518713, + "version": "3.9.7" + }, + "python-bidi-0.4.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "8e1e875bc78e488d805f4e0a574af30a", + "name": "python-bidi", + "sha256": "818cf02a6bc0ccc172f40779363e561c3dda8824702706fd8c60e53fd143f057", + "size": 43730, + "subdir": "linux-64", + "timestamp": 1664435164885, + "version": "0.4.2" + }, + "python-bidi-0.4.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "cddf15560d17da528c98856721f6b8d1", + "name": "python-bidi", + "sha256": "f7010b33d9e0318ec58e8c9a9367b5c8ff763c8b45744f3a66a846a4f910f199", + "size": 48902, + "subdir": "linux-64", + "timestamp": 1676861397484, + "version": "0.4.2" + }, + "python-bidi-0.4.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "4586f3f2878f2bb8f8782d5d3dfcedf6", + "name": "python-bidi", + "sha256": "4eefbf8228d854a8e1ad6cc439cb9806135d7661b385969499e8163f019c2187", + "size": 41905, + "subdir": "linux-64", + "timestamp": 1664435213318, + "version": "0.4.2" + }, + "python-bidi-0.4.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "19991bfdc507cc12f2cf2d63ae9a2932", + "name": "python-bidi", + "sha256": "b132c39d2dd080edbb8d75dbde7e6ba217ceed973a914cb04eb0051bdfbeb682", + "size": 42165, + "subdir": "linux-64", + "timestamp": 1664435188957, + "version": "0.4.2" + }, + "python-bidi-0.4.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "7f02d65a4588f68f0072cb1eeb907d02", + "name": "python-bidi", + "sha256": "dfb9bba9fe0b30597270a29771c41590f0208a220ca97a48b16eb178811a0e72", + "size": 42171, + "subdir": "linux-64", + "timestamp": 1664435127790, + "version": "0.4.2" + }, + "python-blosc-1.10.6-py310h00e6091_0.tar.bz2": { + "build": "py310h00e6091_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2733ee3045e357699dd5c3f4f405bb8a", + "name": "python-blosc", + "sha256": "9f812bc35b0c7041119e95976b9315fe83b66c67141d2b260cd4dd7aef025de7", + "size": 49625, + "subdir": "linux-64", + "timestamp": 1640818545906, + "version": "1.10.6" + }, + "python-blosc-1.10.6-py311hba01205_0.tar.bz2": { + "build": "py311hba01205_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "69ed8880fcdf14ec9bdfeba59292c071", + "name": "python-blosc", + "sha256": "278a09320cacea6fd1a7795e64f3d9b79fc3580e578be97a133630eafe1d5714", + "size": 55677, + "subdir": "linux-64", + "timestamp": 1676861425299, + "version": "1.10.6" + }, + "python-blosc-1.10.6-py37h51133e4_0.tar.bz2": { + "build": "py37h51133e4_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a6b6a98b2bed2028b922d5118bcc72bf", + "name": "python-blosc", + "sha256": "54f2dc78686c3201fab939b5651a6249048db2e9a79a620c97179c63db318753", + "size": 53343, + "subdir": "linux-64", + "timestamp": 1638539227297, + "version": "1.10.6" + }, + "python-blosc-1.10.6-py38h51133e4_0.tar.bz2": { + "build": "py38h51133e4_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6143d87aaaaa4d635fc4a29b5a5df78c", + "name": "python-blosc", + "sha256": "3b2bb306467176710e729e31f4746fbe83ae1fb35168a0597414c44b4eca07d2", + "size": 52779, + "subdir": "linux-64", + "timestamp": 1638539873444, + "version": "1.10.6" + }, + "python-blosc-1.10.6-py39h51133e4_0.tar.bz2": { + "build": "py39h51133e4_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2564f26f2d4141341dc2ee3450c3b829", + "name": "python-blosc", + "sha256": "35a8a37589bf6c23fb8ee40141c36b490e0d62bcccaefa2b1ba91f537e5e9f59", + "size": 49234, + "subdir": "linux-64", + "timestamp": 1638539872894, + "version": "1.10.6" + }, + "python-blosc-1.4.4-py27hf341b41_0.tar.bz2": { + "build": "py27hf341b41_0", + "build_number": 0, + "depends": [ + "blosc >=1.12.0,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f7918a9ee231c43c72211ff8872f6795", + "name": "python-blosc", + "sha256": "b1f8f7228a23044c2ba43a0304bcc62f769672d445d2d9b4a7b3d1de16872dfd", + "size": 27129, + "subdir": "linux-64", + "timestamp": 1511806526501, + "version": "1.4.4" + }, + "python-blosc-1.4.4-py35he4ae7a7_0.tar.bz2": { + "build": "py35he4ae7a7_0", + "build_number": 0, + "depends": [ + "blosc >=1.12.0,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1bd9b509162ad1403f7e7137f1ae118d", + "name": "python-blosc", + "sha256": "da67da9301b24f02528a00deb7f3beb3204ff3ce1ce685ed6b81b0b2b8b68507", + "size": 27377, + "subdir": "linux-64", + "timestamp": 1511806525453, + "version": "1.4.4" + }, + "python-blosc-1.4.4-py36hff4f6c4_0.tar.bz2": { + "build": "py36hff4f6c4_0", + "build_number": 0, + "depends": [ + "blosc >=1.12.0,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "410ef79455f6f156bb374f5f62609536", + "name": "python-blosc", + "sha256": "befa88f107634f21fb6a1f3ac4920b9d7ec62a259da299b99eb747c6ca52ae26", + "size": 27295, + "subdir": "linux-64", + "timestamp": 1511806528449, + "version": "1.4.4" + }, + "python-blosc-1.5.1-py27h14c3975_1.tar.bz2": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6115796ad0fd5d42cb08db8c05f51dc6", + "name": "python-blosc", + "sha256": "38a71f2fa1d1ae5f0c3a4b672213bd2f2ecac63e030965d43e6cff23494a86d5", + "size": 28075, + "subdir": "linux-64", + "timestamp": 1530922617004, + "version": "1.5.1" + }, + "python-blosc-1.5.1-py27h14c3975_2.tar.bz2": { + "build": "py27h14c3975_2", + "build_number": 2, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e146d6c916c771519a01753eb3f8970e", + "name": "python-blosc", + "sha256": "1bff8dd95c0f977162af5d8b94e6de9aacce9905d938d8498a09271bfb4c1230", + "size": 39936, + "subdir": "linux-64", + "timestamp": 1531093145165, + "version": "1.5.1" + }, + "python-blosc-1.5.1-py27h3872d65_1.tar.bz2": { + "build": "py27h3872d65_1", + "build_number": 1, + "depends": [ + "blosc >=1.12.0,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3321eebfff36e467296bbbf01220d89e", + "name": "python-blosc", + "sha256": "27e93dde33a417ad2f0d84b67da20d22c436e127c1cd31629ca6f7fcce2fe16c", + "size": 28436, + "subdir": "linux-64", + "timestamp": 1511879559473, + "version": "1.5.1" + }, + "python-blosc-1.5.1-py35h995797e_1.tar.bz2": { + "build": "py35h995797e_1", + "build_number": 1, + "depends": [ + "blosc >=1.12.0,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f7af7b683524dd5b36973dd27b933f3d", + "name": "python-blosc", + "sha256": "af2b77aaf3adaaa35fd9dd1a63820859e7b9a169e5ac761787c0e103932f1c9f", + "size": 28699, + "subdir": "linux-64", + "timestamp": 1511879717585, + "version": "1.5.1" + }, + "python-blosc-1.5.1-py36h14c3975_1.tar.bz2": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cf962454c99a6b9aceb08d9bebe10489", + "name": "python-blosc", + "sha256": "7a8c44b2686fd9760b84c1383f6d360618393f5304b5a9cb655a9a75cfe28e73", + "size": 28207, + "subdir": "linux-64", + "timestamp": 1530922546268, + "version": "1.5.1" + }, + "python-blosc-1.5.1-py36h14c3975_2.tar.bz2": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8e8a12d745934f0715a09b85e3e5d23d", + "name": "python-blosc", + "sha256": "d2fddb0c79f66654f20f479267b47044f7d5a1d2faa30d391ad51bb6ab656af9", + "size": 40126, + "subdir": "linux-64", + "timestamp": 1531093109587, + "version": "1.5.1" + }, + "python-blosc-1.5.1-py36h2adc113_1.tar.bz2": { + "build": "py36h2adc113_1", + "build_number": 1, + "depends": [ + "blosc >=1.12.0,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "de034dcb16c3c9d73e21bd83336829c5", + "name": "python-blosc", + "sha256": "5be1f563e0ad3ca24f0bb5e67735afa37041df8d9e76efa83a4b4de4e04cec33", + "size": 28581, + "subdir": "linux-64", + "timestamp": 1511879718010, + "version": "1.5.1" + }, + "python-blosc-1.5.1-py37h14c3975_1.tar.bz2": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d412903b37f7e0d97afec274bb9b8072", + "name": "python-blosc", + "sha256": "fa4a85fc55a9f0273825f88ebb6bde9fe7652b1e27c1b23a1c83cb2d1ffa4aad", + "size": 28271, + "subdir": "linux-64", + "timestamp": 1530922580916, + "version": "1.5.1" + }, + "python-blosc-1.5.1-py37h14c3975_2.tar.bz2": { + "build": "py37h14c3975_2", + "build_number": 2, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "60c529e4c9daaca96c3d780a37b71c79", + "name": "python-blosc", + "sha256": "83bfc60c4881e5d09ffac1abbbf4e60e0e537554c7f87fa055de500e846c45b9", + "size": 40210, + "subdir": "linux-64", + "timestamp": 1531093179693, + "version": "1.5.1" + }, + "python-blosc-1.7.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "blosc >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1e77576ac528da340bdb4ebd2c514220", + "name": "python-blosc", + "sha256": "b85490a97c16c934c9abb38dd88b74f1587d9271d8a92546ce746c008d234569", + "size": 43759, + "subdir": "linux-64", + "timestamp": 1548005833998, + "version": "1.7.0" + }, + "python-blosc-1.7.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "blosc >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e3a0e68a5b4f97e2f5df9510ac64fc6f", + "name": "python-blosc", + "sha256": "4aed1f1ac92e8a9a977c401394dd391ce469e5a6228bbd37d5240f1c5cf59a62", + "size": 44089, + "subdir": "linux-64", + "timestamp": 1548005112958, + "version": "1.7.0" + }, + "python-blosc-1.7.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "blosc >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8948907a2e6c70ccf8c86f9d255a3504", + "name": "python-blosc", + "sha256": "1ad0015430f43c884cde444e9646abdd71cd4fddd360dda97247ea73ce6004e7", + "size": 44171, + "subdir": "linux-64", + "timestamp": 1548005113501, + "version": "1.7.0" + }, + "python-blosc-1.7.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "blosc >=1.16.3,<2.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2d3d1656123fdc5b1c9066b13bf81725", + "name": "python-blosc", + "sha256": "f5df8ba27898f1c65a39271c36068f7c021dbcd40f2356987b39cc1ff102d158", + "size": 49929, + "subdir": "linux-64", + "timestamp": 1574094348814, + "version": "1.7.0" + }, + "python-build-0.10.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "pyproject_hooks", + "python >=3.10,<3.11.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f334ae12fdaad4036dba29da628240f", + "name": "python-build", + "sha256": "982b2c1b95df94cf882da567d533fa315d169d12ebda71cb6747ea58e762ac12", + "size": 36037, + "subdir": "linux-64", + "timestamp": 1679596564108, + "version": "0.10.0" + }, + "python-build-0.10.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "pyproject_hooks", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d25c94b762b705c7fec59816d93ffbd", + "name": "python-build", + "sha256": "7cc2fbecf1817a5b6e2505bf82b13ef7a25716b7b0a95fd04238fc33829f680e", + "size": 45077, + "subdir": "linux-64", + "timestamp": 1679596590511, + "version": "0.10.0" + }, + "python-build-0.10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "pyproject_hooks", + "python >=3.8,<3.9.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8afb38683416b7d04c1ddca0c326f4c", + "name": "python-build", + "sha256": "f0d74dce353832899df09f6bfdd8429e623fc615832550777938b93f6ddab0aa", + "size": 35737, + "subdir": "linux-64", + "timestamp": 1679596616428, + "version": "0.10.0" + }, + "python-build-0.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "pyproject_hooks", + "python >=3.9,<3.10.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e92f18c1c4d9c47b018bc01d5379f1c", + "name": "python-build", + "sha256": "5887dccd1f2392b84f0c7a99ffaaf574d5daa692412d382ca06b1b01a45785bf", + "size": 35833, + "subdir": "linux-64", + "timestamp": 1679596537656, + "version": "0.10.0" + }, + "python-chromedriver-binary-2.38.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "chromedriver-binary 2.38 0", + "python >=2.7,<2.8.0a0" + ], + "license": "3-Clause BSD", + "license_family": "BSD", + "md5": "4b27a833496b7de228b53bb433c7afa6", + "name": "python-chromedriver-binary", + "sha256": "ad070221569f430cb6401a5b8a5189b3c9d8d2910d0cf2b1fdaf49644d0be5d9", + "size": 10473, + "subdir": "linux-64", + "timestamp": 1527560012431, + "version": "2.38.0" + }, + "python-chromedriver-binary-2.38.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "chromedriver-binary 2.38 0", + "python >=3.5,<3.6.0a0" + ], + "license": "3-Clause BSD", + "license_family": "BSD", + "md5": "2900047aab7222da848adc169c93cdc4", + "name": "python-chromedriver-binary", + "sha256": "1644f24c361967ce0d91843f949602219ec84b35ace76255349542a83398ff70", + "size": 10515, + "subdir": "linux-64", + "timestamp": 1527560001190, + "version": "2.38.0" + }, + "python-chromedriver-binary-2.38.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "chromedriver-binary 2.38 0", + "python >=3.6,<3.7.0a0" + ], + "license": "3-Clause BSD", + "license_family": "BSD", + "md5": "a884c48f200a9b239c89999206f99ed0", + "name": "python-chromedriver-binary", + "sha256": "7e6b484f9eea8746347c1e659307aa2e90efa64f082acb5e7b1e934b0454920a", + "size": 10502, + "subdir": "linux-64", + "timestamp": 1527559989242, + "version": "2.38.0" + }, + "python-clang-14.0.6-default_py310h261c368_0.tar.bz2": { + "build": "default_py310h261c368_0", + "build_number": 0, + "depends": [ + "libclang 14.0.6", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "5122f296dfab1ea7fbcf89ba9084d118", + "name": "python-clang", + "sha256": "87c975c48bec9f4ac35b3b8dc670227cbffb60bc187404b86f9f21503bfcc493", + "size": 203397, + "subdir": "linux-64", + "timestamp": 1661930439227, + "version": "14.0.6" + }, + "python-clang-14.0.6-default_py311h261c368_0.tar.bz2": { + "build": "default_py311h261c368_0", + "build_number": 0, + "depends": [ + "libclang 14.0.6", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "a765d843de1c04f25bd33cf4925df8a0", + "name": "python-clang", + "sha256": "a86dbc3dfc5eac78724fec3819b3f0f08bb6fc96e0e5c15e6136bce69daa52ec", + "size": 219130, + "subdir": "linux-64", + "timestamp": 1676851081917, + "version": "14.0.6" + }, + "python-clang-14.0.6-default_py37h261c368_0.tar.bz2": { + "build": "default_py37h261c368_0", + "build_number": 0, + "depends": [ + "libclang 14.0.6", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "f32d49bbbf1cacaffc4649619ddc3e01", + "name": "python-clang", + "sha256": "4d67a6fa36601f7bef7717b1fb40f3ee1d3f70338f7c6a6a9c3409e19f607932", + "size": 201568, + "subdir": "linux-64", + "timestamp": 1661930467636, + "version": "14.0.6" + }, + "python-clang-14.0.6-default_py38h261c368_0.tar.bz2": { + "build": "default_py38h261c368_0", + "build_number": 0, + "depends": [ + "libclang 14.0.6", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "ebf159b5b2c0efe92fe9fc5e3a96ffa8", + "name": "python-clang", + "sha256": "87a80d5860e8d864988efb75689425c82e63381fe3eeb233bd88c6e58932b1a8", + "size": 201956, + "subdir": "linux-64", + "timestamp": 1661930447752, + "version": "14.0.6" + }, + "python-clang-14.0.6-default_py39h261c368_0.tar.bz2": { + "build": "default_py39h261c368_0", + "build_number": 0, + "depends": [ + "libclang 14.0.6", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "abf51747e7f52301589bf4392ec6c07a", + "name": "python-clang", + "sha256": "ecc7e6de9cf0693c4ec128f234219e0a5d30e48e8d7744f772cb34d18443b255", + "size": 201852, + "subdir": "linux-64", + "timestamp": 1661930459169, + "version": "14.0.6" + }, + "python-crfsuite-0.9.5-py27h6bb024c_0.tar.bz2": { + "build": "py27h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de1e726768143d04e33dc2926877688a", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "395fd8607e5e97add0ce5261db1aa64172910c70182994738c2b7fae96731eb4", + "size": 187709, + "subdir": "linux-64", + "timestamp": 1525817318438, + "version": "0.9.5" + }, + "python-crfsuite-0.9.5-py35h6bb024c_0.tar.bz2": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f4d9e5ed1f148e9e0e7c50f2d1fc016e", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "c05b790f8a95d2b8fd4c212f678ac21ed7953e570664cf2ed33c512bce3298cc", + "size": 188767, + "subdir": "linux-64", + "timestamp": 1525817410998, + "version": "0.9.5" + }, + "python-crfsuite-0.9.5-py36h6bb024c_0.tar.bz2": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "25b11ce54fdc2eed3fb2bf47d05bac4e", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "6799211ba309a04b1f8a0f8ad01fac4499e124b667ca8df2461b6d1aec04a996", + "size": 191265, + "subdir": "linux-64", + "timestamp": 1525817413420, + "version": "0.9.5" + }, + "python-crfsuite-0.9.6-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe31c86a07099a47aaf2186de6d081d4", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "6221773754a817601a213acc92fd20af43a79d93d2abe811437c9fe20733feaf", + "size": 191518, + "subdir": "linux-64", + "timestamp": 1535179386778, + "version": "0.9.6" + }, + "python-crfsuite-0.9.6-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e80c104ee06accc5120311416c3637f5", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "c23ac5dd9f7af3c86c8715bf469ed5e9c773fe3b8e0a1cd29ce4f4227c6bed7a", + "size": 192243, + "subdir": "linux-64", + "timestamp": 1535179449847, + "version": "0.9.6" + }, + "python-crfsuite-0.9.6-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80d54c246418235dec3d3e89f89d14a9", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "382540cbef921b328cb564948f600baa847050634cfc6acc079bc56584e53810", + "size": 198985, + "subdir": "linux-64", + "timestamp": 1613553302328, + "version": "0.9.6" + }, + "python-crfsuite-0.9.6-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cf8adf36ecdc9c2c7261fa344dfc2537", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "f5ac78a335cc85d065669ef076f4644a0c081f2e744f088835d40e925130fd3b", + "size": 194736, + "subdir": "linux-64", + "timestamp": 1535179444454, + "version": "0.9.6" + }, + "python-crfsuite-0.9.6-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "40450c34357d3d7ee2f641f688a6f65d", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "ef311a8a2fe80ff8878d0b9ee5476600941d2bbe916ce542176ab06f17fd09fc", + "size": 198413, + "subdir": "linux-64", + "timestamp": 1613553952450, + "version": "0.9.6" + }, + "python-crfsuite-0.9.6-py37hf484d3e_0.tar.bz2": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "70638706a8bbbadfa95299efb355b75b", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "f324470319c247bf1bba821791857cbf7936016998d8ae3cf9d31127f6dcf6b3", + "size": 194355, + "subdir": "linux-64", + "timestamp": 1535179380200, + "version": "0.9.6" + }, + "python-crfsuite-0.9.6-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "abe5245da16f089fdc83352b3b73ad56", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "c4e41b949f702a13e9943a75fdc55f2111bcb9c0cffa4c297da697a8a3465b2a", + "size": 202357, + "subdir": "linux-64", + "timestamp": 1613553325362, + "version": "0.9.6" + }, + "python-crfsuite-0.9.6-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f952f4bcf733121e0e4ff74d6052879c", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "16e59a50bf8525d22ce3cd970b97f9c986c9fa90021a1755532d2d554a9f6c53", + "size": 207425, + "subdir": "linux-64", + "timestamp": 1573200441300, + "version": "0.9.6" + }, + "python-crfsuite-0.9.7-py310h295c915_1.tar.bz2": { + "build": "py310h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9eabc16471f45197afa351fac8f6f80d", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "78e3806c1e6f084fc5ba79cb5f0cf4a410a8aa1bd5d0d5157d31082b5c542db6", + "size": 794645, + "subdir": "linux-64", + "timestamp": 1643101022033, + "version": "0.9.7" + }, + "python-crfsuite-0.9.7-py36h2531618_1.tar.bz2": { + "build": "py36h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f89c069919e50c0788871d0455f3a19", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "8ac180ca24a26ab718d0f67b9f5a6d5da5a90829c226c8a47cad1d925235b77a", + "size": 196770, + "subdir": "linux-64", + "timestamp": 1613555035975, + "version": "0.9.7" + }, + "python-crfsuite-0.9.7-py37h2531618_1.tar.bz2": { + "build": "py37h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15f5fc2bb89230ed392a1e510877b4da", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "679a060cbe51bebc7efd4f27c12295d535853579955b4ce3d76aa40c4c36d7cc", + "size": 196609, + "subdir": "linux-64", + "timestamp": 1613555027704, + "version": "0.9.7" + }, + "python-crfsuite-0.9.7-py38h2531618_1.tar.bz2": { + "build": "py38h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6795cec9cd00bb5c3d315bfcfed33f82", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "476801e900be8f9ab975266e39d32bc60d3289ead141ee5fd76163904ad1f34a", + "size": 199953, + "subdir": "linux-64", + "timestamp": 1613554293146, + "version": "0.9.7" + }, + "python-crfsuite-0.9.7-py39h2531618_1.tar.bz2": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d98ef08020a25e40b3832aca722d7263", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "05651e3ac01b91d4050727b1ca327be58542e5588ee5162251a054a75a13ae12", + "size": 199489, + "subdir": "linux-64", + "timestamp": 1613555034219, + "version": "0.9.7" + }, + "python-crfsuite-0.9.9-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1d0655104606273b0841ae8ea1f7200", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "97645d4a81227851c87f77d694203a88234c922415799ceb3089659de876e2fb", + "size": 188205, + "subdir": "linux-64", + "timestamp": 1676300687729, + "version": "0.9.9" + }, + "python-crfsuite-0.9.9-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6002eff750edc11de6187c2d0294cca", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "7010e40b95625da5c1b9d93a437ad24e91c2b49f09efc1d4c1cd2226326aa4bf", + "size": 191056, + "subdir": "linux-64", + "timestamp": 1676861452432, + "version": "0.9.9" + }, + "python-crfsuite-0.9.9-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6bb29b1fafa275ba8b9d86b3e025cde9", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "d79405f30e363ad329f3afb728b316fbeb12099d876fce110f897895e5e4f7ca", + "size": 189798, + "subdir": "linux-64", + "timestamp": 1676300641857, + "version": "0.9.9" + }, + "python-crfsuite-0.9.9-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "793d7f90e487e1a8da931b6b452ea719", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "eccba1b789f1f294163ee1abc2dccf8e69dab8364a1d0dfe02ab8f70f3500a89", + "size": 191937, + "subdir": "linux-64", + "timestamp": 1676300738025, + "version": "0.9.9" + }, + "python-crfsuite-0.9.9-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0fd555322876ca94b00c3e0f2c33e757", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "8b5b3233ae213a8b997372283db201074efb48b8056d529561de3b39b3c018e0", + "size": 189732, + "subdir": "linux-64", + "timestamp": 1676300782809, + "version": "0.9.9" + }, + "python-daemon-2.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "929178ca24a4ce40f94b460bdd2bb6ec", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "84b05a354e44cb4463a261fda409b893214e42f9c93200102219eb1513503d15", + "size": 26008, + "subdir": "linux-64", + "timestamp": 1530898967985, + "version": "2.1.2" + }, + "python-daemon-2.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "9a4b556c48948db7b4686433cb2fef91", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "53d8318784943432c304cef6efa942373b8bea1a5ea891069000c9499ea89281", + "size": 26436, + "subdir": "linux-64", + "timestamp": 1530899029202, + "version": "2.1.2" + }, + "python-daemon-2.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "3db5ac88f716d93f959e6db29d396c70", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "713d3e2808c1029c2aea20bcba44621688b516751ec42cce761d942f32f37621", + "size": 26490, + "subdir": "linux-64", + "timestamp": 1530898998526, + "version": "2.1.2" + }, + "python-daemon-2.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "a9e4eb2988ce7827df9c58a04b5b68e2", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "1027c6a42e012e6630fa58cf7edfeb92eb956ccfbf4572b277f385e8382e8025", + "size": 27620, + "subdir": "linux-64", + "timestamp": 1535521584709, + "version": "2.2.0" + }, + "python-daemon-2.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "9cd53a8ab96b5750dd93c72c7657f827", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "4dcfd8c0dfae7e53b9bb08499af11ac4feed011ace2404413010ec63548d2205", + "size": 28137, + "subdir": "linux-64", + "timestamp": 1535523335104, + "version": "2.2.0" + }, + "python-daemon-2.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "297827c869ad2662ba7d212d73fda53e", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "3accd7eeaaeb1214da0bce92ff718105f3871b3725ed31bb10ca96916625113c", + "size": 28105, + "subdir": "linux-64", + "timestamp": 1535521562744, + "version": "2.2.0" + }, + "python-daemon-2.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "c3a72c2acdf7a37fba620505dada2d23", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "dce5278f7ff8b6b8a147f2c125530305dd58c856e32a57f2e0f0b3e593d75bdd", + "size": 28101, + "subdir": "linux-64", + "timestamp": 1535521609612, + "version": "2.2.0" + }, + "python-daemon-2.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "991b1b5383f93ebc053d07066069a8bc", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "2038c1c058905bbc46a6370d2bfe3043df6f9da388654522249b283ac73ec3a7", + "size": 154588, + "subdir": "linux-64", + "timestamp": 1547983359673, + "version": "2.2.1" + }, + "python-daemon-2.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "9f914e7f9ed38f3c11505782e6d0f1bb", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "5962f6145e30670adb5cc3be40796b6ae2ec87c800a8b8d2f9ad2e9b9fda533d", + "size": 155390, + "subdir": "linux-64", + "timestamp": 1547983450012, + "version": "2.2.1" + }, + "python-daemon-2.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "d0c590a60d3bb0dd3baed526324db233", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "b0a15a0996cb0db7f8bd02281b0ba94516391d08ecd734a9596a26a7ac4e04d1", + "size": 155177, + "subdir": "linux-64", + "timestamp": 1547983496291, + "version": "2.2.1" + }, + "python-daemon-2.2.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "3a27d3536ec015b9aaceb80243242d9a", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "7de905e77df1a1616e3b66e41334041eb0572a752968f43a6eba6f9a82818e98", + "size": 162741, + "subdir": "linux-64", + "timestamp": 1552365999787, + "version": "2.2.3" + }, + "python-daemon-2.2.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "add5ae5f7d6967b6507db918a8fa2ee4", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "44d4d25820a90af8e3701a21ddc26de1b3cbbe02a1ae36d211429ac0e74d1434", + "size": 163528, + "subdir": "linux-64", + "timestamp": 1552366037977, + "version": "2.2.3" + }, + "python-daemon-2.2.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "c6f2cf020de8b4e796749cc3a11cf352", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "185218e1cad469fb186df1971b77c4408041056a1eae19c8747103d0870897cf", + "size": 163289, + "subdir": "linux-64", + "timestamp": 1552365998704, + "version": "2.2.3" + }, + "python-daemon-2.2.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "a1b09a874dd2395216f3ce57019ad6ef", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "ff17efc39b3f638bc4de3dbc1f65476a25085dfd8ab7de4eda85c747e4965488", + "size": 304960, + "subdir": "linux-64", + "timestamp": 1636034744906, + "version": "2.2.3" + }, + "python-daemon-2.2.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "30ee103c878e7c80e3b8e0edb8e4cc70", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "40f3e63dab62f9121100bc78b84f76a925d0c1cbb1eca9c7f522e34fb5556fe2", + "size": 28735, + "subdir": "linux-64", + "timestamp": 1574273943275, + "version": "2.2.3" + }, + "python-daemon-2.2.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "153f2c0d86a24006cb5a2fa60e0a7dd8", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "0c5c3077d0369f647c9bdeea0204bb0b943f3020a6528551ba16ae4335a76f4e", + "size": 305170, + "subdir": "linux-64", + "timestamp": 1636034747174, + "version": "2.2.3" + }, + "python-daemon-2.2.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "c5fb2dd866f6d81b7cb42d7871102676", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "d80d730c10624e63f2f1ee4fcb77e1090812d2bd1cf8372f359aa80f52fb2a83", + "size": 309823, + "subdir": "linux-64", + "timestamp": 1636034221575, + "version": "2.2.3" + }, + "python-daemon-2.2.4-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a3b3d442f078cd4a2ac2e520cbbae6f9", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "b8758e7a3df3dcdbe210253fda587fd7d02fd51eb82b8bdd90d88703744712b9", + "size": 45739, + "subdir": "linux-64", + "timestamp": 1600290951291, + "version": "2.2.4" + }, + "python-daemon-2.2.4-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "66d6f61e1429db5d867987c30625cccc", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "3c2ee31cf0ec387276d2cb64bf62d047539295cb511861ad7d429662fa6ea7d9", + "size": 45930, + "subdir": "linux-64", + "timestamp": 1613484938753, + "version": "2.2.4" + }, + "python-daemon-2.2.4-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "3823ee256b8b55cb59ddbbe413c1c53e", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "50c96d81e73df7dc4d06adde3c60ac7a70d5bdf296704e2d94896602e3aa1e9c", + "size": 45857, + "subdir": "linux-64", + "timestamp": 1600290969032, + "version": "2.2.4" + }, + "python-daemon-2.2.4-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e242f46802f58f30c8c7423093c9c748", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "37f77b6a26242c6953345691861f1574134c35bbc072f0528fa65d1339c652be", + "size": 45997, + "subdir": "linux-64", + "timestamp": 1613485566042, + "version": "2.2.4" + }, + "python-daemon-2.2.4-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "bd6e1994c0c6ee571a5623357afd46af", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "20fb0b80f12a1b5f42ccded2400b082a9b0de345d1108b29cb81afa7d6a05a86", + "size": 45977, + "subdir": "linux-64", + "timestamp": 1600290945293, + "version": "2.2.4" + }, + "python-daemon-2.2.4-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f9c30fcc3aefd65cc2d24f69507b9ab6", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "1ebe6ecb4154541487259fb44da75faf8d4a9979d77f49c4b0e35b5d943db5b3", + "size": 46145, + "subdir": "linux-64", + "timestamp": 1613485564040, + "version": "2.2.4" + }, + "python-daemon-2.2.4-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "2114a00b5ed459bc8bf84945fea53e3c", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "52aa4e0f31ca85408913e74533770a3892a3a120bd5099fb667d1ebe0a1bb275", + "size": 45935, + "subdir": "linux-64", + "timestamp": 1613553305396, + "version": "2.2.4" + }, + "python-daemon-2.3.0-py310h06a4308_3.tar.bz2": { + "build": "py310h06a4308_3", + "build_number": 3, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a12a4722dcfa9ded00090c3db24a493c", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "50ac09e0ad616f5c9bcd1e9cd168abb1be9aeab61a0b4e8252e983690c0e4a26", + "size": 44499, + "subdir": "linux-64", + "timestamp": 1640829124107, + "version": "2.3.0" + }, + "python-daemon-2.3.0-py36h06a4308_3.tar.bz2": { + "build": "py36h06a4308_3", + "build_number": 3, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "3ecbd0340848dd9a41c960e9f57a8e5e", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "3b9edd1ba807666790b20e85bceec183a90b59e402d52752e74f3e5d69c2ab3b", + "size": 44254, + "subdir": "linux-64", + "timestamp": 1613936318494, + "version": "2.3.0" + }, + "python-daemon-2.3.0-py37h06a4308_3.tar.bz2": { + "build": "py37h06a4308_3", + "build_number": 3, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "fbd68593f85e0404468a8da02ac49033", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "a0f11a0f08a21bb9d062c3cdf48263c6ae2afa40521c8c6716b93e99212f8022", + "size": 44291, + "subdir": "linux-64", + "timestamp": 1613936304725, + "version": "2.3.0" + }, + "python-daemon-2.3.0-py38h06a4308_3.tar.bz2": { + "build": "py38h06a4308_3", + "build_number": 3, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "195f37eca5a7f8cb44c9e599eba6e4c4", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "4c8df7d79b914389154049f2182c4ba6404ebd7dd406ff33355b920cbf712760", + "size": 44444, + "subdir": "linux-64", + "timestamp": 1613936318905, + "version": "2.3.0" + }, + "python-daemon-2.3.0-py39h06a4308_3.tar.bz2": { + "build": "py39h06a4308_3", + "build_number": 3, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "681c0d480e1a13a0b585554631f5cad8", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "d94382450d5b386df2800a05e060b4e414abf9e3d98225f1e841916bc221ce4b", + "size": 44365, + "subdir": "linux-64", + "timestamp": 1613935857631, + "version": "2.3.0" + }, + "python-daemon-2.3.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c00507fa4524d2489d89f981db71df48", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "34ef0414facba766aa60d807a00007264da84ebbcfc81e8ff0d68e374d42eb3d", + "size": 44524, + "subdir": "linux-64", + "timestamp": 1659602443416, + "version": "2.3.1" + }, + "python-daemon-2.3.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "686d2c6dfdc09b76d4a663288e0b1246", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "4fc86729e26b15239fa15b129e5cb8ecbed5afe1a2d792b465ef18411f9ff7a2", + "size": 49386, + "subdir": "linux-64", + "timestamp": 1676904157786, + "version": "2.3.1" + }, + "python-daemon-2.3.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "191f69758494b189c6a8ec7dc4e258a9", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "d2175a3e612caf48298ab4e0b9819c2c2e019381c5f0e3ab6ee58436b8288df1", + "size": 44293, + "subdir": "linux-64", + "timestamp": 1659602406105, + "version": "2.3.1" + }, + "python-daemon-2.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "2d01f85dbec3c2b7247b67a31015f9cd", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "227ecbd68eb9a1b36532b38c9fa163bc4cc9b21fbd3e9d49987d9619aec88e55", + "size": 44255, + "subdir": "linux-64", + "timestamp": 1659602470122, + "version": "2.3.1" + }, + "python-daemon-2.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "159d7fc399d9c7b5c288cd7b831a4fa6", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "ed86579dce97720db700c0811536ee111bac2a53f2b9ea15b81e7cbeec516c70", + "size": 44296, + "subdir": "linux-64", + "timestamp": 1659602496757, + "version": "2.3.1" + }, + "python-dateutil-2.6.1-py27h4ca5741_1.tar.bz2": { + "build": "py27h4ca5741_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-clause", + "md5": "dffa336c38a7f4fdb155a034af0cc35b", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "fd33393f8f4bbd663d8a35911e9213aee5d4786c41b1934a9df5923c01e0840d", + "size": 242225, + "subdir": "linux-64", + "timestamp": 1505688441572, + "version": "2.6.1" + }, + "python-dateutil-2.6.1-py35h90d5b31_1.tar.bz2": { + "build": "py35h90d5b31_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-clause", + "md5": "81bdd7c0d970ed09e9042e1caaade945", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "82c0c77047b21728b8c2c2e768d198c4cd4b43d746eadc1df034721ee96cf50c", + "size": 243871, + "subdir": "linux-64", + "timestamp": 1505688453376, + "version": "2.6.1" + }, + "python-dateutil-2.6.1-py36h88d3b88_1.tar.bz2": { + "build": "py36h88d3b88_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-clause", + "md5": "05517cfd206264a914e81ba0b6217dcc", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "08a38372cfe0c6058d463383e26294d3704828054b9a279d6f7a2a6207580027", + "size": 243124, + "subdir": "linux-64", + "timestamp": 1505688465343, + "version": "2.6.1" + }, + "python-dateutil-2.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.5" + ], + "license": "BSD 3-clause", + "md5": "b0786829bcc48f4f08680153ffc0136a", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "bf878031020018d8f8b562c0517fa62847188a27bc0bed540800f7d69d947e44", + "size": 257899, + "subdir": "linux-64", + "timestamp": 1520876415656, + "version": "2.7.0" + }, + "python-dateutil-2.7.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.5" + ], + "license": "BSD 3-clause", + "md5": "8f57ead650af410cfd1c4a0d1e86d86e", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "bc7b79f649f236bd7cdf288ca62085c6a7a19743eaa81181ce0ae974ffb478a0", + "size": 259950, + "subdir": "linux-64", + "timestamp": 1520876436142, + "version": "2.7.0" + }, + "python-dateutil-2.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.5" + ], + "license": "BSD 3-clause", + "md5": "3734c255f9de7f01e190fee55d8e1c33", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "2fb89b4015723b4b049976f9e1da2bac49b7457337fcf03947c465c4c4a57827", + "size": 259756, + "subdir": "linux-64", + "timestamp": 1520876390377, + "version": "2.7.0" + }, + "python-dateutil-2.7.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "fdf6c18bb90e5581e9f9381a7788267e", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "bb094c410b7c8b0f11b4ccc3b34d2373f9a1b9f3ed3ffce796f199764090996c", + "size": 260084, + "subdir": "linux-64", + "timestamp": 1522167512810, + "version": "2.7.2" + }, + "python-dateutil-2.7.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "6d3df18116d0e99c708f08f9c2d0bf8c", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "d75312ef172d708f465a7091e024407dd3fcfd1b02d8853f83f13963092d9a44", + "size": 262410, + "subdir": "linux-64", + "timestamp": 1522167551095, + "version": "2.7.2" + }, + "python-dateutil-2.7.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "2f3f77221d647d3d119c9c68473f1c63", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "0819317c48e4d1ac3163fb32011589cec8d692747eef10bbc4ae8dc11775f0a4", + "size": 262316, + "subdir": "linux-64", + "timestamp": 1522167510208, + "version": "2.7.2" + }, + "python-dateutil-2.7.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "926d3a794de214a57c2daff24765e38d", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "d9daea91a7db92dcaddd566b15090fabc4e4272a085d9aefc200d95e0a67d435", + "size": 264151, + "subdir": "linux-64", + "timestamp": 1526402969967, + "version": "2.7.3" + }, + "python-dateutil-2.7.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "ecafb0da2d967d9cc44ecaed0eae4c38", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "579eb80e70d5e6b24f6ec793f47df0b123b4a5487baf54ce032e9b6bdf7508e4", + "size": 266788, + "subdir": "linux-64", + "timestamp": 1526402994044, + "version": "2.7.3" + }, + "python-dateutil-2.7.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "954f1ca5a4198bdc7f88d312dcdddfa2", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "31e814b380fada66548b16f9582b49c20e51321da8f03f80dd766c6d4094b80e", + "size": 266533, + "subdir": "linux-64", + "timestamp": 1526402950261, + "version": "2.7.3" + }, + "python-dateutil-2.7.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "80a0a01246f0cd7b7668b6d4969b0358", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "af8c3011144a6bddb137e5c7b81b0601f1520739ceda12155208d32f1c49fda9", + "size": 265959, + "subdir": "linux-64", + "timestamp": 1530694486059, + "version": "2.7.3" + }, + "python-dateutil-2.7.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "3b47361230c95d35a91531d35ffd189d", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "1a78c83c60e9bb0c0007592af893969e98f0641b9a0caad7870ae8222b9a5cfd", + "size": 280363, + "subdir": "linux-64", + "timestamp": 1541039148658, + "version": "2.7.5" + }, + "python-dateutil-2.7.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "2065c7f03927a74d2155c559872b7fca", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "6f3899cdbde2a6e94b8ad6be96a1bfcb109d2bc99cdcb9b06d4a23000f9fbe74", + "size": 282067, + "subdir": "linux-64", + "timestamp": 1541039132957, + "version": "2.7.5" + }, + "python-dateutil-2.7.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "70a6c07065aeedde042cb56df0bd3e76", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "1158f1302979f4ae810f4b65eee254b0cf40b2c86401ed482272b47af56953d0", + "size": 281635, + "subdir": "linux-64", + "timestamp": 1541039126810, + "version": "2.7.5" + }, + "python-dateutil-2.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "66a812340442dff7f27775a8a751a090", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "bc5f97e3fdb50ce8b565d25f83c17f411927f79c3b4cac1c87b61d81730727ac", + "size": 285488, + "subdir": "linux-64", + "timestamp": 1551147427054, + "version": "2.8.0" + }, + "python-dateutil-2.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "b844c6c1fa4e4d1d5486e8f4e4a9b4f5", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "8f67f02aa02575d8e08c345e25f5e4cb83517fd1c714043b1fbc329c76572bf9", + "size": 288111, + "subdir": "linux-64", + "timestamp": 1551147445881, + "version": "2.8.0" + }, + "python-dateutil-2.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "913690cd29a48ceec7ece568eb895eea", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "bfd4b87405cc03c3f603270a3bd251c562512c341e2da03ca707df84d330f758", + "size": 287699, + "subdir": "linux-64", + "timestamp": 1551196304636, + "version": "2.8.0" + }, + "python-dotenv-0.21.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click >=5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "91e225708bc3166a28f96e4b7b3e2f3a", + "name": "python-dotenv", + "sha256": "c65af37024d49e226d76043c0f3e3862d339da4a52241ef09d15a0b74a6b1176", + "size": 32212, + "subdir": "linux-64", + "timestamp": 1669132662720, + "version": "0.21.0" + }, + "python-dotenv-0.21.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "click >=5.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ce40bc9abd99463ac36bf85435b2d69f", + "name": "python-dotenv", + "sha256": "4d66afb8922ee52bf9eaee7a5a5b316c7615aefb9bb468a39381cddc03b28cfa", + "size": 40158, + "subdir": "linux-64", + "timestamp": 1676842333818, + "version": "0.21.0" + }, + "python-dotenv-0.21.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click >=5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8289953c627b3946ddbbe0b863a2459f", + "name": "python-dotenv", + "sha256": "e127aa99fdff2ffc602e9d76a9feb0d296776229b4c515e6abd5e228c0e33ef2", + "size": 31665, + "subdir": "linux-64", + "timestamp": 1669132637138, + "version": "0.21.0" + }, + "python-dotenv-0.21.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3157ff976e4da3da966be9962e2be111", + "name": "python-dotenv", + "sha256": "916e4d276966a41f0627a37220b5df0e339a6aa12e3a7889062f36e31fb70ccf", + "size": 31832, + "subdir": "linux-64", + "timestamp": 1669132586501, + "version": "0.21.0" + }, + "python-dotenv-0.21.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "81b373b38855913ec9948f1ec503085e", + "name": "python-dotenv", + "sha256": "87283f6be98098ac36db20f56b791dc6cdb36b2c026a3adfad58bc4b2a0b47b8", + "size": 31833, + "subdir": "linux-64", + "timestamp": 1669132611768, + "version": "0.21.0" + }, + "python-editor-1.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a5b422ea682181167ae8c7d73d486911", + "name": "python-editor", + "namespace_in_name": true, + "sha256": "2e0d8f9a4afc420e9db01b020c986709672fdd53afe0a202e659f9f3a199ae95", + "size": 10538, + "subdir": "linux-64", + "timestamp": 1530737096632, + "version": "1.0.3" + }, + "python-editor-1.0.3-py27hef54e72_0.tar.bz2": { + "build": "py27hef54e72_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9ce18562d901ddd3f7c4007485c2c4d8", + "name": "python-editor", + "namespace_in_name": true, + "sha256": "cd3945815e40b73e475ee12de67e48b02dcbcd5a8a9186e6bdf814b7e55974ea", + "size": 10374, + "subdir": "linux-64", + "timestamp": 1505691430872, + "version": "1.0.3" + }, + "python-editor-1.0.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5d77cec7f652363ccb94d2905ab21fd9", + "name": "python-editor", + "namespace_in_name": true, + "sha256": "ba503bcb9006b3c45d67eed4b916af136d175fe86b2835bbfec761036794e5e9", + "size": 10526, + "subdir": "linux-64", + "timestamp": 1534352640879, + "version": "1.0.3" + }, + "python-editor-1.0.3-py35he568942_0.tar.bz2": { + "build": "py35he568942_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "219ddb64172e6c0b132de37576925a74", + "name": "python-editor", + "namespace_in_name": true, + "sha256": "448c3a78e4804dea72803df3d41441ab5ed43eaf675fbbaf3bea6de50fce3168", + "size": 10436, + "subdir": "linux-64", + "timestamp": 1505691441939, + "version": "1.0.3" + }, + "python-editor-1.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c75d962fe5b8a0343ddb9c27c97c858c", + "name": "python-editor", + "namespace_in_name": true, + "sha256": "00ec6bed68959954c9a3a6e607087a239cac33a4bc994f66be343d217651beed", + "size": 10566, + "subdir": "linux-64", + "timestamp": 1530737076246, + "version": "1.0.3" + }, + "python-editor-1.0.3-py36h928c527_0.tar.bz2": { + "build": "py36h928c527_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dfaaf1f4e567edb416aa741650a12666", + "name": "python-editor", + "namespace_in_name": true, + "sha256": "8c018bac151a1c45bd9f58acd55bb7e4de0f11a3471f8136a55861ab9176ebe5", + "size": 10448, + "subdir": "linux-64", + "timestamp": 1505691453079, + "version": "1.0.3" + }, + "python-editor-1.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2badc8b9d7b1d6b236034da1f0847d9e", + "name": "python-editor", + "namespace_in_name": true, + "sha256": "8d43a6216ea02c9f32d5c63c6fcc1652e2797bbea92184472dc5196f69b5b09d", + "size": 10576, + "subdir": "linux-64", + "timestamp": 1530737117551, + "version": "1.0.3" + }, + "python-engineio-2.0.1-py27h6f79896_0.tar.bz2": { + "build": "py27h6f79896_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8addf85a3fa5a9ef44476ac49b9d019", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "48bba2aeb407418e514665a8c544dcebce00c12a12e6dcb42712c3bbb0027c37", + "size": 32998, + "subdir": "linux-64", + "timestamp": 1511706674225, + "version": "2.0.1" + }, + "python-engineio-2.0.1-py35hcb26707_0.tar.bz2": { + "build": "py35hcb26707_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a29e08afab2b5a3e676d77ef8d0d5c68", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "6526096317a3f9ed1c8c275fd8ff8658ea098a7437adf2ff1b707fcc607dced1", + "size": 39151, + "subdir": "linux-64", + "timestamp": 1511706669158, + "version": "2.0.1" + }, + "python-engineio-2.0.1-py36he21bd9a_0.tar.bz2": { + "build": "py36he21bd9a_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f440a8253291fbd47c7ec5dbedbf7207", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "dad088e6470000b8036df0aa13e278ee05c66c057860b34ee57ab922ffb95c21", + "size": 38956, + "subdir": "linux-64", + "timestamp": 1511706673736, + "version": "2.0.1" + }, + "python-engineio-2.0.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74e9d35527eb3807a4b7a939c376e3d0", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "878f8758c6c7e21d882931c1e95f77e074b7d9a89e11b384525f82295d445a0e", + "size": 33005, + "subdir": "linux-64", + "timestamp": 1522084408746, + "version": "2.0.4" + }, + "python-engineio-2.0.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "712d1b9ec3b748c9f485c1e1e54c3a42", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "b0744d8391cbca1db6df49f10d84bbfd19281a922ed524e3aa21b20750526f78", + "size": 39238, + "subdir": "linux-64", + "timestamp": 1522084421085, + "version": "2.0.4" + }, + "python-engineio-2.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "196459251073b38bf3344d502cbbfd6c", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "890ff060fb9bd6be925985e526b855244f0d8251a79798aa2c65da3533887d75", + "size": 39013, + "subdir": "linux-64", + "timestamp": 1522084325679, + "version": "2.0.4" + }, + "python-engineio-2.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5cfd962d3bad095f264317e50f139d95", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "8b96dbeebde87fd0719d1bb037ef2de9b582ffac97435edbd11d94ae05d89782", + "size": 34107, + "subdir": "linux-64", + "timestamp": 1526938732611, + "version": "2.1.1" + }, + "python-engineio-2.1.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ef89e1825e7e385b091fb6a4b89a7fa", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "b7d32f6dfdcbe54324f82af668c2a0a1d34e736cd0f962685c7e9487f85ccb4d", + "size": 40329, + "subdir": "linux-64", + "timestamp": 1526938735210, + "version": "2.1.1" + }, + "python-engineio-2.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9582cab586543fe806aa868187f22c45", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "bb82faf9351a8eaa36dbf2592cab26ce9443b8b395a97c6fad944677fda662c9", + "size": 40146, + "subdir": "linux-64", + "timestamp": 1526938712249, + "version": "2.1.1" + }, + "python-engineio-2.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f4c19d49454c81493580b28bdf5ef329", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "3d86978d833503daa951d9021ab9c52002bf24a1b04a852058fded01edc0864e", + "size": 40321, + "subdir": "linux-64", + "timestamp": 1530877512351, + "version": "2.1.1" + }, + "python-engineio-2.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b72e46f29b37f50b11cc9477a65006f5", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "feb70b13e6011c6467cf488f453dea921c9a81ec679678a82b73b692107e1605", + "size": 33923, + "subdir": "linux-64", + "timestamp": 1535510750704, + "version": "2.2.0" + }, + "python-engineio-2.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e4c710f0aaa49071e0ce131802ae731", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "bdcde509063baa88a6bd58cb0c8867dbaef3a92abfde1a61bd359e4182f8c654", + "size": 41328, + "subdir": "linux-64", + "timestamp": 1535510784757, + "version": "2.2.0" + }, + "python-engineio-2.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a4e2157a02bd9e7a49924f6751bc5c10", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "3adc4d27a9cf8ae65341e19701f04b70f9dd7655c519a45c15e909c0f6e91017", + "size": 41102, + "subdir": "linux-64", + "timestamp": 1535510706797, + "version": "2.2.0" + }, + "python-engineio-2.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f5dc10086165044eae9545e91b7fa16", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "9571f59e7ab32a905ba5bc32c4285ed697dbbe9fc25b354804730f71cd4a5c21", + "size": 41203, + "subdir": "linux-64", + "timestamp": 1535510785608, + "version": "2.2.0" + }, + "python-engineio-2.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c28c267e03f171a8ae1453f55f0d9785", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "c838e42cf17c48148db25ee24541e6c499b1330bc5cac1870772570c30644697", + "size": 36454, + "subdir": "linux-64", + "timestamp": 1539657032384, + "version": "2.3.2" + }, + "python-engineio-2.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "94e88e53201f26ff4dd87a8641c01481", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "504fc4377e00740f6c6e59b6e9c8c378663e666d19e82924593f673f1d80148a", + "size": 43843, + "subdir": "linux-64", + "timestamp": 1539657048364, + "version": "2.3.2" + }, + "python-engineio-2.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b576a630d43ae88a2a4f8264fd8b4ff2", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "39959647aeaa27851a504f733de4ffc901c98631a587f494802bd735e5dc45a4", + "size": 43880, + "subdir": "linux-64", + "timestamp": 1539657048544, + "version": "2.3.2" + }, + "python-engineio-3.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7fa5d1656bb5244a68a0997e3f655dbb", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "6ec793437c5da4f244fbf01e81593f173564ef011e765467e81abbee337a00d1", + "size": 41055, + "subdir": "linux-64", + "timestamp": 1543611071615, + "version": "3.0.0" + }, + "python-engineio-3.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b518af463382f6a13cc1a868d8d060e1", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "03446bca9d0636d94297f9daa31f2f7c661c3f02403abf114033e524a2075625", + "size": 50234, + "subdir": "linux-64", + "timestamp": 1543611081526, + "version": "3.0.0" + }, + "python-engineio-3.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "151239aea6b40ffd9658774ef2b4da70", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "3fdd84e9e58ff7718202f138b7d0c8994ad785d7ff4b4782d063742d0b153949", + "size": 50276, + "subdir": "linux-64", + "timestamp": 1543611053624, + "version": "3.0.0" + }, + "python-engineio-3.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2487c7e4a6f723813691a624f1354a39", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "ff1df9315c2bf22f7d4a141a7f9d56aa6721412f3b90a75948d0f9ed183b59d2", + "size": 96670, + "subdir": "linux-64", + "timestamp": 1545166635419, + "version": "3.1.0" + }, + "python-engineio-3.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd170a375a058bbf9629b989ac99a31f", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "5735f1d1bd4d4475fee3dc8681f8d8ea065d943c43ee7014a8708c15f114825e", + "size": 110248, + "subdir": "linux-64", + "timestamp": 1545166652068, + "version": "3.1.0" + }, + "python-engineio-3.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "120ffdd1ee482687550f2c4a80ad5312", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "adfe81491bd61152c4df8b7765c9ecc019c124558f089d599d8ba4f65779fcce", + "size": 110161, + "subdir": "linux-64", + "timestamp": 1545166635953, + "version": "3.1.0" + }, + "python-engineio-3.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "509c062bb8862e62223b71ef31dfb7ce", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "7880a2067c157ab6fbb0329ea3a5b7926b0812099a4b532096d61b19bb379efe", + "size": 87228, + "subdir": "linux-64", + "timestamp": 1550355545612, + "version": "3.3.2" + }, + "python-engineio-3.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1fb2db1300f816d2cff3424446a5e06", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "9f6bd824cbdfcda95f5bebe95015ef2f2e8f1a873b590930be4387da89162a13", + "size": 116775, + "subdir": "linux-64", + "timestamp": 1550355522732, + "version": "3.3.2" + }, + "python-engineio-3.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "664c0727ddbd28e7fa9861a2025ce070", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "d37de6f2e52b29de383b07c1652fe2ee34acea520a245f19b04afdef69f70cb6", + "size": 116689, + "subdir": "linux-64", + "timestamp": 1550355489933, + "version": "3.3.2" + }, + "python-fastjsonschema-2.16.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7f9649b98bcdc1b5b0c4b22c5db5b9de", + "name": "python-fastjsonschema", + "sha256": "079d9c3369fc6dcd6fdb2b828167d29634783038fd9cc22b454115186ddbd928", + "size": 265085, + "subdir": "linux-64", + "timestamp": 1661371188626, + "version": "2.16.2" + }, + "python-fastjsonschema-2.16.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "59ec670fcd172447dbd9591b8fbfdd56", + "name": "python-fastjsonschema", + "sha256": "aadc4078311c059265706a56265f0a57ceb538d36179d5203dd487d80d0e8f16", + "size": 278741, + "subdir": "linux-64", + "timestamp": 1679340144625, + "version": "2.16.2" + }, + "python-fastjsonschema-2.16.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7204ceec722f5539f0d37de61d0c43d2", + "name": "python-fastjsonschema", + "sha256": "48b08e9c859f9d174e47f260e9618b3fe3033b145c859956ccd2bf08aada91a9", + "size": 264008, + "subdir": "linux-64", + "timestamp": 1661371244169, + "version": "2.16.2" + }, + "python-fastjsonschema-2.16.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d914447598a4c8d1e61fd888dded2072", + "name": "python-fastjsonschema", + "sha256": "cc0f3ceeae6369f8b1523c1f4fff5c16d14c455b938723671a6bc672a65b77ff", + "size": 264015, + "subdir": "linux-64", + "timestamp": 1661371299911, + "version": "2.16.2" + }, + "python-fastjsonschema-2.16.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0caa188a695319bdb13f53b0a2b3accc", + "name": "python-fastjsonschema", + "sha256": "a7ab4852e35549608b391e96c2e0e35f2cb2035733d9a801f4a039549b770bcb", + "size": 264864, + "subdir": "linux-64", + "timestamp": 1661371117920, + "version": "2.16.2" + }, + "python-gflags-3.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b39a2986e3493108e1f1e1e1efcfa51d", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "ff554df2b837af532eb769fc20905bdb14ecc9d4ea91268190b80ab7cbd3c2de", + "size": 70027, + "subdir": "linux-64", + "timestamp": 1512750499699, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7c612a417f58a763e27008f0e60604ef", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "593b5d3c475ef8d313b3ed9e81dee26918cc5e545d98a0e06e1ea9513698d0a1", + "size": 72546, + "subdir": "linux-64", + "timestamp": 1640793811090, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "efe0ae83501e9ba6832224f5fe4efe19", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "09f2c38c3e7622a62cebd02e45867ff2fddaaa84631f55420dc0df2f7ff273dc", + "size": 91555, + "subdir": "linux-64", + "timestamp": 1676861466484, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fc3fbc3389ea3fd549142ce83ab6fbe2", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "7567d073e2f5f196704715b9b68d90816a812d1d548a41425d9306048f5512ab", + "size": 72016, + "subdir": "linux-64", + "timestamp": 1512750502785, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d3bc59df308a441c5ada8ee39f377296", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "0cf09b930c3f699e64a093908ea6b349ad9ad25932af451b874dd71be6478321", + "size": 71889, + "subdir": "linux-64", + "timestamp": 1512750504243, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b375474486281bcaacd931fca56c9665", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "b1c98c168baa36ea784fc433bc7fb36dcba4764e4c915b997eef5b5b028f7987", + "size": 73048, + "subdir": "linux-64", + "timestamp": 1613492904961, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d78bc8caf48d4a025e48d1ab5e962436", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "6a9269e50d843de1fbb4fd7ac9ac630bfa0cfbe3f042a8d8d8c3bf20cd6cbf82", + "size": 71764, + "subdir": "linux-64", + "timestamp": 1530792963779, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8d78705b81b7271b8090fb82e6948b26", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "05e36184f0856c2602bb62750a7454da208c28c5bc9177be3a5413bbea136d24", + "size": 73134, + "subdir": "linux-64", + "timestamp": 1613493335961, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "09743835e6484d3331186e22414fb25b", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "be9398f599803bb2fb36dbb7c6c5002cc9c19658eb048c62f9729cbe0b02b9a3", + "size": 72578, + "subdir": "linux-64", + "timestamp": 1574094360736, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e004b61ecf281c298c722a28518499a4", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "145de8727657868236c904b3ea38a47c0434d827c3ee0bdb3c452741114481b3", + "size": 73362, + "subdir": "linux-64", + "timestamp": 1613493350999, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dacd9b101fa42f82533ba257785e169c", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "dade1941f7dfa146bb5e30c385f4ef0e358286676038dd835864f213ab0e8628", + "size": 73446, + "subdir": "linux-64", + "timestamp": 1613493341839, + "version": "3.1.2" + }, + "python-graphviz-0.20.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3082859ed345ea2415e628ee34b24902", + "name": "python-graphviz", + "sha256": "f5648f6a07ff5ec34bf11f9961e1ab6854a53b92c0d73ec1d877f54b6346254d", + "size": 63166, + "subdir": "linux-64", + "timestamp": 1660063340906, + "version": "0.20.1" + }, + "python-graphviz-0.20.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6cafd1f41e357447e75386d59919d389", + "name": "python-graphviz", + "sha256": "fa1fe22a6fc983cac0fe61466840ec9fccf8d4b83fd09b85ce226ddf8730460d", + "size": 79625, + "subdir": "linux-64", + "timestamp": 1676838677129, + "version": "0.20.1" + }, + "python-graphviz-0.20.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd53f5a5284990462588f744417d8d17", + "name": "python-graphviz", + "sha256": "1afe2e92584629c51c021a4ce886dd4cc0caa50ba49f069093726f2c3e880d2d", + "size": 62072, + "subdir": "linux-64", + "timestamp": 1660063389156, + "version": "0.20.1" + }, + "python-graphviz-0.20.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "67e1516f580b64ae047cdc631ea7ea8f", + "name": "python-graphviz", + "sha256": "0b8e5c7520249f5ff39325f7b8e201f627977b25dc044e41780fcd0f0bfd6a7c", + "size": 62538, + "subdir": "linux-64", + "timestamp": 1660063283264, + "version": "0.20.1" + }, + "python-graphviz-0.20.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "772650209afb1f14b0541b1f46277f01", + "name": "python-graphviz", + "sha256": "13f97be2e1e517c304d1a4609abc5198e60137e506ab5b0913dffe0a391b3075", + "size": 62391, + "subdir": "linux-64", + "timestamp": 1660063229820, + "version": "0.20.1" + }, + "python-graphviz-0.8.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "graphviz", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87f54a3b0acccfb1c3db698b34f45e6b", + "name": "python-graphviz", + "sha256": "f3c2b60389ca57890c9ace5b3a4e858bba1d4e849342a57a774526667e40f403", + "size": 26651, + "subdir": "linux-64", + "timestamp": 1516927208755, + "version": "0.8.2" + }, + "python-graphviz-0.8.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "graphviz", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9add0e4f74b1880e2d77e31f20c25b62", + "name": "python-graphviz", + "sha256": "4a723434a9c16b7fa3bce3ae750c5fc480ddfe871ae756a7b1d081f8827a49ee", + "size": 27179, + "subdir": "linux-64", + "timestamp": 1516927227890, + "version": "0.8.2" + }, + "python-graphviz-0.8.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "graphviz", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "821cb297069ea843832326fa9b634806", + "name": "python-graphviz", + "sha256": "267d207e887d54229d894927c4db744c6a9ae56254692e36bcb1b61b2c3d02c4", + "size": 27150, + "subdir": "linux-64", + "timestamp": 1516927236295, + "version": "0.8.2" + }, + "python-graphviz-0.8.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "graphviz", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3888c6b24aefa86953c443a7e9546511", + "name": "python-graphviz", + "sha256": "89410ecec6c8d93319a914e48499de6d0b70b233b653dac60bed6dc271531f92", + "size": 26544, + "subdir": "linux-64", + "timestamp": 1527694927688, + "version": "0.8.3" + }, + "python-graphviz-0.8.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "graphviz", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "508146cf460c4f2795cacf3e09b6fc1e", + "name": "python-graphviz", + "sha256": "c02364d83f53ba609ff78cdbf7cba7acca92e9b47917d5f0c90f96ab987b40fa", + "size": 27003, + "subdir": "linux-64", + "timestamp": 1527694929825, + "version": "0.8.3" + }, + "python-graphviz-0.8.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "graphviz", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0c7d770e6c148ebc8532ad870361095", + "name": "python-graphviz", + "sha256": "57de3720f53496ad42612dc5536c0a4da8cfa0615f65200805aa1d4e895c0099", + "size": 26985, + "subdir": "linux-64", + "timestamp": 1527694909729, + "version": "0.8.3" + }, + "python-graphviz-0.8.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "graphviz", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4eee50873ea5e2f5606dd74e4f3b71fa", + "name": "python-graphviz", + "sha256": "7b3cacd8e80d750ceb4cdad3b10fb4570bbde1e74aeb389c7120a86d6899be09", + "size": 27145, + "subdir": "linux-64", + "timestamp": 1531092324130, + "version": "0.8.3" + }, + "python-graphviz-0.8.4-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "graphviz", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "76173d03f9404953b817af5249234582", + "name": "python-graphviz", + "sha256": "f259f9152c00758efddc1123a3583f46d058b577bdff8cd97d27e65427038410", + "size": 27585, + "subdir": "linux-64", + "timestamp": 1533000958051, + "version": "0.8.4" + }, + "python-graphviz-0.8.4-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "graphviz", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21a85378ccaa19e03e01bca79b9645ac", + "name": "python-graphviz", + "sha256": "4371ee5a5087f5b50fe58e008a2d97625397d216f2488abd2e2fe72fb6b5a672", + "size": 28005, + "subdir": "linux-64", + "timestamp": 1533000966948, + "version": "0.8.4" + }, + "python-graphviz-0.8.4-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "graphviz", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f045b276d47015f6b2fba7e22267a020", + "name": "python-graphviz", + "sha256": "1a0ec5392bcb0bb5a74649e4874d697006eb878688abeaf27358019e22f85baf", + "size": 28057, + "subdir": "linux-64", + "timestamp": 1533000925057, + "version": "0.8.4" + }, + "python-graphviz-0.8.4-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "graphviz", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "55411e478f9c25083d9f0fcea888e67a", + "name": "python-graphviz", + "sha256": "639e4f0f55eb7275abe20e13d8eaa61f2ce2d60adaeafd75ca8e5b3d88df5937", + "size": 28022, + "subdir": "linux-64", + "timestamp": 1533000972352, + "version": "0.8.4" + }, + "python-graphviz-0.8.4-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "graphviz", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df2ff367f972773a8d23f23ae33f6857", + "name": "python-graphviz", + "sha256": "5a42f350950da3bed2d8eabaec70949fbd264bf4d0ba432009a43a1dd7edfd80", + "size": 28732, + "subdir": "linux-64", + "timestamp": 1572855320178, + "version": "0.8.4" + }, + "python-hdfs-2.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=2.7,<2.8.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "e3459a4e9673a67c1cb85f2c75380447", + "name": "python-hdfs", + "sha256": "282123a999ff4fba318ee862e173c9237b01a36c9055cdde4f3953fcb5583a82", + "size": 47914, + "subdir": "linux-64", + "timestamp": 1516906175241, + "version": "2.1.0" + }, + "python-hdfs-2.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=3.5,<3.6.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "887a1ff01e8d03ed80b979a1d132bd72", + "name": "python-hdfs", + "sha256": "9b02a0d7c4138126c3b4e319471a48f5496f2b8879ec060a058c57556fd6a514", + "size": 49087, + "subdir": "linux-64", + "timestamp": 1516906174925, + "version": "2.1.0" + }, + "python-hdfs-2.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=3.6,<3.7.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "30ad89f32d58d201924a1174c81e0f07", + "name": "python-hdfs", + "sha256": "036e4c624f6aa937a6f4b5d5b156a2dae6baa6c79aa24310e736b2029b87113f", + "size": 48979, + "subdir": "linux-64", + "timestamp": 1516906201046, + "version": "2.1.0" + }, + "python-hdfs-2.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=3.7,<3.8.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "956f5b3ee01951293c1743ab3a4e807b", + "name": "python-hdfs", + "sha256": "9d814570dc610e2b390a3548e9be9b41d7c9bfad835f21c8fba05211379cc74f", + "size": 48915, + "subdir": "linux-64", + "timestamp": 1530922727335, + "version": "2.1.0" + }, + "python-hdfs-2.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=2.7,<2.8.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "6da421eb5af90715a1658171375fbb45", + "name": "python-hdfs", + "sha256": "7c854b5e67c72491598bf6b932db98a18b79b288ffc13d85b928d7bf5cba563d", + "size": 50227, + "subdir": "linux-64", + "timestamp": 1543611696765, + "version": "2.2.1" + }, + "python-hdfs-2.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=3.6,<3.7.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "1020893c9fed398d8356dc5c78285eb2", + "name": "python-hdfs", + "sha256": "eec1978172d79b76846185925e3f57eb64178503dee8679a79e564d878520789", + "size": 51181, + "subdir": "linux-64", + "timestamp": 1543611722348, + "version": "2.2.1" + }, + "python-hdfs-2.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=3.7,<3.8.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "294cec16264a4681a376ee0dc4964c78", + "name": "python-hdfs", + "sha256": "8be40834338f7065f96b9d32ddd41e037b865532ebd7bbd83dbc1a70375a3bb2", + "size": 51258, + "subdir": "linux-64", + "timestamp": 1543611676791, + "version": "2.2.1" + }, + "python-hdfs-2.2.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=2.7,<2.8.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "481f1456a2fcc3d462856c9658c79317", + "name": "python-hdfs", + "sha256": "8c29e2d5e5b8ae36ba85c05bca8d434349c32c16d168a1ead8251005dd5c6b32", + "size": 48418, + "subdir": "linux-64", + "timestamp": 1545130797180, + "version": "2.2.2" + }, + "python-hdfs-2.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=3.6,<3.7.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "e1aefdfbce1c83e3b70b3d2f4a8e96a9", + "name": "python-hdfs", + "sha256": "b6fede36e80d50e0c123fd72c37f5229eebfc87cc65b21d11c1c1e97f9002d00", + "size": 49389, + "subdir": "linux-64", + "timestamp": 1545130736454, + "version": "2.2.2" + }, + "python-hdfs-2.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=3.7,<3.8.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "32efb96e38bbc04cb5d9f765b8b31056", + "name": "python-hdfs", + "sha256": "2581da678bc2364cc2a283cdd33fc875b838df6705b12dfbe21fad9f1cf52d18", + "size": 49514, + "subdir": "linux-64", + "timestamp": 1545130825618, + "version": "2.2.2" + }, + "python-hdfs-2.7.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.21.19", + "pandas >=0.14.1", + "python >=3.10,<3.11.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ff23608114ee19c5dd4e8146e34a28d", + "name": "python-hdfs", + "sha256": "79945900622c8ca80c9a77aa459e5bb80d0ae6cd3e90d9a88078a2ead3e4adac", + "size": 55074, + "subdir": "linux-64", + "timestamp": 1670952411626, + "version": "2.7.0" + }, + "python-hdfs-2.7.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.21.19", + "pandas >=0.14.1", + "python >=3.11,<3.12.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc1e6e7d989dd7cbeb38d8fad51b6009", + "name": "python-hdfs", + "sha256": "9c9fa645e05b1bc26198a02dbf582266493251a0a89a7bdf4bd3947ff61be3a1", + "size": 70203, + "subdir": "linux-64", + "timestamp": 1679340273350, + "version": "2.7.0" + }, + "python-hdfs-2.7.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.21.19", + "pandas >=0.14.1", + "python >=3.7,<3.8.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ae77e8b39e1023c5bc46dcc3e1ac9fa", + "name": "python-hdfs", + "sha256": "81f0105cdea5e5427af7163ef461bcaa39453a3d92c69e3da57adccdcd2b47d8", + "size": 54330, + "subdir": "linux-64", + "timestamp": 1670952372953, + "version": "2.7.0" + }, + "python-hdfs-2.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.21.19", + "pandas >=0.14.1", + "python >=3.8,<3.9.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d0b8e97a83a8587c09c3ce2a8126387", + "name": "python-hdfs", + "sha256": "db95edf8180c03c50500ff57c11cbfa425be1be61e62bfc5e329c3d9ccaecc68", + "size": 54579, + "subdir": "linux-64", + "timestamp": 1670952485308, + "version": "2.7.0" + }, + "python-hdfs-2.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.21.19", + "pandas >=0.14.1", + "python >=3.9,<3.10.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f10c1b37c76d49be73999a11790888f", + "name": "python-hdfs", + "sha256": "e0c7fdb8f83a83fa3fb337c5dbb92b7e5d2a0dd70047badbd140d1699b4aaa01", + "size": 54686, + "subdir": "linux-64", + "timestamp": 1670952447677, + "version": "2.7.0" + }, + "python-installer-0.5.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd9894e1b726522c19004df956a10910", + "name": "python-installer", + "sha256": "d3208a70b93c970c8ab964dc96ede495ca753b3d79ec9a82db1a90fcd74fe186", + "size": 321660, + "subdir": "linux-64", + "timestamp": 1669064503492, + "version": "0.5.1" + }, + "python-installer-0.5.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a24c563840c20c38905e59dd96a8b2fd", + "name": "python-installer", + "sha256": "0f532d7ecb0621abfc79697636a4da8c6242ba0922c5ecceba54114b444094ed", + "size": 331923, + "subdir": "linux-64", + "timestamp": 1676842348095, + "version": "0.5.1" + }, + "python-installer-0.5.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1040211012a2329bbba57a97537fb3d4", + "name": "python-installer", + "sha256": "e43411aa351a2d2313ffbe91cee928f65afb84069217e3430ee0e3c756dbd22b", + "size": 321079, + "subdir": "linux-64", + "timestamp": 1669064447944, + "version": "0.5.1" + }, + "python-installer-0.5.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e646189d57d3b935a601652ec98731cb", + "name": "python-installer", + "sha256": "60f698dfd498b46bfc601742fa3fc1ca1cfc25a52d469ef7794b500871042d1f", + "size": 321260, + "subdir": "linux-64", + "timestamp": 1669064530945, + "version": "0.5.1" + }, + "python-installer-0.5.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c6ee1d42956396e34e7221c123709ee", + "name": "python-installer", + "sha256": "92d87472bc0684bbbfa8c9a10f0160d6bc985ea709112bd01cacf0ce4ccee344", + "size": 321690, + "subdir": "linux-64", + "timestamp": 1669064475701, + "version": "0.5.1" + }, + "python-installer-0.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e32a1724356e5874f42e728afde882a", + "name": "python-installer", + "sha256": "b3c9b141be30cbbe2cc99a8813ce34d462a92fa2fe96d1ee880fc3fc9c6562a5", + "size": 337607, + "subdir": "linux-64", + "timestamp": 1679433053237, + "version": "0.6.0" + }, + "python-installer-0.6.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "906cbf9a96e844d371d6635f4435cf80", + "name": "python-installer", + "sha256": "67fd5e842b952b2a86db54eef2a4e7ebff10eceb69ae1ae64fc754a34a712ef3", + "size": 348911, + "subdir": "linux-64", + "timestamp": 1679433028089, + "version": "0.6.0" + }, + "python-installer-0.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c6fd88c3c332a208afcc24eb9d44be5", + "name": "python-installer", + "sha256": "b0c75bf78d9d946bb31219fe3e71093caf21caf2592d2a34a8053bd84c592c49", + "size": 337332, + "subdir": "linux-64", + "timestamp": 1679433078265, + "version": "0.6.0" + }, + "python-installer-0.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "88ce7c65272f8b1fb7eb6ac38bc92f11", + "name": "python-installer", + "sha256": "8016917bc15cb78a3e9ca6c7020925cc7255f090216fef151163151a92394bca", + "size": 337278, + "subdir": "linux-64", + "timestamp": 1679433101949, + "version": "0.6.0" + }, + "python-jose-2.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ecdsa <1.0", + "future <1.0", + "pycryptodome >=3.3.1", + "python >=2.7,<2.8.0a0", + "six <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f301201ff41ed4f5b69b79cca679e109", + "name": "python-jose", + "sha256": "919678edf6ca089efd749b1e0505cca4a70302277bb4820c4f21c02935b74b06", + "size": 32298, + "subdir": "linux-64", + "timestamp": 1543384660144, + "version": "2.0.2" + }, + "python-jose-2.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ecdsa <1.0", + "future <1.0", + "pycryptodome >=3.3.1", + "python >=3.6,<3.7.0a0", + "six <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db87fc494bda7fa9c67ecd3a98043739", + "name": "python-jose", + "sha256": "d52cdb8c8a73ccae5a27e5d20a823062ce6b44ce991157dd94140e827327afba", + "size": 32778, + "subdir": "linux-64", + "timestamp": 1543384721720, + "version": "2.0.2" + }, + "python-jose-2.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ecdsa <1.0", + "future <1.0", + "pycryptodome >=3.3.1", + "python >=3.7,<3.8.0a0", + "six <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cf8c08f019ccc946ed94ff401c877216", + "name": "python-jose", + "sha256": "410ea7ee2cd4d928025f60932db63ac91a5045cb451eb0f269c9aa9c1bfb1bc6", + "size": 32835, + "subdir": "linux-64", + "timestamp": 1543384642587, + "version": "2.0.2" + }, + "python-kubernetes-18.20.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f1e68df2261cfac4be6a2eee4f5841d8", + "name": "python-kubernetes", + "sha256": "3989cf70e40a96ed5fcc300d389066b5d32fcb997e3b34c4fae998ff2ec04626", + "size": 1052610, + "subdir": "linux-64", + "timestamp": 1667228498941, + "version": "18.20.0" + }, + "python-kubernetes-18.20.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "fb0a4fee75703ab974d26752e1205a3a", + "name": "python-kubernetes", + "sha256": "0cbcfe48141a0aed36cd8ccbb1fc8d3181a04501db0c16abf1dfe90218e43fe0", + "size": 1056208, + "subdir": "linux-64", + "timestamp": 1667228456627, + "version": "18.20.0" + }, + "python-kubernetes-18.20.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b667c22ef2698fc21ad6de64ae05222d", + "name": "python-kubernetes", + "sha256": "43b170652baf939322ccb6fca0b6bea80f60a6be9a2055f8568b55077ebfdb22", + "size": 1049345, + "subdir": "linux-64", + "timestamp": 1667228414790, + "version": "18.20.0" + }, + "python-kubernetes-18.20.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7935209a1727bc2da3625e62261198c0", + "name": "python-kubernetes", + "sha256": "b737902880f0d298cb92a979f0b5df46714b3a03dd70a66dbd6e248054a2feb5", + "size": 1051713, + "subdir": "linux-64", + "timestamp": 1667228373263, + "version": "18.20.0" + }, + "python-kubernetes-19.15.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9d3ae2c0b2be42d84dc60a4c6d3927e8", + "name": "python-kubernetes", + "sha256": "f16ea556ac8fb44d54bfc09bc69b3f26a6582280befb03774e805834421254b2", + "size": 1097217, + "subdir": "linux-64", + "timestamp": 1666105109159, + "version": "19.15.0" + }, + "python-kubernetes-19.15.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "889b1eca447d9d74f8dd3c2db1552b6f", + "name": "python-kubernetes", + "sha256": "3a1c7856337365d9411f242df169577e7a468a629076d48de44ed3aea2149010", + "size": 1093268, + "subdir": "linux-64", + "timestamp": 1666104986120, + "version": "19.15.0" + }, + "python-kubernetes-19.15.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "17e36b5dda304fe6441a976027c37609", + "name": "python-kubernetes", + "sha256": "ac0f4d89352de51ba1f482ec5de8c9f80cc892990bb4583fb3d0072c60d85760", + "size": 1100616, + "subdir": "linux-64", + "timestamp": 1666105046190, + "version": "19.15.0" + }, + "python-kubernetes-19.15.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "07ac1cfe42e9becc2a4d9cc1acbb9c99", + "name": "python-kubernetes", + "sha256": "6ed5594e8bb14bfd847c6093452ff47bc9f3ce4f6d54d9f7b2741fdf032f7961", + "size": 1094094, + "subdir": "linux-64", + "timestamp": 1666104923405, + "version": "19.15.0" + }, + "python-kubernetes-20.13.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "cbcb2bbd60e644b40c197218b32c187e", + "name": "python-kubernetes", + "sha256": "5bb28e2049341bc5356f486a06e40c5f368c50da49252df44573e26e53cb622e", + "size": 1132251, + "subdir": "linux-64", + "timestamp": 1667228396389, + "version": "20.13.0" + }, + "python-kubernetes-20.13.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8c17264bba7d8ea6384ec8561479de0f", + "name": "python-kubernetes", + "sha256": "baed4a837882a14c622a75fbcc9566ae44b06a843d3795b8716b745d0bdd292a", + "size": 1131753, + "subdir": "linux-64", + "timestamp": 1667228525965, + "version": "20.13.0" + }, + "python-kubernetes-20.13.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7f09782c37b9d8e63b655f1d5b7d434f", + "name": "python-kubernetes", + "sha256": "38e0e95bc0bf5795e357bcb20ed3c7fd6387bcd2105141656916c55160e2546b", + "size": 1135109, + "subdir": "linux-64", + "timestamp": 1667228439530, + "version": "20.13.0" + }, + "python-kubernetes-20.13.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f6a0ae94008473ef8d607e7b1d545a9c", + "name": "python-kubernetes", + "sha256": "1fe5b9ed1ce2737a202f39b6aec7e49260b31afa9531462d32ff1e592c6c0ab1", + "size": 1127770, + "subdir": "linux-64", + "timestamp": 1667228482437, + "version": "20.13.0" + }, + "python-kubernetes-21.7.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "574a85e60554744e7e1462eece331c1d", + "name": "python-kubernetes", + "sha256": "d33e54bc92dc1906b14dfa0fa9b994fb142f470043227a3659883fb5ce4c3ead", + "size": 1147496, + "subdir": "linux-64", + "timestamp": 1667228367125, + "version": "21.7.0" + }, + "python-kubernetes-21.7.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "1d58c424de34e8c4c25816f7600a0543", + "name": "python-kubernetes", + "sha256": "1f9847fbf815146a72c2054bce8917e1d5b4228eca4e827e5570241c00769bcb", + "size": 1157191, + "subdir": "linux-64", + "timestamp": 1667228497279, + "version": "21.7.0" + }, + "python-kubernetes-21.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b9e9a54641d85400797c58fbafae9165", + "name": "python-kubernetes", + "sha256": "f3f8ea33dcfe09abdc037259a9fcdb09b4440e6a13a7251547f2c23074e1988b", + "size": 1155314, + "subdir": "linux-64", + "timestamp": 1667228453196, + "version": "21.7.0" + }, + "python-kubernetes-21.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "78d3ca4ee723f0205bd535fe8dd043fb", + "name": "python-kubernetes", + "sha256": "0ac93a68cbbe08ea89c57cba6c600f919be9f4e7000d577ade8e980882e54013", + "size": 1149024, + "subdir": "linux-64", + "timestamp": 1667228410183, + "version": "21.7.0" + }, + "python-kubernetes-23.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "setuptools >=21.0.0", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b657db67f9c65ea89a794116d681a9c9", + "name": "python-kubernetes", + "sha256": "362bd1784ee0078addb2097f7d6e4f4321ad0cf99f54f47833e5dca12b11b707", + "size": 1057966, + "subdir": "linux-64", + "timestamp": 1659724899640, + "version": "23.6.0" + }, + "python-kubernetes-23.6.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "setuptools >=21.0.0", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "462406bcdb388cbcabcd73a3128c09fd", + "name": "python-kubernetes", + "sha256": "02cd6b5c7eceeaf4ebc46990f5a12ff817b5c1836d91848de9c744ba8a086e68", + "size": 1256449, + "subdir": "linux-64", + "timestamp": 1676861490524, + "version": "23.6.0" + }, + "python-kubernetes-23.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "setuptools >=21.0.0", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8f6598c335e9643bf9d45740cade3651", + "name": "python-kubernetes", + "sha256": "ff5a2051432e01e93c5274cdd44901b649b003243e54582442c248678fd38f1b", + "size": 1060749, + "subdir": "linux-64", + "timestamp": 1659724843806, + "version": "23.6.0" + }, + "python-kubernetes-23.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "setuptools >=21.0.0", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a2c9d63612a828fa5ed7328f12765416", + "name": "python-kubernetes", + "sha256": "7662a3a9ba88340e20e9dee9281aee7dc6dae3ad663931e9bc1737288f389588", + "size": 1063363, + "subdir": "linux-64", + "timestamp": 1659724800581, + "version": "23.6.0" + }, + "python-kubernetes-23.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "setuptools >=21.0.0", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "36690242270ec2fafe1d64371770093b", + "name": "python-kubernetes", + "sha256": "a8a58fec17b0661238c89ae8b1201d1af45e8ffc523074c0ef7e87b1cb48b2cf", + "size": 1057452, + "subdir": "linux-64", + "timestamp": 1659724757374, + "version": "23.6.0" + }, + "python-language-server-0.31.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16.0a0", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0,<2.2.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0c405de1fe0191ca2fee94c89b88d10", + "name": "python-language-server", + "sha256": "4db719724a1ff84885e9f5f1365cfc24bf9666aa5e1d4af2ec1c4ee7b51b4a24", + "size": 75759, + "subdir": "linux-64", + "timestamp": 1587400181204, + "version": "0.31.10" + }, + "python-language-server-0.31.10-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16.0a0", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0,<2.2.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b815eba513d5f8ef0f6d42088af62a6b", + "name": "python-language-server", + "sha256": "d43d52ee139e84ca79360fc6fe0f9694a1fd2aecc695f73265e94f2f65ca276f", + "size": 75825, + "subdir": "linux-64", + "timestamp": 1587400107196, + "version": "0.31.10" + }, + "python-language-server-0.31.10-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16.0a0", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0,<2.2.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47beb89854222c1b980072333e78734a", + "name": "python-language-server", + "sha256": "c12dbbb9afd056ca8b6d1e95a898070c03d873b792c5ce048baa656935e52b6f", + "size": 76180, + "subdir": "linux-64", + "timestamp": 1587400180440, + "version": "0.31.10" + }, + "python-language-server-0.31.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "autopep8", + "backports.functools_lru_cache", + "configparser", + "flake8", + "future >=0.14", + "jedi >=0.14.1,<0.16", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=2.7,<2.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c184734e0854563d885f6acca82e422", + "name": "python-language-server", + "sha256": "d273b9c089ccf0518b3d880962532b648b11685da45b9da17406f35209be35b2", + "size": 72158, + "subdir": "linux-64", + "timestamp": 1575415663473, + "version": "0.31.2" + }, + "python-language-server-0.31.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02eae1ff663ec807cab16e9a3f5d22b8", + "name": "python-language-server", + "sha256": "fc3d43430f3a2ddf0766e3f49cf366fe4bb7b1c174ba1007951352a275fe56df", + "size": 73300, + "subdir": "linux-64", + "timestamp": 1575415685368, + "version": "0.31.2" + }, + "python-language-server-0.31.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b13bdf298e2ea00d9af1b87494a63695", + "name": "python-language-server", + "sha256": "bf87833c68b5cd59b791f7a84d8a208c562bd8ab09829f86fb67a9107b2d5adc", + "size": 73367, + "subdir": "linux-64", + "timestamp": 1575415806439, + "version": "0.31.2" + }, + "python-language-server-0.31.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "44043a397b987d9025c0946e33e20b22", + "name": "python-language-server", + "sha256": "a2f4267d55bdd0ab5bf0e00f3a0e4cd4c759abe3ee401c47951acda61f3aa899", + "size": 73765, + "subdir": "linux-64", + "timestamp": 1575415690903, + "version": "0.31.2" + }, + "python-language-server-0.31.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c8d2d7dc53d4eb20d421d25338faa44", + "name": "python-language-server", + "sha256": "fdb06eef824c947d3e174467e0286ccf15841ce1f17f50dbe6a2bf3e47e286fb", + "size": 73958, + "subdir": "linux-64", + "timestamp": 1580400448641, + "version": "0.31.7" + }, + "python-language-server-0.31.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8896d673657eb763cdf3bd0934279b1b", + "name": "python-language-server", + "sha256": "d0bfb0dfad31c4d2f6d98f485464547e2e57089eefd6d52cf8f9be8dbf882ad3", + "size": 74014, + "subdir": "linux-64", + "timestamp": 1580400348100, + "version": "0.31.7" + }, + "python-language-server-0.31.7-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da984fdcfeaaa4714ae36c6cf32def57", + "name": "python-language-server", + "sha256": "42745b449d5ec8aa1aeb8f0d90df08a854a396d4e52c34014894d3b442f68d5f", + "size": 74408, + "subdir": "linux-64", + "timestamp": 1580400485793, + "version": "0.31.7" + }, + "python-language-server-0.31.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16.0a0", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "810353263464caaab606d44e4c12e52e", + "name": "python-language-server", + "sha256": "5efbbb38eec05b55526a72a7736030fe178266913bfb624a5e9ab5feaa83ea2f", + "size": 75200, + "subdir": "linux-64", + "timestamp": 1584458111164, + "version": "0.31.8" + }, + "python-language-server-0.31.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16.0a0", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e3f12154e62d8f7a7473f115d2c96d6", + "name": "python-language-server", + "sha256": "768f4847d06f7218ccad630d9498eaa7a3994335def8dff60507f661d025f79b", + "size": 75335, + "subdir": "linux-64", + "timestamp": 1584457993863, + "version": "0.31.8" + }, + "python-language-server-0.31.8-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16.0a0", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef4b9e8ecd6ace8f730d67088a73d2cd", + "name": "python-language-server", + "sha256": "07ac72ec61cd7b7ab9e089aed307dba8ce9191d960edbbe834b299784bceba95", + "size": 75593, + "subdir": "linux-64", + "timestamp": 1584458011864, + "version": "0.31.8" + }, + "python-language-server-0.31.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16.0a0", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e78e388eec3f74c6c1fc4aa606afc5bf", + "name": "python-language-server", + "sha256": "85ce0598a9061bc47865df10e288395e570817be54e85ec0639c66659b995d57", + "size": 75410, + "subdir": "linux-64", + "timestamp": 1584638156164, + "version": "0.31.9" + }, + "python-language-server-0.31.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16.0a0", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98f6ac259fc64bc39ffd42cd752556d7", + "name": "python-language-server", + "sha256": "2c14dbe0b188c0637c42c7d8fd75fad8cabc03d15626de7722dc771aa037acf3", + "size": 75518, + "subdir": "linux-64", + "timestamp": 1584638148969, + "version": "0.31.9" + }, + "python-language-server-0.31.9-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16.0a0", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3faba75756b70a271e9af1bb5ffb4536", + "name": "python-language-server", + "sha256": "37b0f5f47b7707147c77c47ec20a2d5ead180358870bfc939fc74cb1836a7fe8", + "size": 75805, + "subdir": "linux-64", + "timestamp": 1584638167098, + "version": "0.31.9" + }, + "python-language-server-0.33.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92c9dfdb295d3fdb97fa05155b69ba29", + "name": "python-language-server", + "sha256": "90d06c61e6eac26a2c9937d18afe2cda31d7be59517ca63a373cb36c5a817461", + "size": 78273, + "subdir": "linux-64", + "timestamp": 1590516711530, + "version": "0.33.0" + }, + "python-language-server-0.33.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c247e3b8297805271873d770eb36321c", + "name": "python-language-server", + "sha256": "f5ee5fd5060c9988d20cef533bcf3e45197ce748b601d96b12b323c307e63fb6", + "size": 78361, + "subdir": "linux-64", + "timestamp": 1590516687784, + "version": "0.33.0" + }, + "python-language-server-0.33.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e325ef5b5451d8aea0809d940ff981e0", + "name": "python-language-server", + "sha256": "9812f841059c2fbba52b840bf9d8799079ace3686bb4cd88ed0ff52c12444a85", + "size": 78708, + "subdir": "linux-64", + "timestamp": 1590516710257, + "version": "0.33.0" + }, + "python-language-server-0.33.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4168bb40fb861709d6cdded681f8391a", + "name": "python-language-server", + "sha256": "439abab87a96ab0c6c05e93e0a55f7cda78e4594463b95ece4645d3d0932efcd", + "size": 78492, + "subdir": "linux-64", + "timestamp": 1592348658434, + "version": "0.33.1" + }, + "python-language-server-0.33.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fdb55d6eb188318c1afcc87cd08c1f64", + "name": "python-language-server", + "sha256": "d2173a6a1d748c43d3b51bb4bca34bcc53be867d4912de6c4f43920c15fcf89d", + "size": 78704, + "subdir": "linux-64", + "timestamp": 1592348658461, + "version": "0.33.1" + }, + "python-language-server-0.33.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce025f7b84a82784d5f2a6db22f5de4f", + "name": "python-language-server", + "sha256": "f269a73d874dc5df1ae2488cf1ca2802085cd05d37b2d9baee8330aba2773739", + "size": 79090, + "subdir": "linux-64", + "timestamp": 1592348659677, + "version": "0.33.1" + }, + "python-language-server-0.33.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c49938e6bc5a2dc8385cc78db69ea51", + "name": "python-language-server", + "sha256": "c729167a1481053c66603821538b64b0f8997a12bcb4975d4ff061311bec6148", + "size": 78676, + "subdir": "linux-64", + "timestamp": 1592846461076, + "version": "0.33.2" + }, + "python-language-server-0.33.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d9403cdc46262cacfc82186123046f0", + "name": "python-language-server", + "sha256": "c5fea2cad40d8730a0ce7f166730809d867f3c8346447ba609536e557100d939", + "size": 78726, + "subdir": "linux-64", + "timestamp": 1592846450262, + "version": "0.33.2" + }, + "python-language-server-0.33.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18315cb35ff597b12026b7c1094af04d", + "name": "python-language-server", + "sha256": "8fb921ac69a03b2054f88240ffdcc5cf9489bd763f73da1151051b563881e721", + "size": 79142, + "subdir": "linux-64", + "timestamp": 1592846461245, + "version": "0.33.2" + }, + "python-language-server-0.33.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef1b021ce80d72ca56a7bd8fa66cf99a", + "name": "python-language-server", + "sha256": "8b34ee215bf563fa16ad4396f5f036bf4dc55010df0d64428f076cd150bfb0ea", + "size": 78786, + "subdir": "linux-64", + "timestamp": 1593447333360, + "version": "0.33.3" + }, + "python-language-server-0.33.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60f63a55a096f5a04dcba84e62a13c39", + "name": "python-language-server", + "sha256": "76a64a5aef3d69f5db5b4313f69624bc2358b9d7148312ebb8e0a0a642fdb524", + "size": 78909, + "subdir": "linux-64", + "timestamp": 1593447317050, + "version": "0.33.3" + }, + "python-language-server-0.33.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f54e0c1ea9b33fb2ba4f3b19b6cd806", + "name": "python-language-server", + "sha256": "120fb217a38bb6ae62d98a613091f3ca34077706b326e18058885386dbcef49e", + "size": 79175, + "subdir": "linux-64", + "timestamp": 1593447319513, + "version": "0.33.3" + }, + "python-language-server-0.34.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "453fffe8b99c56b44e85c93ccda4e026", + "name": "python-language-server", + "sha256": "62b332bc819fd93d175bed9888fea0d204d96fd7228007f11f06355b7a0a7fb2", + "size": 79300, + "subdir": "linux-64", + "timestamp": 1594161901855, + "version": "0.34.1" + }, + "python-language-server-0.34.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb5fdec5d3f9b9b3269425c7adb5fa1a", + "name": "python-language-server", + "sha256": "9140fc93a0830e046b55cfb9980f06059034b12d97e9d955efbb93df74cbfb41", + "size": 79384, + "subdir": "linux-64", + "timestamp": 1594161936391, + "version": "0.34.1" + }, + "python-language-server-0.34.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a4a888fc16dbfe89a8e2518b5ad98b35", + "name": "python-language-server", + "sha256": "f7f33685810405b03cfc5daeaabd821ac9d8c0edbc3b99b719592332edd61037", + "size": 79781, + "subdir": "linux-64", + "timestamp": 1594161939648, + "version": "0.34.1" + }, + "python-ldap-3.4.0-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "openldap >=2.4.11,<2.5", + "openldap >=2.4.58,<2.5.0a0", + "pyasn1", + "pyasn1-modules", + "python >=3.10,<3.11.0a0" + ], + "license": "Python Software Foundation", + "license_family": "OTHER", + "md5": "6cad27ef95c9581eda3984eaf3b50067", + "name": "python-ldap", + "namespace_in_name": true, + "sha256": "5a2b9d1ebfbd28660baff083f2c825c06c4f2f78949121cfc6b3d8fc2b1859b0", + "size": 255148, + "subdir": "linux-64", + "timestamp": 1659722265640, + "version": "3.4.0" + }, + "python-ldap-3.4.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "openldap >=2.4.11,<2.5", + "openldap >=2.4.58,<2.5.0a0", + "pyasn1", + "pyasn1-modules", + "python >=3.11,<3.12.0a0" + ], + "license": "Python Software Foundation", + "license_family": "OTHER", + "md5": "510315db3393cf09591b5ebdf24e58ed", + "name": "python-ldap", + "namespace_in_name": true, + "sha256": "8970d3ee25de2ae88457713a9b33eb08417e50e84e23eee53ade6cc2704a0db9", + "size": 209085, + "subdir": "linux-64", + "timestamp": 1676861517258, + "version": "3.4.0" + }, + "python-ldap-3.4.0-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "openldap >=2.4.11,<2.5", + "openldap >=2.4.58,<2.5.0a0", + "pyasn1", + "pyasn1-modules", + "python >=3.7,<3.8.0a0" + ], + "license": "Python Software Foundation", + "license_family": "OTHER", + "md5": "2b745763f506bd74da5650f6d5786f50", + "name": "python-ldap", + "namespace_in_name": true, + "sha256": "b8d2c390de7ae8168bcd399c8e6cc3c1847602c5b934271510fb637a989cb271", + "size": 165143, + "subdir": "linux-64", + "timestamp": 1659722219570, + "version": "3.4.0" + }, + "python-ldap-3.4.0-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "openldap >=2.4.11,<2.5", + "openldap >=2.4.58,<2.5.0a0", + "pyasn1", + "pyasn1-modules", + "python >=3.8,<3.9.0a0" + ], + "license": "Python Software Foundation", + "license_family": "OTHER", + "md5": "dc3b30e7a8bb18f112d7f01b69be4e52", + "name": "python-ldap", + "namespace_in_name": true, + "sha256": "e342d6f2491a709f77d4bffef2a7c5b085d91be2b2678a16a94bf05067438048", + "size": 166410, + "subdir": "linux-64", + "timestamp": 1659722332962, + "version": "3.4.0" + }, + "python-ldap-3.4.0-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "openldap >=2.4.11,<2.5", + "openldap >=2.4.58,<2.5.0a0", + "pyasn1", + "pyasn1-modules", + "python >=3.9,<3.10.0a0" + ], + "license": "Python Software Foundation", + "license_family": "OTHER", + "md5": "37730d5522933c9ccd567a5db63ace05", + "name": "python-ldap", + "namespace_in_name": true, + "sha256": "e7c25f0bd8514d0fe4d059ca7f727710aa8a2c008e0cb1d79b5e9a26f986566c", + "size": 166631, + "subdir": "linux-64", + "timestamp": 1659722300992, + "version": "3.4.0" + }, + "python-leveldb-0.20-py27hf484d3e_1.tar.bz2": { + "build": "py27hf484d3e_1", + "build_number": 1, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "289c5c368cc7ca1e47826aa8e68415c8", + "name": "python-leveldb", + "sha256": "c0174a124b2621d7ce6ba12cc572605e33ac4a3c41132e03d4af5ed158465ed0", + "size": 25283, + "subdir": "linux-64", + "timestamp": 1512805102043, + "version": "0.20" + }, + "python-leveldb-0.20-py35hf484d3e_1.tar.bz2": { + "build": "py35hf484d3e_1", + "build_number": 1, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d39c75c9ab277f55429a10a4a57ada5e", + "name": "python-leveldb", + "sha256": "49bc6559f610bf967664ae1a63c3077ad94e3bb36b8b91c5a13bb7c4c63e8781", + "size": 25541, + "subdir": "linux-64", + "timestamp": 1512805041846, + "version": "0.20" + }, + "python-leveldb-0.20-py36hf484d3e_1.tar.bz2": { + "build": "py36hf484d3e_1", + "build_number": 1, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b7388129183fd977304f75c94e235d17", + "name": "python-leveldb", + "sha256": "c6c255f09701ea0a6cb1fb75b8c3606e2e9d21ba6f4a358966809ed814da2254", + "size": 25519, + "subdir": "linux-64", + "timestamp": 1512805238226, + "version": "0.20" + }, + "python-leveldb-0.20-py37hf484d3e_1.tar.bz2": { + "build": "py37hf484d3e_1", + "build_number": 1, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0b90c5b35bfc8b5cb69c91b4a6f11da0", + "name": "python-leveldb", + "sha256": "7cf8d0fabf2b31fe5425578c350c5f728d428b5858a9e29fbdb9f5847d00fa16", + "size": 25347, + "subdir": "linux-64", + "timestamp": 1530792937990, + "version": "0.20" + }, + "python-leveldb-0.20-py38he6710b0_1.tar.bz2": { + "build": "py38he6710b0_1", + "build_number": 1, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "02d2886acb6bfc42907668b919d2a861", + "name": "python-leveldb", + "sha256": "56b66f3ec9600133584fbf74652441ccfb089eaa03e34494e5232e8fd144049e", + "size": 33493, + "subdir": "linux-64", + "timestamp": 1573200469890, + "version": "0.20" + }, + "python-leveldb-0.201-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5a786e19e4a19c7a17ec8127eb9d992f", + "name": "python-leveldb", + "sha256": "5ce5a4b7e2e7f806d7e900b673f460614114674085fdf4c0a7fe9610ac89bf9a", + "size": 117153, + "subdir": "linux-64", + "timestamp": 1640793837358, + "version": "0.201" + }, + "python-leveldb-0.201-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0268623a2a023c61fe7ab7d0c5b8cefc", + "name": "python-leveldb", + "sha256": "023a5959c1f0c7da85b978d42dfaefd7053892faf6507cde6f9b2dc1ff97db2e", + "size": 26922, + "subdir": "linux-64", + "timestamp": 1676861536965, + "version": "0.201" + }, + "python-leveldb-0.201-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fd94876e70f26c6b4d36afa525a59006", + "name": "python-leveldb", + "sha256": "d1b3520258453bf61def3aa37b488e7e0f6b72c6c87de2fa80e9b261ae50ba57", + "size": 27311, + "subdir": "linux-64", + "timestamp": 1613553945503, + "version": "0.201" + }, + "python-leveldb-0.201-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "993dbcc14b66d05f4188fe5d41955494", + "name": "python-leveldb", + "sha256": "f2e3067e45267e9bc4588152c2eeb80a3a71c50503439cc1701af42086620829", + "size": 27348, + "subdir": "linux-64", + "timestamp": 1580311448503, + "version": "0.201" + }, + "python-leveldb-0.201-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "37e033dc4c47a0373ae4b69d5c94a0ea", + "name": "python-leveldb", + "sha256": "bb1cb17ecd914fcbacebb00f5ce229ddd9a92efe07d59c7ab595f1a276aba32a", + "size": 27301, + "subdir": "linux-64", + "timestamp": 1613553279129, + "version": "0.201" + }, + "python-leveldb-0.201-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "83c567279b1d710c747fd013d03b3516", + "name": "python-leveldb", + "sha256": "ec57db23356417a29c61e2cf7804153f75f23f003c7738623ee67263530dab7f", + "size": 27303, + "subdir": "linux-64", + "timestamp": 1580311438318, + "version": "0.201" + }, + "python-leveldb-0.201-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7233354e9d265ea620e9b253dd6adc33", + "name": "python-leveldb", + "sha256": "a9af7feaaf15c65b62a0464aeb05eb74b1ce4681b4136960a06a4ad3a399d201", + "size": 27710, + "subdir": "linux-64", + "timestamp": 1613553950772, + "version": "0.201" + }, + "python-leveldb-0.201-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dd7b1122c1cd5839f739bc3673b81236", + "name": "python-leveldb", + "sha256": "3a8efc0ed0365d949c49ece5f296b7a0142b3f7ea74832841becc8707b8af18b", + "size": 27734, + "subdir": "linux-64", + "timestamp": 1580311443433, + "version": "0.201" + }, + "python-leveldb-0.201-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5be5ac9fa37989b886b4f767672b1f05", + "name": "python-leveldb", + "sha256": "9560e69c04a34b07e8c55482e5b258707180d73004828e9627678956efe8cf9d", + "size": 27722, + "subdir": "linux-64", + "timestamp": 1613553947976, + "version": "0.201" + }, + "python-levenshtein-0.12.0-py27h7b6447c_1001.tar.bz2": { + "build": "py27h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "52159dda09a95549b9b74c538972c4a0", + "name": "python-levenshtein", + "sha256": "3612853aed1280b8d95ae73b665a18c88428508f5de67f78ff2891b89edca599", + "size": 81010, + "subdir": "linux-64", + "timestamp": 1569336193856, + "version": "0.12.0" + }, + "python-levenshtein-0.12.0-py36h7b6447c_1001.tar.bz2": { + "build": "py36h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "fd8aa6ef53d50efc31b8b254878f6cac", + "name": "python-levenshtein", + "sha256": "d3e8c7486918ac3d26bca796c657a91d3bf0e78a4fda616cb3bfa7e3b91e131e", + "size": 82043, + "subdir": "linux-64", + "timestamp": 1569336198573, + "version": "0.12.0" + }, + "python-levenshtein-0.12.0-py37h7b6447c_1001.tar.bz2": { + "build": "py37h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "649e05247d6313f6e9030b9081a0b449", + "name": "python-levenshtein", + "sha256": "c8acd53871471366922f7c5f73780a95e4d8ae893164ad6239de26143ed8126d", + "size": 82098, + "subdir": "linux-64", + "timestamp": 1569336189485, + "version": "0.12.0" + }, + "python-levenshtein-0.12.2-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "b02a380609c146bcc8dc5f3191001d11", + "name": "python-levenshtein", + "sha256": "0ebacb6681a07f65d708e46e8fee73b1ec6c6d9fd1fc4f33ea5bf430443c1104", + "size": 157990, + "subdir": "linux-64", + "timestamp": 1640793861939, + "version": "0.12.2" + }, + "python-levenshtein-0.12.2-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "93f012aab5ee3e1cced94c24cc70cb7e", + "name": "python-levenshtein", + "sha256": "bc4395c503c985226a6cc7849441ab8f97143470e0a7e1052f4b741b7a2f9f22", + "size": 81693, + "subdir": "linux-64", + "timestamp": 1676845559787, + "version": "0.12.2" + }, + "python-levenshtein-0.12.2-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "511aba7bc67767bfccf38215d325bece", + "name": "python-levenshtein", + "sha256": "ab307f17403622e9c34269a3925798740c553d8b2eb6b04360359d6cd1a94515", + "size": 83845, + "subdir": "linux-64", + "timestamp": 1613984391327, + "version": "0.12.2" + }, + "python-levenshtein-0.12.2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "03feb4533031e663fd2a16654fa94e59", + "name": "python-levenshtein", + "sha256": "64363497248097656fd3c23d04b3f8b054c64dd85356744e740c962b2700cd54", + "size": 83824, + "subdir": "linux-64", + "timestamp": 1613985269759, + "version": "0.12.2" + }, + "python-levenshtein-0.12.2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "3c376f06d6159d355480f5803f025340", + "name": "python-levenshtein", + "sha256": "f42b3159e8f421787142e02468f2f8538cf4d73f741e9ea20263adde827a230c", + "size": 83987, + "subdir": "linux-64", + "timestamp": 1613985276279, + "version": "0.12.2" + }, + "python-levenshtein-0.12.2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "1cb3077008555178b893a2bccc9e8054", + "name": "python-levenshtein", + "sha256": "aae0008f19052819e28873c9bcd0d84ffd92cceac20878164541613c0b5d6ba6", + "size": 83870, + "subdir": "linux-64", + "timestamp": 1613985249163, + "version": "0.12.2" + }, + "python-libarchive-c-2.7-py27_3.tar.bz2": { + "build": "py27_3", + "build_number": 3, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "5409ec7b9bf7c07473a9df8ba2ea738a", + "name": "python-libarchive-c", + "sha256": "18c843134e657937d2c17d2acddb513be5b69474b46295d5ca329b9108ab690b", + "size": 30855, + "subdir": "linux-64", + "timestamp": 1527551636972, + "version": "2.7" + }, + "python-libarchive-c-2.7-py27ha516919_0.tar.bz2": { + "build": "py27ha516919_0", + "build_number": 0, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "9ec7d14276d7ee37f9be49f3d7abf2da", + "name": "python-libarchive-c", + "sha256": "f8d2b7411ddf5de61667a1176cc100dfb29a95d3e80dc468356c53cfdde33d7e", + "size": 17939, + "subdir": "linux-64", + "timestamp": 1509635398174, + "version": "2.7" + }, + "python-libarchive-c-2.7-py27hc39dc16_0.tar.bz2": { + "build": "py27hc39dc16_0", + "build_number": 0, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "d7ada19e582912a2d250ad1efab84e15", + "name": "python-libarchive-c", + "sha256": "e3177e6d2c2ebdc6d8ac7b57ad6f03ecbed06bc6bd94cfb63b47e92f4d77c027", + "size": 18161, + "subdir": "linux-64", + "timestamp": 1510141974996, + "version": "2.7" + }, + "python-libarchive-c-2.7-py35_3.tar.bz2": { + "build": "py35_3", + "build_number": 3, + "depends": [ + "libarchive", + "python >=3.5,<3.6.0a0" + ], + "license": "CC0-1.0", + "md5": "da90223717605871d84ed6ffe7b83d18", + "name": "python-libarchive-c", + "sha256": "3e0f6bf77858c1ae97bd97ab9b8f79bcd3e6bdc8e8a1b45ec910205b94fd0deb", + "size": 31205, + "subdir": "linux-64", + "timestamp": 1527551658879, + "version": "2.7" + }, + "python-libarchive-c-2.7-py35h47bb897_0.tar.bz2": { + "build": "py35h47bb897_0", + "build_number": 0, + "depends": [ + "libarchive", + "python >=3.5,<3.6.0a0" + ], + "license": "CC0-1.0", + "md5": "d96566da53431d752324921e7a968a88", + "name": "python-libarchive-c", + "sha256": "776b537fd80cd6e3573fba020080b8a0a862a1f97115f7f214f20bfedf3d20c2", + "size": 18296, + "subdir": "linux-64", + "timestamp": 1509635419277, + "version": "2.7" + }, + "python-libarchive-c-2.7-py35he097adb_0.tar.bz2": { + "build": "py35he097adb_0", + "build_number": 0, + "depends": [ + "libarchive", + "python >=3.5,<3.6.0a0" + ], + "license": "CC0-1.0", + "md5": "4130a20b1385078eb07a5b94ef94df75", + "name": "python-libarchive-c", + "sha256": "3359c211c61ff398ae91b11e7737a757d3c6061e8e07bbd3eeaca32f761db057", + "size": 18549, + "subdir": "linux-64", + "timestamp": 1510141990010, + "version": "2.7" + }, + "python-libarchive-c-2.7-py36_3.tar.bz2": { + "build": "py36_3", + "build_number": 3, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "078248b1befb3128920bbf07e9ac80bd", + "name": "python-libarchive-c", + "sha256": "88ecb338c23cc3b0fdb2cfc41f65645cf2f95314df33f5d9efebd78c8f4943ea", + "size": 31204, + "subdir": "linux-64", + "timestamp": 1527551632637, + "version": "2.7" + }, + "python-libarchive-c-2.7-py36h2a28448_0.tar.bz2": { + "build": "py36h2a28448_0", + "build_number": 0, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "109da69b293c69ebc9ec5ed677e2d32f", + "name": "python-libarchive-c", + "sha256": "154fc2a61910c19589698bd58fff665d6261ef0506a196ed6ab614dd8b2c950e", + "size": 18214, + "subdir": "linux-64", + "timestamp": 1509635440694, + "version": "2.7" + }, + "python-libarchive-c-2.7-py36h34ba79f_0.tar.bz2": { + "build": "py36h34ba79f_0", + "build_number": 0, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "152a6463d69e8ee705646d0fd4a37c22", + "name": "python-libarchive-c", + "sha256": "435719463e320c0dc3457d9d1cf47b95407f97d80b54bd3d2b77a5bc43011033", + "size": 18438, + "subdir": "linux-64", + "timestamp": 1510142004761, + "version": "2.7" + }, + "python-libarchive-c-2.8-py27_10.tar.bz2": { + "build": "py27_10", + "build_number": 10, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "5b69044372253f22af5fb0eca301f8df", + "name": "python-libarchive-c", + "sha256": "0b07c5686eb719f3475de3d706332516d552dd6df8d8c7f9ed7e6e8d3c9bbfdd", + "size": 22617, + "subdir": "linux-64", + "timestamp": 1562637158950, + "version": "2.8" + }, + "python-libarchive-c-2.8-py27_11.tar.bz2": { + "build": "py27_11", + "build_number": 11, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "ce00bb214c311fbacde8637c331d9d99", + "name": "python-libarchive-c", + "sha256": "3275e53b17948542dda3d2099e5d07c1a753c42045460bc74c914268ef541d7f", + "size": 22936, + "subdir": "linux-64", + "timestamp": 1563379126980, + "version": "2.8" + }, + "python-libarchive-c-2.8-py27_12.tar.bz2": { + "build": "py27_12", + "build_number": 12, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "b704951e99eb84831a60cf18907a1c4b", + "name": "python-libarchive-c", + "sha256": "e5a5e2e953d2d6987489e73d3b889e4c5b27ec514e3f39f4542dc1e05968a1d7", + "size": 23524, + "subdir": "linux-64", + "timestamp": 1565094958470, + "version": "2.8" + }, + "python-libarchive-c-2.8-py27_13.tar.bz2": { + "build": "py27_13", + "build_number": 13, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "dd842b1fff57f9cb8a09c037d9e6df94", + "name": "python-libarchive-c", + "sha256": "29325923021e14ff10592255c439a7ff9d73b6e8246acb15dda1fdd8cbe6e53f", + "size": 23702, + "subdir": "linux-64", + "timestamp": 1565112859003, + "version": "2.8" + }, + "python-libarchive-c-2.8-py27_3.tar.bz2": { + "build": "py27_3", + "build_number": 3, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "70121b62404c79e525f7c4642fbc675f", + "name": "python-libarchive-c", + "sha256": "26aa263d4a070f61fd17897037a54096dd2deb20bf226f72f3bbe0ad2a182d38", + "size": 19654, + "subdir": "linux-64", + "timestamp": 1528670501438, + "version": "2.8" + }, + "python-libarchive-c-2.8-py27_4.tar.bz2": { + "build": "py27_4", + "build_number": 4, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "0d9585c78d87f63f268bafc995e2b555", + "name": "python-libarchive-c", + "sha256": "129ff514ef21bbeb7b1f7d92b0dc1b788c8ffb8593d401fb59ac8234bc3b4e20", + "size": 20008, + "subdir": "linux-64", + "timestamp": 1537561698266, + "version": "2.8" + }, + "python-libarchive-c-2.8-py27_5.tar.bz2": { + "build": "py27_5", + "build_number": 5, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "9d5c6554d41245aeb8f17706b9fe0cfd", + "name": "python-libarchive-c", + "sha256": "68e405571415739ab2f8684e4c7aef88eec229c4ea271033a80607f4883814a4", + "size": 20093, + "subdir": "linux-64", + "timestamp": 1537657609137, + "version": "2.8" + }, + "python-libarchive-c-2.8-py27_6.tar.bz2": { + "build": "py27_6", + "build_number": 6, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "95f093f7459fd3b6b02d7bf32d39675d", + "name": "python-libarchive-c", + "sha256": "c5e6a27c8bcc05c26e3a241f386e109d83f70268f2cc4ab7e4a3c50c92703163", + "size": 20255, + "subdir": "linux-64", + "timestamp": 1538304544227, + "version": "2.8" + }, + "python-libarchive-c-2.8-py27_8.tar.bz2": { + "build": "py27_8", + "build_number": 8, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "b11b4922f2cce7734f1732bff0ae5956", + "name": "python-libarchive-c", + "sha256": "54a794ef6d60d99f2c6eee186e6f27a8b617db5d62822defec8d5ad59ccd104f", + "size": 22400, + "subdir": "linux-64", + "timestamp": 1562099804534, + "version": "2.8" + }, + "python-libarchive-c-2.8-py27_9.tar.bz2": { + "build": "py27_9", + "build_number": 9, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "e2af9e76cc01f28c233563f18eb37d91", + "name": "python-libarchive-c", + "sha256": "42c423a9bc3b1fb9a60ca18189d961e3b64de28b21fb8de5ec2bcc6e38f9da3e", + "size": 22506, + "subdir": "linux-64", + "timestamp": 1562445650897, + "version": "2.8" + }, + "python-libarchive-c-2.8-py35_3.tar.bz2": { + "build": "py35_3", + "build_number": 3, + "depends": [ + "libarchive", + "python >=3.5,<3.6.0a0" + ], + "license": "CC0-1.0", + "md5": "02b9d615b387bb3304c2d834b43f86a8", + "name": "python-libarchive-c", + "sha256": "9983798277734dc43e3d16394c9669c497c23c2aac2291acd8ef1731d0c83c54", + "size": 20049, + "subdir": "linux-64", + "timestamp": 1528670552417, + "version": "2.8" + }, + "python-libarchive-c-2.8-py35_4.tar.bz2": { + "build": "py35_4", + "build_number": 4, + "depends": [ + "libarchive", + "python >=3.5,<3.6.0a0" + ], + "license": "CC0-1.0", + "md5": "94cd2f45308d001c1bd4aa2cfb812b22", + "name": "python-libarchive-c", + "sha256": "f92bab0bedfd7cc4fa31e2a9e8970c4af0685bd16640f665f21b36fbf02658d2", + "size": 20382, + "subdir": "linux-64", + "timestamp": 1537561529759, + "version": "2.8" + }, + "python-libarchive-c-2.8-py35_5.tar.bz2": { + "build": "py35_5", + "build_number": 5, + "depends": [ + "libarchive", + "python >=3.5,<3.6.0a0" + ], + "license": "CC0-1.0", + "md5": "09d7013da7815c496dccb93c89a0c963", + "name": "python-libarchive-c", + "sha256": "c60101adf6b775f5d55ec3b20315c027117ffb707eb5f45f4744daf950ef0cd5", + "size": 20433, + "subdir": "linux-64", + "timestamp": 1537657732991, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_10.tar.bz2": { + "build": "py36_10", + "build_number": 10, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "718424b5d69276b4063366e6460b1bfc", + "name": "python-libarchive-c", + "sha256": "6c7e80e1d9195e1929ea9b6d2c1c2186908cbead3ba97ee69ee3a1782dc3624f", + "size": 22911, + "subdir": "linux-64", + "timestamp": 1562637162314, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_11.tar.bz2": { + "build": "py36_11", + "build_number": 11, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "807523d852fb4dd606533c899fc60a1f", + "name": "python-libarchive-c", + "sha256": "75a88e9445b072c0b12d39a7c698c7201ce97b97db6d2d2110db846dc004a4c7", + "size": 23288, + "subdir": "linux-64", + "timestamp": 1563379115093, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_12.tar.bz2": { + "build": "py36_12", + "build_number": 12, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "da17a0532d542b28dbd87f24293f67df", + "name": "python-libarchive-c", + "sha256": "f348cb9770300bec3e780735eea4cccda072530650ed9d03e05b2450fea7fb7c", + "size": 23871, + "subdir": "linux-64", + "timestamp": 1565095021240, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_13.tar.bz2": { + "build": "py36_13", + "build_number": 13, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "89ac910adf3330d795b0bf0a6deaa7d2", + "name": "python-libarchive-c", + "sha256": "d7c1142f9379e1c5f701c37953c6dcb9dd3f597184d7036a04faa56f500d922d", + "size": 23974, + "subdir": "linux-64", + "timestamp": 1565112920393, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_3.tar.bz2": { + "build": "py36_3", + "build_number": 3, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "454fe2ba3f0232e9ff0654e8d4396c3a", + "name": "python-libarchive-c", + "sha256": "8376f697556b68d5e54cc080cf2c58abb938a42fe7d677bbcc5201c0eb11caa6", + "size": 20069, + "subdir": "linux-64", + "timestamp": 1528670528832, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_4.tar.bz2": { + "build": "py36_4", + "build_number": 4, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "2631a797c7f0329e95d7bead4238b5c8", + "name": "python-libarchive-c", + "sha256": "ee86c9029c21caede8731aafd117b9c4459e45c80d6ed3d7a2937ecec51e9ae6", + "size": 20355, + "subdir": "linux-64", + "timestamp": 1537561759185, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_5.tar.bz2": { + "build": "py36_5", + "build_number": 5, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "65d4a4a5be16251d79466ea2dd393a41", + "name": "python-libarchive-c", + "sha256": "137525cc581b90bc48797539502da3805630f2bdb4276125ce374eb7dc4e0475", + "size": 20401, + "subdir": "linux-64", + "timestamp": 1537657954901, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_6.tar.bz2": { + "build": "py36_6", + "build_number": 6, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "dbde7bc1877b0f63051ad2ac93c1222e", + "name": "python-libarchive-c", + "sha256": "324b99bd3ae2d434c977efda70c9497d96eecd8140903c6e446ae0cbade3d2d2", + "size": 20574, + "subdir": "linux-64", + "timestamp": 1538304557337, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_8.tar.bz2": { + "build": "py36_8", + "build_number": 8, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "683c9b995dc3d0b7079b3af7565458bb", + "name": "python-libarchive-c", + "sha256": "d462d666ab33f957dcc0121523590dea7deb90873cc792503f3b738db89b8758", + "size": 22745, + "subdir": "linux-64", + "timestamp": 1562099814444, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_9.tar.bz2": { + "build": "py36_9", + "build_number": 9, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "894483560a2a991ecb3b71372ae53bc8", + "name": "python-libarchive-c", + "sha256": "2162999359be09c45dc890fdd15c2f568bb5958b43060e0acb12229248167f11", + "size": 22826, + "subdir": "linux-64", + "timestamp": 1562445658204, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_10.tar.bz2": { + "build": "py37_10", + "build_number": 10, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "126db2c4cdac71eb58fb08060c7e89d9", + "name": "python-libarchive-c", + "sha256": "33db9d5e8f8d119e82a82987d1b067c2ba1f591aaac2646024b65b4d8fed691a", + "size": 22864, + "subdir": "linux-64", + "timestamp": 1562637147425, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_11.tar.bz2": { + "build": "py37_11", + "build_number": 11, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "91b7b59fa152c864114f9e79422e67b5", + "name": "python-libarchive-c", + "sha256": "691acad792a1d592f1d7dcaa587e9e78c1ce9ddaa289193065a4456c0adc2b73", + "size": 23266, + "subdir": "linux-64", + "timestamp": 1563379109593, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_12.tar.bz2": { + "build": "py37_12", + "build_number": 12, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "e9097d4348da10fb504366d9957ba3da", + "name": "python-libarchive-c", + "sha256": "a8aaaca60e21c93e1639eda2d90d2636b169c40b7290095c9a2a8ca5b0c5f3bb", + "size": 23869, + "subdir": "linux-64", + "timestamp": 1565094922619, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_13.tar.bz2": { + "build": "py37_13", + "build_number": 13, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "e21956cfa75890a577807c20a6b28f5e", + "name": "python-libarchive-c", + "sha256": "7e333fe8bb06a9f0e66c4881df3f8872291de1403f319a28f1c4dff4f4e86c03", + "size": 23944, + "subdir": "linux-64", + "timestamp": 1565112746113, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_3.tar.bz2": { + "build": "py37_3", + "build_number": 3, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "9174a18de19b35689de6cd3f7f0c0c2a", + "name": "python-libarchive-c", + "sha256": "18ca0f5500fa3052626ea15b4c35178710faf600ab620af09572395214a6db1d", + "size": 19942, + "subdir": "linux-64", + "timestamp": 1530922766626, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_4.tar.bz2": { + "build": "py37_4", + "build_number": 4, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "143dbe83a544fcf76fcde80c8454aeb7", + "name": "python-libarchive-c", + "sha256": "b8f3712806eb7060131125da311f40f1246e8773e29e06c2efbda035f9347038", + "size": 20326, + "subdir": "linux-64", + "timestamp": 1537561435967, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_5.tar.bz2": { + "build": "py37_5", + "build_number": 5, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "4990a4dc6f9bec7cf9e4bb20e9378df7", + "name": "python-libarchive-c", + "sha256": "591c5c907d30fa7dd284e163b0e4218003dd987c91c8b12e8ea3bb2c8c3fb5f3", + "size": 20373, + "subdir": "linux-64", + "timestamp": 1537657341519, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_6.tar.bz2": { + "build": "py37_6", + "build_number": 6, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "7a65f346023be8d138c5a1da4bcd996d", + "name": "python-libarchive-c", + "sha256": "b32fa069d472af3e5f6c5e5614102d2011570093c42c0fffe4c45c866586a898", + "size": 20590, + "subdir": "linux-64", + "timestamp": 1538304523663, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_8.tar.bz2": { + "build": "py37_8", + "build_number": 8, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "6d4c96c5e37b1080b5a1ef468a6fadf9", + "name": "python-libarchive-c", + "sha256": "3b9bf8decad5bb3393c3dfe282efdf7584e3577253d0d5121d1b37ec6ffcd9c8", + "size": 22745, + "subdir": "linux-64", + "timestamp": 1562099785109, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_9.tar.bz2": { + "build": "py37_9", + "build_number": 9, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "6f25ddc10bdbf4d6cf77f6450dcc061c", + "name": "python-libarchive-c", + "sha256": "45817999d7d41bd685bd7329d56eeb5958b24c6c2c383b80e9a449c4069e310c", + "size": 22807, + "subdir": "linux-64", + "timestamp": 1562445646708, + "version": "2.8" + }, + "python-libarchive-c-2.8-py38_7.tar.bz2": { + "build": "py38_7", + "build_number": 7, + "depends": [ + "libarchive", + "python >=3.8,<3.9.0a0" + ], + "license": "CC0-1.0", + "md5": "252c5a6c883138fc4e817ff17e9bd736", + "name": "python-libarchive-c", + "sha256": "5bfc960228251b9c4da261a051b579c4ce2df8e52486f9c3a5ed5f50b4b87f16", + "size": 20792, + "subdir": "linux-64", + "timestamp": 1573200481551, + "version": "2.8" + }, + "python-libarchive-c-2.9-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "libarchive", + "python >=3.9,<3.10.0a0" + ], + "license": "CC0-1.0", + "md5": "81fb5e0521e96996f4fbcaa2969ab0fe", + "name": "python-libarchive-c", + "sha256": "7b22d0556f4a8e99e5dee2ac2195636331645fcbac2da0470ffbff61a8da19fe", + "size": 30157, + "subdir": "linux-64", + "timestamp": 1605468802267, + "version": "2.9" + }, + "python-lmdb-0.93-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "6ce4cf55a5f1a3c4712a6964f60d1d21", + "name": "python-lmdb", + "sha256": "a65ae17d4a9f646fb9576f1cbc8f0330e07d3d1d3df5af56f36f5a8dfe95f56d", + "size": 125596, + "subdir": "linux-64", + "timestamp": 1522882457657, + "version": "0.93" + }, + "python-lmdb-0.93-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "d9c4853384eec3846cbab4a7fe26426b", + "name": "python-lmdb", + "sha256": "09266ab48237df25a983b436f35b31d31719f40abb4e99a23d7c11afebed5872", + "size": 126865, + "subdir": "linux-64", + "timestamp": 1522882518263, + "version": "0.93" + }, + "python-lmdb-0.93-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "28288873408a3dd67cf3479f79931a32", + "name": "python-lmdb", + "sha256": "4c6c7a758b0f70d80fa11cf68b40028c44547128c009c2222d44bdce384c70cf", + "size": 126682, + "subdir": "linux-64", + "timestamp": 1522882517608, + "version": "0.93" + }, + "python-lmdb-0.94-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "2a460c9f27aaba39f6eb0f02be57577a", + "name": "python-lmdb", + "sha256": "a9102de1fa8afb9579b9cb15cab57c4930204abd58bb83ccd99cc4265d78bb24", + "size": 126543, + "subdir": "linux-64", + "timestamp": 1524094866968, + "version": "0.94" + }, + "python-lmdb-0.94-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "2fb58fd9133205aeeddbceb925791016", + "name": "python-lmdb", + "sha256": "a4df5061795448f26bdc702625dd365f71729d72280b1ce27573ccb843a0c21a", + "size": 127772, + "subdir": "linux-64", + "timestamp": 1524094899078, + "version": "0.94" + }, + "python-lmdb-0.94-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "68d957460d80a53133514b192b48454c", + "name": "python-lmdb", + "sha256": "4ad8ba88bb5e4868b80775928777ec546375ab99625d1103b39bcf0144a988aa", + "size": 127628, + "subdir": "linux-64", + "timestamp": 1524094904574, + "version": "0.94" + }, + "python-lmdb-0.94-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "fbe544acc6d13cf3c338d8b6cdb33a94", + "name": "python-lmdb", + "sha256": "32f063fe20c03d3e7ea17ff6a01802dcd141bcafc2f4c6f0b51f316bbfc303aa", + "size": 127727, + "subdir": "linux-64", + "timestamp": 1530922808789, + "version": "0.94" + }, + "python-lmdb-0.97-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "16b3f7936ed608821ae5300dbf915112", + "name": "python-lmdb", + "sha256": "118e6e4eb00a4d99b74ae3ac49fdc7d4cb430d7252c6474523d18a5dec0f355f", + "size": 131024, + "subdir": "linux-64", + "timestamp": 1569420583853, + "version": "0.97" + }, + "python-lmdb-0.97-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "2217834b1e7ed5814d08e02e36be2fc4", + "name": "python-lmdb", + "sha256": "a7975c16f6345088c67858e1bbee8a293befdfedc55a08c439cbc92321ae62b9", + "size": 132094, + "subdir": "linux-64", + "timestamp": 1569420589456, + "version": "0.97" + }, + "python-lmdb-0.97-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "d8cad3594f96e5f887d314919691554d", + "name": "python-lmdb", + "sha256": "4a724c4044efa00413219e12571cb5184d8bd6704de768d996a07b7de89f2307", + "size": 132351, + "subdir": "linux-64", + "timestamp": 1569420593949, + "version": "0.97" + }, + "python-lmdb-0.97-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "c274af18045149e11afe341fc5e17119", + "name": "python-lmdb", + "sha256": "434b5d481f749bcab0d091cad7ed39d1d06bae74abc7fe60bb629d7ff352a372", + "size": 138132, + "subdir": "linux-64", + "timestamp": 1573200506334, + "version": "0.97" + }, + "python-lmdb-0.98-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "e7ea707f041310ce02e57617199359d8", + "name": "python-lmdb", + "sha256": "918806089a26d74569f4672e8d14b7c3068d9c9333d2f2cdf234a99dda23cd49", + "size": 130898, + "subdir": "linux-64", + "timestamp": 1574369782412, + "version": "0.98" + }, + "python-lmdb-0.98-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "20fa61852d83a0fe2adbd5eedc8c78cf", + "name": "python-lmdb", + "sha256": "2e245b2d8f36bea0f9d617954b66a39f5ea2c3380b3829c0ee4379ad4084e966", + "size": 132576, + "subdir": "linux-64", + "timestamp": 1574369789696, + "version": "0.98" + }, + "python-lmdb-0.98-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "9c905bc431f585d5a1cc6d0419ae63f6", + "name": "python-lmdb", + "sha256": "31d4bd88094377710fa73d8c36fca1fd603eb2b41b383cf49e58f6a49ac45e4c", + "size": 132822, + "subdir": "linux-64", + "timestamp": 1574369773730, + "version": "0.98" + }, + "python-lmdb-0.98-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "d096b37ebe8023d632c1ff588a6079fc", + "name": "python-lmdb", + "sha256": "916ead7c2e219d247da5ead810f3cf5acdd431f88b5669f3a18d32ce610dd7dd", + "size": 140437, + "subdir": "linux-64", + "timestamp": 1574369840669, + "version": "0.98" + }, + "python-lmdb-1.0.0-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "f54bcc279a35efbe5113b3e08657fbca", + "name": "python-lmdb", + "sha256": "1ad95962b56559c67892548afcb688112839ccbc0e7fd7942d7615051ad1bb2e", + "size": 135065, + "subdir": "linux-64", + "timestamp": 1613553142968, + "version": "1.0.0" + }, + "python-lmdb-1.0.0-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "e7c8a2e4fd57bbe97dc9c3d8c31e81dc", + "name": "python-lmdb", + "sha256": "9dc1d2fb847b3aed86b823ab1ab88b9238a417e7ca7a017eaa1d6f6078cbab72", + "size": 135324, + "subdir": "linux-64", + "timestamp": 1613553139120, + "version": "1.0.0" + }, + "python-lmdb-1.0.0-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "24cf63fe113017d4dd0ff079259bbca9", + "name": "python-lmdb", + "sha256": "f292da8ecef08586e7d3b1f1e6b58bd8a03d7f6b554d7fbecb4bd9dcab6ba6f0", + "size": 135985, + "subdir": "linux-64", + "timestamp": 1613552485308, + "version": "1.0.0" + }, + "python-lmdb-1.0.0-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "ec836f7ad83297d095b143d2c134ac55", + "name": "python-lmdb", + "sha256": "4155ce86bcc2df714c74107c4b945a905704603b978317c59435c3d8b94bc256", + "size": 136136, + "subdir": "linux-64", + "timestamp": 1613553130499, + "version": "1.0.0" + }, + "python-lmdb-1.1.1-py36h2531618_1.tar.bz2": { + "build": "py36h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "51471b4d3d431384450da99be3bfe421", + "name": "python-lmdb", + "sha256": "7ec723bc0886e399710b56647d198d1276aad346d4430dd170cf4da4df3ea5e0", + "size": 136078, + "subdir": "linux-64", + "timestamp": 1613936429961, + "version": "1.1.1" + }, + "python-lmdb-1.1.1-py37h2531618_1.tar.bz2": { + "build": "py37h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "1fd76511303ada677a3f1c1d43e9d42f", + "name": "python-lmdb", + "sha256": "0806a6cbff43cda3b234f8853f399ce33a2df4a4d9c1d848c944b8a45c150aef", + "size": 136382, + "subdir": "linux-64", + "timestamp": 1613935953661, + "version": "1.1.1" + }, + "python-lmdb-1.1.1-py38h2531618_1.tar.bz2": { + "build": "py38h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "df217a693119027585ac70d9c26b02bb", + "name": "python-lmdb", + "sha256": "a0e8abd5af5aeed4de64eadb7c97d593d174c1c8d80bbe9c1c39a944235aaeed", + "size": 137095, + "subdir": "linux-64", + "timestamp": 1613936431695, + "version": "1.1.1" + }, + "python-lmdb-1.1.1-py39h2531618_1.tar.bz2": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "b045f8bb872a98e1910b5adb6ebfdfc4", + "name": "python-lmdb", + "sha256": "bc0b24dd9b39f13d0ec2cec24713aaf27bb541635b60f6974e280f896dfcc577", + "size": 137352, + "subdir": "linux-64", + "timestamp": 1613936417951, + "version": "1.1.1" + }, + "python-lmdb-1.2.1-py310h295c915_1.tar.bz2": { + "build": "py310h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "b5cf3d6a7ed53499259683191a6a88ca", + "name": "python-lmdb", + "sha256": "d4411c9e29572e664885ae46671df0f523bf1767f1045ed76a839e1f4d011535", + "size": 284033, + "subdir": "linux-64", + "timestamp": 1640793890808, + "version": "1.2.1" + }, + "python-lmdb-1.2.1-py36h2531618_1.tar.bz2": { + "build": "py36h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "79f40a2c23342caacbb20b73d5e4de34", + "name": "python-lmdb", + "sha256": "7915d4f6aab1041e89549a2b3df37b238e3722394bd9cc9737a6460137312478", + "size": 138651, + "subdir": "linux-64", + "timestamp": 1619704435284, + "version": "1.2.1" + }, + "python-lmdb-1.2.1-py37h2531618_1.tar.bz2": { + "build": "py37h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "71ea0ca3fa01453e8e907f7609e943f1", + "name": "python-lmdb", + "sha256": "d53976ca35d6e04852ae075993bc2642f06d1bc51f77830b1bb4ca8798cf1f2f", + "size": 138882, + "subdir": "linux-64", + "timestamp": 1619708194728, + "version": "1.2.1" + }, + "python-lmdb-1.2.1-py38h2531618_1.tar.bz2": { + "build": "py38h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "cfb0c6464216dd11a338f990de0fd77e", + "name": "python-lmdb", + "sha256": "abfb8101b1d642a8055e900a153410aa9155c2ea34658d517b956139c63a76d9", + "size": 139712, + "subdir": "linux-64", + "timestamp": 1619708194484, + "version": "1.2.1" + }, + "python-lmdb-1.2.1-py39h2531618_1.tar.bz2": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "3cda7341392aabe12acd00eb558b6b87", + "name": "python-lmdb", + "sha256": "9f9960f37966ed8b93479bdcdb2879dbba434073e44ce8f43ca5eda848b2fb75", + "size": 140189, + "subdir": "linux-64", + "timestamp": 1619707719895, + "version": "1.2.1" + }, + "python-lmdb-1.4.0-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "OLDAP-2.8", + "license_family": "Other", + "md5": "a619554c9ebc58fb4665ac631906fae0", + "name": "python-lmdb", + "sha256": "f0742b1ba2a09a1c7c5a4536f594a5819ed9a41fbeb22ed97fa47856884e915d", + "size": 138735, + "subdir": "linux-64", + "timestamp": 1677273782973, + "version": "1.4.0" + }, + "python-lmdb-1.4.0-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "OLDAP-2.8", + "license_family": "Other", + "md5": "76eb10b54cff5ca1a9349fcfe79a26a3", + "name": "python-lmdb", + "sha256": "99176bf91c33cef9264a482cfee74bfef1a027dd9754911471e9b79fea7cbf76", + "size": 154088, + "subdir": "linux-64", + "timestamp": 1677271680687, + "version": "1.4.0" + }, + "python-lmdb-1.4.0-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "OLDAP-2.8", + "license_family": "Other", + "md5": "5e473487c98c1dcb2eb7258fb53173bc", + "name": "python-lmdb", + "sha256": "6b7625c1fd90d56d9b959dba54a5bad6ef58f650ec4c5bbce54baa9d128cec1e", + "size": 137677, + "subdir": "linux-64", + "timestamp": 1677273886282, + "version": "1.4.0" + }, + "python-lmdb-1.4.0-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "OLDAP-2.8", + "license_family": "Other", + "md5": "83466f05c7b9d21b405982f27f6586f8", + "name": "python-lmdb", + "sha256": "3ad4602feb8c8aa675007d5ab6f095c921460fbd815493d2bada548343829aa7", + "size": 138313, + "subdir": "linux-64", + "timestamp": 1677273817065, + "version": "1.4.0" + }, + "python-lmdb-1.4.0-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "OLDAP-2.8", + "license_family": "Other", + "md5": "df18cd2f4c7acb80c8c0417db1767210", + "name": "python-lmdb", + "sha256": "ce2e1f9dd0b5a3201d81206182124dce5f6756c678b23082e91aa6667c7a65de", + "size": 138473, + "subdir": "linux-64", + "timestamp": 1677273851431, + "version": "1.4.0" + }, + "python-louvain-0.11-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "networkx", + "python >=2.7,<2.8.0a0" + ], + "license": "None", + "md5": "0d9c5e4106d04e35bbbac9479ec22968", + "name": "python-louvain", + "sha256": "dac5e72a7cd392e85efcdaaddc058f637926c80f6151a5ac911fc7ec7c09e0b8", + "size": 14753, + "subdir": "linux-64", + "timestamp": 1534680531690, + "version": "0.11" + }, + "python-louvain-0.11-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "networkx", + "python >=3.5,<3.6.0a0" + ], + "license": "None", + "md5": "e0b7a51eba6ffedb06ae0e23db003530", + "name": "python-louvain", + "sha256": "cf9bbbb7854f593fc3b059a4b7f34a6707f5dc5a75a38cdf6116a6eacf41652a", + "size": 14950, + "subdir": "linux-64", + "timestamp": 1534680540532, + "version": "0.11" + }, + "python-louvain-0.11-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "networkx", + "python >=3.6,<3.7.0a0" + ], + "license": "None", + "md5": "6f7c251119919a3d291d5b8200c0826c", + "name": "python-louvain", + "sha256": "af0219d85822819d1357cf9e708e8c531a1524c12bcb8326b975a84de08e5a59", + "size": 14920, + "subdir": "linux-64", + "timestamp": 1534680503010, + "version": "0.11" + }, + "python-louvain-0.11-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "networkx", + "python >=3.7,<3.8.0a0" + ], + "license": "None", + "md5": "fa819a942edcfa465d9e0855c8cffae3", + "name": "python-louvain", + "sha256": "dc4f6d3ad63589317ac91a41af3e418aa59e539c928286d87977cc081638aed8", + "size": 14970, + "subdir": "linux-64", + "timestamp": 1534680545931, + "version": "0.11" + }, + "python-lsp-black-1.2.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "black >=22.3.0", + "python >=3.10,<3.11.0a0", + "python-lsp-server >=1.4.0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3cb6faaa4cc797a8e189ed305928a12a", + "name": "python-lsp-black", + "sha256": "d57984827325cc048136d95eee78ce38226360725275003075de83c57a1a9cdc", + "size": 12330, + "subdir": "linux-64", + "timestamp": 1661852138917, + "version": "1.2.1" + }, + "python-lsp-black-1.2.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "black >=22.3.0", + "python >=3.11,<3.12.0a0", + "python-lsp-server >=1.4.0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e128d59d195200d8a3e54383176acd9", + "name": "python-lsp-black", + "sha256": "f6c067fbea48219852eb2c79e162c3ff2867ae3e83be12323291277b81e00b3f", + "size": 14717, + "subdir": "linux-64", + "timestamp": 1676845574234, + "version": "1.2.1" + }, + "python-lsp-black-1.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "black >=22.3.0", + "python >=3.7,<3.8.0a0", + "python-lsp-server >=1.4.0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "36e0705138d1b86af51321b19c379179", + "name": "python-lsp-black", + "sha256": "b909220cc13653b11e9403818cf57c33edd16891d61e1093b47e0703c2b242e7", + "size": 12240, + "subdir": "linux-64", + "timestamp": 1661852167529, + "version": "1.2.1" + }, + "python-lsp-black-1.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "black >=22.3.0", + "python >=3.8,<3.9.0a0", + "python-lsp-server >=1.4.0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe71decb6437ec23fd3315d4db46ddce", + "name": "python-lsp-black", + "sha256": "a5d9215a8b995ca32fedf0507b5ba0e40dba746a8d70dc9f4c204b9151ba1b4c", + "size": 12299, + "subdir": "linux-64", + "timestamp": 1661852064094, + "version": "1.2.1" + }, + "python-lsp-black-1.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "black >=22.3.0", + "python >=3.9,<3.10.0a0", + "python-lsp-server >=1.4.0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "84c68323823a9b827cd69addffca46c5", + "name": "python-lsp-black", + "sha256": "a7e213ad67615bf31894239c18aa197f0f93518b5de1a9da8f86b9fb22444447", + "size": 12306, + "subdir": "linux-64", + "timestamp": 1661852096891, + "version": "1.2.1" + }, + "python-lsp-server-1.5.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "autopep8 >=1.6.0,<1.7.0", + "flake8 >=4.0.0,<4.1.0", + "jedi >=0.17.2,<0.19.0", + "mccabe >=0.6.0,<0.8.0", + "pluggy >=1.0.0", + "pycodestyle >=2.8.0,<2.9.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.4.0,<2.5.0", + "pylint >=2.5.0", + "python >=3.10,<3.11.0a0", + "python-lsp-jsonrpc >=1.0.0", + "rope >=0.10.5", + "setuptools >=39.0.0", + "ujson >=3.0.0", + "whatthepatch", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd80eb14b261a73bb0ce7c9978ce05c9", + "name": "python-lsp-server", + "sha256": "3dbb9e8147d5368177ff874717169319180423dec9c5a1a0d18d79b13a94a388", + "size": 87815, + "subdir": "linux-64", + "timestamp": 1661813924993, + "version": "1.5.0" + }, + "python-lsp-server-1.5.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "autopep8 >=1.6.0,<1.7.0", + "flake8 >=4.0.0,<4.1.0", + "jedi >=0.17.2,<0.19.0", + "mccabe >=0.6.0,<0.8.0", + "pluggy >=1.0.0", + "pycodestyle >=2.8.0,<2.9.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.4.0,<2.5.0", + "pylint >=2.5.0", + "python >=3.11,<3.12.0a0", + "python-lsp-jsonrpc >=1.0.0", + "rope >=0.10.5", + "setuptools >=39.0.0", + "ujson >=3.0.0", + "whatthepatch", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2bf4c54435463f116b6e88a580e12d09", + "name": "python-lsp-server", + "sha256": "9e2ac15d2f6b35b679a0f064d539ab82a7680a00279b8c80d9035e08f9e2babc", + "size": 116157, + "subdir": "linux-64", + "timestamp": 1676842362907, + "version": "1.5.0" + }, + "python-lsp-server-1.5.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "autopep8 >=1.6.0,<1.7.0", + "flake8 >=4.0.0,<4.1.0", + "jedi >=0.17.2,<0.19.0", + "mccabe >=0.6.0,<0.8.0", + "pluggy >=1.0.0", + "pycodestyle >=2.8.0,<2.9.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.4.0,<2.5.0", + "pylint >=2.5.0", + "python >=3.7,<3.8.0a0", + "python-lsp-jsonrpc >=1.0.0", + "rope >=0.10.5", + "setuptools >=39.0.0", + "ujson >=3.0.0", + "whatthepatch", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90cc8d50294b9951d485af7ed1ef2121", + "name": "python-lsp-server", + "sha256": "5da3047ae2ac404607dbc70dd6294650f4e57b547fdf6031836c1bd72cdb23c3", + "size": 86684, + "subdir": "linux-64", + "timestamp": 1661813881671, + "version": "1.5.0" + }, + "python-lsp-server-1.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "autopep8 >=1.6.0,<1.7.0", + "flake8 >=4.0.0,<4.1.0", + "jedi >=0.17.2,<0.19.0", + "mccabe >=0.6.0,<0.8.0", + "pluggy >=1.0.0", + "pycodestyle >=2.8.0,<2.9.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.4.0,<2.5.0", + "pylint >=2.5.0", + "python >=3.8,<3.9.0a0", + "python-lsp-jsonrpc >=1.0.0", + "rope >=0.10.5", + "setuptools >=39.0.0", + "ujson >=3.0.0", + "whatthepatch", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f371e9fa7f047272359f2afc3b14d10", + "name": "python-lsp-server", + "sha256": "05f4e9f63a585995d457300277964d79c853b02c57d88ce9184470a1772f7be5", + "size": 86892, + "subdir": "linux-64", + "timestamp": 1661813849412, + "version": "1.5.0" + }, + "python-lsp-server-1.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "autopep8 >=1.6.0,<1.7.0", + "flake8 >=4.0.0,<4.1.0", + "jedi >=0.17.2,<0.19.0", + "mccabe >=0.6.0,<0.8.0", + "pluggy >=1.0.0", + "pycodestyle >=2.8.0,<2.9.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.4.0,<2.5.0", + "pylint >=2.5.0", + "python >=3.9,<3.10.0a0", + "python-lsp-jsonrpc >=1.0.0", + "rope >=0.10.5", + "setuptools >=39.0.0", + "ujson >=3.0.0", + "whatthepatch", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6bed0b3faf72e3b43fe9d9a5dea9f4c7", + "name": "python-lsp-server", + "sha256": "143a988b7723e5f1b754025031bdc2a4cae525a8860fc72efedc02fc04f4aebc", + "size": 86871, + "subdir": "linux-64", + "timestamp": 1661813957114, + "version": "1.5.0" + }, + "python-lsp-server-1.7.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "autopep8 >=1.6.0,<1.7.0", + "docstring-to-markdown", + "flake8 >=5.0.0,<7.0.0", + "jedi >=0.17.2,<0.19.0", + "mccabe >=0.7.0,<0.8.0", + "pluggy >=1.0.0", + "pycodestyle 2.10.0.*", + "pydocstyle >=6.3.0,<6.4.0", + "pyflakes >=2.5.0,<3.1.0", + "pylint >=2.5.0,<3.0.0", + "python >=3.10,<3.11.0a0", + "python-lsp-jsonrpc >=1.0.0", + "rope >=1.2.0", + "setuptools >=39.0.0", + "toml", + "ujson >=3.0.0", + "whatthepatch >=1.0.2,<2.0.0", + "yapf <=0.32.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "259af4d10b20ff766a96c7e79bdc8f74", + "name": "python-lsp-server", + "sha256": "72e8964ccceb570180f301428750e072d299249d81f5ec76b499b175420894c8", + "size": 99472, + "subdir": "linux-64", + "timestamp": 1677296853634, + "version": "1.7.1" + }, + "python-lsp-server-1.7.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "autopep8 >=1.6.0,<1.7.0", + "docstring-to-markdown", + "flake8 >=5.0.0,<7.0.0", + "jedi >=0.17.2,<0.19.0", + "mccabe >=0.7.0,<0.8.0", + "pluggy >=1.0.0", + "pycodestyle 2.10.0.*", + "pydocstyle >=6.3.0,<6.4.0", + "pyflakes >=2.5.0,<3.1.0", + "pylint >=2.5.0,<3.0.0", + "python >=3.11,<3.12.0a0", + "python-lsp-jsonrpc >=1.0.0", + "rope >=1.2.0", + "setuptools >=39.0.0", + "toml", + "ujson >=3.0.0", + "whatthepatch >=1.0.2,<2.0.0", + "yapf <=0.32.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0bdaffa89a60cdcf0bcd28f3f4a08d03", + "name": "python-lsp-server", + "sha256": "c3b6fcaf8ebb3b79df449a90d1019264f5ca93ff7811da0aca4b4bd1f4043d06", + "size": 131567, + "subdir": "linux-64", + "timestamp": 1677706546359, + "version": "1.7.1" + }, + "python-lsp-server-1.7.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "autopep8 >=1.6.0,<1.7.0", + "docstring-to-markdown", + "flake8 >=5.0.0,<7.0.0", + "jedi >=0.17.2,<0.19.0", + "mccabe >=0.7.0,<0.8.0", + "pluggy >=1.0.0", + "pycodestyle 2.10.0.*", + "pydocstyle >=6.3.0,<6.4.0", + "pyflakes >=2.5.0,<3.1.0", + "pylint >=2.5.0,<3.0.0", + "python >=3.8,<3.9.0a0", + "python-lsp-jsonrpc >=1.0.0", + "rope >=1.2.0", + "setuptools >=39.0.0", + "toml", + "ujson >=3.0.0", + "whatthepatch >=1.0.2,<2.0.0", + "yapf <=0.32.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef8d603ef0ef8319734516f948c4ede7", + "name": "python-lsp-server", + "sha256": "5a381376f115fa79318095807068382445b434dc1657765d8017f4575ffa90b3", + "size": 98253, + "subdir": "linux-64", + "timestamp": 1677296793266, + "version": "1.7.1" + }, + "python-lsp-server-1.7.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "autopep8 >=1.6.0,<1.7.0", + "docstring-to-markdown", + "flake8 >=5.0.0,<7.0.0", + "jedi >=0.17.2,<0.19.0", + "mccabe >=0.7.0,<0.8.0", + "pluggy >=1.0.0", + "pycodestyle 2.10.0.*", + "pydocstyle >=6.3.0,<6.4.0", + "pyflakes >=2.5.0,<3.1.0", + "pylint >=2.5.0,<3.0.0", + "python >=3.9,<3.10.0a0", + "python-lsp-jsonrpc >=1.0.0", + "rope >=1.2.0", + "setuptools >=39.0.0", + "toml", + "ujson >=3.0.0", + "whatthepatch >=1.0.2,<2.0.0", + "yapf <=0.32.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0bd94a03c4360276539549407070d8d7", + "name": "python-lsp-server", + "sha256": "5106937e1200c3e0c2d90c7bbf3d35ba14d67df8504b8b2e09d351e1cf46a645", + "size": 98236, + "subdir": "linux-64", + "timestamp": 1677296823871, + "version": "1.7.1" + }, + "python-memcached-1.59-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "6d6d21051fbe68c2d055700c9aec9332", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "25d4fd3d6f5e99a6548c8b65830913a1e58ecb47a9d5fc239befe9b6987298de", + "size": 36032, + "subdir": "linux-64", + "timestamp": 1519492008298, + "version": "1.59" + }, + "python-memcached-1.59-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "431d68c947864ea2be276924d2e0d27a", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "fb4d5bd5ec10c518c4423c488a3e556be5f940c0a808d39d85a04a72697456e4", + "size": 37173, + "subdir": "linux-64", + "timestamp": 1640793909123, + "version": "1.59" + }, + "python-memcached-1.59-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "f8ea1754b2dbbef9b69b25b1a2c099b4", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "61e05dbe1805e713be38c1a20a5f0be46245a817f32978e4820903a00b0f94d3", + "size": 45416, + "subdir": "linux-64", + "timestamp": 1676861567375, + "version": "1.59" + }, + "python-memcached-1.59-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "fda788b5d84fada35dbca302c033e977", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "1d1df72c095c8dc3e81fb7a544d52af18be3532605a3540ac5064bb1a260ad85", + "size": 36746, + "subdir": "linux-64", + "timestamp": 1519491984600, + "version": "1.59" + }, + "python-memcached-1.59-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "8241d2902734fc5e31b45bb7a71571c9", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "1703a3a22aa9383d335604032907bf41432bbe9d16c7972e9f4a3e4155b4ead7", + "size": 36757, + "subdir": "linux-64", + "timestamp": 1519492017996, + "version": "1.59" + }, + "python-memcached-1.59-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "7d77c7ce2dc4907c6d4f92dee0a4dc9f", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "73b41b5ec546344a53b5583b4b78b44984e7b1786d8d358fca13846ee36bc93b", + "size": 38164, + "subdir": "linux-64", + "timestamp": 1614172820502, + "version": "1.59" + }, + "python-memcached-1.59-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "9aa03a4505bd5aebe02ef52bcfae7224", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "d442a9ce720ddbe7444ad6f4de6e1e245629a24958caa908f8308d38ce87cf3e", + "size": 36737, + "subdir": "linux-64", + "timestamp": 1530922844348, + "version": "1.59" + }, + "python-memcached-1.59-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "8ed131ae8d31e3601c6756fd343110fe", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "aebaff6af7fd7c2cb0b3bbcd12aad573f32feb0c0066896eb40178c591c0e402", + "size": 38178, + "subdir": "linux-64", + "timestamp": 1614172806987, + "version": "1.59" + }, + "python-memcached-1.59-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "d2557993c4cbd9d513299d15b70ba787", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "7e905e1887e1859b2f292c541f913b9a0f136fffc3d104314a95cd568e09392b", + "size": 37263, + "subdir": "linux-64", + "timestamp": 1574094372838, + "version": "1.59" + }, + "python-memcached-1.59-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "cd37bd6ad43e4860a333b610bfe2db05", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "d7b39e1b274cc5a84fe6d8d867cc4e50bf2da3453a0bc91d05aa298dec86553f", + "size": 38231, + "subdir": "linux-64", + "timestamp": 1614172820124, + "version": "1.59" + }, + "python-memcached-1.59-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "a39dab8539be6c41e6cc3cdec391c246", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "3b68c5b8967a78682685def87503b1426802e6e419d68d36a09aa9c813155d0f", + "size": 38299, + "subdir": "linux-64", + "timestamp": 1614172811184, + "version": "1.59" + }, + "python-ntlm-1.1.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL", + "md5": "2ecb3bea5021f9fb7cc29fba2b3a1d49", + "name": "python-ntlm", + "namespace_in_name": true, + "sha256": "c09211f1f150f0b6b5812bb711e56f1b5a918bd78e730e4389c59480819f86a2", + "size": 42111, + "subdir": "linux-64", + "timestamp": 1540317059729, + "version": "1.1.0" + }, + "python-oauth2-1.1.0-py27h28b3542_1.tar.bz2": { + "build": "py27h28b3542_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a4e464434fe269e71c4809e5d082f6d", + "name": "python-oauth2", + "sha256": "0b256e20e7e48a5198d7889211566e23260b4fdc6a8ca68ba9ef532784d7fc65", + "size": 86969, + "subdir": "linux-64", + "timestamp": 1540510693698, + "version": "1.1.0" + }, + "python-oauth2-1.1.0-py36h28b3542_1.tar.bz2": { + "build": "py36h28b3542_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c6d5fcc105daab51caf935a501b005e", + "name": "python-oauth2", + "sha256": "3b0476a50a350d7731a42bca72cfb9887c5bc1ff682210b512110d7bd95d5a82", + "size": 88612, + "subdir": "linux-64", + "timestamp": 1540510753021, + "version": "1.1.0" + }, + "python-oauth2-1.1.0-py37h28b3542_1.tar.bz2": { + "build": "py37h28b3542_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee950719a090a0071b4665a00ee601fd", + "name": "python-oauth2", + "sha256": "26237e8ddf21792a983d40c6c9cdcbae6053b4fcdac6a2a980478de38e8fb014", + "size": 89137, + "subdir": "linux-64", + "timestamp": 1540510700792, + "version": "1.1.0" + }, + "python-openid-2.2.5-py27_1000.tar.bz2": { + "build": "py27_1000", + "build_number": 1000, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ec0a8a9eab0a78c265185b82f99aa37b", + "name": "python-openid", + "sha256": "a41ebca238cddfe41bc9502d6c565178264a8f9e2cee3c7cc5e8148960634a17", + "size": 175379, + "subdir": "linux-64", + "timestamp": 1579614954702, + "version": "2.2.5" + }, + "python-rapidjson-0.4.3-py35h6bb024c_0.tar.bz2": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "09205ac54b3c4058bb6ade7a04e1cb18", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "b3f85a5fa5be2ce2c3de3cc79153f76484968ef58b26c463ded56211cb0bddf2", + "size": 150464, + "subdir": "linux-64", + "timestamp": 1519470350026, + "version": "0.4.3" + }, + "python-rapidjson-0.4.3-py36h6bb024c_0.tar.bz2": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "32469e5c4c1383a7d2d414c0141d332a", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "dd8c621a5eac42ecb9071b2c4afdbf16ffd0291f14e7a51cfecc473be3a980ab", + "size": 150422, + "subdir": "linux-64", + "timestamp": 1519470335326, + "version": "0.4.3" + }, + "python-rapidjson-0.5.2-py35h6bb024c_0.tar.bz2": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21bfb95caf5411c10946adeae9ce3677", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "0f9e99934712a9b7f1dfd257d883035e01f6cfb1c45711ae409b151967343aa2", + "size": 150990, + "subdir": "linux-64", + "timestamp": 1522790911850, + "version": "0.5.2" + }, + "python-rapidjson-0.5.2-py36h6bb024c_0.tar.bz2": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ed7c99687cf7e947b8609af34fda46bf", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "eaa626be9f6a5f0a96a324d99b34a6973fa53d2c9018a18192a5d11332c69124", + "size": 151031, + "subdir": "linux-64", + "timestamp": 1522790356705, + "version": "0.5.2" + }, + "python-rapidjson-0.6.2-py35h6bb024c_0.tar.bz2": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "91e4185691a604a259fdcace94603163", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "cd2045fe338989d9f82ff7dc2524926e577b505b35895639bf9ed9c556f1ba59", + "size": 150001, + "subdir": "linux-64", + "timestamp": 1529446008729, + "version": "0.6.2" + }, + "python-rapidjson-0.6.2-py36h6bb024c_0.tar.bz2": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f77ebfa911119de6b866f62eb1bba56f", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "0c06fd36b4b535d27818088d95d940c97586997a8389222d3328b9ae5ce13360", + "size": 149952, + "subdir": "linux-64", + "timestamp": 1529445970778, + "version": "0.6.2" + }, + "python-rapidjson-0.6.2-py37h6bb024c_0.tar.bz2": { + "build": "py37h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9c76983f0237fd147de68e45c68a0d5", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "c36cdbb6bfeaa3d776ff5aecbd6558433331d139aff857d82751328c808f9888", + "size": 149979, + "subdir": "linux-64", + "timestamp": 1530922901611, + "version": "0.6.2" + }, + "python-rapidjson-0.6.3-py35he6710b0_0.tar.bz2": { + "build": "py35he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e97951fa3f0dc50ea4e2a6f851f46264", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "32b59d325266a895280b67e22c3b6d608b59a7b1f34f9f39cc46b40b524a4b47", + "size": 179750, + "subdir": "linux-64", + "timestamp": 1535511515075, + "version": "0.6.3" + }, + "python-rapidjson-0.6.3-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b464d2a1930632880a1ec3e53c38850", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "44f7d4c08a8824b5f9d62a60915d2aeb02cc167e597bed5ab2f52d390e2064f0", + "size": 179753, + "subdir": "linux-64", + "timestamp": 1535511482958, + "version": "0.6.3" + }, + "python-rapidjson-0.6.3-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0167e57f313a8c9f7f1ea3b1712b0b32", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "f213e967e46008d08fd1b6a7cafc542341f0254a931988e8733f64e939388764", + "size": 179775, + "subdir": "linux-64", + "timestamp": 1535511587661, + "version": "0.6.3" + }, + "python-rapidjson-0.6.3-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "522692a1a260f08457ba0629cc7da442", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "916d7f951c6ae4ba91ca116765a66ec4acf5c300858ff70f07115212f15df65b", + "size": 189310, + "subdir": "linux-64", + "timestamp": 1573200597231, + "version": "0.6.3" + }, + "python-rapidjson-0.9.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1bf780c461e34ff3d468defaeedb4664", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "cdf1ab886513f3b08e731af550d026df1dc2b2c5044ff4fbd1c6877a000d3991", + "size": 181736, + "subdir": "linux-64", + "timestamp": 1600460017636, + "version": "0.9.1" + }, + "python-rapidjson-0.9.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c3c376e7ad11b499dff2bd7ed979171", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "a0afaef004bdf04cec4c8a154975c26d5a18ba2ce0a3dce5786f610c279c3083", + "size": 181779, + "subdir": "linux-64", + "timestamp": 1600460000785, + "version": "0.9.1" + }, + "python-rapidjson-0.9.1-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b1396b9ff646f3e435f3e9098000701", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "769fd19343dfa980baf4e8243def6105127d4587cf671e6704c3b91d091e79ae", + "size": 183045, + "subdir": "linux-64", + "timestamp": 1600460009469, + "version": "0.9.1" + }, + "python-rapidjson-0.9.4-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cfe4ad4378748d3287dd1499c2bbcb24", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "5167ca5cdf7fc050266cf9567e9a0c6f5c3d91b276b5270fc98fd4c5d691b8dc", + "size": 181711, + "subdir": "linux-64", + "timestamp": 1606518291523, + "version": "0.9.4" + }, + "python-rapidjson-0.9.4-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c2cde0f6ad43c4a399355e1883f1aee", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "8d7c8d0842d852668a1c235a7925dbd8f7fed6025c704a55d91586562f41f558", + "size": 181788, + "subdir": "linux-64", + "timestamp": 1606518282119, + "version": "0.9.4" + }, + "python-rapidjson-0.9.4-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c451e23fdfaf29514c47309ed267f7b", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "a12f5acf3394f0d0d22219be96c110cf5161d97a72ff1e20cbe62ccd140b7c99", + "size": 184457, + "subdir": "linux-64", + "timestamp": 1606518331986, + "version": "0.9.4" + }, + "python-rapidjson-0.9.4-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5475f9508e9ef16f96ddafcf4c225a39", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "5ee815150ad9802609dc400563380e57e5cf80e60d05610f7bacc201f1737d57", + "size": 182467, + "subdir": "linux-64", + "timestamp": 1606518334832, + "version": "0.9.4" + }, + "python-rapidjson-1.0-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "734cd349bc06eeccca71ea10c3bffab6", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "1284c4d1a781c407c2a28beacb1f9da91db1d6824933371dd2b8d103c958aa1f", + "size": 185922, + "subdir": "linux-64", + "timestamp": 1607972583600, + "version": "1.0" + }, + "python-rapidjson-1.0-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ac58a359d1852b7ccadf3d248b75eee3", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "334533855c2ea3595d1bc95c5118b5ed49e30ff797390d43cd6dcf9695715691", + "size": 185961, + "subdir": "linux-64", + "timestamp": 1607972614192, + "version": "1.0" + }, + "python-rapidjson-1.0-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a48e3b2f4907056974fe78d704d98194", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "8af269f566a19189baea16059c361c51faf27a0cef8a1a57d1cb0891db5af206", + "size": 187260, + "subdir": "linux-64", + "timestamp": 1607972176217, + "version": "1.0" + }, + "python-rapidjson-1.0-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5c091e4b48a6ae75157481117789b3f", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "def13bd4cc486f679d53f525791aaa3594991a5bcc174143f6d3fccc86ae8a61", + "size": 184755, + "subdir": "linux-64", + "timestamp": 1607972609915, + "version": "1.0" + }, + "python-rapidjson-1.4-py36h295c915_0.tar.bz2": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f780674881f8a36fec73362f6d0dcbf", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "378d70e78fff67559de64dd947168424a37a0fe5504a4060214bb73c27383b72", + "size": 186619, + "subdir": "linux-64", + "timestamp": 1626241375304, + "version": "1.4" + }, + "python-rapidjson-1.4-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4bd6ba1ccc1d9525f675bd823373b74d", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "5d75fdd968ccb4757f34fee7276ce473bc809a9deb9a61bbfe09fd8fb399210b", + "size": 186721, + "subdir": "linux-64", + "timestamp": 1626284223383, + "version": "1.4" + }, + "python-rapidjson-1.4-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "61c770adaf0e2701e6c10c277b5dd574", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "f226f20bbf87820c6956b5da03714aa39ccbad2667a8e98b01ac4613e196849c", + "size": 186459, + "subdir": "linux-64", + "timestamp": 1626291205489, + "version": "1.4" + }, + "python-rapidjson-1.4-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d350611c9fdd7dc9f463b23b1377ca6f", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "ca0d083ce47e9df114bfe8d6bde1d69c51f6d227f3116e68821693c4732a7025", + "size": 185223, + "subdir": "linux-64", + "timestamp": 1626291332326, + "version": "1.4" + }, + "python-rapidjson-1.5-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef975f4e15c584a2ee3386e47b474c0c", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "65eaab31b302f3df334c2a84ec5c49bcbab4ab9d22d9224df541a023c0e9d40a", + "size": 1084119, + "subdir": "linux-64", + "timestamp": 1640793946792, + "version": "1.5" + }, + "python-rapidjson-1.5-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60226540511752d685a42676d4de527f", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "1a498ee0556542793d5770721fba4f199260c23e004f16c6b327be6dee9e74fc", + "size": 197104, + "subdir": "linux-64", + "timestamp": 1676861598862, + "version": "1.5" + }, + "python-rapidjson-1.5-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77c3eed81041d91470160a3601b3f6b4", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "efc0e10d96893ac381aeb9e101e51bf60c90358c2d5ab2a8fc642b580acd6626", + "size": 186337, + "subdir": "linux-64", + "timestamp": 1639132380745, + "version": "1.5" + }, + "python-rapidjson-1.5-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3b8eace0f5a0b2c4e86f2072e5b41d0", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "8e792ef7d8006759529c1d063e0df254c77f6e356b62f12a7d5bbf7b7862ac17", + "size": 187993, + "subdir": "linux-64", + "timestamp": 1639132384476, + "version": "1.5" + }, + "python-rapidjson-1.5-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8254aca788dd6be645a63b210d462f4", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "233cb1632f1d1cf36809f7f0b42d3c4f0346f47ee0a109ef851f7ea8f38cdf35", + "size": 184899, + "subdir": "linux-64", + "timestamp": 1639132383679, + "version": "1.5" + }, + "python-regr-testsuite-3.9.1-h06a4308_2.tar.bz2": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [], + "license": "Python-2.0", + "md5": "be7f34bafed9975bf7f73de50ebe6e5e", + "name": "python-regr-testsuite", + "sha256": "9afe62bdb435311447c9588d0b878540f53b4d48e44e1e365515a774c465415d", + "size": 7599766, + "subdir": "linux-64", + "timestamp": 1607697801769, + "version": "3.9.1" + }, + "python-regr-testsuite-3.9.11-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "34b7eaae44f4567cde2d0b3b5fc18812", + "name": "python-regr-testsuite", + "sha256": "86c242b613175b3a01ab4f66bf7934ee0c1706803d577d6225b66fe578bf9e43", + "size": 7615498, + "subdir": "linux-64", + "timestamp": 1648462921511, + "version": "3.9.11" + }, + "python-regr-testsuite-3.9.11-h06a4308_2.tar.bz2": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "aa4818b8ab05796d69c2c4980bbb0367", + "name": "python-regr-testsuite", + "sha256": "a2e5dca3bdf25fb6f69a84cc702c9ebc2eba1867d59d52b75e1f608c50aa5b20", + "size": 7605494, + "subdir": "linux-64", + "timestamp": 1648581594295, + "version": "3.9.11" + }, + "python-regr-testsuite-3.9.12-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "c7ee4ab81f0b572c200a4eb65ab58555", + "name": "python-regr-testsuite", + "sha256": "5932f3a98532ad01d4c38973e9562f401cdf56cd7676d76f10b84e26d59923f4", + "size": 7672401, + "subdir": "linux-64", + "timestamp": 1649142504571, + "version": "3.9.12" + }, + "python-regr-testsuite-3.9.12-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "e6e609f395bd6f9059369c298a8a69aa", + "name": "python-regr-testsuite", + "sha256": "a3d270bbdcf1ba2f3207fa9d98457e068c373d21c729687c41deac4a12949b81", + "size": 7629974, + "subdir": "linux-64", + "timestamp": 1654084228189, + "version": "3.9.12" + }, + "python-regr-testsuite-3.9.13-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "b8616768ffac98ba7e8a904aaae88be3", + "name": "python-regr-testsuite", + "sha256": "f2be111ab01ddb6f3fdac198dd375a61aab361f2b65072e84ed6dfc450d191bd", + "size": 7677494, + "subdir": "linux-64", + "timestamp": 1661470728854, + "version": "3.9.13" + }, + "python-regr-testsuite-3.9.13-h06a4308_2.tar.bz2": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "0d3d0ed767534ecf378f42cfe3579d4a", + "name": "python-regr-testsuite", + "sha256": "55eb3d28a414b734921c7240f0809539e53c28b6cc954c3a1e83f74534b83ed2", + "size": 7681218, + "subdir": "linux-64", + "timestamp": 1665696414530, + "version": "3.9.13" + }, + "python-regr-testsuite-3.9.15-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "b6b5f7073da0d0b58dc427171603baa6", + "name": "python-regr-testsuite", + "sha256": "34b861055cefe81fc89a46b24226a472599d77bb55bbb9eb8aafb444f099defe", + "size": 7676497, + "subdir": "linux-64", + "timestamp": 1667579149388, + "version": "3.9.15" + }, + "python-regr-testsuite-3.9.15-h06a4308_2.tar.bz2": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "352f0909e421a00223d55045c7da68b4", + "name": "python-regr-testsuite", + "sha256": "0292b4b11c279a9903dd2d8b926b3c2a41e6652a845f08b2338e3666c3a12edb", + "size": 7697426, + "subdir": "linux-64", + "timestamp": 1669301010492, + "version": "3.9.15" + }, + "python-regr-testsuite-3.9.16-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "0a2e688e53ec4161e3387e21d6aa1ec0", + "name": "python-regr-testsuite", + "sha256": "0a07987bf07ac47503944e8935e993106e8c05f473f6b68928aa4053eadb073f", + "size": 7691735, + "subdir": "linux-64", + "timestamp": 1673453882123, + "version": "3.9.16" + }, + "python-regr-testsuite-3.9.16-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "cc734a78dfe7a4dc8938fa3993ee1ba0", + "name": "python-regr-testsuite", + "sha256": "158984e20f7d07e59ff0109b986232abf7acbd385af737deab0a5a1e194c3026", + "size": 7689276, + "subdir": "linux-64", + "timestamp": 1677695652272, + "version": "3.9.16" + }, + "python-regr-testsuite-3.9.16-h06a4308_2.tar.bz2": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "e8e01f20aa38fe85c8b0e959ff1b8dda", + "name": "python-regr-testsuite", + "sha256": "0fce15511326f0b320070d42c0dfb5a2a58027e69537c96905fcdbb0e2e36990", + "size": 7688176, + "subdir": "linux-64", + "timestamp": 1678284700225, + "version": "3.9.16" + }, + "python-regr-testsuite-3.9.2-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "Python-2.0", + "md5": "90011e0e2c332657333abe2bfd64dbcc", + "name": "python-regr-testsuite", + "sha256": "15add1d338015b3ab2f7b1fb9bc07c2e704f1e06284d74952f67ef40e5f77f09", + "size": 7613411, + "subdir": "linux-64", + "timestamp": 1614802551636, + "version": "3.9.2" + }, + "python-regr-testsuite-3.9.4-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "Python-2.0", + "md5": "97d87629569cd76386c9a113b0bcb0d9", + "name": "python-regr-testsuite", + "sha256": "913e140b57c30df27b88913fc874378f5ec4cf78fb325a2609ba6c6fc4f17cea", + "size": 7630518, + "subdir": "linux-64", + "timestamp": 1617986855753, + "version": "3.9.4" + }, + "python-regr-testsuite-3.9.5-h06a4308_3.tar.bz2": { + "build": "h06a4308_3", + "build_number": 3, + "depends": [], + "license": "Python-2.0", + "md5": "0bdd231a4b28e49b4ca4231b45bf217e", + "name": "python-regr-testsuite", + "sha256": "d5b017b677a9f4abce098fdbcbe5381070ca34ff6f2a75dd0c33404bc98f85f7", + "size": 7630054, + "subdir": "linux-64", + "timestamp": 1621367274458, + "version": "3.9.5" + }, + "python-regr-testsuite-3.9.5-h06a4308_4.tar.bz2": { + "build": "h06a4308_4", + "build_number": 4, + "depends": [], + "license": "Python-2.0", + "md5": "cad1f9a9d331a3cc8b395bd760d734f6", + "name": "python-regr-testsuite", + "sha256": "09d174afa72911ab225caaa3c757b3d8ab854b5da7dbb86afbe18cc8cb66a13c", + "size": 7541829, + "subdir": "linux-64", + "timestamp": 1622828276396, + "version": "3.9.5" + }, + "python-regr-testsuite-3.9.6-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "Python-2.0", + "md5": "0215816715ae5f882d0063db5f08706d", + "name": "python-regr-testsuite", + "sha256": "8b11ea22fef6c0375e3520d265c0a6d3650bf93d4e09ec98f6f8c110b52d4c94", + "size": 7632148, + "subdir": "linux-64", + "timestamp": 1627663696372, + "version": "3.9.6" + }, + "python-regr-testsuite-3.9.6-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "Python-2.0", + "md5": "ec228f0687ec00f97a967c139b2f0ea5", + "name": "python-regr-testsuite", + "sha256": "7686352cd85c7883462929b7e15e89e45dc41d26e86ec2096125839c33f15a42", + "size": 7634132, + "subdir": "linux-64", + "timestamp": 1629316191355, + "version": "3.9.6" + }, + "python-regr-testsuite-3.9.7-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "Python-2.0", + "md5": "fbdf9a892b7cc38ecfdbca45964e0f7d", + "name": "python-regr-testsuite", + "sha256": "e3e24ddc1b8592c877d98fdd4982620abc71c71fe16a53346f15c6273be21e1b", + "size": 7660462, + "subdir": "linux-64", + "timestamp": 1631798589983, + "version": "3.9.7" + }, + "python-slugify-1.2.4-py27h51716b4_1.tar.bz2": { + "build": "py27h51716b4_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6103a4d4828a24177f047d89c69a0bcd", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "5ddf90872839dc765fbc76ffb070bb4a586601413cc0e8c8c523e5510d529250", + "size": 9175, + "subdir": "linux-64", + "timestamp": 1508622624184, + "version": "1.2.4" + }, + "python-slugify-1.2.4-py35hcb49adb_1.tar.bz2": { + "build": "py35hcb49adb_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc07592049b1412d60943b9bc8c04a8d", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "49aa8a457103d9a7c609670248e67adbee400589393609a4aa3fbbc3f1395e5e", + "size": 9333, + "subdir": "linux-64", + "timestamp": 1508622636926, + "version": "1.2.4" + }, + "python-slugify-1.2.4-py36hc9c72ca_1.tar.bz2": { + "build": "py36hc9c72ca_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08538d51c915545f0b7741cb9d281fc8", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "15342bb8437db216d26732537c6b7708a65c35d8e16b12866e500855845d2957", + "size": 9349, + "subdir": "linux-64", + "timestamp": 1508622643571, + "version": "1.2.4" + }, + "python-slugify-1.2.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e8bc39328152f396bac212dec812441", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "19507153279fcc19a51b12726555af8d74898345ce4417496d9229f4b1cd21aa", + "size": 9117, + "subdir": "linux-64", + "timestamp": 1522084408325, + "version": "1.2.5" + }, + "python-slugify-1.2.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "081dff6618205df8bd3e110975738ef7", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "befba135bdb615c84c884ed0d07c0374fbdfc18be93957a558c096024682b6ca", + "size": 9250, + "subdir": "linux-64", + "timestamp": 1522084459601, + "version": "1.2.5" + }, + "python-slugify-1.2.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6bd998aab8feca6f710ca149758de63", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "750b254cd27e4dc41399c4527260c63db61aa9f5e82fea7c329cd7e4aee73c35", + "size": 9243, + "subdir": "linux-64", + "timestamp": 1522084321742, + "version": "1.2.5" + }, + "python-slugify-1.2.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1576891f439905ba036746df79e9bb3d", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "df2f78522ffcc7f6ec2e8d56cff5a978e2500d05f960337acd995e27204274ae", + "size": 9120, + "subdir": "linux-64", + "timestamp": 1530735609690, + "version": "1.2.5" + }, + "python-slugify-1.2.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef7778864466cd4be9237fa2eddfda79", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "8279594240919c74eaa14104fa60cc43b2697b03a22799c8146a43fdb17bab8f", + "size": 9846, + "subdir": "linux-64", + "timestamp": 1536264300956, + "version": "1.2.6" + }, + "python-slugify-1.2.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2bd7b266917f5750827a328a3bc1b536", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "9b0c5edff4d959fe023e5137406e41f67eeb9fe9a9bb29a73ac229139278fb78", + "size": 10020, + "subdir": "linux-64", + "timestamp": 1536264301132, + "version": "1.2.6" + }, + "python-slugify-1.2.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "884df93ee12f7978873f4c0a57b4cae6", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "68c888ebd778541fb785e89ba9084c128d2e6a4e644d2b9b862770c15be6e77e", + "size": 10012, + "subdir": "linux-64", + "timestamp": 1536264270140, + "version": "1.2.6" + }, + "python-slugify-1.2.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e5cd4d3c161ff6ca2f84333e264dc96", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "949e36407805a5bb0fc2bdf52412c8b7551a0f6cd6593b84ba715254fb521423", + "size": 10051, + "subdir": "linux-64", + "timestamp": 1536264339163, + "version": "1.2.6" + }, + "python-slugify-2.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba21648d05bfe878b08040860151e271", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "f78e6e808cdb6d27e2524bcfe210bfc3ce52320a522d613a4236a642e457a4c0", + "size": 13282, + "subdir": "linux-64", + "timestamp": 1547487015759, + "version": "2.0.1" + }, + "python-slugify-2.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a4a9f240153670886a47121226aac457", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "5b043414d106a66b34b44ad24b1fa40fdac4b726f69896271d4922108f78093d", + "size": 13493, + "subdir": "linux-64", + "timestamp": 1547487039979, + "version": "2.0.1" + }, + "python-slugify-2.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0245eabad299d46d7483a9abd7f36fcf", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "b71fd807f276975144bd60af72fe71b7a1ff6845b1ed70328cb3f8ebdff3653d", + "size": 13488, + "subdir": "linux-64", + "timestamp": 1547487037877, + "version": "2.0.1" + }, + "python-snappy-0.5.2-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c610759b1c6110845bc0ab0b06423340", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "c50214ce42fbbcfc19e77a89ca828f23aa6ddedb81413bd4fc53d13cab1a1ea7", + "size": 28180, + "subdir": "linux-64", + "timestamp": 1522882012151, + "version": "0.5.2" + }, + "python-snappy-0.5.2-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "145dc1f96d21707138c8def5141d7c04", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "490318b1e8188a5f0183758fbf0965dfbf3d37434dc714839144e49f181028a7", + "size": 28707, + "subdir": "linux-64", + "timestamp": 1522882123697, + "version": "0.5.2" + }, + "python-snappy-0.5.2-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e9033f895bda998441c50b1246ee7471", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "a49758c0abd15f81e3a4ba16c3fff4959e409e3543c764ea7fe774f858bb73e7", + "size": 28590, + "subdir": "linux-64", + "timestamp": 1522882123337, + "version": "0.5.2" + }, + "python-snappy-0.5.2-py37hf484d3e_0.tar.bz2": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a1c84f397a0f5ec4183dfc83f90457d3", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "3c72ce5b9925155c96e45ef8c01bfd346204673a4ba0056a1707f73c3e95432c", + "size": 28607, + "subdir": "linux-64", + "timestamp": 1530922939354, + "version": "0.5.2" + }, + "python-snappy-0.5.3-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "02bb1c604e5517f05085e84ab27d714f", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "7eff2b664bd5805f357bcc5c7a67ad068e8de87d1a690d88495bb0461bc7e5ec", + "size": 28626, + "subdir": "linux-64", + "timestamp": 1535508140854, + "version": "0.5.3" + }, + "python-snappy-0.5.3-py35he6710b0_0.tar.bz2": { + "build": "py35he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0bfb6495646edbebde878d055cfd6873", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "03b6f0d38f58fca38fe71845b6e9dfc6790cc657dd1446728fac241fd60719b3", + "size": 29146, + "subdir": "linux-64", + "timestamp": 1535508168582, + "version": "0.5.3" + }, + "python-snappy-0.5.3-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "57191dfe3cb9835005e4a08f4370535d", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "015d22f4f9c3a02ee9ae11da1c566a1fe1122286b7f891d5a920a459a9e8b0bc", + "size": 29135, + "subdir": "linux-64", + "timestamp": 1535508135728, + "version": "0.5.3" + }, + "python-snappy-0.5.3-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fe2bff55950403ab1f7abea67179460d", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "466361270d52cfa7b9b193c5615772da19f24f18c18640c5fc663e6b713263b0", + "size": 29131, + "subdir": "linux-64", + "timestamp": 1535508162045, + "version": "0.5.3" + }, + "python-snappy-0.5.4-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "93146858a6e613811dff988151828dda", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "88525f817d7eff9c6dda3e1b32d8901469794b6065e7f94654b586fc8d335a58", + "size": 32288, + "subdir": "linux-64", + "timestamp": 1556117556068, + "version": "0.5.4" + }, + "python-snappy-0.5.4-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "63684bf6edd8d495590d9957cd2a9377", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "3a73ab2a80580b877bc2fa94758a1b3e801d1b108cab968bcac33a1b9052bbeb", + "size": 32780, + "subdir": "linux-64", + "timestamp": 1556117600039, + "version": "0.5.4" + }, + "python-snappy-0.5.4-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a9e3238162108c618738e6a7bcc62451", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "09b5847bc40bd5302016def6342ad61a6d8fd9dd550eecf1d2d798bd1a0476cc", + "size": 32830, + "subdir": "linux-64", + "timestamp": 1556117551549, + "version": "0.5.4" + }, + "python-snappy-0.5.4-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "817eb906893de37dc32d75bfb99bd605", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "e5b008dc40491d2c95b7f575c83e1ea403dbc315eed7281b2a58e60d304de30a", + "size": 36736, + "subdir": "linux-64", + "timestamp": 1573200621110, + "version": "0.5.4" + }, + "python-snappy-0.6.0-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ec8cde9dce5168a11c8b121eb27f4726", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "4906ef70e2e8e0c95214ec60937a13a76ca7b927603faf7c9189470d0f741478", + "size": 51021, + "subdir": "linux-64", + "timestamp": 1640793972833, + "version": "0.6.0" + }, + "python-snappy-0.6.0-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4b8d0c8b03f4452ceff8243b9c79aca1", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "c1ae275c2a0e4877a46e210a213bf6d732b510f23a0e485e9d477be100603000", + "size": 31640, + "subdir": "linux-64", + "timestamp": 1610134379524, + "version": "0.6.0" + }, + "python-snappy-0.6.0-py36h2531618_3.tar.bz2": { + "build": "py36h2531618_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1f0e3bbb5fa47665a0833b3053533a3", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "3a8e434505f5211071aa85331ba13caabfa7a0864fe8fae93c2196eaee02b494", + "size": 31644, + "subdir": "linux-64", + "timestamp": 1610133406468, + "version": "0.6.0" + }, + "python-snappy-0.6.0-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ad7cb3ce016563df3efc5612a5c683f8", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "70b252ff53227a2e67d36a226342e5a94a3c09f6e9ba249d25821bbbde87dbf3", + "size": 31683, + "subdir": "linux-64", + "timestamp": 1610134378270, + "version": "0.6.0" + }, + "python-snappy-0.6.0-py37h2531618_3.tar.bz2": { + "build": "py37h2531618_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8874fabf8b37f7053f3e96f3eee7c2c5", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "bc0fcf67bd0d1b7214bbea1b723eedf66b931b87d3628d9330913fa42eacf627", + "size": 31621, + "subdir": "linux-64", + "timestamp": 1610133399147, + "version": "0.6.0" + }, + "python-snappy-0.6.0-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e97533522606972bdab0a5fe5af3951", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "27a6cb4ace50c6169ea3d619c27164b82dcc51c06b40426bca094ad5194d4ac9", + "size": 31757, + "subdir": "linux-64", + "timestamp": 1610134394930, + "version": "0.6.0" + }, + "python-snappy-0.6.0-py38h2531618_3.tar.bz2": { + "build": "py38h2531618_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cef2bd838aa1fbf4d3c5ce5e12d44017", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "90a44a82fedb1f674842640f3bcbddf6c6b8656f54a4dd1a5514a6f21222837b", + "size": 31760, + "subdir": "linux-64", + "timestamp": 1610133362748, + "version": "0.6.0" + }, + "python-snappy-0.6.0-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "619565a8465d528df3583af0e4598c0c", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "501af8a907189e4a8083ebc0777ec6393ee45b7b3a15711b9a651c432ce0326a", + "size": 31802, + "subdir": "linux-64", + "timestamp": 1610134359111, + "version": "0.6.0" + }, + "python-snappy-0.6.0-py39h2531618_3.tar.bz2": { + "build": "py39h2531618_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "95ef4ec206d097ce7e12f82779c58ce0", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "262e568ec50e23aa7187586da450d427e36f9abd0ddfc25b6574602d835366fe", + "size": 31795, + "subdir": "linux-64", + "timestamp": 1610133082486, + "version": "0.6.0" + }, + "python-snappy-0.6.1-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "snappy >=1.1.9,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7f5b4cc5c57e4f4033265333739c0790", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "2f171053aca8ea83237e46813228d878c89ce2f90ea1b1e7124a99cca9ecf343", + "size": 31806, + "subdir": "linux-64", + "timestamp": 1670944042197, + "version": "0.6.1" + }, + "python-snappy-0.6.1-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "snappy >=1.1.9,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ef7c3d6a2becca7997b00e1ff9444dbb", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "68ecfb1ece016cb4610ddc746022ba892d30efbe12ec0858c605ca18c363098d", + "size": 36679, + "subdir": "linux-64", + "timestamp": 1676842382142, + "version": "0.6.1" + }, + "python-snappy-0.6.1-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.9,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "05df60ccffaae762e466390dcb563617", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "ff0479277cad41c2b089b6ab6a68f1cebef83950f56f64cff310a1fa42b01371", + "size": 31644, + "subdir": "linux-64", + "timestamp": 1670944012549, + "version": "0.6.1" + }, + "python-snappy-0.6.1-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.9,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e446ea0658eae84604ad98a55baf195d", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "03ce88dea3ec4e2bf79feb1346d21bf9a67a643c7c8819cd1ec4ca49815a4e69", + "size": 31654, + "subdir": "linux-64", + "timestamp": 1670943981941, + "version": "0.6.1" + }, + "python-snappy-0.6.1-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.9,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "93d161be97c4833ffa0a66ad70ac9b14", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "9468762d0a40dbd735906fcc8c0f25fd1961f25bb0bc6bc2f33739d2e35c6c71", + "size": 31661, + "subdir": "linux-64", + "timestamp": 1670943952283, + "version": "0.6.1" + }, + "python-socketio-1.8.3-py27hb405ee9_0.tar.bz2": { + "build": "py27hb405ee9_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-engineio >=1.2.1", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "240fea95e1783aa93fe71c016248b16e", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "8443cddbfeff49de5cc048204217742452b5a2d19bd7a5398ee955cc6d52c0e0", + "size": 34589, + "subdir": "linux-64", + "timestamp": 1512038764476, + "version": "1.8.3" + }, + "python-socketio-1.8.3-py35h0598352_0.tar.bz2": { + "build": "py35h0598352_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-engineio >=1.2.1", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be18832894b0e966d97038b00891797b", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "a12aa4f6f0fec120c2d8bae8caab0c399587a777ae76eb9e2373a86d8845c1de", + "size": 39222, + "subdir": "linux-64", + "timestamp": 1512038770718, + "version": "1.8.3" + }, + "python-socketio-1.8.3-py36hc4454f7_0.tar.bz2": { + "build": "py36hc4454f7_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-engineio >=1.2.1", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "06fa5f97fb972a019700479c09601b34", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "b0dc1082147ddf3832e58bdfe87f9053f9eabd2750a6833c9644098f86ba849c", + "size": 39057, + "subdir": "linux-64", + "timestamp": 1512038777288, + "version": "1.8.3" + }, + "python-socketio-1.9.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-engineio >=1.2.1", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a5055f467687496be616734cc67ddab5", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "2df3e5f7b6eb2c13476cff6e6b730cd3eedeb1b1283dcb9f543431ceaa96c1a9", + "size": 34996, + "subdir": "linux-64", + "timestamp": 1522084613208, + "version": "1.9.0" + }, + "python-socketio-1.9.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-engineio >=1.2.1", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff8daa0694d902f18c92ff778d3d18dc", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "d93a6d4efa145008025fa077b161cb4731a2ba70050af39509ef773380d2439b", + "size": 39786, + "subdir": "linux-64", + "timestamp": 1522084623143, + "version": "1.9.0" + }, + "python-socketio-1.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-engineio >=1.2.1", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e1c44bbb6285db23e4dc31e4ddacedbb", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "4558f9f914a41695f8da6eecb4b8bd1b113f999b873714781a3824e0ffb071e5", + "size": 39680, + "subdir": "linux-64", + "timestamp": 1522084555867, + "version": "1.9.0" + }, + "python-socketio-1.9.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-engineio >=1.2.1", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "24ae2110c1cb4bb25df2fa09fa7fc925", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "f25697e99cb7cc70c6a1b0ce8c1ed9903d8933e6de3bf7d01ba3a9f1d498e688", + "size": 39574, + "subdir": "linux-64", + "timestamp": 1530877540139, + "version": "1.9.0" + }, + "python-socketio-2.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-engineio >=2.2.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aeeb92d0d82a5e45ce52fb9364be4669", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "df39e63a3add14d22bc43888438b611bd70557eca5c017f8a1f1aaa486b14f7f", + "size": 35133, + "subdir": "linux-64", + "timestamp": 1535510951176, + "version": "2.0.0" + }, + "python-socketio-2.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-engineio >=2.2.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c754b6acc71c06ec19e2469cf902ca98", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "6d070c1502f1acf660b3d13ce740c9f30ad6972c2d6cc10a2072b12e374c8040", + "size": 39965, + "subdir": "linux-64", + "timestamp": 1535510978416, + "version": "2.0.0" + }, + "python-socketio-2.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-engineio >=2.2.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12ebf3871030cafb49f2bfc23fcc3e3d", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "360c78492e50c360f69230dde49035cb1df2415a1a328b7c9f6c78d5ea09ac61", + "size": 39798, + "subdir": "linux-64", + "timestamp": 1535510845940, + "version": "2.0.0" + }, + "python-socketio-2.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-engineio >=2.2.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d4fc0e34683cda4ecffb0ef769cb8de", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "7987c842bd4851fbef0cebc77a7ae52faf104a5abb4c863f731f39425175688d", + "size": 39863, + "subdir": "linux-64", + "timestamp": 1535510959150, + "version": "2.0.0" + }, + "python-socketio-2.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-engineio >=3.0.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd0170969d7f7cb12483c27f04c7090a", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "fe5c63be262825a28895017b71b4d68cad8091e1006bc85192808ea92d3a3951", + "size": 36487, + "subdir": "linux-64", + "timestamp": 1545166822178, + "version": "2.1.2" + }, + "python-socketio-2.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-engineio >=3.0.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f29af2464127e490d102692311e54912", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "b143eb70ddcebc4949967a1af775a1f8fb85d1bfedd7cd0feef892842d36ec89", + "size": 41119, + "subdir": "linux-64", + "timestamp": 1545166857603, + "version": "2.1.2" + }, + "python-socketio-2.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-engineio >=3.0.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2542166d69120f050273db13e7490cb", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "1e5ca7fcf5059f82fdf2682e5059ad9d99147676bb6a8f690835d21da57fc31d", + "size": 41203, + "subdir": "linux-64", + "timestamp": 1545166832095, + "version": "2.1.2" + }, + "python-socketio-3.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-engineio >=3.0.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b064bc879dbbd431b7920b4e4528824", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "99d1d8ff059d7b96b91918b008d689dd6e224f27bdf2f351b40863aef20ce34f", + "size": 45174, + "subdir": "linux-64", + "timestamp": 1550355787625, + "version": "3.1.2" + }, + "python-socketio-3.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-engineio >=3.0.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d59565046d2fa5d26e38b0129ff1517", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "070e913b837a65d89d7706159dc60275222a2b4a905c17306309226c200c52e8", + "size": 52088, + "subdir": "linux-64", + "timestamp": 1550355759248, + "version": "3.1.2" + }, + "python-socketio-3.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-engineio >=3.0.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6e7dbab7f6668601d02556c3ae5f772", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "a177cac446b28af96c1cf1a540de5186f1901315a9b3b89943bc8787a7020b0c", + "size": 52245, + "subdir": "linux-64", + "timestamp": 1550355711083, + "version": "3.1.2" + }, + "python-utils-2.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d5c4afabcf9ee4edf3984cbdb32a8069", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "599b4deabddc87f6edd88bfbbb8bdf0fabe8d7d212840832850ce125507a2d44", + "size": 18198, + "subdir": "linux-64", + "timestamp": 1519674036340, + "version": "2.3.0" + }, + "python-utils-2.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7c342cca9054024331871fc24a7036ca", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "a7fa27d964b680167899b975ba42b6a088c2eb0cb9a050d6d5d89d4cbeb48494", + "size": 18455, + "subdir": "linux-64", + "timestamp": 1519674131624, + "version": "2.3.0" + }, + "python-utils-2.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6bfd26ede9c3c89371529b8aa1b6971a", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "0d25f36da370775b3c6a929458cb5b46e31ae8e2ddac3db6d7fc14d04cb41b80", + "size": 18326, + "subdir": "linux-64", + "timestamp": 1519674213034, + "version": "2.3.0" + }, + "python-utils-2.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cdc28c036f744cdbc380a2fbddb8087b", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "339c178db50d5ea116ebfb320174a6940363aa4aa5ea7d98e675006123646159", + "size": 18258, + "subdir": "linux-64", + "timestamp": 1530906136002, + "version": "2.3.0" + }, + "python-utils-2.3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5c725aa1aa4b6841a6fdfaa2b2b4191e", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "a59ecab9edfa2b4906de2b142ccedd577660e11991aeff45a1c2f7355ea018c0", + "size": 18826, + "subdir": "linux-64", + "timestamp": 1574094393986, + "version": "2.3.0" + }, + "python-utils-2.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb4041748796318cce8aa637a80768c7", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "58a4f3da975d704e4c4e9bc51b70f912dad4640c9fcacc4e8f2d7cbda19b2965", + "size": 19439, + "subdir": "linux-64", + "timestamp": 1600460189741, + "version": "2.4.0" + }, + "python-utils-2.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "974a3f7c6bba161d732a5c1f134608ea", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "13d4ffffedc6ddbceb3de5ee22496030f67a950c18f1e871ce4e362460700b09", + "size": 19412, + "subdir": "linux-64", + "timestamp": 1600460175295, + "version": "2.4.0" + }, + "python-utils-2.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "44d0a340a1ccbd383dfeebfea411f4e3", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "5aa6a867eabd439590a69778d8bc22e92f5e1bb3862700fd99708b9b3b250db2", + "size": 19445, + "subdir": "linux-64", + "timestamp": 1600460182288, + "version": "2.4.0" + }, + "python-utils-2.5.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ab6f9c8091ed565d496b68a08d5708a4", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "ec3d9a88b08ba9bd858121915147e13f418b1c699ca4c8967553e3d23d9717db", + "size": 20476, + "subdir": "linux-64", + "timestamp": 1610739125263, + "version": "2.5.1" + }, + "python-utils-2.5.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f9a4cd83ad081a5d0f9ef3e7d571f813", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "0f28d4e449e0b37269ff37a50864f3bfb82b1dfa6d6741b14f242717065e9278", + "size": 20463, + "subdir": "linux-64", + "timestamp": 1610739102681, + "version": "2.5.1" + }, + "python-utils-2.5.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eadfba7c8827a9e5d04a2513896dc512", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "c231e667cb72c0e06b7011765f56f3bac1dfaa1a4de96f718a1982230f472e42", + "size": 20521, + "subdir": "linux-64", + "timestamp": 1610739110579, + "version": "2.5.1" + }, + "python-utils-2.5.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "70efb9e61d115b76ea724baffd93f581", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "db475f2e699e52bf2bce8f8cd6b0d59c7f83bb57d5567ca1904d4c21e302fa3f", + "size": 20565, + "subdir": "linux-64", + "timestamp": 1610739068042, + "version": "2.5.1" + }, + "python-utils-2.5.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e4f6494250d35bf90f8c778ffa1ad2da", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "7000d367f57817756760dbf34d225316e2c5677509e3fabfc1803afa8f9e8c78", + "size": 21341, + "subdir": "linux-64", + "timestamp": 1611258352679, + "version": "2.5.2" + }, + "python-utils-2.5.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fdf3403197345baddcf2b8f973010b7d", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "c6ee8089a48f88e8663d8a1b261dc4d15bee1018954f01d5103b9d301780c17e", + "size": 21336, + "subdir": "linux-64", + "timestamp": 1611258312859, + "version": "2.5.2" + }, + "python-utils-2.5.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d0e051330fb9a79cc49b9c54242c022c", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "66995accffab69587d073436fa6b9788faf050e5ca6cd104239bff31b96bac3d", + "size": 21451, + "subdir": "linux-64", + "timestamp": 1611258206579, + "version": "2.5.2" + }, + "python-utils-2.5.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1f3c67534b3a88a79f3c79912a5fbdb", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "98f9810d3e65cbedd84eff443a690bdcc54633fbdad6e4aac942b0db4d661ce8", + "size": 21455, + "subdir": "linux-64", + "timestamp": 1611258348727, + "version": "2.5.2" + }, + "python-utils-2.5.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5c12fa15c55839d1a0f7b2d1079f4204", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "682e8915f73041af8bfb5ecc0ea5652e510ed2170f8084532ffe19750beb022f", + "size": 19996, + "subdir": "linux-64", + "timestamp": 1640793993822, + "version": "2.5.5" + }, + "python-utils-2.5.5-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7129e19baa47793a096e7d2988e5d287", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "23dbc8e207e785c1c7fe3594d3988e2f21bca4f5cbfbe43051ef1fa37740b29b", + "size": 19980, + "subdir": "linux-64", + "timestamp": 1611693997942, + "version": "2.5.5" + }, + "python-utils-2.5.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d5bc57509369d495d703fc3289d9884b", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "a66c6bd2d6556c1977158b2a9daafa6c25d16f8c49d82dbeef1101f6f6ea8a34", + "size": 19961, + "subdir": "linux-64", + "timestamp": 1611694021742, + "version": "2.5.5" + }, + "python-utils-2.5.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c81897dec4cbf3299660e98cbf8eb842", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "80b72e5b210da376dd7066846a5443b7230bb574d61b3529cd029c7ec1605729", + "size": 20008, + "subdir": "linux-64", + "timestamp": 1611694043032, + "version": "2.5.5" + }, + "python-utils-2.5.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "487947130bcdbd2d53f6755750ab2898", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "0958a5796cfcda1f74c1166d975e63501c3131d47831d418d2c8e37dafa86204", + "size": 20071, + "subdir": "linux-64", + "timestamp": 1611694044013, + "version": "2.5.5" + }, + "python-utils-2.5.6-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "24151efe9972878140ec8d7391afb9e9", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "abf90b52ea7d5f9036fed33ba29622d17db61308fb65357374a4097743b7ed9c", + "size": 19949, + "subdir": "linux-64", + "timestamp": 1613936468429, + "version": "2.5.6" + }, + "python-utils-2.5.6-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2297b9da622c3ca93c1f26ed627348c0", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "b13bf2204263451ffc95a0057bce4e8dd03cb1516f5a581ad7e833521aea7203", + "size": 19934, + "subdir": "linux-64", + "timestamp": 1613935622384, + "version": "2.5.6" + }, + "python-utils-2.5.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7a2e44006293259d2cd37c4516e6b142", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "46e1ef438a0fee248299e284bbfa7fcbca3b18b7b55e0bad81146e2c9f8e7684", + "size": 20005, + "subdir": "linux-64", + "timestamp": 1613935620846, + "version": "2.5.6" + }, + "python-utils-2.5.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0955e1303716d8fdd529f3d2ba52b8f3", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "1e4b117385e06a29c2c59ce523631501d5577a22af0011e79234e061fca59bdf", + "size": 20023, + "subdir": "linux-64", + "timestamp": 1613936472192, + "version": "2.5.6" + }, + "python-utils-3.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "58ebbc465524e9429dd5d70c33270793", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "228a9223a20b83c76dc2f5594e2e4652c3061410688d65ac5262e75a4cd53db7", + "size": 36572, + "subdir": "linux-64", + "timestamp": 1663332347125, + "version": "3.3.3" + }, + "python-utils-3.3.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "52b2b19f3000059a5cb32c65c3d793a3", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "30eeaa9ddb0bf0d81213d46fdc6412e6148bba615c470fa1b6ea0c093b5256a3", + "size": 44891, + "subdir": "linux-64", + "timestamp": 1676845588613, + "version": "3.3.3" + }, + "python-utils-3.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e742203dfa50f16bcebf9d57bfd79fc6", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "c8f47dfae9bb01dbdd8e9b6c161c33fef6de9d5a80b293c9673d10e012695248", + "size": 36297, + "subdir": "linux-64", + "timestamp": 1663332308184, + "version": "3.3.3" + }, + "python-utils-3.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "76de8c08f01cfe1445cbe534a04e038e", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "d8982b0ae720617e95d70785196bd78ef8a172abedfc18485f35f34b467c8521", + "size": 36450, + "subdir": "linux-64", + "timestamp": 1663332282771, + "version": "3.3.3" + }, + "python-utils-3.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fd9e130aad663f76487741e7c13fdd8f", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "7b84fdf245c76b387d153c046a0fe9fe9383b31c3041ccb2a91e8644739117a0", + "size": 36233, + "subdir": "linux-64", + "timestamp": 1663332373124, + "version": "3.3.3" + }, + "python-xxhash-2.0.2-py310h5eee18b_1.tar.bz2": { + "build": "py310h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ec90e6d3554b8d3f2ed51287fd817be7", + "name": "python-xxhash", + "sha256": "6811b6587224888a77cde3aac81553a81875ef745adf6de32def92c4621e4550", + "size": 21898, + "subdir": "linux-64", + "timestamp": 1667919649210, + "version": "2.0.2" + }, + "python-xxhash-2.0.2-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "50931784cc84958ab4c6043342899cfd", + "name": "python-xxhash", + "sha256": "c42510d4b16ef958439dbd527027b46c1d21f4e0be480bb0b99cc79232eef87f", + "size": 43933, + "subdir": "linux-64", + "timestamp": 1640794019259, + "version": "2.0.2" + }, + "python-xxhash-2.0.2-py311h5eee18b_1.tar.bz2": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a5b4a93ecec3bff33ef1d463d0de10ce", + "name": "python-xxhash", + "sha256": "6ec021c29869024189566edb876e16043bbce635776b9e028c259448bdfc2cf1", + "size": 22375, + "subdir": "linux-64", + "timestamp": 1676842401281, + "version": "2.0.2" + }, + "python-xxhash-2.0.2-py36h7f8727e_0.tar.bz2": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "7bad47de5b4b346f7df837c59956a69f", + "name": "python-xxhash", + "sha256": "eecfa4d394dbadc79ee90bd6bb6299f04cbee79cd1ca34070d75fb39b2c0eac0", + "size": 25591, + "subdir": "linux-64", + "timestamp": 1633101754365, + "version": "2.0.2" + }, + "python-xxhash-2.0.2-py37h5eee18b_1.tar.bz2": { + "build": "py37h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8a28756607655b87f46a0942f09a2d3f", + "name": "python-xxhash", + "sha256": "604fe4b6c6f0e91c076d3d48baff6ca9712e82b5490b5eca33662d69d2a17d72", + "size": 21895, + "subdir": "linux-64", + "timestamp": 1667919590476, + "version": "2.0.2" + }, + "python-xxhash-2.0.2-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "47c29bda71e63f462d11b0c37b4cea08", + "name": "python-xxhash", + "sha256": "ae5935d673666e895cdb03571a24d87f4bae56267e46c65ea7b267f2b45b059f", + "size": 25576, + "subdir": "linux-64", + "timestamp": 1633091212106, + "version": "2.0.2" + }, + "python-xxhash-2.0.2-py38h5eee18b_1.tar.bz2": { + "build": "py38h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a92f7d2758c0aa092a557338bd9e9d64", + "name": "python-xxhash", + "sha256": "b474dfc4d1ff7dd0ca896c3bb61351d775b6302a5f6beebdb1e2ebf290a57955", + "size": 21942, + "subdir": "linux-64", + "timestamp": 1667919620016, + "version": "2.0.2" + }, + "python-xxhash-2.0.2-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "40b433805055ec4543dd5d402de3fd77", + "name": "python-xxhash", + "sha256": "e61da5986997d0ae947ffcbe9ab139dfe43ef4e5b53a6c53046f1304be0af025", + "size": 25660, + "subdir": "linux-64", + "timestamp": 1633101742347, + "version": "2.0.2" + }, + "python-xxhash-2.0.2-py39h5eee18b_1.tar.bz2": { + "build": "py39h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "77bc62d51cda97b3f3eb5ab43c4674d3", + "name": "python-xxhash", + "sha256": "5da1bca2a60544c4a59f9347a49c4e227bc2fccd1010b94c5718338eae47fd77", + "size": 21871, + "subdir": "linux-64", + "timestamp": 1667919560481, + "version": "2.0.2" + }, + "python-xxhash-2.0.2-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "92a82775b8b4530204890ba84d2fba10", + "name": "python-xxhash", + "sha256": "652fb47db15b10f01ea785a614aaad24684bc8aba5ff9fb024b729ccb8f02e69", + "size": 25656, + "subdir": "linux-64", + "timestamp": 1633101725566, + "version": "2.0.2" + }, + "python3-openid-3.1.0-py310h06a4308_1001.tar.bz2": { + "build": "py310h06a4308_1001", + "build_number": 1001, + "depends": [ + "defusedxml", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ef9eb14f92b2be6e9e3ec28c3037def7", + "name": "python3-openid", + "sha256": "4477a08d3e80844e95aee9c4ae250b28d48a981cbe529f4a9348b3a1cc5f7f5a", + "size": 179789, + "subdir": "linux-64", + "timestamp": 1642510894814, + "version": "3.1.0" + }, + "python3-openid-3.1.0-py311h06a4308_1001.tar.bz2": { + "build": "py311h06a4308_1001", + "build_number": 1001, + "depends": [ + "defusedxml", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ed6f2813a67547c7cd41c15dcc4902e1", + "name": "python3-openid", + "sha256": "5c4900054f5d86e7584b65741da765648090ca1fb501a0f48b2179b1fe782a61", + "size": 233931, + "subdir": "linux-64", + "timestamp": 1676845603315, + "version": "3.1.0" + }, + "python3-openid-3.1.0-py36_1001.tar.bz2": { + "build": "py36_1001", + "build_number": 1001, + "depends": [ + "defusedxml", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "93affbde34e647d63825546e599935a7", + "name": "python3-openid", + "sha256": "06c85f58cd9dd4ddb4ac58ef30f212a0c05c0e97d62e99c72bede38972d52d7b", + "size": 180782, + "subdir": "linux-64", + "timestamp": 1579615028389, + "version": "3.1.0" + }, + "python3-openid-3.1.0-py36h06a4308_1001.tar.bz2": { + "build": "py36h06a4308_1001", + "build_number": 1001, + "depends": [ + "defusedxml", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "18e55a9bd3b174d4e3d70466e64155e6", + "name": "python3-openid", + "sha256": "e73aaf30eb79aaa3921b0e9e0c41450daf1025d26d65f42e474ac638d5b77a4d", + "size": 181009, + "subdir": "linux-64", + "timestamp": 1614085650533, + "version": "3.1.0" + }, + "python3-openid-3.1.0-py37_1001.tar.bz2": { + "build": "py37_1001", + "build_number": 1001, + "depends": [ + "defusedxml", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "557a0d9724e5a5200976434c67f3d6d7", + "name": "python3-openid", + "sha256": "79bf48f0bb5925e808763be61d0e8d3d41202eef06adae040b4e042817edb16b", + "size": 180610, + "subdir": "linux-64", + "timestamp": 1579614933544, + "version": "3.1.0" + }, + "python3-openid-3.1.0-py37h06a4308_1001.tar.bz2": { + "build": "py37h06a4308_1001", + "build_number": 1001, + "depends": [ + "defusedxml", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "feb5a2209b0353ae78f91381118e1594", + "name": "python3-openid", + "sha256": "bdc605010dbe482c6c6cca3c1b9c1375a2d17e82ccfbfb38bc6ef9573ab85b27", + "size": 181420, + "subdir": "linux-64", + "timestamp": 1614085642676, + "version": "3.1.0" + }, + "python3-openid-3.1.0-py38_1001.tar.bz2": { + "build": "py38_1001", + "build_number": 1001, + "depends": [ + "defusedxml", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a0e6565e4242baa7e5429e3c61f63dea", + "name": "python3-openid", + "sha256": "94964cfb1d6e4bbd19c440b1d5a0cb355e99eee84a96e211781304d7b2f1637c", + "size": 181296, + "subdir": "linux-64", + "timestamp": 1579615021014, + "version": "3.1.0" + }, + "python3-openid-3.1.0-py38h06a4308_1001.tar.bz2": { + "build": "py38h06a4308_1001", + "build_number": 1001, + "depends": [ + "defusedxml", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0ef7ae5eaac15da4a93ef18b53e9fef6", + "name": "python3-openid", + "sha256": "b53b3f1ea85a21ae0e08e8aed8660970d35a76f6d736395933e1d24fdb554de0", + "size": 181440, + "subdir": "linux-64", + "timestamp": 1614085645213, + "version": "3.1.0" + }, + "python3-openid-3.1.0-py39h06a4308_1001.tar.bz2": { + "build": "py39h06a4308_1001", + "build_number": 1001, + "depends": [ + "defusedxml", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6f8781dc6bd3c21f50fc26e49e7dabb1", + "name": "python3-openid", + "sha256": "1cc62b0388b519c1c77b4a9bbce6f511ddc4356d43b9a01d5c22217565faec38", + "size": 180514, + "subdir": "linux-64", + "timestamp": 1614085654360, + "version": "3.1.0" + }, + "pythonanywhere-0.10.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "docopt", + "packaging", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "requests", + "schema", + "tabulate", + "typer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f535adfca455fd44275131e36c160073", + "name": "pythonanywhere", + "sha256": "20d38fe7be6811bccd4900cbe739cbe33acff75bf9d423533d454bbd23b92693", + "size": 55841, + "subdir": "linux-64", + "timestamp": 1663667621304, + "version": "0.10.2" + }, + "pythonanywhere-0.10.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "docopt", + "packaging", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests", + "schema", + "tabulate", + "typer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb612da2633094028570d324c922c85a", + "name": "pythonanywhere", + "sha256": "e94c145a60a2bb5d080727e89e8cb535dbdcc44a12879476d309b32f7f58f6bf", + "size": 55041, + "subdir": "linux-64", + "timestamp": 1663667649105, + "version": "0.10.2" + }, + "pythonanywhere-0.10.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "docopt", + "packaging", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests", + "schema", + "tabulate", + "typer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3086875e6e856469b341795450c52e1", + "name": "pythonanywhere", + "sha256": "0da5696198d4726656b58fe47934ba951670135af765e471e76fe575e345fbf5", + "size": 55453, + "subdir": "linux-64", + "timestamp": 1663667705233, + "version": "0.10.2" + }, + "pythonanywhere-0.10.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "docopt", + "packaging", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests", + "schema", + "tabulate", + "typer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ad35e6330f2ebb6c894044d02db3d4d", + "name": "pythonanywhere", + "sha256": "de43fd05561aaaa203054a3ebdcf700211193360525a274ad1666fda88daef81", + "size": 55481, + "subdir": "linux-64", + "timestamp": 1663667677848, + "version": "0.10.2" + }, + "pythonnet-3.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "clr_loader >=0.2.2,<0.3.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bec11d8408b1c7a227bb3908a4eea90e", + "name": "pythonnet", + "sha256": "c2e9abd316b81fe4fee309388c3cb6492862fd56593bb4f7861b4734e206c29f", + "size": 313450, + "subdir": "linux-64", + "timestamp": 1675453856094, + "version": "3.0.1" + }, + "pythonnet-3.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "clr_loader >=0.2.2,<0.3.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9bb3dd9a59a82141a2bbf110a376c219", + "name": "pythonnet", + "sha256": "d5bc3205a6249c94844b66379c672eedda88c679422730e9e7f67938ef5f35b3", + "size": 315391, + "subdir": "linux-64", + "timestamp": 1676861628170, + "version": "3.0.1" + }, + "pythonnet-3.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "clr_loader >=0.2.2,<0.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e24f77be8dfe2a4f826fe8923b89143", + "name": "pythonnet", + "sha256": "c4485dfa142f64f7a86dd700762898ff6f097c07fab29791c15907ecbe84b870", + "size": 313291, + "subdir": "linux-64", + "timestamp": 1675453779577, + "version": "3.0.1" + }, + "pythonnet-3.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "clr_loader >=0.2.2,<0.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6221c9f8f4514e4e6ba33eaf40273060", + "name": "pythonnet", + "sha256": "4406a6b3fe0345fa45b6e7ca7ab12a490226f70da866a2c4443544db5a554626", + "size": 313313, + "subdir": "linux-64", + "timestamp": 1675453742835, + "version": "3.0.1" + }, + "pythonnet-3.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "clr_loader >=0.2.2,<0.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b832182b227999233c8b34ab61b01e3", + "name": "pythonnet", + "sha256": "1079510f03209b8b90722a116d213a640a537a06932d7c8dbf9000fe94e9f88e", + "size": 313366, + "subdir": "linux-64", + "timestamp": 1675453817807, + "version": "3.0.1" + }, + "pythran-0.10.0-py310h3c18c91_0.tar.bz2": { + "build": "py310h3c18c91_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "ply >=3.4", + "python >=3.10,<3.11.0a0", + "xsimd >=7.6,<7.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "54e32af96a78922937433ddfcd7c1b94", + "name": "pythran", + "sha256": "426935898eeb1f177ec146efb82d60c4290045b47caa24b106cec8f11ac3c40d", + "size": 2138837, + "subdir": "linux-64", + "timestamp": 1656068424659, + "version": "0.10.0" + }, + "pythran-0.10.0-py37h79cecc1_0.tar.bz2": { + "build": "py37h79cecc1_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.7,<3.8.0a0", + "xsimd >=7.6,<7.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a4ce6ece79d0998542fea1b140a60f3", + "name": "pythran", + "sha256": "1e7a45d9b20738dc00e00f7b54335e187840f74bb642d1893f91cd4785f636a0", + "size": 2129817, + "subdir": "linux-64", + "timestamp": 1656068596248, + "version": "0.10.0" + }, + "pythran-0.10.0-py38h79cecc1_0.tar.bz2": { + "build": "py38h79cecc1_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.8,<3.9.0a0", + "xsimd >=7.6,<7.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a452449749ddc7fb4793ae98874da82", + "name": "pythran", + "sha256": "304ccd4fc3611249e5a57fc8ee978c4bff2c4b09ab2ff8ddbd2fc5822fe4a4cb", + "size": 2130734, + "subdir": "linux-64", + "timestamp": 1656068510082, + "version": "0.10.0" + }, + "pythran-0.10.0-py39h79cecc1_0.tar.bz2": { + "build": "py39h79cecc1_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.9,<3.10.0a0", + "xsimd >=7.6,<7.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "73dd9a96d9378cf4b95bcc0fb4d10aa2", + "name": "pythran", + "sha256": "9325a7066447d8111ac84ba9c353c6fb2e7dde370650f90d2baf1c67ae9264aa", + "size": 2138874, + "subdir": "linux-64", + "timestamp": 1656068682172, + "version": "0.10.0" + }, + "pythran-0.11.0-py310h3c18c91_0.tar.bz2": { + "build": "py310h3c18c91_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "ply >=3.4", + "python >=3.10,<3.11.0a0", + "xsimd >=8.0.5,<8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "222a18dde64d5cec5cac3c71c9193145", + "name": "pythran", + "sha256": "c10e21fc270e4ec6b3e4a1a2405242cda9535827740bcf028358c104dd8ab4fe", + "size": 2157236, + "subdir": "linux-64", + "timestamp": 1660004908043, + "version": "0.11.0" + }, + "pythran-0.11.0-py37h79cecc1_0.tar.bz2": { + "build": "py37h79cecc1_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.7,<3.8.0a0", + "xsimd >=8.0.5,<8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d88478e6ff0977e4bbe1d36f1df46946", + "name": "pythran", + "sha256": "e0bbb35e0db1ef00d8415616054f8eb869cb67e6aa633f25a1e1779b72e3c195", + "size": 2143382, + "subdir": "linux-64", + "timestamp": 1660005066864, + "version": "0.11.0" + }, + "pythran-0.11.0-py38h79cecc1_0.tar.bz2": { + "build": "py38h79cecc1_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.8,<3.9.0a0", + "xsimd >=8.0.5,<8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3c4ff179ad7d289c40c25a0209885ee2", + "name": "pythran", + "sha256": "26ab3aa897cf2c35192e379185ebb2d602c071823e2adcb821e65cc516d4eb25", + "size": 2147061, + "subdir": "linux-64", + "timestamp": 1660004818257, + "version": "0.11.0" + }, + "pythran-0.11.0-py39h79cecc1_0.tar.bz2": { + "build": "py39h79cecc1_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.9,<3.10.0a0", + "xsimd >=8.0.5,<8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d967a25296ecd597a4a17c2ee663407", + "name": "pythran", + "sha256": "fd0e83fb6bc1fe1e1f5ab9cdf0ac79bd4d2ae01243b314da793314b0de7f969f", + "size": 2146915, + "subdir": "linux-64", + "timestamp": 1660004987459, + "version": "0.11.0" + }, + "pythran-0.12.1-py310h3c18c91_0.tar.bz2": { + "build": "py310h3c18c91_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "ply >=3.4", + "python >=3.10,<3.11.0a0", + "xsimd 10.0.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6c1042b36e13dfe56701228ddfe686f7", + "name": "pythran", + "sha256": "46eb54722a10d3051745f0d9d3b01c70e2ad9660a7c60f41ad5ca80be59bf38d", + "size": 2167845, + "subdir": "linux-64", + "timestamp": 1674515381218, + "version": "0.12.1" + }, + "pythran-0.12.1-py311heed92f4_0.tar.bz2": { + "build": "py311heed92f4_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "ply >=3.4", + "python >=3.11,<3.12.0a0", + "xsimd 10.0.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22f5ab6120847acaa3b3701a0b212253", + "name": "pythran", + "sha256": "e6aa1df5a05f21a09bdde6e75c4fb477a7149768163007046c1bbd5a09bdac43", + "size": 2332599, + "subdir": "linux-64", + "timestamp": 1676827434153, + "version": "0.12.1" + }, + "pythran-0.12.1-py37h79cecc1_0.tar.bz2": { + "build": "py37h79cecc1_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.7,<3.8.0a0", + "xsimd 10.0.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f627516ad31de128b8ada2077d57a38", + "name": "pythran", + "sha256": "3187cc2d26c2b93e77142ec94c370fc6f710da5af4fc368826a1710052a70740", + "size": 2154749, + "subdir": "linux-64", + "timestamp": 1674515310326, + "version": "0.12.1" + }, + "pythran-0.12.1-py38h79cecc1_0.tar.bz2": { + "build": "py38h79cecc1_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.8,<3.9.0a0", + "xsimd 10.0.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "766a3c71617d776b7ac3ac5352592c03", + "name": "pythran", + "sha256": "d1610ed52fc419d280e7e9a82100cdeda0898d87b443e37bbb94dcfb5f2976ce", + "size": 2155527, + "subdir": "linux-64", + "timestamp": 1674515237338, + "version": "0.12.1" + }, + "pythran-0.12.1-py39h79cecc1_0.tar.bz2": { + "build": "py39h79cecc1_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.9,<3.10.0a0", + "xsimd 10.0.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "65eb524c11a9c5af8261859eaee4ed7a", + "name": "pythran", + "sha256": "c47121595790bcada40c5084beb8a26fbe05bd649867e20f50c3e2fb338c9d08", + "size": 2154413, + "subdir": "linux-64", + "timestamp": 1674515453818, + "version": "0.12.1" + }, + "pythran-0.9.11-py310h2571103_3.tar.bz2": { + "build": "py310h2571103_3", + "build_number": 3, + "depends": [ + "beniget 0.3.*", + "decorator", + "gast 0.4.*", + "gxx_linux-64 7.5.0.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2", + "numpy >=1.21.2,<2.0a0", + "ply >=3.4", + "python >=3.10,<3.11.0a0", + "six", + "xsimd" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4968dde8b910466bdc7f8fc910a5665c", + "name": "pythran", + "sha256": "4855444b213d54cd69b042ebe29349337ebec31b0a32fb206f5317bce7511cd4", + "size": 2099757, + "subdir": "linux-64", + "timestamp": 1640810710328, + "version": "0.9.11" + }, + "pythran-0.9.11-py310h2571103_4.tar.bz2": { + "build": "py310h2571103_4", + "build_number": 4, + "depends": [ + "beniget 0.3.*", + "decorator", + "gast 0.4.*", + "gxx_linux-64 7.5.0.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2", + "numpy >=1.21.2,<2.0a0", + "ply >=3.4", + "python >=3.10,<3.11.0a0", + "six", + "xsimd" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4ec6172d99af3b496e6c11fa223fc94a", + "name": "pythran", + "sha256": "93ff71ff65d1b39d5afe5afd4dfddaf9110db9c92ab3fc79b9cbf35d42a06d4f", + "size": 2112478, + "subdir": "linux-64", + "timestamp": 1647959282379, + "version": "0.9.11" + }, + "pythran-0.9.11-py36hae6d005_3.tar.bz2": { + "build": "py36hae6d005_3", + "build_number": 3, + "depends": [ + "beniget 0.3.*", + "decorator", + "gast 0.4.*", + "gxx_linux-64 7.5.0.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.6,<3.7.0a0", + "six", + "xsimd" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9996cafc5652b177001250d68819c6d2", + "name": "pythran", + "sha256": "8340a6854c2a6207351160ed4c2d830f81da675896cd5351c4e3e46ca48251f2", + "size": 2091986, + "subdir": "linux-64", + "timestamp": 1630332122172, + "version": "0.9.11" + }, + "pythran-0.9.11-py37hae6d005_3.tar.bz2": { + "build": "py37hae6d005_3", + "build_number": 3, + "depends": [ + "beniget 0.3.*", + "decorator", + "gast 0.4.*", + "gxx_linux-64 7.5.0.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.7,<3.8.0a0", + "six", + "xsimd" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7df7667cae6035db3a549ee557f2f349", + "name": "pythran", + "sha256": "07ed0b0395f78b1e3c0c7ddded986c18de2a6b70f3ec0d1f972eddbba3977100", + "size": 2105986, + "subdir": "linux-64", + "timestamp": 1630331740555, + "version": "0.9.11" + }, + "pythran-0.9.11-py37hae6d005_4.tar.bz2": { + "build": "py37hae6d005_4", + "build_number": 4, + "depends": [ + "beniget 0.3.*", + "decorator", + "gast 0.4.*", + "gxx_linux-64 7.5.0.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.7,<3.8.0a0", + "six", + "xsimd" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "45a17207f61b94efae1804208695e164", + "name": "pythran", + "sha256": "f586eafb3b28b61af627b3fd1fa2232fdb8dd7c40fc99486b2be17842ce55e0e", + "size": 2095946, + "subdir": "linux-64", + "timestamp": 1647959102679, + "version": "0.9.11" + }, + "pythran-0.9.11-py38hae6d005_3.tar.bz2": { + "build": "py38hae6d005_3", + "build_number": 3, + "depends": [ + "beniget 0.3.*", + "decorator", + "gast 0.4.*", + "gxx_linux-64 7.5.0.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.8,<3.9.0a0", + "six", + "xsimd" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8163c66292bbf39ad63caf74da7f7f3e", + "name": "pythran", + "sha256": "3ad53e1e3bb5676d63ccc324d14d906c5cc765a33a6a7826b21a229c673394fc", + "size": 2106814, + "subdir": "linux-64", + "timestamp": 1630331732290, + "version": "0.9.11" + }, + "pythran-0.9.11-py38hae6d005_4.tar.bz2": { + "build": "py38hae6d005_4", + "build_number": 4, + "depends": [ + "beniget 0.3.*", + "decorator", + "gast 0.4.*", + "gxx_linux-64 7.5.0.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.8,<3.9.0a0", + "six", + "xsimd" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "00116902ce761f13c5f0afdb13870f47", + "name": "pythran", + "sha256": "433c05088d3ba70e60bc8e76686edf763889bad3985df40c491a0ddd7cc2965c", + "size": 2100579, + "subdir": "linux-64", + "timestamp": 1647959019353, + "version": "0.9.11" + }, + "pythran-0.9.11-py39hae6d005_3.tar.bz2": { + "build": "py39hae6d005_3", + "build_number": 3, + "depends": [ + "beniget 0.3.*", + "decorator", + "gast 0.4.*", + "gxx_linux-64 7.5.0.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.9,<3.10.0a0", + "six", + "xsimd" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee33350128a80000fe0ba2fe0850186c", + "name": "pythran", + "sha256": "a7862ce57e031e39d5b641e9226fc1ee6951813cd5fb8ccae36b54eaa10982fd", + "size": 2106520, + "subdir": "linux-64", + "timestamp": 1630322601915, + "version": "0.9.11" + }, + "pythran-0.9.11-py39hae6d005_4.tar.bz2": { + "build": "py39hae6d005_4", + "build_number": 4, + "depends": [ + "beniget 0.3.*", + "decorator", + "gast 0.4.*", + "gxx_linux-64 7.5.0.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.9,<3.10.0a0", + "six", + "xsimd" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5437f41a319fa615ca62f693bdf75735", + "name": "pythran", + "sha256": "d545e10c1d8803ec854c1e0c19a812d98fe4c9dff833a5116e9679fcc3937191", + "size": 2101198, + "subdir": "linux-64", + "timestamp": 1647959192540, + "version": "0.9.11" + }, + "pytimeparse-1.1.7-py27h14c5330_0.tar.bz2": { + "build": "py27h14c5330_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e7f00db78cc8649066702208d89d25bd", + "name": "pytimeparse", + "sha256": "17e27ef27d6bf3b46c2f2e8792ba0cc0debb6dc7608c2f105723d43770b19875", + "size": 15627, + "subdir": "linux-64", + "timestamp": 1508621586039, + "version": "1.1.7" + }, + "pytimeparse-1.1.7-py35h492fd5f_0.tar.bz2": { + "build": "py35h492fd5f_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66e6d687d18cdea456e1a503c5bbfd25", + "name": "pytimeparse", + "sha256": "85b19982797f14803d6915876a32684ef0cb74f4e2c5cd097bba923bd9ecbf69", + "size": 16162, + "subdir": "linux-64", + "timestamp": 1508621607462, + "version": "1.1.7" + }, + "pytimeparse-1.1.7-py36ha42143c_0.tar.bz2": { + "build": "py36ha42143c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "04941d3415129be0f2f0139794fb05ac", + "name": "pytimeparse", + "sha256": "1f061a85ec7693e7940aa24bcf3b1c973ca0eb2258398e29156d392d1290739f", + "size": 16063, + "subdir": "linux-64", + "timestamp": 1508621604611, + "version": "1.1.7" + }, + "pytimeparse-1.1.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e33a9ab18ae1b7baf7901163fe1f64e8", + "name": "pytimeparse", + "sha256": "679899581c41f81c992af68133cd1e019dcd6f7e2d86a9f262ae141dfc78f6d1", + "size": 15577, + "subdir": "linux-64", + "timestamp": 1526938387452, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8cf38e3c850339dc4f3d5871ce3b1714", + "name": "pytimeparse", + "sha256": "f6be4ab074c7dd9d4c3118c1d09c4d6e453ac00f59679b6760e017c1f681587e", + "size": 16885, + "subdir": "linux-64", + "timestamp": 1640794037320, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2460a0c64387bff2ab06b0d70a39b471", + "name": "pytimeparse", + "sha256": "75f2d1a8613f8aec75eefa7608a8b641d8af573e5983b9857d47184ec50dda36", + "size": 20645, + "subdir": "linux-64", + "timestamp": 1676838691263, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fbdd2b4052d08ce87a8ab82b050c3ea1", + "name": "pytimeparse", + "sha256": "aa70c956b39d83bb5977efea5280466ef602a39ea0f43f2aae27691f1875c15d", + "size": 16056, + "subdir": "linux-64", + "timestamp": 1526938398724, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1146ae23ae8853cbcb0a740599526989", + "name": "pytimeparse", + "sha256": "658226fc3057197a79043cf6356555946c0b48b4880056468a0e861b95157d69", + "size": 16022, + "subdir": "linux-64", + "timestamp": 1526938361548, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c8c4cc0bb02bb3563012be5244d938ca", + "name": "pytimeparse", + "sha256": "33a2602b30cea4e761036d4bc8e7b4741ebe118de94066ceccab788342559222", + "size": 18346, + "subdir": "linux-64", + "timestamp": 1613409188073, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "333918c837f0bdf65e36fb17ed677a7f", + "name": "pytimeparse", + "sha256": "dd2b3cfda4dabc6e95cb4af3a6b9ca9a4a3d2e912fa2797a5b4149bc40364cde", + "size": 15936, + "subdir": "linux-64", + "timestamp": 1530735485424, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f15758004f5167f635710d1ec1693d3d", + "name": "pytimeparse", + "sha256": "efc3c1e2d4f4f64392f98f9e08c0660accdc7ed1b90d1dc9f4cd7e3ed804e4f5", + "size": 18255, + "subdir": "linux-64", + "timestamp": 1613409777538, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "788cea52a70ac50438684380b74a0b68", + "name": "pytimeparse", + "sha256": "452da15f197ee98b6c0066f428b7f487e742d2751e62a531537cd813bb5d73ce", + "size": 16786, + "subdir": "linux-64", + "timestamp": 1573200304871, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "99a46f55588ebc6bb2250bf2a22c7a6d", + "name": "pytimeparse", + "sha256": "348acaf36c04925e341c27c9a61d3747c1f143632775687f2b8e46e1ee383fbe", + "size": 18345, + "subdir": "linux-64", + "timestamp": 1613409780745, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "05489400f1f314e5e5f97eb73512da4c", + "name": "pytimeparse", + "sha256": "04ec3d93e5960000a1156bbb549a7719c94c8023f24a1a35d9c7f5bb216a5b78", + "size": 18379, + "subdir": "linux-64", + "timestamp": 1613409780053, + "version": "1.1.8" + }, + "pytoml-0.1.15-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "765d4de00c33834184b18d0127a4825a", + "name": "pytoml", + "sha256": "775e342d031bd712328685051253616de62a85dd6cba458ec323b7530524a2ab", + "size": 16110, + "subdir": "linux-64", + "timestamp": 1529945214202, + "version": "0.1.15" + }, + "pytoml-0.1.15-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "84dddc4766bd6ce1a717b1b6fcf91d26", + "name": "pytoml", + "sha256": "0806da07a83bbb5bc1c8f664a5c6ba16bdb39841a7ca7f3f95ea4a5028df9b32", + "size": 16375, + "subdir": "linux-64", + "timestamp": 1529945275298, + "version": "0.1.15" + }, + "pytoml-0.1.15-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8b6666cfe307eb1cc547073c7feed329", + "name": "pytoml", + "sha256": "d0948674d19ea8b434db45712bda7334bfb3f26bb9da18f1cfad9c883e3d0d0e", + "size": 16245, + "subdir": "linux-64", + "timestamp": 1529945134744, + "version": "0.1.15" + }, + "pytoml-0.1.15-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "47df1e453e039a2e1d34798d9476c4e8", + "name": "pytoml", + "sha256": "7eff45cdaf95968a5b9f619e28bda7fe1c1dfabccb6314d591c6093d6da5e618", + "size": 16245, + "subdir": "linux-64", + "timestamp": 1530898053690, + "version": "0.1.15" + }, + "pytoml-0.1.18-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "73dcafb3761c65ba454f1ad1267e1da1", + "name": "pytoml", + "sha256": "e47e51a64f00ebd7baa5bd872ddc9ce52031d57e7d90c976ccb06a01270c1b28", + "size": 16564, + "subdir": "linux-64", + "timestamp": 1535512688983, + "version": "0.1.18" + }, + "pytoml-0.1.18-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "11b485f72c112667b5a09c8c696034d8", + "name": "pytoml", + "sha256": "8ca16b505a992c97b5af78308b0882759d59a90d5df810ede842cb58c3312443", + "size": 16794, + "subdir": "linux-64", + "timestamp": 1535512717658, + "version": "0.1.18" + }, + "pytoml-0.1.18-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "687f29fc190f81667417665def6e6132", + "name": "pytoml", + "sha256": "bda6b951eafb54e31b41df860d17e0bd7f33594ce73d2d44777ff305421a069a", + "size": 16645, + "subdir": "linux-64", + "timestamp": 1535512643914, + "version": "0.1.18" + }, + "pytoml-0.1.18-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "59fedb28d612049e77583d51e246b135", + "name": "pytoml", + "sha256": "5a892cbaacbd4e2a32c5a8d94054aaf623ba161f9956b6bea7e799bf6ff05d0e", + "size": 16709, + "subdir": "linux-64", + "timestamp": 1535512750201, + "version": "0.1.18" + }, + "pytoml-0.1.19-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "eb8e3add9155cefc36f8735e98b69421", + "name": "pytoml", + "sha256": "15baf0979070e5111d9d4f2690585d093eba6d1eb4b34e1ba9f34a5f8645a4c6", + "size": 16668, + "subdir": "linux-64", + "timestamp": 1538358752740, + "version": "0.1.19" + }, + "pytoml-0.1.19-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4736c45dc1b00ffdf74436a652e75223", + "name": "pytoml", + "sha256": "444a8919abb6f72ba81c1e12532080c12e4a645f67241d32a1210f9e9b3031c9", + "size": 16788, + "subdir": "linux-64", + "timestamp": 1538358779741, + "version": "0.1.19" + }, + "pytoml-0.1.19-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c9bfd6f92efe33e4d7e9fc7fae116d1b", + "name": "pytoml", + "sha256": "5fee3cde267c1d77043ace9f07526dbcffb4313f1d679c8efde83467e6191e48", + "size": 16838, + "subdir": "linux-64", + "timestamp": 1538358686240, + "version": "0.1.19" + }, + "pytoml-0.1.20-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f0cfcf62e9b14c9b3822221bb0d7bee7", + "name": "pytoml", + "sha256": "44d76b67c9ed9223299788cf861f156eb9a80ed83c6a425158ac0b0743b8325c", + "size": 17803, + "subdir": "linux-64", + "timestamp": 1541040846321, + "version": "0.1.20" + }, + "pytoml-0.1.20-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7cc244e4db28ce7ea252792cb26cd25b", + "name": "pytoml", + "sha256": "07b332905b951da1f7200c1ece5e33d4e21b11eb414c53fc78de2f7d52f7bf22", + "size": 17958, + "subdir": "linux-64", + "timestamp": 1541040880326, + "version": "0.1.20" + }, + "pytoml-0.1.20-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "78a152fdcac93f30b59bc5ecbcd1438e", + "name": "pytoml", + "sha256": "00a91abeb6364568c7aed06a843c987fd5fe3f0c9d2f6f86502e808bbb882d64", + "size": 17995, + "subdir": "linux-64", + "timestamp": 1541040785940, + "version": "0.1.20" + }, + "pytoolconfig-1.2.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=22.0", + "python >=3.10,<3.11.0a0", + "tomli >=2.0.1" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "3d4a7e244e03ac2f596e5ea50c068753", + "name": "pytoolconfig", + "sha256": "f77fb5cd5218cb249638e2dcedfbe5b0969552d4c3dcf05e6b2bc7b50f68815e", + "size": 27761, + "subdir": "linux-64", + "timestamp": 1675309504680, + "version": "1.2.5" + }, + "pytoolconfig-1.2.5-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "packaging >=22.0", + "platformdirs", + "python >=3.10,<3.11.0a0", + "tomli >=2.0.1" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "62ba3d248e2b46ccbad5ca0fec5a6ffe", + "name": "pytoolconfig", + "sha256": "52ada4b493e3958cbc2cb7d23434e7227ba8d7d882983092d4ace5393f6634bd", + "size": 27836, + "subdir": "linux-64", + "timestamp": 1676315102999, + "version": "1.2.5" + }, + "pytoolconfig-1.2.5-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "packaging >=22.0", + "platformdirs", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "9d27be6906b6b0815706187f47b2a882", + "name": "pytoolconfig", + "sha256": "bb46b7f192b49b01d70dfe1d281e25e058a914126f26b554202b90061bcd6e5e", + "size": 33391, + "subdir": "linux-64", + "timestamp": 1677709034188, + "version": "1.2.5" + }, + "pytoolconfig-1.2.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=22.0", + "python >=3.7,<3.8.0a0", + "tomli >=2.0.1", + "typing-extensions >=4.4.0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "a36d4c380c5de917e70821b72286b8e0", + "name": "pytoolconfig", + "sha256": "65faf0be536f3bc964b048f3235c3bd0d1a59ce2f007bf26ea4d37e554630d58", + "size": 27547, + "subdir": "linux-64", + "timestamp": 1675309540567, + "version": "1.2.5" + }, + "pytoolconfig-1.2.5-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "packaging >=22.0", + "platformdirs", + "python >=3.7,<3.8.0a0", + "tomli >=2.0.1", + "typing-extensions >=4.4.0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "c776094eb3339abc224f1c6961786b00", + "name": "pytoolconfig", + "sha256": "f1176cd88dd8654588ea89ae1551a0f9b5c79f05536672dd8fd94291482da783", + "size": 27616, + "subdir": "linux-64", + "timestamp": 1676315175903, + "version": "1.2.5" + }, + "pytoolconfig-1.2.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=22.0", + "python >=3.8,<3.9.0a0", + "tomli >=2.0.1" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "1fef9cbd24fec148865a3548f115c07c", + "name": "pytoolconfig", + "sha256": "1dac5099625d8cd58fb816c6c3b422a24994b5c4f420cd1a73e81d2388fa2457", + "size": 27573, + "subdir": "linux-64", + "timestamp": 1675309575590, + "version": "1.2.5" + }, + "pytoolconfig-1.2.5-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "packaging >=22.0", + "platformdirs", + "python >=3.8,<3.9.0a0", + "tomli >=2.0.1" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "9345d00da690c01d86bfebc344d0d809", + "name": "pytoolconfig", + "sha256": "a699cfb8f91c38e04a3878eeb0fe5901b6beb18d7a781726ddf6e0d59df09205", + "size": 27604, + "subdir": "linux-64", + "timestamp": 1676315067791, + "version": "1.2.5" + }, + "pytoolconfig-1.2.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=22.0", + "python >=3.9,<3.10.0a0", + "tomli >=2.0.1" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "e346890f9e755b76adbb2a50dc4e2ffa", + "name": "pytoolconfig", + "sha256": "85ed6bb870b73ab33e0510d746c910d821eafe1a2c3efa07df71164cbb8de0d8", + "size": 27539, + "subdir": "linux-64", + "timestamp": 1675309469484, + "version": "1.2.5" + }, + "pytoolconfig-1.2.5-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "packaging >=22.0", + "platformdirs", + "python >=3.9,<3.10.0a0", + "tomli >=2.0.1" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "3e3b0db2089ba14727333daf47bc3ba0", + "name": "pytoolconfig", + "sha256": "d00cbc86d6f2b0e94f524c0394e0a4427f7ae4420191a32fee9bf830ed6ad157", + "size": 27579, + "subdir": "linux-64", + "timestamp": 1676315138782, + "version": "1.2.5" + }, + "pytorch-0.2.0-py27cuda7.5cudnn5.1_0.tar.bz2": { + "build": "py27cuda7.5cudnn5.1_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 7.5*", + "cudnn 5.1*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2ad43b2a57192163f3b35715b3591b1a", + "name": "pytorch", + "sha256": "73b77edfea24e7cc08d25cc63382cbaf3b5f9cfdfa9d02dabef679f710cc0943", + "size": 174478420, + "subdir": "linux-64", + "timestamp": 1511317602199, + "version": "0.2.0" + }, + "pytorch-0.2.0-py27cuda7.5cudnn6.0_0.tar.bz2": { + "build": "py27cuda7.5cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 7.5*", + "cudnn 6.0*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bac636e4be687bdd54023cfb1898b3ae", + "name": "pytorch", + "sha256": "4d4061a8cc572e5aa732f0d829c4e173ff4d2ca75f6dc0b6ee7ede6d919c512e", + "size": 174481847, + "subdir": "linux-64", + "timestamp": 1511315381620, + "version": "0.2.0" + }, + "pytorch-0.2.0-py27cuda8.0cudnn5.1_0.tar.bz2": { + "build": "py27cuda8.0cudnn5.1_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn 5.1*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8c148c44b0f3a498cc86278997b03645", + "name": "pytorch", + "sha256": "db3315bb99f6a80029d7a114c9e26edd1f03898d1e6c23ad08358b36e21839a2", + "size": 179604064, + "subdir": "linux-64", + "timestamp": 1511304294817, + "version": "0.2.0" + }, + "pytorch-0.2.0-py27cuda8.0cudnn6.0_0.tar.bz2": { + "build": "py27cuda8.0cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn 6.0*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "793aa00611970150763df013a8c0a793", + "name": "pytorch", + "sha256": "b525269dbcee3b984d69bbe23709a4de335c07cb5afb523583268a92d405a69b", + "size": 179602727, + "subdir": "linux-64", + "timestamp": 1511305977597, + "version": "0.2.0" + }, + "pytorch-0.2.0-py35cuda7.5cudnn5.1_0.tar.bz2": { + "build": "py35cuda7.5cudnn5.1_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 7.5*", + "cudnn 5.1*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4f8304561a33cb9eaee45418636e8e28", + "name": "pytorch", + "sha256": "20df24341d28f71a9646fcc14b4746f492c83c7713372e3de811ab4bc1e29983", + "size": 174137854, + "subdir": "linux-64", + "timestamp": 1511320505720, + "version": "0.2.0" + }, + "pytorch-0.2.0-py35cuda7.5cudnn6.0_0.tar.bz2": { + "build": "py35cuda7.5cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 7.5*", + "cudnn 6.0*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "89c751be35d36c7f46a66a7a06a9a470", + "name": "pytorch", + "sha256": "36e383019e51d3613a30f780fb276a49d87ebb2b7d6f541d437d700cadfe0ff2", + "size": 174129287, + "subdir": "linux-64", + "timestamp": 1511313202518, + "version": "0.2.0" + }, + "pytorch-0.2.0-py35cuda8.0cudnn5.1_0.tar.bz2": { + "build": "py35cuda8.0cudnn5.1_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn 5.1*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c83e5ff50b514662fec5d0c76d2b6a92", + "name": "pytorch", + "sha256": "70492532fe08db5091b736edfc135ab874d13d4a993b190fb6366d4a54f94f5a", + "size": 179941650, + "subdir": "linux-64", + "timestamp": 1511296338105, + "version": "0.2.0" + }, + "pytorch-0.2.0-py35cuda8.0cudnn6.0_0.tar.bz2": { + "build": "py35cuda8.0cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn 6.0*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6f14a6476be7bc3bfa4a7ed50466b7c8", + "name": "pytorch", + "sha256": "23b5893554f20b643d12effd096f03014d1ebf23f893e7501079bc8a47d65027", + "size": 179932379, + "subdir": "linux-64", + "timestamp": 1511291935214, + "version": "0.2.0" + }, + "pytorch-0.2.0-py36cuda7.5cudnn5.1_0.tar.bz2": { + "build": "py36cuda7.5cudnn5.1_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 7.5*", + "cudnn 5.1*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dbe9355be4fe30d043080313deeb0314", + "name": "pytorch", + "sha256": "6d534255582421376ed9f40111907e4ab2e30f4805358b2fba930ba661f6069c", + "size": 174524999, + "subdir": "linux-64", + "timestamp": 1511322585474, + "version": "0.2.0" + }, + "pytorch-0.2.0-py36cuda7.5cudnn6.0_0.tar.bz2": { + "build": "py36cuda7.5cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 7.5*", + "cudnn 6.0*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b8cd48ef5560612faa0059e47f3386b3", + "name": "pytorch", + "sha256": "db6b14950f9a139d6fd0323954a0704186fa3d62d473517a51808a6aa06c6e72", + "size": 174519372, + "subdir": "linux-64", + "timestamp": 1511310551802, + "version": "0.2.0" + }, + "pytorch-0.2.0-py36cuda8.0cudnn5.1_0.tar.bz2": { + "build": "py36cuda8.0cudnn5.1_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn 5.1*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7eee043164506fa60723fdf7f79fce4a", + "name": "pytorch", + "sha256": "f634e0d294827c51a11b5bad54b60a01f73447a7db3c59fd7087ddedad18f6e6", + "size": 180545483, + "subdir": "linux-64", + "timestamp": 1511297966997, + "version": "0.2.0" + }, + "pytorch-0.2.0-py36cuda8.0cudnn6.0_0.tar.bz2": { + "build": "py36cuda8.0cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn 6.0*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f98393dd7c473a824b0a61e3368a3f83", + "name": "pytorch", + "sha256": "18fa2c65c83ecb349ffb1fd04858f5e366d4b09d8303afbe1520c876426553da", + "size": 180518834, + "subdir": "linux-64", + "timestamp": 1511288343327, + "version": "0.2.0" + }, + "pytorch-0.3.0-py27cuda7.5cudnn6.0_0.tar.bz2": { + "build": "py27cuda7.5cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 7.5*", + "cudnn 6.0*", + "libgcc-ng", + "libstdcxx-ng", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.9", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "02fd50149df1c931721ed78c053af73b", + "name": "pytorch", + "sha256": "03cb2806f827a830be1cacad55e4e4b802262f8c2bf8f2d1aa4ed9e560ada837", + "size": 213147594, + "subdir": "linux-64", + "timestamp": 1512938590533, + "version": "0.3.0" + }, + "pytorch-0.3.0-py27cuda8.0cudnn6.0_0.tar.bz2": { + "build": "py27cuda8.0cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn 6.0*", + "libgcc-ng", + "libstdcxx-ng", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.9", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bc7e269ea609480e229ff93befc1e88a", + "name": "pytorch", + "sha256": "cc1d4eecef29188230f572abc3089b30a6db331b6aebec72843f059b2422e06a", + "size": 220955799, + "subdir": "linux-64", + "timestamp": 1512948516539, + "version": "0.3.0" + }, + "pytorch-0.3.0-py27cuda8.0cudnn7.0_0.tar.bz2": { + "build": "py27cuda8.0cudnn7.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn >=7.0.0,<=8.0a0", + "libgcc-ng", + "libstdcxx-ng", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.9", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b5913c8f0aa440edfbbd87656d5900b6", + "name": "pytorch", + "sha256": "60cc19148c4205b708385f2dbeb1f606544048692559c39a1ab6863c83ade388", + "size": 220947432, + "subdir": "linux-64", + "timestamp": 1513364911738, + "version": "0.3.0" + }, + "pytorch-0.3.0-py35cuda7.5cudnn6.0_0.tar.bz2": { + "build": "py35cuda7.5cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 7.5*", + "cudnn 6.0*", + "libgcc-ng", + "libstdcxx-ng", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.9", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8cbd7a959dc3b8186ca2b524c8871d4e", + "name": "pytorch", + "sha256": "ea8aca16aebac685331e3fd7a4267bbed957b495fef4545e28c5adb5aa59e8ee", + "size": 213573858, + "subdir": "linux-64", + "timestamp": 1512940969339, + "version": "0.3.0" + }, + "pytorch-0.3.0-py35cuda8.0cudnn6.0_0.tar.bz2": { + "build": "py35cuda8.0cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn 6.0*", + "libgcc-ng", + "libstdcxx-ng", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.9", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3fa2d60a546cfb73aa8727c48ab4f076", + "name": "pytorch", + "sha256": "215b4b67dd7b1d76974cba8191aed5b0ba24b90fb6196433baa2113113a0ab58", + "size": 220896231, + "subdir": "linux-64", + "timestamp": 1512955613753, + "version": "0.3.0" + }, + "pytorch-0.3.0-py35cuda8.0cudnn7.0_0.tar.bz2": { + "build": "py35cuda8.0cudnn7.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn >=7.0.0,<=8.0a0", + "libgcc-ng", + "libstdcxx-ng", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.9", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "12d19d5d9d8240aaa279b549a62f2af9", + "name": "pytorch", + "sha256": "a03c12edd8802f26acc1df6aa2bf1acc599c3551a64424de78752457d763a61c", + "size": 220920374, + "subdir": "linux-64", + "timestamp": 1513368308617, + "version": "0.3.0" + }, + "pytorch-0.3.0-py36cuda7.5cudnn6.0_0.tar.bz2": { + "build": "py36cuda7.5cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 7.5*", + "cudnn 6.0*", + "libgcc-ng", + "libstdcxx-ng", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.9", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cae3bbc133b2cd3e9e791e7fa29f6758", + "name": "pytorch", + "sha256": "3e0a58adf3148210d4450fe7a90d7a634dd9563f391c804934f9bc145912d7ad", + "size": 213740911, + "subdir": "linux-64", + "timestamp": 1512945556833, + "version": "0.3.0" + }, + "pytorch-0.3.0-py36cuda8.0cudnn6.0_0.tar.bz2": { + "build": "py36cuda8.0cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn 6.0*", + "libgcc-ng", + "libstdcxx-ng", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.9", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fa44a449583aa8c3ef05d946b3dc3aa0", + "name": "pytorch", + "sha256": "a9433b30cfa7d9aae2b2c5b55cf67be1d3b58317477ebc9bdfaf69961fb11d61", + "size": 221105693, + "subdir": "linux-64", + "timestamp": 1512958673174, + "version": "0.3.0" + }, + "pytorch-0.3.0-py36cuda8.0cudnn7.0_0.tar.bz2": { + "build": "py36cuda8.0cudnn7.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn >=7.0.0,<=8.0a0", + "libgcc-ng", + "libstdcxx-ng", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.9", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dabdc434b05808bd7c9a0f91a65e11d8", + "name": "pytorch", + "sha256": "2cf306719bb5b500d9e6ffc82330c2b7d91f87608c70bdbca86d7e8faee618bf", + "size": 221165132, + "subdir": "linux-64", + "timestamp": 1513370481640, + "version": "0.3.0" + }, + "pytorch-0.3.1-py27had95abb_0.tar.bz2": { + "build": "py27had95abb_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e02705b10807d9c5d6512ebd16279381", + "name": "pytorch", + "sha256": "d3111a964a4d1d150f4685a623d4a73e76df202a0dbc5a9bf72d0e948a6dcc87", + "size": 226254434, + "subdir": "linux-64", + "timestamp": 1522184003162, + "version": "0.3.1" + }, + "pytorch-0.3.1-py27hfbe7015_1.tar.bz2": { + "build": "py27hfbe7015_1", + "build_number": 1, + "depends": [ + "cffi", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7f09773123991e1ff5d3fd77b5759f4b", + "name": "pytorch", + "sha256": "1d049351f381a84c22f07b62cb0063aed9600ca12d5ce90daf946d5f39f9632d", + "size": 226626004, + "subdir": "linux-64", + "timestamp": 1525803263998, + "version": "0.3.1" + }, + "pytorch-0.3.1-py35had95abb_0.tar.bz2": { + "build": "py35had95abb_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "37ccce346c41171fb923d8c6b75d0fac", + "name": "pytorch", + "sha256": "97baa825272ea5a0a610dce14784c5cff69f2cd69240753dfd4452c52e553476", + "size": 226570239, + "subdir": "linux-64", + "timestamp": 1522184941712, + "version": "0.3.1" + }, + "pytorch-0.3.1-py35hfbe7015_1.tar.bz2": { + "build": "py35hfbe7015_1", + "build_number": 1, + "depends": [ + "cffi", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "beab1d7aecdcaf6de6c5851dcf3a1d29", + "name": "pytorch", + "sha256": "1b28a75e923a9fa6663a3f11fb52708a0959f7e1854741f0e8aff2169262461d", + "size": 226442226, + "subdir": "linux-64", + "timestamp": 1525798856325, + "version": "0.3.1" + }, + "pytorch-0.3.1-py36had95abb_0.tar.bz2": { + "build": "py36had95abb_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4b68f0cb9bce8fa26d5170f46d7d82eb", + "name": "pytorch", + "sha256": "d336968a379537d5e549c0b5b79362abb33a5b98d932fe935f97686529aaa356", + "size": 226301259, + "subdir": "linux-64", + "timestamp": 1522185207380, + "version": "0.3.1" + }, + "pytorch-0.3.1-py36hfbe7015_1.tar.bz2": { + "build": "py36hfbe7015_1", + "build_number": 1, + "depends": [ + "cffi", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5889bb2d4b5b2f14c2fb510857746361", + "name": "pytorch", + "sha256": "cda7758943dec04c38d7e2b9a1c663f5884a556c8b3512e5b2a073a353b33401", + "size": 226639184, + "subdir": "linux-64", + "timestamp": 1525801057965, + "version": "0.3.1" + }, + "pytorch-0.4.0-py27hd73e86b_0.tar.bz2": { + "build": "py27hd73e86b_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9e026afc2e8abac14558acbdda4b79ea", + "name": "pytorch", + "sha256": "1a5cf012f95350a12d1299c7112d77b569b9ad7fb0dc8d62f69944d6df3a4ff4", + "size": 236791850, + "subdir": "linux-64", + "timestamp": 1525818215514, + "version": "0.4.0" + }, + "pytorch-0.4.0-py27hdf912b8_0.tar.bz2": { + "build": "py27hdf912b8_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e7ec81123907db5024f05ee82d5146ef", + "name": "pytorch", + "sha256": "c4f59fa619bba4b4c232ac7659f07db7665f64393f366efc7588dd5c272c2b55", + "size": 235446400, + "subdir": "linux-64", + "timestamp": 1525916432634, + "version": "0.4.0" + }, + "pytorch-0.4.0-py35hd73e86b_0.tar.bz2": { + "build": "py35hd73e86b_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ae0b19ccb0b397b02ab602629f4ab190", + "name": "pytorch", + "sha256": "25393a15175d2a43be24efcef871efedd06924d33f3421e522ee2c001813640e", + "size": 235831737, + "subdir": "linux-64", + "timestamp": 1525815882232, + "version": "0.4.0" + }, + "pytorch-0.4.0-py35hdf912b8_0.tar.bz2": { + "build": "py35hdf912b8_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "88fb28cc63783039e7a2223736eaf4fc", + "name": "pytorch", + "sha256": "7c14c37d76be43b44c1ee3698e544f1d6a45472fbb1af1cbee727be5335fbeb9", + "size": 235458314, + "subdir": "linux-64", + "timestamp": 1525911768205, + "version": "0.4.0" + }, + "pytorch-0.4.0-py36hd73e86b_0.tar.bz2": { + "build": "py36hd73e86b_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3b866a6e6613fcdf8beeceb7c662e577", + "name": "pytorch", + "sha256": "992eb04b2c7c60e73e85f35a66a128569902a05e8fc59ee97dcfa82fdd33840f", + "size": 236110280, + "subdir": "linux-64", + "timestamp": 1525813784282, + "version": "0.4.0" + }, + "pytorch-0.4.0-py36hdf912b8_0.tar.bz2": { + "build": "py36hdf912b8_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "add7a1a9359d201870fded36b1eaeba1", + "name": "pytorch", + "sha256": "0123268626f4489e1382c8ea385da52c77caf8889b4af6106d0c06d5f20cecf1", + "size": 235794919, + "subdir": "linux-64", + "timestamp": 1525914087750, + "version": "0.4.0" + }, + "pytorch-0.4.1-py27ha74772b_0.tar.bz2": { + "build": "py27ha74772b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d70a66fa30a479ecc117d798fcafb7fd", + "name": "pytorch", + "sha256": "a2f884be0f679cfb2ecaee85ad0aba237afc8d44500fc6903edd9c34e946bf4d", + "size": 226074103, + "subdir": "linux-64", + "timestamp": 1533676010655, + "version": "0.4.1" + }, + "pytorch-0.4.1-py35ha74772b_0.tar.bz2": { + "build": "py35ha74772b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "98dd29750df5ea84fa2a47b9413d1043", + "name": "pytorch", + "sha256": "4f547ad35c6ec4e8a7cfc618af22346122e7bedf4ce8b109778b05c89ea9951c", + "size": 226756193, + "subdir": "linux-64", + "timestamp": 1533677581501, + "version": "0.4.1" + }, + "pytorch-0.4.1-py36ha74772b_0.tar.bz2": { + "build": "py36ha74772b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "33f2a333a33ce125f2af7a94bccd2110", + "name": "pytorch", + "sha256": "9fa417ee62b4ca736ed0a68d478245771a0e93b1b95d24d8900b624093c43b66", + "size": 226259901, + "subdir": "linux-64", + "timestamp": 1533673696390, + "version": "0.4.1" + }, + "pytorch-0.4.1-py37ha74772b_0.tar.bz2": { + "build": "py37ha74772b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4f364adc4c083fdffcdceda6e93a27f7", + "name": "pytorch", + "sha256": "eb4bcf6a968798eaed1c9f5b192f350be0509c945b255be7279729b1e3b40744", + "size": 226269644, + "subdir": "linux-64", + "timestamp": 1533741208857, + "version": "0.4.1" + }, + "pytorch-1.0.1-cuda100py27he554f03_0.tar.bz2": { + "build": "cuda100py27he554f03_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f9f7491ba8f301e4399fa62ef1854c6f", + "name": "pytorch", + "sha256": "a8436fe9e65f0c22976685e300dee3fff14fdc091ebb5bc2a9210b84a9f80eb7", + "size": 362203889, + "subdir": "linux-64", + "timestamp": 1550805483195, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda100py36he554f03_0.tar.bz2": { + "build": "cuda100py36he554f03_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "03b20e09026bbff9655bb004b690349e", + "name": "pytorch", + "sha256": "2d94062dda1340a5c8de468d6242723280a86761cad1ce57ca8f3e089c001d6d", + "size": 361790260, + "subdir": "linux-64", + "timestamp": 1550809114539, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda100py37he554f03_0.tar.bz2": { + "build": "cuda100py37he554f03_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4ff61d57c62963716d6f0b32345f4138", + "name": "pytorch", + "sha256": "c3d74c5126c82c410a72382873a0d1c77973fcb2280a723aac805d32e9734730", + "size": 361340025, + "subdir": "linux-64", + "timestamp": 1550799600670, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda80py27ha8650f8_0.tar.bz2": { + "build": "cuda80py27ha8650f8_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=8.0,<8.1.0a0", + "cudnn >=7.1.3,<8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "86746a9a98a890bed98c5fefab72f971", + "name": "pytorch", + "sha256": "9b732535e5f3f0a089eca64d4be05f2ca92555226d5b4c4bde8b1dd505fe572a", + "size": 322115045, + "subdir": "linux-64", + "timestamp": 1550815748825, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda80py36ha8650f8_0.tar.bz2": { + "build": "cuda80py36ha8650f8_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=8.0,<8.1.0a0", + "cudnn >=7.1.3,<8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4542c30c9e362dd17fb4dcfbd6ac30a6", + "name": "pytorch", + "sha256": "d77435dfbf51098f6f5d4be9f2eab6522a4cce64df02710e1f3565c7160f1bbe", + "size": 322101310, + "subdir": "linux-64", + "timestamp": 1550821306010, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda80py37ha8650f8_0.tar.bz2": { + "build": "cuda80py37ha8650f8_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=8.0,<8.1.0a0", + "cudnn >=7.1.3,<8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5bf6666a0d41241e0f53d0798ca750a1", + "name": "pytorch", + "sha256": "3db47d6dd3d499e4f7be1951eb55f92dee70111292cce4d587c546a31f09420a", + "size": 322109981, + "subdir": "linux-64", + "timestamp": 1550818498974, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda90py27h8b0c50b_0.tar.bz2": { + "build": "cuda90py27h8b0c50b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2ac82725f8aa34d5d10b0e14ee54e475", + "name": "pytorch", + "sha256": "c7eb0946a98593cb2d6d9883009237ee44f327749e8c5ad2c797042da67f023d", + "size": 353875667, + "subdir": "linux-64", + "timestamp": 1550789930353, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda90py36h8b0c50b_0.tar.bz2": { + "build": "cuda90py36h8b0c50b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "51fc5ec157900e8bbc5812ef4c0c0522", + "name": "pytorch", + "sha256": "f1613040f061f730f5a502a6104c37dc1419b7860b53dd886ae5815961267686", + "size": 353693151, + "subdir": "linux-64", + "timestamp": 1550783418468, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda90py37h8b0c50b_0.tar.bz2": { + "build": "cuda90py37h8b0c50b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b88adfadbf6b7780b0895a12b8a26d3c", + "name": "pytorch", + "sha256": "efbe335c9978d0b44c1b255402bdc140d853dcf3aca37d13b545e38358aafe11", + "size": 353794307, + "subdir": "linux-64", + "timestamp": 1550786846140, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda92py27h65efead_0.tar.bz2": { + "build": "cuda92py27h65efead_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "734444367a9e654c476e38834a1eab06", + "name": "pytorch", + "sha256": "eb57cea2869f5b27f2475399b7a1b25eead2b1161684b233fba58e8e3e5b0e07", + "size": 330784588, + "subdir": "linux-64", + "timestamp": 1550854900948, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda92py36h65efead_0.tar.bz2": { + "build": "cuda92py36h65efead_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a06ed7b4df0ed76fa286b0468f2b48d2", + "name": "pytorch", + "sha256": "c5bbb0e8db39990f6890e5fcd32e0e6db80a33fa0ca860a824573bd8ebda0f3d", + "size": 330607723, + "subdir": "linux-64", + "timestamp": 1550858153151, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda92py37h65efead_0.tar.bz2": { + "build": "cuda92py37h65efead_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "717e18b78b145628db7da9979af4c2ce", + "name": "pytorch", + "sha256": "e36b64051bcf597dfc4d9e7fd48749df6583a7f2eb85f8e8b39a98b2f1007d08", + "size": 330832215, + "subdir": "linux-64", + "timestamp": 1550851566912, + "version": "1.0.1" + }, + "pytorch-1.1.0-cuda100py27he554f03_0.tar.bz2": { + "build": "cuda100py27he554f03_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "540b9a747cdd122ce9d9a941e562a394", + "name": "pytorch", + "sha256": "fa3706fb7748cf72a684bdc2beb35cda29f1567b562edc13edbaebadf394a88b", + "size": 429956545, + "subdir": "linux-64", + "timestamp": 1565118943587, + "version": "1.1.0" + }, + "pytorch-1.1.0-cuda100py36he554f03_0.tar.bz2": { + "build": "cuda100py36he554f03_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5373fe53820a96a3e620082ca7427b13", + "name": "pytorch", + "sha256": "bbc6b98b17dd44726c0b01e9b270ef7d3ba9df5583114490d13afcf3674883c0", + "size": 429036838, + "subdir": "linux-64", + "timestamp": 1565123236053, + "version": "1.1.0" + }, + "pytorch-1.1.0-cuda100py37he554f03_0.tar.bz2": { + "build": "cuda100py37he554f03_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7cf11302dbbb85a236471bc17261c3f7", + "name": "pytorch", + "sha256": "9c1acc35610c8845e13ab2a2ba59ddbaf2a34ed5d5b869eeb03b504eb28f50cb", + "size": 430100412, + "subdir": "linux-64", + "timestamp": 1565127161473, + "version": "1.1.0" + }, + "pytorch-1.1.0-cuda90py27h8b0c50b_0.tar.bz2": { + "build": "cuda90py27h8b0c50b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "future", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0419d41b7338e1e9d41363c0c0d587f3", + "name": "pytorch", + "sha256": "65c638f8c21a3715797eaefa754d45ee3a6f5a653d0ae9a0c41d60e0f4f1c593", + "size": 422552558, + "subdir": "linux-64", + "timestamp": 1565132813553, + "version": "1.1.0" + }, + "pytorch-1.1.0-cuda90py36h8b0c50b_0.tar.bz2": { + "build": "cuda90py36h8b0c50b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d0083d46f153065bb518666aaad8d78a", + "name": "pytorch", + "sha256": "7d21d3b98836fb9e4f45a67218dff926f0f3e3a4b5079ad4ca60f52176803823", + "size": 422198130, + "subdir": "linux-64", + "timestamp": 1565138062664, + "version": "1.1.0" + }, + "pytorch-1.1.0-cuda90py37h8b0c50b_0.tar.bz2": { + "build": "cuda90py37h8b0c50b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3f6ddbd7fd2760f71e28c6e69a256ca6", + "name": "pytorch", + "sha256": "16c8d85a9a627a8bc6beab87901f7485f2e5512a85877f813f334a66be2bced9", + "size": 422838462, + "subdir": "linux-64", + "timestamp": 1565142965522, + "version": "1.1.0" + }, + "pytorch-1.1.0-cuda92py27h65efead_0.tar.bz2": { + "build": "cuda92py27h65efead_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "38fa796e26495a36075168f8e40e0c16", + "name": "pytorch", + "sha256": "a455e934b75550683e01a9b41b951b275ad5eefec7fe3d1a406baed014b26d28", + "size": 395212930, + "subdir": "linux-64", + "timestamp": 1565159440373, + "version": "1.1.0" + }, + "pytorch-1.1.0-cuda92py36h65efead_0.tar.bz2": { + "build": "cuda92py36h65efead_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "af9df6340b69d5d13b63270b7cdfb18f", + "name": "pytorch", + "sha256": "f2054b56b0847f4d34783adb0a5ba179c9c4d6f1deaddff79f8e6cb6689db3e9", + "size": 395142557, + "subdir": "linux-64", + "timestamp": 1565155249591, + "version": "1.1.0" + }, + "pytorch-1.1.0-cuda92py37h65efead_0.tar.bz2": { + "build": "cuda92py37h65efead_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9095a425ec61ba0459fc8416d76616cf", + "name": "pytorch", + "sha256": "c0b200052d44f8da33fb5eebeb5395184045cb9791014657800db770b2668c3e", + "size": 395285964, + "subdir": "linux-64", + "timestamp": 1565150977158, + "version": "1.1.0" + }, + "pytorch-1.10.2-cpu_py310h6894f24_0.tar.bz2": { + "build": "cpu_py310h6894f24_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "mkl 2021.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "25503ecc9356aa28a1ad1da90b183b7d", + "name": "pytorch", + "sha256": "8cbf19d4924dcffaa97d893fb6710f6144ad3e9a2cbeb5d8e39c0637c6024e05", + "size": 58761522, + "subdir": "linux-64", + "timestamp": 1648025297995, + "version": "1.10.2" + }, + "pytorch-1.10.2-cpu_py37hfa7516b_0.tar.bz2": { + "build": "cpu_py37hfa7516b_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "mkl 2021.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.21.2,<2.0a0", + "python >=3.7,<3.8.0a0", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3e05729c5c0dcde3e42d8dbbcc5fb2ea", + "name": "pytorch", + "sha256": "04afdfdb9866336a6a03756115d87183a05bc11c72523eeaee3f1a61bb004e42", + "size": 58672170, + "subdir": "linux-64", + "timestamp": 1648020263123, + "version": "1.10.2" + }, + "pytorch-1.10.2-cpu_py38hfa7516b_0.tar.bz2": { + "build": "cpu_py38hfa7516b_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "mkl 2021.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.21.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ea70a7483ac5ce4429431d71c29815b5", + "name": "pytorch", + "sha256": "acb4d826123123c94821d4f5b5d35a2965775082461c97823c41dc19ef21972f", + "size": 58645093, + "subdir": "linux-64", + "timestamp": 1648030298116, + "version": "1.10.2" + }, + "pytorch-1.10.2-cpu_py39hfa7516b_0.tar.bz2": { + "build": "cpu_py39hfa7516b_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "mkl 2021.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.21.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "96c4d49a9e563fe01206dd7b71d711dd", + "name": "pytorch", + "sha256": "03f55f9fd20cb0ca097a5633a8810fc8a19865d9e555c2fca32aaf15028a40bf", + "size": 58701580, + "subdir": "linux-64", + "timestamp": 1648035490691, + "version": "1.10.2" + }, + "pytorch-1.12.1-cpu_py310h9dbd814_1.tar.bz2": { + "build": "cpu_py310h9dbd814_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "cffi", + "future", + "libgcc-ng >=11.2.0", + "libopenblas", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "ninja", + "numpy >=1.21,<2", + "python >=3.10,<3.11.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1116601a8e96756df8cfbba33d69c491", + "name": "pytorch", + "sha256": "0c3f60b158fafa624d20c92ef09d33fb20f515d3ca1bbaa8836558d76c0185c7", + "size": 55918557, + "subdir": "linux-64", + "timestamp": 1675220680853, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py310hb1f1ab4_1.tar.bz2": { + "build": "cpu_py310hb1f1ab4_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.21,<2", + "python >=3.10,<3.11.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bd18277bbe2b06ae1755498d0b238dcf", + "name": "pytorch", + "sha256": "89f0eb611b2bd9c2b067fb9568d93f78ffaa6429d5220787cd2a6141e9a5d7e1", + "size": 65467538, + "subdir": "linux-64", + "timestamp": 1675194110885, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py310he8d8e81_0.tar.bz2": { + "build": "cpu_py310he8d8e81_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.21.2,<2", + "python >=3.10,<3.11.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "274d4497530ce5496a7fc5cb9bf33885", + "name": "pytorch", + "sha256": "ef6904b4f3109cf22aa84a29cc47ae34d6461022343881ab2c7f810a82ae391b", + "size": 69872963, + "subdir": "linux-64", + "timestamp": 1669264507374, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py37h9dbd814_1.tar.bz2": { + "build": "cpu_py37h9dbd814_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "cffi", + "future", + "libgcc-ng >=11.2.0", + "libopenblas", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "ninja", + "numpy >=1.19,<2", + "python >=3.7,<3.8.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ac4eecfb2a02bd9ef5ab2166c4ee08e6", + "name": "pytorch", + "sha256": "df0c8d0d906f012c769497f0e66f47c335d478a53ca9cd6f17211a34888af492", + "size": 55750349, + "subdir": "linux-64", + "timestamp": 1675239278886, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py37hb1f1ab4_1.tar.bz2": { + "build": "cpu_py37hb1f1ab4_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.19,<2", + "python >=3.7,<3.8.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c02c286d3ff7278a3210eeee2e798df5", + "name": "pytorch", + "sha256": "abe089a980b01a80b539c14b7658628aa1a9bef5ce3b7aabf8b7224ab152670c", + "size": 65361813, + "subdir": "linux-64", + "timestamp": 1675214459220, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py37he8d8e81_0.tar.bz2": { + "build": "cpu_py37he8d8e81_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.19.2,<2", + "python >=3.7,<3.8.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee88dd7aa8bb0dda5bfd5b925ea41772", + "name": "pytorch", + "sha256": "9f593b589ae72c46c271b4a4e4b0d5b10be6b7dc04de51d4f6e0c062b05953e5", + "size": 69780571, + "subdir": "linux-64", + "timestamp": 1669257900992, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py38h9dbd814_1.tar.bz2": { + "build": "cpu_py38h9dbd814_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "cffi", + "future", + "libgcc-ng >=11.2.0", + "libopenblas", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "ninja", + "numpy >=1.19,<2", + "python >=3.8,<3.9.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b9250067d3a2f9e28e94821154951442", + "name": "pytorch", + "sha256": "d9b175e4ba8d37130b74bfb74a7c5a555f13bf67f7a77c40b978a084e94b712e", + "size": 55852062, + "subdir": "linux-64", + "timestamp": 1675233061380, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py38hb1f1ab4_1.tar.bz2": { + "build": "cpu_py38hb1f1ab4_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.19,<2", + "python >=3.8,<3.9.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "685dd505f597c0ac4d7e64cdb50bd10a", + "name": "pytorch", + "sha256": "56d834e6261d805b6ef42c9a5f4941f87f5246991117d4da2fe2fdb9e9c67299", + "size": 65364245, + "subdir": "linux-64", + "timestamp": 1675207653332, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py38he8d8e81_0.tar.bz2": { + "build": "cpu_py38he8d8e81_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.19.2,<2", + "python >=3.8,<3.9.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3818de733db1a7cdd1d6e08af5c8168e", + "name": "pytorch", + "sha256": "815397425837062f86391611c39f8ca291d9f2850254586522e5ad7bdf362e3b", + "size": 69855545, + "subdir": "linux-64", + "timestamp": 1669277685026, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py39h9dbd814_1.tar.bz2": { + "build": "cpu_py39h9dbd814_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "cffi", + "future", + "libgcc-ng >=11.2.0", + "libopenblas", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "ninja", + "numpy >=1.19,<2", + "python >=3.9,<3.10.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5b982d28f089dc85546d956b7e3451f3", + "name": "pytorch", + "sha256": "974a59267fa4bdaef488e98e859b76ecc47ebcc18a63fb67c72f05139a727777", + "size": 55852077, + "subdir": "linux-64", + "timestamp": 1675226890806, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py39hb1f1ab4_1.tar.bz2": { + "build": "cpu_py39hb1f1ab4_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.19,<2", + "python >=3.9,<3.10.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "81f3694d68af2f4ffbcc6fb672da5088", + "name": "pytorch", + "sha256": "3b6081957b7909115f78a4855a916b2c006beba22e241d5b7ffca3b9fba3e072", + "size": 65369508, + "subdir": "linux-64", + "timestamp": 1675200894815, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py39he8d8e81_0.tar.bz2": { + "build": "cpu_py39he8d8e81_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.19.2,<2", + "python >=3.9,<3.10.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a081fa8caa2291e24b178c66f18d57b", + "name": "pytorch", + "sha256": "ba3e28b56c016845b01dc001b8a70b00733cbf55bdbdc64c933b5879cd798e92", + "size": 69863936, + "subdir": "linux-64", + "timestamp": 1669271105174, + "version": "1.12.1" + }, + "pytorch-1.12.1-gpu_cuda113py310h19ae3d8_1.tar.bz2": { + "build": "gpu_cuda113py310h19ae3d8_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=11.3.1,<11.4.0a0", + "cudnn >=8.2,<9.0a0", + "cudnn >=8.2.1,<9.0a0", + "cupti", + "future", + "libgcc-ng >=9.3.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "magma", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.21,<2", + "python >=3.10,<3.11.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "494d8a23fda23e588e5dc74c876c2e11", + "name": "pytorch", + "sha256": "8ff4fed627438e17073663ad4374d611a752370c97afdea7ba43eb4effaddfa8", + "size": 650938915, + "subdir": "linux-64", + "timestamp": 1673635168015, + "version": "1.12.1" + }, + "pytorch-1.12.1-gpu_cuda113py37h19ae3d8_1.tar.bz2": { + "build": "gpu_cuda113py37h19ae3d8_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=11.3.1,<11.4.0a0", + "cudnn >=8.2,<9.0a0", + "cudnn >=8.2.1,<9.0a0", + "cupti", + "future", + "libgcc-ng >=9.3.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "magma", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.19,<2", + "python >=3.7,<3.8.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e0a11ff0a4e106151950ca72ac1026a8", + "name": "pytorch", + "sha256": "764b6b22716895ba646557fd98fd60d59462bd3fa55cfa212d4012526e398469", + "size": 649661097, + "subdir": "linux-64", + "timestamp": 1673677585762, + "version": "1.12.1" + }, + "pytorch-1.12.1-gpu_cuda113py38h19ae3d8_1.tar.bz2": { + "build": "gpu_cuda113py38h19ae3d8_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=11.3.1,<11.4.0a0", + "cudnn >=8.2,<9.0a0", + "cudnn >=8.2.1,<9.0a0", + "cupti", + "future", + "libgcc-ng >=9.3.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "magma", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.19,<2", + "python >=3.8,<3.9.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c6f21b709c72f770b97b27e7280fbd28", + "name": "pytorch", + "sha256": "74cc41fda726c192b282c0984e9a2a46fd49221b7f33fa0a38aff57cb295e006", + "size": 651061811, + "subdir": "linux-64", + "timestamp": 1673656407835, + "version": "1.12.1" + }, + "pytorch-1.12.1-gpu_cuda113py39h19ae3d8_1.tar.bz2": { + "build": "gpu_cuda113py39h19ae3d8_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=11.3.1,<11.4.0a0", + "cudnn >=8.2,<9.0a0", + "cudnn >=8.2.1,<9.0a0", + "cupti", + "future", + "libgcc-ng >=9.3.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "magma", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.19,<2", + "python >=3.9,<3.10.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fb80823102e82125b5eed40b6bccee73", + "name": "pytorch", + "sha256": "3231723871e6f2ef2124675e5735cb3c996e4628b282513ca5712a8520a30d0c", + "size": 651053215, + "subdir": "linux-64", + "timestamp": 1673613939222, + "version": "1.12.1" + }, + "pytorch-1.2.0-cpu_py27h00be3c6_0.tar.bz2": { + "build": "cpu_py27h00be3c6_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e6a63a77e613880e96035823c134d136", + "name": "pytorch", + "sha256": "db0ad113735550474ba133436fc5785c9ac2bc4d9bf18c607a39c9a09656e515", + "size": 28880839, + "subdir": "linux-64", + "timestamp": 1566785162389, + "version": "1.2.0" + }, + "pytorch-1.2.0-cpu_py36h00be3c6_0.tar.bz2": { + "build": "cpu_py36h00be3c6_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2ef2e543e7dd2b735dc3eaab643cf778", + "name": "pytorch", + "sha256": "d69a1e7df17f0d659d8ebdba161fc2e78fb15b045a239154eae1b6ec38eb2f78", + "size": 28895322, + "subdir": "linux-64", + "timestamp": 1566788476310, + "version": "1.2.0" + }, + "pytorch-1.2.0-cpu_py37h00be3c6_0.tar.bz2": { + "build": "cpu_py37h00be3c6_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8742e28b0624095ae983c09cdd4298da", + "name": "pytorch", + "sha256": "d5d52851d8ee432d3081fbd43ff0a4999f41d7a0da7df0538ebdab758436bfa7", + "size": 28914346, + "subdir": "linux-64", + "timestamp": 1566769146059, + "version": "1.2.0" + }, + "pytorch-1.2.0-cuda100py27h938c94c_0.tar.bz2": { + "build": "cuda100py27h938c94c_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit 10.0.*", + "cudnn >=7.3.0,<=8.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "40f3f2975829de54a625da581bf22b8f", + "name": "pytorch", + "sha256": "9d85ba06380b1b18b4f653990d418349d88ec206c59d71704642dd2086ab8822", + "size": 316987043, + "subdir": "linux-64", + "timestamp": 1566798165213, + "version": "1.2.0" + }, + "pytorch-1.2.0-cuda100py36h938c94c_0.tar.bz2": { + "build": "cuda100py36h938c94c_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit 10.0.*", + "cudnn >=7.3.0,<=8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "84013757c9c4670c26abd36687a24a3e", + "name": "pytorch", + "sha256": "14f012e9812917fcb632f2b064d5e183235be3c1fab2e59bdd6a698173d2327e", + "size": 317012010, + "subdir": "linux-64", + "timestamp": 1566807239409, + "version": "1.2.0" + }, + "pytorch-1.2.0-cuda100py37h938c94c_0.tar.bz2": { + "build": "cuda100py37h938c94c_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit 10.0.*", + "cudnn >=7.3.0,<=8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "140e93b6d48413be718e57d1867c981c", + "name": "pytorch", + "sha256": "c7c47d59fb7ccc3d00d32333dd8313170ea6754d9b0adfc37bef1b047cf9d7ce", + "size": 318061615, + "subdir": "linux-64", + "timestamp": 1566816157725, + "version": "1.2.0" + }, + "pytorch-1.2.0-cuda92py27hd3e106c_0.tar.bz2": { + "build": "cuda92py27hd3e106c_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit 9.2.*", + "cudnn >=7.3.0,<=8.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "793c6af90ed62c964e28b046e0b071c6", + "name": "pytorch", + "sha256": "a53f772a224485df7436d4b2aa2c5d44e249e2fb43eee98831eeaaa51a845697", + "size": 282176733, + "subdir": "linux-64", + "timestamp": 1566783471689, + "version": "1.2.0" + }, + "pytorch-1.2.0-cuda92py36hd3e106c_0.tar.bz2": { + "build": "cuda92py36hd3e106c_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit 9.2.*", + "cudnn >=7.3.0,<=8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bf595149289a19397c206881d5bf271a", + "name": "pytorch", + "sha256": "c147faae82932e18799ba6440d87f16b6a1b74aa7acabbe800b1e7d3d14bc928", + "size": 282601286, + "subdir": "linux-64", + "timestamp": 1566775235615, + "version": "1.2.0" + }, + "pytorch-1.2.0-cuda92py37hd3e106c_0.tar.bz2": { + "build": "cuda92py37hd3e106c_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit 9.2.*", + "cudnn >=7.3.0,<=8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "07f5dd18a3e210e97cead8b4f1e34c43", + "name": "pytorch", + "sha256": "591296e3217ed46f68b6fdca62c572cbf2e8d97564b31a56d19db10abbebd840", + "size": 282242102, + "subdir": "linux-64", + "timestamp": 1566766137261, + "version": "1.2.0" + }, + "pytorch-1.3.1-cpu_py27h62f834f_0.tar.bz2": { + "build": "cpu_py27h62f834f_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "typing" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bb57e7afa9fe56f3f84b39492b6132f3", + "name": "pytorch", + "sha256": "c705777ff441c827639db74c034af3da16274d738e93be4f61ee918653e3037d", + "size": 32604024, + "subdir": "linux-64", + "timestamp": 1574373434802, + "version": "1.3.1" + }, + "pytorch-1.3.1-cpu_py36h62f834f_0.tar.bz2": { + "build": "cpu_py36h62f834f_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f76074535af8aaffa951fc896740cf6c", + "name": "pytorch", + "sha256": "6180ec6e3d912500dd8a41ae67d529ce37fc011cf31f51d2d2031e7643e1f6b2", + "size": 32571639, + "subdir": "linux-64", + "timestamp": 1574378445624, + "version": "1.3.1" + }, + "pytorch-1.3.1-cpu_py37h62f834f_0.tar.bz2": { + "build": "cpu_py37h62f834f_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ab5753e95d78bd620d6affb6757f8abd", + "name": "pytorch", + "sha256": "bf7088bf06dfa6055f0dfebdf53969dcc9f2321bcb9359199d79650cc5938d0c", + "size": 32486822, + "subdir": "linux-64", + "timestamp": 1574376307663, + "version": "1.3.1" + }, + "pytorch-1.3.1-cuda100py27h53c1284_0.tar.bz2": { + "build": "cuda100py27h53c1284_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.4,<8.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "typing" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dd95db97e41612f5a30ddc2396f0db32", + "name": "pytorch", + "sha256": "945334ad4688eb191ec93d4703924c5c2c817867358829ddaffbd8fbd26f24b1", + "size": 309917644, + "subdir": "linux-64", + "timestamp": 1574410757057, + "version": "1.3.1" + }, + "pytorch-1.3.1-cuda100py36h53c1284_0.tar.bz2": { + "build": "cuda100py36h53c1284_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.4,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "145db9f1acd0cc640d7c2012b27f042f", + "name": "pytorch", + "sha256": "4aeccce7caa0c41794ecf290a793f611cc1a1cd72f945e0b2d0dcb5f29ce3c71", + "size": 309824498, + "subdir": "linux-64", + "timestamp": 1574400501705, + "version": "1.3.1" + }, + "pytorch-1.3.1-cuda100py37h53c1284_0.tar.bz2": { + "build": "cuda100py37h53c1284_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.4,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ac02f362ebea16ad5fd4710a1d0cf76e", + "name": "pytorch", + "sha256": "0488750c51d59fec8e20b0e99cfb8df6e1a12db670ba97f5a510ab0a5be72faf", + "size": 309260807, + "subdir": "linux-64", + "timestamp": 1574390294838, + "version": "1.3.1" + }, + "pytorch-1.3.1-cuda92py27hb0ba70e_0.tar.bz2": { + "build": "cuda92py27hb0ba70e_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.4,<8.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "typing" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e92b71dd050246476e5f46c778ac2e4f", + "name": "pytorch", + "sha256": "150090361eb49bf90dcb85cf45727f5bc02b030017f9d6161477f41eb28a4be3", + "size": 277002478, + "subdir": "linux-64", + "timestamp": 1574478507115, + "version": "1.3.1" + }, + "pytorch-1.3.1-cuda92py36hb0ba70e_0.tar.bz2": { + "build": "cuda92py36hb0ba70e_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.4,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "089e4cb2fe7e60148f2af5223bb9a119", + "name": "pytorch", + "sha256": "06930d41510db6b2c286c14322fdcf052335921da064cfa5098bfe4a7df5291d", + "size": 277332773, + "subdir": "linux-64", + "timestamp": 1574469543370, + "version": "1.3.1" + }, + "pytorch-1.3.1-cuda92py37hb0ba70e_0.tar.bz2": { + "build": "cuda92py37hb0ba70e_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.4,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cc4db45821894ffcb4398dca4d5a1765", + "name": "pytorch", + "sha256": "e8192bc4e6765ad1c12cf4c65b98b872319217390ee22bac79f90a2259d909c6", + "size": 276965088, + "subdir": "linux-64", + "timestamp": 1574459959105, + "version": "1.3.1" + }, + "pytorch-1.4.0-cpu_py36h7e40bad_0.tar.bz2": { + "build": "cpu_py36h7e40bad_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "16b53f1cecb190b23b790daf7298337d", + "name": "pytorch", + "sha256": "3ab6dd52b6e4237c15220e734eb23d43f588d6f8d7add91ed23ec34eaced10c8", + "size": 35426769, + "subdir": "linux-64", + "timestamp": 1584029167192, + "version": "1.4.0" + }, + "pytorch-1.4.0-cpu_py37h7e40bad_0.tar.bz2": { + "build": "cpu_py37h7e40bad_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ae0f4e09ae8e8b14b44a6952b559503a", + "name": "pytorch", + "sha256": "186c924eeaf3d1f43da0c5488d58ba48bc23ae247cb4c7ef9a3bf4f89bfc8ff8", + "size": 35375005, + "subdir": "linux-64", + "timestamp": 1584031123580, + "version": "1.4.0" + }, + "pytorch-1.4.0-cpu_py38h7e40bad_0.tar.bz2": { + "build": "cpu_py38h7e40bad_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2f4eb73f97e4afcc34f1d2a038cd8c26", + "name": "pytorch", + "sha256": "2d31277ea67e7d0fa0f3b235d91cc78e653d15082eead2dcd01cc67a742b32fb", + "size": 35445555, + "subdir": "linux-64", + "timestamp": 1584054103142, + "version": "1.4.0" + }, + "pytorch-1.4.0-cuda100py36h75a84eb_0.tar.bz2": { + "build": "cuda100py36h75a84eb_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a696b8c6be3f88096462e2af8950085d", + "name": "pytorch", + "sha256": "4f5ae00d94d74b923b4659ce09a7d56ebe5a26efa65b308fdb14ee7c34feaf63", + "size": 315501324, + "subdir": "linux-64", + "timestamp": 1584374430194, + "version": "1.4.0" + }, + "pytorch-1.4.0-cuda100py37h75a84eb_0.tar.bz2": { + "build": "cuda100py37h75a84eb_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "07f8d941677199483d948d35ddb65186", + "name": "pytorch", + "sha256": "936066a208266ba360231bd95f153ea769337f0b64fa52efd5f1fc5e3c057c56", + "size": 315586246, + "subdir": "linux-64", + "timestamp": 1584394896014, + "version": "1.4.0" + }, + "pytorch-1.4.0-cuda100py38h75a84eb_0.tar.bz2": { + "build": "cuda100py38h75a84eb_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fcee7da8f277b16ba8e37be78ddfb979", + "name": "pytorch", + "sha256": "bb17bc7c4b7e70bac53c2efb4f7d1f7ff50d3f387eca413d8de3f8fa2ae63557", + "size": 314890807, + "subdir": "linux-64", + "timestamp": 1584384608285, + "version": "1.4.0" + }, + "pytorch-1.4.0-cuda101py36h02f0884_0.tar.bz2": { + "build": "cuda101py36h02f0884_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a130d6b4e4597025932cfdff4c2ec0e2", + "name": "pytorch", + "sha256": "8f01699c3ef620cf9709f0996a4795d0799fb5bc90fe236ca57ab46f3e728777", + "size": 316383123, + "subdir": "linux-64", + "timestamp": 1584552362205, + "version": "1.4.0" + }, + "pytorch-1.4.0-cuda101py37h02f0884_0.tar.bz2": { + "build": "cuda101py37h02f0884_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1e31e9e4ef4e212b22a2b066e5c259f6", + "name": "pytorch", + "sha256": "f98d9f0002a5dcf4713fa60953b1c64304ce3c4c99fcf9f4e379d252b251e94f", + "size": 316792737, + "subdir": "linux-64", + "timestamp": 1584562373020, + "version": "1.4.0" + }, + "pytorch-1.4.0-cuda101py38h02f0884_0.tar.bz2": { + "build": "cuda101py38h02f0884_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "88cefd0e4783d9281b0839e3fb1ece65", + "name": "pytorch", + "sha256": "54d6d1d133be4e4ab0d6e72d27d31d4d8f0e869e44fb58f7e4966afd93951797", + "size": 317554829, + "subdir": "linux-64", + "timestamp": 1584572523873, + "version": "1.4.0" + }, + "pytorch-1.4.0-cuda92py36h488537e_0.tar.bz2": { + "build": "cuda92py36h488537e_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0777458703a8fc2192e20435f8eb8918", + "name": "pytorch", + "sha256": "9f2671692a29117e513476087060549136fd3c6f4d8b42aa830d0ef9af989fc8", + "size": 284201346, + "subdir": "linux-64", + "timestamp": 1584481879061, + "version": "1.4.0" + }, + "pytorch-1.4.0-cuda92py37h488537e_0.tar.bz2": { + "build": "cuda92py37h488537e_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5afd011385a9732f4e27ade8dfa1012e", + "name": "pytorch", + "sha256": "015c919b69ca6bc945b2d25145ee33d211291e21c461aa3bee70ef4c7fb0d88f", + "size": 284018536, + "subdir": "linux-64", + "timestamp": 1584500966232, + "version": "1.4.0" + }, + "pytorch-1.4.0-cuda92py38h488537e_0.tar.bz2": { + "build": "cuda92py38h488537e_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f41cc4ee4e59e6640cf9efa166e47551", + "name": "pytorch", + "sha256": "2503762cf37860bad74aa04a30e46a57cac6d0cf856eb1702f5a076d3d4df3d5", + "size": 283557291, + "subdir": "linux-64", + "timestamp": 1584491284483, + "version": "1.4.0" + }, + "pytorch-1.5.0-cpu_py37hd91cbb3_0.tar.bz2": { + "build": "cpu_py37hd91cbb3_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl 2019.*", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "72cd6e5597469c17959ec33d0e92f795", + "name": "pytorch", + "sha256": "da980077a07fc58f55139e40746a3af8c00f9b33cbb37ac8874186a59a64f3de", + "size": 34923400, + "subdir": "linux-64", + "timestamp": 1591292143826, + "version": "1.5.0" + }, + "pytorch-1.7.1-cpu_py37h6a09485_0.tar.bz2": { + "build": "cpu_py37h6a09485_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libmklml", + "libstdcxx-ng >=7.3.0", + "mkl 2020.*", + "mkl >=2020.2,<2021.0a0", + "ninja", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "typing-extensions" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c82e222a9a4097d093a9a7acc4555939", + "name": "pytorch", + "sha256": "6b0dc7d5f75b6ff53228db6fddbcadf655a350a0c55d1dcc5459d883c30ad6fd", + "size": 41680216, + "subdir": "linux-64", + "timestamp": 1614406266099, + "version": "1.7.1" + }, + "pytorch-1.7.1-cpu_py38h6a09485_0.tar.bz2": { + "build": "cpu_py38h6a09485_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libmklml", + "libstdcxx-ng >=7.3.0", + "mkl 2020.*", + "mkl >=2020.2,<2021.0a0", + "ninja", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "typing-extensions" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "02f782ca9eb94d5d290c5af1dad2a19b", + "name": "pytorch", + "sha256": "b0ac22d76029b8cd3face5cd5b56971eab3ddf77a9993ef5c4c7ed5d1d7477f1", + "size": 41663970, + "subdir": "linux-64", + "timestamp": 1614406246397, + "version": "1.7.1" + }, + "pytorch-1.7.1-cpu_py39h6a09485_0.tar.bz2": { + "build": "cpu_py39h6a09485_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libmklml", + "libstdcxx-ng >=7.3.0", + "mkl 2020.*", + "mkl >=2020.2,<2021.0a0", + "ninja", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "typing-extensions" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5ea7f96988b9575bd413ee7159d00937", + "name": "pytorch", + "sha256": "73e5beb8b304885388e49d3d08700559b68cd36341cd11975c72360daa243737", + "size": 41691329, + "subdir": "linux-64", + "timestamp": 1622205443762, + "version": "1.7.1" + }, + "pytorch-1.8.1-cpu_py37h60491be_0.tar.bz2": { + "build": "cpu_py37h60491be_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.5.0", + "libmklml", + "libstdcxx-ng >=7.5.0", + "mkl 2020.*", + "mkl >=2020.2,<2021.0a0", + "ninja", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f5d07157f057b6132c7a1d49aae5cecb", + "name": "pytorch", + "sha256": "429986301db3e1a8da420f5ef4a9ea6f54aad710dbd315d5dbc7cd2cd288e701", + "size": 47446510, + "subdir": "linux-64", + "timestamp": 1625261980653, + "version": "1.8.1" + }, + "pytorch-1.8.1-cpu_py38h60491be_0.tar.bz2": { + "build": "cpu_py38h60491be_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.5.0", + "libmklml", + "libstdcxx-ng >=7.5.0", + "mkl 2020.*", + "mkl >=2020.2,<2021.0a0", + "ninja", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b48fe3de435c2e9e40d83daca14c4df3", + "name": "pytorch", + "sha256": "b45fdc6573afe16cfb1a29c2dde7ba4c3ac250073fff32a96c4bd37c8ce0003a", + "size": 47548254, + "subdir": "linux-64", + "timestamp": 1625255587986, + "version": "1.8.1" + }, + "pytorch-1.8.1-cpu_py39h60491be_0.tar.bz2": { + "build": "cpu_py39h60491be_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.5.0", + "libmklml", + "libstdcxx-ng >=7.5.0", + "mkl 2020.*", + "mkl >=2020.2,<2021.0a0", + "ninja", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f04b71fc2279637aa2b31244999c5b00", + "name": "pytorch", + "sha256": "95a1c476dc5ede247e7fcffe65d51c4a1d6ebaba3a870634c6533afa3e5da17d", + "size": 47523714, + "subdir": "linux-64", + "timestamp": 1625262053780, + "version": "1.8.1" + }, + "pytorch-cpu-1.2.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1.*", + "pytorch 1.2.0.*" + ], + "md5": "2852d48999e5e7baa1bffc7f1322e980", + "name": "pytorch-cpu", + "sha256": "c71870faef27cd51f3c56a46e6a42a2a69229e8b38f42b009f49f5e057799021", + "size": 2147, + "subdir": "linux-64", + "timestamp": 1566852987556, + "version": "1.2.0" + }, + "pytorch-cpu-1.3.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1.*", + "pytorch 1.3.1.*" + ], + "md5": "45129b091b1041abb84094bb2e5da6d5", + "name": "pytorch-cpu", + "sha256": "7b97ac4d6e67103d6e42ad42c766e398beab0cb5606a0357f730f9862de043cb", + "size": 2163, + "subdir": "linux-64", + "timestamp": 1574724994845, + "version": "1.3.1" + }, + "pytorch-gpu-1.2.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2.*", + "pytorch 1.2.0.*" + ], + "md5": "113641f848e25b79414038bfe823754e", + "name": "pytorch-gpu", + "sha256": "c976234b0cde6d40dfc64d3d142eb7e0cc03cb12f7468c00d6b0a9fad8112b0d", + "size": 2155, + "subdir": "linux-64", + "timestamp": 1566853075104, + "version": "1.2.0" + }, + "pytorch-gpu-1.3.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2.*", + "pytorch 1.3.1.*" + ], + "md5": "71829720818bcb842677423ab6ac655e", + "name": "pytorch-gpu", + "sha256": "516c19d33ee43fe3b54d0392ae3bf3e8c9dc155fa3ede3bf3841691a4759c025", + "size": 2171, + "subdir": "linux-64", + "timestamp": 1574725110836, + "version": "1.3.1" + }, + "pytorch-lightning-1.9.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec >2021.06.0", + "lightning-utilities >=0.6.0.post0", + "numpy >=1.17.2", + "packaging >=17.1", + "python >=3.10,<3.11.0a0", + "pytorch >=1.10.0", + "pyyaml >=5.4", + "torchmetrics >=0.7.0", + "tqdm >=4.57.0", + "typing-extensions >=4.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4ccbe84dc90ec3404684c6b209d0d0c3", + "name": "pytorch-lightning", + "sha256": "42fb2b0fc191788b1c8cef96d55daa7d99b94def399e026c6409ca90056b4ab5", + "size": 964288, + "subdir": "linux-64", + "timestamp": 1677759602127, + "version": "1.9.3" + }, + "pytorch-lightning-1.9.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec >2021.06.0", + "lightning-utilities >=0.6.0.post0", + "numpy >=1.17.2", + "packaging >=17.1", + "python >=3.8,<3.9.0a0", + "pytorch >=1.10.0", + "pyyaml >=5.4", + "torchmetrics >=0.7.0", + "tqdm >=4.57.0", + "typing-extensions >=4.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "04ee0c6e7e2232928c0969faab48707e", + "name": "pytorch-lightning", + "sha256": "b4e16cdd7695952bce1b4493ac95273f3f03563e190d917d5a070548cfce2272", + "size": 945058, + "subdir": "linux-64", + "timestamp": 1677759642965, + "version": "1.9.3" + }, + "pytorch-lightning-1.9.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec >2021.06.0", + "lightning-utilities >=0.6.0.post0", + "numpy >=1.17.2", + "packaging >=17.1", + "python >=3.9,<3.10.0a0", + "pytorch >=1.10.0", + "pyyaml >=5.4", + "torchmetrics >=0.7.0", + "tqdm >=4.57.0", + "typing-extensions >=4.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7ae2921584fab16f3ec9e862479e22bc", + "name": "pytorch-lightning", + "sha256": "6ddffb1c22b5b30b6dec0ea4ce083d151c5d64986ccffc8f344320e054c8925f", + "size": 945815, + "subdir": "linux-64", + "timestamp": 1677759556664, + "version": "1.9.3" + }, + "pytz-2017.2-py27hcac29fa_1.tar.bz2": { + "build": "py27hcac29fa_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ee07558943a10d9954aa155db6872d90", + "name": "pytz", + "sha256": "a6c3b66a6a3f514976fa6865c4f1cba61f6f22738c8dca11c1cd13e80545ddd9", + "size": 193078, + "subdir": "linux-64", + "timestamp": 1505691848966, + "version": "2017.2" + }, + "pytz-2017.2-py35h9225bff_1.tar.bz2": { + "build": "py35h9225bff_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "0279282336bc6f0621d1f57253337a43", + "name": "pytz", + "sha256": "126dabb41548bb6539c28cf0f609b4514f176737d0435bfd61b355a0833ed001", + "size": 193663, + "subdir": "linux-64", + "timestamp": 1505691865400, + "version": "2017.2" + }, + "pytz-2017.2-py36hc2ccc2a_1.tar.bz2": { + "build": "py36hc2ccc2a_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e4ead5c368a13c8d30f28d788e80931b", + "name": "pytz", + "sha256": "ff0e925ac25ace2a8db5ae394f49aaa89166f529bf16a6ccf42efbff8a576102", + "size": 193789, + "subdir": "linux-64", + "timestamp": 1505691881888, + "version": "2017.2" + }, + "pytz-2017.3-py27h001bace_0.tar.bz2": { + "build": "py27h001bace_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "29829149186445428aac78598d2a15ba", + "name": "pytz", + "sha256": "bb26130fe554f3791ffecf8fd6208ebbbaa1b7d255e1841bdfa6e0d32cb54f8e", + "size": 214815, + "subdir": "linux-64", + "timestamp": 1511286615302, + "version": "2017.3" + }, + "pytz-2017.3-py35hb13c558_0.tar.bz2": { + "build": "py35hb13c558_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "5216b5f253bea9a52178520566514712", + "name": "pytz", + "sha256": "d5f2b9c5f6073abe6c2fdd38d58e3ca41d7174bc2cb26915f73c96e2596e1e15", + "size": 215308, + "subdir": "linux-64", + "timestamp": 1511286623846, + "version": "2017.3" + }, + "pytz-2017.3-py36h63b9c63_0.tar.bz2": { + "build": "py36h63b9c63_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "22f2c034afd9697e4ae5dccba2f25b13", + "name": "pytz", + "sha256": "d0c5f05b96cb3e73e74efae6debf911b4834bb3ae4f657822bfd9e7346352ebf", + "size": 215421, + "subdir": "linux-64", + "timestamp": 1511286626382, + "version": "2017.3" + }, + "pytz-2018.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ca992935d28d33ac77fff0467007f20d", + "name": "pytz", + "sha256": "a43e5fb40609c61fe6dca34ee480a93642358844e42a3d63c497ade1c3944e0e", + "size": 216129, + "subdir": "linux-64", + "timestamp": 1519020831186, + "version": "2018.3" + }, + "pytz-2018.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "de6ad0d1357dfa96b4e3c05758375834", + "name": "pytz", + "sha256": "03f08750431a9bd64ac5ba1fcc6903754cf64ed8069c485ccc233a2b1cf8bc18", + "size": 216941, + "subdir": "linux-64", + "timestamp": 1519020846010, + "version": "2018.3" + }, + "pytz-2018.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "491acda904df9a08f9b5911fa349afd2", + "name": "pytz", + "sha256": "1e2eba317eb42f713ff5987053f5bdce8eb596517a6e59d16286bd8f5ee00fb5", + "size": 217020, + "subdir": "linux-64", + "timestamp": 1519020847506, + "version": "2018.3" + }, + "pytz-2018.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "08bea68ba4b8e49c93053842b9669f7e", + "name": "pytz", + "sha256": "1f27334bc0a35488b915359b37fbb1b19f718b02208301ed02488fc86bfef895", + "size": 216277, + "subdir": "linux-64", + "timestamp": 1523903064639, + "version": "2018.4" + }, + "pytz-2018.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "76bcf454e10581b4ff45531d796094fe", + "name": "pytz", + "sha256": "da3f0a3546a632eced058e9879906c64c041f0c3103ed2481eece118d56d31cd", + "size": 217046, + "subdir": "linux-64", + "timestamp": 1523903064885, + "version": "2018.4" + }, + "pytz-2018.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "08fd4e3ea3244deca163a0991d1c5de2", + "name": "pytz", + "sha256": "551b18ea49eeaec03c299de60a4dd75ba7c6fc52e5811811badc9b95258ce644", + "size": 217230, + "subdir": "linux-64", + "timestamp": 1523903027075, + "version": "2018.4" + }, + "pytz-2018.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "cae4f3544e72d383152a198e2f316248", + "name": "pytz", + "sha256": "c72b811ddd06cf78e854f902acb38ae62db85ed2746dccb260d573a3740ccd12", + "size": 236099, + "subdir": "linux-64", + "timestamp": 1530592186578, + "version": "2018.5" + }, + "pytz-2018.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "329b874fde7a7afbff04961806194287", + "name": "pytz", + "sha256": "7fcec4418999e0f7d9890529b71072b33222babac351302afb8b3b0a79d5de48", + "size": 236820, + "subdir": "linux-64", + "timestamp": 1530592198244, + "version": "2018.5" + }, + "pytz-2018.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0b8037377f8f4cf00e7f06a49813aee2", + "name": "pytz", + "sha256": "aa3cf925587388a6926947fc63f0976b207c89f5c3148b444f45a603ae42eb9f", + "size": 237066, + "subdir": "linux-64", + "timestamp": 1530592209803, + "version": "2018.5" + }, + "pytz-2018.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "cf28bb08d3984e5de4b797a8310397ba", + "name": "pytz", + "sha256": "c0c72e26206239b989130701e2152b1fb4be71532ab4ece9a71962a1883aa876", + "size": 236557, + "subdir": "linux-64", + "timestamp": 1530695271270, + "version": "2018.5" + }, + "pytz-2018.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e923ae46a3d2f843f09a967eefbb5d61", + "name": "pytz", + "sha256": "753b01a30beb91ae9b2662c2de8bf5321e1eabe30274658685af3cf9dd6f7eff", + "size": 254026, + "subdir": "linux-64", + "timestamp": 1541041402776, + "version": "2018.7" + }, + "pytz-2018.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ab1b1f2a8e82e4e52d09b7ac2f57402e", + "name": "pytz", + "sha256": "cfa48657ee3440b9a19bd8e8425f6032ad54e7f2f81a337fa4c2cbbab84f793d", + "size": 256194, + "subdir": "linux-64", + "timestamp": 1541041469121, + "version": "2018.7" + }, + "pytz-2018.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f6af09e8fa72d9ac902bd5874d6bc508", + "name": "pytz", + "sha256": "5649840c4ae444f401f062cf6b1eb7218b5c043adf1042bd7b2d3b52ed6c0cb3", + "size": 252458, + "subdir": "linux-64", + "timestamp": 1541041384966, + "version": "2018.7" + }, + "pytz-2018.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "81a2b712e2b5318fce867ab3ac1eef9d", + "name": "pytz", + "sha256": "b7207a2b01084a3f1b21cd29a8ee0943d9b4f143de643abc1aa53d90251c98d5", + "size": 269079, + "subdir": "linux-64", + "timestamp": 1547905268417, + "version": "2018.9" + }, + "pytz-2018.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6cf791850129430f7b4fd57f5f513085", + "name": "pytz", + "sha256": "5555e3151e813507814ab100bc90ced1b5d87d466b3929bce7af045c8fbba127", + "size": 266205, + "subdir": "linux-64", + "timestamp": 1547905321991, + "version": "2018.9" + }, + "pytz-2018.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "fbd45501b121c83b3a807288b2ca4b79", + "name": "pytz", + "sha256": "57989b94b6a1869edc7f419e7fb72242c79c1633f64c8e52187e5c3b2f03c636", + "size": 264672, + "subdir": "linux-64", + "timestamp": 1547905317162, + "version": "2018.9" + }, + "pytz-2022.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "e9bd0773d9fce6baf58d647ccd8099cf", + "name": "pytz", + "sha256": "5cfdb7251fb4d7a3f3aaaad0c3f7b5dfd982a1e1c425ee36c4419aed40d1d4e3", + "size": 262480, + "subdir": "linux-64", + "timestamp": 1654762780409, + "version": "2022.1" + }, + "pytz-2022.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1381a60ad9b4149935d15cb64ae86a96", + "name": "pytz", + "sha256": "39f1d18184aa8484d46737728ec592c2cc1f37dc90d791b307e2ae9979b058d0", + "size": 270651, + "subdir": "linux-64", + "timestamp": 1654762674993, + "version": "2022.1" + }, + "pytz-2022.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "46f94f37786004759038582bfa6717d7", + "name": "pytz", + "sha256": "f52c62d617b330db8a6a8673575403228774f23a12929c935d38d090840b6f61", + "size": 249341, + "subdir": "linux-64", + "timestamp": 1654762737905, + "version": "2022.1" + }, + "pytz-2022.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "4f78e6b22e43dcc597168917d225a733", + "name": "pytz", + "sha256": "07d164a622ea69826599047d6aaed8c24625bffab50fe929e6bba83f8367e33d", + "size": 264971, + "subdir": "linux-64", + "timestamp": 1654762707763, + "version": "2022.1" + }, + "pytz-2022.7-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71db24d98277c0b9d16e6b28ac89b13e", + "name": "pytz", + "sha256": "95d9602cf047bd49abf796602d6d0d8e3eb9b3e6a9a128c7be37425ccd438d4a", + "size": 259563, + "subdir": "linux-64", + "timestamp": 1671697464600, + "version": "2022.7" + }, + "pytz-2022.7-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8db50dcd68e31c5fde7915b3ccdf07cc", + "name": "pytz", + "sha256": "84e16df1881e94dafe2d89ba9bd4d981ac6af45d2ad2b2dfee934870cd18cb10", + "size": 263853, + "subdir": "linux-64", + "timestamp": 1676825017820, + "version": "2022.7" + }, + "pytz-2022.7-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c0889623fd664d26b7861ecf658001d", + "name": "pytz", + "sha256": "f0bc26ca026b60c317c6f61629f3a042a0c63d708072327acfba454a9494288e", + "size": 260288, + "subdir": "linux-64", + "timestamp": 1671697523831, + "version": "2022.7" + }, + "pytz-2022.7-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8aa6e6ccafcdf9a753b7c8dcc700038a", + "name": "pytz", + "sha256": "143869639d6f93b9482b6c33d4588e19e5bacf3c7367a564ec6e2289c9b1e087", + "size": 257418, + "subdir": "linux-64", + "timestamp": 1671697494082, + "version": "2022.7" + }, + "pytz-2022.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "645feda2f3506a0ee32e4ae03faf4bb4", + "name": "pytz", + "sha256": "852b6a8a0b402df4101b31719aa8fcc699262c976d304d55cb4985dbfa26b6ac", + "size": 258859, + "subdir": "linux-64", + "timestamp": 1671697553820, + "version": "2022.7" + }, + "pyutilib-5.6-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "nose", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "1326772b707a6af93c5c450508150727", + "name": "pyutilib", + "sha256": "30046b0087677fd747d68bc64d010630c29e325590dad8c1d364e3aa4d23561c", + "size": 338642, + "subdir": "linux-64", + "timestamp": 1519484567143, + "version": "5.6" + }, + "pyutilib-5.6-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "nose", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "9716492b6db255c4757822bdf60fe504", + "name": "pyutilib", + "sha256": "9265dbceba19d077712a5a9c923e6b01ea506a14384a6fff9f4ee98518dfce87", + "size": 344427, + "subdir": "linux-64", + "timestamp": 1519484609836, + "version": "5.6" + }, + "pyutilib-5.6-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "nose", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "a3d65ee5b201fd8768e762fe3e77580e", + "name": "pyutilib", + "sha256": "f4b89f9c1d65020c8966ca9a79a0d16f7e0bcfae1804736472e6f7691d79f1fa", + "size": 341797, + "subdir": "linux-64", + "timestamp": 1519484556562, + "version": "5.6" + }, + "pyutilib-5.6.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "nose", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "8fd11ef1097731d8aa57b1f2113c7c4f", + "name": "pyutilib", + "sha256": "6b2431fd43b81f15cf14b259dd9f4ac7ae1ff8da810d9ce2693dd1445a22bab5", + "size": 342507, + "subdir": "linux-64", + "timestamp": 1522194699522, + "version": "5.6.2" + }, + "pyutilib-5.6.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "b7e1dfa10d78e4bfca3fe1c8af2ff100", + "name": "pyutilib", + "sha256": "205c829d643bee106a2d366a741ffdd0f6a0c300f4612377ace24688dee0380d", + "size": 349089, + "subdir": "linux-64", + "timestamp": 1522194704423, + "version": "5.6.2" + }, + "pyutilib-5.6.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "f8d5594d836f798a3859cb966995c592", + "name": "pyutilib", + "sha256": "ec660597fc3b5e034a37546614bcadf8b560a9acfefb1deab9c50dea1b3ce4aa", + "size": 347283, + "subdir": "linux-64", + "timestamp": 1522194710328, + "version": "5.6.2" + }, + "pyutilib-5.6.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "nose", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "3902484cd1466e35106445fc35659626", + "name": "pyutilib", + "sha256": "beb141c899264e00dda7d0980096c8f9ad6e725b5bc20479474a23856895daf6", + "size": 343011, + "subdir": "linux-64", + "timestamp": 1524087403245, + "version": "5.6.3" + }, + "pyutilib-5.6.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "c6992fce8f3ec4f7757db554aefc1be0", + "name": "pyutilib", + "sha256": "256abc934365c9dd9718bcdb3cf1fcef571e8b18db8f4fc2e9d606a86bbbec6a", + "size": 349677, + "subdir": "linux-64", + "timestamp": 1524087410808, + "version": "5.6.3" + }, + "pyutilib-5.6.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "1f598ba2b0c30b12b00e94c76220f673", + "name": "pyutilib", + "sha256": "768aa57ef2ec3e081825cf8196a336bd421dfd5fe6d6e754052aaad95a6b993b", + "size": 348270, + "subdir": "linux-64", + "timestamp": 1524087404833, + "version": "5.6.3" + }, + "pyutilib-5.6.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "30c0044b05be1a1ccdb88cf46f543cc1", + "name": "pyutilib", + "sha256": "018f35b5998058fbe33d33f6d9c20ff63dd01b5ac517529f8ae6f47414052ac6", + "size": 347583, + "subdir": "linux-64", + "timestamp": 1530922988831, + "version": "5.6.3" + }, + "pyutilib-5.6.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "nose", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "a4ab1431f8ab7dd879fee491ff3e5e64", + "name": "pyutilib", + "sha256": "2487b52b01570a4b9abe67cfe27a797692dbfc94dbbe822946d2439e74d500a4", + "size": 356493, + "subdir": "linux-64", + "timestamp": 1547487930532, + "version": "5.6.4" + }, + "pyutilib-5.6.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "f8327002126b4c7cc6f9c08aa8a24d66", + "name": "pyutilib", + "sha256": "28a1aab3f86bd94379c178474f1a139ea3920b5a24aca8601bf902e205ecc897", + "size": 357336, + "subdir": "linux-64", + "timestamp": 1547487937754, + "version": "5.6.4" + }, + "pyutilib-5.6.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "a2ed1b96b1767f76dae470fe1aa14862", + "name": "pyutilib", + "sha256": "0c1d5561e300b3a2d590db7c9fd86458366b389328d3b6db2e908cfe33eeafae", + "size": 358887, + "subdir": "linux-64", + "timestamp": 1547487954144, + "version": "5.6.4" + }, + "pyutilib-5.6.5-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "nose", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "2f7d56c00da63afa8f0d09c3e11d05b0", + "name": "pyutilib", + "sha256": "1dec1ea127a378ddcadc8bdfd6ed94315e21762a80fb9305f026d250685a7c4b", + "size": 360460, + "subdir": "linux-64", + "timestamp": 1550356024658, + "version": "5.6.5" + }, + "pyutilib-5.6.5-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "nose", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "b03b1a542095576b760e61905815ca62", + "name": "pyutilib", + "sha256": "1f3fd4a9ef49c4f06e3032af428c552b194e267aa6179bfcd9a4195286f8840f", + "size": 359459, + "subdir": "linux-64", + "timestamp": 1550356036272, + "version": "5.6.5" + }, + "pyutilib-5.6.5-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "nose", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "56769c3c544ce17b46ae0a9ea4d48b84", + "name": "pyutilib", + "sha256": "a14184fd090783b28b8dc7f71fac2ee27710499d26066caede3d43210107fd60", + "size": 357984, + "subdir": "linux-64", + "timestamp": 1550356017560, + "version": "5.6.5" + }, + "pyutilib-5.7.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "nose", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "4c55dd6a7732cbc86c7d9f2515194cbe", + "name": "pyutilib", + "sha256": "639f65b3a413fdfee61b946754537728b3ff118f52e008f0959d97bae2c0b1c8", + "size": 360499, + "subdir": "linux-64", + "timestamp": 1569420560608, + "version": "5.7.1" + }, + "pyutilib-5.7.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "837c6d1878d3c3cdabcfcca755b89e4c", + "name": "pyutilib", + "sha256": "5c85777f57160caba392ca9d87f3419e0d042cb75cbcdfc4c46d2c26136c8693", + "size": 359264, + "subdir": "linux-64", + "timestamp": 1569420564870, + "version": "5.7.1" + }, + "pyutilib-5.7.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "0b713c7a49b2f0bc3bc3a383d0ec17bf", + "name": "pyutilib", + "sha256": "c0acb85f14033d75c9e666afe45eed5961a7b2c896f5dee96512ceb4a6fab671", + "size": 361896, + "subdir": "linux-64", + "timestamp": 1569420564813, + "version": "5.7.1" + }, + "pyutilib-5.7.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "nose", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "87f5433c6e7ad713ae1911d822c914a3", + "name": "pyutilib", + "sha256": "ef2edc45aeb84caa4045c5cecd7263b8913da43b74f11e0807d99c255994a65f", + "size": 363281, + "subdir": "linux-64", + "timestamp": 1573972039900, + "version": "5.7.2" + }, + "pyutilib-5.7.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "4445dd3b995e3def4e4401902bcbba73", + "name": "pyutilib", + "sha256": "08cc6cc1e9a4923e6ffe0cbab48243e5bc362fcf1a92440420b01101cd377d49", + "size": 360669, + "subdir": "linux-64", + "timestamp": 1573972060745, + "version": "5.7.2" + }, + "pyutilib-5.7.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "a8e44f109a1fb27abe31b95cecfeee33", + "name": "pyutilib", + "sha256": "3c7b6b6e6d6fe4cbe7de7cadb57903601a1fcb6db7dc94d93952ec45106bd68e", + "size": 360945, + "subdir": "linux-64", + "timestamp": 1573971993168, + "version": "5.7.2" + }, + "pyutilib-5.7.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "857058ba6b9d6b416a5d7f828eed9dd2", + "name": "pyutilib", + "sha256": "5b56c31e0a43a59feedd4c54632f6ffc9cea946fed1d2c185c3c0e7eceb1412b", + "size": 362612, + "subdir": "linux-64", + "timestamp": 1573972089061, + "version": "5.7.2" + }, + "pyviz_comms-0.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "param", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fed9f51c358b2bb9b480ba1e8678c589", + "name": "pyviz_comms", + "sha256": "26f9313f60512fdf79903896819fc4a9a33d06cfc5989ae1b7f744950cde4950", + "size": 12783, + "subdir": "linux-64", + "timestamp": 1527629242054, + "version": "0.1.1" + }, + "pyviz_comms-0.1.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "param", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7a25740df314b399f247d74d48a8abc1", + "name": "pyviz_comms", + "sha256": "b5d1be1c69fd7976992aab15d1b673f58ca16ab8c725dc1a72e975ff768db2df", + "size": 12944, + "subdir": "linux-64", + "timestamp": 1527629288383, + "version": "0.1.1" + }, + "pyviz_comms-0.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "166b6973f7cff52e907e6410ecde3741", + "name": "pyviz_comms", + "sha256": "09cbec78e9375122850542ca6c69736dcf0f36f764877f1679cd40642e12aab6", + "size": 12969, + "subdir": "linux-64", + "timestamp": 1527629233185, + "version": "0.1.1" + }, + "pyviz_comms-0.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "param", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1e37e79404ef9617034bc8e91e3d9178", + "name": "pyviz_comms", + "sha256": "d58d4d44ef6f2951747c4656241e78347d7bdb2bad873248b99c09eca845f030", + "size": 13011, + "subdir": "linux-64", + "timestamp": 1530892975365, + "version": "0.1.1" + }, + "pyviz_comms-0.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "param", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dcd35dc6f0249620cbf8b5997ed794f2", + "name": "pyviz_comms", + "sha256": "5a0658fee3b2c43ca085faaf97a9a554fca1388f2e2481322ae83127650108c9", + "size": 14889, + "subdir": "linux-64", + "timestamp": 1536114443354, + "version": "0.6.0" + }, + "pyviz_comms-0.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "param", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ab667dba11f764e0e8ade261dd1b7a37", + "name": "pyviz_comms", + "sha256": "c2c3d8d9ee5c677a8b390cc182b3df70822fcc24a4f2c0b1b62810c9e669fc96", + "size": 15135, + "subdir": "linux-64", + "timestamp": 1536114260176, + "version": "0.6.0" + }, + "pyviz_comms-0.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ed536bb237ed4de1f52399204fd2d090", + "name": "pyviz_comms", + "sha256": "7275790def35b29f33c066a2fd7366da78fe7a4a11cc7ba7842cfb41f15ad5dc", + "size": 15126, + "subdir": "linux-64", + "timestamp": 1536114420857, + "version": "0.6.0" + }, + "pyviz_comms-0.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "param", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d219f66201f5ba79f171d454ccd3b7d4", + "name": "pyviz_comms", + "sha256": "4112d792a732377600d45180f6e535bd83dbe2ce3ce6a640e5511971a9cf2510", + "size": 15138, + "subdir": "linux-64", + "timestamp": 1536114273293, + "version": "0.6.0" + }, + "pyviz_comms-0.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "param", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9deac67843d761c7f98aa6aaa518063b", + "name": "pyviz_comms", + "sha256": "f5d523b6a3cf5911e86603a9c17263537d3553f7e2327b6682e03dc445bb1149", + "size": 17575, + "subdir": "linux-64", + "timestamp": 1547983400551, + "version": "0.7.0" + }, + "pyviz_comms-0.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "26dc04cfbe0cb00fda51915a0f34a345", + "name": "pyviz_comms", + "sha256": "b03656cbfe9d073d63158e96b60a7e4931e9f2bcf14bd802157e6a33aed7a021", + "size": 17820, + "subdir": "linux-64", + "timestamp": 1547983558521, + "version": "0.7.0" + }, + "pyviz_comms-0.7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "param", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3b4d6d7c08422b66efe04fe89c656a36", + "name": "pyviz_comms", + "sha256": "7bfc9a61d94cf9857854201734116c686c18cc53584a33a083d42259eef415b4", + "size": 17836, + "subdir": "linux-64", + "timestamp": 1547983480829, + "version": "0.7.0" + }, + "pywavelets-0.5.2-py27h035aef0_2.tar.bz2": { + "build": "py27h035aef0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c3056227769544435cc42e39b37ea6a2", + "name": "pywavelets", + "sha256": "08de56bb3d16b4b3582de2f400bf65373bfc9259d6e71ae1f2de67d7945272db", + "size": 4173934, + "subdir": "linux-64", + "timestamp": 1530810053198, + "version": "0.5.2" + }, + "pywavelets-0.5.2-py27hecda097_0.tar.bz2": { + "build": "py27hecda097_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "03f3a563c9eabad1833a6390c39be04e", + "name": "pywavelets", + "sha256": "09493c03eb00aca1936bba16fc042da0a21b1903ae46f6f8a9277c4a5e3e700d", + "size": 4166170, + "subdir": "linux-64", + "timestamp": 1505863575761, + "version": "0.5.2" + }, + "pywavelets-0.5.2-py35h035aef0_2.tar.bz2": { + "build": "py35h035aef0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "6719eaf79577f9adcc6f402a456a56fa", + "name": "pywavelets", + "sha256": "416892b32459107fc4041c2768392328d85940145dea0853d18fa6ca6ef4bcfb", + "size": 4173028, + "subdir": "linux-64", + "timestamp": 1535129508969, + "version": "0.5.2" + }, + "pywavelets-0.5.2-py35h53ec731_0.tar.bz2": { + "build": "py35h53ec731_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "55f1c71fa599fa3f01826c80a26bfd16", + "name": "pywavelets", + "sha256": "5bdea932b065aa97d126db84ab4e221f1e9f19ea74127a56d8a434dfdba1b661", + "size": 4180790, + "subdir": "linux-64", + "timestamp": 1505863675983, + "version": "0.5.2" + }, + "pywavelets-0.5.2-py36h035aef0_2.tar.bz2": { + "build": "py36h035aef0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9f56407622df78016b018c881baa83ac", + "name": "pywavelets", + "sha256": "ea57273efce3f2f3863def752ec7b11675a900a31e080171d88723ec2a48e34a", + "size": 4180895, + "subdir": "linux-64", + "timestamp": 1530810927307, + "version": "0.5.2" + }, + "pywavelets-0.5.2-py36he602eb0_0.tar.bz2": { + "build": "py36he602eb0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "abcd4d982603880b9b2e464ac9fceb69", + "name": "pywavelets", + "sha256": "66db13eb8240612789d4c7fc3f9dae2bb623b844255ba4daff3a0fca8caa9c9a", + "size": 4188037, + "subdir": "linux-64", + "timestamp": 1505863779794, + "version": "0.5.2" + }, + "pywavelets-0.5.2-py37h035aef0_2.tar.bz2": { + "build": "py37h035aef0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4a1714bcc4d8f7e54bda3d706b29b441", + "name": "pywavelets", + "sha256": "881e312dded62ff856850165692464223eef7634a049c2a694d41e9230852609", + "size": 4179487, + "subdir": "linux-64", + "timestamp": 1530810802825, + "version": "0.5.2" + }, + "pywavelets-1.0.0-py27hdd07704_0.tar.bz2": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "1ef17fd3c7804426777fca4240e02b6c", + "name": "pywavelets", + "sha256": "53d70ccc53206f39b777a7ff9943d746953be3d752fd8f05072c72982fcefcb3", + "size": 4627973, + "subdir": "linux-64", + "timestamp": 1536084725785, + "version": "1.0.0" + }, + "pywavelets-1.0.0-py35hdd07704_0.tar.bz2": { + "build": "py35hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "305d95c8fab680902ddc1489a61a92a3", + "name": "pywavelets", + "sha256": "4ecdd29a11cdf3f81bf6cff7ffa5f679e44bf10c69ff01816de7b988a118462f", + "size": 4625634, + "subdir": "linux-64", + "timestamp": 1536084725614, + "version": "1.0.0" + }, + "pywavelets-1.0.0-py36hdd07704_0.tar.bz2": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "060acad39b6f23101123bc3fc16a327f", + "name": "pywavelets", + "sha256": "3b26c3dab5057a99ff9ec07f690afb0b453d18e66eb467c87dcac579d2d88d09", + "size": 4635777, + "subdir": "linux-64", + "timestamp": 1536085396231, + "version": "1.0.0" + }, + "pywavelets-1.0.0-py37hdd07704_0.tar.bz2": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5789c4814bafc05afd01b967b63ff7e9", + "name": "pywavelets", + "sha256": "abe3d6fde637a2a9f87b1314133ea32d891bf40f86744403b48fb935011d273c", + "size": 4629791, + "subdir": "linux-64", + "timestamp": 1536084578647, + "version": "1.0.0" + }, + "pywavelets-1.0.1-py27hdd07704_0.tar.bz2": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "628acb72d9968a3cbd4cdcdfb0d11906", + "name": "pywavelets", + "sha256": "a563e65113ce1da811166a3ce9d384708156d07c754584d401a74f5d52e13d24", + "size": 4631478, + "subdir": "linux-64", + "timestamp": 1538600658619, + "version": "1.0.1" + }, + "pywavelets-1.0.1-py36hdd07704_0.tar.bz2": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7848bc73987c9bf47a62eb9fc00e1294", + "name": "pywavelets", + "sha256": "4dca14b72f3c1e507aab1714a58ad04d599f5262bfb1bc45635196e745ef199d", + "size": 4635557, + "subdir": "linux-64", + "timestamp": 1538600640316, + "version": "1.0.1" + }, + "pywavelets-1.0.1-py37hdd07704_0.tar.bz2": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7cfa5a1f0ebf53caeb2f009f9106db71", + "name": "pywavelets", + "sha256": "9c3de7b519167991700dda81edb67b1b0fb9462c4c6228d3b1f0c8474269ae65", + "size": 4635118, + "subdir": "linux-64", + "timestamp": 1538600635929, + "version": "1.0.1" + }, + "pywavelets-1.0.2-py27hdd07704_0.tar.bz2": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7e1a8913e346a68db3f345ba15b7ea24", + "name": "pywavelets", + "sha256": "b3554ae9d56c349fc992162ab29fdd9a45da3cee516c481c85362085a27ef586", + "size": 4572949, + "subdir": "linux-64", + "timestamp": 1552335592357, + "version": "1.0.2" + }, + "pywavelets-1.0.2-py36hdd07704_0.tar.bz2": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0fc841e27f0a5094f361471baf7becbf", + "name": "pywavelets", + "sha256": "f02f0839c1ffda55ba3a73d67c5ed4e9778c828030fc769f36ce389fa2eea6eb", + "size": 4576707, + "subdir": "linux-64", + "timestamp": 1552335560172, + "version": "1.0.2" + }, + "pywavelets-1.0.2-py37hdd07704_0.tar.bz2": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c6e7920cae2aad89728041ebd95f3ddb", + "name": "pywavelets", + "sha256": "3b75f82506e05eb2bc563eda860d77b322f0caeee97e7f4cdfc4032efeddcf53", + "size": 4610230, + "subdir": "linux-64", + "timestamp": 1552335588610, + "version": "1.0.2" + }, + "pywavelets-1.0.3-py27hdd07704_1.tar.bz2": { + "build": "py27hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "303d5dca0b5a7e0abb683b0475c36549", + "name": "pywavelets", + "sha256": "a938701efe92fad8e9156dd335531d7a13264344f0a5c806da95691fdfc29e88", + "size": 4605131, + "subdir": "linux-64", + "timestamp": 1555432028425, + "version": "1.0.3" + }, + "pywavelets-1.0.3-py36hdd07704_1.tar.bz2": { + "build": "py36hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "fe543595b39624b96170d5ba170fae0a", + "name": "pywavelets", + "sha256": "48c79d82bbb2c23a9fbf603ab868d86fac2db5f44213509556fa4eef880f0340", + "size": 4622698, + "subdir": "linux-64", + "timestamp": 1555432087576, + "version": "1.0.3" + }, + "pywavelets-1.0.3-py37hdd07704_1.tar.bz2": { + "build": "py37hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "18ac4caa19888b3a6c71f6838cc18bbb", + "name": "pywavelets", + "sha256": "2383db6ab35ac019291783c6a700786050553a86c243651bec5fda9d6e5ae860", + "size": 4604569, + "subdir": "linux-64", + "timestamp": 1555431923468, + "version": "1.0.3" + }, + "pywavelets-1.1.1-py310h9102076_4.tar.bz2": { + "build": "py310h9102076_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "6ee882afb5dd31a6718f6dc419d54ea4", + "name": "pywavelets", + "sha256": "87412bde0ab6f5ca4c9080c16b66d5672f7c4e6ef1e088d9c4f331a6830a770a", + "size": 6356195, + "subdir": "linux-64", + "timestamp": 1641402918394, + "version": "1.1.1" + }, + "pywavelets-1.1.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "643e215744f8397e4b6e03233976aecc", + "name": "pywavelets", + "sha256": "b2cfa7061ec85d301923791ba0b08fd20b37ca800745f5ca0cc4d8bfa4aa4da7", + "size": 4647715, + "subdir": "linux-64", + "timestamp": 1571765103922, + "version": "1.1.1" + }, + "pywavelets-1.1.1-py36h7b6447c_2.tar.bz2": { + "build": "py36h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "558ab06edae9faa3cfe234dea606dbc5", + "name": "pywavelets", + "sha256": "a2b33bf9d89ce5e8b0429b22cd91f3c04197f951a896863cdc6a9cbb937a007d", + "size": 4563629, + "subdir": "linux-64", + "timestamp": 1601658449178, + "version": "1.1.1" + }, + "pywavelets-1.1.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e03d76a164137cb78e491351115caa89", + "name": "pywavelets", + "sha256": "f1e9ca390a922c4596c276af903b66f0b01a714cafabd43c5dc624cb541c1e7f", + "size": 4619481, + "subdir": "linux-64", + "timestamp": 1571765137860, + "version": "1.1.1" + }, + "pywavelets-1.1.1-py37h7b6447c_2.tar.bz2": { + "build": "py37h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "36036c9536d6d2dd702ef6c2928420d4", + "name": "pywavelets", + "sha256": "603591547e7b289f25cfdfe324fc0237f4b5a7e38721eea22c46545ffcb1d1cb", + "size": 4568430, + "subdir": "linux-64", + "timestamp": 1601658464940, + "version": "1.1.1" + }, + "pywavelets-1.1.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "d63e2438e5d6e7fad7e62a1e9dbfe15f", + "name": "pywavelets", + "sha256": "dbede1b415f11e35775a348e81cbdebf6c6404f3c3d08e2e77aecf9e88bb3c4d", + "size": 4635218, + "subdir": "linux-64", + "timestamp": 1574081646167, + "version": "1.1.1" + }, + "pywavelets-1.1.1-py38h7b6447c_2.tar.bz2": { + "build": "py38h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "c3047bb42a5b8e6b2b598e5bdcc86c5c", + "name": "pywavelets", + "sha256": "4e0c1d59cd5325e4a17dbaa069c1dee4e4e32a7ff8286cf033dccaa673082908", + "size": 4518054, + "subdir": "linux-64", + "timestamp": 1601658411352, + "version": "1.1.1" + }, + "pywavelets-1.1.1-py39h6323ea4_4.tar.bz2": { + "build": "py39h6323ea4_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "de138f41e4a5a367c493ea84ca9b8ad1", + "name": "pywavelets", + "sha256": "c7f1d66753672babd2eb7a3f1b41e9b00e71f7782eff03193dd9186a8f292ca3", + "size": 4596203, + "subdir": "linux-64", + "timestamp": 1607645549721, + "version": "1.1.1" + }, + "pywavelets-1.3.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d5c6bd3c5b3161de113bf44ba16e56e", + "name": "pywavelets", + "sha256": "e24d1830eda7e1c7321155579445ef8f86f36e8d63ee8f037e2ad717e51b6820", + "size": 6368943, + "subdir": "linux-64", + "timestamp": 1648728001975, + "version": "1.3.0" + }, + "pywavelets-1.3.0-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.18.5,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f32acc6d03eb32796fed411e02d88e1", + "name": "pywavelets", + "sha256": "6721d44439c960da3118a0dcacae9011d8c7159827dd1fa548ef556e9a3bfaa3", + "size": 4564871, + "subdir": "linux-64", + "timestamp": 1648727979242, + "version": "1.3.0" + }, + "pywavelets-1.3.0-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.18.5,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2503b9c21ca45f67a61de280e2b9aee9", + "name": "pywavelets", + "sha256": "29f8fe01732fd7a04f3922a2f523047e74f4dce842735e2f4dfd7b2d464beee6", + "size": 4618312, + "subdir": "linux-64", + "timestamp": 1648710217877, + "version": "1.3.0" + }, + "pywavelets-1.3.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "322c11526dddcec5b04cc626bf6ba82d", + "name": "pywavelets", + "sha256": "fa5ebc9bb009663b1b074c84ca3c40bfca8ca08c55b639820e368f9860df5879", + "size": 4552679, + "subdir": "linux-64", + "timestamp": 1648710116430, + "version": "1.3.0" + }, + "pywavelets-1.4.1-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6934476a15991ad1dd6fa5848027e3c", + "name": "pywavelets", + "sha256": "7edb9ffdac71cedb5cd907a7f4cdcdcce4f2919a724f6aed4d69482489bf2b68", + "size": 4594494, + "subdir": "linux-64", + "timestamp": 1670425632673, + "version": "1.4.1" + }, + "pywavelets-1.4.1-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "187d8b99f3d3f3b6770ee551838567c8", + "name": "pywavelets", + "sha256": "aceee60d54a99741038e8adb43ebabe43e7be4b8888c55387aa1205b6e64cc36", + "size": 4600733, + "subdir": "linux-64", + "timestamp": 1676838743968, + "version": "1.4.1" + }, + "pywavelets-1.4.1-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.18.5,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "acd8f3d760ed4d6aedf0e279b8bf29a5", + "name": "pywavelets", + "sha256": "57e04377f9e6513e074401808296f1a07c5a791cfe296c7d178809a22d71cd35", + "size": 4599105, + "subdir": "linux-64", + "timestamp": 1670425446417, + "version": "1.4.1" + }, + "pywavelets-1.4.1-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "533f4979d06fc728e5dfad27d61f627e", + "name": "pywavelets", + "sha256": "ca6f2cb564a5aaa4a71a2bc56efe40a5427ef91427c9b388fb1faace6d9922db", + "size": 4600603, + "subdir": "linux-64", + "timestamp": 1670425256409, + "version": "1.4.1" + }, + "pywget-3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public-Domain", + "md5": "1875954aca6a839243e27148b85f94d4", + "name": "pywget", + "sha256": "3eaa7229557ac26f3914873cebfbb468894adeab418cc17f4d11867c634d76b2", + "size": 17760, + "subdir": "linux-64", + "timestamp": 1524522443759, + "version": "3.2" + }, + "pywget-3.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Public-Domain", + "md5": "829afa31c99f1d5052e45609f0754134", + "name": "pywget", + "sha256": "80d6707440119e8aa330f824e26b0054ae3f6f6a41452ee6518588bd72b0b063", + "size": 18406, + "subdir": "linux-64", + "timestamp": 1640794060827, + "version": "3.2" + }, + "pywget-3.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Public-Domain", + "md5": "0eb9332c8b93b19a36763c378a342246", + "name": "pywget", + "sha256": "3050154ee88387d1cb73cfdaa5cfd4e99bda801787617d84e18a9be9e1c7651c", + "size": 23614, + "subdir": "linux-64", + "timestamp": 1676907629642, + "version": "3.2" + }, + "pywget-3.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Public-Domain", + "md5": "92b94ab52c0acd3847cf0b5b7785afb4", + "name": "pywget", + "sha256": "28361cca9d718e624632967c7fd3eb21d070420233f9a27dc17ddbac1d1da151", + "size": 18240, + "subdir": "linux-64", + "timestamp": 1524522447749, + "version": "3.2" + }, + "pywget-3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public-Domain", + "md5": "75bd72ea46935aad890894c12fe9f923", + "name": "pywget", + "sha256": "c1ceb570cbe30896667a98a6f86cb3605d670aaa1bf2fe18ddcb7fea085cd6a1", + "size": 18139, + "subdir": "linux-64", + "timestamp": 1524522281107, + "version": "3.2" + }, + "pywget-3.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public-Domain", + "md5": "a590d5fb054980d2a1289797fa7ef4b2", + "name": "pywget", + "sha256": "1a5e376e203f3860b0fcc7b9c1a621f291d5b39f2cb2f8124c597db5d55b76cf", + "size": 240760, + "subdir": "linux-64", + "timestamp": 1614082665246, + "version": "3.2" + }, + "pywget-3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public-Domain", + "md5": "88954295c2f3775ea07eb13d1d15f0c9", + "name": "pywget", + "sha256": "25da8a59c88400b30d2d7cd7603f6f9644bfc2e1464bb956e798cf51369741e1", + "size": 18019, + "subdir": "linux-64", + "timestamp": 1530923026564, + "version": "3.2" + }, + "pywget-3.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public-Domain", + "md5": "f67f1739db617bd36db6127d90d6170c", + "name": "pywget", + "sha256": "70b0e6be6836c38775352e3ec1fa8edfd479cd842e03c6a7c61f32c5160ca2b0", + "size": 240566, + "subdir": "linux-64", + "timestamp": 1614082672214, + "version": "3.2" + }, + "pywget-3.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Public-Domain", + "md5": "e9d8499213ade8f65598139d208a088d", + "name": "pywget", + "sha256": "8bc005a290e8f8d6def9fa318a4f2dcc28b16e28827fe8e06612e434d1ae3c25", + "size": 18531, + "subdir": "linux-64", + "timestamp": 1573200322104, + "version": "3.2" + }, + "pywget-3.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Public-Domain", + "md5": "9e7babc3b8385a939054ac0cd34b4676", + "name": "pywget", + "sha256": "f44bcc478aa37d7d601223c6b5daa3ccfdffc49866790bdfedf8d868319a674c", + "size": 239212, + "subdir": "linux-64", + "timestamp": 1614081743260, + "version": "3.2" + }, + "pywget-3.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Public-Domain", + "md5": "a87c2a045c5c35f76c2f5434d26cfed8", + "name": "pywget", + "sha256": "6e40c38d5a6602f2919a72597e9b41ef9e0071246cb0fd46ed449261bc59dedd", + "size": 18458, + "subdir": "linux-64", + "timestamp": 1607007556784, + "version": "3.2" + }, + "pyyaml-3.12-py27h14c3975_1.tar.bz2": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d93c443aa07fb15aae295b2f8afb839e", + "name": "pyyaml", + "sha256": "d67a725e6c050864b97e0a4dc1c221097c1b63f22c395401d33e597463013a71", + "size": 177157, + "subdir": "linux-64", + "timestamp": 1530737233725, + "version": "3.12" + }, + "pyyaml-3.12-py27h2d70dd7_1.tar.bz2": { + "build": "py27h2d70dd7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66ec5fbf516d968c5e0f76faec4f0eb8", + "name": "pyyaml", + "sha256": "0508840eaf9d04500e8cd2f3ff22ca2e093f794ab300fa2a94c346c7903f1d9d", + "size": 162823, + "subdir": "linux-64", + "timestamp": 1505739670245, + "version": "3.12" + }, + "pyyaml-3.12-py35h46ef4ae_1.tar.bz2": { + "build": "py35h46ef4ae_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e5f83839b9a5737b44cd8cb6942b6946", + "name": "pyyaml", + "sha256": "e741b73cfd363cdebfa651cbd78ca695e74378cf959025312242632668606a42", + "size": 163486, + "subdir": "linux-64", + "timestamp": 1505739698606, + "version": "3.12" + }, + "pyyaml-3.12-py36h14c3975_1.tar.bz2": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8f62014299c3d0d2a4eb094d36fd30f", + "name": "pyyaml", + "sha256": "c081acbf440ddc55236b675777e766c194eb108e781a75f14ff00193b64ceff1", + "size": 182704, + "subdir": "linux-64", + "timestamp": 1530737192771, + "version": "3.12" + }, + "pyyaml-3.12-py36hafb9ca4_1.tar.bz2": { + "build": "py36hafb9ca4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f69dc5210195644edb2c4a14a76fbd4", + "name": "pyyaml", + "sha256": "96d595bf39ba4b8f09fb598340b72ce8013e1a892818d47560138ab41142377d", + "size": 162850, + "subdir": "linux-64", + "timestamp": 1505739726977, + "version": "3.12" + }, + "pyyaml-3.12-py37h14c3975_1.tar.bz2": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a4d1b64be6ea756e24cc0c96f31cae0", + "name": "pyyaml", + "sha256": "77868df83f786ee684198dd060a51fd1f081a202fbcb44aeef514aecfa00f980", + "size": 181608, + "subdir": "linux-64", + "timestamp": 1530737275158, + "version": "3.12" + }, + "pyyaml-3.13-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22a3c9056b447f8ff2da48770c409cdd", + "name": "pyyaml", + "sha256": "70c795f4f50adae600802bb37419741bb419a842d25e40593c5c3bb79164b661", + "size": 177027, + "subdir": "linux-64", + "timestamp": 1532442760271, + "version": "3.13" + }, + "pyyaml-3.13-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "815c6dd5c62a3b896481a485f2d76d36", + "name": "pyyaml", + "sha256": "8071b6bc20073a791297bd93e1608b3d687b0ac3efe7cfe26d3bbd16790a9cc1", + "size": 178247, + "subdir": "linux-64", + "timestamp": 1532442618167, + "version": "3.13" + }, + "pyyaml-3.13-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "001c0bf06a4be08558191a0fc676de5d", + "name": "pyyaml", + "sha256": "43b6c9fb281496222144474014fae8cff6b04c58496617b5c371ecd7686b9683", + "size": 182501, + "subdir": "linux-64", + "timestamp": 1532442758558, + "version": "3.13" + }, + "pyyaml-3.13-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "022343e2976ce2f281adee0a8d443cce", + "name": "pyyaml", + "sha256": "b4e8dc0c34c1a56a8c384a2c8f7e7accfc40cd9adbedc0d00601b334c40ec985", + "size": 181540, + "subdir": "linux-64", + "timestamp": 1532442799049, + "version": "3.13" + }, + "pyyaml-5.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "10a02867f77d0b0cfa763cb009d0d7e5", + "name": "pyyaml", + "sha256": "f96f16cc7b399be07246c58c9923b52ce1b408d125a3731a2b49edcca4586d7d", + "size": 180781, + "subdir": "linux-64", + "timestamp": 1552926804381, + "version": "5.1" + }, + "pyyaml-5.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "69e5e7d6ca62575f848fafd02a5bb281", + "name": "pyyaml", + "sha256": "d1be8cbb0e02ccd281598eae2e6419232720cbebf6388de7c6f88d72a7d63794", + "size": 192440, + "subdir": "linux-64", + "timestamp": 1552926815925, + "version": "5.1" + }, + "pyyaml-5.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d0e75b80a38a637fc6957c8c49973a15", + "name": "pyyaml", + "sha256": "01e37ea8ee5655624286705a5563311fca80ad36a76ffbf79646ec9a78136105", + "size": 192286, + "subdir": "linux-64", + "timestamp": 1552926817790, + "version": "5.1" + }, + "pyyaml-5.1.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "682885b0ee0611b8895c114e0e2bda9e", + "name": "pyyaml", + "sha256": "3fa0130c28270ca45d602f0feac1690c2f628972eaa0de4b3e56f290592d83d6", + "size": 180868, + "subdir": "linux-64", + "timestamp": 1562081350407, + "version": "5.1.1" + }, + "pyyaml-5.1.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e774728356048d686d638e7e8eab3bfa", + "name": "pyyaml", + "sha256": "596938c32132fc32dceba9bebae2b23e6e6472ea8ea449bb6f5e6cf8084e10a3", + "size": 192744, + "subdir": "linux-64", + "timestamp": 1562081352963, + "version": "5.1.1" + }, + "pyyaml-5.1.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "887752df3c7fbf81e39e022c6ac7842b", + "name": "pyyaml", + "sha256": "1e016c4c8e0010a81db9a9dde09a3c0da23a71bc30ea035e4c49e10b1553b25a", + "size": 192521, + "subdir": "linux-64", + "timestamp": 1562081337303, + "version": "5.1.1" + }, + "pyyaml-5.1.2-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18f523b8e058a655fbde86a2d18cd39f", + "name": "pyyaml", + "sha256": "be562d77e07ac96fcbf38b758a80d2cb2a794fb72ec8644ace95dd452e751bb2", + "size": 181773, + "subdir": "linux-64", + "timestamp": 1565957135920, + "version": "5.1.2" + }, + "pyyaml-5.1.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0253a34d52301616d39acc07b27e503f", + "name": "pyyaml", + "sha256": "88928e3eab3169ca3903839e7537240f9285d4d2848ee02ec1b1c942ded100a9", + "size": 193509, + "subdir": "linux-64", + "timestamp": 1565957466529, + "version": "5.1.2" + }, + "pyyaml-5.1.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "efcf1fdacece4caed218c627d07bd67c", + "name": "pyyaml", + "sha256": "a3f9f2b9de35ff1482f7fcbacc0ba86b811647c17347a681b5f24d4b21a50115", + "size": 193172, + "subdir": "linux-64", + "timestamp": 1565957415311, + "version": "5.1.2" + }, + "pyyaml-5.1.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f50ffe705ab1da17cd54b4077fb4ec2f", + "name": "pyyaml", + "sha256": "ff18c9c1d68a992a61e5899d341f7b791a9e1b22d1a7499d078ce617f064587d", + "size": 194060, + "subdir": "linux-64", + "timestamp": 1573200443086, + "version": "5.1.2" + }, + "pyyaml-5.2-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b199aeb7646113900b76c5ec7ffcf320", + "name": "pyyaml", + "sha256": "6c7ddd56c2a2c56bb65ba6eebef19225d1740ca33ba68b5cfec64dedce1da4e9", + "size": 183354, + "subdir": "linux-64", + "timestamp": 1576512808904, + "version": "5.2" + }, + "pyyaml-5.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5ac9e2f8f00d43623167fcc477b9b47", + "name": "pyyaml", + "sha256": "291e30c9c3e4ee93ebbd9eeb59b4011f0d42098d29109f9b26ff6363f161b1cf", + "size": 194643, + "subdir": "linux-64", + "timestamp": 1576512804269, + "version": "5.2" + }, + "pyyaml-5.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be065d7d7611e2386de25d3a17867947", + "name": "pyyaml", + "sha256": "b69f8aa4b158690cf3d94eb341a68887c42eeb37d18561b720a1af0bd13a1efb", + "size": 194455, + "subdir": "linux-64", + "timestamp": 1576512808141, + "version": "5.2" + }, + "pyyaml-5.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "861605bbbd89d2501c05de9d4f92390d", + "name": "pyyaml", + "sha256": "9cf84e36873f31df8aba14dc166b0b7222c1dbc705df19ed391143edb651c014", + "size": 199265, + "subdir": "linux-64", + "timestamp": 1576512816056, + "version": "5.2" + }, + "pyyaml-5.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11a604bac9e98450b8eb2b08e6142141", + "name": "pyyaml", + "sha256": "e90bd50437e7362855a351a3cdb082294b428d09ff5602be63ed2375f1ca8ade", + "size": 195162, + "subdir": "linux-64", + "timestamp": 1580834727945, + "version": "5.3" + }, + "pyyaml-5.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "28dc51b4e5ee11c3ffb594b30fd37c52", + "name": "pyyaml", + "sha256": "1e95444afc5a1bf89fc108a8b773aeb60439019dc12428fb75de2e20283f7188", + "size": 194539, + "subdir": "linux-64", + "timestamp": 1580834750049, + "version": "5.3" + }, + "pyyaml-5.3-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb0138dc672e018805155a02fc65f531", + "name": "pyyaml", + "sha256": "4193f2e83d0a8ea4610ebbb8b605bd8833b7d03b713ba09f96b639c13fadb8a8", + "size": 199534, + "subdir": "linux-64", + "timestamp": 1580834719606, + "version": "5.3" + }, + "pyyaml-5.3.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9107d1a8fb84b3cbb3aa03561c701b76", + "name": "pyyaml", + "sha256": "7601880b7af280a1a561cceec4d022fbfe4a7c497681a7f1baa66e2c6133b456", + "size": 195932, + "subdir": "linux-64", + "timestamp": 1584979028015, + "version": "5.3.1" + }, + "pyyaml-5.3.1-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d78008167ba516c90df6242250fe93dc", + "name": "pyyaml", + "sha256": "d26f0e103d3bfcab63cac9c7406c7960280cf43bc2a4f68a6f25e7fdf928056d", + "size": 195808, + "subdir": "linux-64", + "timestamp": 1593124650570, + "version": "5.3.1" + }, + "pyyaml-5.3.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5c508152178014bd09f736b5530738b", + "name": "pyyaml", + "sha256": "df3e6afe161ac8cc823b4d03fc8653df2468fee80b47c113e41943b09705bfcd", + "size": 195269, + "subdir": "linux-64", + "timestamp": 1584979030736, + "version": "5.3.1" + }, + "pyyaml-5.3.1-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a8a300f87fb43778c1f99f3069e9796", + "name": "pyyaml", + "sha256": "0a49af9111247b888a0deb6c5f55ed9ef3eecc36e7480f615ef0098027e9d593", + "size": 195311, + "subdir": "linux-64", + "timestamp": 1593124652283, + "version": "5.3.1" + }, + "pyyaml-5.3.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b625b4d727b91391a7c53698dac39641", + "name": "pyyaml", + "sha256": "a844997088922d5c9b2472b07d935f7964751b944bf9105a9c4726000d31f4e9", + "size": 199719, + "subdir": "linux-64", + "timestamp": 1584979033384, + "version": "5.3.1" + }, + "pyyaml-5.3.1-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c54f4037a8812ddd84b90f629605737", + "name": "pyyaml", + "sha256": "65b6aad5714cd0ff2ea6cf16836a6de13a92803486deb90a5687368af8f2d47c", + "size": 200449, + "subdir": "linux-64", + "timestamp": 1593124661521, + "version": "5.3.1" + }, + "pyyaml-5.3.1-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bf3792f8a9148de1fe9640e5dca840ba", + "name": "pyyaml", + "sha256": "98b006ad4256dc11c06715deda406f670134f19a0ff92d273a272719d4dc4e9d", + "size": 200062, + "subdir": "linux-64", + "timestamp": 1607027947333, + "version": "5.3.1" + }, + "pyyaml-5.4-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95d2944a96b40c8cd7b2e5ac521c06d6", + "name": "pyyaml", + "sha256": "b102966db9784aa661db73394bee2797551c649b50c52734bca06584db33467a", + "size": 179648, + "subdir": "linux-64", + "timestamp": 1611172339259, + "version": "5.4" + }, + "pyyaml-5.4-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "05af58c85c01fd9dc509ae92a60f1b4b", + "name": "pyyaml", + "sha256": "43a265af8434e5416d62d560418bee979c50ae334cf81c95c9c6abed7b0f4816", + "size": 178789, + "subdir": "linux-64", + "timestamp": 1611172365409, + "version": "5.4" + }, + "pyyaml-5.4-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd3e1dfdb7787190e84e18b4f52ce64d", + "name": "pyyaml", + "sha256": "a93be44f697a11dfea7893e744ec64071f667478648372b1dff5483a9fe65acf", + "size": 184234, + "subdir": "linux-64", + "timestamp": 1611172275378, + "version": "5.4" + }, + "pyyaml-5.4-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1fa57855dce724773bf51a1e41b556e2", + "name": "pyyaml", + "sha256": "78921f454b37a1f8c2339661bab245036573cf01fdc335431036ec1c9b3bdc27", + "size": 184872, + "subdir": "linux-64", + "timestamp": 1611172361382, + "version": "5.4" + }, + "pyyaml-5.4.1-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b708d54d1df8c1141b770b67eddeb4fc", + "name": "pyyaml", + "sha256": "370e12e0ed10a96256a5ae09ae61e5fe080011e8197f1081dd708897c6df0bb9", + "size": 179665, + "subdir": "linux-64", + "timestamp": 1611258435880, + "version": "5.4.1" + }, + "pyyaml-5.4.1-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb059d49d9fb4e57888df387b9396b43", + "name": "pyyaml", + "sha256": "38050ad225511be9ed59d6285c9904259b069c806527a66e04e89f96f73c878c", + "size": 178758, + "subdir": "linux-64", + "timestamp": 1611258452869, + "version": "5.4.1" + }, + "pyyaml-5.4.1-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbbda833c0f773ca73a7f401a5a46aea", + "name": "pyyaml", + "sha256": "7cc767c48a63de04fbc98dd2cd8047a428d7b2c2e060611cce17901425932148", + "size": 184333, + "subdir": "linux-64", + "timestamp": 1611258452844, + "version": "5.4.1" + }, + "pyyaml-5.4.1-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aab0fc073e49da57e556df3019e514d5", + "name": "pyyaml", + "sha256": "4d89212418ecb3cb74ca4453dafe7a40f3be5a551da7b9ed5af303a9edb3e6d5", + "size": 184830, + "subdir": "linux-64", + "timestamp": 1611258452686, + "version": "5.4.1" + }, + "pyyaml-6.0-py310h5eee18b_1.tar.bz2": { + "build": "py310h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a59a7b75e9a389de8b065697e483a16", + "name": "pyyaml", + "sha256": "c8c33e2515cfe179be55283b002779af195b1a54d93be1601aa89400b3963888", + "size": 175696, + "subdir": "linux-64", + "timestamp": 1670514836081, + "version": "6.0" + }, + "pyyaml-6.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02982f901d86037ecc12cd93108d2c19", + "name": "pyyaml", + "sha256": "2249185121c4179d5efac551a3ebeace1d5b63d5f4f08211a4fdf1536cd218f1", + "size": 496996, + "subdir": "linux-64", + "timestamp": 1640794093967, + "version": "6.0" + }, + "pyyaml-6.0-py311h5eee18b_1.tar.bz2": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aff739800ceebb9e36a0e6bff2ed5238", + "name": "pyyaml", + "sha256": "803791d42ff8d3bbde9c223deab56948f73cd06ffa751ef996eb7b0c4697822b", + "size": 206333, + "subdir": "linux-64", + "timestamp": 1676827465689, + "version": "6.0" + }, + "pyyaml-6.0-py37h5eee18b_1.tar.bz2": { + "build": "py37h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b0b7ed521cf3079752be31d988ccd6cb", + "name": "pyyaml", + "sha256": "deb32fabe4c85b62cd351669a7490f4f0f702f85821225df79013531b63ca395", + "size": 183839, + "subdir": "linux-64", + "timestamp": 1670514869797, + "version": "6.0" + }, + "pyyaml-6.0-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bcd6e5cd7d0b197909e24f9e997ba7e8", + "name": "pyyaml", + "sha256": "31b2c03028d3ef571e86c6b817952ecac6dc0b1e61fa91ab511f97726c8b325d", + "size": 178163, + "subdir": "linux-64", + "timestamp": 1635856578229, + "version": "6.0" + }, + "pyyaml-6.0-py37h7f8727e_1.tar.bz2": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dccc3e7ee8eacd1449e7ae4344d6b163", + "name": "pyyaml", + "sha256": "70e39f37ef7c30c924164e77ccad50e2421acdbaa857e711537c7d5c1c6a9b1d", + "size": 178113, + "subdir": "linux-64", + "timestamp": 1635775765870, + "version": "6.0" + }, + "pyyaml-6.0-py38h5eee18b_1.tar.bz2": { + "build": "py38h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1e789ac6cd85344fbd8a099554b693e", + "name": "pyyaml", + "sha256": "40b5e396ce4d3011af39c11997c7d9910a879bb2d30cb2e381eefa2d37aea81d", + "size": 188022, + "subdir": "linux-64", + "timestamp": 1670514804684, + "version": "6.0" + }, + "pyyaml-6.0-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e602b5722b3d8cf3f884c70390251eb9", + "name": "pyyaml", + "sha256": "a33887faa8f95542a6d2896db80f551275010812da8b75cdf967c63ef0719267", + "size": 183782, + "subdir": "linux-64", + "timestamp": 1635856578205, + "version": "6.0" + }, + "pyyaml-6.0-py38h7f8727e_1.tar.bz2": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d28a98def54cf09f7ad028e43f0b33a", + "name": "pyyaml", + "sha256": "4bba1dee9097258660877150dd378d5f39f688642add536c507aff94db35edaf", + "size": 183855, + "subdir": "linux-64", + "timestamp": 1635763881638, + "version": "6.0" + }, + "pyyaml-6.0-py39h5eee18b_1.tar.bz2": { + "build": "py39h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7627eddf5f123f6a727eb74e9089fe0", + "name": "pyyaml", + "sha256": "9560625d31f03f3a562ed1d42f88561194f32bdfd1807d42a86e1b5be4422d72", + "size": 183611, + "subdir": "linux-64", + "timestamp": 1670514771163, + "version": "6.0" + }, + "pyyaml-6.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e555a30ee765a26210538ac244c773b0", + "name": "pyyaml", + "sha256": "9fde5bfdf4fdd54726c4d6779f19502bd51344adc50c105d4b9b1443d2407d2a", + "size": 183657, + "subdir": "linux-64", + "timestamp": 1635856161227, + "version": "6.0" + }, + "pyyaml-6.0-py39h7f8727e_1.tar.bz2": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df73a5d2f6e089d51e71e91935a82c65", + "name": "pyyaml", + "sha256": "3da9cbbd49fac566433748bd245d09d7d5fcd28b04c0397cbbf6d5bb92f5c4a5", + "size": 183753, + "subdir": "linux-64", + "timestamp": 1635775763162, + "version": "6.0" + }, + "pyzmq-16.0.2-py27h297844f_2.tar.bz2": { + "build": "py27h297844f_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "python >=2.7,<2.8.0a0", + "zeromq 4.2*" + ], + "license": "BSD 3-clause", + "md5": "d6fbaad12dc80b18c643b6a1e901a84e", + "name": "pyzmq", + "sha256": "5f442698331af17b82edd5b7f1d4c0b23bc7b50a2d1a00f9506c4c26a30d2a79", + "size": 411991, + "subdir": "linux-64", + "timestamp": 1505688320277, + "version": "16.0.2" + }, + "pyzmq-16.0.2-py35h4be1f71_2.tar.bz2": { + "build": "py35h4be1f71_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "python >=3.5,<3.6.0a0", + "zeromq 4.2*" + ], + "license": "BSD 3-clause", + "md5": "b6613ac502b47eab75f4c154a120d0de", + "name": "pyzmq", + "sha256": "d1d01bff98de35f31821adcc5425d156e4ab008c9edf18b314df2e2aa081bcc9", + "size": 429086, + "subdir": "linux-64", + "timestamp": 1505688373594, + "version": "16.0.2" + }, + "pyzmq-16.0.2-py36h3b0cf96_2.tar.bz2": { + "build": "py36h3b0cf96_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "python >=3.6,<3.7.0a0", + "zeromq 4.2*" + ], + "license": "BSD 3-clause", + "md5": "b789d078314a001a0426ca9c0fb31dd8", + "name": "pyzmq", + "sha256": "31c10651c54a2ad3f6240ce7516787003a836243312306d9076b6d0cf7f74f64", + "size": 428901, + "subdir": "linux-64", + "timestamp": 1505688421122, + "version": "16.0.2" + }, + "pyzmq-16.0.3-py27hc579512_0.tar.bz2": { + "build": "py27hc579512_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "python >=2.7,<2.8.0a0", + "zeromq 4.2*" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7ccc9b91f1c289d603c84c7bcf4044bc", + "name": "pyzmq", + "sha256": "63688b2cbb6f8ed1f7bd697e544346620efd28b3ff13bec3c4fd38dc240dba90", + "size": 421138, + "subdir": "linux-64", + "timestamp": 1511321235661, + "version": "16.0.3" + }, + "pyzmq-16.0.3-py35ha889422_0.tar.bz2": { + "build": "py35ha889422_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "python >=3.5,<3.6.0a0", + "zeromq 4.2*" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "76b7e0bc708360033c1954eb4bc4d3cf", + "name": "pyzmq", + "sha256": "bb8d275da6066856b4b2a81a4ff77a712db6260fd8f46c9cf1f6bf4b691ca0e4", + "size": 440881, + "subdir": "linux-64", + "timestamp": 1511321187415, + "version": "16.0.3" + }, + "pyzmq-16.0.3-py36he2533c7_0.tar.bz2": { + "build": "py36he2533c7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "python >=3.6,<3.7.0a0", + "zeromq 4.2*" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e5d8e289630ca908af08793aaf211c2e", + "name": "pyzmq", + "sha256": "c336c699fcc2a5de4b5fec870d6eb064bf7a49279178d00fbb5508c36ddfa358", + "size": 440634, + "subdir": "linux-64", + "timestamp": 1511321239718, + "version": "16.0.3" + }, + "pyzmq-17.0.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "python >=2.7,<2.8.0a0", + "zeromq >=4.2.3,<4.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6207cad7990b138fbd5747115832a692", + "name": "pyzmq", + "sha256": "1ea09d4c1afb402831a09603bec02ec9d412b165158263988fffce087cc31829", + "size": 450367, + "subdir": "linux-64", + "timestamp": 1520450582407, + "version": "17.0.0" + }, + "pyzmq-17.0.0-py27h14c3975_1.tar.bz2": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=2.7,<2.8.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "098dec648460ed7404080cf0ea1e8288", + "name": "pyzmq", + "sha256": "c3f2d74ae14252e2983c6372fde432df9e3b96c9a1e95d01b493a1f7518dfceb", + "size": 450376, + "subdir": "linux-64", + "timestamp": 1523651175989, + "version": "17.0.0" + }, + "pyzmq-17.0.0-py27h14c3975_3.tar.bz2": { + "build": "py27h14c3975_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=2.7,<2.8.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e3ca61de5b29221e62193e848bcf834b", + "name": "pyzmq", + "sha256": "739a24cb581a5b08375be7d5b511e2d9db212d94b7f52d4422127db281a4b4ad", + "size": 450380, + "subdir": "linux-64", + "timestamp": 1530694672902, + "version": "17.0.0" + }, + "pyzmq-17.0.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "python >=3.5,<3.6.0a0", + "zeromq >=4.2.3,<4.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ec907537e46776866b5e9a3aeed4f8f2", + "name": "pyzmq", + "sha256": "98974c7ffd7dee0fab78684f26642f2d529a918bb5a30f0c542159060c9e91a0", + "size": 467510, + "subdir": "linux-64", + "timestamp": 1520450436971, + "version": "17.0.0" + }, + "pyzmq-17.0.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "python >=3.6,<3.7.0a0", + "zeromq >=4.2.3,<4.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b39b08470f56af9c56b873500856650e", + "name": "pyzmq", + "sha256": "f058f1a16cf096960d72f0bfa2f3579d2b0abc298015a73ff43cdb484bc12a4a", + "size": 464780, + "subdir": "linux-64", + "timestamp": 1520450438285, + "version": "17.0.0" + }, + "pyzmq-17.0.0-py36h14c3975_3.tar.bz2": { + "build": "py36h14c3975_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8ce7f0a5bf6e76b9638bd845a4f3f381", + "name": "pyzmq", + "sha256": "0a9bdabdff322c18f12a015ce18f9a17d5b87c2b8884966378e14e190ae422c3", + "size": 465703, + "subdir": "linux-64", + "timestamp": 1530694536138, + "version": "17.0.0" + }, + "pyzmq-17.0.0-py37h14c3975_3.tar.bz2": { + "build": "py37h14c3975_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "eab303fd24d7f17605c5d22d06929fc5", + "name": "pyzmq", + "sha256": "28616ea68ef6432fb6466748ddb77a305fe9c0f7f02e86eb3626ce918f7b9ba9", + "size": 465984, + "subdir": "linux-64", + "timestamp": 1530694607839, + "version": "17.0.0" + }, + "pyzmq-17.1.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=2.7,<2.8.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "23544faa9edb6df120ec87aa64e9cc31", + "name": "pyzmq", + "sha256": "bc16d066b24ad52f68f1e93cba2d32a5d9e00d4193f232c2c741c44c237af0e5", + "size": 456677, + "subdir": "linux-64", + "timestamp": 1533656247387, + "version": "17.1.0" + }, + "pyzmq-17.1.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.5,<3.6.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1b037ee7c72b0b3b9873f3a685ec55bf", + "name": "pyzmq", + "sha256": "dfec741b330aa2c66be81eca02cf973ccf6a142b96b829814a2bb733a866c78c", + "size": 475940, + "subdir": "linux-64", + "timestamp": 1533656271273, + "version": "17.1.0" + }, + "pyzmq-17.1.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "adbdc0ae9045ccd59e1b13911c952d47", + "name": "pyzmq", + "sha256": "ec98b15fafa065fbb6b88a76ce0f214189cd45f72f3829ede2fda0524b27813f", + "size": 472465, + "subdir": "linux-64", + "timestamp": 1533656172182, + "version": "17.1.0" + }, + "pyzmq-17.1.0-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ade546ca39f89d6364eb9ac778e6f422", + "name": "pyzmq", + "sha256": "fdfd5982848dc8db53a6956fa5be7e1ae5edeed39f6542ca166ffcc9660bdab1", + "size": 471874, + "subdir": "linux-64", + "timestamp": 1533656264988, + "version": "17.1.0" + }, + "pyzmq-17.1.2-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=2.7,<2.8.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "992629fff36f40213712eae2ca413558", + "name": "pyzmq", + "sha256": "67c44abe0f03b5f0925d2088fce0877e95d2587dd6686b33a58dd1d449c3dc89", + "size": 449248, + "subdir": "linux-64", + "timestamp": 1534270187020, + "version": "17.1.2" + }, + "pyzmq-17.1.2-py27he6710b0_2.tar.bz2": { + "build": "py27he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "43c5a298c2fec3b0a0eb45308769f70b", + "name": "pyzmq", + "sha256": "7e42133f341bbf097d84f46f1351e83eb9576cc669846559ab6b19cb21c79221", + "size": 449330, + "subdir": "linux-64", + "timestamp": 1549069267640, + "version": "17.1.2" + }, + "pyzmq-17.1.2-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.5,<3.6.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6498ca6beb44cadd40803ba5181d82b0", + "name": "pyzmq", + "sha256": "5c479080bba8fa72cbd7abee5363185804ac9f00d589cf42b3db4059c56e39c9", + "size": 469784, + "subdir": "linux-64", + "timestamp": 1534270303140, + "version": "17.1.2" + }, + "pyzmq-17.1.2-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "fab7e26588cf0fa7120f56bd1db06c3c", + "name": "pyzmq", + "sha256": "dbe4eb85e6346274f53a5fbd81610b9729adbc4d2f2be2224d7b088ea6208fa4", + "size": 464863, + "subdir": "linux-64", + "timestamp": 1534270165340, + "version": "17.1.2" + }, + "pyzmq-17.1.2-py36he6710b0_2.tar.bz2": { + "build": "py36he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d5ce3bb2d4f0ee9e5a16958abc08229b", + "name": "pyzmq", + "sha256": "9f245d12424ac2a89070477da851f14f0b72f7763ffa785898ebbc0cc3cd9780", + "size": 473001, + "subdir": "linux-64", + "timestamp": 1549069328561, + "version": "17.1.2" + }, + "pyzmq-17.1.2-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "534e2ef56f5eb4211218439bab52b0d1", + "name": "pyzmq", + "sha256": "728d5751e6dd4f5e91b785d412592e425ecf2cdef28e21eb7f542d520496a573", + "size": 464615, + "subdir": "linux-64", + "timestamp": 1534270221172, + "version": "17.1.2" + }, + "pyzmq-17.1.2-py37he6710b0_2.tar.bz2": { + "build": "py37he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b3ff1a6b0f85bc1749dabc1604481b6b", + "name": "pyzmq", + "sha256": "84287ec5e71d461c0fdd3cdfd14807f29ba60bdadffe7b6713d505336cf0daeb", + "size": 493465, + "subdir": "linux-64", + "timestamp": 1549069299194, + "version": "17.1.2" + }, + "pyzmq-18.0.0-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "83b1ce6d3962786fd49f9014e13f5f15", + "name": "pyzmq", + "sha256": "7d8b347e34814105b8a01c240b3535e5058f9ab10bd73b4f3f5252cbac5cef58", + "size": 474609, + "subdir": "linux-64", + "timestamp": 1551148183095, + "version": "18.0.0" + }, + "pyzmq-18.0.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ab599ac1bbae87882996746bf7a57f66", + "name": "pyzmq", + "sha256": "e0d06e84d0c0ac46e20f1a757ef1fda4c0ec9b8e4e16f64ee9d6fbc71d572837", + "size": 530403, + "subdir": "linux-64", + "timestamp": 1551148222885, + "version": "18.0.0" + }, + "pyzmq-18.0.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3a8195baa7d507133b731d6941b84857", + "name": "pyzmq", + "sha256": "5a116209b0a460713601f8a9b801f5f481a2c71ee98e23707ef255f3c734ca01", + "size": 505111, + "subdir": "linux-64", + "timestamp": 1551148167486, + "version": "18.0.0" + }, + "pyzmq-18.1.0-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b042cec6653ccf7942fbaef91608fff8", + "name": "pyzmq", + "sha256": "9273d345c643e52bda412397a4e279c05ad2746cf9f235b926d9be49c41a0552", + "size": 477867, + "subdir": "linux-64", + "timestamp": 1565899590740, + "version": "18.1.0" + }, + "pyzmq-18.1.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dcc92a3c2a13f3866116982dbd427cc3", + "name": "pyzmq", + "sha256": "8f3349907b4bfa2030a572247f66922b75b256491102cbadf2142b59b555cc35", + "size": 532316, + "subdir": "linux-64", + "timestamp": 1565899652077, + "version": "18.1.0" + }, + "pyzmq-18.1.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ef9a68fb72606d56575ce209476ee03d", + "name": "pyzmq", + "sha256": "fb5506d79a02d94121fbc3834d3ffa3fc94f49043ebf5a84d0d7ba5f59ab8e9e", + "size": 509882, + "subdir": "linux-64", + "timestamp": 1565899639474, + "version": "18.1.0" + }, + "pyzmq-18.1.0-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "91c6322674ef3fdb48b0a58ffb8a59da", + "name": "pyzmq", + "sha256": "f1aad433833630d4f898f80b3e1af931b7dd1cab2e95cf95f56084a586418448", + "size": 528200, + "subdir": "linux-64", + "timestamp": 1573200514620, + "version": "18.1.0" + }, + "pyzmq-18.1.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "af040d3af900ad8377a32c57288de05f", + "name": "pyzmq", + "sha256": "42a80618e98dac1407e4b19befef21e9f803e8a32b50c042928137205f202728", + "size": 537120, + "subdir": "linux-64", + "timestamp": 1580845541202, + "version": "18.1.1" + }, + "pyzmq-18.1.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "40588c581c613a223fdd4a66468029a1", + "name": "pyzmq", + "sha256": "97e8bda4468881eaaf445e507b0afe2995533be7378a00838a305692551dad03", + "size": 534288, + "subdir": "linux-64", + "timestamp": 1580845541401, + "version": "18.1.1" + }, + "pyzmq-18.1.1-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2bc807da0d4b40af361b43b9b0a88db6", + "name": "pyzmq", + "sha256": "d7be27ce415b5677488da6c87b27294f6f1b8cf2612371084bc04eec12c2f33c", + "size": 544381, + "subdir": "linux-64", + "timestamp": 1580845531549, + "version": "18.1.1" + }, + "pyzmq-19.0.1-py36he6710b0_1.tar.bz2": { + "build": "py36he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.3.2,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9de81ee04b3ef50b11e19266850d55a3", + "name": "pyzmq", + "sha256": "9a486901007f72a7c359a1804d45ec263a7dbb06b3eb5c8801ff7a05f518b060", + "size": 522475, + "subdir": "linux-64", + "timestamp": 1593033318498, + "version": "19.0.1" + }, + "pyzmq-19.0.1-py37he6710b0_1.tar.bz2": { + "build": "py37he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.2,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e078200f81950b99a16480a39a3d0607", + "name": "pyzmq", + "sha256": "872d7844217aa5cd4fcdc8a1dbac5f4ef92587737ca39a820e333e4b41cebdf6", + "size": 512280, + "subdir": "linux-64", + "timestamp": 1593033313628, + "version": "19.0.1" + }, + "pyzmq-19.0.1-py38he6710b0_1.tar.bz2": { + "build": "py38he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zeromq >=4.3.2,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ad94f1123f4468946065130ea8f534c8", + "name": "pyzmq", + "sha256": "041700048466fe68cac984ef068b04fc448430696ccbb76f4b6ae06f128ccc3d", + "size": 522171, + "subdir": "linux-64", + "timestamp": 1593033315584, + "version": "19.0.1" + }, + "pyzmq-19.0.2-py36he6710b0_1.tar.bz2": { + "build": "py36he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.3.2,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "74cef8a20c8ad0e988e461d5da67ec33", + "name": "pyzmq", + "sha256": "62e60496c18451779842da4226f5e78c6cc73ebf2d625bf874b9373f9bd0353a", + "size": 490691, + "subdir": "linux-64", + "timestamp": 1600460611142, + "version": "19.0.2" + }, + "pyzmq-19.0.2-py37he6710b0_1.tar.bz2": { + "build": "py37he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.2,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d0acc86793afb05a45b3efe50d6d5aed", + "name": "pyzmq", + "sha256": "21f307a7bdf001d57867ac97f94d9bf25eb1134091896a32bc36104006071354", + "size": 511243, + "subdir": "linux-64", + "timestamp": 1600460610477, + "version": "19.0.2" + }, + "pyzmq-19.0.2-py38he6710b0_1.tar.bz2": { + "build": "py38he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zeromq >=4.3.2,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4007dc7c28841a309b32a6a86ac4d686", + "name": "pyzmq", + "sha256": "c958efdca86d56acb760f0b81308ab46515cb51a40965d118f89b24f87e68220", + "size": 513988, + "subdir": "linux-64", + "timestamp": 1600460603061, + "version": "19.0.2" + }, + "pyzmq-20.0.0-py36h2531618_1.tar.bz2": { + "build": "py36h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.3.3,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "26635da7bf82d363ce7974e8d43f6bdd", + "name": "pyzmq", + "sha256": "b4337dcc3d7f0210bb97d7267cd8356689e3bfe22651d3442ac1fcfa6a7db71e", + "size": 482995, + "subdir": "linux-64", + "timestamp": 1606690982209, + "version": "20.0.0" + }, + "pyzmq-20.0.0-py37h2531618_1.tar.bz2": { + "build": "py37h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.3,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "830c07d03922face3432371c4cffa933", + "name": "pyzmq", + "sha256": "34dbcdcc4946af209870c541d3c7a8ce92e86f0b2aa902fcad7a6ba126c2a501", + "size": 482695, + "subdir": "linux-64", + "timestamp": 1606690966744, + "version": "20.0.0" + }, + "pyzmq-20.0.0-py38h2531618_1.tar.bz2": { + "build": "py38h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zeromq >=4.3.3,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4361498d9329686b17a64a2168385cf2", + "name": "pyzmq", + "sha256": "e15682026b246592980645314e88d9f65659eb6adcf486f5f8b1e504e7c66df5", + "size": 526151, + "subdir": "linux-64", + "timestamp": 1606690975269, + "version": "20.0.0" + }, + "pyzmq-20.0.0-py39h2531618_1.tar.bz2": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "zeromq >=4.3.3,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e679607f946ebfe3a28e5c7f5a8efa90", + "name": "pyzmq", + "sha256": "a67edcd2621e27283fc90ba0fca33aefa1b3e436d6cb143f270d2181d7aa8d94", + "size": 494245, + "subdir": "linux-64", + "timestamp": 1606690980826, + "version": "20.0.0" + }, + "pyzmq-22.2.1-py36h295c915_1.tar.bz2": { + "build": "py36h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d616468605cc7aac9f80e920c1e8c224", + "name": "pyzmq", + "sha256": "8703ee6c0140b4ac7a5aab531dc615467287cba206c44dcb08ad1f2858c93c7a", + "size": 531344, + "subdir": "linux-64", + "timestamp": 1628268483717, + "version": "22.2.1" + }, + "pyzmq-22.2.1-py37h295c915_1.tar.bz2": { + "build": "py37h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6a05bbd4e73a7b353dc7bd36a9ae988d", + "name": "pyzmq", + "sha256": "1dd039ea37f98561d318bd802d88adb96cc05e95ede0eab53c4186564e5c94e1", + "size": 533134, + "subdir": "linux-64", + "timestamp": 1628267986245, + "version": "22.2.1" + }, + "pyzmq-22.2.1-py38h295c915_1.tar.bz2": { + "build": "py38h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "94af541ca00906418f990cb2e97cc389", + "name": "pyzmq", + "sha256": "c81512bde6b1b09766b4fe3c2e067fad0581f7dd2bc3d76c204862f0ed43d053", + "size": 543984, + "subdir": "linux-64", + "timestamp": 1628276077821, + "version": "22.2.1" + }, + "pyzmq-22.2.1-py39h295c915_1.tar.bz2": { + "build": "py39h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "375ce50cdc9fc9469fbcc3c176e5b9c7", + "name": "pyzmq", + "sha256": "c29192d0970820235c107276264e7d57c25d7e2d4b9b7eaf1f63a20e6b653a38", + "size": 514554, + "subdir": "linux-64", + "timestamp": 1628275446063, + "version": "22.2.1" + }, + "pyzmq-22.3.0-py310h295c915_2.tar.bz2": { + "build": "py310h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "16950ca6a2533f8b599a6ecfe19b1a15", + "name": "pyzmq", + "sha256": "6e02808cda36e9049ffb1aa8848e34d79b433f0ec63da0760af2c6eabaee0b34", + "size": 1298077, + "subdir": "linux-64", + "timestamp": 1640794137148, + "version": "22.3.0" + }, + "pyzmq-22.3.0-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "a92f4d51ebd80e0bdcfe9a0397010846", + "name": "pyzmq", + "sha256": "363368d619cb5b8bb1414b82011512f56994387979562940b9a7578e1222a39e", + "size": 537445, + "subdir": "linux-64", + "timestamp": 1638366340622, + "version": "22.3.0" + }, + "pyzmq-22.3.0-py37h295c915_1.tar.bz2": { + "build": "py37h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d8d176cd575ebc8672eb2555afc208ce", + "name": "pyzmq", + "sha256": "60b008105d558a2af424a69677733d39a1549e2612e12d2d0981048d82af8872", + "size": 535906, + "subdir": "linux-64", + "timestamp": 1638358416642, + "version": "22.3.0" + }, + "pyzmq-22.3.0-py37h295c915_2.tar.bz2": { + "build": "py37h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "cdd58f1bbdcb4b47f988187197178428", + "name": "pyzmq", + "sha256": "4dee0b759eb703460fd9b0fa5fc63963d8db91efbd70e1f5814364874c7a0aeb", + "size": 544191, + "subdir": "linux-64", + "timestamp": 1638434984801, + "version": "22.3.0" + }, + "pyzmq-22.3.0-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "0a56ac92dcc507fa8276e1e4b5544d3e", + "name": "pyzmq", + "sha256": "67eb936b47b2a0e03aa89ee3ef3456eb220ae2484e0fea163441d2a354c93088", + "size": 547078, + "subdir": "linux-64", + "timestamp": 1638366339926, + "version": "22.3.0" + }, + "pyzmq-22.3.0-py38h295c915_2.tar.bz2": { + "build": "py38h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "ccfebd6d36d1a727dc2922b2e21814ad", + "name": "pyzmq", + "sha256": "de6699ca6cf7fd88e0074c457dd6aa6928ee5256c93b3a86daaf0b0501aef556", + "size": 539827, + "subdir": "linux-64", + "timestamp": 1638436432728, + "version": "22.3.0" + }, + "pyzmq-22.3.0-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "573e7188ca111d892658818ea0778e13", + "name": "pyzmq", + "sha256": "121ea4ff4a75ad733df8a3155676b596d13c5b849628aae01c8c40158dbc0d19", + "size": 545099, + "subdir": "linux-64", + "timestamp": 1638366868850, + "version": "22.3.0" + }, + "pyzmq-22.3.0-py39h295c915_2.tar.bz2": { + "build": "py39h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "2dc75d5a4ccb64310939c3a72d34ae20", + "name": "pyzmq", + "sha256": "26005d191bb15070aad70707ed6493f32678a67978bd3b83d4c9679cab44e717", + "size": 521583, + "subdir": "linux-64", + "timestamp": 1638435042256, + "version": "22.3.0" + }, + "pyzmq-23.2.0-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-Clause AND LGPL-3.0-or-later", + "license_family": "BSD", + "md5": "d3d56ca7c96ad04a5fa0778e20f716aa", + "name": "pyzmq", + "sha256": "299688a1eb0860c36a70b168df58d74f10f94f8969d1f30dcfeb4e284e3e2ac7", + "size": 1295005, + "subdir": "linux-64", + "timestamp": 1657724267998, + "version": "23.2.0" + }, + "pyzmq-23.2.0-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-Clause AND LGPL-3.0-or-later", + "license_family": "BSD", + "md5": "5db7c977dfea8e15c793eb29e1bf4a6d", + "name": "pyzmq", + "sha256": "e55e1f428cfc585bd08af13cf494a5de0adffab426b68c2ea05d4b3ea52f9785", + "size": 585394, + "subdir": "linux-64", + "timestamp": 1676918919898, + "version": "23.2.0" + }, + "pyzmq-23.2.0-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-Clause AND LGPL-3.0-or-later", + "license_family": "BSD", + "md5": "93a2963d627260a934563f6598d0037a", + "name": "pyzmq", + "sha256": "302193f0f23189642c43adbedb3257a06cb4f50f24838d22914cfa0af77352c1", + "size": 508259, + "subdir": "linux-64", + "timestamp": 1657724324840, + "version": "23.2.0" + }, + "pyzmq-23.2.0-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-Clause AND LGPL-3.0-or-later", + "license_family": "BSD", + "md5": "70b353ff1ea3c4a8ad01748abcc650cc", + "name": "pyzmq", + "sha256": "2f66f4d7991f4b0d88ccd9a6a5fd450a0ab8f33f5106b2bed4aec281fea47035", + "size": 518386, + "subdir": "linux-64", + "timestamp": 1657724378233, + "version": "23.2.0" + }, + "pyzmq-23.2.0-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-Clause AND LGPL-3.0-or-later", + "license_family": "BSD", + "md5": "bf2a4feb20647c569f7ce5a8f63094fa", + "name": "pyzmq", + "sha256": "70ee4fc614dd3337ad542c7c961428930160ab8c7da27775faed5ffddbd362d7", + "size": 515650, + "subdir": "linux-64", + "timestamp": 1657724431309, + "version": "23.2.0" + }, + "pyzstd-0.14.4-py36h7f8727e_3.tar.bz2": { + "build": "py36h7f8727e_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ca24e3de33e01ecc7b36c2253d502b32", + "name": "pyzstd", + "sha256": "77919d81a6e5e80a675ab2d78c084cf7a3ff6164a8f383736f1c10df9a86fccc", + "size": 91094, + "subdir": "linux-64", + "timestamp": 1633097303780, + "version": "0.14.4" + }, + "pyzstd-0.14.4-py37h7f8727e_3.tar.bz2": { + "build": "py37h7f8727e_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "023cc4bf71fe1939511939135b45e2ea", + "name": "pyzstd", + "sha256": "ee79900729a66a289e18e19380857668c019b8e08cd7501bbbbfa7f51ae294b9", + "size": 91091, + "subdir": "linux-64", + "timestamp": 1633097119958, + "version": "0.14.4" + }, + "pyzstd-0.14.4-py38h7f8727e_3.tar.bz2": { + "build": "py38h7f8727e_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fdfedcac0c1b550eebc10ed609e0554e", + "name": "pyzstd", + "sha256": "18c26853f631aea6080c3021afc0d5062db9535e97c16f47feaef06ec1242441", + "size": 91542, + "subdir": "linux-64", + "timestamp": 1633086757270, + "version": "0.14.4" + }, + "pyzstd-0.14.4-py39h7f8727e_3.tar.bz2": { + "build": "py39h7f8727e_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9347dbf9241904513013f65383511194", + "name": "pyzstd", + "sha256": "f295dfc3c66b055ace2cb32a2e85f1d9136c20c2eb234eee8ffcfa425e0b0644", + "size": 91589, + "subdir": "linux-64", + "timestamp": 1633097291179, + "version": "0.14.4" + }, + "pyzstd-0.15.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "zstd >=1.5.0,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a135de15dc926e50ff24449bcdb394b3", + "name": "pyzstd", + "sha256": "ccb9b0f92b59e77d187405721a20705dbd6db0e0f426d6fd56faef966ef5c4bb", + "size": 152058, + "subdir": "linux-64", + "timestamp": 1640794163271, + "version": "0.15.0" + }, + "pyzstd-0.15.0-py311h2c38b39_0.tar.bz2": { + "build": "py311h2c38b39_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "703be2dcac4222ba80f927ed849a47c4", + "name": "pyzstd", + "sha256": "be35560d54befad0daa09f999690a57b5935e7ea8122f838fd79c516292e4b50", + "size": 97469, + "subdir": "linux-64", + "timestamp": 1676861667488, + "version": "0.15.0" + }, + "pyzstd-0.15.0-py36h7f8727e_0.tar.bz2": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "019f8bf9d81a96a53a3d92e49109071f", + "name": "pyzstd", + "sha256": "0098dbf49ef06f7ec1d5cb75457676b64beb929c73b01c4eee4ee5dc9471e52c", + "size": 95734, + "subdir": "linux-64", + "timestamp": 1633081810925, + "version": "0.15.0" + }, + "pyzstd-0.15.0-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7906ed0b6db2e426a03dd30ca02e7f0b", + "name": "pyzstd", + "sha256": "f60d5eb0ffb237d96d164a1b02928b565fae24c1d21d3eb084358679e2057703", + "size": 95684, + "subdir": "linux-64", + "timestamp": 1633092318325, + "version": "0.15.0" + }, + "pyzstd-0.15.0-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "665c84a1d48138c90e98db617dc8b135", + "name": "pyzstd", + "sha256": "be2e7dcc981b06e22cff39b903ccc4e9b106078cbe5a2e1a37bb7362c2572bee", + "size": 96164, + "subdir": "linux-64", + "timestamp": 1633092029033, + "version": "0.15.0" + }, + "pyzstd-0.15.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb074da63398969708d99736c0c15d2d", + "name": "pyzstd", + "sha256": "5eaa9bdad6c654d2f06895cd9968549804a4a3b0f707d893ba5de36e23175aed", + "size": 96298, + "subdir": "linux-64", + "timestamp": 1633092319889, + "version": "0.15.0" + }, + "qasync-0.23.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "652f77f063706eb4d8dbee556d6fa884", + "name": "qasync", + "sha256": "cf70b7b3694d68929d8e86ea68be6ad73e320e64e6bc43a2240909eb9dec07ec", + "size": 29606, + "subdir": "linux-64", + "timestamp": 1659335808139, + "version": "0.23.0" + }, + "qasync-0.23.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "3d6eddccf4b714fa013abf121ac4ef36", + "name": "qasync", + "sha256": "6be25579f706eaeb6d824510ad9aae669f7cf00bb71f54fb7fb0cd09b5ff2646", + "size": 37973, + "subdir": "linux-64", + "timestamp": 1676842415853, + "version": "0.23.0" + }, + "qasync-0.23.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "7a856c6fd65fc428c87e8ed4b861561b", + "name": "qasync", + "sha256": "162b3262369ba531aba8c4bb8aac2d0cb5c7fb368b7080877b7d3f90300e28c7", + "size": 29200, + "subdir": "linux-64", + "timestamp": 1659335768493, + "version": "0.23.0" + }, + "qasync-0.23.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a5c30c4625d83e93a23cd043639d9c85", + "name": "qasync", + "sha256": "89b21c74b7915a98a3ed2ecb835aa059dbdd1cccdb6197f65de6f41d660364ee", + "size": 29307, + "subdir": "linux-64", + "timestamp": 1659335783046, + "version": "0.23.0" + }, + "qasync-0.23.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "51206c9527741d3a3ceec6dd1aa431b9", + "name": "qasync", + "sha256": "5811e599578abf48e463d919a5baedf4a547655c1d7a2c2f06dcbf87b1634664", + "size": 29417, + "subdir": "linux-64", + "timestamp": 1659335822945, + "version": "0.23.0" + }, + "qcachegrind-0.7.4-he6710b0_1.tar.bz2": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "qt >=5.9.6,<5.10.0a0" + ], + "license": "GPLv2", + "license_family": "GPL2", + "md5": "fa12641ebc769417d7423355408444db", + "name": "qcachegrind", + "sha256": "796f8e7e46da077811e24576672bc512e4e85754d63ade7deba6f2ac436d8206", + "size": 597649, + "subdir": "linux-64", + "timestamp": 1539289966075, + "version": "0.7.4" + }, + "qgrid-1.0.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "42ff271eddcb1107d9ca6404126c0be4", + "name": "qgrid", + "sha256": "91cb9f3e57d7b0a59323e8c3fcd75467fa235db246055b1846b41ca2c451ec21", + "size": 1292090, + "subdir": "linux-64", + "timestamp": 1519244094863, + "version": "1.0.1" + }, + "qgrid-1.0.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dd5731e3dbd20c30dbb004e9e2da8f08", + "name": "qgrid", + "sha256": "fe4296510c1efd30f80e8d8b0ec79b041bc4efe6e17176a4b7e1a2d350c4e558", + "size": 1295763, + "subdir": "linux-64", + "timestamp": 1519244112558, + "version": "1.0.1" + }, + "qgrid-1.0.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3a269502a9920517b6ba5f2a754eb9ab", + "name": "qgrid", + "sha256": "fb54699173df493f931d4b6c711ea1c01e2e5372dff5841d81a0c3572e8e4837", + "size": 1295279, + "subdir": "linux-64", + "timestamp": 1519244073031, + "version": "1.0.1" + }, + "qgrid-1.0.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "29e50c502d8ab89cc6ad32582d930e11", + "name": "qgrid", + "sha256": "c9c0bacef19086d9b8c2ea47b43ec6ee36c68351f0acb1c2b093f147f7c7a6ab", + "size": 1296767, + "subdir": "linux-64", + "timestamp": 1522195822260, + "version": "1.0.2" + }, + "qgrid-1.0.2-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c9ddb10841dda933f2509995b16fa40d", + "name": "qgrid", + "sha256": "c0142590b0baa5edad7b5b7384e99274008857b36515482ebc3867ffe5c2f0db", + "size": 1298844, + "subdir": "linux-64", + "timestamp": 1522195137429, + "version": "1.0.2" + }, + "qgrid-1.0.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "18ece15082128e90d776db78b005e24e", + "name": "qgrid", + "sha256": "be2e2e98de0013b7ad25678fded819eaecb260f4a50ce2e795714b20d40d8341", + "size": 1297705, + "subdir": "linux-64", + "timestamp": 1522195105408, + "version": "1.0.2" + }, + "qgrid-1.0.5-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8cb35b63b930e72c0dac695a45be5c33", + "name": "qgrid", + "sha256": "618844790b439605ff6d351e1b5c4260ae9f1c0ba5028bb5a15cc09b3df3c245", + "size": 1309579, + "subdir": "linux-64", + "timestamp": 1528148018503, + "version": "1.0.5" + }, + "qgrid-1.0.5-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f5a2a50364dd77de52f25892799d8661", + "name": "qgrid", + "sha256": "e192f37ed6ed497986c75c6924d232ff61d32fd110137a0047aadc1053be53f7", + "size": 1310787, + "subdir": "linux-64", + "timestamp": 1528148038012, + "version": "1.0.5" + }, + "qgrid-1.0.5-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b59fa7f42d61a1d22e54ce6512325976", + "name": "qgrid", + "sha256": "7ed97b68e32e9d82697c1b3f509d3cc9b981e8096bd80752e158071db65847f8", + "size": 1310029, + "subdir": "linux-64", + "timestamp": 1528148002672, + "version": "1.0.5" + }, + "qgrid-1.0.5-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8ce1c8678a2b5ec3cc9ede8b0ae5725d", + "name": "qgrid", + "sha256": "3be925aa3d9a2e9500675a0173401aecdb75fca8477ae066b4ac8c1c4995e782", + "size": 1310314, + "subdir": "linux-64", + "timestamp": 1530923072757, + "version": "1.0.5" + }, + "qgrid-1.1.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "573f5d5b8ab50a6d162638cd09855289", + "name": "qgrid", + "sha256": "d275352e5b70c75143fd488602b3311a2d0f137328d804adf6e1a93a2df44212", + "size": 1320411, + "subdir": "linux-64", + "timestamp": 1535430583157, + "version": "1.1.1" + }, + "qgrid-1.1.1-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1df2ea5c1cc01d0298c815a2fcf5c14f", + "name": "qgrid", + "sha256": "23ccda57dea5c73d50a30f309b0317ee89a9fd73b606e88d466bf4b54cd02469", + "size": 1321247, + "subdir": "linux-64", + "timestamp": 1549994197635, + "version": "1.1.1" + }, + "qgrid-1.1.1-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "820797ee964b1956587930399365d319", + "name": "qgrid", + "sha256": "5d75da0a3f65a3cc5af75939c01144cea1f2159b9a6709138e1cc3599e2515a0", + "size": 1343118, + "subdir": "linux-64", + "timestamp": 1642760550795, + "version": "1.1.1" + }, + "qgrid-1.1.1-py311h06a4308_2.tar.bz2": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5f05692a91eeba901ee9eeda16f1f600", + "name": "qgrid", + "sha256": "da487ef608580af402a413f2acb5cce829dbb202a4517554096dbb6038684c5f", + "size": 1359582, + "subdir": "linux-64", + "timestamp": 1676922559703, + "version": "1.1.1" + }, + "qgrid-1.1.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a74f7f06a12a78b72eb25570358fcd0c", + "name": "qgrid", + "sha256": "a417a50e3ec25f16e2a37e783d5763b6ecf7e46aad70ec283fc212c37f64fce9", + "size": 1322308, + "subdir": "linux-64", + "timestamp": 1535430580922, + "version": "1.1.1" + }, + "qgrid-1.1.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ce0b276397a601a8cf7090efdd8402ca", + "name": "qgrid", + "sha256": "a4d8edfbcf26ce4cb1fe5acdc594de4557095e98e55500219317bc88a1d67d61", + "size": 1323485, + "subdir": "linux-64", + "timestamp": 1535430580054, + "version": "1.1.1" + }, + "qgrid-1.1.1-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "25a55694f500471f13d44b7ce8013a5f", + "name": "qgrid", + "sha256": "998cb45ef75007751f43007c525141b4f4ee121b6ffbcab2ed5251962ba36c05", + "size": 1339937, + "subdir": "linux-64", + "timestamp": 1549994225633, + "version": "1.1.1" + }, + "qgrid-1.1.1-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "12651f0f42c0e18109fdef8067e55dcd", + "name": "qgrid", + "sha256": "319163d3b07575a6ca7852bb93d9d8a7d1b4c1df0e7abc9bd9bd63fb52cf0bf2", + "size": 1326450, + "subdir": "linux-64", + "timestamp": 1614090104207, + "version": "1.1.1" + }, + "qgrid-1.1.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "961e104accfc7e01d49ec8c2e5bb3e9c", + "name": "qgrid", + "sha256": "0dd2e35a73edaa04016471e27de6cc778bd8281e68196bb72deb1924ed86da30", + "size": 1323097, + "subdir": "linux-64", + "timestamp": 1535430638314, + "version": "1.1.1" + }, + "qgrid-1.1.1-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f2f275195102f06a13abb4a159922be9", + "name": "qgrid", + "sha256": "f8287444b214be4a73ffc3057abaab97ba6c3e23d6ba8e0c2cdce7bb2d81d149", + "size": 1339235, + "subdir": "linux-64", + "timestamp": 1549994180592, + "version": "1.1.1" + }, + "qgrid-1.1.1-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d6773534dab9d19df9a8805bb45d5624", + "name": "qgrid", + "sha256": "e34271755746f1ff285fd9a2146ec36303d164659672b1ea8d6497e984bc89cb", + "size": 1342784, + "subdir": "linux-64", + "timestamp": 1614090717117, + "version": "1.1.1" + }, + "qgrid-1.1.1-py38_2.tar.bz2": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "53b618135d3b70b61f2733419477f216", + "name": "qgrid", + "sha256": "8092fdcb9c57b7f0f021385e43de40a4530eef9d1cdee5c673a2c83356f7d923", + "size": 1343124, + "subdir": "linux-64", + "timestamp": 1592485517341, + "version": "1.1.1" + }, + "qgrid-1.1.1-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b1d47b851c935475dd93b82cbfb00f1a", + "name": "qgrid", + "sha256": "69bfcd61d8503b77c4a6909c9b7d37382a8b56b9a45d7f509648220cc23569da", + "size": 1347068, + "subdir": "linux-64", + "timestamp": 1614091010018, + "version": "1.1.1" + }, + "qgrid-1.1.1-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c69d57112dde4bbc4ee03099bc2f3839", + "name": "qgrid", + "sha256": "58dd533d7accbd59cde9ef9c33d258c7bf69556ec780816a7fb1e9ba81b4c2f3", + "size": 1334727, + "subdir": "linux-64", + "timestamp": 1614090045872, + "version": "1.1.1" + }, + "qgrid-1.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8d528644013b901a64a0523c01521633", + "name": "qgrid", + "sha256": "1e2c01b6684dc4a13efacfbf0c398b02df9f89fb57033462b26ed3d1b2a928b7", + "size": 1550311, + "subdir": "linux-64", + "timestamp": 1599278599966, + "version": "1.3.1" + }, + "qgrid-1.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "65826bca0d9bf6bf2f55a0a85c739128", + "name": "qgrid", + "sha256": "1f99079404e5f76bbfbb0865ed1aefdf1a532a8080b95865a9f79090f9e47e84", + "size": 1556910, + "subdir": "linux-64", + "timestamp": 1599278584151, + "version": "1.3.1" + }, + "qgrid-1.3.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8dd7cd179e7e894d7d78f1ef4d7e2704", + "name": "qgrid", + "sha256": "47344fe3604268c37aa8864390fc0197194afb8f3d7c3a7ecc532ca259a4d598", + "size": 1558453, + "subdir": "linux-64", + "timestamp": 1599278555573, + "version": "1.3.1" + }, + "qhull-2020.2-hdb19cb5_2.tar.bz2": { + "build": "hdb19cb5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Qhull", + "license_family": "Other", + "md5": "cb376ee332d02c7e7b10bca9ec74cff5", + "name": "qhull", + "sha256": "a9fce407d219dca8f61be8aab0837b5fb2642b8242965955fbdee7d880d00a82", + "size": 1990101, + "subdir": "linux-64", + "timestamp": 1670915839713, + "version": "2020.2" + }, + "qstylizer-0.2.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >0.3.0,<1.0", + "python >=3.10,<3.11.0a0", + "tinycss2 >=1.1.0,<2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01e0440bfde53e949deea878df5a2a85", + "name": "qstylizer", + "sha256": "112e1a45603fd416321136ad16e36eb7448bac2edbbba62bf8c4374efd682624", + "size": 28202, + "subdir": "linux-64", + "timestamp": 1674008552815, + "version": "0.2.2" + }, + "qstylizer-0.2.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >0.3.0,<1.0", + "python >=3.11,<3.12.0a0", + "tinycss2 >=1.1.0,<2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9b77b8a3d767ba0786245508f8f6250", + "name": "qstylizer", + "sha256": "dcbe67fc3b04c3c0869974dbf6cc18cc85e75ffbe25549cbc48544aa2db0ff7f", + "size": 34475, + "subdir": "linux-64", + "timestamp": 1677706179029, + "version": "0.2.2" + }, + "qstylizer-0.2.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >0.3.0,<1.0", + "python >=3.7,<3.8.0a0", + "tinycss2 >=1.1.0,<2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bf1ebb507f995dc348c16df84aa4483b", + "name": "qstylizer", + "sha256": "752ffb33ca52fda522df9f36978d25a0d874e4db4b908e615ecb6a2a3cae7fb5", + "size": 27970, + "subdir": "linux-64", + "timestamp": 1674008578632, + "version": "0.2.2" + }, + "qstylizer-0.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >0.3.0,<1.0", + "python >=3.8,<3.9.0a0", + "tinycss2 >=1.1.0,<2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98b279dd166eb43abb03cd58f0bf3fd4", + "name": "qstylizer", + "sha256": "45095d4bbab55a489a049120d6f46b5c7bf0dbc6d98c139feea2542c9c187c91", + "size": 28179, + "subdir": "linux-64", + "timestamp": 1674008629691, + "version": "0.2.2" + }, + "qstylizer-0.2.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >0.3.0,<1.0", + "python >=3.9,<3.10.0a0", + "tinycss2 >=1.1.0,<2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "563eff850f55d63009cf3b5ccd9a9aa7", + "name": "qstylizer", + "sha256": "d8f58e36e4731c1637edbf500ec0b8ba7b18564e2519966bb7f857d13c49e4df", + "size": 27931, + "subdir": "linux-64", + "timestamp": 1674008604525, + "version": "0.2.2" + }, + "qt-5.15.7-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "qt-main >=5.15,<6", + "qt-webengine >=5.15,<6" + ], + "license": "LGPL-3.0-only", + "md5": "41ed869509441c7cb06a71cbab68e41e", + "name": "qt", + "sha256": "d84e629488e57aeb69049bbb51f08d3ee2ba91f961e1a221a8051f21a2aee9b3", + "size": 6668, + "subdir": "linux-64", + "timestamp": 1660110239225, + "version": "5.15.7" + }, + "qt-5.15.9-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "qt-main >=5.15,<6", + "qt-webengine >=5.15,<6" + ], + "license": "LGPL-3.0-only", + "md5": "1ec0719e9d2dff0654c247100d588d8e", + "name": "qt", + "sha256": "13ad8419e12750b81071a3e6971bb80ae9e993eea9d9d296c8d1b303d545a923", + "size": 6652, + "subdir": "linux-64", + "timestamp": 1660117585891, + "version": "5.15.9" + }, + "qt-5.6.2-h974d657_12.tar.bz2": { + "build": "h974d657_12", + "build_number": 12, + "depends": [ + "dbus >=1.10.22,<2.0a0", + "fontconfig >=2.12.4,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "gst-plugins-base >=1.12.2,<1.13.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb", + "openssl 1.0.*", + "sqlite >=3.20.1,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "9e6b736886eedcdd0afab64ee143df7f", + "name": "qt", + "sha256": "806abf0be8e60b79203c43b39533dfedfcc98dc24e13c8407da7d6a9387b6f92", + "size": 46627735, + "subdir": "linux-64", + "timestamp": 1505737498619, + "version": "5.6.2" + }, + "qt-5.6.2-hd25b39d_14.tar.bz2": { + "build": "hd25b39d_14", + "build_number": 14, + "depends": [ + "dbus >=1.12.2,<2.0a0", + "fontconfig >=2.12.4,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "gst-plugins-base >=1.12.4,<1.13.0a0", + "gstreamer >=1.12.4,<1.13.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb", + "libxcb >=1.12,<2.0a0", + "libxml2 >=2.9.7,<2.10.0a0", + "openssl 1.0.*", + "openssl >=1.0.2n,<1.0.3a", + "sqlite >=3.22.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "0ce50253a8b1607ca01ac18471f4e170", + "name": "qt", + "sha256": "5aaa458bcdd5af05a657427eef2346ebbefbaed1d0e8bae401f7348b064020b5", + "size": 46626674, + "subdir": "linux-64", + "timestamp": 1518460178064, + "version": "5.6.2" + }, + "qt-5.6.3-h39df351_0.tar.bz2": { + "build": "h39df351_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openssl 1.0.*", + "openssl >=1.0.2o,<1.0.3a", + "sqlite >=3.24.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "c54302918ded819687a6d4fbc58f1311", + "name": "qt", + "sha256": "b20a993e941b73f4a1ccbae24231019f372ea25d6035f9cc5ab52a52f31982ab", + "size": 46806549, + "subdir": "linux-64", + "timestamp": 1532424040899, + "version": "5.6.3" + }, + "qt-5.6.3-h39df351_1.tar.bz2": { + "build": "h39df351_1", + "build_number": 1, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libxcb >=1.13,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openssl 1.0.*", + "openssl >=1.0.2p,<1.0.3a", + "sqlite >=3.24.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "66b6f4c0967ddb427de168668905b531", + "name": "qt", + "sha256": "83f7f08634aa72c797853578fa1bc6c2b444f23330e55a92823049deb802526d", + "size": 47295071, + "subdir": "linux-64", + "timestamp": 1535128668623, + "version": "5.6.3" + }, + "qt-5.6.3-h8bf5577_3.tar.bz2": { + "build": "h8bf5577_3", + "build_number": 3, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.2,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.35,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libxcb >=1.13,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "sqlite >=3.25.3,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "51b5003908dbc8c7b697fbeccb457dcb", + "name": "qt", + "sha256": "2ba02ddeb805793d6dbb7444d43a14ee4ee8981b064385200b800797c886729f", + "size": 47870085, + "subdir": "linux-64", + "timestamp": 1543476509689, + "version": "5.6.3" + }, + "qt-5.9.4-h4e5bff0_0.tar.bz2": { + "build": "h4e5bff0_0", + "build_number": 0, + "depends": [ + "dbus >=1.12.2,<2.0a0", + "expat >=2.2.5,<3.0a0", + "fontconfig >=2.12.6,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "gst-plugins-base >=1.12.4,<1.13.0a0", + "gstreamer >=1.12.4,<1.13.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb", + "libxcb >=1.12,<2.0a0", + "libxml2 >=2.9.7,<2.10.0a0", + "openssl 1.0.*", + "sqlite >=3.22.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "073b13fa9f741566197e673d2b4097c0", + "name": "qt", + "sha256": "6ceebaea783dc8d553384c58a2b3d807195a7d45ae5bdd7da4547de523c680b2", + "size": 90833643, + "subdir": "linux-64", + "timestamp": 1521774952636, + "version": "5.9.4" + }, + "qt-5.9.5-h7e424d6_0.tar.bz2": { + "build": "h7e424d6_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "expat >=2.2.5,<3.0a0", + "fontconfig >=2.12.6,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb", + "libxcb >=1.13,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openssl 1.0.*", + "sqlite >=3.22.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "5e47c52842750cdfea4a07284784f884", + "name": "qt", + "sha256": "eaf325c4b8e281adc39883c3cffc514e49bea77c4c935126712400e7a7ea020a", + "size": 89040059, + "subdir": "linux-64", + "timestamp": 1523721496651, + "version": "5.9.5" + }, + "qt-5.9.6-h52aff34_0.tar.bz2": { + "build": "h52aff34_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "expat >=2.2.5,<3.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openssl 1.0.*", + "sqlite >=3.23.1,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "33188523864883e429297fc83ede072e", + "name": "qt", + "sha256": "aae0d305947290a7d315a0afc7332cc367195394e4c7b41a69512aaec58240fc", + "size": 90932937, + "subdir": "linux-64", + "timestamp": 1529023870444, + "version": "5.9.6" + }, + "qt-5.9.6-h8703b6f_2.tar.bz2": { + "build": "h8703b6f_2", + "build_number": 2, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "expat >=2.2.5,<3.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libxcb >=1.13,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openssl 1.0.*", + "sqlite >=3.24.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "82536307e4d4156a33ef504cca1a2231", + "name": "qt", + "sha256": "ad0f0dad974aaa933c1ebbecf8754690ce6973c9dfe33c3437473a459f584c25", + "size": 91332045, + "subdir": "linux-64", + "timestamp": 1535100214597, + "version": "5.9.6" + }, + "qt-5.9.7-h5867ecd_1.tar.bz2": { + "build": "h5867ecd_1", + "build_number": 1, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "expat >=2.2.6,<3.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.2,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.35,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libxcb >=1.13,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openssl 1.1.*", + "sqlite >=3.25.3,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "50da300935a335f7605d3f96fa045111", + "name": "qt", + "sha256": "5881ffba2ab8ed28112e80dd3f17ced0832b75615b9f8aab6bf171575c812b88", + "size": 90037659, + "subdir": "linux-64", + "timestamp": 1544604609235, + "version": "5.9.7" + }, + "qt-main-5.15.2-h327a75a_4.tar.bz2": { + "build": "h327a75a_4", + "build_number": 4, + "constrains": [ + "qt 5.15.2" + ], + "depends": [ + "__glibc >=2.17,<3.0.a0", + "dbus >=1.13.18,<2.0a0", + "expat >=2.2.10,<3.0a0", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "libclang >=10.0.1,<11.0a0", + "libevent >=2.1.12,<2.1.13.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libstdcxx-ng >=11.2.0", + "libxcb >=1.15,<2.0a0", + "libxkbcommon >=1.0.1,<2.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "nspr >=4.33,<5.0a0", + "nss >=3.74,<4.0a0", + "sqlite >=3.38.5,<4.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "LGPL-3.0-only", + "md5": "e0380f328c03eaa4c9f970c8d745ca52", + "name": "qt-main", + "sha256": "267412ec8d05516bc2ca53e0c493409b73d2ae97619e55c991c1fab55bb5283e", + "size": 62107504, + "subdir": "linux-64", + "timestamp": 1658662615444, + "version": "5.15.2" + }, + "qt-main-5.15.2-h327a75a_6.tar.bz2": { + "build": "h327a75a_6", + "build_number": 6, + "constrains": [ + "qt 5.15.2" + ], + "depends": [ + "__glibc >=2.17,<3.0.a0", + "dbus >=1.13.18,<2.0a0", + "expat >=2.2.10,<3.0a0", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "libclang >=10.0.1,<11.0a0", + "libevent >=2.1.12,<2.1.13.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libstdcxx-ng >=11.2.0", + "libxcb >=1.15,<2.0a0", + "libxkbcommon >=1.0.1,<2.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "nspr >=4.33,<5.0a0", + "nss >=3.74,<4.0a0", + "sqlite >=3.38.5,<4.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "LGPL-3.0-only", + "md5": "e5f193896bacf1cb939abaec2cd3e9af", + "name": "qt-main", + "sha256": "e63079d6a5a003960a0171fb2dae659c888ef6bfdde948c9f8759919028b4522", + "size": 62429309, + "subdir": "linux-64", + "timestamp": 1659430105371, + "version": "5.15.2" + }, + "qt-main-5.15.2-h327a75a_7.tar.bz2": { + "build": "h327a75a_7", + "build_number": 7, + "constrains": [ + "qt >=5.15.2,<6" + ], + "depends": [ + "__glibc >=2.17,<3.0.a0", + "dbus >=1.13.18,<2.0a0", + "expat >=2.2.10,<3.0a0", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "libclang >=10.0.1,<11.0a0", + "libevent >=2.1.12,<2.1.13.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libstdcxx-ng >=11.2.0", + "libxcb >=1.15,<2.0a0", + "libxkbcommon >=1.0.1,<2.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "nspr >=4.33,<5.0a0", + "nss >=3.74,<4.0a0", + "sqlite >=3.39.2,<4.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "LGPL-3.0-only", + "md5": "3207ce0d1744a6e916c57be6caa64602", + "name": "qt-main", + "sha256": "6021dbcd4aa4e1dcb890c289cc74b48b27437bc1152e83a47166e9d56a6adfcf", + "size": 62517768, + "subdir": "linux-64", + "timestamp": 1660127804289, + "version": "5.15.2" + }, + "qt-main-5.15.2-h8373d8f_8.tar.bz2": { + "build": "h8373d8f_8", + "build_number": 8, + "constrains": [ + "qt >=5.15.2,<6" + ], + "depends": [ + "__glibc >=2.17,<3.0.a0", + "dbus >=1.13.18,<2.0a0", + "expat >=2.4.9,<3.0a0", + "fontconfig >=2.14.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.1,<1.15.0a0", + "gstreamer >=1.14.1,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "krb5 >=1.19.4,<1.20.0a0", + "libclang >=14.0.6,<15.0a0", + "libclang13 >=14.0.6", + "libevent >=2.1.12,<2.1.13.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.39,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libstdcxx-ng >=11.2.0", + "libxcb >=1.15,<2.0a0", + "libxkbcommon >=1.0.1,<2.0a0", + "libxml2 >=2.10.3,<2.11.0a0", + "nspr >=4.33,<5.0a0", + "nss >=3.74,<4.0a0", + "openssl >=1.1.1t,<1.1.2a", + "sqlite >=3.41.1,<4.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "LGPL-3.0-only", + "license_family": "LGPL", + "md5": "f3cfd1a2eb140b533f71745315c39b8a", + "name": "qt-main", + "sha256": "9f2b9b3986c5acf3db982793d9737037d7eb595b3e47c199e9c845ab481b58b2", + "size": 62402338, + "subdir": "linux-64", + "timestamp": 1680303411260, + "version": "5.15.2" + }, + "qt-webengine-5.15.9-hbbf29b9_6.tar.bz2": { + "build": "hbbf29b9_6", + "build_number": 6, + "constrains": [ + "qt >=5.15.2,<6" + ], + "depends": [ + "__glibc >=2.17,<3.0.a0", + "dbus >=1.13.18,<2.0a0", + "expat >=2.4.9,<3.0a0", + "fontconfig >=2.14.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "libevent >=2.1.12,<2.1.13.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxcb >=1.15,<2.0a0", + "libxkbcommon >=1.0.1,<2.0a0", + "libxml2 >=2.10.3,<2.11.0a0", + "qt-main >=5.15,<6.0a0", + "qt-main >=5.15.2,<5.16.0a0" + ], + "license": "LGPL-3.0-only", + "license_family": "LGPL", + "md5": "df58bed81c2b1a436f5940a1270c5feb", + "name": "qt-webengine", + "sha256": "fa0f782d8b57eb761ac41c073d804bf5f71c19065cffd0cc213eb4b628fba86d", + "size": 59035010, + "subdir": "linux-64", + "timestamp": 1680703011635, + "version": "5.15.9" + }, + "qt-webengine-5.15.9-hd2b0992_4.tar.bz2": { + "build": "hd2b0992_4", + "build_number": 4, + "constrains": [ + "qt 5.15.9" + ], + "depends": [ + "__glibc >=2.17,<3.0.a0", + "dbus >=1.13.18,<2.0a0", + "expat >=2.2.10,<3.0a0", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "libevent >=2.1.12,<2.1.13.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxcb >=1.15,<2.0a0", + "libxkbcommon >=1.0.1,<2.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "qt-main >=5.15,<6.0a0", + "qt-main >=5.15.2,<5.16.0a0" + ], + "license": "LGPL-3.0-only", + "md5": "5726d711d573a0051b5fd8d73faa555c", + "name": "qt-webengine", + "sha256": "374283ff6d37ffa1e83ef4b9d931f383877cfed912538801698143ba2b6ce72b", + "size": 58933981, + "subdir": "linux-64", + "timestamp": 1658760764896, + "version": "5.15.9" + }, + "qtawesome-0.4.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "eae401bb5aff506917737ea8fdedfc46", + "name": "qtawesome", + "sha256": "c72cadd6a16b331d7cc716d738163b7076c2732eafa83b3de44a372822f946cf", + "size": 162515, + "subdir": "linux-64", + "timestamp": 1530923195100, + "version": "0.4.4" + }, + "qtawesome-0.4.4-py27hd7914c3_0.tar.bz2": { + "build": "py27hd7914c3_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "dba06830617042c250f465000f5f5828", + "name": "qtawesome", + "sha256": "038b67ca3cfbe71f180867b5aa34bcc95ffe3766d5911e90493911c7efbb0d9b", + "size": 162319, + "subdir": "linux-64", + "timestamp": 1505752901983, + "version": "0.4.4" + }, + "qtawesome-0.4.4-py35hd68ff89_0.tar.bz2": { + "build": "py35hd68ff89_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "0097a7c7ac0de6de7a4ec82dbc7f0879", + "name": "qtawesome", + "sha256": "87ef4bfbdcf06512423c249516a9a3baeadd48fa6ff25ab4773e8a46fc76ecf0", + "size": 162492, + "subdir": "linux-64", + "timestamp": 1505752919276, + "version": "0.4.4" + }, + "qtawesome-0.4.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "2320904d7cec430fa6284f6022accc50", + "name": "qtawesome", + "sha256": "f98d9f36c12a3510fef78fcfc432d80754513054d2bd345d4618bf1c41f8ee56", + "size": 162556, + "subdir": "linux-64", + "timestamp": 1530923119056, + "version": "0.4.4" + }, + "qtawesome-0.4.4-py36h609ed8c_0.tar.bz2": { + "build": "py36h609ed8c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "6516270240e1d162680c728c07fbcccc", + "name": "qtawesome", + "sha256": "c38e2f6d9e96153ea00ac64cb9fe10f131743e68b782d73fa6e471040ee01084", + "size": 162481, + "subdir": "linux-64", + "timestamp": 1505752936543, + "version": "0.4.4" + }, + "qtawesome-0.4.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "668d143dee158526db7474a3bd1a3a79", + "name": "qtawesome", + "sha256": "5de21dcec7a08899d7f7a87ee41a1771234ad199995d0f2baee2a2571ca4db98", + "size": 162596, + "subdir": "linux-64", + "timestamp": 1530923157442, + "version": "0.4.4" + }, + "qtawesome-0.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "0ecbaffbda4352229a40c35caa3c52fb", + "name": "qtawesome", + "sha256": "6f9a96c1a97f043c669bf3c0636b36455ac27933a80352eed5c0156ddfd9f7a1", + "size": 583656, + "subdir": "linux-64", + "timestamp": 1538159521601, + "version": "0.5.0" + }, + "qtawesome-0.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "55e22775f73cf383b4f1362882b7c897", + "name": "qtawesome", + "sha256": "ff5240ef721be98b31643878f12309e5ffe93772355ee290db086dfe07299891", + "size": 583454, + "subdir": "linux-64", + "timestamp": 1538159555044, + "version": "0.5.0" + }, + "qtawesome-0.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "3767884a1e40a23e8284ca13cf39b817", + "name": "qtawesome", + "sha256": "4d831f2cca8042a722da0af471a407c794a5291dd94577fa31e9d36bae8a9f5a", + "size": 583281, + "subdir": "linux-64", + "timestamp": 1538159507312, + "version": "0.5.0" + }, + "qtawesome-0.5.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "316ecb353dfa42cdee19096152ed778e", + "name": "qtawesome", + "sha256": "8ff25c977196ec821b4d8859f831f0aa94237b296ae70df71c2f16d1dde5e96c", + "size": 583366, + "subdir": "linux-64", + "timestamp": 1539024955563, + "version": "0.5.1" + }, + "qtawesome-0.5.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "3e5b569e90c8962d7e6b3e5c18964e16", + "name": "qtawesome", + "sha256": "db1e8ca420ffc70abbc0ffe28e89bfbd18019a55a97663448fd4aa58437778b0", + "size": 583121, + "subdir": "linux-64", + "timestamp": 1539024985100, + "version": "0.5.1" + }, + "qtawesome-0.5.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "e8b4ea84372b355344d4cb8d46ea4394", + "name": "qtawesome", + "sha256": "4a62c3f6ba5ec133b6e9a4eb1b0108f9742079186f14b33cb8b74dbc6aa2ec2a", + "size": 583236, + "subdir": "linux-64", + "timestamp": 1539024943485, + "version": "0.5.1" + }, + "qtawesome-0.5.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "afe6511fa45127204117cdd56097ab1f", + "name": "qtawesome", + "sha256": "76f661481df87497f6689d610e5ca8f06bda3164aff850df258a8a46efa28d83", + "size": 604371, + "subdir": "linux-64", + "timestamp": 1541042640535, + "version": "0.5.2" + }, + "qtawesome-0.5.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "5c50da82eeaea8ed5299b570e597222a", + "name": "qtawesome", + "sha256": "4891041be7903c26ac094729e5dfdca39ebca285917410f90f21521edf375630", + "size": 601103, + "subdir": "linux-64", + "timestamp": 1541042681460, + "version": "0.5.2" + }, + "qtawesome-0.5.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "bf287f977046405d891316d0a0a1aeaf", + "name": "qtawesome", + "sha256": "f6757d8fc5bfa83a97d8334ba3967d07c65285c5c481f4cdaa82de72532ff301", + "size": 605471, + "subdir": "linux-64", + "timestamp": 1541042640788, + "version": "0.5.2" + }, + "qtawesome-0.5.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "9c44541654e057249fe2631a6c046aea", + "name": "qtawesome", + "sha256": "f005df6f3f56db4657f35783068dfb6f7e2489bc9b4fd247b3e30705ff98c22a", + "size": 613438, + "subdir": "linux-64", + "timestamp": 1542391817989, + "version": "0.5.3" + }, + "qtawesome-0.5.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "e80d24a39684339217a198ea9873a139", + "name": "qtawesome", + "sha256": "cf680bf2526ed14cb63ee443de90d5e2e670d08a6c83fcd869cdc84392b59e5b", + "size": 613593, + "subdir": "linux-64", + "timestamp": 1542391817875, + "version": "0.5.3" + }, + "qtawesome-0.5.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "5eaa3d9a99862c770bb9f154ac528a62", + "name": "qtawesome", + "sha256": "0e7e7d411b0040f4401ea1b8edaea76acf0095180813873b5d584019113f7ac8", + "size": 612857, + "subdir": "linux-64", + "timestamp": 1542391791766, + "version": "0.5.3" + }, + "qtawesome-0.5.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "618a003ecc54ea33926a40d6e0bed0c2", + "name": "qtawesome", + "sha256": "615efe8aa5431539f36911b1135bcfabbda964d711415d8c9e603a54b4c85fd4", + "size": 631107, + "subdir": "linux-64", + "timestamp": 1547489021888, + "version": "0.5.5" + }, + "qtawesome-0.5.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "8c2b63f8cd68b601cbb491ec577ddcd6", + "name": "qtawesome", + "sha256": "612cf1d5f8fca61fd119bca1a2a91f9fbbeb81bfbadd4e9aca85fb42cc805722", + "size": 633449, + "subdir": "linux-64", + "timestamp": 1547488978796, + "version": "0.5.5" + }, + "qtawesome-0.5.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "4dae542821584e5c950344f69520b0c7", + "name": "qtawesome", + "sha256": "1fde161d6a57cad1884e604d4d08dc7f54f10983d6ce5338f40b0187e4a2d7c2", + "size": 632244, + "subdir": "linux-64", + "timestamp": 1547488990374, + "version": "0.5.5" + }, + "qtawesome-0.5.7-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "7e7d760e0b2c4c5aba4bb411aa252fc2", + "name": "qtawesome", + "sha256": "f2253f90f7e652ac203fd65f4c0b230aa12512149370e853e32bd6803ba63469", + "size": 629667, + "subdir": "linux-64", + "timestamp": 1553303685041, + "version": "0.5.7" + }, + "qtawesome-0.5.7-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "1bf1f20516a735c474fe31d390e57e27", + "name": "qtawesome", + "sha256": "c529ebb07b81ec67190173ac23b7681142369d0cab419f4fdf248cb454e3b69f", + "size": 633667, + "subdir": "linux-64", + "timestamp": 1553303696199, + "version": "0.5.7" + }, + "qtawesome-0.5.7-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "6661b7b5d8db4d0e64e928798742c808", + "name": "qtawesome", + "sha256": "b119a516201bf0209d47ffb897f96f48e39fc2bbe6370721cefe3aae95857049", + "size": 634313, + "subdir": "linux-64", + "timestamp": 1553303673872, + "version": "0.5.7" + }, + "qtawesome-1.2.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "qtpy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0c737445024dece8a77e38082a55f9d", + "name": "qtawesome", + "sha256": "ec3a271d8438cd2034e98188a6b7457fc5a4cae9485802eadb1b7b8bde05d197", + "size": 2193135, + "subdir": "linux-64", + "timestamp": 1674008751573, + "version": "1.2.2" + }, + "qtawesome-1.2.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "qtpy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f18fdf3525eaace53730bb7ea5f96fea", + "name": "qtawesome", + "sha256": "a54a9e9055e9d3392ce8de87316af5cf520c9fb744c5df6075c52185f8508508", + "size": 2216141, + "subdir": "linux-64", + "timestamp": 1677705185029, + "version": "1.2.2" + }, + "qtawesome-1.2.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "qtpy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "598274b59d69aeccf2a5b4eb49c971ef", + "name": "qtawesome", + "sha256": "172aca3f9ce93d7aac19e184e22675004f750c9e84384ecad2d5042e660b8e0b", + "size": 2190123, + "subdir": "linux-64", + "timestamp": 1674008818893, + "version": "1.2.2" + }, + "qtawesome-1.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "qtpy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1165a23d52cf161d0031144c1e8d0043", + "name": "qtawesome", + "sha256": "6275e81c44164facd7726d4cd601be5c9e6dcb17c6adacf9aec7b9056c067155", + "size": 2193440, + "subdir": "linux-64", + "timestamp": 1674008714109, + "version": "1.2.2" + }, + "qtawesome-1.2.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "qtpy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "04f9289408fe4990052c1adb09cd156a", + "name": "qtawesome", + "sha256": "a4a46fd6a1d6e5a3bd8f2da29f36fb926cffccbb0062b5dbc354da2729542e6d", + "size": 2189444, + "subdir": "linux-64", + "timestamp": 1674008785572, + "version": "1.2.2" + }, + "qtconsole-4.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "a606a0a918d5b5ec0f657251480a6993", + "name": "qtconsole", + "sha256": "1a19e8671a0199db4dad35d25b7cc93ba67039113b2ac87f37a9b63e52d31d2a", + "size": 150325, + "subdir": "linux-64", + "timestamp": 1530890864903, + "version": "4.3.1" + }, + "qtconsole-4.3.1-py27hc444b0d_0.tar.bz2": { + "build": "py27hc444b0d_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "d174b18152b0cfce48863c3a8cd47f6f", + "name": "qtconsole", + "sha256": "35bb84d99ccf31d2c5ca38d9644dbdb675cac640a17df99aa7c05f7ae314420c", + "size": 150318, + "subdir": "linux-64", + "timestamp": 1505863849178, + "version": "4.3.1" + }, + "qtconsole-4.3.1-py35h4626a06_0.tar.bz2": { + "build": "py35h4626a06_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.5,<3.6.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "ebfda0f9b061817b0f82cb8ab7a672cd", + "name": "qtconsole", + "sha256": "38bd472a2ebfefd2c124e4ce581100cfd1c21c69181733d96379ee35fc0d949a", + "size": 154147, + "subdir": "linux-64", + "timestamp": 1505869780631, + "version": "4.3.1" + }, + "qtconsole-4.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "469eeaaa24fa325fc214bd68f2b414da", + "name": "qtconsole", + "sha256": "01638b4f5ef688fd06b8d45467025253d04ad19b198613928e415bb8ae2e6057", + "size": 153373, + "subdir": "linux-64", + "timestamp": 1530890814821, + "version": "4.3.1" + }, + "qtconsole-4.3.1-py36h8f73b5b_0.tar.bz2": { + "build": "py36h8f73b5b_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "d16c2cbe799ed65a2e602a249e8e9bb4", + "name": "qtconsole", + "sha256": "76f80beb80cc545637e656b2f2595aafa4d9ecc09cd6df788cf8089e71371920", + "size": 153440, + "subdir": "linux-64", + "timestamp": 1505869807905, + "version": "4.3.1" + }, + "qtconsole-4.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "f967553717d343e227ccb2e4fce7eaf7", + "name": "qtconsole", + "sha256": "f9dcbd9f704c9019d377084608dda9225a6c72bee375c9165039ce96f3a0b4de", + "size": 153357, + "subdir": "linux-64", + "timestamp": 1530890763957, + "version": "4.3.1" + }, + "qtconsole-4.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt >=5.9.2,<5.10.0a0", + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "97d6db8e579dbb4f49d868bd0df4d397", + "name": "qtconsole", + "sha256": "e04f14a443f74a348567d4ca977daa8a50aac87131b2d477f222900f855a63ba", + "size": 156280, + "subdir": "linux-64", + "timestamp": 1534428395196, + "version": "4.4.0" + }, + "qtconsole-4.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.5,<3.6.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "9d002651cb3ed9f49eb6e52795efd806", + "name": "qtconsole", + "sha256": "bab09fff3d6014bf52a6ddc03ddfadcf101db21a2cd65f1dada27e2ca3ae3f8c", + "size": 160095, + "subdir": "linux-64", + "timestamp": 1534428752589, + "version": "4.4.0" + }, + "qtconsole-4.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "b455673799fe3d235607447cce30eef8", + "name": "qtconsole", + "sha256": "aec6100c147044c8de5a8ee52e3ee60bb470666bfa42e9b2e660395b86037e93", + "size": 159584, + "subdir": "linux-64", + "timestamp": 1534428682274, + "version": "4.4.0" + }, + "qtconsole-4.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "13c85258ec1b1012d005a859463997ef", + "name": "qtconsole", + "sha256": "1461ad284d017b72da20c751c4d940ff90863fb809472eb5fc44c8e540e0dd09", + "size": 159076, + "subdir": "linux-64", + "timestamp": 1534428759313, + "version": "4.4.0" + }, + "qtconsole-4.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt >=5.9.2,<5.10.0a0", + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "9a2e3e51e65b0e2e5793846a4552ac6b", + "name": "qtconsole", + "sha256": "4647ec37c2584f3c42623a2b8a3b2091780fdb6486efb20940fe9733520b3d12", + "size": 156482, + "subdir": "linux-64", + "timestamp": 1535391617506, + "version": "4.4.1" + }, + "qtconsole-4.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.5,<3.6.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "36d0aa35b85df5e8d2c0b2203b299d2e", + "name": "qtconsole", + "sha256": "983e18f261f27eab097afa1d9ae931dee09b8c5abecfa572ff11412a5a9ed55d", + "size": 160362, + "subdir": "linux-64", + "timestamp": 1535391645238, + "version": "4.4.1" + }, + "qtconsole-4.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "9dbeb97c020123f012a3f93cc6f528d6", + "name": "qtconsole", + "sha256": "3db0c70f4937d4f1b1e92d4e6198233089319f2cd932d7b1021837fdf619028b", + "size": 159730, + "subdir": "linux-64", + "timestamp": 1535391479393, + "version": "4.4.1" + }, + "qtconsole-4.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "2020848bdaa7d39c53f87acccd71046a", + "name": "qtconsole", + "sha256": "05d8b58e019eb18ef745f900557a7f1796d01cb27956ad06b0f9891e65282ca2", + "size": 159989, + "subdir": "linux-64", + "timestamp": 1535391243261, + "version": "4.4.1" + }, + "qtconsole-4.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "e6b3adbae3086425a18b7433243831ea", + "name": "qtconsole", + "sha256": "3e31cef4b6fce8c7bca4d68b103b63a6753ed7fcd3864e39afc78a8b399576be", + "size": 157454, + "subdir": "linux-64", + "timestamp": 1539885085751, + "version": "4.4.2" + }, + "qtconsole-4.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "2e73c7dac09c870220317160486c68dc", + "name": "qtconsole", + "sha256": "e3f0eaeb3a2908149069548e779f51ba05b6616131cecc21b3d2515694e1b9ad", + "size": 160400, + "subdir": "linux-64", + "timestamp": 1539885115390, + "version": "4.4.2" + }, + "qtconsole-4.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "c2f4fd07e60ff007cd66abc0347d8747", + "name": "qtconsole", + "sha256": "455d378962b6197278f14e10775d0948d5f7f1b70cbf19b85a3b292e03ba5a8a", + "size": 160940, + "subdir": "linux-64", + "timestamp": 1539885132840, + "version": "4.4.2" + }, + "qtconsole-4.4.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "0278ed309ca884f8ff011d01b61005a7", + "name": "qtconsole", + "sha256": "cf002935ac21942325cd71fc251f3cc49f9c31282c38670a4d38af25ef418327", + "size": 158230, + "subdir": "linux-64", + "timestamp": 1544549603973, + "version": "4.4.3" + }, + "qtconsole-4.4.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "7d7cad558abad2c4485278b291f69c62", + "name": "qtconsole", + "sha256": "af74e74d02ab6af4ff46f96587758ed295a9f79577511ea29cae012af8fe4b47", + "size": 161118, + "subdir": "linux-64", + "timestamp": 1544549523764, + "version": "4.4.3" + }, + "qtconsole-4.4.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "8f708580eebb95430e57fe8d74444d20", + "name": "qtconsole", + "sha256": "3d0065f6ab2139e013ac425e42a9952a0bf802d123f5debdb1d97eef7ee4243f", + "size": 161716, + "subdir": "linux-64", + "timestamp": 1544549364180, + "version": "4.4.3" + }, + "qtconsole-5.3.1-py310h06a4308_0.tar.bz2": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.10,<3.11.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "44e92aa3f3faa440c0add043b33c1ae3", + "name": "qtconsole", + "sha256": "e78db34b9edb25a831ed3043af27a94b281af006b2be658c83a9877000bdafbb", + "size": 178978, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1657544165033, + "type": "app", + "version": "5.3.1" + }, + "qtconsole-5.3.1-py310h06a4308_1.tar.bz2": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.10,<3.11.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "74409f5d6a9607fd2e3dd4fdb1cdc78c", + "name": "qtconsole", + "sha256": "eeaff14c4e199a1f25f5745b410855835fe72446d788d7b9a316926c18b1609c", + "size": 179518, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1659510321714, + "type": "app", + "version": "5.3.1" + }, + "qtconsole-5.3.1-py37h06a4308_0.tar.bz2": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1db8dc3b37a67948c42cbbc785f84de2", + "name": "qtconsole", + "sha256": "26f94a66bfa17c62f1f722fa671fc943a6761895a1f3b577900405c37512a7c0", + "size": 177376, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1657544102623, + "type": "app", + "version": "5.3.1" + }, + "qtconsole-5.3.1-py37h06a4308_1.tar.bz2": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c4cf25b4c1d75cd1e18b86bc95bb0b19", + "name": "qtconsole", + "sha256": "d0029d54ded44eca5cbe2eaf40bf2a50308c458e1f7e70e22d8b12ecff6c7916", + "size": 177732, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1659510354881, + "type": "app", + "version": "5.3.1" + }, + "qtconsole-5.3.1-py38h06a4308_0.tar.bz2": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.8,<3.9.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f69685bbba9e9debd5db969d5209df2", + "name": "qtconsole", + "sha256": "b773dd942e671727aa40b707cd7410c10e9752db1e0f81ebba5d497f5d4ed22b", + "size": 177840, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1657544208200, + "type": "app", + "version": "5.3.1" + }, + "qtconsole-5.3.1-py38h06a4308_1.tar.bz2": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.8,<3.9.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6c59cf17946f66b7528a3f4bc43b0256", + "name": "qtconsole", + "sha256": "40ec8e76bd1df8d1113d43950abe8e0c390f9d2f569a87fbd5184beab65aa19a", + "size": 178469, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1659510412603, + "type": "app", + "version": "5.3.1" + }, + "qtconsole-5.3.1-py39h06a4308_0.tar.bz2": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.9,<3.10.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0c0d85582e8c69f4decd8e63732d5053", + "name": "qtconsole", + "sha256": "e11327959b2d755361e9152f702957ab8a23a9167ac4c66dda44cd66ef866b3a", + "size": 177368, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1657544251357, + "type": "app", + "version": "5.3.1" + }, + "qtconsole-5.3.1-py39h06a4308_1.tar.bz2": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.9,<3.10.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d362249a22aac7d48795daa9eb415241", + "name": "qtconsole", + "sha256": "c00ae4a78ab42063d25a64cf6abe61af855eea35c833e0d50947f5665e80a453", + "size": 178680, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1659510384519, + "type": "app", + "version": "5.3.1" + }, + "qtconsole-5.3.2-py310h06a4308_0.tar.bz2": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.10,<3.11.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "517865a89f88e422247888d8c2c1ac56", + "name": "qtconsole", + "sha256": "7cfda7a6d61940b43e197b4b0919376ebd3fa7e33d6fc0ae5dae69d70fef0294", + "size": 178859, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1662018353317, + "type": "app", + "version": "5.3.2" + }, + "qtconsole-5.3.2-py311h06a4308_0.tar.bz2": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.11,<3.12.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1fd835afca33e5e918341535db8d3c94", + "name": "qtconsole", + "sha256": "95660c364f18449d136e983623743037940e0757d39face45763a32a926ea059", + "size": 237235, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1676828772946, + "type": "app", + "version": "5.3.2" + }, + "qtconsole-5.3.2-py37h06a4308_0.tar.bz2": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "306823362085ec41fa5763cbbb142720", + "name": "qtconsole", + "sha256": "191ed4f2206de15d8eb702f48ea9e0f261ab9bab4cb86fb7ccc219ed5276d332", + "size": 177089, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1662018427158, + "type": "app", + "version": "5.3.2" + }, + "qtconsole-5.3.2-py38h06a4308_0.tar.bz2": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.8,<3.9.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "adedc90be7c2fc6ffbb1df42489dbf92", + "name": "qtconsole", + "sha256": "5194a7f7673f7cc1d4d5473991cd0500baba9e45cb592905890122aab52f359a", + "size": 177476, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1662018389762, + "type": "app", + "version": "5.3.2" + }, + "qtconsole-5.3.2-py39h06a4308_0.tar.bz2": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.9,<3.10.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9abb4eca49d3bfc4ed9cf774d9e94ea9", + "name": "qtconsole", + "sha256": "97cb929e76c88ea1d60e0cc35c66d46f6c9e5e10c76ad914bda69d9e9b05e690", + "size": 177473, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1662018292640, + "type": "app", + "version": "5.3.2" + }, + "qtconsole-5.4.0-py310h06a4308_0.tar.bz2": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.10,<3.11.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "93e477cafa8b39e92592f544fa51e8d8", + "name": "qtconsole", + "sha256": "c8f3f1ed4cc1d3afe4960cda1f2788fe027eafba0ea152efab3d4b775f36073a", + "size": 179568, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1674008573146, + "type": "app", + "version": "5.4.0" + }, + "qtconsole-5.4.0-py311h06a4308_0.tar.bz2": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.11,<3.12.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "91b4daf0983bd3917a299f52fe797dea", + "name": "qtconsole", + "sha256": "ef2cb9847381f6605816a2ea05ec6db8a51a62a7c22e70fc4adb0250bb0aff90", + "size": 234859, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1677705044600, + "type": "app", + "version": "5.4.0" + }, + "qtconsole-5.4.0-py37h06a4308_0.tar.bz2": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2f3fbd70d5f8c13033079a919a1d52b3", + "name": "qtconsole", + "sha256": "4640a64768ce3f0d904738669c6e2f4d1ae814f55a398b8e18a4e27f2a8bf877", + "size": 177762, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1674008459719, + "type": "app", + "version": "5.4.0" + }, + "qtconsole-5.4.0-py38h06a4308_0.tar.bz2": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.8,<3.9.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f1052250a571d100f9d7a780338f9b7", + "name": "qtconsole", + "sha256": "835c48ed4e334fb056263dcdd51ae9906a928fbab56f874eacac15eff9db0a5b", + "size": 177712, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1674008537457, + "type": "app", + "version": "5.4.0" + }, + "qtconsole-5.4.0-py39h06a4308_0.tar.bz2": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.9,<3.10.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22c4bf7b22637b761ceaf3872d24a5ad", + "name": "qtconsole", + "sha256": "2fc460268219778d36f45007189ba1947c9e9a1578819926c4c6032a81cb372e", + "size": 177811, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1674008501012, + "type": "app", + "version": "5.4.0" + }, + "qtpy-1.3.1-py27h63d3751_0.tar.bz2": { + "build": "py27h63d3751_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "df0962f81b1c537149cecca9744ff8fa", + "name": "qtpy", + "sha256": "82563098d84d29351e1b8be4dc8ef08aba722290808b60fbc99291093ef7de37", + "size": 40676, + "subdir": "linux-64", + "timestamp": 1505752850057, + "version": "1.3.1" + }, + "qtpy-1.3.1-py35h881af26_0.tar.bz2": { + "build": "py35h881af26_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "cfe498645f39e12dd1281c17d3c93ba1", + "name": "qtpy", + "sha256": "e97ca78bfd9a8a7b117eebe6376a93a8b2e1c9d8cfa6ef598bc520f56441c936", + "size": 41646, + "subdir": "linux-64", + "timestamp": 1505752867082, + "version": "1.3.1" + }, + "qtpy-1.3.1-py36h3691cc8_0.tar.bz2": { + "build": "py36h3691cc8_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b9e1162a22c13bd72356873f89a07298", + "name": "qtpy", + "sha256": "bec74b8704f3cf5c9f2f93e962ecd6fa257879db2ee15577fa4a9611c88cffc6", + "size": 41646, + "subdir": "linux-64", + "timestamp": 1505752884339, + "version": "1.3.1" + }, + "qtpy-1.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7cf30677222c8c39468d02684e6482fa", + "name": "qtpy", + "sha256": "48bce64219b1df8dd7fdc7294cc5695a1ce976b5c4f8c993d0de6b66ef27b7ea", + "size": 43681, + "subdir": "linux-64", + "timestamp": 1520877362921, + "version": "1.4.0" + }, + "qtpy-1.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "a1a14f21f5346c198caa0c965febf76c", + "name": "qtpy", + "sha256": "a3a5ec612e088f98b957cbc1e2cc2fc6c3e79a14f16089e1e13b77f84874d34b", + "size": 44460, + "subdir": "linux-64", + "timestamp": 1520877388930, + "version": "1.4.0" + }, + "qtpy-1.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "dacf189695e70aa0bc86614c8812ecc7", + "name": "qtpy", + "sha256": "db90903a358dec4ac4574d329b63ecfb19f646e99d3ba7f4a872bb871e3b0cd4", + "size": 44579, + "subdir": "linux-64", + "timestamp": 1520877346488, + "version": "1.4.0" + }, + "qtpy-1.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "04e8895afeefc5fca70bef13221f2991", + "name": "qtpy", + "sha256": "9610eef0429f38d04bcf391cd11f00b7f41d4b401b5630310c52dba1a3899125", + "size": 43927, + "subdir": "linux-64", + "timestamp": 1525206911220, + "version": "1.4.1" + }, + "qtpy-1.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "fc6af7ca8fc421f340a5c31ebcb00f01", + "name": "qtpy", + "sha256": "f2beacadeb1f8701a0888bc038c1df957070ae6e12026c42cb0e120e30d5ce38", + "size": 44710, + "subdir": "linux-64", + "timestamp": 1525206926280, + "version": "1.4.1" + }, + "qtpy-1.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0d5751f850c3ebfcd02e2ec49b706b96", + "name": "qtpy", + "sha256": "f00545bc103a3ca7a455bf91be09e754bf18b1431635541b04f5d843efd2bd76", + "size": 44887, + "subdir": "linux-64", + "timestamp": 1525206926633, + "version": "1.4.1" + }, + "qtpy-1.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d913c43d27d5d66c01d35065a0c170a0", + "name": "qtpy", + "sha256": "bb3aae608052fc72b607bb527b0a141483b66bbfec37047e74625fb47be2369e", + "size": 43377, + "subdir": "linux-64", + "timestamp": 1527829361076, + "version": "1.4.2" + }, + "qtpy-1.4.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b111899a8f4bb97142939e31b0df9230", + "name": "qtpy", + "sha256": "c589cf50b3c947749a151ed598676fc8184f8237fccdad23442ad23343e1d797", + "size": 43330, + "subdir": "linux-64", + "timestamp": 1530873620151, + "version": "1.4.2" + }, + "qtpy-1.4.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "eeb909c4ef5458d1223b603d48c8b17f", + "name": "qtpy", + "sha256": "8b38fee398949c58127052c00b3398d9fba26af6fb1d70765a25079806e1b740", + "size": 44180, + "subdir": "linux-64", + "timestamp": 1527829404053, + "version": "1.4.2" + }, + "qtpy-1.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "29cf85281143dd8eca41f2c8e0642ef7", + "name": "qtpy", + "sha256": "1c4191f318c51416cea7124d3216783ab14b9e7ce96606f4d6f67a83fa900fcc", + "size": 44268, + "subdir": "linux-64", + "timestamp": 1527829337632, + "version": "1.4.2" + }, + "qtpy-1.4.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "15da331fa2b5c4439badeef305ac655f", + "name": "qtpy", + "sha256": "99c0af68620b05ce93c55ad385d595a24467b07219cd821141414c5f1daf3ba0", + "size": 44222, + "subdir": "linux-64", + "timestamp": 1530873664852, + "version": "1.4.2" + }, + "qtpy-1.4.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "99f1c50416a88031b5e9b11f42829702", + "name": "qtpy", + "sha256": "856a632eaedd2c0fab85897b76c96c302237a2ad93bdb8e09e9bfb81380f7574", + "size": 44257, + "subdir": "linux-64", + "timestamp": 1530873642226, + "version": "1.4.2" + }, + "qtpy-1.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "eebac24cfb9a0db85225cf8893538ee6", + "name": "qtpy", + "sha256": "ac26f6fb1e3209381575a3532f45b27d828095c97dadb75f4bfa7b7915e65472", + "size": 50071, + "subdir": "linux-64", + "timestamp": 1535390836118, + "version": "1.5.0" + }, + "qtpy-1.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "e97b37359c97da70c84572f06824195e", + "name": "qtpy", + "sha256": "8cda258ca564dff1057626a65e81ad0e4180fd1ee2a0e064d9050545f63d312e", + "size": 51087, + "subdir": "linux-64", + "timestamp": 1535390856279, + "version": "1.5.0" + }, + "qtpy-1.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "62a7c1784a69ae8de727fde43921c41a", + "name": "qtpy", + "sha256": "5c603d53cc26aa7ca8684c521dd7cc9b71712a2c6136be0c09fcf257586667fe", + "size": 51008, + "subdir": "linux-64", + "timestamp": 1535390822106, + "version": "1.5.0" + }, + "qtpy-1.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "64f43ae7d450322b0c40dd765ea29edc", + "name": "qtpy", + "sha256": "3186289826f7f86ad6df0302f3ef9bbc4b79f822bab5f5a4524b6aaba6ca73ba", + "size": 51016, + "subdir": "linux-64", + "timestamp": 1535390863061, + "version": "1.5.0" + }, + "qtpy-1.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "3bb22500dc14df208756616a4c84ddf5", + "name": "qtpy", + "sha256": "c6fe6fe562a0ac678d9249b309b37753c4a10bbab8dbdb2e3b7e9b82c8699f2e", + "size": 53330, + "subdir": "linux-64", + "timestamp": 1538157583409, + "version": "1.5.1" + }, + "qtpy-1.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "40f4c301466e886c85a501e00fe106e4", + "name": "qtpy", + "sha256": "8b56c06e0d3f5efe4e7d20b3a708bc1901633d48836f654b6bde7835c5e7ff2e", + "size": 54052, + "subdir": "linux-64", + "timestamp": 1538157570747, + "version": "1.5.1" + }, + "qtpy-1.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "0203def47ea88e85bb355a6474b6b116", + "name": "qtpy", + "sha256": "960ee865179e8cb206b4a1e38ab10be43ff412f281e5ea6fbf8f363ecc3df2cf", + "size": 54029, + "subdir": "linux-64", + "timestamp": 1538157536478, + "version": "1.5.1" + }, + "qtpy-1.5.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e3c50948111736f4665e247374b78da8", + "name": "qtpy", + "sha256": "79d30b115c360a951637b9fe3e50f39f310d31f9f6552f372b59764fc733ee51", + "size": 54192, + "subdir": "linux-64", + "timestamp": 1540232847240, + "version": "1.5.2" + }, + "qtpy-1.5.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "fcc9743bb7cf8c5056995748ba77059b", + "name": "qtpy", + "sha256": "cf33416b62abcc0fb23143d2194229d35494d9ad6678106f9518b4a942273d2d", + "size": 54937, + "subdir": "linux-64", + "timestamp": 1540232846123, + "version": "1.5.2" + }, + "qtpy-1.5.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "fcc970dcc6d3a5c9e5485a36ea14bff3", + "name": "qtpy", + "sha256": "7b4611040bc979a44394f95530857d2d999d865727bbc76c9bca338126cb2df8", + "size": 54944, + "subdir": "linux-64", + "timestamp": 1540232851641, + "version": "1.5.2" + }, + "qtpy-1.7.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "8b54a0f734988b06b7f24bfea5c91c55", + "name": "qtpy", + "sha256": "9f1e166c7d2684876aa275056a782ffdfb31ddc1ed3f8ad502bb8aa6c338f96e", + "size": 59793, + "subdir": "linux-64", + "timestamp": 1553291168405, + "version": "1.7.0" + }, + "qtpy-1.7.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "efd9fe13255616908fc4e9b439c5a2b4", + "name": "qtpy", + "sha256": "6ed8d45d9856b04d000a3cfaa84c732aa35931e7246ed7bf1ccc1290f364a587", + "size": 60551, + "subdir": "linux-64", + "timestamp": 1553291277029, + "version": "1.7.0" + }, + "qtpy-1.7.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d26480f029f75669af82bbd72ed45908", + "name": "qtpy", + "sha256": "128fc65465cf225fdb2f89c1a66a8bfc7df56bef7d0017f350f868ca5b50bc57", + "size": 60504, + "subdir": "linux-64", + "timestamp": 1553291142692, + "version": "1.7.0" + }, + "qtpy-2.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a839b038601daa7c7d58cd91318407f9", + "name": "qtpy", + "sha256": "1552101ddf2f75d72b2d230e12e8a2efeaa15da7f9abdb4a302af7b22f2300ee", + "size": 85934, + "subdir": "linux-64", + "timestamp": 1662015017414, + "version": "2.2.0" + }, + "qtpy-2.2.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bff131b7c148af55a5317d5b02330e51", + "name": "qtpy", + "sha256": "11e97c40bcfd96db9bbb3c1aed01877546e92614ef0533aad7971751ddd14fa9", + "size": 101724, + "subdir": "linux-64", + "timestamp": 1676827480570, + "version": "2.2.0" + }, + "qtpy-2.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4db05ac09d179062df41de1485c06f2b", + "name": "qtpy", + "sha256": "6c48d8d40a41648bce3cce2a768a049a26672ef39c40e7f3b6f6a3cca037ad9f", + "size": 85730, + "subdir": "linux-64", + "timestamp": 1662014967125, + "version": "2.2.0" + }, + "qtpy-2.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cfe885c58ecdebca90f50864501bb3e6", + "name": "qtpy", + "sha256": "6d5525fb9cc9c2a95d611c95c24529b842cb9fb99c7607e0d091da0adbe8e489", + "size": 85882, + "subdir": "linux-64", + "timestamp": 1662014927600, + "version": "2.2.0" + }, + "qtpy-2.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80f557f5a368e7187464890496a47734", + "name": "qtpy", + "sha256": "986ce43a5328570f2ae567f602fb424d931cb5f99819a346ec8ee1cf04e6ab31", + "size": 85807, + "subdir": "linux-64", + "timestamp": 1662015052924, + "version": "2.2.0" + }, + "qtwebkit-5.212-h4eab89a_4.tar.bz2": { + "build": "h4eab89a_4", + "build_number": 4, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "glib >=2.69.1,<3.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libwebp >=1.2.0,<1.3.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "libxslt >=1.1.35,<2.0a0", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.9,<5.16.0a0", + "sqlite >=3.38.5,<4.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LGPL-2.1-only", + "md5": "c47c9a2e1d2525b9cc25dcf80c889b82", + "name": "qtwebkit", + "sha256": "b958175772a46d97a5e3f2464dc551daea1db554d1939ba23b82e5705bd6625a", + "size": 17763635, + "subdir": "linux-64", + "timestamp": 1659010531169, + "version": "5.212" + }, + "quandl-3.2.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "ndg-httpsclient", + "numpy >=1.8", + "pandas >=0.14", + "pyasn1", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "22e2c1232a87eb71375920f0e732037f", + "name": "quandl", + "sha256": "70344170083f6f016b90ab14bab993266714746496ea6fd5c9bd7e77abb93f33", + "size": 37896, + "subdir": "linux-64", + "timestamp": 1530958977342, + "version": "3.2.0" + }, + "quandl-3.2.0-py27hd2b0aea_0.tar.bz2": { + "build": "py27hd2b0aea_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "ndg-httpsclient", + "numpy >=1.8", + "pandas >=0.14", + "pyasn1", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests >=2.7.0,<2.18", + "six" + ], + "license": "MIT", + "md5": "d42ea6e9e54f08b5fbca3e82ea0c645b", + "name": "quandl", + "sha256": "894d68016b71261f4f2d4f6c495f643f516a429fef30b6c12b43c827e7f62c1a", + "size": 38230, + "subdir": "linux-64", + "timestamp": 1509567384116, + "version": "3.2.0" + }, + "quandl-3.2.0-py35h61fbbd2_0.tar.bz2": { + "build": "py35h61fbbd2_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "requests >=2.7.0,<2.18", + "six" + ], + "license": "MIT", + "md5": "2ee450790de05db361f8209aed480b53", + "name": "quandl", + "sha256": "d41ec594d011efdb5cacbbd88e07adb638e74336f5d128f71ae3001704e7e256", + "size": 39456, + "subdir": "linux-64", + "timestamp": 1509567386622, + "version": "3.2.0" + }, + "quandl-3.2.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "63053c5728f6343e74b5acc3d1f3cf70", + "name": "quandl", + "sha256": "2ccfd05746f019e9496e878ab6668741d74fb1128437c6aef003d9657d308899", + "size": 38929, + "subdir": "linux-64", + "timestamp": 1530923341713, + "version": "3.2.0" + }, + "quandl-3.2.0-py36h3624063_0.tar.bz2": { + "build": "py36h3624063_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0,<2.18", + "six" + ], + "license": "MIT", + "md5": "18f3df76b2ce79925ee107ebf7a7b743", + "name": "quandl", + "sha256": "805679b63389b3a17eb5b5107405c5ca48f92f33fe9f59afa763728252b6cf42", + "size": 39252, + "subdir": "linux-64", + "timestamp": 1509567355946, + "version": "3.2.0" + }, + "quandl-3.2.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "2ebd2369bd6e1663d00813aad0fb985d", + "name": "quandl", + "sha256": "e5246eb7ce7ab420a2edf8a0315f98bba02fe218f83c12dba7520ef26ad8c4ee", + "size": 39031, + "subdir": "linux-64", + "timestamp": 1530923619403, + "version": "3.2.0" + }, + "quandl-3.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "ndg-httpsclient", + "numpy >=1.8", + "pandas >=0.14", + "pyasn1", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "56622f439bd37002ce4ebe8e2cbeda56", + "name": "quandl", + "sha256": "d3b1ac09d298b98412751dbb0f6b9327950748ca076fc4ba7454d700ed94475c", + "size": 38033, + "subdir": "linux-64", + "timestamp": 1519241886248, + "version": "3.3.0" + }, + "quandl-3.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "d70b0c50778a680b29605bedc61e0b61", + "name": "quandl", + "sha256": "126c0800d329bf61b610a739fd2e78d7c0a285cd99e385c0486eb1e793b58c84", + "size": 39229, + "subdir": "linux-64", + "timestamp": 1519241916684, + "version": "3.3.0" + }, + "quandl-3.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "8ccc230a21ea496999d53751c4c87cf0", + "name": "quandl", + "sha256": "c486c28cba23f6462a629ded73a0cb26588825148b1a72e6c01d70417d9f156d", + "size": 39011, + "subdir": "linux-64", + "timestamp": 1519241774918, + "version": "3.3.0" + }, + "quandl-3.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "ndg-httpsclient", + "numpy >=1.8", + "pandas >=0.14", + "pyasn1", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "7f8b6c5a115b60a04d98468aef3fffe4", + "name": "quandl", + "sha256": "3439f2ac962cd87e98344ec8a7bbfcc71e3e228ccfe8641b2e5291a4d915b32a", + "size": 38496, + "subdir": "linux-64", + "timestamp": 1534610166107, + "version": "3.4.0" + }, + "quandl-3.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "97aa0a1c637003faa639193a3f3d4d40", + "name": "quandl", + "sha256": "75d2a7ac0bbd7408deec42b6b4c9cd91b4bb3e230ad5db4d9a205efb67447934", + "size": 39587, + "subdir": "linux-64", + "timestamp": 1534610232289, + "version": "3.4.0" + }, + "quandl-3.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "46e412c2bf65b914ad3d206cc893bb95", + "name": "quandl", + "sha256": "c7723157bb4fa3ad5e977eadd6ed2a9414bdfa6b55e2404a103191bad67a9173", + "size": 39517, + "subdir": "linux-64", + "timestamp": 1534610105634, + "version": "3.4.0" + }, + "quandl-3.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "ad0ca62887d9b10738c644b6c80ed334", + "name": "quandl", + "sha256": "7ac2fa0c037b005e2ecf96af93c61a608ecc05e5a58e38900984d8f82d8f5a28", + "size": 39611, + "subdir": "linux-64", + "timestamp": 1534610235851, + "version": "3.4.0" + }, + "quandl-3.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "ndg-httpsclient", + "numpy >=1.8", + "pandas >=0.14", + "pyasn1", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "47ffa1e2732b5a6f8a6af65f5acda42d", + "name": "quandl", + "sha256": "4cf8e7791d765dfc2789b659bbcc6f8c66221126f36a5b9444b7e9ae216aebcc", + "size": 38664, + "subdir": "linux-64", + "timestamp": 1535723484031, + "version": "3.4.2" + }, + "quandl-3.4.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "64e3cd008137be36da2f328f8f6b1111", + "name": "quandl", + "sha256": "a6abac43033ab389eb27aa9105b7bcf75c42a43885d398ff0a9eeec647f0c384", + "size": 39819, + "subdir": "linux-64", + "timestamp": 1536250854444, + "version": "3.4.2" + }, + "quandl-3.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "226e937eeaf691e1c1e8a7b5a5a06613", + "name": "quandl", + "sha256": "bab2c819fdc657b51a70e7a9ce6332b25279782d7f11548d23ed6326163238c0", + "size": 39674, + "subdir": "linux-64", + "timestamp": 1535723487661, + "version": "3.4.2" + }, + "quandl-3.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "e555ff611c4f1d5c22cc58ea580796e2", + "name": "quandl", + "sha256": "95ef00730831e60c8ab6a4f70f796cb35d5af1321c7d67922490112333086271", + "size": 39725, + "subdir": "linux-64", + "timestamp": 1535723532555, + "version": "3.4.2" + }, + "quandl-3.4.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "ndg-httpsclient", + "numpy >=1.8", + "pandas >=0.14", + "pyasn1", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "a91eb31d86daeb8c46bfb4c79b1fa92d", + "name": "quandl", + "sha256": "569512391aeff883090a9cd1c2df5c483a865c51569728065a6b19c312ed0e20", + "size": 41946, + "subdir": "linux-64", + "timestamp": 1541043492214, + "version": "3.4.4" + }, + "quandl-3.4.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "2b4897217ee02180977f369455807266", + "name": "quandl", + "sha256": "75a38b0a880348eda0e4d7d4f1e103ffacb50f35cd40ece092b3c4235d1e631c", + "size": 42970, + "subdir": "linux-64", + "timestamp": 1541043529913, + "version": "3.4.4" + }, + "quandl-3.4.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "d17874d73f09d372912516f905100c2c", + "name": "quandl", + "sha256": "9616e2be49f343e914ba63227fd84ceab6d8f02f8b0bdaeeeb456cbfb5224b33", + "size": 43070, + "subdir": "linux-64", + "timestamp": 1541043474931, + "version": "3.4.4" + }, + "quandl-3.4.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "ndg-httpsclient", + "numpy >=1.8", + "pandas >=0.14", + "pyasn1", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "3a0d496eb5b0eea914bf40a99fb0abcd", + "name": "quandl", + "sha256": "582bf93d6caa9b500e1340a3a4903329503868b9a5f2070653c378afa13e96cb", + "size": 43759, + "subdir": "linux-64", + "timestamp": 1545156882517, + "version": "3.4.5" + }, + "quandl-3.4.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "9d0551f1b3849da1e27ccde137bd412c", + "name": "quandl", + "sha256": "1d1bc3166a6cd946e6a04383a718f1d349ca3b590c51097341c34a5a35ad6a7b", + "size": 44846, + "subdir": "linux-64", + "timestamp": 1545156811689, + "version": "3.4.5" + }, + "quandl-3.4.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "da2742fb1b212dc86672a7c325193dc3", + "name": "quandl", + "sha256": "c30e393aae226608aa5ee769e944b91e68aed5579439e4efcc0d315588291e1d", + "size": 44876, + "subdir": "linux-64", + "timestamp": 1545156901487, + "version": "3.4.5" + }, + "quandl-3.4.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "ndg-httpsclient", + "numpy >=1.8", + "pandas >=0.14", + "pyasn1", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b32c1007ccf4f175b4b84754d90a20d", + "name": "quandl", + "sha256": "09464b80e31918cf3854bc1a0ead6ccf1131be68a4459962d91849528f86290f", + "size": 48032, + "subdir": "linux-64", + "timestamp": 1569432138781, + "version": "3.4.8" + }, + "quandl-3.4.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "563c991826d6e1df36e0e7d28f8a9387", + "name": "quandl", + "sha256": "7308b5318a12214c391807695c378dbf38228a8ee483149e13c32a3010c78e55", + "size": 49132, + "subdir": "linux-64", + "timestamp": 1569432143856, + "version": "3.4.8" + }, + "quandl-3.4.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb8643bbf1534c91bf78dd7d70b261ae", + "name": "quandl", + "sha256": "10a2dd8d00813bd7584f17c6157d647bfc1c8843e1287fe6581331f408a46fa7", + "size": 49250, + "subdir": "linux-64", + "timestamp": 1569432147582, + "version": "3.4.8" + }, + "quandl-3.4.8-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a08c87a0c6605556d43684b41fa028c3", + "name": "quandl", + "sha256": "438e241792b4164d119675d1f1f8dc04a368fc309073192ebdb98149a7fa2f45", + "size": 50002, + "subdir": "linux-64", + "timestamp": 1588562785698, + "version": "3.4.8" + }, + "quandl-3.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8bd4a4a87cc17bedbfde7a9c3e7fc60", + "name": "quandl", + "sha256": "908e6c0b783b78d41dd4676685b7057c553f45824e42d2cd16b093de4041f992", + "size": 49765, + "subdir": "linux-64", + "timestamp": 1588565508184, + "version": "3.5.0" + }, + "quandl-3.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8924ca2185869bafdc380ed56560b41b", + "name": "quandl", + "sha256": "09dd29a94ace617516051636d48f6b1402a268bd4eab7a1725869b9e2023716e", + "size": 49824, + "subdir": "linux-64", + "timestamp": 1588565498703, + "version": "3.5.0" + }, + "quandl-3.5.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eeea757293bb24e2259211378d22106d", + "name": "quandl", + "sha256": "5bdd68e2c505737d71fc08dcb78184e1e28daaef7fdac4f54bebd21d9e5a9f70", + "size": 49969, + "subdir": "linux-64", + "timestamp": 1588565659844, + "version": "3.5.0" + }, + "quandl-3.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c6b45ad10b355fe4afd427a1f56417d", + "name": "quandl", + "sha256": "8516b4e5d23eb54ac6eec17ccecac3dbbc4ba24f207b6097e15e908264f75f79", + "size": 50272, + "subdir": "linux-64", + "timestamp": 1599889876040, + "version": "3.5.1" + }, + "quandl-3.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b33efaad3b2513988deb3cccdfafb08", + "name": "quandl", + "sha256": "28671bd6254c291471d8d110fd8a4d22fb1bcad2066c9a70f9feca036787423a", + "size": 50360, + "subdir": "linux-64", + "timestamp": 1599889890023, + "version": "3.5.1" + }, + "quandl-3.5.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "57660f2e61e4418ed8aada3f6c4101ce", + "name": "quandl", + "sha256": "4e658a1de84e201e6e841f1060ee0a4d1225be18f7ab12a8c068dc4e06081bab", + "size": 50521, + "subdir": "linux-64", + "timestamp": 1599889871982, + "version": "3.5.1" + }, + "quandl-3.5.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8eb5d8d3675b76b7aafcabb4d451d2f8", + "name": "quandl", + "sha256": "ece89e8a4a3e0433bbb4aeb5d31f469de25f98177ba17002ee35c703b04456d5", + "size": 50352, + "subdir": "linux-64", + "timestamp": 1599890413766, + "version": "3.5.2" + }, + "quandl-3.5.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f67fd90ca61fabff2ac3dd8448c7f2a", + "name": "quandl", + "sha256": "d72d74f3598b97c3fd4d13d4f7672af13ed53b7cb3afbaa3b2a55276879cce5e", + "size": 50445, + "subdir": "linux-64", + "timestamp": 1599890450009, + "version": "3.5.2" + }, + "quandl-3.5.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "19c9e5866456379918fcd1bf624e6d46", + "name": "quandl", + "sha256": "eb740fa3d1d5141fdd723cab595070923037e325ce7a918d2667f3b15e55e5d2", + "size": 50651, + "subdir": "linux-64", + "timestamp": 1599890453664, + "version": "3.5.2" + }, + "quandl-3.5.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "efe4683cd8e512b0e82280036a9d1f84", + "name": "quandl", + "sha256": "c649c9ec9a667398c587858f5bc9a9f28cb9c6f5feaa594acd4faad137309b1b", + "size": 48242, + "subdir": "linux-64", + "timestamp": 1602786570829, + "version": "3.5.3" + }, + "quandl-3.5.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "742897ab4277d28572d98327f64ac776", + "name": "quandl", + "sha256": "b1eb0554028080c64a3bbbc3c71cfe132b218b65250dda8e3a5e30bb493cb9ed", + "size": 48272, + "subdir": "linux-64", + "timestamp": 1602786609496, + "version": "3.5.3" + }, + "quandl-3.5.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "014c495f55f5fe5322ce1ea4b4c38512", + "name": "quandl", + "sha256": "924b0d17974073876c37f114e5bdd210ceff9aeaef00f7c9d4afdb4e229d0d3a", + "size": 48434, + "subdir": "linux-64", + "timestamp": 1602786610589, + "version": "3.5.3" + }, + "quandl-3.6.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc9eaf4939ba274ec19fa0d560efd3f9", + "name": "quandl", + "sha256": "cf8c7bebde56bfc9a4f7dea632b57eecd1e2e8d4b2a3b86ee3939edfd8a2d5b2", + "size": 50312, + "subdir": "linux-64", + "timestamp": 1610404538068, + "version": "3.6.0" + }, + "quandl-3.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "630c44a097b6cfb428d2ba3567a0b15a", + "name": "quandl", + "sha256": "8aa05579b871671c2636f1e599b040252d5fcb38f4fc9c931976583ffac9925c", + "size": 50410, + "subdir": "linux-64", + "timestamp": 1610404103367, + "version": "3.6.0" + }, + "quandl-3.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f2224f2d70ab39d7c3ea9b0470f12f2", + "name": "quandl", + "sha256": "51c85916874cd320f6d950e6ee82efe750ec0b35c4b9270235c63896091c16f4", + "size": 50480, + "subdir": "linux-64", + "timestamp": 1610404538397, + "version": "3.6.0" + }, + "quandl-3.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51fd9da92ea2f6746fbcb2c40330a915", + "name": "quandl", + "sha256": "9971651bf14c468983a999dcc8fe032a0c551b9cb9886ca34399babd9d003822", + "size": 52960, + "subdir": "linux-64", + "timestamp": 1614075794994, + "version": "3.6.0" + }, + "quandl-3.6.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b937cac7cd62253b567421d167203c5", + "name": "quandl", + "sha256": "b40514691c44479799057de7f3fa7c3fc67a84bcf44ab56a4c6fbd2f2ffe6bac", + "size": 50792, + "subdir": "linux-64", + "timestamp": 1640810735979, + "version": "3.6.1" + }, + "quandl-3.6.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.11,<3.12.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0959f6c18b4a24b19e52375fe87cf3ed", + "name": "quandl", + "sha256": "e0ba1c469c6d9b5176b6cf34948a3d703670620e6099a19793d29f0134e777e4", + "size": 62639, + "subdir": "linux-64", + "timestamp": 1676861692071, + "version": "3.6.1" + }, + "quandl-3.6.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6645ee2402333d948b733d027e03ea8", + "name": "quandl", + "sha256": "86ae19e5dabbbc9b004da903b9cec25a20365d1ce39f40ebee778fbbcff09daa", + "size": 50368, + "subdir": "linux-64", + "timestamp": 1614799186397, + "version": "3.6.1" + }, + "quandl-3.6.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "72f30271adae482f0561ae46839a5a9f", + "name": "quandl", + "sha256": "b2a0daa52e3b040d0d65d9569ad3d76c3a5793a429ad00d6cf5737e59433ae26", + "size": 50489, + "subdir": "linux-64", + "timestamp": 1614799176000, + "version": "3.6.1" + }, + "quandl-3.6.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebfeeea14804db2165f9e6f33f68d60c", + "name": "quandl", + "sha256": "b32514766f23413bc6fa81e3bffee0c778cc847990454722de78e26c8e1c656e", + "size": 50645, + "subdir": "linux-64", + "timestamp": 1614797897220, + "version": "3.6.1" + }, + "quandl-3.6.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e0323938a569b736d78c0769c0f7c6f", + "name": "quandl", + "sha256": "7c4acf0857a007e2c1d409b679b392b701f7781e7ce00a09f3ce0f81ba1e22d4", + "size": 50636, + "subdir": "linux-64", + "timestamp": 1614799172026, + "version": "3.6.1" + }, + "quantecon-0.4.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "matplotlib", + "nose", + "numba", + "numpy", + "pandas", + "pytables", + "python >=3.6,<3.7.0a0", + "requests", + "scipy", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "8961a1da54e3dbfed1b076f0dd76c0b3", + "name": "quantecon", + "sha256": "788f53139331b2de475c69eff4a055ab04fe507abf6340add7030262af04c1b9", + "size": 246497, + "subdir": "linux-64", + "timestamp": 1582040386892, + "version": "0.4.5" + }, + "quantecon-0.4.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "matplotlib", + "nose", + "numba", + "numpy", + "pandas", + "pytables", + "python >=3.7,<3.8.0a0", + "requests", + "scipy", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "89a1924dfdd593adc0d7a79704f94cc8", + "name": "quantecon", + "sha256": "fadda2f90819d3a021674c7d3feb1d50816dcb4a6aaaa06a77331a202c7d2473", + "size": 248385, + "subdir": "linux-64", + "timestamp": 1582040394160, + "version": "0.4.5" + }, + "quantecon-0.4.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "matplotlib", + "nose", + "numba", + "numpy", + "pandas", + "pytables", + "python >=3.8,<3.9.0a0", + "requests", + "scipy", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "8e92d49674ca17e2ea011786328e30b4", + "name": "quantecon", + "sha256": "f078fcb69c10c194e03d47921c7336a9fa48603dbf6e29b020983207a940124d", + "size": 247047, + "subdir": "linux-64", + "timestamp": 1582040392701, + "version": "0.4.5" + }, + "quantecon-0.4.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba", + "numpy", + "pandas", + "pytables", + "python >=3.6,<3.7.0a0", + "requests", + "scipy", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "7019d1ca0226bba19ead19f4a1b0574f", + "name": "quantecon", + "sha256": "d1adf81c13f1184972b2785e15b518ddbae4d0b053987faf0669543bdefa82a5", + "size": 336944, + "subdir": "linux-64", + "timestamp": 1591257704407, + "version": "0.4.7" + }, + "quantecon-0.4.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba", + "numpy", + "pandas", + "pytables", + "python >=3.7,<3.8.0a0", + "requests", + "scipy", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "2136cacfe44d48e70dfefe6441cacd6f", + "name": "quantecon", + "sha256": "819d7b34184e3d0fdf9c6784905eaa6de3445e9d38780de4a2fdb87f2cad844c", + "size": 342939, + "subdir": "linux-64", + "timestamp": 1591257725285, + "version": "0.4.7" + }, + "quantecon-0.4.7-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba", + "numpy", + "pandas", + "pytables", + "python >=3.8,<3.9.0a0", + "requests", + "scipy", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "f67adeb6089a6e321e871a00562cd05d", + "name": "quantecon", + "sha256": "3594a044ced50094f6b38367131138232108b3bb5e49dec42b12aae4ad8a5243", + "size": 343367, + "subdir": "linux-64", + "timestamp": 1591257730381, + "version": "0.4.7" + }, + "quantecon-0.4.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba", + "numpy", + "pandas", + "pytables", + "python >=3.6,<3.7.0a0", + "requests", + "scipy", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "3e583cb50be172692a42f41db0d80d00", + "name": "quantecon", + "sha256": "68098a0b258e68960461345acad789e45ebb7616c3cd4f4788944bac8542ec86", + "size": 333365, + "subdir": "linux-64", + "timestamp": 1602265596406, + "version": "0.4.8" + }, + "quantecon-0.4.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba", + "numpy", + "pandas", + "pytables", + "python >=3.7,<3.8.0a0", + "requests", + "scipy", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "47a3b4d3e09b876326437131ac7c97a9", + "name": "quantecon", + "sha256": "47937f5e0e313bb5e9d8559d72394236624a62032a86791d21ed62970d0a9d7a", + "size": 338914, + "subdir": "linux-64", + "timestamp": 1594400148672, + "version": "0.4.8" + }, + "quantecon-0.4.8-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba", + "numpy", + "pandas", + "pytables", + "python >=3.8,<3.9.0a0", + "requests", + "scipy", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "4a84fe33bfe1d4cc9d69804730771666", + "name": "quantecon", + "sha256": "d875666a6e754db13837c3e856c6b33f5339e698ac3465c58cdbf68d83e2a247", + "size": 327089, + "subdir": "linux-64", + "timestamp": 1602265621255, + "version": "0.4.8" + }, + "quantecon-0.5.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba >=0.38", + "numpy", + "pandas", + "pytables", + "python >=3.10,<3.11.0a0", + "requests", + "scipy >=1.0.0", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "d7359766270a905d2751d90ea17156dc", + "name": "quantecon", + "sha256": "3d27d6fab5ef1fd00065debc6d48326e05c9e4eb08b75e1706313edafdcd1ef2", + "size": 336268, + "subdir": "linux-64", + "timestamp": 1641903910656, + "version": "0.5.0" + }, + "quantecon-0.5.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba >=0.38", + "numpy", + "pandas", + "pytables", + "python >=3.6,<3.7.0a0", + "requests", + "scipy >=1.0.0", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "529f69b72dc92a9d48c4145b544eb3da", + "name": "quantecon", + "sha256": "255a45e67bc7786c2350617cfc84ca2867447e3282c3c19f8e1aef8f983b4a7d", + "size": 339257, + "subdir": "linux-64", + "timestamp": 1619455578632, + "version": "0.5.0" + }, + "quantecon-0.5.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba >=0.38", + "numpy", + "pandas", + "pytables", + "python >=3.7,<3.8.0a0", + "requests", + "scipy >=1.0.0", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "420448f650cf8c4d7e2ea15638a61513", + "name": "quantecon", + "sha256": "b89f29c0bad911ee64cbad6536101550d367ac15953950effd7395f02e2f62c9", + "size": 333359, + "subdir": "linux-64", + "timestamp": 1619455012407, + "version": "0.5.0" + }, + "quantecon-0.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba >=0.38", + "numpy", + "pandas", + "pytables", + "python >=3.8,<3.9.0a0", + "requests", + "scipy >=1.0.0", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "8aa8df9d1270b9b1e03dc22790eca211", + "name": "quantecon", + "sha256": "96a01af19a91379fb7b5b3acd45eab33a5b723773b5e38491180b84b1406e829", + "size": 335841, + "subdir": "linux-64", + "timestamp": 1619455585822, + "version": "0.5.0" + }, + "quantecon-0.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba >=0.38", + "numpy", + "pandas", + "pytables", + "python >=3.9,<3.10.0a0", + "requests", + "scipy >=1.0.0", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "03b4d18198999ead2c2ea14d1f419fd6", + "name": "quantecon", + "sha256": "f34ad1e7c8a00314a351e607331a875422ab12404fef716fc5ba36aaf49e6f7c", + "size": 337194, + "subdir": "linux-64", + "timestamp": 1619455580034, + "version": "0.5.0" + }, + "queuelib-1.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "0ce1b243f0e2e351a396a459be51ae55", + "name": "queuelib", + "sha256": "463efa351c38e081ef049e09e9e83edb2c1fef199b7a61e259e3132039ce355d", + "size": 20614, + "subdir": "linux-64", + "timestamp": 1524148029122, + "version": "1.5.0" + }, + "queuelib-1.5.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "91d8dee19d932bbd4c76c57dce14be12", + "name": "queuelib", + "sha256": "8753fb4ff7c4ef1ba3ccf22c890f0bd89290b36b46bbde810516ef5ec289ba6e", + "size": 21839, + "subdir": "linux-64", + "timestamp": 1640794181600, + "version": "1.5.0" + }, + "queuelib-1.5.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "f2a978c70673a3feeb82106b9106d321", + "name": "queuelib", + "sha256": "46ad1a5bc52dcac744f160f98a814de7a5d3abb4ffa0b9da9e82132a265657e7", + "size": 28166, + "subdir": "linux-64", + "timestamp": 1676906174798, + "version": "1.5.0" + }, + "queuelib-1.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "ee601b9a7ccde9437f3bcd53b4754463", + "name": "queuelib", + "sha256": "376d3a8b762d2974c2a601312ab971efdd12079b586bdff246f6e2ea4235673b", + "size": 21402, + "subdir": "linux-64", + "timestamp": 1524146811674, + "version": "1.5.0" + }, + "queuelib-1.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "b10b40cc72929850bb9172e5673026ed", + "name": "queuelib", + "sha256": "f53bb8c06d6d8b437b53f9934102b70c6c6a8ef330f2cde9bed73aee84c41b6a", + "size": 21329, + "subdir": "linux-64", + "timestamp": 1524146805133, + "version": "1.5.0" + }, + "queuelib-1.5.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "55820d2e6d3efff574ebdf90cef26989", + "name": "queuelib", + "sha256": "6e01fabed5f9cc5683b13fdd017e0a4eaeabc9a306d0c0d575b33f8dae8b409f", + "size": 243802, + "subdir": "linux-64", + "timestamp": 1614090983296, + "version": "1.5.0" + }, + "queuelib-1.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "e967b6eb4428da61dc24643cf7185205", + "name": "queuelib", + "sha256": "891d953fd7fa89fa7fb30a804a3e3fcfb5bbddd8e55b3d55141404c3f7d58a5b", + "size": 21292, + "subdir": "linux-64", + "timestamp": 1530959136518, + "version": "1.5.0" + }, + "queuelib-1.5.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "369f1ab0ab954e53f84761eb58f36bbe", + "name": "queuelib", + "sha256": "f4822e893e079b551bb5f832986928d8a7b561b800494bb373f10cdb8795a70b", + "size": 242982, + "subdir": "linux-64", + "timestamp": 1614090965383, + "version": "1.5.0" + }, + "queuelib-1.5.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "9b6cb48b9917d5b3c0edb4d5b4189c1d", + "name": "queuelib", + "sha256": "2af0a2177057af64eacead09f7cc0bbdc187d8622e914c12f3eced2993dda132", + "size": 21793, + "subdir": "linux-64", + "timestamp": 1573200535002, + "version": "1.5.0" + }, + "queuelib-1.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "80f625e7f99aacdee56ae368054123ac", + "name": "queuelib", + "sha256": "1e6953d29dd686ddb051ce08e1a2f8c1f458655517f2c557453527ffdffe3db0", + "size": 243240, + "subdir": "linux-64", + "timestamp": 1614090980318, + "version": "1.5.0" + }, + "queuelib-1.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "f194ee80e5c5f837fe4888b7e70b167a", + "name": "queuelib", + "sha256": "17ea0742e0a5330ff687d2bf5dd6d622e62d533a5ea16c106fa5160df83e0dfa", + "size": 244016, + "subdir": "linux-64", + "timestamp": 1614090975464, + "version": "1.5.0" + }, + "quilt3-3.1.10-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.0", + "aws-requests-auth >=0.4.2", + "boto3 >=1.8.0", + "dnspython >=1.16.0", + "flask", + "flask_cors", + "flask_json", + "jsonlines 1.2.0.*", + "packaging >=16.8", + "pandas >=0.19.2", + "pyarrow >=0.14.1", + "python >=3.10,<3.11.0a0", + "python-dateutil <=2.8.0", + "requests >=2.12.4", + "requests-futures 1.0.0", + "ruamel.yaml >=0.15.78", + "tqdm >=4.26.0", + "urllib3 1.24.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c3a1e040d42479d497fab406d9f2b1f9", + "name": "quilt3", + "sha256": "0c6ce0593e77cfda8570df2ef5325f75b67fbad551fd3c3bac39b93de2e59ed6", + "size": 142443, + "subdir": "linux-64", + "timestamp": 1643103425229, + "version": "3.1.10" + }, + "quilt3-3.1.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.0", + "aws-requests-auth >=0.4.2", + "boto3 >=1.8.0", + "dnspython >=1.16.0", + "flask", + "flask-cors", + "flask-json", + "jsonlines 1.2.0.*", + "packaging >=16.8", + "pandas >=0.19.2", + "pyarrow >=0.14.1", + "python >=3.6,<3.7.0a0", + "python-dateutil <=2.8.0", + "requests >=2.12.4", + "requests-futures 1.0.0", + "ruamel.yaml >=0.15.78", + "tqdm >=4.26.0", + "urllib3 1.24.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0d8108017ad720fc50e95eed365c06ad", + "name": "quilt3", + "sha256": "fb9b1985e2fb09d68692aa4b7a580beef569ef840a76052985987cf4b0625efb", + "size": 140182, + "subdir": "linux-64", + "timestamp": 1582211094571, + "version": "3.1.10" + }, + "quilt3-3.1.10-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.0", + "aws-requests-auth >=0.4.2", + "boto3 >=1.8.0", + "dnspython >=1.16.0", + "flask", + "flask-cors", + "flask-json", + "jsonlines 1.2.0.*", + "packaging >=16.8", + "pandas >=0.19.2", + "pyarrow >=0.14.1", + "python >=3.7,<3.8.0a0", + "python-dateutil <=2.8.0", + "requests >=2.12.4", + "requests-futures 1.0.0", + "ruamel.yaml >=0.15.78", + "tqdm >=4.26.0", + "urllib3 1.24.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2af4f556cf14bb02d2a703fce9b5dbfe", + "name": "quilt3", + "sha256": "2025bb8a9c95c148a8c9cd88b8d053c7619b6516821dbc4bd19f82608d35d4c7", + "size": 140140, + "subdir": "linux-64", + "timestamp": 1582211034591, + "version": "3.1.10" + }, + "quiver_engine-0.1.4.1.4-py27h8e5b075_0.tar.bz2": { + "build": "py27h8e5b075_0", + "build_number": 0, + "depends": [ + "flask", + "flask-cors", + "gevent", + "keras", + "numpy", + "pillow", + "python >=2.7,<2.8.0a0", + "tensorflow" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0032f1864499ed13763a0c1abe3923ac", + "name": "quiver_engine", + "sha256": "97f31f19815f8d4ec5d42d173b140aba2851518c2adbe779b9089bd077abfff3", + "size": 374212, + "subdir": "linux-64", + "timestamp": 1509400196829, + "version": "0.1.4.1.4" + }, + "quiver_engine-0.1.4.1.4-py35hf46ac68_0.tar.bz2": { + "build": "py35hf46ac68_0", + "build_number": 0, + "depends": [ + "flask", + "flask-cors", + "gevent", + "keras", + "numpy", + "pillow", + "python >=3.5,<3.6.0a0", + "tensorflow" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12f6f2505614eb76ac631c0aed931c41", + "name": "quiver_engine", + "sha256": "a161478383ebdc406c6a3672be05e9e281ae423c736b40a1288ba68e2aa5a5d1", + "size": 375190, + "subdir": "linux-64", + "timestamp": 1509400194047, + "version": "0.1.4.1.4" + }, + "quiver_engine-0.1.4.1.4-py36h1714ad7_0.tar.bz2": { + "build": "py36h1714ad7_0", + "build_number": 0, + "depends": [ + "flask", + "flask-cors", + "gevent", + "keras", + "numpy", + "pillow", + "python >=3.6,<3.7.0a0", + "tensorflow" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a746857adfef7da72f5710567e8d0162", + "name": "quiver_engine", + "sha256": "d4a1b1b1d258b5d68d5824f88e20e27cdbe847953cd59aefacfdf0e74d8e07af", + "size": 374781, + "subdir": "linux-64", + "timestamp": 1509400201488, + "version": "0.1.4.1.4" + }, + "r-sf-1.0_7-r42h6a678d5_2.tar.bz2": { + "build": "r42h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal >=3.6.0,<3.7.0a0", + "libstdcxx-ng >=11.2.0", + "r-base >=4.2,<4.3.0a0", + "r-classint >=0.4_1", + "r-dbi >=0.8", + "r-magrittr", + "r-rcpp >=0.12.18", + "r-s2 >=1.0.7", + "r-units >=0.7_0" + ], + "license": "GPL-2 | MIT", + "license_family": "GPL2", + "md5": "187c7d00f30feb7bad5ed18dc1d36961", + "name": "r-sf", + "sha256": "39e290e047fdadfd825f5cef8875b9d21730b3be610689de3a61e84ba5d9d8ff", + "size": 3364378, + "subdir": "linux-64", + "timestamp": 1677598002275, + "version": "1.0_7" + }, + "r-xgboost-0.90-r35h295c915_1.tar.bz2": { + "build": "r35h295c915_1", + "build_number": 1, + "depends": [ + "_r-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libxgboost 0.90 h295c915_1", + "r-base >=3.5,<3.6.0a0", + "r-data.table", + "r-magrittr", + "r-matrix", + "r-stringi" + ], + "md5": "4d09705af103025a752656d520e0f7e4", + "name": "r-xgboost", + "sha256": "148d3ce5b28ef6a01272e6d5f9e03b477da87d8d376350cabc23aacb1d6f052a", + "size": 1124480, + "subdir": "linux-64", + "timestamp": 1642675558667, + "version": "0.90" + }, + "r-xgboost-0.90-r35he6710b0_0.tar.bz2": { + "build": "r35he6710b0_0", + "build_number": 0, + "depends": [ + "_r-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 he6710b0_0", + "r-base >=3.5,<3.6.0a0", + "r-data.table", + "r-magrittr", + "r-matrix", + "r-stringi" + ], + "md5": "37eda95d58514d5f5a8773ca1fe06f20", + "name": "r-xgboost", + "sha256": "90b5bcb36db2d0ecc99c4e8c9c16f8cec68e83800c2b0129037cddda60aa33b0", + "size": 1124250, + "subdir": "linux-64", + "timestamp": 1592297744294, + "version": "0.90" + }, + "r-xgboost-1.5.0-r35h2c33d7e_2.tar.bz2": { + "build": "r35h2c33d7e_2", + "build_number": 2, + "depends": [ + "_openmp_mutex", + "_r-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxgboost 1.5.0 h6a678d5_2", + "r-base >=3.5,<3.6.0a0", + "r-data.table", + "r-jsonlite", + "r-magrittr", + "r-matrix" + ], + "license": "Apache-2.0", + "md5": "85088b36a0255413161bdcf410ffbfdb", + "name": "r-xgboost", + "sha256": "9491ca90b2e3fe16b507384df4e76fe702f93352a75a35444a776f21cf3b55a3", + "size": 1651726, + "subdir": "linux-64", + "timestamp": 1659549472616, + "version": "1.5.0" + }, + "r-xgboost-1.5.0-r35hd872225_1.tar.bz2": { + "build": "r35hd872225_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "_r-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libxgboost 1.5.0 h295c915_1", + "r-base >=3.5,<3.6.0a0", + "r-data.table", + "r-jsonlite", + "r-magrittr", + "r-matrix" + ], + "license": "Apache-2.0", + "md5": "47353a4ca22a9b815afc7ee0490bfd0b", + "name": "r-xgboost", + "sha256": "f580ef080452c5b50b2f472713ffad66dcd7fa5f50369958b97a2da841b02edb", + "size": 1645060, + "subdir": "linux-64", + "timestamp": 1642516719683, + "version": "1.5.0" + }, + "r-xgboost-1.5.1-r35h2a55022_0.tar.bz2": { + "build": "r35h2a55022_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "_r-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxgboost 1.5.1 h6a678d5_0", + "r-base >=3.5,<3.6.0a0", + "r-data.table", + "r-jsonlite", + "r-magrittr", + "r-matrix" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "43d30d5d899c077bc530acc7a12fb68b", + "name": "r-xgboost", + "sha256": "9be4366de7d93ddc50c0b65396049dccf25e18066db0237cfd743548b28cb594", + "size": 1642950, + "subdir": "linux-64", + "timestamp": 1675120125000, + "version": "1.5.1" + }, + "r-xgboost-1.7.3-r35h2c33d7e_0.tar.bz2": { + "build": "r35h2c33d7e_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "_r-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.7.3 h6a678d5_0", + "r-base >=3.5,<3.6.0a0", + "r-data.table", + "r-jsonlite", + "r-magrittr", + "r-matrix" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a38321afbe1b00294712bdd285d827ca", + "name": "r-xgboost", + "sha256": "d819fa176f7da85a8c2325918f6a2c34dd376e8f465aaeb033eb84107a3da646", + "size": 2076862, + "subdir": "linux-64", + "timestamp": 1675458299455, + "version": "1.7.3" + }, + "r-xgboost-cpu-0.90-r35_0.tar.bz2": { + "build": "r35_0", + "build_number": 0, + "depends": [ + "r-base >=3.5,<3.6.0a0", + "r-xgboost 0.90 r35he6710b0_0" + ], + "md5": "3b1333dd50494c87059bc079b07a3270", + "name": "r-xgboost-cpu", + "sha256": "0874a431d6709944256b7ee2cff91fbc68f435b2d56c06bc512fef593080c5e4", + "size": 11820, + "subdir": "linux-64", + "timestamp": 1592297757691, + "version": "0.90" + }, + "r-xgboost-cpu-0.90-r35h06a4308_1.tar.bz2": { + "build": "r35h06a4308_1", + "build_number": 1, + "depends": [ + "r-base >=3.5,<3.6.0a0", + "r-xgboost 0.90 r35h295c915_1" + ], + "md5": "452f60f5698305f59c3f3be698f67846", + "name": "r-xgboost-cpu", + "sha256": "ba826f2c9f90a51d12348b1a2590d5e3d281eb88b2e68576404a21203d0e537c", + "size": 12004, + "subdir": "linux-64", + "timestamp": 1642675577480, + "version": "0.90" + }, + "r-xgboost-cpu-1.5.0-r35h06a4308_1.tar.bz2": { + "build": "r35h06a4308_1", + "build_number": 1, + "depends": [ + "r-base >=3.5,<3.6.0a0", + "r-xgboost 1.5.0 r35hd872225_1" + ], + "license": "Apache-2.0", + "md5": "f58c1b5387587766e3cf156704f9a07c", + "name": "r-xgboost-cpu", + "sha256": "7bc74b14df7af65f983469e30603bbad22f34229d0a289c883ef24d397c407b9", + "size": 14795, + "subdir": "linux-64", + "timestamp": 1642516732707, + "version": "1.5.0" + }, + "r-xgboost-cpu-1.5.0-r35h06a4308_2.tar.bz2": { + "build": "r35h06a4308_2", + "build_number": 2, + "depends": [ + "r-base >=3.5,<3.6.0a0", + "r-xgboost 1.5.0 r35h2c33d7e_2" + ], + "license": "Apache-2.0", + "md5": "70cf31006c03be7d6f9f13301e748d76", + "name": "r-xgboost-cpu", + "sha256": "b36409b0bc155f050aadc99b2b3f560c551a403dbcaf7a02137265d667124a0d", + "size": 15333, + "subdir": "linux-64", + "timestamp": 1659549549730, + "version": "1.5.0" + }, + "r-xgboost-cpu-1.5.1-r35h06a4308_0.tar.bz2": { + "build": "r35h06a4308_0", + "build_number": 0, + "depends": [ + "r-base >=3.5,<3.6.0a0", + "r-xgboost 1.5.1 r35h2a55022_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "16abf930f5cb4f1097513bd6026a8406", + "name": "r-xgboost-cpu", + "sha256": "72229691a2bdef75dea724c19eef902c5f3869a6a5ee71dc19e82e23c68bd774", + "size": 14242, + "subdir": "linux-64", + "timestamp": 1675120198168, + "version": "1.5.1" + }, + "r-xgboost-cpu-1.7.3-r35h06a4308_0.tar.bz2": { + "build": "r35h06a4308_0", + "build_number": 0, + "depends": [ + "r-base >=3.5,<3.6.0a0", + "r-xgboost 1.7.3 r35h2c33d7e_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "56d518a322309d2a015763dbf954e047", + "name": "r-xgboost-cpu", + "sha256": "95661bad2c3938de40e201a0d12da25ac1a787c79f6605348fa6703b4145a3dc", + "size": 11954, + "subdir": "linux-64", + "timestamp": 1675458328210, + "version": "1.7.3" + }, + "rapidfuzz-1.9.1-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e265d91b638eb66f4182b71b233dc3a6", + "name": "rapidfuzz", + "sha256": "12a3661e0adfcc62422e701c58b72c392f2f2abfc18963817dbc756cf1230b62", + "size": 741110, + "subdir": "linux-64", + "timestamp": 1676968639207, + "version": "1.9.1" + }, + "rapidfuzz-1.9.1-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f96b2062713299973f491834e5c8bd75", + "name": "rapidfuzz", + "sha256": "e1ba3108212ad373b63c92235dd8e5ccce6ed428286da25afb3879d6bc419cc0", + "size": 735693, + "subdir": "linux-64", + "timestamp": 1676968548904, + "version": "1.9.1" + }, + "rapidfuzz-1.9.1-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa9981c84cde665e4aee44866a824742", + "name": "rapidfuzz", + "sha256": "cc88a82c5510697031166c996803bf2dd71e256baeaf1470a29edbd9067c10ed", + "size": 743322, + "subdir": "linux-64", + "timestamp": 1676968729381, + "version": "1.9.1" + }, + "rapidfuzz-1.9.1-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8eedd95189cd5cb0a74d5f06e96560db", + "name": "rapidfuzz", + "sha256": "59036ad87a68db72c19565998867608d474c8ec5e6ddb6a530537b527e1c36d9", + "size": 743171, + "subdir": "linux-64", + "timestamp": 1676968457760, + "version": "1.9.1" + }, + "rapidfuzz-2.13.7-py310h1128e8f_0.tar.bz2": { + "build": "py310h1128e8f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d198a52659219ce6cc9c31d53f0eef2e", + "name": "rapidfuzz", + "sha256": "1dd050d52721182bd93ed25c7b51f228e423c370212c458408aed4cdbb5066d8", + "size": 1998632, + "subdir": "linux-64", + "timestamp": 1679594238371, + "version": "2.13.7" + }, + "rapidfuzz-2.13.7-py311ha02d727_0.tar.bz2": { + "build": "py311ha02d727_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e42da569b070d2d9ded7421214fc50e5", + "name": "rapidfuzz", + "sha256": "31a97b2119dd648fc1513081a887a5a5f3fae9d749d81253fffd72e0967a4922", + "size": 1990643, + "subdir": "linux-64", + "timestamp": 1679594487718, + "version": "2.13.7" + }, + "rapidfuzz-2.13.7-py38h417a72b_0.tar.bz2": { + "build": "py38h417a72b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87eeb782823938916aff30cde8c6bc1e", + "name": "rapidfuzz", + "sha256": "4981f20f5d0e7c1c22d1d767c67177b52e51f7f64790c33e75a779c5e9772323", + "size": 2000015, + "subdir": "linux-64", + "timestamp": 1679593986069, + "version": "2.13.7" + }, + "rapidfuzz-2.13.7-py39h417a72b_0.tar.bz2": { + "build": "py39h417a72b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7475d44baf40231aeb09ce6ef96b9f50", + "name": "rapidfuzz", + "sha256": "2ce604bd19f969774ea557733d7c73944d69d772111912015e5c738a35675f58", + "size": 1995510, + "subdir": "linux-64", + "timestamp": 1679593732079, + "version": "2.13.7" + }, + "rapidjson-1.1.0-h6bb024c_0.tar.bz2": { + "build": "h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc930e0fe201a66decbdcb3b9f9d379b", + "name": "rapidjson", + "sha256": "4bd4ed9ddff4b4faa2628053ac80ac9399d522ec993d55a13986f7a1f5330397", + "size": 106700, + "subdir": "linux-64", + "timestamp": 1519467232429, + "version": "1.1.0" + }, + "rasterio-0.36.0-py27h3f37509_2.tar.bz2": { + "build": "py27h3f37509_2", + "build_number": 2, + "depends": [ + "affine >=1.3.0", + "attrs", + "boto3 >=1.2.4", + "click-plugins", + "cligj", + "enum34", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "d9db16963ac958199d3237becbae3261", + "name": "rasterio", + "sha256": "1ca2201aa61d7e4ce29316b1ad1ec57ab052204648132949a7dc77db138a7ca1", + "size": 1055394, + "subdir": "linux-64", + "timestamp": 1530872454421, + "version": "0.36.0" + }, + "rasterio-0.36.0-py27h453aca2_1.tar.bz2": { + "build": "py27h453aca2_1", + "build_number": 1, + "depends": [ + "affine >=1.3.0", + "attrs", + "boto3 >=1.2.4", + "click-plugins", + "cligj", + "enum34", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "205a2a432d9a77b05a22fed90efaaf2f", + "name": "rasterio", + "sha256": "fc602a435ea408c7d66ddd27a8e3e0cd5046b1dbbebc8b9cf9e234a7a8186502", + "size": 950217, + "subdir": "linux-64", + "timestamp": 1511884045780, + "version": "0.36.0" + }, + "rasterio-0.36.0-py35h94a1d1c_1.tar.bz2": { + "build": "py35h94a1d1c_1", + "build_number": 1, + "depends": [ + "affine >=1.3.0", + "attrs", + "boto3 >=1.2.4", + "click-plugins", + "cligj", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "e06443910ba2cf07f21e7abc865a3c72", + "name": "rasterio", + "sha256": "c81ae84f4a45744be270eb3d509744cd76712d97da7e16b01699541600c7faab", + "size": 928873, + "subdir": "linux-64", + "timestamp": 1511884589439, + "version": "0.36.0" + }, + "rasterio-0.36.0-py36h3f37509_2.tar.bz2": { + "build": "py36h3f37509_2", + "build_number": 2, + "depends": [ + "affine >=1.3.0", + "attrs", + "boto3 >=1.2.4", + "click-plugins", + "cligj", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "1fa2dbf8cd931ec62ca918583e05e6c8", + "name": "rasterio", + "sha256": "e8979fa749e0af942379c3b09873827ccdb7ea488eec3172756edf0ae1904266", + "size": 1052706, + "subdir": "linux-64", + "timestamp": 1530872753714, + "version": "0.36.0" + }, + "rasterio-0.36.0-py36hd410cfe_1.tar.bz2": { + "build": "py36hd410cfe_1", + "build_number": 1, + "depends": [ + "affine >=1.3.0", + "attrs", + "boto3 >=1.2.4", + "click-plugins", + "cligj", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "e5c230d53b22797e30b9118d36c7c198", + "name": "rasterio", + "sha256": "d0b5211840a6720576b69d875dca413d59472d74fb5554b8160cbb1ac772ebfd", + "size": 927026, + "subdir": "linux-64", + "timestamp": 1511884589598, + "version": "0.36.0" + }, + "rasterio-0.36.0-py37h3f37509_2.tar.bz2": { + "build": "py37h3f37509_2", + "build_number": 2, + "depends": [ + "affine >=1.3.0", + "attrs", + "boto3 >=1.2.4", + "click-plugins", + "cligj", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "4f216da65153d76d21f62d9356b234ba", + "name": "rasterio", + "sha256": "6c900d8034203fb087f302188bfdaa4a83040029594258289fe0aec236df581c", + "size": 1049081, + "subdir": "linux-64", + "timestamp": 1530872606329, + "version": "0.36.0" + }, + "rasterio-1.0.13-py27hc38cc03_0.tar.bz2": { + "build": "py27hc38cc03_0", + "build_number": 0, + "depends": [ + "affine >=1.3.0", + "attrs >=16.0.0", + "boto3 >=1.2.4", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "enum34", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "87e05df4812eff20cccd4b6d448a5d2c", + "name": "rasterio", + "sha256": "b39d36c9e835a52c9ffb77fce0603ab7c4b281a68642f3bf4ef705defb87d668", + "size": 8485666, + "subdir": "linux-64", + "timestamp": 1545417313952, + "version": "1.0.13" + }, + "rasterio-1.0.13-py36hc38cc03_0.tar.bz2": { + "build": "py36hc38cc03_0", + "build_number": 0, + "depends": [ + "affine >=1.3.0", + "attrs >=16.0.0", + "boto3 >=1.2.4", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "5a96ede85b69f41ba12ead16f3586801", + "name": "rasterio", + "sha256": "61e01d135f198f8e13ef782578a2b5f3e4d1471c26b3a4ea995431af1bbd0edb", + "size": 8513263, + "subdir": "linux-64", + "timestamp": 1545417239715, + "version": "1.0.13" + }, + "rasterio-1.0.13-py37hc38cc03_0.tar.bz2": { + "build": "py37hc38cc03_0", + "build_number": 0, + "depends": [ + "affine >=1.3.0", + "attrs >=16.0.0", + "boto3 >=1.2.4", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "1c6b316e80736d5b014e1d099246b3b9", + "name": "rasterio", + "sha256": "e9f742d334c6822326c7ca7f17d0cfa5f7cc00efff942d852a015c158cd0a455", + "size": 8543590, + "subdir": "linux-64", + "timestamp": 1545417269332, + "version": "1.0.13" + }, + "rasterio-1.0.18-py27hc38cc03_0.tar.bz2": { + "build": "py27hc38cc03_0", + "build_number": 0, + "depends": [ + "affine >=1.3.0", + "attrs >=16.0.0", + "boto3 >=1.2.4", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "enum34", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "4f2bc244a372048fe12f2bff61ba6021", + "name": "rasterio", + "sha256": "6219c38fd6f5dcc335f54a2ba0cb3007447fb1f76acbd808a1d95580bc3ae63e", + "size": 8500999, + "subdir": "linux-64", + "timestamp": 1550357369862, + "version": "1.0.18" + }, + "rasterio-1.0.18-py36hc38cc03_0.tar.bz2": { + "build": "py36hc38cc03_0", + "build_number": 0, + "depends": [ + "affine >=1.3.0", + "attrs >=16.0.0", + "boto3 >=1.2.4", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "02061c969291c72abc1df68367821971", + "name": "rasterio", + "sha256": "acca9927986bb2d3ab64102ab3305cd1af8fccd6ec4451eeef483eab87ed08e8", + "size": 8523591, + "subdir": "linux-64", + "timestamp": 1550357296583, + "version": "1.0.18" + }, + "rasterio-1.0.18-py37hc38cc03_0.tar.bz2": { + "build": "py37hc38cc03_0", + "build_number": 0, + "depends": [ + "affine >=1.3.0", + "attrs >=16.0.0", + "boto3 >=1.2.4", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "2203a86fad3cfd1d7df00c018e2a4eb8", + "name": "rasterio", + "sha256": "7b5ebc5ad7541959fa41b7b27e6f924acbf563b0fbf9d3a03a64bfd828fed23d", + "size": 8529615, + "subdir": "linux-64", + "timestamp": 1550357366766, + "version": "1.0.18" + }, + "rasterio-1.0.21-py27hc38cc03_0.tar.bz2": { + "build": "py27hc38cc03_0", + "build_number": 0, + "depends": [ + "affine >=1.3.0", + "attrs >=16.0.0", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "enum34", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "cf4247cdb6eb1f3e6761fd3d85cb9d10", + "name": "rasterio", + "sha256": "7e074efe16d4c9081e4232c80b7fc4a5fb5fe5c97f065c331a49587ce72393c6", + "size": 8489347, + "subdir": "linux-64", + "timestamp": 1552367489476, + "version": "1.0.21" + }, + "rasterio-1.0.21-py36hc38cc03_0.tar.bz2": { + "build": "py36hc38cc03_0", + "build_number": 0, + "depends": [ + "affine >=1.3.0", + "attrs >=16.0.0", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "dbb1ef4f20e2a570c288a425ec3590da", + "name": "rasterio", + "sha256": "fcd591cb1d7f263bbbdfed5fada71e0d19a0e2280cafe4b82d8dd7a77f3daccb", + "size": 8538810, + "subdir": "linux-64", + "timestamp": 1552367666419, + "version": "1.0.21" + }, + "rasterio-1.0.21-py37hc38cc03_0.tar.bz2": { + "build": "py37hc38cc03_0", + "build_number": 0, + "depends": [ + "affine >=1.3.0", + "attrs >=16.0.0", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "97f299ac4a5e953895a174cbb431a7bc", + "name": "rasterio", + "sha256": "e54799a718659148efd3450fdd1444d22556e365a3d8658d7058231cbb1898e3", + "size": 8540797, + "subdir": "linux-64", + "timestamp": 1552367624856, + "version": "1.0.21" + }, + "rasterio-1.1.0-py27h41e4f33_0.tar.bz2": { + "build": "py27h41e4f33_0", + "build_number": 0, + "depends": [ + "affine", + "attrs", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "enum34", + "libgcc-ng >=7.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD-3-Clause", + "md5": "c822ddb90b8f64b53ff038915a699aa4", + "name": "rasterio", + "sha256": "480e7fe4866fbffdd5602ee078bd5e7b0c1e0e86f5148e3743d5f39e0b542126", + "size": 8614732, + "subdir": "linux-64", + "timestamp": 1573765134461, + "version": "1.1.0" + }, + "rasterio-1.1.0-py310ha4a3290_0.tar.bz2": { + "build": "py310ha4a3290_0", + "build_number": 0, + "depends": [ + "affine", + "attrs", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.5.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD-3-Clause", + "md5": "e80bf8cb792d3eff17335f770b179a30", + "name": "rasterio", + "sha256": "ca9bae061a8f29598017f21244de3caeaad509ae6fd13370de9f25ceb5090ca8", + "size": 12158787, + "subdir": "linux-64", + "timestamp": 1640794292373, + "version": "1.1.0" + }, + "rasterio-1.1.0-py36h41e4f33_0.tar.bz2": { + "build": "py36h41e4f33_0", + "build_number": 0, + "depends": [ + "affine", + "attrs", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD-3-Clause", + "md5": "659a6f83dbbf49c1f5535687e8f669e9", + "name": "rasterio", + "sha256": "c43e470ea9fac21c1f2e65a1d340e608f588250193f08b9d8a79f9ef8a898564", + "size": 8655422, + "subdir": "linux-64", + "timestamp": 1573764087721, + "version": "1.1.0" + }, + "rasterio-1.1.0-py37h41e4f33_0.tar.bz2": { + "build": "py37h41e4f33_0", + "build_number": 0, + "depends": [ + "affine", + "attrs", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD-3-Clause", + "md5": "dbbb96cbe6d907652416358f9875189a", + "name": "rasterio", + "sha256": "420f23af7bb1a5eb34f09b8e0df89ebfeca94591ba1121889176653cbc3d5788", + "size": 8641312, + "subdir": "linux-64", + "timestamp": 1573765806388, + "version": "1.1.0" + }, + "rasterio-1.2.10-py310ha4a3290_0.tar.bz2": { + "build": "py310ha4a3290_0", + "build_number": 0, + "depends": [ + "affine", + "attrs", + "certifi", + "click >=4.0", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.5.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9bece9594f0990ac7a58e592dc61c2bd", + "name": "rasterio", + "sha256": "2b0385914135822f0032414c47504e6b0297b1d4b0db12834f5c867cfc7efdf1", + "size": 12630233, + "subdir": "linux-64", + "timestamp": 1650637382630, + "version": "1.2.10" + }, + "rasterio-1.2.10-py311h5ab40d8_0.tar.bz2": { + "build": "py311h5ab40d8_0", + "build_number": 0, + "depends": [ + "affine", + "attrs", + "certifi", + "click >=4.0", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=11.2.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20361e90ad469a34ebbfea9e20a1c28c", + "name": "rasterio", + "sha256": "d3c220256dee04f5217a11512d622aef9807244dcd4ac3c7fc4ef45f2060c45e", + "size": 8657392, + "subdir": "linux-64", + "timestamp": 1676861787335, + "version": "1.2.10" + }, + "rasterio-1.2.10-py37h9a6c7ee_0.tar.bz2": { + "build": "py37h9a6c7ee_0", + "build_number": 0, + "depends": [ + "affine", + "attrs", + "certifi", + "click >=4.0", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.5.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cac0e723150862ece8c0b54709433312", + "name": "rasterio", + "sha256": "11cc3d5f2477bb95ec0a8caa6882aa08360d29882342a16233a7c8c76d84b100", + "size": 8577595, + "subdir": "linux-64", + "timestamp": 1650638208465, + "version": "1.2.10" + }, + "rasterio-1.2.10-py38h9a6c7ee_0.tar.bz2": { + "build": "py38h9a6c7ee_0", + "build_number": 0, + "depends": [ + "affine", + "attrs", + "certifi", + "click >=4.0", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.5.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1137fa4787493166ce6c9d148ecd347b", + "name": "rasterio", + "sha256": "affb4a289e0f3be4cb62652260941c4a54070e0576fa28ed1c415e9888061916", + "size": 8655998, + "subdir": "linux-64", + "timestamp": 1650637656283, + "version": "1.2.10" + }, + "rasterio-1.2.10-py39h9a6c7ee_0.tar.bz2": { + "build": "py39h9a6c7ee_0", + "build_number": 0, + "depends": [ + "affine", + "attrs", + "certifi", + "click >=4.0", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.5.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6d812b409df2cba6e230c7969f6f7da4", + "name": "rasterio", + "sha256": "a492600ba1e2d873a6d90daf767736d497e2ffdc075da8d8a6ae65442109ab6e", + "size": 8655902, + "subdir": "linux-64", + "timestamp": 1650637932328, + "version": "1.2.10" + }, + "ray-core-1.4.0-py36h295c915_1.tar.bz2": { + "build": "py36h295c915_1", + "build_number": 1, + "depends": [ + "aiohttp", + "aiohttp-cors", + "aioredis", + "click >=7.0", + "colorama", + "colorful", + "dataclasses", + "filelock", + "gpustat", + "grpcio >=1.28.1", + "jsonschema", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "opencensus", + "pickle5", + "prometheus_client >=0.7.1", + "protobuf >=3.15.3", + "psutil", + "pydantic >=1.8", + "python >=3.6,<3.7.0a0", + "pyyaml", + "redis-py >=3.5.0", + "requests", + "setproctitle 1.1.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c6044320aeeb732319af203aff83eae7", + "name": "ray-core", + "sha256": "7e8f20ca42dc6ecf96203f469cd840513963c07303eb9b70a31cee5077cc5f4f", + "size": 23047998, + "subdir": "linux-64", + "timestamp": 1627060887488, + "version": "1.4.0" + }, + "ray-core-1.4.0-py37h295c915_1.tar.bz2": { + "build": "py37h295c915_1", + "build_number": 1, + "depends": [ + "aiohttp", + "aiohttp-cors", + "aioredis", + "click >=7.0", + "colorama", + "colorful", + "filelock", + "gpustat", + "grpcio >=1.28.1", + "jsonschema", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "opencensus", + "pickle5", + "prometheus_client >=0.7.1", + "protobuf >=3.15.3", + "psutil", + "pydantic >=1.8", + "python >=3.7,<3.8.0a0", + "pyyaml", + "redis-py >=3.5.0", + "requests", + "setproctitle 1.1.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "52c933a6dc0033add455e7107ff0f518", + "name": "ray-core", + "sha256": "d79258b7cf166dfaa31060e7618593284b61fdab1d5eb40dd908bf30d79455e7", + "size": 23019563, + "subdir": "linux-64", + "timestamp": 1627060386456, + "version": "1.4.0" + }, + "ray-core-1.4.0-py38h295c915_1.tar.bz2": { + "build": "py38h295c915_1", + "build_number": 1, + "depends": [ + "aiohttp", + "aiohttp-cors", + "aioredis", + "click >=7.0", + "colorama", + "colorful", + "filelock", + "gpustat", + "grpcio >=1.28.1", + "jsonschema", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "opencensus", + "prometheus_client >=0.7.1", + "protobuf >=3.15.3", + "psutil", + "pydantic >=1.8", + "python >=3.8,<3.9.0a0", + "pyyaml", + "redis-py >=3.5.0", + "requests", + "setproctitle 1.1.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3ecb7f3dff8afcfc578a901322232068", + "name": "ray-core", + "sha256": "ee1e346ab2056d35b5321333dafee41d1c113f42af153372a417cee5815c68dc", + "size": 22994127, + "subdir": "linux-64", + "timestamp": 1627059869595, + "version": "1.4.0" + }, + "ray-core-1.4.0-py39h295c915_1.tar.bz2": { + "build": "py39h295c915_1", + "build_number": 1, + "depends": [ + "aiohttp", + "aiohttp-cors", + "aioredis", + "click >=7.0", + "colorama", + "colorful", + "filelock", + "gpustat", + "grpcio >=1.28.1", + "jsonschema", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "opencensus", + "prometheus_client >=0.7.1", + "protobuf >=3.15.3", + "psutil", + "pydantic >=1.8", + "python >=3.9,<3.10.0a0", + "pyyaml", + "redis-py >=3.5.0", + "requests", + "setproctitle 1.1.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "65a50d1e3a13995938f85223725445dd", + "name": "ray-core", + "sha256": "d8af61cb2172e6c577e3fac6c1f0d064cb3ed044524d6f0126e0221bfefcb27a", + "size": 21947276, + "subdir": "linux-64", + "timestamp": 1627061396722, + "version": "1.4.0" + }, + "ray-core-1.6.0-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "attrs", + "click >=7.0", + "colorama", + "filelock", + "grpcio >=1.28.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "pickle5", + "protobuf >=3.15.3", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "redis-py >=3.5.0", + "setproctitle 1.1.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "76c327edfd972789adcba678fed5a40e", + "name": "ray-core", + "sha256": "8aa895302102a7b65e3a56f40e1150416199b862e7705a099459aeed27e88689", + "size": 30276568, + "subdir": "linux-64", + "timestamp": 1640797633844, + "version": "1.6.0" + }, + "ray-core-1.6.0-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "attrs", + "click >=7.0", + "colorama", + "filelock", + "grpcio >=1.28.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "protobuf >=3.15.3", + "psutil", + "python >=3.8,<3.9.0a0", + "pyyaml", + "redis-py >=3.5.0", + "setproctitle 1.1.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "58109934e29fdf33a10cbbae65336ed0", + "name": "ray-core", + "sha256": "00db0ae46d41096cc2cc992a1ade9d2595310495c004b27d0c986c2d74f00c07", + "size": 30259237, + "subdir": "linux-64", + "timestamp": 1640798729195, + "version": "1.6.0" + }, + "ray-core-1.6.0-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "attrs", + "click >=7.0", + "colorama", + "filelock", + "grpcio >=1.28.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "protobuf >=3.15.3", + "psutil", + "python >=3.9,<3.10.0a0", + "pyyaml", + "redis-py >=3.5.0", + "setproctitle 1.1.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "73e86ae41ce36828f362a55e97612246", + "name": "ray-core", + "sha256": "234ebabbd33706ee49669b7e24c32fb0a4861726b7b9dabb06a85b6a232ce8aa", + "size": 28938959, + "subdir": "linux-64", + "timestamp": 1640798192129, + "version": "1.6.0" + }, + "ray-core-1.9.2-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "attrs", + "click >=7.0", + "colorama", + "filelock", + "grpcio >=1.28.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "pickle5", + "protobuf >=3.15.3", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "redis-py >=3.5.0", + "setproctitle 1.2.2.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7e9f344252fa58cbbc7ae30b9e4e99b5", + "name": "ray-core", + "sha256": "1322d91bdd78df290b74bbfba7363ae6203f782800a2416909e249aa5dee1ba2", + "size": 41671418, + "subdir": "linux-64", + "timestamp": 1659006375240, + "version": "1.9.2" + }, + "ray-core-1.9.2-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "attrs", + "click >=7.0", + "colorama", + "filelock", + "grpcio >=1.28.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "protobuf >=3.15.3", + "psutil", + "python >=3.8,<3.9.0a0", + "pyyaml", + "redis-py >=3.5.0", + "setproctitle 1.2.2.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "56821981d7881b7218f21db13d230a01", + "name": "ray-core", + "sha256": "281e702aa4bab984c786f4220be6bc013f35a279b4b6cee567610b379ba9abac", + "size": 41679296, + "subdir": "linux-64", + "timestamp": 1659005675747, + "version": "1.9.2" + }, + "ray-core-1.9.2-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "attrs", + "click >=7.0", + "colorama", + "filelock", + "grpcio >=1.28.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.19.3", + "protobuf >=3.15.3", + "psutil", + "python >=3.9,<3.10.0a0", + "pyyaml", + "redis-py >=3.5.0", + "setproctitle 1.2.2.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d299e2719368b6f490600c791097868d", + "name": "ray-core", + "sha256": "35be709ea442046f4386620d16612152577be3da829126057659497d18a29ba1", + "size": 41694230, + "subdir": "linux-64", + "timestamp": 1659004976267, + "version": "1.9.2" + }, + "ray-core-2.0.1-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "aiosignal", + "attrs", + "click >=7.0,<=8.0.4", + "colorama", + "filelock", + "frozenlist", + "grpcio >=1.28.1,<1.48", + "jsonschema", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.19.3", + "protobuf >=3.15.3,<4.0.0", + "psutil", + "python >=3.10,<3.11.0a0", + "pyyaml", + "requests", + "setproctitle 1.2.2.*", + "virtualenv" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "75eb26f11fceae4a7bf0cc6dead0d904", + "name": "ray-core", + "sha256": "890fa1967b34683b73d0cf21ceb8d152bb8797079f05e8b8d911b94bccfdbd2f", + "size": 38933910, + "subdir": "linux-64", + "timestamp": 1668105883974, + "version": "2.0.1" + }, + "ray-core-2.0.1-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "aiosignal", + "attrs", + "click >=7.0,<=8.0.4", + "colorama", + "filelock", + "frozenlist", + "grpcio >=1.28.1,<1.48", + "jsonschema", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "pickle5", + "protobuf >=3.15.3,<4.0.0", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "requests", + "setproctitle 1.2.2.*", + "typing_extensions", + "virtualenv" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f5039fc1bdc9545872621773f982b420", + "name": "ray-core", + "sha256": "a4611845baa7464368831b286c0c6ac2ea9e4d5c10c398a84d2d3d41397d0365", + "size": 38832712, + "subdir": "linux-64", + "timestamp": 1668106330940, + "version": "2.0.1" + }, + "ray-core-2.0.1-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "aiosignal", + "attrs", + "click >=7.0,<=8.0.4", + "colorama", + "filelock", + "frozenlist", + "grpcio >=1.28.1,<1.48", + "jsonschema", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "protobuf >=3.15.3,<4.0.0", + "psutil", + "python >=3.8,<3.9.0a0", + "pyyaml", + "requests", + "setproctitle 1.2.2.*", + "virtualenv" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b03ae06a5b0e81d2942cdcc56a7e401d", + "name": "ray-core", + "sha256": "9c6c10ebe494061c2efd1d3c076846ed81f84f2a94de4bf31c928a40401ccf41", + "size": 38929385, + "subdir": "linux-64", + "timestamp": 1668107219594, + "version": "2.0.1" + }, + "ray-core-2.0.1-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "aiosignal", + "attrs", + "click >=7.0,<=8.0.4", + "colorama", + "filelock", + "frozenlist", + "grpcio >=1.28.1,<1.48", + "jsonschema", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.19.3", + "protobuf >=3.15.3,<4.0.0", + "psutil", + "python >=3.9,<3.10.0a0", + "pyyaml", + "requests", + "setproctitle 1.2.2.*", + "virtualenv" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b53718d1e8ced2036f6c0fb2489b605b", + "name": "ray-core", + "sha256": "636b359ee0787318b6520695dcd99d6ad8d975737ca44c8bff17f85f2faa59b6", + "size": 38814752, + "subdir": "linux-64", + "timestamp": 1668106775708, + "version": "2.0.1" + }, + "ray-core-2.3.0-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "aiosignal", + "attrs", + "click >=7.0,<=8.0.4", + "colorama", + "filelock", + "frozenlist", + "grpcio >=1.42,<1.49", + "jsonschema", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.19.3", + "packaging", + "protobuf >=3.15.3,!=3.19.5,<4.0.0", + "psutil", + "python >=3.10,<3.11.0a0", + "pyyaml", + "requests", + "setproctitle 1.2.2.*", + "virtualenv >=20.0.24" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "80fc9c96318133211dd9438ab9fccf07", + "name": "ray-core", + "sha256": "0a7d2c2fbf8bbbc03a287bcc3a2ca6a911af14d26dc5df88dd95f8bd82668c40", + "size": 36890732, + "subdir": "linux-64", + "timestamp": 1678437485443, + "version": "2.3.0" + }, + "ray-core-2.3.0-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "aiosignal", + "attrs", + "click >=7.0,<=8.0.4", + "colorama", + "filelock", + "frozenlist", + "grpcio >=1.42,<1.49", + "jsonschema", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "protobuf >=3.15.3,!=3.19.5,<4.0.0", + "psutil", + "python >=3.8,<3.9.0a0", + "pyyaml", + "requests", + "setproctitle 1.2.2.*", + "virtualenv >=20.0.24" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "505da0209cb366f7710197576022af2d", + "name": "ray-core", + "sha256": "95aaf48b73b9a49b452c600c4f9076edb11fe65d6d5826870e4b12dfd54b4924", + "size": 36815783, + "subdir": "linux-64", + "timestamp": 1678432273991, + "version": "2.3.0" + }, + "ray-core-2.3.0-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "aiosignal", + "attrs", + "click >=7.0,<=8.0.4", + "colorama", + "filelock", + "frozenlist", + "grpcio >=1.42,<1.49", + "jsonschema", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.19.3", + "protobuf >=3.15.3,!=3.19.5,<4.0.0", + "psutil", + "python >=3.9,<3.10.0a0", + "pyyaml", + "requests", + "setproctitle 1.2.2.*", + "virtualenv >=20.0.24" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d4e6efb16b1a0a2baf15c5722654ecf8", + "name": "ray-core", + "sha256": "f6f79d16b5f07be8ffabda773989a935799ade54daaabb7fda80af4165299c7e", + "size": 36799652, + "subdir": "linux-64", + "timestamp": 1678434914744, + "version": "2.3.0" + }, + "ray-dashboard-1.4.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "ray-core 1.4.0 py36h295c915_1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fd569b2901a3356dd939e5c84ad4e0e1", + "name": "ray-dashboard", + "sha256": "6717ff3a5e12860ffacbd2ce48d505b32357407b6ed50096aa663701433f026b", + "size": 2288972, + "subdir": "linux-64", + "timestamp": 1627061721368, + "version": "1.4.0" + }, + "ray-dashboard-1.4.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "ray-core 1.4.0 py37h295c915_1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cf33607ca15d04ee0af38cd26764aa92", + "name": "ray-dashboard", + "sha256": "f11b46a203d590eb08dfdc6821aacb11d1180898c6a16bcbd0d3c31aa0f05c69", + "size": 2288782, + "subdir": "linux-64", + "timestamp": 1627061638043, + "version": "1.4.0" + }, + "ray-dashboard-1.4.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "ray-core 1.4.0 py38h295c915_1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4688517e7bd3d33ea13856422ced5d9c", + "name": "ray-dashboard", + "sha256": "5221b3bb5fbe96bf359623747622743818824eb076a81c05803002b6788a67a5", + "size": 2288632, + "subdir": "linux-64", + "timestamp": 1627061554334, + "version": "1.4.0" + }, + "ray-dashboard-1.4.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "ray-core 1.4.0 py39h295c915_1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aad0115c14c6edc22575f2e0ebaef1ba", + "name": "ray-dashboard", + "sha256": "2bcbd500bb4dd5a21b08a222f4ffb5680dfbaf597c2581eeb59af2990724f6ed", + "size": 2288628, + "subdir": "linux-64", + "timestamp": 1627061802247, + "version": "1.4.0" + }, + "ray-dashboard-1.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "ray-default 1.6.0 py37h06a4308_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ae20d949b5e996c8ef2f6d6f7890cc25", + "name": "ray-dashboard", + "sha256": "3cbfd45dd78c9e5946ecd852b06fc6e2ebc1bca1664a5acdb80294584f7ad817", + "size": 2267093, + "subdir": "linux-64", + "timestamp": 1640798967413, + "version": "1.6.0" + }, + "ray-dashboard-1.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "ray-default 1.6.0 py38h06a4308_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "682e7850de19f1228b5af81c756b51c9", + "name": "ray-dashboard", + "sha256": "ea831d238677c379671aa73617640554f60247130cbc79844697c7953ac390bd", + "size": 2267049, + "subdir": "linux-64", + "timestamp": 1640799212028, + "version": "1.6.0" + }, + "ray-dashboard-1.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "ray-default 1.6.0 py39h06a4308_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f7be71569e7f75566930998dfaa68cca", + "name": "ray-dashboard", + "sha256": "adbd9e94b9c797a10bcc2c72cc5e9b28d666036a412d1fecedb27fbc799c2ba4", + "size": 2267361, + "subdir": "linux-64", + "timestamp": 1640799088297, + "version": "1.6.0" + }, + "ray-dashboard-2.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "ray-default 2.3.0 py310h06a4308_0", + "typing-extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "453c11aebdcca687f7ee52c9c3f66f8f", + "name": "ray-dashboard", + "sha256": "0bd72cd23f88f0042c56a7adf5128a1365a9cc08c5c3d8f739a079f797b1127d", + "size": 2381967, + "subdir": "linux-64", + "timestamp": 1678437642408, + "version": "2.3.0" + }, + "ray-dashboard-2.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "ray-default 2.3.0 py38h06a4308_0", + "typing-extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ac2a99bf9a668a886b15a6356f351663", + "name": "ray-dashboard", + "sha256": "86ae74a1fe1baffa59f10014c162b26526bac28405db2f328fff3818b8adb076", + "size": 2382457, + "subdir": "linux-64", + "timestamp": 1678432433639, + "version": "2.3.0" + }, + "ray-dashboard-2.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "ray-default 2.3.0 py39h06a4308_0", + "typing-extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bd867132c7fe25e5536cf37c25c92fad", + "name": "ray-dashboard", + "sha256": "6c0fd2e610063c72305545bf2163443c09fe1e303ee9529635ea20c9721517cd", + "size": 2383011, + "subdir": "linux-64", + "timestamp": 1678435066946, + "version": "2.3.0" + }, + "ray-data-2.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec", + "numpy >=1.20", + "pandas >=1.3", + "pyarrow >=6.0.1", + "python >=3.10,<3.11.0a0", + "ray-core 2.3.0 py310h6a678d5_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8fb0a012d527ccfd44e6adae60a146b6", + "name": "ray-data", + "sha256": "ccde9f58f6db4a104dfbe18a5c530966fdf8aa00372ed0157505160a07f27d6b", + "size": 36794, + "subdir": "linux-64", + "timestamp": 1678437517430, + "version": "2.3.0" + }, + "ray-data-2.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec", + "numpy >=1.20", + "pandas >=1.3", + "pyarrow >=6.0.1", + "python >=3.8,<3.9.0a0", + "ray-core 2.3.0 py38h6a678d5_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "59dbf2683d6d90eac066e7ad6a73a0b1", + "name": "ray-data", + "sha256": "93791bea11440626ad1952bcc39e2e6dbc7ec19d1a4340cda2a524f3464c27cc", + "size": 36783, + "subdir": "linux-64", + "timestamp": 1678432304346, + "version": "2.3.0" + }, + "ray-data-2.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec", + "numpy >=1.20", + "pandas >=1.3", + "pyarrow >=6.0.1", + "python >=3.9,<3.10.0a0", + "ray-core 2.3.0 py39h6a678d5_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7ac7296cf5d766f6009669e278ea6578", + "name": "ray-data", + "sha256": "c849845e52dbe7fe5d6876d77e284a1cb93fa97c16078858f8e9cae7462c096b", + "size": 36739, + "subdir": "linux-64", + "timestamp": 1678434946325, + "version": "2.3.0" + }, + "ray-debug-2.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "py-spy >=0.2.0", + "python >=3.10,<3.11.0a0", + "ray-core 2.3.0 py310h6a678d5_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "816bddc72eefb508334d84c1a1ab08a6", + "name": "ray-debug", + "sha256": "fd857eaef763d6c67726a2f11c4a500711576d427308661b1cabe22a1223405e", + "size": 36729, + "subdir": "linux-64", + "timestamp": 1678437523572, + "version": "2.3.0" + }, + "ray-debug-2.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py-spy >=0.2.0", + "python >=3.8,<3.9.0a0", + "ray-core 2.3.0 py38h6a678d5_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "069dd41c31656f2200f20ae3e93e97f9", + "name": "ray-debug", + "sha256": "39b9dd9fbb51b281564e200d038725247bbccf0e6b747066b7850a3a16196836", + "size": 36718, + "subdir": "linux-64", + "timestamp": 1678432310215, + "version": "2.3.0" + }, + "ray-debug-2.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py-spy >=0.2.0", + "python >=3.9,<3.10.0a0", + "ray-core 2.3.0 py39h6a678d5_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "30b7bc2f3fafa6b28ee01e60cac65244", + "name": "ray-debug", + "sha256": "cef5350d577bf89dc6276c5742684181d0ccdbf738823134dc06a1e1775085fd", + "size": 36725, + "subdir": "linux-64", + "timestamp": 1678434952315, + "version": "2.3.0" + }, + "ray-default-1.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp 3.7.*", + "aiohttp-cors", + "aioredis <2", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1", + "py-spy >=0.2.0", + "python >=3.7,<3.8.0a0", + "ray-core 1.6.0 py37h295c915_0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1ad1ac8778f3d6ad6d1a499ea726adcf", + "name": "ray-default", + "sha256": "c0cb066f621672f86e3291480f40427663e8b79b42e45f8c892eab726ecbb519", + "size": 44108, + "subdir": "linux-64", + "timestamp": 1640798760608, + "version": "1.6.0" + }, + "ray-default-1.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp 3.7.*", + "aiohttp-cors", + "aioredis <2", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1", + "py-spy >=0.2.0", + "python >=3.8,<3.9.0a0", + "ray-core 1.6.0 py38h295c915_0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "19026ace03f08e437cf825c0e9ca56ac", + "name": "ray-default", + "sha256": "c255fdf766ad87ff5e84e141336c46ee21d78694e3a3c59a9d720056914c0304", + "size": 44109, + "subdir": "linux-64", + "timestamp": 1640798773585, + "version": "1.6.0" + }, + "ray-default-1.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp 3.7.*", + "aiohttp-cors", + "aioredis <2", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1", + "py-spy >=0.2.0", + "python >=3.9,<3.10.0a0", + "ray-core 1.6.0 py39h295c915_0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5d0b29d6dc4b7b3937f84d7892dfb5db", + "name": "ray-default", + "sha256": "54f4144291aa491d18c11cd7b6c81d202bf155dfe95bdf96ff819565887892a3", + "size": 44091, + "subdir": "linux-64", + "timestamp": 1640798767354, + "version": "1.6.0" + }, + "ray-default-1.9.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "aioredis <2", + "aiosignal", + "colorful", + "frozenlist", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1", + "py-spy >=0.2.0", + "python >=3.7,<3.8.0a0", + "ray-core 1.9.2 py37h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "96058463ed9fec7dc09628670b4efc28", + "name": "ray-default", + "sha256": "c2bb3f939d5250fa693e27c38807a498bcd43ced80cb2e513a8a247628298c25", + "size": 45016, + "subdir": "linux-64", + "timestamp": 1659006427086, + "version": "1.9.2" + }, + "ray-default-1.9.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "aioredis <2", + "aiosignal", + "colorful", + "frozenlist", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1", + "py-spy >=0.2.0", + "python >=3.8,<3.9.0a0", + "ray-core 1.9.2 py38h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "38e4c02723ad3c3a2100b9aee138383c", + "name": "ray-default", + "sha256": "10173165bfb0c1be491027921a9d72c5c3f5feb4d1ef984b26200e1065475893", + "size": 45003, + "subdir": "linux-64", + "timestamp": 1659006419411, + "version": "1.9.2" + }, + "ray-default-1.9.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "aioredis <2", + "aiosignal", + "colorful", + "frozenlist", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1", + "py-spy >=0.2.0", + "python >=3.9,<3.10.0a0", + "ray-core 1.9.2 py39h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0c0c745206ea7e4e48c46f7bbfefa3cc", + "name": "ray-default", + "sha256": "a27fed94541c3c16aefe62cc0c0267a2cb1b9b5244a825747ffa8afe15374abe", + "size": 44976, + "subdir": "linux-64", + "timestamp": 1659006411976, + "version": "1.9.2" + }, + "ray-default-2.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1,<0.14.0", + "py-spy >=0.2.0", + "pydantic", + "python >=3.10,<3.11.0a0", + "ray-core 2.0.1 py310h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1825cd9b9712db21df62df53c50b4cf6", + "name": "ray-default", + "sha256": "6192dc2ef21db04784efead562d4464b224f98fe608659bf648a7a77e17a146a", + "size": 35022, + "subdir": "linux-64", + "timestamp": 1668107247485, + "version": "2.0.1" + }, + "ray-default-2.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1,<0.14.0", + "py-spy >=0.2.0", + "pydantic", + "python >=3.7,<3.8.0a0", + "ray-core 2.0.1 py37h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e0e45d0921765dded5d70e5c51b50258", + "name": "ray-default", + "sha256": "4e1fb401cf88f120a9cfee0fe429682dc2b74dc6c1e10d93c685cf70b40facfe", + "size": 34971, + "subdir": "linux-64", + "timestamp": 1668107254135, + "version": "2.0.1" + }, + "ray-default-2.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1,<0.14.0", + "py-spy >=0.2.0", + "pydantic", + "python >=3.8,<3.9.0a0", + "ray-core 2.0.1 py38h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f24f20348ffa19bccb3961e4aa0d0e0c", + "name": "ray-default", + "sha256": "06a86fb184e3ebb312e6fb9fb18b9947665fdf0c55ea1a4f02dc1b980a99787a", + "size": 34987, + "subdir": "linux-64", + "timestamp": 1668107267901, + "version": "2.0.1" + }, + "ray-default-2.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1,<0.14.0", + "py-spy >=0.2.0", + "pydantic", + "python >=3.9,<3.10.0a0", + "ray-core 2.0.1 py39h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ed5e4f25db99e0666ac191d059711227", + "name": "ray-default", + "sha256": "5e64903d9d18e9bcb44569afef933f016fcfb0342746244ede382a08ba179ac8", + "size": 35017, + "subdir": "linux-64", + "timestamp": 1668107261176, + "version": "2.0.1" + }, + "ray-default-2.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1,<0.14.0", + "py-spy >=0.2.0", + "pydantic", + "python >=3.10,<3.11.0a0", + "ray-core 2.3.0 py310h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bc84108583294dd22c82eedb63c9bda6", + "name": "ray-default", + "sha256": "41e650dc03174a478a74a8bc772469582264281ce13c44250e46c995e65868a5", + "size": 36808, + "subdir": "linux-64", + "timestamp": 1678437529762, + "version": "2.3.0" + }, + "ray-default-2.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1,<0.14.0", + "py-spy >=0.2.0", + "pydantic", + "python >=3.8,<3.9.0a0", + "ray-core 2.3.0 py38h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c1b4243265690aebd2f610a3e60a72aa", + "name": "ray-default", + "sha256": "395806fefca86d103836e1f8fa61636a9ab2902eb7b255086f41eb376b11ac40", + "size": 36757, + "subdir": "linux-64", + "timestamp": 1678432316051, + "version": "2.3.0" + }, + "ray-default-2.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1,<0.14.0", + "py-spy >=0.2.0", + "pydantic", + "python >=3.9,<3.10.0a0", + "ray-core 2.3.0 py39h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b6c34da78da7b46d6e2b7e551cbc54ab", + "name": "ray-default", + "sha256": "9f16688e4a124629f865e30253f938ae381971b4e2e620a0e124d4f2e8f8afe0", + "size": 36788, + "subdir": "linux-64", + "timestamp": 1678434958308, + "version": "2.3.0" + }, + "ray-rllib-2.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dm-tree", + "gymnasium 0.26.3", + "lz4", + "python >=3.10,<3.11.0a0", + "pyyaml", + "ray-tune 2.3.0 py310h06a4308_0", + "rich", + "scikit-image", + "scipy", + "typer" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a27257198fe96f9bd3f14349f2f68dad", + "name": "ray-rllib", + "sha256": "515ce809fc1c7f787b0f417a5076bf6460ffc171bceab94e409c3dc620bc5fc4", + "size": 37190, + "subdir": "linux-64", + "timestamp": 1678437656771, + "version": "2.3.0" + }, + "ray-rllib-2.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dm-tree", + "gymnasium 0.26.3", + "lz4", + "python >=3.8,<3.9.0a0", + "pyyaml", + "ray-tune 2.3.0 py38h06a4308_0", + "rich", + "scikit-image", + "scipy", + "typer" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b15e9a8dbda9ebc0a395c2b0466f72b6", + "name": "ray-rllib", + "sha256": "31bb2f8d48d4bd5bc1a143d69c2be9cb68dbde13cb930c93f9541a92442045fe", + "size": 37188, + "subdir": "linux-64", + "timestamp": 1678432447290, + "version": "2.3.0" + }, + "ray-rllib-2.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dm-tree", + "gymnasium 0.26.3", + "lz4", + "python >=3.9,<3.10.0a0", + "pyyaml", + "ray-tune 2.3.0 py39h06a4308_0", + "rich", + "scikit-image", + "scipy", + "typer" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "daefce54889aead0e03416d4da175063", + "name": "ray-rllib", + "sha256": "937b8032601824e50cc4d728a533ab281c48f12d38e172d5e8f42eedb0931fd1", + "size": 37147, + "subdir": "linux-64", + "timestamp": 1678435080968, + "version": "2.3.0" + }, + "ray-train-2.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "ray-tune 2.3.0 py310h06a4308_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0c84e2a614b1a5cebe5fd792ba426a73", + "name": "ray-train", + "sha256": "adb158d0adcfe288ad5bac0b2582f614de2f72dd0a4026e56c69e236716a7cac", + "size": 36723, + "subdir": "linux-64", + "timestamp": 1678437662863, + "version": "2.3.0" + }, + "ray-train-2.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "ray-tune 2.3.0 py38h06a4308_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "34410bf552cae401625855c226bde82e", + "name": "ray-train", + "sha256": "3483661a6a4fd05d7b90800d54e3262a7ec14d6e1f1cbd7173d41bebffed917b", + "size": 36688, + "subdir": "linux-64", + "timestamp": 1678432453070, + "version": "2.3.0" + }, + "ray-train-2.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "ray-tune 2.3.0 py39h06a4308_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d448e801f40e92daa49bd55e8471cb61", + "name": "ray-train", + "sha256": "008a9adf8e5d366f5fbd23c44ce70d31ffaf2bfe361bf6054eab7600ea896f4c", + "size": 36711, + "subdir": "linux-64", + "timestamp": 1678435087104, + "version": "2.3.0" + }, + "ray-tune-1.4.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "pandas", + "python >=3.6,<3.7.0a0", + "ray-core 1.4.0 py36h295c915_1", + "tabulate", + "tensorboardx" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b6923f0a487b95115877a38ae170da1f", + "name": "ray-tune", + "sha256": "8cdb2bfabc70dd2dbb619a4e251035f6a31eca9ad589740af31bda4a50daca09", + "size": 41817, + "subdir": "linux-64", + "timestamp": 1627061821230, + "version": "1.4.0" + }, + "ray-tune-1.4.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "pandas", + "python >=3.7,<3.8.0a0", + "ray-core 1.4.0 py37h295c915_1", + "tabulate", + "tensorboardx" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bcecf30bff54af1f08afc91acc7a1517", + "name": "ray-tune", + "sha256": "d5cafc9f857e2a3d26330fe74209f79564327f5583d0ce8b25e28d377abcf43b", + "size": 41816, + "subdir": "linux-64", + "timestamp": 1627061815627, + "version": "1.4.0" + }, + "ray-tune-1.4.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "pandas", + "python >=3.8,<3.9.0a0", + "ray-core 1.4.0 py38h295c915_1", + "tabulate", + "tensorboardx" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d04f9ba4b368ac70ee102c98a52186c9", + "name": "ray-tune", + "sha256": "ba36f649aaecf8178d14a3eb14380397105ec2beebfb3f0eda492551c00e8698", + "size": 41812, + "subdir": "linux-64", + "timestamp": 1627061809809, + "version": "1.4.0" + }, + "ray-tune-1.4.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "pandas", + "python >=3.9,<3.10.0a0", + "ray-core 1.4.0 py39h295c915_1", + "tabulate", + "tensorboardx" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ec76449bc100105001905fb711bdb9e4", + "name": "ray-tune", + "sha256": "ccf6797333ddf5a76c1726d7ab9f190405c375c9faf8c5f7b5d044b9ea8200de", + "size": 41866, + "subdir": "linux-64", + "timestamp": 1627061827351, + "version": "1.4.0" + }, + "ray-tune-1.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pandas", + "python >=3.7,<3.8.0a0", + "ray-core 1.6.0 py37h295c915_0", + "requests", + "tabulate", + "tensorboardx >=1.9" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "47a5df7de17b2a5b79429770b4ac150a", + "name": "ray-tune", + "sha256": "544445c66535f28958f6fc2dfb8ec115a9d9f736b0c3ca164729b1cb639e8616", + "size": 44415, + "subdir": "linux-64", + "timestamp": 1640798779581, + "version": "1.6.0" + }, + "ray-tune-1.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pandas", + "python >=3.8,<3.9.0a0", + "ray-core 1.6.0 py38h295c915_0", + "requests", + "tabulate", + "tensorboardx >=1.9" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "62968c9ca28ceeef7e1df6111c33563b", + "name": "ray-tune", + "sha256": "a370afad2a2a22502516f9473a0b17eac899759ba05c18f738c335e9575a8b56", + "size": 44401, + "subdir": "linux-64", + "timestamp": 1640798792336, + "version": "1.6.0" + }, + "ray-tune-1.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pandas", + "python >=3.9,<3.10.0a0", + "ray-core 1.6.0 py39h295c915_0", + "requests", + "tabulate", + "tensorboardx >=1.9" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "901f0d3e36861eacf836a1fb0c5054e0", + "name": "ray-tune", + "sha256": "c74148228f6bae7457e62a24291f6813265fbe8643fc0a660e67f1ab4c64225c", + "size": 44382, + "subdir": "linux-64", + "timestamp": 1640798786062, + "version": "1.6.0" + }, + "ray-tune-2.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pandas", + "python >=3.10,<3.11.0a0", + "ray-default 2.3.0 py310h06a4308_0", + "requests", + "tabulate", + "tensorboardx >=1.9" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "87993dc44ea77a1792f088d263299c92", + "name": "ray-tune", + "sha256": "5a4bfef7ee0f8f363e23839e221606f8f85b8f3d998b68a2e846a6f84a36bd41", + "size": 37072, + "subdir": "linux-64", + "timestamp": 1678437650539, + "version": "2.3.0" + }, + "ray-tune-2.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pandas", + "python >=3.8,<3.9.0a0", + "ray-default 2.3.0 py38h06a4308_0", + "requests", + "tabulate", + "tensorboardx >=1.9" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ac8684ba83d11080b1eb8b3298310e57", + "name": "ray-tune", + "sha256": "10ff236291b6f2f46eafbe7a9d3657c84be2eb91ba564091dc3769b373391866", + "size": 37044, + "subdir": "linux-64", + "timestamp": 1678432441380, + "version": "2.3.0" + }, + "ray-tune-2.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pandas", + "python >=3.9,<3.10.0a0", + "ray-default 2.3.0 py39h06a4308_0", + "requests", + "tabulate", + "tensorboardx >=1.9" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cf4c93ed73bfe1e79ab61c68deb6a7c2", + "name": "ray-tune", + "sha256": "2b893e438b7b216d25075094cfb8ca5ef4f291a60260594a9094cc2824b6a0f9", + "size": 37060, + "subdir": "linux-64", + "timestamp": 1678435074866, + "version": "2.3.0" + }, + "rbc-0.5.1-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "llvmlite >=0.29", + "netifaces", + "numba", + "python >=3.10,<3.11.0a0", + "six", + "tblib", + "thriftpy2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "56516ed451ab78532c070453bf8e1ca1", + "name": "rbc", + "sha256": "a610eb2ad2ea45f7d471f8e2dec7a3bd36fba9907fbf73e29bdd9642d4d2ca6e", + "size": 217074, + "subdir": "linux-64", + "timestamp": 1642514675945, + "version": "0.5.1" + }, + "rbc-0.5.1-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "llvmlite >=0.29", + "netifaces", + "numba", + "python >=3.6,<3.7.0a0", + "six", + "tblib", + "thriftpy2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c143a04320fec96c6ea729f201781746", + "name": "rbc", + "sha256": "c130df12a21ff1c53a4f66635fb1fe142c1faa9064f32d31b3f5f1c71b434fa8", + "size": 219820, + "subdir": "linux-64", + "timestamp": 1622236063043, + "version": "0.5.1" + }, + "rbc-0.5.1-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "llvmlite >=0.29", + "netifaces", + "numba", + "python >=3.7,<3.8.0a0", + "six", + "tblib", + "thriftpy2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aa3bb48468622ce69ad890885c43267e", + "name": "rbc", + "sha256": "58015db258e2978a1587f998f115b7ef72329013ecd5a745288c751b7f9128ad", + "size": 220579, + "subdir": "linux-64", + "timestamp": 1622235581483, + "version": "0.5.1" + }, + "rbc-0.5.1-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "llvmlite >=0.29", + "netifaces", + "numba", + "python >=3.8,<3.9.0a0", + "six", + "tblib", + "thriftpy2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a1e59b17355f0a117ca7891dc04d4deb", + "name": "rbc", + "sha256": "3d406228e3a5c40239b907cd04ef1b71867b5fccae630e160534bfa1f3e953e6", + "size": 217598, + "subdir": "linux-64", + "timestamp": 1622236063280, + "version": "0.5.1" + }, + "rbc-0.5.1-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "llvmlite >=0.29", + "netifaces", + "numba", + "python >=3.9,<3.10.0a0", + "six", + "tblib", + "thriftpy2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88df95d9f07ce76d2615328af53389bc", + "name": "rbc", + "sha256": "6d3f968233f52472bc8e97b484418c8de7d89cdcf9ae668386319cff9ae0d92b", + "size": 218467, + "subdir": "linux-64", + "timestamp": 1622231011140, + "version": "0.5.1" + }, + "re2-2019.08.01-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-clause", + "md5": "9fd30b4067fed751c87fe59f1010b842", + "name": "re2", + "sha256": "eda8909053281e426b97a098e6c47440ffec4453ac49db2abb79d5fa4a00b563", + "size": 628099, + "subdir": "linux-64", + "timestamp": 1567108263232, + "version": "2019.08.01" + }, + "re2-2020.11.01-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "md5": "2099e89eaa5379491bef2e9b2b76efaa", + "name": "re2", + "sha256": "4127439070a5d48d31b9dc1132c6894b06f1ff1e513694731d00dc729d5e6e56", + "size": 235364, + "subdir": "linux-64", + "timestamp": 1607097668203, + "version": "2020.11.01" + }, + "re2-2020.11.01-h2531618_1.tar.bz2": { + "build": "h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "md5": "ae7dfe7be4ab8f63dea6ba462a05f50d", + "name": "re2", + "sha256": "d2344dd7273a43f325019233f7c26c1be249c0790b19a235b35d60bd48d66ded", + "size": 469926, + "subdir": "linux-64", + "timestamp": 1607099328471, + "version": "2020.11.01" + }, + "re2-2022.04.01-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "md5": "6b583dce61c6feb352ef0f49f413af1e", + "name": "re2", + "sha256": "8a640736bef635346409582dbfe2b7d0ecc9da215c90173ff8a9a5fe22569107", + "size": 235004, + "subdir": "linux-64", + "timestamp": 1652449537852, + "version": "2022.04.01" + }, + "readline-7.0-h7b6447c_5.tar.bz2": { + "build": "h7b6447c_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "ncurses >=6.1,<7.0a0" + ], + "license": "GPL-3.0", + "md5": "44547de0c0be291132a3fdd18829f5ff", + "name": "readline", + "sha256": "00e9e135a450f39076aca5f40034643facf413b80cccebc1761839cde4d44643", + "size": 401325, + "subdir": "linux-64", + "timestamp": 1535475436442, + "version": "7.0" + }, + "readline-7.0-ha6073c6_4.tar.bz2": { + "build": "ha6073c6_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "ncurses >=6.0,<7.0a0" + ], + "license": "GPL3", + "md5": "88397c662965f318626bb586915f5c95", + "name": "readline", + "sha256": "96bd8a72e6ae3b49c6953423fefd3bbe083f2d5d46a890d22bebae5e731b34ec", + "size": 1142746, + "subdir": "linux-64", + "timestamp": 1510351119846, + "version": "7.0" + }, + "readline-7.0-hac23ff0_3.tar.bz2": { + "build": "hac23ff0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "ncurses 6.0*" + ], + "license": "GPL3", + "md5": "88d1133eeb5d34b66cb16af373db0c46", + "name": "readline", + "sha256": "bd6716701b6ef1f642851a19fee59494bcf831a3074d3b1d44f987f82a1e866e", + "size": 396360, + "subdir": "linux-64", + "timestamp": 1505667005716, + "version": "7.0" + }, + "readline-7.0-hb321a52_4.tar.bz2": { + "build": "hb321a52_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL3", + "md5": "6bfa6a9074d876c64fe865766010bafe", + "name": "readline", + "sha256": "29deb692e04b3f343cdbb475a416079f2aa88a9b69f69f035289d2d0dbb0247b", + "size": 397567, + "subdir": "linux-64", + "timestamp": 1510178605778, + "version": "7.0" + }, + "readline-8.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ncurses >=6.1,<7.0a0" + ], + "license": "GPL-3.0", + "md5": "724f71ddc8b5a95db3d97023c788959f", + "name": "readline", + "sha256": "edd7a4575a9ed6d1a606821e3ca686edf9dd06c159e1f1d85131ebc4df66e1ed", + "size": 437901, + "subdir": "linux-64", + "timestamp": 1581612239956, + "version": "8.0" + }, + "readline-8.1-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0" + ], + "license": "GPL-3.0", + "md5": "b3a5e0e61af068595cfd411db9960e1f", + "name": "readline", + "sha256": "fa1a041badf4beeba06f51b17a3214a5509015eef4daf1925d01c207f6b00ca7", + "size": 475570, + "subdir": "linux-64", + "timestamp": 1611868595060, + "version": "8.1" + }, + "readline-8.1.2-h7f8727e_1.tar.bz2": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "ncurses >=6.3,<7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "150ac0eb929bab9dec912797bdfc7b95", + "name": "readline", + "sha256": "8c950c69bee969e2c66f88f0dc247b3ab75a753672a88009779d5f5dba193532", + "size": 433182, + "subdir": "linux-64", + "timestamp": 1642022402894, + "version": "8.1.2" + }, + "readline-8.2-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "960bf00d81e7bbdeff2c7d01ed78eaeb", + "name": "readline", + "sha256": "8a665f0160013939ee6b0c048d4d8f034b6d6feb7feec6844994322b7aaaa6e4", + "size": 467661, + "subdir": "linux-64", + "timestamp": 1666648052561, + "version": "8.2" + }, + "readme_renderer-22.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "1a2b852ce34fc12b5b6cfa6c85b1445d", + "name": "readme_renderer", + "sha256": "fe5592af7297f845e2b254ed60d60fb55e7f5f00f1e9f561f361c0d02ba11ab5", + "size": 19224, + "subdir": "linux-64", + "timestamp": 1539901660758, + "version": "22.0" + }, + "readme_renderer-22.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "20450c2a6f948ba2a54fbac7dc58ed08", + "name": "readme_renderer", + "sha256": "498d42a90af40638d6b2e2643b92e7a336de8c103c60f2ce32af5a2c45bf5192", + "size": 19296, + "subdir": "linux-64", + "timestamp": 1539901680431, + "version": "22.0" + }, + "readme_renderer-22.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "15b74e60589d49d76bb37cab74115ec0", + "name": "readme_renderer", + "sha256": "c29ab56d597db7647bd3cc856d4317f053b14090cf584c70c08de86b93348e0b", + "size": 19326, + "subdir": "linux-64", + "timestamp": 1539901692185, + "version": "22.0" + }, + "readme_renderer-24.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "ce4ab974907ce0cf993340bdba988f72", + "name": "readme_renderer", + "sha256": "d34946034e53a3689b0754f3731fc33c6285165a70b678e8239e086805d51f13", + "size": 20228, + "subdir": "linux-64", + "timestamp": 1541044403627, + "version": "24.0" + }, + "readme_renderer-24.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.10,<3.11.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "2b6e6f30d68bfb91225ad3fa62acaec5", + "name": "readme_renderer", + "sha256": "a6190ceb4947b062aac3fb310a52753315c493dc86680a6448337e4844ec73ad", + "size": 20698, + "subdir": "linux-64", + "timestamp": 1640812834904, + "version": "24.0" + }, + "readme_renderer-24.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.11,<3.12.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "ab561ab29f5250caa7541bc1c05afab2", + "name": "readme_renderer", + "sha256": "c04456c7fe722d17e2fddded3d7b1dae4e9dd707d73d636e33a969086564d570", + "size": 23444, + "subdir": "linux-64", + "timestamp": 1676903944285, + "version": "24.0" + }, + "readme_renderer-24.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "b9712781abeba2be2c126fecb1177c86", + "name": "readme_renderer", + "sha256": "666c8f90ed3cfc7b4d60c078631e2d1556655e707ad4a1e4ec5de27c6cbd6561", + "size": 20352, + "subdir": "linux-64", + "timestamp": 1541044438399, + "version": "24.0" + }, + "readme_renderer-24.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "d8fa9e21070ec7f01b3c3572925d2602", + "name": "readme_renderer", + "sha256": "599f5a88eff078e1f8836ce393b343a0f9f5dee259cf8a925b4e9833ddeb313f", + "size": 240362, + "subdir": "linux-64", + "timestamp": 1613501455737, + "version": "24.0" + }, + "readme_renderer-24.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "25c61fd8a8fc1144dab7ce7ea81647cd", + "name": "readme_renderer", + "sha256": "7cf828f3d90a37a8ce6555ac3e3b64f88880fc5e4bed0b4e6c6ce5a61ada005b", + "size": 20351, + "subdir": "linux-64", + "timestamp": 1541044400577, + "version": "24.0" + }, + "readme_renderer-24.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "d7d7b6c786bf84f769f7628ce32aee73", + "name": "readme_renderer", + "sha256": "003a293dc8dfce01c78ee6d2abe20acc38b9523b70102d0f1030b43b196723d8", + "size": 239314, + "subdir": "linux-64", + "timestamp": 1613502086975, + "version": "24.0" + }, + "readme_renderer-24.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "a6367c612e63339c6e17d3506bcbe849", + "name": "readme_renderer", + "sha256": "48e73b6917cb496bd769eb67831d8ab5664ce250251d515291c9513799628e5c", + "size": 20736, + "subdir": "linux-64", + "timestamp": 1574169864533, + "version": "24.0" + }, + "readme_renderer-24.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "1745c65beffc62af40e00cbb4b20d339", + "name": "readme_renderer", + "sha256": "551ff3f02d0bb558aef418bfeeb37221d0a3c5d664c1070b3387d42467ad8e1e", + "size": 238886, + "subdir": "linux-64", + "timestamp": 1613502095130, + "version": "24.0" + }, + "readme_renderer-24.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "cb08665c3473607b78d45288eced571f", + "name": "readme_renderer", + "sha256": "48925dc11ab5a188d0af8f6396c356d2efe0430fee7880b25b3b60737cdd946a", + "size": 238885, + "subdir": "linux-64", + "timestamp": 1613502484904, + "version": "24.0" + }, + "redis-4.0.10-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "e1a91bddeb1bef7dcb343eed7ef435dd", + "name": "redis", + "sha256": "242629eab922ac7c7b7a4f6a74b7a71492bbd04b3d2830f60b9be669691aed20", + "size": 7610686, + "subdir": "linux-64", + "timestamp": 1529963725548, + "version": "4.0.10" + }, + "redis-4.0.11-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "4437be9151c6aba32a3243411c04d6e5", + "name": "redis", + "sha256": "16ef5592683f6b34ea7a301e732de510ac0ccc5228907861bb775047fe69b31d", + "size": 7614773, + "subdir": "linux-64", + "timestamp": 1534830079345, + "version": "4.0.11" + }, + "redis-4.0.2-h6805cf8_0.tar.bz2": { + "build": "h6805cf8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "d2e7be5e57741cfd33773d26d9304ee8", + "name": "redis", + "sha256": "0a50aded0cb936799c72447881438eed4cca33da64425c5205ab5634ad695786", + "size": 7530562, + "subdir": "linux-64", + "timestamp": 1508783877827, + "version": "4.0.2" + }, + "redis-4.0.8-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "c4366ee40bc2d31ee90810a95d27303a", + "name": "redis", + "sha256": "848bca936472b04c71a14f61f7081093f7f5c9a542293d800b3d49227a30005b", + "size": 7592107, + "subdir": "linux-64", + "timestamp": 1520833693819, + "version": "4.0.8" + }, + "redis-4.0.9-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "7f4b0920b111dc2e1998918857ad8ace", + "name": "redis", + "sha256": "5ed3e26b4af04dca7751f246386a0a40d95888d818be500a8d692b5e3f3db63c", + "size": 7607156, + "subdir": "linux-64", + "timestamp": 1524133004440, + "version": "4.0.9" + }, + "redis-5.0.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "3dfca419c9273bbe3aaef1b02b09ce13", + "name": "redis", + "sha256": "69c5919e607b57385d0a88d5649f8e6fee692d905da30eada9ebbc406ba67a2b", + "size": 10677642, + "subdir": "linux-64", + "timestamp": 1540449545000, + "version": "5.0.0" + }, + "redis-5.0.3-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "2b1400c22e13d54e87d4c0f8555de4e9", + "name": "redis", + "sha256": "955789e93e38e3c9fbfb23e761217dbafc7d6411d7b4bd4a39d1fc7a52e30a3e", + "size": 11124140, + "subdir": "linux-64", + "timestamp": 1548291499252, + "version": "5.0.3" + }, + "redis-py-2.10.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a98ad73a7effc1cfd79e039a3433d9d8", + "name": "redis-py", + "sha256": "4aa837589e5986f011da159d92e3853d3c107d53fa9bac91276c377cbfb57805", + "size": 83829, + "subdir": "linux-64", + "timestamp": 1530959167902, + "version": "2.10.6" + }, + "redis-py-2.10.6-py27hd31c425_0.tar.bz2": { + "build": "py27hd31c425_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83e55035d9e552ab881d38e23e37d0b0", + "name": "redis-py", + "sha256": "175b9d4c9ee2e0079c1c309f7075bf7e1ad7d08e161979e5a1ef1778ca38dd48", + "size": 84149, + "subdir": "linux-64", + "timestamp": 1508916824759, + "version": "2.10.6" + }, + "redis-py-2.10.6-py35h242a0b0_0.tar.bz2": { + "build": "py35h242a0b0_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb4102c5c6f8b1dd3d8c08e30b1a125b", + "name": "redis-py", + "sha256": "c4ae3b912ee7797af69f14df2fec55180efc823e9ee9301b99eb5000cf8da108", + "size": 86659, + "subdir": "linux-64", + "timestamp": 1508916823878, + "version": "2.10.6" + }, + "redis-py-2.10.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8b9ea682e42c569106dfbcf3e3101ad2", + "name": "redis-py", + "sha256": "e3ca1913e5c598c03fea9aa12f0d074f3b24a5389cc867ea431eb04c32deaac0", + "size": 86391, + "subdir": "linux-64", + "timestamp": 1530959199213, + "version": "2.10.6" + }, + "redis-py-2.10.6-py36hf9ffb6b_0.tar.bz2": { + "build": "py36hf9ffb6b_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4175bf7642160ee6aee2e114b737a4b2", + "name": "redis-py", + "sha256": "c40637d2dfd8d1d0cc9b3dd5748af0fc7284c5e9a649d30ae9037124667d86ea", + "size": 86612, + "subdir": "linux-64", + "timestamp": 1508916843153, + "version": "2.10.6" + }, + "redis-py-2.10.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b0b2355175020bcc5bf54bd5a69afc2", + "name": "redis-py", + "sha256": "d5bb679e1a6f6d433a42c78c893be156d5e8318cfaa63cbfec11a2de14e2e3f7", + "size": 86366, + "subdir": "linux-64", + "timestamp": 1530959230537, + "version": "2.10.6" + }, + "redis-py-3.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f52e136d1c4d51505d63b4393c28fa52", + "name": "redis-py", + "sha256": "7d21d917f025ec07b723de9cdf101e452cda3c0090418b5194d4efb64600ce4d", + "size": 94399, + "subdir": "linux-64", + "timestamp": 1542392415414, + "version": "3.0.0" + }, + "redis-py-3.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "afd4c0ee0725e777621c6a1372042f73", + "name": "redis-py", + "sha256": "eba3f695bee6cebef6ace79b1075ff3ce93403c05ee070f22a119feea3baa41a", + "size": 97073, + "subdir": "linux-64", + "timestamp": 1542392421799, + "version": "3.0.0" + }, + "redis-py-3.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a9571a25b6703f3c8efec458d014b2f4", + "name": "redis-py", + "sha256": "e8de0d02d881866b13b633da3a0a1a777baf44950a1cef971f3bdd1049e11a49", + "size": 96959, + "subdir": "linux-64", + "timestamp": 1542392410217, + "version": "3.0.0" + }, + "redis-py-3.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f00515e171e356275209d45be10ab053", + "name": "redis-py", + "sha256": "4f8ea3e1f1587339faae8e3ae848decaaaab6e6c6472b82d86e35772f694bf98", + "size": 94435, + "subdir": "linux-64", + "timestamp": 1545097498750, + "version": "3.0.1" + }, + "redis-py-3.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc0abb08af7a843d8eb32bb4a4bca468", + "name": "redis-py", + "sha256": "4863a63255b354a31c59db4b06aa8bc43aff244724b380195527a2eb4448a0b7", + "size": 97105, + "subdir": "linux-64", + "timestamp": 1545097508274, + "version": "3.0.1" + }, + "redis-py-3.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "88ca1479599e624cfb573bd9483d73c9", + "name": "redis-py", + "sha256": "489fe6e772c3fb84dfe27008ad9e19bb9efceb8304f38d69d1360b549a082da2", + "size": 96916, + "subdir": "linux-64", + "timestamp": 1545097518706, + "version": "3.0.1" + }, + "redis-py-4.3.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=4.0.2", + "deprecated >=1.2.3", + "packaging >=20.4", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4bea37555e20cd3c239c7eb3ec68367", + "name": "redis-py", + "sha256": "1e6b828f4248c732da98729ce8376041436a1ec0db92bd61db242d921a61e281", + "size": 377602, + "subdir": "linux-64", + "timestamp": 1664990713733, + "version": "4.3.4" + }, + "redis-py-4.3.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=4.0.2", + "deprecated >=1.2.3", + "packaging >=20.4", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f213ffb699116c83c1b646225a19c3a6", + "name": "redis-py", + "sha256": "8e0ca2932bcb34925d8db102899f6a3631c9d9b0f7f0a5891609aea41ac9f28e", + "size": 485977, + "subdir": "linux-64", + "timestamp": 1676861810092, + "version": "4.3.4" + }, + "redis-py-4.3.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=4.0.2", + "deprecated >=1.2.3", + "importlib-metadata >=1.0", + "packaging >=20.4", + "python >=3.7,<3.8.0a0", + "typing-extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "122db22ccaa3b615cb1922f025624667", + "name": "redis-py", + "sha256": "632bdda87ec8625883b9194e1f903a55922069a1e0586689e6e9fd8ef65f6504", + "size": 369130, + "subdir": "linux-64", + "timestamp": 1664990769067, + "version": "4.3.4" + }, + "redis-py-4.3.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=4.0.2", + "deprecated >=1.2.3", + "packaging >=20.4", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b881e8d72d23015a6074d81f4a943ab", + "name": "redis-py", + "sha256": "bbbb7b53e42212f87d0b2596b097cb2e0ce0cea2bdd29af5e756987fbee58560", + "size": 372537, + "subdir": "linux-64", + "timestamp": 1664990673380, + "version": "4.3.4" + }, + "redis-py-4.3.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=4.0.2", + "deprecated >=1.2.3", + "packaging >=20.4", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9bab9ca6ff11a9fe97776649c87825f2", + "name": "redis-py", + "sha256": "bd9d120d74ac5f3ac6a674039083773b913e244d87c3253c5cd58b117b1ddefa", + "size": 372417, + "subdir": "linux-64", + "timestamp": 1664990742698, + "version": "4.3.4" + }, + "regex-2017.09.23-py27hecd67f1_0.tar.bz2": { + "build": "py27hecd67f1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "md5": "9676019d866f76a0237b35ba2fc3432d", + "name": "regex", + "sha256": "742bb06921ea0b8bc3edfc5c046c3955253e5acd3782e6bb71668be00c68d9a2", + "size": 330723, + "subdir": "linux-64", + "timestamp": 1508444399710, + "version": "2017.09.23" + }, + "regex-2017.09.23-py35hb1b125d_0.tar.bz2": { + "build": "py35hb1b125d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "md5": "a5696babdbd607768cde1474d66f0f15", + "name": "regex", + "sha256": "48a9070a32c8721123249c263e7626111622c14efd77ab86e4c0d3f5b9826fda", + "size": 344295, + "subdir": "linux-64", + "timestamp": 1508444370613, + "version": "2017.09.23" + }, + "regex-2017.09.23-py36h2527052_0.tar.bz2": { + "build": "py36h2527052_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "md5": "6f74ba32d18a6737d9ce24afa805fcdb", + "name": "regex", + "sha256": "22595c9ffb911c7794c6848d022128f00e61d62df01a1d1fda2e63fe5c675b27", + "size": 343195, + "subdir": "linux-64", + "timestamp": 1508444394647, + "version": "2017.09.23" + }, + "regex-2017.11.09-py27h2a269fe_0.tar.bz2": { + "build": "py27h2a269fe_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "cb153f29428cea25a0b858afe4eeacb4", + "name": "regex", + "sha256": "7c2888d7627fd161dedefcf7919ba8ed67542a675567bafce7dac7bf429b41a5", + "size": 330114, + "subdir": "linux-64", + "timestamp": 1511320891351, + "version": "2017.11.09" + }, + "regex-2017.11.09-py35h982ee26_0.tar.bz2": { + "build": "py35h982ee26_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "9a87af9a87bdc8a62c7d4588192c8b57", + "name": "regex", + "sha256": "b49594cf3aeae3e8b7dd7972835e8e0300223db89c741e42f06ab151465ecac2", + "size": 343526, + "subdir": "linux-64", + "timestamp": 1511320847997, + "version": "2017.11.09" + }, + "regex-2017.11.09-py36had819a5_0.tar.bz2": { + "build": "py36had819a5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "60b3f43ba05504ff5ccd2d12bb7f1ce7", + "name": "regex", + "sha256": "d1dc9c03e6347306fa274c16f77f6aad3184972d417a2637ce49d9ccfd220c81", + "size": 342712, + "subdir": "linux-64", + "timestamp": 1511320916116, + "version": "2017.11.09" + }, + "regex-2018.02.21-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "f778e3a7acd57a34d396d3723d5beea1", + "name": "regex", + "sha256": "2805761716a730bb37677324219e83e7a700f088964f7025c6e113aae5a799f0", + "size": 334445, + "subdir": "linux-64", + "timestamp": 1519763915164, + "version": "2018.02.21" + }, + "regex-2018.02.21-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "66cd698d0f175192074294708369659b", + "name": "regex", + "sha256": "be8731f0741d34e5e2ab7cf3c506a9b75aa176cd90b90a9cb004e3719b36a8b1", + "size": 351666, + "subdir": "linux-64", + "timestamp": 1519763936359, + "version": "2018.02.21" + }, + "regex-2018.02.21-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "8d32f5c0cc1274b05db9b5275132a1b1", + "name": "regex", + "sha256": "7740d43ba008cf3912d413094330e483596599799d19429c8d22e9083fefb8c3", + "size": 348534, + "subdir": "linux-64", + "timestamp": 1519763898683, + "version": "2018.02.21" + }, + "regex-2018.06.09-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "1fb26817f26f90bc7883599b17fa4977", + "name": "regex", + "sha256": "1a4070dcb259cd143a72d07274e49717f8525c0d0e1f7562a97e5b8160d2ca38", + "size": 338495, + "subdir": "linux-64", + "timestamp": 1528984042318, + "version": "2018.06.09" + }, + "regex-2018.06.09-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "35d213a0523066cfe4f7324afff8718d", + "name": "regex", + "sha256": "d17e16c1d0ff9a7da6bb0a4c422259e015e0759de4a965930e86cd0fc480fa5b", + "size": 355078, + "subdir": "linux-64", + "timestamp": 1528984118763, + "version": "2018.06.09" + }, + "regex-2018.06.09-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "b9995a937f71ddb4f07841beb51a935b", + "name": "regex", + "sha256": "732c3fa576804d344a5cea727c89ada4641fcb804b989d0916cba391bcdc0325", + "size": 352615, + "subdir": "linux-64", + "timestamp": 1528984052910, + "version": "2018.06.09" + }, + "regex-2018.06.21-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "9f24e94fa127f19e648561de6cc529ef", + "name": "regex", + "sha256": "e23185a55d6557434e1df23f6f9b533edf1c61c7976a253773410f26d029d433", + "size": 338553, + "subdir": "linux-64", + "timestamp": 1529950239747, + "version": "2018.06.21" + }, + "regex-2018.06.21-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "b12672bf8cf0a3983e62710d0a55e49d", + "name": "regex", + "sha256": "4e7297585d9cb3cd1b14f677c733008467168b77be0e8cd2381e5656f71e0ddc", + "size": 355654, + "subdir": "linux-64", + "timestamp": 1529950290787, + "version": "2018.06.21" + }, + "regex-2018.06.21-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "f06ffa1905f6ce8f173fdc3d197869f9", + "name": "regex", + "sha256": "50c791fb24bff2a1ceb1e0882eb9c73787368afeb26139d0edd1afc5b44d8b59", + "size": 352727, + "subdir": "linux-64", + "timestamp": 1529950194253, + "version": "2018.06.21" + }, + "regex-2018.06.21-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "bef57a09013f137e122241338d68133d", + "name": "regex", + "sha256": "5c8def7dd04b64fb259b81b068db2ff4cd9cd075be704dd72abe573c5e4a34c3", + "size": 352317, + "subdir": "linux-64", + "timestamp": 1530959277771, + "version": "2018.06.21" + }, + "regex-2018.07.11-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "7fb8e980848b39f6b7df450b21c1f98e", + "name": "regex", + "sha256": "2870e10615351606878a8e3adf5742aace84f95426b29536c561c29e75c927e5", + "size": 337320, + "subdir": "linux-64", + "timestamp": 1532628151310, + "version": "2018.07.11" + }, + "regex-2018.07.11-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "53e868a3aa03dbb5ced411c18c3d1856", + "name": "regex", + "sha256": "4b03078d56e51a93645b609eb32d0dd89a9485f0e326fa2665a41b71501e6adb", + "size": 353273, + "subdir": "linux-64", + "timestamp": 1532628126017, + "version": "2018.07.11" + }, + "regex-2018.07.11-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "a723eb0258603e5aa00b69b37162dcd5", + "name": "regex", + "sha256": "2f65737f5891aad759ec64541e576a04d093f47478eb1cddfef1397f7987ea7b", + "size": 351953, + "subdir": "linux-64", + "timestamp": 1532628099551, + "version": "2018.07.11" + }, + "regex-2018.07.11-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "7636b9a3a3ff8dd750b7709ff1637331", + "name": "regex", + "sha256": "93495b75362bb242a8ca0abd380f5881f5c7313e7d4f25c3db274d9919177096", + "size": 352701, + "subdir": "linux-64", + "timestamp": 1532628145168, + "version": "2018.07.11" + }, + "regex-2018.08.17-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "c6e645aea5462cdc4cd444a4f616f904", + "name": "regex", + "sha256": "a49c8a6e38b8d12fdfc24bb13806e680a6014f8b07f9b25712627fd3dcee8a64", + "size": 344104, + "subdir": "linux-64", + "timestamp": 1535431420606, + "version": "2018.08.17" + }, + "regex-2018.08.17-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "62327e7c87ed2f82ad10146abbfbfb06", + "name": "regex", + "sha256": "7738856050bbc707924a4403d61ead891cd3e3ca56dc37ca4d34fa7ea9b95a4b", + "size": 359181, + "subdir": "linux-64", + "timestamp": 1535431579261, + "version": "2018.08.17" + }, + "regex-2018.08.17-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "f30ec41071ed9d315f569405f7c30373", + "name": "regex", + "sha256": "9bb80a7eae85c5e3edde4506571ffce22569e0cfae8381b5a87601d1482bf6c1", + "size": 355923, + "subdir": "linux-64", + "timestamp": 1535431503446, + "version": "2018.08.17" + }, + "regex-2018.08.17-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "8a26f2fa81b0920de1f15ee6b7c05d2e", + "name": "regex", + "sha256": "600fa1a7554f8bef2bee3f70fff471dc57ac1933465c4d94b5bd6b7ea1f09f99", + "size": 355561, + "subdir": "linux-64", + "timestamp": 1535431538667, + "version": "2018.08.17" + }, + "regex-2018.08.29-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "f1ba3292092b3831516fc2b7baa9788c", + "name": "regex", + "sha256": "8e757f4e7fc215973e4e8c1f755dd48b74320ee45604c6578b9c59b710729ea4", + "size": 344476, + "subdir": "linux-64", + "timestamp": 1537471001688, + "version": "2018.08.29" + }, + "regex-2018.08.29-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "c2562ce6af2d5a844877ca66be99a921", + "name": "regex", + "sha256": "3a07cf09afde72ed8a5526dcf41c46f28477c0b557d59e62adf0d73cf560b27e", + "size": 359616, + "subdir": "linux-64", + "timestamp": 1537471043906, + "version": "2018.08.29" + }, + "regex-2018.08.29-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "a3d2922dbb30337cc3ecf3d5ea32abda", + "name": "regex", + "sha256": "ccbe619955d64db5b96d9a1399a329380736afc01ec8a5fe8053fade39934db8", + "size": 356343, + "subdir": "linux-64", + "timestamp": 1537471001134, + "version": "2018.08.29" + }, + "regex-2018.08.29-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "e986af42f5c3f099370bf3bfdf89a1b1", + "name": "regex", + "sha256": "e9e0d5d54ea3b80879c45152f36113e659bf406ba9114f7608061528ffbf15f5", + "size": 355955, + "subdir": "linux-64", + "timestamp": 1537470986100, + "version": "2018.08.29" + }, + "regex-2018.11.02-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "248ce5891b1f3b965724399e8551702b", + "name": "regex", + "sha256": "1cd783df585e6408d23acd0d6b061e29e37dbfa12aec597d70601a7763a23b43", + "size": 345213, + "subdir": "linux-64", + "timestamp": 1541176233945, + "version": "2018.11.02" + }, + "regex-2018.11.02-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "153a2f122290d9bc0809a033d29e046f", + "name": "regex", + "sha256": "c601c013be7fe9de3eb05d48dcef5d1684143ac150cf29fe1626a3b81d0526b4", + "size": 365766, + "subdir": "linux-64", + "timestamp": 1541176255214, + "version": "2018.11.02" + }, + "regex-2018.11.02-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "cbef66a542420a4a1756c8a8d01c98e4", + "name": "regex", + "sha256": "75eba39cd410b6ae951ecaa81d03be59f89b612f5c2fa2091379d8a9580edef9", + "size": 369508, + "subdir": "linux-64", + "timestamp": 1541176164692, + "version": "2018.11.02" + }, + "regex-2018.11.07-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "80facc4a2c2815e2e58002fa73ed54bf", + "name": "regex", + "sha256": "c966f01b72ffa0cad5c52e8a3e1620e34a5b907a435698e222535af895ca0526", + "size": 357974, + "subdir": "linux-64", + "timestamp": 1542088505453, + "version": "2018.11.07" + }, + "regex-2018.11.07-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "45eede026cd6d240ea1c70d1fcbc3d88", + "name": "regex", + "sha256": "2019ee12c61d2c7c6759d2ec8654a28c6d248d2859f748799bdc8fb2be7e1601", + "size": 367018, + "subdir": "linux-64", + "timestamp": 1542088497265, + "version": "2018.11.07" + }, + "regex-2018.11.07-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "02ecc4c8fb3c93603dadfa73bed60e03", + "name": "regex", + "sha256": "88ea302db8eec563b77563652a5e6a97c64d811495cd9b72731a3eebcb21b721", + "size": 370925, + "subdir": "linux-64", + "timestamp": 1542088488381, + "version": "2018.11.07" + }, + "regex-2018.11.22-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "b20ccf61fff8f1f30d4a705de6453fc0", + "name": "regex", + "sha256": "5f61e9f3e7b10cf262fe4f3f9c3ae4215f01808f9139815e165d02e90f1cac27", + "size": 356255, + "subdir": "linux-64", + "timestamp": 1545098547644, + "version": "2018.11.22" + }, + "regex-2018.11.22-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "e1a7e279f12ab50b0348d63d83210a65", + "name": "regex", + "sha256": "eafac8e7f43bf39264dced998cd5839d53c825863bf2cf2e35fb34b03959fce8", + "size": 372267, + "subdir": "linux-64", + "timestamp": 1545098565609, + "version": "2018.11.22" + }, + "regex-2018.11.22-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "da749d3af5a8dbf74c24c59436c98cfd", + "name": "regex", + "sha256": "8e01e78740f746a0e00e27a965a726c55e1899f1c9aca4ae2bbcaeb77594ed2f", + "size": 358480, + "subdir": "linux-64", + "timestamp": 1545098541750, + "version": "2018.11.22" + }, + "regex-2019.03.09-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "0b51c255ef50ffbf84eb006c47235882", + "name": "regex", + "sha256": "04edfa0f85a972a69bb8d54bbd00b07c1c45ce7aee1a4aa66454f294057828de", + "size": 357115, + "subdir": "linux-64", + "timestamp": 1552369253825, + "version": "2019.03.09" + }, + "regex-2019.03.09-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "3915653f02f53b317b62885302ca49a2", + "name": "regex", + "sha256": "85a1139964725aa5fbb704572dd7cbb6c2b01d6ea5920dc7939abc5eebe6412e", + "size": 379947, + "subdir": "linux-64", + "timestamp": 1552369327293, + "version": "2019.03.09" + }, + "regex-2019.03.09-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "ea31b86a4089c18de189f2e203e0b49b", + "name": "regex", + "sha256": "6266c124714a0af753944cb143ac19bf5a55fcd66a244a35bcee3830330ce477", + "size": 381042, + "subdir": "linux-64", + "timestamp": 1552369286636, + "version": "2019.03.09" + }, + "regex-2019.04.14-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "352557413f3fa80c4da8c752abce8c25", + "name": "regex", + "sha256": "5b6b68782684448b0e4727efc5a7fa28a873ab3524094e0fd3762af4f3b8a256", + "size": 367028, + "subdir": "linux-64", + "timestamp": 1556073868659, + "version": "2019.04.14" + }, + "regex-2019.04.14-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "86005d11bc51903126e4729d8c537f5b", + "name": "regex", + "sha256": "c6d5cf653d0609222f81ae8bc382bcf0c646734edd17df2d55a6461c0182614c", + "size": 372691, + "subdir": "linux-64", + "timestamp": 1556073902322, + "version": "2019.04.14" + }, + "regex-2019.04.14-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "5f211a3bbdcb4f06f4f163e9fcfd849f", + "name": "regex", + "sha256": "b797c32377032d74f0f03103ec198dcab020172a48d2f1c2c987e5f2725bbbaf", + "size": 381168, + "subdir": "linux-64", + "timestamp": 1556073861244, + "version": "2019.04.14" + }, + "regex-2019.06.05-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "8d4d368f16f651f4784c26f9fbf63476", + "name": "regex", + "sha256": "184fa08b8e8389bef3cb0454ef79d2d41104bf319a3dc25cd6e171b49ff38700", + "size": 361192, + "subdir": "linux-64", + "timestamp": 1559923666783, + "version": "2019.06.05" + }, + "regex-2019.06.05-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "1b75032affc13ae009805d55e6da4207", + "name": "regex", + "sha256": "04b1ac54118283589d57a3c2b8a91bef398c73deac504c05f82bc7e467ccb7af", + "size": 380034, + "subdir": "linux-64", + "timestamp": 1559923666305, + "version": "2019.06.05" + }, + "regex-2019.06.05-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "dec5ee709e69c2e4f267ba54b94857cf", + "name": "regex", + "sha256": "b9498b1a86d421584799e435b5af1c7fff7a199f828df2b5cd25c0ef304359cf", + "size": 375706, + "subdir": "linux-64", + "timestamp": 1559923649516, + "version": "2019.06.05" + }, + "regex-2019.08.19-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "5f97dfbd63b1f8d9e5635f2fc206504a", + "name": "regex", + "sha256": "75d088d7389349974b15a72216f384551cc44e4214c900f4228a3111c6105927", + "size": 372862, + "subdir": "linux-64", + "timestamp": 1569350637837, + "version": "2019.08.19" + }, + "regex-2019.08.19-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "7338be6dd37f42110bc8c18af75a3508", + "name": "regex", + "sha256": "ef9acb4d541d3897bc7459d17f100af0ef55163c9043c1477d3c60f28bd96501", + "size": 390292, + "subdir": "linux-64", + "timestamp": 1569350630733, + "version": "2019.08.19" + }, + "regex-2019.08.19-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "acaa67fe0fed84629eb8ad917c691860", + "name": "regex", + "sha256": "c38f1db8afd7e146ae07cdde14a05a4808d74591cd2012b4359dc47e507c5724", + "size": 386108, + "subdir": "linux-64", + "timestamp": 1569350652932, + "version": "2019.08.19" + }, + "regex-2019.08.19-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "7e577c078b85017fd4b668a3e77f121d", + "name": "regex", + "sha256": "9677b76bce9979d6325410adcc8f9e27ad8fa242e3cc7876cc05277ff13440c3", + "size": 380782, + "subdir": "linux-64", + "timestamp": 1573200568150, + "version": "2019.08.19" + }, + "regex-2019.11.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "dc31b436059d4d583569265ba66969a3", + "name": "regex", + "sha256": "a46ead30275461c2bf65b737fc44f23f4d9f89abcd007855db3f910cfc22750b", + "size": 371513, + "subdir": "linux-64", + "timestamp": 1573972588164, + "version": "2019.11.1" + }, + "regex-2019.11.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "1b57c340daea685ff79401e7b654842c", + "name": "regex", + "sha256": "54d465f489fd08a834fa8527078f3651a0f3c4c23030fb1cc21be802743ec444", + "size": 390294, + "subdir": "linux-64", + "timestamp": 1573972592905, + "version": "2019.11.1" + }, + "regex-2019.11.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "f65ecd8b1402f6f2736dc1210f2d8e35", + "name": "regex", + "sha256": "84609d5d987f59f5409854811cc6e73aab9f78ea12448e0fa57fe37eb71b05ec", + "size": 380416, + "subdir": "linux-64", + "timestamp": 1573972581617, + "version": "2019.11.1" + }, + "regex-2019.11.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "d83b2cc483b040598b17146f5ac86797", + "name": "regex", + "sha256": "59f724a6f69e7c50868335d95b2b8c0167e8c580f3f0659e22b6288e8035d0e0", + "size": 392398, + "subdir": "linux-64", + "timestamp": 1573972618287, + "version": "2019.11.1" + }, + "regex-2019.12.9-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "7052bc77a514337c398c210fa55a92ac", + "name": "regex", + "sha256": "fd2491d443eda3a9053117eb27071e182b9364a6248e246089d41fa115991d0c", + "size": 376033, + "subdir": "linux-64", + "timestamp": 1576541903699, + "version": "2019.12.9" + }, + "regex-2019.12.9-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "23f8dadda003282c768becd352e019d0", + "name": "regex", + "sha256": "45b5d5845261fa2ad931f4ec9b11743fe1e59cc7afeed529fd673679f95e639e", + "size": 391179, + "subdir": "linux-64", + "timestamp": 1576541907480, + "version": "2019.12.9" + }, + "regex-2019.12.9-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "4fa690c84a780689a149607f3a529aed", + "name": "regex", + "sha256": "47d21ceeb581e75aae53eef7ff4db783e0c9ec10e91ad589ec3d1332f4eaa13a", + "size": 390011, + "subdir": "linux-64", + "timestamp": 1576541899950, + "version": "2019.12.9" + }, + "regex-2019.12.9-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "583eb477f06614e7412f9579ca4d6780", + "name": "regex", + "sha256": "221caf1fad4e5ef2bfec2de823f4a2228f2395722a6380d1a4925cd8ad1dae80", + "size": 398725, + "subdir": "linux-64", + "timestamp": 1576541958299, + "version": "2019.12.9" + }, + "regex-2020.1.8-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "e080d3f1f74926e4a73f132c2767e55d", + "name": "regex", + "sha256": "49a28c7ed2a69e2f8ad039f106f0ec50ef3b0884de2a9e80f97937d6d556fc93", + "size": 391343, + "subdir": "linux-64", + "timestamp": 1581718133048, + "version": "2020.1.8" + }, + "regex-2020.1.8-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "793b69612cec698473f2ce76e436ecc1", + "name": "regex", + "sha256": "7f97da70ff5e43812bcc53a34e3964413d9b19dafcb9c3829e601cae371af40b", + "size": 380079, + "subdir": "linux-64", + "timestamp": 1581718140333, + "version": "2020.1.8" + }, + "regex-2020.1.8-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "5e8d6103084861a963a568ae16c0a49f", + "name": "regex", + "sha256": "025fb4d0862d623bfe95cbfe0c9d70e7f759339871e7e5c6c510bfb48b5a10eb", + "size": 392800, + "subdir": "linux-64", + "timestamp": 1581946164335, + "version": "2020.1.8" + }, + "regex-2020.10.11-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "e06ae1ac3a5f54360fb44772984b3170", + "name": "regex", + "sha256": "12caab9ff39bb02d41837445b02bb4ab30c2a15ad215250ce2b4c48b1d1e604e", + "size": 378632, + "subdir": "linux-64", + "timestamp": 1602685128110, + "version": "2020.10.11" + }, + "regex-2020.10.11-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "53229ca36c67f41b92fb0cb58305acbd", + "name": "regex", + "sha256": "0e22489b081cc7925affd76b0890a85d3c6b35800fbfc2562ff26e2ac0d6025c", + "size": 377452, + "subdir": "linux-64", + "timestamp": 1602685123993, + "version": "2020.10.11" + }, + "regex-2020.10.11-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "f069f46992655f00f9216a6eb0063db5", + "name": "regex", + "sha256": "fec8a435c2341088d23634a52eabcb0db10612d75a2effbe92cde7317b366fb4", + "size": 376027, + "subdir": "linux-64", + "timestamp": 1602685105657, + "version": "2020.10.11" + }, + "regex-2020.10.15-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "ff2338acbf36031f785e854fe594be10", + "name": "regex", + "sha256": "8d3c96a03ccc99afa1765917e7db9971cb09e7256cdfe76b65eee11416fa50a8", + "size": 369582, + "subdir": "linux-64", + "timestamp": 1602786718933, + "version": "2020.10.15" + }, + "regex-2020.10.15-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "5e721d0c7730363495ee69479fcfc069", + "name": "regex", + "sha256": "4b28c41d9f7a34e81e6e7bbf976f516053e469a09e4666b4b519348312e6e0e8", + "size": 366747, + "subdir": "linux-64", + "timestamp": 1602786711918, + "version": "2020.10.15" + }, + "regex-2020.10.15-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "d6cac5deb42a01b3cd81bcef6216091c", + "name": "regex", + "sha256": "596b5ff280f2a616c12c9230b8f9cc8bd1f04a310a5b919adb0c42eaea0425d7", + "size": 369559, + "subdir": "linux-64", + "timestamp": 1602786725849, + "version": "2020.10.15" + }, + "regex-2020.11.13-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "328b9454cac83a1892cadde378dd4971", + "name": "regex", + "sha256": "5ba9891ea25ec7fbe606aa867cadc5f07c9e412ee245334071bab68229e86d42", + "size": 364401, + "subdir": "linux-64", + "timestamp": 1606772765743, + "version": "2020.11.13" + }, + "regex-2020.11.13-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "887d03fa813eee1748377f85aa318c44", + "name": "regex", + "sha256": "66b3a2467e408d57956bf08315e2e394193d121db160cbad9b2b725d3b33faf5", + "size": 362427, + "subdir": "linux-64", + "timestamp": 1606772757964, + "version": "2020.11.13" + }, + "regex-2020.11.13-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "175ea9bdd0a1ef881ad97ee1351ad0cb", + "name": "regex", + "sha256": "0f88e21397e836a980f61751ee8b66a1b58238d34aff2ba051edbcccc757964c", + "size": 374223, + "subdir": "linux-64", + "timestamp": 1606772779619, + "version": "2020.11.13" + }, + "regex-2020.11.13-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "098c3640c83eec92f102e28ba26cd1d5", + "name": "regex", + "sha256": "cefa9596d3c146e2b0a35c216ffd1b62941c0d04776aa2665aa08315f7b6f7ff", + "size": 364752, + "subdir": "linux-64", + "timestamp": 1606772737788, + "version": "2020.11.13" + }, + "regex-2020.2.20-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "97e0f816d5ed12f770106f46bb285f1a", + "name": "regex", + "sha256": "d9a386574fe393536971089d7165a471829f436aff949b5133346c85d26c83e9", + "size": 392509, + "subdir": "linux-64", + "timestamp": 1583248538898, + "version": "2020.2.20" + }, + "regex-2020.2.20-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "81dd7e36f26c7d47738dfb232b41342b", + "name": "regex", + "sha256": "9d019094654c41a5051c8bfcae11fd21edbbf9b8d28b7310afce74c7796277f0", + "size": 391089, + "subdir": "linux-64", + "timestamp": 1583248528541, + "version": "2020.2.20" + }, + "regex-2020.2.20-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "89bc17e74761b563dccdb1dc5dedbb00", + "name": "regex", + "sha256": "5140d8f1d57dcedc983cc55dd333904044d257c279826a3edb4473ab0011a026", + "size": 382594, + "subdir": "linux-64", + "timestamp": 1583248489259, + "version": "2020.2.20" + }, + "regex-2020.4.4-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "32d598541655a4c3f970f4afc3ae822b", + "name": "regex", + "sha256": "d2b6a86ff0f462b721467f65043d16fb3fefb91762c1f31ca78e19bb7bb51a70", + "size": 379222, + "subdir": "linux-64", + "timestamp": 1586534611301, + "version": "2020.4.4" + }, + "regex-2020.4.4-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "a82b751ff428b794c5957db4422b15eb", + "name": "regex", + "sha256": "c9bcf5800fae13489c72504fc42ca9e260a699580e75c55339d959423133120a", + "size": 375302, + "subdir": "linux-64", + "timestamp": 1586534646762, + "version": "2020.4.4" + }, + "regex-2020.4.4-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "43a6ff344568f21b90fca8d2e12e2fe2", + "name": "regex", + "sha256": "04af57e36bdb5520952e222f654e0d301ef9951bbb5768305021a6e3fc3b514f", + "size": 387069, + "subdir": "linux-64", + "timestamp": 1586534694964, + "version": "2020.4.4" + }, + "regex-2020.5.14-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "d2e919110419c7dad5eb3430804994de", + "name": "regex", + "sha256": "801e0ff3e9768fbb1714013c559b3b730425283e1c99c05cc3323b58b0df78b8", + "size": 383325, + "subdir": "linux-64", + "timestamp": 1590084197678, + "version": "2020.5.14" + }, + "regex-2020.5.14-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "dbd78fb195cd1971a66eb198dc0dc92a", + "name": "regex", + "sha256": "a60353d830dc7c26c1ab11c099ffcf866ba297bcbc42b6a6d85f0aa0c129dae2", + "size": 380293, + "subdir": "linux-64", + "timestamp": 1590084178720, + "version": "2020.5.14" + }, + "regex-2020.5.14-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "24f19ced85c3f807ec82b5dd7e24db9f", + "name": "regex", + "sha256": "d42ee563ff4cb50368971f1b429302a6bcc5bd3ea61864584d137608fc8406b1", + "size": 389182, + "subdir": "linux-64", + "timestamp": 1590084205286, + "version": "2020.5.14" + }, + "regex-2020.6.8-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "e01fb3f3154b72b53d0f94987f10dde5", + "name": "regex", + "sha256": "d0bd0ac9c3d89cd81011b2f2512190677d6efe818564de7fa0df6fd8b6db1572", + "size": 374422, + "subdir": "linux-64", + "timestamp": 1593435622386, + "version": "2020.6.8" + }, + "regex-2020.6.8-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "1cd417250fc421c91d826ddf16876f27", + "name": "regex", + "sha256": "6ed13d4b8313f701ce25b4bd06da157f41bfa8d92ac8aec35ea2610dd4cb08fc", + "size": 379593, + "subdir": "linux-64", + "timestamp": 1593435586318, + "version": "2020.6.8" + }, + "regex-2020.6.8-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "c31aa80dfc26c27500488ddc75a06c97", + "name": "regex", + "sha256": "118a589fe9ac42ab09dc698d31c777e573aca94380c2ad11394e649f0364cd44", + "size": 371841, + "subdir": "linux-64", + "timestamp": 1593435597536, + "version": "2020.6.8" + }, + "regex-2020.7.14-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "66a07bb1545a49ba64a24e5304e316e1", + "name": "regex", + "sha256": "ae4991219a6935ea0180fdd7cedd19119989ff4250c11616416f387928051396", + "size": 374396, + "subdir": "linux-64", + "timestamp": 1596829761188, + "version": "2020.7.14" + }, + "regex-2020.7.14-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "0f4a24f0cfdad5b97ce9d1f89922a645", + "name": "regex", + "sha256": "bd51eb57fa42acc5a5fa6aebddaa2dba50ec947a66712dd71c0196b4bcc8c359", + "size": 379681, + "subdir": "linux-64", + "timestamp": 1596829737235, + "version": "2020.7.14" + }, + "regex-2020.7.14-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "9f792481837b60a9fe4235b2e3cc1888", + "name": "regex", + "sha256": "3af7376f3ba179bafbfb5d9477c694c23073d93b29e8d78e44a43351c310fe04", + "size": 378276, + "subdir": "linux-64", + "timestamp": 1596829732008, + "version": "2020.7.14" + }, + "regex-2020.9.27-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "5482ed0fa0c806ed844108bfcf8bcd96", + "name": "regex", + "sha256": "7d19d70d1e865ddc2475eb1cf412daad8bbc6128696d9c83cf9e5236770f2f3f", + "size": 366083, + "subdir": "linux-64", + "timestamp": 1602266187709, + "version": "2020.9.27" + }, + "regex-2020.9.27-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "18bdfcffa3d1e85830968f88a5bebf31", + "name": "regex", + "sha256": "8067b982e4e99e634d08565bad9bd89f3f18e10714458ffc6776ba90102a38a3", + "size": 357127, + "subdir": "linux-64", + "timestamp": 1602266204987, + "version": "2020.9.27" + }, + "regex-2020.9.27-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "092001a8f079aa950939b1a4d0445dbe", + "name": "regex", + "sha256": "58836d66b78642e7cb53030ffd190a1b5aef57213de8f1ca5f7f2989b40bb72e", + "size": 369784, + "subdir": "linux-64", + "timestamp": 1602266207814, + "version": "2020.9.27" + }, + "regex-2021.11.2-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1379a0dc40bbffcc5321f3470f6cd312", + "name": "regex", + "sha256": "79a2e9034d69d4d9c6d1a78cf2c3cd847e4b750dc4f204dbf1f815cbb0970df2", + "size": 369775, + "subdir": "linux-64", + "timestamp": 1642021403056, + "version": "2021.11.2" + }, + "regex-2021.11.2-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ea1fd8a1a3ea60cb448777a6ca586cc4", + "name": "regex", + "sha256": "31abfe11b411bd358a6129a17ecb3551ac175791d92737143c911e98533d038a", + "size": 372311, + "subdir": "linux-64", + "timestamp": 1642021434669, + "version": "2021.11.2" + }, + "regex-2021.11.2-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1c54052ce2accf8a7ca9dad03f29044a", + "name": "regex", + "sha256": "c11069f80814fb426ec0e6b0614bd61491e7770c144d4330989b97bcb7f3f7b4", + "size": 370886, + "subdir": "linux-64", + "timestamp": 1642021370656, + "version": "2021.11.2" + }, + "regex-2021.3.17-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "ec8d479a320c571d70052a9c0dae7329", + "name": "regex", + "sha256": "759c1e0cc1fc66f8c57f3ce3f3b447b2b2afd1253fe0228f15621af0d6db626f", + "size": 364151, + "subdir": "linux-64", + "timestamp": 1616096024847, + "version": "2021.3.17" + }, + "regex-2021.3.17-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "f71b202c6555c271ee0bd7cea0c89473", + "name": "regex", + "sha256": "35ccc85a182c4fd547995f44d5beb4a8f65b65960240601cfd310f7c2508d63d", + "size": 362416, + "subdir": "linux-64", + "timestamp": 1616094083867, + "version": "2021.3.17" + }, + "regex-2021.3.17-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "453a4596c975d7b7d7b99cec0240cbdf", + "name": "regex", + "sha256": "2d1135dc9ecffd99f04223b079321698b0647ccb5b07f766ed66316e8a6f2083", + "size": 365793, + "subdir": "linux-64", + "timestamp": 1616096033205, + "version": "2021.3.17" + }, + "regex-2021.3.17-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "4d47335ea2d2bcf38cb4d9ccdfcd059e", + "name": "regex", + "sha256": "e30d170bfe210ea5edf496b8b2742b414ccb59948ad8cad90f03cf7a3fb0bdfa", + "size": 365072, + "subdir": "linux-64", + "timestamp": 1616095867497, + "version": "2021.3.17" + }, + "regex-2021.4.4-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "028b3e6bb531e9bc06ce245ee0d018cc", + "name": "regex", + "sha256": "431cbbe76f9e99daa0ce8108901130a31e997f7629574a5012a1a6963e5e70ac", + "size": 373568, + "subdir": "linux-64", + "timestamp": 1617569763909, + "version": "2021.4.4" + }, + "regex-2021.4.4-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "903a1b08e422a71ec033fd4a8950a1fe", + "name": "regex", + "sha256": "297d8bb08ba97731ea3f9e913a9c6a09de5c53fb9e4809c2dca4ecaff1fff04f", + "size": 370972, + "subdir": "linux-64", + "timestamp": 1617569767001, + "version": "2021.4.4" + }, + "regex-2021.4.4-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "0acbf25cd02a13f2517cb8fa990c6489", + "name": "regex", + "sha256": "730fd4fe7c91ff1b651b8fd8dbe5806582b9e0e8ed7e59d5d8e5a6ed25469ea7", + "size": 365538, + "subdir": "linux-64", + "timestamp": 1617569251269, + "version": "2021.4.4" + }, + "regex-2021.4.4-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "ea15c71b703ee4bd35cfe5b3dda82b88", + "name": "regex", + "sha256": "8db0bf8d321750ad77e18e492a0be2c09db6bb65d0af6d779acf6751851aabf3", + "size": 374902, + "subdir": "linux-64", + "timestamp": 1617569769303, + "version": "2021.4.4" + }, + "regex-2021.7.6-py36h7f8727e_0.tar.bz2": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e631a58b24e5318da5672115cdda6067", + "name": "regex", + "sha256": "52d4f290646c189c9263fbf9549945679ab36f7455fcc18c5fdd71f218ad2217", + "size": 375677, + "subdir": "linux-64", + "timestamp": 1625610157805, + "version": "2021.7.6" + }, + "regex-2021.7.6-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "849005e992ab10ac32e7d57dd959a1fe", + "name": "regex", + "sha256": "4cfff80c989e17989e874f98f2011b07e98b2116e2b9176a49a4c9eb708f093f", + "size": 374005, + "subdir": "linux-64", + "timestamp": 1625610144933, + "version": "2021.7.6" + }, + "regex-2021.7.6-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4c35f8b0fff8c7b5d473e116d54e9724", + "name": "regex", + "sha256": "23f642c6b7f0e08afb54f3917ba9ff69e8404995028ebb5b4528024ed0dbd9ea", + "size": 373542, + "subdir": "linux-64", + "timestamp": 1625603394959, + "version": "2021.7.6" + }, + "regex-2021.7.6-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bd9cafa2c81c291054a2a9319a61815a", + "name": "regex", + "sha256": "f8fa692c2d8dc1b538cc85409e322cc1dc44d33a88e5a2b9ad787c707c1086e7", + "size": 376011, + "subdir": "linux-64", + "timestamp": 1625603751280, + "version": "2021.7.6" + }, + "regex-2021.8.3-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fc31c171620f69fef5845ead076ad767", + "name": "regex", + "sha256": "db9cb24e9431827c5d1af21202f1377a34608f923a2ba72ec714c07d0aa3c900", + "size": 719942, + "subdir": "linux-64", + "timestamp": 1640794332474, + "version": "2021.8.3" + }, + "regex-2021.8.3-py36h7f8727e_0.tar.bz2": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "efdddd6bc17578515baa63d6146c5c19", + "name": "regex", + "sha256": "9b73d1c5aa599b41dc9ace25bf46e677bbc28804dc9d9e3bf5c8aef3dc056e53", + "size": 375379, + "subdir": "linux-64", + "timestamp": 1629293558795, + "version": "2021.8.3" + }, + "regex-2021.8.3-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d38d808d3da4b59e6321d4eae55835c0", + "name": "regex", + "sha256": "d92304fe3ec5e86610715b8d6036689e48c9bde4972ddc31f6062f084732da09", + "size": 373760, + "subdir": "linux-64", + "timestamp": 1629293544885, + "version": "2021.8.3" + }, + "regex-2021.8.3-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "743a2ae99df58cfabf80da3dd9c4fa48", + "name": "regex", + "sha256": "91c4e6a29026629a8663eb241553022707815f5d3c0cbe05189f9bce6158b297", + "size": 376816, + "subdir": "linux-64", + "timestamp": 1629301384984, + "version": "2021.8.3" + }, + "regex-2021.8.3-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0e281fe1f639ba6c5f1746ab91ea6387", + "name": "regex", + "sha256": "9292cc4af8228bcc3f77ff2299e0edd8b695863bddc9f59ad941356902e9f020", + "size": 376083, + "subdir": "linux-64", + "timestamp": 1628063409172, + "version": "2021.8.3" + }, + "regex-2022.3.15-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4bdfb4c0e59d1f0a0aa1959069c4db07", + "name": "regex", + "sha256": "9b7247ed01d6e7ce814302a6bf1a9f4ac10969ef68f8ffd49b2cd37648c07c48", + "size": 737470, + "subdir": "linux-64", + "timestamp": 1648429646491, + "version": "2022.3.15" + }, + "regex-2022.3.15-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f94bd6b649a9f5ede2d486a1b698ff1c", + "name": "regex", + "sha256": "5307b4e8f538e914bee505608f612a01019a5c656a296e811a77740e6a734ae2", + "size": 453217, + "subdir": "linux-64", + "timestamp": 1676845661095, + "version": "2022.3.15" + }, + "regex-2022.3.15-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "121f2b936d7b802483510dcef838b99c", + "name": "regex", + "sha256": "ac9142c106dd9099491685f1ade81dc30f31b1616789585948e6d777a0542a1f", + "size": 387064, + "subdir": "linux-64", + "timestamp": 1648447762836, + "version": "2022.3.15" + }, + "regex-2022.3.15-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f8d04086a39889bc8803f08ac2063609", + "name": "regex", + "sha256": "dc01f617f29f0a8806f19436779ff18021e75ce70630c0d4747bc04044f7cc65", + "size": 384738, + "subdir": "linux-64", + "timestamp": 1648447758312, + "version": "2022.3.15" + }, + "regex-2022.3.15-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ceb1e30c730f85f2484bd5d1dbba9f9e", + "name": "regex", + "sha256": "c33d4bce839d7e1b1baa1807a1cc49052938e9cea05329202f61bfadc74e1c59", + "size": 394236, + "subdir": "linux-64", + "timestamp": 1648447756521, + "version": "2022.3.15" + }, + "regex-2022.7.9-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7ef9fcc279f0c1dc9d7ae61ff1462565", + "name": "regex", + "sha256": "fbb0eb6e5fba8915dabbb5cc0edfd38119fdca7a514acd00d98cb317b2bab837", + "size": 843826, + "subdir": "linux-64", + "timestamp": 1658257279037, + "version": "2022.7.9" + }, + "regex-2022.7.9-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ca8b84947fd8e716a950a5b902411765", + "name": "regex", + "sha256": "b6df74ea476ca803d03bcc294b1c02a373b4c61f62c757048fba9fe340185019", + "size": 452035, + "subdir": "linux-64", + "timestamp": 1677086850954, + "version": "2022.7.9" + }, + "regex-2022.7.9-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "44edcc62e5765cb022d22125f6ec2b8a", + "name": "regex", + "sha256": "da9933722c62ddee6b9271538a5093cd6feb069d09935fe93bf619396bf57adf", + "size": 390933, + "subdir": "linux-64", + "timestamp": 1658257229770, + "version": "2022.7.9" + }, + "regex-2022.7.9-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1a4b15fdfc6ff0b6df7219ec7843c70a", + "name": "regex", + "sha256": "411979343569747a9aae4ec5c00f2300ced8ae951db2cc2b8d22de850ebe6fca", + "size": 394691, + "subdir": "linux-64", + "timestamp": 1658257314892, + "version": "2022.7.9" + }, + "regex-2022.7.9-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b4054bc745e07dad13066c7a7c6b5a51", + "name": "regex", + "sha256": "7736c63dad0c7522aa6845092d73367bde14b20aa328880b1f1d75d7892d696a", + "size": 392668, + "subdir": "linux-64", + "timestamp": 1658257350962, + "version": "2022.7.9" + }, + "reportlab-3.5.10-py27he686d34_0.tar.bz2": { + "build": "py27he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "58202b1b6e2c07c369946f532e10982f", + "name": "reportlab", + "sha256": "c44290fcf6bd840993a012c858035c3c5b2474967aa08aded5ad2c0ffc170230", + "size": 2515118, + "subdir": "linux-64", + "timestamp": 1542392866359, + "version": "3.5.10" + }, + "reportlab-3.5.10-py36he686d34_0.tar.bz2": { + "build": "py36he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "35bfbef6c72a5c04efe5eed2c97a6bc6", + "name": "reportlab", + "sha256": "f3d41421006374bccb656cf505f13c44ad8999cf702ce1972ff1440546767e5b", + "size": 2493123, + "subdir": "linux-64", + "timestamp": 1542392898831, + "version": "3.5.10" + }, + "reportlab-3.5.10-py37he686d34_0.tar.bz2": { + "build": "py37he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d40c3bb65fb970dbcad164f338b64e90", + "name": "reportlab", + "sha256": "09f20e937e160f953d8f82896f69166d2329d6cbcaf35862a53a7e61a4364484", + "size": 2500295, + "subdir": "linux-64", + "timestamp": 1542392868576, + "version": "3.5.10" + }, + "reportlab-3.5.12-py27he686d34_0.tar.bz2": { + "build": "py27he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "24feb4a95b3361b21e321058cd697c4f", + "name": "reportlab", + "sha256": "c3f13e62477e0c23c2795ea2cf49df03cb77e2a4b4ac79a8500d7ddd655ee81c", + "size": 2527918, + "subdir": "linux-64", + "timestamp": 1545101559629, + "version": "3.5.12" + }, + "reportlab-3.5.12-py36he686d34_0.tar.bz2": { + "build": "py36he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ce3a716156da0fd61510e7b86dee46da", + "name": "reportlab", + "sha256": "ee1cec543e6648b7333774c4ad8379fd5ea795e8ccdd67c014c087c609e21d24", + "size": 2496493, + "subdir": "linux-64", + "timestamp": 1545101515334, + "version": "3.5.12" + }, + "reportlab-3.5.12-py37he686d34_0.tar.bz2": { + "build": "py37he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f6e7ff61e2dfcb8f4f3dde96af4f8d50", + "name": "reportlab", + "sha256": "af35e4152877881c17aa33f4dd24eec94a96fa1f08a91963c39e01e9f718cd10", + "size": 2476359, + "subdir": "linux-64", + "timestamp": 1545101598676, + "version": "3.5.12" + }, + "reportlab-3.5.13-py27he686d34_0.tar.bz2": { + "build": "py27he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f9a8705c1296da8fb4d2557268b18d95", + "name": "reportlab", + "sha256": "eaae55f34a23b203fdf21428e6db9150292ebedc38abe03516ecf43ea0551222", + "size": 2533336, + "subdir": "linux-64", + "timestamp": 1547931430998, + "version": "3.5.13" + }, + "reportlab-3.5.13-py36he686d34_0.tar.bz2": { + "build": "py36he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aae52fbd206a5387a3054041c64391e4", + "name": "reportlab", + "sha256": "cb69375f7121add5b4efb8574b340fc244fea35c5f80e7a2eb21da809a765d9e", + "size": 2493105, + "subdir": "linux-64", + "timestamp": 1547931476651, + "version": "3.5.13" + }, + "reportlab-3.5.13-py37he686d34_0.tar.bz2": { + "build": "py37he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e3c96d1cff4d7b1543e708ec8b82fb5e", + "name": "reportlab", + "sha256": "73da9bc3a0467e63a79c5d1e3bbdb19f9869c3f8b01da00e8a2e1cab68825c3e", + "size": 2489911, + "subdir": "linux-64", + "timestamp": 1547931457178, + "version": "3.5.13" + }, + "reportlab-3.5.19-py27he686d34_0.tar.bz2": { + "build": "py27he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2c565be7ea68fd31af6a77a14cdee029", + "name": "reportlab", + "sha256": "9f36670f30f6d19c77039fea14bd8a96c49bb22166ac325bd8e7d1e7269195d3", + "size": 2550865, + "subdir": "linux-64", + "timestamp": 1556074465018, + "version": "3.5.19" + }, + "reportlab-3.5.19-py36he686d34_0.tar.bz2": { + "build": "py36he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2a08261db49bfaa955da0e4394815525", + "name": "reportlab", + "sha256": "16537ffd8fcc2a2abead5ac57ffcb44d20d530119fab1f7c4cd56bb5dc4a1ce8", + "size": 2504769, + "subdir": "linux-64", + "timestamp": 1556074338977, + "version": "3.5.19" + }, + "reportlab-3.5.19-py37he686d34_0.tar.bz2": { + "build": "py37he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4b0d505dada82a95349eeecfcf1cfa99", + "name": "reportlab", + "sha256": "ea6abc4a6deb636da2440c99b34f696bbba5dcf8de13ce836428d8a957844aa2", + "size": 2499377, + "subdir": "linux-64", + "timestamp": 1556074296862, + "version": "3.5.19" + }, + "reportlab-3.5.2-py27h5871c9b_0.tar.bz2": { + "build": "py27h5871c9b_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.2.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "99cea9c2b9bbe4f296903c32825f33fc", + "name": "reportlab", + "sha256": "de87819ffdd367665d59b358708dd2f99f7d63be1cc3c77fa26c49d30c7fbef4", + "size": 2555218, + "subdir": "linux-64", + "timestamp": 1532781525958, + "version": "3.5.2" + }, + "reportlab-3.5.2-py35h5871c9b_0.tar.bz2": { + "build": "py35h5871c9b_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.2.0", + "pillow >=2.4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "73e510a930bc5377057a289c4c91a094", + "name": "reportlab", + "sha256": "5c9967deb23025783158d4547c53f4e44d32b14ee85fdc3a6eb782ecd5594547", + "size": 2561745, + "subdir": "linux-64", + "timestamp": 1532781652866, + "version": "3.5.2" + }, + "reportlab-3.5.2-py36h5871c9b_0.tar.bz2": { + "build": "py36h5871c9b_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.2.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2f9e87660b61bc725a89b26b04d361d5", + "name": "reportlab", + "sha256": "c8edb6f2ae7f71619fc7e3dcca43db6cdd5dede2403becce8608f4a0ea8880f3", + "size": 2526233, + "subdir": "linux-64", + "timestamp": 1532781516557, + "version": "3.5.2" + }, + "reportlab-3.5.2-py37h5871c9b_0.tar.bz2": { + "build": "py37h5871c9b_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.2.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "63855bcebe77fe1e959778990d20eb47", + "name": "reportlab", + "sha256": "a54ece5ba6ba99c43400ef7afd13860637f10bacf69fe0004fb04c90bb2cbdea", + "size": 2516113, + "subdir": "linux-64", + "timestamp": 1532781610113, + "version": "3.5.2" + }, + "reportlab-3.5.23-py27he686d34_0.tar.bz2": { + "build": "py27he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "61cf2063a6b0ba661146cbe020224416", + "name": "reportlab", + "sha256": "ced47cbb831e59068445819b010098cfc9b7baef9cbc0832c89a2ffbf7a5f94a", + "size": 2531159, + "subdir": "linux-64", + "timestamp": 1559924051972, + "version": "3.5.23" + }, + "reportlab-3.5.23-py36he686d34_0.tar.bz2": { + "build": "py36he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2fd6b961c1bf9581de07642b90ede6af", + "name": "reportlab", + "sha256": "c7987b8a43c15570ee373ad18b85650183a8427661effd03c1a777626db1822c", + "size": 2512475, + "subdir": "linux-64", + "timestamp": 1559924065117, + "version": "3.5.23" + }, + "reportlab-3.5.23-py37he686d34_0.tar.bz2": { + "build": "py37he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "abf7bfec8e0e5f1138d18f27a7679cc9", + "name": "reportlab", + "sha256": "198946ae068ece6dd2fdfb7678d44b2406f55826f665254355fcf16fdac832a9", + "size": 2497958, + "subdir": "linux-64", + "timestamp": 1559924006739, + "version": "3.5.23" + }, + "reportlab-3.5.26-py27he686d34_0.tar.bz2": { + "build": "py27he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "45f08a7ef00103ed8bc6cee9522bb820", + "name": "reportlab", + "sha256": "426092bb862d6650039865e583a73ee05eac3a9c4a626c26a45787bb57353395", + "size": 2544278, + "subdir": "linux-64", + "timestamp": 1569350888160, + "version": "3.5.26" + }, + "reportlab-3.5.26-py36he686d34_0.tar.bz2": { + "build": "py36he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6ac7588fea8fbef257b77f65a3a0e13f", + "name": "reportlab", + "sha256": "774502c462f9fd6749ab5f49f1fe534013f256b2df355bf20ef2258cb024d02c", + "size": 2516841, + "subdir": "linux-64", + "timestamp": 1569350890433, + "version": "3.5.26" + }, + "reportlab-3.5.26-py37he686d34_0.tar.bz2": { + "build": "py37he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "13596e2f5261fdbadd93491351fba515", + "name": "reportlab", + "sha256": "0effec489cf965f636cfa09ab441081e49f66fd295bd1dc22362a5aa5f28ef38", + "size": 2496038, + "subdir": "linux-64", + "timestamp": 1569350916841, + "version": "3.5.26" + }, + "reportlab-3.5.26-py38he686d34_0.tar.bz2": { + "build": "py38he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "80739c7a78d90d3632424b3b2ff20857", + "name": "reportlab", + "sha256": "6076597df0ba9c37bec7d535188d43f9beacea375738de98a29f14e7b137427c", + "size": 2535650, + "subdir": "linux-64", + "timestamp": 1574274112580, + "version": "3.5.26" + }, + "reportlab-3.5.45-py36hd14fb90_0.tar.bz2": { + "build": "py36hd14fb90_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.2,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0e46c1ba3fc1cd4d5de970260ae67950", + "name": "reportlab", + "sha256": "fc6ad78038ebb95c9d23a9a7c16a87e610dd3aee531092bd1b9990e959bb1db3", + "size": 2564149, + "subdir": "linux-64", + "timestamp": 1595336969933, + "version": "3.5.45" + }, + "reportlab-3.5.45-py37hd14fb90_0.tar.bz2": { + "build": "py37hd14fb90_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.2,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "13fead4388d5754866a922d562381a5c", + "name": "reportlab", + "sha256": "595a2fa985dd2e73eb4729680146cc3ed781cc37227af1fdeaeac2304a71f889", + "size": 2554620, + "subdir": "linux-64", + "timestamp": 1595342241165, + "version": "3.5.45" + }, + "reportlab-3.5.45-py38hd14fb90_0.tar.bz2": { + "build": "py38hd14fb90_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.2,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "020bf2241fdfcc49b18d7b7b0fdca4e1", + "name": "reportlab", + "sha256": "4e341d461c0c30be7474a1a3ee371b690fa50539a50f71ef5b4bb9f1a299a297", + "size": 2554370, + "subdir": "linux-64", + "timestamp": 1595336962395, + "version": "3.5.45" + }, + "reportlab-3.5.51-py36h8e67044_0.tar.bz2": { + "build": "py36h8e67044_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.2,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "017d1013d10fda6570cf7371656750f4", + "name": "reportlab", + "sha256": "2739520770ac0732c4797f3bc181ea85635f8af4473d783136c786fd7ad487d6", + "size": 2537160, + "subdir": "linux-64", + "timestamp": 1601054408985, + "version": "3.5.51" + }, + "reportlab-3.5.51-py36hd14fb90_0.tar.bz2": { + "build": "py36hd14fb90_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.2,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b7c383a9644e967d2108d4934f8ac2a7", + "name": "reportlab", + "sha256": "a174c8d1d19781bd09e2f5d7402a81dfd4cfbf83c95c63ef57db2fb0d7d0cb0a", + "size": 2545454, + "subdir": "linux-64", + "timestamp": 1601054731361, + "version": "3.5.51" + }, + "reportlab-3.5.51-py37h8e67044_0.tar.bz2": { + "build": "py37h8e67044_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.2,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cfd486a6114236fc1a738a8751ad0be7", + "name": "reportlab", + "sha256": "aca97a3541495df5768c11b4b5642a51b778200072507e276bc54b6a0d9a8d8c", + "size": 2553629, + "subdir": "linux-64", + "timestamp": 1601054378727, + "version": "3.5.51" + }, + "reportlab-3.5.51-py37hd14fb90_0.tar.bz2": { + "build": "py37hd14fb90_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.2,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "592db4b3ab583a45075de15db4cdc92d", + "name": "reportlab", + "sha256": "ec5de1574d76b45a5d8367ca033b4981bcde5674b2dbef24b0e9b174f4c55666", + "size": 2549222, + "subdir": "linux-64", + "timestamp": 1601054735922, + "version": "3.5.51" + }, + "reportlab-3.5.51-py38h8e67044_0.tar.bz2": { + "build": "py38h8e67044_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.2,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5dfc686ef256b7befad24bca2017c818", + "name": "reportlab", + "sha256": "025f35fa53c3da6aeb06c810e07eaff34ee4ab017d0362086521f2f7fbf1e2da", + "size": 2554075, + "subdir": "linux-64", + "timestamp": 1601054407364, + "version": "3.5.51" + }, + "reportlab-3.5.51-py38hd14fb90_0.tar.bz2": { + "build": "py38hd14fb90_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.2,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aca4063a8c78778f2c1b7082ebad368b", + "name": "reportlab", + "sha256": "905a2334439c59114ab70f6ce71bb408df4807009f6484de543d1d2cd556ad58", + "size": 2563791, + "subdir": "linux-64", + "timestamp": 1601054722393, + "version": "3.5.51" + }, + "reportlab-3.5.59-py36hfdd840d_0.tar.bz2": { + "build": "py36hfdd840d_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c7594c6250f82af8da35efee60f3c696", + "name": "reportlab", + "sha256": "94549837213aad497021d9f71f66e78c448c57fd50181fa410e614f8335aa470", + "size": 2563215, + "subdir": "linux-64", + "timestamp": 1610393160112, + "version": "3.5.59" + }, + "reportlab-3.5.59-py36hfdd840d_1.tar.bz2": { + "build": "py36hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ebb53fb73e412068791475db32bdde09", + "name": "reportlab", + "sha256": "efc1b2d6487da6232e77bfa9cd43ea3260aec7417af296ff473eb8b936630197", + "size": 2575684, + "subdir": "linux-64", + "timestamp": 1610483364609, + "version": "3.5.59" + }, + "reportlab-3.5.59-py37hfdd840d_0.tar.bz2": { + "build": "py37hfdd840d_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ad64034e8b0cc14caea87f4b5842ef47", + "name": "reportlab", + "sha256": "ddd8b9243e45eb758fff1d4f59f00740b461eebceb7ae4a5764c6b8b0ed38baf", + "size": 2555342, + "subdir": "linux-64", + "timestamp": 1610393129766, + "version": "3.5.59" + }, + "reportlab-3.5.59-py37hfdd840d_1.tar.bz2": { + "build": "py37hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e171045e3120f68a85f5d482c85948e6", + "name": "reportlab", + "sha256": "10f72130f36a3279171bc9498b717f3c1e26751283e2cefa010badc402b658f9", + "size": 2564461, + "subdir": "linux-64", + "timestamp": 1610483322191, + "version": "3.5.59" + }, + "reportlab-3.5.59-py38hfdd840d_0.tar.bz2": { + "build": "py38hfdd840d_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b13b767484e6ce89308b25b3b2e83d0f", + "name": "reportlab", + "sha256": "1237e6371cb2b48654cb462867156b120f5167eea844368fec93bffa8422db05", + "size": 2570382, + "subdir": "linux-64", + "timestamp": 1610392706915, + "version": "3.5.59" + }, + "reportlab-3.5.59-py38hfdd840d_1.tar.bz2": { + "build": "py38hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f0383d66cbe44b216566bea372ef9a14", + "name": "reportlab", + "sha256": "316bfcbd0d390467e97f788748c4f2c84031bf4b75a56025ac7a26a24de4f05a", + "size": 2574040, + "subdir": "linux-64", + "timestamp": 1610483359179, + "version": "3.5.59" + }, + "reportlab-3.5.59-py39hfdd840d_0.tar.bz2": { + "build": "py39hfdd840d_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7d8646a9e6037a8639118043551fc406", + "name": "reportlab", + "sha256": "bdc7ea5164f3a46e9b3bfeea02407329efbde58fe34d25320ce2f526d9db4d96", + "size": 2559392, + "subdir": "linux-64", + "timestamp": 1610393112739, + "version": "3.5.59" + }, + "reportlab-3.5.59-py39hfdd840d_1.tar.bz2": { + "build": "py39hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7aafb7d1d6b31c597e72caee9fb6f7ae", + "name": "reportlab", + "sha256": "fdc6f3670efed1e4dd13d986f66295b402627eb43313911bfeadf9522f20b321", + "size": 2589633, + "subdir": "linux-64", + "timestamp": 1610483355920, + "version": "3.5.59" + }, + "reportlab-3.5.6-py27he686d34_0.tar.bz2": { + "build": "py27he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5016c74de8fccc0967ec0d11ee296e22", + "name": "reportlab", + "sha256": "887cc2d754067bf52ecce2f4896432c589a6d9726f4658863752a80fac445f7f", + "size": 2590025, + "subdir": "linux-64", + "timestamp": 1535497214075, + "version": "3.5.6" + }, + "reportlab-3.5.6-py35he686d34_0.tar.bz2": { + "build": "py35he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5ad418ef62b808c0a6e9ee661ff7061b", + "name": "reportlab", + "sha256": "10d6c8e4a4e68f26395ff0a6e33ac7eef2ac6c06a6928e16e8c2a410b13555de", + "size": 2608936, + "subdir": "linux-64", + "timestamp": 1535497147040, + "version": "3.5.6" + }, + "reportlab-3.5.6-py36he686d34_0.tar.bz2": { + "build": "py36he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d2e1f18a41f58f24333b09e710f2063d", + "name": "reportlab", + "sha256": "d4ac8619a4628c154b669ba29f200df349f5488d6f177353c2bd4b4625dd9772", + "size": 2562558, + "subdir": "linux-64", + "timestamp": 1535497077158, + "version": "3.5.6" + }, + "reportlab-3.5.6-py37he686d34_0.tar.bz2": { + "build": "py37he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2fddbcc2d2bf8da301523cc4c02c166c", + "name": "reportlab", + "sha256": "03c652368bfbb6f9a84a87c626e4676909eac9383b796f85454a4ff63a889d46", + "size": 2557714, + "subdir": "linux-64", + "timestamp": 1535497192061, + "version": "3.5.6" + }, + "reportlab-3.5.60-py36hfdd840d_1.tar.bz2": { + "build": "py36hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b78b1dcc4ea5db3d890d93243602e57e", + "name": "reportlab", + "sha256": "86f94088d34884add4570fd28e6c05efe93a402976b06a70a8a50c59909dab39", + "size": 2572352, + "subdir": "linux-64", + "timestamp": 1611344752053, + "version": "3.5.60" + }, + "reportlab-3.5.60-py37hfdd840d_1.tar.bz2": { + "build": "py37hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cfe1397db2399d317447354d1d35ccf4", + "name": "reportlab", + "sha256": "02388dbd540178fb2d37596e7ce568f2ef3bca392f68994b9a3327de00ea25f5", + "size": 2552306, + "subdir": "linux-64", + "timestamp": 1611343968529, + "version": "3.5.60" + }, + "reportlab-3.5.60-py38hfdd840d_1.tar.bz2": { + "build": "py38hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "20610f2243b4ed5ebaf8329ffc6a2778", + "name": "reportlab", + "sha256": "764663bb02124bbb1ac432ca6c7d454da3b0b5c267e7e82bdd8592da04f33979", + "size": 2566266, + "subdir": "linux-64", + "timestamp": 1611344746318, + "version": "3.5.60" + }, + "reportlab-3.5.60-py39hfdd840d_1.tar.bz2": { + "build": "py39hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ed96ce86ccdb8720f2fc3efa499d2b65", + "name": "reportlab", + "sha256": "0462b9896eb28df228878fc1951d2a38f3ec73ac3f5773d3f28e0e92aee0adaa", + "size": 2559444, + "subdir": "linux-64", + "timestamp": 1611344724025, + "version": "3.5.60" + }, + "reportlab-3.5.64-py36hfdd840d_0.tar.bz2": { + "build": "py36hfdd840d_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6b685565d9cab8349624233850b06961", + "name": "reportlab", + "sha256": "ac90f948fabd7d6e114149b85360b103ee21fe365997849a5614ff9b1bcbaf4a", + "size": 2546962, + "subdir": "linux-64", + "timestamp": 1615457339008, + "version": "3.5.64" + }, + "reportlab-3.5.64-py36hfdd840d_1.tar.bz2": { + "build": "py36hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7ef382c66edc340bec52e9a081286e94", + "name": "reportlab", + "sha256": "115df192bc04d4eefc55aee06ae8ef1ec8a6bd748566864133bacbdc29be99ba", + "size": 2547483, + "subdir": "linux-64", + "timestamp": 1615545717179, + "version": "3.5.64" + }, + "reportlab-3.5.64-py37hfdd840d_0.tar.bz2": { + "build": "py37hfdd840d_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fd67ab613830568debd250e4e38ffa9f", + "name": "reportlab", + "sha256": "ee451eee68e43e6d8929b900375481faa3e2e53e27ef606ff73970cdc9828e39", + "size": 2543677, + "subdir": "linux-64", + "timestamp": 1615455734436, + "version": "3.5.64" + }, + "reportlab-3.5.64-py37hfdd840d_1.tar.bz2": { + "build": "py37hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f27d785330f0f25b9110773f89ea6969", + "name": "reportlab", + "sha256": "6cebcc876144ccb00655eda7bf135133d0d4b40445a499130005c9592b805694", + "size": 2541497, + "subdir": "linux-64", + "timestamp": 1615547360600, + "version": "3.5.64" + }, + "reportlab-3.5.64-py38hfdd840d_0.tar.bz2": { + "build": "py38hfdd840d_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8831397b4627a294b6c98781bb41b7bf", + "name": "reportlab", + "sha256": "299850fd6a830142ce826b24bf6aff1fc788ac86a7e8ceead681e4de60d303fc", + "size": 2536823, + "subdir": "linux-64", + "timestamp": 1615457333370, + "version": "3.5.64" + }, + "reportlab-3.5.64-py38hfdd840d_1.tar.bz2": { + "build": "py38hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "588b01278a86a89536e3420da7d22ef7", + "name": "reportlab", + "sha256": "af6a181c2f18587dd5028fcb5984b2f7c71d34366ff2769bd484ef79e7170ba1", + "size": 2548264, + "subdir": "linux-64", + "timestamp": 1615547381171, + "version": "3.5.64" + }, + "reportlab-3.5.64-py39hfdd840d_0.tar.bz2": { + "build": "py39hfdd840d_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b46117d0722187d575e860e8d80aeb30", + "name": "reportlab", + "sha256": "3f330cd86ec96da9c1b526d3d43ed61e5a7c5b18924072b0f20bcac8bd1ef8b6", + "size": 2562748, + "subdir": "linux-64", + "timestamp": 1615457330771, + "version": "3.5.64" + }, + "reportlab-3.5.64-py39hfdd840d_1.tar.bz2": { + "build": "py39hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fdda0c5fda359626daac3dc61b2e00e4", + "name": "reportlab", + "sha256": "c20f308d10b5666c78cf9403ceef8ca1728bfe30b2f98e7caaa8421a9fcf6ad8", + "size": 2541805, + "subdir": "linux-64", + "timestamp": 1615547361742, + "version": "3.5.64" + }, + "reportlab-3.5.65-py36hfdd840d_1.tar.bz2": { + "build": "py36hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5159d2897f45f1fe20d9e13bf4b9a028", + "name": "reportlab", + "sha256": "66382eac0b8db63fb8b5f75037b50b2fe7f242d6c01636964e8b42b8f30e9f0e", + "size": 2559399, + "subdir": "linux-64", + "timestamp": 1615546851765, + "version": "3.5.65" + }, + "reportlab-3.5.65-py37hfdd840d_1.tar.bz2": { + "build": "py37hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0fc273d8fcb6c1293b3f2ce999917ff4", + "name": "reportlab", + "sha256": "7f17e68a85ff462907ff85efa2df9eb4fdc09c55fb46fd10c086aa829799c5c1", + "size": 2564848, + "subdir": "linux-64", + "timestamp": 1615548508021, + "version": "3.5.65" + }, + "reportlab-3.5.65-py38hfdd840d_1.tar.bz2": { + "build": "py38hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0724525738bbaca6fbe66bc24a64d87a", + "name": "reportlab", + "sha256": "dd5ae543a4d251e3df1d3424200c8b436d9ae7a148fe937ec265fa82ce56c139", + "size": 2527729, + "subdir": "linux-64", + "timestamp": 1615548513733, + "version": "3.5.65" + }, + "reportlab-3.5.65-py39hfdd840d_1.tar.bz2": { + "build": "py39hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "30d0693d71e739f94cf951e1fb9fa502", + "name": "reportlab", + "sha256": "f82c7d2c6631beb6e5e03ac60c3ca01c42ab38d6e2dbb1a5295d1ae22bcf95ff", + "size": 2557916, + "subdir": "linux-64", + "timestamp": 1615548500043, + "version": "3.5.65" + }, + "reportlab-3.5.66-py36hfdd840d_1.tar.bz2": { + "build": "py36hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5979282baa55ac438d8ba215de0589a0", + "name": "reportlab", + "sha256": "72b7bc5c70a6b3c29c20d37e816ddaf3cf5cb1058722f24952237c6a84cf1118", + "size": 2567039, + "subdir": "linux-64", + "timestamp": 1616183176821, + "version": "3.5.66" + }, + "reportlab-3.5.66-py37hfdd840d_1.tar.bz2": { + "build": "py37hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3380582a0486f1c6f4fafb96e32cc147", + "name": "reportlab", + "sha256": "ee4c178f2a121e87db6a1cd690001a54558bd7a69115e41e4246d707c7da84a8", + "size": 2541163, + "subdir": "linux-64", + "timestamp": 1616182393368, + "version": "3.5.66" + }, + "reportlab-3.5.66-py38hfdd840d_1.tar.bz2": { + "build": "py38hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2e04d96755a6f314b47d8fdc0d2dad23", + "name": "reportlab", + "sha256": "2c177e7677f7e8188ca7dfff82b686d25b9e71019c7146ce0ffb21bfc42e23ed", + "size": 2553248, + "subdir": "linux-64", + "timestamp": 1616183185061, + "version": "3.5.66" + }, + "reportlab-3.5.66-py39hfdd840d_1.tar.bz2": { + "build": "py39hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "71783f03e17446ba83bfd73e2f9c8e23", + "name": "reportlab", + "sha256": "a266538d4d7a01535071ba1692cf2e34d0cc6643354e3f84e2b11149b8b78524", + "size": 2539217, + "subdir": "linux-64", + "timestamp": 1616183171887, + "version": "3.5.66" + }, + "reportlab-3.5.67-py310h0edfc0f_1.tar.bz2": { + "build": "py310h0edfc0f_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.5.0", + "pillow >=4.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4ba6935211ab20f85b044ceae7a145e0", + "name": "reportlab", + "sha256": "9e1c62dd42ae35f1b96871f4108d758102f2d286fa9aef045cef6e7e1c4fa2cf", + "size": 2795071, + "subdir": "linux-64", + "timestamp": 1643116904246, + "version": "3.5.67" + }, + "reportlab-3.5.67-py36hfdd840d_1.tar.bz2": { + "build": "py36hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b17e631e289d7a6bf877199dd2f177c2", + "name": "reportlab", + "sha256": "4769e36dba86d9c970b8abd48daea9c68d4c6261a713b8dfab1b459415967920", + "size": 2564357, + "subdir": "linux-64", + "timestamp": 1618696020047, + "version": "3.5.67" + }, + "reportlab-3.5.67-py37hfdd840d_1.tar.bz2": { + "build": "py37hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "24e51d797d70790b63620b06e39203e6", + "name": "reportlab", + "sha256": "43a4a83fe0973053520499c6d4ac387c1a2b3185b085e82b3e2129ce754cdf28", + "size": 2546716, + "subdir": "linux-64", + "timestamp": 1618695999497, + "version": "3.5.67" + }, + "reportlab-3.5.67-py38hfdd840d_1.tar.bz2": { + "build": "py38hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0e336b2104f8e30200c4208e2e1a0e01", + "name": "reportlab", + "sha256": "060c666518c73e767f0ba4c970fb9ef901431237d56bd3337965c6bc7e0cedf2", + "size": 2541347, + "subdir": "linux-64", + "timestamp": 1618695996154, + "version": "3.5.67" + }, + "reportlab-3.5.67-py39hfdd840d_1.tar.bz2": { + "build": "py39hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b5c98660723c05ae33c52088075be241", + "name": "reportlab", + "sha256": "9586834018e37c27b76c2b315ebb7636b29335077aec888c8036533bb2ba8290", + "size": 2538811, + "subdir": "linux-64", + "timestamp": 1618849751728, + "version": "3.5.67" + }, + "reportlab-3.5.8-py27he686d34_0.tar.bz2": { + "build": "py27he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cbac3926ca743f42c6a18d946cd1ad20", + "name": "reportlab", + "sha256": "e20f65282ca4c7a7e915129fce03e9c52330a6af9db26bb1a13f4579bb7f4946", + "size": 2590448, + "subdir": "linux-64", + "timestamp": 1538182431074, + "version": "3.5.8" + }, + "reportlab-3.5.8-py36he686d34_0.tar.bz2": { + "build": "py36he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "385b2335c342047a80d7a63422e7ed13", + "name": "reportlab", + "sha256": "54415e995c2eece641f3ef287e42a53049f6e5609619442e90d5edf85f16a879", + "size": 2562337, + "subdir": "linux-64", + "timestamp": 1538182493217, + "version": "3.5.8" + }, + "reportlab-3.5.8-py37he686d34_0.tar.bz2": { + "build": "py37he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "475f891164b3632b216738adc6398864", + "name": "reportlab", + "sha256": "ba6454d355747490afb6634f024ee8247c4874f8ca96cf00f19ecf20a9ca87d9", + "size": 2557603, + "subdir": "linux-64", + "timestamp": 1538182433884, + "version": "3.5.8" + }, + "reportlab-3.5.9-py27he686d34_0.tar.bz2": { + "build": "py27he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1e9b43caf583f83693ff0515b5cb7ff6", + "name": "reportlab", + "sha256": "c302c6853d84355370c3eb6f3c010013d592f824955102cebec58aaef358490c", + "size": 2530271, + "subdir": "linux-64", + "timestamp": 1538866441606, + "version": "3.5.9" + }, + "reportlab-3.5.9-py36he686d34_0.tar.bz2": { + "build": "py36he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f535f962cb91499d0afd38f4292401bc", + "name": "reportlab", + "sha256": "e93d257ea5c2a6ba59bcffea4bbed3632dd28c391919253afccf729fc9e3449a", + "size": 2502888, + "subdir": "linux-64", + "timestamp": 1538866459752, + "version": "3.5.9" + }, + "reportlab-3.5.9-py37he686d34_0.tar.bz2": { + "build": "py37he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fce282d9dae3fe551fd41a6ad44cb926", + "name": "reportlab", + "sha256": "d0a11c03b63103736d3d468c9b80e41d4c4dcc54b6dba38b2e925b09a5467ed2", + "size": 2510671, + "subdir": "linux-64", + "timestamp": 1538866350412, + "version": "3.5.9" + }, + "reportlab-3.6.12-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "freetype 2.10.4,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=11.2.0", + "pillow >=9.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "daa47f8426a7a33406764c2e800f4875", + "name": "reportlab", + "sha256": "3176e6a46eac5c8888efc97499a2832481d65172d8369063b5a4132fecae3f63", + "size": 2618490, + "subdir": "linux-64", + "timestamp": 1676301061491, + "version": "3.6.12" + }, + "reportlab-3.6.12-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "freetype 2.10.4,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=11.2.0", + "pillow >=9.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6af3235fafcbd88c3fe80432c6518820", + "name": "reportlab", + "sha256": "73ff397bbf8a80f4a049acf0a93568ca91bec50f54c4f12dec7bde73afcd681a", + "size": 3071491, + "subdir": "linux-64", + "timestamp": 1676861836208, + "version": "3.6.12" + }, + "reportlab-3.6.12-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "freetype 2.10.4,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=11.2.0", + "pillow >=9.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "127fccb4906b2eecd835ff9a78a7b3c5", + "name": "reportlab", + "sha256": "c3ec6193273968bf6614375a0b7aadedca5b18798a565ffc31aa3a6b8366efaa", + "size": 2558030, + "subdir": "linux-64", + "timestamp": 1676301100049, + "version": "3.6.12" + }, + "reportlab-3.6.12-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "freetype 2.10.4,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=11.2.0", + "pillow >=9.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "27f8099f35046e8633f2668d38bc50e2", + "name": "reportlab", + "sha256": "18ec0268b23bb235d01b6202eb2ee59b62cc6897292f21f8856f3d9e369dacb8", + "size": 2556967, + "subdir": "linux-64", + "timestamp": 1676301019737, + "version": "3.6.12" + }, + "reportlab-3.6.12-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "freetype 2.10.4,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=11.2.0", + "pillow >=9.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "39d0b21f9bd88045213edd0196452dfc", + "name": "reportlab", + "sha256": "73e3eee07f8550546202fe8aab4e10c116460bf1b6ddec7fd63494cfda499eac", + "size": 2555855, + "subdir": "linux-64", + "timestamp": 1676301138644, + "version": "3.6.12" + }, + "repoze.lru-0.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "c9e74b77366758a541dfcd3fd03b67af", + "name": "repoze.lru", + "sha256": "007974aa2bf0e1332c7789559d4db4bf6227221b3227f53b54d343eaab4305b7", + "size": 22399, + "subdir": "linux-64", + "timestamp": 1530875535385, + "version": "0.7" + }, + "repoze.lru-0.7-py27h62c147e_0.tar.bz2": { + "build": "py27h62c147e_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "3136cada417ad3abddeeaadd1c1b3f70", + "name": "repoze.lru", + "sha256": "a7617d21c260fef83751c1a6e6965b0c30d762634665abb0af0b74a9d9f1fc78", + "size": 22680, + "subdir": "linux-64", + "timestamp": 1509044644111, + "version": "0.7" + }, + "repoze.lru-0.7-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "c326efb0891bd3ae2b24a24d3a413c2a", + "name": "repoze.lru", + "sha256": "3ab7833d8a86a29929c5573cc258592f29b31604981e493560d2825068aa51db", + "size": 23416, + "subdir": "linux-64", + "timestamp": 1640794351628, + "version": "0.7" + }, + "repoze.lru-0.7-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "md5": "c2a141d73c8a794b52e35ce2b53ef095", + "name": "repoze.lru", + "sha256": "9f32632cef4f50771c5ff22806f950d37c733a3afd3d3c861e33e186e02f58d8", + "size": 30600, + "subdir": "linux-64", + "timestamp": 1676905989911, + "version": "0.7" + }, + "repoze.lru-0.7-py35h65eef69_0.tar.bz2": { + "build": "py35h65eef69_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "6fbb3a2d28f07e3b7e644ce18d8159a4", + "name": "repoze.lru", + "sha256": "6491bdfd553d47a3aab6af17e4bf6ad7ff936875857773ff5c10279b10d05663", + "size": 23288, + "subdir": "linux-64", + "timestamp": 1509044644803, + "version": "0.7" + }, + "repoze.lru-0.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "aedc3c818ddc215ded4e4d837196ea6e", + "name": "repoze.lru", + "sha256": "0155e3ce20055eb72e24127c62979945911c01142448b04203b9560c240bce9b", + "size": 22907, + "subdir": "linux-64", + "timestamp": 1530875485318, + "version": "0.7" + }, + "repoze.lru-0.7-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "c7ad25c170c28df011be13d23a57f4ac", + "name": "repoze.lru", + "sha256": "f7f2612a82d6411b26f943fc23695b9f06604e0ce375e0d35bc5b97cdfe53c64", + "size": 291175, + "subdir": "linux-64", + "timestamp": 1632756999155, + "version": "0.7" + }, + "repoze.lru-0.7-py36h5d7ca38_0.tar.bz2": { + "build": "py36h5d7ca38_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "4656d4ea05d03730d22cade90d7e3fe6", + "name": "repoze.lru", + "sha256": "70408d1b0dca396be3276400eace524bb2ccf4d1b62b47c9aa4b31b092b9607c", + "size": 23190, + "subdir": "linux-64", + "timestamp": 1509044655994, + "version": "0.7" + }, + "repoze.lru-0.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "993b90a002b76d7f964953225c755cd5", + "name": "repoze.lru", + "sha256": "e9fc9947ae37a9df5c55c2dcc699f96b057698c2a154b8e19f8ab75d77ed4418", + "size": 22973, + "subdir": "linux-64", + "timestamp": 1530875510813, + "version": "0.7" + }, + "repoze.lru-0.7-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "084484bb4a814274137ca29dd0d79f10", + "name": "repoze.lru", + "sha256": "6beaab58b8aa0e06eba1f4910f1c8a290ec0fb169e58cc2901a61492eb9456ef", + "size": 292249, + "subdir": "linux-64", + "timestamp": 1632746595225, + "version": "0.7" + }, + "repoze.lru-0.7-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "4c8092db504ec4bb3742506bc9a25b04", + "name": "repoze.lru", + "sha256": "9756e993197a398655bcf7a3c8eebade5efbf5c94b67dc73ce3ebd866d7310a0", + "size": 23438, + "subdir": "linux-64", + "timestamp": 1573200580286, + "version": "0.7" + }, + "repoze.lru-0.7-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "e4ec5c54156b1132e93c34721526e2f6", + "name": "repoze.lru", + "sha256": "b6d4412e320bfb9ed8303673d8916918556aa97f38322ecb4320d4b4f3419297", + "size": 291508, + "subdir": "linux-64", + "timestamp": 1632756981195, + "version": "0.7" + }, + "repoze.lru-0.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "288e63f88497ca5f766c0567a1356a5a", + "name": "repoze.lru", + "sha256": "ef399454d42cba1a22bf74b5fd47131e9de8ebc00a5ca4950e90065d0a0fe2ee", + "size": 292481, + "subdir": "linux-64", + "timestamp": 1632750933078, + "version": "0.7" + }, + "reproc-14.2.4-h295c915_1.tar.bz2": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af9fc5ca604f2dff3f5951476e45d573", + "name": "reproc", + "sha256": "af7a157f6a9af07b566921f09fffa54ef3a115b70831cec161df6a74837d4d57", + "size": 31513, + "subdir": "linux-64", + "timestamp": 1647441819202, + "version": "14.2.4" + }, + "reproc-cpp-14.2.4-h295c915_1.tar.bz2": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "reproc 14.2.4 h295c915_1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7a41df82594155f7e4afea46041b6609", + "name": "reproc-cpp", + "sha256": "5b38bba55983f36a4c23311e26ba8d52776e1dc1ca1a28b44a697121c4ce54d4", + "size": 23063, + "subdir": "linux-64", + "timestamp": 1647441839399, + "version": "14.2.4" + }, + "reproc-cpp-static-14.2.4-h295c915_1.tar.bz2": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bcb52886c27764395804596a4f467e19", + "name": "reproc-cpp-static", + "sha256": "c6310ccc703abc2ee10ddd81e2bf2995a5c57772817874079c87a681ecc219de", + "size": 13126, + "subdir": "linux-64", + "timestamp": 1647441867159, + "version": "14.2.4" + }, + "reproc-static-14.2.4-h7f8727e_1.tar.bz2": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c6d32aeb1a4bc3d0735557e6c0c5ee28", + "name": "reproc-static", + "sha256": "0f38a81d41fd49035c0aa8b5c46895b0637c618f3c669dcd69dadc86a8eb8a12", + "size": 22339, + "subdir": "linux-64", + "timestamp": 1647441853117, + "version": "14.2.4" + }, + "requests-2.18.4-py27hc5b0589_1.tar.bz2": { + "build": "py27hc5b0589_1", + "build_number": 1, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.7", + "python >=2.7,<2.8.0a0", + "urllib3 >=1.21.1,<1.23" + ], + "license": "Apache 2.0", + "md5": "b2279ec7ac6e94f815eaf3bb60b8b379", + "name": "requests", + "sha256": "c8cb9d49200691b5ef34c7bad57f19c34e8af0ee145a2ad4aa65b001db8c122d", + "size": 92618, + "subdir": "linux-64", + "timestamp": 1505693067766, + "version": "2.18.4" + }, + "requests-2.18.4-py35hb9e6ad1_1.tar.bz2": { + "build": "py35hb9e6ad1_1", + "build_number": 1, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.7", + "python >=3.5,<3.6.0a0", + "urllib3 >=1.21.1,<1.23" + ], + "license": "Apache 2.0", + "md5": "7ff98859eaaacae3eeced892fe4e1231", + "name": "requests", + "sha256": "9d4c7c0b87bf37893576b9ab21501bed38cd5123c9d0b2d0453cc128ea201edf", + "size": 94283, + "subdir": "linux-64", + "timestamp": 1505693080499, + "version": "2.18.4" + }, + "requests-2.18.4-py36he2e5f8d_1.tar.bz2": { + "build": "py36he2e5f8d_1", + "build_number": 1, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.7", + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.23" + ], + "license": "Apache 2.0", + "md5": "d62b0993421d3d9c54d6c1a737714662", + "name": "requests", + "sha256": "516770cdf8406255bcfe20b0cc5f934c6bafad950159c0b576f158b0e09cee70", + "size": 93909, + "subdir": "linux-64", + "timestamp": 1505693093401, + "version": "2.18.4" + }, + "requests-2.19.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=2.7,<2.8.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "72230cbd5936609a40cd51d8aaea6d4c", + "name": "requests", + "sha256": "a14ffd25035d4d9eb51dc0197093a180fbb54e8306a127a8c2a558bd2b77a703", + "size": 97316, + "subdir": "linux-64", + "timestamp": 1529357373170, + "version": "2.19.1" + }, + "requests-2.19.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=3.5,<3.6.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "5756f3632a6faee2a92df9022890e29c", + "name": "requests", + "sha256": "b7fc7c78bd511edac78e92201b456e7e0a9abc88e61e46696e00ac5084c865db", + "size": 98833, + "subdir": "linux-64", + "timestamp": 1529357386857, + "version": "2.19.1" + }, + "requests-2.19.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "3f2966002a15742020bb091a4d3ae008", + "name": "requests", + "sha256": "55942dd9cdf1f0e4f3fdf1e8e10d233827e077a1d2698f0e950ac344b7dcc11e", + "size": 98168, + "subdir": "linux-64", + "timestamp": 1529357353596, + "version": "2.19.1" + }, + "requests-2.19.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "1be5a5b321aa8b58fb020d738178606a", + "name": "requests", + "sha256": "3cec506a70d966a719769bed32a630fc6dd074359aa9d1ab259ba4a4ff2df728", + "size": 97894, + "subdir": "linux-64", + "timestamp": 1530733584270, + "version": "2.19.1" + }, + "requests-2.20.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=2.7,<2.8.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "41f9d86d8815f3447732302b1110fd83", + "name": "requests", + "sha256": "47859824085b1979e46835e2bc66e45d78fc5c8c33c480d949873080dde129c4", + "size": 85512, + "subdir": "linux-64", + "timestamp": 1540229658467, + "version": "2.20.0" + }, + "requests-2.20.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "b99a8b9169612226d719c668fc23388a", + "name": "requests", + "sha256": "7378a84763e2fe3bb44e4a91fda2afc11e60fc1d7c33a0268cfbf6e085fefaf1", + "size": 86666, + "subdir": "linux-64", + "timestamp": 1540229688940, + "version": "2.20.0" + }, + "requests-2.20.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "41602dc9c2ea961d45c4bd9b4a6f9fa3", + "name": "requests", + "sha256": "baf067ccb0a2385395717aa9d0c022cd692b6eb5a255888404c2df458913ef1f", + "size": 86420, + "subdir": "linux-64", + "timestamp": 1540229690297, + "version": "2.20.0" + }, + "requests-2.20.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=2.7,<2.8.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "0b66668cca51930d568cedc7d36c01e0", + "name": "requests", + "sha256": "fb8db4f681f8bf2dd0963ffd16f22bd37718ee20cfbfe8fec5c8caa60f7b4886", + "size": 85671, + "subdir": "linux-64", + "timestamp": 1542089094363, + "version": "2.20.1" + }, + "requests-2.20.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "163cd84b72211bf83bfffa6c1fedff4e", + "name": "requests", + "sha256": "d0fa81e47809247b032c5c1b31be6463de371c1aa97d69f61ba5de4adeac2e16", + "size": 86784, + "subdir": "linux-64", + "timestamp": 1542089131734, + "version": "2.20.1" + }, + "requests-2.20.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "44e11ab982a97a8971bfaaa0074cfc26", + "name": "requests", + "sha256": "dc19b6992595dd87d14e4c38292c2c64a53bc869d095e746a40d980697eeccaa", + "size": 86519, + "subdir": "linux-64", + "timestamp": 1542089074976, + "version": "2.20.1" + }, + "requests-2.21.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=2.7,<2.8.0a0", + "urllib3 >=1.21.1,<1.25" + ], + "license": "Apache 2.0", + "md5": "c0e05292e06a016ad9bbd59e3e8fa17c", + "name": "requests", + "sha256": "16a2f430e401bc55eebaf571ea953134a1dacba447e2aeff5efc70168fa1e681", + "size": 85793, + "subdir": "linux-64", + "timestamp": 1545070280718, + "version": "2.21.0" + }, + "requests-2.21.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.25" + ], + "license": "Apache 2.0", + "md5": "01c0b4e8a4a69d2ec11efbb02feeb98a", + "name": "requests", + "sha256": "8b99d83f5c259202d86938f1130e693d75cdf05f6c9ba8b418721a8e40105f25", + "size": 86802, + "subdir": "linux-64", + "timestamp": 1545070298365, + "version": "2.21.0" + }, + "requests-2.21.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.21.1,<1.25" + ], + "license": "Apache 2.0", + "md5": "420c7f30bb8801aae6f2f9eaabfb9f57", + "name": "requests", + "sha256": "045014a12c5a8f0bd16f089ec205bb178c476c63f0e37fd728baabadf60885ac", + "size": 86539, + "subdir": "linux-64", + "timestamp": 1545070316135, + "version": "2.21.0" + }, + "requests-2.22.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=2.7,<2.8.0a0", + "urllib3 >=1.21.1,<1.25" + ], + "license": "Apache 2.0", + "md5": "c6202417d1e98695ce02cc98eae5bfed", + "name": "requests", + "sha256": "cbe7335bb2a6002f8a3ea93f1683c6c90e23ae7dd367077671668d71c3d9ec69", + "size": 90625, + "subdir": "linux-64", + "timestamp": 1559573536683, + "version": "2.22.0" + }, + "requests-2.22.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=2.7,<2.8.0a0", + "urllib3 >=1.21.1,<1.26,!=1.25.0,!=1.25.1" + ], + "license": "Apache 2.0", + "md5": "bd41e8b474b4d584be5fbc44608e5ff5", + "name": "requests", + "sha256": "52bdf38d3ad9f52f1c3fe4ebf4fa789d2d521e54c2c4e5e30774bb8f0e71c636", + "size": 91166, + "subdir": "linux-64", + "timestamp": 1575481880655, + "version": "2.22.0" + }, + "requests-2.22.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.25" + ], + "license": "Apache 2.0", + "md5": "5d2659cef9a1832bd8a175f091071c7b", + "name": "requests", + "sha256": "b29687d0fac75f43ec87735273ebc5c027632238fc61e0ce5a51458b49fa66dc", + "size": 91623, + "subdir": "linux-64", + "timestamp": 1559573573080, + "version": "2.22.0" + }, + "requests-2.22.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.26,!=1.25.0,!=1.25.1" + ], + "license": "Apache 2.0", + "md5": "2e53ff2c2bdff8c09ad1133173eaa4a4", + "name": "requests", + "sha256": "a217e79fb70a56ada772d2c4ddebaad375d0b7b18e205d923f166f8736069223", + "size": 92231, + "subdir": "linux-64", + "timestamp": 1575481888101, + "version": "2.22.0" + }, + "requests-2.22.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.21.1,<1.25" + ], + "license": "Apache 2.0", + "md5": "da1a538617d0d6444ffb1efddb42b860", + "name": "requests", + "sha256": "9314f425d838c256fd84bc04bd62d27eec3199c76871c296a41e2ba473835ff0", + "size": 91321, + "subdir": "linux-64", + "timestamp": 1559573536076, + "version": "2.22.0" + }, + "requests-2.22.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.21.1,<1.26,!=1.25.0,!=1.25.1" + ], + "license": "Apache 2.0", + "md5": "9dc5278bb7800b57506ada805b0e9fa2", + "name": "requests", + "sha256": "b434d875ac6ab7c933f88b9c64338e16d5a36ab789061efd4fbc5be66dd55383", + "size": 92019, + "subdir": "linux-64", + "timestamp": 1575481897731, + "version": "2.22.0" + }, + "requests-2.22.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=3.8,<3.9.0a0", + "urllib3 >=1.21.1,<1.25" + ], + "license": "Apache 2.0", + "md5": "a18acf43d1254d9c214340ef9ec1b27c", + "name": "requests", + "sha256": "72d11e29ee6f0395f169a8289030147c23a14b18a04d4a24b06a275d332ad3b7", + "size": 86924, + "subdir": "linux-64", + "timestamp": 1574235876389, + "version": "2.22.0" + }, + "requests-2.22.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=3.8,<3.9.0a0", + "urllib3 >=1.21.1,<1.26,!=1.25.0,!=1.25.1" + ], + "license": "Apache 2.0", + "md5": "58123d7bdfaf4df73006932cab086263", + "name": "requests", + "sha256": "ec0fae2616875b6f126743ebc3d52931927a30edf2ab42a14ae42023eb001501", + "size": 92278, + "subdir": "linux-64", + "timestamp": 1575481895953, + "version": "2.22.0" + }, + "requests-2.23.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<4", + "idna >=2.5,<3", + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.26,!=1.25.0,!=1.25.1" + ], + "license": "Apache-2.0", + "md5": "0d3688433bbfe31eee2b74dbe52a8272", + "name": "requests", + "sha256": "1eea6437682d138fa1fb651ebc035d1c5de60864fc9b15cc39ad9c6966b1ab9a", + "size": 93204, + "subdir": "linux-64", + "timestamp": 1584021700667, + "version": "2.23.0" + }, + "requests-2.23.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<4", + "idna >=2.5,<3", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.21.1,<1.26,!=1.25.0,!=1.25.1" + ], + "license": "Apache-2.0", + "md5": "e60680dc2863c1bda20990541a48496e", + "name": "requests", + "sha256": "c529e7d5c9da8b37d9f96d0e0eed35d03b757340b98b3056c10f16b8976731e0", + "size": 92939, + "subdir": "linux-64", + "timestamp": 1584021638562, + "version": "2.23.0" + }, + "requests-2.23.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<4", + "idna >=2.5,<3", + "python >=3.8,<3.9.0a0", + "urllib3 >=1.21.1,<1.26,!=1.25.0,!=1.25.1" + ], + "license": "Apache-2.0", + "md5": "dab0ca3201a463e071e4e79bdca32113", + "name": "requests", + "sha256": "378c479909c9843a4b62ddb034b025b2c4f24c1b553e098e5937559800c54d00", + "size": 93191, + "subdir": "linux-64", + "timestamp": 1584021688433, + "version": "2.23.0" + }, + "requests-2.28.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2.0.0,<2.1.0", + "idna >=2.5,<4", + "python >=3.10,<3.11.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "de117c3a6be0ff776b2b3cd4b361f458", + "name": "requests", + "sha256": "8beae6cf13907ddb968154abcd68dab6378c8e33b18ee86664eb1c539d3f355a", + "size": 94944, + "subdir": "linux-64", + "timestamp": 1656438196490, + "version": "2.28.0" + }, + "requests-2.28.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2.0.0,<2.1.0", + "idna >=2.5,<4", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cde097c914766895aed287679ef087b5", + "name": "requests", + "sha256": "d1377ed063da4b05b398e2d27d65c65baed65a39ebfd153b50c4949571a7995a", + "size": 93529, + "subdir": "linux-64", + "timestamp": 1656438308386, + "version": "2.28.0" + }, + "requests-2.28.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2.0.0,<2.1.0", + "idna >=2.5,<4", + "python >=3.8,<3.9.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f9ef67c6c3e4f6df855455040e8dce7c", + "name": "requests", + "sha256": "d90f4ca8e936603f50fd067baa8317cde5748538abf35ba963d9fd5d7c9b9d34", + "size": 93768, + "subdir": "linux-64", + "timestamp": 1656438270721, + "version": "2.28.0" + }, + "requests-2.28.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2.0.0,<2.1.0", + "idna >=2.5,<4", + "python >=3.9,<3.10.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cf907fabc6eaa0a5a09355001dd0b003", + "name": "requests", + "sha256": "5055851b9cf4c5302764b221d23e9cde596eb12d66b659744ae0a9972428d7bf", + "size": 93943, + "subdir": "linux-64", + "timestamp": 1656438234302, + "version": "2.28.0" + }, + "requests-2.28.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2.0.0,<3", + "idna >=2.5,<4", + "python >=3.10,<3.11.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2fd9d5e9fc579b514311139f644ffa31", + "name": "requests", + "sha256": "fd26954e989b870f9b1ed6a0e1879043b5535783bc879932a9d430ca88f3974e", + "size": 94922, + "subdir": "linux-64", + "timestamp": 1657734711809, + "version": "2.28.1" + }, + "requests-2.28.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "constrains": [ + "chardet >=3.0.2,<6" + ], + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2,<3", + "idna >=2.5,<4", + "python >=3.10,<3.11.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "39034e243012bb95de29d251252981ae", + "name": "requests", + "sha256": "3fbecb551a644f08484798e092ecaf04fe32c7ab155576b8c4b4b8ab58f3f9b8", + "size": 95421, + "subdir": "linux-64", + "timestamp": 1678709752617, + "version": "2.28.1" + }, + "requests-2.28.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2.0.0,<3", + "idna >=2.5,<4", + "python >=3.11,<3.12.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6e4866bb2dcdff7eb1aba1f687e70d98", + "name": "requests", + "sha256": "1d12610ca939dabb2eb4aa364971b1f8b2d064b7ad77b8117ad35f6e954f2eb7", + "size": 120070, + "subdir": "linux-64", + "timestamp": 1676822846829, + "version": "2.28.1" + }, + "requests-2.28.1-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "constrains": [ + "chardet >=3.0.2,<6" + ], + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2,<3", + "idna >=2.5,<4", + "python >=3.11,<3.12.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4fd60352ebda900ebdee51bf44ed6c3e", + "name": "requests", + "sha256": "135bf64dead0866ded5eb78360687521f6a6bf5d39c0127497d3c6688038782b", + "size": 119976, + "subdir": "linux-64", + "timestamp": 1679337635736, + "version": "2.28.1" + }, + "requests-2.28.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2.0.0,<3", + "idna >=2.5,<4", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6ffce18940280a79dad1e2e20bf0653f", + "name": "requests", + "sha256": "7bbc797cdde8567422d760dd62d9a85cdb003cded2085d88f90966078a4d8536", + "size": 93619, + "subdir": "linux-64", + "timestamp": 1657734749243, + "version": "2.28.1" + }, + "requests-2.28.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2.0.0,<3", + "idna >=2.5,<4", + "python >=3.8,<3.9.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9c244e30407cdd8a09cee15ebca4b460", + "name": "requests", + "sha256": "11d55ee1ae7cf44832de484adb371dece1faf5f06e465a8085f99abe203f03d1", + "size": 93818, + "subdir": "linux-64", + "timestamp": 1657734786612, + "version": "2.28.1" + }, + "requests-2.28.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "chardet >=3.0.2,<6" + ], + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2,<3", + "idna >=2.5,<4", + "python >=3.8,<3.9.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c9f375840987eebe4c51e4db45df82a1", + "name": "requests", + "sha256": "1f220849986945cf810828954cadf500c83c15f96b1752faebf6ca2ea9c1043e", + "size": 94180, + "subdir": "linux-64", + "timestamp": 1678709785469, + "version": "2.28.1" + }, + "requests-2.28.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2.0.0,<3", + "idna >=2.5,<4", + "python >=3.9,<3.10.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "022a67a9547db5fdfa024f8bf69ab2ad", + "name": "requests", + "sha256": "1f25bfac4ae6b629548f5f661c2839dc239d8fdea82e078673bb25dd8ce73597", + "size": 93890, + "subdir": "linux-64", + "timestamp": 1657734663449, + "version": "2.28.1" + }, + "requests-2.28.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "chardet >=3.0.2,<6" + ], + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2,<3", + "idna >=2.5,<4", + "python >=3.9,<3.10.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8da8194f6cfbaa7bc89434825fd4e2b7", + "name": "requests", + "sha256": "df22a8650c49d9347859a701b0e65a8556bb490a9840fd25672858529eb7f91c", + "size": 94210, + "subdir": "linux-64", + "timestamp": 1678709817498, + "version": "2.28.1" + }, + "requests-file-1.4.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=1.0.0", + "six" + ], + "license": "Apache", + "md5": "f30b5a05d8c33cdeb166862a529886e4", + "name": "requests-file", + "sha256": "e404ab474fd1a9737147349c60c4c82d00680aeeb364d5755a1a5ee2a275e3a3", + "size": 7776, + "subdir": "linux-64", + "timestamp": 1524232664942, + "version": "1.4.3" + }, + "requests-file-1.4.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=1.0.0", + "six" + ], + "license": "Apache", + "md5": "efc1a3ec35d173534f96013e089df3e9", + "name": "requests-file", + "sha256": "24bd20410238799e86ec4b3e2194a7c359efc20247597333379aa6f1d405a4d0", + "size": 7872, + "subdir": "linux-64", + "timestamp": 1524232174328, + "version": "1.4.3" + }, + "requests-file-1.4.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=1.0.0", + "six" + ], + "license": "Apache", + "md5": "8e204f0543e1e0a6ec4414fbbd5ecfc6", + "name": "requests-file", + "sha256": "75c1988670d1391e2d14c42b95016fb478a95150aa0c00ce032d009451e38b45", + "size": 7854, + "subdir": "linux-64", + "timestamp": 1524232800769, + "version": "1.4.3" + }, + "requests-file-1.4.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=1.0.0", + "six" + ], + "license": "Apache", + "md5": "446f55c2636209f3062d2316b8220438", + "name": "requests-file", + "sha256": "12f4940b5d90313b4c94584a5952ca89bcd3059de0fc065a32d5859fb0005f1c", + "size": 7727, + "subdir": "linux-64", + "timestamp": 1530903210978, + "version": "1.4.3" + }, + "requests-ftp-0.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.3.0", + "wsgiref" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "add58395bea9417b3a87a62eb772ea48", + "name": "requests-ftp", + "sha256": "054cb2b94f66d7cfdf3759aeb1e8c74e23aae85eaa64a19ebc6741308c5f128e", + "size": 13837, + "subdir": "linux-64", + "timestamp": 1530904659486, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "7e22f12951b04e6f4ba8a3bcfd9a79dd", + "name": "requests-ftp", + "sha256": "b0de35cf4ea9ab9a4e6924aad983e03505c8387f2e0d9ec9a9afc0b2660814d0", + "size": 13959, + "subdir": "linux-64", + "timestamp": 1539188983907, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "2e026a54b63014381ea135710a4bff42", + "name": "requests-ftp", + "sha256": "94a49143e3b4086c3c34e5bec38db6adc81c1be20ebb742ba665ce0709e49f4a", + "size": 14323, + "subdir": "linux-64", + "timestamp": 1640794369740, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "ab171d871c2eeaf791676e8cac56cc36", + "name": "requests-ftp", + "sha256": "c2d87e45a5d2fa3b32a3ea6ac6371ab0976b5dcde519a4b957876ca14bee6f04", + "size": 17171, + "subdir": "linux-64", + "timestamp": 1676861853795, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "fd67a955dd9ae715bc587dd167285a58", + "name": "requests-ftp", + "sha256": "4af0875effc29747aa8435d28945036920de947483423386aa8a31059bcaf21c", + "size": 14089, + "subdir": "linux-64", + "timestamp": 1530903266153, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "f27cb3668aa096bfb0c0d84cd7b9f6b1", + "name": "requests-ftp", + "sha256": "b7cddacc6a2475c58757e3dfd061882b87d6c3ee7217bfcf16be45a785be184b", + "size": 14229, + "subdir": "linux-64", + "timestamp": 1539189030636, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "b17ff86d8ecde797eca08ec5910e1c33", + "name": "requests-ftp", + "sha256": "540675d520adde1b42bf4ea15219af5143c0b812477b64fd1bbe3b3646672732", + "size": 15180, + "subdir": "linux-64", + "timestamp": 1613470645527, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "1fda98681cc3fccea1aa208a537c8f55", + "name": "requests-ftp", + "sha256": "97bc3096739925ed2753caf977fdf27fe4bf22070e9d28dd85d01c99d8dffa80", + "size": 14094, + "subdir": "linux-64", + "timestamp": 1530903237367, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "7ff9b02eb4f330d04cb926f7b4668f7d", + "name": "requests-ftp", + "sha256": "383884d7762ea27356b48a87580b3017b07dcce48582796c112446b7670d2df1", + "size": 14238, + "subdir": "linux-64", + "timestamp": 1539189018758, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "886903b37dbdd19c8cccdc2ed491e5f7", + "name": "requests-ftp", + "sha256": "214110fb781a7b2c8f374d429a2ce548092e0642027c2009731d36e434d5de27", + "size": 15199, + "subdir": "linux-64", + "timestamp": 1613470017963, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "65d942f2d3ece1400fc8675ecd01ec72", + "name": "requests-ftp", + "sha256": "6cfc87b8596673acf2a0038d5922ed71515e88be54bc0e98c04ebc45ffbbf787", + "size": 15215, + "subdir": "linux-64", + "timestamp": 1613470635453, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "eebf53f174bda563fd44f17b1413fa50", + "name": "requests-ftp", + "sha256": "7ea9acf12b46c652ae65697d3134ff698474a7169e2ad85a7c5f99b8219246b2", + "size": 15261, + "subdir": "linux-64", + "timestamp": 1613470636061, + "version": "0.3.1" + }, + "requests-futures-1.0.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "6648ae493ffa19f5c1c9aa4b82f5e5f3", + "name": "requests-futures", + "sha256": "fd1f509da432b4640a5086c31052a6d48491b99af97f2f082d862199fdf5281d", + "size": 12345, + "subdir": "linux-64", + "timestamp": 1642519750190, + "version": "1.0.0" + }, + "requests-futures-1.0.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "03fe3d6281bb94f32373a64e885282bb", + "name": "requests-futures", + "sha256": "9b421ffd2deebc57ddac74b63a36f3cff7993334db1e2d251df697d4edafe35f", + "size": 13953, + "subdir": "linux-64", + "timestamp": 1676845677203, + "version": "1.0.0" + }, + "requests-futures-1.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "0f55992c69218ae2356b3632bd65eb95", + "name": "requests-futures", + "sha256": "21c814eabf9564923bdca3c5a80e04e9b929eb8f8dbec9d20c626b2e7f94bd04", + "size": 14619, + "subdir": "linux-64", + "timestamp": 1582139047619, + "version": "1.0.0" + }, + "requests-futures-1.0.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "abd01e512547a46eb4ec1ace3e61fbec", + "name": "requests-futures", + "sha256": "1829707595b49e117f35d1066ff2ebf79052001b6944ec31e2657b2c119b1ad7", + "size": 14795, + "subdir": "linux-64", + "timestamp": 1632756981716, + "version": "1.0.0" + }, + "requests-futures-1.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "0a4e0060b81eed2fb68572b438b7bbc9", + "name": "requests-futures", + "sha256": "035ca4ba52e5610d4bff8fd3d39fb31b62f6e77f40837fe9d4de10ca3bf7ce00", + "size": 14640, + "subdir": "linux-64", + "timestamp": 1582139037997, + "version": "1.0.0" + }, + "requests-futures-1.0.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "6deb910af7b11e1846c30f1b82fb11ed", + "name": "requests-futures", + "sha256": "633b416d51eb297582600aeccdf9c050b053e8e100c8bf2622021381cf7451a3", + "size": 11541, + "subdir": "linux-64", + "timestamp": 1594401712301, + "version": "1.0.0" + }, + "requests-futures-1.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "f957641bf8824035cdba027e74f9de9e", + "name": "requests-futures", + "sha256": "c571a1bf82c56d108da9bbb4c8d636a75f0f188be32a825fb78c92ce9fa8a5dc", + "size": 14787, + "subdir": "linux-64", + "timestamp": 1632756972536, + "version": "1.0.0" + }, + "requests-futures-1.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "7d96e40589c9fedd47c509eb0454cab5", + "name": "requests-futures", + "sha256": "d4a3925fe58d006538f3b8320b8d268c5188e40ad69bbb055778bb182e77a1e1", + "size": 14658, + "subdir": "linux-64", + "timestamp": 1582139120118, + "version": "1.0.0" + }, + "requests-futures-1.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "b02840cdd08bb63fd999e23b5a854afb", + "name": "requests-futures", + "sha256": "129ce4c23a6d7bd32fc17f9cc38987fb035ab0ebdd7a2b2fde57fb51fa292949", + "size": 14812, + "subdir": "linux-64", + "timestamp": 1632756923358, + "version": "1.0.0" + }, + "requests-futures-1.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "db372339a596f531bc4aea38022535c8", + "name": "requests-futures", + "sha256": "967e14cc9836c0e0db3dae35fcb391d6f76c9c9e93d2ee1b0f4432e56b0de8cf", + "size": 14821, + "subdir": "linux-64", + "timestamp": 1632746602114, + "version": "1.0.0" + }, + "requests-kerberos-0.11.0-py27hd0065c0_1.tar.bz2": { + "build": "py27hd0065c0_1", + "build_number": 1, + "depends": [ + "pykerberos >=1.1.8,<2.0.0", + "python >=2.7,<2.8.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "a3578547bddfb4c8d901b50a9db0a9bf", + "name": "requests-kerberos", + "sha256": "b96be12aa1687467d2f9159b651136c5f30591ddaade167044c31411bf1d7a06", + "size": 14408, + "subdir": "linux-64", + "timestamp": 1505851542021, + "version": "0.11.0" + }, + "requests-kerberos-0.11.0-py35hf52cdc7_1.tar.bz2": { + "build": "py35hf52cdc7_1", + "build_number": 1, + "depends": [ + "pykerberos >=1.1.8,<2.0.0", + "python >=3.5,<3.6.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "2a653a44b802616c2e555e672dd18805", + "name": "requests-kerberos", + "sha256": "0656c92303e02dfd0d40fd7adeb5bf7b2dd183d767da47efe40873e3b020baf9", + "size": 14624, + "subdir": "linux-64", + "timestamp": 1505851554146, + "version": "0.11.0" + }, + "requests-kerberos-0.11.0-py36h333c0e5_1.tar.bz2": { + "build": "py36h333c0e5_1", + "build_number": 1, + "depends": [ + "pykerberos >=1.1.8,<2.0.0", + "python >=3.6,<3.7.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "c25cfabe0104a2f954055fb3fce509b5", + "name": "requests-kerberos", + "sha256": "41a5223b2305215f5ef4a2f385a5131987fde9fc819b2151d1ea143a349c3100", + "size": 14674, + "subdir": "linux-64", + "timestamp": 1505851566335, + "version": "0.11.0" + }, + "requests-kerberos-0.12.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=2.7,<2.8.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "2ae3d5a04c9b978e66b525bce6e975e2", + "name": "requests-kerberos", + "sha256": "39d2074e7f35cd356d076d80b858c6b6c4aa2beab9f62d7d8350422ad1eeff90", + "size": 17659, + "subdir": "linux-64", + "timestamp": 1519482809012, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py310h06a4308_3.tar.bz2": { + "build": "py310h06a4308_3", + "build_number": 3, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.10,<3.11.0a0", + "requests >=1.1.0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "7156fe945b6e8649b437261c675c817f", + "name": "requests-kerberos", + "sha256": "eb53ea60311e876b78d50e327b0f58522c9e0863e11e61327c50fa44f62ebb69", + "size": 19610, + "subdir": "linux-64", + "timestamp": 1642519767844, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py311h06a4308_3.tar.bz2": { + "build": "py311h06a4308_3", + "build_number": 3, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.11,<3.12.0a0", + "requests >=1.1.0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "f0700bffbddf3eab774ed542e2b44877", + "name": "requests-kerberos", + "sha256": "5ac81cfa52d5405c4dfa72667ba9765c45cc76cf2f96f24b6e92747dc3bd0c5c", + "size": 23616, + "subdir": "linux-64", + "timestamp": 1676842430193, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.5,<3.6.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "a83a4f9d3aeeb379f1bf37eccc38bed4", + "name": "requests-kerberos", + "sha256": "20ea44882243c4111a7cfd5f4f1167e6e8a3478f859b7c4e749362f28da83f5f", + "size": 17940, + "subdir": "linux-64", + "timestamp": 1519482817427, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.6,<3.7.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "9f97c49dd805e67565d2656fe07f602d", + "name": "requests-kerberos", + "sha256": "7ebf00800595afed8bc79d381ef35a001c3bae2aaf5888039c362b51d3b51dae", + "size": 17918, + "subdir": "linux-64", + "timestamp": 1519482778492, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.6,<3.7.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "2dc718b5f079fc31ce38cf415ee16b6b", + "name": "requests-kerberos", + "sha256": "66570cf820ce5e4c92cc4ac0583be19ed8c9036a3466108f21efee12797f1735", + "size": 236602, + "subdir": "linux-64", + "timestamp": 1613393670364, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.7,<3.8.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "68a871e6cf6b053a77b6439c95e9ded7", + "name": "requests-kerberos", + "sha256": "51ded395159be59a2f5f0bb3001a5d34824e1e844d0e0a3a2141707c225833be", + "size": 17807, + "subdir": "linux-64", + "timestamp": 1530922653289, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.7,<3.8.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "c8faeb0fad698ae1af77af9cb47c9590", + "name": "requests-kerberos", + "sha256": "21c77e1ed5e2ed058845b5985b57c38e46591f76ae220bccf1b52921c0433362", + "size": 235403, + "subdir": "linux-64", + "timestamp": 1613393556462, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.8,<3.9.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "3482f74e1f9977414e613d15acdacfa2", + "name": "requests-kerberos", + "sha256": "3dfedfa8599029c2c1b5e9b35b149fc4eeabe252629bc3b033ad44f836472aab", + "size": 189602, + "subdir": "linux-64", + "timestamp": 1594937565615, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.8,<3.9.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "3738f90a89b46097aae10b03eea0f5ac", + "name": "requests-kerberos", + "sha256": "65801a6196e78c3bc571a75bb39d2175962435d30062f3bf503c3e477cfd2503", + "size": 235903, + "subdir": "linux-64", + "timestamp": 1613393664975, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.9,<3.10.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "ae129bf987d8cb6c39960d8ee9523c48", + "name": "requests-kerberos", + "sha256": "2030d4b66a778712bff906e808f52ace92087d933d130771f4de9b0e493d535d", + "size": 236044, + "subdir": "linux-64", + "timestamp": 1613393668408, + "version": "0.12.0" + }, + "requests-oauthlib-0.8.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "oauthlib >=0.6.2", + "python >=2.7,<2.8.0a0", + "requests >=2.0.0" + ], + "license": "ISC", + "md5": "f37ece476ec9646f47d50a691fb7dd09", + "name": "requests-oauthlib", + "sha256": "9dbaccc4818db1e7831a72e8234da68341c9b5e339cb816ff8f0fdbf23761a3e", + "size": 27781, + "subdir": "linux-64", + "timestamp": 1525813672924, + "version": "0.8.0" + }, + "requests-oauthlib-0.8.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "oauthlib >=0.6.2", + "python >=3.5,<3.6.0a0", + "requests >=2.0.0" + ], + "license": "ISC", + "md5": "5c103ffc0684375c8384c29d9c839f1c", + "name": "requests-oauthlib", + "sha256": "4e015ddc43cfed2da1bad4a3bcc4ef0280fd2acb40cfa7211dd70ff0ec490ee6", + "size": 28184, + "subdir": "linux-64", + "timestamp": 1525813844004, + "version": "0.8.0" + }, + "requests-oauthlib-0.8.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "oauthlib >=0.6.2", + "python >=3.6,<3.7.0a0", + "requests >=2.0.0" + ], + "license": "ISC", + "md5": "c3ee192952dd8d094c97d9b5e875782b", + "name": "requests-oauthlib", + "sha256": "ed9437877cd89c27c2cccf183ebc5266317a3cfbd5c58b0060b14659ab7f0302", + "size": 28116, + "subdir": "linux-64", + "timestamp": 1525813820387, + "version": "0.8.0" + }, + "requests-oauthlib-1.0.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "oauthlib >=0.6.2", + "python >=2.7,<2.8.0a0", + "requests >=2.0.0" + ], + "license": "ISC", + "md5": "98da7920f9561241d2b94dbf23069793", + "name": "requests-oauthlib", + "sha256": "661d0cc7142e7fd3eb0cc0438522cf8f248981f972cc3f6efdf2851ef975beec", + "size": 28220, + "subdir": "linux-64", + "timestamp": 1529438939624, + "version": "1.0.0" + }, + "requests-oauthlib-1.0.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "oauthlib >=0.6.2", + "python >=3.5,<3.6.0a0", + "requests >=2.0.0" + ], + "license": "ISC", + "md5": "b55a3f0232d6daa0ff1b131b6c172468", + "name": "requests-oauthlib", + "sha256": "e00a7833fb091a12b3df1b991f189cd9e6b36874c160209dd22b57c11770816a", + "size": 28657, + "subdir": "linux-64", + "timestamp": 1529438940530, + "version": "1.0.0" + }, + "requests-oauthlib-1.0.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "oauthlib >=0.6.2", + "python >=3.6,<3.7.0a0", + "requests >=2.0.0" + ], + "license": "ISC", + "md5": "763adf5f6431f7c67bc7433be0b2166f", + "name": "requests-oauthlib", + "sha256": "8ad9bb31ff402823e6bf38c07ac72bc583bf694cdabdba5464227827719be818", + "size": 28664, + "subdir": "linux-64", + "timestamp": 1529439148555, + "version": "1.0.0" + }, + "requests-oauthlib-1.0.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "oauthlib >=0.6.2", + "python >=3.7,<3.8.0a0", + "requests >=2.0.0" + ], + "license": "ISC", + "md5": "209125a3f305812c7d49477ba9fd86de", + "name": "requests-oauthlib", + "sha256": "dd8caec09e00fd21031aec7e0b4c6769ee685fcf7c61983388da1d8f27a3eb92", + "size": 28909, + "subdir": "linux-64", + "timestamp": 1545089337022, + "version": "1.0.0" + }, + "requests-toolbelt-0.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.0.1,<3.0.0" + ], + "license": "Apache-2.0", + "md5": "170533f5c88ba6fec2d1d9fbedbb1259", + "name": "requests-toolbelt", + "sha256": "6ac27390a0fea31e15d7c5e0e139ba57a92106638b3d49f51e6d7544c7a35db0", + "size": 61290, + "subdir": "linux-64", + "timestamp": 1522177800202, + "version": "0.8.0" + }, + "requests-toolbelt-0.8.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.0.1,<3.0.0" + ], + "license": "Apache-2.0", + "md5": "883ac440622ebcf374a736b36e67da74", + "name": "requests-toolbelt", + "sha256": "ac6870300223fc40846eb62066e86dd80b27c330212dd3611f0d58bde28d949f", + "size": 62947, + "subdir": "linux-64", + "timestamp": 1522178108833, + "version": "0.8.0" + }, + "requests-toolbelt-0.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.0.1,<3.0.0" + ], + "license": "Apache-2.0", + "md5": "9b5ee9da95ff0c3a1d2140c67b917fdc", + "name": "requests-toolbelt", + "sha256": "cbac31380f822e4fc40ad11ac2378059313f762b4c30005b2de7e82a5fdfd726", + "size": 62908, + "subdir": "linux-64", + "timestamp": 1522177537700, + "version": "0.8.0" + }, + "requests-toolbelt-0.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.0.1,<3.0.0" + ], + "license": "Apache-2.0", + "md5": "b063a9bfafe1f159c017fd0f52cc1136", + "name": "requests-toolbelt", + "sha256": "7a31e4bd787e3e9297d69a6c0ad7d5350e3344897aa5e0d06a16befc4d1ea909", + "size": 62848, + "subdir": "linux-64", + "timestamp": 1530959315562, + "version": "0.8.0" + }, + "requests-wsgi-adapter-0.4.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "requests >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b31789741b80cecc3f0bc42f20aa9054", + "name": "requests-wsgi-adapter", + "sha256": "3bdd0186425dba06ed43afb667a8841640f661bc800016a17b76613c07b29c91", + "size": 11203, + "subdir": "linux-64", + "timestamp": 1669051478499, + "version": "0.4.1" + }, + "requests-wsgi-adapter-0.4.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "requests >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "317ee3422ea995c64a74d303129e8c93", + "name": "requests-wsgi-adapter", + "sha256": "ead605ec3871b5e27f95ff87f4501cea5b45365384326e61427872603a61f021", + "size": 13606, + "subdir": "linux-64", + "timestamp": 1676861868700, + "version": "0.4.1" + }, + "requests-wsgi-adapter-0.4.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "803d68551b90dfebbd7b1a2b325d4139", + "name": "requests-wsgi-adapter", + "sha256": "5f0218b8176924d177522b45b7bccd256c43cfb8c4b1cc24d8e5f6330d1d367c", + "size": 11022, + "subdir": "linux-64", + "timestamp": 1669051504796, + "version": "0.4.1" + }, + "requests-wsgi-adapter-0.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b56b22d00f110095476cf6e166bf956e", + "name": "requests-wsgi-adapter", + "sha256": "f12494c86c936249c04a3d7254e4bec19d90e4d1c6fc4c937013b0fb73dabe77", + "size": 11047, + "subdir": "linux-64", + "timestamp": 1669051426276, + "version": "0.4.1" + }, + "requests-wsgi-adapter-0.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d297404f3182dae5260fe4d749d53fad", + "name": "requests-wsgi-adapter", + "sha256": "1615d23bf6299d42e6793c18041f4e3ae0fa5bcdd461185a109924d54b1986b7", + "size": 11030, + "subdir": "linux-64", + "timestamp": 1669051452519, + "version": "0.4.1" + }, + "requests_download-0.1.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "MIT", + "md5": "90463ef89f0bc6ec52cc1d191b5e9823", + "name": "requests_download", + "sha256": "5f4c4d7ba14ee2196bc37129e064f44f8565ef5e532e9d4d58e1d8d4e0eda64c", + "size": 8143, + "subdir": "linux-64", + "timestamp": 1642519836455, + "version": "0.1.2" + }, + "requests_download-0.1.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "MIT", + "md5": "24573901f7773b514ebe7168da94e091", + "name": "requests_download", + "sha256": "fe4c4dadb902cd2122dec1fae1a4da303cf5dcda42d84c9e85cd44a082fa7a87", + "size": 7563, + "subdir": "linux-64", + "timestamp": 1529945288293, + "version": "0.1.2" + }, + "requests_download-0.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "MIT", + "md5": "c4dcf59f676274f890640b7eee22a9d6", + "name": "requests_download", + "sha256": "6f38365ea5f2eda7226cecb0e335280510c902c2e011c12a54728671592b6e2e", + "size": 7532, + "subdir": "linux-64", + "timestamp": 1529945142061, + "version": "0.1.2" + }, + "requests_download-0.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "MIT", + "md5": "ac4e9bd1ebe4fc530e5e672bd502a237", + "name": "requests_download", + "sha256": "dea6f993afeff482687eedfb1e0b62b0d34e13fc6c9b7e4b9bd1fe306f83af77", + "size": 7530, + "subdir": "linux-64", + "timestamp": 1530898082505, + "version": "0.1.2" + }, + "requests_download-0.1.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "MIT", + "md5": "2f091cf80a489f1857535d06ff05723f", + "name": "requests_download", + "sha256": "ec375d4e1a4e2fbb6ceb045fbda84bcae91f3c4513964837a7c72e3c6a4cfdb3", + "size": 8613, + "subdir": "linux-64", + "timestamp": 1636044918662, + "version": "0.1.2" + }, + "requests_download-0.1.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "MIT", + "md5": "d7e432ae3025dd36dc81e99b314b5d73", + "name": "requests_download", + "sha256": "fc5c75ebd2139d74d0de0d41e8fc2755e20d37482690aae2f226a49d7a9234fe", + "size": 8631, + "subdir": "linux-64", + "timestamp": 1636044844762, + "version": "0.1.2" + }, + "requests_download-0.1.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "MIT", + "md5": "bb6f209efbbe59d17cda21b343b718c6", + "name": "requests_download", + "sha256": "53a19c42d026bc2d11f24c4674e2039c711ab8bc9785a65c41e414aae9c0cdeb", + "size": 8646, + "subdir": "linux-64", + "timestamp": 1636044841201, + "version": "0.1.2" + }, + "resolvelib-0.8.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "62a3640efad4279c4bab6bb90a8840a6", + "name": "resolvelib", + "sha256": "ce9d8af979d6291eda144e04dc3fb6d721c1b2f908ff4c3e8fe117ee80905d30", + "size": 25580, + "subdir": "linux-64", + "timestamp": 1670273526705, + "version": "0.8.1" + }, + "resolvelib-0.8.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "86fa3e674aa08cb6759443eee0423144", + "name": "resolvelib", + "sha256": "23c4e65a3fbb24d3f81303c7cddc6acdc4c61b54c92b413c6e1b17b500f887a4", + "size": 31495, + "subdir": "linux-64", + "timestamp": 1676842445250, + "version": "0.8.1" + }, + "resolvelib-0.8.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "4da70f8eef643c9138c634f3cdbaeea0", + "name": "resolvelib", + "sha256": "1383207bc83d7c6cc9a70211ee8a14a13b00872fe2efa2491a7b8f5fa71d9600", + "size": 25365, + "subdir": "linux-64", + "timestamp": 1670273501910, + "version": "0.8.1" + }, + "resolvelib-0.8.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "0fa3d3777d9915f5fbf22cf1bf261c04", + "name": "resolvelib", + "sha256": "301b3c4988a5852cd63ba5aba5c9a5515482d4ee4568f3505d31c2b54c89044f", + "size": 25459, + "subdir": "linux-64", + "timestamp": 1670273452045, + "version": "0.8.1" + }, + "resolvelib-0.8.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "69a95b5c3e1cb941950b956a32de0261", + "name": "resolvelib", + "sha256": "2f9db00e342bbef1b9cf001d3dda9e3f76dcd186c621a3f61791fdfcad6835f9", + "size": 25453, + "subdir": "linux-64", + "timestamp": 1670273476820, + "version": "0.8.1" + }, + "responses-0.10.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cookies", + "mock", + "python >=2.7,<2.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "05cf2de9ba769328c8f73fc4a4170dce", + "name": "responses", + "sha256": "78db3b8a1cc872691654dca3e073f0925141ed602f5717822ec1e1f509bc99eb", + "size": 30705, + "subdir": "linux-64", + "timestamp": 1542089601861, + "version": "0.10.3" + }, + "responses-0.10.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7438d2ee964b5a7b09bd5f4cfcb9a527", + "name": "responses", + "sha256": "41bcbbd4257b90e9e9bf0db431bad1a44ad8dec8a7c1f0499c3e7d48f70326f0", + "size": 31427, + "subdir": "linux-64", + "timestamp": 1542089611131, + "version": "0.10.3" + }, + "responses-0.10.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "60775d25617eb841a0b757380600947a", + "name": "responses", + "sha256": "33fed1506ab28bf79f62d9e52c5fb4b01fa191ce18c800a657a9b210aa7ff76b", + "size": 31476, + "subdir": "linux-64", + "timestamp": 1542089567396, + "version": "0.10.3" + }, + "responses-0.10.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cookies", + "mock", + "python >=2.7,<2.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b45dceb24d17f5a074b20cb50f40989d", + "name": "responses", + "sha256": "d484050ef1e21b9711ec1765a8c5837dcc28d720669384301cffe8c3a486bee6", + "size": 31556, + "subdir": "linux-64", + "timestamp": 1542393510441, + "version": "0.10.4" + }, + "responses-0.10.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1fca8b48240db7083f48bb45c623692a", + "name": "responses", + "sha256": "10c04a73aec576d22d77d2ab3afff23bfff8f0c7f6f47ed31adce20f11b5bd3e", + "size": 32223, + "subdir": "linux-64", + "timestamp": 1542393540077, + "version": "0.10.4" + }, + "responses-0.10.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5cece978ded9e1a0f5cb4f77bd9df4eb", + "name": "responses", + "sha256": "cb8383891c9a54b8aea4d8ba9b9d8b4ea22239ffe925e041171b892926b59a76", + "size": 32330, + "subdir": "linux-64", + "timestamp": 1542393494367, + "version": "0.10.4" + }, + "responses-0.10.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cookies", + "mock", + "python >=2.7,<2.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "29c7efce4b61141c333150d89383fc0d", + "name": "responses", + "sha256": "bdfd73853075ffb362b435070a6026178b0f3af1fa4df0bc6e47102938d5de69", + "size": 158226, + "subdir": "linux-64", + "timestamp": 1547490137563, + "version": "0.10.5" + }, + "responses-0.10.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "defddf5a329af6b801b789c3b659bb2c", + "name": "responses", + "sha256": "0ed2f0e9beea5682d8877ae1b883426fe475fdd4601f5228fcca10359694f0a0", + "size": 159077, + "subdir": "linux-64", + "timestamp": 1547490151041, + "version": "0.10.5" + }, + "responses-0.10.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f4bb48a6d246f041f9c14d803353b57a", + "name": "responses", + "sha256": "32d3fce024e9b2b96bf693f1c9d2180123f1af9ee591efea79a39af8cdcf7b79", + "size": 159263, + "subdir": "linux-64", + "timestamp": 1547490093522, + "version": "0.10.5" + }, + "responses-0.10.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cookies", + "mock", + "python >=2.7,<2.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ae2e9b93f061a7575f485d1dfa81473f", + "name": "responses", + "sha256": "7b8d937ccd6796f0c2e631b238d9624d1b48563d1afea258642e3b2484cdb6e9", + "size": 164304, + "subdir": "linux-64", + "timestamp": 1564705554470, + "version": "0.10.6" + }, + "responses-0.10.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3b951c54f61a6a69fb32351eb9968a89", + "name": "responses", + "sha256": "e44955d0251655df7da361465e4d03ea1cb99053975cb65b7a7c446367015172", + "size": 164732, + "subdir": "linux-64", + "timestamp": 1564705518553, + "version": "0.10.6" + }, + "responses-0.10.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "37406af398fae0d26448130439d9c68f", + "name": "responses", + "sha256": "bdf9d80cd56827e7eb9178568fc321c7f6227b5b9e7380de59b7120cffa10703", + "size": 164623, + "subdir": "linux-64", + "timestamp": 1564705546992, + "version": "0.10.6" + }, + "responses-0.10.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cookies", + "mock", + "python >=2.7,<2.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ceb2942764e24d63d9b289faca10ce63", + "name": "responses", + "sha256": "0fe65f9f19beac74b9793ac1387ea1f0721e2058cbd709bd7ea836b63c30b98b", + "size": 172577, + "subdir": "linux-64", + "timestamp": 1576248619047, + "version": "0.10.8" + }, + "responses-0.10.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fa95769493aa78ac4aeefedba31e9b65", + "name": "responses", + "sha256": "ce3f452bd008ef50ee005debbd09e435631308f09a3d483c3159a4b32b79f76a", + "size": 172957, + "subdir": "linux-64", + "timestamp": 1576248662209, + "version": "0.10.8" + }, + "responses-0.10.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7f802cdbde0793df1d90e2dba4bd826b", + "name": "responses", + "sha256": "06ad3a653e011cc0b9fc8c78d60f37659fda005d165100e1792188ef16a13afe", + "size": 172981, + "subdir": "linux-64", + "timestamp": 1576248651316, + "version": "0.10.8" + }, + "responses-0.10.8-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "63a574fe47dbffc40c1b2e4a8db469cd", + "name": "responses", + "sha256": "c8f21683e1ab9a169ed503aaf26701786da08a8bd6e52ffa2deefe14c4015e05", + "size": 173043, + "subdir": "linux-64", + "timestamp": 1576248668397, + "version": "0.10.8" + }, + "responses-0.8.1-py27h451b312_0.tar.bz2": { + "build": "py27h451b312_0", + "build_number": 0, + "depends": [ + "cookies", + "python >=2.7,<2.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "56349170377f795fdce5cd33f09fbe0a", + "name": "responses", + "sha256": "e28bec5da198626ad1d99a5a75f8a9b37e67ceafb6ade151552f5718d087698e", + "size": 28332, + "subdir": "linux-64", + "timestamp": 1508217886814, + "version": "0.8.1" + }, + "responses-0.8.1-py35h08f2ab4_0.tar.bz2": { + "build": "py35h08f2ab4_0", + "build_number": 0, + "depends": [ + "cookies", + "python >=3.5,<3.6.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6dbd95275ca912983514659027423019", + "name": "responses", + "sha256": "3171b28336121de2fca5fbc487b85b27008a0cd694650d2718d56ba128f0714e", + "size": 29095, + "subdir": "linux-64", + "timestamp": 1508217772715, + "version": "0.8.1" + }, + "responses-0.8.1-py36hcf147cc_0.tar.bz2": { + "build": "py36hcf147cc_0", + "build_number": 0, + "depends": [ + "cookies", + "python >=3.6,<3.7.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "153260cb1b9e2c6e9ddbdedd90ff9538", + "name": "responses", + "sha256": "33dc5f22810ac5e77ac13b0d1e371d294d25d4e05cd514c15a975b513a1a49e6", + "size": 28989, + "subdir": "linux-64", + "timestamp": 1508217932387, + "version": "0.8.1" + }, + "responses-0.9.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cookies", + "mock", + "python >=2.7,<2.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ebad11428f5220df02c9d32ed86c734f", + "name": "responses", + "sha256": "b156a7ad618505716e4fe782f6c444ecd441dfc4de4d530f6576744ff4ebd049", + "size": 30099, + "subdir": "linux-64", + "timestamp": 1523945115641, + "version": "0.9.0" + }, + "responses-0.9.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cookies", + "python >=3.5,<3.6.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "75def67eebe4ba91240a2490fe93a1df", + "name": "responses", + "sha256": "fb533bf62a834e5816e7bd3f727c9f40030629e400e0f948b6ea399198feab7c", + "size": 30924, + "subdir": "linux-64", + "timestamp": 1523945144331, + "version": "0.9.0" + }, + "responses-0.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cookies", + "python >=3.6,<3.7.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "32cf33f70e657c6cc0cde65a44748491", + "name": "responses", + "sha256": "9742db338c489750c0fe96619bd5fe9f7811d762908269907c402314901b145d", + "size": 30778, + "subdir": "linux-64", + "timestamp": 1523945144291, + "version": "0.9.0" + }, + "responses-0.9.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cookies", + "python >=3.7,<3.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bd65bced5fffc024837f42fe4dd72bfe", + "name": "responses", + "sha256": "d624b45fbcf18a122dfad470db58f8f26072133d32645868dbb0893aab33a6ce", + "size": 30173, + "subdir": "linux-64", + "timestamp": 1530812919601, + "version": "0.9.0" + }, + "retrying-1.3.3-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "63039e76b8c99646089060c8adadc43f", + "name": "retrying", + "sha256": "787469391838c30f7dcab548ebbf10df21523013d30b0cff861863b66b2a8d2e", + "size": 15284, + "subdir": "linux-64", + "timestamp": 1532535254708, + "version": "1.3.3" + }, + "retrying-1.3.3-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "24f517ca5a0cf396b848ac2ec7d56654", + "name": "retrying", + "sha256": "c2c160a1c06b576f54acb0135f937893448a353170ea9e64c6bcacc6fd4b7c3a", + "size": 15540, + "subdir": "linux-64", + "timestamp": 1532535317114, + "version": "1.3.3" + }, + "retrying-1.3.3-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ce93bb8e951a712aa9c482feb67a76d0", + "name": "retrying", + "sha256": "f28a3ee661f1498f736941dbe8dbbee5a65106d1de578ebb62562dd1b6c96907", + "size": 15544, + "subdir": "linux-64", + "timestamp": 1532536448231, + "version": "1.3.3" + }, + "retrying-1.3.3-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "83fa8de071d93df5d5ac8be287e7f7c7", + "name": "retrying", + "sha256": "08ec32ee9d09a986a744262f40adcfd4280c70c7ca27769af5c904d57b37da5d", + "size": 15600, + "subdir": "linux-64", + "timestamp": 1532535323749, + "version": "1.3.3" + }, + "rhash-1.3.5-hbf7ad62_1.tar.bz2": { + "build": "hbf7ad62_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "251fd680786d79894fe03abdd8513fbb", + "name": "rhash", + "sha256": "dcbe967a2ff4cbb9d3ebd6f652b427a95788d26914882c74c9c32324dca6fe0f", + "size": 182005, + "subdir": "linux-64", + "timestamp": 1505687951686, + "version": "1.3.5" + }, + "rhash-1.3.6-h1ba5d50_0.tar.bz2": { + "build": "h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e1229929ff99fe581bacf2e9d3ca225", + "name": "rhash", + "sha256": "ce88d700f5d1ec85480255baabc2b390c1ae6e22b3e0be400aa8f92c218ca3ce", + "size": 189328, + "subdir": "linux-64", + "timestamp": 1540225177390, + "version": "1.3.6" + }, + "rhash-1.3.6-hb7f436b_0.tar.bz2": { + "build": "hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e0bd21bd3ac1cfe64198392b9ee765a", + "name": "rhash", + "sha256": "d75d5936aabcbe2141062d52546c03145d9fed906275db0d142efec5b002fba5", + "size": 188595, + "subdir": "linux-64", + "timestamp": 1528058022109, + "version": "1.3.6" + }, + "rhash-1.3.7-h1ba5d50_0.tar.bz2": { + "build": "h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b28c3a35512319b1cad88875b4ad39bb", + "name": "rhash", + "sha256": "05e0378ca000632fb9aee3b87719172f782d48f8d0c8adab238c48b8b1fece2b", + "size": 214462, + "subdir": "linux-64", + "timestamp": 1547490558933, + "version": "1.3.7" + }, + "rhash-1.3.8-h1ba5d50_0.tar.bz2": { + "build": "h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1b,<1.1.2a" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8ead2420cd69179b6024f61c95f1ee7", + "name": "rhash", + "sha256": "0ac4f06664d1758b6d5ec5348edcbbb129654917602ebce0a11520ec22d1a1ab", + "size": 241014, + "subdir": "linux-64", + "timestamp": 1552511572321, + "version": "1.3.8" + }, + "rhash-1.4.0-h1ba5d50_0.tar.bz2": { + "build": "h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1ca84d42670e34d1366380fe5f5fdcb", + "name": "rhash", + "sha256": "6b0dcccb15123bf28e0f1a768610d2c26b015d723e69af08b58744047b800f9d", + "size": 245703, + "subdir": "linux-64", + "timestamp": 1600432316227, + "version": "1.4.0" + }, + "rhash-1.4.1-h3c74f83_0.tar.bz2": { + "build": "h3c74f83_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4f59b83cada22466f256398a5992de1", + "name": "rhash", + "sha256": "716b9d1a494f755071557960a91603ca7cca0d8aef5939ffb384910306b4c1da", + "size": 253003, + "subdir": "linux-64", + "timestamp": 1610133444516, + "version": "1.4.1" + }, + "rhash-1.4.1-h3c74f83_1.tar.bz2": { + "build": "h3c74f83_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58f86108a48809e122b365357f7d2bda", + "name": "rhash", + "sha256": "a865497bd7218c1c54aa99037eba47ca84f932983df466b3408a6195767d0b0f", + "size": 256861, + "subdir": "linux-64", + "timestamp": 1611089602014, + "version": "1.4.1" + }, + "rich-12.5.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "commonmark >=0.9.0,<0.10.0", + "dataclasses >=0.7,<0.9", + "pygments >=2.6.0,<3.0.0", + "python >=3.10,<3.11.0a0", + "typing_extensions >=4.0.0,<5.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "259a963b734dac0c185a56ef4d5bf3c4", + "name": "rich", + "sha256": "61c828e7c1e8244cedc26ed36d9a712be5148c41ea7e6310570239c4e07c5689", + "size": 429523, + "subdir": "linux-64", + "timestamp": 1659708387121, + "version": "12.5.1" + }, + "rich-12.5.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "commonmark >=0.9.0,<0.10.0", + "dataclasses >=0.7,<0.9", + "pygments >=2.6.0,<3.0.0", + "python >=3.11,<3.12.0a0", + "typing_extensions >=4.0.0,<5.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5c8338b7569afde2e0140b921248748", + "name": "rich", + "sha256": "db2c34ae19bd47c789ec3a08e826d233bc38095a709b0f576daea8adbddef212", + "size": 552199, + "subdir": "linux-64", + "timestamp": 1676904177084, + "version": "12.5.1" + }, + "rich-12.5.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "commonmark >=0.9.0,<0.10.0", + "dataclasses >=0.7,<0.9", + "pygments >=2.6.0,<3.0.0", + "python >=3.7,<3.8.0a0", + "typing_extensions >=4.0.0,<5.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2dc6e3dc123ae086367955c624ddcf5", + "name": "rich", + "sha256": "935bb9b554d2df58d92d688d7408c4a33b052fe04c13528e9fca4892c66af603", + "size": 396252, + "subdir": "linux-64", + "timestamp": 1659708348772, + "version": "12.5.1" + }, + "rich-12.5.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "commonmark >=0.9.0,<0.10.0", + "dataclasses >=0.7,<0.9", + "pygments >=2.6.0,<3.0.0", + "python >=3.8,<3.9.0a0", + "typing_extensions >=4.0.0,<5.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d25c173c56f9066a3c8b654c782d98df", + "name": "rich", + "sha256": "f3fba87b2b293e33d9eadf4f8fa6125604b52182d1029ae87270a317730f9fdd", + "size": 398828, + "subdir": "linux-64", + "timestamp": 1659708319523, + "version": "12.5.1" + }, + "rich-12.5.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "commonmark >=0.9.0,<0.10.0", + "dataclasses >=0.7,<0.9", + "pygments >=2.6.0,<3.0.0", + "python >=3.9,<3.10.0a0", + "typing_extensions >=4.0.0,<5.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "515c63dd7a1888782c936f53f9e14578", + "name": "rich", + "sha256": "7717ab282bc1affabd1129777b1bb60762618a1b09bb9963060c879f4c6c7621", + "size": 398578, + "subdir": "linux-64", + "timestamp": 1659708415289, + "version": "12.5.1" + }, + "ripgrep-0.10.0-hc07d326_0.tar.bz2": { + "build": "hc07d326_0", + "build_number": 0, + "depends": [], + "md5": "ffac7fe45c8f422b45c0eaf7a6f9647a", + "name": "ripgrep", + "sha256": "a7085505badbec5c0654ad1b5ff8570bfa4f8dc8435e4da9973cec8c06b79c84", + "size": 1438447, + "subdir": "linux-64", + "timestamp": 1538175793905, + "version": "0.10.0" + }, + "ripgrep-11.0.2-h0ccce12_0.tar.bz2": { + "build": "h0ccce12_0", + "build_number": 0, + "depends": [], + "md5": "65b8d658cf0127126161dbc3f6673a14", + "name": "ripgrep", + "sha256": "ac83872df453ea455a0b66bb9e24cb2f78ab7ce89cb8f35714582977f049d518", + "size": 1589504, + "subdir": "linux-64", + "timestamp": 1578413933392, + "version": "11.0.2" + }, + "ripgrep-11.0.2-he32d670_0.tar.bz2": { + "build": "he32d670_0", + "build_number": 0, + "depends": [], + "md5": "6ac00ed505a27b05a02ba9e0d905eb08", + "name": "ripgrep", + "sha256": "b260fb8f5430685f3196e7894085686fd78ecdca9cab94b7ef05957be842eff1", + "size": 1536747, + "subdir": "linux-64", + "timestamp": 1578438697374, + "version": "11.0.2" + }, + "ripgrep-12.1.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "md5": "5e6ca5028e467c2fba0616a0b0992764", + "name": "ripgrep", + "sha256": "d772f0f3fcb9bf216417297dbc10a35a74e82fff0d1c3b1930ab879bfa724936", + "size": 1615614, + "subdir": "linux-64", + "timestamp": 1601295780529, + "version": "12.1.1" + }, + "ripgrep-12.1.1-h007679d_0.tar.bz2": { + "build": "h007679d_0", + "build_number": 0, + "depends": [], + "md5": "ed42ccff311c69d1e7f36ad0d92f30fc", + "name": "ripgrep", + "sha256": "8b7aade46399b84b85fd72bb0d5426a53e0e380ec982318c7b3e58b179bd7d33", + "size": 1793958, + "subdir": "linux-64", + "timestamp": 1601295718673, + "version": "12.1.1" + }, + "ripgrep-13.0.0-hbdeaff8_0.tar.bz2": { + "build": "hbdeaff8_0", + "build_number": 0, + "depends": [], + "license": "MIT AND Unlicense", + "license_family": "Other", + "md5": "d779da19cd9367b371d36ca451a4fef1", + "name": "ripgrep", + "sha256": "69f869b46a56f1a66637c1d4c3a19c0d544509189affc1e099ade271d2f853e9", + "size": 1427609, + "subdir": "linux-64", + "timestamp": 1659635547888, + "version": "13.0.0" + }, + "rise-5.4.1-py27_1000.tar.bz2": { + "build": "py27_1000", + "build_number": 1000, + "depends": [ + "jupyter", + "notebook >=5.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3c65a66062c402929d12f48d78e39a8f", + "name": "rise", + "sha256": "9bbe83daa08f81fce5725f05f3038713df28a682e9462e61b97cf464a60c2272", + "size": 2342533, + "subdir": "linux-64", + "timestamp": 1546450877011, + "version": "5.4.1" + }, + "rise-5.4.1-py36_1000.tar.bz2": { + "build": "py36_1000", + "build_number": 1000, + "depends": [ + "jupyter", + "notebook >=5.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2adc27db3b380c69953a63c3d5e6a7ed", + "name": "rise", + "sha256": "e5a5a33efc7742ffd996f8b0c96dd1a82c72502bbd4950b5c66a51dbaf780c29", + "size": 2302436, + "subdir": "linux-64", + "timestamp": 1546450942712, + "version": "5.4.1" + }, + "rise-5.4.1-py37_1000.tar.bz2": { + "build": "py37_1000", + "build_number": 1000, + "depends": [ + "jupyter", + "notebook >=5.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9a9bdd58b6b6330ab6cffc95f6484ff4", + "name": "rise", + "sha256": "8687f240d79fb0fa9ebf7254438c2303bceb5e0aa16a91a3c0115be5040e16be", + "size": 2296081, + "subdir": "linux-64", + "timestamp": 1546450877893, + "version": "5.4.1" + }, + "rise-5.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jupyter", + "notebook >=5.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7244674b26a0ea62de56982870c6761e", + "name": "rise", + "sha256": "703aabb977cf56841e056044cc03fd2f32323b85cfad14c390fad1d380bb7c73", + "size": 2262491, + "subdir": "linux-64", + "timestamp": 1569435742009, + "version": "5.5.1" + }, + "rise-5.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyter", + "notebook >=5.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "76148cc4027a500be637ebfdf79bda34", + "name": "rise", + "sha256": "a4b3f7172725e742ae653d6eb5e3cc45786e826441376722584da78597e98f41", + "size": 2344016, + "subdir": "linux-64", + "timestamp": 1569435748338, + "version": "5.5.1" + }, + "rise-5.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyter", + "notebook >=5.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "98dfa0a4bef8e4774610dd85a69a0a41", + "name": "rise", + "sha256": "105bbbc2c4c248227f9a65fd2b72987751bc1a99159085473934ac46a2409032", + "size": 2308798, + "subdir": "linux-64", + "timestamp": 1569435742207, + "version": "5.5.1" + }, + "rise-5.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fe03c02fa9fa3eb10f96c03b63590d29", + "name": "rise", + "sha256": "afddc91e6ae08b6601877b42dcfe18daa2f3971c0cd565f8adf9b84dee431bf1", + "size": 2485361, + "subdir": "linux-64", + "timestamp": 1573950239179, + "version": "5.6.0" + }, + "rise-5.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "86c6f8ec1e7fab15b6362f786d80ec87", + "name": "rise", + "sha256": "bdc0a5f63bd1b3ba04006642dd1dcce21be25a3adf331f23ff87f6b3348325b2", + "size": 2671864, + "subdir": "linux-64", + "timestamp": 1573950266794, + "version": "5.6.0" + }, + "rise-5.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ac3170c84ad0fbf8a1ceb7652c4a993b", + "name": "rise", + "sha256": "6c94de06fd059b309b163fd0076e5bc6e7ef9a8f417db09cee788146665b2090", + "size": 2573335, + "subdir": "linux-64", + "timestamp": 1573950213415, + "version": "5.6.0" + }, + "rise-5.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8345f49c1ad329e772480e3c2dec4d3e", + "name": "rise", + "sha256": "84e23e74914bc3b960f12d2e2abbec5516a30978a60309d663f153982f3c4a04", + "size": 2500191, + "subdir": "linux-64", + "timestamp": 1582562268519, + "version": "5.6.1" + }, + "rise-5.6.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "24903895249870432f760eb28bcdf912", + "name": "rise", + "sha256": "de92fe796068a6a775b561d4edbef942749cd1607f857f1738f07ac1ffea3446", + "size": 2566853, + "subdir": "linux-64", + "timestamp": 1582562223001, + "version": "5.6.1" + }, + "rise-5.6.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "notebook >=5.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9e288611d2d6f29ab2abfe0c9f26d6a7", + "name": "rise", + "sha256": "d316a8fe7ec7b253b96c901a6c016b8b9efa0727281586b58eaf61d26212fbab", + "size": 2507036, + "subdir": "linux-64", + "timestamp": 1594419379691, + "version": "5.6.1" + }, + "rise-5.6.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d296a67b9d5e9a1bbef8b5aa1780d53b", + "name": "rise", + "sha256": "a802dadd281051c1fe0234eafb2d82e88fc8c95da04661e47973cc08175c6df3", + "size": 2487812, + "subdir": "linux-64", + "timestamp": 1582562241970, + "version": "5.6.1" + }, + "rise-5.7.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f4cb07ac1c07ffe97fb24805156f1858", + "name": "rise", + "sha256": "9069efad559ec0cdf0fb73eee8fa144fd9274b8036db0fb691e316862e602d4a", + "size": 2636324, + "subdir": "linux-64", + "timestamp": 1641919428246, + "version": "5.7.1" + }, + "rise-5.7.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "091ee457a5b51c7cbdfb519744a9f1b1", + "name": "rise", + "sha256": "361ee7431e666d8bfe07f40a638978836f06e1109bdfdb24c5253bdc7968b7d9", + "size": 2731533, + "subdir": "linux-64", + "timestamp": 1676922586317, + "version": "5.7.1" + }, + "rise-5.7.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "43726d0facc36a33cfc2810f297e82a2", + "name": "rise", + "sha256": "6bd0586b3740d29c959317006b4c683b30aeb3129d9b0b6b61ae64dbcdad8114", + "size": 2785833, + "subdir": "linux-64", + "timestamp": 1612306967275, + "version": "5.7.1" + }, + "rise-5.7.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f93a0f4f95bf46a33330164cd192a274", + "name": "rise", + "sha256": "47ce62cad80e680ece435002bc9d49bb1cddbdf19e4a8ac191844ebdcd772819", + "size": 2677327, + "subdir": "linux-64", + "timestamp": 1612307386536, + "version": "5.7.1" + }, + "rise-5.7.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "00ebef250b55524df274ac4bb9148da0", + "name": "rise", + "sha256": "bb19a2a4bdc998561592cd0191987400ac9f7aaac1c0da6681f1fe3c031c8594", + "size": 2697016, + "subdir": "linux-64", + "timestamp": 1612307288438, + "version": "5.7.1" + }, + "rise-5.7.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "10551881c7ed4f163934fcd97a13ac51", + "name": "rise", + "sha256": "917a4714e411619c02d90e113e9dd28f77c94e4c3079acbad860756a6c0a2732", + "size": 2624721, + "subdir": "linux-64", + "timestamp": 1612307383339, + "version": "5.7.1" + }, + "rope-0.10.5-py27hcb0a616_0.tar.bz2": { + "build": "py27hcb0a616_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "GPL 2.0", + "md5": "66f6ecb5b60e9611ba820fd537754ad5", + "name": "rope", + "sha256": "7391196ea87399b1cf992df48611a516b86dcbcf8691f6f5cd658868566e9103", + "size": 277659, + "subdir": "linux-64", + "timestamp": 1505752956811, + "version": "0.10.5" + }, + "rope-0.10.5-py35h31d6b7c_0.tar.bz2": { + "build": "py35h31d6b7c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "GPL 2.0", + "md5": "e24566a39e40287270462666c842fc79", + "name": "rope", + "sha256": "7911eef9ae297bbb706c5cfeae4217410b8ac39bda2138b7c431333b1e4e4466", + "size": 288662, + "subdir": "linux-64", + "timestamp": 1505752977045, + "version": "0.10.5" + }, + "rope-0.10.5-py36h1f8c17e_0.tar.bz2": { + "build": "py36h1f8c17e_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2.0", + "md5": "27acc988bc6dcf9e364831707525b47c", + "name": "rope", + "sha256": "02a7b735dfe1e0edbe0db6e8e69b91707bdfb6c9dc4a1c0dc8a4e324de8165dc", + "size": 285257, + "subdir": "linux-64", + "timestamp": 1505752997714, + "version": "0.10.5" + }, + "rope-0.10.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "1f914916c8bf9376b7c456d9e405d3d0", + "name": "rope", + "sha256": "e136e9c5d32d61d59838679a7e357df325c41cca6bd1db5fb77d9001172c3bd0", + "size": 277895, + "subdir": "linux-64", + "timestamp": 1530959349618, + "version": "0.10.7" + }, + "rope-0.10.7-py27hfe459b0_0.tar.bz2": { + "build": "py27hfe459b0_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "e645a2a1e4a72873c9b3a4eb690d55e9", + "name": "rope", + "sha256": "08c3f5aafe4a2e35438ea2292aaf864cc75987e6db445b84b90d098e2bbbc8fc", + "size": 278101, + "subdir": "linux-64", + "timestamp": 1511320463743, + "version": "0.10.7" + }, + "rope-0.10.7-py35h986144c_0.tar.bz2": { + "build": "py35h986144c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "ec7cd04cea7a24e8257328099c0c3b8f", + "name": "rope", + "sha256": "755e1b63f1394c1a600503b3487d67bdaab58697a9db7c98d19a6cc225e589d2", + "size": 289092, + "subdir": "linux-64", + "timestamp": 1511320468569, + "version": "0.10.7" + }, + "rope-0.10.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "000a3041bd9979bd4f63400266f167d2", + "name": "rope", + "sha256": "03b9c4af8fc9eb7dd72b2eedea9e2cb704643367e1f8f7ddeb7edd57019c82a9", + "size": 285523, + "subdir": "linux-64", + "timestamp": 1530959385452, + "version": "0.10.7" + }, + "rope-0.10.7-py36h147e2ec_0.tar.bz2": { + "build": "py36h147e2ec_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "a08b672f11b150d8431bdf68bb93c105", + "name": "rope", + "sha256": "782ff998140c2ccb35296c7b122b7febfa52374d11b7860440d24e4e0df00924", + "size": 285777, + "subdir": "linux-64", + "timestamp": 1511320469165, + "version": "0.10.7" + }, + "rope-0.10.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "6165913c1c4ca83701f56cb992dc0aa6", + "name": "rope", + "sha256": "2d5ea09f427ad8c7a3cc21e8d03ccd1a87176b7956034af67f9385c20a90b4f6", + "size": 286341, + "subdir": "linux-64", + "timestamp": 1530959421720, + "version": "0.10.7" + }, + "rope-0.11.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "72cd70f8a1b95641d3e0a3fe3023fdbb", + "name": "rope", + "sha256": "604819e81dc3541d7ae584eeefdd7002e6c1e3dc630ae64e7782c4581a1bc0cd", + "size": 280533, + "subdir": "linux-64", + "timestamp": 1534176845722, + "version": "0.11.0" + }, + "rope-0.11.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "50ae0f350115843d622646b5033b17af", + "name": "rope", + "sha256": "8a3dad4a414ab6bec65eb082c6ba7f46930b40014f0ba85f3c07162322c15983", + "size": 291579, + "subdir": "linux-64", + "timestamp": 1534176860903, + "version": "0.11.0" + }, + "rope-0.11.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "22d60da128d9930697ab047d1ab61820", + "name": "rope", + "sha256": "34d1d41cd5d32c10d2f5daef8f408468422a96ac4d5bf1d7bcb8efbeb10ef7a9", + "size": 288534, + "subdir": "linux-64", + "timestamp": 1534176834141, + "version": "0.11.0" + }, + "rope-0.11.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "e0c012cacbe490f8582d650bc6bdc8c4", + "name": "rope", + "sha256": "2fe22c93c13010f2885880a5cddceff8ad81e364ca0e62ddf2ac230a5399ec10", + "size": 288445, + "subdir": "linux-64", + "timestamp": 1534176877995, + "version": "0.11.0" + }, + "rope-0.12.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "045b08296a1d619c18c936dce00d5d53", + "name": "rope", + "sha256": "ff4b648d9c7589cc0b3add084fa271d5609701bd6499376a9d4595ebe483eb57", + "size": 282947, + "subdir": "linux-64", + "timestamp": 1551148691745, + "version": "0.12.0" + }, + "rope-0.12.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "ff8c9638c422ce7f1e7390eef1ee4d85", + "name": "rope", + "sha256": "265ad23aade46ba217a11edb4e50f2b0eb0bc42c815d0fc1be2b2913127619af", + "size": 289186, + "subdir": "linux-64", + "timestamp": 1551148725504, + "version": "0.12.0" + }, + "rope-0.12.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "a37b1976b878d73b04a5cfb1d11b13bf", + "name": "rope", + "sha256": "780e782ea6c62a663c34ef66941f5ca52408623c106180d51e5876034239bf36", + "size": 289797, + "subdir": "linux-64", + "timestamp": 1551148677353, + "version": "0.12.0" + }, + "rope-1.7.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytoolconfig >=1.2.2" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "60360d6d9a4fe9652884ce4f1da70b45", + "name": "rope", + "sha256": "f35ee37c474b7e115454cc959f5c873c715cd41b3341622d35b89b7779e894c0", + "size": 415598, + "subdir": "linux-64", + "timestamp": 1676675078828, + "version": "1.7.0" + }, + "rope-1.7.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "pytoolconfig >=1.2.2" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "0af1cadfed3d709040753e9ae2c5e8e5", + "name": "rope", + "sha256": "d5aa8e9604b04921fd054f99c7640f31a211036e298208f3fab9336bee520b69", + "size": 547082, + "subdir": "linux-64", + "timestamp": 1677708561099, + "version": "1.7.0" + }, + "rope-1.7.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytoolconfig >=1.2.2" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "0f6061c8b0bb3c3fe243dbf81dab6734", + "name": "rope", + "sha256": "e2ac94fe8b28169b09c2e909c5b8b1975ed1e7f2b841de76375a2be3c4410eff", + "size": 408460, + "subdir": "linux-64", + "timestamp": 1676675108915, + "version": "1.7.0" + }, + "rope-1.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytoolconfig >=1.2.2" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "704fba1243c7707a9a2db15416e1422e", + "name": "rope", + "sha256": "2249158249c1aaba3529f579cc95c50bd762b24c5cc9632f86da7821bccf0eb3", + "size": 410733, + "subdir": "linux-64", + "timestamp": 1676675139307, + "version": "1.7.0" + }, + "rope-1.7.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytoolconfig >=1.2.2" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "ace826d8f44b84bf4ca0cf3fc26fd9a1", + "name": "rope", + "sha256": "1a27ff9483706694023440193b290f7ab539740d76fba02d983fa44b9b97d8bc", + "size": 410094, + "subdir": "linux-64", + "timestamp": 1676675048475, + "version": "1.7.0" + }, + "routes-2.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff5c673e0ec87bdba7e135da8e2d0b10", + "name": "routes", + "sha256": "40b0709ff4e3b4f32668686b77281f92cbcdb607d6ae13098c9135075423cb25", + "size": 55310, + "subdir": "linux-64", + "timestamp": 1530959452899, + "version": "2.4.1" + }, + "routes-2.4.1-py27hd2a40da_0.tar.bz2": { + "build": "py27hd2a40da_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9568ee83a686aee98c2c84ab0e0caab", + "name": "routes", + "sha256": "58f8d20cbba0294a7367c71a5b68536dc6b8b5f0db9753da56d55aaf5a0055d0", + "size": 55474, + "subdir": "linux-64", + "timestamp": 1508007487053, + "version": "2.4.1" + }, + "routes-2.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d012df4cafee2b2f81620016616b2c9f", + "name": "routes", + "sha256": "61feebea73228b4c6a3c2dba79be539c39811d083b8f3933f09f1d0c2f92b59b", + "size": 56013, + "subdir": "linux-64", + "timestamp": 1535297883076, + "version": "2.4.1" + }, + "routes-2.4.1-py35hb61f5ad_0.tar.bz2": { + "build": "py35hb61f5ad_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fff079cb895fa5963bd587c53a1c81c6", + "name": "routes", + "sha256": "7942b51c5f6db110b0f20d4c4d2afcd811318c747b1eb4cbfd57620390655ec2", + "size": 56264, + "subdir": "linux-64", + "timestamp": 1508007464597, + "version": "2.4.1" + }, + "routes-2.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f92840d4727a56a699a7e6aed15465f9", + "name": "routes", + "sha256": "7704f0a3d5b28e9222e46776c649c51b119daa9091acd32cc0228ae40047f36f", + "size": 55679, + "subdir": "linux-64", + "timestamp": 1530959484254, + "version": "2.4.1" + }, + "routes-2.4.1-py36h38f819d_0.tar.bz2": { + "build": "py36h38f819d_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f305241b80af3fe169ff81c39fe42440", + "name": "routes", + "sha256": "87e3d05c2d54039344e00a82c87802bde81f3f0d0e3859b90e5a8c1eb3221941", + "size": 56023, + "subdir": "linux-64", + "timestamp": 1508007492087, + "version": "2.4.1" + }, + "routes-2.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca912cf96fe1674b6d16e9f379f7f777", + "name": "routes", + "sha256": "8d132fe6db8c47ba88de58fd278876c8229133eec62012a1ef090d497364a927", + "size": 55681, + "subdir": "linux-64", + "timestamp": 1530959514965, + "version": "2.4.1" + }, + "routes-2.4.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3703f58da530e6e182b0c4a781338935", + "name": "routes", + "sha256": "808eb1a4e7e38619e35cb5829791fe06b346fd246e55c4cd65b00559946c75ac", + "size": 56213, + "subdir": "linux-64", + "timestamp": 1573554677388, + "version": "2.4.1" + }, + "routes-2.5.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d356d952d6ea839ebb4d66e89e63318", + "name": "routes", + "sha256": "14323b96069838afcaede4ad923859acc13d38458e3ca04340f66064830df188", + "size": 57426, + "subdir": "linux-64", + "timestamp": 1642510975038, + "version": "2.5.1" + }, + "routes-2.5.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e5cfc3253896e633f8ea3ffb7abcc33", + "name": "routes", + "sha256": "79c6dbd199f4c484488371e25f3478463015e40143ad16dd40db9aae158b79c0", + "size": 74121, + "subdir": "linux-64", + "timestamp": 1676845690573, + "version": "2.5.1" + }, + "routes-2.5.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9cbcb918810b68eef9a63125367d3c90", + "name": "routes", + "sha256": "8f1a32804f66c526183d6a93b9e24d4915ae1a6bfe2a9e2fb6c5c3e6050d779c", + "size": 57233, + "subdir": "linux-64", + "timestamp": 1606864044128, + "version": "2.5.1" + }, + "routes-2.5.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe4b999680f0292d83a34fb92f1aff1c", + "name": "routes", + "sha256": "96785bf0147688e4b9d4ecaa25363aad9117ac68689ddeac75534167f9ea10f9", + "size": 57242, + "subdir": "linux-64", + "timestamp": 1606864038848, + "version": "2.5.1" + }, + "routes-2.5.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2062cc54bb16391f5274a3ec05acb32", + "name": "routes", + "sha256": "9f323a97455bd022a8631f631b89294d3be0c424653aeb491babd47dcb2a9ab1", + "size": 57358, + "subdir": "linux-64", + "timestamp": 1606863992884, + "version": "2.5.1" + }, + "routes-2.5.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f2069c2334607d065f5f45379c2c0e5", + "name": "routes", + "sha256": "0a634ae6af02c489e66c5e9fa8122d5d56d98a9acb8483c5b4b6459c4a3d2c96", + "size": 57803, + "subdir": "linux-64", + "timestamp": 1632762343482, + "version": "2.5.1" + }, + "rtree-0.8.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "libspatialindex", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-2.1", + "md5": "8f6b614944bdbccba2f0c968cca0408d", + "name": "rtree", + "sha256": "2279886c6dae6aeb261aaa0a75fe667147ef6fe4122b62f3c61fbe19e6105c02", + "size": 45198, + "subdir": "linux-64", + "timestamp": 1530890221011, + "version": "0.8.3" + }, + "rtree-0.8.3-py27h5233db4_0.tar.bz2": { + "build": "py27h5233db4_0", + "build_number": 0, + "depends": [ + "libspatialindex", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-2.1", + "md5": "fd3e601568f4fa8e37baef5a9e2924f2", + "name": "rtree", + "sha256": "030790155cf86aa2f0bfb2f9a5b7745ccc6a26c456706ad627f2277a0d1cb070", + "size": 45576, + "subdir": "linux-64", + "timestamp": 1513269254494, + "version": "0.8.3" + }, + "rtree-0.8.3-py35h2f9c1c0_0.tar.bz2": { + "build": "py35h2f9c1c0_0", + "build_number": 0, + "depends": [ + "libspatialindex", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-2.1", + "md5": "40f7c2163cd3c39f7d7102c0491f2ce9", + "name": "rtree", + "sha256": "60a5c21779a1affaf4eaab062ec50bcfa6c4be2045d2e8758ca3cbb8ea52a15e", + "size": 46895, + "subdir": "linux-64", + "timestamp": 1513269276808, + "version": "0.8.3" + }, + "rtree-0.8.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libspatialindex", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "ad58b9b336dcc8d52b6dd5ba74feeeb3", + "name": "rtree", + "sha256": "77ab783025f87d98f5aca618d0d2ea676fa03c49a189b020f5ec5781fce4551a", + "size": 46609, + "subdir": "linux-64", + "timestamp": 1530890195595, + "version": "0.8.3" + }, + "rtree-0.8.3-py36h2f9c1c0_0.tar.bz2": { + "build": "py36h2f9c1c0_0", + "build_number": 0, + "depends": [ + "libspatialindex", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "eb97099b55900fa554152b5846008cb9", + "name": "rtree", + "sha256": "3f3bd649ca4aa64bd613d4141e41942190435d5679098117205acfd0954ad68f", + "size": 46827, + "subdir": "linux-64", + "timestamp": 1513269328925, + "version": "0.8.3" + }, + "rtree-0.8.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libspatialindex", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1", + "md5": "16b2b048d8736b3354263c8dfe4f6e29", + "name": "rtree", + "sha256": "9d2764f9a110e6e2e6caa77b7d9baaf894d0f0e382bf212bedea7164c9a78f21", + "size": 46554, + "subdir": "linux-64", + "timestamp": 1530890169001, + "version": "0.8.3" + }, + "rtree-0.8.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "libspatialindex", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1", + "md5": "cd5f8c82922d4140cf9be2bb363f2596", + "name": "rtree", + "sha256": "213b178f0bbbc9e61e922b35e1b156e1436f3802f2eba97d965096c7b8d1a84d", + "size": 47302, + "subdir": "linux-64", + "timestamp": 1573200598481, + "version": "0.8.3" + }, + "rtree-0.9.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "427f8703532cc38c0935cffedc8aa16e", + "name": "rtree", + "sha256": "f3a94e42d8ba2f4d7451b716cc0974c3c7eac18c820fdd04a557d9660f7e4c27", + "size": 47723, + "subdir": "linux-64", + "timestamp": 1580336055735, + "version": "0.9.3" + }, + "rtree-0.9.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d5aa74bf853fc87ede77e4dc065b92ae", + "name": "rtree", + "sha256": "2b5599ce99f211773b45d41b0a2900f600498eba7b1499efa78c1d7db917a6c2", + "size": 47682, + "subdir": "linux-64", + "timestamp": 1580336019124, + "version": "0.9.3" + }, + "rtree-0.9.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "50a821f175b712ec9122094d204b3b58", + "name": "rtree", + "sha256": "f3e8141c6a89d373366db33763885ba35c0c5bc089d47afe91c628c432e15ce6", + "size": 47910, + "subdir": "linux-64", + "timestamp": 1580336066836, + "version": "0.9.3" + }, + "rtree-0.9.4-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e493e7d971eabca7321b20a25c9f5522", + "name": "rtree", + "sha256": "b6971b69439d9a2b422a80bc3b51cabc17765cd51c7a241aa26d227339e34d19", + "size": 49475, + "subdir": "linux-64", + "timestamp": 1588548917738, + "version": "0.9.4" + }, + "rtree-0.9.4-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "cbd0bb76ccef17ae76cca26f67285c5d", + "name": "rtree", + "sha256": "6c37577030a9f81dc1af3836954821fead4441dbc4872c95bc03bdd301283a3a", + "size": 49462, + "subdir": "linux-64", + "timestamp": 1588548908039, + "version": "0.9.4" + }, + "rtree-0.9.4-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "5a6f96a9179b97a95bd5387262f43d8d", + "name": "rtree", + "sha256": "1fbc9b40d002803d4de6d55eded46140d11332844e50955ed2fb564d4eb0ab50", + "size": 49671, + "subdir": "linux-64", + "timestamp": 1588548912744, + "version": "0.9.4" + }, + "rtree-0.9.4-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "933ee1efc96593a17dbfc77eb7bb85b2", + "name": "rtree", + "sha256": "ff97e83573c04456fe76a66f41f6561b69e876ab26239f8b215c2affb75bc604", + "size": 50144, + "subdir": "linux-64", + "timestamp": 1607977239723, + "version": "0.9.4" + }, + "rtree-0.9.7-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "fb4f6f7c42abd07a88602408bb340178", + "name": "rtree", + "sha256": "7a87d2a651308c40f2674cadee6a4baf236eb45de93145eb778624de9c320a5e", + "size": 47044, + "subdir": "linux-64", + "timestamp": 1640794395179, + "version": "0.9.7" + }, + "rtree-0.9.7-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a8a2e0159bad0c7ca3408893cdfa4966", + "name": "rtree", + "sha256": "823718331ad62f91685337f5232a73328b58e3cf3add784a8101acf6af56b788", + "size": 50966, + "subdir": "linux-64", + "timestamp": 1618420411821, + "version": "0.9.7" + }, + "rtree-0.9.7-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ca5c72d64b7b1c9214eeeaff892c050e", + "name": "rtree", + "sha256": "ae3f9846d9a8247a1d99a01ffd9b4d0a9fe34221d55ee148e87b2ba235765b2f", + "size": 50846, + "subdir": "linux-64", + "timestamp": 1618420875733, + "version": "0.9.7" + }, + "rtree-0.9.7-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "86612ffd129a27044cfd0812dd1f6a2b", + "name": "rtree", + "sha256": "1183b9f18aa1ca935f8dfa06c2e0d4e5339874307251ec69b204b192f3597cff", + "size": 51243, + "subdir": "linux-64", + "timestamp": 1618420880478, + "version": "0.9.7" + }, + "rtree-0.9.7-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "9f2743112006a45c91f6486c563c2476", + "name": "rtree", + "sha256": "c1b55ad0a5a1cd9eecfd0bf64104a0a991f1f10cdd7acc9cf4651b217fc5707c", + "size": 51128, + "subdir": "linux-64", + "timestamp": 1618420877038, + "version": "0.9.7" + }, + "rtree-1.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "libspatialindex >=1.8.5", + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "75b181c8fc428adbcbe8b45c9e8edbc8", + "name": "rtree", + "sha256": "6e0a4ca65bb946f6c9a7e5e6029e78841914f9640c48b2d436dee72bfb279cdf", + "size": 49054, + "subdir": "linux-64", + "timestamp": 1675157932145, + "version": "1.0.1" + }, + "rtree-1.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "libspatialindex >=1.8.5", + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f59a6905f6488c2e539954eff64ebac5", + "name": "rtree", + "sha256": "c7fe463fd96308054c7c01aea3fb92adcb226b161147e1ff8001b574fed6acb2", + "size": 63080, + "subdir": "linux-64", + "timestamp": 1676845705413, + "version": "1.0.1" + }, + "rtree-1.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "libspatialindex >=1.8.5", + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.7" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "721b526b091604f5d7abf9b5647bbec8", + "name": "rtree", + "sha256": "9bbebf1c24c7f21c1bf32e01be882e61c7f2d9927b078b3d0c958ebc46aaf9f0", + "size": 48669, + "subdir": "linux-64", + "timestamp": 1675157881160, + "version": "1.0.1" + }, + "rtree-1.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "libspatialindex >=1.8.5", + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f04d5207ae2ac4b77eb041d90a60bfc", + "name": "rtree", + "sha256": "c735d6921d8192d6eb56f69a37910c6faeaf36fa7ca23da049164913b15974bd", + "size": 48757, + "subdir": "linux-64", + "timestamp": 1675157906591, + "version": "1.0.1" + }, + "rtree-1.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "libspatialindex >=1.8.5", + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e39ca88c130d31de57559138e8bb5b67", + "name": "rtree", + "sha256": "ddaba633aaf3dedc1c353bc1ed4154d5961cadabbaf055959f0f0b96c77ed203", + "size": 48788, + "subdir": "linux-64", + "timestamp": 1675157957600, + "version": "1.0.1" + }, + "ruamel-1.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aea1cf0b109b376affede81d6540de5c", + "name": "ruamel", + "sha256": "2dfa267872aaf9ab8639f7cb62e1e6af6ade82e1094a90e4613b461726a9632e", + "size": 5788, + "subdir": "linux-64", + "timestamp": 1574354806654, + "version": "1.0" + }, + "ruamel-1.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cf3fd4dd763c78f2634b929d4c397560", + "name": "ruamel", + "sha256": "2be0ddcc7d37f640e51a95ea2c333cc7c7fbcec8b32910a10ac33a5e66383a04", + "size": 4694, + "subdir": "linux-64", + "timestamp": 1641551100460, + "version": "1.0" + }, + "ruamel-1.0-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9a68a72138636a8811ca9bb743a305c5", + "name": "ruamel", + "sha256": "431d898f7ca70b15aac54fb4d50120e816543655edf5b0551234e9ffc5226e70", + "size": 4633, + "subdir": "linux-64", + "timestamp": 1664919733685, + "version": "1.0" + }, + "ruamel-1.0-py311h06a4308_2.tar.bz2": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d974764aedb686801d5f8871f2f1b241", + "name": "ruamel", + "sha256": "efc0b91cda127fcc7cd66cf72e20129e3f1d1aa8bfcea8c2fb510a72ca8401fa", + "size": 4979, + "subdir": "linux-64", + "timestamp": 1676828785739, + "version": "1.0" + }, + "ruamel-1.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8fb979a23ed2024dc67564e6c82c8dba", + "name": "ruamel", + "sha256": "0d638d8d187b9dd208344178844b1b9b0b424b0b2abe6b83f866e3f255a8b179", + "size": 5815, + "subdir": "linux-64", + "timestamp": 1574354824330, + "version": "1.0" + }, + "ruamel-1.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e0f9dbab4586cb87a46c1e70f8ac8b0f", + "name": "ruamel", + "sha256": "63e9e02b79df4d9ddef707b7564c47ffdb42021b35eb128ebdf41d7bff0f0fed", + "size": 5811, + "subdir": "linux-64", + "timestamp": 1613648902368, + "version": "1.0" + }, + "ruamel-1.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "89b82fc386f85485a54420ca6a10a44a", + "name": "ruamel", + "sha256": "f0d8ae912b065881502de8cad09be53b3ee0dd02dd914b20783c79ae5c410d06", + "size": 5809, + "subdir": "linux-64", + "timestamp": 1574354738667, + "version": "1.0" + }, + "ruamel-1.0-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bce74b20e94dcbf7a1f991a8fda4592d", + "name": "ruamel", + "sha256": "baff4ba09cd57f7b67afd31b6ee3eea117aec53b73654422840f715444d52cd2", + "size": 4092, + "subdir": "linux-64", + "timestamp": 1594403307685, + "version": "1.0" + }, + "ruamel-1.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "398f4a8cf8ffae206fe8f26b7166cfdd", + "name": "ruamel", + "sha256": "2b039b7c51dbbd1ff567f4f5e4f179a19db3678d7c0b6b1aba1cfd32c07f6094", + "size": 5804, + "subdir": "linux-64", + "timestamp": 1613648177542, + "version": "1.0" + }, + "ruamel-1.0-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5ff27a42d213c8a76a6b0b2ff8763e25", + "name": "ruamel", + "sha256": "693ebfb9e781b053e946b5e30bafdd13e99992616bf0399ce7d7efcc5dbb57bd", + "size": 4621, + "subdir": "linux-64", + "timestamp": 1664919798159, + "version": "1.0" + }, + "ruamel-1.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "81a96716caeb637a35cbf6fb8e96e8d1", + "name": "ruamel", + "sha256": "1566ad5df4ff714fac59b5406db429c2e5f6fea47c3c044b0f40d9fc9e854582", + "size": 5814, + "subdir": "linux-64", + "timestamp": 1574354862410, + "version": "1.0" + }, + "ruamel-1.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "acaec2afde0c8883f1fac8d1a7b432e9", + "name": "ruamel", + "sha256": "1b9e9133a885a4f7f82fcd1bebc4df7c49f056251f9b081be2d67f1cda50e38d", + "size": 5812, + "subdir": "linux-64", + "timestamp": 1613648893938, + "version": "1.0" + }, + "ruamel-1.0-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "92b3f3a44cce770410ae1cd45e6efec0", + "name": "ruamel", + "sha256": "756a60095eb5712af0ec1fe73918e84eec208b9e180796eb97bfc1b3f217a1e6", + "size": 4628, + "subdir": "linux-64", + "timestamp": 1664919777240, + "version": "1.0" + }, + "ruamel-1.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "44a7a46346b71a33086c2e65374076dc", + "name": "ruamel", + "sha256": "e6b59448a5a8aacd8e8673f2f3d9b84a8f6be20eb4b34f0636ef4490827624f9", + "size": 5799, + "subdir": "linux-64", + "timestamp": 1613648884764, + "version": "1.0" + }, + "ruamel-1.0-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "139be7b5d1e97bc953ece4bf8ae585f0", + "name": "ruamel", + "sha256": "7fcdf78764d880706902373caac25329eee8c85b1bcaa19e48d50ae5ef85ca25", + "size": 4601, + "subdir": "linux-64", + "timestamp": 1664919756701, + "version": "1.0" + }, + "ruamel.yaml-0.16.10-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "eb076a29ae4c104d4fddadb82a7677ac", + "name": "ruamel.yaml", + "sha256": "db1a1412e4a0ce1ccdff92456eb6cecf28ba6d16927e7b631d66d7a475a596e4", + "size": 173993, + "subdir": "linux-64", + "timestamp": 1641550815121, + "version": "0.16.10" + }, + "ruamel.yaml-0.16.10-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "e18a2ef56a439120c444ca4d2b98cb24", + "name": "ruamel.yaml", + "sha256": "c06ab252ddf38c97029b6854c8b629bddccfaa5c93a6dbae5d4ff2e49a48a837", + "size": 183358, + "subdir": "linux-64", + "timestamp": 1587579182889, + "version": "0.16.10" + }, + "ruamel.yaml-0.16.10-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "d1a0ee682d807e8449ce89c2a5c5ba23", + "name": "ruamel.yaml", + "sha256": "97de777eb14c167f0b8e2088c35588715c98d44110bd30e4a24ef24b2d63e468", + "size": 183244, + "subdir": "linux-64", + "timestamp": 1587579400621, + "version": "0.16.10" + }, + "ruamel.yaml-0.16.10-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "87e15534edbc574c51ab04d45a40d3d4", + "name": "ruamel.yaml", + "sha256": "e2614a9e32c9fb979e8df3aaffd5ca6839372e1210ccfbd288e87393c993da33", + "size": 183956, + "subdir": "linux-64", + "timestamp": 1587580012640, + "version": "0.16.10" + }, + "ruamel.yaml-0.16.12-py310h5eee18b_2.tar.bz2": { + "build": "py310h5eee18b_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a1fc4e1880dc3408b723b99effa31692", + "name": "ruamel.yaml", + "sha256": "973fe1825da5bef63596f5281736c86381955d5d1778bf02a36605817f9cb8ee", + "size": 174241, + "subdir": "linux-64", + "timestamp": 1663675885496, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py310h5eee18b_3.tar.bz2": { + "build": "py310h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1cc5e82812665d47eee1fa9427662149", + "name": "ruamel.yaml", + "sha256": "a80751184b0e0a5e8ab2fb26139fa0e99be98449e08b1471406f6e7b0c22c2d9", + "size": 174113, + "subdir": "linux-64", + "timestamp": 1664988612691, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "a0d1f99ca43b4ccbc108dd1cccc915fb", + "name": "ruamel.yaml", + "sha256": "7f9f46a42882c65635a109bfcff176de339ce7c575618b2ff095d47555b14dd1", + "size": 170711, + "subdir": "linux-64", + "timestamp": 1600552856560, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py37h5eee18b_2.tar.bz2": { + "build": "py37h5eee18b_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f556bb1a781d09427afe5bcde4e6675b", + "name": "ruamel.yaml", + "sha256": "a466469ecd2a11e4663aee76f9f710b2dc044fe33c390325d7b4f7c58c3e3a76", + "size": 170909, + "subdir": "linux-64", + "timestamp": 1663675912972, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py37h5eee18b_3.tar.bz2": { + "build": "py37h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d59f120197b2254c6283ac0b42326b8", + "name": "ruamel.yaml", + "sha256": "cdbe729b571a7d61fa2c4e5b8ffc6399824349c8546540044c1d4150e7be91d4", + "size": 170636, + "subdir": "linux-64", + "timestamp": 1664988667145, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "6bdcab8c59a1c6746f48d4f9857a28e8", + "name": "ruamel.yaml", + "sha256": "d967a39a02b015d29d3fcc120a6c9ebd571d7b75854572af323385fdbc104004", + "size": 170545, + "subdir": "linux-64", + "timestamp": 1600552862969, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py38h5eee18b_2.tar.bz2": { + "build": "py38h5eee18b_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f76ec20faac175ea56b49b75a24b3f4", + "name": "ruamel.yaml", + "sha256": "3869c28be13dcceaa7e31b0fed2dd5661f55c8af3333331d6a99db5c8808abc0", + "size": 171392, + "subdir": "linux-64", + "timestamp": 1663675817592, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py38h5eee18b_3.tar.bz2": { + "build": "py38h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd1b789474d3d808af6b923e51b3ee00", + "name": "ruamel.yaml", + "sha256": "94bd25dd09a59a721495a6c500999edba35e228b4bdb3c078f823294fcb93a83", + "size": 171435, + "subdir": "linux-64", + "timestamp": 1664988639723, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "678eff7915e63f883e410f0b06adf685", + "name": "ruamel.yaml", + "sha256": "21276add1cc740be0963902022fea2b191cc557db6161496c5a4d982ba0e486c", + "size": 171340, + "subdir": "linux-64", + "timestamp": 1600552889950, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "00360c3b184e72e8a9c2b9482e75b65e", + "name": "ruamel.yaml", + "sha256": "704bd850e88cec55022700ce9b2a00e2c80f4e40a909c30e5d642f8d0b1e647f", + "size": 184960, + "subdir": "linux-64", + "timestamp": 1613650318760, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py39h5eee18b_2.tar.bz2": { + "build": "py39h5eee18b_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "42e3d4f788e558341ce0bfd87ce215d3", + "name": "ruamel.yaml", + "sha256": "903d7aac131c71750403559694bf2fa9708c7c71fd5615e3149bef0758f4f3d3", + "size": 171740, + "subdir": "linux-64", + "timestamp": 1663675845888, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py39h5eee18b_3.tar.bz2": { + "build": "py39h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "028c194e77a87e80f6adc4dd203dc462", + "name": "ruamel.yaml", + "sha256": "c54d937a3b0be022fcc5d5da015237e4fa48d623dc67ad9ab9d7dd9ff37a4729", + "size": 171662, + "subdir": "linux-64", + "timestamp": 1664988572430, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.5-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "802cc66e29bfb70f799f84b7bb2065dd", + "name": "ruamel.yaml", + "sha256": "c0d4cdce721d5f21fff74dbd3b1577c83a16622b4c4fbb3a8004446744fe95c2", + "size": 182649, + "subdir": "linux-64", + "timestamp": 1574355162600, + "version": "0.16.5" + }, + "ruamel.yaml-0.16.5-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "a37720c1c29ed797f9242e4c3e1b8cdc", + "name": "ruamel.yaml", + "sha256": "99296dddf6b36a210262bd5a92c3ebaec7171f720189e6b3a0e7c641dd51508c", + "size": 182625, + "subdir": "linux-64", + "timestamp": 1574355109296, + "version": "0.16.5" + }, + "ruamel.yaml-0.16.5-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "ff25f0f5185657b12c8d9db8e6f0adcd", + "name": "ruamel.yaml", + "sha256": "579563649173eb9c0b528e9f93d46c1c7619d518f0fffa23db4024cfb9cba25e", + "size": 190737, + "subdir": "linux-64", + "timestamp": 1574355135320, + "version": "0.16.5" + }, + "ruamel.yaml-0.16.6-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "e32ff7aa8d4d653ec624d77576e4f66f", + "name": "ruamel.yaml", + "sha256": "7275f311533b6ea3032cffa72a93febc42b6fed8b120d4d50e08e784da1bc292", + "size": 183050, + "subdir": "linux-64", + "timestamp": 1587400176782, + "version": "0.16.6" + }, + "ruamel.yaml-0.16.6-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "7b6e63d66f4218baa2b78074695be8da", + "name": "ruamel.yaml", + "sha256": "c9f434008fd2c91b5e6989625c4fbfb271065e1ae4d21d4d106fdc82318d84d8", + "size": 183038, + "subdir": "linux-64", + "timestamp": 1587400147840, + "version": "0.16.6" + }, + "ruamel.yaml-0.16.6-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "86498d1a696b4658cf78ab4faf4b7ba0", + "name": "ruamel.yaml", + "sha256": "76dd0f58d26abe28c1b4cf5b89ee5a95bad3373c364090bd593acd5e6381731a", + "size": 183826, + "subdir": "linux-64", + "timestamp": 1587400170339, + "version": "0.16.6" + }, + "ruamel.yaml-0.16.7-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "a52840495c4a0b032dda20279350cf82", + "name": "ruamel.yaml", + "sha256": "bd13687fe65fc2a79af5464b5974d8725a2f7819dbb0f30c45b00fde688049ae", + "size": 183305, + "subdir": "linux-64", + "timestamp": 1587568109040, + "version": "0.16.7" + }, + "ruamel.yaml-0.16.7-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "9626951b3e77f8a4a7c4f674dccce65f", + "name": "ruamel.yaml", + "sha256": "41abf0343f266ab144424594d935184f2e68c3966f60ee65e8193b6cf60b8bf7", + "size": 183115, + "subdir": "linux-64", + "timestamp": 1587568116475, + "version": "0.16.7" + }, + "ruamel.yaml-0.16.7-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "be9ed4bd39db1a08c2da5b3325f786d9", + "name": "ruamel.yaml", + "sha256": "2e21afea765908be89b0be353a27b3a1522983e70e6623b9d8b18a1adce52420", + "size": 184049, + "subdir": "linux-64", + "timestamp": 1587568122325, + "version": "0.16.7" + }, + "ruamel.yaml-0.17.21-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "ruamel.yaml.clib >=0.2.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2feda4ae35feae6b2769620cd3182512", + "name": "ruamel.yaml", + "sha256": "2ca326717a1bc02bcd496511f536a057f4bb93a626ea647a97fd9cd2bc004e37", + "size": 178905, + "subdir": "linux-64", + "timestamp": 1666304642204, + "version": "0.17.21" + }, + "ruamel.yaml-0.17.21-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "55ae8f40a8ad21a09a0eaa0efcf1ccaf", + "name": "ruamel.yaml", + "sha256": "e7e470af80755d7a225976a9badf4e176d6d28db2b0dacb7dc830c394f4e2721", + "size": 248185, + "subdir": "linux-64", + "timestamp": 1676838786578, + "version": "0.17.21" + }, + "ruamel.yaml-0.17.21-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml.clib >=0.2.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "157087e7428fa60b3c34b19a3b8cae55", + "name": "ruamel.yaml", + "sha256": "d49a57b2c0a7a4eea73a3f29db7e812c73d5716c3d3b80126851053b0c56f214", + "size": 174923, + "subdir": "linux-64", + "timestamp": 1666304586743, + "version": "0.17.21" + }, + "ruamel.yaml-0.17.21-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml.clib >=0.2.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85cb6f4655fa773156a5057695b2354d", + "name": "ruamel.yaml", + "sha256": "2443363398a6c2191f16b2fedbf6130a87551cc24770a0313c01af67fbb45756", + "size": 175902, + "subdir": "linux-64", + "timestamp": 1666304614235, + "version": "0.17.21" + }, + "ruamel.yaml-0.17.21-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "ruamel.yaml.clib >=0.2.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a699c17fe55b3929dc9df119b80e943c", + "name": "ruamel.yaml", + "sha256": "9dee3295dfd85553c2bb3acc9ab0ca4957d54699d0ac96da3da1c58a9c6efecc", + "size": 176135, + "subdir": "linux-64", + "timestamp": 1666304669344, + "version": "0.17.21" + }, + "ruamel.yaml.clib-0.2.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71c0d66dd0d8bbe5d0b3cce1d28c2f72", + "name": "ruamel.yaml.clib", + "sha256": "09f1617b0004bca264f71eaccf0f6425698849740f89212c03fff5d80746b69a", + "size": 152237, + "subdir": "linux-64", + "timestamp": 1574354836402, + "version": "0.2.0" + }, + "ruamel.yaml.clib-0.2.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cf7e3716d2af55e2e74f81d29341aee6", + "name": "ruamel.yaml.clib", + "sha256": "8329bb3f198e8291bd34c3ce33f562e5ecfd0dfd513decd249f9e9b6073190c6", + "size": 161500, + "subdir": "linux-64", + "timestamp": 1574354873041, + "version": "0.2.0" + }, + "ruamel.yaml.clib-0.2.0-py37h14c3975_1.tar.bz2": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ea4b4f982b46ff6c1538f889715da53", + "name": "ruamel.yaml.clib", + "sha256": "94c8799b23067bf5d14a8b0999528312b01b22ef5ec749c18ce41d084ee30fe5", + "size": 158753, + "subdir": "linux-64", + "timestamp": 1594403756479, + "version": "0.2.0" + }, + "ruamel.yaml.clib-0.2.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef1891fc05c5416be73e23d13eb83813", + "name": "ruamel.yaml.clib", + "sha256": "598f1b61b620e7d1178bdb00b9f9a5fd00e3a75e908008a14e724d5908157843", + "size": 160734, + "subdir": "linux-64", + "timestamp": 1574354844823, + "version": "0.2.0" + }, + "ruamel.yaml.clib-0.2.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aee09beb111e114642b889c79c420a40", + "name": "ruamel.yaml.clib", + "sha256": "e051379b0f86be00f474db47cf1fe03c02c6918973068b37738c981e06917f68", + "size": 172787, + "subdir": "linux-64", + "timestamp": 1574354874294, + "version": "0.2.0" + }, + "ruamel.yaml.clib-0.2.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d71e90daae91aac3b2b6aa1d01143a0", + "name": "ruamel.yaml.clib", + "sha256": "76dacb3054aad9fde72006313105c6f51c50740e5156316a8d71253a0a42bae9", + "size": 165561, + "subdir": "linux-64", + "timestamp": 1613646261113, + "version": "0.2.0" + }, + "ruamel.yaml.clib-0.2.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e7b1222183d357f5ee76d9ad3e2690e7", + "name": "ruamel.yaml.clib", + "sha256": "6841effc711e9b7d85155eaad3e918c1fee50cc3bc2cee6d80646a876d77736c", + "size": 160421, + "subdir": "linux-64", + "timestamp": 1601999154935, + "version": "0.2.2" + }, + "ruamel.yaml.clib-0.2.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "934928c33fe70d1d81a3a61e8147c2b9", + "name": "ruamel.yaml.clib", + "sha256": "550fc6cc2fe895d04a951311e1bb155a9fe85985f6c42c4c1452c33ef4544562", + "size": 159628, + "subdir": "linux-64", + "timestamp": 1601999142642, + "version": "0.2.2" + }, + "ruamel.yaml.clib-0.2.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba692de5e31720d9f08b4e4365a410c7", + "name": "ruamel.yaml.clib", + "sha256": "5ff4113fde1344981c8be5620b1f33654f0140679c222800e0b9e7cd08f8729b", + "size": 164216, + "subdir": "linux-64", + "timestamp": 1601999138846, + "version": "0.2.2" + }, + "ruamel.yaml.clib-0.2.6-py310h5eee18b_1.tar.bz2": { + "build": "py310h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7bbad8e955476d9ede9bb1ef46ff5bab", + "name": "ruamel.yaml.clib", + "sha256": "d1ae571a5b8695d089301dab08e1b1b24f5386837ce84a2cc71fc108b277237d", + "size": 152086, + "subdir": "linux-64", + "timestamp": 1666302324054, + "version": "0.2.6" + }, + "ruamel.yaml.clib-0.2.6-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "38a7ffec79cc68f8d4bf364a51904303", + "name": "ruamel.yaml.clib", + "sha256": "9d586bd651aa08452ff7528caba4a3955f147b6827deca3a3b8e940312db54dc", + "size": 559663, + "subdir": "linux-64", + "timestamp": 1641550444427, + "version": "0.2.6" + }, + "ruamel.yaml.clib-0.2.6-py37h5eee18b_1.tar.bz2": { + "build": "py37h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b68fbc7b16a433fc076788d0fca4b031", + "name": "ruamel.yaml.clib", + "sha256": "726897b029f529d7a25ba33c1cb55ce4545bb848ff478f39f4417f15bab7f0e3", + "size": 153332, + "subdir": "linux-64", + "timestamp": 1666302392782, + "version": "0.2.6" + }, + "ruamel.yaml.clib-0.2.6-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1dbcdfba141a77b61c920ba75a7ba9ce", + "name": "ruamel.yaml.clib", + "sha256": "1a9aa98ad244e3f87a4186038c7b8f2e2491f5d94382192555c61d6aabd31b55", + "size": 144387, + "subdir": "linux-64", + "timestamp": 1641552593723, + "version": "0.2.6" + }, + "ruamel.yaml.clib-0.2.6-py38h5eee18b_1.tar.bz2": { + "build": "py38h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6d47db8169f3d64a67d77783440e15a", + "name": "ruamel.yaml.clib", + "sha256": "b64bb1bdeb1cffc26f84ae9bc4567de2ffd3c40c84d7a95a912f3ac2f778b83b", + "size": 156342, + "subdir": "linux-64", + "timestamp": 1666302290504, + "version": "0.2.6" + }, + "ruamel.yaml.clib-0.2.6-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "174c5e3bf768b2a63eaa5c0deb2b7931", + "name": "ruamel.yaml.clib", + "sha256": "db4aa759de1980f9ff8cee8e88ff9fa7415c8ce26e90fcaa37c79804af5a4d74", + "size": 149064, + "subdir": "linux-64", + "timestamp": 1641552644147, + "version": "0.2.6" + }, + "ruamel.yaml.clib-0.2.6-py39h5eee18b_1.tar.bz2": { + "build": "py39h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c34151c0fdda89adcda9b74ea5f000de", + "name": "ruamel.yaml.clib", + "sha256": "7e17747ab1287b6cae680638d95ab07137ecfdb46891d938f3144407997109ca", + "size": 152540, + "subdir": "linux-64", + "timestamp": 1666302357107, + "version": "0.2.6" + }, + "ruamel.yaml.clib-0.2.6-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d402ae0b182259d07f8cd7723bec2e3", + "name": "ruamel.yaml.clib", + "sha256": "8d79bc809db236497a556ec847745d274bef22f2ed4a577259ae2e603dbeffc7", + "size": 149309, + "subdir": "linux-64", + "timestamp": 1641552620724, + "version": "0.2.6" + }, + "ruamel.yaml.clib-0.2.7-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c82b4e83ea4ff28ae90cd682c949699", + "name": "ruamel.yaml.clib", + "sha256": "1431b9b6f3373abeb0fc56e675324b3869d67667a6712c35eb19100655647545", + "size": 144642, + "subdir": "linux-64", + "timestamp": 1676828808066, + "version": "0.2.7" + }, + "ruamel.yaml.jinja2-0.2.7-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "ruamel.yaml >=0.15.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a78511226f649607b51b06fc76e4fa54", + "name": "ruamel.yaml.jinja2", + "sha256": "0acb4316caa1809b520eae173ecb9a80db5e7d2b33517573be215230a5a54df6", + "size": 11441, + "subdir": "linux-64", + "timestamp": 1676902992827, + "version": "0.2.7" + }, + "ruamel.yaml.jinja2-0.2.7-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "ruamel.yaml >=0.15.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "555b4473db07d35014a49297439de35f", + "name": "ruamel.yaml.jinja2", + "sha256": "20b16407345e9db52f4ec6701a7f402d577650c74b8f9f039e26711e4ea38ff4", + "size": 11358, + "subdir": "linux-64", + "timestamp": 1676902967971, + "version": "0.2.7" + }, + "ruamel.yaml.jinja2-0.2.7-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "ruamel.yaml >=0.15.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a23fb66de993029d9aa22e4245ac14e1", + "name": "ruamel.yaml.jinja2", + "sha256": "2ff5b7dd6acb133bf57e68012e266bfdcaefee79ac3373988d970a0581247604", + "size": 11363, + "subdir": "linux-64", + "timestamp": 1676902919551, + "version": "0.2.7" + }, + "ruamel.yaml.jinja2-0.2.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "ruamel.yaml >=0.15.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3dfd7db5094f07e3620815f0872d018f", + "name": "ruamel.yaml.jinja2", + "sha256": "fddc41b4695c99ce924dab09081555a2a400d063d73229565de21dff5169c889", + "size": 11371, + "subdir": "linux-64", + "timestamp": 1676902943666, + "version": "0.2.7" + }, + "ruamel_yaml-0.11.14-py27h672d447_2.tar.bz2": { + "build": "py27h672d447_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a9f09b1c2dc85bd87477b260c985813a", + "name": "ruamel_yaml", + "sha256": "65d223305731a6952727000b5d62f739c5cf972fa1fa18a7f50c2fb3ae778db5", + "size": 209704, + "subdir": "linux-64", + "timestamp": 1505693600028, + "version": "0.11.14" + }, + "ruamel_yaml-0.11.14-py35h8e2c16b_2.tar.bz2": { + "build": "py35h8e2c16b_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d2826b8d293ad6a30525d34ef3bcfd0", + "name": "ruamel_yaml", + "sha256": "f7dc1d39d3c87e8fb40bf90bbc892149aea78d7c40999d0bdd35bcdba0552c7c", + "size": 212023, + "subdir": "linux-64", + "timestamp": 1505693623828, + "version": "0.11.14" + }, + "ruamel_yaml-0.11.14-py36ha2fb22d_2.tar.bz2": { + "build": "py36ha2fb22d_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d156ceeeb4ecad376782357ff8e5795", + "name": "ruamel_yaml", + "sha256": "ef0f5f1465fc529200d1ff82da756fffb526c2ead3aee83b11d5d3d7a0f918ef", + "size": 214897, + "subdir": "linux-64", + "timestamp": 1505693648310, + "version": "0.11.14" + }, + "ruamel_yaml-0.15.100-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f60a3d04428c64921d0cf8debe121a7b", + "name": "ruamel_yaml", + "sha256": "00836fb6a32a84abb8911695741123763ef360320e17335d6d99026f1beb3291", + "size": 584088, + "subdir": "linux-64", + "timestamp": 1640794466215, + "version": "0.15.100" + }, + "ruamel_yaml-0.15.100-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5696d12ad0b56dcbcd706c5f060fc81a", + "name": "ruamel_yaml", + "sha256": "a79f9c455243139d0aa7c4945ef469b517f378044097e63c735cea54180a2b40", + "size": 273963, + "subdir": "linux-64", + "timestamp": 1616016338933, + "version": "0.15.100" + }, + "ruamel_yaml-0.15.100-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "110bc737f28a9e533dfdad87a90f55c4", + "name": "ruamel_yaml", + "sha256": "d545ff655e35d0cfe2d9cc6dd7bb8b95f4c578352d96d13517ebb05db932b135", + "size": 273331, + "subdir": "linux-64", + "timestamp": 1616016757254, + "version": "0.15.100" + }, + "ruamel_yaml-0.15.100-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "231800246340ebc12c7584ca25ec81b3", + "name": "ruamel_yaml", + "sha256": "878dad281d73c016f861bebb1ce25b7942b4b3e069e388cb6370d36ac5a81c68", + "size": 276803, + "subdir": "linux-64", + "timestamp": 1616016764495, + "version": "0.15.100" + }, + "ruamel_yaml-0.15.100-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d64a100cf9631996a8ea6b5720556e90", + "name": "ruamel_yaml", + "sha256": "706a773bc013bfeb0f2ca223c3a837851b8cd95fc635d5514cd1fb2861f1ef9f", + "size": 274137, + "subdir": "linux-64", + "timestamp": 1616016777781, + "version": "0.15.100" + }, + "ruamel_yaml-0.15.35-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b115fc734205c9383e7901dc5d701fb", + "name": "ruamel_yaml", + "sha256": "1ca007e72743b63b0f4271e1cb755a55d155aac2dc3d3bf46a5934baf5e435ba", + "size": 245635, + "subdir": "linux-64", + "timestamp": 1516376506124, + "version": "0.15.35" + }, + "ruamel_yaml-0.15.35-py27h14c3975_1.tar.bz2": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "842e2100536f1fdfa639acc3680f4ee6", + "name": "ruamel_yaml", + "sha256": "395fe75a8090e3b288bfe4e695280858fce7a2128f8a8d15c2d0315e6390694f", + "size": 245835, + "subdir": "linux-64", + "timestamp": 1516390673535, + "version": "0.15.35" + }, + "ruamel_yaml-0.15.35-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "yaml", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f6b9970422383ab1726b4cbd5ed9a84", + "name": "ruamel_yaml", + "sha256": "c7c4345755b4fe7f7ccf2b5f6a8604aa032d1d70cc700311fd757d2815959eff", + "size": 246595, + "subdir": "linux-64", + "timestamp": 1516376768265, + "version": "0.15.35" + }, + "ruamel_yaml-0.15.35-py35h14c3975_1.tar.bz2": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "yaml", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e07a859b6cad3656efb059def0135442", + "name": "ruamel_yaml", + "sha256": "fa26f695d6eddc1b95513e02ab1ffcced37121280e2dfba2979f2df9cdd128f4", + "size": 246476, + "subdir": "linux-64", + "timestamp": 1516390727612, + "version": "0.15.35" + }, + "ruamel_yaml-0.15.35-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a6448771dbe92ed6df83d0600fd18c0", + "name": "ruamel_yaml", + "sha256": "38544d905f34d6563a449b88a993b54cb169c4af46eff8f970544c92ac76fb3b", + "size": 250190, + "subdir": "linux-64", + "timestamp": 1516376763405, + "version": "0.15.35" + }, + "ruamel_yaml-0.15.35-py36h14c3975_1.tar.bz2": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2ac6003390340e26a2152504a11ac72", + "name": "ruamel_yaml", + "sha256": "b2d04b8975a913fd62c34c571d49a821093ceb38f7fc928f952bc18c6f085e6c", + "size": 250386, + "subdir": "linux-64", + "timestamp": 1516390695669, + "version": "0.15.35" + }, + "ruamel_yaml-0.15.37-py27h14c3975_2.tar.bz2": { + "build": "py27h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "253abf654607be134d957d244c6e8760", + "name": "ruamel_yaml", + "sha256": "885ca017b339cafc02afebc01931f4da6c32622ddfa02b4443b113a34f395d02", + "size": 245781, + "subdir": "linux-64", + "timestamp": 1528212215481, + "version": "0.15.37" + }, + "ruamel_yaml-0.15.37-py35h14c3975_2.tar.bz2": { + "build": "py35h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee790227157f89fefb051ff0be7d1ccb", + "name": "ruamel_yaml", + "sha256": "c49b28684192b86bb462e8ca02c984ee493788cefd5be91750aabda71b94b05d", + "size": 246151, + "subdir": "linux-64", + "timestamp": 1528212332576, + "version": "0.15.37" + }, + "ruamel_yaml-0.15.37-py36h14c3975_2.tar.bz2": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c8c9b42ef0f4cc94c6d3df14664942e7", + "name": "ruamel_yaml", + "sha256": "fdfc0adcc1bafccf9669d383b35cb12d103515959a9785cd7b2d244be75fe08e", + "size": 250838, + "subdir": "linux-64", + "timestamp": 1528212301550, + "version": "0.15.37" + }, + "ruamel_yaml-0.15.40-py27h14c3975_2.tar.bz2": { + "build": "py27h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "29de70c1086c02b220f48c7adb2447a8", + "name": "ruamel_yaml", + "sha256": "10cc951fffead24ff640283cfd70fca32c8441dea5961c3a9f40885d8bc1076c", + "size": 247263, + "subdir": "linux-64", + "timestamp": 1529355959657, + "version": "0.15.40" + }, + "ruamel_yaml-0.15.40-py35h14c3975_2.tar.bz2": { + "build": "py35h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "abebea7ca3212b4ee1400674c475a819", + "name": "ruamel_yaml", + "sha256": "b7f524f17c5ea62b3f677bc2804bb0679694a843d0b9615172a21e749b9d30c0", + "size": 247548, + "subdir": "linux-64", + "timestamp": 1529355936234, + "version": "0.15.40" + }, + "ruamel_yaml-0.15.40-py36h14c3975_2.tar.bz2": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c9e9098fec2a5943b7829e60fdc0da1", + "name": "ruamel_yaml", + "sha256": "d6ab1339aab635a30b0834218a9db388231825f5b2eeadb3f46a392230c5c813", + "size": 251459, + "subdir": "linux-64", + "timestamp": 1529355882967, + "version": "0.15.40" + }, + "ruamel_yaml-0.15.42-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bbf1fa0ae5f60a99db6233fde758fc06", + "name": "ruamel_yaml", + "sha256": "b6bc3718cb6e4bd42625f0e91d3ca9c6b2c2a4956a62284a84c9c95c70bdb101", + "size": 247072, + "subdir": "linux-64", + "timestamp": 1530548930123, + "version": "0.15.42" + }, + "ruamel_yaml-0.15.42-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "241c8648ad7b097f7f53fedfcbf79b3c", + "name": "ruamel_yaml", + "sha256": "474f31218c1f76642f8defb8227bd93a113ee662bf2472b73857ebc2ac33f17f", + "size": 247556, + "subdir": "linux-64", + "timestamp": 1530548846675, + "version": "0.15.42" + }, + "ruamel_yaml-0.15.42-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6fb6f3cf94b20e9092b01c5020d4c14e", + "name": "ruamel_yaml", + "sha256": "ed38dec0638d2ce55908b7f7beadf57cfe977cede2c85342ac3feb8d4ead39ad", + "size": 250954, + "subdir": "linux-64", + "timestamp": 1530548857867, + "version": "0.15.42" + }, + "ruamel_yaml-0.15.42-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f066f0e1b9b10526260504813f0c5c3f", + "name": "ruamel_yaml", + "sha256": "caa70883f666a78ccf2e292dc0fdcd16c9c6cfc42999b0df78c7a838fda67c70", + "size": 250420, + "subdir": "linux-64", + "timestamp": 1530737412735, + "version": "0.15.42" + }, + "ruamel_yaml-0.15.46-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f2571815bc52c4d8bde3386ebdaddbe", + "name": "ruamel_yaml", + "sha256": "c486060fd4fbad4375094c933da6735a047ec74903272e28516701670a0f2764", + "size": 247279, + "subdir": "linux-64", + "timestamp": 1532968689673, + "version": "0.15.46" + }, + "ruamel_yaml-0.15.46-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f351777f89e1cbf931bf54524b5699c3", + "name": "ruamel_yaml", + "sha256": "11e070a01d9153e50b125e060b17f54af0d3049c56c09c7a36f309c5a3d45738", + "size": 248372, + "subdir": "linux-64", + "timestamp": 1532968917187, + "version": "0.15.46" + }, + "ruamel_yaml-0.15.46-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e73c51e41be6147e77ba334c8b70cd9", + "name": "ruamel_yaml", + "sha256": "7d76b337fcfde60a16ac82872fbd0567e15e44b70fdc8c8d3107a9f1cd01ff02", + "size": 251232, + "subdir": "linux-64", + "timestamp": 1532968829687, + "version": "0.15.46" + }, + "ruamel_yaml-0.15.46-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c619e197774e5ad95303a739f75fdf2b", + "name": "ruamel_yaml", + "sha256": "9cd8cf46fa847a1cdb926312a35c2d5106395605a6bd6ed109ebd68a0ad64ba8", + "size": 250676, + "subdir": "linux-64", + "timestamp": 1532968916601, + "version": "0.15.46" + }, + "ruamel_yaml-0.15.80-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4caee14e4fc6f5eaee2e2bd6882706fe", + "name": "ruamel_yaml", + "sha256": "02ba281265d74a3d2df13b9d35012c34b667c12ca55c7c58034d55078165258b", + "size": 267116, + "subdir": "linux-64", + "timestamp": 1605527280571, + "version": "0.15.80" + }, + "ruamel_yaml-0.15.80-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b3e18d9de9b8c33042f775e23dcc8d52", + "name": "ruamel_yaml", + "sha256": "f68397d7ec5cea386f96cd8d5f5e5d6277624942fef59b0405ccc29be6d8517a", + "size": 268562, + "subdir": "linux-64", + "timestamp": 1605527318938, + "version": "0.15.80" + }, + "ruamel_yaml-0.15.80-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c27fc4b73d7bd7ed0254657a282ed6d", + "name": "ruamel_yaml", + "sha256": "272af24ab3bc0c64f9926c12275808380411a8ac5b87fab2df46454c7df80ebb", + "size": 273779, + "subdir": "linux-64", + "timestamp": 1605527348218, + "version": "0.15.80" + }, + "ruamel_yaml-0.15.80-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d0f7cf862fec8dd32ec49b32da3f46d5", + "name": "ruamel_yaml", + "sha256": "768c493d3ec481a8615918304163116d95e3de7466f47bf56810bbc0c7e2ed04", + "size": 269528, + "subdir": "linux-64", + "timestamp": 1605527334248, + "version": "0.15.80" + }, + "ruamel_yaml-0.15.87-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c08ae5731a53420ccb56562d4f9b8afd", + "name": "ruamel_yaml", + "sha256": "73ae82c459b0612239055749152e22e0229c6bd2fa51a17def43da34315ce91e", + "size": 260790, + "subdir": "linux-64", + "timestamp": 1576853131498, + "version": "0.15.87" + }, + "ruamel_yaml-0.15.87-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f492635184a5944fb67f55a922cb587e", + "name": "ruamel_yaml", + "sha256": "d2c75f31d5eeec16f8f908cf3b158249afdb17e2a4247af1a14df6dbd36e73f2", + "size": 279373, + "subdir": "linux-64", + "timestamp": 1576853114123, + "version": "0.15.87" + }, + "ruamel_yaml-0.15.87-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "268e6d147e4431e9e3589be064022e3c", + "name": "ruamel_yaml", + "sha256": "049d54a2d091f8e97e8f4845d00d1f9859e249e67abd302d3baae496c0ea8be9", + "size": 262121, + "subdir": "linux-64", + "timestamp": 1593122477432, + "version": "0.15.87" + }, + "ruamel_yaml-0.15.87-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c6c2c16bc38d4e6fdd3563abd7d26362", + "name": "ruamel_yaml", + "sha256": "ccd47d19bffc33dc0215b298d18664b14cd551f5afef985f5d6fc227355d5ae6", + "size": 277836, + "subdir": "linux-64", + "timestamp": 1576853112471, + "version": "0.15.87" + }, + "ruamel_yaml-0.15.87-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a19339d2dc55ea7efb1c8daba4cdc81", + "name": "ruamel_yaml", + "sha256": "a773def598a70867a61affc2c373d567cd93c751fa6061578539218040b51b59", + "size": 259255, + "subdir": "linux-64", + "timestamp": 1593122487619, + "version": "0.15.87" + }, + "ruamel_yaml-0.15.87-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2a2803fe4bd6d2b71615a2e3a0720a60", + "name": "ruamel_yaml", + "sha256": "6d253ca0e82ab9cb1f7c9c164b7508135ed44c1d72d2ed7a4b39b162bb98d49b", + "size": 275486, + "subdir": "linux-64", + "timestamp": 1573200629718, + "version": "0.15.87" + }, + "ruamel_yaml-0.15.87-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd8ace9fe39aed9113e87ae51920d60d", + "name": "ruamel_yaml", + "sha256": "62e28646e743809bf1f9d39c4590f73292deeba5b486055f67b497dd7c5d01b1", + "size": 262061, + "subdir": "linux-64", + "timestamp": 1593122490615, + "version": "0.15.87" + }, + "ruamel_yaml-0.17.21-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "ruamel.yaml.clib >=0.2.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "41f73fb8e399e942fae6c18ddfd32548", + "name": "ruamel_yaml", + "sha256": "7ce86f178987a983344777a33ad60da55cfa1847fd3119d5b78c3ca7c40a6c1c", + "size": 175573, + "subdir": "linux-64", + "timestamp": 1667489766326, + "version": "0.17.21" + }, + "ruamel_yaml-0.17.21-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b105c0ecb9e7fee3af4ddafe772dec0c", + "name": "ruamel_yaml", + "sha256": "35f331aa2a9552934684c6aabed63614d9c7719ba08e0019bf65fd2142cd5ab7", + "size": 245535, + "subdir": "linux-64", + "timestamp": 1676845723933, + "version": "0.17.21" + }, + "ruamel_yaml-0.17.21-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml.clib >=0.2.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "28998ae735b8c3b1c66a192291a1e18c", + "name": "ruamel_yaml", + "sha256": "f57e425b61bece493d79b720472ae47d7f85d60f61d6389f7fc4759662d93466", + "size": 171669, + "subdir": "linux-64", + "timestamp": 1667489829091, + "version": "0.17.21" + }, + "ruamel_yaml-0.17.21-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml.clib >=0.2.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47b6bae0c0ac9572a171bed14dae2205", + "name": "ruamel_yaml", + "sha256": "2877260caacd68bdc571872b1c154efb3ad8da7670da93290c9ca9962dd9c413", + "size": 172808, + "subdir": "linux-64", + "timestamp": 1667489860744, + "version": "0.17.21" + }, + "ruamel_yaml-0.17.21-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "ruamel.yaml.clib >=0.2.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3414b5176659d44c9ff4512a8022918c", + "name": "ruamel_yaml", + "sha256": "b39278f3f013161ddfa092555b9f5c167e6a9c2c25856e396b2cfe0799c3c535", + "size": 172824, + "subdir": "linux-64", + "timestamp": 1667489797680, + "version": "0.17.21" + }, + "ruby-2.4.1-h8a22fef_0.tar.bz2": { + "build": "h8a22fef_0", + "build_number": 0, + "depends": [ + "gmp 6.1.*", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "readline 7.*", + "tk 8.6.*", + "yaml", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2", + "license_family": "GPL", + "md5": "ff765a222d005ff9ee3b764d109c9f02", + "name": "ruby", + "sha256": "9af81796336c7f5b31649a36fe29ed2b5fed74697083ea13b87c36f78e78fbce", + "size": 5380726, + "subdir": "linux-64", + "timestamp": 1505734357389, + "track_features": "", + "version": "2.4.1" + }, + "ruby-2.4.1-hd4a244d_0.tar.bz2": { + "build": "hd4a244d_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "tk >=8.6.7,<8.7.0a0", + "yaml >=0.1.7,<0.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2", + "license_family": "GPL", + "md5": "6e1edc38e1d3d790345fd2122324fd35", + "name": "ruby", + "sha256": "f79e0337d2114715f3291b032ac34965536f3ded6a37e92a70ecf04df527aa07", + "size": 5381902, + "subdir": "linux-64", + "timestamp": 1510610977001, + "track_features": "", + "version": "2.4.1" + }, + "ruby-2.4.4-hdc09616_0.tar.bz2": { + "build": "hdc09616_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "tk >=8.6.7,<8.7.0a0", + "yaml >=0.1.7,<0.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2", + "license_family": "GPL", + "md5": "94b03982033276bc6066242b86ec80da", + "name": "ruby", + "sha256": "5714533fa8dd8637fce8a8833aee37ddd7677b020ccc3c480d429e1c3429111e", + "size": 5392353, + "subdir": "linux-64", + "timestamp": 1527866494571, + "track_features": "", + "version": "2.4.4" + }, + "ruby-2.5.1-h070849d_0.tar.bz2": { + "build": "h070849d_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "tk >=8.6.7,<8.7.0a0", + "yaml >=0.1.7,<0.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2", + "license_family": "GPL", + "md5": "e03509c4115804e3faacaf1e506a45a0", + "name": "ruby", + "sha256": "f10086fb1c516bdcf5d3fe9221d5ff6ae90af500041fa10d0e9f5d760b499a47", + "size": 5480735, + "subdir": "linux-64", + "timestamp": 1532875288807, + "track_features": "", + "version": "2.5.1" + }, + "ruby-2.5.1-h7fb2391_0.tar.bz2": { + "build": "h7fb2391_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "tk >=8.6.8,<8.7.0a0", + "yaml >=0.1.7,<0.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2", + "license_family": "GPL", + "md5": "ff34232363a5020d780fbc312d3d235f", + "name": "ruby", + "sha256": "4b36120577c2b454531c04d9b0acc871d4b6fa50213f6d36a015e6f6fb6a0b0d", + "size": 5509183, + "subdir": "linux-64", + "timestamp": 1540331435939, + "track_features": "", + "version": "2.5.1" + }, + "ruby-2.5.1-haf1161a_0.tar.bz2": { + "build": "haf1161a_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1e,<1.1.2a", + "readline >=8.0,<9.0a0", + "tk >=8.6.8,<8.7.0a0", + "yaml >=0.1.7,<0.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2", + "license_family": "GPL", + "md5": "de879f88ab2527504791603334f3b8a3", + "name": "ruby", + "sha256": "ae834aa406bb07c97b45b247402f52e7c82a0d86bcfaf49a2406ba620b606af4", + "size": 5304201, + "subdir": "linux-64", + "timestamp": 1585235786205, + "track_features": "", + "version": "2.5.1" + }, + "ruby-3.1.2-h006b21b_1.tar.bz2": { + "build": "h006b21b_1", + "build_number": 1, + "depends": [ + "gdbm >=1.18,<1.19.0a0", + "gmp >=6.1.2", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "3c2f42b5a2c43a1a785ab64d889d78c0", + "name": "ruby", + "sha256": "fb2f1102a20230f56b7048eced9f01e9f2785bc4b31940aca87251e2e5519c1f", + "size": 8815069, + "subdir": "linux-64", + "timestamp": 1669296053447, + "track_features": "rb31", + "version": "3.1.2" + }, + "ruby-3.1.2-h437172d_0.tar.bz2": { + "build": "h437172d_0", + "build_number": 0, + "depends": [ + "gdbm >=1.18,<1.19.0a0", + "gmp >=6.1.2", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1q,<1.1.2a", + "readline >=8.0,<9.0a0", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "502d51ba066b373f19ffacc82ca75e70", + "name": "ruby", + "sha256": "82344a160d9e6b75135eaa4ff21f293a56b0e2fe9e06ab0c08593622a6fc9561", + "size": 8824291, + "subdir": "linux-64", + "timestamp": 1658957971397, + "track_features": "rb31", + "version": "3.1.2" + }, + "runipy-0.1.5-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=2.7,<2.8.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "84db3c4aaf0cf9718128c0e93394f42f", + "name": "runipy", + "sha256": "2ea85b1b4f644a20a78cbe6374b4bec6d98cead14e045fd79b96412c994de3f5", + "size": 17108, + "subdir": "linux-64", + "timestamp": 1537812399290, + "version": "0.1.5" + }, + "runipy-0.1.5-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=3.10,<3.11.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c021835b3613d212583b4244dc071b52", + "name": "runipy", + "sha256": "e9e74a4aebdd944a8ce76983dd9fcadd1091546e7061434539e98646ecebb748", + "size": 17448, + "subdir": "linux-64", + "timestamp": 1641917394809, + "version": "0.1.5" + }, + "runipy-0.1.5-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=3.5,<3.6.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "42cca7a8309898ecb374869d4c7bcd57", + "name": "runipy", + "sha256": "265a4221a980d30d96dd0458aaa49f69f0e8929a7aa453a8000b182a19e06b40", + "size": 17241, + "subdir": "linux-64", + "timestamp": 1537812437565, + "version": "0.1.5" + }, + "runipy-0.1.5-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=3.6,<3.7.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "52369f30c5ee206820af1b24662ecc72", + "name": "runipy", + "sha256": "f202d89f3c85a172b2b6a0588babc2f978aac6bf36ec5d5b51cb6bf99f915341", + "size": 17201, + "subdir": "linux-64", + "timestamp": 1537812443378, + "version": "0.1.5" + }, + "runipy-0.1.5-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=3.6,<3.7.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4fa882307ad100458373fea14dd4bf31", + "name": "runipy", + "sha256": "72372abde6e2fd07864d2261ab80237046536b4e45a214cb0712f011bcb4aab5", + "size": 19239, + "subdir": "linux-64", + "timestamp": 1613492723567, + "version": "0.1.5" + }, + "runipy-0.1.5-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=3.7,<3.8.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "77760c5237fad6381c2d3ccbb59b65c5", + "name": "runipy", + "sha256": "a9e63e30b19205574c23dcd2683499147d619f4c9abce8d89ab5815cebfa5a3c", + "size": 17151, + "subdir": "linux-64", + "timestamp": 1537812377945, + "version": "0.1.5" + }, + "runipy-0.1.5-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=3.7,<3.8.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e15d85f10915efd87a10705f6ef0db9c", + "name": "runipy", + "sha256": "ed08a146d20a2f0fbda53c65a5de0a5997f323c3990c49dcba616686c09e5d90", + "size": 19199, + "subdir": "linux-64", + "timestamp": 1613493343205, + "version": "0.1.5" + }, + "runipy-0.1.5-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=3.8,<3.9.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "40b6ce1b03683824626aa886464b5050", + "name": "runipy", + "sha256": "cb43ea0c5ca9ace81c6c07c4887ac97b6e4dba5233eb4ac859ee8c68bcfad8d2", + "size": 19252, + "subdir": "linux-64", + "timestamp": 1592494391084, + "version": "0.1.5" + }, + "runipy-0.1.5-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=3.8,<3.9.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "668070065673cd4085fe8cfbd3118eeb", + "name": "runipy", + "sha256": "e9a01088d8b540be035078038ad35c3111d887b89580fb2d48a58f79d076a353", + "size": 19227, + "subdir": "linux-64", + "timestamp": 1613493338897, + "version": "0.1.5" + }, + "runipy-0.1.5-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=3.9,<3.10.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d74a53f7a88337f7b5e38b8b3770ad5f", + "name": "runipy", + "sha256": "67135c55daf2f7f89bfed586d21854724f11e4d4dc9c1df5678d0f6deefd3df6", + "size": 19288, + "subdir": "linux-64", + "timestamp": 1613492901270, + "version": "0.1.5" + }, + "rust-1.29.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MIT", + "md5": "da68dd0df86b4a97929c0eef5aaefacd", + "name": "rust", + "sha256": "71c32deed1a4bc5e8d6654022968db3427d7fc91421bb0887e49b131765f2c47", + "size": 212668610, + "subdir": "linux-64", + "timestamp": 1538132159927, + "version": "1.29.0" + }, + "rust-1.38.0-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [], + "license": "MIT", + "md5": "e28d045d84a3b5089333913c0c5af011", + "name": "rust", + "sha256": "122687a3ef124026900741043c1441d8b65b56107e5884e9542ea705cf630bd8", + "size": 344330260, + "subdir": "linux-64", + "timestamp": 1578326684608, + "version": "1.38.0" + }, + "rust-1.40.0-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [], + "license": "MIT", + "md5": "c0fa85065d94be31a0298a7536f9f62b", + "name": "rust", + "sha256": "2666da00a5680224e1de6b792bff0d98d5f4888fdf65d8d12368f45120b92d28", + "size": 152524338, + "subdir": "linux-64", + "timestamp": 1578437392548, + "version": "1.40.0" + }, + "rust-1.46.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MIT", + "md5": "1837262a3d1ab8ec1db7529f21638edb", + "name": "rust", + "sha256": "8ff323024f621cb21347621e9be37bb8e950070aaf8fb5d324ff5aa8c606075e", + "size": 180609641, + "subdir": "linux-64", + "timestamp": 1601251303126, + "version": "1.46.0" + }, + "rust-1.54.0-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MIT", + "md5": "0f202d0c76c5e72fab78e0e582464408", + "name": "rust", + "sha256": "32aafe4f7ae063b0ebbae8358f8e2cdca854dad278e64f4f854b84472ce5df28", + "size": 194813344, + "subdir": "linux-64", + "timestamp": 1628283936659, + "version": "1.54.0" + }, + "rust-1.56.0-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MIT", + "md5": "518070d1a32f4093c23808fcecc62471", + "name": "rust", + "sha256": "0cd4845b4ad9e52e6a4c3dfc0024e30257f271e65f358f8249b149f031c547ac", + "size": 203150968, + "subdir": "linux-64", + "timestamp": 1644236472385, + "version": "1.56.0" + }, + "rust-1.64.0-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MIT AND Apache-2.0", + "license_family": "OTHER", + "md5": "669a498aab8b03b0413a581552369f11", + "name": "rust", + "sha256": "8ac812531c9735bb1e7902ea288a56c0d0a23a7e04b7027ddfee1d1f3d4c393f", + "size": 226682296, + "subdir": "linux-64", + "timestamp": 1667949550954, + "version": "1.64.0" + }, + "rust-nightly-1.30.0_2018_09_30-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MIT", + "md5": "6ca790bfbf01b187a93436ca2ef1c59f", + "name": "rust-nightly", + "sha256": "8e737d453d006dd351a99cc50a69a7338288d977a10780340843e463a0896888", + "size": 209782679, + "subdir": "linux-64", + "timestamp": 1538392465570, + "version": "1.30.0_2018_09_30" + }, + "rust-nightly_linux-64-1.30.0_2018_09_30-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "rust-nightly 1.30.0_2018_09_30.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96dea805ba949074bacf137c60ed8170", + "name": "rust-nightly_linux-64", + "sha256": "cccbeb2f7f2c3db6a8bb23309187cb23cf084c3d8f54124ec8308463fb3039a1", + "size": 4374, + "subdir": "linux-64", + "timestamp": 1538405867619, + "version": "1.30.0_2018_09_30" + }, + "rust_linux-64-1.29.0-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "rust" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "24b244491b33107b0ef874f7674877b7", + "name": "rust_linux-64", + "sha256": "207b7e04a8bc1324175251324537bb55bdbf1d50e016c90e59c4b52f7e04d8d1", + "size": 7503, + "subdir": "linux-64", + "timestamp": 1538173510721, + "version": "1.29.0" + }, + "rust_linux-64-1.38.0-he6710b0_1.tar.bz2": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "rust >=1.38.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b535c4066b5a0739d6e095063d3ab258", + "name": "rust_linux-64", + "sha256": "4def8899cddd4d8fe0d9247d7976e371158cb92a427abd686b4fe50d9219c57c", + "size": 156820, + "subdir": "linux-64", + "timestamp": 1578413385278, + "version": "1.38.0" + }, + "rust_linux-64-1.40.0-he6710b0_1.tar.bz2": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "rust >=1.40.0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "12aa21b4bc870baba86abc9b8ed0d6e2", + "name": "rust_linux-64", + "sha256": "b4e291084f0b01e643e7cf2a4e74bdbf4659f5972e291124386e40a10dee5237", + "size": 157551, + "subdir": "linux-64", + "timestamp": 1578438200996, + "version": "1.40.0" + }, + "rust_linux-64-1.46.0-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "rust >=1.46.0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "43ac22ee11dafc858962415867d5158f", + "name": "rust_linux-64", + "sha256": "a86e1af29fb4f51fb1856a12e9d772437b490241772f981dc1add8c39f0728f5", + "size": 364621, + "subdir": "linux-64", + "timestamp": 1601256610346, + "version": "1.46.0" + }, + "rust_linux-64-1.46.0-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "gcc_linux-64", + "gxx_linux-64", + "rust >=1.46.0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "361e9a23d8c7c4a9ec68ae337af04c96", + "name": "rust_linux-64", + "sha256": "c9197e03f953565d2fdb5f67ef2790e23b470f3a5b83e550a29c1b99a1176ca2", + "size": 185015, + "subdir": "linux-64", + "timestamp": 1601256699279, + "version": "1.46.0" + }, + "rust_linux-64-1.56.0-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 7.5.0.*", + "gxx_linux-64 7.5.0.*", + "rust >=1.56.0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "ee776821d3a5144652f3d4946069dfe4", + "name": "rust_linux-64", + "sha256": "c6bb7d13ebab0af8abb6c374fa4bb1df827d5024d27354c6be7f28559b71e337", + "size": 8995, + "subdir": "linux-64", + "timestamp": 1644236898618, + "version": "1.56.0" + }, + "rust_linux-64-1.64.0-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 11.2.0.*", + "gxx_linux-64 11.2.0.*", + "rust >=1.64.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ef289d759b4c2f9ebf97deec251c461a", + "name": "rust_linux-64", + "sha256": "e60d235af9a48bb4255e311d41c05660b16de4226da46dd18df39e2d5cc7dd29", + "size": 6676, + "subdir": "linux-64", + "timestamp": 1667954527423, + "version": "1.64.0" + }, + "rust_linux-64-1.64.0-h6a678d5_1.tar.bz2": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "gcc_linux-64 11.2.0.*", + "gxx_linux-64 11.2.0.*", + "rust >=1.64.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cafd82b48140ab89e1a64e12bb1cb582", + "name": "rust_linux-64", + "sha256": "6c92562de386f404946d6b658a77da34db64ef986febb68807847c0014b8e556", + "size": 6673, + "subdir": "linux-64", + "timestamp": 1670833656584, + "version": "1.64.0" + }, + "s3fs-0.1.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b69fe9bff56a1373ad76f2c488528761", + "name": "s3fs", + "sha256": "4469a62a96b1768bf4142ebb7e29640d5eac7328b83e49cbcd305f6423cd6d5d", + "size": 31500, + "subdir": "linux-64", + "timestamp": 1519757907827, + "version": "0.1.3" + }, + "s3fs-0.1.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "95ac3daef7c2336533a7871344527c35", + "name": "s3fs", + "sha256": "762082700c22e120b2195f459822399f19eff4996314a39b9d40981d70d8a9b4", + "size": 32575, + "subdir": "linux-64", + "timestamp": 1519757955228, + "version": "0.1.3" + }, + "s3fs-0.1.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "94b9b6157478763912e0744fbe4e35d6", + "name": "s3fs", + "sha256": "4b5794f27f59c1e233384ca56b4307f0048f7a3683bf882537e97fa3db2fd624", + "size": 32378, + "subdir": "linux-64", + "timestamp": 1519757890218, + "version": "0.1.3" + }, + "s3fs-0.1.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3b10522ac3dd016cdb6d809eb6d5cba8", + "name": "s3fs", + "sha256": "f30baaa68704841d98e9816df2135f9c02d3e2cca83c6a413d9433f2f8950c7b", + "size": 31857, + "subdir": "linux-64", + "timestamp": 1522194993255, + "version": "0.1.4" + }, + "s3fs-0.1.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fc7077a5d1ceafa678a41f5b25f399c2", + "name": "s3fs", + "sha256": "1a51611efcb51560c58c58a2330fe7264dae89f95b7ca6474034262445d38e59", + "size": 32863, + "subdir": "linux-64", + "timestamp": 1522195066409, + "version": "0.1.4" + }, + "s3fs-0.1.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f45de89cfe7f9354231e7f420d8f97d6", + "name": "s3fs", + "sha256": "fd602841c03052fe9bd4aba99a4a8501e631f4ebab834f8d6076ba0103af8f03", + "size": 32717, + "subdir": "linux-64", + "timestamp": 1522195069085, + "version": "0.1.4" + }, + "s3fs-0.1.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8ceeb4c28d99d7cbee3b0a414a57e59a", + "name": "s3fs", + "sha256": "01894414e63eafca258cf194e33a5c6e5c8f6b78be8c89b1fe0d9aed32312aec", + "size": 33609, + "subdir": "linux-64", + "timestamp": 1526916496593, + "version": "0.1.5" + }, + "s3fs-0.1.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ca97d1e8fcec4e9e49f5cf481729a808", + "name": "s3fs", + "sha256": "3974c784144fe70348ba27cc4b400940e822f9d06efbb5d553e028c460838b62", + "size": 34682, + "subdir": "linux-64", + "timestamp": 1526916471919, + "version": "0.1.5" + }, + "s3fs-0.1.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f04839b1752a95a8c6ab7b4180086c3a", + "name": "s3fs", + "sha256": "b6d9a32baba881c84fbc8a9a56bf8d3504ca87357a992736e1369787906f1875", + "size": 34504, + "subdir": "linux-64", + "timestamp": 1526916383911, + "version": "0.1.5" + }, + "s3fs-0.1.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5c97da55c63fbc4848e835c7737ab343", + "name": "s3fs", + "sha256": "d55fc7988d009eeea2500987d808825d4f6ba32a92e1c7c3ab5e8464a59d9f7e", + "size": 34473, + "subdir": "linux-64", + "timestamp": 1530959551376, + "version": "0.1.5" + }, + "s3fs-0.1.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "19543efb5bd8e3cc56d03592526daa2a", + "name": "s3fs", + "sha256": "37fe27cad822ba06e480299688585cecc47fdd5ed00af65eebc308e814a60f2e", + "size": 34622, + "subdir": "linux-64", + "timestamp": 1535116751546, + "version": "0.1.6" + }, + "s3fs-0.1.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b62399cf8112fe94962a56c06624d336", + "name": "s3fs", + "sha256": "1f51a4a85e390af07420c6a27d35605356541fb180edae4ae6d46c357a834da1", + "size": 35633, + "subdir": "linux-64", + "timestamp": 1535116756880, + "version": "0.1.6" + }, + "s3fs-0.1.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e7b21240f88781b526b1fbe41d62d1ca", + "name": "s3fs", + "sha256": "20e776c4602764bc0cf6e7d866d4358c637a83f3509b53eecaa413ea2ae71fbc", + "size": 35447, + "subdir": "linux-64", + "timestamp": 1535116687696, + "version": "0.1.6" + }, + "s3fs-0.1.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e65a01a26c78736d47271e7b48e79fe0", + "name": "s3fs", + "sha256": "1c9f88e94211ab955572c96aac7dbec1fddc1ed93c9d01bb9711324e74e7920b", + "size": 35540, + "subdir": "linux-64", + "timestamp": 1535116611470, + "version": "0.1.6" + }, + "s3fs-0.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d4714c34dd602bb56d4d847a3437db07", + "name": "s3fs", + "sha256": "9da8038dd612fa116e1af106851b6109392ae13740da9f032941ca95092bd492", + "size": 39858, + "subdir": "linux-64", + "timestamp": 1543615026693, + "version": "0.2.0" + }, + "s3fs-0.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d9d0ad4542f6c3f78f99fb99bfa1f550", + "name": "s3fs", + "sha256": "1bc036315a71ac472f58a0627d93139c32b12e5af78e94b4f996107d59313b08", + "size": 40839, + "subdir": "linux-64", + "timestamp": 1543615045657, + "version": "0.2.0" + }, + "s3fs-0.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ce1281cc0956974e588f664dbded7d3e", + "name": "s3fs", + "sha256": "cccf2f444713c1ac9e19337608b01cc132864dde4da2ee6365b5b4ace0d4765a", + "size": 40792, + "subdir": "linux-64", + "timestamp": 1543614984206, + "version": "0.2.0" + }, + "s3fs-2022.10.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore 2.4.0", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2022.10.0.*", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2fc2795dd17153cf9db01c83c21e69fe", + "name": "s3fs", + "sha256": "36101f7f0b7edc962546e0a2197a5043fa693ade5af3d5e53ffcb0e2b874f757", + "size": 51970, + "subdir": "linux-64", + "timestamp": 1667506066697, + "version": "2022.10.0" + }, + "s3fs-2022.10.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore 2.4.0", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2022.10.0.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "69f46b4f367b461c0dcff554c42ab378", + "name": "s3fs", + "sha256": "e6c6fe7e64232180d74104811b76b3a03283f8689c7da5ced12b68d06ac12a60", + "size": 50632, + "subdir": "linux-64", + "timestamp": 1667506038588, + "version": "2022.10.0" + }, + "s3fs-2022.10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore 2.4.0", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2022.10.0.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1b0488786326ae7ab9fa3c58af9343ca", + "name": "s3fs", + "sha256": "a9e6cea987365be6c2922241ef52774d70d5fe945bb8555397d6fada091611e7", + "size": 50962, + "subdir": "linux-64", + "timestamp": 1667505981886, + "version": "2022.10.0" + }, + "s3fs-2022.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore 2.4.0", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2022.10.0.*", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8c5f1266b94f30572b45d9c018b06b23", + "name": "s3fs", + "sha256": "084633a401a2b5e22b8fdf1586019b09bc36e5320bb5e0714fddf83e2a9c9748", + "size": 51058, + "subdir": "linux-64", + "timestamp": 1667506010139, + "version": "2022.10.0" + }, + "s3fs-2022.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore 2.4.*", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2022.11.0.*", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e0222f341b2e070bbef8bd636f115d9b", + "name": "s3fs", + "sha256": "ba496b9a2e005526de3ad2a9357708cccbbf4e2cfc9eb4add03debe3af88972e", + "size": 52265, + "subdir": "linux-64", + "timestamp": 1670361805728, + "version": "2022.11.0" + }, + "s3fs-2022.11.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore 2.4.*", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2022.11.0.*", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "69e6a71b977b5326a2605032eae65bd9", + "name": "s3fs", + "sha256": "2a1d53515cf4fe031a28575dedbfcfad6b7afaeac7c91a09e0a9e189d83ce9f2", + "size": 69788, + "subdir": "linux-64", + "timestamp": 1676861922701, + "version": "2022.11.0" + }, + "s3fs-2022.11.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore 2.4.*", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2022.11.0.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b6d2bb59e909711c59df59bd2a0a8284", + "name": "s3fs", + "sha256": "2f80a98e300b594746bae2c037e0d79ef72bb7c8f09d8988d5cace3a7d5238be", + "size": 50889, + "subdir": "linux-64", + "timestamp": 1670361722473, + "version": "2022.11.0" + }, + "s3fs-2022.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore 2.4.*", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2022.11.0.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1d0cccb8578049f0b8392da066286e72", + "name": "s3fs", + "sha256": "5f3c47d4207564b24f08375a32676fb52f3fb5e4596e89994e8d46ad7b3c3aca", + "size": 51269, + "subdir": "linux-64", + "timestamp": 1670361750517, + "version": "2022.11.0" + }, + "s3fs-2022.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore 2.4.*", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2022.11.0.*", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a0b1257531264a4f25f419b68e5b544", + "name": "s3fs", + "sha256": "44558966912ae60029232c8e73cbb215d20e77af30fce44243dabb1afca841c4", + "size": 51311, + "subdir": "linux-64", + "timestamp": 1670361777881, + "version": "2022.11.0" + }, + "s3fs-2023.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore >=2.4.2,<2.5", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2023.3.0.*", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "44d870fe9c2361ab501fca56a216d5c9", + "name": "s3fs", + "sha256": "d6705bfd30e277cdd296b78489d4650388ca47580f1b7734c25d9b699491e07b", + "size": 53187, + "subdir": "linux-64", + "timestamp": 1680018559041, + "version": "2023.3.0" + }, + "s3fs-2023.3.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore >=2.4.2,<2.5", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2023.3.0.*", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7737c928e3e392fd7be8cccd67b9cdc5", + "name": "s3fs", + "sha256": "3d5bd7a44d5f6796dd5658f517666ab047b3a92b0a6c8bf05f9db1b84ef622da", + "size": 70419, + "subdir": "linux-64", + "timestamp": 1680018531075, + "version": "2023.3.0" + }, + "s3fs-2023.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore >=2.4.2,<2.5", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2023.3.0.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d69f72b825acac973a72e9fa68dbe20f", + "name": "s3fs", + "sha256": "3d9b925c8dcdc4158facc8785f05582b376bfe355d489bff991f4d7e672bc3f5", + "size": 52192, + "subdir": "linux-64", + "timestamp": 1680018503416, + "version": "2023.3.0" + }, + "s3fs-2023.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore >=2.4.2,<2.5", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2023.3.0.*", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "864d2ce505faa5987a17b235407e8d0e", + "name": "s3fs", + "sha256": "b3fe389322b41e201d2d4496a48103c9ea5b6f8af95a320c50d2dc228945578c", + "size": 52228, + "subdir": "linux-64", + "timestamp": 1680018585493, + "version": "2023.3.0" + }, + "s3transfer-0.1.10-py27h9fb3302_1.tar.bz2": { + "build": "py27h9fb3302_1", + "build_number": 1, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "futures >=2.2.0,<4.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a13e6b9f6f20e4f3e192cc39c5b1de45", + "name": "s3transfer", + "sha256": "ebafdf085afa0bcce73c1e50199c011a9a73640aa32350c7a5bceacabe0b3e13", + "size": 70050, + "subdir": "linux-64", + "timestamp": 1505741285250, + "version": "0.1.10" + }, + "s3transfer-0.1.10-py35h0bc0b65_1.tar.bz2": { + "build": "py35h0bc0b65_1", + "build_number": 1, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b88f9479cd5c686038110689f54d8104", + "name": "s3transfer", + "sha256": "cad0510020bf0014d129dba8f50b97ccd3b8e00fb896e987c30ca98650af80e6", + "size": 72310, + "subdir": "linux-64", + "timestamp": 1505741298472, + "version": "0.1.10" + }, + "s3transfer-0.1.10-py36h0257dcc_1.tar.bz2": { + "build": "py36h0257dcc_1", + "build_number": 1, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d9179587ba9d0bd549c1542ffa53c1dd", + "name": "s3transfer", + "sha256": "16f56e0e2f5020688823164b21f3b62a0a8ce7a9f41d674fd715a25854fd21a7", + "size": 72197, + "subdir": "linux-64", + "timestamp": 1505741311941, + "version": "0.1.10" + }, + "s3transfer-0.1.11-py27h83d00de_1.tar.bz2": { + "build": "py27h83d00de_1", + "build_number": 1, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "futures >=2.2.0,<4.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f7ee55cb93dfe3b385800b0656debd21", + "name": "s3transfer", + "sha256": "5e47198adeb328174865b1df8210c0bdeae8cbfe681c8c9065c1ea92d9527892", + "size": 70568, + "subdir": "linux-64", + "timestamp": 1511320230052, + "version": "0.1.11" + }, + "s3transfer-0.1.11-py35hb3b1e1f_1.tar.bz2": { + "build": "py35hb3b1e1f_1", + "build_number": 1, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ddaa6d8cb1ae82b659992f5eec3121e2", + "name": "s3transfer", + "sha256": "ec898b85582ac889885669bb665f586158d88f263834a822847c6ef9ef031f32", + "size": 72875, + "subdir": "linux-64", + "timestamp": 1511320229352, + "version": "0.1.11" + }, + "s3transfer-0.1.11-py36haba1813_1.tar.bz2": { + "build": "py36haba1813_1", + "build_number": 1, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f3741a3d3df5ae373f971853bcb0d25f", + "name": "s3transfer", + "sha256": "7968f0b9faec01644af3064e0d8c862ccae981593efb588eb6f904ac8d36d77a", + "size": 72471, + "subdir": "linux-64", + "timestamp": 1511320232919, + "version": "0.1.11" + }, + "s3transfer-0.1.13-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "futures >=2.2.0,<4.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e09e5e750d07c5ceb7941683605c4244", + "name": "s3transfer", + "sha256": "a4c36defd9e25928b017938f2fe26cf0818e5d02dde84158ffd46101847b8e33", + "size": 76129, + "subdir": "linux-64", + "timestamp": 1519832449290, + "version": "0.1.13" + }, + "s3transfer-0.1.13-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c8de7c452c0d352b79118b9b186bd827", + "name": "s3transfer", + "sha256": "597e7f69245270bc073c329356aa8f2780059c04801b7b2ee236ee414c6af50a", + "size": 78726, + "subdir": "linux-64", + "timestamp": 1519832478048, + "version": "0.1.13" + }, + "s3transfer-0.1.13-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7380fa5fa5a47f9af513f7d17ef92c74", + "name": "s3transfer", + "sha256": "252446ca3c3a7a19e7f12352a024dc97207848f04936930f5e522d067d2fe7b7", + "size": 78270, + "subdir": "linux-64", + "timestamp": 1519832430360, + "version": "0.1.13" + }, + "s3transfer-0.1.13-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1e46b16ea5b8cb393d50448308870719", + "name": "s3transfer", + "sha256": "70455667f878bf6d8ffee96765ed7c93f167ff4cb0e985c59256bd241d3f168d", + "size": 78305, + "subdir": "linux-64", + "timestamp": 1530781291609, + "version": "0.1.13" + }, + "s3transfer-0.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "futures >=2.2.0,<4.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "12eaccc1aa522ce442b89ed794117a1e", + "name": "s3transfer", + "sha256": "6a3a6aa0dc28b1ad77adeef6c9fae847b3bb968dbb9572de608e7d2bc6f18e3e", + "size": 92665, + "subdir": "linux-64", + "timestamp": 1552343395520, + "version": "0.2.0" + }, + "s3transfer-0.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9b6fe561a044e4f3af0b804b4ef8f2fe", + "name": "s3transfer", + "sha256": "7967ea140db07fc377c84fb06091b92b4bf20e74f64ad49cdaf35d558cb61676", + "size": 95356, + "subdir": "linux-64", + "timestamp": 1552343432569, + "version": "0.2.0" + }, + "s3transfer-0.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1f146dbb2c3c3b6cfa953e4d87a3eb5c", + "name": "s3transfer", + "sha256": "4c8dcbbc88485217a8bb1c26941698b826316d2b42e2844e09965e563c3cd709", + "size": 95366, + "subdir": "linux-64", + "timestamp": 1552343372125, + "version": "0.2.0" + }, + "s3transfer-0.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "futures >=2.2.0,<4.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "daabe7e356ba19611198dfb14b2f5c15", + "name": "s3transfer", + "sha256": "06f6a5abbcaf4ecdf3b265ef157f9dff07dbc1e6435ab4d00d3f3cac92a9ae4a", + "size": 95241, + "subdir": "linux-64", + "timestamp": 1564755070934, + "version": "0.2.1" + }, + "s3transfer-0.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a7214b12e5d04b29e48b8d1360914e75", + "name": "s3transfer", + "sha256": "d0f923966d4c48f68e49facef2531f1c29798032eeb7a4e97f65c1ae8edc5098", + "size": 97967, + "subdir": "linux-64", + "timestamp": 1564754856743, + "version": "0.2.1" + }, + "s3transfer-0.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8a93a686f6ce6ee352dce01b153d7285", + "name": "s3transfer", + "sha256": "43300c065845ddb3da8392ba0b1731a6b3498e3d49c68f763daa7177add4dba4", + "size": 98049, + "subdir": "linux-64", + "timestamp": 1564755055293, + "version": "0.2.1" + }, + "s3transfer-0.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "futures >=2.2.0,<4.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e1d6506cf3e8b700fe2b66fdf213db3b", + "name": "s3transfer", + "sha256": "638f2a6e435f0b3256c7e23c77809ffff79d382bb48efcdee3a35cec90fa41bb", + "size": 94383, + "subdir": "linux-64", + "timestamp": 1578947872520, + "version": "0.3.0" + }, + "s3transfer-0.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "473ef02ae07669257c356a1f6594c316", + "name": "s3transfer", + "sha256": "9bb064707653d6bf3940a7170b130408a5aa51f8a78a302feee563f7876cfb8f", + "size": 97140, + "subdir": "linux-64", + "timestamp": 1578947875813, + "version": "0.3.0" + }, + "s3transfer-0.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d4d3aadea2492adfd30f10a4ca7ca1de", + "name": "s3transfer", + "sha256": "a0bef96189cb9a2e64d796537df12a20c946e77070d64fed96e918be860abb62", + "size": 97297, + "subdir": "linux-64", + "timestamp": 1578947838462, + "version": "0.3.0" + }, + "s3transfer-0.3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a4f06dcb8452deb7ac7f6be6ec3ff0d3", + "name": "s3transfer", + "sha256": "82d5a41d32bfa82d3573f18e0581bafe2f2d5e05c67874ce1392ff2263628b24", + "size": 98071, + "subdir": "linux-64", + "timestamp": 1578947878080, + "version": "0.3.0" + }, + "s3transfer-0.3.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9a342caa2e0994b8eb23a8811a76a73d", + "name": "s3transfer", + "sha256": "23074158b14bf68bcc4cc51a7a3452a2e167496c3e8b0d22cb97aa47c8678899", + "size": 97361, + "subdir": "linux-64", + "timestamp": 1581606261276, + "version": "0.3.3" + }, + "s3transfer-0.3.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "be6866398a94a9cb97ac2fc8adf9c9e4", + "name": "s3transfer", + "sha256": "7ea9e081c27747dc52142780c965c4d5387145594e0d2e9818ea7b0fa0cec78b", + "size": 97152, + "subdir": "linux-64", + "timestamp": 1581606263299, + "version": "0.3.3" + }, + "s3transfer-0.3.3-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a0bb88fa8afc047b9ebc6f53815771e8", + "name": "s3transfer", + "sha256": "f22fe22dd763bd9bc8f226a1dbbaca9821a8fea4da06118c26df5fa12261b5f9", + "size": 92466, + "subdir": "linux-64", + "timestamp": 1594420395099, + "version": "0.3.3" + }, + "s3transfer-0.3.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "94bf59cbb86436c8938573248ceb5d19", + "name": "s3transfer", + "sha256": "ddab9ca2df536a6995aa6738295197b8e4fc3d8eac6189a31ddebf164d3b1603", + "size": 98064, + "subdir": "linux-64", + "timestamp": 1581606286012, + "version": "0.3.3" + }, + "s3transfer-0.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0a.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2b75b2aeccbbec2f5288716776672515", + "name": "s3transfer", + "sha256": "74ceca7a38ee3d92a713004ffaae4756aa4c29dfaa24daedbfc650b8c873de3a", + "size": 104698, + "subdir": "linux-64", + "timestamp": 1654524325680, + "version": "0.6.0" + }, + "s3transfer-0.6.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0a.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2827e9e4de86b1aaf7dc78e635c46781", + "name": "s3transfer", + "sha256": "ab22818fa54d5fbbbf0d971d83dc42be642feb703f9b81dfad29cea340979370", + "size": 132073, + "subdir": "linux-64", + "timestamp": 1676828822039, + "version": "0.6.0" + }, + "s3transfer-0.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0a.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0c5926836fde2a17d428d9a7cf01768c", + "name": "s3transfer", + "sha256": "8494650cf805e97928b4db0244dacdfa55fb9309741884dfc9be1007e99680a8", + "size": 102675, + "subdir": "linux-64", + "timestamp": 1654524286531, + "version": "0.6.0" + }, + "s3transfer-0.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0a.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "95cf23bb02a07c98797eb8eb937a30c0", + "name": "s3transfer", + "sha256": "6112afc3c02dfcc38f265a6ca1a056089bce47f0d397298a76bf1576b3a7b49d", + "size": 103421, + "subdir": "linux-64", + "timestamp": 1654524228409, + "version": "0.6.0" + }, + "s3transfer-0.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0a.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "023941930b6e178275973ec595f79a40", + "name": "s3transfer", + "sha256": "296cbd3ecf5cb0c12e4bf79b7cbf2f23eb07b78a0e2581195f403832f429c31f", + "size": 103415, + "subdir": "linux-64", + "timestamp": 1654524258248, + "version": "0.6.0" + }, + "safeint-3.0.26-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9adf340ebacb2e8d1a30e1ce20640c0", + "name": "safeint", + "sha256": "316c8ee2772e071c761d9908d015313ae8680b0e87ddfa71231d6b78933ef35f", + "size": 34961, + "subdir": "linux-64", + "timestamp": 1659021372274, + "version": "3.0.26" + }, + "sas7bdat-2.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "e672667515f955d316ee2fca2e04b76e", + "name": "sas7bdat", + "sha256": "4fefafb3b8ed3d2152e62df54ff8b9b0c6092023cf4ef4e6272d6ce8b35038f4", + "size": 29828, + "subdir": "linux-64", + "timestamp": 1529984027153, + "version": "2.1.1" + }, + "sas7bdat-2.1.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "d1bd928ff286ea8eaf173cb5142a7353", + "name": "sas7bdat", + "sha256": "529282d922c946b78f3908471a22beb3219074411c9f4af3ac93c833b8b63e0d", + "size": 30523, + "subdir": "linux-64", + "timestamp": 1529984049144, + "version": "2.1.1" + }, + "sas7bdat-2.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "ef9c8b289375cc32c91927925881bfe5", + "name": "sas7bdat", + "sha256": "5f208246a415d0f3f09b6e322178b25bffe2794a030a6d207fd06a7f2eb9ea36", + "size": 30352, + "subdir": "linux-64", + "timestamp": 1529984000289, + "version": "2.1.1" + }, + "sas7bdat-2.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "97b57fa22def32f0a5d128dbd9270fd3", + "name": "sas7bdat", + "sha256": "d895ac72f51b2ee50f9bcdeab11fe2e2efd7ca4a1aef99e8f6b1f8797ed89f52", + "size": 30171, + "subdir": "linux-64", + "timestamp": 1541048261281, + "version": "2.1.2" + }, + "sas7bdat-2.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "b23a49583121a04e53e21755187c01ab", + "name": "sas7bdat", + "sha256": "1f2741253dbb714e41511157281a2efcef670c81f78943d9c742585df4c5c026", + "size": 30662, + "subdir": "linux-64", + "timestamp": 1541048279048, + "version": "2.1.2" + }, + "sas7bdat-2.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "93a531eefaac10ad00723515dcabdc09", + "name": "sas7bdat", + "sha256": "5b4a613046a27d8bf1a3b410206cc92053fd4ee392f1cbfc4467fccf5c3624e4", + "size": 30769, + "subdir": "linux-64", + "timestamp": 1541048247873, + "version": "2.1.2" + }, + "sas7bdat-2.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "475c3fa6e68232a6700357b41652baac", + "name": "sas7bdat", + "sha256": "99e69f7ad795897f4a86f757572ad7a69f3d0b1db0cebeb214df9855436e8890", + "size": 28831, + "subdir": "linux-64", + "timestamp": 1541443740669, + "version": "2.2.1" + }, + "sas7bdat-2.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "7b4df40907dbce8055dd4223b74be0d8", + "name": "sas7bdat", + "sha256": "45c311039cd7ff9e2ee7a481342a70740002b66e78518c490543d8ce3928808c", + "size": 29296, + "subdir": "linux-64", + "timestamp": 1541443758255, + "version": "2.2.1" + }, + "sas7bdat-2.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "3391d6dd2a9ad2e243df895c0b40164e", + "name": "sas7bdat", + "sha256": "de1fc55eaee436d9656095fcc9e11db7b8e1ca566f4c219104ab032dc14bf843", + "size": 29351, + "subdir": "linux-64", + "timestamp": 1541443729505, + "version": "2.2.1" + }, + "sas7bdat-2.2.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "1036c6076a6e00a660098e8ab34c0536", + "name": "sas7bdat", + "sha256": "24be0f0c276f368ad58b281a5af5369c1590cfe9d87c128ac609dfdf84c642d4", + "size": 155657, + "subdir": "linux-64", + "timestamp": 1547491110181, + "version": "2.2.2" + }, + "sas7bdat-2.2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "0fcc090dcfc81f9c32b205213726421f", + "name": "sas7bdat", + "sha256": "c094ef9144e3b351cbdaca49b849e9e82eaed6c6ff995eeecb58f4b6c89ba948", + "size": 156065, + "subdir": "linux-64", + "timestamp": 1547491191502, + "version": "2.2.2" + }, + "sas7bdat-2.2.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "9335c00abfc66544f6bca41755ecc864", + "name": "sas7bdat", + "sha256": "10338a4372a6c9bfa8644aa917d58726f0d547b7ccc6e4c05e044ca7c842a5b3", + "size": 156185, + "subdir": "linux-64", + "timestamp": 1547491143249, + "version": "2.2.2" + }, + "sas_kernel-2.1.7-py35h00c0a0d_0.tar.bz2": { + "build": "py35h00c0a0d_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "jupyter_client >=4.4.0", + "metakernel >=0.18.0", + "pygments", + "python >=3.5,<3.6.0a0", + "saspy >=1.2.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "199ed4d2864d00d3c65194c8a727dc10", + "name": "sas_kernel", + "sha256": "23a45d26f38b258aa61670db8023440b401eba50d3b60ab6913bcf3b5c7c9e5d", + "size": 68036, + "subdir": "linux-64", + "timestamp": 1506850596047, + "version": "2.1.7" + }, + "sas_kernel-2.1.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "jupyter_client >=4.4.0", + "metakernel >=0.18.0", + "pygments", + "python >=3.6,<3.7.0a0", + "saspy >=1.2.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d354b8372bbe44600de563f21ea168dd", + "name": "sas_kernel", + "sha256": "8ff3bb34acaa0492f2b3ee8ce6cdcbe0245c3336c618529d2969e033aefa616e", + "size": 67432, + "subdir": "linux-64", + "timestamp": 1530959628481, + "version": "2.1.7" + }, + "sas_kernel-2.1.7-py36he3a6759_0.tar.bz2": { + "build": "py36he3a6759_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "jupyter_client >=4.4.0", + "metakernel >=0.18.0", + "pygments", + "python >=3.6,<3.7.0a0", + "saspy >=1.2.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a9e8b41c1cf0c44eac7652bdc5bd070b", + "name": "sas_kernel", + "sha256": "5cf808fdde7573f966b7c0cc1c8e7dad8c5887fbb820b020db733bc003780cf0", + "size": 67940, + "subdir": "linux-64", + "timestamp": 1506850606970, + "version": "2.1.7" + }, + "sas_kernel-2.1.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "jupyter_client >=4.4.0", + "metakernel >=0.18.0", + "pygments", + "python >=3.7,<3.8.0a0", + "saspy >=1.2.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fa703b7dd523b419056ea3a15ca26b0e", + "name": "sas_kernel", + "sha256": "29d699158082eab10ca18ebd39683ec65775c0f7e8721a6abf7aa7c2d8c0b402", + "size": 67461, + "subdir": "linux-64", + "timestamp": 1530959668926, + "version": "2.1.7" + }, + "sas_kernel-2.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "jupyter_client >=4.4.0", + "metakernel >=0.18.0", + "pygments", + "python >=3.6,<3.7.0a0", + "saspy >=1.2.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3690399bf1e12a0fd47bbab4c8b42b6a", + "name": "sas_kernel", + "sha256": "91866767aa91d348394b13d89c4ffcb6778e6a2a682d65cbe3a6510ecca9e947", + "size": 68941, + "subdir": "linux-64", + "timestamp": 1541048865990, + "version": "2.2.0" + }, + "sas_kernel-2.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "jupyter_client >=4.4.0", + "metakernel >=0.18.0", + "pygments", + "python >=3.7,<3.8.0a0", + "saspy >=1.2.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3157b7ad024c4de2edf59f9ed6a396c2", + "name": "sas_kernel", + "sha256": "491f46225429a73114106324e3201be6d563bc5f308a0cfd185fb676e67277d2", + "size": 69049, + "subdir": "linux-64", + "timestamp": 1541048833774, + "version": "2.2.0" + }, + "sas_kernel-2.3.1-py36_1000.tar.bz2": { + "build": "py36_1000", + "build_number": 1000, + "depends": [ + "ipython >=4", + "jupyter_client >=4.4.0", + "metakernel >=0.18.0", + "pygments", + "python >=3.6,<3.7.0a0", + "saspy >=1.2.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a6a0c401097439654cf75091b3162ac1", + "name": "sas_kernel", + "sha256": "4242630e22ba7b906baccf5d27ed45a00b6e78a5748faa351db2284a6a104951", + "size": 69551, + "subdir": "linux-64", + "timestamp": 1600553258702, + "version": "2.3.1" + }, + "sas_kernel-2.3.1-py37_1000.tar.bz2": { + "build": "py37_1000", + "build_number": 1000, + "depends": [ + "ipython >=4", + "jupyter_client >=4.4.0", + "metakernel >=0.18.0", + "pygments", + "python >=3.7,<3.8.0a0", + "saspy >=1.2.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1c88c881a3f7e74e6e859907e9c7d601", + "name": "sas_kernel", + "sha256": "11ed13b8032f20a61ff95078317221572386d4ba698310cec692d2b70b7c6836", + "size": 69613, + "subdir": "linux-64", + "timestamp": 1600553297560, + "version": "2.3.1" + }, + "sas_kernel-2.3.1-py38_1000.tar.bz2": { + "build": "py38_1000", + "build_number": 1000, + "depends": [ + "ipython >=4", + "jupyter_client >=4.4.0", + "metakernel >=0.18.0", + "pygments", + "python >=3.8,<3.9.0a0", + "saspy >=1.2.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "218cc5ba28446607d39a2f3e1cae4ee0", + "name": "sas_kernel", + "sha256": "8ca2ea56ea0bb0a2884d3971c4dece27382af1c20728ff2ccff3c8cddccd89df", + "size": 69643, + "subdir": "linux-64", + "timestamp": 1600553274285, + "version": "2.3.1" + }, + "sas_kernel-2.4.10-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.6,<3.7.0a0", + "saspy >=3.6" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "af0294e9e1c80faaed309fc13d9775d9", + "name": "sas_kernel", + "sha256": "09bbabb5a859810e110e5184aca1c1eb3a86c0395cb964c0e96500a79e877360", + "size": 70413, + "subdir": "linux-64", + "timestamp": 1623881406578, + "version": "2.4.10" + }, + "sas_kernel-2.4.10-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.7,<3.8.0a0", + "saspy >=3.6" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "46137a8a6c9858fd8d9be561ead2d735", + "name": "sas_kernel", + "sha256": "b61d9a70a41a787552016e251f4f271a9497b1658f7f5381b4d523e32b1ae4af", + "size": 70489, + "subdir": "linux-64", + "timestamp": 1623881411508, + "version": "2.4.10" + }, + "sas_kernel-2.4.10-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.8,<3.9.0a0", + "saspy >=3.6" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2e93de50de5c26d03d963f94fe052a18", + "name": "sas_kernel", + "sha256": "ab7acd9722d9429013bc21f5be8dc33fe91c8d37de02b87f1c65fba42701e970", + "size": 70540, + "subdir": "linux-64", + "timestamp": 1623881380953, + "version": "2.4.10" + }, + "sas_kernel-2.4.10-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.9,<3.10.0a0", + "saspy >=3.6" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "61cea3127bf9c3af3b53dfe80e7d6f47", + "name": "sas_kernel", + "sha256": "024bf7b1a01a4947fe8f27eebf28db5e6fa16507e60164c00affb9fdc54cf9f3", + "size": 70591, + "subdir": "linux-64", + "timestamp": 1623881375824, + "version": "2.4.10" + }, + "sas_kernel-2.4.11-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.6,<3.7.0a0", + "saspy >=3.6" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "856fe2fe2218dfc591e4fa4a9e199231", + "name": "sas_kernel", + "sha256": "f0a43bc2e15aec2fa0bc20da3878c98228356c90be394e23dccb6dfaf7e8e3d5", + "size": 70534, + "subdir": "linux-64", + "timestamp": 1626326698966, + "version": "2.4.11" + }, + "sas_kernel-2.4.11-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.7,<3.8.0a0", + "saspy >=3.6" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4fa3669933bb2a3051ae054b755f8be2", + "name": "sas_kernel", + "sha256": "7cfe16c5897df656fe2cba939a3a6fb7a592bbaa23b781b121df08028f960cb5", + "size": 70439, + "subdir": "linux-64", + "timestamp": 1626327481956, + "version": "2.4.11" + }, + "sas_kernel-2.4.11-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.8,<3.9.0a0", + "saspy >=3.6" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2de0f216cf4496de410acaad47fbeb32", + "name": "sas_kernel", + "sha256": "6084b02b05f0bd63806ddc3f93292c01dd472786437bafcf40e458900e83922c", + "size": 70671, + "subdir": "linux-64", + "timestamp": 1626320368475, + "version": "2.4.11" + }, + "sas_kernel-2.4.11-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.9,<3.10.0a0", + "saspy >=3.6" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c9eadd9ad542d63ca201fc5709550a43", + "name": "sas_kernel", + "sha256": "75f87acf7053b1553e01051063dbbd33706ed93bc69b7d8679d31cb57823c1c1", + "size": 70639, + "subdir": "linux-64", + "timestamp": 1626327490597, + "version": "2.4.11" + }, + "sas_kernel-2.4.9-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9e6fdd8a6a4bb36e6ce3feeeb0ca2f19", + "name": "sas_kernel", + "sha256": "0a22d457a1822856dd01b075b3ff9768f8c57cae17d43f8170d46034cfd7027e", + "size": 66470, + "subdir": "linux-64", + "timestamp": 1620734908029, + "version": "2.4.9" + }, + "sas_kernel-2.4.9-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "523c4f2a8e7e6948d1bf5af882e1a6ee", + "name": "sas_kernel", + "sha256": "5f548fe671996446c8126598c12df65323b5794a39db29f785399bad4a451ad4", + "size": 66609, + "subdir": "linux-64", + "timestamp": 1620734903100, + "version": "2.4.9" + }, + "sas_kernel-2.4.9-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b45dcd11fdf4acdcb63c57f5c49cca56", + "name": "sas_kernel", + "sha256": "71ae0fca9d2563e8fba5fa2670c02516b4cfeb4111b0f95a8710efd55d6571c1", + "size": 66661, + "subdir": "linux-64", + "timestamp": 1620734716255, + "version": "2.4.9" + }, + "sas_kernel-2.4.9-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "afebfcea687b92aaf570a9d3e6696bcb", + "name": "sas_kernel", + "sha256": "7416455b6802339b640d123b1a0e89208b8db8d905b9ecf6a494ab22fc0815ae", + "size": 66623, + "subdir": "linux-64", + "timestamp": 1620734910969, + "version": "2.4.9" + }, + "sasl-0.2.1-py27h4575015_0.tar.bz2": { + "build": "py27h4575015_0", + "build_number": 0, + "depends": [ + "cyrus-sasl 2.1.26.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "12658702eb90acedf2ebf3b26be62324", + "name": "sasl", + "sha256": "1a5a5d78928af8508b1e339b3a2d60c2d138f5b4d222a3749bd682b270f91799", + "size": 57855, + "subdir": "linux-64", + "timestamp": 1512156847634, + "version": "0.2.1" + }, + "sasl-0.2.1-py27h779454e_1.tar.bz2": { + "build": "py27h779454e_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "505c8ef1dc1d663d171fd99b4fb40e35", + "name": "sasl", + "sha256": "6c065cf5c51b4332bc52e7685b4dd977f76833050b3042f4471fc0b4b42ccde8", + "size": 58383, + "subdir": "linux-64", + "timestamp": 1537825554438, + "version": "0.2.1" + }, + "sasl-0.2.1-py27hf484d3e_1.tar.bz2": { + "build": "py27hf484d3e_1", + "build_number": 1, + "depends": [ + "cyrus-sasl 2.1.26.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "95a7e64d13c60b61ee5bb8c14656a5ca", + "name": "sasl", + "sha256": "f98ccb7710cac41b2e7e1a331f9eb0ede7b2a2f621102e6dc01ad2161332ef0a", + "size": 57467, + "subdir": "linux-64", + "timestamp": 1518809283823, + "version": "0.2.1" + }, + "sasl-0.2.1-py310h42fbc30_2.tar.bz2": { + "build": "py310h42fbc30_2", + "build_number": 2, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eeadcada4a52d3ce541022548a55b661", + "name": "sasl", + "sha256": "f9aabc6cc1e89e076a26e513766dc143811c8bc5ef323af4257c59bedc70b82e", + "size": 245730, + "subdir": "linux-64", + "timestamp": 1656584551767, + "version": "0.2.1" + }, + "sasl-0.2.1-py310h48830cd_1.tar.bz2": { + "build": "py310h48830cd_1", + "build_number": 1, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c83a3f3944fa1a6b221442c5b1d3c42f", + "name": "sasl", + "sha256": "e8d3ceedeca5551260f8b12e5aaf6533b40fb9d074faa905b7fe6ee837f71740", + "size": 186875, + "subdir": "linux-64", + "timestamp": 1640794496551, + "version": "0.2.1" + }, + "sasl-0.2.1-py35h779454e_1.tar.bz2": { + "build": "py35h779454e_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1979b9eba955a49dd5c0f97731106e8c", + "name": "sasl", + "sha256": "17965ba22050d4c3c355d97ba6c367e25c31b08a2a55cc474c32bf86a1b4a285", + "size": 59037, + "subdir": "linux-64", + "timestamp": 1537825306152, + "version": "0.2.1" + }, + "sasl-0.2.1-py35h7983f5e_0.tar.bz2": { + "build": "py35h7983f5e_0", + "build_number": 0, + "depends": [ + "cyrus-sasl 2.1.26.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "65516167aeac86ed1e75145339d1777b", + "name": "sasl", + "sha256": "4c714e0b070437987ad8117468c097d16a76667a53f8f21d1a610294a2057315", + "size": 58509, + "subdir": "linux-64", + "timestamp": 1512156896809, + "version": "0.2.1" + }, + "sasl-0.2.1-py35hf484d3e_1.tar.bz2": { + "build": "py35hf484d3e_1", + "build_number": 1, + "depends": [ + "cyrus-sasl 2.1.26.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "af7a440aeb9c8e1297b78a6596d62487", + "name": "sasl", + "sha256": "6208135415d51f2a96eff77c70f18e38a152ed05aa0ab068d77f111bcdf0b06c", + "size": 58215, + "subdir": "linux-64", + "timestamp": 1518809294048, + "version": "0.2.1" + }, + "sasl-0.2.1-py36h48830cd_1.tar.bz2": { + "build": "py36h48830cd_1", + "build_number": 1, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d3e067168c39ec3596047d9a83062a85", + "name": "sasl", + "sha256": "5636057e458d39972940c174bfc3a8d607a0c1978336e40a0ee4382d3f401821", + "size": 61347, + "subdir": "linux-64", + "timestamp": 1632736772553, + "version": "0.2.1" + }, + "sasl-0.2.1-py36h696bdec_0.tar.bz2": { + "build": "py36h696bdec_0", + "build_number": 0, + "depends": [ + "cyrus-sasl 2.1.26.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "86a76aabcee7de777ebed50682d54936", + "name": "sasl", + "sha256": "5512f1c54d10202b80e3c8373198457d40a0e5da0ddaf03a54af74f9559f4149", + "size": 58546, + "subdir": "linux-64", + "timestamp": 1512156839155, + "version": "0.2.1" + }, + "sasl-0.2.1-py36h779454e_1.tar.bz2": { + "build": "py36h779454e_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ed5f3c4728bf724e81c073d925b89ccd", + "name": "sasl", + "sha256": "8f827149ec6a4d9d4e77ed03d53419a906ab2299057ea2b32d264a8f56c7aac6", + "size": 59041, + "subdir": "linux-64", + "timestamp": 1537825230836, + "version": "0.2.1" + }, + "sasl-0.2.1-py36hf484d3e_1.tar.bz2": { + "build": "py36hf484d3e_1", + "build_number": 1, + "depends": [ + "cyrus-sasl 2.1.26.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d0cac01cde21f77cfc2fa625985fb008", + "name": "sasl", + "sha256": "a5662e98439b9e55822582869e110c83e7f9fad95f348ae204481e124fffc0ef", + "size": 58168, + "subdir": "linux-64", + "timestamp": 1518809266495, + "version": "0.2.1" + }, + "sasl-0.2.1-py37h42fbc30_2.tar.bz2": { + "build": "py37h42fbc30_2", + "build_number": 2, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bbcf274d238b4d85886d6d2831b082ff", + "name": "sasl", + "sha256": "573a75a1b66f69f487a7d035ddf436576b500e677d35ec5c746fb20264226a46", + "size": 60446, + "subdir": "linux-64", + "timestamp": 1656584636954, + "version": "0.2.1" + }, + "sasl-0.2.1-py37h48830cd_1.tar.bz2": { + "build": "py37h48830cd_1", + "build_number": 1, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7e02ef020e1ace63c4aa1b5ea63d5c8e", + "name": "sasl", + "sha256": "80331d922db7a62bee098c5d4f4a939d57edf39641e50a2d04eb262e94ffe5c6", + "size": 61304, + "subdir": "linux-64", + "timestamp": 1632736749512, + "version": "0.2.1" + }, + "sasl-0.2.1-py37h779454e_1.tar.bz2": { + "build": "py37h779454e_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5bce447b00adbad2adf8e411e794780b", + "name": "sasl", + "sha256": "c6e4cd6ff47c9f2fdf2133547b45c702f6bbdfabb9650e9e6baed732f2802404", + "size": 59132, + "subdir": "linux-64", + "timestamp": 1537825122257, + "version": "0.2.1" + }, + "sasl-0.2.1-py37hf484d3e_1.tar.bz2": { + "build": "py37hf484d3e_1", + "build_number": 1, + "depends": [ + "cyrus-sasl 2.1.26.*", + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2bf206116dc309369c9a6175d13fcc5a", + "name": "sasl", + "sha256": "a0f42a9a1e545c0b65a2224381781b9858449de1291356e981f9eed3f9d58b77", + "size": 58137, + "subdir": "linux-64", + "timestamp": 1530916955507, + "version": "0.2.1" + }, + "sasl-0.2.1-py38h42fbc30_2.tar.bz2": { + "build": "py38h42fbc30_2", + "build_number": 2, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "80222e0aed2c94c9fb30ff53cc46b651", + "name": "sasl", + "sha256": "fef1c5960a0a3c6051670543d95badecbac4c284702ea6ffe7e3f2ac77d3ecde", + "size": 61012, + "subdir": "linux-64", + "timestamp": 1656584608458, + "version": "0.2.1" + }, + "sasl-0.2.1-py38h48830cd_1.tar.bz2": { + "build": "py38h48830cd_1", + "build_number": 1, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0c1e357f450d8e9aaeaf2226e67213bf", + "name": "sasl", + "sha256": "910cbb443c0d28f2437f7ee8de68de6c3b3d91a62c83ff9d75afcbae5869dcd2", + "size": 62137, + "subdir": "linux-64", + "timestamp": 1632736752021, + "version": "0.2.1" + }, + "sasl-0.2.1-py38h779454e_1.tar.bz2": { + "build": "py38h779454e_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "19f30609617d8acd402c551dd2de34fe", + "name": "sasl", + "sha256": "20fd55159b8db05e93c89807dd805ff6c1d1b8555d9f9eb16ec32ffc6c28adab", + "size": 60748, + "subdir": "linux-64", + "timestamp": 1573554747551, + "version": "0.2.1" + }, + "sasl-0.2.1-py39h42fbc30_2.tar.bz2": { + "build": "py39h42fbc30_2", + "build_number": 2, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "75e4fa58b65291b057e85183903ce28a", + "name": "sasl", + "sha256": "fca0cc7500b8299d3f36ad76994589c21664038a3a53d23d4bbce24d135352f5", + "size": 60183, + "subdir": "linux-64", + "timestamp": 1656584580177, + "version": "0.2.1" + }, + "sasl-0.2.1-py39h48830cd_1.tar.bz2": { + "build": "py39h48830cd_1", + "build_number": 1, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e83c2c34373de3f5482affc03b8f6f7a", + "name": "sasl", + "sha256": "7069471dea2870137627289e705e5a94f07358a657d2dd6c7b25f2bbd0ef60d6", + "size": 61098, + "subdir": "linux-64", + "timestamp": 1632735881197, + "version": "0.2.1" + }, + "sasl-0.3.1-py310h42fbc30_0.tar.bz2": { + "build": "py310h42fbc30_0", + "build_number": 0, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ea81d98714057bd0dd105dfc9668c31f", + "name": "sasl", + "sha256": "8e53252fdab7031682eb2ecc3f2a25f21359e5076350c1182764d2c2836b5f58", + "size": 94315, + "subdir": "linux-64", + "timestamp": 1671027524305, + "version": "0.3.1" + }, + "sasl-0.3.1-py310h42fbc30_1.tar.bz2": { + "build": "py310h42fbc30_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b25e6d82f6b6957048225c05b53436cc", + "name": "sasl", + "sha256": "d8db24a62654f5644dc7b2d82c73d2615cfd85d59a0a7551479f7358ebd42ca4", + "size": 94815, + "subdir": "linux-64", + "timestamp": 1679031603778, + "version": "0.3.1" + }, + "sasl-0.3.1-py311h42fbc30_0.tar.bz2": { + "build": "py311h42fbc30_0", + "build_number": 0, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "852d676c487615bce402fc7d2eb65d9f", + "name": "sasl", + "sha256": "1e6e1b581834c3a0c14c612bd19c1dfa0b24435c3c64f684b9d16ca3f509bfc4", + "size": 94033, + "subdir": "linux-64", + "timestamp": 1676845744659, + "version": "0.3.1" + }, + "sasl-0.3.1-py311h42fbc30_1.tar.bz2": { + "build": "py311h42fbc30_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a9b9875dc7b392cf70c20222453cde02", + "name": "sasl", + "sha256": "330c362a095f807a8c54b5748789e4a6b795074cf499e32ab819a0aedf324a0b", + "size": 94027, + "subdir": "linux-64", + "timestamp": 1679031570277, + "version": "0.3.1" + }, + "sasl-0.3.1-py37h42fbc30_0.tar.bz2": { + "build": "py37h42fbc30_0", + "build_number": 0, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ee7cf2e50b761e43ed72dcf3f4e6015a", + "name": "sasl", + "sha256": "16b0be8aaabbef0ab1972f0d187bdfb39898ec833c5281d4346481acbe11ff5a", + "size": 94789, + "subdir": "linux-64", + "timestamp": 1671027490603, + "version": "0.3.1" + }, + "sasl-0.3.1-py38h42fbc30_0.tar.bz2": { + "build": "py38h42fbc30_0", + "build_number": 0, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3ff66ca6f4db6b879b9a3da148d2c31a", + "name": "sasl", + "sha256": "744a6c60e77feb70d614cf4d760243ab6985882656beb09be76c19a47f45ea77", + "size": 95263, + "subdir": "linux-64", + "timestamp": 1671027456034, + "version": "0.3.1" + }, + "sasl-0.3.1-py38h42fbc30_1.tar.bz2": { + "build": "py38h42fbc30_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "993f0f32c6980349676f13e416411d7f", + "name": "sasl", + "sha256": "5642dcaff09dd51b619ceea3fc6a0360c2e4ec8563448355f2010ffccf43a4a8", + "size": 95697, + "subdir": "linux-64", + "timestamp": 1679031637191, + "version": "0.3.1" + }, + "sasl-0.3.1-py39h42fbc30_0.tar.bz2": { + "build": "py39h42fbc30_0", + "build_number": 0, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c1b360b0ac6289189f5f79aa69a8bdd8", + "name": "sasl", + "sha256": "b2c12b474f9c9e3f6ad94075445f9217d39c56eb1e82cd24dd92f9f0a4189727", + "size": 95043, + "subdir": "linux-64", + "timestamp": 1671027424401, + "version": "0.3.1" + }, + "sasl-0.3.1-py39h42fbc30_1.tar.bz2": { + "build": "py39h42fbc30_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0defec3005a5f4ec462064317036e2df", + "name": "sasl", + "sha256": "105ede8ebaf770ebf952da858da588aeb0724d600c36dfa992eea393fa0ad89a", + "size": 95515, + "subdir": "linux-64", + "timestamp": 1679031536013, + "version": "0.3.1" + }, + "saspy-2.1.7-py35hcba938c_0.tar.bz2": { + "build": "py35hcba938c_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pygments", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "826cd842c1af5777d9aa3d23afa45ace", + "name": "saspy", + "sha256": "0ef559ed94a743d03c0007a13c271a09e1cd1217f40c8cc7622f101cc3949ffc", + "size": 121660, + "subdir": "linux-64", + "timestamp": 1506850506747, + "version": "2.1.7" + }, + "saspy-2.1.7-py36h8cad3b6_0.tar.bz2": { + "build": "py36h8cad3b6_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2093a328af6243f8c7f6d1eb3f6eb14a", + "name": "saspy", + "sha256": "a8793a19d5ec89a54de5d096ccdd53faf07490cf8a745580618b3174210f5133", + "size": 121912, + "subdir": "linux-64", + "timestamp": 1506850515797, + "version": "2.1.7" + }, + "saspy-2.1.8-py35he3b0357_0.tar.bz2": { + "build": "py35he3b0357_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pygments", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f8335d07311a6fc8e6c5e0f7ccd2130f", + "name": "saspy", + "sha256": "3a984789d48a3409256efc415742a8d20b5232000f2f714f68c773bb269085fb", + "size": 128740, + "subdir": "linux-64", + "timestamp": 1511320079927, + "version": "2.1.8" + }, + "saspy-2.1.8-py36h511ab8a_0.tar.bz2": { + "build": "py36h511ab8a_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b0ccb65e1c7718305e6fb0ee73f0c738", + "name": "saspy", + "sha256": "d8b738170353c9e475ce1ad23e38255ef8540cba6d564c971f44d226dad9f0e2", + "size": 129028, + "subdir": "linux-64", + "timestamp": 1511320082900, + "version": "2.1.8" + }, + "saspy-2.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pygments", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8f1f6203b517d6661d640686a5a0d130", + "name": "saspy", + "sha256": "6c68c0f8b6543cf1e1b838e4ea33aad9f6e2afb4d5be30f83c6821c248665d6d", + "size": 128598, + "subdir": "linux-64", + "timestamp": 1519479973650, + "version": "2.2.1" + }, + "saspy-2.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6bdffe9ec72dcd96bc13da21210fa5bf", + "name": "saspy", + "sha256": "8f01b7bdda9624dba491e645633cdd62ffa9f05073cfded6761a000f1ba9b8ca", + "size": 128857, + "subdir": "linux-64", + "timestamp": 1519479959006, + "version": "2.2.1" + }, + "saspy-2.2.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pygments", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4d626dcc88982916e3401b06ebed9a49", + "name": "saspy", + "sha256": "e1d715776d69113fa4d9fcd613fc194ce6da5704e17fd0d80bd3a73cde0a3edd", + "size": 140161, + "subdir": "linux-64", + "timestamp": 1522716625921, + "version": "2.2.4" + }, + "saspy-2.2.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "099183bc2693811b0ffc18a7fe679def", + "name": "saspy", + "sha256": "475004d07cc0189c903c1a7febb5cd6fffe29bac459b5229286d8fae8b3e7819", + "size": 140422, + "subdir": "linux-64", + "timestamp": 1522723273209, + "version": "2.2.4" + }, + "saspy-2.2.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c1509012a9bbca7e15e059f26fe8525a", + "name": "saspy", + "sha256": "89b18065bfb2a767de0649daa242f88bebc8f0c2ca5ad2c8f55b6fce54091ac0", + "size": 149802, + "subdir": "linux-64", + "timestamp": 1529957226273, + "version": "2.2.5" + }, + "saspy-2.2.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7bf9a63c6a3f68fb07b831f97354e35a", + "name": "saspy", + "sha256": "62a23718ec93e1bc1003f9848a9ff7ed33f747e2764973e21dc37eb6e3ef49b9", + "size": 150143, + "subdir": "linux-64", + "timestamp": 1529957195603, + "version": "2.2.5" + }, + "saspy-2.2.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c1b0e5c1b7c8fdaa05939b51b7938481", + "name": "saspy", + "sha256": "7855f3985c652fa89640f47e1325935b5df04286ecc65b5e34d10b84606c99c8", + "size": 149301, + "subdir": "linux-64", + "timestamp": 1530959588084, + "version": "2.2.5" + }, + "saspy-2.2.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a60344adfc3a303b3591de7360328eef", + "name": "saspy", + "sha256": "71caffc0b72a7a7bb0a44cafb8b89ef5116ac05fb2937a0d60e47a925c565401", + "size": 149520, + "subdir": "linux-64", + "timestamp": 1535500719501, + "version": "2.2.7" + }, + "saspy-2.2.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bd9410bae6beead01b3c1479c6684acf", + "name": "saspy", + "sha256": "1ac7a54b33adff8b646262f08b7d2ef60b955e646fc1bfd94001b44cba996eb9", + "size": 149730, + "subdir": "linux-64", + "timestamp": 1535500687138, + "version": "2.2.7" + }, + "saspy-2.2.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "df38ad4ca4ce440ed2c7067b25d4235d", + "name": "saspy", + "sha256": "8220354304bb09f026ef23324d22262365c0d38573b78c5920aabe370f3089e6", + "size": 149125, + "subdir": "linux-64", + "timestamp": 1535500721940, + "version": "2.2.7" + }, + "saspy-2.2.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f9c3f10513e9e5ce3c53aa87ebb9a5c8", + "name": "saspy", + "sha256": "3054be8ec43b561c6cf34f1eec853a2faec71bad1a70ec58e8e1dbe95170c1e0", + "size": 150753, + "subdir": "linux-64", + "timestamp": 1538172506169, + "version": "2.2.8" + }, + "saspy-2.2.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2bb6a2fb74edb84b9285a18f78b82672", + "name": "saspy", + "sha256": "24bd3440b21e5b6ba2c141beca7c2b214cc0d83ac93ca6b3d66dc6f4db567992", + "size": 150030, + "subdir": "linux-64", + "timestamp": 1538172499467, + "version": "2.2.8" + }, + "saspy-2.2.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c4f0f4dc7010d2670a44eb4489fc9587", + "name": "saspy", + "sha256": "5119401b6807ed7748a85bdf2c90b68add2f18100fb491641b05167dc7636d28", + "size": 155883, + "subdir": "linux-64", + "timestamp": 1539649811515, + "version": "2.2.9" + }, + "saspy-2.2.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c5fedc9ca05f3601939f8f5b88a65962", + "name": "saspy", + "sha256": "45a8fbdc2680c2d850d6eaadb19473c47f3229ab008fde3e21bf3d291db9e385", + "size": 155133, + "subdir": "linux-64", + "timestamp": 1539649811995, + "version": "2.2.9" + }, + "saspy-2.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "005be3009aaa714ba9ecac0a3369ebe9", + "name": "saspy", + "sha256": "16ef6e49839444de458d6202c3f28c973392a134c66aeb1c29dd2257761fe4f2", + "size": 160308, + "subdir": "linux-64", + "timestamp": 1543615641752, + "version": "2.3.0" + }, + "saspy-2.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "519f4f06959632510bf03bdfe024a2b1", + "name": "saspy", + "sha256": "a72d7146f1cba93ea43d63520c48460ac30c389791150eed4ab59e5a52cfeef7", + "size": 159598, + "subdir": "linux-64", + "timestamp": 1543615609416, + "version": "2.3.0" + }, + "saspy-2.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3f24fed1a5b25722c40250c5affe0062", + "name": "saspy", + "sha256": "650b8c1f28efe5c498471ae8319f11e57acb4bbc0db6323c73227a2fbd8ffd2b", + "size": 166513, + "subdir": "linux-64", + "timestamp": 1545118459304, + "version": "2.4.1" + }, + "saspy-2.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4a837e8c7f5ef2ba11208c6b77233494", + "name": "saspy", + "sha256": "0bd04b06ac623ea9fab3f6ce58eca3d8cbad2e44dd92f888ac3ca3653c69094e", + "size": 165796, + "subdir": "linux-64", + "timestamp": 1545118445154, + "version": "2.4.1" + }, + "saspy-2.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d19860d16c41977ef10f397f898839a5", + "name": "saspy", + "sha256": "c2c36c9d8a740f7865d220f2c7097ac754143fd1470183d3971a2bdda10a6cf1", + "size": 181082, + "subdir": "linux-64", + "timestamp": 1550358965440, + "version": "2.4.2" + }, + "saspy-2.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c7a0642c6697e1a64be1755eb95456af", + "name": "saspy", + "sha256": "e2f7d9082899d06be0c1c17ac35903882db6a40a22ca2972d02c11230b424990", + "size": 180202, + "subdir": "linux-64", + "timestamp": 1550358887146, + "version": "2.4.2" + }, + "scandir-1.10.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7303cdd47cf9e4990fd798f9db8351bf", + "name": "scandir", + "sha256": "7b9941b7991a1d9ed4de46deb588e8d77ecb1434a64816d18d3a6388358ad066", + "size": 32710, + "subdir": "linux-64", + "timestamp": 1552335425295, + "version": "1.10.0" + }, + "scandir-1.5-py27h1c9e1f8_1.tar.bz2": { + "build": "py27h1c9e1f8_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4b976667dd52c1bc62815960187a0d49", + "name": "scandir", + "sha256": "2a617ea2a5a187a7b15c47247bdb8b10ac340e77c49dfafe4615faaf2ea14ae0", + "size": 26756, + "subdir": "linux-64", + "timestamp": 1505863926960, + "version": "1.5" + }, + "scandir-1.6-py27hf7388dc_0.tar.bz2": { + "build": "py27hf7388dc_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "684db0f18843b16dfd6ec7de58b43955", + "name": "scandir", + "sha256": "2d939edde6c7ae665cfd594fb09a4923119b381013114f54f37c50fb5819d266", + "size": 27689, + "subdir": "linux-64", + "timestamp": 1507669492470, + "version": "1.6" + }, + "scandir-1.7-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e8a46d2a9fb86b29387faa2f88476532", + "name": "scandir", + "sha256": "da5e08f40ba0cb46e360a5f3069cb6dc5f3c5d0c03f9f877b5be5ea7a8a5fb3c", + "size": 27611, + "subdir": "linux-64", + "timestamp": 1519147128248, + "version": "1.7" + }, + "scandir-1.8-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4c1d7fa2881ef79fc7dab6185966bc03", + "name": "scandir", + "sha256": "aa9aa12bd9185a8c959976da834e2d26bc4cc2260e2436e1bb87187ac5547895", + "size": 28058, + "subdir": "linux-64", + "timestamp": 1533673087667, + "version": "1.8" + }, + "scandir-1.9.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "97a5a83d6ed0808179d25e06cc340719", + "name": "scandir", + "sha256": "a3dad267496b137583554eacb6a5c358ccf96ae16069e87f1137f5ec305c5162", + "size": 28201, + "subdir": "linux-64", + "timestamp": 1534177940126, + "version": "1.9.0" + }, + "schema-0.7.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "contextlib2 >=0.5.5", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "57a96df52196882b77287a01ed3503af", + "name": "schema", + "sha256": "20a289b2ae3082bf5ff885e593a297151872ec742ea7386141d18e66e3f1ab8f", + "size": 37041, + "subdir": "linux-64", + "timestamp": 1663666459273, + "version": "0.7.5" + }, + "schema-0.7.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "contextlib2 >=0.5.5", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "177ff54cb8109987d9ece0eb13a1e53c", + "name": "schema", + "sha256": "57e0c63e48267ea7048d49ae2f6b54321358028b2e761cd7eb4eee3a4aed9acd", + "size": 44985, + "subdir": "linux-64", + "timestamp": 1679340658247, + "version": "0.7.5" + }, + "schema-0.7.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "contextlib2 >=0.5.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "46963176ad9358a2615554865e28347d", + "name": "schema", + "sha256": "9664a958b3a130b2a3642b58f1bfc5cdec13588afc782828f8873a9880cf453b", + "size": 36799, + "subdir": "linux-64", + "timestamp": 1663666420253, + "version": "0.7.5" + }, + "schema-0.7.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "contextlib2 >=0.5.5", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "539d029db3fd2741a4ce4a8ac4517caf", + "name": "schema", + "sha256": "c51f1f2b6d727595d5b6a74ac50e1c779e15ff6ef1321b27a4f1a4fa1d44aae6", + "size": 36926, + "subdir": "linux-64", + "timestamp": 1663666393983, + "version": "0.7.5" + }, + "schema-0.7.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "contextlib2 >=0.5.5", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "38c55e5ae48e79642064d28cdf9eabb6", + "name": "schema", + "sha256": "dd33a4352bbbabff4c55eb6b293bc1dbeec0451c9b046ef0605246a47acd9069", + "size": 36903, + "subdir": "linux-64", + "timestamp": 1663666485933, + "version": "0.7.5" + }, + "scikit-bio-0.5.2-py35h3010b51_0.tar.bz2": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.11.5", + "decorator >=3.4.2", + "ipython >=3.2.0", + "libgcc-ng >=7.2.0", + "lockfile >=0.10.2", + "matplotlib >=1.4.3", + "natsort >=4.0.3", + "nose >=1.3.7", + "numpy >=1.9.3,<2.0a0", + "pandas >=0.19.2", + "python >=3.5,<3.6.0a0", + "scikit-learn >=0.19.1", + "scipy >=0.15.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2de8663a3623b40d283e703e10120da5", + "name": "scikit-bio", + "sha256": "f4e7c23d3acc3b6c6b7c5f70c9b290f73675e9eff1cfaadeda27fea2ef52451c", + "size": 1239066, + "subdir": "linux-64", + "timestamp": 1524608963860, + "version": "0.5.2" + }, + "scikit-bio-0.5.2-py36h3010b51_0.tar.bz2": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.11.5", + "decorator >=3.4.2", + "ipython >=3.2.0", + "libgcc-ng >=7.2.0", + "lockfile >=0.10.2", + "matplotlib >=1.4.3", + "natsort >=4.0.3", + "nose >=1.3.7", + "numpy >=1.9.3,<2.0a0", + "pandas >=0.19.2", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.19.1", + "scipy >=0.15.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eb0518b47dfa103ad6bae3b3cdefcdf8", + "name": "scikit-bio", + "sha256": "68141c5afa6bce1272ed2617934b67a7dcbfb8bb59058b5dc522c62553fcfeae", + "size": 1234019, + "subdir": "linux-64", + "timestamp": 1524608964349, + "version": "0.5.2" + }, + "scikit-bio-0.5.4-py35hdd07704_0.tar.bz2": { + "build": "py35hdd07704_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.11.5", + "decorator >=3.4.2", + "hdmedians >=0.13", + "ipython >=3.2.0", + "libgcc-ng >=7.3.0", + "lockfile >=0.10.2", + "matplotlib >=1.4.3", + "natsort >=4.0.3", + "nose >=1.3.7", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19.2,<0.23.0", + "python >=3.5,<3.6.0a0", + "scikit-learn >=0.19.1", + "scipy >=0.15.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "68da0b6dfc1e85ebc743311d1404d67d", + "name": "scikit-bio", + "sha256": "39346c0b05d8493a9ed2b2564f2ff53d5ec0c0c0e4c8ffa24df28d6b62c9fef3", + "size": 1265304, + "subdir": "linux-64", + "timestamp": 1535811868574, + "version": "0.5.4" + }, + "scikit-bio-0.5.4-py36hdd07704_0.tar.bz2": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.11.5", + "decorator >=3.4.2", + "hdmedians >=0.13", + "ipython >=3.2.0", + "libgcc-ng >=7.3.0", + "lockfile >=0.10.2", + "matplotlib >=1.4.3", + "natsort >=4.0.3", + "nose >=1.3.7", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19.2,<0.23.0", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.19.1", + "scipy >=0.15.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4848fe4a67662e32612272f02ff9edc2", + "name": "scikit-bio", + "sha256": "21f626ac992665844872be994253bd93caaa0e89e657fe22f3a71c078fdaa6d3", + "size": 1266534, + "subdir": "linux-64", + "timestamp": 1535812011165, + "version": "0.5.4" + }, + "scikit-bio-0.5.6-py36h6323ea4_0.tar.bz2": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.11.5", + "decorator >=3.4.2", + "hdmedians >=0.13", + "ipython >=3.2.0", + "libgcc-ng >=7.3.0", + "lockfile >=0.10.2", + "matplotlib-base >=1.4.3", + "natsort >=4.0.3", + "numpy >=1.16.6,<2.0a0", + "pandas >=1.0.0", + "pytest", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.19.1", + "scipy >=1.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "68e72bc7a8b6b3a298ff61ac9c10b759", + "name": "scikit-bio", + "sha256": "9c29a53a48876041f70d000b15e6c6105a19fa4edf3d1c95bd0ac4c686a9c907", + "size": 1361971, + "subdir": "linux-64", + "timestamp": 1614415892343, + "version": "0.5.6" + }, + "scikit-bio-0.5.6-py37h6323ea4_0.tar.bz2": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.11.5", + "decorator >=3.4.2", + "hdmedians >=0.13", + "ipython >=3.2.0", + "libgcc-ng >=7.3.0", + "lockfile >=0.10.2", + "matplotlib-base >=1.4.3", + "natsort >=4.0.3", + "numpy >=1.16.6,<2.0a0", + "pandas >=1.0.0", + "pytest", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.19.1", + "scipy >=1.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "04c3c51fbd12ee78bbb1ba7cce3976cc", + "name": "scikit-bio", + "sha256": "45c202b10d6e624484df98f87cecbf7e391615beeadbee36dd540bf3332a21cf", + "size": 1355609, + "subdir": "linux-64", + "timestamp": 1614416003478, + "version": "0.5.6" + }, + "scikit-bio-0.5.6-py38h6323ea4_0.tar.bz2": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.11.5", + "decorator >=3.4.2", + "hdmedians >=0.13", + "ipython >=3.2.0", + "libgcc-ng >=7.3.0", + "lockfile >=0.10.2", + "matplotlib-base >=1.4.3", + "natsort >=4.0.3", + "numpy >=1.16.6,<2.0a0", + "pandas >=1.0.0", + "pytest", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.19.1", + "scipy >=1.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "84d9bf33653a4d7fdd186c488b924e87", + "name": "scikit-bio", + "sha256": "3d8afe9d32ae4e84a1cdda19212db9f7c66eb4abfb8ca2fc58d04de8ab1d0e9e", + "size": 1367212, + "subdir": "linux-64", + "timestamp": 1614414896878, + "version": "0.5.6" + }, + "scikit-bio-0.5.6-py39h6323ea4_0.tar.bz2": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.11.5", + "decorator >=3.4.2", + "hdmedians >=0.13", + "ipython >=3.2.0", + "libgcc-ng >=7.3.0", + "lockfile >=0.10.2", + "matplotlib-base >=1.4.3", + "natsort >=4.0.3", + "numpy >=1.16.6,<2.0a0", + "pandas >=1.0.0", + "pytest", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.19.1", + "scipy >=1.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ec5469d124b996026a07c6963bd77bb9", + "name": "scikit-bio", + "sha256": "682f07bc5157ed7fb1c8bfcfc6a208606e5576878fb99ed1e91b828c347e0474", + "size": 1367405, + "subdir": "linux-64", + "timestamp": 1614415977956, + "version": "0.5.6" + }, + "scikit-build-0.11.1-py310h295c915_2.tar.bz2": { + "build": "py310h295c915_2", + "build_number": 2, + "depends": [ + "cmake", + "distro", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ninja", + "packaging", + "python >=3.10,<3.11.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d170f768e10bff7a32b062cee844c539", + "name": "scikit-build", + "sha256": "f91260f7878e2f948146202beabd2c52c034461da1a7323e3e1a6adaff674039", + "size": 111155, + "subdir": "linux-64", + "timestamp": 1640810837954, + "version": "0.11.1" + }, + "scikit-build-0.11.1-py36h2531618_2.tar.bz2": { + "build": "py36h2531618_2", + "build_number": 2, + "depends": [ + "cmake", + "distro", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ninja", + "packaging", + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74f3ecfd0d2277dc3f0435171fa8d475", + "name": "scikit-build", + "sha256": "057d64b6b9288787bd502dc4414dd939d0c89dd2cb93300374a728602e7905ac", + "size": 133155, + "subdir": "linux-64", + "timestamp": 1610399352691, + "version": "0.11.1" + }, + "scikit-build-0.11.1-py37h2531618_2.tar.bz2": { + "build": "py37h2531618_2", + "build_number": 2, + "depends": [ + "cmake", + "distro", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ninja", + "packaging", + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aeec63557d8da564fb5ebacd1387814e", + "name": "scikit-build", + "sha256": "d95259474185b437ddc0b5e02833c8a1418d1dc2f8bf25e98349dd0c0e6a002b", + "size": 130490, + "subdir": "linux-64", + "timestamp": 1610399372313, + "version": "0.11.1" + }, + "scikit-build-0.11.1-py38h2531618_2.tar.bz2": { + "build": "py38h2531618_2", + "build_number": 2, + "depends": [ + "cmake", + "distro", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ninja", + "packaging", + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "def1dc33c7137fab0ff3f5cb38d1f812", + "name": "scikit-build", + "sha256": "cce4d6454621960596abdc8c1c59a5879e412c73dd633e6a331a292e192fbc79", + "size": 129444, + "subdir": "linux-64", + "timestamp": 1610399354330, + "version": "0.11.1" + }, + "scikit-build-0.11.1-py39h2531618_2.tar.bz2": { + "build": "py39h2531618_2", + "build_number": 2, + "depends": [ + "cmake", + "distro", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ninja", + "packaging", + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0001f4f9d2224f6989f0a5b2470dbbf2", + "name": "scikit-build", + "sha256": "9bda3aa684f9621539e48d54b0d842b4ebc9195ade824ee98c8d77c8f83da3a4", + "size": 116184, + "subdir": "linux-64", + "timestamp": 1610398926547, + "version": "0.11.1" + }, + "scikit-build-0.15.0-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "cmake", + "distro", + "make", + "packaging", + "python >=3.10,<3.11.0a0", + "setuptools >=42.0.0", + "wheel >=0.32.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a77c07a616242cc0e69beecebedb609d", + "name": "scikit-build", + "sha256": "225c159164e2db31fc48641429bb337cedcd3df5666fa963e66889addae64f71", + "size": 120365, + "subdir": "linux-64", + "timestamp": 1664437609321, + "version": "0.15.0" + }, + "scikit-build-0.15.0-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "cmake", + "distro", + "make", + "packaging", + "python >=3.11,<3.12.0a0", + "setuptools >=42.0.0", + "wheel >=0.32.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "75882c84d1a53aa627b09f646bc9d176", + "name": "scikit-build", + "sha256": "dd5a6860127557d6a86bb401b17e61a4abceca8c8a7ac36ddb6a0786d146e38e", + "size": 143837, + "subdir": "linux-64", + "timestamp": 1676842460227, + "version": "0.15.0" + }, + "scikit-build-0.15.0-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "cmake", + "distro", + "make", + "packaging", + "python >=3.7,<3.8.0a0", + "setuptools >=42.0.0", + "wheel >=0.32.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "368d9feeb1bbb1cdc2f4a708998e8c76", + "name": "scikit-build", + "sha256": "b9139c1d0dff191e1a8a94020d13bb2d24d18b1390db346e4101b22c62a92406", + "size": 119444, + "subdir": "linux-64", + "timestamp": 1664437757333, + "version": "0.15.0" + }, + "scikit-build-0.15.0-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "cmake", + "distro", + "make", + "packaging", + "python >=3.8,<3.9.0a0", + "setuptools >=42.0.0", + "wheel >=0.32.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd415bc006b99ca0f8b192baea164f6d", + "name": "scikit-build", + "sha256": "8b7122daf0ceddc94bd41e1255359f159cda6b5f25eb67579eee746dcedd5a1d", + "size": 119652, + "subdir": "linux-64", + "timestamp": 1664437687156, + "version": "0.15.0" + }, + "scikit-build-0.15.0-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "cmake", + "distro", + "make", + "packaging", + "python >=3.9,<3.10.0a0", + "setuptools >=42.0.0", + "wheel >=0.32.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3228fd63e59e08fd170222c6107a5221", + "name": "scikit-build", + "sha256": "ced07a8e6e01074785b067e02d38e2c3b3825d6bcfd0fad38b6502532e7ed822", + "size": 119842, + "subdir": "linux-64", + "timestamp": 1664437830346, + "version": "0.15.0" + }, + "scikit-image-0.13.0-py27h06cb35d_1.tar.bz2": { + "build": "py27h06cb35d_1", + "build_number": 1, + "depends": [ + "dask >=0.5", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "matplotlib >=1.3.1", + "networkx >=1.8", + "numpy >=1.9.3,<2.0a0", + "pillow >=2.1.0", + "python >=2.7,<2.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3" + ], + "license": "BSD 3-Clause", + "md5": "0d945161d65e1c9fb21aed2b62840b15", + "name": "scikit-image", + "sha256": "7b480ebdd3e1ad9c08aec1c50ddab164c19b77841294967e7728cf632a7dbf33", + "size": 24294768, + "subdir": "linux-64", + "timestamp": 1505753288797, + "version": "0.13.0" + }, + "scikit-image-0.13.0-py35h3573165_1.tar.bz2": { + "build": "py35h3573165_1", + "build_number": 1, + "depends": [ + "dask >=0.5", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "matplotlib >=1.3.1", + "networkx >=1.8", + "numpy >=1.9.3,<2.0a0", + "pillow >=2.1.0", + "python >=3.5,<3.6.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3" + ], + "license": "BSD 3-Clause", + "md5": "bb111ebd0f490aeee9ef815c9627f4b1", + "name": "scikit-image", + "sha256": "cf72ae1523481c9fdc540e484c8617c7314c8402064443fbe9953d9e9903163e", + "size": 24081553, + "subdir": "linux-64", + "timestamp": 1505753587092, + "version": "0.13.0" + }, + "scikit-image-0.13.0-py36had3c07a_1.tar.bz2": { + "build": "py36had3c07a_1", + "build_number": 1, + "depends": [ + "dask >=0.5", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "matplotlib >=1.3.1", + "networkx >=1.8", + "numpy >=1.9.3,<2.0a0", + "pillow >=2.1.0", + "python >=3.6,<3.7.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3" + ], + "license": "BSD 3-Clause", + "md5": "2ea86dabc30a420987aa3cb5941c8634", + "name": "scikit-image", + "sha256": "60cacd0b3280d9de4a29c64631967bece13ec800975e5b68123d0d459ec33c6b", + "size": 24105512, + "subdir": "linux-64", + "timestamp": 1505753876364, + "version": "0.13.0" + }, + "scikit-image-0.13.1-py27h14c3975_1.tar.bz2": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "dask >=0.5", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "matplotlib >=1.3.1", + "networkx >=1.8", + "numpy >=1.9.3,<2.0a0", + "pillow >=2.1.0", + "python >=2.7,<2.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0b82c5480244f5906fb3ef5b9b6c5288", + "name": "scikit-image", + "sha256": "a616011bd6f5a06f57f7e96e4435800331fefd1a4646ba50a60c6ba366f612d3", + "size": 24318062, + "subdir": "linux-64", + "timestamp": 1515176081384, + "version": "0.13.1" + }, + "scikit-image-0.13.1-py27h44232b9_0.tar.bz2": { + "build": "py27h44232b9_0", + "build_number": 0, + "depends": [ + "dask >=0.5", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "matplotlib >=1.3.1", + "networkx >=1.8,<2.0", + "numpy >=1.9.3,<2.0a0", + "pillow >=2.1.0", + "python >=2.7,<2.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9c1911e73d23f681e47fce9229ca0f3f", + "name": "scikit-image", + "sha256": "f7e4911864c3073d632cecf53fe6190043746db7bece2e851ea64be8418f967e", + "size": 24316014, + "subdir": "linux-64", + "timestamp": 1511318425015, + "version": "0.13.1" + }, + "scikit-image-0.13.1-py35h14c3975_1.tar.bz2": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "dask >=0.5", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "matplotlib >=1.3.1", + "networkx >=1.8", + "numpy >=1.13.3,<2.0a0", + "pillow >=2.1.0", + "python >=3.5,<3.6.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d7c4e2ea12ec15db4ef72325e5de7fe0", + "name": "scikit-image", + "sha256": "8a2db526064bcff3184c3894850012d5ef37720832a30c44f893fd60ad674b36", + "size": 24120121, + "subdir": "linux-64", + "timestamp": 1515176107505, + "version": "0.13.1" + }, + "scikit-image-0.13.1-py35h7a281a6_0.tar.bz2": { + "build": "py35h7a281a6_0", + "build_number": 0, + "depends": [ + "dask >=0.5", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "matplotlib >=1.3.1", + "networkx >=1.8,<2.0", + "numpy >=1.9.3,<2.0a0", + "pillow >=2.1.0", + "python >=3.5,<3.6.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "28cc75da14aa380071ed6917ea7334e6", + "name": "scikit-image", + "sha256": "3070809fd66d319cdd7223286f02ea9f2a211f9039adf38923732c249afa67bb", + "size": 24107091, + "subdir": "linux-64", + "timestamp": 1511318497980, + "version": "0.13.1" + }, + "scikit-image-0.13.1-py36h14c3975_1.tar.bz2": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "dask >=0.5", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "matplotlib >=1.3.1", + "networkx >=1.8", + "numpy >=1.9.3,<2.0a0", + "pillow >=2.1.0", + "python >=3.6,<3.7.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e8c172e9dd1352f7f76dac19c71594c0", + "name": "scikit-image", + "sha256": "c553173bf6961191e75947143d4ac69b3b70929218867a0672590f5702996ee8", + "size": 24128667, + "subdir": "linux-64", + "timestamp": 1515176428169, + "version": "0.13.1" + }, + "scikit-image-0.13.1-py36ha4a0841_0.tar.bz2": { + "build": "py36ha4a0841_0", + "build_number": 0, + "depends": [ + "dask >=0.5", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "matplotlib >=1.3.1", + "networkx >=1.8,<2.0", + "numpy >=1.9.3,<2.0a0", + "pillow >=2.1.0", + "python >=3.6,<3.7.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8bfe724f03a33a25b425329d4a38f06e", + "name": "scikit-image", + "sha256": "0189fb54c5e05cacff1ff57ae7658f8ac4e247443d67861cb2a2d5eaafd271ef", + "size": 24128175, + "subdir": "linux-64", + "timestamp": 1511318497467, + "version": "0.13.1" + }, + "scikit-image-0.14.0-py27hf484d3e_1.tar.bz2": { + "build": "py27hf484d3e_1", + "build_number": 1, + "depends": [ + "cloudpickle >=0.2.1", + "dask-core >=0.15", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=2.7,<2.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d1cefc4995fde0b857993d1c7991adb4", + "name": "scikit-image", + "sha256": "4cc3c5117561e28656d02bdc2d579348c9cab131a92706bf8288612b39697567", + "size": 25418983, + "subdir": "linux-64", + "timestamp": 1529963088659, + "version": "0.14.0" + }, + "scikit-image-0.14.0-py35hf484d3e_1.tar.bz2": { + "build": "py35hf484d3e_1", + "build_number": 1, + "depends": [ + "cloudpickle >=0.2.1", + "dask-core >=0.15", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.5,<3.6.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1e1b9043ef17caab3b487975ba442308", + "name": "scikit-image", + "sha256": "53747dad0a9e732bd340795bf2698fba4c73f7e03e0a513768e3efa5880eba36", + "size": 25286755, + "subdir": "linux-64", + "timestamp": 1529963061998, + "version": "0.14.0" + }, + "scikit-image-0.14.0-py36hf484d3e_1.tar.bz2": { + "build": "py36hf484d3e_1", + "build_number": 1, + "depends": [ + "cloudpickle >=0.2.1", + "dask-core >=0.15", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.6,<3.7.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dd6d33b861fbb5a4df53b4aa2b345fd2", + "name": "scikit-image", + "sha256": "c57fea4fe1e2a87c7e4a5b4455a6a6297dba391b3beed84c654637f9d5142ada", + "size": 25314886, + "subdir": "linux-64", + "timestamp": 1529963019144, + "version": "0.14.0" + }, + "scikit-image-0.14.0-py37hf484d3e_1.tar.bz2": { + "build": "py37hf484d3e_1", + "build_number": 1, + "depends": [ + "cloudpickle >=0.2.1", + "dask-core >=0.15", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dcf1865a1d6a45a5e5e2b2032452d226", + "name": "scikit-image", + "sha256": "7b8840c00c5e84cb1c02544d9d6efdc7a49f885fa74f88e0b8a7ad2a5cfcee1c", + "size": 25285394, + "subdir": "linux-64", + "timestamp": 1530891536248, + "version": "0.14.0" + }, + "scikit-image-0.14.1-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=2.7,<2.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "390815f067239349efbfdfc7eb938cce", + "name": "scikit-image", + "sha256": "67cff4d9369aeca1b890982fbeb719fa9fea9893cf64c18bedb1b9f1dc0f29b8", + "size": 25043039, + "subdir": "linux-64", + "timestamp": 1544595427967, + "version": "0.14.1" + }, + "scikit-image-0.14.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.6,<3.7.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9e157cf268dadbc75129a5f40d30947a", + "name": "scikit-image", + "sha256": "24f37cb5f6937bf838cb96948da325d1ae3cd0e6fc937de83ffcf28dfd4a637e", + "size": 24975526, + "subdir": "linux-64", + "timestamp": 1544592061964, + "version": "0.14.1" + }, + "scikit-image-0.14.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c3ddd889ffdf628cde19cd89191a1325", + "name": "scikit-image", + "sha256": "117e7f547f750f6a5840ec57adea92707554622af43db96860dbc407b76f52e4", + "size": 24950994, + "subdir": "linux-64", + "timestamp": 1544595266739, + "version": "0.14.1" + }, + "scikit-image-0.14.2-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=2.7,<2.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "781efd59e8ca5a10ed79430a6ba62d9d", + "name": "scikit-image", + "sha256": "8597b9aadf2930fc2419ba077a4d5ada0e1f05dba36a7bd2b707767abaede5a9", + "size": 25182723, + "subdir": "linux-64", + "timestamp": 1552488626464, + "version": "0.14.2" + }, + "scikit-image-0.14.2-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.6,<3.7.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7c7a1afb910fc456e1ec21cafb2642b3", + "name": "scikit-image", + "sha256": "f01abaa4e366cebed2a12108a9b3e700beaf206f85be9020a953d6f46d00bad9", + "size": 25066878, + "subdir": "linux-64", + "timestamp": 1552488598184, + "version": "0.14.2" + }, + "scikit-image-0.14.2-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b164feb1e25e1292801e8eb130c81f2c", + "name": "scikit-image", + "sha256": "3478623dd06502a388b40da1f8a845bc3918bb72ca84bad9cb00e1713475469b", + "size": 25056843, + "subdir": "linux-64", + "timestamp": 1552488652882, + "version": "0.14.2" + }, + "scikit-image-0.15.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.6,<3.7.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "81a27270e41bc49ce103a3deda830980", + "name": "scikit-image", + "sha256": "c61a6cca065b5eb939364f4bfc7d26ee8b0b4a8f193bf741bd3ddd07fa6bb55f", + "size": 29774577, + "subdir": "linux-64", + "timestamp": 1556030482335, + "version": "0.15.0" + }, + "scikit-image-0.15.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9ad2b8633eb195a8a70f3de4eacaefd8", + "name": "scikit-image", + "sha256": "dc8b7b3cc5cb6135e0b33224980bfabe4136df344abf29470d3f6f423cc90569", + "size": 29787774, + "subdir": "linux-64", + "timestamp": 1556030636786, + "version": "0.15.0" + }, + "scikit-image-0.15.0-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.8,<3.9.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b769b6147fdc5ab95f0cda8b9fe0222f", + "name": "scikit-image", + "sha256": "41a943ae5f57c66c6eaba7839bc7305d9e8fcf4e43e30db26ba5bb07ddd7d4c7", + "size": 29965681, + "subdir": "linux-64", + "timestamp": 1574170576225, + "version": "0.15.0" + }, + "scikit-image-0.16.2-py310h6a678d5_1.tar.bz2": { + "build": "py310h6a678d5_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.3.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib >=2.0.0", + "networkx >=2.2", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pillow >=4.3.0", + "python >=3.10,<3.11.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa604974c43cdb963095bf4bc0382984", + "name": "scikit-image", + "sha256": "40bc213ddee7d0e57036134c21d61048e673b3e93dfe769dfe93d7735e657d67", + "size": 25632148, + "subdir": "linux-64", + "timestamp": 1665663289990, + "version": "0.16.2" + }, + "scikit-image-0.16.2-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=2.0", + "numpy >=1.14.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.6,<3.7.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "dfa06d08ac80da8c2ad7c8765027a6db", + "name": "scikit-image", + "sha256": "6dff9a9ac3476ba3c62e3538a73eb070dd085402eedaa97c6e6e894fd7f6cb06", + "size": 26248485, + "subdir": "linux-64", + "timestamp": 1580330411985, + "version": "0.16.2" + }, + "scikit-image-0.16.2-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=2.0", + "numpy >=1.14.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "e6d65e1c861020ce20132e32d80f1075", + "name": "scikit-image", + "sha256": "efd6dd1a6ee2867538c19ca0e49a2819cc5e6fff5d3654e21c278c4ba7fd6c56", + "size": 26249475, + "subdir": "linux-64", + "timestamp": 1580330407879, + "version": "0.16.2" + }, + "scikit-image-0.16.2-py37h6a678d5_1.tar.bz2": { + "build": "py37h6a678d5_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.3.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib >=2.0.0", + "networkx >=2.2,<2.7", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=4.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e6e36bcbfd8ed898d06092f5f94a97d", + "name": "scikit-image", + "sha256": "a3c8f92974c782fa860921bab2cbd6bbd736c1d429543678e551e104450398c6", + "size": 25545398, + "subdir": "linux-64", + "timestamp": 1665662380116, + "version": "0.16.2" + }, + "scikit-image-0.16.2-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=2.0", + "numpy >=1.14.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.8,<3.9.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "a932bd49a5f6191794ac724a81ee8ed0", + "name": "scikit-image", + "sha256": "91c46fefc8b4a11fb381591ba45498fffa0f119788af52d02c7fe56f0ea9df61", + "size": 26439231, + "subdir": "linux-64", + "timestamp": 1580496064495, + "version": "0.16.2" + }, + "scikit-image-0.16.2-py38h6a678d5_1.tar.bz2": { + "build": "py38h6a678d5_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.3.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib >=2.0.0", + "networkx >=2.2", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=4.3.0", + "python >=3.8,<3.9.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "032e187ce1d75385f1befe44036fb299", + "name": "scikit-image", + "sha256": "f48d24d67766111329503d7114efed6767fc4b5aa7f565e4397a437ad0aab025", + "size": 25695415, + "subdir": "linux-64", + "timestamp": 1665662843051, + "version": "0.16.2" + }, + "scikit-image-0.16.2-py39h6a678d5_1.tar.bz2": { + "build": "py39h6a678d5_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.3.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib >=2.0.0", + "networkx >=2.2", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=4.3.0", + "python >=3.9,<3.10.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "75b2db46d52f7c4e5639c4a242e024f1", + "name": "scikit-image", + "sha256": "16621f2bbf85ca2046568b61b16f339eb23bac1e2fcc272669dbb1d0923d7b0b", + "size": 25686964, + "subdir": "linux-64", + "timestamp": 1665661902883, + "version": "0.16.2" + }, + "scikit-image-0.16.2-py39ha9443f7_0.tar.bz2": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.9,<3.10.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "md5": "94fe0db95fed2d726eca2ca5ee129847", + "name": "scikit-image", + "sha256": "0d029e97c9170079188252392ebdab23f0693eb2dd69f3e6371e79c72451987e", + "size": 25786212, + "subdir": "linux-64", + "timestamp": 1608148347464, + "version": "0.16.2" + }, + "scikit-image-0.17.2-py36hdf5156a_0.tar.bz2": { + "build": "py36hdf5156a_0", + "build_number": 0, + "constrains": [ + "pooch >=0.5.2" + ], + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=2.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.6,<3.7.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "md5": "22b74aee78a68c25a7d3e71d803a9090", + "name": "scikit-image", + "sha256": "d6afafc4b16c79ff9aa39c88d7ef5b3927c75b109f6b5eef0530d6714792d0d7", + "size": 11314056, + "subdir": "linux-64", + "timestamp": 1603274774341, + "version": "0.17.2" + }, + "scikit-image-0.17.2-py37hdf5156a_0.tar.bz2": { + "build": "py37hdf5156a_0", + "build_number": 0, + "constrains": [ + "pooch >=0.5.2" + ], + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=2.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "md5": "a09f14a76547d779a01d34a2c213a0fc", + "name": "scikit-image", + "sha256": "eba1310ed2a53a2d4263bb58441d668bb09e1c43b4d4cea0ebae6ab0947a3049", + "size": 11268435, + "subdir": "linux-64", + "timestamp": 1603274774292, + "version": "0.17.2" + }, + "scikit-image-0.17.2-py38hdf5156a_0.tar.bz2": { + "build": "py38hdf5156a_0", + "build_number": 0, + "constrains": [ + "pooch >=0.5.2" + ], + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=2.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.8,<3.9.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "md5": "2c0b55f3e97e3b40be60d67cf9c48a24", + "name": "scikit-image", + "sha256": "035041262d4ae210d56b4c4f6cb34a5182ed53912131bf8a66b02de1b01a91c8", + "size": 11475378, + "subdir": "linux-64", + "timestamp": 1603274757507, + "version": "0.17.2" + }, + "scikit-image-0.17.2-py39ha9443f7_0.tar.bz2": { + "build": "py39ha9443f7_0", + "build_number": 0, + "constrains": [ + "pooch >=0.5.2" + ], + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=2.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.9,<3.10.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "md5": "6ea72edcac26e360c12ee98da42abf7e", + "name": "scikit-image", + "sha256": "adbbd763623e4bb4337b24391e30d3242dffc6689aeb2ceb9843fc2616e6dfa9", + "size": 11466995, + "subdir": "linux-64", + "timestamp": 1608067335701, + "version": "0.17.2" + }, + "scikit-image-0.18.1-py37ha9443f7_0.tar.bz2": { + "build": "py37ha9443f7_0", + "build_number": 0, + "constrains": [ + "pooch >=1.3.0" + ], + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=2.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "md5": "e5ea58c73b59623cfbcd88af23ebfea1", + "name": "scikit-image", + "sha256": "b3796e2eb274e51ffa69bbbf15e8138fe50fbe52c5a260aadc97cd12130e188a", + "size": 11729893, + "subdir": "linux-64", + "timestamp": 1617914863263, + "version": "0.18.1" + }, + "scikit-image-0.18.1-py38ha9443f7_0.tar.bz2": { + "build": "py38ha9443f7_0", + "build_number": 0, + "constrains": [ + "pooch >=1.3.0" + ], + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=2.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.8,<3.9.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "md5": "e86d3438efa47eda0ca947631673895f", + "name": "scikit-image", + "sha256": "96a5427b0b5b5fc430b3fb7b3f1b961f263a5f85f8199567bb4a0f15d2319e8f", + "size": 11852989, + "subdir": "linux-64", + "timestamp": 1617915337155, + "version": "0.18.1" + }, + "scikit-image-0.18.1-py39ha9443f7_0.tar.bz2": { + "build": "py39ha9443f7_0", + "build_number": 0, + "constrains": [ + "pooch >=1.3.0" + ], + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=2.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.9,<3.10.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "md5": "f4e5726aafbdaebb2d04b31f2214d777", + "name": "scikit-image", + "sha256": "81bc6c0e7c40f33f133785382af7de3e2a580b1212c0b0a41b01a10a6b0d61d0", + "size": 11937914, + "subdir": "linux-64", + "timestamp": 1617915380109, + "version": "0.18.1" + }, + "scikit-image-0.18.3-py310h00e6091_0.tar.bz2": { + "build": "py310h00e6091_0", + "build_number": 0, + "constrains": [ + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=2.0.0,!=3.0.0", + "networkx >=2.0", + "numpy >=1.21.2,<2.0a0", + "pillow >=4.3.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.10,<3.11.0a0", + "pywavelets >=1.1.1", + "scipy >=1.0.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a8931861bc0d1f4c347d49184ccf00e4", + "name": "scikit-image", + "sha256": "1e1c7613d41f39f280ef5d1c5027730413a8a169b178edd8f0c3018d4a3227b7", + "size": 29435208, + "subdir": "linux-64", + "timestamp": 1640814004541, + "version": "0.18.3" + }, + "scikit-image-0.18.3-py37h51133e4_0.tar.bz2": { + "build": "py37h51133e4_0", + "build_number": 0, + "constrains": [ + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=2.0.0,!=3.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=1.1.1", + "scipy >=1.0.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "46a9b66e5673a574abcd7176d0d85505", + "name": "scikit-image", + "sha256": "369dd1b80e081aad3b872b97755b04319aff533d317c0ec49be0daa658a3d203", + "size": 11638043, + "subdir": "linux-64", + "timestamp": 1635997998156, + "version": "0.18.3" + }, + "scikit-image-0.18.3-py38h51133e4_0.tar.bz2": { + "build": "py38h51133e4_0", + "build_number": 0, + "constrains": [ + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=2.0.0,!=3.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.8,<3.9.0a0", + "pywavelets >=1.1.1", + "scipy >=1.0.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "074dd329ddeb8947f0d820719f26bea2", + "name": "scikit-image", + "sha256": "103ae6bedf984b219e4606af079f99b058ba63863c00d29e7e36c5f5684bbc2a", + "size": 11862356, + "subdir": "linux-64", + "timestamp": 1636009727119, + "version": "0.18.3" + }, + "scikit-image-0.18.3-py39h51133e4_0.tar.bz2": { + "build": "py39h51133e4_0", + "build_number": 0, + "constrains": [ + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=2.0.0,!=3.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.9,<3.10.0a0", + "pywavelets >=1.1.1", + "scipy >=1.0.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9b795ec28eb28e5e6473f890207c5f3e", + "name": "scikit-image", + "sha256": "209d5c6849f9fa9576bb1cb6d6a1454ddd6209d4e85e78e1fc8635b76743fb11", + "size": 11886275, + "subdir": "linux-64", + "timestamp": 1636009968070, + "version": "0.18.3" + }, + "scikit-image-0.19.2-py310h00e6091_0.tar.bz2": { + "build": "py310h00e6091_0", + "build_number": 0, + "constrains": [ + "matplotlib-base >=3.0.3", + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.4.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2.2", + "numpy >=1.21.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.1.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.10,<3.11.0a0", + "pywavelets >=1.1.1", + "scipy >=1.4.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b49795bc5185b5cd354515b2a339c01c", + "name": "scikit-image", + "sha256": "f71a8e2e9842ecb2ca9267aa5e725ff4825b01fa1dcb738f79550db20511ca50", + "size": 30248592, + "subdir": "linux-64", + "timestamp": 1648214809138, + "version": "0.19.2" + }, + "scikit-image-0.19.2-py37h51133e4_0.tar.bz2": { + "build": "py37h51133e4_0", + "build_number": 0, + "constrains": [ + "pooch >=1.3.0", + "matplotlib-base >=3.0.3" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.4.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2.2", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pillow >=6.1.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=1.1.1", + "scipy >=1.4.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4f7d268b29b6bf50af17c5e315e8ae3c", + "name": "scikit-image", + "sha256": "762d5fd1f7af7bedb7fffa9135279240f1e38b2e55d0d65034faa19a367d65e8", + "size": 12163168, + "subdir": "linux-64", + "timestamp": 1648196607535, + "version": "0.19.2" + }, + "scikit-image-0.19.2-py38h51133e4_0.tar.bz2": { + "build": "py38h51133e4_0", + "build_number": 0, + "constrains": [ + "matplotlib-base >=3.0.3", + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.4.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2.2", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pillow >=6.1.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.8,<3.9.0a0", + "pywavelets >=1.1.1", + "scipy >=1.4.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "371d7b090a9148e541abbff9459059e5", + "name": "scikit-image", + "sha256": "cf875dd8edea26152dcf742e3da60f9bb8062dd60bee2e0cdc9ba7d1f6d80371", + "size": 12342699, + "subdir": "linux-64", + "timestamp": 1648196840181, + "version": "0.19.2" + }, + "scikit-image-0.19.2-py39h51133e4_0.tar.bz2": { + "build": "py39h51133e4_0", + "build_number": 0, + "constrains": [ + "matplotlib-base >=3.0.3", + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.4.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2.2", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pillow >=6.1.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.9,<3.10.0a0", + "pywavelets >=1.1.1", + "scipy >=1.4.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1928abe71a4ee71a89575b10e2971ac", + "name": "scikit-image", + "sha256": "c0494b489222528ac9b636ec7c17166cf403830fd39fd8429ec6233161b7de55", + "size": 12400321, + "subdir": "linux-64", + "timestamp": 1648214708343, + "version": "0.19.2" + }, + "scikit-image-0.19.3-py310h6a678d5_1.tar.bz2": { + "build": "py310h6a678d5_1", + "build_number": 1, + "constrains": [ + "matplotlib-base >=3.0.3", + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.16.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "networkx >=2.2", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pillow >=6.1.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.10,<3.11.0a0", + "pywavelets >=1.1.1", + "scipy >=1.4.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "da5220fd775489d2681d5ae14749c47c", + "name": "scikit-image", + "sha256": "19b8e5ece07310c27ab00c448c992ab93796a656202de1eb9385e33d0b5d26e4", + "size": 12203846, + "subdir": "linux-64", + "timestamp": 1669242126844, + "version": "0.19.3" + }, + "scikit-image-0.19.3-py311h6a678d5_2.tar.bz2": { + "build": "py311h6a678d5_2", + "build_number": 2, + "constrains": [ + "matplotlib-base >=3.0.3", + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.16.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "networkx >=2.2", + "numpy >=1.23.5,<2.0a0", + "packaging >=20.0", + "pillow >=6.1.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.11,<3.12.0a0", + "pywavelets >=1.1.1", + "scipy >=1.4.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d345256b4bbf6f9b076bee0362928473", + "name": "scikit-image", + "sha256": "bcb04072b328bb9cc7c3b38507b139b70683fab5c9fba4c209bc7e8d3a1508b6", + "size": 12580954, + "subdir": "linux-64", + "timestamp": 1677696607005, + "version": "0.19.3" + }, + "scikit-image-0.19.3-py37h6a678d5_1.tar.bz2": { + "build": "py37h6a678d5_1", + "build_number": 1, + "constrains": [ + "matplotlib-base >=3.0.3", + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.16.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "networkx >=2.2,<2.7", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.1.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=1.1.1", + "scipy >=1.4.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1996d3b3b9b5fe6006b46d0b9ce38aa1", + "name": "scikit-image", + "sha256": "0dbd6f91d924a404d2e79bedeaf4e88ed8a4055b3e6229187099dd5ecfc65248", + "size": 12104889, + "subdir": "linux-64", + "timestamp": 1669242736443, + "version": "0.19.3" + }, + "scikit-image-0.19.3-py38h6a678d5_1.tar.bz2": { + "build": "py38h6a678d5_1", + "build_number": 1, + "constrains": [ + "matplotlib-base >=3.0.3", + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.16.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "networkx >=2.2", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.1.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.8,<3.9.0a0", + "pywavelets >=1.1.1", + "scipy >=1.4.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b784007ea6d144cabb87dae7b9e3f4c8", + "name": "scikit-image", + "sha256": "3a4e7150731157ce8f6cf89a784357ba0ce0c9bfc6242c6a34e5464eb892e1de", + "size": 12299369, + "subdir": "linux-64", + "timestamp": 1669243310658, + "version": "0.19.3" + }, + "scikit-image-0.19.3-py39h6a678d5_1.tar.bz2": { + "build": "py39h6a678d5_1", + "build_number": 1, + "constrains": [ + "matplotlib-base >=3.0.3", + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.16.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "networkx >=2.2", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.1.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.9,<3.10.0a0", + "pywavelets >=1.1.1", + "scipy >=1.4.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "45d3a79f50f967d198d085bd0f9a0137", + "name": "scikit-image", + "sha256": "2f47c942449fb5ae8a782953b3b2a7403d0d534aa1790b997f899dff2d934188", + "size": 12244824, + "subdir": "linux-64", + "timestamp": 1669243871552, + "version": "0.19.3" + }, + "scikit-learn-0.19.0-py27_nomklh0ffebdf_2.tar.bz2": { + "build": "py27_nomklh0ffebdf_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "65098d9bb2e1dd263d7b7ea6330a0529", + "name": "scikit-learn", + "sha256": "40cbf6841e2447c380fc174929aad84d9efa9aff36d09032dc7beada85550a24", + "size": 5575022, + "subdir": "linux-64", + "timestamp": 1509734370393, + "version": "0.19.0" + }, + "scikit-learn-0.19.0-py27hd893acb_2.tar.bz2": { + "build": "py27hd893acb_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "e6fd9c30de2c9cd1d6bffa9069986c3c", + "name": "scikit-learn", + "sha256": "49853fee2005fa8ac1dbfb615a429abcd5de7b79c49ca2c4f2fe815ff000bfca", + "size": 5574066, + "subdir": "linux-64", + "timestamp": 1505754160505, + "version": "0.19.0" + }, + "scikit-learn-0.19.0-py35_nomklh375dd1d_2.tar.bz2": { + "build": "py35_nomklh375dd1d_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "cee7657f84d8270d94119aab33f27d09", + "name": "scikit-learn", + "sha256": "a30fe1d53f6da1f77720dc648e91a377fc0c100417134cded23402e6a5723b77", + "size": 5473040, + "subdir": "linux-64", + "timestamp": 1509734440155, + "version": "0.19.0" + }, + "scikit-learn-0.19.0-py35h25e8076_2.tar.bz2": { + "build": "py35h25e8076_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "64a0877acd382ac061835ac7828241c7", + "name": "scikit-learn", + "sha256": "3f325901826c295e22ae3b504a996c8ff16097a709eb0e0839e1d0d32983ffe1", + "size": 5475065, + "subdir": "linux-64", + "timestamp": 1505754719651, + "version": "0.19.0" + }, + "scikit-learn-0.19.0-py36_nomklh41feb14_2.tar.bz2": { + "build": "py36_nomklh41feb14_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "c9caba5f8640e29583ffe18391e3a3b0", + "name": "scikit-learn", + "sha256": "9449144a99a5a9c4f16df878b16f4f9c275e82f3c817283fd73f37238cecb659", + "size": 5437637, + "subdir": "linux-64", + "timestamp": 1509734565763, + "version": "0.19.0" + }, + "scikit-learn-0.19.0-py36h97ac459_2.tar.bz2": { + "build": "py36h97ac459_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "d03140b85c3710914f49cbc6ffacc897", + "name": "scikit-learn", + "sha256": "2e27fc0a078379ee01e7ed578b7bc3bc3a6203135ccda7c67e27a6554f0cdede", + "size": 5440411, + "subdir": "linux-64", + "timestamp": 1505755249949, + "version": "0.19.0" + }, + "scikit-learn-0.19.1-py27_nomklh6479e79_0.tar.bz2": { + "build": "py27_nomklh6479e79_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "dddec741060b3b255733889bc6b1f85d", + "name": "scikit-learn", + "sha256": "c23202d599e3a35187a564d27b07b96d863e9bb2c13ec16a9ef8f79a0f660ae3", + "size": 5594660, + "subdir": "linux-64", + "timestamp": 1509990070121, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py27_nomklh6cfcb94_0.tar.bz2": { + "build": "py27_nomklh6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "c80c93409f24dfb5f04a3eb42df99be1", + "name": "scikit-learn", + "sha256": "7d998d1fbee1a50f18fbc2118f655afa480de0f96aa509ec8787a3cc599d19e9", + "size": 5596526, + "subdir": "linux-64", + "timestamp": 1530840278665, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py27h445a80a_0.tar.bz2": { + "build": "py27h445a80a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "f72c1ea343039ab91c035501eb6bbc8a", + "name": "scikit-learn", + "sha256": "aaf601e238758408ddfa929aea1499bc91d6c5c8408ee78e460b311508ad59fe", + "size": 5593247, + "subdir": "linux-64", + "timestamp": 1508764313894, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py27hedc7406_0.tar.bz2": { + "build": "py27hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "4a0093d4fadfe118fde9c0ac1888a484", + "name": "scikit-learn", + "sha256": "27af76040bf9ad90cf271eaa043c572c693bf69ad10781eda3e993858472a4a2", + "size": 5597984, + "subdir": "linux-64", + "timestamp": 1530839068002, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py35_nomklh26d41a3_0.tar.bz2": { + "build": "py35_nomklh26d41a3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "7f25ccc81cd557cb4b75816cfc90a387", + "name": "scikit-learn", + "sha256": "e7307f393e3979800458d9c0f5851d3860d78cd67f1b71e68a351f4745bb3499", + "size": 5473517, + "subdir": "linux-64", + "timestamp": 1509990074280, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py35hbf1f462_0.tar.bz2": { + "build": "py35hbf1f462_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "60515074a552a4575922214b4cea18ed", + "name": "scikit-learn", + "sha256": "125fd1b9e777f44ba3ed5c819aa92b0aa8bba8f40bac16aadbc593920e1ca15d", + "size": 5475638, + "subdir": "linux-64", + "timestamp": 1508764275439, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py36_nomklh27f7947_0.tar.bz2": { + "build": "py36_nomklh27f7947_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "da547cb7970b8e89dbbec90786af38cf", + "name": "scikit-learn", + "sha256": "9ecb65b231d789681e5c7fec69801464b36b7fb8c62efc60174a0044d478f4d9", + "size": 5459352, + "subdir": "linux-64", + "timestamp": 1509989934790, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py36_nomklh6cfcb94_0.tar.bz2": { + "build": "py36_nomklh6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "0c04943556226ea2cb6c29125ec00790", + "name": "scikit-learn", + "sha256": "c0cd4e0f5dde6ad681d871520f55bfb2b47e2801bb66c3655766d04e108f7dc3", + "size": 5469157, + "subdir": "linux-64", + "timestamp": 1530842082052, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py36h7aa7ec6_0.tar.bz2": { + "build": "py36h7aa7ec6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "a0ee2386e1a142be177b49d84ce8631f", + "name": "scikit-learn", + "sha256": "492df66951d3022604fb9a8a05d821b7ad63fdcb451055c80eb50ebcc8340ace", + "size": 5462720, + "subdir": "linux-64", + "timestamp": 1508764315710, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py36hedc7406_0.tar.bz2": { + "build": "py36hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "cd46ad4c337eab8c4e7b904bbcd57a2d", + "name": "scikit-learn", + "sha256": "4a2fb4467d57863ce49dc041becdb03923749f89038b7e3f65fbd605bbccd7d8", + "size": 5468214, + "subdir": "linux-64", + "timestamp": 1530841220566, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py37_nomklh6cfcb94_0.tar.bz2": { + "build": "py37_nomklh6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "befd2d65d6d52ac86b9b69570a79c9d2", + "name": "scikit-learn", + "sha256": "ee675482bcc9dd1e32c13772bd7a54408232e4bb37e0392985925b72d905c71c", + "size": 5454925, + "subdir": "linux-64", + "timestamp": 1530838232533, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py37hedc7406_0.tar.bz2": { + "build": "py37hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "aa32311858f472a7d427baee4d6b7552", + "name": "scikit-learn", + "sha256": "db1baf55e1441eb9a9b9181a344fafe34a6b858ed0430f43ab30eda69a3fce51", + "size": 5455253, + "subdir": "linux-64", + "timestamp": 1530837380199, + "version": "0.19.1" + }, + "scikit-learn-0.19.2-py27h22eb022_0.tar.bz2": { + "build": "py27h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "e25c8b08efdb4d4c5fd4d5ba935d6ce1", + "name": "scikit-learn", + "sha256": "b02ee46f4cbc861a11dd8d607be668275c0ae2b5b0410aba4b072b0aadf51971", + "size": 5586884, + "subdir": "linux-64", + "timestamp": 1537478138014, + "version": "0.19.2" + }, + "scikit-learn-0.19.2-py27h4989274_0.tar.bz2": { + "build": "py27h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "7c1c6663e605f5ef60a88d5062455466", + "name": "scikit-learn", + "sha256": "966bdb7e459551170ad758a9b6b34c26836f3411056e13834f5002acec185b45", + "size": 5587489, + "subdir": "linux-64", + "timestamp": 1537478715232, + "version": "0.19.2" + }, + "scikit-learn-0.19.2-py35h22eb022_0.tar.bz2": { + "build": "py35h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "c6bbc69c37472698d6a699157b594f85", + "name": "scikit-learn", + "sha256": "fe1fadefdeed0c9e68ca71b5c0f68dd96524de9b800cdf474c4a8525d5deab83", + "size": 5494054, + "subdir": "linux-64", + "timestamp": 1537478083323, + "version": "0.19.2" + }, + "scikit-learn-0.19.2-py35h4989274_0.tar.bz2": { + "build": "py35h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "caec589cef23b26eafbd5731b43aa9a8", + "name": "scikit-learn", + "sha256": "83d079458d3da5528d51e41047f3b43c5084b431219a9ec222ad1d32346184e8", + "size": 5495831, + "subdir": "linux-64", + "timestamp": 1537478466829, + "version": "0.19.2" + }, + "scikit-learn-0.19.2-py36h22eb022_0.tar.bz2": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "36a732bc1b0200bf19fc2fbffa4a137a", + "name": "scikit-learn", + "sha256": "e68b2f9e65262df50ff7e7059cb03f8bda5c8dd640f4a812547bb89ff0d39829", + "size": 5454012, + "subdir": "linux-64", + "timestamp": 1537478215105, + "version": "0.19.2" + }, + "scikit-learn-0.19.2-py36h4989274_0.tar.bz2": { + "build": "py36h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "67c0353dc30b688412209f864ea0e422", + "name": "scikit-learn", + "sha256": "78d0979210ad8611a6b8f07a80934b9108b92fe0288b40ad557c83f35701b2e6", + "size": 5454871, + "subdir": "linux-64", + "timestamp": 1537478778054, + "version": "0.19.2" + }, + "scikit-learn-0.19.2-py37h22eb022_0.tar.bz2": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "85f85c789eb4933438f0e388a15b198a", + "name": "scikit-learn", + "sha256": "6e540558495d5b9aecb449bfc2ebfea75fb43ae58338007672c64111340fe5e7", + "size": 5450053, + "subdir": "linux-64", + "timestamp": 1537478089554, + "version": "0.19.2" + }, + "scikit-learn-0.19.2-py37h4989274_0.tar.bz2": { + "build": "py37h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "22c64e0de87b153a7fbdc749cb73d3f9", + "name": "scikit-learn", + "sha256": "50e1488a4a6e8e67e7d19a53a2cecc0d9ff05f8eb68a19e70068364fd92d3137", + "size": 5451297, + "subdir": "linux-64", + "timestamp": 1537478439400, + "version": "0.19.2" + }, + "scikit-learn-0.20.0-py27h22eb022_0.tar.bz2": { + "build": "py27h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "b41f39809a8578cbed6746fd91878533", + "name": "scikit-learn", + "sha256": "8a9eafcfffe0b42dfa20407ab077158625bb4b2b3306cbb5e9402562fd06c17c", + "size": 6090496, + "subdir": "linux-64", + "timestamp": 1537975606170, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py27h22eb022_1.tar.bz2": { + "build": "py27h22eb022_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "0df90eea6848ef52a0320759f464026f", + "name": "scikit-learn", + "sha256": "1cb551c520759edc7324017953f529e6cba2c7e374ee2f968c0b707466d48282", + "size": 6092086, + "subdir": "linux-64", + "timestamp": 1538056845417, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py27h4989274_0.tar.bz2": { + "build": "py27h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "90fa9a4f1d22c50e4bec327b9054e86e", + "name": "scikit-learn", + "sha256": "1028a1854ffe050ee71ffdb620da5e8ea37275c431c9d872d2397ec46430e660", + "size": 6091220, + "subdir": "linux-64", + "timestamp": 1537975691271, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py27h4989274_1.tar.bz2": { + "build": "py27h4989274_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "0738e972c5aeac3d8556ab13eb956e01", + "name": "scikit-learn", + "sha256": "84a520d13b160a8b2ecb8b78b82858908c40f68718fbe06ec3ef3a7d3ef42a57", + "size": 6093041, + "subdir": "linux-64", + "timestamp": 1538057234496, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py35h22eb022_0.tar.bz2": { + "build": "py35h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "d26bd8b702002c7261ffd4fd46be7750", + "name": "scikit-learn", + "sha256": "56d91215bdbd68c35bcd0be1410500f47c46471812534428c1c4c61542a9f56a", + "size": 5986036, + "subdir": "linux-64", + "timestamp": 1537975695314, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py35h22eb022_1.tar.bz2": { + "build": "py35h22eb022_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "c932e1ca999ea91ec9d580bb76e7bd59", + "name": "scikit-learn", + "sha256": "b6ad55323b82a72d01e7fe15fa8767626c0e92782ec0fe7109ea457a06a82a2a", + "size": 5988306, + "subdir": "linux-64", + "timestamp": 1538056894882, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py35h4989274_0.tar.bz2": { + "build": "py35h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "d115e83ea3443eda1ac2aa576244653f", + "name": "scikit-learn", + "sha256": "d5cd0dbd12659aa93c60171d7a4e8f939b085cd5d47385b324b7f02813835cd8", + "size": 5987761, + "subdir": "linux-64", + "timestamp": 1537975674618, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py35h4989274_1.tar.bz2": { + "build": "py35h4989274_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "f2c7caed845556cae1d4952701d4aac9", + "name": "scikit-learn", + "sha256": "5669b96f94fa09942ffaf81fe563ff358dd3a597ca0f56efb8473cdbcbf97b41", + "size": 5990942, + "subdir": "linux-64", + "timestamp": 1538057428755, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py36h22eb022_0.tar.bz2": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "b9f33e24b5ee972df4958c6fbd1df9e1", + "name": "scikit-learn", + "sha256": "7573dd65a7832960df460934cb377f66d49f509c6c16a7f238e4e2fe66231959", + "size": 6035116, + "subdir": "linux-64", + "timestamp": 1537977081536, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py36h22eb022_1.tar.bz2": { + "build": "py36h22eb022_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "60449859a1842ce7a1f6d35095e018a4", + "name": "scikit-learn", + "sha256": "99ec55bc707470ae2e6a7b820c9119b28f73096818f9d606040f9b22820c1af0", + "size": 6039498, + "subdir": "linux-64", + "timestamp": 1538056878726, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py36h4989274_0.tar.bz2": { + "build": "py36h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "257f3d37afcc55b03d284b49b20728f9", + "name": "scikit-learn", + "sha256": "17f919cfcf07377427297bf64bc58f568d24e20ddcc1c852679086ab6e2816cb", + "size": 6035445, + "subdir": "linux-64", + "timestamp": 1537975682954, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py36h4989274_1.tar.bz2": { + "build": "py36h4989274_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "5c5c524f0d6ef906b449c6109fa97a3e", + "name": "scikit-learn", + "sha256": "a8dbbee71b7422d4f0881600cba9e6787f332d21d35f980706ca27d3d9897b01", + "size": 6038918, + "subdir": "linux-64", + "timestamp": 1538057463166, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py37h22eb022_0.tar.bz2": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "04b17af6c9d3678ab5ce4e33fe154cd2", + "name": "scikit-learn", + "sha256": "a73902a82f3d6d8f60c5de6c2f7ece5f0804567e7f8a66cdb3f51e69192e2c87", + "size": 6019559, + "subdir": "linux-64", + "timestamp": 1537975548225, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py37h22eb022_1.tar.bz2": { + "build": "py37h22eb022_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "fe66eb4f160f5f7d88c565fa4a3dda2e", + "name": "scikit-learn", + "sha256": "9739f3a8caca6fbbf554cbad0bccb0fbd69f0d1c76a1b29a1e6285751bdca29f", + "size": 6023214, + "subdir": "linux-64", + "timestamp": 1538064324996, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py37h4989274_0.tar.bz2": { + "build": "py37h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "774c40688f2617220119db2265e80437", + "name": "scikit-learn", + "sha256": "d2f7751d8ca2793d17ca5c0e115a0bb6d2bf5c55eed18278e5400b19ceeb723e", + "size": 6021100, + "subdir": "linux-64", + "timestamp": 1537975667418, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py37h4989274_1.tar.bz2": { + "build": "py37h4989274_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "98bb29ded72dffd78009ea562a420c10", + "name": "scikit-learn", + "sha256": "0c1b42f1216253f44337b24ca4cb6f9ef9bb85c506585329985a25022cbfd44b", + "size": 6024808, + "subdir": "linux-64", + "timestamp": 1538057132864, + "version": "0.20.0" + }, + "scikit-learn-0.20.1-py27h22eb022_0.tar.bz2": { + "build": "py27h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "bfdc341d7e07d6a595f8fff0eb7f228e", + "name": "scikit-learn", + "sha256": "ea86e55b74f97acc08bd31289b5fba15de1fa0c6ba4e34d9876b4a70c9ab490a", + "size": 6051830, + "subdir": "linux-64", + "timestamp": 1542950750557, + "version": "0.20.1" + }, + "scikit-learn-0.20.1-py27h4989274_0.tar.bz2": { + "build": "py27h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "5af5768bf325d50b0074c186a0789b8f", + "name": "scikit-learn", + "sha256": "a8a138e502ea165411030196ded2800375eae59268276a2880179b71fdeefc3a", + "size": 6074792, + "subdir": "linux-64", + "timestamp": 1543000867296, + "version": "0.20.1" + }, + "scikit-learn-0.20.1-py27hd81dba3_0.tar.bz2": { + "build": "py27hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "e0ee5bd983647e90f738811d0102f250", + "name": "scikit-learn", + "sha256": "ce46a8e010e4121c430b23c6238d9a8dba173eb534d9b871e98a6d682457ee94", + "size": 6051566, + "subdir": "linux-64", + "timestamp": 1544817272383, + "version": "0.20.1" + }, + "scikit-learn-0.20.1-py36h22eb022_0.tar.bz2": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "e480202dbc9f6303676d20a89168d421", + "name": "scikit-learn", + "sha256": "28ff528c61c1bfdcad767ca8dec392960d1ea8064243fa0eaed6d589393733c3", + "size": 6007785, + "subdir": "linux-64", + "timestamp": 1542950685408, + "version": "0.20.1" + }, + "scikit-learn-0.20.1-py36h4989274_0.tar.bz2": { + "build": "py36h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "df264081c87daeeff3d00cdf7ab4bce8", + "name": "scikit-learn", + "sha256": "2fd96b1b65c16ecd0f3a7ccb887be55dd80746eb4d53fd8b3296ac61a896935d", + "size": 5963949, + "subdir": "linux-64", + "timestamp": 1542950851573, + "version": "0.20.1" + }, + "scikit-learn-0.20.1-py36hd81dba3_0.tar.bz2": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "311deaff7da8f4f290340be5bfc33890", + "name": "scikit-learn", + "sha256": "95752c4cf9f7df2ad403f092acec431842a569c6ab27290b0171286e345debe2", + "size": 5959433, + "subdir": "linux-64", + "timestamp": 1544817327740, + "version": "0.20.1" + }, + "scikit-learn-0.20.1-py37h22eb022_0.tar.bz2": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "1be47baf7fc074aec7cc7a1dd4cf0130", + "name": "scikit-learn", + "sha256": "5b09908d7596a5bdd35547fa828e7b48573a3d415d65088a8eed73bd6939b3d5", + "size": 5958730, + "subdir": "linux-64", + "timestamp": 1542950687073, + "version": "0.20.1" + }, + "scikit-learn-0.20.1-py37h4989274_0.tar.bz2": { + "build": "py37h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "0d5bdbb65c8b1d58b4239667ddc80a14", + "name": "scikit-learn", + "sha256": "644d983fe3cea7e7729825873a69a0a76ca94e248a0b1e0b52d80cefcca496ce", + "size": 5939169, + "subdir": "linux-64", + "timestamp": 1543029701541, + "version": "0.20.1" + }, + "scikit-learn-0.20.1-py37hd81dba3_0.tar.bz2": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "f27bb2721bb7f47f9b0646596fa2863e", + "name": "scikit-learn", + "sha256": "5a6d303f381f1ed424f079e03b3a74e8051c92d8ed77e7db2ab446ff6bc96037", + "size": 5946002, + "subdir": "linux-64", + "timestamp": 1544817320148, + "version": "0.20.1" + }, + "scikit-learn-0.20.2-py27h22eb022_0.tar.bz2": { + "build": "py27h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "843c15c79d5415256b6eb3dd87e49f3d", + "name": "scikit-learn", + "sha256": "e1c95baf5923ba80ebf2ac3dfa88da91aebdcae20fcc53286f2ed416384a95ef", + "size": 6095653, + "subdir": "linux-64", + "timestamp": 1545937696099, + "version": "0.20.2" + }, + "scikit-learn-0.20.2-py27hd81dba3_0.tar.bz2": { + "build": "py27hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "f08b295a371121f627d170fa8e931fba", + "name": "scikit-learn", + "sha256": "223ba11ccc063f866054a5646603b2a957fa1788c771b30b9c4f601c7c4ec290", + "size": 6017976, + "subdir": "linux-64", + "timestamp": 1545937860581, + "version": "0.20.2" + }, + "scikit-learn-0.20.2-py36h22eb022_0.tar.bz2": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "a5c89c165308c336991352e835868f01", + "name": "scikit-learn", + "sha256": "67d07f0ce46220841eb4cff90c3e9ef948120595f1220206115da4f43f8b4ac2", + "size": 5962339, + "subdir": "linux-64", + "timestamp": 1545937719956, + "version": "0.20.2" + }, + "scikit-learn-0.20.2-py36hd81dba3_0.tar.bz2": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "7f765e3e5dd01288e1156074fd992349", + "name": "scikit-learn", + "sha256": "5857156858752ddf23f50362b448f4f7379aa4a57fcf2ada79a199194cab3c11", + "size": 6012283, + "subdir": "linux-64", + "timestamp": 1545937635812, + "version": "0.20.2" + }, + "scikit-learn-0.20.2-py37h22eb022_0.tar.bz2": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "b735578530562e3daecccd8aa1980f79", + "name": "scikit-learn", + "sha256": "8c0de9644736fbe828eacd2bb4588661ea18e3cf2ab90aed60edf5d7f09542db", + "size": 5966038, + "subdir": "linux-64", + "timestamp": 1545937690744, + "version": "0.20.2" + }, + "scikit-learn-0.20.2-py37hd81dba3_0.tar.bz2": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "f5662a37947a5dadc6cfcc6ceeee0f7e", + "name": "scikit-learn", + "sha256": "c3b660d0489cbb8e86275f60dbcb7f925464f5be7c2ff8c47a62f8f78307e529", + "size": 5941459, + "subdir": "linux-64", + "timestamp": 1545937715117, + "version": "0.20.2" + }, + "scikit-learn-0.20.3-py27h22eb022_0.tar.bz2": { + "build": "py27h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "72bfb91445ea737608affc6a29bbbce9", + "name": "scikit-learn", + "sha256": "df50dd002da2f1e95224fa4db3872ace49d38958a25d2adea9cdc12c31512afb", + "size": 6129359, + "subdir": "linux-64", + "timestamp": 1552419142299, + "version": "0.20.3" + }, + "scikit-learn-0.20.3-py27hd81dba3_0.tar.bz2": { + "build": "py27hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "26816c8ca0a4649f7c99f1a3fc8d529b", + "name": "scikit-learn", + "sha256": "4c21c26b317ed3df331759cd32edf8b70fe763a5af1ac3c1d0fde3fe26063ba1", + "size": 6057536, + "subdir": "linux-64", + "timestamp": 1552417963365, + "version": "0.20.3" + }, + "scikit-learn-0.20.3-py36h22eb022_0.tar.bz2": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "c5279f89e2beb9f77dfbce2bde2d7fa6", + "name": "scikit-learn", + "sha256": "21168c0f13c7dacf83bdbf4ebb182a30588686b8df64bdac507fd884a193c9fd", + "size": 6063344, + "subdir": "linux-64", + "timestamp": 1552417845471, + "version": "0.20.3" + }, + "scikit-learn-0.20.3-py36hd81dba3_0.tar.bz2": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "23b8df2353f91df37fd8eede55ae025f", + "name": "scikit-learn", + "sha256": "4b3ac8d25be311295cb23e498b8be962f2203e20dd47d65e63a72ef2b2a4ab07", + "size": 6026042, + "subdir": "linux-64", + "timestamp": 1552419333259, + "version": "0.20.3" + }, + "scikit-learn-0.20.3-py37h22eb022_0.tar.bz2": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "8c060e413c4b88b262d3e697e986966e", + "name": "scikit-learn", + "sha256": "d33d9a4b3a860247b422ebb1558c38d8946c64e2aad4331b2e095185ae76469f", + "size": 5986552, + "subdir": "linux-64", + "timestamp": 1552419025243, + "version": "0.20.3" + }, + "scikit-learn-0.20.3-py37hd81dba3_0.tar.bz2": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "f4c03eaf380abfc8d4ad257b6c87e73d", + "name": "scikit-learn", + "sha256": "b1bea3b96c64af37dc1c977fbb5773e15d06aeb461b574ff374fbf4f993c9e91", + "size": 6049421, + "subdir": "linux-64", + "timestamp": 1552419338884, + "version": "0.20.3" + }, + "scikit-learn-0.21.1-py36h22eb022_0.tar.bz2": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "5808edc3132c309a84817242c829a8e7", + "name": "scikit-learn", + "sha256": "a96296e312df68a426b068f6c9c613a257c11cfc5f40bf6b9ca14160d2c78e24", + "size": 7050378, + "subdir": "linux-64", + "timestamp": 1558144091572, + "version": "0.21.1" + }, + "scikit-learn-0.21.1-py36hd81dba3_0.tar.bz2": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "0599ca51d65f22ed7b6de7a4d1f4a960", + "name": "scikit-learn", + "sha256": "a4e5a9dd84e2df09053acced24eb65b49e2fc2101ca52023398d7e5d45577720", + "size": 7035566, + "subdir": "linux-64", + "timestamp": 1558144207485, + "version": "0.21.1" + }, + "scikit-learn-0.21.1-py37h22eb022_0.tar.bz2": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "f2a47ec1979428de48afb1a984703ac0", + "name": "scikit-learn", + "sha256": "0fd1f050f4c3e629bedc2ec78fc8b31cfcf94da069dd4d3b964074d095211a2f", + "size": 7034302, + "subdir": "linux-64", + "timestamp": 1558143679327, + "version": "0.21.1" + }, + "scikit-learn-0.21.1-py37hd81dba3_0.tar.bz2": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "902aa363566b93cafcd5c52817ffe0d3", + "name": "scikit-learn", + "sha256": "baaa5ab6bb331f5ba7325b6a5e503a69b40d6dc3d584a6a61acb81bcebf7ac00", + "size": 7043863, + "subdir": "linux-64", + "timestamp": 1558143803579, + "version": "0.21.1" + }, + "scikit-learn-0.21.1-py38h22eb022_0.tar.bz2": { + "build": "py38h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "29ec0487cbc16bb90ee1bc03079a3d0b", + "name": "scikit-learn", + "sha256": "a76c873aee1cd0254d128f7903fdce6e4d3538c5745d21b7c9b07eb8b73acd27", + "size": 7220050, + "subdir": "linux-64", + "timestamp": 1574275317479, + "version": "0.21.1" + }, + "scikit-learn-0.21.1-py38hd81dba3_0.tar.bz2": { + "build": "py38hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "5b76f330e058293777a64e142b878e12", + "name": "scikit-learn", + "sha256": "baa52f418e7204b046fcafa4ac78637b26005fbfce630e98d0ea19e3f4fb8cfa", + "size": 7220595, + "subdir": "linux-64", + "timestamp": 1574274746174, + "version": "0.21.1" + }, + "scikit-learn-0.21.2-py36h22eb022_0.tar.bz2": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "564cb7d1e04b26795732993ed806d1be", + "name": "scikit-learn", + "sha256": "08a3eac4a6bc9f2d1e88f14db5192656ad4430b480949f47eb69e8b984f9a8a6", + "size": 7063940, + "subdir": "linux-64", + "timestamp": 1559646310151, + "version": "0.21.2" + }, + "scikit-learn-0.21.2-py36hd81dba3_0.tar.bz2": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "3635edd17eccdf15ada607fe88308a8e", + "name": "scikit-learn", + "sha256": "51fbf93cb4f312ba4345e56556b2724235f1a3705a0b8174a6c9d718c83549a0", + "size": 7045090, + "subdir": "linux-64", + "timestamp": 1559646374541, + "version": "0.21.2" + }, + "scikit-learn-0.21.2-py37h22eb022_0.tar.bz2": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "7c10007f9960891cd960d54cf7e1cd63", + "name": "scikit-learn", + "sha256": "2baef7ea38bdaf067a87c917cf7f0a8cd3a36f3b5fc01ed6908dc531d3e5507c", + "size": 6999514, + "subdir": "linux-64", + "timestamp": 1559646259594, + "version": "0.21.2" + }, + "scikit-learn-0.21.2-py37hd81dba3_0.tar.bz2": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "6aed4f77adc091951cbfb67d684642c0", + "name": "scikit-learn", + "sha256": "b0c155d225faec55950efaeb1dfbe6b54ef29f3478d6c0e2380b447e114f1565", + "size": 7029470, + "subdir": "linux-64", + "timestamp": 1559646192009, + "version": "0.21.2" + }, + "scikit-learn-0.21.3-py36h22eb022_0.tar.bz2": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "2d435cf53090afe33b83be72708cb388", + "name": "scikit-learn", + "sha256": "1a474155fe5e74a90c69486285bdad748dc0c9a091871c7ad9b0a404da3d6063", + "size": 7102704, + "subdir": "linux-64", + "timestamp": 1569370060386, + "version": "0.21.3" + }, + "scikit-learn-0.21.3-py36hd81dba3_0.tar.bz2": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "4633e8012e03e6b0067e9eb2a805f81f", + "name": "scikit-learn", + "sha256": "50888eef349772bb987b3b975195477c08e732231201c610dd7e04cafebfec78", + "size": 7109565, + "subdir": "linux-64", + "timestamp": 1569369885554, + "version": "0.21.3" + }, + "scikit-learn-0.21.3-py37h22eb022_0.tar.bz2": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "732e4ca88b8e08d486302e9df059d149", + "name": "scikit-learn", + "sha256": "c5ab07c8fa520c4d0176ecfb7227444b95bb5961bf0a182721a7becf8bf887ad", + "size": 7073856, + "subdir": "linux-64", + "timestamp": 1569370009384, + "version": "0.21.3" + }, + "scikit-learn-0.21.3-py37hd81dba3_0.tar.bz2": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "fc0e025c8be1b237e1e4029ab7bd4450", + "name": "scikit-learn", + "sha256": "39ff271a16a8c4b4ac246b56078d1acc49d6634f396b0515018485fa9aa8d3ba", + "size": 7081788, + "subdir": "linux-64", + "timestamp": 1569370043587, + "version": "0.21.3" + }, + "scikit-learn-0.22-py36h22eb022_0.tar.bz2": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "4f8b65f09f5e9906dc16d86a09eb394c", + "name": "scikit-learn", + "sha256": "f2f986ff08a70f2dcb4ab7629ae8e37c1a3736951eca95e576f8a3120a75199c", + "size": 7470094, + "subdir": "linux-64", + "timestamp": 1576601111313, + "version": "0.22" + }, + "scikit-learn-0.22-py36hd81dba3_0.tar.bz2": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "91222fb1f0eccb73f1a761dd8245de6b", + "name": "scikit-learn", + "sha256": "cb3dccddc73ac47abe8812a3d40c6f739f7de1acad66414925be76465b0b2988", + "size": 7471843, + "subdir": "linux-64", + "timestamp": 1576601224046, + "version": "0.22" + }, + "scikit-learn-0.22-py37h22eb022_0.tar.bz2": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "ab2c6d60e35d8c8c5c49ab959486e7d5", + "name": "scikit-learn", + "sha256": "0ee7eb9fe2c48c5768da5ec1e9522b8378439b7684376fdc429c2e5a8a4c55d0", + "size": 7465266, + "subdir": "linux-64", + "timestamp": 1576601090329, + "version": "0.22" + }, + "scikit-learn-0.22-py37hd81dba3_0.tar.bz2": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "75d1c088da45daf1bd3f33dbd24222c8", + "name": "scikit-learn", + "sha256": "a53ea601c6f20e8f25511d3666c5de0337927f7b5b8dfd16157ee7c24059385d", + "size": 7448241, + "subdir": "linux-64", + "timestamp": 1576601112653, + "version": "0.22" + }, + "scikit-learn-0.22-py38h22eb022_0.tar.bz2": { + "build": "py38h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "878c74a4337221f0f1fa4751a2437d60", + "name": "scikit-learn", + "sha256": "ae1977b1f0b10b5b39cb69afbaee1d5dfcf9ef254bdf71017b509c3603bd6f3b", + "size": 7671862, + "subdir": "linux-64", + "timestamp": 1576601088192, + "version": "0.22" + }, + "scikit-learn-0.22-py38hd81dba3_0.tar.bz2": { + "build": "py38hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "e6c1ce77757fef88c607cf9667e6baea", + "name": "scikit-learn", + "sha256": "6097a00fb17507200017eb059c93946ff84c2dc3fdc8b10ec90c83d440aea2e6", + "size": 7619735, + "subdir": "linux-64", + "timestamp": 1576601213204, + "version": "0.22" + }, + "scikit-learn-0.22.1-py36h22eb022_0.tar.bz2": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "ff35ca97d762e2c134b2e32a5ea82783", + "name": "scikit-learn", + "sha256": "7423d597c2a9a96d9a67e7cb41518f48bc54f6123c50f4610a28e244e089ee40", + "size": 7480677, + "subdir": "linux-64", + "timestamp": 1578509975908, + "version": "0.22.1" + }, + "scikit-learn-0.22.1-py36hd81dba3_0.tar.bz2": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "5a66a2d30d5441c6961dc0262a959e3d", + "name": "scikit-learn", + "sha256": "0c6368687bfec7bfbee5bf6bb74e6dd5118e3d7b27043969c737a77e4e7a52e0", + "size": 7451978, + "subdir": "linux-64", + "timestamp": 1578509987373, + "version": "0.22.1" + }, + "scikit-learn-0.22.1-py37h22eb022_0.tar.bz2": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "cc6fd7890e6b687b96ec62baff24a441", + "name": "scikit-learn", + "sha256": "2eaa7978d512d85e457b25fd25ab4f8ad6ee863b8f53e05a7848edc156fddbbf", + "size": 7472937, + "subdir": "linux-64", + "timestamp": 1578509859744, + "version": "0.22.1" + }, + "scikit-learn-0.22.1-py37hd81dba3_0.tar.bz2": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "3d2e38b8f373285ac982434bf3a600fb", + "name": "scikit-learn", + "sha256": "78ebca3a9c68f74e5dea076afa2f08cfa0e62e2d66e1b5eca8d169f912e66ebb", + "size": 7449035, + "subdir": "linux-64", + "timestamp": 1578511515842, + "version": "0.22.1" + }, + "scikit-learn-0.22.1-py38h22eb022_0.tar.bz2": { + "build": "py38h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "8ece22fcb50a81be67dc341bc4f91e71", + "name": "scikit-learn", + "sha256": "f807dd9d975df1fc27590aca2884868198dd176eb831170245c44d5b8e919ac6", + "size": 7634195, + "subdir": "linux-64", + "timestamp": 1578509841107, + "version": "0.22.1" + }, + "scikit-learn-0.22.1-py38hd81dba3_0.tar.bz2": { + "build": "py38hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "868670866ebb3a09150059cc5856ed18", + "name": "scikit-learn", + "sha256": "4f18ebe09ab718fe557d7fe74f945f509a7f2e40444541eb8c5c6c963e33e940", + "size": 7630536, + "subdir": "linux-64", + "timestamp": 1578509838414, + "version": "0.22.1" + }, + "scikit-learn-0.23.1-py36h423224d_0.tar.bz2": { + "build": "py36h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "30ee7d10e34f01bc35a79cb96a1c979c", + "name": "scikit-learn", + "sha256": "c4e4ca9fe3fc6d54d80edb7cbfc40d712883f341f038c4485606a360b80de410", + "size": 7202176, + "subdir": "linux-64", + "timestamp": 1592503220041, + "version": "0.23.1" + }, + "scikit-learn-0.23.1-py36h7ea95a0_0.tar.bz2": { + "build": "py36h7ea95a0_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "d88f6d1be6504bd396d85ad66af1c7e1", + "name": "scikit-learn", + "sha256": "eb2215afc3fd4491a5eea5b7bd3a72ff8e0a09e36a70e72e48e44f7a85d942e7", + "size": 7187683, + "subdir": "linux-64", + "timestamp": 1592503234780, + "version": "0.23.1" + }, + "scikit-learn-0.23.1-py37h423224d_0.tar.bz2": { + "build": "py37h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "4f98b26efbe9ac3ca521c4b1e974a98a", + "name": "scikit-learn", + "sha256": "070e62e7cd57bfc8c01332be21fdb59fecab62903c2d1ff509198bdb242afc45", + "size": 7152079, + "subdir": "linux-64", + "timestamp": 1592503229047, + "version": "0.23.1" + }, + "scikit-learn-0.23.1-py37h7ea95a0_0.tar.bz2": { + "build": "py37h7ea95a0_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "beac1c6c1407463c8dcf4376605549e7", + "name": "scikit-learn", + "sha256": "f31b080dcf2490bd666fff21e8e9f52a1dc7e409ec8f576488efaa8135dc852a", + "size": 7155243, + "subdir": "linux-64", + "timestamp": 1592503213409, + "version": "0.23.1" + }, + "scikit-learn-0.23.1-py38h423224d_0.tar.bz2": { + "build": "py38h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "4e1ed2758c3cc86ea6f79cac047cc7e6", + "name": "scikit-learn", + "sha256": "8203c8b0170609eb24416d792bacf1d4b892ecb7bb808e27386ff2936a5a9dbf", + "size": 7352864, + "subdir": "linux-64", + "timestamp": 1592503225359, + "version": "0.23.1" + }, + "scikit-learn-0.23.1-py38h7ea95a0_0.tar.bz2": { + "build": "py38h7ea95a0_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "597c514aae61192b80ed72f93968e679", + "name": "scikit-learn", + "sha256": "454bd98d9dab7fe1721e61dd384d2e41153437934851bd0d69043791985b3b33", + "size": 7296984, + "subdir": "linux-64", + "timestamp": 1592503198929, + "version": "0.23.1" + }, + "scikit-learn-0.23.2-py36h0573a6f_0.tar.bz2": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "134dfe061eb1c1f74fe137900082e060", + "name": "scikit-learn", + "sha256": "9626476dd250225c278ebc46d619e8bf134de88fdfbe45053caae0ae32efe7e5", + "size": 7189855, + "subdir": "linux-64", + "timestamp": 1598380080330, + "version": "0.23.2" + }, + "scikit-learn-0.23.2-py37h0573a6f_0.tar.bz2": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "43d656b381705746b69241511e34b36c", + "name": "scikit-learn", + "sha256": "6b9849b34d5ed0fdd39a6b3ef536640db8ed6356c5ac762c83a09deecfd4eea9", + "size": 7209499, + "subdir": "linux-64", + "timestamp": 1598377271102, + "version": "0.23.2" + }, + "scikit-learn-0.23.2-py38h0573a6f_0.tar.bz2": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "ce07cd2d83fabcaad9150e7a4bdf3b6d", + "name": "scikit-learn", + "sha256": "f2c9359344af8d3789c7515a0a26137d3530cb2d9c7d515bd0c05d92eb47927a", + "size": 7373389, + "subdir": "linux-64", + "timestamp": 1598377263181, + "version": "0.23.2" + }, + "scikit-learn-0.23.2-py39ha9443f7_0.tar.bz2": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "66813e1e842088894ed4b801af8b5316", + "name": "scikit-learn", + "sha256": "42cb9c2f30629201137e0419ba1d8371774697bb1f1f99b5b0f2b962e1cb3ece", + "size": 7317534, + "subdir": "linux-64", + "timestamp": 1607712709370, + "version": "0.23.2" + }, + "scikit-learn-0.24.1-py36ha9443f7_0.tar.bz2": { + "build": "py36ha9443f7_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "69028331543e712007c236ee50264ded", + "name": "scikit-learn", + "sha256": "a0542b227bd629e86d2e078e267c2bd8cc233ae170c9cb6647910c7542c08861", + "size": 7395381, + "subdir": "linux-64", + "timestamp": 1614447042003, + "version": "0.24.1" + }, + "scikit-learn-0.24.1-py37ha9443f7_0.tar.bz2": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "ea17083cff14a7e5bb50f8891d24948c", + "name": "scikit-learn", + "sha256": "64098996858f0b2bc363d826281aeba4892bfbebb70ac89fd8f9176bb579247f", + "size": 7433853, + "subdir": "linux-64", + "timestamp": 1614445927466, + "version": "0.24.1" + }, + "scikit-learn-0.24.1-py38ha9443f7_0.tar.bz2": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "df31178e74be48d2030b1695e4ce5a38", + "name": "scikit-learn", + "sha256": "05b48efe69cff1c817bfd4531fc1577fa4d0141a6cf4e2fbd67a134f574dffa8", + "size": 7616716, + "subdir": "linux-64", + "timestamp": 1614447013267, + "version": "0.24.1" + }, + "scikit-learn-0.24.1-py39ha9443f7_0.tar.bz2": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "aaf4e855564b8934e5d1a1db50e92b74", + "name": "scikit-learn", + "sha256": "d053874707cfc8650586e4364f2264ef2f7dc5d921b9d3dc5aa40b6930a589a3", + "size": 7601384, + "subdir": "linux-64", + "timestamp": 1614446989989, + "version": "0.24.1" + }, + "scikit-learn-0.24.2-py36ha9443f7_0.tar.bz2": { + "build": "py36ha9443f7_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.19.1", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "md5": "38c52e24cea8fd7b53e312af939e80cd", + "name": "scikit-learn", + "sha256": "13243e1353ff9516122bc6376cc1dbc712c1990db3db40222e84c7990c0eb1c5", + "size": 7409962, + "subdir": "linux-64", + "timestamp": 1621366138175, + "version": "0.24.2" + }, + "scikit-learn-0.24.2-py37ha9443f7_0.tar.bz2": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.19.1", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "md5": "77951e1822e430674bc04e57dbfcb71f", + "name": "scikit-learn", + "sha256": "2870d94714e060e601605d356d34872b608b5adff999e67443368d4e24bdcc35", + "size": 7464186, + "subdir": "linux-64", + "timestamp": 1621370641737, + "version": "0.24.2" + }, + "scikit-learn-0.24.2-py38ha9443f7_0.tar.bz2": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.19.1", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "md5": "5a903b7633ccc7309fbafdc3ecdf670f", + "name": "scikit-learn", + "sha256": "d0f14d52dfb17cc72c393b206c9d1c2e8eec837880bc711cdfcc58cc56474016", + "size": 7613064, + "subdir": "linux-64", + "timestamp": 1621370723805, + "version": "0.24.2" + }, + "scikit-learn-0.24.2-py39ha9443f7_0.tar.bz2": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.19.1", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "md5": "414e02366089ed8729c9d09102c174bc", + "name": "scikit-learn", + "sha256": "af21f609c4abc170dd2c7e1bade47c6e34dcbd2427e3edd1ffdc303a6d63a1ab", + "size": 7625981, + "subdir": "linux-64", + "timestamp": 1621370712570, + "version": "0.24.2" + }, + "scikit-learn-1.0.1-py310h00e6091_0.tar.bz2": { + "build": "py310h00e6091_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a16d847b9ebbf85605369d1289d4b5c7", + "name": "scikit-learn", + "sha256": "21d9bcd44f0c092f9f059ed78b64aaa46f9d6af3755f17d3c4db985becf7ecf4", + "size": 21875096, + "subdir": "linux-64", + "timestamp": 1641557641362, + "version": "1.0.1" + }, + "scikit-learn-1.0.1-py37h51133e4_0.tar.bz2": { + "build": "py37h51133e4_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0806945e170dd8022680fd4bca157d80", + "name": "scikit-learn", + "sha256": "3422db6f499aeca2fe45b0345225daa7ab3a989d9e85e4ea85ebf9b4fdc61e66", + "size": 7844185, + "subdir": "linux-64", + "timestamp": 1635187368971, + "version": "1.0.1" + }, + "scikit-learn-1.0.1-py38h51133e4_0.tar.bz2": { + "build": "py38h51133e4_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee129f18517b3bdd7f0a69cb6f9816cd", + "name": "scikit-learn", + "sha256": "1e6f98bb442c22ecfb6698b7947bc75ccd5dfbb17546db328bc546ed291ba95a", + "size": 8007193, + "subdir": "linux-64", + "timestamp": 1635175786243, + "version": "1.0.1" + }, + "scikit-learn-1.0.1-py39h51133e4_0.tar.bz2": { + "build": "py39h51133e4_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "301e42c431c8ec0abf7821a0387c5179", + "name": "scikit-learn", + "sha256": "60df2589157e33f7ba03a57cbbfc464169bc58331b5e9e7b7fadbc8c5d287a1b", + "size": 8014900, + "subdir": "linux-64", + "timestamp": 1635187368893, + "version": "1.0.1" + }, + "scikit-learn-1.0.2-py37h51133e4_0.tar.bz2": { + "build": "py37h51133e4_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "078be71cc88e0d4be87c109f555641b5", + "name": "scikit-learn", + "sha256": "92dc6c4770dd8efa4106494312cfd2b4183cb6aeb77fb43dcfcf00d34b80a5ae", + "size": 7813856, + "subdir": "linux-64", + "timestamp": 1641891306932, + "version": "1.0.2" + }, + "scikit-learn-1.0.2-py37h51133e4_1.tar.bz2": { + "build": "py37h51133e4_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8444ce92013aec7ec79085cd6a35dcd5", + "name": "scikit-learn", + "sha256": "17edf66c8daa570d64dbe2f2871fc700588e6b8e7e8613972684844f8a967479", + "size": 7797571, + "subdir": "linux-64", + "timestamp": 1642602084840, + "version": "1.0.2" + }, + "scikit-learn-1.0.2-py38h51133e4_0.tar.bz2": { + "build": "py38h51133e4_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9ed725ad8b0087e30b2550402d745094", + "name": "scikit-learn", + "sha256": "5e912d8ae44abeca527f07f4b7d4ebee43278fca1a46e1536915639fc2754526", + "size": 7984527, + "subdir": "linux-64", + "timestamp": 1641891291979, + "version": "1.0.2" + }, + "scikit-learn-1.0.2-py38h51133e4_1.tar.bz2": { + "build": "py38h51133e4_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "51493123a884f481a231bd0135efbb06", + "name": "scikit-learn", + "sha256": "2bd93c83e2f4b834a876a84dab987eb8c470ea5fc7836023b67c801f803a17c5", + "size": 7971729, + "subdir": "linux-64", + "timestamp": 1642617422064, + "version": "1.0.2" + }, + "scikit-learn-1.0.2-py39h51133e4_0.tar.bz2": { + "build": "py39h51133e4_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9777b0db0833e925a186184f45cd7868", + "name": "scikit-learn", + "sha256": "6e9641eff4cd64567b6c8eafacdf85c3f2d577aaf92f6472d1d3ad83a292d027", + "size": 7965209, + "subdir": "linux-64", + "timestamp": 1641876325807, + "version": "1.0.2" + }, + "scikit-learn-1.0.2-py39h51133e4_1.tar.bz2": { + "build": "py39h51133e4_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0e3a319569493ca47c7f2519e8c08222", + "name": "scikit-learn", + "sha256": "36a340bee59b7d3325e0a9eb5464c00d4f71b153b46819b06e93cc4d5b00c92b", + "size": 7975588, + "subdir": "linux-64", + "timestamp": 1642617419111, + "version": "1.0.2" + }, + "scikit-learn-1.1.1-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c0ab8e7166703125ec2f4c22d9dc4e55", + "name": "scikit-learn", + "sha256": "e4b672a28e624984331af898b720bff7aeee377488a820da715000b04a32ad3e", + "size": 27452641, + "subdir": "linux-64", + "timestamp": 1658421488391, + "version": "1.1.1" + }, + "scikit-learn-1.1.1-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "24a6a06535f5398ca523c8ba346f2de8", + "name": "scikit-learn", + "sha256": "787205bbf23de9cbf97566faf7b06b961d80b9c3191a7b42e8b67ee1a72b8789", + "size": 8780757, + "subdir": "linux-64", + "timestamp": 1658420573509, + "version": "1.1.1" + }, + "scikit-learn-1.1.1-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22e07b6e200a129f1cfc75758e3fb164", + "name": "scikit-learn", + "sha256": "99a35cbe804b2384521764f491b1bc169302377830965c224aa86aa56ac94245", + "size": 8709501, + "subdir": "linux-64", + "timestamp": 1658419721830, + "version": "1.1.1" + }, + "scikit-learn-1.1.2-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "446feb20aa74eded60b1354adc5e349a", + "name": "scikit-learn", + "sha256": "b7fa66e12e737d8a3e3cf8cda32983cc1ce804f2a0e772309ec3b33dd9d92de5", + "size": 8663999, + "subdir": "linux-64", + "timestamp": 1665482300806, + "version": "1.1.2" + }, + "scikit-learn-1.1.2-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7083d8837f5e905cad433bbfb2f431b9", + "name": "scikit-learn", + "sha256": "6cf2b1705cd798ca9330f0713c587fbcd06dd64beade2bed19e05d05c09517aa", + "size": 8774735, + "subdir": "linux-64", + "timestamp": 1665483087407, + "version": "1.1.2" + }, + "scikit-learn-1.1.2-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "32ca0db39aceb40ae06b58210fb8b16b", + "name": "scikit-learn", + "sha256": "1772823f103739ff88312a4c053db7b05b81ee5d160b878efa90737f8e2fe805", + "size": 8690766, + "subdir": "linux-64", + "timestamp": 1665483865138, + "version": "1.1.2" + }, + "scikit-learn-1.1.3-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ca94a4c4c2d563b2a26f3a8af6a67921", + "name": "scikit-learn", + "sha256": "9f7ad74a73b63771dae59a245e683ab5f6d2ed02cfb4942e19244b82d12c35ba", + "size": 8685200, + "subdir": "linux-64", + "timestamp": 1667589422649, + "version": "1.1.3" + }, + "scikit-learn-1.1.3-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e9265b6022532e8b1fcfdefbcbf1dc2f", + "name": "scikit-learn", + "sha256": "4f913aeaa8eb38d57274825f22336ee7e24fa5cd4609bf1a2e2df175ed89184d", + "size": 8737775, + "subdir": "linux-64", + "timestamp": 1667588617358, + "version": "1.1.3" + }, + "scikit-learn-1.1.3-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c3d98860433a44983f6d09df2eb89a68", + "name": "scikit-learn", + "sha256": "996cd29c499c8b84025140d8beabde94fd42762128b46e19c69329703d8110e1", + "size": 8686589, + "subdir": "linux-64", + "timestamp": 1667587828324, + "version": "1.1.3" + }, + "scikit-learn-1.2.0-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e6d0f8f942dfa6c3c79b56c080e9fa89", + "name": "scikit-learn", + "sha256": "7e60a70444d092866e94052f6b58f1acca9b20cc665e5b884eed78a4b27f260e", + "size": 9485092, + "subdir": "linux-64", + "timestamp": 1673957557583, + "version": "1.2.0" + }, + "scikit-learn-1.2.0-py310h6a678d5_1.tar.bz2": { + "build": "py310h6a678d5_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=1.3.2,<1.10.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e4a381998227bb2609e26605d8414e26", + "name": "scikit-learn", + "sha256": "67dbc6b44177d2fc043e147ce82d628838b371dfb2dd6530079096c4af884d8d", + "size": 9457580, + "subdir": "linux-64", + "timestamp": 1675445278397, + "version": "1.2.0" + }, + "scikit-learn-1.2.0-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2190617e2530dad3d27e83281bd786a8", + "name": "scikit-learn", + "sha256": "af4a7c3f1c96b56570266dc4f38e87a38073d5289e0427cba6accce96251727d", + "size": 9562528, + "subdir": "linux-64", + "timestamp": 1673958540155, + "version": "1.2.0" + }, + "scikit-learn-1.2.0-py38h6a678d5_1.tar.bz2": { + "build": "py38h6a678d5_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.3.2,<1.10.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "93defe9c0527f5022dd9994b19e0e6f6", + "name": "scikit-learn", + "sha256": "d074bccdf090e548bdc61057aba7e8080d295baaccdba6504d6a5ffac0d20367", + "size": 9556000, + "subdir": "linux-64", + "timestamp": 1675446363833, + "version": "1.2.0" + }, + "scikit-learn-1.2.0-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eaa92b617987b2ae567d9c38f970ab06", + "name": "scikit-learn", + "sha256": "32a4ef37e27ffd62cba231b7953e4bc414dad0c4fa7cb93afde1f2f7ea96f759", + "size": 9470472, + "subdir": "linux-64", + "timestamp": 1673959525458, + "version": "1.2.0" + }, + "scikit-learn-1.2.0-py39h6a678d5_1.tar.bz2": { + "build": "py39h6a678d5_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.3.2,<1.10.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bf829c54b361bc88e73adb241ecfa48a", + "name": "scikit-learn", + "sha256": "5944e7caa92b6a936d76e9e611e871f893a1be107c473fcf2ea6ff4c20711c5b", + "size": 9442710, + "subdir": "linux-64", + "timestamp": 1675447373915, + "version": "1.2.0" + }, + "scikit-learn-1.2.1-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "36b15a9e866fea9a5bf7d8a585361c77", + "name": "scikit-learn", + "sha256": "398f2589969bcab572f1c398df4f9808de6c2759c1e5c164c5c9560184b72ab3", + "size": 9567684, + "subdir": "linux-64", + "timestamp": 1676912908717, + "version": "1.2.1" + }, + "scikit-learn-1.2.1-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "python >=3.11,<3.12.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f95cadc3b50ac32dd97a1743f8dec43c", + "name": "scikit-learn", + "sha256": "1fd78f2bc9b93ecb6786987d995df607298113da9b5acec7449cb8581d7ff5c2", + "size": 10755350, + "subdir": "linux-64", + "timestamp": 1676919469968, + "version": "1.2.1" + }, + "scikit-learn-1.2.1-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "acd0b4bb4f22adfe7e74ceb68237b7ac", + "name": "scikit-learn", + "sha256": "f7c028216d81a44103159f26ee0af02430709e5b6837d47b5d6645cf6a6a9fd3", + "size": 9677151, + "subdir": "linux-64", + "timestamp": 1676913845682, + "version": "1.2.1" + }, + "scikit-learn-1.2.1-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "be1c65e42931cccf6785978bcfca4c39", + "name": "scikit-learn", + "sha256": "c8cae95b5b8237a7487956e1cff18e72fbf621ddcc5ab5fd9ddd2e947595471d", + "size": 9603253, + "subdir": "linux-64", + "timestamp": 1676911985237, + "version": "1.2.1" + }, + "scikit-learn-1.2.2-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a526e0eedbf0180cb8858dc0353d91bd", + "name": "scikit-learn", + "sha256": "4370a228f7794b08b04d958c4ebddae795bbef5cd58f5589e80d287c6e16a2c0", + "size": 9616386, + "subdir": "linux-64", + "timestamp": 1680199960717, + "version": "1.2.2" + }, + "scikit-learn-1.2.2-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "python >=3.11,<3.12.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6068c477fe2ddfc30da66d9eb003ebb7", + "name": "scikit-learn", + "sha256": "a6c2302d274dae261d796ecd0fa8c5b184c54b3cbe497096befa630d329b8f34", + "size": 10771528, + "subdir": "linux-64", + "timestamp": 1680199084767, + "version": "1.2.2" + }, + "scikit-learn-1.2.2-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.5,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e023f9b194eba9d2582f9ffff0301b16", + "name": "scikit-learn", + "sha256": "c1bfc7f9a58a909532d48d4f0b29728995b255b355a643c6e0e45248982181fc", + "size": 9716854, + "subdir": "linux-64", + "timestamp": 1680201795024, + "version": "1.2.2" + }, + "scikit-learn-1.2.2-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.5,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f66670694a006dba56938577332268c8", + "name": "scikit-learn", + "sha256": "a2f642e0e18fd25f721028e0384d29b387041c6598bab3809934c3313373c456", + "size": 9599096, + "subdir": "linux-64", + "timestamp": 1680200882292, + "version": "1.2.2" + }, + "scikit-learn-intelex-2021.2.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.2.2.*", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.21" + ], + "license": "Apache-2.0", + "md5": "b9de4c690835b2814565b64116904aaf", + "name": "scikit-learn-intelex", + "sha256": "aecb18b96a30cf98fd150a5bd99aaad57ee5ae4fe1f411e50a2ba00f78d2f587", + "size": 22599, + "subdir": "linux-64", + "timestamp": 1620147735682, + "version": "2021.2.2" + }, + "scikit-learn-intelex-2021.2.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.2.2.*", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.21" + ], + "license": "Apache-2.0", + "md5": "66cd3941922f79336c9188fb336f5ce1", + "name": "scikit-learn-intelex", + "sha256": "d6f805a6af9012f6eb5f935e8b394fc3050f0b678a7f60456421347324a50707", + "size": 22627, + "subdir": "linux-64", + "timestamp": 1620151720165, + "version": "2021.2.2" + }, + "scikit-learn-intelex-2021.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.2.2.*", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.21" + ], + "license": "Apache-2.0", + "md5": "6ec4abafeeb5bd9ec0d8f625db13d433", + "name": "scikit-learn-intelex", + "sha256": "11665341267832b079d9bb8af662cded8b69092b4d6dedfc114a22ef24e328c9", + "size": 22686, + "subdir": "linux-64", + "timestamp": 1620150918112, + "version": "2021.2.2" + }, + "scikit-learn-intelex-2021.2.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.2.2.*", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.21" + ], + "license": "Apache-2.0", + "md5": "be948006f9a48b94f003b66a80388d22", + "name": "scikit-learn-intelex", + "sha256": "a76bc85cfce85937346b677efb0470ec7b601bab300715fa64e52a0c0cea9db9", + "size": 22655, + "subdir": "linux-64", + "timestamp": 1620151722573, + "version": "2021.2.2" + }, + "scikit-learn-intelex-2021.3.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.3.0.*", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "8f092a7bf324078ab5e7afd85499db1a", + "name": "scikit-learn-intelex", + "sha256": "08ddfad611a3edf6237d1acaac96f58043b5d648a128eda1413ece3d226b81e9", + "size": 39098, + "subdir": "linux-64", + "timestamp": 1626282224437, + "version": "2021.3.0" + }, + "scikit-learn-intelex-2021.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.3.0.*", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "777ec90e3b0f8ab0f58acfbaad7bfdf0", + "name": "scikit-learn-intelex", + "sha256": "a0d827dfef95f691abecaca0da0d4780bf90e4be4297b03612fcdb3ffd96f9ea", + "size": 39097, + "subdir": "linux-64", + "timestamp": 1626275191037, + "version": "2021.3.0" + }, + "scikit-learn-intelex-2021.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.3.0.*", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "ea6f676f846c477389a098fa0055da7a", + "name": "scikit-learn-intelex", + "sha256": "6881a110fb3c5d93907b18f98344f47825b6208c6ddec2099d442f14aec1e846", + "size": 39224, + "subdir": "linux-64", + "timestamp": 1626282273775, + "version": "2021.3.0" + }, + "scikit-learn-intelex-2021.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.3.0.*", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "c03ec8bb21d374ee88a468a5e07af6c4", + "name": "scikit-learn-intelex", + "sha256": "585ad227d4288b4aaafcea934194a9aa73486c0fb24f9d7b2498584e0496c374", + "size": 39154, + "subdir": "linux-64", + "timestamp": 1626282286129, + "version": "2021.3.0" + }, + "scikit-learn-intelex-2021.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.4.0.*", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "af49ff0b1988f99d40ff424eb398ffa7", + "name": "scikit-learn-intelex", + "sha256": "73eac46a91278f2c82dec5f6d86316167da6abc40195da024168118c59a650d4", + "size": 62408, + "subdir": "linux-64", + "timestamp": 1640812901023, + "version": "2021.4.0" + }, + "scikit-learn-intelex-2021.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.4.0.*", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "ee83ad86c259efb384c43f6148417e9d", + "name": "scikit-learn-intelex", + "sha256": "45487462808643659d712075e26cf81e87cdfdee9aee90ee5e81f3ff4f55df0f", + "size": 63415, + "subdir": "linux-64", + "timestamp": 1638380740985, + "version": "2021.4.0" + }, + "scikit-learn-intelex-2021.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.4.0.*", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "a92b77612ab3156b00df192e43fd9168", + "name": "scikit-learn-intelex", + "sha256": "acf47f33f4cfa98ae26be88939c237b971614427fc5d6f62b982938b586aa634", + "size": 63737, + "subdir": "linux-64", + "timestamp": 1638380740482, + "version": "2021.4.0" + }, + "scikit-learn-intelex-2021.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.4.0.*", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "4497764347dcc49441292cd44af340d1", + "name": "scikit-learn-intelex", + "sha256": "9e16521286bd47e2cdec6595cc458984eee1da8e29286db92d1e99613ea75264", + "size": 63624, + "subdir": "linux-64", + "timestamp": 1638380737744, + "version": "2021.4.0" + }, + "scikit-learn-intelex-2021.5.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.5.0.*", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "59c7717bf9d866ab88949e93b73228ba", + "name": "scikit-learn-intelex", + "sha256": "f2b983c5808ca96732b6d61f83be6ec9c262f8099d89e9601a24bd15d2b8540f", + "size": 66428, + "subdir": "linux-64", + "timestamp": 1644942314493, + "version": "2021.5.0" + }, + "scikit-learn-intelex-2021.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.5.0.*", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "e788b0f0885e9dcd496e36efdf801bc9", + "name": "scikit-learn-intelex", + "sha256": "ab03649ac61c5e4815db85c8cacb4ba21ce39b13a9d4ea052c28365e095e4b45", + "size": 66641, + "subdir": "linux-64", + "timestamp": 1644960436708, + "version": "2021.5.0" + }, + "scikit-learn-intelex-2021.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.5.0.*", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "a3ce3b62cee7db25ab9c34556fbbc887", + "name": "scikit-learn-intelex", + "sha256": "d2c2a52ba5265dcf90592ef671d0978ae787296a1952c0c65fcf1fa3aa0964d6", + "size": 66517, + "subdir": "linux-64", + "timestamp": 1644960437696, + "version": "2021.5.0" + }, + "scikit-learn-intelex-2021.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.6.0.*", + "python >=3.10,<3.11.0a0", + "scikit-learn <1.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "65cb767c62d3269e0b908e35a7f3eda1", + "name": "scikit-learn-intelex", + "sha256": "b37302e3ba2d808e9aa0a2a8c74030ea76544b409f33dd29b516f925cb0493f3", + "size": 73443, + "subdir": "linux-64", + "timestamp": 1664903708808, + "version": "2021.6.0" + }, + "scikit-learn-intelex-2021.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.6.0.*", + "python >=3.7,<3.8.0a0", + "scikit-learn <1.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "de6f2cc86c9b81cf4d6d0bc52861182e", + "name": "scikit-learn-intelex", + "sha256": "931188da3660de8877cd8fd0fd862f40a9c2914dbd84dc3582e87829ab8e25c0", + "size": 72440, + "subdir": "linux-64", + "timestamp": 1664903603645, + "version": "2021.6.0" + }, + "scikit-learn-intelex-2021.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.6.0.*", + "python >=3.8,<3.9.0a0", + "scikit-learn <1.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1a167c290e25a09db71b2927bed926d1", + "name": "scikit-learn-intelex", + "sha256": "62832e07afb8d5a888aff45ec10c16f324bd93ea22362f4aed02bc54da4c9d38", + "size": 72832, + "subdir": "linux-64", + "timestamp": 1664903799836, + "version": "2021.6.0" + }, + "scikit-learn-intelex-2021.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.6.0.*", + "python >=3.9,<3.10.0a0", + "scikit-learn <1.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1b06f24a61fbbb904742762c72d1c742", + "name": "scikit-learn-intelex", + "sha256": "9c8302c63011f38cebde9ac4669d37423db954f1170ed3473748ff9227814f1f", + "size": 72819, + "subdir": "linux-64", + "timestamp": 1664903888931, + "version": "2021.6.0" + }, + "scikit-learn-intelex-2023.0.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2023.0.2.*", + "python >=3.10,<3.11.0a0", + "scikit-learn" + ], + "license": "Apache-2.0 AND BSD-2-Clause AND BSD-3-Clause AND MIT", + "license_family": "Apache", + "md5": "7bbcca0c1151e953aba239e81b97569c", + "name": "scikit-learn-intelex", + "sha256": "e74c302fa988aec26fd2297f04eacb420d3a2163d7f44b4c222225d96de10033", + "size": 76414, + "subdir": "linux-64", + "timestamp": 1677620564590, + "version": "2023.0.2" + }, + "scikit-learn-intelex-2023.0.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2023.0.2.*", + "python >=3.11,<3.12.0a0", + "scikit-learn" + ], + "license": "Apache-2.0 AND BSD-2-Clause AND BSD-3-Clause AND MIT", + "license_family": "Apache", + "md5": "b0dadbd55d797ae595ffe9a20b9d8548", + "name": "scikit-learn-intelex", + "sha256": "926f939fe0b3eaf07b4004924e02424a49b4a5dceb052adfbdc2550cf91e9d8b", + "size": 96051, + "subdir": "linux-64", + "timestamp": 1677685583252, + "version": "2023.0.2" + }, + "scikit-learn-intelex-2023.0.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2023.0.2.*", + "python >=3.8,<3.9.0a0", + "scikit-learn" + ], + "license": "Apache-2.0 AND BSD-2-Clause AND BSD-3-Clause AND MIT", + "license_family": "Apache", + "md5": "e14980788e63f7585aacade464795078", + "name": "scikit-learn-intelex", + "sha256": "e2030428af2c8fe32e237f6cbaf92fecc9475ffed534d54f9579f1879356e35f", + "size": 75819, + "subdir": "linux-64", + "timestamp": 1677620655632, + "version": "2023.0.2" + }, + "scikit-learn-intelex-2023.0.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2023.0.2.*", + "python >=3.9,<3.10.0a0", + "scikit-learn" + ], + "license": "Apache-2.0 AND BSD-2-Clause AND BSD-3-Clause AND MIT", + "license_family": "Apache", + "md5": "9bddc18ca95a4841070cb972e760ea36", + "name": "scikit-learn-intelex", + "sha256": "470bd7f210125c42e85b4343bfbff8c48dd64879cc83b495260fe9aa59d7b888", + "size": 75825, + "subdir": "linux-64", + "timestamp": 1677620470349, + "version": "2023.0.2" + }, + "scikit-rf-0.14.5-py27h6f8029f_0.tar.bz2": { + "build": "py27h6f8029f_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "abba7c077f716cc21a42ffbbe1fb8d9f", + "name": "scikit-rf", + "sha256": "a91c54d680e760644d03cb118623bc58ce0c272e9a61d943c06f3b46abf9ac0a", + "size": 840912, + "subdir": "linux-64", + "timestamp": 1509056523562, + "version": "0.14.5" + }, + "scikit-rf-0.14.5-py35hc292ca9_0.tar.bz2": { + "build": "py35hc292ca9_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.5,<3.6.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "55f72466e7ed35fe6071d139692e5ad0", + "name": "scikit-rf", + "sha256": "f2c525bad2a69576ff74ee77afb7c3af105a2c1a3c00bf5bc3a25d46fc423e76", + "size": 853377, + "subdir": "linux-64", + "timestamp": 1509056527765, + "version": "0.14.5" + }, + "scikit-rf-0.14.5-py36h9a41a6d_0.tar.bz2": { + "build": "py36h9a41a6d_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "ff9b500f96a4f8d531bbf335d007bff4", + "name": "scikit-rf", + "sha256": "30e9424cdbbec342806f383a25f68d7615aa1a81c79d522b42347912495167a3", + "size": 855526, + "subdir": "linux-64", + "timestamp": 1509056513875, + "version": "0.14.5" + }, + "scikit-rf-0.14.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "924bee7cf565061d9e8c1eeb7a757edc", + "name": "scikit-rf", + "sha256": "3482fc7468c94a53c1005aaec6f7717c304df748c938bb6c644fd2f355a35839", + "size": 1870674, + "subdir": "linux-64", + "timestamp": 1520880239988, + "version": "0.14.8" + }, + "scikit-rf-0.14.8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.5,<3.6.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "632a8dc4c6e5b15a0fc2cc7a64caa5ba", + "name": "scikit-rf", + "sha256": "27745180f882e5d85ef9311480197a7827cb1f85cd842e4cca4ad7c8b61213b5", + "size": 1876464, + "subdir": "linux-64", + "timestamp": 1520880270316, + "version": "0.14.8" + }, + "scikit-rf-0.14.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "0a47a93140c0ac25ce326e49240dab45", + "name": "scikit-rf", + "sha256": "31ccdcda1c937f7ed221b40590e0ca12142364c03fbadba35c00cce1efd9aed4", + "size": 1884934, + "subdir": "linux-64", + "timestamp": 1520880236665, + "version": "0.14.8" + }, + "scikit-rf-0.14.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "d6bfd2b5fcb4d8f6922bd6842b48a03b", + "name": "scikit-rf", + "sha256": "db184937a6417cbecc8d14f18ede8881bcda00088bac362081101949089acbe7", + "size": 1869058, + "subdir": "linux-64", + "timestamp": 1522715537979, + "version": "0.14.9" + }, + "scikit-rf-0.14.9-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.5,<3.6.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "2e59148d1c05b1a3ef9e7afa8cfbac5d", + "name": "scikit-rf", + "sha256": "594c0288bed6693c18ff70b81f087f97440eb4c1dfe6c9bfb0dcadd6e7d18fc7", + "size": 1878352, + "subdir": "linux-64", + "timestamp": 1522715537948, + "version": "0.14.9" + }, + "scikit-rf-0.14.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "7b44f2f33210837ef6ca8691daafee42", + "name": "scikit-rf", + "sha256": "df4be28125de40bffd0ca73d8d08d38c728d9782dfb6c1032c97146c21501bb6", + "size": 1885952, + "subdir": "linux-64", + "timestamp": 1522715598714, + "version": "0.14.9" + }, + "scikit-rf-0.15.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "b6cd872ac124080b017a32fc00063c70", + "name": "scikit-rf", + "sha256": "15a45e0a7a4468ddd5ffa68571a422bc044321191e5a1f7f6412600aab0343a3", + "size": 2064903, + "subdir": "linux-64", + "timestamp": 1600553245545, + "version": "0.15.4" + }, + "scikit-rf-0.15.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "2db6852a6dda214dcdeb23f77182a05e", + "name": "scikit-rf", + "sha256": "dcd06ebecc99e8d54c86d2bb79a784b233c2aa5829da902bb83c3cac568c3818", + "size": 2035356, + "subdir": "linux-64", + "timestamp": 1600553257839, + "version": "0.15.4" + }, + "scikit-rf-0.15.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.8,<3.9.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "f14590728bba8bf3adbf62b803915551", + "name": "scikit-rf", + "sha256": "eb0dc563622fb52e19f3ac8ed1a0f44c093e0788f4c6891f70f7280c0bc181b8", + "size": 1974493, + "subdir": "linux-64", + "timestamp": 1600553276234, + "version": "0.15.4" + }, + "scikit-rf-0.16.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "ee2a7f4762e5d27ef88f08c100dacde8", + "name": "scikit-rf", + "sha256": "701b67d567e812ec519ff73b6756b28f10a8450fce0e8612151401dc12a27f8d", + "size": 1995062, + "subdir": "linux-64", + "timestamp": 1611082325182, + "version": "0.16.0" + }, + "scikit-rf-0.16.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "3f0ecd05e7cc5160e8cbe2eae5f36e4d", + "name": "scikit-rf", + "sha256": "0a7d12eb597b68057f3b9d71489329fd3e1e71fbbdf1d39ff02b1b3009d8bf75", + "size": 2054586, + "subdir": "linux-64", + "timestamp": 1611081675660, + "version": "0.16.0" + }, + "scikit-rf-0.16.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.8,<3.9.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "6bbbb78274f3ef2a3ab86c8f08febc94", + "name": "scikit-rf", + "sha256": "df042f59ab4c1d5847c8e8e6aa9d244258dc5f635c0dfc26dfcee541f92076cf", + "size": 1997337, + "subdir": "linux-64", + "timestamp": 1611082469681, + "version": "0.16.0" + }, + "scikit-rf-0.16.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.9,<3.10.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "ea1ae570f9e1dbc88b72f0799f52ef54", + "name": "scikit-rf", + "sha256": "cd0a057b75a9982e7e50fbed4c93c98db9f1e7416c1a350fd173b8df94c6d04b", + "size": 2056491, + "subdir": "linux-64", + "timestamp": 1611082464851, + "version": "0.16.0" + }, + "scipy-0.19.1-py27_nomklhda24f63_3.tar.bz2": { + "build": "py27_nomklhda24f63_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "c825a62d8738da124f477f65fa42a1f0", + "name": "scipy", + "sha256": "c78d45645298d3698ef3cd2e57fe08d8838f5376876f777a8a93afac5693efd1", + "size": 18320281, + "subdir": "linux-64", + "timestamp": 1509733353797, + "version": "0.19.1" + }, + "scipy-0.19.1-py27h1edc525_3.tar.bz2": { + "build": "py27h1edc525_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "d3f31e79b1321185ba1bb5d83557e37c", + "name": "scipy", + "sha256": "e579faffb446b1ab3a5805f6b737f88b531e01f5b390073760d4195c7c9d3f63", + "size": 18329324, + "subdir": "linux-64", + "timestamp": 1506017697639, + "version": "0.19.1" + }, + "scipy-0.19.1-py35_nomklh614202b_3.tar.bz2": { + "build": "py35_nomklh614202b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "ff9db60b281b84e360a98d453097049e", + "name": "scipy", + "sha256": "0f5f81077aea022555ff7598005f4bc17b452950462a4b72aac1b61b805b30b5", + "size": 18219310, + "subdir": "linux-64", + "timestamp": 1509733318874, + "version": "0.19.1" + }, + "scipy-0.19.1-py35ha8f041b_3.tar.bz2": { + "build": "py35ha8f041b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "10d0efcc88413dff9c34265333c2c75d", + "name": "scipy", + "sha256": "2f128f4d591842cd7a67fb5f0540420d55facf4dac5ae7f988bd5867678e1e35", + "size": 18232423, + "subdir": "linux-64", + "timestamp": 1506017721703, + "version": "0.19.1" + }, + "scipy-0.19.1-py36_nomklh59deb5f_3.tar.bz2": { + "build": "py36_nomklh59deb5f_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "d47aeead9abb0cb4d99d18710990b7ba", + "name": "scipy", + "sha256": "7f02473ea58192fe8f7942ada89a622d987c51d6f4b88a04acb9e317184a6ca0", + "size": 18256235, + "subdir": "linux-64", + "timestamp": 1509733524208, + "version": "0.19.1" + }, + "scipy-0.19.1-py36h9976243_3.tar.bz2": { + "build": "py36h9976243_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "3e45e6875aa59fd005c97718bb8a7df4", + "name": "scipy", + "sha256": "7148feab1239d8157dda2be87ec0b97cea77fe8ae029c4bccb2d4c4e3bcc0d8c", + "size": 18263885, + "subdir": "linux-64", + "timestamp": 1506017647024, + "version": "0.19.1" + }, + "scipy-1.0.0-py27_nomklhc4f40eb_0.tar.bz2": { + "build": "py27_nomklhc4f40eb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "1de65ba838179b0e0d403f9565d5e8f0", + "name": "scipy", + "sha256": "8abbccc17b19090255257d3f2087616de5f71efe661f75f64c268500b64b655f", + "size": 18658572, + "subdir": "linux-64", + "timestamp": 1510078238571, + "version": "1.0.0" + }, + "scipy-1.0.0-py27hf5f0f52_0.tar.bz2": { + "build": "py27hf5f0f52_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "485236846e8db0e03ed6b9995503cf28", + "name": "scipy", + "sha256": "b4e4cda5c6a3f7f9eadd581293eebbf35ecd3a490a2f0db28411895b94eeda40", + "size": 18671053, + "subdir": "linux-64", + "timestamp": 1510078459686, + "version": "1.0.0" + }, + "scipy-1.0.0-py35_nomklhb72a26a_0.tar.bz2": { + "build": "py35_nomklhb72a26a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "e55e586122650716fb45ea66730f5884", + "name": "scipy", + "sha256": "0d5b31f60bc27d6cdda9e955f5816e0673cf3dc13557e9d07dde26bff62f5351", + "size": 18613633, + "subdir": "linux-64", + "timestamp": 1510078252167, + "version": "1.0.0" + }, + "scipy-1.0.0-py35hcbbe4a2_0.tar.bz2": { + "build": "py35hcbbe4a2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "43561007ab54717f10b02355101c4258", + "name": "scipy", + "sha256": "01330f4f920f62af329a3a9b4247ff66e989fbfc8291809c354c6abff4e06bfe", + "size": 18619674, + "subdir": "linux-64", + "timestamp": 1510078527168, + "version": "1.0.0" + }, + "scipy-1.0.0-py36_nomklh9d91e6a_0.tar.bz2": { + "build": "py36_nomklh9d91e6a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "06421670ab8e03e10ae78a1095f79ff1", + "name": "scipy", + "sha256": "90c3ff047f2815423c154957aa0d9d458f8bcdf53af83cb7f8cde23e3eb62e9f", + "size": 18693067, + "subdir": "linux-64", + "timestamp": 1510078541594, + "version": "1.0.0" + }, + "scipy-1.0.0-py36hbf646e7_0.tar.bz2": { + "build": "py36hbf646e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "ef35cad057587be153d8f19492d4f7a1", + "name": "scipy", + "sha256": "a612d379b29fb3785a7cf54cac5384eff8f4360b75ebd7cda06cf70348b0631b", + "size": 18699529, + "subdir": "linux-64", + "timestamp": 1510078530461, + "version": "1.0.0" + }, + "scipy-1.0.1-py27_nomklh9d22d0a_0.tar.bz2": { + "build": "py27_nomklh9d22d0a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "0cbf177e8e059ba074720d70b24c9664", + "name": "scipy", + "sha256": "299b54bc46c02dbc8a5d607f51669c8a748aeca36945c7a471edc95772544f99", + "size": 18603000, + "subdir": "linux-64", + "timestamp": 1522431943110, + "version": "1.0.1" + }, + "scipy-1.0.1-py27hfc37229_0.tar.bz2": { + "build": "py27hfc37229_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "8a4cb854a64db164408f5b1816c5979b", + "name": "scipy", + "sha256": "6c71a03ddda048fca799b39daa38997a133ad43f60079a6a72fb8f3b8d559af8", + "size": 18605533, + "subdir": "linux-64", + "timestamp": 1522432596622, + "version": "1.0.1" + }, + "scipy-1.0.1-py35_nomklh9d22d0a_0.tar.bz2": { + "build": "py35_nomklh9d22d0a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "30384029f8dad8302485b795ca60c16f", + "name": "scipy", + "sha256": "0d41be23f69e5f88664b0080cec8b397b79fd8a3ee83a9f061bdc9b3941851d7", + "size": 18654420, + "subdir": "linux-64", + "timestamp": 1522432435226, + "version": "1.0.1" + }, + "scipy-1.0.1-py35hfc37229_0.tar.bz2": { + "build": "py35hfc37229_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "3639d992b33270f8fe7dd1db1fda0e79", + "name": "scipy", + "sha256": "38244cba8478809e0ff85b1fe91fd5c523e9451f635389cfb31cbbea3b196cef", + "size": 18653375, + "subdir": "linux-64", + "timestamp": 1522432603785, + "version": "1.0.1" + }, + "scipy-1.0.1-py36_nomklh9d22d0a_0.tar.bz2": { + "build": "py36_nomklh9d22d0a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "ed326d37a6a01e895dfbcddd8b49e014", + "name": "scipy", + "sha256": "9a2092306957fad84852fe79644a2917e6907efc473919106586a5d356d0b207", + "size": 18695096, + "subdir": "linux-64", + "timestamp": 1522432446621, + "version": "1.0.1" + }, + "scipy-1.0.1-py36hfc37229_0.tar.bz2": { + "build": "py36hfc37229_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "136721636c2b63c5601a33a316dfa28d", + "name": "scipy", + "sha256": "154ebad95ae99404ade250e50096e4aa8b152ba2a18d05cb3efc6f5739225c65", + "size": 18703107, + "subdir": "linux-64", + "timestamp": 1522432028926, + "version": "1.0.1" + }, + "scipy-1.1.0-py27_nomklh9c1e066_0.tar.bz2": { + "build": "py27_nomklh9c1e066_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "90946e34a96fd030bd3bdc6b2606cf29", + "name": "scipy", + "sha256": "5f561afdc46d540686fb46c336ccff9a1e687254f8a9fef4db2db704e04225cf", + "size": 18860896, + "subdir": "linux-64", + "timestamp": 1530776927045, + "version": "1.1.0" + }, + "scipy-1.1.0-py27_nomklh9d22d0a_0.tar.bz2": { + "build": "py27_nomklh9d22d0a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "a8c2a8d2f4e16573072cec05631023dc", + "name": "scipy", + "sha256": "9cdaba2fae79204cf2df660392cbcb43c2fea2803141d9ee53bc4818a1bbabfb", + "size": 18816795, + "subdir": "linux-64", + "timestamp": 1525904152858, + "version": "1.1.0" + }, + "scipy-1.1.0-py27_nomklhb74e8f7_0.tar.bz2": { + "build": "py27_nomklhb74e8f7_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "166fc2519d5c481d5f78d26988ae8988", + "name": "scipy", + "sha256": "a222e989e1878ff47992757633698c1f277dcff8d7af1afc2136957f77004cec", + "size": 18765208, + "subdir": "linux-64", + "timestamp": 1534805161044, + "version": "1.1.0" + }, + "scipy-1.1.0-py27h7c811a0_2.tar.bz2": { + "build": "py27h7c811a0_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ab3730f924c19c7050b8e26c53be0d0c", + "name": "scipy", + "sha256": "266f5dd85120a3128bdd14323c695d953be9045d696522fe0dcbb5914d073b91", + "size": 18467154, + "subdir": "linux-64", + "timestamp": 1544811276215, + "version": "1.1.0" + }, + "scipy-1.1.0-py27h9b217d5_1.tar.bz2": { + "build": "py27h9b217d5_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.1,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6117ba244b44a317ee0a283473aee4ff", + "name": "scipy", + "sha256": "c77d642699ce5298a4aa5f105bf2a2f80cb3864a0f1136b227e7867868dea584", + "size": 18761893, + "subdir": "linux-64", + "timestamp": 1535416374272, + "version": "1.1.0" + }, + "scipy-1.1.0-py27hc49cb51_0.tar.bz2": { + "build": "py27hc49cb51_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e21ec5985860ff0ed454154809033ffa", + "name": "scipy", + "sha256": "aa75d3457618cc671c1de9fb245f9d1a7a1b19fdd9a4970dae03596c21ebec86", + "size": 18867892, + "subdir": "linux-64", + "timestamp": 1530775639634, + "version": "1.1.0" + }, + "scipy-1.1.0-py27hd20e5f9_0.tar.bz2": { + "build": "py27hd20e5f9_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ca940b5c556b4cb7b50985509a427403", + "name": "scipy", + "sha256": "ec535f27c4efe0ffb370314a9aa76462a321990043274d79161ce1c6de91106e", + "size": 18768651, + "subdir": "linux-64", + "timestamp": 1534806504477, + "version": "1.1.0" + }, + "scipy-1.1.0-py27he2b7bc3_1.tar.bz2": { + "build": "py27he2b7bc3_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5f46ccf2cde3c2f0798cfd5d8fa911af", + "name": "scipy", + "sha256": "6b35a5e381eaa2aae1b343edbe174b9eb55d2d2c153f453e73c1d39bf173d61b", + "size": 18762855, + "subdir": "linux-64", + "timestamp": 1536898885749, + "version": "1.1.0" + }, + "scipy-1.1.0-py27he2b7bc3_2.tar.bz2": { + "build": "py27he2b7bc3_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e29322ad3c2c856276327f7f7b5ea9e6", + "name": "scipy", + "sha256": "3f5d9a7af2b04164317ed89ead677114ced5f6002268f8d9202ba194928ccb60", + "size": 18517661, + "subdir": "linux-64", + "timestamp": 1544810775929, + "version": "1.1.0" + }, + "scipy-1.1.0-py27hfa4b5c9_1.tar.bz2": { + "build": "py27hfa4b5c9_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.15.1,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "06c39ca763759f3d74d44e8721d310ef", + "name": "scipy", + "sha256": "df4557e6c25913c65930d4c832941b5453648cd5ca023e5e547c20e4a4b73ba3", + "size": 18769977, + "subdir": "linux-64", + "timestamp": 1535416595082, + "version": "1.1.0" + }, + "scipy-1.1.0-py27hfc37229_0.tar.bz2": { + "build": "py27hfc37229_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "456c862e37cf2cf4c8f490ef92527f94", + "name": "scipy", + "sha256": "a731be153b7785605ba80809a0ab2dce28cc20460dcfb630d0aa173ed2e3acb8", + "size": 18821556, + "subdir": "linux-64", + "timestamp": 1525904280351, + "version": "1.1.0" + }, + "scipy-1.1.0-py35_nomklh9d22d0a_0.tar.bz2": { + "build": "py35_nomklh9d22d0a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "e75156d4a2587d232284737189b1d5e2", + "name": "scipy", + "sha256": "14071de18be60a15c98ac574b27befab0a06b3b386d32b905ad755c9d5b68a13", + "size": 18917095, + "subdir": "linux-64", + "timestamp": 1525904159535, + "version": "1.1.0" + }, + "scipy-1.1.0-py35h9b217d5_1.tar.bz2": { + "build": "py35h9b217d5_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.1,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fc057d3444fc99cb853d20f60bc5902e", + "name": "scipy", + "sha256": "38f6ea1b0ff12f63b73124d14b6c6a8d42ef6c428dc358e9d034a3e27be05a2f", + "size": 18872782, + "subdir": "linux-64", + "timestamp": 1535414960760, + "version": "1.1.0" + }, + "scipy-1.1.0-py35hd20e5f9_0.tar.bz2": { + "build": "py35hd20e5f9_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ec7e905dd551264d224d1a9a52d72db4", + "name": "scipy", + "sha256": "2c4b0c21ffb1f00de40ac7debcad4b498902d30f17e6aa7f2a6271a43442a024", + "size": 18892515, + "subdir": "linux-64", + "timestamp": 1534837742752, + "version": "1.1.0" + }, + "scipy-1.1.0-py35he2b7bc3_1.tar.bz2": { + "build": "py35he2b7bc3_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "99709c0c950399276e925d52635bfe8e", + "name": "scipy", + "sha256": "b4e7b82b6fd5f011f7e841d8b177fdee868bfbfc5c29969cc1890acfc0bb4fc5", + "size": 18876287, + "subdir": "linux-64", + "timestamp": 1536898891741, + "version": "1.1.0" + }, + "scipy-1.1.0-py35hfa4b5c9_1.tar.bz2": { + "build": "py35hfa4b5c9_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.15.1,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d4011a91543d3857e7231ee25ece8d77", + "name": "scipy", + "sha256": "f283fd6895b8b0b2706dc8de4ac4d68e0531c5f2cc8977bf20bc553197732cbc", + "size": 18875356, + "subdir": "linux-64", + "timestamp": 1535416611850, + "version": "1.1.0" + }, + "scipy-1.1.0-py35hfc37229_0.tar.bz2": { + "build": "py35hfc37229_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "7e974791d043eab7e5d1eb050c5b925f", + "name": "scipy", + "sha256": "dbff0bd79b160f40f3428e56124c31f7279ffcd4758a793797d23cc8a2904bd4", + "size": 18929780, + "subdir": "linux-64", + "timestamp": 1525905132618, + "version": "1.1.0" + }, + "scipy-1.1.0-py36_nomklh9c1e066_0.tar.bz2": { + "build": "py36_nomklh9c1e066_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "08bcb9e3cd5da79a7b59819a557f209e", + "name": "scipy", + "sha256": "ff9ede4e54dcdc4cb5eced134a77ec017054f08d6e163a983994eb09b8b530de", + "size": 18956582, + "subdir": "linux-64", + "timestamp": 1530779548309, + "version": "1.1.0" + }, + "scipy-1.1.0-py36_nomklh9d22d0a_0.tar.bz2": { + "build": "py36_nomklh9d22d0a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "1d41b7cd9c9f37daa59f9d508c9df447", + "name": "scipy", + "sha256": "45176ad00289ed981fdea1879380571dda35ccc95eebe6274854b9cbd94050ed", + "size": 18972125, + "subdir": "linux-64", + "timestamp": 1525904179926, + "version": "1.1.0" + }, + "scipy-1.1.0-py36h7c811a0_2.tar.bz2": { + "build": "py36h7c811a0_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fc65b047012bd5fc32178b55121863ab", + "name": "scipy", + "sha256": "8b4688d9a20be4bc4b297359d1285f32fb5bc6a99a4c2a1bb20c168d3832e578", + "size": 18585827, + "subdir": "linux-64", + "timestamp": 1544811268237, + "version": "1.1.0" + }, + "scipy-1.1.0-py36h9b217d5_1.tar.bz2": { + "build": "py36h9b217d5_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.1,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "783a6dcf3290a961ddaad674cdbd8f7d", + "name": "scipy", + "sha256": "3a52b1e115befd4504147febab01b8b812b3e066e9c35bd632ecc7a549f6c551", + "size": 18821505, + "subdir": "linux-64", + "timestamp": 1535416418378, + "version": "1.1.0" + }, + "scipy-1.1.0-py36hc49cb51_0.tar.bz2": { + "build": "py36hc49cb51_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "93ba84f3aa07ef5692031e523fa91539", + "name": "scipy", + "sha256": "b4c5eb128e6a427a896a1387592e60a52d8743e4003ef6401a6136f443b948c4", + "size": 18959127, + "subdir": "linux-64", + "timestamp": 1530778224000, + "version": "1.1.0" + }, + "scipy-1.1.0-py36hd20e5f9_0.tar.bz2": { + "build": "py36hd20e5f9_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8bc17d10d1dfb5b7427cdbbe1aa100c4", + "name": "scipy", + "sha256": "31f49575c164c76a21a45b3274e9d65b7d9d1c1ae62d6c0f51990507f68cb209", + "size": 18836019, + "subdir": "linux-64", + "timestamp": 1534846433876, + "version": "1.1.0" + }, + "scipy-1.1.0-py36he2b7bc3_1.tar.bz2": { + "build": "py36he2b7bc3_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4fffc581ea24e7f66fb9b1eff6b083e2", + "name": "scipy", + "sha256": "ae4eacc55151ea2eb797485d7d853ba9dbab8f538016cff070b9f7086f81f6c9", + "size": 18834993, + "subdir": "linux-64", + "timestamp": 1536898898743, + "version": "1.1.0" + }, + "scipy-1.1.0-py36he2b7bc3_2.tar.bz2": { + "build": "py36he2b7bc3_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "366c8d88ea8bfd24453a4bf9d9c9cc91", + "name": "scipy", + "sha256": "b66c43e3efb2c13b956a71e2d52dff3d79d45f462b94c80b4fb51e06de9d66bb", + "size": 18549695, + "subdir": "linux-64", + "timestamp": 1544810770288, + "version": "1.1.0" + }, + "scipy-1.1.0-py36hfa4b5c9_1.tar.bz2": { + "build": "py36hfa4b5c9_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.15.1,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8285f209fc7c1d81efd36cbec51263c3", + "name": "scipy", + "sha256": "3ddf207c8467e8424bfc07ea4c2d1da4c0b1320b3bf6907a9bf68687dc0a32cf", + "size": 18827074, + "subdir": "linux-64", + "timestamp": 1535416623744, + "version": "1.1.0" + }, + "scipy-1.1.0-py36hfc37229_0.tar.bz2": { + "build": "py36hfc37229_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "6847df85e348fa7453c3ca31c82c69d2", + "name": "scipy", + "sha256": "ea91492a6e900c47cb4f911e59940209d9f1bb532885f9a3edb8e1bacce961b6", + "size": 19012144, + "subdir": "linux-64", + "timestamp": 1525905155031, + "version": "1.1.0" + }, + "scipy-1.1.0-py37_nomklh9c1e066_0.tar.bz2": { + "build": "py37_nomklh9c1e066_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2128528420cc2abc34165a9b695bfeba", + "name": "scipy", + "sha256": "22f9032a6b9bfea0ed86956266cb9e66b15a0dc78baaff3f5508c7677b18979a", + "size": 18944602, + "subdir": "linux-64", + "timestamp": 1530774357854, + "version": "1.1.0" + }, + "scipy-1.1.0-py37h7c811a0_2.tar.bz2": { + "build": "py37h7c811a0_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "472a8443c319e373d8e88d734db81e23", + "name": "scipy", + "sha256": "9a0df9ef5560dcca9947440d980015bce31bbb121c44d5228b94dea6efe8cd04", + "size": 18447836, + "subdir": "linux-64", + "timestamp": 1544811210836, + "version": "1.1.0" + }, + "scipy-1.1.0-py37h9b217d5_1.tar.bz2": { + "build": "py37h9b217d5_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.1,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1d123f74beff3fa2f1653a95706c819a", + "name": "scipy", + "sha256": "7e1e3bf67242299b6b1bf77bbd8d0b0a7fcc2ac7383576a600ebc878afa649c1", + "size": 18814233, + "subdir": "linux-64", + "timestamp": 1535414924058, + "version": "1.1.0" + }, + "scipy-1.1.0-py37hc49cb51_0.tar.bz2": { + "build": "py37hc49cb51_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ca0953edc8e48dd4c8ba22ff7f5fec8c", + "name": "scipy", + "sha256": "cae2bbdf7a2b9e491f9fe40e0291a5593b942d62e24832c8b17c4bd7964a5730", + "size": 18951505, + "subdir": "linux-64", + "timestamp": 1530773056068, + "version": "1.1.0" + }, + "scipy-1.1.0-py37he2b7bc3_1.tar.bz2": { + "build": "py37he2b7bc3_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2c3d096384e56329eb92e7d95777e7d9", + "name": "scipy", + "sha256": "99ea7170650945d88d347b708771dcd07073e70a67bbf357bbc0fcb21e3675a0", + "size": 18817339, + "subdir": "linux-64", + "timestamp": 1536899089778, + "version": "1.1.0" + }, + "scipy-1.1.0-py37he2b7bc3_2.tar.bz2": { + "build": "py37he2b7bc3_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7133fa362404149fa07742d9928b7046", + "name": "scipy", + "sha256": "f6a1372ffa75f5dc232116e36399785d58855c68beb55257d94c3a2afad80405", + "size": 18450982, + "subdir": "linux-64", + "timestamp": 1544811127776, + "version": "1.1.0" + }, + "scipy-1.1.0-py37hfa4b5c9_1.tar.bz2": { + "build": "py37hfa4b5c9_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.15.1,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "24ed4bd83f7ef61c27c95d9139313b28", + "name": "scipy", + "sha256": "0395a6d51892989f0d8e0023cb025a854ae38ec40196122737612850afc32b53", + "size": 18820408, + "subdir": "linux-64", + "timestamp": 1535416612069, + "version": "1.1.0" + }, + "scipy-1.10.0-py310hd5efca6_0.tar.bz2": { + "build": "py310hd5efca6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<1.27.0", + "pooch", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4ce0493f844dd1bf7d10ac34e749b8ea", + "name": "scipy", + "sha256": "95a4a9e7f76bdc99bdbc12921175fdc9ab854763420190eed1988986b8bda10f", + "size": 28604966, + "subdir": "linux-64", + "timestamp": 1675465530503, + "version": "1.10.0" + }, + "scipy-1.10.0-py310hd5efca6_1.tar.bz2": { + "build": "py310hd5efca6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<1.27.0", + "pooch", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5673b5f6b4e86736e36d606a254353eb", + "name": "scipy", + "sha256": "8d5b16cf7905eb7c169509e6b88f6a7c75ff213ef8f366491f8fdafbac690c5f", + "size": 28623455, + "subdir": "linux-64", + "timestamp": 1677600249593, + "version": "1.10.0" + }, + "scipy-1.10.0-py310heeff2f4_0.tar.bz2": { + "build": "py310heeff2f4_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<1.27.0", + "pooch", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4152d501968e386409e39699886b26fe", + "name": "scipy", + "sha256": "2f269035924d19382151f896dbccd8c3cc84abe112370f8a6ff9c1bd011e3ca6", + "size": 28605163, + "subdir": "linux-64", + "timestamp": 1675461306731, + "version": "1.10.0" + }, + "scipy-1.10.0-py310heeff2f4_1.tar.bz2": { + "build": "py310heeff2f4_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<1.27.0", + "pooch", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5114ef69b07f6c518987f580ce533d48", + "name": "scipy", + "sha256": "77a7930c2573548d7dc2cbdb9b2ce8cb599a45769e1bc225531925b4565545f1", + "size": 28624969, + "subdir": "linux-64", + "timestamp": 1677603924913, + "version": "1.10.0" + }, + "scipy-1.10.0-py311h75bd12f_0.tar.bz2": { + "build": "py311h75bd12f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.23,<1.27.0", + "pooch", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e3af409c443864b87dd45ffb0650b10", + "name": "scipy", + "sha256": "d35e83290ff3ce0bff9aa97179286fdf17a6b5c95c29cc46fc3939de457ed8cf", + "size": 30077485, + "subdir": "linux-64", + "timestamp": 1676905140821, + "version": "1.10.0" + }, + "scipy-1.10.0-py311h75bd12f_1.tar.bz2": { + "build": "py311h75bd12f_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.23,<1.27.0", + "pooch", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0547063b1b538207498ea2d6d9a6350c", + "name": "scipy", + "sha256": "b7287f8f77b1bef7d7e1e22c89f6ea33d5f5f83d6842be3f3a7658d444c75035", + "size": 30171443, + "subdir": "linux-64", + "timestamp": 1679339029875, + "version": "1.10.0" + }, + "scipy-1.10.0-py311hefedb09_0.tar.bz2": { + "build": "py311hefedb09_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23,<1.27.0", + "pooch", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a954ba6bc08ad5320db4d3d660ed031e", + "name": "scipy", + "sha256": "4fb8ce6fd7349fd668bd9763edda3feb961747f75f029da144e0d7b92aa63b1e", + "size": 30083163, + "subdir": "linux-64", + "timestamp": 1676905818814, + "version": "1.10.0" + }, + "scipy-1.10.0-py311hefedb09_1.tar.bz2": { + "build": "py311hefedb09_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23,<1.27.0", + "pooch", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ec309c6d31dadab9bf0e025614307a0b", + "name": "scipy", + "sha256": "7476a28e7b13cb9b20c0c2720f6ea6a92c88e134e82ea0ac0c57b3ec6059e3a2", + "size": 30170511, + "subdir": "linux-64", + "timestamp": 1679338330804, + "version": "1.10.0" + }, + "scipy-1.10.0-py38h14f4228_0.tar.bz2": { + "build": "py38h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "035df50ac89e1390554615a5102ccd78", + "name": "scipy", + "sha256": "3d9c34e5e69287657bdae08976ad31cc783a952c9a5fa791735900edba716056", + "size": 26933855, + "subdir": "linux-64", + "timestamp": 1675466982008, + "version": "1.10.0" + }, + "scipy-1.10.0-py38h14f4228_1.tar.bz2": { + "build": "py38h14f4228_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2cb42dddd16c790ef495a152867c3462", + "name": "scipy", + "sha256": "fcbd681a47619f7193c56373ab205bf1ad0bba46c718fa52e79680920e82f433", + "size": 26738452, + "subdir": "linux-64", + "timestamp": 1677599029212, + "version": "1.10.0" + }, + "scipy-1.10.0-py38h32ae08f_0.tar.bz2": { + "build": "py38h32ae08f_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "72b153a1d4f5c411e28205eb85078157", + "name": "scipy", + "sha256": "c266f30353430eb3648f9b9ebb6095d12211a858beb708d09adec9c2109666c6", + "size": 26934992, + "subdir": "linux-64", + "timestamp": 1675462721512, + "version": "1.10.0" + }, + "scipy-1.10.0-py38h32ae08f_1.tar.bz2": { + "build": "py38h32ae08f_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "69a58dfc7ae16495ccbe520de6864b87", + "name": "scipy", + "sha256": "b5010a878a446bdf90780029c0013f1e38b90035059487190548dc5d46c756fd", + "size": 26738693, + "subdir": "linux-64", + "timestamp": 1677602706081, + "version": "1.10.0" + }, + "scipy-1.10.0-py39h14f4228_0.tar.bz2": { + "build": "py39h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d205d7ab1a5006008458918d8b92a11f", + "name": "scipy", + "sha256": "c59a823a709b1ce588ebd8808779ba4ef4bd0f03de69bfeca6e91babc3554465", + "size": 27575547, + "subdir": "linux-64", + "timestamp": 1675464138267, + "version": "1.10.0" + }, + "scipy-1.10.0-py39h14f4228_1.tar.bz2": { + "build": "py39h14f4228_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "765905aa1ecf3ecc62fd5fcb0cf40b2b", + "name": "scipy", + "sha256": "2eebf788c30d99f18665e1cecd92089e1ad1719e65c9759ac68b25bdb1db4bc2", + "size": 27608443, + "subdir": "linux-64", + "timestamp": 1677597800149, + "version": "1.10.0" + }, + "scipy-1.10.0-py39h32ae08f_0.tar.bz2": { + "build": "py39h32ae08f_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "24920304531078d96320e08b2995965f", + "name": "scipy", + "sha256": "57cef4bf337354bc60f66f736662690110b108bac920c9559be18fc680767754", + "size": 27576220, + "subdir": "linux-64", + "timestamp": 1675459897666, + "version": "1.10.0" + }, + "scipy-1.10.0-py39h32ae08f_1.tar.bz2": { + "build": "py39h32ae08f_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5a3cede80f4bcd5e90f871c97bf970e4", + "name": "scipy", + "sha256": "19a27434a89e2df9116b9fc092d85b59df605747231921dde1b4dbafcb5af32a", + "size": 27611434, + "subdir": "linux-64", + "timestamp": 1677601482008, + "version": "1.10.0" + }, + "scipy-1.10.1-py310hd5efca6_0.tar.bz2": { + "build": "py310hd5efca6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<1.27.0", + "pooch", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1504a1fa8b4b15b892efbc8ba6ab36ca", + "name": "scipy", + "sha256": "ab4850fa666f59b5b1a7062c6b4b5b2447fb6c0662493b6ee0eceb6fe992e1e1", + "size": 28668929, + "subdir": "linux-64", + "timestamp": 1680710349594, + "version": "1.10.1" + }, + "scipy-1.10.1-py310heeff2f4_0.tar.bz2": { + "build": "py310heeff2f4_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<1.27.0", + "pooch", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "76f8769962b26078f39a8acd3ed8cbcc", + "name": "scipy", + "sha256": "fbb597064ddc304755270b72ffb677705f76dd856753021d3549e83638cfab29", + "size": 28667747, + "subdir": "linux-64", + "timestamp": 1680704370237, + "version": "1.10.1" + }, + "scipy-1.10.1-py311h24aa872_0.tar.bz2": { + "build": "py311h24aa872_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23,<1.27.0", + "pooch", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee6777ef5763e2bb196a25812fb059f8", + "name": "scipy", + "sha256": "c1cdc3e56c21a8b8a645bcb3a35c5598e304017c07159a39694afff559b4de4e", + "size": 30125932, + "subdir": "linux-64", + "timestamp": 1680703116708, + "version": "1.10.1" + }, + "scipy-1.10.1-py311hc206e33_0.tar.bz2": { + "build": "py311hc206e33_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.23,<1.27.0", + "pooch", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4dcb138539613a8836986362b6649bc2", + "name": "scipy", + "sha256": "c69446602ff54914a7e4f132f34b8d2a0fb4579a76cf5d312bb766e1ee95100c", + "size": 30130289, + "subdir": "linux-64", + "timestamp": 1680708837315, + "version": "1.10.1" + }, + "scipy-1.10.1-py38h14f4228_0.tar.bz2": { + "build": "py38h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4785e728a367ee5ff00f70bbf260f8dd", + "name": "scipy", + "sha256": "3539f225a86b450755e4e7d1ccd2d0137aa71f4036b5a704152a39b960e8f856", + "size": 26898604, + "subdir": "linux-64", + "timestamp": 1680713186408, + "version": "1.10.1" + }, + "scipy-1.10.1-py38h32ae08f_0.tar.bz2": { + "build": "py38h32ae08f_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7c36c15eac0f0e2d30b1c138f5735324", + "name": "scipy", + "sha256": "6fcfa55fc1c07e70990347c0f3023cecbdb2391d8890a424ae89937ebe853ef2", + "size": 26897460, + "subdir": "linux-64", + "timestamp": 1680707158867, + "version": "1.10.1" + }, + "scipy-1.10.1-py39h14f4228_0.tar.bz2": { + "build": "py39h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6717a265581a827f0518bc961194fa37", + "name": "scipy", + "sha256": "8c71d1eaa915fe55747d2bcabd2ad49dcc21ddd75f2ef6307cfd7063a75b35d5", + "size": 27654159, + "subdir": "linux-64", + "timestamp": 1680711776977, + "version": "1.10.1" + }, + "scipy-1.10.1-py39h32ae08f_0.tar.bz2": { + "build": "py39h32ae08f_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "87756cc5e245db62bf82d9addf6d9b44", + "name": "scipy", + "sha256": "53f285777a1dcfa79b2ca1c01073d1802fd3f9d0310ba5fb9ea40be31c6685e8", + "size": 27651436, + "subdir": "linux-64", + "timestamp": 1680705712214, + "version": "1.10.1" + }, + "scipy-1.2.0-py27h7c811a0_0.tar.bz2": { + "build": "py27h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "075e4edf0ba17ea593a9d2c54129f119", + "name": "scipy", + "sha256": "831c269b4505c1334873fb0751c8fe1c02d5d2da37872ef2cf29ae93a854e309", + "size": 18496032, + "subdir": "linux-64", + "timestamp": 1547757181526, + "version": "1.2.0" + }, + "scipy-1.2.0-py27he2b7bc3_0.tar.bz2": { + "build": "py27he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d2876d37e63dd6f5d5b62fb2bf3e7351", + "name": "scipy", + "sha256": "48647fdbd48acda45568529c47869433f069d3f4785017e0af77cfc63a037a6f", + "size": 18471146, + "subdir": "linux-64", + "timestamp": 1547757138532, + "version": "1.2.0" + }, + "scipy-1.2.0-py36h7c811a0_0.tar.bz2": { + "build": "py36h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "56045f403ee5e305b75a8b6f7b788cce", + "name": "scipy", + "sha256": "7ccb47cde47e764710266a9417a00f99dddebc9a6a163ea00b2467168a40e11e", + "size": 18615497, + "subdir": "linux-64", + "timestamp": 1547755997992, + "version": "1.2.0" + }, + "scipy-1.2.0-py36he2b7bc3_0.tar.bz2": { + "build": "py36he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4d337274a9d697750244c3fce5221978", + "name": "scipy", + "sha256": "e336c0e57f0eec8c600c359da3fe699f3883888fdd8b3a695ea171f5467424fc", + "size": 18520839, + "subdir": "linux-64", + "timestamp": 1548258660720, + "version": "1.2.0" + }, + "scipy-1.2.0-py37h7c811a0_0.tar.bz2": { + "build": "py37h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2cad57649a5e426d1b73e04c37b290f3", + "name": "scipy", + "sha256": "d26bc35ca91da54f8a319553ac021f38cb49583f03f9c05f3e215b36fdb93ebe", + "size": 18528698, + "subdir": "linux-64", + "timestamp": 1547756281558, + "version": "1.2.0" + }, + "scipy-1.2.0-py37he2b7bc3_0.tar.bz2": { + "build": "py37he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "db6a69eff164569a2507821d7cddd751", + "name": "scipy", + "sha256": "aca167ea645ff9edb17e3625ef2db03484ba642014e15f4aacc9cf67c480f3d0", + "size": 18561163, + "subdir": "linux-64", + "timestamp": 1547757119071, + "version": "1.2.0" + }, + "scipy-1.2.1-py27h7c811a0_0.tar.bz2": { + "build": "py27h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9c0f44fa2f5856513c022bd63737682d", + "name": "scipy", + "sha256": "502669bb7358aebb3864eb0838e02360f3942d106a36fb901cb01620608c4f3e", + "size": 18492784, + "subdir": "linux-64", + "timestamp": 1550683921676, + "version": "1.2.1" + }, + "scipy-1.2.1-py27he2b7bc3_0.tar.bz2": { + "build": "py27he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c07c8febfecbafad4a8e0fa2333191c2", + "name": "scipy", + "sha256": "611418724a5b10b45305e600884a92336b56a956acc7389e65028241396ead99", + "size": 18507374, + "subdir": "linux-64", + "timestamp": 1550683333767, + "version": "1.2.1" + }, + "scipy-1.2.1-py36h7c811a0_0.tar.bz2": { + "build": "py36h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "426eb5ded1b3c5656227103f0e02788f", + "name": "scipy", + "sha256": "f1dea8052163f5c8fbb61a43253c6289250529732ec43565af599755f212ac76", + "size": 18589348, + "subdir": "linux-64", + "timestamp": 1550683926183, + "version": "1.2.1" + }, + "scipy-1.2.1-py36he2b7bc3_0.tar.bz2": { + "build": "py36he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "71aa3fbb0e7569a741c2fe845df0849d", + "name": "scipy", + "sha256": "29e28cface7c6fa4574b44975f99508813489100385d45993062a56bdff217e3", + "size": 18609948, + "subdir": "linux-64", + "timestamp": 1550683761187, + "version": "1.2.1" + }, + "scipy-1.2.1-py37h7c811a0_0.tar.bz2": { + "build": "py37h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a17a4ff76d69cbf38c6f9c49d86fa688", + "name": "scipy", + "sha256": "f22c80d49499d860f5046ed534afbb526c6fe90097b1c24b72b0c1dc1d694fcc", + "size": 18570463, + "subdir": "linux-64", + "timestamp": 1550688446386, + "version": "1.2.1" + }, + "scipy-1.2.1-py37he2b7bc3_0.tar.bz2": { + "build": "py37he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b6f730e18f0c2147a626b642d9dc6fe9", + "name": "scipy", + "sha256": "c244b7189d6e5495db0b0f296c97d64e5dea8556ed1ccb8030d0273ef2d9d998", + "size": 18569889, + "subdir": "linux-64", + "timestamp": 1550686564363, + "version": "1.2.1" + }, + "scipy-1.3.0-py36h7c811a0_0.tar.bz2": { + "build": "py36h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9563de2d0b64813901e7f5db53d24512", + "name": "scipy", + "sha256": "075916d9df1f9741a6394686312ed18c00500916f31dc54f0e749acfebaf4903", + "size": 18964735, + "subdir": "linux-64", + "timestamp": 1563477150845, + "version": "1.3.0" + }, + "scipy-1.3.0-py36he2b7bc3_0.tar.bz2": { + "build": "py36he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3f0e85c3b2d8754462e9c9ab505672e1", + "name": "scipy", + "sha256": "05584576fc8c79ab2ac955ea1d7ee2682c1476979b45e6c509a4f5e4d53b092f", + "size": 18939425, + "subdir": "linux-64", + "timestamp": 1563476867388, + "version": "1.3.0" + }, + "scipy-1.3.0-py37h7c811a0_0.tar.bz2": { + "build": "py37h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d719edea6bf799f003fddd60254526ec", + "name": "scipy", + "sha256": "a319cd80f69d5790b07a2a06f1cf58b2912ab79c3da3e20ecde8014c40673fa5", + "size": 18901610, + "subdir": "linux-64", + "timestamp": 1563476829236, + "version": "1.3.0" + }, + "scipy-1.3.0-py37he2b7bc3_0.tar.bz2": { + "build": "py37he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0c0179b4221e4ac3a5955c1daf368884", + "name": "scipy", + "sha256": "a6446a2bf21207daf856875b42a3b99b752495f4ccc0d2ba1d18835186dae517", + "size": 18998394, + "subdir": "linux-64", + "timestamp": 1563476855151, + "version": "1.3.0" + }, + "scipy-1.3.1-py36h7c811a0_0.tar.bz2": { + "build": "py36h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "11f5aac973f135fd764d02e9a35bc697", + "name": "scipy", + "sha256": "b6a87bd4c382ede509d30da780f5dd19eb73b5127fe2e7d4c001f14cbba9a2a7", + "size": 18960366, + "subdir": "linux-64", + "timestamp": 1565900320909, + "version": "1.3.1" + }, + "scipy-1.3.1-py36he2b7bc3_0.tar.bz2": { + "build": "py36he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "896f323736c7c1c4fee811c82f8aab19", + "name": "scipy", + "sha256": "3a0af6cfc579968d17945885175411f1d69a902f27ba96216b67105cae243b1b", + "size": 18929907, + "subdir": "linux-64", + "timestamp": 1565900339586, + "version": "1.3.1" + }, + "scipy-1.3.1-py37h7c811a0_0.tar.bz2": { + "build": "py37h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "be66d5dba291637998236a022f037d11", + "name": "scipy", + "sha256": "a3e4a81588ce418aeb378c52eaee507b548604e7ec7b026228b016d54b8d904b", + "size": 18974821, + "subdir": "linux-64", + "timestamp": 1565900737884, + "version": "1.3.1" + }, + "scipy-1.3.1-py37he2b7bc3_0.tar.bz2": { + "build": "py37he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cddc2a893258a2261e6cc644650983f8", + "name": "scipy", + "sha256": "f8640db61ef1b5c840f86bd1605ecfd58bbbf1ffb8367573ee4d91ab359f99d9", + "size": 18901472, + "subdir": "linux-64", + "timestamp": 1565900332909, + "version": "1.3.1" + }, + "scipy-1.3.1-py38h7c811a0_0.tar.bz2": { + "build": "py38h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "647895c129cbbfb3c979c2d89b1904e7", + "name": "scipy", + "sha256": "2787a141b1b962cae3f580d492e7ab38d359f795674346ee6fa5d4dc3712ca42", + "size": 18997806, + "subdir": "linux-64", + "timestamp": 1573555909468, + "version": "1.3.1" + }, + "scipy-1.3.1-py38he2b7bc3_0.tar.bz2": { + "build": "py38he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9d2ad610d7d2e13523b91039f6d1449d", + "name": "scipy", + "sha256": "c485c7e170e7a88954c8653b9e0b1630ed56305d7e2a8baf86d3be4060fa9461", + "size": 19030704, + "subdir": "linux-64", + "timestamp": 1573557040546, + "version": "1.3.1" + }, + "scipy-1.3.2-py36h7c811a0_0.tar.bz2": { + "build": "py36h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b2d1338a9d7be99638a4e4b92a5c5bb2", + "name": "scipy", + "sha256": "6992b12e4231bf1ee471db4c609c31ab12520ee9480bf8749811791c76d830ca", + "size": 18958269, + "subdir": "linux-64", + "timestamp": 1575911689942, + "version": "1.3.2" + }, + "scipy-1.3.2-py36he2b7bc3_0.tar.bz2": { + "build": "py36he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "21308ce2728f8df161ea698ef4f95737", + "name": "scipy", + "sha256": "b50d9ca18e252d867ee5b2b02c96ada0bac6a5c7e3b8aec3e3f1a73a00058d3e", + "size": 19023140, + "subdir": "linux-64", + "timestamp": 1575911688276, + "version": "1.3.2" + }, + "scipy-1.3.2-py37h7c811a0_0.tar.bz2": { + "build": "py37h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "958f7e2b00997866185fb83a777d5f3a", + "name": "scipy", + "sha256": "ce6098eb3b8dad606e3cb80405389e9a38ba7bc081c60e6ded4889a7689934ea", + "size": 18988913, + "subdir": "linux-64", + "timestamp": 1575911684031, + "version": "1.3.2" + }, + "scipy-1.3.2-py37he2b7bc3_0.tar.bz2": { + "build": "py37he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "95032172673cbecdd748b16d317cca1a", + "name": "scipy", + "sha256": "a7ffbeebf193a237c7563e0ab2cf14e1b12315ebaed550ae3e83e6c56aa6da95", + "size": 18953071, + "subdir": "linux-64", + "timestamp": 1575911668813, + "version": "1.3.2" + }, + "scipy-1.3.2-py38h7c811a0_0.tar.bz2": { + "build": "py38h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ca0f5aba2aa24dd8e06174dae55c5763", + "name": "scipy", + "sha256": "5a01f95b60ba3a7b6babd589d08aed300692e5d46f6434e38e94019c1cd47f46", + "size": 19114256, + "subdir": "linux-64", + "timestamp": 1575915578443, + "version": "1.3.2" + }, + "scipy-1.3.2-py38he2b7bc3_0.tar.bz2": { + "build": "py38he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f3a66ebf23052f56e501ffd60b84ec17", + "name": "scipy", + "sha256": "e58b0d06130c75bbb927eea2c3f23c0d5d8630cb0467a09884652f169547885f", + "size": 18995335, + "subdir": "linux-64", + "timestamp": 1575915152031, + "version": "1.3.2" + }, + "scipy-1.4.1-py36h0b6359f_0.tar.bz2": { + "build": "py36h0b6359f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8097db5aed4075fc6be81d82c2af4954", + "name": "scipy", + "sha256": "5835b3e72e902d5a0efaabe68028ef4d14fb571cc3ce070d32f597823a316b63", + "size": 19813654, + "subdir": "linux-64", + "timestamp": 1580841337662, + "version": "1.4.1" + }, + "scipy-1.4.1-py36habc2bb6_0.tar.bz2": { + "build": "py36habc2bb6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "440f7278cea01a2f87e7d05affcb9d81", + "name": "scipy", + "sha256": "04c2e045d96853d5f54f830979af0c85238e2140a1d06989b71d890c548aeae5", + "size": 19737475, + "subdir": "linux-64", + "timestamp": 1580841718015, + "version": "1.4.1" + }, + "scipy-1.4.1-py37h0b6359f_0.tar.bz2": { + "build": "py37h0b6359f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f45a946f2e9059c883c911e16799f5c5", + "name": "scipy", + "sha256": "55d13d5b530e30dd0d0f6f7e3e8f7320892339b648d106cbd9b85e1a5d06ad6f", + "size": 19804326, + "subdir": "linux-64", + "timestamp": 1580841730240, + "version": "1.4.1" + }, + "scipy-1.4.1-py37habc2bb6_0.tar.bz2": { + "build": "py37habc2bb6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "30b36434609a567cd00f4e78ff303217", + "name": "scipy", + "sha256": "dd761025f0f91c9eea96bd2843e3446cdeb1ee81a7fc005be17c2268d85814d1", + "size": 19778389, + "subdir": "linux-64", + "timestamp": 1580841334620, + "version": "1.4.1" + }, + "scipy-1.4.1-py38h0b6359f_0.tar.bz2": { + "build": "py38h0b6359f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "963659977f7e31034ac041d1abb88350", + "name": "scipy", + "sha256": "2c6e69605e934288c6c88f7ecd606b72f76c6225f2cb70d78209ecb834c7e03c", + "size": 20060149, + "subdir": "linux-64", + "timestamp": 1580841357296, + "version": "1.4.1" + }, + "scipy-1.4.1-py38habc2bb6_0.tar.bz2": { + "build": "py38habc2bb6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c4074a58f756f186c5759d3cb2417b79", + "name": "scipy", + "sha256": "2d86e009747bc7cc7485351a971c977626ff5b840373c69e91f0a61eb0476968", + "size": 20005733, + "subdir": "linux-64", + "timestamp": 1580841334279, + "version": "1.4.1" + }, + "scipy-1.5.0-py36h0b6359f_0.tar.bz2": { + "build": "py36h0b6359f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f1e969d2aa4ac2f369833b6c92f7e97d", + "name": "scipy", + "sha256": "be2bb2ff22882d40ead353855bdc6dbc925ff6000d83a08a51a80b0eeeda06bf", + "size": 19483544, + "subdir": "linux-64", + "timestamp": 1592931440731, + "version": "1.5.0" + }, + "scipy-1.5.0-py36habc2bb6_0.tar.bz2": { + "build": "py36habc2bb6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e8e1ace4289e0e1e46d526de37cf2262", + "name": "scipy", + "sha256": "3455f4a9f5c101c9aa3e0e3fdc5e1a9af586000f7559991b6c7ad03517bb08ec", + "size": 19401774, + "subdir": "linux-64", + "timestamp": 1592931401557, + "version": "1.5.0" + }, + "scipy-1.5.0-py37h0b6359f_0.tar.bz2": { + "build": "py37h0b6359f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "51e4455de2bbd023b4fb6669c30bdf65", + "name": "scipy", + "sha256": "3fba399604e63748735490bd6977f15ce2ce05471a361468e13ad8df3a95adc5", + "size": 19421680, + "subdir": "linux-64", + "timestamp": 1592931396034, + "version": "1.5.0" + }, + "scipy-1.5.0-py37habc2bb6_0.tar.bz2": { + "build": "py37habc2bb6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "66c986c6359ecd5ac7f8cf9634f7483b", + "name": "scipy", + "sha256": "b4c76677dc8e0f28589968dc8e68f63a763effe7d6361eb23d646b9fceaa57fe", + "size": 19383118, + "subdir": "linux-64", + "timestamp": 1592931394056, + "version": "1.5.0" + }, + "scipy-1.5.0-py38h0b6359f_0.tar.bz2": { + "build": "py38h0b6359f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fd2b355a437b0c927d92f736c4627f50", + "name": "scipy", + "sha256": "86b9019b9449b2db769641ef2c5bfbc4ee748511b62a9d8fd94ffcd4659dc373", + "size": 19611509, + "subdir": "linux-64", + "timestamp": 1592931398288, + "version": "1.5.0" + }, + "scipy-1.5.0-py38habc2bb6_0.tar.bz2": { + "build": "py38habc2bb6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "40968cfb5395f495f0e696953c2d0135", + "name": "scipy", + "sha256": "2422e9ea72ca9094386e85f0b986f001387a19ea4f67c53d6da9b0198984cafe", + "size": 19636445, + "subdir": "linux-64", + "timestamp": 1592931391464, + "version": "1.5.0" + }, + "scipy-1.5.2-py36h0b6359f_0.tar.bz2": { + "build": "py36h0b6359f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "348ac748b9ac48ff98ab66252d3e9190", + "name": "scipy", + "sha256": "3a6c28a89330ac1fb4285533f2f36544e02ced4f4dc9a1610926a10a753f0bbb", + "size": 19409524, + "subdir": "linux-64", + "timestamp": 1597687692176, + "version": "1.5.2" + }, + "scipy-1.5.2-py36habc2bb6_0.tar.bz2": { + "build": "py36habc2bb6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6eaaed5359f998acd58b07ad78ea3937", + "name": "scipy", + "sha256": "62d26160bdbd243c01e8d52a701f988514abe2bc3d3c89b2edf290fd4cefe0f9", + "size": 19424297, + "subdir": "linux-64", + "timestamp": 1597687522153, + "version": "1.5.2" + }, + "scipy-1.5.2-py37h0b6359f_0.tar.bz2": { + "build": "py37h0b6359f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "82fe67e7c5edcd4ef23f8fd2166fe82d", + "name": "scipy", + "sha256": "d7fb5314e577dc2819e08009adbe22d4bca552ec803c3095265ddfd8795ccdbe", + "size": 19377905, + "subdir": "linux-64", + "timestamp": 1597687691036, + "version": "1.5.2" + }, + "scipy-1.5.2-py37habc2bb6_0.tar.bz2": { + "build": "py37habc2bb6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1ca5d75a395925a9ec511bbdc6466aed", + "name": "scipy", + "sha256": "d6d28560249a08a7fe93a378c48d7e76cd0e5b5ecc32fe96a92c587c272329f1", + "size": 19357660, + "subdir": "linux-64", + "timestamp": 1597687530575, + "version": "1.5.2" + }, + "scipy-1.5.2-py38h0b6359f_0.tar.bz2": { + "build": "py38h0b6359f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9af48d8e43be2dbd97af317622b9d6a5", + "name": "scipy", + "sha256": "3e9f47c52ac1736f48a55da394ee6e4782922466e834f424b7821bf002fe3788", + "size": 19636672, + "subdir": "linux-64", + "timestamp": 1597687522148, + "version": "1.5.2" + }, + "scipy-1.5.2-py38habc2bb6_0.tar.bz2": { + "build": "py38habc2bb6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0cf343bf781268d9c15e1bb94dec7446", + "name": "scipy", + "sha256": "0ff0f553db64c3ebdb1d3b4474d47b55c9ba8092d7450b1b623297431af0d6da", + "size": 19637760, + "subdir": "linux-64", + "timestamp": 1597687517445, + "version": "1.5.2" + }, + "scipy-1.5.2-py39h91f5cce_0.tar.bz2": { + "build": "py39h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7a738e8149d29e124eac7536ecb46acd", + "name": "scipy", + "sha256": "2ef41f525a68de31e85a4aa78ca9f298cfe984dc17dadd7238d8591d250ce869", + "size": 19848060, + "subdir": "linux-64", + "timestamp": 1607617852399, + "version": "1.5.2" + }, + "scipy-1.5.2-py39hf56f3a7_0.tar.bz2": { + "build": "py39hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0decbab5315017f96bff973cf5ba49fb", + "name": "scipy", + "sha256": "63197738ef1de6af1d9e298bd24cfd49ef2d9762ff0a638f075fe267743e463a", + "size": 19836881, + "subdir": "linux-64", + "timestamp": 1607617812978, + "version": "1.5.2" + }, + "scipy-1.6.0-py37h91f5cce_0.tar.bz2": { + "build": "py37h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7d269be6e852c2dc37823628de17e521", + "name": "scipy", + "sha256": "b7680b5911a8a905bff7de4f05c05e7ce8a8dd04fe579c10a5fb0d50b08627fd", + "size": 20826980, + "subdir": "linux-64", + "timestamp": 1612470255644, + "version": "1.6.0" + }, + "scipy-1.6.0-py37hf56f3a7_0.tar.bz2": { + "build": "py37hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "20fbdea8c4a694000154b55a4d85ebb6", + "name": "scipy", + "sha256": "5723f7f50a49a786c3c8fcd0abc530846c1c7a296c83f0f0c21105765165d2c3", + "size": 20845470, + "subdir": "linux-64", + "timestamp": 1612470239301, + "version": "1.6.0" + }, + "scipy-1.6.0-py38h91f5cce_0.tar.bz2": { + "build": "py38h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fb6459da931308e1ac9ca556c448a361", + "name": "scipy", + "sha256": "998253e4f995b434d76f0141ca2cacaded7498be3f037332f590e0a07d421fa4", + "size": 21075586, + "subdir": "linux-64", + "timestamp": 1612470249448, + "version": "1.6.0" + }, + "scipy-1.6.0-py38hf56f3a7_0.tar.bz2": { + "build": "py38hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5b0466fb5598bff0696aa37247ff56a1", + "name": "scipy", + "sha256": "f58763b38c79277b983e52e6d9ebfa3b88012bd7e7142880336dd4be89f9e825", + "size": 21061704, + "subdir": "linux-64", + "timestamp": 1612470105252, + "version": "1.6.0" + }, + "scipy-1.6.0-py39h91f5cce_0.tar.bz2": { + "build": "py39h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0e4114dbff6fc107b0d04e12114c66df", + "name": "scipy", + "sha256": "9dafd36188e52a1e5c93aa03fe18713f5c79220d42f394090ee7d5e2b29ad61a", + "size": 21524360, + "subdir": "linux-64", + "timestamp": 1612469676204, + "version": "1.6.0" + }, + "scipy-1.6.0-py39hf56f3a7_0.tar.bz2": { + "build": "py39hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "072f3cfad04584ec02e214e81877244b", + "name": "scipy", + "sha256": "86381ed9f5edef27fcbf9b0bebb77bdf477b2cf1cf8e415f769c2158faf4b1f2", + "size": 21493114, + "subdir": "linux-64", + "timestamp": 1612470238887, + "version": "1.6.0" + }, + "scipy-1.6.1-py37h91f5cce_0.tar.bz2": { + "build": "py37h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1a36d6f0b38e9e9f62032b24596ff51f", + "name": "scipy", + "sha256": "4ce3a896dfd6fd3b46ce28e39ed240ddcd7dbe910f8361addb8b1a8850d3d224", + "size": 20844256, + "subdir": "linux-64", + "timestamp": 1614023481445, + "version": "1.6.1" + }, + "scipy-1.6.1-py37hf56f3a7_0.tar.bz2": { + "build": "py37hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "78cfdf5e12cb6f8eb8dc4e73aa764752", + "name": "scipy", + "sha256": "30c5de46cd68fdee38eb9bb68972f872ed205fe9774723b763ee6bdc5404bad2", + "size": 20857090, + "subdir": "linux-64", + "timestamp": 1614022582963, + "version": "1.6.1" + }, + "scipy-1.6.1-py38h91f5cce_0.tar.bz2": { + "build": "py38h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e00d9ed3cf1534527664beffec468de2", + "name": "scipy", + "sha256": "d01a94fafd8c4f12613fb9c5ae074be3a313bbaf72e8d2256c8582add66ff5a1", + "size": 21053254, + "subdir": "linux-64", + "timestamp": 1614023385675, + "version": "1.6.1" + }, + "scipy-1.6.1-py38hf56f3a7_0.tar.bz2": { + "build": "py38hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "33cb4b346db30a8159b6f682697c577b", + "name": "scipy", + "sha256": "e87598a5238b1ca6ace6493c338fb8ed67df391f40340d3ab1a232576b463b96", + "size": 21107975, + "subdir": "linux-64", + "timestamp": 1614022572299, + "version": "1.6.1" + }, + "scipy-1.6.1-py39h91f5cce_0.tar.bz2": { + "build": "py39h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "68ff671dd094222ffecbbb2e9b5ed72b", + "name": "scipy", + "sha256": "cbab272e98f1d8130f8dbf620936b6f297b1108e359757f1f6679f7eafd8b0c4", + "size": 21508063, + "subdir": "linux-64", + "timestamp": 1614029302594, + "version": "1.6.1" + }, + "scipy-1.6.1-py39hf56f3a7_0.tar.bz2": { + "build": "py39hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9a237ca2ec62ec46c2f58704a7ed0912", + "name": "scipy", + "sha256": "a25d342f9fc3dc766e1809cb573ab0d08126611c7193072200e6871e1d2456f0", + "size": 21545008, + "subdir": "linux-64", + "timestamp": 1614023456391, + "version": "1.6.1" + }, + "scipy-1.6.2-py37h91f5cce_0.tar.bz2": { + "build": "py37h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0675eb32513a6c1a505227fa97e88d56", + "name": "scipy", + "sha256": "3686f0262c0860f35078c358bbd08f68d56d9d2c66312fd288b6741e79c50048", + "size": 20855414, + "subdir": "linux-64", + "timestamp": 1616701667008, + "version": "1.6.2" + }, + "scipy-1.6.2-py37had2a1c9_1.tar.bz2": { + "build": "py37had2a1c9_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7430873d98875e6cb2c3d2fd9816df76", + "name": "scipy", + "sha256": "1c225ddbf1433d00652c3c7a4f4f99b8d7076ad6e23f3ee917d82f9509224a88", + "size": 20852137, + "subdir": "linux-64", + "timestamp": 1618853339446, + "version": "1.6.2" + }, + "scipy-1.6.2-py37hf56f3a7_0.tar.bz2": { + "build": "py37hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "31fb507872c97e23839035d8994b3446", + "name": "scipy", + "sha256": "a7e73c335dc6c00769b5c26b97ac954aa43fb924c01bebb16e9d4d2ba3211754", + "size": 20831998, + "subdir": "linux-64", + "timestamp": 1616703856349, + "version": "1.6.2" + }, + "scipy-1.6.2-py37hf56f3a7_1.tar.bz2": { + "build": "py37hf56f3a7_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2a83f3aa5aaae4d073871c3ee192f847", + "name": "scipy", + "sha256": "2b0e07048b3c0f8f3b09520948e7d94fe30fc102c52654b7f6dda635d0fc9889", + "size": 20850273, + "subdir": "linux-64", + "timestamp": 1618856628572, + "version": "1.6.2" + }, + "scipy-1.6.2-py38h91f5cce_0.tar.bz2": { + "build": "py38h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "637e16cf3fcc8e2af354b432b45bac51", + "name": "scipy", + "sha256": "973259961a805bc8363f4f86cc22b0c3a77de0bd77086c39d14f8fadc5477833", + "size": 21093826, + "subdir": "linux-64", + "timestamp": 1616703866142, + "version": "1.6.2" + }, + "scipy-1.6.2-py38had2a1c9_1.tar.bz2": { + "build": "py38had2a1c9_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c2b98d3f055c38b93d740402f29347d5", + "name": "scipy", + "sha256": "e601bf7ba1fe39b9e2faab62f0fb9b637ca6aeddc2ed70e7ec364e972c9d7fce", + "size": 21164725, + "subdir": "linux-64", + "timestamp": 1618856307974, + "version": "1.6.2" + }, + "scipy-1.6.2-py38hf56f3a7_0.tar.bz2": { + "build": "py38hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5f93024bb533bcb43f4e38552faf6b99", + "name": "scipy", + "sha256": "9b1fd5458c6762ac92bedb4fd4227aa415b66d84e531184018d56ea0d328e1a5", + "size": 21066253, + "subdir": "linux-64", + "timestamp": 1616703964476, + "version": "1.6.2" + }, + "scipy-1.6.2-py38hf56f3a7_1.tar.bz2": { + "build": "py38hf56f3a7_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "97d33629af384acee9fd7666d4e71314", + "name": "scipy", + "sha256": "73e2990933460741e9b0932992590dc85b27e3d63c07f5694371c730af20f17e", + "size": 21058737, + "subdir": "linux-64", + "timestamp": 1618856588916, + "version": "1.6.2" + }, + "scipy-1.6.2-py39h91f5cce_0.tar.bz2": { + "build": "py39h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8be41e153c7e17d5512e3af7f87d5c6d", + "name": "scipy", + "sha256": "716391373b82bac432eb3f05f6d5d481bf78d65f21681ac881639fa068c5f3f1", + "size": 21588615, + "subdir": "linux-64", + "timestamp": 1616703992384, + "version": "1.6.2" + }, + "scipy-1.6.2-py39had2a1c9_1.tar.bz2": { + "build": "py39had2a1c9_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5f18311a95358bb951f98a6d005a862d", + "name": "scipy", + "sha256": "2cf06019a66fbb0a9df571bac7f0460eb66f60d6b9c37f6a64a6dcddbe2c765f", + "size": 21512828, + "subdir": "linux-64", + "timestamp": 1618856702227, + "version": "1.6.2" + }, + "scipy-1.6.2-py39hf56f3a7_0.tar.bz2": { + "build": "py39hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c0988ea7700f0448a48021e31dfef363", + "name": "scipy", + "sha256": "2da29caa3b9eb55bb8edaff3c5810ecf20495861abaf932c2e076f350c86dc0e", + "size": 21538235, + "subdir": "linux-64", + "timestamp": 1616703859670, + "version": "1.6.2" + }, + "scipy-1.6.2-py39hf56f3a7_1.tar.bz2": { + "build": "py39hf56f3a7_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "335cf57571152cdb1d018c03a9bc1175", + "name": "scipy", + "sha256": "3e374c98f01d9541c4e4add1806a8913f53fbc27ef515c4a7e3ddb93c3d18681", + "size": 21540532, + "subdir": "linux-64", + "timestamp": 1618856563865, + "version": "1.6.2" + }, + "scipy-1.7.1-py37h292c36d_2.tar.bz2": { + "build": "py37h292c36d_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1084088fb0d5eebb6bc42516522bed2b", + "name": "scipy", + "sha256": "1b0a4c06aced32cf9a21751c3df03dd08cb10eb61801274ca08bfff07781d047", + "size": 22137750, + "subdir": "linux-64", + "timestamp": 1630607544553, + "version": "1.7.1" + }, + "scipy-1.7.1-py37hc65b3f8_2.tar.bz2": { + "build": "py37hc65b3f8_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "defdb29827cbf3eb5b65321a04e41cea", + "name": "scipy", + "sha256": "01d354d1bbd0c5a2a86f8cd7ecdafb9ee2fbce43d72247989a4a4177d5de964f", + "size": 22146424, + "subdir": "linux-64", + "timestamp": 1630607275359, + "version": "1.7.1" + }, + "scipy-1.7.1-py38h292c36d_2.tar.bz2": { + "build": "py38h292c36d_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8809316c87b159b81ef44c752a8713f6", + "name": "scipy", + "sha256": "b0933b131959915219fe3949cf12ffd3dfe149a96ba2a3bfc0639afe5f3833cd", + "size": 22385036, + "subdir": "linux-64", + "timestamp": 1630607582275, + "version": "1.7.1" + }, + "scipy-1.7.1-py38hc65b3f8_2.tar.bz2": { + "build": "py38hc65b3f8_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ff7fca487408807419bd2b6b2fc26fcc", + "name": "scipy", + "sha256": "c617fd74b3746f6932a67310d2406b548bdd9db442e09d668f206ee00424a032", + "size": 22319188, + "subdir": "linux-64", + "timestamp": 1630607576146, + "version": "1.7.1" + }, + "scipy-1.7.1-py39h292c36d_2.tar.bz2": { + "build": "py39h292c36d_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d1a49154d61a68cbe9046d826f4260cb", + "name": "scipy", + "sha256": "ed5230359214b0645ab0debfded24e85be1ca01bd5da62a1a75c978da1c2173b", + "size": 22849275, + "subdir": "linux-64", + "timestamp": 1630607582611, + "version": "1.7.1" + }, + "scipy-1.7.1-py39hc65b3f8_2.tar.bz2": { + "build": "py39hc65b3f8_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3e0a4ee708beb31ab6dd4998bed1767e", + "name": "scipy", + "sha256": "324c3cfecc6713aadaa1facdd5a135e8a6b70fbb96e8da9843135076d74ab9a9", + "size": 22876052, + "subdir": "linux-64", + "timestamp": 1630607571741, + "version": "1.7.1" + }, + "scipy-1.7.3-py310h1794996_2.tar.bz2": { + "build": "py310h1794996_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<1.23", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9dbc3e6f76120b8f33f69b70654df92e", + "name": "scipy", + "sha256": "da4da92ccb70f7a259771d419ec4dfd440b22033e965ba84cb03ab3398572e2b", + "size": 72611300, + "subdir": "linux-64", + "timestamp": 1661398526183, + "version": "1.7.3" + }, + "scipy-1.7.3-py310h4f1e569_0.tar.bz2": { + "build": "py310h4f1e569_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<1.23.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "15e998dcee7df70768272542ff9fb88d", + "name": "scipy", + "sha256": "68a14f07d8cb8eec8e223454946c8317eff5752df1a66823b5ff79b3974ccfc3", + "size": 62374175, + "subdir": "linux-64", + "timestamp": 1641392138022, + "version": "1.7.3" + }, + "scipy-1.7.3-py310hac523dd_2.tar.bz2": { + "build": "py310hac523dd_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<1.23", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b8e5c5454f2ca4c51e56954331de9b65", + "name": "scipy", + "sha256": "00f5898c9a01c6775341872fbcdd35629fc9eee2466402529d3c8f1a76d43274", + "size": 72609191, + "subdir": "linux-64", + "timestamp": 1661391221927, + "version": "1.7.3" + }, + "scipy-1.7.3-py310hfa59a62_0.tar.bz2": { + "build": "py310hfa59a62_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21.2,<1.23.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "064d3aedb46e0aac87017023923d149a", + "name": "scipy", + "sha256": "042987dbc0b345629bfb28a9236df9ff8de6ff2503705421ca3df4e924b57edf", + "size": 62371031, + "subdir": "linux-64", + "timestamp": 1641390522722, + "version": "1.7.3" + }, + "scipy-1.7.3-py37h492baa0_0.tar.bz2": { + "build": "py37h492baa0_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<1.23.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "00bb468892f5760198158c44f1b7e771", + "name": "scipy", + "sha256": "31189fb2a9050ec69121a620a0459590c86a8cb39ae92a1d4b189f1fdd82479b", + "size": 22206561, + "subdir": "linux-64", + "timestamp": 1641555797758, + "version": "1.7.3" + }, + "scipy-1.7.3-py37h6c91a56_2.tar.bz2": { + "build": "py37h6c91a56_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<1.23", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "94303ee5432b6f662dbe3e07ee634cfe", + "name": "scipy", + "sha256": "812e6dfdde6ff0c732d74172360aaf1118adab29ed30ff63cdbc050389f74523", + "size": 22676529, + "subdir": "linux-64", + "timestamp": 1661402022788, + "version": "1.7.3" + }, + "scipy-1.7.3-py37hc147768_0.tar.bz2": { + "build": "py37hc147768_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<1.23.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1a5783398688dc5badd017e0ad39e464", + "name": "scipy", + "sha256": "2f25ba2a79da0a34a7d2b5c431ab4e69c237165673a9e21388e7f6c21c559c12", + "size": 22206676, + "subdir": "linux-64", + "timestamp": 1641537668818, + "version": "1.7.3" + }, + "scipy-1.7.3-py37hf838250_2.tar.bz2": { + "build": "py37hf838250_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16,<1.23", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "78a5bef6bec16fb5eb6c21e60568b1d7", + "name": "scipy", + "sha256": "0201befc0e1c0423d303e6de8d5441887d6f700fab8da4aaa568c7eab7c9c361", + "size": 22677692, + "subdir": "linux-64", + "timestamp": 1661394804902, + "version": "1.7.3" + }, + "scipy-1.7.3-py38h492baa0_0.tar.bz2": { + "build": "py38h492baa0_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<1.23.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f99d8bdc475ed3af996196549fa686d4", + "name": "scipy", + "sha256": "c8cac64af82de1ccd1e280b061e1642fd87175dfab4915d88621ed9a0cbbb743", + "size": 22473459, + "subdir": "linux-64", + "timestamp": 1641540904802, + "version": "1.7.3" + }, + "scipy-1.7.3-py38h6c91a56_2.tar.bz2": { + "build": "py38h6c91a56_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<1.23", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "cbd2dacc8ca9eb7a04c868d2ca33b069", + "name": "scipy", + "sha256": "13ff58dbcfbb70178146027aed08431b7bd9d02b3c89c1ae1ef002ff7a31161e", + "size": 22891274, + "subdir": "linux-64", + "timestamp": 1661400308502, + "version": "1.7.3" + }, + "scipy-1.7.3-py38hc147768_0.tar.bz2": { + "build": "py38hc147768_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<1.23.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "19454e3c6ca86b56a24501dcc646ec0a", + "name": "scipy", + "sha256": "0cd2fa4a6f7d6a0e8859dd86443293d5eb90dd7a467c3c4755092606db3e3926", + "size": 22438624, + "subdir": "linux-64", + "timestamp": 1641555781306, + "version": "1.7.3" + }, + "scipy-1.7.3-py38hf838250_2.tar.bz2": { + "build": "py38hf838250_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16,<1.23", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9041c30040edbb612881b43eb4929eb1", + "name": "scipy", + "sha256": "9957356255d3dc2572ae425962bbfc7f5880a78276369f0e60005fadd8ee3f1e", + "size": 22892812, + "subdir": "linux-64", + "timestamp": 1661393055149, + "version": "1.7.3" + }, + "scipy-1.7.3-py39h492baa0_0.tar.bz2": { + "build": "py39h492baa0_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<1.23.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "90a94cc60a4ab6c93250752db7be2adc", + "name": "scipy", + "sha256": "0f48d0a23fcc6bd37c812a9a70a17e75c085d3eb7baad30a696bdf439316e2a3", + "size": 22900419, + "subdir": "linux-64", + "timestamp": 1641555756355, + "version": "1.7.3" + }, + "scipy-1.7.3-py39h6c91a56_2.tar.bz2": { + "build": "py39h6c91a56_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<1.23", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2c7e7a4df3e365271bcebe8c57e237fd", + "name": "scipy", + "sha256": "60c72afc33ea35e2a997337632f38c82ebc3343a6ce7d634aaafa33b2662f1d4", + "size": 23240531, + "subdir": "linux-64", + "timestamp": 1661403721366, + "version": "1.7.3" + }, + "scipy-1.7.3-py39hc147768_0.tar.bz2": { + "build": "py39hc147768_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<1.23.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "026eb176608ac296c4ea8368cd07610d", + "name": "scipy", + "sha256": "18382f40cd3a607c91e0c13cec5b4590cf4c5a5f277b51691c5e8fd34dab4240", + "size": 22906866, + "subdir": "linux-64", + "timestamp": 1641555794105, + "version": "1.7.3" + }, + "scipy-1.7.3-py39hf838250_2.tar.bz2": { + "build": "py39hf838250_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16,<1.23", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "3791fada063755eaad3243b8d679b878", + "name": "scipy", + "sha256": "a2ed3047eff9172490c156922bd56cb6e7bd640b75acdec108d25e06903e31c4", + "size": 23240074, + "subdir": "linux-64", + "timestamp": 1661396602754, + "version": "1.7.3" + }, + "scipy-1.9.1-py310hd5efca6_0.tar.bz2": { + "build": "py310hd5efca6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<1.25.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c4543f542c95d31e6a67f01aadbc3d1f", + "name": "scipy", + "sha256": "528c015a88ff4aa93dca83f888253e4cc720321cd778d48a1005339aa3d9e688", + "size": 99278934, + "subdir": "linux-64", + "timestamp": 1664919631870, + "version": "1.9.1" + }, + "scipy-1.9.1-py310heeff2f4_0.tar.bz2": { + "build": "py310heeff2f4_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<1.25.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d0691656d7f33a2ff6668b1d4355461f", + "name": "scipy", + "sha256": "3a773bbb4be33442824cb67129a88ac67bc153c26011b5331fd77b2dc9dc4950", + "size": 99277374, + "subdir": "linux-64", + "timestamp": 1664915705242, + "version": "1.9.1" + }, + "scipy-1.9.1-py38h14f4228_0.tar.bz2": { + "build": "py38h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19,<1.25.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b40d6a2c549b2f7f7c7808332dfd30c0", + "name": "scipy", + "sha256": "503b67ec990cf4ac205d708571d8d90b3679871457509f5fc7bc056461cbc0d3", + "size": 25868167, + "subdir": "linux-64", + "timestamp": 1664922122274, + "version": "1.9.1" + }, + "scipy-1.9.1-py38h32ae08f_0.tar.bz2": { + "build": "py38h32ae08f_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19,<1.25.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2bb68b0e18c7e014437eb4092279de76", + "name": "scipy", + "sha256": "4312425e0b253a942ffaf6606fd165f80d9c1778a491f7c74e75cad771353477", + "size": 25872142, + "subdir": "linux-64", + "timestamp": 1664918235130, + "version": "1.9.1" + }, + "scipy-1.9.1-py39h14f4228_0.tar.bz2": { + "build": "py39h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19,<1.25.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "670923763170634bebefb3df31b2d896", + "name": "scipy", + "sha256": "c62efea78c6a9b09f29ba8c663092af8bbe2bb58539eaec7227df0c608ce8c22", + "size": 26519905, + "subdir": "linux-64", + "timestamp": 1664920941588, + "version": "1.9.1" + }, + "scipy-1.9.1-py39h32ae08f_0.tar.bz2": { + "build": "py39h32ae08f_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19,<1.25.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "90939418db32914f73806feebc1ac64f", + "name": "scipy", + "sha256": "b343124349ca948ec554c0b5b0b36197e199ea6dd57f411e068430a3a50e46e7", + "size": 26520675, + "subdir": "linux-64", + "timestamp": 1664917001244, + "version": "1.9.1" + }, + "scipy-1.9.3-py310hd5efca6_0.tar.bz2": { + "build": "py310hd5efca6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<1.26.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "17203804b5141fa2af03f374cb69d8e2", + "name": "scipy", + "sha256": "91443658a4012278daeb9aa0d53978f23ff9297817997c05de7edddb5bdc7d3c", + "size": 27497345, + "subdir": "linux-64", + "timestamp": 1667581115246, + "version": "1.9.3" + }, + "scipy-1.9.3-py310hd5efca6_1.tar.bz2": { + "build": "py310hd5efca6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<1.26.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bbc4c2c9300c6ad8d62fea23283f399c", + "name": "scipy", + "sha256": "3e8ffbe30236430dfcf00383065d6992e166cbaa598c09fc857aef487195c083", + "size": 27573812, + "subdir": "linux-64", + "timestamp": 1680103659543, + "version": "1.9.3" + }, + "scipy-1.9.3-py310heeff2f4_0.tar.bz2": { + "build": "py310heeff2f4_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<1.26.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1237e11e1efb1a6edc4143d43e2a1bea", + "name": "scipy", + "sha256": "71e43d915115c7a6bbd32fc91bc1d1192836decb0f35c83894be31cd8289ae71", + "size": 27496212, + "subdir": "linux-64", + "timestamp": 1667577274953, + "version": "1.9.3" + }, + "scipy-1.9.3-py310heeff2f4_1.tar.bz2": { + "build": "py310heeff2f4_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<1.26.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "72b01507964743ae5aebb19f9e836414", + "name": "scipy", + "sha256": "eb8677a99891d5677a3cd283074a46224309bbb3e748df056d6c0b5f24eeb873", + "size": 27574195, + "subdir": "linux-64", + "timestamp": 1680098737244, + "version": "1.9.3" + }, + "scipy-1.9.3-py311h24aa872_1.tar.bz2": { + "build": "py311h24aa872_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23,<1.26.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e5e2fdc10a404c50c3a6fcee2ccc0b6d", + "name": "scipy", + "sha256": "7290edb1e97e8dc64e80daa28dd4e759aaee374241173e259d81c5d3200a72d4", + "size": 28947092, + "subdir": "linux-64", + "timestamp": 1680099907294, + "version": "1.9.3" + }, + "scipy-1.9.3-py311hc206e33_1.tar.bz2": { + "build": "py311hc206e33_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.23,<1.26.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "63b293a8980d5041cfdef2f8cc861a2b", + "name": "scipy", + "sha256": "1a67a718f214b2afafd8e82541569ae1501af93bcbf56481bf5d671508ac276d", + "size": 28949701, + "subdir": "linux-64", + "timestamp": 1680104912340, + "version": "1.9.3" + }, + "scipy-1.9.3-py38h14f4228_0.tar.bz2": { + "build": "py38h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19,<1.26.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "72aa305c5769a79186f91412dadd6631", + "name": "scipy", + "sha256": "45bdd2df54f998cb81047773326b896dae0f224256dffa546260e1ea5aaa6a4b", + "size": 25981705, + "subdir": "linux-64", + "timestamp": 1667582373473, + "version": "1.9.3" + }, + "scipy-1.9.3-py38h14f4228_1.tar.bz2": { + "build": "py38h14f4228_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19,<1.26.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "18539d9312878bd1f1f9718d12600646", + "name": "scipy", + "sha256": "9edc681033ec88305e0428d963d6ee41451ab7e0e0c3c5d94c68937695d8df62", + "size": 25825574, + "subdir": "linux-64", + "timestamp": 1680107329367, + "version": "1.9.3" + }, + "scipy-1.9.3-py38h32ae08f_0.tar.bz2": { + "build": "py38h32ae08f_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19,<1.26.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d07e1afb33bb2da50d288ef1b732f952", + "name": "scipy", + "sha256": "914b379b8bd6d62489568464fc36c81d78110223550d3e039c363964efa4ac5b", + "size": 25981202, + "subdir": "linux-64", + "timestamp": 1667578552544, + "version": "1.9.3" + }, + "scipy-1.9.3-py38h32ae08f_1.tar.bz2": { + "build": "py38h32ae08f_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19,<1.26.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5fafdd21fb638bf6dc25bea17f480a7e", + "name": "scipy", + "sha256": "70cf70f60c2912e9d03f6ca5fc4e93014b64ded364d92701397f453fd2e65e3c", + "size": 25825640, + "subdir": "linux-64", + "timestamp": 1680102453549, + "version": "1.9.3" + }, + "scipy-1.9.3-py39h14f4228_0.tar.bz2": { + "build": "py39h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19,<1.26.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b7be8adf6bd014454eebeee35c91388b", + "name": "scipy", + "sha256": "4d2432ae17a9b2f319ed301c8cb9612f8f92e45272d484500359e049f9d833f2", + "size": 26456790, + "subdir": "linux-64", + "timestamp": 1667583589796, + "version": "1.9.3" + }, + "scipy-1.9.3-py39h14f4228_1.tar.bz2": { + "build": "py39h14f4228_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19,<1.26.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ace7457183380fedd0b6d401eaf3cc84", + "name": "scipy", + "sha256": "6059bd605f75787cbf69d98b196ef9b6935e968f6372f49e2dd128814f828e23", + "size": 26572816, + "subdir": "linux-64", + "timestamp": 1680106091435, + "version": "1.9.3" + }, + "scipy-1.9.3-py39h32ae08f_0.tar.bz2": { + "build": "py39h32ae08f_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19,<1.26.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c8c174692107cf68760fede9d26425fa", + "name": "scipy", + "sha256": "071d22f38ecad6d5dafce85119753cd9fedb56c2f4db0f098ba7fed23a9f4646", + "size": 26456565, + "subdir": "linux-64", + "timestamp": 1667579805371, + "version": "1.9.3" + }, + "scipy-1.9.3-py39h32ae08f_1.tar.bz2": { + "build": "py39h32ae08f_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19,<1.26.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0919a4fba412acaa8427d12fea77564d", + "name": "scipy", + "sha256": "0c5a469f11f00ccc3c7c5c8e6b7682f9ec269da5fac0880d0d4a3f65e7a63f9a", + "size": 26572625, + "subdir": "linux-64", + "timestamp": 1680101265678, + "version": "1.9.3" + }, + "scons-3.0.0-py27h8a56064_0.tar.bz2": { + "build": "py27h8a56064_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4340c9ba3e85684cbfeef2ef6e4653ae", + "name": "scons", + "sha256": "5223fa56267121b5534943c75790422b47c272b5622e424d22ab021515d2b1a4", + "size": 791509, + "subdir": "linux-64", + "timestamp": 1508602954444, + "version": "3.0.0" + }, + "scons-3.0.0-py35h10c8eaf_0.tar.bz2": { + "build": "py35h10c8eaf_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "015172de81e61893eee3ded3037b2d85", + "name": "scons", + "sha256": "7de097312247cdd311a9b2dc6b6855ac18d0a1e0a12809616fce389bbf95bbca", + "size": 810231, + "subdir": "linux-64", + "timestamp": 1508602961596, + "version": "3.0.0" + }, + "scons-3.0.0-py36h799cc36_0.tar.bz2": { + "build": "py36h799cc36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8da1be3645e7c579e2c66e66dc7f1f4", + "name": "scons", + "sha256": "6ee071c7f6507a1dba35d38b18717ca0d91f68e71f7772aef8188a94e9dbef26", + "size": 807821, + "subdir": "linux-64", + "timestamp": 1508602934846, + "version": "3.0.0" + }, + "scons-3.0.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "03c205f69a9287840d9157d6ee213372", + "name": "scons", + "sha256": "d3384d28efe59a550689579cc46980d6da2053793d44673e9afcfdbca46c2950", + "size": 796633, + "subdir": "linux-64", + "timestamp": 1522714682009, + "version": "3.0.1" + }, + "scons-3.0.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "019ccea1e617704d39746749fe92d1f6", + "name": "scons", + "sha256": "8267d3b53b69b086395068c405b1850e28fe9fb4018bd0ce0cdc925dabaca465", + "size": 813741, + "subdir": "linux-64", + "timestamp": 1522714704350, + "version": "3.0.1" + }, + "scons-3.0.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37a57d40045115a1ade71b24dd9c9f87", + "name": "scons", + "sha256": "9d69948de5f2dc614d1cdf5c274217e298fcbe1436d19f61473d9a73ed9cc19a", + "size": 810481, + "subdir": "linux-64", + "timestamp": 1522715200427, + "version": "3.0.1" + }, + "scons-3.0.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7468784bbbc69d40808b1c462c8eff9c", + "name": "scons", + "sha256": "e2a56af4223951658f91cf87d57eb29b4e60e1760bc63b3c09e719e1a3d74c3d", + "size": 813957, + "subdir": "linux-64", + "timestamp": 1530959716146, + "version": "3.0.1" + }, + "scons-3.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a538951fdf5b975316cfc164e885eb36", + "name": "scons", + "sha256": "42538b76465540f9af3caac536560a1b01dac520168c126f7161823e4d6bb369", + "size": 850171, + "subdir": "linux-64", + "timestamp": 1548005750817, + "version": "3.0.3" + }, + "scons-3.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71a3be0593b211784a7961871cd1f3c8", + "name": "scons", + "sha256": "0a42b1220852a1c4ad4be8de11560df0a6e506c061e0ac8fd3fbad8deef6d081", + "size": 841456, + "subdir": "linux-64", + "timestamp": 1548005769329, + "version": "3.0.3" + }, + "scons-3.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b61f983a3d6852e9ab76923de5de5e4b", + "name": "scons", + "sha256": "3d24fb9891813c3910aee5499c0a835630856fa52c7a4b05260f76dab7c62809", + "size": 857515, + "subdir": "linux-64", + "timestamp": 1548005779480, + "version": "3.0.3" + }, + "scons-3.0.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1aa200a839e27c71a786fcb7ea1e70d7", + "name": "scons", + "sha256": "3a4318f71d6e904e88c8a66665654d8fb0ca64dc21888d299291873f43c9e2ca", + "size": 840213, + "subdir": "linux-64", + "timestamp": 1550361122110, + "version": "3.0.4" + }, + "scons-3.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce030ad3b757ca43df7d395db3aa3a98", + "name": "scons", + "sha256": "0e3de839f98c822071d1cc114ca35550739abf98890c3188b40ca778a7cc1f6d", + "size": 861454, + "subdir": "linux-64", + "timestamp": 1550361160508, + "version": "3.0.4" + }, + "scons-3.0.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e77d1191d7bafeeb2381238733cb7f8c", + "name": "scons", + "sha256": "6686c3efacaf2d95d9fb9cf8f0c629572ffd4df82bc00cf811020d5fa6fafcb3", + "size": 850446, + "subdir": "linux-64", + "timestamp": 1550361116456, + "version": "3.0.4" + }, + "scons-3.0.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df5297e1ad36fcce138484b93e5879cb", + "name": "scons", + "sha256": "a4fb0d53b9cfba818d8dbac938c8c17f80b06a0ac242c9e86d8f994d42a00e9f", + "size": 852023, + "subdir": "linux-64", + "timestamp": 1556075299305, + "version": "3.0.5" + }, + "scons-3.0.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6853322372182056cf2c0ca9f31ca2a", + "name": "scons", + "sha256": "e22062d56167f940e099f0e0381748d2faf3e206c742a2212c928190c8fe1c0b", + "size": 851785, + "subdir": "linux-64", + "timestamp": 1556075486154, + "version": "3.0.5" + }, + "scons-3.0.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7d06b830553b80ceba71a51b155c5ddd", + "name": "scons", + "sha256": "ba518f748a0878c78a1d3eb5db06192c6097a79045b6d747ffd7f8da1b962c0c", + "size": 862163, + "subdir": "linux-64", + "timestamp": 1556075469066, + "version": "3.0.5" + }, + "scons-3.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd869d32883ebea9a1c3ab8631c345ba", + "name": "scons", + "sha256": "0c58ea62242f92ee6a5c9d313b6e2986dde84da457a69eec50bb7189cbd66266", + "size": 844735, + "subdir": "linux-64", + "timestamp": 1564706802896, + "version": "3.1.0" + }, + "scons-3.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "19bae8a7dc40be1b8a7c84494fb200de", + "name": "scons", + "sha256": "57e39281bf00c161a542bbc74c7b541796c8bc5973eb5f99614605c4e281ced1", + "size": 858865, + "subdir": "linux-64", + "timestamp": 1564706822152, + "version": "3.1.0" + }, + "scons-3.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0153f8245d935ffd74cab207f536b51e", + "name": "scons", + "sha256": "9ebc4215a6832d34c32a7c15f0570c21cb405e84737e0d23ee655eaa840d8492", + "size": 866464, + "subdir": "linux-64", + "timestamp": 1564706790233, + "version": "3.1.0" + }, + "scons-3.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f688245b9f9639257eae09492d5f8ded", + "name": "scons", + "sha256": "abb217755711f3aae52cc132a2900ee58262d7383f9e577ec7c599d0b68cd5ce", + "size": 856181, + "subdir": "linux-64", + "timestamp": 1569367347720, + "version": "3.1.1" + }, + "scons-3.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "04e6167b867ecc0b900fdb9e7c5f5cf7", + "name": "scons", + "sha256": "291358756f90534c3fdf6a902e8d1e5acbf88b8a5411e6e473bb3ed897706480", + "size": 867879, + "subdir": "linux-64", + "timestamp": 1569367409635, + "version": "3.1.1" + }, + "scons-3.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e1aa3fc846335d7ec8b775ecef9f9ac4", + "name": "scons", + "sha256": "64d8c2bce909ee217b120a1c0f29f7412a9f2ea06a6d748c8a9a301bac158e8a", + "size": 867168, + "subdir": "linux-64", + "timestamp": 1569367370565, + "version": "3.1.1" + }, + "scons-3.1.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b496db99d166f33d66f11fb6bd9b682", + "name": "scons", + "sha256": "ec5d213ea6f599cca89d50918f6382f40a5fd045ac4447894eaaac6dbc87bf65", + "size": 866447, + "subdir": "linux-64", + "timestamp": 1573200646342, + "version": "3.1.1" + }, + "scons-3.1.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1831abe0bc76dde1c69f9994f374554d", + "name": "scons", + "sha256": "ae50875d682bccf017072f4ce266777543de476908cfe71563313365024a0b94", + "size": 867917, + "subdir": "linux-64", + "timestamp": 1640794521828, + "version": "3.1.2" + }, + "scons-3.1.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d29193cdb7b1dc5fc53f2a6d7af39658", + "name": "scons", + "sha256": "9bb47087e0da8cfd11d34de3e71e1c5aa714c5f678c9185c332159a6c64f7f06", + "size": 1095498, + "subdir": "linux-64", + "timestamp": 1676861991354, + "version": "3.1.2" + }, + "scons-3.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1e68a0f3432480534c9a498c682d47b", + "name": "scons", + "sha256": "238b549d112d40851325bf06fa79493ae4e744227118d1ca775920d3ec56f2d6", + "size": 870923, + "subdir": "linux-64", + "timestamp": 1593489751499, + "version": "3.1.2" + }, + "scons-3.1.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cdcf27233956fc3a3ae3483266aacce7", + "name": "scons", + "sha256": "4e0c910eb620d561f6694433b5c06cfbdd6ddd4e48c250dd91f77bf8fdb07af2", + "size": 859304, + "subdir": "linux-64", + "timestamp": 1632761494618, + "version": "3.1.2" + }, + "scons-3.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "88b6a74710eeda1c631ee782a7c1dc78", + "name": "scons", + "sha256": "b3b32bc5be1a16ecb91f752fea020b51a2f90c4aa2173f0b63c7dde22c1f397f", + "size": 859452, + "subdir": "linux-64", + "timestamp": 1593489747042, + "version": "3.1.2" + }, + "scons-3.1.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "567357cc37c9f498fe6805093ac30dea", + "name": "scons", + "sha256": "93210d3aef2626e028464be032039364b92eda24ab00b1cfa89cd216069dbb03", + "size": 870794, + "subdir": "linux-64", + "timestamp": 1632746532007, + "version": "3.1.2" + }, + "scons-3.1.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "91a83635e8457af9e4e76a4e84bd821f", + "name": "scons", + "sha256": "d93b200ae6e61ba5dd27b2b0d2963c1ec3b5db22d3fb76083e4d797574c970e0", + "size": 859821, + "subdir": "linux-64", + "timestamp": 1593489748340, + "version": "3.1.2" + }, + "scons-3.1.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "984b1728d4b7728fa27c5f5506553386", + "name": "scons", + "sha256": "85dd78bd861bbfdca72453672605e539f3ef18d10c3c358ea1c17afe3511e89f", + "size": 872087, + "subdir": "linux-64", + "timestamp": 1632756973648, + "version": "3.1.2" + }, + "scons-3.1.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90cbc7f4eaffb546bc87e02dd59a46b4", + "name": "scons", + "sha256": "0c423b6c9ce55885e88a2321ad2767cb8c09d1af688782e9c5e233ace2f585b4", + "size": 854150, + "subdir": "linux-64", + "timestamp": 1632756976402, + "version": "3.1.2" + }, + "scons-4.1.0.post1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c8c16b71e460c9e65fe0090cf2dbe454", + "name": "scons", + "sha256": "48410073027e4ff316bb7046204af8e3c83df5a790ee77c5512c5c6db6c71195", + "size": 2511351, + "subdir": "linux-64", + "timestamp": 1614713840040, + "version": "4.1.0.post1" + }, + "scons-4.1.0.post1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c4b4d8f5a539d2d49936fa32768a656", + "name": "scons", + "sha256": "7297e08e2fd6fb2a4020ddd51e464d979dcda8137685fdac5bc5523660856a29", + "size": 2507290, + "subdir": "linux-64", + "timestamp": 1614713820101, + "version": "4.1.0.post1" + }, + "scons-4.1.0.post1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1303f4f9ad094a380963019d1f4f2efc", + "name": "scons", + "sha256": "04df5af7b00a4ab22642f1c8d3c68beff96a3c5acffc46a2a789a860b470d88b", + "size": 2515019, + "subdir": "linux-64", + "timestamp": 1614713754556, + "version": "4.1.0.post1" + }, + "scons-4.1.0.post1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12d05f2392c15f4d5e4a8811c01ee30e", + "name": "scons", + "sha256": "22552d7f0a4fab26bced4e0457900c2a06c2e0305f5496f84c484b70256946c2", + "size": 2495467, + "subdir": "linux-64", + "timestamp": 1614713817628, + "version": "4.1.0.post1" + }, + "scp-0.10.2-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "paramiko", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "630503c2b32d8d7290b534ff68a397f5", + "name": "scp", + "sha256": "86257303796eaec5b82d429a207fec063ca28ac651a0b69c1b208b7bba00342f", + "size": 13829, + "subdir": "linux-64", + "timestamp": 1522421060070, + "version": "0.10.2" + }, + "scp-0.10.2-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "paramiko", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "588e832355bf45bd91f69f39746ad0a1", + "name": "scp", + "sha256": "c6f19e69690f74cef8cb1f39f192c9e31a69748bd7af70fac17dd9395466ec0c", + "size": 14203, + "subdir": "linux-64", + "timestamp": 1522421140884, + "version": "0.10.2" + }, + "scp-0.10.2-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "paramiko", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "cb3410b00e5aa7a98476ec0f965bf7df", + "name": "scp", + "sha256": "3189af90da259bc40190ceb1dad16ea8be68632634c0f4ded2c0252a7b8a691c", + "size": 14102, + "subdir": "linux-64", + "timestamp": 1522421139265, + "version": "0.10.2" + }, + "scp-0.11.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "24df21f0b49d7761bdbd005930cfbffa", + "name": "scp", + "sha256": "1500bf03499c2c82706ea9d2affb5f1293221c00f0c110048f80e9305bc54fba", + "size": 15324, + "subdir": "linux-64", + "timestamp": 1526944289932, + "version": "0.11.0" + }, + "scp-0.11.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "cb30c5d11b117508bdbc309c81eae4a9", + "name": "scp", + "sha256": "a1b2a825273522cb8175acfb46012355d4c78c50789b5d07b76c7937c20d47be", + "size": 15774, + "subdir": "linux-64", + "timestamp": 1526944309258, + "version": "0.11.0" + }, + "scp-0.11.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "218f67b0e1bb3deed7eeb65e61541aea", + "name": "scp", + "sha256": "faea3df2a4c569cf597b79f7edf1be43e2f464bf92f67beb425abd25f507c874", + "size": 15630, + "subdir": "linux-64", + "timestamp": 1526944281088, + "version": "0.11.0" + }, + "scp-0.11.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "8c0d7737f183f9235fe857a9b36045b5", + "name": "scp", + "sha256": "6ebf8576df0158545c125a9b85bdf6c7c1f33aba699c4357c87f490fdc3dc98a", + "size": 15677, + "subdir": "linux-64", + "timestamp": 1530959753376, + "version": "0.11.0" + }, + "scp-0.12.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "c18bf27359917741059ae2c4a6252c9c", + "name": "scp", + "sha256": "e9e801c373d3f010a69cab5884b006cae172651289682ea2467d34da5bfeda4c", + "size": 16469, + "subdir": "linux-64", + "timestamp": 1539657258870, + "version": "0.12.1" + }, + "scp-0.12.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "812e63e8900c34469a0c254d70951b52", + "name": "scp", + "sha256": "5a0dd895b62e3d433323458dead84bc3d7bf6f697621fe409286b591e04a17b6", + "size": 16806, + "subdir": "linux-64", + "timestamp": 1539657277414, + "version": "0.12.1" + }, + "scp-0.12.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "9c1ebf441de08f33ec1498cdc4c08eae", + "name": "scp", + "sha256": "f92b34065d531a56890dadd2fcd99b8f55f61bb5f982b00f82bdca3aeb6fa57c", + "size": 16837, + "subdir": "linux-64", + "timestamp": 1539657279235, + "version": "0.12.1" + }, + "scp-0.13.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "35dad20d8f01c3a7121524e1ad6f7dbc", + "name": "scp", + "sha256": "7fabc0f99116e01b057d657e505b3c4a1a1e2e6938cc0f1227bbc4c1dbf0d72a", + "size": 16453, + "subdir": "linux-64", + "timestamp": 1542394390256, + "version": "0.13.0" + }, + "scp-0.13.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "04215ba8060cddc360127ebb5ce2d29a", + "name": "scp", + "sha256": "84a8b64ff61f618d30fbfccd64e1f7f8ab476060159601e5f5826f3222b21a37", + "size": 16714, + "subdir": "linux-64", + "timestamp": 1542394417962, + "version": "0.13.0" + }, + "scp-0.13.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "8631446b87ba3e492c9cd0465d6e6fe9", + "name": "scp", + "sha256": "3b1800644a4d8efdef3f0024f00c5e31a128ae102c2066a4b62f33b4bad3d809", + "size": 16756, + "subdir": "linux-64", + "timestamp": 1542394344050, + "version": "0.13.0" + }, + "scrapy-1.4.0-py27h060f748_1.tar.bz2": { + "build": "py27h060f748_1", + "build_number": 1, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.1.0", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "c7b6e8dd4ca4cf60f472970ef81e9c5c", + "name": "scrapy", + "sha256": "c0592afcc8f5df77098d316aaae656881c102b4b0ca2182cf4056f134003a1ef", + "size": 307893, + "subdir": "linux-64", + "timestamp": 1507838520990, + "version": "1.4.0" + }, + "scrapy-1.4.0-py35h03cf01c_1.tar.bz2": { + "build": "py35h03cf01c_1", + "build_number": 1, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.1.0", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.5,<3.6.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "e59cb7377bb369c0ea241431bbf9f206", + "name": "scrapy", + "sha256": "3863017da74f06d64e7949f7ed352fe4277db2340ffef7d1bed6022bdf9d610a", + "size": 316061, + "subdir": "linux-64", + "timestamp": 1507838530765, + "version": "1.4.0" + }, + "scrapy-1.4.0-py36h5dd8a1d_1.tar.bz2": { + "build": "py36h5dd8a1d_1", + "build_number": 1, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.1.0", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "6805de71ee48a2a180c282bfad81a3c3", + "name": "scrapy", + "sha256": "e5cc416047d05a163a527a6e692ca060ad04159cdb00d404d3c77548fd9fd55a", + "size": 313798, + "subdir": "linux-64", + "timestamp": 1507838581981, + "version": "1.4.0" + }, + "scrapy-1.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.1.0", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "a889f400323949b4cfb3c5f0e032a4ce", + "name": "scrapy", + "sha256": "3ab690dcc014116d9782b92a11cb575eecbde82d15369ddb3d47374f0bf597bd", + "size": 311772, + "subdir": "linux-64", + "timestamp": 1519674106062, + "version": "1.5.0" + }, + "scrapy-1.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.1.0", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.5,<3.6.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "cfd6d70549c96198b0b3d1aafdd41c48", + "name": "scrapy", + "sha256": "6b09c9e449f174f508b87e7fa5efdb96df87832885603d0d1fef3a40a45ac311", + "size": 320711, + "subdir": "linux-64", + "timestamp": 1519674133232, + "version": "1.5.0" + }, + "scrapy-1.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.1.0", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "437065d0b0b18ed35e390467d6140d31", + "name": "scrapy", + "sha256": "7190732d797d6812dd5f9ab87326f6bbff480aa00394c6ef4ddfc111133a4068", + "size": 318586, + "subdir": "linux-64", + "timestamp": 1519674245331, + "version": "1.5.0" + }, + "scrapy-1.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.1.0", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "04bf3d53e5f0bf0bcea5b9926f85e05e", + "name": "scrapy", + "sha256": "e6a4e15b2e316f271454fa122301a13239fb2558a071c5d6711617d898917aa4", + "size": 318186, + "subdir": "linux-64", + "timestamp": 1530959890591, + "version": "1.5.0" + }, + "scrapy-1.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.4", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "c4874ee9ce1bb157b120d294c0aca945", + "name": "scrapy", + "sha256": "4a606f832552222ed82e2f84e14f539949559d64ca4c01a91c327cbe0725c97a", + "size": 312052, + "subdir": "linux-64", + "timestamp": 1533482047847, + "version": "1.5.1" + }, + "scrapy-1.5.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.4", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.5,<3.6.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "560927fd066b5639c922e713eb5efaab", + "name": "scrapy", + "sha256": "870865e88356a238786774c314ae0d30ad1aa790aefdb9f6f6ac6847e3b06f09", + "size": 320426, + "subdir": "linux-64", + "timestamp": 1533482204643, + "version": "1.5.1" + }, + "scrapy-1.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.4", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "83c97d1b8112636ca62546c32fe14c11", + "name": "scrapy", + "sha256": "3d2c8dce1b3f822a511086e447b0d76f0e4a172084267e5eb44d8c7b25ac3539", + "size": 318677, + "subdir": "linux-64", + "timestamp": 1533482176530, + "version": "1.5.1" + }, + "scrapy-1.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.4", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "e2a0e081741a1671818559ed75dd6ac1", + "name": "scrapy", + "sha256": "515c8394c4840a7821d1d3d7859c4fc3beb734c55a20dfda6164dd56cbd526cf", + "size": 318583, + "subdir": "linux-64", + "timestamp": 1533482241443, + "version": "1.5.1" + }, + "scrapy-1.5.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "4d1104d6b81c42969943ec0a67781be6", + "name": "scrapy", + "sha256": "185196fd8c394ea9d4d18d26995242f8262ff188bab4ceee2470497df192e777", + "size": 321500, + "subdir": "linux-64", + "timestamp": 1552370610598, + "version": "1.5.2" + }, + "scrapy-1.5.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "9155b414663efdded4c20dab48222bfb", + "name": "scrapy", + "sha256": "b746a24fd35bf394ca44ac0cc96f784cd084da77beca4c781553574645b75b49", + "size": 325042, + "subdir": "linux-64", + "timestamp": 1552370645552, + "version": "1.5.2" + }, + "scrapy-1.5.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "45c8ff8ac88b6fd5921464fba539cfe2", + "name": "scrapy", + "sha256": "adac0ecdaf47e4d331432898be737f4a0ec64321fed20f99bc90bc312843832a", + "size": 326853, + "subdir": "linux-64", + "timestamp": 1552370605060, + "version": "1.5.2" + }, + "scrapy-1.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "399a19f5b25a174131650a6d6377f115", + "name": "scrapy", + "sha256": "b6ce22a45a05e9c0f55a83ec1ed4f07cf5211273f8880090013d83d0c920ba90", + "size": 321665, + "subdir": "linux-64", + "timestamp": 1556075703779, + "version": "1.6.0" + }, + "scrapy-1.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "d13f1b315294a5fa605de53ab04745dd", + "name": "scrapy", + "sha256": "e15577ee7d4fd383b27a0dc30635442cccc109df66c7095229af82b1ef2a24d2", + "size": 333004, + "subdir": "linux-64", + "timestamp": 1556075871158, + "version": "1.6.0" + }, + "scrapy-1.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "81ff1dfe9e19d9ef6f0d440a270cbba0", + "name": "scrapy", + "sha256": "a0a8029ca717a113c869b3f5e8389fcb60258098d6114017e145942106f2c18a", + "size": 331256, + "subdir": "linux-64", + "timestamp": 1556075683807, + "version": "1.6.0" + }, + "scrapy-1.6.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "858094ded15519d4441a490e741fcd2f", + "name": "scrapy", + "sha256": "2e9dda70df8f1e3431b11f822400ca6512c8d7d39329295d5c980a42d7e9afd1", + "size": 326877, + "subdir": "linux-64", + "timestamp": 1574237396384, + "version": "1.6.0" + }, + "scrapy-2.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD 3-Clauses", + "md5": "8f92702b669fdbd118fc7214473fab7a", + "name": "scrapy", + "sha256": "ce94667ce3a61332e4a2ba28066060a80a5c4852deb00ffdb2b6c12101942f13", + "size": 627221, + "subdir": "linux-64", + "timestamp": 1598667952785, + "version": "2.3.0" + }, + "scrapy-2.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD 3-Clauses", + "md5": "2c0e0598631c17127217eb18435b787e", + "name": "scrapy", + "sha256": "0a171d647a2e2835268693cb15a0856807d52c48f0a775fc6c1660d1c5babfb5", + "size": 626448, + "subdir": "linux-64", + "timestamp": 1598667992392, + "version": "2.3.0" + }, + "scrapy-2.3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD 3-Clauses", + "md5": "0b72299f3607cd283c4b43aeb3273df0", + "name": "scrapy", + "sha256": "e913d4d60ab3b7f7791bb735f0b06e34e3f5a4d5a9f973e27badac1b9eb3f963", + "size": 641583, + "subdir": "linux-64", + "timestamp": 1598667942501, + "version": "2.3.0" + }, + "scrapy-2.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "itemadapter", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "76ab9b77f3ac33946de7535072e929bb", + "name": "scrapy", + "sha256": "847c384c4b96c1a38b665ecc4b1424fb2f061bc2b0d93505a2718255ecd8aa73", + "size": 342756, + "subdir": "linux-64", + "timestamp": 1602522202086, + "version": "2.4.0" + }, + "scrapy-2.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "itemadapter", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "78f448f7917fdc15c442bae86175fbee", + "name": "scrapy", + "sha256": "9d69be03ab332991f7c8cbd753b952ff95f512f6ff3c687609c377f988b0b0e7", + "size": 342916, + "subdir": "linux-64", + "timestamp": 1602522208802, + "version": "2.4.0" + }, + "scrapy-2.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "itemadapter", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "d16611fc3ca7ba0e2137120998e4ed79", + "name": "scrapy", + "sha256": "c2e0068c2e4c79f7c7afa4ae5a56bebec947cc2af88052ae73495e403868266e", + "size": 347142, + "subdir": "linux-64", + "timestamp": 1602522183183, + "version": "2.4.0" + }, + "scrapy-2.4.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "itemadapter", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.10,<3.11.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "ece934535f6ce3c7f241990aeb312cec", + "name": "scrapy", + "sha256": "94cd5bfefc2326c97dd432e1e7d5529fa59c16fe12a2c1e95b95050b1041a023", + "size": 350642, + "subdir": "linux-64", + "timestamp": 1640814040733, + "version": "2.4.1" + }, + "scrapy-2.4.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "itemadapter", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "6a9acdfc131603ccf40168bb882839c3", + "name": "scrapy", + "sha256": "348261f10b8053270a9c099ae5cc84341fe639ae375fad612e37093630886637", + "size": 346048, + "subdir": "linux-64", + "timestamp": 1606864741202, + "version": "2.4.1" + }, + "scrapy-2.4.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "itemadapter", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "ed0aabb2026e97bfaca4c4a513de1fe9", + "name": "scrapy", + "sha256": "1fc1cfb86faa6c6fd287511e2f2199c1b4d9c7b4245a3b162c8d2fdf55011cc6", + "size": 346577, + "subdir": "linux-64", + "timestamp": 1606864724261, + "version": "2.4.1" + }, + "scrapy-2.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "itemadapter", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "60bd8c7754e40d37488532c82258143b", + "name": "scrapy", + "sha256": "c672b39ddbc628f6981d716265b8737250fb5bee722a42698f55d8e8af779e03", + "size": 347091, + "subdir": "linux-64", + "timestamp": 1606864717256, + "version": "2.4.1" + }, + "scrapy-2.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "itemadapter", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.9,<3.10.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "fc653ec4292179a002b04afe87c841f7", + "name": "scrapy", + "sha256": "03aec9af6461ee06915222130e1f2dfae6fa816818d44303e70678697916dc92", + "size": 349199, + "subdir": "linux-64", + "timestamp": 1632767717261, + "version": "2.4.1" + }, + "scrapy-2.6.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.10,<3.11.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "tldextract", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD-3-Clause-Clear", + "md5": "fe135c48a380d57cc2ae631731deff9f", + "name": "scrapy", + "sha256": "3b6e26c028fcc8595d6c0455a8eab3c04ad67b263b7cde7434cb322e33a1544b", + "size": 392515, + "subdir": "linux-64", + "timestamp": 1646837818919, + "version": "2.6.1" + }, + "scrapy-2.6.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.11,<3.12.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "tldextract", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD-3-Clause-Clear", + "md5": "3f09bff409b6f2b26eac4b733d2bdddf", + "name": "scrapy", + "sha256": "839a101eed237f6eaf201b4a93450d8f3e46ee38f6caa08c78c782aa402fae43", + "size": 512949, + "subdir": "linux-64", + "timestamp": 1676862009215, + "version": "2.6.1" + }, + "scrapy-2.6.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "tldextract", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD-3-Clause-Clear", + "md5": "6cd299dcc221d3e6b42a499de97733da", + "name": "scrapy", + "sha256": "25018b988880cfb1e42e1261d37f38f2da990be9e0ffb42f45160b06ef1f5ac5", + "size": 383401, + "subdir": "linux-64", + "timestamp": 1646837806315, + "version": "2.6.1" + }, + "scrapy-2.6.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "tldextract", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD-3-Clause-Clear", + "md5": "a0fdf957577561b6ed0f6dfb1001c3a2", + "name": "scrapy", + "sha256": "c342fb5ab784cdd80176ecb151571d4b779b3287a7339321a6e81bb098041508", + "size": 384963, + "subdir": "linux-64", + "timestamp": 1646820325242, + "version": "2.6.1" + }, + "scrapy-2.6.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "tldextract", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD-3-Clause-Clear", + "md5": "54ef20ed4ce3da4d98bc321426fef498", + "name": "scrapy", + "sha256": "c17c42cbf73303bc89eea33e5f63b8c5f0ad01c8a878f83fe94cc8a8a03f37bd", + "size": 385441, + "subdir": "linux-64", + "timestamp": 1646837803867, + "version": "2.6.1" + }, + "scrapy-2.6.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.10,<3.11.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "tldextract", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88856eee7ac9f2e3fb55e73978df92c1", + "name": "scrapy", + "sha256": "5402490426c4a04abaf6491d3cb5622375f80cf86cec13dffd402ae11c9e7ab4", + "size": 388302, + "subdir": "linux-64", + "timestamp": 1659598772609, + "version": "2.6.2" + }, + "scrapy-2.6.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "tldextract", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3df943f30a7800c098264664f0d17997", + "name": "scrapy", + "sha256": "2ab709a80ce8e49d7c50ab77a55799609ebca329ce6eb00f8659d5f643e9acd7", + "size": 381214, + "subdir": "linux-64", + "timestamp": 1659598850021, + "version": "2.6.2" + }, + "scrapy-2.6.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "tldextract", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3f3b0a58a82a84b9830c8681743d57cc", + "name": "scrapy", + "sha256": "d6a4916867e6cd95403729a912494882f086213bbb241d187f5dd1d809d8dcdf", + "size": 382782, + "subdir": "linux-64", + "timestamp": 1659598810993, + "version": "2.6.2" + }, + "scrapy-2.6.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "tldextract", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6b83eddc88325bda469134353b419f7f", + "name": "scrapy", + "sha256": "75bcad8052194df70108bbd9e3ad2668426738eb9bf0c258428b6ebb9f6cf1d8", + "size": 384150, + "subdir": "linux-64", + "timestamp": 1659598723052, + "version": "2.6.2" + }, + "scrapy-2.8.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.4.6", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "lxml >=4.3.0", + "packaging", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=21.0.0", + "python >=3.10,<3.11.0a0", + "queuelib >=1.4.2", + "service_identity >=18.1.0", + "setuptools", + "tldextract", + "twisted >=18.9.0", + "w3lib >=1.17.0", + "zope.interface >=5.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d56cf9558b13e37ee3b8864e26f9578f", + "name": "scrapy", + "sha256": "88c27a6ffbf3dd9f35cb956737e5f01dde0e3e5ec1eee3cc82dc34c06c5f9352", + "size": 397892, + "subdir": "linux-64", + "timestamp": 1677738262394, + "version": "2.8.0" + }, + "scrapy-2.8.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.4.6", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "lxml >=4.3.0", + "packaging", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=21.0.0", + "python >=3.11,<3.12.0a0", + "queuelib >=1.4.2", + "service_identity >=18.1.0", + "setuptools", + "tldextract", + "twisted >=18.9.0", + "w3lib >=1.17.0", + "zope.interface >=5.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c824f2c61b1ac9ebb19e7c578e6e02b6", + "name": "scrapy", + "sha256": "31a17acaccc358beed81b0678b5ecca030a5c0e16d6c0326aa7749bbc899940d", + "size": 524964, + "subdir": "linux-64", + "timestamp": 1677770292922, + "version": "2.8.0" + }, + "scrapy-2.8.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.4.6", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "lxml >=4.3.0", + "packaging", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=21.0.0", + "python >=3.8,<3.9.0a0", + "queuelib >=1.4.2", + "service_identity >=18.1.0", + "setuptools", + "tldextract", + "twisted >=18.9.0", + "w3lib >=1.17.0", + "zope.interface >=5.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "efbe28b038082ac322ccea7c768acbcb", + "name": "scrapy", + "sha256": "c56734f679ab89c0eb4236eb7a5e50c405813251411c41cb0635fe95ccb5b1a1", + "size": 394056, + "subdir": "linux-64", + "timestamp": 1677738215627, + "version": "2.8.0" + }, + "scrapy-2.8.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.4.6", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "lxml >=4.3.0", + "packaging", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=21.0.0", + "python >=3.9,<3.10.0a0", + "queuelib >=1.4.2", + "service_identity >=18.1.0", + "setuptools", + "tldextract", + "twisted >=18.9.0", + "w3lib >=1.17.0", + "zope.interface >=5.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a3500f6b7daa45fa9d14b62d61502ebf", + "name": "scrapy", + "sha256": "fd5e6fcb64967651f81b414d19e03f17cfafd42bf3c242978cdf9afb6e701c9e", + "size": 394026, + "subdir": "linux-64", + "timestamp": 1677738308082, + "version": "2.8.0" + }, + "seaborn-0.12.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "statsmodels >=0.10", + "scipy >=1.3" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17", + "pandas >=0.25", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e4885756e7a34697cdb551a33364d3b8", + "name": "seaborn", + "sha256": "5f373ae619e8316bead4716b8d3988251dd6c6c04c0f5e353e4d1972a64ea718", + "size": 495249, + "subdir": "linux-64", + "timestamp": 1666299239280, + "version": "0.12.0" + }, + "seaborn-0.12.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "statsmodels >=0.10", + "scipy >=1.3" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17", + "pandas >=0.25", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "24e30587d83d2b910b0a1991bdc09430", + "name": "seaborn", + "sha256": "cc4310a34ef5d8126890cbfbd9ecd16cdd5f737c574edf69f6da1fb3e4794238", + "size": 488138, + "subdir": "linux-64", + "timestamp": 1666299272918, + "version": "0.12.0" + }, + "seaborn-0.12.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "statsmodels >=0.10", + "scipy >=1.3" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17", + "pandas >=0.25", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d7c2157370301511b0f1c45d06153de", + "name": "seaborn", + "sha256": "b0e826af66e8c619333c1ba52d07e56d9a5218e9d7c5c8ac0c2d12e37b2bbdf1", + "size": 488290, + "subdir": "linux-64", + "timestamp": 1666299206213, + "version": "0.12.0" + }, + "seaborn-0.12.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "statsmodels >=0.10", + "scipy >=1.3" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17", + "pandas >=0.25", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5fffc93e1b8879a520a6ad94b3d9d66c", + "name": "seaborn", + "sha256": "395aab952598628a1ba110ba5f869906d53dfcd0c591113d8e9fa1ad499a95cc", + "size": 482848, + "subdir": "linux-64", + "timestamp": 1666299166245, + "version": "0.12.0" + }, + "seaborn-0.12.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "scipy >=1.3", + "statsmodels >=0.10" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17", + "pandas >=0.25", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6a9592ef69871ccd91efe185c008c8b6", + "name": "seaborn", + "sha256": "e6f97894155c7c6e0ac6b15c888ffd85df6575ac913ed1be2e5bfee1a9ffd7da", + "size": 498695, + "subdir": "linux-64", + "timestamp": 1669627850490, + "version": "0.12.1" + }, + "seaborn-0.12.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "scipy >=1.3", + "statsmodels >=0.10" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17", + "pandas >=0.25", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "067f4734873282b3506dad97c5d24a47", + "name": "seaborn", + "sha256": "9e644cfeccf0ac23a26c83105b844d93a22c7f712ce3860d7a9c4df411732e03", + "size": 491225, + "subdir": "linux-64", + "timestamp": 1669627887279, + "version": "0.12.1" + }, + "seaborn-0.12.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "scipy >=1.3", + "statsmodels >=0.10" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17", + "pandas >=0.25", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7b56c630623703734dc7f3b1413a21d9", + "name": "seaborn", + "sha256": "e5e980a235b2a2eb77fbf28c5eca7b0673048f80244c5e223289a60146443468", + "size": 491322, + "subdir": "linux-64", + "timestamp": 1669627957592, + "version": "0.12.1" + }, + "seaborn-0.12.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "scipy >=1.3", + "statsmodels >=0.10" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17", + "pandas >=0.25", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7601ada6aa8738111b1e61823bd84af4", + "name": "seaborn", + "sha256": "7bc5a104af8534994a362f83aa3ccbc3d2bbbac7ec069a65c8c89493b0cd49ff", + "size": 485282, + "subdir": "linux-64", + "timestamp": 1669627922048, + "version": "0.12.1" + }, + "seaborn-0.12.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "statsmodels >=0.10", + "scipy >=1.3" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17,!=1.24.0", + "pandas >=0.25", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5ce213541e78fdcd98f8692fc5091b33", + "name": "seaborn", + "sha256": "cae297016095513f9aed2cf1a8ffecd47d39ba76de6bd7abadc5c43894078d73", + "size": 506262, + "subdir": "linux-64", + "timestamp": 1673479293631, + "version": "0.12.2" + }, + "seaborn-0.12.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "statsmodels >=0.10", + "scipy >=1.3" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17,!=1.24.0", + "pandas >=0.25", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a24287cc380e080c445334be34c7cf4f", + "name": "seaborn", + "sha256": "3f58a57581d66f243800b6c18e06dbbc012645d50454c3659b96d2e3b6f862b1", + "size": 639719, + "subdir": "linux-64", + "timestamp": 1676845760936, + "version": "0.12.2" + }, + "seaborn-0.12.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "statsmodels >=0.10", + "scipy >=1.3" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17,!=1.24.0", + "pandas >=0.25", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a60198e9cee580882219330804410b42", + "name": "seaborn", + "sha256": "27a2f88e55ca1bb6d81c1db62336410362c984545d35cc1a3856d1958c1c52a3", + "size": 498989, + "subdir": "linux-64", + "timestamp": 1673479258559, + "version": "0.12.2" + }, + "seaborn-0.12.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "statsmodels >=0.10", + "scipy >=1.3" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17,!=1.24.0", + "pandas >=0.25", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a7d06bf1210c9c5af95b41117247a05", + "name": "seaborn", + "sha256": "11a7ffaf555c58b8cca8c66986bf71e24f5076ddba7d9d58670107dd72ee444e", + "size": 499467, + "subdir": "linux-64", + "timestamp": 1673479218547, + "version": "0.12.2" + }, + "seaborn-0.12.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "statsmodels >=0.10", + "scipy >=1.3" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17,!=1.24.0", + "pandas >=0.25", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "af0a7c19240063723bed83885c2bf980", + "name": "seaborn", + "sha256": "984a844f70b09eded18ea56930bebcc08531c30c51b0817405e60be6aba34b84", + "size": 493771, + "subdir": "linux-64", + "timestamp": 1673479330048, + "version": "0.12.2" + }, + "seaborn-0.8.0-py27h9d2aaa1_0.tar.bz2": { + "build": "py27h9d2aaa1_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "pandas", + "patsy", + "python >=2.7,<2.8.0a0", + "scipy", + "statsmodels" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2c721c72aa5a321f3441f15ae977d3b7", + "name": "seaborn", + "sha256": "44d799b01062b3c27a6eab65b6b7b87231f47db035da2bc4961233f22aeee04e", + "size": 339664, + "subdir": "linux-64", + "timestamp": 1505755899070, + "version": "0.8.0" + }, + "seaborn-0.8.0-py35h15a2772_0.tar.bz2": { + "build": "py35h15a2772_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "pandas", + "patsy", + "python >=3.5,<3.6.0a0", + "scipy", + "statsmodels" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "84d4d5a81708f5c4d4822ed9313b7a85", + "name": "seaborn", + "sha256": "0297db5fd3b7deff237bebed0b7bd2c7e7b353662705fa8b40b959c93123a6df", + "size": 344496, + "subdir": "linux-64", + "timestamp": 1505755921101, + "version": "0.8.0" + }, + "seaborn-0.8.0-py36h197244f_0.tar.bz2": { + "build": "py36h197244f_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "pandas", + "patsy", + "python >=3.6,<3.7.0a0", + "scipy", + "statsmodels" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "77d9ff3343938172b7b4436bd230ceef", + "name": "seaborn", + "sha256": "61b7e2784bd41185cb0f28ad68f57bb66d215156d503eff42f27b8bd8f4ff53c", + "size": 341171, + "subdir": "linux-64", + "timestamp": 1505755942820, + "version": "0.8.0" + }, + "seaborn-0.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "pandas", + "patsy", + "python >=2.7,<2.8.0a0", + "scipy", + "statsmodels" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "599b66f0621b909efb468e2bf14b9c85", + "name": "seaborn", + "sha256": "2d3dea7362c53da9de7368688234e5d5607fb9a130f31786b7071287285d5428", + "size": 341665, + "subdir": "linux-64", + "timestamp": 1530960883609, + "version": "0.8.1" + }, + "seaborn-0.8.1-py27h633ea1e_0.tar.bz2": { + "build": "py27h633ea1e_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "pandas", + "patsy", + "python >=2.7,<2.8.0a0", + "scipy", + "statsmodels" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "891ddfae37013f7b50bdeadaa3ee23da", + "name": "seaborn", + "sha256": "35278a7d7b75c08ca3558fdd1ac01ea419285d515d54460a17bed7c9cfc22730", + "size": 342018, + "subdir": "linux-64", + "timestamp": 1511297743219, + "version": "0.8.1" + }, + "seaborn-0.8.1-py35h04cba02_0.tar.bz2": { + "build": "py35h04cba02_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "pandas", + "patsy", + "python >=3.5,<3.6.0a0", + "scipy", + "statsmodels" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "49b767423260c5c3be3bd79418c66282", + "name": "seaborn", + "sha256": "75c60e28af7618887e6af0520262c0b30931063e1b40d271ed3d9761122c2e06", + "size": 346867, + "subdir": "linux-64", + "timestamp": 1511297747194, + "version": "0.8.1" + }, + "seaborn-0.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "pandas", + "patsy", + "python >=3.6,<3.7.0a0", + "scipy", + "statsmodels" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3b780bb84f0b97cc2484d9707eb710dc", + "name": "seaborn", + "sha256": "f20b70816b53dff72ab803e4b118f947ee2d4b0a8c2b4e85d2cf7ad9f51edfdb", + "size": 342611, + "subdir": "linux-64", + "timestamp": 1530960924478, + "version": "0.8.1" + }, + "seaborn-0.8.1-py36hfad7ec4_0.tar.bz2": { + "build": "py36hfad7ec4_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "pandas", + "patsy", + "python >=3.6,<3.7.0a0", + "scipy", + "statsmodels" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dc26b38936211aefc242cefbd4281fed", + "name": "seaborn", + "sha256": "4fe36fde92e88e85406fb649be3384dd633827be4367642c02a45d109c930516", + "size": 342862, + "subdir": "linux-64", + "timestamp": 1511297745632, + "version": "0.8.1" + }, + "seaborn-0.8.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "pandas", + "patsy", + "python >=3.7,<3.8.0a0", + "scipy", + "statsmodels" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1dccc9d0c1eea330b8fb6287d8bd98a9", + "name": "seaborn", + "sha256": "65cb05fb3820d2ca78d067f0bf46774f701f8189c681b7b91267195f5d0d8721", + "size": 342476, + "subdir": "linux-64", + "timestamp": 1530960965199, + "version": "0.8.1" + }, + "seaborn-0.9.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "matplotlib >=1.4.3", + "numpy >=1.9.3", + "pandas >=0.14.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.15.2", + "statsmodels >=0.5.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b2fdf720eb469e6024376aea68b185a5", + "name": "seaborn", + "sha256": "a6b5ce7cc535d00b3da8c012541176740cbd94e2f1e5e42979c37c11d88733d2", + "size": 382638, + "subdir": "linux-64", + "timestamp": 1532466972052, + "version": "0.9.0" + }, + "seaborn-0.9.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "matplotlib >=1.4.3", + "numpy >=1.9.3", + "pandas >=0.14.0", + "python >=3.5,<3.6.0a0", + "scipy >=0.15.2", + "statsmodels >=0.5.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8d2f669558ec59b2feba6b17bfb6b9a4", + "name": "seaborn", + "sha256": "26e62c078555c08fd0f38032ab7439dd81c492ecc035d66d8d186edcd27efc2f", + "size": 387024, + "subdir": "linux-64", + "timestamp": 1532467027243, + "version": "0.9.0" + }, + "seaborn-0.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "matplotlib >=1.4.3", + "numpy >=1.9.3", + "pandas >=0.14.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.15.2", + "statsmodels >=0.5.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "06cef3b9c80438f51e76a0651f0fd348", + "name": "seaborn", + "sha256": "61299c2b1f7c57d9df514737f8cd15cf8e59631a84e3ac801962157c1336eb78", + "size": 387912, + "subdir": "linux-64", + "timestamp": 1532466917942, + "version": "0.9.0" + }, + "seaborn-0.9.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "matplotlib >=1.4.3", + "numpy >=1.9.3", + "pandas >=0.14.0", + "python >=3.7,<3.8.0a0", + "scipy >=0.15.2", + "statsmodels >=0.5.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f752f919b821df93fef60ebcc1615b1e", + "name": "seaborn", + "sha256": "7e345896e764b48cc9925cea2c90a7c1ea056d44b0583565c9f935c505d97f6a", + "size": 388161, + "subdir": "linux-64", + "timestamp": 1532467027042, + "version": "0.9.0" + }, + "secretstorage-3.0.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5e3fce43d4ed5a45213e29613ac37c2e", + "name": "secretstorage", + "sha256": "2b9086338fb975a1e106ddd575dd16dd24db8ae0335b0ba33cd7754bbfeb4746", + "size": 21654, + "subdir": "linux-64", + "timestamp": 1529953333389, + "version": "3.0.1" + }, + "secretstorage-3.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "69f5e7a03ae66f611a4753133fd2c3c4", + "name": "secretstorage", + "sha256": "3e64fb65797aa1bf180fc5e8224b4db6610beedf1f7e3cfcd85fbf6dd1895c02", + "size": 21625, + "subdir": "linux-64", + "timestamp": 1529953271948, + "version": "3.0.1" + }, + "secretstorage-3.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b7ed20a72aa4b84aa791bfa3b61a8d1a", + "name": "secretstorage", + "sha256": "fcae0cf5c0db7499d3310b68ead517a0e44ab7a10ec1785a3a12418c842776e3", + "size": 21486, + "subdir": "linux-64", + "timestamp": 1530898181154, + "version": "3.0.1" + }, + "secretstorage-3.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8ad5064677ccbfdc0af3dde520d1d6ef", + "name": "secretstorage", + "sha256": "8b287468ea93f91007b2bf12e2935248ed4dade3bd7dc8ff0571b2b6c67c3226", + "size": 23155, + "subdir": "linux-64", + "timestamp": 1536264577924, + "version": "3.1.0" + }, + "secretstorage-3.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0313889e86b618928b19de48831098af", + "name": "secretstorage", + "sha256": "0e7a9fa9ab91b4a21f4895410d13d9c2d622bcb4ec6d90fc5571edf402c55e4f", + "size": 23164, + "subdir": "linux-64", + "timestamp": 1536264609469, + "version": "3.1.0" + }, + "secretstorage-3.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c9dac44de82aeb3310d6f81373c0bde6", + "name": "secretstorage", + "sha256": "5330cff547024d7e47dbbda2c9a97d9c2e076f7d19f86260f5a5b89093d8a69c", + "size": 23051, + "subdir": "linux-64", + "timestamp": 1536264579621, + "version": "3.1.0" + }, + "secretstorage-3.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "377acca018cb530057d20ab69c14f167", + "name": "secretstorage", + "sha256": "ade5219dbcae1d5f9413fc0d127d9a260e0bad3da49b1b9f32eaa6873b30b4a9", + "size": 24262, + "subdir": "linux-64", + "timestamp": 1552404413918, + "version": "3.1.1" + }, + "secretstorage-3.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "166e41a6826d53ed123caed5558e0815", + "name": "secretstorage", + "sha256": "cc9e590a2cf9a38eb4cb9cca8cbc3b0f5d68c368151eaf05cc8e688de4f96ba0", + "size": 24138, + "subdir": "linux-64", + "timestamp": 1552402583062, + "version": "3.1.1" + }, + "secretstorage-3.1.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "82106d3c12f5ecc780e479306184104a", + "name": "secretstorage", + "sha256": "8f97d148755ee3e8bfcfc01d97c96219e7728d8e9e66823e0f93069024ded9f3", + "size": 23866, + "subdir": "linux-64", + "timestamp": 1574170608854, + "version": "3.1.1" + }, + "secretstorage-3.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b3ea732ab779ce3c3a67c4c6ffbb8313", + "name": "secretstorage", + "sha256": "2470afbf89b0b4072797dcc9fed61b5d876beadd356e19971b8581167f1668c8", + "size": 26189, + "subdir": "linux-64", + "timestamp": 1580153967434, + "version": "3.1.2" + }, + "secretstorage-3.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "936ac6a9eabefbfe1ef7a5d6b341a21c", + "name": "secretstorage", + "sha256": "75d95105eca4834c17226f1dd2837367df02174b1fb2a2601d4494bc6200fe55", + "size": 26042, + "subdir": "linux-64", + "timestamp": 1580153874668, + "version": "3.1.2" + }, + "secretstorage-3.1.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aa08cad1a648805d26f6decd4acd5bd0", + "name": "secretstorage", + "sha256": "f4e8ca8490aa31190c832060677fbc88c22d5600e603631eaa464cd14281ca59", + "size": 23705, + "subdir": "linux-64", + "timestamp": 1594419247329, + "version": "3.1.2" + }, + "secretstorage-3.1.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3a9871b91c5ee3703f4726f5c8c8dba2", + "name": "secretstorage", + "sha256": "fdabf20d6bfa9a991e23f8eb3958b4ed7d83d85cfefda369108d8985553e29ef", + "size": 26093, + "subdir": "linux-64", + "timestamp": 1580153979066, + "version": "3.1.2" + }, + "secretstorage-3.3.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "25302be2a6b38de4378784285532b2fd", + "name": "secretstorage", + "sha256": "9a2938918793e594ac56d36163eb2bcef2dedade72be7c0be35b86b36e70520b", + "size": 24901, + "subdir": "linux-64", + "timestamp": 1606864791817, + "version": "3.3.0" + }, + "secretstorage-3.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dab774881a5b28535d9ed08a31f229f2", + "name": "secretstorage", + "sha256": "4a1d64d93b116f94fd84494399d13c3058d11ea929fd785396f680945f9f1fb0", + "size": 24757, + "subdir": "linux-64", + "timestamp": 1606864786861, + "version": "3.3.0" + }, + "secretstorage-3.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2b02e7d2c09bfa484040cb89c30e6d33", + "name": "secretstorage", + "sha256": "9721bacefc60c9a9726916e4a85cb6159feb66a70fe8c421dba2abf108db3c78", + "size": 24837, + "subdir": "linux-64", + "timestamp": 1606864767477, + "version": "3.3.0" + }, + "secretstorage-3.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7adfad0eda92232919e93c8ef095e05c", + "name": "secretstorage", + "sha256": "4b5b3565eb6e9ab44ddcfcb716ba4f82ad3ea73bb54a3f5b789111df0123dd84", + "size": 24854, + "subdir": "linux-64", + "timestamp": 1606864781423, + "version": "3.3.0" + }, + "secretstorage-3.3.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "297f1b1af9ef27fe13d6c6cd876840cd", + "name": "secretstorage", + "sha256": "3694e90ebd3e95944b210bd8aa9095e467d254ec01e646938bd5309185a4afb9", + "size": 24857, + "subdir": "linux-64", + "timestamp": 1640812919863, + "version": "3.3.1" + }, + "secretstorage-3.3.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography >=2.0", + "dbus >=1.13.18,<2.0a0", + "jeepney >=0.6", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "205ede278128b109e61ed300f9f81b8e", + "name": "secretstorage", + "sha256": "ca9aa817a3fb4989362a4469109fefa34402c3384069c7be75f7a0f875a7531b", + "size": 25285, + "subdir": "linux-64", + "timestamp": 1678709520804, + "version": "3.3.1" + }, + "secretstorage-3.3.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a68c4a9e6f92f9db7279d4c985fbf1b", + "name": "secretstorage", + "sha256": "0b7a62b08a7e41c9502c4a3c008d1f621d643ef1788732fd17ce942de5e0b9f1", + "size": 30279, + "subdir": "linux-64", + "timestamp": 1676823120339, + "version": "3.3.1" + }, + "secretstorage-3.3.1-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography >=2.0", + "dbus >=1.13.18,<2.0a0", + "jeepney >=0.6", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "71bd10b576f095ba2a9c7b3a80bcf992", + "name": "secretstorage", + "sha256": "3ccce20ad7b50784e0dfbb30927282df496b1b69e49c8856648b55c40cfbb388", + "size": 30194, + "subdir": "linux-64", + "timestamp": 1679339081474, + "version": "3.3.1" + }, + "secretstorage-3.3.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ad448bbe4157bdb0f51edaef341aea41", + "name": "secretstorage", + "sha256": "e3704449f3b315eab5aca0dfd7e06b86818193e068391d78b7c813bc62180f53", + "size": 24847, + "subdir": "linux-64", + "timestamp": 1614022923362, + "version": "3.3.1" + }, + "secretstorage-3.3.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0cb7421f002ffc81216ee77a6c971416", + "name": "secretstorage", + "sha256": "970688425e4435e46666b59704cc2d4704e012938df58b6a262ab36127299740", + "size": 24736, + "subdir": "linux-64", + "timestamp": 1614022922365, + "version": "3.3.1" + }, + "secretstorage-3.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2fba2bb014237433eb433573f0205883", + "name": "secretstorage", + "sha256": "d6db9a1e9ff8f61ba5ea82254d93ca354de24b66c9dd3f56ee4834aa544e9e78", + "size": 24834, + "subdir": "linux-64", + "timestamp": 1614022820453, + "version": "3.3.1" + }, + "secretstorage-3.3.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography >=2.0", + "dbus >=1.13.18,<2.0a0", + "jeepney >=0.6", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "da933e81a271550434d56abc94f8817a", + "name": "secretstorage", + "sha256": "808d9321e7ef98fd612640e800b3953bd6d71f764b0e44dd435aced2fc457502", + "size": 25160, + "subdir": "linux-64", + "timestamp": 1678709547289, + "version": "3.3.1" + }, + "secretstorage-3.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "edb6977d41a47f93bdeedb387dc5f05c", + "name": "secretstorage", + "sha256": "4ca09c65ea00c88d1c87a9b9bd7cb73ad6b77b224ec7bf82dfe6a65f20ea936d", + "size": 24821, + "subdir": "linux-64", + "timestamp": 1614022815930, + "version": "3.3.1" + }, + "secretstorage-3.3.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography >=2.0", + "dbus >=1.13.18,<2.0a0", + "jeepney >=0.6", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e3f03184fc1dd2e3fe5e559272261c2", + "name": "secretstorage", + "sha256": "c62d9cf456b88262c2a9351338811ccee37ac44e361f22622651343b8372ed5b", + "size": 25115, + "subdir": "linux-64", + "timestamp": 1678709572644, + "version": "3.3.1" + }, + "sed-4.4-h7b6447c_2.tar.bz2": { + "build": "h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-3", + "md5": "a9c541fd8e8375b98dd603899ac5e945", + "name": "sed", + "sha256": "3aae07d09ce9f60e7acaa395525adb08a0881b2ea998f9dc41770837b3b26f74", + "size": 202588, + "subdir": "linux-64", + "timestamp": 1597346946296, + "version": "4.4" + }, + "sed-4.8-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.2", + "libgcc-ng >=7.3.0" + ], + "license": "GPL-3", + "md5": "cf7fd03eb1f493dfed4d65ef7f1da70c", + "name": "sed", + "sha256": "ee52055fc31e75a673a90a19caf0d23aef0c908ee43ce81973179c4a41682d3a", + "size": 259897, + "subdir": "linux-64", + "timestamp": 1600482712427, + "version": "4.8" + }, + "selenium-3.11.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "77dfccbd9bd2931f4b20f248ab725336", + "name": "selenium", + "sha256": "ddc6eb54e3db14aaaeaf572b5b1fd94b9107c47f1957113162b63d59504d7e9c", + "size": 886781, + "subdir": "linux-64", + "timestamp": 1522790886570, + "version": "3.11.0" + }, + "selenium-3.11.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e4a03e8344e37e594a4b5da3826a5876", + "name": "selenium", + "sha256": "20a0584e47d29f1f70ab00f1612069b341d55b1fa126d01c164bad0613b90688", + "size": 882805, + "subdir": "linux-64", + "timestamp": 1522790515045, + "version": "3.11.0" + }, + "selenium-3.11.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "caf945dbff570a4d7eccb615a8a6ac10", + "name": "selenium", + "sha256": "1a25bb80ae5875de6d3e402c9e001d5d05d2d6b16ab71afa977332d5ff776d01", + "size": 879541, + "subdir": "linux-64", + "timestamp": 1522790897177, + "version": "3.11.0" + }, + "selenium-3.12.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0eac89147d74d4ec863159d02a68ec65", + "name": "selenium", + "sha256": "e370f8e9d90a49137ad914a897a9c3e381d46514ed2e854e8604870cc51f22d7", + "size": 908023, + "subdir": "linux-64", + "timestamp": 1529217366559, + "version": "3.12.0" + }, + "selenium-3.12.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "adf9976d81561a1d5bde68d69f8eb0e2", + "name": "selenium", + "sha256": "b3f057e3957e5d61c3a74b03ba284e9fc6e28da4583292251f9a460c404388fa", + "size": 909038, + "subdir": "linux-64", + "timestamp": 1529217408168, + "version": "3.12.0" + }, + "selenium-3.12.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4f3a4cb82df791f71659254b5edc1e2c", + "name": "selenium", + "sha256": "03374628b413b63a667529aede4b5bcf924836c7d0e454933fe532f21f76b000", + "size": 903387, + "subdir": "linux-64", + "timestamp": 1529217345693, + "version": "3.12.0" + }, + "selenium-3.12.0-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c8b64b6f27e6958d05b216da3bc7581c", + "name": "selenium", + "sha256": "d07a7f01506b658e22385834a33c9147d7b33990f41e7e96a3d7e5a25db97fbd", + "size": 903973, + "subdir": "linux-64", + "timestamp": 1530922430870, + "version": "3.12.0" + }, + "selenium-3.13.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b381989666dee237bd18ea9811619949", + "name": "selenium", + "sha256": "56bb07dac66e2d41d2ebea13b804f9127ce0a4c55cc77f6b9863f8dd89736604", + "size": 909114, + "subdir": "linux-64", + "timestamp": 1532881792230, + "version": "3.13.0" + }, + "selenium-3.13.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "25f575c51c5d797206a84b5f1f20eb88", + "name": "selenium", + "sha256": "860ed27eb2de1fc2b47e16dd90f4b6d0f4e386f034a5ae8a51b6be148f80b0df", + "size": 911145, + "subdir": "linux-64", + "timestamp": 1532881886959, + "version": "3.13.0" + }, + "selenium-3.13.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f9d57bebabfc184d29f8d7718571e537", + "name": "selenium", + "sha256": "fe662409ea5bb52a898785e0482291519f03747bfd6503e69003092d46b138ba", + "size": 905903, + "subdir": "linux-64", + "timestamp": 1532881741900, + "version": "3.13.0" + }, + "selenium-3.13.0-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8626973bdd627902830cde0ac08028c2", + "name": "selenium", + "sha256": "5c34f7f2f447b9ed2dbd49b0a3c5a1702c156581d5416d1813a4541211c65f70", + "size": 905908, + "subdir": "linux-64", + "timestamp": 1532881891427, + "version": "3.13.0" + }, + "selenium-3.14.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c025d34c8cccb1a04556df4997184c30", + "name": "selenium", + "sha256": "1a09517da70d10b32263ce9dd89e71322cdf2551f534d010e0c090be4dbfc6c6", + "size": 888035, + "subdir": "linux-64", + "timestamp": 1534396881379, + "version": "3.14.0" + }, + "selenium-3.14.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4087c4b48d95e816a89f960d073ec642", + "name": "selenium", + "sha256": "a697ccbee6aa576e6644f1a7e24eb38d87e11392f45cc81fa2eebd82fe2b0986", + "size": 883584, + "subdir": "linux-64", + "timestamp": 1534396928028, + "version": "3.14.0" + }, + "selenium-3.14.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f8aad5ede9c03411983aa55ef6c23338", + "name": "selenium", + "sha256": "51d7e984b26bc780cd309c33e66c553c94629e1f10a1f7ec4b0879f576e21642", + "size": 882016, + "subdir": "linux-64", + "timestamp": 1534804134783, + "version": "3.14.0" + }, + "selenium-3.14.0-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "329d4ebd397913fa74078b879a59fce5", + "name": "selenium", + "sha256": "c0ec0aaebb7f43f7ae1e8b714d7109de6652de67187a00afd8437fdddbe194fc", + "size": 881422, + "subdir": "linux-64", + "timestamp": 1534396959146, + "version": "3.14.0" + }, + "selenium-3.14.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4c8fab24022784ef0c9a0e71dc3c40d5", + "name": "selenium", + "sha256": "27c8307f600cd02c8f481b4ee619d09cc4173e43575daeb6e96898c7dc8fdf50", + "size": 890407, + "subdir": "linux-64", + "timestamp": 1539652839505, + "version": "3.14.1" + }, + "selenium-3.14.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7b35bb409d93a6c84f4c24d0ca669021", + "name": "selenium", + "sha256": "641ef0ef1a4b02a4065fa9a50c5da1d487fc6320a45ed191028aac128f6c47f7", + "size": 884132, + "subdir": "linux-64", + "timestamp": 1539652867608, + "version": "3.14.1" + }, + "selenium-3.14.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a8a1f38214593c9b11bf21e3ac6e571a", + "name": "selenium", + "sha256": "56472a518ad4b3e56395a9d7508eb354c679815506d27b2ae7329cf28c5ce0f3", + "size": 884209, + "subdir": "linux-64", + "timestamp": 1539652859554, + "version": "3.14.1" + }, + "selenium-3.141.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1d020f9e65e602f541f2d7c140d6c9b8", + "name": "selenium", + "sha256": "243dca20035f144acc2d6a09f6c1992a2ce29fe7c582d8be7c0a4bef53ddf5ef", + "size": 885252, + "subdir": "linux-64", + "timestamp": 1545122415273, + "version": "3.141.0" + }, + "selenium-3.141.0-py310h7f8727e_1000.tar.bz2": { + "build": "py310h7f8727e_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "109b36eaa13480eff6c0b1a36025c1de", + "name": "selenium", + "sha256": "554c3ca3addfa86c1fd2e60f78d807531d0464d32b336aa596aba912f03c89b7", + "size": 895081, + "subdir": "linux-64", + "timestamp": 1640794547696, + "version": "3.141.0" + }, + "selenium-3.141.0-py311h5eee18b_1000.tar.bz2": { + "build": "py311h5eee18b_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "95c92219173b1ef0e2a0023a007ad36e", + "name": "selenium", + "sha256": "3e55516184bc8aaf4fbde1a47de8e39b8359d0a4eb61c59db3a15c604f15d806", + "size": 939112, + "subdir": "linux-64", + "timestamp": 1676862029614, + "version": "3.141.0" + }, + "selenium-3.141.0-py36h27cfd23_1000.tar.bz2": { + "build": "py36h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "36679d17beed412f37500f7da43a43ac", + "name": "selenium", + "sha256": "f822a3ec029519c380155833102e9a13f44542fbfebe75310893a6cf211e08f9", + "size": 900888, + "subdir": "linux-64", + "timestamp": 1614267825447, + "version": "3.141.0" + }, + "selenium-3.141.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e14d771e5a31f6f9864ff9a455d92e59", + "name": "selenium", + "sha256": "4f141591e3b601ec7d47fb64d331425de5247a4d5b756523043f70c9861fa4a2", + "size": 883406, + "subdir": "linux-64", + "timestamp": 1545122413191, + "version": "3.141.0" + }, + "selenium-3.141.0-py37h14c3975_1001.tar.bz2": { + "build": "py37h14c3975_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2a07618e16fd140b4001aa0e5a310a14", + "name": "selenium", + "sha256": "304242296b662bdcf286ad679fa102e4c87efd8e0cb97aca4f7f2d2a10241ca1", + "size": 887849, + "subdir": "linux-64", + "timestamp": 1594420493940, + "version": "3.141.0" + }, + "selenium-3.141.0-py37h27cfd23_1000.tar.bz2": { + "build": "py37h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "01f45ea1a4a44f53661f54e7fa54f43e", + "name": "selenium", + "sha256": "12f302817cc7942c898f2c5c68b2895f4964a3c5e25f9accd6838bf8a51c3e63", + "size": 956419, + "subdir": "linux-64", + "timestamp": 1614267829152, + "version": "3.141.0" + }, + "selenium-3.141.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "755e34c43c93df76fae4464c1f87f1e9", + "name": "selenium", + "sha256": "2be0399cbf45156bcdafa939fd553266baee3ebe37d767c175025fea79533543", + "size": 883612, + "subdir": "linux-64", + "timestamp": 1545122411143, + "version": "3.141.0" + }, + "selenium-3.141.0-py38h27cfd23_1000.tar.bz2": { + "build": "py38h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4068dfa4c080dc74c247b0130725ed77", + "name": "selenium", + "sha256": "781ed8eb36950bef885a2a4a69c23dc1db1d6a8b0994a8a95e6857c7d1212fc4", + "size": 903314, + "subdir": "linux-64", + "timestamp": 1614267845315, + "version": "3.141.0" + }, + "selenium-3.141.0-py38h7b6447c_1000.tar.bz2": { + "build": "py38h7b6447c_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "05f737a6765b1660208878e02eda634c", + "name": "selenium", + "sha256": "fdac9a113adf2c50efc8d87508ee66a27d16f9ac7a777697d3f551fc649492f8", + "size": 968940, + "subdir": "linux-64", + "timestamp": 1573200367505, + "version": "3.141.0" + }, + "selenium-3.141.0-py39h27cfd23_1000.tar.bz2": { + "build": "py39h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a00b932546e364fd79d4560245da64ee", + "name": "selenium", + "sha256": "c3c29538255e8d1f11dba309c6c49f6c3e68d5614fd98497c251e46133b42aad", + "size": 964131, + "subdir": "linux-64", + "timestamp": 1614267848839, + "version": "3.141.0" + }, + "selenium-3.8.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "66e66e77c1088077be48bee81e2026d6", + "name": "selenium", + "sha256": "0a500dc18202af34054b543dfbd6232dacb36b75a817e6b35716c00a5237c846", + "size": 905018, + "subdir": "linux-64", + "timestamp": 1532968094879, + "version": "3.8.0" + }, + "selenium-3.8.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0bbb0ffb40e3136f5b98d9d0e5e9bfb7", + "name": "selenium", + "sha256": "f9c71f8d4c458c1b97393af329db89228755c88fbcf56a42aca99bb1710e5762", + "size": 901271, + "subdir": "linux-64", + "timestamp": 1532968112552, + "version": "3.8.0" + }, + "selenium-3.8.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a167b3278c83d6a6a09e37fb25be6c39", + "name": "selenium", + "sha256": "5a18166c7fac795aa27840ba4b4cfaaff0fdc5b3486f2ee25e44aac56cda6c9f", + "size": 905513, + "subdir": "linux-64", + "timestamp": 1532968029435, + "version": "3.8.0" + }, + "selenium-3.8.0-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "774d89fd59d414b2fdd6b12488f12fe7", + "name": "selenium", + "sha256": "453b9131a02cf0755d3850ff40c05e382796dd49cfe847b2944078dfa241b750", + "size": 905237, + "subdir": "linux-64", + "timestamp": 1532968111439, + "version": "3.8.0" + }, + "selenium-3.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a5da1126480b3274f6ef257f422f58bd", + "name": "selenium", + "sha256": "318d0d67fa1a3b159b460cb57c7b044a58bbc18077a760842b78dbb2a859b491", + "size": 886153, + "subdir": "linux-64", + "timestamp": 1517949476920, + "version": "3.8.1" + }, + "selenium-3.8.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b321d9371ad1b63d029923c7bc7dc4b1", + "name": "selenium", + "sha256": "2c5b08f14a01a6982a73f639b1f47ba1138e6e8efca11eca6d1ba71c6c515a7b", + "size": 882053, + "subdir": "linux-64", + "timestamp": 1517949491066, + "version": "3.8.1" + }, + "selenium-3.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "499271e2c5017ec7c23d5fa7ba8402c7", + "name": "selenium", + "sha256": "f7d54bc4f0ae17f75eb2acc72c3e072102f0569ae7c305765a9b95c71b9637ef", + "size": 878235, + "subdir": "linux-64", + "timestamp": 1517949506646, + "version": "3.8.1" + }, + "selenium-3.9.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8a2564f72ea9bb048c38e6a3a8be665e", + "name": "selenium", + "sha256": "9f94ce886b62e067b2363681b51e0df470db231ecac97923dc6a2068d589e4dd", + "size": 886418, + "subdir": "linux-64", + "timestamp": 1519238886803, + "version": "3.9.0" + }, + "selenium-3.9.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "77c68d716ebf590b9b682b8ca07ee25c", + "name": "selenium", + "sha256": "f051cf703c5143009372c8819f29fc121cba71eb660cdd9d4f1e87d7028a13ee", + "size": 881719, + "subdir": "linux-64", + "timestamp": 1519238898923, + "version": "3.9.0" + }, + "selenium-3.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f7a28902584252075dc4ee3765dd3657", + "name": "selenium", + "sha256": "21deee0ad047a86a7e539e0cec27ab10df751a8f9992af14b929ddff58820c09", + "size": 878876, + "subdir": "linux-64", + "timestamp": 1519238878234, + "version": "3.9.0" + }, + "semantic_version-2.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "57b1bdc0983d32639c9c835cd96f21b6", + "name": "semantic_version", + "sha256": "e70a32b4e5cab86eaeb01c9a9f40a4d38b0fd826fc98037bc4382a112b888d38", + "size": 19626, + "subdir": "linux-64", + "timestamp": 1538441950287, + "version": "2.6.0" + }, + "semver-2.7.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "21b0320b8e3b8559e03610536afa9875", + "name": "semver", + "sha256": "4775acc0d25cf504af612b85c8e34ee2085b74564136234051adc4ff54828a5f", + "size": 10823, + "subdir": "linux-64", + "timestamp": 1522880852724, + "version": "2.7.9" + }, + "semver-2.7.9-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "0f351ca606db014f11a44ede9cbc8717", + "name": "semver", + "sha256": "8234c3e96f2fda11297f7659f437d8457ae30319464f6e8b97715c3b2ce577d8", + "size": 11074, + "subdir": "linux-64", + "timestamp": 1522880870801, + "version": "2.7.9" + }, + "semver-2.7.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "36f55bd4b99d7ce9b338b7b731be26cd", + "name": "semver", + "sha256": "cffd518a4e39bcea830db226d1f1be8fbcae4a6eb87e44362c9498f5f393dcac", + "size": 11030, + "subdir": "linux-64", + "timestamp": 1522880870752, + "version": "2.7.9" + }, + "semver-2.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "7eab9584c50dababc89b95f4e12efa1b", + "name": "semver", + "sha256": "eb5ef62110adeb671a1350fdce2c5539f843817f1c501509c73f4d66a5f82e5c", + "size": 10716, + "subdir": "linux-64", + "timestamp": 1526937618653, + "version": "2.8.0" + }, + "semver-2.8.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "7ea7a78e0d1bafe037119610a19e6cd3", + "name": "semver", + "sha256": "6349ab6864c3b8f94bdb2163ab4467b095fe6038b7fcbfb15ad8fba367c6ef4b", + "size": 11000, + "subdir": "linux-64", + "timestamp": 1526937633433, + "version": "2.8.0" + }, + "semver-2.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "ba92a08ade3b4480aac95dff1cfd36f6", + "name": "semver", + "sha256": "484e4909fe140796146ed38cb76935af622c19ad805f10d273ec1b57ac584f9c", + "size": 10921, + "subdir": "linux-64", + "timestamp": 1526937602725, + "version": "2.8.0" + }, + "semver-2.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "217cec6c0e5096e54db7adf33bb66087", + "name": "semver", + "sha256": "ef2a097c853391da1eaf007f885fdc3d639fda71168219b4e7ce8c27481145b3", + "size": 10932, + "subdir": "linux-64", + "timestamp": 1530961004896, + "version": "2.8.0" + }, + "semver-2.8.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "78350a7c7cd7a5b61db8f99a9a01818d", + "name": "semver", + "sha256": "ca56af75164fe0eed8e7a319a5946930e705aad93f1a10a00e2ada24a276f0c7", + "size": 11577, + "subdir": "linux-64", + "timestamp": 1535508682869, + "version": "2.8.1" + }, + "semver-2.8.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "9e0cdc8f2e0085dbc9525779ffa953b3", + "name": "semver", + "sha256": "a710a14c451fb3af97ace38a3010f3af83fdd02907a64ddfe8496124ed647e44", + "size": 11891, + "subdir": "linux-64", + "timestamp": 1535508810960, + "version": "2.8.1" + }, + "semver-2.8.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "74ea16672b017e5fda800ea69f34db9e", + "name": "semver", + "sha256": "0fc95b9053920957640c010159a38321cb1abe713df69b17d2488d07d91f78fe", + "size": 11851, + "subdir": "linux-64", + "timestamp": 1535508741256, + "version": "2.8.1" + }, + "semver-2.8.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "6d50774723bc8747eec6a58538ef6eb8", + "name": "semver", + "sha256": "1e3504165c802c8f062bb41f5d4152be963e5e8b6b1dda7da9002996d1faecff", + "size": 11822, + "subdir": "linux-64", + "timestamp": 1535508822121, + "version": "2.8.1" + }, + "send2trash-1.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9114aac82be01039d9c20f3c3b7d4663", + "name": "send2trash", + "sha256": "c0486e69d535a5dc0b74fc3e169a24b99e1a6ecb582098d1a09473860acff518", + "size": 14691, + "subdir": "linux-64", + "timestamp": 1516378680161, + "version": "1.4.2" + }, + "send2trash-1.4.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5938727afddbbcdd6e4d7036e57ae3b7", + "name": "send2trash", + "sha256": "66aa70557a9bf3004bcf7ac93794621f1f2397390ed8ba0a1904758ed74aecbf", + "size": 14898, + "subdir": "linux-64", + "timestamp": 1516378701364, + "version": "1.4.2" + }, + "send2trash-1.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "616a166d42c990bed74d5987fe0b2ec3", + "name": "send2trash", + "sha256": "372b921be112e71f7db443baa31956a6643f593d27121d010061872ab423cad6", + "size": 14825, + "subdir": "linux-64", + "timestamp": 1516378759342, + "version": "1.4.2" + }, + "send2trash-1.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3777688c33cc097debcd687c7e06ad2d", + "name": "send2trash", + "sha256": "2991ba452d72062b20204b46d5cf6754726fc0a4b33806962b8fe77d88b6dcbd", + "size": 16217, + "subdir": "linux-64", + "timestamp": 1519146799026, + "version": "1.5.0" + }, + "send2trash-1.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "969f0877c3d24401fbf8f9d0b7adf1c4", + "name": "send2trash", + "sha256": "bfcaee74c853f1da1c99c3b439774c268045e3801a3024dfede89976ee97f388", + "size": 16432, + "subdir": "linux-64", + "timestamp": 1519146807677, + "version": "1.5.0" + }, + "send2trash-1.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "34dae48b43ff2de1f567ac414c2c955b", + "name": "send2trash", + "sha256": "9c85a909b1faf9f80baf4453c6d10cf776008ce28457005d7f87c10a8f15f265", + "size": 16362, + "subdir": "linux-64", + "timestamp": 1519146845083, + "version": "1.5.0" + }, + "send2trash-1.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "586e109f462cd606a9a69bd77234a7ff", + "name": "send2trash", + "sha256": "cc263310b5461cf47ca0c7f3c78d2dfcb1acd2501f988183ebfb8c2291c51465", + "size": 16302, + "subdir": "linux-64", + "timestamp": 1530734626903, + "version": "1.5.0" + }, + "send2trash-1.5.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0faa7b648ce79508a375bfa730403ed5", + "name": "send2trash", + "sha256": "ddc020ae8bb136f88eb72e3388af30c5490a706cbfe49358ecfcdc73c2c43b45", + "size": 16814, + "subdir": "linux-64", + "timestamp": 1573200396559, + "version": "1.5.0" + }, + "sentencepiece-0.1.95-py310hd09550d_0.tar.bz2": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a3a74d5eb35425c0353b35de91199bbb", + "name": "sentencepiece", + "sha256": "1b450da6b4c6e84d7cbf614b0c568602fe53805cf78f9ec9a738b44f72be62da", + "size": 8550919, + "subdir": "linux-64", + "timestamp": 1640794599235, + "version": "0.1.95" + }, + "sentencepiece-0.1.95-py311hdb19cb5_0.tar.bz2": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2f1f841dd45a8d3e629d7ae9bfde511d", + "name": "sentencepiece", + "sha256": "8b780b414856135574853e9af628befadc396d52b3953f9fcc2e3391e28a546a", + "size": 8475075, + "subdir": "linux-64", + "timestamp": 1676862110603, + "version": "0.1.95" + }, + "sentencepiece-0.1.95-py37hd09550d_0.tar.bz2": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d1088056cff391db35c72500d9b22840", + "name": "sentencepiece", + "sha256": "b65527812a13ec007527895a3d3feeae52fef1240a142fdd571aeb80045bba3c", + "size": 8398181, + "subdir": "linux-64", + "timestamp": 1635181253483, + "version": "0.1.95" + }, + "sentencepiece-0.1.95-py38hd09550d_0.tar.bz2": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e1028fbcd08b9c4a4250d6758cf84aaa", + "name": "sentencepiece", + "sha256": "b18175cdaac3217a62c2e1cf249bd85160830d1d3d5c73a2a1f702ab2e3c7511", + "size": 8487589, + "subdir": "linux-64", + "timestamp": 1635169662536, + "version": "0.1.95" + }, + "sentencepiece-0.1.95-py39hd09550d_0.tar.bz2": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c94bc784ba4cf6c2b47f35c307d90cb2", + "name": "sentencepiece", + "sha256": "3ff8cffd43623ff2c7e236c57008db70c7de6b31065d52f12c37e5decf5752ce", + "size": 8309586, + "subdir": "linux-64", + "timestamp": 1635181246668, + "version": "0.1.95" + }, + "sentry-sdk-1.9.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.10,<3.11.0a0", + "urllib3 >=1.10" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a3ca0cfbf584b536733c6e6192ca74b6", + "name": "sentry-sdk", + "sha256": "eeff6393a67b3bda7c4727eac34427ddfab225fe6becb347efd922ea8921fe1d", + "size": 204698, + "subdir": "linux-64", + "timestamp": 1659784625912, + "version": "1.9.0" + }, + "sentry-sdk-1.9.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.11,<3.12.0a0", + "urllib3 >=1.10" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "97f0231865d4539e504835f6e0aecc16", + "name": "sentry-sdk", + "sha256": "28df990325f1ae6541b47d8c4066f1b3faf03b396c4e5cdd0b97014e217f1d30", + "size": 282264, + "subdir": "linux-64", + "timestamp": 1676862135483, + "version": "1.9.0" + }, + "sentry-sdk-1.9.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.10" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "021b625c0cfcc7190f7d6ae901f733e5", + "name": "sentry-sdk", + "sha256": "7a4eeeda747450ac1adbfaa20d2eae3f79b69f091149bb496cb887f2db6ee210", + "size": 198081, + "subdir": "linux-64", + "timestamp": 1659784654720, + "version": "1.9.0" + }, + "sentry-sdk-1.9.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.8,<3.9.0a0", + "urllib3 >=1.10" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c2b1121e5ffd56bfaefb4c356b2ef884", + "name": "sentry-sdk", + "sha256": "3f02cafbb74cd818f03ce6730163feb4b34ebfda0261de6fe08c52d7c78621b3", + "size": 201710, + "subdir": "linux-64", + "timestamp": 1659784683453, + "version": "1.9.0" + }, + "sentry-sdk-1.9.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.9,<3.10.0a0", + "urllib3 >=1.10" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "6b89ef0c998a097e8656285c61e0c4ec", + "name": "sentry-sdk", + "sha256": "1a7409aeff9088ae827783437f3d4b9f568d6ed05cc492f112d077b0b92d3563", + "size": 202803, + "subdir": "linux-64", + "timestamp": 1659784583793, + "version": "1.9.0" + }, + "serf-1.3.9-h1c830df_0.tar.bz2": { + "build": "h1c830df_0", + "build_number": 0, + "depends": [ + "apr >=1.6.3,<2.0a0", + "expat >=2.2.6,<3.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "794721db232624e2b13d73f1c5d2a6ed", + "name": "serf", + "sha256": "ff08f3436bb4508249a90912226c150a0ea655068c0ad4add35c8a0c9bae9b3d", + "size": 99303, + "subdir": "linux-64", + "timestamp": 1540387751933, + "version": "1.3.9" + }, + "serf-1.3.9-ha066f01_0.tar.bz2": { + "build": "ha066f01_0", + "build_number": 0, + "depends": [ + "apr >=1.6.3,<2.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "f09e3effc1c50eebca9e634721d106c0", + "name": "serf", + "sha256": "04344111650ff2fa4a578f37058324ab076598ed53975f34f3231fd51d2eb8a7", + "size": 393094, + "subdir": "linux-64", + "timestamp": 1631803150008, + "version": "1.3.9" + }, + "serf-1.3.9-hb3b5fc1_0.tar.bz2": { + "build": "hb3b5fc1_0", + "build_number": 0, + "depends": [ + "apr >=1.6.3,<2.0a0", + "expat >=2.2.5,<3.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2n,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "b58a23bdad2372ebf698dbcc1037b94d", + "name": "serf", + "sha256": "739a5d2f8799617cb5d9d428a398c6975cb546946e45decafd7ff4a298f5780b", + "size": 96136, + "subdir": "linux-64", + "timestamp": 1513186030045, + "version": "1.3.9" + }, + "serverfiles-0.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "8863306776b827fb73168328902711d5", + "name": "serverfiles", + "sha256": "16306cbedb8ebca768308d6a576e51ad10bc009e7bf0d9f0567fb27814b5a022", + "size": 14948, + "subdir": "linux-64", + "timestamp": 1530902505940, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py27hb306768_0.tar.bz2": { + "build": "py27hb306768_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "337cdddcef572b81e3be56a8b9d2c596", + "name": "serverfiles", + "sha256": "0faa3dc7581b7734fb680dbece109cb31e1198468c4c8065c21d82e9dfd72098", + "size": 15191, + "subdir": "linux-64", + "timestamp": 1509226997442, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "f7b9e596b7cedd02caf52c4e541104b0", + "name": "serverfiles", + "sha256": "b6aa05c6622f77840deda4a0251fab5ff74336404302c4ae4ee3d8e2be28088f", + "size": 15598, + "subdir": "linux-64", + "timestamp": 1640794623379, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "c3da7db5b7e59fe004d767776fed074e", + "name": "serverfiles", + "sha256": "e12e9d09f8a63db1bfc01593509725997d31eb9bd09a745367b735d1947f0119", + "size": 20538, + "subdir": "linux-64", + "timestamp": 1676862149846, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py35h616d9ea_0.tar.bz2": { + "build": "py35h616d9ea_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "ead286b8405c135c8811feae0df68be3", + "name": "serverfiles", + "sha256": "f8535bcf3fea87104c3cf8a6bfb422f8a4b28ef4785367e98e81474ccae0842d", + "size": 15591, + "subdir": "linux-64", + "timestamp": 1509226997031, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "2681af64976a6a6037f2c32692a0ca33", + "name": "serverfiles", + "sha256": "b961c4562f4465e0498bf16aa1a0d97b055b0f5139ded410e1c6c41601bc583d", + "size": 15209, + "subdir": "linux-64", + "timestamp": 1530902478374, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "6696fa1c696f8bf44577f3f881f4e394", + "name": "serverfiles", + "sha256": "a61e68d4c1c229a2d6633fd97de68f6b6581e595b1d9518dfde643c7fe7817b0", + "size": 15976, + "subdir": "linux-64", + "timestamp": 1632829164564, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py36h79d4018_0.tar.bz2": { + "build": "py36h79d4018_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "8d4252f3e9cc032219da6cc67041238c", + "name": "serverfiles", + "sha256": "3b3d5f31f1e2970bca9be21c0d171933b525f9420631a79e87ee2135bf60c9e4", + "size": 15525, + "subdir": "linux-64", + "timestamp": 1509226998187, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "783eb35d68223f3e512e872262a508f4", + "name": "serverfiles", + "sha256": "fa053e0598b7f193ac25d794fcdb9c0c1205d7f9962ce020fbef660e94aa60e2", + "size": 15221, + "subdir": "linux-64", + "timestamp": 1530902449443, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "d373b416a73e370eede55cd5a8b16742", + "name": "serverfiles", + "sha256": "94f7363438bf97f7d9ed6b64121da439ae6642f54568abded2d2b51fb964ab02", + "size": 15976, + "subdir": "linux-64", + "timestamp": 1632838818180, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "a8152f9a62a77580b50b58957103da13", + "name": "serverfiles", + "sha256": "0886586ef2dcff0d36e4d1b5d9a023efedd2c6fd812d5899100a7dbf4ab373c3", + "size": 15695, + "subdir": "linux-64", + "timestamp": 1574237417834, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "33674722507150055f7f52f991533380", + "name": "serverfiles", + "sha256": "19029c40dbee412bfcf35ca1817e7e7ba431fe223b54849f0f2ab5bb25d68e5d", + "size": 15950, + "subdir": "linux-64", + "timestamp": 1632839542130, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "1a8b1e27b072dddb36e73db77e8d8a2a", + "name": "serverfiles", + "sha256": "779970cd68f4754a66053deca859f1e23a2b4c9e04a104d27f8a0b03ae08664e", + "size": 16007, + "subdir": "linux-64", + "timestamp": 1632839543777, + "version": "0.2.1" + }, + "serverfiles-0.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "5c1b6d02316931482de79f46db7085d8", + "name": "serverfiles", + "sha256": "dfd936b52c893b05d1f348fe2bce5a5a8cec5074ed9e7cd9c30179f35f9a4db5", + "size": 15220, + "subdir": "linux-64", + "timestamp": 1545124347538, + "version": "0.3.0" + }, + "serverfiles-0.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "24402b35d38315751cfd1bb0ac854454", + "name": "serverfiles", + "sha256": "a1e3dac438a30de844a30d6b5f21bc658f1019de9e9df5ddf2969683872d4945", + "size": 15465, + "subdir": "linux-64", + "timestamp": 1545124409226, + "version": "0.3.0" + }, + "serverfiles-0.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "318a7d325491ae40e25a9719b617b306", + "name": "serverfiles", + "sha256": "62b6a194b83ef60ae11f83f025654cead44d2422908a117033fc8dcc6e36ad55", + "size": 15518, + "subdir": "linux-64", + "timestamp": 1545124388389, + "version": "0.3.0" + }, + "serverfiles-0.3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "f162e18eab2bf5324fe7c2689facdd50", + "name": "serverfiles", + "sha256": "db1efdcafd9f4e00c2853f9796a4cea0e84d9fe124471df46215b91a37d9ed9a", + "size": 16062, + "subdir": "linux-64", + "timestamp": 1596700983108, + "version": "0.3.0" + }, + "serverfiles-0.3.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "6e34cbebe7b8140c3e93050ce2665806", + "name": "serverfiles", + "sha256": "501b50fa2deab8bdbe735616a324e30fc122ad3e92ad1b97a45b43140b4673ad", + "size": 15760, + "subdir": "linux-64", + "timestamp": 1611344892867, + "version": "0.3.1" + }, + "serverfiles-0.3.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "b51e8d2df2cd82f77fc267d93e00a40a", + "name": "serverfiles", + "sha256": "25e9754d63369db84f734302215aab733b674a3ebdcf24159f970a5df6a96abe", + "size": 15710, + "subdir": "linux-64", + "timestamp": 1611344875775, + "version": "0.3.1" + }, + "serverfiles-0.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "3c0f5ed6d8cb55d41961e4644ee96ef6", + "name": "serverfiles", + "sha256": "c16171ea0b594c8e090660cdafa80742da2f705503cca36386781d4a6ba26f9a", + "size": 15759, + "subdir": "linux-64", + "timestamp": 1611344886688, + "version": "0.3.1" + }, + "serverfiles-0.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "b168861acf58c0ecc0bd8d0e10c27d09", + "name": "serverfiles", + "sha256": "2f5e381e819297c86d95110a96637cc52a3344a93df4708ba0b47ba51407c232", + "size": 15823, + "subdir": "linux-64", + "timestamp": 1611344877689, + "version": "0.3.1" + }, + "service_identity-17.0.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "pyasn1", + "pyasn1-modules", + "pyopenssl >=0.12", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e73879a9d37372067f95f337504ccf7e", + "name": "service_identity", + "sha256": "e92068acfb63044c9955f30cd2477cd59315656c910ff6a28a4d852370fc0ee9", + "size": 18437, + "subdir": "linux-64", + "timestamp": 1530919658746, + "version": "17.0.0" + }, + "service_identity-17.0.0-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "pyasn1", + "pyasn1-modules", + "pyopenssl >=0.12", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48f0d660446cd5980b1768217f70af7d", + "name": "service_identity", + "sha256": "7012e1038c376e52481bb468803b65d27097ffac87aa98ca3aca942542894fb3", + "size": 18703, + "subdir": "linux-64", + "timestamp": 1534351123401, + "version": "17.0.0" + }, + "service_identity-17.0.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "pyasn1", + "pyasn1-modules", + "pyopenssl >=0.12", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0fa7f51323acdab84139ebc19fcf41a7", + "name": "service_identity", + "sha256": "a3117d3e77de6992da26b794315f2eac73d501193a4d081ba81895103bf8b8ad", + "size": 18702, + "subdir": "linux-64", + "timestamp": 1530919597863, + "version": "17.0.0" + }, + "service_identity-17.0.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "pyasn1", + "pyasn1-modules", + "pyopenssl >=0.12", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3b7359f87b6447d466b61ba84b9a8de", + "name": "service_identity", + "sha256": "bb77a0b05680fb6eee3515938019ef270996cb73cde9996a87aeeb0e4e667f50", + "size": 18747, + "subdir": "linux-64", + "timestamp": 1530919628643, + "version": "17.0.0" + }, + "service_identity-18.1.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "cryptography", + "ipaddress", + "pyasn1", + "pyasn1-modules", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "189a7a814dfa253d7a6087fa015566d1", + "name": "service_identity", + "sha256": "df0aa6c795c6ee96006e9658c7ea90024dca65da080ab484e11b282db123d010", + "size": 19777, + "subdir": "linux-64", + "timestamp": 1545105300765, + "version": "18.1.0" + }, + "service_identity-18.1.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "cryptography", + "pyasn1", + "pyasn1-modules", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f89177ef7638fbc29361122b3afb3b2f", + "name": "service_identity", + "sha256": "ef357698c203f0a9d541a79ba1cfe82224a60f6fc5ee1dcdd16540ff9085cd92", + "size": 20121, + "subdir": "linux-64", + "timestamp": 1545105324139, + "version": "18.1.0" + }, + "service_identity-18.1.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "cryptography", + "pyasn1", + "pyasn1-modules", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96b9f7cdc6e2201a1e028204f792ee5c", + "name": "service_identity", + "sha256": "b71b96518524bb97234c811e7d6a213d7725fb76e4c45863e9cae0373081fa1a", + "size": 20176, + "subdir": "linux-64", + "timestamp": 1545105324968, + "version": "18.1.0" + }, + "setproctitle-1.1.10-py27h7b6447c_1001.tar.bz2": { + "build": "py27h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "684c3115a08a3fe7b6d14c7a83bfee64", + "name": "setproctitle", + "sha256": "e14f251b1863278bdda97383c595f4484f94c117de523b3ffbe5b4d451721df6", + "size": 16921, + "subdir": "linux-64", + "timestamp": 1579609786682, + "version": "1.1.10" + }, + "setproctitle-1.1.10-py36h7b6447c_1001.tar.bz2": { + "build": "py36h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9dbf697721be5d3ed4672716790b4238", + "name": "setproctitle", + "sha256": "832b73e561c3a27b59bc1c772bdae76db09f0f93304b6f42f10970993047929b", + "size": 17347, + "subdir": "linux-64", + "timestamp": 1579609683224, + "version": "1.1.10" + }, + "setproctitle-1.1.10-py37h7b6447c_1001.tar.bz2": { + "build": "py37h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "62fe3e148840731bca2af797175c67dc", + "name": "setproctitle", + "sha256": "6eeed765cfcd9696c0ebba9c2f17e0714a4afaaf7be261b9dc29a5d11aad4289", + "size": 17384, + "subdir": "linux-64", + "timestamp": 1579609803973, + "version": "1.1.10" + }, + "setproctitle-1.1.10-py38h7b6447c_1001.tar.bz2": { + "build": "py38h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e0f611ba6a42b7725caf41b9a63d5ebd", + "name": "setproctitle", + "sha256": "c676c32048ef018e7143c32759dbc7af2f106108fe4e6039f4485b9ecf928d8f", + "size": 17389, + "subdir": "linux-64", + "timestamp": 1579609813106, + "version": "1.1.10" + }, + "setproctitle-1.1.10-py39h7f8727e_1001.tar.bz2": { + "build": "py39h7f8727e_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0df84e0d80facaf735194fd88a8bc303", + "name": "setproctitle", + "sha256": "b0ae3b5d82e166be534f25242f3a3f7a11786a6d13d3eeee828631351abfa37f", + "size": 17550, + "subdir": "linux-64", + "timestamp": 1626467259393, + "version": "1.1.10" + }, + "setproctitle-1.2.2-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "350864b7185f45225e870a31c9dfe273", + "name": "setproctitle", + "sha256": "931fa4489745aa044702fa08ea470823a905e7c9f35ba6502b8d0278c1587154", + "size": 40040, + "subdir": "linux-64", + "timestamp": 1640794647775, + "version": "1.2.2" + }, + "setproctitle-1.2.2-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6cca3d94138f3880fb5f10e4e8d4dc8f", + "name": "setproctitle", + "sha256": "a6a2bf3d49845032b131c6392e188e663643515e32a7e7f0b912b1e12b040b44", + "size": 16670, + "subdir": "linux-64", + "timestamp": 1676838805411, + "version": "1.2.2" + }, + "setproctitle-1.2.2-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8a3eea17118dc39f868e98a01a88f5b8", + "name": "setproctitle", + "sha256": "82b222d785061195680d593584b18d73dcc83a5e1f87bff0d4f0f8c3ca07059a", + "size": 16373, + "subdir": "linux-64", + "timestamp": 1611599935088, + "version": "1.2.2" + }, + "setproctitle-1.2.2-py36h27cfd23_1004.tar.bz2": { + "build": "py36h27cfd23_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f90588a1de84f7bd78ae7a47408101f8", + "name": "setproctitle", + "sha256": "f7ab248b7a96c8711d59499aa82b2bf346b3dc78f3fce0f465a6101a85d83ae3", + "size": 16396, + "subdir": "linux-64", + "timestamp": 1611517605869, + "version": "1.2.2" + }, + "setproctitle-1.2.2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "085f180b0d53cba0c47ea2fcabd93670", + "name": "setproctitle", + "sha256": "4d1d997d0609a12ece5c71d9af847688c310a67bcd853832158ce8e5c14ad757", + "size": 16390, + "subdir": "linux-64", + "timestamp": 1611599964185, + "version": "1.2.2" + }, + "setproctitle-1.2.2-py37h27cfd23_1004.tar.bz2": { + "build": "py37h27cfd23_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "fdf21ee14891e4bc89c00c3dc4dccb14", + "name": "setproctitle", + "sha256": "6a9ff7eb6bd11ed129658aed0fb7af39dee5fb137d16fe6c5954c64ba16969d2", + "size": 16392, + "subdir": "linux-64", + "timestamp": 1611517603046, + "version": "1.2.2" + }, + "setproctitle-1.2.2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7f4cf5bf1fc0456510e6aa88b9d058f4", + "name": "setproctitle", + "sha256": "76fe94b9b69a1c5b7d6796d8c591c7669217548a19a6e2ebbd1bf2470f6f20fe", + "size": 16467, + "subdir": "linux-64", + "timestamp": 1611599962239, + "version": "1.2.2" + }, + "setproctitle-1.2.2-py38h27cfd23_1004.tar.bz2": { + "build": "py38h27cfd23_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9194219a826f0fe43ac96e1fc2e66a5f", + "name": "setproctitle", + "sha256": "211d77c41ca0e412282023fe48725768c560215e2e4d00aa0d872c9cd0248a5d", + "size": 16459, + "subdir": "linux-64", + "timestamp": 1611517605173, + "version": "1.2.2" + }, + "setproctitle-1.2.2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "37ce95af0d0dbaa7a4c5f1327dca0a03", + "name": "setproctitle", + "sha256": "1b403a7e93ec1f23be3b9b54829414c575a5bc7a8307503c8571f4f453013f70", + "size": 16461, + "subdir": "linux-64", + "timestamp": 1611599925694, + "version": "1.2.2" + }, + "setproctitle-1.2.2-py39h27cfd23_1004.tar.bz2": { + "build": "py39h27cfd23_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c77c8cf6035ad09b6f9a8c133c499dcf", + "name": "setproctitle", + "sha256": "77ea5a5402013bba71c154262525c6a405cca68c0ce52be3d3942f35e70f7362", + "size": 16483, + "subdir": "linux-64", + "timestamp": 1611517581520, + "version": "1.2.2" + }, + "setuptools-36.5.0-py27h68b189e_0.tar.bz2": { + "build": "py27h68b189e_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8e6e0cb961d12ecb2fe73056566d350", + "name": "setuptools", + "sha256": "d7c40b897ad7d35b915c306501ebbcaa9468910717959cb8d37487e31cbd0b93", + "size": 514809, + "subdir": "linux-64", + "timestamp": 1505957364946, + "version": "36.5.0" + }, + "setuptools-36.5.0-py35ha8c1747_0.tar.bz2": { + "build": "py35ha8c1747_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "94967e9ab358d5a09691d0af1cded648", + "name": "setuptools", + "sha256": "b3d97b25fbaec03fd5d711df8e8f3f8e98b9ab2c1238f81510eacd85f6adcce9", + "size": 524150, + "subdir": "linux-64", + "timestamp": 1505957384298, + "version": "36.5.0" + }, + "setuptools-36.5.0-py36he42e2e1_0.tar.bz2": { + "build": "py36he42e2e1_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb1383539629db998105faf7e91e2bc7", + "name": "setuptools", + "sha256": "e7778f99150e41fc7cdc8154965202dc8777c79da7ae974f98a39591c27245e5", + "size": 523981, + "subdir": "linux-64", + "timestamp": 1505957403818, + "version": "36.5.0" + }, + "setuptools-38.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17c8083ab9c261df0894428a040e27a9", + "name": "setuptools", + "sha256": "d94646f8bb2422173759b2f541f17d024e6d83b424d7d0ea2c32e21048fd5a1e", + "size": 521745, + "subdir": "linux-64", + "timestamp": 1515791186148, + "version": "38.4.0" + }, + "setuptools-38.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff4981b1f7e89993798860bd8446e197", + "name": "setuptools", + "sha256": "d69d1b4e5a7ff6b2b3efb5ae577816e8aea2a2784477935eacb4c4a43ceb9644", + "size": 537807, + "subdir": "linux-64", + "timestamp": 1515791215210, + "version": "38.4.0" + }, + "setuptools-38.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9699b9f41aa6659602b4280bce91d438", + "name": "setuptools", + "sha256": "9db6660fbf49350e011ba458534a78354f25cb93d1c19dadb0c5681e6ff1bca2", + "size": 537213, + "subdir": "linux-64", + "timestamp": 1515791165259, + "version": "38.4.0" + }, + "setuptools-38.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d69247530ad37ebbbacf2a9182779dc", + "name": "setuptools", + "sha256": "7347f822292e15f67378689fbb1b8d682595c0e3e8b981276b01aca94830ccbf", + "size": 522298, + "subdir": "linux-64", + "timestamp": 1519147905075, + "version": "38.5.1" + }, + "setuptools-38.5.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4589c36b354703db6f3ae4ca4b9e4dab", + "name": "setuptools", + "sha256": "c071e7002ac8a73011ed687f03adf82f3adcdd9eba57c81e4f2f01de7d80d424", + "size": 538275, + "subdir": "linux-64", + "timestamp": 1519147859232, + "version": "38.5.1" + }, + "setuptools-38.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "671e6ff1c688821af1ea025e903dd02d", + "name": "setuptools", + "sha256": "51f2f1276e2581ea44e172d5adef5276e1f7b01ab3a20fd64a96dc9b371f1496", + "size": 537481, + "subdir": "linux-64", + "timestamp": 1519147922362, + "version": "38.5.1" + }, + "setuptools-39.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77a95fbd16ef3a0eff3621040b08035f", + "name": "setuptools", + "sha256": "8da440e00ec439986df24867790564e7fe7928a4373cc21fd454e68b2777b7a0", + "size": 596136, + "subdir": "linux-64", + "timestamp": 1522338171542, + "version": "39.0.1" + }, + "setuptools-39.0.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af4ce46d4d39c49686f31d7ab24be82e", + "name": "setuptools", + "sha256": "7f778fba4e0a9f8180b38908c1603fad4b21b1c5806c39668eb6ed969f73ce4d", + "size": 577958, + "subdir": "linux-64", + "timestamp": 1522338176081, + "version": "39.0.1" + }, + "setuptools-39.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85b5bcbe5d0a237c1eb6f632596f4a9b", + "name": "setuptools", + "sha256": "fed7f7c48362acccacd148f3c0967423fe376a8087a3b8387cf9edb71fad8718", + "size": 562604, + "subdir": "linux-64", + "timestamp": 1522338148760, + "version": "39.0.1" + }, + "setuptools-39.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e9af0edece263f886e47b21f536cf35", + "name": "setuptools", + "sha256": "d7d100a2415d9f650608582c63c00d675b0975f26bd6d98497b3092ccc7499a7", + "size": 595745, + "subdir": "linux-64", + "timestamp": 1525118802038, + "version": "39.1.0" + }, + "setuptools-39.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f61841cd6eb6196e7938bd07e382837b", + "name": "setuptools", + "sha256": "ebd9beff5d7201a75af53c3da972339a0d2d5c7c361c50f366efcc3350be8a9b", + "size": 576447, + "subdir": "linux-64", + "timestamp": 1525118828146, + "version": "39.1.0" + }, + "setuptools-39.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ea0dda11cd6687ab0a509894d275060", + "name": "setuptools", + "sha256": "fe2c6cc8142ce4e4f106a5cb931aedd325a5f2e803cec4e7643f2ae5efaab37b", + "size": 563597, + "subdir": "linux-64", + "timestamp": 1525118829126, + "version": "39.1.0" + }, + "setuptools-39.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ad4777017a18cd995f5920687203015", + "name": "setuptools", + "sha256": "a8bbf35be69906545272632440c45b3343c73c53edd3c3c175ab5b7a3e4ea4f6", + "size": 562979, + "subdir": "linux-64", + "timestamp": 1534955777535, + "version": "39.1.0" + }, + "setuptools-39.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b77764d4db6ab67726e3957b6c2eb004", + "name": "setuptools", + "sha256": "47680ab0990044f18d5a074695b5774595106254691fdd46aca3ecd1cc9aeb90", + "size": 597443, + "subdir": "linux-64", + "timestamp": 1527793493920, + "version": "39.2.0" + }, + "setuptools-39.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "879c8d8005a8c94ee25ab1a5d5d6d20b", + "name": "setuptools", + "sha256": "15f5150dd46c2fd4b9ba1c61891349075bc7b46139c705c70f690809ac1c1f94", + "size": 578669, + "subdir": "linux-64", + "timestamp": 1527793518181, + "version": "39.2.0" + }, + "setuptools-39.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d47d50943fb337e6bf950485a60544cb", + "name": "setuptools", + "sha256": "432bf39d8299010834d8c89f5cef1ef4d179e246fa76f2c827e4f045d4ab75de", + "size": 564050, + "subdir": "linux-64", + "timestamp": 1527793474251, + "version": "39.2.0" + }, + "setuptools-39.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9dc818e5acfa239cb3524fa2840910ac", + "name": "setuptools", + "sha256": "e3afba90100a0334bf44babfef354cda5b79c3a82daec818fc5f577a0468bf11", + "size": 563664, + "subdir": "linux-64", + "timestamp": 1530212487933, + "version": "39.2.0" + }, + "setuptools-40.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e72503c1421bef6d930766f94d854fa", + "name": "setuptools", + "sha256": "e8781f0a153c7395713b5fb52e443049799d5bcb2d89d313a510948dfd56e5a0", + "size": 597077, + "subdir": "linux-64", + "timestamp": 1532987077156, + "version": "40.0.0" + }, + "setuptools-40.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b1b301b6fc79bdd863b468922c17408", + "name": "setuptools", + "sha256": "b29faddadce20e8b6576ae528c360f55ffa4e22bc5d2a6f1d67505848ce4e6e8", + "size": 579211, + "subdir": "linux-64", + "timestamp": 1532987103363, + "version": "40.0.0" + }, + "setuptools-40.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "330bb154814275c3dc3114c3cca08301", + "name": "setuptools", + "sha256": "dfb8f37548d335636271b533843762f7687f784d348be2a4a492dcc45535f24b", + "size": 564228, + "subdir": "linux-64", + "timestamp": 1532987061652, + "version": "40.0.0" + }, + "setuptools-40.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4b51854be4c80cf203c3042847b7620c", + "name": "setuptools", + "sha256": "072854ec2bf326144ee9d647304d1c9a4dfb3e28a33766d08a9fa0f022371425", + "size": 564198, + "subdir": "linux-64", + "timestamp": 1532987108030, + "version": "40.0.0" + }, + "setuptools-40.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4974efcf8cf2b7e9e35f8f64d712860", + "name": "setuptools", + "sha256": "0a7dbf8bd4fec317dafd5e01b811eb36b8b9c557bfa14a3724c91df910cf6a9d", + "size": 599521, + "subdir": "linux-64", + "timestamp": 1535392051767, + "version": "40.2.0" + }, + "setuptools-40.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95c61cce07ae475fd8bb15864eb94e42", + "name": "setuptools", + "sha256": "ae5fd77cfd3ade815b399b8c4421d14be1cabca5d971a95b792cca89c57294b7", + "size": 584244, + "subdir": "linux-64", + "timestamp": 1535391599974, + "version": "40.2.0" + }, + "setuptools-40.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f0057a1d590bae600f4bb7bfd6d28eb7", + "name": "setuptools", + "sha256": "15e2102bcc8a2fd2c0b383ee3bc6861a5e54e0492da714f079ea9a09a66a2aba", + "size": 569383, + "subdir": "linux-64", + "timestamp": 1535391583771, + "version": "40.2.0" + }, + "setuptools-40.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bdd5974505ff4305c4b74954d93938e9", + "name": "setuptools", + "sha256": "70e7fd5907553677339601eb26997e2dc3ad0e2313f6f53f6121005daa55e201", + "size": 567555, + "subdir": "linux-64", + "timestamp": 1535392084778, + "version": "40.2.0" + }, + "setuptools-40.4.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e396f795ddf96c1403143ca4c7f0c54", + "name": "setuptools", + "sha256": "da7eacb2569cd7dece2f2de30d92961112a769195a8c81b5062763b442ce7090", + "size": 600858, + "subdir": "linux-64", + "timestamp": 1538579451439, + "version": "40.4.3" + }, + "setuptools-40.4.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98381b12236df183c8eb0d3a1679a26e", + "name": "setuptools", + "sha256": "43b978dc07aec286257164c3d9e3298073d82c57bf97f51870e558ed7b88068e", + "size": 568478, + "subdir": "linux-64", + "timestamp": 1538579460039, + "version": "40.4.3" + }, + "setuptools-40.4.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43cd915f601934e775d0fc5b6b7a0c6c", + "name": "setuptools", + "sha256": "e023c325a5260cf3f17877e12085db2cfcdd76121628988d26f3f03df4a100ef", + "size": 569365, + "subdir": "linux-64", + "timestamp": 1538579510203, + "version": "40.4.3" + }, + "setuptools-40.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c17537a5c6462112bd19c65813c84d2", + "name": "setuptools", + "sha256": "e4861fc399cf30399c9650655616a61e826cc8db19e66c53d97cc92e329c48d8", + "size": 628786, + "subdir": "linux-64", + "timestamp": 1541049267742, + "version": "40.5.0" + }, + "setuptools-40.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e77f8025c2382b51b92c4b733bf647c5", + "name": "setuptools", + "sha256": "d2f83e53b63f2f841ee3be9f48e71d333e895a82b241cc262d47230cbd011933", + "size": 624549, + "subdir": "linux-64", + "timestamp": 1541049265355, + "version": "40.5.0" + }, + "setuptools-40.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34a68e20a3d24a309266860d02347706", + "name": "setuptools", + "sha256": "9be288a65b999625f80a7911c7c89b79b6a70df86ecccf4d81e7abf355cf9977", + "size": 629418, + "subdir": "linux-64", + "timestamp": 1541049254033, + "version": "40.5.0" + }, + "setuptools-40.6.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "350667aa4938a83d6fd47ab7c8902332", + "name": "setuptools", + "sha256": "c748aae0f8c7520d3228f55bb9ddd6c6c2d23baa7bb55f58389c9f85e2351125", + "size": 657432, + "subdir": "linux-64", + "timestamp": 1542394743281, + "version": "40.6.2" + }, + "setuptools-40.6.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ff570b87a6050d17adedd152457daf7", + "name": "setuptools", + "sha256": "209eb214d15044cf652f4fc80009a217e168671caf3e95dc43b09a8f7487c3cd", + "size": 618291, + "subdir": "linux-64", + "timestamp": 1542394753122, + "version": "40.6.2" + }, + "setuptools-40.6.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52b0ae588198227439a6a0511c8d2a5f", + "name": "setuptools", + "sha256": "5e28757ba4ff6c7b3245f7b255185bf3127c5162b83745bdc2d504eb9b4c0025", + "size": 616984, + "subdir": "linux-64", + "timestamp": 1542394739111, + "version": "40.6.2" + }, + "setuptools-40.6.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31436d7efec9caaac0c812f56f942ad8", + "name": "setuptools", + "sha256": "2b40130f02f3a10570f9a7ad0fa4c77718ef0d8d0e98ef22875daadf11fff233", + "size": 642522, + "subdir": "linux-64", + "timestamp": 1545069686566, + "version": "40.6.3" + }, + "setuptools-40.6.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8af35d901de8a9dcd17fe0b1d64476f", + "name": "setuptools", + "sha256": "3c2a2152922b8fe9ec1d1897db1c99232b17a20b21ee88277af372ce985a96b2", + "size": 639984, + "subdir": "linux-64", + "timestamp": 1545069709853, + "version": "40.6.3" + }, + "setuptools-40.6.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7fee1e5cb9c64775fe3e32ae18de73d2", + "name": "setuptools", + "sha256": "20e45e9acc3c2dd04696e6bb5799736554317207f585ab0c109b58dc60b23104", + "size": 632193, + "subdir": "linux-64", + "timestamp": 1545069728450, + "version": "40.6.3" + }, + "setuptools-40.7.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b832ecc85ba94b58e8d88cd654a115c", + "name": "setuptools", + "sha256": "a8421a622b68c2d41da549c1ee7cd4f6d6fbcaa9817a6dfd98b0b01c22e90c08", + "size": 645227, + "subdir": "linux-64", + "timestamp": 1549298261163, + "version": "40.7.3" + }, + "setuptools-40.7.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56e3553b4e99cbd0db70d44ec8f0c4df", + "name": "setuptools", + "sha256": "6e19719f820bbcc27c1f14fa02893c5d421b59a384f7c9f49d62ca75d3729fa3", + "size": 620122, + "subdir": "linux-64", + "timestamp": 1549298266722, + "version": "40.7.3" + }, + "setuptools-40.7.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6af6539e9cb018076703592d51bcab89", + "name": "setuptools", + "sha256": "ddcf9bb72853582224fd02a65400c8f406b9ec1db03fe3e3f1c21837395cc9e7", + "size": 624745, + "subdir": "linux-64", + "timestamp": 1549298344485, + "version": "40.7.3" + }, + "setuptools-40.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "81c2179307aaaf99dcae942b5de17081", + "name": "setuptools", + "sha256": "d82c0c6b88a71e12c188c9b86f1db81d473b4398cfca8eb326810385c26b4ac2", + "size": 649771, + "subdir": "linux-64", + "timestamp": 1550362270428, + "version": "40.8.0" + }, + "setuptools-40.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f56086fb0235c763d4006d1dd15d2b26", + "name": "setuptools", + "sha256": "43c2578e0a80ad045a5fd5b125c7c27b71eeb9a9d6fc046a81696477a49498e5", + "size": 662964, + "subdir": "linux-64", + "timestamp": 1550362287175, + "version": "40.8.0" + }, + "setuptools-40.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "660dc053dfe07f65c34e3e24fd369ceb", + "name": "setuptools", + "sha256": "753e926e7fe778c1abd964c4f60b8d0df6a6f7f473ea87e86a2cb807b8257c49", + "size": 658477, + "subdir": "linux-64", + "timestamp": 1550362226771, + "version": "40.8.0" + }, + "setuptools-41.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aae0c4c6266e0050c5ee7401d72ecd18", + "name": "setuptools", + "sha256": "ba0b5be3667a724b956add65882d33cbbf556103c015592be19f1cef00381c2a", + "size": 671323, + "subdir": "linux-64", + "timestamp": 1555084258583, + "version": "41.0.0" + }, + "setuptools-41.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90e02691210ca1af6709f8e22b4f179f", + "name": "setuptools", + "sha256": "bf72d64d967bfc603fe70b58e1271aa12400fa1ef40cea87c1b409aaa94c7d7e", + "size": 672108, + "subdir": "linux-64", + "timestamp": 1555084373475, + "version": "41.0.0" + }, + "setuptools-41.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "76b99f8e8f9de6b80d5313fd418aabe7", + "name": "setuptools", + "sha256": "33702405c885bfde6b1846e5d23b9191ffc8a7235d92b2a490313e508947eb3d", + "size": 656148, + "subdir": "linux-64", + "timestamp": 1555084364723, + "version": "41.0.0" + }, + "setuptools-41.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47e011894888d98e285fdff2dff9b450", + "name": "setuptools", + "sha256": "405995a481a0aac950ece58e31d11f320ffc42acb85c22d7e0dd93deb3431504", + "size": 655652, + "subdir": "linux-64", + "timestamp": 1556550457755, + "version": "41.0.1" + }, + "setuptools-41.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5891cd8004849a73cd2dc9214330fa68", + "name": "setuptools", + "sha256": "ba9a66a16e4ceac9b4a841a666971c66f6ef3e457155d732eacd43f7119e6979", + "size": 672058, + "subdir": "linux-64", + "timestamp": 1556550471822, + "version": "41.0.1" + }, + "setuptools-41.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "61ac1f202d34628f75b51c42675cb7be", + "name": "setuptools", + "sha256": "3bada07ad90692b27cee9c4a9516227a21f440bcfdac07deecd3fa254d76f03f", + "size": 663470, + "subdir": "linux-64", + "timestamp": 1556550435060, + "version": "41.0.1" + }, + "setuptools-41.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee1ac7958ecae5608e328a866be998da", + "name": "setuptools", + "sha256": "6186de9d802b31e2cf00b054ecfa6c3ca1ad31e6dacc9cfdbd8198fff03d3f1e", + "size": 677914, + "subdir": "linux-64", + "timestamp": 1569259074776, + "version": "41.2.0" + }, + "setuptools-41.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f22d0c74d9b589a9a88153a4a02a8116", + "name": "setuptools", + "sha256": "dfc2a06dc5e5a9a0dc573fb628e9bc0f34ecdb0ebffda154a2af73b1ad622c3d", + "size": 648135, + "subdir": "linux-64", + "timestamp": 1569259077454, + "version": "41.2.0" + }, + "setuptools-41.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7cabc7a152a2baa5ef5e66da29c19834", + "name": "setuptools", + "sha256": "709e1722126185795cf7b4cfa6f2e7e0bc9adb53877e2e10da59bed240916f6a", + "size": 645445, + "subdir": "linux-64", + "timestamp": 1569259084274, + "version": "41.2.0" + }, + "setuptools-41.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ecff39f4bf0a421f8268303720da060", + "name": "setuptools", + "sha256": "0f7ee9e07ca3283e2d88f37f2227a0d4daaedc647b4e0c6184dbb488d29c1f27", + "size": 655110, + "subdir": "linux-64", + "timestamp": 1570459478731, + "version": "41.4.0" + }, + "setuptools-41.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "048f049528cc2cb3b492376fce2a8403", + "name": "setuptools", + "sha256": "e21bc0a4a1c1201e6dc9d5af1ce465aea4ae679453593dc68671acaa428952f4", + "size": 689451, + "subdir": "linux-64", + "timestamp": 1570459504167, + "version": "41.4.0" + }, + "setuptools-41.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4622c3a04a36d26192160bd21392a652", + "name": "setuptools", + "sha256": "b37857a6ccfb35ebefdd2b24698bc3680272b9b59066447bc7c7d8637cb3156b", + "size": 667027, + "subdir": "linux-64", + "timestamp": 1570459517903, + "version": "41.4.0" + }, + "setuptools-41.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56c76c99de7ae3a7b58745e899d70918", + "name": "setuptools", + "sha256": "37dc5d00a5fac90faee7dd5f6f35a7ede3205a2cf243e84f63d59dbc01509f76", + "size": 644080, + "subdir": "linux-64", + "timestamp": 1571953697213, + "version": "41.4.0" + }, + "setuptools-41.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d61e01e958f0917e1690e4eccd9381d", + "name": "setuptools", + "sha256": "771effef8f5421a9af184e35197aafc61cd932a909ba456ea4c097684554b3b8", + "size": 660483, + "subdir": "linux-64", + "timestamp": 1572451092195, + "version": "41.6.0" + }, + "setuptools-41.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "78dd3001b064ea6048d7078e2b640491", + "name": "setuptools", + "sha256": "7a7aace7b89a4089dcfd472ff1b8e5c2aa46267a21a0df39834f181786ab8efd", + "size": 665358, + "subdir": "linux-64", + "timestamp": 1572451095063, + "version": "41.6.0" + }, + "setuptools-41.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e62513a9d77774b69c67674dbd4b9abc", + "name": "setuptools", + "sha256": "c8e497e6c05ece299e0cb95432d3448d124f8024398b5c7b813f7f45a773ff43", + "size": 667828, + "subdir": "linux-64", + "timestamp": 1572451089793, + "version": "41.6.0" + }, + "setuptools-41.6.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a591dbf69d179dd7eecf212fc1df777f", + "name": "setuptools", + "sha256": "3dbeec91b719d1d5fb5f174a2f4c74adc5cf5c1926828fdc281b2fddedefbbd3", + "size": 682325, + "subdir": "linux-64", + "timestamp": 1572451110150, + "version": "41.6.0" + }, + "setuptools-42.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce3167e3247f292d43b32ef0a38a3c4b", + "name": "setuptools", + "sha256": "0be9eb79ca17958868a91b46f695de0d36d63fe9f2644df284db3043c6995775", + "size": 674222, + "subdir": "linux-64", + "timestamp": 1574698489664, + "version": "42.0.1" + }, + "setuptools-42.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dad492d513a512f456f342cfff3afe49", + "name": "setuptools", + "sha256": "8d6c97e51716d11ca3f40dd353c7374dfa024b3e057e8a38377588fc0fdb8edd", + "size": 659854, + "subdir": "linux-64", + "timestamp": 1574698503305, + "version": "42.0.1" + }, + "setuptools-42.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01ce7790921c825714a2b01f14de3e82", + "name": "setuptools", + "sha256": "6362beaa48eaa40985ea78d9e3a48ce9208bcc2d23d015f958bb0301db236d00", + "size": 686005, + "subdir": "linux-64", + "timestamp": 1574698486777, + "version": "42.0.1" + }, + "setuptools-42.0.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbe24d7b846ce6a5f63c94480f14848e", + "name": "setuptools", + "sha256": "d95df43378e298d6c6c1dc3399c3dc503376984f157bff74ce64fec6d3ff265c", + "size": 670987, + "subdir": "linux-64", + "timestamp": 1574698502202, + "version": "42.0.1" + }, + "setuptools-42.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "963d0c89c0a7fc09172186cf5ced4100", + "name": "setuptools", + "sha256": "42e1d7d4b8d1e4b0c48576fd704922116a930a28a4da8100e0312c007e6558ee", + "size": 665202, + "subdir": "linux-64", + "timestamp": 1575390306348, + "version": "42.0.2" + }, + "setuptools-42.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c7d492e7198ecedfa4e7ef2595c6914c", + "name": "setuptools", + "sha256": "831f424dc4eef6d113e3839c84bc915fbf30e1e56314cc125f09731d13cc4913", + "size": 668628, + "subdir": "linux-64", + "timestamp": 1575390319470, + "version": "42.0.2" + }, + "setuptools-42.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ddf989011550ea07598c6d2b53118763", + "name": "setuptools", + "sha256": "04328879e124f1637b97b06fcbe0967026dbd6cb349b266bd9a8d0d7e98b15c5", + "size": 661071, + "subdir": "linux-64", + "timestamp": 1575390237105, + "version": "42.0.2" + }, + "setuptools-42.0.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b06fb0ae07bb8615b1d3c4e75a75f09d", + "name": "setuptools", + "sha256": "1f65a5d338597d369095758b8cf8bfb3321279f7fc311d7428bc9900fe8e44cc", + "size": 670068, + "subdir": "linux-64", + "timestamp": 1575390389282, + "version": "42.0.2" + }, + "setuptools-44.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c94c8c29ea91cd4e778bd80f14299bec", + "name": "setuptools", + "sha256": "f5808875aac4647c99996e08205c1ae57626a775e302ec1ece67e1ddf10db86d", + "size": 662159, + "subdir": "linux-64", + "timestamp": 1578326214617, + "version": "44.0.0" + }, + "setuptools-44.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e5e352b00185f287f4ada608bd5fd0ed", + "name": "setuptools", + "sha256": "a79ef5d668f0a4f93865e6ac8c569387a0ba48e7f5b991e7da5ac3c50f193f83", + "size": 676937, + "subdir": "linux-64", + "timestamp": 1578326203881, + "version": "44.0.0" + }, + "setuptools-44.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af702086cae4f937b5937adb637f723f", + "name": "setuptools", + "sha256": "915f2fcdff66725b168fb98d6431a41741a76248e076f20f3d440bb61dc1ea60", + "size": 668991, + "subdir": "linux-64", + "timestamp": 1578326219825, + "version": "44.0.0" + }, + "setuptools-44.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d1f80f3805c985bd614861f16152e814", + "name": "setuptools", + "sha256": "dd68c1ac8bfcab73ee39172af7e5da480e500208460ccd541158c6c2b6ba2a5b", + "size": 667949, + "subdir": "linux-64", + "timestamp": 1578326231060, + "version": "44.0.0" + }, + "setuptools-45.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48fb4cd298b259e65acd40f2e205a594", + "name": "setuptools", + "sha256": "e3af530e522eb91e2531e086786a8987b2e9e6fd515bfb8a90fee2cb0edcd25d", + "size": 663490, + "subdir": "linux-64", + "timestamp": 1580148259372, + "version": "45.1.0" + }, + "setuptools-45.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08a9ebf81fa1af89134819021df5fe8b", + "name": "setuptools", + "sha256": "b5c026f7c2ed4abb485afe7a375b6f020fd610c4e6d77c369257cafc57bf4c49", + "size": 680193, + "subdir": "linux-64", + "timestamp": 1580148280188, + "version": "45.1.0" + }, + "setuptools-45.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e7655fb4beb3fc2bb5c9adbe5a4374dd", + "name": "setuptools", + "sha256": "6a9c1da23737e0a9858f9c8a4b11b018053b61ddfbca797dec28d91a2589eddd", + "size": 672908, + "subdir": "linux-64", + "timestamp": 1580148305308, + "version": "45.1.0" + }, + "setuptools-45.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8660ee98767a3d853a22ca95c38f50f0", + "name": "setuptools", + "sha256": "458eb1d8920f1b80087b4fb6fcb9237c4ddf42cc66e264f3e8dd1f71cc682782", + "size": 674764, + "subdir": "linux-64", + "timestamp": 1581351382956, + "version": "45.2.0" + }, + "setuptools-45.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2ce672ac87a68517e79c6f0720bca05", + "name": "setuptools", + "sha256": "dd7a8d928c4c7c08316ae9af759464485c4648398e753a9e7af41f05e1963cdf", + "size": 678815, + "subdir": "linux-64", + "timestamp": 1581351356158, + "version": "45.2.0" + }, + "setuptools-45.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4d056eb8e764fc3c42f1f3e6cc74140", + "name": "setuptools", + "sha256": "58957a9a08d4fb909f7ec49c1b3c197a81c326fd0f281e4bfb2de55553f6fecc", + "size": 671419, + "subdir": "linux-64", + "timestamp": 1581351338853, + "version": "45.2.0" + }, + "setuptools-46.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6689af307377bdaccab9ec5a175079e4", + "name": "setuptools", + "sha256": "d29ba8fe36567fc2d4acc52e1d42d1292e18934af852e29fbd9fefd7ac063a52", + "size": 675933, + "subdir": "linux-64", + "timestamp": 1583787623845, + "version": "46.0.0" + }, + "setuptools-46.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f707a0ecf738348265f0b1f10dffa6c", + "name": "setuptools", + "sha256": "a6d809c507a52fc882f11e9230b9a8874389a8266257e499002caf032f73d7d9", + "size": 676789, + "subdir": "linux-64", + "timestamp": 1583787643307, + "version": "46.0.0" + }, + "setuptools-46.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef32274e0d21d64b26af8ac530325ebc", + "name": "setuptools", + "sha256": "94844f93c5fdcdc55ba59c622eff4385a46d4fa01fffefa001c9ca5341ad62b8", + "size": 681194, + "subdir": "linux-64", + "timestamp": 1583787646819, + "version": "46.0.0" + }, + "setuptools-46.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4175d01babfb48ab15184ba7f3bb65c1", + "name": "setuptools", + "sha256": "a5753621dd31eef81eb4321ab1f2b769ed6e5eaa4c5c9f5a61e6f7cdbce5ffec", + "size": 675802, + "subdir": "linux-64", + "timestamp": 1584975638013, + "version": "46.1.1" + }, + "setuptools-46.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca843510c4fe005ff8c22e01f0dfba2b", + "name": "setuptools", + "sha256": "a2879ca950a7fbbb32d9260506ef754f016db997d9daa4c25afb34947a433665", + "size": 668433, + "subdir": "linux-64", + "timestamp": 1584975601264, + "version": "46.1.1" + }, + "setuptools-46.1.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "999fa195176af7352a67a0e695aaf3ad", + "name": "setuptools", + "sha256": "277ece90605262469cecd07b09690a81642126eb8bdacbb1a9744d21de91f75c", + "size": 669400, + "subdir": "linux-64", + "timestamp": 1584975626711, + "version": "46.1.1" + }, + "setuptools-46.1.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "077f1c9706d9401b8ca0b5198cb7e79b", + "name": "setuptools", + "sha256": "7650ceb0e46abf692346bf423ca5ffc4bfedc07c2fcfff522662b4d1c4b78f20", + "size": 678763, + "subdir": "linux-64", + "timestamp": 1585585310849, + "version": "46.1.3" + }, + "setuptools-46.1.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb8da3be88c910ec6ad6c7de1f9a4fbb", + "name": "setuptools", + "sha256": "325cec13983f7a86fca49cb29f00d0774b7d2165fbfdb69d27485bca3b5feab3", + "size": 671755, + "subdir": "linux-64", + "timestamp": 1585584428629, + "version": "46.1.3" + }, + "setuptools-46.1.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b5b2a7199a3cd45eac6bd416ba5727a", + "name": "setuptools", + "sha256": "137c66c6b15b2bc5f7adc5a69facf4183eafde67af9c54585640d9df95e0dc51", + "size": 672206, + "subdir": "linux-64", + "timestamp": 1585585315568, + "version": "46.1.3" + }, + "setuptools-46.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d8c1e40f7518cdf10ba3d7698582279", + "name": "setuptools", + "sha256": "106ef6fcf5ae1160f8fb8bf44b17be3724eae58a318828528ae95747535a75b6", + "size": 690531, + "subdir": "linux-64", + "timestamp": 1589214143715, + "version": "46.2.0" + }, + "setuptools-46.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e2ea5d0695c3bb1ba2fe122dd725e216", + "name": "setuptools", + "sha256": "0ad06c2054099dd00dd0f61d0f6e5c6f537b13fd36fa8a3f19ff5236a18f3729", + "size": 681049, + "subdir": "linux-64", + "timestamp": 1589214140866, + "version": "46.2.0" + }, + "setuptools-46.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af539df2b523631651741ddb4eb320da", + "name": "setuptools", + "sha256": "5aee8fab69d8c60f7c5738d7041e11ccca4a9b489a8be8463b0dab73c5736448", + "size": 681398, + "subdir": "linux-64", + "timestamp": 1589214182646, + "version": "46.2.0" + }, + "setuptools-46.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e285b191384644f14d378413015a4c1", + "name": "setuptools", + "sha256": "e66ed63cd5db803c4fa54cdc3eedcc4c245578e1a44f3267f49986d4ee80d636", + "size": 661214, + "subdir": "linux-64", + "timestamp": 1589822052556, + "version": "46.4.0" + }, + "setuptools-46.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "182aa35e24831efb59878e8bff4c4e79", + "name": "setuptools", + "sha256": "cf1c0ba0b848d557b59566f8a9ec635db2e708adb95750a4f526fbfe459d6540", + "size": 660600, + "subdir": "linux-64", + "timestamp": 1589822077802, + "version": "46.4.0" + }, + "setuptools-46.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc7e940033aea5f231fd4fe4bab85030", + "name": "setuptools", + "sha256": "15b9ec663375c1d93cda18c25a9482ad633606b14fd07ac79a4b58a05cbc22c2", + "size": 672091, + "subdir": "linux-64", + "timestamp": 1589822068892, + "version": "46.4.0" + }, + "setuptools-47.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "27b45f1c345a50df79661601cb8913af", + "name": "setuptools", + "sha256": "182f6affce14c0175b84ffa1248857138a46e3cd2a63aa4bdfc930e888f016ba", + "size": 668382, + "subdir": "linux-64", + "timestamp": 1591295691196, + "version": "47.1.1" + }, + "setuptools-47.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d3a9ca231b5de043a9654ec53cf15c5d", + "name": "setuptools", + "sha256": "8d47abf8e17027db59a564b322d2c9e6d16fb0b515bb89e147c4e8dcced60d94", + "size": 662754, + "subdir": "linux-64", + "timestamp": 1591295685422, + "version": "47.1.1" + }, + "setuptools-47.1.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "44a1ba1b6e0a176e2bcb023ead82ac17", + "name": "setuptools", + "sha256": "ed7fc04803f296dc43d69970cc8a3b7bc1c896231adf9e67abdafe442af901a0", + "size": 664641, + "subdir": "linux-64", + "timestamp": 1591295688613, + "version": "47.1.1" + }, + "setuptools-47.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9cd78c949b025f5d79aaaa0d0d0834e2", + "name": "setuptools", + "sha256": "bdd0091844278359a4d94fe28f79e0c4feeac45344fc49c7409c0d61d42b6785", + "size": 667584, + "subdir": "linux-64", + "timestamp": 1592319647923, + "version": "47.3.0" + }, + "setuptools-47.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eafff260bed6b62bf7038b218c717cce", + "name": "setuptools", + "sha256": "39c39ec5f2e72abb841e0990b8107f0c4097fa7aa2ac8baaedbb3791230323d0", + "size": 673992, + "subdir": "linux-64", + "timestamp": 1592319622423, + "version": "47.3.0" + }, + "setuptools-47.3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "534bf66d27706fa1c21d1f910a1d7ead", + "name": "setuptools", + "sha256": "5f20453d82b5e9d34bcfa1b24d99e0e70a6c08fedf75582025792052b941fcfb", + "size": 668936, + "subdir": "linux-64", + "timestamp": 1592319648560, + "version": "47.3.0" + }, + "setuptools-47.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca2216dbc30a42e4e0f2494e2db6e569", + "name": "setuptools", + "sha256": "f79e182b1abc3746abd9d111dee7491f510bf4b1ba696c1658e49a45943e3887", + "size": 662363, + "subdir": "linux-64", + "timestamp": 1592841462394, + "version": "47.3.1" + }, + "setuptools-47.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "258d1240e3f1070e90eefdff263a6929", + "name": "setuptools", + "sha256": "a678bc76ef4191d711452c63ca4c8353f0a72de039fdd34b09c6eca8401b281e", + "size": 662052, + "subdir": "linux-64", + "timestamp": 1592841505038, + "version": "47.3.1" + }, + "setuptools-47.3.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6919edcab006157a49b55cd76bc493f2", + "name": "setuptools", + "sha256": "48d70eae94c3633c2b3b8a53321745beb4cbb8d52cda92e4cd1ab699b2693b6b", + "size": 674207, + "subdir": "linux-64", + "timestamp": 1592841462324, + "version": "47.3.1" + }, + "setuptools-49.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec08a36eaaedc91a8bc476b1a33c98e0", + "name": "setuptools", + "sha256": "a1af2c67b1763cd343b4c813035815de19694855f4b9e4972a8e6a98ca943a75", + "size": 934171, + "subdir": "linux-64", + "timestamp": 1601835816638, + "version": "49.1.0" + }, + "setuptools-49.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8082b754f545faaa58469f74082d598", + "name": "setuptools", + "sha256": "ae0e7c1a1a3bf96ec8111ac61379134f4a54785bb20cab11a807fb37401cc3a3", + "size": 935215, + "subdir": "linux-64", + "timestamp": 1594419325502, + "version": "49.1.0" + }, + "setuptools-49.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d95bbfc72ed29f7873e6fcf36d7f99f6", + "name": "setuptools", + "sha256": "8e1efb2b9c2a413318aa7e0b5e9c81da86949e140c12d0ab7ea3a326211af788", + "size": 954644, + "subdir": "linux-64", + "timestamp": 1601835794430, + "version": "49.1.0" + }, + "setuptools-49.1.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8149164da0f910f42d5c4d3b23ce2010", + "name": "setuptools", + "sha256": "47152d8a4bb2a2ad15b2b7440df61ac1d94d50ec097bcb6824a54a7b0ee3087b", + "size": 967714, + "subdir": "linux-64", + "timestamp": 1677521830182, + "version": "49.1.3" + }, + "setuptools-49.1.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1cc34ee8fac3be25951647b43bdcf245", + "name": "setuptools", + "sha256": "a16c103d8c1d2b600efe15a5465c1ccf7abf6fd0333cbb5c499b695d9eb20e89", + "size": 956815, + "subdir": "linux-64", + "timestamp": 1677521880923, + "version": "49.1.3" + }, + "setuptools-49.1.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ed61dd31b658f1d735138b74e32095e", + "name": "setuptools", + "sha256": "13efe063e85898f8f75eb46a0e75e7bdda75cbceb9327aea6b41d31b640fdabf", + "size": 961060, + "subdir": "linux-64", + "timestamp": 1677521906991, + "version": "49.1.3" + }, + "setuptools-49.1.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b06c2d40cb8813866a893f83e3c6fc97", + "name": "setuptools", + "sha256": "8d8e7ff51b37c41e68e6c51131b8fc370f5765c00177d9a1df6a3f9e4a4ee0f3", + "size": 959407, + "subdir": "linux-64", + "timestamp": 1677521855387, + "version": "49.1.3" + }, + "setuptools-49.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5216f170c031877573c23507e76a81a6", + "name": "setuptools", + "sha256": "30e5c27e90615481ef28452d04d727ebf325cae2d063dc0c8fe30802797d7221", + "size": 951290, + "subdir": "linux-64", + "timestamp": 1594753701233, + "version": "49.2.0" + }, + "setuptools-49.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71ef4e1498c090a4b0f7baf324010662", + "name": "setuptools", + "sha256": "db29a0dc25482967828203cec98bfa429e5570f5bee2cee79e7aeba92970a3d6", + "size": 966957, + "subdir": "linux-64", + "timestamp": 1594753978524, + "version": "49.2.0" + }, + "setuptools-49.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "86ae11cafdc188210691ec0a87433564", + "name": "setuptools", + "sha256": "368effc2e7ae9734a86cd4ab2e08c70b11dc9696469483f995dd22baa445181f", + "size": 978219, + "subdir": "linux-64", + "timestamp": 1594753991493, + "version": "49.2.0" + }, + "setuptools-49.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3c466a447e2530f8296499957a70a8a", + "name": "setuptools", + "sha256": "6bb89c0161ace3eb1cc06064715e162d672ae8c51fd3e33f48b9ec86628e1365", + "size": 966353, + "subdir": "linux-64", + "timestamp": 1596809662578, + "version": "49.2.1" + }, + "setuptools-49.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3312dbf5c71ae5e0d3e4365c73120cc", + "name": "setuptools", + "sha256": "1626cffd7a77c48e0f6b790552a62284cc27e03399e43b8a0cb26b94757a6055", + "size": 946612, + "subdir": "linux-64", + "timestamp": 1596809649875, + "version": "49.2.1" + }, + "setuptools-49.2.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a9c96693a4cdc9de3d9d858c2a8af9c", + "name": "setuptools", + "sha256": "9c927b18966cf9bcd7faf6ea1ffbc62a6e54f4c62043ac19677ff5b31fd1fcaa", + "size": 988897, + "subdir": "linux-64", + "timestamp": 1596809662114, + "version": "49.2.1" + }, + "setuptools-49.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d111cd8cbd7226000306f61f2db47876", + "name": "setuptools", + "sha256": "33d1a9d6d8846c5c78deb6262a947d92ccd1b882ac8e18ae949cbf8e517cafce", + "size": 952605, + "subdir": "linux-64", + "timestamp": 1601836218380, + "version": "49.3.1" + }, + "setuptools-49.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "55e03313728c09d1862ca6df098dcc13", + "name": "setuptools", + "sha256": "aca3fc4150d48f73cb2eaa8458427de2ac961cd9b9c4d8ce1e3afb9769964629", + "size": 966309, + "subdir": "linux-64", + "timestamp": 1597080840170, + "version": "49.3.1" + }, + "setuptools-49.3.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eacb657532f58e16a54c6b16978c6674", + "name": "setuptools", + "sha256": "492ff9593379be730ce20b2fdf202457278a7e4adc58b6105e326ccb0d773310", + "size": 977576, + "subdir": "linux-64", + "timestamp": 1601836251422, + "version": "49.3.1" + }, + "setuptools-49.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5184b565380c273ce59e5edbfdab232c", + "name": "setuptools", + "sha256": "832d4a25eafa327d7e694a00841ae2e0ab00e8a34ed9110999d8b133ada3da91", + "size": 922449, + "subdir": "linux-64", + "timestamp": 1601836425542, + "version": "49.4.0" + }, + "setuptools-49.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c2acbee1a16a428ce7d8b95257315f1", + "name": "setuptools", + "sha256": "0b1b9adae437c6b1b1e808bcb5e56a73338b5d7015e3441c0e4ba92f5d8e98b3", + "size": 956248, + "subdir": "linux-64", + "timestamp": 1597340532535, + "version": "49.4.0" + }, + "setuptools-49.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "24e02e39dd09c62e02f4a2bc1cb927e0", + "name": "setuptools", + "sha256": "dc2c102857591630a9f39491121b04f01d523d28804fc2a92e572c793b6b5bbd", + "size": 962552, + "subdir": "linux-64", + "timestamp": 1601836409226, + "version": "49.4.0" + }, + "setuptools-49.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4bd3d2829a573c2b22f5be8350bd42ff", + "name": "setuptools", + "sha256": "3b4b8be7f8ca316493e3b37255471b77fb3de0ebe5c266af255a39f9179df0f4", + "size": 949141, + "subdir": "linux-64", + "timestamp": 1597423242432, + "version": "49.6.0" + }, + "setuptools-49.6.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a40d0c218af34047d38602064cd89f60", + "name": "setuptools", + "sha256": "906d04fafb2d43c3f98c834f144c47582ba9b3eb49abe14809587b46df143fd1", + "size": 955561, + "subdir": "linux-64", + "timestamp": 1601053517740, + "version": "49.6.0" + }, + "setuptools-49.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e57b6101b39531dbfb3a9f6489fe537", + "name": "setuptools", + "sha256": "8bdf98d52cc389c77d501b0ccdd6a00384bb5a90e5c34018f29d2f729082949d", + "size": 931113, + "subdir": "linux-64", + "timestamp": 1597423218629, + "version": "49.6.0" + }, + "setuptools-49.6.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f07b6ef982ce7ea20c57ef7e7a2d41b6", + "name": "setuptools", + "sha256": "3e3f9ad011b04c91c324409919b577796347e4a157148e30702dcecfc768aec4", + "size": 969580, + "subdir": "linux-64", + "timestamp": 1601053512842, + "version": "49.6.0" + }, + "setuptools-49.6.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52e6af9f229c39d0f2b6c1da7ca44918", + "name": "setuptools", + "sha256": "3399764e4b5366d6442d9ecd2951ce5dfba6738e8478d119db5146e11cc21968", + "size": 992176, + "subdir": "linux-64", + "timestamp": 1597423237528, + "version": "49.6.0" + }, + "setuptools-49.6.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f50c678c74c6f60103a8110183197952", + "name": "setuptools", + "sha256": "b63f1e9d0ae5ab2a6ca6e8e08a9f3b4f196f81ede64c9fddf0552852112f0473", + "size": 973503, + "subdir": "linux-64", + "timestamp": 1601053518124, + "version": "49.6.0" + }, + "setuptools-50.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16702069a3d43059da293982b37f1963", + "name": "setuptools", + "sha256": "b417495e6f3828acfc6109db8db7a4a6627b419999c89a76a64a9883d988e3cd", + "size": 942624, + "subdir": "linux-64", + "timestamp": 1601923339615, + "version": "50.3.0" + }, + "setuptools-50.3.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "59fae15471d885a70e221d2bc4734b56", + "name": "setuptools", + "sha256": "2f9007eb07599e926e294c8a49739a229d64dd5509e651fd4e37f31c69c7cc76", + "size": 963012, + "subdir": "linux-64", + "timestamp": 1604430396059, + "version": "50.3.0" + }, + "setuptools-50.3.0-py36hb0f4dca_1.tar.bz2": { + "build": "py36hb0f4dca_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "571503a6169376a4750f9dfc88ce3b3e", + "name": "setuptools", + "sha256": "8bd4bf6eef97dcede7f16f99ce19c7e978d78eeddea9bb03e0c4d4693266afcb", + "size": 912770, + "subdir": "linux-64", + "timestamp": 1601999692654, + "version": "50.3.0" + }, + "setuptools-50.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8cf0799b9be762663c90ef38b5c53652", + "name": "setuptools", + "sha256": "5ec4814a738fb2200b46a87252d6ac4a6721756179b49545e076b5eacf74dbb3", + "size": 971803, + "subdir": "linux-64", + "timestamp": 1601923379258, + "version": "50.3.0" + }, + "setuptools-50.3.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d4b0a5c1f1641ab126bd1e630f7e83e", + "name": "setuptools", + "sha256": "df11415dc9e24dc9fc70a850b7a411231c1775e8fb0efc9f0c8cd8a22c03b68d", + "size": 968837, + "subdir": "linux-64", + "timestamp": 1604430397881, + "version": "50.3.0" + }, + "setuptools-50.3.0-py37hb0f4dca_1.tar.bz2": { + "build": "py37hb0f4dca_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d26a1fc4caffcd026a50ea70ad926b3", + "name": "setuptools", + "sha256": "c19b466a73592f7235b181c3a4c73fe42e282bc6c89f3a58fa3497b35a95c9e7", + "size": 925429, + "subdir": "linux-64", + "timestamp": 1601999673601, + "version": "50.3.0" + }, + "setuptools-50.3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95201816e4c58198fbafb01e84fd9ca9", + "name": "setuptools", + "sha256": "75837ea5825b11930de074eb30942a6b613ea3d7b3c9fc1dc89b2212eb550eea", + "size": 962270, + "subdir": "linux-64", + "timestamp": 1601923348935, + "version": "50.3.0" + }, + "setuptools-50.3.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a1265a63fa552678e4b8c6b41b09692", + "name": "setuptools", + "sha256": "1ed0c0fd6d892fcb28363eadbb5b9e3e4fbd084673f58553494a497228ec1352", + "size": 953472, + "subdir": "linux-64", + "timestamp": 1604430379798, + "version": "50.3.0" + }, + "setuptools-50.3.0-py38hb0f4dca_1.tar.bz2": { + "build": "py38hb0f4dca_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c49c24270f5d66abf6d58542615fdf6a", + "name": "setuptools", + "sha256": "5dec5be70d91dc2296d0d3ce0f74390483b36ee3bf80fc821de482dbc2b3a7c9", + "size": 923537, + "subdir": "linux-64", + "timestamp": 1601999690434, + "version": "50.3.0" + }, + "setuptools-50.3.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "868f4f1f188777e577666689f70afe66", + "name": "setuptools", + "sha256": "b9e2570799d7394dc86006e89765ef1e92988107c1b7e865c122e71be536e40b", + "size": 934946, + "subdir": "linux-64", + "timestamp": 1604430385928, + "version": "50.3.0" + }, + "setuptools-50.3.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f2d1b61d7a777938a88619489919846", + "name": "setuptools", + "sha256": "2c14e0c7d631e26ca4b28e47d1bf5d5a220ec696c3cc18a4968936fc4496c498", + "size": 921300, + "subdir": "linux-64", + "timestamp": 1604771431454, + "version": "50.3.1" + }, + "setuptools-50.3.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2035c8ef4d071ea4cdee22c50d0afc8", + "name": "setuptools", + "sha256": "d465c185804342cb29b1c9fa7d3dede43801e1f4ed6d6019a988db2bfbf91276", + "size": 922972, + "subdir": "linux-64", + "timestamp": 1604771413481, + "version": "50.3.1" + }, + "setuptools-50.3.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe2639d9cc837a07b97c904727aff6cf", + "name": "setuptools", + "sha256": "d019de239bd3263ba95290d7f473614c333b3fffcc3e4437446036edbab7155b", + "size": 927967, + "subdir": "linux-64", + "timestamp": 1604771442322, + "version": "50.3.1" + }, + "setuptools-50.3.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d29eb3ae3a3244657fc8151e4eded03", + "name": "setuptools", + "sha256": "22b20d03a2f0a2d51758f3c51db3405bc57fd37b08922043033cade41b8d259e", + "size": 945626, + "subdir": "linux-64", + "timestamp": 1604771428645, + "version": "50.3.1" + }, + "setuptools-50.3.2-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80225fb625a9402ed6d4fbf2f09bde70", + "name": "setuptools", + "sha256": "d3f2dea5ea55f9252ccf15fe466b8ae42a1aeb2654035d85a398db36c222481f", + "size": 928623, + "subdir": "linux-64", + "timestamp": 1606864963541, + "version": "50.3.2" + }, + "setuptools-50.3.2-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "780509817480fcacfb9976e9c5752dd4", + "name": "setuptools", + "sha256": "9f32718b6f70d9ca4b86ecadd2c1ed7464bb6554de12bac0125dfe4ba5012759", + "size": 957464, + "subdir": "linux-64", + "timestamp": 1606864934630, + "version": "50.3.2" + }, + "setuptools-50.3.2-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ed2e937658d57f31501acfd019f45d19", + "name": "setuptools", + "sha256": "3455f3cb026fd08146871db032f6f036d531e173bb7917763caaee21c4389b91", + "size": 956562, + "subdir": "linux-64", + "timestamp": 1606864944390, + "version": "50.3.2" + }, + "setuptools-50.3.2-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e2e00cbb9f1e75c3d615a3cb91dbb77e", + "name": "setuptools", + "sha256": "33b6c0f039727ea6b6bf1f84d419be0593495f65920754d15d525bfc2f0f45a9", + "size": 948730, + "subdir": "linux-64", + "timestamp": 1606864954496, + "version": "50.3.2" + }, + "setuptools-51.0.0-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e15ef63924ab8ead93fa6cf1947a916", + "name": "setuptools", + "sha256": "4f67facc2fc1b1f9a69bc089ae2f085c5c2a16552febb6e53a13e324be0424aa", + "size": 958633, + "subdir": "linux-64", + "timestamp": 1607369636540, + "version": "51.0.0" + }, + "setuptools-51.0.0-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "03ff9a1395770e4b46659ed721e7dcfc", + "name": "setuptools", + "sha256": "0840286eeba9df9deb7ef942c32af6c0c1a3a4baf7e9196a0129f8445aff0dd4", + "size": 955025, + "subdir": "linux-64", + "timestamp": 1607369661209, + "version": "51.0.0" + }, + "setuptools-51.0.0-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83ce98a02b2ceff8a8f72bd1a603d806", + "name": "setuptools", + "sha256": "a8ab9fa863c10d0076d1daa75bcec51b4b34d395ae190c94b100503940e4ef86", + "size": 911365, + "subdir": "linux-64", + "timestamp": 1607369648803, + "version": "51.0.0" + }, + "setuptools-51.0.0-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef24caef2442f56a37594fb9ab2d67bf", + "name": "setuptools", + "sha256": "bb7b2845da7a7ae03dc44631382ec2e16bc51abbbce497d885187bc2ddcf0fa7", + "size": 925225, + "subdir": "linux-64", + "timestamp": 1607369654728, + "version": "51.0.0" + }, + "setuptools-51.1.2-py36h06a4308_3.tar.bz2": { + "build": "py36h06a4308_3", + "build_number": 3, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "945288a3202d970834d9f06629bd7839", + "name": "setuptools", + "sha256": "8eb3deac66f3a206cbc61cc21ae144f387a93516c668e2d180ca5139ceb4d14e", + "size": 929587, + "subdir": "linux-64", + "timestamp": 1610306790252, + "version": "51.1.2" + }, + "setuptools-51.1.2-py36h06a4308_4.tar.bz2": { + "build": "py36h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3ec67f4df8f5deb74898624fde8b164", + "name": "setuptools", + "sha256": "977edb8ae1202ac7ae61794f4d47e4b4444c6f764598c6f5e8c77abf0db21e3e", + "size": 970902, + "subdir": "linux-64", + "timestamp": 1610483757154, + "version": "51.1.2" + }, + "setuptools-51.1.2-py37h06a4308_3.tar.bz2": { + "build": "py37h06a4308_3", + "build_number": 3, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "758be20c11d4993324e412da840d8496", + "name": "setuptools", + "sha256": "43f7ce15c64461b780931c82507fbf246d5a562c9fab3707bd30c636a0e0dccb", + "size": 929659, + "subdir": "linux-64", + "timestamp": 1610306788999, + "version": "51.1.2" + }, + "setuptools-51.1.2-py37h06a4308_4.tar.bz2": { + "build": "py37h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "554074647aa0dfdb74d2543363ab92b1", + "name": "setuptools", + "sha256": "65c291a46ce1c4887bd1d7a1f8876704919ac65796e528f224f6ffc8f7ef6910", + "size": 921305, + "subdir": "linux-64", + "timestamp": 1610483791480, + "version": "51.1.2" + }, + "setuptools-51.1.2-py38h06a4308_3.tar.bz2": { + "build": "py38h06a4308_3", + "build_number": 3, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "78381be3de8f008b3a7a9ae0a2fb1da9", + "name": "setuptools", + "sha256": "afa41e4b68d54301458a7ee371899fd62935e3a8dfeff5a017ecc6135ed0fa33", + "size": 954604, + "subdir": "linux-64", + "timestamp": 1610306770701, + "version": "51.1.2" + }, + "setuptools-51.1.2-py38h06a4308_4.tar.bz2": { + "build": "py38h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b837568c112afd48ba050662f4b29807", + "name": "setuptools", + "sha256": "7c80ed6761551db75c39a9c6dcf62972fb46aa470b228b22381ea98a0bbb5a59", + "size": 916723, + "subdir": "linux-64", + "timestamp": 1610483304026, + "version": "51.1.2" + }, + "setuptools-51.1.2-py39h06a4308_3.tar.bz2": { + "build": "py39h06a4308_3", + "build_number": 3, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f19732a05157147ec940149eeacfc60", + "name": "setuptools", + "sha256": "3d308f999485b34a676b4e5749411b8ddd01e9ca9babf5f91e4b9bd063dfd903", + "size": 954218, + "subdir": "linux-64", + "timestamp": 1610306764051, + "version": "51.1.2" + }, + "setuptools-51.1.2-py39h06a4308_4.tar.bz2": { + "build": "py39h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "788d4e18ac1d5a42f8bad35612807fd0", + "name": "setuptools", + "sha256": "10b05eefc9064c4307d20fd8551ed4eebe9be990226e1df5d42e5b7a15f61a71", + "size": 959765, + "subdir": "linux-64", + "timestamp": 1610483764376, + "version": "51.1.2" + }, + "setuptools-51.3.2-py36h06a4308_4.tar.bz2": { + "build": "py36h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4ef049d069d9ac28fd1f4c53d231ee6", + "name": "setuptools", + "sha256": "b12ba696d2010e73ade9d6abfe765587b8602c3a5b7085040d1668b947d5d592", + "size": 929426, + "subdir": "linux-64", + "timestamp": 1610911431821, + "version": "51.3.2" + }, + "setuptools-51.3.2-py37h06a4308_4.tar.bz2": { + "build": "py37h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd7ad253200278f6dc7226162a64a3a5", + "name": "setuptools", + "sha256": "36cc3b4762226e1b627887710631fb324c1d74f75b7ab873cbc2dc7c044d4b4d", + "size": 958149, + "subdir": "linux-64", + "timestamp": 1610912128151, + "version": "51.3.2" + }, + "setuptools-51.3.2-py38h06a4308_4.tar.bz2": { + "build": "py38h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b6942a1631075b46b53aac4190c9c80", + "name": "setuptools", + "sha256": "e63407514af1b1348b5b1cb01588a0cf7cc612d6b059f9eea28638e2e0b78add", + "size": 912842, + "subdir": "linux-64", + "timestamp": 1610912110756, + "version": "51.3.2" + }, + "setuptools-51.3.2-py39h06a4308_4.tar.bz2": { + "build": "py39h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "113f4d27b2f3abe8f36a9900e8253530", + "name": "setuptools", + "sha256": "0859f60be65823270e56ee68187dedd66c0634d39f7322597fb3a1902137e076", + "size": 944854, + "subdir": "linux-64", + "timestamp": 1610912132122, + "version": "51.3.2" + }, + "setuptools-51.3.3-py36h06a4308_4.tar.bz2": { + "build": "py36h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d3c6ffea2446f1939269cddb94eb1ba", + "name": "setuptools", + "sha256": "d3d9b2f5d2daeb3982b5688472235814070cf7201f917a6f6faa1a75e71caec3", + "size": 929849, + "subdir": "linux-64", + "timestamp": 1610998818402, + "version": "51.3.3" + }, + "setuptools-51.3.3-py37h06a4308_4.tar.bz2": { + "build": "py37h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0049c280393d5d126c6255a500f6ec49", + "name": "setuptools", + "sha256": "02c3f5ac189291cb194520ba1a16ee7b69030ba9cf014c56b70ae3578d0675f0", + "size": 950774, + "subdir": "linux-64", + "timestamp": 1610998797189, + "version": "51.3.3" + }, + "setuptools-51.3.3-py38h06a4308_4.tar.bz2": { + "build": "py38h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "229ddf25ab50570c0f57fe44f991bf2d", + "name": "setuptools", + "sha256": "77fe03b80b60295c3dc9dbd139893d8e7a62a03ed3e4302b45e99d30f0a3555d", + "size": 927288, + "subdir": "linux-64", + "timestamp": 1610998819683, + "version": "51.3.3" + }, + "setuptools-51.3.3-py39h06a4308_4.tar.bz2": { + "build": "py39h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef5a82a03e2353685613a805310967e1", + "name": "setuptools", + "sha256": "120bce8cb700c366991c680fc30e33c3bd3fc0fa283a4b7e55471186287004a8", + "size": 915161, + "subdir": "linux-64", + "timestamp": 1610998065635, + "version": "51.3.3" + }, + "setuptools-52.0.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85f1e449d37e04364a5a3e58782ee493", + "name": "setuptools", + "sha256": "98b8cd31650e32249d8f1094a402a98605750215ea42982ab9f90d0297d3df0a", + "size": 950591, + "subdir": "linux-64", + "timestamp": 1633501367301, + "version": "52.0.0" + }, + "setuptools-52.0.0-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "014734be6a06901c7524961d82eb054e", + "name": "setuptools", + "sha256": "f8ae09ee7ceff30b860e27e1273a4623ea64a890778407ee9f3955d86a56fe02", + "size": 1138964, + "subdir": "linux-64", + "timestamp": 1676822488587, + "version": "52.0.0" + }, + "setuptools-52.0.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4efc1ff5b385e367414f3946ae82218d", + "name": "setuptools", + "sha256": "462d80456109c555920e01e357ea83c09c99cc182277171646745207ddfdb7b2", + "size": 955139, + "subdir": "linux-64", + "timestamp": 1611605149443, + "version": "52.0.0" + }, + "setuptools-52.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f72dbf4e3b55e8302daddc8ac6bc6df", + "name": "setuptools", + "sha256": "521660cbbca020bd6305f41461d36463278768e38a3457aa8700cb1a3ca2dc43", + "size": 943071, + "subdir": "linux-64", + "timestamp": 1611605118613, + "version": "52.0.0" + }, + "setuptools-52.0.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f92951b607597669819f0dcdb158d69", + "name": "setuptools", + "sha256": "720034fbf528b59ce6fa61c1c3f7d4eeee850377ddd6ff17286e812f74be0d32", + "size": 939086, + "subdir": "linux-64", + "timestamp": 1633512114593, + "version": "52.0.0" + }, + "setuptools-52.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "137b633e94368d2f05b3cea65dc284c0", + "name": "setuptools", + "sha256": "f2764ccd2b4311de6d65d8d0c44876a6d54e1b4c4c8912034998e650beea05dd", + "size": 949805, + "subdir": "linux-64", + "timestamp": 1611605169910, + "version": "52.0.0" + }, + "setuptools-52.0.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "004dfaad7a076fb796553662f454d2e2", + "name": "setuptools", + "sha256": "db17e8d604bdc1953cd4fbb3b0eb324f3a7eb2982be2237dd314568f37537950", + "size": 937416, + "subdir": "linux-64", + "timestamp": 1633512123282, + "version": "52.0.0" + }, + "setuptools-52.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ada69faa041ff8b6dc2bd5b05dd0e756", + "name": "setuptools", + "sha256": "970747f8302d0b967b0b3481d12cba478c2c6f2e59422b4dd54fb0ef7f5ffa42", + "size": 901631, + "subdir": "linux-64", + "timestamp": 1611605161621, + "version": "52.0.0" + }, + "setuptools-52.0.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aba3021f3c9ee97a37f45a8b57be57ee", + "name": "setuptools", + "sha256": "c939309a78acb6c205a090d45808e1ab197309b94cf71dc3c8dbb5dadac18b9a", + "size": 960953, + "subdir": "linux-64", + "timestamp": 1633511313893, + "version": "52.0.0" + }, + "setuptools-58.0.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9d5547a1bac9b90f77dbb07ec7464ed", + "name": "setuptools", + "sha256": "196ff869369ac6ca8881e3c1822acdb8adbdf1e500aced47611bd5d19d855ffc", + "size": 1002419, + "subdir": "linux-64", + "timestamp": 1633608016133, + "version": "58.0.4" + }, + "setuptools-58.0.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64221c97dbe3ea0cb4070d6ff50d79c7", + "name": "setuptools", + "sha256": "84d7c28c12d88f6587f59a01dc34394b6a556e179123056a5dad26a292d17f36", + "size": 1002441, + "subdir": "linux-64", + "timestamp": 1631833152691, + "version": "58.0.4" + }, + "setuptools-58.0.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2e2ef6c7d7d1c65a892f50e7bcc3a93", + "name": "setuptools", + "sha256": "e4451467d63f44dcc28a036261259dc1f5510fb652bcae11b2d16bfae0bff024", + "size": 1002902, + "subdir": "linux-64", + "timestamp": 1631832983661, + "version": "58.0.4" + }, + "setuptools-58.0.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e7c3938e5d3ee58fba62b29740c2ab48", + "name": "setuptools", + "sha256": "8eea5d73683a42dfd59c5b9e4dc7b9bbe114093233324a0befaa6dff795f507f", + "size": 995265, + "subdir": "linux-64", + "timestamp": 1631823241040, + "version": "58.0.4" + }, + "setuptools-58.0.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c212866bb83bcbf8e331a3d0cbfb812b", + "name": "setuptools", + "sha256": "b6aaeb3ab47069666a0ef91c8f5d8c26cffbc89c73fddda8f91f262f4fa7474e", + "size": 988348, + "subdir": "linux-64", + "timestamp": 1631833131205, + "version": "58.0.4" + }, + "setuptools-61.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1bb5334a7b3a23885977d5dcd4b57e48", + "name": "setuptools", + "sha256": "92e4b211e7233d957356dcd2e746ee75e3f159f35606ecd56782b56bee1b4252", + "size": 1349491, + "subdir": "linux-64", + "timestamp": 1649230548784, + "version": "61.2.0" + }, + "setuptools-61.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "27361f488ace03ac5a62e3181c40d263", + "name": "setuptools", + "sha256": "b4302196064b648656a79c6ce51badc053f244f8578569f8a5d82995892ecf4b", + "size": 1312800, + "subdir": "linux-64", + "timestamp": 1649230484203, + "version": "61.2.0" + }, + "setuptools-61.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8383b8868487c73810e283ef51df88aa", + "name": "setuptools", + "sha256": "278a37c418447d53707bdfab711e02a84f0720c5548d1a5ccdeeae66f4874743", + "size": 1337656, + "subdir": "linux-64", + "timestamp": 1649230510263, + "version": "61.2.0" + }, + "setuptools-61.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "244bd0a6260239cebf4d1fbcc8ec82b1", + "name": "setuptools", + "sha256": "8f4fedfa2555e5bb2b192f821c672f76ab9bf49cc47548ef0facbce44de994bc", + "size": 1337710, + "subdir": "linux-64", + "timestamp": 1649230457664, + "version": "61.2.0" + }, + "setuptools-63.4.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "847615cc2db48e0b5b88c670ebdbc190", + "name": "setuptools", + "sha256": "5f0b4fd883aa0fe1c2101359e380d03709a252c0a31845a9191c16d77667544c", + "size": 1415615, + "subdir": "linux-64", + "timestamp": 1661182494050, + "version": "63.4.1" + }, + "setuptools-63.4.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc5107a590b8ae37b6eb31b29fa813a6", + "name": "setuptools", + "sha256": "4fbaef7c7f8660f342d9c6f0e6c686bd7b8d4dfb248518b17d0f5d20aa629ddf", + "size": 1428248, + "subdir": "linux-64", + "timestamp": 1661182525679, + "version": "63.4.1" + }, + "setuptools-63.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc7dd6f1fd24e427ecace4b92b4b7184", + "name": "setuptools", + "sha256": "d4d69376037ec447b49caf91ddecf3f1cca200fa4f546eaee47f8b08b942616d", + "size": 1404611, + "subdir": "linux-64", + "timestamp": 1661182439561, + "version": "63.4.1" + }, + "setuptools-63.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "adc9783401e70d2f0c086938379052d9", + "name": "setuptools", + "sha256": "faad5e630f4b435b1b11028771212f9082435ed71d533ac169ed5b13763e0800", + "size": 1405068, + "subdir": "linux-64", + "timestamp": 1661182561012, + "version": "63.4.1" + }, + "setuptools-65.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e30f3ac578543bad0c5952aaebb665c", + "name": "setuptools", + "sha256": "678894365e2ed78ffe08eeb062eba44897ff271a08aa106016fe5049e12b9078", + "size": 1463474, + "subdir": "linux-64", + "timestamp": 1666983185782, + "version": "65.4.0" + }, + "setuptools-65.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df706fdce6a87d251cc18d94cb2f2ea1", + "name": "setuptools", + "sha256": "709c3ec583217e13a68ef85eea1a7fb7ec7a1a5d61d143ed3b5e126d8abd6220", + "size": 1486418, + "subdir": "linux-64", + "timestamp": 1666983106932, + "version": "65.4.0" + }, + "setuptools-65.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c73f19bb22f66e7c613351b5555df090", + "name": "setuptools", + "sha256": "fcc8923834fd515ce1de10fd61e229275f7e04a72d9d2551650c410c9ff7fa6f", + "size": 1460127, + "subdir": "linux-64", + "timestamp": 1666983157909, + "version": "65.4.0" + }, + "setuptools-65.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5446211b9bd2b762a8d45b6a37d33cd2", + "name": "setuptools", + "sha256": "28e06dc17f7b36e384dfcc0506cc95840d75c6b4d73f5d37375fc5bc71242c71", + "size": 1456619, + "subdir": "linux-64", + "timestamp": 1666983132523, + "version": "65.4.0" + }, + "setuptools-65.5.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60d71ddf6023a619573305cf5dcc9221", + "name": "setuptools", + "sha256": "29ed5a3f71c934a4751557294bf67aac042c4fa694a23fd331055da6ed344912", + "size": 1445125, + "subdir": "linux-64", + "timestamp": 1667236179914, + "version": "65.5.0" + }, + "setuptools-65.5.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "449e08504e8d43d0afa62cc187eb8df9", + "name": "setuptools", + "sha256": "850a6c9f990ec32362bde733a4bdffe06676bad7a07f6894f9497f281ff12c61", + "size": 1893982, + "subdir": "linux-64", + "timestamp": 1669773298100, + "version": "65.5.0" + }, + "setuptools-65.5.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c03716f2c857b46ba156221715f03b7", + "name": "setuptools", + "sha256": "01e563973d47c4c98fe491365cd24422cc3a725b0abb5605b7415045b314bc25", + "size": 1440043, + "subdir": "linux-64", + "timestamp": 1667236125184, + "version": "65.5.0" + }, + "setuptools-65.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c8a92b43998cc14c24d67f42f6a8faa0", + "name": "setuptools", + "sha256": "134a1b37dee8187f1374417ca6e742f69067e133ff36362aa3602575d630f7ab", + "size": 1436496, + "subdir": "linux-64", + "timestamp": 1667236207481, + "version": "65.5.0" + }, + "setuptools-65.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "acfa3ffbcf23cc5d58fdfdad854688d4", + "name": "setuptools", + "sha256": "17690f4a16a45bf7be1bd42408475fbd6673c1ebe1407ca37c395b4c8e4c71c8", + "size": 1435731, + "subdir": "linux-64", + "timestamp": 1667236151454, + "version": "65.5.0" + }, + "setuptools-65.6.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e786bab0eb3557e1cb9ab5a9ae0002b", + "name": "setuptools", + "sha256": "eaf97838a8560f9e1ba6263d86859e025690218461054104409b81763fe30f44", + "size": 1446391, + "subdir": "linux-64", + "timestamp": 1672940228423, + "version": "65.6.3" + }, + "setuptools-65.6.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1427962cecb24e241fb0a4eb88cb555f", + "name": "setuptools", + "sha256": "32d8536fc901ce264d1017c5a0ee3dd7cae5a28504f7c849416f6a5db4dfa724", + "size": 1898794, + "subdir": "linux-64", + "timestamp": 1679339109425, + "version": "65.6.3" + }, + "setuptools-65.6.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f581793c66c363a5d820fd55ad8d4d90", + "name": "setuptools", + "sha256": "5ec021ae21f023370918e6ddf6364707b96e7590b6e7cee9202f4343975f5171", + "size": 1442275, + "subdir": "linux-64", + "timestamp": 1672940142881, + "version": "65.6.3" + }, + "setuptools-65.6.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d31dd71ac10bd267094b45cbf4927ef3", + "name": "setuptools", + "sha256": "3f42bcad0ec1b379cf6ca01ea3f1011c233183f274c4de8996526f70ccd67114", + "size": 1437815, + "subdir": "linux-64", + "timestamp": 1672940171796, + "version": "65.6.3" + }, + "setuptools-65.6.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e9e4c4e9dd6c9f28cfbb719eb474292", + "name": "setuptools", + "sha256": "e281cdbccaed7a7a88a174ab585e5c845b49806c764faf379c029c33bec11d48", + "size": 1436898, + "subdir": "linux-64", + "timestamp": 1672940199006, + "version": "65.6.3" + }, + "setuptools-git-1.2-py27h28b3542_1.tar.bz2": { + "build": "py27h28b3542_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "215989bca1cbac6c47864133a92e8f3b", + "name": "setuptools-git", + "sha256": "9c527894a39c5eacc607259ab873a842ac9a8490ed2c26a22bbffd5469f268f4", + "size": 15495, + "subdir": "linux-64", + "timestamp": 1535492431196, + "version": "1.2" + }, + "setuptools-git-1.2-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9c51b7ab58ea53da5fbaf9c82a27fee2", + "name": "setuptools-git", + "sha256": "406883f5c9505f2a2e9b38d8dda7936c392d5f33f99d0c59eeef0ee0ae08cf34", + "size": 18248, + "subdir": "linux-64", + "timestamp": 1642501110109, + "version": "1.2" + }, + "setuptools-git-1.2-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4f9af349e977a8758129eea1933b8fa9", + "name": "setuptools-git", + "sha256": "6f43fa260db042472d57c0f288142853ca58012c44c1467df3fb3cc675590a1e", + "size": 22877, + "subdir": "linux-64", + "timestamp": 1676845777477, + "version": "1.2" + }, + "setuptools-git-1.2-py35h28b3542_1.tar.bz2": { + "build": "py35h28b3542_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e8bd2f30b1da0c118530b516cd5e1092", + "name": "setuptools-git", + "sha256": "529c9fa96106e79958327cc7ce92a615bccbd82c6bd8d80fc5a086476b0f0002", + "size": 15992, + "subdir": "linux-64", + "timestamp": 1535492446015, + "version": "1.2" + }, + "setuptools-git-1.2-py36h28b3542_1.tar.bz2": { + "build": "py36h28b3542_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8b16c9ed66c39e2c2e9e7d8018204a68", + "name": "setuptools-git", + "sha256": "60d749362d97c0b711ef856c45ec60ee7804de7c69dfb8411b592dc983ea5667", + "size": 15952, + "subdir": "linux-64", + "timestamp": 1535492415754, + "version": "1.2" + }, + "setuptools-git-1.2-py37h28b3542_1.tar.bz2": { + "build": "py37h28b3542_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7ddb47163ea6f5ed0bee2a0c811584b5", + "name": "setuptools-git", + "sha256": "9b17400dc179a02c55d919f0957ffaba9690ed20452a3a68fe0fcca7a3ece2a7", + "size": 15952, + "subdir": "linux-64", + "timestamp": 1535492424775, + "version": "1.2" + }, + "setuptools-git-versioning-1.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "deprecated", + "packaging", + "python >=3.10,<3.11.0a0", + "setuptools", + "toml >=0.10.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a3b8cd60c38644c5653ece1f98f6d08", + "name": "setuptools-git-versioning", + "sha256": "fec04d3d08d341226faece67093482afa923315f2b42852ef8363f5650f770b4", + "size": 20801, + "subdir": "linux-64", + "timestamp": 1667894881747, + "version": "1.11.0" + }, + "setuptools-git-versioning-1.11.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "deprecated", + "packaging", + "python >=3.7,<3.8.0a0", + "setuptools", + "toml >=0.10.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17b3cc10420c32d73f710a91a0b75137", + "name": "setuptools-git-versioning", + "sha256": "bb14ca58921f654dbcaf7626fcc653466bf586f99843cb6aac8b0b17f047056c", + "size": 20630, + "subdir": "linux-64", + "timestamp": 1667894933902, + "version": "1.11.0" + }, + "setuptools-git-versioning-1.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "deprecated", + "packaging", + "python >=3.8,<3.9.0a0", + "setuptools", + "toml >=0.10.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0a39500e57b47969001ea91da9fb40b", + "name": "setuptools-git-versioning", + "sha256": "54e0e33a9bb9bad6d3c700f55db60221b70b90b966af15a55eaf8a049f7ac8e8", + "size": 20691, + "subdir": "linux-64", + "timestamp": 1667894959828, + "version": "1.11.0" + }, + "setuptools-git-versioning-1.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "deprecated", + "packaging", + "python >=3.9,<3.10.0a0", + "setuptools", + "toml >=0.10.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8c1e70898e3bd7ee52e7aec4314c853", + "name": "setuptools-git-versioning", + "sha256": "34d8540d0d9fa9d82235afd1112315604560cc76349b6f8b7266b9d08242fd7b", + "size": 20696, + "subdir": "linux-64", + "timestamp": 1667894907696, + "version": "1.11.0" + }, + "setuptools-git-versioning-1.13.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.10,<3.11.0a0", + "setuptools", + "toml >=0.10.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "465fe61488d999e9c8c17bd3c12cc605", + "name": "setuptools-git-versioning", + "sha256": "aa4f607f057d2a2ce301891a0c1b6058d82c4b02dd7377782d34b4616b719a24", + "size": 21845, + "subdir": "linux-64", + "timestamp": 1670426115539, + "version": "1.13.1" + }, + "setuptools-git-versioning-1.13.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9231a80a1c922441995c32014dede68b", + "name": "setuptools-git-versioning", + "sha256": "f8aac3d616941c960a92b000eb1ec0f0bf33b3d6fc21d12b6fc23a621aeddbaf", + "size": 27455, + "subdir": "linux-64", + "timestamp": 1676828843768, + "version": "1.13.1" + }, + "setuptools-git-versioning-1.13.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.7,<3.8.0a0", + "setuptools", + "toml >=0.10.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "093768d926d36af30ed8af15537a731a", + "name": "setuptools-git-versioning", + "sha256": "26a2b4990be72ae5ccf4077699a4281904b00c28eeeb807ded6aa5d42f141c6d", + "size": 21553, + "subdir": "linux-64", + "timestamp": 1670426089828, + "version": "1.13.1" + }, + "setuptools-git-versioning-1.13.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.8,<3.9.0a0", + "setuptools", + "toml >=0.10.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c06cf0627a2a94a8b8d13839a25df84", + "name": "setuptools-git-versioning", + "sha256": "f370b8475bda673d12e2e85cb1851864f6774d000ad72f77069322340ee3baf0", + "size": 21649, + "subdir": "linux-64", + "timestamp": 1670426140671, + "version": "1.13.1" + }, + "setuptools-git-versioning-1.13.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.9,<3.10.0a0", + "setuptools", + "toml >=0.10.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "442ae0133632070c56b2ff328473bc7b", + "name": "setuptools-git-versioning", + "sha256": "be19be21a7cde262d9480cc5456bb52b441a434029ac1528f5432c6f6a876031", + "size": 21724, + "subdir": "linux-64", + "timestamp": 1670426165984, + "version": "1.13.1" + }, + "setuptools-rust-1.5.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "semantic_version >=2.8.2,<3", + "setuptools >=62.4", + "typing_extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "396d6bc43df1654aa67be386fd37f777", + "name": "setuptools-rust", + "sha256": "6647061ee9a9463183a3e3be74d1b3f304f4cbb9fda4467b7b4b3586e8f15647", + "size": 40276, + "subdir": "linux-64", + "timestamp": 1667503220856, + "version": "1.5.2" + }, + "setuptools-rust-1.5.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "semantic_version >=2.8.2,<3", + "setuptools >=62.4", + "typing_extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f2bcd069dee149365ec7e4f469f0645", + "name": "setuptools-rust", + "sha256": "6875b8b4ee8eed8bed8c50d843e7daa4fbc99f31fedee7a15fced475b65f6351", + "size": 52275, + "subdir": "linux-64", + "timestamp": 1676822566303, + "version": "1.5.2" + }, + "setuptools-rust-1.5.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "semantic_version >=2.8.2,<3", + "setuptools >=62.4", + "typing_extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "915a2519b2cabd1aa18adb2d52d22be6", + "name": "setuptools-rust", + "sha256": "c0b10aba2ecab4c3642504a267c8d398d50c791dbc687f4c798610cf9efe9ba4", + "size": 39792, + "subdir": "linux-64", + "timestamp": 1667503272934, + "version": "1.5.2" + }, + "setuptools-rust-1.5.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "semantic_version >=2.8.2,<3", + "setuptools >=62.4", + "typing_extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "567396c679cad3ee27b97043e24a6af6", + "name": "setuptools-rust", + "sha256": "3c2baa74d4b2ca2051f02d9f54f08b05c02f017666665c80ba7c360a738e8829", + "size": 39957, + "subdir": "linux-64", + "timestamp": 1667503195248, + "version": "1.5.2" + }, + "setuptools-rust-1.5.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "semantic_version >=2.8.2,<3", + "setuptools >=62.4", + "typing_extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e5d5ce45d2be20a21e2cf7bf707e5b3", + "name": "setuptools-rust", + "sha256": "571ff75af0e4103d4aa952295243bff37e07d87d4fce90a080fa65e63f69b91b", + "size": 40019, + "subdir": "linux-64", + "timestamp": 1667503246636, + "version": "1.5.2" + }, + "setuptools-scm-7.0.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20.0", + "python >=3.10,<3.11.0a0", + "setuptools >=45", + "tomli >=1.0.0", + "typing-extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1016b2773ca097e5d3bb7bb5ded87c1f", + "name": "setuptools-scm", + "sha256": "0fb871e92e70f5aa305566c5198a6c137133e8d4061f8fff3038347945e87464", + "size": 62669, + "subdir": "linux-64", + "timestamp": 1657093026935, + "version": "7.0.4" + }, + "setuptools-scm-7.0.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20.0", + "python >=3.11,<3.12.0a0", + "setuptools >=45", + "tomli >=1.0.0", + "typing-extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "159b6d37abc0a039f644147e89340c44", + "name": "setuptools-scm", + "sha256": "3c995ace959ff905be6dfdb71eeabe897e6f47e209ee445bfa945f218d857867", + "size": 78963, + "subdir": "linux-64", + "timestamp": 1676822741030, + "version": "7.0.4" + }, + "setuptools-scm-7.0.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "packaging >=20.0", + "python >=3.7,<3.8.0a0", + "setuptools >=45", + "tomli >=1.0.0", + "typing-extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92ea8b74beb65277c6a3b9618f7450d9", + "name": "setuptools-scm", + "sha256": "65c906eedf3c6bcb8d898ac4acc3dc44e67dd14f0eb52c11defcf7d21c189def", + "size": 61394, + "subdir": "linux-64", + "timestamp": 1657093054354, + "version": "7.0.4" + }, + "setuptools-scm-7.0.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20.0", + "python >=3.8,<3.9.0a0", + "setuptools >=45", + "tomli >=1.0.0", + "typing-extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2dab71f169865f303b5f961ce638509", + "name": "setuptools-scm", + "sha256": "17559001e55fe3ec11331850f1ade69cf91002783e2798ea0e8d27acbe7c0bc9", + "size": 61751, + "subdir": "linux-64", + "timestamp": 1657093066967, + "version": "7.0.4" + }, + "setuptools-scm-7.0.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20.0", + "python >=3.9,<3.10.0a0", + "setuptools >=45", + "tomli >=1.0.0", + "typing-extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4cb7864e3a116c4aa8cc7b315e61fb48", + "name": "setuptools-scm", + "sha256": "1da4ac5ce042edbe7f6aa66ec98d7c1b2310004b3d071af95300ed7fbe261f81", + "size": 61793, + "subdir": "linux-64", + "timestamp": 1657093041642, + "version": "7.0.4" + }, + "setuptools_scm-1.15.6-py27h3d0bb11_0.tar.bz2": { + "build": "py27h3d0bb11_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "d15c66248193652ab97dfd9614c17674", + "name": "setuptools_scm", + "sha256": "dd90197b33e26d40613ae524f30e1be2821ff83a8e47cf3661267f991d5fabe3", + "size": 21808, + "subdir": "linux-64", + "timestamp": 1505688222827, + "version": "1.15.6" + }, + "setuptools_scm-1.15.6-py35ha940eae_0.tar.bz2": { + "build": "py35ha940eae_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "f219ebd8c03c9d8f560d41ca6508e9d0", + "name": "setuptools_scm", + "sha256": "d344d8af76b425c111a531daca66d7f5ad9cc2c582b9544599ec5c08ca4de8d3", + "size": 22157, + "subdir": "linux-64", + "timestamp": 1505688234290, + "version": "1.15.6" + }, + "setuptools_scm-1.15.6-py36h9817af8_0.tar.bz2": { + "build": "py36h9817af8_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "4e8165ed6d41a90debd007b1518a6440", + "name": "setuptools_scm", + "sha256": "56a405323038f291c3e842e4b4dd8de7e64137e7d082fc945e8b7a31f2816525", + "size": 22033, + "subdir": "linux-64", + "timestamp": 1505688245892, + "version": "1.15.6" + }, + "setuptools_scm-1.15.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "c7a47f310d99457afd106c4c2202f788", + "name": "setuptools_scm", + "sha256": "92081a102078665f14f92f8ec924f4700082e2d594ab187a8ffa272a3952e0ee", + "size": 25009, + "subdir": "linux-64", + "timestamp": 1520780231849, + "version": "1.15.7" + }, + "setuptools_scm-1.15.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "bd39c2dc4793623af1fee0f01906193c", + "name": "setuptools_scm", + "sha256": "3c67f2742beab4b94208b8e729c27abb6f2e7df69e4d043bbdf701c2302ebcca", + "size": 25449, + "subdir": "linux-64", + "timestamp": 1520780241763, + "version": "1.15.7" + }, + "setuptools_scm-1.15.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "5243bad927167436588a5b471f99d77c", + "name": "setuptools_scm", + "sha256": "d42222062a61e7639ce9ff808522b9af76ffc3b862f9ff27a19d7d4dca754a65", + "size": 25321, + "subdir": "linux-64", + "timestamp": 1520780218096, + "version": "1.15.7" + }, + "setuptools_scm-1.17.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "c53d14fb7b5e0d8352a51ef3e06565ac", + "name": "setuptools_scm", + "sha256": "44d68cd2acf2ca2ca97df77f0fc8f0a2796b4a123776feda5499f4650412d055", + "size": 25853, + "subdir": "linux-64", + "timestamp": 1522195423605, + "version": "1.17.0" + }, + "setuptools_scm-1.17.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "d74d07350e9e3289f187e290a1e2335b", + "name": "setuptools_scm", + "sha256": "ac6c818bc54af84720e6a57c97d426872bb503f2f62bb80155a5528f0bfd1040", + "size": 26207, + "subdir": "linux-64", + "timestamp": 1522195431529, + "version": "1.17.0" + }, + "setuptools_scm-1.17.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "c4e86c3cd3af41f38ec524be8219e495", + "name": "setuptools_scm", + "sha256": "698bbc6326eed71b75e3fbf6a06637467553054dd6d40daf20036cc30681e729", + "size": 26155, + "subdir": "linux-64", + "timestamp": 1522195435738, + "version": "1.17.0" + }, + "setuptools_scm-2.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "37086bedc3a4827ffdad8cee3a124c50", + "name": "setuptools_scm", + "sha256": "489f1a750c674491391528f79b807c8a2f46543389fae293a29f22c1a0eda750", + "size": 27038, + "subdir": "linux-64", + "timestamp": 1524070005092, + "version": "2.0.0" + }, + "setuptools_scm-2.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "b32165c637432a5a31832735378322e4", + "name": "setuptools_scm", + "sha256": "f8e3dbbc53c05315aa7327ab3531c0d7fab813c2965e9b9a24f63ae598b26ed3", + "size": 27482, + "subdir": "linux-64", + "timestamp": 1524070042453, + "version": "2.0.0" + }, + "setuptools_scm-2.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "577acb229058c4adf6883394363a2fd7", + "name": "setuptools_scm", + "sha256": "0841b79073dac3a05120ace8284665c28b97d796c8bc5bd9a4b84723da042d11", + "size": 27361, + "subdir": "linux-64", + "timestamp": 1524070047452, + "version": "2.0.0" + }, + "setuptools_scm-2.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "731548780331902513b289a4cb22f10f", + "name": "setuptools_scm", + "sha256": "638538ca1452b48be96bbac44629f7c7912661dc4e44805e0a8e065cb74d5b6d", + "size": 29234, + "subdir": "linux-64", + "timestamp": 1526922682844, + "version": "2.1.0" + }, + "setuptools_scm-2.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "e2f87c3628d21d4fafc2445a660f28ef", + "name": "setuptools_scm", + "sha256": "b2edc5dc8972a4d81e35823ad3cc39a0a09dc06e939acff1bbd9f0ec3f7f40cd", + "size": 29773, + "subdir": "linux-64", + "timestamp": 1526922703095, + "version": "2.1.0" + }, + "setuptools_scm-2.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "788946df173c47b9dde8530d9f435983", + "name": "setuptools_scm", + "sha256": "c48843f321b64d056fbec99b8d964e40c1f07aab982f89d65601ad95aea7cf19", + "size": 29684, + "subdir": "linux-64", + "timestamp": 1526922659732, + "version": "2.1.0" + }, + "setuptools_scm-2.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "ee592413da8bc157cb2139268b66eb96", + "name": "setuptools_scm", + "sha256": "e8409b8d0d0704f2c5e65ff4141af736560ffd0fc990c15d97d409ec29741f93", + "size": 29825, + "subdir": "linux-64", + "timestamp": 1530693798333, + "version": "2.1.0" + }, + "setuptools_scm-3.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "c6d51e10bab176b927760934885b8f59", + "name": "setuptools_scm", + "sha256": "6572dd126ca70a47736fdbecd89c7f00a721f991289a5bc752dfb4d0f0082960", + "size": 34239, + "subdir": "linux-64", + "timestamp": 1532631783712, + "version": "3.0.2" + }, + "setuptools_scm-3.0.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "fdbe8c3653403611696ffdc641f786d6", + "name": "setuptools_scm", + "sha256": "354ef24cb9773be1c61c0fde315b5741fd4b987e73ccf67f48b884aa7345d199", + "size": 34712, + "subdir": "linux-64", + "timestamp": 1532631862288, + "version": "3.0.2" + }, + "setuptools_scm-3.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "a7013f75f2acd50f923340a572b2e391", + "name": "setuptools_scm", + "sha256": "83d6d0905f83901cacd7f8075bb06244b122fd395901573f24df7c704b7d7863", + "size": 34611, + "subdir": "linux-64", + "timestamp": 1532631758666, + "version": "3.0.2" + }, + "setuptools_scm-3.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "7de92521ca1aa876215b42c176dcdb60", + "name": "setuptools_scm", + "sha256": "9be8b3f42f131350bad46e881ec5ff124d71d336fa65103efcf297b5841d476e", + "size": 34711, + "subdir": "linux-64", + "timestamp": 1532631870109, + "version": "3.0.2" + }, + "setuptools_scm-3.0.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "f32844a109acb3022ffac9b2f2bd4c72", + "name": "setuptools_scm", + "sha256": "d9229eaf24daafc79ae669f3d4cd491df07708d06ebd4761ba58adb8b3fa9cf4", + "size": 32470, + "subdir": "linux-64", + "timestamp": 1533683305329, + "version": "3.0.6" + }, + "setuptools_scm-3.0.6-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "4587775ded8e789d0585793a18d7ff33", + "name": "setuptools_scm", + "sha256": "f0f335b12483d736eeb44a9a51a39a42c598b4c8adc58ed1adfa03031e83a48d", + "size": 34239, + "subdir": "linux-64", + "timestamp": 1534344985211, + "version": "3.0.6" + }, + "setuptools_scm-3.0.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "ba45f2c6c69aa6d0e12f95dcd811e934", + "name": "setuptools_scm", + "sha256": "ba92dad967afdd00246363359e9768868d6426e33ace83eef708e3aad7ada287", + "size": 33005, + "subdir": "linux-64", + "timestamp": 1533683334354, + "version": "3.0.6" + }, + "setuptools_scm-3.0.6-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "af853f85f87e01a88a9381344ad921b4", + "name": "setuptools_scm", + "sha256": "c8ee5bcf84b21a4848dc86451cdb6bb25c5921517e5dab577630d635a69575f3", + "size": 34698, + "subdir": "linux-64", + "timestamp": 1534345032470, + "version": "3.0.6" + }, + "setuptools_scm-3.0.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "2cef2573313301076e60968959947752", + "name": "setuptools_scm", + "sha256": "9c99db64245ef9c5aa608bf704c99409616a2158f399b580a5f1d9851ab3741a", + "size": 32876, + "subdir": "linux-64", + "timestamp": 1533683283345, + "version": "3.0.6" + }, + "setuptools_scm-3.0.6-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "1adeb573a934ad8dbfc931b1bac4b267", + "name": "setuptools_scm", + "sha256": "53641acd863761e911a831938b2674b6d2c2026fe2d20a77c8a9cab278efa659", + "size": 34608, + "subdir": "linux-64", + "timestamp": 1534345008599, + "version": "3.0.6" + }, + "setuptools_scm-3.0.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "6cd12a04aec8e68ffdc6c18f34fd1a5d", + "name": "setuptools_scm", + "sha256": "576f65ec7557780027ead093a8135198018c919972758c69d024a8dd30097d18", + "size": 32943, + "subdir": "linux-64", + "timestamp": 1533686183948, + "version": "3.0.6" + }, + "setuptools_scm-3.0.6-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "d7c975f81b4236095612651c55194969", + "name": "setuptools_scm", + "sha256": "e0a4ddddccfe793027a8f2c399eaeaa07da2e96aa14f481692b8b9d81e46350d", + "size": 34649, + "subdir": "linux-64", + "timestamp": 1534345056207, + "version": "3.0.6" + }, + "setuptools_scm-3.1.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "aa9a0f0892ce9c0c3da6fe1b43d08a70", + "name": "setuptools_scm", + "sha256": "1043fe7a64c2e37d9d5136c6f920d7f6a20988d7318283830f655dfaff681658", + "size": 33105, + "subdir": "linux-64", + "timestamp": 1534667423567, + "version": "3.1.0" + }, + "setuptools_scm-3.1.0-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "2ec7626658501a6fa27ca59f8f7250aa", + "name": "setuptools_scm", + "sha256": "3cfc7a322b46a3c9f87ba55eccaf21634c5a2cf09d4f9181319e0473ad8f0ecd", + "size": 33584, + "subdir": "linux-64", + "timestamp": 1534667501889, + "version": "3.1.0" + }, + "setuptools_scm-3.1.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "16bc1799af0c1c459a54e1670ec7c0c6", + "name": "setuptools_scm", + "sha256": "4527cb4cef3944840f5de8ef7ebcf9026a1256dd29a6f6e485fc1123c278bffa", + "size": 33426, + "subdir": "linux-64", + "timestamp": 1534667413425, + "version": "3.1.0" + }, + "setuptools_scm-3.1.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "f9faacdc2c995c41c066800076f767c5", + "name": "setuptools_scm", + "sha256": "4be07ddf8c7d85aa76b820a43e3325d4128c0f8322736fe9fe622bae7478a477", + "size": 33532, + "subdir": "linux-64", + "timestamp": 1534667503034, + "version": "3.1.0" + }, + "setuptools_scm_git_archive-1.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e844c9e51e43cefd864efb817a1a9930", + "name": "setuptools_scm_git_archive", + "sha256": "29a93a61649dcdf9881e7ffca099a30e2232793ae583062ff43f08bcbd37a5f3", + "size": 6503, + "subdir": "linux-64", + "timestamp": 1519015425578, + "version": "1.0" + }, + "setuptools_scm_git_archive-1.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ca56fdaef4e3bc46fb81e5e786b9511", + "name": "setuptools_scm_git_archive", + "sha256": "0221049077a0766c9b4cff55b65ed311a22849659b516e0db7df3ab45bb7023f", + "size": 6544, + "subdir": "linux-64", + "timestamp": 1519015436430, + "version": "1.0" + }, + "setuptools_scm_git_archive-1.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "00b85982a49c26eb68eb922288ea3071", + "name": "setuptools_scm_git_archive", + "sha256": "2cab35ff577800a23e6e5346c72e1c5ef39a3ea6f86ffefb184d2f55895a0d2c", + "size": 6515, + "subdir": "linux-64", + "timestamp": 1519015439921, + "version": "1.0" + }, + "setuptools_scm_git_archive-1.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e915b0c35be7185d4eba493be6d8c20f", + "name": "setuptools_scm_git_archive", + "sha256": "31c091bda75a5e933fa18ef8ce95387bce07cbfb386c6664d30554568898b53b", + "size": 6401, + "subdir": "linux-64", + "timestamp": 1530812003098, + "version": "1.0" + }, + "setuptools_scm_git_archive-1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d92aa18c6b421a1331d349d34c1783bc", + "name": "setuptools_scm_git_archive", + "sha256": "fcce802eb241e220e0c09367b70ea4f284856af0b1300511a8ed60e21eef088e", + "size": 7269, + "subdir": "linux-64", + "timestamp": 1564707041898, + "version": "1.1" + }, + "setuptools_scm_git_archive-1.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b331ef9701702fe51d13355a1a1fcda4", + "name": "setuptools_scm_git_archive", + "sha256": "00c9bbf11c1d0a77a49696058a38eacedc4a8ce75afbd33f1dcdc4b4710e4740", + "size": 6492, + "subdir": "linux-64", + "timestamp": 1640794666184, + "version": "1.1" + }, + "setuptools_scm_git_archive-1.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "450504e1f5adeab3910e65571b91e662", + "name": "setuptools_scm_git_archive", + "sha256": "ab1e3fb8e154ef107673c72eb3a4c0dc73fbf37b020e99558b327fcd39f2c829", + "size": 7209, + "subdir": "linux-64", + "timestamp": 1676827496702, + "version": "1.1" + }, + "setuptools_scm_git_archive-1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a1f4381d20e22cc6fb72956d4fae4b9", + "name": "setuptools_scm_git_archive", + "sha256": "9a04b441a3ae07da3ec5441a53594cffc05877d83636aa72670465f6bec19813", + "size": 7326, + "subdir": "linux-64", + "timestamp": 1564707066977, + "version": "1.1" + }, + "setuptools_scm_git_archive-1.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d144eb5de62fe5f82f12866f6dbf1601", + "name": "setuptools_scm_git_archive", + "sha256": "ff0c26ae32218bc26b4b148148c6e0877b128248b45b69723aab6ff902266307", + "size": 7413, + "subdir": "linux-64", + "timestamp": 1611753627837, + "version": "1.1" + }, + "setuptools_scm_git_archive-1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "717caa5072a7a23c6f9c3ee270300856", + "name": "setuptools_scm_git_archive", + "sha256": "71f537b4c30fcd5dda237a333a59d206823734380b631a4f6f0f86c8bdbf23ed", + "size": 7327, + "subdir": "linux-64", + "timestamp": 1564706744935, + "version": "1.1" + }, + "setuptools_scm_git_archive-1.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d39fc3026ec42039ea78d84236746b98", + "name": "setuptools_scm_git_archive", + "sha256": "bc443be578f406aed8f14a7c1aa4bdba376879371480b551b39148cf70ebda26", + "size": 7396, + "subdir": "linux-64", + "timestamp": 1611753504787, + "version": "1.1" + }, + "setuptools_scm_git_archive-1.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80b027c554bf59b0bb7b52bb15e130e2", + "name": "setuptools_scm_git_archive", + "sha256": "cf77151161c85702bd7a794c5343189f76bc2f9914cf1d9f1458928c7cbd72a5", + "size": 6658, + "subdir": "linux-64", + "timestamp": 1574170623313, + "version": "1.1" + }, + "setuptools_scm_git_archive-1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "877d06bcdc957501ce4dbbc9d30c7b9e", + "name": "setuptools_scm_git_archive", + "sha256": "84977d11295359638c1c35969586be99bd7057e2e81c323f9b10699e2d6c9822", + "size": 7412, + "subdir": "linux-64", + "timestamp": 1611753615975, + "version": "1.1" + }, + "setuptools_scm_git_archive-1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e7326b97b9900f2b80d13f3ff6f290ab", + "name": "setuptools_scm_git_archive", + "sha256": "e7435fb602f2144c20de0448ae3b1d00beef1664bfe50f3b2c62d86d549e5fe6", + "size": 7432, + "subdir": "linux-64", + "timestamp": 1611753613887, + "version": "1.1" + }, + "sh-1.12.14-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e3fea31567b59dca6da6719c1507537", + "name": "sh", + "sha256": "a9f28d57cc688e521e18c1747725e0452ef6008152a0608af5ec44437a2be803", + "size": 59281, + "subdir": "linux-64", + "timestamp": 1530961035359, + "version": "1.12.14" + }, + "sh-1.12.14-py27h3066367_0.tar.bz2": { + "build": "py27h3066367_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9b7734b25aa3728156dec94f41f7634", + "name": "sh", + "sha256": "5773ae90067b9b86acfae7dde65409e085930b3259d3a12f1c10b7da647a67bf", + "size": 59498, + "subdir": "linux-64", + "timestamp": 1508445817559, + "version": "1.12.14" + }, + "sh-1.12.14-py35h291aafe_0.tar.bz2": { + "build": "py35h291aafe_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1854cd1ef6e8bed5fd0d5fa19ce4f950", + "name": "sh", + "sha256": "452afc4018e4c72728702002c6b442bfe51b7515260fa8ab175069baf408c472", + "size": 60869, + "subdir": "linux-64", + "timestamp": 1508445825366, + "version": "1.12.14" + }, + "sh-1.12.14-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5a5031319e5abaf9e782a669c323c95f", + "name": "sh", + "sha256": "b8eb136ef56866ff913a88c80fec212e8a18f99d7506d7481a6552d17c27f86a", + "size": 60168, + "subdir": "linux-64", + "timestamp": 1530961064821, + "version": "1.12.14" + }, + "sh-1.12.14-py36h4f86635_0.tar.bz2": { + "build": "py36h4f86635_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e7358f7addfa1f3569e7829f3a69b45", + "name": "sh", + "sha256": "9d646dade974de49d61d3d65332a4f1ccb1f4511419704596f2ba41adcac3659", + "size": 60521, + "subdir": "linux-64", + "timestamp": 1508445814948, + "version": "1.12.14" + }, + "sh-1.12.14-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad7745d29c9b5b022e5983c09b0b97ef", + "name": "sh", + "sha256": "2898047ac939d7d427d41ece78c3a981daf96081b77b79cee098c340d982f159", + "size": 60185, + "subdir": "linux-64", + "timestamp": 1530961095174, + "version": "1.12.14" + }, + "sh-1.12.14-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43257033ab328a077ec1489333ed73db", + "name": "sh", + "sha256": "4bdf0c0af53ddd9564efbb2e4a91d0b778383102f9f676f05402dda5111992b2", + "size": 60815, + "subdir": "linux-64", + "timestamp": 1573200407347, + "version": "1.12.14" + }, + "sh-1.14.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "03cd05897dee3a24f2ab716f5616c99c", + "name": "sh", + "sha256": "e77afb8b42f25c013356d7ffcd406b7c22d01391c8ef03980d9a4aa87f35007e", + "size": 65650, + "subdir": "linux-64", + "timestamp": 1600553817491, + "version": "1.14.0" + }, + "sh-1.14.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d3830d877551792ae80671102bf686bd", + "name": "sh", + "sha256": "64fe7df6878142de1338bf8aa245b8e1965f8c6b22f710709706c2e6195dfefa", + "size": 65687, + "subdir": "linux-64", + "timestamp": 1600553840676, + "version": "1.14.0" + }, + "sh-1.14.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b725db7266ee62e42ae472d6d7530bb5", + "name": "sh", + "sha256": "5fa0ae9d74ff7406c24a5325fb261082e28703ca56bbb4e93ea1264021243e62", + "size": 65743, + "subdir": "linux-64", + "timestamp": 1600553824937, + "version": "1.14.0" + }, + "sh-1.14.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bfad62a8374d85b73633645bf278f279", + "name": "sh", + "sha256": "dac54fba98cf894eec5b0947e8e15681702425334d17c5e8ae595466b51845e8", + "size": 65738, + "subdir": "linux-64", + "timestamp": 1606865054357, + "version": "1.14.1" + }, + "sh-1.14.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be9eceddfa65c140e195f7d24c3a32e9", + "name": "sh", + "sha256": "5706af5ea1bfbb2dca6db348b3ab2175dd84982c910473cace86f0d347047cc6", + "size": 65622, + "subdir": "linux-64", + "timestamp": 1606865051688, + "version": "1.14.1" + }, + "sh-1.14.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7ed90e46302111c6ecc0e080634e851", + "name": "sh", + "sha256": "8446817de205a457cbd8b7563c0705dad7933444960b85826de2a6bf8691d171", + "size": 65903, + "subdir": "linux-64", + "timestamp": 1606865084569, + "version": "1.14.1" + }, + "sh-1.14.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc31bbed930ba93f988625efe0f8902d", + "name": "sh", + "sha256": "a1ff4efa499df47969b0f51b98a5245b5ddd81ce324fc0a849221687d52dfbb6", + "size": 67019, + "subdir": "linux-64", + "timestamp": 1640794683896, + "version": "1.14.2" + }, + "sh-1.14.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "97ac8e4a9ad01a98219399478433bf90", + "name": "sh", + "sha256": "db0137fee2c9d29713ca8f52d4e09aaf2cd87a493e1b23fcfb63a6629f260946", + "size": 87560, + "subdir": "linux-64", + "timestamp": 1676862166219, + "version": "1.14.2" + }, + "sh-1.14.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "efddc4922ebd337616d9d15a61e6e2f7", + "name": "sh", + "sha256": "37bc57ae49e3a132e526a9f00559e8f04d298e64fe00a9ef29f3e774956c43ed", + "size": 75712, + "subdir": "linux-64", + "timestamp": 1623833503141, + "version": "1.14.2" + }, + "sh-1.14.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f0233a52973bdf2347740d4cbc0e4e5", + "name": "sh", + "sha256": "de234c2331c2b5e8dd21952d73701be439b951748924c99a1440986ff00461b0", + "size": 75900, + "subdir": "linux-64", + "timestamp": 1623827651744, + "version": "1.14.2" + }, + "sh-1.14.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9412aced073e12746a5fb33c1f867beb", + "name": "sh", + "sha256": "f23809d808c87fa7030f78bc346b4165df18f8efc64b9d119229014a8c5ca8e4", + "size": 75859, + "subdir": "linux-64", + "timestamp": 1623833484415, + "version": "1.14.2" + }, + "sh-1.14.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "801c7b8a50290ccb0642f1c1edd85054", + "name": "sh", + "sha256": "f0251acf62b25754d6944839d53b53e206ed95c212be7663a9871ad5657440da", + "size": 76121, + "subdir": "linux-64", + "timestamp": 1623832784929, + "version": "1.14.2" + }, + "shap-0.39.0-py310h00e6091_0.tar.bz2": { + "build": "py310h00e6091_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "colorama", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numba", + "numpy", + "pandas", + "python >=3.10,<3.11.0a0", + "scikit-learn", + "scipy", + "slicer 0.0.7.*", + "tqdm >4.25.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4b42f455d51ecd33e9612c1c66d45c1a", + "name": "shap", + "sha256": "049058d1f4a651f0123c585c90dd8f6d25c7d93eece2e5de30152ca8f9315eb7", + "size": 665245, + "subdir": "linux-64", + "timestamp": 1640812964445, + "version": "0.39.0" + }, + "shap-0.39.0-py36h51133e4_0.tar.bz2": { + "build": "py36h51133e4_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "colorama", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numba", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy", + "slicer 0.0.7.*", + "tqdm >4.25.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b38d030fa6c05e29214d113da9d8948", + "name": "shap", + "sha256": "5db3a6b96c78b0869cfbb318f1048f6e5ebea76085553b2c62d59d65185c4e81", + "size": 583553, + "subdir": "linux-64", + "timestamp": 1633430506939, + "version": "0.39.0" + }, + "shap-0.39.0-py37h51133e4_0.tar.bz2": { + "build": "py37h51133e4_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "colorama", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numba", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy", + "slicer 0.0.7.*", + "tqdm >4.25.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4833b154495a4fbc7f4f875abfe70d28", + "name": "shap", + "sha256": "c97d6ca46d8308caf0cb43fc6774cc9cc9a957415deb2ce23a8c9698fee471c7", + "size": 560276, + "subdir": "linux-64", + "timestamp": 1633430482668, + "version": "0.39.0" + }, + "shap-0.39.0-py38h51133e4_0.tar.bz2": { + "build": "py38h51133e4_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "colorama", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numba", + "numpy", + "pandas", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy", + "slicer 0.0.7.*", + "tqdm >4.25.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9320252ef638cff09496c857f7a3aea2", + "name": "shap", + "sha256": "6153dff96247f49485d0e918db7044b898b968f965d9aefe1703bf8d1a1d6f3a", + "size": 584454, + "subdir": "linux-64", + "timestamp": 1633419792978, + "version": "0.39.0" + }, + "shap-0.39.0-py39h51133e4_0.tar.bz2": { + "build": "py39h51133e4_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "colorama", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numba", + "numpy", + "pandas", + "python >=3.9,<3.10.0a0", + "scikit-learn", + "scipy", + "slicer 0.0.7.*", + "tqdm >4.25.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "023974ef1b5cf338ee9f45620b6f55c3", + "name": "shap", + "sha256": "b6c2adf5910559a5717586603616ab149e864711a949336bddad71b3a3a6ac53", + "size": 584084, + "subdir": "linux-64", + "timestamp": 1633430478958, + "version": "0.39.0" + }, + "shap-0.41.0-py310h1128e8f_0.tar.bz2": { + "build": "py310h1128e8f_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numba", + "numpy", + "packaging >20.9", + "pandas", + "python >=3.10,<3.11.0a0", + "scikit-learn", + "scipy", + "slicer 0.0.7.*", + "tqdm >4.25.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "27699f04064e295603535b3e3e3c1e1e", + "name": "shap", + "sha256": "0894099482c70d1807df417a5b4617d31cd50c723220a0825d19828be9145bf6", + "size": 605709, + "subdir": "linux-64", + "timestamp": 1668715327960, + "version": "0.41.0" + }, + "shap-0.41.0-py37h417a72b_0.tar.bz2": { + "build": "py37h417a72b_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numba", + "numpy", + "packaging >20.9", + "pandas", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy", + "slicer 0.0.7.*", + "tqdm >4.25.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebf5de67202af51d481ccec693ad9416", + "name": "shap", + "sha256": "e2c161ca5309a5530d6d84449625ac41fd03c6178265e3a366bd7118abe0ae17", + "size": 602098, + "subdir": "linux-64", + "timestamp": 1668715537994, + "version": "0.41.0" + }, + "shap-0.41.0-py38h417a72b_0.tar.bz2": { + "build": "py38h417a72b_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numba", + "numpy", + "packaging >20.9", + "pandas", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy", + "slicer 0.0.7.*", + "tqdm >4.25.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9bdb177ceafc5b01d5a87776ef22164d", + "name": "shap", + "sha256": "7b4a6d394a48a9fa45d4861f22028a388f83c6e11279cfa049e58a752fa37f1c", + "size": 602218, + "subdir": "linux-64", + "timestamp": 1668715466551, + "version": "0.41.0" + }, + "shap-0.41.0-py39h417a72b_0.tar.bz2": { + "build": "py39h417a72b_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numba", + "numpy", + "packaging >20.9", + "pandas", + "python >=3.9,<3.10.0a0", + "scikit-learn", + "scipy", + "slicer 0.0.7.*", + "tqdm >4.25.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95e3f410d1127f34bb67f04e5bb20e5d", + "name": "shap", + "sha256": "a7ff49aaab91868d008b466bbaca563d76eabaa9d9292b4233864cd06cf8a38c", + "size": 601762, + "subdir": "linux-64", + "timestamp": 1668715399579, + "version": "0.41.0" + }, + "shapely-1.6.2-py27hd647e55_0.tar.bz2": { + "build": "py27hd647e55_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2604b01dec3f5f5ee5adf0a549cd26e4", + "name": "shapely", + "sha256": "ca758e710808a5a1c40c1e61d4e2f5959ecf6a4de792d3e009910b9ec5647736", + "size": 333949, + "subdir": "linux-64", + "timestamp": 1511290504550, + "version": "1.6.2" + }, + "shapely-1.6.2-py35h7e54424_0.tar.bz2": { + "build": "py35h7e54424_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cda42148b7ccae693c40d88667e47862", + "name": "shapely", + "sha256": "0f1243072a2fc055dc0be2c7a2ed22b60e8a74f1c3c65448ddae51dc9a1f8633", + "size": 329312, + "subdir": "linux-64", + "timestamp": 1511291063135, + "version": "1.6.2" + }, + "shapely-1.6.2-py36hfae5896_0.tar.bz2": { + "build": "py36hfae5896_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "895580f564bb1731aea4606402c09094", + "name": "shapely", + "sha256": "07ef28fd3a870a4bc5261197b108424593cbbefe159129a22934f1660ef001ef", + "size": 329941, + "subdir": "linux-64", + "timestamp": 1511290992700, + "version": "1.6.2" + }, + "shapely-1.6.4-py27h0c48222_0.tar.bz2": { + "build": "py27h0c48222_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f27d793d28a3ee18f76e9af1abf19d3b", + "name": "shapely", + "sha256": "ff20d3c990964ebb24d9a75c027b4ecf3c64acee5607e36f7921f4309234fcb5", + "size": 335549, + "subdir": "linux-64", + "timestamp": 1519758569150, + "version": "1.6.4" + }, + "shapely-1.6.4-py27h7ef4460_0.tar.bz2": { + "build": "py27h7ef4460_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "de48634531a65a8d676449d7003e3c52", + "name": "shapely", + "sha256": "f3cdfdd51969ef3dfb38368c5f5b4ff8b20ddd111dff1f079fe93d60097acecb", + "size": 336882, + "subdir": "linux-64", + "timestamp": 1530811488245, + "version": "1.6.4" + }, + "shapely-1.6.4-py27h86c5351_0.tar.bz2": { + "build": "py27h86c5351_0", + "build_number": 0, + "depends": [ + "geos >=3.7.1,<3.7.2.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7cfff7413c3ec9719bd57a274e66b40f", + "name": "shapely", + "sha256": "49d3feae1756d3b941e51dd4b099978d0bb2327fc673c1c8e8c97fea637edf34", + "size": 335992, + "subdir": "linux-64", + "timestamp": 1545319545019, + "version": "1.6.4" + }, + "shapely-1.6.4-py27hc5e8c75_0.tar.bz2": { + "build": "py27hc5e8c75_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a7db8aea87d24fd9069667783385ce16", + "name": "shapely", + "sha256": "68ec22781e9e632cf7057eff5380981de075fdb95442ce7f53d6b29edd22097d", + "size": 346052, + "subdir": "linux-64", + "timestamp": 1573751108962, + "version": "1.6.4" + }, + "shapely-1.6.4-py35h0c48222_0.tar.bz2": { + "build": "py35h0c48222_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "61fd87ecad06d188ebb96e5a7bafa1e0", + "name": "shapely", + "sha256": "f04d50d2c2e7d3d056ef83e9796bc913d55fec1c6958ae661b60916e8d806c12", + "size": 329633, + "subdir": "linux-64", + "timestamp": 1519758488223, + "version": "1.6.4" + }, + "shapely-1.6.4-py35h7ef4460_0.tar.bz2": { + "build": "py35h7ef4460_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "48ce9f02e015ee261f4d08554fbc08aa", + "name": "shapely", + "sha256": "7dde647ae276cd8be496e9671255c97f53036de9a2bc3540495fd8d47b81ef6f", + "size": 330213, + "subdir": "linux-64", + "timestamp": 1535129710774, + "version": "1.6.4" + }, + "shapely-1.6.4-py36h0c48222_0.tar.bz2": { + "build": "py36h0c48222_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cda9c4fc2ed2b63e8555714d5c57f97b", + "name": "shapely", + "sha256": "cfb1decf934822a53c12b78c4f7697c6ba83239708ba85bfdd51b37e0ba4cb79", + "size": 331326, + "subdir": "linux-64", + "timestamp": 1519758572723, + "version": "1.6.4" + }, + "shapely-1.6.4-py36h7ef4460_0.tar.bz2": { + "build": "py36h7ef4460_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d433958d6abf16b5f7363c8c65d051f7", + "name": "shapely", + "sha256": "7ff517542bcb477f043d83ea6fc99c5c49303db2efadb394ce279bc15111bd3b", + "size": 333404, + "subdir": "linux-64", + "timestamp": 1530811585163, + "version": "1.6.4" + }, + "shapely-1.6.4-py36h86c5351_0.tar.bz2": { + "build": "py36h86c5351_0", + "build_number": 0, + "depends": [ + "geos >=3.7.1,<3.7.2.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2a76bced07a91e550d15f06a68c35f01", + "name": "shapely", + "sha256": "a2eb8fddfe8c4d939d47b2ea4724cd096dded37669e13fbd4e750a4ace365bc0", + "size": 338351, + "subdir": "linux-64", + "timestamp": 1545319580634, + "version": "1.6.4" + }, + "shapely-1.6.4-py36hc5e8c75_0.tar.bz2": { + "build": "py36hc5e8c75_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "da09029a0f1c005cec3e8a4390ff6a5d", + "name": "shapely", + "sha256": "a75cb0e3869881be42d64e063bcccfc9d91fba4e6ceceababa40f7c7fe488fa9", + "size": 339261, + "subdir": "linux-64", + "timestamp": 1573751085706, + "version": "1.6.4" + }, + "shapely-1.6.4-py37h7ef4460_0.tar.bz2": { + "build": "py37h7ef4460_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a31fe8aa10631fdf562462b36e53ebaf", + "name": "shapely", + "sha256": "c4b619709e149853215bee34a86b2c67c030d50ee87c86dbe1a8868e465c95b0", + "size": 332715, + "subdir": "linux-64", + "timestamp": 1530811536166, + "version": "1.6.4" + }, + "shapely-1.6.4-py37h86c5351_0.tar.bz2": { + "build": "py37h86c5351_0", + "build_number": 0, + "depends": [ + "geos >=3.7.1,<3.7.2.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "08164b8e047f9a93fbee6dc68acd6899", + "name": "shapely", + "sha256": "bc39f2ce0a35680070f90cf54e024a7b0f85802da58dfe2431e1b24b8c63816a", + "size": 326265, + "subdir": "linux-64", + "timestamp": 1545319594142, + "version": "1.6.4" + }, + "shapely-1.6.4-py37hc5e8c75_0.tar.bz2": { + "build": "py37hc5e8c75_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ca38769f53ab2961f84d988e2c22fdaa", + "name": "shapely", + "sha256": "d506c502e3d35d20cd7998c538a0e84ee062c6ff69b95c8bac33c024893b1226", + "size": 337936, + "subdir": "linux-64", + "timestamp": 1573751074361, + "version": "1.6.4" + }, + "shapely-1.6.4-py38h86c5351_0.tar.bz2": { + "build": "py38h86c5351_0", + "build_number": 0, + "depends": [ + "geos >=3.7.1,<3.7.2.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "57e59bb1308b7cc43bf45ae62fc97c0e", + "name": "shapely", + "sha256": "b365236f3e473c23e959a72eef081ac60e8a0ea3a89991a61f8fc51fe1799b15", + "size": 338944, + "subdir": "linux-64", + "timestamp": 1573557135513, + "version": "1.6.4" + }, + "shapely-1.6.4-py38hc5e8c75_0.tar.bz2": { + "build": "py38hc5e8c75_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b7b93d1b8b91d321ee82d446c40e708c", + "name": "shapely", + "sha256": "62c810979047a9ff4e043b387e2a9ae624489591fa7ee8de92cdbe70aa734f70", + "size": 363201, + "subdir": "linux-64", + "timestamp": 1573751118184, + "version": "1.6.4" + }, + "shapely-1.7.0-py310h21a7e75_0.tar.bz2": { + "build": "py310h21a7e75_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c223866223f2f1864bbe2a20a5ce1c16", + "name": "shapely", + "sha256": "48b37cc18dc61a57207e26a66b60336619356a9ccc9df74a0ee3735e0971ab98", + "size": 832380, + "subdir": "linux-64", + "timestamp": 1640794718579, + "version": "1.7.0" + }, + "shapely-1.7.0-py311h438bf8d_0.tar.bz2": { + "build": "py311h438bf8d_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "06c31da6766963afb343b2e1d0218c10", + "name": "shapely", + "sha256": "da07e1c592f85d169c880c8f9cbe9d1128b11ee1c463da368a4f2373deb724fa", + "size": 472760, + "subdir": "linux-64", + "timestamp": 1676842845239, + "version": "1.7.0" + }, + "shapely-1.7.0-py36h7c4d384_0.tar.bz2": { + "build": "py36h7c4d384_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7f27e9ec922758785fa3244a9a10baf6", + "name": "shapely", + "sha256": "9de8db2a1fe89b41c511a22d8fd4475ba6d76343b0c3be677a92aea117eb6cca", + "size": 431721, + "subdir": "linux-64", + "timestamp": 1613149341140, + "version": "1.7.0" + }, + "shapely-1.7.0-py36h98ec03d_0.tar.bz2": { + "build": "py36h98ec03d_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b44375bca0c82a6d43b21235dcf800aa", + "name": "shapely", + "sha256": "785ff3cd2731a66f4f34fdaa4d2e575a1818183be8a4a4d11cacce7f898caba8", + "size": 450959, + "subdir": "linux-64", + "timestamp": 1588545419811, + "version": "1.7.0" + }, + "shapely-1.7.0-py37h7c4d384_0.tar.bz2": { + "build": "py37h7c4d384_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "23d4457a9d21734f44ece4c599d64aa4", + "name": "shapely", + "sha256": "249bec07cf62dfc6d7c28d83bdbdc943dba6d1963bd2b608e50a95c78ac89f43", + "size": 432308, + "subdir": "linux-64", + "timestamp": 1613149331506, + "version": "1.7.0" + }, + "shapely-1.7.0-py37h98ec03d_0.tar.bz2": { + "build": "py37h98ec03d_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "96b74e6158b1cef3325c4cd6fdc96849", + "name": "shapely", + "sha256": "fb6aeac8c8302e51672264e81595d5000988249dfe29719bc93861c8277730ae", + "size": 456874, + "subdir": "linux-64", + "timestamp": 1588545398700, + "version": "1.7.0" + }, + "shapely-1.7.0-py38h7c4d384_0.tar.bz2": { + "build": "py38h7c4d384_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "1a37c2472128ed99da00f71bfc280251", + "name": "shapely", + "sha256": "41798e01c5de1cf0a765869fde49d057e720b2e799b66fe3c8295bdb13143875", + "size": 444092, + "subdir": "linux-64", + "timestamp": 1613148987657, + "version": "1.7.0" + }, + "shapely-1.7.0-py38h98ec03d_0.tar.bz2": { + "build": "py38h98ec03d_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "762c4d5dd439d900beae77329ea8d9c1", + "name": "shapely", + "sha256": "30009bd27b0307d79c83d164fc07282bcd0a4e6d41c49c226264cc61d747c39b", + "size": 459721, + "subdir": "linux-64", + "timestamp": 1588545378804, + "version": "1.7.0" + }, + "shapely-1.7.0-py39h7c4d384_0.tar.bz2": { + "build": "py39h7c4d384_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "0af4eff4232fbed399b3566ab219c1aa", + "name": "shapely", + "sha256": "2630fe2a32ccd07e8552ba321eff4f3e33e5442dd9ad6f0b57bf339371d9c27f", + "size": 443424, + "subdir": "linux-64", + "timestamp": 1613149330693, + "version": "1.7.0" + }, + "shapely-1.7.1-py36h1728cc4_0.tar.bz2": { + "build": "py36h1728cc4_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c1098d4e259de6392aa2ee27adf7d126", + "name": "shapely", + "sha256": "31a1869b0aa14546671f8be848a68edbf6c5eed5ac16b90e4680769f6c092302", + "size": 447162, + "subdir": "linux-64", + "timestamp": 1632813589910, + "version": "1.7.1" + }, + "shapely-1.7.1-py36h98ec03d_0.tar.bz2": { + "build": "py36h98ec03d_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "df691c26b01713a37078bb7ff17db221", + "name": "shapely", + "sha256": "48b458d758e490dff8f1987590f6566f0c8b83b44d1bc9b94c4b6c55fac966f4", + "size": 455858, + "subdir": "linux-64", + "timestamp": 1599817156351, + "version": "1.7.1" + }, + "shapely-1.7.1-py37h1728cc4_0.tar.bz2": { + "build": "py37h1728cc4_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2b85827199b36254d27f22db255f2a56", + "name": "shapely", + "sha256": "b9df26928b1a78fb7891ceed1ae6afbd58a7bf2d7491e83d38024917e4c161fb", + "size": 445989, + "subdir": "linux-64", + "timestamp": 1632813578715, + "version": "1.7.1" + }, + "shapely-1.7.1-py37h98ec03d_0.tar.bz2": { + "build": "py37h98ec03d_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f3236965e4ff1a71a40b9f5915c92a18", + "name": "shapely", + "sha256": "923ce16d7e082a25ea204ea86eda67d3431dfd1d5ab4620b818e7360141b9586", + "size": 444934, + "subdir": "linux-64", + "timestamp": 1599817155661, + "version": "1.7.1" + }, + "shapely-1.7.1-py38h1728cc4_0.tar.bz2": { + "build": "py38h1728cc4_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "6c73554c4de6df382fa254eba9fe2c3c", + "name": "shapely", + "sha256": "7e09fab4eba71c6bbfb16c0d6ccce87106e0a7f09a868db90f27850ed29c25a0", + "size": 456532, + "subdir": "linux-64", + "timestamp": 1632813570956, + "version": "1.7.1" + }, + "shapely-1.7.1-py38h98ec03d_0.tar.bz2": { + "build": "py38h98ec03d_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d6822a9c51ca6347fd1f5267bac57bdf", + "name": "shapely", + "sha256": "666844049af14823de17c44a9aa6fb39a82b050ea123ca7b8037288577cc62ce", + "size": 454027, + "subdir": "linux-64", + "timestamp": 1599817161138, + "version": "1.7.1" + }, + "shapely-1.7.1-py39h1728cc4_0.tar.bz2": { + "build": "py39h1728cc4_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "98098f45b14bbb47c4820dc871ec7f53", + "name": "shapely", + "sha256": "80bef77401aa0f91afd0db21c0eaae73a9896bf99029a24e16a7d2d8c656023f", + "size": 461830, + "subdir": "linux-64", + "timestamp": 1632813578598, + "version": "1.7.1" + }, + "shapely-1.8.4-py310h81ba7c5_0.tar.bz2": { + "build": "py310h81ba7c5_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c74d9fc6ed76937e65286af3ca92c777", + "name": "shapely", + "sha256": "9a1903195259ae96efc5de7c87f86ca17302d193554f14f7994491c5b39bbae5", + "size": 904441, + "subdir": "linux-64", + "timestamp": 1664521670000, + "version": "1.8.4" + }, + "shapely-1.8.4-py37h81ba7c5_0.tar.bz2": { + "build": "py37h81ba7c5_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b67c3f264d2f6e4a74974f3c0aa727b7", + "name": "shapely", + "sha256": "9ff0d6ee7a0cd2d1df80e080fd1990f3fdacea185b99dbdc386b76f4213f9616", + "size": 367526, + "subdir": "linux-64", + "timestamp": 1664521829763, + "version": "1.8.4" + }, + "shapely-1.8.4-py38h81ba7c5_0.tar.bz2": { + "build": "py38h81ba7c5_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "029925cc2f0c98b3f085b375b4950781", + "name": "shapely", + "sha256": "6635163c2aa491cc8ed0bdaaa77d9b156532d85cb4a019b6b15161b06c0c89cf", + "size": 374467, + "subdir": "linux-64", + "timestamp": 1664521722260, + "version": "1.8.4" + }, + "shapely-1.8.4-py39h81ba7c5_0.tar.bz2": { + "build": "py39h81ba7c5_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3ef787be6adc2505469da7967fa2369d", + "name": "shapely", + "sha256": "5745b524cd67f16220921fade01a6e6639dc191aa2065ad54e561700ac1d284b", + "size": 371835, + "subdir": "linux-64", + "timestamp": 1664521776613, + "version": "1.8.4" + }, + "shapely-2.0.1-py310h006c72b_0.tar.bz2": { + "build": "py310h006c72b_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ad44626d30fa2473dc892ba30cba5e19", + "name": "shapely", + "sha256": "731d8c2b779ceb060dc8d18ad85a888b5e393d95c64ac54be205d2958243ece2", + "size": 458439, + "subdir": "linux-64", + "timestamp": 1680636339258, + "version": "2.0.1" + }, + "shapely-2.0.1-py311h24a2a10_0.tar.bz2": { + "build": "py311h24a2a10_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dfa1685efd1b2d7e297762ca1226ac49", + "name": "shapely", + "sha256": "7a477de614b4cbba6a29cfdd26e431c4e849e1e6fed7129bc0271283b4cbcf54", + "size": 535395, + "subdir": "linux-64", + "timestamp": 1680636507282, + "version": "2.0.1" + }, + "shapely-2.0.1-py38h0fbb895_0.tar.bz2": { + "build": "py38h0fbb895_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0985fc7a037643a9081d894a8ee341ab", + "name": "shapely", + "sha256": "650d822c91b3985b90a2ad667fd470625a7f97de844cc5188eff0180ae06caed", + "size": 463159, + "subdir": "linux-64", + "timestamp": 1680636395435, + "version": "2.0.1" + }, + "shapely-2.0.1-py39h0fbb895_0.tar.bz2": { + "build": "py39h0fbb895_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ce4437ea2f4323cc2a5e30e64aabaafc", + "name": "shapely", + "sha256": "3aff4b2cde02c5197fa7069ac420ae34e40b08409da768d663a05c2147d85075", + "size": 459222, + "subdir": "linux-64", + "timestamp": 1680636451813, + "version": "2.0.1" + }, + "shellcheck-0.7.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "0b5d20c075f067ed29fd7dd8ccc4c074", + "name": "shellcheck", + "sha256": "0c403a1509fc4d4802d1e3d7c2c0cc14c9558a301784a4c75f741e889fb0924e", + "size": 1744204, + "subdir": "linux-64", + "timestamp": 1598387406337, + "version": "0.7.1" + }, + "shellcheck-0.7.2-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "e30396006c81b7741369a89a5fdcb932", + "name": "shellcheck", + "sha256": "d002248f52f42a5d0e81cabf58805912c5c349a86b65217d6eb04217b6b915cc", + "size": 1689955, + "subdir": "linux-64", + "timestamp": 1619436827733, + "version": "0.7.2" + }, + "shellcheck-0.7.2-h06a4308_1.tar.bz2": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "da2e7de452c4b6dea5663cdd3b836d68", + "name": "shellcheck", + "sha256": "c022cd1589248ae2d58c3402d4de3a1e0835cf3fa1f7ba90699369532c031171", + "size": 1690007, + "subdir": "linux-64", + "timestamp": 1619439978714, + "version": "0.7.2" + }, + "shellingham-1.5.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "3bfa02f0aa125c52ea3d2a785c2abad4", + "name": "shellingham", + "sha256": "40205c54c1f3983837e8f308159cd4a83a6517aa1e53b3a68576c57cf91ea230", + "size": 16890, + "subdir": "linux-64", + "timestamp": 1669142272317, + "version": "1.5.0" + }, + "shellingham-1.5.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "6bcab5bab5dbc27a5e18df8586012523", + "name": "shellingham", + "sha256": "6136c6c125cdefa9ee313df3d1a6489e07afd591ee7d52a9709f2db648d62b8e", + "size": 20780, + "subdir": "linux-64", + "timestamp": 1676823217089, + "version": "1.5.0" + }, + "shellingham-1.5.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "7fbefb99b41224ab46d152df8bb619a0", + "name": "shellingham", + "sha256": "abdb1deefd03d36b02e875597f61f66af103e3007409e3613bb9297232f8ba8e", + "size": 16764, + "subdir": "linux-64", + "timestamp": 1669142247741, + "version": "1.5.0" + }, + "shellingham-1.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "7fc1ba4b6c8b8c12bc44e75deae2601f", + "name": "shellingham", + "sha256": "d2f62a691bb09c13deb9ecd3b93aaf8d0d4367fdb9e3c3aac2a4f5a309a22d59", + "size": 16782, + "subdir": "linux-64", + "timestamp": 1669142222916, + "version": "1.5.0" + }, + "shellingham-1.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "26aed1d2be282e7b59a6138023db0a52", + "name": "shellingham", + "sha256": "74ef3eee5b7dda47c867d5090a0aee89871d324a230cba309ed1a20b19d58668", + "size": 16819, + "subdir": "linux-64", + "timestamp": 1669142198319, + "version": "1.5.0" + }, + "simpervisor-0.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c299e7071ae709bf4ebe44e12442bc79", + "name": "simpervisor", + "sha256": "86b17beb1bc25e048b11e50b9c502912de5156ea07a8fecc88b046ded4dabf7b", + "size": 12610, + "subdir": "linux-64", + "timestamp": 1678869242138, + "version": "0.4" + }, + "simpervisor-0.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0fa39fca1701e1b12b6b1beba403bf46", + "name": "simpervisor", + "sha256": "8ed28968cdbc16b01c02344801f32c56642d4c4777b519075d190051d2936fd8", + "size": 14449, + "subdir": "linux-64", + "timestamp": 1678959786878, + "version": "0.4" + }, + "simpervisor-0.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2c3310bc7d064ad01635049f143b6bdc", + "name": "simpervisor", + "sha256": "ae87b7a23633a0cfcad4878f6d52460ef692610f0ae12c7502c0a2e0911ee8d4", + "size": 12509, + "subdir": "linux-64", + "timestamp": 1678869289761, + "version": "0.4" + }, + "simpervisor-0.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "174cc0115589acc5c56fa20c40859a34", + "name": "simpervisor", + "sha256": "457b1376ba0ed419b3d215bcf605c5795bbb13fba08fbb984b16e3e3302ac297", + "size": 12552, + "subdir": "linux-64", + "timestamp": 1678869265376, + "version": "0.4" + }, + "simplegeneric-0.8.1-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Zope Public", + "md5": "5c297ea25bf7db4a3af884f6ddc9f992", + "name": "simplegeneric", + "sha256": "dc01081d09bdec9deb512f0470e41a82264344c912253d56cd81dbe8c96ec72f", + "size": 9268, + "subdir": "linux-64", + "timestamp": 1518031044737, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py27h19e43cd_0.tar.bz2": { + "build": "py27h19e43cd_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Zope Public", + "md5": "4f505870aeb3518dd671642a4525feb6", + "name": "simplegeneric", + "sha256": "87f69f14652e21b736b8f38c2bcb61fae9628d0ccf1f942c697eff64a3a8e435", + "size": 9010, + "subdir": "linux-64", + "timestamp": 1505690370417, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Zope Public", + "md5": "e49a06162a1c74077c25b60cd93bc224", + "name": "simplegeneric", + "sha256": "00e98eceba7c5c977569f4533381e7873736c1141d349a140b78ca9fc3414e2f", + "size": 9508, + "subdir": "linux-64", + "timestamp": 1640794737413, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py311h06a4308_2.tar.bz2": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Zope Public", + "md5": "dee2550c93c9ca2963911a76a12df717", + "name": "simplegeneric", + "sha256": "dc3f60f8f4c16fb8b171bdde5f702ba93a367fe6b843dd203e9b42fb17ae2a4a", + "size": 10887, + "subdir": "linux-64", + "timestamp": 1676862180253, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Zope Public", + "md5": "d8fcca1c18031217f0d27ac30654400e", + "name": "simplegeneric", + "sha256": "c036b528d0842e4783c45c061437b3422b97cb91033e35845069e3741c5dbf6e", + "size": 9378, + "subdir": "linux-64", + "timestamp": 1518030856175, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py35h2ec4104_0.tar.bz2": { + "build": "py35h2ec4104_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Zope Public", + "md5": "6d283aca6f374bbca96fdf484b76450f", + "name": "simplegeneric", + "sha256": "bafc9164f0d927060b112d15bfa766c00b7ace7860dc0e49e0d1caa821b7ffe6", + "size": 9121, + "subdir": "linux-64", + "timestamp": 1505690381203, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Zope Public", + "md5": "5a927ad2880b1e2312102c8c15acf01a", + "name": "simplegeneric", + "sha256": "7178dcd11c0431e42ecff09ad1ad7407e509ebea29a8396d016567cdf4238e36", + "size": 9358, + "subdir": "linux-64", + "timestamp": 1518031419901, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py36h2cb9092_0.tar.bz2": { + "build": "py36h2cb9092_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Zope Public", + "md5": "01147009181acc53bec05e8318ad3d80", + "name": "simplegeneric", + "sha256": "932eb6384cbed56018f7909b08ddf1be4c036d76c16c438fd48aadb2e9050b59", + "size": 9113, + "subdir": "linux-64", + "timestamp": 1505690392176, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Zope Public", + "md5": "11fa530d2f748ef507386029feac6cea", + "name": "simplegeneric", + "sha256": "7b520ac9796179544caaeac72dfe7427788001b2886748d5e0c20f02f3272014", + "size": 9233, + "subdir": "linux-64", + "timestamp": 1530694779790, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py38_2.tar.bz2": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Zope Public", + "md5": "50b14310648840fce4ea3f0abcc7def4", + "name": "simplegeneric", + "sha256": "0461a2c3d0ba35127a89283371742384ba0569bb67302e073b9ec669e5c8e7cd", + "size": 9683, + "subdir": "linux-64", + "timestamp": 1573200417114, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Zope Public", + "md5": "e15ea6eaea7c3e8e36c02941d4a4abb2", + "name": "simplegeneric", + "sha256": "327a267d50e6605516d32fd4a098c2bbd4033f43d4f37363cb8cccfd5826bbdc", + "size": 10879, + "subdir": "linux-64", + "timestamp": 1607570616595, + "version": "0.8.1" + }, + "simplejson-3.12.0-py27h264bab0_0.tar.bz2": { + "build": "py27h264bab0_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "720d17f8f3225cceb9bffb5e9d413eb1", + "name": "simplejson", + "sha256": "df52dcb10341b931b67c8c4946c39ca133035bf34388895eaab14b2440368b79", + "size": 76328, + "subdir": "linux-64", + "timestamp": 1511319909117, + "version": "3.12.0" + }, + "simplejson-3.12.0-py35h592e862_0.tar.bz2": { + "build": "py35h592e862_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11a0b774959e4aaa37c8c990476a1693", + "name": "simplejson", + "sha256": "a3809b0769b60c26777dcaa57d9180929473ea2c6d013eb3cc18ed1af9e1a4b6", + "size": 77585, + "subdir": "linux-64", + "timestamp": 1511319909627, + "version": "3.12.0" + }, + "simplejson-3.12.0-py36h5dd3b74_0.tar.bz2": { + "build": "py36h5dd3b74_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9530c6386df0d23c69a0d60baba0bbda", + "name": "simplejson", + "sha256": "317e323c94acfa3a9258111e8f04da1574953f29642888eed21416eb807ad0fb", + "size": 77081, + "subdir": "linux-64", + "timestamp": 1511319912613, + "version": "3.12.0" + }, + "simplejson-3.13.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e5dbd51942e4241f5dfc9684b934fc2", + "name": "simplejson", + "sha256": "5ee799c67bbdc4b841caa391b69716f8bf965453d654ab9c7463344e63b25f85", + "size": 76831, + "subdir": "linux-64", + "timestamp": 1519674022769, + "version": "3.13.2" + }, + "simplejson-3.13.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbf462722c8841864ca55eccf60cb679", + "name": "simplejson", + "sha256": "3d57fdf0871601cef1d7dc46e983a40ea7120ea7529dad8d78394f07c78f091f", + "size": 78210, + "subdir": "linux-64", + "timestamp": 1519673718107, + "version": "3.13.2" + }, + "simplejson-3.13.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "afa6483b9a4e999fc6c2192b97ce44bd", + "name": "simplejson", + "sha256": "0c25a18be0f02e2cf07ab80cec24223d2d06e9d4ac2ca82a36e6e366598c5c28", + "size": 77595, + "subdir": "linux-64", + "timestamp": 1519674220038, + "version": "3.13.2" + }, + "simplejson-3.14.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5460ef81552376dabd93a43524320379", + "name": "simplejson", + "sha256": "c6f548073e4bcc31ac1d54a9fc4f09edf051aff3278c9dd0225752f0a78f60ce", + "size": 98880, + "subdir": "linux-64", + "timestamp": 1524509480628, + "version": "3.14.0" + }, + "simplejson-3.14.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8cafd186ea8e05462927dec63535758", + "name": "simplejson", + "sha256": "9d43e2d7000d692a45b92c7619b85feff38907fc46e8b006cc7e351d0dbdf301", + "size": 98762, + "subdir": "linux-64", + "timestamp": 1524509497258, + "version": "3.14.0" + }, + "simplejson-3.14.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ac64ce48fabbf302007129deeb3aefc0", + "name": "simplejson", + "sha256": "12ced2ec6bbfaf8fe2e0174c2daf03b92dfbf77ff75d5626a95ecb82f99814f5", + "size": 98409, + "subdir": "linux-64", + "timestamp": 1524509503266, + "version": "3.14.0" + }, + "simplejson-3.15.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b3e55f3a9f838bee496ca06478c5c3d4", + "name": "simplejson", + "sha256": "94ca8218c90be2de872b6d136bf551c51d829e83da1b4bfbd77cc88999d06e19", + "size": 103278, + "subdir": "linux-64", + "timestamp": 1526918311724, + "version": "3.15.0" + }, + "simplejson-3.15.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c66ac2ca7e97c3b0a25af3426f6c37d", + "name": "simplejson", + "sha256": "b0c48e0a175b2ff803bd4bc42d82e78038140e449563fd7f370ed8142ea05938", + "size": 102934, + "subdir": "linux-64", + "timestamp": 1526917989203, + "version": "3.15.0" + }, + "simplejson-3.15.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f84f239081eb5d4d3478b480ce46ac9b", + "name": "simplejson", + "sha256": "e7abdeb6fd21967af4dcc8cdd10b4b35c31c2892769dbe8c1bee081037bf1315", + "size": 102302, + "subdir": "linux-64", + "timestamp": 1526918327960, + "version": "3.15.0" + }, + "simplejson-3.15.0-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba6c42e7c5888d50e2a5343cb57e5fff", + "name": "simplejson", + "sha256": "6f300c1a4165a95cf649e63238be8f2a2f99704361a26844ecf52aa50533c73d", + "size": 102142, + "subdir": "linux-64", + "timestamp": 1530737668876, + "version": "3.15.0" + }, + "simplejson-3.16.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f10de7346c31c171c35eb300b6f8d16b", + "name": "simplejson", + "sha256": "29f4df16b05830daf0d5d1620b5ceb9416bd5eac6528ab081a1fa838087fa33c", + "size": 103248, + "subdir": "linux-64", + "timestamp": 1532619211603, + "version": "3.16.0" + }, + "simplejson-3.16.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4cbf3dc2bdc5539576930ed04a37a780", + "name": "simplejson", + "sha256": "2795f9b8689d4fa5d58fa1b2b5d2d76fc38c095c990a609dcee8645dd19579d3", + "size": 102754, + "subdir": "linux-64", + "timestamp": 1532619223837, + "version": "3.16.0" + }, + "simplejson-3.16.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4b5c0aa61af5924e00f06e06f2f2e261", + "name": "simplejson", + "sha256": "e5111a56da617018b989481801d1c69ba0649f78bf3b89c697c27f201f404e49", + "size": 102449, + "subdir": "linux-64", + "timestamp": 1532619152649, + "version": "3.16.0" + }, + "simplejson-3.16.0-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dade2617501831d1fceccd1c3723df11", + "name": "simplejson", + "sha256": "8c444d149efdf871abed9b935c6b4fe8dac6b7a8778a96dcb6c27d2968dde15a", + "size": 102197, + "subdir": "linux-64", + "timestamp": 1532619230308, + "version": "3.16.0" + }, + "simplejson-3.16.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dadfc5fcd2dc357a8dfad1891a9c029a", + "name": "simplejson", + "sha256": "2e552d982c63377c0780267892fd310ac4f879ee18e81de4a1fb3772364ba07f", + "size": 112287, + "subdir": "linux-64", + "timestamp": 1573200435027, + "version": "3.16.0" + }, + "simplejson-3.17.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f5bec189978e9747f42d1e94c2b605c", + "name": "simplejson", + "sha256": "6b55aa66f7d20860cc9121648449c64da6c12ce30f50474eb67b884ffb9300c2", + "size": 107591, + "subdir": "linux-64", + "timestamp": 1574364779896, + "version": "3.17.0" + }, + "simplejson-3.17.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c920fc46c39bffd60b78f64867981dcc", + "name": "simplejson", + "sha256": "7206caf2747bc1fa2cd802cb09cb67822310d8030c7391f23b5af006af1ef526", + "size": 107163, + "subdir": "linux-64", + "timestamp": 1613470862278, + "version": "3.17.0" + }, + "simplejson-3.17.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5772abdbc9b29c9fb25071b3c4111a7f", + "name": "simplejson", + "sha256": "1258786ca92f45902edf960ff7117876e475b679b1e820b2d45528e6d4ad02c3", + "size": 107006, + "subdir": "linux-64", + "timestamp": 1574364800212, + "version": "3.17.0" + }, + "simplejson-3.17.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cf773a61dfa68f0922a3deaf8f4d3afa", + "name": "simplejson", + "sha256": "01e6a53fd66cf48204cab7013bbca5eb6d43adec77ebd1f40a3b3986e92120aa", + "size": 106866, + "subdir": "linux-64", + "timestamp": 1613470713727, + "version": "3.17.0" + }, + "simplejson-3.17.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9afcab28b4ae2e809ab3c881de69ab57", + "name": "simplejson", + "sha256": "6144bab7715bd72b12d47fabb1c3bb3e2d53f98bad49e0819bed1a3e11b92995", + "size": 106750, + "subdir": "linux-64", + "timestamp": 1574364765619, + "version": "3.17.0" + }, + "simplejson-3.17.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b48c7a531e23f593893f5b9e89fd667", + "name": "simplejson", + "sha256": "10d762e6a4168f8f8d2d5270616f3a37333fcc003dcae9db8f22810c46ccf5ef", + "size": 108039, + "subdir": "linux-64", + "timestamp": 1613470867577, + "version": "3.17.0" + }, + "simplejson-3.17.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39d07bab33e86ce5316a1f0407c91c7d", + "name": "simplejson", + "sha256": "88565681f5f67c4d96ae120cbff0305ac983236f954b98ae7fe3f3b310070e48", + "size": 114886, + "subdir": "linux-64", + "timestamp": 1574364823453, + "version": "3.17.0" + }, + "simplejson-3.17.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "916abd12a4c5724e9519e14e3fb1c3ef", + "name": "simplejson", + "sha256": "c80e97742227df34eabe9b399a8830a67468ae49ed659cdf33bfa2fc12450ee5", + "size": 107976, + "subdir": "linux-64", + "timestamp": 1613470859863, + "version": "3.17.0" + }, + "simplejson-3.17.2-py36h27cfd23_2.tar.bz2": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e7997c0f88071659084271d89a5ee42", + "name": "simplejson", + "sha256": "853b7c655ae54b4ffe04f2050760da9f9f08af1997accf9f67b21f4dd416c293", + "size": 109199, + "subdir": "linux-64", + "timestamp": 1614003837317, + "version": "3.17.2" + }, + "simplejson-3.17.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f518ae3ad709de94d1bd617e8a5a7dd9", + "name": "simplejson", + "sha256": "4ce1fdffe8d46f4670ad72a44cb9961bb712347c58e13bb49afa34e112d789e8", + "size": 108603, + "subdir": "linux-64", + "timestamp": 1598626002450, + "version": "3.17.2" + }, + "simplejson-3.17.2-py37h27cfd23_2.tar.bz2": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7529909d0be02ad20f48768393e6581a", + "name": "simplejson", + "sha256": "e39eec671699b3a526d7e26abcdbc678d963bcaa1af0a1c5aa56faafc1449f8c", + "size": 108920, + "subdir": "linux-64", + "timestamp": 1614003832999, + "version": "3.17.2" + }, + "simplejson-3.17.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "20432b35cb958349841a721c674783cb", + "name": "simplejson", + "sha256": "69b49e663fe490a4ad89232a9f5421765f1f5100d0d3f25cf8cbb5bc7690ca56", + "size": 108398, + "subdir": "linux-64", + "timestamp": 1598625992173, + "version": "3.17.2" + }, + "simplejson-3.17.2-py38h27cfd23_2.tar.bz2": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a95674049b4f2ded2cbc61609765ec30", + "name": "simplejson", + "sha256": "c7b484d0dc636866c9dc102226c6003958c26dd21086dd5747612e9fc68dddad", + "size": 110117, + "subdir": "linux-64", + "timestamp": 1614003833056, + "version": "3.17.2" + }, + "simplejson-3.17.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c9bbb0be42b151d88ad848d750529ba2", + "name": "simplejson", + "sha256": "93aef7f740fa55ef9d901caa5ea277f003c96e7fdee751168c6771eb1b06e19b", + "size": 109458, + "subdir": "linux-64", + "timestamp": 1598625997853, + "version": "3.17.2" + }, + "simplejson-3.17.2-py39h27cfd23_2.tar.bz2": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "920820f268c100ca6b60bed219fdc5f3", + "name": "simplejson", + "sha256": "a8157dfab8e6c446a9e946ab3b0fd4e8c0320571894d185a55d83acd1ccf559e", + "size": 110025, + "subdir": "linux-64", + "timestamp": 1614003843305, + "version": "3.17.2" + }, + "simplejson-3.17.3-py36h7f8727e_2.tar.bz2": { + "build": "py36h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "769e2c966b540b8dbf2dfbafb46928d9", + "name": "simplejson", + "sha256": "6e3039c870dc522e1fd2f43c55bc37b11da6f44b116197427e9dce2be357446f", + "size": 104886, + "subdir": "linux-64", + "timestamp": 1626446578448, + "version": "3.17.3" + }, + "simplejson-3.17.3-py37h7f8727e_2.tar.bz2": { + "build": "py37h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e0f9637a7edb619830f58caed00f339", + "name": "simplejson", + "sha256": "8276c262d5cf261a4deb67895a9b219b2a8e241782aa8d850621b1253bfd8282", + "size": 104505, + "subdir": "linux-64", + "timestamp": 1626446560312, + "version": "3.17.3" + }, + "simplejson-3.17.3-py38h7f8727e_2.tar.bz2": { + "build": "py38h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f4320090dcb6f054fb16a62696dfa494", + "name": "simplejson", + "sha256": "534ee2ec9e73d920fc79b3cd4b6dcf47729cfe23f9fe2b03864cf6e78e6df8bf", + "size": 105753, + "subdir": "linux-64", + "timestamp": 1626446362815, + "version": "3.17.3" + }, + "simplejson-3.17.3-py39h7f8727e_2.tar.bz2": { + "build": "py39h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b02535207c9f1f64fc0186f6c2f99f2d", + "name": "simplejson", + "sha256": "59f8bfdb454ca4aee21c94411f20caabcf61e5da61b09d559e693505f6336d13", + "size": 105679, + "subdir": "linux-64", + "timestamp": 1626446570452, + "version": "3.17.3" + }, + "simplejson-3.17.6-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5a4beb8e6b82b0d0cbad489435a3dca", + "name": "simplejson", + "sha256": "82f7a5999398630426310168a9d2c9088fd4920dea31f24cbe1cfd87393f12b0", + "size": 153251, + "subdir": "linux-64", + "timestamp": 1640794762209, + "version": "3.17.6" + }, + "simplejson-3.17.6-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1bbdd26d64ca920dbb8eb33a4cba908b", + "name": "simplejson", + "sha256": "b8de338d94094475f6114da333b287a4e6e52a520aab6a0e87e916f36651cc77", + "size": 133914, + "subdir": "linux-64", + "timestamp": 1676845797385, + "version": "3.17.6" + }, + "simplejson-3.17.6-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39b5419b11b6b3bc731d1c4ffcdf35c0", + "name": "simplejson", + "sha256": "1ed221c6e2fe5e7123591d53ec9b61ebb233147605a47655273ec2ed231ce187", + "size": 110320, + "subdir": "linux-64", + "timestamp": 1639127229059, + "version": "3.17.6" + }, + "simplejson-3.17.6-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cf7a33c12e3f3c1a69492c6954a25810", + "name": "simplejson", + "sha256": "b2bd6cdf7e984cec19a0efa2dafd3256793f6c2b730ce62f428f062316caaeab", + "size": 111489, + "subdir": "linux-64", + "timestamp": 1639140815978, + "version": "3.17.6" + }, + "simplejson-3.17.6-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e523439524dc4226787de7fbaa1d77f5", + "name": "simplejson", + "sha256": "0b7cd69444e40dbc1b8dc2ba4d0cd008b190e58b0f42aa9f8b0c9fd9f35d3f42", + "size": 111203, + "subdir": "linux-64", + "timestamp": 1639122697806, + "version": "3.17.6" + }, + "singledispatch-3.4.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "74ea3d0f558d51b39ab0c48ee9a6c5b4", + "name": "singledispatch", + "sha256": "af6d8ce120eddd9186fbfbb082a926587e571fc37c9cf9661d9429b82549d685", + "size": 15331, + "subdir": "linux-64", + "timestamp": 1530735230353, + "version": "3.4.0.3" + }, + "singledispatch-3.4.0.3-py27h9bcb476_0.tar.bz2": { + "build": "py27h9bcb476_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "5901a4ded6ec5dd06e12d75dc1e0f29a", + "name": "singledispatch", + "sha256": "8498c3a15303efd17a25a48e6936d588467d567ec699d4fa47badec56bda226d", + "size": 15198, + "subdir": "linux-64", + "timestamp": 1505690466797, + "version": "3.4.0.3" + }, + "singledispatch-3.4.0.3-py35h0cd4ec3_0.tar.bz2": { + "build": "py35h0cd4ec3_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "b761d6638d6c9469c620924560292b84", + "name": "singledispatch", + "sha256": "9e3d00174249e5eee547cc3c4eb44adc13e28e70f824fe402a2f07ac4d99b82d", + "size": 15565, + "subdir": "linux-64", + "timestamp": 1505690477844, + "version": "3.4.0.3" + }, + "singledispatch-3.4.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "fbe30d7149b3e3e51fe4b8dbbb727919", + "name": "singledispatch", + "sha256": "7e86b46f57be63b936c24a8de488ce2edc4aad3ccaab87e2230b0fea26763525", + "size": 15637, + "subdir": "linux-64", + "timestamp": 1530735209967, + "version": "3.4.0.3" + }, + "singledispatch-3.4.0.3-py36h7a266c3_0.tar.bz2": { + "build": "py36h7a266c3_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "956a431e5c0ed6d15073da672c0a12a6", + "name": "singledispatch", + "sha256": "551c7bddd69170e97dbd9db86afc97b35b085449f08e591128ec8bf3cae98121", + "size": 15540, + "subdir": "linux-64", + "timestamp": 1505690488981, + "version": "3.4.0.3" + }, + "singledispatch-3.4.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "727dbd0b409248d99cc1d5a81cac6ee1", + "name": "singledispatch", + "sha256": "421a4094ed4dc4167a3734fbeb925dbc5bf7d64cc94e87d823b2d206dc1f9d67", + "size": 15679, + "subdir": "linux-64", + "timestamp": 1530735251011, + "version": "3.4.0.3" + }, + "singledispatch-3.4.0.3-py37_1000.tar.bz2": { + "build": "py37_1000", + "build_number": 1000, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "63c74d5d577a33c89e45505689bcf9d2", + "name": "singledispatch", + "sha256": "7a9a1e065c45668d7b9855cf8b07d6c7d0cf98f72f4fd54627bb86d165f47206", + "size": 15310, + "subdir": "linux-64", + "timestamp": 1597002549088, + "version": "3.4.0.3" + }, + "singledispatch-3.4.0.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "md5": "1108f80ccccf5d35b1150ef30e41fade", + "name": "singledispatch", + "sha256": "b275580c98dc6c2160174d6bf42c338fee222f0f8fcab4e773a24fbc928c45d8", + "size": 16158, + "subdir": "linux-64", + "timestamp": 1573557156486, + "version": "3.4.0.3" + }, + "sip-4.18.1-py27he9ba0ab_2.tar.bz2": { + "build": "py27he9ba0ab_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-3.0", + "md5": "3bcf12c6ff40ba7f4b52ca759598a1f0", + "name": "sip", + "sha256": "6e16a06d35384882125e14a2a65b0cbe15bbbb9fcafbe028255d3a4fe5ccbfc7", + "size": 285168, + "subdir": "linux-64", + "timestamp": 1505733898462, + "version": "4.18.1" + }, + "sip-4.18.1-py27hf484d3e_2.tar.bz2": { + "build": "py27hf484d3e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-3.0", + "md5": "77419926cc64f03ca888c508fae4d6f6", + "name": "sip", + "sha256": "5875bb165b70ed4830194c7df5344cd4bc88e174df97c5526b0ac4d86314104a", + "size": 285677, + "subdir": "linux-64", + "timestamp": 1530795626475, + "version": "4.18.1" + }, + "sip-4.18.1-py35h9eaea60_2.tar.bz2": { + "build": "py35h9eaea60_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL-3.0", + "md5": "c9ada20f87ab79f0c8f8134048f345aa", + "name": "sip", + "sha256": "d3f9cb0203c9db9a3734116b6e2bc64f9057efc2b323560a424325966e87d796", + "size": 284431, + "subdir": "linux-64", + "timestamp": 1505733924941, + "version": "4.18.1" + }, + "sip-4.18.1-py35hf484d3e_2.tar.bz2": { + "build": "py35hf484d3e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL-3.0", + "md5": "1a2606909a77b8d1d3aa1a16a910dab1", + "name": "sip", + "sha256": "47e80b7f708793489bcfeba493e84bf2894bea987827ad2034f77eadcc088a80", + "size": 284658, + "subdir": "linux-64", + "timestamp": 1535112189392, + "version": "4.18.1" + }, + "sip-4.18.1-py36h295c915_2.tar.bz2": { + "build": "py36h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "febe234ee1e100f4d2677882f0922245", + "name": "sip", + "sha256": "c441273a2a6953c92cc30c6a4a8717cb67c9c73f7d5ac85b2af5d4457290bbf2", + "size": 284516, + "subdir": "linux-64", + "timestamp": 1632839605028, + "version": "4.18.1" + }, + "sip-4.18.1-py36h51ed4ed_2.tar.bz2": { + "build": "py36h51ed4ed_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "1905b17664e34a057132c9a0d8e1a1bb", + "name": "sip", + "sha256": "ae03cefc5468982f270fe2edc2fdb371589d296f788bda0352eaa5e38fd40898", + "size": 283858, + "subdir": "linux-64", + "timestamp": 1505733951555, + "version": "4.18.1" + }, + "sip-4.18.1-py36hf484d3e_2.tar.bz2": { + "build": "py36hf484d3e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "dd74db448499198a3ac5e3c90251141a", + "name": "sip", + "sha256": "b6d50d5234ebbc9e968e6dd1b4c5c0c5bfefe6ea023c6826dabb37d30ef21714", + "size": 284375, + "subdir": "linux-64", + "timestamp": 1530795665443, + "version": "4.18.1" + }, + "sip-4.18.1-py37h295c915_2.tar.bz2": { + "build": "py37h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "c0d1ddc43ec08f31c618814dd01f34eb", + "name": "sip", + "sha256": "9b0197af67e9536099a87f33ffbc7a2ea12bfc7068827b6fcd95037418a1c1be", + "size": 284407, + "subdir": "linux-64", + "timestamp": 1632839575871, + "version": "4.18.1" + }, + "sip-4.18.1-py37hf484d3e_2.tar.bz2": { + "build": "py37hf484d3e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "cd3d7885462372262350ab83724ec095", + "name": "sip", + "sha256": "8e8d418a75854db1e21e04d82025db8d53c802b57f02b73559100d03a034ca94", + "size": 284322, + "subdir": "linux-64", + "timestamp": 1530795704476, + "version": "4.18.1" + }, + "sip-4.18.1-py38h295c915_2.tar.bz2": { + "build": "py38h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "md5": "db6c6ad446fbd19fc793afacd1ef0de6", + "name": "sip", + "sha256": "aec40172ddd0481789461ce5bcd1c060584d84dd93f25513d4e069831eac771b", + "size": 285439, + "subdir": "linux-64", + "timestamp": 1632839848372, + "version": "4.18.1" + }, + "sip-4.18.1-py39h295c915_2.tar.bz2": { + "build": "py39h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-3.0", + "md5": "3341f2c32a9e29803c1bdd947d1bd93a", + "name": "sip", + "sha256": "3815dfff341f19f29b73eb87ec91ef6a3513bc291066dcd2b2d81a95b82f83ec", + "size": 285449, + "subdir": "linux-64", + "timestamp": 1632829187507, + "version": "4.18.1" + }, + "sip-4.19.12-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-3.0", + "md5": "b6a3ac21fb3fe63ad126201ec9628a7c", + "name": "sip", + "sha256": "e3d9b1db404ac869c23246847deb944c1b2845fc406c1229d67ba745e189024e", + "size": 299570, + "subdir": "linux-64", + "timestamp": 1535397440107, + "version": "4.19.12" + }, + "sip-4.19.12-py35he6710b0_0.tar.bz2": { + "build": "py35he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL-3.0", + "md5": "d0ddafc7bb67a2331349da77b679b34d", + "name": "sip", + "sha256": "af7759bde47ddfff96b2164631c4c04fe77b87f0ae43e06ca70e8ec739a5118d", + "size": 299452, + "subdir": "linux-64", + "timestamp": 1535414006059, + "version": "4.19.12" + }, + "sip-4.19.12-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "5a14f5777fa0da7649f569c28f86493a", + "name": "sip", + "sha256": "7f567cc6518b0facc8f4e849a062c934db402dbd83ff8cd9d737bc4309284c4e", + "size": 298895, + "subdir": "linux-64", + "timestamp": 1535397341716, + "version": "4.19.12" + }, + "sip-4.19.12-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "b7ef5877c0a1ebc8c8c1071aede63864", + "name": "sip", + "sha256": "de29b52e9bd1dfd28a8ea4aa69190267750b43c3e4efe80093c9eea0b602ac58", + "size": 298929, + "subdir": "linux-64", + "timestamp": 1535397021786, + "version": "4.19.12" + }, + "sip-4.19.13-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-3.0", + "md5": "973ca700461e701901c56329a8c82983", + "name": "sip", + "sha256": "0afd81af26320800039bfb4ad9d9243fe778c7694fcf218ed414326a994762c6", + "size": 300295, + "subdir": "linux-64", + "timestamp": 1541049907618, + "version": "4.19.13" + }, + "sip-4.19.13-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "GPL-3.0", + "md5": "ee5da76a1d0ab2e9688ddecb59278432", + "name": "sip", + "sha256": "31b588ef8fa4934303ae498177cbab88f577029bbf4b8ec53f4b03182b67ea22", + "size": 303641, + "subdir": "linux-64", + "timestamp": 1643114613076, + "version": "4.19.13" + }, + "sip-4.19.13-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "b560b341effed8ca99a8f53ab7efd05b", + "name": "sip", + "sha256": "5b0d7c22ce6c57b8d5a2d3fb4bf1bfdd679c7e01dfab4afbed4a9129d774f759", + "size": 299657, + "subdir": "linux-64", + "timestamp": 1541049928464, + "version": "4.19.13" + }, + "sip-4.19.13-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "74e3596c61a579593da5d9163064ab0e", + "name": "sip", + "sha256": "2a2fa81782591464c7e153cf6fc09d97b9b6dbf01aa3a85d764c142e228d9db4", + "size": 301548, + "subdir": "linux-64", + "timestamp": 1643114666959, + "version": "4.19.13" + }, + "sip-4.19.13-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "dae098312edb7bf27be16aac996a17f5", + "name": "sip", + "sha256": "b7fe155beafa1e56bb05953083915aa32a063181b5d17389ee5a0e383ef60aa1", + "size": 299769, + "subdir": "linux-64", + "timestamp": 1541049854131, + "version": "4.19.13" + }, + "sip-4.19.13-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "md5": "ddc650a2539e21bbb5687f48efd0ca98", + "name": "sip", + "sha256": "707df76fe52ac4ed5bd6848c97562edf8deb8e78987545baa4958e6ed92b23f8", + "size": 302714, + "subdir": "linux-64", + "timestamp": 1643114697081, + "version": "4.19.13" + }, + "sip-4.19.13-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "md5": "8300829923f37c4267613755632770b8", + "name": "sip", + "sha256": "c9a8835628124ecaee4a43b151be0b7ad382d3c7d25c0289b2c3396e00190b4a", + "size": 301151, + "subdir": "linux-64", + "timestamp": 1573200494589, + "version": "4.19.13" + }, + "sip-4.19.13-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-3.0", + "md5": "368252c01815923d7f4063ab01aab286", + "name": "sip", + "sha256": "d394590b9265bce4a1303886847bd9c5bd82f279656730482629c750209a35df", + "size": 303491, + "subdir": "linux-64", + "timestamp": 1607550718266, + "version": "4.19.13" + }, + "sip-4.19.13-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-3.0", + "md5": "3ec6ce8f2eae0969b341e5702fb029c6", + "name": "sip", + "sha256": "9f2d68b41365097a380979014b3cabf5f1f9f07e5554eb215eef4801f640922e", + "size": 302624, + "subdir": "linux-64", + "timestamp": 1643114723175, + "version": "4.19.13" + }, + "sip-4.19.22-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "5a86cbe843cb12e6947685aa690f7920", + "name": "sip", + "sha256": "a16df0ed58b22ae6ae33dbf08876b82ba874203a2e079af8bdaaf6480c141df3", + "size": 305553, + "subdir": "linux-64", + "timestamp": 1592441747638, + "version": "4.19.22" + }, + "sip-4.19.22-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "eb067beab34a7bbde7f618015d800be7", + "name": "sip", + "sha256": "a59d3c0b9adc43f1af28d60a983d2d93c86c8951826fe5eb67d2bb662b57f4b3", + "size": 305537, + "subdir": "linux-64", + "timestamp": 1592441771763, + "version": "4.19.22" + }, + "sip-4.19.22-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "md5": "c65cd09f67ede0fbc5ebed12431cfacb", + "name": "sip", + "sha256": "c8717eb43aec1a50dcd760facaa225327846d0b2fc599a0e82d789f0113f0ceb", + "size": 306728, + "subdir": "linux-64", + "timestamp": 1592441773931, + "version": "4.19.22" + }, + "sip-4.19.23-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "985062da790dee80f4462d9e62b26ae6", + "name": "sip", + "sha256": "90ccb930d94856212d2efc22ec20efe59ad269df57234db0bf137460828d6c46", + "size": 305945, + "subdir": "linux-64", + "timestamp": 1593109914249, + "version": "4.19.23" + }, + "sip-4.19.23-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "672c9c7960bb38f043caaacd00f7c142", + "name": "sip", + "sha256": "540198fae4bf50c2bfc39bd75c7a5a5e4b467d1fecb8ffde504be11eae7f30f7", + "size": 305914, + "subdir": "linux-64", + "timestamp": 1593109930590, + "version": "4.19.23" + }, + "sip-4.19.23-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "md5": "0014a5b9b8728ad57794581b7d2c2a77", + "name": "sip", + "sha256": "9b5ca5a947e2fd6cd705362e3ed02a83a7778a90df3dc2e70a9980146ddcebfb", + "size": 307040, + "subdir": "linux-64", + "timestamp": 1593109923723, + "version": "4.19.23" + }, + "sip-4.19.24-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "37fb4f34123b4ba9d2de1bdc3cd1ef0e", + "name": "sip", + "sha256": "dc7a1bee247423971e3858799af6aabe470f3c3b9abf7c02077acc87ab2e481c", + "size": 303799, + "subdir": "linux-64", + "timestamp": 1597341671915, + "version": "4.19.24" + }, + "sip-4.19.24-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "413b6a4e282b1f749f1a89a05d599a19", + "name": "sip", + "sha256": "e8676b7e86a4f47caaaa94054c3220ca98681c7eea25d6f3cf37f9083871da42", + "size": 303652, + "subdir": "linux-64", + "timestamp": 1597341682248, + "version": "4.19.24" + }, + "sip-4.19.24-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "md5": "b717a03820d7585890f25c3e47fc1445", + "name": "sip", + "sha256": "f914beb384062fc36ee50b9a2585fd789f24477deb4dccafcdd2a81db7b00173", + "size": 304753, + "subdir": "linux-64", + "timestamp": 1597341699538, + "version": "4.19.24" + }, + "sip-4.19.24-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-3.0", + "md5": "9625146b6392dc0268dbe918793a9314", + "name": "sip", + "sha256": "a91a090b24bc538c5a34efc306df35002da37c351ef77ff2a0c628a6ff6eb918", + "size": 307735, + "subdir": "linux-64", + "timestamp": 1607102353831, + "version": "4.19.24" + }, + "sip-4.19.25-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "GPL-3.0", + "md5": "e9c9e8ab75283d2b714e18078857b547", + "name": "sip", + "sha256": "358121880a68037d21bb5c95926130d8b3ffb95887e653a0dd8ca5c1acf7e2b4", + "size": 303181, + "subdir": "linux-64", + "timestamp": 1640794796998, + "version": "4.19.25" + }, + "sip-4.19.25-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "2f7edc197e6a78ab7538781b433329b9", + "name": "sip", + "sha256": "4e50be55444f2d287c99bea9d0cc06d5754d4c109c4c366e60a9a51518e95c36", + "size": 302364, + "subdir": "linux-64", + "timestamp": 1614366670720, + "version": "4.19.25" + }, + "sip-4.19.25-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "a4c9aab4523040a29387ffcea97b0196", + "name": "sip", + "sha256": "9df0dc15a3c6c178319cdc617594d5a9a9c1a0924f1b99a8564878e75e7dfacd", + "size": 302310, + "subdir": "linux-64", + "timestamp": 1614366663078, + "version": "4.19.25" + }, + "sip-4.19.25-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "md5": "39babaa5b7b211b661ec85aebda8540b", + "name": "sip", + "sha256": "8218a893a58244656b084f5c80a89d9c252e412bfb2bed631b21a334b473f14b", + "size": 303515, + "subdir": "linux-64", + "timestamp": 1614366675321, + "version": "4.19.25" + }, + "sip-4.19.25-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-3.0", + "md5": "e5dd8dc1f5f7bcbf65d210004b767b48", + "name": "sip", + "sha256": "daf2326587171711089cddc64ef89ff48eb11ee2624b27eebec485ee1e863141", + "size": 303424, + "subdir": "linux-64", + "timestamp": 1614365616335, + "version": "4.19.25" + }, + "sip-4.19.8-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-3.0", + "md5": "3f8d79fd6065f6e14f470197355dbc65", + "name": "sip", + "sha256": "f5713f031324fbdd9180faf4f648492212ecb6ac147cd605b32d5c573a5e6d2e", + "size": 297829, + "subdir": "linux-64", + "timestamp": 1521796117814, + "version": "4.19.8" + }, + "sip-4.19.8-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL-3.0", + "md5": "79cab970f73e1e836a4268200a4405ee", + "name": "sip", + "sha256": "eb4ff8737aa350f0328df27c9168d507aa34abc63e47deb916c6c88ea62c3f6a", + "size": 297668, + "subdir": "linux-64", + "timestamp": 1521796149321, + "version": "4.19.8" + }, + "sip-4.19.8-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "4c8ef34a6e7ca445ec92901f0b5d90c0", + "name": "sip", + "sha256": "64ba7795813d3cf5890d736f06e01a06ccdabee1853acc91a7a1f2fa59c3d3bb", + "size": 296974, + "subdir": "linux-64", + "timestamp": 1521796180404, + "version": "4.19.8" + }, + "sip-4.19.8-py37hf484d3e_0.tar.bz2": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "128cd74c4a5f3ec92872bfb7f5b288c2", + "name": "sip", + "sha256": "ccea9572e389588b198aad6703b3d97ee4f8299707b909b10e309dd976c7ed56", + "size": 297157, + "subdir": "linux-64", + "timestamp": 1530793400234, + "version": "4.19.8" + }, + "sip-4.19.8-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "md5": "380b0bab1793466ddf599b5b8c643af3", + "name": "sip", + "sha256": "736694e739762c6273c8f73cdd52ca152d2fb07551977883997cdd4ce14372d6", + "size": 299800, + "subdir": "linux-64", + "timestamp": 1579625560000, + "version": "4.19.8" + }, + "sip-6.5.1-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "packaging", + "python >=3.10,<3.11.0a0", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "19ef05102ec95847a6eebeb0715b8fb6", + "name": "sip", + "sha256": "18efadbdb5ac702ac6a4118457778394012a7010e8b9425280aaf4839606d5ac", + "size": 699713, + "subdir": "linux-64", + "timestamp": 1651046326934, + "version": "6.5.1" + }, + "sip-6.5.1-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "packaging", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "30097fcd7bac89a0c04d6602b88bfc92", + "name": "sip", + "sha256": "aafbfc12dc9a943091782f3d19a1628b879b58df18461ec5f07cf15f532c2fdc", + "size": 407351, + "subdir": "linux-64", + "timestamp": 1651046410867, + "version": "6.5.1" + }, + "sip-6.5.1-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "packaging", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "d17e4774138dd50b7b4c0bc268536698", + "name": "sip", + "sha256": "05cfbd3a5072345e188684a6dda59c68bc39b7ac639515d8afcd9a6b80c494a6", + "size": 416026, + "subdir": "linux-64", + "timestamp": 1651046275372, + "version": "6.5.1" + }, + "sip-6.5.1-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "packaging", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "c7b4df8a161b0488aa454c6f2c2acee9", + "name": "sip", + "sha256": "4b2c76691cd65f352dd904cce9e6a806f86621982d4a03cb33b5ca26a81f2584", + "size": 415445, + "subdir": "linux-64", + "timestamp": 1651046370285, + "version": "6.5.1" + }, + "sip-6.6.2-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "ply", + "python >=3.10,<3.11.0a0", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "b2010c208eec2c87487581def9f1f7ac", + "name": "sip", + "sha256": "824a1c283bc0bcc126aa1fdf427248d1098fe34b88df710a4aaf2cfda584b01b", + "size": 826312, + "subdir": "linux-64", + "timestamp": 1659012503474, + "version": "6.6.2" + }, + "sip-6.6.2-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "ply", + "python >=3.11,<3.12.0a0", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "6bb6494528e32e5659b162e3ee954abe", + "name": "sip", + "sha256": "71e5381e3e9745bf563399feadb408b28602d34bff7a81b5adfb323750b02483", + "size": 585383, + "subdir": "linux-64", + "timestamp": 1676825141789, + "version": "6.6.2" + }, + "sip-6.6.2-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "ply", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "c0b5c6599b44d3cc521d71137d8f7e6c", + "name": "sip", + "sha256": "948e14e3353917ae4fb92e46f6294b9fc0b823354e7794e53ed846dafdd439d6", + "size": 499735, + "subdir": "linux-64", + "timestamp": 1659012560366, + "version": "6.6.2" + }, + "sip-6.6.2-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "ply", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "86021f0baf773bc6afbc609a1c44113d", + "name": "sip", + "sha256": "8e7ad58e97bc49ba3c346c03d281d97a22a79bef02674ccda8f7ad7af2667b01", + "size": 500846, + "subdir": "linux-64", + "timestamp": 1659012616068, + "version": "6.6.2" + }, + "sip-6.6.2-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "ply", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "bb02a522e08b9e34d020579b4d36e56c", + "name": "sip", + "sha256": "c138c4271403757597f59cf9503d405da2dfdd0152d498dc04e2e160e76c9719", + "size": 505841, + "subdir": "linux-64", + "timestamp": 1659012429830, + "version": "6.6.2" + }, + "six-1.10.0-py27hdcd7534_1.tar.bz2": { + "build": "py27hdcd7534_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "09599a7e8d2f6642e220926853479037", + "name": "six", + "sha256": "86d53c5d34d5088520bf3188873ee8cd94c05dbb384ffa2395ed6a571a68d336", + "size": 20568, + "subdir": "linux-64", + "timestamp": 1505672067944, + "version": "1.10.0" + }, + "six-1.10.0-py35h5312c1b_1.tar.bz2": { + "build": "py35h5312c1b_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6092132bf652e4ed46e81d68b9ef8581", + "name": "six", + "sha256": "e54a871939cf9f54a495340c55223551b8a440e679449939b2252c98d9954480", + "size": 20981, + "subdir": "linux-64", + "timestamp": 1505672078657, + "version": "1.10.0" + }, + "six-1.10.0-py36hcac75e4_1.tar.bz2": { + "build": "py36hcac75e4_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "816dd34bf45fe338b86fd3c79add7a86", + "name": "six", + "sha256": "ffb70e93db8c69a63c6cc53abcbeb9af41fa811da4aeced91b7d5f7e043cd6c1", + "size": 20918, + "subdir": "linux-64", + "timestamp": 1505672089464, + "version": "1.10.0" + }, + "six-1.11.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c13b7574e2357aeea5ee3dc755ee699f", + "name": "six", + "sha256": "1c23f7412d3a6913cfee1e9834bf4bf47c06053369341e9a0255b6916d3cf7be", + "size": 21153, + "subdir": "linux-64", + "timestamp": 1530693756133, + "version": "1.11.0" + }, + "six-1.11.0-py27h5f960f1_1.tar.bz2": { + "build": "py27h5f960f1_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f44412e3008d94309936c9b238518516", + "name": "six", + "sha256": "e3947ed53a5426f63765a42c67e9365e0611e4267d38a4f339689a17233ee4c2", + "size": 21501, + "subdir": "linux-64", + "timestamp": 1508610494828, + "version": "1.11.0" + }, + "six-1.11.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1508857d0387325bb00abd58a79679b6", + "name": "six", + "sha256": "952a1dcff75aa9b0fcf25c6ef7f5e01506fc051303385fde2be086c0956fda0f", + "size": 21470, + "subdir": "linux-64", + "timestamp": 1534344959297, + "version": "1.11.0" + }, + "six-1.11.0-py35h423b573_1.tar.bz2": { + "build": "py35h423b573_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "576d38abfcb7ceb3b323b802b1fec665", + "name": "six", + "sha256": "fe0d3e31e6f5c0b79666313416fa0c9aa41c083585f73d1d62a49f3bd464b095", + "size": 21870, + "subdir": "linux-64", + "timestamp": 1508610522504, + "version": "1.11.0" + }, + "six-1.11.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a5fb5d8d75bf5d76f139b6c3152cf26", + "name": "six", + "sha256": "1b9f8bd729d7c4c241be085dd10dc02c6587c1d45a087530956438c1657f324d", + "size": 21501, + "subdir": "linux-64", + "timestamp": 1530693718665, + "version": "1.11.0" + }, + "six-1.11.0-py36h372c433_1.tar.bz2": { + "build": "py36h372c433_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1912b4563535b2c12b5f80ac514e2e01", + "name": "six", + "sha256": "cbaa191de4426b8fc3abd555bbef24687aa5915e04c7f969af7324e57918b30f", + "size": 21798, + "subdir": "linux-64", + "timestamp": 1508610520093, + "version": "1.11.0" + }, + "six-1.11.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "97a78bf9aa73ef433f9e0f65c48f48c3", + "name": "six", + "sha256": "d898ab9d8e6575411594ff03baebe2a4903d7ab03cd2b3337a3e92336056f686", + "size": 21522, + "subdir": "linux-64", + "timestamp": 1530693737763, + "version": "1.11.0" + }, + "six-1.12.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8afd153522a742b029e4aab70a61925e", + "name": "six", + "sha256": "2db08901a2bb73fee41839bbda82b8f96d6f0afa5cbe3a067517162fb8119a40", + "size": 22326, + "subdir": "linux-64", + "timestamp": 1544542935561, + "version": "1.12.0" + }, + "six-1.12.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b65b372c36988bab5ec501be37c4740", + "name": "six", + "sha256": "458d3ebb7b7286ebca53e8e5803da5f651b8f5b08468ca0cfd1c0c5618490f72", + "size": 22704, + "subdir": "linux-64", + "timestamp": 1544542969635, + "version": "1.12.0" + }, + "six-1.12.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "737521afc3a721bd133cc96cc871888c", + "name": "six", + "sha256": "57776ca2ad814ed8107336d900cbde1eea8439cfea76fc7941aca55ccdf22e2e", + "size": 22691, + "subdir": "linux-64", + "timestamp": 1544542931768, + "version": "1.12.0" + }, + "six-1.12.0-py38_1000.tar.bz2": { + "build": "py38_1000", + "build_number": 1000, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "46fb3b2cd12daa7d82b56ff245bb3ea4", + "name": "six", + "sha256": "172f7cac46f4ffedf9afee17a74cb68968251e5457cba2a6da8f32a63e00f10f", + "size": 23449, + "subdir": "linux-64", + "timestamp": 1572609182813, + "version": "1.12.0" + }, + "six-1.13.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d382089ccc1ca3120ecf23b303dd4c9", + "name": "six", + "sha256": "bf20cbd284528c066100d3c033be46f6865b48b5be023152638c46c00bb5d1e8", + "size": 26825, + "subdir": "linux-64", + "timestamp": 1573251215503, + "version": "1.13.0" + }, + "six-1.13.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "014ec5cf49869fff2cc71512c0819e5a", + "name": "six", + "sha256": "b08673c9d7e14b9f2a0d706622038ca9031442b5ac4452cea8e3bf033f248a20", + "size": 27148, + "subdir": "linux-64", + "timestamp": 1573251221722, + "version": "1.13.0" + }, + "six-1.13.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8cb4088270f942361ac53b864040aaa2", + "name": "six", + "sha256": "63d5ee15183bb5223ab4e9764b907c587a18fedba902f4b268f7496db4cd1db8", + "size": 27199, + "subdir": "linux-64", + "timestamp": 1573251210326, + "version": "1.13.0" + }, + "six-1.13.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4285910f7cbc33c07ae08da41a1c695d", + "name": "six", + "sha256": "f8a5b2162fc30da195e93ee1e4e9dc914c6ec59f467e1314e89c2c4acf1ff383", + "size": 27279, + "subdir": "linux-64", + "timestamp": 1573251253148, + "version": "1.13.0" + }, + "six-1.14.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "740812179949cd44db43db51ef7a935e", + "name": "six", + "sha256": "4acada6b3741f395c61e6edbb6881dcb28b7f8a3da5f631dfbe10bf1eac1efa6", + "size": 27654, + "subdir": "linux-64", + "timestamp": 1580149944409, + "version": "1.14.0" + }, + "six-1.14.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5dc842c91eda592e763086cf8dbf7661", + "name": "six", + "sha256": "39bc95a1dc0dc98e156c900467684ce1e7e5b11a496df400716f06ae543166f8", + "size": 27991, + "subdir": "linux-64", + "timestamp": 1605201619625, + "version": "1.14.0" + }, + "six-1.14.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb6def8ed7c6461756dd78429faadcf2", + "name": "six", + "sha256": "c908985359452c7fb5ca3fc486881754727e0fe52234a5b65f542ff9e2f6b539", + "size": 27674, + "subdir": "linux-64", + "timestamp": 1580149912348, + "version": "1.14.0" + }, + "six-1.14.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "50cd044e4b65bf315c2c8dcf7f45f36b", + "name": "six", + "sha256": "a49dd92da11da4ab85a19602f15c60571a382f386f3aaea2b12443b78fb56738", + "size": 27972, + "subdir": "linux-64", + "timestamp": 1605201645932, + "version": "1.14.0" + }, + "six-1.14.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a44424cee795266d4dbfba1e2bd3da15", + "name": "six", + "sha256": "72fc6ecdaa06c45dc0de0870cc5a8364f91d4cb4030dc16ef1e3bfe3e22c97ed", + "size": 27726, + "subdir": "linux-64", + "timestamp": 1580149919050, + "version": "1.14.0" + }, + "six-1.14.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bdc98ef5ddd6432fbb7b53409cc3570c", + "name": "six", + "sha256": "3f40d5611fbe22a5598105bf52ba093b985003d11fe663aca0f3046da4fa90d9", + "size": 28059, + "subdir": "linux-64", + "timestamp": 1605201641536, + "version": "1.14.0" + }, + "six-1.14.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f2ecf41e9432997af932fe79924d068", + "name": "six", + "sha256": "a4ff65c5851598da184d733676bdcb5a58e9acaaffd0201dab8a704c6143a614", + "size": 28072, + "subdir": "linux-64", + "timestamp": 1605201648065, + "version": "1.14.0" + }, + "six-1.15.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2355b3ce489084a0aa42aed324318495", + "name": "six", + "sha256": "9591d6cae56e04d29bb9f59eb9bf320030f0aa4f0777cdb28b56771ed17cabae", + "size": 27975, + "subdir": "linux-64", + "timestamp": 1605205370543, + "version": "1.15.0" + }, + "six-1.15.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7a340ec0722ff732a9eac8dd4a41adc7", + "name": "six", + "sha256": "c75fb171b6d53c39e90c60b0ae9bf1e796b1b82dc5d6170917f8f77c763c0314", + "size": 28002, + "subdir": "linux-64", + "timestamp": 1605205343469, + "version": "1.15.0" + }, + "six-1.15.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2525fc7e0eea23757368702c61d48aa", + "name": "six", + "sha256": "0ecdc24f8ab65f9d04ddbab7f443217b01d5c73f148f905487e6f034edd05d98", + "size": 28066, + "subdir": "linux-64", + "timestamp": 1605205355842, + "version": "1.15.0" + }, + "six-1.15.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc3710d703315a9b7a1ca687ba71f187", + "name": "six", + "sha256": "4b536fc491eb19512729d2e3b6930d8a8664f30214e5fde20ed43b4d9c07c80d", + "size": 28081, + "subdir": "linux-64", + "timestamp": 1605205336128, + "version": "1.15.0" + }, + "skl2onnx-1.13-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.15", + "onnx >=1.2.1", + "onnxconverter-common >=1.7.0", + "packaging", + "protobuf", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.19,<=1.1.1", + "scipy >=1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fb9fcde8d27d3cff91af6982ae6aa5c6", + "name": "skl2onnx", + "sha256": "166d610dba063389734d78e4779719925306ca8d2955ce632b660567380ddce2", + "size": 407248, + "subdir": "linux-64", + "timestamp": 1671654320198, + "version": "1.13" + }, + "skl2onnx-1.13-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.15", + "onnx >=1.2.1", + "onnxconverter-common >=1.7.0", + "packaging", + "protobuf", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.19,<=1.1.1", + "scipy >=1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0593cc4f5c61560df315cb868f3609f6", + "name": "skl2onnx", + "sha256": "e0878f092fdca4b8d2195a55d9aef01adf035fb95f76294f75b898dd0bd1d476", + "size": 394133, + "subdir": "linux-64", + "timestamp": 1671654259659, + "version": "1.13" + }, + "skl2onnx-1.13-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.15", + "onnx >=1.2.1", + "onnxconverter-common >=1.7.0", + "packaging", + "protobuf", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.19,<=1.1.1", + "scipy >=1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "57703a69d259c08b9cb12bdd9ef1d8c6", + "name": "skl2onnx", + "sha256": "093cfaac95f2c42bce128ae96ec0a6e9f787918ad3315a75656dabe718214efc", + "size": 396208, + "subdir": "linux-64", + "timestamp": 1671654290376, + "version": "1.13" + }, + "skl2onnx-1.13-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.15", + "onnx >=1.2.1", + "onnxconverter-common >=1.7.0", + "packaging", + "protobuf", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.19,<=1.1.1", + "scipy >=1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8e0b8bc7fff70ca1e7962fae0de6d9f7", + "name": "skl2onnx", + "sha256": "88d72e3ae8bf467a0e1b4ba7d0b88cde4cd8e9dd054ac2709b823787a029d635", + "size": 396307, + "subdir": "linux-64", + "timestamp": 1671654227364, + "version": "1.13" + }, + "slack-sdk-3.19.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1003f1df1023fdb445396ebdfb2e7d91", + "name": "slack-sdk", + "sha256": "16e0edfac87e66f286f2b9e4f02bed9b13e37b53b39f3a953437cea12dca8e70", + "size": 350898, + "subdir": "linux-64", + "timestamp": 1675353525242, + "version": "3.19.5" + }, + "slack-sdk-3.19.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "908cab3626fda572ffa1968053d2699d", + "name": "slack-sdk", + "sha256": "f1b9cc610d4d9d8a8ee1a715336425968175faadd57df240e1e60bebc79e9951", + "size": 497648, + "subdir": "linux-64", + "timestamp": 1676862199113, + "version": "3.19.5" + }, + "slack-sdk-3.19.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9d87f7c185072628d378ec2c57ce2ca", + "name": "slack-sdk", + "sha256": "6294498134e88e00e625e505d1a36b1d011fccc6dfe950b8e452e649dc6ac5d7", + "size": 339662, + "subdir": "linux-64", + "timestamp": 1675353497598, + "version": "3.19.5" + }, + "slack-sdk-3.19.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aac072e1ba87cc9eaa39e5b9f9612406", + "name": "slack-sdk", + "sha256": "9eb7dee95be10342260b38a924dfd6d24e3b7f06caab21191bf6fa94f31bdfbf", + "size": 344450, + "subdir": "linux-64", + "timestamp": 1675353430270, + "version": "3.19.5" + }, + "slack-sdk-3.19.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e89577928f6c615eedb6df0ddfe19973", + "name": "slack-sdk", + "sha256": "ff455f03aa8fde90364b224f602c4a84caf0e49c6864237b8dc4a6678e900add", + "size": 345231, + "subdir": "linux-64", + "timestamp": 1675353466690, + "version": "3.19.5" + }, + "slack-sdk-3.2.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a905a1487430a9ada5d714ca884b4b27", + "name": "slack-sdk", + "sha256": "e300c00c845492d7ae47072263a01a26ba4f5427bf74ecece5824e2498275fc0", + "size": 240096, + "subdir": "linux-64", + "timestamp": 1612478124311, + "version": "3.2.1" + }, + "slack-sdk-3.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4a38dba70513af7133bbbe4b4b4773f0", + "name": "slack-sdk", + "sha256": "2fb7225d7720e13676c97f5548a30f0d79612010e9064d49768ddfc1eec8d81d", + "size": 242460, + "subdir": "linux-64", + "timestamp": 1612478586024, + "version": "3.2.1" + }, + "slack-sdk-3.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7623dad1cdf081367d660cbe801cf726", + "name": "slack-sdk", + "sha256": "1456c83bb6eced47e5b9f81910cf258835c418082b1a317801cd7c8234948782", + "size": 244242, + "subdir": "linux-64", + "timestamp": 1612478593196, + "version": "3.2.1" + }, + "slackclient-2.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b49cdb2b2fd42855183e76c5829f3653", + "name": "slackclient", + "sha256": "f86eafe71ac194ed01e3d5e3d1cfd5bff86c96cf7618914c7fd5d2738b443ab1", + "size": 123005, + "subdir": "linux-64", + "timestamp": 1597067100478, + "version": "2.8.0" + }, + "slackclient-2.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d70287c071a8a82992b5d9787aaf9eeb", + "name": "slackclient", + "sha256": "4c0697599b48eb2f2f4280df4dcc9250c6266d89b9ebe00d76fb3a80f94134f7", + "size": 127027, + "subdir": "linux-64", + "timestamp": 1600554234625, + "version": "2.9.0" + }, + "slackclient-2.9.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16071c73bd2896027c3f1411b62a3ecd", + "name": "slackclient", + "sha256": "af8478753ec588c741884fe99826913807f1b5dab281c293e6fb625d6932369d", + "size": 127142, + "subdir": "linux-64", + "timestamp": 1600554234115, + "version": "2.9.0" + }, + "slackclient-2.9.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "78e2e4a79523805a7329472bb173b7de", + "name": "slackclient", + "sha256": "eef59874e555743074bad9897b61d52a5666722d42057803751e30dc1d1d53f3", + "size": 128591, + "subdir": "linux-64", + "timestamp": 1600554222222, + "version": "2.9.0" + }, + "slackclient-2.9.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "93e425adfafda2c62cf467e61db60e58", + "name": "slackclient", + "sha256": "b9f5be04beb23dff270457cc270b1a22f40d92850d8c729296aa23741720a946", + "size": 127170, + "subdir": "linux-64", + "timestamp": 1600885313560, + "version": "2.9.1" + }, + "slackclient-2.9.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "10408e4063e7ed70faa72fdeac7681ab", + "name": "slackclient", + "sha256": "85d0f755731cebb0cf797849a9654a578ebc5f487286c55a7e6dd7840ad765d3", + "size": 127385, + "subdir": "linux-64", + "timestamp": 1600881137963, + "version": "2.9.1" + }, + "slackclient-2.9.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b475a9cd16be340f80918cc1862327a", + "name": "slackclient", + "sha256": "b8c2c011073f221688f0415c8bbaed7c2b46297305d8c5779f05ee8fef8d403b", + "size": 128816, + "subdir": "linux-64", + "timestamp": 1600885283322, + "version": "2.9.1" + }, + "slackclient-2.9.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd80fbb7e4b1c4f3943edca0d2d28e4f", + "name": "slackclient", + "sha256": "b3c559d9ef946e45a3cbe447c9d02597a3c5a41097a435693bd6568452c5bfd0", + "size": 128393, + "subdir": "linux-64", + "timestamp": 1602525307560, + "version": "2.9.2" + }, + "slackclient-2.9.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e4f62d0989e49d6cbdd5902eb1af39f", + "name": "slackclient", + "sha256": "7e5dc5b6d93720e1fae2ab26adbf264e691b564f193cbce9a409136fd072fb9c", + "size": 128656, + "subdir": "linux-64", + "timestamp": 1602525304074, + "version": "2.9.2" + }, + "slackclient-2.9.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f32e4c933e4cea5ea9e626bc527d3f4e", + "name": "slackclient", + "sha256": "dddfa818ba9aa99b139c6968d69e4759bc2d37f323e4126c65aba444f1a27ed1", + "size": 130115, + "subdir": "linux-64", + "timestamp": 1602525286981, + "version": "2.9.2" + }, + "slackclient-2.9.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3bf114d0dce9a0a24eff054858593c84", + "name": "slackclient", + "sha256": "ce7f8c52876f08ec03d893149dcf1a231a9897c677a13a39f1fd0f81a4ba561c", + "size": 131729, + "subdir": "linux-64", + "timestamp": 1641904219706, + "version": "2.9.3" + }, + "slackclient-2.9.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5cd0de29a2292846223ceb822dba02c8", + "name": "slackclient", + "sha256": "96a85e57ba8fd2c04fe22fd821b08475f330262b3ed15955d4753b1ec731941f", + "size": 179453, + "subdir": "linux-64", + "timestamp": 1676862221062, + "version": "2.9.3" + }, + "slackclient-2.9.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ce682e597cefb3c207e1f40257676de", + "name": "slackclient", + "sha256": "f863120ef7960361cd128880eb1ba54b118a1c186562cb28ec1bed8c67de64dc", + "size": 128244, + "subdir": "linux-64", + "timestamp": 1603479088289, + "version": "2.9.3" + }, + "slackclient-2.9.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f0aed65e44852f3ccb08f1327ad0b1a7", + "name": "slackclient", + "sha256": "8d411a185cb1431e5a291e4fde686129a8d0d362dc99ca149f6ac9eaf8269033", + "size": 128320, + "subdir": "linux-64", + "timestamp": 1603816112200, + "version": "2.9.3" + }, + "slackclient-2.9.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "94db1a69dfb5fbcb45630ef6118893d2", + "name": "slackclient", + "sha256": "c932337decb7313edd18211afcdc9730ea9806bc1eb6c8b476b55bf9764eb86e", + "size": 128377, + "subdir": "linux-64", + "timestamp": 1603479081137, + "version": "2.9.3" + }, + "slackclient-2.9.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f0f0811d65baa15269b799070feeeb83", + "name": "slackclient", + "sha256": "97ac4bc53f789a85044521711b03f1c14276bc987c00daca098f06ddffe5e7be", + "size": 128398, + "subdir": "linux-64", + "timestamp": 1603816097766, + "version": "2.9.3" + }, + "slackclient-2.9.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e53732d21347beace62d077e0ed8f100", + "name": "slackclient", + "sha256": "c9b489bbdb300d7597ebb008f2997683c3877ea6a69e22a0248b5c88feb17bb5", + "size": 129813, + "subdir": "linux-64", + "timestamp": 1603479056056, + "version": "2.9.3" + }, + "slackclient-2.9.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60714167d7e847af8acedfd105e3adba", + "name": "slackclient", + "sha256": "748125875970c5bc65856a26bfcdc54f4d98947671e55413c1d4d66cc7b73bb5", + "size": 130037, + "subdir": "linux-64", + "timestamp": 1603816111042, + "version": "2.9.3" + }, + "slackclient-2.9.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b0f0d85a4f59408bf118e1ba925f8999", + "name": "slackclient", + "sha256": "48819beb9c9e7445189b801a879456e378065ef20750031b11e691c078fcc071", + "size": 136823, + "subdir": "linux-64", + "timestamp": 1613481541420, + "version": "2.9.3" + }, + "smart_open-1.5.6-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "boto >=2.32", + "boto3", + "bz2file", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74a8c29dbbcdccece83e2403c28cd127", + "name": "smart_open", + "sha256": "4d466da800e6673e7fff1387b21edc4f86ef37baa8210cb619ac2d5affeb8f24", + "size": 57573, + "subdir": "linux-64", + "timestamp": 1519838656086, + "version": "1.5.6" + }, + "smart_open-1.5.6-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "boto >=2.32", + "boto3", + "bz2file", + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d16a0dc3e5eee325b76f6282ea74728", + "name": "smart_open", + "sha256": "52b189130b49f3358d39a3704bd72d119aa2fc39a29ca2896c7c331b5f5a21e7", + "size": 59076, + "subdir": "linux-64", + "timestamp": 1519838697304, + "version": "1.5.6" + }, + "smart_open-1.5.6-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "boto >=2.32", + "boto3", + "bz2file", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e95b886ddb9873a18e64077f51d55fd", + "name": "smart_open", + "sha256": "2d7bb6e4f46bb10c8c301a30539564bcc564a5c056366faa7dc89ad3399a5fa9", + "size": 59029, + "subdir": "linux-64", + "timestamp": 1519838629764, + "version": "1.5.6" + }, + "smart_open-1.5.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "bz2file", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "409b1720ce3aece578791cb7271e1863", + "name": "smart_open", + "sha256": "f56ecc92581764fb74ddc17f6d8d46ca55c9010f6db7dd8cc84f9c2ce3a4d0ca", + "size": 57685, + "subdir": "linux-64", + "timestamp": 1522195592417, + "version": "1.5.7" + }, + "smart_open-1.5.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "bz2file", + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "678c72f947599f5e3622aef59ce26e64", + "name": "smart_open", + "sha256": "b0a087c98f96ed29ac66682f8cd97c3489b04ff4c0b655c8236d86734375af72", + "size": 59182, + "subdir": "linux-64", + "timestamp": 1522195623993, + "version": "1.5.7" + }, + "smart_open-1.5.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "bz2file", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dec07b57b143005035064ca0ddff853f", + "name": "smart_open", + "sha256": "4a9e5a2a79021d354df0811bf082634c970b8e609fb19317cab756d0be135860", + "size": 59122, + "subdir": "linux-64", + "timestamp": 1522195628590, + "version": "1.5.7" + }, + "smart_open-1.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "bz2file", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c7cbc6d319812386b29ba3e5912b8db", + "name": "smart_open", + "sha256": "c9882dd8aeb3a7d314ba8daa361e0c9c21a9dd92078140921f8f2bb200393bb4", + "size": 63877, + "subdir": "linux-64", + "timestamp": 1530556756233, + "version": "1.6.0" + }, + "smart_open-1.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b31992dcf166daf5997597c0def8fa6", + "name": "smart_open", + "sha256": "19da0e1cb936ecd0b2bec620c44e0e13eda660c9893001dc8e67b9d316758d3d", + "size": 65194, + "subdir": "linux-64", + "timestamp": 1530556775910, + "version": "1.6.0" + }, + "smart_open-1.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a7dfd7d3052eff61d61bbe16347cd635", + "name": "smart_open", + "sha256": "b91ae554c9ee4c8a9a2480ce15659db14776acbe20a440862588ecad18148daf", + "size": 65093, + "subdir": "linux-64", + "timestamp": 1530556774803, + "version": "1.6.0" + }, + "smart_open-1.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98c832633bfa8f05e8585784335631ce", + "name": "smart_open", + "sha256": "0c1cf14ee50b3feddb1911a1adc60bd90aa50a68b27986a45722a74fe3e99abc", + "size": 65125, + "subdir": "linux-64", + "timestamp": 1530889256326, + "version": "1.6.0" + }, + "smart_open-1.7.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "bz2file", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "565dc9098185b6aeb4fa761dcc4e0f94", + "name": "smart_open", + "sha256": "418e3d3da8a5a733fa51ff05e45583d7b4a5241bf0d71e04019f90a4eb0eca7c", + "size": 67330, + "subdir": "linux-64", + "timestamp": 1539638619092, + "version": "1.7.1" + }, + "smart_open-1.7.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3bcff260eecc98cca8959519df76e8ad", + "name": "smart_open", + "sha256": "5be610492b8ae2bc009dfde6b7db9bdd60f360fab64eef39c9f824c40a8551ee", + "size": 68619, + "subdir": "linux-64", + "timestamp": 1539638635611, + "version": "1.7.1" + }, + "smart_open-1.7.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8e5fe8b2b723acab9c8ff4983f8a951", + "name": "smart_open", + "sha256": "9c144e94e4556f9f9c43f213cf52b4bd63f7dcff1f58fe7fb7cad483f10be2dc", + "size": 68666, + "subdir": "linux-64", + "timestamp": 1539638637622, + "version": "1.7.1" + }, + "smart_open-1.8.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "bz2file", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "391ef3994c6ed8f2283b4ab0a8f64adf", + "name": "smart_open", + "sha256": "3a78daf1181c362c07901d7a6f9f60565ad359814a709fdea982932de1592484", + "size": 69953, + "subdir": "linux-64", + "timestamp": 1547925279513, + "version": "1.8.0" + }, + "smart_open-1.8.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "843d1280eacc84ae32a19e12e38182c7", + "name": "smart_open", + "sha256": "1472be35eef3fe7166570fc06a67c76efcb16027a040501c6715cb636aa0ecf8", + "size": 71427, + "subdir": "linux-64", + "timestamp": 1547925320069, + "version": "1.8.0" + }, + "smart_open-1.8.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2d044b29545af8cc1551771189cd7bf", + "name": "smart_open", + "sha256": "ca818a426e72a2d4184f3f251418e56cc8c0c1a6cdb52c522f4d9bd811e8c45c", + "size": 71386, + "subdir": "linux-64", + "timestamp": 1547925302849, + "version": "1.8.0" + }, + "smart_open-5.2.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "acaf60fd95224ee8c19c1d0619968054", + "name": "smart_open", + "sha256": "ff62fc50b6626be8a11e7a68dd7d0c132b24103c536dae15d86eed374341b264", + "size": 77475, + "subdir": "linux-64", + "timestamp": 1651563590365, + "version": "5.2.1" + }, + "smart_open-5.2.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f7775f12e86192d8bb7e0902250ce9d", + "name": "smart_open", + "sha256": "e7126304390aafb54097cfc2f287a829c102a8034933dce76ed8ac66b32ef0aa", + "size": 97694, + "subdir": "linux-64", + "timestamp": 1676842861655, + "version": "5.2.1" + }, + "smart_open-5.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e3d0c925b4668b1d9d0ecb396e13da1", + "name": "smart_open", + "sha256": "00a571fe910ecff4b3f2ebf075c24c078cab839bd0cabe0b8ef0a8be6db11d8f", + "size": 76562, + "subdir": "linux-64", + "timestamp": 1651563646788, + "version": "5.2.1" + }, + "smart_open-5.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b8409b4c98d4ff64a8e043942ca404d", + "name": "smart_open", + "sha256": "b53e845346644be2442fed1a9cdcbf2c64286714928d2889fe95d14f8e8f8ecd", + "size": 76751, + "subdir": "linux-64", + "timestamp": 1651563673017, + "version": "5.2.1" + }, + "smart_open-5.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80fd1b0ca6dc5a560b439ab0ce78a3ac", + "name": "smart_open", + "sha256": "a012ab651b0ed00b1116dc89a06fbe56f1b580bc66d0aef03f22678632a68480", + "size": 76906, + "subdir": "linux-64", + "timestamp": 1651563617958, + "version": "5.2.1" + }, + "smartypants-2.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2a14fa762257e5f3bf7820b3ea91937a", + "name": "smartypants", + "sha256": "7af0d4c77bab54501a135f539e80f234103a1adf95e33bfd540028dc2aa73ae4", + "size": 19900, + "subdir": "linux-64", + "timestamp": 1651243004692, + "version": "2.0.1" + }, + "smartypants-2.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "67e1aaa40e0183d04ede416b77089d13", + "name": "smartypants", + "sha256": "901181cbcec6ed1a17eda5215ccfe7c5a61f2ea722c2214b753acfbca526d7a5", + "size": 19565, + "subdir": "linux-64", + "timestamp": 1676862236933, + "version": "2.0.1" + }, + "smartypants-2.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "215d38711c6b3e9f404ddf87c7b35cc7", + "name": "smartypants", + "sha256": "ef9300709b4a6e6fb3f1749cc422010f24862e05e0549b2a13116cbbcad98b0b", + "size": 19760, + "subdir": "linux-64", + "timestamp": 1651242984418, + "version": "2.0.1" + }, + "smartypants-2.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fe7f01dda1a29041ad3b80184f77e14c", + "name": "smartypants", + "sha256": "9e5cff301a068123793314d6aa7d195358d1de98333164846bfb871196c98bf0", + "size": 19825, + "subdir": "linux-64", + "timestamp": 1651242981997, + "version": "2.0.1" + }, + "smartypants-2.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bacc8ac54b799c019ebc0fefd13a6d02", + "name": "smartypants", + "sha256": "e4e049a4f44559ef8f1522a28cf66db22a450172c51a46b24428c1400408f1b2", + "size": 19806, + "subdir": "linux-64", + "timestamp": 1651225127299, + "version": "2.0.1" + }, + "smmap2-2.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "83a78b79dfa3a7821fe3435321831384", + "name": "smmap2", + "sha256": "eccd83c2d16825e46c4fa115a3d18015e99b8e2a619436da0bf27066ecc07e98", + "size": 34267, + "subdir": "linux-64", + "timestamp": 1522774771921, + "version": "2.0.3" + }, + "smmap2-2.0.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7730b12768203c04ff25c5ef221b5c13", + "name": "smmap2", + "sha256": "e45a69557d443a536307b00a7fcd809f56bbdcd8c79572b0bc16a38426a1d6fa", + "size": 35088, + "subdir": "linux-64", + "timestamp": 1522774836326, + "version": "2.0.3" + }, + "smmap2-2.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e86add101ccf4005285f1b10711076bd", + "name": "smmap2", + "sha256": "a0f2ca9dd9248b84d2d8f3d3cf8cc0bd8856ef83c8d9a0a04911d9c3e97dc26c", + "size": 34992, + "subdir": "linux-64", + "timestamp": 1522774811364, + "version": "2.0.3" + }, + "smmap2-2.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b2430bf9a0540f7af9d4cbf13c5b2e54", + "name": "smmap2", + "sha256": "ff9911f57e8499a61aef59a1c60b758526ee65ba19156608e886a27a8f692a86", + "size": 34877, + "subdir": "linux-64", + "timestamp": 1530890653505, + "version": "2.0.3" + }, + "smmap2-2.0.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c8871dd36d2612450a314091365e51ce", + "name": "smmap2", + "sha256": "0a2a8da1de10daecba9445f7a3cadc492dd40755fd18d57a26d2c0336447b617", + "size": 35732, + "subdir": "linux-64", + "timestamp": 1535498311332, + "version": "2.0.4" + }, + "smmap2-2.0.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "886c5289b8ce8752fb88da3eb4382df0", + "name": "smmap2", + "sha256": "0bdf4437d530061460b157fefe08a15be99f3c6d8175b3505c4b6adf4846f6a0", + "size": 36558, + "subdir": "linux-64", + "timestamp": 1535498390762, + "version": "2.0.4" + }, + "smmap2-2.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ae8c6203289526c2f08a05aad86b9e8d", + "name": "smmap2", + "sha256": "504cd54016c2648c857aa0b7056ba3e7b1336f309fd5ac09795e11ce00c6fc90", + "size": 36449, + "subdir": "linux-64", + "timestamp": 1535498274007, + "version": "2.0.4" + }, + "smmap2-2.0.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b42f8be57cbb22d1803818d08414a83f", + "name": "smmap2", + "sha256": "1e9f42feb774fde18a34642deabe58e633af4ae8a7fe32be72cff5c1a88c0354", + "size": 36433, + "subdir": "linux-64", + "timestamp": 1535498330349, + "version": "2.0.4" + }, + "smmap2-2.0.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0bb55a3c9fc6e60be483e1405e32d595", + "name": "smmap2", + "sha256": "54a81838586c84d41847bb3418b933f2560210bda0b97ecbc43531c148ff6a8c", + "size": 36581, + "subdir": "linux-64", + "timestamp": 1539644976482, + "version": "2.0.5" + }, + "smmap2-2.0.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c68a088c340ef3fd6e6a933db067f3a4", + "name": "smmap2", + "sha256": "637816db49c610ef9da12609d749f00bddf0e0d79bcb6d6b20261d500537f1ec", + "size": 37243, + "subdir": "linux-64", + "timestamp": 1539644996467, + "version": "2.0.5" + }, + "smmap2-2.0.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ee9e860bc3c087205276dbc8172a8baa", + "name": "smmap2", + "sha256": "c6469611a61ca2a3a3fb538fbf8f066c837ec27623f8754d680c6446c8a102eb", + "size": 37284, + "subdir": "linux-64", + "timestamp": 1539644988489, + "version": "2.0.5" + }, + "snakebite-2.11.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "protobuf >2.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ae1769a4bb4a98101f0b097b364059ea", + "name": "snakebite", + "sha256": "acb0c117c0996f8310c9131651f53518302939fe205de5ecf1392c5d0049da88", + "size": 133008, + "subdir": "linux-64", + "timestamp": 1522776065542, + "version": "2.11.0" + }, + "snakebite-py3-3.0.5-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "protobuf >2.4.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "55f9ead92ad90209502e5413fe266f29", + "name": "snakebite-py3", + "sha256": "6199d6bba39735dd69aec6a0962a74dd59feba03fb17c423b34ac7ab15fc155c", + "size": 143822, + "subdir": "linux-64", + "timestamp": 1659787093381, + "version": "3.0.5" + }, + "snakebite-py3-3.0.5-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "protobuf >2.4.1", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "081ff80a0a2aaf90c5ae6fbc25b2443e", + "name": "snakebite-py3", + "sha256": "700c7555a51773cfd7f1bed9ff7922cabeec924b03d514418e26bb8467ea9873", + "size": 200506, + "subdir": "linux-64", + "timestamp": 1676845832471, + "version": "3.0.5" + }, + "snakebite-py3-3.0.5-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "protobuf >2.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fd35d84aefb57279af2429befbb0ca76", + "name": "snakebite-py3", + "sha256": "28b0f31442631433b58b711444089f87aa1a986bebbd954cc6c9897618900861", + "size": 140311, + "subdir": "linux-64", + "timestamp": 1659787151786, + "version": "3.0.5" + }, + "snakebite-py3-3.0.5-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "protobuf >2.4.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cf8de37346854fdd270b444cbf38df91", + "name": "snakebite-py3", + "sha256": "1202e7d474aacd5f051b898a8b85b6ab5ff1573eb01ff85c3b52494dd9c71c73", + "size": 141045, + "subdir": "linux-64", + "timestamp": 1659787051861, + "version": "3.0.5" + }, + "snakebite-py3-3.0.5-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "protobuf >2.4.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "751af15a32eaf53cfa981c1681ea0cf1", + "name": "snakebite-py3", + "sha256": "31ada4025346b9382b30ffbe287d39931fed9f5d22688feb97873e580f1b93ca", + "size": 140839, + "subdir": "linux-64", + "timestamp": 1659787124007, + "version": "3.0.5" + }, + "snakeviz-0.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "05e853fa0d181f1e7541858b3caba492", + "name": "snakeviz", + "sha256": "73b3383b15fbbe8246b5ccd559e95192263465b1dabcb0ac6190808f757c4be4", + "size": 170722, + "subdir": "linux-64", + "timestamp": 1530961128249, + "version": "0.4.2" + }, + "snakeviz-0.4.2-py27hf4b41a6_0.tar.bz2": { + "build": "py27hf4b41a6_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "5ec6d62694bafb286b86281520e47653", + "name": "snakeviz", + "sha256": "ebc64e37caf4cb3787997568011de0fe16d9e4dbbe53c8341792a2f70ae31ab7", + "size": 171220, + "subdir": "linux-64", + "timestamp": 1509050080501, + "version": "0.4.2" + }, + "snakeviz-0.4.2-py35h5e3ed1c_0.tar.bz2": { + "build": "py35h5e3ed1c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "aae98a02c544afd52237c6ff6da17039", + "name": "snakeviz", + "sha256": "b859ec2784add50d1596b55646dbcefd6dae7afb37b6808277e650375e209203", + "size": 171110, + "subdir": "linux-64", + "timestamp": 1509050132838, + "version": "0.4.2" + }, + "snakeviz-0.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "53bf1f0754e90fa32e788f942e8f9bfa", + "name": "snakeviz", + "sha256": "7588829383fcc09df180598dfcc0c990603b94151eaf69e4bc1f97fd4a505717", + "size": 171005, + "subdir": "linux-64", + "timestamp": 1530961159882, + "version": "0.4.2" + }, + "snakeviz-0.4.2-py36h8fadade_0.tar.bz2": { + "build": "py36h8fadade_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "94634d0e5fca5f4aabad4631f6e4ad57", + "name": "snakeviz", + "sha256": "fdb51dda59d2a03ea167b740c8dd19f53c7e5745922c09ef648a3aa8b82dc97f", + "size": 171165, + "subdir": "linux-64", + "timestamp": 1509050130945, + "version": "0.4.2" + }, + "snakeviz-0.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "81c6f2e60012d0adbf770cf81b4802d4", + "name": "snakeviz", + "sha256": "99c1469c3724a2f8f2fa20ff5f5e61fcdcf74727fcdb36a5374c4716117f2537", + "size": 170958, + "subdir": "linux-64", + "timestamp": 1530961191637, + "version": "0.4.2" + }, + "snakeviz-1.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "78f2c67d79623b51081cfcfc8b3cb591", + "name": "snakeviz", + "sha256": "8b2e4fb3ca0d928bb3f3d8dc409e0942407ab557a5282d897b354a3bc2f39f65", + "size": 172811, + "subdir": "linux-64", + "timestamp": 1536109662221, + "version": "1.0.0" + }, + "snakeviz-1.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "5da9f39eedede6a2fdc7c5d7ee3c56e9", + "name": "snakeviz", + "sha256": "79539ff20c968bbd6f314cfcd5cba29e12ac39a147d2591ab5fcfc503554af8f", + "size": 173016, + "subdir": "linux-64", + "timestamp": 1536109721452, + "version": "1.0.0" + }, + "snakeviz-1.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "ef53c19fca26924b37c25969b2ebcb16", + "name": "snakeviz", + "sha256": "7b2e2113f47e55c188c318b103f2430e1e054ef27a132a1ed44f38133a7da4f6", + "size": 172986, + "subdir": "linux-64", + "timestamp": 1536109623410, + "version": "1.0.0" + }, + "snakeviz-1.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "2bb05731050566907f7ebee409460c8e", + "name": "snakeviz", + "sha256": "ce6d9cd511057790f37f7ac907d2750280ec9933a4c32318bc39265ca5e998c2", + "size": 173165, + "subdir": "linux-64", + "timestamp": 1536109735701, + "version": "1.0.0" + }, + "snakeviz-2.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "bd333119053ff07140931bfd176e8f19", + "name": "snakeviz", + "sha256": "c87798654afac4f3e7865a9a3a10908f5dd1cbe3b26b8d2ee388d7391e097eac", + "size": 325975, + "subdir": "linux-64", + "timestamp": 1564707340907, + "version": "2.0.1" + }, + "snakeviz-2.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "370e7c07ee05ff76157cdc77c74b5524", + "name": "snakeviz", + "sha256": "20cad74fcc7836ef4b13abf09ed4cf72c8c552dc0b12f684e87efe88aca66dad", + "size": 175893, + "subdir": "linux-64", + "timestamp": 1640810912686, + "version": "2.0.1" + }, + "snakeviz-2.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "1b66680a55a1ea28d3d7bfe95f7ad20f", + "name": "snakeviz", + "sha256": "5bff8acaaeb66924a288e5079bb2a670a20f7768be9b4dcc7979f487d8bd856b", + "size": 180952, + "subdir": "linux-64", + "timestamp": 1676907678308, + "version": "2.0.1" + }, + "snakeviz-2.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "f0e71bf64de39372bd3bbcccd563d15c", + "name": "snakeviz", + "sha256": "3cbe2f9362e1af287fda00c22ce1c169942abce85247acea86bd2c00b1cfa505", + "size": 323088, + "subdir": "linux-64", + "timestamp": 1564707373123, + "version": "2.0.1" + }, + "snakeviz-2.0.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "00e48e067e2f80b72237906ecee3fc8e", + "name": "snakeviz", + "sha256": "df52c5207c9c9c52d0248ba3b257f45091f950e0a8de015fd57cf0d8c26eef58", + "size": 447084, + "subdir": "linux-64", + "timestamp": 1632756936391, + "version": "2.0.1" + }, + "snakeviz-2.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "faa3bf507addbb49db669215ffff6075", + "name": "snakeviz", + "sha256": "977df7291943e5f859fad85f09df9a22074c9e14282079157332f8499614fea3", + "size": 326507, + "subdir": "linux-64", + "timestamp": 1564707332811, + "version": "2.0.1" + }, + "snakeviz-2.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "34862fc465467dc3abd78cf4f5be6f0c", + "name": "snakeviz", + "sha256": "ea575b3dbe7a375e37c14a41d4ba2120378c68df520ab73f7a5c326bbb379072", + "size": 448624, + "subdir": "linux-64", + "timestamp": 1632746603985, + "version": "2.0.1" + }, + "snakeviz-2.0.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "12edbc9d0afc1ccbd19fd4fa675da257", + "name": "snakeviz", + "sha256": "6cae6f011091affcff6f191ef04b61061f7765756b7c72451125a0c946c6d0e9", + "size": 175888, + "subdir": "linux-64", + "timestamp": 1573557179354, + "version": "2.0.1" + }, + "snakeviz-2.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "29955af76997e015df33e182fc96f5b7", + "name": "snakeviz", + "sha256": "6e23779b4646e8c552846220217ba8ee1a05dae267340ec0b39e03adaa7f6c09", + "size": 449116, + "subdir": "linux-64", + "timestamp": 1632756959537, + "version": "2.0.1" + }, + "snakeviz-2.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "b63b2751bacdcf29b7cf61b98595a40e", + "name": "snakeviz", + "sha256": "d6d4c82feee45d3be2fc17e94b008d5d4950dae1db5b2ff0ee9a66fb64a3444f", + "size": 449573, + "subdir": "linux-64", + "timestamp": 1632756962813, + "version": "2.0.1" + }, + "snappy-1.1.6-h4f0f562_2.tar.bz2": { + "build": "h4f0f562_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "119cdb8b083716fcf9083e83b6fd5225", + "name": "snappy", + "sha256": "4cf67cbd9241cbba7b2fd7de73f471f3321f4e27826b1f1524adda2d2b3cb436", + "size": 38340, + "subdir": "linux-64", + "timestamp": 1505740623562, + "version": "1.1.6" + }, + "snappy-1.1.7-h493ac5f_1.tar.bz2": { + "build": "h493ac5f_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "fb4a8562c907c33b475494d82d176ad6", + "name": "snappy", + "sha256": "20677674f39d35838793c64186aed6298c70865ddb0ff491c4beb32cd509fb89", + "size": 39036, + "subdir": "linux-64", + "timestamp": 1508782495126, + "version": "1.1.7" + }, + "snappy-1.1.7-h88f177e_2.tar.bz2": { + "build": "h88f177e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "48dd1685a73f5eb17eeae72665eddb8a", + "name": "snappy", + "sha256": "dccc9a537d588e5ea30c7c58d75399a8e2caa8147c2d857209183402bc466036", + "size": 39044, + "subdir": "linux-64", + "timestamp": 1510171715979, + "version": "1.1.7" + }, + "snappy-1.1.7-hbae5bb6_3.tar.bz2": { + "build": "hbae5bb6_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "16d8af00ef7fa8189d0da5483cd4d2f8", + "name": "snappy", + "sha256": "5f69eab08a111e124136e3fec1cf16559d6bbec3de2268b42c3bd7d12612b960", + "size": 39238, + "subdir": "linux-64", + "timestamp": 1511805960762, + "version": "1.1.7" + }, + "snappy-1.1.8-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c52dbed225efcb7598239f0a7f6f4438", + "name": "snappy", + "sha256": "ca423a10defeee03da729b5302e7dc7c467f11b819f14c8d8ca2a2d3f6361890", + "size": 44456, + "subdir": "linux-64", + "timestamp": 1592866364308, + "version": "1.1.8" + }, + "snappy-1.1.9-h295c915_0.tar.bz2": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-clause AND CC-BY-3.0 AND MIT AND CC-BY AND Public Domain", + "license_family": "BSD", + "md5": "71b25fd79c57bcf6bd2ba8ccf1e18506", + "name": "snappy", + "sha256": "0f5809564b323f020dec2633dc274bbc96dc13d54888bb115938d3d7f6a717bb", + "size": 891170, + "subdir": "linux-64", + "timestamp": 1649923859475, + "version": "1.1.9" + }, + "sniffio-1.1.0-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "contextvars >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "APACHE", + "license_family": "APACHE", + "md5": "325b61d4d99082549905ee7900ef7b66", + "name": "sniffio", + "sha256": "aab7ce1450fa9ccea0494a53f3d1a881466864bceeecf61a8f98941838ad87f6", + "size": 17386, + "subdir": "linux-64", + "timestamp": 1594058998790, + "version": "1.1.0" + }, + "sniffio-1.1.0-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "APACHE", + "license_family": "APACHE", + "md5": "1d9f97eb0b2b3e4f3fcd69132db4462e", + "name": "sniffio", + "sha256": "ea67f751477b75db448bc6c3f29de0f8539ba188a1467097ed78d9a828410ed6", + "size": 17372, + "subdir": "linux-64", + "timestamp": 1594058994037, + "version": "1.1.0" + }, + "sniffio-1.1.0-py38_2.tar.bz2": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "APACHE", + "license_family": "APACHE", + "md5": "8a14499f30974b360a7884d7c14084a1", + "name": "sniffio", + "sha256": "5bbdba999a054bc2534689e3a979866a41bb87a372d37c56cffbcabbad0cc996", + "size": 17390, + "subdir": "linux-64", + "timestamp": 1594058990221, + "version": "1.1.0" + }, + "sniffio-1.2.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c15dcab2d9945d0997d49db7bbb2b12f", + "name": "sniffio", + "sha256": "e07c6ad52415ceac1405a370e644e4a36a4f0b0d220e495057cd222c12f85c91", + "size": 15636, + "subdir": "linux-64", + "timestamp": 1640794815222, + "version": "1.2.0" + }, + "sniffio-1.2.0-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "55548e1d0a036c5c2bbb019db65cb06f", + "name": "sniffio", + "sha256": "69ff9d0fe4ab70c5a6e81361809a92e54588d1f7bca566b90826364ac803ddf6", + "size": 17162, + "subdir": "linux-64", + "timestamp": 1676823755808, + "version": "1.2.0" + }, + "sniffio-1.2.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "contextvars >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fed25fe7c9b02c652167d66150555197", + "name": "sniffio", + "sha256": "4e9547af7de4247be604309c3e3015aa51a2102f849671253a529b9bddbb3c68", + "size": 15667, + "subdir": "linux-64", + "timestamp": 1614030506826, + "version": "1.2.0" + }, + "sniffio-1.2.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a3054c47506585feff3d0db340cce4d0", + "name": "sniffio", + "sha256": "5f00cc6eee3a6de35dc1640079f2dec4e341dc1ac533037438fa8b0e0803e5be", + "size": 15660, + "subdir": "linux-64", + "timestamp": 1614030514952, + "version": "1.2.0" + }, + "sniffio-1.2.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "884ea8d949dedfb11505f8d0e27c022e", + "name": "sniffio", + "sha256": "52850a7d4a19c13be2b62962055e8a8104f5dc79926ca70a1d1a52529527d30f", + "size": 15671, + "subdir": "linux-64", + "timestamp": 1614030513783, + "version": "1.2.0" + }, + "sniffio-1.2.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e19ffbfb24b990275d24fcea2bd1699b", + "name": "sniffio", + "sha256": "58bea49efb19cf0af5399d369a9c9b4cd0fc1b3bb1c3542d09f313050823576f", + "size": 15702, + "subdir": "linux-64", + "timestamp": 1614030498860, + "version": "1.2.0" + }, + "snowballstemmer-1.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "95afa1f83867395e066b806246393c1c", + "name": "snowballstemmer", + "sha256": "6d244a1ba858ade9e3ca4bc368db1eb7d1cce9d017f67894d0301c624bba65dc", + "size": 81229, + "subdir": "linux-64", + "timestamp": 1530695042365, + "version": "1.2.1" + }, + "snowballstemmer-1.2.1-py27h44e2768_0.tar.bz2": { + "build": "py27h44e2768_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "7431e9e0b8e2a6949235f2a8a576b1fa", + "name": "snowballstemmer", + "sha256": "8fc2c650c4fad9411cbc844f80c25ce3b3507712fd0f91bc578abb65e7ea5204", + "size": 80945, + "subdir": "linux-64", + "timestamp": 1505746914693, + "version": "1.2.1" + }, + "snowballstemmer-1.2.1-py35h5435977_0.tar.bz2": { + "build": "py35h5435977_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-2-Clause", + "md5": "70ac7d45dc823a76058bdf630bdbe1de", + "name": "snowballstemmer", + "sha256": "7a5260c42491c34b58314afd9a497e64ef1dc4b05c3453131812e7733168143a", + "size": 86168, + "subdir": "linux-64", + "timestamp": 1505746928425, + "version": "1.2.1" + }, + "snowballstemmer-1.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "b6a3a78fe0452ea04cbedf5441d8d6e8", + "name": "snowballstemmer", + "sha256": "bd96c70979a02757145f60be2d1ecc687e95546ef824f9751aa3ca27fb8a012a", + "size": 87063, + "subdir": "linux-64", + "timestamp": 1530695002582, + "version": "1.2.1" + }, + "snowballstemmer-1.2.1-py36h6febd40_0.tar.bz2": { + "build": "py36h6febd40_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "3317bcd04ba68538065c0d193c674802", + "name": "snowballstemmer", + "sha256": "0fd446245c7e67d3b5851b254a524f3b22492651382328711b17d1ce30020ca2", + "size": 86832, + "subdir": "linux-64", + "timestamp": 1505746942144, + "version": "1.2.1" + }, + "snowballstemmer-1.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "29ab412d0a676522ef1ec8df22ba5f82", + "name": "snowballstemmer", + "sha256": "90c7c3834d3fb73140e8fa6b03508e0614f7a264e7c4e5da1e9df5c5e3e8aecb", + "size": 83719, + "subdir": "linux-64", + "timestamp": 1530695023049, + "version": "1.2.1" + }, + "snowflake-connector-python-2.6.2-py36h51133e4_0.tar.bz2": { + "build": "py36h51133e4_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "azure-common <2", + "azure-storage-blob >=12.0.0,<13.0.0", + "boto3 >=1.4.4,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=2.5.0,<4.0.0", + "dataclasses <1", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<21.0.0", + "python >=3.6,<3.7.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "63cee3ceee6b22b204180540490450d6", + "name": "snowflake-connector-python", + "sha256": "64d0e23f17121bfe7aaa3be0e65fdb7fc6c02b53f607dd8c8f2809fada8fae23", + "size": 736575, + "subdir": "linux-64", + "timestamp": 1633352413795, + "version": "2.6.2" + }, + "snowflake-connector-python-2.6.2-py37h51133e4_0.tar.bz2": { + "build": "py37h51133e4_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "azure-common <2", + "azure-storage-blob >=12.0.0,<13.0.0", + "boto3 >=1.4.4,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=2.5.0,<4.0.0", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<21.0.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1d92ed7eccab61fbbc233ff96e58fa2b", + "name": "snowflake-connector-python", + "sha256": "a49e873cd1127c817a95d04c50cfc329f1f69646b8eb53aa204a39360e6530ad", + "size": 732458, + "subdir": "linux-64", + "timestamp": 1633363051996, + "version": "2.6.2" + }, + "snowflake-connector-python-2.6.2-py37h51133e4_1.tar.bz2": { + "build": "py37h51133e4_1", + "build_number": 1, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "azure-common <2", + "azure-storage-blob >=12.0.0,<13.0.0", + "boto3 >=1.4.4,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=2.5.0,<4.0.0", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<21.0.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "21455fd7100a4d4e42cc576d4cec3711", + "name": "snowflake-connector-python", + "sha256": "db32d1caf5c22cb53e4e2848fb8f718485f44746f8fcc87ed5fc9a6ce03cc5bd", + "size": 716532, + "subdir": "linux-64", + "timestamp": 1653636153057, + "version": "2.6.2" + }, + "snowflake-connector-python-2.6.2-py38h51133e4_0.tar.bz2": { + "build": "py38h51133e4_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "azure-common <2", + "azure-storage-blob >=12.0.0,<13.0.0", + "boto3 >=1.4.4,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=2.5.0,<4.0.0", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<21.0.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d84459ae7a9b228b81d70b8ded6e00fb", + "name": "snowflake-connector-python", + "sha256": "d7cf8564fe0a9bce0e7292f35c44f5750143021039db1cd3da6595629458f217", + "size": 738908, + "subdir": "linux-64", + "timestamp": 1633362976858, + "version": "2.6.2" + }, + "snowflake-connector-python-2.6.2-py38h51133e4_1.tar.bz2": { + "build": "py38h51133e4_1", + "build_number": 1, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "azure-common <2", + "azure-storage-blob >=12.0.0,<13.0.0", + "boto3 >=1.4.4,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=2.5.0,<4.0.0", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<21.0.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "352cddada266442eea3155149ab13353", + "name": "snowflake-connector-python", + "sha256": "5839a20fea26c560a1ea01d9026f96e3686774433053c00e43addeef82a7ebe0", + "size": 722103, + "subdir": "linux-64", + "timestamp": 1653636382224, + "version": "2.6.2" + }, + "snowflake-connector-python-2.6.2-py39h51133e4_0.tar.bz2": { + "build": "py39h51133e4_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "azure-common <2", + "azure-storage-blob >=12.0.0,<13.0.0", + "boto3 >=1.4.4,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=2.5.0,<4.0.0", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<21.0.0", + "python >=3.9,<3.10.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1a93317b5f9b5cec150b7d32728622c0", + "name": "snowflake-connector-python", + "sha256": "83e9d6fbd5ab80512be11e85b437a8ab3cd5273625a93937de00458bded40137", + "size": 744937, + "subdir": "linux-64", + "timestamp": 1633363031184, + "version": "2.6.2" + }, + "snowflake-connector-python-2.6.2-py39h51133e4_1.tar.bz2": { + "build": "py39h51133e4_1", + "build_number": 1, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "azure-common <2", + "azure-storage-blob >=12.0.0,<13.0.0", + "boto3 >=1.4.4,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=2.5.0,<4.0.0", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<21.0.0", + "python >=3.9,<3.10.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4e11d09f976563ed56389913903c4ff9", + "name": "snowflake-connector-python", + "sha256": "7cac4c54846b3b32d866be6bb15c4d5d74bca22f50b26600020b8eebf75751ba", + "size": 718662, + "subdir": "linux-64", + "timestamp": 1653636269273, + "version": "2.6.2" + }, + "snowflake-connector-python-2.7.11-py310h1128e8f_0.tar.bz2": { + "build": "py310h1128e8f_0", + "build_number": 0, + "constrains": [ + "keyring !=16.1.0,<24.0.0", + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=8.0.0,<9.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer >=2,<3", + "cryptography >=3.1.0,<37.0.0", + "idna >=2.5,<4", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "oscrypto <2.0.0", + "pyarrow", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.10,<3.11.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0", + "typing-extensions >=4.3.0,<5", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0a00ed10badb492a107feae78f7ccc5c", + "name": "snowflake-connector-python", + "sha256": "bce86186aee38f6b7d2935e1a16c8b4041c93248d75f8881947267c5cf69f153", + "size": 3390869, + "subdir": "linux-64", + "timestamp": 1659699368534, + "version": "2.7.11" + }, + "snowflake-connector-python-2.7.11-py37h417a72b_0.tar.bz2": { + "build": "py37h417a72b_0", + "build_number": 0, + "constrains": [ + "keyring !=16.1.0,<24.0.0", + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=8.0.0,<9.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer >=2,<3", + "cryptography >=3.1.0,<37.0.0", + "idna >=2.5,<4", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "oscrypto <2.0.0", + "pyarrow", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0", + "typing-extensions >=4.3.0,<5", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c4d9e813e75499577e31a37ea63e6480", + "name": "snowflake-connector-python", + "sha256": "d6be505c572912830df70e47735587f86ec884c3e46b741b11eb3214bbb2e963", + "size": 732712, + "subdir": "linux-64", + "timestamp": 1659699186894, + "version": "2.7.11" + }, + "snowflake-connector-python-2.7.11-py38h417a72b_0.tar.bz2": { + "build": "py38h417a72b_0", + "build_number": 0, + "constrains": [ + "keyring !=16.1.0,<24.0.0", + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=8.0.0,<9.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer >=2,<3", + "cryptography >=3.1.0,<37.0.0", + "idna >=2.5,<4", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "oscrypto <2.0.0", + "pyarrow", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0", + "typing-extensions >=4.3.0,<5", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "63ab80ea7c62af8cdd9ea6cc2cd6a888", + "name": "snowflake-connector-python", + "sha256": "c5640221e19a8140f7f05262b2e76a7cd3b5ccad3157a7b24c022930be88e2b4", + "size": 735635, + "subdir": "linux-64", + "timestamp": 1659699268980, + "version": "2.7.11" + }, + "snowflake-connector-python-2.7.11-py39h417a72b_0.tar.bz2": { + "build": "py39h417a72b_0", + "build_number": 0, + "constrains": [ + "keyring !=16.1.0,<24.0.0", + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=8.0.0,<9.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer >=2,<3", + "cryptography >=3.1.0,<37.0.0", + "idna >=2.5,<4", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "oscrypto <2.0.0", + "pyarrow", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.9,<3.10.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0", + "typing-extensions >=4.3.0,<5", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9dce17762918b2d5a2beabe29d630ee0", + "name": "snowflake-connector-python", + "sha256": "e7d5ac677d67fad315be69bb3f26d6caa8b579012f233e61356a20766942c4df", + "size": 737537, + "subdir": "linux-64", + "timestamp": 1659699453921, + "version": "2.7.11" + }, + "snowflake-connector-python-2.7.12-py310h1128e8f_0.tar.bz2": { + "build": "py310h1128e8f_0", + "build_number": 0, + "constrains": [ + "keyring !=16.1.0,<24.0.0", + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=8.0.0,<9.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer >=2,<3", + "cryptography >=3.1.0,<37.0.0", + "filelock >=3.5,<4", + "idna >=2.5,<4", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "oscrypto <2.0.0", + "pyarrow", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.10,<3.11.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0", + "typing-extensions >=4.3.0,<5", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c08d1f89296864208f23a84d67096fec", + "name": "snowflake-connector-python", + "sha256": "d5e3b33ea45f4dd16c0522a2173968c98ed14be511b3b91bc8f3e557d0df2955", + "size": 3412319, + "subdir": "linux-64", + "timestamp": 1662316833462, + "version": "2.7.12" + }, + "snowflake-connector-python-2.7.12-py37h417a72b_0.tar.bz2": { + "build": "py37h417a72b_0", + "build_number": 0, + "constrains": [ + "keyring !=16.1.0,<24.0.0", + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=8.0.0,<9.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer >=2,<3", + "cryptography >=3.1.0,<37.0.0", + "filelock >=3.5,<4", + "idna >=2.5,<4", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "oscrypto <2.0.0", + "pyarrow", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0", + "typing-extensions >=4.3.0,<5", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2ff60f8eb2131295b9a57e91612889a5", + "name": "snowflake-connector-python", + "sha256": "6371f38d43a1bc1f965f12ca83e65654c25f3833fee125345d58073cc342e528", + "size": 753963, + "subdir": "linux-64", + "timestamp": 1662316953786, + "version": "2.7.12" + }, + "snowflake-connector-python-2.7.12-py38h417a72b_0.tar.bz2": { + "build": "py38h417a72b_0", + "build_number": 0, + "constrains": [ + "keyring !=16.1.0,<24.0.0", + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=8.0.0,<9.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer >=2,<3", + "cryptography >=3.1.0,<37.0.0", + "filelock >=3.5,<4", + "idna >=2.5,<4", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "oscrypto <2.0.0", + "pyarrow", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0", + "typing-extensions >=4.3.0,<5", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "60ae33c2a81ab82f3e0322d999bb0104", + "name": "snowflake-connector-python", + "sha256": "14e60d9e53d7600f60ea7c8916be82c5c6ccb92863f6728b7bf0f93669b7e483", + "size": 758739, + "subdir": "linux-64", + "timestamp": 1662317070343, + "version": "2.7.12" + }, + "snowflake-connector-python-2.7.12-py39h417a72b_0.tar.bz2": { + "build": "py39h417a72b_0", + "build_number": 0, + "constrains": [ + "keyring !=16.1.0,<24.0.0", + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=8.0.0,<9.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer >=2,<3", + "cryptography >=3.1.0,<37.0.0", + "filelock >=3.5,<4", + "idna >=2.5,<4", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "oscrypto <2.0.0", + "pyarrow", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.9,<3.10.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0", + "typing-extensions >=4.3.0,<5", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "137af4feee26ab4b1c5c72187f78d589", + "name": "snowflake-connector-python", + "sha256": "5bed9474860146cb33b71a6816a0907eb7a1e789a8e4f156e4ab5e39302a0da5", + "size": 756653, + "subdir": "linux-64", + "timestamp": 1662316687300, + "version": "2.7.12" + }, + "snowflake-connector-python-2.7.8-py37h51133e4_0.tar.bz2": { + "build": "py37h51133e4_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=3.1.0,<37.0.0", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2ad3aa78e89c5c63783e6c88d8f9748c", + "name": "snowflake-connector-python", + "sha256": "c9030b1f90f7e187883f227ec08973f62021ff558fad46ee17527679b50af6ad", + "size": 711067, + "subdir": "linux-64", + "timestamp": 1653663697152, + "version": "2.7.8" + }, + "snowflake-connector-python-2.7.8-py38h51133e4_0.tar.bz2": { + "build": "py38h51133e4_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=3.1.0,<37.0.0", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9f54096206f6d133004d413557906743", + "name": "snowflake-connector-python", + "sha256": "dc7006a0d2a1ad69024e17178bfb8c22fa15ffa63828c6d87311bd6f6e602ea9", + "size": 708048, + "subdir": "linux-64", + "timestamp": 1653663807909, + "version": "2.7.8" + }, + "snowflake-connector-python-2.7.8-py39h51133e4_0.tar.bz2": { + "build": "py39h51133e4_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=3.1.0,<37.0.0", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.9,<3.10.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "50acab5912940471666fd6781bfaf6e2", + "name": "snowflake-connector-python", + "sha256": "6b2b98f4d2a5d3b548b2e985be55b48fdcf53d0bcf4250dfef7cba9d99a6307b", + "size": 715632, + "subdir": "linux-64", + "timestamp": 1653663918064, + "version": "2.7.8" + }, + "snowflake-snowpark-python-0.10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python >=2.7.12", + "typing-extensions >=4.1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bf2f3a66792c49c3a5f428179450f8da", + "name": "snowflake-snowpark-python", + "sha256": "fea5a6f1fc76a83c425228c2d6276198c3aaceedad21b8a14f6e4b92b18c6938", + "size": 359593, + "subdir": "linux-64", + "timestamp": 1663585453092, + "version": "0.10.0" + }, + "snowflake-snowpark-python-0.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python >=2.7.12", + "typing-extensions >=4.1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "87fbc71358a462f0628c53c2b0641296", + "name": "snowflake-snowpark-python", + "sha256": "844f9b16d3e8e3f37b9dcf16e5dfe05f586761c00348fcc2c48bac96dd8a6976", + "size": 384132, + "subdir": "linux-64", + "timestamp": 1664478363951, + "version": "0.11.0" + }, + "snowflake-snowpark-python-0.12.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python >=2.7.12", + "typing-extensions >=4.1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "034cea769b62729b89f65c02692864fa", + "name": "snowflake-snowpark-python", + "sha256": "0e70441b44481210a3c5e167a570b2ffaad51f523f44f03fff9280f1f3ebe5a4", + "size": 392349, + "subdir": "linux-64", + "timestamp": 1666196826087, + "version": "0.12.0" + }, + "snowflake-snowpark-python-0.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python", + "typing-extensions >=4.1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d17410a19372cccd9201d32819b3b7ca", + "name": "snowflake-snowpark-python", + "sha256": "01a7000f0134ac75d1ada23c81bf2e2b84f43252977c0108e35ec5019f632a1d", + "size": 304562, + "subdir": "linux-64", + "timestamp": 1654500874046, + "version": "0.6.0" + }, + "snowflake-snowpark-python-0.7.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python", + "typing-extensions >=4.1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b6793a37868fd6a28839c55b66b917e7", + "name": "snowflake-snowpark-python", + "sha256": "a120f9b484f6ddbebed315bd6ee8c98c246fdf039814c57f1cd0497ff47227f0", + "size": 323319, + "subdir": "linux-64", + "timestamp": 1653639955548, + "version": "0.7.0" + }, + "snowflake-snowpark-python-0.8.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python >=2.7.4", + "typing-extensions >=4.1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e7b75cfbe2edf55c47c683e40e531e11", + "name": "snowflake-snowpark-python", + "sha256": "c1d877be3a4e4e756f54f08bf8df26b318a33cab6f3cdf342a5aeba878035fc4", + "size": 331860, + "subdir": "linux-64", + "timestamp": 1659013123391, + "version": "0.8.0" + }, + "snowflake-snowpark-python-0.9.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python >=2.7.11", + "typing-extensions >=4.1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f3ec58b1cc6cfe1d9e210f9e09181404", + "name": "snowflake-snowpark-python", + "sha256": "b766e41ca5e309c835e006653910bbd142fab26885e23803ee647a69f22f8a2d", + "size": 347646, + "subdir": "linux-64", + "timestamp": 1662314403374, + "version": "0.9.0" + }, + "snowflake-snowpark-python-1.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python >=2.7.12,<3.0.0a0", + "typing-extensions >=4.1.0,<5.0.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "573848f8988c8446249dbc377532d0a4", + "name": "snowflake-snowpark-python", + "sha256": "14b1e3e201ca599f3345c1e1e389b8dcd57908773a0f15aa76d52d0f66955be7", + "size": 398793, + "subdir": "linux-64", + "timestamp": 1667400753220, + "version": "1.0.0" + }, + "snowflake-snowpark-python-1.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python >=2.7.12,<4.0.0a0", + "typing-extensions >=4.1.0,<5.0.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "420606b267157ebc4c1b0b369bd0fe65", + "name": "snowflake-snowpark-python", + "sha256": "f133e0dd769171cea1ec9fcc9683b3f20c268cd9217cacabc435bbe3b8edc544", + "size": 403632, + "subdir": "linux-64", + "timestamp": 1674852942768, + "version": "1.1.0" + }, + "snowflake-snowpark-python-1.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python >=2.7.12,<4.0.0a0", + "typing-extensions >=4.1.0,<5.0.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9aabf14e839cb13b008b2033e8602729", + "name": "snowflake-snowpark-python", + "sha256": "01adfdf61b5bf58241611cb034f70120be6bd6f58f71f8f3e545902f24ec0b9a", + "size": 404144, + "subdir": "linux-64", + "timestamp": 1677874608165, + "version": "1.2.0" + }, + "snowflake-snowpark-python-1.3.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python >=2.7.12,<4.0.0a0", + "typing-extensions >=4.1.0,<5.0.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2b6664032e9debd5b3a68ecabf2d01ae", + "name": "snowflake-snowpark-python", + "sha256": "4b2808d16d9700b7c2df5f19d553a3a52709d52b9047e73934ed445afd935e06", + "size": 435379, + "subdir": "linux-64", + "timestamp": 1680276482053, + "version": "1.3.0" + }, + "snuggs-1.4.1-py27h9686676_0.tar.bz2": { + "build": "py27h9686676_0", + "build_number": 0, + "depends": [ + "click", + "numpy", + "pyparsing", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "cca78b744bafa73a9d266c862e788f48", + "name": "snuggs", + "sha256": "54839a662e15efb0e946b27597ddb9aea96761dac03fbd60cfbfb67fe54346b7", + "size": 10244, + "subdir": "linux-64", + "timestamp": 1506702432874, + "version": "1.4.1" + }, + "snuggs-1.4.1-py35h9ebd86a_0.tar.bz2": { + "build": "py35h9ebd86a_0", + "build_number": 0, + "depends": [ + "click", + "numpy", + "pyparsing", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "a5658dc6480cb2a92b4ea93274e8ea5c", + "name": "snuggs", + "sha256": "86b2692a55403515c7d4182a15ddbb4c5a8cd4ccae887c0fc171adad0715a43a", + "size": 10510, + "subdir": "linux-64", + "timestamp": 1506702447402, + "version": "1.4.1" + }, + "snuggs-1.4.1-py36h2e8bf8d_0.tar.bz2": { + "build": "py36h2e8bf8d_0", + "build_number": 0, + "depends": [ + "click", + "numpy", + "pyparsing", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "06ed7108bee8e72476ca8884257b01bd", + "name": "snuggs", + "sha256": "d0f5d7c44ba8c8e644fa4769e5425416ffbbef4b5a5966baf485b0e1f6fe14ad", + "size": 10412, + "subdir": "linux-64", + "timestamp": 1506702491027, + "version": "1.4.1" + }, + "snuggs-1.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click", + "numpy", + "pyparsing", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d7080c90c2a63f973d5a982ef73b0aea", + "name": "snuggs", + "sha256": "80266605cba785a1f9b5c20cad44703f97675ef48ecc47cffc4f57c0bc18db3c", + "size": 10145, + "subdir": "linux-64", + "timestamp": 1529417072740, + "version": "1.4.2" + }, + "snuggs-1.4.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click", + "numpy", + "pyparsing", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "cd4b270e3b03b2dd94cced42c75e491b", + "name": "snuggs", + "sha256": "0139dfff4f06f73341efefd8d3065deaad881aa61890423cd972174f8727d815", + "size": 10387, + "subdir": "linux-64", + "timestamp": 1529417091224, + "version": "1.4.2" + }, + "snuggs-1.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click", + "numpy", + "pyparsing", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "abd69cd7c02fb82704bd96a6f2dafeeb", + "name": "snuggs", + "sha256": "979401146f6f11899bc294fd2db1f2a0e37ac99d3f2354d5d6ce6037c8f6c12f", + "size": 10306, + "subdir": "linux-64", + "timestamp": 1529417042679, + "version": "1.4.2" + }, + "snuggs-1.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click", + "numpy", + "pyparsing", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "baa0c3ee51fb8dfd69e5b500dbcc2f6c", + "name": "snuggs", + "sha256": "f4bfa3a25d32c9fb6c7e1ce6c8d1237927a66a3ea6f4a7218abec85ef7ba88db", + "size": 10316, + "subdir": "linux-64", + "timestamp": 1530872277449, + "version": "1.4.2" + }, + "soappy-0.12.22-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "defusedxml", + "python >=2.7,<2.8.0a0", + "wstools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b0410118d10746a1faa1d3b1ceace003", + "name": "soappy", + "sha256": "259897ccd8904816b553d6511d1345ae7822279cda8253f684878af4eb488ff2", + "size": 90024, + "subdir": "linux-64", + "timestamp": 1530919312849, + "version": "0.12.22" + }, + "sockjs-tornado-1.0.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "tornado >=2.1.1" + ], + "license": "MIT", + "md5": "d2f0c314a8ebdabae54b614de7b7d094", + "name": "sockjs-tornado", + "sha256": "cd021f944dbea3f06cda613287e8c28d568f42ae37d5ab6d3b01535cd6797d03", + "size": 39958, + "subdir": "linux-64", + "timestamp": 1537832021447, + "version": "1.0.5" + }, + "sockjs-tornado-1.0.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "tornado >=2.1.1" + ], + "license": "MIT", + "md5": "de8c8f3abf31fd31b2643bed6487cef4", + "name": "sockjs-tornado", + "sha256": "598fc114027800dd5126477730b81399491b4d04678783538af6d3dbb9a7cd5a", + "size": 40968, + "subdir": "linux-64", + "timestamp": 1537832107079, + "version": "1.0.5" + }, + "sockjs-tornado-1.0.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "tornado >=2.1.1" + ], + "license": "MIT", + "md5": "e4059eabd7cd9e2348618e1c38ee2722", + "name": "sockjs-tornado", + "sha256": "35a30d2aa5006c600b7659d1519f9aa1e6e0c50a4309eaa8be97022ba89d7341", + "size": 40867, + "subdir": "linux-64", + "timestamp": 1537832095277, + "version": "1.0.5" + }, + "sockjs-tornado-1.0.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "tornado >=2.1.1" + ], + "license": "MIT", + "md5": "9882afbf90e18ddb81e8ed75a479493d", + "name": "sockjs-tornado", + "sha256": "727e2fe17304e84b0a13c80b739a71618de550263b00a5a5903369e41b6a9d9d", + "size": 40941, + "subdir": "linux-64", + "timestamp": 1537831986525, + "version": "1.0.5" + }, + "sockjs-tornado-1.0.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "tornado >=2.1.1" + ], + "license": "MIT", + "md5": "eec86bbccfa9d14358703216bc8ee67f", + "name": "sockjs-tornado", + "sha256": "63cf04a1a4eb889ad44d21aec073565c590431b15f3d42b6e9da547c47d24672", + "size": 40335, + "subdir": "linux-64", + "timestamp": 1541050647794, + "version": "1.0.6" + }, + "sockjs-tornado-1.0.6-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "tornado >=2.1.1" + ], + "license": "MIT", + "md5": "967ca7894d8857841b3dad28b929a455", + "name": "sockjs-tornado", + "sha256": "bfd534805a0814eaddc70b1f173fcab9052e2d45681f017cc6bdaa4f3e0f7c97", + "size": 42369, + "subdir": "linux-64", + "timestamp": 1640810931370, + "version": "1.0.6" + }, + "sockjs-tornado-1.0.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "tornado >=2.1.1" + ], + "license": "MIT", + "md5": "ae8b4c257dcde25f76000d23b977aa64", + "name": "sockjs-tornado", + "sha256": "0ac9aaa2eb74074bce79706f40cf46cee49c58d5bea8bc2ae04056a8d25b4980", + "size": 41258, + "subdir": "linux-64", + "timestamp": 1541050676725, + "version": "1.0.6" + }, + "sockjs-tornado-1.0.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "tornado >=2.1.1" + ], + "license": "MIT", + "md5": "5cd6f2bc7c79d057e836c1387c76d669", + "name": "sockjs-tornado", + "sha256": "9d5e6ec6779ba344ff8ed449f1c49943ddb839fdf95b4fd06945f87050d77bf9", + "size": 41498, + "subdir": "linux-64", + "timestamp": 1541050625264, + "version": "1.0.6" + }, + "sockjs-tornado-1.0.6-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "tornado >=2.1.1" + ], + "license": "MIT", + "md5": "327449584b4b8638cf3ef3bbcd487b2c", + "name": "sockjs-tornado", + "sha256": "2a9d939017cd3acd01d59a68bd72ba9efb7fe23b5111f1b9497db443008c51c4", + "size": 41888, + "subdir": "linux-64", + "timestamp": 1573557195925, + "version": "1.0.6" + }, + "sortedcollections-0.5.3-py27h135218e_0.tar.bz2": { + "build": "py27h135218e_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "sortedcontainers" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2005a29d78eb57962fb19e7065b2218c", + "name": "sortedcollections", + "sha256": "acc5d1c1d0db0c9f2234f98e1be9e8bdafea24b93f43d4f6320e74cedbb8c1d5", + "size": 14021, + "subdir": "linux-64", + "timestamp": 1505755963383, + "version": "0.5.3" + }, + "sortedcollections-0.5.3-py35hb2f60ff_0.tar.bz2": { + "build": "py35hb2f60ff_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "sortedcontainers" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "df886c18a5ff2c3e97e68c64b122099c", + "name": "sortedcollections", + "sha256": "5fba4615a2b425484d94aee2613fcec394bf49e8cd4cf6fdad470ee88356f26e", + "size": 14601, + "subdir": "linux-64", + "timestamp": 1505755976982, + "version": "0.5.3" + }, + "sortedcollections-0.5.3-py36h3c761f9_0.tar.bz2": { + "build": "py36h3c761f9_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "sortedcontainers" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d40c6d63f06f90fa8844945602c7e67d", + "name": "sortedcollections", + "sha256": "15ea616eff61cb13c0f5eb1a5f84bf9e2b7597e48dbd01ba26380116361ad6d9", + "size": 14632, + "subdir": "linux-64", + "timestamp": 1505755990462, + "version": "0.5.3" + }, + "sortedcollections-0.6.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "sortedcontainers" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "65d418f2122bc5003f3309d747750cca", + "name": "sortedcollections", + "sha256": "c851b5f217b3c977ea9f60fa186c7520f3d884e63f508e32f24497da57de7f53", + "size": 14292, + "subdir": "linux-64", + "timestamp": 1521483866268, + "version": "0.6.1" + }, + "sortedcollections-0.6.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "sortedcontainers" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bf427f5b2e6648fae394b478d8bb10a0", + "name": "sortedcollections", + "sha256": "00358e6c15c5974ff0058d8fedcee61043ca9098e9ab1999a8a0abac863667cc", + "size": 14809, + "subdir": "linux-64", + "timestamp": 1521483817774, + "version": "0.6.1" + }, + "sortedcollections-0.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "sortedcontainers" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4176809d2b5227a3133950234a6ffd23", + "name": "sortedcollections", + "sha256": "780e2b0389dde3f1072855f5c85141ce4e7f676caf0c17f7c2aa0cb8e7fcee4d", + "size": 14841, + "subdir": "linux-64", + "timestamp": 1521483866978, + "version": "0.6.1" + }, + "sortedcollections-1.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "sortedcontainers >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5e2937f91351ed8aa2fd1ce4c8e11741", + "name": "sortedcollections", + "sha256": "fc43b535a404699f236aa4b3f54ba0e17435a4bbddeeb53cb5690467f737bb6e", + "size": 14570, + "subdir": "linux-64", + "timestamp": 1527851464280, + "version": "1.0.1" + }, + "sortedcollections-1.0.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "sortedcontainers >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "06cf0fbf64f524ab05b96a8cc6e86727", + "name": "sortedcollections", + "sha256": "160cc8a7151bb61183a0bf258989139eac2fd061ac4e6a58491fc3d6fa31fb6a", + "size": 15143, + "subdir": "linux-64", + "timestamp": 1527851588104, + "version": "1.0.1" + }, + "sortedcollections-1.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "sortedcontainers >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2c2f91e08563169b0525f98e75a6487b", + "name": "sortedcollections", + "sha256": "c53e69c0c578a194cebe228eb464d2106afa59758bdd5db564d7c6292e967a58", + "size": 15124, + "subdir": "linux-64", + "timestamp": 1527851596197, + "version": "1.0.1" + }, + "sortedcollections-1.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "sortedcontainers >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fc88c2e1b32b4cf12b411a7cbf27851f", + "name": "sortedcollections", + "sha256": "4a142601133ad3b1af4949b0bd4b4426a4af51b6f9b6966efa079df82479850d", + "size": 15207, + "subdir": "linux-64", + "timestamp": 1530961224113, + "version": "1.0.1" + }, + "sortedcollections-1.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "sortedcontainers >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d724c6a25f2111b9f8008be3f9d50f09", + "name": "sortedcollections", + "sha256": "d32029c05190b8c4c029e745cb0e0bcc04e18986a37f650f679ab4a1a1905f8e", + "size": 17711, + "subdir": "linux-64", + "timestamp": 1547909196220, + "version": "1.1.2" + }, + "sortedcollections-1.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "sortedcontainers >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0e6b8c78765a47b3016158ebb3c47adc", + "name": "sortedcollections", + "sha256": "755ee314465f6283990cd3347797bfcd20fc30d92373f3a50855b0633369eec2", + "size": 18314, + "subdir": "linux-64", + "timestamp": 1547909301258, + "version": "1.1.2" + }, + "sortedcollections-1.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "sortedcontainers >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6cee9d3838f1e98c1273119cb411c1dc", + "name": "sortedcollections", + "sha256": "8a960d4c4a51bcd90e72f032a4137c447bf8afd523cc8bb1292c8b5dc565302e", + "size": 18357, + "subdir": "linux-64", + "timestamp": 1547909326676, + "version": "1.1.2" + }, + "sortedcontainers-1.5.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "58d87325798eca6c67675f8c7639fb14", + "name": "sortedcontainers", + "sha256": "c98b6e976ee11c54d94781a0cf1c15e5b4c5ac448e40e727d974a03231f28ab6", + "size": 46186, + "subdir": "linux-64", + "timestamp": 1524496433055, + "version": "1.5.10" + }, + "sortedcontainers-1.5.10-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "cac879689852ec577967e8b1c730574b", + "name": "sortedcontainers", + "sha256": "b3573dc228b6d85df6c36cedd658f11da4910614354a424faf2aca97628133ca", + "size": 47224, + "subdir": "linux-64", + "timestamp": 1524496432554, + "version": "1.5.10" + }, + "sortedcontainers-1.5.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "d2587ce81c715b8015ca962325a72675", + "name": "sortedcontainers", + "sha256": "4fef9ed300392b80d4c080c99ad3d11ff8aa50c6c333666ad823780797bbc37d", + "size": 47064, + "subdir": "linux-64", + "timestamp": 1524496442850, + "version": "1.5.10" + }, + "sortedcontainers-1.5.7-py27he59936f_0.tar.bz2": { + "build": "py27he59936f_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "34a48933e7d6b7e6e9b6192d270f5fbe", + "name": "sortedcontainers", + "sha256": "e0a378a186d0e977147e8d1c9e790229d78a3e14e84e8a957cd67889b718f68d", + "size": 45665, + "subdir": "linux-64", + "timestamp": 1505863970372, + "version": "1.5.7" + }, + "sortedcontainers-1.5.7-py35h683703c_0.tar.bz2": { + "build": "py35h683703c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "b171531b0a75cd619c6ea01d99c1e3d5", + "name": "sortedcontainers", + "sha256": "05f30315420ac3e7eba572a5e331db919130579207af6f5a2f895ef7e4399ef1", + "size": 46792, + "subdir": "linux-64", + "timestamp": 1505863982813, + "version": "1.5.7" + }, + "sortedcontainers-1.5.7-py36hdf89491_0.tar.bz2": { + "build": "py36hdf89491_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "0c84dc5927bcd5cdd31a18365af050aa", + "name": "sortedcontainers", + "sha256": "9cf8e8c82b8ee19f22955a0bff3e4bd7c3558731c1293344834094d14dd60ec0", + "size": 46573, + "subdir": "linux-64", + "timestamp": 1505863995502, + "version": "1.5.7" + }, + "sortedcontainers-1.5.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "dd3224ac9081184ed7628ad5a4630713", + "name": "sortedcontainers", + "sha256": "0b39a0aa544b7983d5bc1a8c4f71c20c0ecae62ecca9d564a221009888a687df", + "size": 46010, + "subdir": "linux-64", + "timestamp": 1515725233323, + "version": "1.5.9" + }, + "sortedcontainers-1.5.9-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "6066bce90e2bc235d4441a15c48346b9", + "name": "sortedcontainers", + "sha256": "4969ab83d74c4fb2359e85d9cb5248ed34977d8f1fc0a365fab760156265c8a4", + "size": 47068, + "subdir": "linux-64", + "timestamp": 1515725064891, + "version": "1.5.9" + }, + "sortedcontainers-1.5.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "ff3860661415499eec0472ae954f19f1", + "name": "sortedcontainers", + "sha256": "3bd43548d25b6c2a8ae2ecfa81326b6233a306d7a5cfe91ede13200e26eacfaa", + "size": 46882, + "subdir": "linux-64", + "timestamp": 1515724977674, + "version": "1.5.9" + }, + "sortedcontainers-2.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "61748545645b2d5c5ba1b4a9552c56f2", + "name": "sortedcontainers", + "sha256": "8449c9a6cb015d4ee054f9118097d406ef3766a3685203c6de2741928791e4ea", + "size": 42445, + "subdir": "linux-64", + "timestamp": 1527832467708, + "version": "2.0.2" + }, + "sortedcontainers-2.0.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "288947d3e3a61a95d600780a5b5b79ec", + "name": "sortedcontainers", + "sha256": "6a357419683c6b4a55d5a0802de99d1e384472b2aeea15ab80d6bdd48ad76fbd", + "size": 43381, + "subdir": "linux-64", + "timestamp": 1527832478837, + "version": "2.0.2" + }, + "sortedcontainers-2.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "82b240efcb67b026bfbbe0ddd0d3c2ee", + "name": "sortedcontainers", + "sha256": "3922dad9455a874941b6fc6dc279171085251e3e1a4ed6de716e683fecb11f55", + "size": 43292, + "subdir": "linux-64", + "timestamp": 1527832434429, + "version": "2.0.2" + }, + "sortedcontainers-2.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "ca617693f5289f43e25efe95e457a0e0", + "name": "sortedcontainers", + "sha256": "d7ae0367bdd9a59570772f22693aaac2c02ed87d575fba153c02aea5203bd9aa", + "size": 41963, + "subdir": "linux-64", + "timestamp": 1527856511748, + "version": "2.0.3" + }, + "sortedcontainers-2.0.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "1a688dfc753c7975ef120150974ef271", + "name": "sortedcontainers", + "sha256": "e48d469956e849caf42777ef8abac3363b6bee175e207b8dcbf89351d1d04cc1", + "size": 42854, + "subdir": "linux-64", + "timestamp": 1527856576167, + "version": "2.0.3" + }, + "sortedcontainers-2.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "4cd9ab197588e5fa90501bdcced68b4d", + "name": "sortedcontainers", + "sha256": "1c587427f9f6ffbe8ace19525f41e2a6e546bd3faebd16e7275bc16fd120f8f7", + "size": 42830, + "subdir": "linux-64", + "timestamp": 1527856461758, + "version": "2.0.3" + }, + "sortedcontainers-2.0.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "cddaee89290eb23903ba46205d7efac7", + "name": "sortedcontainers", + "sha256": "8e5aa94b8b46008aa5eeb0524ed542ba7afb46b1f53f1da5eb4e2a12ae2696d9", + "size": 42430, + "subdir": "linux-64", + "timestamp": 1528895860248, + "version": "2.0.4" + }, + "sortedcontainers-2.0.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "4e5c0930d1f569ca3cbf75e88ef8a97b", + "name": "sortedcontainers", + "sha256": "ce4359efae6ed71f5db941d644a3edb79a37db9dc55ca394bc43b85344b184d0", + "size": 43378, + "subdir": "linux-64", + "timestamp": 1528895986983, + "version": "2.0.4" + }, + "sortedcontainers-2.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "9f19159b31b340f01ce125ecb485b6f0", + "name": "sortedcontainers", + "sha256": "85193f03dd26ce3eff6f53efec94440bec0cc0a6e8689226e77335ad1b47b321", + "size": 43321, + "subdir": "linux-64", + "timestamp": 1528895795796, + "version": "2.0.4" + }, + "sortedcontainers-2.0.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "0aa3599945f9fe9d2469ab9d90a6667d", + "name": "sortedcontainers", + "sha256": "c6d029c444ba19db0514e23dcd7434ee844c06855b6d535c86885c93ab997770", + "size": 43309, + "subdir": "linux-64", + "timestamp": 1530741443182, + "version": "2.0.4" + }, + "sortedcontainers-2.0.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "4071affa5bb081cd00803d0fcb19eba9", + "name": "sortedcontainers", + "sha256": "dace485a00479e0bc93b8a9a871c47ec833c58e58e3675fe3b55250fdd44b2c9", + "size": 42634, + "subdir": "linux-64", + "timestamp": 1536077278427, + "version": "2.0.5" + }, + "sortedcontainers-2.0.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "40d02c890f9ec5e1be8d1e6ea012c932", + "name": "sortedcontainers", + "sha256": "afa408246ae40eb53ed115501001e0c00b2bc60f2bf7844bde9103f057d5fd33", + "size": 43608, + "subdir": "linux-64", + "timestamp": 1536077295315, + "version": "2.0.5" + }, + "sortedcontainers-2.0.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "217ca7c6ca45931bf7555609a9a1fc2f", + "name": "sortedcontainers", + "sha256": "d6839ef34ddbb163f53dbd590ba7434d175c54ce0ae4ad6ced3edc6c8d73a791", + "size": 43563, + "subdir": "linux-64", + "timestamp": 1536077255432, + "version": "2.0.5" + }, + "sortedcontainers-2.0.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "d180f78371fee3dc695e01674b6166c8", + "name": "sortedcontainers", + "sha256": "c3510089cffe795a18a43aa0332a12835ae5d38e5fd85dfbc2ecde8aae1c3a61", + "size": 43544, + "subdir": "linux-64", + "timestamp": 1536077316897, + "version": "2.0.5" + }, + "sortedcontainers-2.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "550f84cf834144939707b520661111ea", + "name": "sortedcontainers", + "sha256": "2931e555e3a926a0865b0db440f5a9f9e4f02e9727d0b7145a857d63be889a32", + "size": 45204, + "subdir": "linux-64", + "timestamp": 1543617821716, + "version": "2.1.0" + }, + "sortedcontainers-2.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "6b4bb4d6c531e7d244f4d60554558b7e", + "name": "sortedcontainers", + "sha256": "ac36348da20005bc217af9e84a1c8caf7ef5332b32d4214f0e993447561a33f8", + "size": 46058, + "subdir": "linux-64", + "timestamp": 1543617857085, + "version": "2.1.0" + }, + "sortedcontainers-2.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "1b2ebd940081a76bf25b6e338d581622", + "name": "sortedcontainers", + "sha256": "0012b7bf1ae4e0f2c62703ae6f850af2dfbc80d38ff1e5b1f39354c9d179ce7f", + "size": 46079, + "subdir": "linux-64", + "timestamp": 1543617804238, + "version": "2.1.0" + }, + "sortedcontainers-2.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "b5bad8dc4bc8a81232e06ec8ecd8f2bf", + "name": "sortedcontainers", + "sha256": "2ae77e2360665208e2454aa975c3239555536b0882e0c8a7d771d485c81e402a", + "size": 44033, + "subdir": "linux-64", + "timestamp": 1573200529092, + "version": "2.1.0" + }, + "soupsieve-1.7.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "4536f6c922b15264c1195137220eb7d0", + "name": "soupsieve", + "sha256": "33d0d8586f8b0b83f10bbec9128640436f92197060531715c981ddfa595f5c03", + "size": 50919, + "subdir": "linux-64", + "timestamp": 1547908442057, + "version": "1.7.1" + }, + "soupsieve-1.7.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "28413bacc66d009fee9e123f00c929c9", + "name": "soupsieve", + "sha256": "36b08464e257e98cd22895db0abcb241592af5bfbd6c215ffa917d3e578f7cdb", + "size": 51645, + "subdir": "linux-64", + "timestamp": 1547908289769, + "version": "1.7.1" + }, + "soupsieve-1.7.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f99edd9dc2d1db43ed7b39b485f82043", + "name": "soupsieve", + "sha256": "d80fb8ad1888ac179c03e40a0c646fc61239f77b359fd6fc3993c5f85e8e4834", + "size": 51465, + "subdir": "linux-64", + "timestamp": 1547908396667, + "version": "1.7.1" + }, + "soupsieve-1.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e4ecf39e499833d735635b0f7d539a19", + "name": "soupsieve", + "sha256": "fd06886ec1d0ed9b9ccf25d3b016c559ae420b4b17cb6fb7174a9da0e722f8c6", + "size": 103544, + "subdir": "linux-64", + "timestamp": 1552448023914, + "version": "1.8" + }, + "soupsieve-1.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3c3785184a2a9c7e0f06d4ce814e31c4", + "name": "soupsieve", + "sha256": "e1a383bc326fe96a07a3df2f7dfdf5d223858c6d6c723471517311b5e6d37063", + "size": 106965, + "subdir": "linux-64", + "timestamp": 1552446532182, + "version": "1.8" + }, + "soupsieve-1.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c165e93fa34434dda4586d7fdac4538d", + "name": "soupsieve", + "sha256": "330bca72c5abc910147d9d2418f224173565997a5e624b8a0fe3b6d4a1089720", + "size": 106603, + "subdir": "linux-64", + "timestamp": 1552446415126, + "version": "1.8" + }, + "soupsieve-1.9.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "cdfef5685b2ab257a3ffa53fbd2aed0c", + "name": "soupsieve", + "sha256": "8c61a3ddb3646269d954d7562684b030fa4c081a9ce5ca694c244a5ba38c0b1f", + "size": 61566, + "subdir": "linux-64", + "timestamp": 1564707750770, + "version": "1.9.2" + }, + "soupsieve-1.9.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "64de0f0368a1e8539428adcdbd7aa0de", + "name": "soupsieve", + "sha256": "f0e928d23f652a9207f4192d40181425ee1c2a4f4a2cb187ada32de6fb2c56ae", + "size": 62476, + "subdir": "linux-64", + "timestamp": 1564707762977, + "version": "1.9.2" + }, + "soupsieve-1.9.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "05d20283528781b3324253423f9f325f", + "name": "soupsieve", + "sha256": "00d079071fa58618ea7be2706b567cfdd839815bbbf8d8ef277b689be4022ac3", + "size": 62394, + "subdir": "linux-64", + "timestamp": 1564707728882, + "version": "1.9.2" + }, + "soupsieve-1.9.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f5506e9601f9d09873cfc80ad63e21de", + "name": "soupsieve", + "sha256": "6bc193f5b72ef5cf49b1953d4e9682a1542bee9a6afeadeb963069cef9ea138b", + "size": 60359, + "subdir": "linux-64", + "timestamp": 1569427176861, + "version": "1.9.3" + }, + "soupsieve-1.9.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2a7da209ffdcd3852344916911178d5d", + "name": "soupsieve", + "sha256": "c24f964bae6a0aa1747e1a42c97c322e931a5c71efc82c9239a632f2a01d4872", + "size": 61466, + "subdir": "linux-64", + "timestamp": 1569427193875, + "version": "1.9.3" + }, + "soupsieve-1.9.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1e3e9c430be972d9e9e8e301cb6c1d1b", + "name": "soupsieve", + "sha256": "0101d01afa22af9bed28886b95a3157d1517a899d4f21ad15bc200d4a00e0c90", + "size": 61388, + "subdir": "linux-64", + "timestamp": 1569427172706, + "version": "1.9.3" + }, + "soupsieve-1.9.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "11de3e94811f4318c04346c3310e1927", + "name": "soupsieve", + "sha256": "f3b8658e06457e6b1f188c69499d78ccca6ac1a8fe4f05a946d0bd1d690e7578", + "size": 59207, + "subdir": "linux-64", + "timestamp": 1572608982925, + "version": "1.9.3" + }, + "soupsieve-1.9.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ce1a51f9d2b58da4b805d9c169050b10", + "name": "soupsieve", + "sha256": "04739fe5df183c767bc14e8624640a973c9ee67c075d2dec17777a2aa0121154", + "size": 61101, + "subdir": "linux-64", + "timestamp": 1573941977344, + "version": "1.9.4" + }, + "soupsieve-1.9.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "878d157bdf9985c57f6fe799c51de71e", + "name": "soupsieve", + "sha256": "ea3c3913ca709f8ca201108dc8043d2da119f62f4dbad856b79b8abde37b66cb", + "size": 62088, + "subdir": "linux-64", + "timestamp": 1573941903578, + "version": "1.9.4" + }, + "soupsieve-1.9.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1dfb74ec80478e2c5f61ace87c8aaa74", + "name": "soupsieve", + "sha256": "88f1ba496d5e038bcf204b0e6e0b8f48b6cebcf4891670a3e5de2ff871575b53", + "size": 62144, + "subdir": "linux-64", + "timestamp": 1573941946599, + "version": "1.9.4" + }, + "soupsieve-1.9.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "0289b7bc24982e78b5e4c215785083e4", + "name": "soupsieve", + "sha256": "2190cf2c9da9e469d2e49641d253257d68c8ce154c96a8e74cf1a49537a31519", + "size": 62122, + "subdir": "linux-64", + "timestamp": 1573941984426, + "version": "1.9.4" + }, + "soupsieve-1.9.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "3e80b06c70e33b0b9be663143120116e", + "name": "soupsieve", + "sha256": "e18fcf3806e180d49c0b326684523f27f873a4164b18f24f53d9a695f80041eb", + "size": 61457, + "subdir": "linux-64", + "timestamp": 1574269065867, + "version": "1.9.5" + }, + "soupsieve-1.9.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "315db5c5f722a795bdba51524e3448f0", + "name": "soupsieve", + "sha256": "2bcedfb726498f36d4d86bf960b7e03d097e026aa79d112b0834de71741b3af5", + "size": 62658, + "subdir": "linux-64", + "timestamp": 1574269090439, + "version": "1.9.5" + }, + "soupsieve-1.9.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6965282c7da0688a04113b20aa2ddce5", + "name": "soupsieve", + "sha256": "d89707afe8eb85b7be33747edd282f084067dd5ab5603fcc4cfb8cb38ba9b5be", + "size": 62342, + "subdir": "linux-64", + "timestamp": 1574269088786, + "version": "1.9.5" + }, + "soupsieve-1.9.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "b6c679340b0428fe1c5804a873b138d7", + "name": "soupsieve", + "sha256": "5c3727c372a2ac81a479f774896da02160f9616be498d404911e492073e14d7f", + "size": 62586, + "subdir": "linux-64", + "timestamp": 1574269142277, + "version": "1.9.5" + }, + "soupsieve-2.3.2.post1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e2c4318adddfbccf7563ff47ee88bd8d", + "name": "soupsieve", + "sha256": "bdb2dfd54615662f4d3fd07877b6958d6e95c95991f41864cdf691ecc709320b", + "size": 67052, + "subdir": "linux-64", + "timestamp": 1666296424215, + "version": "2.3.2.post1" + }, + "soupsieve-2.3.2.post1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64f20002e7f0f2255e796b5071242d0a", + "name": "soupsieve", + "sha256": "7690423ee5bb186838ebfd1bb50f77d1072906877d91fce37a20df75d3593990", + "size": 92608, + "subdir": "linux-64", + "timestamp": 1676823551313, + "version": "2.3.2.post1" + }, + "soupsieve-2.3.2.post1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7dfd129dbaaa250867381948c85115e9", + "name": "soupsieve", + "sha256": "588fb09ec3d12f2b2bfa5ade5cd481f9ee3e671c85d51686aaad39fb52f51cad", + "size": 66116, + "subdir": "linux-64", + "timestamp": 1666296506095, + "version": "2.3.2.post1" + }, + "soupsieve-2.3.2.post1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58dac96b2367efe1e1bf36cda5949769", + "name": "soupsieve", + "sha256": "5e588fb39658322210f2874675f9c9dd431c5f2a959b5005b022e56f82d72e34", + "size": 66379, + "subdir": "linux-64", + "timestamp": 1666296477717, + "version": "2.3.2.post1" + }, + "soupsieve-2.3.2.post1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "42d59786a87d9bfb7a4d93c7952a622d", + "name": "soupsieve", + "sha256": "abc639aacfd7c0cb9694cc4ff5da82cd79b5e982fc7f318c0f52f3aabba19c67", + "size": 66306, + "subdir": "linux-64", + "timestamp": 1666296451145, + "version": "2.3.2.post1" + }, + "soupsieve-2.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "462139240b566aa6df8eb2736a573de6", + "name": "soupsieve", + "sha256": "f4288b844b3fa68174102aab05f6575dfd5317cd355fdb5fc4fae1cd2e889518", + "size": 67022, + "subdir": "linux-64", + "timestamp": 1680518587357, + "version": "2.4" + }, + "soupsieve-2.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "719dc17fd2987051c3e735ead1a531a6", + "name": "soupsieve", + "sha256": "463da4c4f266d93aab0f2eb62c7fee23afbdd438d76d35a2ca6780b2acd228ff", + "size": 89234, + "subdir": "linux-64", + "timestamp": 1680518535885, + "version": "2.4" + }, + "soupsieve-2.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d94d9b3921e99b7cbe11ebba4680d376", + "name": "soupsieve", + "sha256": "131003dde07015b3da77ab27c52ad676f9e659c5f0b1855bda285f32705a5817", + "size": 66503, + "subdir": "linux-64", + "timestamp": 1680518509942, + "version": "2.4" + }, + "soupsieve-2.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9038c09d073c3bc38beab5b74507f89", + "name": "soupsieve", + "sha256": "929ea9cb718a48969ff091d604416cc85394cdfb949ff223ebe1808d9c659db6", + "size": 66439, + "subdir": "linux-64", + "timestamp": 1680518561058, + "version": "2.4" + }, + "spacy-1.9.0-py27h2a2a31f_1.tar.bz2": { + "build": "py27h2a2a31f_1", + "build_number": 1, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "murmurhash >=0.26,<0.27", + "numpy >=1.9.3,<2.0a0", + "pathlib", + "pip >=9.0.0,<10.0.0", + "plac <1.0.0,>=0.9.6", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "regex >=2017.4.1,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.5.0,<6.6.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "61b7be8608b43ad7f2d0d5c090475c8f", + "name": "spacy", + "sha256": "7485a75a0c73cb8f6a761872a6b97be24648f828ce86a1afa2ecde610cd96dff", + "size": 2945082, + "subdir": "linux-64", + "timestamp": 1509399455367, + "version": "1.9.0" + }, + "spacy-1.9.0-py35h56fe5f8_1.tar.bz2": { + "build": "py35h56fe5f8_1", + "build_number": 1, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "murmurhash >=0.26,<0.27", + "numpy >=1.9.3,<2.0a0", + "pathlib", + "pip >=9.0.0,<10.0.0", + "plac <1.0.0,>=0.9.6", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "regex >=2017.4.1,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.5.0,<6.6.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "ad019b58ed06375f5ef0a774dab47bdf", + "name": "spacy", + "sha256": "358281174d110118a87fa3ba25d36d8b9160a7ffa68000bc5fd06cd6e14087bc", + "size": 2908074, + "subdir": "linux-64", + "timestamp": 1509399486629, + "version": "1.9.0" + }, + "spacy-1.9.0-py36hc78c2e1_1.tar.bz2": { + "build": "py36hc78c2e1_1", + "build_number": 1, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "murmurhash >=0.26,<0.27", + "numpy >=1.9.3,<2.0a0", + "pathlib", + "pip >=9.0.0,<10.0.0", + "plac <1.0.0,>=0.9.6", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "regex >=2017.4.1,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.5.0,<6.6.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "eb77dbaf42e3b31a4b72a99c95a65ff6", + "name": "spacy", + "sha256": "17f31599493fd6a03d5601569dd2a6c9043284380c8700f31b487802715671a8", + "size": 2894967, + "subdir": "linux-64", + "timestamp": 1509399660930, + "version": "1.9.0" + }, + "spacy-2.0.10-py27h637b7d7_0.tar.bz2": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "regex >=2017.4.0,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "e15c2ed2df65d4b10b8fbfe8a6c859dc", + "name": "spacy", + "sha256": "17f03d7e6473c76382fa3be0e170a13920d9943f7344073e4ed92fb7dc747b73", + "size": 43475953, + "subdir": "linux-64", + "timestamp": 1522706163040, + "version": "2.0.10" + }, + "spacy-2.0.10-py35h637b7d7_0.tar.bz2": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "regex >=2017.4.0,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "a49f33a8b6f7bdc0ddc46da05bc0193b", + "name": "spacy", + "sha256": "138417592fb928ee5467b45e861a5866e0208ddbe1d44cfad4e5b1d0a7da6428", + "size": 42300734, + "subdir": "linux-64", + "timestamp": 1522706165278, + "version": "2.0.10" + }, + "spacy-2.0.10-py36h637b7d7_0.tar.bz2": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "regex >=2017.4.0,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "ccac4423579d1f45c539a599e0545513", + "name": "spacy", + "sha256": "1d74c25e4bb912e37032d4ce3d90b399bb432de8688b6868a9051baf4d56fb39", + "size": 36119639, + "subdir": "linux-64", + "timestamp": 1522706152138, + "version": "2.0.10" + }, + "spacy-2.0.11-py27h04863e7_1.tar.bz2": { + "build": "py27h04863e7_1", + "build_number": 1, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.4.2", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "pathlib2", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "regex >=2017.4.0,<=2018.6.21", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.12.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "edf6fa2a09488310ea33bd31f8f691c1", + "name": "spacy", + "sha256": "056a0c5d079735383de611005599dd23901ec8930dc91e577261e9384f821712", + "size": 43681608, + "subdir": "linux-64", + "timestamp": 1530962401650, + "version": "2.0.11" + }, + "spacy-2.0.11-py27h04863e7_2.tar.bz2": { + "build": "py27h04863e7_2", + "build_number": 2, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "pathlib2", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "regex >=2017.4.0,<=2018.6.21", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.12.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "cf902d3f8f780ab76fc7afb6193a94e3", + "name": "spacy", + "sha256": "cab7c802c675ab147325ae1f99a08f249d5a00a9f2b6aafdd3c77589ea5fc182", + "size": 43673911, + "subdir": "linux-64", + "timestamp": 1531058476777, + "version": "2.0.11" + }, + "spacy-2.0.11-py27h637b7d7_0.tar.bz2": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "regex >=2017.4.0,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "ce8958466edd75d249e0cc23e6ce9479", + "name": "spacy", + "sha256": "83df969c87b72baafefb501e649adc6bf538fd7e58957c409bdcb66f5450f26e", + "size": 43674126, + "subdir": "linux-64", + "timestamp": 1524074943948, + "version": "2.0.11" + }, + "spacy-2.0.11-py35h637b7d7_0.tar.bz2": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "regex >=2017.4.0,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "46ee62c8ea9273eef6116154e9eb72fc", + "name": "spacy", + "sha256": "67c1ff21b9efaf75d1998064fb1b3fc8f6dc4e6b32ce6362789907fcc3735362", + "size": 42360538, + "subdir": "linux-64", + "timestamp": 1524074607692, + "version": "2.0.11" + }, + "spacy-2.0.11-py36h04863e7_1.tar.bz2": { + "build": "py36h04863e7_1", + "build_number": 1, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.4.2", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "regex >=2017.4.0,<=2018.6.21", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.12.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "efad0083eb331e56c1cad6d8c120594d", + "name": "spacy", + "sha256": "9691404c719bba1b7f846e8c46151f6eb4219d9b64b9eb05772d833e8e3069f9", + "size": 36172177, + "subdir": "linux-64", + "timestamp": 1531049437511, + "version": "2.0.11" + }, + "spacy-2.0.11-py36h04863e7_2.tar.bz2": { + "build": "py36h04863e7_2", + "build_number": 2, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "regex >=2017.4.0,<=2018.6.21", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.12.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "f69b4c313e932babca716064924304e7", + "name": "spacy", + "sha256": "69ea05e08141fd6d9964c22b7db245f0db6d9e449b9967e7f29121860ef9cb63", + "size": 36174106, + "subdir": "linux-64", + "timestamp": 1531056748504, + "version": "2.0.11" + }, + "spacy-2.0.11-py36h637b7d7_0.tar.bz2": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "regex >=2017.4.0,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "90783d3df964ca5e7d2677eef3361c75", + "name": "spacy", + "sha256": "6374adcc5bac047a3f92173374b68c1794f3212ad3655588202ef1b80c7065a1", + "size": 36172671, + "subdir": "linux-64", + "timestamp": 1524074935540, + "version": "2.0.11" + }, + "spacy-2.0.11-py37h04863e7_1.tar.bz2": { + "build": "py37h04863e7_1", + "build_number": 1, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.4.2", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.7,<3.8.0a0", + "regex >=2017.4.0,<=2018.6.21", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.12.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "440bcd43676401ae86d10956197637ef", + "name": "spacy", + "sha256": "726f9eaacd757c2feeae5c64df45ffc40a454347e164e5db2f88fdf71cb68d95", + "size": 36154549, + "subdir": "linux-64", + "timestamp": 1530963714745, + "version": "2.0.11" + }, + "spacy-2.0.11-py37h04863e7_2.tar.bz2": { + "build": "py37h04863e7_2", + "build_number": 2, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.7,<3.8.0a0", + "regex >=2017.4.0,<=2018.6.21", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.12.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "9862c56725f981ab708be552aad63066", + "name": "spacy", + "sha256": "1294cf94278a9fe3432842e33c19b1991c4726c9739d0738452a34bb22415100", + "size": 36160107, + "subdir": "linux-64", + "timestamp": 1531056139760, + "version": "2.0.11" + }, + "spacy-2.0.12-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "pathlib2", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "regex >=2017.4.0,<=2018.7.11", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.3,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "84fca1f3eb51825946f52d5a3484f42c", + "name": "spacy", + "sha256": "b89795c0ab3bc7434cb95764d600731e21ef4bb9681ba7c378c462c49ca97ead", + "size": 56407842, + "subdir": "linux-64", + "timestamp": 1535689673437, + "version": "2.0.12" + }, + "spacy-2.0.12-py35h962f231_0.tar.bz2": { + "build": "py35h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "regex >=2017.4.0,<=2018.7.11", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.3,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "e0cfd7216bb89d6d8040ca11bde46d52", + "name": "spacy", + "sha256": "de1fbffa026ea5314e4993e9fbd177a2fe753fe968c336ce578e090b6f857ca3", + "size": 54648780, + "subdir": "linux-64", + "timestamp": 1535690630839, + "version": "2.0.12" + }, + "spacy-2.0.12-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "regex >=2017.4.0,<=2018.7.11", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.3,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "28d63f0fa1ca06954fefee850445dbf5", + "name": "spacy", + "sha256": "a7435d309c03f4308847451fe2a596d9f1aa49750f283cdbbbfd68e9521bf4fa", + "size": 47866421, + "subdir": "linux-64", + "timestamp": 1535689694093, + "version": "2.0.12" + }, + "spacy-2.0.12-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.7,<3.8.0a0", + "regex >=2017.4.0,<=2018.7.11", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.3,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "3a3ccf7133a5086d86ffa547a83f0714", + "name": "spacy", + "sha256": "5ebb14a5d98f62c4127082b64726461fada95804a7831ac5e2db0a5aa4634781", + "size": 47673616, + "subdir": "linux-64", + "timestamp": 1535689675404, + "version": "2.0.12" + }, + "spacy-2.0.16-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "pathlib2", + "plac >=0.9.6,<1.0.0", + "preshed >=2.0.1,<2.1.0", + "python >=2.7,<2.8.0a0", + "regex >=2018.01.10", + "requests >=2.13.0,<3.0.0", + "thinc >=6.12.0,<6.13.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "1683863834523607a7498e52e5f29d95", + "name": "spacy", + "sha256": "4ad7f585231d3d522c96d79245513159004141a88e88fbf683d4edbadeb3948c", + "size": 58566900, + "subdir": "linux-64", + "timestamp": 1539885820475, + "version": "2.0.16" + }, + "spacy-2.0.16-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=2.0.1,<2.1.0", + "python >=3.6,<3.7.0a0", + "regex >=2018.01.10", + "requests >=2.13.0,<3.0.0", + "thinc >=6.12.0,<6.13.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "b70dfa85378f230a8e22aa3fd7902b71", + "name": "spacy", + "sha256": "71baf0114f5bafffd19fb5501522e3226ceff3dbb5b6f0c4c6da47a9a9b8074e", + "size": 50030429, + "subdir": "linux-64", + "timestamp": 1539885802540, + "version": "2.0.16" + }, + "spacy-2.0.16-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=2.0.1,<2.1.0", + "python >=3.7,<3.8.0a0", + "regex >=2018.01.10", + "requests >=2.13.0,<3.0.0", + "thinc >=6.12.0,<6.13.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "f2af13f8471fe9914c79fb8cc2381086", + "name": "spacy", + "sha256": "a12f33e347de56c1d8cb9075aa078ef8cf3c1c7877aa6cd9460136476409620f", + "size": 49732919, + "subdir": "linux-64", + "timestamp": 1539885665864, + "version": "2.0.16" + }, + "spacy-2.0.16-py38h962f231_0.tar.bz2": { + "build": "py38h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=2.0.1,<2.1.0", + "python >=3.8,<3.9.0a0", + "regex >=2018.01.10", + "requests >=2.13.0,<3.0.0", + "thinc >=6.12.0,<6.13.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "b967505efe042edecea3ca5f0ba5f403", + "name": "spacy", + "sha256": "0d4a9954d597df681bddfa7c51e76893099193a8e2c84d32559f26211b007be5", + "size": 50093013, + "subdir": "linux-64", + "timestamp": 1574237877975, + "version": "2.0.16" + }, + "spacy-2.0.5-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy 0.4.1", + "msgpack-python", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "regex 2017.4.5", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "f03dd86fd62a5c1e2a5d3db6d9c4dcbb", + "name": "spacy", + "sha256": "4a73388ab3f2a137a348d31de8f13f4d4921474dc3cefb6d3a66f44de8c61c21", + "size": 32713328, + "subdir": "linux-64", + "timestamp": 1515522994066, + "version": "2.0.5" + }, + "spacy-2.0.5-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy 0.4.1", + "msgpack-python", + "murmurhash >=0.28,<0.29", + "numpy >=1.14.0,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "regex 2017.4.5", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "0131bebf750d32bbece16b2cc53323e4", + "name": "spacy", + "sha256": "71a69f4f6ca2367783b600712282551eefe17138e6ad74548ee096c16c6cdca2", + "size": 31236356, + "subdir": "linux-64", + "timestamp": 1515523062910, + "version": "2.0.5" + }, + "spacy-2.0.5-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy 0.4.1", + "msgpack-python", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "regex 2017.4.5", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "a509ab74c99d98742af103b09738d45d", + "name": "spacy", + "sha256": "f070f8fa922512b0564df7c8686a539259ca2d12f98769f2723b3fa8c8ed2f7a", + "size": 27167302, + "subdir": "linux-64", + "timestamp": 1515522992593, + "version": "2.0.5" + }, + "spacy-2.0.9-py27h637b7d7_0.tar.bz2": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "regex >=2017.4.0,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "05e32ef9da901e8dfc89a8d390b1297e", + "name": "spacy", + "sha256": "d79b25326a5efe07360c9db0194c3d39f8f79b06732993ccdf462923dac4bf7b", + "size": 43450808, + "subdir": "linux-64", + "timestamp": 1520539508800, + "version": "2.0.9" + }, + "spacy-2.0.9-py35h637b7d7_0.tar.bz2": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "regex >=2017.4.0,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "ffb93e9174c62db1ed54a3bc8a867914", + "name": "spacy", + "sha256": "aefd2de257c3d6283595f7f2f33786e89e1442fbd6d16734faa0fc27a661db75", + "size": 42256736, + "subdir": "linux-64", + "timestamp": 1520539588005, + "version": "2.0.9" + }, + "spacy-2.0.9-py36h637b7d7_0.tar.bz2": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "regex >=2017.4.0,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "d5043d33ff8d27337497b52e97bdeb62", + "name": "spacy", + "sha256": "e7835fe9e094ce751b5e3b3f9470725d7596b49bc137daba44a74719e76d2522", + "size": 36097410, + "subdir": "linux-64", + "timestamp": 1520539039528, + "version": "2.0.9" + }, + "spacy-2.3.1-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.6,<3.7.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc 7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "3f02afb3e489a323e7bd2d7086ba1d06", + "name": "spacy", + "sha256": "a66623f369dbb3995a7416b3a45c331f51d73beff1c180cfe2e736175cf16212", + "size": 8642225, + "subdir": "linux-64", + "timestamp": 1594303659124, + "version": "2.3.1" + }, + "spacy-2.3.1-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.7,<3.8.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc 7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "d975130ea772c57c0df314b9dd194874", + "name": "spacy", + "sha256": "3f2f5129dbba787884acbf4e49f999cb7db651b891f2a589ebf47acde84eb2a8", + "size": 8632027, + "subdir": "linux-64", + "timestamp": 1594303621898, + "version": "2.3.1" + }, + "spacy-2.3.1-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.8,<3.9.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc 7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "00b4303e89ab677e7857e918eea2076f", + "name": "spacy", + "sha256": "9f87c5efd1d6529d4ca4c80152e6eebb4528bb76ced16d8dec7db02fe2c930b0", + "size": 8822775, + "subdir": "linux-64", + "timestamp": 1594305462266, + "version": "2.3.1" + }, + "spacy-2.3.2-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.6,<3.7.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc 7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "84cab93ca4a2fe385981620404a26a54", + "name": "spacy", + "sha256": "93976126abac2657dcf0b2624c0adbbdbe606ba7f19b6548d69f7e815d5e9c6c", + "size": 8640179, + "subdir": "linux-64", + "timestamp": 1600554551239, + "version": "2.3.2" + }, + "spacy-2.3.2-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.7,<3.8.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc 7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "3cccbe3e24d120f78f34b9c938e45936", + "name": "spacy", + "sha256": "4b25ebda2e0839afea215a45f919be2060187b5ada3fe38c09687c44a304fe93", + "size": 8629714, + "subdir": "linux-64", + "timestamp": 1600554549421, + "version": "2.3.2" + }, + "spacy-2.3.2-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.8,<3.9.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc 7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "2c163cfb03e05c94ff96ecc5a2e3a0b5", + "name": "spacy", + "sha256": "6cd67517b93d2f27fac27211effbc105c04a637a301279bd67e776405558f290", + "size": 8814265, + "subdir": "linux-64", + "timestamp": 1600554543147, + "version": "2.3.2" + }, + "spacy-2.3.5-py36hff7bd54_0.tar.bz2": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.6,<3.7.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc >=7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "74b1f43156e86f880ff041fd8bd2ea1b", + "name": "spacy", + "sha256": "04f79123e2525576eb0ea1705a4161720f2c28a63c5aaec062708abbf9e07c3d", + "size": 8672649, + "subdir": "linux-64", + "timestamp": 1608321420980, + "version": "2.3.5" + }, + "spacy-2.3.5-py37hff7bd54_0.tar.bz2": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.7,<3.8.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc >=7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "dab62946627111f18b083e78453f8405", + "name": "spacy", + "sha256": "b84af42a76a10f843e8892cf9952e8c83307bbf48e01cd534d1ff24cc3573c7a", + "size": 8633997, + "subdir": "linux-64", + "timestamp": 1608321377365, + "version": "2.3.5" + }, + "spacy-2.3.5-py38hff7bd54_0.tar.bz2": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.8,<3.9.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc >=7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "ef23b51752fcb664320a3b66376e61fe", + "name": "spacy", + "sha256": "ec3b840098852ea9af360a1515b3edbae74ea26444080ba37eec2f160c7028d0", + "size": 8865963, + "subdir": "linux-64", + "timestamp": 1608321435733, + "version": "2.3.5" + }, + "spacy-2.3.5-py39hff7bd54_0.tar.bz2": { + "build": "py39hff7bd54_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.9,<3.10.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc >=7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "8fd9905798cc36ceca34919d7436f12b", + "name": "spacy", + "sha256": "9b9a42e68050e6cefa55a2636e693f6649ba8e984ed15d8385573112fff5669c", + "size": 8838944, + "subdir": "linux-64", + "timestamp": 1608323278083, + "version": "2.3.5" + }, + "spacy-3.2.1-py37hae6d005_0.tar.bz2": { + "build": "py37hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1,<1.9.0", + "python >=3.7,<3.8.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.8,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.1,<3.0.0", + "thinc >=8.0.12,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.2,<0.5.0", + "typing_extensions >=3.7.4,<4.0.0.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "md5": "3f2123ef9fe7faf012ce74b99e9248df", + "name": "spacy", + "sha256": "4a83147d08547560d4907c0cb9b12e1fa49010ef25da787f0baad519b955359e", + "size": 6157534, + "subdir": "linux-64", + "timestamp": 1643539074553, + "version": "3.2.1" + }, + "spacy-3.2.1-py38hae6d005_0.tar.bz2": { + "build": "py38hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1,<1.9.0", + "python >=3.8,<3.9.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.8,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.1,<3.0.0", + "thinc >=8.0.12,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.2,<0.5.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "md5": "890e2c646829ee17d6c50faf00cfc5eb", + "name": "spacy", + "sha256": "fab92b68317f9664e10b1f838b58b9a63c439933d4933f7dbad869ec22d01c07", + "size": 6439988, + "subdir": "linux-64", + "timestamp": 1643539855978, + "version": "3.2.1" + }, + "spacy-3.2.1-py39hae6d005_0.tar.bz2": { + "build": "py39hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1,<1.9.0", + "python >=3.9,<3.10.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.8,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.1,<3.0.0", + "thinc >=8.0.12,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.2,<0.5.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "md5": "38446aa0be77d0caa161ea641b6af322", + "name": "spacy", + "sha256": "d6639771eb3d13db96b750da745264f5dc7884e7c9fbeaff1c30b44d9ffb073e", + "size": 6414129, + "subdir": "linux-64", + "timestamp": 1643538275130, + "version": "3.2.1" + }, + "spacy-3.3.0-py310h2571103_0.tar.bz2": { + "build": "py310h2571103_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "click <8.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.10,<3.11.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.9,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.3,<3.0.0", + "thinc >=8.0.14,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.0,<0.5.0", + "wasabi >=0.9.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dca9c84192604fb4edb2c27630956c96", + "name": "spacy", + "sha256": "bce3e2e1ceb9b76babbf7210aa57c16bdb227de6496b8579cbfa52bf48fe4d30", + "size": 24546665, + "subdir": "linux-64", + "timestamp": 1651736794228, + "version": "3.3.0" + }, + "spacy-3.3.0-py37hae6d005_0.tar.bz2": { + "build": "py37hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "click <8.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.7,<3.8.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.9,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.3,<3.0.0", + "thinc >=8.0.14,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.0,<0.5.0", + "typing_extensions >=3.7.4,<4.0.0.0", + "wasabi >=0.9.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "abdc626d4cf48792261621936a44a57c", + "name": "spacy", + "sha256": "7f76af80f5480d09263cc6bb1453bb6d685d92df157604c9ff0abf1bd775e8ed", + "size": 6437277, + "subdir": "linux-64", + "timestamp": 1651736119378, + "version": "3.3.0" + }, + "spacy-3.3.0-py38hae6d005_0.tar.bz2": { + "build": "py38hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "click <8.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.8,<3.9.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.9,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.3,<3.0.0", + "thinc >=8.0.14,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.0,<0.5.0", + "wasabi >=0.9.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "662f20ee6b3c998ffa088637d9c67f5a", + "name": "spacy", + "sha256": "1673cbc5ae0dbc1843d70c1a20ce8789c7e0f43b8f24593ca6a69fc05c20ec98", + "size": 6677314, + "subdir": "linux-64", + "timestamp": 1651734909183, + "version": "3.3.0" + }, + "spacy-3.3.0-py39hae6d005_0.tar.bz2": { + "build": "py39hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "click <8.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.9,<3.10.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.9,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.3,<3.0.0", + "thinc >=8.0.14,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.0,<0.5.0", + "wasabi >=0.9.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af1e8e0f4b2566b2b37dd34dbe24e55b", + "name": "spacy", + "sha256": "191e414e98512f07ed7cbfe2b9f8a70d6774e61e08a411c60dc15b2544028a12", + "size": 6644983, + "subdir": "linux-64", + "timestamp": 1651735508132, + "version": "3.3.0" + }, + "spacy-3.3.1-py310h3c18c91_0.tar.bz2": { + "build": "py310h3c18c91_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "click <8.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.10,<3.11.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.9,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.3,<3.0.0", + "thinc >=8.0.14,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.0,<0.5.0", + "wasabi >=0.9.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b269f7fc3447c1f8f57c60e557a2406a", + "name": "spacy", + "sha256": "86e2f31b0a497403d448b0a0e48ba0315db3081ba71d1c6e69d0a1fc7b9c4a36", + "size": 28592459, + "subdir": "linux-64", + "timestamp": 1656601812398, + "version": "3.3.1" + }, + "spacy-3.3.1-py311heed92f4_0.tar.bz2": { + "build": "py311heed92f4_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "click <8.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.22.3,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.11,<3.12.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.9,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.3,<3.0.0", + "thinc >=8.0.14,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.0,<0.5.0", + "wasabi >=0.9.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb42690eb9e81fcc03d96aba696871da", + "name": "spacy", + "sha256": "57a8850ad6baf0376a74940869fd79b0415f6b7452b3e30fd9acbc978b180900", + "size": 6989510, + "subdir": "linux-64", + "timestamp": 1677697535262, + "version": "3.3.1" + }, + "spacy-3.3.1-py37h79cecc1_0.tar.bz2": { + "build": "py37h79cecc1_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "click <8.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.7,<3.8.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.9,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.3,<3.0.0", + "thinc >=8.0.14,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.0,<0.5.0", + "typing_extensions >=3.7.4.1,<4.2.0", + "wasabi >=0.9.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "93258cfe40f50a57d0abeeb21570823b", + "name": "spacy", + "sha256": "473ce19c57603c292db22deb480fd79c612cd1b866ea46ea4c4c9e1f8fce8b5a", + "size": 6507651, + "subdir": "linux-64", + "timestamp": 1656603793657, + "version": "3.3.1" + }, + "spacy-3.3.1-py38h79cecc1_0.tar.bz2": { + "build": "py38h79cecc1_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "click <8.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.8,<3.9.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.9,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.3,<3.0.0", + "thinc >=8.0.14,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.0,<0.5.0", + "wasabi >=0.9.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb80c2563cb9684d94368f70f839b509", + "name": "spacy", + "sha256": "6427cfec19faca1125376a0fa767806b2e5cf4d2d60230f5bc227342a69ad96b", + "size": 6775478, + "subdir": "linux-64", + "timestamp": 1656603123670, + "version": "3.3.1" + }, + "spacy-3.3.1-py39h79cecc1_0.tar.bz2": { + "build": "py39h79cecc1_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "click <8.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.9,<3.10.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.9,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.3,<3.0.0", + "thinc >=8.0.14,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.0,<0.5.0", + "wasabi >=0.9.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc879fab3a3daa20c48285092f98c3d7", + "name": "spacy", + "sha256": "5b090f3b78176ddbdc0ce398b629679ff17cd6af1de2b32f5c219a3262c41ccb", + "size": 6623193, + "subdir": "linux-64", + "timestamp": 1656602482185, + "version": "3.3.1" + }, + "spacy-alignments-0.8.5-py310hd24b679_0.tar.bz2": { + "build": "py310hd24b679_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd33cb30de7247a795aa9e83759f1d0a", + "name": "spacy-alignments", + "sha256": "a62f8d16f0b1665962b49f802d34ed7ae63f63d7aac9ff9c70dfc76e580d0f58", + "size": 1009909, + "subdir": "linux-64", + "timestamp": 1651063840816, + "version": "0.8.5" + }, + "spacy-alignments-0.8.5-py37hd24b679_0.tar.bz2": { + "build": "py37hd24b679_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc2c85d53517cbe0ad3a12f397b7089a", + "name": "spacy-alignments", + "sha256": "35aaa7a3d536aca479781da0a33df6acbe1b12ec22971bdbf904fc7adefee0fd", + "size": 1008907, + "subdir": "linux-64", + "timestamp": 1651063466686, + "version": "0.8.5" + }, + "spacy-alignments-0.8.5-py38hd24b679_0.tar.bz2": { + "build": "py38hd24b679_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d021eb6f5b9ae163d629bc0679ca1ba", + "name": "spacy-alignments", + "sha256": "da5f8296408863b6c263cce797e71148e0ce04b290d76126195625c14a1459fb", + "size": 1009382, + "subdir": "linux-64", + "timestamp": 1651063586868, + "version": "0.8.5" + }, + "spacy-alignments-0.8.5-py39hd24b679_0.tar.bz2": { + "build": "py39hd24b679_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0bcef881abdf826b812ce7ad74812605", + "name": "spacy-alignments", + "sha256": "7e61cae272e6560ac44f172a66c89583b25bf46275c88917a17bfb5c2fef52b2", + "size": 1010881, + "subdir": "linux-64", + "timestamp": 1651063710307, + "version": "0.8.5" + }, + "spacy-alignments-0.9.0-py310hbdeaff8_0.tar.bz2": { + "build": "py310hbdeaff8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b0870fcbe46fae147f7cee7749de5d19", + "name": "spacy-alignments", + "sha256": "0f25a3097abcc3850f9bb71397aefe25a3f726776f78c9e500c9656ffe00a814", + "size": 1049921, + "subdir": "linux-64", + "timestamp": 1674249608743, + "version": "0.9.0" + }, + "spacy-alignments-0.9.0-py311hbdeaff8_0.tar.bz2": { + "build": "py311hbdeaff8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "50abec402e6d692ea8407a5a85cc5a10", + "name": "spacy-alignments", + "sha256": "ffe9908ffb66280fb35afa94f496428043b651c21ab1951ce43ba94a3fa8ebb1", + "size": 1050705, + "subdir": "linux-64", + "timestamp": 1676862429543, + "version": "0.9.0" + }, + "spacy-alignments-0.9.0-py37hbdeaff8_0.tar.bz2": { + "build": "py37hbdeaff8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b581b9ee9f489749a7850a47ab767fc3", + "name": "spacy-alignments", + "sha256": "4f524d0832d3d232a2c6c5bf7834634b94c5d00559f5cc015c40ca04da8153f6", + "size": 1049554, + "subdir": "linux-64", + "timestamp": 1674249833433, + "version": "0.9.0" + }, + "spacy-alignments-0.9.0-py38hbdeaff8_0.tar.bz2": { + "build": "py38hbdeaff8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6404f441821a2b6db64f29a5340c584", + "name": "spacy-alignments", + "sha256": "54e8347384c0eac57070e928ea48c72d9372084077fdc9a24d5fec47722e9190", + "size": 1049629, + "subdir": "linux-64", + "timestamp": 1674249484745, + "version": "0.9.0" + }, + "spacy-alignments-0.9.0-py39hbdeaff8_0.tar.bz2": { + "build": "py39hbdeaff8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b897417582f5fcb65ec119cb7ca3a0c", + "name": "spacy-alignments", + "sha256": "eca3d5645cd2010243326a3fcb288a222db435a49d499988bc0779a7b647284c", + "size": 1049314, + "subdir": "linux-64", + "timestamp": 1674249720838, + "version": "0.9.0" + }, + "spacy-legacy-3.0.9-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62c0cd4ae192f9e540228bf3b3a6ac71", + "name": "spacy-legacy", + "sha256": "3bf97fb09e56d973874f51fea19458da27cf6184f0e1d2dee5230f343a4797b8", + "size": 31868, + "subdir": "linux-64", + "timestamp": 1651648793241, + "version": "3.0.9" + }, + "spacy-legacy-3.0.9-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad265c89be8d1b38adf7000b446686ba", + "name": "spacy-legacy", + "sha256": "487b72e42d4d24b5048ae3306447f42b4809e7926dc28abbba3d5728576a904c", + "size": 40662, + "subdir": "linux-64", + "timestamp": 1676845848879, + "version": "3.0.9" + }, + "spacy-legacy-3.0.9-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9319483a105955ae19654c30a72f531f", + "name": "spacy-legacy", + "sha256": "fa00465a78056de5120804df3a8a563791713654fc278e8ffbb9c70a90bf5395", + "size": 31381, + "subdir": "linux-64", + "timestamp": 1651648843731, + "version": "3.0.9" + }, + "spacy-legacy-3.0.9-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2dac48fd15439ddb8df2efce83e38b3f", + "name": "spacy-legacy", + "sha256": "cf1e801d9e7a7e4c144191ebfe36be9124fad0f53a10e35840f837ef4e1a4e5e", + "size": 31600, + "subdir": "linux-64", + "timestamp": 1651648868032, + "version": "3.0.9" + }, + "spacy-legacy-3.0.9-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c10643b635a7ae7c4610d9d04414a137", + "name": "spacy-legacy", + "sha256": "00ae6f9c778266a1c8b2da13ad9d09adc86f60c568491b10770ba41bf3cdd378", + "size": 31633, + "subdir": "linux-64", + "timestamp": 1651648819081, + "version": "3.0.9" + }, + "spacy-transformers-1.1.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytorch >=1.6.0", + "spacy >=3.1.3,<4.0.0", + "spacy-alignments >=0.7.2,<1.0.0", + "srsly >=2.4.0,<3.0.0", + "transformers >=3.4.0,<4.19.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01c4b55a921fa7e699f6cf71ed87ee12", + "name": "spacy-transformers", + "sha256": "3cb1f8707358d0366d044fa1be63f8ece43a700b8d20e5e600d2a78f5fe3afc2", + "size": 77730, + "subdir": "linux-64", + "timestamp": 1651845980317, + "version": "1.1.5" + }, + "spacy-transformers-1.1.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytorch >=1.6.0", + "spacy >=3.1.3,<4.0.0", + "spacy-alignments >=0.7.2,<1.0.0", + "srsly >=2.4.0,<3.0.0", + "transformers >=3.4.0,<4.19.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a72fe1a956e286fac3aafc5fc82a593f", + "name": "spacy-transformers", + "sha256": "f536d3ca693cb63964877116c55a7801a0d837bad8ff03f7dccd53707b4f2d9f", + "size": 76744, + "subdir": "linux-64", + "timestamp": 1651845804193, + "version": "1.1.5" + }, + "spacy-transformers-1.1.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytorch >=1.6.0", + "spacy >=3.1.3,<4.0.0", + "spacy-alignments >=0.7.2,<1.0.0", + "srsly >=2.4.0,<3.0.0", + "transformers >=3.4.0,<4.19.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9aa2b938e3cbe8f14546553d567a60b", + "name": "spacy-transformers", + "sha256": "39f2dcf105f5cdf24b21626bfb3c57c64d713689ecd209a3ed11907c567a1c66", + "size": 76923, + "subdir": "linux-64", + "timestamp": 1651845646477, + "version": "1.1.5" + }, + "spacy-transformers-1.1.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytorch >=1.6.0", + "spacy >=3.1.3,<4.0.0", + "spacy-alignments >=0.7.2,<1.0.0", + "srsly >=2.4.0,<3.0.0", + "transformers >=3.4.0,<4.19.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d71e9d0f8b880ccd875223c7b806eac", + "name": "spacy-transformers", + "sha256": "f32e4c8a255f20f7ec33a31df47edf9ee78e932710b6926e82008653758e2c92", + "size": 77165, + "subdir": "linux-64", + "timestamp": 1651845447887, + "version": "1.1.5" + }, + "sparkmagic-0.12.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3d3d148bfce49f1eeae132c9809e98a9", + "name": "sparkmagic", + "sha256": "dd966b038be42c25a50a413d6e02f85129182a1070d00fccec9f4742c7b3129f", + "size": 64699, + "subdir": "linux-64", + "timestamp": 1531059496452, + "version": "0.12.5" + }, + "sparkmagic-0.12.5-py27h0acb2c8_0.tar.bz2": { + "build": "py27h0acb2c8_0", + "build_number": 0, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0570f9cb3e79cebc27679a452630426e", + "name": "sparkmagic", + "sha256": "803cc8cdc0dfe7346ca9440058ef5214af51af5a06929fc5f6b23a976485f4f7", + "size": 65003, + "subdir": "linux-64", + "timestamp": 1511317363484, + "version": "0.12.5" + }, + "sparkmagic-0.12.5-py35hb9a971e_0.tar.bz2": { + "build": "py35hb9a971e_0", + "build_number": 0, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.5,<3.6.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ff9616f5bc348f7285009d5b35d5a6fe", + "name": "sparkmagic", + "sha256": "00564efa2900fdcbd5af44b8ce55c09e1e4d7fb68e778f14403f443f79b3290e", + "size": 67245, + "subdir": "linux-64", + "timestamp": 1511317374325, + "version": "0.12.5" + }, + "sparkmagic-0.12.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "16b6345c7a8dbbf0e08f774aaaafff99", + "name": "sparkmagic", + "sha256": "1a4c2d701f32ed690e0f909dd5ecb4a1284b5db0a241236e0d8b28efe3a60792", + "size": 66729, + "subdir": "linux-64", + "timestamp": 1531059399433, + "version": "0.12.5" + }, + "sparkmagic-0.12.5-py36h8c657a7_0.tar.bz2": { + "build": "py36h8c657a7_0", + "build_number": 0, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4414cd2c2d6849708f611114d254a635", + "name": "sparkmagic", + "sha256": "1d7a5f3e07a1ec8ba6209ddccfd6186c66114c17ff4a056b915e06138eedbc27", + "size": 66991, + "subdir": "linux-64", + "timestamp": 1511317363166, + "version": "0.12.5" + }, + "sparkmagic-0.12.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6f5c8f6de41a41d7bb63d7e0c96918f5", + "name": "sparkmagic", + "sha256": "fd5553fe4da019163b98ac2e9bbff836e89125ad15b7a094159337099633bd26", + "size": 66854, + "subdir": "linux-64", + "timestamp": 1531059450065, + "version": "0.12.5" + }, + "sparkmagic-0.12.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "md5": "fcccf3af67fba764c3bb1951587a0ccf", + "name": "sparkmagic", + "sha256": "b5b4db8eeb445bec0be7b9d1b17d9057228c2a87657b7ff898560ab971b43a97", + "size": 64937, + "subdir": "linux-64", + "timestamp": 1539647665816, + "version": "0.12.6" + }, + "sparkmagic-0.12.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "md5": "ec9449e536990aa011b29b0471672909", + "name": "sparkmagic", + "sha256": "d1236266e41067dcc64b705a8ed2d75ea36657e7dfe6f0249a1e14dae7d8e34f", + "size": 66962, + "subdir": "linux-64", + "timestamp": 1539647688828, + "version": "0.12.6" + }, + "sparkmagic-0.12.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "md5": "1489f3d6acefc155f0bf7d8387257e77", + "name": "sparkmagic", + "sha256": "ea5890445784e54484ab4954e6e9932fc9ca0e4906de33772d39b155963f54db", + "size": 67160, + "subdir": "linux-64", + "timestamp": 1539647688563, + "version": "0.12.6" + }, + "sparkmagic-0.12.7-py27_1001.tar.bz2": { + "build": "py27_1001", + "build_number": 1001, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "md5": "350141e5e756ab35fb176f3bade22ed2", + "name": "sparkmagic", + "sha256": "733b857f8671d165d1f126d82c29ca787e144997a30f1678421ca1cbc113accf", + "size": 88466, + "subdir": "linux-64", + "timestamp": 1551473623651, + "version": "0.12.7" + }, + "sparkmagic-0.12.7-py27_1002.tar.bz2": { + "build": "py27_1002", + "build_number": 1002, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "md5": "2c02fddb4602c61338cf899cfa5ba52c", + "name": "sparkmagic", + "sha256": "6a32bae5db7f04309b4c640417e8c28876a4da365493f5f3440d6d4a245b9bff", + "size": 88819, + "subdir": "linux-64", + "timestamp": 1561070014501, + "version": "0.12.7" + }, + "sparkmagic-0.12.7-py36_1001.tar.bz2": { + "build": "py36_1001", + "build_number": 1001, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "md5": "18d0c8a5a2d50a51f5714e81ac44ac45", + "name": "sparkmagic", + "sha256": "c97ee7dbddfa097a3d59d4e9cf8191184dd26f3048e516b769e6271662e05cae", + "size": 90737, + "subdir": "linux-64", + "timestamp": 1551473616699, + "version": "0.12.7" + }, + "sparkmagic-0.12.7-py36_1002.tar.bz2": { + "build": "py36_1002", + "build_number": 1002, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "md5": "cc51c9e63eb87b1c51ed116f17eef71f", + "name": "sparkmagic", + "sha256": "5d742a8195f2ff32fd62c333e2e7105853c3a7601301e9ae4d98bf1d047d094e", + "size": 90862, + "subdir": "linux-64", + "timestamp": 1561070101808, + "version": "0.12.7" + }, + "sparkmagic-0.12.7-py37_1001.tar.bz2": { + "build": "py37_1001", + "build_number": 1001, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "md5": "00f3540bc18d8ddcfe820729cf806a3b", + "name": "sparkmagic", + "sha256": "6fc297d95c2b0bb095956cb46ad772db01c5a8ba76ae3fcc913bd35287e7ebff", + "size": 90971, + "subdir": "linux-64", + "timestamp": 1551473557092, + "version": "0.12.7" + }, + "sparkmagic-0.12.7-py37_1002.tar.bz2": { + "build": "py37_1002", + "build_number": 1002, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "md5": "1d4fcf1e3859abf905ea9a3fde4ede5c", + "name": "sparkmagic", + "sha256": "43b1f3e15038e3283f85343c77e43705619c329e4103faed3c3b588593a80cbf", + "size": 91174, + "subdir": "linux-64", + "timestamp": 1561070018387, + "version": "0.12.7" + }, + "sparkmagic-0.20.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.10,<3.11.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "75088de7c09a462c2afed5420f5f7513", + "name": "sparkmagic", + "sha256": "6bd9e6fde3d251874b05d794f0aefa6ca631604fa8912e994cd0278cbe9f259f", + "size": 114878, + "subdir": "linux-64", + "timestamp": 1663060889039, + "version": "0.20.0" + }, + "sparkmagic-0.20.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.10,<3.11.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "adc42ac2af2e3c1db7ac69724a6278c2", + "name": "sparkmagic", + "sha256": "a69e9ba5683163a6ed7434d417fd967ea8548311b25b8ac8fa38417a54417cd2", + "size": 114866, + "subdir": "linux-64", + "timestamp": 1663085254477, + "version": "0.20.0" + }, + "sparkmagic-0.20.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.11,<3.12.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0effa2b5ee477eec8f36ef2a1b5f04d3", + "name": "sparkmagic", + "sha256": "cacaaf60a3d17f9e48da786b8bab51e03ed3cc39fd36911afa2a5c6e3398645b", + "size": 141578, + "subdir": "linux-64", + "timestamp": 1677697569939, + "version": "0.20.0" + }, + "sparkmagic-0.20.0-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.11,<3.12.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "86045eb0ebe05740837d0fd372208b0a", + "name": "sparkmagic", + "sha256": "472894ec122e9c359299095f08ea256e072663fe2a05e713bc95e64ba2a3df2b", + "size": 141644, + "subdir": "linux-64", + "timestamp": 1679339203925, + "version": "0.20.0" + }, + "sparkmagic-0.20.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.7,<3.8.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a9a7209783e7f16a6a2b5902e05adf1b", + "name": "sparkmagic", + "sha256": "1131db4ff77175a5d0af12089cc258af7e201e419ebfb04484a5eebed5f67fc5", + "size": 113672, + "subdir": "linux-64", + "timestamp": 1663060957546, + "version": "0.20.0" + }, + "sparkmagic-0.20.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.7,<3.8.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d3062381061b6fd84a0ad928c4df54d8", + "name": "sparkmagic", + "sha256": "c37170601b68cab47512294854b019966761d8d244d6b0ba0d8a84e5f2084ebc", + "size": 113578, + "subdir": "linux-64", + "timestamp": 1663085493331, + "version": "0.20.0" + }, + "sparkmagic-0.20.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.8,<3.9.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "82a85272d0f9139362664357223d7fce", + "name": "sparkmagic", + "sha256": "a86906b32b2a7270fc6cea6927d3ccde4dcceeb5efefa497bc568ebef2d3529a", + "size": 114347, + "subdir": "linux-64", + "timestamp": 1663060802652, + "version": "0.20.0" + }, + "sparkmagic-0.20.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.8,<3.9.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9bff2b19fe63d3fbdd6378280ad8fc80", + "name": "sparkmagic", + "sha256": "a652f18b6bf4e61152bf6f310e747bcd9455bcbc41bcdf87dcfbf9ccc446c264", + "size": 114328, + "subdir": "linux-64", + "timestamp": 1663085348601, + "version": "0.20.0" + }, + "sparkmagic-0.20.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.9,<3.10.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c848a397d1b63c8ae15f079e11f1d829", + "name": "sparkmagic", + "sha256": "0ee7abdf779de4ec127165ff187c655cea6c27fe4491fedfcd4bb9542c563d3d", + "size": 114309, + "subdir": "linux-64", + "timestamp": 1663061027908, + "version": "0.20.0" + }, + "sparkmagic-0.20.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.9,<3.10.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "13bdcad1a7267a4325ef3daa31575d18", + "name": "sparkmagic", + "sha256": "20bed81eef25ce40fcc3915c7428e4f31861bc56885899a09e93de8da2712fc0", + "size": 114289, + "subdir": "linux-64", + "timestamp": 1663085419122, + "version": "0.20.0" + }, + "spdlog-1.11.0-hdb19cb5_0.tar.bz2": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5d82919cbc4866c3fc037bae9c775bf", + "name": "spdlog", + "sha256": "ea9d5e904f772efe2aa4822297e5ae2678eca063449ca9d888c0ac9ba6927eae", + "size": 246370, + "subdir": "linux-64", + "timestamp": 1676361400180, + "version": "1.11.0" + }, + "spdlog-1.8.0-hfd86e86_1.tar.bz2": { + "build": "hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c4a051aaad3cc0f09cffc97d0da85bd", + "name": "spdlog", + "sha256": "67dc77c0c670bc370cf4f45d007cb3ecaa06527c466af2471c3cbf619671f9e9", + "size": 1473093, + "subdir": "linux-64", + "timestamp": 1600695090058, + "version": "1.8.0" + }, + "spdlog-1.8.1-h7739ffd_0.tar.bz2": { + "build": "h7739ffd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4325a3645a598233510a7c75c16b30d", + "name": "spdlog", + "sha256": "a44af419736a0975654bc894859a9ac82cc69402f43b8fff38fabe4747194dbe", + "size": 327210, + "subdir": "linux-64", + "timestamp": 1603921386766, + "version": "1.8.1" + }, + "spdlog-1.8.2-hff7bd54_0.tar.bz2": { + "build": "hff7bd54_0", + "build_number": 0, + "depends": [ + "fmt >=7.1.3,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95c870d9b5400b20dac9b237a80db369", + "name": "spdlog", + "sha256": "6ed4e679bb4f7e77699ecd3752ae894b917131140c83c5ad35e436955062daa9", + "size": 175114, + "subdir": "linux-64", + "timestamp": 1608225075884, + "version": "1.8.2" + }, + "spdlog-1.9.0-hd09550d_0.tar.bz2": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "fmt >=7.1.3,<8.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "76356868040741ef82c675f76a2d9041", + "name": "spdlog", + "sha256": "c2f9a3c1857597e306ac7d14a6ee17acf0b3cefd2e510c8d44c4435714cb1081", + "size": 180020, + "subdir": "linux-64", + "timestamp": 1626867794353, + "version": "1.9.0" + }, + "spdlog-1.9.2-hd09550d_0.tar.bz2": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "fmt >=8.1.1,<9.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49c6d33598be3f20af1e6ae226c9261e", + "name": "spdlog", + "sha256": "f3af6d3c808b1a7b6f14ec4eb7e44b7f7451417d57740cba0daa0ed02b30a300", + "size": 216607, + "subdir": "linux-64", + "timestamp": 1646908211737, + "version": "1.9.2" + }, + "spdlog-fmt-embed-1.11.0-hdb19cb5_0.tar.bz2": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "028903fc99cac6a448d9c31912760d23", + "name": "spdlog-fmt-embed", + "sha256": "5f3bb6728806a85c8163026261412377a675b9ae3ec7997fa12df49371ef8767", + "size": 359600, + "subdir": "linux-64", + "timestamp": 1676361466975, + "version": "1.11.0" + }, + "spdlog-fmt-embed-1.9.2-hd09550d_0.tar.bz2": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8af6595b7fa30fcaf5e2d9bd347f19c", + "name": "spdlog-fmt-embed", + "sha256": "e95ea327e43c4a8816e144a42a3b4b59530b005fcca3518a29ead9eed84cdf8d", + "size": 345403, + "subdir": "linux-64", + "timestamp": 1646908251183, + "version": "1.9.2" + }, + "sphinx-1.6.3-py27hf9b1778_0.tar.bz2": { + "build": "py27hf9b1778_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "pygments", + "python >=2.7,<2.8.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "c34403196d3a728642556f1bfb4860c7", + "name": "sphinx", + "sha256": "819a74c3d705a63dd8cc59e7ba0382d5da9dbe6ea7d392cd62c17b6eb0bb57e7", + "size": 1647266, + "subdir": "linux-64", + "timestamp": 1505746965605, + "version": "1.6.3" + }, + "sphinx-1.6.3-py35hea25a1c_0.tar.bz2": { + "build": "py35hea25a1c_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "pygments", + "python >=3.5,<3.6.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "a3624f35e08ed86876278693e0a22424", + "name": "sphinx", + "sha256": "5efc1fc2bb0c3130b2ef2325e3923646872f5a45ac32fb500575f72e2b010729", + "size": 1659240, + "subdir": "linux-64", + "timestamp": 1505746998826, + "version": "1.6.3" + }, + "sphinx-1.6.3-py36he5f0bdb_0.tar.bz2": { + "build": "py36he5f0bdb_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "e85cbb67e02e26e665ada06ba9ae9f1f", + "name": "sphinx", + "sha256": "4cd7d5fb7cff3165f176f1944028e03eb15fe1012824463114b926cc7a701893", + "size": 1646492, + "subdir": "linux-64", + "timestamp": 1505747033382, + "version": "1.6.3" + }, + "sphinx-1.6.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "pygments", + "python >=2.7,<2.8.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "2505baa6969cc3dfea1fe943b604b3f7", + "name": "sphinx", + "sha256": "b9ec8feda11f4440ae2b5ca2df2e2f481dcbd8720e80d0beed54df263fe2cff6", + "size": 1655221, + "subdir": "linux-64", + "timestamp": 1515725005345, + "version": "1.6.6" + }, + "sphinx-1.6.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "pygments", + "python >=3.5,<3.6.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "bbefe67320c4938cb3e7e99c3c4d1f25", + "name": "sphinx", + "sha256": "2526dddd8c7a777e7f2342a3c4e3bb69fa940c889536d89161cf476bbf934724", + "size": 1664224, + "subdir": "linux-64", + "timestamp": 1515725279669, + "version": "1.6.6" + }, + "sphinx-1.6.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "8db8abacd97148c5d32d9706b1dd0e53", + "name": "sphinx", + "sha256": "acdffc2f5125345c3b79597f401eba37064290adf782b3f60cd116718f13f394", + "size": 1655830, + "subdir": "linux-64", + "timestamp": 1515725330989, + "version": "1.6.6" + }, + "sphinx-1.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=2.7,<2.8.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "d145374dc58ef81e7efdd5941d8baf28", + "name": "sphinx", + "sha256": "3f07e243df7068059879a1d9b3c1ebae4b576c9a51a4fa633eda5528d3e900fd", + "size": 1629109, + "subdir": "linux-64", + "timestamp": 1519140274911, + "version": "1.7.0" + }, + "sphinx-1.7.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.5,<3.6.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "0002aaa0c4e3e67e9607197b06af2650", + "name": "sphinx", + "sha256": "8f44f00eb56a72f757005d9ee0f47437ab107bd92336ebcdd058f6c0d60277c5", + "size": 1664979, + "subdir": "linux-64", + "timestamp": 1519140322607, + "version": "1.7.0" + }, + "sphinx-1.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "d297d6859617b138745f6daf1bd73ee2", + "name": "sphinx", + "sha256": "4c0c60b55662067c353cc6e6d5fd41f3c1e68695014731ef26536fde1d688880", + "size": 1635953, + "subdir": "linux-64", + "timestamp": 1519140322167, + "version": "1.7.0" + }, + "sphinx-1.7.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=2.7,<2.8.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "89aaec372bf54aa810864ed598fffe36", + "name": "sphinx", + "sha256": "7447334eb57888c870215208a44c95d3cad2a09b145b3457a0bd4b1d8419b27a", + "size": 1634284, + "subdir": "linux-64", + "timestamp": 1519747892013, + "version": "1.7.1" + }, + "sphinx-1.7.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.5,<3.6.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "c55ab5c36835505d756bf96f9566c5d7", + "name": "sphinx", + "sha256": "14d0f8edc14edb19cb730b77b0f59b1d319f2d8a440ef1c6a77c449e6d1c7f39", + "size": 1674380, + "subdir": "linux-64", + "timestamp": 1519747909735, + "version": "1.7.1" + }, + "sphinx-1.7.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "50e8d16fa9357576403d6237fca57fe8", + "name": "sphinx", + "sha256": "4ccb406d746c3905906bbad8d171b50ae20119924c9084dc199a3c70264a23ee", + "size": 1648212, + "subdir": "linux-64", + "timestamp": 1519747903846, + "version": "1.7.1" + }, + "sphinx-1.7.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=2.7,<2.8.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "8087b98d1e58c7103d86784e609c1a79", + "name": "sphinx", + "sha256": "2cfdd22c2f2948638187e037a1c0bfb83a70ba241964482270ce18ec79b9b781", + "size": 1630706, + "subdir": "linux-64", + "timestamp": 1522187132173, + "version": "1.7.2" + }, + "sphinx-1.7.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.5,<3.6.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "6e3d4147b4a43944dde67c8b5bd5f4a3", + "name": "sphinx", + "sha256": "7b3315072d1470e90f783adf1eab31137c0427e0477b3333a342ec6522895ece", + "size": 1663807, + "subdir": "linux-64", + "timestamp": 1522187154415, + "version": "1.7.2" + }, + "sphinx-1.7.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "934e80a914d7799e4cb30eb61bf4929f", + "name": "sphinx", + "sha256": "6fac042e6f9be8afdad44b0140c6d46b5fe55076bf5b1a303454ce4f84f113ca", + "size": 1639300, + "subdir": "linux-64", + "timestamp": 1522187115767, + "version": "1.7.2" + }, + "sphinx-1.7.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=2.7,<2.8.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "5c449a0af2f8fbe4003a947233e4aced", + "name": "sphinx", + "sha256": "f63d5e04b11be49698b69907c6c2fbd17d2a797e719e00e6be75372bfe287156", + "size": 1632759, + "subdir": "linux-64", + "timestamp": 1524496963197, + "version": "1.7.3" + }, + "sphinx-1.7.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.5,<3.6.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "fd20cf54bc81d65112747fd8a3263d3c", + "name": "sphinx", + "sha256": "1e7c1f126c79dacd039911cccd047fa3a5fc6f17eda4a6dbf5c699ac7e026879", + "size": 1667815, + "subdir": "linux-64", + "timestamp": 1524496969376, + "version": "1.7.3" + }, + "sphinx-1.7.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "6e7298657fae142e9f5309be07b1ed1a", + "name": "sphinx", + "sha256": "7293fedb6acb74b34b07a6c4538951e9f546445a0be8b80883cfc60247e69857", + "size": 1644840, + "subdir": "linux-64", + "timestamp": 1524496984919, + "version": "1.7.3" + }, + "sphinx-1.7.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=2.7,<2.8.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "f460a8beddc3c8d888bf302857b533a9", + "name": "sphinx", + "sha256": "51512110df2c3b7653edaebcd3b06dd3f5ef883187c940c29ecf781361fb8614", + "size": 1632768, + "subdir": "linux-64", + "timestamp": 1525119308004, + "version": "1.7.4" + }, + "sphinx-1.7.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.5,<3.6.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "df6d38c62cfb501dd22265f7c3ec6241", + "name": "sphinx", + "sha256": "5f9678fa0c006f2686a759daec9965d8282544df01182581e2e6de9ff766bc36", + "size": 1668247, + "subdir": "linux-64", + "timestamp": 1525119324042, + "version": "1.7.4" + }, + "sphinx-1.7.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "1415406fe12d3ddcdde53ca70c4ce744", + "name": "sphinx", + "sha256": "7de5521cc4ebe1c030f6890faf7ff8adc2333fc723fb7b86ffbf11016c51be2e", + "size": 1644905, + "subdir": "linux-64", + "timestamp": 1525119213042, + "version": "1.7.4" + }, + "sphinx-1.7.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >2.0", + "python >=2.7,<2.8.0a0", + "requests >2.0.0", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "c0a11d4b02430aedf1ec482edbb5d123", + "name": "sphinx", + "sha256": "07f316005787efb835725db8624574081aa4e0ae8cbab6514125adde6b18446c", + "size": 1635334, + "subdir": "linux-64", + "timestamp": 1527875800407, + "version": "1.7.5" + }, + "sphinx-1.7.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >2.0", + "python >=3.5,<3.6.0a0", + "requests >2.0.0", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "e34888d7cc0fa3fda2123b3dbe8526ff", + "name": "sphinx", + "sha256": "af2c6e440adefa1a93838ee165e76572f5fb07a38dfd58ba77dfd6a7a67e5274", + "size": 1667739, + "subdir": "linux-64", + "timestamp": 1527875805729, + "version": "1.7.5" + }, + "sphinx-1.7.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >2.0", + "python >=3.6,<3.7.0a0", + "requests >2.0.0", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "4b87c024fb1c8000c688afcf05f9314c", + "name": "sphinx", + "sha256": "f04ed44a69e838cc32a8e06387d11387fa487a0bf8d2cee31e7d2d5a12f3758d", + "size": 1648890, + "subdir": "linux-64", + "timestamp": 1527875736544, + "version": "1.7.5" + }, + "sphinx-1.7.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >2.0", + "python >=3.7,<3.8.0a0", + "requests >2.0.0", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "58fc2c333508df86cce01f8348ce492b", + "name": "sphinx", + "sha256": "b4b4bdc31f49c720ac4acac84c1485a77cdf04871b54a53a79da467004829b76", + "size": 1648035, + "subdir": "linux-64", + "timestamp": 1530733620621, + "version": "1.7.5" + }, + "sphinx-1.7.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >2.0", + "python >=2.7,<2.8.0a0", + "requests >2.0.0", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "366e1db252d0998f77b50486e02dc0de", + "name": "sphinx", + "sha256": "c0cc0092e5cc270a727c327c91eb57317f9c2666354ff2c085969c46dfc5a1ab", + "size": 1636445, + "subdir": "linux-64", + "timestamp": 1532452325113, + "version": "1.7.6" + }, + "sphinx-1.7.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >2.0", + "python >=3.5,<3.6.0a0", + "requests >2.0.0", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "fa349f16709fb631d398328672e901d2", + "name": "sphinx", + "sha256": "cebe9de572750fea64f46bb6b2c896635f705a2981fdd4705131cbde895f4825", + "size": 1673024, + "subdir": "linux-64", + "timestamp": 1532452374809, + "version": "1.7.6" + }, + "sphinx-1.7.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >2.0", + "python >=3.6,<3.7.0a0", + "requests >2.0.0", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "46f222b84a73395e6c74d4ba2c490b53", + "name": "sphinx", + "sha256": "22b847fa1b9e9603904aaf38ecfb45c1cd62057370ec397b9f0fae03edd7b2b8", + "size": 1651137, + "subdir": "linux-64", + "timestamp": 1532455792792, + "version": "1.7.6" + }, + "sphinx-1.7.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >2.0", + "python >=3.7,<3.8.0a0", + "requests >2.0.0", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "a196e82dad8c91621d9d15989e357be3", + "name": "sphinx", + "sha256": "9466bede99e69b0df4e61459c239d98dd39808066a56422ed12eee037e7c23e1", + "size": 1648886, + "subdir": "linux-64", + "timestamp": 1532452263449, + "version": "1.7.6" + }, + "sphinx-1.7.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "3f1bbd81c7a213d34b9abe5d9c54ee8b", + "name": "sphinx", + "sha256": "319908707617a76806045a8fe70a4dfbe3a4eb11fd8e6ec747909f99f6ef7ee4", + "size": 1637752, + "subdir": "linux-64", + "timestamp": 1534947948433, + "version": "1.7.7" + }, + "sphinx-1.7.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "062a676d44d2559c433aef8b9ab11ec4", + "name": "sphinx", + "sha256": "a00703aad5b0a18fedcd9d45a6085c9ede2078270fa736fc336dd61e239b0ed2", + "size": 1675457, + "subdir": "linux-64", + "timestamp": 1534947982063, + "version": "1.7.7" + }, + "sphinx-1.7.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "4f9358120d2b16ad47657025cc5afbde", + "name": "sphinx", + "sha256": "b9b3215c45c34c80f4d450d149a596da621daff217adcfa77ec1275b0e0bb96a", + "size": 1651891, + "subdir": "linux-64", + "timestamp": 1534947821762, + "version": "1.7.7" + }, + "sphinx-1.7.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "3c31e1727192a0b38e0a5e57fac76002", + "name": "sphinx", + "sha256": "e8a34362152617f71b7c42ef03dbb878f94e6114f015e687dcea8fadd87cc382", + "size": 1651414, + "subdir": "linux-64", + "timestamp": 1534947867990, + "version": "1.7.7" + }, + "sphinx-1.7.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "a381cf2668d2033467db8c677da0c0e4", + "name": "sphinx", + "sha256": "7a2802aad25548b57e39194d5152da91eb069a7438b97c14080f001bec157771", + "size": 1638265, + "subdir": "linux-64", + "timestamp": 1536076407539, + "version": "1.7.8" + }, + "sphinx-1.7.8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "6ff3d59efd0abc4fb6d21985f99beeb3", + "name": "sphinx", + "sha256": "f9f767d66a65fd7628c7755c4d23510171d600bdd1ccae69de3487ae2c522eb5", + "size": 1675586, + "subdir": "linux-64", + "timestamp": 1536076407907, + "version": "1.7.8" + }, + "sphinx-1.7.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "d68f04a23a4a662f82922e785c64370c", + "name": "sphinx", + "sha256": "4c59c244cda88e15b496368979713c161a8c589b707a46ee27f550fd67b0bcbe", + "size": 1652542, + "subdir": "linux-64", + "timestamp": 1536076424744, + "version": "1.7.8" + }, + "sphinx-1.7.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "d7410bb54ccbb4859eed3e4c6c876690", + "name": "sphinx", + "sha256": "1fd327a2d3fc3a3d7f2238f13b1f4167c337e9301f04e7078750d501cae75c45", + "size": 1650053, + "subdir": "linux-64", + "timestamp": 1536076413861, + "version": "1.7.8" + }, + "sphinx-1.7.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "3936e45c870ac1b5110ac6be86210386", + "name": "sphinx", + "sha256": "513c34dac65c98209ffa6a921ee809cbb7826ada3e5580898119dce53ed20026", + "size": 1637317, + "subdir": "linux-64", + "timestamp": 1536696742509, + "version": "1.7.9" + }, + "sphinx-1.7.9-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "eec616013f4d07062f185cb7a24601f7", + "name": "sphinx", + "sha256": "f7addd42e3e1a4bacffa3ca5dd00b90f4570a393a42429b6c1fa25829b0c5dbf", + "size": 1675107, + "subdir": "linux-64", + "timestamp": 1536696765089, + "version": "1.7.9" + }, + "sphinx-1.7.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "796abb8b67e70826fac173e60b5b7a7b", + "name": "sphinx", + "sha256": "6bad7576fbdc3ac235a6014ef6e905c036a477efd76c4a93c9e6363084cc51df", + "size": 1653041, + "subdir": "linux-64", + "timestamp": 1536696781157, + "version": "1.7.9" + }, + "sphinx-1.7.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "fa03abdf1fdd6cc77942ef40176d6022", + "name": "sphinx", + "sha256": "a69e432b99bbf982548f884ce795996c22c26dfb717fae3db317458178508551", + "size": 1651801, + "subdir": "linux-64", + "timestamp": 1536696742509, + "version": "1.7.9" + }, + "sphinx-1.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "fd2c194a60bd703f557835e71bc3fff6", + "name": "sphinx", + "sha256": "24419183fbebab8e08cb44af4acaa87fd9171494833ecbd7227270de93256776", + "size": 1977425, + "subdir": "linux-64", + "timestamp": 1538161600697, + "version": "1.8.1" + }, + "sphinx-1.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "c2a720fca05d875dff715cf8bc16662b", + "name": "sphinx", + "sha256": "7edbc7f07ea95dba50454eab02ec48c1cab4d3b8c09c631236414fd4321b02e0", + "size": 2007152, + "subdir": "linux-64", + "timestamp": 1538161583212, + "version": "1.8.1" + }, + "sphinx-1.8.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "f11e8c23a3254f5981bba55155c982f9", + "name": "sphinx", + "sha256": "b42776a0ea0969554a4018a853d8ecf2a55daf95185907c818c585db1de36ce2", + "size": 2005087, + "subdir": "linux-64", + "timestamp": 1538161604812, + "version": "1.8.1" + }, + "sphinx-1.8.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "b0730f87a8df148de7d9bc3eabfa16ef", + "name": "sphinx", + "sha256": "d5b6516ab2cb651b2c7302a752263b5bd52c359d9e42152eb549ac0ca409ae62", + "size": 1942574, + "subdir": "linux-64", + "timestamp": 1542090000010, + "version": "1.8.2" + }, + "sphinx-1.8.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "ccbdd2b99d360ac96600e10fad6bb91b", + "name": "sphinx", + "sha256": "5846e34b82216eff20f1b2d10df7e1be4b12cf106be8b33a6d2fcd767eabd006", + "size": 1953350, + "subdir": "linux-64", + "timestamp": 1542089993914, + "version": "1.8.2" + }, + "sphinx-1.8.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "764d72448c65e3218ffd6c4706c6cfd2", + "name": "sphinx", + "sha256": "bc441ef3217a89886d314be009e177f555cc414bed0b1b529dad94eb92ed9093", + "size": 1931948, + "subdir": "linux-64", + "timestamp": 1542089955340, + "version": "1.8.2" + }, + "sphinx-1.8.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "cb7b581125ecb679f8534deaf9846ace", + "name": "sphinx", + "sha256": "427941fec977c8cca08413c769b41d0a747cdc10f4f254ded9f5fc9a88e13f6f", + "size": 1942822, + "subdir": "linux-64", + "timestamp": 1549326409676, + "version": "1.8.4" + }, + "sphinx-1.8.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "a8f997804b19cbcc20062019fb8baaf7", + "name": "sphinx", + "sha256": "e8e41ad4ea67417a944a058a8ce6fecc40b612e75142041225248bdc48387465", + "size": 1942408, + "subdir": "linux-64", + "timestamp": 1549326464543, + "version": "1.8.4" + }, + "sphinx-1.8.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "d0ddb1c00e7fa5b78630ca7c8880c2ba", + "name": "sphinx", + "sha256": "df38bb739366835d18b2470aa0f13f7ff5c16dac3e5f7bbad489a32a8c34e27e", + "size": 1952984, + "subdir": "linux-64", + "timestamp": 1549326428772, + "version": "1.8.4" + }, + "sphinx-1.8.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "082aacac00b79a606babce56247f48cb", + "name": "sphinx", + "sha256": "f8e4d4153a91585fa0f0bc5e911876ee33afeab8d776c494063df55d379b91d1", + "size": 1944315, + "subdir": "linux-64", + "timestamp": 1552326249875, + "version": "1.8.5" + }, + "sphinx-1.8.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "14c2e39f70106bf75e3ec16c2f705c56", + "name": "sphinx", + "sha256": "6906d4c52ef58d27b627966c0ff3462cfddff65a333500f817313ac6a5f2f569", + "size": 1975301, + "subdir": "linux-64", + "timestamp": 1552326302183, + "version": "1.8.5" + }, + "sphinx-1.8.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "ba2fab25db607784461bb02847d5421d", + "name": "sphinx", + "sha256": "d85035c710f4c46dc7ae7adf8ada9f09dc55f4d071dbd34faa69377daf917b16", + "size": 1947744, + "subdir": "linux-64", + "timestamp": 1552326280923, + "version": "1.8.5" + }, + "sphinx-5.0.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3", + "colorama >=0.3.5", + "docutils >=0.14,<0.19", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.10,<3.11.0a0", + "requests >=2.5.0", + "snowballstemmer >=1.1", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp >=2.0.0", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml >=1.1.5" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "95142dfa9299459a8894327564b62b04", + "name": "sphinx", + "sha256": "0d41a225d4c65d38dd2e1fe2f40ea24e98acf9dbe79cf4a6700869048cce2483", + "size": 2272910, + "subdir": "linux-64", + "timestamp": 1657784175183, + "version": "5.0.2" + }, + "sphinx-5.0.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3", + "colorama >=0.3.5", + "docutils >=0.14,<0.19", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.11,<3.12.0a0", + "requests >=2.5.0", + "snowballstemmer >=1.1", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp >=2.0.0", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml >=1.1.5" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "366db7b1f3a1ca89e087506096615934", + "name": "sphinx", + "sha256": "20ce47c7273ed6bef4e02b8f7bf99a04592243ca6b628404f37cd29aabb109c7", + "size": 2669900, + "subdir": "linux-64", + "timestamp": 1676842881763, + "version": "5.0.2" + }, + "sphinx-5.0.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3", + "colorama >=0.3.5", + "docutils >=0.14,<0.19", + "imagesize", + "importlib-metadata >=4.4", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.5.0", + "snowballstemmer >=1.1", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp >=2.0.0", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml >=1.1.5" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "700243a8c83092357084e8cb3a356102", + "name": "sphinx", + "sha256": "31bddfc0918318e3459ecaaf0926b816606a4d81d54ab977344394725539fab9", + "size": 2251452, + "subdir": "linux-64", + "timestamp": 1657784218874, + "version": "5.0.2" + }, + "sphinx-5.0.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3", + "colorama >=0.3.5", + "docutils >=0.14,<0.19", + "imagesize", + "importlib-metadata >=4.4", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.5.0", + "snowballstemmer >=1.1", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp >=2.0.0", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml >=1.1.5" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a1b54495330cdea1aef288ce15365944", + "name": "sphinx", + "sha256": "836c36b24e523a1ffd1a3a5116bd9b96608adad75270e36e17bd8a2b02a7a17c", + "size": 2252276, + "subdir": "linux-64", + "timestamp": 1657784304555, + "version": "5.0.2" + }, + "sphinx-5.0.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3", + "colorama >=0.3.5", + "docutils >=0.14,<0.19", + "imagesize", + "importlib-metadata >=4.4", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.5.0", + "snowballstemmer >=1.1", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp >=2.0.0", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml >=1.1.5" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8e4702297b761c5988b0a93df5c23719", + "name": "sphinx", + "sha256": "3112a79e831c50472e88a6b3de706399077817712de2f0fdb138265d3804b198", + "size": 2248091, + "subdir": "linux-64", + "timestamp": 1657784262535, + "version": "5.0.2" + }, + "sphinx_rtd_theme-0.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "0fd7b8a1f68937200be31adac2a64926", + "name": "sphinx_rtd_theme", + "sha256": "796819302d7f402e7d6323411a4da32936ac62d44edeef938f5dc407e57b98f2", + "size": 2017412, + "subdir": "linux-64", + "timestamp": 1523999323417, + "version": "0.3.0" + }, + "sphinx_rtd_theme-0.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "d994c3096fa0ae0b83f5ee85970402bf", + "name": "sphinx_rtd_theme", + "sha256": "b7bb58cd3dee065b3fd985bf77fbc8dadb8b4a0874427fb055ec9ea791e88bc7", + "size": 2017302, + "subdir": "linux-64", + "timestamp": 1523999330741, + "version": "0.3.0" + }, + "sphinx_rtd_theme-0.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9937641fb6db9d88a39773fb187753a8", + "name": "sphinx_rtd_theme", + "sha256": "d5b8184c9b8dd66c11eb86195ecc7bad97a149c089c469e43d6672bcf2d140f5", + "size": 2017322, + "subdir": "linux-64", + "timestamp": 1523999386693, + "version": "0.3.0" + }, + "sphinx_rtd_theme-0.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "74c3dc161d22f2139d093fe8dea86d25", + "name": "sphinx_rtd_theme", + "sha256": "012c64fac28607e9de79a61bc4fa791a7264be1c389ffc255284d5f2851a501a", + "size": 2017006, + "subdir": "linux-64", + "timestamp": 1526918172887, + "version": "0.3.1" + }, + "sphinx_rtd_theme-0.3.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "78195f699f3e04c75f68b1bf848908c9", + "name": "sphinx_rtd_theme", + "sha256": "f104a2429ac471a44b01dee76134f2168624f161051a0b5664d48dd7eec75fc6", + "size": 2017236, + "subdir": "linux-64", + "timestamp": 1526918163228, + "version": "0.3.1" + }, + "sphinx_rtd_theme-0.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a55832b10132147e9e62c1754ad9bc00", + "name": "sphinx_rtd_theme", + "sha256": "3a7ebf45dbbda2bcbf302d949201fe0e381c6d21870db189b68b3c22b1b94330", + "size": 2017234, + "subdir": "linux-64", + "timestamp": 1526918160693, + "version": "0.3.1" + }, + "sphinx_rtd_theme-0.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "0b973f3a91711ce99de3801ccddacaf1", + "name": "sphinx_rtd_theme", + "sha256": "966355c2e5497c08895c10f45a92e47fc80d26261b57a3a5d7904ccf9c730567", + "size": 5324950, + "subdir": "linux-64", + "timestamp": 1528984088041, + "version": "0.4.0" + }, + "sphinx_rtd_theme-0.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "abd350dfddc09c18ce08a436eb080a7f", + "name": "sphinx_rtd_theme", + "sha256": "85dc1bb3f639afc844ca7f63ae4a6d5d9c99f15d88fdfdaad9f988e726f4591b", + "size": 5325851, + "subdir": "linux-64", + "timestamp": 1528983901133, + "version": "0.4.0" + }, + "sphinx_rtd_theme-0.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9ce85283ccc2690cc7ab997798879932", + "name": "sphinx_rtd_theme", + "sha256": "c5fbd50ba08e5538e551ed5a6aa105f2bb4b203b4d5503af2a0c7b52a78e6f99", + "size": 5325109, + "subdir": "linux-64", + "timestamp": 1528983869462, + "version": "0.4.0" + }, + "sphinx_rtd_theme-0.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "949fb2b7d43b3332d1a15a402ebe2e9a", + "name": "sphinx_rtd_theme", + "sha256": "ff2d803dd993b8ed892c33064b6b87d7f307c27ae1727cd558410f6b57930f94", + "size": 5324493, + "subdir": "linux-64", + "timestamp": 1531059543521, + "version": "0.4.0" + }, + "sphinx_rtd_theme-0.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "4f8fb4e93d5b3b7ee561cce6b7c68617", + "name": "sphinx_rtd_theme", + "sha256": "963d86ca625461262e6a76e327d54cbefdbd479ee90feb00f522941dc3e3130a", + "size": 5324333, + "subdir": "linux-64", + "timestamp": 1532998146640, + "version": "0.4.1" + }, + "sphinx_rtd_theme-0.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "f6c8997e6a585b3103dde730d84d0a10", + "name": "sphinx_rtd_theme", + "sha256": "66284b89887cfcdc7f78608d356ac153a0c7d7c273862da3abc0eeb606be6802", + "size": 5324489, + "subdir": "linux-64", + "timestamp": 1532998115897, + "version": "0.4.1" + }, + "sphinx_rtd_theme-0.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3e56fef2218e1b8556bcadb69496a369", + "name": "sphinx_rtd_theme", + "sha256": "6e7e7d2871b8aae8f0c87ff791d3151dcbe2ffd95fa9a56767687d93df748db8", + "size": 5324066, + "subdir": "linux-64", + "timestamp": 1532998084872, + "version": "0.4.1" + }, + "sphinx_rtd_theme-0.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1d97ca9b6d486c4571af5c819d77b063", + "name": "sphinx_rtd_theme", + "sha256": "5526796086cfa390cf593f5ae7d9aa1332274833b26b94a1a1f4ead5b00c45c8", + "size": 5324458, + "subdir": "linux-64", + "timestamp": 1532998158818, + "version": "0.4.1" + }, + "sphinx_rtd_theme-0.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "300b12443aac37b76aa734eec0d3a82e", + "name": "sphinx_rtd_theme", + "sha256": "84c60e4173e06b433a2c4d1d7df4f3b2069cd1e6c3289ed463f9ececa291c113", + "size": 5324510, + "subdir": "linux-64", + "timestamp": 1539638374495, + "version": "0.4.2" + }, + "sphinx_rtd_theme-0.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c96b1880dee99a36c7ec92f8ec187cd5", + "name": "sphinx_rtd_theme", + "sha256": "0ea66cad95a2c0f6f0da126fe1018e3f29de5c6f99eb3ba0386ad7d2c0a1b546", + "size": 5323749, + "subdir": "linux-64", + "timestamp": 1539638390690, + "version": "0.4.2" + }, + "sphinx_rtd_theme-0.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "9152b47d83da3c7e4ba46a6e67556bd8", + "name": "sphinx_rtd_theme", + "sha256": "8203ed350014fd64903e36a95b0f456cecd8eef18a6d1e0f2f88e0f0772acee0", + "size": 5324047, + "subdir": "linux-64", + "timestamp": 1539638396017, + "version": "0.4.2" + }, + "sphinxcontrib-1.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "5f602e5cd34424c10b296ef0e6ce1016", + "name": "sphinxcontrib", + "sha256": "0a1f1001f6711c7bccb28fe87b9aedb34f0afde7778437698f943842fd4e4eff", + "size": 3323, + "subdir": "linux-64", + "timestamp": 1530694859730, + "version": "1.0" + }, + "sphinxcontrib-1.0-py27h1512b58_1.tar.bz2": { + "build": "py27h1512b58_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "9aedb73ba1858180b572edbbe9bcc2f3", + "name": "sphinxcontrib", + "sha256": "f114872badeaa01104b26e3ab5ccb0ac20fcf42cc75b7cf99693d717b767feb3", + "size": 2981, + "subdir": "linux-64", + "timestamp": 1505746837051, + "version": "1.0" + }, + "sphinxcontrib-1.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "f6479a554f9c702ef8ddad72e3490f9b", + "name": "sphinxcontrib", + "sha256": "17afbdcbc1218bf5570f6677e76d228d61d525ad23bdc28263ecd6b2872a75ea", + "size": 3629, + "subdir": "linux-64", + "timestamp": 1640794832593, + "version": "1.0" + }, + "sphinxcontrib-1.0-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "md5": "de8ec8c0415281384357b0aef6682d13", + "name": "sphinxcontrib", + "sha256": "aa2d9f96fe6476093eb4d69656751d99db768e4461d31b84c0862700f7152e0b", + "size": 3916, + "subdir": "linux-64", + "timestamp": 1676907708328, + "version": "1.0" + }, + "sphinxcontrib-1.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "1d685f2856e7402463439b113524af4a", + "name": "sphinxcontrib", + "sha256": "dbc212452e630e1445e84a0e4635a564cba4712efae8e0a65c6e9b0394757632", + "size": 3310, + "subdir": "linux-64", + "timestamp": 1534345431389, + "version": "1.0" + }, + "sphinxcontrib-1.0-py35hcb7efd2_1.tar.bz2": { + "build": "py35hcb7efd2_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "c1e721f58a26119e3f77b8f86c5b43d1", + "name": "sphinxcontrib", + "sha256": "7a5e35ca3ca70b3798a1a36293805b115d85240c922aeaa977a24f84cd43b2b2", + "size": 3009, + "subdir": "linux-64", + "timestamp": 1505746848118, + "version": "1.0" + }, + "sphinxcontrib-1.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "a6784a0ec89617f61cd63b91ae07df63", + "name": "sphinxcontrib", + "sha256": "662ea04ef007f73b6e4a614303b1c70d934ad26141123690973bde8de3d3076c", + "size": 3343, + "subdir": "linux-64", + "timestamp": 1530694822314, + "version": "1.0" + }, + "sphinxcontrib-1.0-py36h6d0f590_1.tar.bz2": { + "build": "py36h6d0f590_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "889384df7d012ce35bfda5d83406bcd6", + "name": "sphinxcontrib", + "sha256": "b7fbe4952819f1f5aad57f2727e2d860d74f2db9dbd8cec35c8e1ae622cc33a2", + "size": 3015, + "subdir": "linux-64", + "timestamp": 1505746859621, + "version": "1.0" + }, + "sphinxcontrib-1.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "01644091d65f0af7330da388a9129657", + "name": "sphinxcontrib", + "sha256": "7e45a8bc0f6c73a61a1d51be10963f81ddd0feaee1091cd74db91efb667ea382", + "size": 3343, + "subdir": "linux-64", + "timestamp": 1530694841345, + "version": "1.0" + }, + "sphinxcontrib-1.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "3c913a132fbdad4b6b5ea88dbbda0aa1", + "name": "sphinxcontrib", + "sha256": "d930460cb6bb2467e5e67a792897925feae42d94f63a6d96edae49b823e0fb39", + "size": 3776, + "subdir": "linux-64", + "timestamp": 1573661755073, + "version": "1.0" + }, + "sphinxcontrib-1.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "4dd67a1643b04bb7768723f2c01fc375", + "name": "sphinxcontrib", + "sha256": "07ab66898eb08020c133a0236babdedfd391b20f913f548e8a5c3a370aac1a82", + "size": 199549, + "subdir": "linux-64", + "timestamp": 1607574925736, + "version": "1.0" + }, + "sphinxcontrib-websupport-1.0.1-py27hf906f22_1.tar.bz2": { + "build": "py27hf906f22_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "sphinxcontrib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ad989e99354ebaf194051589afc575ff", + "name": "sphinxcontrib-websupport", + "sha256": "a09c23a5fd3a892673eb681b7fe93712bacd100217f832925315bb2d93544327", + "size": 35935, + "subdir": "linux-64", + "timestamp": 1505746873602, + "version": "1.0.1" + }, + "sphinxcontrib-websupport-1.0.1-py35h3537809_1.tar.bz2": { + "build": "py35h3537809_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "sphinxcontrib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "89c7076cde83fffd2cb0745cc512c9f8", + "name": "sphinxcontrib-websupport", + "sha256": "170336fe409757fd034a609962ce2036ec1529c9ceb86a09cc91c6542f79d0e0", + "size": 36699, + "subdir": "linux-64", + "timestamp": 1505746887251, + "version": "1.0.1" + }, + "sphinxcontrib-websupport-1.0.1-py36hb5cb234_1.tar.bz2": { + "build": "py36hb5cb234_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "sphinxcontrib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "007dc0591f198022cf0ced32bf5654af", + "name": "sphinxcontrib-websupport", + "sha256": "31ed35084cf24c278e9933092f35a62261be6524355d0733f3991e16912c566b", + "size": 36516, + "subdir": "linux-64", + "timestamp": 1505746901013, + "version": "1.0.1" + }, + "sphinxcontrib-websupport-1.1.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "sphinxcontrib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "426ebc18a95c810b616a415d23f52ef4", + "name": "sphinxcontrib-websupport", + "sha256": "029ce2ab217bb7aa43e685cc8075aba70c7c66e006f51bc48db332ed41720673", + "size": 36218, + "subdir": "linux-64", + "timestamp": 1528907745747, + "version": "1.1.0" + }, + "sphinxcontrib-websupport-1.1.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "sphinxcontrib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "6440e5353b45295b6a6901d1f30b50d7", + "name": "sphinxcontrib-websupport", + "sha256": "cd7b0f7e64a3dbee0209ced704a49ad3b74ff88090ee741784afd649eaea30fe", + "size": 36892, + "subdir": "linux-64", + "timestamp": 1528907818130, + "version": "1.1.0" + }, + "sphinxcontrib-websupport-1.1.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "sphinxcontrib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "12a11e0f72324b6666cb8b54dffde789", + "name": "sphinxcontrib-websupport", + "sha256": "4e897eaa62535334fe7e575b21487edaa711c0a2a8effb9ca1af5737e6b70ae3", + "size": 36798, + "subdir": "linux-64", + "timestamp": 1528907775813, + "version": "1.1.0" + }, + "sphinxcontrib-websupport-1.1.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "sphinxcontrib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "194f306ee94c3ab8ccb0631ae2637978", + "name": "sphinxcontrib-websupport", + "sha256": "dc47f34b382d9ce6c3c83662febffa11c45f54236d8a0b51fb3fdbbb4a3cf8c0", + "size": 36761, + "subdir": "linux-64", + "timestamp": 1530694880974, + "version": "1.1.0" + }, + "spirv-tools-2021.4-hd09550d_0.tar.bz2": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "976ed2d45ab78bff90550570bd4d40f4", + "name": "spirv-tools", + "sha256": "a140815854e3cfd696529c56f316c36f8e693512be07f244d52f5e023d68ff1e", + "size": 353940887, + "subdir": "linux-64", + "timestamp": 1646152411371, + "version": "2021.4" + }, + "sputnik-0.9.3-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "semver" + ], + "license": "MIT", + "md5": "5d3a6ade2a760f9af884c40d2d8c46c8", + "name": "sputnik", + "sha256": "df1195b4e295b90a429299893ec6f91eae9a1d92c348c96758bbbabb5d680b03", + "size": 46946, + "subdir": "linux-64", + "timestamp": 1539186835641, + "version": "0.9.3" + }, + "sputnik-0.9.3-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0", + "semver" + ], + "license": "MIT", + "md5": "3e15cee8ac7d80a05f34401e58694129", + "name": "sputnik", + "sha256": "2b0c7649317d109cf7f2159ee262f0b72f8cccd35de73664bfffd9abb27c400d", + "size": 48730, + "subdir": "linux-64", + "timestamp": 1640794851889, + "version": "0.9.3" + }, + "sputnik-0.9.3-py311h06a4308_2.tar.bz2": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0", + "semver" + ], + "license": "MIT", + "md5": "c8718dd68ced02c78bb672db53c58aae", + "name": "sputnik", + "sha256": "74e3e9efad78d1471c8a07e5ded773bf25865c80158a52586d549e33c06eb10b", + "size": 68044, + "subdir": "linux-64", + "timestamp": 1676862730168, + "version": "0.9.3" + }, + "sputnik-0.9.3-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "semver" + ], + "license": "MIT", + "md5": "7de352235d508fbfb176ec6334e481cf", + "name": "sputnik", + "sha256": "d60b53084608d4ea45218ebecdb24d4867c4fc29224a3192f1de52b6e373fbf4", + "size": 47938, + "subdir": "linux-64", + "timestamp": 1539186861257, + "version": "0.9.3" + }, + "sputnik-0.9.3-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "semver" + ], + "license": "MIT", + "md5": "3c597f4153defb13a53eba657fc2c9a9", + "name": "sputnik", + "sha256": "010c84019675bf31bf5f8d7a93110ededc153211e7edf026f9d5607c63414624", + "size": 49218, + "subdir": "linux-64", + "timestamp": 1614266812147, + "version": "0.9.3" + }, + "sputnik-0.9.3-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "semver" + ], + "license": "MIT", + "md5": "8d32e9d4abe39f338ba75040340622ae", + "name": "sputnik", + "sha256": "4173b115e98cc4a1ca075e4e6a69700586fbe1aa2c9d809cf6b444509262265a", + "size": 47928, + "subdir": "linux-64", + "timestamp": 1539186860655, + "version": "0.9.3" + }, + "sputnik-0.9.3-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "semver" + ], + "license": "MIT", + "md5": "a6f069cc22a6819bff9ae5e0aa58accc", + "name": "sputnik", + "sha256": "67185b1abc931236f57db1ddec94661f54d5d05872e44315d574de8593f8398e", + "size": 49251, + "subdir": "linux-64", + "timestamp": 1614267828706, + "version": "0.9.3" + }, + "sputnik-0.9.3-py38_2.tar.bz2": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "semver" + ], + "license": "MIT", + "md5": "bc392b8724428aa85d434de7e4f5d3bc", + "name": "sputnik", + "sha256": "7416cf8b5ebfdc752ca30e57985163cea173109f4b04d56e738a9fe167eabe77", + "size": 48321, + "subdir": "linux-64", + "timestamp": 1573554600148, + "version": "0.9.3" + }, + "sputnik-0.9.3-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "semver" + ], + "license": "MIT", + "md5": "e8b1d2fc25ee566aa7995675a525902b", + "name": "sputnik", + "sha256": "e8a05d13dd267b5aa043ee6c0724a426f95cae6d84ef0673e180423ed57b87a6", + "size": 49399, + "subdir": "linux-64", + "timestamp": 1614267843291, + "version": "0.9.3" + }, + "sputnik-0.9.3-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0", + "semver" + ], + "license": "MIT", + "md5": "4cc075a1ab3202d3a5f1d221d8901fc2", + "name": "sputnik", + "sha256": "95e72f8e8c6df8f7609f72bb30fd0f7bbbcc1608b8169cb7a89d0571fa8cd58f", + "size": 49463, + "subdir": "linux-64", + "timestamp": 1614267827159, + "version": "0.9.3" + }, + "spyder-3.2.3-py27hbf281d3_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27hbf281d3_1", + "build_number": 1, + "depends": [ + "chardet >=2.0", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.1", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "5c56e2d5eacc7b5fccbca15c1d8080a2", + "name": "spyder", + "sha256": "b061adc122608789411c09cc604e833e7e774057859a599b0e1c6ff9109080f8", + "size": 2643650, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1506299718174, + "type": "app", + "version": "3.2.3" + }, + "spyder-3.2.3-py35h49e6fe2_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py35h49e6fe2_1", + "build_number": 1, + "depends": [ + "chardet >=2.0", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.5,<3.6.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.1", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "bb12077e113d23da15919f47fca05e25", + "name": "spyder", + "sha256": "869b315912b56b4fa1107b36c8189c327e7b475e41856a49160edc40c74fcdc5", + "size": 2670554, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1506299075782, + "type": "app", + "version": "3.2.3" + }, + "spyder-3.2.3-py36he38cbf7_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36he38cbf7_1", + "build_number": 1, + "depends": [ + "chardet >=2.0", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.1", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "17369978301e488b4f8d1064b4ba6f80", + "name": "spyder", + "sha256": "3460a178a9c4766ba8c16bc46e5f0d3869b9f6b1f6bf8879b734480308efe112", + "size": 2648573, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1506299582729, + "type": "app", + "version": "3.2.3" + }, + "spyder-3.2.4-py27h04a3490_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27h04a3490_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "ed9729850ec1ab3c83d87b422e687bc5", + "name": "spyder", + "sha256": "1bae4ef4f6e25d40a4f3b649e203fff67ef147814e74c675899f9f6b204458ba", + "size": 2645321, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1508356637551, + "type": "app", + "version": "3.2.4" + }, + "spyder-3.2.4-py35h27cea69_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py35h27cea69_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.5,<3.6.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "b78e75bb097f0cf0ec35c8f3137ce183", + "name": "spyder", + "sha256": "b460aeeab39bff235ee3a544191f868b946d62f5005879934d72df11a9722a55", + "size": 2670608, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1508356646689, + "type": "app", + "version": "3.2.4" + }, + "spyder-3.2.4-py36hbe6152b_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36hbe6152b_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "0195f8fe2f1d0effd4b81825df1fbdbb", + "name": "spyder", + "sha256": "065fc432133546e19feea312aaed5ef6ac27516b8930b2bc06846d0a1bae125c", + "size": 2649503, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1508356627088, + "type": "app", + "version": "3.2.4" + }, + "spyder-3.2.5-py27_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "4c50222ed692890920fb01c301934d6f", + "name": "spyder", + "sha256": "e7dd82098dd47753aa3089d4920dd475adba0be932b970b90987ddb4d2b8011e", + "size": 2659168, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1514270697514, + "type": "app", + "version": "3.2.5" + }, + "spyder-3.2.5-py35_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.5,<3.6.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "776bbd874664fa2e024493c94a578e2a", + "name": "spyder", + "sha256": "ba44bb2c84f44acd887caaa9e26f82dd7603d8da496b393d3db7f27560bd1c13", + "size": 2682924, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1514270799100, + "type": "app", + "version": "3.2.5" + }, + "spyder-3.2.5-py36_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "f7f40e12bc4a677bd456054649959690", + "name": "spyder", + "sha256": "6a04aba1498f11127aae2b52670fdf24a1142cf08eab99a3e33f68997104a13a", + "size": 2662206, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1514270799495, + "type": "app", + "version": "3.2.5" + }, + "spyder-3.2.6-py27_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "439d76d6866875c637efe42ec8497b6e", + "name": "spyder", + "sha256": "7bd7fb49a9eb86f95564ff9a17bd0d01aca92ea0da58c07ffa332c2bbe86436a", + "size": 2671389, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1515525227818, + "type": "app", + "version": "3.2.6" + }, + "spyder-3.2.6-py35_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.5,<3.6.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "3c99effb61b70d918444b2461571ded1", + "name": "spyder", + "sha256": "4801dc1010813a186a22684a57463c86ad3bc324b175b44442b127e20e00cac0", + "size": 2692976, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1515525268731, + "type": "app", + "version": "3.2.6" + }, + "spyder-3.2.6-py36_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "e3ba6ad8ab77bb7c4dc202be0c9f6e6c", + "name": "spyder", + "sha256": "0a5c06880c0ec5144a8956ccfd3288da49ed16a33d230a07e15eee7deed23c75", + "size": 2686208, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1515525272849, + "type": "app", + "version": "3.2.6" + }, + "spyder-3.2.7-py27_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "fbae32fd479ad2022f0139bc9baf91eb", + "name": "spyder", + "sha256": "eeb75a35905a7b0f6de8152701f2cccfdb48a921e969e3ea7054162a197bd332", + "size": 2679367, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1519577319617, + "type": "app", + "version": "3.2.7" + }, + "spyder-3.2.7-py35_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.5,<3.6.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "d90166b8ab5659361e4c428fa5b43f98", + "name": "spyder", + "sha256": "386b65695af8b3f951dcb2e87f4fd7f460908d17bf4c3ff29be843dc9f023f3d", + "size": 2724089, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1519577637971, + "type": "app", + "version": "3.2.7" + }, + "spyder-3.2.7-py36_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "154f5c69ea3a8b27c96abb93899ee7ad", + "name": "spyder", + "sha256": "8470865963485114d7cffb1bd8411561ba2e047db399fec36564eaa4a06d6d5b", + "size": 2694811, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1519577356080, + "type": "app", + "version": "3.2.7" + }, + "spyder-3.2.8-py27_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "618fa177efa438258dccfe9564459c09", + "name": "spyder", + "sha256": "d4debc23690876c2f11766f018f5506841348e8244b5b55a4ee5a4053daa6dc1", + "size": 2702482, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1521092320462, + "type": "app", + "version": "3.2.8" + }, + "spyder-3.2.8-py35_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.5,<3.6.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "6252fc050ed605241075bbaf895cbb90", + "name": "spyder", + "sha256": "548237a0868add9558522624e3ea6b422650638720c4ac5238ce7dd98f11b73c", + "size": 2744754, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1521092348389, + "type": "app", + "version": "3.2.8" + }, + "spyder-3.2.8-py36_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "9ad003181d3ce2134a6f024b86a2cdab", + "name": "spyder", + "sha256": "a460addd78adc9ac73fefa1b3202c626bebaf1f2b8b796ee7cb4036839150279", + "size": 2711465, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1521092348360, + "type": "app", + "version": "3.2.8" + }, + "spyder-3.3.0-py27_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx", + "spyder-kernels 0.*" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "d8c697b39ce413f2e01bc6c63dc35f62", + "name": "spyder", + "sha256": "ed8b2e51477baf00367d3d3fe4a2ca84213751a1ee912e8a1820f307cd8a84b3", + "size": 2657092, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1531232105067, + "type": "app", + "version": "3.3.0" + }, + "spyder-3.3.0-py36_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx", + "spyder-kernels 0.*" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "00550c342dd00cf67207be4e87259bb9", + "name": "spyder", + "sha256": "1faf6c884d9377293f93d46132a662c34b1775f8a6457492da4bfd5c7db8ca20", + "size": 2688746, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1531232259447, + "type": "app", + "version": "3.3.0" + }, + "spyder-3.3.0-py37_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.7,<3.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx", + "spyder-kernels 0.*" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "236b6679f662012bea1bad64773c536a", + "name": "spyder", + "sha256": "4d269faef15d129cec5eb1b40557aa5e0a4d36acf46cb62d19b450ef79fdb9b5", + "size": 2687991, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1531232183419, + "type": "app", + "version": "3.3.0" + }, + "spyder-3.3.1-py27_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_1", + "build_number": 1, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx", + "spyder-kernels 0.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "aa6d233c86d3faa0b6ec913c85fc11b6", + "name": "spyder", + "sha256": "abb8ae5e0129075db596ea4a1351e6a9f5a40ca095befb69382c1d54df07320e", + "size": 2660372, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1534262439012, + "type": "app", + "version": "3.3.1" + }, + "spyder-3.3.1-py35_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py35_1", + "build_number": 1, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.5,<3.6.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx", + "spyder-kernels 0.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "d41bf55ac7f9fe1f44adad796547c37f", + "name": "spyder", + "sha256": "898ac8530ea453fb244a5dd21464e1ca92798fe86cae428b62a6e078efeafe63", + "size": 2710924, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1534262179565, + "type": "app", + "version": "3.3.1" + }, + "spyder-3.3.1-py36_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_1", + "build_number": 1, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx", + "spyder-kernels 0.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "e7d5f4977fba1b5672065fa2b8ef686c", + "name": "spyder", + "sha256": "560b9b9fc95bc123561d62f1f8e91fb6fed4faeeb906200713b8ba4b15edc57e", + "size": 2690461, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1534262128089, + "type": "app", + "version": "3.3.1" + }, + "spyder-3.3.1-py37_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_1", + "build_number": 1, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.7,<3.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx", + "spyder-kernels 0.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "3e95fed65dee064ebd3788ac4e08ed19", + "name": "spyder", + "sha256": "9b1f37607b5f1279158a9121bcbdc79aa6c020ea903470c9259613aa970a836d", + "size": 2690524, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1534263423275, + "type": "app", + "version": "3.3.1" + }, + "spyder-3.3.2-py27_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.1,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "596eac695db96c5e303dd4a21f914ea1", + "name": "spyder", + "sha256": "40af6c51f90af2574cfafa5f8ab220c8d748e6fe28887c1e3e2e99183e7e65eb", + "size": 2793391, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1543439615431, + "type": "app", + "version": "3.3.2" + }, + "spyder-3.3.2-py36_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.1,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "f09519fda30b079930f2fdc679762f18", + "name": "spyder", + "sha256": "186c897b2f7cfbe73dbdddab2d6ef8c3b372a2f3f4dd178f074e05eb226ba308", + "size": 2808294, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1543439626393, + "type": "app", + "version": "3.3.2" + }, + "spyder-3.3.2-py37_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.7,<3.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.1,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "bc36f22573f25f8dd941d0484ddf0c1e", + "name": "spyder", + "sha256": "21d6a06698c1d8d6ae4b534f74e7757cefb696bc3cb5def7eb58efb1a710aa44", + "size": 2809407, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1543439616720, + "type": "app", + "version": "3.3.2" + }, + "spyder-3.3.3-py27_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.4.2,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "73f7210e1b90521aca1abaec3370fc61", + "name": "spyder", + "sha256": "59b5f6866cc94162ea703fae147d615c80b1eba669f2fc4c6b97261a8376d003", + "size": 2683764, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1549989068389, + "type": "app", + "version": "3.3.3" + }, + "spyder-3.3.3-py36_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.4.2,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "f38773cc797b55da69b5f0a084a5460a", + "name": "spyder", + "sha256": "4dd0ac6862a65dac93de9733193a88a25de56fda9f4d8f76443faad1eed73903", + "size": 2694912, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1549989092972, + "type": "app", + "version": "3.3.3" + }, + "spyder-3.3.3-py37_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.7,<3.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.4.2,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "f1b0b2b107e91c43d2545549a81f9a82", + "name": "spyder", + "sha256": "20a0f4a24312cede30771d12572cab3ac1da8a448ae967607f5f0fdb6001b167", + "size": 2641230, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1549988991220, + "type": "app", + "version": "3.3.3" + }, + "spyder-3.3.4-py27_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.5.7", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.4.3,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "2ca51bd5c134059bb64774e396a7a5a7", + "name": "spyder", + "sha256": "da8e4f352fb9118b3540ce2aba0bfa948919ff2134aef7039c55a96b6c8cbf2d", + "size": 2635259, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1554942947258, + "type": "app", + "version": "3.3.4" + }, + "spyder-3.3.4-py36_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.5.7", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.4.3,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "e253f8d52a76d348e0d2c84ba2bcdb36", + "name": "spyder", + "sha256": "ca1076d1823246613e3b9afdfabf0bff9fe3dc9c8094abf7d8db8c8535eea6ae", + "size": 2673528, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1554943056859, + "type": "app", + "version": "3.3.4" + }, + "spyder-3.3.4-py37_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.7,<3.8.0a0", + "pyzmq", + "qtawesome >=0.5.7", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.4.3,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "20c2d15ee0bd9140e7f7d033f40cfc02", + "name": "spyder", + "sha256": "9f6b5b61f990434902fea4de99f93ced97fdcb24d675e6445b46c7094e7fc6bf", + "size": 2677079, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1554943027516, + "type": "app", + "version": "3.3.4" + }, + "spyder-3.3.5-py27_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.5.7", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.5.0,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "48ed8108f0945cb714f2ba59c8f8aaea", + "name": "spyder", + "sha256": "09dab0f90d905ee24ccffb29b08e784ec446e5c123081c7d1e400f4ac50d9cc7", + "size": 2650410, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1562005078329, + "type": "app", + "version": "3.3.5" + }, + "spyder-3.3.5-py36_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.5.7", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.5.0,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "cc1fb4f5bfd75552a2871a21de879d95", + "name": "spyder", + "sha256": "6fd1ea4359a7e67fd0365e93afe8d454260dc59f5f2e5157bac2180d9508de8d", + "size": 2693922, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1562005083339, + "type": "app", + "version": "3.3.5" + }, + "spyder-3.3.5-py37_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.7,<3.8.0a0", + "pyzmq", + "qtawesome >=0.5.7", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.5.0,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "b6b9d970a849003ec9b17a063ffaea81", + "name": "spyder", + "sha256": "6d147910fe93a7e0c9a8ad65d857fb2605857b2adc45a219d2c2260faf32fee2", + "size": 2652383, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1562005074441, + "type": "app", + "version": "3.3.5" + }, + "spyder-3.3.6-py27_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.5.7", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.5.0,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "0a22609dc830e14295488d3188b3c435", + "name": "spyder", + "sha256": "7407220d25b20cb5e5d2f6f8ff8f24719d6b0b6868641e0be0ac41926a2d78c8", + "size": 2662270, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1563210388380, + "type": "app", + "version": "3.3.6" + }, + "spyder-3.3.6-py36_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.5.7", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.5.0,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "f9169e4a10fe67daa587615e91079894", + "name": "spyder", + "sha256": "c0f1b268a1ea984e02da0a68b0a197d0bc8ad5cb2ef4899064a6ded366879d7e", + "size": 2670204, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1563210387948, + "type": "app", + "version": "3.3.6" + }, + "spyder-3.3.6-py37_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.7,<3.8.0a0", + "pyzmq", + "qtawesome >=0.5.7", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.5.0,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "72de2e1257e9d4f47e2b53ad4a9d26fe", + "name": "spyder", + "sha256": "f95aa69903a99d9d90a5a270619d557f93dcc1f252d3e37028c56e044d1096ac", + "size": 2644182, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1563210388380, + "type": "app", + "version": "3.3.6" + }, + "spyder-4.0.0-py27_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "chardet >=2.0.0", + "cloudpickle", + "diff-match-patch", + "intervaltree", + "jedi 0.14.1.*", + "nbconvert", + "numpydoc", + "pexpect", + "pickleshare", + "psutil >=5.2", + "pygments >=2.0", + "pylint", + "pympler", + "pyqt >=5.6,<5.13", + "python >=2.7,<2.8.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg", + "pyzmq", + "qdarkstyle >=2.7", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree", + "sphinx", + "spyder-kernels >=1.8.1,<1.9.0", + "watchdog", + "parso 0.5.2.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "86855909bb08b25fbcfe4d542cd49efc", + "name": "spyder", + "sha256": "aeeca61ca72b95118c5894a7299e3d384be950e87ace7787bcfdd486afbe4eb6", + "size": 8041038, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1575674837094, + "type": "app", + "version": "4.0.0" + }, + "spyder-4.0.0-py36_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "chardet >=2.0.0", + "cloudpickle", + "diff-match-patch", + "intervaltree", + "jedi 0.14.1.*", + "keyring", + "nbconvert", + "numpydoc", + "pexpect", + "pickleshare", + "psutil >=5.2", + "pygments >=2.0", + "pylint", + "pympler", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg", + "pyzmq", + "qdarkstyle >=2.7", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree", + "sphinx", + "spyder-kernels >=1.8.1,<1.9.0", + "watchdog", + "parso 0.5.2.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "6f31b6a6bdd2483545eeb6f3240338fa", + "name": "spyder", + "sha256": "57d89986574f3c8f74f1acf3bab849a95489e13999fa4c9fd1cf067f1adf1b5d", + "size": 8079090, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1575674830756, + "type": "app", + "version": "4.0.0" + }, + "spyder-4.0.0-py37_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "chardet >=2.0.0", + "cloudpickle", + "diff-match-patch", + "intervaltree", + "jedi 0.14.1.*", + "keyring", + "nbconvert", + "numpydoc", + "pexpect", + "pickleshare", + "psutil >=5.2", + "pygments >=2.0", + "pylint", + "pympler", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg", + "pyzmq", + "qdarkstyle >=2.7", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree", + "sphinx", + "spyder-kernels >=1.8.1,<1.9.0", + "watchdog", + "parso 0.5.2.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "4b4f0449e9d6d1b4fabf344d5e4cfbb3", + "name": "spyder", + "sha256": "e12fefd8e75a113b114af321bcf9350b7e315fc6da9bce14ce13f48a325e9300", + "size": 8064112, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1575674830533, + "type": "app", + "version": "4.0.0" + }, + "spyder-4.0.1-py27_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "chardet >=2.0.0", + "cloudpickle", + "diff-match-patch", + "intervaltree", + "jedi 0.14.1.*", + "nbconvert", + "numpydoc", + "pexpect", + "pickleshare", + "psutil >=5.2", + "pygments >=2.0", + "pylint", + "pyqt >=5.6,<5.13", + "python >=2.7,<2.8.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg", + "pyzmq", + "qdarkstyle >=2.7", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree", + "sphinx", + "spyder-kernels >=1.8.1,<1.9.0", + "watchdog", + "parso 0.5.2.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "35a9b03bf3db0ba77eabaefebcf1e269", + "name": "spyder", + "sha256": "9f8f077575248adb4f4273443440b4f4094d6e28a52ab71c80198110d46312b4", + "size": 8030932, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1578414741184, + "type": "app", + "version": "4.0.1" + }, + "spyder-4.0.1-py36_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "chardet >=2.0.0", + "cloudpickle", + "diff-match-patch", + "intervaltree", + "jedi 0.14.1.*", + "keyring", + "nbconvert", + "numpydoc", + "pexpect", + "pickleshare", + "psutil >=5.2", + "pygments >=2.0", + "pylint", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg", + "pyzmq", + "qdarkstyle >=2.7", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree", + "sphinx", + "spyder-kernels >=1.8.1,<1.9.0", + "watchdog", + "parso 0.5.2.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "01d172c44dc56f042d48a519c9631c8d", + "name": "spyder", + "sha256": "ee98af137c2d943d78fbd24efc728fc05398af2086e05c5356d2395b915a8871", + "size": 8063269, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1578414750144, + "type": "app", + "version": "4.0.1" + }, + "spyder-4.0.1-py37_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "chardet >=2.0.0", + "cloudpickle", + "diff-match-patch", + "intervaltree", + "jedi 0.14.1.*", + "keyring", + "nbconvert", + "numpydoc", + "pexpect", + "pickleshare", + "psutil >=5.2", + "pygments >=2.0", + "pylint", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg", + "pyzmq", + "qdarkstyle >=2.7", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree", + "sphinx", + "spyder-kernels >=1.8.1,<1.9.0", + "watchdog", + "parso 0.5.2.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "598b6bea6649d6fbc44df0eed3d28362", + "name": "spyder", + "sha256": "57980302cf021757f6abc3f5c5e801994909a455cbbc52f376c4159fff0e8051", + "size": 8058795, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1578414735139, + "type": "app", + "version": "4.0.1" + }, + "spyder-4.0.1-py38_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "chardet >=2.0.0", + "cloudpickle", + "diff-match-patch", + "intervaltree", + "jedi 0.14.1.*", + "keyring", + "nbconvert", + "numpydoc", + "pexpect", + "pickleshare", + "psutil >=5.2", + "pygments >=2.0", + "pylint", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg", + "pyzmq", + "qdarkstyle >=2.7", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree", + "sphinx", + "spyder-kernels >=1.8.1,<1.9.0", + "watchdog", + "parso 0.5.2.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "767e8d8a8605a37e2ecc2b0b17a45bad", + "name": "spyder", + "sha256": "6b940536f45e9aea73fba7403937585ed1f4784786dcea656ddee21eff483ea0", + "size": 8080735, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1580252845906, + "type": "app", + "version": "4.0.1" + }, + "spyder-4.1.0-py36_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.14.1.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.0,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "1b94883721a13c9c6b5ecb81e4605f58", + "name": "spyder", + "sha256": "7073d8afe03c0520f0a2e8c5584f64aebb155af2c15026d41822ee9830f5483a", + "size": 8041205, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1584458108654, + "type": "app", + "version": "4.1.0" + }, + "spyder-4.1.0-py37_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.14.1.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.0,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "78e570264fbec1dcc11e4efdb71eaa92", + "name": "spyder", + "sha256": "4015807c6f96c3c5da77c950f96a6fd106254246ccdc499777fb8650a8eb897a", + "size": 8026131, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1584458076090, + "type": "app", + "version": "4.1.0" + }, + "spyder-4.1.0-py38_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.14.1.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.0,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "2a5fb0df734b4087a7d82354da382153", + "name": "spyder", + "sha256": "4e024c32ee7faf0e96a25594173969d12fde4e697fe1032553c6f3c27be474da", + "size": 8053007, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1584458194336, + "type": "app", + "version": "4.1.0" + }, + "spyder-4.1.1-py36_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.15.2.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.31.9,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.0,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "86896930db4d920b354d51696e4a92df", + "name": "spyder", + "sha256": "b2a487cf024440d349690da0ff427e0a195cfc6f8ef87bf216af767a21f3c851", + "size": 8467930, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1584645138428, + "type": "app", + "version": "4.1.1" + }, + "spyder-4.1.1-py37_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.15.2.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.31.9,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.0,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "b9df9573db6f429170b061d7d0329e48", + "name": "spyder", + "sha256": "630b15a945618c179157fddbfe583fdb0168a4efa733ed90b95513baf2385931", + "size": 8463827, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1584645156179, + "type": "app", + "version": "4.1.1" + }, + "spyder-4.1.1-py38_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.15.2.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.31.9,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.0,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "3c0eea9707af06751aa9012faf29810a", + "name": "spyder", + "sha256": "0e2351026f723d0678651b128014bd3f2d7c590702cf99bf2fadb7157cc6957f", + "size": 8480674, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1584645155863, + "type": "app", + "version": "4.1.1" + }, + "spyder-4.1.2-py36_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.15.2.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.31.9,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.0,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "74eab067e25d6e5c2e94d9d39fe67ba4", + "name": "spyder", + "sha256": "8377ae8663b5099d6e279d39efde2068307ac534025d558434ed247fef2025e8", + "size": 8471341, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1586199074528, + "type": "app", + "version": "4.1.2" + }, + "spyder-4.1.2-py37_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.15.2.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.31.9,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.0,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "395f78e7841e3d31a9ed5b2c739b09a7", + "name": "spyder", + "sha256": "67f54be255eac3b9c4c8f9c008884e1181b122756f7d419b4f89a1c3a88f1887", + "size": 8473209, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1586199059789, + "type": "app", + "version": "4.1.2" + }, + "spyder-4.1.2-py38_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.15.2.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.31.9,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.0,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "7c792816e520c534ea3ed12aca7a4a70", + "name": "spyder", + "sha256": "a0cc94843c64df832195fd673dd9ff28fdc03775fd4934a20ba86f0aa2a925d1", + "size": 8501159, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1586199086537, + "type": "app", + "version": "4.1.2" + }, + "spyder-4.1.3-py36_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.15.2.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.31.9,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.1,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "d0f905e8db4e9f695d4f2a261665e930", + "name": "spyder", + "sha256": "253b60009444a07bce6a2220fdc562f07e06911a99c447bcc50ec1f95e6a2def", + "size": 8492615, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1589207380819, + "type": "app", + "version": "4.1.3" + }, + "spyder-4.1.3-py37_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.15.2.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.31.9,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.1,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "ca3cdd586eed8a03a932740394ccf076", + "name": "spyder", + "sha256": "d6118a9260c792d784878b8583d8791ab8d9aae6cd85c8172ac5067337cbe1ec", + "size": 8540972, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1589207374647, + "type": "app", + "version": "4.1.3" + }, + "spyder-4.1.3-py38_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.15.2.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.31.9,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.1,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "50beb2236180f86dae1ef2010183984e", + "name": "spyder", + "sha256": "20f0e0a10c2c287953274a6cbcbf88094baa6c1b3a80fe24464fe286a9f539ab", + "size": 8530623, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1589207402892, + "type": "app", + "version": "4.1.3" + }, + "spyder-4.1.4-py36_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.17.1.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.34.0,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.2,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "f0cd9fe1eb07366146169f8daa8567d3", + "name": "spyder", + "sha256": "fd1a69cb89c3d5e9a33562bb4e5dcb038d6f2ef0f5c3c66de0f84c6beb20d42e", + "size": 8551888, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1594830433349, + "type": "app", + "version": "4.1.4" + }, + "spyder-4.1.4-py37_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.17.1.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.34.0,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.2,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "d991144f86f356bce1f0c3ecadfd94d8", + "name": "spyder", + "sha256": "b5e58c7d3ff4c1b235fbf361ac218abae50ca59961ab33c0d7cced61641e48f3", + "size": 8572315, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1594830433634, + "type": "app", + "version": "4.1.4" + }, + "spyder-4.1.4-py38_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.17.1.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.34.0,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.2,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "9b3f179bd1f95158db4a632b8d59917a", + "name": "spyder", + "sha256": "77c1ba84c72637e81e8d74d3e66c55d8ce4bb9a75702ca68070e104369dd2649", + "size": 8548385, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1594832175527, + "type": "app", + "version": "4.1.4" + }, + "spyder-4.1.5-py36_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.17.1.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.34.0,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.4,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "4c29697c288ade569f7e624951544a1b", + "name": "spyder", + "sha256": "eddf0958141ca1e6d5b82f09e89e8e31810e4b1dcf7cf61e04c509d703c2f7a9", + "size": 8544313, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1599057070363, + "type": "app", + "version": "4.1.5" + }, + "spyder-4.1.5-py37_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.17.1.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.34.0,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.4,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "333b79bb6e13908a65659d27c101e7b1", + "name": "spyder", + "sha256": "19b8ba07c10bb30d2ba47e2c0fb6fd566c27deb86852fdc95652a809a0ac4f8a", + "size": 8533185, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1599057043183, + "type": "app", + "version": "4.1.5" + }, + "spyder-4.1.5-py38_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.17.1.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.34.0,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.4,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "50022be3dbfc8293ff95121230a1cc86", + "name": "spyder", + "sha256": "5da76c9c614211eceb0a9b2ee51bf7643f4dbb1483b11a64f2a85bd067390acf", + "size": 8563685, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1599057039903, + "type": "app", + "version": "4.1.5" + }, + "spyder-4.2.0-py36h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.1.1", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.1,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.7.7", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.0,<1.11.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "2864da7907b0ab01e7233068f02760d8", + "name": "spyder", + "sha256": "fb00840b52cc46348a5620c0ea95f974d7f3e86932b9093571553bd7d6ee0381", + "size": 8640678, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1607704323990, + "type": "app", + "version": "4.2.0" + }, + "spyder-4.2.0-py37h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.1.1", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.1,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.7.7", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.0,<1.11.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "9dc56bceffb6b5de11dfd542cb7dde47", + "name": "spyder", + "sha256": "ba9eb5c6ea4a9408607c415c8e23588d08d83d6c835ced965e7b198b78311535", + "size": 8695658, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1607701283274, + "type": "app", + "version": "4.2.0" + }, + "spyder-4.2.0-py38h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.1.1", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.1,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.7.7", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.0,<1.11.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "88c862b52651c5317b3df1fb38451a95", + "name": "spyder", + "sha256": "61b4023753868dc23f55eef7b889983766598182a78fac67541d7572f514a359", + "size": 8652182, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1607704323071, + "type": "app", + "version": "4.2.0" + }, + "spyder-4.2.0-py39h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.1.1", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.1,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.7.7", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.0,<1.11.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "f5a303f79213591bc70148f4d55f9dc7", + "name": "spyder", + "sha256": "e59a1956d0395160a276ba2c93983868f427836bd4a38fe810b0de22f3f4ba5e", + "size": 8593641, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1607982209159, + "type": "app", + "version": "4.2.0" + }, + "spyder-4.2.1-py36h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.1.1", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.1,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.7.7", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.0,<1.11.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "faef7efe9eea6dc100b9b8c2593883f3", + "name": "spyder", + "sha256": "3d41598a65fc91c59a956e764ebf7ad20f76835b2a92fb4d11562f1c9a5318fb", + "size": 8635266, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1612320411495, + "type": "app", + "version": "4.2.1" + }, + "spyder-4.2.1-py36h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.0", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=5.0.1", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.1,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "528cbf9aff8d5e4ae6688efd734b6367", + "name": "spyder", + "sha256": "0d2fcdc0eb9de02492d56a51ee5dc18c7485002a7eb0c3b0248619a5df7937a4", + "size": 8683794, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1612463449415, + "type": "app", + "version": "4.2.1" + }, + "spyder-4.2.1-py37h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.1.1", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.1,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.7.7", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.0,<1.11.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "0f6e2d6f1d43aca15933fd5885056376", + "name": "spyder", + "sha256": "fd84b7c4d77d8b4fba689808d6e6e1f897f375754ecd16cad7086a829e255a08", + "size": 8674610, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1612318777698, + "type": "app", + "version": "4.2.1" + }, + "spyder-4.2.1-py37h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.0", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=5.0.1", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.1,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "92b6cac2327161688eadd32cdf893cc9", + "name": "spyder", + "sha256": "ffc5922b8dac3d8283466a161728e74c3552b82d9b1fb9f918f18dfa8dda7d8a", + "size": 8703750, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1612463538427, + "type": "app", + "version": "4.2.1" + }, + "spyder-4.2.1-py38h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.1.1", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.1,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.7.7", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.0,<1.11.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "404ed8f0d3a6c94fd7f56dfac583ba6b", + "name": "spyder", + "sha256": "36c8245f406e42c286686e08a73100ca497c5f1577ac30b1b957633df23528da", + "size": 8663013, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1612318776121, + "type": "app", + "version": "4.2.1" + }, + "spyder-4.2.1-py38h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.0", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=5.0.1", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.1,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "4da1dd63b5dfc9eead621373d12f42bc", + "name": "spyder", + "sha256": "92e0bafcfd059cd85eb39f09f786eb71bd3153fc8ad034c6e7e3b208d634e275", + "size": 8669445, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1612462791035, + "type": "app", + "version": "4.2.1" + }, + "spyder-4.2.1-py39h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.1.1", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.1,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.7.7", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.0,<1.11.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "31de267726bf8e3d30edd16c64452366", + "name": "spyder", + "sha256": "0f6c13276a8838ca3248a1bebcc42b27affd392bfa401524acea3e8b9292db3b", + "size": 8630759, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1612320676723, + "type": "app", + "version": "4.2.1" + }, + "spyder-4.2.1-py39h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.0", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=5.0.1", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.1,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "79ed60d624d344b6d2c3790c9998bc8f", + "name": "spyder", + "sha256": "97fab89999c1ad00dccf604f90cecf66113359ac524a5545a68fb4089ac4b701", + "size": 8653344, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1612463543652, + "type": "app", + "version": "4.2.1" + }, + "spyder-4.2.3-py36h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=5.0.1", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "63a0566933060f1aafa2c205dda4015f", + "name": "spyder", + "sha256": "de8c51de593cdf6ae5bbebbeaf3aa0143e2854b1e9a0fc87f9c7f7ae63b9507d", + "size": 8345928, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1615366389673, + "type": "app", + "version": "4.2.3" + }, + "spyder-4.2.3-py37h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=5.0.1", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "b2cadf07cd29acfd0a177489e5b98665", + "name": "spyder", + "sha256": "20e530ea3dd603f28e16abf5f375a078bd39bcc85ac0450caf37855f88ce0e87", + "size": 8371803, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1615366395453, + "type": "app", + "version": "4.2.3" + }, + "spyder-4.2.3-py38h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=5.0.1", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "9ea20e2943849013bd22e267e3127047", + "name": "spyder", + "sha256": "0860b6c55a9e938711133071f4d2c938bbd595111a737b7c26f2e47bd44698e1", + "size": 8329659, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1615366387511, + "type": "app", + "version": "4.2.3" + }, + "spyder-4.2.3-py39h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=5.0.1", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "1ca06d23b20c63e8aba47be42b79a24d", + "name": "spyder", + "sha256": "3562afffbfaa46f3e93638765db540d9b17d47ba96d01143471de88dba3e1b9b", + "size": 8327332, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1615366288552, + "type": "app", + "version": "4.2.3" + }, + "spyder-4.2.4-py36h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8,<3.0", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "9620f6ddbadbbded7f2f753c4a60bcf3", + "name": "spyder", + "sha256": "9155fbe21bc039606005996c577341148a724512772034d89e9ab2ef04084ec6", + "size": 8378261, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1616685585973, + "type": "app", + "version": "4.2.4" + }, + "spyder-4.2.4-py37h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8,<3.0", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "3860f2dc7c3c256faf90ba96d519182a", + "name": "spyder", + "sha256": "f36ad882eee024fa7da257a3fa3cccebead919a193ca69dfb831c83123a38987", + "size": 8347907, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1616685571651, + "type": "app", + "version": "4.2.4" + }, + "spyder-4.2.4-py38h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8,<3.0", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "e8a6e2f6b7e8551f7594bd010edbaae6", + "name": "spyder", + "sha256": "0e66e1868b634676bb03631eb53b486ad8e65c1c92a9d4d890661987f6a5197b", + "size": 8330082, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1616685590804, + "type": "app", + "version": "4.2.4" + }, + "spyder-4.2.4-py39h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8,<3.0", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "23c4f684e94463211ebdb3c3703dd947", + "name": "spyder", + "sha256": "38890b5277bd15875ac5857391b23a0156e056b5c33e891f64ba5e1a8fb19992", + "size": 8346082, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1616685598782, + "type": "app", + "version": "4.2.4" + }, + "spyder-4.2.5-py36h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8,<3.0", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "0ca785caa194d5f5c2b485f45479399a", + "name": "spyder", + "sha256": "cd14fc913c850e29be3dca0170aa7338f2651623a93595e3852cdf72ce65d9eb", + "size": 8354804, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1616775687184, + "type": "app", + "version": "4.2.5" + }, + "spyder-4.2.5-py37h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8,<3.0", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "0d18852ff39817140f8b7b0b0d75cbf2", + "name": "spyder", + "sha256": "52bca80a04d46c494de2f8af233702b1753cdb1d6945bd2a9f312b8b76e86f1d", + "size": 8322946, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1616775672556, + "type": "app", + "version": "4.2.5" + }, + "spyder-4.2.5-py38h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8,<3.0", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "f86849bd69e3651587822b27d5f8cac3", + "name": "spyder", + "sha256": "3f8d9981b133b2e345fc56ec93a88365a27a56c9c4b051aba28c2dab414b8068", + "size": 8356049, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1616775673972, + "type": "app", + "version": "4.2.5" + }, + "spyder-4.2.5-py39h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8,<3.0", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "b69715755452f3a7913cdb0ce7ad7bce", + "name": "spyder", + "sha256": "04a1072aa650bc6af91eba2ac53d9fe0f8ca38e292445aeb6c92f075883bcdbc", + "size": 8387236, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1616775667679, + "type": "app", + "version": "4.2.5" + }, + "spyder-5.0.0-py36h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.1,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "c1bc828d544bead1741ff848bb682c08", + "name": "spyder", + "sha256": "6545fbadf07dc8dc5150347bbe3550b14ebf1e8af048dc5c3e6f41875db518c4", + "size": 8471055, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1617483447153, + "type": "app", + "version": "5.0.0" + }, + "spyder-5.0.0-py36h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qstylizer >=0.1.10", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.1,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "8bf675f2e46bcf1c478ec2a6e48f66a2", + "name": "spyder", + "sha256": "d6a98b222933cccc28a22facb9ae357a4a400e3565514b21ca5bcffa261de216", + "size": 8491734, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1618327956831, + "type": "app", + "version": "5.0.0" + }, + "spyder-5.0.0-py37h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.1,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "9e256589f231ff3db7c0ed5fb67698c4", + "name": "spyder", + "sha256": "98c94538e7f127b8fb7883b4e081106887b43e292c747e9b2e5984320a8ed140", + "size": 8472589, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1617483443393, + "type": "app", + "version": "5.0.0" + }, + "spyder-5.0.0-py37h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qstylizer >=0.1.10", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.1,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "cb6b8ce53f19032f5041f13dfeec65c0", + "name": "spyder", + "sha256": "c7cb6f1b8d1c5ab2dcb68e5a51efd9dfbec172311b98bf2cdf8fa636a3ba8981", + "size": 8498096, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1618327954061, + "type": "app", + "version": "5.0.0" + }, + "spyder-5.0.0-py38h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.1,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "ce6a9eef55dc3b01e3f0048328d9f684", + "name": "spyder", + "sha256": "a28bec3ab96873b0e73c22669ba8327ed29aa3b472728025b856314e7e8dc1f2", + "size": 8479597, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1617483445359, + "type": "app", + "version": "5.0.0" + }, + "spyder-5.0.0-py38h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qstylizer >=0.1.10", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.1,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "c979afbb86b44790858fc3ed5bf7fc58", + "name": "spyder", + "sha256": "40fbcfaf99f62bccbf1d88c82ced8670dddb39120c58dacf18c6cce35f85a8b9", + "size": 8515368, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1618327968816, + "type": "app", + "version": "5.0.0" + }, + "spyder-5.0.0-py39h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.1,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "2ce367e2ac55bb2a2ab85591e189d315", + "name": "spyder", + "sha256": "0215878afb8fde2252b97f596d1d0bc339a46e264b525c7211a4c15493947586", + "size": 8499526, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1617483239029, + "type": "app", + "version": "5.0.0" + }, + "spyder-5.0.0-py39h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qstylizer >=0.1.10", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.1,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "da7d38e69b680f87ec6c2a809361e43b", + "name": "spyder", + "sha256": "980605162bab68dfc68cef89641eab22e3cd219ed4827513f0d45c122cf0a956", + "size": 8472238, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1618327905070, + "type": "app", + "version": "5.0.0" + }, + "spyder-5.0.3-py36h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2,<0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.3,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "c5df58024654948f6ee090cf6b842d0d", + "name": "spyder", + "sha256": "1f68e7a77b5e3588f2102f79c6073d63e7b3e93afb40381b248683f4eec98920", + "size": 8507503, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1623423654728, + "type": "app", + "version": "5.0.3" + }, + "spyder-5.0.3-py37h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2,<0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.3,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "285f12fa33dbcbe35605be29bf939019", + "name": "spyder", + "sha256": "903c40537401f6d47543a272e0c073925349c63975176b7311e7630fb3532a20", + "size": 8512937, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1623423657737, + "type": "app", + "version": "5.0.3" + }, + "spyder-5.0.3-py38h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2,<0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.3,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "17a2b5c3d69e363444bcc1a335f5be30", + "name": "spyder", + "sha256": "79a8742e288e564619c39f8783550241f0ad4c7f3994d564c4daa38339fce0d2", + "size": 8491442, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1623417988855, + "type": "app", + "version": "5.0.3" + }, + "spyder-5.0.3-py39h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2,<0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.3,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "0412c830dddf17efd5498e5b9a4a8dbd", + "name": "spyder", + "sha256": "de45056d82e37217b4a717b0ac11fae93e92ae350a9aedb7fcb78f31739330d9", + "size": 8489345, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1623423651392, + "type": "app", + "version": "5.0.3" + }, + "spyder-5.0.5-py36h06a4308_2.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2,<0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.4,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "7bc77b9cb9a8bb697f4257696715669a", + "name": "spyder", + "sha256": "2ccb8abc5c383aef9ee5d34e0c7df317f6d3814161c7ef01393bfddb26f091c0", + "size": 8511553, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1626175111452, + "type": "app", + "version": "5.0.5" + }, + "spyder-5.0.5-py37h06a4308_2.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2,<0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.4,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "e5385d44547780d6b3406f02599af504", + "name": "spyder", + "sha256": "3be9825cc0ffd1d99b30631791e2c34056666f050d3c4803ea1cf4538841c709", + "size": 8515727, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1626182119397, + "type": "app", + "version": "5.0.5" + }, + "spyder-5.0.5-py38h06a4308_2.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2,<0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.4,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "8fd54900882299b13ebaadc1d96995f1", + "name": "spyder", + "sha256": "3f41329b09920e5b47a6e0511fa2276306af8e80653febdce3073580f9869168", + "size": 8532534, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1626182115082, + "type": "app", + "version": "5.0.5" + }, + "spyder-5.0.5-py39h06a4308_2.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2,<0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.4,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "20daff58fc64df714cecc857476040ae", + "name": "spyder", + "sha256": "e217ecdd767dadc1ead4f9ac79b99138381b0a04141c71a20c02e23f219d0be7", + "size": 8512939, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1625814753091, + "type": "app", + "version": "5.0.5" + }, + "spyder-5.1.5-py310h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi >=0.17.2,<0.19.0", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<2.10.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.10,<3.11.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.2.2,<1.3.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.1.1,<2.2.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "5a49f9f1ea3bac9f0bf4c3bb395dfd8f", + "name": "spyder", + "sha256": "9e18c52b3e85ebdba58b77f1fcd6ab8ba1b0386b869f3e5427febddcacc4f9b1", + "size": 12518759, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1642522017263, + "type": "app", + "version": "5.1.5" + }, + "spyder-5.1.5-py37h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi >=0.17.2,<0.19.0", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<2.10.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.2.2,<1.3.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.1.1,<2.2.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "75ce829387ee493a1460046a865f7771", + "name": "spyder", + "sha256": "9f503076f6e0bb3b13be51ba6d1aba281be9f5b45cf34fc1ac31bbdd8bceff82", + "size": 12472866, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1634576236783, + "type": "app", + "version": "5.1.5" + }, + "spyder-5.1.5-py37h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi >=0.17.2,<0.19.0", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<2.10.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.2.2,<1.3.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.1.1,<2.2.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "7dcb376efe8057a0450cdc2f5447ec76", + "name": "spyder", + "sha256": "39074fa36863d540e6ddb23c9f76dddfa83b946290a04587f4c1f1833586a2f9", + "size": 12539827, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1636480287535, + "type": "app", + "version": "5.1.5" + }, + "spyder-5.1.5-py38h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi >=0.17.2,<0.19.0", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<2.10.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.2.2,<1.3.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.1.1,<2.2.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "1242aec3e49f8afbfe68e81c78c14ae4", + "name": "spyder", + "sha256": "88ae9da0c878c1c4f00c039fb17bed9b6c155b940383dc326cfa328bb5e09210", + "size": 12529468, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1634576238602, + "type": "app", + "version": "5.1.5" + }, + "spyder-5.1.5-py38h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi >=0.17.2,<0.19.0", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<2.10.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.2.2,<1.3.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.1.1,<2.2.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "f322a9dfd4ff4df06d55bdb85409cb86", + "name": "spyder", + "sha256": "ef464f5b479accc9b8ffad56c917c4b84a30f1df7da7a041d75604bf743e5274", + "size": 12537043, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1636480282533, + "type": "app", + "version": "5.1.5" + }, + "spyder-5.1.5-py39h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi >=0.17.2,<0.19.0", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<2.10.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.2.2,<1.3.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.1.1,<2.2.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "b9d6e830bb34f2e673f667854476685e", + "name": "spyder", + "sha256": "4c56dd9c724e24645b0ac5ed5c79a9ebc0ce732a78616f03092061f0252a9a90", + "size": 12490222, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1634576234190, + "type": "app", + "version": "5.1.5" + }, + "spyder-5.1.5-py39h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi >=0.17.2,<0.19.0", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<2.10.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.2.2,<1.3.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.1.1,<2.2.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "b3b292e38cbce2231ea4858ba3429ed5", + "name": "spyder", + "sha256": "417d98d83520634d715221c65ca1138902342b46eda09f0337f7cea3c21108d6", + "size": 12544472, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1636479915366, + "type": "app", + "version": "5.1.5" + }, + "spyder-5.2.2-py310h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py310h06a4308_1", + "build_number": 1, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0,<8.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6", + "python >=3.10,<3.11.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.3.2,<1.4.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.2.1,<5.3.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.2.1,<2.3.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "40a3d21d484f76090e8ccd7c6df7fd2f", + "name": "spyder", + "sha256": "6845d38e58fa3d9dd869849aa520d84582fcf71b47a93b515135459fbdb44a0a", + "size": 12592213, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1659599927494, + "type": "app", + "version": "5.2.2" + }, + "spyder-5.2.2-py37h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0,<8.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6", + "python >=3.7,<3.8.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.3.2,<1.4.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.2.1,<5.3.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.2.1,<2.3.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "23d4175b4654702a14c8843838263f5d", + "name": "spyder", + "sha256": "2749b9fb2c664c55caa141e9ac4e0e067dc0869525820de34a54860911bb5b11", + "size": 12567543, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1659599990592, + "type": "app", + "version": "5.2.2" + }, + "spyder-5.2.2-py38h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0,<8.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6", + "python >=3.8,<3.9.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.3.2,<1.4.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.2.1,<5.3.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.2.1,<2.3.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "0dd7eca8af54a1cf6f8dc1499f62b501", + "name": "spyder", + "sha256": "6881bbd43a296a9b8feadbdf18d351dfa004179b2522e30610c4b7db11dfdac0", + "size": 12564655, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1659599847025, + "type": "app", + "version": "5.2.2" + }, + "spyder-5.2.2-py39h06a4308_1.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0,<8.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6", + "python >=3.9,<3.10.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.3.2,<1.4.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.2.1,<5.3.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.2.1,<2.3.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "8b8394982ea379b388d655f78dba461e", + "name": "spyder", + "sha256": "4acd97d7de9e949da9b9f7274f4434e3ea61f4126a66a4c633add125d24d4846", + "size": 12539380, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1659600053485, + "type": "app", + "version": "5.2.2" + }, + "spyder-5.3.3-py310h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<8.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine >=5.15,<5.16", + "python >=3.10,<3.11.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.5.0,<1.6.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.3.2,<5.4.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.3.3,<2.4.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "756fd7669d778c3db1df34cad4881d9f", + "name": "spyder", + "sha256": "65c48898d81b834c4bac015d71320954237aed8bfe37890bc58054bfc4585efe", + "size": 12588868, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1663056975846, + "type": "app", + "version": "5.3.3" + }, + "spyder-5.3.3-py37h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "importlib-metadata <4.3", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<8.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine >=5.15,<5.16", + "python >=3.7,<3.8.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.5.0,<1.6.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.3.2,<5.4.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.3.3,<2.4.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "2c674d6827434d96625f315df74a81ff", + "name": "spyder", + "sha256": "b67f98d7fabe4091f2a65defafde40b9c45fe27ac130cd334287f8085ce9145a", + "size": 12563481, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1663057119750, + "type": "app", + "version": "5.3.3" + }, + "spyder-5.3.3-py38h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<8.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine >=5.15,<5.16", + "python >=3.8,<3.9.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.5.0,<1.6.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.3.2,<5.4.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.3.3,<2.4.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "6c85d98b3a4682300719015992ec4355", + "name": "spyder", + "sha256": "292b4389f3785620342e2c69086e1da40a199410e783bb045c8a6338a32feece", + "size": 12581578, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1663056885637, + "type": "app", + "version": "5.3.3" + }, + "spyder-5.3.3-py39h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<8.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine >=5.15,<5.16", + "python >=3.9,<3.10.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.5.0,<1.6.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.3.2,<5.4.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.3.3,<2.4.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "c165f6ce6823dbdaef3758c77aeb5ec9", + "name": "spyder", + "sha256": "c0312ff7220395a6330ac9a0f1f5d56898acf2161c503e55df5e566bb9015c2f", + "size": 12568807, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1663057047137, + "type": "app", + "version": "5.3.3" + }, + "spyder-5.4.1-py310h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<9.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pylint-venv >=2.1.1", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine <5.16", + "python >=3.10,<3.11.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.7.0,<1.8.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.2.2", + "qtawesome >=1.2.1", + "qtconsole >=5.4.0,<5.5.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.4.1,<2.5.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "8804fa7300c204b66de1aca6cfbcd4a9", + "name": "spyder", + "sha256": "246415a9945df2662a3c6c3594fb8929fc40ab1f5036a427977596f318a25429", + "size": 12651895, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1677776327978, + "type": "app", + "version": "5.4.1" + }, + "spyder-5.4.1-py311h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<9.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pylint-venv >=2.1.1", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine <5.16", + "python >=3.11,<3.12.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.7.0,<1.8.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.2.2", + "qtawesome >=1.2.1", + "qtconsole >=5.4.0,<5.5.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.4.1,<2.5.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "b6cf8962d568f23754d3c7bc9ac4398b", + "name": "spyder", + "sha256": "1ae3c08ad01336e7beef568d42784a0de63b5dd6ecb578143822beb2a95e8342", + "size": 13292771, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1677707166789, + "type": "app", + "version": "5.4.1" + }, + "spyder-5.4.1-py38h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<9.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pylint-venv >=2.1.1", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine <5.16", + "python >=3.8,<3.9.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.7.0,<1.8.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.2.2", + "qtawesome >=1.2.1", + "qtconsole >=5.4.0,<5.5.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.4.1,<2.5.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "fcb9c1c0cffeee4f8e2135c8a04874b5", + "name": "spyder", + "sha256": "caf1e932b534608bafebee41cc213ec60428e6e0dd92c42763105483ee7c8241", + "size": 12639709, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1677776253408, + "type": "app", + "version": "5.4.1" + }, + "spyder-5.4.1-py39h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<9.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pylint-venv >=2.1.1", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine <5.16", + "python >=3.9,<3.10.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.7.0,<1.8.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.2.2", + "qtawesome >=1.2.1", + "qtconsole >=5.4.0,<5.5.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.4.1,<2.5.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "4ef50a82c9266f79e4d19fb912675002", + "name": "spyder", + "sha256": "76d3556bd78dd881b03fcc5341c2ce312e90df17edd2252b78ce990e7a027a51", + "size": 12642744, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1677776170919, + "type": "app", + "version": "5.4.1" + }, + "spyder-5.4.2-py310h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<9.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pylint-venv >=2.1.1", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine <5.16", + "python >=3.10,<3.11.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.7.1,<1.8.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.2.2", + "qtawesome >=1.2.1", + "qtconsole >=5.4.0,<5.5.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.4.2,<2.5.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "5536d056982f983147083e68c65486eb", + "name": "spyder", + "sha256": "15228afc0866c5fa0cf7f6a5a6f5d4ae2b9e398d7fabe8d5612a485d7bd4497c", + "size": 12640641, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1678296361787, + "type": "app", + "version": "5.4.2" + }, + "spyder-5.4.2-py311h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<9.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pylint-venv >=2.1.1", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine <5.16", + "python >=3.11,<3.12.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.7.1,<1.8.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.2.2", + "qtawesome >=1.2.1", + "qtconsole >=5.4.0,<5.5.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.4.2,<2.5.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "7db1823d9440e7968f7c33a19dda87e0", + "name": "spyder", + "sha256": "dc04dd32b001111255a38e542f82f2ec6d023224124ba2e18384e7788b5a6d5a", + "size": 13244949, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1679339238310, + "type": "app", + "version": "5.4.2" + }, + "spyder-5.4.2-py38h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<9.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pylint-venv >=2.1.1", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine <5.16", + "python >=3.8,<3.9.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.7.1,<1.8.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.2.2", + "qtawesome >=1.2.1", + "qtconsole >=5.4.0,<5.5.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.4.2,<2.5.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "17bd2a880e7e74fe1cdbcb97beffad2a", + "name": "spyder", + "sha256": "60666db1567ec6b5ca78c405babf8d41160611e03d5000555778bdc814c353b3", + "size": 12585219, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1678296286363, + "type": "app", + "version": "5.4.2" + }, + "spyder-5.4.2-py39h06a4308_0.tar.bz2": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<9.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pylint-venv >=2.1.1", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine <5.16", + "python >=3.9,<3.10.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.7.1,<1.8.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.2.2", + "qtawesome >=1.2.1", + "qtconsole >=5.4.0,<5.5.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.4.2,<2.5.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "90f1667c68ad4e9a4b79d40f4ce89041", + "name": "spyder", + "sha256": "8a5532f01dbeff9c9d282dec06478317656d14526fa0b7ec387464203923a311", + "size": 12616385, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1678296200126, + "type": "app", + "version": "5.4.2" + }, + "spyder-kernels-0.2.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fbcef364f822a2edd97f6449114f3f6b", + "name": "spyder-kernels", + "sha256": "43bc5f22adaec6cddb96806a073d765a690d3de0c4ead961594f45f36ebf2673", + "size": 67856, + "subdir": "linux-64", + "timestamp": 1531231973650, + "version": "0.2.4" + }, + "spyder-kernels-0.2.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58b559f818cb6fa62203d723af786a3c", + "name": "spyder-kernels", + "sha256": "11ccaa027f79410742fda0db3505093f484ee5dbc2643fef7b10fc6a8e021b8f", + "size": 68407, + "subdir": "linux-64", + "timestamp": 1531232045991, + "version": "0.2.4" + }, + "spyder-kernels-0.2.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "788cec8ef3ee8c1a286f8920d3a9cb99", + "name": "spyder-kernels", + "sha256": "ca45d00d1f1b6c066ed05ef552118bbc630cf579bf3f343aa233a231006278cf", + "size": 68566, + "subdir": "linux-64", + "timestamp": 1531232009808, + "version": "0.2.4" + }, + "spyder-kernels-0.2.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=4.8.2", + "jupyter_client >=5.2.3", + "python >=2.7,<2.8.0a0", + "pyzmq >=17" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fad5d63603f5c4c62795bcf8ebad8609", + "name": "spyder-kernels", + "sha256": "c18ca4c3886ecbf41c794775d2d8fdceb59e6d3febf7b5ad610749b4f7876a3a", + "size": 69935, + "subdir": "linux-64", + "timestamp": 1534261967887, + "version": "0.2.6" + }, + "spyder-kernels-0.2.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=4.8.2", + "jupyter_client >=5.2.3", + "python >=3.5,<3.6.0a0", + "pyzmq >=17" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "162e5c787c5e18fa8e057f5c4f099860", + "name": "spyder-kernels", + "sha256": "7a778dba037e345ec895300189d4e998ef53a1a30da9f7702ec9cefb5a6f6088", + "size": 70922, + "subdir": "linux-64", + "timestamp": 1534261847751, + "version": "0.2.6" + }, + "spyder-kernels-0.2.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=4.8.2", + "jupyter_client >=5.2.3", + "python >=3.6,<3.7.0a0", + "pyzmq >=17" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1bc0950e658a744077f70b3f6d1b4911", + "name": "spyder-kernels", + "sha256": "808f5c1903dd7ba01c93a638e87c4503a60e53a91ce486fbdb0238100735420a", + "size": 70585, + "subdir": "linux-64", + "timestamp": 1534261799320, + "version": "0.2.6" + }, + "spyder-kernels-0.2.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=4.8.2", + "jupyter_client >=5.2.3", + "python >=3.7,<3.8.0a0", + "pyzmq >=17" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2550b60906f5f9f413b845a7555549d8", + "name": "spyder-kernels", + "sha256": "b60a5398c61ea4182530974ea6cdc026ee640433e8af7af58ce523afe8510976", + "size": 70603, + "subdir": "linux-64", + "timestamp": 1534263114934, + "version": "0.2.6" + }, + "spyder-kernels-0.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fbb2408eeb4144bb293ed247f7d5e90b", + "name": "spyder-kernels", + "sha256": "58b4f6dfd2ba26b6aacf9c09e9d3464d1c9c152eab38ca2a4eb6597be1a20f22", + "size": 63444, + "subdir": "linux-64", + "timestamp": 1543426999359, + "version": "0.3.0" + }, + "spyder-kernels-0.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5dfd8b1ea1e72e39a9f1f46ec8340dfe", + "name": "spyder-kernels", + "sha256": "e5ec690f9be233c9fd1d06dfa2b59cd2bf3c4426fd89f2892b1d2551cf9f492c", + "size": 64030, + "subdir": "linux-64", + "timestamp": 1543427074958, + "version": "0.3.0" + }, + "spyder-kernels-0.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a89235b8d4b54ffb55050873d435bec8", + "name": "spyder-kernels", + "sha256": "abcb7af3f06d6b10cfa44bfab5886896f1204ebf35595ec92922a1320aeaaa45", + "size": 64065, + "subdir": "linux-64", + "timestamp": 1543426986791, + "version": "0.3.0" + }, + "spyder-kernels-0.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "53998d30ab9cc6c1ef6d4c5150af959a", + "name": "spyder-kernels", + "sha256": "f77332c2f3bab6362d8c26acf62a5397604f07f4aee391bf5dcec392a729932b", + "size": 65239, + "subdir": "linux-64", + "timestamp": 1549636462846, + "version": "0.4.2" + }, + "spyder-kernels-0.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5284fcbe865eff388bf99c14565417d7", + "name": "spyder-kernels", + "sha256": "e18b21e94f519443c40304a550a33ed7df2c2c619dc5e1ac9327841626a8fc58", + "size": 66024, + "subdir": "linux-64", + "timestamp": 1549636523676, + "version": "0.4.2" + }, + "spyder-kernels-0.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63216d67a02782fb057c21e591606965", + "name": "spyder-kernels", + "sha256": "71141d8afce826552d35bcfce4b7161b41ebdf265384a3951f6cd8a7a7bc42e8", + "size": 66043, + "subdir": "linux-64", + "timestamp": 1549636464706, + "version": "0.4.2" + }, + "spyder-kernels-0.4.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8fcbffc2c92d7dc8cf4a507a7824df37", + "name": "spyder-kernels", + "sha256": "bae2477c27c69200a2a7393b4bbc21121e2a51e78209ef5cb61c00ec01ba4e14", + "size": 68800, + "subdir": "linux-64", + "timestamp": 1554934386819, + "version": "0.4.3" + }, + "spyder-kernels-0.4.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e62c1121162abfa28a123345f954d63", + "name": "spyder-kernels", + "sha256": "38b2341e8c99a0352b2af81ee182e15848f89c742885822b2af5e72a63315236", + "size": 69449, + "subdir": "linux-64", + "timestamp": 1554934403032, + "version": "0.4.3" + }, + "spyder-kernels-0.4.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bf108cd258aba552082103779c32ee4f", + "name": "spyder-kernels", + "sha256": "8fe8ef3cff29480be46f1b6eac06937fad0c43bc325eba9be3e6e33378679fc5", + "size": 69449, + "subdir": "linux-64", + "timestamp": 1554934254666, + "version": "0.4.3" + }, + "spyder-kernels-0.4.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2de870cd134dde9ce377e0bfa040d8e", + "name": "spyder-kernels", + "sha256": "072a350473b21f95ce854e9148a9a4c032144b2cf02cedf1c7eff5c8d98a1136", + "size": 68819, + "subdir": "linux-64", + "timestamp": 1554942265695, + "version": "0.4.4" + }, + "spyder-kernels-0.4.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "623ac88a56abeec6af90691ba014ddba", + "name": "spyder-kernels", + "sha256": "91bd1dc24d703bf97c705283d22caa8be16299948e6bfe8a9dfb3af442d01253", + "size": 69587, + "subdir": "linux-64", + "timestamp": 1554942280104, + "version": "0.4.4" + }, + "spyder-kernels-0.4.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49170e503f97d876e09b56adea8feb9f", + "name": "spyder-kernels", + "sha256": "2f569f10df74c08a5042fe2fd9842479e5cc128ab8d4bb20029fe082fa332138", + "size": 69541, + "subdir": "linux-64", + "timestamp": 1554942344164, + "version": "0.4.4" + }, + "spyder-kernels-0.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b90e472f29ed8e9d37483becfd4effa", + "name": "spyder-kernels", + "sha256": "b9c517e4ad4f5db5349f85733bfbed333fd599e381e46796a26a57d96e48b17d", + "size": 69891, + "subdir": "linux-64", + "timestamp": 1561548550051, + "version": "0.5.0" + }, + "spyder-kernels-0.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe570a26aeea8dd826a6944a80805f8a", + "name": "spyder-kernels", + "sha256": "02529bd58c204fdb3745bb87a91e1c227d2257af4278698075f52d9c07c78c36", + "size": 70519, + "subdir": "linux-64", + "timestamp": 1561548348361, + "version": "0.5.0" + }, + "spyder-kernels-0.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b69ec4386c85d1d94e503c0dce81733", + "name": "spyder-kernels", + "sha256": "a0756ebb2081d3b2a03c9d07cf7f53b8f3eb73eaf93aa156b24b6309049a5200", + "size": 70535, + "subdir": "linux-64", + "timestamp": 1561548350809, + "version": "0.5.0" + }, + "spyder-kernels-0.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60a412112bb0fe77a22ca038e8eed9cd", + "name": "spyder-kernels", + "sha256": "7b8ea74d2b829e3324dea0b3713f72fff827f87d423c91d57f8b6ec58237d19b", + "size": 70135, + "subdir": "linux-64", + "timestamp": 1563205855967, + "version": "0.5.1" + }, + "spyder-kernels-0.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5dd5ea24a8afe8d3dd03902ed57d730", + "name": "spyder-kernels", + "sha256": "bb991a8369ffd4368a6ae67bbceb970cc0d6a74f8ad81d3a35f03cf14922f322", + "size": 70749, + "subdir": "linux-64", + "timestamp": 1563205856920, + "version": "0.5.1" + }, + "spyder-kernels-0.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f31a513f5bfa1bddc9a77851dcd010ef", + "name": "spyder-kernels", + "sha256": "de7cc1377305bc287457156b3d3d6208992603dc24b15d698f56651fd6bc3bb8", + "size": 70832, + "subdir": "linux-64", + "timestamp": 1563205848010, + "version": "0.5.1" + }, + "spyder-kernels-0.5.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "995013ea4418793930e9913bcb7884d3", + "name": "spyder-kernels", + "sha256": "d196b34669b782adee09c06306359a067d96df323bc65b78b5dcf257aa6df840", + "size": 70265, + "subdir": "linux-64", + "timestamp": 1569377835310, + "version": "0.5.2" + }, + "spyder-kernels-0.5.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f21ab6ee065832614d4c834d74afd1af", + "name": "spyder-kernels", + "sha256": "99facf0d482d16242f9a4c79be2e742e5cdb3f5714010468175e214d4b5e1ca0", + "size": 70908, + "subdir": "linux-64", + "timestamp": 1569377830155, + "version": "0.5.2" + }, + "spyder-kernels-0.5.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6000555f88020c4d5b0bb03a498bbcc", + "name": "spyder-kernels", + "sha256": "6fdbe65866dfb4c3dd3aa867393f1b073ac67b5ab68c94e4ae5cdfb0617e0164", + "size": 70918, + "subdir": "linux-64", + "timestamp": 1569377835711, + "version": "0.5.2" + }, + "spyder-kernels-0.5.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "125b1b8c5ead9e1ee13f396f1b815fcf", + "name": "spyder-kernels", + "sha256": "1717057d6c55ef1109535eb37229db1ea9ea7b6c028e27a1c9297a7e516d7dff", + "size": 67848, + "subdir": "linux-64", + "timestamp": 1574237965404, + "version": "0.5.2" + }, + "spyder-kernels-1.10.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fdc6686ea04a97946f81ca091cf93b24", + "name": "spyder-kernels", + "sha256": "65c142fedc2186d3ffe851148a4f37ea7681b5f9dd1db065dd313888011099cc", + "size": 99004, + "subdir": "linux-64", + "timestamp": 1606929328176, + "version": "1.10.0" + }, + "spyder-kernels-1.10.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e365d158feede3c15059b18e055d1116", + "name": "spyder-kernels", + "sha256": "f3581977e3d05d1e098621f8ffdafc92f7cf418896e56ae44a4c5c36907dcd10", + "size": 99049, + "subdir": "linux-64", + "timestamp": 1606929349303, + "version": "1.10.0" + }, + "spyder-kernels-1.10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ae4d83c3b5ac3b2cf758c2c5c422aa17", + "name": "spyder-kernels", + "sha256": "59d04584f934c925bea9d8ca88d51c918d95b7ecd09c1d736c7d3e7f3635cf01", + "size": 99454, + "subdir": "linux-64", + "timestamp": 1606929338852, + "version": "1.10.0" + }, + "spyder-kernels-1.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e2e72c49bb791780117efb41f8387ac2", + "name": "spyder-kernels", + "sha256": "10bf0107cf2e3f74edda78bc47ee1c688b8ed03febdb823a52d019c1484e3b8f", + "size": 105441, + "subdir": "linux-64", + "timestamp": 1607457553596, + "version": "1.10.0" + }, + "spyder-kernels-1.10.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "159a4d48a4f090e25dabfc9b02d5de3d", + "name": "spyder-kernels", + "sha256": "40ecf43becbddd05f3af38dfce68d1cde680683afe9ee101bb87eb5650851abd", + "size": 99436, + "subdir": "linux-64", + "timestamp": 1608578812496, + "version": "1.10.1" + }, + "spyder-kernels-1.10.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e51811af832093043bb47b50a769cf8", + "name": "spyder-kernels", + "sha256": "f40a38175ddb75fa03f342bd82ff7e5ba3e48af87df25898602be979df8c2e4b", + "size": 99544, + "subdir": "linux-64", + "timestamp": 1608578838205, + "version": "1.10.1" + }, + "spyder-kernels-1.10.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca468d81382d0933716db86d18aa28d6", + "name": "spyder-kernels", + "sha256": "c64ca7b57b595010a34e83d5d1c55a76587b9b19b5b896ba8a1684dd9115d3cf", + "size": 99818, + "subdir": "linux-64", + "timestamp": 1608578833289, + "version": "1.10.1" + }, + "spyder-kernels-1.10.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c353ea460a39d7b1c1f7187ed6c7ebdd", + "name": "spyder-kernels", + "sha256": "ea98fd8e1ee45c17cb22c15c304112e1c0cf8c499ef89679bc428b696752cb54", + "size": 100004, + "subdir": "linux-64", + "timestamp": 1608578825508, + "version": "1.10.1" + }, + "spyder-kernels-1.10.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cbcc029e037a1a637787e0d4b9a858fb", + "name": "spyder-kernels", + "sha256": "e6aa1de0e61f246b9c498012cfdf97042d328d65086070ae8bd213302206e036", + "size": 100393, + "subdir": "linux-64", + "timestamp": 1614030621813, + "version": "1.10.2" + }, + "spyder-kernels-1.10.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1327a7e3b40b6337f80db9fcc3783f5a", + "name": "spyder-kernels", + "sha256": "4e1bdf42be37975080e9f3bec4cc6f8b1f97c03f3a1a2be877aa8360b434a5e1", + "size": 100374, + "subdir": "linux-64", + "timestamp": 1614030619140, + "version": "1.10.2" + }, + "spyder-kernels-1.10.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "65dc6d76699afef6f42da50a89e1bda3", + "name": "spyder-kernels", + "sha256": "2d5a1c3839d1cf5e9382ea6f1e3e5156d7e0eaea7d3bb180bf3e8a4d0ef96077", + "size": 100803, + "subdir": "linux-64", + "timestamp": 1614030629656, + "version": "1.10.2" + }, + "spyder-kernels-1.10.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "803cf174577574da2aeef655a0d82493", + "name": "spyder-kernels", + "sha256": "0796c2810bd5597b1f457c5e0d0b2603d9facfaabbc27031e577d3b4f80e2263", + "size": 100942, + "subdir": "linux-64", + "timestamp": 1614029724785, + "version": "1.10.2" + }, + "spyder-kernels-1.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "826e866a3e7a08b6c30495001d13e238", + "name": "spyder-kernels", + "sha256": "fe35e31db84608866821cbc5755e6f904c4034b8690e622bc979bf7abea6e400", + "size": 64384, + "subdir": "linux-64", + "timestamp": 1550363810448, + "version": "1.3.2" + }, + "spyder-kernels-1.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e155dc92e7920087df39d576bcf72f57", + "name": "spyder-kernels", + "sha256": "9b62903c1616e421edb98568fe33738c93a79fbae4f72d091857693498feeb6c", + "size": 65117, + "subdir": "linux-64", + "timestamp": 1550363807578, + "version": "1.3.2" + }, + "spyder-kernels-1.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f94db2b5662eafcd5dc9cf5c566a6072", + "name": "spyder-kernels", + "sha256": "17dc13b4b4e26973e59919ea8c082ea3b564502876b8d85aa17d4ef4f2f15396", + "size": 65068, + "subdir": "linux-64", + "timestamp": 1550363769082, + "version": "1.3.2" + }, + "spyder-kernels-1.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "966b4fce7128f3a0d0b035195a2315d1", + "name": "spyder-kernels", + "sha256": "8f069ebdce7129fc53e7314a06c56264a01fac449c1976bac48f3984391e57b6", + "size": 65929, + "subdir": "linux-64", + "timestamp": 1564708135325, + "version": "1.4.0" + }, + "spyder-kernels-1.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee67351b87f2829d52f41877cd6c8c22", + "name": "spyder-kernels", + "sha256": "3d81bcc78577b734e07d1193ebbe6e64d69639aa818e0f1b444219a9ffa5d55b", + "size": 66602, + "subdir": "linux-64", + "timestamp": 1564708144532, + "version": "1.4.0" + }, + "spyder-kernels-1.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "82d01a0801129ed49119430058d06aff", + "name": "spyder-kernels", + "sha256": "78682a10ac15fe5017ebda20c205d265633332615615639ccc431a3e6e3bc167", + "size": 66588, + "subdir": "linux-64", + "timestamp": 1564708096411, + "version": "1.4.0" + }, + "spyder-kernels-1.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.3.4", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22f00915c47149fac42327848d4329ef", + "name": "spyder-kernels", + "sha256": "bebc2b1ac39e2179dc039620d0126ec0ad67d51eddae0ef46cefaf7666d49934", + "size": 90849, + "subdir": "linux-64", + "timestamp": 1575583640403, + "version": "1.8.1" + }, + "spyder-kernels-1.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "926c015bdb56d1c7e424ecba0115f6c8", + "name": "spyder-kernels", + "sha256": "416169390d21099f7c484c8a9857477e18aa2f25c1387ac338b802c6acb36652", + "size": 91861, + "subdir": "linux-64", + "timestamp": 1575583738871, + "version": "1.8.1" + }, + "spyder-kernels-1.8.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7502b4e7ef3fa499446a0c02ae295c1f", + "name": "spyder-kernels", + "sha256": "14b3488d9d30996175246307010bea1a483c9b5c3ba3c47879d2d08e22f4910e", + "size": 91903, + "subdir": "linux-64", + "timestamp": 1575583697111, + "version": "1.8.1" + }, + "spyder-kernels-1.8.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a9b393a2907e5eb63b673e7fbd26dbc4", + "name": "spyder-kernels", + "sha256": "463c54990f342e88cda895021cd89d4d498bdd4897de27f9329ee9d90072f2ea", + "size": 92239, + "subdir": "linux-64", + "timestamp": 1575583739922, + "version": "1.8.1" + }, + "spyder-kernels-1.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c7150571c9d4a115943f82989db6fdda", + "name": "spyder-kernels", + "sha256": "898317b1077091d4a66b5801115c98716050b168e7ebf060687fdfddf64379d4", + "size": 95344, + "subdir": "linux-64", + "timestamp": 1584457767462, + "version": "1.9.0" + }, + "spyder-kernels-1.9.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c40218b890c18c9da77f32169a735d25", + "name": "spyder-kernels", + "sha256": "2d8abd4088d55db5c7074344360105c5ae5c204d4af2653a832e7139f35b61bf", + "size": 95360, + "subdir": "linux-64", + "timestamp": 1584457716747, + "version": "1.9.0" + }, + "spyder-kernels-1.9.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a4245e3da48120914f5c3f21fbc988bb", + "name": "spyder-kernels", + "sha256": "a9932fa0e0b9263361a4f212f864f915bd116aecf1ef7d2751c12d85c3d6a7a8", + "size": 95608, + "subdir": "linux-64", + "timestamp": 1584457743640, + "version": "1.9.0" + }, + "spyder-kernels-1.9.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "463d9793185add977a2e3a1d90a69557", + "name": "spyder-kernels", + "sha256": "948ff85298985b9693b92953c026248be5ee1900bbe60b261b4b100cf83a28d9", + "size": 95259, + "subdir": "linux-64", + "timestamp": 1588949408889, + "version": "1.9.1" + }, + "spyder-kernels-1.9.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "205bc2cb0324e1c6edabd2c36819c42f", + "name": "spyder-kernels", + "sha256": "394686501b2e43d170bb88583f2f5a7f6e4493876df5f3788e1eeef8ddabad86", + "size": 95308, + "subdir": "linux-64", + "timestamp": 1588949389765, + "version": "1.9.1" + }, + "spyder-kernels-1.9.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc6cbf65ed447c9d7baf39b67221b4ba", + "name": "spyder-kernels", + "sha256": "2d0ff3ae0f0973b8bcc8b3c1fa3bbb82b5b641f2d4b49e85a07bfdabec86376f", + "size": 95592, + "subdir": "linux-64", + "timestamp": 1588949411507, + "version": "1.9.1" + }, + "spyder-kernels-1.9.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1a95f632de760a45a5fa9a34d045125", + "name": "spyder-kernels", + "sha256": "0ece26c0799faad417079392cc2794efaddd030028aa6842d84956690c8891e6", + "size": 96927, + "subdir": "linux-64", + "timestamp": 1594751579108, + "version": "1.9.2" + }, + "spyder-kernels-1.9.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "527e13055e3269f58bf2916260a45678", + "name": "spyder-kernels", + "sha256": "0526d08e3f666f85071462d94a0192830edb776cb3fa650699f352c007f46769", + "size": 96865, + "subdir": "linux-64", + "timestamp": 1594751578336, + "version": "1.9.2" + }, + "spyder-kernels-1.9.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12d9c34ebdcaaf2fc219cb321e822633", + "name": "spyder-kernels", + "sha256": "fe038b20c25e535c396e295855d313ea22d61776330364cf216e31045037ae83", + "size": 97185, + "subdir": "linux-64", + "timestamp": 1594751579927, + "version": "1.9.2" + }, + "spyder-kernels-1.9.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4c989980809bbd983f0d557e5c66f58", + "name": "spyder-kernels", + "sha256": "52d885c1d217c7e0decd6ebce76ec7e2db207006b9a3822f8e2945ef175dfbcf", + "size": 97080, + "subdir": "linux-64", + "timestamp": 1598375156510, + "version": "1.9.3" + }, + "spyder-kernels-1.9.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c84097b33c10e83b5f1226c8c4606fdd", + "name": "spyder-kernels", + "sha256": "705dde11d0091959bd8cb253792c822695b6f1f421584c6398b3ba811784b69a", + "size": 90963, + "subdir": "linux-64", + "timestamp": 1597005065463, + "version": "1.9.3" + }, + "spyder-kernels-1.9.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45233d6640ae4799ae77f0c177f1392a", + "name": "spyder-kernels", + "sha256": "ea4b5e588a5429d5ac9856d48fe19436324cf18adb99916daca7c3dc6604cab9", + "size": 97423, + "subdir": "linux-64", + "timestamp": 1598375160707, + "version": "1.9.3" + }, + "spyder-kernels-1.9.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0e539b5faea3b541458bb4642b065da0", + "name": "spyder-kernels", + "sha256": "fb64032703f80b23f3733a1bbab3f98ca1e2f021d989e42e0b53143a4e0e56ce", + "size": 97512, + "subdir": "linux-64", + "timestamp": 1599056786619, + "version": "1.9.4" + }, + "spyder-kernels-1.9.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c16cafcb2f770421a35454f585be5c68", + "name": "spyder-kernels", + "sha256": "f12ba1c2dcfceb9a2e2b2213c6165903f1f513618e6cc29109337b14ed4b10dc", + "size": 97500, + "subdir": "linux-64", + "timestamp": 1599056786619, + "version": "1.9.4" + }, + "spyder-kernels-1.9.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c427e2ad77bbc5ca4e9c1edf5fc0b10f", + "name": "spyder-kernels", + "sha256": "fb793ef64cafe1d1ce27bb7cc425874109a0a2fa41e526367b2aabc8359f72b5", + "size": 97804, + "subdir": "linux-64", + "timestamp": 1599056788633, + "version": "1.9.4" + }, + "spyder-kernels-2.0.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb9fb8552a03715a2c0df94fb5c5e4e1", + "name": "spyder-kernels", + "sha256": "25e4b938cdc84e68350b3fd80d2b30695c22360c4535c642ba9ff868e1715130", + "size": 100241, + "subdir": "linux-64", + "timestamp": 1617396614787, + "version": "2.0.1" + }, + "spyder-kernels-2.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5fec863d3246c9375de92d5174745433", + "name": "spyder-kernels", + "sha256": "0c0daae02fc4e34155f980320ecc84b3d7edbd97a684e8950509df9ee2955350", + "size": 100259, + "subdir": "linux-64", + "timestamp": 1617395927915, + "version": "2.0.1" + }, + "spyder-kernels-2.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "81e925fd23e5a0ac400d65fa84df7085", + "name": "spyder-kernels", + "sha256": "3d65b2ff3e71f2ccdbfeec2d99308cb21f48453e5ef69352076d420e0bc71484", + "size": 100654, + "subdir": "linux-64", + "timestamp": 1617396603007, + "version": "2.0.1" + }, + "spyder-kernels-2.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15d7d7f7c91860860af96ceec221b7a3", + "name": "spyder-kernels", + "sha256": "6f0ff1002dc14ad3cd75dc8c4a86a3af9279db2441da7e7b59e47e0a8bc7afb1", + "size": 100841, + "subdir": "linux-64", + "timestamp": 1617396596466, + "version": "2.0.1" + }, + "spyder-kernels-2.0.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "decorator <5", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "195a57d843cca3dc72e23ca49b185f4e", + "name": "spyder-kernels", + "sha256": "a044dd825b6b2987d1901586e905df1e40f6c932c4e8cc46d97debd5729bc17e", + "size": 107170, + "subdir": "linux-64", + "timestamp": 1623278699300, + "version": "2.0.3" + }, + "spyder-kernels-2.0.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "decorator <5", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "688bf10701f9a0976918eb589d7dc580", + "name": "spyder-kernels", + "sha256": "27f6965752dc39ec00a96885ed97117dea7ca22c7bf1b5b2e24174afaa1d89c9", + "size": 107213, + "subdir": "linux-64", + "timestamp": 1623273245382, + "version": "2.0.3" + }, + "spyder-kernels-2.0.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "decorator <5", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "26da05ac6f0bda6b6fd58d434f8f0a50", + "name": "spyder-kernels", + "sha256": "edb56207a9d51259ddac057f38e8da6fc20a21e595dfcd3293a7962055fbf8c9", + "size": 107517, + "subdir": "linux-64", + "timestamp": 1623278786555, + "version": "2.0.3" + }, + "spyder-kernels-2.0.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "decorator <5", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "70396b253ac31834ab5804f7bbd12b00", + "name": "spyder-kernels", + "sha256": "c1c9445390cb89b2631cdeb9811191a3be55893bcc7dfed9ed659fde325df033", + "size": 107729, + "subdir": "linux-64", + "timestamp": 1623278802738, + "version": "2.0.3" + }, + "spyder-kernels-2.0.5-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0b93fe3d5cc6b1d6fe18dc7b48c3395", + "name": "spyder-kernels", + "sha256": "4604113a2afd03ef6650a7a9ff622786883f9467f9757a93f6e49b660744b655", + "size": 99129, + "subdir": "linux-64", + "timestamp": 1625670749102, + "version": "2.0.5" + }, + "spyder-kernels-2.0.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e5ad42b2489b1836c199743f734d9426", + "name": "spyder-kernels", + "sha256": "db7a5c18114a93a2a6e742de59b048f012f95f86e7e2f3c958313f30194cdaf5", + "size": 99146, + "subdir": "linux-64", + "timestamp": 1625671073348, + "version": "2.0.5" + }, + "spyder-kernels-2.0.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "426063dcdd21f64d222b64061c659457", + "name": "spyder-kernels", + "sha256": "38f1e8023e2aca391745713c6b98d1b1502cba303f13a653b1c0f2a15a8bfbd3", + "size": 99495, + "subdir": "linux-64", + "timestamp": 1625671065923, + "version": "2.0.5" + }, + "spyder-kernels-2.0.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90f331e804864870c3f9a8cfe9d51a58", + "name": "spyder-kernels", + "sha256": "5f065259746af49d6336a9f2b5c5c1aa100d6676e57ff093927d29bf980b2205", + "size": 99593, + "subdir": "linux-64", + "timestamp": 1625671079102, + "version": "2.0.5" + }, + "spyder-kernels-2.1.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4,<7", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d6770809e9fd5e1a8e85c300a09efab0", + "name": "spyder-kernels", + "sha256": "356867552984e560a20a70b183034067ccab82dd8fb27682b3c4c763b001b29d", + "size": 109674, + "subdir": "linux-64", + "timestamp": 1632249729296, + "version": "2.1.1" + }, + "spyder-kernels-2.1.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4,<7", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5bea6530e1b2b375ac80af36b68d4346", + "name": "spyder-kernels", + "sha256": "caede3f211e2167974015ee90f498639cdc3a77c59cb8d62710eb10e9acbfd55", + "size": 109721, + "subdir": "linux-64", + "timestamp": 1632249720319, + "version": "2.1.1" + }, + "spyder-kernels-2.1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4,<7", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ddd6a72b6b44be7926ef0064b81204ba", + "name": "spyder-kernels", + "sha256": "cc57268234b40bdd87046f65b30e0d74a99535f0d2350bc872275e66ddec9f51", + "size": 110066, + "subdir": "linux-64", + "timestamp": 1632249714645, + "version": "2.1.1" + }, + "spyder-kernels-2.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4,<7", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a9055ef461a26782b10498234ad8ac4e", + "name": "spyder-kernels", + "sha256": "681032d7544e292b92f376b027ac87694e70c4b69bc9a70a165578c452ee00e6", + "size": 110300, + "subdir": "linux-64", + "timestamp": 1632249454109, + "version": "2.1.1" + }, + "spyder-kernels-2.1.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4,<7", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d0ec9f8f759e9cfc3066abc77948527", + "name": "spyder-kernels", + "sha256": "041fff557cc995b19d43669845e7fbc826f7a6ee92e02404d67c83141fb9c1e4", + "size": 104578, + "subdir": "linux-64", + "timestamp": 1642518688479, + "version": "2.1.3" + }, + "spyder-kernels-2.1.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4,<7", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8bc302572a8e3c7c396971b4dfe3a65b", + "name": "spyder-kernels", + "sha256": "ec7a80b00ed328d6d68ec3fc9dfc87fa2ea4374eda443bc04c3605e07efe61c5", + "size": 111415, + "subdir": "linux-64", + "timestamp": 1634236955582, + "version": "2.1.3" + }, + "spyder-kernels-2.1.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4,<7", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d67ce34ffafa828fed41392482d275b9", + "name": "spyder-kernels", + "sha256": "9e66a542e6b2bc527e35be11206f5257164e9ade7e659700b503e450b94864e1", + "size": 111792, + "subdir": "linux-64", + "timestamp": 1634236960071, + "version": "2.1.3" + }, + "spyder-kernels-2.1.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4,<7", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3f7772275deb2b805b0586f5eadf83e", + "name": "spyder-kernels", + "sha256": "d2ce94be490887d9054633e4b57d8fb48cfeef4b83a6ca7d2fe639b2e7b31cd3", + "size": 111899, + "subdir": "linux-64", + "timestamp": 1634236950330, + "version": "2.1.3" + }, + "spyder-kernels-2.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8b4cbfa162f80b92235706636592d93", + "name": "spyder-kernels", + "sha256": "e276c93c35cd04bf8fc0ecbb977a8041987fe2e5bb3d1b837936611834603ac8", + "size": 113579, + "subdir": "linux-64", + "timestamp": 1641393018023, + "version": "2.2.0" + }, + "spyder-kernels-2.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1fb8f7e317468e580bc7c3ff20f6cfa0", + "name": "spyder-kernels", + "sha256": "43aede977fd8fd12709aae8ed7846929fbc449536cb06568af1260435507e492", + "size": 113904, + "subdir": "linux-64", + "timestamp": 1641393021672, + "version": "2.2.0" + }, + "spyder-kernels-2.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0693b5f39872ba41056c6e4abe5bc877", + "name": "spyder-kernels", + "sha256": "5f211fb6ab3efad8035d3404582533cd84b87a57e7f793d4411cc677481ba707", + "size": 114179, + "subdir": "linux-64", + "timestamp": 1641393017589, + "version": "2.2.0" + }, + "spyder-kernels-2.2.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.6.1", + "ipython >=7.6.0,<8.0.0", + "jupyter_client >=7.1.0", + "python >=3.10,<3.11.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb86e50f27b4e2c9ee7a5cd76fd798c1", + "name": "spyder-kernels", + "sha256": "229236de7cf2f2d62577dcb03941847e859de694e741f94c3ac64e2951cbba52", + "size": 115983, + "subdir": "linux-64", + "timestamp": 1647011273819, + "version": "2.2.1" + }, + "spyder-kernels-2.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.6.1", + "ipython >=7.6.0,<8.0.0", + "jupyter_client >=7.1.0", + "python >=3.7,<3.8.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "369edf468d6b50c3b12eb032f9d82abb", + "name": "spyder-kernels", + "sha256": "9753d474f2e5b68934fc36f149bcd86faf11f3994d2ffddaf879311439d8760d", + "size": 114272, + "subdir": "linux-64", + "timestamp": 1646993694832, + "version": "2.2.1" + }, + "spyder-kernels-2.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.6.1", + "ipython >=7.6.0,<8.0.0", + "jupyter_client >=7.1.0", + "python >=3.8,<3.9.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1de312852491845686680fa9b386aa38", + "name": "spyder-kernels", + "sha256": "4dc67383ad06d6e2ff5e45ec4d6019b2553c1624d7a865e301b4a4ae49c1f77b", + "size": 114700, + "subdir": "linux-64", + "timestamp": 1647011261195, + "version": "2.2.1" + }, + "spyder-kernels-2.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.6.1", + "ipython >=7.6.0,<8.0.0", + "jupyter_client >=7.1.0", + "python >=3.9,<3.10.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cdf1a6fa7820edc1c375bb0192a9fe3f", + "name": "spyder-kernels", + "sha256": "9ff1be7f6a9426afdbcf28fda90d455e50a2cd4d3753f74174d44b5bebfe6bed", + "size": 114909, + "subdir": "linux-64", + "timestamp": 1647011256326, + "version": "2.2.1" + }, + "spyder-kernels-2.3.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.9.2,<7.0.0", + "ipython >=7.31.1,<8.0.0", + "jupyter_client >=7.3.4,<8.0.0", + "python >=3.10,<3.11.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4cf9296cfb476a84fc2d5175be00a9f6", + "name": "spyder-kernels", + "sha256": "a060c05058ed46b694d31bd7f7b3777037dce8cc6c38df6e1bb9a74daebe5c20", + "size": 110747, + "subdir": "linux-64", + "timestamp": 1662458042577, + "version": "2.3.3" + }, + "spyder-kernels-2.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.9.2,<7.0.0", + "ipython >=7.31.1,<8.0.0", + "jupyter_client >=7.3.4,<8.0.0", + "python >=3.7,<3.8.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5485c7b023605ddaed727f920b75b865", + "name": "spyder-kernels", + "sha256": "d71e1694ff05c2f4f8ca8d009b403872886d75616985e2465bc09ab1cd687466", + "size": 109073, + "subdir": "linux-64", + "timestamp": 1662457919629, + "version": "2.3.3" + }, + "spyder-kernels-2.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.9.2,<7.0.0", + "ipython >=7.31.1,<8.0.0", + "jupyter_client >=7.3.4,<8.0.0", + "python >=3.8,<3.9.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74fc6f15b5da5c86b42160b6445e5500", + "name": "spyder-kernels", + "sha256": "51581c34c5a3132c4c26882434b15a6e48face197fa6373588a9ccdffbc7cac0", + "size": 109518, + "subdir": "linux-64", + "timestamp": 1662457954084, + "version": "2.3.3" + }, + "spyder-kernels-2.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.9.2,<7.0.0", + "ipython >=7.31.1,<8.0.0", + "jupyter_client >=7.3.4,<8.0.0", + "python >=3.9,<3.10.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "55b862d577860695b470e1f8daf87c11", + "name": "spyder-kernels", + "sha256": "68b67d603f560255184f1df4e80157d5250334b9cb5078961613ffbe76c24455", + "size": 109747, + "subdir": "linux-64", + "timestamp": 1662457987937, + "version": "2.3.3" + }, + "spyder-kernels-2.4.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.16.1,<7.0.0", + "ipython >=7.31.1,<9.0.0", + "jupyter_client >=7.3.4,<8.0.0", + "packaging", + "python >=3.10,<3.11.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a88be2131afd09b0488976f93371474", + "name": "spyder-kernels", + "sha256": "1e079037a5ceb5f0b439297249b23a374cd11de5cf9642ce7dfdf9f9f077b06e", + "size": 144705, + "subdir": "linux-64", + "timestamp": 1673292299338, + "version": "2.4.1" + }, + "spyder-kernels-2.4.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.16.1,<7.0.0", + "ipython >=7.31.1,<9.0.0", + "jupyter_client >=7.3.4,<8.0.0", + "packaging", + "python >=3.11,<3.12.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c9e15649f9c096b18dc2bd5cc8cafbc5", + "name": "spyder-kernels", + "sha256": "61147264092369c1c7eb2a7b15d06f535cac1c9fb805718d3db8cda25c177227", + "size": 189993, + "subdir": "linux-64", + "timestamp": 1677696674388, + "version": "2.4.1" + }, + "spyder-kernels-2.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.16.1,<7.0.0", + "ipython >=7.31.1,<9.0.0", + "jupyter_client >=7.3.4,<8.0.0", + "packaging", + "python >=3.8,<3.9.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c2669a7c5df5d08c45bb5fa247efab1", + "name": "spyder-kernels", + "sha256": "c6a29965365cf06cae882a7da2a7b0258e47069e95a9b5a7679194809054b682", + "size": 143328, + "subdir": "linux-64", + "timestamp": 1673292330376, + "version": "2.4.1" + }, + "spyder-kernels-2.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.16.1,<7.0.0", + "ipython >=7.31.1,<9.0.0", + "jupyter_client >=7.3.4,<8.0.0", + "packaging", + "python >=3.9,<3.10.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca2d80522059d70dd168f6a5d3eff4fb", + "name": "spyder-kernels", + "sha256": "926d69345c0a87d0dedebdb694968eb66528af19c1b2f0b1a14226cf1959e6f4", + "size": 143365, + "subdir": "linux-64", + "timestamp": 1673292267056, + "version": "2.4.1" + }, + "spyder-kernels-2.4.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.16.1,<7.0.0", + "ipython >=7.31.1,<9.0.0", + "jupyter_client >=7.4.9,<8.0.0", + "python >=3.10,<3.11.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f531034d28ed464901022d3447092643", + "name": "spyder-kernels", + "sha256": "8fd32192fc7c0066ffce35f4c55ed6b2e7236a9244e543f641f52967eb50244c", + "size": 144539, + "subdir": "linux-64", + "timestamp": 1678120626506, + "version": "2.4.2" + }, + "spyder-kernels-2.4.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.16.1,<7.0.0", + "ipython >=7.31.1,<9.0.0", + "jupyter_client >=7.4.9,<8.0.0", + "python >=3.11,<3.12.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ee1e3ef29ba1774a8dd9cfa6094b3d5", + "name": "spyder-kernels", + "sha256": "602eba547e4c067a0995d1f8dc82191aaffc4a528a8cb8d752e6d1426005bf7e", + "size": 189873, + "subdir": "linux-64", + "timestamp": 1679339273338, + "version": "2.4.2" + }, + "spyder-kernels-2.4.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.16.1,<7.0.0", + "ipython >=7.31.1,<9.0.0", + "jupyter_client >=7.4.9,<8.0.0", + "python >=3.8,<3.9.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e97816790324eda6916025f9ca5761d9", + "name": "spyder-kernels", + "sha256": "45084c640288a134474d935ee8e656a3e595bf0651d2ed7bab93b746ec118d5a", + "size": 143222, + "subdir": "linux-64", + "timestamp": 1678120658923, + "version": "2.4.2" + }, + "spyder-kernels-2.4.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.16.1,<7.0.0", + "ipython >=7.31.1,<9.0.0", + "jupyter_client >=7.4.9,<8.0.0", + "python >=3.9,<3.10.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2a7e4ffa44cd075a8c05e690fab0934e", + "name": "spyder-kernels", + "sha256": "ec0c025a6e12eb79c9a28b06e563f3b4417f790db25f942d4bc878d8ddb2481e", + "size": 143234, + "subdir": "linux-64", + "timestamp": 1678120691636, + "version": "2.4.2" + }, + "sqlalchemy-1.1.13-py27hb0a01da_0.tar.bz2": { + "build": "py27hb0a01da_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d1fa1021e302edfaa5032f0531cddf4e", + "name": "sqlalchemy", + "sha256": "da94c6712a63861828428b395a207d7c132e07a75415a7028bec845572b4f80f", + "size": 1526397, + "subdir": "linux-64", + "timestamp": 1505691314964, + "version": "1.1.13" + }, + "sqlalchemy-1.1.13-py35h4911131_0.tar.bz2": { + "build": "py35h4911131_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "7c4fd2de4e25bf9d79511976cb768ae0", + "name": "sqlalchemy", + "sha256": "913ae08dc4d6c4106775f9eb15f29fe5d8ffb7e484b7532bf5dda658b8a40fb2", + "size": 1574417, + "subdir": "linux-64", + "timestamp": 1505691345949, + "version": "1.1.13" + }, + "sqlalchemy-1.1.13-py36hfb5efd7_0.tar.bz2": { + "build": "py36hfb5efd7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b9f3e16a358e05899dd7350f8c35fc6b", + "name": "sqlalchemy", + "sha256": "7cbcd844e253f58f9d7a87401d0531548552d76efc2010788b34522407970f08", + "size": 1544449, + "subdir": "linux-64", + "timestamp": 1505691376985, + "version": "1.1.13" + }, + "sqlalchemy-1.2.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7e67b16cb900fff0f1d1add60dd85719", + "name": "sqlalchemy", + "sha256": "6ab7b5b7bb9b3c39c77b62d609e9dfb5d1d76151888f838d7d2875ff93630b58", + "size": 1592769, + "subdir": "linux-64", + "timestamp": 1515725072899, + "version": "1.2.0" + }, + "sqlalchemy-1.2.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "09f3724dcd8f281b205bc162807d68c6", + "name": "sqlalchemy", + "sha256": "00b4e183d2c52506cdffd3c88e0bc6d8cad23bd681fa61a9127b2b07ad4ac822", + "size": 1637498, + "subdir": "linux-64", + "timestamp": 1515725295800, + "version": "1.2.0" + }, + "sqlalchemy-1.2.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "13d77a6db7adaf9c6a9fbfa1e7ec903b", + "name": "sqlalchemy", + "sha256": "a92b4e8ea98a252c1490f16d683a4a07023f83783354f0e8db030987d8615565", + "size": 1643561, + "subdir": "linux-64", + "timestamp": 1515725285325, + "version": "1.2.0" + }, + "sqlalchemy-1.2.1-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ec1c38823bffaf20dd2344fe471c3c6d", + "name": "sqlalchemy", + "sha256": "d3626e30d68db9b36a3c2eee35a8b8f0ee5639af411e343a0278ce72b44c5763", + "size": 1594289, + "subdir": "linux-64", + "timestamp": 1516376497809, + "version": "1.2.1" + }, + "sqlalchemy-1.2.1-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "e6e6a44ebd77bdd3000003d4821dc98d", + "name": "sqlalchemy", + "sha256": "f6eeae124929b2cbcc8eca3237be322d36e6a2f1789ac0cfc8b3a567412bcaab", + "size": 1640307, + "subdir": "linux-64", + "timestamp": 1516376766835, + "version": "1.2.1" + }, + "sqlalchemy-1.2.1-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "adf5c0d2949ff24c3bd00b06c59f56a3", + "name": "sqlalchemy", + "sha256": "6a85642ac445458e6c98a46c1bf2ec79e8a994501d59be710be44290319cab5d", + "size": 1644613, + "subdir": "linux-64", + "timestamp": 1516376758656, + "version": "1.2.1" + }, + "sqlalchemy-1.2.10-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5bc48685d559943ffc1bc644a062f0d0", + "name": "sqlalchemy", + "sha256": "0efe80aa846d932b4b2022edf52e389fc753e6d42a42ffb5ec448186c79ad9d6", + "size": 1634570, + "subdir": "linux-64", + "timestamp": 1532459516475, + "version": "1.2.10" + }, + "sqlalchemy-1.2.10-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "de04e3172d51187f0ab5738afb05baa1", + "name": "sqlalchemy", + "sha256": "d0c49576bb0741ea25756647d0700368c9d1693d1df031618543a14c32a2ad25", + "size": 1677861, + "subdir": "linux-64", + "timestamp": 1532459443976, + "version": "1.2.10" + }, + "sqlalchemy-1.2.10-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "634ab9e0c198e0178df4b3eaa85ddcd9", + "name": "sqlalchemy", + "sha256": "5a2b2e3eb491973bd1cf546c1fb37717c99a7f71dbc48d1cf6539522921362e5", + "size": 1678227, + "subdir": "linux-64", + "timestamp": 1532459501808, + "version": "1.2.10" + }, + "sqlalchemy-1.2.10-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f8f69f4c7e70a52a398129b6dabb0b14", + "name": "sqlalchemy", + "sha256": "b8d7c37cdea5950e4dbeb9d54f187b0307433806ba35754801365fb1c92c665a", + "size": 1679646, + "subdir": "linux-64", + "timestamp": 1532459523301, + "version": "1.2.10" + }, + "sqlalchemy-1.2.11-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "817686c51d775094baca56372c397d1c", + "name": "sqlalchemy", + "sha256": "0cf68cac2a8e255644f2a4ba870442116fdb70a23f9fc41443a5e08fb765c027", + "size": 1630322, + "subdir": "linux-64", + "timestamp": 1535379540967, + "version": "1.2.11" + }, + "sqlalchemy-1.2.11-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "90ba23ef82f796ba8102e1b3221957aa", + "name": "sqlalchemy", + "sha256": "fa26014dac569f636e4d481033851a01cea6409dfe4b347476325aeacb2b1373", + "size": 1670366, + "subdir": "linux-64", + "timestamp": 1535379455276, + "version": "1.2.11" + }, + "sqlalchemy-1.2.11-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d5d74a51c4e067265a0ed48cdca24e16", + "name": "sqlalchemy", + "sha256": "7a592ce6bf46392b2be7b808e67118ff338919590bb18cc000299250a9a6c8b7", + "size": 1673397, + "subdir": "linux-64", + "timestamp": 1535379516283, + "version": "1.2.11" + }, + "sqlalchemy-1.2.11-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "bdea96a67d73f83298079003572ce809", + "name": "sqlalchemy", + "sha256": "46b47e62b8c09e68124078a91f36d28e60e0ce349a394f1bfc73ad6e371e5c2b", + "size": 1673740, + "subdir": "linux-64", + "timestamp": 1535379552993, + "version": "1.2.11" + }, + "sqlalchemy-1.2.12-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ac7e969e63ef28c51885400ab9225460", + "name": "sqlalchemy", + "sha256": "933fb77651ffebdaddd6eb2cd50d9228045aeb2fc970ab16d24cf0822deeca0e", + "size": 1635051, + "subdir": "linux-64", + "timestamp": 1538157133605, + "version": "1.2.12" + }, + "sqlalchemy-1.2.12-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "cfd0492f08e4e6ea6fb5845773985256", + "name": "sqlalchemy", + "sha256": "3a1f178d954c0aae068cf7b968295c920000122f4df143dd5246ff25e03e89db", + "size": 1676571, + "subdir": "linux-64", + "timestamp": 1538157141480, + "version": "1.2.12" + }, + "sqlalchemy-1.2.12-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "757003ea6bc121dae619fad46006f8c2", + "name": "sqlalchemy", + "sha256": "5b6b6e6d4ea64eb8b9faa699846d778869bbad9d7a07f5115d60e5f791ecc5eb", + "size": 1678296, + "subdir": "linux-64", + "timestamp": 1538157136035, + "version": "1.2.12" + }, + "sqlalchemy-1.2.13-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "fb1dd14c1ca78c808e9e81a7b12b8dda", + "name": "sqlalchemy", + "sha256": "a66f7be2cd78f757bffeb784a50da8de0cccb21b75d0d4812ba6dca8599b8ce9", + "size": 1729851, + "subdir": "linux-64", + "timestamp": 1541450168066, + "version": "1.2.13" + }, + "sqlalchemy-1.2.13-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "94304ca71e2cd3a9b0b8b2c95c7264fc", + "name": "sqlalchemy", + "sha256": "4bcce8106ca88539f093aaafb7a5894c9db2ba63c892076a18d9cf0b759914e3", + "size": 1757217, + "subdir": "linux-64", + "timestamp": 1541450207931, + "version": "1.2.13" + }, + "sqlalchemy-1.2.13-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a3a93e7342a01e91f6be776b01428d7a", + "name": "sqlalchemy", + "sha256": "c9ba69ef2fc273f53cd8fb3fe6526a428ca215faf89a622354099a2cfbe983f5", + "size": 1757469, + "subdir": "linux-64", + "timestamp": 1541450175261, + "version": "1.2.13" + }, + "sqlalchemy-1.2.14-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "49b5901234e3228fbe10ba1fc5bee569", + "name": "sqlalchemy", + "sha256": "941393c19c5087fcad0c1c9c4958c8e49f4eb935328ece6505a5ff6dcd1fe9a5", + "size": 1725835, + "subdir": "linux-64", + "timestamp": 1542090471012, + "version": "1.2.14" + }, + "sqlalchemy-1.2.14-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "dbc717b32c78864488b0ac96db677a73", + "name": "sqlalchemy", + "sha256": "a9bdc682b82b9e10c9397ba9bcf5c340a39c51fea98b7bcc37a18defc84ac7cf", + "size": 1755472, + "subdir": "linux-64", + "timestamp": 1542090501750, + "version": "1.2.14" + }, + "sqlalchemy-1.2.14-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "bde9314d9442da55314d70ad4e1ebee9", + "name": "sqlalchemy", + "sha256": "641a824ee08124365ad30fe198362cc06de6d1796970a594a8f30bd40d7db854", + "size": 1758328, + "subdir": "linux-64", + "timestamp": 1542090465445, + "version": "1.2.14" + }, + "sqlalchemy-1.2.15-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9d544d9ad9518fa70a31f3bf40d21fec", + "name": "sqlalchemy", + "sha256": "cf389db0624b737d38d9ae35bbfec3eefb7db82c355280801ae91b14b95bf62b", + "size": 1725603, + "subdir": "linux-64", + "timestamp": 1545075325418, + "version": "1.2.15" + }, + "sqlalchemy-1.2.15-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "68b3aa45e6b3783503890df7dfea1ae2", + "name": "sqlalchemy", + "sha256": "e78881f5d6f386516fba4255364c2952f7d639d4a416312e9b9351a2066a5e9d", + "size": 1757680, + "subdir": "linux-64", + "timestamp": 1545075328855, + "version": "1.2.15" + }, + "sqlalchemy-1.2.15-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ef689f93517d8df4d61025c55125bbae", + "name": "sqlalchemy", + "sha256": "4b060a00bea7adaaa43705d625db4e0481eb3a2ffa332ed47df95d970bca508f", + "size": 1760070, + "subdir": "linux-64", + "timestamp": 1545075329713, + "version": "1.2.15" + }, + "sqlalchemy-1.2.16-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c8e37d6fa016075e6dc6b262f4a45ea5", + "name": "sqlalchemy", + "sha256": "7733ec194e4920f854db7dc58c94206c36d02f9b15720a7748ae6140ddfb7af7", + "size": 1745247, + "subdir": "linux-64", + "timestamp": 1547907654421, + "version": "1.2.16" + }, + "sqlalchemy-1.2.16-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9f26e7808f4aebf530f4f6e79a2d6940", + "name": "sqlalchemy", + "sha256": "4e85cb780669811cf71c9167ec2ee9d9ace121bea7d47926cdddc48b53009f3a", + "size": 1770308, + "subdir": "linux-64", + "timestamp": 1547907652825, + "version": "1.2.16" + }, + "sqlalchemy-1.2.16-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "82f66c9f1b8fe06a3898370e9993a73c", + "name": "sqlalchemy", + "sha256": "0ffa8986857f34a5045e0ebf73e8465fca22112fa96f0072db16f8f19a2cb32f", + "size": 1770388, + "subdir": "linux-64", + "timestamp": 1547907663598, + "version": "1.2.16" + }, + "sqlalchemy-1.2.17-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ae8d0c5dfaf276b4dff71406fe5e8f93", + "name": "sqlalchemy", + "sha256": "60ecbc0f9dd8209ca903c3fe29ebf8bda36789110765b431a0b07428aa9cf56a", + "size": 1732876, + "subdir": "linux-64", + "timestamp": 1549338052786, + "version": "1.2.17" + }, + "sqlalchemy-1.2.17-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a6e93a84c9f9b21d353b4006cfc58d1f", + "name": "sqlalchemy", + "sha256": "2c09e802f933bb3d7a4845941b319b9767a260d901b03667ed317336f54d7039", + "size": 1762948, + "subdir": "linux-64", + "timestamp": 1549328178036, + "version": "1.2.17" + }, + "sqlalchemy-1.2.17-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "206309e547b4eca3d1a93b36a706c3bc", + "name": "sqlalchemy", + "sha256": "f7cd69bb87e86c218584196624a47c2a7ba22ca55a4293eddc0c80bdf0a6d71d", + "size": 1762666, + "subdir": "linux-64", + "timestamp": 1549328131611, + "version": "1.2.17" + }, + "sqlalchemy-1.2.18-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "8ed424931ac16db615e75880f92f838c", + "name": "sqlalchemy", + "sha256": "5ca9bdbfcce853cd74621ccdbd1bd93f714d2cdd445d0d39d53e1d4b5ad300f3", + "size": 1741735, + "subdir": "linux-64", + "timestamp": 1550363081280, + "version": "1.2.18" + }, + "sqlalchemy-1.2.18-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1aa8fc5375c7bde0bfaa2c6e385de38e", + "name": "sqlalchemy", + "sha256": "6a5e222847e669fb7c660589b8d07ef68414530dd293dd50c58d433b962afa33", + "size": 1767671, + "subdir": "linux-64", + "timestamp": 1550363102085, + "version": "1.2.18" + }, + "sqlalchemy-1.2.18-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f8db884bf4bab655de674be1fc540977", + "name": "sqlalchemy", + "sha256": "eef463c4eece2eeb5c4c0fb284e09e4ba29b2f11b417bee8dda1d8ecc7067a48", + "size": 1768075, + "subdir": "linux-64", + "timestamp": 1550363034135, + "version": "1.2.18" + }, + "sqlalchemy-1.2.3-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "aa027543de087a1799f96ad7e131ee4b", + "name": "sqlalchemy", + "sha256": "0370ed3c05e55e48454ccd89520551988d08db878ef7475261a432978975d878", + "size": 1607943, + "subdir": "linux-64", + "timestamp": 1519139748676, + "version": "1.2.3" + }, + "sqlalchemy-1.2.3-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "e8d1c87e9f324cd25338a8389cc3e685", + "name": "sqlalchemy", + "sha256": "0806d1c364460aa4858f3ac4937deed1a6c811b49d9103e464ea097732221f4c", + "size": 1647824, + "subdir": "linux-64", + "timestamp": 1519139750951, + "version": "1.2.3" + }, + "sqlalchemy-1.2.3-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4387eadbf45cd046a694d813672fc540", + "name": "sqlalchemy", + "sha256": "b085f416f18760c1960c4f60b8cde022be44024e24b05665b10ff7162877c755", + "size": 1649145, + "subdir": "linux-64", + "timestamp": 1519139843718, + "version": "1.2.3" + }, + "sqlalchemy-1.2.4-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "bdf614d2c27e494a832d399188c9b463", + "name": "sqlalchemy", + "sha256": "9a6db756504294fba1b981bb9781679b4dd075fd6ddce30500e06eece34f6bf4", + "size": 1608004, + "subdir": "linux-64", + "timestamp": 1519747717932, + "version": "1.2.4" + }, + "sqlalchemy-1.2.4-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "70640ab2a2570896d629b682ef86b596", + "name": "sqlalchemy", + "sha256": "87e8257d4b0b83cb1465c38809b3e24dff86d1ab8ca50a865a6fe1fd1772c14e", + "size": 1647943, + "subdir": "linux-64", + "timestamp": 1519747777784, + "version": "1.2.4" + }, + "sqlalchemy-1.2.4-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "5d3c6e54e33570120b51309783a087f1", + "name": "sqlalchemy", + "sha256": "02f9fdb05a8d443a0491039a4f2c0339e68fe199aca6b3ad1b8b43737e17c1fe", + "size": 1649287, + "subdir": "linux-64", + "timestamp": 1519747713828, + "version": "1.2.4" + }, + "sqlalchemy-1.2.5-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5a72aa40d6d9fdb373e7df13d7d6a42d", + "name": "sqlalchemy", + "sha256": "8feec51c976a38560b59c4dcc923e6782d6510d4fd81bdadc86d495a578d3f1b", + "size": 1612569, + "subdir": "linux-64", + "timestamp": 1520973167440, + "version": "1.2.5" + }, + "sqlalchemy-1.2.5-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "84f60be2b7322fb479590361495ebd68", + "name": "sqlalchemy", + "sha256": "d8303942e99d1a98557effcb2c03a2060e358427180e66d7a83982f377c6c456", + "size": 1652189, + "subdir": "linux-64", + "timestamp": 1520973174842, + "version": "1.2.5" + }, + "sqlalchemy-1.2.5-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "65d8936cd1f59289f75d95392128fb1b", + "name": "sqlalchemy", + "sha256": "1dcb2f64d40467ebc3a4572821838b26095db0bf0a4cd8a662f19c0fad331d2e", + "size": 1654049, + "subdir": "linux-64", + "timestamp": 1520972981968, + "version": "1.2.5" + }, + "sqlalchemy-1.2.6-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c42464bd7f3d3c8a7c823c4a47e53e3d", + "name": "sqlalchemy", + "sha256": "ffb37734a584a95f1d77e29b69235c6e0ec4251842d5041f5591dcc96823b7ca", + "size": 1612459, + "subdir": "linux-64", + "timestamp": 1522690128088, + "version": "1.2.6" + }, + "sqlalchemy-1.2.6-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "5937ca72bd3bf1cfc78e8a256d32eff9", + "name": "sqlalchemy", + "sha256": "9124398c1679bcbc6fc78804b8429c5da4cf513149e1851141b254b0010b094b", + "size": 1655149, + "subdir": "linux-64", + "timestamp": 1522690348760, + "version": "1.2.6" + }, + "sqlalchemy-1.2.6-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "93ea6824e87c9ae12e024e17297e269b", + "name": "sqlalchemy", + "sha256": "a2d7279abfc06e9afebc485de5f772cfd01a0a7d15f457dee1766b12b0f55471", + "size": 1655390, + "subdir": "linux-64", + "timestamp": 1522690342697, + "version": "1.2.6" + }, + "sqlalchemy-1.2.7-py27h6b74fdf_0.tar.bz2": { + "build": "py27h6b74fdf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "6882a51f6075116f8489b1a4a12fa1fc", + "name": "sqlalchemy", + "sha256": "91e8034d0f022a593bae18a418da781e4862ccd2aa97f836b0a808ad0464a221", + "size": 1617245, + "subdir": "linux-64", + "timestamp": 1524496109593, + "version": "1.2.7" + }, + "sqlalchemy-1.2.7-py35h6b74fdf_0.tar.bz2": { + "build": "py35h6b74fdf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "7428b48b986b7d2ad622d59d27bedddb", + "name": "sqlalchemy", + "sha256": "bd5cbda55c21777102db926378aaa46699654522337f43c2b98a7b4033732e54", + "size": 1657598, + "subdir": "linux-64", + "timestamp": 1524496122699, + "version": "1.2.7" + }, + "sqlalchemy-1.2.7-py36h6b74fdf_0.tar.bz2": { + "build": "py36h6b74fdf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "26578809cbc0c2fb7393c0a143b79596", + "name": "sqlalchemy", + "sha256": "3840a78071eee79bfce5e9de51cfec1ec945b98bd8b9aa60b4660d8a7d24f2ac", + "size": 1657482, + "subdir": "linux-64", + "timestamp": 1524496002837, + "version": "1.2.7" + }, + "sqlalchemy-1.2.8-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "4dffd3658b0a15e49c3f320dde83f8d1", + "name": "sqlalchemy", + "sha256": "708fb7daf9bd462bf62913874c8c161cfea78117578974ef554900e34abde154", + "size": 1625206, + "subdir": "linux-64", + "timestamp": 1527822704163, + "version": "1.2.8" + }, + "sqlalchemy-1.2.8-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "ad0d46ebeab803705637c60895f1b5ad", + "name": "sqlalchemy", + "sha256": "c168b5f35f4f77bee3240f20b8e0f144c71321d3920598cf33e196285863acc2", + "size": 1664925, + "subdir": "linux-64", + "timestamp": 1527822729843, + "version": "1.2.8" + }, + "sqlalchemy-1.2.8-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d3892e7277d10a6e42fc45947c998126", + "name": "sqlalchemy", + "sha256": "6250fa79e2289bf2463c091f13a27bba5609e2fe5c3fa2d4d0a8463ce3f5099a", + "size": 1663173, + "subdir": "linux-64", + "timestamp": 1527822696882, + "version": "1.2.8" + }, + "sqlalchemy-1.2.8-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "68597c80dd110555f934a295ae28d675", + "name": "sqlalchemy", + "sha256": "25b98cb8f791f31e92b14a7d526c493cfed600744d9aab94914e4828ceb39790", + "size": 1665102, + "subdir": "linux-64", + "timestamp": 1530736394573, + "version": "1.2.8" + }, + "sqlalchemy-1.3.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b6bcd7bd846e7629a62a9265ab28bbca", + "name": "sqlalchemy", + "sha256": "cdc07a397a0b3139deccd809f1970827259d89efc660372f9ee5ff6dee32ad78", + "size": 1779726, + "subdir": "linux-64", + "timestamp": 1552327503886, + "version": "1.3.1" + }, + "sqlalchemy-1.3.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "38ed942c697ef53620f64a6a76c6e459", + "name": "sqlalchemy", + "sha256": "b2c949de81fbda4065e08393c68d28fe0a4f41d6a769877902edb87df29d4925", + "size": 1808670, + "subdir": "linux-64", + "timestamp": 1552327487540, + "version": "1.3.1" + }, + "sqlalchemy-1.3.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "fd95ba7db58ce320af54ae3d725b1c5b", + "name": "sqlalchemy", + "sha256": "9efcc2e3c68a2547cc3f0a0c826be367e3bc2586a26e0237e123d6968b0c4383", + "size": 1810181, + "subdir": "linux-64", + "timestamp": 1552328457626, + "version": "1.3.1" + }, + "sqlalchemy-1.3.10-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "6f9d4f76eb07187dc8920589d85fcce1", + "name": "sqlalchemy", + "sha256": "85087d21d3db0a7593c6a68bdad90ffeb9bbd6ae06fe56cc4908edd1551dfd92", + "size": 1817129, + "subdir": "linux-64", + "timestamp": 1571758665307, + "version": "1.3.10" + }, + "sqlalchemy-1.3.10-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e2d0068ae13c082f01db4c5085eb5284", + "name": "sqlalchemy", + "sha256": "6dfabe4a22079ba28e7183a52815e208b7dc6bb591b73cc81dca61b7b06d240a", + "size": 1847594, + "subdir": "linux-64", + "timestamp": 1571758666343, + "version": "1.3.10" + }, + "sqlalchemy-1.3.10-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "0afa8d902f2f13eed425de03b1c56568", + "name": "sqlalchemy", + "sha256": "a6b28487d4c7fdd430950bec8fc60ca9bcede79f122093c08548b7cee24f467e", + "size": 1845341, + "subdir": "linux-64", + "timestamp": 1571758667493, + "version": "1.3.10" + }, + "sqlalchemy-1.3.10-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "cb51c6f3d092604fdb5870b719cd0589", + "name": "sqlalchemy", + "sha256": "43f048f1953520972ccf4127f5b44ae82f32dd23011ee55973a2a796cf7811fb", + "size": 1855215, + "subdir": "linux-64", + "timestamp": 1573661794351, + "version": "1.3.10" + }, + "sqlalchemy-1.3.11-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f112f35020fe7a7371e47718c2270b8d", + "name": "sqlalchemy", + "sha256": "81193ddfe4e7e90ec51ae93246d4497c1cdbcfbfbeb90d5d9d2f0c6a7be883b5", + "size": 1834166, + "subdir": "linux-64", + "timestamp": 1573942441512, + "version": "1.3.11" + }, + "sqlalchemy-1.3.11-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "03f568827cdcdfae61a936e0d2643f84", + "name": "sqlalchemy", + "sha256": "0df784b8f415af3fe3f196a2b8b69a07f2c2751c538b0af4f09d0b9d2d91d35c", + "size": 1860033, + "subdir": "linux-64", + "timestamp": 1573942442907, + "version": "1.3.11" + }, + "sqlalchemy-1.3.11-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "88a9a3d78597684685124014ea1af04c", + "name": "sqlalchemy", + "sha256": "ea0f86873e3763622f10ed21dde00fec2eb5d857f9db28b1f463b1ecc28c3836", + "size": 1865753, + "subdir": "linux-64", + "timestamp": 1573942429299, + "version": "1.3.11" + }, + "sqlalchemy-1.3.11-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "9116d6ebfaadea3886f878b86c4193cb", + "name": "sqlalchemy", + "sha256": "e1d56cd5a85579374a92a60250d6efdba35f48755866800c9c5a60ac85723fb2", + "size": 1883621, + "subdir": "linux-64", + "timestamp": 1573942478613, + "version": "1.3.11" + }, + "sqlalchemy-1.3.12-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "a293181c75cd64f35c3a5f654f22c263", + "name": "sqlalchemy", + "sha256": "dd316a56742dd371b85bdd7ced6c953474a10fb991330636408e61fd911f7b2e", + "size": 1838507, + "subdir": "linux-64", + "timestamp": 1578414465311, + "version": "1.3.12" + }, + "sqlalchemy-1.3.12-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3c995f3adb54a83b245ec891ebce522f", + "name": "sqlalchemy", + "sha256": "da7cb8a1f46179218cfa295764cda2d2964ca32c3dc1074a3c1d87131b407a3d", + "size": 1871249, + "subdir": "linux-64", + "timestamp": 1578414532804, + "version": "1.3.12" + }, + "sqlalchemy-1.3.12-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c9630eeca6e7a2c5fbbe377db402f2da", + "name": "sqlalchemy", + "sha256": "97f103f1a25a8660e28b7e8b1eca68d3c2deacd1d77501f2aeef7a39d2677bed", + "size": 1869034, + "subdir": "linux-64", + "timestamp": 1578414518417, + "version": "1.3.12" + }, + "sqlalchemy-1.3.12-py37heee7806_0.tar.bz2": { + "build": "py37heee7806_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6838b6510ac96efd4e209123e2c344c3", + "name": "sqlalchemy", + "sha256": "81c0694a0e4fec33952bfe15e5e5fc52ee57adf0e31316d7743bae83e6dad9b1", + "size": 1872559, + "subdir": "linux-64", + "timestamp": 1635955341942, + "version": "1.3.12" + }, + "sqlalchemy-1.3.12-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "fe67d6ae1cdedfdbe6760c996bf8778d", + "name": "sqlalchemy", + "sha256": "af5c0c5cbf3d85fd46906d217ef749bb4993b14171c29aff7110d06eeba7c7ad", + "size": 1887950, + "subdir": "linux-64", + "timestamp": 1578414518374, + "version": "1.3.12" + }, + "sqlalchemy-1.3.12-py38heee7806_0.tar.bz2": { + "build": "py38heee7806_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "a96edc39273f3139f5c846a3f6629337", + "name": "sqlalchemy", + "sha256": "725c28d79b4ff4a75b1b7aaa38912991392fafe015113a943c5e5a21698e8e45", + "size": 1879537, + "subdir": "linux-64", + "timestamp": 1635955338708, + "version": "1.3.12" + }, + "sqlalchemy-1.3.12-py39heee7806_0.tar.bz2": { + "build": "py39heee7806_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "f4a4a470a0da14bc5e5b1e7a9d03f587", + "name": "sqlalchemy", + "sha256": "63408924724179cbf59c3916beb9f3e522c063313165405af30d2f6bf7a57b3c", + "size": 1876798, + "subdir": "linux-64", + "timestamp": 1635943365566, + "version": "1.3.12" + }, + "sqlalchemy-1.3.13-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d78edb78f42535de1fc9ad134e83e305", + "name": "sqlalchemy", + "sha256": "126a68bb59a6058982e4c9bd8959b7f4768575335ae38ca42c9c96df26c32eb2", + "size": 1878371, + "subdir": "linux-64", + "timestamp": 1580151909354, + "version": "1.3.13" + }, + "sqlalchemy-1.3.13-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6631a4798373a5040e5910d9bccabd9d", + "name": "sqlalchemy", + "sha256": "4599a307ed4871fc750e46aedb3526e400e6890939aae124407cc237c57adde1", + "size": 1877282, + "subdir": "linux-64", + "timestamp": 1580151858061, + "version": "1.3.13" + }, + "sqlalchemy-1.3.13-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "f19caa277daa937e3006a69d0a1476ae", + "name": "sqlalchemy", + "sha256": "46ec79c3e0ec7df2a9ed276ced908b1884eacb191ed3cb9369a7c99a9e0b28c3", + "size": 1882204, + "subdir": "linux-64", + "timestamp": 1580151884284, + "version": "1.3.13" + }, + "sqlalchemy-1.3.15-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2cd8174dfc9a1ea2af8f05f70f3a7afb", + "name": "sqlalchemy", + "sha256": "f6c98ebd28b15c990ad2da28b28257a3b0bfbca53e768cedf37ba852f1691f48", + "size": 1888540, + "subdir": "linux-64", + "timestamp": 1584458815195, + "version": "1.3.15" + }, + "sqlalchemy-1.3.15-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ecb5ee05501dcf4199736351dcc29275", + "name": "sqlalchemy", + "sha256": "9ae9033a44d41fec1a89189539e931266e5040d8e33741b99b575b13700dbeb7", + "size": 1889077, + "subdir": "linux-64", + "timestamp": 1584458812088, + "version": "1.3.15" + }, + "sqlalchemy-1.3.15-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "4fd0fb176d92c3d07e787a06549f19f3", + "name": "sqlalchemy", + "sha256": "b900c5e772f6b37238538b19362d4860e47fc164eea3448356b01920352c899b", + "size": 1903576, + "subdir": "linux-64", + "timestamp": 1584458812467, + "version": "1.3.15" + }, + "sqlalchemy-1.3.16-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4c9b9a79a320f097db15cd77e69fb716", + "name": "sqlalchemy", + "sha256": "34fa01c28abc7d434c323be3b5e1ebde04777cd27f59e4a03c27ce4b766df2b0", + "size": 1900654, + "subdir": "linux-64", + "timestamp": 1587134357183, + "version": "1.3.16" + }, + "sqlalchemy-1.3.16-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2f1be817266611049e66f53a0c58e102", + "name": "sqlalchemy", + "sha256": "0b529f71f17540be428f7a9d102a156437e6f25776d4c5ea765dcbcf66fda343", + "size": 1902838, + "subdir": "linux-64", + "timestamp": 1587134358854, + "version": "1.3.16" + }, + "sqlalchemy-1.3.16-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "20e3ba4093bdced1d27141286f696dc8", + "name": "sqlalchemy", + "sha256": "e192b2597c6f5ec0429c5bf454a61d5c47718c9afd130489750a20c5686835f2", + "size": 1914766, + "subdir": "linux-64", + "timestamp": 1587134379051, + "version": "1.3.16" + }, + "sqlalchemy-1.3.17-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "97e8aac7b1f1cfe566a47bc5f2214027", + "name": "sqlalchemy", + "sha256": "f6a2aeb3be1292aa9efbe121cfe1c11cc918b1b8fcd536e3be46556754d3b4e3", + "size": 1911115, + "subdir": "linux-64", + "timestamp": 1590085091542, + "version": "1.3.17" + }, + "sqlalchemy-1.3.17-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "dbf899c38bc2acc6940199206e6db33d", + "name": "sqlalchemy", + "sha256": "f3d7afb26b0aed1f1d251c94ce12bee44502fb648c3442045ea7aa0aa6795844", + "size": 1910622, + "subdir": "linux-64", + "timestamp": 1590085087877, + "version": "1.3.17" + }, + "sqlalchemy-1.3.17-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "6e8d7ce4b618e97cce863377a48ce4d6", + "name": "sqlalchemy", + "sha256": "2c860abc0dd519654db405fd4a69a2b8993d2cb4d5abbc9488f6e654d8ef150c", + "size": 1920802, + "subdir": "linux-64", + "timestamp": 1590085083608, + "version": "1.3.17" + }, + "sqlalchemy-1.3.18-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9c296f41422761af7ad79da0fe1ef534", + "name": "sqlalchemy", + "sha256": "d096b1d3636138a3d1e038037ad82e791f751ab500e4f17b007c575a9df52a49", + "size": 1916025, + "subdir": "linux-64", + "timestamp": 1593446372810, + "version": "1.3.18" + }, + "sqlalchemy-1.3.18-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "174ee7fee9e89bf5d5b83d90338ba94e", + "name": "sqlalchemy", + "sha256": "99f0faa607bac5ee00612eb23304df3d5f4fbfaab3885e831f67d366cec5f3cc", + "size": 1916853, + "subdir": "linux-64", + "timestamp": 1593446339578, + "version": "1.3.18" + }, + "sqlalchemy-1.3.18-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "1a6d1b1f45ba37fcf1272d78e533619b", + "name": "sqlalchemy", + "sha256": "becada7a59be08ab946d3723ce67c04dbae13f67e8cb187a6f74c3ed09929980", + "size": 1928360, + "subdir": "linux-64", + "timestamp": 1593446341544, + "version": "1.3.18" + }, + "sqlalchemy-1.3.19-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "eb772a6664bf1fe5dfa8ae9d3d3f6191", + "name": "sqlalchemy", + "sha256": "73c3c2c688b6147720db90c4d0fa8fcdffce1a7e417ac124d336f37967038f5c", + "size": 1923507, + "subdir": "linux-64", + "timestamp": 1598374812373, + "version": "1.3.19" + }, + "sqlalchemy-1.3.19-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "75cd1d95ac8b15067a9e59993a877a99", + "name": "sqlalchemy", + "sha256": "ea857e8c091d297aece959495b2c03a0cdafed313fc320c21c477adc87d6c715", + "size": 1916979, + "subdir": "linux-64", + "timestamp": 1597768544499, + "version": "1.3.19" + }, + "sqlalchemy-1.3.19-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "22164c52109862924f02078a4b892e50", + "name": "sqlalchemy", + "sha256": "a9002175f4585bed9c0ecc059164e43d66b049d4ce9697878a12d0555acbe88c", + "size": 1923851, + "subdir": "linux-64", + "timestamp": 1598374774293, + "version": "1.3.19" + }, + "sqlalchemy-1.3.19-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "78dfaed8bedb06e97e76e56ad2a76858", + "name": "sqlalchemy", + "sha256": "0cc8015978e1d4e565a80ffd34307b27f50e2d1c77f1f5c9d3ea3d98b3b1b080", + "size": 1931125, + "subdir": "linux-64", + "timestamp": 1598374772974, + "version": "1.3.19" + }, + "sqlalchemy-1.3.20-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ae03104b7b02d490d0677fe0d5d0068b", + "name": "sqlalchemy", + "sha256": "a476f8bc3d04ee75a5cc20ab9ce569b9f81a8c33d50e9ca3f6b952f04e4a27c8", + "size": 1920409, + "subdir": "linux-64", + "timestamp": 1603398054413, + "version": "1.3.20" + }, + "sqlalchemy-1.3.20-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "736d41be03714fc6f8d1d8d6648c56db", + "name": "sqlalchemy", + "sha256": "c09cf29e12fedf0693c309add9f4072bc196211855642bdbc13527576aa08d5d", + "size": 1919775, + "subdir": "linux-64", + "timestamp": 1603810460502, + "version": "1.3.20" + }, + "sqlalchemy-1.3.20-py37he8ac12f_0.tar.bz2": { + "build": "py37he8ac12f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d165da20f7f5dd8002b87a4805006142", + "name": "sqlalchemy", + "sha256": "63dc43eb6d18a5c42cb8272075750120eaafd23e41d17a2c3c742a80580571c5", + "size": 1929483, + "subdir": "linux-64", + "timestamp": 1607563742264, + "version": "1.3.20" + }, + "sqlalchemy-1.3.20-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "4cba2332645043cd8ea2aa4f6aa4e23f", + "name": "sqlalchemy", + "sha256": "13104c5f8f2dd3673a7ce3dde1c27ac7532f321478186f10e3e28b2b0c9a9d69", + "size": 1932303, + "subdir": "linux-64", + "timestamp": 1603398030368, + "version": "1.3.20" + }, + "sqlalchemy-1.3.20-py39he8ac12f_0.tar.bz2": { + "build": "py39he8ac12f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "222a9db3b422d401f9613a204cf5d070", + "name": "sqlalchemy", + "sha256": "94eeadaf2121ec7317d3d19b9f6c5c119b897dbc6d028c4ffbed05f7d7e07975", + "size": 1937883, + "subdir": "linux-64", + "timestamp": 1607563783023, + "version": "1.3.20" + }, + "sqlalchemy-1.3.21-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7710a92010434203e58bf7d41b3261cd", + "name": "sqlalchemy", + "sha256": "4a626e9804a5ba5e0cbd593f8afc0a6664658910fd874590e3b3a92b7e76a418", + "size": 1922007, + "subdir": "linux-64", + "timestamp": 1608243777818, + "version": "1.3.21" + }, + "sqlalchemy-1.3.21-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "251dfdfedd9404b6856b332762c05314", + "name": "sqlalchemy", + "sha256": "1796eedd9f6e98846f0f0cd41180bf488a286bae1862015b7e23eec04ad93932", + "size": 1927898, + "subdir": "linux-64", + "timestamp": 1608243803010, + "version": "1.3.21" + }, + "sqlalchemy-1.3.21-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "7285c53739c579ccbcdbdd8a185a7326", + "name": "sqlalchemy", + "sha256": "f2d17a74c0eec91ecb4c9ddbfee2a68567a692f2eaf8dd3a919bd16de15bebf8", + "size": 1936653, + "subdir": "linux-64", + "timestamp": 1608243754176, + "version": "1.3.21" + }, + "sqlalchemy-1.3.21-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "331fbc71eedce0a4b2b68d16a3b7407c", + "name": "sqlalchemy", + "sha256": "7df08462843543e7486a69fbdae6a9b73bce149a58784083b336b6b83a64da53", + "size": 1933935, + "subdir": "linux-64", + "timestamp": 1608243785816, + "version": "1.3.21" + }, + "sqlalchemy-1.3.23-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "73ed53f38f0c1741e4bd26384e59ac98", + "name": "sqlalchemy", + "sha256": "ecc86e0682ebd93fb2165b2f1384e9f5e209bcd0eb2e68de2f1152f0b265fe69", + "size": 1932626, + "subdir": "linux-64", + "timestamp": 1612467270759, + "version": "1.3.23" + }, + "sqlalchemy-1.3.23-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "fe499be105490855e57aa78bf1391a6d", + "name": "sqlalchemy", + "sha256": "16ca1e46d5a0efd6377ef1421e0d80d671b2addd3a47afe872d8af8262e7bf34", + "size": 1926563, + "subdir": "linux-64", + "timestamp": 1612467612138, + "version": "1.3.23" + }, + "sqlalchemy-1.3.23-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "5e07ee985bb339a5e5aae6e0b189bb2d", + "name": "sqlalchemy", + "sha256": "301ea89898a5739570c5a8df040ea629d3b382f58eb19ad10a31b94d462c6b29", + "size": 1940376, + "subdir": "linux-64", + "timestamp": 1612467605260, + "version": "1.3.23" + }, + "sqlalchemy-1.3.23-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "fa40100bb6697e1a233467c1ad84f097", + "name": "sqlalchemy", + "sha256": "08416500960e4ab06768351de07c6c86d913b30ee54db65f8adf3d439b036e7e", + "size": 1943739, + "subdir": "linux-64", + "timestamp": 1612467506459, + "version": "1.3.23" + }, + "sqlalchemy-1.3.3-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "1d5ddc8cc4218b6a28172dc914785e9c", + "name": "sqlalchemy", + "sha256": "bef46302ab1bb2a348be23169df0661bd192250693e3a8b4c6c96483821532ab", + "size": 1783837, + "subdir": "linux-64", + "timestamp": 1555429535800, + "version": "1.3.3" + }, + "sqlalchemy-1.3.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "5971fcc3a6f0273c5169cbf3dce1af6f", + "name": "sqlalchemy", + "sha256": "b3b0bbd5ebf1a5214398366798863d60578a69808d6ac7aa7a9beb15b8fd1445", + "size": 1811841, + "subdir": "linux-64", + "timestamp": 1555429540095, + "version": "1.3.3" + }, + "sqlalchemy-1.3.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5b3ede41370c403dbf3b144aaf57d9ad", + "name": "sqlalchemy", + "sha256": "d5a46a51a15ec7c0a00e8069bbaad11f3ade271c4dee41c63487c5040110729c", + "size": 1807551, + "subdir": "linux-64", + "timestamp": 1555429508562, + "version": "1.3.3" + }, + "sqlalchemy-1.3.4-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "12da3b98f1da784106a07c5a10f310c1", + "name": "sqlalchemy", + "sha256": "0922cf10854a9715998967658d18321d5f9f1533e53a2ff2b05432cb2e9e6b69", + "size": 1792638, + "subdir": "linux-64", + "timestamp": 1559849469674, + "version": "1.3.4" + }, + "sqlalchemy-1.3.4-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8c7c859ca0ebcaf8f934bd017c372996", + "name": "sqlalchemy", + "sha256": "930f6674e62e72f41ef8b9d6523f17822ca234d7d5e6eda811081480e74e60d9", + "size": 1809936, + "subdir": "linux-64", + "timestamp": 1559849505722, + "version": "1.3.4" + }, + "sqlalchemy-1.3.4-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "48a8b0900f86447ec9864f582de88f84", + "name": "sqlalchemy", + "sha256": "9af47ba0e2387f58757cdb39289334e0833694083d57f435a01c0a3b3a48c6a9", + "size": 1811574, + "subdir": "linux-64", + "timestamp": 1559849676478, + "version": "1.3.4" + }, + "sqlalchemy-1.3.5-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "34627bfe8699b3fcba5caf0f142a8988", + "name": "sqlalchemy", + "sha256": "5f5d53bf51b69e2d00eb1bb557c71961a156bfe7169f8717b5f9a155ebf1ee4d", + "size": 1792671, + "subdir": "linux-64", + "timestamp": 1562084763597, + "version": "1.3.5" + }, + "sqlalchemy-1.3.5-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "cc159e405d12bd265fd6a78881f5d618", + "name": "sqlalchemy", + "sha256": "66f8835e1af2718531f5766ac0c6206c20ca01b60aa921e536eeb43781a72451", + "size": 1811509, + "subdir": "linux-64", + "timestamp": 1562084762821, + "version": "1.3.5" + }, + "sqlalchemy-1.3.5-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "32129cf12de7adeda566460d07fb1675", + "name": "sqlalchemy", + "sha256": "8742e31c5055fea8aa7839862145c3686e3651759b6c8eea625009a293fed35e", + "size": 1816320, + "subdir": "linux-64", + "timestamp": 1562084746961, + "version": "1.3.5" + }, + "sqlalchemy-1.3.7-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "4cc8769353dbceebcd8463cf7d479d36", + "name": "sqlalchemy", + "sha256": "dcfb3fd0e5ad021251b68fa3ec6170284a374f89571ac46143215aaafd6f323e", + "size": 1800372, + "subdir": "linux-64", + "timestamp": 1565965430356, + "version": "1.3.7" + }, + "sqlalchemy-1.3.7-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8baacd3367be82d44aac7b4eb97d430a", + "name": "sqlalchemy", + "sha256": "18903ad7a1420c754a492fd9cf74a7329b465fb2d9598a3050f5885cc4c449bc", + "size": 1832491, + "subdir": "linux-64", + "timestamp": 1565967084813, + "version": "1.3.7" + }, + "sqlalchemy-1.3.7-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c32f82a3c63a6d309f2ef168660ed6d9", + "name": "sqlalchemy", + "sha256": "3a1bf4d649691e3ea866a726540e3b7dcf04f9f67c3970efb65e1c37fa701a3a", + "size": 1826943, + "subdir": "linux-64", + "timestamp": 1565965429121, + "version": "1.3.7" + }, + "sqlalchemy-1.3.8-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "63232f39a645e700a86b936ebd4006b4", + "name": "sqlalchemy", + "sha256": "ea25df71a391a3d6780aefd4d65380c0ee48501179318e7e8da86a80f331ff98", + "size": 1807355, + "subdir": "linux-64", + "timestamp": 1569332513717, + "version": "1.3.8" + }, + "sqlalchemy-1.3.8-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b113fdd1da956039c71b602d99529e65", + "name": "sqlalchemy", + "sha256": "de344cedc8a8b81a8d1738695fef5fe2a8a9acd3421ac0b7c969e5b0410212a6", + "size": 1830074, + "subdir": "linux-64", + "timestamp": 1569332514469, + "version": "1.3.8" + }, + "sqlalchemy-1.3.8-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "82bdd93f11daee08ff4c7cf0a7ec6b53", + "name": "sqlalchemy", + "sha256": "a59d406f6e87fb0dd8e25e4474f6e47c3d60f14df8f9ec4d9211c428f86aa214", + "size": 1833576, + "subdir": "linux-64", + "timestamp": 1569332484417, + "version": "1.3.8" + }, + "sqlalchemy-1.3.9-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "493675e4edf29b90ac210f686a59e3ed", + "name": "sqlalchemy", + "sha256": "60bf85e77d2e3683b3451c5d5eb17d810fa00b7797a261ff8ccf8065c7adfa9c", + "size": 1814128, + "subdir": "linux-64", + "timestamp": 1570464452096, + "version": "1.3.9" + }, + "sqlalchemy-1.3.9-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "858063e9e6c7049a1db506c2e7648b89", + "name": "sqlalchemy", + "sha256": "2bf01b1698897e59bb31f5e46a3c40fe4a2bb1574e4c882fba355bb2a9df7669", + "size": 1847819, + "subdir": "linux-64", + "timestamp": 1570464452294, + "version": "1.3.9" + }, + "sqlalchemy-1.3.9-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b01bf512612928811531b1392b43fe35", + "name": "sqlalchemy", + "sha256": "97e445d24895f2e778bee7e7e7c6728ec86ee30b6ae19e950d9c347659d57a52", + "size": 1848172, + "subdir": "linux-64", + "timestamp": 1570464470361, + "version": "1.3.9" + }, + "sqlalchemy-1.4.15-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "063509e727e7634e460b8fd800245703", + "name": "sqlalchemy", + "sha256": "066a89246fbff18be8d577547a20b0913d3e7ed18950ffa771bd7b28706eaf7e", + "size": 2353230, + "subdir": "linux-64", + "timestamp": 1620712484790, + "version": "1.4.15" + }, + "sqlalchemy-1.4.15-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "cddfe3e80440111e3f39fa46ad390ad9", + "name": "sqlalchemy", + "sha256": "23b0cb4858cd17080c8c82a441e1fa4447ae885127a0ccf5dae3e3f13995f637", + "size": 2355103, + "subdir": "linux-64", + "timestamp": 1620712479152, + "version": "1.4.15" + }, + "sqlalchemy-1.4.15-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "fef396ae5e8b0f1f25b9ab7aa6123be7", + "name": "sqlalchemy", + "sha256": "9668a1c078c871160fb81ea6ad9906ea5e39cc7a6465ac1d709d39e13eb48bae", + "size": 2366509, + "subdir": "linux-64", + "timestamp": 1620712486829, + "version": "1.4.15" + }, + "sqlalchemy-1.4.15-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "21ec81a62b2156df483b36691c317037", + "name": "sqlalchemy", + "sha256": "d3cf6080eb3c86996bbd3bb1de6846670c11bdeed9b24f2c793989306e512550", + "size": 2365074, + "subdir": "linux-64", + "timestamp": 1620708207030, + "version": "1.4.15" + }, + "sqlalchemy-1.4.19-py36h7f8727e_0.tar.bz2": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3bc3907eb662c45a754b378084d5d083", + "name": "sqlalchemy", + "sha256": "10bc62b6920771721cda0694e9d4722d64217d70984c0233f2ccfdfc6473043d", + "size": 3156006, + "subdir": "linux-64", + "timestamp": 1624590501151, + "version": "1.4.19" + }, + "sqlalchemy-1.4.19-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85527500a08d47a008ab364609dd115d", + "name": "sqlalchemy", + "sha256": "7c55886dd84a1650551b563dddc749f658a5ac77e0ce849b10169a2e3366725f", + "size": 3113460, + "subdir": "linux-64", + "timestamp": 1624590509299, + "version": "1.4.19" + }, + "sqlalchemy-1.4.19-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a254a6ea503d2e9799ec4393700de974", + "name": "sqlalchemy", + "sha256": "908311a8a7e8f81cecc3cba2cbc55b73ef7bf599ca25ed212958588aac0dd1f9", + "size": 3066396, + "subdir": "linux-64", + "timestamp": 1624584251247, + "version": "1.4.19" + }, + "sqlalchemy-1.4.19-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "50c585f83e6a9546c7996b97ba12e9c0", + "name": "sqlalchemy", + "sha256": "af34ea8b31d865585a3701dbd49f0655d469e71944c3503105bc85d41603177d", + "size": 2377687, + "subdir": "linux-64", + "timestamp": 1624590246090, + "version": "1.4.19" + }, + "sqlalchemy-1.4.21-py36h7f8727e_0.tar.bz2": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "493a86d61bd43bfd49bdca5298bd9740", + "name": "sqlalchemy", + "sha256": "93da3a524554fd74df073d330bb32447771dd9eb8f4db49a28bdaa1be42ebc33", + "size": 3185577, + "subdir": "linux-64", + "timestamp": 1626318175710, + "version": "1.4.21" + }, + "sqlalchemy-1.4.21-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "543be4c4ae2ff6bf2d1b0c05f9532bbe", + "name": "sqlalchemy", + "sha256": "bb9d9a47e0d006b8202c91b9becc52e70a5ed22fcb2ef4972cff74c0ec321489", + "size": 3125417, + "subdir": "linux-64", + "timestamp": 1626325264422, + "version": "1.4.21" + }, + "sqlalchemy-1.4.21-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a9b9affe2725579ebee0629b908ce1a5", + "name": "sqlalchemy", + "sha256": "d81ddcd1ef27d8499c3311fb9955f779022ab24525bca4a4aa8c20540e2ea611", + "size": 3066895, + "subdir": "linux-64", + "timestamp": 1626325262436, + "version": "1.4.21" + }, + "sqlalchemy-1.4.21-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7d269bf738df9268c4f543a820f64cab", + "name": "sqlalchemy", + "sha256": "b826d375e223527d1ef0d6e8afd8c252f0e23831e8967dedc719db9af4781c9f", + "size": 2386938, + "subdir": "linux-64", + "timestamp": 1626325269090, + "version": "1.4.21" + }, + "sqlalchemy-1.4.22-py36h7f8727e_0.tar.bz2": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c6f9e2166d72c896ee398f9e8e8e6042", + "name": "sqlalchemy", + "sha256": "27e2adac5c8fca290ba72cecc95244df9ded7452fc3d139ec49c8465090a8cc5", + "size": 2373502, + "subdir": "linux-64", + "timestamp": 1626948505698, + "version": "1.4.22" + }, + "sqlalchemy-1.4.22-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ad894b0fa29c332c3175247d7957747", + "name": "sqlalchemy", + "sha256": "c3b53921cc83849933d1d116644bc9b11add45643e056ccdb4a985aa55554543", + "size": 2373336, + "subdir": "linux-64", + "timestamp": 1626948491130, + "version": "1.4.22" + }, + "sqlalchemy-1.4.22-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d0b9e517aa0425ca2898e56295641d5", + "name": "sqlalchemy", + "sha256": "f7c1eff67cead14d913beefb206cfaadbf530c3424bf3ca2cbb29fb7930606e5", + "size": 2389984, + "subdir": "linux-64", + "timestamp": 1626941069316, + "version": "1.4.22" + }, + "sqlalchemy-1.4.22-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f4ac3e27e1b387e4178fae7c8e136b69", + "name": "sqlalchemy", + "sha256": "bccc39c2e4993b6f4c0d5c678988135a99eb0956d558a4fe0ca11bbca679ec60", + "size": 2388034, + "subdir": "linux-64", + "timestamp": 1626947945723, + "version": "1.4.22" + }, + "sqlalchemy-1.4.27-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c18f0aa6c059208639be909686b94731", + "name": "sqlalchemy", + "sha256": "902a338ed488cf0fadb512aad729a685b2222e8eb86812faa24d4dc7eaa440d6", + "size": 2496997, + "subdir": "linux-64", + "timestamp": 1640794881040, + "version": "1.4.27" + }, + "sqlalchemy-1.4.27-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc22f581782c92435fbb4c42bcb62db2", + "name": "sqlalchemy", + "sha256": "0c33cc1752f34b99f65eb35ec6b9e02b7f7733b8373cd64b3fe1da68384358f8", + "size": 2415893, + "subdir": "linux-64", + "timestamp": 1638290712911, + "version": "1.4.27" + }, + "sqlalchemy-1.4.27-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d839994279342392e1ed543315d7f19", + "name": "sqlalchemy", + "sha256": "7ac16f4069ec3b60928f97d5a25c318ed073d4e3c82acc2e34fd06adebb54129", + "size": 2431578, + "subdir": "linux-64", + "timestamp": 1638290713486, + "version": "1.4.27" + }, + "sqlalchemy-1.4.27-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "79bd4073dc85f2d136517ae0da307df2", + "name": "sqlalchemy", + "sha256": "9c01fbeb532437697f227fde64dd8ca20f6f4953b7b942f3a3219953cb3a5c3b", + "size": 2431998, + "subdir": "linux-64", + "timestamp": 1638277569574, + "version": "1.4.27" + }, + "sqlalchemy-1.4.3-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a01ac970da4b84f8975f96de5409c3f2", + "name": "sqlalchemy", + "sha256": "bc7f389d3072dc11b36519e719f5362da30cf510020c447e84bb1915ece3230c", + "size": 2318050, + "subdir": "linux-64", + "timestamp": 1617216991130, + "version": "1.4.3" + }, + "sqlalchemy-1.4.3-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "550dc6162358a37f47c7f62a783a260e", + "name": "sqlalchemy", + "sha256": "360e09314fc32b2236a76dd162e6e0c497ef56334b1a579e412053d90900979f", + "size": 2313912, + "subdir": "linux-64", + "timestamp": 1617216217178, + "version": "1.4.3" + }, + "sqlalchemy-1.4.3-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "e3dc3de1bbbe7c53c08c62bea66844b7", + "name": "sqlalchemy", + "sha256": "1b7b328e2e5ff7f4387006159eb34550f1189f1d92fc6c565b85681ff78cfcc3", + "size": 2329552, + "subdir": "linux-64", + "timestamp": 1617214486163, + "version": "1.4.3" + }, + "sqlalchemy-1.4.3-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "bb95f96e4750938fc01bd57eaff50700", + "name": "sqlalchemy", + "sha256": "b4fa9d077582b6bb07406d2441da2a28c1a03e87f97e6c7d899a9a11077be86c", + "size": 2332006, + "subdir": "linux-64", + "timestamp": 1617216990234, + "version": "1.4.3" + }, + "sqlalchemy-1.4.32-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f7fc64ac688501bbc5ab695eed7c3478", + "name": "sqlalchemy", + "sha256": "2cd9c64ecf2b038a12d39aed1828f045791c8aea63559b8475b6e330c165825d", + "size": 2524283, + "subdir": "linux-64", + "timestamp": 1647599869742, + "version": "1.4.32" + }, + "sqlalchemy-1.4.32-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2e0b764ce69cf45d04cf5b8b136e4a4", + "name": "sqlalchemy", + "sha256": "1ee096f31b2ca87c2285b7f11821646068ef96427fc2af5848bb9f2b8be0ffa0", + "size": 2454157, + "subdir": "linux-64", + "timestamp": 1647581987329, + "version": "1.4.32" + }, + "sqlalchemy-1.4.32-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1587a86bfc00a505fdd0357abc4b3f96", + "name": "sqlalchemy", + "sha256": "fb0e6ddc10d2dfc5fa10111305b6ad99b772d080a0a233dc723ca89baea5bb18", + "size": 2468151, + "subdir": "linux-64", + "timestamp": 1647599849849, + "version": "1.4.32" + }, + "sqlalchemy-1.4.32-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c08d1c8e6fae44ecb26c3bbb6e3c9775", + "name": "sqlalchemy", + "sha256": "ab198b2b9d35d9a2fcf6763e190214e124be7196f1c81de69a2a298b30c88dc9", + "size": 2470000, + "subdir": "linux-64", + "timestamp": 1647581723658, + "version": "1.4.32" + }, + "sqlalchemy-1.4.39-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "598d2fe3223ed655c4d1f65bf06e2822", + "name": "sqlalchemy", + "sha256": "cb16639e54e07334ea76c123f94963b2a5b8dc13ee3e33e65630df6f53fb6492", + "size": 2532280, + "subdir": "linux-64", + "timestamp": 1657868025937, + "version": "1.4.39" + }, + "sqlalchemy-1.4.39-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fbc99c702c0e96ad10d492597ee61ec1", + "name": "sqlalchemy", + "sha256": "e0d038e924eaf0471d0f8ad356265157f657b2dcbbdaf8135b366ea29e84ea4e", + "size": 3110022, + "subdir": "linux-64", + "timestamp": 1676827517442, + "version": "1.4.39" + }, + "sqlalchemy-1.4.39-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "686dd96b8495ea51d3894db226ef5d95", + "name": "sqlalchemy", + "sha256": "285f5248d2080fa83ee47cd348369784f3ef991ac4dbbe31cde3c642fd43d99f", + "size": 2451057, + "subdir": "linux-64", + "timestamp": 1657867906711, + "version": "1.4.39" + }, + "sqlalchemy-1.4.39-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43fa20c95a79d0069fbe11aeb4b851df", + "name": "sqlalchemy", + "sha256": "013e9a6be752b729455db4a33d64fb9f3c38dfa9b760e3f21cfd2bba1458b0e1", + "size": 2469899, + "subdir": "linux-64", + "timestamp": 1657867943530, + "version": "1.4.39" + }, + "sqlalchemy-1.4.39-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0ae303b335b1d92fa0d56ce1a711383a", + "name": "sqlalchemy", + "sha256": "a993fd2666fb3b20f9d7af4d750b12160e65e9055a458f4922742266a9257594", + "size": 2465023, + "subdir": "linux-64", + "timestamp": 1657867978380, + "version": "1.4.39" + }, + "sqlalchemy-1.4.4-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8d0fe277ba480b328110cde4a056a9c8", + "name": "sqlalchemy", + "sha256": "88f9bc4224b0043728c6eda9a207eeb7e15b0054f6d5b451b22146fe3908e2a4", + "size": 2332373, + "subdir": "linux-64", + "timestamp": 1617207807952, + "version": "1.4.4" + }, + "sqlalchemy-1.4.4-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "777cc0cc171e9dede6cf8422a07f1b75", + "name": "sqlalchemy", + "sha256": "07d590bdb0bf56958db5669c28ad720ebd0fbd6d9f260018c36259cdb1e588ce", + "size": 2330602, + "subdir": "linux-64", + "timestamp": 1617208314183, + "version": "1.4.4" + }, + "sqlalchemy-1.4.4-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "ae39ae85fe2494bdc4ffe23dba84c9e2", + "name": "sqlalchemy", + "sha256": "71137f21cad1bc2599c02626d0658d69f05e965dbaf5d2191cf53c17d506694c", + "size": 2339948, + "subdir": "linux-64", + "timestamp": 1617205798923, + "version": "1.4.4" + }, + "sqlalchemy-1.4.4-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "ab5bac6727e335b786655222c5b33008", + "name": "sqlalchemy", + "sha256": "e7eeeb82a832314dcb56761986c8d81f9758b0a3d8bb7da18d3f16f6cbd574fe", + "size": 2338838, + "subdir": "linux-64", + "timestamp": 1617208305393, + "version": "1.4.4" + }, + "sqlalchemy-1.4.5-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7338051a39a8c17069a19aadd3e10814", + "name": "sqlalchemy", + "sha256": "ff606bf5a33316054be498b723e62804fee9c6450815ada5ff18d29a410d56ee", + "size": 2325257, + "subdir": "linux-64", + "timestamp": 1617395986157, + "version": "1.4.5" + }, + "sqlalchemy-1.4.5-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "53c372b7381108b35dcfc873b4815fbf", + "name": "sqlalchemy", + "sha256": "c8820d61417a20f3197281446c1870a12a89619c0ec3ae497c6172aa84053ff6", + "size": 2324709, + "subdir": "linux-64", + "timestamp": 1617394081460, + "version": "1.4.5" + }, + "sqlalchemy-1.4.5-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "beab5df2bfe9e3f0a6c9f0a82a82be9c", + "name": "sqlalchemy", + "sha256": "ec7cf2122f475a45f9d6ca97df75bf9115107d1c1f3691a5c576ba18dabb37a0", + "size": 2341665, + "subdir": "linux-64", + "timestamp": 1617396670119, + "version": "1.4.5" + }, + "sqlalchemy-1.4.5-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "60a8378e64657f4a2444eec4110c644a", + "name": "sqlalchemy", + "sha256": "439d8cb63a37c2e968d3cca5735604343e5b3415336fd2697effabb02f771b29", + "size": 2338037, + "subdir": "linux-64", + "timestamp": 1617396672405, + "version": "1.4.5" + }, + "sqlalchemy-1.4.7-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b593bb7c16eaba7aedab2a4e27920cb2", + "name": "sqlalchemy", + "sha256": "13978c33036adac879793ac471e80bb8090589ce50b75689c0ec00c71ff384cf", + "size": 2325587, + "subdir": "linux-64", + "timestamp": 1618089593582, + "version": "1.4.7" + }, + "sqlalchemy-1.4.7-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "030b4398d06925fcccde08be4aa075e4", + "name": "sqlalchemy", + "sha256": "e9cc304dd5eb719957a83efe04a68ef39a248c74941ab0433aa8e92895dd6e3c", + "size": 2331490, + "subdir": "linux-64", + "timestamp": 1618089605068, + "version": "1.4.7" + }, + "sqlalchemy-1.4.7-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "6e7c2b4d33dbdad479a397c5efb898e1", + "name": "sqlalchemy", + "sha256": "e1f0a42354f8c5c67263550d86d8839e0e1fef49a17a9408fc4e3b2c19f2ae10", + "size": 2340401, + "subdir": "linux-64", + "timestamp": 1618089227156, + "version": "1.4.7" + }, + "sqlalchemy-1.4.7-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "306c853dec026df11d2872fad66abeb0", + "name": "sqlalchemy", + "sha256": "0c016b9be6fb6a0f038e299ed1d0efef137913e21637a4dc9dcd4ebcda1ef2d4", + "size": 2344356, + "subdir": "linux-64", + "timestamp": 1618089594284, + "version": "1.4.7" + }, + "sqlalchemy-utils-0.32.14-py27h71c0323_0.tar.bz2": { + "build": "py27h71c0323_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "enum34", + "furl >=0.4.1", + "intervals >=0.7.1", + "ipaddr", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "43bb0917de6dfe50f42074bc68ac3dfb", + "name": "sqlalchemy-utils", + "sha256": "1ffbe69d27dcfc8dbe956b68b0359c76548571f24a187f91004013b27aa1f402", + "size": 105731, + "subdir": "linux-64", + "timestamp": 1507402042636, + "version": "0.32.14" + }, + "sqlalchemy-utils-0.32.14-py35he446904_0.tar.bz2": { + "build": "py35he446904_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "75f4363e6dbdcebfd5aacc78ab1eb1e0", + "name": "sqlalchemy-utils", + "sha256": "5c1efc738a15da221b07ca6bbf83be702d95c9a907bc6caf7f2bea783803f848", + "size": 108632, + "subdir": "linux-64", + "timestamp": 1507402049476, + "version": "0.32.14" + }, + "sqlalchemy-utils-0.32.14-py36h340ff1a_0.tar.bz2": { + "build": "py36h340ff1a_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2551f9d15689cc7b716eb5c5ab97fede", + "name": "sqlalchemy-utils", + "sha256": "7d5da14234f1fd5d7c33fbcba487c65df3e1a50151532205169c9e62565a9b7b", + "size": 108391, + "subdir": "linux-64", + "timestamp": 1507402052967, + "version": "0.32.14" + }, + "sqlalchemy-utils-0.33.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "enum34", + "furl >=0.4.1", + "intervals >=0.7.1", + "ipaddr", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0a7360c1bbe38ba1a463936c28c34006", + "name": "sqlalchemy-utils", + "sha256": "e32fc52296cb99e27bb76196715e611abba90e24ca84db876c26d9ce268decba", + "size": 109976, + "subdir": "linux-64", + "timestamp": 1519365713928, + "version": "0.33.0" + }, + "sqlalchemy-utils-0.33.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2f057b43e769646cb5b8c8048448d3be", + "name": "sqlalchemy-utils", + "sha256": "a6a648ed2e4f50fd622a302525618ca877a40e260a0850975128a675ba9d75c9", + "size": 113284, + "subdir": "linux-64", + "timestamp": 1519365781188, + "version": "0.33.0" + }, + "sqlalchemy-utils-0.33.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2a02fafc4e3615af4a773478b61d7b95", + "name": "sqlalchemy-utils", + "sha256": "faa763862c899407c9a5f7e3c3f5a3d016957df0c06ec1c3d47403d2b32fc018", + "size": 112843, + "subdir": "linux-64", + "timestamp": 1519365678624, + "version": "0.33.0" + }, + "sqlalchemy-utils-0.33.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "enum34", + "furl >=0.4.1", + "intervals >=0.7.1", + "ipaddr", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "32df3153a967345cc48dc0b8306b7621", + "name": "sqlalchemy-utils", + "sha256": "6958e8174928e9dfa2ecbf699dc95f7d7e440b75665ab8dba479b9e564b9916f", + "size": 110476, + "subdir": "linux-64", + "timestamp": 1522723263279, + "version": "0.33.1" + }, + "sqlalchemy-utils-0.33.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "da35803635322fbb39ee0b6bf436dd69", + "name": "sqlalchemy-utils", + "sha256": "af2ad6a0b29607183718f7b448ed709e35cb6fb8e97aead1d80e6e1b9805c18a", + "size": 113781, + "subdir": "linux-64", + "timestamp": 1522723285547, + "version": "0.33.1" + }, + "sqlalchemy-utils-0.33.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "000d1525dcd44b99bb73ef2ae5fc69c0", + "name": "sqlalchemy-utils", + "sha256": "0aa6256b35866d78ea1caea88540f871ab9f87f29a330fb921ed8908ba25a294", + "size": 113375, + "subdir": "linux-64", + "timestamp": 1522723256709, + "version": "0.33.1" + }, + "sqlalchemy-utils-0.33.11-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "enum34", + "furl >=0.4.1", + "intervals >=0.7.1", + "ipaddr", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eebb3fbdc2c66a852fc7597651cfda52", + "name": "sqlalchemy-utils", + "sha256": "04887b3b6482e84249eba0f50fdfa342a119dff1a898bfdc48e892d45dde9566", + "size": 118940, + "subdir": "linux-64", + "timestamp": 1548004273024, + "version": "0.33.11" + }, + "sqlalchemy-utils-0.33.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d512f7fff272541640cd176d2318df44", + "name": "sqlalchemy-utils", + "sha256": "1f9c819c7f77bf2af5639e8fcfb027d133cd8235971e8e2bc010c8ae8bce2fa8", + "size": 121797, + "subdir": "linux-64", + "timestamp": 1548004300834, + "version": "0.33.11" + }, + "sqlalchemy-utils-0.33.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "70c2e486cdb70c7397665e8a0ceef9e3", + "name": "sqlalchemy-utils", + "sha256": "790526726fccec7b957c7888218fc37573680fe0d01612c725442331f4f07a7a", + "size": 121818, + "subdir": "linux-64", + "timestamp": 1548004300136, + "version": "0.33.11" + }, + "sqlalchemy-utils-0.33.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "enum34", + "furl >=0.4.1", + "intervals >=0.7.1", + "ipaddr", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f49d0041e9053942789663564d31eca6", + "name": "sqlalchemy-utils", + "sha256": "282f1cf2e7f07150650ea2aea2df77ee2942ebac25cdf5dae373c5beec90356e", + "size": 110429, + "subdir": "linux-64", + "timestamp": 1524071312868, + "version": "0.33.2" + }, + "sqlalchemy-utils-0.33.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "91630f6523fba51125d9517a8a972b87", + "name": "sqlalchemy-utils", + "sha256": "f4879147317cc64d691220493c024a71ceee855136a5372c1be6683ed0a84231", + "size": 113920, + "subdir": "linux-64", + "timestamp": 1524071331933, + "version": "0.33.2" + }, + "sqlalchemy-utils-0.33.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3a1508809e9e6705dc0582ac50b728f3", + "name": "sqlalchemy-utils", + "sha256": "f92c8631d778b83ccb0cffdb9b55aaa644bbd9ee6b748a124be62b1b6a211624", + "size": 113381, + "subdir": "linux-64", + "timestamp": 1524071334804, + "version": "0.33.2" + }, + "sqlalchemy-utils-0.33.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "enum34", + "furl >=0.4.1", + "intervals >=0.7.1", + "ipaddr", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aff2d718f0ad477fbdc1dd3c1a69f9c3", + "name": "sqlalchemy-utils", + "sha256": "e9bdb9a3d33a15c4fedcb51b24bfdf8a71d4bbf4b0f9d85edb40272134cfaf03", + "size": 114223, + "subdir": "linux-64", + "timestamp": 1526929531809, + "version": "0.33.3" + }, + "sqlalchemy-utils-0.33.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6376041926a1f3f9346afab7f5ad7c06", + "name": "sqlalchemy-utils", + "sha256": "40dfbc787a07c88d484c1e32288288614fa5ef514180294f6cff83be230d9d49", + "size": 117471, + "subdir": "linux-64", + "timestamp": 1526929554478, + "version": "0.33.3" + }, + "sqlalchemy-utils-0.33.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "70f099c9425ebb4d574c432fa4518a8a", + "name": "sqlalchemy-utils", + "sha256": "9aa47cf98bbdb5ebe0ea77fd76dfffd85f3358ac539b8223c700a1c1ae95bd48", + "size": 117129, + "subdir": "linux-64", + "timestamp": 1526929498266, + "version": "0.33.3" + }, + "sqlalchemy-utils-0.33.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d44eb6368c7d51e3dcd928618dfa7408", + "name": "sqlalchemy-utils", + "sha256": "bc200f9a3cf4d82d887fe9d702908f1c9308d3addcad6e1296d0adb18573042e", + "size": 117371, + "subdir": "linux-64", + "timestamp": 1531059678963, + "version": "0.33.3" + }, + "sqlalchemy-utils-0.33.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "enum34", + "furl >=0.4.1", + "intervals >=0.7.1", + "ipaddr", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6edf2125f0132945b9dbe84669f476be", + "name": "sqlalchemy-utils", + "sha256": "3b757f588ce71adf179d6da0fe0c5c2997fccf0f8e3127f5f46c478c3acec6eb", + "size": 115530, + "subdir": "linux-64", + "timestamp": 1539645481311, + "version": "0.33.6" + }, + "sqlalchemy-utils-0.33.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3d81e53492d879704b379f5c37019d56", + "name": "sqlalchemy-utils", + "sha256": "5fd0459da68a14222a0e776fe510a80dbcd6cd43173481c4ee362d1bad1e9626", + "size": 118447, + "subdir": "linux-64", + "timestamp": 1539645511500, + "version": "0.33.6" + }, + "sqlalchemy-utils-0.33.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "42ff78a363d71c0752b39f4e76f4e4c3", + "name": "sqlalchemy-utils", + "sha256": "35a4f18ff95df9d9e39f2f26c6cd762b0a9f25bf066e200964c3f0b6fb4db50f", + "size": 118685, + "subdir": "linux-64", + "timestamp": 1539645504309, + "version": "0.33.6" + }, + "sqlalchemy-utils-0.33.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "enum34", + "furl >=0.4.1", + "intervals >=0.7.1", + "ipaddr", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "85888a87c6f0e6375477d9b9ed0ab048", + "name": "sqlalchemy-utils", + "sha256": "aba268f7fd35104e573f6fda2ab26ce0164363653e134f47014872c49d5f2ffb", + "size": 116088, + "subdir": "linux-64", + "timestamp": 1545112551844, + "version": "0.33.9" + }, + "sqlalchemy-utils-0.33.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "908cbfd13d299e8d81696e8461757dff", + "name": "sqlalchemy-utils", + "sha256": "3a3f736bbae793194b9e750aad9f63810f4fb80d171c16af9e1347069c39743c", + "size": 118881, + "subdir": "linux-64", + "timestamp": 1545112586826, + "version": "0.33.9" + }, + "sqlalchemy-utils-0.33.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1ea5dcb880c158bf10a0bf28ee5e8f09", + "name": "sqlalchemy-utils", + "sha256": "ed113b1b1669ffa2c4a01b2af8ce540c6f6a65f776d3734c51a8587e8f6306aa", + "size": 119163, + "subdir": "linux-64", + "timestamp": 1545112609564, + "version": "0.33.9" + }, + "sqlite-3.20.1-h6d8b0f3_1.tar.bz2": { + "build": "h6d8b0f3_1", + "build_number": 1, + "depends": [ + "libedit", + "libgcc-ng >=7.2.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "58093fcadd677bc3ed98ddd4a2f7d286", + "name": "sqlite", + "sha256": "24a3c773abd915d2f13da177a29e264e59a0ae3c6fd2a31267dcc6a8ef9c0a1c", + "size": 1540584, + "subdir": "linux-64", + "timestamp": 1505666546842, + "version": "3.20.1" + }, + "sqlite-3.20.1-hb898158_2.tar.bz2": { + "build": "hb898158_2", + "build_number": 2, + "depends": [ + "libedit", + "libgcc-ng >=7.2.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "c7224911deba3d9a2da76ce534dc623f", + "name": "sqlite", + "sha256": "f05570c7382ea91ca37588a4a109326a0c850410b3b6200880a8d6d62bf15556", + "size": 1541062, + "subdir": "linux-64", + "timestamp": 1510171800608, + "version": "3.20.1" + }, + "sqlite-3.21.0-h1bed415_0.tar.bz2": { + "build": "h1bed415_0", + "build_number": 0, + "depends": [ + "libedit", + "libgcc-ng >=7.2.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "1a4603ebe95b528c8a830ee85697ae32", + "name": "sqlite", + "sha256": "aa48c4d5fa5f1d89f06620f6a14b95adcd7100903da0cd6558d2f1522eef745e", + "size": 1557960, + "subdir": "linux-64", + "timestamp": 1516736436984, + "version": "3.21.0" + }, + "sqlite-3.21.0-h1bed415_2.tar.bz2": { + "build": "h1bed415_2", + "build_number": 2, + "depends": [ + "libedit", + "libgcc-ng >=7.2.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "0303b51afab6ef51115f6f938c49ef5c", + "name": "sqlite", + "sha256": "212b5e600f554f03a45c5abc85bf63a26a02ffc7d3e6e77dfd8415ddb104d782", + "size": 1557985, + "subdir": "linux-64", + "timestamp": 1517236999506, + "version": "3.21.0" + }, + "sqlite-3.22.0-h1bed415_0.tar.bz2": { + "build": "h1bed415_0", + "build_number": 0, + "depends": [ + "libedit", + "libgcc-ng >=7.2.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "5198a7d43090c167e83770e9a9b93b1e", + "name": "sqlite", + "sha256": "f36ced5551952d769a54e84c977cfd88edcc936b33d3d2c9b134e9a9f193e681", + "size": 1582745, + "subdir": "linux-64", + "timestamp": 1517325921602, + "version": "3.22.0" + }, + "sqlite-3.23.1-he433501_0.tar.bz2": { + "build": "he433501_0", + "build_number": 0, + "depends": [ + "libedit", + "libgcc-ng >=7.2.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "b2f3ce483ad271d461113b48b7bc951e", + "name": "sqlite", + "sha256": "5c7c81d92569655ad342b350f7f48bdb8c424cabff756cd40035ce0dfd34dfec", + "size": 1594493, + "subdir": "linux-64", + "timestamp": 1524193435107, + "version": "3.23.1" + }, + "sqlite-3.24.0-h84994c4_0.tar.bz2": { + "build": "h84994c4_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20170329,<3.2.0a0", + "libgcc-ng >=7.2.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "8d9545311f3a1fa6cdbab2e6c1351065", + "name": "sqlite", + "sha256": "2cb9355bcec2cca9fa6c24c5e387cc3303cdca3917c09a3447024cb4c7009a54", + "size": 1859563, + "subdir": "linux-64", + "timestamp": 1529358396807, + "version": "3.24.0" + }, + "sqlite-3.25.2-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20170329,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "69ed329923ba8b15ef24c8b184173004", + "name": "sqlite", + "sha256": "5771f97d92dd3fc042454315771f6d0c5c8ff420dd0b9d032811c8f9ae778e1b", + "size": 1947257, + "subdir": "linux-64", + "timestamp": 1538082485705, + "version": "3.25.2" + }, + "sqlite-3.25.3-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20170329,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "1433c1efd0d39930c6edc91e1cd205f4", + "name": "sqlite", + "sha256": "fa86709723485ce66c017aec683383f9587a64b55b475167a6e2d96353115ef3", + "size": 1945281, + "subdir": "linux-64", + "timestamp": 1542091115818, + "version": "3.25.3" + }, + "sqlite-3.26.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20170329,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "4811f4389968b575332d40068f29dbe5", + "name": "sqlite", + "sha256": "81eaae7aa310196d4e216726172aabb07057e6a20fe21200675e526b50ae2ba9", + "size": 1952980, + "subdir": "linux-64", + "timestamp": 1545057743770, + "version": "3.26.0" + }, + "sqlite-3.27.2-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "34b4970a37801271f8c010ca1490fd04", + "name": "sqlite", + "sha256": "6924ec3a7ad96524cffd9eb4e3a2b57e226a3ea69da15c1734a6f50609a45198", + "size": 1964444, + "subdir": "linux-64", + "timestamp": 1552418002674, + "version": "3.27.2" + }, + "sqlite-3.28.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "f0129804aae5d555f6dc90af25413b41", + "name": "sqlite", + "sha256": "c9b71a0957ac319e9995cb9b711b0118e4099b0b28f26c3e75300f37ff6f6a7f", + "size": 2004895, + "subdir": "linux-64", + "timestamp": 1555958148895, + "version": "3.28.0" + }, + "sqlite-3.29.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "1a6911c8bcde93d5c5365ff299b942f3", + "name": "sqlite", + "sha256": "712185469ab8d452b5d6dd3448728bbf1f336518ac69cbd1c406f9cf08ddb007", + "size": 1993104, + "subdir": "linux-64", + "timestamp": 1563287521477, + "version": "3.29.0" + }, + "sqlite-3.30.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "c6ed845176a88dc2bbe6e77835cb158e", + "name": "sqlite", + "sha256": "89afb148e38a6e6d8edca08fce35684aa83f541815bbdb0223f1e83b82cd6937", + "size": 2025080, + "subdir": "linux-64", + "timestamp": 1570211057213, + "version": "3.30.0" + }, + "sqlite-3.30.1-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "6d5ebd5a27574db7738c6f391033b970", + "name": "sqlite", + "sha256": "359839ce62aa523f4b1e5d761f1681ebee6fe595a035a8920fc841d60d847724", + "size": 2006607, + "subdir": "linux-64", + "timestamp": 1572009937171, + "version": "3.30.1" + }, + "sqlite-3.31.1-h62c20be_1.tar.bz2": { + "build": "h62c20be_1", + "build_number": 1, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "a6fffb2c69521883d55154df6176543b", + "name": "sqlite", + "sha256": "fd9f7dd2099750ee1093e4cf82bb21ace8b6e74bb831b9f8ec1760e79cc263d3", + "size": 2101076, + "subdir": "linux-64", + "timestamp": 1587498181207, + "version": "3.31.1" + }, + "sqlite-3.31.1-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "3eeff1732f5a15b2bb40c3d4ca5e4557", + "name": "sqlite", + "sha256": "9de579952ac9dcd97d4a542009bc51b93a7070a829272e4dde5bef5040a15cff", + "size": 2076136, + "subdir": "linux-64", + "timestamp": 1580838834162, + "version": "3.31.1" + }, + "sqlite-3.32.2-h62c20be_0.tar.bz2": { + "build": "h62c20be_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "a011922322c43b57e3a7dedfa492abc6", + "name": "sqlite", + "sha256": "6afeae47a0fa0315f421ee17a8dc8dad05ee2af08718c1e8d1944743dea2b3d7", + "size": 2122021, + "subdir": "linux-64", + "timestamp": 1592511505471, + "version": "3.32.2" + }, + "sqlite-3.32.3-h62c20be_0.tar.bz2": { + "build": "h62c20be_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20191231,<3.2.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "6a6a0ab0b63b707498d6cc68c3c53baf", + "name": "sqlite", + "sha256": "645cf20964a89e23b829605c2e5503bb2d71635ce09066e7cf19a34ecb05f1c2", + "size": 2139491, + "subdir": "linux-64", + "timestamp": 1592847543592, + "version": "3.32.3" + }, + "sqlite-3.33.0-h62c20be_0.tar.bz2": { + "build": "h62c20be_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20191231,<3.2.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "803edb3abbf1241e491cf6c844c5a009", + "name": "sqlite", + "sha256": "1fa19a020c0cb5305559402bb97d21fb09525e4598cb7eb643a56b802163f086", + "size": 2124319, + "subdir": "linux-64", + "timestamp": 1597935754268, + "version": "3.33.0" + }, + "sqlite-3.35.0-hdfb4753_0.tar.bz2": { + "build": "hdfb4753_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "143b04a8e6e9e8da6500913bd95fec97", + "name": "sqlite", + "sha256": "03a8a5f1be255db749cbd2ebbd81561fda680912430c3393aff64371b2b28443", + "size": 1514580, + "subdir": "linux-64", + "timestamp": 1615820103755, + "version": "3.35.0" + }, + "sqlite-3.35.1-hdfb4753_0.tar.bz2": { + "build": "hdfb4753_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "0bb8a1c02fcbb0f1a15636dce45bf931", + "name": "sqlite", + "sha256": "315bda919e601ba7bfc37971dd52bc5c5d119149a956c03facda76deaf9c6ebb", + "size": 1499513, + "subdir": "linux-64", + "timestamp": 1615836970400, + "version": "3.35.1" + }, + "sqlite-3.35.2-hdfb4753_0.tar.bz2": { + "build": "hdfb4753_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "a7b7afb74608a90b2151687586d263b5", + "name": "sqlite", + "sha256": "70e5b140729d26fbcdfa5d3a1bb18d58da8c0e2904a56934d03bdd72b38a28da", + "size": 1500811, + "subdir": "linux-64", + "timestamp": 1616094242182, + "version": "3.35.2" + }, + "sqlite-3.35.3-hdfb4753_0.tar.bz2": { + "build": "hdfb4753_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "bc7384615222977707372009f240a3cf", + "name": "sqlite", + "sha256": "58bec4057461266309e8c64edcbdb0a42f1de2e6b6283dfc640a12a5dde154c7", + "size": 1515010, + "subdir": "linux-64", + "timestamp": 1617134175367, + "version": "3.35.3" + }, + "sqlite-3.35.4-hdfb4753_0.tar.bz2": { + "build": "hdfb4753_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "144c35fc0863007a789085dcd3cd15a9", + "name": "sqlite", + "sha256": "68087ac2d1a4242325852821816fc0d6adcbc7440fac642df2315ee1ff9b80d5", + "size": 1509947, + "subdir": "linux-64", + "timestamp": 1617396741975, + "version": "3.35.4" + }, + "sqlite-3.36.0-hc218d9a_0.tar.bz2": { + "build": "hc218d9a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "7147fbe9c210388a7603df8168184535", + "name": "sqlite", + "sha256": "5b8e64bcf8486bbd3a05798c572e897023d882fa3dde3fd50cb44009eeddb5f4", + "size": 1510907, + "subdir": "linux-64", + "timestamp": 1624470591767, + "version": "3.36.0" + }, + "sqlite-3.37.0-hc218d9a_0.tar.bz2": { + "build": "hc218d9a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Unlicense", + "md5": "42765d76eee8ec1d900297f4b935fd0c", + "name": "sqlite", + "sha256": "21ab6413009dbf9991cf7b7a134603c456dc310642df886b4cf339a5b17f2e7e", + "size": 1535008, + "subdir": "linux-64", + "timestamp": 1640179788083, + "version": "3.37.0" + }, + "sqlite-3.37.2-hc218d9a_0.tar.bz2": { + "build": "hc218d9a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Unlicense", + "md5": "623a0fcb6e1ff082e0886ef5a73ceb95", + "name": "sqlite", + "sha256": "7386b44873638e144c8faf01cef3d9b1771361153b84d8d7adcc54c6371f8231", + "size": 1528553, + "subdir": "linux-64", + "timestamp": 1643970309844, + "version": "3.37.2" + }, + "sqlite-3.38.0-hc218d9a_0.tar.bz2": { + "build": "hc218d9a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Unlicense", + "md5": "7086edbfafa6c8a77a411fde07a94be4", + "name": "sqlite", + "sha256": "aed10c7fae52f779fdfec9af6919c334945c96bc98327d373d3d281da27b858f", + "size": 1540667, + "subdir": "linux-64", + "timestamp": 1646926931516, + "version": "3.38.0" + }, + "sqlite-3.38.2-hc218d9a_0.tar.bz2": { + "build": "hc218d9a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Unlicense", + "md5": "68387ed148d6329ae609dfe0e8a894df", + "name": "sqlite", + "sha256": "69ea8a48c99204c059d110eaf13f27ae9e8b8ef2fa7c153934e2d2f2c0abb684", + "size": 1546837, + "subdir": "linux-64", + "timestamp": 1648718095207, + "version": "3.38.2" + }, + "sqlite-3.38.3-hc218d9a_0.tar.bz2": { + "build": "hc218d9a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "blessing", + "license_family": "Other", + "md5": "fe053719a8824775887e8d0e1c37a1d5", + "name": "sqlite", + "sha256": "985077a20a45cb8b1e0e83efce39813bff3a88b6467585bc9f067b1e697df0bc", + "size": 1556833, + "subdir": "linux-64", + "timestamp": 1651697672351, + "version": "3.38.3" + }, + "sqlite-3.38.5-hc218d9a_0.tar.bz2": { + "build": "hc218d9a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "blessing", + "license_family": "Other", + "md5": "fa334030245135b37027a882f3c468bf", + "name": "sqlite", + "sha256": "87965b7b46d93866d31696a1045216d64f077a06b2900c356aba87e8559c6188", + "size": 1561908, + "subdir": "linux-64", + "timestamp": 1655328608308, + "version": "3.38.5" + }, + "sqlite-3.39.0-h5082296_0.tar.bz2": { + "build": "h5082296_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "blessing", + "license_family": "Other", + "md5": "cf60048c59c30de91038f0e689fef225", + "name": "sqlite", + "sha256": "bcc5f1fc9f4428b907f90d1e683963543e9665a8b57310ad6953874546f1c683", + "size": 1609786, + "subdir": "linux-64", + "timestamp": 1659462267794, + "version": "3.39.0" + }, + "sqlite-3.39.2-h5082296_0.tar.bz2": { + "build": "h5082296_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "blessing", + "license_family": "Other", + "md5": "11e2b91d54d6f15b0c08251eb8283e5f", + "name": "sqlite", + "sha256": "e64530a919b42de0b2808a0b6491d2dc1862a28ecbd7cad122e2b83fd536b5c3", + "size": 1615048, + "subdir": "linux-64", + "timestamp": 1659712464546, + "version": "3.39.2" + }, + "sqlite-3.39.3-h5082296_0.tar.bz2": { + "build": "h5082296_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "blessing", + "license_family": "Other", + "md5": "34fa0120fc3c9719213dbe2eb443e63d", + "name": "sqlite", + "sha256": "28716472cd71a6715050273479bbdbda1daf9ef06b3e47959a439f8e1bdcfacb", + "size": 1606034, + "subdir": "linux-64", + "timestamp": 1664326359748, + "version": "3.39.3" + }, + "sqlite-3.40.0-h5082296_0.tar.bz2": { + "build": "h5082296_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "blessing", + "license_family": "Other", + "md5": "12abdad9b7ca20d49af7211fed4d6f59", + "name": "sqlite", + "sha256": "2525eca3acf007cecda1758200c31a1ee33c47ece950229b9369cdb697801558", + "size": 1626448, + "subdir": "linux-64", + "timestamp": 1669138335049, + "version": "3.40.0" + }, + "sqlite-3.40.1-h5082296_0.tar.bz2": { + "build": "h5082296_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "blessing", + "license_family": "Other", + "md5": "d1e20816f58d88e65615183652633403", + "name": "sqlite", + "sha256": "c0bea055f55bf234994c403d111bfd3acaff072d03d15e53878cbc109a6cac50", + "size": 1626109, + "subdir": "linux-64", + "timestamp": 1673293981140, + "version": "3.40.1" + }, + "sqlite-3.41.1-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "ncurses >=6.4,<7.0a0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zlib >=1.2.13,<2.0a0" + ], + "license": "blessing", + "license_family": "Other", + "md5": "3517a8025e55aa6dfb4c8fbea03b8cbc", + "name": "sqlite", + "sha256": "b0de8f0bfd6a6638266fbfbaaa8a8be056a946115c3faf0b49359770a6d14dc4", + "size": 1631720, + "subdir": "linux-64", + "timestamp": 1678878009316, + "version": "3.41.1" + }, + "sqlparse-0.2.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d784d925b9015b4c51e3d9b44f50999c", + "name": "sqlparse", + "sha256": "edc98b81bcc48ddba8ec0edbbd8cba28acf78e84222a82ec78b457d7a1f9b0fd", + "size": 57404, + "subdir": "linux-64", + "timestamp": 1519760497553, + "version": "0.2.4" + }, + "sqlparse-0.2.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a7a8b6ade12be648c7ecb16e227ced8a", + "name": "sqlparse", + "sha256": "a4309767bf4872011a0454914d46af0b8c86f922bab3107a724a1aee869e8bca", + "size": 58617, + "subdir": "linux-64", + "timestamp": 1519760511012, + "version": "0.2.4" + }, + "sqlparse-0.2.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e579e460cda48617dbd84de8894f0ff0", + "name": "sqlparse", + "sha256": "0b9f0d9b3c5c0b72a02245da2c1b1dc889ffe4af9894c404d58f54674a42e01d", + "size": 56825, + "subdir": "linux-64", + "timestamp": 1519760481116, + "version": "0.2.4" + }, + "sqlparse-0.2.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b763c2e08e36a2387057cb702d2d4826", + "name": "sqlparse", + "sha256": "d0b18608671c14e35a9971ae67cdfca3264a2fc088c30567e7ac8ff299d0f7d1", + "size": 56783, + "subdir": "linux-64", + "timestamp": 1531059717254, + "version": "0.2.4" + }, + "sqlparse-0.4.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "352721050385b310d7e5471c6ca47bd2", + "name": "sqlparse", + "sha256": "d67859e759bcdf48c708b28ac0aa220407a52c13b92b1f0aaadc31793752f2e2", + "size": 70718, + "subdir": "linux-64", + "timestamp": 1668793594692, + "version": "0.4.3" + }, + "sqlparse-0.4.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ed48f73b56b648b73235e321481cd3ff", + "name": "sqlparse", + "sha256": "c5d30675e931d57de09001c581d6e080a8abdebef8fe8b71e419c2c2048543f4", + "size": 91982, + "subdir": "linux-64", + "timestamp": 1676828857752, + "version": "0.4.3" + }, + "sqlparse-0.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "33e5c45c6e74c63b3d920617795adc51", + "name": "sqlparse", + "sha256": "004409362c22e5c94922224f4eb3a599c80ed38a70ec24f4d3f601a4f97c1c47", + "size": 65383, + "subdir": "linux-64", + "timestamp": 1668793517393, + "version": "0.4.3" + }, + "sqlparse-0.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3a3d37165c9abe0e4ccec4403bc947c0", + "name": "sqlparse", + "sha256": "2a9267f02e67b8e812eb970acab490771223d19eb8dd21f674a49267d13e2c3d", + "size": 65544, + "subdir": "linux-64", + "timestamp": 1668793569016, + "version": "0.4.3" + }, + "sqlparse-0.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85b35283a40683400a675243c7e8e703", + "name": "sqlparse", + "sha256": "f26d3b51de76d1a9da4c2506eec403919cf4286e68f0837a128d96d14c7f78e7", + "size": 65585, + "subdir": "linux-64", + "timestamp": 1668793543264, + "version": "0.4.3" + }, + "srsly-1.0.2-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f5aa71f53614af27cd9bba2360493df7", + "name": "srsly", + "sha256": "b7f6da78d74c3b40507fcb4663f05544962996927039ee3cbb399814cf914e3a", + "size": 220850, + "subdir": "linux-64", + "timestamp": 1590155061839, + "version": "1.0.2" + }, + "srsly-1.0.2-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ad9e13dda650b123438eeb0ee8bd25e", + "name": "srsly", + "sha256": "77d384832dfc0800ca8fbb94df1f2d4fbaa8b5dc10bf52f08e78d28d3608fb75", + "size": 220134, + "subdir": "linux-64", + "timestamp": 1590155091742, + "version": "1.0.2" + }, + "srsly-1.0.2-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c650374a247f84acc7e6ee6832211d35", + "name": "srsly", + "sha256": "59f8058d2b0e21491dd9d7da8b24424233427a3ffeb3fd7d0222ccbf90095f61", + "size": 225422, + "subdir": "linux-64", + "timestamp": 1590155061725, + "version": "1.0.2" + }, + "srsly-1.0.5-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "284ac7359359227541f05d37d9186c6f", + "name": "srsly", + "sha256": "c9d103dcf909b2366fdccc291aad407233446ff1bc6eaad24b0eeea66df99f09", + "size": 215393, + "subdir": "linux-64", + "timestamp": 1607548601131, + "version": "1.0.5" + }, + "srsly-1.0.5-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7239e3bc7a386876b2f1f2eb1830feb9", + "name": "srsly", + "sha256": "f301e667e4705215828a76d9d2a99e83c13fbcb36ed60a237bf20f42c1af9dfd", + "size": 214767, + "subdir": "linux-64", + "timestamp": 1607548566596, + "version": "1.0.5" + }, + "srsly-1.0.5-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "114947cf5842fc88abda10df8f1c0cb0", + "name": "srsly", + "sha256": "580005bb186647b99376db2c2972a6fbcf3479b77fd52624f6f55ebd48f858f3", + "size": 218232, + "subdir": "linux-64", + "timestamp": 1607548595823, + "version": "1.0.5" + }, + "srsly-1.0.5-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "623f4fbaea9f9dc32d696eb8e9a48bd8", + "name": "srsly", + "sha256": "3aa8c2126763162aaa33e0272ac4b8a32d56df8b8972969653cd02b318565cd3", + "size": 216475, + "subdir": "linux-64", + "timestamp": 1607548583937, + "version": "1.0.5" + }, + "srsly-2.2.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d35b01abb8d15c3a29ad7aa9bb281a9", + "name": "srsly", + "sha256": "c38f19a773d41cc05846f6e766c144c116774ecb9f618612b3f15d1b3466f9cb", + "size": 555114, + "subdir": "linux-64", + "timestamp": 1594254063821, + "version": "2.2.0" + }, + "srsly-2.2.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d946f1f86a86f47cc4d9f97fde6f076", + "name": "srsly", + "sha256": "1150b14a8c1984010f07231f396dd8d63aa9956bfce36f6c7176f1a1cdc00d3c", + "size": 541311, + "subdir": "linux-64", + "timestamp": 1594254065550, + "version": "2.2.0" + }, + "srsly-2.2.0-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "29895b43f2895acdf216bf1c6aead0be", + "name": "srsly", + "sha256": "f42494a9193ebd7839ac1d4ba3a072b09977f210b6f3e8936fd65e27c1b9dc66", + "size": 550487, + "subdir": "linux-64", + "timestamp": 1594254040598, + "version": "2.2.0" + }, + "srsly-2.3.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "194493e476fcfa6082a39fa8a9eaeeea", + "name": "srsly", + "sha256": "699d12b1a6eed983bbbeba4e8e6c9ee70a6df5ae95d2b660365f84e2f0d4b8ab", + "size": 534601, + "subdir": "linux-64", + "timestamp": 1602000024351, + "version": "2.3.0" + }, + "srsly-2.3.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dcc1d796e2ece5d6047409ceb59c1a65", + "name": "srsly", + "sha256": "904d8854af776d5cbc328a9a20889b0a8cf91e73c30491842ff22d354ac3ecdd", + "size": 541629, + "subdir": "linux-64", + "timestamp": 1602000031051, + "version": "2.3.0" + }, + "srsly-2.3.0-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "68febdbd45deaad2260d6402a4f0fc75", + "name": "srsly", + "sha256": "35af66570aa3746f143744291c5d38f9fc1daba6a070866d8b1c1c57eae8f77d", + "size": 550536, + "subdir": "linux-64", + "timestamp": 1602000032807, + "version": "2.3.0" + }, + "srsly-2.3.2-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b28d7895bd3aa8deec382cc5a3b22861", + "name": "srsly", + "sha256": "16e9faecaef17e27dd1b70894526513770a0ecfd2ba6dd2fdfaac84a5939b46d", + "size": 543795, + "subdir": "linux-64", + "timestamp": 1606929412299, + "version": "2.3.2" + }, + "srsly-2.3.2-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "387821ce697f74dc8f52397059ad2622", + "name": "srsly", + "sha256": "4c91b4699b8525380ecedc9370638605b890c1d4a0ffe7f12ee9dd92a6b21de0", + "size": 543148, + "subdir": "linux-64", + "timestamp": 1606929402732, + "version": "2.3.2" + }, + "srsly-2.3.2-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ba90d8eac5a5dbd53c313af33c3578c", + "name": "srsly", + "sha256": "c8e6ee3e5b2079b21efa6421c57c268120380c33fb3913d34198dbdb656a799c", + "size": 549099, + "subdir": "linux-64", + "timestamp": 1606929408533, + "version": "2.3.2" + }, + "srsly-2.4.0-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "catalogue", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a9a0fd317c4d4c20d9f8790f5d5b2134", + "name": "srsly", + "sha256": "dc4d1ff3c9994d83cd85ab0807ff6da11a93950134bb6b771a5e60cd838b6eb2", + "size": 539390, + "subdir": "linux-64", + "timestamp": 1612468502424, + "version": "2.4.0" + }, + "srsly-2.4.0-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "catalogue", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b3483440cb4c24eb6f6ab826ac6a400", + "name": "srsly", + "sha256": "6fb93835c6424613d20e4101d5a2f7e8394e961b6d04a6657f33925e719c2a96", + "size": 547716, + "subdir": "linux-64", + "timestamp": 1612468950284, + "version": "2.4.0" + }, + "srsly-2.4.0-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "catalogue", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a5de35e5e4cfd9fae25a6a96e56d8249", + "name": "srsly", + "sha256": "3d88adc1104be23889be20860e26aa5c5b212596efbe20e3a53e7dc8c59166a6", + "size": 554559, + "subdir": "linux-64", + "timestamp": 1612468960033, + "version": "2.4.0" + }, + "srsly-2.4.0-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "catalogue", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a91a5d42170d0a2b12948010808de46c", + "name": "srsly", + "sha256": "01116d2edd468d00db6f5ecedd4fe3a9aa711768033984402f0cd3faae1487ca", + "size": 545886, + "subdir": "linux-64", + "timestamp": 1612468954461, + "version": "2.4.0" + }, + "srsly-2.4.1-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dca1389aada43ea138c554b0c378d139", + "name": "srsly", + "sha256": "10ea48dd3691245acc064a85b470b060dc728fc70814c9bc4a6baa61f4a40d8f", + "size": 855974, + "subdir": "linux-64", + "timestamp": 1640794915963, + "version": "2.4.1" + }, + "srsly-2.4.1-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "catalogue", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e0f5b948248cfe4bff0a1efe589361b", + "name": "srsly", + "sha256": "3fbb21f3735f60d5bca81d19a33e429c86af908905224faa13a913f609db1ec6", + "size": 548266, + "subdir": "linux-64", + "timestamp": 1618696336856, + "version": "2.4.1" + }, + "srsly-2.4.1-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "catalogue", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f677374375f3367c203afed3fac89019", + "name": "srsly", + "sha256": "7ab4cc12cf1ba75f67d44dfe045d012bf814a9340485115b2ac0803116fa9266", + "size": 538632, + "subdir": "linux-64", + "timestamp": 1618693074684, + "version": "2.4.1" + }, + "srsly-2.4.1-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "catalogue", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2a4f9473c5203227dea99280f7b78da4", + "name": "srsly", + "sha256": "629aadfce75b73213c330b284e930f3d9ffda6bcd5185355420123d1072a7c51", + "size": 542644, + "subdir": "linux-64", + "timestamp": 1618696232148, + "version": "2.4.1" + }, + "srsly-2.4.1-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "595745d8aea7496219005f1127c4f735", + "name": "srsly", + "sha256": "cb1fa1d8794049d13bfe6886eeedbbc12e2e655c878c30c7689cc93667532009", + "size": 556904, + "subdir": "linux-64", + "timestamp": 1618836827566, + "version": "2.4.1" + }, + "srsly-2.4.3-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d047ba4794f7566da701e85e4f9d6de5", + "name": "srsly", + "sha256": "0fc2856115e0a07d7c95e4b068fb349f89ff6a683c814945da165c156433d4d2", + "size": 858826, + "subdir": "linux-64", + "timestamp": 1651584861545, + "version": "2.4.3" + }, + "srsly-2.4.3-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a23f61f0ce9b92b5c18fbe2c4b98c6c9", + "name": "srsly", + "sha256": "25f8db16ca547f992eb89e174de0f4a846b4dcd91fc888c5769f08ff2b34a668", + "size": 673717, + "subdir": "linux-64", + "timestamp": 1676842911003, + "version": "2.4.3" + }, + "srsly-2.4.3-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "530f5b88d0461382993e0f4f8c18b606", + "name": "srsly", + "sha256": "33012822118063ca73d3d774c27cfddeed1d551cd00fdd713d3d2c835c23e079", + "size": 552573, + "subdir": "linux-64", + "timestamp": 1651584907652, + "version": "2.4.3" + }, + "srsly-2.4.3-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "880c6af0289e4cb6d3ef4f6ca7a77428", + "name": "srsly", + "sha256": "fb2e6a16fc3f3470018a5a280e48b911d509fc848bba3ff70489f2000e054336", + "size": 556295, + "subdir": "linux-64", + "timestamp": 1651584953935, + "version": "2.4.3" + }, + "srsly-2.4.3-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16437e66bcc705bc33b98b8004031b34", + "name": "srsly", + "sha256": "45724f5aef87795e59478a3e9749dc88f060b9cf6040fbb92bb92fed941d631f", + "size": 551827, + "subdir": "linux-64", + "timestamp": 1651584798383, + "version": "2.4.3" + }, + "srsly-2.4.6-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5a02a6760e75752103ea883220270ca0", + "name": "srsly", + "sha256": "c1f6f571448823e2e04a16729972753c128bbc9fbf29a39ef4a97ca89a9196c8", + "size": 599480, + "subdir": "linux-64", + "timestamp": 1677855639453, + "version": "2.4.6" + }, + "srsly-2.4.6-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a2eb17f46c9f39ef33d3ff209dc1dc12", + "name": "srsly", + "sha256": "e89724d51ca4efcdee1bfd43332034ec842845f664f62d9b10578e338c7c6adc", + "size": 746922, + "subdir": "linux-64", + "timestamp": 1677787954256, + "version": "2.4.6" + }, + "srsly-2.4.6-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a95428f1b522243479750bd955c747ec", + "name": "srsly", + "sha256": "663b20b320566ebe510290c9d63bba924d9d113a2c268540dbe45ea582f17366", + "size": 596858, + "subdir": "linux-64", + "timestamp": 1677855695428, + "version": "2.4.6" + }, + "srsly-2.4.6-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "778117c3fa440eda872e7909a167f03d", + "name": "srsly", + "sha256": "ab3bf835f48b4565faf86a5bff723cb6524fe68da0ab78949d2d0d44c2e3c5ff", + "size": 596030, + "subdir": "linux-64", + "timestamp": 1677855581573, + "version": "2.4.6" + }, + "ssl_match_hostname-3.5.0.1-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "2590962f61d96bd6c7e30968d6a52836", + "name": "ssl_match_hostname", + "sha256": "dc034d519fb776cc0134a76ab4743e7a02cc4fc96d19a7e408ee938b918c1b7a", + "size": 9667, + "subdir": "linux-64", + "timestamp": 1531059751818, + "version": "3.5.0.1" + }, + "ssl_match_hostname-3.5.0.1-py27h4ec10b9_2.tar.bz2": { + "build": "py27h4ec10b9_2", + "build_number": 2, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "aeadae260a04acfbf00eadecd14bf92d", + "name": "ssl_match_hostname", + "sha256": "2f3d0d9d715c4f3977fcf25900bf470bd39600c6945b3ddf16e0c45c8785c418", + "size": 9482, + "subdir": "linux-64", + "timestamp": 1505690500163, + "version": "3.5.0.1" + }, + "ssl_match_hostname-3.7.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "1ecb157d8adf1cd1d8b61eb107c7538b", + "name": "ssl_match_hostname", + "sha256": "d3d2665bae44d42f8ffe198db4a437e600961e422f18e1fb44b61d070fca9c39", + "size": 13087, + "subdir": "linux-64", + "timestamp": 1547910023909, + "version": "3.7.0.1" + }, + "statistics-1.0.3.5-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "docutils >=0.3", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c5c77c7b2b4f763dcce72e423e63d7e7", + "name": "statistics", + "sha256": "d43d8329dbbe9803c100d25c37d7828ac8f20670234a63c344d5867d472c932f", + "size": 13988, + "subdir": "linux-64", + "timestamp": 1520379028622, + "version": "1.0.3.5" + }, + "statistics-1.0.3.5-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "docutils >=0.3", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a075181f445329986cdf7ea5fc20615e", + "name": "statistics", + "sha256": "261ad41fe970570a85de2caa8b6bf489ca9469aeeee6b2df2cd5b12e3cb264d2", + "size": 14134, + "subdir": "linux-64", + "timestamp": 1642511084282, + "version": "1.0.3.5" + }, + "statsmodels-0.10.0-py27hdd07704_0.tar.bz2": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "numpy >=1.11.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6e72213b305b840295ea5b5eacb6c8ce", + "name": "statsmodels", + "sha256": "3aa243f1ae23f61b2df61a76187e6c6436563e140be58cf3d48df2e6f8050d12", + "size": 10018246, + "subdir": "linux-64", + "timestamp": 1562172050455, + "version": "0.10.0" + }, + "statsmodels-0.10.0-py36hdd07704_0.tar.bz2": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c2b0d55e961588aec6b66963c4df4bb9", + "name": "statsmodels", + "sha256": "c82b18ef69dd6bddfccf7fde7f31e54b386f1721de800b358c8b5b205952af67", + "size": 10118625, + "subdir": "linux-64", + "timestamp": 1562171940160, + "version": "0.10.0" + }, + "statsmodels-0.10.0-py37hdd07704_0.tar.bz2": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=3.7,<3.8.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a5b039413e7df6f18cdbdb8be06e0c4a", + "name": "statsmodels", + "sha256": "6f805d8d508ce54b5962aa1b1bd423c597fc08f102c9f0725a7362259d18acae", + "size": 9943283, + "subdir": "linux-64", + "timestamp": 1562171911520, + "version": "0.10.0" + }, + "statsmodels-0.10.1-py27hdd07704_0.tar.bz2": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fc200d8225f27d5d60a500d97f9b3832", + "name": "statsmodels", + "sha256": "77736f6f88ec2b9a7fff9e0e011760f851ad8951e322488aa5bfeaae22fff276", + "size": 10039478, + "subdir": "linux-64", + "timestamp": 1563914492440, + "version": "0.10.1" + }, + "statsmodels-0.10.1-py36hdd07704_0.tar.bz2": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "76a7ed14f99fc0d521743ed09e85f127", + "name": "statsmodels", + "sha256": "4c115fe11d2ad1ac2ced3e004bec3c71bbe82e02dbcc4d0d327ebfbca30d0eab", + "size": 10105357, + "subdir": "linux-64", + "timestamp": 1563914456317, + "version": "0.10.1" + }, + "statsmodels-0.10.1-py37hdd07704_0.tar.bz2": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=3.7,<3.8.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "00e3951926978e311d1db073bd660149", + "name": "statsmodels", + "sha256": "5ed5f5808a55f0323c5982aee06e86b8f0db6f260a7faf3966b35e0158ba1ff8", + "size": 9969122, + "subdir": "linux-64", + "timestamp": 1563914439334, + "version": "0.10.1" + }, + "statsmodels-0.11.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.6,<3.7.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f487b4596f246d20cc80ff4324755752", + "name": "statsmodels", + "sha256": "8a05cde5cb985901ed5a5846d625b1a1a3bbc8edb1c3a50565ea517b22a34b04", + "size": 10793696, + "subdir": "linux-64", + "timestamp": 1580251501420, + "version": "0.11.0" + }, + "statsmodels-0.11.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.7,<3.8.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3a67df25fc1d2cf9275679b5efbe42f1", + "name": "statsmodels", + "sha256": "5d5b512cd9ff5e978f992e1af4982cd17447783053d4f18a58779fce83715038", + "size": 10607853, + "subdir": "linux-64", + "timestamp": 1580251499797, + "version": "0.11.0" + }, + "statsmodels-0.11.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.8,<3.9.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e26782c7f72f359daa49804c5f8aeb8f", + "name": "statsmodels", + "sha256": "2bf75d6d5b6a58b91c87c745d0ecac208dda7a3bbca344c9be4577a8f7237d72", + "size": 10751625, + "subdir": "linux-64", + "timestamp": 1580251495072, + "version": "0.11.0" + }, + "statsmodels-0.11.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.6,<3.7.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6afeb701b32aaa953186d9a221cb01b5", + "name": "statsmodels", + "sha256": "138ab2e399500c3e378d7173632cbb9e77bd8fc8f45d6a5a958a7b8a8243ffed", + "size": 10784121, + "subdir": "linux-64", + "timestamp": 1590093152141, + "version": "0.11.1" + }, + "statsmodels-0.11.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.7,<3.8.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8797a1618b2d252c779c077f9194f72a", + "name": "statsmodels", + "sha256": "40619925bfdc046a79bcf9914bf4eef31fd3c733c6a84b81fa6b217fe92f49c8", + "size": 10647348, + "subdir": "linux-64", + "timestamp": 1590093064095, + "version": "0.11.1" + }, + "statsmodels-0.11.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.8,<3.9.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d4e0da113281c7d18ddbf859947082bb", + "name": "statsmodels", + "sha256": "5ee09364107446fcb421b09aa0f02a161bf5d6e0a7290a3bc8c6c1bb7e92e26d", + "size": 10758165, + "subdir": "linux-64", + "timestamp": 1590093140223, + "version": "0.11.1" + }, + "statsmodels-0.12.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.6,<3.7.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "34de8c1110405b0848e38a0a4a1021be", + "name": "statsmodels", + "sha256": "4ab30f0dfb6eb70647005bac4ec9f4dff839778b45b039d1ed45b49600f3c839", + "size": 11678296, + "subdir": "linux-64", + "timestamp": 1602280461035, + "version": "0.12.0" + }, + "statsmodels-0.12.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.7,<3.8.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1db471f07f337d0f7c9d0c85cec096e9", + "name": "statsmodels", + "sha256": "f1a4fe1ceaa86b558a184810e1d96e20e31ca1553dc20f38c238240b77220364", + "size": 11477455, + "subdir": "linux-64", + "timestamp": 1602280500702, + "version": "0.12.0" + }, + "statsmodels-0.12.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.19.1,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.8,<3.9.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ca8f26564affc85aefce604ad5283096", + "name": "statsmodels", + "sha256": "7c56830c145eb8ea4eaf518c55212f87403e3212284b28562d8b65426bab2add", + "size": 11639361, + "subdir": "linux-64", + "timestamp": 1602280499888, + "version": "0.12.0" + }, + "statsmodels-0.12.1-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.6,<3.7.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7b07024a02ce798efafe4aab45634a53", + "name": "statsmodels", + "sha256": "26fa80a133377139be6223921fcc1201145f191d0f93faa916bfaffd03fec64b", + "size": 11657726, + "subdir": "linux-64", + "timestamp": 1606925691863, + "version": "0.12.1" + }, + "statsmodels-0.12.1-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.7,<3.8.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "81d9be9b547511b4a199c1fdcbb9c69b", + "name": "statsmodels", + "sha256": "9167a9105781f4cb10c87ecc026c127535269b627f4877e88a8dfdf037bf25a8", + "size": 11515371, + "subdir": "linux-64", + "timestamp": 1606925730923, + "version": "0.12.1" + }, + "statsmodels-0.12.1-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.8,<3.9.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7ef641516279582b60b451c5763a2593", + "name": "statsmodels", + "sha256": "a29b7177d07cdedf4c87a76638ed908b77c25662c68092a54170f0a25397fa8f", + "size": 11611346, + "subdir": "linux-64", + "timestamp": 1606866011523, + "version": "0.12.1" + }, + "statsmodels-0.12.1-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.9,<3.10.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a8d3a91f0486051ad10a6bec1137c530", + "name": "statsmodels", + "sha256": "260f4eb2e57e9f647782bd2d3936c64db3604ece318e6e4c6246c0f7b17c5828", + "size": 11566644, + "subdir": "linux-64", + "timestamp": 1607710074650, + "version": "0.12.1" + }, + "statsmodels-0.12.2-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.6,<3.7.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4c352b19168de135f39907c69a16b03d", + "name": "statsmodels", + "sha256": "cf64cbf677de244f1e394b2aecf845e2cc691d016ad000d15268e46e502accb5", + "size": 11669764, + "subdir": "linux-64", + "timestamp": 1614024141867, + "version": "0.12.2" + }, + "statsmodels-0.12.2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.7,<3.8.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b6d5d506ad06dada23490feb39591e30", + "name": "statsmodels", + "sha256": "56e1ef8400e4f382ef07328b0088bd1959e4b2836fada719215f2af1d3d1732b", + "size": 11495066, + "subdir": "linux-64", + "timestamp": 1614024088346, + "version": "0.12.2" + }, + "statsmodels-0.12.2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.8,<3.9.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6961ef98107b9318d0c4295398a89f48", + "name": "statsmodels", + "sha256": "dfc875c4e87ae3b12cd1d2b919a7622e4862f6d0ee425f46232a24e01d401afe", + "size": 11622160, + "subdir": "linux-64", + "timestamp": 1614024129348, + "version": "0.12.2" + }, + "statsmodels-0.12.2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.9,<3.10.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20d2cabb2091a274c638873cb1efd0dc", + "name": "statsmodels", + "sha256": "3a1b9f28bbc07e3d3ca378ef9bbc20bdae0719ed9a0d075c3d76ca71bd86b124", + "size": 11558970, + "subdir": "linux-64", + "timestamp": 1614023214335, + "version": "0.12.2" + }, + "statsmodels-0.13.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "pandas >=1.0", + "patsy >=0.5.2", + "python >=3.10,<3.11.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e6538d0c6f05a0c6cdff97af831176b", + "name": "statsmodels", + "sha256": "8ccfd6ff04e7524427bafadd09b379e24f5d5b3b617930656f60c3185992025d", + "size": 21611434, + "subdir": "linux-64", + "timestamp": 1642514974483, + "version": "0.13.0" + }, + "statsmodels-0.13.0-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "pandas >=1.0", + "patsy >=0.5.2", + "python >=3.7,<3.8.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e4be201592cf37b849fd0a6b1e60714", + "name": "statsmodels", + "sha256": "a45a3c7a9d824e0b2946c7114ad35c66548b8910c7a48234434c40e9d9f63f09", + "size": 11638026, + "subdir": "linux-64", + "timestamp": 1635163331918, + "version": "0.13.0" + }, + "statsmodels-0.13.0-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "pandas >=1.0", + "patsy >=0.5.2", + "python >=3.8,<3.9.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "57e286e53ad6fd8c7e5ef195c35954c2", + "name": "statsmodels", + "sha256": "b07a8e73981c5ca50fa8ef916392f93b73a006f6fd46a54b9fb1285a61bdc950", + "size": 11754165, + "subdir": "linux-64", + "timestamp": 1635163326180, + "version": "0.13.0" + }, + "statsmodels-0.13.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "pandas >=1.0", + "patsy >=0.5.2", + "python >=3.9,<3.10.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "433f71037d9e7cdafa19c45d6eba5a48", + "name": "statsmodels", + "sha256": "519ce1d838ec39e7c5e2e64c7b9aa127f20b68a536e7c0536452935d064969c5", + "size": 11679161, + "subdir": "linux-64", + "timestamp": 1635151765338, + "version": "0.13.0" + }, + "statsmodels-0.13.2-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=21.3", + "pandas >=1.0", + "patsy >=0.5.2", + "python >=3.10,<3.11.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "03f82405643a10b867600582b4df2640", + "name": "statsmodels", + "sha256": "a425eca73d08db7964af7806aaf21a534931e4a7dc48bbf6b8a3efd11d2aced7", + "size": 21600231, + "subdir": "linux-64", + "timestamp": 1648015551848, + "version": "0.13.2" + }, + "statsmodels-0.13.2-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=21.3", + "pandas >=1.0", + "patsy >=0.5.2", + "python >=3.7,<3.8.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "81d8c5ed148079fc839be2977d5a7073", + "name": "statsmodels", + "sha256": "de27eb4fabed55688e5e9eb94205416b9bdb8b3e9e1f88a32836fc027df874ed", + "size": 11643940, + "subdir": "linux-64", + "timestamp": 1648033627475, + "version": "0.13.2" + }, + "statsmodels-0.13.2-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=21.3", + "pandas >=1.0", + "patsy >=0.5.2", + "python >=3.8,<3.9.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7b1aa8748ed2eb15f9842f983de9a710", + "name": "statsmodels", + "sha256": "132dd774917817d0fb4c9539f5f35845dc890c5faa229f9478f25df764dd29dc", + "size": 11745603, + "subdir": "linux-64", + "timestamp": 1648033614933, + "version": "0.13.2" + }, + "statsmodels-0.13.2-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=21.3", + "pandas >=1.0", + "patsy >=0.5.2", + "python >=3.9,<3.10.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "feb118e16ee8549f8f87e3e4022ba8b7", + "name": "statsmodels", + "sha256": "8d5626ec0f1a41389b3deaf8b5173f22630c24fa6cc1e389934cdff28fdddb5d", + "size": 11741711, + "subdir": "linux-64", + "timestamp": 1648015729202, + "version": "0.13.2" + }, + "statsmodels-0.13.5-py310ha9d4c09_0.tar.bz2": { + "build": "py310ha9d4c09_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=21.3", + "pandas >=0.25", + "patsy >=0.5.2", + "python >=3.10,<3.11.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8735f13a382ea34547070c5256c47da1", + "name": "statsmodels", + "sha256": "21eb6e0fead762d34ea32e03c88ece926669a1bdb209ee413b1e92738db4aa2b", + "size": 12308949, + "subdir": "linux-64", + "timestamp": 1674589232348, + "version": "0.13.5" + }, + "statsmodels-0.13.5-py310ha9d4c09_1.tar.bz2": { + "build": "py310ha9d4c09_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=21.3", + "pandas >=0.25", + "patsy >=0.5.2", + "python >=3.10,<3.11.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d6fc6dfe8ce68d816f4218d78739ef55", + "name": "statsmodels", + "sha256": "f233e172bd0a53a95997a5dc6c7f99c32ae1e80fb2d9fd68d5e794cca7772ef6", + "size": 12319458, + "subdir": "linux-64", + "timestamp": 1676644038055, + "version": "0.13.5" + }, + "statsmodels-0.13.5-py311h5eee18b_1.tar.bz2": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "packaging >=21.3", + "pandas >=0.25", + "patsy >=0.5.2", + "python >=3.11,<3.12.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b9e34e601a10d1ba5a399b81642d8470", + "name": "statsmodels", + "sha256": "d2002ecb2dd0a9df2c5dfccb1f58bf61cfc01a2839b39d2d964bd594a4685518", + "size": 13207655, + "subdir": "linux-64", + "timestamp": 1676906395241, + "version": "0.13.5" + }, + "statsmodels-0.13.5-py37h7deecbd_0.tar.bz2": { + "build": "py37h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=21.3", + "pandas >=0.25", + "patsy >=0.5.2", + "python >=3.7,<3.8.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b92588a9f48526a4f38da750a06843dd", + "name": "statsmodels", + "sha256": "65a067042f373eb6f5db2940361ad056cd3ec06d2f80d3ded6db45ba221672c7", + "size": 11671594, + "subdir": "linux-64", + "timestamp": 1674589440619, + "version": "0.13.5" + }, + "statsmodels-0.13.5-py37h7deecbd_1.tar.bz2": { + "build": "py37h7deecbd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=21.3", + "pandas >=0.25", + "patsy >=0.5.2", + "python >=3.7,<3.8.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e782a134181e22c9e83ff37d0bbf9072", + "name": "statsmodels", + "sha256": "075bc3a72d3d954b999af5cf5ce74cc6772344a33f3c45d741440e88889bbdf6", + "size": 11690688, + "subdir": "linux-64", + "timestamp": 1676644563073, + "version": "0.13.5" + }, + "statsmodels-0.13.5-py38h7deecbd_0.tar.bz2": { + "build": "py38h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=21.3", + "pandas >=0.25", + "patsy >=0.5.2", + "python >=3.8,<3.9.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee63eea1ee1114da51be076b576c1b18", + "name": "statsmodels", + "sha256": "023096de1baabf6290c3d90df71144adf3e5534820f65eb821a49a23e8704b67", + "size": 11805075, + "subdir": "linux-64", + "timestamp": 1674589639258, + "version": "0.13.5" + }, + "statsmodels-0.13.5-py38h7deecbd_1.tar.bz2": { + "build": "py38h7deecbd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=21.3", + "pandas >=0.25", + "patsy >=0.5.2", + "python >=3.8,<3.9.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "466da492c39987c3f842e5a60a5e8cac", + "name": "statsmodels", + "sha256": "eb8dc41c2defde3319f1ca38cc7d4ce3fdadb3a19814ff67f23a76d3cda49186", + "size": 11778062, + "subdir": "linux-64", + "timestamp": 1676644293948, + "version": "0.13.5" + }, + "statsmodels-0.13.5-py39h7deecbd_0.tar.bz2": { + "build": "py39h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=21.3", + "pandas >=0.25", + "patsy >=0.5.2", + "python >=3.9,<3.10.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "811d3c43799202de752a97ed2c9a019e", + "name": "statsmodels", + "sha256": "a0f04c6f801e7b7f7cd9e2bdcc82d95f05f2dd1cbd71aab275abb335f6974bba", + "size": 11680959, + "subdir": "linux-64", + "timestamp": 1674589002083, + "version": "0.13.5" + }, + "statsmodels-0.13.5-py39h7deecbd_1.tar.bz2": { + "build": "py39h7deecbd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=21.3", + "pandas >=0.25", + "patsy >=0.5.2", + "python >=3.9,<3.10.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a74742b0ebcd6c993cafd4d22b9aed98", + "name": "statsmodels", + "sha256": "05932446f3307d628ba3314f7e0133491e8a9276002371f2a173a6ea6a1b84b3", + "size": 11659534, + "subdir": "linux-64", + "timestamp": 1676644812694, + "version": "0.13.5" + }, + "statsmodels-0.8.0-py27hc87d62d_0.tar.bz2": { + "build": "py27hc87d62d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas", + "patsy", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3a09b9692db4cbadda322bf1946c7e01", + "name": "statsmodels", + "sha256": "4c95e2e77e80defd844190c2a80a69fc591d18bebf5b43ed581238e27c5711e3", + "size": 6560845, + "subdir": "linux-64", + "timestamp": 1505755624968, + "version": "0.8.0" + }, + "statsmodels-0.8.0-py35haa9d50b_0.tar.bz2": { + "build": "py35haa9d50b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas", + "patsy", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9fbfcf0cb0d96711f50a8364f6817fb0", + "name": "statsmodels", + "sha256": "02b4be675bb02c210cc43cd755df84836ef98d88d9f12c2ea19928d22f261e40", + "size": 6774114, + "subdir": "linux-64", + "timestamp": 1505755744915, + "version": "0.8.0" + }, + "statsmodels-0.8.0-py36h8533d0b_0.tar.bz2": { + "build": "py36h8533d0b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas", + "patsy", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9b90c32fc526d9fa6c058c7f9817b922", + "name": "statsmodels", + "sha256": "8876ed37a7cd40bea06c84b6b8a456068f479416645365f06991f5aa0b6cf64b", + "size": 6687009, + "subdir": "linux-64", + "timestamp": 1505755867538, + "version": "0.8.0" + }, + "statsmodels-0.9.0-py27h035aef0_0.tar.bz2": { + "build": "py27h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "91f0e345e4b914455a9d97871a86658c", + "name": "statsmodels", + "sha256": "8f5d83d902ebade48a9efe83d59c8b457dd8597a1fae56d5ee1dacfb5a875ab3", + "size": 9310221, + "subdir": "linux-64", + "timestamp": 1530960275773, + "version": "0.9.0" + }, + "statsmodels-0.9.0-py27h3010b51_0.tar.bz2": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "96583d76aef7788f01141abeb3a80192", + "name": "statsmodels", + "sha256": "1ea58eb829870e08a0136247cbcf2533778c557a1f058e44460a13f5462a8eae", + "size": 9275069, + "subdir": "linux-64", + "timestamp": 1526405628041, + "version": "0.9.0" + }, + "statsmodels-0.9.0-py35h3010b51_0.tar.bz2": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=3.5,<3.6.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0e2eb86d6383782508bf20aec1542739", + "name": "statsmodels", + "sha256": "d522e5a807210ec2882972439f04c87053b40bbd060de6b7c82bc4f705554e1e", + "size": 9264617, + "subdir": "linux-64", + "timestamp": 1526405659636, + "version": "0.9.0" + }, + "statsmodels-0.9.0-py36h035aef0_0.tar.bz2": { + "build": "py36h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2b47c5e54c5b2973790c12240f241a0f", + "name": "statsmodels", + "sha256": "7b3c8096ef279598650633128d01e7565ccd42646084405a38c1f7be243b2ef7", + "size": 9463080, + "subdir": "linux-64", + "timestamp": 1530960556340, + "version": "0.9.0" + }, + "statsmodels-0.9.0-py36h3010b51_0.tar.bz2": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "95ce801325a4d01d3c296a086be60402", + "name": "statsmodels", + "sha256": "62e030ea93136ee66fbb32bc7baabd435cb79e9e359017352f7ebab8368d0cbe", + "size": 9334812, + "subdir": "linux-64", + "timestamp": 1526405577681, + "version": "0.9.0" + }, + "statsmodels-0.9.0-py37h035aef0_0.tar.bz2": { + "build": "py37h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=3.7,<3.8.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f47eaddba9496885bc6cbf41a85194c8", + "name": "statsmodels", + "sha256": "668c5ec3d7663218de981f91293051d77d2582c569e38255f1fb22d75592378f", + "size": 9243406, + "subdir": "linux-64", + "timestamp": 1530960832276, + "version": "0.9.0" + }, + "stdlib-list-0.8.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e90da4c9c1cc4d557bf30b436bdb2693", + "name": "stdlib-list", + "sha256": "15425a878b9cf87f5afe5e4a21216692ceebc9e31e3fdb513cff09ea69c70b6e", + "size": 31138, + "subdir": "linux-64", + "timestamp": 1676903032671, + "version": "0.8.0" + }, + "stdlib-list-0.8.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fdc6b503ccdc5936a2b9f18ce5716996", + "name": "stdlib-list", + "sha256": "fcfff59a1398df5cb45b8a2d1f77f94465f0eeadfb9fdb11fbcb894340fc313e", + "size": 31057, + "subdir": "linux-64", + "timestamp": 1676902970477, + "version": "0.8.0" + }, + "stdlib-list-0.8.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "70bc61ff21e224b7a240d984d8339f74", + "name": "stdlib-list", + "sha256": "e8099adeabe46a9d8fce4aba499e7bc7774381eb259c7e8fc213c4cc86723466", + "size": 31078, + "subdir": "linux-64", + "timestamp": 1676903012038, + "version": "0.8.0" + }, + "stdlib-list-0.8.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bdadaa916de005d4b86e656b225d0d88", + "name": "stdlib-list", + "sha256": "534d16572df8edfb39ed721a9dceaf493730aa7793f2f290917b68d6d93341e0", + "size": 31042, + "subdir": "linux-64", + "timestamp": 1676902991307, + "version": "0.8.0" + }, + "strace_linux-64-11.2.0-h1234567_0.tar.bz2": { + "build": "h1234567_0", + "build_number": 0, + "depends": [], + "license": "GPL", + "md5": "60a322301ab6636667d2dbdfdcefe115", + "name": "strace_linux-64", + "sha256": "5bb9dabad6ef93caf69de4be9c7de45cfc05f47b020535f6476a93066642b6da", + "size": 556681, + "subdir": "linux-64", + "timestamp": 1652859728530, + "version": "11.2.0" + }, + "strace_linux-64-11.2.0-h1234567_1.tar.bz2": { + "build": "h1234567_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "2a466be854ae958516315e7439f7585b", + "name": "strace_linux-64", + "sha256": "7a2cff51ec1f1d4b4b2c547f00a965464928ea5f3c1092f073e58cca092cacd0", + "size": 574336, + "subdir": "linux-64", + "timestamp": 1654090813833, + "version": "11.2.0" + }, + "streamlit-1.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "attrs >=16.0.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0,<8.1", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "064457318775b3e7165c7c448c13e50c", + "name": "streamlit", + "sha256": "979cfcd8bf2538312082b6f7d24429350bd631a7413eabb67cb085a25a6c5729", + "size": 7892417, + "subdir": "linux-64", + "timestamp": 1657914812046, + "version": "1.11.0" + }, + "streamlit-1.11.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "attrs >=16.0.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0,<8.1", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.11,<3.12.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d0d8f33fe468251b94e8e59aa4f8ae61", + "name": "streamlit", + "sha256": "c18f69e923180723b1cd52c237809ee98b185ff246818ab615eb08039b72d3ce", + "size": 8017070, + "subdir": "linux-64", + "timestamp": 1676862799204, + "version": "1.11.0" + }, + "streamlit-1.11.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "attrs >=16.0.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0,<8.1", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bf3c028d3b4dd25c410ad38119641472", + "name": "streamlit", + "sha256": "e7ec12409ecacd248200e02b5959c7fda6cde5309818a040aaa1fe1779358c63", + "size": 7883794, + "subdir": "linux-64", + "timestamp": 1657914947994, + "version": "1.11.0" + }, + "streamlit-1.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "attrs >=16.0.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0,<8.1", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "488d68f9dcba08dd6e4c7e26f2b3d2a7", + "name": "streamlit", + "sha256": "e05546a1b26352938d98ac12a1f84295ea7341df51c9bf4beb4ed9c48966d814", + "size": 7895196, + "subdir": "linux-64", + "timestamp": 1657914883288, + "version": "1.11.0" + }, + "streamlit-1.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "attrs >=16.0.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0,<8.1", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "20fe8ca17ce9e988bf3c863b337930f7", + "name": "streamlit", + "sha256": "1fc3c92deb22593aed3c4d50c00d5d41f564e1b87200e7581272af0e624d6ed3", + "size": 7892831, + "subdir": "linux-64", + "timestamp": 1657915014540, + "version": "1.11.0" + }, + "streamlit-1.16.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "60a4d496ff68f4fd19ef1a2b4e8920bf", + "name": "streamlit", + "sha256": "64261424536096b0be2e06c45624292066483a36ca3a55abf657aa3b10ec87f2", + "size": 8062367, + "subdir": "linux-64", + "timestamp": 1673469728176, + "version": "1.16.0" + }, + "streamlit-1.16.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.11,<3.12.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3bdd4eb6f5453ed2c75b5a9f60dc46f8", + "name": "streamlit", + "sha256": "174a572b717c46fa1b8213a8cb88b68183843a8b0f422367c12f93e438692ff7", + "size": 8218284, + "subdir": "linux-64", + "timestamp": 1679339302736, + "version": "1.16.0" + }, + "streamlit-1.16.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4e8f9a27aedf3cf551d5de485f2412cb", + "name": "streamlit", + "sha256": "9a65c4820d7e686c1d8ca6f7172f7e84133de8297f4335cbede300d574c59441", + "size": 8059636, + "subdir": "linux-64", + "timestamp": 1673469655575, + "version": "1.16.0" + }, + "streamlit-1.16.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "376cbd9eec382f1f30fcda796d9a614e", + "name": "streamlit", + "sha256": "4b32e15df9efea96a3fbfbc5fcc094921f9762ec6727a633e127d30a1823d95d", + "size": 8063518, + "subdir": "linux-64", + "timestamp": 1673469800923, + "version": "1.16.0" + }, + "streamlit-1.16.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e9289a268dde30019c34c26a23a5f878", + "name": "streamlit", + "sha256": "8bc0cf38d26ab0a63fd246e8137a1aa2c86e02ba685f46e6344d2453ba5f0b90", + "size": 8056094, + "subdir": "linux-64", + "timestamp": 1673469571036, + "version": "1.16.0" + }, + "streamz-0.2.0-py27h9c708c3_0.tar.bz2": { + "build": "py27h9c708c3_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "25eefcde0c5c82b9ab18f258f3031a86", + "name": "streamz", + "sha256": "faecc968131f7ad653b3657100d13742e52c633fa0b30be5166659a39754cd11", + "size": 45144, + "subdir": "linux-64", + "timestamp": 1509178897145, + "version": "0.2.0" + }, + "streamz-0.2.0-py35h3e04ef2_0.tar.bz2": { + "build": "py35h3e04ef2_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "713b0e7aea908c24527d439c63ace1df", + "name": "streamz", + "sha256": "373a9687806c727cb845dbfbb6debca803daae6c754450eeb545cde03e8001b0", + "size": 46861, + "subdir": "linux-64", + "timestamp": 1509178917651, + "version": "0.2.0" + }, + "streamz-0.2.0-py36hbb54d36_0.tar.bz2": { + "build": "py36hbb54d36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4bd7b00b2ba5c841c539c8af8a431e60", + "name": "streamz", + "sha256": "6afeb7068c170dab41a694e6bf4357f0d4227947eabc696fd290773668c518a3", + "size": 46748, + "subdir": "linux-64", + "timestamp": 1509178925958, + "version": "0.2.0" + }, + "streamz-0.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6c64857cad0e856da22fa591b02f4fb1", + "name": "streamz", + "sha256": "860df5a2034bde3e64a14693e357c19bdd67a14f71bef269ef9986f8568297fa", + "size": 57014, + "subdir": "linux-64", + "timestamp": 1519481559225, + "version": "0.3.0" + }, + "streamz-0.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "deaa55dd4ba114dd3c89d700002acd40", + "name": "streamz", + "sha256": "dd3aedd9dcd9dd0cd15176420fe0f9fca03093b6baf8e31e9758aee370d30a85", + "size": 59049, + "subdir": "linux-64", + "timestamp": 1519481577041, + "version": "0.3.0" + }, + "streamz-0.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f8712ba01a359a5a48b1bcc05d707361", + "name": "streamz", + "sha256": "50f2617aadeb08dc4709b15d992d6a34ceb1f2981a5b096fdef2d9c568b16391", + "size": 59023, + "subdir": "linux-64", + "timestamp": 1519481607156, + "version": "0.3.0" + }, + "streamz-0.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "481f0b469d616ea966d5ff5ac4f78831", + "name": "streamz", + "sha256": "88ae1195b94535b8bdda9cf0bb6ed8e7c6a760db232cf6dfa433e0339ae5e341", + "size": 59134, + "subdir": "linux-64", + "timestamp": 1531059785764, + "version": "0.3.0" + }, + "streamz-0.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "15f09989caa5be2f1fbf8de8f51bf4c2", + "name": "streamz", + "sha256": "d8eaeab0bb6dd0bc1b0843e172067f7a8d7ce2da9bcdb965f3d0eaad0d753b0a", + "size": 90157, + "subdir": "linux-64", + "timestamp": 1538171189556, + "version": "0.4.0" + }, + "streamz-0.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f7f16560771b9d6f7e6c38caad46b30f", + "name": "streamz", + "sha256": "b7b0a13796615fa2cf95655ef4d60ceda3407550b4d8deb1e695576ab5d3c75a", + "size": 92770, + "subdir": "linux-64", + "timestamp": 1538171202061, + "version": "0.4.0" + }, + "streamz-0.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0d2495797a2b963202ede88d9995ee96", + "name": "streamz", + "sha256": "8a80694a6cae7683cb127c25da4b8783a0dafa6278cfe9dab448e578a8648f8f", + "size": 92864, + "subdir": "linux-64", + "timestamp": 1538171196536, + "version": "0.4.0" + }, + "streamz-0.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "021054097f3c13f05497a62b01419b51", + "name": "streamz", + "sha256": "d4a4e5772f5cec5c6edb26b2bc7eb14ba13987ee5921927738d64eae610faa3c", + "size": 90383, + "subdir": "linux-64", + "timestamp": 1539648032780, + "version": "0.5.0" + }, + "streamz-0.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "949bdd6f65585eacfb17c7540b3ee344", + "name": "streamz", + "sha256": "a29414844b1f15311202b04b5cfc4588dd3a7b810b9b901d084919f35f126ad6", + "size": 93124, + "subdir": "linux-64", + "timestamp": 1539648048974, + "version": "0.5.0" + }, + "streamz-0.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3bdb9b935f501f1ca5ba23cc11c15bd8", + "name": "streamz", + "sha256": "1b81eeeb0a310546493355dc81586233785ff9b730145af8c860ff7e38e0d88b", + "size": 93231, + "subdir": "linux-64", + "timestamp": 1539648063751, + "version": "0.5.0" + }, + "stripe-1.68.0-py27hf392dbc_0.tar.bz2": { + "build": "py27hf392dbc_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "888d9c162ecdad2efbd451c7b4c3193a", + "name": "stripe", + "sha256": "551812e5a8c6e823640efc87e1c352e3169f68441417fd82853577f31f232f17", + "size": 250341, + "subdir": "linux-64", + "timestamp": 1508447844494, + "version": "1.68.0" + }, + "stripe-1.68.0-py35hda75455_0.tar.bz2": { + "build": "py35hda75455_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "76aa332837d721e3db606072e95e035a", + "name": "stripe", + "sha256": "256d22789421caaf5b5782ed1900deefbccd13a3632a4759c6e8668f675d8a84", + "size": 254758, + "subdir": "linux-64", + "timestamp": 1508447851503, + "version": "1.68.0" + }, + "stripe-1.68.0-py36hf796cb2_0.tar.bz2": { + "build": "py36hf796cb2_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "72d4d558b7b24a4e65d9349e2fed67a2", + "name": "stripe", + "sha256": "fc5a8489c56ee84beb1793a8c4152480929eb75388ea1ce0b3ff5ea9b41a9a25", + "size": 254232, + "subdir": "linux-64", + "timestamp": 1508447858413, + "version": "1.68.0" + }, + "stripe-1.75.0-py27h5c86c07_0.tar.bz2": { + "build": "py27h5c86c07_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "eabf81f41e20a4a7c035a92e6bbcf65d", + "name": "stripe", + "sha256": "472ce2dda696dc6866696f52d82f5dc52f2cd78064787a424dd71b2b9ecd5a39", + "size": 222447, + "subdir": "linux-64", + "timestamp": 1511834396279, + "version": "1.75.0" + }, + "stripe-1.75.0-py35h03a9acd_0.tar.bz2": { + "build": "py35h03a9acd_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "857adb4d210a3bee874b4a4a58202a0b", + "name": "stripe", + "sha256": "36f5c9c3f6ada3c1fb6e9ee3da8bb845e09b1bc4d798e10abeb1fe923b0c645d", + "size": 225082, + "subdir": "linux-64", + "timestamp": 1511834412100, + "version": "1.75.0" + }, + "stripe-1.75.0-py36h1abf1ca_0.tar.bz2": { + "build": "py36h1abf1ca_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "28ee8c709290ab78e870d625b5d81c48", + "name": "stripe", + "sha256": "74f9143df23bc12fea413a7a7818cb80531de72aff782aa3cd1748ffe102eb53", + "size": 225201, + "subdir": "linux-64", + "timestamp": 1511834412989, + "version": "1.75.0" + }, + "stripe-1.79.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "55d6f3fa02b960aef69da261fc6f4e9f", + "name": "stripe", + "sha256": "e8758c49ecf2b5bf79114ecc294e949db2b69341c1eea07c138a5a75aaa273dc", + "size": 223415, + "subdir": "linux-64", + "timestamp": 1519674090106, + "version": "1.79.0" + }, + "stripe-1.79.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "bffc313d17b4050d2dc1a3c3e1ec5633", + "name": "stripe", + "sha256": "ad70d56c01dbbc9900ecd512c73d04ef808d358f85ba27c63434af25c125e438", + "size": 226091, + "subdir": "linux-64", + "timestamp": 1519674111899, + "version": "1.79.0" + }, + "stripe-1.79.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "edafabf1f38964241cd517fb4861305a", + "name": "stripe", + "sha256": "5cf5ec825981f5afaa76eb0e4873425859d332cbd7dacb428257c544c384cb74", + "size": 226094, + "subdir": "linux-64", + "timestamp": 1519674226898, + "version": "1.79.0" + }, + "stripe-1.79.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "3fe2df98230e0c42b446a057f4ad8de5", + "name": "stripe", + "sha256": "d2b5900646876ccd2f1747ee5f35b42a6acdf0437351d13b7463e0d5e52dc4dc", + "size": 223738, + "subdir": "linux-64", + "timestamp": 1524070741550, + "version": "1.79.1" + }, + "stripe-1.79.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "5905ab3df7a4fb7b64ba448a7945a6a9", + "name": "stripe", + "sha256": "bd786d1164484ccd3d15fd21d58081a84040a924eb2c7e858cb09c822e9db3f5", + "size": 226205, + "subdir": "linux-64", + "timestamp": 1524070743961, + "version": "1.79.1" + }, + "stripe-1.79.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "603bf8c3400ce8cf6a840328ce7309cc", + "name": "stripe", + "sha256": "600facb10a4d08620879e39b4ceaba42da096e40687202298025b450e9170b38", + "size": 226171, + "subdir": "linux-64", + "timestamp": 1524070751579, + "version": "1.79.1" + }, + "stripe-1.82.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "7ea804c1bd5441fc5e564ed1cc1ec8a5", + "name": "stripe", + "sha256": "543957e217259a4f9e04f07fc1e5bda4bd9430fe82600d60d7068a309eea86d0", + "size": 225054, + "subdir": "linux-64", + "timestamp": 1526922900959, + "version": "1.82.1" + }, + "stripe-1.82.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "6c0993e04ae8b03e8e35832962e41190", + "name": "stripe", + "sha256": "817db3bb61afdbee5b679dce48335031157ddd8c3531d55e4f216eb6cfc70cdd", + "size": 227261, + "subdir": "linux-64", + "timestamp": 1526922923711, + "version": "1.82.1" + }, + "stripe-1.82.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "8ad7c8c31d2e7dd88d1573b8f39f2949", + "name": "stripe", + "sha256": "277f0661a9e872e8093ea54062e4627d82f8a6bc6a0ab0e0d8e047ca5fdb6ef2", + "size": 227180, + "subdir": "linux-64", + "timestamp": 1526922874337, + "version": "1.82.1" + }, + "stripe-1.82.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "7e126c8567f10f6ee58470aa5a6ba215", + "name": "stripe", + "sha256": "f2fe14b94c05c269520d34d6ace0fddb6e077796892936273ed9aeae15d2fa3b", + "size": 224740, + "subdir": "linux-64", + "timestamp": 1529951156151, + "version": "1.82.2" + }, + "stripe-1.82.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "4c3db2aadb3c0226a79d90579df83e94", + "name": "stripe", + "sha256": "42350933c8b71478a119a8b753a0080b90562c787dc223d2872fac2fac41cc8c", + "size": 227463, + "subdir": "linux-64", + "timestamp": 1529951164692, + "version": "1.82.2" + }, + "stripe-1.82.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "8fa165800f638b42e666d486077ccb75", + "name": "stripe", + "sha256": "7fb8c354469d4b347823f2538ce5dca32f8fc11fc3897f65a89b9e8f65a2104e", + "size": 227425, + "subdir": "linux-64", + "timestamp": 1529951111637, + "version": "1.82.2" + }, + "stripe-1.82.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "a42b66f09b72a07db37a4cc90d44aadb", + "name": "stripe", + "sha256": "b75fdde93f932b3e2ed575903b4bbb8100ad3502dedbe0f5f87b0d8e17063924", + "size": 227435, + "subdir": "linux-64", + "timestamp": 1531059827273, + "version": "1.82.2" + }, + "stripe-2.10.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "68056a4dff31bcca8b83b5f08b0cafa6", + "name": "stripe", + "sha256": "d3d2bd4cb714fd12151847a1e068c3c44270c0f31a0d86f94f2097e38d34f4ee", + "size": 227412, + "subdir": "linux-64", + "timestamp": 1539644511049, + "version": "2.10.1" + }, + "stripe-2.10.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "77f09851fd25b5b8c2e0d1e32f430bdb", + "name": "stripe", + "sha256": "375e924950c5263a25ea295c3a7380306cc2184fb5fc940a2717d59587d863b1", + "size": 230145, + "subdir": "linux-64", + "timestamp": 1539644519644, + "version": "2.10.1" + }, + "stripe-2.10.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "0f2ba1094bb2368ff968f14f18b00131", + "name": "stripe", + "sha256": "f154a439c0cb04d931ac8b27fcad88b6219950ae67e255cf6c6c3f78af07397b", + "size": 230170, + "subdir": "linux-64", + "timestamp": 1539644522073, + "version": "2.10.1" + }, + "stripe-2.11.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "ca4e6ca290b06e4e3b8205d1a1303117", + "name": "stripe", + "sha256": "463d2f9185838e4a455660648fad2468948735cdd34ae9a6bdb192e54b292628", + "size": 228067, + "subdir": "linux-64", + "timestamp": 1541053519899, + "version": "2.11.0" + }, + "stripe-2.11.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "a116337eb1e14f3bbc0b3e2a32057fde", + "name": "stripe", + "sha256": "27a82ce823eba4afde72855f810d3d47286bf3627c9e5b5ec3dfb1cb8efd6e21", + "size": 230915, + "subdir": "linux-64", + "timestamp": 1541053539846, + "version": "2.11.0" + }, + "stripe-2.11.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "39dbc21eb8fa034592b2a626fb5fc621", + "name": "stripe", + "sha256": "2090cad83cc7e99a3e2c03840e043aebee125e72a1680c822bee3db057ea9bea", + "size": 230850, + "subdir": "linux-64", + "timestamp": 1541053513448, + "version": "2.11.0" + }, + "stripe-2.12.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "0c7bae4ee513b87f9ea35847cca63cf6", + "name": "stripe", + "sha256": "a9427440e1ce54e7679254d107a688a0ad801e3960fc9b7fd08e5890e46d31f0", + "size": 228243, + "subdir": "linux-64", + "timestamp": 1542091330033, + "version": "2.12.0" + }, + "stripe-2.12.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "687efd1e9d38348351132d6be194beac", + "name": "stripe", + "sha256": "9640c0e2d04ad0ad19dec05ca7aa23f4ac5fb4e8f081053554d6a7fcb82be695", + "size": 231027, + "subdir": "linux-64", + "timestamp": 1542091387358, + "version": "2.12.0" + }, + "stripe-2.12.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "94f5aece2d35b87acd15244f19d86670", + "name": "stripe", + "sha256": "d09a9c1b6568d77c6f1a409805f7eeb5bf51ce66b571a6046c557d10172f8d36", + "size": 231075, + "subdir": "linux-64", + "timestamp": 1542091350897, + "version": "2.12.0" + }, + "stripe-2.16.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "2cda30719b00ff8d1be7c9558391514b", + "name": "stripe", + "sha256": "f5515907961ba1175950e40240705bf7edf4417a960a26b948507d48bbc4695b", + "size": 206043, + "subdir": "linux-64", + "timestamp": 1545109337355, + "version": "2.16.0" + }, + "stripe-2.16.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "73ca5c9c4be2afa54e46bc1ca8e45a3a", + "name": "stripe", + "sha256": "c569a6a8140b7d65eb16c399203a8d81d37e36102139ad66db02f603fbfbef68", + "size": 208845, + "subdir": "linux-64", + "timestamp": 1545109348757, + "version": "2.16.0" + }, + "stripe-2.16.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "5407827d700d4ffcbf3113bc12f5b0ca", + "name": "stripe", + "sha256": "04eb166d2a415dc56943a5f794825e1e7c939a0812b86f7fdc29886037a22c92", + "size": 208993, + "subdir": "linux-64", + "timestamp": 1545109380389, + "version": "2.16.0" + }, + "stripe-2.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "0c72a3486dd48a93969c3a19a624442a", + "name": "stripe", + "sha256": "d912197f9c816e7081c8e7710ca20cad3a37f77bca9cb6e410bc1c4312af7aa8", + "size": 222708, + "subdir": "linux-64", + "timestamp": 1532631504987, + "version": "2.2.0" + }, + "stripe-2.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "e1205d74ca8f9f247b1e8b38bb68431c", + "name": "stripe", + "sha256": "71c44d1ac80770f1a105041bd198c8d8a2e4294ba344fb1717793b785d6cbb6a", + "size": 225302, + "subdir": "linux-64", + "timestamp": 1532631537503, + "version": "2.2.0" + }, + "stripe-2.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "46c3575e4046b7ee1d371ba7d09ae867", + "name": "stripe", + "sha256": "6a4ddd869f588abbac0636f2440b0180ce68d3c408a504747b6d7df64bb00594", + "size": 225330, + "subdir": "linux-64", + "timestamp": 1532631485544, + "version": "2.2.0" + }, + "stripe-2.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "46fe630867fbeae38f57ea4da4779560", + "name": "stripe", + "sha256": "c6f9dc4dba6fa4471c4fd3a79e66a00efed4ce9e10fa4f7d12fcaca106018218", + "size": 225456, + "subdir": "linux-64", + "timestamp": 1532631545668, + "version": "2.2.0" + }, + "stripe-2.21.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "ce4e412e211e5512b7d0cf6560fdbfa3", + "name": "stripe", + "sha256": "c728fd7fbc64d25f965f8d2c091785e17d974f539e6ea44357b1816d44159280", + "size": 343212, + "subdir": "linux-64", + "timestamp": 1550363342554, + "version": "2.21.0" + }, + "stripe-2.21.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "bb57efaf11a0102d0d1499d511c483cd", + "name": "stripe", + "sha256": "7d45bf42d23030a4f0600b49e5eb3f669e63a0675d35de7ffd8029b5e7c2d3cb", + "size": 346151, + "subdir": "linux-64", + "timestamp": 1550363364227, + "version": "2.21.0" + }, + "stripe-2.21.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "f76fbd721fe4e17bb44230f2dc98a71a", + "name": "stripe", + "sha256": "ba6cb6c84976c619525e6df77228ee0ec1bd81cc4ca2f5d2f664807e4aac3f66", + "size": 343829, + "subdir": "linux-64", + "timestamp": 1550363325342, + "version": "2.21.0" + }, + "stripe-2.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "0afe28f89b13488bda1618ccb7eeeb9f", + "name": "stripe", + "sha256": "f125440d3d10b0dd2652e162a5945916b321469d193391245b796bab342455d3", + "size": 223597, + "subdir": "linux-64", + "timestamp": 1534661578547, + "version": "2.5.0" + }, + "stripe-2.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "6d3189bf4724d50209624b84b8326dff", + "name": "stripe", + "sha256": "2604dc41594b2b55bcd63568709931cd4b052c492be4e2e275203b1e1c630b28", + "size": 226247, + "subdir": "linux-64", + "timestamp": 1534661101560, + "version": "2.5.0" + }, + "stripe-2.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "27b8c101774061020ce6ece45a9e8810", + "name": "stripe", + "sha256": "2a477b8bd81eb3751f8b377a1c7b630c4fd4046ac5393ce07054b0993c049662", + "size": 226426, + "subdir": "linux-64", + "timestamp": 1534662761057, + "version": "2.5.0" + }, + "stripe-2.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "a4771e37830b20aa3c6ba249e89d392d", + "name": "stripe", + "sha256": "aca858f303150d22c706df4e4c2b50159f3f874c018555d72f83a4fc3870e7cb", + "size": 226622, + "subdir": "linux-64", + "timestamp": 1534661637889, + "version": "2.5.0" + }, + "stripe-2.6.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "97de7176a4461eaf9d50814100094471", + "name": "stripe", + "sha256": "67f39312f213ed7cdc366412e371df7e1ef88c4db572a9b92ed5dfdee1886d8e", + "size": 223894, + "subdir": "linux-64", + "timestamp": 1535497540430, + "version": "2.6.0" + }, + "stripe-2.6.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "b63a312ed91a52ea33e01701ca75ab45", + "name": "stripe", + "sha256": "5a2bdc34b0b4346cee29a102a82f046a64a24408f64e1243e9457f37a1f3d145", + "size": 226583, + "subdir": "linux-64", + "timestamp": 1535497574032, + "version": "2.6.0" + }, + "stripe-2.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "89cf0b736ef72cba4faaf4f19555653e", + "name": "stripe", + "sha256": "c0ef1db56f84e70768b6b85675917790b398759c0c749ba98193c200282bae4a", + "size": 226689, + "subdir": "linux-64", + "timestamp": 1535497549471, + "version": "2.6.0" + }, + "stripe-2.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "904b9515c4dab0acd9fc45e1281717c8", + "name": "stripe", + "sha256": "185a46734d477f9676c6666b89a07a64c4460d5dda83fe5c63701b698a85841e", + "size": 226686, + "subdir": "linux-64", + "timestamp": 1535497572093, + "version": "2.6.0" + }, + "subprocess32-3.2.7-py27h373dbce_0.tar.bz2": { + "build": "py27h373dbce_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "432f053d228c4c18a2bdc5d9e69cad89", + "name": "subprocess32", + "sha256": "86f60810840ea2fc1c1174a3545b9e33d9cce8a65c745bea2ca9bcc04a8f7feb", + "size": 40525, + "subdir": "linux-64", + "timestamp": 1505739293719, + "version": "3.2.7" + }, + "subprocess32-3.5.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "13be65798afa44a7a1b48b55e6b92991", + "name": "subprocess32", + "sha256": "3a9ec33255113c88f1a89403763308b7b9f68492e43a9a5416d844c454103ab8", + "size": 40947, + "subdir": "linux-64", + "timestamp": 1526493434141, + "version": "3.5.0" + }, + "subprocess32-3.5.1-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "43fdf2cfa913cad88adbd1de6bc57b23", + "name": "subprocess32", + "sha256": "c267fa5479c9b335f1697f895dfa6bb4e53976ee67f2936e326620750ec8a0e4", + "size": 40733, + "subdir": "linux-64", + "timestamp": 1527830398885, + "version": "3.5.1" + }, + "subprocess32-3.5.2-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "b881e357ff4ab9b114eb019e95cde29a", + "name": "subprocess32", + "sha256": "8815a985af0bcbe619c69499ae4f39f98b1f07884fd8de09e5efc16d49b73013", + "size": 40835, + "subdir": "linux-64", + "timestamp": 1528908524109, + "version": "3.5.2" + }, + "subprocess32-3.5.3-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "5b44a8d406ebadbe9a0e27fa9c47ce52", + "name": "subprocess32", + "sha256": "22e58f17c6098bf7f99ea128f19a4b580a741268af55201b238937adb22f830d", + "size": 45554, + "subdir": "linux-64", + "timestamp": 1539636015303, + "version": "3.5.3" + }, + "subprocess32-3.5.4-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "md5": "83a942d0fb22e88a2d6f313de23f3b4a", + "name": "subprocess32", + "sha256": "725fc044909ede4ab6057523defa47892200b874e8eeabe746c2966956732cd8", + "size": 49877, + "subdir": "linux-64", + "timestamp": 1559849640809, + "version": "3.5.4" + }, + "suds-jurko-0.6-py27_3.tar.bz2": { + "build": "py27_3", + "build_number": 3, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "3823373cdf2980d67102c1623cf683ca", + "name": "suds-jurko", + "sha256": "41587c7b43ac9dcefbddb2db6a7f3aef0e92e649cc73472d40256dc598d56f34", + "size": 252192, + "subdir": "linux-64", + "timestamp": 1537813327879, + "version": "0.6" + }, + "suds-jurko-0.6-py310h06a4308_3.tar.bz2": { + "build": "py310h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "069bb6883d934f8ceedd52ceb1aa6600", + "name": "suds-jurko", + "sha256": "e4748ef8bbe3830289b352ec14804dbeb8cb9f759d5e811a952578b4b87006f2", + "size": 268428, + "subdir": "linux-64", + "timestamp": 1641555152334, + "version": "0.6" + }, + "suds-jurko-0.6-py35_3.tar.bz2": { + "build": "py35_3", + "build_number": 3, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "be24aacf1ebcd71b90caba2f4a0b40f4", + "name": "suds-jurko", + "sha256": "8b6d676fe41732b7cf5d9feb30bb19d89af573d18a4841814d2e97c1682ec2d3", + "size": 256091, + "subdir": "linux-64", + "timestamp": 1537813370401, + "version": "0.6" + }, + "suds-jurko-0.6-py36_3.tar.bz2": { + "build": "py36_3", + "build_number": 3, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "1e3290ef665774ca3589956607d71004", + "name": "suds-jurko", + "sha256": "70044ebfedb6bde3abff2a40d7f86992de3a07bda2aaaed8b1e62cd37c80a3c5", + "size": 255087, + "subdir": "linux-64", + "timestamp": 1537813396445, + "version": "0.6" + }, + "suds-jurko-0.6-py36h06a4308_3.tar.bz2": { + "build": "py36h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "152f27a7df07468a76b1eb4fca9913dd", + "name": "suds-jurko", + "sha256": "7a81666948b82ab91fd878dd123001f73db0017e9fd51b3ffcbef9b92a6304cd", + "size": 271430, + "subdir": "linux-64", + "timestamp": 1614246460290, + "version": "0.6" + }, + "suds-jurko-0.6-py37_3.tar.bz2": { + "build": "py37_3", + "build_number": 3, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "031457d027c86fa7f443a03a6a5f8cb9", + "name": "suds-jurko", + "sha256": "c966575c84efb91196e01a23941b3d773b23b7fafe6bedea25a1a03724d97123", + "size": 255679, + "subdir": "linux-64", + "timestamp": 1537813333522, + "version": "0.6" + }, + "suds-jurko-0.6-py37h06a4308_3.tar.bz2": { + "build": "py37h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "ee3ef69d8442f6dd72441e7f992ca0f9", + "name": "suds-jurko", + "sha256": "85f70001b557c842c8463d20236a397cf8f553c78b1356f3210b805bc6241569", + "size": 271135, + "subdir": "linux-64", + "timestamp": 1614247315187, + "version": "0.6" + }, + "suds-jurko-0.6-py38_3.tar.bz2": { + "build": "py38_3", + "build_number": 3, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "4c020d7da40552c6395442eff58ec40e", + "name": "suds-jurko", + "sha256": "9c8744a6487e4e33b55efe440bd1b4b0497418dbc75a426fda18b2a2fc8d3d12", + "size": 267529, + "subdir": "linux-64", + "timestamp": 1573661817788, + "version": "0.6" + }, + "suds-jurko-0.6-py38h06a4308_3.tar.bz2": { + "build": "py38h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "c1ce0c6424c8e782fd9ddae6489f98d1", + "name": "suds-jurko", + "sha256": "268a7565d2376b2e69cb2be6b3c722afb0013b2b83240c1a1529f9b24d72d169", + "size": 271403, + "subdir": "linux-64", + "timestamp": 1614247323227, + "version": "0.6" + }, + "suds-jurko-0.6-py39h06a4308_3.tar.bz2": { + "build": "py39h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "6412bbdbbf5bc436d0763d59f4565a90", + "name": "suds-jurko", + "sha256": "e0870ed0adb886b5a42fd3bb2f67648cf090f43863fa8e8f7451ff013db47bfc", + "size": 268589, + "subdir": "linux-64", + "timestamp": 1614247317126, + "version": "0.6" + }, + "suitesparse-5.10.1-h17784d6_1.tar.bz2": { + "build": "h17784d6_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "gmp >=6.1.2", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "metis >=5.1.0,<6.0a0", + "mpfr >=4.0.2,<5.0a0", + "tbb >=2020.3" + ], + "license": "LGPL v2 (AMD, BTF, etc), BSD 3-clause (UFget), GPL v2 (UMFPACK, RBIO, SPQR, GPUQRENGINE), Apache 2.0 (Metis)", + "md5": "4c32e2e3d64802efa7661cce12132260", + "name": "suitesparse", + "sha256": "e76e5eca317b004ba7f4233d48a16e535330db79dc0422d2f55083e4bf9ed7bd", + "size": 2579657, + "subdir": "linux-64", + "timestamp": 1655304810320, + "version": "5.10.1" + }, + "suitesparse-5.10.1-h1fa4727_1.tar.bz2": { + "build": "h1fa4727_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "gmp >=6.1.2", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "metis >=5.1.0,<6.0a0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mpfr >=4.0.2,<5.0a0", + "tbb >=2020.3" + ], + "license": "LGPL v2 (AMD, BTF, etc), BSD 3-clause (UFget), GPL v2 (UMFPACK, RBIO, SPQR, GPUQRENGINE), Apache 2.0 (Metis)", + "md5": "18241dd2e9a8096728a5dab1e1d9f4bd", + "name": "suitesparse", + "sha256": "d5b3e9897cf03bc7a58420c1080340cad1ea88dcc5c02427571e5e75c05e77be", + "size": 2579954, + "subdir": "linux-64", + "timestamp": 1655304659525, + "version": "5.10.1" + }, + "suitesparse-5.10.1-h446ee2e_2.tar.bz2": { + "build": "h446ee2e_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "gmp >=6.1.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "metis >=5.1.0,<6.0a0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mpfr >=4.0.2,<5.0a0", + "tbb >=2020.3" + ], + "license": "LGPL v2 (AMD, BTF, etc), BSD 3-clause (UFget), GPL v2 (UMFPACK, RBIO, SPQR, GPUQRENGINE), Apache 2.0 (Metis)", + "md5": "948e10e5107897700a32922d178536bb", + "name": "suitesparse", + "sha256": "4b26d8832bd2b7f6138a3f2b33adc3e9115f59bf2b688c92dd4c9f36242ef6f6", + "size": 2471214, + "subdir": "linux-64", + "timestamp": 1656059765847, + "version": "5.10.1" + }, + "suitesparse-5.10.1-hccbcb17_0.tar.bz2": { + "build": "hccbcb17_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "metis >=5.1.0,<6.0a0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mpfr >=4.0.2,<5.0a0", + "tbb >=2020.3" + ], + "license": "LGPL v2 (AMD, BTF, etc), BSD 3-clause (UFget), GPL v2 (UMFPACK, RBIO, SPQR, GPUQRENGINE), Apache 2.0 (Metis)", + "md5": "5467b4a88558d2aef024f90bc15b14b1", + "name": "suitesparse", + "sha256": "bc23b91e636743e117cbfd6552cdefb1ce7da34bf2c41d8ef5e55180bab5a927", + "size": 2592262, + "subdir": "linux-64", + "timestamp": 1641890340953, + "version": "5.10.1" + }, + "suitesparse-5.10.1-he2db622_2.tar.bz2": { + "build": "he2db622_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "gmp >=6.1.2", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "metis >=5.1.0,<6.0a0", + "mpfr >=4.0.2,<5.0a0", + "tbb >=2020.3" + ], + "license": "LGPL v2 (AMD, BTF, etc), BSD 3-clause (UFget), GPL v2 (UMFPACK, RBIO, SPQR, GPUQRENGINE), Apache 2.0 (Metis)", + "md5": "69236e58001dc9c55f66cbae91251363", + "name": "suitesparse", + "sha256": "4d31862432b2f42b347242d49e105250fbed1ce426576f68ccbc385dea2a0ccf", + "size": 2471113, + "subdir": "linux-64", + "timestamp": 1656059595613, + "version": "5.10.1" + }, + "suitesparse-5.2.0-h0253a28_0.tar.bz2": { + "build": "h0253a28_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "metis >=5.1.0,<6.0a0", + "tbb >=2018.0.4,<2019.0a0" + ], + "license": "LGPL v2 (AMD, BTF, etc), BSD 3-clause (UFget), GPL v2 (UMFPACK, RBIO, SPQR, GPUQRENGINE), Apache 2.0 (Metis)", + "md5": "86e42670e65533d9853697e9d629c3cc", + "name": "suitesparse", + "sha256": "7b14ce241555fab045935dd60797ab1737348a59ddab9a331caeb70525309b1f", + "size": 2483333, + "subdir": "linux-64", + "timestamp": 1528940862588, + "version": "5.2.0" + }, + "suitesparse-5.2.0-h171a5a3_0.tar.bz2": { + "build": "h171a5a3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "metis >=5.1.0,<6.0a0", + "mkl >=2018.0.3,<2019.0a0", + "tbb >=2018.0.4,<2019.0a0" + ], + "license": "LGPL v2 (AMD, BTF, etc), BSD 3-clause (UFget), GPL v2 (UMFPACK, RBIO, SPQR, GPUQRENGINE), Apache 2.0 (Metis)", + "md5": "5fd03afe27724888e1ab5d685dfc7b18", + "name": "suitesparse", + "sha256": "0a2837489dfbaf793f0fab4a297a31d122c6f8a83506dad96dd90f9ad850507f", + "size": 2483812, + "subdir": "linux-64", + "timestamp": 1528940946760, + "version": "5.2.0" + }, + "suitesparse-5.2.0-h2ffa06c_0.tar.bz2": { + "build": "h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "metis >=5.1.0,<6.0a0", + "tbb >=2019.1" + ], + "license": "LGPL v2 (AMD, BTF, etc), BSD 3-clause (UFget), GPL v2 (UMFPACK, RBIO, SPQR, GPUQRENGINE), Apache 2.0 (Metis)", + "md5": "ff276ea6027b180b001edd8b7716c693", + "name": "suitesparse", + "sha256": "8f7096c261177b4fd57945f408da23d396de9cf8c56dcffbca7a92eb933775e4", + "size": 2534275, + "subdir": "linux-64", + "timestamp": 1550646422332, + "version": "5.2.0" + }, + "suitesparse-5.2.0-h9e4a6bb_0.tar.bz2": { + "build": "h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "metis >=5.1.0,<6.0a0", + "mkl >=2019.1,<2021.0a0", + "tbb >=2019.1" + ], + "license": "LGPL v2 (AMD, BTF, etc), BSD 3-clause (UFget), GPL v2 (UMFPACK, RBIO, SPQR, GPUQRENGINE), Apache 2.0 (Metis)", + "md5": "2f70fdadeabeabaf9942356837e53cba", + "name": "suitesparse", + "sha256": "991e8f0a0119cfa8efdcfedb7ca985a04146e679b7ac5a3f6da4be30442f963b", + "size": 2544606, + "subdir": "linux-64", + "timestamp": 1550646469944, + "version": "5.2.0" + }, + "supervisor-3.3.3-py27h9aadb0f_0.tar.bz2": { + "build": "py27h9aadb0f_0", + "build_number": 0, + "depends": [ + "meld3 >=0.6.5", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "d04d66891b2507560063f6a0551b45e0", + "name": "supervisor", + "sha256": "4e9e10d3d940da6074581bb1d165185b6399f0b3eba17dec653896b03e519f44", + "size": 466988, + "subdir": "linux-64", + "timestamp": 1508999918344, + "version": "3.3.3" + }, + "supervisor-3.3.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=0.6.5", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "de661dc869d2f5cc3272b30c5d83c361", + "name": "supervisor", + "sha256": "ab552105942a935d773e573cf38c453e2d199b4205d2d8bd1156c23a45074b1b", + "size": 471430, + "subdir": "linux-64", + "timestamp": 1520793743501, + "version": "3.3.4" + }, + "supervisor-3.3.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=0.6.5", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "cb37882c6caf6c86acec8fbbbab7c62c", + "name": "supervisor", + "sha256": "524f9e665fc762d0f557ebe09cb5db3143662a20ee65c311d60c69430a468035", + "size": 483363, + "subdir": "linux-64", + "timestamp": 1548006621221, + "version": "3.3.5" + }, + "supervisor-4.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "5513d66dda8c533c08f73c6b4f54cd32", + "name": "supervisor", + "sha256": "824c28cfc2223bbc81d5fc88fae679aea42c98d44f9716d79e8800814e60d1c0", + "size": 498330, + "subdir": "linux-64", + "timestamp": 1556076712610, + "version": "4.0.2" + }, + "supervisor-4.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "f77099f941527d4dbb03d733c407901d", + "name": "supervisor", + "sha256": "f6f50fa448259bcb45b14e0c436f62645438ca07653e5e6026da60d487adfce3", + "size": 514486, + "subdir": "linux-64", + "timestamp": 1556076750652, + "version": "4.0.2" + }, + "supervisor-4.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "64e5081c64b01563ac755ec03a236133", + "name": "supervisor", + "sha256": "fc2a8922a5c8e5cc9d929f0cc53239382c91638bce95257bdcbda0fbf166f6f3", + "size": 517213, + "subdir": "linux-64", + "timestamp": 1556076854283, + "version": "4.0.2" + }, + "supervisor-4.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "61b9c98532e6804333a9018c5a668c07", + "name": "supervisor", + "sha256": "30e7f323017563c710b85dfb059211b64a568a2ac6f46868e84f3eaf64f41683", + "size": 500264, + "subdir": "linux-64", + "timestamp": 1559925087743, + "version": "4.0.3" + }, + "supervisor-4.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "4097ec17b06e5b7de3f4c21c18961807", + "name": "supervisor", + "sha256": "3633c0a2a7bbb5e95c70992ed70d7cd00999aa2cf0b87c42910046ee49d34261", + "size": 519478, + "subdir": "linux-64", + "timestamp": 1559925103215, + "version": "4.0.3" + }, + "supervisor-4.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "9be5d1db24b048ce263bf523148642e3", + "name": "supervisor", + "sha256": "d968ec15203f2062c26b32564c172d0129c8ec3882d65d1c5639e2916582092d", + "size": 520278, + "subdir": "linux-64", + "timestamp": 1559925071121, + "version": "4.0.3" + }, + "supervisor-4.0.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "b89d29192cb0593ebd50e7098c1977dd", + "name": "supervisor", + "sha256": "7953696c0eb7bd3cc1e945aa1b4d5b0e977cc78387ff9f3fb27836bce4c98585", + "size": 500155, + "subdir": "linux-64", + "timestamp": 1564709062002, + "version": "4.0.4" + }, + "supervisor-4.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "8723b19998176e68b81b1b74adf0b6ff", + "name": "supervisor", + "sha256": "beef8aa25285c38ff9a25ec59f86275da15c1b1bb6d02164de42fc0b67412ad1", + "size": 520819, + "subdir": "linux-64", + "timestamp": 1564709090787, + "version": "4.0.4" + }, + "supervisor-4.0.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "1e399bda9569c0076f7e1881d3f203e4", + "name": "supervisor", + "sha256": "85476c03699c4793cd62b85787200b59b47bd4d872223f152c3e0e7e51773b94", + "size": 521606, + "subdir": "linux-64", + "timestamp": 1564709013545, + "version": "4.0.4" + }, + "supervisor-4.0.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "5cd7a5216fe23c7f2647a4b61c5debc3", + "name": "supervisor", + "sha256": "cede242efccdc584532b5aa9c2dbd67f0b50fd90e5fbb605099522461207ef5b", + "size": 517805, + "subdir": "linux-64", + "timestamp": 1573554618289, + "version": "4.0.4" + }, + "supervisor-4.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "3ccb614e9be8ffae1149041c4e4964f5", + "name": "supervisor", + "sha256": "e6b792bad57d6475ca36076a370986922794bb5ddebcf01890300bdba8fa2332", + "size": 554900, + "subdir": "linux-64", + "timestamp": 1573973797500, + "version": "4.1.0" + }, + "supervisor-4.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "d77fa2586b25c57a9517516407784eed", + "name": "supervisor", + "sha256": "b96849a046c1534b7645ae7953be812d59b3329195cbb25563f5c5d25fa67537", + "size": 560588, + "subdir": "linux-64", + "timestamp": 1573973795992, + "version": "4.1.0" + }, + "supervisor-4.1.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "meld3 >=1", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "f305af954e83486a643dd00786b58e3a", + "name": "supervisor", + "sha256": "9d1bb9c840c61aebc36c96eed4a77bb1dd163f8891dc08275eccac665bd90833", + "size": 569199, + "subdir": "linux-64", + "timestamp": 1614080336814, + "version": "4.1.0" + }, + "supervisor-4.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "3d9efacb6474febd55cbf6002b2a08f2", + "name": "supervisor", + "sha256": "dc3e30e2fa3f15fe9ba7d4b5bf294b5258ebfcd35a0b4106311cdaf627f4eba1", + "size": 564631, + "subdir": "linux-64", + "timestamp": 1573973757279, + "version": "4.1.0" + }, + "supervisor-4.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "meld3 >=1", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "57aac298dcf41d40a66efed36b5777bf", + "name": "supervisor", + "sha256": "001cdf5dc3d898947195ce582ec04e9046aa63ff990655116e0848880e12b3ee", + "size": 566247, + "subdir": "linux-64", + "timestamp": 1614081253567, + "version": "4.1.0" + }, + "supervisor-4.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "933bcf3f398b5c122e931f93b821a428", + "name": "supervisor", + "sha256": "f359b1cb8fe906f6cc9dfad41907932a25fa7bd0e536180b516ad1fcdeb22822", + "size": 568834, + "subdir": "linux-64", + "timestamp": 1573973792000, + "version": "4.1.0" + }, + "supervisor-4.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "meld3 >=1", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "e0f0a67c56b1bf28b527d457b0dd4f79", + "name": "supervisor", + "sha256": "055389c95a39358b6806ff6192fda76ba0e7447a87aebf4e7f4f6aa25948edb0", + "size": 566471, + "subdir": "linux-64", + "timestamp": 1614081255050, + "version": "4.1.0" + }, + "supervisor-4.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "meld3 >=1", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "5c2041b7e0739f43855bb5c3d5c2ee0d", + "name": "supervisor", + "sha256": "61b51098793f367633b50a5f9b1b2046bcadb8b9ffd0da3a849af6d02cfd3b01", + "size": 572194, + "subdir": "linux-64", + "timestamp": 1614081250986, + "version": "4.1.0" + }, + "supervisor-4.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "9ad19b5e443376574244b48f3500ca79", + "name": "supervisor", + "sha256": "65a07f91a68323633b1a15c01e90f65826e9e7a626e06d0fbd9bf55e8ca0a83d", + "size": 562087, + "subdir": "linux-64", + "timestamp": 1597083414680, + "version": "4.2.0" + }, + "supervisor-4.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "76dbfa1309cdbaa9bc58b450a6b9bd5c", + "name": "supervisor", + "sha256": "db3f24cdb0ec643f8136c2fe8e86314442ef868902f1f36c2233e6cb37b816c2", + "size": 559194, + "subdir": "linux-64", + "timestamp": 1600554370558, + "version": "4.2.1" + }, + "supervisor-4.2.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "f6f8c30a3fba44e55335f32e9a73d9c1", + "name": "supervisor", + "sha256": "233db5c252b9450f44eae5adf5de0f0c59a8f84135246f214c30073e5c54fa94", + "size": 568347, + "subdir": "linux-64", + "timestamp": 1614081577913, + "version": "4.2.1" + }, + "supervisor-4.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "c94ea50ecc6e999407b59e1de187fcfb", + "name": "supervisor", + "sha256": "33f9ddd667f81850ee776a385fd79ebf87259a7fca4ace7bb610a4b3a758ee55", + "size": 556049, + "subdir": "linux-64", + "timestamp": 1600554336770, + "version": "4.2.1" + }, + "supervisor-4.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "6fc225d71b6bf6b83436159570a83535", + "name": "supervisor", + "sha256": "efe1c96343d2847aa5d6c0b16134d9b9ee0046bda2290fe7e346524039861b90", + "size": 566677, + "subdir": "linux-64", + "timestamp": 1614081586354, + "version": "4.2.1" + }, + "supervisor-4.2.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "69b0c656439938f0d3d1171eca3701bc", + "name": "supervisor", + "sha256": "34b4f9bd85d145e1753a872807222c794c3507b44b3813739bf81888c37fa605", + "size": 559924, + "subdir": "linux-64", + "timestamp": 1600554344378, + "version": "4.2.1" + }, + "supervisor-4.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "02930912465f2a52993f8e54cc27a2f4", + "name": "supervisor", + "sha256": "24fa62b1c687540ce662bd478d7fc12c18b5818766e576e0ee7c2b4d5bcda179", + "size": 569458, + "subdir": "linux-64", + "timestamp": 1614081138789, + "version": "4.2.1" + }, + "supervisor-4.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "0a62dab282a284759b6244cdb9a51214", + "name": "supervisor", + "sha256": "0c7d1627e8649621205d7c9db572dc0f81193677dfc18c8ea920faa66b091452", + "size": 562682, + "subdir": "linux-64", + "timestamp": 1614081590729, + "version": "4.2.1" + }, + "supervisor-4.2.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "gettext >=0.21.0,<1.0a0", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "BSD-derived AND PSF AND Other", + "license_family": "BSD", + "md5": "c50e0be0ea6608cc99ddef935e2b595d", + "name": "supervisor", + "sha256": "d7414289dfb4f0b8ab3e8c010117adb618847bd46c7716ad1c4605571c42fb11", + "size": 566633, + "subdir": "linux-64", + "timestamp": 1640794952224, + "version": "4.2.2" + }, + "supervisor-4.2.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "gettext >=0.21.0,<1.0a0", + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "BSD-derived AND PSF AND Other", + "license_family": "BSD", + "md5": "d49e538a4a760828f3e73ee16829af98", + "name": "supervisor", + "sha256": "a7bd2dc65dbacbf40c909d359cb64c13a52c3c99dfd18e8182f60bd13873dd81", + "size": 796142, + "subdir": "linux-64", + "timestamp": 1676862823899, + "version": "4.2.2" + }, + "supervisor-4.2.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "gettext >=0.21.0,<1.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-derived AND PSF AND Other", + "license_family": "BSD", + "md5": "d5436678d447c70acf09dd1b96b97c5a", + "name": "supervisor", + "sha256": "68a4ed60d26883588f64bddf53a7301f2e0f4ad1c769de6af923a037b56d58fb", + "size": 564747, + "subdir": "linux-64", + "timestamp": 1624542934833, + "version": "4.2.2" + }, + "supervisor-4.2.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "gettext >=0.21.0,<1.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-derived AND PSF AND Other", + "license_family": "BSD", + "md5": "1d0314deac023758b94496ce50038b41", + "name": "supervisor", + "sha256": "18db358377e151fde57b7a34c5e4b4b405769cec1fb1fa2e16a7ca5dd7730581", + "size": 565013, + "subdir": "linux-64", + "timestamp": 1624542756479, + "version": "4.2.2" + }, + "supervisor-4.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "gettext >=0.21.0,<1.0a0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-derived AND PSF AND Other", + "license_family": "BSD", + "md5": "e367bd49f34eb8e7f951e7049f028e0d", + "name": "supervisor", + "sha256": "9e009da5ff96298f5a5b582a4743a630e9d01ef146462805d8346502605713d9", + "size": 565564, + "subdir": "linux-64", + "timestamp": 1624542922735, + "version": "4.2.2" + }, + "supervisor-4.2.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "gettext >=0.21.0,<1.0a0", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "BSD-derived AND PSF AND Other", + "license_family": "BSD", + "md5": "3793d0a022278ad0b0af68a78e8238c2", + "name": "supervisor", + "sha256": "771fa124a1214b755f4fdcef03d4cca53cfa984c2b4f20cbce44681d6f05252b", + "size": 567107, + "subdir": "linux-64", + "timestamp": 1624542941194, + "version": "4.2.2" + }, + "svn-1.10.0-ha72275e_0.tar.bz2": { + "build": "ha72275e_0", + "build_number": 0, + "depends": [ + "apr >=1.6.3,<2.0a0", + "cyrus-sasl >=2.1.26,<3.0a0", + "expat >=2.2.5,<3.0a0", + "libgcc-ng >=7.2.0", + "libutf8proc >=2.1.1,<2.2.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "serf >=1.3.9,<1.4.0a0", + "sqlite >=3.23.1,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache Software License V.2", + "license_family": "Apache", + "md5": "d77348029888179bd832c66c4e2a6554", + "name": "svn", + "sha256": "87a7885f205034f995b1310bbc96b3462353c08ab6581400830f3455197cb394", + "size": 4228376, + "subdir": "linux-64", + "timestamp": 1527951016154, + "version": "1.10.0" + }, + "svn-1.10.2-h52f66ed_0.tar.bz2": { + "build": "h52f66ed_0", + "build_number": 0, + "depends": [ + "apr >=1.6.3,<2.0a0", + "cyrus-sasl >=2.1.26,<3.0a0", + "expat >=2.2.5,<3.0a0", + "libgcc-ng >=7.2.0", + "libutf8proc >=2.1.1,<2.2.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "serf >=1.3.9,<1.4.0a0", + "sqlite >=3.24.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache Software License V.2", + "license_family": "Apache", + "md5": "cf6ae0dc60d1695844194aa35580ca33", + "name": "svn", + "sha256": "019efa31de990e165f3d434f01fb68a619f1a413ee3dd9c3619ea68a2bc7811f", + "size": 4229353, + "subdir": "linux-64", + "timestamp": 1533705671201, + "version": "1.10.2" + }, + "svn-1.9.7-h30a3245_0.tar.bz2": { + "build": "h30a3245_0", + "build_number": 0, + "depends": [ + "apr >=1.6.3,<2.0a0", + "libgcc-ng >=7.2.0", + "serf >=1.3.9,<1.4.0a0", + "sqlite >=3.20.1,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache Software License V.2", + "license_family": "Apache", + "md5": "9b96f22ad2b5b9360a9ecaf35cc4379a", + "name": "svn", + "sha256": "76dc3e19c69b67c3837cbae847d03691db9971f4292da3c95712042c2663d3bc", + "size": 3233514, + "subdir": "linux-64", + "timestamp": 1513193396587, + "version": "1.9.7" + }, + "swagger-ui-bundle-0.0.9-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "421e8ff44f7dfcc20416923b49b2c45e", + "name": "swagger-ui-bundle", + "sha256": "93f45c0bd32fa0970a891267d9a4d16163db5e92f9f074f80c7233de2b0ea2d9", + "size": 5218528, + "subdir": "linux-64", + "timestamp": 1667595868886, + "version": "0.0.9" + }, + "swagger-ui-bundle-0.0.9-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a7491fc74afe134b6b920697c74889a9", + "name": "swagger-ui-bundle", + "sha256": "a540a30ab2f72836cea83f88f6833ffe0cf0f2fcf9a3dad87af70b671c5f7953", + "size": 5251881, + "subdir": "linux-64", + "timestamp": 1676838823706, + "version": "0.0.9" + }, + "swagger-ui-bundle-0.0.9-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c58b3741a6a9bf16d95130ff22cc6111", + "name": "swagger-ui-bundle", + "sha256": "35b67c599bfd96143e3261777ce13c6ee55b8f192634ffd26953aa4ac3f4ef42", + "size": 5218521, + "subdir": "linux-64", + "timestamp": 1667595794651, + "version": "0.0.9" + }, + "swagger-ui-bundle-0.0.9-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "81d79dae02bd7f2b4707aa0eea46f49d", + "name": "swagger-ui-bundle", + "sha256": "f89f9406a7a7639815d7d63d1853ba8269e2c6e4daf33cb4017e29fa5bde4a73", + "size": 5215934, + "subdir": "linux-64", + "timestamp": 1667595755340, + "version": "0.0.9" + }, + "swagger-ui-bundle-0.0.9-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7d4a86b52b2f24d7a73ff0c80998e760", + "name": "swagger-ui-bundle", + "sha256": "15809308027036716152c3b348beab13a6ddda09ec584c3a4a075a1f328af177", + "size": 5216906, + "subdir": "linux-64", + "timestamp": 1667595831783, + "version": "0.0.9" + }, + "swig-3.0.12-h38cdd7d_3.tar.bz2": { + "build": "h38cdd7d_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "pcre" + ], + "license": "GPL 3", + "license_family": "GPL", + "md5": "1abbbc5f00ed5a1305a5948431b03df9", + "name": "swig", + "sha256": "2cf56561449fedc45c6e6d6eb81fcf3b79e339538167b0ed50a211263cada070", + "size": 1324769, + "subdir": "linux-64", + "timestamp": 1513182163621, + "version": "3.0.12" + }, + "swig-4.0.2-h2531618_3.tar.bz2": { + "build": "h2531618_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.44,<9.0a0" + ], + "license": "GPL 3", + "license_family": "GPL", + "md5": "a0c87e1f47a9d188996c43efe255b3d5", + "name": "swig", + "sha256": "7b22582aee778d05ea764f5c5949cb3a578aaf5ec2bee744c5a83c5ff498cb60", + "size": 1250058, + "subdir": "linux-64", + "timestamp": 1612469500179, + "version": "4.0.2" + }, + "swig-4.0.2-h295c915_4.tar.bz2": { + "build": "h295c915_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "pcre >=8.45,<9.0a0" + ], + "license": "GPL 3", + "license_family": "GPL", + "md5": "b1d083d826077f80110f53da893b2758", + "name": "swig", + "sha256": "c534c2a3bf241a811b32c48c2f52674d2a4010e5b51311ec97a34a9cc0e88711", + "size": 1251579, + "subdir": "linux-64", + "timestamp": 1634714506100, + "version": "4.0.2" + }, + "sympy-1.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=2.7,<2.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "674cb1a3192dd7609735316fd7fac919", + "name": "sympy", + "sha256": "3890696e322551614ae675e94f9c62473b70af9a57371f65a696a4ca97b7c10f", + "size": 7231637, + "subdir": "linux-64", + "timestamp": 1531060144343, + "version": "1.1.1" + }, + "sympy-1.1.1-py27hc28188a_0.tar.bz2": { + "build": "py27hc28188a_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=2.7,<2.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "9fca250183b86f31b319beb74f3beba4", + "name": "sympy", + "sha256": "0112d0328c0c5d55bc2dec21396bd23e7f4bd0740a2cf8c9d6f782e51111b2f6", + "size": 7231542, + "subdir": "linux-64", + "timestamp": 1505851806040, + "version": "1.1.1" + }, + "sympy-1.1.1-py35h919b29a_0.tar.bz2": { + "build": "py35h919b29a_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.5,<3.6.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "6c7a5403fe7c36b750a7744641e18cd4", + "name": "sympy", + "sha256": "d38961fdaa4c84b9bc8d77bfa39b6c8a28529a529f8ebcbcb20d7c7a5428c444", + "size": 7419255, + "subdir": "linux-64", + "timestamp": 1505851892777, + "version": "1.1.1" + }, + "sympy-1.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "632405f170895c9ac1b9e944633ee04a", + "name": "sympy", + "sha256": "52b673fe3606cdac4ac2183a49a1c8c05e6a3089f1cf607843cad8900f9fe260", + "size": 7142338, + "subdir": "linux-64", + "timestamp": 1531059942045, + "version": "1.1.1" + }, + "sympy-1.1.1-py36hc6d1c1c_0.tar.bz2": { + "build": "py36hc6d1c1c_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "cdf81f824ac0c5ed468f25da41de48ef", + "name": "sympy", + "sha256": "d1466741252d903671d3670b63cd41a4f2b18771ec39a3cf192b1456a4a8a9a5", + "size": 7327927, + "subdir": "linux-64", + "timestamp": 1505851980578, + "version": "1.1.1" + }, + "sympy-1.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "09e10e2db558b007450b8219dfe41f81", + "name": "sympy", + "sha256": "7f561f267ad99060c9f1723b7a5c87e16e0cd85ca13b2f9797326f2ce1029901", + "size": 7143123, + "subdir": "linux-64", + "timestamp": 1531060053633, + "version": "1.1.1" + }, + "sympy-1.10.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause AND MIT", + "license_family": "BSD", + "md5": "e8b531ddfc6fed9aceba6aa8b591d6b0", + "name": "sympy", + "sha256": "294780b1ff54f9b8083b8f20293dbd0b363ebea5113fd09e94b8c94fb6cec707", + "size": 12321970, + "subdir": "linux-64", + "timestamp": 1647835869549, + "version": "1.10.1" + }, + "sympy-1.10.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause AND MIT", + "license_family": "BSD", + "md5": "afa5aee1af7b718354aeac23b058a2f6", + "name": "sympy", + "sha256": "21f3cc3f887e4c0097582e5f786dd7eb6315e0993df5540b1dd545441e187c80", + "size": 19618021, + "subdir": "linux-64", + "timestamp": 1676845911461, + "version": "1.10.1" + }, + "sympy-1.10.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause AND MIT", + "license_family": "BSD", + "md5": "a3d30f141bc941b6b07942e49f31e4d9", + "name": "sympy", + "sha256": "872227ae1eb6fb48aaa0ad060e9269b7f2ac357d7f2be034f363e6899c802d69", + "size": 12226795, + "subdir": "linux-64", + "timestamp": 1647835589018, + "version": "1.10.1" + }, + "sympy-1.10.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause AND MIT", + "license_family": "BSD", + "md5": "3d5b7751e9449c3774d8c40d36a52972", + "name": "sympy", + "sha256": "0775baee2a07e03c7f1bf2120ec5fcb95c9637f881687b8682aefe07a02861dd", + "size": 12278110, + "subdir": "linux-64", + "timestamp": 1647853718110, + "version": "1.10.1" + }, + "sympy-1.10.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause AND MIT", + "license_family": "BSD", + "md5": "511002cbb7eeacf6973c7e03bf0b9cea", + "name": "sympy", + "sha256": "e322c6044cd60cefdf343cbb0d9be63f426d899b4cb257af5c3d52f9550bb93c", + "size": 12233214, + "subdir": "linux-64", + "timestamp": 1647853714323, + "version": "1.10.1" + }, + "sympy-1.11.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause AND MIT", + "license_family": "BSD", + "md5": "726f8246fa97b279e2a5a87c26be0587", + "name": "sympy", + "sha256": "7a656409fc53f3341c4a57ab71c3e311aeef08cc1a57bd2e6aa0bd23e5e2d79d", + "size": 12445806, + "subdir": "linux-64", + "timestamp": 1668202452480, + "version": "1.11.1" + }, + "sympy-1.11.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause AND MIT", + "license_family": "BSD", + "md5": "79bda26adbe492b87a0a0ee8cf6db54b", + "name": "sympy", + "sha256": "a639ed3036d9fc5bcca6467339a2e42b096205e345ec89d690c322345dd07142", + "size": 19844517, + "subdir": "linux-64", + "timestamp": 1679339356417, + "version": "1.11.1" + }, + "sympy-1.11.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause AND MIT", + "license_family": "BSD", + "md5": "c6b6a9f893483f58b9f431fc17a08ea0", + "name": "sympy", + "sha256": "b588dc43b9004a3afb4b3b23ecf063ff6560d80d2e2494536c7e000758662aa4", + "size": 12407159, + "subdir": "linux-64", + "timestamp": 1668206322385, + "version": "1.11.1" + }, + "sympy-1.11.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause AND MIT", + "license_family": "BSD", + "md5": "610a90128fe91c0402b3907b14c43542", + "name": "sympy", + "sha256": "d0a6c03dbe0b345752dee89659b33bbeb03457d7f370492daa8bc86f3d4841e1", + "size": 12358373, + "subdir": "linux-64", + "timestamp": 1668204388050, + "version": "1.11.1" + }, + "sympy-1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=2.7,<2.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "a0e970a26b601095dac802caa3b7e31b", + "name": "sympy", + "sha256": "13522f92fefd71dc789c4eab591573bd51f80f1b3029fcbad4edecbb0f8a2b56", + "size": 9452323, + "subdir": "linux-64", + "timestamp": 1532527819078, + "version": "1.2" + }, + "sympy-1.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.5,<3.6.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "c3d809ddb5c88e89f26d38d9e8464605", + "name": "sympy", + "sha256": "0a94d29c9d100562b5a8865dbb947e2088b1621a8218d94905610515d6e6056a", + "size": 10374491, + "subdir": "linux-64", + "timestamp": 1532528003666, + "version": "1.2" + }, + "sympy-1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "83f824f6faeed05c56be490c3017992a", + "name": "sympy", + "sha256": "ca9f83681ce340afa76078d0e234a20e30d1cddf95d83d40f1ed0cd95b037c8e", + "size": 9251769, + "subdir": "linux-64", + "timestamp": 1532527886314, + "version": "1.2" + }, + "sympy-1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "18ac4e9b07e92940b16794f684b87332", + "name": "sympy", + "sha256": "2e6e9f5bc88ca4be3fa05b1fbbc97411b756b9ce7dbb096a8e29708a8888b342", + "size": 9229778, + "subdir": "linux-64", + "timestamp": 1532528024334, + "version": "1.2" + }, + "sympy-1.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=2.7,<2.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "ae2d364ea8902f551e3fe9a6437bedee", + "name": "sympy", + "sha256": "b85e151f5c3e429c6017d75f685993debd067f780fdf81971606a76b9fc86b8b", + "size": 10177301, + "subdir": "linux-64", + "timestamp": 1538155955148, + "version": "1.3" + }, + "sympy-1.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "448a5a28c9e63233565e88f8001c2a6b", + "name": "sympy", + "sha256": "793ef07a73d29e27926140a146dd55cb49f464d7ec6dc535c1511ff43de11ab6", + "size": 9982366, + "subdir": "linux-64", + "timestamp": 1538156011318, + "version": "1.3" + }, + "sympy-1.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "5590f47e92217a2bb99e7415faee03d1", + "name": "sympy", + "sha256": "ac0d78739213bd93654cab6310545acff0a24180443f5569249ef2b20dfc4b39", + "size": 9967159, + "subdir": "linux-64", + "timestamp": 1538156004630, + "version": "1.3" + }, + "sympy-1.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1020eaaeeb1db2e063543037f2a584d0", + "name": "sympy", + "sha256": "c4b0dd7379625dae440fa8fe1ecf23f6de097c55722fecb3a4b102e7b939a89e", + "size": 10350712, + "subdir": "linux-64", + "timestamp": 1555436749487, + "version": "1.4" + }, + "sympy-1.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e38ea1fc09c70d967e81e4e2e840c9c4", + "name": "sympy", + "sha256": "6b2885af1376eb53a1a3e7b57f8a458f58c5b3b2472c31513b6e03bc16c724ff", + "size": 10180037, + "subdir": "linux-64", + "timestamp": 1555436756746, + "version": "1.4" + }, + "sympy-1.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6601b9de24c36ee21566c851bf8a953c", + "name": "sympy", + "sha256": "3b5fdc2b8c9193ebed3799c63a0421e49412563daa86735076105b57343ca14f", + "size": 10163351, + "subdir": "linux-64", + "timestamp": 1555436621523, + "version": "1.4" + }, + "sympy-1.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07e82608fc8f0ab6251f60f0e10638cb", + "name": "sympy", + "sha256": "011caf105da717ce5a61098d12ff560694ec29c8a56d9db7feb15606d86237d6", + "size": 10258529, + "subdir": "linux-64", + "timestamp": 1573554713852, + "version": "1.4" + }, + "sympy-1.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "199cf4c8a69224a9a1826f451090fd4d", + "name": "sympy", + "sha256": "90e902342bfec874267a762fe5d60dcef348bf77b8b6d0864c98fa81ec4879a5", + "size": 10982107, + "subdir": "linux-64", + "timestamp": 1576514427454, + "version": "1.5" + }, + "sympy-1.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "52c7d564ee7151d7c72195f5412f719f", + "name": "sympy", + "sha256": "3bd5787686dc0f7a6b104fe14863290c2d79ecd137058f8b49a87c002d85bd79", + "size": 10765102, + "subdir": "linux-64", + "timestamp": 1576514425704, + "version": "1.5" + }, + "sympy-1.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38813969719cbf8a9221d13cf3cfd937", + "name": "sympy", + "sha256": "1197d2a5167849bc4b5f6c675622c9486eb9596435a6fb6d59558aba180c040e", + "size": 10729093, + "subdir": "linux-64", + "timestamp": 1576514428809, + "version": "1.5" + }, + "sympy-1.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "15db98d50c31f8d659a30de644771533", + "name": "sympy", + "sha256": "51c07136f36299be6a9f9b12cb2c8b6a1e5bc166218c61d0ed982cf9c9b00cf0", + "size": 10755918, + "subdir": "linux-64", + "timestamp": 1576514432676, + "version": "1.5" + }, + "sympy-1.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6d81fc6d63210342646f56006a5bf871", + "name": "sympy", + "sha256": "528a45ce2460529ab030b068aa21bfbdce1daa372586dde968ca512e974ee325", + "size": 10956462, + "subdir": "linux-64", + "timestamp": 1578428409491, + "version": "1.5.1" + }, + "sympy-1.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b0ed0f44fb67bbe8b901c158f2d58133", + "name": "sympy", + "sha256": "1f70425f0ff5028489d16f29498985e9cf6a4db59291d5eed058bd9500a3f598", + "size": 10773776, + "subdir": "linux-64", + "timestamp": 1578428423508, + "version": "1.5.1" + }, + "sympy-1.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "db287bbb3c75472f65e009abef0b61a6", + "name": "sympy", + "sha256": "e7d45a2246be0d9d8c3ed108434eb60d8cfc8590b7f005c31a082b10308cddcf", + "size": 10729283, + "subdir": "linux-64", + "timestamp": 1578428405273, + "version": "1.5.1" + }, + "sympy-1.5.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "774038e90593896513bf6003e04e7e90", + "name": "sympy", + "sha256": "b0f248bc6f0c0ed8b196231c1551584c51cacb5938d47e9c986dcc3522727b9c", + "size": 10782497, + "subdir": "linux-64", + "timestamp": 1578428427254, + "version": "1.5.1" + }, + "sympy-1.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "mpmath >=0.19", + "python >=3.6,<3.7.0a0", + "fastcache", + "gmpy2 >=2.0.8" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "223ab19dca4f103ff6abc5c35d4021cb", + "name": "sympy", + "sha256": "21d8c610df67578526db4db25e987e3dba497897e8850af51f6f4f0ed8a238e8", + "size": 11079207, + "subdir": "linux-64", + "timestamp": 1592279613271, + "version": "1.6" + }, + "sympy-1.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "mpmath >=0.19", + "python >=3.7,<3.8.0a0", + "fastcache", + "gmpy2 >=2.0.8" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38966a3941d1cad9aa0d2890cdb7af2c", + "name": "sympy", + "sha256": "be03a5902160f75fd4a7b8c10025ed6d39a260f72a7174d177ced990b99823ec", + "size": 11060576, + "subdir": "linux-64", + "timestamp": 1592279571595, + "version": "1.6" + }, + "sympy-1.6-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "mpmath >=0.19", + "python >=3.8,<3.9.0a0", + "fastcache", + "gmpy2 >=2.0.8" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5e59246978578ca43c5d8b4a9d893633", + "name": "sympy", + "sha256": "4c7f5ceaeac83ce20af8e15dfd807591d806a583583ab63d49a48f0a838f1168", + "size": 11092523, + "subdir": "linux-64", + "timestamp": 1592279573280, + "version": "1.6" + }, + "sympy-1.6.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "mpmath >=0.19", + "python >=3.6,<3.7.0a0", + "fastcache", + "gmpy2 >=2.0.8" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "72d4454a4edf96e994a0f5de9b80c3bf", + "name": "sympy", + "sha256": "b10b0da75774e9f18c46d5086632c9ae101f59c1cc018d872521aad4f38f879e", + "size": 11100227, + "subdir": "linux-64", + "timestamp": 1594236616743, + "version": "1.6.1" + }, + "sympy-1.6.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "mpmath >=0.19", + "python >=3.7,<3.8.0a0", + "fastcache", + "gmpy2 >=2.0.8" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8d5c2ab8be3ff7678b417f1db71ceb87", + "name": "sympy", + "sha256": "413b585c96d8158b3683a8ae512a68476d810caa5aeaf6b36dfc25b3d087b3ee", + "size": 11063278, + "subdir": "linux-64", + "timestamp": 1594236601614, + "version": "1.6.1" + }, + "sympy-1.6.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "mpmath >=0.19", + "python >=3.8,<3.9.0a0", + "fastcache", + "gmpy2 >=2.0.8" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "842fe8d9eb67939ddd20640964037852", + "name": "sympy", + "sha256": "813044a9e8927ef6eb3e602c1950f0e271249affdf8447821c6c843dbaa8fb9b", + "size": 11113420, + "subdir": "linux-64", + "timestamp": 1594236604040, + "version": "1.6.1" + }, + "sympy-1.6.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d895cff3fabd5b0b373595e753a2f03", + "name": "sympy", + "sha256": "6cdfe0df5317b7e8cbf552d285ff36c69cb8e9c299af3f54149cee7c44451547", + "size": 11096659, + "subdir": "linux-64", + "timestamp": 1598376402443, + "version": "1.6.2" + }, + "sympy-1.6.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9d5a82f5aca819bb94fb37c126f35208", + "name": "sympy", + "sha256": "40a844066a0042b6343f94c45d2e47802a3b712fd0f3141b2288524b283ca0a7", + "size": 11095858, + "subdir": "linux-64", + "timestamp": 1605119629383, + "version": "1.6.2" + }, + "sympy-1.6.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "mpmath >=0.19", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "96722a706449ab848ab43de0b8f89547", + "name": "sympy", + "sha256": "88e2b14f505944df74072c981bf68c2ed8409436f12b6eec80b1fa5b5c1f768c", + "size": 11052293, + "subdir": "linux-64", + "timestamp": 1597083201738, + "version": "1.6.2" + }, + "sympy-1.6.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c803897460e094e601a12f7cd5d66998", + "name": "sympy", + "sha256": "c2db13aee02b51fbd1093bf96df5c9f7b19753eaf7896bf2b22b41e7bad2ba93", + "size": 11067260, + "subdir": "linux-64", + "timestamp": 1605119589194, + "version": "1.6.2" + }, + "sympy-1.6.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cb72e3d73ead429f40ecd2f014ce5953", + "name": "sympy", + "sha256": "8697fa3bdc50de70e67c209799f936b5627e01748a66d44e8707f49a0a701d64", + "size": 11103821, + "subdir": "linux-64", + "timestamp": 1598376392699, + "version": "1.6.2" + }, + "sympy-1.6.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4194417fa602547052cb24ac2a74bac6", + "name": "sympy", + "sha256": "56364aeb6d053acee56f3c217823b015738a51087cf0f25f1f0e1f1c3661f98c", + "size": 11093471, + "subdir": "linux-64", + "timestamp": 1605119603831, + "version": "1.6.2" + }, + "sympy-1.6.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d61e3f8f8072344c92799ebc05a11ae4", + "name": "sympy", + "sha256": "32f44c43d137df9413a0ac792752907dcc2e9c24519c8c44bccb415c2bf123c6", + "size": 11084202, + "subdir": "linux-64", + "timestamp": 1607722764172, + "version": "1.6.2" + }, + "sympy-1.7.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "18aa800040973f71a9f2f995cdaf694a", + "name": "sympy", + "sha256": "736a5bf71a8ef8aab99b5e451facee3ceead41079256d2b066eb341ad0b360a0", + "size": 11435318, + "subdir": "linux-64", + "timestamp": 1608137749688, + "version": "1.7.1" + }, + "sympy-1.7.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "67923b4e55cb745af7ab04e616b7fabf", + "name": "sympy", + "sha256": "25a080adb769251d886216b458de5de169b5de19a37ec163eedad98be28bc137", + "size": 11393658, + "subdir": "linux-64", + "timestamp": 1608137712477, + "version": "1.7.1" + }, + "sympy-1.7.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d9052a7b307ba0ce25c6ab8a45826d69", + "name": "sympy", + "sha256": "f1cd83905d9e626172e6c91456650243ae75b561167995a98434dfdc78ceffcd", + "size": 11441219, + "subdir": "linux-64", + "timestamp": 1608137748509, + "version": "1.7.1" + }, + "sympy-1.7.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8721a0fc4ad49509845fece0e2856266", + "name": "sympy", + "sha256": "aa0c688b6d283e4e2d62c04acb45345cc6e0f51303b88d69bdfbab3c304e4b54", + "size": 11391604, + "subdir": "linux-64", + "timestamp": 1608137766028, + "version": "1.7.1" + }, + "sympy-1.8-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d8767599aa0c9e9e89976469e7ab27a3", + "name": "sympy", + "sha256": "14aee73fde86c7ba61a116c8c5c77edaa4896a0c67f0457cea6e73e10f0bf09c", + "size": 11716698, + "subdir": "linux-64", + "timestamp": 1618255389252, + "version": "1.8" + }, + "sympy-1.8-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d0c2008957ef77792809e286aceca1e", + "name": "sympy", + "sha256": "63e4daa85f32cef3dd626256e4a628a6e9ecda832f814fa6146298729b4eaa9b", + "size": 11659670, + "subdir": "linux-64", + "timestamp": 1618255380495, + "version": "1.8" + }, + "sympy-1.8-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "736670fcd2a177a4aa2b42bc8dba0dcb", + "name": "sympy", + "sha256": "0324b91290745f5efcfe1c6f33b07f53339a3df4d0f9b45796027f55495bb62b", + "size": 11692335, + "subdir": "linux-64", + "timestamp": 1618252350546, + "version": "1.8" + }, + "sympy-1.8-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c54c0d9d2d67258e6fb04d4a478b55fb", + "name": "sympy", + "sha256": "cd5850497eab7178110be8c7d6c89665693cb0ff2f1c352f2f4a1d6fe09a4b42", + "size": 11664031, + "subdir": "linux-64", + "timestamp": 1618255386428, + "version": "1.8" + }, + "sympy-1.9-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "843aa48d2d6de0b5defc697d229eb1fa", + "name": "sympy", + "sha256": "cf410e96712bc31f025e55028828d5608bb0202202df49882610848cb5c22cc5", + "size": 12032029, + "subdir": "linux-64", + "timestamp": 1640810972256, + "version": "1.9" + }, + "sympy-1.9-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3dfbd4d6a58592d3dfb050247da36a23", + "name": "sympy", + "sha256": "eff099078704c688bccabf1c8c0d68a9c56f59e19c781701c4326c1029251a64", + "size": 11937995, + "subdir": "linux-64", + "timestamp": 1635225510424, + "version": "1.9" + }, + "sympy-1.9-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "360db25180d037dbfd5df26e86ecc413", + "name": "sympy", + "sha256": "f673e5cad8bb9c0999717c2fbb7e244887e9094e65e6b681682a892fe02af7c8", + "size": 12004839, + "subdir": "linux-64", + "timestamp": 1635237122353, + "version": "1.9" + }, + "sympy-1.9-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fe4eb6b381b828ab5bb19ba28eda983c", + "name": "sympy", + "sha256": "265062721491b0424efab52f6fa5c3ea1991423c5615dcbf52eb03b2e4916ce1", + "size": 11962173, + "subdir": "linux-64", + "timestamp": 1635237134113, + "version": "1.9" + }, + "tabpy-client-0.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64ffbe2ef5c366a7d97d8be44c7c29c4", + "name": "tabpy-client", + "sha256": "1f56f6423ebd4f4ac15ee6dc1832cb780de41d4285944fb9c1ffd3f7dff74d06", + "size": 26176, + "subdir": "linux-64", + "timestamp": 1537832451124, + "version": "0.2" + }, + "tabpy-client-0.2-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85d0f7770dbbc522a0a38cc0102be64e", + "name": "tabpy-client", + "sha256": "17cd90cf3f86bc299b32bd929fb26e6fd4a74ef18885384c664dbbb08b06588e", + "size": 27759, + "subdir": "linux-64", + "timestamp": 1640811001676, + "version": "0.2" + }, + "tabpy-client-0.2-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1a76061e925d3fc55f4290e3b98ea49", + "name": "tabpy-client", + "sha256": "90e6426f9929af0222c5ea339336b9754bc5ef312076fb6cd75c75a306762390", + "size": 26985, + "subdir": "linux-64", + "timestamp": 1537832464402, + "version": "0.2" + }, + "tabpy-client-0.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ad72e0ff1d3b4b6045ef068f1af1e3c", + "name": "tabpy-client", + "sha256": "881fb6f79fa655cc42756c9a84fb8a4f8724e1790972e621ba204b4421bb00c6", + "size": 26954, + "subdir": "linux-64", + "timestamp": 1537832462617, + "version": "0.2" + }, + "tabpy-client-0.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "328e034f962f299941e6dcfb371b2712", + "name": "tabpy-client", + "sha256": "2beef295784beead542bdc3d3510fecc40ff4a03fa93be1a957ee370f54f086a", + "size": 250268, + "subdir": "linux-64", + "timestamp": 1613651359697, + "version": "0.2" + }, + "tabpy-client-0.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "78b7b3981af7b0c3552bb6ad116f586d", + "name": "tabpy-client", + "sha256": "777f210e8df244e6675cc33ed306f79f40f63bee3bd42618d83e1fa47490c555", + "size": 26986, + "subdir": "linux-64", + "timestamp": 1537832426119, + "version": "0.2" + }, + "tabpy-client-0.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e0f6f5ee8790cbbd7b06edae31ecf76", + "name": "tabpy-client", + "sha256": "0dcd4915ef6c28a9b5baf6a6b150f82f41eff33397669bc686621881ed7e9895", + "size": 246764, + "subdir": "linux-64", + "timestamp": 1613652070497, + "version": "0.2" + }, + "tabpy-client-0.2-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b3ac329f5a28a142800c53ded980734", + "name": "tabpy-client", + "sha256": "9897f1613bfb11ae75b6542f4da144de95d686335a19cc1a0effd3142c54ee62", + "size": 27479, + "subdir": "linux-64", + "timestamp": 1574237980346, + "version": "0.2" + }, + "tabpy-client-0.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bac17c1008cd2eab83106e6cbd3f1518", + "name": "tabpy-client", + "sha256": "7a87e14c1e4c837a8548fecbb8f30d90a08bec52abd5714f1ca5b341de9ec36b", + "size": 247673, + "subdir": "linux-64", + "timestamp": 1613652073607, + "version": "0.2" + }, + "tabpy-client-0.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a484f579429e27cbfc2a9b6ae2162b4", + "name": "tabpy-client", + "sha256": "05c135d029f6006d1643bb56a525fee9fe331789cc49904503309084127fb5e8", + "size": 247590, + "subdir": "linux-64", + "timestamp": 1613651724398, + "version": "0.2" + }, + "tabpy-server-0.2-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "futures", + "genson", + "jsonschema", + "numpy", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests", + "simplejson", + "tabpy-client", + "tornado", + "tornado-json" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ad37ecdb014f3df3bfb041cc0c6af40", + "name": "tabpy-server", + "sha256": "53dcb3db3b8f45fac4bc7699d4403c953d762a121426365b1f73d90535d8943b", + "size": 64133, + "subdir": "linux-64", + "timestamp": 1537888632581, + "version": "0.2" + }, + "tabpy-server-0.2-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "numpy", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "requests", + "simplejson", + "tabpy-client", + "tornado", + "tornado-json" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e3a2d99ad37bbe7fbc0f0baa5cde8997", + "name": "tabpy-server", + "sha256": "2f59a15e8493b72d585b9cd59e98ec4197ca98ab16288dc4a9ad82eef8d1e37a", + "size": 65762, + "subdir": "linux-64", + "timestamp": 1640813035392, + "version": "0.2" + }, + "tabpy-server-0.2-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "numpy", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "requests", + "simplejson", + "tabpy-client", + "tornado", + "tornado-json" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4e7dc85d999231f0a10067388d7405f", + "name": "tabpy-server", + "sha256": "9d466354cbc6bd4ef2f42ae6c441a1d98c5328642d6bd43188e03b0accd821b6", + "size": 65028, + "subdir": "linux-64", + "timestamp": 1537888653936, + "version": "0.2" + }, + "tabpy-server-0.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "numpy", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests", + "simplejson", + "tabpy-client", + "tornado", + "tornado-json" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "09dec0c74caf6356fe9298a4fae478ee", + "name": "tabpy-server", + "sha256": "55e2fd1866a143e3dfb3d1250684ce5f5472885e8401a38505db0b7b1cfcc456", + "size": 64886, + "subdir": "linux-64", + "timestamp": 1537888682096, + "version": "0.2" + }, + "tabpy-server-0.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "numpy", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests", + "simplejson", + "tabpy-client", + "tornado", + "tornado-json" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "28086cba4b39d9824c42d1b2035a0a60", + "name": "tabpy-server", + "sha256": "f3228f1bd9a3d0ed08d660cc253996bad14048fd37540a05704aeee7fcd9756b", + "size": 290301, + "subdir": "linux-64", + "timestamp": 1614065506490, + "version": "0.2" + }, + "tabpy-server-0.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "numpy", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests", + "simplejson", + "tabpy-client", + "tornado", + "tornado-json" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a72508ba37e9cb413e75b22cccee7b88", + "name": "tabpy-server", + "sha256": "0827d60887ab969a6b4c0bc2fb784f4b5f3cd7f72c0829956878c58d142d62cf", + "size": 64901, + "subdir": "linux-64", + "timestamp": 1537888599473, + "version": "0.2" + }, + "tabpy-server-0.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "numpy", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests", + "simplejson", + "tabpy-client", + "tornado", + "tornado-json" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "afa459bf8a9f7930522dc723675ad1a2", + "name": "tabpy-server", + "sha256": "88fb32f5c44adf83c839e7b0bbb79740ac38e028c0cc032008337d9798bfa570", + "size": 290841, + "subdir": "linux-64", + "timestamp": 1614066107414, + "version": "0.2" + }, + "tabpy-server-0.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "numpy", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests", + "simplejson", + "tabpy-client", + "tornado", + "tornado-json" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18f684de7c44104537e8fabed9d720a3", + "name": "tabpy-server", + "sha256": "b0d3e00d7a3793cff91c18c223f7293816caba3ae691c74e8f37e3f3886ab8bb", + "size": 290745, + "subdir": "linux-64", + "timestamp": 1614066111834, + "version": "0.2" + }, + "tabpy-server-0.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "numpy", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests", + "simplejson", + "tabpy-client", + "tornado", + "tornado-json" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f03d2a7079af42fb7ab4880d5dba9993", + "name": "tabpy-server", + "sha256": "5333e849fccfb38e1bef39fc7ebb74388eb2ecf46ee9f8bf7169b434202e9f3a", + "size": 286567, + "subdir": "linux-64", + "timestamp": 1614065206782, + "version": "0.2" + }, + "tabula-py-2.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "distro", + "numpy", + "openjdk >=8", + "pandas >=0.25.3", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dfc14b1434c04671b858fb0cc700b681", + "name": "tabula-py", + "sha256": "227bfeaab782ab7252c3c9baaa0ea12a1db2ad15aaa42fb9cf7b13109eda6448", + "size": 12062508, + "subdir": "linux-64", + "timestamp": 1640794975832, + "version": "2.3.0" + }, + "tabula-py-2.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "distro", + "numpy", + "openjdk >=8", + "pandas >=0.25.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eedf328613485f05bf53b6ff9d2c6db4", + "name": "tabula-py", + "sha256": "d4817f004d599dfc3a67f0a90fa09aba58a4a6b1c05eff04f2993e1c3852c4fd", + "size": 12064905, + "subdir": "linux-64", + "timestamp": 1637055835338, + "version": "2.3.0" + }, + "tabula-py-2.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "distro", + "numpy", + "openjdk >=8", + "pandas >=0.25.3", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b897ade9333d82143caf29bd121e9c8", + "name": "tabula-py", + "sha256": "8b205b7275b0bc234e44ef52d4ac6319eccfcf6a3ddce48911be94dbf7e42a1d", + "size": 12069623, + "subdir": "linux-64", + "timestamp": 1637055562985, + "version": "2.3.0" + }, + "tabula-py-2.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "distro", + "numpy", + "openjdk >=8", + "pandas >=0.25.3", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9263195637873a26fe90589a8643f1fb", + "name": "tabula-py", + "sha256": "de4c8952838f7c898b9285ec5fb4a36d84720d60b23adf0a2e70328815482fb6", + "size": 12070752, + "subdir": "linux-64", + "timestamp": 1637055829916, + "version": "2.3.0" + }, + "tabula-py-2.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "distro", + "numpy", + "openjdk >=8", + "pandas >=0.25.3", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da953cbbbdef90af82635e249d343464", + "name": "tabula-py", + "sha256": "c4553de8fe568150285e945d6fdbb988a1160bbc6e9cf007c1b9d72557c26f84", + "size": 12070340, + "subdir": "linux-64", + "timestamp": 1676300715941, + "version": "2.6.0" + }, + "tabula-py-2.6.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "distro", + "numpy", + "openjdk >=8", + "pandas >=0.25.3", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "10d843c4f9ae1f69e41329cd5bfcaf3d", + "name": "tabula-py", + "sha256": "216ff4bff643a953897eff86af6f958663ac7a6c0428aa5e71791d31486c5231", + "size": 12077650, + "subdir": "linux-64", + "timestamp": 1676862843214, + "version": "2.6.0" + }, + "tabula-py-2.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "distro", + "numpy", + "openjdk >=8", + "pandas >=0.25.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8354f1ed0815a37d44bf0990af58e97", + "name": "tabula-py", + "sha256": "7b2c61c5f779ad868fae46990730a96802057fea5b6923c307a9441aa594668e", + "size": 12068833, + "subdir": "linux-64", + "timestamp": 1676300659455, + "version": "2.6.0" + }, + "tabula-py-2.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "distro", + "numpy", + "openjdk >=8", + "pandas >=0.25.3", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "53cd6d78d0c088affec35bb275c4463e", + "name": "tabula-py", + "sha256": "80d15b5e2319101a403688c6a0e55d3a04ed97f296cffdcb35cfc2541ab3231e", + "size": 12069867, + "subdir": "linux-64", + "timestamp": 1676300764980, + "version": "2.6.0" + }, + "tabula-py-2.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "distro", + "numpy", + "openjdk >=8", + "pandas >=0.25.3", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ba440544e2672c11ce2104ff34486b8", + "name": "tabula-py", + "sha256": "eb0b96e8aac5d8abc942a3eeb3add363afbe614049fe55a17ee180e4379e7862", + "size": 12069520, + "subdir": "linux-64", + "timestamp": 1676300815594, + "version": "2.6.0" + }, + "tabulate-0.8.10-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb1f14f39083d15c5a02ca5c390b99cd", + "name": "tabulate", + "sha256": "ab6de29383610a32b7f34e6b4086ba9988a8fce5bdde31241a752bd7fc87f6cc", + "size": 46972, + "subdir": "linux-64", + "timestamp": 1657784147376, + "version": "0.8.10" + }, + "tabulate-0.8.10-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b499421f71d64e5df1eb67af7105e459", + "name": "tabulate", + "sha256": "a657e312cf100fa78820bb0c986b4e461dc9e047e4e5381eef9cd7321adaeec1", + "size": 59592, + "subdir": "linux-64", + "timestamp": 1676838842645, + "version": "0.8.10" + }, + "tabulate-0.8.10-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "78770e54894c6c0e70c7291a86979e5c", + "name": "tabulate", + "sha256": "9bd07e828255f06b4318d32348dc0fca6bb3ada1aa777c461fb24af669351c36", + "size": 46378, + "subdir": "linux-64", + "timestamp": 1657784201643, + "version": "0.8.10" + }, + "tabulate-0.8.10-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b341c01eff2e8874854ad85150eedca2", + "name": "tabulate", + "sha256": "e43d3b5f19b9a785ec2da73ffad378861b121f3c36ff433ce7db9e322fdef334", + "size": 46572, + "subdir": "linux-64", + "timestamp": 1657784228264, + "version": "0.8.10" + }, + "tabulate-0.8.10-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33d3a83b1e2019d026cc1dd76a23b10d", + "name": "tabulate", + "sha256": "8ad9dbd5fda7380dcf078fb26e2b97fbd9815843f185afc0a7a443ff7afd2d24", + "size": 46578, + "subdir": "linux-64", + "timestamp": 1657784174556, + "version": "0.8.10" + }, + "tabulate-0.8.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f39d026b53427800b4995c564f7721a9", + "name": "tabulate", + "sha256": "958036393131e584a8a8111deefae932cc4571896fe778f6b4a83c52f61fbffe", + "size": 36864, + "subdir": "linux-64", + "timestamp": 1519407100818, + "version": "0.8.2" + }, + "tabulate-0.8.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a946ccbe8f433dd86f8eec0dcb4f7958", + "name": "tabulate", + "sha256": "6b2a7b3d524d1634d3c8c05f9d5ba968ce85e82ae61854515a25ab3bf20a4ce7", + "size": 37664, + "subdir": "linux-64", + "timestamp": 1519408332707, + "version": "0.8.2" + }, + "tabulate-0.8.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d290a8b2cac595d0220112c962b4e676", + "name": "tabulate", + "sha256": "3a20d5f7996356bd28061fd3ee02b2de2eebfd05aa8f3cfcb9e18ca157de5fe0", + "size": 37476, + "subdir": "linux-64", + "timestamp": 1519407047391, + "version": "0.8.2" + }, + "tabulate-0.8.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af4eb7c2e49676cc5b84acafaf67191a", + "name": "tabulate", + "sha256": "71cdf5f67f5f8ed150828bbc8c4dba1c4a25e89733f59d7dec55c835146d9146", + "size": 37344, + "subdir": "linux-64", + "timestamp": 1531060188132, + "version": "0.8.2" + }, + "tabulate-0.8.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1c4a7eff17117ea7b1590257effae26", + "name": "tabulate", + "sha256": "0a968fcdef60021a9ae84558e7bfdb88e468fe7c74d8536f0e7c30b538ca70b5", + "size": 38954, + "subdir": "linux-64", + "timestamp": 1552401390517, + "version": "0.8.3" + }, + "tabulate-0.8.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1cc6f656cc4272b3695d87e6a568eb90", + "name": "tabulate", + "sha256": "44d8600138a87c3f6afa4f310ad81a86849a0f084dd8df386f231f2eee880a08", + "size": 39636, + "subdir": "linux-64", + "timestamp": 1552401901875, + "version": "0.8.3" + }, + "tabulate-0.8.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3ca4bce5d595a8b4ab36c4b1f0a19c2", + "name": "tabulate", + "sha256": "f5ee5c3df0563adfd48567f82f9f59359ff4b7f005e1e0054de2a83a8f09975f", + "size": 39497, + "subdir": "linux-64", + "timestamp": 1552403483671, + "version": "0.8.3" + }, + "tabulate-0.8.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c688dbe52c13fb07610a66233646698", + "name": "tabulate", + "sha256": "2acd66bc77b3dfff14a63926c1a08f71c563866204eede400543c27bc9201308", + "size": 38156, + "subdir": "linux-64", + "timestamp": 1573661828687, + "version": "0.8.3" + }, + "tabulate-0.8.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22b62a18d068a6f3404d14210d80d973", + "name": "tabulate", + "sha256": "727a29649374a7914fa663449239611d850ba6fe9dbea0c6902deeb972b87228", + "size": 40703, + "subdir": "linux-64", + "timestamp": 1597430392099, + "version": "0.8.7" + }, + "tabulate-0.8.7-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a155035c726f00459d7ef998dc12af95", + "name": "tabulate", + "sha256": "7ae3c5772beb35c5c7df35173f928c324d42bb34d017d8e0f96ed4f1c7d2a7e9", + "size": 40761, + "subdir": "linux-64", + "timestamp": 1613564221131, + "version": "0.8.7" + }, + "tabulate-0.8.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c068df66500fa0f40ffb3797c8487921", + "name": "tabulate", + "sha256": "f06351f24de94728eb9a3a017a6e3eceb2a8ce2541ab5bfbd3f1d478e2ca8827", + "size": 40622, + "subdir": "linux-64", + "timestamp": 1597430386791, + "version": "0.8.7" + }, + "tabulate-0.8.7-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e851ee38d554b1693a94edd03bee8b8c", + "name": "tabulate", + "sha256": "e53f5aff3dec08d30eac72c3e8efe9bb0b1d0502930f5dcba816f7a89a162190", + "size": 40743, + "subdir": "linux-64", + "timestamp": 1613564890570, + "version": "0.8.7" + }, + "tabulate-0.8.7-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd137823deaa2e65257c0a2a8bc5375c", + "name": "tabulate", + "sha256": "280c5ffed8df12f23fca9af5d5be94cb3114b36255fd4263d89ad0e3c5626d11", + "size": 40910, + "subdir": "linux-64", + "timestamp": 1597430382968, + "version": "0.8.7" + }, + "tabulate-0.8.7-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "29c7a0f55642d8edea27cc258c7e5e72", + "name": "tabulate", + "sha256": "e123d14c4e1b69ae99cb4c8e4ee34f8e83243126d1b5dc827b484cf92a58bcea", + "size": 41042, + "subdir": "linux-64", + "timestamp": 1613564889286, + "version": "0.8.7" + }, + "tabulate-0.8.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f07dacd060d542b55855603da96c3ba3", + "name": "tabulate", + "sha256": "3939d8e8b40bf0f1b98a7f8d72b67ec2ec40b20ede5165fce408aad476a1374a", + "size": 40951, + "subdir": "linux-64", + "timestamp": 1613564888697, + "version": "0.8.7" + }, + "tabulate-0.8.9-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee20c3e13ebc63ab7651a5b0febce926", + "name": "tabulate", + "sha256": "e5ca9311a879c88e76b40c0210c4ea5b0f1885488414301e69a04a485ffe830a", + "size": 40545, + "subdir": "linux-64", + "timestamp": 1640794997450, + "version": "0.8.9" + }, + "tabulate-0.8.9-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2427a378f114a9199323c0bacae913c6", + "name": "tabulate", + "sha256": "440603a67c19a9353989acb824a7086e0b7456031be1289280378d5e657522c6", + "size": 40334, + "subdir": "linux-64", + "timestamp": 1614028904974, + "version": "0.8.9" + }, + "tabulate-0.8.9-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83d96fae15c89dd51947baaad1be3391", + "name": "tabulate", + "sha256": "dbedd203c99bc62b58043516725aa52d9508f17424e84691cd6bb51692983170", + "size": 40291, + "subdir": "linux-64", + "timestamp": 1614029746441, + "version": "0.8.9" + }, + "tabulate-0.8.9-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9913a0f57f6e7b9b29aa5e235b42746c", + "name": "tabulate", + "sha256": "665002e3b28034bca5575b9f582bb7b160af5af94a483869cf9e9a2593f5e96d", + "size": 40532, + "subdir": "linux-64", + "timestamp": 1614029801868, + "version": "0.8.9" + }, + "tabulate-0.8.9-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c74cba02853885575c95870878b55017", + "name": "tabulate", + "sha256": "e83ea3ec793790e89aad410e4620465bdd48e578ed3b6ee0427013d0ad3c330d", + "size": 40506, + "subdir": "linux-64", + "timestamp": 1614029810339, + "version": "0.8.9" + }, + "tangled-up-in-unicode-0.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "9ec8a008d5f71a319dd9074fd05f4569", + "name": "tangled-up-in-unicode", + "sha256": "f00a91c09ad71f8a50698675a35877281373ed5e359c958963d64458be35c5e1", + "size": 10537835, + "subdir": "linux-64", + "timestamp": 1668545409400, + "version": "0.2.0" + }, + "tangled-up-in-unicode-0.2.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "4a936fb5e4d7a73f104475b9a112eec3", + "name": "tangled-up-in-unicode", + "sha256": "96fca4645606e8fbf9140f2dd47d7b65228028b9cc5c4264b84fc3fce341e788", + "size": 10383518, + "subdir": "linux-64", + "timestamp": 1676842938740, + "version": "0.2.0" + }, + "tangled-up-in-unicode-0.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "08feab16992d3d098f57ad0da0edc520", + "name": "tangled-up-in-unicode", + "sha256": "21ae6fdfc89a0686f92bb50fa1251c2b19bcfa58269768b597ad9d9fdc9274bf", + "size": 5269392, + "subdir": "linux-64", + "timestamp": 1668546017173, + "version": "0.2.0" + }, + "tangled-up-in-unicode-0.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "2a1e784e10f7303b1c898749d30370b9", + "name": "tangled-up-in-unicode", + "sha256": "e1392c17e40ce419ed8e73ca0fe209b11769aa90b0299c7ab2eeaa9a4d6bcd68", + "size": 5289284, + "subdir": "linux-64", + "timestamp": 1668545273901, + "version": "0.2.0" + }, + "tangled-up-in-unicode-0.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "26a4b4d9a0684ddbbe1bfd75880ceb99", + "name": "tangled-up-in-unicode", + "sha256": "ff0751b0c06ab8284dd54a83949eb0ffa8b581f8459b5ecd602334eca1b36884", + "size": 5290798, + "subdir": "linux-64", + "timestamp": 1668545328152, + "version": "0.2.0" + }, + "tapi-1100.0.11-h039ab34_1.tar.bz2": { + "build": "h039ab34_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "NCSA", + "license_family": "MIT", + "md5": "849d68171674cd41276d81444d800ad3", + "name": "tapi", + "sha256": "30f32fecc46435f90ccf672a2f73f9fb133ac63096235fc923c237052977fb3b", + "size": 1293223, + "subdir": "linux-64", + "timestamp": 1662380929878, + "version": "1100.0.11" + }, + "tbb-2018.0.2-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "md5": "8debe84195c1627d71f99023c2108f71", + "name": "tbb", + "sha256": "ba1ce48b37bb73d8ff6c1e7bb723a4954d140b8a068735c839a5f686d35ba966", + "size": 425011, + "subdir": "linux-64", + "timestamp": 1521147527749, + "version": "2018.0.2" + }, + "tbb-2018.0.4-h6bb024c_1.tar.bz2": { + "build": "h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "md5": "5548e199b20be12fc7b7c4087ce590b8", + "name": "tbb", + "sha256": "6718ee1eea79d5ad5fea28e4c0033fe7da6ed017c4b73ed78ae854cf05810971", + "size": 1353520, + "subdir": "linux-64", + "timestamp": 1528735288511, + "version": "2018.0.4" + }, + "tbb-2018.0.5-h6bb024c_0.tar.bz2": { + "build": "h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "md5": "fd6a9046969f45e5a6589475b5a6d6b7", + "name": "tbb", + "sha256": "7182b3ce3c4d08186342cac117c032c5ef061830840dbb352d1f3d50d17a77d1", + "size": 1464957, + "subdir": "linux-64", + "timestamp": 1535203813841, + "version": "2018.0.5" + }, + "tbb-2019.0-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "md5": "31df468cb2c1b32959b5399edf5abfbd", + "name": "tbb", + "sha256": "d40b63c2cbcc6cea7409103e3e38a983f4f479186c2e16198c44ecf7c01bf73d", + "size": 1467777, + "subdir": "linux-64", + "timestamp": 1538483576896, + "version": "2019.0" + }, + "tbb-2019.1-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "md5": "9d22394e61bbc50df630e84a13f4fd9c", + "name": "tbb", + "sha256": "088d78f5e7e11fdded2d2dad8e863b73f9e274da70b1e4287210469348ac9544", + "size": 1463064, + "subdir": "linux-64", + "timestamp": 1539116540571, + "version": "2019.1" + }, + "tbb-2019.4-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "md5": "a736e7a81ee26c492cae946d3052d2d8", + "name": "tbb", + "sha256": "26ed060d970e81d77fde41bff0bd9f96c7762e5c59b5b6d47dc657f128cea8d7", + "size": 1469318, + "subdir": "linux-64", + "timestamp": 1552512268103, + "version": "2019.4" + }, + "tbb-2019.8-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "md5": "1ac915b8b1ccd091aeac33c7cd5c3841", + "name": "tbb", + "sha256": "9d2066cc05fe05b3a973140eac2132f9b4b36a8ee8c61bd91d690593578c886f", + "size": 1475405, + "subdir": "linux-64", + "timestamp": 1570736062888, + "version": "2019.8" + }, + "tbb-2020.0-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "md5": "b1141407c77650749af7d1b8b9a2384b", + "name": "tbb", + "sha256": "44aba8995647485338fdc993f1b08644922ade01f5c0ab3243ca5e79db8918fd", + "size": 1484343, + "subdir": "linux-64", + "timestamp": 1580848349460, + "version": "2020.0" + }, + "tbb-2020.1-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "md5": "52348435fbf4c92d9a473b82f8f208df", + "name": "tbb", + "sha256": "5eb95ba39fae1ba4a1ed6c9c05aa91781b387621deb37c1d7a57d7e0d8dd9763", + "size": 1508288, + "subdir": "linux-64", + "timestamp": 1597700578963, + "version": "2020.1" + }, + "tbb-2020.2-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "md5": "43df98a40789df1591c251a0d43d4839", + "name": "tbb", + "sha256": "e85998754fcc9cb312e9eb8138e5a4e13563878303c2a00b7dfefd8befbce146", + "size": 1510868, + "subdir": "linux-64", + "timestamp": 1598284735993, + "version": "2020.2" + }, + "tbb-2020.2-hff7bd54_0.tar.bz2": { + "build": "hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "md5": "d6f66f877b2264e3e6f2d9a03dc3aab7", + "name": "tbb", + "sha256": "955b48be2393f68f21b9d6145fe3009dbc68bcbfc20cde65482a1614535a079c", + "size": 1506941, + "subdir": "linux-64", + "timestamp": 1613159239113, + "version": "2020.2" + }, + "tbb-2020.3-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "md5": "925e0f059d35762aaee4d4ae28c9f6b7", + "name": "tbb", + "sha256": "f10722742d3df2332941f1b41d5f63c52a038bd7135096ddf228b2d886c640bc", + "size": 1499654, + "subdir": "linux-64", + "timestamp": 1600554924591, + "version": "2020.3" + }, + "tbb-2021.2.0-hff7bd54_0.tar.bz2": { + "build": "hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "md5": "86c9c2075fbcb1dc3917e1585190eba4", + "name": "tbb", + "sha256": "05d61d192c85b1bddb6471d6c44a522df9618422533b80d7832b99e2677bea7a", + "size": 205401, + "subdir": "linux-64", + "timestamp": 1618504840266, + "version": "2021.2.0" + }, + "tbb-2021.3.0-hd09550d_0.tar.bz2": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "md5": "b8a1c5d95e20855cde6bd26030ad6da3", + "name": "tbb", + "sha256": "3598c5b41419a647d1ccc29873d19dc794fdc0f66b83cfdbda2b031b26604102", + "size": 211831, + "subdir": "linux-64", + "timestamp": 1626359187729, + "version": "2021.3.0" + }, + "tbb-2021.4.0-hd09550d_0.tar.bz2": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "md5": "8b45e4b33bd07ffedeaffdc862189084", + "name": "tbb", + "sha256": "181819c90eb3a8662901bae5519f76bc5325c8980fe2349adf6a1d35049feba6", + "size": 185087, + "subdir": "linux-64", + "timestamp": 1634724023113, + "version": "2021.4.0" + }, + "tbb-2021.5.0-hd09550d_0.tar.bz2": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "md5": "1decb9dd0e7bcee086d83b8b4ab8c8eb", + "name": "tbb", + "sha256": "d4c0f3e57d8df6042151e65a706f8cd76c9325a47548f4ca3c3516e352dd8ca3", + "size": 171277, + "subdir": "linux-64", + "timestamp": 1641830509786, + "version": "2021.5.0" + }, + "tbb-2021.6.0-hdb19cb5_0.tar.bz2": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "26fe14f621b5fa8c47c1fd3a8449cfea", + "name": "tbb", + "sha256": "634f1191883476c736287e6b36c10c93c127c685284f03c9cc71b0a2360919bc", + "size": 1886040, + "subdir": "linux-64", + "timestamp": 1664812947196, + "version": "2021.6.0" + }, + "tbb-2021.6.0-hdb19cb5_1.tar.bz2": { + "build": "hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "704539c152f0e56336378f153d97b4e3", + "name": "tbb", + "sha256": "ce3f0847a35504239f321cd81cc075b274025838e99444fbf7de00a9736afab7", + "size": 1886306, + "subdir": "linux-64", + "timestamp": 1673966561702, + "version": "2021.6.0" + }, + "tbb-2021.7.0-hdb19cb5_0.tar.bz2": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f0a2efeb023eff7e191e84cb49e856bb", + "name": "tbb", + "sha256": "d8161cc39373b8e9c07930b0586b11ff0bb82b9034b0b9b5ba1101d4a1a9da5f", + "size": 1887661, + "subdir": "linux-64", + "timestamp": 1676908648515, + "version": "2021.7.0" + }, + "tbb-2021.8.0-hdb19cb5_0.tar.bz2": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "041a3caf09dc9ce8fc6c10925c4fe050", + "name": "tbb", + "sha256": "fad05a7c749760b7d18d897a41fa4a00d83d137cdb90a76ddde4ee0b7e07d3ea", + "size": 1888016, + "subdir": "linux-64", + "timestamp": 1680167274961, + "version": "2021.8.0" + }, + "tbb-devel-2018.0.4-h6bb024c_1.tar.bz2": { + "build": "h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "tbb 2018.0.4 h6bb024c_1" + ], + "license": "Apache 2.0", + "md5": "9865bdef5651a6678a48ba74f18a68ec", + "name": "tbb-devel", + "sha256": "bf2db1f241e9b3ae0fe63f543cef33e65d2ee0348afe80576f31cbe2d0ee2390", + "size": 3354994, + "subdir": "linux-64", + "timestamp": 1528735308421, + "version": "2018.0.4" + }, + "tbb-devel-2018.0.5-h6bb024c_0.tar.bz2": { + "build": "h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2018.0.5 h6bb024c_0" + ], + "license": "Apache 2.0", + "md5": "4521b256a4a367302fb823375423d830", + "name": "tbb-devel", + "sha256": "e0c798b92a7909754a08ecff070c4cbf103c313778f845a65efb1a2edee8e529", + "size": 1328688, + "subdir": "linux-64", + "timestamp": 1535203850891, + "version": "2018.0.5" + }, + "tbb-devel-2019.0-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2019.0 hfd86e86_0" + ], + "license": "Apache 2.0", + "md5": "9143cf4a91bf3c2adb42d0479cc5e809", + "name": "tbb-devel", + "sha256": "16fafb3952a9e320778b74ce6fa4f9c128b9344552a7690534546ab8bb3b6fd2", + "size": 4133630, + "subdir": "linux-64", + "timestamp": 1538483589455, + "version": "2019.0" + }, + "tbb-devel-2019.1-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2019.1 hfd86e86_0" + ], + "license": "Apache 2.0", + "md5": "59f5bd1122e9b58175ca64f5f9814f3f", + "name": "tbb-devel", + "sha256": "fb4ed0270cbd50a3c29922dc7284fd343fce2d9158442459bb004bbb1f3414e9", + "size": 4135589, + "subdir": "linux-64", + "timestamp": 1539116559565, + "version": "2019.1" + }, + "tbb-devel-2019.4-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2019.4 hfd86e86_0" + ], + "license": "Apache 2.0", + "md5": "5759168a4da9180ff168c8e8c18ef193", + "name": "tbb-devel", + "sha256": "2f68634bb7b60cf3853f76a18f7f310860f5ec72805b7e3a4795099f57349858", + "size": 4158895, + "subdir": "linux-64", + "timestamp": 1552512283866, + "version": "2019.4" + }, + "tbb-devel-2019.8-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2019.8 hfd86e86_0" + ], + "license": "Apache 2.0", + "md5": "efed5a9869c748d296c07d994ca7ec58", + "name": "tbb-devel", + "sha256": "0d1a29ba23306390e779f22831d037b7d94b0a044042083a5846b81724174b0b", + "size": 4173830, + "subdir": "linux-64", + "timestamp": 1570736094081, + "version": "2019.8" + }, + "tbb-devel-2020.0-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2020.0 hfd86e86_0" + ], + "license": "Apache 2.0", + "md5": "4aa159806ced1914c759a89f9cf6a095", + "name": "tbb-devel", + "sha256": "7960b7614b52e678bf905334ae55a3b6617c63d40b85235c5d782d5dccff354c", + "size": 1437298, + "subdir": "linux-64", + "timestamp": 1580848379029, + "version": "2020.0" + }, + "tbb-devel-2020.1-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2020.1 hfd86e86_0" + ], + "license": "Apache-2.0", + "md5": "9c8fe3d926c4203a526017583ad1d402", + "name": "tbb-devel", + "sha256": "8df21f7a51921b3f1e8287eb2eccc1ec8d0cac207c25bdbb41211454f2521e08", + "size": 1452648, + "subdir": "linux-64", + "timestamp": 1597700593910, + "version": "2020.1" + }, + "tbb-devel-2020.2-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2020.2 hfd86e86_0" + ], + "license": "Apache-2.0", + "md5": "5391acfec6d30494f5971e728d0849f3", + "name": "tbb-devel", + "sha256": "23d856967778faf873968e55a5357f341f2b8dea7f0db3121051d0328c1e3551", + "size": 1464166, + "subdir": "linux-64", + "timestamp": 1598284756020, + "version": "2020.2" + }, + "tbb-devel-2020.2-hff7bd54_0.tar.bz2": { + "build": "hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2020.2 hff7bd54_0" + ], + "license": "Apache-2.0", + "md5": "e9f58364248cf395a5fefa04ba9752bb", + "name": "tbb-devel", + "sha256": "577451fe6fa2a8a3bcc8a8134349415ce7da1d42e5095424bb69c037511546c1", + "size": 1458369, + "subdir": "linux-64", + "timestamp": 1613159260245, + "version": "2020.2" + }, + "tbb-devel-2020.3-hfd86e86_0.tar.bz2": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2020.3 hfd86e86_0" + ], + "license": "Apache-2.0", + "md5": "9d790b0c31e3b3693dd00918fe15fc60", + "name": "tbb-devel", + "sha256": "10f6b2a133b179b650827050e87932f77f77b06b0655be4ef687055bbe1a450c", + "size": 1449659, + "subdir": "linux-64", + "timestamp": 1600554943851, + "version": "2020.3" + }, + "tbb-devel-2021.2.0-hff7bd54_0.tar.bz2": { + "build": "hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2021.2.0 hff7bd54_0" + ], + "license": "Apache-2.0", + "md5": "3af73d01f5708fd1c9b5f48270fc9aa3", + "name": "tbb-devel", + "sha256": "f470fe9f725ee1a41a26d55e184ec9112512f15aa130e2f895f2e5b2636c51a3", + "size": 941457, + "subdir": "linux-64", + "timestamp": 1618504851478, + "version": "2021.2.0" + }, + "tbb-devel-2021.3.0-hd09550d_0.tar.bz2": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "tbb 2021.3.0 hd09550d_0" + ], + "license": "Apache-2.0", + "md5": "545912574994e32c8003143ab0c89762", + "name": "tbb-devel", + "sha256": "49480a701cac62c7f88325a83e29f886cb99a22f562372d847ee369d857f8cac", + "size": 964259, + "subdir": "linux-64", + "timestamp": 1626359202242, + "version": "2021.3.0" + }, + "tbb-devel-2021.4.0-hd09550d_0.tar.bz2": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "tbb 2021.4.0 hd09550d_0" + ], + "license": "Apache-2.0", + "md5": "3efe7a86b45715734ef448009daf7dfb", + "name": "tbb-devel", + "sha256": "6a3672c76c9acbd6d408aa045f73febcd11bfa43d32a05966970e8bbbffdd579", + "size": 987219, + "subdir": "linux-64", + "timestamp": 1634724038507, + "version": "2021.4.0" + }, + "tbb-devel-2021.5.0-hd09550d_0.tar.bz2": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "tbb 2021.5.0 hd09550d_0" + ], + "license": "Apache-2.0", + "md5": "3711425b063d68a9f058379f7e495694", + "name": "tbb-devel", + "sha256": "b350436764ba026fef6302bf6fff7b01be32f708d33ef515584bdfed112238fe", + "size": 991758, + "subdir": "linux-64", + "timestamp": 1641830523313, + "version": "2021.5.0" + }, + "tbb-devel-2021.6.0-hdb19cb5_0.tar.bz2": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.6.0 hdb19cb5_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "36f622152a2c125f261731cfd8320076", + "name": "tbb-devel", + "sha256": "7431692d423848191efed5517bb0ce0103b50a3a754d0e5fe821fc17f0b737a2", + "size": 1119757, + "subdir": "linux-64", + "timestamp": 1664812960756, + "version": "2021.6.0" + }, + "tbb-devel-2021.6.0-hdb19cb5_1.tar.bz2": { + "build": "hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.6.0 hdb19cb5_1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "36b975e6ffdaa4f6578b0fd05b2a3123", + "name": "tbb-devel", + "sha256": "bbf8889263f7130a4bf8de82670b858d0eae444b4b4759e6a05819384231e5d0", + "size": 1119900, + "subdir": "linux-64", + "timestamp": 1673966577121, + "version": "2021.6.0" + }, + "tbb-devel-2021.7.0-hdb19cb5_0.tar.bz2": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.7.0 hdb19cb5_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c49f2e6c5d1fccf1909408831a03cea7", + "name": "tbb-devel", + "sha256": "3fec6d5e87509a7b7137b8d850ea7e4d4a828f655694d8323313bbc9c71355f5", + "size": 1121165, + "subdir": "linux-64", + "timestamp": 1676908663814, + "version": "2021.7.0" + }, + "tbb-devel-2021.8.0-hdb19cb5_0.tar.bz2": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.8.0 hdb19cb5_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "713850f72caf05e0e3a42b484df763c3", + "name": "tbb-devel", + "sha256": "fdeef70124a2794ec5a88bd884e5ce1447aa09e9b20a51b387de75c2dedaf91f", + "size": 1127404, + "subdir": "linux-64", + "timestamp": 1680167284254, + "version": "2021.8.0" + }, + "tbb4py-2018.0.4-py27h6bb024c_1.tar.bz2": { + "build": "py27h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "tbb >=2018.0.4" + ], + "license": "Apache 2.0", + "md5": "a3b79fcd02eb74cae1f3c66fa8cf422d", + "name": "tbb4py", + "sha256": "cf857c9b03aeee46f119476187ca02b47968fa490acd3d17052cbec277547338", + "size": 195456, + "subdir": "linux-64", + "timestamp": 1528735449472, + "version": "2018.0.4" + }, + "tbb4py-2018.0.4-py35h6bb024c_1.tar.bz2": { + "build": "py35h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "tbb >=2018.0.4" + ], + "license": "Apache 2.0", + "md5": "8e76a9861866c396efb7b850b5eacb6c", + "name": "tbb4py", + "sha256": "19e0ff1cb3a42842c384c9384436aafd0bc915150598dda5cdcee7c96d39b518", + "size": 195167, + "subdir": "linux-64", + "timestamp": 1528735408095, + "version": "2018.0.4" + }, + "tbb4py-2018.0.4-py36h6bb024c_1.tar.bz2": { + "build": "py36h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "tbb >=2018.0.4" + ], + "license": "Apache 2.0", + "md5": "0a7e09c2140bce862d670f3b77952a3f", + "name": "tbb4py", + "sha256": "629ea169bbc52ef1b497b5137685df974d60fc91fdc7a17fc6b61555a2a71930", + "size": 194971, + "subdir": "linux-64", + "timestamp": 1528735429374, + "version": "2018.0.4" + }, + "tbb4py-2018.0.5-py27h6bb024c_0.tar.bz2": { + "build": "py27h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "tbb >=2018.0.5" + ], + "license": "Apache 2.0", + "md5": "9bd66ffc1c7f487401fd90f3b1372d7e", + "name": "tbb4py", + "sha256": "abc28def6efff4f9e620f4a3763fd5855e071d05cdb7e42f02bdb64f13db8fea", + "size": 251825, + "subdir": "linux-64", + "timestamp": 1535203950052, + "version": "2018.0.5" + }, + "tbb4py-2018.0.5-py35h6bb024c_0.tar.bz2": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "tbb >=2018.0.5" + ], + "license": "Apache 2.0", + "md5": "5b07b8da55a830d0dc25c9610943dc42", + "name": "tbb4py", + "sha256": "df4668b6649e6a0551a149aa0b5d86f1a0dab8f03fdb5b08447273df320b0c0a", + "size": 251551, + "subdir": "linux-64", + "timestamp": 1535203922588, + "version": "2018.0.5" + }, + "tbb4py-2018.0.5-py36h6bb024c_0.tar.bz2": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2018.0.5" + ], + "license": "Apache 2.0", + "md5": "4b24d30bfdc5bfafdb057ec52205b374", + "name": "tbb4py", + "sha256": "91b16dee458cb70337cb3d136115f3c2c94cc9b7711652350c31a3dd6d6a5b7f", + "size": 251391, + "subdir": "linux-64", + "timestamp": 1535203979367, + "version": "2018.0.5" + }, + "tbb4py-2018.0.5-py37h6bb024c_0.tar.bz2": { + "build": "py37h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2018.0.5" + ], + "license": "Apache 2.0", + "md5": "a858b052f72f362d0aa12ae0b1d5cdd7", + "name": "tbb4py", + "sha256": "604e1e8e863380fcdc548d98a17e23e7642c1233efa7acfcb48edddaa053db1b", + "size": 251438, + "subdir": "linux-64", + "timestamp": 1535203890293, + "version": "2018.0.5" + }, + "tbb4py-2019.0-py27hfd86e86_0.tar.bz2": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "tbb >=2019.0" + ], + "license": "Apache 2.0", + "md5": "9b058eed92f33b35f76d9a4a6c1b2f6e", + "name": "tbb4py", + "sha256": "220aca28836c7b062ba22c391ea533833778c3f8ae04ea31d036e6216e41bb6a", + "size": 251948, + "subdir": "linux-64", + "timestamp": 1538483613853, + "version": "2019.0" + }, + "tbb4py-2019.0-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.0" + ], + "license": "Apache 2.0", + "md5": "c50f099d7421dd2af413ceee72e16b14", + "name": "tbb4py", + "sha256": "a094373078ce553966d0d22aa3dd70351c502b044502869a130d289437101a23", + "size": 251248, + "subdir": "linux-64", + "timestamp": 1538483628171, + "version": "2019.0" + }, + "tbb4py-2019.0-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.0" + ], + "license": "Apache 2.0", + "md5": "fb95a770d90e955def6f9f60dadab572", + "name": "tbb4py", + "sha256": "587b4c736c3fbe36edb87360d8f7a5f44dc5ed2e753329bcd74f2e1ae1778808", + "size": 251432, + "subdir": "linux-64", + "timestamp": 1538483642751, + "version": "2019.0" + }, + "tbb4py-2019.1-py27hfd86e86_0.tar.bz2": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "tbb >=2019.1" + ], + "license": "Apache 2.0", + "md5": "42fe86ed9a2e7c4a2e2551f21e2cbb99", + "name": "tbb4py", + "sha256": "6178cd05b7be570cd43119dceca517606aaeee9025c9bfd2bd7171fc1e8f5a9d", + "size": 247773, + "subdir": "linux-64", + "timestamp": 1539116594522, + "version": "2019.1" + }, + "tbb4py-2019.1-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.1" + ], + "license": "Apache 2.0", + "md5": "e582ce4ea9178741b65d425f0aba2044", + "name": "tbb4py", + "sha256": "bf4eba2b1be38fe6da847fbf2f7c3d1192fcf7aa908df4321554f4c3141c363d", + "size": 247364, + "subdir": "linux-64", + "timestamp": 1539116617950, + "version": "2019.1" + }, + "tbb4py-2019.1-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.1" + ], + "license": "Apache 2.0", + "md5": "ddcf3f31a705318ce0a513596485fe90", + "name": "tbb4py", + "sha256": "b8fcd41b88ee25fdd9da080f95bb612e494858b72790f5dd5ba3d5c205ac20b4", + "size": 247478, + "subdir": "linux-64", + "timestamp": 1539116642564, + "version": "2019.1" + }, + "tbb4py-2019.4-py27hfd86e86_0.tar.bz2": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "tbb >=2019.4" + ], + "license": "Apache 2.0", + "md5": "4662f90c210e1bb520e63640c13ccaaa", + "name": "tbb4py", + "sha256": "e481ed3a77d553ab4e6e301946a124fb11630a077463b9aedfb5bdf6ced6f399", + "size": 255584, + "subdir": "linux-64", + "timestamp": 1552512349863, + "version": "2019.4" + }, + "tbb4py-2019.4-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.4" + ], + "license": "Apache 2.0", + "md5": "3304eaf14b3a68b86a3ddc2c8b5dbc53", + "name": "tbb4py", + "sha256": "f94cc2ced3a5d98340bae7b76a9c081c8ef49035c23f5f9e0f276bff2b4b0895", + "size": 255231, + "subdir": "linux-64", + "timestamp": 1552512313660, + "version": "2019.4" + }, + "tbb4py-2019.4-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.4" + ], + "license": "Apache 2.0", + "md5": "40af24ed12c473bebde9ff989a70e200", + "name": "tbb4py", + "sha256": "8ec5c196987d0ad4b4bb162806a143330ef36b9e8eeb43a6677f2d24c5e1914b", + "size": 255256, + "subdir": "linux-64", + "timestamp": 1552512331323, + "version": "2019.4" + }, + "tbb4py-2019.8-py27hfd86e86_0.tar.bz2": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "tbb >=2019.8" + ], + "license": "Apache 2.0", + "md5": "89998e679b3eeb4f5ee4c89902c36b56", + "name": "tbb4py", + "sha256": "6357307004870eabe9baf166f79302366c1071e1f845226437ea3beac5976a08", + "size": 259602, + "subdir": "linux-64", + "timestamp": 1570736126780, + "version": "2019.8" + }, + "tbb4py-2019.8-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.8" + ], + "license": "Apache 2.0", + "md5": "46863931f45059e9010623eb09e83067", + "name": "tbb4py", + "sha256": "8e7a3961ca9b3360efa9cc31d4fb3439bd6ef68cf97efd09ce9af9aa887a5ec3", + "size": 259374, + "subdir": "linux-64", + "timestamp": 1570736132962, + "version": "2019.8" + }, + "tbb4py-2019.8-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.8" + ], + "license": "Apache 2.0", + "md5": "0f22cfa37aa0f637480e5d041dc572c1", + "name": "tbb4py", + "sha256": "7f6622b37c1b7b2a3135854d073de89c9849021fdd711371173153f5265397e1", + "size": 259380, + "subdir": "linux-64", + "timestamp": 1570736094008, + "version": "2019.8" + }, + "tbb4py-2020.0-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2020.0" + ], + "license": "Apache 2.0", + "md5": "d46e8064a241cd7eabf73a3db7edb84d", + "name": "tbb4py", + "sha256": "a3ef0f22a027d6ecb946a096ce3550c5923acaf6d753c0d1fc2e3e8e4c1d7eb1", + "size": 260271, + "subdir": "linux-64", + "timestamp": 1580848419855, + "version": "2020.0" + }, + "tbb4py-2020.0-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2020.0" + ], + "license": "Apache 2.0", + "md5": "ff1d38fae6d060003a8f99fe6a259ba8", + "name": "tbb4py", + "sha256": "b171e331e26b9a3b37bca715d3ae7d6f0ef0d2a2c87725470171ee9b90afeb3d", + "size": 260287, + "subdir": "linux-64", + "timestamp": 1580848446323, + "version": "2020.0" + }, + "tbb4py-2020.0-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "tbb >=2020.0" + ], + "license": "Apache 2.0", + "md5": "ca35d074f2768a6fc3d5ae1af6624f9e", + "name": "tbb4py", + "sha256": "51d14705e1b09b4b20e1030573e385b9ccab67d272282e7d46939d7e2f7552e4", + "size": 260566, + "subdir": "linux-64", + "timestamp": 1580848473908, + "version": "2020.0" + }, + "tbb4py-2020.1-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2020.1" + ], + "license": "Apache 2.0", + "md5": "e7ea26b22c735f1c66c354bc48161351", + "name": "tbb4py", + "sha256": "28a4136387e68ca4022a493dd570987459224931496f6d194c7f09726d54c4fa", + "size": 259940, + "subdir": "linux-64", + "timestamp": 1597700645893, + "version": "2020.1" + }, + "tbb4py-2020.1-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2020.1" + ], + "license": "Apache 2.0", + "md5": "2e2005286181bd5c2b010990ab18df50", + "name": "tbb4py", + "sha256": "d8a262d983d62574b67c1ad8b562d651b3113817d143a558c768a455475fe575", + "size": 260040, + "subdir": "linux-64", + "timestamp": 1597700617034, + "version": "2020.1" + }, + "tbb4py-2020.1-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "tbb >=2020.1" + ], + "license": "Apache 2.0", + "md5": "e41670e80cb45c0105026f709e06fd25", + "name": "tbb4py", + "sha256": "7ad822e0e2f5526c69c1aa266503d52359fb0938c710835a27fd05c273e82c32", + "size": 260134, + "subdir": "linux-64", + "timestamp": 1597700630436, + "version": "2020.1" + }, + "tbb4py-2020.2-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2020.2" + ], + "license": "Apache 2.0", + "md5": "37fe97c5136181a5f71410dcecd7e0a0", + "name": "tbb4py", + "sha256": "f8de5adab76a351d7516808a387cddc27d63541b4737c0f18ae5382fbbe887f2", + "size": 260112, + "subdir": "linux-64", + "timestamp": 1598284782889, + "version": "2020.2" + }, + "tbb4py-2020.2-py36hff7bd54_0.tar.bz2": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2020.2" + ], + "license": "Apache 2.0", + "md5": "2507b67c1f3700a0c6d1be900adc7b58", + "name": "tbb4py", + "sha256": "27acafbe1d4d63076484f2ab2264d20a60001b3540c50fb02ac378c64a7bd074", + "size": 260536, + "subdir": "linux-64", + "timestamp": 1613159289122, + "version": "2020.2" + }, + "tbb4py-2020.2-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2020.2" + ], + "license": "Apache 2.0", + "md5": "5d27a0b9d933f16a7a88e488b9a87138", + "name": "tbb4py", + "sha256": "f8442bc1d4133c27829185cb6c4356abe620897717ee01e7f264c52d907f36aa", + "size": 260100, + "subdir": "linux-64", + "timestamp": 1598284800246, + "version": "2020.2" + }, + "tbb4py-2020.2-py37hff7bd54_0.tar.bz2": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2020.2" + ], + "license": "Apache 2.0", + "md5": "e2762631e90d81160be071c0297d30f5", + "name": "tbb4py", + "sha256": "4b0d8f2802a915ebcd5eac0071c138b5ea5a1fa16c07a81a7282246da7da1886", + "size": 260672, + "subdir": "linux-64", + "timestamp": 1613159344000, + "version": "2020.2" + }, + "tbb4py-2020.2-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "tbb >=2020.2" + ], + "license": "Apache 2.0", + "md5": "a827e30ab5c640792398ca973f9777bb", + "name": "tbb4py", + "sha256": "fe9e6c2fadc28d42ab31b1f84cfb9a4423fa318e02d3e86ac5d43e2cf2655653", + "size": 260365, + "subdir": "linux-64", + "timestamp": 1598284818051, + "version": "2020.2" + }, + "tbb4py-2020.2-py38hff7bd54_0.tar.bz2": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "tbb >=2020.2" + ], + "license": "Apache 2.0", + "md5": "befcdb1d6e17fef4c7cbd99155c58d59", + "name": "tbb4py", + "sha256": "12b0beb2a51e7a08ae3cdc0902c8ba880c36dd97dcb2d08b61b19ccdaa3e1cd3", + "size": 260937, + "subdir": "linux-64", + "timestamp": 1613159326023, + "version": "2020.2" + }, + "tbb4py-2020.2-py39hff7bd54_0.tar.bz2": { + "build": "py39hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "tbb >=2020.2" + ], + "license": "Apache 2.0", + "md5": "e1b9567b9d31e169d4c3f4c5447d853a", + "name": "tbb4py", + "sha256": "5730445f090abce9398d74007cc7d5e3a3aa627cb010cc32c428095d71051506", + "size": 260871, + "subdir": "linux-64", + "timestamp": 1613159307629, + "version": "2020.2" + }, + "tbb4py-2020.3-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2020.3" + ], + "license": "Apache 2.0", + "md5": "1671a3a2865df87bb3e3e071ebab8583", + "name": "tbb4py", + "sha256": "1f690cf1a71c565ac3a39faca8bb36e16846a5cfb35ad5199cf3278911f205d1", + "size": 251636, + "subdir": "linux-64", + "timestamp": 1600555006031, + "version": "2020.3" + }, + "tbb4py-2020.3-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2020.3" + ], + "license": "Apache 2.0", + "md5": "735fceed7c0b0e4d0a2faf658a09e0da", + "name": "tbb4py", + "sha256": "39e019fbc4156a94eadc97a9bc44333c0c3c7944261cbd622ebcc3fe7b8617cd", + "size": 251664, + "subdir": "linux-64", + "timestamp": 1600554971585, + "version": "2020.3" + }, + "tbb4py-2020.3-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "tbb >=2020.3" + ], + "license": "Apache 2.0", + "md5": "0c383ebb2632d219d55064261bf6fd8b", + "name": "tbb4py", + "sha256": "fe08ca122d4e06ccbd968cbceab8ab9cd4ab7de0ea4e4f2f542617e7ae498534", + "size": 251783, + "subdir": "linux-64", + "timestamp": 1600554989193, + "version": "2020.3" + }, + "tbb4py-2021.2.0-py36hff7bd54_0.tar.bz2": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2021.2.0" + ], + "license": "Apache 2.0", + "md5": "d9b19a650a49938cddff10e272843b43", + "name": "tbb4py", + "sha256": "beb14b2783cb9a3a7b011a74f90b06ceb4d15e6cc3d63810f21227e286f6ae18", + "size": 88964, + "subdir": "linux-64", + "timestamp": 1618504957377, + "version": "2021.2.0" + }, + "tbb4py-2021.2.0-py37hff7bd54_0.tar.bz2": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2021.2.0" + ], + "license": "Apache 2.0", + "md5": "eb9301a2724f6d3ff99d62d6f8edc547", + "name": "tbb4py", + "sha256": "6db42d9a612777d8bb3738fb7b75da05c3794266824f6bd44d47416e35685094", + "size": 88998, + "subdir": "linux-64", + "timestamp": 1618504932051, + "version": "2021.2.0" + }, + "tbb4py-2021.2.0-py38hff7bd54_0.tar.bz2": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "tbb >=2021.2.0" + ], + "license": "Apache 2.0", + "md5": "fadf35186a6e8e67ac82cd207f2ba64d", + "name": "tbb4py", + "sha256": "e8c217e92affa1d136c16e9b79f38441a671fcff6ac1df94d4dd1b35c8035556", + "size": 89391, + "subdir": "linux-64", + "timestamp": 1618504882310, + "version": "2021.2.0" + }, + "tbb4py-2021.2.0-py39hff7bd54_0.tar.bz2": { + "build": "py39hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "tbb >=2021.2.0" + ], + "license": "Apache 2.0", + "md5": "466c986ef92e749df3cf250839ac33a4", + "name": "tbb4py", + "sha256": "16ce316a141de5432614f3d36e591e9cf5df07db395af813e0739940245f77ce", + "size": 89271, + "subdir": "linux-64", + "timestamp": 1618504907879, + "version": "2021.2.0" + }, + "tbb4py-2021.3.0-py36hd09550d_0.tar.bz2": { + "build": "py36hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "tbb >=2021.3.0" + ], + "license": "Apache 2.0", + "md5": "b10f7a73bf9751903bcac8ea9745eb30", + "name": "tbb4py", + "sha256": "92a9907c12bc46efdd06003583be297d8dca06fbbaea2c9b44d2f17a0ae5b84a", + "size": 88611, + "subdir": "linux-64", + "timestamp": 1626359298456, + "version": "2021.3.0" + }, + "tbb4py-2021.3.0-py37hd09550d_0.tar.bz2": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "tbb >=2021.3.0" + ], + "license": "Apache 2.0", + "md5": "5ef47e7fda6f9c13afb84cab8207f805", + "name": "tbb4py", + "sha256": "73e1678453ac4d8b94c42f5adc2f032f316b5c6209ffc8598da2fc1dd87ed115", + "size": 88790, + "subdir": "linux-64", + "timestamp": 1626359230034, + "version": "2021.3.0" + }, + "tbb4py-2021.3.0-py38hd09550d_0.tar.bz2": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "tbb >=2021.3.0" + ], + "license": "Apache 2.0", + "md5": "615cd9ed8778232a96b7500c92ea1b81", + "name": "tbb4py", + "sha256": "d15ab0f7c1d7b69eae406fd9d3b2a9325cc2175bb7dfb98ab0a1f3723014e2bf", + "size": 88905, + "subdir": "linux-64", + "timestamp": 1626359275676, + "version": "2021.3.0" + }, + "tbb4py-2021.3.0-py39hd09550d_0.tar.bz2": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "tbb >=2021.3.0" + ], + "license": "Apache 2.0", + "md5": "97ef83d8d0078c5d0fff2307bbc78d92", + "name": "tbb4py", + "sha256": "6be276ef097c9936926c4603147a12f9265e96850d2ef8e2bae7e57d4bf98459", + "size": 88758, + "subdir": "linux-64", + "timestamp": 1626359252778, + "version": "2021.3.0" + }, + "tbb4py-2021.4.0-py37hd09550d_0.tar.bz2": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "tbb >=2021.4.0" + ], + "license": "Apache 2.0", + "md5": "30aef10b0eac3cadf7c021ffb9fa384e", + "name": "tbb4py", + "sha256": "987773722dc271ada7a79e5a4ea12ed13b82b8af165eff0e1d482e50b080b88a", + "size": 89259, + "subdir": "linux-64", + "timestamp": 1634724068955, + "version": "2021.4.0" + }, + "tbb4py-2021.4.0-py38hd09550d_0.tar.bz2": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "tbb >=2021.4.0" + ], + "license": "Apache 2.0", + "md5": "a3d3edefb3d09ef52ef6f9418308ceb7", + "name": "tbb4py", + "sha256": "7d944cec46de52e23b21f898e9f10e05bf439396184c4d5d65e5a80c6c8d8939", + "size": 89528, + "subdir": "linux-64", + "timestamp": 1634724094301, + "version": "2021.4.0" + }, + "tbb4py-2021.4.0-py39hd09550d_0.tar.bz2": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "tbb >=2021.4.0" + ], + "license": "Apache 2.0", + "md5": "41927ad4fdfadd9fc60a943156ed650a", + "name": "tbb4py", + "sha256": "89fd2018efca9539d46cdb09bba16c9573806d9a618f4c60399105f6c24bee02", + "size": 89274, + "subdir": "linux-64", + "timestamp": 1634724119775, + "version": "2021.4.0" + }, + "tbb4py-2021.5.0-py310hd09550d_0.tar.bz2": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "tbb >=2021.5.0" + ], + "license": "Apache 2.0", + "md5": "2b3cc275284e384a20614e787575db51", + "name": "tbb4py", + "sha256": "4fbe0f06cde2fe35e40976fc03ce8076ccb61cc01ec8f2acf68969843de9b86d", + "size": 358505, + "subdir": "linux-64", + "timestamp": 1641834026726, + "version": "2021.5.0" + }, + "tbb4py-2021.5.0-py37hd09550d_0.tar.bz2": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "tbb >=2021.5.0" + ], + "license": "Apache-2.0", + "md5": "a259bbce8d5629794bd42a71f77375b9", + "name": "tbb4py", + "sha256": "932e4ca663706c48a9f9046f2e9dbc55acd9e2320189c328c4fb88c9acda29dd", + "size": 249714, + "subdir": "linux-64", + "timestamp": 1642690137520, + "version": "2021.5.0" + }, + "tbb4py-2021.5.0-py38hd09550d_0.tar.bz2": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "tbb >=2021.5.0" + ], + "license": "Apache-2.0", + "md5": "bb71de4704a8d81e7755a354cb4c2506", + "name": "tbb4py", + "sha256": "e6b0f73e2163846a92673da3a12ae08fe891952b430b34d2c91436ef1168c24f", + "size": 249544, + "subdir": "linux-64", + "timestamp": 1642690166624, + "version": "2021.5.0" + }, + "tbb4py-2021.5.0-py39hd09550d_0.tar.bz2": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "tbb >=2021.5.0" + ], + "license": "Apache-2.0", + "md5": "db9047a6842e17d7c9d8cf50c2945fc8", + "name": "tbb4py", + "sha256": "d564803f3ba501e3407eb7bf96a2442420d413d0e3b1b2ed24c77b41a155926f", + "size": 249920, + "subdir": "linux-64", + "timestamp": 1642690196110, + "version": "2021.5.0" + }, + "tbb4py-2021.6.0-py310hdb19cb5_0.tar.bz2": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "tbb >=2021.6.0" + ], + "license": "Apache-2.0", + "md5": "29e62389849eb58d3364752b23d5aa21", + "name": "tbb4py", + "sha256": "840a1500db7b5cfb84c35c3bbb0e41e139cd1a8a9bd9f0add9923addfb5e7967", + "size": 409926, + "subdir": "linux-64", + "timestamp": 1664812999990, + "version": "2021.6.0" + }, + "tbb4py-2021.6.0-py310hdb19cb5_1.tar.bz2": { + "build": "py310hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "tbb >=2021.6.0" + ], + "license": "Apache-2.0", + "md5": "ef0696e6434e7f1fd63f45db0c4532ef", + "name": "tbb4py", + "sha256": "10aabca716144984646c13edc4baa3078855576a5a7315ef887108116ca5ae82", + "size": 254454, + "subdir": "linux-64", + "timestamp": 1673966619683, + "version": "2021.6.0" + }, + "tbb4py-2021.6.0-py311hdb19cb5_1.tar.bz2": { + "build": "py311hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "tbb >=2021.6.0" + ], + "license": "Apache-2.0", + "md5": "2abb3bf238b5fec43f097d984985b2dd", + "name": "tbb4py", + "sha256": "db9d99db9145a8902d8961204074652e4f5082ff153f93e6c9d55410c9e84f74", + "size": 264155, + "subdir": "linux-64", + "timestamp": 1676862929281, + "version": "2021.6.0" + }, + "tbb4py-2021.6.0-py37hdb19cb5_0.tar.bz2": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "tbb >=2021.6.0" + ], + "license": "Apache-2.0", + "md5": "c695c4b4b7238c7a4e5858ab12a03e97", + "name": "tbb4py", + "sha256": "fbc8a6ba6a71316d4e9a962afa1460ea1b2f388c90fd918f01a9e522f3402b94", + "size": 254263, + "subdir": "linux-64", + "timestamp": 1664813031916, + "version": "2021.6.0" + }, + "tbb4py-2021.6.0-py37hdb19cb5_1.tar.bz2": { + "build": "py37hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "tbb >=2021.6.0" + ], + "license": "Apache-2.0", + "md5": "517c0018cdf7629f163279ccf122e6d5", + "name": "tbb4py", + "sha256": "d49b8e0bccb0f4d316b8eb23b1ee3f15aeeaca727e99301755c3adb693e229c6", + "size": 254141, + "subdir": "linux-64", + "timestamp": 1673966652500, + "version": "2021.6.0" + }, + "tbb4py-2021.6.0-py38hdb19cb5_0.tar.bz2": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "tbb >=2021.6.0" + ], + "license": "Apache-2.0", + "md5": "43d18e2bcb1b742d490d9b58cb1053a4", + "name": "tbb4py", + "sha256": "e8ad599dacdce2bf042fe1f3458dbbc2945054d67d8fa27e53fae334f1b2a54d", + "size": 254221, + "subdir": "linux-64", + "timestamp": 1664813099047, + "version": "2021.6.0" + }, + "tbb4py-2021.6.0-py38hdb19cb5_1.tar.bz2": { + "build": "py38hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "tbb >=2021.6.0" + ], + "license": "Apache-2.0", + "md5": "2276ece57b3e125cfe4ffe88c4d828bf", + "name": "tbb4py", + "sha256": "2f16f990200e28b667c142a7c834ef5546caedb29fb53a90122b1cd94cf3ce04", + "size": 254326, + "subdir": "linux-64", + "timestamp": 1673966684724, + "version": "2021.6.0" + }, + "tbb4py-2021.6.0-py39hdb19cb5_0.tar.bz2": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "tbb >=2021.6.0" + ], + "license": "Apache-2.0", + "md5": "6bdc78ba983443f77f747af74122558a", + "name": "tbb4py", + "sha256": "65f51f9636a72f37f874ebe0f2a5e090be30f3befac8cd18dee4f967e937531b", + "size": 254109, + "subdir": "linux-64", + "timestamp": 1664813067044, + "version": "2021.6.0" + }, + "tbb4py-2021.6.0-py39hdb19cb5_1.tar.bz2": { + "build": "py39hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "tbb >=2021.6.0" + ], + "license": "Apache-2.0", + "md5": "420f205188c2c880cbf28b6d6d1ebfaa", + "name": "tbb4py", + "sha256": "d4f8a392a1a7fac5f3f8413c39e471fee0edd90eb14c688e54a79a0677d3a1d0", + "size": 254042, + "subdir": "linux-64", + "timestamp": 1673966719236, + "version": "2021.6.0" + }, + "tbb4py-2021.7.0-py310hdb19cb5_0.tar.bz2": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "tbb >=2021.7.0" + ], + "license": "Apache-2.0", + "md5": "22567b9b9a56f4ac34082f8bf4739d12", + "name": "tbb4py", + "sha256": "a8f9b773d6d4570f416d1ca9911b2f4229ffc8b80259ed84542fc217cc282bf5", + "size": 254108, + "subdir": "linux-64", + "timestamp": 1676908801557, + "version": "2021.7.0" + }, + "tbb4py-2021.7.0-py37hdb19cb5_0.tar.bz2": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "tbb >=2021.7.0" + ], + "license": "Apache-2.0", + "md5": "37233eb90912170939dbfe67ab051481", + "name": "tbb4py", + "sha256": "14cbca3c7e3fbb7743be03f7219df347209b017180c4f384455af31d8959f90c", + "size": 254053, + "subdir": "linux-64", + "timestamp": 1676908736014, + "version": "2021.7.0" + }, + "tbb4py-2021.7.0-py38hdb19cb5_0.tar.bz2": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "tbb >=2021.7.0" + ], + "license": "Apache-2.0", + "md5": "dba6f6e672ddb877ee079e8b69afcfbf", + "name": "tbb4py", + "sha256": "a73ecef0bed36d50f782c8d69138f0d65c0d0ea061a4843495bdd3436314238b", + "size": 254075, + "subdir": "linux-64", + "timestamp": 1676908768469, + "version": "2021.7.0" + }, + "tbb4py-2021.7.0-py39hdb19cb5_0.tar.bz2": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "tbb >=2021.7.0" + ], + "license": "Apache-2.0", + "md5": "539cc66f7cad20cdde4777da04bbf3d2", + "name": "tbb4py", + "sha256": "2bfc40d4b3a7b317bbe945419af061ffd5430a83cdcf8318cbbdef4a2e8a0f11", + "size": 253766, + "subdir": "linux-64", + "timestamp": 1676908703243, + "version": "2021.7.0" + }, + "tbb4py-2021.8.0-py310hdb19cb5_0.tar.bz2": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "tbb >=2021.8.0" + ], + "license": "Apache-2.0", + "md5": "8a4225b30f98545a18215512fa7aab5e", + "name": "tbb4py", + "sha256": "62b7ee17d6f90ce92af3d69636357768816931740654b5837bab8a403612d774", + "size": 255134, + "subdir": "linux-64", + "timestamp": 1680167321362, + "version": "2021.8.0" + }, + "tbb4py-2021.8.0-py311hdb19cb5_0.tar.bz2": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "tbb >=2021.8.0" + ], + "license": "Apache-2.0", + "md5": "61faf0713f837f4c186377e8919932cf", + "name": "tbb4py", + "sha256": "44db8fd42ffe49c2dcef10785253d1f8cf939553c0274f772d3d4cfb8cbe339f", + "size": 264571, + "subdir": "linux-64", + "timestamp": 1680167352437, + "version": "2021.8.0" + }, + "tbb4py-2021.8.0-py38hdb19cb5_0.tar.bz2": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "tbb >=2021.8.0" + ], + "license": "Apache-2.0", + "md5": "4b5e805053ea7cafe168fa805380f589", + "name": "tbb4py", + "sha256": "8e211e8e4929c57b47cfdf1dde886a6d86e617e4a7eccbb1f2ea2135dad5dd22", + "size": 255049, + "subdir": "linux-64", + "timestamp": 1680167414694, + "version": "2021.8.0" + }, + "tbb4py-2021.8.0-py39hdb19cb5_0.tar.bz2": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "tbb >=2021.8.0" + ], + "license": "Apache-2.0", + "md5": "77f354fc351ca8a8da5c1919ddd01937", + "name": "tbb4py", + "sha256": "6812404d292861e241eeeed5bcd356ab8ba92711008aa2c8961ebc153c822951", + "size": 254831, + "subdir": "linux-64", + "timestamp": 1680167383598, + "version": "2021.8.0" + }, + "tblib-1.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a434361fd598dd8be3e4b07a8086ac64", + "name": "tblib", + "sha256": "611d570d8a67154c5f96aa619162e021aee764d2e19e807e2763b761c661a606", + "size": 15974, + "subdir": "linux-64", + "timestamp": 1530741307256, + "version": "1.3.2" + }, + "tblib-1.3.2-py27h51fe5ba_0.tar.bz2": { + "build": "py27h51fe5ba_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b46c4864741594cf5c8090c467d1ef22", + "name": "tblib", + "sha256": "ec052f894962cb7a018ced352b3ed9cd6a98e1c682b770f0e06a0ed5a00d6dd3", + "size": 15800, + "subdir": "linux-64", + "timestamp": 1505733062312, + "version": "1.3.2" + }, + "tblib-1.3.2-py35hf1eb0b4_0.tar.bz2": { + "build": "py35hf1eb0b4_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7425fb2c1c5957ca77a5647a6ad3d024", + "name": "tblib", + "sha256": "fc7fb9192f663091c790002a9b2f0d178d0bd10d0b6af69eec09c7e9ce1b857e", + "size": 16149, + "subdir": "linux-64", + "timestamp": 1505733073838, + "version": "1.3.2" + }, + "tblib-1.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "12850f489c16a7d6e169584050ab7afc", + "name": "tblib", + "sha256": "5cf03a2b43f93da10501f1b0acdf21d10518e437015554eb783d8cb11eb1b0f8", + "size": 16200, + "subdir": "linux-64", + "timestamp": 1530741286127, + "version": "1.3.2" + }, + "tblib-1.3.2-py36h34cf8b6_0.tar.bz2": { + "build": "py36h34cf8b6_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4a34b983e438ddd89452dafddbfe1b1f", + "name": "tblib", + "sha256": "6bd82c9a0fdb7fb71fd8abbddb5401cb277841439049591b136b546428b145f3", + "size": 16088, + "subdir": "linux-64", + "timestamp": 1505733085518, + "version": "1.3.2" + }, + "tblib-1.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "fad13511a7e2aed6ac700b9e771c6694", + "name": "tblib", + "sha256": "741e600bea5abbac4519de40cf7507910c75c2f4fc8432784e3eebae3be9ca26", + "size": 16234, + "subdir": "linux-64", + "timestamp": 1530741328742, + "version": "1.3.2" + }, + "tempita-0.5.3dev-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "68c72deab8ad01584c6ecdaf6c7ab065", + "name": "tempita", + "sha256": "4f8d808aeaab5dfb94a6381e2d965e925992fb20b8723949424908f43d928111", + "size": 27221, + "subdir": "linux-64", + "timestamp": 1537812823319, + "version": "0.5.3dev" + }, + "tempita-0.5.3dev-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "ea8e58a35d6c4c601f3a6c9189327e0f", + "name": "tempita", + "sha256": "7f32ac2758f61dee2e79590064840f66dd258ed080ed89a40f24e1b7385ccab4", + "size": 28153, + "subdir": "linux-64", + "timestamp": 1641402768846, + "version": "0.5.3dev" + }, + "tempita-0.5.3dev-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "686b589cca5c99ac054883cb82772f67", + "name": "tempita", + "sha256": "b846d06ed2ad7922b167487ecda1f4f2c7be396eb692a0ca59612b60d4597bf2", + "size": 27827, + "subdir": "linux-64", + "timestamp": 1537812874706, + "version": "0.5.3dev" + }, + "tempita-0.5.3dev-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ec4f84f37b523c9ba88e2f95327db73f", + "name": "tempita", + "sha256": "2802455642835eda19ce7d55bdf201747e909c4748343a4ca0c2ac4bebbcf54a", + "size": 27702, + "subdir": "linux-64", + "timestamp": 1537812860349, + "version": "0.5.3dev" + }, + "tempita-0.5.3dev-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0cb394ed3f3eec7b32763554222a230c", + "name": "tempita", + "sha256": "5af1c3fa2a17bd10a41cad79897221e00ad2b38504d14e08ab4b29490017fad0", + "size": 29277, + "subdir": "linux-64", + "timestamp": 1614066113903, + "version": "0.5.3dev" + }, + "tempita-0.5.3dev-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8ab782248dd0c74a65fc0e4bfa82a6d5", + "name": "tempita", + "sha256": "efde72ea94330e684abe363fccdb98af768b47d060b786221fc30c7a31a7b6ef", + "size": 27732, + "subdir": "linux-64", + "timestamp": 1537812783559, + "version": "0.5.3dev" + }, + "tempita-0.5.3dev-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e9805efa75ce2eea00a3de0a2b738f7c", + "name": "tempita", + "sha256": "fa81c91400677cdb8212d0c13701e78467f31152913cfc18ba3b5e4015d8c141", + "size": 29303, + "subdir": "linux-64", + "timestamp": 1614066100912, + "version": "0.5.3dev" + }, + "tempita-0.5.3dev-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "493b156622df290eda4dc08df7af923d", + "name": "tempita", + "sha256": "518957db12828d08abc4714c23dc675547e174168bf5693903ac68a787852f88", + "size": 28253, + "subdir": "linux-64", + "timestamp": 1573661840692, + "version": "0.5.3dev" + }, + "tempita-0.5.3dev-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "05460281c71879909d3bf613cf2e8a35", + "name": "tempita", + "sha256": "effe2502266b6bbbe3129ece6108ba8908004e53994bfbe307720a82f107e0f9", + "size": 29473, + "subdir": "linux-64", + "timestamp": 1614066093665, + "version": "0.5.3dev" + }, + "tempita-0.5.3dev-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "68bf789dd519c00aa30da3fc9b3784e8", + "name": "tempita", + "sha256": "1e182ee7f61155bb6a794a9aa4a6246c2ead9bafcf30a665a4a68452cc940aeb", + "size": 29401, + "subdir": "linux-64", + "timestamp": 1614065198366, + "version": "0.5.3dev" + }, + "tempora-1.10-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "88637f8879b45268d13c4175aec27a9e", + "name": "tempora", + "sha256": "53a8b6990ebc1b45f68843f84ec3620cb388612b3f928703ebf582bd3e849963", + "size": 22117, + "subdir": "linux-64", + "timestamp": 1520907794440, + "version": "1.10" + }, + "tempora-1.10-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "815d7ea1a94cfaeec6d0d74b64f2855f", + "name": "tempora", + "sha256": "6d726096c8048317ebadd7ce277a0819a6d816bae1650077f469c0ca3810f8c1", + "size": 22737, + "subdir": "linux-64", + "timestamp": 1520907799197, + "version": "1.10" + }, + "tempora-1.10-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bf5fbe145e118ee6b5747e46395598e8", + "name": "tempora", + "sha256": "d8eaa474d0d9db69ce7dd263d1d210ec3aebcf6cc128ed86a65ef5cff864afa7", + "size": 22674, + "subdir": "linux-64", + "timestamp": 1520907759438, + "version": "1.10" + }, + "tempora-1.11-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a445bcb012f87dcf6923a2ec487dda72", + "name": "tempora", + "sha256": "c52f73e309fa683292d57fabcc04bedce52ae4a1f640e29006c61d4fcc6a8bbc", + "size": 23010, + "subdir": "linux-64", + "timestamp": 1522786937328, + "version": "1.11" + }, + "tempora-1.11-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43385f578a6ca09af8982ada6b09c5df", + "name": "tempora", + "sha256": "2f8f2dbc0fafd91eb71ffee29edb2232687c679a58207a778ba203e8b22c8d22", + "size": 23663, + "subdir": "linux-64", + "timestamp": 1522786986018, + "version": "1.11" + }, + "tempora-1.11-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb179a8cc4ef3354b8022a9a1993b6ba", + "name": "tempora", + "sha256": "5e842dfe982787855903d4113a34f7c4c94b6a1091bc5e5ba2435cdc54738900", + "size": 23583, + "subdir": "linux-64", + "timestamp": 1522787016738, + "version": "1.11" + }, + "tempora-1.11-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6481ca7a8a4afcb4b324bf6f73191db", + "name": "tempora", + "sha256": "df37f81e7f570ab5e413188d6621a995e74054a544fc6bc94123859a62c9520b", + "size": 23421, + "subdir": "linux-64", + "timestamp": 1530812061671, + "version": "1.11" + }, + "tempora-1.13-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "jaraco.functools >=1.20", + "python >=2.7,<2.8.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5428d9460ecf7655a4caec6faa47a35d", + "name": "tempora", + "sha256": "8d0c18e4ebe8258bff540fce9ca0a9133bb24d20d8ed6179beb9a6445d0daacb", + "size": 24984, + "subdir": "linux-64", + "timestamp": 1539723491664, + "version": "1.13" + }, + "tempora-1.13-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "jaraco.functools >=1.20", + "python >=3.6,<3.7.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7cd6437e639e29210737832270ba2a67", + "name": "tempora", + "sha256": "014a539b5e6a6776292a4c9b82de19ceb51964f968595e5eda3e85d7f2750abf", + "size": 25571, + "subdir": "linux-64", + "timestamp": 1539723522952, + "version": "1.13" + }, + "tempora-1.13-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "jaraco.functools >=1.20", + "python >=3.7,<3.8.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4784390dc4b7716e2a98bb2277211e54", + "name": "tempora", + "sha256": "76d3ea017111a259a682345cd61a2a6615a9490674b119ef3ccc0cb4836521ee", + "size": 25514, + "subdir": "linux-64", + "timestamp": 1539723501038, + "version": "1.13" + }, + "tempora-1.14-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jaraco.functools >=1.20", + "python >=2.7,<2.8.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d9826f3e1268567214f760fce435bd3", + "name": "tempora", + "sha256": "f67e9e869121c2526fb9f70ce3b41ed88ec4220fd863395cab73ca8d23f8d6bd", + "size": 24882, + "subdir": "linux-64", + "timestamp": 1545231817221, + "version": "1.14" + }, + "tempora-1.14-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jaraco.functools >=1.20", + "python >=3.6,<3.7.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e0da504f84e1ee6f1f1c7b944cd172f", + "name": "tempora", + "sha256": "e8781c18876761d6e4eeba8446bd65d1001834da8129966bcfe5e95d3230a48d", + "size": 25488, + "subdir": "linux-64", + "timestamp": 1545232217203, + "version": "1.14" + }, + "tempora-1.14-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jaraco.functools >=1.20", + "python >=3.7,<3.8.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9fed2954632e74ba09c5d4153479cab4", + "name": "tempora", + "sha256": "45a1a167d8b6a80318a60abb68c5bb38d7ea6a1062c93f210e20272b5a72d6c6", + "size": 25444, + "subdir": "linux-64", + "timestamp": 1545232206748, + "version": "1.14" + }, + "tempora-1.9-py27hd65d453_0.tar.bz2": { + "build": "py27hd65d453_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "53b9de80db2efdea87c74c84ebf9679e", + "name": "tempora", + "sha256": "925e92dc922e63216ec3f1c263416a15037dc550fea93b70bb354b51b2282031", + "size": 21352, + "subdir": "linux-64", + "timestamp": 1507584184984, + "version": "1.9" + }, + "tempora-1.9-py35h731c0ba_0.tar.bz2": { + "build": "py35h731c0ba_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "78e8f7d759910404df9ffeace5127cbf", + "name": "tempora", + "sha256": "53ae8e9078a35d90fdeec4ef2207bd92c072fb9c25ef2bf0bb1a7f0d7a3e56f0", + "size": 22005, + "subdir": "linux-64", + "timestamp": 1507584187355, + "version": "1.9" + }, + "tempora-1.9-py36h3630c69_0.tar.bz2": { + "build": "py36h3630c69_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c7c9be72c353b51c481cf7f5edb67bb9", + "name": "tempora", + "sha256": "a5b09fac1d717505e4b0bdb812386f88c9a0ae0d36dc366af6b2460eb366d0f6", + "size": 21906, + "subdir": "linux-64", + "timestamp": 1507584187302, + "version": "1.9" + }, + "tenacity-4.12.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3", + "monotonic >=0.6", + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "91e32a6081da4a1129b92022417ed485", + "name": "tenacity", + "sha256": "40ed5370d0eee5039c660f0344811dd7e500e5df5d2d3addd284ab81351b6691", + "size": 46389, + "subdir": "linux-64", + "timestamp": 1579635965559, + "version": "4.12.0" + }, + "tenacity-4.12.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "7bddb2865b732c633b85e71d46716bb2", + "name": "tenacity", + "sha256": "2109e36a277417dce4fae7f3858712f9bd3faf10dd00db90064a17cf328cc68d", + "size": 48619, + "subdir": "linux-64", + "timestamp": 1579635964604, + "version": "4.12.0" + }, + "tenacity-4.12.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "e0b8d8c1bb1eac19673f6584794114c6", + "name": "tenacity", + "sha256": "d1daffe6f3c30f83311bf33108f1ee9c39292bc74aa3c1a154178805cfda7f14", + "size": 48735, + "subdir": "linux-64", + "timestamp": 1579635973565, + "version": "4.12.0" + }, + "tenacity-4.12.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "294c9d45c49d657493d59da0006ea07b", + "name": "tenacity", + "sha256": "19972057e462842004596f1cfe331fb7115697f1b0861116f25c227b8d33f2d4", + "size": 49139, + "subdir": "linux-64", + "timestamp": 1579635973302, + "version": "4.12.0" + }, + "tenacity-6.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3", + "monotonic >=0.6", + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "b1ade3a3eaf68e6d02e81c4262df37d6", + "name": "tenacity", + "sha256": "d034e94ee82c051e35a201a5a7f24113aebe063b6b3b9981c0e7adc32ec953d2", + "size": 38574, + "subdir": "linux-64", + "timestamp": 1576535711758, + "version": "6.0.0" + }, + "tenacity-6.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "c8765b34d55a79ff8024e6bd33ebf1f0", + "name": "tenacity", + "sha256": "35c250b141c74d680b0cd7ed6018efdea0cfc952a40039ed1cbde4c6ea4be56a", + "size": 39986, + "subdir": "linux-64", + "timestamp": 1576535700782, + "version": "6.0.0" + }, + "tenacity-6.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "c90c2305f24fe93e7321caf48380cafb", + "name": "tenacity", + "sha256": "5a7ebd6a37f28c7521845509f3541bf1fe7b1153ec33a717654b1482cd00e693", + "size": 40002, + "subdir": "linux-64", + "timestamp": 1576535677600, + "version": "6.0.0" + }, + "tenacity-6.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "f4e4d4e58aa9972dba97ad97019f647c", + "name": "tenacity", + "sha256": "d8e0ca9676a118967a3113132a30ecb22bfb6cbf4823c8a32ed8524da4cafb65", + "size": 40215, + "subdir": "linux-64", + "timestamp": 1576535730582, + "version": "6.0.0" + }, + "tenacity-6.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "803e9a20709c6f515032ba418e5ec060", + "name": "tenacity", + "sha256": "b7a1506c438b751e2dbe862ce7e73fd96086e435a20fb9961202d0b8d44bd95a", + "size": 40115, + "subdir": "linux-64", + "timestamp": 1597706171654, + "version": "6.1.0" + }, + "tenacity-6.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "c526ae0a13217dc1b86b2f391128625c", + "name": "tenacity", + "sha256": "33e62749cb6ea3b0ad596b8d78e5a52aba646e14914b3d39e19701954c8d1660", + "size": 40178, + "subdir": "linux-64", + "timestamp": 1597706188024, + "version": "6.1.0" + }, + "tenacity-6.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "a8774a997af665060b2e3bc14f1cd559", + "name": "tenacity", + "sha256": "152c654d4327aec2ac02a3336edd7b9314d4980b212aeaf8383bb024674108db", + "size": 40362, + "subdir": "linux-64", + "timestamp": 1597706194748, + "version": "6.1.0" + }, + "tenacity-6.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "421cdd145dff607db39b0f239c65bbe0", + "name": "tenacity", + "sha256": "98b8705dbb8126c3e8c4a01dc8f5a326698dba1bba809c6a95ffb0addb5814bd", + "size": 41332, + "subdir": "linux-64", + "timestamp": 1597706726857, + "version": "6.2.0" + }, + "tenacity-6.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "ec027f3c56bcdc21fc6c80c9b1e9f92a", + "name": "tenacity", + "sha256": "6ffa052acf26f8a173ecacf71edb4e16e2a424f9d38672cfcf70c80761ef8408", + "size": 41343, + "subdir": "linux-64", + "timestamp": 1597706734992, + "version": "6.2.0" + }, + "tenacity-6.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "d49fd09e16dc8514086337aaa51f2209", + "name": "tenacity", + "sha256": "3711b0b9a73270bb5e5af6a444c876f463de0c286bc899cba216945fee7eee1b", + "size": 41540, + "subdir": "linux-64", + "timestamp": 1597706748033, + "version": "6.2.0" + }, + "tenacity-6.3.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "1c28dc6b8df6eefdc9ef89ebee65ff9d", + "name": "tenacity", + "sha256": "328d625ac4d8a6029e85ab5e92ed09813e3c25656316cbe6e5fc2f8ba046850c", + "size": 37656, + "subdir": "linux-64", + "timestamp": 1608058901554, + "version": "6.3.0" + }, + "tenacity-6.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "bd85a66a0546ea90f8b2a061aa2fedd9", + "name": "tenacity", + "sha256": "25e7a40a08cb8b4d4ee51483dc2f0cb31fb4b248192a6d08361f8475434c5a9b", + "size": 37743, + "subdir": "linux-64", + "timestamp": 1608058835559, + "version": "6.3.0" + }, + "tenacity-6.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "1f84fcddefbfd6f8abad74b38bbc757c", + "name": "tenacity", + "sha256": "a03ac02d8e2b8606c0366201d777b7de7d94c6b71162592566139a85f6baeb41", + "size": 37895, + "subdir": "linux-64", + "timestamp": 1608058891588, + "version": "6.3.0" + }, + "tenacity-6.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "250679505732ad6fb8bd01b0ed2e781e", + "name": "tenacity", + "sha256": "f5b19fcb709d2f87b30d6c51fd68106b46826d40ea5f71b52808f5ab71f915cd", + "size": 37960, + "subdir": "linux-64", + "timestamp": 1608058889840, + "version": "6.3.0" + }, + "tenacity-6.3.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "ac2fa91c68842c5aef4c92d7b2b51719", + "name": "tenacity", + "sha256": "ceb8e7565aeef28483f20ebc94fcc2837dc08d0341fc60174a97fdd5cf168a3e", + "size": 37674, + "subdir": "linux-64", + "timestamp": 1608241858736, + "version": "6.3.1" + }, + "tenacity-6.3.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "3c0bfd0cded04da6711687f5f73196cc", + "name": "tenacity", + "sha256": "835f099f5cbad68887abc43bc2719a40a562ec531a7b69d3449ac40197fe4d43", + "size": 37728, + "subdir": "linux-64", + "timestamp": 1608241858819, + "version": "6.3.1" + }, + "tenacity-6.3.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "ffce64a0e6e0199bbf6991286f206260", + "name": "tenacity", + "sha256": "0d804055ae424c203ffcbfe88e280668bb070e7957f648073f1b7da2eebf08b2", + "size": 37914, + "subdir": "linux-64", + "timestamp": 1608241856685, + "version": "6.3.1" + }, + "tenacity-6.3.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "902e51e995e637ab69110f3415182c13", + "name": "tenacity", + "sha256": "0ad8fae2ad5a7b7394e2983901959b3aec7911526e0c2fee9280dd526d1a5871", + "size": 37951, + "subdir": "linux-64", + "timestamp": 1608241837906, + "version": "6.3.1" + }, + "tenacity-7.0.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "f9b08907809818aa54d15efb32806c40", + "name": "tenacity", + "sha256": "5052a0c6ff8d08206cc057e9ab13b3f232a54f5d291590d9ad2094b4fc9d602a", + "size": 33592, + "subdir": "linux-64", + "timestamp": 1614798153065, + "version": "7.0.0" + }, + "tenacity-7.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "9d13125049139b1b0194151a48a153b1", + "name": "tenacity", + "sha256": "86139791c4cc3fa9fbe2ff9e6084b08b78cf5c5097724ce77b061b891cfa34f4", + "size": 33610, + "subdir": "linux-64", + "timestamp": 1614799429382, + "version": "7.0.0" + }, + "tenacity-7.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "3d61201c7fda10ab10e068cb622c6e2c", + "name": "tenacity", + "sha256": "0afa2d1e0759263501fc69797245f99ba9193e78bd78e8ef020c540684489e82", + "size": 33879, + "subdir": "linux-64", + "timestamp": 1614799442940, + "version": "7.0.0" + }, + "tenacity-7.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "97314a975d95f1c7d36e771fc3af055e", + "name": "tenacity", + "sha256": "8a1112d2b2fe4e412c890a76e77a21acf0ed42803132eff66746d86f4dc4ef72", + "size": 33871, + "subdir": "linux-64", + "timestamp": 1614799436456, + "version": "7.0.0" + }, + "tenacity-8.0.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "704b8c4f93e1d748559ab802cdd1fed5", + "name": "tenacity", + "sha256": "9e9483a0f862a4d8c1eb69db0a9b1bf75609039dd9f5f4f4d658acee37da8a6a", + "size": 33407, + "subdir": "linux-64", + "timestamp": 1625815756144, + "version": "8.0.0" + }, + "tenacity-8.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "8ab87e7df3dca686a50f724a98a470a4", + "name": "tenacity", + "sha256": "8a4d00bfc74a5f1683a43d97a41a77f281ca14b999c390fd8332f7dc02dbbe13", + "size": 33499, + "subdir": "linux-64", + "timestamp": 1625808884173, + "version": "8.0.0" + }, + "tenacity-8.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "e444595331503422519bf7a2988d4137", + "name": "tenacity", + "sha256": "01ec916e99afbd1a1f0fa0b6b288a671ebf8cb3850acd0e6895b75bec31fe467", + "size": 33747, + "subdir": "linux-64", + "timestamp": 1625815736217, + "version": "8.0.0" + }, + "tenacity-8.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "aaeb0fe37dc5776917c9c487f7415bd4", + "name": "tenacity", + "sha256": "d2870a9eb30029c4037d350bc68a3995b92227415f814c6b13845df1885bb050", + "size": 33936, + "subdir": "linux-64", + "timestamp": 1625852859837, + "version": "8.0.0" + }, + "tenacity-8.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "77b2c3cc3ccac637a635524f49ed8971", + "name": "tenacity", + "sha256": "ddf15e930a138d3c10c257d8ff09ed86582d42d96ee0b35231f48fa8de3821c6", + "size": 36006, + "subdir": "linux-64", + "timestamp": 1642511113490, + "version": "8.0.1" + }, + "tenacity-8.0.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "af206ae38ff2b518e7167602874b52ea", + "name": "tenacity", + "sha256": "19af707fbef24975c7cfbf114ad5b28b3b156a5b15577b64a784ebcb51a95dc3", + "size": 36773, + "subdir": "linux-64", + "timestamp": 1657899336613, + "version": "8.0.1" + }, + "tenacity-8.0.1-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "270e408f2969d0b3e54a956049470e65", + "name": "tenacity", + "sha256": "031481ffc3cabcd0f09fd605706b63b91fd01b2b87a3f88f2acd3b6b31581cf8", + "size": 45113, + "subdir": "linux-64", + "timestamp": 1676838858272, + "version": "8.0.1" + }, + "tenacity-8.0.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "078a1bd8df2c5d6e4f3390c0757b9883", + "name": "tenacity", + "sha256": "d1add9aa2a33f7ec1f6a75b7af1f7072dfc90e56d22b6335fd9a3e419cf678d7", + "size": 40017, + "subdir": "linux-64", + "timestamp": 1632756984487, + "version": "8.0.1" + }, + "tenacity-8.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "485784fe16f5be6d79cc9bceea7809dc", + "name": "tenacity", + "sha256": "4d99c43c56bd2e9c33d35548dac0fda1094252003f06d6d575ab1631120e0bf8", + "size": 40094, + "subdir": "linux-64", + "timestamp": 1632746537969, + "version": "8.0.1" + }, + "tenacity-8.0.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "539c66b88f4b0c810d1fcd7448a9d123", + "name": "tenacity", + "sha256": "3efe677b4fa1aadab2e5cf11ca3ddeba0f8524b433dfa89cb7257d93221855d8", + "size": 35883, + "subdir": "linux-64", + "timestamp": 1657899401204, + "version": "8.0.1" + }, + "tenacity-8.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2b82afa3858d03ed0af0b3451aeb9a0b", + "name": "tenacity", + "sha256": "76a71bc489faf0da091ec0edb04f01a3ffaf67c9e2700286f357a213f0631b2e", + "size": 40325, + "subdir": "linux-64", + "timestamp": 1632756908622, + "version": "8.0.1" + }, + "tenacity-8.0.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c244ea287a2975d6628951403755771c", + "name": "tenacity", + "sha256": "01c932e7d2fa8b878db22bb48f833fe47303ebec064b81117274095ac8afeee1", + "size": 36134, + "subdir": "linux-64", + "timestamp": 1657899246361, + "version": "8.0.1" + }, + "tenacity-8.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f3b14e177094c17126f74ca2755e879d", + "name": "tenacity", + "sha256": "a74482a8f14dc9cbe22595b8bad66ba4fd2bf3ec7b8b76e2ecb00ac878fda714", + "size": 35239, + "subdir": "linux-64", + "timestamp": 1626248339181, + "version": "8.0.1" + }, + "tenacity-8.0.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "55f0cedafe39388c64ffdcf240b3aa7f", + "name": "tenacity", + "sha256": "2dd619d79ba67072f8f3b2589eda6e4966780dff5a1b1777e51a9d7a95230635", + "size": 36155, + "subdir": "linux-64", + "timestamp": 1657899182480, + "version": "8.0.1" + }, + "tensorboard-1.10.0-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "futures >=3.1.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d2478a32b46d5d10fcb1a8383807351f", + "name": "tensorboard", + "sha256": "e64cb8518039d9f853a459d56a76855804bf89c0f062099de2e53f3860dcf894", + "size": 3450863, + "subdir": "linux-64", + "timestamp": 1534870854005, + "version": "1.10.0" + }, + "tensorboard-1.10.0-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8eb11a06369ea70a2d92f7ac6649c021", + "name": "tensorboard", + "sha256": "24122530b96e81684e7720f0630d0a22f7a92144cd1f7c539506eb22269e29a4", + "size": 3456407, + "subdir": "linux-64", + "timestamp": 1534870749762, + "version": "1.10.0" + }, + "tensorboard-1.10.0-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0b309125e9355ca29dfd2988aec3b2c2", + "name": "tensorboard", + "sha256": "ddb3d8a1a0da4cf70383117cfec918ed03cfe5eaa164bec645586f756dfbbdb0", + "size": 3447961, + "subdir": "linux-64", + "timestamp": 1534870642904, + "version": "1.10.0" + }, + "tensorboard-1.11.0-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "futures >=3.1.1", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "66451f4495ded4342513c2b0fcf36115", + "name": "tensorboard", + "sha256": "1f08aa573d12349f11e46c04afe0a0341a95728317de5966d00dcc0dcea15741", + "size": 3230306, + "subdir": "linux-64", + "timestamp": 1538591921574, + "version": "1.11.0" + }, + "tensorboard-1.11.0-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f0931710f01101706d961bbf1896cfc6", + "name": "tensorboard", + "sha256": "f7ea0c10a19bc0ae11615f8b47e1d2be7876b99b811512120dd73e18e829cfb7", + "size": 3214962, + "subdir": "linux-64", + "timestamp": 1538592106572, + "version": "1.11.0" + }, + "tensorboard-1.12.0-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "futures >=3.1.1", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2f8fb30c895dd45733a1deff63e3c468", + "name": "tensorboard", + "sha256": "9fe89766dee2559d7daf0a1907cf9883968f5c1ed7b6e350bc3d93000ec5385b", + "size": 3285520, + "subdir": "linux-64", + "timestamp": 1542083527370, + "version": "1.12.0" + }, + "tensorboard-1.12.0-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e31ef304583e826507107c5a90ffe012", + "name": "tensorboard", + "sha256": "a1fd29d6a24f627b7ae5a06c112a2927ac97fb828724d1fe4fa7f3b36c7d8f43", + "size": 3263365, + "subdir": "linux-64", + "timestamp": 1542077717358, + "version": "1.12.0" + }, + "tensorboard-1.12.1-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "futures >=3.1.1", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "054bade36cd9014be1ec73bd1a7a730e", + "name": "tensorboard", + "sha256": "958f738bba5d91919c4b532be8eaede3c543c440f58611fae8b43dd0b4190bd4", + "size": 3281658, + "subdir": "linux-64", + "timestamp": 1545233805240, + "version": "1.12.1" + }, + "tensorboard-1.12.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c35a87fb4f4f738027fc75cf798bc1a1", + "name": "tensorboard", + "sha256": "74e331d016f74a4da7ab723a7487f95c986d217ca943b62fbf2cfe8be8f9d155", + "size": 3289227, + "subdir": "linux-64", + "timestamp": 1545234027966, + "version": "1.12.1" + }, + "tensorboard-1.12.2-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "futures >=3.1.1", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "018a1255659ac7d5325067b949e7de86", + "name": "tensorboard", + "sha256": "b5deb2c3a0db3abbe4799230f96cbb5c63b1afe0a9f5054efa60b7d88a3b9657", + "size": 3275807, + "subdir": "linux-64", + "timestamp": 1546627351628, + "version": "1.12.2" + }, + "tensorboard-1.12.2-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ab00c1c2bb2c43d1119114dbdec83b54", + "name": "tensorboard", + "sha256": "46c775b945b5d58f1e8de8bc4a740876211a4219234553db17133d7ef1c725b5", + "size": 3289298, + "subdir": "linux-64", + "timestamp": 1546627346054, + "version": "1.12.2" + }, + "tensorboard-1.13.1-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "futures >=3.1.1", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.15" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8df6e2b00cd7da32c89485694c3f39ff", + "name": "tensorboard", + "sha256": "3725d8e2001f83b50deeff2df2858ddeb26a9c271755ea9e06d3bcdfdb3942ef", + "size": 3448447, + "subdir": "linux-64", + "timestamp": 1554308771240, + "version": "1.13.1" + }, + "tensorboard-1.13.1-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.15" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3b3dd40d309ae0eb728b47a3e84d1eb4", + "name": "tensorboard", + "sha256": "995f46e47d4924d7243c8d17547e655e72d7f5da2edee827842c09ffb0a713c3", + "size": 3442689, + "subdir": "linux-64", + "timestamp": 1554308442838, + "version": "1.13.1" + }, + "tensorboard-1.13.1-py37hf484d3e_0.tar.bz2": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.15" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "59d5fc9064fd438c8e59a0d1915cec16", + "name": "tensorboard", + "sha256": "d672b435f997ed52ac945a48f6dce330f68e79d86ebed973d3a9ab0680ad1e8a", + "size": 3429950, + "subdir": "linux-64", + "timestamp": 1554309009398, + "version": "1.13.1" + }, + "tensorboard-1.14.0-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "futures >=3.1.1", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.15" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "31f0417b9dac8048cdb0f79a58753d5a", + "name": "tensorboard", + "sha256": "d7f96403633773e3ed58ab3ffd7ffbae14e4534b1529646f5dd4d275c9dbc011", + "size": 3409676, + "subdir": "linux-64", + "timestamp": 1561049602139, + "version": "1.14.0" + }, + "tensorboard-1.14.0-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.15" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ebd094ffafe6219e3ae0d3c8c81e94c5", + "name": "tensorboard", + "sha256": "d2f4fc6cbd4011062deed22242695c048f61daa1527f808348951ee10e7f9563", + "size": 3403797, + "subdir": "linux-64", + "timestamp": 1561049354595, + "version": "1.14.0" + }, + "tensorboard-1.14.0-py37hf484d3e_0.tar.bz2": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.15" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3a7acc69a262d3305efc0729df71a7af", + "name": "tensorboard", + "sha256": "ae317ad2a52d785d0f898d3e805ef4525fefadb7f91800ba1c0f08d9223a1b87", + "size": 3375424, + "subdir": "linux-64", + "timestamp": 1561049172295, + "version": "1.14.0" + }, + "tensorboard-1.15.0-py27hb230dea_0.tar.bz2": { + "build": "py27hb230dea_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7", + "futures >=3.1.1", + "grpcio >=1.14", + "markdown >=2.6.11", + "numpy >=1.16", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.12", + "webencodings", + "werkzeug >=0.14", + "wheel" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8a591fd6c48c3240cc9314ba207cfaa5", + "name": "tensorboard", + "sha256": "38d81f664fba86bad9e2d25d11fe9712f88adc709de213d0d7830229777a9633", + "size": 3952089, + "subdir": "linux-64", + "timestamp": 1573244241989, + "version": "1.15.0" + }, + "tensorboard-1.6.0-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach ==1.5.0", + "futures >=3.1.1", + "html5lib ==0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f6f0c813b4a71373613db8da9d96fc1a", + "name": "tensorboard", + "sha256": "47e7b3760689bf220d4f1aad0199c52b99153559a4beb33bdcda4c9e6305561b", + "size": 3076367, + "subdir": "linux-64", + "timestamp": 1521223760452, + "version": "1.6.0" + }, + "tensorboard-1.6.0-py27hf484d3e_1.tar.bz2": { + "build": "py27hf484d3e_1", + "build_number": 1, + "depends": [ + "bleach >=1.5.0,<1.5.1.0a0", + "futures", + "html5lib >=0.9999999,<0.10000000.0a0", + "libgcc-ng", + "libstdcxx-ng", + "markdown", + "numpy", + "protobuf", + "python >=2.7,<2.8.0a0", + "six", + "werkzeug" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "33ee7f90931c99d3495e441c7449c4af", + "name": "tensorboard", + "sha256": "489f05f3cde98a4fdb9e40055c04decfabedb24e19a00b4070e3325c8464385a", + "size": 3075143, + "subdir": "linux-64", + "timestamp": 1524776946656, + "version": "1.6.0" + }, + "tensorboard-1.6.0-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach ==1.5.0", + "html5lib ==0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3ce2489a5c22e788ceafcbbe2737c5d4", + "name": "tensorboard", + "sha256": "9747c0bbc9a9dc71e4360456f28a1e6e42f3db46540a653c9e765255ee96a04f", + "size": 3078404, + "subdir": "linux-64", + "timestamp": 1521223319065, + "version": "1.6.0" + }, + "tensorboard-1.6.0-py35hf484d3e_1.tar.bz2": { + "build": "py35hf484d3e_1", + "build_number": 1, + "depends": [ + "bleach >=1.5.0,<1.5.1.0a0", + "html5lib >=0.9999999,<0.10000000.0a0", + "libgcc-ng", + "libstdcxx-ng", + "markdown", + "numpy", + "protobuf", + "python >=3.5,<3.6.0a0", + "six", + "werkzeug" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ab77eeed5648e652a6c2043882f1d20b", + "name": "tensorboard", + "sha256": "2618029925bfffa25bab8099cf3a6173bfcb8ab76a650e63f777c6b0cfc51b07", + "size": 3078076, + "subdir": "linux-64", + "timestamp": 1524776669122, + "version": "1.6.0" + }, + "tensorboard-1.6.0-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach ==1.5.0", + "html5lib ==0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b0c3d75f3277b3886a7042d74d6efebb", + "name": "tensorboard", + "sha256": "c8881a0e6e08b958ca506bee138c5a150d52b89ce066830fa6fa6122d7b724e2", + "size": 3076041, + "subdir": "linux-64", + "timestamp": 1521223765060, + "version": "1.6.0" + }, + "tensorboard-1.6.0-py36hf484d3e_1.tar.bz2": { + "build": "py36hf484d3e_1", + "build_number": 1, + "depends": [ + "bleach >=1.5.0,<1.5.1.0a0", + "html5lib >=0.9999999,<0.10000000.0a0", + "libgcc-ng", + "libstdcxx-ng", + "markdown", + "numpy", + "protobuf", + "python >=3.6,<3.7.0a0", + "six", + "werkzeug" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4e7bb05c938615852231b0b39497b97b", + "name": "tensorboard", + "sha256": "7687ce1c335a45df231f6270c84844361432e52e02b5ce76c0c7f8d576e55ecf", + "size": 3075461, + "subdir": "linux-64", + "timestamp": 1524776804562, + "version": "1.6.0" + }, + "tensorboard-1.7.0-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach ==1.5.0", + "futures >=3.1.1", + "html5lib ==0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b336c20bf8f34fce4e7f032cb1ddb068", + "name": "tensorboard", + "sha256": "10fd11c3eda48698f4b1adb83f05bdac02356a82c7e7bdf6406c6a98090183d9", + "size": 3139797, + "subdir": "linux-64", + "timestamp": 1524276809302, + "version": "1.7.0" + }, + "tensorboard-1.7.0-py27hf484d3e_1.tar.bz2": { + "build": "py27hf484d3e_1", + "build_number": 1, + "depends": [ + "bleach >=1.5.0,<1.5.1.0a0", + "futures", + "html5lib >=0.9999999,<0.10000000.0a0", + "libgcc-ng", + "libstdcxx-ng", + "markdown", + "numpy", + "protobuf", + "python >=2.7,<2.8.0a0", + "six", + "werkzeug" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b9aed726bd255e1a69775eaf3f400e1c", + "name": "tensorboard", + "sha256": "16ec598dffff13fa33547d3b601e50554dcc657280b51c8883de6a35cf162247", + "size": 3138921, + "subdir": "linux-64", + "timestamp": 1524771746239, + "version": "1.7.0" + }, + "tensorboard-1.7.0-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach ==1.5.0", + "html5lib ==0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b83219598a64e6a803d609dc7fd2c7da", + "name": "tensorboard", + "sha256": "fd0a525f2afdf0ed7fed328654708e42cc9a6d783e49ea157ad1362329ac7927", + "size": 3146687, + "subdir": "linux-64", + "timestamp": 1524276815441, + "version": "1.7.0" + }, + "tensorboard-1.7.0-py35hf484d3e_1.tar.bz2": { + "build": "py35hf484d3e_1", + "build_number": 1, + "depends": [ + "bleach >=1.5.0,<1.5.1.0a0", + "html5lib >=0.9999999,<0.10000000.0a0", + "libgcc-ng", + "libstdcxx-ng", + "markdown", + "numpy", + "protobuf", + "python >=3.5,<3.6.0a0", + "six", + "werkzeug" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4f156e461714518b2cd1de47dcb7c973", + "name": "tensorboard", + "sha256": "e5da709dc211e21393579bfc9477b91eaa2ea5fb54ce67344dd843808a2b52fd", + "size": 3146826, + "subdir": "linux-64", + "timestamp": 1524772030165, + "version": "1.7.0" + }, + "tensorboard-1.7.0-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach ==1.5.0", + "html5lib ==0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4ac185196ea03bd63b321727c7b0b9f7", + "name": "tensorboard", + "sha256": "3284da10b40a27cc2cfffa3a19a0033e55d9c37cdb933d132f3e08c07bbb5e10", + "size": 3148054, + "subdir": "linux-64", + "timestamp": 1524276818492, + "version": "1.7.0" + }, + "tensorboard-1.7.0-py36hf484d3e_1.tar.bz2": { + "build": "py36hf484d3e_1", + "build_number": 1, + "depends": [ + "bleach >=1.5.0,<1.5.1.0a0", + "html5lib >=0.9999999,<0.10000000.0a0", + "libgcc-ng", + "libstdcxx-ng", + "markdown", + "numpy", + "protobuf", + "python >=3.6,<3.7.0a0", + "six", + "werkzeug" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "19402918590cc4638f24880002763953", + "name": "tensorboard", + "sha256": "d9d027374499f06b5906cff75676a2662401053069bceca1899fd8f3d51b510c", + "size": 3147701, + "subdir": "linux-64", + "timestamp": 1524772025091, + "version": "1.7.0" + }, + "tensorboard-1.8.0-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach 1.5.0", + "futures >=3.1.1", + "html5lib 0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d93ae840e08390b115b748d9cf171bf1", + "name": "tensorboard", + "sha256": "1747f5b5dd9bdbc20720d482af0dae7f9f2691e20729542bfc6a7ba5210d9f2b", + "size": 3197209, + "subdir": "linux-64", + "timestamp": 1527062647677, + "version": "1.8.0" + }, + "tensorboard-1.8.0-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach 1.5.0", + "html5lib 0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "39673735d482b87712b3486361169b66", + "name": "tensorboard", + "sha256": "747e6689d9d5dc603eb66797a38b0aba287f655472561e4a5812bc7434594fcb", + "size": 3198611, + "subdir": "linux-64", + "timestamp": 1527062619621, + "version": "1.8.0" + }, + "tensorboard-1.8.0-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach 1.5.0", + "html5lib 0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "418f39cbff1bb982c04a63f813288bbd", + "name": "tensorboard", + "sha256": "608bf726265c019163dc30f50c5c91d4ad016b4b32848b39826d2134807f9688", + "size": 3200120, + "subdir": "linux-64", + "timestamp": 1527062652926, + "version": "1.8.0" + }, + "tensorboard-1.9.0-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "futures >=3.1.1", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0df9239d8bc36a34f6901d73302c2b70", + "name": "tensorboard", + "sha256": "f0bb44b24d3c92106d7783f37267ae7e9d2098ac23d6ecadef10a5284be13532", + "size": 3437508, + "subdir": "linux-64", + "timestamp": 1532470025905, + "version": "1.9.0" + }, + "tensorboard-1.9.0-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cd250d116a68f95524d2adee6eab6192", + "name": "tensorboard", + "sha256": "845b8d0f6a7caf6e6fbf50013eca3ba1213631c379c908f9d396d7e5f75abba7", + "size": 3444287, + "subdir": "linux-64", + "timestamp": 1532470206291, + "version": "1.9.0" + }, + "tensorboard-1.9.0-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "90977684e99413568383fc44cd2319a3", + "name": "tensorboard", + "sha256": "3a134bb474fac7d73678d169be52b7e08a134824ac3d826414ab31ecd7e38e75", + "size": 3435249, + "subdir": "linux-64", + "timestamp": 1532469907181, + "version": "1.9.0" + }, + "tensorboard-2.0.0-py27hb230dea_0.tar.bz2": { + "build": "py27hb230dea_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7", + "futures >=3.1.1", + "grpcio >=1.14", + "markdown >=2.6.11", + "numpy >=1.16", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.12", + "webencodings", + "werkzeug >=0.14", + "wheel", + "setuptools >=41.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e1bb66fcc77889be40cdf7b1ce721527", + "name": "tensorboard", + "sha256": "a0199e64cb2237453a4482612879dfc45f4aacd882fecdd00e66c01f9c776ba8", + "size": 3954714, + "subdir": "linux-64", + "timestamp": 1571761524683, + "version": "2.0.0" + }, + "tensorboard-2.0.0-py27hb38c66f_1.tar.bz2": { + "build": "py27hb38c66f_1", + "build_number": 1, + "depends": [ + "absl-py >=0.7", + "futures >=3.1.1", + "grpcio >=1.14", + "markdown >=2.6.11", + "numpy >=1.16", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "setuptools >=41.0.0", + "six >=1.12", + "werkzeug >=0.14", + "wheel" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8f8ed22f2ac15d865bac88717c64d21b", + "name": "tensorboard", + "sha256": "43e42f8712f2ced785882b3dee99adb30a89ebd107886d8b6211b831325c09fd", + "size": 4002627, + "subdir": "linux-64", + "timestamp": 1574447706791, + "version": "2.0.0" + }, + "tensorboard-2.10.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.10,<3.11.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7e9f7a8b30067dadafb98360e8c0ef70", + "name": "tensorboard", + "sha256": "442bb33cf67a2cacd96b8d621e58739875dfa4daacc1e4c308cdf9d7e9b13b43", + "size": 6152053, + "subdir": "linux-64", + "timestamp": 1666889931054, + "version": "2.10.0" + }, + "tensorboard-2.10.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "026285a729c60ac67900b70c4d44e6c0", + "name": "tensorboard", + "sha256": "c8c2b097214889765749e18f82d0f626b59da1b9fd187e3e61b896812b5937b3", + "size": 6128485, + "subdir": "linux-64", + "timestamp": 1666889974691, + "version": "2.10.0" + }, + "tensorboard-2.10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.8,<3.9.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "322483ccd0dc44cab4408d72fc942680", + "name": "tensorboard", + "sha256": "b1224664943d1725258ae4160f44a423efb2871ba9bcc5e4cfcfd433ce040596", + "size": 6123893, + "subdir": "linux-64", + "timestamp": 1666890020213, + "version": "2.10.0" + }, + "tensorboard-2.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.9,<3.10.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f9768b4bce4b3d1aaec60c32b7983c91", + "name": "tensorboard", + "sha256": "c799958e0661236727d93b29431ba9098b0f621162a57b0ca802cd5af7fef63e", + "size": 6134643, + "subdir": "linux-64", + "timestamp": 1666889884435, + "version": "2.10.0" + }, + "tensorboard-2.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.10,<3.11.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "32acf210988e871c6127b2f31e157e9b", + "name": "tensorboard", + "sha256": "5d9b1d06c9ecf44eb97cccb0109836ec3716366e73563c5d310fe1b0686103fb", + "size": 6270199, + "subdir": "linux-64", + "timestamp": 1678126790241, + "version": "2.11.0" + }, + "tensorboard-2.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.8,<3.9.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "44b4833911e9f206393815e3b5fba7dd", + "name": "tensorboard", + "sha256": "fcaabd712e1fa9ddc282efb715abb16b6a534f6b5dc71fc85262ec244029e1fb", + "size": 6234266, + "subdir": "linux-64", + "timestamp": 1678126721243, + "version": "2.11.0" + }, + "tensorboard-2.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.9,<3.10.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "316675bf5d41170a235d9cf4e71297ee", + "name": "tensorboard", + "sha256": "14f7ffef2e6bfda7044e807c788cc98099208807d7ce028a2add1747b0a0ccc2", + "size": 6241028, + "subdir": "linux-64", + "timestamp": 1678126757132, + "version": "2.11.0" + }, + "tensorboard-2.8.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.10,<3.11.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=0.11.15", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "504fc13627c1eda992063ee159c9a9aa", + "name": "tensorboard", + "sha256": "311c35582ffc5a65842ad6b182825eb0546922ca3bd675cfe75b622117c8fff2", + "size": 6055833, + "subdir": "linux-64", + "timestamp": 1658918319899, + "version": "2.8.0" + }, + "tensorboard-2.8.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=0.11.15", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "86d6e99fa429656eb34150b1e84ce598", + "name": "tensorboard", + "sha256": "d0eeba81b3d530ccc8952e0ef3d5541d0c9aa0858aa1eb8a6d109ce51efd6d91", + "size": 6016246, + "subdir": "linux-64", + "timestamp": 1658918298776, + "version": "2.8.0" + }, + "tensorboard-2.8.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.8,<3.9.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=0.11.15", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a28c1494f7266a561fa08b5f68aab56c", + "name": "tensorboard", + "sha256": "f1ecb8da3acbca352c48660538a26c7a230b0393fbb2cff8b83a3364ee71e387", + "size": 6021166, + "subdir": "linux-64", + "timestamp": 1658918340715, + "version": "2.8.0" + }, + "tensorboard-2.8.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.9,<3.10.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=0.11.15", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b73fa0c2ffe51c800a0a7259a38f5541", + "name": "tensorboard", + "sha256": "1b8fec64de9516ee1d839d8ec9c6e44e5712d280054e8c642b4ffefc0a4d8e8b", + "size": 6015287, + "subdir": "linux-64", + "timestamp": 1658918277667, + "version": "2.8.0" + }, + "tensorboard-2.9.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.10,<3.11.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6aae7bff17fb657e5bce5b1d30cc4989", + "name": "tensorboard", + "sha256": "e964125dd7b9096d7198efb87c622d2b8a74b4c92077b95023840c0cc1c31fbe", + "size": 6028874, + "subdir": "linux-64", + "timestamp": 1661447998434, + "version": "2.9.0" + }, + "tensorboard-2.9.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fe28c72c6951d12bd3bcfb51658cbab2", + "name": "tensorboard", + "sha256": "2b981e43555798f41c42439bdb0f7be9e142504edb880678013744286e709480", + "size": 5977881, + "subdir": "linux-64", + "timestamp": 1661447952699, + "version": "2.9.0" + }, + "tensorboard-2.9.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.8,<3.9.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a87ad5b4265b70ae58485ad8a6df99d2", + "name": "tensorboard", + "sha256": "e4ccddafe047bfef05f8ddb3441290798cd13a10ba5b34c45f21bbebd976ea71", + "size": 5988293, + "subdir": "linux-64", + "timestamp": 1661447904703, + "version": "2.9.0" + }, + "tensorboard-2.9.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.9,<3.10.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7d35183ddac6c403bfe47d1604d8ed92", + "name": "tensorboard", + "sha256": "e67b7f0ee557f4a79e62fe753f7eda05be8c6af2477fb6f48be1f236a57b8ced", + "size": 5987784, + "subdir": "linux-64", + "timestamp": 1661447855329, + "version": "2.9.0" + }, + "tensorboard-data-server-0.6.0-py310hca6d32c_0.tar.bz2": { + "build": "py310hca6d32c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "151df63d5e7708aa23c5432107c38cfa", + "name": "tensorboard-data-server", + "sha256": "5b8f2419f397501c135226e8483715ad47780bda3c4282c599695f25d5b2fa5d", + "size": 3336136, + "subdir": "linux-64", + "timestamp": 1640795121638, + "version": "0.6.0" + }, + "tensorboard-data-server-0.6.0-py36hca6d32c_0.tar.bz2": { + "build": "py36hca6d32c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "5d644593fa30862fe352a30595e5adf9", + "name": "tensorboard-data-server", + "sha256": "c2a1e3fc3fc29e50bac9dab343847a038b909dd1c9eee0b50d0f3b9f9793c823", + "size": 3339190, + "subdir": "linux-64", + "timestamp": 1633035275829, + "version": "0.6.0" + }, + "tensorboard-data-server-0.6.0-py37hca6d32c_0.tar.bz2": { + "build": "py37hca6d32c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "d94c6544515dcc7cbfc0c25a1c79a164", + "name": "tensorboard-data-server", + "sha256": "a9d174ae92ac71d851dd24893a192a1bfa5aa3c59a7ffeedd810b0fdf6602153", + "size": 3341630, + "subdir": "linux-64", + "timestamp": 1633024748442, + "version": "0.6.0" + }, + "tensorboard-data-server-0.6.0-py38hca6d32c_0.tar.bz2": { + "build": "py38hca6d32c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "13d4bfa39d9e4ed1bb0775865afd0f75", + "name": "tensorboard-data-server", + "sha256": "7505fc4264280260691ee40a357f5482d8dc8c9040b2b6c4e51556ed8733396a", + "size": 3339323, + "subdir": "linux-64", + "timestamp": 1633035238452, + "version": "0.6.0" + }, + "tensorboard-data-server-0.6.0-py39hca6d32c_0.tar.bz2": { + "build": "py39hca6d32c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "3fc5f3d8d847cc682f4a25475c904ff3", + "name": "tensorboard-data-server", + "sha256": "9505d4d64a68ad2a4fe49b49c639c2b73b8f4ef73e3236fb41e6d4bd82939a0c", + "size": 3333224, + "subdir": "linux-64", + "timestamp": 1633034947638, + "version": "0.6.0" + }, + "tensorboard-data-server-0.6.1-py310h52d8a92_0.tar.bz2": { + "build": "py310h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eb41f6f2f777b4a7ba6f8f652b1e8af6", + "name": "tensorboard-data-server", + "sha256": "a4e44305e61403ba2d6f2592ab8bec693b0c419c0503ac01b83a4a4ed806074a", + "size": 4391150, + "subdir": "linux-64", + "timestamp": 1670854556169, + "version": "0.6.1" + }, + "tensorboard-data-server-0.6.1-py37h52d8a92_0.tar.bz2": { + "build": "py37h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a55943ae716b64aec3d6f893691f91e8", + "name": "tensorboard-data-server", + "sha256": "a17f17f83e078da98c574dc4f0068a450a731ac4ccdb82bf9b3766596b53b64c", + "size": 4391732, + "subdir": "linux-64", + "timestamp": 1670853835552, + "version": "0.6.1" + }, + "tensorboard-data-server-0.6.1-py38h52d8a92_0.tar.bz2": { + "build": "py38h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9c1850a45b7060af7067ace3909d1c83", + "name": "tensorboard-data-server", + "sha256": "5c8736a50783d33d8159c3c08b9bbfbc21f4dbaff5526ce893e40f5f20246b2a", + "size": 4389337, + "subdir": "linux-64", + "timestamp": 1670854075242, + "version": "0.6.1" + }, + "tensorboard-data-server-0.6.1-py39h52d8a92_0.tar.bz2": { + "build": "py39h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "85aa99e300e1528b9a48d7102e85247d", + "name": "tensorboard-data-server", + "sha256": "282a1b24e216da50d8b12d86cf1d2b40552a705d25c7476fe7483c269f187199", + "size": 4390097, + "subdir": "linux-64", + "timestamp": 1670854315363, + "version": "0.6.1" + }, + "tensorboard-plugin-wit-1.8.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "24511128a6f40262d600ecc9b381f4dc", + "name": "tensorboard-plugin-wit", + "sha256": "f7b9985f79bf36a524a3dd709ed31ab30d18ea4e7103220233590ce6756d2d66", + "size": 723387, + "subdir": "linux-64", + "timestamp": 1658918566413, + "version": "1.8.1" + }, + "tensorboard-plugin-wit-1.8.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4e3794bd199a822c3b65d170780385b7", + "name": "tensorboard-plugin-wit", + "sha256": "b1b063912751dc4d1de564673c612e604f9081cc7441950111d43685e53f745b", + "size": 720972, + "subdir": "linux-64", + "timestamp": 1658918549227, + "version": "1.8.1" + }, + "tensorboard-plugin-wit-1.8.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ef0417c22506ab4554cd8f402bee8435", + "name": "tensorboard-plugin-wit", + "sha256": "54eba39695d32a72f0e134a64aafc3d6bfbe5e50c173c54ad04327ad4fabf659", + "size": 722919, + "subdir": "linux-64", + "timestamp": 1658918515390, + "version": "1.8.1" + }, + "tensorboard-plugin-wit-1.8.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aa17c5603c4a58957f3233bb5887d00f", + "name": "tensorboard-plugin-wit", + "sha256": "b109c50294b887d5313134986ee291b53f5d74963417d95b8f15f159d7e2ad69", + "size": 723422, + "subdir": "linux-64", + "timestamp": 1658918532558, + "version": "1.8.1" + }, + "tensorflow-1.10.0-eigen_py27ha0ab958_0.tar.bz2": { + "build": "eigen_py27ha0ab958_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 2.7.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 eigen_py27h4dcebc2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "39d734675fcd43f86b2963aa36b93420", + "name": "tensorflow", + "namespace": "python", + "sha256": "247f119ed4eb754083832f3c12b49463148398363dc4fe2e95663df31ee76ba1", + "size": 3876, + "subdir": "linux-64", + "timestamp": 1534981075689, + "version": "1.10.0" + }, + "tensorflow-1.10.0-eigen_py35h5ed898b_0.tar.bz2": { + "build": "eigen_py35h5ed898b_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.5.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 eigen_py35h4dcebc2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cd9e9a31b4c36470a531b5dfb5b86a57", + "name": "tensorflow", + "namespace": "python", + "sha256": "e1d85d9b2122fb8be97e6b6b125c6632202855d1bed8d56496eb31af6e579332", + "size": 3875, + "subdir": "linux-64", + "timestamp": 1534981088346, + "version": "1.10.0" + }, + "tensorflow-1.10.0-eigen_py36hb995bb4_0.tar.bz2": { + "build": "eigen_py36hb995bb4_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.6.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 eigen_py36h4dcebc2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5a3fcd145812d8038f948a5761a238a2", + "name": "tensorflow", + "namespace": "python", + "sha256": "6c225031f99fb2144227209fca9a5525e351b855046b8be18a816e455de0bbd4", + "size": 3866, + "subdir": "linux-64", + "timestamp": 1534981044542, + "version": "1.10.0" + }, + "tensorflow-1.10.0-gpu_py27h67ad7fe_0.tar.bz2": { + "build": "gpu_py27h67ad7fe_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 gpu_py27had579c0_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5c8d1e012fcc875e5a8fdd857913bbb4", + "name": "tensorflow", + "namespace": "python", + "sha256": "01a142a2595c1d6af6f2dd39f18010cbe372871a4a19ad2e9c1f09a2efdbb849", + "size": 3206, + "subdir": "linux-64", + "timestamp": 1534967611358, + "version": "1.10.0" + }, + "tensorflow-1.10.0-gpu_py27h6f941b3_0.tar.bz2": { + "build": "gpu_py27h6f941b3_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 gpu_py27h6ecc378_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ca4c7e37efa2c5ca118008007f82b597", + "name": "tensorflow", + "namespace": "python", + "sha256": "909c091bba1c3a782f61aa9b182cf4bcc658b37fff6ab9c8b4506253270a4867", + "size": 3224, + "subdir": "linux-64", + "timestamp": 1534982459611, + "version": "1.10.0" + }, + "tensorflow-1.10.0-gpu_py27h9580370_0.tar.bz2": { + "build": "gpu_py27h9580370_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 gpu_py27h3435052_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0a3550af31f91a6fd0cbd14437d505d5", + "name": "tensorflow", + "namespace": "python", + "sha256": "dff2ea635c35ea5091b13c1f34b0d4599ca992faf64b998005c318b313e8ca12", + "size": 3094, + "subdir": "linux-64", + "timestamp": 1534981728080, + "version": "1.10.0" + }, + "tensorflow-1.10.0-gpu_py35h566a776_0.tar.bz2": { + "build": "gpu_py35h566a776_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.5.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 gpu_py35h6ecc378_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "78e3c8ff2b05f9e78558674610f14cd8", + "name": "tensorflow", + "namespace": "python", + "sha256": "ce8a9d39aabb190202e58ef48b88665377de276ccddadc45a945eaca46677b86", + "size": 3231, + "subdir": "linux-64", + "timestamp": 1534982229867, + "version": "1.10.0" + }, + "tensorflow-1.10.0-gpu_py35ha6119f3_0.tar.bz2": { + "build": "gpu_py35ha6119f3_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.5.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 gpu_py35h3435052_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1cc5ad53c6d131f5761718ef064c1256", + "name": "tensorflow", + "namespace": "python", + "sha256": "0082bd5a715aea3a668b8ede3e91cfef2dc050d7d91c10eaa00ddd7297219461", + "size": 3081, + "subdir": "linux-64", + "timestamp": 1534981776295, + "version": "1.10.0" + }, + "tensorflow-1.10.0-gpu_py35hd9c640d_0.tar.bz2": { + "build": "gpu_py35hd9c640d_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.5.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 gpu_py35had579c0_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "349619253d7f83250182baef908b04d2", + "name": "tensorflow", + "namespace": "python", + "sha256": "afdcc0ce408ba6d7f0077922596a9b17d58da8fc4c01fd4674235747d2b7b562", + "size": 3211, + "subdir": "linux-64", + "timestamp": 1534967634500, + "version": "1.10.0" + }, + "tensorflow-1.10.0-gpu_py36h8dbd23f_0.tar.bz2": { + "build": "gpu_py36h8dbd23f_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 gpu_py36h3435052_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a3c74246d89c2a81251be184765c03b7", + "name": "tensorflow", + "namespace": "python", + "sha256": "9c1c638ce1e0427502a8fedeefd956f33c3b023984d545a8ad913635b2ec8e80", + "size": 3095, + "subdir": "linux-64", + "timestamp": 1534981800216, + "version": "1.10.0" + }, + "tensorflow-1.10.0-gpu_py36h97a2126_0.tar.bz2": { + "build": "gpu_py36h97a2126_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 gpu_py36h6ecc378_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5685c83d8a926053deb4a544f0b11c47", + "name": "tensorflow", + "namespace": "python", + "sha256": "3406a8196d0ca172b9e7ac22b919d8110126099b25f4ab02b3f316b3013734f7", + "size": 3230, + "subdir": "linux-64", + "timestamp": 1534982515526, + "version": "1.10.0" + }, + "tensorflow-1.10.0-gpu_py36hcebf108_0.tar.bz2": { + "build": "gpu_py36hcebf108_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 gpu_py36had579c0_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "daacffb726ccad90ec5aa9515bcf9f30", + "name": "tensorflow", + "namespace": "python", + "sha256": "3c7eb6db53ceb2f8911cb8fcbd3fa31fda9014a2dcd530d12069c73935fadc49", + "size": 3194, + "subdir": "linux-64", + "timestamp": 1534967591531, + "version": "1.10.0" + }, + "tensorflow-1.10.0-mkl_py27h857755f_0.tar.bz2": { + "build": "mkl_py27h857755f_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 2.7.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 mkl_py27h3c3e929_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "91bd21e7a746040a0a044b23bd464c2b", + "name": "tensorflow", + "namespace": "python", + "sha256": "9fb33c752fd3f3093e5be3c3abf5f8ed8ab53152a0a1ed6e7f98c0053ca5be79", + "size": 3881, + "subdir": "linux-64", + "timestamp": 1534981011463, + "version": "1.10.0" + }, + "tensorflow-1.10.0-mkl_py35heddcb22_0.tar.bz2": { + "build": "mkl_py35heddcb22_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.5.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 mkl_py35h3c3e929_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2d050c84e04dcf8f09e842ab87c52422", + "name": "tensorflow", + "namespace": "python", + "sha256": "49f819c2d038913bd78e70bf890e4edcaac23d77f9eb2d3dc3f8cb4aaead79d5", + "size": 3865, + "subdir": "linux-64", + "timestamp": 1534981058901, + "version": "1.10.0" + }, + "tensorflow-1.10.0-mkl_py36hdb377fd_0.tar.bz2": { + "build": "mkl_py36hdb377fd_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.6.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 mkl_py36h3c3e929_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "34d15b55888700e8369c0843332670e8", + "name": "tensorflow", + "namespace": "python", + "sha256": "affe157fd2555768acdf3e46de60b35633bd421b32dd28e1fa667bb678072de4", + "size": 3870, + "subdir": "linux-64", + "timestamp": 1534981027845, + "version": "1.10.0" + }, + "tensorflow-1.11.0-eigen_py27h06aee4b_0.tar.bz2": { + "build": "eigen_py27h06aee4b_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 2.7.*", + "tensorboard >=1.11.0,<1.12.0", + "tensorflow-base ==1.11.0 eigen_py27h4dcebc2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9e4d4e30d655c026b6b2a4d6491dbe33", + "name": "tensorflow", + "namespace": "python", + "sha256": "f1a1e9c14f24f1cb22bb0bb7bd046023ac42b6233c5424905b2782d764b227d1", + "size": 3608, + "subdir": "linux-64", + "timestamp": 1538592559093, + "version": "1.11.0" + }, + "tensorflow-1.11.0-eigen_py36he3f7ef1_0.tar.bz2": { + "build": "eigen_py36he3f7ef1_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.6.*", + "tensorboard >=1.11.0,<1.12.0", + "tensorflow-base ==1.11.0 eigen_py36h4dcebc2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "66fee9f102b9418e76df237f6344a68c", + "name": "tensorflow", + "namespace": "python", + "sha256": "ddfab78f284acc3818164b5bf8ddbd57f37fbba153b1fb009a3d69a573b2e3fc", + "size": 3610, + "subdir": "linux-64", + "timestamp": 1538592522142, + "version": "1.11.0" + }, + "tensorflow-1.11.0-gpu_py27h99ab47f_0.tar.bz2": { + "build": "gpu_py27h99ab47f_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.11.0,<1.12.0", + "tensorflow-base ==1.11.0 gpu_py27h8e0ae2d_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "717cb6f4cab992cf7c0e25449f0320b4", + "name": "tensorflow", + "namespace": "python", + "sha256": "c9ae54d24c2996c4e1d704161eca74e347e13e573be535cbce7343b781f3aa51", + "size": 3447, + "subdir": "linux-64", + "timestamp": 1538749320605, + "version": "1.11.0" + }, + "tensorflow-1.11.0-gpu_py27hd8bfc1a_0.tar.bz2": { + "build": "gpu_py27hd8bfc1a_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.11.0,<1.12.0", + "tensorflow-base ==1.11.0 gpu_py27had579c0_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b8d5d46d19b4390e5a93e1c2e1b6f761", + "name": "tensorflow", + "namespace": "python", + "sha256": "f1ec376253d2a3316849336bcb0946be3652299a39b0578f75def2012beea590", + "size": 3421, + "subdir": "linux-64", + "timestamp": 1538749727101, + "version": "1.11.0" + }, + "tensorflow-1.11.0-gpu_py36h4459f94_0.tar.bz2": { + "build": "gpu_py36h4459f94_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.11.0,<1.12.0", + "tensorflow-base ==1.11.0 gpu_py36h8e0ae2d_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "554f391498066b1556c2900e3d59b19f", + "name": "tensorflow", + "namespace": "python", + "sha256": "8417a275505bd1e3b0d542692fdfade9581668614bb834668af3188a0b847cdb", + "size": 3447, + "subdir": "linux-64", + "timestamp": 1538749080306, + "version": "1.11.0" + }, + "tensorflow-1.11.0-gpu_py36h9c9050a_0.tar.bz2": { + "build": "gpu_py36h9c9050a_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.11.0,<1.12.0", + "tensorflow-base ==1.11.0 gpu_py36had579c0_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c0f72f5a5f8ac9ba2f82411506c5f2ea", + "name": "tensorflow", + "namespace": "python", + "sha256": "a99637f9be5c43e9fe0cfd0a26886ed7f0863242d45fe328f610b7fb9f290010", + "size": 3411, + "subdir": "linux-64", + "timestamp": 1538749489335, + "version": "1.11.0" + }, + "tensorflow-1.11.0-mkl_py27h25e0b76_0.tar.bz2": { + "build": "mkl_py27h25e0b76_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 2.7.*", + "tensorboard >=1.11.0,<1.12.0", + "tensorflow-base ==1.11.0 mkl_py27h3c3e929_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "661f1999d5af3bad118e6812ed9df9f0", + "name": "tensorflow", + "namespace": "python", + "sha256": "bf5fc57ee1461c9afb8d1fba2c673cf37ab31b6e95c88711332837cee515b618", + "size": 3622, + "subdir": "linux-64", + "timestamp": 1538592540344, + "version": "1.11.0" + }, + "tensorflow-1.11.0-mkl_py36ha6f0bda_0.tar.bz2": { + "build": "mkl_py36ha6f0bda_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.6.*", + "tensorboard >=1.11.0,<1.12.0", + "tensorflow-base ==1.11.0 mkl_py36h3c3e929_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "eeca02e95b44e8c42373a91add1564f0", + "name": "tensorflow", + "namespace": "python", + "sha256": "a6288b2539d6dc6e8fe68c57a8cca5ce5f3da3a3b69f58b0b57d23f57338d2f8", + "size": 3604, + "subdir": "linux-64", + "timestamp": 1538592574420, + "version": "1.11.0" + }, + "tensorflow-1.12.0-eigen_py27hfe19c55_0.tar.bz2": { + "build": "eigen_py27hfe19c55_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 2.7.*", + "tensorboard >=1.12.0,<1.13.0", + "tensorflow-base ==1.12.0 eigen_py27h4dcebc2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1c3843422b15fcc3d7ab2eedca8f6fce", + "name": "tensorflow", + "namespace": "python", + "sha256": "eb95afe33a0ea46c12e4db689b58c098da1ee6f580a6ec65d656341a500e58f3", + "size": 3618, + "subdir": "linux-64", + "timestamp": 1542084162567, + "version": "1.12.0" + }, + "tensorflow-1.12.0-eigen_py36hbd5f568_0.tar.bz2": { + "build": "eigen_py36hbd5f568_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.6.*", + "tensorboard >=1.12.0,<1.13.0", + "tensorflow-base ==1.12.0 eigen_py36h4dcebc2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8b252a9d33221cd40efb04699308c41b", + "name": "tensorflow", + "namespace": "python", + "sha256": "e8a810a143ac7a6d6c82d928bd57b4fec4fa2e988be3802ade78878a4e28685d", + "size": 3611, + "subdir": "linux-64", + "timestamp": 1542084115670, + "version": "1.12.0" + }, + "tensorflow-1.12.0-gpu_py27h2a0f108_0.tar.bz2": { + "build": "gpu_py27h2a0f108_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.12.0,<1.13.0", + "tensorflow-base ==1.12.0 gpu_py27had579c0_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dbca50b34743fc75d90e3ba245dc4f4e", + "name": "tensorflow", + "namespace": "python", + "sha256": "8df54022bc8fcf5ee6a17bb99a36ccda474a956461050c64cf7f20ae2bd1a0f3", + "size": 3389, + "subdir": "linux-64", + "timestamp": 1542153436129, + "version": "1.12.0" + }, + "tensorflow-1.12.0-gpu_py27h956c076_0.tar.bz2": { + "build": "gpu_py27h956c076_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.12.0,<1.13.0", + "tensorflow-base ==1.12.0 gpu_py27h8e0ae2d_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "14a9b4ee18f024963070de193e8e7015", + "name": "tensorflow", + "namespace": "python", + "sha256": "468c7e4575b7bfa69aae9c75c7dc855a46538678d69c6f82a9dc2a2ba2a2e457", + "size": 3420, + "subdir": "linux-64", + "timestamp": 1542144658627, + "version": "1.12.0" + }, + "tensorflow-1.12.0-gpu_py36he68c306_0.tar.bz2": { + "build": "gpu_py36he68c306_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.12.0,<1.13.0", + "tensorflow-base ==1.12.0 gpu_py36h8e0ae2d_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5bb614150ef68a7f4cb2d4d30bff3a7f", + "name": "tensorflow", + "namespace": "python", + "sha256": "a8edf23376b86f151546d41506816bb0e1a635dae764d8e82a4196971c7e9dc4", + "size": 3418, + "subdir": "linux-64", + "timestamp": 1542144685899, + "version": "1.12.0" + }, + "tensorflow-1.12.0-gpu_py36he74679b_0.tar.bz2": { + "build": "gpu_py36he74679b_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.12.0,<1.13.0", + "tensorflow-base ==1.12.0 gpu_py36had579c0_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "484637949ca03b9299b5edcbf76f5f02", + "name": "tensorflow", + "namespace": "python", + "sha256": "205f121ba34ece7cd9aed288b54e5ce6007ad65f6a36a9cd49bcd00c059f69ac", + "size": 3369, + "subdir": "linux-64", + "timestamp": 1542153462926, + "version": "1.12.0" + }, + "tensorflow-1.12.0-mkl_py27hc55d17a_0.tar.bz2": { + "build": "mkl_py27hc55d17a_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 2.7.*", + "tensorboard >=1.12.0,<1.13.0", + "tensorflow-base ==1.12.0 mkl_py27h3c3e929_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b44a98c68b40ce23ca74a511b6c2ecea", + "name": "tensorflow", + "namespace": "python", + "sha256": "f8901998352a2d1a01b097d3eb77e03fe11a1477cdc836c4240434a829b6a383", + "size": 3618, + "subdir": "linux-64", + "timestamp": 1542084140716, + "version": "1.12.0" + }, + "tensorflow-1.12.0-mkl_py36h69b6ba0_0.tar.bz2": { + "build": "mkl_py36h69b6ba0_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.6.*", + "tensorboard >=1.12.0,<1.13.0", + "tensorflow-base ==1.12.0 mkl_py36h3c3e929_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0b829bc448ac1420ecbb9bebbc463ab5", + "name": "tensorflow", + "namespace": "python", + "sha256": "b9c25e95f5896eb2175208fe7946411ef91b4f7cab0e72de609310d8acb3a29a", + "size": 3615, + "subdir": "linux-64", + "timestamp": 1542084181377, + "version": "1.12.0" + }, + "tensorflow-1.13.1-eigen_py27h5e92bea_0.tar.bz2": { + "build": "eigen_py27h5e92bea_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 2.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 eigen_py27hf4a566f_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7648f56cb620fc7be25f04368308d256", + "name": "tensorflow", + "namespace": "python", + "sha256": "21c5fd8b247da495b31f292f6eeec63898c1ec609ae9961fa6e68176133730b2", + "size": 3763, + "subdir": "linux-64", + "timestamp": 1554327977844, + "version": "1.13.1" + }, + "tensorflow-1.13.1-eigen_py36hc59b85e_0.tar.bz2": { + "build": "eigen_py36hc59b85e_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.6.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 eigen_py36hf4a566f_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "90d8a0dcc5f855db154d16fc6c9d3a7f", + "name": "tensorflow", + "namespace": "python", + "sha256": "80c6f5489e5e77296cb568b9b6543cceabeff72e0360b3f293f16abdb1e2dd12", + "size": 3754, + "subdir": "linux-64", + "timestamp": 1554327952616, + "version": "1.13.1" + }, + "tensorflow-1.13.1-eigen_py37h7cb7401_0.tar.bz2": { + "build": "eigen_py37h7cb7401_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 eigen_py37hf4a566f_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b329f99fcc4bc1b2dbe5aa881214e79f", + "name": "tensorflow", + "namespace": "python", + "sha256": "618e7ea947354855e3c0db866a9ceae0fc470c95bf0f5f28465436b8a1cee9e7", + "size": 3767, + "subdir": "linux-64", + "timestamp": 1554327902072, + "version": "1.13.1" + }, + "tensorflow-1.13.1-gpu_py27hc5faae7_0.tar.bz2": { + "build": "gpu_py27hc5faae7_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 gpu_py27h611c6d2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8161856803b95e6f5c7992b0a20c178b", + "name": "tensorflow", + "namespace": "python", + "sha256": "d5de49334b9d51fcb22274159a130ea9b83d96efeeb258a03ef025fac95c9a64", + "size": 3694, + "subdir": "linux-64", + "timestamp": 1554467552087, + "version": "1.13.1" + }, + "tensorflow-1.13.1-gpu_py27hcb41dfa_0.tar.bz2": { + "build": "gpu_py27hcb41dfa_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 gpu_py27h8d69cac_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5a9752c98021f4992f17497678a62d67", + "name": "tensorflow", + "namespace": "python", + "sha256": "706f497b1105ce0c5ab6f69bdbb02f42e2bf239b1c6b73b40945bb39e3005a50", + "size": 3672, + "subdir": "linux-64", + "timestamp": 1554431543520, + "version": "1.13.1" + }, + "tensorflow-1.13.1-gpu_py27hd3b962e_0.tar.bz2": { + "build": "gpu_py27hd3b962e_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 gpu_py27h8f37b9b_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c5856e43ca613d84b720a42a7fbb834f", + "name": "tensorflow", + "namespace": "python", + "sha256": "175e3c9fdbd985fa6abec7f79a823213f4a5964385cf51e6298a3c8d78a3dc37", + "size": 3687, + "subdir": "linux-64", + "timestamp": 1554491874865, + "version": "1.13.1" + }, + "tensorflow-1.13.1-gpu_py36h26cf82e_0.tar.bz2": { + "build": "gpu_py36h26cf82e_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 gpu_py36h8f37b9b_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8e36eb7fe07980e2e6c079b2da8f84d4", + "name": "tensorflow", + "namespace": "python", + "sha256": "865e67be66faeb75ee3e799c6d3de1443c50394ebe84441fbdba7cada97d80ed", + "size": 3699, + "subdir": "linux-64", + "timestamp": 1554491850327, + "version": "1.13.1" + }, + "tensorflow-1.13.1-gpu_py36h3991807_0.tar.bz2": { + "build": "gpu_py36h3991807_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 gpu_py36h8d69cac_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "86dfeeb3a6cee1f85652b078f302fd96", + "name": "tensorflow", + "namespace": "python", + "sha256": "af679431e02350d2ef1359ac075e8aabc3acf47bf122e2416768328af9110ac6", + "size": 3684, + "subdir": "linux-64", + "timestamp": 1554431545088, + "version": "1.13.1" + }, + "tensorflow-1.13.1-gpu_py36h9b25d83_0.tar.bz2": { + "build": "gpu_py36h9b25d83_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 gpu_py36h611c6d2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "22d4229599567128cdec5f60147b8ac9", + "name": "tensorflow", + "namespace": "python", + "sha256": "634f94bcf1b93e23890805a8b4240cbea34a5171da53047da15398c5db9a0ecd", + "size": 3678, + "subdir": "linux-64", + "timestamp": 1554467577127, + "version": "1.13.1" + }, + "tensorflow-1.13.1-gpu_py37h49933a4_0.tar.bz2": { + "build": "gpu_py37h49933a4_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 gpu_py37h611c6d2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9a7377de95eb4b7a93513287bc7fc0a7", + "name": "tensorflow", + "namespace": "python", + "sha256": "3ff128a1c54de56f0bd3283a22ffdb66e9416b766d8a2dd153a637b2175f7640", + "size": 3677, + "subdir": "linux-64", + "timestamp": 1554467601808, + "version": "1.13.1" + }, + "tensorflow-1.13.1-gpu_py37hc158e3b_0.tar.bz2": { + "build": "gpu_py37hc158e3b_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 gpu_py37h8d69cac_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4141d27fb369a41eb7c6850690d175e7", + "name": "tensorflow", + "namespace": "python", + "sha256": "fde7d571b9f323c347a69dfa13f140675c59542a98ceb9c452452095da09fdd4", + "size": 3668, + "subdir": "linux-64", + "timestamp": 1554431544323, + "version": "1.13.1" + }, + "tensorflow-1.13.1-gpu_py37hd37c573_0.tar.bz2": { + "build": "gpu_py37hd37c573_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 gpu_py37h8f37b9b_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8d5b0ca00d3376cdcd75d6f448b960ae", + "name": "tensorflow", + "namespace": "python", + "sha256": "14809ab93dcda1f1b18d23268d5e9810c11ba540a8d2b00ac2ebb6238812966d", + "size": 3675, + "subdir": "linux-64", + "timestamp": 1554491827785, + "version": "1.13.1" + }, + "tensorflow-1.13.1-mkl_py27h74ee40f_0.tar.bz2": { + "build": "mkl_py27h74ee40f_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 2.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 mkl_py27h7ce6ba3_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "79c8e669a0bea1a220082bd727801ba0", + "name": "tensorflow", + "namespace": "python", + "sha256": "349de5803c2799928a2b85b4eca98de84b2f819241426c6defe05dfc5613bce8", + "size": 3776, + "subdir": "linux-64", + "timestamp": 1554328027396, + "version": "1.13.1" + }, + "tensorflow-1.13.1-mkl_py36h27d456a_0.tar.bz2": { + "build": "mkl_py36h27d456a_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.6.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 mkl_py36h7ce6ba3_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2f44ef2b3c811060d72a58424539d576", + "name": "tensorflow", + "namespace": "python", + "sha256": "35bcc74225dbc53a7941ae11d5d7cca6c6080abbe0ad2d59e209e1f16e6278c9", + "size": 3759, + "subdir": "linux-64", + "timestamp": 1554327927772, + "version": "1.13.1" + }, + "tensorflow-1.13.1-mkl_py37h54b294f_0.tar.bz2": { + "build": "mkl_py37h54b294f_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 mkl_py37h7ce6ba3_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "73a065f63291a4fd6b06c8b8e4452777", + "name": "tensorflow", + "namespace": "python", + "sha256": "e45deaf7bb615fe3d49b8562e8b61e96a07c1bec359c778311af0f613cae3bff", + "size": 3763, + "subdir": "linux-64", + "timestamp": 1554328003023, + "version": "1.13.1" + }, + "tensorflow-1.14.0-eigen_py27h99c1539_0.tar.bz2": { + "build": "eigen_py27h99c1539_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 2.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 eigen_py27hf4a566f_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5ab95e90baac622cea104f1fdb6f2439", + "name": "tensorflow", + "namespace": "python", + "sha256": "b1ad00102726b7d1b458a691b02ee8d51fa21eb85c2442e05f2f84038720b8b6", + "size": 3693, + "subdir": "linux-64", + "timestamp": 1561050024368, + "version": "1.14.0" + }, + "tensorflow-1.14.0-eigen_py36hb2cf719_0.tar.bz2": { + "build": "eigen_py36hb2cf719_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.6.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 eigen_py36hf4a566f_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bf27f85758955b73d5cd02937037ad78", + "name": "tensorflow", + "namespace": "python", + "sha256": "0ca8f5c65284c1e65217401cd9e94dc2ff9bbe71bf24c4162b80fbd0a37d283d", + "size": 3707, + "subdir": "linux-64", + "timestamp": 1561050050421, + "version": "1.14.0" + }, + "tensorflow-1.14.0-eigen_py37h195cb1b_0.tar.bz2": { + "build": "eigen_py37h195cb1b_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 eigen_py37hf4a566f_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "45270e88c5909062818ebe12fe45a179", + "name": "tensorflow", + "namespace": "python", + "sha256": "f8270c85412e8feb42c507c0e82de412f3d586a3f70ce55dd655cb18b8508023", + "size": 3700, + "subdir": "linux-64", + "timestamp": 1561049925182, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py27h39f1c70_0.tar.bz2": { + "build": "gpu_py27h39f1c70_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py27he45bfe2_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c0f5ab422c385d2881ad64c84e2955eb", + "name": "tensorflow", + "namespace": "python", + "sha256": "e4f892ca190de649afb0235a21c7417a6ad810667309708027adf7f221219cdf", + "size": 3811, + "subdir": "linux-64", + "timestamp": 1561649415809, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py27h48701d4_0.tar.bz2": { + "build": "gpu_py27h48701d4_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py27h611c6d2_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2f8f756ea2cb4f8570d895113d92ff85", + "name": "tensorflow", + "namespace": "python", + "sha256": "616f38f411aa2448f68b44101d9f8208b0912308d337b6c6d2d5c8ea8740d939", + "size": 3712, + "subdir": "linux-64", + "timestamp": 1561554688858, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py27h84ace93_0.tar.bz2": { + "build": "gpu_py27h84ace93_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py27h8f37b9b_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "14e6a31276a59d47d5f1ceeb7a49e73c", + "name": "tensorflow", + "namespace": "python", + "sha256": "607fe6b0b9b1e413c5acf59b27f80ec509657ad375fa4deea07f1f4a144d8b11", + "size": 3723, + "subdir": "linux-64", + "timestamp": 1561537496289, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py27he9627f8_0.tar.bz2": { + "build": "gpu_py27he9627f8_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py27h8d69cac_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b721575bb7a89d4332185568de78ddf8", + "name": "tensorflow", + "namespace": "python", + "sha256": "fbee2af997a97d8c0fc690da21a231103850c9172abe6fb30d5867bed65aac37", + "size": 3729, + "subdir": "linux-64", + "timestamp": 1561577155101, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py36h3fb9ad6_0.tar.bz2": { + "build": "gpu_py36h3fb9ad6_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py36he45bfe2_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a1da5dddc961f90d053c9ae7e835765c", + "name": "tensorflow", + "namespace": "python", + "sha256": "10416cafdb08b9736baa17447e8a738d1adaba399a76b4b34fd27b70f1eb45b0", + "size": 3803, + "subdir": "linux-64", + "timestamp": 1561649453408, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py36h57aa796_0.tar.bz2": { + "build": "gpu_py36h57aa796_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py36h8d69cac_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b2dcb6caedfb2611c57e61bb6f07b688", + "name": "tensorflow", + "namespace": "python", + "sha256": "b563db5ede72bac9e1017d7e44fa962c73d3e7a1d43819172aa9e947835047db", + "size": 3726, + "subdir": "linux-64", + "timestamp": 1561577125099, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py36hc335bb8_0.tar.bz2": { + "build": "gpu_py36hc335bb8_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py36h8f37b9b_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "10aa01c543ba69149004e3b26f718353", + "name": "tensorflow", + "namespace": "python", + "sha256": "76ac920ca6d80cff5d820610f998e3d277655e0449724bab113c3a5e6601ef67", + "size": 3739, + "subdir": "linux-64", + "timestamp": 1561537513555, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py36hfc5689a_0.tar.bz2": { + "build": "gpu_py36hfc5689a_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py36h611c6d2_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "916c50bb968624d892f0bfaab39d3d08", + "name": "tensorflow", + "namespace": "python", + "sha256": "746477fcf436c4ef957b9e9f3aaa1b51ef1fea213fdc04bce0443e21ac562745", + "size": 3713, + "subdir": "linux-64", + "timestamp": 1561554662946, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py37h4491b45_0.tar.bz2": { + "build": "gpu_py37h4491b45_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py37h8d69cac_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b61d1aea503818573c727a977dbebb68", + "name": "tensorflow", + "namespace": "python", + "sha256": "3d8053cc40495d9418817c04e343c0bb726f9803a35b09e1c320a7cbd3b279bc", + "size": 3731, + "subdir": "linux-64", + "timestamp": 1561577184143, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py37h63f5f00_0.tar.bz2": { + "build": "gpu_py37h63f5f00_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py37h611c6d2_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0cd53e1c7f45791de83023640e105d33", + "name": "tensorflow", + "namespace": "python", + "sha256": "6e9653206b3b29e829f66825b59bcc8eaf887c6d75b4c43e31ec63aac59bd4a4", + "size": 3699, + "subdir": "linux-64", + "timestamp": 1561554637174, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py37h74c33d7_0.tar.bz2": { + "build": "gpu_py37h74c33d7_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py37he45bfe2_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "519c9a4cfb48d1c288093af105766797", + "name": "tensorflow", + "namespace": "python", + "sha256": "0506a1fe2eba2112d7c24a0bf0828fb7e0dbea06e28006e74a53c24a3380605c", + "size": 3807, + "subdir": "linux-64", + "timestamp": 1561649434543, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py37hae64822_0.tar.bz2": { + "build": "gpu_py37hae64822_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py37h8f37b9b_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bc847ee8343faf675f1a68c1134604fb", + "name": "tensorflow", + "namespace": "python", + "sha256": "d3037bad21083e53b81ede127fb969361af3d7d06b9fbb50ff15dc62211ce714", + "size": 3732, + "subdir": "linux-64", + "timestamp": 1561537476135, + "version": "1.14.0" + }, + "tensorflow-1.14.0-mkl_py27h957988d_0.tar.bz2": { + "build": "mkl_py27h957988d_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 2.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 mkl_py27h7ce6ba3_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "88a4fc7fe63b0e6dc1699ed3100149dd", + "name": "tensorflow", + "namespace": "python", + "sha256": "005e927e2699bafa4fa6022b888d19b792cb6765182710a7d8f0c0bd8b80c9ab", + "size": 3693, + "subdir": "linux-64", + "timestamp": 1561049975245, + "version": "1.14.0" + }, + "tensorflow-1.14.0-mkl_py36h2526735_0.tar.bz2": { + "build": "mkl_py36h2526735_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.6.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 mkl_py36h7ce6ba3_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8e867b1a5d480ece769be72c41616ea5", + "name": "tensorflow", + "namespace": "python", + "sha256": "2a499760c7afbec4020dd861ff7c8b2cf7b50cf153ed95b883e28519de4e3b58", + "size": 3704, + "subdir": "linux-64", + "timestamp": 1561049951605, + "version": "1.14.0" + }, + "tensorflow-1.14.0-mkl_py37h45c423b_0.tar.bz2": { + "build": "mkl_py37h45c423b_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 mkl_py37h7ce6ba3_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "94ebf831d2bb79d1238a913e237655a9", + "name": "tensorflow", + "namespace": "python", + "sha256": "660925385e768df7fafd1e9c4713e2defeb2473adebabe5e617dd10a0a4b303b", + "size": 3688, + "subdir": "linux-64", + "timestamp": 1561050000805, + "version": "1.14.0" + }, + "tensorflow-1.15.0-eigen_py27h7b7505e_0.tar.bz2": { + "build": "eigen_py27h7b7505e_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 2.7.*", + "tensorboard 1.15.*", + "tensorflow-base 1.15.0 eigen_py27hd4672e3_0", + "tensorflow-estimator 1.15.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "585622999fc054f399be3b0b3fb70a33", + "name": "tensorflow", + "namespace": "python", + "sha256": "e22ace464985593d3de102084b845452e5444dc4358957b5bb4b9a0930d952ff", + "size": 4059, + "subdir": "linux-64", + "timestamp": 1573244526098, + "version": "1.15.0" + }, + "tensorflow-1.15.0-eigen_py36hd3854b5_0.tar.bz2": { + "build": "eigen_py36hd3854b5_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.6.*", + "tensorboard 1.15.*", + "tensorflow-base 1.15.0 eigen_py36h52b156a_0", + "tensorflow-estimator 1.15.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e37e692caf071604bd6db0923b17dec0", + "name": "tensorflow", + "namespace": "python", + "sha256": "264a7dd54218c28a2837238582b0b10aed798415b80766f6ca053d2a02505d70", + "size": 4059, + "subdir": "linux-64", + "timestamp": 1573244417844, + "version": "1.15.0" + }, + "tensorflow-1.15.0-eigen_py37h3790f83_0.tar.bz2": { + "build": "eigen_py37h3790f83_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard 1.15.*", + "tensorflow-base 1.15.0 eigen_py37h52b156a_0", + "tensorflow-estimator 1.15.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f222c96c71e20c7244804b14aa3d348c", + "name": "tensorflow", + "namespace": "python", + "sha256": "2ee5625c74620744d8be5343ecf51611bdaad7a84bf444889cabb4f3f2fc9211", + "size": 4057, + "subdir": "linux-64", + "timestamp": 1573244493390, + "version": "1.15.0" + }, + "tensorflow-1.15.0-gpu_py27h0c9f15b_0.tar.bz2": { + "build": "gpu_py27h0c9f15b_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 2.7.*", + "tensorboard 1.15.*", + "tensorflow-base 1.15.0 gpu_py27hf473bbb_0", + "tensorflow-estimator 1.15.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "413a009b12e978c519f26240ed8bc210", + "name": "tensorflow", + "namespace": "python", + "sha256": "8701c865011a962518d1f8fab634bb8ee07fd89546d58bf91ab00182031a9bef", + "size": 3688, + "subdir": "linux-64", + "timestamp": 1573482360101, + "version": "1.15.0" + }, + "tensorflow-1.15.0-gpu_py36h5a509aa_0.tar.bz2": { + "build": "gpu_py36h5a509aa_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.6.*", + "tensorboard 1.15.*", + "tensorflow-base 1.15.0 gpu_py36h9dcbed7_0", + "tensorflow-estimator 1.15.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "198319e915a19c852f3f30475e04f3b2", + "name": "tensorflow", + "namespace": "python", + "sha256": "8e44d167b149c9e72672d517ba2d8fd603b9741c90bf7be8cef9f1cad4d5ffe4", + "size": 3682, + "subdir": "linux-64", + "timestamp": 1573482394523, + "version": "1.15.0" + }, + "tensorflow-1.15.0-gpu_py37h0f0df58_0.tar.bz2": { + "build": "gpu_py37h0f0df58_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.7.*", + "tensorboard 1.15.*", + "tensorflow-base 1.15.0 gpu_py37h9dcbed7_0", + "tensorflow-estimator 1.15.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "497b2a713a3bf7c47d956147e0ea806d", + "name": "tensorflow", + "namespace": "python", + "sha256": "a920208564e9979201225b6b6057ddc64b6cdd6eb7c18fd77af4bd9744ac4f86", + "size": 3685, + "subdir": "linux-64", + "timestamp": 1573482376003, + "version": "1.15.0" + }, + "tensorflow-1.15.0-mkl_py27hbe5f72a_0.tar.bz2": { + "build": "mkl_py27hbe5f72a_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 2.7.*", + "tensorboard 1.15.*", + "tensorflow-base 1.15.0 mkl_py27h503033c_0", + "tensorflow-estimator 1.15.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "45ba7f3879bbd0f6172090e9a1213e05", + "name": "tensorflow", + "namespace": "python", + "sha256": "d544ade1e23bca1413467f117ae5080532c8e11d3ac97a79269d393fc1185468", + "size": 4068, + "subdir": "linux-64", + "timestamp": 1573244562679, + "version": "1.15.0" + }, + "tensorflow-1.15.0-mkl_py36h4920b83_0.tar.bz2": { + "build": "mkl_py36h4920b83_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.6.*", + "tensorboard 1.15.*", + "tensorflow-base 1.15.0 mkl_py36he1670d9_0", + "tensorflow-estimator 1.15.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4aa0bf6c2aedccc97d6e7270a13b4879", + "name": "tensorflow", + "namespace": "python", + "sha256": "ea6d47084d8b538add923a0c2ca0d8c6dcec3fb7b935e3a0c846183ae09c1fde", + "size": 4057, + "subdir": "linux-64", + "timestamp": 1573244456783, + "version": "1.15.0" + }, + "tensorflow-1.15.0-mkl_py37h28c19af_0.tar.bz2": { + "build": "mkl_py37h28c19af_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard 1.15.*", + "tensorflow-base 1.15.0 mkl_py37he1670d9_0", + "tensorflow-estimator 1.15.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "125ca2c6bf307bec41a9204ee200d569", + "name": "tensorflow", + "namespace": "python", + "sha256": "7b7555200bbb78e105014de0d24b07c2a0fd23727964b457eeaa6487219ee055", + "size": 4056, + "subdir": "linux-64", + "timestamp": 1573244383231, + "version": "1.15.0" + }, + "tensorflow-1.4.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "tensorflow-base 1.4.1", + "tensorflow-tensorboard" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "28e9d8536df36553716d0194d2533fc0", + "name": "tensorflow", + "namespace": "python", + "sha256": "5dcf5c63dff0bffbd30ad670cef01a17b5d9cbcca197591c1529626da25ac393", + "size": 3341, + "subdir": "linux-64", + "timestamp": 1516404690814, + "version": "1.4.1" + }, + "tensorflow-1.5.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "tensorflow-base 1.5.0", + "tensorflow-tensorboard >=1.5.0,<1.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "df90645c9f1e16ac067d954b34fe2b9d", + "name": "tensorflow", + "namespace": "python", + "sha256": "4859b6eb2fe67a10bda4f51e887cd695ba0d65f5cf1c01e49a63851bc4bca2e2", + "size": 3376, + "subdir": "linux-64", + "timestamp": 1519700118780, + "version": "1.5.0" + }, + "tensorflow-1.6.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "tensorboard >=1.6.0,<1.7.0", + "tensorflow-base ==1.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fc64db4c059cd5d1f8633e9f64755053", + "name": "tensorflow", + "namespace": "python", + "sha256": "6ba0d6f8aa85f324e29fc431d3572cd17319b3d9eceb06fdb74fd1bbef3d9d3b", + "size": 3429, + "subdir": "linux-64", + "timestamp": 1521234256918, + "version": "1.6.0" + }, + "tensorflow-1.7.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "tensorboard >=1.7.0,<1.8.0", + "tensorflow-base ==1.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f9206487a30d0c1c3aa2adf5a9b0ea57", + "name": "tensorflow", + "namespace": "python", + "sha256": "6c0a05cfc98d316ab3685e0e362cb42ffd1b96e5653c3b67e1ebc20b221e293e", + "size": 3436, + "subdir": "linux-64", + "timestamp": 1524277365595, + "version": "1.7.0" + }, + "tensorflow-1.8.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base 1.8.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a3ab72e87df3b41dead62b94ad9c2e38", + "name": "tensorflow", + "namespace": "python", + "sha256": "5816afc2b564edd71e42ce45bd9faf3294acd4c72eb6b23382cdd5194ff1697b", + "size": 3869, + "subdir": "linux-64", + "timestamp": 1574087205039, + "version": "1.8.0" + }, + "tensorflow-1.8.0-h01c6a4e_0.tar.bz2": { + "build": "h01c6a4e_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.2.0 mkl", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py36hee38f2d_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "644b8ace4600cd119198fbe2499c666e", + "name": "tensorflow", + "namespace": "python", + "sha256": "acfb53b522571f9188ce78bd56125657309be86bd5ff274c4632bc40c6119ea3", + "size": 3294, + "subdir": "linux-64", + "timestamp": 1527093873244, + "version": "1.8.0" + }, + "tensorflow-1.8.0-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base 1.8.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "64a8e42bc7c5841a93bb177207fe8915", + "name": "tensorflow", + "namespace": "python", + "sha256": "7be8137d4bc1333801bb03a173dd516bd39e5e8fdc0017e54de702dadef92055", + "size": 3633, + "subdir": "linux-64", + "timestamp": 1642517607854, + "version": "1.8.0" + }, + "tensorflow-1.8.0-h16da8f2_0.tar.bz2": { + "build": "h16da8f2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.1.0 gpu", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py27hc1a7637_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f797a33f927c807168ae30edec1fc427", + "name": "tensorflow", + "namespace": "python", + "sha256": "a49e1186a46c47c92e28b478fd5daa6cf415ce754af78926d3110a581fd70de6", + "size": 5459, + "subdir": "linux-64", + "timestamp": 1527183535099, + "version": "1.8.0" + }, + "tensorflow-1.8.0-h2742514_0.tar.bz2": { + "build": "h2742514_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.2.0 mkl", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py35hee38f2d_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b1f6c8bcf78409d6bba07b7a8dc6a3ad", + "name": "tensorflow", + "namespace": "python", + "sha256": "ea4c071a863dd794307771e94a428be8b24494eddd3fc608b77cd75cd440a505", + "size": 3304, + "subdir": "linux-64", + "timestamp": 1527093866984, + "version": "1.8.0" + }, + "tensorflow-1.8.0-h469b60b_0.tar.bz2": { + "build": "h469b60b_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.3.0 eigen", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py35h5f64886_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "99e915fd0d5153eaf52c799bcd1e36f7", + "name": "tensorflow", + "namespace": "python", + "sha256": "41202138c50c2db58aa3cb4c2216052d7360957a4a6f0beaaaa723cffcc19c61", + "size": 3323, + "subdir": "linux-64", + "timestamp": 1527093873485, + "version": "1.8.0" + }, + "tensorflow-1.8.0-h57681fa_0.tar.bz2": { + "build": "h57681fa_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.3.0 eigen", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py36h5f64886_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1333c088ff0b87bd818b02207a49a246", + "name": "tensorflow", + "namespace": "python", + "sha256": "b8e04613ab47798e9ab41b84680ae17058341c7dc6dec63335975890b7d6ffd7", + "size": 3312, + "subdir": "linux-64", + "timestamp": 1527093887495, + "version": "1.8.0" + }, + "tensorflow-1.8.0-h5c3c37f_0.tar.bz2": { + "build": "h5c3c37f_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.1.0 gpu", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py27h4df133c_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a182b8398940e5bf1b6b9b9041414eea", + "name": "tensorflow", + "namespace": "python", + "sha256": "ec8346c47df57bd8c4c2a10310fad9b30ddab3d8350cf357d3c3e1738332689e", + "size": 5434, + "subdir": "linux-64", + "timestamp": 1527183455976, + "version": "1.8.0" + }, + "tensorflow-1.8.0-h645107b_0.tar.bz2": { + "build": "h645107b_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.1.0 gpu", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py35h4df133c_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "75ab87db78b9e40fd16c68e9424af60b", + "name": "tensorflow", + "namespace": "python", + "sha256": "f958414d48265d29bede3fd50e49c852ec869a564e7082e22fcac6db0a54e14c", + "size": 5442, + "subdir": "linux-64", + "timestamp": 1527183484983, + "version": "1.8.0" + }, + "tensorflow-1.8.0-h7b2774c_0.tar.bz2": { + "build": "h7b2774c_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.3.0 eigen", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py27h5f64886_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "92f063dddd8f8b76bfb38b77ca370f93", + "name": "tensorflow", + "namespace": "python", + "sha256": "675c4049779705095eeae4f277609d5a0957cc0c4cd2dddf9226da79a163fc07", + "size": 3314, + "subdir": "linux-64", + "timestamp": 1527093875009, + "version": "1.8.0" + }, + "tensorflow-1.8.0-hb11d968_0.tar.bz2": { + "build": "hb11d968_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.1.0 gpu", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py36hc1a7637_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9000f2137794bdd3fca3a85d13d26d29", + "name": "tensorflow", + "namespace": "python", + "sha256": "c5cd854902163e449b69dadeb2b18df66912759a4a49f3ec617713cedc37d693", + "size": 5461, + "subdir": "linux-64", + "timestamp": 1527183646691, + "version": "1.8.0" + }, + "tensorflow-1.8.0-hb1b1514_0.tar.bz2": { + "build": "hb1b1514_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.2.0 mkl", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py27hee38f2d_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b45e718ab633bb9994ad4617d8e24600", + "name": "tensorflow", + "namespace": "python", + "sha256": "9401eb72f64b3288f1c8eeb696aaa23175a6c51088f9e21a2a1ec0251062400f", + "size": 3311, + "subdir": "linux-64", + "timestamp": 1527093869507, + "version": "1.8.0" + }, + "tensorflow-1.8.0-hb381393_0.tar.bz2": { + "build": "hb381393_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.1.0 gpu", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py36h4df133c_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e28774d91de96871d279f6900c79d49f", + "name": "tensorflow", + "namespace": "python", + "sha256": "4e4056ca4ee9fcec05477b344c6ee6c9afb8858fabac9683af7e2e494a6bbf3c", + "size": 5444, + "subdir": "linux-64", + "timestamp": 1527183510036, + "version": "1.8.0" + }, + "tensorflow-1.8.0-hc2d9325_0.tar.bz2": { + "build": "hc2d9325_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.1.0 gpu", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py35hc1a7637_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "31d507272c5dec43b9e47b2cb40d2888", + "name": "tensorflow", + "namespace": "python", + "sha256": "3759424511008c4c696da8b52103367b764499041da295e271001b89d6a8ac9e", + "size": 5438, + "subdir": "linux-64", + "timestamp": 1527183562443, + "version": "1.8.0" + }, + "tensorflow-1.9.0-eigen_py27hf386fcc_1.tar.bz2": { + "build": "eigen_py27hf386fcc_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 2.7.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 eigen_py27hdfca3bf_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a274d8842af2fd749454207f0de5d22c", + "name": "tensorflow", + "namespace": "python", + "sha256": "5146b21a68c44b2431c7b08e2ca9a1158d0cba095621ecac7efac6e3157126e3", + "size": 2998, + "subdir": "linux-64", + "timestamp": 1532705185399, + "version": "1.9.0" + }, + "tensorflow-1.9.0-eigen_py35h8c89287_1.tar.bz2": { + "build": "eigen_py35h8c89287_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.5.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 eigen_py35hdfca3bf_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "060212e60529e6e2a0c52c624b097c2f", + "name": "tensorflow", + "namespace": "python", + "sha256": "a558d84bc6d0aabc5f3396ee71691ab5a0037911bfb6849e3323a35ffcb3f745", + "size": 3005, + "subdir": "linux-64", + "timestamp": 1532705162496, + "version": "1.9.0" + }, + "tensorflow-1.9.0-eigen_py36h8c89287_0.tar.bz2": { + "build": "eigen_py36h8c89287_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.5.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 eigen_py35hdfca3bf_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "95b7fcf4b1b913cc930110dc34b02e6e", + "name": "tensorflow", + "namespace": "python", + "sha256": "1c67e8a8b2b42acfa1678f51e3d826055527fe3a1278b232bbfdff70c3a60f8c", + "size": 3135, + "subdir": "linux-64", + "timestamp": 1532470386666, + "version": "1.9.0" + }, + "tensorflow-1.9.0-eigen_py36hbec2359_0.tar.bz2": { + "build": "eigen_py36hbec2359_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.6.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 eigen_py36hdfca3bf_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6ee6ba9a1332fb0423e3c5b2921916ad", + "name": "tensorflow", + "namespace": "python", + "sha256": "51b5ffbb87715c4c2b837a24fb0ee6248e08532531bb09cd3d43b946fe42464e", + "size": 3103, + "subdir": "linux-64", + "timestamp": 1532470428812, + "version": "1.9.0" + }, + "tensorflow-1.9.0-eigen_py36hbec2359_1.tar.bz2": { + "build": "eigen_py36hbec2359_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.6.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 eigen_py36hdfca3bf_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "25ca0a38dd2c887faf405b97a3cffa64", + "name": "tensorflow", + "namespace": "python", + "sha256": "5c4f973a7fa5ac5a4c818355ef4c89c9af407556a146ba8ff36763b42d8ad84e", + "size": 2989, + "subdir": "linux-64", + "timestamp": 1532705208427, + "version": "1.9.0" + }, + "tensorflow-1.9.0-eigen_py36hf386fcc_0.tar.bz2": { + "build": "eigen_py36hf386fcc_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 2.7.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 eigen_py27hdfca3bf_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b0f31069a7462a01fdb9d24e77d9cb7e", + "name": "tensorflow", + "namespace": "python", + "sha256": "80e10773d84735d2cd15e1a84896fbec4a7c3ac86db3d944a82e8e192196af23", + "size": 3122, + "subdir": "linux-64", + "timestamp": 1532470443204, + "version": "1.9.0" + }, + "tensorflow-1.9.0-gpu_py27h233f449_1.tar.bz2": { + "build": "gpu_py27h233f449_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 gpu_py27h9f529ab_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a0f40d16586d155a7324eec0b53b7efd", + "name": "tensorflow", + "namespace": "python", + "sha256": "a02e7a99ea18ae8d21e771c206e311225d3c3fa099a28963061210e2147cf8f3", + "size": 2981, + "subdir": "linux-64", + "timestamp": 1532704918005, + "version": "1.9.0" + }, + "tensorflow-1.9.0-gpu_py27h395d940_1.tar.bz2": { + "build": "gpu_py27h395d940_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 gpu_py27h9f529ab_1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "76c0e6ce794f6d0357bb37ab050d40aa", + "name": "tensorflow", + "namespace": "python", + "sha256": "ffe4c6691e679b50151122d8a458ff64ed076c26d3b56ff46c111b072056f563", + "size": 3190, + "subdir": "linux-64", + "timestamp": 1533839329679, + "version": "1.9.0" + }, + "tensorflow-1.9.0-gpu_py27hd3a791e_1.tar.bz2": { + "build": "gpu_py27hd3a791e_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 gpu_py27h6ecc378_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "34f2c62c9b145a3e57710eead3c9a10d", + "name": "tensorflow", + "namespace": "python", + "sha256": "ef5bb17c500283306bb6296af8ba71804bce20bc75fe883ad9096b0cf052aef0", + "size": 3120, + "subdir": "linux-64", + "timestamp": 1532706311823, + "version": "1.9.0" + }, + "tensorflow-1.9.0-gpu_py35h42d5ad8_1.tar.bz2": { + "build": "gpu_py35h42d5ad8_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.5.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 gpu_py35h6ecc378_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b8c9691f8cf1f574902a0eab252ef1ec", + "name": "tensorflow", + "namespace": "python", + "sha256": "a1c3f4872cfc3f77eacbd81397e10c2d92a51099b780be6e91b0b0856d0e3698", + "size": 3118, + "subdir": "linux-64", + "timestamp": 1532706247485, + "version": "1.9.0" + }, + "tensorflow-1.9.0-gpu_py35h60c0932_1.tar.bz2": { + "build": "gpu_py35h60c0932_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.5.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 gpu_py35h9f529ab_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "11af65a23ad32fa349387b845fa01f62", + "name": "tensorflow", + "namespace": "python", + "sha256": "327bb5f33b86c568d9522d7f6222192b429fc74a3ab39b2361624a1d8143014f", + "size": 2973, + "subdir": "linux-64", + "timestamp": 1532704883176, + "version": "1.9.0" + }, + "tensorflow-1.9.0-gpu_py35hb39db67_1.tar.bz2": { + "build": "gpu_py35hb39db67_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.5.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 gpu_py35h9f529ab_1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "99dbd875b3d54b26b25aa4300dde63c5", + "name": "tensorflow", + "namespace": "python", + "sha256": "54652f168dfcbc08a9030cc675360daf64ce16dbc903ff50cc807b26c4c65ecb", + "size": 3194, + "subdir": "linux-64", + "timestamp": 1533839278028, + "version": "1.9.0" + }, + "tensorflow-1.9.0-gpu_py36h02c5d5e_1.tar.bz2": { + "build": "gpu_py36h02c5d5e_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 gpu_py36h6ecc378_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8b4bcafe529f91b7571824242622a0af", + "name": "tensorflow", + "namespace": "python", + "sha256": "ea88df4db17b9e6e70b6a454e85136b2ecc0dbc9c7fa4c38a585636aaa74775c", + "size": 3112, + "subdir": "linux-64", + "timestamp": 1532706292898, + "version": "1.9.0" + }, + "tensorflow-1.9.0-gpu_py36h220e158_1.tar.bz2": { + "build": "gpu_py36h220e158_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 gpu_py36h9f529ab_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ceb4ecd0d565e81893b12e6d89d9191f", + "name": "tensorflow", + "namespace": "python", + "sha256": "ada7013162575a2e105e1a64b11f3b1849d2ed5e2f813d82455eb779ad42967f", + "size": 2977, + "subdir": "linux-64", + "timestamp": 1532704900341, + "version": "1.9.0" + }, + "tensorflow-1.9.0-gpu_py36h313df88_1.tar.bz2": { + "build": "gpu_py36h313df88_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 gpu_py36h9f529ab_1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c16a0771d5e4164c108935cfee4f8380", + "name": "tensorflow", + "namespace": "python", + "sha256": "ef43b3e300305eff5bd1b5f26496fde52074b3d5c9bcf55f10da0248b30cf64f", + "size": 3184, + "subdir": "linux-64", + "timestamp": 1533839379022, + "version": "1.9.0" + }, + "tensorflow-1.9.0-mkl_py27h0cb61a4_1.tar.bz2": { + "build": "mkl_py27h0cb61a4_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 2.7.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 mkl_py27h2ca6a6a_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ca85630e444ef5b2bccc2fd02baebe3b", + "name": "tensorflow", + "namespace": "python", + "sha256": "ec74122388f8c721117fafe60a46f65c815f727d472a3def96d3d38e3d73e648", + "size": 2982, + "subdir": "linux-64", + "timestamp": 1532705231282, + "version": "1.9.0" + }, + "tensorflow-1.9.0-mkl_py35h5be851a_1.tar.bz2": { + "build": "mkl_py35h5be851a_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.5.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 mkl_py35h2ca6a6a_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b8dfd83097638c36084e11962c111547", + "name": "tensorflow", + "namespace": "python", + "sha256": "879058bb68f29c2de8a4bcc9c548c0f3c5ee8a9b3406765c0a8f2adb624a45d0", + "size": 2989, + "subdir": "linux-64", + "timestamp": 1532705131013, + "version": "1.9.0" + }, + "tensorflow-1.9.0-mkl_py36h0cb61a4_0.tar.bz2": { + "build": "mkl_py36h0cb61a4_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 2.7.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 mkl_py27h2ca6a6a_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "280152af77f0fbc30e9c720a91fba3ea", + "name": "tensorflow", + "namespace": "python", + "sha256": "84d275d2f85b563c391512c643ae53e38b466696bd0541fa7886bfb361b7cd77", + "size": 3115, + "subdir": "linux-64", + "timestamp": 1532470399230, + "version": "1.9.0" + }, + "tensorflow-1.9.0-mkl_py36h5be851a_0.tar.bz2": { + "build": "mkl_py36h5be851a_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.5.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 mkl_py35h2ca6a6a_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "17e2185cb3db912aab673bd1615d5662", + "name": "tensorflow", + "namespace": "python", + "sha256": "dbbc8b6e914decb6b7ba2a94bc0cefe588d92e561040569c5a890e164fe50520", + "size": 3108, + "subdir": "linux-64", + "timestamp": 1532470414002, + "version": "1.9.0" + }, + "tensorflow-1.9.0-mkl_py36h6d6ce78_0.tar.bz2": { + "build": "mkl_py36h6d6ce78_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.6.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 mkl_py36h2ca6a6a_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6576768f094b0e09c0c9777be15597a7", + "name": "tensorflow", + "namespace": "python", + "sha256": "c6c05ac14f45bfc3175735c0e01101027ebc0edbdc1119070801198f5e23b643", + "size": 3102, + "subdir": "linux-64", + "timestamp": 1532470455646, + "version": "1.9.0" + }, + "tensorflow-1.9.0-mkl_py36h6d6ce78_1.tar.bz2": { + "build": "mkl_py36h6d6ce78_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.6.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 mkl_py36h2ca6a6a_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f532103c206f18b59da53d2e5b28f5a3", + "name": "tensorflow", + "namespace": "python", + "sha256": "140541a8c66d5edf4abe729f5bac838fef19e6c9f3bb1f9b3fc04d4e8783c344", + "size": 2978, + "subdir": "linux-64", + "timestamp": 1532705099883, + "version": "1.9.0" + }, + "tensorflow-2.0.0-eigen_py27hec4e49e_0.tar.bz2": { + "build": "eigen_py27hec4e49e_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 2.7.*", + "tensorboard >=2.0.0", + "tensorflow-base 2.0.0 eigen_py27hce92a77_0", + "tensorflow-estimator >=2.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a8a0a04f3e3831bd199525f5950cfef4", + "name": "tensorflow", + "namespace": "python", + "sha256": "67ed7adf6541f21fdbbbf28b2814a26c7455ea9ee33c52c56fccf240a8f503b7", + "size": 3488, + "subdir": "linux-64", + "timestamp": 1571761788108, + "version": "2.0.0" + }, + "tensorflow-2.0.0-eigen_py36ha83d16c_0.tar.bz2": { + "build": "eigen_py36ha83d16c_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.6.*", + "tensorboard >=2.0.0", + "tensorflow-base 2.0.0 eigen_py36h4ed9498_0", + "tensorflow-estimator >=2.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "662df161da8b9298afef4d273556465c", + "name": "tensorflow", + "namespace": "python", + "sha256": "309e24460043efada2db19d9075d74f632511a30491b465df0cf5078ce764f36", + "size": 3500, + "subdir": "linux-64", + "timestamp": 1571761804510, + "version": "2.0.0" + }, + "tensorflow-2.0.0-eigen_py37hce6be7f_0.tar.bz2": { + "build": "eigen_py37hce6be7f_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard >=2.0.0", + "tensorflow-base 2.0.0 eigen_py37h4ed9498_0", + "tensorflow-estimator >=2.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cf15c8607544f78bf5c98c055b2e5038", + "name": "tensorflow", + "namespace": "python", + "sha256": "980a1348cc25e5cfab3cea3dc4b223bc1637ad6c5f98725f73fe34728e22ef45", + "size": 3487, + "subdir": "linux-64", + "timestamp": 1571761828151, + "version": "2.0.0" + }, + "tensorflow-2.0.0-gpu_py27hb041a2f_0.tar.bz2": { + "build": "gpu_py27hb041a2f_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 2.7.*", + "tensorboard >=2.0.0", + "tensorflow-base 2.0.0 gpu_py27h356bb79_0", + "tensorflow-estimator >=2.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0ecebf41a1151548b21e328582f851cc", + "name": "tensorflow", + "namespace": "python", + "sha256": "657d4a80a3a7af3a2a20fcf784a42ae494be9e032892ff2b5644f4d9fde7678c", + "size": 3506, + "subdir": "linux-64", + "timestamp": 1571762070716, + "version": "2.0.0" + }, + "tensorflow-2.0.0-gpu_py36h6b29c10_0.tar.bz2": { + "build": "gpu_py36h6b29c10_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.6.*", + "tensorboard >=2.0.0", + "tensorflow-base 2.0.0 gpu_py36h0ec5d1f_0", + "tensorflow-estimator >=2.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7ae52d5595642eddc398f6be63f14526", + "name": "tensorflow", + "namespace": "python", + "sha256": "f5476b0213c8424b5d100b0fc82a09da8240e760aa32591a4b0bb0c1bd5e8d98", + "size": 3515, + "subdir": "linux-64", + "timestamp": 1571762090866, + "version": "2.0.0" + }, + "tensorflow-2.0.0-gpu_py37h768510d_0.tar.bz2": { + "build": "gpu_py37h768510d_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.7.*", + "tensorboard >=2.0.0", + "tensorflow-base 2.0.0 gpu_py37h0ec5d1f_0", + "tensorflow-estimator >=2.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6548c400db72fdd428d446e2c4d3c39e", + "name": "tensorflow", + "namespace": "python", + "sha256": "d23654dfa78079fab826c4ddec98b37c07a936090035699a9b94ff5517deedf9", + "size": 3500, + "subdir": "linux-64", + "timestamp": 1571762052693, + "version": "2.0.0" + }, + "tensorflow-2.0.0-mkl_py27h68eb67f_0.tar.bz2": { + "build": "mkl_py27h68eb67f_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 2.7.*", + "tensorboard >=2.0.0", + "tensorflow-base 2.0.0 mkl_py27had7a488_0", + "tensorflow-estimator >=2.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "71f94ca03be6fc5cb25e873ee979de9e", + "name": "tensorflow", + "namespace": "python", + "sha256": "d77b549f1ba22a4d9ad96aacb87df159901bda6cced0546b27df325453fd2052", + "size": 3496, + "subdir": "linux-64", + "timestamp": 1571761771304, + "version": "2.0.0" + }, + "tensorflow-2.0.0-mkl_py36hef7ec59_0.tar.bz2": { + "build": "mkl_py36hef7ec59_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.6.*", + "tensorboard >=2.0.0", + "tensorflow-base 2.0.0 mkl_py36h9204916_0", + "tensorflow-estimator >=2.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6c27ab12fc87ab27884b88e531e7e280", + "name": "tensorflow", + "namespace": "python", + "sha256": "fa949d8a906eac8d982e6bfc43f9b1be9ac660ac04be0abbfcd7e93aa3ead03f", + "size": 3500, + "subdir": "linux-64", + "timestamp": 1571761865200, + "version": "2.0.0" + }, + "tensorflow-2.0.0-mkl_py37h66b46cc_0.tar.bz2": { + "build": "mkl_py37h66b46cc_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard >=2.0.0", + "tensorflow-base 2.0.0 mkl_py37h9204916_0", + "tensorflow-estimator >=2.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dc534c1f68afb18a52da681cb1c05a70", + "name": "tensorflow", + "namespace": "python", + "sha256": "22fb3c69e1d6f9fec95c920e6c52376eeab6d706070bc10ab65d081b415e31ce", + "size": 3495, + "subdir": "linux-64", + "timestamp": 1571761848920, + "version": "2.0.0" + }, + "tensorflow-2.1.0-eigen_py27h636cc2a_0.tar.bz2": { + "build": "eigen_py27h636cc2a_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 2.7.*", + "tensorboard >=2.1.0", + "tensorflow-base 2.1.0 eigen_py27hedad41d_0", + "tensorflow-estimator >=2.1.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "781790fb1b6f3352e24606ff645ce65b", + "name": "tensorflow", + "namespace": "python", + "sha256": "663dbcaa7db086ee1042ddd5efa097230a8abc5391e52e9253da2e123d107347", + "size": 4384, + "subdir": "linux-64", + "timestamp": 1582050527352, + "version": "2.1.0" + }, + "tensorflow-2.1.0-eigen_py36hbb90eaf_0.tar.bz2": { + "build": "eigen_py36hbb90eaf_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.6.*", + "tensorboard >=2.1.0", + "tensorflow-base 2.1.0 eigen_py36h0c57e5d_0", + "tensorflow-estimator >=2.1.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "138c9581f89f58714f4674980e03457e", + "name": "tensorflow", + "namespace": "python", + "sha256": "0523c93209c8bee6ce43d32573611b14e7cf5cd5762bf008de1ab195a7ec7d40", + "size": 4394, + "subdir": "linux-64", + "timestamp": 1582050492515, + "version": "2.1.0" + }, + "tensorflow-2.1.0-eigen_py37h1a52d58_0.tar.bz2": { + "build": "eigen_py37h1a52d58_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard >=2.1.0", + "tensorflow-base 2.1.0 eigen_py37h0c57e5d_0", + "tensorflow-estimator >=2.1.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4cd9afd09ed674997d25d32c00bff33a", + "name": "tensorflow", + "namespace": "python", + "sha256": "6e6095a828b2a815496bd371b9660bd66a1543688eda92d1f325719c63e32685", + "size": 4367, + "subdir": "linux-64", + "timestamp": 1582050647441, + "version": "2.1.0" + }, + "tensorflow-2.1.0-gpu_py27h9cdf9a9_0.tar.bz2": { + "build": "gpu_py27h9cdf9a9_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 2.7.*", + "tensorboard >=2.1.0", + "tensorflow-base 2.1.0 gpu_py27hb9b3ea8_0", + "tensorflow-estimator >=2.1.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dd87c290157bb366a6ce91005a2f5b15", + "name": "tensorflow", + "namespace": "python", + "sha256": "177589e43c02e446dfe04f58aa84b2de26e29df140f7cca2c0498805b73528ff", + "size": 3935, + "subdir": "linux-64", + "timestamp": 1582138611291, + "version": "2.1.0" + }, + "tensorflow-2.1.0-gpu_py36h2e5cdaa_0.tar.bz2": { + "build": "gpu_py36h2e5cdaa_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.6.*", + "tensorboard >=2.1.0", + "tensorflow-base 2.1.0 gpu_py36h6c5654b_0", + "tensorflow-estimator >=2.1.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3c59cf95800cd5f77e8d38e779bad11b", + "name": "tensorflow", + "namespace": "python", + "sha256": "54bb7bb61340754183e1e853baccaad38601c6d7800cf594ca3bc003fa58d0fd", + "size": 3603, + "subdir": "linux-64", + "timestamp": 1582138639872, + "version": "2.1.0" + }, + "tensorflow-2.1.0-gpu_py37h7a4bb67_0.tar.bz2": { + "build": "gpu_py37h7a4bb67_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.7.*", + "tensorboard >=2.1.0", + "tensorflow-base 2.1.0 gpu_py37h6c5654b_0", + "tensorflow-estimator >=2.1.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d39fe65512d37dd40799d9c42cbd7e75", + "name": "tensorflow", + "namespace": "python", + "sha256": "6b3ad5bcb743af9f55f5e32e710311b4ee676263e0ca841b482aece349ec7fc8", + "size": 3928, + "subdir": "linux-64", + "timestamp": 1582138667928, + "version": "2.1.0" + }, + "tensorflow-2.1.0-mkl_py27h9dbd782_0.tar.bz2": { + "build": "mkl_py27h9dbd782_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 2.7.*", + "tensorboard >=2.1.0", + "tensorflow-base 2.1.0 mkl_py27hb6fb96e_0", + "tensorflow-estimator >=2.1.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d70e15aee95cf7c8332fbf779397c42d", + "name": "tensorflow", + "namespace": "python", + "sha256": "aae8fb7e81d73f941f1a10994a4fbcc8c3a98bbf21472547f8d7bb3b2f419606", + "size": 4359, + "subdir": "linux-64", + "timestamp": 1582050559711, + "version": "2.1.0" + }, + "tensorflow-2.1.0-mkl_py36h23468d9_0.tar.bz2": { + "build": "mkl_py36h23468d9_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.6.*", + "tensorboard >=2.1.0", + "tensorflow-base 2.1.0 mkl_py36h6d63fb7_0", + "tensorflow-estimator >=2.1.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "52457fd81ad568633ee3a7b2c2d0301b", + "name": "tensorflow", + "namespace": "python", + "sha256": "8ea668c9c6de4b1324e57738dfd55ec218418428a5d26c4d3055f601714af093", + "size": 4386, + "subdir": "linux-64", + "timestamp": 1582050588078, + "version": "2.1.0" + }, + "tensorflow-2.1.0-mkl_py37h80a91df_0.tar.bz2": { + "build": "mkl_py37h80a91df_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard >=2.1.0", + "tensorflow-base 2.1.0 mkl_py37h6d63fb7_0", + "tensorflow-estimator >=2.1.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "910b71158e31f39ecac0211f1727306c", + "name": "tensorflow", + "namespace": "python", + "sha256": "7b17fdb21a75414f9a96da8c45b183bb23ea40e35abd18365f58e284cbc8e272", + "size": 4385, + "subdir": "linux-64", + "timestamp": 1582050615831, + "version": "2.1.0" + }, + "tensorflow-2.10.0-eigen_py310h7dfe345_0.tar.bz2": { + "build": "eigen_py310h7dfe345_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.10.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 eigen_py310h1969d1f_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "85026fe88917d82b82df38508e7fb8cd", + "name": "tensorflow", + "namespace": "python", + "sha256": "bbccef6968ff4010cbb9fe6071c6ef8b74c8d7e5cb3edccac334b8204211bf7b", + "size": 4148, + "subdir": "linux-64", + "timestamp": 1667220553220, + "version": "2.10.0" + }, + "tensorflow-2.10.0-eigen_py37ha43bb76_0.tar.bz2": { + "build": "eigen_py37ha43bb76_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 eigen_py37h1969d1f_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e141cf15c7299a67f607dab25907ff07", + "name": "tensorflow", + "namespace": "python", + "sha256": "88d1ea96dc9308a5d12440898d09c4438a764ffd897bbd011fc9bdb40019caaf", + "size": 4166, + "subdir": "linux-64", + "timestamp": 1667220731107, + "version": "2.10.0" + }, + "tensorflow-2.10.0-eigen_py38h77fcdc8_0.tar.bz2": { + "build": "eigen_py38h77fcdc8_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.8.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 eigen_py38h1969d1f_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dab32a418e4b9101567c7c13e3734ecb", + "name": "tensorflow", + "namespace": "python", + "sha256": "9c1502e2fc64158e736b0ccda8aa42d9bb155408f68dd793a8b76362230a31de", + "size": 4152, + "subdir": "linux-64", + "timestamp": 1667220578018, + "version": "2.10.0" + }, + "tensorflow-2.10.0-eigen_py39he2aad1f_0.tar.bz2": { + "build": "eigen_py39he2aad1f_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.9.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 eigen_py39h1969d1f_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6e10877ab96050760d3f4becf094d4a2", + "name": "tensorflow", + "namespace": "python", + "sha256": "f4b5624c97c9d427d87cc5d239860b98a40cf79f0cf6b0adff17248ab1386a83", + "size": 4170, + "subdir": "linux-64", + "timestamp": 1667220705751, + "version": "2.10.0" + }, + "tensorflow-2.10.0-gpu_py310hb074053_0.tar.bz2": { + "build": "gpu_py310hb074053_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.10.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 gpu_py310h6559e04_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3910f7a45bf0ffa98ddef211941db9b5", + "name": "tensorflow", + "namespace": "python", + "sha256": "57882c5f2d73535f5b8a2b35c5834c94bb1734a8dfba55b691fa6136f1b94389", + "size": 4146, + "subdir": "linux-64", + "timestamp": 1667223001471, + "version": "2.10.0" + }, + "tensorflow-2.10.0-gpu_py37h84cb581_0.tar.bz2": { + "build": "gpu_py37h84cb581_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.7.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 gpu_py37h6559e04_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bf6f760ef99d7576d01fa716d8524288", + "name": "tensorflow", + "namespace": "python", + "sha256": "4309c9cddee7741a4527e2d5d31e8fb705f6bad8137bab4a83d08aab17b887b8", + "size": 4142, + "subdir": "linux-64", + "timestamp": 1667222974576, + "version": "2.10.0" + }, + "tensorflow-2.10.0-gpu_py38h11b98a5_0.tar.bz2": { + "build": "gpu_py38h11b98a5_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.8.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 gpu_py38h6559e04_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "781869c346c8f77036c7558950bed067", + "name": "tensorflow", + "namespace": "python", + "sha256": "7c8d16b227d629348e25184f41b0d539c7833807bf0ad306cb5f172bed14b301", + "size": 4157, + "subdir": "linux-64", + "timestamp": 1667222916616, + "version": "2.10.0" + }, + "tensorflow-2.10.0-gpu_py39h039f4ff_0.tar.bz2": { + "build": "gpu_py39h039f4ff_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.9.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 gpu_py39h6559e04_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "455534bf3fe08de766c7d704fd7d2ae6", + "name": "tensorflow", + "namespace": "python", + "sha256": "72e4041a8b24aacbefd1c8d7cc0e2152812fd8f45ef91462e804db9ed45312f7", + "size": 4151, + "subdir": "linux-64", + "timestamp": 1667222946598, + "version": "2.10.0" + }, + "tensorflow-2.10.0-mkl_py310h24f4fea_0.tar.bz2": { + "build": "mkl_py310h24f4fea_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.10.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 mkl_py310hb9daa73_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "109f26948be7c81152c062c79418dbaa", + "name": "tensorflow", + "namespace": "python", + "sha256": "ffba88933d42cbd6b79b76bfb0fcc6b47102c4096a75986469c9e36619f99131", + "size": 4153, + "subdir": "linux-64", + "timestamp": 1667220655108, + "version": "2.10.0" + }, + "tensorflow-2.10.0-mkl_py37h5d113c5_0.tar.bz2": { + "build": "mkl_py37h5d113c5_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 mkl_py37hb9daa73_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "87b155a2e5bbf94db1045d6892f02aa7", + "name": "tensorflow", + "namespace": "python", + "sha256": "3b1e4de059ce51258910516b76947ff93c38120bde7fcddaa7e34cb07eae03de", + "size": 4148, + "subdir": "linux-64", + "timestamp": 1667220679864, + "version": "2.10.0" + }, + "tensorflow-2.10.0-mkl_py38hd2379f1_0.tar.bz2": { + "build": "mkl_py38hd2379f1_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 mkl_py38hb9daa73_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c94cd0bb835defbad9466fde3b6fea28", + "name": "tensorflow", + "namespace": "python", + "sha256": "e918c8fbada198f7402a320c11f3f216a76be20f50c84809ee736e410641425e", + "size": 4151, + "subdir": "linux-64", + "timestamp": 1667220604036, + "version": "2.10.0" + }, + "tensorflow-2.10.0-mkl_py39hdc5b6f4_0.tar.bz2": { + "build": "mkl_py39hdc5b6f4_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.9.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 mkl_py39hb9daa73_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d06827c76ad704425ce31e2be34bb493", + "name": "tensorflow", + "namespace": "python", + "sha256": "00aaec0cc41e5ed7a1dddb5dfc5912b57d655df5a42ad4d8e7eeeb537f4c4ec5", + "size": 4151, + "subdir": "linux-64", + "timestamp": 1667220628893, + "version": "2.10.0" + }, + "tensorflow-2.11.0-eigen_py310h0f08fec_0.tar.bz2": { + "build": "eigen_py310h0f08fec_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.10.*", + "tensorboard 2.11.*", + "tensorflow-base 2.11.0 eigen_py310h3323580_0", + "tensorflow-estimator 2.11.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "854967ee124c88786a54feacb4f4c70c", + "name": "tensorflow", + "namespace": "python", + "sha256": "3c0b559b59224026483a0899608755857587994f0dca2dd0ee30c57197084e62", + "size": 4481, + "subdir": "linux-64", + "timestamp": 1678394799352, + "version": "2.11.0" + }, + "tensorflow-2.11.0-eigen_py38h370c993_0.tar.bz2": { + "build": "eigen_py38h370c993_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.8.*", + "tensorboard 2.11.*", + "tensorflow-base 2.11.0 eigen_py38h3323580_0", + "tensorflow-estimator 2.11.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a97f4357731bc615dfef3d6db01f00bc", + "name": "tensorflow", + "namespace": "python", + "sha256": "d78e87db58b2dbbfedc057880d9f8f0ace740a1161e16a34ba61ea208788d54c", + "size": 4469, + "subdir": "linux-64", + "timestamp": 1678394704521, + "version": "2.11.0" + }, + "tensorflow-2.11.0-eigen_py39h76f29f1_0.tar.bz2": { + "build": "eigen_py39h76f29f1_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.9.*", + "tensorboard 2.11.*", + "tensorflow-base 2.11.0 eigen_py39h3323580_0", + "tensorflow-estimator 2.11.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "46f036d97150ff4aba2f01c5687097d3", + "name": "tensorflow", + "namespace": "python", + "sha256": "ad3f78759ae76c29b3a1ff326c209a652cd85929a33cd582d0a9fc4d23709068", + "size": 4471, + "subdir": "linux-64", + "timestamp": 1678394727807, + "version": "2.11.0" + }, + "tensorflow-2.11.0-gpu_py310hf8ff8df_0.tar.bz2": { + "build": "gpu_py310hf8ff8df_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.10.*", + "tensorboard 2.11.*", + "tensorflow-base 2.11.0 gpu_py310h24d65da_0", + "tensorflow-estimator 2.11.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "49694bc201b557ddfc23e599612d54d9", + "name": "tensorflow", + "namespace": "python", + "sha256": "009bb68362b976d0486e052d87687622f1684879b8f512eebc0fc3f4c61e841b", + "size": 4473, + "subdir": "linux-64", + "timestamp": 1678395062356, + "version": "2.11.0" + }, + "tensorflow-2.11.0-gpu_py38hec62255_0.tar.bz2": { + "build": "gpu_py38hec62255_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.8.*", + "tensorboard 2.11.*", + "tensorflow-base 2.11.0 gpu_py38h24d65da_0", + "tensorflow-estimator 2.11.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7f07ccb2bfa91155e444b5e89cb318f9", + "name": "tensorflow", + "namespace": "python", + "sha256": "00132fff5fb1f520ccfaedcca4fd34ec6668300273fec82b0592cbe061144668", + "size": 4485, + "subdir": "linux-64", + "timestamp": 1678395035057, + "version": "2.11.0" + }, + "tensorflow-2.11.0-gpu_py39h6d58c08_0.tar.bz2": { + "build": "gpu_py39h6d58c08_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.9.*", + "tensorboard 2.11.*", + "tensorflow-base 2.11.0 gpu_py39h24d65da_0", + "tensorflow-estimator 2.11.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3b923ab5eef141c62e04e49b0842dae7", + "name": "tensorflow", + "namespace": "python", + "sha256": "50df2a5271fc4b7483a296d4797169dc8d2b4e91a895f21e52804574232660cb", + "size": 4465, + "subdir": "linux-64", + "timestamp": 1678395006472, + "version": "2.11.0" + }, + "tensorflow-2.11.0-mkl_py310hb40ee82_0.tar.bz2": { + "build": "mkl_py310hb40ee82_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.10.*", + "tensorboard 2.11.*", + "tensorflow-base 2.11.0 mkl_py310he5f8e37_0", + "tensorflow-estimator 2.11.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "41fb8209ae1546842d9534ebd37b91ff", + "name": "tensorflow", + "namespace": "python", + "sha256": "d71f368dd0c2e438d0ca7f0ff1f5feb933b90ee8d387911a79c7bbaed961d5d7", + "size": 4468, + "subdir": "linux-64", + "timestamp": 1678394775156, + "version": "2.11.0" + }, + "tensorflow-2.11.0-mkl_py38hda6d4db_0.tar.bz2": { + "build": "mkl_py38hda6d4db_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard 2.11.*", + "tensorflow-base 2.11.0 mkl_py38he5f8e37_0", + "tensorflow-estimator 2.11.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ff62c94f41680f96696532842677ce71", + "name": "tensorflow", + "namespace": "python", + "sha256": "c10e357adea592f59b0a42d6dca97813fe08f69c751479592a1f5975c34d5069", + "size": 4471, + "subdir": "linux-64", + "timestamp": 1678394677659, + "version": "2.11.0" + }, + "tensorflow-2.11.0-mkl_py39hea27e05_0.tar.bz2": { + "build": "mkl_py39hea27e05_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.9.*", + "tensorboard 2.11.*", + "tensorflow-base 2.11.0 mkl_py39he5f8e37_0", + "tensorflow-estimator 2.11.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7d6d103df7645ce8f86af85265edc579", + "name": "tensorflow", + "namespace": "python", + "sha256": "0a86bca54c8df0c50021bede2fa4b9014bfd14414fa4da228d28179bfc632000", + "size": 4471, + "subdir": "linux-64", + "timestamp": 1678394753369, + "version": "2.11.0" + }, + "tensorflow-2.2.0-eigen_py36h84d285f_0.tar.bz2": { + "build": "eigen_py36h84d285f_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.6.*", + "tensorboard >=2.2.0", + "tensorflow-base 2.2.0 eigen_py36haef3446_0", + "tensorflow-estimator >=2.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "19f8894de4073836ae5e2975d1e76d2e", + "name": "tensorflow", + "namespace": "python", + "sha256": "905f460706c771530f9f95c935a06e8c29326dc738639e45f8de2191b2d9f423", + "size": 3753, + "subdir": "linux-64", + "timestamp": 1590158763636, + "version": "2.2.0" + }, + "tensorflow-2.2.0-eigen_py37h1b16bb3_0.tar.bz2": { + "build": "eigen_py37h1b16bb3_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard >=2.2.0", + "tensorflow-base 2.2.0 eigen_py37haef3446_0", + "tensorflow-estimator >=2.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2b5eed964ab96baad00793ca9c1cb1af", + "name": "tensorflow", + "namespace": "python", + "sha256": "5909fafaf0d9066dfb0774e9c5268c73490686deae03ce7db8f22f529570960a", + "size": 3745, + "subdir": "linux-64", + "timestamp": 1590158673573, + "version": "2.2.0" + }, + "tensorflow-2.2.0-eigen_py38hfc6e53c_0.tar.bz2": { + "build": "eigen_py38hfc6e53c_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.8.*", + "tensorboard >=2.2.0", + "tensorflow-base 2.2.0 eigen_py38h2e5f744_0", + "tensorflow-estimator >=2.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1e91d022b948e3070c3ff0e70bb15998", + "name": "tensorflow", + "namespace": "python", + "sha256": "f0e86e0aea272cdfeeae60f6f04f98a4fc7d5470c7d405d38a9d434953dc2575", + "size": 3776, + "subdir": "linux-64", + "timestamp": 1590158640929, + "version": "2.2.0" + }, + "tensorflow-2.2.0-gpu_py36hf933387_0.tar.bz2": { + "build": "gpu_py36hf933387_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.6.*", + "tensorboard >=2.2.0", + "tensorflow-base 2.2.0 gpu_py36h8a81be8_0", + "tensorflow-estimator >=2.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8e98889c8fa6f618aa0b8aba8685ec25", + "name": "tensorflow", + "namespace": "python", + "sha256": "6f42589fed6da2defdc26190a37a7ad06b9821c3d5d4d4ecd97a44792730e9b1", + "size": 4060, + "subdir": "linux-64", + "timestamp": 1590183046255, + "version": "2.2.0" + }, + "tensorflow-2.2.0-gpu_py37h1a511ff_0.tar.bz2": { + "build": "gpu_py37h1a511ff_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.7.*", + "tensorboard >=2.2.0", + "tensorflow-base 2.2.0 gpu_py37h8a81be8_0", + "tensorflow-estimator >=2.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "078b71679af1419b5a23d92eb2868d79", + "name": "tensorflow", + "namespace": "python", + "sha256": "06730d7f58a9d44a48dffa4f402c54ad6c21905a8138002ae74881e5148d16bb", + "size": 4060, + "subdir": "linux-64", + "timestamp": 1590183063377, + "version": "2.2.0" + }, + "tensorflow-2.2.0-gpu_py38hb782248_0.tar.bz2": { + "build": "gpu_py38hb782248_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.8.*", + "tensorboard >=2.2.0", + "tensorflow-base 2.2.0 gpu_py38h83e3d50_0", + "tensorflow-estimator >=2.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5559351855047a7e0f743488c406f9df", + "name": "tensorflow", + "namespace": "python", + "sha256": "051b2c3c874576bd6b2f64163837c7bf3bc8c35ea020bf9baf280bec29f5f223", + "size": 4051, + "subdir": "linux-64", + "timestamp": 1590182966494, + "version": "2.2.0" + }, + "tensorflow-2.2.0-mkl_py36h5a57954_0.tar.bz2": { + "build": "mkl_py36h5a57954_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.6.*", + "tensorboard >=2.2.0", + "tensorflow-base 2.2.0 mkl_py36hd506778_0", + "tensorflow-estimator >=2.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "83236ea6a3ad486c31a7f5f029ff7698", + "name": "tensorflow", + "namespace": "python", + "sha256": "65cec894e5b8371f758f39073f0a5f2400d53c5571dbae61718e153ee28a6f9d", + "size": 3750, + "subdir": "linux-64", + "timestamp": 1590158819808, + "version": "2.2.0" + }, + "tensorflow-2.2.0-mkl_py37h6e9ce2d_0.tar.bz2": { + "build": "mkl_py37h6e9ce2d_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard >=2.2.0", + "tensorflow-base 2.2.0 mkl_py37hd506778_0", + "tensorflow-estimator >=2.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ac9c895af342b13c0a6787d1c7205e6b", + "name": "tensorflow", + "namespace": "python", + "sha256": "afe29ca06578670076c9fa14581ae8668ed904000d47b4bd49a26571c8e75854", + "size": 3769, + "subdir": "linux-64", + "timestamp": 1590158706131, + "version": "2.2.0" + }, + "tensorflow-2.2.0-mkl_py38h6d3daf0_0.tar.bz2": { + "build": "mkl_py38h6d3daf0_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard >=2.2.0", + "tensorflow-base 2.2.0 mkl_py38h5059a2d_0", + "tensorflow-estimator >=2.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "be511a497a09403072eef13cb87b6629", + "name": "tensorflow", + "namespace": "python", + "sha256": "e31316b84b295fd0f71814031d4a7fc1eebec95b837129006ec9642e7d998fbb", + "size": 3763, + "subdir": "linux-64", + "timestamp": 1590158803754, + "version": "2.2.0" + }, + "tensorflow-2.3.0-eigen_py37h189e6a2_0.tar.bz2": { + "build": "eigen_py37h189e6a2_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 eigen", + "python 3.7.*", + "tensorboard >=2.3.0", + "tensorflow-base 2.3.0 eigen_py37h3b305d7_0", + "tensorflow-estimator >=2.3.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "74ceb7b06f1f88e769ec57e6936841c7", + "name": "tensorflow", + "namespace": "python", + "sha256": "cd413649d776700cdaa97f89286683f8244987b59b5dd886244fe2b3464ceb9d", + "size": 3557, + "subdir": "linux-64", + "timestamp": 1604315799761, + "version": "2.3.0" + }, + "tensorflow-2.3.0-eigen_py38h71ff20e_0.tar.bz2": { + "build": "eigen_py38h71ff20e_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 eigen", + "python 3.8.*", + "tensorboard >=2.3.0", + "tensorflow-base 2.3.0 eigen_py38hb57a387_0", + "tensorflow-estimator >=2.3.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d7ae95621bfb26d00b60cdab5442db36", + "name": "tensorflow", + "namespace": "python", + "sha256": "8649f17e688d84dd94758bdffcb32246676d3044241436668329b60de2fac2ea", + "size": 3563, + "subdir": "linux-64", + "timestamp": 1604315778375, + "version": "2.3.0" + }, + "tensorflow-2.3.0-mkl_py37h0481017_0.tar.bz2": { + "build": "mkl_py37h0481017_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard >=2.3.0", + "tensorflow-base 2.3.0 mkl_py37he9661a2_0", + "tensorflow-estimator >=2.3.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2bc937e8ba37f34ecc5b775fa867dcba", + "name": "tensorflow", + "namespace": "python", + "sha256": "6774135954dc4bb4a7208a0b98bf09babb3d6af0b8dec3c7b15d7abfa4a8d26d", + "size": 3566, + "subdir": "linux-64", + "timestamp": 1604315759116, + "version": "2.3.0" + }, + "tensorflow-2.3.0-mkl_py38hd53216f_0.tar.bz2": { + "build": "mkl_py38hd53216f_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard >=2.3.0", + "tensorflow-base 2.3.0 mkl_py38hac35e67_0", + "tensorflow-estimator >=2.3.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b9e320446f5338f12a25ac999fb68f77", + "name": "tensorflow", + "namespace": "python", + "sha256": "45f02fb23f135fdc187909076007239fdda406cefd89df853e2aa18e55858661", + "size": 3553, + "subdir": "linux-64", + "timestamp": 1604315739346, + "version": "2.3.0" + }, + "tensorflow-2.4.1-eigen_py37h3da6045_0.tar.bz2": { + "build": "eigen_py37h3da6045_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard >=2.4.0", + "tensorflow-base 2.4.1 eigen_py37h17880bf_0", + "tensorflow-estimator >=2.4.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b6c1e70ec650fbc1e95ec208787d6cd4", + "name": "tensorflow", + "namespace": "python", + "sha256": "6132d9a1b6e3f504e9afd0f0f86c345ddc52d84a4c97bc27f5a1755597c4616c", + "size": 3473, + "subdir": "linux-64", + "timestamp": 1614594522842, + "version": "2.4.1" + }, + "tensorflow-2.4.1-eigen_py38h0e0807f_0.tar.bz2": { + "build": "eigen_py38h0e0807f_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.8.*", + "tensorboard >=2.4.0", + "tensorflow-base 2.4.1 eigen_py38h17880bf_0", + "tensorflow-estimator >=2.4.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1e4255525507787e9746c02addf5173b", + "name": "tensorflow", + "namespace": "python", + "sha256": "2af2ed6333aba99a8a62ff7fab1bf0de7b9a49d7e15866aa9d4cb2475905895f", + "size": 3467, + "subdir": "linux-64", + "timestamp": 1614594418602, + "version": "2.4.1" + }, + "tensorflow-2.4.1-eigen_py39h813c054_0.tar.bz2": { + "build": "eigen_py39h813c054_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.9.*", + "tensorboard >=2.4.0", + "tensorflow-base 2.4.1 eigen_py39h17880bf_0", + "tensorflow-estimator >=2.4.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7a075ebd4f4d73c143e8464d17337445", + "name": "tensorflow", + "namespace": "python", + "sha256": "a0ea3f3692fec2c1d061852510b3685b320be8712dfc6a8de018603c2aa3f32b", + "size": 3469, + "subdir": "linux-64", + "timestamp": 1614594438484, + "version": "2.4.1" + }, + "tensorflow-2.4.1-gpu_py37ha2e99fa_0.tar.bz2": { + "build": "gpu_py37ha2e99fa_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.7.*", + "tensorboard >=2.4.0", + "tensorflow-base 2.4.1 gpu_py37h29c2da4_0", + "tensorflow-estimator >=2.4.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b31850ca93c580c01f5e90be2e87b810", + "name": "tensorflow", + "namespace": "python", + "sha256": "bd1bf298e650176ff45bcde8e408625c01b0ad94f7a697543b5b984d750667e9", + "size": 3483, + "subdir": "linux-64", + "timestamp": 1614594751591, + "version": "2.4.1" + }, + "tensorflow-2.4.1-gpu_py38h8a7d6ce_0.tar.bz2": { + "build": "gpu_py38h8a7d6ce_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.8.*", + "tensorboard >=2.4.0", + "tensorflow-base 2.4.1 gpu_py38h29c2da4_0", + "tensorflow-estimator >=2.4.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "93219bcd66b2e839a544355dc0a88c95", + "name": "tensorflow", + "namespace": "python", + "sha256": "15162229d18f88af35794dad42a15146873c85c24b70d725ee42bdcf1c0fbf4c", + "size": 3464, + "subdir": "linux-64", + "timestamp": 1614594675767, + "version": "2.4.1" + }, + "tensorflow-2.4.1-gpu_py39h8236f22_0.tar.bz2": { + "build": "gpu_py39h8236f22_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.9.*", + "tensorboard >=2.4.0", + "tensorflow-base 2.4.1 gpu_py39h29c2da4_0", + "tensorflow-estimator >=2.4.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2a30d30dc6b6765b1c9b449d4155471c", + "name": "tensorflow", + "namespace": "python", + "sha256": "8bc2b6c6185675ac0b822da7798fc9b9fc88d71863e9ec3fed28ccdcdcdea966", + "size": 3467, + "subdir": "linux-64", + "timestamp": 1614594600986, + "version": "2.4.1" + }, + "tensorflow-2.4.1-mkl_py37h2d14ff2_0.tar.bz2": { + "build": "mkl_py37h2d14ff2_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard >=2.4.0", + "tensorflow-base 2.4.1 mkl_py37h43e0292_0", + "tensorflow-estimator >=2.4.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "10471aa950e50cba16dd0c0d357dbfc3", + "name": "tensorflow", + "namespace": "python", + "sha256": "4e3832e5365e90f4c3fcf6087ff5a1c5eeaf9fd40467f5ff591eaec38a7778fd", + "size": 3463, + "subdir": "linux-64", + "timestamp": 1614594396271, + "version": "2.4.1" + }, + "tensorflow-2.4.1-mkl_py38hb2083e0_0.tar.bz2": { + "build": "mkl_py38hb2083e0_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard >=2.4.0", + "tensorflow-base 2.4.1 mkl_py38h43e0292_0", + "tensorflow-estimator >=2.4.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e82192cb0512d92ee9996e694d29551d", + "name": "tensorflow", + "namespace": "python", + "sha256": "e019f827fdaaa1f1c8e0cf8ce835a251194fbb9f9e38dd6baf39351487e9ffaf", + "size": 3475, + "subdir": "linux-64", + "timestamp": 1614594480229, + "version": "2.4.1" + }, + "tensorflow-2.4.1-mkl_py39h4683426_0.tar.bz2": { + "build": "mkl_py39h4683426_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.9.*", + "tensorboard >=2.4.0", + "tensorflow-base 2.4.1 mkl_py39h43e0292_0", + "tensorflow-estimator >=2.4.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "de983ca49b8c6741e7e2ae960a3e4a19", + "name": "tensorflow", + "namespace": "python", + "sha256": "f553a0353923b128750f295f671ab691035f037722aa1f1bf8d82d0f59e45f95", + "size": 3462, + "subdir": "linux-64", + "timestamp": 1614594375026, + "version": "2.4.1" + }, + "tensorflow-2.5.0-eigen_py37hff93566_0.tar.bz2": { + "build": "eigen_py37hff93566_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard >=2.5.0", + "tensorflow-base 2.5.0 eigen_py37h2b86b3d_0", + "tensorflow-estimator >=2.5.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "862639fe23e6d3d5a6c1bc8fa711ffdc", + "name": "tensorflow", + "namespace": "python", + "sha256": "f3707675907a89e4576996224dadafb74327dc23c76c272950bfb8e7204f7e30", + "size": 3439, + "subdir": "linux-64", + "timestamp": 1622187252921, + "version": "2.5.0" + }, + "tensorflow-2.5.0-eigen_py38h17aada3_0.tar.bz2": { + "build": "eigen_py38h17aada3_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.8.*", + "tensorboard >=2.5.0", + "tensorflow-base 2.5.0 eigen_py38h2b86b3d_0", + "tensorflow-estimator >=2.5.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e8a717f58da5307d3e6abf293eeef53e", + "name": "tensorflow", + "namespace": "python", + "sha256": "b6f400d44bc09365b006d5a407fb5884a47a417982c1e316eeed01c99d4e7f5b", + "size": 3451, + "subdir": "linux-64", + "timestamp": 1622187309332, + "version": "2.5.0" + }, + "tensorflow-2.5.0-eigen_py38h94feaef_0.tar.bz2": { + "build": "eigen_py38h94feaef_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard >=2.5.0", + "tensorflow-base 2.5.0 eigen_py38h2b86b3d_0", + "tensorflow-estimator >=2.5.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3008915d9c1270056628b43be0587456", + "name": "tensorflow", + "namespace": "python", + "sha256": "cfc89f66380becacd293301d7c8d8d7e2d5b919b6b09e9c0943d97ee0e1e6420", + "size": 3462, + "subdir": "linux-64", + "timestamp": 1622195191762, + "version": "2.5.0" + }, + "tensorflow-2.5.0-eigen_py39hd8d7d70_0.tar.bz2": { + "build": "eigen_py39hd8d7d70_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.9.*", + "tensorboard >=2.5.0", + "tensorflow-base 2.5.0 eigen_py39h2b86b3d_0", + "tensorflow-estimator >=2.5.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "777b410a44b34de40146c498fbcbd913", + "name": "tensorflow", + "namespace": "python", + "sha256": "e5aec463043dba9b2314bd5a732ed67647654ff1f591299a495b73be655cb870", + "size": 3451, + "subdir": "linux-64", + "timestamp": 1622187292207, + "version": "2.5.0" + }, + "tensorflow-2.5.0-mkl_py37h3e8b3f4_0.tar.bz2": { + "build": "mkl_py37h3e8b3f4_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard >=2.5.0", + "tensorflow-base 2.5.0 mkl_py37h35b2a3d_0", + "tensorflow-estimator >=2.5.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2e06c3847b1b126b37d479ef09434eae", + "name": "tensorflow", + "namespace": "python", + "sha256": "d783c496dcb92f2757448c3ba0b3d98472cf758f55c70f35c3f1f697a471e662", + "size": 3433, + "subdir": "linux-64", + "timestamp": 1622187272817, + "version": "2.5.0" + }, + "tensorflow-2.5.0-mkl_py38hce4fbe1_0.tar.bz2": { + "build": "mkl_py38hce4fbe1_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard >=2.5.0", + "tensorflow-base 2.5.0 mkl_py38h35b2a3d_0", + "tensorflow-estimator >=2.5.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2f7cc062482195b7109173df3afa4ea1", + "name": "tensorflow", + "namespace": "python", + "sha256": "2503bc33b960b698f2eed6173aa6b8149abd6af5fd6f67eacca5d7698fd7734d", + "size": 3430, + "subdir": "linux-64", + "timestamp": 1622187232998, + "version": "2.5.0" + }, + "tensorflow-2.5.0-mkl_py39h4a0693c_0.tar.bz2": { + "build": "mkl_py39h4a0693c_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.9.*", + "tensorboard >=2.5.0", + "tensorflow-base 2.5.0 mkl_py39h35b2a3d_0", + "tensorflow-estimator >=2.5.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2119bc41b2b7121af461c80fe5254629", + "name": "tensorflow", + "namespace": "python", + "sha256": "8086ea5b84efe3975fdc9256dd30973eb9755a68b4b3a64049c64f7ac216240e", + "size": 3445, + "subdir": "linux-64", + "timestamp": 1622187213415, + "version": "2.5.0" + }, + "tensorflow-2.6.0-eigen_py37h34b007a_0.tar.bz2": { + "build": "eigen_py37h34b007a_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard >=2.6.0", + "tensorflow-base 2.6.0 eigen_py37ha9cc040_0", + "tensorflow-estimator >=2.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d09d7a5135835628fc6f29a24c184807", + "name": "tensorflow", + "namespace": "python", + "sha256": "c36873c2c8417a4b8e0e9a8783640ee6314fcee7ba0dec964b5a10517df98d7c", + "size": 3612, + "subdir": "linux-64", + "timestamp": 1630523916628, + "version": "2.6.0" + }, + "tensorflow-2.6.0-eigen_py38hcc1cb13_0.tar.bz2": { + "build": "eigen_py38hcc1cb13_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.8.*", + "tensorboard >=2.6.0", + "tensorflow-base 2.6.0 eigen_py38ha9cc040_0", + "tensorflow-estimator >=2.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "263ac54e0372db9b10bec8238be39bf3", + "name": "tensorflow", + "namespace": "python", + "sha256": "b042292dfee0e0b82d8e7580830db67a0046cc5b62c6d8b8fdb25f8e46ab05f3", + "size": 3613, + "subdir": "linux-64", + "timestamp": 1630524011440, + "version": "2.6.0" + }, + "tensorflow-2.6.0-eigen_py39h4b72145_0.tar.bz2": { + "build": "eigen_py39h4b72145_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.9.*", + "tensorboard >=2.6.0", + "tensorflow-base 2.6.0 eigen_py39ha9cc040_0", + "tensorflow-estimator >=2.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1b7a21bc9deaab772648c3c6f9115396", + "name": "tensorflow", + "namespace": "python", + "sha256": "1f02e41b25e0d35bda7ba34432399c3da3c8b3f0e332a17ab2c0f705f10b9418", + "size": 3619, + "subdir": "linux-64", + "timestamp": 1630523953144, + "version": "2.6.0" + }, + "tensorflow-2.6.0-mkl_py37h9d15365_0.tar.bz2": { + "build": "mkl_py37h9d15365_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard >=2.6.0", + "tensorflow-base 2.6.0 mkl_py37h3d85931_0", + "tensorflow-estimator >=2.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5d76b28912f2163328287c45e635fea9", + "name": "tensorflow", + "namespace": "python", + "sha256": "4aab30cfa21e5caf5c89f0439f8b3bab6999e52a82d9adfc07a0dd43d428e890", + "size": 3600, + "subdir": "linux-64", + "timestamp": 1630523992000, + "version": "2.6.0" + }, + "tensorflow-2.6.0-mkl_py38h874c8e8_0.tar.bz2": { + "build": "mkl_py38h874c8e8_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard >=2.6.0", + "tensorflow-base 2.6.0 mkl_py38h3d85931_0", + "tensorflow-estimator >=2.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9d4606348ed26ded0cab793f7813b05f", + "name": "tensorflow", + "namespace": "python", + "sha256": "ca61c29d33d9e3bfa1341195efbdd8eb9d93c5e23e9a8289c5322cbf38bf29a4", + "size": 3603, + "subdir": "linux-64", + "timestamp": 1630523972022, + "version": "2.6.0" + }, + "tensorflow-2.6.0-mkl_py39haac40d1_0.tar.bz2": { + "build": "mkl_py39haac40d1_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.9.*", + "tensorboard >=2.6.0", + "tensorflow-base 2.6.0 mkl_py39h3d85931_0", + "tensorflow-estimator >=2.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "36a8be302c8c4ad2dc54590bb74b9551", + "name": "tensorflow", + "namespace": "python", + "sha256": "9f69310f8e8d9cab902ec8b8c15adbfc0671258df9d910ef3dca4db4ed9c1e68", + "size": 3606, + "subdir": "linux-64", + "timestamp": 1630523936225, + "version": "2.6.0" + }, + "tensorflow-2.8.2-eigen_py310h2d010dc_0.tar.bz2": { + "build": "eigen_py310h2d010dc_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.10.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 eigen_py310h980454f_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1f7ae1418697aed77f9837ea8853ef70", + "name": "tensorflow", + "namespace": "python", + "sha256": "e28026f26321177031f78326a9662370a8625f26df23a15f1c34712300abd4dc", + "size": 3694, + "subdir": "linux-64", + "timestamp": 1658949257085, + "version": "2.8.2" + }, + "tensorflow-2.8.2-eigen_py37h02982d4_0.tar.bz2": { + "build": "eigen_py37h02982d4_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 eigen_py37h980454f_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a05aab86bc907f04b6012a4bc85cf00b", + "name": "tensorflow", + "namespace": "python", + "sha256": "2a827b784c70893cf2257e400fef077c65e74ab09f5c4a50c48f61d8be708287", + "size": 3686, + "subdir": "linux-64", + "timestamp": 1658949386906, + "version": "2.8.2" + }, + "tensorflow-2.8.2-eigen_py38h4fd5193_0.tar.bz2": { + "build": "eigen_py38h4fd5193_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.8.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 eigen_py38h980454f_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "06779a519c44848b5610188e12921525", + "name": "tensorflow", + "namespace": "python", + "sha256": "d587b0c07483efcd764fa1c4b9f13b0089b1b57e68bddb94ec9656300487c376", + "size": 3688, + "subdir": "linux-64", + "timestamp": 1658949432142, + "version": "2.8.2" + }, + "tensorflow-2.8.2-eigen_py39h2e3267a_0.tar.bz2": { + "build": "eigen_py39h2e3267a_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.9.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 eigen_py39h980454f_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6eb2695f3da8db83659ae36b6347acf8", + "name": "tensorflow", + "namespace": "python", + "sha256": "cb5cc6154647249d23fe5ca3695bb66d037c90e818a77345cc44fce87cc89a7a", + "size": 3689, + "subdir": "linux-64", + "timestamp": 1658949343777, + "version": "2.8.2" + }, + "tensorflow-2.8.2-gpu_py310hf783e45_0.tar.bz2": { + "build": "gpu_py310hf783e45_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.10.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 gpu_py310h1986732_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9e3f6507ee8dc95276661c722093ddec", + "name": "tensorflow", + "namespace": "python", + "sha256": "75e86d3e0bb73a43c3903ee265659a65db6c02f950a988a1935e4774f2e842d4", + "size": 7072, + "subdir": "linux-64", + "timestamp": 1659965964020, + "version": "2.8.2" + }, + "tensorflow-2.8.2-gpu_py37hbb399c4_0.tar.bz2": { + "build": "gpu_py37hbb399c4_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.7.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 gpu_py37h1986732_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6fa8473504e4df1ebb3eb067ede6f7bf", + "name": "tensorflow", + "namespace": "python", + "sha256": "61003564f1a308ac694930f4a7a4cc4d0e289904551707a098f97e50ed66dbbe", + "size": 7061, + "subdir": "linux-64", + "timestamp": 1659965962646, + "version": "2.8.2" + }, + "tensorflow-2.8.2-gpu_py38h75b8afa_0.tar.bz2": { + "build": "gpu_py38h75b8afa_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.8.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 gpu_py38h1986732_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "19ec216fe0dca6f7f3eb7c463477ce6a", + "name": "tensorflow", + "namespace": "python", + "sha256": "68f0bf4bfcc4a09d8db578bf6b099d80c184cbf067914e79a1e2ac92c4eea85a", + "size": 7070, + "subdir": "linux-64", + "timestamp": 1659965966409, + "version": "2.8.2" + }, + "tensorflow-2.8.2-gpu_py39hc0c9373_0.tar.bz2": { + "build": "gpu_py39hc0c9373_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.9.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 gpu_py39h1986732_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fe8e37ba39aa35302a91306fa9220aab", + "name": "tensorflow", + "namespace": "python", + "sha256": "79c805f5593cd4918deac5d2783fb5cf9f4cb17e7b29039acb5625bca34871d4", + "size": 7063, + "subdir": "linux-64", + "timestamp": 1659965965172, + "version": "2.8.2" + }, + "tensorflow-2.8.2-mkl_py310hd2b8f8c_0.tar.bz2": { + "build": "mkl_py310hd2b8f8c_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.10.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 mkl_py310hf890080_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c8e0d638ccacd8c1216c6f5068f50bdd", + "name": "tensorflow", + "namespace": "python", + "sha256": "ad6ec557d052184a64ec1551e2b7c225b6c4adc8af7a3336b5986b88293de46b", + "size": 3674, + "subdir": "linux-64", + "timestamp": 1658949302013, + "version": "2.8.2" + }, + "tensorflow-2.8.2-mkl_py37h98100e6_0.tar.bz2": { + "build": "mkl_py37h98100e6_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 mkl_py37hf890080_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7cc3551d99794f6af639d9529cb83aa4", + "name": "tensorflow", + "namespace": "python", + "sha256": "9e6d499fcd09602ac011081d06ba4b1744b6bd4a0ea373568a1f86ea284b96b9", + "size": 3686, + "subdir": "linux-64", + "timestamp": 1658949148185, + "version": "2.8.2" + }, + "tensorflow-2.8.2-mkl_py38hb41d75a_0.tar.bz2": { + "build": "mkl_py38hb41d75a_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 mkl_py38hf890080_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "247df27b21701311ec52f24c797500a3", + "name": "tensorflow", + "namespace": "python", + "sha256": "bc1eee1f4970ec927192bc285c044c7e1f38048a7111f785f4fe7ab96094586c", + "size": 3677, + "subdir": "linux-64", + "timestamp": 1658949099240, + "version": "2.8.2" + }, + "tensorflow-2.8.2-mkl_py39ha986a27_0.tar.bz2": { + "build": "mkl_py39ha986a27_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.9.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 mkl_py39hf890080_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "def9f8bfd5d22e6521870cd004c1dafe", + "name": "tensorflow", + "namespace": "python", + "sha256": "7e0cb436bc7fdf50fda60ae94c8a375543d988f47c0b87320c47163906e3126e", + "size": 3687, + "subdir": "linux-64", + "timestamp": 1658949203233, + "version": "2.8.2" + }, + "tensorflow-2.9.1-eigen_py310h1b3eda0_1.tar.bz2": { + "build": "eigen_py310h1b3eda0_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.10.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 eigen_py310hd99631c_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0d3910e45dc836c08e250ad935b7d34d", + "name": "tensorflow", + "namespace": "python", + "sha256": "3e96c1efd7b0b90c6a704a98afd7dbbbd55892049cc4edc30e27fcd8bae1409e", + "size": 4107, + "subdir": "linux-64", + "timestamp": 1667479963738, + "version": "2.9.1" + }, + "tensorflow-2.9.1-eigen_py310h7bda0dd_0.tar.bz2": { + "build": "eigen_py310h7bda0dd_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.10.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 eigen_py310hd99631c_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "60412e18847478b7c1e175aa0fa6892c", + "name": "tensorflow", + "namespace": "python", + "sha256": "3535ab89bd780b1331492a9df1a3f42eafe18c30a66692d48b9527001a32e8fc", + "size": 4176, + "subdir": "linux-64", + "timestamp": 1661531036064, + "version": "2.9.1" + }, + "tensorflow-2.9.1-eigen_py37h054527f_0.tar.bz2": { + "build": "eigen_py37h054527f_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 eigen_py37hd99631c_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f410e210e63ecdb6a5f17609df36e953", + "name": "tensorflow", + "namespace": "python", + "sha256": "8efae0aa392452a344ac93b3d49ae2a2527ae438009e222c9720e0b736cc8fcd", + "size": 4160, + "subdir": "linux-64", + "timestamp": 1661530965745, + "version": "2.9.1" + }, + "tensorflow-2.9.1-eigen_py37hb9d071f_1.tar.bz2": { + "build": "eigen_py37hb9d071f_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 eigen_py37hd99631c_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "800132271a9653d339dcc6b5b14544eb", + "name": "tensorflow", + "namespace": "python", + "sha256": "3e0cb450cf597e506d6ab0e35de33a3bd34e852386e453bfa8b99cf7421224a0", + "size": 4101, + "subdir": "linux-64", + "timestamp": 1667479988733, + "version": "2.9.1" + }, + "tensorflow-2.9.1-eigen_py38h6be4119_0.tar.bz2": { + "build": "eigen_py38h6be4119_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.8.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 eigen_py38hd99631c_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "27ccf59b4ef8253673b54c5fe026c567", + "name": "tensorflow", + "namespace": "python", + "sha256": "5ecf0222ecc544ccb3632c0adb29ff0e0d98350ee2b8ae74c9349b1470a3f031", + "size": 4169, + "subdir": "linux-64", + "timestamp": 1661531014168, + "version": "2.9.1" + }, + "tensorflow-2.9.1-eigen_py38hdf99000_1.tar.bz2": { + "build": "eigen_py38hdf99000_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.8.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 eigen_py38hd99631c_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "053aeceb91901b48802c48168d5aab07", + "name": "tensorflow", + "namespace": "python", + "sha256": "5f366a2330db8b29ea893e72c7e8ff4f860f9bf2b75b6c35f151d9fab474ddd0", + "size": 4096, + "subdir": "linux-64", + "timestamp": 1667480016004, + "version": "2.9.1" + }, + "tensorflow-2.9.1-eigen_py39h0984c0c_0.tar.bz2": { + "build": "eigen_py39h0984c0c_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.9.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 eigen_py39hd99631c_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4a00da8680aae9a22391d311f2fe9b40", + "name": "tensorflow", + "namespace": "python", + "sha256": "201def2d28c8bd409ae7b1eabd5d9b41f760354c198430c16c8a351e74d687ea", + "size": 4170, + "subdir": "linux-64", + "timestamp": 1661530940401, + "version": "2.9.1" + }, + "tensorflow-2.9.1-eigen_py39hd6755af_1.tar.bz2": { + "build": "eigen_py39hd6755af_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.9.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 eigen_py39hd99631c_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d9303678868e3364c8443c85f17bd09b", + "name": "tensorflow", + "namespace": "python", + "sha256": "3ed981e2cbd56dc1b4c3f2c4b7bb86e64a2a38cf51be63f0390960f57937f1c3", + "size": 4095, + "subdir": "linux-64", + "timestamp": 1667479859017, + "version": "2.9.1" + }, + "tensorflow-2.9.1-gpu_py310h710b358_0.tar.bz2": { + "build": "gpu_py310h710b358_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.10.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 gpu_py310h1986732_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dcdc1352dea8676f09512507fa4474eb", + "name": "tensorflow", + "namespace": "python", + "sha256": "c2a961c818993a8dbf539aa35962c4ed45615b779a932636fd24b7e852485006", + "size": 4169, + "subdir": "linux-64", + "timestamp": 1661530764200, + "version": "2.9.1" + }, + "tensorflow-2.9.1-gpu_py310h958eec2_1.tar.bz2": { + "build": "gpu_py310h958eec2_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.10.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 gpu_py310h1986732_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f8d416c6911019868f96dbbb69c42c30", + "name": "tensorflow", + "namespace": "python", + "sha256": "e5018955c75aeba0f7a13436e170cb0d2d86fd30ac191e45dc9ed3b6572919c6", + "size": 4101, + "subdir": "linux-64", + "timestamp": 1667480196445, + "version": "2.9.1" + }, + "tensorflow-2.9.1-gpu_py37h94660a9_1.tar.bz2": { + "build": "gpu_py37h94660a9_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.7.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 gpu_py37h1986732_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "efd47805f3ec0da97d4863e4e1bfc76e", + "name": "tensorflow", + "namespace": "python", + "sha256": "dfcbce1255a57d03dc95979993f5a1b04d0f1738449f8ea4705849744b5a41ca", + "size": 4104, + "subdir": "linux-64", + "timestamp": 1667480257712, + "version": "2.9.1" + }, + "tensorflow-2.9.1-gpu_py37hecb99ea_0.tar.bz2": { + "build": "gpu_py37hecb99ea_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.7.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 gpu_py37h1986732_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "548b7b3c6a2921d77ee95e784dc64c19", + "name": "tensorflow", + "namespace": "python", + "sha256": "732088f1d844fde694f6398305b336eb8ca2f1c6de0b76f01f58f8c4bc84f97b", + "size": 4176, + "subdir": "linux-64", + "timestamp": 1661530789492, + "version": "2.9.1" + }, + "tensorflow-2.9.1-gpu_py38h731a0ae_0.tar.bz2": { + "build": "gpu_py38h731a0ae_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.8.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 gpu_py38h1986732_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "40f293092ca481fa66e27081fa5c4476", + "name": "tensorflow", + "namespace": "python", + "sha256": "49a05b63e1a1c7e2ead0502b795646068d552170c0cf6d8852406a4fed131e92", + "size": 4171, + "subdir": "linux-64", + "timestamp": 1661530739597, + "version": "2.9.1" + }, + "tensorflow-2.9.1-gpu_py38hb4feff2_1.tar.bz2": { + "build": "gpu_py38hb4feff2_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.8.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 gpu_py38h1986732_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c4688a098fa1dec71ba0e5c7a6493134", + "name": "tensorflow", + "namespace": "python", + "sha256": "a72a0e9c7d56f8a3b428f8b315238c76983fc9bd4ef4ee28f9bb784dd0e4db01", + "size": 4114, + "subdir": "linux-64", + "timestamp": 1667480226202, + "version": "2.9.1" + }, + "tensorflow-2.9.1-gpu_py39hb717771_1.tar.bz2": { + "build": "gpu_py39hb717771_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.9.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 gpu_py39h1986732_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "513132767741661534f12dfdfaa711c7", + "name": "tensorflow", + "namespace": "python", + "sha256": "e8cc92d6066fc097baa5a9735b69acaefda446e9b571e8ad491a5fb02b6a0dca", + "size": 4111, + "subdir": "linux-64", + "timestamp": 1667480288504, + "version": "2.9.1" + }, + "tensorflow-2.9.1-gpu_py39hd4ae112_0.tar.bz2": { + "build": "gpu_py39hd4ae112_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.9.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 gpu_py39h1986732_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c74f4f2305cbdf85d91a3f6523a1925d", + "name": "tensorflow", + "namespace": "python", + "sha256": "3dcf866bd5ef303f083a086eea666d7aa95f55b8afb409a17243790fb2ad71af", + "size": 4165, + "subdir": "linux-64", + "timestamp": 1661530713835, + "version": "2.9.1" + }, + "tensorflow-2.9.1-mkl_py310h6648609_1.tar.bz2": { + "build": "mkl_py310h6648609_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.10.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 mkl_py310h353358b_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "440e5faf93e9ed8abb61675641bd1a3a", + "name": "tensorflow", + "namespace": "python", + "sha256": "48889333a7e26c89c7eac89bdc5cdff9562c8a94d723b99b8c09bd7390ebfefb", + "size": 4113, + "subdir": "linux-64", + "timestamp": 1667479910109, + "version": "2.9.1" + }, + "tensorflow-2.9.1-mkl_py310h871f1f9_0.tar.bz2": { + "build": "mkl_py310h871f1f9_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.10.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 mkl_py310h353358b_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1dca6d6ee688db4b55c1119f641c66b0", + "name": "tensorflow", + "namespace": "python", + "sha256": "5523a955efa761fded7d86fcb88d87a48e21e55950fad83d3459d5c2ec5cbbc2", + "size": 4159, + "subdir": "linux-64", + "timestamp": 1661530989922, + "version": "2.9.1" + }, + "tensorflow-2.9.1-mkl_py37h38a6e85_1.tar.bz2": { + "build": "mkl_py37h38a6e85_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 mkl_py37h353358b_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eb7243cb29094387f7c23df8a880d378", + "name": "tensorflow", + "namespace": "python", + "sha256": "45bd363c5dabbd24e45292bc47a883bdc6dbed822b6fe02b888ca624b54518db", + "size": 4106, + "subdir": "linux-64", + "timestamp": 1667479829156, + "version": "2.9.1" + }, + "tensorflow-2.9.1-mkl_py37h58a621a_0.tar.bz2": { + "build": "mkl_py37h58a621a_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 mkl_py37h353358b_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ded949193ee402aa774031ed9dd4f780", + "name": "tensorflow", + "namespace": "python", + "sha256": "de0a7216afddcc92c16ec2e9eccdb6b856d444b312b5708674c1da4271e35289", + "size": 4164, + "subdir": "linux-64", + "timestamp": 1661530890103, + "version": "2.9.1" + }, + "tensorflow-2.9.1-mkl_py38h197d616_1.tar.bz2": { + "build": "mkl_py38h197d616_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 mkl_py38h353358b_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "95f29e1ac8172d675ccf7a96713a4c46", + "name": "tensorflow", + "namespace": "python", + "sha256": "59c2410a30ac5102ff023664fdad9f004e22bd44ba8ae2160fe22bb3026a80e3", + "size": 4114, + "subdir": "linux-64", + "timestamp": 1667479936833, + "version": "2.9.1" + }, + "tensorflow-2.9.1-mkl_py38h96f9fba_0.tar.bz2": { + "build": "mkl_py38h96f9fba_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 mkl_py38h353358b_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a11ede1f3b4628a0e41e09faf1201d03", + "name": "tensorflow", + "namespace": "python", + "sha256": "88e7093a0df4303ba63f4eb106cc3760887376bad829c0804e14eaf9024bb34b", + "size": 4168, + "subdir": "linux-64", + "timestamp": 1661530915771, + "version": "2.9.1" + }, + "tensorflow-2.9.1-mkl_py39h3a96225_1.tar.bz2": { + "build": "mkl_py39h3a96225_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.9.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 mkl_py39h353358b_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2ca2b73ea17db2c4f3172b3f28aec9b2", + "name": "tensorflow", + "namespace": "python", + "sha256": "53b8af507ab636bcaf314515982f64754a7aacf6da257d3d28f68b074fed814c", + "size": 4114, + "subdir": "linux-64", + "timestamp": 1667479886018, + "version": "2.9.1" + }, + "tensorflow-2.9.1-mkl_py39hb9fcb14_0.tar.bz2": { + "build": "mkl_py39hb9fcb14_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.9.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 mkl_py39h353358b_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a605883d056fa47aaea88a236fc979ad", + "name": "tensorflow", + "namespace": "python", + "sha256": "f1345f9bd5c21d7994f33b4b06841c6b64bd99987c69d8e0b882c0fdc5ddd30d", + "size": 4162, + "subdir": "linux-64", + "timestamp": 1661530864649, + "version": "2.9.1" + }, + "tensorflow-base-1.10.0-eigen_py27h4dcebc2_0.tar.bz2": { + "build": "eigen_py27h4dcebc2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "baa73a22dfd64b259b375cc60f6bbb3a", + "name": "tensorflow-base", + "sha256": "add994ecd3829f8abe69427fa73f1e735f25323df767233b499994d31be46af1", + "size": 51209536, + "subdir": "linux-64", + "timestamp": 1534978001081, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-eigen_py35h4dcebc2_0.tar.bz2": { + "build": "eigen_py35h4dcebc2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7759d44436c0613cb974c8f7f1002f6b", + "name": "tensorflow-base", + "sha256": "a539ad6a06939c90486e6c442512df86e5ac34780b1f5a3ac8340be3252c9493", + "size": 51460793, + "subdir": "linux-64", + "timestamp": 1534975867024, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-eigen_py36h4dcebc2_0.tar.bz2": { + "build": "eigen_py36h4dcebc2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e010fb61be129dba98c53faf6d19fed1", + "name": "tensorflow-base", + "sha256": "0f57f78c7236184a54c8d0055af7c65315291c2821f03c51b57c7ca06951a5e3", + "size": 51407311, + "subdir": "linux-64", + "timestamp": 1534972347124, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-gpu_py27h3435052_0.tar.bz2": { + "build": "gpu_py27h3435052_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a96f1191ce19ea6aeaa7dda01e3ef427", + "name": "tensorflow-base", + "sha256": "de2c17ab6cccb8bf3fbf724d4900719ea0590dabb9ed3738ca6e20d374c97ead", + "size": 174598156, + "subdir": "linux-64", + "timestamp": 1534898323213, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-gpu_py27h6ecc378_0.tar.bz2": { + "build": "gpu_py27h6ecc378_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a28824c536161d86aed7cc2fb0c4972a", + "name": "tensorflow-base", + "sha256": "a478c841d72f8784f1dfafff3db3df9a54b9c25816f649cbf14d7378af0f72f3", + "size": 202119392, + "subdir": "linux-64", + "timestamp": 1534886963721, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-gpu_py27had579c0_0.tar.bz2": { + "build": "gpu_py27had579c0_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4fad488df798d0e40845aebcc21096cf", + "name": "tensorflow-base", + "sha256": "e24dddfa2a123a70b4b6e676e27efc7705897d8ca77732831005fb8e60bf32df", + "size": 199977344, + "subdir": "linux-64", + "timestamp": 1534965180285, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-gpu_py35h3435052_0.tar.bz2": { + "build": "gpu_py35h3435052_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1321d5dad37ae22a5038d02f04156749", + "name": "tensorflow-base", + "sha256": "5c1b37a7112efabb3d18a8a03c505d4e35a972afb31819c07306806f86a4b6fc", + "size": 174760280, + "subdir": "linux-64", + "timestamp": 1534896701563, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-gpu_py35h6ecc378_0.tar.bz2": { + "build": "gpu_py35h6ecc378_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4f0c331527e951f894a33d1fa0971bdb", + "name": "tensorflow-base", + "sha256": "7270f8d2df2d71781078ef851844d068ab0bea2a696e02c253a234e28767cce6", + "size": 202529228, + "subdir": "linux-64", + "timestamp": 1534888676415, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-gpu_py35had579c0_0.tar.bz2": { + "build": "gpu_py35had579c0_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5ce9991a5b584119cc34a54c89850f25", + "name": "tensorflow-base", + "sha256": "16972fcf974e8521ce4088e6e7f3a2a1f20118fec519ab48493c7b91849cab82", + "size": 199895130, + "subdir": "linux-64", + "timestamp": 1534963311292, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-gpu_py36h3435052_0.tar.bz2": { + "build": "gpu_py36h3435052_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6374f6b27f4aa2273b23613bc9b34b1e", + "name": "tensorflow-base", + "sha256": "f6f5753d69bd1d84f80f3534fa9a4a1e5da2696193e6325f392122cbc07e3da6", + "size": 174856980, + "subdir": "linux-64", + "timestamp": 1534899937566, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-gpu_py36h6ecc378_0.tar.bz2": { + "build": "gpu_py36h6ecc378_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9dea89a946ac027a1ac23ee81c7a6d11", + "name": "tensorflow-base", + "sha256": "182de2ff4d5c2d5d7818b277bfb654aae352155287cde384ae5c00188e3bc069", + "size": 202520749, + "subdir": "linux-64", + "timestamp": 1534885299423, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-gpu_py36had579c0_0.tar.bz2": { + "build": "gpu_py36had579c0_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ab032937b87db0a6af3ab91b9fa4516f", + "name": "tensorflow-base", + "sha256": "ab872f19e33010c4d7c48365558018ffd182ecacfb0959559a9279badee7cb04", + "size": 200034600, + "subdir": "linux-64", + "timestamp": 1534966994904, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-mkl_py27h3c3e929_0.tar.bz2": { + "build": "mkl_py27h3c3e929_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "41e323b0ab5c431a528e02634a30f34f", + "name": "tensorflow-base", + "sha256": "a9fb4295e9c6fb4efaf34bdcb224ad2c2f6420c141d2a1993e1ac0e26d6e0c1f", + "size": 85761816, + "subdir": "linux-64", + "timestamp": 1534977038629, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-mkl_py35h3c3e929_0.tar.bz2": { + "build": "mkl_py35h3c3e929_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1655fa1db42386642c40e5fae8006fb9", + "name": "tensorflow-base", + "sha256": "a800a209d1c64630bd403f51f09415c8816af7f6db0842c4145760945c15883c", + "size": 86117707, + "subdir": "linux-64", + "timestamp": 1534974854841, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-mkl_py36h3c3e929_0.tar.bz2": { + "build": "mkl_py36h3c3e929_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b112590816c0c65a28ac1559cf2c1ca1", + "name": "tensorflow-base", + "sha256": "e108ebf59bd424d575b7ac20f529ec972ef29a88a749d7e0cd059e7549bafb17", + "size": 85932218, + "subdir": "linux-64", + "timestamp": 1534973391894, + "version": "1.10.0" + }, + "tensorflow-base-1.11.0-eigen_py27h4dcebc2_0.tar.bz2": { + "build": "eigen_py27h4dcebc2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "69da8929e5f74dd6fd537d1adb7172f1", + "name": "tensorflow-base", + "sha256": "e1d5c3fd0d929a503a589228cfc7ddb728732998edcfdd916254788b8eebd4cb", + "size": 54991165, + "subdir": "linux-64", + "timestamp": 1538591156544, + "version": "1.11.0" + }, + "tensorflow-base-1.11.0-eigen_py36h4dcebc2_0.tar.bz2": { + "build": "eigen_py36h4dcebc2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "17da8dd3e84d111575a208f28462e701", + "name": "tensorflow-base", + "sha256": "99074151e9ff18bfe2040b7b7081c23a324a316951b82701608eb21e6eeeba38", + "size": 55112508, + "subdir": "linux-64", + "timestamp": 1538588221849, + "version": "1.11.0" + }, + "tensorflow-base-1.11.0-gpu_py27h8e0ae2d_0.tar.bz2": { + "build": "gpu_py27h8e0ae2d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a083e233e31e9537b4377a294c03ab1d", + "name": "tensorflow-base", + "sha256": "204b70fcd9b68760b48f29fa9a628489585fdd17a431a9fbaa6fb1d06150372d", + "size": 207909477, + "subdir": "linux-64", + "timestamp": 1538676300511, + "version": "1.11.0" + }, + "tensorflow-base-1.11.0-gpu_py27had579c0_0.tar.bz2": { + "build": "gpu_py27had579c0_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "88dd96f2e03314252341ae69ea613fc6", + "name": "tensorflow-base", + "sha256": "713012e8576f13c298c215037b56f4f3c96d7236264c6adb4fb642c8426c659d", + "size": 205351451, + "subdir": "linux-64", + "timestamp": 1538696059014, + "version": "1.11.0" + }, + "tensorflow-base-1.11.0-gpu_py36h8e0ae2d_0.tar.bz2": { + "build": "gpu_py36h8e0ae2d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9fead3b2ba65b6fe3ed5499e8246a2c5", + "name": "tensorflow-base", + "sha256": "21887813a2ef2e249d627abcaeb3ff56c1c9a4a208078dfeaba2dee27536a550", + "size": 208247863, + "subdir": "linux-64", + "timestamp": 1538673481399, + "version": "1.11.0" + }, + "tensorflow-base-1.11.0-gpu_py36had579c0_0.tar.bz2": { + "build": "gpu_py36had579c0_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f4c14ba06fddea4932671381f3732ec9", + "name": "tensorflow-base", + "sha256": "d8e6bfafc962347902876a1461cb580a03912fb3e3d29544c2553838b046b8a0", + "size": 205869094, + "subdir": "linux-64", + "timestamp": 1538693415620, + "version": "1.11.0" + }, + "tensorflow-base-1.11.0-mkl_py27h3c3e929_0.tar.bz2": { + "build": "mkl_py27h3c3e929_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "91ea861bcb19574b0e15b725fb4795b2", + "name": "tensorflow-base", + "sha256": "0bb4e0f8cad1965843351cfd9969f86c5c81116e576b6f6a1e4d2bed41caad4e", + "size": 87131803, + "subdir": "linux-64", + "timestamp": 1538589739754, + "version": "1.11.0" + }, + "tensorflow-base-1.11.0-mkl_py36h3c3e929_0.tar.bz2": { + "build": "mkl_py36h3c3e929_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2bdd9b33a67892a0ee8f29a979c9cb76", + "name": "tensorflow-base", + "sha256": "ea7e0b9c79d6054dc6681b1764d4d1827104e076f53183bfc249a6c89532dea7", + "size": 87450635, + "subdir": "linux-64", + "timestamp": 1538586408417, + "version": "1.11.0" + }, + "tensorflow-base-1.12.0-eigen_py27h4dcebc2_0.tar.bz2": { + "build": "eigen_py27h4dcebc2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f86ba6604017a5d5eb78eff69f4b5ce1", + "name": "tensorflow-base", + "sha256": "0211be81e1c45b7525e99b7a8dd65ab30f2b90cdec99f0ea7ca1f2788984f639", + "size": 71299096, + "subdir": "linux-64", + "timestamp": 1542081103736, + "version": "1.12.0" + }, + "tensorflow-base-1.12.0-eigen_py36h4dcebc2_0.tar.bz2": { + "build": "eigen_py36h4dcebc2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7b9ccbf9459754a8cc4441f847d2fd67", + "name": "tensorflow-base", + "sha256": "d9548040ce042f9801ca252fba908cbf94b2e96f29146fad861321adde6d7989", + "size": 71325782, + "subdir": "linux-64", + "timestamp": 1542075497694, + "version": "1.12.0" + }, + "tensorflow-base-1.12.0-gpu_py27h8e0ae2d_0.tar.bz2": { + "build": "gpu_py27h8e0ae2d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9fa8861115f691cca9276cada1c3cb4a", + "name": "tensorflow-base", + "sha256": "2f8030fb1df5f841fbc7fd048ccb40b4a6b8311a79e905ba381a5695b12cdf54", + "size": 229744926, + "subdir": "linux-64", + "timestamp": 1542144059823, + "version": "1.12.0" + }, + "tensorflow-base-1.12.0-gpu_py27had579c0_0.tar.bz2": { + "build": "gpu_py27had579c0_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e66d0ae5e0be12b358d967b2e456c2fd", + "name": "tensorflow-base", + "sha256": "67cf6295d4c47d77e11825dd643ddc5678b4ddfe1af7f3678db0e7c050dae7e4", + "size": 227873820, + "subdir": "linux-64", + "timestamp": 1542152838859, + "version": "1.12.0" + }, + "tensorflow-base-1.12.0-gpu_py36h8e0ae2d_0.tar.bz2": { + "build": "gpu_py36h8e0ae2d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7c71932829ee0541b8ce1cc801254cfa", + "name": "tensorflow-base", + "sha256": "1a78470d24094418e1f191c8c0314437b17b8b7b07b67519af7e1cca3dfd0eca", + "size": 230309674, + "subdir": "linux-64", + "timestamp": 1542138164161, + "version": "1.12.0" + }, + "tensorflow-base-1.12.0-gpu_py36had579c0_0.tar.bz2": { + "build": "gpu_py36had579c0_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "864a3bc0fbe130937986a5f187a48f29", + "name": "tensorflow-base", + "sha256": "e79a51405ec22b4dd68dca82fa6499920ac393332e34fe6b90bc92866fc38d57", + "size": 227480426, + "subdir": "linux-64", + "timestamp": 1542150119219, + "version": "1.12.0" + }, + "tensorflow-base-1.12.0-mkl_py27h3c3e929_0.tar.bz2": { + "build": "mkl_py27h3c3e929_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5f9bb557f0b3dbb85e96b7c6c895bf43", + "name": "tensorflow-base", + "sha256": "5af1333a61b47a701549b6872894fc193dbb1c78c5007c7569b2530600dfb688", + "size": 103330646, + "subdir": "linux-64", + "timestamp": 1542079698517, + "version": "1.12.0" + }, + "tensorflow-base-1.12.0-mkl_py36h3c3e929_0.tar.bz2": { + "build": "mkl_py36h3c3e929_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7749d68e4d6cfdd7b33b06e128501c6d", + "name": "tensorflow-base", + "sha256": "b923777b841452586813ed24348e84428b1550b89e5ebd0e0cb55d99dc7b640d", + "size": 103303229, + "subdir": "linux-64", + "timestamp": 1542076945263, + "version": "1.12.0" + }, + "tensorflow-base-1.13.1-eigen_py27hf4a566f_0.tar.bz2": { + "build": "eigen_py27hf4a566f_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fc54abc65b32d99a54fe58eaf363d315", + "name": "tensorflow-base", + "sha256": "dc97f25cfde45ee9a5f5d683af4bec57e2b31aee02298b6aeb2dd5542a656f64", + "size": 79079623, + "subdir": "linux-64", + "timestamp": 1554301668533, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-eigen_py36hf4a566f_0.tar.bz2": { + "build": "eigen_py36hf4a566f_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ff4c55224d13565d1b921961ad0f8764", + "name": "tensorflow-base", + "sha256": "adc4600385b53bac0b10c16499410c2fa874384f4e65753107105e2a390d3d04", + "size": 79100855, + "subdir": "linux-64", + "timestamp": 1554304926780, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-eigen_py37hf4a566f_0.tar.bz2": { + "build": "eigen_py37hf4a566f_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6656bec467dea225f013920ce4bc6c06", + "name": "tensorflow-base", + "sha256": "336a16f9fd6149a2089bfadc6cfe4f3f723828924e9b9a0b9900c6d6d3cbb259", + "size": 79151820, + "subdir": "linux-64", + "timestamp": 1554307836679, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-gpu_py27h611c6d2_0.tar.bz2": { + "build": "gpu_py27h611c6d2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3fd4f9ab7e3f6d99cb4b2e5694a525d4", + "name": "tensorflow-base", + "sha256": "267d0f435178b9cb1d57a434b9454746bbf994f34188436d69fa24f96fdcc73e", + "size": 281143117, + "subdir": "linux-64", + "timestamp": 1554428866551, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-gpu_py27h8d69cac_0.tar.bz2": { + "build": "gpu_py27h8d69cac_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a1e9b2e8215e83b866eb0971f22e6e98", + "name": "tensorflow-base", + "sha256": "1a4140139208afb99287c8e192315f8bcffbe2d7f014b12f6439e7bb86969f0d", + "size": 308406235, + "subdir": "linux-64", + "timestamp": 1554408187672, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-gpu_py27h8f37b9b_0.tar.bz2": { + "build": "gpu_py27h8f37b9b_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3618959f0523b52c847f9cedc936f706", + "name": "tensorflow-base", + "sha256": "652dd44f2526785436a5c7aeb1adaf0ee83fcdaecdb4881650d83fde09e9bc99", + "size": 284129743, + "subdir": "linux-64", + "timestamp": 1554474941685, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-gpu_py36h611c6d2_0.tar.bz2": { + "build": "gpu_py36h611c6d2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "aff3e76b4b261f84449396d79857c492", + "name": "tensorflow-base", + "sha256": "6fa21c1a5c45640b0747ad5f3dd58d4ea0aba37016468cd76eb6ef5496cdf46c", + "size": 281332725, + "subdir": "linux-64", + "timestamp": 1554440938874, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-gpu_py36h8d69cac_0.tar.bz2": { + "build": "gpu_py36h8d69cac_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "12a366a135a44005aa623fcb71c6b1b8", + "name": "tensorflow-base", + "sha256": "9c3d098b06cf8f63a0ccceffd749c1be256d94fc984ce5137b53f9f31402f486", + "size": 308118868, + "subdir": "linux-64", + "timestamp": 1554396820407, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-gpu_py36h8f37b9b_0.tar.bz2": { + "build": "gpu_py36h8f37b9b_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b5d00dfba00569b9abc00934bfecd88f", + "name": "tensorflow-base", + "sha256": "6976a8951a07e7161eb25bb5bb01e7b9b8742bfce535d3d66fe206e81a8e283d", + "size": 284819225, + "subdir": "linux-64", + "timestamp": 1554481710746, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-gpu_py37h611c6d2_0.tar.bz2": { + "build": "gpu_py37h611c6d2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "11497cdd58c5e5fe611f8b875f4c1f26", + "name": "tensorflow-base", + "sha256": "1005fca38d9300ab0c99ec47bf140ac51334782834d81f71aacbba3f1e0d49ad", + "size": 281413534, + "subdir": "linux-64", + "timestamp": 1554437103362, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-gpu_py37h8d69cac_0.tar.bz2": { + "build": "gpu_py37h8d69cac_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b05b15f5958bca08d72d380d34e92df3", + "name": "tensorflow-base", + "sha256": "aafbc189b6551814ade248fac17291b0a1f9b081639b8572b336f3c732068e82", + "size": 307776584, + "subdir": "linux-64", + "timestamp": 1554417482026, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-gpu_py37h8f37b9b_0.tar.bz2": { + "build": "gpu_py37h8f37b9b_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d51a0b11ea7af0db329e095cf772d58e", + "name": "tensorflow-base", + "sha256": "de418ac59e02d5ad1c609d5877bd7be5004384cc31f26ad6e4584e21866bc9a4", + "size": 284278614, + "subdir": "linux-64", + "timestamp": 1554488962365, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-mkl_py27h7ce6ba3_0.tar.bz2": { + "build": "mkl_py27h7ce6ba3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "db34c93ff98f0c5fa13b93c0fe49c8ff", + "name": "tensorflow-base", + "sha256": "d2572338f7049799a04d3fabe3ac580a42df21bf53b5b24fa7a8590b0d9c4cf3", + "size": 111967231, + "subdir": "linux-64", + "timestamp": 1554319628640, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-mkl_py36h7ce6ba3_0.tar.bz2": { + "build": "mkl_py36h7ce6ba3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "91c4421eb01f5eddfc88d95ea53bbdf6", + "name": "tensorflow-base", + "sha256": "b5c4a160ea2c0e741899b879d710b8a2df90e41b684aa7e64042fddf0bc38a37", + "size": 111785219, + "subdir": "linux-64", + "timestamp": 1554322300653, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-mkl_py37h7ce6ba3_0.tar.bz2": { + "build": "mkl_py37h7ce6ba3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "62c094d1ac9d58b39200fe5b2c4e2c37", + "name": "tensorflow-base", + "sha256": "1d120664595942d2e739d2924aaad67526561f1148bb1b3aa60f702c6fc2865d", + "size": 111896531, + "subdir": "linux-64", + "timestamp": 1554314673918, + "version": "1.13.1" + }, + "tensorflow-base-1.14.0-eigen_py27hf4a566f_0.tar.bz2": { + "build": "eigen_py27hf4a566f_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "future", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "21d428fd628b525e677aedab6394fa1d", + "name": "tensorflow-base", + "sha256": "ed1a14e839c73d1d8991e0b066ed21cb670f2682729d482fa1cf5fb05551caf7", + "size": 93464242, + "subdir": "linux-64", + "timestamp": 1561045220700, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-eigen_py36hf4a566f_0.tar.bz2": { + "build": "eigen_py36hf4a566f_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c97a990f3c72f2ed38200d0de4be665a", + "name": "tensorflow-base", + "sha256": "2084a087361992e84ec64db45636920bd608d3a9f3c4200102a651fe11437a17", + "size": 93711155, + "subdir": "linux-64", + "timestamp": 1560988476052, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-eigen_py37hf4a566f_0.tar.bz2": { + "build": "eigen_py37hf4a566f_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ae6d3345f5a2d1cf27e851cad63ee6d0", + "name": "tensorflow-base", + "sha256": "733436714f46b1e56f27252b84450f60f43904ed6e24a1a8b15cb552d7a6a0dc", + "size": 93662334, + "subdir": "linux-64", + "timestamp": 1560993194148, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py27h611c6d2_0.tar.bz2": { + "build": "gpu_py27h611c6d2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "enum34 >=1.1.6", + "future", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "94f7cfb5a4407ef4e20630d0f48a8c72", + "name": "tensorflow-base", + "sha256": "462ab64d8c1efa881ea6382523d1bbb42ff924b2bcfdcea73cfd4083a6b738fb", + "size": 316038679, + "subdir": "linux-64", + "timestamp": 1561546879977, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py27h8d69cac_0.tar.bz2": { + "build": "gpu_py27h8d69cac_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "enum34 >=1.1.6", + "future", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2cad50837b6556c86da6450ecb8c920c", + "name": "tensorflow-base", + "sha256": "4f19e97e343a9c40f485a15474f434371482a64f229490657d5afba65e94da18", + "size": 344505239, + "subdir": "linux-64", + "timestamp": 1561566952009, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py27h8f37b9b_0.tar.bz2": { + "build": "gpu_py27h8f37b9b_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "enum34 >=1.1.6", + "future", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "828ede633dd1d69930b4dccf8639dedb", + "name": "tensorflow-base", + "sha256": "2fff86c9f81ebd6533ce277e9c8e988ff62d90beb7c8f1f5ecc25e851642b0d3", + "size": 319362185, + "subdir": "linux-64", + "timestamp": 1561520844300, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py27he45bfe2_0.tar.bz2": { + "build": "gpu_py27he45bfe2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit >=10.1.168,<10.2.0a0", + "cudnn >=7.6.0,<8.0a0", + "cupti", + "enum34 >=1.1.6", + "future", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7accb514fe300e2b1ff812ba03d85825", + "name": "tensorflow-base", + "sha256": "193d1a890fc925fa06dd11ef9405e627a002b08396daa6c3f39c53cececa714c", + "size": 343188810, + "subdir": "linux-64", + "timestamp": 1561598429112, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py36h611c6d2_0.tar.bz2": { + "build": "gpu_py36h611c6d2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f1ba41759666629731397771610d8982", + "name": "tensorflow-base", + "sha256": "a199130f080e4b3f790c5546bfcfe2d256cb907ec071665aa5e907551f6df00d", + "size": 315638734, + "subdir": "linux-64", + "timestamp": 1561550571637, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py36h8d69cac_0.tar.bz2": { + "build": "gpu_py36h8d69cac_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fcb99996f76a07d28b129351d7b0c4f8", + "name": "tensorflow-base", + "sha256": "ad129d60c90afa5ad6d262aa8a205285eb6989a3bd9bda4c5d1c964004346ab8", + "size": 345149059, + "subdir": "linux-64", + "timestamp": 1561571251588, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py36h8f37b9b_0.tar.bz2": { + "build": "gpu_py36h8f37b9b_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d95fcb7f4999bb23956348972e907baf", + "name": "tensorflow-base", + "sha256": "189525ee77923ade2dc49511ba82ab70e9949b7c40162cfd6dc0bfd5c84216c9", + "size": 320427595, + "subdir": "linux-64", + "timestamp": 1561511610427, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py36he45bfe2_0.tar.bz2": { + "build": "gpu_py36he45bfe2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "cudatoolkit >=10.1.168,<10.2.0a0", + "cudnn >=7.6.0,<8.0a0", + "cupti", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "861477180955d6d0b8d3cc669c389c17", + "name": "tensorflow-base", + "sha256": "6a0821314b5a31828c90e3c4b6f7555dc2739ff41367f41f1372d37672aea5d0", + "size": 343549198, + "subdir": "linux-64", + "timestamp": 1561591373510, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py37h611c6d2_0.tar.bz2": { + "build": "gpu_py37h611c6d2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "69df5742c468d7a1a9decc7c15116bbe", + "name": "tensorflow-base", + "sha256": "5d7b06e2793e31b5ee5dd4771ec43c628b5141bfce7ff97be5b22582b2d2342d", + "size": 315759530, + "subdir": "linux-64", + "timestamp": 1561542990158, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py37h8d69cac_0.tar.bz2": { + "build": "gpu_py37h8d69cac_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2ca18fa6710cba1d95b4bacc6e9ab5eb", + "name": "tensorflow-base", + "sha256": "fd3da1569c17bd1ee20e4e3c3c49105550e63584a4f31598df3a7c39520b64c8", + "size": 344862611, + "subdir": "linux-64", + "timestamp": 1561575240142, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py37h8f37b9b_0.tar.bz2": { + "build": "gpu_py37h8f37b9b_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "84e43baffe639d6695936495b65fbb0c", + "name": "tensorflow-base", + "sha256": "3b5d93738645aadb2cb22051cc2355bf711ed05a7d4aa50efc0ab47d805c2086", + "size": 319300810, + "subdir": "linux-64", + "timestamp": 1561505600781, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py37he45bfe2_0.tar.bz2": { + "build": "gpu_py37he45bfe2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "cudatoolkit >=10.1.168,<10.2.0a0", + "cudnn >=7.6.0,<8.0a0", + "cupti", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "34e77b26b0582de60c4329090c8d0eb0", + "name": "tensorflow-base", + "sha256": "64075c88aa5d63820209c6bc282c9777cdae31ab99cebd633b4c15b8440f6d3f", + "size": 343843046, + "subdir": "linux-64", + "timestamp": 1561584865373, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-mkl_py27h7ce6ba3_0.tar.bz2": { + "build": "mkl_py27h7ce6ba3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "future", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6a420c8dc23023d6201343b0131b0f06", + "name": "tensorflow-base", + "sha256": "9a2706ca227aef99600c8463665efb64d7a29e2e7c34cb9b1d5129244631ea67", + "size": 123012911, + "subdir": "linux-64", + "timestamp": 1561048186700, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-mkl_py36h7ce6ba3_0.tar.bz2": { + "build": "mkl_py36h7ce6ba3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c96b8ae6f2d6876d47a8bc8fb63e3f4f", + "name": "tensorflow-base", + "sha256": "62bed520b12663ae845bbef0ea4e36c52bd7acb92a41d59386dc926faa00f014", + "size": 123029225, + "subdir": "linux-64", + "timestamp": 1560986225960, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-mkl_py37h7ce6ba3_0.tar.bz2": { + "build": "mkl_py37h7ce6ba3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4f0dd0ffb0ff59c7012eac3b3fd32f99", + "name": "tensorflow-base", + "sha256": "be1cb4eff58313ba5f49eb046f368e699385fe72963abca07ec8bf3dbe950618", + "size": 123081559, + "subdir": "linux-64", + "timestamp": 1560991017709, + "version": "1.14.0" + }, + "tensorflow-base-1.15.0-eigen_py27hd4672e3_0.tar.bz2": { + "build": "eigen_py27hd4672e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "backports.weakref >=1.0.0inf.1,<2.0a0", + "enum34 >=1.1.6,<2.0a0", + "future", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "mock >=2.0.0,<3.0a0", + "opt_einsum >=2.3.2,<3.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=2.7,<2.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fd6921c128e3898a35261607487292c8", + "name": "tensorflow-base", + "sha256": "86ec779c1eb5134caa11fde7a1efa55a08a36fc31ea44e784cd97aac2b247079", + "size": 94305764, + "subdir": "linux-64", + "timestamp": 1573095590157, + "version": "1.15.0" + }, + "tensorflow-base-1.15.0-eigen_py36h52b156a_0.tar.bz2": { + "build": "eigen_py36h52b156a_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.6,<3.7.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c87a7b8cf779d762d1afe05db1d33c2c", + "name": "tensorflow-base", + "sha256": "41af658413d2faeecbccaa5a1303846b6693f6086963ca187078310c8b7aa866", + "size": 94455313, + "subdir": "linux-64", + "timestamp": 1573070363381, + "version": "1.15.0" + }, + "tensorflow-base-1.15.0-eigen_py37h52b156a_0.tar.bz2": { + "build": "eigen_py37h52b156a_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.7,<3.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f824168c4820652d32fcbe692d746297", + "name": "tensorflow-base", + "sha256": "fcbc5be7e2a0c2a4b544bd5dafd458f36d3171cef01a941c0528c8f09477fa34", + "size": 94473072, + "subdir": "linux-64", + "timestamp": 1573088299487, + "version": "1.15.0" + }, + "tensorflow-base-1.15.0-gpu_py27hf473bbb_0.tar.bz2": { + "build": "gpu_py27hf473bbb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "backports.weakref >=1.0.0inf.1,<2.0a0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.4,<8.0a0", + "cupti", + "enum34 >=1.1.6,<2.0a0", + "future", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "mock >=2.0.0,<3.0a0", + "numpy >=1.16.5,<2.0a0", + "opt_einsum >=2.3.2,<3.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=2.7,<2.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1ea30be9783539a0359e39baa7764b5c", + "name": "tensorflow-base", + "sha256": "52984d441cec0a3df46dffc04a9feff299e259a8df48cf1fd6096a0770f74712", + "size": 374315529, + "subdir": "linux-64", + "timestamp": 1573243833688, + "version": "1.15.0" + }, + "tensorflow-base-1.15.0-gpu_py36h9dcbed7_0.tar.bz2": { + "build": "gpu_py36h9dcbed7_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.4,<8.0a0", + "cupti", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "numpy >=1.16.5,<2.0a0", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.6,<3.7.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e459e45c7571ea35226a9070c0396f04", + "name": "tensorflow-base", + "sha256": "0bc709a4c65dc98c96804ad397cca0f94cb95aa3376c1a4a0db5ed2027ce603c", + "size": 374437151, + "subdir": "linux-64", + "timestamp": 1573253133339, + "version": "1.15.0" + }, + "tensorflow-base-1.15.0-gpu_py37h9dcbed7_0.tar.bz2": { + "build": "gpu_py37h9dcbed7_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.4,<8.0a0", + "cupti", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "numpy >=1.16.5,<2.0a0", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.7,<3.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "95376bb747651d1ac8aaddb20ac45bac", + "name": "tensorflow-base", + "sha256": "af94ec8e84cebd76dcff25b7300d763b3292e7e260ae8dadbd34674d74af6986", + "size": 374520908, + "subdir": "linux-64", + "timestamp": 1573156246826, + "version": "1.15.0" + }, + "tensorflow-base-1.15.0-mkl_py27h503033c_0.tar.bz2": { + "build": "mkl_py27h503033c_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "backports.weakref >=1.0.0inf.1,<2.0a0", + "enum34 >=1.1.6,<2.0a0", + "future", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "mock >=2.0.0,<3.0a0", + "opt_einsum >=2.3.2,<3.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=2.7,<2.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6d9b311443bc3d9a8052416411ca538e", + "name": "tensorflow-base", + "sha256": "2bca8936e176f1d4828450594385a5ffe9854b6842654aade768076c332e70bc", + "size": 124956714, + "subdir": "linux-64", + "timestamp": 1573092604419, + "version": "1.15.0" + }, + "tensorflow-base-1.15.0-mkl_py36he1670d9_0.tar.bz2": { + "build": "mkl_py36he1670d9_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.6,<3.7.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0bbfeb9c54061d7cafe254939fd9655a", + "name": "tensorflow-base", + "sha256": "24fd8642df29a0675e9e0374bb37f25d514cf77c893b508641a5e3c998813940", + "size": 124967037, + "subdir": "linux-64", + "timestamp": 1573073622545, + "version": "1.15.0" + }, + "tensorflow-base-1.15.0-mkl_py37he1670d9_0.tar.bz2": { + "build": "mkl_py37he1670d9_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.7,<3.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f4229cfb9e73652ff3d09dc2aae29ed1", + "name": "tensorflow-base", + "sha256": "1885c48ca9bf45e0595a346e95c6992cc21c6f30ea713b5a56c3a910e84ec37d", + "size": 124988194, + "subdir": "linux-64", + "timestamp": 1573085149789, + "version": "1.15.0" + }, + "tensorflow-base-1.4.1-py27hd00c003_2.tar.bz2": { + "build": "py27hd00c003_2", + "build_number": 2, + "depends": [ + "enum34 >=1.1.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.3.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4eba09b4ff04676f08e8fe870f87dacb", + "name": "tensorflow-base", + "sha256": "1f0fd8416791c248683834484b18181264ca4ce9d9a6f1e59e138e46033ff82d", + "size": 34183711, + "subdir": "linux-64", + "timestamp": 1516402489774, + "version": "1.4.1" + }, + "tensorflow-base-1.4.1-py35hd00c003_2.tar.bz2": { + "build": "py35hd00c003_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.3.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cd507990fad9057d34a62eee0c8dda0c", + "name": "tensorflow-base", + "sha256": "ed4f879519d6f555f1e70df3e1a1d3351b5896634e28f9ec297f97e37086e232", + "size": 34323004, + "subdir": "linux-64", + "timestamp": 1516402697312, + "version": "1.4.1" + }, + "tensorflow-base-1.4.1-py36hd00c003_2.tar.bz2": { + "build": "py36hd00c003_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.3.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e486d6a29a510afb23a481845cde933e", + "name": "tensorflow-base", + "sha256": "8a4b1e1170c7ed351f2693a8246bf55a58c97df167b0f9dd578c82c801efef0d", + "size": 34271099, + "subdir": "linux-64", + "timestamp": 1516399935071, + "version": "1.4.1" + }, + "tensorflow-base-1.5.0-py27hff88cb2_1.tar.bz2": { + "build": "py27hff88cb2_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl", + "mock >=2.0.0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e473fc8084c3fe142e04638d1c8779c6", + "name": "tensorflow-base", + "sha256": "40574ca46a1af9afedbb47115150b1001a0a462a6d240f33e7bb2fbab7535777", + "size": 39804709, + "subdir": "linux-64", + "timestamp": 1519535882351, + "version": "1.5.0" + }, + "tensorflow-base-1.5.0-py35hff88cb2_1.tar.bz2": { + "build": "py35hff88cb2_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3b290638b281d69b1bf398a4fd5a8ec9", + "name": "tensorflow-base", + "sha256": "264faab5dd1fa6c60a3d5e9be81e299250dab53bdb9f3ce15b93e9ae65f39310", + "size": 39991274, + "subdir": "linux-64", + "timestamp": 1519467261172, + "version": "1.5.0" + }, + "tensorflow-base-1.5.0-py36hff88cb2_1.tar.bz2": { + "build": "py36hff88cb2_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "44b63eb3ff548a59c2e4e5e7fa1ccd06", + "name": "tensorflow-base", + "sha256": "4d94a46dd5775c288e2f27206578b790a501919d3c6bf29bbda850932f469d1c", + "size": 40001191, + "subdir": "linux-64", + "timestamp": 1519494029516, + "version": "1.5.0" + }, + "tensorflow-base-1.6.0-py27hdbcaa40_1.tar.bz2": { + "build": "py27hdbcaa40_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0693727c92ab1198d4a9d148f8c71990", + "name": "tensorflow-base", + "sha256": "3036b6e51357439ab2644884478dde34ff45efdab7a0b87c1fbea244c8fa558b", + "size": 38314477, + "subdir": "linux-64", + "timestamp": 1525894556062, + "version": "1.6.0" + }, + "tensorflow-base-1.6.0-py27hff88cb2_0.tar.bz2": { + "build": "py27hff88cb2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d19804bc6fc4e223e78ffae93a61f0a3", + "name": "tensorflow-base", + "sha256": "b68bf98bbaa69b5803dd81800c480d25dba0e3d31b3f5fdf3c5c7177b53289fd", + "size": 41161776, + "subdir": "linux-64", + "timestamp": 1521151929472, + "version": "1.6.0" + }, + "tensorflow-base-1.6.0-py35hdbcaa40_1.tar.bz2": { + "build": "py35hdbcaa40_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a803b8ffad9311c6aa7227479fa956f6", + "name": "tensorflow-base", + "sha256": "9dcc2e5974857eddcfcaede015f31cf1b9635095a31263531c570468e1da9935", + "size": 38529598, + "subdir": "linux-64", + "timestamp": 1525894557457, + "version": "1.6.0" + }, + "tensorflow-base-1.6.0-py35hff88cb2_0.tar.bz2": { + "build": "py35hff88cb2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c1eccaa5a10bc437397222a94e8c5ea8", + "name": "tensorflow-base", + "sha256": "591eb4e1a4779bc19b4ba47a65875a69853eb078bd74cf0c7c446355fa12de3e", + "size": 41357502, + "subdir": "linux-64", + "timestamp": 1521176075311, + "version": "1.6.0" + }, + "tensorflow-base-1.6.0-py36hdbcaa40_1.tar.bz2": { + "build": "py36hdbcaa40_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c00eb5b34aab2d787caa7917e72a859e", + "name": "tensorflow-base", + "sha256": "6159300b9340324f5ef8c0104d8881855fb47fd5dcb5e98c25be401721172098", + "size": 38479685, + "subdir": "linux-64", + "timestamp": 1525894614592, + "version": "1.6.0" + }, + "tensorflow-base-1.6.0-py36hff88cb2_0.tar.bz2": { + "build": "py36hff88cb2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3ba7c13e7ea6f113202f3c27d04a391c", + "name": "tensorflow-base", + "sha256": "b271c960d3bb7531061b08fbc2c6ff25c7fe736b9cac841ca9b4ed574b3c4144", + "size": 41334385, + "subdir": "linux-64", + "timestamp": 1521176284348, + "version": "1.6.0" + }, + "tensorflow-base-1.7.0-py27hdbcaa40_2.tar.bz2": { + "build": "py27hdbcaa40_2", + "build_number": 2, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6fd3fc43785286c30867294a9c57ab3a", + "name": "tensorflow-base", + "sha256": "2079dd0e7550fee408c73fc35d8318e920d6ec073afaad1f287aaa45346f230a", + "size": 40517434, + "subdir": "linux-64", + "timestamp": 1525883251042, + "version": "1.7.0" + }, + "tensorflow-base-1.7.0-py27hff88cb2_0.tar.bz2": { + "build": "py27hff88cb2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "82115abc3e0285e251899167e332588b", + "name": "tensorflow-base", + "sha256": "1efa01134cff0869287674dd0977b850e686b32cf310e121fc2602873164dc25", + "size": 43766509, + "subdir": "linux-64", + "timestamp": 1524273608030, + "version": "1.7.0" + }, + "tensorflow-base-1.7.0-py35hdbcaa40_2.tar.bz2": { + "build": "py35hdbcaa40_2", + "build_number": 2, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "97d6a9455ec7728b46913be0c7001489", + "name": "tensorflow-base", + "sha256": "172fee595d781380a07e4d673ee2c156a3bf23f40c0f067bca2c32fe381a932a", + "size": 40716619, + "subdir": "linux-64", + "timestamp": 1525886989699, + "version": "1.7.0" + }, + "tensorflow-base-1.7.0-py35hff88cb2_0.tar.bz2": { + "build": "py35hff88cb2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "72deccd3a6a4b1a3e31b2ecc500e741c", + "name": "tensorflow-base", + "sha256": "5737e823cc0e2ed48681f49c21b00fc8b9659eac361eca65d73bf574e07fda39", + "size": 43942390, + "subdir": "linux-64", + "timestamp": 1524273560912, + "version": "1.7.0" + }, + "tensorflow-base-1.7.0-py36hdbcaa40_2.tar.bz2": { + "build": "py36hdbcaa40_2", + "build_number": 2, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "27f1ed4f807adf077ceb036d0010cf15", + "name": "tensorflow-base", + "sha256": "678741d560d5772d898d3e809b3f70ede8753bc9b2f73d9c2b5a4d4325c6ea7e", + "size": 40590562, + "subdir": "linux-64", + "timestamp": 1525886988498, + "version": "1.7.0" + }, + "tensorflow-base-1.7.0-py36hff88cb2_0.tar.bz2": { + "build": "py36hff88cb2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cded1489edb9567985e569f49ebc941d", + "name": "tensorflow-base", + "sha256": "46e7f42caa799eacf564b0af8fca819847c8b214641cc0c07be5cabb34e7e702", + "size": 43857151, + "subdir": "linux-64", + "timestamp": 1524271577294, + "version": "1.7.0" + }, + "tensorflow-base-1.8.0-py27h4df133c_0.tar.bz2": { + "build": "py27h4df133c_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e43ae7d472156b1b74946e9f64528b4e", + "name": "tensorflow-base", + "sha256": "096cd48b4f9a96f90ebc2d8066abf375ff535ac8b484c53d7247403ea243995d", + "size": 144419398, + "subdir": "linux-64", + "timestamp": 1527168757820, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py27h5f64886_0.tar.bz2": { + "build": "py27h5f64886_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3fb9e6ce78d125b8b38254fca986c40f", + "name": "tensorflow-base", + "sha256": "7b66abb5277f5eeb049bb1a44a5d40e71201e3a4e445638d477af3cb0d29001f", + "size": 41947102, + "subdir": "linux-64", + "timestamp": 1527045820681, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py27hc1a7637_0.tar.bz2": { + "build": "py27hc1a7637_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "eda65df0eacdbf9f21fcd2fa9686597c", + "name": "tensorflow-base", + "sha256": "9c38118a42522124ff854f27a177627c744e2805e16db233303ff6fd1a235ed9", + "size": 168278518, + "subdir": "linux-64", + "timestamp": 1527180195584, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py27hee38f2d_0.tar.bz2": { + "build": "py27hee38f2d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "761cebbea2a01ee44dbc340495923a72", + "name": "tensorflow-base", + "sha256": "ecaa52bef2699d3c79db0a3587bda4ee342c5631d0b40cf238d824dd9d736ab6", + "size": 75328000, + "subdir": "linux-64", + "timestamp": 1527061395268, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py35h4df133c_0.tar.bz2": { + "build": "py35h4df133c_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f9d60503a31588623e8ff3271de7f988", + "name": "tensorflow-base", + "sha256": "5f4cbd06e81e842afa804bca53146989fbd67c8463aa55883710a0a85dd67f89", + "size": 144758474, + "subdir": "linux-64", + "timestamp": 1527171933295, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py35h5f64886_0.tar.bz2": { + "build": "py35h5f64886_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "82d4ecc8161c308cd486a1f5c430ffac", + "name": "tensorflow-base", + "sha256": "cd18565d83408e9c01e6342884a41a20fceb7d20665e276c99d21203bf2efe46", + "size": 42057722, + "subdir": "linux-64", + "timestamp": 1527045891435, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py35hc1a7637_0.tar.bz2": { + "build": "py35hc1a7637_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "831deb23e8dea9bf386a14b228b5a7a9", + "name": "tensorflow-base", + "sha256": "afab17e34421c654cf211c3b1fb4993b77fa952ec144a9e2e3dddd62ccb7a58a", + "size": 168590226, + "subdir": "linux-64", + "timestamp": 1527183144886, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py35hee38f2d_0.tar.bz2": { + "build": "py35hee38f2d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "efeec4905d3c8070aed2836041b4b224", + "name": "tensorflow-base", + "sha256": "871dec5d88b539b7d96a2b63535fc0bb0112d3b7c4dc8ce25f7479b99b94b210", + "size": 75369942, + "subdir": "linux-64", + "timestamp": 1527061464305, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py36h4df133c_0.tar.bz2": { + "build": "py36h4df133c_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "006e29747cecaa9e96d2054a22b9e1c2", + "name": "tensorflow-base", + "sha256": "bf0943670e02d7275e7e79a482717a46cae8ff5eb5debeeb2bec78489d2939dc", + "size": 144925772, + "subdir": "linux-64", + "timestamp": 1527164465407, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py36h5f64886_0.tar.bz2": { + "build": "py36h5f64886_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c3eaf0fb47e3b6ac9cebf44afcb76755", + "name": "tensorflow-base", + "sha256": "659b960a5c1ef969e7d90c58e8bf8ddfb5291c3ee820393f94ca88fc7477f082", + "size": 42045614, + "subdir": "linux-64", + "timestamp": 1527041027886, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py36hc1a7637_0.tar.bz2": { + "build": "py36hc1a7637_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9a7f1721fc64414caba4376da983f989", + "name": "tensorflow-base", + "sha256": "c557cc861009a78a3cd7d06d8573718c09c800295bff7c68993b3e2144e809de", + "size": 169099199, + "subdir": "linux-64", + "timestamp": 1527176803509, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py36hee38f2d_0.tar.bz2": { + "build": "py36hee38f2d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f317b8a614420ec1f500f823b329ae32", + "name": "tensorflow-base", + "sha256": "b2375581484b7c2dd52e1e346904c03a7b82a89c2f2ac094a44937606399b8a1", + "size": 75356339, + "subdir": "linux-64", + "timestamp": 1527061395250, + "version": "1.8.0" + }, + "tensorflow-base-1.9.0-eigen_py27hdfca3bf_0.tar.bz2": { + "build": "eigen_py27hdfca3bf_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "49f424b13b2a39a7ce35c5af7339f33e", + "name": "tensorflow-base", + "sha256": "7e427c4fc72cba13448a42b96d85120446a7a1570ab3db79aee340c50d1934d4", + "size": 44802348, + "subdir": "linux-64", + "timestamp": 1532467501690, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-eigen_py35hdfca3bf_0.tar.bz2": { + "build": "eigen_py35hdfca3bf_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cd17df91261d779bd7f8c9add322c92d", + "name": "tensorflow-base", + "sha256": "7701966f6ae1883194fa77e67abb985e8d12d6791798750108f9b7943de290e7", + "size": 44867498, + "subdir": "linux-64", + "timestamp": 1532469529610, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-eigen_py36hdfca3bf_0.tar.bz2": { + "build": "eigen_py36hdfca3bf_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "81d75dcb5b6915b95b1eed6b4a3d74e6", + "name": "tensorflow-base", + "sha256": "cb6e0d5ac82a99c79e0720fa39fa62fe742f1b0964f404b97310830e1be953ec", + "size": 44970072, + "subdir": "linux-64", + "timestamp": 1532464098777, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-gpu_py27h6ecc378_0.tar.bz2": { + "build": "gpu_py27h6ecc378_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "57ca3a5943de34f7920c7f5da9c4140d", + "name": "tensorflow-base", + "sha256": "b781b4691d599d8c9a9b3ced4120a8c5f9f5e54715077a28312f28df364c49e7", + "size": 179256744, + "subdir": "linux-64", + "timestamp": 1532620092714, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-gpu_py27h9f529ab_0.tar.bz2": { + "build": "gpu_py27h9f529ab_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0", + "package_has_been_revoked", + "package_has_been_revoked" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "71fd646a0eba9fe055fccd5ee66bc5ac", + "name": "tensorflow-base", + "revoked": true, + "sha256": "b67459bab08549174797d9808df5b1973b4ffd7f46c1c564363273b7562ebb5a", + "size": 152630848, + "subdir": "linux-64", + "timestamp": 1532639215060, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-gpu_py27h9f529ab_1.tar.bz2": { + "build": "gpu_py27h9f529ab_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7d742982c9c96b123e948f9bcbe0a019", + "name": "tensorflow-base", + "sha256": "943ac3b3c186ad7469f75a5525803386728cf2cfc02b28cd3f3edd0959f46d21", + "size": 152493600, + "subdir": "linux-64", + "timestamp": 1532639215060, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-gpu_py35h6ecc378_0.tar.bz2": { + "build": "gpu_py35h6ecc378_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "117049f3d42fad308bf3b54a07d4c984", + "name": "tensorflow-base", + "sha256": "8c0306afba5a7c5779dd2dbcc5b72b704973d952f0e9846403691eaedd60b053", + "size": 179231018, + "subdir": "linux-64", + "timestamp": 1532621825865, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-gpu_py35h9f529ab_0.tar.bz2": { + "build": "gpu_py35h9f529ab_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0", + "package_has_been_revoked", + "package_has_been_revoked" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8e09521379d92a6842d368cc246d42c6", + "name": "tensorflow-base", + "revoked": true, + "sha256": "b39360efd0bb6a79eaa232541e23375e4fc39f79b9b137bc49a8fcd9d12fb97d", + "size": 152886968, + "subdir": "linux-64", + "timestamp": 1532640820146, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-gpu_py35h9f529ab_1.tar.bz2": { + "build": "gpu_py35h9f529ab_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3642e79798eb0308415b387f60119b7c", + "name": "tensorflow-base", + "sha256": "2454bbd7769bd7837551fae02a7733c03464e173825b3a613584416196dfe435", + "size": 152451575, + "subdir": "linux-64", + "timestamp": 1532640820146, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-gpu_py36h6ecc378_0.tar.bz2": { + "build": "gpu_py36h6ecc378_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ae5225aca6f4e25f564ebaae6421112f", + "name": "tensorflow-base", + "sha256": "03a8cbd2adca151a9153ffeb64dbf663005d871bdf9f533199162650967e5561", + "size": 179130211, + "subdir": "linux-64", + "timestamp": 1532617321129, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-gpu_py36h9f529ab_0.tar.bz2": { + "build": "gpu_py36h9f529ab_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0", + "package_has_been_revoked", + "package_has_been_revoked" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9b4cf9af747a48ad36a30d1022dac140", + "name": "tensorflow-base", + "revoked": true, + "sha256": "6ccf8a1f4a2c2d668cd85b6058b535e374b0fc525df9a98c267015606ea5a0f2", + "size": 153517666, + "subdir": "linux-64", + "timestamp": 1532636773336, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-gpu_py36h9f529ab_1.tar.bz2": { + "build": "gpu_py36h9f529ab_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c61ea9b6e276ce9567728f380d64ca35", + "name": "tensorflow-base", + "sha256": "ae117c880ce9fe2eb5d7e2c128ca4a4e348e185161e6b97458a512f11f037bee", + "size": 152368512, + "subdir": "linux-64", + "timestamp": 1532636773336, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-mkl_py27h2ca6a6a_0.tar.bz2": { + "build": "mkl_py27h2ca6a6a_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7ec07473539c413cbacee8156f046ae5", + "name": "tensorflow-base", + "sha256": "7f5c0987a057f312755a82fa9f2ce5989ac805cbce584fdea97ce1d04d856e54", + "size": 79354960, + "subdir": "linux-64", + "timestamp": 1532466569453, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-mkl_py35h2ca6a6a_0.tar.bz2": { + "build": "mkl_py35h2ca6a6a_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4c1f69004378a4f1fa279807f6977b90", + "name": "tensorflow-base", + "sha256": "28b315224b183aaf470567dc8d751490fead1a712b90fdbc0022a972a21a6b83", + "size": 79493580, + "subdir": "linux-64", + "timestamp": 1532468554085, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-mkl_py36h2ca6a6a_0.tar.bz2": { + "build": "mkl_py36h2ca6a6a_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7ae2315d3cdc8ca7a99b6408745222ee", + "name": "tensorflow-base", + "sha256": "ac4c050d1f8567d7f6fb84b2a63c9ae63d5fd88108635eae34638721fd421245", + "size": 79383313, + "subdir": "linux-64", + "timestamp": 1532465095637, + "version": "1.9.0" + }, + "tensorflow-base-2.0.0-eigen_py27hce92a77_0.tar.bz2": { + "build": "eigen_py27hce92a77_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "backports.weakref >=1.0.0inf.1,<2.0a0", + "enum34 >=1.1.6,<2.0a0", + "future", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "mock >=2.0.0,<3.0a0", + "opt_einsum >=2.3.2,<3.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=2.7,<2.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f475adad5e9c9fddd0021724a5b7aa2d", + "name": "tensorflow-base", + "sha256": "c2981340c043e73a67b785d4d3fad2452040bf03d47a4547059f6a67471934ce", + "size": 72011203, + "subdir": "linux-64", + "timestamp": 1571430043669, + "version": "2.0.0" + }, + "tensorflow-base-2.0.0-eigen_py36h4ed9498_0.tar.bz2": { + "build": "eigen_py36h4ed9498_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.6,<3.7.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "57337e86dbeaa9b505de2765994ba9e5", + "name": "tensorflow-base", + "sha256": "8785f3b051a2ec00620aa81c92bc1567428ee6e4924a5d0aa8357528eeb79435", + "size": 72298824, + "subdir": "linux-64", + "timestamp": 1571424691149, + "version": "2.0.0" + }, + "tensorflow-base-2.0.0-eigen_py37h4ed9498_0.tar.bz2": { + "build": "eigen_py37h4ed9498_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.7,<3.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "92d53926263821ba4d2f8328beac0277", + "name": "tensorflow-base", + "sha256": "d6d239d6e9381938b7cca2790c251d99231a0b6b882525382ae5e1563560541a", + "size": 72311739, + "subdir": "linux-64", + "timestamp": 1571418185158, + "version": "2.0.0" + }, + "tensorflow-base-2.0.0-gpu_py27h356bb79_0.tar.bz2": { + "build": "gpu_py27h356bb79_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "backports.weakref >=1.0.0inf.1,<2.0a0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6.0,<8.0a0", + "cupti", + "enum34 >=1.1.6,<2.0a0", + "future", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "mock >=2.0.0,<3.0a0", + "opt_einsum >=2.3.2,<3.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=2.7,<2.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6ea1814544cd3d27e51a9f63775e3f8c", + "name": "tensorflow-base", + "sha256": "531c6450b158e77207b291948a76bce96c567aa008ebb5bdd53a4beef639f741", + "size": 345769431, + "subdir": "linux-64", + "timestamp": 1571692376358, + "version": "2.0.0" + }, + "tensorflow-base-2.0.0-gpu_py36h0ec5d1f_0.tar.bz2": { + "build": "gpu_py36h0ec5d1f_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6.0,<8.0a0", + "cupti", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.6,<3.7.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f73a8fd573c604234d085f24c452d8c2", + "name": "tensorflow-base", + "sha256": "a922d6f9e7d9deb506415c1a4e29415a98814c4a4cb70f6d552df8100c0a50d1", + "size": 345940274, + "subdir": "linux-64", + "timestamp": 1571686492444, + "version": "2.0.0" + }, + "tensorflow-base-2.0.0-gpu_py37h0ec5d1f_0.tar.bz2": { + "build": "gpu_py37h0ec5d1f_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6.0,<8.0a0", + "cupti", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.7,<3.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9cf5e2d1537c8290e613f22c6bae27c6", + "name": "tensorflow-base", + "sha256": "4ceb57b52e8e0df147a9051f22bb52fef6d2a91995a3c5382e99c4631a8c5324", + "size": 345987686, + "subdir": "linux-64", + "timestamp": 1571680265061, + "version": "2.0.0" + }, + "tensorflow-base-2.0.0-mkl_py27had7a488_0.tar.bz2": { + "build": "mkl_py27had7a488_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "backports.weakref >=1.0.0inf.1,<2.0a0", + "enum34 >=1.1.6,<2.0a0", + "future", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "mock >=2.0.0,<3.0a0", + "opt_einsum >=2.3.2,<3.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=2.7,<2.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2ee08853e9b8dee765fb7aee3f25ee01", + "name": "tensorflow-base", + "sha256": "aec8ec4fc78d5e53c2513d1d46d6d8eb116a6e42da6c68551f547bacbd441565", + "size": 105673098, + "subdir": "linux-64", + "timestamp": 1571427739657, + "version": "2.0.0" + }, + "tensorflow-base-2.0.0-mkl_py36h9204916_0.tar.bz2": { + "build": "mkl_py36h9204916_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.6,<3.7.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "af44f89fe1eb459051a880e89a3f133d", + "name": "tensorflow-base", + "sha256": "8fa9c1a8cbdbe6881a7721c9c2d64ee3889687fa21b3b9d7cb9ec61af8adbd5a", + "size": 105843909, + "subdir": "linux-64", + "timestamp": 1571422667762, + "version": "2.0.0" + }, + "tensorflow-base-2.0.0-mkl_py37h9204916_0.tar.bz2": { + "build": "mkl_py37h9204916_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.7,<3.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5f65aaf34339b9e39e43d0a5e881cb38", + "name": "tensorflow-base", + "sha256": "620c06c03c57d7c772c09ea956a3da8a96ee56d9dc227270cb53bc44e861ad9c", + "size": 105884150, + "subdir": "linux-64", + "timestamp": 1571416221300, + "version": "2.0.0" + }, + "tensorflow-base-2.1.0-eigen_py27hedad41d_0.tar.bz2": { + "build": "eigen_py27hedad41d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astor >=0.6.2", + "backports.weakref >=1.0", + "enum34 >=1.1.6", + "functools32 >=3.2.3.2", + "future", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7", + "grpcio >=1.14.1", + "keras-applications >=1.0.8", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=2.7,<2.8.0a0", + "scipy >=1.2.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3c840dcca498d326842a034e80960773", + "name": "tensorflow-base", + "sha256": "ff80ae33e0d717e683f0b106c4c29be033cb113181e4b1d827e352d87341d42a", + "size": 87247285, + "subdir": "linux-64", + "timestamp": 1582004093834, + "version": "2.1.0" + }, + "tensorflow-base-2.1.0-eigen_py36h0c57e5d_0.tar.bz2": { + "build": "eigen_py36h0c57e5d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astor >=0.6.2", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7", + "grpcio >=1.14.1", + "keras-applications >=1.0.8", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.8.0", + "python >=3.6,<3.7.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d4ada06004610b6ff3069d4407cc885a", + "name": "tensorflow-base", + "sha256": "0a8059bc64c7fdba23e858f5a9677fb3f20bdf9296c06bb13f3701dce8450ae2", + "size": 87175012, + "subdir": "linux-64", + "timestamp": 1582037582444, + "version": "2.1.0" + }, + "tensorflow-base-2.1.0-eigen_py37h0c57e5d_0.tar.bz2": { + "build": "eigen_py37h0c57e5d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astor >=0.6.2", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7", + "grpcio >=1.14.1", + "keras-applications >=1.0.8", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.8.0", + "python >=3.7,<3.8.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "12cacb712dbb74a6c6051ba283566bf9", + "name": "tensorflow-base", + "sha256": "0576c53bb659ed4c79acd697a54b8242a2c9d0ee4636a79953e670bf991d9fd5", + "size": 87247908, + "subdir": "linux-64", + "timestamp": 1581993773849, + "version": "2.1.0" + }, + "tensorflow-base-2.1.0-gpu_py27hb9b3ea8_0.tar.bz2": { + "build": "gpu_py27hb9b3ea8_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astor >=0.6.2", + "backports.weakref >=1.0", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "cupti", + "enum34 >=1.1.6", + "functools32 >=3.2.3.2", + "future", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7", + "grpcio >=1.14.1", + "keras-applications >=1.0.8", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=2.7,<2.8.0a0", + "scipy >=1.2.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "43788faffcb9ac435a6281afb08efb1f", + "name": "tensorflow-base", + "sha256": "a1d516836ab842ee19f35df95ce9dabb4c168048b9ef6930092ede60827ad91f", + "size": 382354812, + "subdir": "linux-64", + "timestamp": 1582127345546, + "version": "2.1.0" + }, + "tensorflow-base-2.1.0-gpu_py36h6c5654b_0.tar.bz2": { + "build": "gpu_py36h6c5654b_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astor >=0.6.2", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "cupti", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7", + "grpcio >=1.14.1", + "keras-applications >=1.0.8", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.8.0", + "python >=3.6,<3.7.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "93dddb90bb1bc7d66b53d45254995ea0", + "name": "tensorflow-base", + "sha256": "de261fe735fa8f2b40f50ab5c47ac9a8b884123532162cd585cf33c23165f202", + "size": 382037530, + "subdir": "linux-64", + "timestamp": 1582137937791, + "version": "2.1.0" + }, + "tensorflow-base-2.1.0-gpu_py37h6c5654b_0.tar.bz2": { + "build": "gpu_py37h6c5654b_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astor >=0.6.2", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "cupti", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7", + "grpcio >=1.14.1", + "keras-applications >=1.0.8", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.8.0", + "python >=3.7,<3.8.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c4178bdf1057c96286c40198302143d9", + "name": "tensorflow-base", + "sha256": "f82f79482414be95b0fe8c8cbd56c5797013ba84cbddbc88a539806dff0df68c", + "size": 382707916, + "subdir": "linux-64", + "timestamp": 1582085009709, + "version": "2.1.0" + }, + "tensorflow-base-2.1.0-mkl_py27hb6fb96e_0.tar.bz2": { + "build": "mkl_py27hb6fb96e_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astor >=0.6.2", + "backports.weakref >=1.0", + "enum34 >=1.1.6", + "functools32 >=3.2.3.2", + "future", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7", + "grpcio >=1.14.1", + "keras-applications >=1.0.8", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=2.7,<2.8.0a0", + "scipy >=1.2.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0edfee8e1596aaaf37437206fcc33747", + "name": "tensorflow-base", + "sha256": "e78cbdca28b4823515d6e988571a744157d2cac87410e64b54f8b4c66a016c58", + "size": 174125652, + "subdir": "linux-64", + "timestamp": 1582007764881, + "version": "2.1.0" + }, + "tensorflow-base-2.1.0-mkl_py36h6d63fb7_0.tar.bz2": { + "build": "mkl_py36h6d63fb7_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astor >=0.6.2", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7", + "grpcio >=1.14.1", + "keras-applications >=1.0.8", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.8.0", + "python >=3.6,<3.7.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7aa8650d7fbb6284f1cf1d4a0011f670", + "name": "tensorflow-base", + "sha256": "6927cb330a4f367104f8d21b2ca0670d952d1d8cec850a5c9db47af66e75bef3", + "size": 174308967, + "subdir": "linux-64", + "timestamp": 1582041224818, + "version": "2.1.0" + }, + "tensorflow-base-2.1.0-mkl_py37h6d63fb7_0.tar.bz2": { + "build": "mkl_py37h6d63fb7_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astor >=0.6.2", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7", + "grpcio >=1.14.1", + "keras-applications >=1.0.8", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.8.0", + "python >=3.7,<3.8.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "43e8662fb957bf5ce68dc59325be9fcf", + "name": "tensorflow-base", + "sha256": "690a02a8792b2cc80d5255003e7e481ebaedfd560c731bfb147ff95f4d6090fb", + "size": 174211475, + "subdir": "linux-64", + "timestamp": 1581997410194, + "version": "2.1.0" + }, + "tensorflow-base-2.10.0-eigen_py310h1969d1f_0.tar.bz2": { + "build": "eigen_py310h1969d1f_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6452f8f777ca31f905184e2d5ebf0c89", + "name": "tensorflow-base", + "sha256": "f8e5e04d9533fa7af6d360c58fc34447a7b6bcd7978fb1fd8789404bc8f3a3e2", + "size": 153035071, + "subdir": "linux-64", + "timestamp": 1666980402968, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-eigen_py37h1969d1f_0.tar.bz2": { + "build": "eigen_py37h1969d1f_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.7,<3.8.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7601878e019eed8141b49593df8bc538", + "name": "tensorflow-base", + "sha256": "a27517a3991db7bc08290a786aba5abe5339d05979606c48feb34bad666ae9d9", + "size": 156670508, + "subdir": "linux-64", + "timestamp": 1666900483140, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-eigen_py38h1969d1f_0.tar.bz2": { + "build": "eigen_py38h1969d1f_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "32a0a430572dbdcdec188bea4f87e175", + "name": "tensorflow-base", + "sha256": "4f092522248cd470465f854e0ffa535231c0d1edf630360d2b335084404be182", + "size": 156725871, + "subdir": "linux-64", + "timestamp": 1666935593871, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-eigen_py39h1969d1f_0.tar.bz2": { + "build": "eigen_py39h1969d1f_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "00ae9c7401dd338f310aa4ee0ba38f74", + "name": "tensorflow-base", + "sha256": "374ed4111b5e1bb81bb552c7a45d45c039350cf900781397c541720def0df06d", + "size": 156686385, + "subdir": "linux-64", + "timestamp": 1666971691462, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-gpu_py310h6559e04_0.tar.bz2": { + "build": "gpu_py310h6559e04_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a75858a0191f05172e93b369dfba1f82", + "name": "tensorflow-base", + "sha256": "78d05464b83a5021437cb6b69476787829c2508e4d5352149363f8b094cab000", + "size": 482661891, + "subdir": "linux-64", + "timestamp": 1666987687109, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-gpu_py37h6559e04_0.tar.bz2": { + "build": "gpu_py37h6559e04_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.7,<3.8.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "77701ea730d60488c1401d47c2238672", + "name": "tensorflow-base", + "sha256": "8665ba08cfda886e00a3cc2ee492f23c97f36f02cce4ccd31c78b78a3cb9f203", + "size": 486040416, + "subdir": "linux-64", + "timestamp": 1666897461141, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-gpu_py38h6559e04_0.tar.bz2": { + "build": "gpu_py38h6559e04_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6fd3b921becb4f5927b7adb54ae11aec", + "name": "tensorflow-base", + "sha256": "1f34c678238deb5640c2de81728b8b1becaced3099b8dda22247c568af969ef8", + "size": 487072639, + "subdir": "linux-64", + "timestamp": 1666945436197, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-gpu_py39h6559e04_0.tar.bz2": { + "build": "gpu_py39h6559e04_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5c04a451dc16f89a07b1b703f52872c3", + "name": "tensorflow-base", + "sha256": "dee2189c1c8a43ad3beed395e72a494d95f5220cdddd6a698292ebf42d7312a0", + "size": 485419411, + "subdir": "linux-64", + "timestamp": 1666968696065, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-mkl_py310hb9daa73_0.tar.bz2": { + "build": "mkl_py310hb9daa73_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "789b3e7fed2e8f2b8c9b73397984b6a1", + "name": "tensorflow-base", + "sha256": "46142f6dc35a362edef5ae7ecc3414f49fd281e62bfe683c8f5f728aad592228", + "size": 153531049, + "subdir": "linux-64", + "timestamp": 1666977618866, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-mkl_py37hb9daa73_0.tar.bz2": { + "build": "mkl_py37hb9daa73_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.7,<3.8.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "20c08e2623e569ea280e46bd4003469b", + "name": "tensorflow-base", + "sha256": "41e16f6654d54ba4a821b05f8e842ac28345ff32b5000fdddeb763572e4b5632", + "size": 157120079, + "subdir": "linux-64", + "timestamp": 1666903286610, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-mkl_py38hb9daa73_0.tar.bz2": { + "build": "mkl_py38hb9daa73_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "442e98ecc9611f09853541e815527c8d", + "name": "tensorflow-base", + "sha256": "2e54f4a8137a8ab0fd84524af1998d83269adfa78f90d98c1a73f2d757e9f37e", + "size": 157130094, + "subdir": "linux-64", + "timestamp": 1666938392589, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-mkl_py39hb9daa73_0.tar.bz2": { + "build": "mkl_py39hb9daa73_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b24ec1c376319b26b2aa8f550a11999b", + "name": "tensorflow-base", + "sha256": "5b04fac6a9b13e99d6327ff0187f3557e36b5a87376945b90f5cd9881eb64447", + "size": 156976766, + "subdir": "linux-64", + "timestamp": 1666961458372, + "version": "2.10.0" + }, + "tensorflow-base-2.11.0-eigen_py310h3323580_0.tar.bz2": { + "build": "eigen_py310h3323580_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.11.*", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.39,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1t,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tensorboard 2.11.*", + "tensorflow-estimator 2.11.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "da4f92b4eef51ce5b12a77aecd894dc7", + "name": "tensorflow-base", + "sha256": "4ef9199ad9b3dbf930f59ad5eaebc0d49b4a79d4faf77395967ee93db3244788", + "size": 155574619, + "subdir": "linux-64", + "timestamp": 1678235166961, + "version": "2.11.0" + }, + "tensorflow-base-2.11.0-eigen_py38h3323580_0.tar.bz2": { + "build": "eigen_py38h3323580_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.11.*", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.39,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1t,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tensorboard 2.11.*", + "tensorflow-estimator 2.11.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c673a807a25fca38547fcc81ae6ee39c", + "name": "tensorflow-base", + "sha256": "96823a9efffa538734e4a0bafb3ef26e4a452d7c60d7577ed2fb20af8782eff0", + "size": 155375331, + "subdir": "linux-64", + "timestamp": 1678238021595, + "version": "2.11.0" + }, + "tensorflow-base-2.11.0-eigen_py39h3323580_0.tar.bz2": { + "build": "eigen_py39h3323580_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.11.*", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.39,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1t,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tensorboard 2.11.*", + "tensorflow-estimator 2.11.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6e36eaf8ac895c59338dd7c6b3e2949a", + "name": "tensorflow-base", + "sha256": "fd6ab9128dbbb8a1acc60ae3312114862b9894fab655e4e6a05e773e0b2b6bf2", + "size": 155376100, + "subdir": "linux-64", + "timestamp": 1678240841639, + "version": "2.11.0" + }, + "tensorflow-base-2.11.0-gpu_py310h24d65da_0.tar.bz2": { + "build": "gpu_py310h24d65da_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.11.*", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.39,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1t,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tensorboard 2.11.*", + "tensorflow-estimator 2.11.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "155c12446fdd94bd5033234b3deb17cd", + "name": "tensorflow-base", + "sha256": "c60908851c68e278cd992a0d47cced249033b2282c8d1931c2dbee913ab958bb", + "size": 495867943, + "subdir": "linux-64", + "timestamp": 1678217195743, + "version": "2.11.0" + }, + "tensorflow-base-2.11.0-gpu_py38h24d65da_0.tar.bz2": { + "build": "gpu_py38h24d65da_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.11.*", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.39,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1t,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tensorboard 2.11.*", + "tensorflow-estimator 2.11.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5532dc635d7df15ae0095b61b134edfb", + "name": "tensorflow-base", + "sha256": "1b894b0dda27dbc3ea358e15887229d43b6f2812075ad3e8f38cd2ee55578092", + "size": 494315274, + "subdir": "linux-64", + "timestamp": 1678224697495, + "version": "2.11.0" + }, + "tensorflow-base-2.11.0-gpu_py39h24d65da_0.tar.bz2": { + "build": "gpu_py39h24d65da_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.11.*", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.39,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1t,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tensorboard 2.11.*", + "tensorflow-estimator 2.11.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "37196067d7655b1dfab26ac1f7975ca8", + "name": "tensorflow-base", + "sha256": "cbf70c81adf09fcbe32168ca2b7d0e12cc43ff7553f2b1b4740a08e9c77e1256", + "size": 495221978, + "subdir": "linux-64", + "timestamp": 1678232116582, + "version": "2.11.0" + }, + "tensorflow-base-2.11.0-mkl_py310he5f8e37_0.tar.bz2": { + "build": "mkl_py310he5f8e37_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.11.*", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.39,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1t,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tensorboard 2.11.*", + "tensorflow-estimator 2.11.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1475775c421a7aa06085ad101fd4c969", + "name": "tensorflow-base", + "sha256": "7e5f0d4ab97f3301acffb67e39764048d57e39ebcee4a07cfa0a31383fcd66e4", + "size": 155958925, + "subdir": "linux-64", + "timestamp": 1678243652815, + "version": "2.11.0" + }, + "tensorflow-base-2.11.0-mkl_py38he5f8e37_0.tar.bz2": { + "build": "mkl_py38he5f8e37_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.11.*", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.39,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1t,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tensorboard 2.11.*", + "tensorflow-estimator 2.11.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d3f849f1f06a09b61c9a5cc3b37d3dc5", + "name": "tensorflow-base", + "sha256": "db3f0a042ebda55dbc526ed7baa9ea5637181a68b0391eb96f5242908bf6e3fb", + "size": 155763243, + "subdir": "linux-64", + "timestamp": 1678246442053, + "version": "2.11.0" + }, + "tensorflow-base-2.11.0-mkl_py39he5f8e37_0.tar.bz2": { + "build": "mkl_py39he5f8e37_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.11.*", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.39,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1t,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tensorboard 2.11.*", + "tensorflow-estimator 2.11.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f017acd8d0cd862fe600565b8651a91b", + "name": "tensorflow-base", + "sha256": "2a5276ad1eddb5cd589aba39f8c5345f05268b02df63dbb9f26b369575f0e4fb", + "size": 155818023, + "subdir": "linux-64", + "timestamp": 1678249223809, + "version": "2.11.0" + }, + "tensorflow-base-2.2.0-eigen_py36haef3446_0.tar.bz2": { + "build": "eigen_py36haef3446_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=3.6,<3.7.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6a50711d0040d1c335fe013ca6100280", + "name": "tensorflow-base", + "sha256": "0e3f763d52656e34cd17b8813cb076284513c93c8a402e338e1fee9a29c3be86", + "size": 120623316, + "subdir": "linux-64", + "timestamp": 1590122174427, + "version": "2.2.0" + }, + "tensorflow-base-2.2.0-eigen_py37haef3446_0.tar.bz2": { + "build": "eigen_py37haef3446_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=3.7,<3.8.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7d5cd5b2773ade58fadfa852c898c4e9", + "name": "tensorflow-base", + "sha256": "8fd4ae5b250811e2330fba263ec8bdd854749d804bbca0f2a5f18c36c931f2a6", + "size": 120563638, + "subdir": "linux-64", + "timestamp": 1590096392354, + "version": "2.2.0" + }, + "tensorflow-base-2.2.0-eigen_py38h2e5f744_0.tar.bz2": { + "build": "eigen_py38h2e5f744_0", + "build_number": 0, + "depends": [ + "absl-py >=0.8.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.9.2", + "python >=3.8,<3.9.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d9088fc1b3e7f91927831b3b573b1b24", + "name": "tensorflow-base", + "sha256": "9265e558d6ed5d15d625067c6888e6d09de7d717dd7e336a7b073230430fb078", + "size": 120680844, + "subdir": "linux-64", + "timestamp": 1590105901939, + "version": "2.2.0" + }, + "tensorflow-base-2.2.0-gpu_py36h8a81be8_0.tar.bz2": { + "build": "gpu_py36h8a81be8_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "cupti", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=3.6,<3.7.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "66e9386b67221a0824e51a133cf2b340", + "name": "tensorflow-base", + "sha256": "d2ee94ba8e9a4e4dbe698a33a249e000d250808875fc26368f8b296c5a9c609a", + "size": 442193470, + "subdir": "linux-64", + "timestamp": 1590173216680, + "version": "2.2.0" + }, + "tensorflow-base-2.2.0-gpu_py37h8a81be8_0.tar.bz2": { + "build": "gpu_py37h8a81be8_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "cupti", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=3.7,<3.8.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d25e161c56b4979de0ac5d9719c04416", + "name": "tensorflow-base", + "sha256": "ff1a80648cc477087584db140afb728ce87435fa29f89a16c791fc33e84ee91d", + "size": 442679468, + "subdir": "linux-64", + "timestamp": 1590166137312, + "version": "2.2.0" + }, + "tensorflow-base-2.2.0-gpu_py38h83e3d50_0.tar.bz2": { + "build": "gpu_py38h83e3d50_0", + "build_number": 0, + "depends": [ + "absl-py >=0.8.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "cupti", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.9.2", + "python >=3.8,<3.9.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c52580a81e313386369154c7bdc32211", + "name": "tensorflow-base", + "sha256": "69362d079d918cfcb4d3dc56e5ca68e4093962c6402b6979835dcceb0ae4c7c5", + "size": 441766119, + "subdir": "linux-64", + "timestamp": 1590181687234, + "version": "2.2.0" + }, + "tensorflow-base-2.2.0-mkl_py36hd506778_0.tar.bz2": { + "build": "mkl_py36hd506778_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=3.6,<3.7.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8715288fb5bd952dd942e57afaeadd86", + "name": "tensorflow-base", + "sha256": "753fc74613abdbcfdf11ed5575f342da8a44630df7c56387e3a40e32a70bbfc1", + "size": 289909060, + "subdir": "linux-64", + "timestamp": 1590125215629, + "version": "2.2.0" + }, + "tensorflow-base-2.2.0-mkl_py37hd506778_0.tar.bz2": { + "build": "mkl_py37hd506778_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=3.7,<3.8.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "19a8f642671368f47a2a309caba20ba3", + "name": "tensorflow-base", + "sha256": "1c79bc1a587b12d427dcbcd88688fe28f83aec68ded2c07e3c4820b237dc8f5b", + "size": 289803999, + "subdir": "linux-64", + "timestamp": 1590099882941, + "version": "2.2.0" + }, + "tensorflow-base-2.2.0-mkl_py38h5059a2d_0.tar.bz2": { + "build": "mkl_py38h5059a2d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.8.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.9.2", + "python >=3.8,<3.9.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5a7c0b6199ddeb7b2b90ab153f2f3d38", + "name": "tensorflow-base", + "sha256": "d9183d1870de42b30b08041ad4e806547c524895d99f403e7ccf75e41c185d06", + "size": 289915186, + "subdir": "linux-64", + "timestamp": 1590108862023, + "version": "2.2.0" + }, + "tensorflow-base-2.3.0-eigen_py37h3b305d7_0.tar.bz2": { + "build": "eigen_py37h3b305d7_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=3.7,<3.8.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "faa197bcb87a6ba24e4761661de83e7e", + "name": "tensorflow-base", + "sha256": "a60afbda0eaa27b9fde07449a78b0c03b9fb69ab5b427e15b32a7a14c91f81b3", + "size": 113113553, + "subdir": "linux-64", + "timestamp": 1597947372860, + "version": "2.3.0" + }, + "tensorflow-base-2.3.0-eigen_py38hb57a387_0.tar.bz2": { + "build": "eigen_py38hb57a387_0", + "build_number": 0, + "depends": [ + "absl-py >=0.8.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.9.2", + "python >=3.8,<3.9.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "073429ad553f22d168e77d47225519c0", + "name": "tensorflow-base", + "sha256": "f846b47cd241a1334910f92b692956302422c5db2e15668e5840e0b723c3850b", + "size": 113300666, + "subdir": "linux-64", + "timestamp": 1597939897173, + "version": "2.3.0" + }, + "tensorflow-base-2.3.0-mkl_py37he9661a2_0.tar.bz2": { + "build": "mkl_py37he9661a2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=3.7,<3.8.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c038767db45ddeda893d6a89b8a18f00", + "name": "tensorflow-base", + "sha256": "e4e2ac3217dfdf4eb2d7b11933a575b89320323929a3cf7e79f23d2fcbfc16c8", + "size": 317492376, + "subdir": "linux-64", + "timestamp": 1597950533095, + "version": "2.3.0" + }, + "tensorflow-base-2.3.0-mkl_py38hac35e67_0.tar.bz2": { + "build": "mkl_py38hac35e67_0", + "build_number": 0, + "depends": [ + "absl-py >=0.8.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.9.2", + "python >=3.8,<3.9.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "608af42f51d454ac555d60f5ddf04217", + "name": "tensorflow-base", + "sha256": "5727897df2986996595b99c156a64394f9dfc9403ee5c653dd32a35886bb01a0", + "size": 317424040, + "subdir": "linux-64", + "timestamp": 1597942942612, + "version": "2.3.0" + }, + "tensorflow-base-2.4.1-eigen_py37h17880bf_0.tar.bz2": { + "build": "eigen_py37h17880bf_0", + "build_number": 0, + "depends": [ + "absl-py >=0.11.0", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.4.0,<0.4.1.0a0", + "google-pasta >=0.2.0", + "grpcio >=1.35.0", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.2", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.14.0", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.6.1", + "six >=1.15.0", + "sqlite >=3.33.0,<4.0a0", + "termcolor >=1.1.0", + "typing_extensions", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5e67d5c9dc3f94ebb83f9ee72f691af3", + "name": "tensorflow-base", + "sha256": "c45b1ffaabca546665cb97a91a1de4e5fe5302cb572272f7026fde3de1f2cbb0", + "size": 118540543, + "subdir": "linux-64", + "timestamp": 1614350230007, + "version": "2.4.1" + }, + "tensorflow-base-2.4.1-eigen_py38h17880bf_0.tar.bz2": { + "build": "eigen_py38h17880bf_0", + "build_number": 0, + "depends": [ + "absl-py >=0.11.0", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.4.0,<0.4.1.0a0", + "google-pasta >=0.2.0", + "grpcio >=1.35.0", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.2", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.14.0", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.6.1", + "six >=1.15.0", + "sqlite >=3.33.0,<4.0a0", + "termcolor >=1.1.0", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8f7205c6f74a5f7b32e7f2deac0e1212", + "name": "tensorflow-base", + "sha256": "6e7fbf2040e62a6c42ddff94ed0c47e66f850233a3a3212841549f47edced0ec", + "size": 118635094, + "subdir": "linux-64", + "timestamp": 1614357824206, + "version": "2.4.1" + }, + "tensorflow-base-2.4.1-eigen_py39h17880bf_0.tar.bz2": { + "build": "eigen_py39h17880bf_0", + "build_number": 0, + "depends": [ + "absl-py >=0.11.0", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.4.0,<0.4.1.0a0", + "google-pasta >=0.2.0", + "grpcio >=1.35.0", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.2", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.14.0", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.6.1", + "six >=1.15.0", + "sqlite >=3.33.0,<4.0a0", + "termcolor >=1.1.0", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6221c48ef74905069bab3ca86d8a5106", + "name": "tensorflow-base", + "sha256": "654ed979919715de08f80d385d4ce0e637eb82ead879bfc84eb0135b07109c8a", + "size": 118658289, + "subdir": "linux-64", + "timestamp": 1614364530070, + "version": "2.4.1" + }, + "tensorflow-base-2.4.1-gpu_py37h29c2da4_0.tar.bz2": { + "build": "gpu_py37h29c2da4_0", + "build_number": 0, + "depends": [ + "absl-py >=0.11.0", + "astunparse >=1.6.3,<1.6.4.0a0", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "cupti", + "gast >=0.4.0,<0.4.1.0a0", + "google-pasta >=0.2.0", + "grpcio >=1.35.0", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.2", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.14.0", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.6.1", + "six >=1.15.0", + "sqlite >=3.33.0,<4.0a0", + "termcolor >=1.1.0", + "typing_extensions", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "76e21e8f9f26c09d1ca73e09e2c4a2f9", + "name": "tensorflow-base", + "sha256": "95f33b27feeeb1fd3ccc0f687016fcca61233fa7c05dc2d7ca5b22db653d1c85", + "size": 443156082, + "subdir": "linux-64", + "timestamp": 1614542338829, + "version": "2.4.1" + }, + "tensorflow-base-2.4.1-gpu_py38h29c2da4_0.tar.bz2": { + "build": "gpu_py38h29c2da4_0", + "build_number": 0, + "depends": [ + "absl-py >=0.11.0", + "astunparse >=1.6.3,<1.6.4.0a0", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "cupti", + "gast >=0.4.0,<0.4.1.0a0", + "google-pasta >=0.2.0", + "grpcio >=1.35.0", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.2", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.14.0", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.6.1", + "six >=1.15.0", + "sqlite >=3.33.0,<4.0a0", + "termcolor >=1.1.0", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d6ee2e7403c1fabe07dec9632dfe95f4", + "name": "tensorflow-base", + "sha256": "88aa27d6bf5138e44a89e55bf72c77c3d25ff2df59b7bf937907da88c938150e", + "size": 444725641, + "subdir": "linux-64", + "timestamp": 1614550833676, + "version": "2.4.1" + }, + "tensorflow-base-2.4.1-gpu_py39h29c2da4_0.tar.bz2": { + "build": "gpu_py39h29c2da4_0", + "build_number": 0, + "depends": [ + "absl-py >=0.11.0", + "astunparse >=1.6.3,<1.6.4.0a0", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "cupti", + "gast >=0.4.0,<0.4.1.0a0", + "google-pasta >=0.2.0", + "grpcio >=1.35.0", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.2", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.14.0", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.6.1", + "six >=1.15.0", + "sqlite >=3.33.0,<4.0a0", + "termcolor >=1.1.0", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c1ca5779dc8c081dcd995f49e4a0355b", + "name": "tensorflow-base", + "sha256": "f16392e3e5bd0fb106e4ade5adbf3c1faad53324fc4ff187fbdc98f82f9a3637", + "size": 442888579, + "subdir": "linux-64", + "timestamp": 1614591566613, + "version": "2.4.1" + }, + "tensorflow-base-2.4.1-mkl_py37h43e0292_0.tar.bz2": { + "build": "mkl_py37h43e0292_0", + "build_number": 0, + "depends": [ + "absl-py >=0.11.0", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.4.0,<0.4.1.0a0", + "google-pasta >=0.2.0", + "grpcio >=1.35.0", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.2", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.14.0", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.6.1", + "six >=1.15.0", + "sqlite >=3.33.0,<4.0a0", + "termcolor >=1.1.0", + "typing_extensions", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3ab5439c6192588422c07672e160cc80", + "name": "tensorflow-base", + "sha256": "9ede93b6d60c6419d1346a45d2977c83ff76ec672c5e0ad5e6248853a8a88342", + "size": 131400930, + "subdir": "linux-64", + "timestamp": 1614352982204, + "version": "2.4.1" + }, + "tensorflow-base-2.4.1-mkl_py38h43e0292_0.tar.bz2": { + "build": "mkl_py38h43e0292_0", + "build_number": 0, + "depends": [ + "absl-py >=0.11.0", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.4.0,<0.4.1.0a0", + "google-pasta >=0.2.0", + "grpcio >=1.35.0", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.2", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.14.0", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.6.1", + "six >=1.15.0", + "sqlite >=3.33.0,<4.0a0", + "termcolor >=1.1.0", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7db0f568f73bc4a4be5c277e55af7265", + "name": "tensorflow-base", + "sha256": "9d5383f69acafdd7779fe1b121278d39802e9cea6213e36b68ec3b9e46fd951e", + "size": 131503106, + "subdir": "linux-64", + "timestamp": 1614360610470, + "version": "2.4.1" + }, + "tensorflow-base-2.4.1-mkl_py39h43e0292_0.tar.bz2": { + "build": "mkl_py39h43e0292_0", + "build_number": 0, + "depends": [ + "absl-py >=0.11.0", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.4.0,<0.4.1.0a0", + "google-pasta >=0.2.0", + "grpcio >=1.35.0", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.2", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.14.0", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.6.1", + "six >=1.15.0", + "sqlite >=3.33.0,<4.0a0", + "termcolor >=1.1.0", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "670cc2bd20987304ec187352d71bf8ff", + "name": "tensorflow-base", + "sha256": "fc96294669d2386811d8941995c0c1874e4bd120b46d9e591192c0605895b2ba", + "size": 131596150, + "subdir": "linux-64", + "timestamp": 1614367451224, + "version": "2.4.1" + }, + "tensorflow-base-2.5.0-eigen_py37h2b86b3d_0.tar.bz2": { + "build": "eigen_py37h2b86b3d_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20200923.3,<20200923.4.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.7,<3.8.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.35.4,<4.0a0", + "tensorboard >=2.5.0,<2.6", + "tensorflow-estimator >=2.5.0,<2.6", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel <0.36", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a7f03d1de4cd62da4ed574bc4ea3cf62", + "name": "tensorflow-base", + "sha256": "12a5a4575dd4d77708befe9cb18abe1027f308e5638a93bca19c36cd7f9fa857", + "size": 120705690, + "subdir": "linux-64", + "timestamp": 1622103985155, + "version": "2.5.0" + }, + "tensorflow-base-2.5.0-eigen_py38h2b86b3d_0.tar.bz2": { + "build": "eigen_py38h2b86b3d_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20200923.3,<20200923.4.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.8,<3.9.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.35.4,<4.0a0", + "tensorboard >=2.5.0,<2.6", + "tensorflow-estimator >=2.5.0,<2.6", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel <0.36", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b8b26d57e5cba398a95522cd94bff964", + "name": "tensorflow-base", + "sha256": "ff04ca58034de54ca8b836d96c30022dea7d1bcb083b108dce85b87e1e4d8138", + "size": 120337905, + "subdir": "linux-64", + "timestamp": 1622114435345, + "version": "2.5.0" + }, + "tensorflow-base-2.5.0-eigen_py39h2b86b3d_0.tar.bz2": { + "build": "eigen_py39h2b86b3d_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20200923.3,<20200923.4.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.9,<3.10.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.35.4,<4.0a0", + "tensorboard >=2.5.0,<2.6", + "tensorflow-estimator >=2.5.0,<2.6", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel >=0.35,<0.36", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "08048626e7fc73bf66631efcb11815fe", + "name": "tensorflow-base", + "sha256": "f1671aaa2c0b462d968e716fb679b6b3bbe3b65b689cbecd56498f0e1697f2ec", + "size": 117516868, + "subdir": "linux-64", + "timestamp": 1622124950135, + "version": "2.5.0" + }, + "tensorflow-base-2.5.0-mkl_py37h35b2a3d_0.tar.bz2": { + "build": "mkl_py37h35b2a3d_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20200923.3,<20200923.4.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.7,<3.8.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.35.4,<4.0a0", + "tensorboard >=2.5.0,<2.6", + "tensorflow-estimator >=2.5.0,<2.6", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel <0.36", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "01f777b49a6b43ece6e3066ecd274298", + "name": "tensorflow-base", + "sha256": "4ffa75c0389b04e768739eacaaf2d56af99fdfaeae773e1e3dfd4a7460f08476", + "size": 120462298, + "subdir": "linux-64", + "timestamp": 1622107418140, + "version": "2.5.0" + }, + "tensorflow-base-2.5.0-mkl_py38h35b2a3d_0.tar.bz2": { + "build": "mkl_py38h35b2a3d_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20200923.3,<20200923.4.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.8,<3.9.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.35.4,<4.0a0", + "tensorboard >=2.5.0,<2.6", + "tensorflow-estimator >=2.5.0,<2.6", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel <0.36", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7f2922effb50af9dc448411f9bcb2777", + "name": "tensorflow-base", + "sha256": "2355f16609fd873e0a7d88de047533417041c53dd1ff85b2ad4422a0e8d7c997", + "size": 120221187, + "subdir": "linux-64", + "timestamp": 1622110966745, + "version": "2.5.0" + }, + "tensorflow-base-2.5.0-mkl_py39h35b2a3d_0.tar.bz2": { + "build": "mkl_py39h35b2a3d_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20200923.3,<20200923.4.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.9,<3.10.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.35.4,<4.0a0", + "tensorboard >=2.5.0,<2.6", + "tensorflow-estimator >=2.5.0,<2.6", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel >=0.35,<0.36", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "565a9feed6828a4605383d3b8549a3fe", + "name": "tensorflow-base", + "sha256": "b96de19e1ed60ec9931e0ff8d13d5980f259465301b4bc28ea77982c9061cd75", + "size": 117370645, + "subdir": "linux-64", + "timestamp": 1622121483571, + "version": "2.5.0" + }, + "tensorflow-base-2.6.0-eigen_py37ha9cc040_0.tar.bz2": { + "build": "eigen_py37ha9cc040_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.7,<3.8.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.36.0,<4.0a0", + "tensorboard >=2.6.0,<2.7", + "tensorflow-estimator >=2.6.0,<2.7", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel >=0.35,<0.36", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "12071670935437f111828adce6163e72", + "name": "tensorflow-base", + "sha256": "f1f702b3248edd0c237bbc204fa423871a0b162f7cd826fc4426910afef798a8", + "size": 123143105, + "subdir": "linux-64", + "timestamp": 1630513623371, + "version": "2.6.0" + }, + "tensorflow-base-2.6.0-eigen_py38ha9cc040_0.tar.bz2": { + "build": "eigen_py38ha9cc040_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.8,<3.9.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.36.0,<4.0a0", + "tensorboard >=2.6.0,<2.7", + "tensorflow-estimator >=2.6.0,<2.7", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel >=0.35,<0.36", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "76131831a81399dfaf23341cbcb28d2a", + "name": "tensorflow-base", + "sha256": "7a02ae4fd72562b0771486ce5f2bed4164ac3102d72aa2ebbbe8c06144a19214", + "size": 123073664, + "subdir": "linux-64", + "timestamp": 1630518169042, + "version": "2.6.0" + }, + "tensorflow-base-2.6.0-eigen_py39ha9cc040_0.tar.bz2": { + "build": "eigen_py39ha9cc040_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.9,<3.10.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.36.0,<4.0a0", + "tensorboard >=2.6.0,<2.7", + "tensorflow-estimator >=2.6.0,<2.7", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel >=0.35,<0.36", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4a0f42ae5c631f503427077639ae45a6", + "name": "tensorflow-base", + "sha256": "4ccc2234a5d172fa0ee78b11df5a59998ec9a0cf53e7d9a00cfd13cb1f21ff19", + "size": 120013000, + "subdir": "linux-64", + "timestamp": 1630520715169, + "version": "2.6.0" + }, + "tensorflow-base-2.6.0-mkl_py37h3d85931_0.tar.bz2": { + "build": "mkl_py37h3d85931_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.7,<3.8.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.36.0,<4.0a0", + "tensorboard >=2.6.0,<2.7", + "tensorflow-estimator >=2.6.0,<2.7", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel >=0.35,<0.36", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a5630d3944bc5a429c849ac90d7d61e6", + "name": "tensorflow-base", + "sha256": "bc2272639c154e5dd6c7c85670f5b636ee3d8a657f3b520c73127da34bd60e34", + "size": 122917041, + "subdir": "linux-64", + "timestamp": 1630511484102, + "version": "2.6.0" + }, + "tensorflow-base-2.6.0-mkl_py38h3d85931_0.tar.bz2": { + "build": "mkl_py38h3d85931_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.8,<3.9.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.36.0,<4.0a0", + "tensorboard >=2.6.0,<2.7", + "tensorflow-estimator >=2.6.0,<2.7", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel >=0.35,<0.36", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f68e14c93815dcd457dbe314315bc928", + "name": "tensorflow-base", + "sha256": "84dc19dc7435e7eb1a414dd37c8348f2afa5ea38c5daf8352b806049b7fd24b7", + "size": 122996904, + "subdir": "linux-64", + "timestamp": 1630516015623, + "version": "2.6.0" + }, + "tensorflow-base-2.6.0-mkl_py39h3d85931_0.tar.bz2": { + "build": "mkl_py39h3d85931_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.9,<3.10.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.36.0,<4.0a0", + "tensorboard >=2.6.0,<2.7", + "tensorflow-estimator >=2.6.0,<2.7", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel >=0.35,<0.36", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c77405182480010ea5ebfad2ab44e171", + "name": "tensorflow-base", + "sha256": "b522b1490746e2b4debab3ac71444394b9154570300891212aa3957e7bba1df2", + "size": 120070278, + "subdir": "linux-64", + "timestamp": 1630522852931, + "version": "2.6.0" + }, + "tensorflow-base-2.8.2-eigen_py310h980454f_0.tar.bz2": { + "build": "eigen_py310h980454f_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.38.5,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "abd9aa72cbda6f502044093987d19a0c", + "name": "tensorflow-base", + "sha256": "716167c9fbb8749fec836121cc149cf16b333cad97a4d83df5525b1c55a3b674", + "size": 134789020, + "subdir": "linux-64", + "timestamp": 1658935387847, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-eigen_py37h980454f_0.tar.bz2": { + "build": "eigen_py37h980454f_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.38.5,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5367d3e97e20d988ca2256f699750c71", + "name": "tensorflow-base", + "sha256": "25bf7704dfbaa127cedd4483d7feb5557d24cb835044b52865dcb6e988e81172", + "size": 138190380, + "subdir": "linux-64", + "timestamp": 1658940036680, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-eigen_py38h980454f_0.tar.bz2": { + "build": "eigen_py38h980454f_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.38.5,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0e08100c478e2727eddd9a0ffd7b609d", + "name": "tensorflow-base", + "sha256": "536da13634e397ef8ba58f4aa23c82d6c4b7c86f93c434998e48eead68435bb7", + "size": 138157198, + "subdir": "linux-64", + "timestamp": 1658933069131, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-eigen_py39h980454f_0.tar.bz2": { + "build": "eigen_py39h980454f_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.38.5,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d6427ce6eba332d55b7376dc30d6d8b2", + "name": "tensorflow-base", + "sha256": "d2ef108e588814f452ec30e26c159be3aa52ee5f1711729a6e95bac0c7010e58", + "size": 138191321, + "subdir": "linux-64", + "timestamp": 1658937720842, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-gpu_py310h1986732_0.tar.bz2": { + "build": "gpu_py310h1986732_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.0,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f04464f4a9bb9367d91c41a1a553f390", + "name": "tensorflow-base", + "sha256": "b3bd538e03ec4986e376e82eb66a33d2ae280e65e6f3e31a89755e8ed559e098", + "size": 589434072, + "subdir": "linux-64", + "timestamp": 1659639211970, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-gpu_py37h1986732_0.tar.bz2": { + "build": "gpu_py37h1986732_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.0,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "44cc86a98bf41873cbb6d990c4350f08", + "name": "tensorflow-base", + "sha256": "34015c2b6b18ecf593f599f0fb4808437d2deb42086b667123b578a3f255089e", + "size": 593619921, + "subdir": "linux-64", + "timestamp": 1659651064983, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-gpu_py38h1986732_0.tar.bz2": { + "build": "gpu_py38h1986732_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.0,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9db94532c49c28d6125707770a76cc1e", + "name": "tensorflow-base", + "sha256": "48e72c9267779c88b622b0de2346a3ed68d84c50f940145ca54eba5598283e3d", + "size": 594523053, + "subdir": "linux-64", + "timestamp": 1659645157620, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-gpu_py39h1986732_0.tar.bz2": { + "build": "gpu_py39h1986732_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.0,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "526478280738a314c02c0e682457f904", + "name": "tensorflow-base", + "sha256": "9a5b2593fc8993576ca22ea47da55bc283c190f1f53967d5cb3b23605ab81add", + "size": 594439754, + "subdir": "linux-64", + "timestamp": 1659632969469, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-mkl_py310hf890080_0.tar.bz2": { + "build": "mkl_py310hf890080_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.38.5,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f5e854653d59bc7ea5f6d1be022e2829", + "name": "tensorflow-base", + "sha256": "fa3f9b43f54b3cbb4dc9c6ea33271872599217694e2ec7c3de0b781e3f08d2aa", + "size": 135187184, + "subdir": "linux-64", + "timestamp": 1658926050046, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-mkl_py37hf890080_0.tar.bz2": { + "build": "mkl_py37hf890080_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.38.5,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "27a909f4674f2054d8fef83ca09ee046", + "name": "tensorflow-base", + "sha256": "64d403cde7dd8fe81fa5a894a220fe28de954b7f8ef7f34a5e32e6c134fe4a89", + "size": 138612167, + "subdir": "linux-64", + "timestamp": 1658930756242, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-mkl_py38hf890080_0.tar.bz2": { + "build": "mkl_py38hf890080_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.38.5,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "af54d49a66db892f649325d9a14da231", + "name": "tensorflow-base", + "sha256": "0e9c169fc8ee24d9b0b27e429b74cdb6f3d561e03f685d8f1938a6a06d27c7d2", + "size": 138690370, + "subdir": "linux-64", + "timestamp": 1658923715929, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-mkl_py39hf890080_0.tar.bz2": { + "build": "mkl_py39hf890080_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.38.5,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c93cde43c15c9eddd869aeb1cc8268a4", + "name": "tensorflow-base", + "sha256": "24d3f6e1558eb55045b8532c91d27df5facf98bffc8730a25863951b31828bc7", + "size": 138641045, + "subdir": "linux-64", + "timestamp": 1658928422117, + "version": "2.8.2" + }, + "tensorflow-base-2.9.1-eigen_py310hd99631c_0.tar.bz2": { + "build": "eigen_py310hd99631c_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f0ebb362a92d45a33d3d9585a97a3b1b", + "name": "tensorflow-base", + "sha256": "876b6b169d6e25ea176665e909384f2221f8e829991ec16fb414509f0f33d214", + "size": 140594289, + "subdir": "linux-64", + "timestamp": 1661494948075, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-eigen_py310hd99631c_1.tar.bz2": { + "build": "eigen_py310hd99631c_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3123f6d739389e35581ccc42bb438ba9", + "name": "tensorflow-base", + "sha256": "7e907d477ff2ab0b282fe5a6c6d0bca3b9f816ae58da1eb71f9be4334b6a1fcf", + "size": 140490157, + "subdir": "linux-64", + "timestamp": 1666075171038, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-eigen_py37hd99631c_0.tar.bz2": { + "build": "eigen_py37hd99631c_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2d7a9cbca8e6d91e55474c14c8a0080e", + "name": "tensorflow-base", + "sha256": "7f2de04ca9d6979b21b9d3b86c29fb0f5eeb434e1b7ba2752031696e435a9661", + "size": 144079083, + "subdir": "linux-64", + "timestamp": 1661489725783, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-eigen_py37hd99631c_1.tar.bz2": { + "build": "eigen_py37hd99631c_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "16207f4a5eb59485522ea0d924ea6513", + "name": "tensorflow-base", + "sha256": "221bf1f7ba28178696bcc5da1b61b274ec14b2b5ea05634913ca592217f3b104", + "size": 143986602, + "subdir": "linux-64", + "timestamp": 1665989894499, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-eigen_py38hd99631c_0.tar.bz2": { + "build": "eigen_py38hd99631c_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fe5d72a611d8aa0c4161ffc1c686c7d3", + "name": "tensorflow-base", + "sha256": "159e5fdcf571512f4ecd59a95b11227505d8f6464144e1d9c0bfff027532ae92", + "size": 143985580, + "subdir": "linux-64", + "timestamp": 1661492330681, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-eigen_py38hd99631c_1.tar.bz2": { + "build": "eigen_py38hd99631c_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cbc12ef8f569e4a50f2b0afc0235170d", + "name": "tensorflow-base", + "sha256": "ae61e6b5daae1935c7c471decde60ea54244624af1bcc97333e01332ec114cf9", + "size": 144128351, + "subdir": "linux-64", + "timestamp": 1666010299142, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-eigen_py39hd99631c_0.tar.bz2": { + "build": "eigen_py39hd99631c_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "35b054480b435fbfd2461423717bc5e8", + "name": "tensorflow-base", + "sha256": "40620c5f57b1a9e4d9598a430b09e02d72fb89f2283f16e88d0eac69ab9e16ac", + "size": 144057834, + "subdir": "linux-64", + "timestamp": 1661487089195, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-eigen_py39hd99631c_1.tar.bz2": { + "build": "eigen_py39hd99631c_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d432f4c47e4fdf4da373afaa7a9db1dc", + "name": "tensorflow-base", + "sha256": "d6c53334d4e2fde96c08fdd2e0cf8bd96e3e1bd704e884335b86914bd01f8a36", + "size": 144239205, + "subdir": "linux-64", + "timestamp": 1666023881253, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-gpu_py310h1986732_0.tar.bz2": { + "build": "gpu_py310h1986732_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c8eed0b057bd01aff8184f84097f9f39", + "name": "tensorflow-base", + "sha256": "247128adc58f82d022440ffd901d6dc40fbcf74c397460bc7f27d9a1933c832d", + "size": 596421573, + "subdir": "linux-64", + "timestamp": 1661484216776, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-gpu_py310h1986732_1.tar.bz2": { + "build": "gpu_py310h1986732_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fd455bff8de826ab833bd9a1f7b1b12c", + "name": "tensorflow-base", + "sha256": "897c7009d671d556e91e89016d6fcb9ea64fa442d590e29349ed80b0e711e8c9", + "size": 598781238, + "subdir": "linux-64", + "timestamp": 1666083910001, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-gpu_py37h1986732_0.tar.bz2": { + "build": "gpu_py37h1986732_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d0ae23909dc0d8240b8dce2474a6cd4c", + "name": "tensorflow-base", + "sha256": "e8a069829ff0228ff3768be51faf76d3d0d5adb6e71a826749245599220a9e13", + "size": 601483870, + "subdir": "linux-64", + "timestamp": 1661471574045, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-gpu_py37h1986732_1.tar.bz2": { + "build": "gpu_py37h1986732_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ea71e78189fb18466b67b5e21cecd3a5", + "name": "tensorflow-base", + "sha256": "9a07116e0dbba79ecd01b316258503c5c7a10bdaa4fec63fac6e7c822f8b1101", + "size": 600977639, + "subdir": "linux-64", + "timestamp": 1665996235307, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-gpu_py38h1986732_0.tar.bz2": { + "build": "gpu_py38h1986732_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e8946c2737694ecb8194859564360f63", + "name": "tensorflow-base", + "sha256": "5314f8c7e542001417f4d85845d64bf56e94b57b3ae2a987db493ae3256cdca9", + "size": 601476169, + "subdir": "linux-64", + "timestamp": 1661477886621, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-gpu_py38h1986732_1.tar.bz2": { + "build": "gpu_py38h1986732_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "711d5f973a1cc5e0ba1edd1c5bfec97c", + "name": "tensorflow-base", + "sha256": "656e58a2b46653c232017f60cc9b39e3d1731b06792606296e71d74e4596fcc0", + "size": 600633272, + "subdir": "linux-64", + "timestamp": 1666016445368, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-gpu_py39h1986732_0.tar.bz2": { + "build": "gpu_py39h1986732_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0a8484b78fa09a5d270cf8c4fcac9eb6", + "name": "tensorflow-base", + "sha256": "8faf29abfb7ce2a8a443e975d0d560a1d8c849b19b2a160544637fd4a65b049c", + "size": 599583823, + "subdir": "linux-64", + "timestamp": 1661465201574, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-gpu_py39h1986732_1.tar.bz2": { + "build": "gpu_py39h1986732_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fdf9b48d70f74d2454c524747a2c75f1", + "name": "tensorflow-base", + "sha256": "bf2434230656dfe0e4e175cdf80905a9701bb4a7a9ee2f3e7bf66d1e66b001ba", + "size": 599441646, + "subdir": "linux-64", + "timestamp": 1666032698774, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-mkl_py310h353358b_0.tar.bz2": { + "build": "mkl_py310h353358b_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ab8c48493b8a6fa217057c62eb2a9a34", + "name": "tensorflow-base", + "sha256": "6020272ba32153d454c157489c40ff2b0b19b711944808b104691326df94df10", + "size": 140921575, + "subdir": "linux-64", + "timestamp": 1661459084594, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-mkl_py310h353358b_1.tar.bz2": { + "build": "mkl_py310h353358b_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3297c9a07ffe48092bd1ba444a9e55e4", + "name": "tensorflow-base", + "sha256": "72041c0173efe44882add900980a135ba24b1b0e524466180e07e234f0a858c0", + "size": 141050279, + "subdir": "linux-64", + "timestamp": 1666077786578, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-mkl_py37h353358b_0.tar.bz2": { + "build": "mkl_py37h353358b_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "19a12a1a0feee86891734d13d1a17f88", + "name": "tensorflow-base", + "sha256": "69bcc5abb4fd2f5694c591428f8458520b098f0ab49853755c121b7fd8bdf919", + "size": 144498212, + "subdir": "linux-64", + "timestamp": 1661453849463, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-mkl_py37h353358b_1.tar.bz2": { + "build": "mkl_py37h353358b_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fbf79a17311bc0ee9357db287ff8a33b", + "name": "tensorflow-base", + "sha256": "fbc47902ab9582b4e35991becc3bd98a48f2937c078f3977eed5e1b422bade90", + "size": 144581187, + "subdir": "linux-64", + "timestamp": 1665999083795, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-mkl_py38h353358b_0.tar.bz2": { + "build": "mkl_py38h353358b_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2a5e7c5100bc6db073ffcdd01e944cd4", + "name": "tensorflow-base", + "sha256": "826faf68538dd8a4bef940051389aabce3305efe9cc5e502a4c9a2fb66f22062", + "size": 144483833, + "subdir": "linux-64", + "timestamp": 1661456484481, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-mkl_py38h353358b_1.tar.bz2": { + "build": "mkl_py38h353358b_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c0e8e0c0e5a4fdcbbda54023a64c3dd2", + "name": "tensorflow-base", + "sha256": "9558b26ab45978658e6de1aba32e677c9c8b9c7504ec6ba724e57f7d1bec2082", + "size": 144635865, + "subdir": "linux-64", + "timestamp": 1666019333297, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-mkl_py39h353358b_0.tar.bz2": { + "build": "mkl_py39h353358b_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f237257775bcbd3726bb537d15652a14", + "name": "tensorflow-base", + "sha256": "5e9516029c018b27792375a6706c2df1bc39fb9a35341a8eb7a13b37fbe788ac", + "size": 144450328, + "subdir": "linux-64", + "timestamp": 1661451232750, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-mkl_py39h353358b_1.tar.bz2": { + "build": "mkl_py39h353358b_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cc2b98b438ca1b8a80f26fc0b90b7d44", + "name": "tensorflow-base", + "sha256": "a0f82291fa1ba06692426b9f7e480ed69a54dbe9912ef740b9098c3cd3d7a7ec", + "size": 144528167, + "subdir": "linux-64", + "timestamp": 1666026494701, + "version": "2.9.1" + }, + "tensorflow-datasets-1.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "absl-py", + "attrs", + "bz2file", + "dill", + "enum34", + "functools32", + "future", + "futures", + "numpy", + "promise", + "protobuf >=3.6.1", + "psutil", + "python >=2.7,<2.8.0a0", + "requests >=2.19.0", + "six", + "tensorflow >=1.14", + "tensorflow-metadata", + "termcolor", + "tqdm", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "5e5eb6045f2bcce5cd9c4f0ca1b225d3", + "name": "tensorflow-datasets", + "sha256": "74b1ff159052d65e1d3e04ff7b4def1e1e0d5af9eb72fffa016031d67974094f", + "size": 2379463, + "subdir": "linux-64", + "timestamp": 1567017053290, + "version": "1.2.0" + }, + "tensorflow-datasets-1.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py", + "attrs", + "dill", + "future", + "numpy", + "promise", + "protobuf >=3.6.1", + "psutil", + "python >=3.10,<3.11.0a0", + "requests >=2.19.0", + "six", + "tensorflow >=1.14", + "tensorflow-metadata", + "termcolor", + "tqdm", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "93ca438be32b66c6d44f50148d92bf9a", + "name": "tensorflow-datasets", + "sha256": "a331517656cde5f89795a786a5e1bb232ae9cf8095d0242a0779b7cba0dfdb44", + "size": 2245140, + "subdir": "linux-64", + "timestamp": 1640814197284, + "version": "1.2.0" + }, + "tensorflow-datasets-1.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "absl-py", + "attrs", + "dill", + "future", + "numpy", + "promise", + "protobuf >=3.6.1", + "psutil", + "python >=3.6,<3.7.0a0", + "requests >=2.19.0", + "six", + "tensorflow >=1.14", + "tensorflow-metadata", + "termcolor", + "tqdm", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "d9a922bc9a9af3570f7b0d95bf16e0e4", + "name": "tensorflow-datasets", + "sha256": "bd2bc17830387a1e14b0cc4ddc985c666be2f480af1ae4284ecd281ccce6ced7", + "size": 2403198, + "subdir": "linux-64", + "timestamp": 1567017061800, + "version": "1.2.0" + }, + "tensorflow-datasets-1.2.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py", + "attrs", + "dill", + "future", + "numpy", + "promise", + "protobuf >=3.6.1", + "psutil", + "python >=3.6,<3.7.0a0", + "requests >=2.19.0", + "six", + "tensorflow >=1.14", + "tensorflow-metadata", + "termcolor", + "tqdm", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "0308c490d1eb8992e401f98c4e3a8ab5", + "name": "tensorflow-datasets", + "sha256": "a40c48d5d40b17c0045791073d2481d6a4abbb9ce4f623830ec89abf4478b96c", + "size": 2477887, + "subdir": "linux-64", + "timestamp": 1615394842135, + "version": "1.2.0" + }, + "tensorflow-datasets-1.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "absl-py", + "attrs", + "dill", + "future", + "numpy", + "promise", + "protobuf >=3.6.1", + "psutil", + "python >=3.7,<3.8.0a0", + "requests >=2.19.0", + "six", + "tensorflow >=1.14", + "tensorflow-metadata", + "termcolor", + "tqdm", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "90629c09651c56af45e6e8e3c3570675", + "name": "tensorflow-datasets", + "sha256": "adff98981b6c89b2135a4c859673947023d98ba789026075fc90e5fbebcd97c5", + "size": 2399730, + "subdir": "linux-64", + "timestamp": 1567017055762, + "version": "1.2.0" + }, + "tensorflow-datasets-1.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py", + "attrs", + "dill", + "future", + "numpy", + "promise", + "protobuf >=3.6.1", + "psutil", + "python >=3.7,<3.8.0a0", + "requests >=2.19.0", + "six", + "tensorflow >=1.14", + "tensorflow-metadata", + "termcolor", + "tqdm", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "141056d64b0c2c8da2f2efd6ee655064", + "name": "tensorflow-datasets", + "sha256": "b2424a3d51df16cabb072264979b5cdcc0d77c7dd9d7a50efba6c76a2368da1f", + "size": 2481891, + "subdir": "linux-64", + "timestamp": 1615395019444, + "version": "1.2.0" + }, + "tensorflow-datasets-1.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "absl-py", + "attrs", + "dill", + "future", + "numpy", + "promise", + "protobuf >=3.6.1", + "psutil", + "python >=3.8,<3.9.0a0", + "requests >=2.19.0", + "six", + "tensorflow >=1.14", + "tensorflow-metadata", + "termcolor", + "tqdm", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "9f20fb72bd4155cc330c4cb0560e74ea", + "name": "tensorflow-datasets", + "sha256": "21d30e268bd0202714a0bdb45a3cc5cf5083a9cad18b78768c21d34b91cfbb34", + "size": 2235916, + "subdir": "linux-64", + "timestamp": 1574238089285, + "version": "1.2.0" + }, + "tensorflow-datasets-1.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py", + "attrs", + "dill", + "future", + "numpy", + "promise", + "protobuf >=3.6.1", + "psutil", + "python >=3.8,<3.9.0a0", + "requests >=2.19.0", + "six", + "tensorflow >=1.14", + "tensorflow-metadata", + "termcolor", + "tqdm", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "3ca4dbdf430fffd600f3f887a5c520a1", + "name": "tensorflow-datasets", + "sha256": "9356df0f4725bc98a52972567b5b88cf10fdea03e370edb0a94573224b0c3c42", + "size": 2478864, + "subdir": "linux-64", + "timestamp": 1615395005573, + "version": "1.2.0" + }, + "tensorflow-datasets-1.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py", + "attrs", + "dill", + "future", + "numpy", + "promise", + "protobuf >=3.6.1", + "psutil", + "python >=3.9,<3.10.0a0", + "requests >=2.19.0", + "six", + "tensorflow >=1.14", + "tensorflow-metadata", + "termcolor", + "tqdm", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "44d16e2417551c45002c0633765d9662", + "name": "tensorflow-datasets", + "sha256": "b020bbe1fd15d87f56f7992310fbafc9726f3b1933c006eaceceef8149a9710f", + "size": 2486169, + "subdir": "linux-64", + "timestamp": 1615394837008, + "version": "1.2.0" + }, + "tensorflow-eigen-1.10.0-h97799b2_0.tar.bz2": { + "build": "h97799b2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 1.10.0" + ], + "md5": "83833b4a24b5d4a922ab6ccbd9d71b14", + "name": "tensorflow-eigen", + "sha256": "184c70fb33af89958d4a3b6ac369029040869bc5cd1f9bd7d8c0df64a539e365", + "size": 2320, + "subdir": "linux-64", + "timestamp": 1534871883496, + "version": "1.10.0" + }, + "tensorflow-eigen-1.11.0-h68edfc2_0.tar.bz2": { + "build": "h68edfc2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 1.11.0" + ], + "md5": "f8eb6a801244c748422de926ccb0fd6f", + "name": "tensorflow-eigen", + "sha256": "7534717165825b96266121855386852323821be2e14b72df0afc80463effae36", + "size": 2336, + "subdir": "linux-64", + "timestamp": 1538592717410, + "version": "1.11.0" + }, + "tensorflow-eigen-1.12.0-h68edfc2_0.tar.bz2": { + "build": "h68edfc2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 1.12.0" + ], + "md5": "64e0319eac58afc7df2f739100801f11", + "name": "tensorflow-eigen", + "sha256": "026ae2c8b422e31d404459e88454b1c4f80993bac012de8187bbbae2fa560062", + "size": 2419, + "subdir": "linux-64", + "timestamp": 1542084297939, + "version": "1.12.0" + }, + "tensorflow-eigen-1.13.1-h68edfc2_0.tar.bz2": { + "build": "h68edfc2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 1.13.1" + ], + "md5": "7fa32bb27717e3a351f38c27786756ec", + "name": "tensorflow-eigen", + "sha256": "e01248239bc07111583fa80977f6c458190011221817a3b11a5ebafda6f5a949", + "size": 2471, + "subdir": "linux-64", + "timestamp": 1554328256822, + "version": "1.13.1" + }, + "tensorflow-eigen-1.14.0-h68edfc2_0.tar.bz2": { + "build": "h68edfc2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 1.14.0" + ], + "md5": "080cd0d765f2c2e165f2645b2420b932", + "name": "tensorflow-eigen", + "sha256": "2a61e05198161c63456544c5be8c42b88d4e8004192f6020e31fa5332614c842", + "size": 2335, + "subdir": "linux-64", + "timestamp": 1561050158727, + "version": "1.14.0" + }, + "tensorflow-eigen-1.15.0-h68edfc2_0.tar.bz2": { + "build": "h68edfc2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 1.15.0" + ], + "md5": "98185415f67408f20e09f2ddcb1942c5", + "name": "tensorflow-eigen", + "sha256": "3d4a86975ec5219da663855f6ae630da8c4406509ddb62651370053bc654915d", + "size": 2445, + "subdir": "linux-64", + "timestamp": 1573483031226, + "version": "1.15.0" + }, + "tensorflow-eigen-1.8.0-h08ee40d_0.tar.bz2": { + "build": "h08ee40d_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.3.0 eigen", + "tensorflow 1.8.0" + ], + "md5": "217ab424197d3214e2d794f085a8a541", + "name": "tensorflow-eigen", + "sha256": "930ad54ed781199ec1ef590b0e506d46c40c0ea47fb39b771166b6b81e25930c", + "size": 2763, + "subdir": "linux-64", + "timestamp": 1527094787428, + "version": "1.8.0" + }, + "tensorflow-eigen-1.9.0-h97799b2_0.tar.bz2": { + "build": "h97799b2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 1.9.0" + ], + "md5": "a09e6466b35539031642dec4dfee0a55", + "name": "tensorflow-eigen", + "sha256": "70d59b83bffc03ceda0f62900fb84b77841949564b3d0ac9f173c90fde64a2c4", + "size": 2355, + "subdir": "linux-64", + "timestamp": 1532470494958, + "version": "1.9.0" + }, + "tensorflow-eigen-2.0.0-h68edfc2_0.tar.bz2": { + "build": "h68edfc2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 2.0.0" + ], + "md5": "2ab67d26ddb875aedc9f09b6e1d7d02b", + "name": "tensorflow-eigen", + "sha256": "f1809967d02ed567050166ebcbc9fdc32b1cb0e3d68a812e094b5f49d37fa998", + "size": 2242, + "subdir": "linux-64", + "timestamp": 1571762181509, + "version": "2.0.0" + }, + "tensorflow-eigen-2.1.0-h68edfc2_0.tar.bz2": { + "build": "h68edfc2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 2.1.0" + ], + "md5": "db192eee3c577d844d2426069c46f4bf", + "name": "tensorflow-eigen", + "sha256": "f725a4b4d09c4dae6287481ff38a8810c7df01eae7944404752fc0ca6c245a12", + "size": 2369, + "subdir": "linux-64", + "timestamp": 1582050850535, + "version": "2.1.0" + }, + "tensorflow-eigen-2.2.0-h68edfc2_0.tar.bz2": { + "build": "h68edfc2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 2.2.0" + ], + "md5": "c31931f1ac6588bcf4daa3b6240d6c7e", + "name": "tensorflow-eigen", + "sha256": "1f311f317d866e235d940c8527ef97edb96e0744bb765884d7ece990dea9b319", + "size": 2545, + "subdir": "linux-64", + "timestamp": 1590159163119, + "version": "2.2.0" + }, + "tensorflow-eigen-2.4.1-h17f2ed4_0.tar.bz2": { + "build": "h17f2ed4_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 2.4.1" + ], + "md5": "ab66bc7d1b9108fe3b11937db2dcb7b1", + "name": "tensorflow-eigen", + "sha256": "5c7ebcb17577c5460dfdb7ac4c8514f46aa05d4004a473992992f626c1ebc8d2", + "size": 2319, + "subdir": "linux-64", + "timestamp": 1614595064824, + "version": "2.4.1" + }, + "tensorflow-eigen-2.5.0-h17f2ed4_0.tar.bz2": { + "build": "h17f2ed4_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 2.5.0" + ], + "md5": "bfa91d5259f00a68512867066de18e43", + "name": "tensorflow-eigen", + "sha256": "1fdf8d89dc99660a245b02c86e5ffcabf83c3438a8edbd6786241b1b90d31e06", + "size": 2391, + "subdir": "linux-64", + "timestamp": 1622195448330, + "version": "2.5.0" + }, + "tensorflow-estimator-2.10.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.10.*" + ], + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "79482573f42afbd38a8e4135ad73a429", + "name": "tensorflow-estimator", + "sha256": "81c5ad88e05f38cd77317cbb2c776e24e03b62f4588f96f64ebca5c9f7bee44f", + "size": 613927, + "subdir": "linux-64", + "timestamp": 1666890076256, + "version": "2.10.0" + }, + "tensorflow-estimator-2.10.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.10.*" + ], + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8d67d14b6765d48f3da1fb9c217b83be", + "name": "tensorflow-estimator", + "sha256": "81a6f78e9112031f6c46d7850b08bc3aeee3551562a8459b47c60b4d602184fb", + "size": 604976, + "subdir": "linux-64", + "timestamp": 1666890130654, + "version": "2.10.0" + }, + "tensorflow-estimator-2.10.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.10.*" + ], + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "046b1e25818e55349479424188c17191", + "name": "tensorflow-estimator", + "sha256": "7bc380989f3c1d6336f3a5da73ce29940f8c31b836caf51333665f24e849f278", + "size": 608257, + "subdir": "linux-64", + "timestamp": 1666890111244, + "version": "2.10.0" + }, + "tensorflow-estimator-2.10.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.10.*" + ], + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a39e0ea4407005566f341da8e60bc5ea", + "name": "tensorflow-estimator", + "sha256": "4368a974696b0bbb21db0b8eb89c2221becee2f72674e45798680cff973f4c35", + "size": 609925, + "subdir": "linux-64", + "timestamp": 1666890093737, + "version": "2.10.0" + }, + "tensorflow-estimator-2.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.11.*" + ], + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aaa608bbe02d6a726ee09498f97b72b8", + "name": "tensorflow-estimator", + "sha256": "918af3cdfe0bafa6f77e5e21d604a1fe1574298a2e85aedb778e8849ba48fb75", + "size": 613929, + "subdir": "linux-64", + "timestamp": 1678126875178, + "version": "2.11.0" + }, + "tensorflow-estimator-2.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.11.*" + ], + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "40a6464deb917878c78775a377e45894", + "name": "tensorflow-estimator", + "sha256": "55ca818472fe55e669266c5cb2216374b1c06320960ae6f142ce8797b83850aa", + "size": 608713, + "subdir": "linux-64", + "timestamp": 1678126889805, + "version": "2.11.0" + }, + "tensorflow-estimator-2.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.11.*" + ], + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "05412f41826286c75bfd450759771220", + "name": "tensorflow-estimator", + "sha256": "a7e063b8745f54325451beda8370d220be88f4ea7380ca134c6b6f00b4670713", + "size": 609844, + "subdir": "linux-64", + "timestamp": 1678126904557, + "version": "2.11.0" + }, + "tensorflow-estimator-2.8.0-py310h2f386ee_0.tar.bz2": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "tensorflow-base 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1cbc28f6b7dc569d6c39c795aca58ee9", + "name": "tensorflow-estimator", + "sha256": "2d31adfa4e3f3552509d119254ca3fa7d37ee54ac0f9523b0ff68cf4729362fd", + "size": 652864, + "subdir": "linux-64", + "timestamp": 1658918754703, + "version": "2.8.0" + }, + "tensorflow-estimator-2.8.0-py37hb070fc8_0.tar.bz2": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "tensorflow-base 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0a1e709a2c371ab10d5a34cd3e40f681", + "name": "tensorflow-estimator", + "sha256": "f455f5907ffafdb5253a24d80fd45e0ed6c5eb937a9d1eada5b618634c070dce", + "size": 644382, + "subdir": "linux-64", + "timestamp": 1658918789146, + "version": "2.8.0" + }, + "tensorflow-estimator-2.8.0-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "tensorflow-base 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4220ffac9cd6ada5d4012bfeb7ad4b53", + "name": "tensorflow-estimator", + "sha256": "5a7da766939796bd301c0052be97846a6e2c7d41b55d793eb2f4b8a0e1197512", + "size": 648181, + "subdir": "linux-64", + "timestamp": 1658918771884, + "version": "2.8.0" + }, + "tensorflow-estimator-2.8.0-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "tensorflow-base 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "299c379eace431598dbf2e6953668642", + "name": "tensorflow-estimator", + "sha256": "cd67486446b91773e0d9fad86fb8f3a0d81880edeeea9721964b3f18c26e5c31", + "size": 648569, + "subdir": "linux-64", + "timestamp": 1658918736668, + "version": "2.8.0" + }, + "tensorflow-estimator-2.9.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.9.*" + ], + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2c9e83d07a4df0e809b90d39b8ee2a06", + "name": "tensorflow-estimator", + "sha256": "1a73b43163eec61b111449ea3b98f6252546b7795e117bf8bba2fffb18ddd9e5", + "size": 613853, + "subdir": "linux-64", + "timestamp": 1661448142086, + "version": "2.9.0" + }, + "tensorflow-estimator-2.9.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.9.*" + ], + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3ab80c6cba621a1cdf26d086c57542ea", + "name": "tensorflow-estimator", + "sha256": "7b356603b1d9d24f33517b966c7b7220084234edadb6c8abde42f9615adcc6b2", + "size": 602223, + "subdir": "linux-64", + "timestamp": 1661448124375, + "version": "2.9.0" + }, + "tensorflow-estimator-2.9.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.9.*" + ], + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "145c2132f43e9fd350e0ed3b5b723d5a", + "name": "tensorflow-estimator", + "sha256": "447313d5e67e13ebb6c11e146400eb0746f318150a1765d9ed88ab279e7210cb", + "size": 607203, + "subdir": "linux-64", + "timestamp": 1661448161728, + "version": "2.9.0" + }, + "tensorflow-estimator-2.9.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.9.*" + ], + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "186650771e3b4209d20e988363d0b53b", + "name": "tensorflow-estimator", + "sha256": "549cb5422b90054db4fa0b281c649c22457a8bec5cca818eabe2ad18d21a8a81", + "size": 608059, + "subdir": "linux-64", + "timestamp": 1661448104330, + "version": "2.9.0" + }, + "tensorflow-gpu-1.10.0-hf154084_0.tar.bz2": { + "build": "hf154084_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 1.10.0" + ], + "md5": "7e3ade370fe9006b75c83ba045eec887", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "2bbd4f571f33d58133513958588f03a7fe507e5e895088c83840d28705dc0ac7", + "size": 2103, + "subdir": "linux-64", + "timestamp": 1534889702492, + "version": "1.10.0" + }, + "tensorflow-gpu-1.11.0-h0d30ee6_0.tar.bz2": { + "build": "h0d30ee6_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 1.11.0" + ], + "md5": "b4d7755037fff9332526056e1ef55cbd", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "d0a32a2e856d28de5fc4dac81a5fb925c35be0d1569328b674f66f87f4a538cb", + "size": 2140, + "subdir": "linux-64", + "timestamp": 1538749556658, + "version": "1.11.0" + }, + "tensorflow-gpu-1.12.0-h0d30ee6_0.tar.bz2": { + "build": "h0d30ee6_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 1.12.0" + ], + "md5": "68569d05b12155ce4300afc51389d801", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "acfea3b5207c17cc49eee371b2f0ff68c9e59a69e4798a01429bd9f8a7c0d89f", + "size": 2195, + "subdir": "linux-64", + "timestamp": 1542153549403, + "version": "1.12.0" + }, + "tensorflow-gpu-1.13.1-h0d30ee6_0.tar.bz2": { + "build": "h0d30ee6_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 1.13.1" + ], + "md5": "86ece9909f03834f377e4c4588cfa312", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "5daf8ad49acf15ceaab0ff2e49a7a2845dcb05c678bf0ca4af5d26a43f2e3f29", + "size": 2347, + "subdir": "linux-64", + "timestamp": 1554467722644, + "version": "1.13.1" + }, + "tensorflow-gpu-1.14.0-h0d30ee6_0.tar.bz2": { + "build": "h0d30ee6_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 1.14.0" + ], + "md5": "d4bddba7343adf8e0436d98bc7fad1d2", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "7bc07fc87abe25d94d613349ec5289655a02c79f3e5a3987b359a25b8d9771a7", + "size": 2667, + "subdir": "linux-64", + "timestamp": 1561537703680, + "version": "1.14.0" + }, + "tensorflow-gpu-1.15.0-h0d30ee6_0.tar.bz2": { + "build": "h0d30ee6_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 1.15.0" + ], + "md5": "2579f4ba7c9d97026f05c2aabfa628b8", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "f79c56a469784ef7f4b1e8b2f1ac5e13199875d0057e0d9508fbc093c0f12397", + "size": 2434, + "subdir": "linux-64", + "timestamp": 1573483047498, + "version": "1.15.0" + }, + "tensorflow-gpu-1.4.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "tensorflow-gpu-base 1.4.1", + "tensorflow-tensorboard" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "70a2d10d844cdfde5a484ec46e212806", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "50ccc6712270a7e12703b8ffdffa490de24e2a6b2a87a46016d05a335fb68b76", + "size": 3035, + "subdir": "linux-64", + "timestamp": 1516642141208, + "version": "1.4.1" + }, + "tensorflow-gpu-1.5.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "tensorflow-gpu-base 1.5.0", + "tensorflow-tensorboard >=1.5.0,<1.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "62e8f1d37c1776fa2239edec109176c0", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "492d500815c9ee18e91d3e76d04e7fe6264364d26e42895556996cbb6dc9b2d0", + "size": 3118, + "subdir": "linux-64", + "timestamp": 1524251597249, + "version": "1.5.0" + }, + "tensorflow-gpu-1.6.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "tensorboard >=1.6.0,<1.7.0", + "tensorflow-gpu-base 1.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5a728a904ca6e61f836fb84f7776175b", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "b674d7dae17299237534ee66c76a78e59e9a6528435ef6e13e9248ed2a377fb2", + "size": 3562, + "subdir": "linux-64", + "timestamp": 1524325197583, + "version": "1.6.0" + }, + "tensorflow-gpu-1.7.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "tensorboard >=1.7.0,<1.8.0", + "tensorflow-gpu-base 1.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b2d862251cbc75872d549e69bf809a65", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "7df24c090e7a725ab27b8433a7bf5f4368d437fc157868ad372d8e42a480c4e7", + "size": 3579, + "subdir": "linux-64", + "timestamp": 1524418129196, + "version": "1.7.0" + }, + "tensorflow-gpu-1.8.0-h7b35bdc_0.tar.bz2": { + "build": "h7b35bdc_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.1.0 gpu", + "tensorflow >=1.8.0,<1.8.1.0a0" + ], + "md5": "2d4213ae61a84672f7b88a2ef39702f8", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "de4e5b3214a4132107542f552764206157e803c9ef87256e42167a7b075849bc", + "size": 4828, + "subdir": "linux-64", + "timestamp": 1527183790291, + "version": "1.8.0" + }, + "tensorflow-gpu-1.9.0-hf154084_0.tar.bz2": { + "build": "hf154084_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 1.9.0" + ], + "md5": "29635ffba3717a823604661bb293b4a5", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "7b2f9d85bdf9f6ab39253a9835c5ab1f36c31271b609ca35401d66f21f073a65", + "size": 2165, + "subdir": "linux-64", + "timestamp": 1532624036275, + "version": "1.9.0" + }, + "tensorflow-gpu-2.0.0-h0d30ee6_0.tar.bz2": { + "build": "h0d30ee6_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 2.0.0" + ], + "md5": "8a342e13307cba02e9f275997cf80d18", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "5305643953ae499ab2462232974825e6aab2979294a23aec739e5cb58ee7f731", + "size": 2239, + "subdir": "linux-64", + "timestamp": 1571762216140, + "version": "2.0.0" + }, + "tensorflow-gpu-2.1.0-h0d30ee6_0.tar.bz2": { + "build": "h0d30ee6_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 2.1.0" + ], + "md5": "dcbe07750c7df60794c3ef60516b64d7", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "bb6cf82bd859677612b6c3d710257900e253af12a698d952488997bdeafc8478", + "size": 2395, + "subdir": "linux-64", + "timestamp": 1582138833411, + "version": "2.1.0" + }, + "tensorflow-gpu-2.2.0-h0d30ee6_0.tar.bz2": { + "build": "h0d30ee6_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 2.2.0" + ], + "md5": "9756ff65945a79a70c04767213c99946", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "1ac48c656b5f6b3384119c0c11c468e5aee84d7b083ab85e4a0c8c789c8b770d", + "size": 2526, + "subdir": "linux-64", + "timestamp": 1590174247474, + "version": "2.2.0" + }, + "tensorflow-gpu-2.4.1-h30adc30_0.tar.bz2": { + "build": "h30adc30_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 2.4.1" + ], + "md5": "4e634deed31f00a266d230188803fc0b", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "6bad5455f4617f9e1e3499ed06180fe3de6990a50b369053e32a19cf67009839", + "size": 2316, + "subdir": "linux-64", + "timestamp": 1614595013103, + "version": "2.4.1" + }, + "tensorflow-gpu-base-1.4.1-py27h01caf0a_0.tar.bz2": { + "build": "py27h01caf0a_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "enum34 >=1.1.6", + "mock >=2.0.0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.3.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ea9fe3bd5f7bc91ebf29a9dd2b1815d9", + "name": "tensorflow-gpu-base", + "sha256": "c980af779e6cd692017aa459bb3e7a931b2f362ccc8343d8451529255f88f64e", + "size": 119360197, + "subdir": "linux-64", + "timestamp": 1516550814366, + "version": "1.4.1" + }, + "tensorflow-gpu-base-1.4.1-py27ha7e2fe3_0.tar.bz2": { + "build": "py27ha7e2fe3_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn 6.0.*", + "enum34 >=1.1.6", + "mock >=2.0.0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.3.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e06977f1b3899f68f8b965a75c88ad08", + "name": "tensorflow-gpu-base", + "sha256": "db149a17b3fb18c25fba8ebb4b6730e6f6b34427f80e8975638f038e23607ccf", + "size": 119347392, + "subdir": "linux-64", + "timestamp": 1516564230711, + "version": "1.4.1" + }, + "tensorflow-gpu-base-1.4.1-py35h01caf0a_0.tar.bz2": { + "build": "py35h01caf0a_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.3.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "33bed0f72693a1b369dd521c19034210", + "name": "tensorflow-gpu-base", + "sha256": "1e2ff791a951157620127706a0c6fe14e39efe9633bec62ada6b05fea32a61bf", + "size": 119514307, + "subdir": "linux-64", + "timestamp": 1516552207143, + "version": "1.4.1" + }, + "tensorflow-gpu-base-1.4.1-py35ha7e2fe3_0.tar.bz2": { + "build": "py35ha7e2fe3_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn 6.0.*", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.3.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f641875ddd263de322ea3645a03a731b", + "name": "tensorflow-gpu-base", + "sha256": "97cb58161b3c0499487dd260c01522e02df33c00de4b98243e33fec6be39cf49", + "size": 119507776, + "subdir": "linux-64", + "timestamp": 1516578550054, + "version": "1.4.1" + }, + "tensorflow-gpu-base-1.4.1-py36h01caf0a_0.tar.bz2": { + "build": "py36h01caf0a_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.3.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f08b27493cf121c92545ac8832b2683f", + "name": "tensorflow-gpu-base", + "sha256": "94e1273727b1757afdb5ef675fb300fa2322174b20c940a16f806b42e44319be", + "size": 119468973, + "subdir": "linux-64", + "timestamp": 1516553872591, + "version": "1.4.1" + }, + "tensorflow-gpu-base-1.4.1-py36ha7e2fe3_0.tar.bz2": { + "build": "py36ha7e2fe3_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn 6.0.*", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.3.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0c6096d4d81c9a8917132c08324ef01c", + "name": "tensorflow-gpu-base", + "sha256": "686b58f57f64e577c46d56efbb26a35cc9465ae9567dffd0e750e9b0c7cc24c8", + "size": 119474464, + "subdir": "linux-64", + "timestamp": 1516583040892, + "version": "1.4.1" + }, + "tensorflow-gpu-base-1.5.0-py27h8a131e3_0.tar.bz2": { + "build": "py27h8a131e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "mock >=2.0.0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "984e03b16d6ed00b93f1d9ac68fb005e", + "name": "tensorflow-gpu-base", + "sha256": "2f627ea54af0c0c1e91e93c817806d3ae520aade2a9c384b7a8b78ca3eb7f18b", + "size": 160141207, + "subdir": "linux-64", + "timestamp": 1524340351292, + "version": "1.5.0" + }, + "tensorflow-gpu-base-1.5.0-py27had95abb_0.tar.bz2": { + "build": "py27had95abb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "backports.weakref >=1.0rc1", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "mock >=2.0.0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3cee619a2b24f50dcbd152d78242d04f", + "name": "tensorflow-gpu-base", + "sha256": "ae403dc835d7b23e4f026ee842af26d12cbfa1f265bb4d3a17f9d9786bfa0907", + "size": 137377191, + "subdir": "linux-64", + "timestamp": 1524247813551, + "version": "1.5.0" + }, + "tensorflow-gpu-base-1.5.0-py35h8a131e3_0.tar.bz2": { + "build": "py35h8a131e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5b7de9bb456d68a3bfee95fc32ff84b3", + "name": "tensorflow-gpu-base", + "sha256": "c7e899e22150bd1b3fe4bb2ce36144f995d0c47ee8e4a78fe777b91746516d71", + "size": 160970531, + "subdir": "linux-64", + "timestamp": 1524338499640, + "version": "1.5.0" + }, + "tensorflow-gpu-base-1.5.0-py35had95abb_0.tar.bz2": { + "build": "py35had95abb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "85d13bf2ea3e9478e906d464bbb3caf4", + "name": "tensorflow-gpu-base", + "sha256": "60f492b245e39fcbd456f4eb5e836fea59bb200d478ef647c396b5983e9c8205", + "size": 137506327, + "subdir": "linux-64", + "timestamp": 1524246318963, + "version": "1.5.0" + }, + "tensorflow-gpu-base-1.5.0-py36h8a131e3_0.tar.bz2": { + "build": "py36h8a131e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "10e3251c927a97b9c2dd36cbdc994623", + "name": "tensorflow-gpu-base", + "sha256": "a5d432cf6ea08fb54194f4861ebc6bded7313f765fa854b6215b44feb0ae7eb6", + "size": 160904038, + "subdir": "linux-64", + "timestamp": 1524336871212, + "version": "1.5.0" + }, + "tensorflow-gpu-base-1.5.0-py36had95abb_0.tar.bz2": { + "build": "py36had95abb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bde65f1a5175df8afbf48d3743d21105", + "name": "tensorflow-gpu-base", + "sha256": "e07185939f2f3063cf19116eaad6bbfc4e8ae135bdbf893097bee3f4d0994b16", + "size": 137556794, + "subdir": "linux-64", + "timestamp": 1524244464976, + "version": "1.5.0" + }, + "tensorflow-gpu-base-1.6.0-py27h5b7bae4_1.tar.bz2": { + "build": "py27h5b7bae4_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ead0f5774912fb2cbcaf3df170bc0540", + "name": "tensorflow-gpu-base", + "sha256": "e81305ab6199999859097bdce9df21c42d675c516c054ed91fb69416425b2dfd", + "size": 138792119, + "subdir": "linux-64", + "timestamp": 1525885198325, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py27h8a131e3_0.tar.bz2": { + "build": "py27h8a131e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "75e2657088469bd8b8c3fb8ee56bd811", + "name": "tensorflow-gpu-base", + "sha256": "505e7392776130c4177210bea36303504f459bc22a93b99bf851c67e3634891b", + "size": 167454095, + "subdir": "linux-64", + "timestamp": 1524343611600, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py27had95abb_0.tar.bz2": { + "build": "py27had95abb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "045f76366309e2d8b0d0573c63340cd0", + "name": "tensorflow-gpu-base", + "sha256": "10f9f3d3ba3f07bd5eb26727fda330cade141f0ebef5e632181e24e104fdf615", + "size": 143032870, + "subdir": "linux-64", + "timestamp": 1524275475892, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py27hcdda91b_1.tar.bz2": { + "build": "py27hcdda91b_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cb8f26267db16399bb2e040455dbb3c2", + "name": "tensorflow-gpu-base", + "sha256": "ce444ea19b286e9331524f119e771034f1e2b8c94bf6dd38c85772e452ace0b8", + "size": 162334377, + "subdir": "linux-64", + "timestamp": 1525887600843, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py35h5b7bae4_1.tar.bz2": { + "build": "py35h5b7bae4_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "47819667908ab8b5e2d509bc5bf5cd27", + "name": "tensorflow-gpu-base", + "sha256": "9db3fd72ab2a34e2bf171a1757106fa05671067928fd9e0a360b2240461e9619", + "size": 138022494, + "subdir": "linux-64", + "timestamp": 1525883577998, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py35h8a131e3_0.tar.bz2": { + "build": "py35h8a131e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "14b6576f41cbf8c0419328f58e6dce9a", + "name": "tensorflow-gpu-base", + "sha256": "dcecdd2413d08f1d801212bbe4347810e4648cd8b764b659414727b8b959e772", + "size": 168182516, + "subdir": "linux-64", + "timestamp": 1524349345333, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py35had95abb_0.tar.bz2": { + "build": "py35had95abb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "59c0b1aec72033887c1ae5602b543fcf", + "name": "tensorflow-gpu-base", + "sha256": "9e7577831629a272e730090772842931bf79cd38fcb63232613f2a495f6e880e", + "size": 143632029, + "subdir": "linux-64", + "timestamp": 1524322150162, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py35hcdda91b_1.tar.bz2": { + "build": "py35hcdda91b_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "db63148bd8db29bad9febed0c6dbb87d", + "name": "tensorflow-gpu-base", + "sha256": "01839e887c190d346313075bfb5ef62889ea7a5da8ea115ae5574d476e4ef36c", + "size": 162310361, + "subdir": "linux-64", + "timestamp": 1525889187584, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py36h5b7bae4_1.tar.bz2": { + "build": "py36h5b7bae4_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f5d69be38a93d162a2bda8d182c4155d", + "name": "tensorflow-gpu-base", + "sha256": "72ac911ce4c086358079e6470d9606ad86700e127a65006cc6483d6207093c5b", + "size": 137952767, + "subdir": "linux-64", + "timestamp": 1525882005970, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py36h8a131e3_0.tar.bz2": { + "build": "py36h8a131e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c657f0bd4e13cdca6051ecc816af1cab", + "name": "tensorflow-gpu-base", + "sha256": "6c747c53b8d24491d2cd1f99ac52aba402ca2f2e9442e11c2bd83f2e6abc7ae5", + "size": 168272513, + "subdir": "linux-64", + "timestamp": 1524356441703, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py36had95abb_0.tar.bz2": { + "build": "py36had95abb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "70495f934509e2c1be03f2abeea63000", + "name": "tensorflow-gpu-base", + "sha256": "0f2441bbbb553da97643f9b1624b6ec08435f5ca0e9f3d45cda9c598af19534c", + "size": 143711694, + "subdir": "linux-64", + "timestamp": 1524314713282, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py36hcdda91b_1.tar.bz2": { + "build": "py36hcdda91b_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "54d6e112fcc4b824238d83f775e5d49c", + "name": "tensorflow-gpu-base", + "sha256": "1a09672934887c9009db93f10a6be1d2979256993f0417b2438f8f60ac9454bc", + "size": 162388108, + "subdir": "linux-64", + "timestamp": 1525891188345, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.7.0-py27h5b7bae4_1.tar.bz2": { + "build": "py27h5b7bae4_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b3a5ffbb29c132de5b87eb269d6d3502", + "name": "tensorflow-gpu-base", + "sha256": "205697a6a4184b4cbe6f02857462b0955ea8640a01ece5f893059e3030850433", + "size": 140848698, + "subdir": "linux-64", + "timestamp": 1525899886235, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py27h8a131e3_0.tar.bz2": { + "build": "py27h8a131e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "484450d6fc8136852cc5d1ac953dcd29", + "name": "tensorflow-gpu-base", + "sha256": "20b42891973757cf83b374d6dc9bb31149a97d4b154401fa45c50471e9147d76", + "size": 169941638, + "subdir": "linux-64", + "timestamp": 1524371398570, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py27had95abb_0.tar.bz2": { + "build": "py27had95abb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e11c8cd3f5a5c0c6c0bd8c7debd455a7", + "name": "tensorflow-gpu-base", + "sha256": "14226285892864ed38594e052405811f898057fab5dd705f80262126aa207606", + "size": 145470772, + "subdir": "linux-64", + "timestamp": 1524328233812, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py27hcdda91b_1.tar.bz2": { + "build": "py27hcdda91b_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "caa11031c8615db768e236e81dc45b7f", + "name": "tensorflow-gpu-base", + "sha256": "59fa9a044324f21cb1c2c4905af6047306c15dba277c8673da40558f6babd868", + "size": 165566480, + "subdir": "linux-64", + "timestamp": 1525902699297, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py35h5b7bae4_1.tar.bz2": { + "build": "py35h5b7bae4_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1f5339d10bd7b891c4ef157ea0a02f91", + "name": "tensorflow-gpu-base", + "sha256": "fee43c413fccce9c922812006c5275c1d6eb0429fef9f0c87f00881517ff3ab2", + "size": 139942472, + "subdir": "linux-64", + "timestamp": 1525901660531, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py35h8a131e3_0.tar.bz2": { + "build": "py35h8a131e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1a714b34d38acb27909dffd229516bd4", + "name": "tensorflow-gpu-base", + "sha256": "c362fea5f74a1672379e69435de2895c723c485a12778e50980c9ad355bde0fe", + "size": 170661777, + "subdir": "linux-64", + "timestamp": 1524364338390, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py35had95abb_0.tar.bz2": { + "build": "py35had95abb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e7953656b7dc770dec032f8af0d09b69", + "name": "tensorflow-gpu-base", + "sha256": "4d67ec158b018956234e45d0d9f0d29b07116b3de9fc6c68289c2701a232fc33", + "size": 146526817, + "subdir": "linux-64", + "timestamp": 1524329966269, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py35hcdda91b_1.tar.bz2": { + "build": "py35hcdda91b_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "53b31cb11a622d9855390026d3be4d8d", + "name": "tensorflow-gpu-base", + "sha256": "fce00654ef34b954e0bf0db165272a43be7980a6c541e88409bce74e43452f6d", + "size": 165018862, + "subdir": "linux-64", + "timestamp": 1525904572848, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py36h5b7bae4_1.tar.bz2": { + "build": "py36h5b7bae4_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "eaffe710b4a64da9e6c63e6bfe4ceac1", + "name": "tensorflow-gpu-base", + "sha256": "e561939e922b0bdd5a3185e0cbf0fc22ae94923b364a5f8c4be4d81a8e0195b8", + "size": 140794057, + "subdir": "linux-64", + "timestamp": 1525896859894, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py36h8a131e3_0.tar.bz2": { + "build": "py36h8a131e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2f56f866f64307d97f348a28c34ca776", + "name": "tensorflow-gpu-base", + "sha256": "d004839ff3ac0d964d3ff9a3798091b9cc7a2180af749c051b7b7bbb4870f367", + "size": 170890810, + "subdir": "linux-64", + "timestamp": 1524360530566, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py36had95abb_0.tar.bz2": { + "build": "py36had95abb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "eb34d4b6bd2433ac7b014b97e358c835", + "name": "tensorflow-gpu-base", + "sha256": "c55b56f364190de72cecb1ccc8dad3854b468c0dea471fb483627f45100b49ec", + "size": 146018570, + "subdir": "linux-64", + "timestamp": 1524331545091, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py36hcdda91b_1.tar.bz2": { + "build": "py36hcdda91b_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f9b5084d3cd49524b0bcdf922ec16f69", + "name": "tensorflow-gpu-base", + "sha256": "fc419ea53198bf96ffba639d5d59885407ab90154777fe40dfbdb440dabcf463", + "size": 164774035, + "subdir": "linux-64", + "timestamp": 1525899187341, + "version": "1.7.0" + }, + "tensorflow-mkl-1.10.0-h067cd57_0.tar.bz2": { + "build": "h067cd57_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 1.10.0" + ], + "md5": "7f7705c3c8478946b1a71e971c99551f", + "name": "tensorflow-mkl", + "sha256": "b687bf97a464c6c01366dfd017b8599020af1344a3043b417261bff7465a4319", + "size": 2312, + "subdir": "linux-64", + "timestamp": 1534871897653, + "version": "1.10.0" + }, + "tensorflow-mkl-1.11.0-h4fcabd2_0.tar.bz2": { + "build": "h4fcabd2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 1.11.0" + ], + "md5": "0165063ff289751846cd76c885ef5917", + "name": "tensorflow-mkl", + "sha256": "a9c38349c18e60af3a40235ed0bba40d93ce4a27e0954bba84a3912a6781e9db", + "size": 2330, + "subdir": "linux-64", + "timestamp": 1538592701795, + "version": "1.11.0" + }, + "tensorflow-mkl-1.12.0-h4fcabd2_0.tar.bz2": { + "build": "h4fcabd2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 1.12.0" + ], + "md5": "0238db0f453468a8b7296ea8533de326", + "name": "tensorflow-mkl", + "sha256": "241b9b6f45619f58cef3ebb77432550909bad0c60862928937b84ee7a26c308f", + "size": 2414, + "subdir": "linux-64", + "timestamp": 1542084275944, + "version": "1.12.0" + }, + "tensorflow-mkl-1.13.1-h4fcabd2_0.tar.bz2": { + "build": "h4fcabd2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 1.13.1" + ], + "md5": "2c2ca66cf3a43962bb095ab5c99a32d1", + "name": "tensorflow-mkl", + "sha256": "b5e28dcb7abb15d58b375a9d48545dfea6ba00ae60291fbcb8d626fce26f35cd", + "size": 2458, + "subdir": "linux-64", + "timestamp": 1554328284671, + "version": "1.13.1" + }, + "tensorflow-mkl-1.14.0-h4fcabd2_0.tar.bz2": { + "build": "h4fcabd2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 1.14.0" + ], + "md5": "cb13e41042f59cfea4109f8001a83b32", + "name": "tensorflow-mkl", + "sha256": "2087e3b405a6f37f3d27fe8ddb41b4e8a4d61cfe01cb7e8429a029132b8eb1be", + "size": 2342, + "subdir": "linux-64", + "timestamp": 1561050184032, + "version": "1.14.0" + }, + "tensorflow-mkl-1.15.0-h4fcabd2_0.tar.bz2": { + "build": "h4fcabd2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 1.15.0" + ], + "md5": "e92d515fa343307a91b382599ec9c467", + "name": "tensorflow-mkl", + "sha256": "f863a80d1edffbf11a48bdadb013e89ec558a1a09ff9db528378a064035bc93c", + "size": 2464, + "subdir": "linux-64", + "timestamp": 1573483014066, + "version": "1.15.0" + }, + "tensorflow-mkl-1.8.0-h5a53b39_0.tar.bz2": { + "build": "h5a53b39_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.2.0 mkl", + "tensorflow 1.8.0" + ], + "md5": "0f08541469ddca14ef02c16b25833b7b", + "name": "tensorflow-mkl", + "sha256": "2976519789e4da927e5bf4de9cdafc5e89aff914706aba3f9f750bf731d515ef", + "size": 2749, + "subdir": "linux-64", + "timestamp": 1527094788454, + "version": "1.8.0" + }, + "tensorflow-mkl-1.9.0-h067cd57_0.tar.bz2": { + "build": "h067cd57_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 1.9.0" + ], + "md5": "1a63365b5a8df08633bae03a1a93e856", + "name": "tensorflow-mkl", + "sha256": "967983d1707c968d752117502e24ed368917da8bd5df20b2b8d9ac82bdf536c5", + "size": 2347, + "subdir": "linux-64", + "timestamp": 1532470508014, + "version": "1.9.0" + }, + "tensorflow-mkl-2.0.0-h4fcabd2_0.tar.bz2": { + "build": "h4fcabd2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 2.0.0" + ], + "md5": "a555c36f681bf16294c488b60c5df7d1", + "name": "tensorflow-mkl", + "sha256": "fabfb5feb5a56c0f2cf6c4e1e5548b52c8e82b3ae46f19b55b8e4a8b95005d9a", + "size": 2243, + "subdir": "linux-64", + "timestamp": 1571762198882, + "version": "2.0.0" + }, + "tensorflow-mkl-2.1.0-h4fcabd2_0.tar.bz2": { + "build": "h4fcabd2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 2.1.0" + ], + "md5": "1bc4c845489b3418c0ebba27ba5fc3d4", + "name": "tensorflow-mkl", + "sha256": "844e7b55b55e84bd3e20a5dad5c0e8521912316ac6b49bc0f44f9b7dde2230af", + "size": 2366, + "subdir": "linux-64", + "timestamp": 1582050880656, + "version": "2.1.0" + }, + "tensorflow-mkl-2.2.0-h4fcabd2_0.tar.bz2": { + "build": "h4fcabd2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 2.2.0" + ], + "md5": "44e387af21d92599e0f2003893f530f6", + "name": "tensorflow-mkl", + "sha256": "2320c5f86144604b98bf4eaa6196bb518028aad7b74fe0dbebcfa29b220d5b90", + "size": 2530, + "subdir": "linux-64", + "timestamp": 1590159179630, + "version": "2.2.0" + }, + "tensorflow-mkl-2.4.1-h65a7e9c_0.tar.bz2": { + "build": "h65a7e9c_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 2.4.1" + ], + "md5": "03a04e07d560434ebc02149d7874b48a", + "name": "tensorflow-mkl", + "sha256": "9e1c92f6a13feddbd2fd7b7b68baad0219a6ecde9ae5ff03fc901284d0ede77e", + "size": 2321, + "subdir": "linux-64", + "timestamp": 1614595039083, + "version": "2.4.1" + }, + "tensorflow-mkl-2.5.0-h1e5c024_0.tar.bz2": { + "build": "h1e5c024_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 2.5.0" + ], + "md5": "e2ddb88e3a4d38fe68e81d485e42e278", + "name": "tensorflow-mkl", + "sha256": "5b72251f11e86a310842890032df54a6713ceceb795e3ad52a3ff06428c9a52e", + "size": 2379, + "subdir": "linux-64", + "timestamp": 1622195427055, + "version": "2.5.0" + }, + "tensorflow-tensorboard-0.4.0-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach 1.5.0", + "futures >=3.1.1", + "html5lib 0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bc9d5679c671f3452805927d3b869237", + "name": "tensorflow-tensorboard", + "sha256": "a2d18a32c16f63818336fb35c47b6fcf78176355a9dfce7dad37fdeccbb5c536", + "size": 1695198, + "subdir": "linux-64", + "timestamp": 1517616380566, + "version": "0.4.0" + }, + "tensorflow-tensorboard-0.4.0-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach 1.5.0", + "html5lib 0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dbb91ecd28ba916cc03a85fb7350bdbb", + "name": "tensorflow-tensorboard", + "sha256": "edc645b3482fc1adc0a7990d1a338a0731431b82ecc74456211e2e575716d80d", + "size": 1695983, + "subdir": "linux-64", + "timestamp": 1517616345132, + "version": "0.4.0" + }, + "tensorflow-tensorboard-0.4.0-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach 1.5.0", + "html5lib 0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3bec4c0b335a5a7782938a06bd05a170", + "name": "tensorflow-tensorboard", + "sha256": "2bb136a5bfabdc98292e2f07e67c803ad05f58f4796317ffcea1ecef4d973a55", + "size": 1693872, + "subdir": "linux-64", + "timestamp": 1517616414543, + "version": "0.4.0" + }, + "tensorflow-tensorboard-1.5.1-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach 1.5.0", + "futures >=3.1.1", + "html5lib 0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7f9dfbf3a3e2dbd50d13fcb5aa2bbbc7", + "name": "tensorflow-tensorboard", + "sha256": "b8d9dcf6bf33ceffba823fbcd27c39f8b03cde9028ceb2be68953920eb8d2272", + "size": 3056224, + "subdir": "linux-64", + "timestamp": 1519693326076, + "version": "1.5.1" + }, + "tensorflow-tensorboard-1.5.1-py27hf484d3e_1.tar.bz2": { + "build": "py27hf484d3e_1", + "build_number": 1, + "depends": [ + "bleach >=1.5.0,<1.5.1.0a0", + "futures", + "html5lib >=0.9999999,<0.10000000.0a0", + "libgcc-ng", + "libstdcxx-ng", + "markdown", + "numpy", + "protobuf", + "python >=2.7,<2.8.0a0", + "six", + "werkzeug" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5180ac1be9c40002919a2766bf9771c5", + "name": "tensorflow-tensorboard", + "sha256": "a1dd7dbd0eec37a4cb8e900a2293e1fabef2c778d2f52fdb75ed476c74a12803", + "size": 3055825, + "subdir": "linux-64", + "timestamp": 1524776951881, + "version": "1.5.1" + }, + "tensorflow-tensorboard-1.5.1-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach 1.5.0", + "html5lib 0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ee6ca68d9667b8c88fc60c2d3597e724", + "name": "tensorflow-tensorboard", + "sha256": "532744c528a797c1a3add389198fc8b6e85d6a3e33d31abdcc27de8c7347afc4", + "size": 3057311, + "subdir": "linux-64", + "timestamp": 1519693367705, + "version": "1.5.1" + }, + "tensorflow-tensorboard-1.5.1-py35hf484d3e_1.tar.bz2": { + "build": "py35hf484d3e_1", + "build_number": 1, + "depends": [ + "bleach >=1.5.0,<1.5.1.0a0", + "html5lib >=0.9999999,<0.10000000.0a0", + "libgcc-ng", + "libstdcxx-ng", + "markdown", + "numpy", + "protobuf", + "python >=3.5,<3.6.0a0", + "six", + "werkzeug" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ebce39c83c1adb0b758a25d53949253d", + "name": "tensorflow-tensorboard", + "sha256": "995f752772ea7d99517d40da559f4aad3064559fbbb96739412fd0ef4529ce12", + "size": 3057384, + "subdir": "linux-64", + "timestamp": 1524777625300, + "version": "1.5.1" + }, + "tensorflow-tensorboard-1.5.1-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach 1.5.0", + "html5lib 0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "df33671ca948676b71af5a7818d7ed0c", + "name": "tensorflow-tensorboard", + "sha256": "3dc14a291ba921c4fec9bac79c1f2516e50132b666aace6153e3c959716f01f2", + "size": 3056498, + "subdir": "linux-64", + "timestamp": 1519693007330, + "version": "1.5.1" + }, + "tensorflow-tensorboard-1.5.1-py36hf484d3e_1.tar.bz2": { + "build": "py36hf484d3e_1", + "build_number": 1, + "depends": [ + "bleach >=1.5.0,<1.5.1.0a0", + "html5lib >=0.9999999,<0.10000000.0a0", + "libgcc-ng", + "libstdcxx-ng", + "markdown", + "numpy", + "protobuf", + "python >=3.6,<3.7.0a0", + "six", + "werkzeug" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "06356e8a82487ec2e80917d355227280", + "name": "tensorflow-tensorboard", + "sha256": "564e76abdf48aacb03d114685edcd3d9e83aec8d5d3b65c8c42b786818edf5a8", + "size": 3055810, + "subdir": "linux-64", + "timestamp": 1524777625631, + "version": "1.5.1" + }, + "teradata-15.10.0.21-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0a4874ea9d4e78056b7817a174a023e", + "name": "teradata", + "sha256": "f81f944ffab2d779b846461743423b960d5864110e70bcf6210b83e7754b3aa7", + "size": 70276, + "subdir": "linux-64", + "timestamp": 1531060286406, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py27hc4fef92_0.tar.bz2": { + "build": "py27hc4fef92_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2aed9d0d96bd50ae2b025302dfc1d22", + "name": "teradata", + "sha256": "1843bd90325e2a71dce7d67ea2c28b4687e3ca4b577fff5b5963652985cfe75a", + "size": 70682, + "subdir": "linux-64", + "timestamp": 1509054871686, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a176f57c557ebb890f575f7fa79ca373", + "name": "teradata", + "sha256": "fd860fd5bbe9024baeb51f8499a47380d6a3ccf885bd8c75246af7fea06ad611", + "size": 73429, + "subdir": "linux-64", + "timestamp": 1640795143446, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py35h40e09d7_0.tar.bz2": { + "build": "py35h40e09d7_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9caad93f7a7cf6aa9a4930373ddaa892", + "name": "teradata", + "sha256": "dc1480b946deeab755dd02c3a954cd13b1d28e590aebe36b2fa4dc21aa9028a4", + "size": 72004, + "subdir": "linux-64", + "timestamp": 1509054883825, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33ef0e64d5d6fd238c84641e131a0973", + "name": "teradata", + "sha256": "67e80ad8fcee3632743cb5dbe6f0ce3b05c9e289924acaf02c0ba3d2ade010f1", + "size": 71607, + "subdir": "linux-64", + "timestamp": 1531060221626, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d01aa68d2a07e919f3d7f9f148a8f5cf", + "name": "teradata", + "sha256": "a2bfed87e6911153843731db54747ca331004fc9a82f39b20ed8f45484928cfd", + "size": 294846, + "subdir": "linux-64", + "timestamp": 1614326534531, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py36ha1fefe6_0.tar.bz2": { + "build": "py36ha1fefe6_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "717ae2fa8fa0f138dce2f500aff5b560", + "name": "teradata", + "sha256": "f1eb001e8bb63eba71b2ef66617a50a0f2f904b06e1da9fd262dccecf87ea7bf", + "size": 71808, + "subdir": "linux-64", + "timestamp": 1509054881288, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23447a325a069adf206f9a834b58ca1f", + "name": "teradata", + "sha256": "888e018004cb9edf5144ec6630be46c58b990d33accd2041149bc3f1c306e608", + "size": 71675, + "subdir": "linux-64", + "timestamp": 1531060254238, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c39550624fb9ae70c8f56ccabafb8b45", + "name": "teradata", + "sha256": "cc6865edcf2ae1b54eab7fd2e96bf56f8dfdd7b692f2966a17ad2393c4de4d6e", + "size": 296561, + "subdir": "linux-64", + "timestamp": 1614326528658, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b93f21c8e18905fc4254831618246a1e", + "name": "teradata", + "sha256": "9d8c5d66129165a2557ad0028712bd5b528f5b9fdce444a79959c4348d737a67", + "size": 72921, + "subdir": "linux-64", + "timestamp": 1573661856796, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7483bc76279bcd88d5535d1691afe094", + "name": "teradata", + "sha256": "63a1dc9bd5ac8abda4182a14face1527d5ec4ed3e5c3d5351119b4dcb55ce461", + "size": 297511, + "subdir": "linux-64", + "timestamp": 1614326524997, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9fb2203f46ca2f5ec7bf7214ce2736c6", + "name": "teradata", + "sha256": "270a2fb9c813f539d3338434db25b10c118db8992371cb09717a68c67ce71719", + "size": 296812, + "subdir": "linux-64", + "timestamp": 1614325478617, + "version": "15.10.0.21" + }, + "termcolor-1.1.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "514d99b660fa0c373c3c5b6eeb3ca611", + "name": "termcolor", + "sha256": "4217040b1ee3a00139824c7be3da2afafd49ebea8cdc3478cb217c9a2b467824", + "size": 7636, + "subdir": "linux-64", + "timestamp": 1519945284577, + "version": "1.1.0" + }, + "termcolor-1.1.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "c139a8088a43300811a243d873a20027", + "name": "termcolor", + "sha256": "662a5c2067ae85f351253404ee558adf447a05378b9ea61f7e26d6bd9d052644", + "size": 7919, + "subdir": "linux-64", + "timestamp": 1640795161477, + "version": "1.1.0" + }, + "termcolor-1.1.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "6f2536614fd8dea93b75f8f9d920971f", + "name": "termcolor", + "sha256": "b1e4f08038908d8c0593af419975f7e104dd2bc04c694b9cb5be244cc8258673", + "size": 7677, + "subdir": "linux-64", + "timestamp": 1519945254465, + "version": "1.1.0" + }, + "termcolor-1.1.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1fb9f12cf27dc4eefbe8e78fed7d13fa", + "name": "termcolor", + "sha256": "950b6b0652763247f784b67ea769250e17bcd64a56acd5f961d6c89255ab59ef", + "size": 7673, + "subdir": "linux-64", + "timestamp": 1519945302665, + "version": "1.1.0" + }, + "termcolor-1.1.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "37769ed62c9fb43adecd0df82627b84f", + "name": "termcolor", + "sha256": "aa9f15b7fd191fa293d3c06f48b0a3f739e7d0b102f682baa893700d70595cc8", + "size": 9108, + "subdir": "linux-64", + "timestamp": 1613470843114, + "version": "1.1.0" + }, + "termcolor-1.1.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6cd822061ff89e779c1cc2093d88fdac", + "name": "termcolor", + "sha256": "ab4eb861a530c9957eeaab22f84851451adbc81e9c412329e25ab2deeb705e73", + "size": 7544, + "subdir": "linux-64", + "timestamp": 1530961256129, + "version": "1.1.0" + }, + "termcolor-1.1.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5ba36754f9d0926d387f39ce79abd70b", + "name": "termcolor", + "sha256": "bebb79b7a14658661252411e67c60757f6d974390950acac88fa1f03733cbf75", + "size": 9124, + "subdir": "linux-64", + "timestamp": 1613470221960, + "version": "1.1.0" + }, + "termcolor-1.1.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "e69b3c6c3380770389b9924db202e8d9", + "name": "termcolor", + "sha256": "c636850755282e903fa37035477e9fc12adab4c55bc2a0047bb68c264b1fb9c1", + "size": 8030, + "subdir": "linux-64", + "timestamp": 1573661866459, + "version": "1.1.0" + }, + "termcolor-1.1.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "72e54b9d44d2eb822060a12e752edfc6", + "name": "termcolor", + "sha256": "622407bd19c0e4f6199205155ae2cb38036193051ba20bb2ae2d13205fbf68f8", + "size": 9118, + "subdir": "linux-64", + "timestamp": 1613470846520, + "version": "1.1.0" + }, + "termcolor-1.1.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "b284eb31ff5e631e0e51d741f09d641a", + "name": "termcolor", + "sha256": "efde7d9f6c3a99cae561bfcb318fd2c605d7c309d9dee18efe583986759c6782", + "size": 9181, + "subdir": "linux-64", + "timestamp": 1613470845326, + "version": "1.1.0" + }, + "termcolor-2.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4865b272b37eb679f0802ca8f7ea6e6", + "name": "termcolor", + "sha256": "ce4a8bb2573f683252aa7e679fc724417f7de2ed990c3b08e3ced96285b54b92", + "size": 11126, + "subdir": "linux-64", + "timestamp": 1668084767143, + "version": "2.1.0" + }, + "termcolor-2.1.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "750c318689637b3abcc2b960b9bb584a", + "name": "termcolor", + "sha256": "408b2f76db42401e431668ae46c4264749a80386a750c6cfdd7ee211dc0f2cc4", + "size": 12643, + "subdir": "linux-64", + "timestamp": 1676838872404, + "version": "2.1.0" + }, + "termcolor-2.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "44b90852a9723f3a374030bfb1cc8ef4", + "name": "termcolor", + "sha256": "cc87b92c96631fe937a860aefe935dc17c3ca84aeee280febe65fa54a1fe1444", + "size": 11062, + "subdir": "linux-64", + "timestamp": 1668084739680, + "version": "2.1.0" + }, + "termcolor-2.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5dbb6ae0d69f8530476b784306dcd51b", + "name": "termcolor", + "sha256": "536f0b62d7c64dc1374221669b1336fd582cc6d354b3912431014c899f9de9ed", + "size": 11041, + "subdir": "linux-64", + "timestamp": 1668084684161, + "version": "2.1.0" + }, + "termcolor-2.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec08cd0d9194191d0adde97ec1dde914", + "name": "termcolor", + "sha256": "cd01e2810af68caf0d40b6d67cc9076a338ccae0944456b9e0c11f338ec21cf9", + "size": 11080, + "subdir": "linux-64", + "timestamp": 1668084711473, + "version": "2.1.0" + }, + "termcolor-cpp-2.0.0-hd09550d_0.tar.bz2": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4583573abe66043e771254f56bea31cd", + "name": "termcolor-cpp", + "sha256": "248ab44f536b6f20ee49df2aba5433294b62fbbdbde6280cc47b6ea392b5a588", + "size": 10682, + "subdir": "linux-64", + "timestamp": 1646156069109, + "version": "2.0.0" + }, + "terminado-0.13.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.10,<3.11.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "19dfca5aa6a1995afb7713f20c7f62b0", + "name": "terminado", + "sha256": "66318c5074a69de0a351c29bbe3e57cb4b7ee8b2403c1c663ae20d7126b210d4", + "size": 30922, + "subdir": "linux-64", + "timestamp": 1644322629663, + "version": "0.13.1" + }, + "terminado-0.13.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.7,<3.8.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b69d10ce9b2536ce3066f5586678b8ad", + "name": "terminado", + "sha256": "3e980acd18e972fb988877944637519a588a038277efd46c1d0e39555b88055e", + "size": 30686, + "subdir": "linux-64", + "timestamp": 1644304491754, + "version": "0.13.1" + }, + "terminado-0.13.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.8,<3.9.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "64b594e98bd7c3d51754894b52522724", + "name": "terminado", + "sha256": "8513c683438280d6b0e0f6ca50eed08d9cd93d58603e7e1b6b0858fa40111947", + "size": 30762, + "subdir": "linux-64", + "timestamp": 1644322613881, + "version": "0.13.1" + }, + "terminado-0.13.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.9,<3.10.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "85675806b873aaee7699c68dbca2284c", + "name": "terminado", + "sha256": "1ed7eb314e8423d6b51be92eea6e4bf61bc2968a2d9393905e9ae6ba100803cd", + "size": 30733, + "subdir": "linux-64", + "timestamp": 1644322613276, + "version": "0.13.1" + }, + "terminado-0.17.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.10,<3.11.0a0", + "tornado >=6.1.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "00362c34088a3a02bcca1ad72df5f58a", + "name": "terminado", + "sha256": "0baaf2c1c9c5bdd29a149877e8cce8400fd190cb9d451b74af58adc91147984f", + "size": 30045, + "subdir": "linux-64", + "timestamp": 1671752107828, + "version": "0.17.1" + }, + "terminado-0.17.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.11,<3.12.0a0", + "tornado >=6.1.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "442dde204d14d171aab9ee40e8de4de8", + "name": "terminado", + "sha256": "856a8ab8c350c50247b79966c6cb80fb6d4de36eef49ddf75aebbbcaf854c82d", + "size": 37456, + "subdir": "linux-64", + "timestamp": 1677696176157, + "version": "0.17.1" + }, + "terminado-0.17.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.7,<3.8.0a0", + "tornado >=6.1.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9df91494dde4fc93dcf38ec0031410b8", + "name": "terminado", + "sha256": "780b3e70d4dae619503a849c3801d3d8f87364cae7bf39a339a861d90e08e198", + "size": 29817, + "subdir": "linux-64", + "timestamp": 1671752026753, + "version": "0.17.1" + }, + "terminado-0.17.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.8,<3.9.0a0", + "tornado >=6.1.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "462c5ca383e788c3f7d20270e378991b", + "name": "terminado", + "sha256": "b1aaff89c39b3dfd49e910e706f63fc361d4edd14350ea7f6b9fbfc1984ead35", + "size": 29863, + "subdir": "linux-64", + "timestamp": 1671751945016, + "version": "0.17.1" + }, + "terminado-0.17.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.9,<3.10.0a0", + "tornado >=6.1.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "0e76eab58fe488e91f0aee73f46de031", + "name": "terminado", + "sha256": "b2727fb9c674d7ae7786f322ae4e00673edff6c87ce016871f492026a26a0f5e", + "size": 29816, + "subdir": "linux-64", + "timestamp": 1671751864131, + "version": "0.17.1" + }, + "terminado-0.6-py27h4be8df9_0.tar.bz2": { + "build": "py27h4be8df9_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=2.7,<2.8.0a0", + "tornado >=4" + ], + "license": "BSD 3-clause", + "md5": "ce3607ecdaf28091775189e988c5a7c2", + "name": "terminado", + "sha256": "094c859281e843787027eec285f3e8760abdce8de9fea6c79ee94551bd2a6818", + "size": 21040, + "subdir": "linux-64", + "timestamp": 1505690740936, + "version": "0.6" + }, + "terminado-0.6-py35hce234ed_0.tar.bz2": { + "build": "py35hce234ed_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.5,<3.6.0a0", + "tornado >=4" + ], + "license": "BSD 3-clause", + "md5": "ebe9a4243a102df6bffe5700eb8647d4", + "name": "terminado", + "sha256": "9d4e8421a45822ff38a620a7385ea3e5442fbef9bb35579f2c54cfb26cb94e5e", + "size": 21687, + "subdir": "linux-64", + "timestamp": 1505690752231, + "version": "0.6" + }, + "terminado-0.6-py36ha25a19f_0.tar.bz2": { + "build": "py36ha25a19f_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "BSD 3-clause", + "md5": "57a2b3e0ba4db86985aa56882f7aed32", + "name": "terminado", + "sha256": "67902166ee4f00e220619d7c2d218e04814a9a6f2843a259bf80b5bd8bf2474d", + "size": 21665, + "subdir": "linux-64", + "timestamp": 1505690763580, + "version": "0.6" + }, + "terminado-0.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=2.7,<2.8.0a0", + "tornado >=4" + ], + "license": "BSD 3-clause", + "md5": "e4083dd249029725a10d06c113e5a2af", + "name": "terminado", + "sha256": "46232343deb613111a1c37eac6a7483cb14b539e7a68098869276ea870320dd3", + "size": 20589, + "subdir": "linux-64", + "timestamp": 1515723284417, + "version": "0.8.1" + }, + "terminado-0.8.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "ptyprocess", + "python >=2.7,<2.8.0a0", + "tornado >=4" + ], + "license": "BSD 3-clause", + "md5": "943c45b57d23e91b32da1ddf13f9868f", + "name": "terminado", + "sha256": "d0ed165e3bfb41b17c592c52adfe747f706ab6e651e199d0b2888907e59c2ccc", + "size": 20585, + "subdir": "linux-64", + "timestamp": 1517592904899, + "version": "0.8.1" + }, + "terminado-0.8.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.5,<3.6.0a0", + "tornado >=4" + ], + "license": "BSD 3-clause", + "md5": "795f376a555ff5054e6b3259ccec8adf", + "name": "terminado", + "sha256": "e8cad346613a83a2a6dd59f07528d902fecd023e4f3d5a1912df208c5e2370a5", + "size": 21293, + "subdir": "linux-64", + "timestamp": 1515723311817, + "version": "0.8.1" + }, + "terminado-0.8.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "ptyprocess", + "python >=3.5,<3.6.0a0", + "tornado >=4" + ], + "license": "BSD 3-clause", + "md5": "a1abebe26478a33b65f0282e00e12e3d", + "name": "terminado", + "sha256": "01fd849b2106d4e2a1df0b6ca026a9a7e298ae55ab3ee07eed5e18db738e3df2", + "size": 21291, + "subdir": "linux-64", + "timestamp": 1517592910613, + "version": "0.8.1" + }, + "terminado-0.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "BSD 3-clause", + "md5": "561faf04659a67974e9665ceeb45f768", + "name": "terminado", + "sha256": "02eee88fa25fa8dc85ee552f8e6fcef778e2e1785d94cb591db173e8d09766ba", + "size": 21210, + "subdir": "linux-64", + "timestamp": 1515723241244, + "version": "0.8.1" + }, + "terminado-0.8.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "ptyprocess", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "BSD 3-clause", + "md5": "5d45740880aa3c14417ba4f56c530e4d", + "name": "terminado", + "sha256": "ef9af0d7b221157710a9cf2c15af767c8ae1c6cc80cdaac3aab462d273679fb3", + "size": 21214, + "subdir": "linux-64", + "timestamp": 1517592829612, + "version": "0.8.1" + }, + "terminado-0.8.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "ptyprocess", + "python >=3.7,<3.8.0a0", + "tornado >=4" + ], + "license": "BSD 2-clause", + "md5": "e190d08c9bfd72e391c15287deb7c3f4", + "name": "terminado", + "sha256": "a5a6fb9cbdf4d4156e18bee4d6d6834cf841207b64e4423d1bb93e62da2a5770", + "size": 21184, + "subdir": "linux-64", + "timestamp": 1530734649304, + "version": "0.8.1" + }, + "terminado-0.8.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=2.7,<2.8.0a0", + "tornado >=4" + ], + "license": "BSD 2-Clause", + "md5": "7c0ab741a7afe60ff4f257ff741f470e", + "name": "terminado", + "sha256": "4f1239b334f2912ead385374a19414bb9acc3ed442cc0358d60f2b1225b4efcd", + "size": 22167, + "subdir": "linux-64", + "timestamp": 1555428155267, + "version": "0.8.2" + }, + "terminado-0.8.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "BSD 2-Clause", + "md5": "2b92f7182782117e4971a491cc3385c4", + "name": "terminado", + "sha256": "ac5defab5511e99b331f2712ba598ef3eb26c791c338f2e2dd0cbe447c651e69", + "size": 22793, + "subdir": "linux-64", + "timestamp": 1555428183030, + "version": "0.8.2" + }, + "terminado-0.8.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.7,<3.8.0a0", + "tornado >=4" + ], + "license": "BSD 2-Clause", + "md5": "36ca0ba99e1036f2e60b3852a149f9fc", + "name": "terminado", + "sha256": "c773e7dc997039380b970217134cee5a6ea7c8745f2f3b0ae9f829ebbb251a96", + "size": 22861, + "subdir": "linux-64", + "timestamp": 1555428264819, + "version": "0.8.2" + }, + "terminado-0.8.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.8,<3.9.0a0", + "tornado >=4" + ], + "license": "BSD 2-Clause", + "md5": "386ca7f5fd72b5f010ae187c793e47ff", + "name": "terminado", + "sha256": "5fa6163b388372d09afc06ea4fc785da9012e8dc148e112358e871c44d2adb59", + "size": 21772, + "subdir": "linux-64", + "timestamp": 1573554737636, + "version": "0.8.2" + }, + "terminado-0.8.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=2.7,<2.8.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "c307eec7199790a0f3293985d8013b6d", + "name": "terminado", + "sha256": "c9f381c3ebe02eef982aef852cf72fa3e8780ff70a585b79b5441a2bc329f9ab", + "size": 24757, + "subdir": "linux-64", + "timestamp": 1574271887106, + "version": "0.8.3" + }, + "terminado-0.8.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "1c9c70abf4cefb943a8480f25ca328fa", + "name": "terminado", + "sha256": "a6daaf7a865de884222c0845ee948d0b7cf5f3670013775efcdbedf419e6b037", + "size": 25420, + "subdir": "linux-64", + "timestamp": 1574272380240, + "version": "0.8.3" + }, + "terminado-0.8.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.7,<3.8.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "317b099f548c21c12a91b15ccf0fd930", + "name": "terminado", + "sha256": "e5d72e6b643d0980b9a2a50d6aaa36b8817711a09911f62f8b06a9811f828453", + "size": 25500, + "subdir": "linux-64", + "timestamp": 1574271823151, + "version": "0.8.3" + }, + "terminado-0.8.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.8,<3.9.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "88131d1d8d033358897f3aa839b4de2d", + "name": "terminado", + "sha256": "188c6a23c0572ca1e0e681814b6a0575f39c76e24d1121d3170b7c2f7faeefd4", + "size": 25511, + "subdir": "linux-64", + "timestamp": 1574271879193, + "version": "0.8.3" + }, + "terminado-0.9.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "f10205aa7f355518ca2cd1b2ccc3a926", + "name": "terminado", + "sha256": "c0e01497c058940e408903a4c892b20308a58c0e2d248ea63301e93ec2be0e6a", + "size": 26762, + "subdir": "linux-64", + "timestamp": 1602280986405, + "version": "0.9.1" + }, + "terminado-0.9.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.7,<3.8.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "eab8c242f464573683e4437144645567", + "name": "terminado", + "sha256": "3c100ecf61b50e8062dfd177d1da4f34d51f3e9a6052fa02504a8af062b3200d", + "size": 26824, + "subdir": "linux-64", + "timestamp": 1602280973679, + "version": "0.9.1" + }, + "terminado-0.9.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.8,<3.9.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "2db7e8b4538d6ca905155cc05e39497d", + "name": "terminado", + "sha256": "a2b8d7988d6ba37edc809f2f1e9026fb03fcacbe6436b96ad8c354904ec25c7a", + "size": 26882, + "subdir": "linux-64", + "timestamp": 1602280984668, + "version": "0.9.1" + }, + "terminado-0.9.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.9,<3.10.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "1d49816cbf5fbb00e3570de8e7d23c5c", + "name": "terminado", + "sha256": "c0e7fd6da470e1f4b7469b47227b352351ec12a607ec2aa558ddc1740da721cf", + "size": 26973, + "subdir": "linux-64", + "timestamp": 1607372838106, + "version": "0.9.1" + }, + "terminado-0.9.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "1aeb1a3020e30a510f957649e67ac618", + "name": "terminado", + "sha256": "7784ad30bc56a87ac06eaabd8b0d3fbac45332e04862694071fc8f5efdaa03dd", + "size": 24562, + "subdir": "linux-64", + "timestamp": 1609860806824, + "version": "0.9.2" + }, + "terminado-0.9.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.7,<3.8.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "255e594c412b39a8e295e84095b8088b", + "name": "terminado", + "sha256": "42ad0bbb644db2704a80ca8a1deac6c412146bb78503498025dfb260a4b19b34", + "size": 24572, + "subdir": "linux-64", + "timestamp": 1609788082709, + "version": "0.9.2" + }, + "terminado-0.9.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.8,<3.9.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "532f43ba7bebfcb4c5ed5108f7d072fc", + "name": "terminado", + "sha256": "06ba362d4e52e62bf97b37368d66378e4688dcb9245c644e168fef5b06b61207", + "size": 24639, + "subdir": "linux-64", + "timestamp": 1609788098543, + "version": "0.9.2" + }, + "terminado-0.9.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.9,<3.10.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "bf767b5e6ac77c12106a82b24465047d", + "name": "terminado", + "sha256": "6e5552ea6962c399ddf69cba797002d4a4588a6f3c1ede97b15aadea828ffb2e", + "size": 24620, + "subdir": "linux-64", + "timestamp": 1609787984443, + "version": "0.9.2" + }, + "terminado-0.9.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "67fb031bd692af9baffaa04343d199cb", + "name": "terminado", + "sha256": "60a9f81cb31e39dc98c5ba374c44dd514295717afaa2496fa1fc68d629a4b5ab", + "size": 24588, + "subdir": "linux-64", + "timestamp": 1615837005383, + "version": "0.9.3" + }, + "terminado-0.9.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.7,<3.8.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "3c2d1a9d5dfa451593436fd0c2b94b74", + "name": "terminado", + "sha256": "13a588608cbeab192a0770df2a46d06745011b51129570e6b629b68bbfdc0449", + "size": 24672, + "subdir": "linux-64", + "timestamp": 1615837000103, + "version": "0.9.3" + }, + "terminado-0.9.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.8,<3.9.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "e4fe48e523d12733f300af5ccf2acb9e", + "name": "terminado", + "sha256": "a6b6c22ced70ebdbaa07060b5ed3c4863e64dc178ee61d115d9b8c398d6ee0f4", + "size": 24738, + "subdir": "linux-64", + "timestamp": 1615837013538, + "version": "0.9.3" + }, + "terminado-0.9.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.9,<3.10.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "cbd18d993e8f5f894ea5902ad63c74ff", + "name": "terminado", + "sha256": "7b7918e47039d67cbab047c79862b1fc10cb078cb1bacc02f1e494cbad91a6ed", + "size": 24724, + "subdir": "linux-64", + "timestamp": 1615836542460, + "version": "0.9.3" + }, + "terminado-0.9.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.10,<3.11.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "e0295cac4e6709eb309ff6353ecb5edb", + "name": "terminado", + "sha256": "f57e5b8d55883b7987e3ccd6dd44e81cb7cbf3bdf1dc1c5994fcb44113850e76", + "size": 25215, + "subdir": "linux-64", + "timestamp": 1640811103854, + "version": "0.9.4" + }, + "terminado-0.9.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "8a893a2e6c73d6fd3b6a1eba74543874", + "name": "terminado", + "sha256": "61e86869e0dfe72f4fa426b726aae8c29df3f004a9365d522610f429236ae6db", + "size": 24814, + "subdir": "linux-64", + "timestamp": 1617136687771, + "version": "0.9.4" + }, + "terminado-0.9.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.7,<3.8.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "3a7f7be6491d6e93de10c6b475a66c3a", + "name": "terminado", + "sha256": "6f5cd6a94d5901dae19c7639231121d5f3a70e14b1b9037f85a656691776cf5b", + "size": 24882, + "subdir": "linux-64", + "timestamp": 1617136693500, + "version": "0.9.4" + }, + "terminado-0.9.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.8,<3.9.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "01ca0fddea3957eb499151dcf15722c6", + "name": "terminado", + "sha256": "44c878a2fcb0c837123cae4186f188a4bd840ba6980e111035c0640531d27148", + "size": 24930, + "subdir": "linux-64", + "timestamp": 1617136557217, + "version": "0.9.4" + }, + "terminado-0.9.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.9,<3.10.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "5f8f7842268ef25191dd327c75e0349e", + "name": "terminado", + "sha256": "f9370fb54c55861730fc38e873a86812995060731f3126e7cd26b3c625921197", + "size": 24932, + "subdir": "linux-64", + "timestamp": 1617136694558, + "version": "0.9.4" + }, + "tesseract-5.2.0-h6a678d5_0.tar.bz2": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "leptonica >=1.82.0,<1.83.0a0", + "libarchive >=3.6.1,<3.7.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2938c71cf54125c138b37a4086b6dcc3", + "name": "tesseract", + "sha256": "5e3288320dddcde0e4a3a5b6f28e81729372babc5796d695df43e8b2bf080893", + "size": 179682982, + "subdir": "linux-64", + "timestamp": 1666182213677, + "version": "5.2.0" + }, + "testfixtures-5.2.0-py27h1c44549_0.tar.bz2": { + "build": "py27h1c44549_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "88a29cbf616350ab7aa9a4385deceb68", + "name": "testfixtures", + "sha256": "4e748a6e93192a62684807944acd2bd36ada9e2f7cebe68daa0db13590f1c0e2", + "size": 114138, + "subdir": "linux-64", + "timestamp": 1508794291745, + "version": "5.2.0" + }, + "testfixtures-5.2.0-py35h3f4e679_0.tar.bz2": { + "build": "py35h3f4e679_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "b6e6513eb87b2d2efe2fc538fe48dd8b", + "name": "testfixtures", + "sha256": "63d0ee9ccdd058fdad67af967dd7574d1c507a6b2d6f4c556eabaf6c3ee77e93", + "size": 119345, + "subdir": "linux-64", + "timestamp": 1508794289332, + "version": "5.2.0" + }, + "testfixtures-5.2.0-py36hfeca728_0.tar.bz2": { + "build": "py36hfeca728_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9086b9c614da41a19ba42f32054f47e3", + "name": "testfixtures", + "sha256": "860cc345b6976b7bff1886eb9321b100ccaa76f5664650a841b614605928a6d6", + "size": 118300, + "subdir": "linux-64", + "timestamp": 1508794319086, + "version": "5.2.0" + }, + "testfixtures-5.3.1-py27he9e6c30_0.tar.bz2": { + "build": "py27he9e6c30_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e1ca89f3ae4cc54912e4e146cfb36336", + "name": "testfixtures", + "sha256": "3d9456cd536e474ec85348d687ec8cf0486610feeac99dffc4f344f2d25ce34e", + "size": 115890, + "subdir": "linux-64", + "timestamp": 1511316986734, + "version": "5.3.1" + }, + "testfixtures-5.3.1-py35hd2928f4_0.tar.bz2": { + "build": "py35hd2928f4_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "572c5d61a6dc41e824660c6af4ba8c46", + "name": "testfixtures", + "sha256": "987edfe4a97586ff0f9ef9d3cab6a948e8c93a84f57742a4b2a5673af71363d8", + "size": 121179, + "subdir": "linux-64", + "timestamp": 1511316994004, + "version": "5.3.1" + }, + "testfixtures-5.3.1-py36ha2b07aa_0.tar.bz2": { + "build": "py36ha2b07aa_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "babf596cf5c2b32f6b451717b07daf97", + "name": "testfixtures", + "sha256": "1f0b9ce5c9c884ebdcc7c58e0cae7ac90f32c4f0b03846502b7df7f1a9a0de65", + "size": 120200, + "subdir": "linux-64", + "timestamp": 1511316994428, + "version": "5.3.1" + }, + "testfixtures-5.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "db4102e3feff5efc908d39fb2cfe1754", + "name": "testfixtures", + "sha256": "e7b8183b8355a85e9ae9659605d08ec2b28312f08e62d200a10373eb1fd22439", + "size": 117175, + "subdir": "linux-64", + "timestamp": 1519241849188, + "version": "5.4.0" + }, + "testfixtures-5.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "db987558c8910bac3bb8b6c020e45c80", + "name": "testfixtures", + "sha256": "82b8215f5458bd85522e6feea9f414f4f6ddab82c40b44e12cd2c5992133aac9", + "size": 122030, + "subdir": "linux-64", + "timestamp": 1519241957400, + "version": "5.4.0" + }, + "testfixtures-5.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0cfd6d2335f5228ae9b03b22dbec7efe", + "name": "testfixtures", + "sha256": "c22915a2a1008ef4046bc9329ad706d4d03b8a3a2755f2f4a8159dc4e2e1250d", + "size": 121487, + "subdir": "linux-64", + "timestamp": 1519241794416, + "version": "5.4.0" + }, + "testfixtures-6.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "a661989daf0f8ed4c0e451e8a5a39a6c", + "name": "testfixtures", + "sha256": "d5f62d587cc01cc6faef4bf79a89ef561e5c017663fe1c8c7e194111da15ce16", + "size": 122802, + "subdir": "linux-64", + "timestamp": 1522786799253, + "version": "6.0.0" + }, + "testfixtures-6.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "2f88edcfa620de140c484bd5a5df2bc3", + "name": "testfixtures", + "sha256": "77f1bfd70ec128c0b4c27f56d3d50c682af783bb78849410aa3110351aefda2a", + "size": 128375, + "subdir": "linux-64", + "timestamp": 1522786837058, + "version": "6.0.0" + }, + "testfixtures-6.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "659a91575de5f4dc9a677a4275724ca5", + "name": "testfixtures", + "sha256": "00993b9a9be05524b950da514287ed1c3a1b43d89306ba3c3c2ebd4adf0fbd96", + "size": 127616, + "subdir": "linux-64", + "timestamp": 1522786844618, + "version": "6.0.0" + }, + "testfixtures-6.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "585721a999f32b1ffee00133ce59a105", + "name": "testfixtures", + "sha256": "fb75174eb69ca806fa3c98ac825652a41b26a83e71a63ca718c107d6ca9d234f", + "size": 122932, + "subdir": "linux-64", + "timestamp": 1524514936340, + "version": "6.0.1" + }, + "testfixtures-6.0.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "f560c2bbc07b762d923fd9b961a0c884", + "name": "testfixtures", + "sha256": "7fdd8dc8ba9f0d70c37e28fda42111f479e363b8159f85ead63ae21f59fb8cc7", + "size": 128365, + "subdir": "linux-64", + "timestamp": 1524514908860, + "version": "6.0.1" + }, + "testfixtures-6.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9c6a0172b2965c8a21de88b2ce8aa7b5", + "name": "testfixtures", + "sha256": "6419d63ed165cc079fd57bb826063e28dc8694e3c5b05f56fe5405c8fbc7b5ba", + "size": 127415, + "subdir": "linux-64", + "timestamp": 1524514833938, + "version": "6.0.1" + }, + "testfixtures-6.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "eef3ad6689b642e3c0e79ef716edc6d7", + "name": "testfixtures", + "sha256": "2c8feae937e83dc497fe138848942b3d8de82043138285073b816969e519c1bb", + "size": 126368, + "subdir": "linux-64", + "timestamp": 1526939537555, + "version": "6.0.2" + }, + "testfixtures-6.0.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "0c90869af9a81128bf8c6353098df76c", + "name": "testfixtures", + "sha256": "874074b52fd413ac13a3148acfefb4f15e1ae39ad9ec5032c0962a0840b5dc7b", + "size": 131835, + "subdir": "linux-64", + "timestamp": 1526939570777, + "version": "6.0.2" + }, + "testfixtures-6.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a6929926707e9936f4e7d1f90aff2c48", + "name": "testfixtures", + "sha256": "98766724113ea7ee998add8b23a887146287afa766b487ac8ffa4dd74f456519", + "size": 130961, + "subdir": "linux-64", + "timestamp": 1526939523402, + "version": "6.0.2" + }, + "testfixtures-6.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "417cb3b638558df53816ca79d21a8a0c", + "name": "testfixtures", + "sha256": "7f022e2ac2ae7f46b4079de6b6b83479a6fc4f5cb2dc1b05638027539eae631a", + "size": 126723, + "subdir": "linux-64", + "timestamp": 1529438301251, + "version": "6.1.0" + }, + "testfixtures-6.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "df000db5e024ee8b6770094464223dc4", + "name": "testfixtures", + "sha256": "9237693bf51ed5211dc2edf4150cb987a24eb1c52b7f8b91dfb8e82096ae5865", + "size": 131840, + "subdir": "linux-64", + "timestamp": 1529438350772, + "version": "6.1.0" + }, + "testfixtures-6.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8001b764e48d3c095647f313a756dc97", + "name": "testfixtures", + "sha256": "0eb95665c3f8ea0db86bd0165a2d71b420600d3b8ebbe09dc0e42138251ce612", + "size": 131658, + "subdir": "linux-64", + "timestamp": 1529438231446, + "version": "6.1.0" + }, + "testfixtures-6.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f0c5a23624888cef8f7f09b2de7f3806", + "name": "testfixtures", + "sha256": "c84168c9f89847381f1bb8b6d61f0b9b660c7338717b2f92c53befbc8825620b", + "size": 127255, + "subdir": "linux-64", + "timestamp": 1529956285902, + "version": "6.2.0" + }, + "testfixtures-6.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "7114c08b24404e2243f923b6914683ce", + "name": "testfixtures", + "sha256": "f8780700d193157d322d9ec84ec98ed750fec7dd9fba34eb417ec96ad4ff3e7f", + "size": 132909, + "subdir": "linux-64", + "timestamp": 1529956305155, + "version": "6.2.0" + }, + "testfixtures-6.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6aa5fee8eb269509caa129331c3b4a80", + "name": "testfixtures", + "sha256": "0f370355c538d57e67c0b88b11a944d7eb0c152eda28b7930a6e624f68a20afc", + "size": 132001, + "subdir": "linux-64", + "timestamp": 1529956271166, + "version": "6.2.0" + }, + "testfixtures-6.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2ab9b751cf645dc8ce4bca10a5ee5811", + "name": "testfixtures", + "sha256": "41d3f6872bad01b162c51e7f4ff0cf9eb5046f94057872125f378a2dc81cc07f", + "size": 131108, + "subdir": "linux-64", + "timestamp": 1530887663025, + "version": "6.2.0" + }, + "testfixtures-6.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ebb897c03ff390474b300ab488f433ee", + "name": "testfixtures", + "sha256": "07c80467456c94437beadf4451f2ce33038ce6dc06b3c08e227cee95c6dc2e5b", + "size": 128476, + "subdir": "linux-64", + "timestamp": 1536263053325, + "version": "6.3.0" + }, + "testfixtures-6.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "aef4b144c92cdefdf20688d496e8c0ab", + "name": "testfixtures", + "sha256": "2a140ff73288faf89bf826f80a734dc7903586b56f4ab1957495d1ef6776298a", + "size": 134177, + "subdir": "linux-64", + "timestamp": 1536263056493, + "version": "6.3.0" + }, + "testfixtures-6.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3699e43bf317a4f9458593ecfa9c2908", + "name": "testfixtures", + "sha256": "23a51ee391463bf619b293c765d744b0f73276f566ed341449f40900117c63a1", + "size": 133098, + "subdir": "linux-64", + "timestamp": 1536263007293, + "version": "6.3.0" + }, + "testfixtures-6.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "509ecdb2eae550e556ba6b923b6ebabc", + "name": "testfixtures", + "sha256": "ef207b12967a7f5c9308fc839825bd5f038f9f8bc6e594a3e48f3c5ca6379398", + "size": 132708, + "subdir": "linux-64", + "timestamp": 1536263076384, + "version": "6.3.0" + }, + "testfixtures-6.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "df30df476d26a3716dcd37b83a36035d", + "name": "testfixtures", + "sha256": "702bfb2d79c9581b35a1f89a5d8b37eb87132303d2bc52fc6436ddc27a88efe9", + "size": 139031, + "subdir": "linux-64", + "timestamp": 1550363897404, + "version": "6.5.0" + }, + "testfixtures-6.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "99a417909dcb91287d5747dcf03af49b", + "name": "testfixtures", + "sha256": "a9e72499f5d07093393b87a2b49946e172005145fbc374c71d7f64c3eee5fab5", + "size": 143398, + "subdir": "linux-64", + "timestamp": 1550363909598, + "version": "6.5.0" + }, + "testfixtures-6.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "eac2a968054124a37a597d749f44d35c", + "name": "testfixtures", + "sha256": "a156a2d6ffce36c03b79a2f63d89f944bba98611885a77ce9fd7ae35eb6cfe56", + "size": 143513, + "subdir": "linux-64", + "timestamp": 1550363859462, + "version": "6.5.0" + }, + "testpath-0.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pathlib2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be324130667a3c81153129d901e68372", + "name": "testpath", + "sha256": "610700bc228a74fca25083bccea06df2ad1c187de60731d6a4af264702d87ca0", + "size": 92005, + "subdir": "linux-64", + "timestamp": 1530734261652, + "version": "0.3.1" + }, + "testpath-0.3.1-py27hc38d2c4_0.tar.bz2": { + "build": "py27hc38d2c4_0", + "build_number": 0, + "depends": [ + "pathlib2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc6fc17e11eaa6764a118c8959495083", + "name": "testpath", + "sha256": "7616aece23dbd8f5a735d01c4252c325d2a8e57691b7c1bd4ce6087a4bde896f", + "size": 91210, + "subdir": "linux-64", + "timestamp": 1505688601741, + "version": "0.3.1" + }, + "testpath-0.3.1-py35had42eaf_0.tar.bz2": { + "build": "py35had42eaf_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "53d7aca350e67cb29011109e2ac33b5c", + "name": "testpath", + "sha256": "748dae30777034c8e0dfaebde704f8fbe955306b0d05b20ab31535cda44c78ca", + "size": 91574, + "subdir": "linux-64", + "timestamp": 1505688614112, + "version": "0.3.1" + }, + "testpath-0.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14ad874c762ce7f99133cf5b03422e5a", + "name": "testpath", + "sha256": "700e0f43e4488febda4773db0e980ada4d6da34d0ea00984c52c11c39f0a4b8e", + "size": 92082, + "subdir": "linux-64", + "timestamp": 1530734241602, + "version": "0.3.1" + }, + "testpath-0.3.1-py36h8cadb63_0.tar.bz2": { + "build": "py36h8cadb63_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2158b1d76fb934d4024a0a56c4e71763", + "name": "testpath", + "sha256": "524e7be9c6f0a34ff11a9977291e28597434edb66c5a33843e53f59c9bd81c8a", + "size": 91457, + "subdir": "linux-64", + "timestamp": 1505688626461, + "version": "0.3.1" + }, + "testpath-0.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13548c4b4a4011fe4fa046cbc89c2997", + "name": "testpath", + "sha256": "f0de65ec112641a897b891dd958769112ac43693fa5d63e1de67bc2b194a75f6", + "size": 92220, + "subdir": "linux-64", + "timestamp": 1530734282583, + "version": "0.3.1" + }, + "testpath-0.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ea4039abc8883a5a6532bce54d3e6c3", + "name": "testpath", + "sha256": "717c91d81fd1cb677fb0792c73a7969759c3eaf82f7a66e5a1c00fea6b14377b", + "size": 93322, + "subdir": "linux-64", + "timestamp": 1538667007532, + "version": "0.4.1" + }, + "testpath-0.4.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da834503fd2098f3fcf2de302d2849d2", + "name": "testpath", + "sha256": "fb7d24f69b5e17eb97c3cd88c58347ce540bb49ffca6dbdba097af33976fde97", + "size": 93280, + "subdir": "linux-64", + "timestamp": 1538862876705, + "version": "0.4.1" + }, + "testpath-0.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cef344064b92ab4df576e183e1e1570c", + "name": "testpath", + "sha256": "eb559112906c4550e73b6b9b5ad8dd971dd07cea525176c03ca318a35bcc6f01", + "size": 93358, + "subdir": "linux-64", + "timestamp": 1538666481254, + "version": "0.4.1" + }, + "testpath-0.4.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c653c30ffdc6630c133188250a3e0423", + "name": "testpath", + "sha256": "0d6e767c0d696b92622ad1bd0174fc489d4ccc5cf59c269209ba08324097ffe7", + "size": 93322, + "subdir": "linux-64", + "timestamp": 1538862864343, + "version": "0.4.1" + }, + "testpath-0.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0ac8601f79339a38f783776ace69f6f1", + "name": "testpath", + "sha256": "73927b662f026480aeb571530e8aab7174a7f2e1c242abb0dc238232d949c828", + "size": 93145, + "subdir": "linux-64", + "timestamp": 1538864340541, + "version": "0.4.2" + }, + "testpath-0.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d675830a1d2c5fc1a90c2aae7cd1c1c4", + "name": "testpath", + "sha256": "53e95d332b4e610b5df280b163abb83da7f9b630f628f6fccc5ed0dfd9d4992c", + "size": 93478, + "subdir": "linux-64", + "timestamp": 1538864345999, + "version": "0.4.2" + }, + "testpath-0.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "440c4d8ac83e0c212e11f2ddeed501c5", + "name": "testpath", + "sha256": "db9d2c81ed709a0420a78553ab980b6d3138d89317a63e4e4c378382c85001ff", + "size": 93448, + "subdir": "linux-64", + "timestamp": 1538864319863, + "version": "0.4.2" + }, + "testpath-0.6.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7b68a8036e46a3f101e43340cf1ac835", + "name": "testpath", + "sha256": "6dc081021778bf0396ccded7d0dfcd269df31629d562ba6c150e210f8e35993d", + "size": 93655, + "subdir": "linux-64", + "timestamp": 1655908680174, + "version": "0.6.0" + }, + "testpath-0.6.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4e5aabc29991f4db0c106e030288184a", + "name": "testpath", + "sha256": "267ffcdc0e315efdfde73ce547b2bef01c22e469bc10248c528624b598cd67c4", + "size": 97591, + "subdir": "linux-64", + "timestamp": 1676862947873, + "version": "0.6.0" + }, + "testpath-0.6.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "03a603b436fdfe299221d1aa0f8a6541", + "name": "testpath", + "sha256": "4ab60154908933459d95bc2074081dbe59b9fa67d476a67e3aaeccec147770e7", + "size": 93385, + "subdir": "linux-64", + "timestamp": 1655908725295, + "version": "0.6.0" + }, + "testpath-0.6.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "23ebb7cf9ee5b1fe62a911fb71e272ee", + "name": "testpath", + "sha256": "5bc56eb1d33f8d60d675b53bf462ec49e9ac548614af880db53b651bfaae54a5", + "size": 93471, + "subdir": "linux-64", + "timestamp": 1655908769769, + "version": "0.6.0" + }, + "testpath-0.6.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "462c2a924ef617f929787960affc972c", + "name": "testpath", + "sha256": "925677ec26cb76d10c4f0598afcfd83baf8abcb53566e2e16098eb375eeb9200", + "size": 93566, + "subdir": "linux-64", + "timestamp": 1655908613837, + "version": "0.6.0" + }, + "testscenarios-0.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "1c5aac6e90f9bdc8559425e0e4fade3f", + "name": "testscenarios", + "sha256": "e72231741361fbfa4f53d8414a93434c3d772ab76dc303ac116a4aaee77d0b61", + "size": 24002, + "subdir": "linux-64", + "timestamp": 1530898625947, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "61e7a927372dc3678adca433e7fcf547", + "name": "testscenarios", + "sha256": "fb13def68d84189485d1f3e7ad2d7d0e2379e160c83b2e8bc07d8ad8af3f8073", + "size": 25162, + "subdir": "linux-64", + "timestamp": 1640795180168, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "e5d076135979c80b56b62a33249b604b", + "name": "testscenarios", + "sha256": "335c7716051fbbb522cd9071e07d32d7f80f5038aaec7de3b4ab9d96ff805c81", + "size": 29868, + "subdir": "linux-64", + "timestamp": 1676907739765, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "c530158b8dbc7ed6a053f790f2bc1fa9", + "name": "testscenarios", + "sha256": "d662d515185d368b606fccdd2bf7bebaf95d510b22f93df4ae6b769eb92f0164", + "size": 24870, + "subdir": "linux-64", + "timestamp": 1535522079415, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "e22bba4218529a0270940202ded5a043", + "name": "testscenarios", + "sha256": "96e9bcc7247a986df17ef3cfe0bcbe79869d28f91da4a9b8e91d463bcd497a04", + "size": 24782, + "subdir": "linux-64", + "timestamp": 1530898671694, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "866258a783d7e6c482fd84e9384d1473", + "name": "testscenarios", + "sha256": "55b119caacc363f1fc1cf3c2e0224afce930fa3b4365f8d32fc15e6fba18a5e9", + "size": 246158, + "subdir": "linux-64", + "timestamp": 1613996721439, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "c4e0619fda24d312cf83f4694ddc5fd1", + "name": "testscenarios", + "sha256": "35b2a274809bca7d1a6706b379d6b4267794fa7028d9ddb5caa0634dd4d91ffd", + "size": 24774, + "subdir": "linux-64", + "timestamp": 1530898648300, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "bc92b2c5b28a7c23b372db4a75a71230", + "name": "testscenarios", + "sha256": "fd1c15ca0b08dab27fe10a2543fd0298384677730acf88d86d2e8a08eeaa6919", + "size": 249828, + "subdir": "linux-64", + "timestamp": 1613996715651, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "6e9b41c09ca3e41647bd6aabee7a991d", + "name": "testscenarios", + "sha256": "27cb87c31d65a7a1c72cbe57c159f093ebe86730e243e3d7e4fbddceac634aed", + "size": 25351, + "subdir": "linux-64", + "timestamp": 1573728873236, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "979fefad5d08ef7236e8fd63f61c1c7b", + "name": "testscenarios", + "sha256": "f7192b2704329fb43f742dbcfe52502494946c1f2179930e3c0e367a23f0ac3a", + "size": 250001, + "subdir": "linux-64", + "timestamp": 1613996720927, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "db3ff1b7f4b8fcc8d6114e9448894d47", + "name": "testscenarios", + "sha256": "b2b6151cbd30ccc435a0f0fa5cea7f0c5f50bca53b1c61c824770c6301f25607", + "size": 249820, + "subdir": "linux-64", + "timestamp": 1613995988286, + "version": "0.5.0" + }, + "testtools-2.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49de014e67ddf5984b95305e971c1c4b", + "name": "testtools", + "sha256": "64be9962e1e01dba37b131e3509dfe1a42d9c7c3187e9e7c3921030cb930065c", + "size": 275935, + "subdir": "linux-64", + "timestamp": 1530898697002, + "version": "2.3.0" + }, + "testtools-2.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4bc9ca3888dee99d57ec46d55c99f61f", + "name": "testtools", + "sha256": "44dcfc9d2e404a31ca7fa9a1b413bbb91a91687719c65cea8ee94fd958583865", + "size": 308568, + "subdir": "linux-64", + "timestamp": 1640795198553, + "version": "2.3.0" + }, + "testtools-2.3.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f09a8da95e3a13af58cb0436489e08b5", + "name": "testtools", + "sha256": "009b18e56dcab517284adc386a65c1ef12ae50966ef476ab47ec6c693b22774c", + "size": 407925, + "subdir": "linux-64", + "timestamp": 1676862964175, + "version": "2.3.0" + }, + "testtools-2.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "78518be6d5d0b3db6c3d436fca5a8abf", + "name": "testtools", + "sha256": "c721da63d8a8acb565c5f8d845d47aa7e310a5a0839ce98c4b285e38f32c0e13", + "size": 289589, + "subdir": "linux-64", + "timestamp": 1535488562446, + "version": "2.3.0" + }, + "testtools-2.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d450f7f82d73de2fcb16c7571707bb07", + "name": "testtools", + "sha256": "c4c63efb0153b2823d60ba000f58e836073772042be36d68ea0fa5e4a506472c", + "size": 290544, + "subdir": "linux-64", + "timestamp": 1530898764503, + "version": "2.3.0" + }, + "testtools-2.3.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e473575f365b2c5f0d26bf24d673a8d8", + "name": "testtools", + "sha256": "ead89001a13dc7c13802b19b79b016616434c935b791266cba6775ecd4861f29", + "size": 301463, + "subdir": "linux-64", + "timestamp": 1613502820982, + "version": "2.3.0" + }, + "testtools-2.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "feac64ffb9becc315e77bf787498fac5", + "name": "testtools", + "sha256": "22a02b996921807d0ca5c3a2afd4b5261082734b209711f84f30a63c615214a1", + "size": 290962, + "subdir": "linux-64", + "timestamp": 1530898730348, + "version": "2.3.0" + }, + "testtools-2.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0310a8bdf72c315fa58df27d62ce0783", + "name": "testtools", + "sha256": "4200440649840f55c9ee90ec5123459e828e15d222e157b8d4960abcbc3ab0a3", + "size": 301359, + "subdir": "linux-64", + "timestamp": 1613502517570, + "version": "2.3.0" + }, + "testtools-2.3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6e19a36efe4384dcea9356ab3bf47cc", + "name": "testtools", + "sha256": "2b2fc7c9eb6e5c138e113352d146ba00779fd4cc183cede0a5f88c1fd4d86e03", + "size": 303333, + "subdir": "linux-64", + "timestamp": 1574183797369, + "version": "2.3.0" + }, + "testtools-2.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c66126837b0f300e9ad050f01b08892", + "name": "testtools", + "sha256": "153374a1112f0dbbc25d7461ebdf9d7adb19f493440ef7dc1b74c8f2fb08321e", + "size": 306302, + "subdir": "linux-64", + "timestamp": 1613502828200, + "version": "2.3.0" + }, + "testtools-2.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea7ced6726000af3955ada54217c5317", + "name": "testtools", + "sha256": "c018c25aa99cbb3a965de09eed7aa346649255e93281d296f0253ef58c4892f0", + "size": 306036, + "subdir": "linux-64", + "timestamp": 1613502193740, + "version": "2.3.0" + }, + "testtools-2.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "176959d39d5f6dfeddd06b9233f7bfe2", + "name": "testtools", + "sha256": "1dec3112c6917faa9862568cd3026aff90083e62b3f96042e6a66b35b79cead3", + "size": 299700, + "subdir": "linux-64", + "timestamp": 1600554948346, + "version": "2.4.0" + }, + "testtools-2.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1966391f49d725ca68e0a1b9bfefb7da", + "name": "testtools", + "sha256": "f7111c57d6b55dbcf69392a264782f664de29b13ed858e6dc8b2c3c336d9db52", + "size": 300873, + "subdir": "linux-64", + "timestamp": 1600554962273, + "version": "2.4.0" + }, + "testtools-2.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8da9a022e7ce8c23597cfe79c91abf51", + "name": "testtools", + "sha256": "f368819d8af99ab7f9204365018927434bbea43c3f5fd781f624e361cd25ea6d", + "size": 304927, + "subdir": "linux-64", + "timestamp": 1600554942549, + "version": "2.4.0" + }, + "texinfo-6.5-pl526h14c3975_0.tar.bz2": { + "build": "pl526h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "ncurses >=6.1,<7.0a0", + "perl" + ], + "license": "GPL-2.0 and GPL-3.0", + "md5": "4df4be50e7cc4b1ca76139857f4b1f7f", + "name": "texinfo", + "sha256": "39708fba82de203473acdf6517f719ca3b71620dd6a8e55518377d39095e2702", + "size": 1520764, + "subdir": "linux-64", + "timestamp": 1527352014885, + "version": "6.5" + }, + "texinfo-6.7-pl5262h7f8727e_0.tar.bz2": { + "build": "pl5262h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "perl" + ], + "license": "GPL-2.0 and GPL-3.0", + "license_family": "GPL", + "md5": "bb83adafe281f9e1e48ea963e89ad4e9", + "name": "texinfo", + "sha256": "43c9cc057cb0644b7a601f54588415345a37f91679e32af31814b86ea0b5db8d", + "size": 1511592, + "subdir": "linux-64", + "timestamp": 1624617959398, + "version": "6.7" + }, + "texinfo-6.8-pl5262h7f8727e_0.tar.bz2": { + "build": "pl5262h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "perl" + ], + "license": "GPL-2.0 and GPL-3.0", + "license_family": "GPL", + "md5": "d252a2490a3d8d1c987a9174fba081b5", + "name": "texinfo", + "sha256": "00badff5820e42bd40517ce18e42385fcddf0517dfd4e9c09774c5c696f33c40", + "size": 1551584, + "subdir": "linux-64", + "timestamp": 1625642898021, + "version": "6.8" + }, + "texlive-core-20170520-pl526hcfff585_3.tar.bz2": { + "build": "pl526hcfff585_3", + "build_number": 3, + "depends": [ + "cairo 1.14.*", + "cairo >=1.14.10,<2.0a0", + "freetype >=2.8,<2.9.0a0", + "gmp 6.1.*", + "graphite2", + "harfbuzz", + "harfbuzz >=1.5.0,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "mpfr 3.1.*", + "perl", + "pixman 0.34.*", + "pixman >=0.34.0,<1.0a0", + "poppler", + "poppler >=0.60.1,<1.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0+ and GPL-2.0 and GPL-3.0 and LPPL-1.3c and LPPL-1.0 and Artistic-1.0 and Apache-2.0 and MIT and BSD-3-Clause", + "md5": "b5d406a4fb315e4293e0a38fc62fc0bb", + "name": "texlive-core", + "namespace": "global", + "sha256": "17a7f840809960db47beae0c8d3476fea0f22eb0dec53c39d70855c126b02b6b", + "size": 9207506, + "subdir": "linux-64", + "timestamp": 1507908420398, + "version": "20170520" + }, + "texlive-core-20180414-hc8d0b01_0.tar.bz2": { + "build": "hc8d0b01_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "gmp >=6.1.2", + "graphite2 >=1.3.11,<2.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "mpfr >=4.0.1,<5.0a0", + "pixman >=0.34.0,<1.0a0", + "poppler >=0.65.0,<1.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0+ and GPL-2.0 and GPL-3.0 and LPPL-1.3c and LPPL-1.0 and Artistic-1.0 and Apache-2.0 and MIT and BSD-3-Clause", + "md5": "b1aa32930a5fefbb87f363d8719ef1e7", + "name": "texlive-core", + "namespace": "global", + "sha256": "57cda0d1b53cdbcf957aa8a5f13f8e27746c7b0ce2a6212c408edc0a463e9b47", + "size": 10827834, + "subdir": "linux-64", + "timestamp": 1528110001740, + "version": "20180414" + }, + "text-unidecode-1.0-py36he5a4ee8_0.tar.bz2": { + "build": "py36he5a4ee8_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Artistic License", + "license_family": "Other", + "md5": "4e164d6f98109c4597896e5c55842f01", + "name": "text-unidecode", + "sha256": "15911386c5c1a0e4c87e548e823e133345057e317cf96be423a051df45252d71", + "size": 66821, + "subdir": "linux-64", + "timestamp": 1508954619615, + "version": "1.0" + }, + "text-unidecode-1.1-py27ha29237d_0.tar.bz2": { + "build": "py27ha29237d_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Artistic License", + "license_family": "Other", + "md5": "0c29e4af49f52844555021eb1f54f7da", + "name": "text-unidecode", + "sha256": "d36fed4712ec51d3fb85add71b3cd31fec30665a358dd7151428283f4d1c7d52", + "size": 66734, + "subdir": "linux-64", + "timestamp": 1511316578012, + "version": "1.1" + }, + "text-unidecode-1.1-py35h97c4824_0.tar.bz2": { + "build": "py35h97c4824_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Artistic License", + "license_family": "Other", + "md5": "266c1263f09605877c350e037bcf86f1", + "name": "text-unidecode", + "sha256": "5f46b6996a93a64833b14d042fe614458d1886163cd6bfa9d12e6f2aaf70f42c", + "size": 66972, + "subdir": "linux-64", + "timestamp": 1511316587924, + "version": "1.1" + }, + "text-unidecode-1.1-py36h30150ea_0.tar.bz2": { + "build": "py36h30150ea_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Artistic License", + "license_family": "Other", + "md5": "d8cdb8a64715617841077defc88ac7d7", + "name": "text-unidecode", + "sha256": "b168ab9e6917ba3a8f8b296806ed8068023d63aa88f7d0d780616b0f81c1b8a3", + "size": 66798, + "subdir": "linux-64", + "timestamp": 1511316586607, + "version": "1.1" + }, + "text-unidecode-1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Artistic License", + "license_family": "Other", + "md5": "c1672ff4809fb86444d72c7809a090fb", + "name": "text-unidecode", + "sha256": "8603e6040b0f7dd8633a71fb570d52fcb28fcf69be9ab51b1729ec0580cefed9", + "size": 66472, + "subdir": "linux-64", + "timestamp": 1519482783967, + "version": "1.2" + }, + "text-unidecode-1.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Artistic License", + "license_family": "Other", + "md5": "acefb1d39115e6078bf743763741bbd9", + "name": "text-unidecode", + "sha256": "cbd02de9c4cdd983974dbb6effb189d588f16ec341aecf2c5102a239db46ef27", + "size": 66544, + "subdir": "linux-64", + "timestamp": 1519482831235, + "version": "1.2" + }, + "text-unidecode-1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Artistic License", + "license_family": "Other", + "md5": "ad99f2dd7d1c69cb03f3c34e81a615ec", + "name": "text-unidecode", + "sha256": "a4bfe38c8472ae0451ece0c08489468446ac0870052f8497cb76547b62adacfb", + "size": 66497, + "subdir": "linux-64", + "timestamp": 1519482764040, + "version": "1.2" + }, + "text-unidecode-1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Artistic License", + "license_family": "Other", + "md5": "585ba740c61ca3d8a2005c5b5737e7f0", + "name": "text-unidecode", + "sha256": "af92388d10cb74fab7d18580028247fcf73f2bbfcafc96399e2c05e216243cd7", + "size": 66376, + "subdir": "linux-64", + "timestamp": 1530727707203, + "version": "1.2" + }, + "the_silver_searcher-2.1.0-h4cbc732_0.tar.bz2": { + "build": "h4cbc732_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pcre", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2acc61b8009ae3755b742c4883b6687f", + "name": "the_silver_searcher", + "sha256": "4fe16f75646bcc36af5fd295f2dac6eec08e2168e9dfad50accc6790c09a177e", + "size": 63318, + "subdir": "linux-64", + "timestamp": 1511653156244, + "version": "2.1.0" + }, + "the_silver_searcher-2.2.0-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pcre >=8.42,<9.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "79677f573502b4805b44ea0263db9a8b", + "name": "the_silver_searcher", + "sha256": "8709cd4e217b9e758196554e55e2be05c1ae9ff5422399bcfca63486cefddb53", + "size": 63297, + "subdir": "linux-64", + "timestamp": 1535177119515, + "version": "2.2.0" + }, + "theano-0.9.0-py27ha72280b_3.tar.bz2": { + "build": "py27ha72280b_3", + "build_number": 3, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.6.5,<0.7", + "python >=2.7,<2.8.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0621b45091e70e9b021d88e53a302179", + "name": "theano", + "sha256": "03907acc15b3dd71f55aa95c56a51b4f91cc7dcca0418c6371f0e67ae7cdb8dc", + "size": 4174774, + "subdir": "linux-64", + "timestamp": 1512408263820, + "version": "0.9.0" + }, + "theano-0.9.0-py35hb20a197_3.tar.bz2": { + "build": "py35hb20a197_3", + "build_number": 3, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.6.5,<0.7", + "python >=3.5,<3.6.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8d337edb3f8a4613a3d907e01682cc75", + "name": "theano", + "sha256": "f3833261acfe7ed88276f935762203e426eebcf8a4ae378ccfc58ad96be89005", + "size": 4283797, + "subdir": "linux-64", + "timestamp": 1512408289608, + "version": "0.9.0" + }, + "theano-0.9.0-py36h6b64b5b_3.tar.bz2": { + "build": "py36h6b64b5b_3", + "build_number": 3, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.6.5,<0.7", + "python >=3.6,<3.7.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "db08138009f6eb92fe2448166cf766ab", + "name": "theano", + "sha256": "5ae2a14d3ccfbb16227399e6eab84c20f42b5f6b31a680f491bc75056104ef59", + "size": 4270815, + "subdir": "linux-64", + "timestamp": 1512408321462, + "version": "0.9.0" + }, + "theano-1.0.1-py27h6bb024c_0.tar.bz2": { + "build": "py27h6bb024c_0", + "build_number": 0, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "33229dcb02bee801040cb028db09cd72", + "name": "theano", + "sha256": "69f6dd8afacc38382b9123b3dbb1f0432e4dc8b99a7f1ca3212bec1a3f03302f", + "size": 3793259, + "subdir": "linux-64", + "timestamp": 1515164048460, + "version": "1.0.1" + }, + "theano-1.0.1-py35h6bb024c_0.tar.bz2": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eba2b770a182f7dcd017f61c55569ffc", + "name": "theano", + "sha256": "c920956db6e635958c2e6d1a592f37e591573bb7d99827c38b37f0a0f41ec88d", + "size": 3892383, + "subdir": "linux-64", + "timestamp": 1515164059870, + "version": "1.0.1" + }, + "theano-1.0.1-py36h6bb024c_0.tar.bz2": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0af373b1f3040fdbf8c384d5328bf5b7", + "name": "theano", + "sha256": "c86b35f2acff336d01e092939ce7b4ab7a949a47c10203b7fc3fc5c0e5c82bd6", + "size": 3878126, + "subdir": "linux-64", + "timestamp": 1515164064499, + "version": "1.0.1" + }, + "theano-1.0.2-py27h6bb024c_0.tar.bz2": { + "build": "py27h6bb024c_0", + "build_number": 0, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "350d5fd953fc1e6ce0fcbf3aa85e967f", + "name": "theano", + "sha256": "1bdb1b07d242290d22dcdf445fe1457bcf743781b8a587f53c6b92f4f7faa1d3", + "size": 3802576, + "subdir": "linux-64", + "timestamp": 1528351610247, + "version": "1.0.2" + }, + "theano-1.0.2-py35h6bb024c_0.tar.bz2": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "acb4125ee1ace4bce01151f0f7d07daa", + "name": "theano", + "sha256": "d39aa6a6b1a879420674fc9f4fe61ead37f2f2a6a3763d6b408846f94f7f4144", + "size": 3896402, + "subdir": "linux-64", + "timestamp": 1528351670405, + "version": "1.0.2" + }, + "theano-1.0.2-py36h6bb024c_0.tar.bz2": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ee33e1fcb9e03f0b087c1bebb6d2d114", + "name": "theano", + "sha256": "53c920265c818aaa235beb8e55184b03f838cecad7a40fb53b9f855d272cfd17", + "size": 3890689, + "subdir": "linux-64", + "timestamp": 1528351596858, + "version": "1.0.2" + }, + "theano-1.0.2-py37h6bb024c_0.tar.bz2": { + "build": "py37h6bb024c_0", + "build_number": 0, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fe67d1beed13cca283b25f267af0e53f", + "name": "theano", + "sha256": "ac88723e80f86e5bd86190edfa33e33d012128798e43a4f5797d5b2ceaa8fcb5", + "size": 3832162, + "subdir": "linux-64", + "timestamp": 1530917559962, + "version": "1.0.2" + }, + "theano-1.0.3-py27hfd86e86_0.tar.bz2": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "gxx_linux-64 7.3.0.*", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5767acf435ccbcccf0f5fd4e05777286", + "name": "theano", + "sha256": "0b9ce21fc06519ad490b5bfdb32ccf155ecedb4c45084ce3a4be1c9cbaacee08", + "size": 3740225, + "subdir": "linux-64", + "timestamp": 1538228644972, + "version": "1.0.3" + }, + "theano-1.0.3-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "gxx_linux-64 7.3.0.*", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d0d015ec908076e72034590b31bf42f1", + "name": "theano", + "sha256": "3b919b67e023d48cad3bb01211fd631625be6dad469922b0621510e850f1d9f8", + "size": 3833450, + "subdir": "linux-64", + "timestamp": 1538229063203, + "version": "1.0.3" + }, + "theano-1.0.3-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "gxx_linux-64 7.3.0.*", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bbb44e28f71c4aa8e56391da13bad3df", + "name": "theano", + "sha256": "744c5375d6a27d4578bf58c5a8e18afcde2b7c1f0c36270689b5ac240f07b0d7", + "size": 3811908, + "subdir": "linux-64", + "timestamp": 1538228697700, + "version": "1.0.3" + }, + "theano-1.0.4-py27hfd86e86_0.tar.bz2": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "gxx_linux-64 7.3.0.*", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ff5eeb58ba52e18111ac9ff9342254ad", + "name": "theano", + "sha256": "64add9ea12ab6935097a04d37da5e1b107520a39b3891bf1aea1b02fe6fe6f29", + "size": 3739709, + "subdir": "linux-64", + "timestamp": 1568298725967, + "version": "1.0.4" + }, + "theano-1.0.4-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "gxx_linux-64 7.3.0.*", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "03965841580f2f14e72249982f3a08e9", + "name": "theano", + "sha256": "99ee4670263691d6c44286f32b3af4c5afc906c38b7fb7a9bd12836c8c049b1b", + "size": 3798731, + "subdir": "linux-64", + "timestamp": 1568298782021, + "version": "1.0.4" + }, + "theano-1.0.4-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "gxx_linux-64 7.3.0.*", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d674ad3d7c2a05e99469826831cfb911", + "name": "theano", + "sha256": "a27e279712dc21c347af01969e767b2be5b7311da89ea7f79222530cace00d2e", + "size": 3773810, + "subdir": "linux-64", + "timestamp": 1568298790394, + "version": "1.0.4" + }, + "theano-1.0.4-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "gxx_linux-64 7.3.0.*", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3f72b8a5129499d44caa2d60b1801a17", + "name": "theano", + "sha256": "2f86899d5481d6474de350e756b85bc458feafa45e12524c087f6a5780512741", + "size": 3763112, + "subdir": "linux-64", + "timestamp": 1574412720213, + "version": "1.0.4" + }, + "theano-1.0.5-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 7.5.0.*", + "gxx_linux-64 7.5.0.*", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "35124c040e05d28c41974705f3ec56d0", + "name": "theano", + "sha256": "d9dcb4a1646364387be30d746cc81319256451e20d3ebc93c7d96f0ba293f86b", + "size": 3798808, + "subdir": "linux-64", + "timestamp": 1640811129594, + "version": "1.0.5" + }, + "theano-1.0.5-py37h295c915_1.tar.bz2": { + "build": "py37h295c915_1", + "build_number": 1, + "depends": [ + "gcc_linux-64 7.5.0.*", + "gxx_linux-64 7.5.0.*", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.14,<1.8", + "six >=1.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "93450d87ded95c09a7ab16c3c7d02edd", + "name": "theano", + "sha256": "9a97b04fcf44ed28118c61e3bc4c9c44ee50ee195f11542a78a39ff0d3c800b6", + "size": 3756697, + "subdir": "linux-64", + "timestamp": 1643818030896, + "version": "1.0.5" + }, + "theano-1.0.5-py38h295c915_1.tar.bz2": { + "build": "py38h295c915_1", + "build_number": 1, + "depends": [ + "gcc_linux-64 7.5.0.*", + "gxx_linux-64 7.5.0.*", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.14,<1.8", + "six >=1.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3c889153aff4d28b7c7598943d4bdc41", + "name": "theano", + "sha256": "851ded692a5880100100e68ddd8c287d235d37592ebd77538336253c81aec1cd", + "size": 3767659, + "subdir": "linux-64", + "timestamp": 1643799912077, + "version": "1.0.5" + }, + "theano-1.0.5-py39h295c915_1.tar.bz2": { + "build": "py39h295c915_1", + "build_number": 1, + "depends": [ + "gcc_linux-64 7.5.0.*", + "gxx_linux-64 7.5.0.*", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.14,<1.8", + "six >=1.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d6c858adc7f5d7dd6b6467fa7a8d7f9c", + "name": "theano", + "sha256": "0c118d802d0023c1d6c12d02a2bfcf3af0ce24d218d1fbee3bb05a45e5207b9f", + "size": 3791012, + "subdir": "linux-64", + "timestamp": 1643802074547, + "version": "1.0.5" + }, + "theano-pymc-1.1.2-py310h00e6091_0.tar.bz2": { + "build": "py310h00e6091_0", + "build_number": 0, + "depends": [ + "filelock", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=0.14,<1.8" + ], + "license": "BSD-3-Clause", + "md5": "ac44a3245d0f753b8c2d5af0eeae9ddd", + "name": "theano-pymc", + "sha256": "00e746a983008eecc00e3124abd4adeccd84c9926e3caf7b1d6e85a2ddd35f82", + "size": 2319009, + "subdir": "linux-64", + "timestamp": 1640811162816, + "version": "1.1.2" + }, + "theano-pymc-1.1.2-py311hba01205_0.tar.bz2": { + "build": "py311hba01205_0", + "build_number": 0, + "depends": [ + "filelock", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0", + "scipy >=0.14,<1.8" + ], + "license": "BSD-3-Clause", + "md5": "2630dd567430fa3a87b95a83566e9601", + "name": "theano-pymc", + "sha256": "0f3de7d9fb2bdadf0463c3f1fef711c9f8d2da91a6db3f8ac796f13609720ae6", + "size": 2958255, + "subdir": "linux-64", + "timestamp": 1676845958444, + "version": "1.1.2" + }, + "theano-pymc-1.1.2-py37h51133e4_0.tar.bz2": { + "build": "py37h51133e4_0", + "build_number": 0, + "depends": [ + "filelock", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.14,<1.8" + ], + "license": "BSD-3-Clause", + "md5": "0817218593a86573c575f1a806c5281b", + "name": "theano-pymc", + "sha256": "89153b2757614b7de13acf3f2c04c4ef3fb9f9006078e3c45b5b5be89f8c7d6b", + "size": 2305597, + "subdir": "linux-64", + "timestamp": 1634734591197, + "version": "1.1.2" + }, + "theano-pymc-1.1.2-py38h51133e4_0.tar.bz2": { + "build": "py38h51133e4_0", + "build_number": 0, + "depends": [ + "filelock", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.14,<1.8" + ], + "license": "BSD-3-Clause", + "md5": "01534bc867d0742dc336865811b0600d", + "name": "theano-pymc", + "sha256": "439ced7806dc2c032bbbdc76fc7f3f2187107bcb4d696890c803a6fd6e417f68", + "size": 2318842, + "subdir": "linux-64", + "timestamp": 1634734602238, + "version": "1.1.2" + }, + "theano-pymc-1.1.2-py39h51133e4_0.tar.bz2": { + "build": "py39h51133e4_0", + "build_number": 0, + "depends": [ + "filelock", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.14,<1.8" + ], + "license": "BSD-3-Clause", + "md5": "debd519eaeb2364339b41ed95014cc55", + "name": "theano-pymc", + "sha256": "2f6e25cfe28d7c439bfd063df2ba073ca0275c8df465734269850d18e3874469", + "size": 2299371, + "subdir": "linux-64", + "timestamp": 1634723244153, + "version": "1.1.2" + }, + "thefuzz-0.19.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "5d8a27fec2287f44a8adb5044c4b7652", + "name": "thefuzz", + "sha256": "2abab8854f483476c02d59789f2767dc93b508244b207c7b2f66e184e1bfcf75", + "size": 29117, + "subdir": "linux-64", + "timestamp": 1664351331399, + "version": "0.19.0" + }, + "thefuzz-0.19.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "4c0c4942d11dc41535defe80282c0a3e", + "name": "thefuzz", + "sha256": "f04583700ff2d140bf7afdb73653cf10d94e0e0cef8cc56e477081672095f1dc", + "size": 33592, + "subdir": "linux-64", + "timestamp": 1679340367786, + "version": "0.19.0" + }, + "thefuzz-0.19.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "3659392ee788e9556728d23173316368", + "name": "thefuzz", + "sha256": "00d1c32ba855e59d41e0ba9d3bf0ff4255451dc2423bcc5086fa0e24d0e64d82", + "size": 29060, + "subdir": "linux-64", + "timestamp": 1664351357598, + "version": "0.19.0" + }, + "thefuzz-0.19.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "4e0cf34bdb5b31c87f9be354e1da5f66", + "name": "thefuzz", + "sha256": "cc900683025318087ed39a3d5a11a08fcb68ce52ccece895238bc57dc33c1aac", + "size": 29133, + "subdir": "linux-64", + "timestamp": 1664351286931, + "version": "0.19.0" + }, + "thefuzz-0.19.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "9254d947bf6eea425e386e734ec04cd2", + "name": "thefuzz", + "sha256": "a836137cb1b605b612b16d581de62fd978880de352b704138ff9cdf844407093", + "size": 29092, + "subdir": "linux-64", + "timestamp": 1664351388133, + "version": "0.19.0" + }, + "thinc-6.10.0-py27h53cc36c_0.tar.bz2": { + "build": "py27h53cc36c_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.8,<0.9", + "dill", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy", + "msgpack-python", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "termcolor", + "tqdm >=4.10.0,<5.0.0", + "wrapt" + ], + "license": "MIT", + "md5": "544c43bb3f8b85b673fc86f49a04784b", + "name": "thinc", + "sha256": "3efef018bfcc5515993955189ac0300c72ec4c986d720c0e7bd8e1558340a744", + "size": 1499519, + "subdir": "linux-64", + "timestamp": 1509389017076, + "version": "6.10.0" + }, + "thinc-6.10.0-py35hef661f6_0.tar.bz2": { + "build": "py35hef661f6_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.8,<0.9", + "dill", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy", + "msgpack-python", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0,<2.0.0", + "termcolor", + "tqdm >=4.10.0,<5.0.0", + "wrapt" + ], + "license": "MIT", + "md5": "34cb72d1e2a26712f99590dbe9734596", + "name": "thinc", + "sha256": "38d60874f9b25c6b62752385db22e3807dbb610337024676142c601d8e2c8649", + "size": 1501915, + "subdir": "linux-64", + "timestamp": 1509389024919, + "version": "6.10.0" + }, + "thinc-6.10.0-py36hc5923a9_0.tar.bz2": { + "build": "py36hc5923a9_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.8,<0.9", + "dill", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy", + "msgpack-python", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "termcolor", + "tqdm >=4.10.0,<5.0.0", + "wrapt" + ], + "license": "MIT", + "md5": "731b1242ee3c699487d3265f6e5e0f79", + "name": "thinc", + "sha256": "b7c7860b1dd39f8852e51390a036793e867fd9f55da8b39d70981db63aaa4259", + "size": 1513837, + "subdir": "linux-64", + "timestamp": 1509389020891, + "version": "6.10.0" + }, + "thinc-6.10.1-py27ha99dbb2_0.tar.bz2": { + "build": "py27ha99dbb2_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.8,<0.9", + "dill", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy", + "msgpack-python", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "termcolor", + "tqdm >=4.10.0,<5.0.0", + "wrapt" + ], + "license": "MIT", + "md5": "943aa804dcd7aea714abfd0c8975a7a3", + "name": "thinc", + "sha256": "bc91f4a3ff696307cc01cd48584382e61a79f0a1845b61c74957dfee981b842c", + "size": 1520926, + "subdir": "linux-64", + "timestamp": 1511372593542, + "version": "6.10.1" + }, + "thinc-6.10.1-py35hd0b83a8_0.tar.bz2": { + "build": "py35hd0b83a8_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.8,<0.9", + "dill", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy", + "msgpack-python", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0,<2.0.0", + "termcolor", + "tqdm >=4.10.0,<5.0.0", + "wrapt" + ], + "license": "MIT", + "md5": "eb5e92c055279df99acc26d26492755e", + "name": "thinc", + "sha256": "0d1bb72846eaabb4b9de678081ad281d3d34ca5036ee729a12ab7d0338e8ea30", + "size": 1528134, + "subdir": "linux-64", + "timestamp": 1511372658762, + "version": "6.10.1" + }, + "thinc-6.10.1-py36hd61447b_0.tar.bz2": { + "build": "py36hd61447b_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.8,<0.9", + "dill", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy", + "msgpack-python", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "termcolor", + "tqdm >=4.10.0,<5.0.0", + "wrapt" + ], + "license": "MIT", + "md5": "716d2d1bda595144b8932cb673bf3cbd", + "name": "thinc", + "sha256": "675e838100419e6d6d5124fb5ede6400b9edc98c2e848e50684c049ff9c9d1ab", + "size": 1539330, + "subdir": "linux-64", + "timestamp": 1511372667121, + "version": "6.10.1" + }, + "thinc-6.10.2-py27h637b7d7_0.tar.bz2": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.8,<0.9", + "dill >=0.2.6,<0.3.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy ==0.4.1", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.30", + "numpy >=1.9.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<2.0.0" + ], + "license": "MIT", + "md5": "fc710c14568470b102e1cc1b1c97d029", + "name": "thinc", + "sha256": "8fe97cb5546d317af988641323f1376379c36d23e9319a0f8d416a2a5a856eb2", + "size": 1547367, + "subdir": "linux-64", + "timestamp": 1519845134056, + "version": "6.10.2" + }, + "thinc-6.10.2-py35h637b7d7_0.tar.bz2": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.8,<0.9", + "dill >=0.2.6,<0.3.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy ==0.4.1", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.30", + "numpy >=1.9.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<2.0.0" + ], + "license": "MIT", + "md5": "64add453335b45b1bf53667e567191a9", + "name": "thinc", + "sha256": "68df7300419c6d4f21a81444b48bf84c6ddf815fa9fededd33b1e83af6fc9da6", + "size": 1548377, + "subdir": "linux-64", + "timestamp": 1519845143714, + "version": "6.10.2" + }, + "thinc-6.10.2-py36h637b7d7_0.tar.bz2": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.8,<0.9", + "dill >=0.2.6,<0.3.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy ==0.4.1", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.30", + "numpy >=1.9.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<2.0.0" + ], + "license": "MIT", + "md5": "e0164bbabda94862bd3026802ab16946", + "name": "thinc", + "sha256": "cd014e223816f0ec6aa93f483bcdd4e9f0cc191ddb8b49658a395cffcc3d3592", + "size": 1560698, + "subdir": "linux-64", + "timestamp": 1519845150412, + "version": "6.10.2" + }, + "thinc-6.10.3-py27h962f231_0.tar.bz2": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.9,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy >=0.4.1,<1.0.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<0.29.0", + "numpy >=1.11.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "afb101aecd8725a957444258905ac108", + "name": "thinc", + "sha256": "d5393dfaf4e524741ea3cd6d44b872cd2fd1216aac24ed3baf0b8cae4e35b33d", + "size": 1569233, + "subdir": "linux-64", + "timestamp": 1535604135076, + "version": "6.10.3" + }, + "thinc-6.10.3-py35h962f231_0.tar.bz2": { + "build": "py35h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.9,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy >=0.4.1,<1.0.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<0.29.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "f259aee065a4eb07e78139f302965403", + "name": "thinc", + "sha256": "b9942646bdb69256c77af88ffa0f353e8643fb2b0980ec9df49e510b9c8c6603", + "size": 1571169, + "subdir": "linux-64", + "timestamp": 1535604432289, + "version": "6.10.3" + }, + "thinc-6.10.3-py36h962f231_0.tar.bz2": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.9,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy >=0.4.1,<1.0.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<0.29.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "53753a2a9400d33f4ffba2b19a166a22", + "name": "thinc", + "sha256": "4f69132115fb6933c6021e280599597638037003aeb428b93c9837a237a58a88", + "size": 1580134, + "subdir": "linux-64", + "timestamp": 1535604191962, + "version": "6.10.3" + }, + "thinc-6.10.3-py37h962f231_0.tar.bz2": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.9,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy >=0.4.1,<1.0.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<0.29.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "e12c91eac4812e344055fdce67023e2e", + "name": "thinc", + "sha256": "4fbd66e96531385d64550bb95e3507cef0278ecdd70dc9de32398e5787341374", + "size": 1577613, + "subdir": "linux-64", + "timestamp": 1535604328986, + "version": "6.10.3" + }, + "thinc-6.11.2-py27h6cfcb94_0.tar.bz2": { + "build": "py27h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "40586e9bbeac4817e7d23dbab422760d", + "name": "thinc", + "sha256": "9523eb7d44fc37811e0dd75f7abce3251442fa3858830ac2587bea4d3a452eb0", + "size": 1844586, + "subdir": "linux-64", + "timestamp": 1529614590924, + "version": "6.11.2" + }, + "thinc-6.11.2-py27h6cfcb94_1.tar.bz2": { + "build": "py27h6cfcb94_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "six", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "cc5dbacdbf2bd4d247b92f757dbbdb20", + "name": "thinc", + "sha256": "75db7a6f254e96e4e5fc1540ed383159cbc7b1f52d0cc0fe4c8ad523b6156ad7", + "size": 1845030, + "subdir": "linux-64", + "timestamp": 1531127441221, + "version": "6.11.2" + }, + "thinc-6.11.2-py27hedc7406_0.tar.bz2": { + "build": "py27hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "d4f443c7970c623bdc6db60294e51f60", + "name": "thinc", + "sha256": "52ad0830f2409fdb3cab02f0a344303c5172a8f935c4053b7ecf5e322119e74a", + "size": 1844945, + "subdir": "linux-64", + "timestamp": 1529611469813, + "version": "6.11.2" + }, + "thinc-6.11.2-py27hedc7406_1.tar.bz2": { + "build": "py27hedc7406_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "six", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "d94425e4cb4f1dc7d6999a1f8815afaf", + "name": "thinc", + "sha256": "2febe95c7ed51fd156bc14c45ded5927eecb77e7f2ba66a7c6069c9b672d50de", + "size": 1844570, + "subdir": "linux-64", + "timestamp": 1531127273590, + "version": "6.11.2" + }, + "thinc-6.11.2-py35h6cfcb94_0.tar.bz2": { + "build": "py35h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "d2668210a17c37067ebd9af6fd588aad", + "name": "thinc", + "sha256": "8840b9eeab779a6fd7ccafa1265ab663660a69d6b99615946d67f526f8283eb2", + "size": 1834972, + "subdir": "linux-64", + "timestamp": 1529612753984, + "version": "6.11.2" + }, + "thinc-6.11.2-py35hedc7406_0.tar.bz2": { + "build": "py35hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "dfb01d890bdf5248f1cc1124bd6949ce", + "name": "thinc", + "sha256": "9cc76396f5690919dd2ba309a19920c6fe70037c06aa1979f02bd9ab17ae21b9", + "size": 1834454, + "subdir": "linux-64", + "timestamp": 1529612753182, + "version": "6.11.2" + }, + "thinc-6.11.2-py36h6cfcb94_0.tar.bz2": { + "build": "py36h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "8b934cfc470d352f92a6007c6ef35950", + "name": "thinc", + "sha256": "3f898717fcef1c72b8cd5a203d9e80d375d9f794b5a221837a50a81631583eed", + "size": 1847318, + "subdir": "linux-64", + "timestamp": 1529612754249, + "version": "6.11.2" + }, + "thinc-6.11.2-py36h6cfcb94_1.tar.bz2": { + "build": "py36h6cfcb94_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "six", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "10780e314f7d4d91f7afdc911c39777a", + "name": "thinc", + "sha256": "e01b4d06e2905ba2905522d03fa647ebc9a8438c978bd9757e5531590f779eb7", + "size": 1846831, + "subdir": "linux-64", + "timestamp": 1531128114884, + "version": "6.11.2" + }, + "thinc-6.11.2-py36hedc7406_0.tar.bz2": { + "build": "py36hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "2a76ae6e6381fd8fddd50e3386469991", + "name": "thinc", + "sha256": "269827798d0c53f6e2705067e7492c6380fc73fe88ece908366099e732b549db", + "size": 1847192, + "subdir": "linux-64", + "timestamp": 1529612752890, + "version": "6.11.2" + }, + "thinc-6.11.2-py36hedc7406_1.tar.bz2": { + "build": "py36hedc7406_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "six", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "453a9ef6e4116d0936f6302c16eda7f7", + "name": "thinc", + "sha256": "cd2d18e7456256953afadb31627b7fbfa453d8bce6bfdd1bf9242e587dec4eee", + "size": 1846214, + "subdir": "linux-64", + "timestamp": 1531127950038, + "version": "6.11.2" + }, + "thinc-6.11.2-py37h6cfcb94_1.tar.bz2": { + "build": "py37h6cfcb94_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.7,<3.8.0a0", + "six", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "ef02a0f6b11282b32c53d27c14a8f9bb", + "name": "thinc", + "sha256": "82c2e9f95675ea2bdd33f78204165d740d8d64d388f7f6956686f6aca5a98c51", + "size": 1843860, + "subdir": "linux-64", + "timestamp": 1531127777522, + "version": "6.11.2" + }, + "thinc-6.11.2-py37hedc7406_1.tar.bz2": { + "build": "py37hedc7406_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.7,<3.8.0a0", + "six", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "1880c5c9f088e357ebf58c61057447c7", + "name": "thinc", + "sha256": "2b199c7354a73532b92c1c6201438ed8e08233dd231e962cb809ee1a5e2f3840", + "size": 1843917, + "subdir": "linux-64", + "timestamp": 1531127614323, + "version": "6.11.2" + }, + "thinc-6.12.0-py27h22eb022_0.tar.bz2": { + "build": "py27h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "b56887ad5ae6b31a6eb445a8422e1c48", + "name": "thinc", + "sha256": "529c919c7a2672a2a814948813ab638a1dd2f5573013f9e2ad75aaf35601a4ba", + "size": 1691428, + "subdir": "linux-64", + "timestamp": 1539880952726, + "version": "6.12.0" + }, + "thinc-6.12.0-py27h4989274_0.tar.bz2": { + "build": "py27h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "fb07e6ae81f58112a5fb7d6c6afe983d", + "name": "thinc", + "sha256": "94596ec12090722f9ab1065c0022bd2143abae1600eeeddd4696fb1c8d3cbbd7", + "size": 1691324, + "subdir": "linux-64", + "timestamp": 1539881171267, + "version": "6.12.0" + }, + "thinc-6.12.0-py36h22eb022_0.tar.bz2": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "99e42fe63fff4f1020430fafbd8e8219", + "name": "thinc", + "sha256": "08d403a3535e50406208eb8ab59f29945d4af3e8545b68b8d2fa7a29a934772f", + "size": 1695693, + "subdir": "linux-64", + "timestamp": 1539880980469, + "version": "6.12.0" + }, + "thinc-6.12.0-py36h4989274_0.tar.bz2": { + "build": "py36h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "4230b30b17415f603e6ddfccf93f013b", + "name": "thinc", + "sha256": "4dadcb7c955663caeb32be7d7a9a12e48a056996d3f57946476a8de707c5a8da", + "size": 1695767, + "subdir": "linux-64", + "timestamp": 1539881417875, + "version": "6.12.0" + }, + "thinc-6.12.0-py37h22eb022_0.tar.bz2": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "538b9842af321c507608525a7097341d", + "name": "thinc", + "sha256": "ddb08e09fc14105d8984eb58bb1bdbe33a649333a71ea8f8747d892de458ad0e", + "size": 1698096, + "subdir": "linux-64", + "timestamp": 1539880972975, + "version": "6.12.0" + }, + "thinc-6.12.0-py37h4989274_0.tar.bz2": { + "build": "py37h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "fff86384cda95d6d197e2db2dcb51291", + "name": "thinc", + "sha256": "41026f660eed8bafa39e30a7896053510c85a4af34ddc1ab68ce7dc2e9e0ca31", + "size": 1697260, + "subdir": "linux-64", + "timestamp": 1539881394699, + "version": "6.12.0" + }, + "thinc-6.12.1-py27h22eb022_0.tar.bz2": { + "build": "py27h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "7c6e194d6e99691e59a12925f8865e92", + "name": "thinc", + "sha256": "fc8e3382a3c178ab8b143a4b6ccbdd50c0cf5d7edf139aa4b4fb11c115d4989a", + "size": 1501211, + "subdir": "linux-64", + "timestamp": 1545123188656, + "version": "6.12.1" + }, + "thinc-6.12.1-py27h4989274_0.tar.bz2": { + "build": "py27h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "d20f529b1eebc42ea3c15373c7446677", + "name": "thinc", + "sha256": "6bab6d20aedde7d8f9839ca16a00d6e065130071552b8ebede9881d72f12a1ce", + "size": 1486303, + "subdir": "linux-64", + "timestamp": 1545123302151, + "version": "6.12.1" + }, + "thinc-6.12.1-py36h22eb022_0.tar.bz2": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "5baa9916bd7f6a31a55fc4fe92dcb9a3", + "name": "thinc", + "sha256": "68a2d3d03dca7820d04dfa04cef8c82373e5aa6a5b0b164206c3cd4707f69880", + "size": 1508533, + "subdir": "linux-64", + "timestamp": 1545123171959, + "version": "6.12.1" + }, + "thinc-6.12.1-py36h4989274_0.tar.bz2": { + "build": "py36h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "259f61d1655c2aebdcb8e31cd208dd47", + "name": "thinc", + "sha256": "ac881a2e55dc1065eb74432ddf2f9f0f83637c4f812b8bcad12bca63b03b06a1", + "size": 1515733, + "subdir": "linux-64", + "timestamp": 1545123373814, + "version": "6.12.1" + }, + "thinc-6.12.1-py37h22eb022_0.tar.bz2": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "b9b403ad8cd708fd324bf1d0f7a5b287", + "name": "thinc", + "sha256": "f305c2ec3f2b6822a26f94455e5584ac5063b225176bf7ca7852753629b5eab6", + "size": 1528328, + "subdir": "linux-64", + "timestamp": 1545123173027, + "version": "6.12.1" + }, + "thinc-6.12.1-py37h4989274_0.tar.bz2": { + "build": "py37h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "f9ebe2658f01f852802837de18c51619", + "name": "thinc", + "sha256": "7d08a36fe5ab77d06333fc1bf7d52b6f83a91e97115089999f448e0a6e0bdde1", + "size": 1519143, + "subdir": "linux-64", + "timestamp": 1545123289790, + "version": "6.12.1" + }, + "thinc-6.12.1-py38h22eb022_0.tar.bz2": { + "build": "py38h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.8,<3.9.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "441d04a6d9926c3c51013e5f9d3686ea", + "name": "thinc", + "sha256": "77ae20b9da34c622791865974d99d3a8bb8953c855f588abc836dc254812dcbd", + "size": 1546486, + "subdir": "linux-64", + "timestamp": 1574153414861, + "version": "6.12.1" + }, + "thinc-6.12.1-py38hd81dba3_0.tar.bz2": { + "build": "py38hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.8,<3.9.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "92db7667cc876fe8b02cbf73600cd108", + "name": "thinc", + "sha256": "b2003db27b1e8c7963eebcf5160c5f0e6a66b8d87ae660578554acefad44784b", + "size": 1546829, + "subdir": "linux-64", + "timestamp": 1574153322941, + "version": "6.12.1" + }, + "thinc-7.4.1-py36hfd86e86_0.tar.bz2": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.5.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.6,<3.7.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "43e8a4c917eedb75258356a8cd5deaab", + "name": "thinc", + "sha256": "f14841cd1426ae096fc5c65e5b913bc85c7514869521804427b2952a92af5104", + "size": 1726744, + "subdir": "linux-64", + "timestamp": 1594252072469, + "version": "7.4.1" + }, + "thinc-7.4.1-py37hfd86e86_0.tar.bz2": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.5.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.7,<3.8.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "89e4a15d4012b56f80edace378801c44", + "name": "thinc", + "sha256": "6b896e465e83a46172eff4a8b5dda03d529f72a1d61d11d3d004ae6a1510b974", + "size": 1713709, + "subdir": "linux-64", + "timestamp": 1594252076438, + "version": "7.4.1" + }, + "thinc-7.4.1-py38hfd86e86_0.tar.bz2": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.5.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.8,<3.9.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "cb11352fa8edc7c489033e0eb2d21ed7", + "name": "thinc", + "sha256": "1b8ca9cdfa4a7b9e9b5dae857fd690ed50dd1a9c38a2ba399f984f4063a3a364", + "size": 1717337, + "subdir": "linux-64", + "timestamp": 1594252067123, + "version": "7.4.1" + }, + "thinc-7.4.4-py36h9a67853_0.tar.bz2": { + "build": "py36h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.6,<3.7.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "797591660849cbde915f22a3a538ba8b", + "name": "thinc", + "sha256": "fc5b521c0e5cd54e61de6702694d6f9852f9d27366cbb956cb2aba92acf31e71", + "size": 968414, + "subdir": "linux-64", + "timestamp": 1607551228569, + "version": "7.4.4" + }, + "thinc-7.4.4-py37h9a67853_0.tar.bz2": { + "build": "py37h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.7,<3.8.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "9362f7cd599234e2da5a93d515cdd6d8", + "name": "thinc", + "sha256": "d6317a79ae52ddac9d3702aed4bc53ae0d05c60b9cb3cea96ab89547f38e2e1e", + "size": 955338, + "subdir": "linux-64", + "timestamp": 1607551233317, + "version": "7.4.4" + }, + "thinc-7.4.4-py38h9a67853_0.tar.bz2": { + "build": "py38h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.8,<3.9.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "2e28dde1593770129f749a92cbba8172", + "name": "thinc", + "sha256": "4885999e7a8be7b0cd2860a79f528f44a9bd6c11668b5f42900fa5654beb6bd1", + "size": 999839, + "subdir": "linux-64", + "timestamp": 1607551244747, + "version": "7.4.4" + }, + "thinc-7.4.5-py36h9a67853_0.tar.bz2": { + "build": "py36h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.6,<3.7.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "226699e1da14dff78e45aba36a55a449", + "name": "thinc", + "sha256": "a8642e4f62b5d103b7245a6f0987ffc1abcb20bf1a0637de8784790b9136a3a7", + "size": 947421, + "subdir": "linux-64", + "timestamp": 1607710276168, + "version": "7.4.5" + }, + "thinc-7.4.5-py37h9a67853_0.tar.bz2": { + "build": "py37h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.7,<3.8.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "7f14476072ebe6f49ae8e6eb16856825", + "name": "thinc", + "sha256": "d8d3119bfc5c3dfb6083f5d868dec869738e5fb2e7a26d97002c03580d1ed011", + "size": 961393, + "subdir": "linux-64", + "timestamp": 1607710260377, + "version": "7.4.5" + }, + "thinc-7.4.5-py38h9a67853_0.tar.bz2": { + "build": "py38h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.8,<3.9.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "10b7e7bd1b80ce8e643769a68e05a440", + "name": "thinc", + "sha256": "24827d13d8905142edc15975a8c564843dd9e841e70523f04ad9fedacbe52e96", + "size": 987943, + "subdir": "linux-64", + "timestamp": 1607710277618, + "version": "7.4.5" + }, + "thinc-7.4.5-py39h9a67853_0.tar.bz2": { + "build": "py39h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.9,<3.10.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "5a2529591baaea831c669c5dd26bf232", + "name": "thinc", + "sha256": "ed7920b4b1685d0991e68bd6aba1ae24c730ec2f31c608acb438a27c55f7eafa", + "size": 1004590, + "subdir": "linux-64", + "timestamp": 1608240819666, + "version": "7.4.5" + }, + "thinc-8.0.1-py36h9a67853_0.tar.bz2": { + "build": "py36h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.2.0,<3.0.0", + "contextvars >=2.4,<3", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "dataclasses >=0.6,<1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.1,<1.8.0", + "python >=3.6,<3.7.0a0", + "srsly >=2.0.0,<3.0.0", + "typing_extensions", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "42c6c7e8121376d7b798285d8447b14f", + "name": "thinc", + "sha256": "c1202a40aff05859cf082993c75cec827b89f000792334c7b5a8e6478a5a500a", + "size": 1009931, + "subdir": "linux-64", + "timestamp": 1611697229433, + "version": "8.0.1" + }, + "thinc-8.0.1-py37h9a67853_0.tar.bz2": { + "build": "py37h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.2.0,<3.0.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.1,<1.8.0", + "python >=3.7,<3.8.0a0", + "srsly >=2.0.0,<3.0.0", + "typing_extensions", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "30209c0d25604ea96215aefd57c64204", + "name": "thinc", + "sha256": "2bf3ca7842ab27cc3306f8645d7282a599a77743d68c3d1664758dfaff92d6ab", + "size": 1015338, + "subdir": "linux-64", + "timestamp": 1611697184949, + "version": "8.0.1" + }, + "thinc-8.0.1-py38h9a67853_0.tar.bz2": { + "build": "py38h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.2.0,<3.0.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.1,<1.8.0", + "python >=3.8,<3.9.0a0", + "srsly >=2.0.0,<3.0.0", + "typing_extensions", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "ce3479558ea3b0b84e343c50ccf8a569", + "name": "thinc", + "sha256": "3ad5b64ae9b0ad9d27bb82e6ae197675b4c2440feed36a3f83c07bb6f082caf5", + "size": 1011226, + "subdir": "linux-64", + "timestamp": 1611697198648, + "version": "8.0.1" + }, + "thinc-8.0.13-py37hae6d005_0.tar.bz2": { + "build": "py37hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.4,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1,<1.9.0", + "python >=3.7,<3.8.0a0", + "srsly >=2.4.0,<3.0.0", + "typing_extensions >=3.7.4.1,<4.0.0.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5eeb6ca467000fb534e15daccff3707f", + "name": "thinc", + "sha256": "4cdd8163229967b5d6567eb5fa8712a968537e3ba134ebdc143b11a21400f544", + "size": 691248, + "subdir": "linux-64", + "timestamp": 1636635356546, + "version": "8.0.13" + }, + "thinc-8.0.13-py38hae6d005_0.tar.bz2": { + "build": "py38hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.4,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1,<1.9.0", + "python >=3.8,<3.9.0a0", + "srsly >=2.4.0,<3.0.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "26dba06095af967c7b53db0cc271ea07", + "name": "thinc", + "sha256": "c26e357a1b232d9c9467889c430eeb58e7fa5c8f478f8c0a16b485cdc5c653cd", + "size": 720517, + "subdir": "linux-64", + "timestamp": 1636623029001, + "version": "8.0.13" + }, + "thinc-8.0.13-py39hae6d005_0.tar.bz2": { + "build": "py39hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.4,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1,<1.9.0", + "python >=3.9,<3.10.0a0", + "srsly >=2.4.0,<3.0.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d5176508da4e9ea885e28d819f85580", + "name": "thinc", + "sha256": "27af9b48108e23159add26b4d9ea5228d008d0a6f81f3832940627d673dcb967", + "size": 713024, + "subdir": "linux-64", + "timestamp": 1636635343146, + "version": "8.0.13" + }, + "thinc-8.0.15-py310h2571103_0.tar.bz2": { + "build": "py310h2571103_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.4,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=1.0.2,<1.1.0", + "numpy >=1.21.5,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.10,<3.11.0a0", + "setuptools", + "srsly >=2.4.0,<3.0.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "833d123687af428181b70d443d3a824d", + "name": "thinc", + "sha256": "c791eb73bc59c9e17ed2aab499c6cd58e781006014854dc7d2643d5cb531e86a", + "size": 1982741, + "subdir": "linux-64", + "timestamp": 1651591825368, + "version": "8.0.15" + }, + "thinc-8.0.15-py311heed92f4_0.tar.bz2": { + "build": "py311heed92f4_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.4,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "murmurhash >=1.0.2,<1.1.0", + "numpy >=1.22.3,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.11,<3.12.0a0", + "setuptools", + "srsly >=2.4.0,<3.0.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "938928d2e33351fb2ef6cb83d4cb7a78", + "name": "thinc", + "sha256": "ed5011cc6ad4e03859894a57d7fd9a43b1b40566c14aa75b5a33f6836dc5873a", + "size": 923388, + "subdir": "linux-64", + "timestamp": 1676846005899, + "version": "8.0.15" + }, + "thinc-8.0.15-py37hae6d005_0.tar.bz2": { + "build": "py37hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.4,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=1.0.2,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.7,<3.8.0a0", + "setuptools", + "srsly >=2.4.0,<3.0.0", + "typing_extensions >=3.7.4.1,<4.0.0.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d4afd65c5c7d156840fd99e7e8249a3c", + "name": "thinc", + "sha256": "e3c87148946152ad59f7e6238aecc9cdb6ca99e41e1edbe03a85a5789f131933", + "size": 731025, + "subdir": "linux-64", + "timestamp": 1651591552518, + "version": "8.0.15" + }, + "thinc-8.0.15-py38hae6d005_0.tar.bz2": { + "build": "py38hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.4,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=1.0.2,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.8,<3.9.0a0", + "setuptools", + "srsly >=2.4.0,<3.0.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a5553dfa665336bcb26783e97fef6d32", + "name": "thinc", + "sha256": "36380da91892edcc14dff408a9123be1fe7c01c79d7aa2980c8dc48a11e4818f", + "size": 747440, + "subdir": "linux-64", + "timestamp": 1651591638933, + "version": "8.0.15" + }, + "thinc-8.0.15-py39hae6d005_0.tar.bz2": { + "build": "py39hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.4,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=1.0.2,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.9,<3.10.0a0", + "setuptools", + "srsly >=2.4.0,<3.0.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bde196d8484e9a54bfe007042a181bf4", + "name": "thinc", + "sha256": "936d8e2987627c55f896b578943b019b6d17bd2f78bc8260d5bcc525310192d7", + "size": 750321, + "subdir": "linux-64", + "timestamp": 1651591726222, + "version": "8.0.15" + }, + "thrift-0.11.0-py27hf484d3e_0.tar.bz2": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "c1fe0d2996237080b8871e57d3db4c53", + "name": "thrift", + "sha256": "3bb5838494b249624b4a29af391aea05bb9f5651ac3138fdbed610f6a534804b", + "size": 102706, + "subdir": "linux-64", + "timestamp": 1516905017272, + "version": "0.11.0" + }, + "thrift-0.11.0-py35hf484d3e_0.tar.bz2": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "e37ba94594fea42a42fa739ac9c32971", + "name": "thrift", + "sha256": "c49e7bd262c04c8238cf1bfbc5abd2cbf71ae0d641ba8b907594019fbb209b1e", + "size": 107901, + "subdir": "linux-64", + "timestamp": 1516905032012, + "version": "0.11.0" + }, + "thrift-0.11.0-py36h295c915_0.tar.bz2": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "a8b89a44e8c00de9cb94454a232d6faf", + "name": "thrift", + "sha256": "938422e31c9f926efaedfadb1d1353ac5a6cc40af800284f8ee7af689fedb859", + "size": 109729, + "subdir": "linux-64", + "timestamp": 1632730693915, + "version": "0.11.0" + }, + "thrift-0.11.0-py36hf484d3e_0.tar.bz2": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "882ed350778c9a7945e38eeee50088cb", + "name": "thrift", + "sha256": "64721376370d5689f0146ac79dc51bfd56812c8fe3dfce9219d4ef563831dd11", + "size": 107547, + "subdir": "linux-64", + "timestamp": 1516905032129, + "version": "0.11.0" + }, + "thrift-0.11.0-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "04c96e40d11f082f3b69b1e5bdeeb154", + "name": "thrift", + "sha256": "4a830cdacb6c2370131e4d67663178cc345fdf8a633e6780aa45adb52292ecc3", + "size": 109777, + "subdir": "linux-64", + "timestamp": 1632720323493, + "version": "0.11.0" + }, + "thrift-0.11.0-py37hf484d3e_0.tar.bz2": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "868ee20d78c49ea5725c8778dd0d0aa6", + "name": "thrift", + "sha256": "65f67109b6c56753c727e7a3143a8407210ef68b46844968afe1eb757dd1c0e0", + "size": 107552, + "subdir": "linux-64", + "timestamp": 1530876507259, + "version": "0.11.0" + }, + "thrift-0.11.0-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "ed84f806d88b826e0728457249bbf647", + "name": "thrift", + "sha256": "c60479c88d49fa49679cbc1a295288e19ef4b31bb4743628147cd4c158b356b4", + "size": 111006, + "subdir": "linux-64", + "timestamp": 1632720321664, + "version": "0.11.0" + }, + "thrift-0.11.0-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "fc803a734dd86bdcd0ffc233ae86ce1c", + "name": "thrift", + "sha256": "bb5ff9667be68c989ba7b0ac60fd8a33f8b62a11861730bbb49b7b6c8170401d", + "size": 116941, + "subdir": "linux-64", + "timestamp": 1573554770523, + "version": "0.11.0" + }, + "thrift-0.11.0-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "0f2f312c35f0b03d5ae2c42459ed0234", + "name": "thrift", + "sha256": "579a6cad72c4846bf4a1ee0c3c91dda9a14af9703041c1f1ff1458fa3ed2bc88", + "size": 110949, + "subdir": "linux-64", + "timestamp": 1632730671576, + "version": "0.11.0" + }, + "thrift-0.13.0-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "a366e88628840a3254ea2178f92c284d", + "name": "thrift", + "sha256": "e41003aa55e84fcbc6d0cc8d63b7b3be3211e864dc3c0fe042445179cbffaef1", + "size": 300303, + "subdir": "linux-64", + "timestamp": 1640795230941, + "version": "0.13.0" + }, + "thrift-0.13.0-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "6dafb08dfd61716739bca5bf57b2b0f3", + "name": "thrift", + "sha256": "c2c09c349179a6b7c6554eeee285c5a8e78ca99fd0bc276223f2c4af9970f366", + "size": 120073, + "subdir": "linux-64", + "timestamp": 1613159419918, + "version": "0.13.0" + }, + "thrift-0.13.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "41e1b061ff46f0e5cd724a420feba1a3", + "name": "thrift", + "sha256": "db5a8e88339752c9d69670f2dd6140849299e62dc2bf0f58160af3b2745910af", + "size": 120098, + "subdir": "linux-64", + "timestamp": 1582543898912, + "version": "0.13.0" + }, + "thrift-0.13.0-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "c1a227c3636d8579cf2deac8a4195082", + "name": "thrift", + "sha256": "ce3ea716bf48b74f08fb317d4c5d38601b9199231fc533b43d024b59787150c1", + "size": 120226, + "subdir": "linux-64", + "timestamp": 1613159419791, + "version": "0.13.0" + }, + "thrift-0.13.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "caf5f521a3c30f46674faa1d6d8b6acb", + "name": "thrift", + "sha256": "24b5921307b882c603e5bb2ce830b5c75578db98db5372273ec5e74e9ac631ff", + "size": 120042, + "subdir": "linux-64", + "timestamp": 1582543855328, + "version": "0.13.0" + }, + "thrift-0.13.0-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "cd814d8591a3f82518949b1f890cf0a7", + "name": "thrift", + "sha256": "183cbe54433ba0aee2e50b0225494474112de9010d4e27658a7b886b2dbe9d7e", + "size": 121517, + "subdir": "linux-64", + "timestamp": 1613159735172, + "version": "0.13.0" + }, + "thrift-0.13.0-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "c27d8bc063b07e9d77d021c93525747f", + "name": "thrift", + "sha256": "74f91190aac0dd61160bfac7dd2104993a51db5ee65d7b55ad456e025f2f7213", + "size": 121402, + "subdir": "linux-64", + "timestamp": 1582543932751, + "version": "0.13.0" + }, + "thrift-0.13.0-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "daa887a52b52c27785799cc785f6a809", + "name": "thrift", + "sha256": "a40492c7e317861dcc68c0e8d1f9c7f8d67c061325a53ecca1ad3f8edf829a1f", + "size": 121388, + "subdir": "linux-64", + "timestamp": 1613159282027, + "version": "0.13.0" + }, + "thrift-0.15.0-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "six >=1.7.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e6eb0379bcbcd31e30ea97dde4ea9b72", + "name": "thrift", + "sha256": "1f952219cfe911d47527326cf4d35d0ffbe8304ed080bc1878de30f022d4aa6d", + "size": 301242, + "subdir": "linux-64", + "timestamp": 1655212032799, + "version": "0.15.0" + }, + "thrift-0.15.0-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "six >=1.7.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "eab3ab80d7f33363b40183ea9bd9e43f", + "name": "thrift", + "sha256": "9793db5299c0e85623fda68473ad20636f0801802e9302d2091e1f6a47decc67", + "size": 119278, + "subdir": "linux-64", + "timestamp": 1655211961623, + "version": "0.15.0" + }, + "thrift-0.15.0-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "six >=1.7.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5178a05985a9509c854eadeb7f21be15", + "name": "thrift", + "sha256": "5c3ebf7160b0585708795b03934ed7e0034aacb0e12491627b91a946e9bc3323", + "size": 120509, + "subdir": "linux-64", + "timestamp": 1655211991146, + "version": "0.15.0" + }, + "thrift-0.15.0-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "six >=1.7.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "45356ff4ff2571a9369653938b7cc193", + "name": "thrift", + "sha256": "c449076780990b5c5c04db10bb7bc6182ebadcbd1273911a60f2d0f452dbab5f", + "size": 120585, + "subdir": "linux-64", + "timestamp": 1655211929180, + "version": "0.15.0" + }, + "thrift-0.17.0-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "six >=1.7.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5eb9ea8dd31770c498e8de48e0b992c0", + "name": "thrift", + "sha256": "0e70d1e9c7ad271df4e0680750946bf090baf9695cbd6b8594ec158e799fb7c6", + "size": 130366, + "subdir": "linux-64", + "timestamp": 1666296565801, + "version": "0.17.0" + }, + "thrift-0.17.0-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "six >=1.7.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "159fc89d25c655289be6027c13ff3689", + "name": "thrift", + "sha256": "e62c16763f9bc5c7bbbcf0ae6e4b6ee9cf6fc55b80a306a2fdfc753a65d4a72a", + "size": 162665, + "subdir": "linux-64", + "timestamp": 1676846029404, + "version": "0.17.0" + }, + "thrift-0.17.0-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "six >=1.7.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "bea503e381a2e983440d3890dfcb5d41", + "name": "thrift", + "sha256": "a297801bffce148b09c745382690c9a8ed090a6f7e04bb2a39e6bcf7f4b29cdb", + "size": 128650, + "subdir": "linux-64", + "timestamp": 1666296596771, + "version": "0.17.0" + }, + "thrift-0.17.0-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "six >=1.7.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "da914586bf315379c27fa9dca6f3b337", + "name": "thrift", + "sha256": "7d67b37f3ae90d50c18c837292445fdda1d31d79c4663bcd1e93a8b1c1e1edb3", + "size": 129600, + "subdir": "linux-64", + "timestamp": 1666296532746, + "version": "0.17.0" + }, + "thrift-0.17.0-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "six >=1.7.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "22475a3e47ac882de71cfd80c3771678", + "name": "thrift", + "sha256": "49b380af9a94648f228a38bfdb726f8047cf13cda868018ec2f5eaa410c6d626", + "size": 129134, + "subdir": "linux-64", + "timestamp": 1666296627327, + "version": "0.17.0" + }, + "thrift-0.9.3-py27h14c3975_1.tar.bz2": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "46d8fcf5b19e144bc72809ca1bcd47df", + "name": "thrift", + "sha256": "57677b46d7c2b5428b781ec3fd426934567a4357c2d8d4c6d4ad8b7f4ec458e9", + "size": 76307, + "subdir": "linux-64", + "timestamp": 1531092229635, + "version": "0.9.3" + }, + "thrift-compiler-0.13.0-hfb8234f_6.tar.bz2": { + "build": "hfb8234f_6", + "build_number": 6, + "depends": [ + "libevent", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libthrift 0.13.0 hfb8234f_6", + "openssl", + "zlib" + ], + "license": "Apache-2.0", + "md5": "6fdaea31dad1623c9768e35043bf7605", + "name": "thrift-compiler", + "sha256": "31359b1f48ea315f2caab262bead1fcedf1ac45c090d0395feed60dd7edc26c1", + "size": 16101124, + "subdir": "linux-64", + "timestamp": 1612012824493, + "version": "0.13.0" + }, + "thrift-compiler-0.14.2-hcc01f38_0.tar.bz2": { + "build": "hcc01f38_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libthrift 0.14.2 hcc01f38_0" + ], + "license": "Apache-2.0", + "md5": "93ac28d273777101cb35ef2d1cfa6dba", + "name": "thrift-compiler", + "sha256": "f7acb759adf8d6a54c6f547d58d0b548a41d64fe4be12d1530ec94510a8907c7", + "size": 15869957, + "subdir": "linux-64", + "timestamp": 1632847292687, + "version": "0.14.2" + }, + "thrift-compiler-0.15.0-hcc01f38_0.tar.bz2": { + "build": "hcc01f38_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libthrift 0.15.0 hcc01f38_0" + ], + "license": "Apache-2.0", + "md5": "416980a746b4b7e0a2c70b360c90f143", + "name": "thrift-compiler", + "sha256": "29d9a3b563c81664ebb5433df0e14166b8f6257ad92ef38354b89b441a39b961", + "size": 15204960, + "subdir": "linux-64", + "timestamp": 1631679373754, + "version": "0.15.0" + }, + "thrift-cpp-0.11.0-h02b749d_3.tar.bz2": { + "build": "h02b749d_3", + "build_number": 3, + "depends": [ + "libevent >=2.1.8,<2.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "md5": "bed12c4738409b565ec3630130ae9293", + "name": "thrift-cpp", + "sha256": "79ef0fabee030971d9bfa4d6cb3eec9def3090351fcc3fa50d9ea5c4785a772f", + "size": 2422436, + "subdir": "linux-64", + "timestamp": 1540475166474, + "version": "0.11.0" + }, + "thrift-cpp-0.11.0-hc04171f_3.tar.bz2": { + "build": "hc04171f_3", + "build_number": 3, + "depends": [ + "libevent >=2.1.8,<2.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "md5": "75bf9d0d706b6ffa757a9bb195f9d71b", + "name": "thrift-cpp", + "sha256": "0424e6f4fe9cd0798e973b7fa14ebe18f0f4c7310d1998ec0c731bffe0f2fd9b", + "size": 2399145, + "subdir": "linux-64", + "timestamp": 1529362421471, + "version": "0.11.0" + }, + "thrift-cpp-0.13.0-h06a4308_6.tar.bz2": { + "build": "h06a4308_6", + "build_number": 6, + "depends": [ + "libthrift 0.13.0 hfb8234f_6", + "thrift-compiler 0.13.0 hfb8234f_6" + ], + "license": "Apache-2.0", + "md5": "6c5e7da2ac69f5e6f00ae17ae83535ec", + "name": "thrift-cpp", + "sha256": "441303501e753b7f7ba81b2305295544e07db374aa3ab6df32786e8a5eca93f5", + "size": 13898, + "subdir": "linux-64", + "timestamp": 1612012840379, + "version": "0.13.0" + }, + "thrift-cpp-0.13.0-hf7127d7_3.tar.bz2": { + "build": "hf7127d7_3", + "build_number": 3, + "constrains": [ + "boost-cpp >=1.67.0,<1.68.0a0" + ], + "depends": [ + "libevent >=2.1.8,<2.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "md5": "5e3efc482dc3445861bc747352edc37d", + "name": "thrift-cpp", + "sha256": "65f359c405ab9169731e4cf66fe3c3f3772a2ea557d5ae3da15f8b65364dfa86", + "size": 19490255, + "subdir": "linux-64", + "timestamp": 1599760830466, + "version": "0.13.0" + }, + "thrift-cpp-0.14.2-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libthrift 0.14.2 hcc01f38_0", + "thrift-compiler 0.14.2 hcc01f38_0" + ], + "license": "Apache-2.0", + "md5": "6441b0f55875b445cdd1e2277f2e89c5", + "name": "thrift-cpp", + "sha256": "7a2d9bb9601283d6301b1ef987628a62e81cc27f5c2ae4a20cc4f46042ef57bc", + "size": 14798, + "subdir": "linux-64", + "timestamp": 1632847309667, + "version": "0.14.2" + }, + "thrift-cpp-0.15.0-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libthrift 0.15.0 hcc01f38_0", + "thrift-compiler 0.15.0 hcc01f38_0" + ], + "license": "Apache-2.0", + "md5": "a63c0efc4f85b9d79941e3cdcc955b23", + "name": "thrift-cpp", + "sha256": "22635f0afcf80a6c2e0855e054f8716bfea39b4fbb64bd723827fcae917fe053", + "size": 14850, + "subdir": "linux-64", + "timestamp": 1631679389201, + "version": "0.15.0" + }, + "thrift_sasl-0.3.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "sasl >=0.2.1", + "thrift" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7a3027da8a29bd857c053090f2707a82", + "name": "thrift_sasl", + "sha256": "39c937c9a172dc0f42081f43f80fe5997a9cd5bd9329b2b0c61f62d8be8b054f", + "size": 8748, + "subdir": "linux-64", + "timestamp": 1530916984728, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py27h1c006f6_1.tar.bz2": { + "build": "py27h1c006f6_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "sasl >=0.2.1", + "thrift" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "25fd40727d7872dcf615ecdf676b5f9a", + "name": "thrift_sasl", + "sha256": "c4a0ea0ea8c9f71f70326a6a9a96ff4cb31a9e23d2a44944bb9ff6027f69de4d", + "size": 9098, + "subdir": "linux-64", + "timestamp": 1512157933386, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py35h595cfc9_1.tar.bz2": { + "build": "py35h595cfc9_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e13ef2eeb825be33f144136304d04a97", + "name": "thrift_sasl", + "sha256": "aad187e76af85a282fd7026867d3763c8c4e7211c69e1bfe6084c69bfcac07c2", + "size": 9268, + "subdir": "linux-64", + "timestamp": 1512157933622, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0d83179a41a788da16fb0b218d383764", + "name": "thrift_sasl", + "sha256": "3301623b0f89e5cb67168759361b6759a8943a7f1bbd4a73b681cefa2eb1903c", + "size": 8832, + "subdir": "linux-64", + "timestamp": 1530917014954, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "da8a2c6835744feeea4e87bba73a78f3", + "name": "thrift_sasl", + "sha256": "1b9595f67eb0e9d3920f563a21860228b7c807df7e9f24203ce9d3f5619feeb5", + "size": 10211, + "subdir": "linux-64", + "timestamp": 1632738104902, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py36hc03b066_1.tar.bz2": { + "build": "py36hc03b066_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f472d8d91e56aaf6aaa38c93a2d5133f", + "name": "thrift_sasl", + "sha256": "d4b6a8bedce78e577f1f39977045253c3fdcc4a642b4041b2729e3536e6f275e", + "size": 9212, + "subdir": "linux-64", + "timestamp": 1512157946073, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "61b255e177f8b988a4f61c4d2c2c857e", + "name": "thrift_sasl", + "sha256": "593ac3bd17e87a27176d5f39977e6950f6e8be90980bb59a82082e456b8e97b0", + "size": 8851, + "subdir": "linux-64", + "timestamp": 1530917044111, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c303dfa7473418592591ac0d68eef61e", + "name": "thrift_sasl", + "sha256": "27326935eb59db18d797be00be111ea2289db903555a3aca333017d41c62e7c8", + "size": 10222, + "subdir": "linux-64", + "timestamp": 1632748441752, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "511b344950bd89d493d54e9cdd691838", + "name": "thrift_sasl", + "sha256": "2126458714ac6e75d6b690868e141955e4b9d5983fba5e153030123abe161f56", + "size": 9326, + "subdir": "linux-64", + "timestamp": 1574153434886, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1f808b9240b9a22c48fbee15debe7f51", + "name": "thrift_sasl", + "sha256": "74882261fdaa2527350c4af3ccb52ecbf8ee85d40e45d9ffc2870d130ee6c666", + "size": 10239, + "subdir": "linux-64", + "timestamp": 1632748089627, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9bdde0a8fb6d90700072a140d10e663f", + "name": "thrift_sasl", + "sha256": "872401a2371345396dc00c3bf0b2d113eac65a6bb712abfc651fd4592c42a07e", + "size": 10242, + "subdir": "linux-64", + "timestamp": 1632748443209, + "version": "0.3.0" + }, + "thrift_sasl-0.4.2-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "sasl >=0.2.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0e224b48287e2707fc4a484f74f53809", + "name": "thrift_sasl", + "sha256": "4938d48e0d446d264275e40138358ab81c2fe3f6007ef4fdd3f4b04c52cfe49d", + "size": 9339, + "subdir": "linux-64", + "timestamp": 1640811183520, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5fe104936a204389612a40c606e3d916", + "name": "thrift_sasl", + "sha256": "cf4110936f19138685a5f331bbdfe9b6f8df2733e5f09bc83f9408633624f66b", + "size": 9309, + "subdir": "linux-64", + "timestamp": 1659877565089, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py311h06a4308_2.tar.bz2": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2f68c528e9271c1b9e06bee17c5865dc", + "name": "thrift_sasl", + "sha256": "201ef05e3bb2732ffcf1757e4c5e72e4d5590ee6b7f2e2067ccbc00536357c87", + "size": 11364, + "subdir": "linux-64", + "timestamp": 1676862996470, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "46395745c194013d5de32e81e3c794a0", + "name": "thrift_sasl", + "sha256": "7b7ac155dad012bfe770496ecced31e29e2934f5462c191d22e24e318b6e7e80", + "size": 9379, + "subdir": "linux-64", + "timestamp": 1600708663695, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "49d2b4298f44d0d71637f0db9a5be458", + "name": "thrift_sasl", + "sha256": "b05aeae1b23935f11a278c91e8fe715fb039453ad73a60e37187935694096265", + "size": 10514, + "subdir": "linux-64", + "timestamp": 1632736749606, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e2b55200151f5c8959ffc68e92bec2f2", + "name": "thrift_sasl", + "sha256": "78b43a683577c8244fe3bd76968246b2170e6d9f11e6f50da7f5ac6e3ac1f8bf", + "size": 9381, + "subdir": "linux-64", + "timestamp": 1600708661315, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "455c940acfd351e592cbf3783cba5e2d", + "name": "thrift_sasl", + "sha256": "245729b418e4bea479fa8cd9b93f7ead0784d9db1e69bcd1a8f15f2811e87683", + "size": 10536, + "subdir": "linux-64", + "timestamp": 1632736731976, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "154027a3431c22843cda35b31ca5cd62", + "name": "thrift_sasl", + "sha256": "a837ab2594d04d99442602d7d6921493cbabb8baacaacad76e997d0b2f569aa7", + "size": 9246, + "subdir": "linux-64", + "timestamp": 1659877529352, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "da5a16af97a3903b5e46318440d53f0f", + "name": "thrift_sasl", + "sha256": "a94dcbf061ba3a321f633e2733ad7b70cdf2958904fd74c729bc3ab9a5e5d4db", + "size": 9396, + "subdir": "linux-64", + "timestamp": 1600708640549, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6a840f89a8cefadb661f4d063efe6512", + "name": "thrift_sasl", + "sha256": "37a8d841eb2959342f7d8f733465e6ee0a5d7da2637faf6495247217cbc18c91", + "size": 10543, + "subdir": "linux-64", + "timestamp": 1632726375419, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "af681d50bd6ed15118e28aed24ec1ada", + "name": "thrift_sasl", + "sha256": "c16c4790f147c70b90d59b43910ff5e0e2463e640730e880e9c6c9a59fd742b4", + "size": 9233, + "subdir": "linux-64", + "timestamp": 1659877587470, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "743d676f2ea3a608d17faf265a491953", + "name": "thrift_sasl", + "sha256": "023b8b395c2ef967cf5ecb57b678c926e9d8c9db8bb0c486a9a4ad2271e5a0db", + "size": 10555, + "subdir": "linux-64", + "timestamp": 1632735864754, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "01218adcc6335edb5f2a1d6014a9670c", + "name": "thrift_sasl", + "sha256": "8f531c2d4e5f5f608e98b72c92b692d4f771bde2acb10e6b6009390480ae79dc", + "size": 9225, + "subdir": "linux-64", + "timestamp": 1659877503951, + "version": "0.4.2" + }, + "thriftpy-0.3.9-py27h14c3975_1.tar.bz2": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "ply >=3.4,<4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ddb216c166d47280b4475de0e5ee7bd", + "name": "thriftpy", + "sha256": "c7065323443e4def9e90f785b7faeddfbf0f48f94f48395981f4835d9325cd65", + "size": 204650, + "subdir": "linux-64", + "timestamp": 1522783665107, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py27h14c3975_2.tar.bz2": { + "build": "py27h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "ply >=3.4,<4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60ab53256ca25b3e334e7606cda898c9", + "name": "thriftpy", + "sha256": "62f46d9e3f17c332736ed630b2ea95d368d54823448cc2b99ee62c470dd32410", + "size": 204347, + "subdir": "linux-64", + "timestamp": 1530893336549, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py310h7f8727e_2.tar.bz2": { + "build": "py310h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "ply >=3.4,<4.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4dfa739c72e0d522fca0ec7b590b1105", + "name": "thriftpy", + "sha256": "bb9e30ae030e5747af902b16f7376678e717d483cc5edada1789552e950474ca", + "size": 664712, + "subdir": "linux-64", + "timestamp": 1640811216509, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py35h14c3975_1.tar.bz2": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "ply >=3.4,<4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1791d15c771896d6e670642e4a05d104", + "name": "thriftpy", + "sha256": "31d3622ad9667ea104ddbb7a71ad06523fcc5f9a726b8598878fbb25c60eda04", + "size": 211461, + "subdir": "linux-64", + "timestamp": 1522783982496, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py36h14c3975_1.tar.bz2": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "ply >=3.4,<4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87d68b27eda05305c7cb6dcccae14af6", + "name": "thriftpy", + "sha256": "6027161e6c17be3ed4fb1ccc22615d5bf8091c26ab6f06dd78ab69ff5450ed9a", + "size": 212274, + "subdir": "linux-64", + "timestamp": 1522783982857, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py36h14c3975_2.tar.bz2": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "ply >=3.4,<4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60a485dfb356c7fbd0f84a8ea8922c6d", + "name": "thriftpy", + "sha256": "fad87354364dbe190e45374d19ce178fa1a05a136470d73203c76127be8f147c", + "size": 212227, + "subdir": "linux-64", + "timestamp": 1530893293779, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py36h27cfd23_2.tar.bz2": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c7f9387dcd5eeb98226c7a0b2b3f4c1", + "name": "thriftpy", + "sha256": "cda0c6c5889d55c2834b8050870792af54575a1c4bcf2a3c1c81d827fa171e6b", + "size": 199957, + "subdir": "linux-64", + "timestamp": 1613383673645, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py36h7f8727e_2.tar.bz2": { + "build": "py36h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "ply >=3.4,<4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02c1c7931da71c853c44e2a76cea9ec4", + "name": "thriftpy", + "sha256": "c5cb8700badce75eb1bb6b220b7ef1c8ec982a475cec0bdd518a123acdece647", + "size": 201148, + "subdir": "linux-64", + "timestamp": 1632730393551, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py37h14c3975_2.tar.bz2": { + "build": "py37h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "ply >=3.4,<4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "144025163cdf2cf6008deaddc13f867d", + "name": "thriftpy", + "sha256": "32da112a5a693e4343c99ea0618ce8c3db69fcb226c2a4dac8056421e46ec1be", + "size": 212271, + "subdir": "linux-64", + "timestamp": 1530893249844, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py37h27cfd23_2.tar.bz2": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0ef7abb68b6acf8ed80a46a21f6690c", + "name": "thriftpy", + "sha256": "b03f6039b84e15da22ae544766ea2baccd168fab25c8f265ed6c02371b7b1cf2", + "size": 199629, + "subdir": "linux-64", + "timestamp": 1613383673072, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py37h7f8727e_2.tar.bz2": { + "build": "py37h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "ply >=3.4,<4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6eb8fb0ed94e5f736e907479c7be89fb", + "name": "thriftpy", + "sha256": "3fff8a1c239600474acc4e95cd31a1990c5cdd8728a2fb4e9f77eb5f155b783c", + "size": 201241, + "subdir": "linux-64", + "timestamp": 1632730678400, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py38h27cfd23_2.tar.bz2": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f616f5fba791cbd95c4f112c5de70ca", + "name": "thriftpy", + "sha256": "9d57732a5ca7c6c2f16ee8eaa7f5ac7c163f69e844c85596a06cbf62ad54b88e", + "size": 206894, + "subdir": "linux-64", + "timestamp": 1613383689536, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py38h7b6447c_2.tar.bz2": { + "build": "py38h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9993e203913a8ece644e565a1cba4f0f", + "name": "thriftpy", + "sha256": "65ed380d4a1b821a36ae5f0125dc9691918a5a852d3678ffcf9c6415a6085b22", + "size": 217418, + "subdir": "linux-64", + "timestamp": 1573554803884, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py38h7f8727e_2.tar.bz2": { + "build": "py38h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "ply >=3.4,<4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8e5034669d159c3207c3e6586d71740", + "name": "thriftpy", + "sha256": "fcc06e739191ec6440f5ab02facb9222f2ea4d2a25565068657ef7165ad33d0e", + "size": 207984, + "subdir": "linux-64", + "timestamp": 1632730675043, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py39h7f8727e_2.tar.bz2": { + "build": "py39h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "ply >=3.4,<4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7d6cdedb6f031173eedcda04b993090f", + "name": "thriftpy", + "sha256": "4cb73ac498a2afa4177230c7609ecdb3db821b7ee822566a68fede255ce2bf66", + "size": 206935, + "subdir": "linux-64", + "timestamp": 1632730667964, + "version": "0.3.9" + }, + "thriftpy2-0.4.12-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7a506364a6b07ae066d3ce9f6b343d80", + "name": "thriftpy2", + "sha256": "d337355b61537306e0725da0e0b47edcd0f76a3b0d2cbe3d666344749a0911c1", + "size": 371111, + "subdir": "linux-64", + "timestamp": 1606158343671, + "version": "0.4.12" + }, + "thriftpy2-0.4.12-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1610877aece4c31f7df803cdcc839ba", + "name": "thriftpy2", + "sha256": "a75ac9c8cd1d1323a93c5d09441fd3daad89d632633edc3c9f345afd43743af9", + "size": 378689, + "subdir": "linux-64", + "timestamp": 1606158333836, + "version": "0.4.12" + }, + "thriftpy2-0.4.12-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3563dcaa0da912ea0e93038d01a671e7", + "name": "thriftpy2", + "sha256": "a749ec10efdca41ae5e67db7a69ce9f26b36bd0c5234451cff132b2b731e14a9", + "size": 376239, + "subdir": "linux-64", + "timestamp": 1606158357471, + "version": "0.4.12" + }, + "thriftpy2-0.4.14-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "ply >=3.4,<4.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b274d0752151fd82e5db2a26a3c4d7ec", + "name": "thriftpy2", + "sha256": "a50cd6d0ce03c4080e4dcfdd9d914b93ac19461f8a43e48b033216f00fe9ed6d", + "size": 866370, + "subdir": "linux-64", + "timestamp": 1640811249277, + "version": "0.4.14" + }, + "thriftpy2-0.4.14-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "558c8207d2e91a892c69a5baa5dcf754", + "name": "thriftpy2", + "sha256": "2ef1a83cf9e43977e379c2a27f76c70bff2e183fd4368174e7ff9e489dd6625f", + "size": 362156, + "subdir": "linux-64", + "timestamp": 1611259362708, + "version": "0.4.14" + }, + "thriftpy2-0.4.14-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b06998f640e28a2c3cb89bc46dc890da", + "name": "thriftpy2", + "sha256": "630a77dd605df46353d8cf68d29b1b079286d0dfe4b676d43ca4ec0d700093e0", + "size": 353284, + "subdir": "linux-64", + "timestamp": 1611259332186, + "version": "0.4.14" + }, + "thriftpy2-0.4.14-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc98ede6bb62e6376d6780988347d66a", + "name": "thriftpy2", + "sha256": "c96726d5ee2813878d773adffe0b14e941b14a81697e769fef6c4ec447f3e69f", + "size": 362543, + "subdir": "linux-64", + "timestamp": 1611259370430, + "version": "0.4.14" + }, + "thriftpy2-0.4.14-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c68c80081884682d8f50850ef48c0b99", + "name": "thriftpy2", + "sha256": "0d93f62885270806137f25c1a0cb4d5c01ba09cc35743bd44b83c1c4805bc079", + "size": 359839, + "subdir": "linux-64", + "timestamp": 1611259361812, + "version": "0.4.14" + }, + "thriftpy2-0.4.16-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "ply >=3.4,<4.0", + "python >=3.10,<3.11.0a0", + "six 1.15.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cea5e518213b5d8411b0bf9fb5016db7", + "name": "thriftpy2", + "sha256": "3a2e07d4b9446ee39ee015c82a7375ad0ec566f5bbc0c8cd20cf27e04ccb8f4a", + "size": 385140, + "subdir": "linux-64", + "timestamp": 1670627133708, + "version": "0.4.16" + }, + "thriftpy2-0.4.16-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "ply >=3.4,<4.0", + "python >=3.11,<3.12.0a0", + "six 1.15.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2246e0f0e748a2ef6826d6a69b11e619", + "name": "thriftpy2", + "sha256": "974f12be4b0f5e071ef7325cf909dc00815dbd6686933d4a47eed9a3825cb3b6", + "size": 415914, + "subdir": "linux-64", + "timestamp": 1676863022144, + "version": "0.4.16" + }, + "thriftpy2-0.4.16-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "ply >=3.4,<4.0", + "python >=3.7,<3.8.0a0", + "six 1.15.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e656028b87b89cb92d4aa01c97992728", + "name": "thriftpy2", + "sha256": "5eae8f8f89810622fd438ada838371858c73e1fee023ed444723c15902407a2e", + "size": 380094, + "subdir": "linux-64", + "timestamp": 1670627167644, + "version": "0.4.16" + }, + "thriftpy2-0.4.16-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "ply >=3.4,<4.0", + "python >=3.8,<3.9.0a0", + "six 1.15.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f077f3b5043d5d592be02e0f9a6d7682", + "name": "thriftpy2", + "sha256": "691be804bfec04357c1f5b0f3a6a66b9f335d4a8c7ac02872e835c356ea4dcb7", + "size": 385914, + "subdir": "linux-64", + "timestamp": 1670627061023, + "version": "0.4.16" + }, + "thriftpy2-0.4.16-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "ply >=3.4,<4.0", + "python >=3.9,<3.10.0a0", + "six 1.15.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e592e3b63409bd9a633a9c54bce17344", + "name": "thriftpy2", + "sha256": "0b5c2ab10f522f61d6731264d579d8edf66040fc51e078b86c66903458980095", + "size": 382300, + "subdir": "linux-64", + "timestamp": 1670627099099, + "version": "0.4.16" + }, + "tifffile-0.15.1-py36heb32a55_2.tar.bz2": { + "build": "py36heb32a55_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1573e5e4aefd90dddada55b50307f263", + "name": "tifffile", + "sha256": "b8b35b01f6d749a3eba4f1a049f0f4a3af2b71bb295882b129faab215971777c", + "size": 192842, + "subdir": "linux-64", + "timestamp": 1585222044993, + "version": "0.15.1" + }, + "tifffile-0.15.1-py37heb32a55_2.tar.bz2": { + "build": "py37heb32a55_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aad3dab0727325d5ad3d133ee9098560", + "name": "tifffile", + "sha256": "c32eb33fe51fc0caf8a4b9c3d448e3b2ff19a95f3d8465d763870f736448b98f", + "size": 191048, + "subdir": "linux-64", + "timestamp": 1585221945370, + "version": "0.15.1" + }, + "tifffile-0.15.1-py38heb32a55_2.tar.bz2": { + "build": "py38heb32a55_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d122df39c03be1e87bf0b58da0a77565", + "name": "tifffile", + "sha256": "a718fb0cc59bfdeb793169f232160dc830911efc9594346f824779c95c129336", + "size": 191937, + "subdir": "linux-64", + "timestamp": 1585222039815, + "version": "0.15.1" + }, + "tifffile-2020.10.1-py36hdd07704_2.tar.bz2": { + "build": "py36hdd07704_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e7d8deff80548405eb0b1c7b6fee8187", + "name": "tifffile", + "sha256": "1d2d69bff8331ff8a08fc96b20829f39d2642d8921668b89f6c782a3dfdb5050", + "size": 278866, + "subdir": "linux-64", + "timestamp": 1602000690830, + "version": "2020.10.1" + }, + "tifffile-2020.10.1-py37hdd07704_2.tar.bz2": { + "build": "py37hdd07704_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "195537f38853e44018f3709b7096a065", + "name": "tifffile", + "sha256": "e40e8581e4c17b47fd7ae05c110da9eda13f8712a9f28702e70faed7f4ff47df", + "size": 266451, + "subdir": "linux-64", + "timestamp": 1602000690760, + "version": "2020.10.1" + }, + "tifffile-2020.10.1-py38hdd07704_2.tar.bz2": { + "build": "py38hdd07704_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "178da0ad5bb23acaf80005358b444344", + "name": "tifffile", + "sha256": "99d5d18eebf0372dc4e96e6b3c071ba2dc017d414db37380eff7c86400d5b3b3", + "size": 270087, + "subdir": "linux-64", + "timestamp": 1602000718859, + "version": "2020.10.1" + }, + "tifffile-2020.9.22-py36hdd07704_2.tar.bz2": { + "build": "py36hdd07704_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bbc0203b64a6039c9bd7cdc41457bcaa", + "name": "tifffile", + "sha256": "1b3aedfdc7a1aa11818a81474b68a24e3a43e957ececfeb8e7dc1a372185c9c7", + "size": 278958, + "subdir": "linux-64", + "timestamp": 1601054171234, + "version": "2020.9.22" + }, + "tifffile-2020.9.22-py37hdd07704_2.tar.bz2": { + "build": "py37hdd07704_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "60e29f6ba8f745bf127b73dff021dd08", + "name": "tifffile", + "sha256": "aaa7bfedf17d2d46ff0eb6414acab1f638fb3fd57cf9d7f31248cf3bcd6c917a", + "size": 269344, + "subdir": "linux-64", + "timestamp": 1601054138863, + "version": "2020.9.22" + }, + "tifffile-2020.9.22-py38hdd07704_2.tar.bz2": { + "build": "py38hdd07704_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1a8ab74a7fe3b85bcfdca16f08c88f64", + "name": "tifffile", + "sha256": "a86ebb15760c62a8f6381a0ba586b41cf6ef6d979f29aa7620c83c06833ee74c", + "size": 271908, + "subdir": "linux-64", + "timestamp": 1601054172523, + "version": "2020.9.22" + }, + "tiledb-1.6.3-h1fb8f14_0.tar.bz2": { + "build": "h1fb8f14_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "curl", + "libcurl >=7.65.3,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "openssl >=1.1.1d,<1.1.2a", + "tbb 2018.0.5.*", + "tbb >=2018.0.5,<2019.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e50c9dca3c182527a0559d6a1ba4bac1", + "name": "tiledb", + "sha256": "54806aac9b4404c420aaa01d49ad225d331ee496f7f56b1f16343adb1a5de3d5", + "size": 2443458, + "subdir": "linux-64", + "timestamp": 1573499209189, + "version": "1.6.3" + }, + "tiledb-2.2.9-he5ba936_1.tar.bz2": { + "build": "he5ba936_1", + "build_number": 1, + "depends": [ + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "openssl >=1.1.1o,<1.1.2a", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c1f9cd1323682ff7389575eae108a78", + "name": "tiledb", + "sha256": "5120552f9bf79658dc57bbe56150493bb908a91ce4fb5686e5312f01e95e06dd", + "size": 1864440, + "subdir": "linux-64", + "timestamp": 1655304046469, + "version": "2.2.9" + }, + "tiledb-2.2.9-hffe1d7a_0.tar.bz2": { + "build": "hffe1d7a_0", + "build_number": 0, + "depends": [ + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "openssl >=1.1.1k,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c97ee1834361965bdd31312ca9650dc", + "name": "tiledb", + "sha256": "8be642799a2a15ad1a444aa863fde9e5bf0671617f7046dab33429acc04a5221", + "size": 1772055, + "subdir": "linux-64", + "timestamp": 1621648801177, + "version": "2.2.9" + }, + "tiledb-2.3.3-h1132f93_2.tar.bz2": { + "build": "h1132f93_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "openssl >=1.1.1o,<1.1.2a", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d957d28b1c29c042c9bf1e77f8cf5d69", + "name": "tiledb", + "sha256": "988b7eb27d5a99c7fc037e812f5b4f4cc2913f2a400428cb1645268b4f6526ad", + "size": 2600714, + "subdir": "linux-64", + "timestamp": 1655311366629, + "version": "2.3.3" + }, + "tiledb-2.3.3-hc47dd91_1.tar.bz2": { + "build": "hc47dd91_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "curl", + "libcurl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "openssl >=1.1.1l,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.5.0,<1.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "82dd93350fd108f7be05c6e69a374286", + "name": "tiledb", + "sha256": "c4e4856783e14a6cb34c486ee97ccc2db1bb045c906f01e8508e73d99bbfcf20", + "size": 2596209, + "subdir": "linux-64", + "timestamp": 1636018003654, + "version": "2.3.3" + }, + "tini-0.18.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f406608f0e1e8dde9e99180f0f695c3c", + "name": "tini", + "sha256": "5b4abe1fed3426a3eddc89aadd9214b0edae229ed33a1795cfbae1e166396ec6", + "size": 14699, + "subdir": "linux-64", + "timestamp": 1540504504197, + "version": "0.18.0" + }, + "tini-0.18.0-h7b6447c_1001.tar.bz2": { + "build": "h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e689889177645732c747e26f25b0890", + "name": "tini", + "sha256": "de660bf915b5056933f9c18f9ec558abad5228aa9399f0ec1cdbd1c5817ec7aa", + "size": 12963, + "subdir": "linux-64", + "timestamp": 1603309190592, + "version": "0.18.0" + }, + "tini-0.19.0-h27cfd23_1001.tar.bz2": { + "build": "h27cfd23_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6532edfdc1db4fa012b2b7d7226eef12", + "name": "tini", + "sha256": "aafef63c4641006cc74caef3c12b6f724b3dc7c09f8a95b8321d34fddd88dee9", + "size": 12977, + "subdir": "linux-64", + "timestamp": 1606938270229, + "version": "0.19.0" + }, + "tinycss2-1.2.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "webencodings >=0.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "12d717c4e3873e295865c1666ff125ef", + "name": "tinycss2", + "sha256": "c839dba354cb1f6b7bf7d7a0fda8c65c1fb1ec2d2165a37cd5abe8ee1ed2ecfc", + "size": 39119, + "subdir": "linux-64", + "timestamp": 1668168931128, + "version": "1.2.1" + }, + "tinycss2-1.2.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "webencodings >=0.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2902d5a5854865baaaf58dc59cf06b3c", + "name": "tinycss2", + "sha256": "f0a026ddc0ed041bfc60c8a1ca0b70b7a69232775b3181bfb35a39fda42d6994", + "size": 49185, + "subdir": "linux-64", + "timestamp": 1676823769869, + "version": "1.2.1" + }, + "tinycss2-1.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "webencodings >=0.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "064175e3bd4837f036ce1b9b2786b26b", + "name": "tinycss2", + "sha256": "ac4b8f9b10b8b0ba6ed96ffa9ebabf84f59a5e3341c9d80c475fa33043051e54", + "size": 39148, + "subdir": "linux-64", + "timestamp": 1668168848549, + "version": "1.2.1" + }, + "tinycss2-1.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "webencodings >=0.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "806aa4861199d75d60b7b964cd04dc6c", + "name": "tinycss2", + "sha256": "d8d4ab14d89a1e994b979923a985519d12b7a5dd25c552e861690486237f2e80", + "size": 39305, + "subdir": "linux-64", + "timestamp": 1668168903676, + "version": "1.2.1" + }, + "tinycss2-1.2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "webencodings >=0.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b413a210eca82fe867e991eed085201b", + "name": "tinycss2", + "sha256": "6ac6003ae10a377e9c2e8953f00aba524b166484252069f19670c6c3792cb5ca", + "size": 38882, + "subdir": "linux-64", + "timestamp": 1668168876032, + "version": "1.2.1" + }, + "tk-8.6.10-hbc83047_0.tar.bz2": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Tcl/Tk", + "license_family": "BSD", + "md5": "76350e04c66dde3f9d94884866ed70c3", + "name": "tk", + "sha256": "51dacd65bba96d74f135cf531c832ebb04f3250df72eaf6d5f0840e5cbcb3d6d", + "size": 3406660, + "subdir": "linux-64", + "timestamp": 1592503345885, + "version": "8.6.10" + }, + "tk-8.6.11-h1ccaba5_0.tar.bz2": { + "build": "h1ccaba5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Tcl/Tk", + "license_family": "BSD", + "md5": "a7bd5edf919b9a24f4f4ed5b23bf62a3", + "name": "tk", + "sha256": "79adf0ddc4e5de7798a97e6fc83097385c877b723a4a50c4bf7c14f502c1fe85", + "size": 3401311, + "subdir": "linux-64", + "timestamp": 1632504578475, + "version": "8.6.11" + }, + "tk-8.6.11-h1ccaba5_1.tar.bz2": { + "build": "h1ccaba5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Tcl/Tk", + "license_family": "BSD", + "md5": "6b41a6aef9cdec5bca809526a4c257e4", + "name": "tk", + "sha256": "253e1ab7e612cfacb05857598edf862182f90b1f07d088684edb2f2f48877f2c", + "size": 3421190, + "subdir": "linux-64", + "timestamp": 1652087619389, + "version": "8.6.11" + }, + "tk-8.6.12-h1ccaba5_0.tar.bz2": { + "build": "h1ccaba5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "TCL", + "license_family": "BSD", + "md5": "5b8375e2092012db69d2123dc0c68630", + "name": "tk", + "sha256": "4a822e705b349b3ba698cc1845397977aa17a0b853e9ea63d1b228e3fc60ba9b", + "size": 3485432, + "subdir": "linux-64", + "timestamp": 1654088939579, + "version": "8.6.12" + }, + "tk-8.6.7-h5979e9b_1.tar.bz2": { + "build": "h5979e9b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "Tcl/Tk", + "license_family": "BSD", + "md5": "5dae7bc95818ef72988000d4db972a62", + "name": "tk", + "sha256": "ddc0a581a762816750c3e18da0dbd60c1f36ddd6d6e4501b29721e147322f651", + "size": 3310231, + "subdir": "linux-64", + "timestamp": 1505666716948, + "version": "8.6.7" + }, + "tk-8.6.7-hc745277_3.tar.bz2": { + "build": "hc745277_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "Tcl/Tk", + "license_family": "BSD", + "md5": "57a8d95fabebbe5aa0fec8945db89536", + "name": "tk", + "sha256": "0067f5430252a65ed3028b46d2fa404f2c94ac05d344767d1ca528a661b26519", + "size": 3311557, + "subdir": "linux-64", + "timestamp": 1510171868737, + "version": "8.6.7" + }, + "tk-8.6.8-hbc83047_0.tar.bz2": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Tcl/Tk", + "license_family": "BSD", + "md5": "7cfa80461710ca1d25a692d28738cfd3", + "name": "tk", + "sha256": "1abdcefc724dccb211740dc19354bbf8f53ed8abd93634a67b97fbc8de02dc0f", + "size": 3295425, + "subdir": "linux-64", + "timestamp": 1535485270027, + "version": "8.6.8" + }, + "tktable-2.10-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "tk", + "tk >=8.6.7,<8.7.0a0" + ], + "license": "Tcl/Tk", + "license_family": "BSD", + "md5": "6814c3b5b7f94675eddb272a9c2496ca", + "name": "tktable", + "sha256": "5622f6b77a0705f053b340a6160ee6c813d01761cc470637432e4d82d5d45a94", + "size": 89947, + "subdir": "linux-64", + "timestamp": 1516268590228, + "version": "2.10" + }, + "tmux-3.3a-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libevent >=2.1.12,<2.1.13.0a0", + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "bc108e0ce6e2e3589a2f1960adf795ed", + "name": "tmux", + "sha256": "fa2392c73d4bb1a325598aa581e6ca9a7dccd7bf085ef3b600d8be37fd9fbecb", + "size": 453692, + "subdir": "linux-64", + "timestamp": 1661976983585, + "version": "3.3a" + }, + "tokenizers-0.10.3-py310hb317417_1.tar.bz2": { + "build": "py310hb317417_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a031ecb1f4a54349c95a0b84f6ce3bef", + "name": "tokenizers", + "sha256": "9abcef8a199fecc8540852647e91c9a6c90a89e5d2952b1cca826513ececcb1a", + "size": 2956652, + "subdir": "linux-64", + "timestamp": 1640795364755, + "version": "0.10.3" + }, + "tokenizers-0.10.3-py37hb317417_1.tar.bz2": { + "build": "py37hb317417_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9a7ee223c30976bb50f286fc8bdc0ffb", + "name": "tokenizers", + "sha256": "3c698f954be8cb88343351a48f40026629bd0072a279cccb383fefce06975e8e", + "size": 2953994, + "subdir": "linux-64", + "timestamp": 1639594214829, + "version": "0.10.3" + }, + "tokenizers-0.10.3-py38hb317417_1.tar.bz2": { + "build": "py38hb317417_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e81a6d8c369137cc89e908bb9b2e59b0", + "name": "tokenizers", + "sha256": "02c1cb222e2f016003a1ab2dc4892d2e931ed5b0e47d79bfb1adfb13f98efa52", + "size": 2992773, + "subdir": "linux-64", + "timestamp": 1639608090910, + "version": "0.10.3" + }, + "tokenizers-0.10.3-py39hb317417_1.tar.bz2": { + "build": "py39hb317417_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7f2edad315c72518f35ee20f78fce266", + "name": "tokenizers", + "sha256": "f98e75fca78930aafb5794a2389a5d42b8a4a73b1cd67a5caa68a2a8e2e3af9e", + "size": 2958308, + "subdir": "linux-64", + "timestamp": 1639589976032, + "version": "0.10.3" + }, + "tokenizers-0.11.4-py310h3dcd8bd_1.tar.bz2": { + "build": "py310h3dcd8bd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1n,<1.1.2a", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ba1443893d86c12bd7bb5f2c5ef930b9", + "name": "tokenizers", + "sha256": "e7432ee88c7eff8be302c42edd228911606d9c18d38976ace954cc427ce438c8", + "size": 4627609, + "subdir": "linux-64", + "timestamp": 1651822814639, + "version": "0.11.4" + }, + "tokenizers-0.11.4-py37h3dcd8bd_1.tar.bz2": { + "build": "py37h3dcd8bd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1n,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2b2e35a666b2ce81335cd1ca6e448c39", + "name": "tokenizers", + "sha256": "0e156a4bb14b37a30b77b097f011843c22b0669bd30ff9a10f8a5568a1e5f73a", + "size": 4625339, + "subdir": "linux-64", + "timestamp": 1651823381002, + "version": "0.11.4" + }, + "tokenizers-0.11.4-py38h3dcd8bd_1.tar.bz2": { + "build": "py38h3dcd8bd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1n,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e9d62020c97e20d09258f7cad79c5da9", + "name": "tokenizers", + "sha256": "bc4c85f030e01a162ce5d5250a09c57a6a8261fdfed3e4df5e5f1b63114b2048", + "size": 4626279, + "subdir": "linux-64", + "timestamp": 1651823004030, + "version": "0.11.4" + }, + "tokenizers-0.11.4-py39h3dcd8bd_1.tar.bz2": { + "build": "py39h3dcd8bd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1n,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a5d30817eeea819f39ce1d8240a32986", + "name": "tokenizers", + "sha256": "7d8175abfaa2e0f8e7c4ff7c6b219ae303c24b55ec1e0beb543cf5f3c135eca0", + "size": 4626740, + "subdir": "linux-64", + "timestamp": 1651823192997, + "version": "0.11.4" + }, + "tokenizers-0.13.2-py311he7d60b5_0.tar.bz2": { + "build": "py311he7d60b5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "629f83ea6bf3a96b8d93ef5b323f1ad1", + "name": "tokenizers", + "sha256": "3ad5812ef4274bb176e31ff39e8a5f7270550d00414b1dd04d1031a73814f851", + "size": 4536953, + "subdir": "linux-64", + "timestamp": 1676863258866, + "version": "0.13.2" + }, + "toml-0.10.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6acb39d912d397a7a7f06190f7055f2", + "name": "toml", + "sha256": "bf9f0d3c67a32838889854c570a77089de5be33c8fd7fb576cb9a40b52ae544e", + "size": 29032, + "subdir": "linux-64", + "timestamp": 1539658616996, + "version": "0.10.0" + }, + "toml-0.10.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aeca5ae42c3c6b9b445387c056e624cb", + "name": "toml", + "sha256": "12ba87febe90c2ddbe2b95464291c0d635eb93f10c0016d88144bbcc74fe55f6", + "size": 29399, + "subdir": "linux-64", + "timestamp": 1539658632793, + "version": "0.10.0" + }, + "toml-0.10.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13c5b187842371cda919adb26a9dc83c", + "name": "toml", + "sha256": "51eb200ca7e50bcd0c625903b5e33c53bc0ff3021a2b25f61e031c9659f8dcca", + "size": 29250, + "subdir": "linux-64", + "timestamp": 1539658632727, + "version": "0.10.0" + }, + "toml-0.9.4-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39979dde18b3988845eb0a41b136bedf", + "name": "toml", + "sha256": "3625515f4d2d31f22617bfca75a14662986de4ecdcc1e83dd01b7403ed2843bc", + "size": 22295, + "subdir": "linux-64", + "timestamp": 1538441034633, + "version": "0.9.4" + }, + "toml-0.9.4-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "20e8744ed8d4c8f4b9bafcf318144492", + "name": "toml", + "sha256": "5882d9a01ea865de5f12abb516195db3ca2ae265f704aec7c399013193d9cbc6", + "size": 22444, + "subdir": "linux-64", + "timestamp": 1529945187865, + "version": "0.9.4" + }, + "toml-0.9.4-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec9437d20402f3177af2bd4c38bea8e8", + "name": "toml", + "sha256": "395dddfae2582a89ec3c071440ab2d2f56732c86f8fcb858f4c00df2f82687fe", + "size": 22494, + "subdir": "linux-64", + "timestamp": 1538441062629, + "version": "0.9.4" + }, + "toml-0.9.4-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63edda380edc1860d580fc98bc279b95", + "name": "toml", + "sha256": "52d2c7801692cdb187bef8ead5134d6841db26ac01212b9a696438007b19b3e9", + "size": 22338, + "subdir": "linux-64", + "timestamp": 1538441035591, + "version": "0.9.4" + }, + "tomli-2.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c484ebee52415c809546b14d9d87b391", + "name": "tomli", + "sha256": "8c907320b7a66bd46b155ad9c4f6774e5abc3ce4a85f8fa9da43e1b98e1836c5", + "size": 24991, + "subdir": "linux-64", + "timestamp": 1657175627477, + "version": "2.0.1" + }, + "tomli-2.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a6bc8c147486932b028b1b89ce4288f", + "name": "tomli", + "sha256": "21618723c43826a00b34242c544e35532b32b4cba80d352b6c23ee89b971305c", + "size": 31106, + "subdir": "linux-64", + "timestamp": 1676822672777, + "version": "2.0.1" + }, + "tomli-2.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "397bffdc088ce8a2c835c8042d57174c", + "name": "tomli", + "sha256": "734dc6407c89ed3fc0350eb384461af4f172d04191449a2004769798e262abc3", + "size": 24797, + "subdir": "linux-64", + "timestamp": 1657175535077, + "version": "2.0.1" + }, + "tomli-2.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc854e728e27537990a07e6d00d30b04", + "name": "tomli", + "sha256": "32a9adfd88e3527f3c2b7bed2ab56f9febda943b497100e9c1ddbc59e72f4de2", + "size": 24863, + "subdir": "linux-64", + "timestamp": 1657175559684, + "version": "2.0.1" + }, + "tomli-2.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c925f0e6cbc92a445946470f9d3732e", + "name": "tomli", + "sha256": "b91bd44ade7b16900ce08a0697abf363e04606f891df593c459d062c8fcf5478", + "size": 24854, + "subdir": "linux-64", + "timestamp": 1657175588674, + "version": "2.0.1" + }, + "tomlkit-0.11.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbfee5d0d4ea07223aae21f9e93b3adb", + "name": "tomlkit", + "sha256": "5b84596e939fe2551952f32d6aaeda3ac7df57b09e02ab65ffb4ec1eba61d352", + "size": 72423, + "subdir": "linux-64", + "timestamp": 1658946924024, + "version": "0.11.1" + }, + "tomlkit-0.11.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "822548273bcfc762ef31820f160d2e03", + "name": "tomlkit", + "sha256": "6c8d6582dbc7897cbae84279c0b4bcc5bb0e8b92bb71ba1d5f63d1ca126e48f4", + "size": 99223, + "subdir": "linux-64", + "timestamp": 1676823231205, + "version": "0.11.1" + }, + "tomlkit-0.11.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ddfe503418ff3b9fc0936ed8576e7f7", + "name": "tomlkit", + "sha256": "7ceb09d0e9225e5b9d4c4bc2b14415cbd620460ceed4e988c0f80f60e3068883", + "size": 70622, + "subdir": "linux-64", + "timestamp": 1658947001425, + "version": "0.11.1" + }, + "tomlkit-0.11.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6edd5c1579b75ee07e67861e32e2a2e4", + "name": "tomlkit", + "sha256": "96b36437692052fadbfa99fd4adc932add60786301809bda6ccf1e30460fc78d", + "size": 71179, + "subdir": "linux-64", + "timestamp": 1658946974368, + "version": "0.11.1" + }, + "tomlkit-0.11.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6afe6236b9fa632dcc150d78cd2f287a", + "name": "tomlkit", + "sha256": "28184df13906f05b8f294b26ebc0d216668251aae6061bb8fdc1a56497ffe712", + "size": 71249, + "subdir": "linux-64", + "timestamp": 1658946949354, + "version": "0.11.1" + }, + "tomlkit-0.5.11-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d773db3c59323f38c4ed43d9f90d4335", + "name": "tomlkit", + "sha256": "a0d3cbfbe1f88bb9770b4b1f95d8f07f7250f74fdcce6900dfed33c792cd2cea", + "size": 122834, + "subdir": "linux-64", + "timestamp": 1594840933949, + "version": "0.5.11" + }, + "tomlkit-0.5.11-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "10bdc83f22e8d1ad66aa47125db6b344", + "name": "tomlkit", + "sha256": "1f471f6ad876cd9ea4031ca28d8ff4f2594db38638e63d5a9032e6db37ec2820", + "size": 122833, + "subdir": "linux-64", + "timestamp": 1594843395234, + "version": "0.5.11" + }, + "tomlkit-0.5.11-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "76763bb5cf05e14aa8ded6f88e251afd", + "name": "tomlkit", + "sha256": "9424eaff8a558bfd55c2229d15d27c1848093d7e1b0c79c6b7326cae3964cd75", + "size": 123241, + "subdir": "linux-64", + "timestamp": 1594843397985, + "version": "0.5.11" + }, + "tomlkit-0.5.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34 >=1.1,<2.0", + "functools32 >=3.2.3,<4.0.0", + "python >=2.7,<2.8.0a0", + "typing >=3.6,<4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "596da5256d65223b2bd94cd254a013ac", + "name": "tomlkit", + "sha256": "06b7b9331c9544c09d4472e23d05c8589fd6d079e9b0de3b5fdb64f6a5c50355", + "size": 117129, + "subdir": "linux-64", + "timestamp": 1579614712585, + "version": "0.5.8" + }, + "tomlkit-0.5.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1357c72bb0b7413e4d8aa8508798af82", + "name": "tomlkit", + "sha256": "71e2f3fc0ac59f8ad24cf538cdaf126e1c0c3fae3ecc63c8713563f268442aac", + "size": 119232, + "subdir": "linux-64", + "timestamp": 1579614787545, + "version": "0.5.8" + }, + "tomlkit-0.5.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c60e15cef8508ed58c1378567baa32b0", + "name": "tomlkit", + "sha256": "3c4fb983b182d259e847cf1de92162924235529872271379f24353508ccc63bf", + "size": 119194, + "subdir": "linux-64", + "timestamp": 1579614611657, + "version": "0.5.8" + }, + "tomlkit-0.5.8-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74ab5bb62ca49e764098eda79ce79aae", + "name": "tomlkit", + "sha256": "d70de7d61e8cb67a286cf0d2d2c6a1522028ab15c562dc530cf6e4685c2ca6c0", + "size": 119674, + "subdir": "linux-64", + "timestamp": 1579614672367, + "version": "0.5.8" + }, + "tomlkit-0.6.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "109efcf2744949c28b135fc8d32029e1", + "name": "tomlkit", + "sha256": "1874afc38ec562f196f798d7656ca5a0ec230226461e334d42fcb923b89eedd7", + "size": 123581, + "subdir": "linux-64", + "timestamp": 1594851845683, + "version": "0.6.0" + }, + "tomlkit-0.6.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e993a4497f0c0fdd2529d2f9183c1c16", + "name": "tomlkit", + "sha256": "e9e7192094c5a3bc068f3a19a219616f8338f463a45ecab3f62308c0fea6bdeb", + "size": 123532, + "subdir": "linux-64", + "timestamp": 1594851846600, + "version": "0.6.0" + }, + "tomlkit-0.6.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d740493a0b0020bb67e3250129e2b71", + "name": "tomlkit", + "sha256": "4c099146d8900dfac1adedc974371d81aa13d4fd7e512668c557f9e96cf7678a", + "size": 123972, + "subdir": "linux-64", + "timestamp": 1594851859186, + "version": "0.6.0" + }, + "tomlkit-0.7.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d0bdb10be25cd26e9a8bb88d53770eb8", + "name": "tomlkit", + "sha256": "75faf0160fcb214951025c4d62fb83fb8370601d425a0d2aaa900c36466669ef", + "size": 196747, + "subdir": "linux-64", + "timestamp": 1640795389093, + "version": "0.7.0" + }, + "tomlkit-0.7.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "acb406ffef067f842bdb9d1dfa5d2bf8", + "name": "tomlkit", + "sha256": "6f8fd61fa41c93cdf63787f0275499cca6e4f7a051f4685e65d18532f3085795", + "size": 202702, + "subdir": "linux-64", + "timestamp": 1605814657419, + "version": "0.7.0" + }, + "tomlkit-0.7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9661b2d1e0e8eba4b072abf1c8485f0e", + "name": "tomlkit", + "sha256": "9af8bfbca5c6da2ebc61c122897d404d28e1213c3e72dcb912856b8db3abe5ab", + "size": 194811, + "subdir": "linux-64", + "timestamp": 1597076541588, + "version": "0.7.0" + }, + "tomlkit-0.7.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4a5bee0768d38352d24b99983bed785", + "name": "tomlkit", + "sha256": "30f8eccfd15f1eac7a34f6753bbe02eda2f4ff5743fc67e4302b42724cfbe9d2", + "size": 204050, + "subdir": "linux-64", + "timestamp": 1605814647341, + "version": "0.7.0" + }, + "tomlkit-0.7.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f42156390293a28e699ca4b45315d2d4", + "name": "tomlkit", + "sha256": "26b2cff391c4db2663f2e87ba585ec7541ae1b075d3bf42ccf32f3e238ad750f", + "size": 200415, + "subdir": "linux-64", + "timestamp": 1605814639309, + "version": "0.7.0" + }, + "tomlkit-0.7.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64ef4d2413d69f6020ab4018f7fb9044", + "name": "tomlkit", + "sha256": "2c637eaabbbb8f6835398ec52fd557bd8e1a0d5ff61f70c5e8b40086a7b6c58f", + "size": 202394, + "subdir": "linux-64", + "timestamp": 1605814632821, + "version": "0.7.0" + }, + "tomlkit-0.7.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbde4ca5d74cf30fd5b1c88167b8718c", + "name": "tomlkit", + "sha256": "e41b027d107a8c82f46efa2775bda6818d64f31b182f31d739e84ed31ea752db", + "size": 61378, + "subdir": "linux-64", + "timestamp": 1626771250883, + "version": "0.7.2" + }, + "tomlkit-0.7.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "42a6bd4ab02207e9543d142ffac35c4d", + "name": "tomlkit", + "sha256": "6e30c774896f314fad506f657ed5769d661cf7c4142e9a10707dccaed03487f9", + "size": 61305, + "subdir": "linux-64", + "timestamp": 1626770940375, + "version": "0.7.2" + }, + "tomlkit-0.7.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a7b44c3a0c17ecafe4e40dc50f44d2d", + "name": "tomlkit", + "sha256": "43e6c0489bd97ed1f5e5144a7f57f1a4575055011baf25a3958fade322390227", + "size": 61844, + "subdir": "linux-64", + "timestamp": 1626763896163, + "version": "0.7.2" + }, + "tomlkit-0.7.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "545bbbf70e531e36a833bdbd24a43a63", + "name": "tomlkit", + "sha256": "e36e54cf75a232c1282704c167f1e82fa93fe9fda9d9e598550d409e1e471df7", + "size": 61873, + "subdir": "linux-64", + "timestamp": 1626771240765, + "version": "0.7.2" + }, + "toolchain-2.4.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "BSD 3-Clause", + "md5": "2e3b661742bcb9c3bb927cf775b764c0", + "name": "toolchain", + "sha256": "cc65259ad10fbc310251c139a3c0c12db8ce8b60005c72eaa0f0b5c92f8c599a", + "size": 13123, + "subdir": "linux-64", + "timestamp": 1565097658074, + "version": "2.4.0" + }, + "toolchain_c_linux-64-2.4.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "toolchain 2.4.0 0" + ], + "license": "BSD 3-Clause", + "md5": "b2d9cc8237b257bfb6ba4295e64460d4", + "name": "toolchain_c_linux-64", + "sha256": "710f9075050570ad05cc3f74b524b0780847d11f902c3310f7c61f861c3cb362", + "size": 13256, + "subdir": "linux-64", + "timestamp": 1565097666416, + "version": "2.4.0" + }, + "toolchain_cxx_linux-64-2.4.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "toolchain 2.4.0 0" + ], + "license": "BSD 3-Clause", + "md5": "29a51a7ec29a03381d25d08debd55be9", + "name": "toolchain_cxx_linux-64", + "sha256": "957f32194c042f29af7a25c58593a2ad8f2e2d5a7c154dda20054a2158d03b44", + "size": 13239, + "subdir": "linux-64", + "timestamp": 1565097679165, + "version": "2.4.0" + }, + "toolchain_fort_linux-64-2.4.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "toolchain 2.4.0 0" + ], + "license": "BSD 3-Clause", + "md5": "52ed6db959f23059f53264193e38806b", + "name": "toolchain_fort_linux-64", + "sha256": "60f91bc01c8914c014a25a8ca6fa424a33dcfb747a634c214118d7545907bb0d", + "size": 13249, + "subdir": "linux-64", + "timestamp": 1565097687641, + "version": "2.4.0" + }, + "toolz-0.12.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38dac546077abb0c9721f655c381c7e6", + "name": "toolz", + "sha256": "76fb218f58792fab0d456e57408e7debdb87c2ecb0497e4855c989b83282118e", + "size": 103861, + "subdir": "linux-64", + "timestamp": 1667464115489, + "version": "0.12.0" + }, + "toolz-0.12.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "32ee4723173f1fad5563b8afb5f1c8f1", + "name": "toolz", + "sha256": "e58ff4a82819446f3c92e5b1aa2a784c4b06643e751fe67cf115858296dbfa50", + "size": 135634, + "subdir": "linux-64", + "timestamp": 1676827536101, + "version": "0.12.0" + }, + "toolz-0.12.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6574d2eda17c13fe249a5d8329c07e9c", + "name": "toolz", + "sha256": "2cdae4f12a337cc3057617a29643d6aeb800f42750ec6aac11d044e30facb49f", + "size": 100721, + "subdir": "linux-64", + "timestamp": 1667464143922, + "version": "0.12.0" + }, + "toolz-0.12.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aec171353448852f51e81c68ef45dfaa", + "name": "toolz", + "sha256": "85077229bfc69efa66079274390675e2f81ffe092435103685d54166e5e69ba6", + "size": 101498, + "subdir": "linux-64", + "timestamp": 1667464200465, + "version": "0.12.0" + }, + "toolz-0.12.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3ce956b1e1a7f77af6e6127dca987b95", + "name": "toolz", + "sha256": "57983e3eb698a3b08b570d5f398d9550cf50b9bf54b2b4728c731ecbc0c89138", + "size": 101246, + "subdir": "linux-64", + "timestamp": 1667464172523, + "version": "0.12.0" + }, + "toolz-0.8.2-py27hd3b1e7e_0.tar.bz2": { + "build": "py27hd3b1e7e_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e0bb9126b3f0ac12821a7e0dc477c694", + "name": "toolz", + "sha256": "5fccd36fc4d0e0ed21f9177e8c26118bfc908621ad46c6ef9dc9bd3256b3240d", + "size": 91707, + "subdir": "linux-64", + "timestamp": 1505732776961, + "version": "0.8.2" + }, + "toolz-0.8.2-py35h90f1797_0.tar.bz2": { + "build": "py35h90f1797_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a0c6de37e4fe0b3fe3e4c6f90dec818f", + "name": "toolz", + "sha256": "ec27ba5d45f23e6866cce7dc69e519159c2b781905995dff80e0eafcb3e4d0ce", + "size": 94142, + "subdir": "linux-64", + "timestamp": 1505732789990, + "version": "0.8.2" + }, + "toolz-0.8.2-py36h81f2dff_0.tar.bz2": { + "build": "py36h81f2dff_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fde5b9e09e09267bca060ebffd0fbf23", + "name": "toolz", + "sha256": "a4c9b62c0a676ed385153d92f829c88a58c09c4a669b59ca5852b265605d57dc", + "size": 93063, + "subdir": "linux-64", + "timestamp": 1505732803222, + "version": "0.8.2" + }, + "toolz-0.9.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8489508c12f2986db707e822398d3fc0", + "name": "toolz", + "sha256": "f98c4824988ca3a530e4e5e290ee548156637c66ce7b93ad6a0f7a6dcd47bded", + "size": 92166, + "subdir": "linux-64", + "timestamp": 1515709467803, + "version": "0.9.0" + }, + "toolz-0.9.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "491ebce622e506e83f8875bfea5a8b2f", + "name": "toolz", + "sha256": "be946eae762a2a2e300292737ac015f0cf9b27ad4084d263dcb54ee0fc0c9ef8", + "size": 94612, + "subdir": "linux-64", + "timestamp": 1515709579065, + "version": "0.9.0" + }, + "toolz-0.9.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "22323bc7ca90d8ae1f786a019205cfb7", + "name": "toolz", + "sha256": "3a7eea8696f3afade6b3e3efa122e721f591575bd73036fef742f5c4971e3ca8", + "size": 93416, + "subdir": "linux-64", + "timestamp": 1515709381763, + "version": "0.9.0" + }, + "toolz-0.9.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5e76706702672279ec95cd340ce451bb", + "name": "toolz", + "sha256": "2fb694c80ac81dde513489a7853641dc88b7e2d711a44e75116c83aa114aeb37", + "size": 93134, + "subdir": "linux-64", + "timestamp": 1530741263341, + "version": "0.9.0" + }, + "torchmetrics-0.11.2-py310h2f386ee_0.tar.bz2": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "numpy >=1.17.2", + "packaging", + "python >=3.10,<3.11.0a0", + "pytorch >=1.8.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "33056a866c4d4b2a4a5f0573191fcc85", + "name": "torchmetrics", + "sha256": "e24eb70de88cd8bdf6bba58ded339de4b516b93bafa3db13f2149a39b9a64070", + "size": 513522, + "subdir": "linux-64", + "timestamp": 1677573127146, + "version": "0.11.2" + }, + "torchmetrics-0.11.2-py37hb070fc8_0.tar.bz2": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy >=1.17.2", + "packaging", + "python >=3.7,<3.8.0a0", + "pytorch >=1.8.1", + "typing-extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "586f70a6f76cb20c96291e2c0dad720c", + "name": "torchmetrics", + "sha256": "45084a5ef115d9d6b2c038aa14cece3fc64f379071e4ae87ac587f9281171674", + "size": 507207, + "subdir": "linux-64", + "timestamp": 1677573083886, + "version": "0.11.2" + }, + "torchmetrics-0.11.2-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy >=1.17.2", + "packaging", + "python >=3.8,<3.9.0a0", + "pytorch >=1.8.1", + "typing-extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4fa2a8d8e97f10904aa040abd410eb4b", + "name": "torchmetrics", + "sha256": "c112b4af2206697374b85e249d4fe448874b72c70162d3476118567c56f264a0", + "size": 508657, + "subdir": "linux-64", + "timestamp": 1677572997721, + "version": "0.11.2" + }, + "torchmetrics-0.11.2-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy >=1.17.2", + "packaging", + "python >=3.9,<3.10.0a0", + "pytorch >=1.8.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d437f145acb5ac944f5af8f41340d517", + "name": "torchmetrics", + "sha256": "cde38fdcfc977075dce6ef5630bff0783c94d22f9df821a456cc27e024731323", + "size": 508300, + "subdir": "linux-64", + "timestamp": 1677573040747, + "version": "0.11.2" + }, + "torchvision-0.11.3-cpu_py310h164cc8f_1.tar.bz2": { + "build": "cpu_py310h164cc8f_1", + "build_number": 1, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.10,<3.11.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5e84af6f2cc0cdc5d5641e2b7c82993d", + "name": "torchvision", + "sha256": "80b0e58caa448bf5a66e8140612572594af6e75afd385680f56ae5ca477386c9", + "size": 24912122, + "subdir": "linux-64", + "timestamp": 1665040691898, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py310h164cc8f_2.tar.bz2": { + "build": "cpu_py310h164cc8f_2", + "build_number": 2, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.10,<3.11.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ae75a7240c5398a53189fd8570af800c", + "name": "torchvision", + "sha256": "f0cf9471e93066a8434dd901145d62e496d490ab480ce3371f3b5427607794b1", + "size": 7421144, + "subdir": "linux-64", + "timestamp": 1665559620475, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py37h164cc8f_0.tar.bz2": { + "build": "cpu_py37h164cc8f_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.7,<3.8.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e13fb630679edf12a33cbdb271123f1b", + "name": "torchvision", + "sha256": "09a3016540fd666d271b4f607eaa2434e807054c17c6ef29f05b7b09294e9964", + "size": 7403477, + "subdir": "linux-64", + "timestamp": 1661862995811, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py37h164cc8f_1.tar.bz2": { + "build": "cpu_py37h164cc8f_1", + "build_number": 1, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.7,<3.8.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "199bb58e99959b665bf695be9962b707", + "name": "torchvision", + "sha256": "cd27b0e4f58d860852cf00e9a9f34109a5970576580fef606d2297f268370682", + "size": 7414557, + "subdir": "linux-64", + "timestamp": 1665041328603, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py37h164cc8f_2.tar.bz2": { + "build": "cpu_py37h164cc8f_2", + "build_number": 2, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.7,<3.8.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "03aa50afac259cbbd6ae9f29fcfc7876", + "name": "torchvision", + "sha256": "8bdd27cc756940881e17294befa2db429a41ea3a3cd27029b998a1c42e6b56e4", + "size": 7415356, + "subdir": "linux-64", + "timestamp": 1665559317534, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py38h164cc8f_0.tar.bz2": { + "build": "cpu_py38h164cc8f_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.8,<3.9.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2108ed46f46c6ced379474791ada502b", + "name": "torchvision", + "sha256": "2e1b520951fc18ac3d0e6ca40cc2c55538fe8efb669bf07b80f15d0e202f2f9f", + "size": 7406269, + "subdir": "linux-64", + "timestamp": 1661862689077, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py38h164cc8f_1.tar.bz2": { + "build": "cpu_py38h164cc8f_1", + "build_number": 1, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.8,<3.9.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "abb603173d59c628a228f98b7cac6ab6", + "name": "torchvision", + "sha256": "d512c95a69de8361eee62b7f21d63ac61cc3b356fbbdc72d1c979f5958564b04", + "size": 7414984, + "subdir": "linux-64", + "timestamp": 1665040341332, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py38h164cc8f_2.tar.bz2": { + "build": "cpu_py38h164cc8f_2", + "build_number": 2, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.8,<3.9.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5ec7095819dc2c31c83513992186bde4", + "name": "torchvision", + "sha256": "9fb21e6cc74e15b78ed74604c02b8bd3278007317d12ffe38b258076f6c8ee07", + "size": 7419288, + "subdir": "linux-64", + "timestamp": 1665559019911, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py39h164cc8f_0.tar.bz2": { + "build": "cpu_py39h164cc8f_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.9,<3.10.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "432b61cc4a0d5504021822db86c66850", + "name": "torchvision", + "sha256": "9f28ad95a0fdc385da20b8328a90e2a228f617d113ad78dc1aa21fa1c38bbba5", + "size": 7407893, + "subdir": "linux-64", + "timestamp": 1661863308993, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py39h164cc8f_1.tar.bz2": { + "build": "cpu_py39h164cc8f_1", + "build_number": 1, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.9,<3.10.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "322dd777fc162085fee3716866230001", + "name": "torchvision", + "sha256": "cc8de9b726afff689d071f9619fb583e769b163d14ccbc23594149bbff8b477e", + "size": 7418768, + "subdir": "linux-64", + "timestamp": 1665041031900, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py39h164cc8f_2.tar.bz2": { + "build": "cpu_py39h164cc8f_2", + "build_number": 2, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.9,<3.10.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e35b683de3accb1fec3341bffb4d2ca2", + "name": "torchvision", + "sha256": "9ea6b5564afa866f0367a2e7bcbff19f5e7c701bbb5b70ee6d2a9bd7f2c9277b", + "size": 7418232, + "subdir": "linux-64", + "timestamp": 1665559915093, + "version": "0.11.3" + }, + "torchvision-0.13.1-cpu_py310h164cc8f_0.tar.bz2": { + "build": "cpu_py310h164cc8f_0", + "build_number": 0, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.2,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.10,<3.11.0a0", + "pytorch", + "requests", + "setuptools", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8825b29357d0a86d7eb68d2678483516", + "name": "torchvision", + "sha256": "359fab11626df25804ff96273155849ff9277e53be848ba8de593d7c87355f41", + "size": 6455224, + "subdir": "linux-64", + "timestamp": 1670314661797, + "version": "0.13.1" + }, + "torchvision-0.13.1-cpu_py37h164cc8f_0.tar.bz2": { + "build": "cpu_py37h164cc8f_0", + "build_number": 0, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.7,<3.8.0a0", + "pytorch", + "requests", + "setuptools", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "edea69308561dc5be4fc6ae9c4fc3d4e", + "name": "torchvision", + "sha256": "8bb94ed0339b6c29dea65db1e1758c320562fea11e0f531647c0753776199c07", + "size": 6450456, + "subdir": "linux-64", + "timestamp": 1670314015631, + "version": "0.13.1" + }, + "torchvision-0.13.1-cpu_py38h164cc8f_0.tar.bz2": { + "build": "cpu_py38h164cc8f_0", + "build_number": 0, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.8,<3.9.0a0", + "pytorch", + "requests", + "setuptools", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3e23e9787e2d6bcfd1f9a57240627fc8", + "name": "torchvision", + "sha256": "5f74416502746cf6c44f8a4e6e5429ed047587d5f56bdf455f3a7b0d3d9f5c3c", + "size": 6449729, + "subdir": "linux-64", + "timestamp": 1670314342385, + "version": "0.13.1" + }, + "torchvision-0.13.1-cpu_py39h164cc8f_0.tar.bz2": { + "build": "cpu_py39h164cc8f_0", + "build_number": 0, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.9,<3.10.0a0", + "pytorch", + "requests", + "setuptools", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "46aade5bd1cfa34ee2d8258068ac1bf1", + "name": "torchvision", + "sha256": "811792b4e5f79c13d3e3ab91c7cca089c1563a5388025422ae41a9bfe714a670", + "size": 6447287, + "subdir": "linux-64", + "timestamp": 1670313692093, + "version": "0.13.1" + }, + "torchvision-0.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch >=0.3", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b43ea92074d2297730a7c54ed645a54b", + "name": "torchvision", + "sha256": "fd8e7e510091e9a91d9f376212de646c76c04f4af25a05e2802175c09cc50746", + "size": 63283, + "subdir": "linux-64", + "timestamp": 1513405387751, + "version": "0.2.0" + }, + "torchvision-0.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.5,<3.6.0a0", + "pytorch >=0.3", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7fd557be0ea359034bf04661e586599b", + "name": "torchvision", + "sha256": "edc9eb0fc7eb74c65bb55a8a0d9099628d561983a4e3242f36f1c2a5ff3d3afa", + "size": 64604, + "subdir": "linux-64", + "timestamp": 1513405369837, + "version": "0.2.0" + }, + "torchvision-0.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch >=0.3", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3d78d9267147829deb75be4471172808", + "name": "torchvision", + "sha256": "895f14c453c53af99516172483cc23eaef51830745ab15798196d4019ad95ee5", + "size": 64440, + "subdir": "linux-64", + "timestamp": 1513405407298, + "version": "0.2.0" + }, + "torchvision-0.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch >=0.4", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "775bc7cb729bbc03c42707fafe525848", + "name": "torchvision", + "sha256": "9a34a6e6cf2fd3b45c1f7c155702475fb13574f354b411b55914c189925c26ba", + "size": 75487, + "subdir": "linux-64", + "timestamp": 1526310288966, + "version": "0.2.1" + }, + "torchvision-0.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=4.1.1", + "python >=3.5,<3.6.0a0", + "pytorch >=0.4", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8519fa7093bd7b041177ae49f8386c34", + "name": "torchvision", + "sha256": "c0df7afdb8cc112ebe9eb1cd46b4044535c7a9939272259a6e141849f41783d8", + "size": 77071, + "subdir": "linux-64", + "timestamp": 1526310308915, + "version": "0.2.1" + }, + "torchvision-0.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch >=0.4", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "60cfd750cedc69096fe30932a45edec3", + "name": "torchvision", + "sha256": "1f525a411e1f063be42bb33fbf5ba0c63c292b65111fb4849ceb58bf5e7a21ab", + "size": 76988, + "subdir": "linux-64", + "timestamp": 1526310283604, + "version": "0.2.1" + }, + "torchvision-0.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch >=0.4", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "260f3a1d6c36762ee5ac9e28feb39a9c", + "name": "torchvision", + "sha256": "fcfc2a7b549893c57f1ef7aafc393a621fc208eaadedee5ed5ef717405ae3228", + "size": 77134, + "subdir": "linux-64", + "timestamp": 1565199693994, + "version": "0.2.1" + }, + "torchvision-0.3.0-cuda100py27h72fc40a_0.tar.bz2": { + "build": "cuda100py27h72fc40a_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch 1.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ed4407017d5feb495205ccf3593adaaf", + "name": "torchvision", + "sha256": "690ddda79c1be71879fa797b201de5a25c8d27d4080834f11e9b083de556e477", + "size": 2247617, + "subdir": "linux-64", + "timestamp": 1565128281467, + "version": "0.3.0" + }, + "torchvision-0.3.0-cuda100py36h72fc40a_0.tar.bz2": { + "build": "cuda100py36h72fc40a_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch 1.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8a8cf26e5418ef037d778f45c0c4ee26", + "name": "torchvision", + "sha256": "d8dd6fcf9756522c702f74c1bed35a737fd5252caef3de702b0ddcc459d76eb0", + "size": 2309026, + "subdir": "linux-64", + "timestamp": 1565128179685, + "version": "0.3.0" + }, + "torchvision-0.3.0-cuda100py37h72fc40a_0.tar.bz2": { + "build": "cuda100py37h72fc40a_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "117a2047bd4bf068c9e390ae49705b66", + "name": "torchvision", + "sha256": "c227ad4a03ac104f4e6ee799dd2100d224259232ccdc7f2babfea46472fcdb0a", + "size": 2294933, + "subdir": "linux-64", + "timestamp": 1565128442711, + "version": "0.3.0" + }, + "torchvision-0.3.0-cuda90py27h6edc907_0.tar.bz2": { + "build": "cuda90py27h6edc907_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "future", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch 1.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ac38d7da2258d53fea7f3d5606d89b1c", + "name": "torchvision", + "sha256": "dcc340c080f3b63731b742f2a1b14e0e77114023b94a5de0389e45e62bde711f", + "size": 2356174, + "subdir": "linux-64", + "timestamp": 1565187682628, + "version": "0.3.0" + }, + "torchvision-0.3.0-cuda90py36h6edc907_0.tar.bz2": { + "build": "cuda90py36h6edc907_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch 1.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "520ebc27c571ff0b572d95935b8b0efb", + "name": "torchvision", + "sha256": "5787b687e6042b261544423accc9c54d9fd8eb04cbc1e94a63b754829e5f3e87", + "size": 2356392, + "subdir": "linux-64", + "timestamp": 1565187230936, + "version": "0.3.0" + }, + "torchvision-0.3.0-cuda90py37h6edc907_0.tar.bz2": { + "build": "cuda90py37h6edc907_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4e6089184e0a525da9dc291723ee3846", + "name": "torchvision", + "sha256": "af29b64ccbd0cb121a98b2fb422193712b6dfe1942e90e9e6a2205ccedb359c9", + "size": 2340534, + "subdir": "linux-64", + "timestamp": 1565187352244, + "version": "0.3.0" + }, + "torchvision-0.3.0-cuda92py27h0601742_0.tar.bz2": { + "build": "cuda92py27h0601742_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch 1.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "645d732329e2ffc033dbf01bdf7f46bb", + "name": "torchvision", + "sha256": "16e127f79328320fdb6f274ddc5855e9d950727dc2031db244d656ce02efdc37", + "size": 2330471, + "subdir": "linux-64", + "timestamp": 1565188819424, + "version": "0.3.0" + }, + "torchvision-0.3.0-cuda92py36h0601742_0.tar.bz2": { + "build": "cuda92py36h0601742_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch 1.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "52b0f286f78ea77f71e284555b49a453", + "name": "torchvision", + "sha256": "865ae8c9b9af0ede112db7d3543324d05e2d156ac545b24046a22effb7d89c41", + "size": 2327516, + "subdir": "linux-64", + "timestamp": 1565188658510, + "version": "0.3.0" + }, + "torchvision-0.3.0-cuda92py37h0601742_0.tar.bz2": { + "build": "cuda92py37h0601742_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a42229b67b5e6a183a69a680712f996a", + "name": "torchvision", + "sha256": "b1bd96a3a321baf9c0dd41cc7f106719c96f4286d5a15b14063c82077eb4be85", + "size": 2327643, + "subdir": "linux-64", + "timestamp": 1565188303018, + "version": "0.3.0" + }, + "torchvision-0.4.0-cpu_py27h1e143f5_0.tar.bz2": { + "build": "cpu_py27h1e143f5_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch 1.2.0.*", + "six", + "_pytorch_select 0.1" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "40039274047ceac899d4a4ce83d616c7", + "name": "torchvision", + "sha256": "074a5e1cf25683b5953cb09073a2f4f3b64b2ca9df3b12fbb34751c7c91651c7", + "size": 2166294, + "subdir": "linux-64", + "timestamp": 1566851088302, + "version": "0.4.0" + }, + "torchvision-0.4.0-cpu_py36h1e143f5_0.tar.bz2": { + "build": "cpu_py36h1e143f5_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch 1.2.0.*", + "six", + "_pytorch_select 0.1" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d3e69224d2a6b13878438c78fe165d1e", + "name": "torchvision", + "sha256": "6b2551445db713ee5b91d5e1446d31c53a6eafd788ee1162ca005660a9a0c165", + "size": 2172240, + "subdir": "linux-64", + "timestamp": 1566851660777, + "version": "0.4.0" + }, + "torchvision-0.4.0-cpu_py37h1e143f5_0.tar.bz2": { + "build": "cpu_py37h1e143f5_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.2.0.*", + "six", + "_pytorch_select 0.1" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2a1408b73f4a129ad550bdfcec8982b8", + "name": "torchvision", + "sha256": "711ad1923a0514ee5839d6610f3ac48839267c5e7f62c3e824f42e0b6a387e6e", + "size": 2170510, + "subdir": "linux-64", + "timestamp": 1566852233347, + "version": "0.4.0" + }, + "torchvision-0.4.0-cuda100py27hecfc37a_0.tar.bz2": { + "build": "cuda100py27hecfc37a_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch 1.2.0.*", + "six", + "_pytorch_select 0.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "38587eacb38c1721f7ddd7bc9c976994", + "name": "torchvision", + "sha256": "0de1f9da4404113d3ff1aafdb59b208212798396d62fc7abc7addcb3560fab28", + "size": 2979820, + "subdir": "linux-64", + "timestamp": 1566850194040, + "version": "0.4.0" + }, + "torchvision-0.4.0-cuda100py36hecfc37a_0.tar.bz2": { + "build": "cuda100py36hecfc37a_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch 1.2.0.*", + "six", + "_pytorch_select 0.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a9749235326e7780d2a5476953f718de", + "name": "torchvision", + "sha256": "1c38d16a148ab05f1f2d5e694bfe2e5e719e13413e4372bc317343a8f76488df", + "size": 2985661, + "subdir": "linux-64", + "timestamp": 1566850686448, + "version": "0.4.0" + }, + "torchvision-0.4.0-cuda100py37hecfc37a_0.tar.bz2": { + "build": "cuda100py37hecfc37a_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.2.0.*", + "six", + "_pytorch_select 0.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5c6c73809bb2e534f1bd4960d1609b29", + "name": "torchvision", + "sha256": "7603737f1009f8ca4ac2527fc4b44082957ddebec021c51e12ffa99a6bbeebd0", + "size": 2986454, + "subdir": "linux-64", + "timestamp": 1566849702506, + "version": "0.4.0" + }, + "torchvision-0.4.0-cuda92py27h1667eeb_0.tar.bz2": { + "build": "cuda92py27h1667eeb_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch 1.2.0.*", + "six", + "_pytorch_select 0.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3943966c4178a25c6f67f84718f3462a", + "name": "torchvision", + "sha256": "f0d63fa513c6197132555cd1a82cfdb3524ffd9c681c47f26a700a625322e68c", + "size": 2955179, + "subdir": "linux-64", + "timestamp": 1566848494911, + "version": "0.4.0" + }, + "torchvision-0.4.0-cuda92py36h1667eeb_0.tar.bz2": { + "build": "cuda92py36h1667eeb_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch 1.2.0.*", + "six", + "_pytorch_select 0.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f0916734818c029ce87d90889b94fc1d", + "name": "torchvision", + "sha256": "685b5b0854e783fe4774684eae1b4fb52ea05a966b7c39a350c64af27e6b77ae", + "size": 2958203, + "subdir": "linux-64", + "timestamp": 1566849047589, + "version": "0.4.0" + }, + "torchvision-0.4.0-cuda92py37h1667eeb_0.tar.bz2": { + "build": "cuda92py37h1667eeb_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.2.0.*", + "six", + "_pytorch_select 0.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "21ae0e08b8f8350ed4a65308024fe23b", + "name": "torchvision", + "sha256": "9b9ac1ffbd26c59013f00da6991196e2f4b8931d01687d54f9d643b0057a9ead", + "size": 2948585, + "subdir": "linux-64", + "timestamp": 1566847942448, + "version": "0.4.0" + }, + "torchvision-0.4.2-cpu_py27h9ec355b_0.tar.bz2": { + "build": "cpu_py27h9ec355b_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch 1.3.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "073963e3f8bc919425e39713adac32d8", + "name": "torchvision", + "sha256": "b8c3318025674353e7e3ed97cd262c6b977c0859ed06e09e1c6595cbbe3a022a", + "size": 6269972, + "subdir": "linux-64", + "timestamp": 1574723178832, + "version": "0.4.2" + }, + "torchvision-0.4.2-cpu_py36h9ec355b_0.tar.bz2": { + "build": "cpu_py36h9ec355b_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch 1.3.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f98c847fedbe2b517514f1f11b7d15d4", + "name": "torchvision", + "sha256": "4a040c836ca8d75c1b67ded129c6bf816cbafa449bfbcc3f7c5e1983942759ec", + "size": 6269523, + "subdir": "linux-64", + "timestamp": 1574723552571, + "version": "0.4.2" + }, + "torchvision-0.4.2-cpu_py37h9ec355b_0.tar.bz2": { + "build": "cpu_py37h9ec355b_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.3.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e37b5cd1d1cb890764fd6a696581985a", + "name": "torchvision", + "sha256": "a34d5e1b3319e99fe7e9d533135ab7b1471f809afc39b626528a463e8abe9c15", + "size": 6294891, + "subdir": "linux-64", + "timestamp": 1574723990250, + "version": "0.4.2" + }, + "torchvision-0.4.2-cuda100py27hecfc37a_0.tar.bz2": { + "build": "cuda100py27hecfc37a_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch 1.3.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f67597b89245acdcf14915cf50ce508b", + "name": "torchvision", + "sha256": "248d66bf0cbe9d9552ef34af3fcc11c3c01f96b711dff3934f9fccde8cec80eb", + "size": 7117070, + "subdir": "linux-64", + "timestamp": 1574718923382, + "version": "0.4.2" + }, + "torchvision-0.4.2-cuda100py36hecfc37a_0.tar.bz2": { + "build": "cuda100py36hecfc37a_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch 1.3.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b4f4bb6022d092112c58fcae5338c148", + "name": "torchvision", + "sha256": "6eb786ee0d6f80b1278e79b987158459ebb0d5ea56193ad593ad263854bf315b", + "size": 7143537, + "subdir": "linux-64", + "timestamp": 1574719539330, + "version": "0.4.2" + }, + "torchvision-0.4.2-cuda100py37hecfc37a_0.tar.bz2": { + "build": "cuda100py37hecfc37a_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.3.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "977c506c8b8ee5b115abc3d85d9df35f", + "name": "torchvision", + "sha256": "8a0ffb7f081a3eeb9b61cd9ad550102dde6cc49128609d62beba3728af65c52f", + "size": 7118178, + "subdir": "linux-64", + "timestamp": 1574720098335, + "version": "0.4.2" + }, + "torchvision-0.4.2-cuda92py27h1667eeb_0.tar.bz2": { + "build": "cuda92py27h1667eeb_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch 1.3.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8f3d83b2638b545a1bb75cf6de1e5e67", + "name": "torchvision", + "sha256": "368fd6badfc592b12e4d65688530f18ebc1d9e134d10967b1b200275fa2c6f8c", + "size": 7127560, + "subdir": "linux-64", + "timestamp": 1574716613108, + "version": "0.4.2" + }, + "torchvision-0.4.2-cuda92py36h1667eeb_0.tar.bz2": { + "build": "cuda92py36h1667eeb_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch 1.3.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4bf2cf062e1f5317efc89b97c72012fe", + "name": "torchvision", + "sha256": "0eec77884a5352059efcb1fad9942086636e80546d5ad20f136783a46929d138", + "size": 7102463, + "subdir": "linux-64", + "timestamp": 1574717271846, + "version": "0.4.2" + }, + "torchvision-0.4.2-cuda92py37h1667eeb_0.tar.bz2": { + "build": "cuda92py37h1667eeb_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.3.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "147ae1304012251f1168e8005a63d147", + "name": "torchvision", + "sha256": "2ed3a4a2939d12fe22627a924fff32ede7039050d821159d1667e95d8ce47b13", + "size": 7130197, + "subdir": "linux-64", + "timestamp": 1574718012934, + "version": "0.4.2" + }, + "torchvision-0.8.2-cpu_py37ha229d99_0.tar.bz2": { + "build": "cpu_py37ha229d99_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.7.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "87877ffec727e5b98e10bdb418fc9dc4", + "name": "torchvision", + "sha256": "8acbb68036813d6d3f972288b2bb798455285cb08b9b62a11488a3bdee5a8b21", + "size": 6888806, + "subdir": "linux-64", + "timestamp": 1622219836194, + "version": "0.8.2" + }, + "torchvision-0.8.2-cpu_py38ha229d99_0.tar.bz2": { + "build": "cpu_py38ha229d99_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.8,<3.9.0a0", + "pytorch 1.7.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2d8d6effe0284c09199bb77917b4f013", + "name": "torchvision", + "sha256": "e7513e4aecbf17162f199a63129ee52f11a9a606376b5fb460acc199eb67cc97", + "size": 6852899, + "subdir": "linux-64", + "timestamp": 1622214794240, + "version": "0.8.2" + }, + "torchvision-0.8.2-cpu_py39ha229d99_0.tar.bz2": { + "build": "cpu_py39ha229d99_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.9,<3.10.0a0", + "pytorch 1.7.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6594af9d20d7a1468085c5405b1aa35f", + "name": "torchvision", + "sha256": "9775491fb44bdbaf6e0c33a860b7782518bd65b1e174698abaf5bb2f00db3c55", + "size": 6915508, + "subdir": "linux-64", + "timestamp": 1622226192276, + "version": "0.8.2" + }, + "tornado-4.5.2-py27h97b179f_0.tar.bz2": { + "build": "py27h97b179f_0", + "build_number": 0, + "depends": [ + "backports_abc >=0.4", + "certifi", + "python >=2.7,<2.8.0a0", + "singledispatch", + "ssl_match_hostname" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1e0ba3172d35b24adb8983ad6c241e2c", + "name": "tornado", + "sha256": "da530e5ad1fd6897d2972e6161d94e4deb2bd25e6ff3baae317c740a681f428a", + "size": 607772, + "subdir": "linux-64", + "timestamp": 1505690514746, + "version": "4.5.2" + }, + "tornado-4.5.2-py35hf879e1d_0.tar.bz2": { + "build": "py35hf879e1d_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "983dc1a7a6677ea495b9aa40a6ee63cf", + "name": "tornado", + "sha256": "dad06ecc037215f2e4df0ccfd4c32376b55dfbfe13bd79ff647e018cfe608b44", + "size": 636184, + "subdir": "linux-64", + "timestamp": 1505690531884, + "version": "4.5.2" + }, + "tornado-4.5.2-py36h1283b2a_0.tar.bz2": { + "build": "py36h1283b2a_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6e44c56eee49ff16e15806b9b4391381", + "name": "tornado", + "sha256": "3f065f02e3d4c8966741b01daf129a6c15e3f65e6c190b51abaa63da9758a234", + "size": 631059, + "subdir": "linux-64", + "timestamp": 1505690549225, + "version": "4.5.2" + }, + "tornado-4.5.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports_abc >=0.4", + "certifi", + "python >=2.7,<2.8.0a0", + "singledispatch", + "ssl_match_hostname" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c6a8a45e5ddba3c9284a3f3cd53d0ef7", + "name": "tornado", + "sha256": "8f6d3f52cd0781aca7ce69bc2e1d1a8712c0c5392c32a7fc06a4055d5a227e79", + "size": 609441, + "subdir": "linux-64", + "timestamp": 1515709494866, + "version": "4.5.3" + }, + "tornado-4.5.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3dd8aa23f8f8391a6a4b8e351031e37c", + "name": "tornado", + "sha256": "47fb9d7caca3c523bc8c94856eba5a7ab9e5f4a2f40a372f21792cfd2d758b49", + "size": 637726, + "subdir": "linux-64", + "timestamp": 1515709574674, + "version": "4.5.3" + }, + "tornado-4.5.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "407e2d6c73ca97d7453504e5f959f587", + "name": "tornado", + "sha256": "160e1b44f0bf86e318b290457dcfef1ffaf8259c2fd9fd63b9371110a51e1b5e", + "size": 631775, + "subdir": "linux-64", + "timestamp": 1515709357660, + "version": "4.5.3" + }, + "tornado-4.5.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ccd9410b898cfeb9fa645b797aee502b", + "name": "tornado", + "sha256": "eca87a14bbb09f75cb69fe799f077876aab0ad0c953d8eeb7d859b24f8b90a70", + "size": 633136, + "subdir": "linux-64", + "timestamp": 1536601522165, + "version": "4.5.3" + }, + "tornado-5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports_abc >=0.4", + "futures", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cdb6e53fded4298779481b3b45c8700a", + "name": "tornado", + "sha256": "18491f5adf5f41878627af420a36fdeaa4e3f0cdc97524f0dfdfd3374196d34a", + "size": 631617, + "subdir": "linux-64", + "timestamp": 1520362820683, + "version": "5.0" + }, + "tornado-5.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "262dcab5b899543a203b22cebc627256", + "name": "tornado", + "sha256": "66224b013d9d3b1bc0065a0aec27bd0f9d12f413da5bd0b8269b6d47e53077a9", + "size": 655710, + "subdir": "linux-64", + "timestamp": 1520362902205, + "version": "5.0" + }, + "tornado-5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "548689c5f831e9583538e61db86f3a93", + "name": "tornado", + "sha256": "044d786749e9c87b2780d0d603f4d85a9683e88eb5d12c6dd5da3f3fe15ab78f", + "size": 655513, + "subdir": "linux-64", + "timestamp": 1520362500488, + "version": "5.0" + }, + "tornado-5.0.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "backports_abc >=0.4", + "futures", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "061f6d846c23dafff6024256d7f69e13", + "name": "tornado", + "sha256": "8c0bbd122cc1b0d45dcd0673da1ee12b41c0310f34ff66555382a0a2a32eaa0b", + "size": 632025, + "subdir": "linux-64", + "timestamp": 1522263246558, + "version": "5.0.1" + }, + "tornado-5.0.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "15865c3d12e418dc83ab989042a84581", + "name": "tornado", + "sha256": "44e4f8e21912580d77766fe3b74c09a0561c75e0ddfaf4b01ab4bf221b0e89e3", + "size": 655293, + "subdir": "linux-64", + "timestamp": 1522263255676, + "version": "5.0.1" + }, + "tornado-5.0.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "47335598a80ac857d107aa10c0ecebc3", + "name": "tornado", + "sha256": "589eebca14c49a2d33de5fdbda6ce769e4bb6b822e84524b1573979179218999", + "size": 656560, + "subdir": "linux-64", + "timestamp": 1522263160670, + "version": "5.0.1" + }, + "tornado-5.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports_abc >=0.4", + "futures", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "38566176e46feb51138994bf8d12e63d", + "name": "tornado", + "sha256": "aa1c165c519e29dfe02f9a679acdd7b5aa514c284a2756c112362c41198c9381", + "size": 635280, + "subdir": "linux-64", + "timestamp": 1524145094055, + "version": "5.0.2" + }, + "tornado-5.0.2-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "backports_abc >=0.4", + "futures", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "17c9bfac3acc179c40a41f1283a68583", + "name": "tornado", + "sha256": "b62891a0d134a444d750ced17b71e28f89d3679a50fa0e5a60cc55de2ca7490d", + "size": 642191, + "subdir": "linux-64", + "timestamp": 1530694253724, + "version": "5.0.2" + }, + "tornado-5.0.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6b36c0ea14396f665383cb3ababd68c4", + "name": "tornado", + "sha256": "bad2e0337a96531830185a37941b8526923b708afc995899aa91e84390eae352", + "size": 659025, + "subdir": "linux-64", + "timestamp": 1524145102292, + "version": "5.0.2" + }, + "tornado-5.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "72560c0dd67b5974d15cfc31f2bfcde3", + "name": "tornado", + "sha256": "5c9384b251e2e64802d87ee5dff297fbfb45285c5b2aa8680b2b2f416e3d240f", + "size": 659891, + "subdir": "linux-64", + "timestamp": 1524145144436, + "version": "5.0.2" + }, + "tornado-5.0.2-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f1aeaf92f2c0d8b88dd2450b4451ca0e", + "name": "tornado", + "sha256": "f0c92aff582550bff89a5830ff931487e8f10d284c2d5a3d4dda899b345e66d7", + "size": 667561, + "subdir": "linux-64", + "timestamp": 1530694199142, + "version": "5.0.2" + }, + "tornado-5.0.2-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d65235423e1a8b875a9712d4f6059b9e", + "name": "tornado", + "sha256": "59c67b5b578c58331301fa926eb6b333792cde7110c2b6df9140a14482a79e2e", + "size": 696911, + "subdir": "linux-64", + "timestamp": 1613166497991, + "version": "5.0.2" + }, + "tornado-5.0.2-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b889aa71b7a1480cc2387f7e561d14e0", + "name": "tornado", + "sha256": "1f58b179d8aa9f9086b1bbef806831a5355976473255b4a4fb55c6e1d3e8cea3", + "size": 668040, + "subdir": "linux-64", + "timestamp": 1530694228083, + "version": "5.0.2" + }, + "tornado-5.0.2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c479b915c7a9716adc5dc6520d09451b", + "name": "tornado", + "sha256": "8d3fdd080254fe30078c84581a6b94fd61c3bd1f5f7bfc57360606663d3b0b8a", + "size": 698846, + "subdir": "linux-64", + "timestamp": 1613166951357, + "version": "5.0.2" + }, + "tornado-5.0.2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "72c766327ce05bc68b786a981254db5e", + "name": "tornado", + "sha256": "734c05553a144c418437d4aad5cfe3ebae2111c323a3d791c39bbb9ae2847823", + "size": 701153, + "subdir": "linux-64", + "timestamp": 1613166962101, + "version": "5.0.2" + }, + "tornado-5.0.2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fc125d547718dcbfa785eff220825f37", + "name": "tornado", + "sha256": "67b893a893c55851665fb41cb569e9fc386894d99c8bf3965629cc59057544d5", + "size": 700732, + "subdir": "linux-64", + "timestamp": 1613166952067, + "version": "5.0.2" + }, + "tornado-5.1-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "backports_abc >=0.4", + "futures", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9870c9b21798c18e1c8a648c5037c825", + "name": "tornado", + "sha256": "bf45a6da16e302217a1c87806157a440bd3c86a88a4e8b8e370ff06966e4ee71", + "size": 662970, + "subdir": "linux-64", + "timestamp": 1532981417628, + "version": "5.1" + }, + "tornado-5.1-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "07bf18c3cf6004ee2818de48b94d06bf", + "name": "tornado", + "sha256": "be7ad1a86872b24b24792cefaa4a6b95c380569639da3f2248823d59db5a99f2", + "size": 684179, + "subdir": "linux-64", + "timestamp": 1532981606362, + "version": "5.1" + }, + "tornado-5.1-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a8ae0c0ecb84039c4c56ec4d97f6b28a", + "name": "tornado", + "sha256": "103592313d81773a8482fa8faeb060a1b85e97aa5d44f6af400b81537290df6b", + "size": 682427, + "subdir": "linux-64", + "timestamp": 1532981600848, + "version": "5.1" + }, + "tornado-5.1-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3269b439b8432c8dc8d49635a80c750f", + "name": "tornado", + "sha256": "73a45ddf521b3ee01508e61e8c11cb00dec6d2138f2bab0f677ea6a488a66773", + "size": 681001, + "subdir": "linux-64", + "timestamp": 1532981604311, + "version": "5.1" + }, + "tornado-5.1.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "backports_abc >=0.4", + "futures", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a8d994df814ce3aab97d449693211b5a", + "name": "tornado", + "sha256": "403077e47488802d697049e843000c53228453427dc0e7007754b49dc549f50c", + "size": 658668, + "subdir": "linux-64", + "timestamp": 1538231536242, + "version": "5.1.1" + }, + "tornado-5.1.1-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4beb627473b03eed55fadcfa84b5863f", + "name": "tornado", + "sha256": "68032d51578710e166baef9192f85c5060611bd76850039b88c5fdc0ca0c3e52", + "size": 680615, + "subdir": "linux-64", + "timestamp": 1538231569613, + "version": "5.1.1" + }, + "tornado-5.1.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "62ef269c7cc79d4da7539cfffb5e7ed5", + "name": "tornado", + "sha256": "38fb1b8568cb4afcc090aee5390e9aacc516c030b53142f8272ebcc769c566e8", + "size": 678819, + "subdir": "linux-64", + "timestamp": 1538231576095, + "version": "5.1.1" + }, + "tornado-5.1.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f6ba14c98545875d4d671f0dfd095c4a", + "name": "tornado", + "sha256": "daa4ee30a7e46a94303b55687497c9654f2f1bd99d7a6385c55cce6c281549ae", + "size": 677767, + "subdir": "linux-64", + "timestamp": 1538231515594, + "version": "5.1.1" + }, + "tornado-6.0.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "04458c7c82825cf0a4a59ed9972f79c4", + "name": "tornado", + "sha256": "484342c7130d37c84cba9aaea2cdf8ac56b8313851dd3c286fc6496ed862fe46", + "size": 657653, + "subdir": "linux-64", + "timestamp": 1552339698377, + "version": "6.0.1" + }, + "tornado-6.0.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ac4bd8e9d15af6502e2ee043f0c8ed1c", + "name": "tornado", + "sha256": "642ac727dacfc6ae8a1590b5d4889410f62dda99288ec5739d3e9809656c188c", + "size": 654718, + "subdir": "linux-64", + "timestamp": 1552339660266, + "version": "6.0.1" + }, + "tornado-6.0.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7c4110c11c37cad7a728122d4ec1cead", + "name": "tornado", + "sha256": "05034545386cb4ede763ad8cdc8afd0017778e32ec3ffa0912716ceea2bc5dec", + "size": 655623, + "subdir": "linux-64", + "timestamp": 1553523913908, + "version": "6.0.2" + }, + "tornado-6.0.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c4c081ef86d326eeb1c9cef86b7e662d", + "name": "tornado", + "sha256": "f2a77de5e6baea21481812387fd0e77f7177c1b310c23ce0e7b7a7d2b7046d87", + "size": 657899, + "subdir": "linux-64", + "timestamp": 1553523880697, + "version": "6.0.2" + }, + "tornado-6.0.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "03c0e257f5540b3886dd055311014a1d", + "name": "tornado", + "sha256": "1372498112a3aa7da26f8043980a9c0a629e7ec874dc58670d5c6faaa82a98f9", + "size": 658359, + "subdir": "linux-64", + "timestamp": 1562078778510, + "version": "6.0.3" + }, + "tornado-6.0.3-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "459e860c3ba69ea23894b5ec3f7dba4d", + "name": "tornado", + "sha256": "ee716fdc7752b5d85805d7a3db9ac96dd5eeabee4b34cf45af189a5473a7de11", + "size": 661059, + "subdir": "linux-64", + "timestamp": 1581113859447, + "version": "6.0.3" + }, + "tornado-6.0.3-py36h7b6447c_3.tar.bz2": { + "build": "py36h7b6447c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3927d5549d26603ca49a4e1c30acc1c8", + "name": "tornado", + "sha256": "aee40648da447bc714d54466e6f04cc38b867ed464e9dc82fef77cdb78980483", + "size": 659156, + "subdir": "linux-64", + "timestamp": 1581357683755, + "version": "6.0.3" + }, + "tornado-6.0.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b7339cc0a2e4df93a6043a3d8b4cc79f", + "name": "tornado", + "sha256": "cad6a94d29d4d5d5c20f6598ed699acb84b2d7253953ab44712709ef3f46c45b", + "size": 659237, + "subdir": "linux-64", + "timestamp": 1562078778390, + "version": "6.0.3" + }, + "tornado-6.0.3-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2e561ec9baa032f823247a28a26dc6f0", + "name": "tornado", + "sha256": "a0f5107c179b2b7f4a919acc9865d75b395b55ee48b8d8efbaee2ebaf55c65eb", + "size": 659024, + "subdir": "linux-64", + "timestamp": 1581113880232, + "version": "6.0.3" + }, + "tornado-6.0.3-py37h7b6447c_3.tar.bz2": { + "build": "py37h7b6447c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "67c433948bbf1ce2327010008015f0f9", + "name": "tornado", + "sha256": "3290773884c8bf1d46e82ad43c49063c22d239e0f98f86251a11d7605065a71d", + "size": 657875, + "subdir": "linux-64", + "timestamp": 1581357679822, + "version": "6.0.3" + }, + "tornado-6.0.3-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7e74f420da772bab0595c13ded8371dc", + "name": "tornado", + "sha256": "6222a7f8b18a7e94063c14e53d84fe0e65154cc42d46bc0c5246662f70b0acfb", + "size": 660456, + "subdir": "linux-64", + "timestamp": 1573200428365, + "version": "6.0.3" + }, + "tornado-6.0.3-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "35c3d93710f9709612e26546873ea50a", + "name": "tornado", + "sha256": "f70d8736ee19c71442ace6c6d81a393135bf085cb091598bb23b4adfeab75025", + "size": 661228, + "subdir": "linux-64", + "timestamp": 1581113883752, + "version": "6.0.3" + }, + "tornado-6.0.3-py38h7b6447c_3.tar.bz2": { + "build": "py38h7b6447c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "15b1e308f303b1cbbe21157ba89627d9", + "name": "tornado", + "sha256": "28b5a58e43a6f326d037445e61a71e58023a1ab28e0cda53911e6b8f4cd58e41", + "size": 663650, + "subdir": "linux-64", + "timestamp": 1581357715994, + "version": "6.0.3" + }, + "tornado-6.0.4-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bd19eb18402bf49ce46c75f990b44606", + "name": "tornado", + "sha256": "46f19b05bf8fe82297ca5dddc4cd69cc0f4b0a6bbf3370bd3597c717b67cb1df", + "size": 665950, + "subdir": "linux-64", + "timestamp": 1584026791598, + "version": "6.0.4" + }, + "tornado-6.0.4-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "95494de5a054319080c4236a65032393", + "name": "tornado", + "sha256": "b2c2998bf54d24cbb629648a7c8f4bd629e0330a26f5bcb1337bc33dbf837cca", + "size": 664824, + "subdir": "linux-64", + "timestamp": 1584026756160, + "version": "6.0.4" + }, + "tornado-6.0.4-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "14a2593680ee47d17f480bf7f89d9d45", + "name": "tornado", + "sha256": "814ab309ac050a56d7e9ecbdabedf4391a13572e53af3ad672655feda5aea321", + "size": 666260, + "subdir": "linux-64", + "timestamp": 1584026786758, + "version": "6.0.4" + }, + "tornado-6.1-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "55bf10237c01dee421799c36a1330d29", + "name": "tornado", + "sha256": "dcfeb70e565c04cfec6e5aee9c5c17fe4adc75fb8bbb6eb15d4a8b8cd65459cc", + "size": 681452, + "subdir": "linux-64", + "timestamp": 1640795414786, + "version": "6.1" + }, + "tornado-6.1-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e465a5c176fc03f944fb9ce6fa985ea0", + "name": "tornado", + "sha256": "536832331203916e3863938bfe8864b7d6079332204e6699a51bd95f8aa4f0d4", + "size": 658736, + "subdir": "linux-64", + "timestamp": 1606942366873, + "version": "6.1" + }, + "tornado-6.1-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5cc070f92a24e4b408bb7c685dd3f342", + "name": "tornado", + "sha256": "6c2409494b0bb0d5d8b34a1814c00d97735cbff7fd144aa75770e7bff1af3a34", + "size": 662206, + "subdir": "linux-64", + "timestamp": 1606942320203, + "version": "6.1" + }, + "tornado-6.1-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5a07056c0968e39f39510f8b9526714c", + "name": "tornado", + "sha256": "d90c5e38c73cc80e7d69e7f7e8df47df5d32b6a31bef0d7a799e12132211624b", + "size": 663452, + "subdir": "linux-64", + "timestamp": 1606942346182, + "version": "6.1" + }, + "tornado-6.1-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "200e86f8d53aeebf4b7dcfc944fd7920", + "name": "tornado", + "sha256": "b746e39272888b9cc1a2a711b7b8836f2e26f4457850e43ad18bf0765e21dc3d", + "size": 661662, + "subdir": "linux-64", + "timestamp": 1606942359431, + "version": "6.1" + }, + "tornado-6.2-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7a9b2a50c99708ed401cb99141cd7617", + "name": "tornado", + "sha256": "5084ccf6e07748b39074af11d19728efd896ba89826b91dc39e4a32486734b4c", + "size": 679414, + "subdir": "linux-64", + "timestamp": 1662061773929, + "version": "6.2" + }, + "tornado-6.2-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ee880c31fc1900ce487f2de33fa32626", + "name": "tornado", + "sha256": "d07bffc29188d7857f6e1c61579011c93fda86ad17f64af474ef044741082056", + "size": 886861, + "subdir": "linux-64", + "timestamp": 1676823435699, + "version": "6.2" + }, + "tornado-6.2-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4172b780648e001edbfdbfc0f12014e6", + "name": "tornado", + "sha256": "c17c03e1e5badad9d069b148b1ad40acafe2ad9a915d4a0fd7e4805f4a25e1e4", + "size": 667455, + "subdir": "linux-64", + "timestamp": 1662061843812, + "version": "6.2" + }, + "tornado-6.2-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e599c27a060b8b256e169474f95bda61", + "name": "tornado", + "sha256": "2e75d001c74155c49e203d012e5f75922baa36d0829806f02dfc400edc322ba7", + "size": 671181, + "subdir": "linux-64", + "timestamp": 1662061808629, + "version": "6.2" + }, + "tornado-6.2-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "97a705471f27f23009d060bf8e7a66a2", + "name": "tornado", + "sha256": "4acf2c88d33b7045cca41ab7ff3ac7516a1a5dad20dd1a0fc46f5451229668e2", + "size": 669071, + "subdir": "linux-64", + "timestamp": 1662061881952, + "version": "6.2" + }, + "tornado-json-1.3.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0", + "python >=2.7,<2.8.0a0", + "tornado >=3.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08dc0636cee27cc4a33b1845337c24a7", + "name": "tornado-json", + "sha256": "3b15d7b9dc580e185d63512157db09ad4095efa603871e82a08e131fa4905966", + "size": 25607, + "subdir": "linux-64", + "timestamp": 1537836684199, + "version": "1.3.3" + }, + "tornado-json-1.3.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0", + "python >=3.5,<3.6.0a0", + "tornado >=3.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "edb97c884e8d1d7bbd78467b22bcf4f0", + "name": "tornado-json", + "sha256": "a762732cda32b2b4a16c2752e806e0df9487f1c5d6ea9b460929016299d61461", + "size": 26342, + "subdir": "linux-64", + "timestamp": 1537832757489, + "version": "1.3.3" + }, + "tornado-json-1.3.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0", + "python >=3.6,<3.7.0a0", + "tornado >=3.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2076bf7b1435e3cc25a172d2ab627b6e", + "name": "tornado-json", + "sha256": "ed45466d94e3d358a3dfc1bbdf8e0a454e36742f42462dcded6528d76b32162f", + "size": 26255, + "subdir": "linux-64", + "timestamp": 1537832767527, + "version": "1.3.3" + }, + "tornado-json-1.3.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0", + "python >=3.7,<3.8.0a0", + "tornado >=3.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be201e6ddad6b02db73922dca979def2", + "name": "tornado-json", + "sha256": "d417cbeba289cb72d87eaaf61a3bda6b9082bb53550ac9770763456ba73ced69", + "size": 26256, + "subdir": "linux-64", + "timestamp": 1537832668962, + "version": "1.3.3" + }, + "tornado-json-1.3.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0,<3.0", + "python >=2.7,<2.8.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "925711fd4c3db34697d4dab285530806", + "name": "tornado-json", + "sha256": "515330f821e9bee281ec336176ea5758c22fad230cb13cf555bb9342e0d40327", + "size": 172733, + "subdir": "linux-64", + "timestamp": 1569442067926, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "jsonschema >=2.3.0", + "python >=3.10,<3.11.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2eab3752d43002a8e47b8ff630b6f6c2", + "name": "tornado-json", + "sha256": "740f96ceee488f5ce702cbff3ec50b15720c1a91228e6c5018509a92f6ae4649", + "size": 27694, + "subdir": "linux-64", + "timestamp": 1640811268843, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0,<3.0", + "python >=3.6,<3.7.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e87efa780dda0f849468a746a3452b8f", + "name": "tornado-json", + "sha256": "c0d7d989d50be26d85a258935040ae020204afe863b12d2fd35e1c56adabb30e", + "size": 173332, + "subdir": "linux-64", + "timestamp": 1569442073010, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0,<3.0", + "python >=3.6,<3.7.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb23f12b698ed88f7d4600263b639ade", + "name": "tornado-json", + "sha256": "2f2cfbc12e22fae981d3689b2dc533fc51d28c06e36fda2c673d39ae9f355852", + "size": 243909, + "subdir": "linux-64", + "timestamp": 1613038668052, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "jsonschema >=2.3.0", + "python >=3.6,<3.7.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e30388aeaa36b98256cb36e1c414b9fe", + "name": "tornado-json", + "sha256": "376c067ca25918eb65825286f3f6dd1caf9d56ff5071c08bd4e59e99143407c5", + "size": 250691, + "subdir": "linux-64", + "timestamp": 1613996857792, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0,<3.0", + "python >=3.7,<3.8.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ac6b88178871b59183844aeebab73cb", + "name": "tornado-json", + "sha256": "e864f026313c2de25a90843b94a6918a1afeb33fda63dbc241e925eb7c079902", + "size": 173333, + "subdir": "linux-64", + "timestamp": 1569442068984, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0,<3.0", + "python >=3.7,<3.8.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3198c29f387f65a7daa1548dfd67cdff", + "name": "tornado-json", + "sha256": "054ad86714db85a225e15560df69f36185288055a1dec4140f5cab11a04d3265", + "size": 244442, + "subdir": "linux-64", + "timestamp": 1613038666020, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "jsonschema >=2.3.0", + "python >=3.7,<3.8.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbcc7bea25e5f5dc89eac016d24b1364", + "name": "tornado-json", + "sha256": "99cc53dc4fa61029399046a49134ba84ad21bc65b6c6188319dae551430fb6a1", + "size": 248074, + "subdir": "linux-64", + "timestamp": 1613996910677, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0,<3.0", + "python >=3.8,<3.9.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff16302fdbf09405888bac11df0015e6", + "name": "tornado-json", + "sha256": "820e4c668c4c902ca118d9928a11873fa4a32fb774fe7f028790c4e70af46eb9", + "size": 27515, + "subdir": "linux-64", + "timestamp": 1574412742590, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "jsonschema >=2.3.0", + "python >=3.8,<3.9.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b48dba9542dd6d6f3389c8630d1ef11", + "name": "tornado-json", + "sha256": "4ed83829cfe39cf2a340c0605d5962a42e6f83e43c9a4d988f5e0332f59e63d4", + "size": 251376, + "subdir": "linux-64", + "timestamp": 1613997746765, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "jsonschema >=2.3.0", + "python >=3.9,<3.10.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2d598b804ac1544fc374332f2472117", + "name": "tornado-json", + "sha256": "5852d5c6ce4e88b1cf9a01739bc173c7fd77bcc140b6123962667faf35356725", + "size": 248061, + "subdir": "linux-64", + "timestamp": 1613997747955, + "version": "1.3.4" + }, + "toro-1.0.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8255a4cd929c94d893c6d45dbb9b3403", + "name": "toro", + "sha256": "4e91c04b4f436df2ff6b0f71a39dc2534cf69ca487e5162325badc83198abc00", + "size": 18828, + "subdir": "linux-64", + "timestamp": 1539184250708, + "version": "1.0.1" + }, + "toro-1.0.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2dddddcc933122aeb927229b8f7c19f1", + "name": "toro", + "sha256": "434cade523cb0d99a4325584d593b289a983df0e2002c398c58132d231b1c0b0", + "size": 19719, + "subdir": "linux-64", + "timestamp": 1641557858664, + "version": "1.0.1" + }, + "toro-1.0.1-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6ef2d33c46a5ab48a4045df146c695ff", + "name": "toro", + "sha256": "36e9e6445ef298faef76a5058166eaf55fbc9b38c468e52cee6d299a3a2a74eb", + "size": 22214, + "subdir": "linux-64", + "timestamp": 1646746009555, + "version": "1.0.1" + }, + "toro-1.0.1-py311h06a4308_2.tar.bz2": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "72636c689029d8b301b569525c64eb7d", + "name": "toro", + "sha256": "db2a6d24729fc93166b39d2100534814827be5f89890e55345b90fc89c35fc8a", + "size": 26894, + "subdir": "linux-64", + "timestamp": 1676863279885, + "version": "1.0.1" + }, + "toro-1.0.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "849541fb6839f0f4832367da92efbe89", + "name": "toro", + "sha256": "e6c9eba34223573994efadde78d2d2a15c603a695ca3b4aedaef82b46dca8a0b", + "size": 19457, + "subdir": "linux-64", + "timestamp": 1539184263472, + "version": "1.0.1" + }, + "toro-1.0.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "97b716131c18f07042e2f3923d81c5df", + "name": "toro", + "sha256": "52209999488a01dc856348bc580699d39ba13c38e5d92478a3b7a273be77546c", + "size": 20343, + "subdir": "linux-64", + "timestamp": 1614066244343, + "version": "1.0.1" + }, + "toro-1.0.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e87d3c9f7dfadea86a2ee56ce6fba89b", + "name": "toro", + "sha256": "cc6655319b53fd664a5ba78001f9273d200bbf76ebb81cd7123f0cee51dd9799", + "size": 19527, + "subdir": "linux-64", + "timestamp": 1539184273283, + "version": "1.0.1" + }, + "toro-1.0.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f8012f7e31abaf298abd84fa3bb7f9ce", + "name": "toro", + "sha256": "bec9eacf7f7eb32692e4db4b38f2d243716dc2bef1a5747b51f019b2499c2b5b", + "size": 20376, + "subdir": "linux-64", + "timestamp": 1614066231281, + "version": "1.0.1" + }, + "toro-1.0.1-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "09d8aa5f27bca14a6de1aa75f4bb3143", + "name": "toro", + "sha256": "b89e9227d879366fec8f0ee43a6a14ceed061f54c7aaec1211a74d1017c93fcd", + "size": 21952, + "subdir": "linux-64", + "timestamp": 1646745947818, + "version": "1.0.1" + }, + "toro-1.0.1-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2aa926ab93d41a492b80fdf110145084", + "name": "toro", + "sha256": "2f4b4a190c7bdc1d562ebd61d9a02ff74c1f2788d980e75f4adb1c4428da9c21", + "size": 19805, + "subdir": "linux-64", + "timestamp": 1573554815585, + "version": "1.0.1" + }, + "toro-1.0.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "65f9bbe032509f0886dd3cf56219a1b8", + "name": "toro", + "sha256": "d2a53928c4513bcfc8bff78f1b7015c8e849f0a800b73d4403299ea64c6464cd", + "size": 20466, + "subdir": "linux-64", + "timestamp": 1614066240324, + "version": "1.0.1" + }, + "toro-1.0.1-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "181ca4fedb355e09b83f466022d1c9fa", + "name": "toro", + "sha256": "04f5e29b451d947b9fbe521f04f31b4f80d637a9d9fe6485287d39a84fe6bfed", + "size": 22079, + "subdir": "linux-64", + "timestamp": 1646745907598, + "version": "1.0.1" + }, + "toro-1.0.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "27807ac44f6d9349baf3f7a6d2da0248", + "name": "toro", + "sha256": "188cbd490f38ddf074130255cb0102c8b05d8f6563a16f7d1a36262be72f7073", + "size": 20437, + "subdir": "linux-64", + "timestamp": 1614065626619, + "version": "1.0.1" + }, + "toro-1.0.1-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0fe060bf2669e31d38a093095bba65e1", + "name": "toro", + "sha256": "7a85eae837007fe4f259064c38474d05dfe8da2c34aab43a767999d5674efaef", + "size": 21984, + "subdir": "linux-64", + "timestamp": 1646745868764, + "version": "1.0.1" + }, + "tqdm-4.19.2-py27hba956de_0.tar.bz2": { + "build": "py27hba956de_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "5589951e4659694c59f03671db5c76c2", + "name": "tqdm", + "sha256": "4279e2de738982f2c91e2b8d39347b9e015c8589d03c152fe702f2a8c2eb09d5", + "size": 53715, + "subdir": "linux-64", + "timestamp": 1507832464217, + "version": "4.19.2" + }, + "tqdm-4.19.2-py35h6552237_0.tar.bz2": { + "build": "py35h6552237_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "41c67825e6ec9a227277660ea13b1eb4", + "name": "tqdm", + "sha256": "762355ee0c6426564517c8a3478504413dc003955a6bb5b3a10a18c9d3240c4a", + "size": 54351, + "subdir": "linux-64", + "timestamp": 1507832464701, + "version": "4.19.2" + }, + "tqdm-4.19.2-py36ha9864ad_0.tar.bz2": { + "build": "py36ha9864ad_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "6963f6f708863e8129e7e25a8b47904f", + "name": "tqdm", + "sha256": "14721b19ec95bdb2725ff4ef543e7da06761b6e01cc94cd45203da4471dab265", + "size": 54233, + "subdir": "linux-64", + "timestamp": 1507832460691, + "version": "4.19.2" + }, + "tqdm-4.19.4-py27hdfef72e_0.tar.bz2": { + "build": "py27hdfef72e_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "7c675d3ef2b9d37e40685c08f5223113", + "name": "tqdm", + "sha256": "377b4a44a575fed757d2311a7de90000066fc3a03a50ae5da25db7bd2ccc1c77", + "size": 53497, + "subdir": "linux-64", + "timestamp": 1508915658908, + "version": "4.19.4" + }, + "tqdm-4.19.4-py35h68e51d2_0.tar.bz2": { + "build": "py35h68e51d2_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "2ce005a41538fa38aebf5a63ae5259c5", + "name": "tqdm", + "sha256": "77e8859a37bc71e0fc4e314653622ba5b6c039815849c0e104f1bc5fd08597fc", + "size": 54250, + "subdir": "linux-64", + "timestamp": 1508915660104, + "version": "4.19.4" + }, + "tqdm-4.19.4-py36ha5a5176_0.tar.bz2": { + "build": "py36ha5a5176_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "2283d9ceb5eb20b6769dfa6c7caab374", + "name": "tqdm", + "sha256": "3dec855ae037bf062c8a956021b80148d0b6a0a1b9ab0d071137f244df1a6bbb", + "size": 54161, + "subdir": "linux-64", + "timestamp": 1508915678515, + "version": "4.19.4" + }, + "tqdm-4.19.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "93557391b762b296d24bfd9c1969d52a", + "name": "tqdm", + "sha256": "0f7cf1422cc5fae8a9facc045f5dc7d8a8781338882b4c1c89bac915cc2bb6f6", + "size": 53698, + "subdir": "linux-64", + "timestamp": 1519755106380, + "version": "4.19.5" + }, + "tqdm-4.19.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "7f1e4684e456147b8bf6996bac59603a", + "name": "tqdm", + "sha256": "289f0971b9d5994e78dffae103860d62b9cc2c0ae660a6c077ef0b69fcbbb16a", + "size": 54436, + "subdir": "linux-64", + "timestamp": 1519755119945, + "version": "4.19.5" + }, + "tqdm-4.19.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "c61f026acb79f718186fbd9526b5a18c", + "name": "tqdm", + "sha256": "15841dff99f4597b78a4cb365af3a3c39e4ff103a6311ca830d0ccb46b449d70", + "size": 54325, + "subdir": "linux-64", + "timestamp": 1519755084101, + "version": "4.19.5" + }, + "tqdm-4.19.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "36f00a2edca4cc4d16e05c1d040d53b3", + "name": "tqdm", + "sha256": "086f1b4338d5622ccb0143d77f3b04738378d147232943b59fe75a6109c21d83", + "size": 55218, + "subdir": "linux-64", + "timestamp": 1522195971945, + "version": "4.19.8" + }, + "tqdm-4.19.8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "6aefe8d0d22702a6c11939d7141b8725", + "name": "tqdm", + "sha256": "1d3eb5a9915a747a667f9f689c761a245c5e3d82ce565ab174ca4d7943a9d6fc", + "size": 55991, + "subdir": "linux-64", + "timestamp": 1522197082166, + "version": "4.19.8" + }, + "tqdm-4.19.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "92821d39a68f4298eb6dc55a66069376", + "name": "tqdm", + "sha256": "fec32696a68ee5399071c00f98915f11ff7040adc527027f8f1320966229140f", + "size": 55876, + "subdir": "linux-64", + "timestamp": 1522196032332, + "version": "4.19.8" + }, + "tqdm-4.19.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "d360c40e75039f74e5b6b4753fa6e4f9", + "name": "tqdm", + "sha256": "b168ad119b087720b8cdaba17012dd9f296305c31d2bfe668a1db819c4222bef", + "size": 55283, + "subdir": "linux-64", + "timestamp": 1522696575450, + "version": "4.19.9" + }, + "tqdm-4.19.9-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "fbd011c1e5c92413a15669b843ed2e3d", + "name": "tqdm", + "sha256": "86f8b6af9e757e9cba30728b85425f8a6e52a01033989b1399d0227826b489ad", + "size": 56043, + "subdir": "linux-64", + "timestamp": 1522696586515, + "version": "4.19.9" + }, + "tqdm-4.19.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "93caf9eb552904da66cbae5d9bf1a1fa", + "name": "tqdm", + "sha256": "2a3efeacce0276c16b48c2617eac1b1cf4fae17c9ff64348bafc15469d4e6a1f", + "size": 55953, + "subdir": "linux-64", + "timestamp": 1522696585369, + "version": "4.19.9" + }, + "tqdm-4.23.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "6e828adca7d3c90a811b83475fa37978", + "name": "tqdm", + "sha256": "c0fb0da7ecefdfe7aeb6ccd30463265afff97f03711e4a8084a8291432057688", + "size": 57142, + "subdir": "linux-64", + "timestamp": 1523983516269, + "version": "4.23.0" + }, + "tqdm-4.23.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "a0b05f4c058d44e2c5141aebf98b122b", + "name": "tqdm", + "sha256": "c7b99d7023d03659187744f4feeef85e631fc0a4b44bc73f363b9d9926854d57", + "size": 57967, + "subdir": "linux-64", + "timestamp": 1523983518082, + "version": "4.23.0" + }, + "tqdm-4.23.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "2400071445d684cc8d333b37f17cfc50", + "name": "tqdm", + "sha256": "075b2b51f29809c197b081ecfe409c13a2c2c7104b9fc0a9db2bee037a01cd70", + "size": 57855, + "subdir": "linux-64", + "timestamp": 1523983519979, + "version": "4.23.0" + }, + "tqdm-4.23.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "29b1a015d0dbd2e80b114445b06df8b7", + "name": "tqdm", + "sha256": "fd397959722decfc8a233d7e8229bd1de4f1a676898c9a9e9f0fdbbc597998d6", + "size": 58215, + "subdir": "linux-64", + "timestamp": 1526915319761, + "version": "4.23.3" + }, + "tqdm-4.23.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "f8e91bc176d91e84f553c474642214c8", + "name": "tqdm", + "sha256": "40fe594de6fe74b631d5a8262b1b5ef232d5057d6da5020520c2abba5c215284", + "size": 58998, + "subdir": "linux-64", + "timestamp": 1526915333733, + "version": "4.23.3" + }, + "tqdm-4.23.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "77827d4cc0ab5e5bf16ed97640945936", + "name": "tqdm", + "sha256": "6f9d3ce18d9f25513ccd3952417bc788584515274c35fb9556886235599927aa", + "size": 58901, + "subdir": "linux-64", + "timestamp": 1526915260745, + "version": "4.23.3" + }, + "tqdm-4.23.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "6d3f45d5b45e3bac97147d16f693e48e", + "name": "tqdm", + "sha256": "159ef8e537e912e188e237af096fb179e69730b76d448a01fbe5d5b9c97f8c1d", + "size": 58893, + "subdir": "linux-64", + "timestamp": 1530917248874, + "version": "4.23.3" + }, + "tqdm-4.23.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "b402f9a8a408436ab98efd1b5ae26930", + "name": "tqdm", + "sha256": "c1303c7c172adf9e86588eee3dad6ac98125bf4880390e3d7dfbc2b4c0a4dc22", + "size": 58300, + "subdir": "linux-64", + "timestamp": 1527629543055, + "version": "4.23.4" + }, + "tqdm-4.23.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "4bd1e8e49525cd8129670f7739f63c8a", + "name": "tqdm", + "sha256": "df1251b6411d3654a73e3443c8f7649662a05ddd007c04e733b9a3f03d26575e", + "size": 59085, + "subdir": "linux-64", + "timestamp": 1527629604753, + "version": "4.23.4" + }, + "tqdm-4.23.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "5bba2591f781a69065f9df22d415e5bf", + "name": "tqdm", + "sha256": "02c632b187533e457a5407804ba376b369815d97e6c12be7ca39ec89b33e103c", + "size": 58985, + "subdir": "linux-64", + "timestamp": 1527629552164, + "version": "4.23.4" + }, + "tqdm-4.24.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "2b2cdfb9e2737f91fd3b276538aa073a", + "name": "tqdm", + "sha256": "4a3b6cb0e258555e90cc5faeda801d68431b54187f280173c0bb742ce4faa92f", + "size": 58554, + "subdir": "linux-64", + "timestamp": 1532994116122, + "version": "4.24.0" + }, + "tqdm-4.24.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "2160a7209fe97bf4fb683bac07955567", + "name": "tqdm", + "sha256": "46a49193087f0e7e36b8be4030a77cea71d038a48f286fabc95e82391e6aed2a", + "size": 59284, + "subdir": "linux-64", + "timestamp": 1532994210796, + "version": "4.24.0" + }, + "tqdm-4.24.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "f0a1f410d3ab1e843d0a316875c7a4c1", + "name": "tqdm", + "sha256": "4c5d3b618cdd357d36203002104032152f2d560cbd1ed4eb813ab2c1bca420bc", + "size": 59186, + "subdir": "linux-64", + "timestamp": 1532994132965, + "version": "4.24.0" + }, + "tqdm-4.24.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "92543b0dd112e20062268da8f2c8dd23", + "name": "tqdm", + "sha256": "de9cc36802d31a77669e9fa301f86c5ac8d326f01dc8b5f8b636d4ab4f213413", + "size": 59140, + "subdir": "linux-64", + "timestamp": 1532994149491, + "version": "4.24.0" + }, + "tqdm-4.25.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "9a074d4c01d6d0a4638e126596e99036", + "name": "tqdm", + "sha256": "c5ca248275063fbba86419e6ad2bc9823c78998d3f347a8034bcae3382aac5ca", + "size": 58406, + "subdir": "linux-64", + "timestamp": 1534794951421, + "version": "4.25.0" + }, + "tqdm-4.25.0-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "708491dc58b77ec3787eebd225a1f05f", + "name": "tqdm", + "sha256": "cdd9cdb79ec03f7193bbd643993c2e6ff54cf0754db1646f8d8d7c1bc68cd468", + "size": 59224, + "subdir": "linux-64", + "timestamp": 1534794967230, + "version": "4.25.0" + }, + "tqdm-4.25.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "c6a85e9f5f7f91113d23c3c29aebcfa7", + "name": "tqdm", + "sha256": "cde186feba35cc12119590c80c9ce411fd826c622bc2ad5f27666a73c737c087", + "size": 59163, + "subdir": "linux-64", + "timestamp": 1534794924783, + "version": "4.25.0" + }, + "tqdm-4.25.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "570c479252dd92fad14fc2d2f648de37", + "name": "tqdm", + "sha256": "0153a8d3c56e2974e219bdeccd4ae2e5d1cd01db3cd43bb2a74e3572b492db19", + "size": 59107, + "subdir": "linux-64", + "timestamp": 1534795095638, + "version": "4.25.0" + }, + "tqdm-4.26.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "1910fc921d3777b529c2eaaa400d60f0", + "name": "tqdm", + "sha256": "186432ba52d0045aed2abe2c44755de581f555eb1abc4b57b52b2c14a2ee3f49", + "size": 59572, + "subdir": "linux-64", + "timestamp": 1537471364978, + "version": "4.26.0" + }, + "tqdm-4.26.0-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "cb83793e2aca8bbdbac035c72d597c4d", + "name": "tqdm", + "sha256": "fbd027b72506bf90e6ca562c76a78e47d1f8a833be5c67ead6e4b021252521e6", + "size": 60374, + "subdir": "linux-64", + "timestamp": 1537471395729, + "version": "4.26.0" + }, + "tqdm-4.26.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "1dafd7081c5ffb74f3e0f00f5666816e", + "name": "tqdm", + "sha256": "40817cd99aa478e1b1ad5198757eee321db5bd988f184546c27bd1d533b54d93", + "size": 60322, + "subdir": "linux-64", + "timestamp": 1537471381146, + "version": "4.26.0" + }, + "tqdm-4.26.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "852211116528a9c256aa1de6a43872d8", + "name": "tqdm", + "sha256": "c650f5dbdd65bc0a2960aacc8323152d1aaed6e86b269e1691998cf851b02a28", + "size": 60202, + "subdir": "linux-64", + "timestamp": 1537471324858, + "version": "4.26.0" + }, + "tqdm-4.28.1-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "5e8c61a9001711e3c7390d107ba769c1", + "name": "tqdm", + "sha256": "08532cd288642bbb4306f78e9099d180a82ad5b062419a5a756615f8d719e33a", + "size": 61492, + "subdir": "linux-64", + "timestamp": 1541054637155, + "version": "4.28.1" + }, + "tqdm-4.28.1-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "7616b3547ac193c09a1fbf83af614512", + "name": "tqdm", + "sha256": "28b4cfa4050a2f0074222e365c8cbc78c8d8b06c35515948606a227417d5ee92", + "size": 62222, + "subdir": "linux-64", + "timestamp": 1541054668558, + "version": "4.28.1" + }, + "tqdm-4.28.1-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "069152f121d20b1813c417d7a4d550a2", + "name": "tqdm", + "sha256": "189348524b4fc444b5f67d4e3c7179adcbb8f56c0b98f829c2ef426db92ea50e", + "size": 62087, + "subdir": "linux-64", + "timestamp": 1541054644286, + "version": "4.28.1" + }, + "tqdm-4.31.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "56212fa6bea1aeba63d85eee3d1ee730", + "name": "tqdm", + "sha256": "1e457be8d8b363fa06f11e0404b85a3f109aa305031ee23d88355ff44d0d9ea7", + "size": 70280, + "subdir": "linux-64", + "timestamp": 1553291144630, + "version": "4.31.1" + }, + "tqdm-4.31.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "8adf85dd77c697b8278e1f15d633e93e", + "name": "tqdm", + "sha256": "e98c932e080a42d55dcadc9bfd3449dd5700bd7fdbf125fe0b145c3f0ea4bf62", + "size": 71007, + "subdir": "linux-64", + "timestamp": 1553291327820, + "version": "4.31.1" + }, + "tqdm-4.31.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "814528f31dec0450e8622e93842010fb", + "name": "tqdm", + "sha256": "c667cfa9fcebfedf377f1d3c7139ea9ac0238678bacbbd9803a6f17ab8e3284a", + "size": 71072, + "subdir": "linux-64", + "timestamp": 1553291180198, + "version": "4.31.1" + }, + "tqdm-4.64.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "70d0f1aabeaeddfd3dce90bc59e0d19d", + "name": "tqdm", + "sha256": "7898423b77e6efa17ced300e2f63b76f850c67b7ddfe68a26c29e467ec3b0ddc", + "size": 125975, + "subdir": "linux-64", + "timestamp": 1650891128591, + "version": "4.64.0" + }, + "tqdm-4.64.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "bc75686a9a0ed23f932aeaa8a0e2c7be", + "name": "tqdm", + "sha256": "ad9e1bdafad0ab901d80e833c65a92d460fdacbd81b64e2dcc486c99abb9cdc9", + "size": 154276, + "subdir": "linux-64", + "timestamp": 1676827550361, + "version": "4.64.0" + }, + "tqdm-4.64.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "5b2934c5e9b89652a6e4ba3a71740795", + "name": "tqdm", + "sha256": "af329f3c315640350bd0dbeb158b5d6e10e88568356a10b89a812ea7ecdd97a7", + "size": 124413, + "subdir": "linux-64", + "timestamp": 1650891158490, + "version": "4.64.0" + }, + "tqdm-4.64.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "3eaedd95d8f1abc88049c9dd57b78f75", + "name": "tqdm", + "sha256": "72a351ab03e1aae8d082047188810a7c86f2b1feeb18f355fa3abafd3c49be6b", + "size": 124830, + "subdir": "linux-64", + "timestamp": 1650891221480, + "version": "4.64.0" + }, + "tqdm-4.64.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "d06d129f5aef397b3437e691ad7c8770", + "name": "tqdm", + "sha256": "01bf466c21f8a2cfef7ad734c8505e9e21a8e1bc25d6b31e9c1cd3efd4c5c054", + "size": 125111, + "subdir": "linux-64", + "timestamp": 1650891189657, + "version": "4.64.0" + }, + "tqdm-4.64.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "6352f8e6ec03e6dadff4a7d47793c50a", + "name": "tqdm", + "sha256": "123949959a56a164ea0021992ec7d3a4396053a47604c3a0ac594d5bc22a0570", + "size": 126019, + "subdir": "linux-64", + "timestamp": 1664392845255, + "version": "4.64.1" + }, + "tqdm-4.64.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "c1674135cad855c2d929142d54992b33", + "name": "tqdm", + "sha256": "21a16ef5eeb6292e2c0896372f0efce24b7808b96b466edb4921b85e844f083b", + "size": 154072, + "subdir": "linux-64", + "timestamp": 1679339403752, + "version": "4.64.1" + }, + "tqdm-4.64.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "8e9357f3dc1f4227280880c456c44aca", + "name": "tqdm", + "sha256": "5dc536fbf7520841c28bfa8748f848267ea57239dd146dcb4962ffb87e27180b", + "size": 124556, + "subdir": "linux-64", + "timestamp": 1664392760650, + "version": "4.64.1" + }, + "tqdm-4.64.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "33f950641fe205338953b2df255180cb", + "name": "tqdm", + "sha256": "17797010901b53584f08ab8c7e058d5d50d643df0a4fc77234e8ec820a447d2b", + "size": 124885, + "subdir": "linux-64", + "timestamp": 1664392725664, + "version": "4.64.1" + }, + "tqdm-4.64.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "c02133a1b4cad3cda61efa7eced75442", + "name": "tqdm", + "sha256": "a870238eff14c9fdeabb58061d64d0e6a022b38ea0f2c322e1414880baa83162", + "size": 125036, + "subdir": "linux-64", + "timestamp": 1664392798362, + "version": "4.64.1" + }, + "tqdm-4.65.0-py310h2f386ee_0.tar.bz2": { + "build": "py310h2f386ee_0", + "build_number": 0, + "constrains": [ + "ipywidgets >=6", + "requests", + "slack-sdk" + ], + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "8db7239ae56fe0026c80a98aea04691b", + "name": "tqdm", + "sha256": "a30a5199c6949d7bf07df14ac82f75eaada108f7d0b379442c538cf7fb660406", + "size": 124632, + "subdir": "linux-64", + "timestamp": 1679561970726, + "version": "4.65.0" + }, + "tqdm-4.65.0-py311h92b7b1e_0.tar.bz2": { + "build": "py311h92b7b1e_0", + "build_number": 0, + "constrains": [ + "ipywidgets >=6", + "requests", + "slack-sdk" + ], + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "a94778a1fa3ad0ce3774751f4786fe55", + "name": "tqdm", + "sha256": "948846e5f3f49dba2e5d33b73deb0dc6db17656ffd3d5a55d35c3dcefea248d0", + "size": 152015, + "subdir": "linux-64", + "timestamp": 1679562095911, + "version": "4.65.0" + }, + "tqdm-4.65.0-py38hb070fc8_0.tar.bz2": { + "build": "py38hb070fc8_0", + "build_number": 0, + "constrains": [ + "ipywidgets >=6", + "requests", + "slack-sdk" + ], + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "0769c92607812f43d1b10fdff177e247", + "name": "tqdm", + "sha256": "effd1650a61f827fe737a963c6b2463b3710bcde3ff32908cca3b3617064b3aa", + "size": 123487, + "subdir": "linux-64", + "timestamp": 1679562034657, + "version": "4.65.0" + }, + "tqdm-4.65.0-py39hb070fc8_0.tar.bz2": { + "build": "py39hb070fc8_0", + "build_number": 0, + "constrains": [ + "ipywidgets >=6", + "requests", + "slack-sdk" + ], + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "67a8320961ff24e92eebb661536e5cf7", + "name": "tqdm", + "sha256": "89473ae25cda1917882fdf204887ab7138ac7ea72c2519248425872f422c5971", + "size": 123763, + "subdir": "linux-64", + "timestamp": 1679561904852, + "version": "4.65.0" + }, + "traceback2-1.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "f81611a9f317980468523faf708e212e", + "name": "traceback2", + "sha256": "703e640a8837e6bc38e20f8b3770ed00f4b54ecb6da1eea7ca164486d68cfe47", + "size": 31134, + "subdir": "linux-64", + "timestamp": 1530898793095, + "version": "1.4.0" + }, + "traceback2-1.4.0-py27h153c7c5_0.tar.bz2": { + "build": "py27h153c7c5_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "cd88013f4662b0a018589769621c747f", + "name": "traceback2", + "sha256": "50d3f43aea21e01d8ff910086d123212b5ff9761acc1f4311d3f2cc8d7d1b1a6", + "size": 31487, + "subdir": "linux-64", + "timestamp": 1508304257948, + "version": "1.4.0" + }, + "traceback2-1.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "3ea2a727e7c14f085b5895923db7af0d", + "name": "traceback2", + "sha256": "7ec70af05cac23f96438c3b29c41cca4f3ff207ad46b96f2428da9f8d255422d", + "size": 32621, + "subdir": "linux-64", + "timestamp": 1642511154158, + "version": "1.4.0" + }, + "traceback2-1.4.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "cef0f7f30fa1e342e7300deb4e624f8d", + "name": "traceback2", + "sha256": "16927adb8d592184514a2d208baf9c8666aa6b20d7deb3d932be1878ee1d6fd0", + "size": 43848, + "subdir": "linux-64", + "timestamp": 1676863295275, + "version": "1.4.0" + }, + "traceback2-1.4.0-py35hb87e97a_0.tar.bz2": { + "build": "py35hb87e97a_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "47ae41f9f056fa78e2736ab4f38fe5c4", + "name": "traceback2", + "sha256": "ad7e1f94bacab5873f80a0ab4742485c7ecb89f8901eaf061698b24723ab2829", + "size": 32272, + "subdir": "linux-64", + "timestamp": 1508304260959, + "version": "1.4.0" + }, + "traceback2-1.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "d1dc0d8bd9c6f7cf7ea66d6f8e0858f8", + "name": "traceback2", + "sha256": "715257b5622246d06b2cb281602c14537d51f1c5a44dcb13d83cfe743aa585a2", + "size": 31816, + "subdir": "linux-64", + "timestamp": 1530898848965, + "version": "1.4.0" + }, + "traceback2-1.4.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "8007d08345ba7ed6d4c84a390a170748", + "name": "traceback2", + "sha256": "097daa49d2ecac2a2a5a305d6b2c41a3b2d7dd81f5e5787048d676f94de36290", + "size": 32740, + "subdir": "linux-64", + "timestamp": 1632756988587, + "version": "1.4.0" + }, + "traceback2-1.4.0-py36h3ec00f9_0.tar.bz2": { + "build": "py36h3ec00f9_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "ea173851c19f34962bb8c85545ea36ab", + "name": "traceback2", + "sha256": "425d60024c9f44be17add3f3dab2bade22a92b0eb24c59af948d89ba0040286c", + "size": 32187, + "subdir": "linux-64", + "timestamp": 1508304255644, + "version": "1.4.0" + }, + "traceback2-1.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "9a439f37a859fd70b83312df7cc7835b", + "name": "traceback2", + "sha256": "a4abb253bfaa71e7b59a392453f16c5c6772c4e601345085825a8e8b0fec9f72", + "size": 31835, + "subdir": "linux-64", + "timestamp": 1530898820655, + "version": "1.4.0" + }, + "traceback2-1.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "11dff659d79bde8b6854bf5d2bb9754c", + "name": "traceback2", + "sha256": "6dfc64a1f6617c438d99a978b2b78132da48d76b15497b7b6c282657a7cfdfa1", + "size": 32791, + "subdir": "linux-64", + "timestamp": 1632752281557, + "version": "1.4.0" + }, + "traceback2-1.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "c93705602c39f9201fbd33e59502c883", + "name": "traceback2", + "sha256": "d0d22aa2280b397137c7ee7339a2f1b5642309f487a8b4b0b8b6cd4ee282e8e1", + "size": 32595, + "subdir": "linux-64", + "timestamp": 1573554831627, + "version": "1.4.0" + }, + "traceback2-1.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "e4505cbee813cc40935e729525386ae2", + "name": "traceback2", + "sha256": "fda4b353bc98b6a1d68bc9b4d5ea845f280b6dec07269cb252fcdbf92ce9451c", + "size": 33047, + "subdir": "linux-64", + "timestamp": 1632756887100, + "version": "1.4.0" + }, + "traceback2-1.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "85d69ef981cb57baf3164d19c53900a6", + "name": "traceback2", + "sha256": "07f79e1832c3335eeb4170cf9cd218b326ccdb50583423af0bb47435a8a4856f", + "size": 33101, + "subdir": "linux-64", + "timestamp": 1632756964699, + "version": "1.4.0" + }, + "traitlets-4.3.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator", + "enum34", + "ipython_genutils", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-clause", + "md5": "eaae1501a6c3ec38686585b38cffb17e", + "name": "traitlets", + "sha256": "bce7493d08be7703b8c7a1c8cec13a4f7723c91246a8dabad14f64cce268c576", + "size": 130781, + "subdir": "linux-64", + "timestamp": 1530694397034, + "version": "4.3.2" + }, + "traitlets-4.3.2-py27hd6ce930_0.tar.bz2": { + "build": "py27hd6ce930_0", + "build_number": 0, + "depends": [ + "decorator", + "enum34", + "ipython_genutils", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-clause", + "md5": "608b5d2a4eaf7d6914a968e43559a697", + "name": "traitlets", + "sha256": "21faba82272207f6f55e39cf226933c63721a01bbdd1473c99fdf31a8ac77cfa", + "size": 128824, + "subdir": "linux-64", + "timestamp": 1505672115044, + "version": "4.3.2" + }, + "traitlets-4.3.2-py35ha522a97_0.tar.bz2": { + "build": "py35ha522a97_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-clause", + "md5": "7d40fb1b8ccb9db0766aac3ec466673a", + "name": "traitlets", + "sha256": "382402e4d7e1c268f616071978e5993f71066bc195063b1b958b75d525debca8", + "size": 134648, + "subdir": "linux-64", + "timestamp": 1505672128737, + "version": "4.3.2" + }, + "traitlets-4.3.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-clause", + "md5": "1a76202abdf1380529fd92d3dfabb1a8", + "name": "traitlets", + "sha256": "8c9199df12d4e8bc1ada8b6f6bfb0be37b2a1dc0e56e6a83e3e3611b424eb36d", + "size": 135865, + "subdir": "linux-64", + "timestamp": 1530694354888, + "version": "4.3.2" + }, + "traitlets-4.3.2-py36h674d592_0.tar.bz2": { + "build": "py36h674d592_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-clause", + "md5": "162155efee546ec07a9b10acaefb8b90", + "name": "traitlets", + "sha256": "a4c619d68abafa03df3f12d4b050fe72578dd5ead84577bb9f10165b014b2e22", + "size": 134101, + "subdir": "linux-64", + "timestamp": 1505672142545, + "version": "4.3.2" + }, + "traitlets-4.3.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-clause", + "md5": "5d95f644e073d043240d2cbf3b642755", + "name": "traitlets", + "sha256": "036d8a375532d50ebfbf633f23854ead09f2d37c37c2dc5f7e7d29cc57d8ab10", + "size": 135895, + "subdir": "linux-64", + "timestamp": 1530694376494, + "version": "4.3.2" + }, + "traitlets-4.3.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator", + "enum34", + "ipython_genutils", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "bd198ad0eea1c36ee0f4a03609f1bf4c", + "name": "traitlets", + "sha256": "d5c941ab8f212803f47264ec048f6b8a582a1cea7cbc87719258baa542b12eea", + "size": 135543, + "subdir": "linux-64", + "timestamp": 1570464061848, + "version": "4.3.3" + }, + "traitlets-4.3.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "44b52bb016a744d011d96b8dd9bed2c5", + "name": "traitlets", + "sha256": "8960d40a616b206f21e136d2c89e86b915e047f73970306c0588bdf0af1a1e42", + "size": 140728, + "subdir": "linux-64", + "timestamp": 1570464062639, + "version": "4.3.3" + }, + "traitlets-4.3.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "554e5cd61892d4aaa06905f7ac3ad22d", + "name": "traitlets", + "sha256": "c697127f479e715ff89c933ba9496d056f24f16341cbcf8ac636db64d355b352", + "size": 140839, + "subdir": "linux-64", + "timestamp": 1632746557055, + "version": "4.3.3" + }, + "traitlets-4.3.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "1e31d870dd09f8f0f93d567b164467ec", + "name": "traitlets", + "sha256": "61e899ad429fb527719d0ad63148ddda59b3d4cd7e350939baf5bbad6a3736af", + "size": 140817, + "subdir": "linux-64", + "timestamp": 1570464067737, + "version": "4.3.3" + }, + "traitlets-4.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "e3b418e2542934831cee9465f66174a6", + "name": "traitlets", + "sha256": "16ad409287fe12a7a274ca930731fcb5530abe93d1cabf2743cda0f18749a967", + "size": 140779, + "subdir": "linux-64", + "timestamp": 1632756915266, + "version": "4.3.3" + }, + "traitlets-4.3.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "ef208a9f484936f07b25a0b0ced0bb71", + "name": "traitlets", + "sha256": "9038bd4f4e31f3b312b3387f69e12e1aaa30737e28b0f8ddfcefcc72e110a526", + "size": 138000, + "subdir": "linux-64", + "timestamp": 1573554848366, + "version": "4.3.3" + }, + "traitlets-4.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "e961c8d5b6d81785e0238abf27d7b0b8", + "name": "traitlets", + "sha256": "ec1abf3b6fc68ebe1da87be1b9c3f0ec97211efb1ef1a7e37018e4ed355a6c4b", + "size": 141392, + "subdir": "linux-64", + "timestamp": 1632756972899, + "version": "4.3.3" + }, + "traitlets-4.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "80499bcbb7025f0b16223c9e1169c593", + "name": "traitlets", + "sha256": "d8da0990cf94126056a7fe9ef9f343c731b4f4008ec1b1dcb2a0db0a52a6bbd2", + "size": 141755, + "subdir": "linux-64", + "timestamp": 1632756916362, + "version": "4.3.3" + }, + "traitlets-5.0.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipython_genutils", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d9bd41f2523e1a3e172f2e05def51b85", + "name": "traitlets", + "sha256": "d9ee68a828bdeaeec9b1a421e340624409f5e169af059e002bb912df40304567", + "size": 177014, + "subdir": "linux-64", + "timestamp": 1600712423494, + "version": "5.0.4" + }, + "traitlets-5.7.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fc14d3692ef44fee5d3b267adbf97c74", + "name": "traitlets", + "sha256": "82014300af56f45295fd7bbe0a21919ddae0a720f4725a40db456d8d74d8e2fd", + "size": 194158, + "subdir": "linux-64", + "timestamp": 1671143967706, + "version": "5.7.1" + }, + "traitlets-5.7.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f2c25e5dfdd23f70b83776a8832893cf", + "name": "traitlets", + "sha256": "0575785f6553e61cc6138abfd5de52305fac6f85971642fa1f056a76c66a52b2", + "size": 270865, + "subdir": "linux-64", + "timestamp": 1676823316868, + "version": "5.7.1" + }, + "traitlets-5.7.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "12f1d27b4a077f90aebd20d32936c0da", + "name": "traitlets", + "sha256": "8feee9c60fa4f47a3b750822902b365afe385076b5457da7867b8d63f510344a", + "size": 190996, + "subdir": "linux-64", + "timestamp": 1671143912609, + "version": "5.7.1" + }, + "traitlets-5.7.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "329270e6ef807c97c1141afdb85113fe", + "name": "traitlets", + "sha256": "235a049eda3efc73e47d54c57d3bd1567008e5b9b1b9aed4d72d800c217d77fa", + "size": 191687, + "subdir": "linux-64", + "timestamp": 1671143939929, + "version": "5.7.1" + }, + "traitlets-5.7.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0f0b91a158dd3692cbb7a7763b657bfe", + "name": "traitlets", + "sha256": "cf64b9ca6e05ac898d0a14973a4492e6bfbf02023d3bb0971335e3e73888e37f", + "size": 192032, + "subdir": "linux-64", + "timestamp": 1671143995098, + "version": "5.7.1" + }, + "traits-4.6.0-py27h14c3975_2.tar.bz2": { + "build": "py27h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "acf8075b830afa48928de70b944a4c07", + "name": "traits", + "sha256": "27202ad9449eea3ee9d45bcefe07e8a1aaf6fddc8cda7093f820451638ae067c", + "size": 418780, + "subdir": "linux-64", + "timestamp": 1530873856838, + "version": "4.6.0" + }, + "traits-4.6.0-py27h7b6447c_3.tar.bz2": { + "build": "py27h7b6447c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "6f77cc2062e0170392b77bdf64e95d6b", + "name": "traits", + "sha256": "4b4015a708c610af5b10efddee9d4fad6174d99af9146c7a72f6e1662d3b39ed", + "size": 419112, + "subdir": "linux-64", + "timestamp": 1536253549735, + "version": "4.6.0" + }, + "traits-4.6.0-py35h7b6447c_3.tar.bz2": { + "build": "py35h7b6447c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "md5": "76148b17e69ab358e2809a1b86327a7c", + "name": "traits", + "sha256": "3bccd5a81cfababfb01fa38ff80c9c5b83de6ad154d1b2497f3abfbc99406401", + "size": 427970, + "subdir": "linux-64", + "timestamp": 1536253581611, + "version": "4.6.0" + }, + "traits-4.6.0-py36h14c3975_2.tar.bz2": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "bd3bb5d04fc70d3cf8577fd4339ad1ef", + "name": "traits", + "sha256": "7ad04f2e913ac5fc356ce9bb613392033c9bb3f88746c205627ad28156b447d6", + "size": 423381, + "subdir": "linux-64", + "timestamp": 1530873950004, + "version": "4.6.0" + }, + "traits-4.6.0-py36h7b6447c_3.tar.bz2": { + "build": "py36h7b6447c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "906106215334ff86851d65f4145b4680", + "name": "traits", + "sha256": "44f923e61b08f7ea72dcd375e767d4be94d37040185a27a6206b9f8453b5b398", + "size": 423520, + "subdir": "linux-64", + "timestamp": 1536253516992, + "version": "4.6.0" + }, + "traits-4.6.0-py37h14c3975_2.tar.bz2": { + "build": "py37h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "5f94302d830ffd0cc40266c2eda0451b", + "name": "traits", + "sha256": "5476750d79e731b5baa6e29201ad81ea589b2d9cc267be0d299ffd178c67c68c", + "size": 423615, + "subdir": "linux-64", + "timestamp": 1530873902542, + "version": "4.6.0" + }, + "traits-4.6.0-py37h7b6447c_3.tar.bz2": { + "build": "py37h7b6447c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "81470b7d2a73479f8509fced8313bc7e", + "name": "traits", + "sha256": "e0b414d15fed9374bf7ba40030977ae6c62f6ade26c2bce2ecd6839da9a8bb64", + "size": 423345, + "subdir": "linux-64", + "timestamp": 1536253655813, + "version": "4.6.0" + }, + "traits-5.0.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "3b1de7414cb630956185c8d7a85e01db", + "name": "traits", + "sha256": "0222212dc832172b830e4cb1a6b16a2e028565ced0f8133fd5c9f2bdcb631bcc", + "size": 433638, + "subdir": "linux-64", + "timestamp": 1552371289178, + "version": "5.0.0" + }, + "traits-5.0.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "39c3a2e2040d7cc055c165b5ed1eab28", + "name": "traits", + "sha256": "639e5800f2d80da7acfec019f936b9206abd183ada614eae3d0a673c50f13e96", + "size": 441709, + "subdir": "linux-64", + "timestamp": 1552371308648, + "version": "5.0.0" + }, + "traits-5.0.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "df9fae67c7f103592f0ad7e40d0d8444", + "name": "traits", + "sha256": "e9246e373441be8ce1761d9e297555218dda1a04b33a8f7b01d0276dd138a8b9", + "size": 440560, + "subdir": "linux-64", + "timestamp": 1552371261350, + "version": "5.0.0" + }, + "traits-5.1.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "ec40af529f35771ff05081e22e682da7", + "name": "traits", + "sha256": "97731173a4b3f3f5a9338b7a70905e3487aa1fed07209c574f584256b758d982", + "size": 432454, + "subdir": "linux-64", + "timestamp": 1556076978230, + "version": "5.1.1" + }, + "traits-5.1.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "f5cef579c69918172f97288762045238", + "name": "traits", + "sha256": "316d5433b3b6c79c73c8f6ae6e25b41ce29434113104ec9e359157c929a783b6", + "size": 444494, + "subdir": "linux-64", + "timestamp": 1556077004497, + "version": "5.1.1" + }, + "traits-5.1.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "3ee002ed5b76dce74e3bfe856d5d9122", + "name": "traits", + "sha256": "fcd62ca501dcbfbf70ba8fa1a0198cea60c3cdafe3fc995d180cd36e31ddb639", + "size": 444327, + "subdir": "linux-64", + "timestamp": 1556076949224, + "version": "5.1.1" + }, + "traits-5.1.2-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "47a4bfb700ae79783984cd73c5331b87", + "name": "traits", + "sha256": "e7cb586c86ba5abd838ff8b5370c46fb1eb06cc5fa6e13273f170974a37d2de0", + "size": 433090, + "subdir": "linux-64", + "timestamp": 1569359636616, + "version": "5.1.2" + }, + "traits-5.1.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "808a38a581be80f65737bffa0d0888f3", + "name": "traits", + "sha256": "5ba26ae53ea8cb0d7f7f96235ca69ab015f73026a12e53c56cfb895401a0ec93", + "size": 443753, + "subdir": "linux-64", + "timestamp": 1569359641034, + "version": "5.1.2" + }, + "traits-5.1.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "b09bb954e34ab53f098da83522d11f29", + "name": "traits", + "sha256": "d5282d08e598b17c2ff66a2d937f5c9767a5c05ed3a41672710e949f0b047589", + "size": 440821, + "subdir": "linux-64", + "timestamp": 1569359635489, + "version": "5.1.2" + }, + "traits-5.1.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "md5": "4621a3fc5d9b9f1577df3048ecc89f9b", + "name": "traits", + "sha256": "740cca5b073e64cc29101f7f8382953b816fae5d0eef2fb40834a243c9165fd8", + "size": 449638, + "subdir": "linux-64", + "timestamp": 1573200464057, + "version": "5.1.2" + }, + "traits-5.2.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "54359327c46103e44e25e08852b62dcf", + "name": "traits", + "sha256": "177a52347f3c3b3f67c0177e0c5af7cf6b5e7071bf961b23fd965c6decee30b9", + "size": 433855, + "subdir": "linux-64", + "timestamp": 1574367103659, + "version": "5.2.0" + }, + "traits-5.2.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "c2511a598835587e03c8c5d5a54c376a", + "name": "traits", + "sha256": "20563d6ef4b6fc293a751436a040e3cbdb0acae891a69abed3a7ab45f04e704d", + "size": 442492, + "subdir": "linux-64", + "timestamp": 1574367103066, + "version": "5.2.0" + }, + "traits-5.2.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "d0863db8bf5e3e3c66514250633c4518", + "name": "traits", + "sha256": "0fdb7b7a020b10d037baf34b3dd9458c104cd0d33109b60bf270e441c0b78ecb", + "size": 445331, + "subdir": "linux-64", + "timestamp": 1574367084693, + "version": "5.2.0" + }, + "traits-5.2.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "md5": "a8809952fbd52a0ba8a0169763728ed0", + "name": "traits", + "sha256": "6d3d5d4306b59be8f14e04f7994c6b581af58448e1bf3b28e4c81f81ca0669d5", + "size": 453027, + "subdir": "linux-64", + "timestamp": 1574367097613, + "version": "5.2.0" + }, + "traits-6.0.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "1b6c7f005d932e0edc91d81048a704c1", + "name": "traits", + "sha256": "888c7a2608622ca184b4c2f3af6fb7f3f1f4e7cdb7e962180f96cf5cc798c448", + "size": 461290, + "subdir": "linux-64", + "timestamp": 1586838405725, + "version": "6.0.0" + }, + "traits-6.1.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "4285cf033b713535416d07d74b05be6e", + "name": "traits", + "sha256": "06da29645807def7e36a235978be298390ae82efd435ce3ec6f776422b802a8d", + "size": 660850, + "subdir": "linux-64", + "timestamp": 1595342055054, + "version": "6.1.0" + }, + "traits-6.1.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "1f22ddf5c7239db700b460dd62f36eb5", + "name": "traits", + "sha256": "d9c419ee1bce298222dc087d14703514c9a38f1415202af733f2d2e3c8f4b7a9", + "size": 660100, + "subdir": "linux-64", + "timestamp": 1595342634079, + "version": "6.1.0" + }, + "traits-6.1.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "md5": "2c69d04a5a81301deeb59172a31c1af8", + "name": "traits", + "sha256": "68dfec40dcc557a8844c6d19c35ab456fb30749ed07db7c7ff90e1d10ade6b0f", + "size": 661589, + "subdir": "linux-64", + "timestamp": 1595342638271, + "version": "6.1.0" + }, + "traits-6.1.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "b3d8d15ef9d6002ebd53f53b0d178239", + "name": "traits", + "sha256": "6418b01e93812da0a5a5f8b4600352ed3c007f9de1fcec25ecb924c5a1016943", + "size": 663685, + "subdir": "linux-64", + "timestamp": 1596110861024, + "version": "6.1.1" + }, + "traits-6.1.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "77d99d3b4a43bcd29b3b0552f781c99f", + "name": "traits", + "sha256": "dc74b552b8b617c4c0059dcbb062d71500b4b11dcfba2cb88191a1170446760f", + "size": 661357, + "subdir": "linux-64", + "timestamp": 1596110843676, + "version": "6.1.1" + }, + "traits-6.1.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "md5": "b76eaec307befec49dc7234ca8ae6f60", + "name": "traits", + "sha256": "dd0f592c334171fca8e9e3b0000dc1718bbad11623050276840364631c1168e7", + "size": 663810, + "subdir": "linux-64", + "timestamp": 1596110872264, + "version": "6.1.1" + }, + "traits-6.2.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-clause", + "md5": "4a1b1394c0ccbea087a76e673f9cb529", + "name": "traits", + "sha256": "2624922008cce1a08f3d5e8c46310adf830ee47b20921c446a1bd676c499102f", + "size": 5288011, + "subdir": "linux-64", + "timestamp": 1640795444378, + "version": "6.2.0" + }, + "traits-6.2.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-clause", + "md5": "c0d596b92b73fc718f565b72730a3d07", + "name": "traits", + "sha256": "dc9fe94e039acdbdf0de3a68cbf3d175823915ce39b86ddc45546d6490b98118", + "size": 5426189, + "subdir": "linux-64", + "timestamp": 1676846051646, + "version": "6.2.0" + }, + "traits-6.2.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "810c28751f1cc3cee62d471ed9b3d7f1", + "name": "traits", + "sha256": "962cdb4c2ae0d0123dc8807b03a637b7f0a2bae03ec253cfcc01a484c1baf7e3", + "size": 5214430, + "subdir": "linux-64", + "timestamp": 1611259455471, + "version": "6.2.0" + }, + "traits-6.2.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "433c107846e010d1f350afad81f31ee0", + "name": "traits", + "sha256": "18454e1507e8f578989c469ca6fec8b55f10a190d9d2f8a4d4084f4437a4a076", + "size": 5202669, + "subdir": "linux-64", + "timestamp": 1611259443650, + "version": "6.2.0" + }, + "traits-6.2.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "md5": "aaf63e43e8830506454e3dc694199b51", + "name": "traits", + "sha256": "0321e6ec8897a3ed243d27caa3fc9fa11e7c9bf494f63ac4f5267f1989e802ec", + "size": 5206304, + "subdir": "linux-64", + "timestamp": 1611259478446, + "version": "6.2.0" + }, + "traits-6.2.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-clause", + "md5": "c03d755331a965283f8228b77a7bd011", + "name": "traits", + "sha256": "7ca93c3202d49d7d4af7984d6e0dc24a5d499c4adda2c99d7f4660551a0f4cb6", + "size": 5216590, + "subdir": "linux-64", + "timestamp": 1611259453212, + "version": "6.2.0" + }, + "traitsui-6.0.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pyface >=6", + "python >=2.7,<2.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "md5": "ef25b5187700d2f2ec4cda711e58d2f6", + "name": "traitsui", + "sha256": "5290f2a75fce4374466f3e10b90b6a345c23181f24394e8cc487a801a7247b9f", + "size": 867089, + "subdir": "linux-64", + "timestamp": 1524596792700, + "version": "6.0.0" + }, + "traitsui-6.0.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "pyface >=6", + "python >=3.5,<3.6.0a0", + "traits" + ], + "license": "BSD 3-clause", + "md5": "abe4e796cbb3ea9270d1f4a7472cb8ae", + "name": "traitsui", + "sha256": "e17cc111c6118631f66e2d04dc84573dba86d332578d99f541b02748ed0f7dca", + "size": 884203, + "subdir": "linux-64", + "timestamp": 1524596837137, + "version": "6.0.0" + }, + "traitsui-6.0.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pyface >=6", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "md5": "28ab12350fc38c313ce7750675a86cc9", + "name": "traitsui", + "sha256": "3d4d393264ca469f70aa5255edc19cc4c4788850237c367090e99c6c9787fa4d", + "size": 877033, + "subdir": "linux-64", + "timestamp": 1524596849590, + "version": "6.0.0" + }, + "traitsui-6.0.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pyface >=6", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "md5": "50f97625968414622c2057424f581f80", + "name": "traitsui", + "sha256": "678a422a70c3df2fc04b70989330b2b5dacbd92b51f884778349ecd8e92d4b69", + "size": 890877, + "subdir": "linux-64", + "timestamp": 1530874689100, + "version": "6.0.0" + }, + "transaction-2.1.2-py27hd729c4d_0.tar.bz2": { + "build": "py27hd729c4d_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "e31c7934010bc7f5c886fe07dd17fa35", + "name": "transaction", + "sha256": "064884bf8243ca828e75f49516f10d961e41099a67afd773c006f816b34faa52", + "size": 72203, + "subdir": "linux-64", + "timestamp": 1507984318719, + "version": "2.1.2" + }, + "transaction-2.1.2-py35h6fe4a84_0.tar.bz2": { + "build": "py35h6fe4a84_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "8d5323429214ad51b08da112b960bdac", + "name": "transaction", + "sha256": "60828e50c08c730dc519fb547ed0d2b9ebb09b915ccd6c88d11ed34c7cfac7b6", + "size": 75888, + "subdir": "linux-64", + "timestamp": 1507984352140, + "version": "2.1.2" + }, + "transaction-2.1.2-py36h49b28f5_0.tar.bz2": { + "build": "py36h49b28f5_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "58328c1b9a256950415b05d7636f70f6", + "name": "transaction", + "sha256": "b47664211289e868c5fe082dcb174048eca7b6013d22021a1dd6b9d09bda9535", + "size": 75846, + "subdir": "linux-64", + "timestamp": 1507984350879, + "version": "2.1.2" + }, + "transaction-2.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "59e3e1df1b05deef78c3e65aaa842f8b", + "name": "transaction", + "sha256": "3c714b311b68ca87e622d98a7ce258376e0099447825e5bdc6fbf546f4268d86", + "size": 73043, + "subdir": "linux-64", + "timestamp": 1520793723120, + "version": "2.2.0" + }, + "transaction-2.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "b8edc8feeb8efaa4d086f58d77bb4b04", + "name": "transaction", + "sha256": "1675b6a2c8397a166b61605f62f134324d560e948892a0aec676af73864c5dca", + "size": 76908, + "subdir": "linux-64", + "timestamp": 1520793741153, + "version": "2.2.0" + }, + "transaction-2.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "571c3b137e5dc0e741f0dcf59ab2f3c7", + "name": "transaction", + "sha256": "e553a0f55f3339a7b2bc6e1246f35151bf6da827d7618d6590595f98599ff0b5", + "size": 76694, + "subdir": "linux-64", + "timestamp": 1520793702029, + "version": "2.2.0" + }, + "transaction-2.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "78705852ab8ec008dc96ce685c1ec463", + "name": "transaction", + "sha256": "9590a77ce401d815d48cc421c5d5342705afe2656d540968420081c9383e54f8", + "size": 73383, + "subdir": "linux-64", + "timestamp": 1522715272089, + "version": "2.2.1" + }, + "transaction-2.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "375d12872f2a25784e5d6ed49bb6af57", + "name": "transaction", + "sha256": "ad678fe2f5d2cf6cb6f7b79f810af6347302e38a4383668721e67049a2518e39", + "size": 77250, + "subdir": "linux-64", + "timestamp": 1522715307030, + "version": "2.2.1" + }, + "transaction-2.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "5829fac8fbd63c2a91dc3c647f0e86c1", + "name": "transaction", + "sha256": "346ac1775dabc3daaad177858d25d51240cf916f32b3d869d702bfd524f444e2", + "size": 77321, + "subdir": "linux-64", + "timestamp": 1522715306665, + "version": "2.2.1" + }, + "transaction-2.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "ff8b98db8e87b513769c467ed2b64e54", + "name": "transaction", + "sha256": "72599da050bef551ac84b25c304e99dfef70b32f638cd91968274cef1b627855", + "size": 77177, + "subdir": "linux-64", + "timestamp": 1531060322152, + "version": "2.2.1" + }, + "transaction-2.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "be484c3ca3e74d632416872c522b9141", + "name": "transaction", + "sha256": "f9113a914a88107722c3b1fc6fa3300ba5d8fa864e9c21940d791503e00139ae", + "size": 74314, + "subdir": "linux-64", + "timestamp": 1541055602251, + "version": "2.4.0" + }, + "transaction-2.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "2b27fea4fee99906a1b6bb4d580c2b80", + "name": "transaction", + "sha256": "6fca4bbf14fba7c8b1fda3159ef345c9602310302913661f40bedfe59d17f903", + "size": 78097, + "subdir": "linux-64", + "timestamp": 1541055638288, + "version": "2.4.0" + }, + "transaction-2.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "ddc3296df6192d7d7d7ce2ebb542a5ba", + "name": "transaction", + "sha256": "2dedc4cb1aff91e2f01cc0ac7e22b83fab5e54bed8139add91633901687a01d2", + "size": 78353, + "subdir": "linux-64", + "timestamp": 1541055582791, + "version": "2.4.0" + }, + "transaction-2.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "0c5d761d29db88d13aa8d9d7dc950c25", + "name": "transaction", + "sha256": "d7bbb00100eb92fbcdddff57d3f996f8342350c5d7482a6cd46209c3650a4c8e", + "size": 78839, + "subdir": "linux-64", + "timestamp": 1574153487282, + "version": "2.4.0" + }, + "transaction-3.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "521f63d3ec008eefc29ad30caaf2d67f", + "name": "transaction", + "sha256": "993532ea3b75cd9fabd94ccb6bb33ec5b695c51fb26f7968e95852ab7eb0fc81", + "size": 76220, + "subdir": "linux-64", + "timestamp": 1598413056858, + "version": "3.0.0" + }, + "transaction-3.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "8472f34bbdb6dee31126616ee6a75071", + "name": "transaction", + "sha256": "97aec81e6fcbb8dbf0eacc353dc06103da348decd422d4830d4e613bb4e8913c", + "size": 76443, + "subdir": "linux-64", + "timestamp": 1598413031717, + "version": "3.0.0" + }, + "transaction-3.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "f9d0faff7d2ba2a4b8ceba1d9d911f50", + "name": "transaction", + "sha256": "99489fdc937b363e92ec4c784ff08fc6d1a82e48959992915180eee320b8291a", + "size": 76710, + "subdir": "linux-64", + "timestamp": 1598413034834, + "version": "3.0.0" + }, + "transaction-3.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "cb3a7adaf46a8f2c20dacb138b0d31ba", + "name": "transaction", + "sha256": "ec5ea6da53a21ae76aff6aec3899fdded00ba7c850d29dacb803bd927761d714", + "size": 77127, + "subdir": "linux-64", + "timestamp": 1607563572236, + "version": "3.0.0" + }, + "transaction-3.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "c9e95cd75cbbe303c878e59dfdddeb89", + "name": "transaction", + "sha256": "443e00ade9c83c137efa07e91cba8c87428f3e92c0639ced9eff14c94b35bcf9", + "size": 76728, + "subdir": "linux-64", + "timestamp": 1640813156947, + "version": "3.0.1" + }, + "transaction-3.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "6b33e34f3d5692f149142d18c0ad5846", + "name": "transaction", + "sha256": "5f1b1d4e7903df63ed62efc4a2ab00233bb1686a44629ecb93cc93be4a7a2ee5", + "size": 100535, + "subdir": "linux-64", + "timestamp": 1676863310923, + "version": "3.0.1" + }, + "transaction-3.0.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "6ce29564783b9469773fa20c3dd66daf", + "name": "transaction", + "sha256": "16c1ee85a32843b503df63e2e7e2ee672266d6e385e5f49bcfd71a88779d78ae", + "size": 75250, + "subdir": "linux-64", + "timestamp": 1607710306298, + "version": "3.0.1" + }, + "transaction-3.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "281426623038cfee395edc19e9567ec2", + "name": "transaction", + "sha256": "3acb5152fa7e1e03cda99a5dcb9a98f9956dc28360e068e9583daf579a7b4f70", + "size": 75508, + "subdir": "linux-64", + "timestamp": 1607710331062, + "version": "3.0.1" + }, + "transaction-3.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "7c0e531899c82405071ce09bd6c88ae9", + "name": "transaction", + "sha256": "f3b05197f5d9e7244787e5a938725a22198e315adf92960f3ec14c3612eefffb", + "size": 75720, + "subdir": "linux-64", + "timestamp": 1607710315123, + "version": "3.0.1" + }, + "transaction-3.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "1154a25e071e675699c8b29044a6e920", + "name": "transaction", + "sha256": "a6e305411b6fef3faa68886a086afa0e88d69d8a6b0a564a8b415082c6056c37", + "size": 76034, + "subdir": "linux-64", + "timestamp": 1607710323256, + "version": "3.0.1" + }, + "transformers-4.18.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.1.0,<1.0", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.10,<3.11.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "sacremoses", + "tokenizers >=0.11.1,!=0.11.3,<0.13", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "436d3f067a0ed395480d710a3d045a42", + "name": "transformers", + "sha256": "e76ee0de2902604117440347921175f312c7eb8b23f96029899a02e9f9c261fc", + "size": 4676941, + "subdir": "linux-64", + "timestamp": 1651834558977, + "version": "4.18.0" + }, + "transformers-4.18.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "filelock", + "huggingface_hub >=0.1.0,<=0.9.1", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.10,<3.11.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "sacremoses", + "tokenizers >=0.11.1,!=0.11.3,<0.13", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "306e8040f585a045e7c01091ca8b8c88", + "name": "transformers", + "sha256": "bb03741ff07460c5086fe2939f5a1df62c1322802c5a4a905a073401935e595c", + "size": 4683800, + "subdir": "linux-64", + "timestamp": 1667833520442, + "version": "4.18.0" + }, + "transformers-4.18.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.1.0,<1.0", + "importlib_metadata", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.7,<3.8.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "sacremoses", + "tokenizers >=0.11.1,!=0.11.3,<0.13", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c37919adb95e9c644a060bd5e37f0b0d", + "name": "transformers", + "sha256": "6ec3d7f65445f775429211c006f557877a77c10322154718edb58ef09805e945", + "size": 4615663, + "subdir": "linux-64", + "timestamp": 1651834485145, + "version": "4.18.0" + }, + "transformers-4.18.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "filelock", + "huggingface_hub >=0.1.0,<=0.9.1", + "importlib_metadata", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.7,<3.8.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "sacremoses", + "tokenizers >=0.11.1,!=0.11.3,<0.13", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3b717e6b2f5a751b23cfa20626a5d18e", + "name": "transformers", + "sha256": "88fd5596cbd0a810cf1920765fedeb216b2736bca70c48f4af8a9449bcc1c45e", + "size": 4617162, + "subdir": "linux-64", + "timestamp": 1667833576418, + "version": "4.18.0" + }, + "transformers-4.18.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.1.0,<1.0", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.8,<3.9.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "sacremoses", + "tokenizers >=0.11.1,!=0.11.3,<0.13", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a44ab6a0caa89a12f0b6efb24135d954", + "name": "transformers", + "sha256": "0ba723c5339a2a0fcb286482cfd743419b2eaf2dde264c14c843798419467da0", + "size": 4629987, + "subdir": "linux-64", + "timestamp": 1651834425709, + "version": "4.18.0" + }, + "transformers-4.18.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "filelock", + "huggingface_hub >=0.1.0,<=0.9.1", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.8,<3.9.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "sacremoses", + "tokenizers >=0.11.1,!=0.11.3,<0.13", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4e2bf1cd2130eb977a52f2ca400c73d2", + "name": "transformers", + "sha256": "f2f2b9fd73e3875038a7bf3e573a53a96c9696eb27398c1b8b82a5bee5c9f4b6", + "size": 4634331, + "subdir": "linux-64", + "timestamp": 1667833460441, + "version": "4.18.0" + }, + "transformers-4.18.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.1.0,<1.0", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.9,<3.10.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "sacremoses", + "tokenizers >=0.11.1,!=0.11.3,<0.13", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "22117080718dcad3784fe662781f3aa3", + "name": "transformers", + "sha256": "6bf76de3bef55061ebda5f0cb6516dbf74db86bcb6b7ddb6b8683f1113153e5b", + "size": 4626931, + "subdir": "linux-64", + "timestamp": 1651834359138, + "version": "4.18.0" + }, + "transformers-4.18.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "filelock", + "huggingface_hub >=0.1.0,<=0.9.1", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.9,<3.10.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "sacremoses", + "tokenizers >=0.11.1,!=0.11.3,<0.13", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4babd67eef857fbe22f708032324b43a", + "name": "transformers", + "sha256": "912f3d33f7472587eea96e689360ba6fb9432d0e894b30ff3f70a4cb84c4deb0", + "size": 4631220, + "subdir": "linux-64", + "timestamp": 1667833633252, + "version": "4.18.0" + }, + "transformers-4.24.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.10.0,<1.0", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.10,<3.11.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "tokenizers >=0.11.1,!=0.11.3,<0.14", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b8639caf96cd4567a3cfd2342fb8f515", + "name": "transformers", + "sha256": "7a5a3d1fe1a9fea983dec6e7ffa5ceace981f14bbe42e221db04e5bf0c80fc53", + "size": 6502255, + "subdir": "linux-64", + "timestamp": 1667919486622, + "version": "4.24.0" + }, + "transformers-4.24.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.10.0,<1.0", + "importlib-metadata", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.7,<3.8.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "tokenizers >=0.11.1,!=0.11.3,<0.14", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9f399dbb5d63980c2979edfca18279ca", + "name": "transformers", + "sha256": "66cb7c5462bda4494409c05f62ce1f199f7f4dc7c27e8ce15220064f8e32bd6f", + "size": 6372242, + "subdir": "linux-64", + "timestamp": 1667919674956, + "version": "4.24.0" + }, + "transformers-4.24.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.10.0,<1.0", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.8,<3.9.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "tokenizers >=0.11.1,!=0.11.3,<0.14", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a0e476d272d63b348f3e2fdb998c0658", + "name": "transformers", + "sha256": "739589ea7d85091074ed9a015d6b2f22344c255ed53d1a67569bd7c92147151a", + "size": 6438065, + "subdir": "linux-64", + "timestamp": 1667919613014, + "version": "4.24.0" + }, + "transformers-4.24.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.10.0,<1.0", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.9,<3.10.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "tokenizers >=0.11.1,!=0.11.3,<0.14", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7a3fd50e3567fd56390d5214292efc2c", + "name": "transformers", + "sha256": "49a033a1cacfc90ee12afccaf38c400c88d68885a1c38027760dc40865732620", + "size": 6428907, + "subdir": "linux-64", + "timestamp": 1667919551888, + "version": "4.24.0" + }, + "translationstring-1.3-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "ef75feae279637367e645fe1d311e01f", + "name": "translationstring", + "sha256": "ba4757cb00dfec81e0a79799b70ffaa9307e44a51d81bb587bc1b9d0a8492d0a", + "size": 23170, + "subdir": "linux-64", + "timestamp": 1530025598447, + "version": "1.3" + }, + "translationstring-1.3-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "e8f8025618a6d6a2869fedece0e69de4", + "name": "translationstring", + "sha256": "548d429797d853f87196bde1d2c5f6ec016ff0e267e537ea82236594c34e614f", + "size": 24464, + "subdir": "linux-64", + "timestamp": 1640795464890, + "version": "1.3" + }, + "translationstring-1.3-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "md5": "28eb818ca3c57d2c8a6a4a3931d9b801", + "name": "translationstring", + "sha256": "c900d342c6c84a8a51d939c148cf39cf3d30d8d11b7c591296f44f85c8638bd9", + "size": 30568, + "subdir": "linux-64", + "timestamp": 1676904199589, + "version": "1.3" + }, + "translationstring-1.3-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "28e949fed690d9041c729a16eec243a3", + "name": "translationstring", + "sha256": "c95aec2cbed708d439b9652c7c092d282dff0e67705747130b035afe1b527fe0", + "size": 23830, + "subdir": "linux-64", + "timestamp": 1530025690958, + "version": "1.3" + }, + "translationstring-1.3-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "032a410f706d98bcb244a62e4b72a855", + "name": "translationstring", + "sha256": "b1c23e6affc0110c6ec6b83d77f0ee4350d437f230eb264bca64769411f6cac0", + "size": 23861, + "subdir": "linux-64", + "timestamp": 1530025409212, + "version": "1.3" + }, + "translationstring-1.3-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "bdc769588597feacf8c700ace1a089aa", + "name": "translationstring", + "sha256": "5faaaca9e7f0129f15236e6bb61de2ca649856296247d1f30b07cf42149e2727", + "size": 242775, + "subdir": "linux-64", + "timestamp": 1613502178365, + "version": "1.3" + }, + "translationstring-1.3-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "26356d4dca5317be72603daa58106a8e", + "name": "translationstring", + "sha256": "af08be937b9dba6b74e81f5ebb26dade942271ea1c60f4d24b8dfe8b7090da99", + "size": 23858, + "subdir": "linux-64", + "timestamp": 1530875146450, + "version": "1.3" + }, + "translationstring-1.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "15b46ebe57c18317c65f07f74080162e", + "name": "translationstring", + "sha256": "05c056d932752c2977ea324ff805ff116fe10a8f051dfad3cfabf14971335aeb", + "size": 244709, + "subdir": "linux-64", + "timestamp": 1613502176595, + "version": "1.3" + }, + "translationstring-1.3-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "5f3458fe1838ba5ba248440dcd27ec8e", + "name": "translationstring", + "sha256": "900203d7f56ced274d2109838cbfa3088f845ecd7320a9380ba32e5f099d43de", + "size": 24510, + "subdir": "linux-64", + "timestamp": 1573200482512, + "version": "1.3" + }, + "translationstring-1.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "4eaad566faec4d71f549f7bc02ff5683", + "name": "translationstring", + "sha256": "85b63b1fc65eea35140de124640b7434f755f17e3c5ab597312869a511a9e04a", + "size": 242830, + "subdir": "linux-64", + "timestamp": 1613502835759, + "version": "1.3" + }, + "translationstring-1.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "15c2616774acb24e80c30b4794eb8378", + "name": "translationstring", + "sha256": "2e7d69d198151df94305a46dc9d698dc4bad3aa06a80c3032355b6868f88de99", + "size": 242705, + "subdir": "linux-64", + "timestamp": 1613502838023, + "version": "1.3" + }, + "trio-0.18.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.10,<3.11.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4aba0b029633f3fc6c4ad762672badfc", + "name": "trio", + "sha256": "7c55f24b5ca8f0b72604d0266f8c9e5e46f259e07f5d4c4193fb18c8f070eaf1", + "size": 502026, + "subdir": "linux-64", + "timestamp": 1640811304327, + "version": "0.18.0" + }, + "trio-0.18.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "contextvars >=2.1", + "idna", + "outcome", + "python >=3.6,<3.7.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5fdd1b872cd3d23b5d2ff48f52ca3524", + "name": "trio", + "sha256": "15f78108f183d506084cca067a4fed3e68180522fab8d15e3790f565708779b7", + "size": 491713, + "subdir": "linux-64", + "timestamp": 1610405384316, + "version": "0.18.0" + }, + "trio-0.18.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.7,<3.8.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5af6cff1202b1b324cb92b11090ebd06", + "name": "trio", + "sha256": "139403bfbf162e0295f0ba1e19c791affd8ee3ff04501dd49bab422b66080d46", + "size": 493164, + "subdir": "linux-64", + "timestamp": 1610405393257, + "version": "0.18.0" + }, + "trio-0.18.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.8,<3.9.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52db97cbca9887fe65192a42e35aa432", + "name": "trio", + "sha256": "7b190901112d87330bc73a422d6666563141b204034614649cb25e547d9605a0", + "size": 487589, + "subdir": "linux-64", + "timestamp": 1610404959266, + "version": "0.18.0" + }, + "trio-0.18.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.9,<3.10.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37cc338d5339be332e45389a07183c17", + "name": "trio", + "sha256": "e32a752ec3b347f0f0fd21c4b155efbd1e4d121074f2017bb0aa3108efc334b0", + "size": 503382, + "subdir": "linux-64", + "timestamp": 1614065319615, + "version": "0.18.0" + }, + "trio-0.19.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.10,<3.11.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "069d206e265d5f83b6c3f6c0c80bbbf8", + "name": "trio", + "sha256": "226425a6c3bc5ec9286b77d2ff8585b0958da70b4bb85045aa450b4ef1886017", + "size": 511471, + "subdir": "linux-64", + "timestamp": 1644403440474, + "version": "0.19.0" + }, + "trio-0.19.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.11,<3.12.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "599162cc12269a3112adeb9b68f6b7b6", + "name": "trio", + "sha256": "f9ac322da4b1382be6dd533efb818a5c07e49559771d8d6ef366eb1645dc2749", + "size": 668658, + "subdir": "linux-64", + "timestamp": 1676863327335, + "version": "0.19.0" + }, + "trio-0.19.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.7,<3.8.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c77c8d60b0e2abdd6d0b132d86e7f8f", + "name": "trio", + "sha256": "1c9f61a99b647ab2a6581bae0d8f61962eb92d2bc9a50c7c98d960983843e63d", + "size": 501192, + "subdir": "linux-64", + "timestamp": 1644403425469, + "version": "0.19.0" + }, + "trio-0.19.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.8,<3.9.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f5faba5a4d3584e691a7abc2a0f9a44", + "name": "trio", + "sha256": "05309985a627f50f6a906e5660d559688771881752df421d6566b0f1419715e9", + "size": 501338, + "subdir": "linux-64", + "timestamp": 1644385298098, + "version": "0.19.0" + }, + "trio-0.19.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.9,<3.10.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23ee46e35ebbc1bbd24bc2e3a4e25b00", + "name": "trio", + "sha256": "ce778967a6bfc81193bbd5e00b597244dd76150bcd3ee144d7bb77ca393343d7", + "size": 505568, + "subdir": "linux-64", + "timestamp": 1644387179434, + "version": "0.19.0" + }, + "trio-0.22.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "exceptiongroup >=1.0.0rc9", + "idna", + "outcome", + "python >=3.10,<3.11.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d6efaf3fd4efd8c981be0f34c42a7e77", + "name": "trio", + "sha256": "7074a982c03444c9ef3a24131adb07c7ee0dfdac0293c3928705c5ee1b7ab5b7", + "size": 552003, + "subdir": "linux-64", + "timestamp": 1677879591809, + "version": "0.22.0" + }, + "trio-0.22.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.11,<3.12.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "721b884e2bfb3b225399a3cf705168a4", + "name": "trio", + "sha256": "6d6e0622f7a1453bfd8c0146caf6cd74c7f31356c885b9b2a026a576e1e9a06b", + "size": 742342, + "subdir": "linux-64", + "timestamp": 1677860023931, + "version": "0.22.0" + }, + "trio-0.22.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "exceptiongroup >=1.0.0rc9", + "idna", + "outcome", + "python >=3.8,<3.9.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5e4c054392e29c011a75603d3d7d99e", + "name": "trio", + "sha256": "b7d0493c227857841cf7428591698b1b05ea887db6178913c091fc9f3145e549", + "size": 543200, + "subdir": "linux-64", + "timestamp": 1677879647311, + "version": "0.22.0" + }, + "trio-0.22.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "exceptiongroup >=1.0.0rc9", + "idna", + "outcome", + "python >=3.9,<3.10.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34e0888e2c136d7bdb88fd12fc22556f", + "name": "trio", + "sha256": "195cd6159836390d3b2b55154665f9c0653944ab96d72259f34d255e023a034a", + "size": 546182, + "subdir": "linux-64", + "timestamp": 1677879619289, + "version": "0.22.0" + }, + "trollius-2.2-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "futures", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "88440d51ea8e9ba8ec38640b48073279", + "name": "trollius", + "sha256": "d9e18a3dc14d7e07292a35b20e3ca8f7c6a9648cc40d4646aab3ebe2e675bd04", + "size": 171949, + "subdir": "linux-64", + "timestamp": 1522776279053, + "version": "2.2" + }, + "trollius-2.2-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "15ecb5b2ed1910f861b2257f4afd88a5", + "name": "trollius", + "sha256": "e997afbc79b0933a9b5942675358e2d5eed201c8809a3bcc185409be44bbdc1a", + "size": 177177, + "subdir": "linux-64", + "timestamp": 1522776396637, + "version": "2.2" + }, + "trollius-2.2-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cc59542d549676b73e89225e1220edde", + "name": "trollius", + "sha256": "3ec5dd3a47309a10cfafc3d787907b109f60e64326e8b5286beb478625571e54", + "size": 176499, + "subdir": "linux-64", + "timestamp": 1522776395895, + "version": "2.2" + }, + "trove-classifiers-2023.3.9-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b2d7ba66613eaf9f76dd1f58f110028c", + "name": "trove-classifiers", + "sha256": "bf715f413f0148c7a8e87181170885fed5d1284a9e4c5ac1471d1baa35864017", + "size": 21619, + "subdir": "linux-64", + "timestamp": 1679610058698, + "version": "2023.3.9" + }, + "trove-classifiers-2023.3.9-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c21de440f2fd6a93465c04e9de3dd9e0", + "name": "trove-classifiers", + "sha256": "061fd09a6c31fdb3b5224cc3ca416fc262bbbf672b970a561bc48b1b6b36a971", + "size": 21906, + "subdir": "linux-64", + "timestamp": 1679610083778, + "version": "2023.3.9" + }, + "trove-classifiers-2023.3.9-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4b48ba60cf83d859c8a89c3088e0bac1", + "name": "trove-classifiers", + "sha256": "486b2ffeef8d62b749bcf016672efd790aca5eafb84cbe0977cfad4ef831680a", + "size": 22967, + "subdir": "linux-64", + "timestamp": 1679610108557, + "version": "2023.3.9" + }, + "trove-classifiers-2023.3.9-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2ad3a8be1bd983f9ada1ccb6d1a2a69d", + "name": "trove-classifiers", + "sha256": "2ac2a7716e1ad552039e54e005b43fbeacf596e14dbce958fc06a8a2bd6fdaf8", + "size": 21561, + "subdir": "linux-64", + "timestamp": 1679610132316, + "version": "2023.3.9" + }, + "trustme-0.9.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "idna", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 or MIT", + "license_family": "MIT", + "md5": "efaccb29a518234628ba6387db5660d8", + "name": "trustme", + "sha256": "765cbf1f19f043b2faf314fff141bece64f9ee210ab05b25070d9fb961a24e04", + "size": 30733, + "subdir": "linux-64", + "timestamp": 1669834420113, + "version": "0.9.0" + }, + "trustme-0.9.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "idna", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0 or MIT", + "license_family": "MIT", + "md5": "1257611701f1a3de6913d8857e083313", + "name": "trustme", + "sha256": "e9e93fbf723038bb446cf594a0abd4c0fcaa6fc847d00c8c91ea7b74354ce9b7", + "size": 35203, + "subdir": "linux-64", + "timestamp": 1676863344745, + "version": "0.9.0" + }, + "trustme-0.9.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "idna", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 or MIT", + "license_family": "MIT", + "md5": "b64e83d8b7f3496b47aa774f2560773d", + "name": "trustme", + "sha256": "81cd9c40c30b841338eac32b248d7f91635fddc937d828022c4362c31f6f449c", + "size": 30585, + "subdir": "linux-64", + "timestamp": 1669834386459, + "version": "0.9.0" + }, + "trustme-0.9.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "idna", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 or MIT", + "license_family": "MIT", + "md5": "ba0a6f8a0df72ac593334a32abe768b0", + "name": "trustme", + "sha256": "a027780fefb10f5110fa2b513cb45d31ea5892cd5e8d2c83bf68971298e30e8f", + "size": 30734, + "subdir": "linux-64", + "timestamp": 1669834323982, + "version": "0.9.0" + }, + "trustme-0.9.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "idna", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 or MIT", + "license_family": "MIT", + "md5": "808a97e155e56dea930d353b4987b510", + "name": "trustme", + "sha256": "0d8ae62bc47a55d722d8718aab2a55a14c5cfa2842ceeaa1111f90abae55d825", + "size": 30770, + "subdir": "linux-64", + "timestamp": 1669834355105, + "version": "0.9.0" + }, + "twine-1.11.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pkginfo >=1.4.2", + "python >=2.7,<2.8.0a0", + "requests >=2.5.0,!=2.15,!=2.16", + "requests-toolbelt >=0.8.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c3675ce14795f8cf9dd7bced783cc1b9", + "name": "twine", + "sha256": "bc3b1f2192be6ae245e150f80a5d06899d4bfb084eca1e347516b6c80ec27d9d", + "size": 35729, + "subdir": "linux-64", + "timestamp": 1522178626619, + "version": "1.11.0" + }, + "twine-1.11.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pkginfo >=1.4.2", + "python >=3.5,<3.6.0a0", + "requests >=2.5.0,!=2.15,!=2.16", + "requests-toolbelt >=0.8.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "162a778d6e71454b1d186ea2d8eadfba", + "name": "twine", + "sha256": "7380d2f6f90578a41ad1f45a53d69f8dfb065ec3163966b947c7259f75cd2049", + "size": 36162, + "subdir": "linux-64", + "timestamp": 1522178698204, + "version": "1.11.0" + }, + "twine-1.11.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pkginfo >=1.4.2", + "python >=3.6,<3.7.0a0", + "requests >=2.5.0,!=2.15,!=2.16", + "requests-toolbelt >=0.8.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "52fd30c4b4f85db2be672505e4ff5c09", + "name": "twine", + "sha256": "62db31ce1790977e1543f71ba755faaec9ca0e35d8a80626d790c3260d6104b6", + "size": 35979, + "subdir": "linux-64", + "timestamp": 1522178495811, + "version": "1.11.0" + }, + "twine-1.11.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pkginfo >=1.4.2", + "python >=3.7,<3.8.0a0", + "requests >=2.5.0,!=2.15,!=2.16", + "requests-toolbelt >=0.8.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d07957c465409d2bb76f143b5fa3b652", + "name": "twine", + "sha256": "6675151cd945bf05c41177e8ed5e03b912c67e8caaa97affe4f3f8f846f4b1d0", + "size": 35922, + "subdir": "linux-64", + "timestamp": 1531060357970, + "version": "1.11.0" + }, + "twine-1.12.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pkginfo >=1.4.2", + "python >=2.7,<2.8.0a0", + "readme_renderer >=21.0", + "requests >=2.5.0,!=2.15,!=2.16", + "requests-toolbelt >=0.8.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fb88ad79969bbbb6778c595b219bae13", + "name": "twine", + "sha256": "ab313ecfaf29978f626ec6cef4b8f568ba5ece4902ae2ed6f3ec06f23d2026ad", + "size": 43761, + "subdir": "linux-64", + "timestamp": 1539903056584, + "version": "1.12.1" + }, + "twine-1.12.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pkginfo >=1.4.2", + "python >=3.6,<3.7.0a0", + "readme_renderer >=21.0", + "requests >=2.5.0,!=2.15,!=2.16", + "requests-toolbelt >=0.8.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b7b79321ba0b67975d4be9dcbbae98a5", + "name": "twine", + "sha256": "a372c23c7d77b7f22e6602790ad4e2771ca2d65fa5feb0cecd4565b9ab11c20f", + "size": 44097, + "subdir": "linux-64", + "timestamp": 1539903098028, + "version": "1.12.1" + }, + "twine-1.12.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pkginfo >=1.4.2", + "python >=3.7,<3.8.0a0", + "readme_renderer >=21.0", + "requests >=2.5.0,!=2.15,!=2.16", + "requests-toolbelt >=0.8.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "69f98def302c7beef534ccf31cacd71f", + "name": "twine", + "sha256": "f3b5e60d431a05f69c7ad235e5a2822aea8495ba848f8cef52defb66f2d0c3dd", + "size": 44206, + "subdir": "linux-64", + "timestamp": 1539903082224, + "version": "1.12.1" + }, + "twine-3.2.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.6,<3.7.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "349ad7657b2cc79024c2d1444a6a58f4", + "name": "twine", + "sha256": "f551a296ec2f67780bc4ae47c1ccca81bc1df7e64e9e4892ab13d97d34528985", + "size": 52894, + "subdir": "linux-64", + "timestamp": 1605552671105, + "version": "3.2.0" + }, + "twine-3.2.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.7,<3.8.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "61da7464089ba8f731224e72e9a3e3a4", + "name": "twine", + "sha256": "9fbd49fe2d7d6f5d3432665258e5b13e585d841ccd3cc4e127e0553457972ad6", + "size": 52969, + "subdir": "linux-64", + "timestamp": 1605552653176, + "version": "3.2.0" + }, + "twine-3.2.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.8,<3.9.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4b05d8bd54931eff5ee33f7ac3b7deeb", + "name": "twine", + "sha256": "63439286e763a7ac256e848c23e9bcc9c8fe0a2ff5cac48632eb97e6e06e9f9d", + "size": 53328, + "subdir": "linux-64", + "timestamp": 1605552656232, + "version": "3.2.0" + }, + "twine-3.3.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.6,<3.7.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dfd55ae733d651765cc74a2f0b89bfd2", + "name": "twine", + "sha256": "fd808e26fc804d907072774ae532a9bb85bedad9e3fa9f173c22b9bb5e3d73fa", + "size": 49527, + "subdir": "linux-64", + "timestamp": 1608836970573, + "version": "3.3.0" + }, + "twine-3.3.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.6,<3.7.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b3c3b2eb0c8c5427f401e5d135d73e6d", + "name": "twine", + "sha256": "26116eef1c4a1c0865bde8bac96fbf4e821ba3dc681a3390a50c762237996068", + "size": 54501, + "subdir": "linux-64", + "timestamp": 1610483983726, + "version": "3.3.0" + }, + "twine-3.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.7,<3.8.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "46901e39d0ce66916893873297c41703", + "name": "twine", + "sha256": "8d0f63aa702be79d5169eff07b67376e90fa700473ad1090536af275872a1f93", + "size": 49522, + "subdir": "linux-64", + "timestamp": 1608836978808, + "version": "3.3.0" + }, + "twine-3.3.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.7,<3.8.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "97a5eb92beb8fd9a75d92e5e5a74f3c4", + "name": "twine", + "sha256": "73618fd19267bd4f60c6a4ba2a4881c463e069aee33ae9704a0c3dad99fa116e", + "size": 54571, + "subdir": "linux-64", + "timestamp": 1610483995083, + "version": "3.3.0" + }, + "twine-3.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "colorama >=0.4.3", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.8,<3.9.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a052a5cc5ab528b1f74c31751576b19d", + "name": "twine", + "sha256": "01125d86018e82641f624888195240220ea31fb0277683e78ec8fa8ff20f79dd", + "size": 49853, + "subdir": "linux-64", + "timestamp": 1608836934449, + "version": "3.3.0" + }, + "twine-3.3.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.8,<3.9.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "74018732aca21c9bf2dc638e761f36c4", + "name": "twine", + "sha256": "3207632b4f68756f6c8fb557c4dafae17b9558dd27523c51799f43cc8c25cda6", + "size": 54896, + "subdir": "linux-64", + "timestamp": 1610483982738, + "version": "3.3.0" + }, + "twine-3.4.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.6,<3.7.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "610bc8982065149fa49e551a70a14fb4", + "name": "twine", + "sha256": "960d3ca3104c58d0a8435b3a859ab13bb889d416f2234f0bd4cf434afe60e16a", + "size": 48183, + "subdir": "linux-64", + "timestamp": 1615911077260, + "version": "3.4.0" + }, + "twine-3.4.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.7,<3.8.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "be7126c994b18b86505de59a3d6115d4", + "name": "twine", + "sha256": "820baef53236845b22cf1a1ecd5267b3102449c7b294b19ea126c6200ca9c942", + "size": 48251, + "subdir": "linux-64", + "timestamp": 1615909231584, + "version": "3.4.0" + }, + "twine-3.4.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.8,<3.9.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "55354176156b0611f6ee8d3f59a095a8", + "name": "twine", + "sha256": "0f00e49f63d504db84f9409c1e381dd32d1d9eada36e787d463650c3e6495567", + "size": 48530, + "subdir": "linux-64", + "timestamp": 1615910902977, + "version": "3.4.0" + }, + "twine-3.4.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.9,<3.10.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a678f5113b9c11ea33b465f127b90dc6", + "name": "twine", + "sha256": "326d8d91dbcc8e59ca0fda86648d09bb151aefa7daac92956a267460deaec838", + "size": 48641, + "subdir": "linux-64", + "timestamp": 1615911069711, + "version": "3.4.0" + }, + "twine-3.4.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.10,<3.11.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3192d088ffc99868eb160ffb2ecb8e5f", + "name": "twine", + "sha256": "89ea53592b67ec03c698598122697886a8bdff6f95e31c8a071b97e80ac6cf3f", + "size": 49413, + "subdir": "linux-64", + "timestamp": 1642521132359, + "version": "3.4.1" + }, + "twine-3.4.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.6,<3.7.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bb1d0aa5a7ee563486d389690a033270", + "name": "twine", + "sha256": "f0c0f25e7b049cc7941b73d6db1182be8b3b50bc4dc464306440b3d357f01046", + "size": 48310, + "subdir": "linux-64", + "timestamp": 1616171709650, + "version": "3.4.1" + }, + "twine-3.4.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.6,<3.7.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eb4aa42ca77fc48971b2a344110fbade", + "name": "twine", + "sha256": "da544421f7057b2320f89a116d91d1b1a8971aae4e9eff9fce04e851fc70a985", + "size": 48312, + "subdir": "linux-64", + "timestamp": 1616009508848, + "version": "3.4.1" + }, + "twine-3.4.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.7,<3.8.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a6e52117a6be8d2ffc80ce35c467fd2a", + "name": "twine", + "sha256": "24061b366e4194d7abbbb3702ac5a05425b7d71ab8aaa96489391dd3059a538f", + "size": 48434, + "subdir": "linux-64", + "timestamp": 1616171710696, + "version": "3.4.1" + }, + "twine-3.4.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.7,<3.8.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f749662429a11a4a391b2ad403074e2a", + "name": "twine", + "sha256": "faedfa174ed140d4f7754e8e9f101ace7ce2732e6cb71c827acfb7aafa2b7fae", + "size": 48445, + "subdir": "linux-64", + "timestamp": 1616008223480, + "version": "3.4.1" + }, + "twine-3.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.8,<3.9.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5a273e697410369ef8b73c8c695c73a4", + "name": "twine", + "sha256": "a329a651646825c7396bc9b836b98b816ee219f145057465f2b0e767728f86d5", + "size": 48647, + "subdir": "linux-64", + "timestamp": 1616169733790, + "version": "3.4.1" + }, + "twine-3.4.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.8,<3.9.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c94bc60291e96675dd97b8f55f761420", + "name": "twine", + "sha256": "58e33166d658afa5ff7eaa82fcf5fef71e0f288c5b9185e5e74a4a63170ded2b", + "size": 48694, + "subdir": "linux-64", + "timestamp": 1616010131367, + "version": "3.4.1" + }, + "twine-3.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.9,<3.10.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b5ee9897d8d2df207e8ca3c8b6f8b7ee", + "name": "twine", + "sha256": "d02746b260f3957cbffbbb7784576985ea4b28f07c6adb54b90acd14ebe761a9", + "size": 48754, + "subdir": "linux-64", + "timestamp": 1616171224831, + "version": "3.4.1" + }, + "twine-3.4.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.9,<3.10.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d572f508bf31c2a0ff2fb50afa82a1c6", + "name": "twine", + "sha256": "6594b2eae59c4a735cbd72502d942e9549b75aedfd9c5fe8ec64144f58795503", + "size": 48717, + "subdir": "linux-64", + "timestamp": 1616010135885, + "version": "3.4.1" + }, + "twisted-17.9.0-py27h7008fb7_0.tar.bz2": { + "build": "py27h7008fb7_0", + "build_number": 0, + "constrains": [ + "soappy", + "pyserial >=3.0", + "pyobjc-core", + "pyobjc-framework-CFNetwork", + "pyobjc-framework-Cocoa", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=2.7,<2.8.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c2cbc4fb7afda78232e1fa2e1ae1699", + "name": "twisted", + "sha256": "446791a765adef1066b9d4906b44b7bbb4099aa209d047d189e6f9a8e1fe1b7c", + "size": 5142765, + "subdir": "linux-64", + "timestamp": 1508791899508, + "version": "17.9.0" + }, + "twisted-17.9.0-py35h812867c_0.tar.bz2": { + "build": "py35h812867c_0", + "build_number": 0, + "constrains": [ + "soappy", + "pyserial >=3.0", + "pyobjc-core", + "pyobjc-framework-CFNetwork", + "pyobjc-framework-Cocoa", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=3.5,<3.6.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "698090bf575aa0aea46a437c60234ef0", + "name": "twisted", + "sha256": "384b76e7abab212b2168761e5056a1340cd4c025d69f12db5a16f971d8d1bfd2", + "size": 5004868, + "subdir": "linux-64", + "timestamp": 1508791932402, + "version": "17.9.0" + }, + "twisted-17.9.0-py36hb8d8d5a_0.tar.bz2": { + "build": "py36hb8d8d5a_0", + "build_number": 0, + "constrains": [ + "soappy", + "pyserial >=3.0", + "pyobjc-core", + "pyobjc-framework-CFNetwork", + "pyobjc-framework-Cocoa", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6f5f69776720053001e62965af4bb81", + "name": "twisted", + "sha256": "a16aea1108f32939652e79b3c337d2fb0e1cd2c921444f6a3f10a8977aa09bc3", + "size": 4952840, + "subdir": "linux-64", + "timestamp": 1508791885519, + "version": "17.9.0" + }, + "twisted-18.4.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "constrains": [ + "soappy", + "pyserial >=3.0", + "pyobjc-core", + "pyobjc-framework-CFNetwork", + "pyobjc-framework-Cocoa", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=2.7,<2.8.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "180b18e5b41fa24521ecc87d254f1d10", + "name": "twisted", + "sha256": "9cf1207748c1cb5cbe8504269b61b47f7f096c7bd07c8353388b0247b7eaae02", + "size": 5232266, + "subdir": "linux-64", + "timestamp": 1525812777618, + "version": "18.4.0" + }, + "twisted-18.4.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "constrains": [ + "soappy", + "pyserial >=3.0", + "pyobjc-core", + "pyobjc-framework-CFNetwork", + "pyobjc-framework-Cocoa", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=3.5,<3.6.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7633241208733c9aa56020daced3fa79", + "name": "twisted", + "sha256": "66a72529a005e548093e62902b1b81c47beb1a59b5b18be47078858319b00729", + "size": 5099793, + "subdir": "linux-64", + "timestamp": 1525813801179, + "version": "18.4.0" + }, + "twisted-18.4.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "constrains": [ + "soappy", + "pyserial >=3.0", + "pyobjc-core", + "pyobjc-framework-CFNetwork", + "pyobjc-framework-Cocoa", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80f3fcbead408deb0ae53ee9678f0e10", + "name": "twisted", + "sha256": "44d5aa7a2dab77f420b575b095cb9e336f3c5cf8053a4ee91ad41adf6a708bc7", + "size": 5117327, + "subdir": "linux-64", + "timestamp": 1525813345136, + "version": "18.4.0" + }, + "twisted-18.4.0-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1cd6ad88ae96af6f28f42f8e3ad51506", + "name": "twisted", + "sha256": "c3f2e3c39a74becfb3af752f31842073a8d36807904e19d8c779615bb316f83b", + "size": 5060722, + "subdir": "linux-64", + "timestamp": 1530919831601, + "version": "18.4.0" + }, + "twisted-18.7.0-py27h14c3975_1.tar.bz2": { + "build": "py27h14c3975_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=2.7,<2.8.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a3a6049c759364699724cc268d0f8ea", + "name": "twisted", + "sha256": "6cb035e855d5bbcf5a36fd151465fed307f37982b292c93375406baea996b8ad", + "size": 5209043, + "subdir": "linux-64", + "timestamp": 1533481784772, + "version": "18.7.0" + }, + "twisted-18.7.0-py35h14c3975_1.tar.bz2": { + "build": "py35h14c3975_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=3.5,<3.6.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3593400a1c810b61f645eb7957393f38", + "name": "twisted", + "sha256": "179649494bd76157574343770ae344d600b4add494fb9ccb2796d459c8c4e814", + "size": 5070524, + "subdir": "linux-64", + "timestamp": 1533481927057, + "version": "18.7.0" + }, + "twisted-18.7.0-py36h14c3975_1.tar.bz2": { + "build": "py36h14c3975_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f044273240a32ec00f5b0dcdf774fca", + "name": "twisted", + "sha256": "68b0dc9a21f9012badad839bb76ca0a21a44af27c4d36ef976bcb585c39d77ca", + "size": 5099388, + "subdir": "linux-64", + "timestamp": 1533481927865, + "version": "18.7.0" + }, + "twisted-18.7.0-py37h14c3975_1.tar.bz2": { + "build": "py37h14c3975_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2686c7cd869bbeddb25866b4591e8921", + "name": "twisted", + "sha256": "20f8916591085f2f80e0ab7b259196fc430e7387947a104beb450c0b39c670ef", + "size": 5096448, + "subdir": "linux-64", + "timestamp": 1533481924921, + "version": "18.7.0" + }, + "twisted-18.9.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=17.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=2.7,<2.8.0a0", + "service_identity", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16fcb7e252401814f506f04ec621e595", + "name": "twisted", + "sha256": "109bb28dfe57f19d51696d311f18fb2543d6d5b08eef3d269a58cef30ad71cfa", + "size": 5227147, + "subdir": "linux-64", + "timestamp": 1539712764927, + "version": "18.9.0" + }, + "twisted-18.9.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=17.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f5dd222d2bec5c5774380aaf00b602d", + "name": "twisted", + "sha256": "a0f2453fc2222e92cae38e6820ef247167f83ebae5703120bb6e9e46cc73cd28", + "size": 5097886, + "subdir": "linux-64", + "timestamp": 1539712812923, + "version": "18.9.0" + }, + "twisted-18.9.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=17.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ce749f22dd24900a6f4842cecf22d16", + "name": "twisted", + "sha256": "f8df9cc93a0da9ce535b5b7aa1ac4f71e77ee1d62045dcdbda4df81f5c84c3df", + "size": 5103616, + "subdir": "linux-64", + "timestamp": 1539712836654, + "version": "18.9.0" + }, + "twisted-19.10.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=2.7,<2.8.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7239fb29ccd603253b572fdbdfe4535e", + "name": "twisted", + "sha256": "11f3c45b5e2219555cc2f2768817c55d28891dfe250de95edf50dcdc50e8faeb", + "size": 5277344, + "subdir": "linux-64", + "timestamp": 1573974680291, + "version": "19.10.0" + }, + "twisted-19.10.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ee2562b8dff977880b47168486c8526", + "name": "twisted", + "sha256": "fa4d05321e810f6fdb868994f93bec7d53316d1cb841ee753991666dd1858833", + "size": 5231653, + "subdir": "linux-64", + "timestamp": 1573974774309, + "version": "19.10.0" + }, + "twisted-19.10.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb81aaba06f77104b60b3109d7c277fc", + "name": "twisted", + "sha256": "fc976c9b9ddc68b60f7d159eaac87cbbf52dc9e16aa97bfad0b66ac6632e5e8e", + "size": 5233249, + "subdir": "linux-64", + "timestamp": 1573974670149, + "version": "19.10.0" + }, + "twisted-19.10.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.8,<3.9.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b53e3a3b48c83fb5523119d3def204b", + "name": "twisted", + "sha256": "1045f20a3ff7d43c17094c86e9e4ba877d38ffe6036d94233002f4aeaac19998", + "size": 5241510, + "subdir": "linux-64", + "timestamp": 1574183880269, + "version": "19.10.0" + }, + "twisted-19.2.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=2.7,<2.8.0a0", + "service_identity", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "610899f839ac8db6be6379ae1c413f90", + "name": "twisted", + "sha256": "8d166d74ce74787671f854a42fccfe308e5beabda4d542cde242e93dde944492", + "size": 5253315, + "subdir": "linux-64", + "timestamp": 1556077746868, + "version": "19.2.0" + }, + "twisted-19.2.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a43a7c346df390daf0d1011d68f7bddc", + "name": "twisted", + "sha256": "3282c2ffd00d07da546d979a9e56d650f3720aa826f2b4224ab1f7d7b7f95653", + "size": 5204985, + "subdir": "linux-64", + "timestamp": 1556077748823, + "version": "19.2.0" + }, + "twisted-19.2.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4584e20c567e7caaea728c702baf6101", + "name": "twisted", + "sha256": "8a39f583b12e98311a4fd79c0a92dd35001137506acf2de933e5256cc17d4454", + "size": 5196040, + "subdir": "linux-64", + "timestamp": 1556077677581, + "version": "19.2.0" + }, + "twisted-19.7.0-py27h7b6447c_1.tar.bz2": { + "build": "py27h7b6447c_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=2.7,<2.8.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c7ab47c747ffbe41ab7b9df62792c371", + "name": "twisted", + "sha256": "14de333f7952d35de5a5bec27b848d44e49ae0dec38d52e09db67c91163e860e", + "size": 5262916, + "subdir": "linux-64", + "timestamp": 1568312172357, + "version": "19.7.0" + }, + "twisted-19.7.0-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f59b3b5727152cde2e2d55b811cbd8a", + "name": "twisted", + "sha256": "dc257c90b8fdd5a8ca795f4715aa102c342867e94e9e094f318e6c963f3d08b2", + "size": 5218802, + "subdir": "linux-64", + "timestamp": 1568312161895, + "version": "19.7.0" + }, + "twisted-19.7.0-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3067aaeff2b27074029a00b9ecd983b0", + "name": "twisted", + "sha256": "d416d4cce0114c9002230144038b50e4c9023d331bf9a02bf8ff7001904dcf1f", + "size": 5222113, + "subdir": "linux-64", + "timestamp": 1568312206542, + "version": "19.7.0" + }, + "twisted-20.3.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "priority >=1.1.0,<2.0", + "h2 >=3.0,<4.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f4d8077f5fc8cb028b67e6c8001599f", + "name": "twisted", + "sha256": "98c7e07613431cc888e4282b43a516eaaf90b35434fc27dbfabbf41ce4bbba0b", + "size": 5236915, + "subdir": "linux-64", + "timestamp": 1614066280555, + "version": "20.3.0" + }, + "twisted-20.3.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "375184c046adcc254931d946f8dad7ed", + "name": "twisted", + "sha256": "2f0c304b5c6b586e27e684311e1d383e68e2663f12f328e353ece35d7a177271", + "size": 5249367, + "subdir": "linux-64", + "timestamp": 1586466506286, + "version": "20.3.0" + }, + "twisted-20.3.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4a34fd32ab1347ab02f26682d7cac38", + "name": "twisted", + "sha256": "a4b7828c2a4cc6eee74bbaf33ee934d907e10c25ecd40d60bf54b2b91cf384ca", + "size": 5244304, + "subdir": "linux-64", + "timestamp": 1614065647386, + "version": "20.3.0" + }, + "twisted-20.3.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31a4103c4cbafe95256f4adc9cbf8ba1", + "name": "twisted", + "sha256": "2b210ace8bfc9e8c2a292e4f4fc57df692d1c7726e380caf6402ff2948ef4a1b", + "size": 5242137, + "subdir": "linux-64", + "timestamp": 1586466481529, + "version": "20.3.0" + }, + "twisted-20.3.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.8,<3.9.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7af20a5b393e665eecddcdde9cbe3d67", + "name": "twisted", + "sha256": "4206566e03b7d3a11979fe93767b4a5dfe3b34b07009cabdaa64382928f7213e", + "size": 5254892, + "subdir": "linux-64", + "timestamp": 1614066262250, + "version": "20.3.0" + }, + "twisted-20.3.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.8,<3.9.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "38eb98330b50a6fca87fb2f0c1f903bb", + "name": "twisted", + "sha256": "114d8fbe2785541c80bbfd909167a8066812e47bfb58993e3dd9e2597fb6222c", + "size": 5255374, + "subdir": "linux-64", + "timestamp": 1586466512469, + "version": "20.3.0" + }, + "twisted-20.3.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "constrains": [ + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0", + "pyserial >=3.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.9,<3.10.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ac8cae3b2871b4ba8eb92b9690f2ba0a", + "name": "twisted", + "sha256": "7d7b205c4dd993e2f8dd2b7617622f55ec98cdae1338f43961efc14e5a800346", + "size": 5251623, + "subdir": "linux-64", + "timestamp": 1614066281408, + "version": "20.3.0" + }, + "twisted-21.2.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "priority >=1.1.0,<2.0", + "h2 >=3.0,<4.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af8fb24f4484da6fb8b6fcfeb3139f82", + "name": "twisted", + "sha256": "f22e4c212875f1704a551efa975b73d3a94306905b3cd4c5df3d6c1264f914f5", + "size": 5331500, + "subdir": "linux-64", + "timestamp": 1614873149683, + "version": "21.2.0" + }, + "twisted-21.2.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "priority >=1.1.0,<2.0", + "h2 >=3.0,<4.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "30fa853ac56ebffa540f1512f1d73337", + "name": "twisted", + "sha256": "e764fdd0d9794c695151c8b52440d57bcd8df01ec3ec28772a3786202f32e507", + "size": 5331243, + "subdir": "linux-64", + "timestamp": 1614874469005, + "version": "21.2.0" + }, + "twisted-21.2.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "constrains": [ + "priority >=1.1.0,<2.0", + "pyserial >=3.0", + "h2 >=3.0,<4.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.8,<3.9.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34d817a349c67a9a457bf21dc6361cb1", + "name": "twisted", + "sha256": "7586db17f848cfb9c49be20d0e41647af94a5859ff54f06baa3f860875fe5416", + "size": 5334841, + "subdir": "linux-64", + "timestamp": 1614874445902, + "version": "21.2.0" + }, + "twisted-21.2.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "constrains": [ + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0", + "pyserial >=3.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.9,<3.10.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "968a4112f772f6f3ac681eea4564c29a", + "name": "twisted", + "sha256": "56208e07c07e3e2eb8b1869f4319d00998ba12585e1c556bffc05c2ffbfa2772", + "size": 5341873, + "subdir": "linux-64", + "timestamp": 1614874475341, + "version": "21.2.0" + }, + "twisted-21.7.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "constrains": [ + "priority >=1.1.0,<2.0", + "h2 >=3.0,<4.0", + "pyserial >=3.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=7.5.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.10,<3.11.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a4078c97729324ad0bc632c70ed309a", + "name": "twisted", + "sha256": "c4dbe7abb33538f0b4dc54ba5e63639fd5c1779e6aecd9ab5d2db239be3502d7", + "size": 5405448, + "subdir": "linux-64", + "timestamp": 1640813190953, + "version": "21.7.0" + }, + "twisted-21.7.0-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "constrains": [ + "h2 >=3.0,<4.0", + "pyserial >=3.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=7.5.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a5f21227991b2394810bae7a725aec71", + "name": "twisted", + "sha256": "fbc7b3df9cdf3f5393c5eeb489535dd3057cefbafd7ad01f0eb3b44c60cdba85", + "size": 5351993, + "subdir": "linux-64", + "timestamp": 1636984189511, + "version": "21.7.0" + }, + "twisted-21.7.0-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "constrains": [ + "priority >=1.1.0,<2.0", + "h2 >=3.0,<4.0", + "pyserial >=3.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=7.5.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.8,<3.9.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9cd75b1ca66056f0c233ea21caf02716", + "name": "twisted", + "sha256": "1a86e28be5b3f973215498dbf23751cbfeb2ca9e5cc2c44792be26faec98c43c", + "size": 5359854, + "subdir": "linux-64", + "timestamp": 1636996686775, + "version": "21.7.0" + }, + "twisted-21.7.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "priority >=1.1.0,<2.0", + "h2 >=3.0,<4.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=7.5.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.9,<3.10.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "544acb99d666ca4dbd150aa1a496adda", + "name": "twisted", + "sha256": "2350815219f3137b1bdc8cb2e77a9ce4713ddaa9e88c908a5ad61d9d69d6deb0", + "size": 5374153, + "subdir": "linux-64", + "timestamp": 1636996194203, + "version": "21.7.0" + }, + "twisted-22.2.0-py310h5eee18b_1.tar.bz2": { + "build": "py310h5eee18b_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=11.2.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.10,<3.11.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d3691abcf36c44a4c24e52edf3b06396", + "name": "twisted", + "sha256": "efd461032fa212c245215d54f0a287c31476045d2236c2861c5a3ef6a90d2678", + "size": 5394941, + "subdir": "linux-64", + "timestamp": 1659592929856, + "version": "22.2.0" + }, + "twisted-22.2.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "constrains": [ + "priority >=1.1.0,<2.0", + "pyserial >=3.0", + "h2 >=3.0,<4.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=7.5.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.10,<3.11.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc309bc4507bf516ec70bfdcaa649f0a", + "name": "twisted", + "sha256": "549b0a85a75a4937314d972e2e05b6a046e011f3fc649cbf67555ed96cd37613", + "size": 5396205, + "subdir": "linux-64", + "timestamp": 1646817786687, + "version": "22.2.0" + }, + "twisted-22.2.0-py311h5eee18b_1.tar.bz2": { + "build": "py311h5eee18b_1", + "build_number": 1, + "constrains": [ + "priority >=1.1.0,<2.0", + "pyserial >=3.0", + "h2 >=3.0,<4.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=11.2.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.11,<3.12.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22450f2268949a278c4895d7459ca35c", + "name": "twisted", + "sha256": "960912f20ed9c1fe289eac7abdc2c17c6168589269bfc2767d9c72ff143d931a", + "size": 6737899, + "subdir": "linux-64", + "timestamp": 1676846083398, + "version": "22.2.0" + }, + "twisted-22.2.0-py37h5eee18b_1.tar.bz2": { + "build": "py37h5eee18b_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=11.2.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d96c628e15f80d45b1c5273f4f92822", + "name": "twisted", + "sha256": "fc6613686f9262c7fe7f498ac678822a8e5ecd3f97c5deb75479aeddbda968a3", + "size": 5341490, + "subdir": "linux-64", + "timestamp": 1659592800997, + "version": "22.2.0" + }, + "twisted-22.2.0-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=7.5.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "81a5be9e846091dc6bc89240ec6feac6", + "name": "twisted", + "sha256": "57b0e9663f89e94243ae3a8ce9c61f4c76b42fc030a4e489d39633ea3d9bc9e8", + "size": 5335008, + "subdir": "linux-64", + "timestamp": 1646835250235, + "version": "22.2.0" + }, + "twisted-22.2.0-py38h5eee18b_1.tar.bz2": { + "build": "py38h5eee18b_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=11.2.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.8,<3.9.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "498d5d804ad8a991ddcbc2ee02554ed2", + "name": "twisted", + "sha256": "d2bedd61faf775aa8f442ddfc7ff411ec971f6cdcfc4153eea9873f7a11dba7b", + "size": 5351661, + "subdir": "linux-64", + "timestamp": 1659592840512, + "version": "22.2.0" + }, + "twisted-22.2.0-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=7.5.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.8,<3.9.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "889152c4b41330ff8c5ab434cb0e2d94", + "name": "twisted", + "sha256": "ab99b0083c066f8ca2b9f1f835bac693d97208f34d90483ec687af478b0a5714", + "size": 5348402, + "subdir": "linux-64", + "timestamp": 1646835249176, + "version": "22.2.0" + }, + "twisted-22.2.0-py39h5eee18b_1.tar.bz2": { + "build": "py39h5eee18b_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=11.2.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.9,<3.10.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ecec369369d7ae5f9d7332100b191e1", + "name": "twisted", + "sha256": "8957d5f2012ce795affb4c19cdbaa289b32a332c91e031e79651c151ac5b2306", + "size": 5348912, + "subdir": "linux-64", + "timestamp": 1659592879954, + "version": "22.2.0" + }, + "twisted-22.2.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "constrains": [ + "priority >=1.1.0,<2.0", + "pyserial >=3.0", + "h2 >=3.0,<4.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=7.5.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.9,<3.10.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "41798d18371324803200c9df3cc1ee35", + "name": "twisted", + "sha256": "f688863703e78b8d9ece4a33d9d7945d24bd94fe0143fbf96e1f8ddb9d3cb526", + "size": 5353009, + "subdir": "linux-64", + "timestamp": 1646835255336, + "version": "22.2.0" + }, + "twofish-0.3.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "1e00fe71f80f415cdbddc0f67aa90fe0", + "name": "twofish", + "sha256": "19c962b3244cdef30d3738cedd22623bb3786b854798e8e91c92aaa37d6b3292", + "size": 17183, + "subdir": "linux-64", + "timestamp": 1545424270442, + "version": "0.3.0" + }, + "twofish-0.3.0-py310h7f8727e_1000.tar.bz2": { + "build": "py310h7f8727e_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "9716741b24aad42245c409765de10c65", + "name": "twofish", + "sha256": "8b706274815c1aacf2c1aa414a851d8cb59a6319ccb1fc44b2cb6d4468681646", + "size": 33735, + "subdir": "linux-64", + "timestamp": 1640795489503, + "version": "0.3.0" + }, + "twofish-0.3.0-py311h5eee18b_1000.tar.bz2": { + "build": "py311h5eee18b_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "3438e414981eb31e0c4bab7ccb103dd3", + "name": "twofish", + "sha256": "2dbc8af90ae095dffd4e9fb4c8fab8b7177e9b15e2f409cec64c912283cdd555", + "size": 18840, + "subdir": "linux-64", + "timestamp": 1676863365131, + "version": "0.3.0" + }, + "twofish-0.3.0-py36h27cfd23_1000.tar.bz2": { + "build": "py36h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "1b5349afa0dde846167f3d22a134fb28", + "name": "twofish", + "sha256": "4902a101e8b5f28ee8756c38f745c5e80275934ce19bff540f33e2ea3a8aad34", + "size": 18497, + "subdir": "linux-64", + "timestamp": 1613502529428, + "version": "0.3.0" + }, + "twofish-0.3.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "aef95033d2272ac2b841635ea4c350ee", + "name": "twofish", + "sha256": "5400c84b3683757c876f4115a7bdbd3677ee2ac468b0168e80cf992328417293", + "size": 17230, + "subdir": "linux-64", + "timestamp": 1545424304116, + "version": "0.3.0" + }, + "twofish-0.3.0-py36h7b6447c_1000.tar.bz2": { + "build": "py36h7b6447c_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "f5b72ca6b66c9bd7ab5d2faba89ca3e0", + "name": "twofish", + "sha256": "895274c22b92c0b87479a4b9b49661b2078fd77523fecc873eeca6f91c9f8d5b", + "size": 18196, + "subdir": "linux-64", + "timestamp": 1591257727239, + "version": "0.3.0" + }, + "twofish-0.3.0-py37h27cfd23_1000.tar.bz2": { + "build": "py37h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "53a1a206e5d22f3767d7a077398070f9", + "name": "twofish", + "sha256": "69e4ef7878447ea8f0f123e2376c2b17976848017d630205c12e46b9c55cb180", + "size": 18473, + "subdir": "linux-64", + "timestamp": 1613502853390, + "version": "0.3.0" + }, + "twofish-0.3.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "b3ebc67a9fe743c5a45a0be823affc16", + "name": "twofish", + "sha256": "ed35a4ee85f199f4a6c712d67f18cd38bd9f1e4dfbfeabaa387f363339b2e33b", + "size": 17202, + "subdir": "linux-64", + "timestamp": 1545424291129, + "version": "0.3.0" + }, + "twofish-0.3.0-py37h7b6447c_1000.tar.bz2": { + "build": "py37h7b6447c_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "f0285923d45899c2e0d706120c50a2e3", + "name": "twofish", + "sha256": "494cfb321cb0d6f9ddc6572c013e0de8390a100d05722f9c84ec8c3e1bcb6c75", + "size": 18155, + "subdir": "linux-64", + "timestamp": 1591257717091, + "version": "0.3.0" + }, + "twofish-0.3.0-py38h27cfd23_1000.tar.bz2": { + "build": "py38h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "76991cc69d4e9103b4eed8e045380001", + "name": "twofish", + "sha256": "dfe3890b914d52b59a581642602a34690076f1ae55fa10184073abc42bfb852e", + "size": 18482, + "subdir": "linux-64", + "timestamp": 1613502531289, + "version": "0.3.0" + }, + "twofish-0.3.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "e3b63212a9b4ddafe34fa53375e1d6d7", + "name": "twofish", + "sha256": "5c1c4abca00f6957c228876b16e39aa39454ff85ec123e69a6c82aeac18389a4", + "size": 24002, + "subdir": "linux-64", + "timestamp": 1573200500486, + "version": "0.3.0" + }, + "twofish-0.3.0-py38h7b6447c_1000.tar.bz2": { + "build": "py38h7b6447c_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "5048f6819ff7f85b1e6173430885acf0", + "name": "twofish", + "sha256": "00128b8cb32cdfb3b578db38c9c41ef74d219f21f9f6040ef31f38a70b5d9d09", + "size": 18165, + "subdir": "linux-64", + "timestamp": 1591257723141, + "version": "0.3.0" + }, + "twofish-0.3.0-py39h27cfd23_1000.tar.bz2": { + "build": "py39h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "a636e5f802972d2c4fccb31d1c715797", + "name": "twofish", + "sha256": "200165b921ee0d80c3b5e41f8946d3cd221747b906b8a591d73ed543c440d40b", + "size": 18482, + "subdir": "linux-64", + "timestamp": 1613502854176, + "version": "0.3.0" + }, + "twython-3.7.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d763dcb4b82f9f19d5f540969783c501", + "name": "twython", + "sha256": "a1882d15504bc80b5b049aa824dec3a1af5816e84595fbe7a161280ba8baebb1", + "size": 44523, + "subdir": "linux-64", + "timestamp": 1525813869860, + "version": "3.7.0" + }, + "twython-3.7.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b6fd9438a50365361f828e0bf15ea67", + "name": "twython", + "sha256": "dd2f4be68e542793a64db2a8af8254a5894d8895f9ca96ebed8dfd5a3ace0bc8", + "size": 45589, + "subdir": "linux-64", + "timestamp": 1525813983070, + "version": "3.7.0" + }, + "twython-3.7.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e7110fd9a491faa0b0c7fe9e25499f4", + "name": "twython", + "sha256": "42cd7160095ea31cc30074faad6051c9e36b9b1080a536342ffc4741cf542998", + "size": 45571, + "subdir": "linux-64", + "timestamp": 1525813974696, + "version": "3.7.0" + }, + "twython-3.7.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "09b3234ea57a5c88894938fe7728bcc7", + "name": "twython", + "sha256": "b2a109cb5894e4a25bcee41033ad945effb100aaa43cadb53c5a08b751e6758d", + "size": 45835, + "subdir": "linux-64", + "timestamp": 1545089459062, + "version": "3.7.0" + }, + "twython-3.8.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df118112895463963f4a7ae4c785187d", + "name": "twython", + "sha256": "d0a49b48bd672ebe3a3ba1afb41a9c2a86f64e87f90d3cd16710b31d3d547e8e", + "size": 46375, + "subdir": "linux-64", + "timestamp": 1640795508037, + "version": "3.8.2" + }, + "twython-3.8.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f01da190f520f6686aa5eb256d07b1ed", + "name": "twython", + "sha256": "b3dab5911958ac731a5bef16560d4c9731b78e37e2c28497414619622885664a", + "size": 55583, + "subdir": "linux-64", + "timestamp": 1676863381758, + "version": "3.8.2" + }, + "twython-3.8.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16eef045e09afbbe45ffbd03c6b76790", + "name": "twython", + "sha256": "4b9fe4c8040840c153572b25704ef0aaf2627b565300d7d7a79ff6634222f8b7", + "size": 47381, + "subdir": "linux-64", + "timestamp": 1593483279840, + "version": "3.8.2" + }, + "twython-3.8.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4aefc14240f21a7cdcc7c0fdadb02658", + "name": "twython", + "sha256": "764b54b79a7eaee30f688a51aac7604cfac29583cfff0d3e68c012acba4feff3", + "size": 47539, + "subdir": "linux-64", + "timestamp": 1614080319063, + "version": "3.8.2" + }, + "twython-3.8.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1885217cd6b178b29e4495c79457371b", + "name": "twython", + "sha256": "e3b21a2f332e1997679e74e5d29a655eb1204c2354470914c19d7e84747e1548", + "size": 47360, + "subdir": "linux-64", + "timestamp": 1593483274172, + "version": "3.8.2" + }, + "twython-3.8.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d4d2f27a0c5af9d726a0d0225020aee", + "name": "twython", + "sha256": "66a17493566b525a6bd185945b08e7f524f8292c57aea9fc0c4834532c905ea4", + "size": 47534, + "subdir": "linux-64", + "timestamp": 1614079985475, + "version": "3.8.2" + }, + "twython-3.8.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74b47ab0c06bb396f2c46eb1721f3a0a", + "name": "twython", + "sha256": "2a8c6e65d1f66eb91a90601f1064c74332e6c410815d324fff6d0148a1dd1ab4", + "size": 47361, + "subdir": "linux-64", + "timestamp": 1593483258687, + "version": "3.8.2" + }, + "twython-3.8.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc6461170637f061c9a7a2930a25addb", + "name": "twython", + "sha256": "ed11ae35ab64835d7fbca6a9a2e2190285b9881771c80314b416824f59fb717e", + "size": 47615, + "subdir": "linux-64", + "timestamp": 1614080318972, + "version": "3.8.2" + }, + "twython-3.8.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a38bc6cf35d04c6c4c5a1b94dc12485f", + "name": "twython", + "sha256": "a6849af8e446a70d2436181699422f7288757c0c0969dc97f6618aaf2f7c63a0", + "size": 47619, + "subdir": "linux-64", + "timestamp": 1614080325539, + "version": "3.8.2" + }, + "typed-ast-1.1.0-py35h20cf15d_0.tar.bz2": { + "build": "py35h20cf15d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d1986af68132b6ed58a76ee9d2bd39bb", + "name": "typed-ast", + "sha256": "c57ae2c0a6fc4fd50c9c2d4536b34a0cac674ef253de2740a220ac58e84709d9", + "size": 200865, + "subdir": "linux-64", + "timestamp": 1507240396388, + "version": "1.1.0" + }, + "typed-ast-1.1.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "029391c78adffb8c8351f577f45f6c8e", + "name": "typed-ast", + "sha256": "f7601bf3d1e2e5d2dcddccaf85d94557790f7990db829567d1750e642552ffde", + "size": 200208, + "subdir": "linux-64", + "timestamp": 1530900669521, + "version": "1.1.0" + }, + "typed-ast-1.1.0-py36h4769eee_0.tar.bz2": { + "build": "py36h4769eee_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8888fc882e2a8115c59e426ad270d7cf", + "name": "typed-ast", + "sha256": "ebb949fa8d145eafdd22343a41df7e29c20bcc79e9b3102d8f76262f434a0b42", + "size": 200511, + "subdir": "linux-64", + "timestamp": 1507240417207, + "version": "1.1.0" + }, + "typed-ast-1.1.0-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e867a8c6b56c02ff68f287b9ba4b82a2", + "name": "typed-ast", + "sha256": "5f514900d9b65646b8c4bbaf58d7d82c5eb85f5b2eee2495058a2538d532001b", + "size": 200446, + "subdir": "linux-64", + "timestamp": 1530900625994, + "version": "1.1.0" + }, + "typed-ast-1.2.0-py36h7b6447c_1000.tar.bz2": { + "build": "py36h7b6447c_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cddcf196acc14f6614976ca0b07e1c44", + "name": "typed-ast", + "sha256": "035e1b010d05c68dd991842e0065ed3505f712af0c51acbb44b0a24fc986005d", + "size": 205509, + "subdir": "linux-64", + "timestamp": 1552362442315, + "version": "1.2.0" + }, + "typed-ast-1.2.0-py37h7b6447c_1000.tar.bz2": { + "build": "py37h7b6447c_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2e42cfba94921f5143d16716fad74797", + "name": "typed-ast", + "sha256": "810a93ffd4ae7b18a79f5825d299e8f9ab25ec5d6928a3427af892fdb19907d7", + "size": 204846, + "subdir": "linux-64", + "timestamp": 1552362397703, + "version": "1.2.0" + }, + "typed-ast-1.3.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "71f7729638963b9f1e66012a6e262b8b", + "name": "typed-ast", + "sha256": "493e59268524b4f69fdc6b99ba15eebb8db5a9aff21af0d77e792ea81e067709", + "size": 204523, + "subdir": "linux-64", + "timestamp": 1550431625709, + "version": "1.3.1" + }, + "typed-ast-1.3.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1d0e4627134483cf2ae88c1f1ec02f15", + "name": "typed-ast", + "sha256": "27ab95a6d64ec1f47f0365d418111716ec0a19572a1fbea47072542a34fd929d", + "size": 204544, + "subdir": "linux-64", + "timestamp": 1550431589741, + "version": "1.3.1" + }, + "typed-ast-1.3.4-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d68ee03e8d2c610d391935f1744ed375", + "name": "typed-ast", + "sha256": "01ca930f68b0ff95600c40e0147f12a567037954abf46b81f7d19d569cb27ef2", + "size": 211748, + "subdir": "linux-64", + "timestamp": 1556109889211, + "version": "1.3.4" + }, + "typed-ast-1.3.4-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "86ef0ca03c28dbc6f7c715ada94c3804", + "name": "typed-ast", + "sha256": "970ff97953a6e77866564cf1fdd56cc2c0da3267835a72455d4e059af44d8173", + "size": 211470, + "subdir": "linux-64", + "timestamp": 1556088339356, + "version": "1.3.4" + }, + "typed-ast-1.4.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0ae441bb874e20bb854e29396d179c57", + "name": "typed-ast", + "sha256": "cfa5aa3a480eea6f2a0ff40427ae9d66bd24587ddfc21643532e33d56bfe9c8d", + "size": 212505, + "subdir": "linux-64", + "timestamp": 1569360549081, + "version": "1.4.0" + }, + "typed-ast-1.4.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "deae221e12080e72634d10864f2ee5fd", + "name": "typed-ast", + "sha256": "52ef959f5194aabf9deb3be9c0c19d9cfb0ba6fecb428aa8199e9f6d3d511e5c", + "size": 212588, + "subdir": "linux-64", + "timestamp": 1569360541363, + "version": "1.4.0" + }, + "typed-ast-1.4.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6781835aaa79eb4da62a8af5f422715b", + "name": "typed-ast", + "sha256": "617b3aaad047161c7304587a9c409ef5bc77fb2c271d4ab4198597a463e31b93", + "size": 221638, + "subdir": "linux-64", + "timestamp": 1573200533044, + "version": "1.4.0" + }, + "typed-ast-1.4.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3a2a55e3e5fba3f2fc0d17a937dd078f", + "name": "typed-ast", + "sha256": "783f2ba5043535dbfa1277af1ff497a38b2e8aa72aaaf319280f6fdfc7b6c566", + "size": 213480, + "subdir": "linux-64", + "timestamp": 1580153490794, + "version": "1.4.1" + }, + "typed-ast-1.4.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4becc1a6bcf955b689402a49494f2087", + "name": "typed-ast", + "sha256": "599588833cc1766c774af05b4514d780bc4006f1890c29f051bfcbdc9863c76f", + "size": 213782, + "subdir": "linux-64", + "timestamp": 1580153429658, + "version": "1.4.1" + }, + "typed-ast-1.4.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f557902d184379b610d55039fb25969c", + "name": "typed-ast", + "sha256": "ff2141f5c94afda4c3ac37cc21bb3f704afe7c906f4276a58b3df9bf5d4a68f9", + "size": 216799, + "subdir": "linux-64", + "timestamp": 1580153398024, + "version": "1.4.1" + }, + "typed-ast-1.4.2-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d82d6efa4f5eb34b2e0f6b992635df0f", + "name": "typed-ast", + "sha256": "939eba61200acdb40942720859d2d3bd040f2904b496180ab94435895e9b23d1", + "size": 211016, + "subdir": "linux-64", + "timestamp": 1610393152559, + "version": "1.4.2" + }, + "typed-ast-1.4.2-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "60a16d6cd3fbfffe5b6171be749a421e", + "name": "typed-ast", + "sha256": "165f24c880d9a10b125449cfb94bba71c7315e660228a9f76134fd4f380665f2", + "size": 214987, + "subdir": "linux-64", + "timestamp": 1610484580892, + "version": "1.4.2" + }, + "typed-ast-1.4.2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "24aa779b7bbb3afac8bb1b4b3dd2b5f2", + "name": "typed-ast", + "sha256": "4077e51790fd1691303af91032df58e8957cf55c7208cec1208068074e5a2180", + "size": 210660, + "subdir": "linux-64", + "timestamp": 1610393153851, + "version": "1.4.2" + }, + "typed-ast-1.4.2-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "af3b6b91de6f0b046d299847a55134bb", + "name": "typed-ast", + "sha256": "a0a85322dd545c7293c6e0316bf9a605a1a3391768821e7203f2928d364421e1", + "size": 214977, + "subdir": "linux-64", + "timestamp": 1610484610492, + "version": "1.4.2" + }, + "typed-ast-1.4.2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "984d0639174661595ed66d9d4473de7a", + "name": "typed-ast", + "sha256": "0fefdec6624d691e0025eed04f3bcaeecefb369284bdeac7c6d6473ba7956e44", + "size": 214453, + "subdir": "linux-64", + "timestamp": 1610393156221, + "version": "1.4.2" + }, + "typed-ast-1.4.2-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7e3fb7e89d40f9beda56e1617944ac22", + "name": "typed-ast", + "sha256": "fe472bcc02ae15798361baaa553470bf9a7a4069d29ff42bbe47fbee37b93ef4", + "size": 219418, + "subdir": "linux-64", + "timestamp": 1610484596524, + "version": "1.4.2" + }, + "typed-ast-1.4.2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "053c6fd6130d795df1353224e6f069d3", + "name": "typed-ast", + "sha256": "9b851fa072194cab0c09c3023f4d2ac123bd5c03abae2b7e94aadb45f0831c5e", + "size": 215589, + "subdir": "linux-64", + "timestamp": 1610393155887, + "version": "1.4.2" + }, + "typed-ast-1.4.2-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fbbd358fddc4630f000ccc129d301156", + "name": "typed-ast", + "sha256": "199b98be7bd2fecec6699ec430570e1cf8bc5f0b7edbbf9f602edf1576cec565", + "size": 220001, + "subdir": "linux-64", + "timestamp": 1610484131222, + "version": "1.4.2" + }, + "typed-ast-1.4.3-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 AND PSF-2.0 AND MIT", + "license_family": "Apache", + "md5": "2cd7d12be300a25620312ff1d906ef3d", + "name": "typed-ast", + "sha256": "99094152114ed572708cba10e48f58b56f86e864909dcbf8394cf092f8470394", + "size": 739036, + "subdir": "linux-64", + "timestamp": 1640795540672, + "version": "1.4.3" + }, + "typed-ast-1.4.3-py36h7f8727e_1.tar.bz2": { + "build": "py36h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0 AND PSF-2.0 AND MIT", + "license_family": "Apache", + "md5": "b0e597ea30aa4a7621ffd13f41849373", + "name": "typed-ast", + "sha256": "cdc6e222e34718f2e8c33664722724793c0918080fb5240728a3113e9eb1e56b", + "size": 210352, + "subdir": "linux-64", + "timestamp": 1624953748316, + "version": "1.4.3" + }, + "typed-ast-1.4.3-py37h7f8727e_1.tar.bz2": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 AND PSF-2.0 AND MIT", + "license_family": "Apache", + "md5": "12792a5dc4e089fcf16fcfeb9a266ed5", + "name": "typed-ast", + "sha256": "fbbec8cf6c653db51ba53ac6b4e6d4a2568e9631560e75eafe9c81b62c848659", + "size": 210355, + "subdir": "linux-64", + "timestamp": 1624953437755, + "version": "1.4.3" + }, + "typed-ast-1.4.3-py38h7f8727e_1.tar.bz2": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 AND PSF-2.0 AND MIT", + "license_family": "Apache", + "md5": "053ed6bfd4731343f244bf6e46083ea8", + "name": "typed-ast", + "sha256": "c706521edf6b19fafd230fe2471f65a11fe618984f8f604c8a63bf2df213ebb2", + "size": 214373, + "subdir": "linux-64", + "timestamp": 1624953737565, + "version": "1.4.3" + }, + "typed-ast-1.4.3-py39h7f8727e_1.tar.bz2": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 AND PSF-2.0 AND MIT", + "license_family": "Apache", + "md5": "e95b4aa8b4fbac725eb7eb330c427b0f", + "name": "typed-ast", + "sha256": "a1bbd5ef4b4073748ab579f8433e0c659b8b1fb182c99f545cdd61bf93d65d0b", + "size": 216099, + "subdir": "linux-64", + "timestamp": 1624953750784, + "version": "1.4.3" + }, + "typeguard-2.13.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "32116de8fff8f12f25f4a6ca0839d4d9", + "name": "typeguard", + "sha256": "f05921181ab073d93a48035b90ba60e4236a4336e4dcebf78b302209d27c01db", + "size": 35584, + "subdir": "linux-64", + "timestamp": 1674631902702, + "version": "2.13.3" + }, + "typeguard-2.13.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "06ac57935e2532a5778f842ef3f93d1f", + "name": "typeguard", + "sha256": "8bee4ab3506559b9feb4947762c63f1a5ab10b6c9e919eb8bd2419293cdd3f4d", + "size": 48317, + "subdir": "linux-64", + "timestamp": 1676846107567, + "version": "2.13.3" + }, + "typeguard-2.13.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15fd3a39273c4a3d4718736362651488", + "name": "typeguard", + "sha256": "da3cb2fbc1585b1ff7ba3fa69995b5199fb611d3cf0593475b7e84e662bb2e49", + "size": 35313, + "subdir": "linux-64", + "timestamp": 1674631982994, + "version": "2.13.3" + }, + "typeguard-2.13.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "46ee9c3e4a5f213d1777d90eba266fce", + "name": "typeguard", + "sha256": "dba859a2babab8658f415cc9926b7e848652b9d602e0a56fa9b6157f05abcc2f", + "size": 35527, + "subdir": "linux-64", + "timestamp": 1674631955986, + "version": "2.13.3" + }, + "typeguard-2.13.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8516e15efd126d4a2d3923e2262a2c5b", + "name": "typeguard", + "sha256": "90827a4f828b548002270a218cf982858d117351f5bcd8df7a4ab26a94a05e78", + "size": 35348, + "subdir": "linux-64", + "timestamp": 1674631929444, + "version": "2.13.3" + }, + "typer-0.4.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.1.1,<9.0.0", + "colorama >=0.4.3,<0.5.0", + "python >=3.10,<3.11.0a0", + "shellingham >=1.3.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d5e63247f35ab4d3bec777d86dd93471", + "name": "typer", + "sha256": "29099d6bbea5dde6a818040026e31a819c2fcea7ce47901b00fb0f1b738eecc3", + "size": 50897, + "subdir": "linux-64", + "timestamp": 1651237229716, + "version": "0.4.1" + }, + "typer-0.4.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.1.1,<9.0.0", + "colorama >=0.4.3,<0.5.0", + "python >=3.11,<3.12.0a0", + "shellingham >=1.3.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e99b4ef744099e4b837d2d9cd95a6f22", + "name": "typer", + "sha256": "aa7117b09e459c6bf7a60fafc703d2f099b8177fd03a4eccc4bb1970d42c4204", + "size": 68591, + "subdir": "linux-64", + "timestamp": 1676842970793, + "version": "0.4.1" + }, + "typer-0.4.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.1.1,<9.0.0", + "colorama >=0.4.3,<0.5.0", + "python >=3.7,<3.8.0a0", + "shellingham >=1.3.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e578716484faa3f72b8c202363b58e6", + "name": "typer", + "sha256": "27513ee2ec2c1e8956760bef4441b1acccbf5e97bb5d30ed9bc0898e80ca275a", + "size": 48521, + "subdir": "linux-64", + "timestamp": 1651237193784, + "version": "0.4.1" + }, + "typer-0.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.1.1,<9.0.0", + "colorama >=0.4.3,<0.5.0", + "python >=3.8,<3.9.0a0", + "shellingham >=1.3.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ac95c4f15ec7d305c2d2b0dfae5ffdb0", + "name": "typer", + "sha256": "05f8c00562f446f6c08fa2c05c07219a51e639b2288c708a1e6076cdd8a60a87", + "size": 48962, + "subdir": "linux-64", + "timestamp": 1651237278895, + "version": "0.4.1" + }, + "typer-0.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.1.1,<9.0.0", + "colorama >=0.4.3,<0.5.0", + "python >=3.9,<3.10.0a0", + "shellingham >=1.3.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0af407c7e8d458eb7db29f4199acf47a", + "name": "typer", + "sha256": "86971141bfcf91c689064089e2047205c8ac739391a49d2d3e2d8d5f26dc7029", + "size": 48937, + "subdir": "linux-64", + "timestamp": 1651237255250, + "version": "0.4.1" + }, + "types-pytz-2022.4.0.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 AND MIT", + "md5": "abe1fde6a7ff8df4fbd2eb0983b7244b", + "name": "types-pytz", + "sha256": "e61d078651380ee742563cfe29c2019ce3b2b7f9022403af430093965e90ff06", + "size": 12850, + "subdir": "linux-64", + "timestamp": 1665514295712, + "version": "2022.4.0.0" + }, + "types-pytz-2022.4.0.0-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0 AND MIT", + "md5": "66e1b5184a61ed91b712809d10e713db", + "name": "types-pytz", + "sha256": "2d489ccd643f1d73edccf3243a9e8e11a2bd75048b9831223d79a4b0623509c9", + "size": 13242, + "subdir": "linux-64", + "timestamp": 1676846121986, + "version": "2022.4.0.0" + }, + "types-pytz-2022.4.0.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 AND MIT", + "md5": "3cb8a20983ca979f9dc84f55b61c414e", + "name": "types-pytz", + "sha256": "a160c2ce7304496e5d400213ba94aebf0f904e3b6948b8bbafd7f2d2931f271c", + "size": 12836, + "subdir": "linux-64", + "timestamp": 1665514343899, + "version": "2022.4.0.0" + }, + "types-pytz-2022.4.0.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 AND MIT", + "md5": "36d5771f79dbde76356f56c27ed931e6", + "name": "types-pytz", + "sha256": "c827a4268fe72b46e647e70477eefeb598cf5575e873916c63594ba685f9d973", + "size": 12847, + "subdir": "linux-64", + "timestamp": 1665514271526, + "version": "2022.4.0.0" + }, + "types-pytz-2022.4.0.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 AND MIT", + "md5": "730854706baa64b2e63d23bf3d9e4079", + "name": "types-pytz", + "sha256": "4587a3d2e8389eb81ff7402d4acb14ffd320e75daea56f704816bcd2e262c159", + "size": 12826, + "subdir": "linux-64", + "timestamp": 1665514319178, + "version": "2022.4.0.0" + }, + "typing-3.10.0.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "PSF", + "md5": "a903d275ca29cd4b5d2aa6bd6b2cbfd3", + "name": "typing", + "sha256": "87d23706839cc710124e5250751dc6a5bd7bc48b152a35f19f1cd56aa1be1a50", + "size": 7853, + "subdir": "linux-64", + "timestamp": 1640795559347, + "version": "3.10.0.0" + }, + "typing-3.10.0.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "PSF", + "md5": "6b069a108408d96843bbb5aa86867479", + "name": "typing", + "sha256": "7d5ece5cd7712c3a6bed6fcb9b7f13e38342578c1586f67e1860f2adf3e33869", + "size": 8127, + "subdir": "linux-64", + "timestamp": 1676828887149, + "version": "3.10.0.0" + }, + "typing-3.10.0.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "273f408dbcaed13702567061b08b1c59", + "name": "typing", + "sha256": "7ec253aba7f8b058131d4f845a65a3f9059328e5cbd4fe05bcde2ecd00729033", + "size": 7919, + "subdir": "linux-64", + "timestamp": 1620168048534, + "version": "3.10.0.0" + }, + "typing-3.10.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "60a2ba319c9b693b306ef463937ade68", + "name": "typing", + "sha256": "b90b3c5ce21d8d46bb3bc5f30e7b2448bf8d2f8dec8fa22fca54837839085d4d", + "size": 7922, + "subdir": "linux-64", + "timestamp": 1620172048569, + "version": "3.10.0.0" + }, + "typing-3.10.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "ba29d7c683adb94aff97a35d8c79d0eb", + "name": "typing", + "sha256": "b538ae80427183ac3aaf808d2ee355eaa38cb5cb8541ac8a0c41d446475a615a", + "size": 7942, + "subdir": "linux-64", + "timestamp": 1620172050749, + "version": "3.10.0.0" + }, + "typing-3.10.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "667a534535baaf93ada36c32eb173fd8", + "name": "typing", + "sha256": "6868606b612d0145de88de7f55d40dc94db683ec2a1639e706050d1993eab53c", + "size": 7952, + "subdir": "linux-64", + "timestamp": 1620171616726, + "version": "3.10.0.0" + }, + "typing-3.6.2-py27h66f49e2_0.tar.bz2": { + "build": "py27h66f49e2_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "6e9c937bf8f1d514bb480e2aeb296e2a", + "name": "typing", + "sha256": "47a1670bcaa8ccb4cd09a131a6e6e251c4201d1e48db3aa46db2336ab2b22879", + "size": 40343, + "subdir": "linux-64", + "timestamp": 1505864007847, + "version": "3.6.2" + }, + "typing-3.6.2-py35hcadae7e_0.tar.bz2": { + "build": "py35hcadae7e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "PSF", + "md5": "4a92a0dd2d5e1df2d4d63fe496d8cba5", + "name": "typing", + "sha256": "1c4dca310a67e115b67f736f9e93ac70f828e3c55871e84463053652ec3f16b5", + "size": 45245, + "subdir": "linux-64", + "timestamp": 1505864019969, + "version": "3.6.2" + }, + "typing-3.6.2-py36h7da032a_0.tar.bz2": { + "build": "py36h7da032a_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "9cbdd1a94dfd5cdd12fa892b70567777", + "name": "typing", + "sha256": "0b77a5ff5af7a3c851b990bbc44925ca3bc9b3583388b57e3305529953627c9a", + "size": 45183, + "subdir": "linux-64", + "timestamp": 1505864032217, + "version": "3.6.2" + }, + "typing-3.6.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "d0b668f131f35a6b3c6ecb2873fb2431", + "name": "typing", + "sha256": "5b82c47ea83ca24779228cf1783fba7ee7c721b81a67c6fe2ddbae71b3b7e9b7", + "size": 40923, + "subdir": "linux-64", + "timestamp": 1519139562885, + "version": "3.6.4" + }, + "typing-3.6.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "PSF", + "md5": "f5f149f951a04484f459f60182ffc7ad", + "name": "typing", + "sha256": "12a6033f8ec7f6a2bdd1a676a6d08cff782b28f2b64db0502094ef7301775c4e", + "size": 45632, + "subdir": "linux-64", + "timestamp": 1519139623599, + "version": "3.6.4" + }, + "typing-3.6.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "6184be730b025c070e42a5eedce0bcec", + "name": "typing", + "sha256": "a1d997a70bfe3da58a10bce1619893f0ca28f60001d722b7156a926818d86722", + "size": 45642, + "subdir": "linux-64", + "timestamp": 1519139621470, + "version": "3.6.4" + }, + "typing-3.6.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "b35bd3a8b2b7a5f015e549048ea2fd4a", + "name": "typing", + "sha256": "789bbde7d29fa4bf053276f0accee63119bd2496383e0c3624f7fe37c1abd8a8", + "size": 45464, + "subdir": "linux-64", + "timestamp": 1530694981874, + "version": "3.6.4" + }, + "typing-3.6.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "c7553458a0fc295e780927ec5d554793", + "name": "typing", + "sha256": "a91edf4521162e56e074287b51da460a60d0170473aa30171c57d6b8d9903ccc", + "size": 41057, + "subdir": "linux-64", + "timestamp": 1535378969153, + "version": "3.6.6" + }, + "typing-3.6.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "PSF", + "md5": "b2252a1b62d65025b0d1faf4c060e7a7", + "name": "typing", + "sha256": "c233640145fe5dc03f7db59ca04971d760c0751fe1f17a9e0a681790a62fbb7c", + "size": 45840, + "subdir": "linux-64", + "timestamp": 1535378979419, + "version": "3.6.6" + }, + "typing-3.7.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "c7f5ac11439151aeeea52fa1d026d9c0", + "name": "typing", + "sha256": "c41696ec4c3903446a76a5d1301e372e7bd33b817a4f45563d134e1f5bca546a", + "size": 50481, + "subdir": "linux-64", + "timestamp": 1562085576206, + "version": "3.7.4" + }, + "typing-3.7.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "96c3a1662e69981d1bff99081effd1d6", + "name": "typing", + "sha256": "02197370efcf997bf84e8ef6b8f4f965070ec6e4a4d599dbb79f20d7ec409766", + "size": 50824, + "subdir": "linux-64", + "timestamp": 1569266839325, + "version": "3.7.4.1" + }, + "typing-3.7.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "9f9ef848c50774dbfe3e77eec2554cb0", + "name": "typing", + "sha256": "5f72c7b40b1781c807f6cdd73ce3e1f5060526e8f965eda0898bde2c7d4db98c", + "size": 51038, + "subdir": "linux-64", + "timestamp": 1592249999988, + "version": "3.7.4.1" + }, + "typing-3.7.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "dbfd946ac1a126430ffcf59884d78322", + "name": "typing", + "sha256": "7ad70e97303b83600828b7b0eb4bddb045889529106e7bc0f3171ca551979017", + "size": 50948, + "subdir": "linux-64", + "timestamp": 1592250064593, + "version": "3.7.4.1" + }, + "typing-3.7.4.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "daf6074d4278e1e29f7c097e227f738e", + "name": "typing", + "sha256": "2143cb8828c0c7beec1a8427253e4d0ea0659694638455c96999403c293c8f26", + "size": 51258, + "subdir": "linux-64", + "timestamp": 1592250039921, + "version": "3.7.4.1" + }, + "typing-3.7.4.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "77b2a55d61e9db9d0d58c0ebd3e76375", + "name": "typing", + "sha256": "54413fd3ad433a3daecde47d46ae2c7a26a3af559c61fbf984ddbd2ac61ea894", + "size": 12082, + "subdir": "linux-64", + "timestamp": 1594747962190, + "version": "3.7.4.3" + }, + "typing-3.7.4.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "fdad6f228dda6937508c271afc53d4f5", + "name": "typing", + "sha256": "76c34e7d0a06d4e4cc5e1b2107c09e0000027baba237bd6250e872c30d0b7131", + "size": 12098, + "subdir": "linux-64", + "timestamp": 1611751130609, + "version": "3.7.4.3" + }, + "typing-3.7.4.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "747f8d0fd322293030c0a93cb076e8f0", + "name": "typing", + "sha256": "6824cc266faa3369de14d299cd8554bb45a07130eabb62312fe3974bff9d5668", + "size": 12076, + "subdir": "linux-64", + "timestamp": 1594747961244, + "version": "3.7.4.3" + }, + "typing-3.7.4.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "0569f61331cf33ed94ab8570a7ccb6df", + "name": "typing", + "sha256": "bab1a4c15d1f85547b24811c272ed1897e3a1ec4fc1673aa8804a9b8b8b247fd", + "size": 12069, + "subdir": "linux-64", + "timestamp": 1611751110746, + "version": "3.7.4.3" + }, + "typing-3.7.4.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "9742e4ffca044d9a380029fc787f654c", + "name": "typing", + "sha256": "7a5f6d0c930db159af0419799550fa690cc753f2afd5a8649b202acb6de9f8b5", + "size": 12093, + "subdir": "linux-64", + "timestamp": 1594747716455, + "version": "3.7.4.3" + }, + "typing-3.7.4.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "d6fa4bd17c5ad48b1ad313aa2251369f", + "name": "typing", + "sha256": "e04f6ed32758552040776e9305915f511b1d84f6b8f7fe478ebc01c73d752966", + "size": 12112, + "subdir": "linux-64", + "timestamp": 1611751126716, + "version": "3.7.4.3" + }, + "typing-3.7.4.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "a61323e8ba7c4bd90c4583e11dd5713d", + "name": "typing", + "sha256": "475cc5eec16c69ab9cd4099da65e2b1db13395e052a280c644c710f6e1d78d14", + "size": 12125, + "subdir": "linux-64", + "timestamp": 1611751096323, + "version": "3.7.4.3" + }, + "typing-extensions-3.7.4-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "python", + "typing_extensions 3.7.4 py36_0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "4507be3260dcaf764219de0e1c09fbb6", + "name": "typing-extensions", + "sha256": "2593f4c0d201c1f60064e5308bae9c20ba1aac4ff2083655505c5e5a66634bdb", + "size": 10261, + "subdir": "linux-64", + "timestamp": 1569354439008, + "version": "3.7.4" + }, + "typing-extensions-3.7.4.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "python", + "typing_extensions 3.7.4.1 py38_0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "31994ed6ff9b67ee10e44ac5da7182a3", + "name": "typing-extensions", + "sha256": "ac5ffcd8fa3459c3ee5ade918db9385b903bd5156c408de146e4f5308abfea8c", + "size": 10732, + "subdir": "linux-64", + "timestamp": 1573975369052, + "version": "3.7.4.1" + }, + "typing-extensions-4.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "typing_extensions 4.3.0 py310h06a4308_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "2a3efe1ac5d896ed64f1814abd268788", + "name": "typing-extensions", + "sha256": "a70e56b3010bba17f2685dbf3896a0d919204b245436625cc1d8930884eacfc3", + "size": 8830, + "subdir": "linux-64", + "timestamp": 1659646979837, + "version": "4.3.0" + }, + "typing-extensions-4.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions 4.3.0 py37h06a4308_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "e1af4e283240f9683f99de22243a891a", + "name": "typing-extensions", + "sha256": "393f5f3beb7d2af7c354859e216256d55372579d199ab75a8dd98332da6e65e2", + "size": 8823, + "subdir": "linux-64", + "timestamp": 1659646941305, + "version": "4.3.0" + }, + "typing-extensions-4.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "typing_extensions 4.3.0 py38h06a4308_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "1fce7d76876ae3ee0b26e699e29007b9", + "name": "typing-extensions", + "sha256": "f7d342827a8739d1f994b62c52c330f8118649ccab751f30437c0d1947feff76", + "size": 8824, + "subdir": "linux-64", + "timestamp": 1659646884488, + "version": "4.3.0" + }, + "typing-extensions-4.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "typing_extensions 4.3.0 py39h06a4308_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "dfb50d579a0a9d64694fa8fc9ad29a8a", + "name": "typing-extensions", + "sha256": "e1e71c101d4e958adb75689e7e1e6572d9785844dcefa5eabf78ca2fb80587e4", + "size": 8817, + "subdir": "linux-64", + "timestamp": 1659646912817, + "version": "4.3.0" + }, + "typing-extensions-4.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "typing_extensions 4.4.0 py310h06a4308_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "8511b9973eb99a71fe72362279115cc0", + "name": "typing-extensions", + "sha256": "e7856f5b875b0f28dc3d4e8652403d6670b2feef897e5dcbffda59d6299f80a2", + "size": 8131, + "subdir": "linux-64", + "timestamp": 1669924695636, + "version": "4.4.0" + }, + "typing-extensions-4.4.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "typing_extensions 4.4.0 py311h06a4308_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "fdf90fa348f46263f3097edff0325a3b", + "name": "typing-extensions", + "sha256": "93398ebd4c6e85bf2c07c4f5412d1d5bef1727e865422cdecbfde5e1ee3faf26", + "size": 8395, + "subdir": "linux-64", + "timestamp": 1676822531595, + "version": "4.4.0" + }, + "typing-extensions-4.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions 4.4.0 py37h06a4308_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "be11f1157544d4c5348be0377b19975d", + "name": "typing-extensions", + "sha256": "711fc1f4c459ae8b42221a1779e9823189a728674df506771b198a22b675dab6", + "size": 8087, + "subdir": "linux-64", + "timestamp": 1669924624551, + "version": "4.4.0" + }, + "typing-extensions-4.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "typing_extensions 4.4.0 py38h06a4308_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "6778f7e784a8cfeeddfdd303b65cf253", + "name": "typing-extensions", + "sha256": "cf1cec683e3055f515694241a4e4b8b3442e7d007a068334bb1e4fde44f15f3f", + "size": 8101, + "subdir": "linux-64", + "timestamp": 1669924589305, + "version": "4.4.0" + }, + "typing-extensions-4.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "typing_extensions 4.4.0 py39h06a4308_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "01c9a294dbc9885819a21903950a0e9e", + "name": "typing-extensions", + "sha256": "ebf2655a4249243c67436bfb572bcb7606fec7d42fa34025d2f833f7b6292c12", + "size": 8104, + "subdir": "linux-64", + "timestamp": 1669924659728, + "version": "4.4.0" + }, + "typing_extensions-3.7.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "typing >=3.7.4" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "f22244e91d0cdc614e01de8066478817", + "name": "typing_extensions", + "sha256": "c9d5943984c0755a4d47d3cdc97dcf87f55d6a381aad333558014c02ed72f7bf", + "size": 18195, + "subdir": "linux-64", + "timestamp": 1569354436357, + "version": "3.7.4" + }, + "typing_extensions-3.7.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "22a0fabf0999a9153314d0f5d946aa16", + "name": "typing_extensions", + "sha256": "a293b258ddb84d9b27e87182dccc3a885280bf834989fc0ab2d6a0b8ad24403d", + "size": 41402, + "subdir": "linux-64", + "timestamp": 1569354436212, + "version": "3.7.4" + }, + "typing_extensions-3.7.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "0a3143bc209b93b33d74c8032870c5a0", + "name": "typing_extensions", + "sha256": "3056801c05b43435e70f7753a1ef22d45d63c1e9a84e256fb83c0d861699099c", + "size": 41336, + "subdir": "linux-64", + "timestamp": 1569354474512, + "version": "3.7.4" + }, + "typing_extensions-3.7.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "24cd80f9c26247ee6cbb235ed0788bce", + "name": "typing_extensions", + "sha256": "4b6d22b9991288a22c70fd5b1c0186871e18abe7bbd176734b3b06ba866bc872", + "size": 40045, + "subdir": "linux-64", + "timestamp": 1573200309422, + "version": "3.7.4" + }, + "typing_extensions-3.7.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "typing >=3.7.4" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "a31aa152375f3a2854a59a14d279f0ff", + "name": "typing_extensions", + "sha256": "57c1d9e9647a984de75d5e1ec6105decbb6b31bc114ddced5294989525ad8a52", + "size": 18708, + "subdir": "linux-64", + "timestamp": 1573975316951, + "version": "3.7.4.1" + }, + "typing_extensions-3.7.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "ac15a7158422906ac809783480a65f4c", + "name": "typing_extensions", + "sha256": "c5ad91754042f182f088faf23e0f8c2bba4d2479d66d0ba92b6df57a4f7ae46e", + "size": 42058, + "subdir": "linux-64", + "timestamp": 1573975250663, + "version": "3.7.4.1" + }, + "typing_extensions-3.7.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "5a5473b1fe437872f3af5658eff89587", + "name": "typing_extensions", + "sha256": "10fef869c6f29fd0c4b906c38199e4ea75b2229537de768ed5f74cfda837d6a1", + "size": 42017, + "subdir": "linux-64", + "timestamp": 1573975311113, + "version": "3.7.4.1" + }, + "typing_extensions-3.7.4.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "412afe3f5da2c21b04c3ff10479e5e59", + "name": "typing_extensions", + "sha256": "d3f40664a73078188452633128cf6f8dc181fade4d642b0814fb4f716cfdf4ad", + "size": 42368, + "subdir": "linux-64", + "timestamp": 1573975362923, + "version": "3.7.4.1" + }, + "typing_extensions-4.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "d4f8bda7ede3588afc6f5dd4e6cc75e4", + "name": "typing_extensions", + "sha256": "ec9dad868df22cd1b339d2ddc2b27288db987052ffdb59c0f3002b854fa8c768", + "size": 45156, + "subdir": "linux-64", + "timestamp": 1659638902760, + "version": "4.3.0" + }, + "typing_extensions-4.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "587f4578b8d6abf3e17d576e319ec39a", + "name": "typing_extensions", + "sha256": "e9800f7432b641673c99a16efd16195a95bb5f881cd7d13a0504a9ac447aef02", + "size": 44710, + "subdir": "linux-64", + "timestamp": 1659638848414, + "version": "4.3.0" + }, + "typing_extensions-4.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "226bf89e4ee4dde5f9dfbd1a13f6b00d", + "name": "typing_extensions", + "sha256": "5937bd29de469a0c3a6c2c859f5e37879b9ea5e6e049f5fabe0ff7b7447314c4", + "size": 44945, + "subdir": "linux-64", + "timestamp": 1659638924152, + "version": "4.3.0" + }, + "typing_extensions-4.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "259aebda0d152d106e7243bd9fc946af", + "name": "typing_extensions", + "sha256": "5f769f3f7d26752de74c0b4df80b004123dd8ea96291c2ef371a75a22c1caf5a", + "size": 44919, + "subdir": "linux-64", + "timestamp": 1659638870582, + "version": "4.3.0" + }, + "typing_extensions-4.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.6,<4", + "python >=3.10,<3.11.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "56c5d621a13bae4fe9df9214bdf741f0", + "name": "typing_extensions", + "sha256": "7a6865eef800136c0498a29766a202dbfec16712c15e30c7577c1353e0fddc71", + "size": 46369, + "subdir": "linux-64", + "timestamp": 1669924689894, + "version": "4.4.0" + }, + "typing_extensions-4.4.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.6,<4", + "python >=3.11,<3.12.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "7345a31f7c5557585fe7ba24e903c8e8", + "name": "typing_extensions", + "sha256": "386335d1961a2120de8593ed6a9dca069c4e2f78949ab74b9d8da5ef1c7d0754", + "size": 57073, + "subdir": "linux-64", + "timestamp": 1676822528160, + "version": "4.4.0" + }, + "typing_extensions-4.4.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.6,<4", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "6e52121d3c7b2d36281255a2aa33be44", + "name": "typing_extensions", + "sha256": "f4a42625bcbf16835126b0777feb5bd70b3908054fa045bc9463e3c55990c910", + "size": 45895, + "subdir": "linux-64", + "timestamp": 1669924619181, + "version": "4.4.0" + }, + "typing_extensions-4.4.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.6,<4", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "ff34a2d955becbddc53a6816d13d1ec6", + "name": "typing_extensions", + "sha256": "9a5b73d60eccfd0e332593acce8cc17b821463c1cf0b2e2be3bbb70da330a26c", + "size": 46090, + "subdir": "linux-64", + "timestamp": 1669924583937, + "version": "4.4.0" + }, + "typing_extensions-4.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.6,<4", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "380a1666cbc35c2535af87f179de8617", + "name": "typing_extensions", + "sha256": "89a494caead677d33e53d957c4fab1bc67e91a19783e1db454a0cd66067d3334", + "size": 46016, + "subdir": "linux-64", + "timestamp": 1669924654177, + "version": "4.4.0" + }, + "typogrify-2.0.7-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "smartypants >=1.8.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dcce5b6fa1154e7654d6a5808f12dbcc", + "name": "typogrify", + "sha256": "1701ab5fb121a410f8dc1318a264df8fb563fa1c828c6b6532dc5431dc0077f7", + "size": 23176, + "subdir": "linux-64", + "timestamp": 1677593254081, + "version": "2.0.7" + }, + "typogrify-2.0.7-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "smartypants >=1.8.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3572a4202bd32a50cd4f94b48c733a57", + "name": "typogrify", + "sha256": "d3541f5b9b97a2f20150f64d8a9932e4298ede73e0a97185b391c554674868b4", + "size": 27715, + "subdir": "linux-64", + "timestamp": 1679340345732, + "version": "2.0.7" + }, + "typogrify-2.0.7-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "smartypants >=1.8.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "43cb6ca4201beba8b2e2cc3926e54e66", + "name": "typogrify", + "sha256": "b297a5d9fb0a5e85f7c9730829ab8d663a46b262e5195d7cb7127186610b5cfb", + "size": 23107, + "subdir": "linux-64", + "timestamp": 1677593277989, + "version": "2.0.7" + }, + "typogrify-2.0.7-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "smartypants >=1.8.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ebb270e06383011e5c915ba4f74954c2", + "name": "typogrify", + "sha256": "fcafa371f2d391f51e7d04b0f89fca4965adf2122fa3e00506e9c39233329b60", + "size": 23121, + "subdir": "linux-64", + "timestamp": 1677593301766, + "version": "2.0.7" + }, + "typogrify-2.0.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "smartypants >=1.8.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "157e809151a600234ab31cc77038d694", + "name": "typogrify", + "sha256": "0131c9ecfb8c1b4e0f70a216408893b2356ba0a8d2812ed13d9a734d77c25227", + "size": 23131, + "subdir": "linux-64", + "timestamp": 1677593230045, + "version": "2.0.7" + }, + "tzlocal-1.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "c3915e6c5b6c11ae6c1e40a48aaad764", + "name": "tzlocal", + "sha256": "556547fb2fe72c4a72d2cecec2383939f188a9b8ae871022ee1fa53964e365ee", + "size": 27349, + "subdir": "linux-64", + "timestamp": 1529579512681, + "version": "1.5.1" + }, + "tzlocal-1.5.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytz" + ], + "license": "MIT", + "md5": "0f9ad49d44e1e39a4e24f5c2de68a8bb", + "name": "tzlocal", + "sha256": "3d4cc75679c4e0e0f85a298e5be919384d3980288039362d4e88b2b31bed0a43", + "size": 32088, + "subdir": "linux-64", + "timestamp": 1659703455445, + "version": "1.5.1" + }, + "tzlocal-1.5.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "MIT", + "md5": "d18637c97b6ae58768fdb95b77dbf2fb", + "name": "tzlocal", + "sha256": "fcfaedfe90af9d31ef3ddeecbfff516fb36941db3cef61365bd6e5c8b0fb81fb", + "size": 27357, + "subdir": "linux-64", + "timestamp": 1529579573554, + "version": "1.5.1" + }, + "tzlocal-1.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "a22cd0cc0676c14ec26bd6cf7459fd62", + "name": "tzlocal", + "sha256": "f677bf600ff470be08f84790d3f2ac0a0f2075a84c2c7897259533038a30f56d", + "size": 26671, + "subdir": "linux-64", + "timestamp": 1529579509525, + "version": "1.5.1" + }, + "tzlocal-1.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "23e04213040eea44bb8fe1f3b6e6e68d", + "name": "tzlocal", + "sha256": "d2e4ea8f632127bfd3bd2ac34264b803479918a4cfa41cc24140481599c5f828", + "size": 26731, + "subdir": "linux-64", + "timestamp": 1537652410372, + "version": "1.5.1" + }, + "tzlocal-1.5.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "9c7770dd0a2306b14523d62a2a84d8fd", + "name": "tzlocal", + "sha256": "917be642f57e1b72fe9cedef192a296b163c35b103d58fd5ed70ff5eb40d4ea5", + "size": 28196, + "subdir": "linux-64", + "timestamp": 1659703477031, + "version": "1.5.1" + }, + "tzlocal-1.5.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "d03cdce3403f96b78e680eee2282b5ad", + "name": "tzlocal", + "sha256": "8493b5a6c1f9a59fb333f83426de0e1dc59f6819120c3b21c202fcaded4a8102", + "size": 28434, + "subdir": "linux-64", + "timestamp": 1659703424344, + "version": "1.5.1" + }, + "tzlocal-1.5.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "a9c60a19a43817e46af843a7b2240975", + "name": "tzlocal", + "sha256": "f101c765d180bd13953775938fecdd4646b29f1b38ad22d478bbfaaa018df18b", + "size": 28463, + "subdir": "linux-64", + "timestamp": 1659703498216, + "version": "1.5.1" + }, + "tzlocal-2.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "886942a3a482c99181b61329a2d5a723", + "name": "tzlocal", + "sha256": "a5109d05fed7d61a09f6ba7ef91a3fd19da4e7715a52f7c42311dd45467a77c6", + "size": 28855, + "subdir": "linux-64", + "timestamp": 1564710514522, + "version": "2.0.0" + }, + "tzlocal-2.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "fc83e66273e76ca7da440a3b0768cef8", + "name": "tzlocal", + "sha256": "88a049c9f61356ebf2e013eabd9ad55297fe170634831c2db44b7ecc862c109d", + "size": 28134, + "subdir": "linux-64", + "timestamp": 1564710535408, + "version": "2.0.0" + }, + "tzlocal-2.0.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "7f7b8d1f9522e3536a8f01873c619174", + "name": "tzlocal", + "sha256": "909241d5107625011f82efcf317c353d757c53f0f1b504a20b278c99a44bcf81", + "size": 28994, + "subdir": "linux-64", + "timestamp": 1613144869393, + "version": "2.0.0" + }, + "tzlocal-2.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "d20424cfd178285b1f5cf295ae0860f2", + "name": "tzlocal", + "sha256": "f5f6b8e6a61ee0bcc70e9d336e2c0878c5b135bfea4ff3b9fccab39c03e664ff", + "size": 28122, + "subdir": "linux-64", + "timestamp": 1564710173019, + "version": "2.0.0" + }, + "tzlocal-2.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "c8ca4a10735f98ed7271a86ec731f476", + "name": "tzlocal", + "sha256": "d13bc3c309c87a5fb313bc35c831673cbe20b6f16024059609a5828ad30fb4be", + "size": 29037, + "subdir": "linux-64", + "timestamp": 1613145314325, + "version": "2.0.0" + }, + "tzlocal-2.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "67ef4c3c4a91416c42a472de6f9bd8af", + "name": "tzlocal", + "sha256": "2a89b754ae26fd4bbf1335eedf78a2d5c819797454a708424c3fa5f86c687dfd", + "size": 26490, + "subdir": "linux-64", + "timestamp": 1573554860257, + "version": "2.0.0" + }, + "tzlocal-2.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "a4888d0c04dc316a5e330c50a83840e6", + "name": "tzlocal", + "sha256": "37b554b5cc1922d1fed4aa000b7815e336ab7da883c5c3d0853508b2504b1d1f", + "size": 29277, + "subdir": "linux-64", + "timestamp": 1613145321970, + "version": "2.0.0" + }, + "tzlocal-2.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "8fab97ccd047f73e70a0c5146df34896", + "name": "tzlocal", + "sha256": "2a4024eed123ba1badc12add45f52e9c1ff8db87af5a29c41c3ac9bd21a5b9e1", + "size": 29304, + "subdir": "linux-64", + "timestamp": 1613145322353, + "version": "2.0.0" + }, + "tzlocal-2.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytz" + ], + "license": "MIT", + "md5": "782039b04d45b2ae54f270184cb8368e", + "name": "tzlocal", + "sha256": "7adcf6641f1334b280f5e246ed9034553da33b90eeaf00683df62dd884c02850", + "size": 30393, + "subdir": "linux-64", + "timestamp": 1640795577170, + "version": "2.1" + }, + "tzlocal-2.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7279fd11129567090c937a9c30931c7a", + "name": "tzlocal", + "sha256": "34ff911ede11092651192e055d76ceef9583b30c63251321b8a1df6e2ac13c27", + "size": 30642, + "subdir": "linux-64", + "timestamp": 1668627684640, + "version": "2.1" + }, + "tzlocal-2.1-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6de6f398120f44e4ec28b1115164b94d", + "name": "tzlocal", + "sha256": "061db40dc038f783128e414082893debb91caf9970576b53fa167d106004e72e", + "size": 35702, + "subdir": "linux-64", + "timestamp": 1676842985251, + "version": "2.1" + }, + "tzlocal-2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "326ebd5e0f676080903133c1eb3a7c29", + "name": "tzlocal", + "sha256": "68dda37ed4d3708feadc3f3da1de775522e1f99b1078cf8f03a186771b0dd733", + "size": 28768, + "subdir": "linux-64", + "timestamp": 1597435751899, + "version": "2.1" + }, + "tzlocal-2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "6dedfa1234671156c3e16abc72f5049c", + "name": "tzlocal", + "sha256": "52b6bd3ed710dcfe67b7d5ea60bfcdb24cfad65cdecc6b9434daf45f1db96f97", + "size": 28782, + "subdir": "linux-64", + "timestamp": 1597435747660, + "version": "2.1" + }, + "tzlocal-2.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7188bc42f2aed1d03ee9e074476afc6c", + "name": "tzlocal", + "sha256": "55cc9c6ab8a1d207f9c6bcd8cf9270cab90d7dc051ee81efd9e13fd8a78da246", + "size": 26893, + "subdir": "linux-64", + "timestamp": 1668627630663, + "version": "2.1" + }, + "tzlocal-2.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "020ed1798feea346ee50ef8495dde710", + "name": "tzlocal", + "sha256": "d5633707b6cd0799302dee709992700ea904a7d31f3e5b0dcc12bd0c20e10a2d", + "size": 29003, + "subdir": "linux-64", + "timestamp": 1597435760220, + "version": "2.1" + }, + "tzlocal-2.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ce65e2f8248bbe7af4958ff57adf861", + "name": "tzlocal", + "sha256": "adb9a7ef2f306bb9eed8d98ae2886e87651bb54ddc45a7f58065afbd95e755f6", + "size": 27080, + "subdir": "linux-64", + "timestamp": 1668627711015, + "version": "2.1" + }, + "tzlocal-2.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "f25424d2f072e78597548dec377ef424", + "name": "tzlocal", + "sha256": "0a13ab792db9bf9c6b09749a9bc33df2571876b6232303aa5383cdedc9ec33a4", + "size": 29136, + "subdir": "linux-64", + "timestamp": 1608245380590, + "version": "2.1" + }, + "tzlocal-2.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2eb62508cf49ed743190860407fc33e0", + "name": "tzlocal", + "sha256": "82a4590a849f7a01905e78e3e4b3fbce494fe73b17579a6b3a785d70ed01e27b", + "size": 27193, + "subdir": "linux-64", + "timestamp": 1668627657649, + "version": "2.1" + }, + "uc-micro-py-1.0.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a74bf3425ae419af7b95b622b81de24", + "name": "uc-micro-py", + "sha256": "c67bb54cb344ab975ef08503be4a57ee320ef62c9921f26b5aaeb91131481dbe", + "size": 10781, + "subdir": "linux-64", + "timestamp": 1659769481565, + "version": "1.0.1" + }, + "uc-micro-py-1.0.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c402d5bf4e01c8c3895c9ef41707b6e", + "name": "uc-micro-py", + "sha256": "509b962773f0fe44a93a7f6196b254670a030eac8ea7f90727312e3ccd9294b2", + "size": 11371, + "subdir": "linux-64", + "timestamp": 1676828901104, + "version": "1.0.1" + }, + "uc-micro-py-1.0.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5bc19838468bb19a2414ff3df8996784", + "name": "uc-micro-py", + "sha256": "f2d9d485bc8efa1635c1188c5753bd21d8ec98b79a6ede2d5dc7f54c955164da", + "size": 10722, + "subdir": "linux-64", + "timestamp": 1659769535849, + "version": "1.0.1" + }, + "uc-micro-py-1.0.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49a0a2c9c5a1f0ea96f8eacebaf20e49", + "name": "uc-micro-py", + "sha256": "312fa66c020ac59a22eff656ec4a07e039606f013df3a57f93eb59b4899bbc3e", + "size": 10731, + "subdir": "linux-64", + "timestamp": 1659769442938, + "version": "1.0.1" + }, + "uc-micro-py-1.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "89e6a047e97aa6b06c8a217e64182646", + "name": "uc-micro-py", + "sha256": "bdafa637d91ee2986a37cc82eb18c7b9b6e467eddd2eac3f510ad878a5b45da2", + "size": 10729, + "subdir": "linux-64", + "timestamp": 1659769510353, + "version": "1.0.1" + }, + "udunits2-2.2.25-hd30922c_1.tar.bz2": { + "build": "hd30922c_1", + "build_number": 1, + "depends": [ + "expat", + "libgcc-ng >=7.2.0" + ], + "license": "UCAR OSI approved", + "md5": "1525535a72f488ff852f8f7bfb9e1f3b", + "name": "udunits2", + "sha256": "f5fe5067ea058853f4436e6f190df2f96f85c9b45f7f86f909cb61b5f332bb68", + "size": 165156, + "subdir": "linux-64", + "timestamp": 1507908864208, + "version": "2.2.25" + }, + "ujson-1.35-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "67dedd6cef2f84786b85a72e2c3480ba", + "name": "ujson", + "sha256": "87796ffe005d08337ca45e90f8f9f572281b16525036453f8bd0d5129d4f05a0", + "size": 27078, + "subdir": "linux-64", + "timestamp": 1530961770339, + "version": "1.35" + }, + "ujson-1.35-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "60a6e40fbdffaf2b0239f30cabc05c05", + "name": "ujson", + "sha256": "821ccd7cc59f4f7d999251219dccea5ff6791427463c31f8e8ffe7aeac9eeafa", + "size": 27883, + "subdir": "linux-64", + "timestamp": 1535739541348, + "version": "1.35" + }, + "ujson-1.35-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "44071f73ccf987feaa96cce2e2375373", + "name": "ujson", + "sha256": "f3ff0ca06f7e6200ea61d3f477e48ecaffb463debd40811c672a56e7e5fa4168", + "size": 27098, + "subdir": "linux-64", + "timestamp": 1530961802013, + "version": "1.35" + }, + "ujson-1.35-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ea662fb8f69f68b5fb2a1a6ae8b9870c", + "name": "ujson", + "sha256": "f03c5c2abdacbd57685336f5a5925be397d24688646d8c3f3265b824f1a532c4", + "size": 27123, + "subdir": "linux-64", + "timestamp": 1530961833984, + "version": "1.35" + }, + "ujson-1.35-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a1f5ec9276d420fd417f3075eda3a69a", + "name": "ujson", + "sha256": "0a020f85b15af6cfef676487fec7b6f42eab2e1902b5b23dc4f5a1fc7d5f17ae", + "size": 35693, + "subdir": "linux-64", + "timestamp": 1573200552758, + "version": "1.35" + }, + "ujson-2.0.3-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "03b266ff5bb538294f99fd4a1c1636ce", + "name": "ujson", + "sha256": "ac1fad7595150850d094d56d054c10435e543485de608a8cb3ddf2b93815331d", + "size": 48348, + "subdir": "linux-64", + "timestamp": 1586458603578, + "version": "2.0.3" + }, + "ujson-2.0.3-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "3a38bd186e699a225e6e90f3c2182d16", + "name": "ujson", + "sha256": "82f24f0205d880a7ca36a8ddabfcacf6f54b3fb9beb2114e9b6919ac0c993b1a", + "size": 48347, + "subdir": "linux-64", + "timestamp": 1586458589665, + "version": "2.0.3" + }, + "ujson-2.0.3-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d13ec333f15dd49458020541853c4c9e", + "name": "ujson", + "sha256": "f75b5dc4560c63fb4682fc173fefc24b965896bb62838ba6ff8ddef396fe3a5b", + "size": 48630, + "subdir": "linux-64", + "timestamp": 1586458581230, + "version": "2.0.3" + }, + "ujson-3.0.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "20462a59c5ab3c5cc7b5ed594737475d", + "name": "ujson", + "sha256": "927116c47147adf8171b07e11b1e976fbbb37b36538fc1e4afad6407dc9615f5", + "size": 51293, + "subdir": "linux-64", + "timestamp": 1592441293975, + "version": "3.0.0" + }, + "ujson-3.0.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b4d31895f37efbfa97557058c85f1889", + "name": "ujson", + "sha256": "82bb2019c4937703fdbf9db9e2f4f2e4b4a16793942366583c7c21d1f34c9b42", + "size": 51267, + "subdir": "linux-64", + "timestamp": 1592441264276, + "version": "3.0.0" + }, + "ujson-3.0.0-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "cd1491ed63acfc054919d2246feb0607", + "name": "ujson", + "sha256": "fca2a1ccb271daecd89067339d1e11766a1d2c8005d54aad3379567fa99c9175", + "size": 51525, + "subdir": "linux-64", + "timestamp": 1592441264386, + "version": "3.0.0" + }, + "ujson-3.1.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7b8d3f19d7c0c137773b2ca27722f49a", + "name": "ujson", + "sha256": "ca58f0332a5d1dcf473bc1b8e1de1f626146f48a735daf483bbab6ab91924c6e", + "size": 51696, + "subdir": "linux-64", + "timestamp": 1597931499965, + "version": "3.1.0" + }, + "ujson-3.1.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "96a30b4f4eb18d9fbc765f922480ef31", + "name": "ujson", + "sha256": "7c946e5a0ec3b81cef11a66258598a69b2f42656728203202c8fce92671ce5a5", + "size": 51674, + "subdir": "linux-64", + "timestamp": 1597931462649, + "version": "3.1.0" + }, + "ujson-3.1.0-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "29b4e0e167205acf39f4a0297b9c5f8a", + "name": "ujson", + "sha256": "64925401193cdbbefca213d7fa240116a1abc5105a1996d1495606ab1bfb4bcf", + "size": 51941, + "subdir": "linux-64", + "timestamp": 1597931493556, + "version": "3.1.0" + }, + "ujson-3.1.0-py39h66f3464_0.tar.bz2": { + "build": "py39h66f3464_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d4b0ba11352158fedfd0d187e7b14a09", + "name": "ujson", + "sha256": "9fa3f4e9d8049ebc01afffa031b58db6fc3683fb58547dfb5cd87387dcdbc44b", + "size": 52367, + "subdir": "linux-64", + "timestamp": 1607570432262, + "version": "3.1.0" + }, + "ujson-3.2.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "760f49e21846352ace3c8409a8064be6", + "name": "ujson", + "sha256": "2e9035f7646fc0ab41fde9ae16da5f45f06dff9c29a153a7d54aade5884f1630", + "size": 48795, + "subdir": "linux-64", + "timestamp": 1600709395780, + "version": "3.2.0" + }, + "ujson-3.2.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "90cb9643b905a04779be16bb406087bd", + "name": "ujson", + "sha256": "3b84bd49c93349d550bb24f5bf94530170d186f46175aa72c9a0c0c5b71cf545", + "size": 48772, + "subdir": "linux-64", + "timestamp": 1600709349719, + "version": "3.2.0" + }, + "ujson-3.2.0-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "bf6a07b6b293b65aff6a6d1d8c471b77", + "name": "ujson", + "sha256": "77c7b808af0c63b00d14ad7175da53084951ded9f7efc94bc366fda660aeacd8", + "size": 49106, + "subdir": "linux-64", + "timestamp": 1600709369218, + "version": "3.2.0" + }, + "ujson-4.0.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7c26509052271ee229d53f95cfecf218", + "name": "ujson", + "sha256": "b9352e3244c4bad4d7b4045dc04bd84fb39106c6e822935e8e72f0a648369401", + "size": 48807, + "subdir": "linux-64", + "timestamp": 1602185255835, + "version": "4.0.0" + }, + "ujson-4.0.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a3bf43a6ad74e73d6cd75eae21ca656a", + "name": "ujson", + "sha256": "f9d699adcbc7bf0d31ba302e51c40d276b8d4f5472d47c0c20e77a21a4140e87", + "size": 48794, + "subdir": "linux-64", + "timestamp": 1602185225480, + "version": "4.0.0" + }, + "ujson-4.0.0-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "240d17c8ee3e48707f2cfb7d2c3461b8", + "name": "ujson", + "sha256": "d605631d147e2c03e5e60cfcd89f3d4c477469a6504116d4cc08fa8273747192", + "size": 49086, + "subdir": "linux-64", + "timestamp": 1602185250665, + "version": "4.0.0" + }, + "ujson-4.0.1-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e467c0f91aa33dcf81c608c274882670", + "name": "ujson", + "sha256": "00d1bea1fee467b9d8139fa91d3306b14891f2663ebaa29c856ca9a4c765ae7c", + "size": 48782, + "subdir": "linux-64", + "timestamp": 1602523363196, + "version": "4.0.1" + }, + "ujson-4.0.1-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "6763c42007dccf917e6c51bf672fed34", + "name": "ujson", + "sha256": "c7d477841cfe594943b909bbd5b4e6d6b9107d3137f0d3e93815a601b4d8bf1f", + "size": 48726, + "subdir": "linux-64", + "timestamp": 1602523355051, + "version": "4.0.1" + }, + "ujson-4.0.1-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "38a98fb75b148100867260d15a782d56", + "name": "ujson", + "sha256": "07d21749c9f7f25651ca3d82b513d51f865697d0e7c9eb3c1f540ae924c4d4eb", + "size": 49159, + "subdir": "linux-64", + "timestamp": 1602523368189, + "version": "4.0.1" + }, + "ujson-4.0.2-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "41d45576ccb16e164fe547f4cb08bb1f", + "name": "ujson", + "sha256": "1fc1ceb1013d738242e86a337508ce96bab7339d302e72b67cdddb1ed0de73eb", + "size": 192540, + "subdir": "linux-64", + "timestamp": 1640795605515, + "version": "4.0.2" + }, + "ujson-4.0.2-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2c96f606870ca4aae138f0543cec3413", + "name": "ujson", + "sha256": "f834831e33c7e418b5d378ed2f19002040e1824c5ceecf188ecd02d42bf59ff9", + "size": 48824, + "subdir": "linux-64", + "timestamp": 1611259545930, + "version": "4.0.2" + }, + "ujson-4.0.2-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a70166060c467dc1bc4e1dc65f840417", + "name": "ujson", + "sha256": "d109301ce2a12d83a01d1b25ad8a1e1640e1c60a6fb15f70b802cf61ab4de4dc", + "size": 48845, + "subdir": "linux-64", + "timestamp": 1611259553564, + "version": "4.0.2" + }, + "ujson-4.0.2-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "624edc0a547750a659c708917999b3bf", + "name": "ujson", + "sha256": "5a94df80fe0b679cec61c0559a89be3a349513aa43ee15ec8c7cb761ee5e3a34", + "size": 49118, + "subdir": "linux-64", + "timestamp": 1611259568435, + "version": "4.0.2" + }, + "ujson-4.0.2-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "603de31a0181d53ccc117c4343a312b2", + "name": "ujson", + "sha256": "10ff4d5b481648a9964e791ccc0652cc2f1567434a083c3dc884aec22fe03262", + "size": 49396, + "subdir": "linux-64", + "timestamp": 1611259570977, + "version": "4.0.2" + }, + "ujson-4.2.0-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d1c58ba545cc5b95c7044d2e3fc295b4", + "name": "ujson", + "sha256": "51435c7d850092b1e919d6ef98d0bbe3e3460504ed6c682674240cac99112ea3", + "size": 48974, + "subdir": "linux-64", + "timestamp": 1640703936763, + "version": "4.2.0" + }, + "ujson-4.2.0-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "231cfe18f7edd4ab19fa6755c2af760b", + "name": "ujson", + "sha256": "b8415d6d61c6636a67358fde1ac64869ebca174ef8d9199909823d41a6ac1db7", + "size": 49204, + "subdir": "linux-64", + "timestamp": 1640703963524, + "version": "4.2.0" + }, + "ujson-4.2.0-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "90d6c2d5e16195eda02179caef3db84c", + "name": "ujson", + "sha256": "d91291e0f8a540334cc3dac5f5516b68a02ba39ff81995953c94a152e5fc2ca6", + "size": 49511, + "subdir": "linux-64", + "timestamp": 1640703908654, + "version": "4.2.0" + }, + "ujson-5.1.0-py310h295c915_0.tar.bz2": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6eecf2a16cda9a3721c3fc9ea294b822", + "name": "ujson", + "sha256": "f0f2fa64f0634f693d008f762624c1fd274982a8764e2568ab3ae73ccba69c04", + "size": 50175, + "subdir": "linux-64", + "timestamp": 1648044108934, + "version": "5.1.0" + }, + "ujson-5.1.0-py37h295c915_0.tar.bz2": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "95ef771695f8b0dd48ada3ba9286c43f", + "name": "ujson", + "sha256": "f89feba0a1449d1e50183becafa7ca4e2b7f993c6b92b7f0f4d73616f37bec10", + "size": 49893, + "subdir": "linux-64", + "timestamp": 1648026228174, + "version": "5.1.0" + }, + "ujson-5.1.0-py38h295c915_0.tar.bz2": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e3d4ef5f5b69441ea0edc6c83c89c9f9", + "name": "ujson", + "sha256": "0414bc50adb65c52883124f05cc665b89b77638e197bac20f63809a7c2b5b06e", + "size": 50121, + "subdir": "linux-64", + "timestamp": 1648025964104, + "version": "5.1.0" + }, + "ujson-5.1.0-py39h295c915_0.tar.bz2": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bced0b4e7ba23198c7622c414d072325", + "name": "ujson", + "sha256": "e5c44d1c98781162d058f79988c2f34e9ce5899284fcbe6cbd6c6dd2b8591857", + "size": 50418, + "subdir": "linux-64", + "timestamp": 1648025964063, + "version": "5.1.0" + }, + "ujson-5.4.0-py310h6a678d5_0.tar.bz2": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "68bdf9e8a00ca9041e1f3b25543290a3", + "name": "ujson", + "sha256": "8a9ca5e341de020f6f6050b7eb0cef8331aced045b21235638f1b565e914ef3b", + "size": 47980, + "subdir": "linux-64", + "timestamp": 1657544991544, + "version": "5.4.0" + }, + "ujson-5.4.0-py311h6a678d5_0.tar.bz2": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1f07a7638e734474ce82dcf29c8ecebb", + "name": "ujson", + "sha256": "139a153cbfc208b57b5672bb558470d621da9e3514eddd536bac49674edee5cb", + "size": 48318, + "subdir": "linux-64", + "timestamp": 1676828920779, + "version": "5.4.0" + }, + "ujson-5.4.0-py37h6a678d5_0.tar.bz2": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "28363766331a9dba6bdd86a6a5e0da36", + "name": "ujson", + "sha256": "55bed9aa187d9b97b1ba272d62298f2580110700ecaa846b845bffe06de32b24", + "size": 47846, + "subdir": "linux-64", + "timestamp": 1657545094704, + "version": "5.4.0" + }, + "ujson-5.4.0-py38h6a678d5_0.tar.bz2": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "74f37a5286dcd2470abdfe4ac1b62af0", + "name": "ujson", + "sha256": "d3e64a5b88cffc245b657f26582b77ce399af017883e482840d59f224eaeae0a", + "size": 47937, + "subdir": "linux-64", + "timestamp": 1657545059454, + "version": "5.4.0" + }, + "ujson-5.4.0-py39h6a678d5_0.tar.bz2": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "097c4204d1ca8d082736c3462d41d29a", + "name": "ujson", + "sha256": "a5460e766a64b1f94c6babd6ea68bc5a86f3fe0765e977ae676454ef78cc4b37", + "size": 47942, + "subdir": "linux-64", + "timestamp": 1657545025422, + "version": "5.4.0" + }, + "ukkonen-1.0.1-py310hdb19cb5_0.tar.bz2": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "cffi >=1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "329764f9bf94b5056f1981921ac57271", + "name": "ukkonen", + "sha256": "c14fc34073ea57a6b0605eba2de3f47bb134d6548ccb3910e03d8cfc5cc6307d", + "size": 33326, + "subdir": "linux-64", + "timestamp": 1663174692558, + "version": "1.0.1" + }, + "ukkonen-1.0.1-py311hdb19cb5_0.tar.bz2": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "cffi >=1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18a31148ee7a34cd896b7d37e05275f1", + "name": "ukkonen", + "sha256": "3ab2b02afccb78df05c48480dffc37e347ed2f1b1407be409980f99b1fa68453", + "size": 12679, + "subdir": "linux-64", + "timestamp": 1676843006064, + "version": "1.0.1" + }, + "ukkonen-1.0.1-py37hdb19cb5_0.tar.bz2": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "cffi >=1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a2059327f4c089180291b188a386f442", + "name": "ukkonen", + "sha256": "4c82043d279c5bf9d27103d1f6fadccb994900982ad7d5b3cc4de7734b913adb", + "size": 12101, + "subdir": "linux-64", + "timestamp": 1663174649605, + "version": "1.0.1" + }, + "ukkonen-1.0.1-py38hdb19cb5_0.tar.bz2": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "cffi >=1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ef31869b69a608507aa9e488b667e1d", + "name": "ukkonen", + "sha256": "4d9b21d4e4175f3185c08e843b06f41efdd9e94f9be45573af8ff08ed770faab", + "size": 12128, + "subdir": "linux-64", + "timestamp": 1663174588135, + "version": "1.0.1" + }, + "ukkonen-1.0.1-py39hdb19cb5_0.tar.bz2": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "cffi >=1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "285cb70dd7254b56135592f3077e519c", + "name": "ukkonen", + "sha256": "b473c37fd5ce706a1d14c42c6b41a7c71fc68bd71fe4a159af48628fc25387c7", + "size": 12146, + "subdir": "linux-64", + "timestamp": 1663174619229, + "version": "1.0.1" + }, + "unearth-0.6.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20", + "python >=3.10,<3.11.0a0", + "requests >=2.25" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d6c1ab14ef575232f760ef9c55311ca", + "name": "unearth", + "sha256": "277d278c89a2783bde9d3cb5f50c2280b0487bd9dfcf3c0579f14121d0b7ae69", + "size": 309173, + "subdir": "linux-64", + "timestamp": 1670000630946, + "version": "0.6.2" + }, + "unearth-0.6.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20", + "python >=3.11,<3.12.0a0", + "requests >=2.25" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c55a119d05d4d4de6ec1896d8739340", + "name": "unearth", + "sha256": "79b9f2bdaedce511b29d02fd4ef392602b3396b84417950a36a1d2bb3e2a9f52", + "size": 332573, + "subdir": "linux-64", + "timestamp": 1676843020645, + "version": "0.6.2" + }, + "unearth-0.6.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cached-property >=1.5.2", + "packaging >=20", + "python >=3.7,<3.8.0a0", + "requests >=2.25" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e2a6b862f72740f7838b1d2b7c736ea4", + "name": "unearth", + "sha256": "449b1da05b7c150678f77c8f80bb29ac1b2481d4e45010d66e3603c25ad3b455", + "size": 308269, + "subdir": "linux-64", + "timestamp": 1670000663502, + "version": "0.6.2" + }, + "unearth-0.6.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20", + "python >=3.8,<3.9.0a0", + "requests >=2.25" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc6b190365c49c1a23941208818bcadd", + "name": "unearth", + "sha256": "1af07e0d4cf53e15312fe5faa246ce57a18ca14db594deb3402bb60cea0e26f9", + "size": 308636, + "subdir": "linux-64", + "timestamp": 1670000598259, + "version": "0.6.2" + }, + "unearth-0.6.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20", + "python >=3.9,<3.10.0a0", + "requests >=2.25" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4605a7d10a0ba4ca7857b24db125482", + "name": "unearth", + "sha256": "474e83a7804f270e2e13a0f2ec0b5425de579973d4a313ef6fa4667e319a5003", + "size": 308615, + "subdir": "linux-64", + "timestamp": 1670000565401, + "version": "0.6.2" + }, + "unicodecsv-0.14.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "dc9adeb2ec3b6f3afa6d35477eaf17fe", + "name": "unicodecsv", + "sha256": "a473d4cad40276f6ff02f4a174e14de88d010aebc75425a2f86c30157aab00be", + "size": 24831, + "subdir": "linux-64", + "timestamp": 1531060456119, + "version": "0.14.1" + }, + "unicodecsv-0.14.1-py27h5062da9_0.tar.bz2": { + "build": "py27h5062da9_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "743d1de0563382fa05783ee171d49811", + "name": "unicodecsv", + "sha256": "b9bb4c23100e298b4f601b4fe69221e806e8e3c720b7c51b72b286cf1c22084b", + "size": 24661, + "subdir": "linux-64", + "timestamp": 1505852006564, + "version": "0.14.1" + }, + "unicodecsv-0.14.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "d340d1f870b9765b7ffc5292302f6af3", + "name": "unicodecsv", + "sha256": "187df4456df019406472c5be81c334edfeb9ce5a315aca5c5dff0dec664145b4", + "size": 26799, + "subdir": "linux-64", + "timestamp": 1640795623457, + "version": "0.14.1" + }, + "unicodecsv-0.14.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "86d251ee5b3e920c2bfdcd867fbb6538", + "name": "unicodecsv", + "sha256": "2801c48bf917ef406ec116b16722588aee1f813b32573257fb5dafe32c0a4f33", + "size": 35733, + "subdir": "linux-64", + "timestamp": 1676838885496, + "version": "0.14.1" + }, + "unicodecsv-0.14.1-py35h4805c0c_0.tar.bz2": { + "build": "py35h4805c0c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "69b80d1433216581064a816a0b409dc6", + "name": "unicodecsv", + "sha256": "32d4d1cfd1800c484d955ee83841b1ecc01246893efa34760ff7c75cdf141466", + "size": 25887, + "subdir": "linux-64", + "timestamp": 1505852018863, + "version": "0.14.1" + }, + "unicodecsv-0.14.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "eb0d5ea9f6178d87577d7674e2f58835", + "name": "unicodecsv", + "sha256": "37bc72b416ef10c10d4700e2b5d480ad6cf13335670bb5e568c92eab48c68c1e", + "size": 25977, + "subdir": "linux-64", + "timestamp": 1531060393148, + "version": "0.14.1" + }, + "unicodecsv-0.14.1-py36ha668878_0.tar.bz2": { + "build": "py36ha668878_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "fb5252a9cd71a4796f4687429d2dc013", + "name": "unicodecsv", + "sha256": "8b31ac3ca074e06ffd109a46caa0677cef128af7923d27ade635b718f7edd3c5", + "size": 25827, + "subdir": "linux-64", + "timestamp": 1505852031265, + "version": "0.14.1" + }, + "unicodecsv-0.14.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "9e7f0ba0028c94b97c7b2735af473076", + "name": "unicodecsv", + "sha256": "a5e4d0a8e22ba6e623c6eff0bec65e950e4744493e1dbe0757d3525a20323397", + "size": 26072, + "subdir": "linux-64", + "timestamp": 1531060424646, + "version": "0.14.1" + }, + "unicodecsv-0.14.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "410aaf6ee2d0024afa27aab4b0e560d5", + "name": "unicodecsv", + "sha256": "9b7eb9aae3c1113833c5e734b3d0e4e8ca5792fe92769420cf0bfd1582348403", + "size": 26834, + "subdir": "linux-64", + "timestamp": 1573200564391, + "version": "0.14.1" + }, + "unicodecsv-0.14.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "4547f5752f09e6449732cd2fdc4cd055", + "name": "unicodecsv", + "sha256": "535708c95c9a9ff7dba13699a50f98b595383143d4aa993c9daf0472ff54462f", + "size": 27145, + "subdir": "linux-64", + "timestamp": 1607574365897, + "version": "0.14.1" + }, + "unicodedata2-13.0.0.post2-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "23b34c42243afad988afba7bb175cd9e", + "name": "unicodedata2", + "sha256": "da9ccf3ce736cc1efe78207f1fc7a70702b93ab98936536d1af291567737c6ab", + "size": 509202, + "subdir": "linux-64", + "timestamp": 1613482860449, + "version": "13.0.0.post2" + }, + "unicodedata2-13.0.0.post2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "006dfb335c143734ce6014e40437eae3", + "name": "unicodedata2", + "sha256": "afe3c4ffcd523c1e32284c573137c20fc0b81e7bfa4f9335dd1dc251fa3cbb72", + "size": 508794, + "subdir": "linux-64", + "timestamp": 1587393869738, + "version": "13.0.0.post2" + }, + "unicodedata2-13.0.0.post2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "55ee197868c26a7be9d3b9e5041c263e", + "name": "unicodedata2", + "sha256": "d7d3856211217f0da24f43363deb54144b1ccaca1965b9babb0c2527a593c8ac", + "size": 508666, + "subdir": "linux-64", + "timestamp": 1613482727542, + "version": "13.0.0.post2" + }, + "unicodedata2-13.0.0.post2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c9e98e5f60678620504620671f075371", + "name": "unicodedata2", + "sha256": "57945dd3cf669caa54d0735da1ff87bbf8613262df84128fbd49fce568ea796f", + "size": 508755, + "subdir": "linux-64", + "timestamp": 1587393847403, + "version": "13.0.0.post2" + }, + "unicodedata2-13.0.0.post2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9c1b437803e0f4ac00cbd41bbec55968", + "name": "unicodedata2", + "sha256": "312a5a4dcd7f59e30cbac10846ec041d43902265da404f50438fefd744108c51", + "size": 508649, + "subdir": "linux-64", + "timestamp": 1613482868665, + "version": "13.0.0.post2" + }, + "unicodedata2-13.0.0.post2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "31fe3abb7d706452cdc8f8dc4b0ff74e", + "name": "unicodedata2", + "sha256": "263989d7ba42d91a7d27651cfe84bf2f21f257e06deadc6559a293c1d3f59036", + "size": 508748, + "subdir": "linux-64", + "timestamp": 1587393885344, + "version": "13.0.0.post2" + }, + "unicodedata2-13.0.0.post2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d1c93a81ac685550e0420043ad8fc4b8", + "name": "unicodedata2", + "sha256": "dc2dd2206734e5c0f7b0d7af97e9317fe7dbd43282c7f76410b1dd4742f04ba4", + "size": 509334, + "subdir": "linux-64", + "timestamp": 1613482865849, + "version": "13.0.0.post2" + }, + "unicodedata2-14.0.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "361e6c859c22cbf07770ff4a4e272df5", + "name": "unicodedata2", + "sha256": "cd9fbc8789e25f4abd8aacc69ddfa19da94ec4f1c89c8c538b81438de221efeb", + "size": 560723, + "subdir": "linux-64", + "timestamp": 1642781405652, + "version": "14.0.0" + }, + "unicodedata2-15.0.0-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c7d7f380d88b9ea20f2a428f4c37f272", + "name": "unicodedata2", + "sha256": "93d19816a101372593029e28f53df216513ff329836fedba7d97d57e5a0b0998", + "size": 509049, + "subdir": "linux-64", + "timestamp": 1674227967685, + "version": "15.0.0" + }, + "unicodedata2-15.0.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "044f0880a93d86166531dc72298f1891", + "name": "unicodedata2", + "sha256": "8455ce54c3231ca7424a0753e13c0fbdbcf752bc8a6ea9c648e82c3c2820d78d", + "size": 508797, + "subdir": "linux-64", + "timestamp": 1676863402217, + "version": "15.0.0" + }, + "unicodedata2-15.0.0-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "841549f5bb0379752c8451552177bed5", + "name": "unicodedata2", + "sha256": "52dd3eaf1d1bddbc18e40110b7c6a7aa7111cc8039eaa12716a94e3a1a1734df", + "size": 511304, + "subdir": "linux-64", + "timestamp": 1674227937711, + "version": "15.0.0" + }, + "unicodedata2-15.0.0-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b195aef2097f9d7100486444f607ba67", + "name": "unicodedata2", + "sha256": "57685fc6d8ac80f3f0b194f538fb5de9a54569b392977bae7d28adfde6d310cf", + "size": 508884, + "subdir": "linux-64", + "timestamp": 1674227877840, + "version": "15.0.0" + }, + "unicodedata2-15.0.0-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "76c74bdcb78622b1236d7252b8cbd3d6", + "name": "unicodedata2", + "sha256": "4d78661deb775e952f9148428920a23bdeb4884d53d77dbb1a1ae7f224f2fae2", + "size": 509097, + "subdir": "linux-64", + "timestamp": 1674227907669, + "version": "15.0.0" + }, + "unidecode-1.0.22-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "md5": "52c195fc497982d0b24f9c4d95237bea", + "name": "unidecode", + "sha256": "a1b1a718393da7b974530865d9e98ae9c6ae3ec3e002afa453acdbd9ef022e18", + "size": 244908, + "subdir": "linux-64", + "timestamp": 1519244704887, + "version": "1.0.22" + }, + "unidecode-1.0.22-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "GPL-2.0", + "md5": "9959e1d11d0178d11e18477e6159a873", + "name": "unidecode", + "sha256": "ec2f87a1370fee1af74dd95df3e3255ac500b91ff2a2201dd20ef63099db9b62", + "size": 233824, + "subdir": "linux-64", + "timestamp": 1519244729605, + "version": "1.0.22" + }, + "unidecode-1.0.22-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "md5": "3ef083ae27c5578a66cf64378bc54e94", + "name": "unidecode", + "sha256": "e6efa6990794af8c8bb8c02d692d77b0f37f13998b430eb2bd4f19d62dd24775", + "size": 234035, + "subdir": "linux-64", + "timestamp": 1519244691935, + "version": "1.0.22" + }, + "unidecode-1.0.22-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "md5": "f4f25d5b657e02b0f495dc2b21ba8d54", + "name": "unidecode", + "sha256": "d2661d8d49ec3e46e4f4ea011697aa7d4ea6af96a4f16f2b9f7b16619e09c377", + "size": 228025, + "subdir": "linux-64", + "timestamp": 1530735586631, + "version": "1.0.22" + }, + "unidecode-1.0.23-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "md5": "ae32293e04be0efb4a5e8c26f8aed436", + "name": "unidecode", + "sha256": "c9d9f3f5a2a02abc0df1c7cb665e5e4445c477c68b8f5e40b2a28f4b7c5d5b04", + "size": 244126, + "subdir": "linux-64", + "timestamp": 1542642168359, + "version": "1.0.23" + }, + "unidecode-1.0.23-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "md5": "bfb62e10aac6deb66624dc2cb4b1cf2d", + "name": "unidecode", + "sha256": "018862a4341a41b9d8462238353370a25131ff28b5d0003709f9ab2082b6d812", + "size": 234472, + "subdir": "linux-64", + "timestamp": 1542642198682, + "version": "1.0.23" + }, + "unidecode-1.0.23-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "md5": "caf5613766fd3c8f81144ee763c33a45", + "name": "unidecode", + "sha256": "e97e3037d25a1f593e3b856fa0a97c6364ce8c51aff22b508a288e25262ef98b", + "size": 229225, + "subdir": "linux-64", + "timestamp": 1542642148820, + "version": "1.0.23" + }, + "unittest2-1.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.4", + "traceback2" + ], + "license": "BSD", + "md5": "cf4a48bd4ae41e91e3e7de00b123cf5e", + "name": "unittest2", + "sha256": "dde81a1706ade3d2159a732b65da451107462d865376eaa59ee43093e8f81fd0", + "size": 145940, + "subdir": "linux-64", + "timestamp": 1530898878278, + "version": "1.1.0" + }, + "unittest2-1.1.0-py27h1e968a4_0.tar.bz2": { + "build": "py27h1e968a4_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.4", + "traceback2" + ], + "license": "BSD", + "md5": "526d3d0e61e2724248440750c366bab5", + "name": "unittest2", + "sha256": "ada6f4f84115ff5fc3efc06591f7954e420dc77f8adb80314d9782b3e8784759", + "size": 146444, + "subdir": "linux-64", + "timestamp": 1508346237291, + "version": "1.1.0" + }, + "unittest2-1.1.0-py35h0cb595e_0.tar.bz2": { + "build": "py35h0cb595e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.4", + "traceback2" + ], + "license": "BSD", + "md5": "13e34ee766906b2e0fa8445afb8c0371", + "name": "unittest2", + "sha256": "a69caf28ae284306d78b5987a4cfd0f169bc7c332e16d4357f133967f1f0fcdc", + "size": 154123, + "subdir": "linux-64", + "timestamp": 1508346245435, + "version": "1.1.0" + }, + "unittest2-1.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.4", + "traceback2" + ], + "license": "BSD", + "md5": "f2f98826f22370bdc07ef738715a4b54", + "name": "unittest2", + "sha256": "fa81a042eeef181d39b10a4df6890a6e3d7c7910835ef1570edd0e3b4e6d4d9d", + "size": 153192, + "subdir": "linux-64", + "timestamp": 1530898939236, + "version": "1.1.0" + }, + "unittest2-1.1.0-py36h1dd7840_0.tar.bz2": { + "build": "py36h1dd7840_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.4", + "traceback2" + ], + "license": "BSD", + "md5": "1741cef936c6c63e5a26bffd36247875", + "name": "unittest2", + "sha256": "4ad2d957ab25ae34f8d3233ee5c7eedbe333d754c4007776fa97ed906af03f24", + "size": 153505, + "subdir": "linux-64", + "timestamp": 1508346247934, + "version": "1.1.0" + }, + "unittest2-1.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.4", + "traceback2" + ], + "license": "BSD", + "md5": "e53075dbd5ce7b73dcba0f615409757d", + "name": "unittest2", + "sha256": "3ee0f2c38ca21d1fd9466d3a906d91185a89514361671caa8e6715f63f498a20", + "size": 153239, + "subdir": "linux-64", + "timestamp": 1530898908174, + "version": "1.1.0" + }, + "unittest2-1.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.4", + "traceback2" + ], + "license": "BSD", + "md5": "12e56f4ba768341b15e6a14bc5105f0e", + "name": "unittest2", + "sha256": "eadc7e90695ae7c36ff82ada2e03089e63aec7381a21faf4122ac7ce2a78b84e", + "size": 155058, + "subdir": "linux-64", + "timestamp": 1574153508147, + "version": "1.1.0" + }, + "unixodbc-2.3.11-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20210910,<3.2.0a0", + "libgcc-ng >=11.2.0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "bef6af52c4772fef23292f91452156aa", + "name": "unixodbc", + "sha256": "7ccb4fc525ba33750d1344a4ee4ea5e7c33caf763558ed82f4536e111693e439", + "size": 305762, + "subdir": "linux-64", + "timestamp": 1659559616604, + "version": "2.3.11" + }, + "unixodbc-2.3.4-h1bed415_2.tar.bz2": { + "build": "h1bed415_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "e122806bc0d49359dcec27699e5ff4c7", + "name": "unixodbc", + "sha256": "d608749e3ec4a721f5e85664e2045c80023f321b84e187dfbf56146118cef2b2", + "size": 318623, + "subdir": "linux-64", + "timestamp": 1519122442569, + "version": "2.3.4" + }, + "unixodbc-2.3.4-hc36303a_1.tar.bz2": { + "build": "hc36303a_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "a520e7854d843896672ed3679331d64e", + "name": "unixodbc", + "sha256": "331cf9a1d16096c601e7b62d76c759ed2bb51236e844d23751f2808cce7521f5", + "size": 323096, + "subdir": "linux-64", + "timestamp": 1505751906155, + "version": "2.3.4" + }, + "unixodbc-2.3.5-h1bed415_0.tar.bz2": { + "build": "h1bed415_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "f3297415d97a334dfb2ad273031e8450", + "name": "unixodbc", + "sha256": "2b3c2fddbfff37b133d7e87e9b52d7a7904fe93eec0a86f49586d68fc82b83a3", + "size": 323577, + "subdir": "linux-64", + "timestamp": 1519174128895, + "version": "2.3.5" + }, + "unixodbc-2.3.6-h1bed415_0.tar.bz2": { + "build": "h1bed415_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "79ff4c3e272ee5eb39d133ad64f200b4", + "name": "unixodbc", + "sha256": "05629d33f8a100032b636965e8018b2ef25d83ea104a507e32ceb9225b2c0f11", + "size": 324933, + "subdir": "linux-64", + "timestamp": 1522793866209, + "version": "2.3.6" + }, + "unixodbc-2.3.7-h14c3975_0.tar.bz2": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20170329,<3.2.0a0", + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "ea3f7b47cc02a20efcf352ebd53d5f1e", + "name": "unixodbc", + "sha256": "9ed180c5c37001e1cd2795529787a7633bc477681d779e940f137b2e31bc1dd7", + "size": 326418, + "subdir": "linux-64", + "timestamp": 1535134163089, + "version": "2.3.7" + }, + "unixodbc-2.3.9-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20191231,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "9e7ee3f8ae9c1046728cbde28bb976f3", + "name": "unixodbc", + "sha256": "fca7bf7fc370d24754acdf3e63442d9d44d26bc58b588246b303f25234d2e935", + "size": 306225, + "subdir": "linux-64", + "timestamp": 1602700091394, + "version": "2.3.9" + }, + "unyt-2.9.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.17.5", + "python >=3.10,<3.11.0a0", + "sympy >=1.5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2114d80198550f9112813130e2c4bee7", + "name": "unyt", + "sha256": "4167f656856862467d649b5609a338deb382197b3007473e7369695b86ad6751", + "size": 201502, + "subdir": "linux-64", + "timestamp": 1680625399202, + "version": "2.9.5" + }, + "unyt-2.9.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.17.5", + "python >=3.11,<3.12.0a0", + "sympy >=1.5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "250501f00a96a4e16e228642447d2a62", + "name": "unyt", + "sha256": "c8083d718967a44d83969b33974f5f7a03a7208b38ddfef6bb40a5b8b586650d", + "size": 273578, + "subdir": "linux-64", + "timestamp": 1680625435431, + "version": "2.9.5" + }, + "unyt-2.9.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.17.5", + "python >=3.8,<3.9.0a0", + "sympy >=1.5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "66beb1f699696ea4b006869efba0f5b5", + "name": "unyt", + "sha256": "c6b7c8a1ee39a2c7bc4c8230da942cefecf192d1665d08b2ddd7327584e79b79", + "size": 199009, + "subdir": "linux-64", + "timestamp": 1680625323197, + "version": "2.9.5" + }, + "unyt-2.9.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.17.5", + "python >=3.9,<3.10.0a0", + "sympy >=1.5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4c10c2885d0d493be710b8cb63b87a4f", + "name": "unyt", + "sha256": "f9751500843c6df8868e7c1cc58e9ac19a39b18a0c1c83d32e868339bcd2ba7e", + "size": 204339, + "subdir": "linux-64", + "timestamp": 1680625362206, + "version": "2.9.5" + }, + "unzip-6.0-h611a1e1_0.tar.bz2": { + "build": "h611a1e1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "BSD-like", + "md5": "66ba38e35e7fc9585b206867e9448366", + "name": "unzip", + "sha256": "0f004b37ef40abd785537b2855d6853c179eb488bca2c7fd6f52ab646261658f", + "size": 93057, + "subdir": "linux-64", + "timestamp": 1508870827771, + "version": "6.0" + }, + "uriparser-0.9.3-he6710b0_1.tar.bz2": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "641c1137a01009899cab025ece8100d5", + "name": "uriparser", + "sha256": "9a3ccb890c28864779704d8d92d11ee43a66d6ca2e4f8babd6a129fe4675ebcc", + "size": 51843, + "subdir": "linux-64", + "timestamp": 1580397170986, + "version": "0.9.3" + }, + "urllib3-1.22-py27ha55213b_0.tar.bz2": { + "build": "py27ha55213b_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b27cc242c7cf45110067a2a494da4cb", + "name": "urllib3", + "sha256": "d5fdbf5c653ee9e5fcf16cb45fc5c588561149a6141109d1216416291a96b309", + "size": 156311, + "subdir": "linux-64", + "timestamp": 1505693026646, + "version": "1.22" + }, + "urllib3-1.22-py35h2ab6e29_0.tar.bz2": { + "build": "py35h2ab6e29_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2da7d6a3bb4d7840c13625e90a3bf5a4", + "name": "urllib3", + "sha256": "cffb1e90f6da408c6b9c7cf819ae04a9a955699c5c484dd2ad9331b846f0b53d", + "size": 158739, + "subdir": "linux-64", + "timestamp": 1505693040638, + "version": "1.22" + }, + "urllib3-1.22-py36hbe7ace6_0.tar.bz2": { + "build": "py36hbe7ace6_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb8e6b582465154dcd1904cb8f524f02", + "name": "urllib3", + "sha256": "8c44fd45f14486364e15126c53a95f75189b8e274d3e1fb23cf9559bb1c7de83", + "size": 158237, + "subdir": "linux-64", + "timestamp": 1505693054673, + "version": "1.22" + }, + "urllib3-1.23-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21befc00a13cce1daf27c507676e34e2", + "name": "urllib3", + "sha256": "09e8fe640a9a79fa12be0c5961786404a71f2a5d104586dae9b8e7412c6cf03f", + "size": 153631, + "subdir": "linux-64", + "timestamp": 1529348113315, + "version": "1.23" + }, + "urllib3-1.23-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "93cee4564f90ea9725e8dd01300e3107", + "name": "urllib3", + "sha256": "9fdff583cdc338e48fed9b28f41d1242c4fcc23ffd2efe9fff942684e86c6851", + "size": 156453, + "subdir": "linux-64", + "timestamp": 1529348125173, + "version": "1.23" + }, + "urllib3-1.23-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "70b16860ff24015083797087cec06d7c", + "name": "urllib3", + "sha256": "b4f663651b4ef061358b1dd0c5186296f6570863b916751ae592310bc3e4aaa2", + "size": 155619, + "subdir": "linux-64", + "timestamp": 1529348098316, + "version": "1.23" + }, + "urllib3-1.23-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e97e0aa9135b4d2f15060b7b0cc02bf0", + "name": "urllib3", + "sha256": "edf6b236c9a38d0e3fafb3fdbf89964747b3f25a7322edc5d51ca4a76be3c825", + "size": 155866, + "subdir": "linux-64", + "timestamp": 1530733464142, + "version": "1.23" + }, + "urllib3-1.24-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b55ab552c461741ea01f5383c5714450", + "name": "urllib3", + "sha256": "d165822b984e991eb4a28ffe9919fa0ebddfb1840d34e32a42218a6721710df0", + "size": 150863, + "subdir": "linux-64", + "timestamp": 1540237904038, + "version": "1.24" + }, + "urllib3-1.24-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e5cb55c87701e1713eda589daaae1643", + "name": "urllib3", + "sha256": "40338edad2e96f1324da5e78fda3fae35dec0ac9fcaed4d4fc6705901e16692d", + "size": 152550, + "subdir": "linux-64", + "timestamp": 1540237945370, + "version": "1.24" + }, + "urllib3-1.24-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0cadf6f219231792c9143bc74a7c7771", + "name": "urllib3", + "sha256": "5f102003339679431db82116a41b92b62748be19eee3d19c4cb99840779f4d92", + "size": 152634, + "subdir": "linux-64", + "timestamp": 1540237923889, + "version": "1.24" + }, + "urllib3-1.24-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "72939a1e7dae3e5e22e7fbebb3ccefbe", + "name": "urllib3", + "sha256": "2920ad4cb6ca27093bd96a51a89f203756aa216ab2a92b75f60eec1f2aabac8d", + "size": 160000, + "subdir": "linux-64", + "timestamp": 1582215534615, + "version": "1.24" + }, + "urllib3-1.24.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1d79656fc4c0c1671a678f0d2fc2868", + "name": "urllib3", + "sha256": "b42da1c7d2c6d16cbbbe162817546f98f37b1218cc170d4cf272cf43eb6f6a1c", + "size": 150868, + "subdir": "linux-64", + "timestamp": 1541444088500, + "version": "1.24.1" + }, + "urllib3-1.24.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62abeea4095b1f7d1ad50e4b74ad1bd4", + "name": "urllib3", + "sha256": "a3ab9ff8b6a4b88df5677dea0abeebd69bf0688c288211f84e5df68bfaa150e9", + "size": 152630, + "subdir": "linux-64", + "timestamp": 1541444125949, + "version": "1.24.1" + }, + "urllib3-1.24.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3501e11589d033196fadce99f44f7ac9", + "name": "urllib3", + "sha256": "f6873199a4667d25a9f4ac78ecc347c95bf65c182e6285ea9b5565adfac6bb5f", + "size": 152991, + "subdir": "linux-64", + "timestamp": 1541444054071, + "version": "1.24.1" + }, + "urllib3-1.24.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33132346244175052a1e1aec728f55d2", + "name": "urllib3", + "sha256": "677364411d6997067552952cc194cb3f8ed70833203bceb1fbba607b05ed32cd", + "size": 154307, + "subdir": "linux-64", + "timestamp": 1556288033688, + "version": "1.24.2" + }, + "urllib3-1.24.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "855fa5e24bbf11108d11dff02f1ec52e", + "name": "urllib3", + "sha256": "c6141815582084fcf7ee32e7411de8ada21608d386bc6b179dbfbd9b4e4e8718", + "size": 156208, + "subdir": "linux-64", + "timestamp": 1556288170380, + "version": "1.24.2" + }, + "urllib3-1.24.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bbb73f8be297cd28774aacc2bb7b7fe9", + "name": "urllib3", + "sha256": "9c79d0819489b8fb8f741e1bddb8acc4b947d293b98ebeec780304447f8caf56", + "size": 156540, + "subdir": "linux-64", + "timestamp": 1556288088820, + "version": "1.24.2" + }, + "urllib3-1.24.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c7dde9777cbbdac474fa2c5e7a60e9a", + "name": "urllib3", + "sha256": "99669f2ebd52de7f6543a2561ecd9824d8f0354830f6253189abea6dd241848a", + "size": 160450, + "subdir": "linux-64", + "timestamp": 1582210947517, + "version": "1.24.3" + }, + "urllib3-1.24.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f104b61682b8a904ea31f7b159f74d45", + "name": "urllib3", + "sha256": "3d420201b5b2d683319119744bd34436fccfb719ab8be2436e19ab0ddc3f0841", + "size": 160368, + "subdir": "linux-64", + "timestamp": 1582210959892, + "version": "1.24.3" + }, + "urllib3-1.24.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2dcead410720751fbdf56b10bdeffd94", + "name": "urllib3", + "sha256": "4c039ab30efcb81616b65931d66f26a8c0162bd71e9ff7923e4cdf0ecfbe3d4a", + "size": 160755, + "subdir": "linux-64", + "timestamp": 1582210988072, + "version": "1.24.3" + }, + "urllib3-1.25-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab5bafb10a73ca485b4608c8b812c563", + "name": "urllib3", + "sha256": "6e77b998bfda6d71a30d8ac75105bc0f427756bf705c3cb86759c5e7ee762942", + "size": 190104, + "subdir": "linux-64", + "timestamp": 1555953833087, + "version": "1.25" + }, + "urllib3-1.25-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6367d6ce2bba66629a23b18fa5f40067", + "name": "urllib3", + "sha256": "1cf4460149b53024a10cbd46f9dbd42dd36063731a3bb06287b2ca5dbc8fb30a", + "size": 192354, + "subdir": "linux-64", + "timestamp": 1555953851231, + "version": "1.25" + }, + "urllib3-1.25-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3836bcd29bf3747923a81cdd9b7d953d", + "name": "urllib3", + "sha256": "eb0444876ebcb6856d79f5b2bd889fd36ac3287b93156909e47a019499b33aa7", + "size": 192219, + "subdir": "linux-64", + "timestamp": 1555953671499, + "version": "1.25" + }, + "urllib3-1.25.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c22599cad77a0c8d53613e97a3537fc", + "name": "urllib3", + "sha256": "087e4255e887aaafcf54bcf3979069eb2f866023001108183a0649242b22f986", + "size": 191637, + "subdir": "linux-64", + "timestamp": 1556287881980, + "version": "1.25.1" + }, + "urllib3-1.25.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d11bad80fdaf88a98677765e1c9f0b39", + "name": "urllib3", + "sha256": "8d84f3cdfba96a210a01039ea128860812757c969a7d8d049ae8b5d9d08f55b4", + "size": 193021, + "subdir": "linux-64", + "timestamp": 1556287987032, + "version": "1.25.1" + }, + "urllib3-1.25.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "371bb5e7af15d1d921ce4520b5a27e30", + "name": "urllib3", + "sha256": "f96027b0c2f0de9b06d21d5f9953c112aadc4716a8040e16c380ad6ad2e23239", + "size": 192877, + "subdir": "linux-64", + "timestamp": 1556287859420, + "version": "1.25.1" + }, + "urllib3-1.25.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "584d667c575742e8f4e9064a486e2893", + "name": "urllib3", + "sha256": "9f08401a30a986e7220efb694765281279bbbf698d1933210866cfa1f3d2a6bb", + "size": 193921, + "subdir": "linux-64", + "timestamp": 1556551854545, + "version": "1.25.2" + }, + "urllib3-1.25.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8dfccf2d8498e3a5fe0e3e8d8d0d6a31", + "name": "urllib3", + "sha256": "9e3f7863ba3033cb4d8730ae4e2120fa2741ea018fb7db880aadf492c4c0f361", + "size": 195986, + "subdir": "linux-64", + "timestamp": 1556551902676, + "version": "1.25.2" + }, + "urllib3-1.25.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "35573068238c105c3488dee36160000f", + "name": "urllib3", + "sha256": "e4382fe227892d727c8d324a970f7e9ea4bded1c6a9a75635e6c7d6508cb732c", + "size": 195852, + "subdir": "linux-64", + "timestamp": 1556551867272, + "version": "1.25.2" + }, + "urllib3-1.25.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6dcbb9e05e617697566ebc92127f9de", + "name": "urllib3", + "sha256": "df565e3bff5f6b66ffb6cafce5c8087e8601910ecfa471fabdcdf70cdd294a97", + "size": 194192, + "subdir": "linux-64", + "timestamp": 1559849607238, + "version": "1.25.3" + }, + "urllib3-1.25.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3186d6f87ffa56948728f861efd168ae", + "name": "urllib3", + "sha256": "ac4978d8f29b1cabb6cde5cdbdd6ef8bfb2952a691ab278d568946726a3ddda7", + "size": 196304, + "subdir": "linux-64", + "timestamp": 1559849739365, + "version": "1.25.3" + }, + "urllib3-1.25.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f06fbed3e6bb1f09c4e6e3ec283086e0", + "name": "urllib3", + "sha256": "7495543552e05227acedf06269c5c17127adb1e832ba20c82228663781859d7b", + "size": 196212, + "subdir": "linux-64", + "timestamp": 1559849559862, + "version": "1.25.3" + }, + "urllib3-1.25.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "19a97584dad40a9449ce5de9bee3d16b", + "name": "urllib3", + "sha256": "2fce40caed741699056070de0cca9778f6f89dbf0d8bf9513f1ad14acfb9619a", + "size": 167239, + "subdir": "linux-64", + "timestamp": 1569267080047, + "version": "1.25.5" + }, + "urllib3-1.25.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c231340966bedc5330b7e3f10791b92", + "name": "urllib3", + "sha256": "a2f449485ae532777eb882ca0d3e7d70a5842ddabad6dab00badf86658010b0b", + "size": 168914, + "subdir": "linux-64", + "timestamp": 1569267065363, + "version": "1.25.5" + }, + "urllib3-1.25.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e7a234465359ff3ab6ee84a71a6dca0c", + "name": "urllib3", + "sha256": "159539803b7f4bc61a16d48e626fe4f518b9be92a9e1e05c26cfc60575cc14df", + "size": 168819, + "subdir": "linux-64", + "timestamp": 1569267101310, + "version": "1.25.5" + }, + "urllib3-1.25.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d4a42d2f6d0e07b8a3d1368d47b1f809", + "name": "urllib3", + "sha256": "21f3c7a0c2cf7c4a756a393c5053b4b5ce1a350b66eeb22ef065784138a174c7", + "size": 167337, + "subdir": "linux-64", + "timestamp": 1569854849356, + "version": "1.25.6" + }, + "urllib3-1.25.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a23ec159d9e7bb148c3a2897f1d4f35d", + "name": "urllib3", + "sha256": "a6b590830a1489bf709b1a71ce18752205f8ff2779fa518124e6f35028c6f74e", + "size": 169343, + "subdir": "linux-64", + "timestamp": 1569854855037, + "version": "1.25.6" + }, + "urllib3-1.25.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3fa60f088267a390605e1d581199953f", + "name": "urllib3", + "sha256": "819373f3fcad8090dd73d75929cd551b5883c341472b06e2ea75d503d2ee250b", + "size": 169239, + "subdir": "linux-64", + "timestamp": 1569854845118, + "version": "1.25.6" + }, + "urllib3-1.25.6-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c1c8b8bedf4773ec1248d83a1335278", + "name": "urllib3", + "sha256": "5ee662b72f339cb77cfd0080a0bb23aee67dc20749df1ba5e591e8ee465a4240", + "size": 165486, + "subdir": "linux-64", + "timestamp": 1574087112631, + "version": "1.25.6" + }, + "urllib3-1.25.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a748aaab0b1ec99879ec7f1d39a347a2", + "name": "urllib3", + "sha256": "8c1160c3128642eadc8af4b319081437a226323bc4a171db2de3d7eb2fb3fdb3", + "size": 167425, + "subdir": "linux-64", + "timestamp": 1573943470523, + "version": "1.25.7" + }, + "urllib3-1.25.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c60545cf219403801fe47b9461ee5a80", + "name": "urllib3", + "sha256": "7cd7b2136dd5285336c8b9a653040b8c7a3250d42bab21c5d888af415a202465", + "size": 169062, + "subdir": "linux-64", + "timestamp": 1573943497288, + "version": "1.25.7" + }, + "urllib3-1.25.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23b01f327fd9c181369d7526c1d7b392", + "name": "urllib3", + "sha256": "551e3122e007c008c80d25e3a0e968d62ce12b9275c3eec65a38478d1f7796ae", + "size": 169255, + "subdir": "linux-64", + "timestamp": 1573943456191, + "version": "1.25.7" + }, + "urllib3-1.25.7-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "186ae96eab27d1704276973e704702f2", + "name": "urllib3", + "sha256": "eb058eb8962f1d94d0393496932b7339c693c54fc93d1d1b68fe54cda278ec59", + "size": 165147, + "subdir": "linux-64", + "timestamp": 1574177601901, + "version": "1.25.7" + }, + "urllib3-1.25.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c2dc80bb6f3a6121ecbce32420a209a", + "name": "urllib3", + "sha256": "28da33661bd3b57af2e3393dc69d6df4a26b6cfff259d959ba0f095ed69a8e12", + "size": 169179, + "subdir": "linux-64", + "timestamp": 1580152465218, + "version": "1.25.8" + }, + "urllib3-1.25.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3faa6cf1894282e4dff0e73f54aba755", + "name": "urllib3", + "sha256": "340a05ba6a85aa0a61e5a33df641047c8a111ac90bfaf607d5e1744610efef31", + "size": 169060, + "subdir": "linux-64", + "timestamp": 1580152499572, + "version": "1.25.8" + }, + "urllib3-1.25.8-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6e7447bbb59eb815df9cc8534653a00", + "name": "urllib3", + "sha256": "5d7ea7849ba0daeaf1b5f21d53bc57db2b040ce55b6fd38f3c873df15f0dcb13", + "size": 169757, + "subdir": "linux-64", + "timestamp": 1580152471177, + "version": "1.25.8" + }, + "urllib3-1.26.11-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83c6e53f0a5ce8caabf094ba52e3d0e2", + "name": "urllib3", + "sha256": "0f9ba09a028a83e4fc5db7749bf49db3249deea3f56e3adc7f1fa937cb846796", + "size": 185055, + "subdir": "linux-64", + "timestamp": 1659110581155, + "version": "1.26.11" + }, + "urllib3-1.26.11-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "81c3dd9a9c35ecbc4874b336196d08c4", + "name": "urllib3", + "sha256": "a232bd6cca6bd660702163c08764704ddba2fce7a374be05daf63c1a890d3ee3", + "size": 182088, + "subdir": "linux-64", + "timestamp": 1659110497654, + "version": "1.26.11" + }, + "urllib3-1.26.11-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8958dce3754928741b5024be9558ab4", + "name": "urllib3", + "sha256": "34cd2378d63c9c1df7d889d00b8cd19c6b87729b43ba5fcd7180bef605ae048c", + "size": 183299, + "subdir": "linux-64", + "timestamp": 1659110531581, + "version": "1.26.11" + }, + "urllib3-1.26.11-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3763a6d835897d9817ebc9a9e3d29631", + "name": "urllib3", + "sha256": "affd17fe71f875a723f45e11ffb7d91f4cd7f89a39eeff63a495cb6d22d37247", + "size": 183874, + "subdir": "linux-64", + "timestamp": 1659110615111, + "version": "1.26.11" + }, + "urllib3-1.26.12-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df8ebf343671688fe166c04c6d510784", + "name": "urllib3", + "sha256": "fcb37678f6c7ca37a2b5a3d9dccfdf82a7273889da4a65ee902f0a433e9f7dd7", + "size": 184268, + "subdir": "linux-64", + "timestamp": 1666299028295, + "version": "1.26.12" + }, + "urllib3-1.26.12-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1138f6078340e1d241656a103fc84163", + "name": "urllib3", + "sha256": "698b3fbaa7dbf05b4b729b68dad0541baa72661e965414e607dd12617211227d", + "size": 232079, + "subdir": "linux-64", + "timestamp": 1676822756847, + "version": "1.26.12" + }, + "urllib3-1.26.12-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d626c458153ad1e40e0b33c2270e8237", + "name": "urllib3", + "sha256": "fbfe4af64223606e1c63d245a4bcad0aecf6fc6e7e588a36a23057bf9895d4c2", + "size": 182176, + "subdir": "linux-64", + "timestamp": 1666299000763, + "version": "1.26.12" + }, + "urllib3-1.26.12-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "faccb60d41faff458d6908ca73062acf", + "name": "urllib3", + "sha256": "fd33920202720b45c9428720ba8f3ea65fd7778e204bec0a99fb3e01ce4903ed", + "size": 182541, + "subdir": "linux-64", + "timestamp": 1666299055257, + "version": "1.26.12" + }, + "urllib3-1.26.12-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "612cb2f1ece418be7923817e3f72537d", + "name": "urllib3", + "sha256": "31ee5e238d583a9992840e740414de927310a92ec08c755971392502783b924d", + "size": 183367, + "subdir": "linux-64", + "timestamp": 1666298972427, + "version": "1.26.12" + }, + "urllib3-1.26.13-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e9a960cc7451a51ebd00b742c1315b7", + "name": "urllib3", + "sha256": "b0e5c7bf4b807b3cd0d6da93cbf6043a963b2b4c0ce88997474c3e9c9efd3702", + "size": 184409, + "subdir": "linux-64", + "timestamp": 1670527071091, + "version": "1.26.13" + }, + "urllib3-1.26.13-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "298ba570ff1c263c0ea067169c4a7a77", + "name": "urllib3", + "sha256": "15b918464383d7520fcd0f0c59ff71e4e6dd82a709f8386c26c32e3bb4bbcb66", + "size": 182398, + "subdir": "linux-64", + "timestamp": 1670527018168, + "version": "1.26.13" + }, + "urllib3-1.26.13-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e0d423783c383b344ed0dc3ecd204ed", + "name": "urllib3", + "sha256": "9ac6783eb902d3df1a688e5ea2c540cba81f32e3331016e2917bd0d758081e1d", + "size": 183309, + "subdir": "linux-64", + "timestamp": 1670527044373, + "version": "1.26.13" + }, + "urllib3-1.26.13-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7be14803ad2eb92a94e7a052f00bd1f5", + "name": "urllib3", + "sha256": "439c96c94430470e945c0971017f3a4aaee74edb85792553d98efa2137da3709", + "size": 183338, + "subdir": "linux-64", + "timestamp": 1670527097306, + "version": "1.26.13" + }, + "urllib3-1.26.14-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "539ad0df78e7cf018e3ee0bad299046d", + "name": "urllib3", + "sha256": "fbeaccf02b0dafcee9114ba67638232ed76194820bb5c5b8bcf1955927d2bbd3", + "size": 184477, + "subdir": "linux-64", + "timestamp": 1673575614211, + "version": "1.26.14" + }, + "urllib3-1.26.14-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ce5c54d056b0486b405644399610d56", + "name": "urllib3", + "sha256": "749235a2d0c9c4bc2035aefe60711192a85dd04f477b3d54b9d49a709d05ffba", + "size": 232004, + "subdir": "linux-64", + "timestamp": 1679339426051, + "version": "1.26.14" + }, + "urllib3-1.26.14-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e5583616c92663aee9e6c7c41f9f15e", + "name": "urllib3", + "sha256": "86caa4eeeb39d871e0e580d4cf02bb843fcce584f4fd634c9f96c7f39c4d8bbf", + "size": 182350, + "subdir": "linux-64", + "timestamp": 1673575559595, + "version": "1.26.14" + }, + "urllib3-1.26.14-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8424d351d5fc5de30d9238249ba3c0f8", + "name": "urllib3", + "sha256": "28c63791cf7225056f7d50058328701aa8bf10617eb8a686a5dbdca9c8162185", + "size": 182639, + "subdir": "linux-64", + "timestamp": 1673575532097, + "version": "1.26.14" + }, + "urllib3-1.26.14-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49d1ffb44c6c1f6c7a73f0c64363c3f2", + "name": "urllib3", + "sha256": "3899149ee4c212450de41fd69e014fbed580a2a4c91fe5f311c205d0718d8f16", + "size": 183524, + "subdir": "linux-64", + "timestamp": 1673575587015, + "version": "1.26.14" + }, + "urllib3-1.26.15-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de2f364f3795012c6bb65e8349050df3", + "name": "urllib3", + "sha256": "f8e3c986baa75ca935f86a2fd33c93fa4705969c9e775d4f74d7b03a0000378e", + "size": 185821, + "subdir": "linux-64", + "timestamp": 1680254765346, + "version": "1.26.15" + }, + "urllib3-1.26.15-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "59b3103bfb5563f54cb1678e136eea19", + "name": "urllib3", + "sha256": "4a6cc4dfd9f68cbb4a6c515c64c6e233ad5f9c19c0a63bfecbb3bb9a0b289410", + "size": 231572, + "subdir": "linux-64", + "timestamp": 1680254738571, + "version": "1.26.15" + }, + "urllib3-1.26.15-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "adf641a6be12488d7a2b13b547735bd6", + "name": "urllib3", + "sha256": "01ae54f54213fdded47540d77e439ab6f53ebc03f7845506466310d53809411e", + "size": 183880, + "subdir": "linux-64", + "timestamp": 1680254711775, + "version": "1.26.15" + }, + "urllib3-1.26.15-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4af615dbba08e8539e7fc116245c7cc2", + "name": "urllib3", + "sha256": "0ae27fd39faf4fc75879403b065c823fc86c76d360a72e83320f06ae84f3d222", + "size": 183512, + "subdir": "linux-64", + "timestamp": 1680254790803, + "version": "1.26.15" + }, + "urllib3-1.26.9-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "849cd68d265b617e2acf93c6324fd48a", + "name": "urllib3", + "sha256": "5b7b123b4bd4883e926ea5484873bc9c4f817172371b60b751d9bac9c185d4bb", + "size": 182702, + "subdir": "linux-64", + "timestamp": 1650637255477, + "version": "1.26.9" + }, + "urllib3-1.26.9-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f17796333e2e4bd3f1931d82eba2f46", + "name": "urllib3", + "sha256": "08d3911ab79f1b34a60d6cd6b8ced7e25be71d283c45d631d5e8864cbdd2fcc1", + "size": 180133, + "subdir": "linux-64", + "timestamp": 1650640030149, + "version": "1.26.9" + }, + "urllib3-1.26.9-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3da1e46f4aeacfaf14ef3d3c6525cffb", + "name": "urllib3", + "sha256": "a002ca6c2e62d1520afee9db2e9e3d875881415b1d1bcd7a1df076596afcf261", + "size": 181662, + "subdir": "linux-64", + "timestamp": 1650640056618, + "version": "1.26.9" + }, + "urllib3-1.26.9-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13a23b9754e6149c4f955648b8633d30", + "name": "urllib3", + "sha256": "472729d96a39f888641a2aac683534339dcef90fef5726105faba3f89d542258", + "size": 181407, + "subdir": "linux-64", + "timestamp": 1650640102349, + "version": "1.26.9" + }, + "urwid-2.1.1-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1", + "md5": "f317811d82dc61fa506d89ba15c404ba", + "name": "urwid", + "sha256": "fcba33edf684a460cafdf8ecfe20e2058394db4346aedeb1631fbc8e1fdc4c08", + "size": 435514, + "subdir": "linux-64", + "timestamp": 1640795668512, + "version": "2.1.1" + }, + "urwid-2.1.1-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.1", + "md5": "d2dc469aa8b2de7b4719239ffe40fac6", + "name": "urwid", + "sha256": "855a4e43406c39e33c94e663bedecfead7d87886995117f094ee3e6c48f90e6d", + "size": 535094, + "subdir": "linux-64", + "timestamp": 1676846143163, + "version": "2.1.1" + }, + "urwid-2.1.1-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "8cd7484b7c049d32ce30eea76a51d9b8", + "name": "urwid", + "sha256": "52e8432dc84d409d3d5842513391525aaecc4c19335bc47bd70a38e3fceaf05b", + "size": 411236, + "subdir": "linux-64", + "timestamp": 1613482241046, + "version": "2.1.1" + }, + "urwid-2.1.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "a39e59e51fa4c6da35fac34bc7ebea8c", + "name": "urwid", + "sha256": "64020d0acaf9e38d580aa206aec6533cb2dcaeccc899e46191be00ac45279812", + "size": 418530, + "subdir": "linux-64", + "timestamp": 1598660950208, + "version": "2.1.1" + }, + "urwid-2.1.1-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1", + "md5": "7c24e7c75b0f7f362164c9aa6e65b0ae", + "name": "urwid", + "sha256": "6343ee7f5db2ed3c496ab082293438156cd8968627e09bfc36e3674df6592ce8", + "size": 409096, + "subdir": "linux-64", + "timestamp": 1613482857346, + "version": "2.1.1" + }, + "urwid-2.1.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1", + "md5": "d7405c3c486aeb659022716e68826677", + "name": "urwid", + "sha256": "caaaa3f7376e627c8ff1ca5d2bc1b31f2b09e5ee7ed42fcdaa35f0b4827fa4a4", + "size": 408902, + "subdir": "linux-64", + "timestamp": 1598660978385, + "version": "2.1.1" + }, + "urwid-2.1.1-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1", + "md5": "db2d355170933864332ad1eb333b96d6", + "name": "urwid", + "sha256": "a0190d5f767c4b1766e823ca906cc1afce990d7c141753f0c3b96151d7f99d77", + "size": 416740, + "subdir": "linux-64", + "timestamp": 1613482730031, + "version": "2.1.1" + }, + "urwid-2.1.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1", + "md5": "444a880b0d8fa84e504e94ab1d76f257", + "name": "urwid", + "sha256": "f1bbfa403796d7448faa3bd5636692cb0f5afc9ad031bd18927a7cb79cb4dff5", + "size": 417465, + "subdir": "linux-64", + "timestamp": 1598660928925, + "version": "2.1.1" + }, + "urwid-2.1.1-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1", + "md5": "382ee09ed7c6a27de735e0af411af0a6", + "name": "urwid", + "sha256": "7a9002fd63c5da08720f7033ee54b640ef071b87d0989f47ff22fad534fd86f3", + "size": 417906, + "subdir": "linux-64", + "timestamp": 1613482877217, + "version": "2.1.1" + }, + "urwid-2.1.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "3674f9e0feff23f644e05cfebffddd33", + "name": "urwid", + "sha256": "e642c25e926de61e30591fc4f685774592d8eeab35eec74dd1b9da66268b2145", + "size": 410500, + "subdir": "linux-64", + "timestamp": 1602001160417, + "version": "2.1.2" + }, + "urwid-2.1.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1", + "md5": "34668389967abc6dcae93dc8fa878ceb", + "name": "urwid", + "sha256": "c620be9691a87e7166811e61282b62efc0cdf74bfcb8b12a8fb6104ca89f6cb4", + "size": 410181, + "subdir": "linux-64", + "timestamp": 1602001194232, + "version": "2.1.2" + }, + "urwid-2.1.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1", + "md5": "7e130970d3e8786e8d0e67c46d1719af", + "name": "urwid", + "sha256": "00db62d864ea8da0d1aef0e1e38f9eab7aa971963b09fdda1f7aaf52c4e07838", + "size": 408687, + "subdir": "linux-64", + "timestamp": 1602001172223, + "version": "2.1.2" + }, + "utf8proc-2.6.1-h27cfd23_0.tar.bz2": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b45754c4fa24c5b4ce9d504c5b6cc4f1", + "name": "utf8proc", + "sha256": "3573b5d63801189ea8a1cbaffce73171f2c4c3b77c5c4952bf2b709694e140ff", + "size": 309353, + "subdir": "linux-64", + "timestamp": 1611836033971, + "version": "2.6.1" + }, + "utfcpp-3.2.1-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "BSL-1.0", + "md5": "92394d99777d1ca76fe0921259de960b", + "name": "utfcpp", + "sha256": "5ec8a63d42e277974200a77a99f28e1db3921e2baa425d1b757b1d7c50e17811", + "size": 13903, + "subdir": "linux-64", + "timestamp": 1635955308136, + "version": "3.2.1" + }, + "uvicorn-0.16.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.4.0", + "click >=7.*", + "h11 >=0.8", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "09b41662b8f2da73742803332b972358", + "name": "uvicorn", + "sha256": "aa2d3eb122797f0b1aede878a59972059ce26f42328afd78269373c24da8800b", + "size": 80873, + "subdir": "linux-64", + "timestamp": 1641600767726, + "version": "0.16.0" + }, + "uvicorn-0.16.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.4.0", + "click >=7.*", + "h11 >=0.8", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b0b698cc9427b3420fc94372a94546a5", + "name": "uvicorn", + "sha256": "1b691d6f1ef3961fdfc13c6f17aca3ea0b85705ddec03943f7e7422600af8070", + "size": 80916, + "subdir": "linux-64", + "timestamp": 1641600745545, + "version": "0.16.0" + }, + "uvicorn-0.20.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.*", + "h11 >=0.8", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ce53de988172cff3251964b24ca1288b", + "name": "uvicorn", + "sha256": "428f84610cf393331b1000d77d3196e19521deda05626323f554615ff945b0fa", + "size": 86555, + "subdir": "linux-64", + "timestamp": 1678090210576, + "version": "0.20.0" + }, + "uvicorn-0.20.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.*", + "h11 >=0.8", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9809a4089bd2fdcc97d1ad7140bcb768", + "name": "uvicorn", + "sha256": "37fa261b12f59fe0e76dfc11473aa3873774d5950599f45eb5ec57b5d262fab0", + "size": 115401, + "subdir": "linux-64", + "timestamp": 1679340496599, + "version": "0.20.0" + }, + "uvicorn-0.20.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.*", + "h11 >=0.8", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07bef93d16f0a43a5cdb9479c5c12408", + "name": "uvicorn", + "sha256": "79139fea3d42f28cbad1e8faafe8623288bc6d3c23cb3d1e483e2e7086fa9365", + "size": 84472, + "subdir": "linux-64", + "timestamp": 1678090168148, + "version": "0.20.0" + }, + "uvicorn-0.20.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.*", + "h11 >=0.8", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1d33469073c6bc459860a935ce18c0db", + "name": "uvicorn", + "sha256": "083a27ac806dd5611bd9715df6369c5b59019ffab12858037d4b9df0673b022e", + "size": 84428, + "subdir": "linux-64", + "timestamp": 1678090115817, + "version": "0.20.0" + }, + "uvicorn-standard-0.20.0-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "httptools >=0.5.0", + "python-dotenv >=0.13", + "pyyaml >=5.1", + "uvicorn 0.20.0 py39h06a4308_0", + "uvloop >=0.14.0,!=0.15.0,!=0.15.1", + "watchfiles >=0.13", + "websockets >=10.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b588616b84fb0e51ed0f44062a7db04e", + "name": "uvicorn-standard", + "sha256": "2acc89d9b81236e2a811e8735bc38c5215cde0ac22fde3b1ce4c856430f8c087", + "size": 4932, + "subdir": "linux-64", + "timestamp": 1678090123235, + "version": "0.20.0" + }, + "uvloop-0.10.1-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "4dc29664018213fd9fa6ac2b14936a97", + "name": "uvloop", + "sha256": "3af420f56055b3dadacd128eccea01dfce75c362e884fcaf85fe9def4fd4142a", + "size": 1366428, + "subdir": "linux-64", + "timestamp": 1528143611597, + "version": "0.10.1" + }, + "uvloop-0.10.1-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "391f81b23dd9235f75706c7fc3f23738", + "name": "uvloop", + "sha256": "b305cc2d902a137bc9f53045eff26a5a35fe0a52642cf876f91210a1ca3ae5fb", + "size": 1386278, + "subdir": "linux-64", + "timestamp": 1528143561208, + "version": "0.10.1" + }, + "uvloop-0.10.1-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "05bec022f8ef66e4358fd61aa88a0c69", + "name": "uvloop", + "sha256": "20314f092b38a2a7d6b8f69c01ba6ad2fbf5978702ea867075c5ceae8f7b4d65", + "size": 1381650, + "subdir": "linux-64", + "timestamp": 1531060556688, + "version": "0.10.1" + }, + "uvloop-0.11.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "621fc216ba879e7c7944f16e4f539d9c", + "name": "uvloop", + "sha256": "cff3c1a2b2b9b940fd6375626037c4f7576db421d18d5289eeaf72e0e1669563", + "size": 1395733, + "subdir": "linux-64", + "timestamp": 1532800468523, + "version": "0.11.0" + }, + "uvloop-0.11.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7711ff8fa070565097bd630f57ef4935", + "name": "uvloop", + "sha256": "b366296e6f30471a73eae3c1c9bcd44fa53a7a03d91a6c82b29c9ef6f3107c5e", + "size": 1414563, + "subdir": "linux-64", + "timestamp": 1532800425940, + "version": "0.11.0" + }, + "uvloop-0.11.0-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8014bb0534a4b9b22bb452e51572803f", + "name": "uvloop", + "sha256": "91257ee18f14d92ce2556a8580d62fc12f98ba94e493b42cc3ac702a2330fef9", + "size": 1411300, + "subdir": "linux-64", + "timestamp": 1532800455666, + "version": "0.11.0" + }, + "uvloop-0.11.2-py35h7b6447c_0.tar.bz2": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "19cda9ed4c692d93d77590543fb09e52", + "name": "uvloop", + "sha256": "d5abd291167b12cec1f53746cfdccb37dadae791f70c8d3c9e1f984f97a5fcad", + "size": 1398652, + "subdir": "linux-64", + "timestamp": 1535669443141, + "version": "0.11.2" + }, + "uvloop-0.11.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3eebe5e90d9e46ac23813ea7d9cabe48", + "name": "uvloop", + "sha256": "c855e7fb6929a24396d29706753fa9c46dde4a3faba4a7a6f691bf816599abc5", + "size": 1417820, + "subdir": "linux-64", + "timestamp": 1535669392508, + "version": "0.11.2" + }, + "uvloop-0.11.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "11f9a6045eb6073266ad0638a69d0203", + "name": "uvloop", + "sha256": "394edb867ba0e87a6183ed5e11ac91c0ec3aa929ca0d09d2720ad0d8c5dd6293", + "size": 1414616, + "subdir": "linux-64", + "timestamp": 1535669470838, + "version": "0.11.2" + }, + "uvloop-0.11.3-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "63138fae70e667207fb93d9c2bfceaf9", + "name": "uvloop", + "sha256": "64bcb5762e2c3c2eb9b1c23c46a220870db7774238c721d1ddd1a5a6318993ec", + "size": 1438523, + "subdir": "linux-64", + "timestamp": 1545120067487, + "version": "0.11.3" + }, + "uvloop-0.11.3-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5028428e00d8486c68318dc2ab57182c", + "name": "uvloop", + "sha256": "f0737ee2e21fa32f3b7c958eeded76f55c3e3964a93308857ee7a4495e9f38c2", + "size": 1435900, + "subdir": "linux-64", + "timestamp": 1545120066315, + "version": "0.11.3" + }, + "uvloop-0.12.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "5d992c0a675aa9a371170fb623f2f9c1", + "name": "uvloop", + "sha256": "655059c4eda7abc2bfb85de1db3e7160aaf2e38c89988f65fccc3ac8bde952ac", + "size": 1405108, + "subdir": "linux-64", + "timestamp": 1552371957141, + "version": "0.12.1" + }, + "uvloop-0.12.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b64e33f1905ae66f593744e983cc5141", + "name": "uvloop", + "sha256": "ba8ea5fd7b2f823509022de0f3ca22e1da6441fe5315d471245fa6b1bfa6c81e", + "size": 1388123, + "subdir": "linux-64", + "timestamp": 1552371955909, + "version": "0.12.1" + }, + "uvloop-0.12.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "36de5bbf0af81fa25ba969a372e94a36", + "name": "uvloop", + "sha256": "35232a3fb497fd8cbabdc140b77adce366d6e92d72a1b4978f5ae986b34e5f22", + "size": 1403698, + "subdir": "linux-64", + "timestamp": 1556078222108, + "version": "0.12.2" + }, + "uvloop-0.12.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "306c8bfed63fbb282e5a0a62e2945f8c", + "name": "uvloop", + "sha256": "a70eb20bad83cd2bf820a87685b16ca046c87d202b793d9a066adb1c5bded0e7", + "size": 1401749, + "subdir": "linux-64", + "timestamp": 1556078271285, + "version": "0.12.2" + }, + "uvloop-0.12.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "21df840451f83bc6bafbe0bcbf8296cd", + "name": "uvloop", + "sha256": "db81f0fc19a5a7f7e75f694066d5cee32949b7edb0036bceafb5319ca1f47e19", + "size": 1460430, + "subdir": "linux-64", + "timestamp": 1573200644873, + "version": "0.12.2" + }, + "uvloop-0.14.0-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e12b4e52b19deb0b0eb7fbca2506e9a0", + "name": "uvloop", + "sha256": "c646d56961ef0dafb7ddb5c5d2e5d3f6ef4eb29ec4705a901d0efa3f2437a170", + "size": 1329301, + "subdir": "linux-64", + "timestamp": 1613405881970, + "version": "0.14.0" + }, + "uvloop-0.14.0-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "fa5747da83909ccdb9f4498792886535", + "name": "uvloop", + "sha256": "58247de015c88f83eac0b9deac3e96b646e56aad973e12f33e1d2bf020724be6", + "size": 1440674, + "subdir": "linux-64", + "timestamp": 1587391850496, + "version": "0.14.0" + }, + "uvloop-0.14.0-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "409859971cd5d390e7450c56970b1774", + "name": "uvloop", + "sha256": "3dc7f3a96f85cd58d81b8c3d3fe3e9c134120bd2b8e6286ee17a5ef82d9694d6", + "size": 1347684, + "subdir": "linux-64", + "timestamp": 1613405810527, + "version": "0.14.0" + }, + "uvloop-0.14.0-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "59335e41c836be206c972abad38b66e0", + "name": "uvloop", + "sha256": "38d756f5f3192c6938aef5b8164d6029f590a673fb6d675c26f13267da15f744", + "size": 1432188, + "subdir": "linux-64", + "timestamp": 1587391756105, + "version": "0.14.0" + }, + "uvloop-0.14.0-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "c45e87588bfc311da8133d6dcea7354a", + "name": "uvloop", + "sha256": "375c56bf4281c5435f126c1d0d28870b968c5e64dd1f3c2e8b6f6f8d4f7473cc", + "size": 1384781, + "subdir": "linux-64", + "timestamp": 1613405276742, + "version": "0.14.0" + }, + "uvloop-0.14.0-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "d8ab0f2fc1c4b93f89ca9e7290ce56f5", + "name": "uvloop", + "sha256": "720ffe9d3b15638e136c80df10a7549977967509dae49a99ed3257c61ed4e75b", + "size": 1486127, + "subdir": "linux-64", + "timestamp": 1587391872222, + "version": "0.14.0" + }, + "uvloop-0.14.0-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "4031c313c8a0c52653c3b40443a4a55b", + "name": "uvloop", + "sha256": "066967c9a1abaff8d065d4286982fe5c18fdc58e2d565e0b41530aaebcd91dcd", + "size": 1391358, + "subdir": "linux-64", + "timestamp": 1613405873133, + "version": "0.14.0" + }, + "uvloop-0.15.2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT OR Apache-2.0", + "md5": "07f7c9c40769e1f168c73e63f333febe", + "name": "uvloop", + "sha256": "3be18023382cde5e4d5e8bd325093fa01a930d590772e1241364976ee2e2c447", + "size": 1058491, + "subdir": "linux-64", + "timestamp": 1615407877861, + "version": "0.15.2" + }, + "uvloop-0.15.2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT OR Apache-2.0", + "md5": "7d01f4c2ce472d2a674dad1d04a5156d", + "name": "uvloop", + "sha256": "2a8684b1aed2421bc6e42ded674e75b1a2da315cec07fb2470ba0c97b1f06dce", + "size": 1100971, + "subdir": "linux-64", + "timestamp": 1615408131915, + "version": "0.15.2" + }, + "uvloop-0.15.2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT OR Apache-2.0", + "md5": "f62f9c8b492e06cbb265b86ee5c75afe", + "name": "uvloop", + "sha256": "bde548b62735485f45d19e9f11ca5aff3a7b77b2c2cf0b87a0f0e044de577f09", + "size": 1114990, + "subdir": "linux-64", + "timestamp": 1615408116776, + "version": "0.15.2" + }, + "uvloop-0.16.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT OR Apache-2.0", + "md5": "ea172285cf2a5f4d9fc9f21342a948fd", + "name": "uvloop", + "sha256": "99d62b359fdc9b6a74a1e6f045b95e05427bcc82fd49d770e02f1492bfe0bbec", + "size": 3023289, + "subdir": "linux-64", + "timestamp": 1640795729159, + "version": "0.16.0" + }, + "uvloop-0.16.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT OR Apache-2.0", + "md5": "7c66e72114271b0d00fb752c02ffe241", + "name": "uvloop", + "sha256": "e129fd95c2bf2cdfc9ae21f12ddf65f2cc30d8c2be1eb32e4d24bdc05cd2a56e", + "size": 1087757, + "subdir": "linux-64", + "timestamp": 1676863451743, + "version": "0.16.0" + }, + "uvloop-0.16.0-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT OR Apache-2.0", + "md5": "ae113a9bff0810b123ce2efdd321bfdf", + "name": "uvloop", + "sha256": "bc5a3c06b3c794e6c438b858fae0756bec11f73ed9c6d91ab70dada593b063ab", + "size": 1061606, + "subdir": "linux-64", + "timestamp": 1639503251088, + "version": "0.16.0" + }, + "uvloop-0.16.0-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT OR Apache-2.0", + "md5": "4dbcc6af4456326d1f11fe4ee2bc4d81", + "name": "uvloop", + "sha256": "93313a62f2b817fd7484fbf98a737c19345bc839da562c94fd63be8b7d0f09e9", + "size": 1116506, + "subdir": "linux-64", + "timestamp": 1639489489218, + "version": "0.16.0" + }, + "uvloop-0.16.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT OR Apache-2.0", + "md5": "fdef2902b09baeef950f302a704caeac", + "name": "uvloop", + "sha256": "53f95ae2c77fd7bcac2bfff3a92e518826f21a45f8f18cc82742d2ee1a716a03", + "size": 1109375, + "subdir": "linux-64", + "timestamp": 1639503243172, + "version": "0.16.0" + }, + "uvloop-0.17.0-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libuv >=1.44.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT OR Apache-2.0", + "license_family": "Other", + "md5": "658281d4e229ac01163043bfe3f57f39", + "name": "uvloop", + "sha256": "bf5d686bb96bb27c1dd6a2afdbefb77ec778a161062523d11c7298b50e1b6682", + "size": 1105599, + "subdir": "linux-64", + "timestamp": 1677843314473, + "version": "0.17.0" + }, + "uvloop-0.17.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libuv >=1.44.2,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT OR Apache-2.0", + "license_family": "Other", + "md5": "b5d84dd320b821e1ad4298b3f2fce0d8", + "name": "uvloop", + "sha256": "56f0890c5a8bf64da09fe89e2666d62dfa8f8e4fb31f6c623818c85859fc47f9", + "size": 1100021, + "subdir": "linux-64", + "timestamp": 1679339485880, + "version": "0.17.0" + }, + "uvloop-0.17.0-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libuv >=1.44.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT OR Apache-2.0", + "license_family": "Other", + "md5": "4c083624cbb1cd09364729a4366b07a5", + "name": "uvloop", + "sha256": "178d25182cb92fa9c4d9808c7002801bde6559b79a059f62e56ceddb95f2d6ad", + "size": 1145612, + "subdir": "linux-64", + "timestamp": 1677843441566, + "version": "0.17.0" + }, + "uvloop-0.17.0-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libuv >=1.44.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT OR Apache-2.0", + "license_family": "Other", + "md5": "e1d2b210f3d825db489c3124b97e56d9", + "name": "uvloop", + "sha256": "1fefac86e144f2ae39984d40908f182e7026fab518c13f941601fee604e227ed", + "size": 1122122, + "subdir": "linux-64", + "timestamp": 1677843375918, + "version": "0.17.0" + }, + "uvloop-0.8.1-py35hc45d62f_0.tar.bz2": { + "build": "py35hc45d62f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "94bdb901910b077ee889e9b16482560f", + "name": "uvloop", + "sha256": "a60c631ae8a3d044f0b07a99f49cf428c236e990e7ee122472452b4a32a69414", + "size": 1179778, + "subdir": "linux-64", + "timestamp": 1507236315111, + "version": "0.8.1" + }, + "uvloop-0.8.1-py36h7036845_0.tar.bz2": { + "build": "py36h7036845_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "08c2f33a9f9286daf673a411e19ebbef", + "name": "uvloop", + "sha256": "00efc45dd849530eff8de5c4376e68130fc32002313d2f04ddf06f0510fe32b0", + "size": 1196749, + "subdir": "linux-64", + "timestamp": 1507236312039, + "version": "0.8.1" + }, + "uvloop-0.9.1-py35h9cf2f49_0.tar.bz2": { + "build": "py35h9cf2f49_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "222ba24ac6476988c92952935bcd8c78", + "name": "uvloop", + "sha256": "e1ed4e870c4d9272aee356d6f5260381f50e82a6b1d1d65b4bf8d4ea5985d232", + "size": 1235144, + "subdir": "linux-64", + "timestamp": 1512037457077, + "version": "0.9.1" + }, + "uvloop-0.9.1-py36h0ff8193_0.tar.bz2": { + "build": "py36h0ff8193_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "dd2c11262c44b201da951f08be06df99", + "name": "uvloop", + "sha256": "242b7313176dad0a00b06af8da7c7dc2cb714724faf671bf45b3e1275e1b942d", + "size": 1249864, + "subdir": "linux-64", + "timestamp": 1512037479402, + "version": "0.9.1" + }, + "uwsgi-2.0.21-py310h068a5ad_1.tar.bz2": { + "build": "py310h068a5ad_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "jansson >=2.14,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuuid", + "libxml2 >=2.10.3,<2.11.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre >=8.44,<9.0a0", + "python >=3.10,<3.11.0a0", + "xz", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "860090e8b77149d47085f83511985191", + "name": "uwsgi", + "sha256": "893370298e372d5023dbf139cc6e54a634d8e2d4d1ca58ca32a42c312a074eab", + "size": 8555383, + "subdir": "linux-64", + "timestamp": 1679988563394, + "version": "2.0.21" + }, + "uwsgi-2.0.21-py310hb8d2a22_0.tar.bz2": { + "build": "py310hb8d2a22_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "jansson >=2.14,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuuid", + "libxml2 >=2.9.14,<2.10.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre >=8.44,<9.0a0", + "python >=3.10,<3.11.0a0", + "xz", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "44bdd7233802d83bcad4999c33835c82", + "name": "uwsgi", + "sha256": "7ad9c78c7010c280af6d18965be0a16485dac9a47b3faef927f37b39b99aa81d", + "size": 8545732, + "subdir": "linux-64", + "timestamp": 1678466501519, + "version": "2.0.21" + }, + "uwsgi-2.0.21-py311h068a5ad_1.tar.bz2": { + "build": "py311h068a5ad_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "jansson >=2.14,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuuid", + "libxml2 >=2.10.3,<2.11.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre >=8.44,<9.0a0", + "python >=3.11,<3.12.0a0", + "xz", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "a40b48af48de89ab58adc259a8b5557e", + "name": "uwsgi", + "sha256": "3a92c19092481ed9b69100e6586b00e7e08702887b1003b7e0ea7f3e0da675a9", + "size": 10549952, + "subdir": "linux-64", + "timestamp": 1679988830751, + "version": "2.0.21" + }, + "uwsgi-2.0.21-py311hb8d2a22_0.tar.bz2": { + "build": "py311hb8d2a22_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "jansson >=2.14,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuuid", + "libxml2 >=2.9.14,<2.10.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre >=8.44,<9.0a0", + "python >=3.11,<3.12.0a0", + "xz", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "81f110ae34b2a94220fdb609849daf63", + "name": "uwsgi", + "sha256": "ac92d08997f1427e2748432731916422e7d1d6c9c089ad3b332b81729d8ec359", + "size": 10533172, + "subdir": "linux-64", + "timestamp": 1679339749338, + "version": "2.0.21" + }, + "uwsgi-2.0.21-py38h068a5ad_1.tar.bz2": { + "build": "py38h068a5ad_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "jansson >=2.14,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuuid", + "libxml2 >=2.10.3,<2.11.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre >=8.44,<9.0a0", + "python >=3.8,<3.9.0a0", + "xz", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "aae75f2bfa2d42a836e411d23ae59306", + "name": "uwsgi", + "sha256": "aeeb69b39924a43671d638c3ba806b336acb574958813b1bd5c8ab5c5f3324cb", + "size": 7154000, + "subdir": "linux-64", + "timestamp": 1679988690807, + "version": "2.0.21" + }, + "uwsgi-2.0.21-py38hb8d2a22_0.tar.bz2": { + "build": "py38hb8d2a22_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "jansson >=2.14,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuuid", + "libxml2 >=2.9.14,<2.10.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre >=8.44,<9.0a0", + "python >=3.8,<3.9.0a0", + "xz", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "6a03e97bc5532eddd2ea4d91ca5f0e2f", + "name": "uwsgi", + "sha256": "82287fa4af10a7c9df0d90651ef7bcdf9c704fafc6f5875c4ffc810c6c8dfec1", + "size": 7149640, + "subdir": "linux-64", + "timestamp": 1678466366238, + "version": "2.0.21" + }, + "uwsgi-2.0.21-py39h068a5ad_1.tar.bz2": { + "build": "py39h068a5ad_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "jansson >=2.14,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuuid", + "libxml2 >=2.10.3,<2.11.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre >=8.44,<9.0a0", + "python >=3.9,<3.10.0a0", + "xz", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "b44197f7b6c97df74bb021239fb97439", + "name": "uwsgi", + "sha256": "eadf53a9d4770f65067b2dcea041ffe5a59c2a6c2729bf54d10d1dea30c14279", + "size": 8113088, + "subdir": "linux-64", + "timestamp": 1679988430196, + "version": "2.0.21" + }, + "uwsgi-2.0.21-py39hb8d2a22_0.tar.bz2": { + "build": "py39hb8d2a22_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "jansson >=2.14,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuuid", + "libxml2 >=2.9.14,<2.10.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre >=8.44,<9.0a0", + "python >=3.9,<3.10.0a0", + "xz", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "e4b5c5575ebe4c61c208e2a9cc044a82", + "name": "uwsgi", + "sha256": "33cd2aaa33ad2d59f93032029f9f71f4a225e23bce3dcc5392d764c829876d62", + "size": 8108294, + "subdir": "linux-64", + "timestamp": 1678466635809, + "version": "2.0.21" + }, + "vcrpy-1.13.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "mock", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63a53ad815c42db5ac6824d222774abb", + "name": "vcrpy", + "sha256": "93bda0caf0a2272985b2fc32cadf7a40f37eb42ee54ffab3d76663140b89a856", + "size": 50678, + "subdir": "linux-64", + "timestamp": 1536853882283, + "version": "1.13.0" + }, + "vcrpy-1.13.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea4e143e62b5f9e8160c6e2aaeb80828", + "name": "vcrpy", + "sha256": "0dbe5ba38b92d082381dd70897545dc5f404473bd47ab63df01f0d9a5d55a021", + "size": 53959, + "subdir": "linux-64", + "timestamp": 1536853915658, + "version": "1.13.0" + }, + "vcrpy-1.13.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a31d61d30176f038f196ca15f33b635", + "name": "vcrpy", + "sha256": "4bf84dae3aa99d4e395fde775b9eb8a921a43f60dadf7a31ee39fd220512a20d", + "size": 53742, + "subdir": "linux-64", + "timestamp": 1536853922752, + "version": "1.13.0" + }, + "vcrpy-1.13.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4772ba3f2168f4b293e0312ec41fedb", + "name": "vcrpy", + "sha256": "bb9f5c6179d23f494525a298db79abbf702545ada3161fd35057689ed3e3b756", + "size": 53823, + "subdir": "linux-64", + "timestamp": 1536853866379, + "version": "1.13.0" + }, + "vcrpy-2.0.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "mock", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df84a0fbe88dcfaca2c5f33b139eb07d", + "name": "vcrpy", + "sha256": "67599ad3a4de3d58f1d1630a1593941f8ac77a9fa978d314f954b7b60f48a6ca", + "size": 51414, + "subdir": "linux-64", + "timestamp": 1539658868326, + "version": "2.0.1" + }, + "vcrpy-2.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45da12766ef276c8b98fd1a3e418c11e", + "name": "vcrpy", + "sha256": "11bb3c4165a9be828c9fecea1cff895d368b588732c0d96eaaf3953a33f994e6", + "size": 54478, + "subdir": "linux-64", + "timestamp": 1539658891978, + "version": "2.0.1" + }, + "vcrpy-2.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a9e62853cfacc36b0b0ac80748cd211b", + "name": "vcrpy", + "sha256": "4dce86ba8e47bfced354bfdc080dc55485a660d92403be3c066dcab11f0aaf96", + "size": 54571, + "subdir": "linux-64", + "timestamp": 1539658871559, + "version": "2.0.1" + }, + "vcrpy-2.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "mock", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1859dd8e47ea8ca4f06679ab6304a20", + "name": "vcrpy", + "sha256": "af45d14f9cde71f6bfb2699552972fdba22c2ea7ae8d1182b310b3f73cbc9700", + "size": 59906, + "subdir": "linux-64", + "timestamp": 1569428144588, + "version": "2.1.0" + }, + "vcrpy-2.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb585ef9ca4740521c7d2a73107f8a33", + "name": "vcrpy", + "sha256": "d77eee15c3f679ddf735b15fa45de1c13ec63696e6134a6a7f85b1e6456a98e2", + "size": 63775, + "subdir": "linux-64", + "timestamp": 1569428133567, + "version": "2.1.0" + }, + "vcrpy-2.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d4cfe7a2ba50802cba65fddace1b7028", + "name": "vcrpy", + "sha256": "9d1d20c05454a25b4daaa63b134c8bcb460d94e09e273055c7beb9f01c9e4cc6", + "size": 63918, + "subdir": "linux-64", + "timestamp": 1569428131201, + "version": "2.1.0" + }, + "vcrpy-2.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "mock", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c7b162806239d4c795a0e2aaa0abfe3", + "name": "vcrpy", + "sha256": "3443ce0fbeb08bb1612d9349afeb54b8c22b55850b6ce30c172cb81baa484492", + "size": 59986, + "subdir": "linux-64", + "timestamp": 1573975890679, + "version": "2.1.1" + }, + "vcrpy-2.1.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5336500a4d472a508c07dd81475f71e4", + "name": "vcrpy", + "sha256": "f4187ec221f1a329b9f840b9652dabdfb800f823cb446e97b5443362c0c29481", + "size": 61542, + "subdir": "linux-64", + "timestamp": 1640813215287, + "version": "2.1.1" + }, + "vcrpy-2.1.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "262cbab90eecb131992adc933b3de6ee", + "name": "vcrpy", + "sha256": "742cc36c1aced08d47e399c4f16308f4f64c7eb6f981f333708ccc3c0ebb4d94", + "size": 82587, + "subdir": "linux-64", + "timestamp": 1676863470569, + "version": "2.1.1" + }, + "vcrpy-2.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95e485d91392718f9bc440a9a757c8c9", + "name": "vcrpy", + "sha256": "715e3042b55234ff336884222ea66d0f82af2b1a787d3cdc48a39add028d803c", + "size": 63860, + "subdir": "linux-64", + "timestamp": 1573975897222, + "version": "2.1.1" + }, + "vcrpy-2.1.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "701dcad98f77257ceaace1cd0b9ab7a3", + "name": "vcrpy", + "sha256": "0ab07ddcf5e96694baaf0f527936d24f8afcaafcddbdaa35c6095601b1d492d4", + "size": 63973, + "subdir": "linux-64", + "timestamp": 1613038276262, + "version": "2.1.1" + }, + "vcrpy-2.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a33d41224261affa838c808fa200ad9c", + "name": "vcrpy", + "sha256": "15f82c4b26ecd1b6e23c09b06475c1bc6f78683911bb295be6ed2ca17902a3da", + "size": 64060, + "subdir": "linux-64", + "timestamp": 1573975877661, + "version": "2.1.1" + }, + "vcrpy-2.1.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "083398139b439464016ba539e8e27402", + "name": "vcrpy", + "sha256": "697d9ab12737d48a775e0081452e4e56b1445b7fa3551e2e2c2294fa9b056064", + "size": 64159, + "subdir": "linux-64", + "timestamp": 1613038675156, + "version": "2.1.1" + }, + "vcrpy-2.1.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a5062489c2b660c3572d9ab475a6d504", + "name": "vcrpy", + "sha256": "b8263c37dba51ad3f76b4b09771dc55dca39b36f8495f4843130c74f517694ff", + "size": 60784, + "subdir": "linux-64", + "timestamp": 1574153530444, + "version": "2.1.1" + }, + "vcrpy-2.1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e1a68678e90acea6b4e1ce7e574e4d79", + "name": "vcrpy", + "sha256": "6783ed53ab2e2e412e03aad35d5aadbcfacdbaf9f48ffadae25706e9941c5e25", + "size": 64438, + "subdir": "linux-64", + "timestamp": 1613038627351, + "version": "2.1.1" + }, + "vcrpy-2.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "633c96832e4afda6df77c32cbea04229", + "name": "vcrpy", + "sha256": "37ffca25632cbd8d9128fb1e088d42e2c6c7755e470e0cf8221c0edeb07e6eb5", + "size": 64523, + "subdir": "linux-64", + "timestamp": 1613038662638, + "version": "2.1.1" + }, + "vcrpy-4.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a8feeb4d0f9512d8dd395c95b565e84", + "name": "vcrpy", + "sha256": "1e2dc7e9a04849cb0885cf4dc4d7955ceb6b87095085ff2ffad4afb045ba3822", + "size": 64874, + "subdir": "linux-64", + "timestamp": 1600470088940, + "version": "4.1.0" + }, + "vcrpy-4.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "41647e003b35f010cd83e4f317a5fbc4", + "name": "vcrpy", + "sha256": "536605baea9fbdf307a498545c39a0a671a8741c0b99bd058766b6662e86d535", + "size": 65044, + "subdir": "linux-64", + "timestamp": 1600470086701, + "version": "4.1.0" + }, + "vcrpy-4.1.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d5e3262dfc1a92a5fce538b65aa8954", + "name": "vcrpy", + "sha256": "74128641cfd8460c37a969795111f6e8f201b353f95901010e07eed52000af39", + "size": 65293, + "subdir": "linux-64", + "timestamp": 1600470068743, + "version": "4.1.0" + }, + "vcrpy-4.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18b19e2402a3bb0142827aa86941e770", + "name": "vcrpy", + "sha256": "99cc25081ec2ab164983f86a250df50e14dfcf65795b82580cf816324135b6ca", + "size": 64903, + "subdir": "linux-64", + "timestamp": 1602526767692, + "version": "4.1.1" + }, + "vcrpy-4.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1ab748df5f19cdab5fdb401c8145e6a", + "name": "vcrpy", + "sha256": "d04d31ebc152b3a5c37980f5908558a3e2f89e731986de41c468ec63b94e7cfc", + "size": 65030, + "subdir": "linux-64", + "timestamp": 1602523544301, + "version": "4.1.1" + }, + "vcrpy-4.1.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aabdf20abe044a91947364b70035cb13", + "name": "vcrpy", + "sha256": "f58175e7afe51553a9309ae58ceea2463d0a27d185ae7597a65dc5a669dae7ae", + "size": 65289, + "subdir": "linux-64", + "timestamp": 1602523518193, + "version": "4.1.1" + }, + "vcversioner-2.16.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "79bc37a73d176b77d28603544d9559b5", + "name": "vcversioner", + "sha256": "721b07a0908679d03cc16a1ae96d485158e2c79dfca2a8adb49e1b67e45e6ed1", + "size": 13139, + "subdir": "linux-64", + "timestamp": 1530693910883, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py27h4da6c7b_0.tar.bz2": { + "build": "py27h4da6c7b_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "f3005e8af293175308ddaf0ac46bbc41", + "name": "vcversioner", + "sha256": "63c5d4a9c2ec32e8ab9e157f0870f3a8d43672cccc6f2d3f9b36561b6cae3557", + "size": 12994, + "subdir": "linux-64", + "timestamp": 1505672156046, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "ISC", + "md5": "2a641f08fc2e75c1b48eaaaf5ae13533", + "name": "vcversioner", + "sha256": "48ee59fb7f774b68d6caa5995ad2fdf755aefd769eeef8e54f4d3cad2b6d80db", + "size": 13564, + "subdir": "linux-64", + "timestamp": 1640795749876, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "ISC", + "md5": "522bc590604ce6a3cb9c150b04a40d95", + "name": "vcversioner", + "sha256": "86db86fa7ed5af97ccea127ba3433fc41e7d10296022924a7eb6758ef9a1d8c0", + "size": 15439, + "subdir": "linux-64", + "timestamp": 1676863484913, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py35h8b0535f_0.tar.bz2": { + "build": "py35h8b0535f_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "c9595833eabd203fd5562f0a27470659", + "name": "vcversioner", + "sha256": "aed118ca7b8deaa39177081689dc94a6092c67d9ad678fd6ffece82f74099fbb", + "size": 13172, + "subdir": "linux-64", + "timestamp": 1505672166710, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "c956efab4ddd27003c5e41cd2f5535ad", + "name": "vcversioner", + "sha256": "4da4eea99f59281b65d5fc0fbff874677072445b226117734868d760dce48830", + "size": 13311, + "subdir": "linux-64", + "timestamp": 1530693874232, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "bb55acef7ebf6ee73871aba9cc86674d", + "name": "vcversioner", + "sha256": "07a3d5838b2650d77c4ad8169db8808cb8e519ce05e124e2df2235a2c54967c2", + "size": 15086, + "subdir": "linux-64", + "timestamp": 1611772642186, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py36h539c7c5_0.tar.bz2": { + "build": "py36h539c7c5_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "5631a7e66f2bf1c4b1fc3e92c758c78c", + "name": "vcversioner", + "sha256": "84279c04e519b68144a739fe1b1834326efb10c47a020d664d4fa1c5e5b61259", + "size": 13173, + "subdir": "linux-64", + "timestamp": 1505672177464, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "194ebd077e5d78ee46d020987e6743fa", + "name": "vcversioner", + "sha256": "d673be8c6dd236f8f05d63cfd154514cd55505e39b0ef28f82a8ea19c2ad7199", + "size": 13242, + "subdir": "linux-64", + "timestamp": 1530693893251, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "75a90c4948aa5a3907c8bf6a5c3e499f", + "name": "vcversioner", + "sha256": "37a20c3b646a0af5b61a633a4a7e599b28b883ed4c1e8fc7d1f3659e4a36c7a8", + "size": 14999, + "subdir": "linux-64", + "timestamp": 1611772653122, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "f9ff0b56bfc33365edfb33a90d1ebe1a", + "name": "vcversioner", + "sha256": "063def841da3f5182baf2b96e4ee988ebe03c1408726bd9fb2778e178e4c4dcf", + "size": 13723, + "subdir": "linux-64", + "timestamp": 1573200295885, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "965da6caa6e5099f31068849e7d031aa", + "name": "vcversioner", + "sha256": "b144e45c0a3ce2971560220b7ea58a08eb6cbf6d6d9fd61dbc0563441696b4f8", + "size": 15043, + "subdir": "linux-64", + "timestamp": 1611772663464, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "md5": "392c6c94727b7047fc6d906dbcca8202", + "name": "vcversioner", + "sha256": "b6a0feb1b61885dab37ae1be8d78f3b85797eea5c7b3224771f2480e1fbea008", + "size": 15110, + "subdir": "linux-64", + "timestamp": 1611772366456, + "version": "2.16.0.0" + }, + "venusian-1.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "1b6e696dd781b8df27179bc01c622072", + "name": "venusian", + "sha256": "c8458f8e4396badbecaf09aaa1cbbbbad6d695560cdb10df5fa16e04412e6adb", + "size": 39429, + "subdir": "linux-64", + "timestamp": 1530814241061, + "version": "1.1.0" + }, + "venusian-1.1.0-py27hb5d49f3_0.tar.bz2": { + "build": "py27hb5d49f3_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "2066ed6e6482143d99f297a76167f799", + "name": "venusian", + "sha256": "9802c9c20c64e70ff63241d9d81e27438cfeff60dfd778f9c89f2407ea343863", + "size": 39619, + "subdir": "linux-64", + "timestamp": 1508006852687, + "version": "1.1.0" + }, + "venusian-1.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "1349e43930980e7e096f37bf4184736e", + "name": "venusian", + "sha256": "715183bc5a55ad30fcb408d787ebd723be15acac23e8572ff7be6db080235721", + "size": 40694, + "subdir": "linux-64", + "timestamp": 1535130261506, + "version": "1.1.0" + }, + "venusian-1.1.0-py35h7b98667_0.tar.bz2": { + "build": "py35h7b98667_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "2d809e129af5d853e85a17eafadc6f9e", + "name": "venusian", + "sha256": "827ca579a4c9bbe6a83c213edbd7fd93fca6db6e08274b3ca60cc85081498061", + "size": 40918, + "subdir": "linux-64", + "timestamp": 1508006870580, + "version": "1.1.0" + }, + "venusian-1.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "f0039bdd24f0afdbb1b9925741e7fd17", + "name": "venusian", + "sha256": "2d3abc38c59918d6b23ca8b39c530a5453080bc01ac3f0e970af2c91f5259796", + "size": 40522, + "subdir": "linux-64", + "timestamp": 1530814294668, + "version": "1.1.0" + }, + "venusian-1.1.0-py36h56a613d_0.tar.bz2": { + "build": "py36h56a613d_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "06a9418dcc369920936cc68851a7f8b8", + "name": "venusian", + "sha256": "8f36c438254f622576e4c717b791b40fbf6944585208018c0d1c8dbb8b4a0e5c", + "size": 40762, + "subdir": "linux-64", + "timestamp": 1508006862533, + "version": "1.1.0" + }, + "venusian-1.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "4d35c5b3b3019723b3e0e6799b7e8fda", + "name": "venusian", + "sha256": "470fca1468eb95da8e79df88bffa638d6d0e5823bb1f61758d8f96bcc8f4328d", + "size": 40565, + "subdir": "linux-64", + "timestamp": 1530814267275, + "version": "1.1.0" + }, + "venusian-1.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "64ed09faa5ae13f5171fca64ac39c133", + "name": "venusian", + "sha256": "0c012035815e920ff0e48d38b78c7e0460208877116275e156089059d1ca7343", + "size": 166575, + "subdir": "linux-64", + "timestamp": 1547984417428, + "version": "1.2.0" + }, + "venusian-1.2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "796588bfea0c8820d49eb6167637881e", + "name": "venusian", + "sha256": "54738be94ffb2f896d84725b13d0a4cc2c236b94fa17f9ee4db01e1b551993f2", + "size": 41285, + "subdir": "linux-64", + "timestamp": 1640795768128, + "version": "1.2.0" + }, + "venusian-1.2.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "md5": "ba5841853bb47de693559577bf552d63", + "name": "venusian", + "sha256": "c5d3279817e97350b62456cc2986a9d8049150fd9d498b7717a80a2dcbc89b51", + "size": 49779, + "subdir": "linux-64", + "timestamp": 1676905875996, + "version": "1.2.0" + }, + "venusian-1.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "b4e238dd533f73ac4fb1a4be32468023", + "name": "venusian", + "sha256": "a58d53934cfe5a21a862fba82bbfeba0b3ffe5f0ace1a92b16ba467ea5c41cb9", + "size": 167932, + "subdir": "linux-64", + "timestamp": 1547984494511, + "version": "1.2.0" + }, + "venusian-1.2.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "f1b3cc5fdffbb976c52161c5efaaebc3", + "name": "venusian", + "sha256": "d0d03f3d8c387f0360b29a2c7f3dc7971582bbac1550d7b9d37bc7de97f31d64", + "size": 262400, + "subdir": "linux-64", + "timestamp": 1614000079897, + "version": "1.2.0" + }, + "venusian-1.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "b8bb08dfdff16488738389de8247eb9f", + "name": "venusian", + "sha256": "aae063b03b9f68a1ffc1e82c153b29ca2f9c12c146856a00da909ea09f841284", + "size": 167915, + "subdir": "linux-64", + "timestamp": 1547984515514, + "version": "1.2.0" + }, + "venusian-1.2.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "1de77d8793ed13868df23b1cdb2266ba", + "name": "venusian", + "sha256": "b074a1e851f48e16e0b0cad6c5e7e92203e7571ce280617cc925d1f65812ff34", + "size": 262087, + "subdir": "linux-64", + "timestamp": 1614000070087, + "version": "1.2.0" + }, + "venusian-1.2.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "a137412c3ca74e664ba5ac889e65e905", + "name": "venusian", + "sha256": "453384ef17103702866c40056468b178f2079f149a41d8565289bcc5deae0187", + "size": 41254, + "subdir": "linux-64", + "timestamp": 1573200308105, + "version": "1.2.0" + }, + "venusian-1.2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "387296041d0807baaa20b552e74ad23e", + "name": "venusian", + "sha256": "cc43cca984f33b0ab579c2e2f8509b2c03b5ff9346ebb95640ee23e5836ba4b7", + "size": 262942, + "subdir": "linux-64", + "timestamp": 1613999199163, + "version": "1.2.0" + }, + "venusian-1.2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "ec70b7e6c9bd2d4d729b40c851482cb1", + "name": "venusian", + "sha256": "28961ba6e8b281fd90c352fe064a45bffb986b5ae31ce48e3865256d57ae2dd6", + "size": 262532, + "subdir": "linux-64", + "timestamp": 1614000424730, + "version": "1.2.0" + }, + "verboselogs-1.4-py27h0984be8_0.tar.bz2": { + "build": "py27h0984be8_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d6eb3bc89ea9069156cb9a5d3cc83aae", + "name": "verboselogs", + "sha256": "a727d7e80fa9cb0549c3d668934e73a7d2a1aa9f2e147de9f3fe3e4972e174d8", + "size": 10993, + "subdir": "linux-64", + "timestamp": 1505864044286, + "version": "1.4" + }, + "verboselogs-1.4-py35h7d0379e_0.tar.bz2": { + "build": "py35h7d0379e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "ea797918be1a70d298fb39b759f3b817", + "name": "verboselogs", + "sha256": "91ecca55c9b58306d8bd04c5ad402411bd6350e1521178c43f167e18e44c3fa2", + "size": 11127, + "subdir": "linux-64", + "timestamp": 1505864055845, + "version": "1.4" + }, + "verboselogs-1.4-py36h802500c_0.tar.bz2": { + "build": "py36h802500c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7b5905d8955652546c745fa0237774a6", + "name": "verboselogs", + "sha256": "8e8631e9dcf1934ff65da474ee0ccd20add1008471fc81dda8e925c93c1d5dd3", + "size": 11106, + "subdir": "linux-64", + "timestamp": 1505864067481, + "version": "1.4" + }, + "verboselogs-1.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "8561df094ac67073efc061bacf9742c2", + "name": "verboselogs", + "sha256": "0ddffa0e16f466595c6c524e1217d379f82a9ca391be8013bdfc6dae13529ed4", + "size": 11955, + "subdir": "linux-64", + "timestamp": 1531060659591, + "version": "1.7" + }, + "verboselogs-1.7-py27h713c921_0.tar.bz2": { + "build": "py27h713c921_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "51cda4ab2262ae53f28aee6a93c2d584", + "name": "verboselogs", + "sha256": "7fa7195dfcf3d81c1603bf99c94f29e8f82fe83a73f326acef02cc19914f2e8f", + "size": 12305, + "subdir": "linux-64", + "timestamp": 1511315808868, + "version": "1.7" + }, + "verboselogs-1.7-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "be5a9653b26ecf5c249142b779155497", + "name": "verboselogs", + "sha256": "d748df93b1d58477751f2e385363fdb481582d5331cebb3912d5a391ced2ad6e", + "size": 12535, + "subdir": "linux-64", + "timestamp": 1640795786705, + "version": "1.7" + }, + "verboselogs-1.7-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "f90f01f0f620af38ae8c92ea95b79d8e", + "name": "verboselogs", + "sha256": "3b52c2bf5f622eb760e87824266bf989e255e7daa13e1e0a266380f1742f8483", + "size": 14285, + "subdir": "linux-64", + "timestamp": 1676863500537, + "version": "1.7" + }, + "verboselogs-1.7-py35h5d477f3_0.tar.bz2": { + "build": "py35h5d477f3_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "6de5b8324e1eb22b397f84fa6f5fa9ae", + "name": "verboselogs", + "sha256": "6fa54f42df928000b6b8200fab357b794787ff0a0a988e563240bdc98987b479", + "size": 12501, + "subdir": "linux-64", + "timestamp": 1511315817699, + "version": "1.7" + }, + "verboselogs-1.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4a493fdd9d8b7e50ba7af4588b64ae45", + "name": "verboselogs", + "sha256": "200d6e401e6a39a26e315a4b81a63f3d08da8cbe3c31de4766285d2ec2dca3f6", + "size": 12143, + "subdir": "linux-64", + "timestamp": 1531060594858, + "version": "1.7" + }, + "verboselogs-1.7-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "24aef7efe9ef1cabd4428897948b5995", + "name": "verboselogs", + "sha256": "f8b21514f122aa0c62e698ea024a14df5352a5a1d364f55aaa42afd4cdf35262", + "size": 13429, + "subdir": "linux-64", + "timestamp": 1614000077420, + "version": "1.7" + }, + "verboselogs-1.7-py36h71e5335_0.tar.bz2": { + "build": "py36h71e5335_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "06e8a4f5db429a4b58f877dba8344146", + "name": "verboselogs", + "sha256": "f6dc567682628118edeb2fd27bc75042bb91e1373734777fa616b25d49c51e17", + "size": 12487, + "subdir": "linux-64", + "timestamp": 1511315814809, + "version": "1.7" + }, + "verboselogs-1.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c6d9c12e0e9cb6b054bea90e1814e5fd", + "name": "verboselogs", + "sha256": "8a296aeca93dd48efe46e39f0c8b1d1a90f85308dde23e65e5ad212435f387ce", + "size": 12169, + "subdir": "linux-64", + "timestamp": 1531060627342, + "version": "1.7" + }, + "verboselogs-1.7-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "aa13ec37ef66e55e415312c7832ccfa0", + "name": "verboselogs", + "sha256": "b8b3cf162b7e7b75bcb12c36c440266b1ba3454931035d7c81d4498001c03666", + "size": 13454, + "subdir": "linux-64", + "timestamp": 1613999916353, + "version": "1.7" + }, + "verboselogs-1.7-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "ce006dc551befbfb9ef266aa7f89cf2c", + "name": "verboselogs", + "sha256": "ff26818a7c1261b305f78282fccb5e1a02423d773b30c3f04fd235ac027e0f78", + "size": 12630, + "subdir": "linux-64", + "timestamp": 1573200318916, + "version": "1.7" + }, + "verboselogs-1.7-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "1500b78ded3ea7c080bef4dfb240a82b", + "name": "verboselogs", + "sha256": "435fde0d7f84f06bd9f8ee06719ed8a16b068fc2542d077058b0e9630687631b", + "size": 13447, + "subdir": "linux-64", + "timestamp": 1614000083091, + "version": "1.7" + }, + "verboselogs-1.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "7680c792b6949708750cff75c354ea66", + "name": "verboselogs", + "sha256": "b5134052d2aff0b836bd565d928bff6d4fb43bc49e73ad2cd5c1a208240c3460", + "size": 13481, + "subdir": "linux-64", + "timestamp": 1614000075154, + "version": "1.7" + }, + "virtualenv-15.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "99e7f2e5af6b0c989f78fdfedabc6a3e", + "name": "virtualenv", + "sha256": "8ac6f97ea95875bcfe18e192c39440e4cba91f95ae2d3971a2c57c0a6355de06", + "size": 2544059, + "subdir": "linux-64", + "timestamp": 1522722947567, + "version": "15.2.0" + }, + "virtualenv-15.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "b10c20724f8f38e6f2a60e4c4a9504bd", + "name": "virtualenv", + "sha256": "5214b918f949ef34596653262b8281c17234eeb09f5db41e4479f4c47e362f3b", + "size": 2545248, + "subdir": "linux-64", + "timestamp": 1522715886502, + "version": "15.2.0" + }, + "virtualenv-15.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0e123dbff72f2e3c3f4cd0dd624e2802", + "name": "virtualenv", + "sha256": "69a302f8130eceb2f10d8afa2962c44bc3ac9c2bbe1f506cf1b043498843d421", + "size": 2544843, + "subdir": "linux-64", + "timestamp": 1522722955416, + "version": "15.2.0" + }, + "virtualenv-16.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "343f8ad8bb1addaf2a123c9a4751362b", + "name": "virtualenv", + "sha256": "b2a2d55b7f73e7c98534e935db3754345b37144b865409a896b866f3eefeead1", + "size": 1900826, + "subdir": "linux-64", + "timestamp": 1526918799447, + "version": "16.0.0" + }, + "virtualenv-16.0.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "0a8e0591bf37eab2b17ed0a1b9038b86", + "name": "virtualenv", + "sha256": "b669b744a96e9b4a396781854f0cca6d0e1600757cc9d8e6abbdcab66fd82f0e", + "size": 1902144, + "subdir": "linux-64", + "timestamp": 1526918819763, + "version": "16.0.0" + }, + "virtualenv-16.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0f8657befe94b9eb1a4f51168fe0e514", + "name": "virtualenv", + "sha256": "89c8f35867c1ae3a001d610a852d6ee864067cef5e4ba5aeb22018def4722294", + "size": 1902077, + "subdir": "linux-64", + "timestamp": 1526918762444, + "version": "16.0.0" + }, + "virtualenv-16.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "11d5a72604eb8c60855e512ecc96c590", + "name": "virtualenv", + "sha256": "37b2993fa8e64ef722e2ded757a9586331d742970cf71797e1e33d511a16e2e1", + "size": 1902085, + "subdir": "linux-64", + "timestamp": 1531060692110, + "version": "16.0.0" + }, + "virtualenv-16.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "76b3cc1439291f6bef97cae2f70f0efe", + "name": "virtualenv", + "sha256": "853d2aa41d4f3d91c9cab531295b6c5d4f19a1193e75c4f38ef5f5c6db334dcb", + "size": 1907162, + "subdir": "linux-64", + "timestamp": 1573200350148, + "version": "16.0.0" + }, + "virtualenv-20.0.20-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<2", + "importlib_resources >=1.0,<2", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "9992bfd52811eb93e8283abd1420f24e", + "name": "virtualenv", + "sha256": "021a0323743541eb23129c75611bd6e81bfb73a9d3d06cabef76dd472ef672d5", + "size": 4399495, + "subdir": "linux-64", + "timestamp": 1600783082694, + "version": "20.0.20" + }, + "virtualenv-20.0.20-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<2", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "f3321664c8cf6d17f5110cc073547575", + "name": "virtualenv", + "sha256": "2b2e18561c840041e988b3c7bc12ea20d41e08d83619a655a9766d743f531f7b", + "size": 4202797, + "subdir": "linux-64", + "timestamp": 1600783109599, + "version": "20.0.20" + }, + "virtualenv-20.0.20-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "7d34d8824898eece0af1a15942f42729", + "name": "virtualenv", + "sha256": "cb95f7c1ea83c7c8cfb103350928fff4eb7a87a1700515c562aa3fbf844c32b0", + "size": 4401649, + "subdir": "linux-64", + "timestamp": 1600782946244, + "version": "20.0.20" + }, + "virtualenv-20.0.33-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "5ce476a23c394b8cfb6039ba98924965", + "name": "virtualenv", + "sha256": "63d1d225e4b424c8a529da259ac4293fada86fe57ce741a5ad8ca5810643c93a", + "size": 4574998, + "subdir": "linux-64", + "timestamp": 1602266758825, + "version": "20.0.33" + }, + "virtualenv-20.0.33-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "b6c19eaf513f9568318ef187200a68df", + "name": "virtualenv", + "sha256": "c0b7c4516833e7d90adde0971f51f8234e6a15f43ce9b860e815a9ff8421732d", + "size": 4576748, + "subdir": "linux-64", + "timestamp": 1602266764324, + "version": "20.0.33" + }, + "virtualenv-20.0.33-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "a1d52eb023559aca604569a9aae9055e", + "name": "virtualenv", + "sha256": "7ead6fea0deb2c8990bcd6e2ea728415959e6562cbf5d2927607baea3cbc00a1", + "size": 4555649, + "subdir": "linux-64", + "timestamp": 1602266769189, + "version": "20.0.33" + }, + "virtualenv-20.0.34-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "20974eb0cf3bf365424b0a891746e0fc", + "name": "virtualenv", + "sha256": "16bffdbc9e2cdb638f70ee19ef72c82019429681fac9d9d2b9e372146d9d650b", + "size": 4643759, + "subdir": "linux-64", + "timestamp": 1602527460641, + "version": "20.0.34" + }, + "virtualenv-20.0.34-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "71a259ba2bebefe34659c9aa194dd70b", + "name": "virtualenv", + "sha256": "04f99917740f098d986e1e212e061b8ffca3ce28c844c4c20c45682a5293b225", + "size": 4572854, + "subdir": "linux-64", + "timestamp": 1602527433598, + "version": "20.0.34" + }, + "virtualenv-20.0.34-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "799bf7550d17df17f8b19352d63c02bb", + "name": "virtualenv", + "sha256": "99db31b01961728ef93218f7bac3990b79ff96d63ae8d7972c547063213067d5", + "size": 4651058, + "subdir": "linux-64", + "timestamp": 1602527468564, + "version": "20.0.34" + }, + "virtualenv-20.0.35-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "40011ef234045ff6a19d0f58cfcbdc22", + "name": "virtualenv", + "sha256": "78855611f98b8ea9bcdba4c264ba9855e269dc1e0d93ede2366d059448b82600", + "size": 4668723, + "subdir": "linux-64", + "timestamp": 1602787754881, + "version": "20.0.35" + }, + "virtualenv-20.0.35-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "e26ec4f3e6c39d9e04129eb3fa7156fc", + "name": "virtualenv", + "sha256": "b8fef4369535509f04f8e97af3059f7f9483fe28fbc2887cae6ce15b7b15f843", + "size": 4666102, + "subdir": "linux-64", + "timestamp": 1602787743393, + "version": "20.0.35" + }, + "virtualenv-20.0.35-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "ef4867cb9982d33ef98da103f43044c4", + "name": "virtualenv", + "sha256": "56d7bdaaab59e3a0e70bfce657e998dbb883bf988b44203a70c3a19dacd3ef76", + "size": 4551786, + "subdir": "linux-64", + "timestamp": 1602787749345, + "version": "20.0.35" + }, + "virtualenv-20.16.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.1,<1", + "filelock >=3.2,<4", + "platformdirs >=2,<3", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3e3049261152c7f7042e84d2bd2e3f7", + "name": "virtualenv", + "sha256": "cdec3ac0fca71a2173414fc4466a6732217505b09ff5fbf9c347675334ff9ae0", + "size": 8614870, + "subdir": "linux-64", + "timestamp": 1663253747788, + "version": "20.16.2" + }, + "virtualenv-20.16.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.1,<1", + "filelock >=3.2,<4", + "platformdirs >=2,<3", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02346bc04b78a09423fd1be429aba80b", + "name": "virtualenv", + "sha256": "a2e6d25f4f898d275ae0bff6b5790275601a48f9beeca782a1c0833e84eabfcf", + "size": 8728307, + "subdir": "linux-64", + "timestamp": 1676823249607, + "version": "20.16.2" + }, + "virtualenv-20.16.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.1,<1", + "filelock >=3.2,<4", + "importlib-metadata >=0.12", + "platformdirs >=2,<3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e01bfa2e3d153bc1b4d3cdfff1f78fe7", + "name": "virtualenv", + "sha256": "31d8812967846a1003dbc3aa9d245851d45a2e9c93dc8a054a4a1280b6c38410", + "size": 8616012, + "subdir": "linux-64", + "timestamp": 1663253699836, + "version": "20.16.2" + }, + "virtualenv-20.16.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.1,<1", + "filelock >=3.2,<4", + "platformdirs >=2,<3", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f0c4414134428d966c114e786db6aa5", + "name": "virtualenv", + "sha256": "366cfa89a361ccd53b208c1b44eb76947865e15238ebf9da20d927ecc98b7366", + "size": 8612214, + "subdir": "linux-64", + "timestamp": 1663253782455, + "version": "20.16.2" + }, + "virtualenv-20.16.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.1,<1", + "filelock >=3.2,<4", + "platformdirs >=2,<3", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd0bbbd9a6cfd8b91dc4952a8d8c7184", + "name": "virtualenv", + "sha256": "a7d25e145abf71d36047f2a6ff337eaeb878684efc96fb3837fd525560a78475", + "size": 8613065, + "subdir": "linux-64", + "timestamp": 1663253664367, + "version": "20.16.2" + }, + "virtualenv-20.17.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.6,<1", + "filelock >=3.4.1,<4", + "platformdirs >=2.4,<3", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa1a60a3fb8b432f104e544e596a8d62", + "name": "virtualenv", + "sha256": "9be3b098a3178e6567140201a536110f16131a933b9950415f3562d78feca18a", + "size": 8629713, + "subdir": "linux-64", + "timestamp": 1674752134817, + "version": "20.17.1" + }, + "virtualenv-20.17.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.6,<1", + "filelock >=3.4.1,<4", + "platformdirs >=2.4,<3", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2f5788ab19f4fb7f3286062fd6b15db", + "name": "virtualenv", + "sha256": "3806897062ce1c980ab877e5ef94bf677204416a8c97ddf4ba5f2035b9e35868", + "size": 8640875, + "subdir": "linux-64", + "timestamp": 1679038293316, + "version": "20.17.1" + }, + "virtualenv-20.17.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.6,<1", + "filelock >=3.4.1,<4", + "importlib-metadata >=4.8.3", + "platformdirs >=2.4,<3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6bdac6e1abb4afaf2a68b3b01ee5d0ad", + "name": "virtualenv", + "sha256": "d38fdacdd05437f7c9130aebae06604fd01c960094dd56ffb8eb5e5c6f0168aa", + "size": 8637489, + "subdir": "linux-64", + "timestamp": 1674752169888, + "version": "20.17.1" + }, + "virtualenv-20.17.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.6,<1", + "filelock >=3.4.1,<4", + "platformdirs >=2.4,<3", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "492f7dc86982f85a23d6dc09f9fdbb3e", + "name": "virtualenv", + "sha256": "8f0168bf5554820bc1825485c8ea2035014e75fde08106bfc5b85cc2a0535024", + "size": 8637882, + "subdir": "linux-64", + "timestamp": 1674752204319, + "version": "20.17.1" + }, + "virtualenv-20.17.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.6,<1", + "filelock >=3.4.1,<4", + "platformdirs >=2.4,<3", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2648271129ed068beecfefd80b07b8b4", + "name": "virtualenv", + "sha256": "505fd4fc8304fe2a1910c45c3fb87d6633b2521471e0e31ba092ae4185140fad", + "size": 8638037, + "subdir": "linux-64", + "timestamp": 1674752238694, + "version": "20.17.1" + }, + "virtualenv-20.2.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "7404babc72de0d3feace3dac20dceb54", + "name": "virtualenv", + "sha256": "69c99d4ede3d55fdadbb08f7572217197e9828adb59941e0b6316cd143f4acc8", + "size": 4576147, + "subdir": "linux-64", + "timestamp": 1606938853006, + "version": "20.2.1" + }, + "virtualenv-20.2.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "c6b8693e2c05e54c65c4979f0bea2127", + "name": "virtualenv", + "sha256": "ff850211e9fbbb45b7532c997a786aa481c4627306688ebb8894560d3819bceb", + "size": 4669274, + "subdir": "linux-64", + "timestamp": 1606938867670, + "version": "20.2.1" + }, + "virtualenv-20.2.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "cf314b7e8d79a775bbb07f1d644da0d8", + "name": "virtualenv", + "sha256": "acfa61af27656e29a815e211c8bb701ef8b2e3acb06b5579245810d5b61b01ef", + "size": 4553006, + "subdir": "linux-64", + "timestamp": 1606938849434, + "version": "20.2.1" + }, + "virtualenv-20.2.2-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "a3f71d5514ae1cbf9d83734d39c2706d", + "name": "virtualenv", + "sha256": "06aa038cad894a5fac830c2574ab2f53d17ea901e36ac0621576aaae06bd9863", + "size": 5289997, + "subdir": "linux-64", + "timestamp": 1607370089408, + "version": "20.2.2" + }, + "virtualenv-20.2.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "9673af182f4d924968fbaef6e7356563", + "name": "virtualenv", + "sha256": "3bc4d36f0037fcf2ab7e693b5af8b9fe2b38a091ea596d665827ff9ee2d7dcc4", + "size": 5196860, + "subdir": "linux-64", + "timestamp": 1607370112132, + "version": "20.2.2" + }, + "virtualenv-20.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "dcf89f0d2b953ef60761da604100d6a6", + "name": "virtualenv", + "sha256": "fdd2fe2ddf0e8cf9956b9d7f172fecbd559c964496f3751f7362e4291fc8ee06", + "size": 5195676, + "subdir": "linux-64", + "timestamp": 1607370090472, + "version": "20.2.2" + }, + "virtualenv-20.3.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "901fa35067acd1f28c7fc34f0e754ed4", + "name": "virtualenv", + "sha256": "2554a37ccd24502092f8e2cf88df8a1b69ed958a9b24e0e01512a0bef338b4ab", + "size": 5282231, + "subdir": "linux-64", + "timestamp": 1610393195888, + "version": "20.3.0" + }, + "virtualenv-20.3.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "e6c9fb3f189817047fb2b3057913896c", + "name": "virtualenv", + "sha256": "76293109718000203fe4a22ca0193f18a2e0acffdcfa6c82a8a1d9b2c1afea6d", + "size": 5266511, + "subdir": "linux-64", + "timestamp": 1610484688721, + "version": "20.3.0" + }, + "virtualenv-20.3.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "d074f9a1a10de3d7f03082e3ededc340", + "name": "virtualenv", + "sha256": "30777eb4fcecf2ae644effb40b964d12615e7771a9a0c7a2e5423b1628a3a675", + "size": 5199229, + "subdir": "linux-64", + "timestamp": 1610392792275, + "version": "20.3.0" + }, + "virtualenv-20.3.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "26169c5e327141b4b45d073c9cb13b16", + "name": "virtualenv", + "sha256": "a678f7b21e372db704ae9d6e67831d6fc52ee51d5477455f37d62c33171f6cb5", + "size": 5203903, + "subdir": "linux-64", + "timestamp": 1610484197814, + "version": "20.3.0" + }, + "virtualenv-20.3.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "18eff14a49241993d16bba13db0c2892", + "name": "virtualenv", + "sha256": "184ae816947fb9f3c0dd8edf5253ad78258ee169126ef31afdf18db21c34e6d9", + "size": 5198110, + "subdir": "linux-64", + "timestamp": 1610393239472, + "version": "20.3.0" + }, + "virtualenv-20.3.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "891a1321a673d68d1fa2d0cddc90f593", + "name": "virtualenv", + "sha256": "18f712d06216da49ea540ab98951f26f8e3e8c80a37d20ba30604a9047f339f4", + "size": 5300118, + "subdir": "linux-64", + "timestamp": 1610484673734, + "version": "20.3.0" + }, + "virtualenv-20.3.1-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "4919599a515174744f9b030934a278e0", + "name": "virtualenv", + "sha256": "0ed6d17d1590d77276a2237793210d107ea82bf2423ebe392331ea71ad70b366", + "size": 5201700, + "subdir": "linux-64", + "timestamp": 1610566130415, + "version": "20.3.1" + }, + "virtualenv-20.3.1-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "d903f3762bdd3f70c3d1d640d8e804d9", + "name": "virtualenv", + "sha256": "9442f60417b6df4f70ee5d8eed1a342f68c22eb3fd908e1a71c6cd3f6e131f28", + "size": 5285638, + "subdir": "linux-64", + "timestamp": 1610566134309, + "version": "20.3.1" + }, + "virtualenv-20.3.1-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "3174e36a58a136edf4c5ee597ca3368e", + "name": "virtualenv", + "sha256": "4c083563b2aec86f11d92b2ebef16c57c16ca0adf4168ced1259e068916a0bfe", + "size": 5250128, + "subdir": "linux-64", + "timestamp": 1610566642157, + "version": "20.3.1" + }, + "virtualenv-20.4.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "929419844965cd16403b442ad2d5c345", + "name": "virtualenv", + "sha256": "3f55b76dc6ecaf054ae88a068e40411148decbc654a55743d114eecd34cd7280", + "size": 6776402, + "subdir": "linux-64", + "timestamp": 1612471166542, + "version": "20.4.2" + }, + "virtualenv-20.4.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "0f795b2ba53181a6ab67c8ccb31ad688", + "name": "virtualenv", + "sha256": "d5031698ebf61b0a08c96de6906586c89cdfd787b6b8375198fb08ed394ca0d6", + "size": 6806895, + "subdir": "linux-64", + "timestamp": 1612470471159, + "version": "20.4.2" + }, + "virtualenv-20.4.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "612225b677783532ed222e4ac3606f95", + "name": "virtualenv", + "sha256": "a6b287510eee03a22db772aaa78a2747321e3ee33c2a3f925be8d306b920489a", + "size": 6700490, + "subdir": "linux-64", + "timestamp": 1612471152542, + "version": "20.4.2" + }, + "virtualenv-20.4.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.9,<3.10.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "6918016384b0af0aa5534bdbfd57943d", + "name": "virtualenv", + "sha256": "a74d22666b210f6942dcd5afcb658c9a9a731adbf009c2d6794d175fe6356a9b", + "size": 6701655, + "subdir": "linux-64", + "timestamp": 1613233973739, + "version": "20.4.2" + }, + "virtualenv-20.4.3-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "f6726c97c19944592b4f46a7fb2a130e", + "name": "virtualenv", + "sha256": "dc8ee9b244485f8bca9bee9e2d65a76210a2e43f030f2f06ad7ca3820aa9255d", + "size": 6777026, + "subdir": "linux-64", + "timestamp": 1615923547866, + "version": "20.4.3" + }, + "virtualenv-20.4.3-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "3f8b0ea1d68b7033c2fcb519b063d2ae", + "name": "virtualenv", + "sha256": "f67618fbfcdb640b2c3490a0961bca287b54cfdd372428fbd1ad75c2fa1f05fa", + "size": 6701248, + "subdir": "linux-64", + "timestamp": 1615923648635, + "version": "20.4.3" + }, + "virtualenv-20.4.3-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "b2f0cf6eb8df49d3ba9945fdce85b5fa", + "name": "virtualenv", + "sha256": "e59b144f66d17fee0f731e053205eae9ce0a61d124089dff52726cf0545493b0", + "size": 6777160, + "subdir": "linux-64", + "timestamp": 1615923660506, + "version": "20.4.3" + }, + "virtualenv-20.4.3-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.9,<3.10.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "ea97156788c3186fe17eb9d131362b12", + "name": "virtualenv", + "sha256": "fe41e8831a308293b562193c7b6e724595fb777d0a95b2e938fa0825237204e7", + "size": 6813416, + "subdir": "linux-64", + "timestamp": 1615921791128, + "version": "20.4.3" + }, + "virtualenv-20.4.4-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "b4029f6867b8d219e5b879de3e6ad5f0", + "name": "virtualenv", + "sha256": "6615b5395ebf7eef1a1c821cc4b0969162f04f6d2184a0b743cfc21ab5ade4e7", + "size": 6699926, + "subdir": "linux-64", + "timestamp": 1619391850528, + "version": "20.4.4" + }, + "virtualenv-20.4.4-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "a5eedef593508f45de39d9e4563b2bb6", + "name": "virtualenv", + "sha256": "d9d6a9317d9b308b39b0e4f888ea150f23ef79962db9380e6fbb09d306e6a758", + "size": 6698172, + "subdir": "linux-64", + "timestamp": 1619392231022, + "version": "20.4.4" + }, + "virtualenv-20.4.4-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "fa1b93c94618c2fc89e4bcee549fc2e6", + "name": "virtualenv", + "sha256": "44fcaec3c1792c01e5d09d77028d6078cdcd6158efc8ab5e86b8c6bbb64e5c88", + "size": 6702234, + "subdir": "linux-64", + "timestamp": 1619392243401, + "version": "20.4.4" + }, + "virtualenv-20.4.4-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.9,<3.10.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "36d8f438bc24f27aba638659251b4336", + "name": "virtualenv", + "sha256": "39a7a9c2a5d71b95e0c17530707466ae976825a02dd6155d0e5a2f94ba05941c", + "size": 6810169, + "subdir": "linux-64", + "timestamp": 1619392237225, + "version": "20.4.4" + }, + "virtualenv-20.4.6-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.1,<1", + "filelock >=3.0.0,<4", + "python >=3.10,<3.11.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "463c06563ab5a986ae8e4f7c49af6ef1", + "name": "virtualenv", + "sha256": "7672e247c101c078ec75e53e43cb956cb80003c00fb2259d1b983338f39700c9", + "size": 6707423, + "subdir": "linux-64", + "timestamp": 1640877488844, + "version": "20.4.6" + }, + "virtualenv-20.4.6-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.1,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "35897bab91dd7b8548646fb67ae340e9", + "name": "virtualenv", + "sha256": "ab5d345f1fc143e606a402d3ac8c3577ccee50682d584b9451ceac899056ac2c", + "size": 6708227, + "subdir": "linux-64", + "timestamp": 1620973316876, + "version": "20.4.6" + }, + "virtualenv-20.4.6-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.1,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "a44c62815ebaf43ecdd1bdd205262bfe", + "name": "virtualenv", + "sha256": "a918e5a34dbb234041b474426a2acb45a1fba2f21a6459b8c4e510e00f3c8391", + "size": 6783414, + "subdir": "linux-64", + "timestamp": 1620977719730, + "version": "20.4.6" + }, + "virtualenv-20.4.6-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.1,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "d714f5596e73b4ebbab52770356dc370", + "name": "virtualenv", + "sha256": "ffaa75e9dcd05600af7ac8ebde21b9a579188254857b559acd2c5c04bbb0dee4", + "size": 6817057, + "subdir": "linux-64", + "timestamp": 1620977392511, + "version": "20.4.6" + }, + "virtualenv-20.4.6-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.1,<1", + "filelock >=3.0.0,<4", + "python >=3.9,<3.10.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "f4a95e9b356538eb523bfb99a1bfacbf", + "name": "virtualenv", + "sha256": "a5df006f9c655657b8e772dc0e1a8c9137e463da1f670b2923596eebb3481786", + "size": 6706861, + "subdir": "linux-64", + "timestamp": 1620977720065, + "version": "20.4.6" + }, + "virtualenv-clone-0.5.7-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba72f0e28e51ba2b9cc9321f77af3c80", + "name": "virtualenv-clone", + "sha256": "8d4b123e6841f51cd2db16861c71404acc1008fc87f50cde9cec3f14e4f2e5a3", + "size": 15231, + "subdir": "linux-64", + "timestamp": 1657896162813, + "version": "0.5.7" + }, + "virtualenv-clone-0.5.7-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f91d5b877daa090ce2b4a951cbc12fd1", + "name": "virtualenv-clone", + "sha256": "e7de923f4d03a08e17201f0547dce1c7543ea90c2ac7221c312e5ecdb5aecd95", + "size": 18578, + "subdir": "linux-64", + "timestamp": 1676843036981, + "version": "0.5.7" + }, + "virtualenv-clone-0.5.7-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "329f58275c218701205a4f22a2feb36f", + "name": "virtualenv-clone", + "sha256": "747b8e7aeae2ed2ea56c04eb5413d26e3c8cf91ecadd94ccbc3e5fd0d6406bf1", + "size": 15131, + "subdir": "linux-64", + "timestamp": 1657896097881, + "version": "0.5.7" + }, + "virtualenv-clone-0.5.7-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85437ad778846fbbbbf9c6982da99533", + "name": "virtualenv-clone", + "sha256": "77aae20b7f30897f45252c69171703244d7059c53572e7b0d67bf5a86a3d2139", + "size": 15153, + "subdir": "linux-64", + "timestamp": 1657896124020, + "version": "0.5.7" + }, + "virtualenv-clone-0.5.7-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "78a87765134c01187b02b8576238cfed", + "name": "virtualenv-clone", + "sha256": "731aacc185251e391321900f3310a21e0c06c9784748c896e7e711cebea8d272", + "size": 15177, + "subdir": "linux-64", + "timestamp": 1657896190678, + "version": "0.5.7" + }, + "visions-0.7.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.3.0", + "multimethod >=1.4", + "networkx >=2.4", + "numpy", + "pandas >=0.25.3", + "python >=3.10,<3.11.0a0", + "tangled-up-in-unicode >=0.0.4" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "bf437aeadfd8cc79ee1f9b12e855d6b9", + "name": "visions", + "sha256": "0653b139c88bdd8240a38459141f9b094b95ae4a89dac1bdaaf5074e2bc4b75e", + "size": 117881, + "subdir": "linux-64", + "timestamp": 1668114460783, + "version": "0.7.5" + }, + "visions-0.7.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.3.0", + "multimethod >=1.4", + "networkx >=2.4", + "numpy", + "pandas >=0.25.3", + "python >=3.11,<3.12.0a0", + "tangled-up-in-unicode >=0.0.4" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "bad63eac759960c6c684c3cea02ddda6", + "name": "visions", + "sha256": "66302fda546d19a781d59c255d4329330b616d7ad24b8518a701852ad0a9bb24", + "size": 151249, + "subdir": "linux-64", + "timestamp": 1676846159540, + "version": "0.7.5" + }, + "visions-0.7.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.3.0", + "multimethod >=1.4", + "networkx >=2.4", + "numpy", + "pandas >=0.25.3", + "python >=3.7,<3.8.0a0", + "tangled-up-in-unicode >=0.0.4" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "3eb95d2c7a9b5f2f2f858e9d47c62a04", + "name": "visions", + "sha256": "6ce590d780e305e2d81465e1caebc147c3d1668c902796b19b477c227e7f1b9e", + "size": 115171, + "subdir": "linux-64", + "timestamp": 1668114420351, + "version": "0.7.5" + }, + "visions-0.7.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.3.0", + "multimethod >=1.4", + "networkx >=2.4", + "numpy", + "pandas >=0.25.3", + "python >=3.8,<3.9.0a0", + "tangled-up-in-unicode >=0.0.4" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "5771e7f49e10691df2a0f58f14a2d59e", + "name": "visions", + "sha256": "7bd8fb5c0c93a3c8d4d8c6907d96cb19bbce6a234ddd893dd30b80af3ddde678", + "size": 116023, + "subdir": "linux-64", + "timestamp": 1668114504335, + "version": "0.7.5" + }, + "visions-0.7.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.3.0", + "multimethod >=1.4", + "networkx >=2.4", + "numpy", + "pandas >=0.25.3", + "python >=3.9,<3.10.0a0", + "tangled-up-in-unicode >=0.0.4" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "cae058723c2affc16ed5209383b162b4", + "name": "visions", + "sha256": "b4a2bcdfb38a38479e952be3b66ac88b17cef0538cde851a4c7ce2c76b4a4f94", + "size": 116123, + "subdir": "linux-64", + "timestamp": 1668114376811, + "version": "0.7.5" + }, + "vispy-0.12.1-py310h243fa6c_0.tar.bz2": { + "build": "py310h243fa6c_0", + "build_number": 0, + "depends": [ + "fontconfig", + "freetype-py", + "hsluv", + "kiwisolver", + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5920425951e1bcaa40638df11f0af39d", + "name": "vispy", + "sha256": "df4fe633a0286ef83de0a7a3f2ba645ce98b8d81e02956aa42250b8dc4a4fe62", + "size": 1669938, + "subdir": "linux-64", + "timestamp": 1669140834071, + "version": "0.12.1" + }, + "vispy-0.12.1-py311hd892b02_0.tar.bz2": { + "build": "py311hd892b02_0", + "build_number": 0, + "depends": [ + "fontconfig", + "freetype-py", + "hsluv", + "kiwisolver", + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "packaging", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7d6204517d8c5420e9756cf61cd74d8d", + "name": "vispy", + "sha256": "0855e02c5149136390765bcdcb1c2cb35e2150d98d8e4bc35e123a154a722c11", + "size": 1992115, + "subdir": "linux-64", + "timestamp": 1676846186706, + "version": "0.12.1" + }, + "vispy-0.12.1-py37h4a1f111_0.tar.bz2": { + "build": "py37h4a1f111_0", + "build_number": 0, + "depends": [ + "fontconfig", + "freetype-py", + "hsluv", + "kiwisolver", + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "45d012020433f64b071fff0d79d512d0", + "name": "vispy", + "sha256": "20820314e0521a916ac069a896bf567342c81a229558cf7db667c2405052d1bb", + "size": 1647079, + "subdir": "linux-64", + "timestamp": 1669140935079, + "version": "0.12.1" + }, + "vispy-0.12.1-py38h4a1f111_0.tar.bz2": { + "build": "py38h4a1f111_0", + "build_number": 0, + "depends": [ + "fontconfig", + "freetype-py", + "hsluv", + "kiwisolver", + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b6e1af549536c1f65faa7df265f60b7e", + "name": "vispy", + "sha256": "dd6895fec6fdfedf7029156100ca018066839a27abd2911a64f75bd821f55076", + "size": 1660028, + "subdir": "linux-64", + "timestamp": 1669140786452, + "version": "0.12.1" + }, + "vispy-0.12.1-py39h4a1f111_0.tar.bz2": { + "build": "py39h4a1f111_0", + "build_number": 0, + "depends": [ + "fontconfig", + "freetype-py", + "hsluv", + "kiwisolver", + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8ad12e6c70ec352120ffc5418b26bcb8", + "name": "vispy", + "sha256": "34cdb8276b6cf6524487c670a8d3fc42a004d97f6f07dc28ef8db056c9b5c4e2", + "size": 1657935, + "subdir": "linux-64", + "timestamp": 1669140882115, + "version": "0.12.1" + }, + "vispy-0.5.2-py27hf951d6b_0.tar.bz2": { + "build": "py27hf951d6b_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.6,<3.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5c2be41bf426d5a0415b5fd641d4b810", + "name": "vispy", + "sha256": "7b07d2bfbf45303a78e885b7b957221bfd892d3513e7d046131341c6bfe9671b", + "size": 1199119, + "subdir": "linux-64", + "timestamp": 1521005238282, + "version": "0.5.2" + }, + "vispy-0.5.2-py35hf951d6b_0.tar.bz2": { + "build": "py35hf951d6b_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.6,<3.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "81cb1e6eade8b5fd75aa017a7f9d3d07", + "name": "vispy", + "sha256": "efb6c90cf62286bf9d2c77910957ab80cd3afd66e9849af9b6b2578cd2424ad8", + "size": 1220864, + "subdir": "linux-64", + "timestamp": 1521005192991, + "version": "0.5.2" + }, + "vispy-0.5.2-py36hf951d6b_0.tar.bz2": { + "build": "py36hf951d6b_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.6,<3.0a0", + "numpy >=1.14.2,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9a29d305d3c646b1f3d36ac02caa5062", + "name": "vispy", + "sha256": "d0b262acbe1304e4907e142622579f7b81253b941865b73445eac63c7bdc7123", + "size": 1225861, + "subdir": "linux-64", + "timestamp": 1521005246334, + "version": "0.5.2" + }, + "vispy-0.5.3-py27hee6b756_0.tar.bz2": { + "build": "py27hee6b756_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.13.0,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5ab3ea0a8122d9320a4eb200707e56df", + "name": "vispy", + "sha256": "1135765a20a58edbedf085906a9b391a38fdf2f0e8e4422ee5eeae59bf9eda55", + "size": 1200730, + "subdir": "linux-64", + "timestamp": 1531060882346, + "version": "0.5.3" + }, + "vispy-0.5.3-py27hf951d6b_0.tar.bz2": { + "build": "py27hf951d6b_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.6,<3.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0735f4f83edca9d0823978e57e151930", + "name": "vispy", + "sha256": "597dd4d82d67d822065ebb5f3db4a6943d124e5877cb60adaf00d3c257a765b1", + "size": 1199150, + "subdir": "linux-64", + "timestamp": 1522723758867, + "version": "0.5.3" + }, + "vispy-0.5.3-py35hf951d6b_0.tar.bz2": { + "build": "py35hf951d6b_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.6,<3.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f6bef899b58df27a912b3db1e6c63cde", + "name": "vispy", + "sha256": "0f12c4aaa076057c7d718feb91d89ad5f110e506d3a0d9ab9eee0007f579914c", + "size": 1222334, + "subdir": "linux-64", + "timestamp": 1522724168754, + "version": "0.5.3" + }, + "vispy-0.5.3-py36hee6b756_0.tar.bz2": { + "build": "py36hee6b756_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.13.0,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eeb4cb44e158e5fd89bd54fe4e8e3e41", + "name": "vispy", + "sha256": "12a7912afd73bb05465b1128df28dbae0adb763360c1b29a70f4afb93fed4326", + "size": 1222886, + "subdir": "linux-64", + "timestamp": 1531060758728, + "version": "0.5.3" + }, + "vispy-0.5.3-py36hf951d6b_0.tar.bz2": { + "build": "py36hf951d6b_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.6,<3.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fed553ae5a6d020995c48fb31776478a", + "name": "vispy", + "sha256": "b8a8d5faf4e02c05e807637aa10f08411dfdbb201bd3132484d09e6ed96ebc2f", + "size": 1225405, + "subdir": "linux-64", + "timestamp": 1522717313337, + "version": "0.5.3" + }, + "vispy-0.5.3-py37hee6b756_0.tar.bz2": { + "build": "py37hee6b756_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.13.0,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c36bcdf6e926765e30294b3e23b059c2", + "name": "vispy", + "sha256": "8d2e580fcae549a1097cd6563004ef8ec43bd0d516d6a63b4f58aecac8bcaf23", + "size": 1221680, + "subdir": "linux-64", + "timestamp": 1531060824802, + "version": "0.5.3" + }, + "vispy-0.5.3-py38hee6b756_0.tar.bz2": { + "build": "py38hee6b756_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.13.0,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "280b44a8c5dc7a6e4f77536b03db32a8", + "name": "vispy", + "sha256": "643ddc0c61602aba24d9d2b723e37878b93ceb82c9930e3a6630124c2fb567fd", + "size": 1236823, + "subdir": "linux-64", + "timestamp": 1574077595477, + "version": "0.5.3" + }, + "vispy-0.7.3-py310h213f4d1_0.tar.bz2": { + "build": "py310h213f4d1_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.13.1,<3.0a0", + "freetype-py", + "hsluv", + "kiwisolver", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "047c95191622eabc67db5fe5d2dc4284", + "name": "vispy", + "sha256": "56df161241121427b530aadedaea7efc6333bffc79c890a95f81ee875e87aa8c", + "size": 2404820, + "subdir": "linux-64", + "timestamp": 1640795818523, + "version": "0.7.3" + }, + "visvis-1.10.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6a5814c8830159fd1e902f5c44a9ad0f", + "name": "visvis", + "sha256": "aa4c794e0d51f2ba4e097f7a648c17d3d58e68f184e40af83cdda54a4acf0a35", + "size": 5130529, + "subdir": "linux-64", + "timestamp": 1522779458596, + "version": "1.10.0" + }, + "visvis-1.10.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "22a104860d12bcf3937009b549b0e69f", + "name": "visvis", + "sha256": "bdccd75db0de045006de88e24bfd5cef1a05966eafb252b56b683816611fe804", + "size": 5124292, + "subdir": "linux-64", + "timestamp": 1522779680452, + "version": "1.10.0" + }, + "visvis-1.10.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a6f454ed3d0dbd086aed5c1879dd26b3", + "name": "visvis", + "sha256": "ed8de3e29e433a9ac2c77980f5c57b9c63d5dc5e6d52fb64aca3b80dd4381ba5", + "size": 5125577, + "subdir": "linux-64", + "timestamp": 1522779690914, + "version": "1.10.0" + }, + "visvis-1.11.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7a1caae7644e414de9e6fad370fbde32", + "name": "visvis", + "sha256": "6290694a62de4db735103f25ee67032d0cbfcec02701d459cad74b2ceec836cb", + "size": 5136364, + "subdir": "linux-64", + "timestamp": 1524511001539, + "version": "1.11.1" + }, + "visvis-1.11.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "180d007d42352dfd6580746a8279678e", + "name": "visvis", + "sha256": "8fb07edfb8c863aa354ec56861f95005a908421464c84fe1bcbf876b8cbb8c24", + "size": 5135089, + "subdir": "linux-64", + "timestamp": 1524510867872, + "version": "1.11.1" + }, + "visvis-1.11.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a21f67c17a618ba14311300523dcfd8d", + "name": "visvis", + "sha256": "3185a625b0eb28f7e2554cb81ecbb7cbe57ca8c7ccaf73a801b5ae326fa6e60d", + "size": 5127293, + "subdir": "linux-64", + "timestamp": 1524511014061, + "version": "1.11.1" + }, + "visvis-1.11.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ec0eef8d4651d7780e16721aab6f7283", + "name": "visvis", + "sha256": "5e6367f5c2d7c4f3fb1ced4979b9aceb1e3ca7d435eb4e4d72c742cada21fa33", + "size": 5135147, + "subdir": "linux-64", + "timestamp": 1531060936273, + "version": "1.11.1" + }, + "visvis-1.11.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7a2d000e623825af23c6ed196371b720", + "name": "visvis", + "sha256": "b0f1ad77ab7f83f5f06bd56b9ae095faf82c6225a7242cdf2b08eef9cc6e1dd1", + "size": 5173046, + "subdir": "linux-64", + "timestamp": 1556078470118, + "version": "1.11.2" + }, + "visvis-1.11.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "66b44f19cfe56a0bd2adeaf75da46376", + "name": "visvis", + "sha256": "ee0eb42729a84b1dba8872a2e2ae222071b51d9ec0e96dab56ddc3c14ae22036", + "size": 5174946, + "subdir": "linux-64", + "timestamp": 1556078631395, + "version": "1.11.2" + }, + "visvis-1.11.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "32ddd232e55d24c20ff773a70ec26225", + "name": "visvis", + "sha256": "fbdd5d0e57d351c659cca0ffe816500159cfd297c7fa3a2aa8e85bc8024df343", + "size": 5185871, + "subdir": "linux-64", + "timestamp": 1556078563563, + "version": "1.11.2" + }, + "vtk-8.1.0-py27h9686630_201.tar.bz2": { + "build": "py27h9686630_201", + "build_number": 201, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "future", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.7,<2.10.0a0", + "python >=2.7,<2.8.0a0", + "tbb", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d7dbd4020683d2249267533b6073b1b6", + "name": "vtk", + "sha256": "08cfbda4cd9d695fd2967bfd0c41f01413f41065e1349dfa602be8ef462f3cef", + "size": 36696802, + "subdir": "linux-64", + "timestamp": 1521238014007, + "version": "8.1.0" + }, + "vtk-8.1.0-py27h969b564_201.tar.bz2": { + "build": "py27h969b564_201", + "build_number": 201, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "future", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.7,<2.10.0a0", + "python >=2.7,<2.8.0a0", + "tbb", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7c637c5fa12676024a16236d96e74f06", + "name": "vtk", + "sha256": "3bc1d3177d58a46e00c400b583dc7cf1e4ed6b7e39c94121b87a50f659dc5445", + "size": 36696297, + "subdir": "linux-64", + "timestamp": 1521237887575, + "version": "8.1.0" + }, + "vtk-8.1.0-py35h9686630_201.tar.bz2": { + "build": "py35h9686630_201", + "build_number": 201, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "future", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.7,<2.10.0a0", + "python >=3.5,<3.6.0a0", + "tbb", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "69945a989117b75bf9eb00c69a427597", + "name": "vtk", + "sha256": "582250cad23a101c2eee5ec8e4d9887671c41734f2e721d89776eee333e0e37a", + "size": 36737584, + "subdir": "linux-64", + "timestamp": 1521237945365, + "version": "8.1.0" + }, + "vtk-8.1.0-py35h969b564_201.tar.bz2": { + "build": "py35h969b564_201", + "build_number": 201, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "future", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.7,<2.10.0a0", + "python >=3.5,<3.6.0a0", + "tbb", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "20d7533061bedfa92b16e0ae975e4b35", + "name": "vtk", + "sha256": "beb623645a66ae81f14f9281ffc75a34c2167341848120fd151afa052525fdb5", + "size": 36735668, + "subdir": "linux-64", + "timestamp": 1521238034868, + "version": "8.1.0" + }, + "vtk-8.1.0-py36h9686630_201.tar.bz2": { + "build": "py36h9686630_201", + "build_number": 201, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "future", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.7,<2.10.0a0", + "python >=3.6,<3.7.0a0", + "tbb", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5a68c48359f9d2ca95ab126d99afed46", + "name": "vtk", + "sha256": "99e40615dc069e70212ca2ccd1a6b77cac21600f2713051dea3d09124ae7fc12", + "size": 36730123, + "subdir": "linux-64", + "timestamp": 1521238040701, + "version": "8.1.0" + }, + "vtk-8.1.0-py36h969b564_201.tar.bz2": { + "build": "py36h969b564_201", + "build_number": 201, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "future", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.7,<2.10.0a0", + "python >=3.6,<3.7.0a0", + "tbb", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "27b4b98859f7b2c417c3d1fe48fc88f6", + "name": "vtk", + "sha256": "2856c1e174707f9371eae122e5128717e214877f5cd2fd797b0f272552b42859", + "size": 36728399, + "subdir": "linux-64", + "timestamp": 1521237929035, + "version": "8.1.0" + }, + "vtk-8.1.1-py27h4f1983a_204.tar.bz2": { + "build": "py27h4f1983a_204", + "build_number": 204, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "future", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libogg >=1.3.2,<2.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=2.7,<2.8.0a0", + "tbb >=2019.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cc1b520b2da22591052406acff62d2c3", + "name": "vtk", + "sha256": "dd2e370f82c1977323496f0876c32ac56db57ae4897a3ecab8c3a738a9c94a97", + "size": 36475993, + "subdir": "linux-64", + "timestamp": 1539532919025, + "version": "8.1.1" + }, + "vtk-8.1.1-py27h881b6ac_204.tar.bz2": { + "build": "py27h881b6ac_204", + "build_number": 204, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "future", + "hdf5 >=1.8.20,<1.9.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libogg >=1.3.2,<2.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=2.7,<2.8.0a0", + "tbb >=2019.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "43f8cfb3fd8d6399ed93314996161be9", + "name": "vtk", + "sha256": "cd79f92837b29a050ecab2b94079f6dbc16b98af4ecf332c6269c338645d74cf", + "size": 36473960, + "subdir": "linux-64", + "timestamp": 1539532917117, + "version": "8.1.1" + }, + "vtk-8.1.1-py36h4f1983a_204.tar.bz2": { + "build": "py36h4f1983a_204", + "build_number": 204, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "future", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libogg >=1.3.2,<2.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b67b3ba5f9980da0bb3e9e1aca262581", + "name": "vtk", + "sha256": "da3673284b100edd9486f233eb04db7f006cde1cb4c8a93c280dc44ff1b4ed08", + "size": 36442919, + "subdir": "linux-64", + "timestamp": 1539535345625, + "version": "8.1.1" + }, + "vtk-8.1.1-py36h881b6ac_204.tar.bz2": { + "build": "py36h881b6ac_204", + "build_number": 204, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "future", + "hdf5 >=1.8.20,<1.9.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libogg >=1.3.2,<2.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7cd1a33e8ef112f2088c32f268dd4ed4", + "name": "vtk", + "sha256": "34d405128d8bfb970359d4e28007701ff729b29350a720d49e961279a5a7ade6", + "size": 36420980, + "subdir": "linux-64", + "timestamp": 1539535292782, + "version": "8.1.1" + }, + "vtk-8.2.0-py27haa4764d_200.tar.bz2": { + "build": "py27haa4764d_200", + "build_number": 200, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "future", + "hdf5 >=1.10.4,<1.10.5.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libogg >=1.3.2,<2.0a0", + "libpng >=1.6.36,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.0.10,<5.0a0", + "libxml2 >=2.9.9,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=2.7,<2.8.0a0", + "tbb >=2019.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dcfdfd0f4084f75844574055fba97eff", + "name": "vtk", + "sha256": "2b521886becb144898afa9243a37c2e996ff4a6e707b54c873ae097be7b50025", + "size": 39135116, + "subdir": "linux-64", + "timestamp": 1549816282405, + "version": "8.2.0" + }, + "vtk-8.2.0-py36haa4764d_200.tar.bz2": { + "build": "py36haa4764d_200", + "build_number": 200, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "future", + "hdf5 >=1.10.4,<1.10.5.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libogg >=1.3.2,<2.0a0", + "libpng >=1.6.36,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.0.10,<5.0a0", + "libxml2 >=2.9.9,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "eb230965a36e55a23cc4ca4b568c9d4b", + "name": "vtk", + "sha256": "1df73623d1b1fcb4807bdff51a51b5ac4a236b08ba4c72ae999747772804f237", + "size": 39139590, + "subdir": "linux-64", + "timestamp": 1549814912511, + "version": "8.2.0" + }, + "vtk-8.2.0-py37haa4764d_200.tar.bz2": { + "build": "py37haa4764d_200", + "build_number": 200, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "future", + "hdf5 >=1.10.4,<1.10.5.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libogg >=1.3.2,<2.0a0", + "libpng >=1.6.36,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.0.10,<5.0a0", + "libxml2 >=2.9.9,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "444a8c616d65c45f48f988bdf98bd0dd", + "name": "vtk", + "sha256": "2da9e826fd568b3d0ac1005240ccfab45bc21caaf4d732dac83e1df616228f57", + "size": 39130299, + "subdir": "linux-64", + "timestamp": 1549814925156, + "version": "8.2.0" + }, + "vtk-9.0.3-py311hf89884c_202.tar.bz2": { + "build": "py311hf89884c_202", + "build_number": 202, + "constrains": [ + "paraview ==9999999999" + ], + "depends": [ + "double-conversion", + "eigen", + "expat >=2.4.9,<3.0a0", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "gl2ps >=1.4.2,<1.4.3.0a0", + "glew >=2.2.0,<2.3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "jsoncpp >=1.9.4,<1.9.5.0a0", + "libgcc-ng >=11.2.0", + "libnetcdf >=4.8.1,<5.0a0", + "libogg >=1.3.5,<1.4.0a0", + "libpng >=1.6.39,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.1.0,<5.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "loguru", + "lz4-c >=1.9.4,<1.10.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.11,<3.12.0a0", + "qt >=5.15.9,<5.16.0a0", + "qt >=5.15.9,<6.0a0", + "sqlite >=3.41.1,<4.0a0", + "tbb >=2021.7.0", + "tk >=8.6.12,<8.7.0a0", + "utfcpp", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aa537e928128dee52d06c5098fea0451", + "name": "vtk", + "sha256": "a8667baf9c5ddd3cd477bef4a46cd7880642a94d483c40d15cd538c16b25a00f", + "size": 38161302, + "subdir": "linux-64", + "timestamp": 1679759732430, + "version": "9.0.3" + }, + "vtk-9.0.3-py37h0649366_201.tar.bz2": { + "build": "py37h0649366_201", + "build_number": 201, + "constrains": [ + "paraview ==9999999999" + ], + "depends": [ + "double-conversion", + "eigen", + "expat >=2.2.10,<3.0a0", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "gl2ps >=1.4.2,<1.4.3.0a0", + "glew >=2.1.0,<2.2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "jsoncpp >=1.9.4,<1.9.5.0a0", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.8.1,<5.0a0", + "libogg", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.1.0,<5.0a0", + "libxml2 >=2.9.12,<2.10.0a0", + "loguru", + "lz4-c >=1.9.3,<1.10.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.7,<3.8.0a0", + "qt >=5.9.7,<5.10.0a0", + "qt >=5.9.7,<6.0a0", + "sqlite >=3.37.2,<4.0a0", + "tbb >=2021.5.0", + "tk >=8.6.11,<8.7.0a0", + "utfcpp", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0f8cbb3e2d70406056fc6290c2e137f2", + "name": "vtk", + "sha256": "08ee00529ef4c1c92739dd57b02deda0028a0f74cfc0d3ff4a99aa5da519cd5c", + "size": 37812508, + "subdir": "linux-64", + "timestamp": 1646117806063, + "version": "9.0.3" + }, + "vtk-9.0.3-py38h0649366_201.tar.bz2": { + "build": "py38h0649366_201", + "build_number": 201, + "constrains": [ + "paraview ==9999999999" + ], + "depends": [ + "double-conversion", + "eigen", + "expat >=2.2.10,<3.0a0", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "gl2ps >=1.4.2,<1.4.3.0a0", + "glew >=2.1.0,<2.2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "jsoncpp >=1.9.4,<1.9.5.0a0", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.8.1,<5.0a0", + "libogg", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.1.0,<5.0a0", + "libxml2 >=2.9.12,<2.10.0a0", + "loguru", + "lz4-c >=1.9.3,<1.10.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.8,<3.9.0a0", + "qt >=5.9.7,<5.10.0a0", + "qt >=5.9.7,<6.0a0", + "sqlite >=3.37.2,<4.0a0", + "tbb >=2021.5.0", + "tk >=8.6.11,<8.7.0a0", + "utfcpp", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "28f8aa3459b74cf852ede5fbc8aa818f", + "name": "vtk", + "sha256": "1c224e90a95ae2b61ecedc642752cd11b67e5239f47b4807ddad43a5c409fba4", + "size": 37842962, + "subdir": "linux-64", + "timestamp": 1646116991743, + "version": "9.0.3" + }, + "vtk-9.0.3-py38hf89884c_202.tar.bz2": { + "build": "py38hf89884c_202", + "build_number": 202, + "constrains": [ + "paraview ==9999999999" + ], + "depends": [ + "double-conversion", + "eigen", + "expat >=2.4.9,<3.0a0", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "gl2ps >=1.4.2,<1.4.3.0a0", + "glew >=2.2.0,<2.3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "jsoncpp >=1.9.4,<1.9.5.0a0", + "libgcc-ng >=11.2.0", + "libnetcdf >=4.8.1,<5.0a0", + "libogg >=1.3.5,<1.4.0a0", + "libpng >=1.6.39,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.1.0,<5.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "loguru", + "lz4-c >=1.9.4,<1.10.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.8,<3.9.0a0", + "qt >=5.15.9,<5.16.0a0", + "qt >=5.15.9,<6.0a0", + "sqlite >=3.41.1,<4.0a0", + "tbb >=2021.7.0", + "tk >=8.6.12,<8.7.0a0", + "utfcpp", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fb2f0af84e8c1d2a492a398512b638e4", + "name": "vtk", + "sha256": "0a0d6fc2cd0c71f3f70333c6f67fe55931bda17acc7502e5894a4715100a1fee", + "size": 38161044, + "subdir": "linux-64", + "timestamp": 1679757213734, + "version": "9.0.3" + }, + "vtk-9.0.3-py39h0649366_201.tar.bz2": { + "build": "py39h0649366_201", + "build_number": 201, + "constrains": [ + "paraview ==9999999999" + ], + "depends": [ + "double-conversion", + "eigen", + "expat >=2.2.10,<3.0a0", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "gl2ps >=1.4.2,<1.4.3.0a0", + "glew >=2.1.0,<2.2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "jsoncpp >=1.9.4,<1.9.5.0a0", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.8.1,<5.0a0", + "libogg", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.1.0,<5.0a0", + "libxml2 >=2.9.12,<2.10.0a0", + "loguru", + "lz4-c >=1.9.3,<1.10.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.9,<3.10.0a0", + "qt >=5.9.7,<5.10.0a0", + "qt >=5.9.7,<6.0a0", + "sqlite >=3.37.2,<4.0a0", + "tbb >=2021.5.0", + "tk >=8.6.11,<8.7.0a0", + "utfcpp", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e5c8912764871e606de958546d9c2701", + "name": "vtk", + "sha256": "75f757688e90a514119b20dd30c04af2ed0c1d92ab02858ce28f3180897eb728", + "size": 37846759, + "subdir": "linux-64", + "timestamp": 1646119360333, + "version": "9.0.3" + }, + "vtk-9.0.3-py39hf89884c_202.tar.bz2": { + "build": "py39hf89884c_202", + "build_number": 202, + "constrains": [ + "paraview ==9999999999" + ], + "depends": [ + "double-conversion", + "eigen", + "expat >=2.4.9,<3.0a0", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "gl2ps >=1.4.2,<1.4.3.0a0", + "glew >=2.2.0,<2.3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "jsoncpp >=1.9.4,<1.9.5.0a0", + "libgcc-ng >=11.2.0", + "libnetcdf >=4.8.1,<5.0a0", + "libogg >=1.3.5,<1.4.0a0", + "libpng >=1.6.39,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.1.0,<5.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "loguru", + "lz4-c >=1.9.4,<1.10.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.9,<3.10.0a0", + "qt >=5.15.9,<5.16.0a0", + "qt >=5.15.9,<6.0a0", + "sqlite >=3.41.1,<4.0a0", + "tbb >=2021.7.0", + "tk >=8.6.12,<8.7.0a0", + "utfcpp", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6349a50ebd8801ea01123effeda0f1d4", + "name": "vtk", + "sha256": "fa1f32fdfcce3df79eb7605b1b708b2bc43ecf8093a7c25b9f3bdece18bd13a4", + "size": 38159846, + "subdir": "linux-64", + "timestamp": 1679754708005, + "version": "9.0.3" + }, + "vyper-config-1.1.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "distconfig3 >=1.0.1", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.4.1", + "toml >=0.10.0", + "watchdog >=0.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "79b3c5027ef186b6800aa4c6d2d351d9", + "name": "vyper-config", + "sha256": "a5dcd00f0faba1115b0e97ab75ef123245cfa1a94f6d84ba19db5125f2f938ae", + "size": 24729, + "subdir": "linux-64", + "timestamp": 1668696418490, + "version": "1.1.1" + }, + "vyper-config-1.1.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "distconfig3 >=1.0.1", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.4.1", + "toml >=0.10.0", + "watchdog >=0.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ea5ba107f7933eec37eee8279435536", + "name": "vyper-config", + "sha256": "c7ac3105be7615f4f401e1632c1b349da482c3f80f01098b688c957f4f71e283", + "size": 32426, + "subdir": "linux-64", + "timestamp": 1676863516163, + "version": "1.1.1" + }, + "vyper-config-1.1.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "distconfig3 >=1.0.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.4.1", + "toml >=0.10.0", + "watchdog >=0.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3fe6dd9af94dff41cb2410bc33374766", + "name": "vyper-config", + "sha256": "207466766f95eb2d72751953c78d684005bb9aa43f44e46bae241c0da12934f1", + "size": 24502, + "subdir": "linux-64", + "timestamp": 1668696389271, + "version": "1.1.1" + }, + "vyper-config-1.1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "distconfig3 >=1.0.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.4.1", + "toml >=0.10.0", + "watchdog >=0.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4104a21ead3dd9241fadaeb90c6cd145", + "name": "vyper-config", + "sha256": "bdd83841cf18fa837b54aaa36d7d7ac6b3b5bd2d8594d39a59bd8dae1249fe44", + "size": 24478, + "subdir": "linux-64", + "timestamp": 1668696476537, + "version": "1.1.1" + }, + "vyper-config-1.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "distconfig3 >=1.0.1", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.4.1", + "toml >=0.10.0", + "watchdog >=0.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e886432e74661aebbce01d07e88c9a2", + "name": "vyper-config", + "sha256": "82904e17614e5a453f45758a06a9f30b6fb39d85684ab27aced7986e6db4b1ad", + "size": 24508, + "subdir": "linux-64", + "timestamp": 1668696447432, + "version": "1.1.1" + }, + "w3lib-1.18.0-py27hc2697b3_0.tar.bz2": { + "build": "py27hc2697b3_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "6e8d11fd3f08e946bf8adbabd31d11a2", + "name": "w3lib", + "sha256": "0e9d97cd85996f6803fa5b53e6c3364c245b2127620665ba94f34986e126a217", + "size": 31375, + "subdir": "linux-64", + "timestamp": 1507834880083, + "version": "1.18.0" + }, + "w3lib-1.18.0-py35hc71e62e_0.tar.bz2": { + "build": "py35hc71e62e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "4a3dc8435e9642ebb5be0afb02402c7f", + "name": "w3lib", + "sha256": "a658536cfcff8b3f46146ff5f68bd03eb3e13341abdfb86f76a528c4530c88a4", + "size": 31610, + "subdir": "linux-64", + "timestamp": 1507834899629, + "version": "1.18.0" + }, + "w3lib-1.18.0-py36hc34d9f4_0.tar.bz2": { + "build": "py36hc34d9f4_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "d64e68791ce26d654e6fc381f81405d3", + "name": "w3lib", + "sha256": "b4a0984641b42d151627f67773b6238568a9ab69e443754cde711a5d35af3eac", + "size": 31510, + "subdir": "linux-64", + "timestamp": 1507834907878, + "version": "1.18.0" + }, + "w3lib-1.19.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "56f21b1881951cca163d059b72863f93", + "name": "w3lib", + "sha256": "25a98175fdf7d16778ad69232de6ae2387bffa9a60c50069ce24040ecff1b833", + "size": 31156, + "subdir": "linux-64", + "timestamp": 1519671826621, + "version": "1.19.0" + }, + "w3lib-1.19.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "d23c8980f815251161577b95b55cbd1a", + "name": "w3lib", + "sha256": "6043a34a7d7b7e79369c846cbcea1aaa836d754c7642504c565ebf38658c959f", + "size": 31403, + "subdir": "linux-64", + "timestamp": 1519671862740, + "version": "1.19.0" + }, + "w3lib-1.19.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "c732c30d774b3a106594b5fe7e09edbc", + "name": "w3lib", + "sha256": "39a4cf0b094feee494bcf410a6a2e9a6143e71b06bc021735d3a48ed86af91d3", + "size": 31365, + "subdir": "linux-64", + "timestamp": 1519671896701, + "version": "1.19.0" + }, + "w3lib-1.19.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "e6de1f88cbc77934debd1d0b970110d3", + "name": "w3lib", + "sha256": "ef0099a257cb3a337c03376c5bdeb472b852825db085b95120dcf3f071c7aeba", + "size": 31307, + "subdir": "linux-64", + "timestamp": 1530904799126, + "version": "1.19.0" + }, + "w3lib-1.20.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "ef21db87af8b505c03917678760743e5", + "name": "w3lib", + "sha256": "c291ed9e772d9a255d34d03b2695c84d11d5469891756028b9820b25b1ae228f", + "size": 158732, + "subdir": "linux-64", + "timestamp": 1547927144305, + "version": "1.20.0" + }, + "w3lib-1.20.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "31bba3443a3b7867d9e31dfa25e32b1f", + "name": "w3lib", + "sha256": "abe98163ae2f39bc476809922fc4d95dfbeed54a49adb5c6eab9e7fd9ceb735c", + "size": 158867, + "subdir": "linux-64", + "timestamp": 1547927290670, + "version": "1.20.0" + }, + "w3lib-1.20.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "be00834cb63714adcda41178b45bd42b", + "name": "w3lib", + "sha256": "76cf33e73d7c9c76a879550ac03078737136bc73c874f4d8d50de5ea43d16d15", + "size": 158791, + "subdir": "linux-64", + "timestamp": 1547927236075, + "version": "1.20.0" + }, + "waf-2.0.18-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "be51ad927397e23d627bcbfd833cc06a", + "name": "waf", + "sha256": "e51e5bae8cc0acd47ef821a828a657e75a6c8831926ca707383b955d68555cf0", + "size": 115598, + "subdir": "linux-64", + "timestamp": 1569435946443, + "version": "2.0.18" + }, + "waf-2.0.18-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9be0e705cd6a0c59885aa45af7f57f5c", + "name": "waf", + "sha256": "be2fcf4f25f86a98bd491519c6e01262ed8d41b20400d9b154a97c4c45c1c958", + "size": 115599, + "subdir": "linux-64", + "timestamp": 1569435954983, + "version": "2.0.18" + }, + "waf-2.0.18-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ade67a16bfcea04dac0f5f58428ad220", + "name": "waf", + "sha256": "ce1f25164008047f65328525e16605c9b1a924ae431f3e01a5a5ca6e34c1553a", + "size": 115614, + "subdir": "linux-64", + "timestamp": 1569436047839, + "version": "2.0.18" + }, + "waf-2.0.18-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2c0d0cec9e6e91b80a4fbff741f868a9", + "name": "waf", + "sha256": "cc6a8d8fd310c1ea585a018110bd2960f486cf79f70707bf0b65eecd252153e4", + "size": 112182, + "subdir": "linux-64", + "timestamp": 1573200427429, + "version": "2.0.18" + }, + "waf-2.0.20-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "274615770e4e5b0e7104a179bf8ad87a", + "name": "waf", + "sha256": "c69f234f410fed5fffe9c641ae248f3dd7e9447dd6dd94e5ddc19c026b2ebba3", + "size": 111993, + "subdir": "linux-64", + "timestamp": 1600470410497, + "version": "2.0.20" + }, + "waf-2.0.20-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "613b05e50d8a66badfd673f3d1400f22", + "name": "waf", + "sha256": "69cca44e51ec8a50ae74489a5cabeed358ff4f9e860b0d312aa64df122fd6650", + "size": 112002, + "subdir": "linux-64", + "timestamp": 1600470410843, + "version": "2.0.20" + }, + "waf-2.0.20-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7c18cc6e25a18453bb43314406db81c1", + "name": "waf", + "sha256": "fd4e6827496eac8acea04ee399b42f229ba5a4dcf166439df543fed6c2f771d5", + "size": 112090, + "subdir": "linux-64", + "timestamp": 1600470432988, + "version": "2.0.20" + }, + "waf-2.0.21-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "076437814208ee8fb78b102c797cf6d3", + "name": "waf", + "sha256": "2934e52f3dce7e5cc61f3a1bc64a34b1962b50d654165705cccdedc240fba4f3", + "size": 112172, + "subdir": "linux-64", + "timestamp": 1606939071598, + "version": "2.0.21" + }, + "waf-2.0.21-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3aad8083af75bc9cef6014dadf6cb97d", + "name": "waf", + "sha256": "966aebc9bad9187e3829bca3326be58e326ef6c0d995f8e5361e0e2cd677ff93", + "size": 112154, + "subdir": "linux-64", + "timestamp": 1606939075812, + "version": "2.0.21" + }, + "waf-2.0.21-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "04fedb3d35bdf657689dead178f2e51d", + "name": "waf", + "sha256": "b59dbbc1d6c53be2e2369c86bab3e0c19c68098ce9280d7fc820e79d9e58abe2", + "size": 112341, + "subdir": "linux-64", + "timestamp": 1606939071597, + "version": "2.0.21" + }, + "waf-2.0.21-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "47e2356754c4c064390fd9672cdd5b7f", + "name": "waf", + "sha256": "2c6cb6e5334a0b131e7f8126c032e0850d920a691d9cd0e9089c8a928fb703b3", + "size": 112409, + "subdir": "linux-64", + "timestamp": 1606939091759, + "version": "2.0.21" + }, + "waf-2.0.22-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "854d9367d435182a8804f523b9583825", + "name": "waf", + "sha256": "41844c13aedc28d3db7fea28531894b7ab5e0d4166f31104c14d495af8445bad", + "size": 112963, + "subdir": "linux-64", + "timestamp": 1640795846381, + "version": "2.0.22" + }, + "waf-2.0.22-py311h5eee18b_1.tar.bz2": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7cfc7b07e485661d5eb0e8939325797b", + "name": "waf", + "sha256": "5e6ba5261cf1b4cb5272739289455f70e09fc656175223fea12c039a408145d0", + "size": 113411, + "subdir": "linux-64", + "timestamp": 1676838901118, + "version": "2.0.22" + }, + "waf-2.0.22-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b5c4a3f9273a8222d0e6ccecd0ecc430", + "name": "waf", + "sha256": "6cca0748cb7dcc6d274223568a5845ca4aa4fd0e8a4ce6096aaf8a3ec181235e", + "size": 112184, + "subdir": "linux-64", + "timestamp": 1614626021794, + "version": "2.0.22" + }, + "waf-2.0.22-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "83dbe750727a8ce0f0f466f8c2b997aa", + "name": "waf", + "sha256": "2f1ea36d6c0adb5b4996c63b44847bf001931d24acf51cefa22e6be529cebb69", + "size": 112212, + "subdir": "linux-64", + "timestamp": 1614630641646, + "version": "2.0.22" + }, + "waf-2.0.22-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e1cc555d7fd051f6a3af024fda92a15d", + "name": "waf", + "sha256": "69475d1d0d6e0516371dd3ddfe444fcd14c8db22de1df539e912065e621c5791", + "size": 112345, + "subdir": "linux-64", + "timestamp": 1614624825742, + "version": "2.0.22" + }, + "waf-2.0.22-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f26d5b33c7282813eda4a97ffc80d5ee", + "name": "waf", + "sha256": "6b113a14c313ea93c5885be1642899c95a71a68aa196fe2782039a94e3cb009e", + "size": 112372, + "subdir": "linux-64", + "timestamp": 1614625993551, + "version": "2.0.22" + }, + "waf-2.0.8-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4789a6ca06bf1607d217be072f7ebc82", + "name": "waf", + "sha256": "a69e2d567fcf1389407e98bf7fb64d3dce71493f70ab2845a0f24b3ada0590ea", + "size": 113850, + "subdir": "linux-64", + "timestamp": 1561613145990, + "version": "2.0.8" + }, + "waf-2.0.8-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "72afed4f3f514b1cde7a2ccee1af055b", + "name": "waf", + "sha256": "077bfabfe859427911279f8abad8094ce8851814252f264abb5078e2414b8cd1", + "size": 113884, + "subdir": "linux-64", + "timestamp": 1561613178512, + "version": "2.0.8" + }, + "waf-2.0.8-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b9665478106e9c63d9c1f108fdd73a77", + "name": "waf", + "sha256": "46ccb59c9a8c8a827d895fb08b547595761e99265b52528df3927944de690962", + "size": 113842, + "subdir": "linux-64", + "timestamp": 1561613135234, + "version": "2.0.8" + }, + "waitress-1.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "50534816d846dcdb5516279a0e0438fe", + "name": "waitress", + "sha256": "ad53f45fcab5e98e04eff5465c882ca2b244568c5133de8f648ac59359724514", + "size": 159427, + "subdir": "linux-64", + "timestamp": 1530875724183, + "version": "1.1.0" + }, + "waitress-1.1.0-py27ha0b65e1_0.tar.bz2": { + "build": "py27ha0b65e1_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "c84480b07e5a7a5b36dd5cf780edf2c0", + "name": "waitress", + "sha256": "41476b98f29a7a617dff8116b9b5648e100363c6cf14ccec62f92d01db5d3251", + "size": 159643, + "subdir": "linux-64", + "timestamp": 1507983539258, + "version": "1.1.0" + }, + "waitress-1.1.0-py35h0c2a5b4_0.tar.bz2": { + "build": "py35h0c2a5b4_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "5356253f722027820818f936f20117b1", + "name": "waitress", + "sha256": "31bd237f70b31f04b321a191a2af9509e58028cc24b7bae8fa904f130b7e4890", + "size": 164865, + "subdir": "linux-64", + "timestamp": 1507983553745, + "version": "1.1.0" + }, + "waitress-1.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "a53d4c702c412d9e1080886e4412dd39", + "name": "waitress", + "sha256": "2f5d8441e1c4aebf93e1941cb41deba08e96f8d15aedafadd7d7a02be9dbc0c3", + "size": 164233, + "subdir": "linux-64", + "timestamp": 1530875669888, + "version": "1.1.0" + }, + "waitress-1.1.0-py36hd6e6ebe_0.tar.bz2": { + "build": "py36hd6e6ebe_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "e7faa61d9a4872ba23b5cfbb053568c0", + "name": "waitress", + "sha256": "c7a22a0c6c6ab1e845925eb1db79575d8bf226d4c58a8550b21de25a52a975a7", + "size": 164290, + "subdir": "linux-64", + "timestamp": 1507983554677, + "version": "1.1.0" + }, + "waitress-1.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "e8d8581ba96fb3cc1983f886e6a073ac", + "name": "waitress", + "sha256": "cad5f60d3b6b3f8784974080d82aca0b72c76faec97aa3f039ce70578ec8280c", + "size": 164000, + "subdir": "linux-64", + "timestamp": 1530875697476, + "version": "1.1.0" + }, + "waitress-1.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "9e65e6311c67de233ddf0aacf6d1c384", + "name": "waitress", + "sha256": "a8473a4d44e1578a417dfd6dffb256bf2afccd0f579f5edafc78105e68e0674a", + "size": 332434, + "subdir": "linux-64", + "timestamp": 1547984486121, + "version": "1.2.0" + }, + "waitress-1.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "65d8c63ce3c7528cf1e0403008b84f44", + "name": "waitress", + "sha256": "c2548e4d1e35aca67ce81b75c58cea36abc6b345ffecfa93222ffcae7274d696", + "size": 346373, + "subdir": "linux-64", + "timestamp": 1547984586726, + "version": "1.2.0" + }, + "waitress-1.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "8df775f5bed06efaf19529d813651470", + "name": "waitress", + "sha256": "a7710ee65186c0019d9b32078a0c265cdf7e776a20213e6d9abccd680680e676", + "size": 352461, + "subdir": "linux-64", + "timestamp": 1547984526003, + "version": "1.2.0" + }, + "waitress-1.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "934acdbde613afe904bbc425dae9ffc1", + "name": "waitress", + "sha256": "0b0b01ede76bf017f8230e6b8f1f6f9ba414b8d429de6c119d7d651b39c774fc", + "size": 337878, + "subdir": "linux-64", + "timestamp": 1550431957184, + "version": "1.2.1" + }, + "waitress-1.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "e10ee33c8ac20dc0fd0e95c2154d3139", + "name": "waitress", + "sha256": "d38b1b4593670b73f95c1f7b097df78310ddce3bf38003a3679bce05ce6a7af5", + "size": 358675, + "subdir": "linux-64", + "timestamp": 1550431974226, + "version": "1.2.1" + }, + "waitress-1.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "b49e8c8dc56a5b72d7fee809f3811d48", + "name": "waitress", + "sha256": "8265e0f862158469bab66e217a3fb2a208236c468dae79974140e8025dcd9af7", + "size": 343967, + "subdir": "linux-64", + "timestamp": 1550431958021, + "version": "1.2.1" + }, + "waitress-1.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "3dcc334206b73adb8d7528ec4e436ca7", + "name": "waitress", + "sha256": "90dd325021cd57589d24eec68cf25fb03b9cf2e68313e1016ac8b2415c9c695a", + "size": 366030, + "subdir": "linux-64", + "timestamp": 1564711261050, + "version": "1.3.0" + }, + "waitress-1.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "91785dd8da57111acbc8414caed6790b", + "name": "waitress", + "sha256": "1f2507a763325c5e599f76150ae0e0ebe6c21494ddf8ce1e0a2e4a695647df36", + "size": 358774, + "subdir": "linux-64", + "timestamp": 1564711288315, + "version": "1.3.0" + }, + "waitress-1.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "baf78f58300892fc9ee2562dae8bbe38", + "name": "waitress", + "sha256": "537706b5f777ea05b7cca37ba65762212dcafd872c445827615eecf64d0124d2", + "size": 357022, + "subdir": "linux-64", + "timestamp": 1564711257174, + "version": "1.3.0" + }, + "wasabi-0.9.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "acbe7eb2f4c17afe1ca60b6d3524e65a", + "name": "wasabi", + "sha256": "bbb20b230671d8e7ff67c408c7f4b2acdd437dd51a75582e81abaa3cde90e662", + "size": 42092, + "subdir": "linux-64", + "timestamp": 1651237360650, + "version": "0.9.1" + }, + "wasabi-0.9.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab88237c9032aba8feb6532c3300527e", + "name": "wasabi", + "sha256": "91ee72ef19d227fbdb52fa1994fe673e53953596801a2e67ff2df26f4b004afd", + "size": 51937, + "subdir": "linux-64", + "timestamp": 1676843051174, + "version": "0.9.1" + }, + "wasabi-0.9.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "734cc0e4899e1d1844f507a8e86ddc63", + "name": "wasabi", + "sha256": "c31c58ad447e3ad39087f0f0c3fff2714bd41821c2545901c9019e26404e5a3e", + "size": 41808, + "subdir": "linux-64", + "timestamp": 1651237434264, + "version": "0.9.1" + }, + "wasabi-0.9.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39345a820bb098b52ddf4e04dc84219f", + "name": "wasabi", + "sha256": "140ca5198a10c3429fa4b64b3804d0bdacdafe89ff0ac6e3c2a5acb9104beabc", + "size": 41892, + "subdir": "linux-64", + "timestamp": 1651237470063, + "version": "0.9.1" + }, + "wasabi-0.9.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0e24d5e979e845b532ad7a2763e2a119", + "name": "wasabi", + "sha256": "e74b0f06139a35aec9d75e108d0eb8af90c30752e242bcb1d5bb3d2964649615", + "size": 41939, + "subdir": "linux-64", + "timestamp": 1651237397959, + "version": "0.9.1" + }, + "watchdog-0.10.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "5837b73c864e05cd87d766cef63329ac", + "name": "watchdog", + "sha256": "71667849edeb50ae489a73c766456015a1bc1100483f86c1db9baf7c98c3b5f0", + "size": 95010, + "subdir": "linux-64", + "timestamp": 1580838480220, + "version": "0.10.1" + }, + "watchdog-0.10.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "0b767101b6ea5bc7ffd009f345dfeb7e", + "name": "watchdog", + "sha256": "d9a269c4f6019ff5b622ca28f90d0063f6fa72f43ee0f583acd798d555090a88", + "size": 95122, + "subdir": "linux-64", + "timestamp": 1580838464561, + "version": "0.10.1" + }, + "watchdog-0.10.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "f42422fc3c0519d8c279e3ffc607ccaa", + "name": "watchdog", + "sha256": "29dcc977417a58689fb34ab773113e9e2720787cc58a326b32231b99615430d1", + "size": 95334, + "subdir": "linux-64", + "timestamp": 1580838599948, + "version": "0.10.1" + }, + "watchdog-0.10.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "1cc66173d6597b575038e917b563432a", + "name": "watchdog", + "sha256": "06e72a855288b29c2d0001555f49de9e50c466a85a702dbe200c5719755af83b", + "size": 95100, + "subdir": "linux-64", + "timestamp": 1581354492921, + "version": "0.10.2" + }, + "watchdog-0.10.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "be4e73f81a332351a539821330e996ae", + "name": "watchdog", + "sha256": "1bdb212483fe0df1c2e8c1ab0c3c9a1c87db2a262d2589fd0fcc490d8618d6a1", + "size": 95259, + "subdir": "linux-64", + "timestamp": 1581354416911, + "version": "0.10.2" + }, + "watchdog-0.10.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "8dff9593d468f69f2bdacf4b834965ad", + "name": "watchdog", + "sha256": "7db4f31fb7f187022f9b9c29fc161276b93957e81edb6b3bca2efa0575a5d778", + "size": 95530, + "subdir": "linux-64", + "timestamp": 1581354495028, + "version": "0.10.2" + }, + "watchdog-0.10.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "5f0ee845f40b4af1d73faf42b70d5929", + "name": "watchdog", + "sha256": "a2ac36cf18f693eebf346dbd3019f55ba363f33fa76b585bfa44d96d4b097357", + "size": 95909, + "subdir": "linux-64", + "timestamp": 1593447372182, + "version": "0.10.3" + }, + "watchdog-0.10.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "b5abb9f2e6b3acfa347027994dd5e726", + "name": "watchdog", + "sha256": "a2d02c005f8bfec172dcb0ee6bbe70a4ee42ab274d49f0045374f3f5055ba2a7", + "size": 96043, + "subdir": "linux-64", + "timestamp": 1593447329924, + "version": "0.10.3" + }, + "watchdog-0.10.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "1c62e79a665fc0db0e0c87d818da5189", + "name": "watchdog", + "sha256": "ad2f7ba3c2a1d95c0359fbf32628dc6bf9438944f714fc77769e1f175063b47d", + "size": 96357, + "subdir": "linux-64", + "timestamp": 1593447370162, + "version": "0.10.3" + }, + "watchdog-0.10.4-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "19a4f3ef4381a3c904e7a13fbdcfcde4", + "name": "watchdog", + "sha256": "d5d8b19dad238e05383b5201b2eaaa45a61ac985812ebdd4a30e7ab61ecc5135", + "size": 93376, + "subdir": "linux-64", + "timestamp": 1606939099406, + "version": "0.10.4" + }, + "watchdog-0.10.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "b04c4670261fe527e1ac5e3b508ffa8d", + "name": "watchdog", + "sha256": "8739604ce43d3dc3f1cbddbb2e631f0ec1d16350ef262e3ff99bf9f1a4256396", + "size": 93416, + "subdir": "linux-64", + "timestamp": 1606939093742, + "version": "0.10.4" + }, + "watchdog-0.10.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "ef74ffe57ae6a2abee93a1342554ee0e", + "name": "watchdog", + "sha256": "874e1b9fd693669ccda80bc178a9f1f1d7803256add918b7f13bf7af1fcbe2d7", + "size": 93723, + "subdir": "linux-64", + "timestamp": 1606939129565, + "version": "0.10.4" + }, + "watchdog-0.10.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "9659bbb0a400a416f042288401772d07", + "name": "watchdog", + "sha256": "45aedd387fae1c65cfbc38c454dda76fbb49fc7df0ed19b39eb29390c3e3a711", + "size": 98196, + "subdir": "linux-64", + "timestamp": 1607530063564, + "version": "0.10.4" + }, + "watchdog-0.9.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=2.7,<2.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "9f8aac6bcb8f4139c4581abfacd6bf54", + "name": "watchdog", + "sha256": "36b857987d8930c53837c8166d89a185a3d514ca8f40f833fbcd04c7f3587592", + "size": 93187, + "subdir": "linux-64", + "timestamp": 1575416422784, + "version": "0.9.0" + }, + "watchdog-0.9.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "ed78878a015fe9d61a3c78ec22f9e0d5", + "name": "watchdog", + "sha256": "f9b22c31e7f9f9385f039e7e665e338d12d2a51b3ecb05de8dea42a2659ab361", + "size": 95358, + "subdir": "linux-64", + "timestamp": 1575416382026, + "version": "0.9.0" + }, + "watchdog-0.9.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "dd64bc8209128a4b7897cd444fe2dbce", + "name": "watchdog", + "sha256": "2ce08a7d36add1680cd10247a50d16bee033eb6be054c1d29f0af9c6945b12e0", + "size": 95471, + "subdir": "linux-64", + "timestamp": 1575416459376, + "version": "0.9.0" + }, + "watchdog-0.9.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "0b7f137543d18852099425d11a8e0fdd", + "name": "watchdog", + "sha256": "96b1ed535b35c9053d33c7222969185e36962efaac1335fa91c81e017763ac24", + "size": 95811, + "subdir": "linux-64", + "timestamp": 1575416459870, + "version": "0.9.0" + }, + "watchdog-1.0.2-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "argh >=0.24.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "07f83b80a68923c2ffb7226b421c8921", + "name": "watchdog", + "sha256": "570e76d16373ba54b92dbf9fdceb2febcde59aaef5d288b80ba4f23f912b18ff", + "size": 90951, + "subdir": "linux-64", + "timestamp": 1612471170375, + "version": "1.0.2" + }, + "watchdog-1.0.2-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "argh >=0.24.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "1569e551d60daaa0085c7d2943078ae5", + "name": "watchdog", + "sha256": "75419c8a986e2d7bd01aaad65656e40c28c74fd767fa36b4c0ccf8b6918692f5", + "size": 91042, + "subdir": "linux-64", + "timestamp": 1612471164401, + "version": "1.0.2" + }, + "watchdog-1.0.2-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "argh >=0.24.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "bd3b100789cb0e0ece76ea84f389748c", + "name": "watchdog", + "sha256": "12e374ab4db5f9a770e36ff56d2870c2f26e851cff3477164395e589eae19aa2", + "size": 91327, + "subdir": "linux-64", + "timestamp": 1612471077817, + "version": "1.0.2" + }, + "watchdog-1.0.2-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "argh >=0.24.1", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "94106e5f13657d39d270dc34875c5c9c", + "name": "watchdog", + "sha256": "34a19b5db25d3f87381c34d7f7cb5fdc13d74efeda94ae10348e4b8e8c26e83d", + "size": 91447, + "subdir": "linux-64", + "timestamp": 1612471167917, + "version": "1.0.2" + }, + "watchdog-2.1.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "argh >=0.24.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "519d2526706155207c13a20e21a943a4", + "name": "watchdog", + "sha256": "2b8f8a137871db94a555054227c32939ec53a8cc25b64d6e1b96c62dedf48184", + "size": 94107, + "subdir": "linux-64", + "timestamp": 1620778287704, + "version": "2.1.1" + }, + "watchdog-2.1.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "argh >=0.24.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "9954fb5ff6fe91864e1f7a66d8864fcb", + "name": "watchdog", + "sha256": "64fd6ebc998cc62c32261edddd5c541303db464ff5ea0bf74dab0c9306663cab", + "size": 94288, + "subdir": "linux-64", + "timestamp": 1620778285799, + "version": "2.1.1" + }, + "watchdog-2.1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "argh >=0.24.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "b497cdb40d916df0f44057027dcef47d", + "name": "watchdog", + "sha256": "2d7b50dc235d1c31cdd81c825e229aefdcbbdaedacf47d1270439a603e476d5c", + "size": 94499, + "subdir": "linux-64", + "timestamp": 1620778241018, + "version": "2.1.1" + }, + "watchdog-2.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "argh >=0.24.1", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "84bf0e41fdbe5484cbf77049e8b2bb66", + "name": "watchdog", + "sha256": "555983b3e018809430e33625c85fcad7798be3cc0a7e1484ea0bb56f6f8f31df", + "size": 94618, + "subdir": "linux-64", + "timestamp": 1620773990409, + "version": "2.1.1" + }, + "watchdog-2.1.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "argh >=0.24.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ba80e9c3991a9e4944caca0695775c28", + "name": "watchdog", + "sha256": "2f2936cee0d99a0613b41f12f288e90534c17cb1d1407771b583def047394dc2", + "size": 94262, + "subdir": "linux-64", + "timestamp": 1624955050969, + "version": "2.1.3" + }, + "watchdog-2.1.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "argh >=0.24.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0fab0837ca6646f3110c1d6a4bc04d9f", + "name": "watchdog", + "sha256": "d52e29348233fb405441e64b43f2f7da8ec260a80da435bc5e4bd0f8a6f933b3", + "size": 94413, + "subdir": "linux-64", + "timestamp": 1624955030969, + "version": "2.1.3" + }, + "watchdog-2.1.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "argh >=0.24.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "53af053e809bf8bfe5ba677e9dc154c1", + "name": "watchdog", + "sha256": "873203f43b4a4f5487309f1bf0bb63900b076cf9d11279031b202859693f07d1", + "size": 94581, + "subdir": "linux-64", + "timestamp": 1624948613247, + "version": "2.1.3" + }, + "watchdog-2.1.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "argh >=0.24.1", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2ade8c1421b73be3cd96b300ca15f851", + "name": "watchdog", + "sha256": "263bfc92e179af3e89770504c3959319c0fb075b5b9e9797c03d2e22c5178916", + "size": 94674, + "subdir": "linux-64", + "timestamp": 1624955043256, + "version": "2.1.3" + }, + "watchdog-2.1.6-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "python >=3.10,<3.11.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1fefa62f3474b6a2e2ce172cdf9f8326", + "name": "watchdog", + "sha256": "ce488d874ebcbaabbc50f022fad49bee8403dcda0c7080268858485aaaecedcb", + "size": 97574, + "subdir": "linux-64", + "timestamp": 1640811355374, + "version": "2.1.6" + }, + "watchdog-2.1.6-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "python >=3.11,<3.12.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fc5d73c3bdc64c4d1fb9521d44ac7624", + "name": "watchdog", + "sha256": "a59d04aa6aa9cd913f5cd680d58bf7cf78e5c38f108a63a4b4607d0fc98783e6", + "size": 123615, + "subdir": "linux-64", + "timestamp": 1676846203886, + "version": "2.1.6" + }, + "watchdog-2.1.6-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "203a1d168299152adadef421c85680f7", + "name": "watchdog", + "sha256": "5e0cc31a27eb5362ea77d1c8125cb80a6d75024a0a77997fa64393a815d54e79", + "size": 96029, + "subdir": "linux-64", + "timestamp": 1638367318147, + "version": "2.1.6" + }, + "watchdog-2.1.6-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "59996eb6112e15db3183a82138b65b22", + "name": "watchdog", + "sha256": "12f066971d0d2bc1b7c1f467b889fdce3b2522f9cc9552f90b2a93e52bed6103", + "size": 96338, + "subdir": "linux-64", + "timestamp": 1638366592042, + "version": "2.1.6" + }, + "watchdog-2.1.6-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "42ec03d33e877a2c8af0c49ce85823d0", + "name": "watchdog", + "sha256": "c9c094a5013e96a327960d78190e230eb501b3d86b7255c72aa8915e83520500", + "size": 96461, + "subdir": "linux-64", + "timestamp": 1638367309504, + "version": "2.1.6" + }, + "watchfiles-0.18.1-py310h52d8a92_0.tar.bz2": { + "build": "py310h52d8a92_0", + "build_number": 0, + "depends": [ + "anyio >=3.0.0,<4", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0af43e1e353e346aca1206e40c483ebf", + "name": "watchfiles", + "sha256": "e2e1c114909292d688dafd5f9036869306da692ad2b3769bf6162266e223868e", + "size": 1139222, + "subdir": "linux-64", + "timestamp": 1677830339601, + "version": "0.18.1" + }, + "watchfiles-0.18.1-py38h52d8a92_0.tar.bz2": { + "build": "py38h52d8a92_0", + "build_number": 0, + "depends": [ + "anyio >=3.0.0,<4", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fff11af9573370ceb6e7e4cd8444ee90", + "name": "watchfiles", + "sha256": "2e5ebbd062be6b7c51c767a48e9b4c179e4b2408d1ebb074bb57b542036b8921", + "size": 1138176, + "subdir": "linux-64", + "timestamp": 1677830482864, + "version": "0.18.1" + }, + "watchfiles-0.18.1-py39h52d8a92_0.tar.bz2": { + "build": "py39h52d8a92_0", + "build_number": 0, + "depends": [ + "anyio >=3.0.0,<4", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "30d2bdce363816fe8771373f5cf257b5", + "name": "watchfiles", + "sha256": "ea8d083c08e80466fda3b144dfd5569879bbf557a305a5ee51656a1c4c1022cc", + "size": 1138527, + "subdir": "linux-64", + "timestamp": 1677830624215, + "version": "0.18.1" + }, + "wcwidth-0.1.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "de2b2c81d4b8043e913bd04e470c1f8a", + "name": "wcwidth", + "sha256": "9c0413b673039bc0a465b55f6b3fe7284ae9e6fb7947b420c66a23af29ef9ced", + "size": 25402, + "subdir": "linux-64", + "timestamp": 1530733740471, + "version": "0.1.7" + }, + "wcwidth-0.1.7-py27h9e3e1ab_0.tar.bz2": { + "build": "py27h9e3e1ab_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "a5ae2d8d2a4d7ac88bbde95f4501b01e", + "name": "wcwidth", + "sha256": "9082ce2419c3a1ae9ee103e33b4d6906b0ff55b75d7eca68cc6c9b934b8697e1", + "size": 25283, + "subdir": "linux-64", + "timestamp": 1505864079686, + "version": "0.1.7" + }, + "wcwidth-0.1.7-py35hcd08066_0.tar.bz2": { + "build": "py35hcd08066_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "8964832c7b5b53d2e44df2ad6e4900ba", + "name": "wcwidth", + "sha256": "feb752dd0b6f67bc06d56630dc06c6b85e0a3a51cb92eac01dd7740ca6cfc875", + "size": 25326, + "subdir": "linux-64", + "timestamp": 1505864091824, + "version": "0.1.7" + }, + "wcwidth-0.1.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "29f23b988aa7bff05d411e550668b4d6", + "name": "wcwidth", + "sha256": "e35aaf3df071ad6105a2660ad32f56f3f7e08cb3045346a9a9be0984c7520ebe", + "size": 25398, + "subdir": "linux-64", + "timestamp": 1530733720757, + "version": "0.1.7" + }, + "wcwidth-0.1.7-py36hdf4376a_0.tar.bz2": { + "build": "py36hdf4376a_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c45454e37a4024e4dccf0d855a974515", + "name": "wcwidth", + "sha256": "a01b3eafd73de3e98cc73c83811a313667f936a7ef53be5e3b828382e46a45da", + "size": 25277, + "subdir": "linux-64", + "timestamp": 1505864104033, + "version": "0.1.7" + }, + "wcwidth-0.1.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5eda000166f658ac0dcc8805fb2bd746", + "name": "wcwidth", + "sha256": "8588fd43cb248ae0792312c46c1059b5d3dadadd733ce79d54e25a12c899e37a", + "size": 23533, + "subdir": "linux-64", + "timestamp": 1530733760749, + "version": "0.1.7" + }, + "wcwidth-0.1.7-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "c10c08cc969b4fe96e31215f3394c97b", + "name": "wcwidth", + "sha256": "fe736f94cf254c689182125aae15e088c0711fd56677705d97bcef591d944d51", + "size": 24100, + "subdir": "linux-64", + "timestamp": 1572609159880, + "version": "0.1.7" + }, + "webencodings-0.5.1-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "deb443e4e59b213c04246bc8e7d0f07f", + "name": "webencodings", + "sha256": "3243c341406f5a7cce3552dfe81a4212147758be8e6df634e53af477847f1aa7", + "size": 19925, + "subdir": "linux-64", + "timestamp": 1530734107231, + "version": "0.5.1" + }, + "webencodings-0.5.1-py27hff10b21_1.tar.bz2": { + "build": "py27hff10b21_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ab5154345e701305f677f9cab7b2f650", + "name": "webencodings", + "sha256": "daa8561843ff568ea51262729f18fae15737dcee5586fedab56d673ac8aaec49", + "size": 19662, + "subdir": "linux-64", + "timestamp": 1505688679735, + "version": "0.5.1" + }, + "webencodings-0.5.1-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "49b82f30a2a45b2ce167a876cdc9e21c", + "name": "webencodings", + "sha256": "a375f3ad671266b27503b33f62ceaa7be112c0e47836e38a6c6a76225aff927d", + "size": 21391, + "subdir": "linux-64", + "timestamp": 1640795864430, + "version": "0.5.1" + }, + "webencodings-0.5.1-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a4c77e204b7787f820955166a1283168", + "name": "webencodings", + "sha256": "c3a5e0b855dc2de6c162708dfcf170a23eb9e7525d4252d8dce553369af4a330", + "size": 25890, + "subdir": "linux-64", + "timestamp": 1676823132898, + "version": "0.5.1" + }, + "webencodings-0.5.1-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2331b1ff14761661886f919b11b6330e", + "name": "webencodings", + "sha256": "bdf66da26922c54b24dd1df2c988b34d33bad03f8de0553c562f81f32694286e", + "size": 19902, + "subdir": "linux-64", + "timestamp": 1534350855539, + "version": "0.5.1" + }, + "webencodings-0.5.1-py35hb6cf162_1.tar.bz2": { + "build": "py35hb6cf162_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9b84b8370c3999767736272ff069797b", + "name": "webencodings", + "sha256": "8f9ed877451989a9a2e9a8e05a32daf4c4d5c1826a2e7280d218be7b2b8afbf8", + "size": 19811, + "subdir": "linux-64", + "timestamp": 1505688690700, + "version": "0.5.1" + }, + "webencodings-0.5.1-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "32050cbb6d7ed7ae30a46d7d180c2c48", + "name": "webencodings", + "sha256": "05352d40ecb389e3a6dff6e3c4778c644f7895af1044c8ac38dbb37ee8648741", + "size": 19616, + "subdir": "linux-64", + "timestamp": 1530734087663, + "version": "0.5.1" + }, + "webencodings-0.5.1-py36h800622e_1.tar.bz2": { + "build": "py36h800622e_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0d9274d975c10df3a64276dbb5a5d314", + "name": "webencodings", + "sha256": "41938bc19edba1e7936e8d574779d9f15495093fc654ebd8f9b2d07173b0eb18", + "size": 19419, + "subdir": "linux-64", + "timestamp": 1505688701757, + "version": "0.5.1" + }, + "webencodings-0.5.1-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ad7b6b14717396aab3e6263d9f22817a", + "name": "webencodings", + "sha256": "ba41760dd707714854a5548c6af4fc0133c8e5868dee0be6157199ca78de0c6d", + "size": 19650, + "subdir": "linux-64", + "timestamp": 1530734127084, + "version": "0.5.1" + }, + "webencodings-0.5.1-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "46be58263b91ea0ce41774c6cef974b7", + "name": "webencodings", + "sha256": "c6fd7f78c18396f22bde60d84004159a5398d7eaad14ab1b6f7550e9605e3616", + "size": 20211, + "subdir": "linux-64", + "timestamp": 1573200372707, + "version": "0.5.1" + }, + "webencodings-0.5.1-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f8d03a15b974fc7810d9f54ae849fc8e", + "name": "webencodings", + "sha256": "a32a1aa28f8927a9e6b9057fdf8426b83ee5d415ab005038b07ad4f3d1945173", + "size": 20781, + "subdir": "linux-64", + "timestamp": 1607365390528, + "version": "0.5.1" + }, + "webob-1.7.3-py27h7bd3e19_0.tar.bz2": { + "build": "py27h7bd3e19_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23c505bcc65197f0e4dfe28ef5f12d57", + "name": "webob", + "sha256": "c5e08e36810ce1b8d28a6a5c883bcbf6cce31cb23bd2531be2a3ec0376cf7478", + "size": 123835, + "subdir": "linux-64", + "timestamp": 1507962477657, + "version": "1.7.3" + }, + "webob-1.7.3-py35hf0121d3_0.tar.bz2": { + "build": "py35hf0121d3_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "583394c105b262a189491d8ca0bc781e", + "name": "webob", + "sha256": "3f74217397c17a8226144d415b548b9e612472380e4f577c6728d710660c5a71", + "size": 127600, + "subdir": "linux-64", + "timestamp": 1507962498904, + "version": "1.7.3" + }, + "webob-1.7.3-py36hb151027_0.tar.bz2": { + "build": "py36hb151027_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d5654230021d380a595e4eb559ce13b8", + "name": "webob", + "sha256": "7d10be3d9cad070e47f573d9c5dfec77682226e7894eb1c3fddac4b388edef0c", + "size": 127074, + "subdir": "linux-64", + "timestamp": 1507962506788, + "version": "1.7.3" + }, + "webob-1.7.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e66b44641524d62ade12e2e53eebd11", + "name": "webob", + "sha256": "adcfbd47eb9ffab9a05e2bf75cd5a45de082462132a32a477737179e962e0ded", + "size": 123876, + "subdir": "linux-64", + "timestamp": 1520781870641, + "version": "1.7.4" + }, + "webob-1.7.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fea0a19b971a3bb1806cc85bf72d0cc6", + "name": "webob", + "sha256": "5e983463c42e984b5422fde5af672594cdfd6ac3b432ff42700c678820ff5678", + "size": 127559, + "subdir": "linux-64", + "timestamp": 1520782162516, + "version": "1.7.4" + }, + "webob-1.7.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5c178013705d121caaae47222d60c34", + "name": "webob", + "sha256": "8575c6215cdffb72493350372a3c6327d3ae621b7421e56151d4a34225612a1b", + "size": 127093, + "subdir": "linux-64", + "timestamp": 1520781847931, + "version": "1.7.4" + }, + "webob-1.8.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bcacde8f473f3fe61e134942deacd1e4", + "name": "webob", + "sha256": "7862d9eecae9462d773c2106cbf35b92706571bb4d6fb0a96b2ee9a23c5876f0", + "size": 160866, + "subdir": "linux-64", + "timestamp": 1524070420433, + "version": "1.8.1" + }, + "webob-1.8.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "55e7ba4d2fcf5a0b4debe87a4b262db8", + "name": "webob", + "sha256": "f9f16ad0636a2bd8906e199d633646b910081fd2353df9eb8177f422f9f09398", + "size": 161018, + "subdir": "linux-64", + "timestamp": 1524070472280, + "version": "1.8.1" + }, + "webob-1.8.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0607feb5500cd10dcbd2813f89e32658", + "name": "webob", + "sha256": "d49ef31c877710e055eed0cb7e17c967aa74154770b617213e11ed8930f23498", + "size": 160506, + "subdir": "linux-64", + "timestamp": 1524070471759, + "version": "1.8.1" + }, + "webob-1.8.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f4d4526c03434c8920a0a006139a402", + "name": "webob", + "sha256": "c47138409f2b4d9c0c9fcdd99bb1199994fba8b6125792b35d08dcf7292ce726", + "size": 160749, + "subdir": "linux-64", + "timestamp": 1528985227683, + "version": "1.8.2" + }, + "webob-1.8.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cbdd40456e1f42128c640815a1188d42", + "name": "webob", + "sha256": "2da6930a14a0a7c448d2e517363033ba9e2298dca31bd8ab1b907170f4de46a5", + "size": 161236, + "subdir": "linux-64", + "timestamp": 1528985437152, + "version": "1.8.2" + }, + "webob-1.8.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d1918223789e6aed24dddd7793bb5bfa", + "name": "webob", + "sha256": "6a708ab041e3e3048fa75931599a5d32c4ee6ab2deb2a42d9b15d5187d2b9063", + "size": 160416, + "subdir": "linux-64", + "timestamp": 1528985281434, + "version": "1.8.2" + }, + "webob-1.8.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1aaf5a52ee8370cdaca6464a0643c3f4", + "name": "webob", + "sha256": "d8275f7e1f2318b872b77c8a84e9aeae0c48368eee0b8f232dda2722e1c2f735", + "size": 160498, + "subdir": "linux-64", + "timestamp": 1530814214692, + "version": "1.8.2" + }, + "webob-1.8.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c7f36bda61d4347e1faa27c9c3d936a1", + "name": "webob", + "sha256": "70cafa63def52095be09af8ffa7743a55e90270668e64becdecdc3ac8c91d88a", + "size": 165464, + "subdir": "linux-64", + "timestamp": 1539644751604, + "version": "1.8.3" + }, + "webob-1.8.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dad0880e35bce91ec544f497a01e1134", + "name": "webob", + "sha256": "3331bb596298b12e995b2532827c90863cc7ca88e7982afa7422aa2e48f8bea3", + "size": 163902, + "subdir": "linux-64", + "timestamp": 1539644771186, + "version": "1.8.3" + }, + "webob-1.8.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "30d905e021dcb9ef5471da2156a47899", + "name": "webob", + "sha256": "d977c5c540489232b55839a39c9b0d257d4733e386fdde5c1ae8e39d486ec829", + "size": 163996, + "subdir": "linux-64", + "timestamp": 1539644752232, + "version": "1.8.3" + }, + "webob-1.8.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "473e6562edfa3b68777557608d570a65", + "name": "webob", + "sha256": "cb57f503dd710218cb4cfee17af7c4a541b998e74f39705f61dc0ff6debdf73b", + "size": 166945, + "subdir": "linux-64", + "timestamp": 1542091731547, + "version": "1.8.4" + }, + "webob-1.8.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "03922bd480c848974ff6d549e0da2c9f", + "name": "webob", + "sha256": "3a16d997c3cbe2ced80e036e8aa50cad39fb664a51fe31beb8004e970bab583e", + "size": 164388, + "subdir": "linux-64", + "timestamp": 1542091708211, + "version": "1.8.4" + }, + "webob-1.8.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "005e21329770d520c4787a8d24a038de", + "name": "webob", + "sha256": "da1974432b3a2e0a891317c99c1cbec3bcedb8e3a4d1e1ac7003e4c66784db34", + "size": 164439, + "subdir": "linux-64", + "timestamp": 1542091668623, + "version": "1.8.4" + }, + "webob-1.8.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39e6815f9dc17eaa3cbf29b6a4fd82ad", + "name": "webob", + "sha256": "5eaf9b8819a0979d26c728b39c19434ba5fe9beca76609164bf580afc189c658", + "size": 167426, + "subdir": "linux-64", + "timestamp": 1547984486665, + "version": "1.8.5" + }, + "webob-1.8.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "224d63f6a2ceafaf25821561df18f3a1", + "name": "webob", + "sha256": "c7a56721a061a2b75e7ef65ab736cfb882852a5779ee27b81d05c044b63c7a8b", + "size": 166890, + "subdir": "linux-64", + "timestamp": 1547984553791, + "version": "1.8.5" + }, + "webob-1.8.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3626f00afb241b79e9b173ff90761be", + "name": "webob", + "sha256": "ef699f33f760d56cf03eb89141df73fe58299105afd5a2e27932b88b7c1017fe", + "size": 166988, + "subdir": "linux-64", + "timestamp": 1547984563696, + "version": "1.8.5" + }, + "websocket-client-0.54.0-py27_1000.tar.bz2": { + "build": "py27_1000", + "build_number": 1000, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "c1bc6489967f1fd81e4171e9cc693d05", + "name": "websocket-client", + "sha256": "1cb617d23688f9e5244d81f9315e1c614306aa135ed6367ae53114180cfa01e4", + "size": 60723, + "subdir": "linux-64", + "timestamp": 1545409838455, + "version": "0.54.0" + }, + "websocket-client-0.54.0-py36_1000.tar.bz2": { + "build": "py36_1000", + "build_number": 1000, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "8153de9b305a16cbfa0e3c1d2f9e43a9", + "name": "websocket-client", + "sha256": "b6cb3dbcb7eebc365f027292971c9ced6e02aad5a0b8e12901035f26faa53364", + "size": 62001, + "subdir": "linux-64", + "timestamp": 1545409866241, + "version": "0.54.0" + }, + "websocket-client-0.54.0-py37_1000.tar.bz2": { + "build": "py37_1000", + "build_number": 1000, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "605f230c4ce544fa20ae886ce7f3ef0e", + "name": "websocket-client", + "sha256": "61de4033cbca77dc7bbce7e4a55655f5b5c33b87bb3b15d0f62d76c7eebc7f07", + "size": 61883, + "subdir": "linux-64", + "timestamp": 1545409852761, + "version": "0.54.0" + }, + "websocket-client-0.55.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "c9c908aa1b36a0a81235c406fe8373a6", + "name": "websocket-client", + "sha256": "4ea6a148fb9360e725a28287165307d1518da90dddcb59f8d553d751a3059354", + "size": 61722, + "subdir": "linux-64", + "timestamp": 1552402291093, + "version": "0.55.0" + }, + "websocket-client-0.55.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "d4f27cf33b659541448b0368172f41eb", + "name": "websocket-client", + "sha256": "5dcab3b01a70178ec00545b007ede4b765b3b14e9f0a19ef2932a071b666223f", + "size": 62938, + "subdir": "linux-64", + "timestamp": 1552401218869, + "version": "0.55.0" + }, + "websocket-client-0.55.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "3b9bb0d926c13ea946f024703660918d", + "name": "websocket-client", + "sha256": "77bf662e10e33ec69019ca15accd21e2623792c74bec18cc858293c6e867020a", + "size": 62898, + "subdir": "linux-64", + "timestamp": 1552400982607, + "version": "0.55.0" + }, + "websocket-client-0.56.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "0a291979afafe71c601d49b75312e4de", + "name": "websocket-client", + "sha256": "4f1c00dc7751988a04ea5fcad1c5d8c568d170e88c602f6b2d340a2be8b1a5ec", + "size": 62016, + "subdir": "linux-64", + "timestamp": 1556112334597, + "version": "0.56.0" + }, + "websocket-client-0.56.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "3f307480f0a0aacc98d287881e95a849", + "name": "websocket-client", + "sha256": "7b4abfe0d5350a554699cc0b227e1847b20b2cb9363cc4c162bd2faded4f4499", + "size": 63180, + "subdir": "linux-64", + "timestamp": 1556088519424, + "version": "0.56.0" + }, + "websocket-client-0.56.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "5fd924fac4e410ab4611a8b368ffbabb", + "name": "websocket-client", + "sha256": "ecd1ef8e3a6361227afb583c7914644ea2bab35ef724ee6d24f179f8a0b0586e", + "size": 63220, + "subdir": "linux-64", + "timestamp": 1556088462031, + "version": "0.56.0" + }, + "websocket-client-0.56.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "8dbb90eb04d80ca5f3fa6ac1a469fb0f", + "name": "websocket-client", + "sha256": "fe7135cd04fe48cd8cf7eec41e6050ef749cc4f45a4de6e12a76b50e60de95a9", + "size": 60266, + "subdir": "linux-64", + "timestamp": 1574437317637, + "version": "0.56.0" + }, + "websocket-client-0.57.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "c075caf746f7bcc2ff19cc93cdb51f1b", + "name": "websocket-client", + "sha256": "b7e63a49da0ba50c4e1fe7782d8e1968ca27be36f1e0eea4288abec558de0941", + "size": 64580, + "subdir": "linux-64", + "timestamp": 1587391568308, + "version": "0.57.0" + }, + "websocket-client-0.57.0-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d1152751a5402f2d80527b9720729c46", + "name": "websocket-client", + "sha256": "0e55eff5ff4c9502f6a6dd1adc400139c914190543ef286c482e9b7c7716da75", + "size": 60456, + "subdir": "linux-64", + "timestamp": 1602006598338, + "version": "0.57.0" + }, + "websocket-client-0.57.0-py36h06a4308_1.tar.bz2": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "766e4df094ab0b5be0a74ea0cb6b709e", + "name": "websocket-client", + "sha256": "ffe88de90cd1f9c094fb104980db3b869aee2027a0f9e3d5c18cb3a785858a19", + "size": 64804, + "subdir": "linux-64", + "timestamp": 1613159636034, + "version": "0.57.0" + }, + "websocket-client-0.57.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "87e0c81b6f90fa0962dd76b9132314ab", + "name": "websocket-client", + "sha256": "fc6016549028f9c336a254850f6ce0037b6282245266f66a8c8fab7b1bc5feaa", + "size": 64470, + "subdir": "linux-64", + "timestamp": 1587391571193, + "version": "0.57.0" + }, + "websocket-client-0.57.0-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f15ac817c3624534b987cf075c894740", + "name": "websocket-client", + "sha256": "85b09d3b29a92e9a3af4033ad6d456467e61916bf0abb5fd304e93beb19355dd", + "size": 60519, + "subdir": "linux-64", + "timestamp": 1602006619791, + "version": "0.57.0" + }, + "websocket-client-0.57.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "9740b8e8e3b7a64f852e2cd50699b72c", + "name": "websocket-client", + "sha256": "8543ac14d3d4f4fb7b073ad36de87260b4688c89731572005697cdc7f2958014", + "size": 64687, + "subdir": "linux-64", + "timestamp": 1613159313791, + "version": "0.57.0" + }, + "websocket-client-0.57.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "4da4c25b0bd80c0129223e2603af49e5", + "name": "websocket-client", + "sha256": "53146c1c07c717a08972d9fafc964701b56a4561b67850b93e09f1e0bbfdf8a1", + "size": 64694, + "subdir": "linux-64", + "timestamp": 1587391688925, + "version": "0.57.0" + }, + "websocket-client-0.57.0-py38_2.tar.bz2": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1639aab373c52dfe0605c79bf0a2ad65", + "name": "websocket-client", + "sha256": "55fabe9a0576565426192e118f09539bee6c3fd26a3b55c460fddfaed745c168", + "size": 60790, + "subdir": "linux-64", + "timestamp": 1602006616442, + "version": "0.57.0" + }, + "websocket-client-0.57.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "fb6a881c4184cb82a5ff2dd18f3d0177", + "name": "websocket-client", + "sha256": "41cdbfee6b62ef7db36645327e40fe58f2d899e522605943fa47d59a4b5107c4", + "size": 64933, + "subdir": "linux-64", + "timestamp": 1613159627551, + "version": "0.57.0" + }, + "websocket-client-0.57.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "4adfe280bd0191f34cfe00f5c27410a4", + "name": "websocket-client", + "sha256": "a09e8bf4358c88fc629ac8e704268f197bbdcd3703bc7421aadee889b689b82f", + "size": 64957, + "subdir": "linux-64", + "timestamp": 1613159170421, + "version": "0.57.0" + }, + "websocket-client-0.58.0-py310h06a4308_4.tar.bz2": { + "build": "py310h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bcd8414adfe572fc3d04850d1fae2845", + "name": "websocket-client", + "sha256": "7e971edc178e66023da0a1c6e35536806a3b77e50273392e2edf8ce0d0328064", + "size": 71305, + "subdir": "linux-64", + "timestamp": 1640795883083, + "version": "0.58.0" + }, + "websocket-client-0.58.0-py311h06a4308_4.tar.bz2": { + "build": "py311h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07dc61e2e59fe57a9bfe8efcbb23ffe6", + "name": "websocket-client", + "sha256": "7b505fdb5d801adfb3032e2541bf9bf17ed2238764b7a53cb845e33e7f835faf", + "size": 90518, + "subdir": "linux-64", + "timestamp": 1676824901641, + "version": "0.58.0" + }, + "websocket-client-0.58.0-py36h06a4308_4.tar.bz2": { + "build": "py36h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "927e28e3e32f36cb44e8ec2d9d09c278", + "name": "websocket-client", + "sha256": "408a9522417a01d459d0ad8cfc03d28133895a4b465bc7631f86303e152c4af1", + "size": 70769, + "subdir": "linux-64", + "timestamp": 1614804296961, + "version": "0.58.0" + }, + "websocket-client-0.58.0-py37h06a4308_4.tar.bz2": { + "build": "py37h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6d04d473afcbfb6ef7ff4e6b2e502983", + "name": "websocket-client", + "sha256": "e43b1004770b44a6a21fc74a6f9813f3a6648ad1a820eb49ebb30ac960248331", + "size": 70653, + "subdir": "linux-64", + "timestamp": 1614804295414, + "version": "0.58.0" + }, + "websocket-client-0.58.0-py38h06a4308_4.tar.bz2": { + "build": "py38h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8ea9442d80b018f9d1bcac1e59469232", + "name": "websocket-client", + "sha256": "14ffa5f5ce2a18bc7b59c1157c9a61db6c3af83adf5d7b7f386681dfd7571524", + "size": 70872, + "subdir": "linux-64", + "timestamp": 1614804298366, + "version": "0.58.0" + }, + "websocket-client-0.58.0-py39h06a4308_4.tar.bz2": { + "build": "py39h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d7db5d6ce1db80eade8a082ff78bf479", + "name": "websocket-client", + "sha256": "3f3ed61beaf5939afe7ec80af940b5d4dc316f90e32b1528f53e49546378d389", + "size": 71044, + "subdir": "linux-64", + "timestamp": 1614804011510, + "version": "0.58.0" + }, + "websockets-10.4-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e5f75488265a6f2aa04d81b170322b37", + "name": "websockets", + "sha256": "e6e555d842161841aca5c548da482e0ea006d981d0da8aed0e18f2c018d2af1c", + "size": 128309, + "subdir": "linux-64", + "timestamp": 1677830227959, + "version": "10.4" + }, + "websockets-10.4-py310h5eee18b_1.tar.bz2": { + "build": "py310h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7ed9a900cc1519901ab5a5d9157496e8", + "name": "websockets", + "sha256": "83fc1e93c3507f9370ee0c8dee3ce0426440348bbface4392976fc705305c0fb", + "size": 128864, + "subdir": "linux-64", + "timestamp": 1678966827747, + "version": "10.4" + }, + "websockets-10.4-py311h5eee18b_1.tar.bz2": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0d94e3484b2898e9713af75ae07f04c2", + "name": "websockets", + "sha256": "fc98fa0e942e8258497b04384d4808a6646b62e7c0d17d308dd39b8c6022dfda", + "size": 161495, + "subdir": "linux-64", + "timestamp": 1678966883211, + "version": "10.4" + }, + "websockets-10.4-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d74eeaf7d84aaf8e748b441766dd3495", + "name": "websockets", + "sha256": "40ca122ab8dc242bb23c4022e968bd4617a2a35dcaadef7fce97d761759748c2", + "size": 126816, + "subdir": "linux-64", + "timestamp": 1677830282802, + "version": "10.4" + }, + "websockets-10.4-py38h5eee18b_1.tar.bz2": { + "build": "py38h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7389e8a2145a03c27a4f756a7cd7d12c", + "name": "websockets", + "sha256": "281e761152438768717dc6413529615d677aca780062996b59dd1aefc5dadd6a", + "size": 126800, + "subdir": "linux-64", + "timestamp": 1678966855198, + "version": "10.4" + }, + "websockets-10.4-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "65af250506773902cc8df85f8673ad5f", + "name": "websockets", + "sha256": "504d32a7691b6fb0283ffde693de64f181d15e19b47a0b31206bc17094c4534c", + "size": 126952, + "subdir": "linux-64", + "timestamp": 1677830256465, + "version": "10.4" + }, + "websockets-10.4-py39h5eee18b_1.tar.bz2": { + "build": "py39h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "de71db2c739b1d49f59e0bce9b99085e", + "name": "websockets", + "sha256": "aec0363bd8961a2eb04af514746b64ddf4bed35ac52a3f5ca9af8bd5d3ecab54", + "size": 127329, + "subdir": "linux-64", + "timestamp": 1678966910133, + "version": "10.4" + }, + "webtest-2.0.29-py27h0360dea_0.tar.bz2": { + "build": "py27h0360dea_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=2.7,<2.8.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "4e8fc8a821f499adcbe2216ff8a0ee26", + "name": "webtest", + "sha256": "17e9334802ec2d4d3151592feb71b7e2f65889fb7abebf343b2ac7f2c894bd70", + "size": 70973, + "subdir": "linux-64", + "timestamp": 1509401289839, + "version": "2.0.29" + }, + "webtest-2.0.29-py35h2d26cb8_0.tar.bz2": { + "build": "py35h2d26cb8_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.5,<3.6.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "f02a1d07fbafb76e11b58b972406455c", + "name": "webtest", + "sha256": "d857b9328c0073240a1be1d2e757bc2f79e81f5d20069f57dfd08aae5382abfa", + "size": 72106, + "subdir": "linux-64", + "timestamp": 1509401293729, + "version": "2.0.29" + }, + "webtest-2.0.29-py36h291c265_0.tar.bz2": { + "build": "py36h291c265_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.6,<3.7.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "ca8c48d17ca2c5593f4402dbc3e859f8", + "name": "webtest", + "sha256": "d8f577b01a70d2918928b3be745141b62d1ac0391c241b48177cbc4916efc3ef", + "size": 71442, + "subdir": "linux-64", + "timestamp": 1509401296617, + "version": "2.0.29" + }, + "webtest-2.0.30-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=2.7,<2.8.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "30222bb4ab7ec4a8596ade3b2999a146", + "name": "webtest", + "sha256": "8fff2d7e8533653668f6e8c25be1cf7a7c528595272f75b6a2fcb547cb417e33", + "size": 70886, + "subdir": "linux-64", + "timestamp": 1529954667951, + "version": "2.0.30" + }, + "webtest-2.0.30-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.5,<3.6.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "be46f77d4df0e55b01d7833a4f490ec2", + "name": "webtest", + "sha256": "92aa6c15901eae8a7b6c000dd98208f1a71ff70455c60409c4e35736a5bcc1b3", + "size": 71967, + "subdir": "linux-64", + "timestamp": 1529954683700, + "version": "2.0.30" + }, + "webtest-2.0.30-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.6,<3.7.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "907ed53c914f89cf4b49aed5e4a7f3ed", + "name": "webtest", + "sha256": "5bcf09e83ac3e33cb719f23e327bd819ab5420dde462b541ac550735c406e6c5", + "size": 71261, + "subdir": "linux-64", + "timestamp": 1529954641267, + "version": "2.0.30" + }, + "webtest-2.0.30-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.7,<3.8.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "03a840f97aca55b1588850479910382c", + "name": "webtest", + "sha256": "67609085688668e499c9d46a76ed37a25063b2e28382afb0be3d12b0a24c30dc", + "size": 71230, + "subdir": "linux-64", + "timestamp": 1530875751288, + "version": "2.0.30" + }, + "webtest-2.0.32-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=2.7,<2.8.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "3bdcd7e10626cd669f542f45aabe5588", + "name": "webtest", + "sha256": "48752794559aea5657482ad1737a39db12479e728f0e75779834dd0092f7c492", + "size": 71167, + "subdir": "linux-64", + "timestamp": 1539648295155, + "version": "2.0.32" + }, + "webtest-2.0.32-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.6,<3.7.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "ff2ea6326d9821a00ecd69085bee8872", + "name": "webtest", + "sha256": "ebd7f7ccdab3fc3de7001de0ed663d84230ca75f0c5756eab53295342e26b6e7", + "size": 71603, + "subdir": "linux-64", + "timestamp": 1539648300405, + "version": "2.0.32" + }, + "webtest-2.0.32-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.7,<3.8.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "9f17cbefd04e332212d40b8417ca32a9", + "name": "webtest", + "sha256": "6da043ca0f4fa2ce0066828dd80de89f1e45427d465099c6148df7b5f84f876b", + "size": 71496, + "subdir": "linux-64", + "timestamp": 1539648303295, + "version": "2.0.32" + }, + "webtest-2.0.33-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=2.7,<2.8.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "6b445c2f9a7dcc86c8faa967f65311c9", + "name": "webtest", + "sha256": "0e8544762605078791e5ca10b3a798e4653595c38594866bdd092896d5e75a8f", + "size": 213555, + "subdir": "linux-64", + "timestamp": 1552372051897, + "version": "2.0.33" + }, + "webtest-2.0.33-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.10,<3.11.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "96f1cd255ef3d3692a37a602ae5d9f4b", + "name": "webtest", + "sha256": "3c86176aa3f94dea94da7c83526b528d6a9155d197f6ca30e08d9bcceaa1c790", + "size": 73373, + "subdir": "linux-64", + "timestamp": 1640795901135, + "version": "2.0.33" + }, + "webtest-2.0.33-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.11,<3.12.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "d4783503efa9730a3bd9bbc0152cf677", + "name": "webtest", + "sha256": "c98bac512b1875a1f5727d79302621de9d2cf338b59c36e115ebd3d73214f5d1", + "size": 92537, + "subdir": "linux-64", + "timestamp": 1676907755082, + "version": "2.0.33" + }, + "webtest-2.0.33-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.6,<3.7.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "591fe9575ad7c55ae09ad119518a12cc", + "name": "webtest", + "sha256": "002a0fa7d01cfba03061930f5ced65080143eafd2d9af6bfd3c4ef3164290695", + "size": 213689, + "subdir": "linux-64", + "timestamp": 1552372111203, + "version": "2.0.33" + }, + "webtest-2.0.33-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.6,<3.7.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "2034737f962c855b96985da9db583c96", + "name": "webtest", + "sha256": "d8542fe83d390578455f9574c4e2b6d8178faccb065b2857907075a00ae23a77", + "size": 297683, + "subdir": "linux-64", + "timestamp": 1613158710226, + "version": "2.0.33" + }, + "webtest-2.0.33-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.7,<3.8.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "943eadd79e0c11894a2dfb165ee66708", + "name": "webtest", + "sha256": "dc7ab0fe925730d25660696bca18ff72c47c553bcc11214ae352b48c70acecd9", + "size": 211693, + "subdir": "linux-64", + "timestamp": 1552372032700, + "version": "2.0.33" + }, + "webtest-2.0.33-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.7,<3.8.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "79c1444dceebf92dfeee87093ce556d1", + "name": "webtest", + "sha256": "ad0cb41be607a4e6dd500fdb7c62375fdbb14b6eff667ab97af4c438b850cfe4", + "size": 297693, + "subdir": "linux-64", + "timestamp": 1613159166028, + "version": "2.0.33" + }, + "webtest-2.0.33-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.8,<3.9.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "990436769b0e343494c9fc994a6583a3", + "name": "webtest", + "sha256": "5bf932dc2098fcad3f2ca3edc6e0e6bf5e14081a8a7e83e4dfbcfcd4775f4a00", + "size": 72411, + "subdir": "linux-64", + "timestamp": 1574437335273, + "version": "2.0.33" + }, + "webtest-2.0.33-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.8,<3.9.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "a9452cbaf9766901dd7847979168abab", + "name": "webtest", + "sha256": "ba03e355ee09ed5e659782ebbb5f280c845fdbed89f5a8a5757efda11fc0be0b", + "size": 289956, + "subdir": "linux-64", + "timestamp": 1613158896872, + "version": "2.0.33" + }, + "webtest-2.0.33-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.9,<3.10.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "093a7b6a701dd781b68bee15a9f3a1d8", + "name": "webtest", + "sha256": "74c8bc90dde8e5375403ca324c7e80adbdb8fe2ba3cf879e4a866c5862e35df4", + "size": 296852, + "subdir": "linux-64", + "timestamp": 1613163233534, + "version": "2.0.33" + }, + "werkzeug-0.12.2-py27hbf75dff_0.tar.bz2": { + "build": "py27hbf75dff_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c4ed50a23fcad257667e367a12460fad", + "name": "werkzeug", + "sha256": "571dfb9e5f0bbb3d83103709b922cde2ca0c37ffa6cb0d71e0314af00afffce4", + "size": 417863, + "subdir": "linux-64", + "timestamp": 1505740357794, + "version": "0.12.2" + }, + "werkzeug-0.12.2-py35hbfc1ea6_0.tar.bz2": { + "build": "py35hbfc1ea6_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1e39d67f9790263ac1e322939e4ef1b4", + "name": "werkzeug", + "sha256": "7972f4838ffcae8f7a35431bdcc9184cb21d8ae74953d860c87f2e95659b5532", + "size": 424828, + "subdir": "linux-64", + "timestamp": 1505740372988, + "version": "0.12.2" + }, + "werkzeug-0.12.2-py36hc703753_0.tar.bz2": { + "build": "py36hc703753_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e323c692c6034daf4eeb1228b9666b31", + "name": "werkzeug", + "sha256": "bbdf5250caad82fa4694f31dd16dade63017d754c7f7ee64c5d174a580c6a64a", + "size": 422973, + "subdir": "linux-64", + "timestamp": 1505740388434, + "version": "0.12.2" + }, + "werkzeug-0.14.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9a3d62d3ad85203420418542057e8683", + "name": "werkzeug", + "sha256": "69dc2df5444290ad8b465628463cbe32093e099704713fe55cdde61164b7c36e", + "size": 428663, + "subdir": "linux-64", + "timestamp": 1515709497669, + "version": "0.14.1" + }, + "werkzeug-0.14.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d5e7c8337badd5e4228bb27f9603852d", + "name": "werkzeug", + "sha256": "4610fd660da438d2dd355dad47488679d02966f0418181ffed846e8fb402354a", + "size": 436634, + "subdir": "linux-64", + "timestamp": 1515709624608, + "version": "0.14.1" + }, + "werkzeug-0.14.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7f013f2377f75deb512f4c54a92ce4f8", + "name": "werkzeug", + "sha256": "b1f9d96e090d002ef1827373aaf3157fbbe8ee584e8d2ceccdc5e68454b6cad9", + "size": 433481, + "subdir": "linux-64", + "timestamp": 1515709387120, + "version": "0.14.1" + }, + "werkzeug-0.14.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "800ce77b89fce2580288947ff677540c", + "name": "werkzeug", + "sha256": "c4eeccabac7754b0fdc66439c4e5e69d753c6b0e5931632c96f330a04654834a", + "size": 433408, + "subdir": "linux-64", + "timestamp": 1530771750607, + "version": "0.14.1" + }, + "werkzeug-2.2.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.1.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3eb416974eb2ecc68de8e30d1c4dd3e0", + "name": "werkzeug", + "sha256": "4d76a362821874ab5d460b581a2d3f5ba0348222ea8573c9cfe45d66bc3e7b5f", + "size": 370113, + "subdir": "linux-64", + "timestamp": 1671216052927, + "version": "2.2.2" + }, + "werkzeug-2.2.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.1.1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1b7640f9b44365c27d690011c1b9a04", + "name": "werkzeug", + "sha256": "e0d07e7301a1970cba2d87236fe04b0e8b299967991ac3d4182011ee9be72b39", + "size": 470516, + "subdir": "linux-64", + "timestamp": 1676826930304, + "version": "2.2.2" + }, + "werkzeug-2.2.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.1.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1bff24dfebd723a70f068ec50ebcef75", + "name": "werkzeug", + "sha256": "6f10d3403e7f61db83035945b80083a7ce1bd59e4ce504f9cc05fe0796d5ce64", + "size": 363548, + "subdir": "linux-64", + "timestamp": 1671216026726, + "version": "2.2.2" + }, + "werkzeug-2.2.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.1.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "840c05bbb9a964a698561121d1ae9456", + "name": "werkzeug", + "sha256": "a5245f5aef2a7d58cd9e75c803ba164e5d37dd06a1590eeec93400d10d9eb24c", + "size": 365339, + "subdir": "linux-64", + "timestamp": 1671216104791, + "version": "2.2.2" + }, + "werkzeug-2.2.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.1.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "69fa2b9a92eb0b015345c97b553e846f", + "name": "werkzeug", + "sha256": "168d1d97d8e5ea2b5e98f879da1964d1c2e5f65f0aa9d82009ba5f3b85c97016", + "size": 365264, + "subdir": "linux-64", + "timestamp": 1671216078867, + "version": "2.2.2" + }, + "werkzeug-2.2.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.1.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2eec1110caf2ab5b4f1c452084a89e27", + "name": "werkzeug", + "sha256": "a8896f54cc2d104109fb308725fd7cd37d7d59a18d669be70b9c3218fb92c0af", + "size": 375778, + "subdir": "linux-64", + "timestamp": 1679489749077, + "version": "2.2.3" + }, + "werkzeug-2.2.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.1.1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a8f10106d152b552a9c9afaf6ead7b44", + "name": "werkzeug", + "sha256": "c1c12d650e845ccb1acd353355c9902512ee3cf7594059148d80a211ba8b60a7", + "size": 471078, + "subdir": "linux-64", + "timestamp": 1679489775331, + "version": "2.2.3" + }, + "werkzeug-2.2.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.1.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3a740b5c7f5e89fabd6d123be3adb3e0", + "name": "werkzeug", + "sha256": "c779c93b3b0ad552bf2fd6b5655aa6693c70def0e6b41d64ed7b3837387966d6", + "size": 369745, + "subdir": "linux-64", + "timestamp": 1679489824958, + "version": "2.2.3" + }, + "werkzeug-2.2.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.1.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7039edf48d376ae05ea01cea961ffc1d", + "name": "werkzeug", + "sha256": "ec797b97bd8853c8b4634965195419cc374ca517a55fad0bf003603ff72fe8f1", + "size": 371715, + "subdir": "linux-64", + "timestamp": 1679489799965, + "version": "2.2.3" + }, + "wget-1.19.1-he4ec0ba_0.tar.bz2": { + "build": "he4ec0ba_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL3", + "md5": "81564faf3cce80d10a585604068c727c", + "name": "wget", + "sha256": "dae059b6d7a22cc489e5d92fd26ef0bda549af0c31b56c93192f307b1e92e3b1", + "size": 766109, + "subdir": "linux-64", + "timestamp": 1505742567028, + "version": "1.19.1" + }, + "wget-1.19.4-hf388c53_0.tar.bz2": { + "build": "hf388c53_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL3", + "md5": "e36bef042ebc2486c4ff81be4f6d9668", + "name": "wget", + "sha256": "0bd6fe61fc91fbbd9bdff2cd35663403f8276d84c6efad65ce57411c00824f6f", + "size": 746632, + "subdir": "linux-64", + "timestamp": 1524178863272, + "version": "1.19.4" + }, + "wget-1.19.5-h1ad7b7a_0.tar.bz2": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL3", + "md5": "7fd406921533468c258181b2af207a94", + "name": "wget", + "sha256": "a6deb66b02e172c12e95bcbf87670e99584f964f0d878591a9562f392817f65c", + "size": 744113, + "subdir": "linux-64", + "timestamp": 1527641585318, + "version": "1.19.5" + }, + "wget-1.19.5-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL3", + "md5": "be6393b471b0e853000a5d3eafce063f", + "name": "wget", + "sha256": "f69af7eca0dfe396c78548dd79e96fbaaa4e3fa8282d0209770a1ed994cc0d54", + "size": 752989, + "subdir": "linux-64", + "timestamp": 1540583242074, + "version": "1.19.5" + }, + "wget-1.20.1-h20c2e04_0.tar.bz2": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1b,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL3", + "md5": "8c3cafd4002f0f672b1f9132957bc879", + "name": "wget", + "sha256": "6399ff247d36cb6f131e6b960d7ed433822eb30f484d78fc7c7696ea60637780", + "size": 915506, + "subdir": "linux-64", + "timestamp": 1551978000266, + "version": "1.20.1" + }, + "wget-1.21.3-h0b77cf5_0.tar.bz2": { + "build": "h0b77cf5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libidn2 >=2,<3.0a0", + "openssl >=1.1.1n,<1.1.2a", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "2a3a62043687d06172619dd7e89ab6c9", + "name": "wget", + "sha256": "b8bb6dbb572a1199c7a90e56156a0ac349b71c8edb02b050a86d174ad2331f47", + "size": 837571, + "subdir": "linux-64", + "timestamp": 1650648190870, + "version": "1.21.3" + }, + "whatthepatch-1.0.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f29386f314bf7ced10deb8c9fceb470", + "name": "whatthepatch", + "sha256": "dcf6fc5c6ace176221d573d09884c59f717354a392a12bb3a589d40acf486400", + "size": 22672, + "subdir": "linux-64", + "timestamp": 1661796035744, + "version": "1.0.2" + }, + "whatthepatch-1.0.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3eabd88a3e1d64ec8030b60b06ed891", + "name": "whatthepatch", + "sha256": "a351b600f8cc9eebdcffb00c1a7861b992f008a6c7f3ce7b5f19fbba7c6b6d3e", + "size": 29471, + "subdir": "linux-64", + "timestamp": 1677708403592, + "version": "1.0.2" + }, + "whatthepatch-1.0.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2127f0c91270c40a5274ba0a83fcd1b1", + "name": "whatthepatch", + "sha256": "33f1e5a9b7b6cdf17c7d6c2e3d81b5afb61e414185fa5e0a927d1566fef38307", + "size": 22498, + "subdir": "linux-64", + "timestamp": 1661796116198, + "version": "1.0.2" + }, + "whatthepatch-1.0.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b63ae65c1ffc0e279c86f9c62f504393", + "name": "whatthepatch", + "sha256": "5b4341507001127417a47d094e59301986ec952c558f7778ffb5ae3e276ef0eb", + "size": 22388, + "subdir": "linux-64", + "timestamp": 1661796061723, + "version": "1.0.2" + }, + "whatthepatch-1.0.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a935b75da92d6283a3c629c72a76bb1", + "name": "whatthepatch", + "sha256": "f01fbcd36489fbc1d6e31316e4ffcc090bd71c5ed55d08a362f36a9b8414d8bf", + "size": 22518, + "subdir": "linux-64", + "timestamp": 1661796090170, + "version": "1.0.2" + }, + "wheel-0.29.0-py27h411dd7b_1.tar.bz2": { + "build": "py27h411dd7b_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "3cddb4a59b117098a9ebc4157f54f3a1", + "name": "wheel", + "sha256": "5ee4654df95fe87782240c5fe52feb0b701df3e4ab4a3fe0cb3d314d26ec7f2b", + "size": 89253, + "subdir": "linux-64", + "timestamp": 1505671888349, + "version": "0.29.0" + }, + "wheel-0.29.0-py35h601ca99_1.tar.bz2": { + "build": "py35h601ca99_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "4e875ace91954cfca9b678b2c243c990", + "name": "wheel", + "sha256": "c9ab1df7578cfb7e064427d7c108e6587e124fcc04e049d69eb7c367935c6e77", + "size": 90513, + "subdir": "linux-64", + "timestamp": 1505671897680, + "version": "0.29.0" + }, + "wheel-0.29.0-py36he7f4e38_1.tar.bz2": { + "build": "py36he7f4e38_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "d5e8a04bf8cd765f5bc805ba04cbb08f", + "name": "wheel", + "sha256": "7e7cfa50843564822abfd4448c887bc6561a68d29af5800601b3af7d1bdd4d6b", + "size": 90320, + "subdir": "linux-64", + "timestamp": 1505671907011, + "version": "0.29.0" + }, + "wheel-0.30.0-py27h2bc6bb2_1.tar.bz2": { + "build": "py27h2bc6bb2_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "195ca6efe6f1c45e1a610c5eea089191", + "name": "wheel", + "sha256": "72edfc36f2aa7bcf8fd88abd5b18173917035ab89edaa7a1ffa80308632e507c", + "size": 67653, + "subdir": "linux-64", + "timestamp": 1511280523138, + "version": "0.30.0" + }, + "wheel-0.30.0-py35hd3883cf_1.tar.bz2": { + "build": "py35hd3883cf_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "fd7a104dd49338e1c810bc3edcdac1a1", + "name": "wheel", + "sha256": "c38043cae7ad79543eb2982b70e375e490ba1b8125c341bfc5c511ceed8832ea", + "size": 68812, + "subdir": "linux-64", + "timestamp": 1511280527186, + "version": "0.30.0" + }, + "wheel-0.30.0-py36hfd4bba0_1.tar.bz2": { + "build": "py36hfd4bba0_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "f54cd176f02a102fdf2dfd49402e7c8f", + "name": "wheel", + "sha256": "9fdd5f4277c85c2aef56994324e064de34c66dec24c3467deeaabecd03a43038", + "size": 68633, + "subdir": "linux-64", + "timestamp": 1511280516538, + "version": "0.30.0" + }, + "wheel-0.31.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "5410b58ff849f0b8c6c1dd63bff9488b", + "name": "wheel", + "sha256": "0b13b49c18b6a0357a9eae63d31d7300493d995dcde2a7e692ece568b05ba068", + "size": 62954, + "subdir": "linux-64", + "timestamp": 1522684041101, + "version": "0.31.0" + }, + "wheel-0.31.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "94f3fdc6ec29cf956c5a616beea56b78", + "name": "wheel", + "sha256": "8c1f4b32c3c01ab9af55ce6a58e2e2b51e56d1578e2b9f8bcec3639787d7b580", + "size": 63913, + "subdir": "linux-64", + "timestamp": 1522684071973, + "version": "0.31.0" + }, + "wheel-0.31.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "e90067612fc1560cbb5f8ad643add936", + "name": "wheel", + "sha256": "36b8999f4f093de9c9186e69f24b48d259b021e28479b12599f093c798cf50c8", + "size": 63720, + "subdir": "linux-64", + "timestamp": 1522684072712, + "version": "0.31.0" + }, + "wheel-0.31.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "f10863022d161f7a9c7d07b5b18b87ba", + "name": "wheel", + "sha256": "7891758870a318d3ed1b15a32750fc86efab50e1b1c93ccc1bebf925429ef960", + "size": 62985, + "subdir": "linux-64", + "timestamp": 1526403243190, + "version": "0.31.1" + }, + "wheel-0.31.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "59262e13e8850fd9c62d5fd0a627b06c", + "name": "wheel", + "sha256": "a4666a2127c3ba6a770654a495920504cbeb2f70a18f63cb5e70b3d7527ebf4e", + "size": 64002, + "subdir": "linux-64", + "timestamp": 1526403262983, + "version": "0.31.1" + }, + "wheel-0.31.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "da44783fa5642c6b0de3fc3c43c98c36", + "name": "wheel", + "sha256": "e3e137c394c5a99214016abad909adce422acc18829adde8d0dec6029aef21aa", + "size": 63778, + "subdir": "linux-64", + "timestamp": 1526403202821, + "version": "0.31.1" + }, + "wheel-0.31.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "8b45a7024ceaad98e4b15b965afa6913", + "name": "wheel", + "sha256": "47756ab345589387cc566f8a80227dbe19b1d1fa1a7ccdf3a4753c20e0fa54e8", + "size": 63601, + "subdir": "linux-64", + "timestamp": 1530212714978, + "version": "0.31.1" + }, + "wheel-0.32.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "43505b6719b71d89f751e59b8bd4bea8", + "name": "wheel", + "sha256": "d8ba39d813990e880262a0bc7353524dc3f59f067799f6f9da24e173a8e4ed76", + "size": 35182, + "subdir": "linux-64", + "timestamp": 1538587175463, + "version": "0.32.0" + }, + "wheel-0.32.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "e34f2ca56e7236131e116ad832324b06", + "name": "wheel", + "sha256": "fb41a62d2611ae81fea5c0cea58deaccfdc7d6e4249070f0eeead95017d238a9", + "size": 35573, + "subdir": "linux-64", + "timestamp": 1538587183029, + "version": "0.32.0" + }, + "wheel-0.32.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "5d2ecee6942e2a37f5593a72fd721a63", + "name": "wheel", + "sha256": "f97ad6debbdc9147521799caadd18049f650e33b04a4f0abff8ee7e8981d171a", + "size": 35490, + "subdir": "linux-64", + "timestamp": 1538587164804, + "version": "0.32.0" + }, + "wheel-0.32.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "9dfd2eb8dd5f3a4a681ac0bf24f780c6", + "name": "wheel", + "sha256": "ad3908f80d4ac6d72be3526605e254ab26cc7ab7ec875c8779b4ec8ceb441f46", + "size": 35398, + "subdir": "linux-64", + "timestamp": 1539024068583, + "version": "0.32.1" + }, + "wheel-0.32.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "5b293670ac4721d0bd539360600966f2", + "name": "wheel", + "sha256": "1f630d4bc10bacdbdbd1c9ad8041294d54874739efd15761028995308a9c318b", + "size": 35745, + "subdir": "linux-64", + "timestamp": 1539024082766, + "version": "0.32.1" + }, + "wheel-0.32.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "48200ff54e0d3b0d0cf0e70a444a2cbd", + "name": "wheel", + "sha256": "ecfd7c22b4256b25d16ef258a761a911002633010b4140a5a894955126c33416", + "size": 35643, + "subdir": "linux-64", + "timestamp": 1539024030399, + "version": "0.32.1" + }, + "wheel-0.32.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "5faeb7765d6c6c2ae4799ca758e0b1e3", + "name": "wheel", + "sha256": "d95392a9ed2ade269a822fa0e5a8f87c9e9526b046e8aa0bc5d9ebdd18e4715e", + "size": 35379, + "subdir": "linux-64", + "timestamp": 1540228737560, + "version": "0.32.2" + }, + "wheel-0.32.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "7cc94a4f626dbe85061f619e6f501450", + "name": "wheel", + "sha256": "bb7b0cdbeff30dd65f6fa1a23054b3d80f4a48434df8b366ba545132250ae1d5", + "size": 35742, + "subdir": "linux-64", + "timestamp": 1540228750835, + "version": "0.32.2" + }, + "wheel-0.32.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "8fbe04eb9475ad52b27ee6406c634944", + "name": "wheel", + "sha256": "cc612135fe3a0ae45755865de4f349109a7fe54d6347c6a5ca132ce28835b279", + "size": 35522, + "subdir": "linux-64", + "timestamp": 1540228778841, + "version": "0.32.2" + }, + "wheel-0.32.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "ee813999cd8c39d08038638e76a8cc6e", + "name": "wheel", + "sha256": "b4e14c8dd7274cc3b0a04ffacba77d3073885a6fc5c03569211b26cfe1ac124c", + "size": 35262, + "subdir": "linux-64", + "timestamp": 1542642542001, + "version": "0.32.3" + }, + "wheel-0.32.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "87b8c0384556a3cd3b13cdc352b1bf0e", + "name": "wheel", + "sha256": "8e197b93fd2a7ce7446ed7c36ed00fa42538583356767a7d1693b53e9704b42b", + "size": 35611, + "subdir": "linux-64", + "timestamp": 1542642564954, + "version": "0.32.3" + }, + "wheel-0.32.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "69388c944e9aa6db79264a396b3ca7cc", + "name": "wheel", + "sha256": "62e21eb654c0ed28d8c8114252f156716bfc5ffeb3e59f08598212cf56c94886", + "size": 35434, + "subdir": "linux-64", + "timestamp": 1542642524752, + "version": "0.32.3" + }, + "wheel-0.32.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "cd563282ceb7ab85405185e1f0252ba9", + "name": "wheel", + "sha256": "c20ce01ba7f24da5d51e730b6309d3578d7e0ef4b651f0299000b25c17dad3a1", + "size": 35697, + "subdir": "linux-64", + "timestamp": 1573034077354, + "version": "0.32.3" + }, + "wheel-0.33.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "1577c839c63d8aec830913672d4656f6", + "name": "wheel", + "sha256": "43328f637b0160ffead7f7ff03a56a4691462c15d9783ce49fb59fa968826a1b", + "size": 39687, + "subdir": "linux-64", + "timestamp": 1551149172509, + "version": "0.33.1" + }, + "wheel-0.33.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "d2bd7c46afa74e87eabc2bede6ae4b58", + "name": "wheel", + "sha256": "bf37f48bea12e1ca0d6dd7f355b9519ba873d9a9a95051b4e221686fa5bb292c", + "size": 39975, + "subdir": "linux-64", + "timestamp": 1551149182787, + "version": "0.33.1" + }, + "wheel-0.33.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "e15ae8528528a941e87a40059360d893", + "name": "wheel", + "sha256": "e1457589e95e48aed74a8d7c7a26c9a363e0658164bea83d2ba35a943a52d560", + "size": 39885, + "subdir": "linux-64", + "timestamp": 1551149152778, + "version": "0.33.1" + }, + "wheel-0.33.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "3fac00fd0df660a66b123f0b001bd9be", + "name": "wheel", + "sha256": "c0fb39d286c8f73a973d003d51b7345acc2b54623b4c248636811bd69ad4641c", + "size": 40281, + "subdir": "linux-64", + "timestamp": 1557502304569, + "version": "0.33.2" + }, + "wheel-0.33.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "ad53f0302f3c9e866d00a80afcde821e", + "name": "wheel", + "sha256": "1959e363568cb7009f66c72fd06e5cbaee4163e0ba2d84e94536399a174fac41", + "size": 40581, + "subdir": "linux-64", + "timestamp": 1557502342180, + "version": "0.33.2" + }, + "wheel-0.33.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "b0518cfada5b18eff30766a00a8a0dfe", + "name": "wheel", + "sha256": "f0fac25a7d111d8da74ee055929095f5a2675c04319fcc10c7c8c3ec29bf6a9f", + "size": 40407, + "subdir": "linux-64", + "timestamp": 1557502247924, + "version": "0.33.2" + }, + "wheel-0.33.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "ab25708b2884fedaac5c6c47b792ab35", + "name": "wheel", + "sha256": "544992c592a63c265b42a2df81dcacee92cce43b56b11c725365103bf01a7b7a", + "size": 40325, + "subdir": "linux-64", + "timestamp": 1557857033805, + "version": "0.33.4" + }, + "wheel-0.33.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "9ccbcc08a616df0372c79e819ce696a5", + "name": "wheel", + "sha256": "bb66fcf858307ecb3af278a26c4d432952020dbbbf04882b2f7d6d79540b0927", + "size": 40626, + "subdir": "linux-64", + "timestamp": 1557857080569, + "version": "0.33.4" + }, + "wheel-0.33.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "0a70fdabbfa3ab275be133ee93f3a13d", + "name": "wheel", + "sha256": "97f5965fdfcb2f55e4ca085d97f85fb88c25efae4270ea2e8beb2f8b20727356", + "size": 40429, + "subdir": "linux-64", + "timestamp": 1557857035837, + "version": "0.33.4" + }, + "wheel-0.33.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "99d20fd656d91c2c8a50af0e9c08c4f5", + "name": "wheel", + "sha256": "697a1c2bc0565254cfe2b48b49707addca59767da591cf5f2f75c1fb18e73773", + "size": 41160, + "subdir": "linux-64", + "timestamp": 1569263315807, + "version": "0.33.6" + }, + "wheel-0.33.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "96d7edd76bd3e241fdd690dbeeb29976", + "name": "wheel", + "sha256": "af32c0bbb6c1ef9d0a305e2605b1f811c8a11340d3455c82f19d1f43f036ff08", + "size": 41447, + "subdir": "linux-64", + "timestamp": 1569263320834, + "version": "0.33.6" + }, + "wheel-0.33.6-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "d2175efbb4f75212abc4842980ae7eea", + "name": "wheel", + "sha256": "b4266c888cb6d05545275076384d1f571f328634d61829b31cd2955cd0078908", + "size": 41330, + "subdir": "linux-64", + "timestamp": 1569263303880, + "version": "0.33.6" + }, + "wheel-0.33.6-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "e97a0e73b494695109b8d1949bc0a944", + "name": "wheel", + "sha256": "c8bdfc43897f5d34ad18890afebec5a57c63ef2a1fde7abc8367049b28b3c642", + "size": 36317, + "subdir": "linux-64", + "timestamp": 1572437465923, + "version": "0.33.6" + }, + "wheel-0.34.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "fc6601c553e151cbbe71c6336c76c3fa", + "name": "wheel", + "sha256": "6ec42935e934f69f246050c3b307b96b92ca50150c0dcd9e9408b38467395472", + "size": 49905, + "subdir": "linux-64", + "timestamp": 1580399501764, + "version": "0.34.1" + }, + "wheel-0.34.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "a3f7c651b40ef9cf9691298593ce1e94", + "name": "wheel", + "sha256": "6c3b09959f70c4ebdf77605145f9cb57cad00ebd3fb1d21fa45cca25ee0d61f3", + "size": 49761, + "subdir": "linux-64", + "timestamp": 1580399417908, + "version": "0.34.1" + }, + "wheel-0.34.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "2837e823fbbd5e9f7eb6c7f77c896ae3", + "name": "wheel", + "sha256": "652898a42d04a1a8618bd68adf1c93cb16556003703adb1591922c7bfa90c4e4", + "size": 49870, + "subdir": "linux-64", + "timestamp": 1580399441638, + "version": "0.34.1" + }, + "wheel-0.34.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "cf891a92193ceeb74a65b836bdbfa042", + "name": "wheel", + "sha256": "aa2b5dd3ba9954c0db455633464c040f68ea9b6c170b03bc74cf57b2f3bd4cc7", + "size": 50359, + "subdir": "linux-64", + "timestamp": 1580834165295, + "version": "0.34.2" + }, + "wheel-0.34.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "26287a503e7ca973fcdcafc9e58fbbc4", + "name": "wheel", + "sha256": "44bf74cd2d2fcb0a80ce21bb4c5180dbfa4bab17d013a11d90e94ca184afa232", + "size": 50246, + "subdir": "linux-64", + "timestamp": 1580834163987, + "version": "0.34.2" + }, + "wheel-0.34.2-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "5d29428f2d9ce9cc5f30d56b871a8fb1", + "name": "wheel", + "sha256": "8e699370713ce3805438eb924f2deff7e2aba5e87e0bb0efb00f0914c3f68af5", + "size": 50342, + "subdir": "linux-64", + "timestamp": 1580834172764, + "version": "0.34.2" + }, + "wheel-0.38.4-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "145e9fb4acd831420d20bc92f094b0b0", + "name": "wheel", + "sha256": "d040250b2e26d72807e3938c0a60899c729ec5ee9ce2ec488e4277ba605c48b2", + "size": 59547, + "subdir": "linux-64", + "timestamp": 1676621847044, + "version": "0.38.4" + }, + "wheel-0.38.4-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "291aac949f67eefef7ec51ee48250ac8", + "name": "wheel", + "sha256": "a360dee17536bc58269bfc2c9418b34e14828c864b0d111cb911b01a53699f42", + "size": 78728, + "subdir": "linux-64", + "timestamp": 1679340678910, + "version": "0.38.4" + }, + "wheel-0.38.4-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b01e8f33d742abc91f3c9be2ac996bb2", + "name": "wheel", + "sha256": "9062105b2409793805ac052fc4a28c70369a599fb3349c30a42628d6b994f64b", + "size": 58697, + "subdir": "linux-64", + "timestamp": 1676621894403, + "version": "0.38.4" + }, + "wheel-0.38.4-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3795ac50210dde8f83dfb24d441dfb5e", + "name": "wheel", + "sha256": "1249aa6a1cbde53649bb474712de88e9f1773c59effc65bf516727e24506b626", + "size": 58921, + "subdir": "linux-64", + "timestamp": 1676621918009, + "version": "0.38.4" + }, + "wheel-0.38.4-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bbc6bc964d74a4e07bad3174da128e05", + "name": "wheel", + "sha256": "6f5a3011ef164034b2a548f0e09a89ee0070b46d9cd46b0dc20ef29add9475f7", + "size": 59062, + "subdir": "linux-64", + "timestamp": 1676621870595, + "version": "0.38.4" + }, + "whisper-1.0.2-py27hba602c6_0.tar.bz2": { + "build": "py27hba602c6_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache", + "md5": "fbe73545edee287209ad180c0c2839ab", + "name": "whisper", + "sha256": "6ac0eef77c6c05fbc4131bd9d3c9ff7f3e6aee61c23a35d197e7b5e8d3b29b31", + "size": 36212, + "subdir": "linux-64", + "timestamp": 1509213213874, + "version": "1.0.2" + }, + "whisper-1.0.2-py35ha4f42f5_0.tar.bz2": { + "build": "py35ha4f42f5_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache", + "md5": "81273d24e3966bb3671bfa42128640b1", + "name": "whisper", + "sha256": "b8496fa8159592bc56ba6a24f0c28d9cbac07b1ee6741ea8d0a74a7412338f94", + "size": 36688, + "subdir": "linux-64", + "timestamp": 1509213186482, + "version": "1.0.2" + }, + "whisper-1.0.2-py36h3df0b0a_0.tar.bz2": { + "build": "py36h3df0b0a_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache", + "md5": "fa37feb69268cf7a15340b7385149d14", + "name": "whisper", + "sha256": "230309aed5d61349fb72504ac7c191597ad24b3ad500d97ba11b8f1b3af91524", + "size": 36609, + "subdir": "linux-64", + "timestamp": 1509213192065, + "version": "1.0.2" + }, + "whisper-1.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache", + "md5": "fc9db549e0395a4c6e28113246af2574", + "name": "whisper", + "sha256": "e25e4610fcce6625fe64974cc02bc20b97f3e2b83d862c8c9a5899dca20e1c8a", + "size": 36707, + "subdir": "linux-64", + "timestamp": 1519482803397, + "version": "1.1.2" + }, + "whisper-1.1.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache", + "md5": "ce715effab9df2bf1cafde9c82963ac4", + "name": "whisper", + "sha256": "7f15de55ff2ecb9f9b785a20d7e0e21d42afec6fc5aecf577608477ac2f58cc5", + "size": 37213, + "subdir": "linux-64", + "timestamp": 1519482830984, + "version": "1.1.2" + }, + "whisper-1.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache", + "md5": "c77622b784389375f8d226c667bdc2cf", + "name": "whisper", + "sha256": "e08423e68b5ac11044827b99db6119e0d6d967d479bfa5e94559795d74a9cbe8", + "size": 37048, + "subdir": "linux-64", + "timestamp": 1519482764442, + "version": "1.1.2" + }, + "whisper-1.1.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache", + "md5": "31c7b83a22f6b4542ce0a0836c467067", + "name": "whisper", + "sha256": "762ab0193a5d6a80ab8f4c889028b3ccc294a5cd313e4852e0fa1cdf5a837794", + "size": 36753, + "subdir": "linux-64", + "timestamp": 1524087887518, + "version": "1.1.3" + }, + "whisper-1.1.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache", + "md5": "f129abaed3839275fef17cbf3d5f0194", + "name": "whisper", + "sha256": "e7b24211eeb8c31d876bc864c764b309dbfb0ff36424f39e06753fb1db091b86", + "size": 37284, + "subdir": "linux-64", + "timestamp": 1524087858203, + "version": "1.1.3" + }, + "whisper-1.1.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache", + "md5": "8f15c21ea30a7266543168f4729e66a7", + "name": "whisper", + "sha256": "ca66bac9fd679f6b404e4c653f577e4231c7edbaa2274bb67e8fc5a6dcc8475b", + "size": 37076, + "subdir": "linux-64", + "timestamp": 1524087855481, + "version": "1.1.3" + }, + "whisper-1.1.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache", + "md5": "42f2af4321ba873beed0460c5cc2bb35", + "name": "whisper", + "sha256": "2ee058edb099e13632a09fc97e6c4fe3e335415da5621d4911062ac229493507", + "size": 36964, + "subdir": "linux-64", + "timestamp": 1531060982136, + "version": "1.1.3" + }, + "whisper-1.1.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache", + "md5": "23c4badc626f6d18bb8cf1bb81daf5ca", + "name": "whisper", + "sha256": "5ac9b2f36d4fe87ff74c6af8049ef2bf854146f852681734d70bb30c2e4a9c2b", + "size": 36757, + "subdir": "linux-64", + "timestamp": 1536264472352, + "version": "1.1.4" + }, + "whisper-1.1.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache", + "md5": "bf50f73c13338d64d687aed8abd4a369", + "name": "whisper", + "sha256": "0297109ad17d059ec5886521bbd26f0b3c240ba8c6ad66a33bf26602510c185d", + "size": 37235, + "subdir": "linux-64", + "timestamp": 1536264480483, + "version": "1.1.4" + }, + "whisper-1.1.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache", + "md5": "9842917b797f9113fd01621eaad84250", + "name": "whisper", + "sha256": "c9c3f041b3ffd0a12863b97463df2ca6bac2476867a3219d893972aa2d2cfc8c", + "size": 37021, + "subdir": "linux-64", + "timestamp": 1536264419733, + "version": "1.1.4" + }, + "whisper-1.1.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache", + "md5": "08e0f79dd6a44d5fb18e51690485580d", + "name": "whisper", + "sha256": "8c9dfe4c6d0b17771312ce5249ddbd3a46337b449e686ec98e1b426807a8954c", + "size": 37042, + "subdir": "linux-64", + "timestamp": 1536264494956, + "version": "1.1.4" + }, + "whisper-1.1.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache", + "md5": "c157e3a74c2fa7191c3fd3e3230405e0", + "name": "whisper", + "sha256": "0018c0576542872605d456622b756397d6cf9974aed90e87cad5d9166cb8cca1", + "size": 171944, + "subdir": "linux-64", + "timestamp": 1552402518435, + "version": "1.1.5" + }, + "whisper-1.1.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "Apache", + "md5": "8f37b595aefbaa3654497af68e427d53", + "name": "whisper", + "sha256": "ee2836d0819b1f539d07074d7529d557b20c8d93f4b0792b1270969374641226", + "size": 37914, + "subdir": "linux-64", + "timestamp": 1640795920100, + "version": "1.1.5" + }, + "whisper-1.1.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "Apache", + "md5": "db2d80326e972dadd9d8d02010e5bb3e", + "name": "whisper", + "sha256": "739d134beff96b3f5a0fd4e7b2d2355c262966c0ae8f823add694f6e26f3b4ef", + "size": 47447, + "subdir": "linux-64", + "timestamp": 1676907770087, + "version": "1.1.5" + }, + "whisper-1.1.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache", + "md5": "16dee84f449ef5e3755681a53e7bc056", + "name": "whisper", + "sha256": "30405c2c91c940ba59cc0e09e57ffa0388de362e17d85297b97448cacc70e529", + "size": 172304, + "subdir": "linux-64", + "timestamp": 1552405194607, + "version": "1.1.5" + }, + "whisper-1.1.5-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache", + "md5": "ea28b6111d2059b5063b0046ac465106", + "name": "whisper", + "sha256": "758f3c56a4f475800533754a5dd5d84227fc49d8cd2613b96d33f4365ca8b666", + "size": 261564, + "subdir": "linux-64", + "timestamp": 1614272426753, + "version": "1.1.5" + }, + "whisper-1.1.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache", + "md5": "2a16bf5d445caac136bf366c85031b7e", + "name": "whisper", + "sha256": "23fcabf72d438d6d8e4f7e5cb389deabc06d8683fe4add8c753d46274504b97d", + "size": 172419, + "subdir": "linux-64", + "timestamp": 1552404997523, + "version": "1.1.5" + }, + "whisper-1.1.5-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache", + "md5": "61ebec064e0544391a664edf4046d47f", + "name": "whisper", + "sha256": "a1aa86e581a4dd86e1919922997b430604c594be2fdfc1b2da046892021b366d", + "size": 260512, + "subdir": "linux-64", + "timestamp": 1614272432409, + "version": "1.1.5" + }, + "whisper-1.1.5-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache", + "md5": "87a26a37fac1a155a1cd15f2b4d4e579", + "name": "whisper", + "sha256": "425f72dc8b5dac301538a779e474a28fd427c6cf91cd21f6a8363bbbdf186ff5", + "size": 37897, + "subdir": "linux-64", + "timestamp": 1574437351942, + "version": "1.1.5" + }, + "whisper-1.1.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache", + "md5": "bf98c7908790d0c5c8241d6e53896619", + "name": "whisper", + "sha256": "ccbc0fa3ecc72e24c14ce6b75d532bcb12768bac9d3ce8b9bd35fdc77d1bea2f", + "size": 260793, + "subdir": "linux-64", + "timestamp": 1614271414878, + "version": "1.1.5" + }, + "whisper-1.1.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache", + "md5": "f7a0c78fa896aeec98a4821334117130", + "name": "whisper", + "sha256": "f0cfe3c9ef8b04334eb9d65e4998b4af399d8461af8ec0938f24842658afa158", + "size": 260796, + "subdir": "linux-64", + "timestamp": 1614272443600, + "version": "1.1.5" + }, + "whoosh-2.7.4-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "17cd9981699c55ec18cb7a98327f1fcf", + "name": "whoosh", + "sha256": "8793eaa01f1047289620e550752254345b5e82702bb9d5c27cec3c81c3bd366a", + "size": 675220, + "subdir": "linux-64", + "timestamp": 1537812234395, + "version": "2.7.4" + }, + "whoosh-2.7.4-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f0f39df307f377d42e9746ed6f35b688", + "name": "whoosh", + "sha256": "2ff69963702328d6ab815c3c44cf56e279aaa078f68d41d77112cd007002e6e8", + "size": 692161, + "subdir": "linux-64", + "timestamp": 1537812240126, + "version": "2.7.4" + }, + "whoosh-2.7.4-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "557e6513c5fb33bb48561228a1cfba14", + "name": "whoosh", + "sha256": "a018b5ce0d75d10c8c144f6857a1ecc7915ffd79c0dd28fe6a1eb4c2b90ed16d", + "size": 684958, + "subdir": "linux-64", + "timestamp": 1537812267617, + "version": "2.7.4" + }, + "whoosh-2.7.4-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "dbb149b3bb5cbe73fb86f6e413b7f108", + "name": "whoosh", + "sha256": "cbb81d0ebd496eb0fe945bca2e8d1eb5b1f1cdd51fc3560d408bbbf4348ac5c4", + "size": 681516, + "subdir": "linux-64", + "timestamp": 1537812197322, + "version": "2.7.4" + }, + "widgetsnbextension-3.0.2-py27hcb77dec_1.tar.bz2": { + "build": "py27hcb77dec_1", + "build_number": 1, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "92eae90953cb1f8f551af51f4a79d3d0", + "name": "widgetsnbextension", + "sha256": "1570adbf90ba0c747ed086bd68318d3380badf688c7a75dff8523936dde25336", + "size": 2046558, + "subdir": "linux-64", + "timestamp": 1505722743065, + "version": "3.0.2" + }, + "widgetsnbextension-3.0.2-py35h0be620c_1.tar.bz2": { + "build": "py35h0be620c_1", + "build_number": 1, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7ef4cc4018178941a420a925fca2013d", + "name": "widgetsnbextension", + "sha256": "d3ef678a8d7bde7d922982789582edcd929cfeb3c7add00c8b5c32f3e5b18ffe", + "size": 2047786, + "subdir": "linux-64", + "timestamp": 1505690914432, + "version": "3.0.2" + }, + "widgetsnbextension-3.0.2-py36hd01bb71_1.tar.bz2": { + "build": "py36hd01bb71_1", + "build_number": 1, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2dca6414ba00bba69253f078366d0936", + "name": "widgetsnbextension", + "sha256": "8295ada8215caad1a16a1b9c12b04a1add95a79d75bf7475b4d822d4c2f1c100", + "size": 2047398, + "subdir": "linux-64", + "timestamp": 1505690933948, + "version": "3.0.2" + }, + "widgetsnbextension-3.0.8-py27h618a941_0.tar.bz2": { + "build": "py27h618a941_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c9f8489708d6e65cc39d1c363e5594cf", + "name": "widgetsnbextension", + "sha256": "10ace08f6d840828dc44145a8430108ab8b0b68f7e6d0e8899a3d523ac4b8ae8", + "size": 1775836, + "subdir": "linux-64", + "timestamp": 1511371690931, + "version": "3.0.8" + }, + "widgetsnbextension-3.0.8-py35h84cb72a_0.tar.bz2": { + "build": "py35h84cb72a_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1cbd52b7bc4196666997923153d69479", + "name": "widgetsnbextension", + "sha256": "5cb5a3e81d4067e5dc30ad5d0f02d1022eb0cfd36a2c397dbb6aedcaea0812d7", + "size": 1775043, + "subdir": "linux-64", + "timestamp": 1511371706908, + "version": "3.0.8" + }, + "widgetsnbextension-3.0.8-py36h25a1d49_0.tar.bz2": { + "build": "py36h25a1d49_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2ced8c2e67d2d508731ea34040a7b881", + "name": "widgetsnbextension", + "sha256": "3ec67eadd774a2cac8b1589ef36a060df394fb3bbd13b568fe9a5e29c1e028bf", + "size": 1775459, + "subdir": "linux-64", + "timestamp": 1511371722492, + "version": "3.0.8" + }, + "widgetsnbextension-3.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "aa34ad9ec2f585818d509d987c0a1aa1", + "name": "widgetsnbextension", + "sha256": "ecb7019f00889d4f03bd3e6928ed361995f0022d7f7ecb9f3562e866de0be9eb", + "size": 1775061, + "subdir": "linux-64", + "timestamp": 1515709734657, + "version": "3.1.0" + }, + "widgetsnbextension-3.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a82c945633d23de3c369d95218fd16f9", + "name": "widgetsnbextension", + "sha256": "484c6b13303f34e1133fdc35564d5b3f05368521620185a0166b773cf50101a9", + "size": 1776052, + "subdir": "linux-64", + "timestamp": 1515709648977, + "version": "3.1.0" + }, + "widgetsnbextension-3.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7d2c7b2669ef292cb0416f20de0c4cae", + "name": "widgetsnbextension", + "sha256": "597fa634a15b2f34662f03112a89bc8b8e82526c2f3ed5a381bcfb7ce763ad35", + "size": 1775336, + "subdir": "linux-64", + "timestamp": 1515709624366, + "version": "3.1.0" + }, + "widgetsnbextension-3.1.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "94e0ae70e026164c2b1b6afda482b84c", + "name": "widgetsnbextension", + "sha256": "0a931f9c65ab6f32d648d3dac60918349dc53c5e2aa74096a1fc7b001297a896", + "size": 1774426, + "subdir": "linux-64", + "timestamp": 1519139403790, + "version": "3.1.4" + }, + "widgetsnbextension-3.1.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e78bef893c3695655fc1d9f5e3561963", + "name": "widgetsnbextension", + "sha256": "45792856e03dac6b136a81256388fbd804bef85eacf887ddd1091c546d3fc148", + "size": 1775187, + "subdir": "linux-64", + "timestamp": 1519139434876, + "version": "3.1.4" + }, + "widgetsnbextension-3.1.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "62f1b2b48d2ad9669723a729fb20d442", + "name": "widgetsnbextension", + "sha256": "6fdb8762ea6579e2ea52b1d5c6a64151211fb162382d00e17166860890e58ec1", + "size": 1775609, + "subdir": "linux-64", + "timestamp": 1519139425372, + "version": "3.1.4" + }, + "widgetsnbextension-3.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "921fa6adcf6c2bc93b27f2ada8a3c248", + "name": "widgetsnbextension", + "sha256": "ec6250535971e995bc027e8f1b7f1833d6a9d9c8ec6244fe4280c8d6de6bd7bf", + "size": 1793068, + "subdir": "linux-64", + "timestamp": 1522694655219, + "version": "3.2.0" + }, + "widgetsnbextension-3.2.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5109f351ae8ebfa78370e13e0fc69f47", + "name": "widgetsnbextension", + "sha256": "b9c5a74c80b36af8e455c3543fbc6e32f79d7fa83b4e7aec7acc27b0b2a57a8f", + "size": 1791826, + "subdir": "linux-64", + "timestamp": 1522694709767, + "version": "3.2.0" + }, + "widgetsnbextension-3.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8d14f0ea09c9b48203fe3b30646b3950", + "name": "widgetsnbextension", + "sha256": "6f1d17aab10cbf8427ce2c567f658de7bf3b2e929ddcf1080ccf12f233535f9e", + "size": 1792503, + "subdir": "linux-64", + "timestamp": 1522694715030, + "version": "3.2.0" + }, + "widgetsnbextension-3.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "efd9fb29e1ef3237dda2507918e424dc", + "name": "widgetsnbextension", + "sha256": "373faa5a4d59cf58df6db6af9f3a2c486e95d151906a90c60761ef12dfb801d5", + "size": 1790340, + "subdir": "linux-64", + "timestamp": 1523971158550, + "version": "3.2.1" + }, + "widgetsnbextension-3.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5ac6bde7c2a70c904405678b04de49c1", + "name": "widgetsnbextension", + "sha256": "76579b97a872912029210de332ac05480459359d7fdad7c39c987024bf3128f5", + "size": 1790768, + "subdir": "linux-64", + "timestamp": 1523971230818, + "version": "3.2.1" + }, + "widgetsnbextension-3.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "606e5aab8ec5bb21676a2fd12176c680", + "name": "widgetsnbextension", + "sha256": "23713181717e28beff43e4d6c6cfcf6b2ef896a0566a6e39e998b50fbe9e016a", + "size": 1791291, + "subdir": "linux-64", + "timestamp": 1523971238598, + "version": "3.2.1" + }, + "widgetsnbextension-3.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0a88b12e479bfa34a430d14c98d683de", + "name": "widgetsnbextension", + "sha256": "3177959114d4035fcedad7d85ca419378426a2bc8a71bd1d7918c6819b99c112", + "size": 1791648, + "subdir": "linux-64", + "timestamp": 1530734756504, + "version": "3.2.1" + }, + "widgetsnbextension-3.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f4ee09decc91621873e1a672b623e8a5", + "name": "widgetsnbextension", + "sha256": "3ebdf879db4305f37cddf3d4a61d6e23061e59424103ee289232d76a297bed1c", + "size": 1790421, + "subdir": "linux-64", + "timestamp": 1532451324376, + "version": "3.3.0" + }, + "widgetsnbextension-3.3.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1ebdbcfc8ad48923bcbb660aa56682d4", + "name": "widgetsnbextension", + "sha256": "f95eeb8d70c22420981ccc244a0d20faf890aaf3445a99479c61a65d6831f04a", + "size": 1790232, + "subdir": "linux-64", + "timestamp": 1532451390980, + "version": "3.3.0" + }, + "widgetsnbextension-3.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3afba201f5bb616ddb4f2ef7a4ed69bf", + "name": "widgetsnbextension", + "sha256": "c80d1ba94084f40d9162755d1c7e789990990a08857f4c63b71cffb962d30139", + "size": 1790700, + "subdir": "linux-64", + "timestamp": 1532451164265, + "version": "3.3.0" + }, + "widgetsnbextension-3.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8b131ad75810a586cc4da76aef7f5046", + "name": "widgetsnbextension", + "sha256": "8d33fde7cfc4e24ce08039629c91b3728f3e2ffb17e915c22a364b4d25938515", + "size": 1790849, + "subdir": "linux-64", + "timestamp": 1532451237506, + "version": "3.3.0" + }, + "widgetsnbextension-3.3.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a74ddd300f3b4ec8bdf8073b6b802c06", + "name": "widgetsnbextension", + "sha256": "50bdfc68746f6eec9993a79608ae3d65b70516f539a0c93fab04f695917392ef", + "size": 1791178, + "subdir": "linux-64", + "timestamp": 1532970238995, + "version": "3.3.1" + }, + "widgetsnbextension-3.3.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "55d466877b1ddddfcccefd084b25a50d", + "name": "widgetsnbextension", + "sha256": "3c1f0405d8c8e11f735705130937e56d9f72c1a0538d61ba8440cfb97ad6720b", + "size": 1789797, + "subdir": "linux-64", + "timestamp": 1532970275365, + "version": "3.3.1" + }, + "widgetsnbextension-3.3.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "86077978119f32a91193a8e6d9b3c93b", + "name": "widgetsnbextension", + "sha256": "f4d4c46288ffe7a859207ea4be705d1487051fb8e5f14136272602fc33a36481", + "size": 1790352, + "subdir": "linux-64", + "timestamp": 1532970104485, + "version": "3.3.1" + }, + "widgetsnbextension-3.3.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "04b8ab3f628f265277b05847bfd25c6d", + "name": "widgetsnbextension", + "sha256": "40a2d84d19a1408d6a9a30573535af324089e1e59662969b3138cd5132b64c8f", + "size": 1789936, + "subdir": "linux-64", + "timestamp": 1532970162151, + "version": "3.3.1" + }, + "widgetsnbextension-3.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4685dbe280b856a68290bca23c5d1bd7", + "name": "widgetsnbextension", + "sha256": "97b673d13a68c152b9ddc74674350f4ec95d7d1add8a885548297155a7842485", + "size": 1797443, + "subdir": "linux-64", + "timestamp": 1533742936534, + "version": "3.4.0" + }, + "widgetsnbextension-3.4.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b23548427d8bd9c4a382c36f706031e1", + "name": "widgetsnbextension", + "sha256": "1f8b163e1294451f4780b0324d07b6acb2bf9c8a7db186a7474854636be6ee5f", + "size": 1798497, + "subdir": "linux-64", + "timestamp": 1533743471602, + "version": "3.4.0" + }, + "widgetsnbextension-3.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f149c095b781be5de4e8a86a71166ad3", + "name": "widgetsnbextension", + "sha256": "e76f421a92bb8710118cf9877c959e0287b09f482260f31a104e31aca9ba3869", + "size": 1797494, + "subdir": "linux-64", + "timestamp": 1533742966745, + "version": "3.4.0" + }, + "widgetsnbextension-3.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8844884de86ade64376b98db793c7fa3", + "name": "widgetsnbextension", + "sha256": "7f20b3cecf889ce7f4e63b8cf173446289816261cdf4c5a551a69673b2e36cb6", + "size": 1796101, + "subdir": "linux-64", + "timestamp": 1533743061670, + "version": "3.4.0" + }, + "widgetsnbextension-3.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2af1a998508e008942e1bd84060ef676", + "name": "widgetsnbextension", + "sha256": "4296e7cc44df3676b0377814b7be30d2d9f383e1d6043d8747e528dbeffb145d", + "size": 1795485, + "subdir": "linux-64", + "timestamp": 1536075484531, + "version": "3.4.1" + }, + "widgetsnbextension-3.4.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9c904688829ee50f58fe856527b2bc69", + "name": "widgetsnbextension", + "sha256": "25952ea96a65114c04fec146cdc14daa102d5686ec3afa4660faf624183df9af", + "size": 1794083, + "subdir": "linux-64", + "timestamp": 1536075504048, + "version": "3.4.1" + }, + "widgetsnbextension-3.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "592036652ce127874a5a02d46ef03c24", + "name": "widgetsnbextension", + "sha256": "dcffae01057dc916aca934f77b18e47a28aad284f8ccf7f27fb55ac96cfbe255", + "size": 1794492, + "subdir": "linux-64", + "timestamp": 1536075433603, + "version": "3.4.1" + }, + "widgetsnbextension-3.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8c88c97a70d8c22a0c23857a797e4f18", + "name": "widgetsnbextension", + "sha256": "5507fd8020f9bdf82aeb0d64507881dc302e7e4b515c9c477cddd828248e9a83", + "size": 1795534, + "subdir": "linux-64", + "timestamp": 1536075449851, + "version": "3.4.1" + }, + "widgetsnbextension-3.4.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6f36d5cb3282e6589179550f8e04f527", + "name": "widgetsnbextension", + "sha256": "17dc7ce7f490c7ab95e749db4189a072afec436b4037751b0211ea4e622943d9", + "size": 1794641, + "subdir": "linux-64", + "timestamp": 1538155586674, + "version": "3.4.2" + }, + "widgetsnbextension-3.4.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c17f80f5913ee8d17943fdfd56387111", + "name": "widgetsnbextension", + "sha256": "7c6037266f3f9e33c4a682b7ba77768ede6ef02817d7e241c75b072513c404a5", + "size": 1795785, + "subdir": "linux-64", + "timestamp": 1538155589465, + "version": "3.4.2" + }, + "widgetsnbextension-3.4.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4ec239ed9f427319129a94794640474a", + "name": "widgetsnbextension", + "sha256": "ae8550ba6b52ef46ec710d98485d6155a9b48543c2752b71a42892c6903e1f0a", + "size": 1794525, + "subdir": "linux-64", + "timestamp": 1538155566205, + "version": "3.4.2" + }, + "widgetsnbextension-3.5.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0699358568358b873097605d69261cc5", + "name": "widgetsnbextension", + "sha256": "1d8f33c9d288cdf6351d5b232e1ccbd69189c2b1478a431a14c10abb01cdc74e", + "size": 1899774, + "subdir": "linux-64", + "timestamp": 1563207662608, + "version": "3.5.0" + }, + "widgetsnbextension-3.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1b596d9dd73a29bcba173ca26506b1c9", + "name": "widgetsnbextension", + "sha256": "8444ae60969581c681e3e29390a61a43ae3741ec5e7eeee8b4c268020ebbd329", + "size": 1897168, + "subdir": "linux-64", + "timestamp": 1563207662166, + "version": "3.5.0" + }, + "widgetsnbextension-3.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9231564999932541e4c018c69ae48595", + "name": "widgetsnbextension", + "sha256": "55b0f9dea3068b12697a45ea4beec31a74695dc2f618496a8dc5c5f4137c6884", + "size": 1902035, + "subdir": "linux-64", + "timestamp": 1563207662153, + "version": "3.5.0" + }, + "widgetsnbextension-3.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "32e1a312958fb0e72a76dfa828e331d8", + "name": "widgetsnbextension", + "sha256": "f154393ac0ce36e0f0e0eb0bb35ece887a30ffaec2fa95cce1777e69d014cb78", + "size": 1896712, + "subdir": "linux-64", + "timestamp": 1565958493195, + "version": "3.5.1" + }, + "widgetsnbextension-3.5.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "035cbdc1905bce2d3c3c9752eb4965df", + "name": "widgetsnbextension", + "sha256": "816c5000ef61c86a8d3cad9d2d34314247b3a2188ae2eb659029d6feb7ea7b02", + "size": 1888087, + "subdir": "linux-64", + "timestamp": 1641918277589, + "version": "3.5.1" + }, + "widgetsnbextension-3.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "96f11f98dcea5f6290331af1b77abcc4", + "name": "widgetsnbextension", + "sha256": "31fcf9198e7df19e2698d95c1f6c606ef2755abb7cc0542f3e6f506543a39263", + "size": 1897174, + "subdir": "linux-64", + "timestamp": 1565959140969, + "version": "3.5.1" + }, + "widgetsnbextension-3.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0c80d2bd6448120c9974c620935eafda", + "name": "widgetsnbextension", + "sha256": "9d37ec9f6527a25549c6a406d658476a7e1739ab5021cdfb228567626b653942", + "size": 1895547, + "subdir": "linux-64", + "timestamp": 1565958517961, + "version": "3.5.1" + }, + "widgetsnbextension-3.5.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "34428bf68f1240f343e811e313086cae", + "name": "widgetsnbextension", + "sha256": "bec246b58906aeb0a82da01ee91eb7001cffe1cc85b16cd1648020ea263192cc", + "size": 1896262, + "subdir": "linux-64", + "timestamp": 1580237157572, + "version": "3.5.1" + }, + "widgetsnbextension-3.5.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dd36ebf85049c444775649c8f9226353", + "name": "widgetsnbextension", + "sha256": "d07b97faeaa5f7ddb69d222724ddc28769337d20dedd2be56814dd2c1ff872b5", + "size": 1895873, + "subdir": "linux-64", + "timestamp": 1607531565796, + "version": "3.5.1" + }, + "widgetsnbextension-3.5.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "57b9c609ad6b278bc8f3e3689ef8f20f", + "name": "widgetsnbextension", + "sha256": "c866b3fa5705a4e3357d8124b611ae4fbb5d53dd6611626d7f1e5cddc99aa79e", + "size": 1348852, + "subdir": "linux-64", + "timestamp": 1645009398817, + "version": "3.5.2" + }, + "widgetsnbextension-3.5.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a32d7116e8e82ea43ae1730bab81a05b", + "name": "widgetsnbextension", + "sha256": "8b2674dd260b783b4fa26e1d9f7bbd4e0e30c0dfdf1997d95a66213be74b7ef1", + "size": 1315737, + "subdir": "linux-64", + "timestamp": 1676827582788, + "version": "3.5.2" + }, + "widgetsnbextension-3.5.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20ad3d36daf52dff11da1e0cdc056d43", + "name": "widgetsnbextension", + "sha256": "207951f72056a89c05b601ddddce7d5812349638515b98cb6819515a86853c46", + "size": 1323409, + "subdir": "linux-64", + "timestamp": 1645009388027, + "version": "3.5.2" + }, + "widgetsnbextension-3.5.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50e63cefa1b88adbd676fc2da00e36c9", + "name": "widgetsnbextension", + "sha256": "9b25e94b157cdcd81dc1ad9a9a77abdeed4426276e8052f641024f1f734a9942", + "size": 1324253, + "subdir": "linux-64", + "timestamp": 1645009387114, + "version": "3.5.2" + }, + "widgetsnbextension-3.5.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aa41ad1a2c79dfc34f7c587e46b7b135", + "name": "widgetsnbextension", + "sha256": "a546e0c868578e0b006b60ce3fb2e2ccaac46c8c4c5707f945388d3735f55fbf", + "size": 1345468, + "subdir": "linux-64", + "timestamp": 1644992829240, + "version": "3.5.2" + }, + "widgetsnbextension-4.0.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e7b961151fc281ecc8ee6f2edb2b46ab", + "name": "widgetsnbextension", + "sha256": "88c9f5bcd495ce81b651b2bc5bad5a88ddf4cc28cda07eba4ffe3844962be50f", + "size": 1711620, + "subdir": "linux-64", + "timestamp": 1668501827711, + "version": "4.0.3" + }, + "widgetsnbextension-4.0.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7ce8bb18243c5f58d58581ef826c81b6", + "name": "widgetsnbextension", + "sha256": "87ac61d92e7ec793af01977d6d217edf9a6204285aba336ad76c1e62798351b9", + "size": 1722817, + "subdir": "linux-64", + "timestamp": 1676827566421, + "version": "4.0.3" + }, + "widgetsnbextension-4.0.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "93bfb71aeae4a30ba92ed2cc475abe6d", + "name": "widgetsnbextension", + "sha256": "9698130af32a73baf75eeb3297ac688b8322fd7e7b4c158bfdec85b4961f2218", + "size": 1712185, + "subdir": "linux-64", + "timestamp": 1668501858455, + "version": "4.0.3" + }, + "widgetsnbextension-4.0.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ab203c3030227a85eadf75c864fbb3fe", + "name": "widgetsnbextension", + "sha256": "a9f9a3454dc572a5c2532d1f3c95d985004f240b5cb0855916a600e3632a66d8", + "size": 1712465, + "subdir": "linux-64", + "timestamp": 1668501888991, + "version": "4.0.3" + }, + "widgetsnbextension-4.0.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4030f9b308db0988d3a1a64d6c35068e", + "name": "widgetsnbextension", + "sha256": "547d0085ddd885fc5a72fbb218b18c936660a4d64894cffc4cc0bb44dc44ec2e", + "size": 1712395, + "subdir": "linux-64", + "timestamp": 1668501796649, + "version": "4.0.3" + }, + "widgetsnbextension-4.0.5-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "26735c99b638659f6b2104b31391b6a5", + "name": "widgetsnbextension", + "sha256": "85707cd8079a833a21a7e31e091369b1f015c953b04cd1392308ef0ab85f8d16", + "size": 1716298, + "subdir": "linux-64", + "timestamp": 1679313973748, + "version": "4.0.5" + }, + "widgetsnbextension-4.0.5-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6f2d0520dc3b35b85fb1dd71f064eef7", + "name": "widgetsnbextension", + "sha256": "062a9e0cba9df987845fd87e030cc3b414996e218cdda035245c002ce741c3af", + "size": 1716210, + "subdir": "linux-64", + "timestamp": 1679313945165, + "version": "4.0.5" + }, + "widgetsnbextension-4.0.5-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "261b31c8871414c40e68036d2cf01687", + "name": "widgetsnbextension", + "sha256": "646f71c7f74c8b0d079854c12844d151d6009c649857cd2a83545e1505a49f9a", + "size": 1716797, + "subdir": "linux-64", + "timestamp": 1679313890777, + "version": "4.0.5" + }, + "widgetsnbextension-4.0.5-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6e62d56e10c8dcf15b9751be26815579", + "name": "widgetsnbextension", + "sha256": "14a0a6514ab339ea6d5a60ff0b2c5a307465f8c5162251f56da3eca271153149", + "size": 1715268, + "subdir": "linux-64", + "timestamp": 1679313917195, + "version": "4.0.5" + }, + "winsdk-10.0.17763.0-hc402f9b_0.tar.bz2": { + "build": "hc402f9b_0", + "build_number": 0, + "depends": [ + "curl", + "msitools", + "p7zip" + ], + "license": "LicenseRef-MICROSOFT_SDK", + "license_family": "Proprietary", + "md5": "a1483989d893adf38cc524dbe7d2ae3d", + "name": "winsdk", + "sha256": "550dba2164a935c7349492b8bf6df38a6f72f2d4767c9ca4cb9b74bf7f78249c", + "size": 25437, + "subdir": "linux-64", + "timestamp": 1668352701562, + "version": "10.0.17763.0" + }, + "word2vec-0.9.2-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d2dbb0e29e426aadaad84a852770516a", + "name": "word2vec", + "sha256": "b2a688a0bd953784e267d00e0348a1b0cca2808e1b208830d580e14c721849a7", + "size": 84384, + "subdir": "linux-64", + "timestamp": 1515213616966, + "version": "0.9.2" + }, + "word2vec-0.9.2-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8e4b2aa5696df785ed75b4fa6a4ba14f", + "name": "word2vec", + "sha256": "d25172a036bc3d619d6d641f1f720e80b9cca28ad311ba346dad0a117e6ccbed", + "size": 84894, + "subdir": "linux-64", + "timestamp": 1515213621153, + "version": "0.9.2" + }, + "word2vec-0.9.2-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "26f2f734e0765b9d5467e168ba61d693", + "name": "word2vec", + "sha256": "ac87c6240bde601ef02c19f1125d4a291fb7cf98c90c8ef998286ad3ad3f9450", + "size": 84825, + "subdir": "linux-64", + "timestamp": 1515213574730, + "version": "0.9.2" + }, + "word2vec-0.9.4-py27h035aef0_0.tar.bz2": { + "build": "py27h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "901af20dc13a1122b43d6308045ecd2c", + "name": "word2vec", + "sha256": "4333ef91003146d1871c2463a36f0b88de84ff40e6dc817dc6ee1db787124db3", + "size": 85415, + "subdir": "linux-64", + "timestamp": 1529437790986, + "version": "0.9.4" + }, + "word2vec-0.9.4-py310h9102076_0.tar.bz2": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "feacfc90c612f1b999b0145abfc2bfd5", + "name": "word2vec", + "sha256": "4ea83229518144eca1a2cb5b1cf4e34caf340e2d9c32a273162ee82de85b1ef6", + "size": 110709, + "subdir": "linux-64", + "timestamp": 1640795956016, + "version": "0.9.4" + }, + "word2vec-0.9.4-py311hbed6279_0.tar.bz2": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "38441d2de6ed084e0be577b1bbd40171", + "name": "word2vec", + "sha256": "e32baa71a55e6550c046b46521a00f571eb4450e37e6b93dcd802b0130689ba2", + "size": 92174, + "subdir": "linux-64", + "timestamp": 1676907795551, + "version": "0.9.4" + }, + "word2vec-0.9.4-py35h035aef0_0.tar.bz2": { + "build": "py35h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f44c9b05c43015eba88ba51a0fc368c6", + "name": "word2vec", + "sha256": "a7e997a683f5e5e18c4aa6bdb63ed80b2246e5ad31649d51cb921118c013f4ff", + "size": 85880, + "subdir": "linux-64", + "timestamp": 1529437792428, + "version": "0.9.4" + }, + "word2vec-0.9.4-py36h035aef0_0.tar.bz2": { + "build": "py36h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9e345619b1998f0a324e300fe62c42f7", + "name": "word2vec", + "sha256": "338d6ed88b811cd6a498ec14a0bb88770cfab2f3cc4e6b10c9da9c54f48215f3", + "size": 85849, + "subdir": "linux-64", + "timestamp": 1529437319164, + "version": "0.9.4" + }, + "word2vec-0.9.4-py36h6323ea4_0.tar.bz2": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "98768a55ff70f0ed8d5dcf8dcf4f09e8", + "name": "word2vec", + "sha256": "113c971fe25f9eaca3d9b29b93d17264ab1d84269bf6a0e648a09fa36f08cb48", + "size": 304240, + "subdir": "linux-64", + "timestamp": 1613040237136, + "version": "0.9.4" + }, + "word2vec-0.9.4-py36heb32a55_0.tar.bz2": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "793f9b3b7b491359df6161a30470c546", + "name": "word2vec", + "sha256": "3100c1b4d82ea526cba2b2a140aa25f0e75ea6cbf2f37cf4ac597c46a5e1b8ea", + "size": 260095, + "subdir": "linux-64", + "timestamp": 1592481982060, + "version": "0.9.4" + }, + "word2vec-0.9.4-py37h035aef0_0.tar.bz2": { + "build": "py37h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1c468e4a266d4aa7115ab5e345513dd0", + "name": "word2vec", + "sha256": "d17dc9eaa6a4f8ec452fc46abd7fdca7ae47520e6d2582af74eebbb4b68d3c8e", + "size": 85343, + "subdir": "linux-64", + "timestamp": 1531061031797, + "version": "0.9.4" + }, + "word2vec-0.9.4-py37h6323ea4_0.tar.bz2": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b1739dc69fcdcf55460c111ba294fda0", + "name": "word2vec", + "sha256": "80451571f41ff07e4fbbdd338ff54e882dbf1b78c7fe6c903b1193cb388416bc", + "size": 304390, + "subdir": "linux-64", + "timestamp": 1613040242966, + "version": "0.9.4" + }, + "word2vec-0.9.4-py37heb32a55_0.tar.bz2": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "96ac8be1305dab1917057c455917ceb2", + "name": "word2vec", + "sha256": "39176f172336c4abddd9029b0d1b514c69b741998bc5f07580fbff32e04d0d50", + "size": 263285, + "subdir": "linux-64", + "timestamp": 1592481981119, + "version": "0.9.4" + }, + "word2vec-0.9.4-py38h6323ea4_0.tar.bz2": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7cd8883926affac0fee20896dcef7c6d", + "name": "word2vec", + "sha256": "674d95fe5c3359b8fac51bd1d125742afc4eac3508057f0d63787f24a47c7b1f", + "size": 306878, + "subdir": "linux-64", + "timestamp": 1613040243732, + "version": "0.9.4" + }, + "word2vec-0.9.4-py38heb32a55_0.tar.bz2": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0256632ac2b3da3d06407c59d1bbd173", + "name": "word2vec", + "sha256": "77861a5e53a3636a52aa4ebf1155f6f1cfc220b8afbf430dc622260b4a97dea7", + "size": 263421, + "subdir": "linux-64", + "timestamp": 1592481934628, + "version": "0.9.4" + }, + "word2vec-0.9.4-py39h6323ea4_0.tar.bz2": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "399347494e72c2f37de3e44c77aafca3", + "name": "word2vec", + "sha256": "cf7244b5b562c4286e3bc731dfa62bc82b78abc01e3f19de9d470ad6091d99f0", + "size": 308650, + "subdir": "linux-64", + "timestamp": 1613040244866, + "version": "0.9.4" + }, + "workerpool-0.9.4-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "8decedb37b17ef2bcee2cdf0969d3065", + "name": "workerpool", + "sha256": "c25277e229c353e77e7075a007748b8a8647cf3f8f44be63b17a2f8e5eb86908", + "size": 11247, + "subdir": "linux-64", + "timestamp": 1537836868015, + "version": "0.9.4" + }, + "workerpool-0.9.4-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "MIT", + "md5": "4cdfc74aecb22cab1b4946555f778e25", + "name": "workerpool", + "sha256": "b9e1f7b0c10537f1ec5b49d5c45b947d51a61466c11c2e9264863bbf7199dc6d", + "size": 12090, + "subdir": "linux-64", + "timestamp": 1640795980806, + "version": "0.9.4" + }, + "workerpool-0.9.4-py311h06a4308_2.tar.bz2": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "MIT", + "md5": "a0b9c60e28cf32d9da6f78c5475fe82a", + "name": "workerpool", + "sha256": "d088270762969d9ca8f8868a30f6b5ddbf19741096444a4aa21a20e29b7db814", + "size": 13667, + "subdir": "linux-64", + "timestamp": 1676907814858, + "version": "0.9.4" + }, + "workerpool-0.9.4-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "babe5425e1aa50d0692bc8a177e96840", + "name": "workerpool", + "sha256": "e81f96e5979e464c9c27911b874a6d2c1002e665b878966103129be4d85f5d7c", + "size": 11501, + "subdir": "linux-64", + "timestamp": 1537882257137, + "version": "0.9.4" + }, + "workerpool-0.9.4-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "15c001970f22aa4bfd27f2664959e921", + "name": "workerpool", + "sha256": "a7091c290e5bffc192cd49c634d7bc74389510e055c35f22af238587dced5f1b", + "size": 11442, + "subdir": "linux-64", + "timestamp": 1537836935725, + "version": "0.9.4" + }, + "workerpool-0.9.4-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "7a26f1c8ab20114a37e0ae20252df620", + "name": "workerpool", + "sha256": "28fab5befedefc99558604fba29c27ab95395c6e1c1865e4e9d2b3adfa0cc70b", + "size": 279556, + "subdir": "linux-64", + "timestamp": 1632746627379, + "version": "0.9.4" + }, + "workerpool-0.9.4-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "6b5ea384710b2c5ca53a481d982740ce", + "name": "workerpool", + "sha256": "ce30580a7cf9e738871b15e6b8655288099c32dd73270786148136bc89df99e6", + "size": 11469, + "subdir": "linux-64", + "timestamp": 1537836862764, + "version": "0.9.4" + }, + "workerpool-0.9.4-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "7e205ab1e5c0756a7d625695c7a2a197", + "name": "workerpool", + "sha256": "fe2f9e1d9d19f1812836a2c83947f798a0aa281aea4a35e66085ff285dcea2d4", + "size": 281107, + "subdir": "linux-64", + "timestamp": 1632746609161, + "version": "0.9.4" + }, + "workerpool-0.9.4-py38_2.tar.bz2": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "md5": "f8184f7deeb93543193d58c12d8ccc5a", + "name": "workerpool", + "sha256": "f5804267a1b1d5967de6a372dc7fd89d94ba750d448135c91e765dfc7273c5e3", + "size": 11793, + "subdir": "linux-64", + "timestamp": 1574437367937, + "version": "0.9.4" + }, + "workerpool-0.9.4-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "md5": "11c0a23a56ef9304006189f8896e1047", + "name": "workerpool", + "sha256": "e06bb17520b9c245fa17ddb1dce4efe60efba64f6aba2b95d336e41886702d85", + "size": 280846, + "subdir": "linux-64", + "timestamp": 1632756982701, + "version": "0.9.4" + }, + "workerpool-0.9.4-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "md5": "e90503f24a6a8bca8254129460ada8cb", + "name": "workerpool", + "sha256": "fddaabfae85fd3573b5418323200867f538c547c937627619410ddecca8307d4", + "size": 281264, + "subdir": "linux-64", + "timestamp": 1632746538947, + "version": "0.9.4" + }, + "wrapt-1.10.11-py27h04f6869_0.tar.bz2": { + "build": "py27h04f6869_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "b560cb96557a0cd2a20a351150ea2103", + "name": "wrapt", + "sha256": "04dcfed0d4ccf3dc761ef251ab5c78e6ce49f38f6ee8d5a29fc73d01b00965bc", + "size": 44938, + "subdir": "linux-64", + "timestamp": 1505693861107, + "version": "1.10.11" + }, + "wrapt-1.10.11-py27h14c3975_2.tar.bz2": { + "build": "py27h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "0467af994873c25cd2517a2a41056433", + "name": "wrapt", + "sha256": "42d22b6a84926ed1db8f00f5d28e4b1ea27ce4a0bfd11111230e72354dea10c8", + "size": 45155, + "subdir": "linux-64", + "timestamp": 1530736620856, + "version": "1.10.11" + }, + "wrapt-1.10.11-py35h14c3975_2.tar.bz2": { + "build": "py35h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "62648d1af3688fc0c22b760bdd95a014", + "name": "wrapt", + "sha256": "58d3589b55c19f0ce9389d74ccba9b4efe2bffaa765b458e3f7d04acaa7c59d1", + "size": 45913, + "subdir": "linux-64", + "timestamp": 1534352309509, + "version": "1.10.11" + }, + "wrapt-1.10.11-py35hfdafd39_0.tar.bz2": { + "build": "py35hfdafd39_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "5fa1630db3c0f006b121cc63400d1ceb", + "name": "wrapt", + "sha256": "f3ad84513e306ed131a2665659df62023e5c936130d9069b543e4efe2ebc9c59", + "size": 45785, + "subdir": "linux-64", + "timestamp": 1505693876080, + "version": "1.10.11" + }, + "wrapt-1.10.11-py36h14c3975_2.tar.bz2": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "65955eab8d230efcd9a70e86a5c65e32", + "name": "wrapt", + "sha256": "368b6e1fb3e50b6ae7fa7b0cbd3a9628cc0dc5600ecc03411885d508846c228d", + "size": 45839, + "subdir": "linux-64", + "timestamp": 1530736598786, + "version": "1.10.11" + }, + "wrapt-1.10.11-py36h28b7045_0.tar.bz2": { + "build": "py36h28b7045_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "a9ff34652b7d82011f8b9d2cd5ccb998", + "name": "wrapt", + "sha256": "5eaac194041c237e6685f5ac0f7f1a1f85fc5fc45fbc0f031d5aefee8bf89938", + "size": 45731, + "subdir": "linux-64", + "timestamp": 1505693891235, + "version": "1.10.11" + }, + "wrapt-1.10.11-py37h14c3975_2.tar.bz2": { + "build": "py37h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "d4c17fd0545a6720cdfc18206ff96d79", + "name": "wrapt", + "sha256": "673758d8c7724b4743a43b7bb402d6eae534178e6f9a5da404de5119485e1dad", + "size": 45979, + "subdir": "linux-64", + "timestamp": 1530736642849, + "version": "1.10.11" + }, + "wrapt-1.11.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "771900fd0e86890aec5bfb5fb09a9ae9", + "name": "wrapt", + "sha256": "e1e55cc40c52219d07f723c0cbac89f8b0b119e7eb2ddd9677a1d93b2de70f59", + "size": 45819, + "subdir": "linux-64", + "timestamp": 1547909248778, + "version": "1.11.0" + }, + "wrapt-1.11.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "69542bbf2cdc587246d69aead50cfa83", + "name": "wrapt", + "sha256": "0ddc0b10f6e11716bfacbc80de1fc0fd55e44a1572a6c95a083f1b9cb3b0841c", + "size": 46561, + "subdir": "linux-64", + "timestamp": 1547909326738, + "version": "1.11.0" + }, + "wrapt-1.11.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "5fdb6a14fe4acbe0287cc2b986a6b2db", + "name": "wrapt", + "sha256": "778bdbc150d8cff4612bf7c0a5f3c2386cfd7f554ef654c1d44afc46fbdb1a56", + "size": 46655, + "subdir": "linux-64", + "timestamp": 1547909341411, + "version": "1.11.0" + }, + "wrapt-1.11.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "d2a4519abd3daebf9d77e5287ce564a8", + "name": "wrapt", + "sha256": "45c07499217c6c9909d78b772723d57504ca63c06ce4d81699855a3b74888c56", + "size": 46334, + "subdir": "linux-64", + "timestamp": 1549637180633, + "version": "1.11.1" + }, + "wrapt-1.11.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "7c49194db32e768f851a908b5b278ae2", + "name": "wrapt", + "sha256": "9134989d2187b830109e648a873b8456f96322497bae1a4f989ba52a9a0fa24e", + "size": 47041, + "subdir": "linux-64", + "timestamp": 1549637199042, + "version": "1.11.1" + }, + "wrapt-1.11.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "175b752dfdabfe471724d7311d03cf90", + "name": "wrapt", + "sha256": "323f2dbf8e600f99b8b8599bcc85a682e1489250bd42ba7dc41972e36a5997de", + "size": 47142, + "subdir": "linux-64", + "timestamp": 1549637159351, + "version": "1.11.1" + }, + "wrapt-1.11.2-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "4eb9b0b9dc6745f7f2953ed6e105b10b", + "name": "wrapt", + "sha256": "402044e8f37ff5cd9cd2d9893ed1d954688b5eb44e9262e8ccd31e4d4b3185bf", + "size": 48878, + "subdir": "linux-64", + "timestamp": 1562087085483, + "version": "1.11.2" + }, + "wrapt-1.11.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "1332cb0c480ee3db90f4665a9ffcb619", + "name": "wrapt", + "sha256": "018bb0e70302852a9fa138e2372abe046f7dbbd58748e3f913ee66d83ad29662", + "size": 49620, + "subdir": "linux-64", + "timestamp": 1562087104596, + "version": "1.11.2" + }, + "wrapt-1.11.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "1605becd411421c82b1a86d83f4b2b45", + "name": "wrapt", + "sha256": "ab7bdf864fba8c423a66b39853346f19e170c3782b7e659c73a63fc96197a91d", + "size": 49734, + "subdir": "linux-64", + "timestamp": 1562087105302, + "version": "1.11.2" + }, + "wrapt-1.11.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "md5": "7ad4b0369461161de803d27bb855e291", + "name": "wrapt", + "sha256": "4a2c99a83c6f7a60a1ec29fa275313009a26526588ef3f71dd6410e782c30bdb", + "size": 54898, + "subdir": "linux-64", + "timestamp": 1573200465137, + "version": "1.11.2" + }, + "wrapt-1.11.2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "md5": "f07f3a290820872f3a346b41126d48de", + "name": "wrapt", + "sha256": "1583f3639231f1adc170b9722df3dcb8ebfc4e71e0ae736a83a324ea9a9f9973", + "size": 50556, + "subdir": "linux-64", + "timestamp": 1607712559171, + "version": "1.11.2" + }, + "wrapt-1.12.1-py36h7b6447c_1.tar.bz2": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "11df4b4f128dbc5adaaa7a425e4a0cb1", + "name": "wrapt", + "sha256": "91b43c46dfebc3623c38cfb91372a44c051104a4e745d214bf96375828167930", + "size": 50595, + "subdir": "linux-64", + "timestamp": 1584459673785, + "version": "1.12.1" + }, + "wrapt-1.12.1-py37h7b6447c_1.tar.bz2": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "375bed82cde499ac9fb25f9238ea5680", + "name": "wrapt", + "sha256": "fcf0ec4da07420c9cc4f09248b1f7c44782fe7fa7680988dcfe2fa6a4dc5ed14", + "size": 50773, + "subdir": "linux-64", + "timestamp": 1584459646855, + "version": "1.12.1" + }, + "wrapt-1.12.1-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "md5": "461c635433e2c73f0a1bbf744120adc0", + "name": "wrapt", + "sha256": "e43975ec5957ddc07fa30d09e8c7b141e11e62d47d33616e790d53a2ae2f38b9", + "size": 51428, + "subdir": "linux-64", + "timestamp": 1584459748636, + "version": "1.12.1" + }, + "wrapt-1.12.1-py39he8ac12f_1.tar.bz2": { + "build": "py39he8ac12f_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "md5": "d0945723314a1244260877805a912b2d", + "name": "wrapt", + "sha256": "3bce7081c1a14b16d10bf0b420c79a144ba49dbf1f360f3f6e771406ffd7ded0", + "size": 51864, + "subdir": "linux-64", + "timestamp": 1607574535188, + "version": "1.12.1" + }, + "wrapt-1.13.3-py310h7f8727e_2.tar.bz2": { + "build": "py310h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c33a3effadbc5251dabc558c82e1080c", + "name": "wrapt", + "sha256": "b69f944d4156152951884728b97c8b8d416d4e01fcf4749ef271f065a41d6627", + "size": 86859, + "subdir": "linux-64", + "timestamp": 1640796005412, + "version": "1.13.3" + }, + "wrapt-1.13.3-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "1d6f3323ccb78cdafb0be0520944f111", + "name": "wrapt", + "sha256": "3b938306c3e47f5b8986bc30635b38a4bedeafff2e94c64f7f4378f08356625c", + "size": 48784, + "subdir": "linux-64", + "timestamp": 1638260486585, + "version": "1.13.3" + }, + "wrapt-1.13.3-py37h7f8727e_1.tar.bz2": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "3b69397e51af6ecf0f86b39807efa92e", + "name": "wrapt", + "sha256": "b533763ed9dce58356bb0d2d6bd9425c53c4a799944b603027d07a5b10d4f027", + "size": 48612, + "subdir": "linux-64", + "timestamp": 1637920109734, + "version": "1.13.3" + }, + "wrapt-1.13.3-py37h7f8727e_2.tar.bz2": { + "build": "py37h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5af06494420fa18ed08014239514fec9", + "name": "wrapt", + "sha256": "58b0f8a099921aed1408f644ecac0dd2bfb7e7bb8be711631cf8cceb5f8ed7c7", + "size": 52608, + "subdir": "linux-64", + "timestamp": 1638420669364, + "version": "1.13.3" + }, + "wrapt-1.13.3-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "1eadbf2f6d5dd56380a312beacbcbebd", + "name": "wrapt", + "sha256": "c475a4d30a49b073c970038c855d2f89050c96be9596f4b3aa16d68e3d068d64", + "size": 49454, + "subdir": "linux-64", + "timestamp": 1638260465960, + "version": "1.13.3" + }, + "wrapt-1.13.3-py38h7f8727e_1.tar.bz2": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "md5": "377b55aa50b1bb351b92ce58dffb063b", + "name": "wrapt", + "sha256": "fc6ad5e6f7b908a560bd84d71183952052862a2e87edb541d096757aec5593ea", + "size": 49411, + "subdir": "linux-64", + "timestamp": 1637920111562, + "version": "1.13.3" + }, + "wrapt-1.13.3-py38h7f8727e_2.tar.bz2": { + "build": "py38h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e707270d599e07eeb4c8c89cb50ba38a", + "name": "wrapt", + "sha256": "9d0f2c29418eff3d837af83c426b0b2980808c38f0e1e9545572ca41e1a543b6", + "size": 53174, + "subdir": "linux-64", + "timestamp": 1638433279490, + "version": "1.13.3" + }, + "wrapt-1.13.3-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "37ccc77eb1930b139b5c6e3998b8fc6e", + "name": "wrapt", + "sha256": "1dfd84e8586391a934e38e590cac720e3710c4c0d37b09aca4e22e59b0c2ac6d", + "size": 49550, + "subdir": "linux-64", + "timestamp": 1638260474224, + "version": "1.13.3" + }, + "wrapt-1.13.3-py39h7f8727e_1.tar.bz2": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "md5": "73ed9e2d0cc0f8660221c5009457ac3b", + "name": "wrapt", + "sha256": "d1fbf459aca8b4a8935e9b53b53e78aa06d65f0758e906fb520039503c277f14", + "size": 49386, + "subdir": "linux-64", + "timestamp": 1637920102064, + "version": "1.13.3" + }, + "wrapt-1.13.3-py39h7f8727e_2.tar.bz2": { + "build": "py39h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c7d90bc44d8366ae13b21168605062ea", + "name": "wrapt", + "sha256": "5df54c791fe67a6766444ab8d4a11c1e0b009e202a9d2d71e30363c73c69f916", + "size": 53447, + "subdir": "linux-64", + "timestamp": 1638433893758, + "version": "1.13.3" + }, + "wrapt-1.14.1-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d841452d35f0316511e36dd6f085f0f1", + "name": "wrapt", + "sha256": "d124a4c35ad87af326dab95842b1cd26e8ea730ba3df29d79043e9baebd7f862", + "size": 88964, + "subdir": "linux-64", + "timestamp": 1657814488569, + "version": "1.14.1" + }, + "wrapt-1.14.1-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ee1d74d8bd6dcc12c0b2ceafcd7ec428", + "name": "wrapt", + "sha256": "0a23cb35ff8cfe9dc40f6d55d878bc2b1a7213dcf46ccb855b46e1520e9e0bb8", + "size": 60594, + "subdir": "linux-64", + "timestamp": 1676827602470, + "version": "1.14.1" + }, + "wrapt-1.14.1-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "03e81635176b32105ded25ae11aafe13", + "name": "wrapt", + "sha256": "e23361a4087fb1fd1567bef4e73acc26384d9e7bc797bfbc3537c3170330acfd", + "size": 51839, + "subdir": "linux-64", + "timestamp": 1657814445721, + "version": "1.14.1" + }, + "wrapt-1.14.1-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "dbff9ae7b588ef9b0922a5789f02accb", + "name": "wrapt", + "sha256": "b50c6209d813358a32cfb1490e167c46b7b52e009e9fb08f1c75b78dc625b59c", + "size": 52245, + "subdir": "linux-64", + "timestamp": 1657814516213, + "version": "1.14.1" + }, + "wrapt-1.14.1-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8c84b851e32adce99aee6db8f6646c6d", + "name": "wrapt", + "sha256": "71745256a6d64341e39cc01011e6b0a518a746505a5face2ea385cf8b7f543c1", + "size": 52310, + "subdir": "linux-64", + "timestamp": 1657814543605, + "version": "1.14.1" + }, + "ws4py-0.4.2-py27hbd04d0f_0.tar.bz2": { + "build": "py27hbd04d0f_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cbe1ec5181cdc8ecfc7de2c997ec6523", + "name": "ws4py", + "sha256": "f4d71942c655d9aebb16025700dfc8ac87493816fdc04fbe5fc11aa96af1a782", + "size": 57532, + "subdir": "linux-64", + "timestamp": 1507268699890, + "version": "0.4.2" + }, + "ws4py-0.4.2-py35he0e66b0_0.tar.bz2": { + "build": "py35he0e66b0_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ad38fe237f1f830d4378575f99c5bb1b", + "name": "ws4py", + "sha256": "5cc257d3bdb35dcec2983c26fcfa1cf5e4dfcf4ec5f83aa23021724af502bbda", + "size": 58787, + "subdir": "linux-64", + "timestamp": 1507268700333, + "version": "0.4.2" + }, + "ws4py-0.4.2-py36haccdab7_0.tar.bz2": { + "build": "py36haccdab7_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0406647289df8e4872d6a02611928eec", + "name": "ws4py", + "sha256": "c6ca3ca9bb493c74df0c2392068b0cb4c6627137e564f94f51e7b46c43bbf366", + "size": 58641, + "subdir": "linux-64", + "timestamp": 1507268718499, + "version": "0.4.2" + }, + "ws4py-0.5.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2347011c21d04162423ffe83a80abf5d", + "name": "ws4py", + "sha256": "7f8e5a486e94b877ee9a1e021f72b9445dfbc2e7fee5b583c24955645a4105ba", + "size": 57667, + "subdir": "linux-64", + "timestamp": 1522103958104, + "version": "0.5.1" + }, + "ws4py-0.5.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "70cfe04d79b7d59b87e4e406139233f2", + "name": "ws4py", + "sha256": "dbf5a01c6078997017d7688795ef5e50a183ea337f040e69299ef958684af0a1", + "size": 61979, + "subdir": "linux-64", + "timestamp": 1640796023994, + "version": "0.5.1" + }, + "ws4py-0.5.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3cba69c5aecffe86f03e688c55541078", + "name": "ws4py", + "sha256": "3260ca9cfbaf815b765d0963ae9ff2a3a83e27301bcf808183d8ed83bdbfacfe", + "size": 79452, + "subdir": "linux-64", + "timestamp": 1676863533066, + "version": "0.5.1" + }, + "ws4py-0.5.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "32cc6be1caa9f20068dc21fa07d56753", + "name": "ws4py", + "sha256": "1ebd6b94f88b818b7d5a51e5f48d9433a62e8e139fec5d1432260e75a8f1afb7", + "size": 63674, + "subdir": "linux-64", + "timestamp": 1522103954398, + "version": "0.5.1" + }, + "ws4py-0.5.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1b2d63b9a2adf5c70e259cdc0fdc082f", + "name": "ws4py", + "sha256": "f0a5b39473ff42514e8b46d5215e42c2aec228ce8cd6f123c5347c5f0a309264", + "size": 63578, + "subdir": "linux-64", + "timestamp": 1522103954640, + "version": "0.5.1" + }, + "ws4py-0.5.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9ed9cecb28a4016fc5b52886a157b154", + "name": "ws4py", + "sha256": "976eeee3e247c77e3298bf424c8ebfcec770fc5decd8bf932e4a3a85de54dbed", + "size": 65697, + "subdir": "linux-64", + "timestamp": 1613159175254, + "version": "0.5.1" + }, + "ws4py-0.5.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d2b0af7763150e5a195a60b29f4052e9", + "name": "ws4py", + "sha256": "4bd884f4c33a3c061f83eed7d1da1cbc430d724f018f59aef8f7f687c6bf3665", + "size": 60841, + "subdir": "linux-64", + "timestamp": 1531061071395, + "version": "0.5.1" + }, + "ws4py-0.5.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "abb8531470fff029daf6d61a06e5cb82", + "name": "ws4py", + "sha256": "22cf8584282dc7401b21e1a7ab0eb246a8acf6d2dfc648a09b8e03111ee686d4", + "size": 63043, + "subdir": "linux-64", + "timestamp": 1613158705460, + "version": "0.5.1" + }, + "ws4py-0.5.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1d5cd9094f00a23d76dc3ca41fdaa226", + "name": "ws4py", + "sha256": "523408fb993d37a9a19dfb0183d2f017296e84f592cd829da52dc62790b11495", + "size": 61580, + "subdir": "linux-64", + "timestamp": 1573200476656, + "version": "0.5.1" + }, + "ws4py-0.5.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "85fd3bb8e84e020f27aab8b1b97fc80f", + "name": "ws4py", + "sha256": "9e19903635051338aa84fe7fcf5b1acaf5e810e1789cba9f014a5432c2ba82e7", + "size": 63172, + "subdir": "linux-64", + "timestamp": 1613159161899, + "version": "0.5.1" + }, + "ws4py-0.5.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6e77dbfdb212354109c78258709d42e8", + "name": "ws4py", + "sha256": "56826de358200e94c180b94e06a20cb6dc72222dc9aac70b5dbead4b40ffd12f", + "size": 63275, + "subdir": "linux-64", + "timestamp": 1613159168740, + "version": "0.5.1" + }, + "wsgiproxy2-0.4.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "webob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a850e18442b28ede2c9216c7b77da10", + "name": "wsgiproxy2", + "sha256": "90cc2707cced3887c87f2aa099a66022b17943d486578b0b6da62bd7c6848f5f", + "size": 16540, + "subdir": "linux-64", + "timestamp": 1530875613623, + "version": "0.4.4" + }, + "wsgiproxy2-0.4.4-py27hfc095f2_0.tar.bz2": { + "build": "py27hfc095f2_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "webob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bdadb39484a02ea18380a09cb26f3c94", + "name": "wsgiproxy2", + "sha256": "b4ab02c4ffb6e751b6e1b278f2a4692ae8c843c5866ca16ae9bc289184cc3e5a", + "size": 16823, + "subdir": "linux-64", + "timestamp": 1509398997763, + "version": "0.4.4" + }, + "wsgiproxy2-0.4.4-py35hb7a3433_0.tar.bz2": { + "build": "py35hb7a3433_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "webob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c50c64a725bfa5300a95b6e81b854730", + "name": "wsgiproxy2", + "sha256": "585ea40f4999fe73a8163b846a6ea18d193363e5db6db1710e7afc86b16bc32e", + "size": 17218, + "subdir": "linux-64", + "timestamp": 1509399005965, + "version": "0.4.4" + }, + "wsgiproxy2-0.4.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "webob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b5a95ee34d92e7955196d122504c7f2", + "name": "wsgiproxy2", + "sha256": "bb76cabef647191efd01d2558660204616b171ef88fdca9bf05d038d498e3181", + "size": 16845, + "subdir": "linux-64", + "timestamp": 1530875561217, + "version": "0.4.4" + }, + "wsgiproxy2-0.4.4-py36h8281bc4_0.tar.bz2": { + "build": "py36h8281bc4_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "webob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "762de4bca64f79c94f9beb2df7380050", + "name": "wsgiproxy2", + "sha256": "c49a59d8e73a9b4d150d553503486b31502e15fa8a8e78703fb97b9f811f0dc4", + "size": 17107, + "subdir": "linux-64", + "timestamp": 1509399006026, + "version": "0.4.4" + }, + "wsgiproxy2-0.4.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "webob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc5b96e141df6b9a63e9e2fbd3ebd54c", + "name": "wsgiproxy2", + "sha256": "6d6a1e609dc47cf6b2a284d36ec9f65d8331b529f2aa283333cec05510b8a786", + "size": 16912, + "subdir": "linux-64", + "timestamp": 1530875588089, + "version": "0.4.4" + }, + "wsgiproxy2-0.4.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "webob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c2c19450c8410d6fe77c87f28f744bf", + "name": "wsgiproxy2", + "sha256": "c8bc5ca87a24d4c55bd970752a80a9111de550741003c5a69a16cf2c9d2d7c76", + "size": 17085, + "subdir": "linux-64", + "timestamp": 1539649511331, + "version": "0.4.5" + }, + "wsgiproxy2-0.4.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "webob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8dbc3e3073011073d252635a65f7324", + "name": "wsgiproxy2", + "sha256": "61bddf832a5b1d7776ffa5cc6975617ecc350bff898f6d4adc186316f29065bf", + "size": 17411, + "subdir": "linux-64", + "timestamp": 1539649530108, + "version": "0.4.5" + }, + "wsgiproxy2-0.4.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "webob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b46668a47318d5607ca6aae1a154f91", + "name": "wsgiproxy2", + "sha256": "59e6a1ef387457427006adc3503ef900fdf4a2fac89dd4172101581e7c4207a1", + "size": 17461, + "subdir": "linux-64", + "timestamp": 1539649517567, + "version": "0.4.5" + }, + "wsgiref-0.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF or ZPL", + "license_family": "PSF", + "md5": "579155bfc8d4fcb51644eaf7b7d2b760", + "name": "wsgiref", + "sha256": "f0f06283ece24bad08f551fd714e26406541181b99d3cb6458b6f811dfc967f8", + "size": 30022, + "subdir": "linux-64", + "timestamp": 1530904631987, + "version": "0.1.2" + }, + "wstools-0.4.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pbr", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ca747546126d7206446493dcdae69edc", + "name": "wstools", + "sha256": "c3b47b4a55f35949e70360861a93647b5c91a1893b5d4b875706951512258670", + "size": 97890, + "subdir": "linux-64", + "timestamp": 1530919199601, + "version": "0.4.6" + }, + "wstools-0.4.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pbr", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fc3a215f28b930668a145c1fa74b6e87", + "name": "wstools", + "sha256": "836affba2eebbc3e49524a8c603fe551ea477cacba933295629aaab1d92b4f9b", + "size": 97999, + "subdir": "linux-64", + "timestamp": 1535512811086, + "version": "0.4.7" + }, + "wstools-0.4.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pbr", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "098fd2b7676f4ba88177c0a05c011471", + "name": "wstools", + "sha256": "437ddc41215cc0a902f759a2c7fdd6c858b59c42fdb04b6a372424b74158c8ae", + "size": 98527, + "subdir": "linux-64", + "timestamp": 1539659221515, + "version": "0.4.8" + }, + "wtforms-2.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bf34791e433084432a1bbc63206874af", + "name": "wtforms", + "sha256": "486ffa6d002620a116ec29339bc690327bdbdacf49a9426e32dc7a00369b187a", + "size": 113434, + "subdir": "linux-64", + "timestamp": 1528174803338, + "version": "2.2" + }, + "wtforms-2.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "da153e3a7f8bce39ad0c92e5b037e253", + "name": "wtforms", + "sha256": "6e8826c5d1d3d086ff2d78ac7190905c247713b0a133ab05710e2eac5d538c07", + "size": 115737, + "subdir": "linux-64", + "timestamp": 1528174839525, + "version": "2.2" + }, + "wtforms-2.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d86557d93e106714099547b18d954c9f", + "name": "wtforms", + "sha256": "cb28a69c61e507acf88bc72cfcc9702e4db39da1dd24b94d24fac369aa07d30c", + "size": 115469, + "subdir": "linux-64", + "timestamp": 1528174770851, + "version": "2.2" + }, + "wtforms-2.2.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b3d68075a9db7d644277c8e770a3dae4", + "name": "wtforms", + "sha256": "7423adec62e070a7ae63d81ca1ae4c5b55b0b3abc5f04daffc77c57d99372db9", + "size": 113266, + "subdir": "linux-64", + "timestamp": 1529423245573, + "version": "2.2.1" + }, + "wtforms-2.2.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e0e403024945e45380d1e429937c1e6f", + "name": "wtforms", + "sha256": "ec8823be5153abec8c78b89d8517c8a0a6fe16d2341f467f48fbcef3f984f493", + "size": 115515, + "subdir": "linux-64", + "timestamp": 1529423253173, + "version": "2.2.1" + }, + "wtforms-2.2.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aa8af781a343659149499f45bc47a5bc", + "name": "wtforms", + "sha256": "6b7de8c010fa761e1bfc68de22f3cfb09a95ddc94b103370589c955b72ddf397", + "size": 115434, + "subdir": "linux-64", + "timestamp": 1529423231765, + "version": "2.2.1" + }, + "wtforms-2.2.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e06306f374cd28935b1b101a74d74c89", + "name": "wtforms", + "sha256": "c1bec34a0629a4f41a20222892469a7bdfb0f3e5963a00a515fdab5da6e4f81d", + "size": 115444, + "subdir": "linux-64", + "timestamp": 1537202605887, + "version": "2.2.1" + }, + "wtforms-2.2.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b451f439654c4ef3ec0e1f6df64016d9", + "name": "wtforms", + "sha256": "3a2327a3a716764b1ac2e81f69e41d1005354ad1c72f39b29a2e24085dbbe71a", + "size": 116103, + "subdir": "linux-64", + "timestamp": 1573661913808, + "version": "2.2.1" + }, + "wurlitzer-1.0.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c29e975bb6315e06e38d45a06859953b", + "name": "wurlitzer", + "sha256": "f54fe9fe34b0287aa5f8a381d7766200a94ff69e4afdd8bc18a9d231864b0265", + "size": 12048, + "subdir": "linux-64", + "timestamp": 1543426895337, + "version": "1.0.2" + }, + "wurlitzer-1.0.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5836708906990522a062192a7fd5314", + "name": "wurlitzer", + "sha256": "bbcd18c179c2fe310de4b22a2525890904c016a59256dced03f5d1eae21161b6", + "size": 12213, + "subdir": "linux-64", + "timestamp": 1543426923142, + "version": "1.0.2" + }, + "wurlitzer-1.0.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea8e986d4c0b9d0ea85b9827c77f7a3a", + "name": "wurlitzer", + "sha256": "0541856fd0556cd388ec26c09cd20b96287ede4d542a08e4472da97ea8173a20", + "size": 12243, + "subdir": "linux-64", + "timestamp": 1543426874786, + "version": "1.0.2" + }, + "wurlitzer-1.0.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fde6b08e4aa0ea917f7ca4791c2a24fa", + "name": "wurlitzer", + "sha256": "e4e47d1965897f81d916436452a0181e32ca60fb670d026963f1ff386ad02331", + "size": 13912, + "subdir": "linux-64", + "timestamp": 1564757037098, + "version": "1.0.3" + }, + "wurlitzer-1.0.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "227afbb919e2ae20ab920453a9d6a072", + "name": "wurlitzer", + "sha256": "c242994ccfe50ed5e41e38b86851c3bf30781318470e82439e3f22bc3bc9d6d7", + "size": 14107, + "subdir": "linux-64", + "timestamp": 1564764293878, + "version": "1.0.3" + }, + "wurlitzer-1.0.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb86c3104b5f2801a306d9cfae12e89e", + "name": "wurlitzer", + "sha256": "f93162532fd888ad1326abee2fdd58423924036ab771944b2a7831da3c935bfd", + "size": 14097, + "subdir": "linux-64", + "timestamp": 1564756778947, + "version": "1.0.3" + }, + "wurlitzer-1.0.3-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba28f3e37a10ca8131f4f9001b0ac3f7", + "name": "wurlitzer", + "sha256": "34bcf96f116b8d8294d1c35310c3713154b0c9a5df2917ceda0d728608276a39", + "size": 13168, + "subdir": "linux-64", + "timestamp": 1573729977752, + "version": "1.0.3" + }, + "wurlitzer-2.0.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "selectors2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e83f8fb212b0b3a1ff330e0bba9c6fd9", + "name": "wurlitzer", + "sha256": "155e526e399d5bf0b54380077c29489b7b6597c6253bc0b265f779bf988cc7ac", + "size": 14376, + "subdir": "linux-64", + "timestamp": 1574280274164, + "version": "2.0.0" + }, + "wurlitzer-2.0.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d42543af57a63e7ee6ae3696e812ae4", + "name": "wurlitzer", + "sha256": "42191740d5753be51515e4ea7892a239c196da41eea6c8bd5b1b7b0c4127844e", + "size": 14377, + "subdir": "linux-64", + "timestamp": 1574269156860, + "version": "2.0.0" + }, + "wurlitzer-2.0.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4763ae9e48dd14ce0e63ab7090ee683e", + "name": "wurlitzer", + "sha256": "f95d2d54f2fb14e30896b553f621ef8a92fdb039d4ad3a504084bbb52799f5a0", + "size": 14402, + "subdir": "linux-64", + "timestamp": 1574269157353, + "version": "2.0.0" + }, + "wurlitzer-2.0.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce5ded187113d271883e3fd5e13f3de6", + "name": "wurlitzer", + "sha256": "157edee52a115519eae53ddea571616bb241c41982563db0381b2aca809d97d9", + "size": 14377, + "subdir": "linux-64", + "timestamp": 1574269232080, + "version": "2.0.0" + }, + "wurlitzer-2.0.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "19410cf325255af7031ca3600b88f5aa", + "name": "wurlitzer", + "sha256": "31337cefdefc75d2b6d0148975a4a8c47fe3ac39ac3c8eb19d8b0d4c5284bc8f", + "size": 14846, + "subdir": "linux-64", + "timestamp": 1594753873288, + "version": "2.0.1" + }, + "wurlitzer-2.0.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a3d9ca2813fdc3da57d40419b76c342", + "name": "wurlitzer", + "sha256": "053787d6dd64c904d8de4a55a6d820a82cfbce0766a540d6f5daeee51128cd67", + "size": 14861, + "subdir": "linux-64", + "timestamp": 1594751896084, + "version": "2.0.1" + }, + "wurlitzer-2.0.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a6c61a45ebeae8e8a39258786475caba", + "name": "wurlitzer", + "sha256": "08d9d2c97433ae6e5032fb504a4633c59ebf17a6439c54d6f4afb1fe528ccefe", + "size": 14863, + "subdir": "linux-64", + "timestamp": 1594753876988, + "version": "2.0.1" + }, + "wurlitzer-2.0.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "29f5b1ab5b3e0c452130ecf52fb70c97", + "name": "wurlitzer", + "sha256": "e59d5a3e9790a7ab5a561a433ad356a63cf3ff0ed649d62e774fc806a40309ce", + "size": 15047, + "subdir": "linux-64", + "timestamp": 1607030039533, + "version": "2.0.1" + }, + "wurlitzer-2.1.0-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be4010b628739821c7cc3c6fbdfe3558", + "name": "wurlitzer", + "sha256": "b500745ca693e01cfbab3e6148efb8a27ad386f494b656476ac59585e14c23fd", + "size": 13665, + "subdir": "linux-64", + "timestamp": 1617222183401, + "version": "2.1.0" + }, + "wurlitzer-2.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c04ac7e1cc554b3adb9fe4cb9fd9dc6", + "name": "wurlitzer", + "sha256": "398daf4631adc6e45a98702ed8153ebb953939ef747846759f676a228824c1b3", + "size": 13724, + "subdir": "linux-64", + "timestamp": 1617224693898, + "version": "2.1.0" + }, + "wurlitzer-2.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db51ac52ff26591f9492ebb7038210db", + "name": "wurlitzer", + "sha256": "90c3d2e4373f1e95ab8889c040980191049f353e9bc768f20deef1ae933b5d44", + "size": 13684, + "subdir": "linux-64", + "timestamp": 1617224697519, + "version": "2.1.0" + }, + "wurlitzer-2.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd03f3dc88af9777c3f5cace57f9480d", + "name": "wurlitzer", + "sha256": "ba7f4fcc2fffff7a4d5cd19e2ea0df9e2a38f950a6c301b0e4383a71333c8e16", + "size": 13747, + "subdir": "linux-64", + "timestamp": 1617224676532, + "version": "2.1.0" + }, + "wurlitzer-2.1.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e92fa0bf11968dc599c280c29bf2fd70", + "name": "wurlitzer", + "sha256": "370fc6a006392f44db2c382fa8961549ef90d9a3aa5603d26f8fe898cbca4fdf", + "size": 13574, + "subdir": "linux-64", + "timestamp": 1626947845221, + "version": "2.1.1" + }, + "wurlitzer-2.1.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa2b8303310e16fc89a6ffd1d21480a0", + "name": "wurlitzer", + "sha256": "216c5a133d6473fef40af289ac4410accc1ff83a50df070fdc1821ade9dafa52", + "size": 13630, + "subdir": "linux-64", + "timestamp": 1626940405586, + "version": "2.1.1" + }, + "wurlitzer-2.1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f95ba678786df457bb24dd6e423f0c6", + "name": "wurlitzer", + "sha256": "c63b1a7f5ee24e86d342ba9614fd9863d1f2fa4abd6693b1bf4d8d50dd19e6b9", + "size": 13584, + "subdir": "linux-64", + "timestamp": 1626947820523, + "version": "2.1.1" + }, + "wurlitzer-2.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d62d1214c2668b58c1bd333e72d7b53d", + "name": "wurlitzer", + "sha256": "8b8b3844ff79b21117c6d90bd534062fa11eed2246df9e074935a301c4496385", + "size": 13652, + "subdir": "linux-64", + "timestamp": 1626947839474, + "version": "2.1.1" + }, + "wurlitzer-3.0.2-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "869f7ab66e54706520562e063395c58c", + "name": "wurlitzer", + "sha256": "bf18f3ae99ef39564288896820f0860aef2286da3c7cdde8a5f2dc44da2260fe", + "size": 15583, + "subdir": "linux-64", + "timestamp": 1640796042129, + "version": "3.0.2" + }, + "wurlitzer-3.0.2-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9c0e9139b9d6166f192c36ba7b3dd8b", + "name": "wurlitzer", + "sha256": "9bbe30f9aa6c7d31fe49efe3dd5b0d866d520b52951214ac1dba44522cb7a36c", + "size": 19276, + "subdir": "linux-64", + "timestamp": 1676843066851, + "version": "3.0.2" + }, + "wurlitzer-3.0.2-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "69f483af4374f3219cf22285afc286f6", + "name": "wurlitzer", + "sha256": "d516f329768cbba46f89ce70897682a19e35925dd57891327dcad1f8ac6460db", + "size": 15238, + "subdir": "linux-64", + "timestamp": 1638368193924, + "version": "3.0.2" + }, + "wurlitzer-3.0.2-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "67aa6b19d39d9255493d721eddededc0", + "name": "wurlitzer", + "sha256": "82dbb9406f1d36174e14ca335325d417e877163ddeb816d67cbef0262a2c940b", + "size": 15246, + "subdir": "linux-64", + "timestamp": 1638354998774, + "version": "3.0.2" + }, + "wurlitzer-3.0.2-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc8ac86c60bdf53b1ad724b3b1c5b1f2", + "name": "wurlitzer", + "sha256": "f01b478afe35a6a69c5d9f38735f51dd54565ab924da7d2780ac1ec36dad7b83", + "size": 15316, + "subdir": "linux-64", + "timestamp": 1638368193903, + "version": "3.0.2" + }, + "wxpython-4.0.1-py27h37420ed_1.tar.bz2": { + "build": "py27h37420ed_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.53.6,<3.0a0", + "gst-plugins-base", + "gst-plugins-base >=1.12.4,<1.13.0a0", + "gstreamer", + "gstreamer >=1.12.4,<1.13.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "pango >=1.41.0,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "10a08a69a6e62c36cb71da0d700fb782", + "name": "wxpython", + "sha256": "95abf23b4159288ace68d61f500f07efe5586fb4addca85f9118a5f6617a2b47", + "size": 21127834, + "subdir": "linux-64", + "timestamp": 1521001929675, + "version": "4.0.1" + }, + "wxpython-4.0.1-py35h37420ed_1.tar.bz2": { + "build": "py35h37420ed_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.53.6,<3.0a0", + "gst-plugins-base", + "gst-plugins-base >=1.12.4,<1.13.0a0", + "gstreamer", + "gstreamer >=1.12.4,<1.13.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "pango >=1.41.0,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "f947661f7cc3c70a01a5c12d6d09dd78", + "name": "wxpython", + "sha256": "0cf04c8045f36db76148dd481597f1025f6425e43638951770b321f53dfe8139", + "size": 21242947, + "subdir": "linux-64", + "timestamp": 1520999849509, + "version": "4.0.1" + }, + "wxpython-4.0.1-py36h37420ed_1.tar.bz2": { + "build": "py36h37420ed_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.53.6,<3.0a0", + "gst-plugins-base", + "gst-plugins-base >=1.12.4,<1.13.0a0", + "gstreamer", + "gstreamer >=1.12.4,<1.13.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "pango >=1.41.0,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "aba6de95f182e8a768b6e0ce655a599b", + "name": "wxpython", + "sha256": "524f836a98d75ca43dfa6cca56b070875fea9ff56ff99a5eef708914f28c23f8", + "size": 21307938, + "subdir": "linux-64", + "timestamp": 1521001932773, + "version": "4.0.1" + }, + "wxpython-4.0.2-py27h0e7c882_1.tar.bz2": { + "build": "py27h0e7c882_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.1,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "4571a9348e7c6b9074edd958de94c530", + "name": "wxpython", + "sha256": "0d6fe59bfad7ecdda5ce7846f95a012b1c2cce0094f5ba306c29c99e3437e759", + "size": 20921570, + "subdir": "linux-64", + "timestamp": 1529579187327, + "version": "4.0.2" + }, + "wxpython-4.0.2-py27h76a34b6_1.tar.bz2": { + "build": "py27h76a34b6_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.1,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "0cf006ae2fabfbc5e5ce46f4793299e1", + "name": "wxpython", + "sha256": "a9b44835e037d1eb604ec656e410201e216377a1d0f7d805804cb3170bedc1fa", + "size": 20928043, + "subdir": "linux-64", + "timestamp": 1531065082433, + "version": "4.0.2" + }, + "wxpython-4.0.2-py35h0e7c882_1.tar.bz2": { + "build": "py35h0e7c882_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.1,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "f730543982df6a4ae9c01a988cfe5bef", + "name": "wxpython", + "sha256": "98ab7e2decb0389fcb5ff9afb076b4cc0d0355f801a6c0d1615d5dee53be3384", + "size": 44530050, + "subdir": "linux-64", + "timestamp": 1529580606040, + "version": "4.0.2" + }, + "wxpython-4.0.2-py36h0e7c882_1.tar.bz2": { + "build": "py36h0e7c882_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.1,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "41b88bb18681b600a61af20f5be15f2b", + "name": "wxpython", + "sha256": "ed3fafda3dfbeac060f0b7e8cd552e2a6e398d66624711e1bb71ab216bd9c24b", + "size": 45323689, + "subdir": "linux-64", + "timestamp": 1529580613816, + "version": "4.0.2" + }, + "wxpython-4.0.2-py36h76a34b6_1.tar.bz2": { + "build": "py36h76a34b6_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.1,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "6439e1832aa480ec83ac4164e51ef55d", + "name": "wxpython", + "sha256": "3a4dc73727202cf2564e29ed76cb83e8a98dd15160c786ac88986078ff5d7ae8", + "size": 45320138, + "subdir": "linux-64", + "timestamp": 1531062557696, + "version": "4.0.2" + }, + "wxpython-4.0.2-py37h76a34b6_1.tar.bz2": { + "build": "py37h76a34b6_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.1,<2.0a0", + "python >=3.7,<3.8.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "a92ade11607b579a204033d783a8ea78", + "name": "wxpython", + "sha256": "cdc5920cffda5a5e9f2d4cb17b815aa8d3d4eafa409c5347d3df72e8ea6d3994", + "size": 46533720, + "subdir": "linux-64", + "timestamp": 1531064144846, + "version": "4.0.2" + }, + "wxpython-4.0.3-py27h76a34b6_0.tar.bz2": { + "build": "py27h76a34b6_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.2,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "02ed1f9b2a40711c0fe90addc872e225", + "name": "wxpython", + "sha256": "05e9e38df06e1a607b4658ec9a3e78a97229faab0f63d95828a68d38bc3b61f6", + "size": 20934588, + "subdir": "linux-64", + "timestamp": 1533101474099, + "version": "4.0.3" + }, + "wxpython-4.0.3-py35h76a34b6_0.tar.bz2": { + "build": "py35h76a34b6_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.2,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "e2e79ac5288fed36802a5085e1801f83", + "name": "wxpython", + "sha256": "42c004cac03f3d785539558fd782808ae07a9496fc3c990894b676bc21905b82", + "size": 44544322, + "subdir": "linux-64", + "timestamp": 1533103074639, + "version": "4.0.3" + }, + "wxpython-4.0.3-py36h76a34b6_0.tar.bz2": { + "build": "py36h76a34b6_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.2,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "4f75d4e7a0e3095c4f9960196a251003", + "name": "wxpython", + "sha256": "b3ad2f08e285f2ff5bfd32e106d70f5b95c517747d6cd62360e648b277b89ddd", + "size": 45311793, + "subdir": "linux-64", + "timestamp": 1533100070416, + "version": "4.0.3" + }, + "wxpython-4.0.3-py37h76a34b6_0.tar.bz2": { + "build": "py37h76a34b6_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.2,<2.0a0", + "python >=3.7,<3.8.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "3e14a2c02681d146a946b6a10d6b7ebe", + "name": "wxpython", + "sha256": "dd4591a0e717a462baa976dacecb95fc67732d7195c6a5cd4a84c4ebd95b4f78", + "size": 46531946, + "subdir": "linux-64", + "timestamp": 1533103135071, + "version": "4.0.3" + }, + "wxpython-4.0.4-py27hc99224d_0.tar.bz2": { + "build": "py27hc99224d_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.6,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.2,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libglu", + "libpng >=1.6.36,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.4,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "a4f76cd585fa007c5e96f141108da4f6", + "name": "wxpython", + "sha256": "02e00ed3d5e0ea674f0c21780c3f577e6c739294ccf8b54b2b73a1e65771ec8d", + "size": 20824862, + "subdir": "linux-64", + "timestamp": 1547934557269, + "version": "4.0.4" + }, + "wxpython-4.0.4-py36hc99224d_0.tar.bz2": { + "build": "py36hc99224d_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.6,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.2,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libglu", + "libpng >=1.6.36,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.4,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "9ac35ef3a2a4a534f91b19d8897b9178", + "name": "wxpython", + "sha256": "a2b956de7f069dabfafdd50d28efdee679e591c4dbb2a240fda8a59793201b17", + "size": 21013218, + "subdir": "linux-64", + "timestamp": 1547935109988, + "version": "4.0.4" + }, + "wxpython-4.0.4-py37hc99224d_0.tar.bz2": { + "build": "py37hc99224d_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.6,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.2,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libglu", + "libpng >=1.6.36,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.4,<2.0a0", + "python >=3.7,<3.8.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "c273fa786fbc875e290ae185cede7f9b", + "name": "wxpython", + "sha256": "3ca2de54945d8f50dc39f38c121c1f7b3dfeecec2a563b5b5d34fb87a34ff216", + "size": 20893036, + "subdir": "linux-64", + "timestamp": 1547935114899, + "version": "4.0.4" + }, + "x264-1!152.20180806-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-2.0", + "md5": "244b39e6c450e0a9d74f0bcf23cdb82f", + "name": "x264", + "sha256": "7b2bb7954c127eff0432815a8c9caf2a941e19ab682684a0d42a6468caf64e73", + "size": 1495250, + "subdir": "linux-64", + "timestamp": 1576633222936, + "version": "1!152.20180806" + }, + "x264-1!157.20191217-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-2.0", + "md5": "ca43674c30514c24c8cf30254fc94a9d", + "name": "x264", + "sha256": "f8cc31c945776425102bf859c7d69a161a3eccade9822b37d30703b89f751ee6", + "size": 2591119, + "subdir": "linux-64", + "timestamp": 1587147235073, + "version": "1!157.20191217" + }, + "x507-1.4.6-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "BSD", + "md5": "97699d81f39b5b2914125ffe95e9928f", + "name": "x507", + "sha256": "237db234a6de3eb014c5c227b0f114825374c89806094945f7840b8128803892", + "size": 3132, + "subdir": "linux-64", + "version": "1.4.6" + }, + "xar-1.6.1-h427f29d_0.tar.bz2": { + "build": "h427f29d_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d8db3c8a334ed2ff6ab973e549a92610", + "name": "xar", + "sha256": "66f26ef2ae152e8e9aa8dbac6b85b02bcf384b4a72e86ae3121212e7564139a1", + "size": 1064669, + "subdir": "linux-64", + "timestamp": 1505852085050, + "version": "1.6.1" + }, + "xar-1.8.0.425.2-h5de8990_0.tar.bz2": { + "build": "h5de8990_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "openssl >=1.1.1l,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "94a363c563f77df7222b5fb37fd7d036", + "name": "xar", + "sha256": "d080dae5c5d909c579659a2a9b94e8e1810a1aa3700b16e7b86cc2b1518561b4", + "size": 546733, + "subdir": "linux-64", + "timestamp": 1631124677431, + "version": "1.8.0.425.2" + }, + "xarray-0.10.0-py27hd0a7aca_0.tar.bz2": { + "build": "py27hd0a7aca_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "830a8fc509da325d0f8b095c033231e3", + "name": "xarray", + "sha256": "71262fc800717a78747628e0c122165e95e36e15aa0d1f4e662bd9bff92eb01b", + "size": 571287, + "subdir": "linux-64", + "timestamp": 1511285974055, + "version": "0.10.0" + }, + "xarray-0.10.0-py35h17cbfd9_0.tar.bz2": { + "build": "py35h17cbfd9_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "40a32fa57f9215792e7bc9dec5130c68", + "name": "xarray", + "sha256": "21c9c4a48437be35ff872c71db2d865fc7c292aa33d23ef65bf1f412a6596e30", + "size": 580569, + "subdir": "linux-64", + "timestamp": 1511285981386, + "version": "0.10.0" + }, + "xarray-0.10.0-py36hbc13e12_0.tar.bz2": { + "build": "py36hbc13e12_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "19143d101dc78cd2a5ace4cbeb763c51", + "name": "xarray", + "sha256": "cb5cfd111a860a8a84e42bf04bcb93b6735a1d961d0172c0da40ec1e07a49004", + "size": 572840, + "subdir": "linux-64", + "timestamp": 1511285975212, + "version": "0.10.0" + }, + "xarray-0.10.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4817f5e1e9acbc08663e31ca3120344b", + "name": "xarray", + "sha256": "fa3a4e2a44cdd1aaa011944286b958171f1120a2cacd8807c20e7bc5b5d5d9f2", + "size": 642471, + "subdir": "linux-64", + "timestamp": 1519755246190, + "version": "0.10.1" + }, + "xarray-0.10.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e4ae96aa328cec7ca71c9548cefb74c6", + "name": "xarray", + "sha256": "03cd53b9bf30d95002b18fa0c9c7e98ffe476e2e13c0cf6f22da0862f1c68f2f", + "size": 649107, + "subdir": "linux-64", + "timestamp": 1519755219886, + "version": "0.10.1" + }, + "xarray-0.10.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "77d26a66402132075a2e2af55d69d025", + "name": "xarray", + "sha256": "5aae0c21a8c525181c542bda80679a8dabe5d47de3448cd5d8b58a748f3c5592", + "size": 641705, + "subdir": "linux-64", + "timestamp": 1519755214842, + "version": "0.10.1" + }, + "xarray-0.10.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6a00d88659c919e3f984ae3227488a70", + "name": "xarray", + "sha256": "7d79ce0735bba2eda093bbd3cd0f42ebfbb12dccd3c26ac6ff2b2469f36de07c", + "size": 666389, + "subdir": "linux-64", + "timestamp": 1521484527598, + "version": "0.10.2" + }, + "xarray-0.10.2-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "15a0126b25ae9182c2b67c49e3ce0e44", + "name": "xarray", + "sha256": "49c4a17de5db51917d641dd6d3dd71cf91531d1954ed70c0515ef34857672e5a", + "size": 684609, + "subdir": "linux-64", + "timestamp": 1521484542784, + "version": "0.10.2" + }, + "xarray-0.10.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "92ec879d7e3f2f1dd62b5b6a751b6431", + "name": "xarray", + "sha256": "caceb8cb9d649804c1761261b3b09a29418546309d92ad8e44997ccfdbed3d3c", + "size": 678894, + "subdir": "linux-64", + "timestamp": 1521484540346, + "version": "0.10.2" + }, + "xarray-0.10.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c7f9559b8842fe0d7729bf4aec79a812", + "name": "xarray", + "sha256": "c561b4e2d5affde4c6210387a6606b89bd523822c5db6a73e0ce3ae0d853481c", + "size": 668966, + "subdir": "linux-64", + "timestamp": 1523983778663, + "version": "0.10.3" + }, + "xarray-0.10.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "131e2855e405437e0f58de558593bb1f", + "name": "xarray", + "sha256": "8801f6dcf9a03d0bd0929255796cef4f97132acce6e4559ec2565f4354d99c40", + "size": 691124, + "subdir": "linux-64", + "timestamp": 1523983799834, + "version": "0.10.3" + }, + "xarray-0.10.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9998a71c0cd458ccb697c501cc90b350", + "name": "xarray", + "sha256": "8aee14433587f2d204de36955336135fb4c35287336a077b59fe4cf39c9ff417", + "size": 686358, + "subdir": "linux-64", + "timestamp": 1523983750348, + "version": "0.10.3" + }, + "xarray-0.10.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8fc82b72b04bf65aa51a812fcf1c21df", + "name": "xarray", + "sha256": "d5829746065460175e0bfe3108b9a583c473307c4e44bd71778a285d3ab129b4", + "size": 705871, + "subdir": "linux-64", + "timestamp": 1526916218435, + "version": "0.10.4" + }, + "xarray-0.10.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2d5dda969c7c9709b20cb6b39c92c235", + "name": "xarray", + "sha256": "603779de3f80f20bf09a17fe9aaba74e399d6bd7a3db3e39ac2a4684d52f64c9", + "size": 723098, + "subdir": "linux-64", + "timestamp": 1526916233278, + "version": "0.10.4" + }, + "xarray-0.10.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "59ba6b95d5b2a36b6a81a7c5f982c681", + "name": "xarray", + "sha256": "23a38ff6f2d874b3644db98ec0b23c84f26b3379b0c346d2aef41b40abdd156f", + "size": 721074, + "subdir": "linux-64", + "timestamp": 1526916196824, + "version": "0.10.4" + }, + "xarray-0.10.6-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3e5e2d16abd9a9951bb6817a31667d23", + "name": "xarray", + "sha256": "a039e0f65ec794d17b8a98edae5539190f5b5185e176c578cd42fa2d07704c01", + "size": 720185, + "subdir": "linux-64", + "timestamp": 1528147329269, + "version": "0.10.6" + }, + "xarray-0.10.6-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2770131094f63c683c5d9f670079cd79", + "name": "xarray", + "sha256": "9c8d122cad261f3a8df5ae20cec3143e3754c6cb9d2f1f969ef2e941543190ff", + "size": 743217, + "subdir": "linux-64", + "timestamp": 1528147343975, + "version": "0.10.6" + }, + "xarray-0.10.6-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "89196495ee8649c765003ecdd0fea047", + "name": "xarray", + "sha256": "e072c07fca33f0453eb1ee66664c9bf2916dff1ce98b20c0c8ae2a52f3bbc1e0", + "size": 735941, + "subdir": "linux-64", + "timestamp": 1528147282613, + "version": "0.10.6" + }, + "xarray-0.10.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "69095029a694399acb7626affc95e52b", + "name": "xarray", + "sha256": "a053c3a82341f16a64ef7e452a11293fe0129ab7ff2f65e5ec4be36d2fa22e96", + "size": 741607, + "subdir": "linux-64", + "timestamp": 1528909892114, + "version": "0.10.7" + }, + "xarray-0.10.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2c69adfbc0a45d631a2831885d18830b", + "name": "xarray", + "sha256": "c9bb79de1df5d66bf447780acd3c3ad0d6eb4df01460cde6bc568b888b78a141", + "size": 756699, + "subdir": "linux-64", + "timestamp": 1528909911664, + "version": "0.10.7" + }, + "xarray-0.10.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0a8a155161c7402aefd8025df939b0c3", + "name": "xarray", + "sha256": "8c840297efc90fca1c5c24ed3bb5662d31805b243f31a791a8ce9955e3a3aa36", + "size": 756186, + "subdir": "linux-64", + "timestamp": 1528909870948, + "version": "0.10.7" + }, + "xarray-0.10.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f62299cca50ca95262a6d42a17529823", + "name": "xarray", + "sha256": "704a1770caddff8f6d1c6dc4f71b06f21eefff1041ab811ae78c57467c0f7366", + "size": 753527, + "subdir": "linux-64", + "timestamp": 1530872882019, + "version": "0.10.7" + }, + "xarray-0.10.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "13b0896fc627ca2ed617ab1b58a0dc38", + "name": "xarray", + "sha256": "80db7f350689c49c7ad9abaddc25c1548a026602244e46779399a2e4f60e18a3", + "size": 739545, + "subdir": "linux-64", + "timestamp": 1532538695892, + "version": "0.10.8" + }, + "xarray-0.10.8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6c308f79bb2498a039072fdd134a3852", + "name": "xarray", + "sha256": "49e7ba0f22d24aba1b29cd7ccbb91846508251a9291f7423a76c188782d71559", + "size": 754946, + "subdir": "linux-64", + "timestamp": 1532538668006, + "version": "0.10.8" + }, + "xarray-0.10.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "75aecbd708d28845bf742f4cbec4a625", + "name": "xarray", + "sha256": "e864bccff9b1098cd201fbb4b70c299c1ccad70c2a11e40526cc7762d8c1880c", + "size": 747988, + "subdir": "linux-64", + "timestamp": 1532538643333, + "version": "0.10.8" + }, + "xarray-0.10.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "79d433e41c601cac7b8539b124b63df8", + "name": "xarray", + "sha256": "309fca039b39982b1f6af86f3c1b9acfc17088d4f87583cd2aea02d33ef15bf9", + "size": 745797, + "subdir": "linux-64", + "timestamp": 1532538750616, + "version": "0.10.8" + }, + "xarray-0.10.9-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "14fb5efd62b08d18ffd8865e11a9d701", + "name": "xarray", + "sha256": "a201259f1ae860ba670060899ffe1164f355d182fcfd0613f65d8de98d751510", + "size": 789499, + "subdir": "linux-64", + "timestamp": 1538181880078, + "version": "0.10.9" + }, + "xarray-0.10.9-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "55dd95ed720ba5e2bd0e08ccfe227e32", + "name": "xarray", + "sha256": "b19de1b0b778b11ba1ad7d6b175c6355076c630cdf1b80c853bd906134b7b114", + "size": 794639, + "subdir": "linux-64", + "timestamp": 1538181900689, + "version": "0.10.9" + }, + "xarray-0.10.9-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "14fb13af3bce301cdb6969cc3cea426d", + "name": "xarray", + "sha256": "aa9e09b1ce606b9c8f30bb5b53671ecfa9dbf5fd9d1562d99101b5efa3d8f5d4", + "size": 790804, + "subdir": "linux-64", + "timestamp": 1538181878376, + "version": "0.10.9" + }, + "xarray-0.11.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6c2909b0c319756b2033ed50399c0c97", + "name": "xarray", + "sha256": "f33adf30ba2cd4f245338ed5421481a2898a8ae4f36f704d7275c1de1441ccaa", + "size": 829695, + "subdir": "linux-64", + "timestamp": 1542092227384, + "version": "0.11.0" + }, + "xarray-0.11.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b42e3a12be4b1b6359832197b45fc19a", + "name": "xarray", + "sha256": "ddff51e6efe5b052aa8e2e38e60338a147c0073da8ed809c8dee6a31c2a01ff5", + "size": 831962, + "subdir": "linux-64", + "timestamp": 1542092159124, + "version": "0.11.0" + }, + "xarray-0.11.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ce56f99751ee7492a6e65e887b40baa1", + "name": "xarray", + "sha256": "86767902f732d20c5103f3e5c0610c556c1ce4064793cf122240f897376e85e5", + "size": 832248, + "subdir": "linux-64", + "timestamp": 1542092176559, + "version": "0.11.0" + }, + "xarray-0.11.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1624f10d089a01568be2c073f1e186d9", + "name": "xarray", + "sha256": "0766582a803412a2890c2b3441951031a07d9db4694ddf00de22f88e0430d76e", + "size": 858624, + "subdir": "linux-64", + "timestamp": 1550432177849, + "version": "0.11.3" + }, + "xarray-0.11.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c48ebd3fa3338deb66447c8ef37ed10a", + "name": "xarray", + "sha256": "7a3448e982249ab0dda07c2d134fb7721a075a40ab22e7bafe5d6f60f1c6dd47", + "size": 864151, + "subdir": "linux-64", + "timestamp": 1550432270782, + "version": "0.11.3" + }, + "xarray-0.11.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "71cb2848a5649ebd6532bc50ae8260f7", + "name": "xarray", + "sha256": "3338503dfcdf9817ec32ba8aea547b35ee85af12ef091eadca0d6474e6d6158b", + "size": 859335, + "subdir": "linux-64", + "timestamp": 1550432178276, + "version": "0.11.3" + }, + "xarray-2022.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.20", + "packaging >=21.0", + "pandas >=1.3", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b0f2da77a2abd0b129e7d60621874749", + "name": "xarray", + "sha256": "5baacdc99d37732113fb49230e4698e3de83aff50b8a40448636a789b069af32", + "size": 1740838, + "subdir": "linux-64", + "timestamp": 1668776680921, + "version": "2022.11.0" + }, + "xarray-2022.11.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.20", + "packaging >=21.0", + "pandas >=1.3", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a531407239714a7ed1b5595d58c415ea", + "name": "xarray", + "sha256": "db3d66de45b117a8ddd987067ceb42ffbe3eeb0d7295f29c7a8e5fcf1780c444", + "size": 2389822, + "subdir": "linux-64", + "timestamp": 1676843085172, + "version": "2022.11.0" + }, + "xarray-2022.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.20", + "packaging >=21.0", + "pandas >=1.3", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cbef8e255222ff1c5727b7529031ccf8", + "name": "xarray", + "sha256": "508985a639f29648f66f7dd3856ad0baf5501601582e52ad26cae4c0e7ca8ea8", + "size": 1722500, + "subdir": "linux-64", + "timestamp": 1668776634679, + "version": "2022.11.0" + }, + "xarray-2022.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.20", + "packaging >=21.0", + "pandas >=1.3", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6e410f1c8ac68dcf641305f0eaf5e87d", + "name": "xarray", + "sha256": "ff67256374df7c4ed297402d5dd4a1a2fd6c7b2d606c153ebe9ef1c7a4b428f4", + "size": 1725040, + "subdir": "linux-64", + "timestamp": 1668776724424, + "version": "2022.11.0" + }, + "xattr-0.10.1-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ce2166ebeb5049c0b9ff5ed098c84d2", + "name": "xattr", + "sha256": "9ce19046bcfbd2fa64e47bef266a629c8427cbbaa11cd1d46595b0637b0b866c", + "size": 28033, + "subdir": "linux-64", + "timestamp": 1679670828645, + "version": "0.10.1" + }, + "xattr-0.10.1-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c6a72b96d544d1e2573cbc5e22afe98", + "name": "xattr", + "sha256": "d56ee0b5e38e7dc533560abf97b7dbc08d281cf699053e6aa910ac73bb0e765c", + "size": 33698, + "subdir": "linux-64", + "timestamp": 1679670793639, + "version": "0.10.1" + }, + "xattr-0.10.1-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0234bbe274c0fc3aa3c6d340d7cdeaac", + "name": "xattr", + "sha256": "7d5d060135846e3c40b1a3d4ba2ad04d9762c8b8b2ef53a5c515016bab3785de", + "size": 27897, + "subdir": "linux-64", + "timestamp": 1679670758901, + "version": "0.10.1" + }, + "xattr-0.10.1-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b212c533bba25d10c623a63522faff3a", + "name": "xattr", + "sha256": "fc24a515a84ecbb1adf0cf808027bd645d28210c656a6bf3f4280f657330364d", + "size": 27892, + "subdir": "linux-64", + "timestamp": 1679670724537, + "version": "0.10.1" + }, + "xcb-proto-1.12-py27h14c3975_1.tar.bz2": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e7be37d83149c173cf2de1b110292a7", + "name": "xcb-proto", + "namespace": "global", + "sha256": "07ce158b1b34f799de2584baeba0b853d62b7044052d437fc2d9f06bf6c17eb2", + "size": 104811, + "subdir": "linux-64", + "timestamp": 1531065214572, + "version": "1.12" + }, + "xcb-proto-1.12-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ffadd830edbc39afdc8dd5257e5a1bee", + "name": "xcb-proto", + "namespace": "global", + "sha256": "bd65d425c49998b2e8494d0aa87b1d5391833046896bef8aa5335e5520bd6ebf", + "size": 106190, + "subdir": "linux-64", + "timestamp": 1642508361850, + "version": "1.12" + }, + "xcb-proto-1.12-py311h5eee18b_1.tar.bz2": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8827e54b8cd5b1b8f33b24f8591c8180", + "name": "xcb-proto", + "namespace": "global", + "sha256": "e2ed80374eabcd58c4f8bfbdc4cf419f4e6adc030d0dbdb466f7ba38461f1a84", + "size": 119336, + "subdir": "linux-64", + "timestamp": 1676823271443, + "version": "1.12" + }, + "xcb-proto-1.12-py36h14c3975_1.tar.bz2": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "04a10dd26e27307171219230c8892364", + "name": "xcb-proto", + "namespace": "global", + "sha256": "5aed83679cae3e2bdc64a502b6926a05dea954b179f594ce46ae838bc6598bbe", + "size": 105636, + "subdir": "linux-64", + "timestamp": 1531065143469, + "version": "1.12" + }, + "xcb-proto-1.12-py36h27cfd23_1.tar.bz2": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "75d937d4e9d100d4830082424fe4bebc", + "name": "xcb-proto", + "namespace": "global", + "sha256": "3a9f7851aab6a115daf5239e704fb139790a6f24654c3a1153624135d9e77b74", + "size": 107432, + "subdir": "linux-64", + "timestamp": 1614066551392, + "version": "1.12" + }, + "xcb-proto-1.12-py36hf39a981_1.tar.bz2": { + "build": "py36hf39a981_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1176f83995341c4ccd756f8faada39b6", + "name": "xcb-proto", + "namespace": "global", + "sha256": "73cc3f78ccc0b43714a2a87d9205555f4f64cb740a2bb8737ffef4546c2501c1", + "size": 105143, + "subdir": "linux-64", + "timestamp": 1505734020624, + "version": "1.12" + }, + "xcb-proto-1.12-py37h14c3975_1.tar.bz2": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7d00f463e0eb5e0523a770f59df8db6a", + "name": "xcb-proto", + "namespace": "global", + "sha256": "df0574475b29a1bd95d2e72657ca08ae20756938191f473313db859181bb05e1", + "size": 105495, + "subdir": "linux-64", + "timestamp": 1531065180479, + "version": "1.12" + }, + "xcb-proto-1.12-py37h27cfd23_1.tar.bz2": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cbc41336c9f100a40216e69bfa7dc600", + "name": "xcb-proto", + "namespace": "global", + "sha256": "be69d3d67adba7a19cccca8162e2815d119df0021db199e82ca9e02d2a28625c", + "size": 107298, + "subdir": "linux-64", + "timestamp": 1614067276488, + "version": "1.12" + }, + "xcb-proto-1.12-py38h27cfd23_1.tar.bz2": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a6596a12a3b417bff06e8c8bc13f719f", + "name": "xcb-proto", + "namespace": "global", + "sha256": "defe40e62d06c30e079f0996f2188f148c90685142d6d4be34d31aa7bc467e13", + "size": 107350, + "subdir": "linux-64", + "timestamp": 1614067281069, + "version": "1.12" + }, + "xcb-proto-1.12-py38h7b6447c_1.tar.bz2": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f4967d2e2230f00b60e0fa6c4445be7", + "name": "xcb-proto", + "namespace": "global", + "sha256": "75eb6e2bab94539059cdc526968fda4416c3b879dfdff5cbb1875917dc895b75", + "size": 113113, + "subdir": "linux-64", + "timestamp": 1573730016702, + "version": "1.12" + }, + "xcb-proto-1.12-py39h27cfd23_1.tar.bz2": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b3a1c830a1c98167464efc90395e7c98", + "name": "xcb-proto", + "namespace": "global", + "sha256": "a30ec943953c14828ec3ab084737b8e29f4759cb9dbea5a54b2c7a72b5e8e6f5", + "size": 107366, + "subdir": "linux-64", + "timestamp": 1614066349044, + "version": "1.12" + }, + "xcb-proto-1.13-h1bed415_0.tar.bz2": { + "build": "h1bed415_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python" + ], + "md5": "43b1519aff5b678e3f608d0fff114f76", + "name": "xcb-proto", + "namespace": "global", + "sha256": "e64ec6a871e7450eb99d49bcd5e6e4454b38a2186d55a4024ccc9376989feb6f", + "size": 108682, + "subdir": "linux-64", + "timestamp": 1522698371233, + "version": "1.13" + }, + "xcb-proto-1.13-h1bed415_1.tar.bz2": { + "build": "h1bed415_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python" + ], + "md5": "9660462ceec030498f12075aef237e45", + "name": "xcb-proto", + "namespace": "global", + "sha256": "855b0a265710c43ce86a598c1cde367ab4f1378e491e91764f183779f3275b2a", + "size": 109138, + "subdir": "linux-64", + "timestamp": 1523637242969, + "version": "1.13" + }, + "xcb-proto-1.14-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "md5": "0a70882912cf14e68266cd9bd4a59592", + "name": "xcb-proto", + "namespace": "global", + "sha256": "f2416b7ad1ed10c52b447acfbfecc4f60a414b5422ac08cf4b35e85ba178839d", + "size": 111635, + "subdir": "linux-64", + "timestamp": 1593535405098, + "version": "1.14" + }, + "xcb-proto-1.14-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "md5": "43c522f613c22cd01196c3a23837b8f5", + "name": "xcb-proto", + "namespace": "global", + "sha256": "f43af9e9a30848ec59d4cef32d1e54895f95d5b2cad009651607c29d175a7e63", + "size": 111669, + "subdir": "linux-64", + "timestamp": 1593535416523, + "version": "1.14" + }, + "xerces-c-3.2.0-h1c8713b_0.tar.bz2": { + "build": "h1c8713b_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b611bdf095668023dbb3730d06551a46", + "name": "xerces-c", + "sha256": "43cfd4550d77e387b2e25a9565e6566993f7c734200be47c1234df167b68f13f", + "size": 3341761, + "subdir": "linux-64", + "timestamp": 1509503605043, + "version": "3.2.0" + }, + "xerces-c-3.2.0-h524ea4d_2.tar.bz2": { + "build": "h524ea4d_2", + "build_number": 2, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e55b28310693f7f6fd478fa8299ab267", + "name": "xerces-c", + "sha256": "d9c7a89e45558ec10a2e0deebf06ec89be086233b565851f6329abb5822106ca", + "size": 3337953, + "subdir": "linux-64", + "timestamp": 1510158423200, + "version": "3.2.0" + }, + "xerces-c-3.2.0-h5306e6a_1.tar.bz2": { + "build": "h5306e6a_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e216405f3847f5eb82ba74f0b30d21b4", + "name": "xerces-c", + "sha256": "12e69acf96eaffe808a5bbd1f4c8320963ae8d0e540bc24d9ed36ef3c0781e94", + "size": 3339572, + "subdir": "linux-64", + "timestamp": 1510093112821, + "version": "3.2.0" + }, + "xerces-c-3.2.1-hac72e42_0.tar.bz2": { + "build": "hac72e42_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3b9f25fda91ffaa5aa117cff48cf5ba8", + "name": "xerces-c", + "sha256": "feeda980c9c91ae8d785c5b4b7ef75a6c15d26344c0f29c08135289b927a96ab", + "size": 3346766, + "subdir": "linux-64", + "timestamp": 1522082323064, + "version": "3.2.1" + }, + "xerces-c-3.2.2-h780794e_0.tar.bz2": { + "build": "h780794e_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6dd209638aacd6282da6cab8589563ed", + "name": "xerces-c", + "sha256": "b2651d6a948800bb9bb7e18b4b947debec805b6eb8464131b924b5643aed3752", + "size": 3395962, + "subdir": "linux-64", + "timestamp": 1539730858945, + "version": "3.2.2" + }, + "xerces-c-3.2.3-h780794e_0.tar.bz2": { + "build": "h780794e_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8dc5173488d49dc09105ca6359fd4986", + "name": "xerces-c", + "sha256": "92db799484b158380af98f43d255e61469a759e1a3cf7e5dd0c900687880fd3b", + "size": 3476121, + "subdir": "linux-64", + "timestamp": 1599879004914, + "version": "3.2.3" + }, + "xerces-c-3.2.4-h94c2ce2_0.tar.bz2": { + "build": "h94c2ce2_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1de065240c270b629e1122bde773b27a", + "name": "xerces-c", + "sha256": "ec33b106bf0d7a03f98e457d1315cfb8805972710783474e8324644110de3dc8", + "size": 3603515, + "subdir": "linux-64", + "timestamp": 1668712691999, + "version": "3.2.4" + }, + "xgboost-1.3.3-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.3.3 py36h06a4308_0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "d0b198b8c1a3529f75a95ecbaef6fcae", + "name": "xgboost", + "sha256": "78b8ec7d621431416f3fd189fbfd5fd12a182764139628115f86a13e640e83bc", + "size": 22883, + "subdir": "linux-64", + "timestamp": 1619725060384, + "version": "1.3.3" + }, + "xgboost-1.3.3-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.3.3 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "14e95fb196a82dd96b9577e661374ba1", + "name": "xgboost", + "sha256": "58a96f2bef07f816c1cf6025b35d57c3f8e8e523554c7673f7c48cf1bb092617", + "size": 22861, + "subdir": "linux-64", + "timestamp": 1619725052872, + "version": "1.3.3" + }, + "xgboost-1.3.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.3.3 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "f218d0f3228fd682e7f05e5513da2dbd", + "name": "xgboost", + "sha256": "8250292c714946543f2bf0591e134b86cacb350362054d686843f11e56f24e4e", + "size": 22859, + "subdir": "linux-64", + "timestamp": 1619725067759, + "version": "1.3.3" + }, + "xgboost-1.3.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.3.3 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "07b166d6b97f1cbe076896df57c66d63", + "name": "xgboost", + "sha256": "02d8e317978cbd35731e7391f70ae6195b8711c048170b2eb6e7dbdd58d379e5", + "size": 22878, + "subdir": "linux-64", + "timestamp": 1619725045272, + "version": "1.3.3" + }, + "xgboost-1.5.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "py-xgboost 1.5.0 py310h06a4308_1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "950f4f174eb92693913bfa552f536ed9", + "name": "xgboost", + "sha256": "7e24c050fc1dadf1ae272ee60930759242e6b0e57e1b53c713d61ce747574581", + "size": 14418, + "subdir": "linux-64", + "timestamp": 1641558660057, + "version": "1.5.0" + }, + "xgboost-1.5.0-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "py-xgboost 1.5.0 py310h06a4308_2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "42ce2bffb08b989be03a3c1b4c5175cd", + "name": "xgboost", + "sha256": "50bcccc8a4920ad43a1ea280e97ef06a77a0e4358a2a0193b0541f37a2c122d2", + "size": 14968, + "subdir": "linux-64", + "timestamp": 1659549575202, + "version": "1.5.0" + }, + "xgboost-1.5.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "py-xgboost 1.5.0 py37h06a4308_1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "7e5a3285af38499a387b6cee4072a1ec", + "name": "xgboost", + "sha256": "71febbf8a615306eda9b280c83c483b307aba1e32da73ea220e4493ef61dd430", + "size": 24878, + "subdir": "linux-64", + "timestamp": 1638290439953, + "version": "1.5.0" + }, + "xgboost-1.5.0-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "py-xgboost 1.5.0 py37h06a4308_2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "0b249ca8a47f18e0044ab9957e167904", + "name": "xgboost", + "sha256": "e05ecf466878213d827bf26743ab8e5d9e23e63244ee288eb44665b34cdb9da7", + "size": 14946, + "subdir": "linux-64", + "timestamp": 1659549583165, + "version": "1.5.0" + }, + "xgboost-1.5.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "py-xgboost 1.5.0 py38h06a4308_1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "024c935d025de91d7036b9664b8e52bb", + "name": "xgboost", + "sha256": "c5db65bc13aaee1b1decd918ce2a5444ed1cd6bc3c65c0f9b8795f8c0e82c067", + "size": 24853, + "subdir": "linux-64", + "timestamp": 1638290428386, + "version": "1.5.0" + }, + "xgboost-1.5.0-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "py-xgboost 1.5.0 py38h06a4308_2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "22b5a7f82bc8588e7c5af09cadfa1655", + "name": "xgboost", + "sha256": "22355c90ea236402872c7352a5beef7e96f677ff9ed213b8d32c44ee1a4dc0dc", + "size": 14941, + "subdir": "linux-64", + "timestamp": 1659549558140, + "version": "1.5.0" + }, + "xgboost-1.5.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "py-xgboost 1.5.0 py39h06a4308_1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "2c9f783bdfe472c493385132d53210c7", + "name": "xgboost", + "sha256": "3265efdef936e8914820df05ab1d4bdf5fbc97ac3cec095086ba829bb31e7efd", + "size": 24876, + "subdir": "linux-64", + "timestamp": 1638290434279, + "version": "1.5.0" + }, + "xgboost-1.5.0-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "py-xgboost 1.5.0 py39h06a4308_2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "d77b004bdcb7b5b288ef4e96b4a5270d", + "name": "xgboost", + "sha256": "01a4337983e468365b6f653a8e911be5df6ea979f7f35a1e3ad5f989b472f1ec", + "size": 14942, + "subdir": "linux-64", + "timestamp": 1659549566670, + "version": "1.5.0" + }, + "xgboost-1.5.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.5.1 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fdb396ec18d55b8ec5d9c10ac8fbf40b", + "name": "xgboost", + "sha256": "8dc1778e68bdf67c146c2387b4ac7e46660c054538625970707fef8655484613", + "size": 13802, + "subdir": "linux-64", + "timestamp": 1675120221592, + "version": "1.5.1" + }, + "xgboost-1.5.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.5.1 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9f06e1a98a7431908dd5d0bff8e9638f", + "name": "xgboost", + "sha256": "8507e78221bb92b6ce48179b8178d5254b2215c09b18d68bde00392338d8b51c", + "size": 13779, + "subdir": "linux-64", + "timestamp": 1675120215524, + "version": "1.5.1" + }, + "xgboost-1.5.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.5.1 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1a1d8e86705f1c4fabac6f3d03d2fd6d", + "name": "xgboost", + "sha256": "736f55bfcc65f6799810b86be6473835e45448da24a5d394b9f6003075644b44", + "size": 13799, + "subdir": "linux-64", + "timestamp": 1675120203933, + "version": "1.5.1" + }, + "xgboost-1.5.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.5.1 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "094a340c4c2abfa194684235da3c1672", + "name": "xgboost", + "sha256": "55af652802d74ceb36ba84e869625344782bfd8ae0cf5429820f363267dd1176", + "size": 13771, + "subdir": "linux-64", + "timestamp": 1675120209568, + "version": "1.5.1" + }, + "xgboost-1.7.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.7.3 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e132e18752a3734faf6e6c8727b23ce4", + "name": "xgboost", + "sha256": "13a5d5e89375ae9652f14204eb8d68638a5fa31263b15c787bd3f8183828a2b5", + "size": 11478, + "subdir": "linux-64", + "timestamp": 1675458334122, + "version": "1.7.3" + }, + "xgboost-1.7.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.7.3 py311h06a4308_0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "05521b911a772c09383bd71085925fbb", + "name": "xgboost", + "sha256": "d76d98f05b1ab8a620e2d2c177e59ae6b8c357174a76b7a24cadb639594ab83c", + "size": 11804, + "subdir": "linux-64", + "timestamp": 1676922357173, + "version": "1.7.3" + }, + "xgboost-1.7.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.7.3 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "25e3e0374896fc5e4587c82416f7bb08", + "name": "xgboost", + "sha256": "17253664a8d70dae92bf4317e9e643cee6084e5104b15a66d965bc02466e8e39", + "size": 11432, + "subdir": "linux-64", + "timestamp": 1675458786974, + "version": "1.7.3" + }, + "xgboost-1.7.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.7.3 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6cf12405a8137b277750ecc4747718bf", + "name": "xgboost", + "sha256": "0cfbc8e035c219a76840102303684a5e8ca3e784af81f40d800ce05ea934f653", + "size": 11468, + "subdir": "linux-64", + "timestamp": 1675458570174, + "version": "1.7.3" + }, + "xlrd-1.1.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "cb18727772e8f3d1ada5b804e2f71a39", + "name": "xlrd", + "sha256": "13e365bf7530e3dc5f761c2208e477ef3c7c6c775a3468414127a80114332cf3", + "size": 197319, + "subdir": "linux-64", + "timestamp": 1530735954137, + "version": "1.1.0" + }, + "xlrd-1.1.0-py27ha77178f_1.tar.bz2": { + "build": "py27ha77178f_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "658ecf14e59fc777cb6d0f9af34d9ae1", + "name": "xlrd", + "sha256": "15da1c628de73d8e78f718bef9544746daebc5b4b80a888c80800abda8afcfac", + "size": 197205, + "subdir": "linux-64", + "timestamp": 1505957463525, + "version": "1.1.0" + }, + "xlrd-1.1.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "c21ae703d5ed01ede16933d1af98926a", + "name": "xlrd", + "sha256": "f57964a7d57690ba52c15394020006c9bf26b8c1a38cec01b77966c44820d172", + "size": 198770, + "subdir": "linux-64", + "timestamp": 1534352124391, + "version": "1.1.0" + }, + "xlrd-1.1.0-py35h45a0a2a_1.tar.bz2": { + "build": "py35h45a0a2a_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "6d3e60a8968643c89db87a82d0e3778d", + "name": "xlrd", + "sha256": "69e8fab515b76036761a1edafc23f5af3f64aee918361f68881f260b367d53fd", + "size": 198758, + "subdir": "linux-64", + "timestamp": 1505957478030, + "version": "1.1.0" + }, + "xlrd-1.1.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "fe8846385e713c5f5ba777726a838c6f", + "name": "xlrd", + "sha256": "7779eff17daad882b4e6e33464ab409033254e5ed10143fa7b7bc25e6e2fd455", + "size": 198473, + "subdir": "linux-64", + "timestamp": 1530735933445, + "version": "1.1.0" + }, + "xlrd-1.1.0-py36h1db9f0c_1.tar.bz2": { + "build": "py36h1db9f0c_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "536ec72d025279dc2fe1905334431fa4", + "name": "xlrd", + "sha256": "983482fe64ed789f8b10477d9710d6025998c3f88bd51b15281f93ce5a43b240", + "size": 198337, + "subdir": "linux-64", + "timestamp": 1505957492488, + "version": "1.1.0" + }, + "xlrd-1.1.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "ce2017d621c821f400829d1c06775112", + "name": "xlrd", + "sha256": "fa8984c5050f1b7041b92497efc3e975f0baeee78a4bdf983594264b53ed7754", + "size": 196337, + "subdir": "linux-64", + "timestamp": 1530735975270, + "version": "1.1.0" + }, + "xlrd-1.2.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "19261febc0ec5c0bf4e1cf9ba9c069b4", + "name": "xlrd", + "sha256": "10dab01b91f3267daab037a3c8a8473e4dc71db2aad5a54429ed9ed770032237", + "size": 191133, + "subdir": "linux-64", + "timestamp": 1545084033314, + "version": "1.2.0" + }, + "xlrd-1.2.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "e08c0248eb387b0d52a2ee6a7bce2391", + "name": "xlrd", + "sha256": "8226d12a4c8b24ce1aebd7833a00f790d9a80ef5c74ef894413ecad571d36efe", + "size": 192404, + "subdir": "linux-64", + "timestamp": 1545084063693, + "version": "1.2.0" + }, + "xlrd-1.2.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "b332f6f4b20513a0169f77f6314909ad", + "name": "xlrd", + "sha256": "ad5fd3fb828dbf5000fe77ba696a5e37eb9486eca6fa399c1441fe49113f5832", + "size": 190216, + "subdir": "linux-64", + "timestamp": 1545084091435, + "version": "1.2.0" + }, + "xlsxwriter-0.9.8-py27h260ecd4_0.tar.bz2": { + "build": "py27h260ecd4_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f8bff206ea36e9f4b08e6f9f17a539af", + "name": "xlsxwriter", + "sha256": "a71d2ea8c6dd8922945dfb6b7266bc4aadffc8af4d9b051eccaf6a1f134d7b6a", + "size": 201551, + "subdir": "linux-64", + "timestamp": 1505852136453, + "version": "0.9.8" + }, + "xlsxwriter-0.9.8-py35hc9d400f_0.tar.bz2": { + "build": "py35hc9d400f_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "105d0ec0e4be43cfc651cd208f3b0521", + "name": "xlsxwriter", + "sha256": "4ac3f9246f862f000887556311949255cd42882e9e20178eb8ec47edafa426e8", + "size": 205332, + "subdir": "linux-64", + "timestamp": 1505852150722, + "version": "0.9.8" + }, + "xlsxwriter-0.9.8-py36hf41c223_0.tar.bz2": { + "build": "py36hf41c223_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "039b0fc17fc4e26a6dc5f6489bf9d2f3", + "name": "xlsxwriter", + "sha256": "a9f26376fdc54ea609bcac11e834e40baa5cc657628ce704ea964879e656c3fb", + "size": 203262, + "subdir": "linux-64", + "timestamp": 1505852165158, + "version": "0.9.8" + }, + "xlsxwriter-1.0.2-py27h12cbc6b_0.tar.bz2": { + "build": "py27h12cbc6b_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "2b3ac0db7b9b9315fc3a4d3deadbba60", + "name": "xlsxwriter", + "sha256": "192694ca5bf53c236a286fd85c3b28eb3880508eee84cda4820b3066dececdf3", + "size": 205693, + "subdir": "linux-64", + "timestamp": 1508626765468, + "version": "1.0.2" + }, + "xlsxwriter-1.0.2-py35h8ee9321_0.tar.bz2": { + "build": "py35h8ee9321_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7080e59f00a80e6a86aefc2adaca14c2", + "name": "xlsxwriter", + "sha256": "0315655ec59a1a00996f8544349b2ed8e844cefa976d5cfff9f785edb4dc8091", + "size": 208970, + "subdir": "linux-64", + "timestamp": 1508626736309, + "version": "1.0.2" + }, + "xlsxwriter-1.0.2-py36h3de1aca_0.tar.bz2": { + "build": "py36h3de1aca_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "0d97ba16444a251183e6542f4b131d33", + "name": "xlsxwriter", + "sha256": "a8cea224b1604121efd3c70600d86d51b39374dd8a7cd056b192cb00a9582f45", + "size": 206945, + "subdir": "linux-64", + "timestamp": 1508626789486, + "version": "1.0.2" + }, + "xlsxwriter-1.0.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c33b62f66c52a8ca0a675a816f83825f", + "name": "xlsxwriter", + "sha256": "b4c7a70b717ff6dc8174f73f51eafc9b2365ea573de2eced25f0cf298173f519", + "size": 209287, + "subdir": "linux-64", + "timestamp": 1523945846481, + "version": "1.0.4" + }, + "xlsxwriter-1.0.4-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8d43226092b2c92ce07692836c1cd192", + "name": "xlsxwriter", + "sha256": "ef844f539783b1a3f5d86251f5b3e97b240f89ace84af5fe6437c644b62c31a3", + "size": 212901, + "subdir": "linux-64", + "timestamp": 1523946057706, + "version": "1.0.4" + }, + "xlsxwriter-1.0.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b41285ae18b3e11daf4965648b089181", + "name": "xlsxwriter", + "sha256": "2855283ab3ccdf5485000d9f6aedca9c32723a28f17f8c5279fa35a8e3b58892", + "size": 210825, + "subdir": "linux-64", + "timestamp": 1523946050359, + "version": "1.0.4" + }, + "xlsxwriter-1.0.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8cbf0d0a49a37a4b7eb772eab486d85d", + "name": "xlsxwriter", + "sha256": "914b612ebb995a27940ddd242fbd54d54430fd11c6756c2873987c9c3803c2af", + "size": 212029, + "subdir": "linux-64", + "timestamp": 1527829440164, + "version": "1.0.5" + }, + "xlsxwriter-1.0.5-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e4404245ba03c24f8bf46bcca46bbfe2", + "name": "xlsxwriter", + "sha256": "c5a16bb9b5a42f51a5f147039fe580fd53b7e563744b9804a311ba173b620003", + "size": 216125, + "subdir": "linux-64", + "timestamp": 1527830312008, + "version": "1.0.5" + }, + "xlsxwriter-1.0.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8cf918a985ef6a870eeaa4360000a021", + "name": "xlsxwriter", + "sha256": "8fd1fc9590cb30df05d39ee1b6e33e8420e3a08bae25dbb98202a80995d3e787", + "size": 213902, + "subdir": "linux-64", + "timestamp": 1527829417802, + "version": "1.0.5" + }, + "xlsxwriter-1.0.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c72a462bb234d6e636664fe5e17cce9a", + "name": "xlsxwriter", + "sha256": "6ab4cae494056e0eb158e3f439dc27b46800c22e20f1f8e057c800344fea7799", + "size": 213101, + "subdir": "linux-64", + "timestamp": 1531065251202, + "version": "1.0.5" + }, + "xlsxwriter-1.0.7-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d084657e70df6ac81363cd755a1c7317", + "name": "xlsxwriter", + "sha256": "b2168ec1b7baaf24114269b1222a370b4a41ca02280c7632c6b5c470703865e9", + "size": 211894, + "subdir": "linux-64", + "timestamp": 1534949128769, + "version": "1.0.7" + }, + "xlsxwriter-1.0.7-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "47f68d1a52fc55cc6428e87ee03d547c", + "name": "xlsxwriter", + "sha256": "4c58941ab48ef90e3b47655a964b8aff599acd0ad7b35d74cdd0c51ae455314f", + "size": 215336, + "subdir": "linux-64", + "timestamp": 1534949196997, + "version": "1.0.7" + }, + "xlsxwriter-1.0.7-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "322f47cb400383b0ba3f4906d59c0189", + "name": "xlsxwriter", + "sha256": "37a6549f7731d2889e27b2ac4e446af381d79b1490b4c296f13a087c1290e0de", + "size": 213964, + "subdir": "linux-64", + "timestamp": 1534949166534, + "version": "1.0.7" + }, + "xlsxwriter-1.0.7-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a8e6dda80891320d20ef760dfcff6011", + "name": "xlsxwriter", + "sha256": "9cf90c0a83477819edcfeaacdbe150a139b45a3f00cceef1e1dc5af01297ed4f", + "size": 213041, + "subdir": "linux-64", + "timestamp": 1534949145433, + "version": "1.0.7" + }, + "xlsxwriter-1.0.8-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "92e61bd6e9206bbbb6934cdca5211f32", + "name": "xlsxwriter", + "sha256": "a24fcc5fffad72cdea71b51fa29fbc0d24e5c7bdfda4404951788f49150f9bbb", + "size": 213181, + "subdir": "linux-64", + "timestamp": 1535380656812, + "version": "1.0.8" + }, + "xlsxwriter-1.0.8-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8ae79f4dee585e98540a6a942b73a50e", + "name": "xlsxwriter", + "sha256": "4ed0bd30916b123fd1f4db1fa768f892a06b775cca4ed997611b6e1241c8c354", + "size": 216848, + "subdir": "linux-64", + "timestamp": 1535380555654, + "version": "1.0.8" + }, + "xlsxwriter-1.0.8-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "60db6cfa550fcd0a8a45ec08f30f8158", + "name": "xlsxwriter", + "sha256": "611ae73092bf21b8658b62a34a817a14205f1e6aa16667389008884d56630c22", + "size": 214906, + "subdir": "linux-64", + "timestamp": 1535380516825, + "version": "1.0.8" + }, + "xlsxwriter-1.0.8-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b3a7978a533868b1231a95f0cc6b93ba", + "name": "xlsxwriter", + "sha256": "27216f11c2149d7582975fd87e489b0a169d574e87428014f4bc97c5bb4d69fe", + "size": 214428, + "subdir": "linux-64", + "timestamp": 1535380669643, + "version": "1.0.8" + }, + "xlsxwriter-1.1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3671afea3d31ece435c48a7273f9ffed", + "name": "xlsxwriter", + "sha256": "269552f21832879d6f35b533109848adc0a4ba8b5ea989d54e3d2a17bc225071", + "size": 213151, + "subdir": "linux-64", + "timestamp": 1536083864946, + "version": "1.1.0" + }, + "xlsxwriter-1.1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e49e0759869a9c26833aa1d058b256e2", + "name": "xlsxwriter", + "sha256": "62f6c284d9517471e4e1d7e0bf17f7872720adace682df46e6ef121a5c3cefae", + "size": 216550, + "subdir": "linux-64", + "timestamp": 1536080224388, + "version": "1.1.0" + }, + "xlsxwriter-1.1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8a037f33bfa9f37131542be81d72c18a", + "name": "xlsxwriter", + "sha256": "e45107cfef306bc5916cabc46373cb7aa29f22bc2a8f3c3367aae10319997128", + "size": 214971, + "subdir": "linux-64", + "timestamp": 1536080194913, + "version": "1.1.0" + }, + "xlsxwriter-1.1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "eb5646758d19d6c06cf46c41084d784b", + "name": "xlsxwriter", + "sha256": "3c9c0620d88195fbf677201be977afe8c535dd6fa2396599e0d92fb6bc9f1cb5", + "size": 214568, + "subdir": "linux-64", + "timestamp": 1536083890472, + "version": "1.1.0" + }, + "xlsxwriter-1.1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d2896ef21ac2bacf6e225cb7d607fd28", + "name": "xlsxwriter", + "sha256": "7dcd2b18310a76b38eab40ddd214886e71c7ea25900f09dea0da21fa5755309e", + "size": 215695, + "subdir": "linux-64", + "timestamp": 1538231258162, + "version": "1.1.1" + }, + "xlsxwriter-1.1.1-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f8d5b1f174db9801069ced1895c39011", + "name": "xlsxwriter", + "sha256": "6d52cad4f722b51015619ecdafc58e51a76d2a6ef080df5e5731396d658ebcae", + "size": 218758, + "subdir": "linux-64", + "timestamp": 1538231285440, + "version": "1.1.1" + }, + "xlsxwriter-1.1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "44f3b9aee2309c9ca69163de402270f9", + "name": "xlsxwriter", + "sha256": "d95e30e4ce41e84e0961ba26aecea6c374f1527599ec51af46cbda1be96381bb", + "size": 217232, + "subdir": "linux-64", + "timestamp": 1538231284767, + "version": "1.1.1" + }, + "xlsxwriter-1.1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5acda9756a60239b8a9f6af899262d91", + "name": "xlsxwriter", + "sha256": "3f7af8b0decfd583fb94f5742890bce30207822cf48f6bbf29da78d282fffd43", + "size": 216682, + "subdir": "linux-64", + "timestamp": 1538231245788, + "version": "1.1.1" + }, + "xlsxwriter-1.1.2-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "35dbca23c2ea5066d3818cea6eeaf9f6", + "name": "xlsxwriter", + "sha256": "4596d96401d16e0c46a5c5743f121c45950728231d7d564c695cb8c782501798", + "size": 216648, + "subdir": "linux-64", + "timestamp": 1540236392823, + "version": "1.1.2" + }, + "xlsxwriter-1.1.2-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "31aeaebe5934791461c8c551f72f3d05", + "name": "xlsxwriter", + "sha256": "78040fb692f7e20f5c87d8b2a5e8ba5d31ef65d98cd2a49726f7cab54ef46ec8", + "size": 218203, + "subdir": "linux-64", + "timestamp": 1540236436649, + "version": "1.1.2" + }, + "xlsxwriter-1.1.2-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c3ed46aef2542d80f1de43f6482494f8", + "name": "xlsxwriter", + "sha256": "948c4a5637f679171fa3894dffb61ecbcea47b70fa83cc7cdaa13d7750548e5b", + "size": 217399, + "subdir": "linux-64", + "timestamp": 1540236431121, + "version": "1.1.2" + }, + "xlsxwriter-1.1.5-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e2d0255992ed22e086135f475e03aba6", + "name": "xlsxwriter", + "sha256": "c3ce7496f7143b9c8fda2dd556b815760ac31684d2c31133ada9fffa34593efe", + "size": 218734, + "subdir": "linux-64", + "timestamp": 1551149758442, + "version": "1.1.5" + }, + "xlsxwriter-1.1.5-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7417570137fce01fac246c8c5e0fb9bc", + "name": "xlsxwriter", + "sha256": "9be0f6cc7f5c54afe9b350cba1c0ca7c0118ad8ffc3aaf69eb008afd8256e748", + "size": 218016, + "subdir": "linux-64", + "timestamp": 1551149776375, + "version": "1.1.5" + }, + "xlsxwriter-1.1.5-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b707437930abf9e9e3b45d39a39f41b7", + "name": "xlsxwriter", + "sha256": "d81562561bf4e2743a44ebba9bf3781b5125d9e5298a3eb64b4d3db8f9735649", + "size": 217475, + "subdir": "linux-64", + "timestamp": 1551149751540, + "version": "1.1.5" + }, + "xlutils-2.0.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "xlrd >=0.7.2", + "xlwt >=0.7.4" + ], + "license": "MIT", + "md5": "4bf529952855881156f7cc1adaf31cb1", + "name": "xlutils", + "sha256": "3938785bbd8e350e5c9450699da3d6facb08deeefb07945228aa945d19e06187", + "size": 77590, + "subdir": "linux-64", + "timestamp": 1540320449699, + "version": "2.0.0" + }, + "xlutils-2.0.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "xlrd >=0.7.2", + "xlwt >=0.7.4" + ], + "license": "MIT", + "md5": "9db4265b0606a10e84466c50d4d464a1", + "name": "xlutils", + "sha256": "839ee9aad2810ae0b8b9de7a06a9996c405a4064c5cb02e3d2c2abc3c860b413", + "size": 78772, + "subdir": "linux-64", + "timestamp": 1540320491367, + "version": "2.0.0" + }, + "xlutils-2.0.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "xlrd >=0.7.2", + "xlwt >=0.7.4" + ], + "license": "MIT", + "md5": "52729fca74ce19f338c9c527c0e4af99", + "name": "xlutils", + "sha256": "490173f9cafa69210041acb669a5a198b52d3e07c18f1f4d6c9d4c81f1eb5037", + "size": 78507, + "subdir": "linux-64", + "timestamp": 1540320515747, + "version": "2.0.0" + }, + "xlwt-1.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "5526ba4c3e8fe7ea5de822db7ab609b1", + "name": "xlwt", + "sha256": "b71d6bd242230900717ee54405661243c5d09631ed221b95e19a0088b32a04cc", + "size": 163730, + "subdir": "linux-64", + "timestamp": 1531065354863, + "version": "1.3.0" + }, + "xlwt-1.3.0-py27h3d85d97_0.tar.bz2": { + "build": "py27h3d85d97_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "c2f6ed08836cfc603894c2c67415f979", + "name": "xlwt", + "sha256": "be653d85bdafda93c0b66b9d160df64dae3fc7d82d94c0da7392cf213e8b642f", + "size": 163348, + "subdir": "linux-64", + "timestamp": 1505852179274, + "version": "1.3.0" + }, + "xlwt-1.3.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "9e54115da4d55ebf3fe9aba8bb31caab", + "name": "xlwt", + "sha256": "d97f84380f80a4bc22b8797ed459e3b1c2fb278e024525fe2dd379d7118e13fa", + "size": 173154, + "subdir": "linux-64", + "timestamp": 1640796107721, + "version": "1.3.0" + }, + "xlwt-1.3.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "9a7425fc0166fbebb359b4bf805a7058", + "name": "xlwt", + "sha256": "3153844d757c65d03b30a970135cfdba0a9b8f1027accc898e162d3540238661", + "size": 218074, + "subdir": "linux-64", + "timestamp": 1676863547463, + "version": "1.3.0" + }, + "xlwt-1.3.0-py35h884a0cf_0.tar.bz2": { + "build": "py35h884a0cf_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "a036a37ef5057b912bc74eae870b0b0a", + "name": "xlwt", + "sha256": "6576ff21d02d8f7afb87991ad923355bbcc87393b80f5a120ec388d187daa451", + "size": 168509, + "subdir": "linux-64", + "timestamp": 1505852192718, + "version": "1.3.0" + }, + "xlwt-1.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "5a093ba65c4def0d740b406f0173b11c", + "name": "xlwt", + "sha256": "3f960129780aee7c3a8c503b78613047e05da0c340b5d1c96bc0db8be20bdbc9", + "size": 166673, + "subdir": "linux-64", + "timestamp": 1531065286737, + "version": "1.3.0" + }, + "xlwt-1.3.0-py36h7b00a1f_0.tar.bz2": { + "build": "py36h7b00a1f_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "4b544d450a435c02505552f6976042e8", + "name": "xlwt", + "sha256": "46b85cc2265faec26d1a3dbe5958869817b7a64137c0d9f0324d75d849afd4a9", + "size": 166335, + "subdir": "linux-64", + "timestamp": 1505852206320, + "version": "1.3.0" + }, + "xlwt-1.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "fca17f6b2f62d38d0062358dcc630cd6", + "name": "xlwt", + "sha256": "8a2ec8b854ce17ab493416a6d27420d3ec1ad8108891b3d6db858e5e31cb06c0", + "size": 166203, + "subdir": "linux-64", + "timestamp": 1531065321284, + "version": "1.3.0" + }, + "xlwt-1.3.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "3a5194516cd5da77b563418ab3fa1613", + "name": "xlwt", + "sha256": "6ba22a810c9cc6309e3ac56b51aae5adf1d37cc427affc88869ccc4829c171d7", + "size": 167299, + "subdir": "linux-64", + "timestamp": 1573730053566, + "version": "1.3.0" + }, + "xlwt-1.3.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "1b2c27b60f52e323d6b1c87d4175af26", + "name": "xlwt", + "sha256": "bb34c08ec90e09e317ac65513d1711b53751464b3dbec130b98e37fbd223e0d4", + "size": 167365, + "subdir": "linux-64", + "timestamp": 1607542800454, + "version": "1.3.0" + }, + "xmlrpc2-0.3.1-py27_2.tar.bz2": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "01f7a9af29c6621497b2cacc309d9631", + "name": "xmlrpc2", + "sha256": "6eaae0b8885f1c243fefd72fbc46f6825019964681c2a3084481924e9f6520f6", + "size": 11227, + "subdir": "linux-64", + "timestamp": 1530022663593, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py310h06a4308_2.tar.bz2": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "e28de7086beac9850b2251b3f15e18da", + "name": "xmlrpc2", + "sha256": "7efc93ae31183bcabc5f83bb6e3720fbf99f1890c5f9d25d9e392bdf445348fe", + "size": 11718, + "subdir": "linux-64", + "timestamp": 1640796125743, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py311h06a4308_2.tar.bz2": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "7485bcd7fee9db3e1e8382389f67b86e", + "name": "xmlrpc2", + "sha256": "cd5bf9bb89163c9c52e06c09f5060241fc547fcf9a0fe062b84baeb0a904c6cb", + "size": 14991, + "subdir": "linux-64", + "timestamp": 1676907829709, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py35_2.tar.bz2": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "0e97b237dd2b6b018c70e399bbf331da", + "name": "xmlrpc2", + "sha256": "5b099a4741ce0d47c49d01c3bccb4c6f6a9a5229dc744331387aeb0d75badfdd", + "size": 11456, + "subdir": "linux-64", + "timestamp": 1530022738965, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py36_2.tar.bz2": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "3ab1d7c713deecdfd20e35de95c4e868", + "name": "xmlrpc2", + "sha256": "38c1106b4c40c0aefa78824ba9857e2303b76bd997185f75596850ccb2467a8f", + "size": 11425, + "subdir": "linux-64", + "timestamp": 1530022643056, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py36h06a4308_2.tar.bz2": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "a121cea30bb203a9aa2bf9e84dc684d6", + "name": "xmlrpc2", + "sha256": "023c8a17a1819c5594b43be505f23b852a3ec0fba4b0ec24ae4935a0dac5b0eb", + "size": 227999, + "subdir": "linux-64", + "timestamp": 1613159725309, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py37_2.tar.bz2": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "fc8df739866c33a119e8c1cf179c66ad", + "name": "xmlrpc2", + "sha256": "eacb8d231e283919a019780c0bec4a3a239294d18ebe26e120842221218a332d", + "size": 11628, + "subdir": "linux-64", + "timestamp": 1545233507649, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py37h06a4308_2.tar.bz2": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "e3537893c4a0fa85da99405ea9cee063", + "name": "xmlrpc2", + "sha256": "e01f973e0ca8f47afd9765d0088bef7d438a70ffa7329a694333b0dd0721d571", + "size": 228029, + "subdir": "linux-64", + "timestamp": 1613159719197, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py38_2.tar.bz2": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "e4a52a23377199bf8a6863bf70dcee94", + "name": "xmlrpc2", + "sha256": "c7ad7bcf633acd309ad90a861517c8335ad7068ae782805e8273fd277126ef81", + "size": 11875, + "subdir": "linux-64", + "timestamp": 1574237992569, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py38h06a4308_2.tar.bz2": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "97c6aee565f36255fd23183962b4edd2", + "name": "xmlrpc2", + "sha256": "1518ccf19cff2820a0a71c42c504e3c08b71563f4944dfbfc675eee12ad532bf", + "size": 228293, + "subdir": "linux-64", + "timestamp": 1613159262164, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py39h06a4308_2.tar.bz2": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "ef20d302f0475662ffcc08fe56445274", + "name": "xmlrpc2", + "sha256": "19bab235d1857e9e243e9d6726bc35f484b7126beaacab4a49b764ccca9fc150", + "size": 227515, + "subdir": "linux-64", + "timestamp": 1613159722399, + "version": "0.3.1" + }, + "xmlsec-1.3.10-py310hfa300c1_0.tar.bz2": { + "build": "py310hfa300c1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxmlsec1 >=1.2.32,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "28f5a0000fa24b4f292a224bf91154c6", + "name": "xmlsec", + "sha256": "6b489168028577d515fbc5cd587f46311d6f31278263611e0ab07a84e022454c", + "size": 165749, + "subdir": "linux-64", + "timestamp": 1641480333640, + "version": "1.3.10" + }, + "xmlsec-1.3.10-py311h0cc8e7e_0.tar.bz2": { + "build": "py311h0cc8e7e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "libxmlsec1 >=1.2.32,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f457d3686af90bba8b9411cc0e2d3a84", + "name": "xmlsec", + "sha256": "5b346649a7c91225a3960d74628c0287a7b3ae091cee871d17901d6d0cbe5cd8", + "size": 157017, + "subdir": "linux-64", + "timestamp": 1676907851352, + "version": "1.3.10" + }, + "xmlsec-1.3.13-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "libxmlsec1 >=1.2.32,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a93cb282d9e9c1c69b2a62ef57fb54b", + "name": "xmlsec", + "sha256": "d7e3c4f80f65f2caa9ffd4ca97669e6e5581963a1dcf4f0c1232f5ddf77a171e", + "size": 158227, + "subdir": "linux-64", + "timestamp": 1679915886203, + "version": "1.3.13" + }, + "xmlsec-1.3.13-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "libxmlsec1 >=1.2.32,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d674cafe4167b18811c57b1c5071aeb4", + "name": "xmlsec", + "sha256": "f8d7c40b240ddc6c2a2c6b998d302a65fb5dd2c5bf9925bf6dd18a36c4db1768", + "size": 162011, + "subdir": "linux-64", + "timestamp": 1679915983871, + "version": "1.3.13" + }, + "xmlsec-1.3.13-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "libxmlsec1 >=1.2.32,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4a9144a021c792e50f14b47a22674555", + "name": "xmlsec", + "sha256": "9d7d25e9d793709ca6db3727b132cbf755ce45d3fe3a0e7d5748585173f3613e", + "size": 158854, + "subdir": "linux-64", + "timestamp": 1679915950755, + "version": "1.3.13" + }, + "xmlsec-1.3.13-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "libxmlsec1 >=1.2.32,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "133c8e4095b96ba46672db31a4eb46ab", + "name": "xmlsec", + "sha256": "e1382b263fed17d6fca12ebc8aac6f8101958cd20a935c87fc31c721630d3c0f", + "size": 156649, + "subdir": "linux-64", + "timestamp": 1679915917972, + "version": "1.3.13" + }, + "xmlsec-1.3.3-py36h0e8eec6_0.tar.bz2": { + "build": "py36h0e8eec6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxmlsec1 >=1.2.29,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "05d294eac63e8638bfee1976df2258bd", + "name": "xmlsec", + "sha256": "082fbfbfe975ed7dbd2bf2e8a5e18f09c3fc54dd56e8da2b9e62cde58d8b861c", + "size": 313866, + "subdir": "linux-64", + "timestamp": 1584995656132, + "version": "1.3.3" + }, + "xmlsec-1.3.3-py36h49a3d8c_0.tar.bz2": { + "build": "py36h49a3d8c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxmlsec1 >=1.2.29,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f768d96eb1f9abc40264eb825ed3a7d2", + "name": "xmlsec", + "sha256": "1d6c6ab42aab7afe35ab93eacd659cb914a2b0a06e028c2ddc463f6a792f5aae", + "size": 368144, + "subdir": "linux-64", + "timestamp": 1613393300545, + "version": "1.3.3" + }, + "xmlsec-1.3.3-py37h0e8eec6_0.tar.bz2": { + "build": "py37h0e8eec6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxmlsec1 >=1.2.29,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ce4f2777583843d9dcea0470815fcd8", + "name": "xmlsec", + "sha256": "774740e9457ececac9478d2b1eff35589f98e8ea65b30be3c2af03f57abde735", + "size": 316927, + "subdir": "linux-64", + "timestamp": 1584995654935, + "version": "1.3.3" + }, + "xmlsec-1.3.3-py37h49a3d8c_0.tar.bz2": { + "build": "py37h49a3d8c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxmlsec1 >=1.2.29,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ccb3432850454c676dbbf725eecf54f", + "name": "xmlsec", + "sha256": "e02c2e51462a076b948acb778915ccaa1366e5ee57b742c4b38e0638e2e7044d", + "size": 372357, + "subdir": "linux-64", + "timestamp": 1613393302446, + "version": "1.3.3" + }, + "xmlsec-1.3.3-py38h0e8eec6_0.tar.bz2": { + "build": "py38h0e8eec6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxmlsec1 >=1.2.29,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e5ac6553406abd2b4090580b6bff3e9e", + "name": "xmlsec", + "sha256": "7b3a7c550a68d524ecf0040ee7a6ab2c1d9bee8b0595d92371582a65c485cb15", + "size": 319511, + "subdir": "linux-64", + "timestamp": 1584995650789, + "version": "1.3.3" + }, + "xmlsec-1.3.3-py38h49a3d8c_0.tar.bz2": { + "build": "py38h49a3d8c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxmlsec1 >=1.2.29,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de14cb3c68352418967ce94be5e3abc3", + "name": "xmlsec", + "sha256": "2e1d59ed1905f9665b93e8207ad41efae31a891caab1d41d032018ca82935c8f", + "size": 375714, + "subdir": "linux-64", + "timestamp": 1613393237639, + "version": "1.3.3" + }, + "xmlsec-1.3.3-py39h49a3d8c_0.tar.bz2": { + "build": "py39h49a3d8c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxmlsec1 >=1.2.29,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e1e3f0716d62710bb32e8482798aa1d6", + "name": "xmlsec", + "sha256": "94be1f87a22d2bc6784908666c8cbc212dfe5331ca20a70e11815402beba6a6e", + "size": 374460, + "subdir": "linux-64", + "timestamp": 1613393236020, + "version": "1.3.3" + }, + "xmltodict-0.11.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "34ef0aca394bfeb31631fc058942af32", + "name": "xmltodict", + "sha256": "d01be22c9fcdb5c5df419e705afebd7134a5b083305f1775c5f7aeb9b0169390", + "size": 14636, + "subdir": "linux-64", + "timestamp": 1536857584645, + "version": "0.11.0" + }, + "xmltodict-0.11.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "8142699cde7406b22dd97d8d646048ab", + "name": "xmltodict", + "sha256": "dcb130b0b9232ff723d74fbc0e4267bbdbe9b84a01ec33cd1a8bc113a6adc0d0", + "size": 14746, + "subdir": "linux-64", + "timestamp": 1536857704113, + "version": "0.11.0" + }, + "xmltodict-0.11.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "44a902864c83492c011283afa14a5563", + "name": "xmltodict", + "sha256": "1260069ff1ba81ca7cc1c1f189bd4428edc9b853d14f9c9c6f4aeb6d573a3abd", + "size": 14720, + "subdir": "linux-64", + "timestamp": 1536857678746, + "version": "0.11.0" + }, + "xmltodict-0.11.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "22ca7d0e1dc1f73229f83771ec5d214b", + "name": "xmltodict", + "sha256": "54cb43b9410fea4fa170370889b67f956f769f1efcbd92f03e9614d034b0a65a", + "size": 14745, + "subdir": "linux-64", + "timestamp": 1536857563546, + "version": "0.11.0" + }, + "xorg-util-macros-1.19.0-h27cfd23_1.tar.bz2": { + "build": "h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1a40ba1b1100211fe8ba33484f90c0c", + "name": "xorg-util-macros", + "sha256": "d18c90b162850d93f29add12e328a72becca7d9422a6117e65d16d0a0990968b", + "size": 53468, + "subdir": "linux-64", + "timestamp": 1607596307831, + "version": "1.19.0" + }, + "xorg-util-macros-1.19.0-h27cfd23_2.tar.bz2": { + "build": "h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a0de2c24dfb2d498bc2f0dcb6eade04", + "name": "xorg-util-macros", + "sha256": "dacf2b9d9f99287c2b2d9e4738e9493276bdd9fda93a902e88f23d245ed2b75d", + "size": 53527, + "subdir": "linux-64", + "timestamp": 1608058495834, + "version": "1.19.0" + }, + "xorg-xproto-7.0.31-h27cfd23_1007.tar.bz2": { + "build": "h27cfd23_1007", + "build_number": 1007, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7638aa708e96e15149bb713633c2cdf7", + "name": "xorg-xproto", + "sha256": "b25727936b0844254d78b9247023fc6d682ce812ba7cf5ea289d651d399a395d", + "size": 78329, + "subdir": "linux-64", + "timestamp": 1608060663059, + "version": "7.0.31" + }, + "xsimd-10.0.0-hdb19cb5_0.tar.bz2": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "86e5aceaab697918dc4b167f85cd2b1a", + "name": "xsimd", + "sha256": "eb3614e1f3d08980fe8b2269ede64d2bdf008f008a832a8c25559a368d85e907", + "size": 104184, + "subdir": "linux-64", + "timestamp": 1674510107603, + "version": "10.0.0" + }, + "xsimd-7.5.0-hd09550d_1.tar.bz2": { + "build": "hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88586a1cfd0c4651d03b7a21bd0458b1", + "name": "xsimd", + "sha256": "35fcb2381222e98a9f7475515531ba69f03327b0e1de7b20a9116b5f4291dea9", + "size": 105745, + "subdir": "linux-64", + "timestamp": 1625061921267, + "version": "7.5.0" + }, + "xsimd-7.6.0-hd09550d_0.tar.bz2": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "54c13e8a53818883eab000227fbec4dd", + "name": "xsimd", + "sha256": "d4ccb071de2fae5e62edfcc3b767eea213c92a896494c89788efede98a12437f", + "size": 121999, + "subdir": "linux-64", + "timestamp": 1631121334121, + "version": "7.6.0" + }, + "xsimd-8.0.5-hdb19cb5_0.tar.bz2": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5c64d5c9d3e03337e9a85e604b60bf08", + "name": "xsimd", + "sha256": "b306a5d9bc30471a5abaefdf00c61d6a5f43f1517b1af28b62e49edbe1c39ff4", + "size": 83350, + "subdir": "linux-64", + "timestamp": 1659988723476, + "version": "8.0.5" + }, + "xsimd-9.0.1-hdb19cb5_0.tar.bz2": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "57db97985923fac8e094eea3a2c96a88", + "name": "xsimd", + "sha256": "59108c38d5326058b3337842c83cfb886cea41f3470c1134c199f954668b00f6", + "size": 103341, + "subdir": "linux-64", + "timestamp": 1668700367347, + "version": "9.0.1" + }, + "xxhash-0.8.0-h7f8727e_3.tar.bz2": { + "build": "h7f8727e_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "BSD-2-Clause", + "md5": "b660f7bd1ac43f503751f6129f4a15a1", + "name": "xxhash", + "sha256": "510669621e06aa9a7c3cb7e49052babf296dba59fac821cc547ac4b41257e5f4", + "size": 92752, + "subdir": "linux-64", + "timestamp": 1633100384388, + "version": "0.8.0" + }, + "xyzservices-2022.9.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fc65fa37a5784c32bfa3d2d5d19f60a9", + "name": "xyzservices", + "sha256": "afff05263ef5a31b8180b5f28b5c5d24b0b5fed523b99e65caffe8a90c4ecebb", + "size": 47912, + "subdir": "linux-64", + "timestamp": 1665472449729, + "version": "2022.9.0" + }, + "xyzservices-2022.9.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "19e7ea26af10c4cab50f154f358048b3", + "name": "xyzservices", + "sha256": "3a40d7ba77be22b17da9ad610218f01b4401b05a27eaeadafa417140dac1d8b0", + "size": 47939, + "subdir": "linux-64", + "timestamp": 1675159089417, + "version": "2022.9.0" + }, + "xyzservices-2022.9.0-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9f7353d72046b16dd6ef6b5689ac9bfd", + "name": "xyzservices", + "sha256": "d18cdca154bf668826f869117ea996c4f9e8ef7d27b7c528332a7d17e5a8602c", + "size": 54731, + "subdir": "linux-64", + "timestamp": 1676828934954, + "version": "2022.9.0" + }, + "xyzservices-2022.9.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "356c95b6ee96d252c84aa7ca549624bb", + "name": "xyzservices", + "sha256": "b1920a204460d1a67a38fdcaecf24aef5480193a5ff61c2fd983796b89bfb68a", + "size": 48137, + "subdir": "linux-64", + "timestamp": 1665472498112, + "version": "2022.9.0" + }, + "xyzservices-2022.9.0-py37h06a4308_1.tar.bz2": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "010dbca9152cd5f90b9b27147b0c564e", + "name": "xyzservices", + "sha256": "7fe9a7f24e06a4623ff91eaea4d4de2403f93d76b06040a13ab8e8b6d4730640", + "size": 47875, + "subdir": "linux-64", + "timestamp": 1675159140331, + "version": "2022.9.0" + }, + "xyzservices-2022.9.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "158ceda22b2bec4410574163882e7b9e", + "name": "xyzservices", + "sha256": "18dd50a0b4f998453479a63df6361b5843c02fedffb5be316e2b51917669f9c1", + "size": 47972, + "subdir": "linux-64", + "timestamp": 1665472522514, + "version": "2022.9.0" + }, + "xyzservices-2022.9.0-py38h06a4308_1.tar.bz2": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d7632b5d03d4b2be70e952e890bcbd5", + "name": "xyzservices", + "sha256": "846ae02929f4570ad0979c56332af5b3b4da851419a051e7902bd3a6ec2a0755", + "size": 47860, + "subdir": "linux-64", + "timestamp": 1675159165834, + "version": "2022.9.0" + }, + "xyzservices-2022.9.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "70a3cb6b9f92266bce1e19e9afaf8070", + "name": "xyzservices", + "sha256": "bfd74f6bfa2782d80f05468cf7bc5f6065baefdb71fb0eecafe5155112bdbae2", + "size": 47883, + "subdir": "linux-64", + "timestamp": 1665472473554, + "version": "2022.9.0" + }, + "xyzservices-2022.9.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dd9bda05830964c550a69b70178ee6f9", + "name": "xyzservices", + "sha256": "8e8d728472d26c1a42345003d69bf381c062db8050d3444a6ccced7e5dcc3524", + "size": 48001, + "subdir": "linux-64", + "timestamp": 1675159114742, + "version": "2022.9.0" + }, + "xz-5.2.10-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "LGPL-2.1-or-later and GPL-2.0-or-later", + "license_family": "GPL2", + "md5": "6aec21d09288d7a5e9fe4e61a00b5ab4", + "name": "xz", + "sha256": "6bd051706f9c107cb458602706e79f2feaa1e40fd741b03e425832843e5a1208", + "size": 480632, + "subdir": "linux-64", + "timestamp": 1673967759586, + "version": "5.2.10" + }, + "xz-5.2.10-h5eee18b_1.tar.bz2": { + "build": "h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "LGPL-2.1-or-later and GPL-2.0-or-later", + "license_family": "GPL2", + "md5": "4adc6af15880436b664fc56be08fb4c5", + "name": "xz", + "sha256": "8773654d99f1718f56d9451b7afe06038cb14e96d1578cd6c2f382e60464217e", + "size": 459331, + "subdir": "linux-64", + "timestamp": 1674070777716, + "version": "5.2.10" + }, + "xz-5.2.3-h2bcbf08_1.tar.bz2": { + "build": "h2bcbf08_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1 and GPL-2.0", + "md5": "83ab851989997fe62dad9eeac1a54bfa", + "name": "xz", + "sha256": "592153affd97114f52dc9d923980e2991cc043ebc60e467532e2d49a453d6555", + "size": 364971, + "subdir": "linux-64", + "timestamp": 1505665902645, + "version": "5.2.3" + }, + "xz-5.2.3-h55aa19d_2.tar.bz2": { + "build": "h55aa19d_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1 and GPL-2.0", + "md5": "991bc96bdebef7109607636e913a29d4", + "name": "xz", + "sha256": "03082b1043347e498a1048282a9b3aec1ed15620bcad1514f7dc04ff89ed3844", + "size": 365792, + "subdir": "linux-64", + "timestamp": 1510092273095, + "version": "5.2.3" + }, + "xz-5.2.3-h5e939de_4.tar.bz2": { + "build": "h5e939de_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1 and GPL-2.0", + "md5": "44dd9983e4d0cae5e2980f336a2c2514", + "name": "xz", + "sha256": "3967e054c77b1fe586bf6c28535c7f5888a50607badb0a97019ca249456937cc", + "size": 373820, + "subdir": "linux-64", + "timestamp": 1524586578890, + "version": "5.2.3" + }, + "xz-5.2.4-h14c3975_4.tar.bz2": { + "build": "h14c3975_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1 and GPL-2.0", + "md5": "496e0e34e1c9710bd307765767318269", + "name": "xz", + "sha256": "cc567f3c241b873980b448d8741d1b7b5efa239384ff69a635e61f7a016798fd", + "size": 374500, + "subdir": "linux-64", + "timestamp": 1526499283093, + "version": "5.2.4" + }, + "xz-5.2.5-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "LGPL-2.1 and GPL-2.0", + "md5": "e17620ef8fc8654e77f53b4f2995b288", + "name": "xz", + "sha256": "85f331e34675d2ecfc096398ec8ba34c58f23f374e882c354e2245d895d96e67", + "size": 448605, + "subdir": "linux-64", + "timestamp": 1587011767250, + "version": "5.2.5" + }, + "xz-5.2.5-h7f8727e_1.tar.bz2": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "LGPL-2.1-or-later and GPL-2.0-or-later", + "license_family": "GPL2", + "md5": "94cb94dc47405b24b1b5bd0a3275ab59", + "name": "xz", + "sha256": "2ce360ff98c0ca4537d70c19266b5700810196c54ce2fbaff3b94a969846ee37", + "size": 398058, + "subdir": "linux-64", + "timestamp": 1651602137803, + "version": "5.2.5" + }, + "xz-5.2.6-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "LGPL-2.1-or-later and GPL-2.0-or-later", + "license_family": "GPL2", + "md5": "82ef85822b3b1deca12197d9db565aee", + "name": "xz", + "sha256": "55974ed382fd96f6f2f908b5a99e12984bc5cf880063d3e5b7743183800e2cb1", + "size": 486831, + "subdir": "linux-64", + "timestamp": 1664287115388, + "version": "5.2.6" + }, + "xz-5.2.8-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "LGPL-2.1-or-later and GPL-2.0-or-later", + "license_family": "GPL2", + "md5": "b9d28643ae483f9869844045bec092cb", + "name": "xz", + "sha256": "e36828d1e5c51e9de210c355596b819d96c87610a4b8ab14243abf428d43efe1", + "size": 459040, + "subdir": "linux-64", + "timestamp": 1669941680582, + "version": "5.2.8" + }, + "yajl-2.1.0-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "ISC", + "md5": "dc0bb40afc106e5883e0d011124dd941", + "name": "yajl", + "sha256": "0bb2d869a58f13bdfb276e29d4665b40cd7e8c692b037e5f85a1037411fab8a4", + "size": 58263, + "subdir": "linux-64", + "timestamp": 1592214357612, + "version": "2.1.0" + }, + "yajl-2.1.0-h7f8727e_1.tar.bz2": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "093a37020e95733ef6b2c8f77f5d3ab4", + "name": "yajl", + "sha256": "202e71d034cfbb73e27f89a80aaca16d6956f6aa8584468102a0fed15418ac0d", + "size": 55799, + "subdir": "linux-64", + "timestamp": 1655211952921, + "version": "2.1.0" + }, + "yaml-0.1.7-h014fa73_1.tar.bz2": { + "build": "h014fa73_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "bebe2c2a2336bda00363fd056f58b1ba", + "name": "yaml", + "sha256": "b7d15288c106701fefe51dfb4d931f3658136906b9c62d632d918fca857dad37", + "size": 86893, + "subdir": "linux-64", + "timestamp": 1510092261586, + "version": "0.1.7" + }, + "yaml-0.1.7-h014fa73_2.tar.bz2": { + "build": "h014fa73_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "e723d423ade454d40d09840b1d61ea95", + "name": "yaml", + "sha256": "a280801f71ca749954a5683dcba311d6e006cf9b7597753cad9433b83da2ab27", + "size": 86890, + "subdir": "linux-64", + "timestamp": 1510100858096, + "version": "0.1.7" + }, + "yaml-0.1.7-h96e3832_1.tar.bz2": { + "build": "h96e3832_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "92f59bc8dfead80b573089868ee71cd2", + "name": "yaml", + "sha256": "7f253072c76601507b2e235de2eb2a3614e3e29e7d19ba018585c857344947b7", + "size": 86260, + "subdir": "linux-64", + "timestamp": 1505957511206, + "version": "0.1.7" + }, + "yaml-0.1.7-had09818_2.tar.bz2": { + "build": "had09818_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "8bc3d68df049640c74941c52156a2e7a", + "name": "yaml", + "sha256": "fdb7ff699dd2ec13677601b4f01c023ca03e0683c917db30556f9cfafde5e0d2", + "size": 87051, + "subdir": "linux-64", + "timestamp": 1510609996778, + "version": "0.1.7" + }, + "yaml-0.2.5-h7b6447c_0.tar.bz2": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "md5": "fcff4f33bb4e3fa91f8d5c3168807abb", + "name": "yaml", + "sha256": "21957e347f97960435b5267baefe1014fe53e4e673b478dfe46b82e371bc0e2b", + "size": 88839, + "subdir": "linux-64", + "timestamp": 1593116114710, + "version": "0.2.5" + }, + "yaml-cpp-0.7.0-h295c915_1.tar.bz2": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6d5d6ea1b1701b745589f1970af96e6", + "name": "yaml-cpp", + "sha256": "38fc3776a29194734a4aba316a1e96edfccaa43c0b7fc508d7d73407c7550b71", + "size": 611266, + "subdir": "linux-64", + "timestamp": 1646734742292, + "version": "0.7.0" + }, + "yaml-cpp-static-0.7.0-h295c915_1.tar.bz2": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "yaml-cpp 0.7.0 h295c915_1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "99072bc4c8744f7cf31af9d5c8912de8", + "name": "yaml-cpp-static", + "sha256": "85bb5ab4a26eff48a766d833196d0faba18507f631726f288cba0bdd31214acb", + "size": 248083, + "subdir": "linux-64", + "timestamp": 1646734760243, + "version": "0.7.0" + }, + "yapf-0.22.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "e9637b58fe7b1502a5bd497759325c5d", + "name": "yapf", + "sha256": "5ba78009da2a185f7c31d97a7c7a3f94974eab944fef7102211bc93ffc8eea1a", + "size": 193661, + "subdir": "linux-64", + "timestamp": 1536861270717, + "version": "0.22.0" + }, + "yapf-0.22.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "5def072f6cd4ce31d8e93e87c5182ff8", + "name": "yapf", + "sha256": "9599f965f504e19aa1c077fffd34e0981868714770871e04f1850dd9acd14c5d", + "size": 200505, + "subdir": "linux-64", + "timestamp": 1536861346725, + "version": "0.22.0" + }, + "yapf-0.22.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "079e7c2f72a15165094845220cf3c95c", + "name": "yapf", + "sha256": "03f210ef4d725e327897c2d8048c08ee8f03fc94473c18dc8a6781c396b2b18e", + "size": 203567, + "subdir": "linux-64", + "timestamp": 1536861392328, + "version": "0.22.0" + }, + "yapf-0.22.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "73792011c8a95c2107e07213d8d5466c", + "name": "yapf", + "sha256": "ae447654489a1ecb87b16de87d52e2c18c11c68a7ae1468af1895c5ed58cacf2", + "size": 203321, + "subdir": "linux-64", + "timestamp": 1536861161534, + "version": "0.22.0" + }, + "yapf-0.24.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "f3317b63ab12c645359b24907b6eeec4", + "name": "yapf", + "sha256": "3762e55b6da48daadbaa212ba068bffbe8b1d61c215a082df82bf2f29c0c0e0c", + "size": 196865, + "subdir": "linux-64", + "timestamp": 1538359864945, + "version": "0.24.0" + }, + "yapf-0.24.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "11f89ef238fe93858407d3acceb36422", + "name": "yapf", + "sha256": "cc478cbd13ab7a409d44677861fa7934eee09d64f4bde145fa74e859cd975668", + "size": 205647, + "subdir": "linux-64", + "timestamp": 1538359871775, + "version": "0.24.0" + }, + "yapf-0.24.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "bc62427bfd62696652f699ad0f4d6e03", + "name": "yapf", + "sha256": "0004c802084f9e7b49b0dfab336b4cd68a0b47f5aafe3f2f7a22691796e9b256", + "size": 205203, + "subdir": "linux-64", + "timestamp": 1538359815231, + "version": "0.24.0" + }, + "yapf-0.25.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "46e5daa8667201864ff3c33d26de86c6", + "name": "yapf", + "sha256": "030fb7b216acd214e300878f1f62adaf40a1a51fec4bdac1794adeb534ac9651", + "size": 229119, + "subdir": "linux-64", + "timestamp": 1543620150067, + "version": "0.25.0" + }, + "yapf-0.25.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "4443f89390039bcb1f88ef30645874d7", + "name": "yapf", + "sha256": "29eb6deaa573654da1c5435a0de0ab26cf6e4ea89b4378922b7db16516024dad", + "size": 228931, + "subdir": "linux-64", + "timestamp": 1543620171741, + "version": "0.25.0" + }, + "yapf-0.25.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "af2c27929c980a2fc325f8f38cf14c96", + "name": "yapf", + "sha256": "28340e9bca5f7f25ab0438b4da57adf268e6e11e58c587131520e48f57d2c394", + "size": 231156, + "subdir": "linux-64", + "timestamp": 1543620129645, + "version": "0.25.0" + }, + "yapf-0.26.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "ff30b7ee8a7b25b601b701edfd588e89", + "name": "yapf", + "sha256": "36bf70c23ce241c928f2f4f8db3458c6f21cfc3a867032c2c0b573ca9285808b", + "size": 239810, + "subdir": "linux-64", + "timestamp": 1550637448386, + "version": "0.26.0" + }, + "yapf-0.26.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "5bd5e0c0530f6fd4112e257bb307ebd4", + "name": "yapf", + "sha256": "b8457602abff9f2ec5e6338c3213c3b947ce7fccfbfdd3b889a91d0b185ecb45", + "size": 244791, + "subdir": "linux-64", + "timestamp": 1550637464876, + "version": "0.26.0" + }, + "yapf-0.26.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "42e783f9876ddbe771ec666312f8fcdb", + "name": "yapf", + "sha256": "21f7d48ec8af6d28264d67c2ac1134b1fd64e03169118c0c3b775d2b85ae656f", + "size": 239954, + "subdir": "linux-64", + "timestamp": 1550637435383, + "version": "0.26.0" + }, + "yarl-0.13.0-py35hcc48116_0.tar.bz2": { + "build": "py35hcc48116_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "multidict >=2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cd8bb5864981e465041c3d91b4bfe20f", + "name": "yarl", + "sha256": "a47d2bf841762bcb2231b339df9cc67de2e2dbca97e55c7732f4f47d0baa435b", + "size": 101447, + "subdir": "linux-64", + "timestamp": 1507976467538, + "version": "0.13.0" + }, + "yarl-0.13.0-py36h21e4b6b_0.tar.bz2": { + "build": "py36h21e4b6b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "multidict >=2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f58a6d073c2e055862d673b8af5a28ad", + "name": "yarl", + "sha256": "e0ac92f0b6c6532be70aead02d0cac88203662c21cb192eb7208733760aef842", + "size": 101653, + "subdir": "linux-64", + "timestamp": 1507976468446, + "version": "0.13.0" + }, + "yarl-0.14.2-py35h31c3c03_0.tar.bz2": { + "build": "py35h31c3c03_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "multidict >=2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "846c4349358358010c9bd33cba243589", + "name": "yarl", + "sha256": "b19679101ec4240d4b788d3a9dcd0c749ce62ecc661e6c5dfc1b7de21ccfd3d0", + "size": 99811, + "subdir": "linux-64", + "timestamp": 1511315082093, + "version": "0.14.2" + }, + "yarl-0.14.2-py36hcd1f455_0.tar.bz2": { + "build": "py36hcd1f455_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "multidict >=2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "84d3c1174d673a0b836f09b2c95893b2", + "name": "yarl", + "sha256": "a1e75886672e099b3714fddb73e2315606e45c1698f05fef0ce4043be564abf9", + "size": 99704, + "subdir": "linux-64", + "timestamp": 1511315082175, + "version": "0.14.2" + }, + "yarl-1.1.1-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dbea73e0c93be3262ffb01d3baa73d5a", + "name": "yarl", + "sha256": "b933a9d7accfefe6075874f52e0121f673c722e17c324c26fd40306c5c996e76", + "size": 130048, + "subdir": "linux-64", + "timestamp": 1519072003590, + "version": "1.1.1" + }, + "yarl-1.1.1-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7d032647450ea6df6690cc6834067c68", + "name": "yarl", + "sha256": "f3100e153531aa3d0fa9c49e71426157c42e2678fbf92d6bf60dd1e4db523815", + "size": 130864, + "subdir": "linux-64", + "timestamp": 1519072008174, + "version": "1.1.1" + }, + "yarl-1.2.4-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e4be5dc4ea5b03f9bcfbcd3a00f49b1f", + "name": "yarl", + "sha256": "f0a8497798e80f02fb1fa0ccfbbdd40ae550086476fff60ce9912bdca71b9866", + "size": 133909, + "subdir": "linux-64", + "timestamp": 1526411511866, + "version": "1.2.4" + }, + "yarl-1.2.4-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1044213af8699b1f3244f258f18fda54", + "name": "yarl", + "sha256": "6d2c7eadafda2c7f6ffd3ad0462b76088f708acf1a6e70c727fe1c28d0e7e530", + "size": 134770, + "subdir": "linux-64", + "timestamp": 1526411402889, + "version": "1.2.4" + }, + "yarl-1.2.5-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4a39fcd1b9d7cb4b736fc8186a419db0", + "name": "yarl", + "sha256": "16c5e5c4a5fd821164f8809a78269a16647913ae16b20180f6ecaf50994ef630", + "size": 133851, + "subdir": "linux-64", + "timestamp": 1528984907876, + "version": "1.2.5" + }, + "yarl-1.2.5-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3f3e0f81c20950cbd7dda4c77123a505", + "name": "yarl", + "sha256": "c79ac4359949b7a90a1fbd1d318aa65e701321d7f6eba4106727ef96289b6412", + "size": 134672, + "subdir": "linux-64", + "timestamp": 1528985152578, + "version": "1.2.5" + }, + "yarl-1.2.6-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "58c5e09f08517964d71082ccb907022c", + "name": "yarl", + "sha256": "5123d4a49cc06549fd2c8a724436ec4177d109dd36ed5109b6be2256894ba4f0", + "size": 133808, + "subdir": "linux-64", + "timestamp": 1529418946794, + "version": "1.2.6" + }, + "yarl-1.2.6-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "89bbff93a09c92aa59b4cc68c738d868", + "name": "yarl", + "sha256": "e49213c0cbe8fba89809d703177eb3dce54eb0e4645c0a9394a6986fef542fb5", + "size": 135121, + "subdir": "linux-64", + "timestamp": 1529418877397, + "version": "1.2.6" + }, + "yarl-1.2.6-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6294c3609a944545d1549be5000dd865", + "name": "yarl", + "sha256": "dfc2cf0c727dfe8cee93d352d0358d21f807359c10a8113a0fca3d84e902f235", + "size": 134321, + "subdir": "linux-64", + "timestamp": 1530736532473, + "version": "1.2.6" + }, + "yarl-1.3.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6c6f06d6353e091a2dbdcebffc9e4d36", + "name": "yarl", + "sha256": "24d26bff7c9a702ceea67bea0c5985ab079ad529c685e74e0c48cd3c2f443b82", + "size": 136308, + "subdir": "linux-64", + "timestamp": 1545110350214, + "version": "1.3.0" + }, + "yarl-1.3.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e6e0811f4f8d4fb108def8f63d7a70d5", + "name": "yarl", + "sha256": "0882f20029d8431af0702e35ac804ec86e92399f51825def243b3c2c8414b2ec", + "size": 136186, + "subdir": "linux-64", + "timestamp": 1545110320525, + "version": "1.3.0" + }, + "yarl-1.3.0-py38h7b6447c_1000.tar.bz2": { + "build": "py38h7b6447c_1000", + "build_number": 1000, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9154845bacdd0a304e3880d7042e54ef", + "name": "yarl", + "sha256": "fd0e277946f4709b00385909590c2ab7276017abc1b4cb327e84b8a2f56a15bd", + "size": 148445, + "subdir": "linux-64", + "timestamp": 1574437457721, + "version": "1.3.0" + }, + "yarl-1.4.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dbc2467c096bb089c268f1aa5bdc978d", + "name": "yarl", + "sha256": "059d549f9adae7fb5c53002d0d9824bdf225e48a04ff76434f40facd70baef61", + "size": 141493, + "subdir": "linux-64", + "timestamp": 1576688264517, + "version": "1.4.2" + }, + "yarl-1.4.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "162755bee247f20489d5d591436eb6e5", + "name": "yarl", + "sha256": "c67806ae74405b0f03f34af67c8479047ad907c563f31dfa98aaea6b432135ff", + "size": 141184, + "subdir": "linux-64", + "timestamp": 1576688236914, + "version": "1.4.2" + }, + "yarl-1.4.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ac68197817779bd43630fb5f0ceedd90", + "name": "yarl", + "sha256": "956fa1eb2243907f5c572d0d32cd74564051e51661faf0056dd99342d47ddfdc", + "size": 152895, + "subdir": "linux-64", + "timestamp": 1576688261450, + "version": "1.4.2" + }, + "yarl-1.5.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e79516051c64148fbeaafe873f64bace", + "name": "yarl", + "sha256": "c125e407ab3224f231bdcb336193b464bb59d78ba091ce4f8ef746c13fa72af6", + "size": 143958, + "subdir": "linux-64", + "timestamp": 1598045064883, + "version": "1.5.1" + }, + "yarl-1.5.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "083deaa3b7b89f6dccb1959e45e39ec0", + "name": "yarl", + "sha256": "af00c12aebdfe588e26c39890de8ff8745c9efafa4c4db89590697f9270063aa", + "size": 144057, + "subdir": "linux-64", + "timestamp": 1598045089035, + "version": "1.5.1" + }, + "yarl-1.5.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c1507fcc0c723bbd68fbdb9caab3856d", + "name": "yarl", + "sha256": "9d6e6725b67beb7e9d07f3d40eb8f1019e68a6a81b4b522871353671832588be", + "size": 147399, + "subdir": "linux-64", + "timestamp": 1598045064847, + "version": "1.5.1" + }, + "yarl-1.6.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2567358a544e88dcaa2f66c18b5e2f1d", + "name": "yarl", + "sha256": "f3321b156eef7ae100aa975a507e26393e3cc20aac1f723d7e6da988eab1ac9b", + "size": 142785, + "subdir": "linux-64", + "timestamp": 1602006880959, + "version": "1.6.0" + }, + "yarl-1.6.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "37681055c42e000f58a3d50ea6806649", + "name": "yarl", + "sha256": "49edfdeee28cbac7eafdccc58875e67d7f71cda4d78316d9ea53f9cd18b28edd", + "size": 142731, + "subdir": "linux-64", + "timestamp": 1602006876060, + "version": "1.6.0" + }, + "yarl-1.6.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c34bee432ef8f6a7e439d85a07dd0c56", + "name": "yarl", + "sha256": "8aba6f29eba8057783788d971d94cdd15ea2928e48cc6585a0661306f1fb2d3d", + "size": 146123, + "subdir": "linux-64", + "timestamp": 1602006870803, + "version": "1.6.0" + }, + "yarl-1.6.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a2b21c8a60f2999ff05b73ee58376e0e", + "name": "yarl", + "sha256": "a8295c6615c915b08b67ed0168314189d7823e592678c9bbdd1c1270d30d5cb0", + "size": 142448, + "subdir": "linux-64", + "timestamp": 1602693086124, + "version": "1.6.2" + }, + "yarl-1.6.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a0083b622f90a88fd1cd662f252e5cb6", + "name": "yarl", + "sha256": "830de010ff23a0fe6fd310216878d1141902679c7fde9f1e59f618dfeea46af5", + "size": 142338, + "subdir": "linux-64", + "timestamp": 1602693088465, + "version": "1.6.2" + }, + "yarl-1.6.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6044f7a4924efb0dbc521901b1de5570", + "name": "yarl", + "sha256": "0653aa9bc0d7a39f2dbad13735533c78c90da4bbf94536d50327672111169fbb", + "size": 145662, + "subdir": "linux-64", + "timestamp": 1602693046471, + "version": "1.6.2" + }, + "yarl-1.6.3-py310h7f8727e_1.tar.bz2": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.5.0", + "multidict >=4.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ffa1bbacc405a23edd749257779051db", + "name": "yarl", + "sha256": "6f510580ab9d025450b8f081bdff9e5e2f35196be38007ff80190f2d4e73f00c", + "size": 280922, + "subdir": "linux-64", + "timestamp": 1640811427258, + "version": "1.6.3" + }, + "yarl-1.6.3-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f4f54e99ad947780f8c8583c01da8201", + "name": "yarl", + "sha256": "4c6b559fb3dc645109b11fb17e79d31862a3b853e147c895bdce889b8f3f5d34", + "size": 142434, + "subdir": "linux-64", + "timestamp": 1606939955082, + "version": "1.6.3" + }, + "yarl-1.6.3-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8d714d8f88d82df0780b32fe16ca928c", + "name": "yarl", + "sha256": "d4c52bad22788939cce5ddbb5ba734a17213494d7dd178babc59d8479e564b49", + "size": 142231, + "subdir": "linux-64", + "timestamp": 1606939999443, + "version": "1.6.3" + }, + "yarl-1.6.3-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a7f5c716ae7037be6588c206f3bca0c7", + "name": "yarl", + "sha256": "7f7863607dcf7b7354c46b18bcd4b42ebe5482da5070948fbbf7dfe9f0d25151", + "size": 145456, + "subdir": "linux-64", + "timestamp": 1606939964659, + "version": "1.6.3" + }, + "yarl-1.6.3-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e5b45fbf58970697e8627620cd514e26", + "name": "yarl", + "sha256": "e212d7f972ae5016fdbd3a95c357bae0b5205c97c431e2f4f287ce3f410d305b", + "size": 145400, + "subdir": "linux-64", + "timestamp": 1606939987117, + "version": "1.6.3" + }, + "yarl-1.8.1-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=11.2.0", + "multidict >=4.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d54cae01435acd8e62b0f263e882913a", + "name": "yarl", + "sha256": "20e4ff393854e0649b68991f3182315888362c980c7724902bd81970dfa564e3", + "size": 246697, + "subdir": "linux-64", + "timestamp": 1661437155383, + "version": "1.8.1" + }, + "yarl-1.8.1-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=11.2.0", + "multidict >=4.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7f41ab5e5d6537ad22829359058e137d", + "name": "yarl", + "sha256": "f81f67d27f008b4507ace240341f4d93050900752e8010a189a0009c48496a16", + "size": 100433, + "subdir": "linux-64", + "timestamp": 1676827620821, + "version": "1.8.1" + }, + "yarl-1.8.1-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=11.2.0", + "multidict >=4.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4aa7e4778461d9b860864de639569603", + "name": "yarl", + "sha256": "2d309ae2ec96db4ae207e5ffb93d7a9311ce187545de8320ce5164fecc3b58c3", + "size": 90651, + "subdir": "linux-64", + "timestamp": 1661437223046, + "version": "1.8.1" + }, + "yarl-1.8.1-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=11.2.0", + "multidict >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f0aebfb40b5418f0bccca8b7cb110469", + "name": "yarl", + "sha256": "6dda7aea0b95dfe3a90c553dc575f285881f1482c61664c2a2adc5e96cf56a30", + "size": 92047, + "subdir": "linux-64", + "timestamp": 1661437189051, + "version": "1.8.1" + }, + "yarl-1.8.1-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=11.2.0", + "multidict >=4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "54143c55d6c764019c93572ceb3bb8a3", + "name": "yarl", + "sha256": "c68989ec72b4e3fb3c5ce98c9dce1040aa2c0a14dadbe795e520fe5619e074ec", + "size": 91419, + "subdir": "linux-64", + "timestamp": 1661437260076, + "version": "1.8.1" + }, + "yarn-1.22.19-h06a4308_0.tar.bz2": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "nodejs" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f081562deb6813d27cfef2a94095f9ca", + "name": "yarn", + "sha256": "18446ffcc497192559a601e535bb5faf911c3312d43eef9f869ef1f6abd41aa3", + "size": 1044420, + "subdir": "linux-64", + "timestamp": 1659703793841, + "version": "1.22.19" + }, + "yasm-1.3.0-h99c0ef8_2.tar.bz2": { + "build": "h99c0ef8_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "md5": "0faefa4c75f86c85fb9b14b089902e5d", + "name": "yasm", + "sha256": "a0bd5606d634a392a3f79ae5ae1b79c6375cf5f6381c361fa69bbb423c63ba57", + "size": 1499920, + "subdir": "linux-64", + "timestamp": 1510100508620, + "version": "1.3.0" + }, + "ydata-profiling-4.1.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-core >=4.6.3", + "ipywidgets >=7.5.1", + "jupyter-client >=5.3.4", + "tangled-up-in-unicode 0.2.0" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash 4.3.1", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.7", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "typeguard >=2.13.2,<2.14", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c91d58a7cc7ad3dd0b0734f339de4f9d", + "name": "ydata-profiling", + "sha256": "3f788b35a972da643b9ff2322ebaf03c83689cfccef7ab4a9387b02470bb9027", + "size": 315104, + "subdir": "linux-64", + "timestamp": 1680556017461, + "version": "4.1.1" + }, + "ydata-profiling-4.1.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-core >=4.6.3", + "ipywidgets >=7.5.1", + "jupyter-client >=5.3.4", + "tangled-up-in-unicode 0.2.0" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash 4.3.1", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.7", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "typeguard >=2.13.2,<2.14", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a359b0d930079a18f9f2900356a6bbda", + "name": "ydata-profiling", + "sha256": "8b91708fc0eac7442fea0e4c6238e27e259625db4e2ba385d94c86d9d54303ca", + "size": 384958, + "subdir": "linux-64", + "timestamp": 1680555911736, + "version": "4.1.1" + }, + "ydata-profiling-4.1.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-core >=4.6.3", + "ipywidgets >=7.5.1", + "jupyter-client >=5.3.4", + "tangled-up-in-unicode 0.2.0" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash 4.3.1", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.7", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "typeguard >=2.13.2,<2.14", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d92f2bb17a3b91a86de61ef877b1dd98", + "name": "ydata-profiling", + "sha256": "3bfc2ad368ce45310c09a95b08c5a8b627c2c03336062a2d2ca7af2afc3257f1", + "size": 311807, + "subdir": "linux-64", + "timestamp": 1680555853078, + "version": "4.1.1" + }, + "ydata-profiling-4.1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-core >=4.6.3", + "ipywidgets >=7.5.1", + "jupyter-client >=5.3.4", + "tangled-up-in-unicode 0.2.0" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash 4.3.1", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.7", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "typeguard >=2.13.2,<2.14", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7554fad39559b5967adf75d036a6a0bb", + "name": "ydata-profiling", + "sha256": "8f38422213f271d269ded0690dc8f75c788f579037f78970b8d8810b94505891", + "size": 310414, + "subdir": "linux-64", + "timestamp": 1680555963573, + "version": "4.1.1" + }, + "yt-3.4.1-py27h14c3975_1.tar.bz2": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "sympy" + ], + "license": "BSD 3-clause", + "md5": "02d2f2acfab14b447a1916877aabd7ef", + "name": "yt", + "sha256": "600ea72bb1f39bb1784e2bd40780b8435cf319dbd11ef510c33cc9064bcdaeea", + "size": 10169778, + "subdir": "linux-64", + "timestamp": 1531066651889, + "version": "3.4.1" + }, + "yt-3.4.1-py27h3010b51_0.tar.bz2": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "sympy" + ], + "license": "BSD 3-clause", + "md5": "7803e0eeb92ef78f15d437ae6f56caa3", + "name": "yt", + "sha256": "1e81733f450a8cc73948267e1804a5378a449b54737df8f2829a8a2dc9187573", + "size": 10120140, + "subdir": "linux-64", + "timestamp": 1520476503443, + "version": "3.4.1" + }, + "yt-3.4.1-py35h3010b51_0.tar.bz2": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools", + "sympy" + ], + "license": "BSD 3-clause", + "md5": "7d73bcbc6d0d3e23016069c5a008f999", + "name": "yt", + "sha256": "0729f3e888b0ea2e327e51838857f19bdcb6143bc4b8e2ecd9416b1f9b9037ef", + "size": 9960862, + "subdir": "linux-64", + "timestamp": 1520476524164, + "version": "3.4.1" + }, + "yt-3.4.1-py36h14c3975_1.tar.bz2": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "sympy" + ], + "license": "BSD 3-clause", + "md5": "20a641023430b80e5be93fc08957ed5f", + "name": "yt", + "sha256": "6ff41d1eae0cf3256db7236b4bed2cada4a8c7b94c769cae18a7704025974255", + "size": 9999465, + "subdir": "linux-64", + "timestamp": 1531065770272, + "version": "3.4.1" + }, + "yt-3.4.1-py36h3010b51_0.tar.bz2": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "sympy" + ], + "license": "BSD 3-clause", + "md5": "0edf319e8b50c26d0982213d730cb8df", + "name": "yt", + "sha256": "4e3efb3534493350da887f98dcc71f83e931457875fb8294a401d9696947a43d", + "size": 9973255, + "subdir": "linux-64", + "timestamp": 1520476514311, + "version": "3.4.1" + }, + "yt-3.4.1-py36h33eb3a4_2.tar.bz2": { + "build": "py36h33eb3a4_2", + "build_number": 2, + "depends": [ + "h5py", + "hdf5 >=1.10.4,<1.10.5.0a0", + "ipython", + "libgcc-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "sympy" + ], + "license": "BSD 3-clause", + "md5": "ce444fffd415fa8ff3720b6056e38b97", + "name": "yt", + "sha256": "6010a6ec756b15412926305edfc37a0f0711b4c874bfa63ab90c1e5d68d504b8", + "size": 9268645, + "subdir": "linux-64", + "timestamp": 1592482292447, + "version": "3.4.1" + }, + "yt-3.4.1-py37h14c3975_1.tar.bz2": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "sympy" + ], + "license": "BSD 3-clause", + "md5": "64b3e715267ddc941581a5cdfafc9a13", + "name": "yt", + "sha256": "680a900a3c61007418e76be10a68672cd191243139221926582045dc482cc723", + "size": 9970661, + "subdir": "linux-64", + "timestamp": 1531066206059, + "version": "3.4.1" + }, + "yt-3.4.1-py37h33eb3a4_2.tar.bz2": { + "build": "py37h33eb3a4_2", + "build_number": 2, + "depends": [ + "h5py", + "hdf5 >=1.10.4,<1.10.5.0a0", + "ipython", + "libgcc-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "sympy" + ], + "license": "BSD 3-clause", + "md5": "c0bc82f937cb2e2952dfe4998fc36cc2", + "name": "yt", + "sha256": "d9255a35cef006b4833ece1d68c73dcb34fe54f7f4069423379d973b8b26a5ab", + "size": 9202767, + "subdir": "linux-64", + "timestamp": 1592482260742, + "version": "3.4.1" + }, + "yt-3.4.1-py38h33eb3a4_2.tar.bz2": { + "build": "py38h33eb3a4_2", + "build_number": 2, + "depends": [ + "h5py", + "hdf5 >=1.10.4,<1.10.5.0a0", + "ipython", + "libgcc-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "sympy" + ], + "license": "BSD 3-clause", + "md5": "568985a2b67b5f4497186f44df71e2ed", + "name": "yt", + "sha256": "55be213ac6c549893399de6a4aa9a902b50ab6d73b66f3b23826176acb170984", + "size": 9364906, + "subdir": "linux-64", + "timestamp": 1592482233464, + "version": "3.4.1" + }, + "yt-3.6.1-py310h9102076_0.tar.bz2": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.5.0", + "matplotlib", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "sympy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cbb7c3872ad450e23127848f8a2346c2", + "name": "yt", + "sha256": "ab11e2c99354671ff9188fc672611bfc2f60245bc95a6a124bc0e4abe63515a8", + "size": 20295177, + "subdir": "linux-64", + "timestamp": 1640814702512, + "version": "3.6.1" + }, + "yt-3.6.1-py36h6323ea4_0.tar.bz2": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.3.0", + "matplotlib", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "sympy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5a472034de46cd4d33e7c62c57e4f358", + "name": "yt", + "sha256": "28df0d61612cca29402256012e2087400f382104fb3f5cbc785a37ab1fc7f35d", + "size": 9563423, + "subdir": "linux-64", + "timestamp": 1613477228670, + "version": "3.6.1" + }, + "yt-3.6.1-py37h6323ea4_0.tar.bz2": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.3.0", + "matplotlib", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "sympy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "285e297ffc2009e55b6e848b54f390e4", + "name": "yt", + "sha256": "47a9d7146546aec4aaee2581d68278f51fe3b78dbe77ea47198a8cb876c9e33c", + "size": 9543720, + "subdir": "linux-64", + "timestamp": 1613477841936, + "version": "3.6.1" + }, + "yt-3.6.1-py38h6323ea4_0.tar.bz2": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.3.0", + "matplotlib", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "sympy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7d8dc71a2a9a141a82ca8f917b50efbf", + "name": "yt", + "sha256": "5d47c20efdc5fd1a893b3746029de927e0e4e5cabce22629c4e2d4a68b03421f", + "size": 9701189, + "subdir": "linux-64", + "timestamp": 1613477828571, + "version": "3.6.1" + }, + "yt-3.6.1-py39h6323ea4_0.tar.bz2": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.3.0", + "matplotlib", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "sympy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "503ed9ef9605ddd90c7b94633d2546cb", + "name": "yt", + "sha256": "203c50319d14113254c3559d84a06cee70c7e8f485b317ed6b94202854b6b3f0", + "size": 9697450, + "subdir": "linux-64", + "timestamp": 1613477277470, + "version": "3.6.1" + }, + "zarr-2.13.3-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "asciitree", + "fasteners", + "numcodecs >=0.10.0", + "numpy >=1.7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e91564f604f2ae189eefc46505dd1127", + "name": "zarr", + "sha256": "93c184172b3f1f6b231b20a4c64e76e0dc0845731bd66c6b6844329863f718e1", + "size": 342714, + "subdir": "linux-64", + "timestamp": 1669363788544, + "version": "2.13.3" + }, + "zarr-2.13.3-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "asciitree", + "fasteners", + "numcodecs >=0.10.0", + "numpy >=1.7", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c0d8230a60656e09c70a2db2110c4c7", + "name": "zarr", + "sha256": "1040166f44b965a2a6bb05d8cd0c4c66f864dfcf4ebcf47670146b8090ee40d4", + "size": 489235, + "subdir": "linux-64", + "timestamp": 1676846647140, + "version": "2.13.3" + }, + "zarr-2.13.3-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "asciitree", + "fasteners", + "numcodecs >=0.10.0", + "numpy >=1.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98e8afe360c9b590f74bd5c940d46d05", + "name": "zarr", + "sha256": "00cce06f81f34e658fa42691f4fad659a40e8f25e9aed9b5745506cf99db243b", + "size": 340379, + "subdir": "linux-64", + "timestamp": 1669363675171, + "version": "2.13.3" + }, + "zarr-2.13.3-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "asciitree", + "fasteners", + "numcodecs >=0.10.0", + "numpy >=1.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "024916d52442084e56d0e47a7ac3502a", + "name": "zarr", + "sha256": "8a2f27a8d04f3e083650105f5c15b2350f3924a60e9f7ecba55dfb865f4a6ac3", + "size": 340361, + "subdir": "linux-64", + "timestamp": 1669363566548, + "version": "2.13.3" + }, + "zc.lockfile-1.3.0-py27h28b3542_0.tar.bz2": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "29302ae307c1ceb7b6dd883a93e98d04", + "name": "zc.lockfile", + "sha256": "4dffbefc8b99e54bd665e6f7203fab75de5edba5ede7e891c3221740e02acd6a", + "size": 13373, + "subdir": "linux-64", + "timestamp": 1535301040544, + "version": "1.3.0" + }, + "zc.lockfile-1.3.0-py35h28b3542_0.tar.bz2": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "30990646b829650123c530ab857360f2", + "name": "zc.lockfile", + "sha256": "4dd18b92876cfdaba64e6cf1640168bd4899b3bb4fbb87a89db0361a774d9502", + "size": 13558, + "subdir": "linux-64", + "timestamp": 1535301065091, + "version": "1.3.0" + }, + "zc.lockfile-1.3.0-py36h28b3542_0.tar.bz2": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "e0d2a5df675510f7be8025fb4c3c6d80", + "name": "zc.lockfile", + "sha256": "03e2e2d99a54e410546fd4fd0c56027711135f31b819adc383fa3faa4e6e0af2", + "size": 13521, + "subdir": "linux-64", + "timestamp": 1535301035794, + "version": "1.3.0" + }, + "zc.lockfile-1.3.0-py37h28b3542_0.tar.bz2": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "b372ba0f81ceedc928d9bba92faa5d55", + "name": "zc.lockfile", + "sha256": "ceaf882fc685aa626794b2c60e73aea012716dfeab9345bb26be98641ebc022b", + "size": 13550, + "subdir": "linux-64", + "timestamp": 1535301054413, + "version": "1.3.0" + }, + "zeep-4.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "cached-property >=1.3.0", + "isodate >=0.5.4", + "lxml >=4.6.0", + "platformdirs >=1.4.0", + "python >=3.10,<3.11.0a0", + "pytz", + "requests >=2.7.0", + "requests-file >=1.5.1", + "requests-toolbelt >=0.7.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5a5c3ab0b21f114bb4df99bd0b94147e", + "name": "zeep", + "sha256": "6ac1a59c7c78e49264b5aa4df1a5a937ed1a2bb46ce3893051b5a40760f391cc", + "size": 149615, + "subdir": "linux-64", + "timestamp": 1665167985990, + "version": "4.1.0" + }, + "zeep-4.1.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "cached-property >=1.3.0", + "isodate >=0.5.4", + "lxml >=4.6.0", + "platformdirs >=1.4.0", + "python >=3.11,<3.12.0a0", + "pytz", + "requests >=2.7.0", + "requests-file >=1.5.1", + "requests-toolbelt >=0.7.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "780c37d0a81470377d4995e15cf3e6e0", + "name": "zeep", + "sha256": "53a27b4900072ca9fd6748b9d9a95382ecd1a49b9514659e0c35676d6646f79f", + "size": 198065, + "subdir": "linux-64", + "timestamp": 1676863767302, + "version": "4.1.0" + }, + "zeep-4.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "cached-property >=1.3.0", + "isodate >=0.5.4", + "lxml >=4.6.0", + "platformdirs >=1.4.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests >=2.7.0", + "requests-file >=1.5.1", + "requests-toolbelt >=0.7.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ca83f95c6c4337f96d2e0bc611e9c14", + "name": "zeep", + "sha256": "ad66fea0fa2820b1e479179f5b3198735e291497e8b221ab7ff7c8a0b835a29b", + "size": 147883, + "subdir": "linux-64", + "timestamp": 1665167915796, + "version": "4.1.0" + }, + "zeep-4.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "cached-property >=1.3.0", + "isodate >=0.5.4", + "lxml >=4.6.0", + "platformdirs >=1.4.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests >=2.7.0", + "requests-file >=1.5.1", + "requests-toolbelt >=0.7.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13603ca6ab61d55083eb2ba50df08c44", + "name": "zeep", + "sha256": "f8d19be3281820c6a70f57b3c0313ba712cba9612f8d1904f46eeafb1835e00b", + "size": 148376, + "subdir": "linux-64", + "timestamp": 1665167885503, + "version": "4.1.0" + }, + "zeep-4.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "cached-property >=1.3.0", + "isodate >=0.5.4", + "lxml >=4.6.0", + "platformdirs >=1.4.0", + "python >=3.9,<3.10.0a0", + "pytz", + "requests >=2.7.0", + "requests-file >=1.5.1", + "requests-toolbelt >=0.7.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "804aa1e5687314b8b3b97a3f3ec845c6", + "name": "zeep", + "sha256": "54c8a08b53396e74f3aac19fcbefe76ef52894b79ee72f0521857f16e0981376", + "size": 148208, + "subdir": "linux-64", + "timestamp": 1665167944236, + "version": "4.1.0" + }, + "zeromq-4.2.2-hb0b69da_1.tar.bz2": { + "build": "hb0b69da_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "b557230be953bdc899bc76a53f7c9967", + "name": "zeromq", + "sha256": "3cc90a1766ebf3142c886478720bd405c72c561636a85ac1c16a4a590b2f4513", + "size": 677864, + "subdir": "linux-64", + "timestamp": 1505688169910, + "version": "4.2.2" + }, + "zeromq-4.2.2-hbedb6e5_2.tar.bz2": { + "build": "hbedb6e5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "22232e8b7b4d871b7db7b8160f26c31c", + "name": "zeromq", + "sha256": "1f9f76ea185708433983ff5050926336c32793da8dba7de449542d2bcc1d9977", + "size": 678347, + "subdir": "linux-64", + "timestamp": 1510168774315, + "version": "4.2.2" + }, + "zeromq-4.2.3-h439df22_3.tar.bz2": { + "build": "h439df22_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "7d2515119575c929f28616e2af9efcd9", + "name": "zeromq", + "sha256": "d5ae3a86c67e92ae182974cf1e5802ec9d245aa3d9714cc72683b17ca80c70ff", + "size": 593967, + "subdir": "linux-64", + "timestamp": 1520462522912, + "version": "4.2.3" + }, + "zeromq-4.2.3-hf484d3e_2.tar.bz2": { + "build": "hf484d3e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "142bfb28955c71ec0bbdca0746c5b44c", + "name": "zeromq", + "sha256": "a353e96e7d7d252afb7b51251832bdc6ec75941050d155d1a0b227d62bf12eeb", + "size": 613122, + "subdir": "linux-64", + "timestamp": 1520450126586, + "version": "4.2.3" + }, + "zeromq-4.2.5-h439df22_0.tar.bz2": { + "build": "h439df22_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "4ecc6f617b8d5946816203070a8d7f1e", + "name": "zeromq", + "sha256": "524e18db2147ce32564e2bb6aa5d989fa77c31e9e41a40224157126a88d26c7b", + "size": 580955, + "subdir": "linux-64", + "timestamp": 1523637518476, + "version": "4.2.5" + }, + "zeromq-4.2.5-hf484d3e_0.tar.bz2": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "9515cc6826800f6169f8e64b3b9f51a9", + "name": "zeromq", + "sha256": "beb5163ecaa24a0754a89a9a7919a9bd464362d52d645e98a39d738ff64c7de8", + "size": 580547, + "subdir": "linux-64", + "timestamp": 1531081630493, + "version": "4.2.5" + }, + "zeromq-4.2.5-hf484d3e_1.tar.bz2": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "9195623f72f50d5f5c4eb299dc0ccc28", + "name": "zeromq", + "sha256": "922fe4d24ea5e30b290eff15efd1c51553ff9211b7392a7ea12a526b3a9f5cfa", + "size": 580440, + "subdir": "linux-64", + "timestamp": 1534345401396, + "version": "4.2.5" + }, + "zeromq-4.3.1-he6710b0_2.tar.bz2": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL 3", + "md5": "d2a5bb7b82ffd701ab50a37e232d3ff3", + "name": "zeromq", + "sha256": "f7187d54ae66272e1c440e15d8407f4b31063b04bc1541123e5d4589bc151674", + "size": 692202, + "subdir": "linux-64", + "timestamp": 1548969987835, + "version": "4.3.1" + }, + "zeromq-4.3.1-he6710b0_3.tar.bz2": { + "build": "he6710b0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL 3", + "md5": "e59aaaa10e70ee13cdf89275fa6c09e0", + "name": "zeromq", + "sha256": "bbff634a139272851e7e11137af7e1176645e500a5b1474b882d409a5a76e6af", + "size": 681607, + "subdir": "linux-64", + "timestamp": 1549023379958, + "version": "4.3.1" + }, + "zeromq-4.3.2-he6710b0_2.tar.bz2": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL 3", + "md5": "13ac2746fae688ddecec702ba8bc114f", + "name": "zeromq", + "sha256": "35bedee0af37b2936867d24e1c03aa609b2a926b974a7e6133affdd83ba85dba", + "size": 697306, + "subdir": "linux-64", + "timestamp": 1593027140375, + "version": "4.3.2" + }, + "zeromq-4.3.2-he6710b0_3.tar.bz2": { + "build": "he6710b0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL 3", + "md5": "c9dd5127462ed552f690d270110f39b0", + "name": "zeromq", + "sha256": "bea3dad48428aff9526df3bf557d114f31037473a91ad24e0976e28298a3f817", + "size": 691079, + "subdir": "linux-64", + "timestamp": 1599759670606, + "version": "4.3.2" + }, + "zeromq-4.3.3-he6710b0_3.tar.bz2": { + "build": "he6710b0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL 3", + "md5": "32b0e004e4b330cc55430f2b6e0291bf", + "name": "zeromq", + "sha256": "dbd18ec7ac037ec6230e8f41d961deda2dcc5165058c13b8aee33ec41dc0aca4", + "size": 694328, + "subdir": "linux-64", + "timestamp": 1602701579750, + "version": "4.3.3" + }, + "zeromq-4.3.4-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL-3.0-or-later", + "md5": "567b68192c387b5fc88178425577a0fe", + "name": "zeromq", + "sha256": "95c82f0f889e8cbd0abe00cdc1ef22591293f741055179dcb973cf0830e63ee3", + "size": 366479, + "subdir": "linux-64", + "timestamp": 1616055552392, + "version": "4.3.4" + }, + "zeromq-static-4.3.4-h2531618_0.tar.bz2": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "libstdcxx-ng >=7.3.0", + "zeromq 4.3.4 h2531618_0" + ], + "license": "LGPL-3.0-or-later", + "md5": "3b69fdf4a89a967470f7af15205abc1e", + "name": "zeromq-static", + "sha256": "074b1dc02b1fba52b9a89e11de00fb59a5da9bf24824acc39f54c0adfd3a6b84", + "size": 413211, + "subdir": "linux-64", + "timestamp": 1616055563935, + "version": "4.3.4" + }, + "zfp-0.5.5-h2531618_4.tar.bz2": { + "build": "h2531618_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9321f89164acbaf3d267fbf78daaa946", + "name": "zfp", + "sha256": "a46c5640a432798293c58c5384be22fe05c62a243080c95136948fa78d6dcd18", + "size": 202079, + "subdir": "linux-64", + "timestamp": 1611240514082, + "version": "0.5.5" + }, + "zfp-0.5.5-h2531618_6.tar.bz2": { + "build": "h2531618_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d4b6220e5901f12f68d6ec946f8baa60", + "name": "zfp", + "sha256": "8abde3518c029924ad11278cb3ff83b7060f3dd854439601c06b40978ed2e009", + "size": 202418, + "subdir": "linux-64", + "timestamp": 1617995968460, + "version": "0.5.5" + }, + "zfp-0.5.5-h295c915_6.tar.bz2": { + "build": "h295c915_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b5a6506fa232bf64a94e8fc212e1ebc6", + "name": "zfp", + "sha256": "e52d5af1dfb0707f5428cadc921d6db7e01842c1e501ccc5f32720e6e72ced1a", + "size": 196080, + "subdir": "linux-64", + "timestamp": 1642508403235, + "version": "0.5.5" + }, + "zfpy-0.5.5-py310h00e6091_6.tar.bz2": { + "build": "py310h00e6091_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "zfp 0.5.5 h295c915_6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "530260bea8bb8b7eda6285895359cb50", + "name": "zfpy", + "sha256": "f33445adbfb83e553eea95921db8e3a8d93e3ba23bb09b788696855fa36a9d73", + "size": 106158, + "subdir": "linux-64", + "timestamp": 1640796181024, + "version": "0.5.5" + }, + "zfpy-0.5.5-py36ha9443f7_4.tar.bz2": { + "build": "py36ha9443f7_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "zfp 0.5.5 h2531618_4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5a8021fb9843d258b3fe416db482b67a", + "name": "zfpy", + "sha256": "a386100fe8bb0b59ce9109ebd2ff67f64c1b37ef9e6608f510888e61011f0fcc", + "size": 109134, + "subdir": "linux-64", + "timestamp": 1611240547318, + "version": "0.5.5" + }, + "zfpy-0.5.5-py36ha9443f7_6.tar.bz2": { + "build": "py36ha9443f7_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "zfp 0.5.5 h2531618_6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "daf544d4588510d7653261f84855109f", + "name": "zfpy", + "sha256": "f49ce36ef485a1d0c6876554e0ec4b5d158ac01454293a918b975b233fe56512", + "size": 109428, + "subdir": "linux-64", + "timestamp": 1617996045289, + "version": "0.5.5" + }, + "zfpy-0.5.5-py37ha9443f7_4.tar.bz2": { + "build": "py37ha9443f7_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "zfp 0.5.5 h2531618_4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7c6b99c250576c3a0bddfcec53ca8036", + "name": "zfpy", + "sha256": "4bec7a5dcf507180b99155c8878f3b227713a5c0e5503047ff68c8960555aefd", + "size": 108931, + "subdir": "linux-64", + "timestamp": 1611240610773, + "version": "0.5.5" + }, + "zfpy-0.5.5-py37ha9443f7_6.tar.bz2": { + "build": "py37ha9443f7_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "zfp 0.5.5 h2531618_6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f1d30db45b70fc7736b19249130cf596", + "name": "zfpy", + "sha256": "8c6ccab0ddda3a4bd774a94a2864f84861d3335f76d3c75d891c0567227dcef3", + "size": 109571, + "subdir": "linux-64", + "timestamp": 1617996111387, + "version": "0.5.5" + }, + "zfpy-0.5.5-py38ha9443f7_4.tar.bz2": { + "build": "py38ha9443f7_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "zfp 0.5.5 h2531618_4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "91e75b3b8c08a191e82ce1c8a9eb86a0", + "name": "zfpy", + "sha256": "28bc654a725e5c806eaf99e8abb39d4ca0183efed89b232253f25f965617be24", + "size": 111398, + "subdir": "linux-64", + "timestamp": 1611240640020, + "version": "0.5.5" + }, + "zfpy-0.5.5-py38ha9443f7_6.tar.bz2": { + "build": "py38ha9443f7_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "zfp 0.5.5 h2531618_6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0bd23519f457f2192b1867e8f5eb1042", + "name": "zfpy", + "sha256": "4aa7d395c8952026bf91894b5d23fb1c56be8e3c52d3e93811e5ed3aa4ba3785", + "size": 111835, + "subdir": "linux-64", + "timestamp": 1617996078685, + "version": "0.5.5" + }, + "zfpy-0.5.5-py39ha9443f7_4.tar.bz2": { + "build": "py39ha9443f7_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "zfp 0.5.5 h2531618_4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fbb19633b37f6731cff5d64298f046a6", + "name": "zfpy", + "sha256": "b9fa06dd28e001e85eff3909420a688b8e6e5a7b0f4b63876ee910172e6ffc3d", + "size": 111547, + "subdir": "linux-64", + "timestamp": 1611240580899, + "version": "0.5.5" + }, + "zfpy-0.5.5-py39ha9443f7_6.tar.bz2": { + "build": "py39ha9443f7_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "zfp 0.5.5 h2531618_6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d9a0aa8fec7aad06c4d5227dc1a7fd80", + "name": "zfpy", + "sha256": "106cb1c24dde87ff7d854c2d9118a354b056fd36e2385bb0a0c163b8094beeec", + "size": 112141, + "subdir": "linux-64", + "timestamp": 1617996005524, + "version": "0.5.5" + }, + "zict-0.1.2-py27hd58a209_0.tar.bz2": { + "build": "py27hd58a209_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "817c14270b0fcbf1d1a250d8df16f7a5", + "name": "zict", + "sha256": "156c7bbd264729c702f8530ee7a5ac45e8d243202e97353664f43e489debaffa", + "size": 17379, + "subdir": "linux-64", + "timestamp": 1505864116669, + "version": "0.1.2" + }, + "zict-0.1.2-py35h00a3a39_0.tar.bz2": { + "build": "py35h00a3a39_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7f3a78e0961f907a90d233c36f94d213", + "name": "zict", + "sha256": "a3d60ec7b68a7128732ff74d26ccdeec5783c64c99b91102c4c8efb7134ef8bf", + "size": 18061, + "subdir": "linux-64", + "timestamp": 1505864129358, + "version": "0.1.2" + }, + "zict-0.1.2-py36ha0d441b_0.tar.bz2": { + "build": "py36ha0d441b_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a6ce06a0c82fcff768ae00f42751b469", + "name": "zict", + "sha256": "22b9c911694b47598315260d029728893c1c05b3588709d8943865c417b66623", + "size": 17947, + "subdir": "linux-64", + "timestamp": 1505864141657, + "version": "0.1.2" + }, + "zict-0.1.3-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7a8572adb40d45786b13b5fd1b0ffbb9", + "name": "zict", + "sha256": "3c964e9aae1cd5d0816d48e580efbf906872c6512fd9706d77238af7b4c2a247", + "size": 17919, + "subdir": "linux-64", + "timestamp": 1530741396896, + "version": "0.1.3" + }, + "zict-0.1.3-py27h12c336c_0.tar.bz2": { + "build": "py27h12c336c_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5fe9bff7b54a7e16c6b6799c36348c33", + "name": "zict", + "sha256": "1832cf03a27046a589462d7d1c7d444439925a153f17b32d5b738a07e8324745", + "size": 18169, + "subdir": "linux-64", + "timestamp": 1506623950570, + "version": "0.1.3" + }, + "zict-0.1.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "67bb21644ce23d067f3c430082a03382", + "name": "zict", + "sha256": "6e5864e95b5b905c87125d009ba6f68328ff7a8d4d22f408e5492bb76c10aeee", + "size": 18486, + "subdir": "linux-64", + "timestamp": 1534356526527, + "version": "0.1.3" + }, + "zict-0.1.3-py35h29275ca_0.tar.bz2": { + "build": "py35h29275ca_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0653c1c6f85168d743c50ec51741889d", + "name": "zict", + "sha256": "0678e2edb75f7d31a4e972376d445c69a982bf110bc3718af4dfdaba20da109e", + "size": 18784, + "subdir": "linux-64", + "timestamp": 1506623963574, + "version": "0.1.3" + }, + "zict-0.1.3-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "af2487f3d6ee4063c5766fa9ab92242d", + "name": "zict", + "sha256": "b2639164d6f28a240e2ec1a82fed28d2343020044fc638c63439822e4f3afc39", + "size": 18448, + "subdir": "linux-64", + "timestamp": 1530741375348, + "version": "0.1.3" + }, + "zict-0.1.3-py36h3a3bf81_0.tar.bz2": { + "build": "py36h3a3bf81_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "eec234595d7a7745fe3e482b004863c2", + "name": "zict", + "sha256": "415b25e1c7f6f2db818e922e37a55759624af03da28c7f3bcd7d9493ac5be5bd", + "size": 18637, + "subdir": "linux-64", + "timestamp": 1506623934600, + "version": "0.1.3" + }, + "zict-0.1.3-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a49d07c3b30c3b3b4bbaa2d3c92f498c", + "name": "zict", + "sha256": "8fd28043e488977d46ec79bb3a2b24c4fca50fabba9be23eba940d9cb292ca84", + "size": 18451, + "subdir": "linux-64", + "timestamp": 1530741419634, + "version": "0.1.3" + }, + "zict-0.1.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0131743dfc70097f43d113cf939503f2", + "name": "zict", + "sha256": "4c0043641a210791dad5637674508e4c1e2a61ca71face7b2cf8582d87dcb337", + "size": 19909, + "subdir": "linux-64", + "timestamp": 1552332522142, + "version": "0.1.4" + }, + "zict-0.1.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "994866a701d274d817407f9ab194ca4a", + "name": "zict", + "sha256": "3187550cebf244bffdd6e3b8bc7d35dce4928363d0f29448340e1fa47a19a579", + "size": 20423, + "subdir": "linux-64", + "timestamp": 1552332562580, + "version": "0.1.4" + }, + "zict-0.1.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e4430addc8080b657a7fe722f85fe6ee", + "name": "zict", + "sha256": "227ee15097455c64de149cfa55120c900a7fbf86c11e997c4b01716d59c448e2", + "size": 20423, + "subdir": "linux-64", + "timestamp": 1552332498401, + "version": "0.1.4" + }, + "zict-2.1.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "953a9b7bd372745b827e5486d2ba22c0", + "name": "zict", + "sha256": "300325594aad9cfd8394f54b06f98663c4d8df89c661c0fc60d9fade37d40c84", + "size": 19598, + "subdir": "linux-64", + "timestamp": 1656387213310, + "version": "2.1.0" + }, + "zict-2.1.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "798b088988bba83bebc8059d596fb381", + "name": "zict", + "sha256": "e8af51bdca69c453c504559564f2a726b4d0944e15410caeec076d03ca817546", + "size": 25204, + "subdir": "linux-64", + "timestamp": 1679340722072, + "version": "2.1.0" + }, + "zict-2.1.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "254fa18e7244a650b27fdf26c58b7a5e", + "name": "zict", + "sha256": "b19bfed2198e7a461bfc3228fccb4d8146c0bfe7ec8aca410ab4a7b89afc0863", + "size": 19216, + "subdir": "linux-64", + "timestamp": 1656387239621, + "version": "2.1.0" + }, + "zict-2.1.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3922c59916e4c2627f231875f5592a40", + "name": "zict", + "sha256": "2327825614f8348e1db29be921158ed07ed8dfcbd78ab03683d0f5483af31011", + "size": 19308, + "subdir": "linux-64", + "timestamp": 1656387288864, + "version": "2.1.0" + }, + "zict-2.1.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "75e08431fbd599e873d99b651ff3accc", + "name": "zict", + "sha256": "2aa1b067123afbc8057a538baf0881ab167e675735b878cd9a4215ed2cbed9b5", + "size": 19320, + "subdir": "linux-64", + "timestamp": 1656387265003, + "version": "2.1.0" + }, + "zip-3.0-h1adfe0e_0.tar.bz2": { + "build": "h1adfe0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "BSD-like", + "md5": "2d20bf60237c3a6deecc7fb770795e0e", + "name": "zip", + "sha256": "3c2cc77ec24b604cc5144100eac2229cf948139c2515873eda52f3ab344f0d52", + "size": 120029, + "subdir": "linux-64", + "timestamp": 1508871053253, + "version": "3.0" + }, + "zip-3.0-h7f8727e_1.tar.bz2": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0c980487c906a60dcc1582ce2fb71245", + "name": "zip", + "sha256": "15142091783963acf147230cf731e5cbecde952fadeeeaa546d2e353e4bd9be4", + "size": 118553, + "subdir": "linux-64", + "timestamp": 1641485406564, + "version": "3.0" + }, + "zipfile36-0.1.3-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "PSF", + "md5": "8c07e72c0c5aec8314359234db8266c9", + "name": "zipfile36", + "sha256": "16b9a43dae052dda9b62f56a23a31b9c9dd635dab3c30c1f47f104b3275b67dd", + "size": 38911, + "subdir": "linux-64", + "timestamp": 1529946830714, + "version": "0.1.3" + }, + "zipp-0.3.3-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95bf17685b6e64d8eb1fb8c29ebc664f", + "name": "zipp", + "sha256": "0000b1cbbc59e50de1f255a4fdf1158d166331f0ab29c4fde0e3624da09e8ab5", + "size": 8699, + "subdir": "linux-64", + "timestamp": 1553291284730, + "version": "0.3.3" + }, + "zipp-0.3.3-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45b998e47f1d425d81afeea12da64a48", + "name": "zipp", + "sha256": "01357a9fc95f6f56e669487f2dc3c0ce22a3598ac6399923e14a0cca1f494f60", + "size": 8846, + "subdir": "linux-64", + "timestamp": 1553291254866, + "version": "0.3.3" + }, + "zipp-0.3.3-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64eb2e49bd71149d57db67225c06970a", + "name": "zipp", + "sha256": "4b05b78f896bb8d430db815f146b08d135e155d3f3338dac9385f30630efcd6e", + "size": 8870, + "subdir": "linux-64", + "timestamp": 1553291096233, + "version": "0.3.3" + }, + "zipp-3.11.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6616a7c8c866cbfb984e121daa000203", + "name": "zipp", + "sha256": "111b051a18202e29cb357f38614f8223b2957d79b6cd63da72cc4fd9285cf27d", + "size": 18133, + "subdir": "linux-64", + "timestamp": 1672387178187, + "version": "3.11.0" + }, + "zipp-3.11.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a196bcb527aab35c0b3feaf645ca0093", + "name": "zipp", + "sha256": "6ca65de4710f8434567e16c38c0db993da9f329e78eb6c1a58fabd9ff2111f99", + "size": 21202, + "subdir": "linux-64", + "timestamp": 1676822906227, + "version": "3.11.0" + }, + "zipp-3.11.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "357a440dd6cb7d467c15460783322288", + "name": "zipp", + "sha256": "ad7a24e2774a58272e2063d84ba86e56fd21fccd07a2f8898971a3fd498494f3", + "size": 17935, + "subdir": "linux-64", + "timestamp": 1672387204646, + "version": "3.11.0" + }, + "zipp-3.11.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea786d4d331b83592b3004c0d5015131", + "name": "zipp", + "sha256": "bf2618c61988cae41c3428a3e4564f22016705b29b312ba2ffe02b2c7413e407", + "size": 17966, + "subdir": "linux-64", + "timestamp": 1672387151546, + "version": "3.11.0" + }, + "zipp-3.11.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3818a9531fe74433c3b7d5144c9a58cc", + "name": "zipp", + "sha256": "d15085ade33b9eb9adf8f3b8dad240688ee10ab49e7d7c33015c6d4f51202b72", + "size": 18021, + "subdir": "linux-64", + "timestamp": 1672387231268, + "version": "3.11.0" + }, + "zipp-3.8.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4bda2df7cccf45ef8e4396fc02ccae4a", + "name": "zipp", + "sha256": "36a5666b0ecc0728516f41a8087dbc5ff89ec49e61c7332d59bf171d0eb0613d", + "size": 15066, + "subdir": "linux-64", + "timestamp": 1652341858470, + "version": "3.8.0" + }, + "zipp-3.8.0-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3dd4fe7393f6238ea00adf903c125da5", + "name": "zipp", + "sha256": "f68a5a6641e9f095c42a349a4275707a0a14c9ff2145383eff0599645f2aacfe", + "size": 14877, + "subdir": "linux-64", + "timestamp": 1652341821246, + "version": "3.8.0" + }, + "zipp-3.8.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f4dade40cd86126c352d108080892761", + "name": "zipp", + "sha256": "98fae1a4bd69f55ed17961bf4eba76089d5bfb0154758d859c92fd32fc61f4e6", + "size": 14925, + "subdir": "linux-64", + "timestamp": 1652341795481, + "version": "3.8.0" + }, + "zipp-3.8.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "215b8728e7dd452f9dde848fabe76c66", + "name": "zipp", + "sha256": "f982ca0fbecce3ac6e536dd012524d119bb5db0161426627459c56ca0102f4c9", + "size": 14968, + "subdir": "linux-64", + "timestamp": 1652341885546, + "version": "3.8.0" + }, + "zlib-1.2.11-h7b6447c_3.tar.bz2": { + "build": "h7b6447c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "zlib", + "license_family": "Other", + "md5": "e76217678961a4836e1067a2d11603e2", + "name": "zlib", + "sha256": "d5653139d823ef26148ea5fe781e48e62a1d95b487a80e9aa3507dfd9efd5971", + "size": 122469, + "subdir": "linux-64", + "timestamp": 1542814864621, + "version": "1.2.11" + }, + "zlib-1.2.11-h7f8727e_4.tar.bz2": { + "build": "h7f8727e_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "zlib", + "license_family": "Other", + "md5": "5a6b72afc653d20469e4e6818e554df2", + "name": "zlib", + "sha256": "c37b50a76f3a34d3260ebca42200aefb33aea71e9141c167e0a70199f6b3c071", + "size": 128442, + "subdir": "linux-64", + "timestamp": 1639764859039, + "version": "1.2.11" + }, + "zlib-1.2.11-ha838bed_2.tar.bz2": { + "build": "ha838bed_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "zlib", + "license_family": "Other", + "md5": "7da835fb21e0c8da332aaef68f9ab80f", + "name": "zlib", + "sha256": "32155b71ec8acb488e7c534dc4e00d9ee396f2084767680c1767cd9d865ac2a1", + "size": 103683, + "subdir": "linux-64", + "timestamp": 1510092253691, + "version": "1.2.11" + }, + "zlib-1.2.11-hfbfcf68_1.tar.bz2": { + "build": "hfbfcf68_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "zlib", + "license_family": "Other", + "md5": "cb3dfd6392fcc03474b8d71cf8f0b264", + "name": "zlib", + "sha256": "97c9bd774d08dcc6383c297e4378e1486061e7af426f3e62fda449454de7defb", + "size": 102991, + "subdir": "linux-64", + "timestamp": 1505666570797, + "version": "1.2.11" + }, + "zlib-1.2.12-h5eee18b_3.tar.bz2": { + "build": "h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "Zlib", + "license_family": "Other", + "md5": "e3aea5293bc691638d2de998a6dff9f8", + "name": "zlib", + "sha256": "f01dd324e1f198b7311eb5e89abe6f0818e0b1770741a71790841042b73e50af", + "size": 127024, + "subdir": "linux-64", + "timestamp": 1662662335210, + "version": "1.2.12" + }, + "zlib-1.2.12-h7f8727e_2.tar.bz2": { + "build": "h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "Zlib", + "license_family": "Other", + "md5": "601d9449c280b9b145dc8c83b6f06119", + "name": "zlib", + "sha256": "513444d83ac2405e898531492ea59f3a95641e357cc39c1048d6fffc1791a16b", + "size": 133595, + "subdir": "linux-64", + "timestamp": 1650637720646, + "version": "1.2.12" + }, + "zlib-1.2.13-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "Zlib", + "license_family": "Other", + "md5": "4f315d7551f4bbeb06b6fc28342a9aa5", + "name": "zlib", + "sha256": "2dc9150a95704d83efd39bb9dfb44bdf8419022f4fb0fc416380a922a27c130d", + "size": 127528, + "subdir": "linux-64", + "timestamp": 1666595012798, + "version": "1.2.13" + }, + "zlib-ng-2.0.7-h5eee18b_0.tar.bz2": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "Zlib", + "license_family": "Other", + "md5": "0a59ed64efbc352b90efbb2f8960b032", + "name": "zlib-ng", + "sha256": "d61ea03b1adfa448f78571ed67ff78069296f45930243f7a1e99ef26f04d59dc", + "size": 99105, + "subdir": "linux-64", + "timestamp": 1680705068426, + "version": "2.0.7" + }, + "zope-1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "e0ab2b551af60818aa7dd7b4d2941edb", + "name": "zope", + "sha256": "18d2c5eab8c302802d5ff748e93b726bcda8ac49ed1ea93bc27880b885bab711", + "size": 3463, + "subdir": "linux-64", + "timestamp": 1530875059578, + "version": "1.0" + }, + "zope-1.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "149723053e2e32cf9c1ed21cb861ff94", + "name": "zope", + "sha256": "d2adb8c3d700e5a2090d12142cb51dfa3cf478a9e2dd1c5c31e758968f9d422c", + "size": 3545, + "subdir": "linux-64", + "timestamp": 1536258468186, + "version": "1.0" + }, + "zope-1.0-py310h06a4308_1.tar.bz2": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "3fd30b705b3915929c857b6ff1b5a426", + "name": "zope", + "sha256": "c00a2cb3dcc8ac5ecbb99963762bff23dd32a2012792112c7d54c413e3a7424c", + "size": 3783, + "subdir": "linux-64", + "timestamp": 1640796198952, + "version": "1.0" + }, + "zope-1.0-py311h06a4308_1.tar.bz2": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "md5": "a4bfb759eded2c4e92511e48a87c1cef", + "name": "zope", + "sha256": "22652cd10010b6b09f9cd43a73992ed43c3ec2fd7a8ca64b2332c146bfa46692", + "size": 4059, + "subdir": "linux-64", + "timestamp": 1676904014115, + "version": "1.0" + }, + "zope-1.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "04e9a1ab28211c2914312dbed81e5b94", + "name": "zope", + "sha256": "e6feb13d008d49372fa996119b5fca81ed93030c4dbe410c6758e5a572407d12", + "size": 3596, + "subdir": "linux-64", + "timestamp": 1536258551233, + "version": "1.0" + }, + "zope-1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "2c2dfd97a3cc05a806a746177b258565", + "name": "zope", + "sha256": "8071ac6735f76e9555edae838eed6ab519f3ac0c1e679168b90943e6645bdb04", + "size": 3498, + "subdir": "linux-64", + "timestamp": 1530875010387, + "version": "1.0" + }, + "zope-1.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "d3d86bf9a4a93faa02b345b2c04dbfb7", + "name": "zope", + "sha256": "2878d305b292a7e6791b0f4fd9a28bebd07fce392f704985c051fc11eb89fbcc", + "size": 3572, + "subdir": "linux-64", + "timestamp": 1536258449452, + "version": "1.0" + }, + "zope-1.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "e167afb5a53c9e058e121a9e98fb4cb2", + "name": "zope", + "sha256": "0fbfa34c656d9d5c7b27f1e6a535cdc64644da399d587ca0afc605394c73402d", + "size": 3505, + "subdir": "linux-64", + "timestamp": 1530875035196, + "version": "1.0" + }, + "zope-1.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "78c27cd846f6c3ec1f4f0c46b07760dd", + "name": "zope", + "sha256": "4ce1e3a35a34c91294a5505d7ba752fc3615bf66d5d7fd2a530b9ea285c383aa", + "size": 3587, + "subdir": "linux-64", + "timestamp": 1536258526985, + "version": "1.0" + }, + "zope-1.0-py38_1.tar.bz2": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "f2f5c16e6857d8c3b32f23ff04afb38e", + "name": "zope", + "sha256": "512675fb206df408715cea1aeeb1f488248115ab360dd6ea94d26fb8600fc631", + "size": 3950, + "subdir": "linux-64", + "timestamp": 1573730067287, + "version": "1.0" + }, + "zope-1.0-py39h06a4308_1.tar.bz2": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "52e331bdeb276177ffc2f4f2ed36dd37", + "name": "zope", + "sha256": "f92d870066424bdad80d7a32dd4dce1f3a9a39d6bf8576a5bfe9bb713412dbd3", + "size": 199837, + "subdir": "linux-64", + "timestamp": 1607554559140, + "version": "1.0" + }, + "zope.component-4.4.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "ed46adaf18782ff3cd82b0c9a0bbdc09", + "name": "zope.component", + "sha256": "ce04ce70afbf0819bc0b60dd54310acc20e0efeabd33854ce84a3dfa06d1793a", + "size": 84492, + "subdir": "linux-64", + "timestamp": 1530875457003, + "version": "4.4.1" + }, + "zope.component-4.4.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "39e971e8d49a1976d7179560b9c1ab29", + "name": "zope.component", + "sha256": "4b37e93cd630159a8bf82b4c153216f08b3034a10836bf43a874c47ced2650f9", + "size": 92163, + "subdir": "linux-64", + "timestamp": 1640813234958, + "version": "4.4.1" + }, + "zope.component-4.4.1-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "d0ecf6c05c2f9cad1dc190ce826517ee", + "name": "zope.component", + "sha256": "e52df6b55940f90bcdf40aec0a077f0c02dc1a0b181484c4e254ae7b2b0b1f78", + "size": 121183, + "subdir": "linux-64", + "timestamp": 1676907901924, + "version": "4.4.1" + }, + "zope.component-4.4.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "56846b9320cda0ed9e9bb4f7b72409e8", + "name": "zope.component", + "sha256": "d2f65410a32be588608bc7100661c3e3dc3f9cbf48ae46ab5e892db54037366c", + "size": 89475, + "subdir": "linux-64", + "timestamp": 1530875397792, + "version": "4.4.1" + }, + "zope.component-4.4.1-py36h06a4308_0.tar.bz2": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "fbd71841f4b60625e2c02fea0a06a804", + "name": "zope.component", + "sha256": "0bb8faf842261ec5e901fe5bb587a00b8aad244df9b87464cfe1d5d5881c9195", + "size": 305610, + "subdir": "linux-64", + "timestamp": 1613038482861, + "version": "4.4.1" + }, + "zope.component-4.4.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "1a796bc077abf301c5d07f39389cc76d", + "name": "zope.component", + "sha256": "af943c801cf40da8b16957e1d7c25be8018b25818207b2639091f168fad6c6a9", + "size": 89693, + "subdir": "linux-64", + "timestamp": 1530875428225, + "version": "4.4.1" + }, + "zope.component-4.4.1-py37h06a4308_0.tar.bz2": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "05e526fad35a5363cef8c5b184f3015e", + "name": "zope.component", + "sha256": "396dd7907e22da71f6b0bd52a0e8179c50867d995629f33002d2af9577a37f3d", + "size": 314437, + "subdir": "linux-64", + "timestamp": 1613038453001, + "version": "4.4.1" + }, + "zope.component-4.4.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "6c913db4e69f70924de3bb20971793a8", + "name": "zope.component", + "sha256": "d8cd5742e6302ce12a69f9cec05eb6d90049235f535d6a8f7d31a3b574bb099a", + "size": 90796, + "subdir": "linux-64", + "timestamp": 1574412804135, + "version": "4.4.1" + }, + "zope.component-4.4.1-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "82f0c9e1af0396394ea67bc9c8d94cc5", + "name": "zope.component", + "sha256": "dc126b72f0fd87149b56053b5e7774fff0fab2f0c087b920778fcbae7e43b284", + "size": 315580, + "subdir": "linux-64", + "timestamp": 1613043468132, + "version": "4.4.1" + }, + "zope.component-4.4.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "2b293d558a090e264fe2c7a31fb380e6", + "name": "zope.component", + "sha256": "614c481b2147dfbbd79df90953db0b45cd152baf1b1c46c8dc0981cf5414643a", + "size": 307129, + "subdir": "linux-64", + "timestamp": 1613043067627, + "version": "4.4.1" + }, + "zope.deprecation-4.3.0-py27_1.tar.bz2": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "1570fd5c673f7a825d3ebfd305fab7d8", + "name": "zope.deprecation", + "sha256": "d1f257f67cd21858bce772da8392485f1c53e93bb5ea2abbb7ab2dac8ac2b439", + "size": 18185, + "subdir": "linux-64", + "timestamp": 1530025617156, + "version": "4.3.0" + }, + "zope.deprecation-4.3.0-py35_1.tar.bz2": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "156616610c73db8073c57038fbdb3801", + "name": "zope.deprecation", + "sha256": "c52e4e60ab2b6d2e1abcd0368067b3d41ad75d9a10bd6c010f07b7fc6be2c33f", + "size": 18991, + "subdir": "linux-64", + "timestamp": 1530025685756, + "version": "4.3.0" + }, + "zope.deprecation-4.3.0-py36_1.tar.bz2": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "d7c622dc63b5ce35add82765fb3aac8f", + "name": "zope.deprecation", + "sha256": "d23183e5495ad501acfc0f4ea392813d05882ceec80fcf855607f6bebbf4f1db", + "size": 18991, + "subdir": "linux-64", + "timestamp": 1530025447369, + "version": "4.3.0" + }, + "zope.deprecation-4.3.0-py37_1.tar.bz2": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "92c3a3e3614adf64fb87f1bd2c7d5db0", + "name": "zope.deprecation", + "sha256": "afdd0ba8cb035ca95b5bdfc7d1c12b0d13e65491ad725f2a4e2f4a965cb601a8", + "size": 19051, + "subdir": "linux-64", + "timestamp": 1530875086317, + "version": "4.3.0" + }, + "zope.deprecation-4.4.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "ab394b4b9525d1edf5409b3dca767127", + "name": "zope.deprecation", + "sha256": "22a8409c4370258d15ef31d33916de4dc945b4a7276be83e228a55984396bb6b", + "size": 18350, + "subdir": "linux-64", + "timestamp": 1545113657943, + "version": "4.4.0" + }, + "zope.deprecation-4.4.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "5597e15e267a5efc9820bd0f9722f951", + "name": "zope.deprecation", + "sha256": "70b9af9356689d9d52dd703f2f312ca9d620ae90cee96d63437aed3ac9dd6c48", + "size": 19627, + "subdir": "linux-64", + "timestamp": 1640811446562, + "version": "4.4.0" + }, + "zope.deprecation-4.4.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "88061662e10a8f435c4a0a7c7b236a75", + "name": "zope.deprecation", + "sha256": "dcda9e1b833a7055812a131aa953179382aed89ec3129a6699e22d237dc5d052", + "size": 25025, + "subdir": "linux-64", + "timestamp": 1676905892997, + "version": "4.4.0" + }, + "zope.deprecation-4.4.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "8576df2733a3f4ac3ed1650303afbb3b", + "name": "zope.deprecation", + "sha256": "cb9b9bef050030ffaa08b9d0cfc0b2b79fd4fd0a3bcc817318017cabedbb216c", + "size": 19177, + "subdir": "linux-64", + "timestamp": 1545113690000, + "version": "4.4.0" + }, + "zope.deprecation-4.4.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "627716ce83703c2e804ee10e2298f1f2", + "name": "zope.deprecation", + "sha256": "d4ee749001140572c9229538f0389356efaf3500e0ebdd6328a7d8aa91c04814", + "size": 19262, + "subdir": "linux-64", + "timestamp": 1545113675367, + "version": "4.4.0" + }, + "zope.deprecation-4.4.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "0a38ebc41077bf6ccd2494104ff10de7", + "name": "zope.deprecation", + "sha256": "cb774ee688d5317986bdad458dcc50093f787c20c3a60d6a27f863ffe24a1c9c", + "size": 19651, + "subdir": "linux-64", + "timestamp": 1574437475997, + "version": "4.4.0" + }, + "zope.deprecation-4.4.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "6b41bdca05d9d144ddcd29d0eb4e3781", + "name": "zope.deprecation", + "sha256": "7072a48cb190ce76b1509cc1787327dccccc42f3db1912e937b0f09a1707229c", + "size": 218550, + "subdir": "linux-64", + "timestamp": 1607554972940, + "version": "4.4.0" + }, + "zope.event-4.3.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "612ae3c2e32ab96609204c9531c5efba", + "name": "zope.event", + "sha256": "37f3a8bd5df75e7b1cb5fc653c6b884b22711fadddff0f47f500c5f1cc2e9dce", + "size": 9236, + "subdir": "linux-64", + "timestamp": 1530875368195, + "version": "4.3.0" + }, + "zope.event-4.3.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "c9b1f5ab90f3ab11ee8dc479958d963a", + "name": "zope.event", + "sha256": "a4c959591932af964b4de76ef737ee39f6914be50a869cdb889010e710270452", + "size": 9361, + "subdir": "linux-64", + "timestamp": 1530875317520, + "version": "4.3.0" + }, + "zope.event-4.3.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "fa5749b30f8c548541de5bce05857070", + "name": "zope.event", + "sha256": "342f1a90512cd9b28a38d4fae5a3e0094ea8eb39f80d3c36c55ee77f9394a904", + "size": 9376, + "subdir": "linux-64", + "timestamp": 1530875343248, + "version": "4.3.0" + }, + "zope.event-4.4-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "a8f4dd2afe119f622dc670469af77e69", + "name": "zope.event", + "sha256": "3e638ca863ee9a9f04d2c6b83ded3646b634cb0ed2b05ced5899555194289bbc", + "size": 9529, + "subdir": "linux-64", + "timestamp": 1539659607288, + "version": "4.4" + }, + "zope.event-4.4-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "86d650078af65319b60150966fa03e8d", + "name": "zope.event", + "sha256": "0c35132d65c8ff8208a3b1a99d8957e08ae41d4dab537064d5afff4fc71a771d", + "size": 9653, + "subdir": "linux-64", + "timestamp": 1539659620561, + "version": "4.4" + }, + "zope.event-4.4-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "c4b305b9ff353ca551e7ebf08ef7c015", + "name": "zope.event", + "sha256": "36af92b77c1858534ecbc630327677a4d58429c5810f244419ff9ee56f01bd09", + "size": 9642, + "subdir": "linux-64", + "timestamp": 1539659622532, + "version": "4.4" + }, + "zope.event-4.4-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "571d357cbe476e1c9ac72612fc40f2ef", + "name": "zope.event", + "sha256": "34de89d4d8b2163d445f45e1b3f67456a0a262f611dc71c248fe1243d5ef531b", + "size": 9872, + "subdir": "linux-64", + "timestamp": 1574153556005, + "version": "4.4" + }, + "zope.event-4.5.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "6c6914295aa09eebe61c7c37183473f6", + "name": "zope.event", + "sha256": "7e9e2cd28fe51ca9df94bc93b5c15bab701371f9dc0f3b93c02f117b87a628cb", + "size": 9725, + "subdir": "linux-64", + "timestamp": 1640796217001, + "version": "4.5.0" + }, + "zope.event-4.5.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "0ee03f7ae9de0eba07bf6a5b7ec4b1d6", + "name": "zope.event", + "sha256": "b1bf22cdc92411ad04489a97c91f8f275df065786826fe314c24de8e3ddab0c4", + "size": 10872, + "subdir": "linux-64", + "timestamp": 1676906008282, + "version": "4.5.0" + }, + "zope.event-4.5.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "2413cd3140ef87bf7e525e90568676c9", + "name": "zope.event", + "sha256": "e49305a9b0523f1ce9f5524d4af09df98c334cb4af2e6a4f3e638ceab34762ab", + "size": 189837, + "subdir": "linux-64", + "timestamp": 1602679982746, + "version": "4.5.0" + }, + "zope.event-4.5.0-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "f467e75d4c9e18dbdeb83f7897945590", + "name": "zope.event", + "sha256": "b231bd7c8253d908a0e594793808139de176c63150020cad3b789483e40cf9e3", + "size": 189890, + "subdir": "linux-64", + "timestamp": 1602679988095, + "version": "4.5.0" + }, + "zope.event-4.5.0-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "2882a512544363072a19e180a3b3eb18", + "name": "zope.event", + "sha256": "ee6db1f84bddc5dc6218bb56f7f03e0714050307dedaa5e433cbb78a30a4a44d", + "size": 189858, + "subdir": "linux-64", + "timestamp": 1602679981330, + "version": "4.5.0" + }, + "zope.event-4.5.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "4bd4222120c245b26900c4df27a3a6b2", + "name": "zope.event", + "sha256": "68875bc0055d0346da28ebf49cae916fad06889873c63f97667fee3d81f7aa3c", + "size": 207040, + "subdir": "linux-64", + "timestamp": 1607554554233, + "version": "4.5.0" + }, + "zope.interface-4.4.3-py27hb02d991_0.tar.bz2": { + "build": "py27hb02d991_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "ac3174f869060149bde21c4fb179d200", + "name": "zope.interface", + "sha256": "4b79fda01f0f43ca7c9dc08ac178a91dedcbd0b047457d7e1266f725f30ade3e", + "size": 194965, + "subdir": "linux-64", + "timestamp": 1509046374236, + "version": "4.4.3" + }, + "zope.interface-4.4.3-py35h9cef842_0.tar.bz2": { + "build": "py35h9cef842_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "8dae33dc8976c2848b2b7663430e6b9c", + "name": "zope.interface", + "sha256": "8caab9482d55571ffba96c4a88545065d89185d4ed05569bd9908bdff27f3e11", + "size": 207405, + "subdir": "linux-64", + "timestamp": 1509046456695, + "version": "4.4.3" + }, + "zope.interface-4.4.3-py36h0ccbf34_0.tar.bz2": { + "build": "py36h0ccbf34_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "69a443974da9ffaf00bb7045b1aca173", + "name": "zope.interface", + "sha256": "08e7fffe68bdd240669b0fd2858df314d990ebcebbdb1bd7577711dd1fd5ad52", + "size": 206552, + "subdir": "linux-64", + "timestamp": 1509046464634, + "version": "4.4.3" + }, + "zope.interface-4.5.0-py27h14c3975_0.tar.bz2": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "e93448438c67bb13ae8d649a20982733", + "name": "zope.interface", + "sha256": "7901618956f136ff42be6f64d33943f24077fbd7f5511b49081db91c3079f92a", + "size": 194260, + "subdir": "linux-64", + "timestamp": 1524497593527, + "version": "4.5.0" + }, + "zope.interface-4.5.0-py35h14c3975_0.tar.bz2": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "a9104027073439acf86490dbb77ecb30", + "name": "zope.interface", + "sha256": "6c638b2f21bbf37766e37347ac2212035771efa03b9976b96b1c2f3b3b41e155", + "size": 206833, + "subdir": "linux-64", + "timestamp": 1524497638655, + "version": "4.5.0" + }, + "zope.interface-4.5.0-py36h14c3975_0.tar.bz2": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "54484594b572ea41f5968e7057972feb", + "name": "zope.interface", + "sha256": "95eae9e43529fe95d91709793cd670609362a4fdf537b5634c60186987757e9a", + "size": 206094, + "subdir": "linux-64", + "timestamp": 1524497527741, + "version": "4.5.0" + }, + "zope.interface-4.5.0-py37h14c3975_0.tar.bz2": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "96bb2cf560a3c34d9f9e952c76aabf9e", + "name": "zope.interface", + "sha256": "00d88db680a0893d64feb58dbf77285127d8ebabfd6540fa3ea3569d2aaa2789", + "size": 206290, + "subdir": "linux-64", + "timestamp": 1530875118566, + "version": "4.5.0" + }, + "zope.interface-4.6.0-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "899594f7738e18de36d32fd1c88c841d", + "name": "zope.interface", + "sha256": "4bbad74171a11ef47acefc6b1603ffa1fb86b52a5b81dac5b844849b2a5a5411", + "size": 204460, + "subdir": "linux-64", + "timestamp": 1541086267566, + "version": "4.6.0" + }, + "zope.interface-4.6.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "55175c1e17cc0ca88ff4816936d53ee7", + "name": "zope.interface", + "sha256": "536df0fdb1ce58439b6cbb5b514eb671275658573a3b7e7d476bb78bd4cf7d9b", + "size": 211593, + "subdir": "linux-64", + "timestamp": 1541086284344, + "version": "4.6.0" + }, + "zope.interface-4.6.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "7ea9b568a944c16f91042276e4b785fb", + "name": "zope.interface", + "sha256": "d620c7498c9ea904d0a1535c652b3080a5576efb7d851187a36650c107b6a736", + "size": 214261, + "subdir": "linux-64", + "timestamp": 1541086260681, + "version": "4.6.0" + }, + "zope.interface-4.6.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "eedf9bc1e8515e61f03cf9647f7f57f3", + "name": "zope.interface", + "sha256": "050e7464fa375e3fb9e688a647bd1194adce6bcf5c4315dd783358c986157bdf", + "size": 221192, + "subdir": "linux-64", + "timestamp": 1574412786634, + "version": "4.6.0" + }, + "zope.interface-4.7.1-py27h7b6447c_0.tar.bz2": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "1c56b7776e3b2cc2c201796777a1c3b4", + "name": "zope.interface", + "sha256": "26bcb67c1d2c730f28d115bb988f7ec173d6b580bfd524fa7c1cf23ddbd4425c", + "size": 209760, + "subdir": "linux-64", + "timestamp": 1574380019380, + "version": "4.7.1" + }, + "zope.interface-4.7.1-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "329e210267980e0c89450806c90aa602", + "name": "zope.interface", + "sha256": "346266d57c029197f06b8b6d37eb06b5df02c4ce9e28d7d407059c70af0ebabe", + "size": 219425, + "subdir": "linux-64", + "timestamp": 1574380047371, + "version": "4.7.1" + }, + "zope.interface-4.7.1-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "ac99459eeb3608866c2e967aa3bd6ec6", + "name": "zope.interface", + "sha256": "9ededc9af4ec80d06e91dbdd5ab438c5612a81ee7baf94b045aa719074551bf5", + "size": 219721, + "subdir": "linux-64", + "timestamp": 1574380033765, + "version": "4.7.1" + }, + "zope.interface-4.7.1-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "197ab6cb10fe8871a83ab2d21b1fa1cd", + "name": "zope.interface", + "sha256": "9d2d64b6d32d3faea8b5ad09a164812d7c05dc4d3f8d1b28c6d270c841cbb35b", + "size": 225663, + "subdir": "linux-64", + "timestamp": 1574380083111, + "version": "4.7.1" + }, + "zope.interface-5.1.0-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "eef5ffbecc4b39ef7973dc9d10305e8a", + "name": "zope.interface", + "sha256": "e9cce3bc3d2710f0e211204a975df919ef94bab378445ae0c4a41d0fa25309ff", + "size": 303804, + "subdir": "linux-64", + "timestamp": 1598624219648, + "version": "5.1.0" + }, + "zope.interface-5.1.0-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "dcc291bfdc974342856983005d3f20b8", + "name": "zope.interface", + "sha256": "2bc32b4bb1f96aed826f2450ae4512512468442f55a445e9990e1673e0c250a5", + "size": 302316, + "subdir": "linux-64", + "timestamp": 1598624210199, + "version": "5.1.0" + }, + "zope.interface-5.1.0-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "12f6267a7e2048f4a1423cbbaae1308a", + "name": "zope.interface", + "sha256": "37e828e6b7e7810fc062e8288b742a9af8ec33e4eee3e0388f13ced7153794d7", + "size": 304231, + "subdir": "linux-64", + "timestamp": 1598624233645, + "version": "5.1.0" + }, + "zope.interface-5.1.2-py36h7b6447c_0.tar.bz2": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "70ffaf71e4905208f68661888039c746", + "name": "zope.interface", + "sha256": "f6c4ddffd7ebc8cfb4ef1c2463a454f5cbfffe3c4a9bd7b0478c01a304fba8fe", + "size": 301438, + "subdir": "linux-64", + "timestamp": 1602002464067, + "version": "5.1.2" + }, + "zope.interface-5.1.2-py37h7b6447c_0.tar.bz2": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "52e7eca01a01812cd6530c87b9af790f", + "name": "zope.interface", + "sha256": "6d52e2667185b19603188e98b96032d8737d91d944e2099e92e36544b08bbf76", + "size": 301362, + "subdir": "linux-64", + "timestamp": 1602002484898, + "version": "5.1.2" + }, + "zope.interface-5.1.2-py38h7b6447c_0.tar.bz2": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "b374d3b6552d1175975f79a58f10f00e", + "name": "zope.interface", + "sha256": "bf611665cf69c62fb4f95ca38ab382d71ecfdb832ae98b2c83907afe774de386", + "size": 303915, + "subdir": "linux-64", + "timestamp": 1602002458077, + "version": "5.1.2" + }, + "zope.interface-5.2.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "60c60c79efd69e5a52edf93e009aefb2", + "name": "zope.interface", + "sha256": "90592a66f56c3e91e05703d9267e098422737742c9dde7707ec706fc44f3469e", + "size": 302340, + "subdir": "linux-64", + "timestamp": 1606940292673, + "version": "5.2.0" + }, + "zope.interface-5.2.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "a4afa45ffb7d68dc710c8326defdad97", + "name": "zope.interface", + "sha256": "d02e4eb4f93c0b62f268ba605b82183ab3f453377d43ace0388e8fbafb288199", + "size": 304481, + "subdir": "linux-64", + "timestamp": 1606940275034, + "version": "5.2.0" + }, + "zope.interface-5.2.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "844d63d786cea8d374b7aa298076c18d", + "name": "zope.interface", + "sha256": "847eab19b21dc1be5910706c151e7d5e16cd7d40fcea096c0524ca781e52ad7a", + "size": 303411, + "subdir": "linux-64", + "timestamp": 1606940298281, + "version": "5.2.0" + }, + "zope.interface-5.2.0-py39he8ac12f_0.tar.bz2": { + "build": "py39he8ac12f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "61eeca2e05639b81ab63dfbde2fc6acf", + "name": "zope.interface", + "sha256": "c0e164949045688c70d4639e08c495f7fb415852a595e55e111802ac8bc37d87", + "size": 307622, + "subdir": "linux-64", + "timestamp": 1607554999322, + "version": "5.2.0" + }, + "zope.interface-5.3.0-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "ed9485168ae2bc69de9715fe9be1cec2", + "name": "zope.interface", + "sha256": "3e51775a4036166ebc87815cd7b31bdd29dbe1ffc608e1d3da68b8508e014d5a", + "size": 320955, + "subdir": "linux-64", + "timestamp": 1616357256441, + "version": "5.3.0" + }, + "zope.interface-5.3.0-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "e76da4dee5cf7004193ea8c0e199e9e7", + "name": "zope.interface", + "sha256": "75868306dd73c1fc5f2f7b8ca7b8aba9f37bf06820ddd19dc3fc441aaf4bf5e3", + "size": 322229, + "subdir": "linux-64", + "timestamp": 1616355176353, + "version": "5.3.0" + }, + "zope.interface-5.3.0-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "d81e97d0eacd7ed377a62cccdc2db080", + "name": "zope.interface", + "sha256": "d07d12ee27326fab80671f5ac537acbabfdadcbab97cacf729ded0ae14c5fed0", + "size": 320695, + "subdir": "linux-64", + "timestamp": 1616357256943, + "version": "5.3.0" + }, + "zope.interface-5.3.0-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "3a587863a702c025caf4a7bd7719f377", + "name": "zope.interface", + "sha256": "a83999ed67b955580f1e8068739a193e49c14777ec8a2150c0b0e8a78be3887a", + "size": 319120, + "subdir": "linux-64", + "timestamp": 1616357254194, + "version": "5.3.0" + }, + "zope.interface-5.4.0-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "0a7056de81b12e18b277f48108f750db", + "name": "zope.interface", + "sha256": "52e42a11fa02a3a7fd803d0be950e6f63250823dbfd3a92d4ed8f121b86252ec", + "size": 368658, + "subdir": "linux-64", + "timestamp": 1640811472712, + "version": "5.4.0" + }, + "zope.interface-5.4.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "cb6ada415534c0a744f672b3094311d6", + "name": "zope.interface", + "sha256": "9589a0b9746d408d1af63061de329a4b36f92f138c1536a00db09f98fa37f051", + "size": 427303, + "subdir": "linux-64", + "timestamp": 1676905915790, + "version": "5.4.0" + }, + "zope.interface-5.4.0-py36h7f8727e_0.tar.bz2": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "da8ecc7da06080d6ea0b4a9a638ca585", + "name": "zope.interface", + "sha256": "7ab4191a02bd7e0b255dacb849bdf8d69348116b60e67ddac937fa3664ccd695", + "size": 325101, + "subdir": "linux-64", + "timestamp": 1625036220225, + "version": "5.4.0" + }, + "zope.interface-5.4.0-py37h7f8727e_0.tar.bz2": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "bfa65e5eafe75465157d78ac9929c869", + "name": "zope.interface", + "sha256": "8e3009773f38eea8d15ed07492d10c0df2976c132836c8ad9d7b3d69a7ec53c0", + "size": 328218, + "subdir": "linux-64", + "timestamp": 1625029751829, + "version": "5.4.0" + }, + "zope.interface-5.4.0-py38h7f8727e_0.tar.bz2": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "dc59f044503f55f8980a0ff7a34f3347", + "name": "zope.interface", + "sha256": "1faa2312665c6eace6e857fda2a2c0fbacd518876bab5a4d351c264b98e62202", + "size": 323930, + "subdir": "linux-64", + "timestamp": 1625035589413, + "version": "5.4.0" + }, + "zope.interface-5.4.0-py39h7f8727e_0.tar.bz2": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "df3e7bb79db3beb2648d5a0c22050bc0", + "name": "zope.interface", + "sha256": "fa60f0c62d6f7e719e70b607f122926081573229bddc785d4af4b26e5a81a835", + "size": 324379, + "subdir": "linux-64", + "timestamp": 1625036218413, + "version": "5.4.0" + }, + "zope.sqlalchemy-1.0-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "sqlalchemy >=0.5.1", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "60fcfb3d96f5d0e2e05352fe596855e5", + "name": "zope.sqlalchemy", + "sha256": "715709a288990dbe1cff2c33ce93f2715352e92af72bb3ff312583faa4f72ea2", + "size": 28404, + "subdir": "linux-64", + "timestamp": 1530022074421, + "version": "1.0" + }, + "zope.sqlalchemy-1.0-py35_0.tar.bz2": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "sqlalchemy >=0.5.1", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "231dcd90a3a00688d13b77aa6d96b0bc", + "name": "zope.sqlalchemy", + "sha256": "9ee923040a42a6ab84d73bdb2f5010a96b9a06b9a9447316d4a170d516dd2139", + "size": 29182, + "subdir": "linux-64", + "timestamp": 1530022095999, + "version": "1.0" + }, + "zope.sqlalchemy-1.0-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "sqlalchemy >=0.5.1", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "6a3c24f1c53312c42898ab0559ec3231", + "name": "zope.sqlalchemy", + "sha256": "81fb0dfbeb39aa4e68952550f0d2005649416bc1e2ba29fe9137455b3b34c508", + "size": 29078, + "subdir": "linux-64", + "timestamp": 1530022050857, + "version": "1.0" + }, + "zope.sqlalchemy-1.1-py27_0.tar.bz2": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "sqlalchemy >=0.5.1", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "4b2c6cc6455cff9dda012a4fe0013ceb", + "name": "zope.sqlalchemy", + "sha256": "eb7115c4b0e9b549aba617aff2e5fb2a4847017df049e2afbdc1667405e4df29", + "size": 155229, + "subdir": "linux-64", + "timestamp": 1548291061364, + "version": "1.1" + }, + "zope.sqlalchemy-1.1-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "sqlalchemy >=0.5.1", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "64268a8bde5f75f20dc996dbdf7244ca", + "name": "zope.sqlalchemy", + "sha256": "0262dc9bca157eafc1f410407c0c8397e8d01f92b92d20f119b91c129e8ab5d1", + "size": 29507, + "subdir": "linux-64", + "timestamp": 1640814737947, + "version": "1.1" + }, + "zope.sqlalchemy-1.1-py36_0.tar.bz2": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "sqlalchemy >=0.5.1", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "7d063090d7e1c47552bd569eecee0a6b", + "name": "zope.sqlalchemy", + "sha256": "842f2160f19d9975e24398527f1ba00f82f55338c1231d929d676b0bd0a82a69", + "size": 155699, + "subdir": "linux-64", + "timestamp": 1548291116118, + "version": "1.1" + }, + "zope.sqlalchemy-1.1-py37_0.tar.bz2": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "sqlalchemy >=0.5.1", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "0858fb3708254e24973af09febddd918", + "name": "zope.sqlalchemy", + "sha256": "51f24fe0ed7c665d41cfa73e498a4e256f4ff7c04f6e874986b5436105a5ef4e", + "size": 155833, + "subdir": "linux-64", + "timestamp": 1548310767869, + "version": "1.1" + }, + "zope.sqlalchemy-1.1-py38_0.tar.bz2": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "sqlalchemy >=0.5.1", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "4fdff2afeb0c1092f05e016419908613", + "name": "zope.sqlalchemy", + "sha256": "0c1120b028e8d022596c85dce5ad081d98a7c35d44bff283747261fc9307bb68", + "size": 29846, + "subdir": "linux-64", + "timestamp": 1573569845456, + "version": "1.1" + }, + "zope.sqlalchemy-1.1-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "sqlalchemy >=0.5.1", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "509a26f68e84de3c3dadca7f309b8d33", + "name": "zope.sqlalchemy", + "sha256": "ddd8a379e889a568f4bdd95345b826f6e66a77329efa3b76bb1d1e21902c2628", + "size": 230543, + "subdir": "linux-64", + "timestamp": 1607565334509, + "version": "1.1" + }, + "zope.sqlalchemy-2.0-py310h06a4308_0.tar.bz2": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "sqlalchemy >=1.1,!=1.4.0,!=1.4.1,!=1.4.2,!=1.4.3,!=1.4.4,!=1.4.5,!=1.4.6,<2", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "294e3cb22b0b83f661ceb0787019d064", + "name": "zope.sqlalchemy", + "sha256": "22dbf5c457240c061ab9f137c298debceae3a65294a05aef8efb313d00b04b17", + "size": 32522, + "subdir": "linux-64", + "timestamp": 1680531119592, + "version": "2.0" + }, + "zope.sqlalchemy-2.0-py311h06a4308_0.tar.bz2": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "sqlalchemy >=1.1,!=1.4.0,!=1.4.1,!=1.4.2,!=1.4.3,!=1.4.4,!=1.4.5,!=1.4.6,<2", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "80c0b9c3a42969c39f5cfbc57fd2b7ae", + "name": "zope.sqlalchemy", + "sha256": "9d184abe529adbc17147ff0030a1215cffb9980ee36d8995810177c3d07a7dff", + "size": 39784, + "subdir": "linux-64", + "timestamp": 1680531145428, + "version": "2.0" + }, + "zope.sqlalchemy-2.0-py38h06a4308_0.tar.bz2": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "sqlalchemy >=1.1,!=1.4.0,!=1.4.1,!=1.4.2,!=1.4.3,!=1.4.4,!=1.4.5,!=1.4.6,<2", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "a683156eedb19b232e72a5ed27252702", + "name": "zope.sqlalchemy", + "sha256": "6513ea143e66a8b92c7573829a89df41831b89afa4a4c969d1b602fa3024c388", + "size": 32405, + "subdir": "linux-64", + "timestamp": 1680531093869, + "version": "2.0" + }, + "zope.sqlalchemy-2.0-py39h06a4308_0.tar.bz2": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "sqlalchemy >=1.1,!=1.4.0,!=1.4.1,!=1.4.2,!=1.4.3,!=1.4.4,!=1.4.5,!=1.4.6,<2", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "ba66ec990d179f244ecfa2c2e456bb68", + "name": "zope.sqlalchemy", + "sha256": "e82b8b13e1c6b8162007bb5693eee55fc32de9ded6e0ad71309cbadfbccb9464", + "size": 32371, + "subdir": "linux-64", + "timestamp": 1680531169767, + "version": "2.0" + }, + "zstandard-0.12.0-py27he6710b0_0.tar.bz2": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e2f4c82dc5aaec1e2d5c393cec421318", + "name": "zstandard", + "sha256": "25f0d2d70326483b2a7947b5ac550ae931d9deae2e50e37bdb49e10be69f1c1f", + "size": 573677, + "subdir": "linux-64", + "timestamp": 1574350854778, + "version": "0.12.0" + }, + "zstandard-0.12.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "60dc9fadfe25f8faf1f425f23b1af0f8", + "name": "zstandard", + "sha256": "278535d207a7c445fa7b779813dd4e8a5c28d29e47679790f327a686440cecea", + "size": 603201, + "subdir": "linux-64", + "timestamp": 1574350865962, + "version": "0.12.0" + }, + "zstandard-0.12.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e79b0eea260d6c66c665d27bf42c08ac", + "name": "zstandard", + "sha256": "7126fc726b9eecb3084d346229e6cb10708391c9d2b525c7a8ee3922864280c5", + "size": 591892, + "subdir": "linux-64", + "timestamp": 1574350793607, + "version": "0.12.0" + }, + "zstandard-0.12.0-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cc10c47c3e8b2e2adc7444162b38b2ad", + "name": "zstandard", + "sha256": "a956b2b5f4bf4e5405d72c0fba428646a7c592c3b1342143ba45409ccd07e057", + "size": 603448, + "subdir": "linux-64", + "timestamp": 1574350887346, + "version": "0.12.0" + }, + "zstandard-0.13.0-py36he6710b0_0.tar.bz2": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fde85845fe25e998120861dc2430a0ee", + "name": "zstandard", + "sha256": "ba34ad934d0be49956a2ef19b9f54664db9fde489a498092505fb29baac7ebf9", + "size": 604603, + "subdir": "linux-64", + "timestamp": 1587391843895, + "version": "0.13.0" + }, + "zstandard-0.13.0-py37he6710b0_0.tar.bz2": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c374676d7a933b6a50b034cd132c8660", + "name": "zstandard", + "sha256": "20344ff5d8e63c96ab3559a80b0a99c6bd16c684f36a5d5bdf5a1fabab72cabc", + "size": 615106, + "subdir": "linux-64", + "timestamp": 1587391848339, + "version": "0.13.0" + }, + "zstandard-0.13.0-py38he6710b0_0.tar.bz2": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "96254004f1435d816a4658780df6161a", + "name": "zstandard", + "sha256": "287e8e9e1232252874eddce794ecd438b3ba3842db8e695b3d4cc5477f297070", + "size": 585572, + "subdir": "linux-64", + "timestamp": 1587391845625, + "version": "0.13.0" + }, + "zstandard-0.14.0-py36he6710b0_1.tar.bz2": { + "build": "py36he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "134487e76a86cc95e56e434f4ffe602d", + "name": "zstandard", + "sha256": "f0ebb275d76a283d012d3dd8f79ee4ba1b06c5e7655fe725bb7b8d6840134144", + "size": 618198, + "subdir": "linux-64", + "timestamp": 1602002578078, + "version": "0.14.0" + }, + "zstandard-0.14.0-py37he6710b0_1.tar.bz2": { + "build": "py37he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9fa7168119af1ef33d339b6742218042", + "name": "zstandard", + "sha256": "a1e85ea0167c8a64d62e11bb63e1a65db271be52140de9f80acbb3e2b22312dd", + "size": 622863, + "subdir": "linux-64", + "timestamp": 1602002574558, + "version": "0.14.0" + }, + "zstandard-0.14.0-py38he6710b0_1.tar.bz2": { + "build": "py38he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9de9ff8ad407edff04f175d2a4d654c0", + "name": "zstandard", + "sha256": "3bc790c4a685ba48dcded9e2497d0397e74d32b4b4b03beb8016cd0faf5cfdc1", + "size": 619426, + "subdir": "linux-64", + "timestamp": 1602002575022, + "version": "0.14.0" + }, + "zstandard-0.14.1-py36h2531618_0.tar.bz2": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c21dd0332114dbd5de2826222210ab82", + "name": "zstandard", + "sha256": "082960374839107aab796159438064314517e363b294295f6561db3a2024e04c", + "size": 594743, + "subdir": "linux-64", + "timestamp": 1607370388347, + "version": "0.14.1" + }, + "zstandard-0.14.1-py37h2531618_0.tar.bz2": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "60e7fb45410e2f68b632850549b9827d", + "name": "zstandard", + "sha256": "26b7c389ebfb64b748333f48581d72bc76d81efa6934c03f7fac9eeec6004f2f", + "size": 610334, + "subdir": "linux-64", + "timestamp": 1607370373091, + "version": "0.14.1" + }, + "zstandard-0.14.1-py38h2531618_0.tar.bz2": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "4ebb4cb018f5036651aecf0fc5793876", + "name": "zstandard", + "sha256": "ef91d01a5b34aeef28f408d6d352dc2dd5f7d9a92fc998d20b6e64c9ff549eca", + "size": 625523, + "subdir": "linux-64", + "timestamp": 1607370376071, + "version": "0.14.1" + }, + "zstandard-0.14.1-py39h2531618_0.tar.bz2": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "92bee231af8c2065966ae29b7fbff8e7", + "name": "zstandard", + "sha256": "d23843e4d332edd934e4b88bac5aa9c86b9d00575a4a97f4504982a37d0ae54b", + "size": 624119, + "subdir": "linux-64", + "timestamp": 1607370391118, + "version": "0.14.1" + }, + "zstandard-0.15.1-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c252bedc98b2e3990d99b8a7994a5ee3", + "name": "zstandard", + "sha256": "34d16020c038d12e62756c6c11443ee7abeb308190b6b0605fd7d6569838201b", + "size": 625065, + "subdir": "linux-64", + "timestamp": 1612472925947, + "version": "0.15.1" + }, + "zstandard-0.15.1-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9d32ad98f0e54fa2c5d389ca5fe9d92a", + "name": "zstandard", + "sha256": "294347071176592b0e11a0509e61d28f721d53732ac43b73a99beea4e2b3454c", + "size": 593237, + "subdir": "linux-64", + "timestamp": 1612472924443, + "version": "0.15.1" + }, + "zstandard-0.15.1-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "18aa785abc94bedc093b252d44f8f13e", + "name": "zstandard", + "sha256": "fd6cc9ac7c633222983786bd09afa3bddd80be950c98cdf2121917673b5b63ba", + "size": 594730, + "subdir": "linux-64", + "timestamp": 1612472921529, + "version": "0.15.1" + }, + "zstandard-0.15.1-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e0973bd7efe8d4095e7f2e5722e33d13", + "name": "zstandard", + "sha256": "6c1b074de49280be708853d2fe18a4c8b8c4613e98053cc12e14e92e17cfc49b", + "size": 629254, + "subdir": "linux-64", + "timestamp": 1612472887440, + "version": "0.15.1" + }, + "zstandard-0.15.2-py310h7f8727e_0.tar.bz2": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "74aa085bab593888ae377ebae3b9e9cb", + "name": "zstandard", + "sha256": "9c4894614167943194b87ad711fa81dfd777a0a688e5929f3969de7372d16eed", + "size": 2650488, + "subdir": "linux-64", + "timestamp": 1640796279567, + "version": "0.15.2" + }, + "zstandard-0.15.2-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "42500a44d38455940ace2a133fb5f40f", + "name": "zstandard", + "sha256": "22b55eb4d8ad06dfdd4897a4e6cfd1750d282974fd7b60bef99521bf40b26073", + "size": 641631, + "subdir": "linux-64", + "timestamp": 1676843149260, + "version": "0.15.2" + }, + "zstandard-0.15.2-py36h27cfd23_0.tar.bz2": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "5303cdc99cd8a00348e01a1c32da099d", + "name": "zstandard", + "sha256": "7f216e649342552e130932542294b155468392fa40afad49f7884b03664433a9", + "size": 612507, + "subdir": "linux-64", + "timestamp": 1614712289526, + "version": "0.15.2" + }, + "zstandard-0.15.2-py37h27cfd23_0.tar.bz2": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "4e075f453280378779e85e7d5480817f", + "name": "zstandard", + "sha256": "8c01383d5cf19e3afd8f1d85cdc66a6b9437bb195029e5b6c9764f05a6e68129", + "size": 612290, + "subdir": "linux-64", + "timestamp": 1614712702734, + "version": "0.15.2" + }, + "zstandard-0.15.2-py38h27cfd23_0.tar.bz2": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "33034b464d773308558bac77aa3c41a5", + "name": "zstandard", + "sha256": "78b6687318e0ca4583939d81a54a9b1aa09cc5d3b71531010dbd26dc80478738", + "size": 613729, + "subdir": "linux-64", + "timestamp": 1614712287481, + "version": "0.15.2" + }, + "zstandard-0.15.2-py39h27cfd23_0.tar.bz2": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "39be5f98577e0eee89bc8c6308b8398e", + "name": "zstandard", + "sha256": "c5441609117fe773f9cc263bce2672205bbf4626a7c7d1d1b484ff8864f3d951", + "size": 616081, + "subdir": "linux-64", + "timestamp": 1614712710598, + "version": "0.15.2" + }, + "zstandard-0.18.0-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.11", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7571fc26c935e053339054dd442cb6c4", + "name": "zstandard", + "sha256": "d3999cd7eec3476ab39c8f2809b6001151f622f2c80a89095c82e92f54cf44ad", + "size": 3890934, + "subdir": "linux-64", + "timestamp": 1663827618399, + "version": "0.18.0" + }, + "zstandard-0.18.0-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.11", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2f0beb17ee93d2197af2e964571b25c2", + "name": "zstandard", + "sha256": "f1033a6315bc076b580cf13e007c872f2e72697b2b54e9c627f618ec989f11bd", + "size": 682056, + "subdir": "linux-64", + "timestamp": 1663827683516, + "version": "0.18.0" + }, + "zstandard-0.18.0-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.11", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "773aeb569685d1aeb094d96a22992dab", + "name": "zstandard", + "sha256": "88dbe97515ce3a1b9a9c1ffe655cbead2c0fa3a64475771e4a517b379d88416b", + "size": 682521, + "subdir": "linux-64", + "timestamp": 1663827463404, + "version": "0.18.0" + }, + "zstandard-0.18.0-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.11", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "cf795c40ade55690299cc201f4fa4b46", + "name": "zstandard", + "sha256": "bc994bada9c090fbedcc2f0c36ac175ac0bd842db10d5860ac8659a35b745cdc", + "size": 683754, + "subdir": "linux-64", + "timestamp": 1663827528984, + "version": "0.18.0" + }, + "zstandard-0.19.0-py310h5eee18b_0.tar.bz2": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.11", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "43965738c2997758f1872ce22c1151e5", + "name": "zstandard", + "sha256": "61e8b8daa6b825f1a6943b4f814ededa5d93cd0293115ad97e65d0c986cf8748", + "size": 683538, + "subdir": "linux-64", + "timestamp": 1677013424472, + "version": "0.19.0" + }, + "zstandard-0.19.0-py311h5eee18b_0.tar.bz2": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.11", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6917453a6eb8bfb6c060f33f44f4eab0", + "name": "zstandard", + "sha256": "53b35c58a6b85a85f794aa9d7cf01df9f4a02be937da76d3f469350e3b93c6a7", + "size": 696129, + "subdir": "linux-64", + "timestamp": 1679339552937, + "version": "0.19.0" + }, + "zstandard-0.19.0-py37h5eee18b_0.tar.bz2": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.11", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fcba01fa52a2d0ff95b7b4fd001bed95", + "name": "zstandard", + "sha256": "b23f0866c48e5abcccc3b65d8b80a2c33bdb97b5808a20afded21b9652a5f00a", + "size": 682552, + "subdir": "linux-64", + "timestamp": 1677013223735, + "version": "0.19.0" + }, + "zstandard-0.19.0-py38h5eee18b_0.tar.bz2": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.11", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b3a4956643e78cfe65b59823bbf0c633", + "name": "zstandard", + "sha256": "9e109b0d4fa7072697e7a428ea2eda4208a7c831409113df603011ef65a18844", + "size": 683175, + "subdir": "linux-64", + "timestamp": 1677013289650, + "version": "0.19.0" + }, + "zstandard-0.19.0-py39h5eee18b_0.tar.bz2": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.11", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7c71b30d7d429a390f5c7c413e4419dc", + "name": "zstandard", + "sha256": "2d1be32ceb41d684b13833410dec3bdb0bbce83414067dc1ad33ee2050723bfc", + "size": 686202, + "subdir": "linux-64", + "timestamp": 1677013359201, + "version": "0.19.0" + }, + "zstd-1.3.3-h84994c4_0.tar.bz2": { + "build": "h84994c4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8fd394fad0526da0465637434e03263f", + "name": "zstd", + "sha256": "d1794998ab350b02e744a602aee0049ec0ed11d0a94f719df493cb7214793dce", + "size": 860489, + "subdir": "linux-64", + "timestamp": 1529361748345, + "version": "1.3.3" + }, + "zstd-1.3.7-h0b5b093_0.tar.bz2": { + "build": "h0b5b093_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "79121f98f7c307c15e95e8cba48280d2", + "name": "zstd", + "sha256": "5149968ff75f178e2c291c8900bd92f539110280dc8f5ef54d5993c7e9b961b2", + "size": 908297, + "subdir": "linux-64", + "timestamp": 1541459808645, + "version": "1.3.7" + }, + "zstd-1.4.4-h0b5b093_3.tar.bz2": { + "build": "h0b5b093_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0b1f1e8e98976618516edf05d9e76088", + "name": "zstd", + "sha256": "004fbd0ae2eeb2967bfff71501a302cb75ed065542df52902d1c9cbebd3a5383", + "size": 1029951, + "subdir": "linux-64", + "timestamp": 1587075143434, + "version": "1.4.4" + }, + "zstd-1.4.5-h0b5b093_0.tar.bz2": { + "build": "h0b5b093_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fdf2afb5be1a28b2e46c73d6874dabc1", + "name": "zstd", + "sha256": "11384fafb1c34bebe001d9940fa71a3965e52b8cd9b94883857f9852c8ec9559", + "size": 1028994, + "subdir": "linux-64", + "timestamp": 1593122504152, + "version": "1.4.5" + }, + "zstd-1.4.5-h9ceee32_0.tar.bz2": { + "build": "h9ceee32_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4a44879022464818fe3602e126db8feb", + "name": "zstd", + "sha256": "02732e80aa6212ad9c5cd2f917b9e012c896e01c475989cde7300e0919f5563e", + "size": 733540, + "subdir": "linux-64", + "timestamp": 1595964883124, + "version": "1.4.5" + }, + "zstd-1.4.9-haebb681_0.tar.bz2": { + "build": "haebb681_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "77148a73936c37451810f0b1453569e9", + "name": "zstd", + "sha256": "d1969321874e6d0a7b9994a043830e453a5caab9c3d89690351ba658700ab611", + "size": 828849, + "subdir": "linux-64", + "timestamp": 1617228573594, + "version": "1.4.9" + }, + "zstd-1.5.0-ha4553b6_1.tar.bz2": { + "build": "ha4553b6_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "423776deda168563f71daf4bd3127862", + "name": "zstd", + "sha256": "7ff54720d0b9755603d0755f89686204475cd5a96a0ce41de26104c827c1ed55", + "size": 940485, + "subdir": "linux-64", + "timestamp": 1635437706953, + "version": "1.5.0" + }, + "zstd-1.5.2-ha4553b6_0.tar.bz2": { + "build": "ha4553b6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "BSD-3-Clause AND GPL-2.0-or-later", + "license_family": "BSD", + "md5": "b1737dfd2e06ad69ec5cfec341e207c6", + "name": "zstd", + "sha256": "1c049c23788a00b6f38bdc801245e0e60af98718d4db4c958658bcc67ff158c7", + "size": 827172, + "subdir": "linux-64", + "timestamp": 1650622223170, + "version": "1.5.2" + }, + "zstd-1.5.4-hc292b87_0.tar.bz2": { + "build": "hc292b87_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "lz4-c >=1.9.4,<1.10.0a0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause AND GPL-2.0-or-later", + "license_family": "BSD", + "md5": "0469a8a9f026f846f2d992aa649a5be1", + "name": "zstd", + "sha256": "49715484a1f9c7ec3b5012158fc5cdde87d4ac19b2036ee41b70dcfac49ee540", + "size": 1030040, + "subdir": "linux-64", + "timestamp": 1680034663602, + "version": "1.5.4" + }, + "zstd-static-1.4.5-he6710b0_0.tar.bz2": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zstd 1.4.5 h9ceee32_0" + ], + "license": "BSD 3-Clause", + "md5": "039bbfc86f8be756fa2eefdc84af9885", + "name": "zstd-static", + "sha256": "71096a5e662f214009a1ce13dc6560c4330b2576c255deccb7b0dcdf8872462b", + "size": 324852, + "subdir": "linux-64", + "timestamp": 1595964895392, + "version": "1.4.5" + } + }, + "packages.conda": { + "_anaconda_depends-2018.12-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.os", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "funcsigs", + "functools32", + "future", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "linecache2", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traceback2", + "traitlets", + "typing", + "unicodecsv", + "unittest2", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "c64c38860168c341cee90ff2d615f160", + "name": "_anaconda_depends", + "sha256": "447d60baa9c9aa871ae4af347a1def98a69bdf4cca16d4d4e6bf00ea5c2c88d8", + "size": 6339, + "subdir": "linux-64", + "timestamp": 1562173890182, + "version": "2018.12" + }, + "_anaconda_depends-2018.12-py36h44efdcc_0.conda": { + "build": "py36h44efdcc_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backcall", + "backports", + "backports.os", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "conda", + "conda-build", + "conda-env", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.6.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typed-ast", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "bc834b4bcd4c2989cbd0f945caa23f89", + "name": "_anaconda_depends", + "sha256": "4bef2a6c6207a0fcd8b549f891f11c12e6aaf8235f23debbc1610ae84a958a30", + "size": 6364, + "subdir": "linux-64", + "timestamp": 1562173908400, + "version": "2018.12" + }, + "_anaconda_depends-2018.12-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backcall", + "backports", + "backports.os", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.7.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "89de28d81c5b3452b8e9029d261fe31c", + "name": "_anaconda_depends", + "sha256": "de8e1a61398f6a0663b7dd917fa33d75c0a50addd163fc6306413df1d8c15be3", + "size": 6186, + "subdir": "linux-64", + "timestamp": 1562173919149, + "version": "2018.12" + }, + "_anaconda_depends-2019.03-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.os", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "fontconfig", + "freetype", + "fribidi", + "funcsigs", + "functools32", + "future", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "linecache2", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traceback2", + "traitlets", + "typing", + "unicodecsv", + "unittest2", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "cce894c9e095986ff1a531cb05a813c7", + "name": "_anaconda_depends", + "sha256": "bfb29c4b86cf9f240d06f6da58836b3b72559d27030f3e55814899682675e7f4", + "size": 6323, + "subdir": "linux-64", + "timestamp": 1562173936297, + "version": "2019.03" + }, + "_anaconda_depends-2019.03-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backcall", + "backports", + "backports.os", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "flask", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.6.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typed-ast", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "1dde8da154010fee75b12913da3ba9c5", + "name": "_anaconda_depends", + "sha256": "da48109e987816c12c9bcdf6019be4c7b9283518eaa8e8a14a062f515339177e", + "size": 6184, + "subdir": "linux-64", + "timestamp": 1562173951982, + "version": "2019.03" + }, + "_anaconda_depends-2019.03-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backcall", + "backports", + "backports.os", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.7.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "5664dd32eda6650b70ea7486b434554c", + "name": "_anaconda_depends", + "sha256": "1c1dffb11aea190dbb8a51e70cc254190e8aae2eab7a0b6da69014d20b68b53e", + "size": 6175, + "subdir": "linux-64", + "timestamp": 1562173963130, + "version": "2019.03" + }, + "_anaconda_depends-2019.07-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.os", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "fontconfig", + "freetype", + "fribidi", + "funcsigs", + "functools32", + "future", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "linecache2", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traceback2", + "traitlets", + "typing", + "unicodecsv", + "unittest2", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "8c5ce6786fea08831f77319dbb75ec00", + "name": "_anaconda_depends", + "sha256": "3c445bbb8e19ac52de731a89e5826c4d093f8ae5416e6debae9d5f3a3942d790", + "size": 6143, + "subdir": "linux-64", + "timestamp": 1587065885251, + "version": "2019.07" + }, + "_anaconda_depends-2019.07-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backcall", + "backports", + "backports.os", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.6.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typed-ast", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "294af4a0251872912d6dc3354cfc1883", + "name": "_anaconda_depends", + "sha256": "5db5f355b9266ab4421d3741f870e7160ef8d4b4c792adf09dc5dee00e516492", + "size": 6223, + "subdir": "linux-64", + "timestamp": 1587065921282, + "version": "2019.07" + }, + "_anaconda_depends-2019.07-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backcall", + "backports", + "backports.os", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.7.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "b03af7cd9538da10c063c051f05dde77", + "name": "_anaconda_depends", + "sha256": "b2d158392256c82d684eaccba620c12d168dd30c6a3c26ff8b847335b4645f63", + "size": 6202, + "subdir": "linux-64", + "timestamp": 1587065951532, + "version": "2019.07" + }, + "_anaconda_depends-2019.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.os", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "fontconfig", + "freetype", + "fribidi", + "funcsigs", + "functools32", + "future", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "linecache2", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "ripgrep", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tbb", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traceback2", + "traitlets", + "typing", + "unicodecsv", + "unittest2", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "799ff1102725b6715bdf70bcfd520123", + "name": "_anaconda_depends", + "sha256": "618b34c7384e29a0806d0a5e0b41f66a7baff46e2f5edb48febaf88f57b0ef96", + "size": 6161, + "subdir": "linux-64", + "timestamp": 1587065992450, + "version": "2019.10" + }, + "_anaconda_depends-2019.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backcall", + "backports", + "backports.os", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "fontconfig", + "freetype", + "fribidi", + "fsspec", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.6.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "ripgrep", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typed-ast", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "2bc43389ae2ff0eec36df1b6987d0fec", + "name": "_anaconda_depends", + "sha256": "d96156aa1d62143a777704fb5229160f8a57142e61a5ac38a5f93a35c4f6250e", + "size": 6253, + "subdir": "linux-64", + "timestamp": 1587066029397, + "version": "2019.10" + }, + "_anaconda_depends-2019.10-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "babel", + "backcall", + "backports", + "backports.os", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "fontconfig", + "freetype", + "fribidi", + "fsspec", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.7.*", + "python-dateutil", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "ripgrep", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "8dcf0e1dd7b3078abe6824a7e302ab54", + "name": "_anaconda_depends", + "sha256": "46dbaed876cc24f6c3c3e4e6439598a448612fd77a5e7d0da9025c766c4a5d0a", + "size": 6171, + "subdir": "linux-64", + "timestamp": 1587066059915, + "version": "2019.10" + }, + "_anaconda_depends-2020.02-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "argh", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "autopep8", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flake8", + "flask", + "fontconfig", + "freetype", + "fribidi", + "fsspec", + "future", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hypothesis", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "ld_impl_linux-64", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "matplotlib-base", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path", + "path.py", + "pathlib2", + "pathtools", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pydocstyle", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-astropy-header", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.6.*", + "python-dateutil", + "python-jsonrpc-server", + "python-language-server", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "ripgrep", + "rope", + "rtree", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typed-ast", + "ujson", + "unicodecsv", + "unixodbc", + "urllib3", + "watchdog", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "yapf", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "2addd69414a049f2efd8a0e44a4c39b8", + "name": "_anaconda_depends", + "sha256": "f6c37f48d221e36e678e397648f65b2724dbaecc3a03a29ee90477c801862105", + "size": 6518, + "subdir": "linux-64", + "timestamp": 1587066097370, + "version": "2020.02" + }, + "_anaconda_depends-2020.02-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "argh", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "autopep8", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flake8", + "flask", + "fontconfig", + "freetype", + "fribidi", + "fsspec", + "future", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hypothesis", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "ld_impl_linux-64", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libpng", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "matplotlib-base", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path", + "path.py", + "pathlib2", + "pathtools", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pydocstyle", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-astropy-header", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.7.*", + "python-dateutil", + "python-jsonrpc-server", + "python-language-server", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "ripgrep", + "rope", + "rtree", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "ujson", + "unicodecsv", + "unixodbc", + "urllib3", + "watchdog", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "yapf", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "81ef914a7bdac3d1e8bc9f965d8c787b", + "name": "_anaconda_depends", + "sha256": "fcd3cb40e232186413696443ff1739a0ae09e18c34ad155cf6df337d69166e7d", + "size": 6504, + "subdir": "linux-64", + "timestamp": 1587066130431, + "version": "2020.02" + }, + "_anaconda_depends-2020.02-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "argh", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "autopep8", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flake8", + "flask", + "fontconfig", + "freetype", + "fribidi", + "fsspec", + "future", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hypothesis", + "icu", + "idna", + "imageio", + "imagesize", + "importlib_metadata", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "ld_impl_linux-64", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "matplotlib-base", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path", + "path.py", + "pathlib2", + "pathtools", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycurl", + "pydocstyle", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-astropy-header", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.8.*", + "python-dateutil", + "python-jsonrpc-server", + "python-language-server", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "ripgrep", + "rope", + "rtree", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "ujson", + "unicodecsv", + "unixodbc", + "urllib3", + "watchdog", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "yapf", + "zeromq", + "zict", + "zipp", + "zlib", + "zstd" + ], + "license": "BSD", + "md5": "1c4f1174886ff80537816f57c5881260", + "name": "_anaconda_depends", + "sha256": "3b2bdb0245dc5257b9205521f96e0f581b34c0e8cb2bdf41991fae46449e6010", + "size": 6478, + "subdir": "linux-64", + "timestamp": 1587066147200, + "version": "2020.02" + }, + "_anaconda_depends-2020.07-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "argh", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "autopep8", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "brotlipy", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "contextvars", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flake8", + "flask", + "fontconfig", + "freetype", + "fribidi", + "fsspec", + "future", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "immutables", + "importlib-metadata", + "importlib_metadata", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "lcms2", + "ld_impl_linux-64", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libllvm9", + "libpng", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "matplotlib-base", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path", + "path.py", + "pathlib2", + "pathtools", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt-toolkit", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pydocstyle", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 3.6.*", + "python-dateutil", + "python-jsonrpc-server", + "python-language-server", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "regex", + "requests", + "ripgrep", + "rope", + "rtree", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tblib", + "terminado", + "testpath", + "threadpoolctl", + "tk", + "toml", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typed-ast", + "typing_extensions", + "ujson", + "unicodecsv", + "unixodbc", + "urllib3", + "watchdog", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "yapf", + "zeromq", + "zict", + "zipp", + "zlib", + "zope", + "zope.event", + "zope.interface", + "zstd" + ], + "license": "BSD", + "md5": "9556c505376d39ad119bb44ab9c2d3cc", + "name": "_anaconda_depends", + "sha256": "3e01be04c88c11763af5fba77615b006c63089979ccac3812b0384f31165e663", + "size": 6508, + "subdir": "linux-64", + "timestamp": 1595561605727, + "version": "2020.07" + }, + "_anaconda_depends-2020.07-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "argh", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "autopep8", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "brotlipy", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flake8", + "flask", + "fontconfig", + "freetype", + "fribidi", + "fsspec", + "future", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib-metadata", + "importlib_metadata", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "lcms2", + "ld_impl_linux-64", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libllvm9", + "libpng", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "matplotlib-base", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path", + "path.py", + "pathlib2", + "pathtools", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt-toolkit", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pydocstyle", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 3.7.*", + "python-dateutil", + "python-jsonrpc-server", + "python-language-server", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "regex", + "requests", + "ripgrep", + "rope", + "rtree", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tblib", + "terminado", + "testpath", + "threadpoolctl", + "tk", + "toml", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typed-ast", + "typing_extensions", + "ujson", + "unicodecsv", + "unixodbc", + "urllib3", + "watchdog", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "yapf", + "zeromq", + "zict", + "zipp", + "zlib", + "zope", + "zope.event", + "zope.interface", + "zstd" + ], + "license": "BSD", + "md5": "c550557b1e681a6ced99c3cfee4506c4", + "name": "_anaconda_depends", + "sha256": "95da18092088adca93cf3bb5bdb43d5fb20118fef8eba68a412fa8bca419c43a", + "size": 6472, + "subdir": "linux-64", + "timestamp": 1595561753272, + "version": "2020.07" + }, + "_anaconda_depends-2020.07-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "argh", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "autopep8", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "brotlipy", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "dbus", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flake8", + "flask", + "fontconfig", + "freetype", + "fribidi", + "fsspec", + "future", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "importlib-metadata", + "importlib_metadata", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_server", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "lcms2", + "ld_impl_linux-64", + "libarchive", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "liblief", + "libllvm9", + "libpng", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "matplotlib-base", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path", + "path.py", + "pathlib2", + "pathtools", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt-toolkit", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycurl", + "pydocstyle", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 3.8.*", + "python-dateutil", + "python-jsonrpc-server", + "python-language-server", + "python-libarchive-c", + "pytz", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "regex", + "requests", + "ripgrep", + "rope", + "rtree", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tblib", + "terminado", + "testpath", + "threadpoolctl", + "tk", + "toml", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typing_extensions", + "ujson", + "unicodecsv", + "unixodbc", + "urllib3", + "watchdog", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "yapf", + "zeromq", + "zict", + "zipp", + "zlib", + "zope", + "zope.event", + "zope.interface", + "zstd" + ], + "license": "BSD", + "md5": "8ec7be1cdabd60b11a7b03cb58a1b5fe", + "name": "_anaconda_depends", + "sha256": "c9325a6f43c4bc22dbf71ed4f72052c24b75a3744d6ba7df675bdc109d7a32f9", + "size": 6471, + "subdir": "linux-64", + "timestamp": 1595561529079, + "version": "2020.07" + }, + "_anaconda_depends-2021.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "_openmp_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "anyio", + "appdirs", + "argcomplete", + "argh", + "argon2-cffi", + "arrow", + "asn1crypto", + "astroid", + "astropy", + "async_generator", + "atomicwrites", + "attrs", + "autopep8", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "binaryornot", + "bitarray", + "bkcharts", + "black", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "brotli", + "brotlipy", + "brunsli", + "bzip2", + "c-ares", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "cfitsio", + "chardet", + "charls", + "charset-normalizer", + "click", + "cloudpickle", + "clyent", + "colorama", + "conda-content-trust", + "conda-token", + "contextlib2", + "cookiecutter", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "daal4py", + "dal", + "dask", + "dask-core", + "dataclasses", + "dbus", + "debugpy", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flake8", + "flask", + "fontconfig", + "fonttools", + "freetype", + "fribidi", + "fsspec", + "get_terminal_size", + "gevent", + "giflib", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imagecodecs", + "imageio", + "imagesize", + "importlib-metadata", + "importlib_metadata", + "inflection", + "iniconfig", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jinja2-time", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyter_server", + "jupyterlab", + "jupyterlab_pygments", + "jupyterlab_server", + "jupyterlab_widgets", + "jxrlib", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "lcms2", + "ld_impl_linux-64", + "lerc", + "libaec", + "libarchive", + "libcurl", + "libdeflate", + "libedit", + "libev", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libgfortran4", + "libgomp", + "liblief", + "libllvm11", + "libnghttp2", + "libpng", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libuv", + "libwebp", + "libwebp-base", + "libxcb", + "libxml2", + "libxslt", + "libzopfli", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "matplotlib-base", + "matplotlib-inline", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpi", + "mpich", + "mpmath", + "msgpack-python", + "multipledispatch", + "munkres", + "mypy_extensions", + "nbclassic", + "nbclient", + "nbconvert", + "nbformat", + "ncurses", + "nest-asyncio", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openjpeg", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path", + "path.py", + "pathlib2", + "pathspec", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "poyo", + "prometheus_client", + "prompt-toolkit", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pydocstyle", + "pyerfa", + "pyflakes", + "pygments", + "pylint", + "pyls-spyder", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 3.7.*", + "python-dateutil", + "python-libarchive-c", + "python-lsp-black", + "python-lsp-jsonrpc", + "python-lsp-server", + "python-slugify", + "pytz", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qstylizer", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "regex", + "requests", + "ripgrep", + "rope", + "rtree", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "sniffio", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tbb4py", + "tblib", + "terminado", + "testpath", + "text-unidecode", + "textdistance", + "threadpoolctl", + "three-merge", + "tifffile", + "tinycss", + "tk", + "toml", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typed-ast", + "typing-extensions", + "typing_extensions", + "ujson", + "unicodecsv", + "unidecode", + "unixodbc", + "urllib3", + "watchdog", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "whichcraft", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "yapf", + "zeromq", + "zfp", + "zict", + "zipp", + "zlib", + "zope", + "zope.event", + "zope.interface", + "zstd" + ], + "license": "BSD", + "md5": "310f6da5de7440a0fc04f6814ce39f6e", + "name": "_anaconda_depends", + "sha256": "ad19508482d5429bb547001ac44f053678e306fe6af314fc5accb93b243b2983", + "size": 6904, + "subdir": "linux-64", + "timestamp": 1636994981070, + "version": "2021.11" + }, + "_anaconda_depends-2021.11-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "_openmp_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "anyio", + "appdirs", + "argh", + "argon2-cffi", + "arrow", + "asn1crypto", + "astroid", + "astropy", + "async_generator", + "atomicwrites", + "attrs", + "autopep8", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "binaryornot", + "bitarray", + "bkcharts", + "black", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "brotli", + "brotlipy", + "brunsli", + "bzip2", + "c-ares", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "cfitsio", + "chardet", + "charls", + "charset-normalizer", + "click", + "cloudpickle", + "clyent", + "colorama", + "conda-content-trust", + "conda-token", + "contextlib2", + "cookiecutter", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "daal4py", + "dal", + "dask", + "dask-core", + "dataclasses", + "dbus", + "debugpy", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flake8", + "flask", + "fontconfig", + "fonttools", + "freetype", + "fribidi", + "fsspec", + "get_terminal_size", + "gevent", + "giflib", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imagecodecs", + "imageio", + "imagesize", + "importlib-metadata", + "importlib_metadata", + "inflection", + "iniconfig", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jinja2-time", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyter_server", + "jupyterlab", + "jupyterlab_pygments", + "jupyterlab_server", + "jupyterlab_widgets", + "jxrlib", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "lcms2", + "ld_impl_linux-64", + "lerc", + "libaec", + "libarchive", + "libcurl", + "libdeflate", + "libedit", + "libev", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libgfortran4", + "libgomp", + "liblief", + "libllvm11", + "libnghttp2", + "libpng", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libuv", + "libwebp", + "libwebp-base", + "libxcb", + "libxml2", + "libxslt", + "libzopfli", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "matplotlib-base", + "matplotlib-inline", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpi", + "mpich", + "mpmath", + "msgpack-python", + "multipledispatch", + "munkres", + "mypy_extensions", + "nbclassic", + "nbclient", + "nbconvert", + "nbformat", + "ncurses", + "nest-asyncio", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openjpeg", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path", + "path.py", + "pathlib2", + "pathspec", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "poyo", + "prometheus_client", + "prompt-toolkit", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycurl", + "pydocstyle", + "pyerfa", + "pyflakes", + "pygments", + "pylint", + "pyls-spyder", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 3.8.*", + "python-dateutil", + "python-libarchive-c", + "python-lsp-black", + "python-lsp-jsonrpc", + "python-lsp-server", + "python-slugify", + "pytz", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qstylizer", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "regex", + "requests", + "ripgrep", + "rope", + "rtree", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "sniffio", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tbb4py", + "tblib", + "terminado", + "testpath", + "text-unidecode", + "textdistance", + "threadpoolctl", + "three-merge", + "tifffile", + "tinycss", + "tk", + "toml", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typed-ast", + "typing_extensions", + "ujson", + "unicodecsv", + "unidecode", + "unixodbc", + "urllib3", + "watchdog", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "whichcraft", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "yapf", + "zeromq", + "zfp", + "zict", + "zipp", + "zlib", + "zope", + "zope.event", + "zope.interface", + "zstd" + ], + "license": "BSD", + "md5": "639fea8f0bb90e5762e88245d928c298", + "name": "_anaconda_depends", + "sha256": "25df7c547e76c94e0808dfc4d39f7355d0ba7db605beebc1a5bdc89dfc6b3580", + "size": 6877, + "subdir": "linux-64", + "timestamp": 1636994991327, + "version": "2021.11" + }, + "_anaconda_depends-2021.11-py39_0.conda": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "_openmp_mutex", + "alabaster", + "anaconda-client", + "anaconda-project", + "anyio", + "appdirs", + "argh", + "argon2-cffi", + "arrow", + "asn1crypto", + "astroid", + "astropy", + "async_generator", + "atomicwrites", + "attrs", + "autopep8", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "binaryornot", + "bitarray", + "bkcharts", + "black", + "blas", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "brotli", + "brotlipy", + "brunsli", + "bzip2", + "c-ares", + "ca-certificates", + "cached-property", + "cairo", + "certifi", + "cffi", + "cfitsio", + "chardet", + "charls", + "charset-normalizer", + "click", + "cloudpickle", + "clyent", + "colorama", + "conda-content-trust", + "conda-token", + "contextlib2", + "cookiecutter", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "daal4py", + "dal", + "dask", + "dask-core", + "dataclasses", + "dbus", + "debugpy", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flake8", + "flask", + "fontconfig", + "fonttools", + "freetype", + "fribidi", + "fsspec", + "get_terminal_size", + "gevent", + "giflib", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imagecodecs", + "imageio", + "imagesize", + "importlib-metadata", + "importlib_metadata", + "inflection", + "iniconfig", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jinja2-time", + "joblib", + "jpeg", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyter_server", + "jupyterlab", + "jupyterlab_pygments", + "jupyterlab_server", + "jupyterlab_widgets", + "jxrlib", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "lcms2", + "ld_impl_linux-64", + "lerc", + "libaec", + "libarchive", + "libcurl", + "libdeflate", + "libedit", + "libev", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libgfortran4", + "libgomp", + "liblief", + "libllvm11", + "libnghttp2", + "libpng", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libuv", + "libwebp", + "libwebp-base", + "libxcb", + "libxml2", + "libxslt", + "libzopfli", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markupsafe", + "matplotlib", + "matplotlib-base", + "matplotlib-inline", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "more-itertools", + "mpc", + "mpfr", + "mpi", + "mpich", + "mpmath", + "msgpack-python", + "multipledispatch", + "munkres", + "mypy_extensions", + "nbclassic", + "nbclient", + "nbconvert", + "nbformat", + "ncurses", + "nest-asyncio", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "openjpeg", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path", + "path.py", + "pathlib2", + "pathspec", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "poyo", + "prometheus_client", + "prompt-toolkit", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pycodestyle", + "pycosat", + "pycparser", + "pycurl", + "pydocstyle", + "pyerfa", + "pyflakes", + "pygments", + "pylint", + "pyls-spyder", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 3.9.*", + "python-dateutil", + "python-libarchive-c", + "python-lsp-black", + "python-lsp-jsonrpc", + "python-lsp-server", + "python-slugify", + "pytz", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qstylizer", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "regex", + "requests", + "ripgrep", + "rope", + "rtree", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "sniffio", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tbb", + "tbb4py", + "tblib", + "terminado", + "testpath", + "text-unidecode", + "textdistance", + "threadpoolctl", + "three-merge", + "tifffile", + "tinycss", + "tk", + "toml", + "toolz", + "tornado", + "tqdm", + "traitlets", + "typed-ast", + "typing_extensions", + "tzdata", + "ujson", + "unicodecsv", + "unidecode", + "unixodbc", + "urllib3", + "watchdog", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "whichcraft", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "yapf", + "zeromq", + "zfp", + "zict", + "zipp", + "zlib", + "zope", + "zope.event", + "zope.interface", + "zstd" + ], + "license": "BSD", + "md5": "4baa38cc7057417653e3bc6e6e8c3989", + "name": "_anaconda_depends", + "sha256": "22d3047184457e6f881cf0e49bf2b0c51d20bd0358bbca6ce9a1706daa05fb22", + "size": 6900, + "subdir": "linux-64", + "timestamp": 1636994998469, + "version": "2021.11" + }, + "_anaconda_depends-2022.05-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "_openmp_mutex", + "aiohttp", + "aiosignal", + "alabaster", + "anaconda-client", + "anaconda-project", + "anyio", + "appdirs", + "argon2-cffi", + "argon2-cffi-bindings", + "arrow", + "astroid", + "astropy", + "async-timeout", + "asynctest", + "atomicwrites", + "attrs", + "automat", + "autopep8", + "babel", + "backcall", + "backports", + "backports.functools_lru_cache", + "backports.tempfile", + "backports.weakref", + "bcrypt", + "beautifulsoup4", + "binaryornot", + "bitarray", + "bkcharts", + "black", + "blas", + "bleach", + "blosc", + "bokeh", + "boto3", + "botocore", + "bottleneck", + "brotli", + "brotlipy", + "brunsli", + "bzip2", + "c-ares", + "ca-certificates", + "cachetools", + "certifi", + "cffi", + "cfitsio", + "chardet", + "charls", + "charset-normalizer", + "click", + "cloudpickle", + "clyent", + "colorama", + "colorcet", + "conda-content-trust", + "conda-token", + "constantly", + "cookiecutter", + "cryptography", + "cssselect", + "curl", + "cycler", + "cython", + "cytoolz", + "daal4py", + "dal", + "dask", + "dask-core", + "dataclasses", + "datashader", + "datashape", + "dbus", + "debugpy", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "filelock", + "flake8", + "flask", + "fontconfig", + "fonttools", + "freetype", + "frozenlist", + "fsspec", + "future", + "gensim", + "giflib", + "glib", + "glob2", + "gmp", + "gmpy2", + "google-api-core", + "google-auth", + "google-cloud-core", + "google-cloud-storage", + "google-crc32c", + "google-resumable-media", + "googleapis-common-protos", + "greenlet", + "grpcio", + "gst-plugins-base", + "gstreamer", + "h5py", + "hdf5", + "heapdict", + "holoviews", + "hvplot", + "hyperlink", + "icu", + "idna", + "imagecodecs", + "imageio", + "imagesize", + "importlib-metadata", + "importlib_metadata", + "importlib_resources", + "incremental", + "inflection", + "iniconfig", + "intake", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itemadapter", + "itemloaders", + "itsdangerous", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jinja2-time", + "jmespath", + "joblib", + "jpeg", + "jq", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyter_server", + "jupyterlab", + "jupyterlab_pygments", + "jupyterlab_server", + "jupyterlab_widgets", + "jxrlib", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "lcms2", + "ld_impl_linux-64", + "lerc", + "libaec", + "libarchive", + "libcrc32c", + "libcurl", + "libdeflate", + "libedit", + "libev", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libgfortran4", + "libgomp", + "libidn2", + "liblief", + "libllvm11", + "libnghttp2", + "libpng", + "libprotobuf", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libunistring", + "libuuid", + "libwebp", + "libwebp-base", + "libxcb", + "libxml2", + "libxslt", + "libzopfli", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markdown", + "markupsafe", + "matplotlib", + "matplotlib-base", + "matplotlib-inline", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "mpc", + "mpfr", + "mpi", + "mpich", + "mpmath", + "msgpack-python", + "multidict", + "multipledispatch", + "munkres", + "mypy_extensions", + "nbclassic", + "nbclient", + "nbconvert", + "nbformat", + "ncurses", + "nest-asyncio", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "oniguruma", + "openjpeg", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "panel", + "param", + "parsel", + "parso", + "partd", + "patchelf", + "pathspec", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pkginfo", + "plotly", + "pluggy", + "poyo", + "prometheus_client", + "prompt-toolkit", + "prompt_toolkit", + "protego", + "protobuf", + "psutil", + "ptyprocess", + "py", + "py-lief", + "pyasn1", + "pyasn1-modules", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pyct", + "pycurl", + "pydispatcher", + "pydocstyle", + "pyerfa", + "pyflakes", + "pygments", + "pyhamcrest", + "pylint", + "pyls-spyder", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 3.7.*", + "python-dateutil", + "python-fastjsonschema", + "python-libarchive-c", + "python-lsp-black", + "python-lsp-jsonrpc", + "python-lsp-server", + "python-slugify", + "python-snappy", + "pytz", + "pyviz_comms", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qstylizer", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "queuelib", + "readline", + "regex", + "requests", + "requests-file", + "ripgrep", + "rope", + "rsa", + "rtree", + "ruamel_yaml", + "s3transfer", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "secretstorage", + "send2trash", + "service_identity", + "setuptools", + "sip", + "six", + "smart_open", + "snappy", + "sniffio", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tabulate", + "tbb", + "tbb4py", + "tblib", + "tenacity", + "terminado", + "testpath", + "text-unidecode", + "textdistance", + "threadpoolctl", + "three-merge", + "tifffile", + "tinycss", + "tk", + "tldextract", + "toml", + "tomli", + "toolz", + "tornado", + "tqdm", + "traitlets", + "twisted", + "typed-ast", + "typing-extensions", + "typing_extensions", + "ujson", + "unidecode", + "unixodbc", + "urllib3", + "w3lib", + "watchdog", + "wcwidth", + "webencodings", + "websocket-client", + "werkzeug", + "wget", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xarray", + "xlrd", + "xlsxwriter", + "xz", + "yaml", + "yapf", + "yarl", + "zeromq", + "zfp", + "zict", + "zipp", + "zlib", + "zope", + "zope.interface", + "zstd" + ], + "license": "BSD", + "md5": "e0837427f8f77f43037a79de62b19887", + "name": "_anaconda_depends", + "sha256": "fbd7e5f28e6f4a0777dbb66973355082fa67e30c45732b90df916e0994c22615", + "size": 7483, + "subdir": "linux-64", + "timestamp": 1651788387896, + "version": "2022.05" + }, + "_anaconda_depends-2022.05-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "_openmp_mutex", + "aiohttp", + "aiosignal", + "alabaster", + "anaconda-client", + "anaconda-project", + "anyio", + "appdirs", + "argon2-cffi", + "argon2-cffi-bindings", + "arrow", + "astroid", + "astropy", + "asttokens", + "async-timeout", + "atomicwrites", + "attrs", + "automat", + "autopep8", + "babel", + "backcall", + "backports", + "backports.functools_lru_cache", + "backports.tempfile", + "backports.weakref", + "bcrypt", + "beautifulsoup4", + "binaryornot", + "bitarray", + "bkcharts", + "black", + "blas", + "bleach", + "blosc", + "bokeh", + "boto3", + "botocore", + "bottleneck", + "brotli", + "brotlipy", + "brunsli", + "bzip2", + "c-ares", + "ca-certificates", + "cachetools", + "certifi", + "cffi", + "cfitsio", + "chardet", + "charls", + "charset-normalizer", + "click", + "cloudpickle", + "clyent", + "colorama", + "colorcet", + "conda-content-trust", + "conda-token", + "constantly", + "cookiecutter", + "cryptography", + "cssselect", + "curl", + "cycler", + "cython", + "cytoolz", + "daal4py", + "dal", + "dask", + "dask-core", + "dataclasses", + "datashader", + "datashape", + "dbus", + "debugpy", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "executing", + "expat", + "filelock", + "flake8", + "flask", + "fontconfig", + "fonttools", + "freetype", + "frozenlist", + "fsspec", + "future", + "gensim", + "giflib", + "glib", + "glob2", + "gmp", + "gmpy2", + "google-api-core", + "google-auth", + "google-cloud-core", + "google-cloud-storage", + "google-crc32c", + "google-resumable-media", + "googleapis-common-protos", + "greenlet", + "grpcio", + "gst-plugins-base", + "gstreamer", + "h5py", + "hdf5", + "heapdict", + "holoviews", + "hvplot", + "hyperlink", + "icu", + "idna", + "imagecodecs", + "imageio", + "imagesize", + "importlib-metadata", + "importlib_metadata", + "importlib_resources", + "incremental", + "inflection", + "iniconfig", + "intake", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itemadapter", + "itemloaders", + "itsdangerous", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jinja2-time", + "jmespath", + "joblib", + "jpeg", + "jq", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyter_server", + "jupyterlab", + "jupyterlab_pygments", + "jupyterlab_server", + "jupyterlab_widgets", + "jxrlib", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "lcms2", + "ld_impl_linux-64", + "lerc", + "libaec", + "libarchive", + "libcrc32c", + "libcurl", + "libdeflate", + "libedit", + "libev", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libgfortran4", + "libgomp", + "libidn2", + "liblief", + "libllvm11", + "libnghttp2", + "libpng", + "libprotobuf", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libunistring", + "libuuid", + "libwebp", + "libwebp-base", + "libxcb", + "libxml2", + "libxslt", + "libzopfli", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markdown", + "markupsafe", + "matplotlib", + "matplotlib-base", + "matplotlib-inline", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "mpc", + "mpfr", + "mpi", + "mpich", + "mpmath", + "msgpack-python", + "multidict", + "multipledispatch", + "munkres", + "mypy_extensions", + "nbclassic", + "nbclient", + "nbconvert", + "nbformat", + "ncurses", + "nest-asyncio", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "oniguruma", + "openjpeg", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "panel", + "param", + "parsel", + "parso", + "partd", + "patchelf", + "pathspec", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pkginfo", + "plotly", + "pluggy", + "poyo", + "prometheus_client", + "prompt-toolkit", + "prompt_toolkit", + "protego", + "protobuf", + "psutil", + "ptyprocess", + "pure_eval", + "py", + "py-lief", + "pyasn1", + "pyasn1-modules", + "pycodestyle", + "pycosat", + "pycparser", + "pyct", + "pycurl", + "pydispatcher", + "pydocstyle", + "pyerfa", + "pyflakes", + "pygments", + "pyhamcrest", + "pylint", + "pyls-spyder", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 3.8.*", + "python-dateutil", + "python-fastjsonschema", + "python-libarchive-c", + "python-lsp-black", + "python-lsp-jsonrpc", + "python-lsp-server", + "python-slugify", + "python-snappy", + "pytz", + "pyviz_comms", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qstylizer", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "queuelib", + "readline", + "regex", + "requests", + "requests-file", + "ripgrep", + "rope", + "rsa", + "rtree", + "ruamel_yaml", + "s3transfer", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "secretstorage", + "send2trash", + "service_identity", + "setuptools", + "sip", + "six", + "smart_open", + "snappy", + "sniffio", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "stack_data", + "statsmodels", + "sympy", + "tabulate", + "tbb", + "tbb4py", + "tblib", + "tenacity", + "terminado", + "testpath", + "text-unidecode", + "textdistance", + "threadpoolctl", + "three-merge", + "tifffile", + "tinycss", + "tk", + "tldextract", + "toml", + "tomli", + "toolz", + "tornado", + "tqdm", + "traitlets", + "twisted", + "typed-ast", + "typing-extensions", + "typing_extensions", + "ujson", + "unidecode", + "unixodbc", + "urllib3", + "w3lib", + "watchdog", + "wcwidth", + "webencodings", + "websocket-client", + "werkzeug", + "wget", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xarray", + "xlrd", + "xlsxwriter", + "xz", + "yaml", + "yapf", + "yarl", + "zeromq", + "zfp", + "zict", + "zipp", + "zlib", + "zope", + "zope.interface", + "zstd" + ], + "license": "BSD", + "md5": "e98e2a48b8f29414b3c9baaf50505189", + "name": "_anaconda_depends", + "sha256": "ee4ff6bd340a26d9e1dc08987e59a0f0740201333eba49d83701c6740c91b90f", + "size": 7523, + "subdir": "linux-64", + "timestamp": 1651788399085, + "version": "2022.05" + }, + "_anaconda_depends-2022.05-py39_0.conda": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex", + "_openmp_mutex", + "aiohttp", + "aiosignal", + "alabaster", + "anaconda-client", + "anaconda-project", + "anyio", + "appdirs", + "argon2-cffi", + "argon2-cffi-bindings", + "arrow", + "astroid", + "astropy", + "asttokens", + "async-timeout", + "atomicwrites", + "attrs", + "automat", + "autopep8", + "babel", + "backcall", + "backports", + "backports.functools_lru_cache", + "backports.tempfile", + "backports.weakref", + "bcrypt", + "beautifulsoup4", + "binaryornot", + "bitarray", + "bkcharts", + "black", + "blas", + "bleach", + "blosc", + "bokeh", + "boto3", + "botocore", + "bottleneck", + "brotli", + "brotlipy", + "brunsli", + "bzip2", + "c-ares", + "ca-certificates", + "cachetools", + "certifi", + "cffi", + "cfitsio", + "chardet", + "charls", + "charset-normalizer", + "click", + "cloudpickle", + "clyent", + "colorama", + "colorcet", + "conda-content-trust", + "conda-token", + "constantly", + "cookiecutter", + "cryptography", + "cssselect", + "curl", + "cycler", + "cython", + "cytoolz", + "daal4py", + "dal", + "dask", + "dask-core", + "dataclasses", + "datashader", + "datashape", + "dbus", + "debugpy", + "decorator", + "defusedxml", + "diff-match-patch", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "executing", + "expat", + "filelock", + "flake8", + "flask", + "fontconfig", + "fonttools", + "freetype", + "frozenlist", + "fsspec", + "future", + "gensim", + "giflib", + "glib", + "glob2", + "gmp", + "gmpy2", + "google-api-core", + "google-auth", + "google-cloud-core", + "google-cloud-storage", + "google-crc32c", + "google-resumable-media", + "googleapis-common-protos", + "greenlet", + "grpcio", + "gst-plugins-base", + "gstreamer", + "h5py", + "hdf5", + "heapdict", + "holoviews", + "hvplot", + "hyperlink", + "icu", + "idna", + "imagecodecs", + "imageio", + "imagesize", + "importlib-metadata", + "importlib_metadata", + "incremental", + "inflection", + "iniconfig", + "intake", + "intel-openmp", + "intervaltree", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itemadapter", + "itemloaders", + "itsdangerous", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jinja2-time", + "jmespath", + "joblib", + "jpeg", + "jq", + "json5", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyter_server", + "jupyterlab", + "jupyterlab_pygments", + "jupyterlab_server", + "jupyterlab_widgets", + "jxrlib", + "keyring", + "kiwisolver", + "krb5", + "lazy-object-proxy", + "lcms2", + "ld_impl_linux-64", + "lerc", + "libaec", + "libarchive", + "libcrc32c", + "libcurl", + "libdeflate", + "libedit", + "libev", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libgfortran4", + "libgomp", + "libidn2", + "liblief", + "libllvm11", + "libnghttp2", + "libpng", + "libprotobuf", + "libsodium", + "libspatialindex", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libunistring", + "libuuid", + "libwebp", + "libwebp-base", + "libxcb", + "libxml2", + "libxslt", + "libzopfli", + "llvmlite", + "locket", + "lxml", + "lz4-c", + "lzo", + "markdown", + "markupsafe", + "matplotlib", + "matplotlib-base", + "matplotlib-inline", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "mock", + "mpc", + "mpfr", + "mpi", + "mpich", + "mpmath", + "msgpack-python", + "multidict", + "multipledispatch", + "munkres", + "mypy_extensions", + "nbclassic", + "nbclient", + "nbconvert", + "nbformat", + "ncurses", + "nest-asyncio", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "olefile", + "oniguruma", + "openjpeg", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "panel", + "param", + "parsel", + "parso", + "partd", + "patchelf", + "pathspec", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pkginfo", + "plotly", + "pluggy", + "poyo", + "prometheus_client", + "prompt-toolkit", + "prompt_toolkit", + "protego", + "protobuf", + "psutil", + "ptyprocess", + "pure_eval", + "py", + "py-lief", + "pyasn1", + "pyasn1-modules", + "pycodestyle", + "pycosat", + "pycparser", + "pyct", + "pycurl", + "pydispatcher", + "pydocstyle", + "pyerfa", + "pyflakes", + "pygments", + "pyhamcrest", + "pylint", + "pyls-spyder", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pyrsistent", + "pysocks", + "pytables", + "pytest", + "python 3.9.*", + "python-dateutil", + "python-fastjsonschema", + "python-libarchive-c", + "python-lsp-black", + "python-lsp-jsonrpc", + "python-lsp-server", + "python-slugify", + "python-snappy", + "pytz", + "pyviz_comms", + "pywavelets", + "pyxdg", + "pyyaml", + "pyzmq", + "qdarkstyle", + "qstylizer", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "queuelib", + "readline", + "regex", + "requests", + "requests-file", + "ripgrep", + "rope", + "rsa", + "rtree", + "ruamel_yaml", + "s3transfer", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "secretstorage", + "send2trash", + "service_identity", + "setuptools", + "sip", + "six", + "smart_open", + "snappy", + "sniffio", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "soupsieve", + "sphinx", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "stack_data", + "statsmodels", + "sympy", + "tabulate", + "tbb", + "tbb4py", + "tblib", + "tenacity", + "terminado", + "testpath", + "text-unidecode", + "textdistance", + "threadpoolctl", + "three-merge", + "tifffile", + "tinycss", + "tk", + "tldextract", + "toml", + "tomli", + "toolz", + "tornado", + "tqdm", + "traitlets", + "twisted", + "typed-ast", + "typing-extensions", + "typing_extensions", + "tzdata", + "ujson", + "unidecode", + "unixodbc", + "urllib3", + "w3lib", + "watchdog", + "wcwidth", + "webencodings", + "websocket-client", + "werkzeug", + "wget", + "wheel", + "widgetsnbextension", + "wrapt", + "wurlitzer", + "xarray", + "xlrd", + "xlsxwriter", + "xz", + "yaml", + "yapf", + "yarl", + "zeromq", + "zfp", + "zict", + "zipp", + "zlib", + "zope", + "zope.interface", + "zstd" + ], + "license": "BSD", + "md5": "9148edf2aa1770eb1a159883275f3f49", + "name": "_anaconda_depends", + "sha256": "b5fedfe1e0305f3ef382ddf157d62c159e5d163eba24ec7cf33fead8cc853888", + "size": 7521, + "subdir": "linux-64", + "timestamp": 1651788407958, + "version": "2022.05" + }, + "_anaconda_depends-2022.10-py310_2.conda": { + "build": "py310_2", + "build_number": 2, + "depends": [ + "alabaster", + "astroid", + "astropy", + "babel", + "backports", + "beautifulsoup4", + "bitarray", + "bkcharts", + "bleach", + "bokeh", + "boto3", + "bottleneck", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dal", + "dask", + "datashader", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "flask", + "fontconfig", + "freetype", + "gensim", + "glib", + "gst-plugins-base", + "gstreamer", + "h5py", + "hdf5", + "heapdict", + "holoviews", + "hvplot", + "icu", + "idna", + "imagesize", + "intake", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jq", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "lazy-object-proxy", + "libffi", + "libpng", + "libsodium", + "libssh2", + "libtiff", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "markupsafe", + "matplotlib", + "mistune", + "mkl", + "mkl-service", + "mpmath", + "msgpack-python", + "nbconvert", + "nbformat", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "panel", + "partd", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "plotly", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pytables", + "pytest", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "setuptools", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tabulate", + "tbb4py", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "unixodbc", + "wcwidth", + "wget", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "56078582033d47b6bf7345a94f13ac31", + "name": "_anaconda_depends", + "sha256": "1b5762a006826b51caef8cc8568d774e7d6dae202b1c90dbff64494aec40255a", + "size": 68968, + "subdir": "linux-64", + "timestamp": 1674079928443, + "version": "2022.10" + }, + "_anaconda_depends-2022.10-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "alabaster", + "astroid", + "astropy", + "babel", + "backports", + "beautifulsoup4", + "bitarray", + "bkcharts", + "bleach", + "bokeh", + "boto3", + "bottleneck", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dal", + "dask", + "datashader", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "flask", + "fontconfig", + "freetype", + "gensim", + "glib", + "gst-plugins-base", + "gstreamer", + "h5py", + "hdf5", + "heapdict", + "holoviews", + "hvplot", + "icu", + "idna", + "imagesize", + "intake", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jq", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "lazy-object-proxy", + "libffi", + "libpng", + "libsodium", + "libssh2", + "libtiff", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "markupsafe", + "matplotlib", + "mistune", + "mkl", + "mkl-service", + "mpmath", + "msgpack-python", + "nbconvert", + "nbformat", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "panel", + "partd", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "plotly", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pytables", + "pytest", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "setuptools", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tabulate", + "tbb4py", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "unixodbc", + "wcwidth", + "wget", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fe1592a1b2918ee04972632e4d451f7c", + "name": "_anaconda_depends", + "sha256": "0cd54ad346f542ccdc46bb7bed7482bae87ac52d8de76961c0755715ffdcf58d", + "size": 68944, + "subdir": "linux-64", + "timestamp": 1674079934110, + "version": "2022.10" + }, + "_anaconda_depends-2022.10-py38_2.conda": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "alabaster", + "astroid", + "astropy", + "babel", + "backports", + "beautifulsoup4", + "bitarray", + "bkcharts", + "bleach", + "bokeh", + "boto3", + "bottleneck", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dal", + "dask", + "datashader", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "flask", + "fontconfig", + "freetype", + "gensim", + "glib", + "gst-plugins-base", + "gstreamer", + "h5py", + "hdf5", + "heapdict", + "holoviews", + "hvplot", + "icu", + "idna", + "imagesize", + "intake", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jq", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "lazy-object-proxy", + "libffi", + "libpng", + "libsodium", + "libssh2", + "libtiff", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "markupsafe", + "matplotlib", + "mistune", + "mkl", + "mkl-service", + "mpmath", + "msgpack-python", + "nbconvert", + "nbformat", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "panel", + "partd", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "plotly", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pytables", + "pytest", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "setuptools", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tabulate", + "tbb4py", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "unixodbc", + "wcwidth", + "wget", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f99ef20ced5aa45a8b374fa1a2f038db", + "name": "_anaconda_depends", + "sha256": "d8221971dcb526a144de597e10d5692b98572bcb552c377ad0549f0103a8c3b3", + "size": 68940, + "subdir": "linux-64", + "timestamp": 1674079922312, + "version": "2022.10" + }, + "_anaconda_depends-2022.10-py39_2.conda": { + "build": "py39_2", + "build_number": 2, + "depends": [ + "alabaster", + "astroid", + "astropy", + "babel", + "backports", + "beautifulsoup4", + "bitarray", + "bkcharts", + "bleach", + "bokeh", + "boto3", + "bottleneck", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dal", + "dask", + "datashader", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "flask", + "fontconfig", + "freetype", + "gensim", + "glib", + "gst-plugins-base", + "gstreamer", + "h5py", + "hdf5", + "heapdict", + "holoviews", + "hvplot", + "icu", + "idna", + "imagesize", + "intake", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jq", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "lazy-object-proxy", + "libffi", + "libpng", + "libsodium", + "libssh2", + "libtiff", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "markupsafe", + "matplotlib", + "mistune", + "mkl", + "mkl-service", + "mpmath", + "msgpack-python", + "nbconvert", + "nbformat", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandocfilters", + "panel", + "partd", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "plotly", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pytables", + "pytest", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "setuptools", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tabulate", + "tbb4py", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "unixodbc", + "wcwidth", + "wget", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d601f1e19b98600fe2cad8719dfb10f", + "name": "_anaconda_depends", + "sha256": "05c310bd8d4beb5bcf1ce63ba939e123452fcfb1961a42a590e54a8296dab4e0", + "size": 68942, + "subdir": "linux-64", + "timestamp": 1674079916768, + "version": "2022.10" + }, + "_anaconda_depends-2023.03-py310_0.conda": { + "build": "py310_0", + "build_number": 0, + "depends": [ + "astropy", + "beautifulsoup4", + "bokeh", + "curl", + "daal4py", + "dal", + "dask", + "datashader", + "flask", + "gensim", + "h5py", + "holoviews", + "hvplot", + "imbalanced-learn", + "intake", + "intel-openmp", + "ipython", + "jq", + "jupyter", + "jupyterlab", + "matplotlib", + "mkl", + "mkl-service", + "nbconvert", + "networkx", + "nltk", + "notebook", + "numba", + "numpy", + "openpyxl", + "pandas", + "panel", + "pep8", + "pillow", + "pip", + "plotly", + "pycurl", + "pyflakes", + "pylint", + "pyodbc", + "pytables", + "pytest", + "python >=3.10,<3.11.0a0", + "pywavelets", + "requests", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "setuptools", + "snowballstemmer", + "spyder", + "sqlalchemy", + "statsmodels", + "sympy", + "tabulate", + "tbb4py", + "transformers", + "unixodbc", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "32b7eb4320309513231d7ede3ffeb3cf", + "name": "_anaconda_depends", + "sha256": "4c98226abc9ece01ea6a5f2390cdc70f5660694e9d153948363e8604398bb9c8", + "size": 67072, + "subdir": "linux-64", + "timestamp": 1678132252313, + "version": "2023.03" + }, + "_anaconda_depends-2023.03-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "astropy", + "beautifulsoup4", + "bokeh", + "curl", + "daal4py", + "dal", + "dask", + "datashader", + "flask", + "gensim", + "h5py", + "holoviews", + "hvplot", + "imbalanced-learn", + "intake", + "intel-openmp", + "ipython", + "jq", + "jupyter", + "jupyterlab", + "matplotlib", + "mkl", + "mkl-service", + "nbconvert", + "networkx", + "nltk", + "notebook", + "numba", + "numpy", + "openpyxl", + "pandas", + "panel", + "pep8", + "pillow", + "pip", + "plotly", + "pycurl", + "pyflakes", + "pylint", + "pyodbc", + "pytables", + "pytest", + "python >=3.8,<3.9.0a0", + "pywavelets", + "requests", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "setuptools", + "snowballstemmer", + "spyder", + "sqlalchemy", + "statsmodels", + "sympy", + "tabulate", + "tbb4py", + "transformers", + "unixodbc", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d3fcb7f41c38ed325bd5b1ada51cd901", + "name": "_anaconda_depends", + "sha256": "de07e94b6bf1f0f82a6c8d88ee756ac9ab2f90bfe8bae26dfd83f4998a4b43d5", + "size": 67028, + "subdir": "linux-64", + "timestamp": 1678132263899, + "version": "2023.03" + }, + "_anaconda_depends-2023.03-py39_0.conda": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "astropy", + "beautifulsoup4", + "bokeh", + "curl", + "daal4py", + "dal", + "dask", + "datashader", + "flask", + "gensim", + "h5py", + "holoviews", + "hvplot", + "imbalanced-learn", + "intake", + "intel-openmp", + "ipython", + "jq", + "jupyter", + "jupyterlab", + "matplotlib", + "mkl", + "mkl-service", + "nbconvert", + "networkx", + "nltk", + "notebook", + "numba", + "numpy", + "openpyxl", + "pandas", + "panel", + "pep8", + "pillow", + "pip", + "plotly", + "pycurl", + "pyflakes", + "pylint", + "pyodbc", + "pytables", + "pytest", + "python >=3.9,<3.10.0a0", + "pywavelets", + "requests", + "scikit-image", + "scikit-learn", + "scikit-learn-intelex", + "scipy", + "scrapy", + "seaborn", + "setuptools", + "snowballstemmer", + "spyder", + "sqlalchemy", + "statsmodels", + "sympy", + "tabulate", + "tbb4py", + "transformers", + "unixodbc", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "771adf815feda5d2a579a580da4b4741", + "name": "_anaconda_depends", + "sha256": "2c32d92d9832f54873a3a37ba6580a0a74e1d244a89bbc8bd1eccec2d39c5379", + "size": 67035, + "subdir": "linux-64", + "timestamp": 1678132258283, + "version": "2023.03" + }, + "_anaconda_depends-5.0.0-py27he0e5e41_0.conda": { + "build": "py27he0e5e41_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "funcsigs", + "functools32", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "e07d896e009fe7b2e4b821fd26655fba", + "name": "_anaconda_depends", + "sha256": "cbe4a6097f75cdeffca6d6cd4022557226594ace9985a3b399b567cf2e411af8", + "size": 6031, + "subdir": "linux-64", + "timestamp": 1562174055449, + "version": "5.0.0" + }, + "_anaconda_depends-5.0.0-py35h81e3b35_0.conda": { + "build": "py35h81e3b35_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.5.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "326be1cb6a205b0352c00118f8f7b1ac", + "name": "_anaconda_depends", + "sha256": "3412d133293649d304c089ebd3e42274871b7f5c98df0f48829d8e4895c012b3", + "size": 5851, + "subdir": "linux-64", + "timestamp": 1562174066309, + "version": "5.0.0" + }, + "_anaconda_depends-5.0.0-py36h06de3c5_0.conda": { + "build": "py36h06de3c5_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.6.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "4017b7b44c6b6aeb6c999cab3617ad9c", + "name": "_anaconda_depends", + "sha256": "9249d9be6579437e575c4039ee4fdb69b329e491eeb40559d7189a08c4507c73", + "size": 5845, + "subdir": "linux-64", + "timestamp": 1562174078347, + "version": "5.0.0" + }, + "_anaconda_depends-5.0.0.1-py27h1e3bc52_1.conda": { + "build": "py27h1e3bc52_1", + "build_number": 1, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "funcsigs", + "functools32", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "f7efe3d0720d5935ae0754976b152975", + "name": "_anaconda_depends", + "sha256": "6eb0bc468bfb5fbcfc9525190478f9c233f5b146a9798eb0aaddc8cfd5560143", + "size": 6050, + "subdir": "linux-64", + "timestamp": 1562173977964, + "version": "5.0.0.1" + }, + "_anaconda_depends-5.0.0.1-py27hfd10420_0.conda": { + "build": "py27hfd10420_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "funcsigs", + "functools32", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "32c4f4f8138e301032abf5337e98cfbf", + "name": "_anaconda_depends", + "sha256": "46f0bc3b8f0db36ee63ff685f64db841b210e50e32c3b46ec73c2b5030616484", + "size": 6050, + "subdir": "linux-64", + "timestamp": 1562173992756, + "version": "5.0.0.1" + }, + "_anaconda_depends-5.0.0.1-py35h1ed3d8c_0.conda": { + "build": "py35h1ed3d8c_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.5.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "81dc0c4ca90cf699c71c8c5c55ee815d", + "name": "_anaconda_depends", + "sha256": "9cae286faeda6488a9ee4a8ad266a0d90aa6685a243b1f9d54744095e25fcf8e", + "size": 5858, + "subdir": "linux-64", + "timestamp": 1562174003282, + "version": "5.0.0.1" + }, + "_anaconda_depends-5.0.0.1-py35h6d98c0b_1.conda": { + "build": "py35h6d98c0b_1", + "build_number": 1, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.5.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "deaab90a6304a2a985fd41074bd3767c", + "name": "_anaconda_depends", + "sha256": "71b6782c973e91597be3502314ab69297ce5691072a507347bcbb1b31b5eb8ad", + "size": 5853, + "subdir": "linux-64", + "timestamp": 1562174015006, + "version": "5.0.0.1" + }, + "_anaconda_depends-5.0.0.1-py36h6c6c83f_0.conda": { + "build": "py36h6c6c83f_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.6.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "4fe25809f030bfc967c772ecb210b9f3", + "name": "_anaconda_depends", + "sha256": "e0ca31998bd82227e8f923b2792d6201f3c31cbb080d410e0096e436c5de7a20", + "size": 5851, + "subdir": "linux-64", + "timestamp": 1562174027781, + "version": "5.0.0.1" + }, + "_anaconda_depends-5.0.0.1-py36hfb0b618_1.conda": { + "build": "py36hfb0b618_1", + "build_number": 1, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.6.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "8e692147e9fe06b4b9ce4faed06e9132", + "name": "_anaconda_depends", + "sha256": "96ee39d152de9d013f9a7e2551c226cb5bf8eda8af91199fe00bfbbfd3d18045", + "size": 5852, + "subdir": "linux-64", + "timestamp": 1562174040487, + "version": "5.0.0.1" + }, + "_anaconda_depends-5.0.1-py27hd9359a7_1.conda": { + "build": "py27hd9359a7_1", + "build_number": 1, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "funcsigs", + "functools32", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "1eb1874e2207be624a054e830ceea1db", + "name": "_anaconda_depends", + "sha256": "f45b69a513abc2c87eac679a6487914e89caeb17d1aeff976f01bbacbc3869ce", + "size": 6039, + "subdir": "linux-64", + "timestamp": 1562174094094, + "version": "5.0.1" + }, + "_anaconda_depends-5.0.1-py35h6f6dcbc_1.conda": { + "build": "py35h6f6dcbc_1", + "build_number": 1, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.5.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "18850ba1d478f493ddc35efee876ecb0", + "name": "_anaconda_depends", + "sha256": "d9ae01225201a89b04273ec28346dd8c4a74d6d636b5d989c02879a54f800fa6", + "size": 5857, + "subdir": "linux-64", + "timestamp": 1562174105402, + "version": "5.0.1" + }, + "_anaconda_depends-5.0.1-py36hd30a520_1.conda": { + "build": "py36hd30a520_1", + "build_number": 1, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-navigator", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "navigator-updater", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.6.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "0def6e1727eb0299c00d9e53c4c28fa3", + "name": "_anaconda_depends", + "sha256": "f19375e6abae7220f1ebd180b43179c48a62fe3f2f92c438d38aa2cfc481a568", + "size": 5849, + "subdir": "linux-64", + "timestamp": 1562174117633, + "version": "5.0.1" + }, + "_anaconda_depends-5.1.0-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "attrs", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "funcsigs", + "functools32", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "bb45c36019a08fe3a266e4cddff3aa70", + "name": "_anaconda_depends", + "sha256": "622462212c40e03eb33c0fda3033d5bde8e44899cfa36dfeb7731f5848d0933f", + "size": 6136, + "subdir": "linux-64", + "timestamp": 1562174132746, + "version": "5.1.0" + }, + "_anaconda_depends-5.1.0-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "attrs", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.5.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "978fd90ca772ce5e7c2ad387895cea52", + "name": "_anaconda_depends", + "sha256": "67f2e045c55e130653cd3f1f0faae656e4fd3f6377946871761234cc6f7f0034", + "size": 5942, + "subdir": "linux-64", + "timestamp": 1562174142418, + "version": "5.1.0" + }, + "_anaconda_depends-5.1.0-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "attrs", + "babel", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blaze", + "bleach", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 3.6.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "79a9f7116d31925f38d2f5df6d165820", + "name": "_anaconda_depends", + "sha256": "bfe48c7a068ab1ce50ab8a62dc3c1bc8ced5d5715ba2fbeda86f4704b8eaed31", + "size": 5937, + "subdir": "linux-64", + "timestamp": 1562174154716, + "version": "5.1.0" + }, + "_anaconda_depends-5.2.0-py27_3.conda": { + "build": "py27_3", + "build_number": 3, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "attrs", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "funcsigs", + "functools32", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "61fc18f0e016306c70fb3cdc495203ed", + "name": "_anaconda_depends", + "sha256": "3f3559d5c7d32109513e7ce1ed8cd95e935310ba253eda66fc0b864b288961c3", + "size": 6138, + "subdir": "linux-64", + "timestamp": 1562174170539, + "version": "5.2.0" + }, + "_anaconda_depends-5.2.0-py35_3.conda": { + "build": "py35_3", + "build_number": 3, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "attrs", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.5.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "102884b7ede0c8a8a2179d1df4e0d472", + "name": "_anaconda_depends", + "sha256": "5d76d90607306bb8594e60ae0349ae27baf738b2c8cf94a4204b4f5f48a3c49b", + "size": 6023, + "subdir": "linux-64", + "timestamp": 1562174180775, + "version": "5.2.0" + }, + "_anaconda_depends-5.2.0-py36_3.conda": { + "build": "py36_3", + "build_number": 3, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "asn1crypto", + "astroid", + "astropy", + "attrs", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "icu", + "idna", + "imageio", + "imagesize", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.6.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "traitlets", + "typing", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib" + ], + "license": "BSD", + "md5": "8e91ebc7f0cd795a0390f2e24dad8027", + "name": "_anaconda_depends", + "sha256": "82938dac18c992590c653a13e3429465b33ef6c3bbc1e32929276cfcb708d54c", + "size": 6029, + "subdir": "linux-64", + "timestamp": 1562174193565, + "version": "5.2.0" + }, + "_anaconda_depends-5.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "appdirs", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "automat", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "constantly", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "funcsigs", + "functools32", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hyperlink", + "icu", + "idna", + "imageio", + "imagesize", + "incremental", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "linecache2", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pyasn1", + "pyasn1-modules", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "service_identity", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traceback2", + "traitlets", + "twisted", + "typing", + "unicodecsv", + "unittest2", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zope", + "zope.interface" + ], + "license": "BSD", + "md5": "6aa34200f2ed64c7d5956ba418d4c5f9", + "name": "_anaconda_depends", + "sha256": "367fa11573d0d4c078dfcd05ade62e0d1b588d2ee6633e427e89f62a119f37ae", + "size": 6424, + "subdir": "linux-64", + "timestamp": 1562174211249, + "version": "5.3.0" + }, + "_anaconda_depends-5.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "appdirs", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "automat", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "constantly", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hyperlink", + "icu", + "idna", + "imageio", + "imagesize", + "incremental", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "keyring", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pyasn1", + "pyasn1-modules", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.6.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "service_identity", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "twisted", + "typed-ast", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zope", + "zope.interface" + ], + "license": "BSD", + "md5": "fd6572f0cd3fc6b5e2c3e13aae1c3230", + "name": "_anaconda_depends", + "sha256": "6ccfe5ac13904ac5f220f1755fa696d4c61222e4461646a1e0649fdcedf42608", + "size": 6303, + "subdir": "linux-64", + "timestamp": 1562174224865, + "version": "5.3.0" + }, + "_anaconda_depends-5.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "appdirs", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "automat", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "constantly", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hyperlink", + "icu", + "idna", + "imageio", + "imagesize", + "incremental", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "keyring", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pyasn1", + "pyasn1-modules", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "service_identity", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "twisted", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zope", + "zope.interface" + ], + "license": "BSD", + "md5": "7cf6b2bcd9e3d5baedcf74d66230cb26", + "name": "_anaconda_depends", + "sha256": "e2d78369d53e8f5012d5125b37496d5e0e7d933e4f69dc72588a7700a912b7f2", + "size": 6292, + "subdir": "linux-64", + "timestamp": 1562174233624, + "version": "5.3.0" + }, + "_anaconda_depends-5.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "appdirs", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "automat", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "constantly", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "funcsigs", + "functools32", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hyperlink", + "icu", + "idna", + "imageio", + "imagesize", + "incremental", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "linecache2", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pyasn1", + "pyasn1-modules", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "service_identity", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traceback2", + "traitlets", + "twisted", + "typing", + "unicodecsv", + "unittest2", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zope", + "zope.interface" + ], + "license": "BSD", + "md5": "dc4ed04b52bd908944514edf6c6dfb45", + "name": "_anaconda_depends", + "sha256": "d1ba134bfb6408469bbad4c63ba3b2830f746cf82c89439087458ea7af7e9974", + "size": 6442, + "subdir": "linux-64", + "timestamp": 1562174249652, + "version": "5.3.1" + }, + "_anaconda_depends-5.3.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "appdirs", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "automat", + "babel", + "backports", + "backports.functools_lru_cache", + "backports.shutil_get_terminal_size", + "backports_abc", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "cdecimal", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "configparser", + "constantly", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "enum34", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "funcsigs", + "functools32", + "futures", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "grin", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hyperlink", + "icu", + "idna", + "imageio", + "imagesize", + "incremental", + "intel-openmp", + "ipaddress", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "linecache2", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pyasn1", + "pyasn1-modules", + "pycairo", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "python 2.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scandir", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "send2trash", + "service_identity", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "ssl_match_hostname", + "statsmodels", + "subprocess32", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traceback2", + "traitlets", + "twisted", + "typing", + "unicodecsv", + "unittest2", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zope", + "zope.interface" + ], + "license": "BSD", + "md5": "a8ca0f3ef3b8254eff7f42d9a59fd650", + "name": "_anaconda_depends", + "sha256": "f8d3779a663e8e6529d2eb9607a6c4c77826b293fcdde9efb3948e30e4d281b6", + "size": 6432, + "subdir": "linux-64", + "timestamp": 1562174265857, + "version": "5.3.1" + }, + "_anaconda_depends-5.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "appdirs", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "automat", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "constantly", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hyperlink", + "icu", + "idna", + "imageio", + "imagesize", + "incremental", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "keyring", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pyasn1", + "pyasn1-modules", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "service_identity", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "twisted", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zope", + "zope.interface" + ], + "license": "BSD", + "md5": "5b03f229a90bfbfc35c70f02e6d689b8", + "name": "_anaconda_depends", + "sha256": "d0d1cab581d06cea09fccf920ea0572b6b823616e75180aac46fc22aeb49cb99", + "size": 6294, + "subdir": "linux-64", + "timestamp": 1562174274613, + "version": "5.3.1" + }, + "_anaconda_depends-5.3.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "alabaster", + "anaconda-client", + "anaconda-project", + "appdirs", + "asn1crypto", + "astroid", + "astropy", + "atomicwrites", + "attrs", + "automat", + "babel", + "backcall", + "backports", + "backports.shutil_get_terminal_size", + "beautifulsoup4", + "bitarray", + "bkcharts", + "blas", + "blaze", + "bleach", + "blosc", + "bokeh", + "boto", + "bottleneck", + "bzip2", + "ca-certificates", + "cairo", + "certifi", + "cffi", + "chardet", + "click", + "cloudpickle", + "clyent", + "colorama", + "constantly", + "contextlib2", + "cryptography", + "curl", + "cycler", + "cython", + "cytoolz", + "dask", + "dask-core", + "datashape", + "dbus", + "decorator", + "defusedxml", + "distributed", + "docutils", + "entrypoints", + "et_xmlfile", + "expat", + "fastcache", + "filelock", + "flask", + "flask-cors", + "fontconfig", + "freetype", + "fribidi", + "get_terminal_size", + "gevent", + "glib", + "glob2", + "gmp", + "gmpy2", + "graphite2", + "greenlet", + "gst-plugins-base", + "gstreamer", + "h5py", + "harfbuzz", + "hdf5", + "heapdict", + "html5lib", + "hyperlink", + "icu", + "idna", + "imageio", + "imagesize", + "incremental", + "intel-openmp", + "ipykernel", + "ipython", + "ipython_genutils", + "ipywidgets", + "isort", + "itsdangerous", + "jbig", + "jdcal", + "jedi", + "jeepney", + "jinja2", + "jpeg", + "jsonschema", + "jupyter", + "jupyter_client", + "jupyter_console", + "jupyter_core", + "jupyterlab", + "jupyterlab_launcher", + "keyring", + "kiwisolver", + "lazy-object-proxy", + "libcurl", + "libedit", + "libffi", + "libgcc-ng", + "libgfortran-ng", + "libpng", + "libsodium", + "libssh2", + "libstdcxx-ng", + "libtiff", + "libtool", + "libuuid", + "libxcb", + "libxml2", + "libxslt", + "llvmlite", + "locket", + "lxml", + "lzo", + "markupsafe", + "matplotlib", + "mccabe", + "mistune", + "mkl", + "mkl-service", + "mkl_fft", + "mkl_random", + "more-itertools", + "mpc", + "mpfr", + "mpmath", + "msgpack-python", + "multipledispatch", + "nbconvert", + "nbformat", + "ncurses", + "networkx", + "nltk", + "nose", + "notebook", + "numba", + "numexpr", + "numpy", + "numpy-base", + "numpydoc", + "odo", + "olefile", + "openpyxl", + "openssl", + "packaging", + "pandas", + "pandoc", + "pandocfilters", + "pango", + "parso", + "partd", + "patchelf", + "path.py", + "pathlib2", + "patsy", + "pcre", + "pep8", + "pexpect", + "pickleshare", + "pillow", + "pip", + "pixman", + "pkginfo", + "pluggy", + "ply", + "prometheus_client", + "prompt_toolkit", + "psutil", + "ptyprocess", + "py", + "pyasn1", + "pyasn1-modules", + "pycodestyle", + "pycosat", + "pycparser", + "pycrypto", + "pycurl", + "pyflakes", + "pygments", + "pylint", + "pyodbc", + "pyopenssl", + "pyparsing", + "pyqt", + "pysocks", + "pytables", + "pytest", + "pytest-arraydiff", + "pytest-astropy", + "pytest-doctestplus", + "pytest-openfiles", + "pytest-remotedata", + "python 3.7.*", + "python-dateutil", + "pytz", + "pywavelets", + "pyyaml", + "pyzmq", + "qt", + "qtawesome", + "qtconsole", + "qtpy", + "readline", + "requests", + "rope", + "ruamel_yaml", + "scikit-image", + "scikit-learn", + "scipy", + "seaborn", + "secretstorage", + "send2trash", + "service_identity", + "setuptools", + "simplegeneric", + "singledispatch", + "sip", + "six", + "snappy", + "snowballstemmer", + "sortedcollections", + "sortedcontainers", + "sphinx", + "sphinxcontrib", + "sphinxcontrib-websupport", + "spyder", + "spyder-kernels", + "sqlalchemy", + "sqlite", + "statsmodels", + "sympy", + "tblib", + "terminado", + "testpath", + "tk", + "toolz", + "tornado", + "tqdm", + "traitlets", + "twisted", + "unicodecsv", + "unixodbc", + "urllib3", + "wcwidth", + "webencodings", + "werkzeug", + "wheel", + "widgetsnbextension", + "wrapt", + "xlrd", + "xlsxwriter", + "xlwt", + "xz", + "yaml", + "zeromq", + "zict", + "zlib", + "zope", + "zope.interface" + ], + "license": "BSD", + "md5": "dfe9f6143a019308bbd83848c3c917d8", + "name": "_anaconda_depends", + "sha256": "ba71afdbffca1aa6b4b14267012065f0dcfef02e6776ceb87f4096ff088ac5e9", + "size": 6289, + "subdir": "linux-64", + "timestamp": 1562174283455, + "version": "5.3.1" + }, + "_go_select-2.1.0-precompiled.conda": { + "build": "precompiled", + "build_number": 0, + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "54959b483b1a78140c25d7c339272672", + "name": "_go_select", + "sha256": "36578fb5f8ed6617f515b401b9fa667387a7a904a0e30b57c379e409597709a2", + "size": 8103, + "subdir": "linux-64", + "timestamp": 1623378331023, + "version": "2.1.0" + }, + "_go_select-2.2.0-nocgo.conda": { + "build": "nocgo", + "build_number": 0, + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "035933055c5cd8926e11c356df6a3666", + "name": "_go_select", + "sha256": "0a8d82938ea7f91b7687c19d539aadc2cc6b7e9c8267dc3d91e7894a06c70259", + "size": 8086, + "subdir": "linux-64", + "timestamp": 1623377704294, + "version": "2.2.0" + }, + "_go_select-2.3.0-cgo.conda": { + "build": "cgo", + "build_number": 0, + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "73a9dbf6acbed92b5e45e336f0372bcf", + "name": "_go_select", + "sha256": "55d4eaaa3c34787821982017a44ba6ef481b966cdad68beaeed96b9cee152ef2", + "size": 8044, + "subdir": "linux-64", + "timestamp": 1623378326334, + "version": "2.3.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=2.7,<2.8.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "0550d0927482f84d721ca9bd6f1fb6a4", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "bd95d01596d556ff200135dab15ea5463ebc4a9d91dff34d338ed35bdc449e60", + "size": 4263, + "subdir": "linux-64", + "timestamp": 1530735062325, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py27h08a7f0c_0.conda": { + "build": "py27h08a7f0c_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=2.7,<2.8.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "29518a202fb75260b8e3f3c6a95ae4e1", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "45aff2ba4b824387dcd11eaa0acb36a0344e3154f9921c5242e29f92b5e7a510", + "size": 4578, + "subdir": "linux-64", + "timestamp": 1505722768904, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.10,<3.11.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "14739d2f102595bcb49d4ec11b177d2f", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "3e6366dfec6b719a8db079a8645716f27b3498852a3431987262f41288f1c406", + "size": 4894, + "subdir": "linux-64", + "timestamp": 1641918112240, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.10,<3.11.0a0", + "widgetsnbextension" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "533cf418dedbca46fa11cec6282631f8", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "34a93c16882728915a912a92ebafcfc4142b7a92d294611db15ab81fb3436f9f", + "size": 4703, + "subdir": "linux-64", + "timestamp": 1649860682597, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.11,<3.12.0a0", + "widgetsnbextension" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "25ae7cde362b3ff78c34e8282901035a", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "0cf098d2165c77818b2bde9d139d860c58ec163c67b62a73e5e16a853c7ea6ae", + "size": 4857, + "subdir": "linux-64", + "timestamp": 1679340223752, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.5,<3.6.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "186139352399e463448b6c04888eb6ff", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "70944396b4ae08bc41dd3c152499939557317ea06bdf5ee394f65fd0eb0545fb", + "size": 4262, + "subdir": "linux-64", + "timestamp": 1534351776132, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py35h02fa31e_0.conda": { + "build": "py35h02fa31e_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.5,<3.6.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "0ee28644766572a7d12e6df5c75e0d92", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "0242445fadd75ff58d3f3537b14dffc33176d2d9491f46fe4515b24589f86eaa", + "size": 4384, + "subdir": "linux-64", + "timestamp": 1505691121049, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.6,<3.7.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "7a580c07e4fa974b2af115f324e38475", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "eafc8b68b46ba0728682cad7c793ea661087ee284300a92ee2e38376c8f9eb27", + "size": 4079, + "subdir": "linux-64", + "timestamp": 1530735015948, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py36he11e457_0.conda": { + "build": "py36he11e457_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.6,<3.7.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "469139538c6b6bfaf6f174b442c73abe", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "5f797be390d2746cfe74e03d7963cec1382f0ea63b5ac8cfacc631435097fb81", + "size": 4392, + "subdir": "linux-64", + "timestamp": 1505691138983, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.7,<3.8.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "25b69eca180f53503693895de426edeb", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "d084825581a298fbac2a157ee3c632d82d93cd1bf8edd2df22c0bf58c8bd2ddf", + "size": 4085, + "subdir": "linux-64", + "timestamp": 1530735099589, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.7,<3.8.0a0", + "widgetsnbextension" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "816f95cb3f564eeee1d16b214e2302b8", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "2dbc236a74ef39dfca4f9180db5759e78e32213e73a19e83257451f4d3e3ac31", + "size": 4647, + "subdir": "linux-64", + "timestamp": 1649860621854, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.8,<3.9.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "f4b9b8a02353eeea3baf7637c7b6ff4e", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "3758d7f6b7231095d9906cca2513909701b1aad3f9626563a9e53361c9b99fc7", + "size": 196532, + "subdir": "linux-64", + "timestamp": 1593558066359, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.8,<3.9.0a0", + "widgetsnbextension" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "74cc435155d4612afd7215bfbc311345", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "aa2c38800651cc3e5b74f5d6e0f0ec68404523b6ee552f8d27e16efd1e7877bb", + "size": 4684, + "subdir": "linux-64", + "timestamp": 1649860731265, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.9,<3.10.0a0", + "widgetsnbextension" + ], + "license": "BSD", + "md5": "24d7029d37c26651122c28bc2a9319f3", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "36939422e734ef020f572b9795f586d7faf5288a9cbe629b446811ba4b33ffad", + "size": 226472, + "subdir": "linux-64", + "timestamp": 1608230120597, + "version": "0.1.0" + }, + "_ipyw_jlab_nb_ext_conf-0.1.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "ipywidgets", + "jupyterlab", + "python >=3.9,<3.10.0a0", + "widgetsnbextension" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c665d6c758cc9cc4739b700d8eb143e4", + "name": "_ipyw_jlab_nb_ext_conf", + "sha256": "c22b3f28597a3bfef74d61d3ea73bff5fda2e380a9b9930cfe66f0fb97586651", + "size": 4677, + "subdir": "linux-64", + "timestamp": 1649860571444, + "version": "0.1.0" + }, + "_libarchive_static_for_cph-3.3.3-hf8de549_0.conda": { + "build": "hf8de549_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "md5": "8020a7cc554c04197580cbdbe6edf5fe", + "name": "_libarchive_static_for_cph", + "sha256": "90a3284d79eb08ebfdd41404e047eb40f2188cbe0f41690705891d36af6634c4", + "size": 914797, + "subdir": "linux-64", + "timestamp": 1568316050596, + "version": "3.3.3" + }, + "_libarchive_static_for_cph-3.4.3-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "md5": "24a56d1f34a516c93fda302c38c003bf", + "name": "_libarchive_static_for_cph", + "sha256": "4d2e796a8419675ee9d2e94c1434663fe8585953936478186e627e193e8289cf", + "size": 1005413, + "subdir": "linux-64", + "timestamp": 1602685890983, + "version": "3.4.3" + }, + "_libarchive_static_for_cph-3.4.3-h14c3975_2.conda": { + "build": "h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "md5": "481c6a85945f23aea027922a3f50e997", + "name": "_libarchive_static_for_cph", + "sha256": "13cd212345d1d024e76fe0046b17dededcc48b80da889637b1cdfe6e5e56dbb9", + "size": 1006632, + "subdir": "linux-64", + "timestamp": 1602831181297, + "version": "3.4.3" + }, + "_libarchive_static_for_cph-3.4.3-hf8de549_0.conda": { + "build": "hf8de549_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "md5": "f368a1da5b3b45895a6175417acfbc26", + "name": "_libarchive_static_for_cph", + "sha256": "e5614b3f0da68498e6f1c8395a2f5299daade637341de3657cad7418f041f699", + "size": 1003165, + "subdir": "linux-64", + "timestamp": 1602685785944, + "version": "3.4.3" + }, + "_libarchive_static_for_cph-3.4.3-hf8de549_2.conda": { + "build": "hf8de549_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "md5": "7ba07f2f22b69f720ebfd3814f0ff8af", + "name": "_libarchive_static_for_cph", + "sha256": "d45de6388b9e1ef4cce5ea9d4839ade173ceef1c740153f3fba301fb895a95dd", + "size": 1005527, + "subdir": "linux-64", + "timestamp": 1602831121800, + "version": "3.4.3" + }, + "_libarchive_static_for_cph-3.6.1-h6926279_0.conda": { + "build": "h6926279_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "19aefbed43e8aede663d094d08a37771", + "name": "_libarchive_static_for_cph", + "sha256": "aeed157d2f7f2fa52559cd2e758ea226693ebfd815d872621b2291a35e20a1b3", + "size": 864735, + "subdir": "linux-64", + "timestamp": 1666855795487, + "version": "3.6.1" + }, + "_libgcc_mutex-0.1-main.conda": { + "build": "main", + "build_number": 0, + "depends": [], + "md5": "c3473ff8bdb3d124ed5ff11ec380d6f9", + "name": "_libgcc_mutex", + "sha256": "476626712f60e5ef0fe04c354727152b1ee5285d57ccd3575c7be930122bd051", + "size": 3473, + "subdir": "linux-64", + "timestamp": 1562011674792, + "version": "0.1" + }, + "_low_priority-1.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "md5": "5b563966b9da4409aafad0d917732ee1", + "name": "_low_priority", + "sha256": "84a7ad5db9d4314349fd626c1b4c8c7400b7297fef733c89e4aa343051e65f66", + "size": 164704, + "subdir": "linux-64", + "timestamp": 1563307428325, + "track_features": "_low_priority", + "version": "1.0" + }, + "_mutex_mxnet-0.0.10-gpu_openblas.conda": { + "build": "gpu_openblas", + "build_number": 0, + "depends": [], + "md5": "b6526125d048d28e0628b8050c3e61b5", + "name": "_mutex_mxnet", + "sha256": "40666dd8de9310dddaaefb39ae34a1f5e8c85b3f8f6e888a1eb87b19be22c4a8", + "size": 2534, + "subdir": "linux-64", + "timestamp": 1533361949863, + "version": "0.0.10" + }, + "_mutex_mxnet-0.0.20-gpu_mkl.conda": { + "build": "gpu_mkl", + "build_number": 0, + "depends": [], + "md5": "7022720333449fea115f4f0539f06e83", + "name": "_mutex_mxnet", + "sha256": "dede1830f2a2fb1a81ecd1b133a662cf6e0a5283c432763c161330e5cf31c761", + "size": 2513, + "subdir": "linux-64", + "timestamp": 1533361947999, + "version": "0.0.20" + }, + "_mutex_mxnet-0.0.30-mkl.conda": { + "build": "mkl", + "build_number": 0, + "depends": [], + "md5": "30ef0a367d8e702c3ff0808c9bb81482", + "name": "_mutex_mxnet", + "sha256": "57ecfc32a4251bb0def9b9394d8ab37c5f3dfb4d536645920ed9d9baa5460363", + "size": 2460, + "subdir": "linux-64", + "timestamp": 1633948420983, + "version": "0.0.30" + }, + "_mutex_mxnet-0.0.30-openblas.conda": { + "build": "openblas", + "build_number": 0, + "depends": [], + "md5": "d68c3db07ecc6c4c903a085fc061d976", + "name": "_mutex_mxnet", + "sha256": "a42afb156ccd774e1274b05e211f2feddeb0bbce589de4fcb2276445fb1acaee", + "size": 2510, + "subdir": "linux-64", + "timestamp": 1533361950617, + "version": "0.0.30" + }, + "_mutex_mxnet-0.0.40-mkl.conda": { + "build": "mkl", + "build_number": 0, + "depends": [], + "md5": "b272b014da0284f28938c8a7831ed69c", + "name": "_mutex_mxnet", + "sha256": "2dad1fc27081f395a2653abcecb7e42a91410a710b77cbc36dfc896809aa042d", + "size": 2490, + "subdir": "linux-64", + "timestamp": 1533361949118, + "version": "0.0.40" + }, + "_mutex_mxnet-0.0.40-openblas.conda": { + "build": "openblas", + "build_number": 0, + "depends": [], + "md5": "09f7769a7b6fb4641d13d270f454ac5b", + "name": "_mutex_mxnet", + "sha256": "f229647700a2cf056aca33f6d46ee94766b2b90c442bed1878d7a30b9ff5ba27", + "size": 2472, + "subdir": "linux-64", + "timestamp": 1633948426128, + "version": "0.0.40" + }, + "_mutex_mxnet-0.0.50-openblas.conda": { + "build": "openblas", + "build_number": 0, + "depends": [], + "md5": "4ed0273943d61fca83414def35c0becb", + "name": "_mutex_mxnet", + "sha256": "521aab6c4d99e4ac99c6ec9c971c9d597f7b3c534802a9792f2138a6358ea5d0", + "size": 9617, + "subdir": "linux-64", + "timestamp": 1665585850437, + "version": "0.0.50" + }, + "_openmp_mutex-5.1-1_gnu.conda": { + "build": "1_gnu", + "build_number": 0, + "constrains": [ + "openmp_impl 9999" + ], + "depends": [ + "_libgcc_mutex 0.1 main", + "libgomp >=7.5.0" + ], + "license": "BSD-3-Clause", + "md5": "71d281e9c2192cb3fa425655a8defb85", + "name": "_openmp_mutex", + "sha256": "576011048d23f2e03372263493c5529f802286ff53e8426df99a5b11cc2572f3", + "size": 21315, + "subdir": "linux-64", + "timestamp": 1652859733309, + "version": "5.1" + }, + "_py-xgboost-mutex-1.0-gpu_0.conda": { + "build": "gpu_0", + "build_number": 0, + "depends": [], + "md5": "9ffe07435e26556b6974d42beac4a6e3", + "name": "_py-xgboost-mutex", + "sha256": "cfbb9b8060e5f1cade9bcbbf2ac77e0f75440525840afe7f827b98637de14b6d", + "size": 7583, + "subdir": "linux-64", + "timestamp": 1530223592998, + "version": "1.0" + }, + "_py-xgboost-mutex-2.0-cpu_0.conda": { + "build": "cpu_0", + "build_number": 0, + "depends": [], + "md5": "679b6a89372923b19b87392d0c01e79e", + "name": "_py-xgboost-mutex", + "sha256": "70f0b890345226792f21553ed123d2cc6a7b10ad14da05359a4973b2fbe33e1c", + "size": 8880, + "subdir": "linux-64", + "timestamp": 1530218242088, + "version": "2.0" + }, + "_pytorch_select-0.1-cpu_0.conda": { + "build": "cpu_0", + "build_number": 0, + "depends": [], + "md5": "1ee08ed0f245ff0fad27d2227f0fc974", + "name": "_pytorch_select", + "sha256": "f66d6a14a2a5643a4bfcb80bb7cdd9e570dc9bf82511ea26014964c76cb27285", + "size": 2575, + "subdir": "linux-64", + "timestamp": 1566845455257, + "track_features": "pytorch_cpuonly", + "version": "0.1" + }, + "_pytorch_select-0.2-gpu_0.conda": { + "build": "gpu_0", + "build_number": 0, + "depends": [], + "md5": "65305a8912df0bae8ed3f815fcebc853", + "name": "_pytorch_select", + "sha256": "fb459b90820ebb8e12123d3c3f02289fa68e90f501468591b3a577ddcd91a4c1", + "size": 2559, + "subdir": "linux-64", + "timestamp": 1566845453862, + "version": "0.2" + }, + "_r-mutex-1.0.0-anacondar_1.conda": { + "build": "anacondar_1", + "build_number": 1, + "depends": [], + "license": "BSD", + "md5": "0f61143f2321902658c42f3016bc1dd7", + "name": "_r-mutex", + "sha256": "feecdc69b852753c76f2ccfa6037ba9c72c6aa7d6e157d594d5e24bf090e9136", + "size": 2445, + "subdir": "linux-64", + "timestamp": 1653520834377, + "version": "1.0.0" + }, + "_r-xgboost-mutex-2.0-cpu_0.conda": { + "build": "cpu_0", + "build_number": 0, + "depends": [], + "license": "Apache-2.0", + "md5": "7c48343e41bda892623cad45b03fae11", + "name": "_r-xgboost-mutex", + "sha256": "38ecb5b5149d99e623e598299eca020dda3bffd721e331683537c26751ed47d3", + "size": 14918, + "subdir": "linux-64", + "timestamp": 1659549251616, + "version": "2.0" + }, + "_tflow_1100_select-0.0.1-gpu.conda": { + "build": "gpu", + "build_number": 0, + "depends": [], + "md5": "a0bf3bc0a49636eeb40212bea3bc1797", + "name": "_tflow_1100_select", + "sha256": "4560d96ce5e5f2d49afc3dcff2b0c330913e4d631c2b9f4e198f3baef73573ea", + "size": 2423, + "subdir": "linux-64", + "timestamp": 1534870922091, + "version": "0.0.1" + }, + "_tflow_1100_select-0.0.2-eigen.conda": { + "build": "eigen", + "build_number": 0, + "depends": [], + "md5": "67ff7a571b1fe520bf2aded9d73efb00", + "name": "_tflow_1100_select", + "sha256": "990d7ef292812d0f4e4b5523cfac4634e7ed48eb2921f37fe776b78ebb2a43cb", + "size": 2436, + "subdir": "linux-64", + "timestamp": 1534870923651, + "version": "0.0.2" + }, + "_tflow_1100_select-0.0.3-mkl.conda": { + "build": "mkl", + "build_number": 0, + "depends": [], + "md5": "5dd33a991bb84186a4eb66528730f18a", + "name": "_tflow_1100_select", + "sha256": "da0d529571c18592e1b4bf2367b9b00da789d63ad30a560a0ddef17760f19e36", + "size": 2424, + "subdir": "linux-64", + "timestamp": 1534870925081, + "version": "0.0.3" + }, + "_tflow_180_select-1.0-gpu.conda": { + "build": "gpu", + "build_number": 0, + "depends": [], + "md5": "974aa6162e5dbf7e8c3c3a86ca3d17ba", + "name": "_tflow_180_select", + "sha256": "dd69ca47d5fcd26c5788bc704549e6d7eea1e89f7aafe144a2d2fd8b2838e2dd", + "size": 2923, + "subdir": "linux-64", + "timestamp": 1527093815212, + "version": "1.0" + }, + "_tflow_180_select-2.0-mkl.conda": { + "build": "mkl", + "build_number": 0, + "depends": [], + "md5": "7e8e3577dd5c390fcb71f3890e115100", + "name": "_tflow_180_select", + "sha256": "c3f7d6564416f61a3c5834ed9da64f93a54d78ef0fb8de3042841d1e0188dee7", + "size": 2924, + "subdir": "linux-64", + "timestamp": 1527093812314, + "version": "2.0" + }, + "_tflow_180_select-3.0-eigen.conda": { + "build": "eigen", + "build_number": 0, + "depends": [], + "md5": "85e064d4a982bc2b3c5b6a6296f02a8d", + "name": "_tflow_180_select", + "sha256": "c488314bdafc0545f408db153a6304f77fe5babd6b3d3310d75f6e16cd2edd9f", + "size": 2922, + "subdir": "linux-64", + "timestamp": 1527093815183, + "version": "3.0" + }, + "_tflow_190_select-0.0.1-gpu.conda": { + "build": "gpu", + "build_number": 0, + "depends": [], + "md5": "9cf46b0ea0aa24536a751fc64762591b", + "name": "_tflow_190_select", + "sha256": "64e08d94d9faf29ac73fd0c1afc9f978c65456f25ba5c723b551cb63353d975a", + "size": 2406, + "subdir": "linux-64", + "timestamp": 1532469780564, + "version": "0.0.1" + }, + "_tflow_190_select-0.0.2-eigen.conda": { + "build": "eigen", + "build_number": 0, + "depends": [], + "md5": "073042442b5f8fcf92f1b455c00db7b8", + "name": "_tflow_190_select", + "sha256": "2f9e519748fe6184a6eb43c4b08714417eae565771c03a52eb959f47fec35146", + "size": 2407, + "subdir": "linux-64", + "timestamp": 1532469783493, + "version": "0.0.2" + }, + "_tflow_190_select-0.0.3-mkl.conda": { + "build": "mkl", + "build_number": 0, + "depends": [], + "md5": "d74b6c1a84d0070c26815cc19c48b078", + "name": "_tflow_190_select", + "sha256": "d818acfde0529cef9fa0ced4b17b18231303b18ba59322db84e762c6c2510a3d", + "size": 2410, + "subdir": "linux-64", + "timestamp": 1532469781990, + "version": "0.0.3" + }, + "_tflow_select-1.1.0-gpu.conda": { + "build": "gpu", + "build_number": 0, + "depends": [], + "md5": "33a43c6d652350d055a06d45e3f5195c", + "name": "_tflow_select", + "sha256": "69f9e33eaffa91bac576b6cba01fa3f78db9c1d0af71b1bd4475bf57dcb4dfae", + "size": 2425, + "subdir": "linux-64", + "timestamp": 1538592487387, + "version": "1.1.0" + }, + "_tflow_select-1.2.0-mkl.conda": { + "build": "mkl", + "build_number": 0, + "depends": [], + "md5": "8477f59b71c15ef59d9cecf6f63adccb", + "name": "_tflow_select", + "sha256": "576eefbd8613bc609a850e15766f6f74fd3cb51e5712331764c3efdcbb08539e", + "size": 2433, + "subdir": "linux-64", + "timestamp": 1538592488112, + "version": "1.2.0" + }, + "_tflow_select-1.3.0-eigen.conda": { + "build": "eigen", + "build_number": 0, + "depends": [], + "md5": "aa5692c246d4fce723f70830f05735af", + "name": "_tflow_select", + "sha256": "2a0dc77f9d641e4e909c3f2a6fba3594993ff16e3729a43d926bcc30b221526f", + "size": 2437, + "subdir": "linux-64", + "timestamp": 1538592490308, + "version": "1.3.0" + }, + "_tflow_select-2.1.0-gpu.conda": { + "build": "gpu", + "build_number": 0, + "depends": [], + "md5": "1b1de4b8b5bab444dc262a42f136a097", + "name": "_tflow_select", + "sha256": "feb29d87498fe8b9444fa95753d06a13537ebde5788ad7070f92c6ce27f8bad3", + "size": 2433, + "subdir": "linux-64", + "timestamp": 1538592489581, + "version": "2.1.0" + }, + "_tflow_select-2.2.0-eigen.conda": { + "build": "eigen", + "build_number": 0, + "depends": [], + "md5": "3e1fbac18e9970d03968787a1bf89ffa", + "name": "_tflow_select", + "sha256": "b99d115c4e6ee93e724f83d440602f508dd97eccfbc6442882a2f4a0ddd73ac8", + "size": 2436, + "subdir": "linux-64", + "timestamp": 1538592488840, + "version": "2.2.0" + }, + "_tflow_select-2.3.0-eigen.conda": { + "build": "eigen", + "build_number": 0, + "depends": [], + "md5": "3faaff08cc913172ee9353d22279a808", + "name": "_tflow_select", + "sha256": "101cc75956566db271c44b9563d8b338f2070f5779f92bc0eda69f9cf72d9204", + "size": 2562, + "subdir": "linux-64", + "timestamp": 1604315720983, + "version": "2.3.0" + }, + "_tflow_select-2.3.0-mkl.conda": { + "build": "mkl", + "build_number": 0, + "depends": [], + "md5": "bae8f1f0e1eea557cec5928eb603328d", + "name": "_tflow_select", + "sha256": "4bfc1bf2abe66817eeeb55cbd3bdd8d8110b9ff7a7ca1539af77e1fad4fe051c", + "size": 2430, + "subdir": "linux-64", + "timestamp": 1538592486542, + "version": "2.3.0" + }, + "abseil-cpp-20200225.2-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d1ec671f63438c0b061f8d12b04feef6", + "name": "abseil-cpp", + "sha256": "1851caa3febe52ef9f59835f317219f3fa6bf3a6712c93b81d72ddc19af5712c", + "size": 885009, + "subdir": "linux-64", + "timestamp": 1607137388014, + "version": "20200225.2" + }, + "abseil-cpp-20200923.2-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "35b259f3e464379f3d69260d7eb1f5de", + "name": "abseil-cpp", + "sha256": "9dafd33ee74b1d47811eb79ef68040b3a78995c0ed2d9b0cc510476ad4a993cc", + "size": 944977, + "subdir": "linux-64", + "timestamp": 1607091227580, + "version": "20200923.2" + }, + "abseil-cpp-20200923.3-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2fcb8edd9be03f87bfa09078bb6471ff", + "name": "abseil-cpp", + "sha256": "e7d508901b5af32275d74085a926ddbbed86c62caa9b30e0af13794cc4b14616", + "size": 941373, + "subdir": "linux-64", + "timestamp": 1611167716798, + "version": "20200923.3" + }, + "abseil-cpp-20210324.2-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "37f4921a499712f31b56077e6c4647bc", + "name": "abseil-cpp", + "sha256": "050558633eaba82231e337b5da05e3db30ab77ed187e11d6184100eefacff6b4", + "size": 988027, + "subdir": "linux-64", + "timestamp": 1622571748956, + "version": "20210324.2" + }, + "abseil-cpp-20211102.0-hd4dd3e8_0.conda": { + "build": "hd4dd3e8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=8.4.0", + "libstdcxx-ng >=8.4.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6c6164c998c0b31113d569f7788a66aa", + "name": "abseil-cpp", + "sha256": "87989e8288487785de00bfc422b61374c2dff1793df94ec3cda7a983a97a269d", + "size": 1044586, + "subdir": "linux-64", + "timestamp": 1652382888447, + "version": "20211102.0" + }, + "absl-py-0.1.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "645649cdb101fe20addf85db6fe1fbe0", + "name": "absl-py", + "sha256": "35666b0a296b99e5460ca9b7868e3d29d34058fd56480a2288a488a6f86e570c", + "size": 128736, + "subdir": "linux-64", + "timestamp": 1517610163929, + "version": "0.1.10" + }, + "absl-py-0.1.10-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0658684ba670e985ecf2f7d922f25195", + "name": "absl-py", + "sha256": "31fb01be7f105b7799f332ed75678835cf6a9ebe8beca20f110bcb93572ed3ef", + "size": 133302, + "subdir": "linux-64", + "timestamp": 1517610182895, + "version": "0.1.10" + }, + "absl-py-0.1.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "366bffffc73668849d035a73b507390f", + "name": "absl-py", + "sha256": "8385531d787fb10cde6e3035906bb00f47924d2bf5b930d9b2a5e38f54d95b28", + "size": 132318, + "subdir": "linux-64", + "timestamp": 1517610182992, + "version": "0.1.10" + }, + "absl-py-0.1.13-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b99ba5ad4a96e62d5d2e591667f576e1", + "name": "absl-py", + "sha256": "0e0093e31efbd7ccb04094827e44cb4b98177a8b5633fc24bfd27d0c57d3d5b7", + "size": 131904, + "subdir": "linux-64", + "timestamp": 1523902724946, + "version": "0.1.13" + }, + "absl-py-0.1.13-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0938d8e18a7e29bae5bab1dce54587a0", + "name": "absl-py", + "sha256": "6b01e5d515259344b9ad18c6b301cf7efe6a7c6326cc7a259b7a9f753ec0826c", + "size": 134207, + "subdir": "linux-64", + "timestamp": 1523902774758, + "version": "0.1.13" + }, + "absl-py-0.1.13-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8aa6824c3e88b1817c486666b5d274c0", + "name": "absl-py", + "sha256": "62f0dd1e1bb958a0ee05ee6af794b090fbd69f71a93d92894eb93ba066b3da0e", + "size": 130852, + "subdir": "linux-64", + "timestamp": 1523902774784, + "version": "0.1.13" + }, + "absl-py-0.10.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "33ba938e202927d537448942496d644c", + "name": "absl-py", + "sha256": "9379ed3db0f465a167bf6b6e1a6163fefc94d4187f8e1e8fd4cc7f8f928bfe94", + "size": 172117, + "subdir": "linux-64", + "timestamp": 1600297543935, + "version": "0.10.0" + }, + "absl-py-0.10.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "00b5262c4a68f24b013962027934c674", + "name": "absl-py", + "sha256": "711ee77a84c365aeadec3f44f993eed90f6a5de54b7ecd56828d3e2188815628", + "size": 172637, + "subdir": "linux-64", + "timestamp": 1600297556287, + "version": "0.10.0" + }, + "absl-py-0.10.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "919333074be5c752043cde235ee1e07c", + "name": "absl-py", + "sha256": "6e84632debe91f06ee006688eaf16f159f47ebbf1ebe7925a53317c3dd6c19fc", + "size": 176363, + "subdir": "linux-64", + "timestamp": 1600297549477, + "version": "0.10.0" + }, + "absl-py-0.11.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a2f5fd2c4e9dd08ac72785eafa0ad58b", + "name": "absl-py", + "sha256": "99fafd85980d1062e45dc11c964b58b2b0a761fc0e4cf0c5cf270d2ba3234608", + "size": 172642, + "subdir": "linux-64", + "timestamp": 1603893156544, + "version": "0.11.0" + }, + "absl-py-0.11.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "09f4dc0330b1add075fc84d67149ab99", + "name": "absl-py", + "sha256": "ef470bf44fdd079c5916ffd029e66f699093adbe6741177fd3c1ffeb83bf2777", + "size": 175883, + "subdir": "linux-64", + "timestamp": 1603893166339, + "version": "0.11.0" + }, + "absl-py-0.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4c8ed8acea46b73fcde5a16334ade6e6", + "name": "absl-py", + "sha256": "4aede18b1dc277355c9c0bed24cf77c0f1c4fe202663aa00cea2eef0885d7627", + "size": 176994, + "subdir": "linux-64", + "timestamp": 1603893134597, + "version": "0.11.0" + }, + "absl-py-0.12.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "337bf446ca6c715c08aff7df2bdb844a", + "name": "absl-py", + "sha256": "38791430a43528404d1b10106c5d5551400d9aa6a48994d8e6d4265dcfb82cae", + "size": 180538, + "subdir": "linux-64", + "timestamp": 1642495509143, + "version": "0.12.0" + }, + "absl-py-0.12.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f83f476a47fa8aab8d7d3d8336fce281", + "name": "absl-py", + "sha256": "256b450176ae9b16d2de0f0f05f5db47c17361b570576483fe11233b66d5cea0", + "size": 174931, + "subdir": "linux-64", + "timestamp": 1615411231364, + "version": "0.12.0" + }, + "absl-py-0.12.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b3cdd226908ac88cd18aef5638c68767", + "name": "absl-py", + "sha256": "16b1b2b845ac6f1c6ed0dc1686ea7e96ece2454bd55049aceb7bedd21cdfefdb", + "size": 175413, + "subdir": "linux-64", + "timestamp": 1615411238537, + "version": "0.12.0" + }, + "absl-py-0.12.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4f2cef4a53f00a2b9e098f71ac89e411", + "name": "absl-py", + "sha256": "7012e4731231a108950a76e3d8533f864b8ee6515912f38acfb1c47e75c6c08e", + "size": 176105, + "subdir": "linux-64", + "timestamp": 1615411237821, + "version": "0.12.0" + }, + "absl-py-0.12.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7b56aaf17e542798dd95457a2c4a3485", + "name": "absl-py", + "sha256": "201fa605bda9b199133f029832cbd1a8e605686f10e9a6a1a6907e9fd742bac3", + "size": 176121, + "subdir": "linux-64", + "timestamp": 1615410702925, + "version": "0.12.0" + }, + "absl-py-0.13.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6a301bdbd0dca8fa0c82a785747f00d4", + "name": "absl-py", + "sha256": "c81c8c762ccb001d948a676d4f86a13815f4b43fbf7b5f684c87d2ead0a2f007", + "size": 180196, + "subdir": "linux-64", + "timestamp": 1623867088033, + "version": "0.13.0" + }, + "absl-py-0.13.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "59a06b399615be898011ee15b8794d5b", + "name": "absl-py", + "sha256": "ee7b9a058c0a5e498a569efc21f63297eb97bdd36f0defaf3ee239747790fc24", + "size": 177514, + "subdir": "linux-64", + "timestamp": 1623861431925, + "version": "0.13.0" + }, + "absl-py-0.13.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "059a06c866c0e849140cb8aedafe1aae", + "name": "absl-py", + "sha256": "b3f94feb728e4fe9edc29bf643ca5ea23ba69a19290468df2160c79c16af9288", + "size": 181793, + "subdir": "linux-64", + "timestamp": 1623867255364, + "version": "0.13.0" + }, + "absl-py-0.13.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "90bd01ae4d6d0ec6890d51071b545597", + "name": "absl-py", + "sha256": "31698c764028eba266282a9a8026c2b185a2ffda5157864c79bd3bd2b050fa1a", + "size": 181854, + "subdir": "linux-64", + "timestamp": 1623867269514, + "version": "0.13.0" + }, + "absl-py-0.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8f1059166640366aba239bb577368fdc", + "name": "absl-py", + "sha256": "aa089a421e972d086e38fcad26e5de3c619afdb897067bb8c20634d8a7e5c114", + "size": 135303, + "subdir": "linux-64", + "timestamp": 1524512668988, + "version": "0.2.0" + }, + "absl-py-0.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ff99a9f935e2b6b909d84c2e49b900f2", + "name": "absl-py", + "sha256": "f73f91ab858276146eb66b03ecae56744a8846fb72439bf29df7b0eb57f13f5d", + "size": 139917, + "subdir": "linux-64", + "timestamp": 1524512677080, + "version": "0.2.0" + }, + "absl-py-0.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "db476e1f39c4e6b9526ea0f1754c7e95", + "name": "absl-py", + "sha256": "a2924f0a1cac7f67648391cabc277b7ce62557fa24ba663698d1586c6ed74cb6", + "size": 138891, + "subdir": "linux-64", + "timestamp": 1524512676165, + "version": "0.2.0" + }, + "absl-py-0.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0f4241c24caf99fe610a1e1c13d64c40", + "name": "absl-py", + "sha256": "b37916b2ea8277eb2864a45b00434fc52f98325d36afcc5477a3426d78f6c79d", + "size": 135656, + "subdir": "linux-64", + "timestamp": 1526931332258, + "version": "0.2.1" + }, + "absl-py-0.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3ab31c26634da24fe4f7eadd6ecd66d5", + "name": "absl-py", + "sha256": "b3115185ce47a0d5de62604b18085e41ff854e162f192307ae8160ff9043dcb2", + "size": 140262, + "subdir": "linux-64", + "timestamp": 1526931343118, + "version": "0.2.1" + }, + "absl-py-0.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a5d81a38d6d6e294b3f5e63ac7e5ad13", + "name": "absl-py", + "sha256": "8e44167ee419b59ac5460f6c630e2898c67fa17e0ec91bdb9131faa6450832d4", + "size": 139259, + "subdir": "linux-64", + "timestamp": 1526931309606, + "version": "0.2.1" + }, + "absl-py-0.2.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "463e95b177267fd8cc1c36b466d46fff", + "name": "absl-py", + "sha256": "288adfeab7535702d1804924f10fe0f844751179742151591c21737a061fee10", + "size": 135841, + "subdir": "linux-64", + "timestamp": 1527631426805, + "version": "0.2.2" + }, + "absl-py-0.2.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f6d3b6bb48b2ece5307657310c713f2a", + "name": "absl-py", + "sha256": "b41fa447985788b15d2bcfd2907b1e003e1e55dfa96695973f58ff05ca6db817", + "size": 137877, + "subdir": "linux-64", + "timestamp": 1527631612527, + "version": "0.2.2" + }, + "absl-py-0.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "27ac5882aa19f3f376d5b0a4ad2f33b6", + "name": "absl-py", + "sha256": "32463d20e97f8d6f1584034525e034e6a91aaffa5f69894defb0feb7a59cf9b3", + "size": 136972, + "subdir": "linux-64", + "timestamp": 1527631590997, + "version": "0.2.2" + }, + "absl-py-0.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f8c8b872ced7cec383f5d23ee7e8cb7e", + "name": "absl-py", + "sha256": "7f3589042b4f98a22f084a0c77ea46ba991fcc3515268eba4ba5b8142ef817eb", + "size": 137234, + "subdir": "linux-64", + "timestamp": 1530735418283, + "version": "0.2.2" + }, + "absl-py-0.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "18ec697d3c404464ff01500f85e645fe", + "name": "absl-py", + "sha256": "f3a87baa88c9efbbd714b85ef0b6047524492d729aa391b22b869bb655a00495", + "size": 137086, + "subdir": "linux-64", + "timestamp": 1532554034071, + "version": "0.3.0" + }, + "absl-py-0.3.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ff7701ee74c0b1b4f85dfde41e665596", + "name": "absl-py", + "sha256": "5cece0d9992bb60f268b779824c75448d4145878e0c0199a7b651bfd3f230d33", + "size": 137076, + "subdir": "linux-64", + "timestamp": 1534351910968, + "version": "0.3.0" + }, + "absl-py-0.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "86feb26beee572d0a4688631e8a695e1", + "name": "absl-py", + "sha256": "10c627f8d122baf6523081eb0ae0a1434744552b831de16b88617f77065e9f4c", + "size": 141762, + "subdir": "linux-64", + "timestamp": 1532554055802, + "version": "0.3.0" + }, + "absl-py-0.3.0-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1079027ee51948ba838f2916c32c9fa7", + "name": "absl-py", + "sha256": "cc41503d17a8e9f4a891dd865767982f475d8748b0503d2913b345e6b44e6783", + "size": 139191, + "subdir": "linux-64", + "timestamp": 1534351934157, + "version": "0.3.0" + }, + "absl-py-0.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e2d6ebc8166cdc32f42f38441adfdf1d", + "name": "absl-py", + "sha256": "97438f4f7f5409fbdef65251a5ed4f968b9445983aefa715eca3cda983107c50", + "size": 140674, + "subdir": "linux-64", + "timestamp": 1532554003878, + "version": "0.3.0" + }, + "absl-py-0.3.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4d0e858025f00705ab611083e33381c8", + "name": "absl-py", + "sha256": "0973afae4399f736af53e8150cc64dcf89ae8105f3dcaead9ba3a37467fe3d5a", + "size": 138132, + "subdir": "linux-64", + "timestamp": 1534351958094, + "version": "0.3.0" + }, + "absl-py-0.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2071c7ea3e32252737299fc764a476e3", + "name": "absl-py", + "sha256": "73e99f3fd496a671c0f405ab7e5769da347e8cc92cd63b1064cb554d0d41744e", + "size": 140961, + "subdir": "linux-64", + "timestamp": 1532553968138, + "version": "0.3.0" + }, + "absl-py-0.3.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5a70d3da2e8a0f74bd9f7c053d73f883", + "name": "absl-py", + "sha256": "bbefbdb45f01128aa0e957e6c4769b1fd0879ace404e62d1a41fb377e84bc3f6", + "size": 138523, + "subdir": "linux-64", + "timestamp": 1534351888574, + "version": "0.3.0" + }, + "absl-py-0.4.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "38c6aad008057cb3f0b38770310233b1", + "name": "absl-py", + "sha256": "6a34640b6fe8189b0dc58734e20b65a7028f471b017e04f818bff92eb7b34d5a", + "size": 143582, + "subdir": "linux-64", + "timestamp": 1534793387737, + "version": "0.4.0" + }, + "absl-py-0.4.0-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "08f8e3199a26cdd09a3956bd05acc81a", + "name": "absl-py", + "sha256": "e0a15e49933a2a66cf2cf04fef9763542e892676a5d3475e3315d577b2fafea0", + "size": 148757, + "subdir": "linux-64", + "timestamp": 1534793449693, + "version": "0.4.0" + }, + "absl-py-0.4.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "af3ebea1c31679a4f747ad6eddd23c33", + "name": "absl-py", + "sha256": "ba2dcea2cd916bd9d27bd97f704e7bf217a17aaee96e468bd79aec307d8c75c5", + "size": 147662, + "subdir": "linux-64", + "timestamp": 1534793364072, + "version": "0.4.0" + }, + "absl-py-0.4.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3d8cd3b625253ce2e52dc4d32c2fb008", + "name": "absl-py", + "sha256": "0f3beb0123881ec797cac4f1c0ac7a6c58b1b759c8117006c0744f64b7b8ebb1", + "size": 145248, + "subdir": "linux-64", + "timestamp": 1534793470303, + "version": "0.4.0" + }, + "absl-py-0.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "49b49e9bd74f041cca41e3907e4eaad5", + "name": "absl-py", + "sha256": "8f09fb08b319fb4bd655539cdbc2ad2fe680f2f90ecb87706fad40c0639c0ab8", + "size": 146670, + "subdir": "linux-64", + "timestamp": 1536102596908, + "version": "0.4.1" + }, + "absl-py-0.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "35ffb2d8d31b8e5da4d34b1dec6b0bbd", + "name": "absl-py", + "sha256": "5e25ea01b23eea53f9e65549c3cf7a8b9caa9ffb19ee1426bf4469c3f7584b1a", + "size": 146486, + "subdir": "linux-64", + "timestamp": 1536102605750, + "version": "0.4.1" + }, + "absl-py-0.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "afc7f97daf1aac2a5ccb9b3445236ffa", + "name": "absl-py", + "sha256": "5b6118090fe2a56f8bfeb6676e374a7b0585e9f31d44fc82bd18a05fb005eccc", + "size": 145526, + "subdir": "linux-64", + "timestamp": 1536102555868, + "version": "0.4.1" + }, + "absl-py-0.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fe01036a5388a57f813e814ab6ad5026", + "name": "absl-py", + "sha256": "ab5c2b33a20b7b18fb4e1681e08b7bf80313053795ab9f4abbdbe2fbed966066", + "size": 145781, + "subdir": "linux-64", + "timestamp": 1536102643902, + "version": "0.4.1" + }, + "absl-py-0.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c121fd05afa80d8d8df09c3617460377", + "name": "absl-py", + "sha256": "0e363a43e9c90484f9b791d5f7e5d71abe4642a5ff47598680422a176eb1b5c7", + "size": 148441, + "subdir": "linux-64", + "timestamp": 1538176252869, + "version": "0.5.0" + }, + "absl-py-0.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0005936931050d298ae5c3699f64ac8c", + "name": "absl-py", + "sha256": "8dff7aec86449f9c25779517afe6fbf79e1e7ff43a0342e8c16a4e161bb85811", + "size": 147244, + "subdir": "linux-64", + "timestamp": 1538176277723, + "version": "0.5.0" + }, + "absl-py-0.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0cf944da7997b109bd07f7cf8199085c", + "name": "absl-py", + "sha256": "b60862ea0808fcbf9918c858a4a1b673d2909ba3562eaf79779313088dd02671", + "size": 150357, + "subdir": "linux-64", + "timestamp": 1538176263609, + "version": "0.5.0" + }, + "absl-py-0.6.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "42786d93849ae97b1c8e07d62883c94f", + "name": "absl-py", + "sha256": "4ab2b7ac9da79c6446839978f113282c182db2bc7aace7e1dfe9279362240c19", + "size": 154276, + "subdir": "linux-64", + "timestamp": 1540955260491, + "version": "0.6.1" + }, + "absl-py-0.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "558162bf4b325382f031ac53bd20613e", + "name": "absl-py", + "sha256": "c8f7d3691a7ec3751606735f09bc451ae56d110a1fe2bfa9cde0765fef854703", + "size": 156085, + "subdir": "linux-64", + "timestamp": 1540955331425, + "version": "0.6.1" + }, + "absl-py-0.6.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "db97158191b7eb459a921f3d311df3dd", + "name": "absl-py", + "sha256": "db45707c8f2004e4a13de89c905058217a11a5962ab34904143df15e9be898ef", + "size": 152899, + "subdir": "linux-64", + "timestamp": 1540955317795, + "version": "0.6.1" + }, + "absl-py-0.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1ee14e929a7a1eea68d25525498bb7e8", + "name": "absl-py", + "sha256": "53f158baede069d405c994b927b8682dd788845a3b37c7555aa2c31a5060ebe5", + "size": 158728, + "subdir": "linux-64", + "timestamp": 1547744445261, + "version": "0.7.0" + }, + "absl-py-0.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5ecd3c7d6fcc74be0e781d7e051f40cf", + "name": "absl-py", + "sha256": "23258ea80a366c0f1b8b46853205414e97d0a64842e6ae6c18d4871c8ca027d6", + "size": 157064, + "subdir": "linux-64", + "timestamp": 1547744495640, + "version": "0.7.0" + }, + "absl-py-0.7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "53c9bc048b03b4c7d21cc1af1e54f3df", + "name": "absl-py", + "sha256": "d6766040dbe44098aa6f0b01c0a5a853f6f2bac5be90427e46e0ae04b7f6a16d", + "size": 160896, + "subdir": "linux-64", + "timestamp": 1547744492366, + "version": "0.7.0" + }, + "absl-py-0.7.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3383a815d28f2182ae7f5f91213de04a", + "name": "absl-py", + "sha256": "b1aee8e950b0d8a2c8f20ffd9ff9f6233c86852142a74912f48c25521bce1fe0", + "size": 156662, + "subdir": "linux-64", + "timestamp": 1556061050792, + "version": "0.7.1" + }, + "absl-py-0.7.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0f7babcc1cabd30ccadcb8668dbf9eeb", + "name": "absl-py", + "sha256": "3f3c7102a63eb12cb347bfff70a741309a57a60be61a56a6c301604e6c97cbd6", + "size": 161242, + "subdir": "linux-64", + "timestamp": 1556061208650, + "version": "0.7.1" + }, + "absl-py-0.7.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "453192258df6db9ac65e49e21a528d4f", + "name": "absl-py", + "sha256": "e6355eb4d6ced14ab5e30808f187148d59f458ad110c87b3bd2528d25844420f", + "size": 161621, + "subdir": "linux-64", + "timestamp": 1556061174938, + "version": "0.7.1" + }, + "absl-py-0.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c9c1afed5be1f5ab2e7cab97d3a377ef", + "name": "absl-py", + "sha256": "995f568f84541befaca3d72fb91d698bb602baf50cee9e0518f26c86cbfb1e86", + "size": 163496, + "subdir": "linux-64", + "timestamp": 1569267547648, + "version": "0.8.0" + }, + "absl-py-0.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "572e38a28c4c696c29aa56756394ba20", + "name": "absl-py", + "sha256": "85c1714db5a7fc35f6bfbe871c5231b187346fa962a8c13069bd49b2dcdd7148", + "size": 164829, + "subdir": "linux-64", + "timestamp": 1569267548539, + "version": "0.8.0" + }, + "absl-py-0.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ed62b39c50011ccbb9a749a0fba86f0b", + "name": "absl-py", + "sha256": "37d1d5181ed700a8cd2b547b990d85b46e0d295e2402b1b7e7a0cc21d4d45f0b", + "size": 168248, + "subdir": "linux-64", + "timestamp": 1569267546992, + "version": "0.8.0" + }, + "absl-py-0.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "22276054d4eb8d2e390c8bab4c7346bb", + "name": "absl-py", + "sha256": "c2ff3c977dbc55b79ae3920f1f4847eb38d821d28d93174524083a3143ea4641", + "size": 166873, + "subdir": "linux-64", + "timestamp": 1573224863087, + "version": "0.8.1" + }, + "absl-py-0.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0995fe881d14a4c3a902eff02fce4759", + "name": "absl-py", + "sha256": "deeeb6546753a12011a2de0e99a6df2faf7c8e151a38cd3b590dc9dc828ca9b6", + "size": 168226, + "subdir": "linux-64", + "timestamp": 1573224871696, + "version": "0.8.1" + }, + "absl-py-0.8.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6d57762cc48a114f94d5c617b96ab71e", + "name": "absl-py", + "sha256": "02117931ea82dcef3fa78064bcb7757a4c6dd52f05cd07fb2d3ca4a0d6b195e1", + "size": 168554, + "subdir": "linux-64", + "timestamp": 1573224871352, + "version": "0.8.1" + }, + "absl-py-0.8.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "62ae3da432502e49bef2e172599f4165", + "name": "absl-py", + "sha256": "8b056536cfb0c49a7e21f826e84d74a1fa929ffadf3fd2c9fee2191578eafe83", + "size": 169510, + "subdir": "linux-64", + "timestamp": 1573224879094, + "version": "0.8.1" + }, + "absl-py-0.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f4494927453ce55efee7fb5a0c692f0d", + "name": "absl-py", + "sha256": "6b95c43715358fa4e76f317adf621f54d927a00c2f8996461bb30fbe065b298d", + "size": 171106, + "subdir": "linux-64", + "timestamp": 1581610019179, + "version": "0.9.0" + }, + "absl-py-0.9.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "48d3a3c7e31d4215fd43fec81ff8f011", + "name": "absl-py", + "sha256": "3015b00eaec97961afd9ea65ab1e5b2361d9215d3095fdcdb5e22b28e5861bbd", + "size": 171166, + "subdir": "linux-64", + "timestamp": 1581610014431, + "version": "0.9.0" + }, + "absl-py-0.9.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c7df73b6983bb9b771ef0b54492ebbb2", + "name": "absl-py", + "sha256": "202dd9f50e249c6dccf17c29aba237b4fb6d1370ed02d9b92ed1e89b04529520", + "size": 169407, + "subdir": "linux-64", + "timestamp": 1581610028581, + "version": "0.9.0" + }, + "absl-py-1.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4f06f179844f874b6c81d9827864f55b", + "name": "absl-py", + "sha256": "da85f4092d4dbf1b173e25988fa25bffc642215e4806e1b0399abdd2d17db32e", + "size": 172487, + "subdir": "linux-64", + "timestamp": 1666362970875, + "version": "1.3.0" + }, + "absl-py-1.3.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3b71e65ce897a0ea0fc8fa9ebf3255a7", + "name": "absl-py", + "sha256": "d23dd38c73121e27b475eef7bc5bae6e2263bdbd870a76f65678b27f11f55024", + "size": 222036, + "subdir": "linux-64", + "timestamp": 1676838943500, + "version": "1.3.0" + }, + "absl-py-1.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5bebb1a64f04b5b02d6ff93360aa5f5d", + "name": "absl-py", + "sha256": "7a99e332a50fbb3e3c28b0e4e54ffcd3501f496c1d518c40d66573478c3f9492", + "size": 170043, + "subdir": "linux-64", + "timestamp": 1666362997020, + "version": "1.3.0" + }, + "absl-py-1.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e29c9b757f864bad0c7ecdbee58f9088", + "name": "absl-py", + "sha256": "0ea6473cfd8ebb5044f5097f561b038765b79f76b3c188b9bb227431767d0b1e", + "size": 171125, + "subdir": "linux-64", + "timestamp": 1666363048677, + "version": "1.3.0" + }, + "absl-py-1.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a209d7278d2784995cf7e8da4ab0a763", + "name": "absl-py", + "sha256": "eebd808c807e691374e90c8d6686e2671469f2b8450821e3d5d8c985c2f9e983", + "size": 171193, + "subdir": "linux-64", + "timestamp": 1666363023028, + "version": "1.3.0" + }, + "adtk-0.6.2-py310h2f386ee_0.conda": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=17.0", + "pandas >=0.23", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.20", + "statsmodels >=0.9", + "tabulate >=0.8" + ], + "license": "MPL-2.0", + "license_family": "MOZILLA", + "md5": "8262363135553df3615c919454c6ff7a", + "name": "adtk", + "sha256": "7a4ae2b18d3de6c184f1dcddfb4cd8340f924a6207e8972e4dda35879368ed8f", + "size": 94686, + "subdir": "linux-64", + "timestamp": 1677843572621, + "version": "0.6.2" + }, + "adtk-0.6.2-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=17.0", + "pandas >=0.23", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.20", + "statsmodels >=0.9", + "tabulate >=0.8" + ], + "license": "MPL-2.0", + "license_family": "MOZILLA", + "md5": "e50baa11b15de6be7731e5a0bcf9e7db", + "name": "adtk", + "sha256": "b7d6aa26ae21f206b400509904988e505c9296dc4f4f7862f07994869a34d362", + "size": 93752, + "subdir": "linux-64", + "timestamp": 1677843523504, + "version": "0.6.2" + }, + "adtk-0.6.2-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=17.0", + "pandas >=0.23", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.20", + "statsmodels >=0.9", + "tabulate >=0.8" + ], + "license": "MPL-2.0", + "license_family": "MOZILLA", + "md5": "f3877a0c3f3e9c8a18c0d5260bcb3d58", + "name": "adtk", + "sha256": "45eb4b640df23914a436ca5b744c860e23f7c6da364a4eda7b5daae012a7dce8", + "size": 93624, + "subdir": "linux-64", + "timestamp": 1677843620649, + "version": "0.6.2" + }, + "aenum-2.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "363b8620e0c23a6704c86314bfb048e2", + "name": "aenum", + "sha256": "0da217478cdd04fbe936d0cf227f0f9df21ce4f9566a0be8d15ffd76b00d2d1d", + "size": 130107, + "subdir": "linux-64", + "timestamp": 1521779698394, + "version": "2.1.0" + }, + "aenum-2.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9e22742b7ffe0075633ed2bcb37f6d67", + "name": "aenum", + "sha256": "f2f92201a2d0a0b1bbbb466a67cff14bbb9e0237cb42745958c4540e9981a229", + "size": 145264, + "subdir": "linux-64", + "timestamp": 1521779718693, + "version": "2.1.0" + }, + "aenum-2.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e31fc6509908f19caa83a08d7c28670d", + "name": "aenum", + "sha256": "4d8ea180985b07c0a5a73436cf6ca866085adfd118d0df95cbf0758049505b26", + "size": 143932, + "subdir": "linux-64", + "timestamp": 1521779720175, + "version": "2.1.0" + }, + "aenum-2.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0720068901d20215c2b823ee58c9b575", + "name": "aenum", + "sha256": "ae113d52e7cb3d88b262f0c355e5f929f1d3fe8af244321a48d910306cf56eb9", + "size": 134765, + "subdir": "linux-64", + "timestamp": 1526942954855, + "version": "2.1.2" + }, + "aenum-2.1.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2fb9c9a21ba5a3c8124f0029022e490d", + "name": "aenum", + "sha256": "468c9e6663094464d67520d0769bd55b54a721791be1b31d75056ae64f218de7", + "size": 149916, + "subdir": "linux-64", + "timestamp": 1526942971003, + "version": "2.1.2" + }, + "aenum-2.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1ffd88992d31b0ff8585fbea0dcb0f81", + "name": "aenum", + "sha256": "e0995bb63683de270eedb5ed7058fba14a22f8c8bbc71713d3c297b05f4415f2", + "size": 146988, + "subdir": "linux-64", + "timestamp": 1526942974950, + "version": "2.1.2" + }, + "aenum-2.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3fdda11d25781f898938120c3ecc4f68", + "name": "aenum", + "sha256": "dd875e01228745c364f74bf74fd68fdf2c1f86a255a7ef68fe0579782bb683fd", + "size": 147240, + "subdir": "linux-64", + "timestamp": 1530735440335, + "version": "2.1.2" + }, + "aenum-2.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c344dd5e0ee67ceaf3784c246be3ab6b", + "name": "aenum", + "sha256": "c857bf22fff0820859e2d9451abdebb977f6d1129b5c3cc794f44615b650f7b0", + "size": 142789, + "subdir": "linux-64", + "timestamp": 1564763496963, + "version": "2.2.1" + }, + "aenum-2.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3f0e33ffcce336780914a3c32d6f1124", + "name": "aenum", + "sha256": "ff485f580b25e7060b5e29e676969d309ad33a4828e58bf49e7752823519b357", + "size": 158196, + "subdir": "linux-64", + "timestamp": 1564763150156, + "version": "2.2.1" + }, + "aenum-2.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "496cfb174f4ca143f695a868cb3d98af", + "name": "aenum", + "sha256": "49fce8bfd190072ec6d36f5955d2fc9ba06343151dfae683b568b2c5d554d46d", + "size": 156222, + "subdir": "linux-64", + "timestamp": 1564763404229, + "version": "2.2.1" + }, + "aenum-2.2.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b402d3876f92dc1d71f2b49ba9c86841", + "name": "aenum", + "sha256": "a1587050ffffe2a4a761f5fbecb2cb17fab55e756b16735606e6c23331da030a", + "size": 158135, + "subdir": "linux-64", + "timestamp": 1572437488025, + "version": "2.2.1" + }, + "aenum-2.2.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9037293326487d536a46d7a377582b13", + "name": "aenum", + "sha256": "67affd3625bfeec4d06567404ecd0aa8d3ef346e09fd4255ced44c40023168d5", + "size": 162306, + "subdir": "linux-64", + "timestamp": 1600297579287, + "version": "2.2.4" + }, + "aenum-2.2.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "efda1f53589aa0198a002e8a556c72c4", + "name": "aenum", + "sha256": "eac2e3445fcc19f0d5b881edd4f9c841c21bd80dc1027ec3ff6feb7a5d897a6b", + "size": 161803, + "subdir": "linux-64", + "timestamp": 1600297580607, + "version": "2.2.4" + }, + "aenum-2.2.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3fbff875911805b7ed5e2e6c52cd5a74", + "name": "aenum", + "sha256": "c0702cc0d94242a51eab152a8b5c3f4d03ef701625d7b0dff0019ad5762a7f2c", + "size": 164444, + "subdir": "linux-64", + "timestamp": 1600297569228, + "version": "2.2.4" + }, + "aenum-2.2.6-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c073fea7852652e3ed95e07d6e3554f2", + "name": "aenum", + "sha256": "e6613a3f7375d42fe4e321f5e4b884ca5408e962e937de9a56a06d28c359e81a", + "size": 169392, + "subdir": "linux-64", + "timestamp": 1607533542514, + "version": "2.2.6" + }, + "aenum-2.2.6-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff94c2333509a17cd50c90e236de1cb6", + "name": "aenum", + "sha256": "20b0580cd03422ede03eb0f83b9f63fce9f5f3c0f49d9689ab23d87109a03273", + "size": 168726, + "subdir": "linux-64", + "timestamp": 1607533555479, + "version": "2.2.6" + }, + "aenum-2.2.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8eb4dc78f165827b832e7b3ec718f397", + "name": "aenum", + "sha256": "296ac97e48f4ded06077f694dbc728f31295ca85315546a01be0c693aebe9cfb", + "size": 170435, + "subdir": "linux-64", + "timestamp": 1607533554216, + "version": "2.2.6" + }, + "aenum-2.2.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "82ce2e76f6492cecf00c3969a692f9c6", + "name": "aenum", + "sha256": "4fa487ff81c2a7bc749037082c132122f1378af5a1cd48a04ff9c2ca379e594a", + "size": 168977, + "subdir": "linux-64", + "timestamp": 1607533564797, + "version": "2.2.6" + }, + "aenum-3.0.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "becac94d20b944cc0e825aff81dd34d9", + "name": "aenum", + "sha256": "a4863dfd04c7cb997d360147b82f98a360bc4d21c546aa4908bdf50b5ada57d8", + "size": 176651, + "subdir": "linux-64", + "timestamp": 1611690173117, + "version": "3.0.0" + }, + "aenum-3.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "380cb5f2440f80e5307e670ad9c03d9f", + "name": "aenum", + "sha256": "5efe6777ddf509f915780f46cda31e7b001259897e6a726dace6a051f908478d", + "size": 176492, + "subdir": "linux-64", + "timestamp": 1611690179147, + "version": "3.0.0" + }, + "aenum-3.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "753542313f11067c05a8730f68f3edef", + "name": "aenum", + "sha256": "3c29cfaf4926df32f9edfdc1a4f1c3ea64be3a3aac7c8b9234bf0e08ecbc0d78", + "size": 177991, + "subdir": "linux-64", + "timestamp": 1611690179125, + "version": "3.0.0" + }, + "aenum-3.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "92ff9505261bd06d2a1130546131bb5e", + "name": "aenum", + "sha256": "68efc176ddb6dccd9059ddc0c0e1917551a555058c9b0c6012078ffbaade170b", + "size": 177571, + "subdir": "linux-64", + "timestamp": 1611689780619, + "version": "3.0.0" + }, + "aenum-3.1.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f00e2985c2ed094187525a6fa906cd18", + "name": "aenum", + "sha256": "f69d557d2ed7cb1e78a66cc372caf1b217f74b04ffba3d9a67c9dea54fb2a363", + "size": 184922, + "subdir": "linux-64", + "timestamp": 1622112375027, + "version": "3.1.0" + }, + "aenum-3.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1100b244bb90583108e6ec515c5b3178", + "name": "aenum", + "sha256": "f34cf103e10be7c5a61e7255aed06db2fe5fe6201789a791e441c0ba5cd16bc0", + "size": 183247, + "subdir": "linux-64", + "timestamp": 1622112366442, + "version": "3.1.0" + }, + "aenum-3.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b56ed207fa96c1bfcb1265f00e6d89a3", + "name": "aenum", + "sha256": "23eced27881644ce624a7d735d3cbbffde47ccb949979600be19ac2a51bbe690", + "size": 185072, + "subdir": "linux-64", + "timestamp": 1622111602646, + "version": "3.1.0" + }, + "aenum-3.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "53ba15adfb42f1df282f2c09514ea1ba", + "name": "aenum", + "sha256": "ab85af11c3da2039bb0708fb39999cd2ed01cd016aded515746d81f8efe30c1e", + "size": 183863, + "subdir": "linux-64", + "timestamp": 1622107393321, + "version": "3.1.0" + }, + "aenum-3.1.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1230634c5ca1ae8256e393bf53285e06", + "name": "aenum", + "sha256": "76601ae386bf7c9e964409d4bed2f715eaecd86435ffb73f447b733ad0eb013a", + "size": 194992, + "subdir": "linux-64", + "timestamp": 1640788069315, + "version": "3.1.5" + }, + "aenum-3.1.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5043dabb995619983a4c6befe1c370fd", + "name": "aenum", + "sha256": "4563ee64cd82af6992f7a6f9403b1250de3cc1450225207de770e06e2e2e4673", + "size": 262247, + "subdir": "linux-64", + "timestamp": 1676846680211, + "version": "3.1.5" + }, + "aenum-3.1.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "82bb5949b14fba3f01d3307087ef296d", + "name": "aenum", + "sha256": "284c940fef5b5fd632089a0a5419bb6e0c90626ede3a9d0daf406b67d788e75b", + "size": 192525, + "subdir": "linux-64", + "timestamp": 1638535092632, + "version": "3.1.5" + }, + "aenum-3.1.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0818391f76d11c17cf79a5c07b1eb355", + "name": "aenum", + "sha256": "dc44d75391aa8950792e4ef08b27a737c31d990eeb7fa8a71b42bebb5c943678", + "size": 194402, + "subdir": "linux-64", + "timestamp": 1638521819600, + "version": "3.1.5" + }, + "aenum-3.1.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9f1f105b133c5b65824956d37365def6", + "name": "aenum", + "sha256": "8c1f517d186cc053102bbd336b47f6e4f83e383827af2a1d627b2d457415f7b6", + "size": 194241, + "subdir": "linux-64", + "timestamp": 1638535094158, + "version": "3.1.5" + }, + "affine-2.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8e5f4af2d98ebe6331fcb2f7faa8ab07", + "name": "affine", + "sha256": "c9e17df9bb5e45ef65f83688645b1c59499b2263c16cf9e4b829e61b6e60b9b2", + "size": 26993, + "subdir": "linux-64", + "timestamp": 1522080606210, + "version": "2.2.0" + }, + "affine-2.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "910f3c9b8399e707ff476a2bff11ab9e", + "name": "affine", + "sha256": "ff8a7a3957ac262578d9cfa6837fcc6a0982764ce12cbf7e7c5400b08a648550", + "size": 28249, + "subdir": "linux-64", + "timestamp": 1522080637107, + "version": "2.2.0" + }, + "affine-2.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dea30139d7d3cf4d5083f5f9ad50aa7b", + "name": "affine", + "sha256": "211745ee77febcf4b0bdf99696740ad8ec909e73a481b0119f6d42ba4cb8bd0c", + "size": 27924, + "subdir": "linux-64", + "timestamp": 1522080638358, + "version": "2.2.0" + }, + "affine-2.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8bb1f1c034120b81a0a9233968b5b2e9", + "name": "affine", + "sha256": "02dc4b0376b90915077a68decffca78777f2308bf6bdd723840a0dddc09e5bec", + "size": 27414, + "subdir": "linux-64", + "timestamp": 1528984040931, + "version": "2.2.1" + }, + "affine-2.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "33aaab329eeb8a59b1fce96065507174", + "name": "affine", + "sha256": "80afc38c08a7702b90a1eb2132426b511417c511d84e9a09d38ce9e83bf72fa8", + "size": 28340, + "subdir": "linux-64", + "timestamp": 1528984096777, + "version": "2.2.1" + }, + "affine-2.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0964d0b90ae71d3425d4d201b8ef02cc", + "name": "affine", + "sha256": "2747badedc7a6cb7e187690f6d19b4fe2a954f782b22aeca3ece9ef68d15a71f", + "size": 28257, + "subdir": "linux-64", + "timestamp": 1528983947135, + "version": "2.2.1" + }, + "affine-2.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "242d6b0df8ea6e4ab1058b21836a4c3a", + "name": "affine", + "sha256": "6ae3697ca719daa37068aeb7723772f904a125d4f654dc6a44a9893630323010", + "size": 27922, + "subdir": "linux-64", + "timestamp": 1530735462767, + "version": "2.2.1" + }, + "affine-2.2.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ec2ffcde97b3ceda84daba913e30d445", + "name": "affine", + "sha256": "d25c1450d1a63303febff5a5e2e925d2733cbb8a36d805a88640bf3f9f6e4801", + "size": 30552, + "subdir": "linux-64", + "timestamp": 1547221308441, + "version": "2.2.2" + }, + "affine-2.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a8537e71d8a8db8af4b1fd2d2e846940", + "name": "affine", + "sha256": "b19456accc1a56fe8a7ebeccc9f6b811c5861d66e7134f951aa120529758f53d", + "size": 30897, + "subdir": "linux-64", + "timestamp": 1547221373396, + "version": "2.2.2" + }, + "affine-2.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9d5e75469dcd6817017b23bb6a800833", + "name": "affine", + "sha256": "7d296733f38f01ebc2682c2fa6f95965e7954b00486e6d0f8bac4ec93642b16b", + "size": 30942, + "subdir": "linux-64", + "timestamp": 1547221374363, + "version": "2.2.2" + }, + "agate-1.6.0-py27hb771d64_2.conda": { + "build": "py27hb771d64_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=2.7,<2.8.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "5c4e26e3c19efc844d16ddb62c0a6fd8", + "name": "agate", + "sha256": "153bad924fb1363f4765648f296d81c4f0c2e94901eef340a9aa51e49bf0098c", + "size": 101508, + "subdir": "linux-64", + "timestamp": 1508623366090, + "version": "1.6.0" + }, + "agate-1.6.0-py35h2a67053_2.conda": { + "build": "py35h2a67053_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.5,<3.6.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "96853ffb35cfd92f1e4688c0270a7702", + "name": "agate", + "sha256": "12f40dc2b44fe386e1d20c90647f86829bcfc42ac37ff7a1cb659cfa73db820b", + "size": 105099, + "subdir": "linux-64", + "timestamp": 1508623370971, + "version": "1.6.0" + }, + "agate-1.6.0-py36h1b42258_2.conda": { + "build": "py36h1b42258_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.6,<3.7.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "8692901abf8383af4b4bb72085ed516b", + "name": "agate", + "sha256": "cb0e1f05994b32c062d3eac21c3d993d8d7015373520482cc763d99919a145af", + "size": 104197, + "subdir": "linux-64", + "timestamp": 1508623356978, + "version": "1.6.0" + }, + "agate-1.6.1-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=2.7,<2.8.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "ced722b19d7e320627af4308ea39a9ba", + "name": "agate", + "sha256": "4115154ced5cbfc994f998b4ba7d5e94de437e69f8a5310f6998423eaefe74a4", + "size": 101110, + "subdir": "linux-64", + "timestamp": 1520969373125, + "version": "1.6.1" + }, + "agate-1.6.1-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.10,<3.11.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "cf9920da12bd25c1b2deec326b4dc4e1", + "name": "agate", + "sha256": "b8d87e2d26284988c8021764511084141d14c8c4acfe0e7c8c4fdd9a410248ca", + "size": 104550, + "subdir": "linux-64", + "timestamp": 1640803305417, + "version": "1.6.1" + }, + "agate-1.6.1-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.5,<3.6.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "bef51cd4b75a6475d490cf22372add4e", + "name": "agate", + "sha256": "2774585e6f8969916c60cccbfded901a7ab59552ec5c25bcc477b9a6dc60a32a", + "size": 104717, + "subdir": "linux-64", + "timestamp": 1520969526224, + "version": "1.6.1" + }, + "agate-1.6.1-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.6,<3.7.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "625ac8aec8c48dfc2240cdc1764a8055", + "name": "agate", + "sha256": "1ffdd55fc8e5df28db2f6038fbb753bc4d0724898e62bee09824cc0305cb1d03", + "size": 102593, + "subdir": "linux-64", + "timestamp": 1520969364209, + "version": "1.6.1" + }, + "agate-1.6.1-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.6,<3.7.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "7876d062fbf7c5d2c8149eafe6494283", + "name": "agate", + "sha256": "86da5c810fa935b79e5664f5f3c5011bd0d68ba83d86e00c7b9f6492b11ed6a7", + "size": 103883, + "subdir": "linux-64", + "timestamp": 1614002827662, + "version": "1.6.1" + }, + "agate-1.6.1-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.7,<3.8.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "39efa96839fb895003bfbebca7031190", + "name": "agate", + "sha256": "106a7a7a849b3cdd9506ba9c98bdea307b30c837e2ef90fb6b854dd8c8810993", + "size": 102462, + "subdir": "linux-64", + "timestamp": 1530735770212, + "version": "1.6.1" + }, + "agate-1.6.1-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.7,<3.8.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "985ca4a6a8637c933357350f709cb972", + "name": "agate", + "sha256": "b90b1a36d4eb30703b85eb8e5b889944631c9c4a3e1707192b4276e1c5ed5b14", + "size": 105356, + "subdir": "linux-64", + "timestamp": 1614002826990, + "version": "1.6.1" + }, + "agate-1.6.1-py38_2.conda": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.8,<3.9.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "88f29e17b05c281435ae3483bfc685e7", + "name": "agate", + "sha256": "85e583a6ebc41e8f29b18dd938c29322cd80a1893b4cdf6d434a92b2bcba27e1", + "size": 104306, + "subdir": "linux-64", + "timestamp": 1574097675373, + "version": "1.6.1" + }, + "agate-1.6.1-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.8,<3.9.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "0aa19b6656fbbc3ebc207398963672df", + "name": "agate", + "sha256": "b5bb54579da6bdc000bcda167092b7c402f10110cb37e1731de206ff6e822a93", + "size": 105331, + "subdir": "linux-64", + "timestamp": 1614002830515, + "version": "1.6.1" + }, + "agate-1.6.1-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.9,<3.10.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "198777b862d97068f0186b5bf59fbfac", + "name": "agate", + "sha256": "6e8bd1a42687c3e19174663235cb965ad1a83c5c11ae458e364c68e5d23c6047", + "size": 103948, + "subdir": "linux-64", + "timestamp": 1614002831529, + "version": "1.6.1" + }, + "agate-1.6.2-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.6,<3.7.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "8747fe7958bc8fa6bfbce616d0c11d5b", + "name": "agate", + "sha256": "2511234f7f6215261086c219a021e1c05fadee4ff3032d3d93066c7b9db636f0", + "size": 104149, + "subdir": "linux-64", + "timestamp": 1615487454859, + "version": "1.6.2" + }, + "agate-1.6.2-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.7,<3.8.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "6d4229147643018feb4bfec46ba35f20", + "name": "agate", + "sha256": "6476f881ba5e6206bbfb4ad96fd932c147d5a9b4b3580e8a62dd6ce04bdc7cd2", + "size": 105620, + "subdir": "linux-64", + "timestamp": 1615487453199, + "version": "1.6.2" + }, + "agate-1.6.2-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.8,<3.9.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "8628806a6a777467d570bb46e58332d3", + "name": "agate", + "sha256": "ff0922f7ad2434942fb871073a045a8002059a21bfb3910792efaa2ee208162b", + "size": 104092, + "subdir": "linux-64", + "timestamp": 1615485833021, + "version": "1.6.2" + }, + "agate-1.6.2-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1", + "python >=3.9,<3.10.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "COPYING", + "license_family": "MIT", + "md5": "3843473c099090f440eb5bcffe26a8e9", + "name": "agate", + "sha256": "36d300dd58c0fd726bfcaf6847fa4d73c88d697e8c878275926c652036260060", + "size": 105502, + "subdir": "linux-64", + "timestamp": 1615487462335, + "version": "1.6.2" + }, + "agate-1.7.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1,!=2.5", + "python >=3.10,<3.11.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "998202ff7414fdc2ec401da994db6ac9", + "name": "agate", + "sha256": "9c962fe236e2a81ca6b25f6a677d9a937bd3bc813a3d73c133b083fe916337a7", + "size": 115562, + "subdir": "linux-64", + "timestamp": 1674846298185, + "version": "1.7.1" + }, + "agate-1.7.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1,!=2.5", + "python >=3.11,<3.12.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ce643f24337b07ee2d1b7c582fe7851", + "name": "agate", + "sha256": "04e885662b331f43fd5abddae40946805cc1ed657b9b0046e7d7512a8ae8eaf0", + "size": 140172, + "subdir": "linux-64", + "timestamp": 1676838958400, + "version": "1.7.1" + }, + "agate-1.7.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1,!=2.5", + "python >=3.7,<3.8.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f3c0ebbc0134c9aa2fc92ceded71fb0", + "name": "agate", + "sha256": "41cb83b2e5fe9bf8ce88cbcd7c7d59cbc62b2ed4d87bc1a3b282a5aca51adf9c", + "size": 114944, + "subdir": "linux-64", + "timestamp": 1674846354165, + "version": "1.7.1" + }, + "agate-1.7.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1,!=2.5", + "python >=3.8,<3.9.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0bc3a828f2ca943af4d88ae8811af41", + "name": "agate", + "sha256": "7c31121913a669c6192e96fde9f670ab60ebd05662bca3bf9587954afae24359", + "size": 114712, + "subdir": "linux-64", + "timestamp": 1674846326076, + "version": "1.7.1" + }, + "agate-1.7.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.0", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime >=2.1,!=2.5", + "python >=3.9,<3.10.0a0", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7767b9ce6a38462bc0c684bf32773f96", + "name": "agate", + "sha256": "2468ba96c8023ea058074858333c20968c32ca742106788a2c8115a5048b1288", + "size": 114770, + "subdir": "linux-64", + "timestamp": 1674846269665, + "version": "1.7.1" + }, + "agate-dbf-0.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "dbfread >=2.0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ef3875611836134e96a8a30f8af3e2a", + "name": "agate-dbf", + "sha256": "e2dab599d5ecc8b9aef020ab0823067e851edf6e7bc4bb07bfc869ae927498ad", + "size": 6167, + "subdir": "linux-64", + "timestamp": 1530735883156, + "version": "0.2.0" + }, + "agate-dbf-0.2.0-py27h9ce99ee_0.conda": { + "build": "py27h9ce99ee_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "dbfread >=2.0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d0d00df2eade43ae8d3eb2826e8c23ba", + "name": "agate-dbf", + "sha256": "1934df520886a546ad2006fe1bc6e9eaa41051645ede6c72b8bcf478d92df49a", + "size": 6964, + "subdir": "linux-64", + "timestamp": 1508625648960, + "version": "0.2.0" + }, + "agate-dbf-0.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "dbfread >=2.0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "afc44e5d8582b803f523ae8e1cf26bb7", + "name": "agate-dbf", + "sha256": "a406506db0c975b657deeaa39032f80a2736011143eb40172d1669d0d4265e01", + "size": 6160, + "subdir": "linux-64", + "timestamp": 1534352093152, + "version": "0.2.0" + }, + "agate-dbf-0.2.0-py35h575f34e_0.conda": { + "build": "py35h575f34e_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "dbfread >=2.0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "951f80270a8d4e94b703968a74c95795", + "name": "agate-dbf", + "sha256": "9a0dc308745b7e4d9af721f8bac9263ad9fa3edade32dc5cfaf9e5cd0d8b7e83", + "size": 7018, + "subdir": "linux-64", + "timestamp": 1508625654228, + "version": "0.2.0" + }, + "agate-dbf-0.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "dbfread >=2.0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea24bdaf1dea443c95383621c82ac7ca", + "name": "agate-dbf", + "sha256": "cb8dc6c9f6543279024d7cc71ef8236130f7b00335ffbbd1be4ceac71f79e5d3", + "size": 6179, + "subdir": "linux-64", + "timestamp": 1530735858002, + "version": "0.2.0" + }, + "agate-dbf-0.2.0-py36hacfe2c2_0.conda": { + "build": "py36hacfe2c2_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "dbfread >=2.0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92d936f20d7b8b7c2153a8b8456ad034", + "name": "agate-dbf", + "sha256": "09d46128c5e14598e8a2694b221c63de6c4e9d4b2dd69a58984689af3b1e3cf4", + "size": 6977, + "subdir": "linux-64", + "timestamp": 1508625648439, + "version": "0.2.0" + }, + "agate-dbf-0.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "dbfread >=2.0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0eec0fbe7d0340ccecbc093fdb418cea", + "name": "agate-dbf", + "sha256": "78a92064040425762cfe5dfba65b34f171ef637b532f0ecd8a8420c222e33cf5", + "size": 6182, + "subdir": "linux-64", + "timestamp": 1530735909210, + "version": "0.2.0" + }, + "agate-excel-0.2.1-py27h3c51f3f_0.conda": { + "build": "py27h3c51f3f_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "openpyxl >=2.3.0", + "python >=2.7,<2.8.0a0", + "xlrd >=0.9.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "006cb206205a88e384f317f66aaba3da", + "name": "agate-excel", + "sha256": "b7df5fd7376f856d82002ac985b8c8abd729c2acc828c78d53cd2c99501fc270", + "size": 10731, + "subdir": "linux-64", + "timestamp": 1508624734697, + "version": "0.2.1" + }, + "agate-excel-0.2.1-py35h3f91c98_0.conda": { + "build": "py35h3f91c98_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "openpyxl >=2.3.0", + "python >=3.5,<3.6.0a0", + "xlrd >=0.9.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "264c3ca4d4708f733b5b6315498ecf54", + "name": "agate-excel", + "sha256": "e68db3c83fb0679f81f76f5a90f4b410c3dec4c30e9d0a7408675f730471d333", + "size": 10897, + "subdir": "linux-64", + "timestamp": 1508624778521, + "version": "0.2.1" + }, + "agate-excel-0.2.1-py36h4cc37e8_0.conda": { + "build": "py36h4cc37e8_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "openpyxl >=2.3.0", + "python >=3.6,<3.7.0a0", + "xlrd >=0.9.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f04ac8c9919e96eeccb1cc902d66e8f", + "name": "agate-excel", + "sha256": "acd8b0b1333dfc5f6dd34bb92e018bac1765e3d56bdab403a053b84b29a9b244", + "size": 10767, + "subdir": "linux-64", + "timestamp": 1508624777093, + "version": "0.2.1" + }, + "agate-excel-0.2.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "openpyxl >=2.3.0", + "python >=2.7,<2.8.0a0", + "xlrd >=0.9.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96fbcda1458c6f9f6ed7aa6b12be2270", + "name": "agate-excel", + "sha256": "ac1eba97386dfcf89d2bc309c26c989dad5b2d0576bdc7ffe22c40bc3c29120c", + "size": 10715, + "subdir": "linux-64", + "timestamp": 1520969734062, + "version": "0.2.2" + }, + "agate-excel-0.2.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "openpyxl >=2.3.0", + "python >=3.5,<3.6.0a0", + "xlrd >=0.9.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0dcbd3d10eb2c5b68a1e88fac6307a5a", + "name": "agate-excel", + "sha256": "cdf152f216ff00f15bcadd2f4d72e1e35c588c211246f15dceb825ab4bab298d", + "size": 10920, + "subdir": "linux-64", + "timestamp": 1520969878190, + "version": "0.2.2" + }, + "agate-excel-0.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "openpyxl >=2.3.0", + "python >=3.6,<3.7.0a0", + "xlrd >=0.9.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d998f25a1af33ec4551fa2301a5a0890", + "name": "agate-excel", + "sha256": "7881160eb3846936697ae7a4e818d21330b3143da4479da6a996424d9146be82", + "size": 10790, + "subdir": "linux-64", + "timestamp": 1520969576403, + "version": "0.2.2" + }, + "agate-excel-0.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "openpyxl >=2.3.0", + "python >=3.7,<3.8.0a0", + "xlrd >=0.9.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f865d3f67bb71072e5ecac13ba86552b", + "name": "agate-excel", + "sha256": "62f10d9ab602c15b590fd452d0c481b8d19a6ec27d32552acded98b3dffa8590", + "size": 10605, + "subdir": "linux-64", + "timestamp": 1530736116668, + "version": "0.2.2" + }, + "agate-sql-0.5.2-py27habb94be_0.conda": { + "build": "py27habb94be_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "python >=2.7,<2.8.0a0", + "sqlalchemy >=1.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be4e0af798295797fbad52ceed7f975b", + "name": "agate-sql", + "sha256": "c2db2bcf03bed0fd3633db3f5324ffcdd2e8e282c877b7853a11461dc0880d9d", + "size": 11481, + "subdir": "linux-64", + "timestamp": 1508624045026, + "version": "0.5.2" + }, + "agate-sql-0.5.2-py35h2ac6a9e_0.conda": { + "build": "py35h2ac6a9e_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "python >=3.5,<3.6.0a0", + "sqlalchemy >=1.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1918dd92be1f327f50e435c47e53e581", + "name": "agate-sql", + "sha256": "7b9c2e78ae7c2b004ebff77226b25d6a88a7049e3970291807b9d49d068bc11f", + "size": 11602, + "subdir": "linux-64", + "timestamp": 1508623985459, + "version": "0.5.2" + }, + "agate-sql-0.5.2-py36h44b7e2c_0.conda": { + "build": "py36h44b7e2c_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "python >=3.6,<3.7.0a0", + "sqlalchemy >=1.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "97051d7902ebe9292de93bca44a4a65c", + "name": "agate-sql", + "sha256": "ba5f2f184d00ad4766ed11ba3de31dc8c2609e32facc91a40bc8558274be422f", + "size": 11500, + "subdir": "linux-64", + "timestamp": 1508624060850, + "version": "0.5.2" + }, + "agate-sql-0.5.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "python >=2.7,<2.8.0a0", + "sqlalchemy >=1.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80593a24e8ef75fdb0007dd2a58c8361", + "name": "agate-sql", + "sha256": "e65ff6a0954604a8f42b413daab1ab5ca281cc3f702611290d36452813a921a6", + "size": 12059, + "subdir": "linux-64", + "timestamp": 1520969743340, + "version": "0.5.3" + }, + "agate-sql-0.5.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "python >=3.5,<3.6.0a0", + "sqlalchemy >=1.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7a32168c3c96b23b27b926c2cb437212", + "name": "agate-sql", + "sha256": "1abf9d7375e14891d7fe9b2596b269ce0fb094bb93d610bab08f030cae77c61f", + "size": 12207, + "subdir": "linux-64", + "timestamp": 1520969847408, + "version": "0.5.3" + }, + "agate-sql-0.5.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "python >=3.6,<3.7.0a0", + "sqlalchemy >=1.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a7320f3c0d81b32c05064ea8ef8d6c5b", + "name": "agate-sql", + "sha256": "53bd65f9663c0b3f72a39b453d513988ecbef4a2fce556856a4a0c4e665c10c7", + "size": 12045, + "subdir": "linux-64", + "timestamp": 1520969574639, + "version": "0.5.3" + }, + "agate-sql-0.5.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "python >=3.7,<3.8.0a0", + "sqlalchemy >=1.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9172f44a6c249b28237cef5b4cc37dcb", + "name": "agate-sql", + "sha256": "36f90bca472b208f3cbfa8185404c5094705c7df6ac0ebe6c2168ac65d4316eb", + "size": 11904, + "subdir": "linux-64", + "timestamp": 1530736420417, + "version": "0.5.3" + }, + "aiobotocore-0.10.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "botocore >=1.12.49,<1.12.50", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "2fdb29a31e7917fd0762736772b7d4be", + "name": "aiobotocore", + "sha256": "84d5cd0157b772734f9c38f874d670531969bff4b72bdda3a1b0a7bcebc326be", + "size": 41200, + "subdir": "linux-64", + "timestamp": 1545162239367, + "version": "0.10.0" + }, + "aiobotocore-0.10.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "botocore >=1.12.49,<1.12.50", + "python >=3.7,<3.8.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "2b76af1e7577a11dc7661927e5d7066c", + "name": "aiobotocore", + "sha256": "f22e1a0f1ae84f213aed61497f570d920ea9146e9f2551d7a3b61dcc0b07f8e8", + "size": 41308, + "subdir": "linux-64", + "timestamp": 1545162213453, + "version": "0.10.0" + }, + "aiobotocore-0.10.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "async_generator >=1.10", + "botocore >=1.12.49,<1.12.50", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "b97f1f20ede67403f89adeb421ce05a3", + "name": "aiobotocore", + "sha256": "1685e86d1fd49384beb1b33d2210b39539f93fffccf5f484ac516e4f1cbd8c8b", + "size": 44632, + "subdir": "linux-64", + "timestamp": 1550266978306, + "version": "0.10.2" + }, + "aiobotocore-0.10.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "async_generator >=1.10", + "botocore >=1.12.49,<1.12.50", + "python >=3.7,<3.8.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "b16e62e5f0e47d121649f9e61cd51b0d", + "name": "aiobotocore", + "sha256": "54fd5651c85c00090d671e5554281bd541e3e43710e42114247261aee584cb29", + "size": 44548, + "subdir": "linux-64", + "timestamp": 1550266831648, + "version": "0.10.2" + }, + "aiobotocore-0.4.3-py35h8f5c47f_0.conda": { + "build": "py35h8f5c47f_0", + "build_number": 0, + "depends": [ + "aiohttp >=2.0.4,<=2.3.0", + "botocore >=1.5.71,<=1.5.78", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.5,<3.6.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "92451aec76501f85c78b337a84767f6a", + "name": "aiobotocore", + "sha256": "f298f67ea5487f659a34ac44056090a35b7bd509fc1efab2d0f1e1bfa0cd57cd", + "size": 33923, + "subdir": "linux-64", + "timestamp": 1507658798173, + "version": "0.4.3" + }, + "aiobotocore-0.4.3-py36ha4832ae_0.conda": { + "build": "py36ha4832ae_0", + "build_number": 0, + "depends": [ + "aiohttp >=2.0.4,<=2.3.0", + "botocore >=1.5.71,<=1.5.78", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "cf0544f8b3576e3952fb4ab69ac45b41", + "name": "aiobotocore", + "sha256": "2929defee943f0bbf34ebfe651bed13840e61242c02e91a7f1eb21a06368ea18", + "size": 33452, + "subdir": "linux-64", + "timestamp": 1507658802537, + "version": "0.4.3" + }, + "aiobotocore-0.4.5-py35h86c1b7f_0.conda": { + "build": "py35h86c1b7f_0", + "build_number": 0, + "depends": [ + "aiohttp >=2.0.4,<=2.3.0", + "botocore >=1.7.4,<=1.7.5", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.5,<3.6.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "9d246ed005550e6cfc3a903de5848521", + "name": "aiobotocore", + "sha256": "49706f44d5f274175f985efdc21c4b7eb676f0e31a48caaf70a1004a389cc4e7", + "size": 34881, + "subdir": "linux-64", + "timestamp": 1507654541823, + "version": "0.4.5" + }, + "aiobotocore-0.4.5-py36h52af316_0.conda": { + "build": "py36h52af316_0", + "build_number": 0, + "depends": [ + "aiohttp >=2.0.4,<=2.3.0", + "botocore >=1.7.4,<=1.7.5", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "624af0d5d3ddc8ec300400568864ed6a", + "name": "aiobotocore", + "sha256": "0a14df8e623d7e36cde1ea140f7ebea5facee2c2031263c50915ba1462e6d36c", + "size": 34568, + "subdir": "linux-64", + "timestamp": 1507654547385, + "version": "0.4.5" + }, + "aiobotocore-0.5.1-py35h7f75d60_0.conda": { + "build": "py35h7f75d60_0", + "build_number": 0, + "depends": [ + "aiohttp >=2.3.0,<3.0.0", + "botocore >=1.7.28,<=1.7.40", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.5,<3.6.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "33264095bbb5a79f84461dc1cc8f12e6", + "name": "aiobotocore", + "sha256": "3e81b9c6bb68448214a2fb0af8ced5da0847eb435b21db17d6e696321c5df02c", + "size": 34508, + "subdir": "linux-64", + "timestamp": 1511928450617, + "version": "0.5.1" + }, + "aiobotocore-0.5.1-py36h9454989_0.conda": { + "build": "py36h9454989_0", + "build_number": 0, + "depends": [ + "aiohttp >=2.3.0,<3.0.0", + "botocore >=1.7.28,<=1.7.40", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "4b375975e1347d65e2a146b66868a76f", + "name": "aiobotocore", + "sha256": "a5c3cc1e41cb7ce2db2b134cf3299a30e4f293e6cea7588986c39296daeecdb3", + "size": 33988, + "subdir": "linux-64", + "timestamp": 1511928460060, + "version": "0.5.1" + }, + "aiobotocore-0.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.0.0", + "botocore >=1.8.0,<=1.8.21", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.5,<3.6.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "782ad60a210b488c24514f3e453e3fa0", + "name": "aiobotocore", + "sha256": "d91541e0b502c2fbdaa1c1bfd178e1e744bf2b8e2c7ee260520127475de8e976", + "size": 35439, + "subdir": "linux-64", + "timestamp": 1520922009871, + "version": "0.6.0" + }, + "aiobotocore-0.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.0.0", + "botocore >=1.8.0,<=1.8.21", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "5734703855aaeda6a6af7c65e364bd61", + "name": "aiobotocore", + "sha256": "f52199045160fd1de137c569257d86d6182c9720cfde4e950d51081a4ee9cdd1", + "size": 35233, + "subdir": "linux-64", + "timestamp": 1520921986597, + "version": "0.6.0" + }, + "aiobotocore-0.8.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.1.0,<3.2.0", + "botocore >=1.10.12,<=1.10.13", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.5,<3.6.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "7e1deb4614a1b9eb021fc902dbcfe250", + "name": "aiobotocore", + "sha256": "83a5992da66677c238c1f5e8e93b39b94a4837a6fbaf7019df6f8df0c05fe204", + "size": 36248, + "subdir": "linux-64", + "timestamp": 1527700992015, + "version": "0.8.0" + }, + "aiobotocore-0.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.1.0,<3.2.0", + "botocore >=1.10.12,<=1.10.13", + "multidict >=2.1.4", + "packaging >=16.8", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "65d2079320c24ed68cfd3a221d9b7fdd", + "name": "aiobotocore", + "sha256": "3e8563e4c9584be0c37662b1754f4768f444abd22565ed9fda6a96c2098e7946", + "size": 35893, + "subdir": "linux-64", + "timestamp": 1527700946882, + "version": "0.8.0" + }, + "aiobotocore-0.9.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.0", + "botocore >=1.10.12,<1.10.13", + "python >=3.5,<3.6.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "bb7c611a68ac25b9d58a4ca6dafaad48", + "name": "aiobotocore", + "sha256": "4ac23e964eed5ef92b4c6a63bc24bbef414736f3a163007a4d89cad3860123aa", + "size": 34754, + "subdir": "linux-64", + "timestamp": 1528210048749, + "version": "0.9.1" + }, + "aiobotocore-0.9.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.0", + "botocore >=1.10.12,<1.10.13", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "f2d2de8b58b50c059bd71e8930842f5b", + "name": "aiobotocore", + "sha256": "5efb20c6d3b789e3961b28221c9d31bc4f951330a90606a3d225ecc68b6cf81e", + "size": 34430, + "subdir": "linux-64", + "timestamp": 1528210001250, + "version": "0.9.1" + }, + "aiobotocore-0.9.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.0", + "botocore >=1.10.12,<1.10.13", + "python >=3.5,<3.6.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "6beb4fe8fa8796f871b95c9d7cbc3e62", + "name": "aiobotocore", + "sha256": "c28de4238bc9d7bbebb7e9c6226f34461de04e3a278bb48144d30c4793a30b8f", + "size": 34931, + "subdir": "linux-64", + "timestamp": 1529322630981, + "version": "0.9.2" + }, + "aiobotocore-0.9.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.0", + "botocore >=1.10.12,<1.10.13", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "95ed8cc98b9fe51001810ac23089a057", + "name": "aiobotocore", + "sha256": "349120cdb39b2a310b94b4436b414a01acae130e65e72d35909befc230fac277", + "size": 34601, + "subdir": "linux-64", + "timestamp": 1529322642410, + "version": "0.9.2" + }, + "aiobotocore-0.9.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.0", + "botocore >=1.10.12,<1.10.13", + "python >=3.7,<3.8.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "24f4a3108c1f49a7ba99ba67347d91af", + "name": "aiobotocore", + "sha256": "1d880131d7560a398c8a492d96cb57c30d2db99e364886935c3cb38e86e17979", + "size": 34707, + "subdir": "linux-64", + "timestamp": 1530736959539, + "version": "0.9.2" + }, + "aiobotocore-0.9.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "botocore >=1.10.58,<1.10.59", + "python >=3.5,<3.6.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "a46758212f053e39752a6c1823c42bee", + "name": "aiobotocore", + "sha256": "5a1e4b0709391347345e1c0ea3d15c9a7993339ac665f18a3ae4171616697a0e", + "size": 37372, + "subdir": "linux-64", + "timestamp": 1536117999593, + "version": "0.9.3" + }, + "aiobotocore-0.9.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "botocore >=1.10.58,<1.10.59", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "e4db22e0bb6a851bb437d7a5fc2c9482", + "name": "aiobotocore", + "sha256": "99f46b41645838e2c88e0b3f6eed1130a02f1c6b32ef00626d1f5e324133720c", + "size": 36788, + "subdir": "linux-64", + "timestamp": 1536117933843, + "version": "0.9.3" + }, + "aiobotocore-0.9.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "botocore >=1.10.58,<1.10.59", + "python >=3.7,<3.8.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "00f306ba195ad3237df711ade73c0e16", + "name": "aiobotocore", + "sha256": "7dc54aa075e4e8a5d427688b347381a42fb475c45ff608d8fb73d74232c69f9a", + "size": 36879, + "subdir": "linux-64", + "timestamp": 1536118021192, + "version": "0.9.3" + }, + "aiobotocore-0.9.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "botocore >=1.10.58,<1.10.59", + "python >=3.6,<3.7.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "285fda946a49d9a142de232eb1ee19fc", + "name": "aiobotocore", + "sha256": "1803ee94459ace26e91d3c6a41686a2d13f1326dab003bfd35067aeee2f2b22c", + "size": 37175, + "subdir": "linux-64", + "timestamp": 1538171576435, + "version": "0.9.4" + }, + "aiobotocore-0.9.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "botocore >=1.10.58,<1.10.59", + "python >=3.7,<3.8.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "6548def3294493941d9306c2173f598e", + "name": "aiobotocore", + "sha256": "3b2145286334d1287bfdf2fbc6516a94f45f170b2c0d8f2813ffdd0ae63a556c", + "size": 36967, + "subdir": "linux-64", + "timestamp": 1538171517861, + "version": "0.9.4" + }, + "aiobotocore-2.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.27.59,<1.27.60", + "python >=3.10,<3.11.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ece25054f86ac34df9114e07ec30218f", + "name": "aiobotocore", + "sha256": "9eb0dfeea3c63478ebac100518000e903161bf96f5892f5472278998984f7a23", + "size": 107841, + "subdir": "linux-64", + "timestamp": 1667504214605, + "version": "2.4.0" + }, + "aiobotocore-2.4.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.27.59,<1.27.60", + "python >=3.11,<3.12.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2f51104ba91efff441fffa1fc07d0105", + "name": "aiobotocore", + "sha256": "aef0bf0505264e25434092ec956180018200e0ef64ef49cfeba6df69fa10ce0b", + "size": 132150, + "subdir": "linux-64", + "timestamp": 1676843165754, + "version": "2.4.0" + }, + "aiobotocore-2.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.27.59,<1.27.60", + "python >=3.7,<3.8.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7f7993bc1e422fda99996c3552c923ae", + "name": "aiobotocore", + "sha256": "9d6d954385ba32f055f73a6fad1179f15ee6469f40b969358da91ad0c18baffe", + "size": 106325, + "subdir": "linux-64", + "timestamp": 1667504243156, + "version": "2.4.0" + }, + "aiobotocore-2.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.27.59,<1.27.60", + "python >=3.8,<3.9.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f60375c26c8097a165f8467582101515", + "name": "aiobotocore", + "sha256": "dc1e399d1266c62b1305a14340e7a69b48c774574405e7da379720553e265a67", + "size": 107306, + "subdir": "linux-64", + "timestamp": 1667504184234, + "version": "2.4.0" + }, + "aiobotocore-2.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.27.59,<1.27.60", + "python >=3.9,<3.10.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a3f183aec5ef2ab97d479b9a81a13593", + "name": "aiobotocore", + "sha256": "e8341ceec6f10b4819abb1ac73087085e1ce264a83c2c18c32dddad554ed7670", + "size": 107308, + "subdir": "linux-64", + "timestamp": 1667504271329, + "version": "2.4.0" + }, + "aiobotocore-2.4.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.27.59,<1.27.60", + "python >=3.10,<3.11.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8622a93a45078532dc6132af0ff2db2a", + "name": "aiobotocore", + "sha256": "447e53a43ab73884d8b260ba640cbe9a9e88af668bcf0b14137057d6200a168a", + "size": 109814, + "subdir": "linux-64", + "timestamp": 1680004359011, + "version": "2.4.2" + }, + "aiobotocore-2.4.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.27.59,<1.27.60", + "python >=3.11,<3.12.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bdc5fa9ea884604518e3580505fafd1d", + "name": "aiobotocore", + "sha256": "7db827d2e8b35efce9a9997e6c2b52bbf3ecb9e22e8243fc03f80b238508dbd5", + "size": 142085, + "subdir": "linux-64", + "timestamp": 1680004386704, + "version": "2.4.2" + }, + "aiobotocore-2.4.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.27.59,<1.27.60", + "python >=3.8,<3.9.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f26928ab5c25347fb9ab56058af2cf4b", + "name": "aiobotocore", + "sha256": "a999b01a32611a4908c08ee35cadde2bf07bb215c408967dbd742fb62cd8d5fb", + "size": 109350, + "subdir": "linux-64", + "timestamp": 1680004330963, + "version": "2.4.2" + }, + "aiobotocore-2.4.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.27.59,<1.27.60", + "python >=3.9,<3.10.0a0", + "wrapt >=1.10.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a2930ccaae007daa08460cbd3ae70220", + "name": "aiobotocore", + "sha256": "fdf5a42a080e8f4249d5147b7a210793b4019b521cb9d01f9ce1efb6715f25d5", + "size": 109220, + "subdir": "linux-64", + "timestamp": 1680004303624, + "version": "2.4.2" + }, + "aiofiles-0.3.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b602cae419c909772a800dad42fd7504", + "name": "aiofiles", + "sha256": "bb3f1a23a965196dae611a75e27b735f9d767fe5a2006a9864597bd80f404d31", + "size": 17327, + "subdir": "linux-64", + "timestamp": 1522782325751, + "version": "0.3.2" + }, + "aiofiles-0.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "eccc03031f9a5395532ea131af617c24", + "name": "aiofiles", + "sha256": "aabd3986504fcb0024391e0160612523aed6cde6346ccae27639eb88b236575c", + "size": 17220, + "subdir": "linux-64", + "timestamp": 1522782326129, + "version": "0.3.2" + }, + "aiofiles-0.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6b186590c69a8e92f322dbaa281db33f", + "name": "aiofiles", + "sha256": "6d92aef9434b0c372d09e5af8838a713b96a8056081c9dfbf047654f7606fe99", + "size": 17064, + "subdir": "linux-64", + "timestamp": 1530736984461, + "version": "0.3.2" + }, + "aiofiles-0.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1a11f73cc6a81eecd9bcde18a6f0e09e", + "name": "aiofiles", + "sha256": "e539c4c4d3f67cbb5aee89d17877bed9455e42545ab96524c959df6f98b896ab", + "size": 16381, + "subdir": "linux-64", + "timestamp": 1535422416146, + "version": "0.4.0" + }, + "aiofiles-0.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ca71a1d2f5dc0c2c7198a8bb6403e090", + "name": "aiofiles", + "sha256": "8ddb74e09e5e33214a6e0ef055c188ef89ee59f89e22f2a65fc72dd4cad1617b", + "size": 16321, + "subdir": "linux-64", + "timestamp": 1535422401170, + "version": "0.4.0" + }, + "aiofiles-0.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c4708bf804f26029c98479f000132240", + "name": "aiofiles", + "sha256": "78142b1cea66aba5c4679d51ce98728eb013e6000c6fa6b8133e555ef4c646d7", + "size": 16357, + "subdir": "linux-64", + "timestamp": 1535422432138, + "version": "0.4.0" + }, + "aiofiles-0.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3985ce6ca2ee16a92ed592d167d13d0e", + "name": "aiofiles", + "sha256": "e641853e892cd9540b16628578dbfa9af5e23ac1043d88f410a175ec69e2e5df", + "size": 16650, + "subdir": "linux-64", + "timestamp": 1572437545106, + "version": "0.4.0" + }, + "aiofiles-0.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5765dee4cef42fc65a20bbc354677b99", + "name": "aiofiles", + "sha256": "2670203ad8834c33023bfc7b8d9b2d045282f1ef3b48fa6f3c167f8cc44c92d7", + "size": 17448, + "subdir": "linux-64", + "timestamp": 1598642675750, + "version": "0.5.0" + }, + "aiofiles-0.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "50f04b09b94a13e840c23915f7d8f8be", + "name": "aiofiles", + "sha256": "4fdecd708b3e408f844f5ebe01f8dd8f71ae8e62fcb7915bae165d100bf34197", + "size": 17422, + "subdir": "linux-64", + "timestamp": 1598642692632, + "version": "0.5.0" + }, + "aiofiles-0.5.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "15220d3d64fc9b4301696b4b8a8a0f93", + "name": "aiofiles", + "sha256": "d8af5642a23f5e07155d14c772be9e9979da44a32b90ccb618da6e02970816d9", + "size": 17504, + "subdir": "linux-64", + "timestamp": 1598642697336, + "version": "0.5.0" + }, + "aiofiles-0.6.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "65ad5bd7a10ef56ca0cee6675f699b1f", + "name": "aiofiles", + "sha256": "97f30c3b1d69168063df2f141f63935e5c43ff7709da9d3a4ac3f2b3e79679e8", + "size": 16761, + "subdir": "linux-64", + "timestamp": 1603893211704, + "version": "0.6.0" + }, + "aiofiles-0.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "00fc57aa786f274b70c8432ac0b0820b", + "name": "aiofiles", + "sha256": "b9d1f2b0122497103ddfc4923f328187d0bc37eeb5026a484a6938d915bc1720", + "size": 16759, + "subdir": "linux-64", + "timestamp": 1603893194988, + "version": "0.6.0" + }, + "aiofiles-0.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "de10a22c2f847e5bef34f7146af469c0", + "name": "aiofiles", + "sha256": "16a0f80b73e85d809bcad2708849577923ffd8a826c28d5407ca99837710cd78", + "size": 16919, + "subdir": "linux-64", + "timestamp": 1603893219597, + "version": "0.6.0" + }, + "aiofiles-0.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0788f7a0c0da03aafd84d0a3aba78410", + "name": "aiofiles", + "sha256": "1f7963b30e6c9c73ec5b321302218c1b71b97749e3e7da3fcbcce12cd1d2d9d6", + "size": 17730, + "subdir": "linux-64", + "timestamp": 1611675314164, + "version": "0.6.0" + }, + "aiofiles-0.7.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2216a7f5507ad8b5cb16e7413d851cc7", + "name": "aiofiles", + "sha256": "ad70d3214c36c7b443971080d6410fe6b6cb6982247f6a1791f87f47ffed2131", + "size": 20766, + "subdir": "linux-64", + "timestamp": 1621258542990, + "version": "0.7.0" + }, + "aiofiles-0.7.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2a2a08d8fd80277bd4b2424f1ec6f550", + "name": "aiofiles", + "sha256": "4229365b155d8e809eb5aa4425ace913289b87f33133c89061f2cf4ca60aa8a9", + "size": 20675, + "subdir": "linux-64", + "timestamp": 1621258446322, + "version": "0.7.0" + }, + "aiofiles-0.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "90e0956c64a9b2cea274685228554edd", + "name": "aiofiles", + "sha256": "7c2914716efed067221d8e27734a5fe08987fc5d2a02cc7c91e8b51f811e4252", + "size": 20788, + "subdir": "linux-64", + "timestamp": 1621258540065, + "version": "0.7.0" + }, + "aiofiles-0.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8d70c5182d3eb9f3b37e24f2c1faece2", + "name": "aiofiles", + "sha256": "fe47f2b38e942704caac4233a67aae4dc03e10d4b6d1d1b98f4bd33756a7f65d", + "size": 20827, + "subdir": "linux-64", + "timestamp": 1621253989644, + "version": "0.7.0" + }, + "aiohttp-2.2.5-py35h8d7d2b0_0.conda": { + "build": "py35h8d7d2b0_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2.0", + "chardet", + "multidict >=2.1.4", + "python >=3.5,<3.6.0a0", + "yarl >=0.11" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f782de3e4dee73f3d6b013cf7c969af0", + "name": "aiohttp", + "sha256": "aead9369700b1d2811a2e3887e80cc1d97bd49f6796042a474e1ff40714b8da6", + "size": 273469, + "subdir": "linux-64", + "timestamp": 1507573394484, + "version": "2.2.5" + }, + "aiohttp-2.2.5-py36h3a1b670_0.conda": { + "build": "py36h3a1b670_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2.0", + "chardet", + "multidict >=2.1.4", + "python >=3.6,<3.7.0a0", + "yarl >=0.11" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "570d40f0e945a9fb8c30f7e64ec3ea4a", + "name": "aiohttp", + "sha256": "a038a547643c4c6f2bae8de8374e0b061fd5d189a5ee367ef28bf757e397a864", + "size": 272620, + "subdir": "linux-64", + "timestamp": 1507573400930, + "version": "2.2.5" + }, + "aiohttp-2.3.3-py35h1b2d56f_0.conda": { + "build": "py35h1b2d56f_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2.0", + "chardet", + "multidict >=3.0.0", + "python >=3.5,<3.6.0a0", + "yarl >=0.11" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b20fbb6da2f9c2244acf2c73746806fb", + "name": "aiohttp", + "sha256": "8159e7e9149d13b3c49ce230890244571c80377053b25270c9851b3dcba5eac3", + "size": 299467, + "subdir": "linux-64", + "timestamp": 1511844479300, + "version": "2.3.3" + }, + "aiohttp-2.3.3-py36h90e93d8_0.conda": { + "build": "py36h90e93d8_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2.0", + "chardet", + "multidict >=3.0.0", + "python >=3.6,<3.7.0a0", + "yarl >=0.11" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2b8212080c48c3852a01f658016fb503", + "name": "aiohttp", + "sha256": "5fca0873363df109abfff41b69f8fb54644e6600a562783d025a8c42f4b9525d", + "size": 296685, + "subdir": "linux-64", + "timestamp": 1511844477244, + "version": "2.3.3" + }, + "aiohttp-2.3.9-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2.0", + "chardet", + "multidict >=3.0.0", + "python >=3.5,<3.6.0a0", + "yarl >=0.11" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7c39317d812748d1e08f6b1666895591", + "name": "aiohttp", + "sha256": "57f1a083d620b6e2286432b2df3266910a2640b961d2694695b0176508793528", + "size": 302478, + "subdir": "linux-64", + "timestamp": 1516979140787, + "version": "2.3.9" + }, + "aiohttp-2.3.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2.0", + "chardet", + "multidict >=3.0.0", + "python >=3.6,<3.7.0a0", + "yarl >=0.11" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a77318c0c28dabef56ab5cd8c8d56b7b", + "name": "aiohttp", + "sha256": "9772cff205103368ab6906622e718ae8b4968ba192e9f9de4d1f2d121f842187", + "size": 299650, + "subdir": "linux-64", + "timestamp": 1516979141409, + "version": "2.3.9" + }, + "aiohttp-3.0.7-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2,<3.0", + "attrs >=17.4.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.5,<3.6.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c3b5963771d3ce600a2b8d1a943bfe84", + "name": "aiohttp", + "sha256": "8939c069a33e54c559ea05305481ca425ad94365278c410990a8f0959154f9dc", + "size": 379839, + "subdir": "linux-64", + "timestamp": 1520921439340, + "version": "3.0.7" + }, + "aiohttp-3.0.7-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2,<3.0", + "attrs >=17.4.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d03cc47d92f0ccc7d671093a7dfaf1c1", + "name": "aiohttp", + "sha256": "90cc857b276cdd80f760d10af4ec57c0885ede635d822bf0d86e020b0b887934", + "size": 381078, + "subdir": "linux-64", + "timestamp": 1520921424205, + "version": "3.0.7" + }, + "aiohttp-3.1.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2,<3.0", + "attrs >=17.4.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.5,<3.6.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5611c8c1d76494620be984fce30752b1", + "name": "aiohttp", + "sha256": "e2ca81c5c12cfadc12fa6197d7dd86c39a81287002abc0b4b8299f42f6137fe0", + "size": 384772, + "subdir": "linux-64", + "timestamp": 1522190567280, + "version": "3.1.0" + }, + "aiohttp-3.1.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2,<3.0", + "attrs >=17.4.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d1601c712239776b99439e27fdc2dc3f", + "name": "aiohttp", + "sha256": "07e198840e88649b99b53d3071fb941b3d218221143182c1a0e1ac4f881f2f0f", + "size": 384136, + "subdir": "linux-64", + "timestamp": 1522190616262, + "version": "3.1.0" + }, + "aiohttp-3.1.1-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2,<3.0", + "attrs >=17.4.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.5,<3.6.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b1b407ba13e1ff7ac91bf8ca9f67954d", + "name": "aiohttp", + "sha256": "847e7d26119fa592c6394726431cc0a0f071112a1577c840bdb58e91e30803ea", + "size": 385327, + "subdir": "linux-64", + "timestamp": 1522715085600, + "version": "3.1.1" + }, + "aiohttp-3.1.1-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2,<3.0", + "attrs >=17.4.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7a52a5f8213760aafd40c3cb06f0b728", + "name": "aiohttp", + "sha256": "b29cf14daac8c257e21f3c23237129d4d5bb0d102fed96c6f6735d69b67b81f5", + "size": 384948, + "subdir": "linux-64", + "timestamp": 1522715081688, + "version": "3.1.1" + }, + "aiohttp-3.1.3-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2,<3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.5,<3.6.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "74d3da112b53d83523a3d2a9f7cda0d7", + "name": "aiohttp", + "sha256": "b47e370fb9e14420ed67a8007dec38efd9abe8ec8614cc839735c8b1c7b3f2a9", + "size": 386728, + "subdir": "linux-64", + "timestamp": 1524002676127, + "version": "3.1.3" + }, + "aiohttp-3.1.3-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=1.2,<3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d04d0ad915fa3088b6d4640323c1eb6f", + "name": "aiohttp", + "sha256": "228e92c75f0a2050f92fcc07a64d07698fd19c8a7d5d4cd56e04a5466ca0a552", + "size": 386044, + "subdir": "linux-64", + "timestamp": 1524001823621, + "version": "3.1.3" + }, + "aiohttp-3.2.1-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.5,<3.6.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3dc79decb2cdd095accafaa85f7b0d76", + "name": "aiohttp", + "sha256": "dbc11f81d40e23a575c9a03faaff8062b87070cc58a5b0c9c3412d34da4ddd66", + "size": 406632, + "subdir": "linux-64", + "timestamp": 1526921044031, + "version": "3.2.1" + }, + "aiohttp-3.2.1-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7f53d6c5ca41fedab48e9de787706083", + "name": "aiohttp", + "sha256": "3d51bb147f9980ce1c114790d5562c6566f6a49392c1458e208b97ca3416ce7e", + "size": 406107, + "subdir": "linux-64", + "timestamp": 1526921007509, + "version": "3.2.1" + }, + "aiohttp-3.3.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.5,<3.6.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "97419cad4fda2c369ef93e8f44d6d60b", + "name": "aiohttp", + "sha256": "86bda63cdf53db10a4b498b4b6618de22a1f62f4482f990090dbec9e9b03fd9e", + "size": 315449, + "subdir": "linux-64", + "timestamp": 1528209781006, + "version": "3.3.0" + }, + "aiohttp-3.3.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4063c9f876a6800f080efe314ef38345", + "name": "aiohttp", + "sha256": "a251a0958efed71762be44987471343baf639afa6531587ddfa61dadfdc008bf", + "size": 312370, + "subdir": "linux-64", + "timestamp": 1528209688726, + "version": "3.3.0" + }, + "aiohttp-3.3.2-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.5,<3.6.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9192c7f440252193f79f810cd605a299", + "name": "aiohttp", + "sha256": "d93c557480fe60dcdebbdeabbafb44783b8afafe71c315e3f41f1c3b14fc28da", + "size": 430524, + "subdir": "linux-64", + "timestamp": 1529417688706, + "version": "3.3.2" + }, + "aiohttp-3.3.2-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9af4287d7052ebacb1663f40831edc5d", + "name": "aiohttp", + "sha256": "c52054d3696b3e0e45f9fdef646a8beb19a224bd31cac33d31027e0549f341ff", + "size": 429189, + "subdir": "linux-64", + "timestamp": 1529417674668, + "version": "3.3.2" + }, + "aiohttp-3.3.2-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0,<5.0", + "python >=3.7,<3.8.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "368f5b6f128d34f2e02684fd1ff5b2eb", + "name": "aiohttp", + "sha256": "0bca9edeaf0cd6b2ddbea7c1b74544115187ef7a15c6dcb13babe3b84d2976c8", + "size": 428369, + "subdir": "linux-64", + "timestamp": 1530736572948, + "version": "3.3.2" + }, + "aiohttp-3.4.2-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.5,<3.6.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d97a99f87e45b5afb44d78dbac82a84e", + "name": "aiohttp", + "sha256": "a0fd89230273d23c6f8f714f5edd8e3f47e2ce448850c8f5eefeb3755efe6ca9", + "size": 507838, + "subdir": "linux-64", + "timestamp": 1536103454616, + "version": "3.4.2" + }, + "aiohttp-3.4.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c97bffb0daf71a1ffba2177b5ec4af08", + "name": "aiohttp", + "sha256": "1fcb622b6c94ea9b2f3321df88a747bc91eeb96ee38222d3d3425e91f59e7878", + "size": 507223, + "subdir": "linux-64", + "timestamp": 1536103356588, + "version": "3.4.2" + }, + "aiohttp-3.4.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.7,<3.8.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6a21c9f411911072d9a49d943d64aaf4", + "name": "aiohttp", + "sha256": "f11c4b858cba6262918463d98ce340f2ee2cd5bf37c0a1917dae00f9850d1a84", + "size": 505635, + "subdir": "linux-64", + "timestamp": 1536103419576, + "version": "3.4.2" + }, + "aiohttp-3.4.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "52aa2aa42f259d85253ecf2ba68ec0d6", + "name": "aiohttp", + "sha256": "683d2adb7528ddb5bc1713df02a0e09f0216428e01fcf8feb0dd909fba425e24", + "size": 506740, + "subdir": "linux-64", + "timestamp": 1538181025693, + "version": "3.4.3" + }, + "aiohttp-3.4.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.7,<3.8.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7a897333e30a3239d3bc65e5632f7877", + "name": "aiohttp", + "sha256": "933803dd64524592a5ca0dfbe07f91476119b09a28d0b923bc8c4d95e763f8f6", + "size": 506865, + "subdir": "linux-64", + "timestamp": 1538180984810, + "version": "3.4.3" + }, + "aiohttp-3.4.4-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6c53d41077b19f562eca05e6793bcce2", + "name": "aiohttp", + "sha256": "9c2161d0ae37b93e86c0793062e0c42852547b71bd0ffaa67fb293f5090af826", + "size": 507939, + "subdir": "linux-64", + "timestamp": 1539465947367, + "version": "3.4.4" + }, + "aiohttp-3.4.4-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.7,<3.8.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f4c12728bf9a0bb98a08edab5e459e0f", + "name": "aiohttp", + "sha256": "02526a3bf10a95d4123448712246d7059b2510c849c29863e5757522ea6a8b6f", + "size": 507266, + "subdir": "linux-64", + "timestamp": 1539465957589, + "version": "3.4.4" + }, + "aiohttp-3.5.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9bb0740dbb5014c135072b850c64eb77", + "name": "aiohttp", + "sha256": "d2adc73a2e7ff7c00317379db38a39cd0d8a44b4f25863750825a9bc295e0464", + "size": 541201, + "subdir": "linux-64", + "timestamp": 1547221851760, + "version": "3.5.1" + }, + "aiohttp-3.5.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.7,<3.8.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "655c0824a1657e66b1ef1f69da84e40d", + "name": "aiohttp", + "sha256": "02e2358f5ad5963a92249090ea96bb1f16cc35b9a6c02ad5695791c67536e869", + "size": 543244, + "subdir": "linux-64", + "timestamp": 1547221886429, + "version": "3.5.1" + }, + "aiohttp-3.5.4-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.6,<3.7.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b1cc7f4adb0cf846862f2850bcab0791", + "name": "aiohttp", + "sha256": "204767ceeeccd1155df7874e444b58598208df0a0d4814e7f15731c7b6cc3a28", + "size": 544966, + "subdir": "linux-64", + "timestamp": 1547745168854, + "version": "3.5.4" + }, + "aiohttp-3.5.4-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0,<5.0", + "python >=3.7,<3.8.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f273c36e6161f5ae8829d5a5ae6a2987", + "name": "aiohttp", + "sha256": "b5fb74b6e233f23144dcc18a8d31600e2aefea4ccd9b3ef1eae2fbed44149456", + "size": 546785, + "subdir": "linux-64", + "timestamp": 1547745189964, + "version": "3.5.4" + }, + "aiohttp-3.6.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.6,<3.7.0a0", + "typing_extensions >=3.6.5", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6031e13aa31fac515556170ee5e166a1", + "name": "aiohttp", + "sha256": "a1d00206158417cadb99493a0dc766dfca182defc291756150f0bf920e8c49e9", + "size": 555224, + "subdir": "linux-64", + "timestamp": 1569354725753, + "version": "3.6.1" + }, + "aiohttp-3.6.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.7,<3.8.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0d9975965a6cabd8142d721469bf8821", + "name": "aiohttp", + "sha256": "f5155afae7240ff5a2103d1f4de65677dfafe12a9e0d462e446493f7c0d7ede8", + "size": 554765, + "subdir": "linux-64", + "timestamp": 1569351515515, + "version": "3.6.1" + }, + "aiohttp-3.6.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.8,<3.9.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "51da7646c3d2674d5e8718941b63d082", + "name": "aiohttp", + "sha256": "dda9f9a68a031f70e8f66999628a34402c376935a955271869bfb35f79450013", + "size": 561582, + "subdir": "linux-64", + "timestamp": 1574097774981, + "version": "3.6.1" + }, + "aiohttp-3.6.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.6,<3.7.0a0", + "typing_extensions >=3.6.5", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a7005bdb0401c6a63c35168adf5aee48", + "name": "aiohttp", + "sha256": "ac3153725991484e8dde7a5d5c99ca19ffb0968e03c8a3c4b9e61e00708cc949", + "size": 556855, + "subdir": "linux-64", + "timestamp": 1574366164673, + "version": "3.6.2" + }, + "aiohttp-3.6.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.7,<3.8.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8fec640217bbee2adf2d51fa115680ab", + "name": "aiohttp", + "sha256": "b591ed6c8c742b42c2e6b584007cf8a11343fb55a4ef3cbf960b1dbc1f9083cd", + "size": 556744, + "subdir": "linux-64", + "timestamp": 1574366172846, + "version": "3.6.2" + }, + "aiohttp-3.6.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.8,<3.9.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bc5e361dd437eb20d495c5dc90fc2dd1", + "name": "aiohttp", + "sha256": "98a7937aadeb6ce2b9dd62650fa466394003455673a04b4e5a4cf00d2f9b88b4", + "size": 566554, + "subdir": "linux-64", + "timestamp": 1591133496059, + "version": "3.6.2" + }, + "aiohttp-3.6.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1,<2", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.6,<3.7.0a0", + "typing_extensions >=3.6.5", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a09b5de05b73a7dc10e02651299f13c2", + "name": "aiohttp", + "sha256": "57dc85f103e4e2691ac9c99959118578f99d5eb0ff35e0e40318dd00abd23436", + "size": 554633, + "subdir": "linux-64", + "timestamp": 1602530332630, + "version": "3.6.3" + }, + "aiohttp-3.6.3-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.6,<3.7.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<1.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f0e47cde0618d20df8d1469635fdf42c", + "name": "aiohttp", + "sha256": "35bc0d73def42c450ed71d68ac2437b71572a62aaf4ebe3dafc75174126647f4", + "size": 551571, + "subdir": "linux-64", + "timestamp": 1603204991544, + "version": "3.6.3" + }, + "aiohttp-3.6.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.7,<3.8.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "869088d14f42739c6bb12b9580002a95", + "name": "aiohttp", + "sha256": "4e6f119d857b1eca347c0c8112bd653228e9e34517140ca8a050a6f17d6cd534", + "size": 557061, + "subdir": "linux-64", + "timestamp": 1602530363812, + "version": "3.6.3" + }, + "aiohttp-3.6.3-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<1.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c18dee9ce7df7c9da63fd3e74ac08f32", + "name": "aiohttp", + "sha256": "4d2be00ff9d3743148d19f4ec0eb2f16e7ce9cc7f507826ce67014fc26b9017d", + "size": 551044, + "subdir": "linux-64", + "timestamp": 1603204989518, + "version": "3.6.3" + }, + "aiohttp-3.6.3-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.8,<3.9.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "86e0e943db403ce2eacfe8a4222eed36", + "name": "aiohttp", + "sha256": "cb72573630f331bad37283d7270bdb256f1e5e922767e7ce96c93d208d17d363", + "size": 566231, + "subdir": "linux-64", + "timestamp": 1602530351863, + "version": "3.6.3" + }, + "aiohttp-3.6.3-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<1.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c7bb25304e4745c32db6a061e417bed3", + "name": "aiohttp", + "sha256": "252ff17451201ba0e50d76f85c75ccea9dd084f269de8c5319f54a444eb08217", + "size": 562598, + "subdir": "linux-64", + "timestamp": 1603204994987, + "version": "3.6.3" + }, + "aiohttp-3.7.2-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.6,<3.7.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<1.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b62f0490bd6416a098ad5a29efb0279e", + "name": "aiohttp", + "sha256": "de2fee43f28c1b67f9d050fdf392135b10c5a2b6a942d0838ece9832c53266b8", + "size": 542993, + "subdir": "linux-64", + "timestamp": 1603893315388, + "version": "3.7.2" + }, + "aiohttp-3.7.2-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<1.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "97dcac55bb9cd0896ea732da95cb9957", + "name": "aiohttp", + "sha256": "a55e93fa6bc5540289523c7fed32ca62ce419e0b86042937978f21576307fa28", + "size": 545613, + "subdir": "linux-64", + "timestamp": 1603893288200, + "version": "3.7.2" + }, + "aiohttp-3.7.2-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<1.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1a475d506c859a1c67521ac810276e49", + "name": "aiohttp", + "sha256": "826db8ac79015dbcb164e6d8bf0da54db8a9c1c964e6ee7f91727cf41a3523ff", + "size": 556627, + "subdir": "linux-64", + "timestamp": 1603893291931, + "version": "3.7.2" + }, + "aiohttp-3.7.3-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.6,<3.7.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<1.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3baacc17aa92f580cb7358205831af81", + "name": "aiohttp", + "sha256": "0beebd43cea06e363b634bdfb15f28e9f73d43e6a5a1e4bd3898881caa19297d", + "size": 547591, + "subdir": "linux-64", + "timestamp": 1607109698065, + "version": "3.7.3" + }, + "aiohttp-3.7.3-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<1.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "27d6930608cd4fb578fa82192dfe6226", + "name": "aiohttp", + "sha256": "d08bf4d2f431f62e73654905fd7dbf91b574aff6b7dc5c6b30c22a60c003c156", + "size": 547523, + "subdir": "linux-64", + "timestamp": 1607109682805, + "version": "3.7.3" + }, + "aiohttp-3.7.3-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<5.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<1.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "992c5697ffa5fe8bf6018f38d7aa2513", + "name": "aiohttp", + "sha256": "aec6451fee3d0b43ee7bca4f77f105edf7afa1f257493a8a772f4cbb2aa0cbb1", + "size": 557128, + "subdir": "linux-64", + "timestamp": 1607109665015, + "version": "3.7.3" + }, + "aiohttp-3.7.3-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<7.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0211f7a4a45cb6e76edafef947785757", + "name": "aiohttp", + "sha256": "2f0de70f08af10e8d8eab57f7c1481ee6cbc1e0221729b334069b7924f18851d", + "size": 559475, + "subdir": "linux-64", + "timestamp": 1613390632412, + "version": "3.7.3" + }, + "aiohttp-3.7.4-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "idna_ssl >=1.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<7.0", + "python >=3.6,<3.7.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3cd509bdfcf8af72115fbfa4f5b7a293", + "name": "aiohttp", + "sha256": "6acca8f3d12a2c9f644dedf9fa890868db2ee6ac11983f2646591ad45bd95cc7", + "size": 545663, + "subdir": "linux-64", + "timestamp": 1614361065144, + "version": "3.7.4" + }, + "aiohttp-3.7.4-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<7.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0a9904873718e01b507c7c0a98574074", + "name": "aiohttp", + "sha256": "15423d721c248a90ef37600472af37b3c4df21888dbcb3119e61882fc86665c8", + "size": 549061, + "subdir": "linux-64", + "timestamp": 1614361051112, + "version": "3.7.4" + }, + "aiohttp-3.7.4-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<7.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a63fd7fd72d392d9206b8093b6a5a269", + "name": "aiohttp", + "sha256": "484c90e025886276753381d965bc32437a865e107f715898458841d35290a3b1", + "size": 554676, + "subdir": "linux-64", + "timestamp": 1614361065092, + "version": "3.7.4" + }, + "aiohttp-3.7.4-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "async-timeout <4.0,>=3.0", + "attrs >=17.3.0", + "chardet >=2.0,<4.0", + "libgcc-ng >=7.3.0", + "multidict >=4.5,<7.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "51474f17c578c708942dc7fa950c95da", + "name": "aiohttp", + "sha256": "4ba95a3287774151d9c667fc8e4aa62a9a31e1b308e28bcc68fdb039821c6033", + "size": 555297, + "subdir": "linux-64", + "timestamp": 1614361043162, + "version": "3.7.4" + }, + "aiohttp-3.7.4.post0-py310h7f8727e_2.conda": { + "build": "py310h7f8727e_2", + "build_number": 2, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<5.0", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.10,<3.11.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0ce3e7ee8fc4f4bae811d84da88cb9eb", + "name": "aiohttp", + "sha256": "7fcec307f10f5553dda4905a9169b087e82fc5a5c1fa7e44790f80e37c0c1f6a", + "size": 979457, + "subdir": "linux-64", + "timestamp": 1640811543714, + "version": "3.7.4.post0" + }, + "aiohttp-3.7.4.post0-py36h7f8727e_2.conda": { + "build": "py36h7f8727e_2", + "build_number": 2, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<5.0", + "idna_ssl >=1.0", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.6,<3.7.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5569cdb929446449c43d763a8a6f72db", + "name": "aiohttp", + "sha256": "f4bb9492d273ddb7f952dc13754bf7588465c7e3b312fd76168f4c8f92eb858d", + "size": 552533, + "subdir": "linux-64", + "timestamp": 1632748137770, + "version": "3.7.4.post0" + }, + "aiohttp-3.7.4.post0-py37h7f8727e_2.conda": { + "build": "py37h7f8727e_2", + "build_number": 2, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<5.0", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c8cdb01320a494fd988f9a1a9b5a68fc", + "name": "aiohttp", + "sha256": "a00904f0b753a4251210fbf5bb622765c2fb2ae649c3155818e9b657bbe9c90a", + "size": 554052, + "subdir": "linux-64", + "timestamp": 1632748484944, + "version": "3.7.4.post0" + }, + "aiohttp-3.7.4.post0-py38h7f8727e_2.conda": { + "build": "py38h7f8727e_2", + "build_number": 2, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<5.0", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d48bd83010898a5b4cf1b629d4fd2b4d", + "name": "aiohttp", + "sha256": "bbdeb6dc1a12c1518668346e80bd88da75cabb52098ab0df6e3acb6878f9ec64", + "size": 565975, + "subdir": "linux-64", + "timestamp": 1632748471029, + "version": "3.7.4.post0" + }, + "aiohttp-3.7.4.post0-py39h7f8727e_2.conda": { + "build": "py39h7f8727e_2", + "build_number": 2, + "depends": [ + "async-timeout >=3.0,<4.0", + "attrs >=17.3.0", + "chardet >=2.0,<5.0", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.6.5", + "yarl >=1.0,<2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3d2f589f9c0fbdec7fcb626d32e59961", + "name": "aiohttp", + "sha256": "51ffa2ae52f1d998666b35620ecd5162e8b393aa054d5f7e3da214f20941d6b3", + "size": 560869, + "subdir": "linux-64", + "timestamp": 1632748481730, + "version": "3.7.4.post0" + }, + "aiohttp-3.8.1-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.10,<3.11.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "17275ae999c15f7aa226dc01b1236617", + "name": "aiohttp", + "sha256": "9634c6cb1c5dcc5015b73d45771b742bf557ac24384159b675752358809b31bd", + "size": 916308, + "subdir": "linux-64", + "timestamp": 1646806430383, + "version": "3.8.1" + }, + "aiohttp-3.8.1-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "asynctest 0.13.0.*", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ff27de926d453d4ba06f2c3a3784f34c", + "name": "aiohttp", + "sha256": "9442164803ed32e21a8dbda06d8d2db0712c5c066ac85f278ccb4d278556c1fe", + "size": 522785, + "subdir": "linux-64", + "timestamp": 1637857146913, + "version": "3.8.1" + }, + "aiohttp-3.8.1-py37h7f8727e_1.conda": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "asynctest 0.13.0.*", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a2aba5e38a68006b6630f4a42edea783", + "name": "aiohttp", + "sha256": "bc9ffbb9a7b42d2a3544e4d5f7fa5eca96db65663741d1aec5df0ea4693f1e15", + "size": 525995, + "subdir": "linux-64", + "timestamp": 1646788290611, + "version": "3.8.1" + }, + "aiohttp-3.8.1-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.8,<3.9.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "44161ddb65902f8d4e403443a32aef91", + "name": "aiohttp", + "sha256": "2237389b481d18f562ea32ed71dddf61086bc20bf000e620dff33a0795b554f8", + "size": 531076, + "subdir": "linux-64", + "timestamp": 1637844213877, + "version": "3.8.1" + }, + "aiohttp-3.8.1-py38h7f8727e_1.conda": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.8,<3.9.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8ef4e9cb16cea30c4e37eafe25a54206", + "name": "aiohttp", + "sha256": "10bca83abbef62a8624369c8b680a6a025ee8fd61a4703dc224b17b40583b2c8", + "size": 537558, + "subdir": "linux-64", + "timestamp": 1646806416719, + "version": "3.8.1" + }, + "aiohttp-3.8.1-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.9,<3.10.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "59a1a49712cb903f290e7a3053e5ff77", + "name": "aiohttp", + "sha256": "765ced30ca03373f43cc50d953470890139a4cc329e51104cf0a33d51b677163", + "size": 528828, + "subdir": "linux-64", + "timestamp": 1637856948637, + "version": "3.8.1" + }, + "aiohttp-3.8.1-py39h7f8727e_1.conda": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=7.5.0", + "multidict >=4.5,<7.0", + "python >=3.9,<3.10.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "552f4d51953e986357ef31f70bb3a8ad", + "name": "aiohttp", + "sha256": "b51837c0defc2a8ab88f55f70bab37d16099139f25325f23e47eb8389056cd4e", + "size": 537133, + "subdir": "linux-64", + "timestamp": 1646806413651, + "version": "3.8.1" + }, + "aiohttp-3.8.3-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=11.2.0", + "multidict >=4.5,<7.0", + "python >=3.10,<3.11.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "245b9ba8845b232dbac0d047f645f174", + "name": "aiohttp", + "sha256": "14b41023cf91768861026fc0648e65f2c984722b897ec0baa0ad438f70fe62f5", + "size": 466303, + "subdir": "linux-64", + "timestamp": 1670009644981, + "version": "3.8.3" + }, + "aiohttp-3.8.3-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=11.2.0", + "multidict >=4.5,<7.0", + "python >=3.11,<3.12.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f6a2cefa8b74c269bed7d42f273cfb44", + "name": "aiohttp", + "sha256": "f8ba070b3d1c9c546c1a611e4ae258fce9c3194bbf8ace13c9d570e46640e303", + "size": 541564, + "subdir": "linux-64", + "timestamp": 1676827647590, + "version": "3.8.3" + }, + "aiohttp-3.8.3-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "asynctest 0.13.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=11.2.0", + "multidict >=4.5,<7.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b0edda41a39b746f1bba3b1c73f8e173", + "name": "aiohttp", + "sha256": "f553ad43c64509d45aaafb38f74b3cce7a508639bce2e3de2144329c2933c645", + "size": 457254, + "subdir": "linux-64", + "timestamp": 1670009606141, + "version": "3.8.3" + }, + "aiohttp-3.8.3-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=11.2.0", + "multidict >=4.5,<7.0", + "python >=3.8,<3.9.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "797ac89354311616677b627626d8607b", + "name": "aiohttp", + "sha256": "e1e86cfbfe6f7194e369db51b98876f6958e895d284a430cfc31c7eca21edfab", + "size": 465525, + "subdir": "linux-64", + "timestamp": 1670009721104, + "version": "3.8.3" + }, + "aiohttp-3.8.3-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "aiosignal >=1.1.2", + "async-timeout >=4.0.0a3,<5.0", + "attrs >=17.3.0", + "charset-normalizer >=2.0,<3.0", + "frozenlist >=1.1.1", + "libgcc-ng >=11.2.0", + "multidict >=4.5,<7.0", + "python >=3.9,<3.10.0a0", + "yarl >=1.0,<2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "363f9fbcf45b8e6dd36b91ea01f2be7b", + "name": "aiohttp", + "sha256": "0249e65b8503dabc5e5fa1edf4de8ec6181b749b1dc6893571dfb9149c82e350", + "size": 464094, + "subdir": "linux-64", + "timestamp": 1670009682967, + "version": "3.8.3" + }, + "aiopg-1.3.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<5.0", + "psycopg2 >=2.8.4", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "33da6b0b15e184663e2820e2c6927ec6", + "name": "aiopg", + "sha256": "e41ca585d8e96fbcad63a29808a09c989a5b291466f9590955f8c67756f6a945", + "size": 60335, + "subdir": "linux-64", + "timestamp": 1663356775079, + "version": "1.3.4" + }, + "aiopg-1.3.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<5.0", + "psycopg2 >=2.8.4", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "bc2ada3d5c475825907fe49ea3e9f1b4", + "name": "aiopg", + "sha256": "8c18e3ac321452f930dc9c9f73d475552b823945d30cb58686b8d4fe3f81ad29", + "size": 77706, + "subdir": "linux-64", + "timestamp": 1679340077473, + "version": "1.3.4" + }, + "aiopg-1.3.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<5.0", + "psycopg2 >=2.8.4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a8090745f27460491bbace51ca5504d9", + "name": "aiopg", + "sha256": "7e798d8e1d1426cc732a1233e9fd13a153d7c503af0aff5b3326aec33f1392c8", + "size": 58009, + "subdir": "linux-64", + "timestamp": 1663356856201, + "version": "1.3.4" + }, + "aiopg-1.3.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<5.0", + "psycopg2 >=2.8.4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "618ff7513b33a1328af2bc4bd76c63ab", + "name": "aiopg", + "sha256": "9cbb237aab7d12bc78a1fea565c16c710ae40ef4b386a8907df73df71cdb4026", + "size": 58519, + "subdir": "linux-64", + "timestamp": 1663356801538, + "version": "1.3.4" + }, + "aiopg-1.3.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=3.0,<5.0", + "psycopg2 >=2.8.4", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "1efd6622145a91fc36a94941ddca86dd", + "name": "aiopg", + "sha256": "e3d4fe3161f598594e95891e8a5aa07b8e27ac6fb94b81608584b400042da398", + "size": 58583, + "subdir": "linux-64", + "timestamp": 1663356829126, + "version": "1.3.4" + }, + "aiorwlock-1.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8cf9d26ba15070472b35d6f2e1e3e450", + "name": "aiorwlock", + "sha256": "5ab8a47947acffc65032fdbea350ac54fc00c4ddcf6c6a07d4d6d854347f4890", + "size": 17959, + "subdir": "linux-64", + "timestamp": 1677738263770, + "version": "1.3.0" + }, + "aiorwlock-1.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "992a3d4b80413324a22d6770ccf84feb", + "name": "aiorwlock", + "sha256": "f2ad8bc8cb4e6509082c76001ed6d3c6c95552ebada719eb440656fed63aef90", + "size": 17789, + "subdir": "linux-64", + "timestamp": 1677738215264, + "version": "1.3.0" + }, + "aiorwlock-1.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "590771ab25100c677a5f69f55e84eb5a", + "name": "aiorwlock", + "sha256": "ad6c8eed097fb0bf3fcc6e84481f1ff3c0826ef1bf89c3fb337bba755e1ef605", + "size": 17775, + "subdir": "linux-64", + "timestamp": 1677738239438, + "version": "1.3.0" + }, + "airflow-1.10.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alembic >=1.0,<2.0", + "argcomplete >=1.10.0", + "attrs >=19.3,<19.4", + "cached-property >=1.5.0,<1.6.0", + "cattrs >=0.9", + "colorlog >=4.0.2", + "configparser >=3.5.0", + "croniter >=0.3.17,<0.4", + "dill >=0.2.2,<0.4", + "flask >=1.1.0,<2.0", + "flask-admin 1.5.4", + "flask-appbuilder >=2.2,<2.3", + "flask-caching >=1.3.3", + "flask-login >=0.3,<0.5", + "flask-swagger 0.2.13", + "flask-wtf >=0.14.2,<0.15", + "funcsigs >=1.0.0,<2.0.0", + "future >=0.16.0,<0.19", + "gunicorn >=19.5.0", + "iso8601 >=0.1.12", + "jinja2 >=2.10.1", + "json-merge-patch 0.2", + "jsonschema >=3.0.0,<3.1.0", + "lazy-object-proxy >=1.3.0", + "markdown >=2.5.2", + "pandas >=0.17.1", + "pendulum 1.4.4", + "psutil >=4.2.0,<6.0.0", + "pygments >=2.0.1,<3.0", + "python >=3.6,<3.7.0a0", + "python-daemon >=2.1.1", + "python-dateutil >=2.3,<3", + "python-graphviz >=0.12", + "pytzdata >=2018.3", + "requests >=2.20.0,<3", + "setproctitle >=1.1.8,<2", + "sqlalchemy >=1.3.0,<1.4.0", + "sqlalchemy-jsonfield >=0.9.0,<0.10.0", + "tabulate >=0.7.5,<0.9", + "tenacity", + "termcolor >=1.1.0", + "text-unidecode >=1.2,<2.0", + "thrift >=0.9.2", + "typing_extensions >=3.7.4", + "tzlocal >=1.4", + "unicodecsv >=0.14.1", + "werkzeug", + "zope.deprecation >=4.0,<5.0" + ], + "license": "Apache 2.0", + "md5": "2f0e044decd73c11c9b54dad4f4fc305", + "name": "airflow", + "sha256": "a90bcc31a63f71a518b9e491b41dc5d1ef43e85ebd06b306a22465755b4d9dda", + "size": 2540662, + "subdir": "linux-64", + "timestamp": 1593114339987, + "version": "1.10.10" + }, + "airflow-1.10.10-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alembic >=1.0,<2.0", + "argcomplete >=1.10.0", + "attrs >=19.3,<19.4", + "cached-property >=1.5.0,<1.6.0", + "cattrs >=0.9", + "colorlog >=4.0.2", + "configparser >=3.5.0", + "croniter >=0.3.17,<0.4", + "dill >=0.2.2,<0.4", + "flask >=1.1.0,<2.0", + "flask-admin 1.5.4", + "flask-appbuilder >=2.2,<2.3", + "flask-caching >=1.3.3", + "flask-login >=0.3,<0.5", + "flask-swagger 0.2.13", + "flask-wtf >=0.14.2,<0.15", + "funcsigs >=1.0.0,<2.0.0", + "future >=0.16.0,<0.19", + "gunicorn >=19.5.0", + "iso8601 >=0.1.12", + "jinja2 >=2.10.1", + "json-merge-patch 0.2", + "jsonschema >=3.0.0,<3.1.0", + "lazy-object-proxy >=1.3.0", + "markdown >=2.5.2", + "pandas >=0.17.1", + "pendulum 1.4.4", + "psutil >=4.2.0,<6.0.0", + "pygments >=2.0.1,<3.0", + "python >=3.7,<3.8.0a0", + "python-daemon >=2.1.1", + "python-dateutil >=2.3,<3", + "python-graphviz >=0.12", + "pytzdata >=2018.3", + "requests >=2.20.0,<3", + "setproctitle >=1.1.8,<2", + "sqlalchemy >=1.3.0,<1.4.0", + "sqlalchemy-jsonfield >=0.9.0,<0.10.0", + "tabulate >=0.7.5,<0.9", + "tenacity", + "termcolor >=1.1.0", + "text-unidecode >=1.2,<2.0", + "thrift >=0.9.2", + "typing_extensions >=3.7.4", + "tzlocal >=1.4", + "unicodecsv >=0.14.1", + "werkzeug", + "zope.deprecation >=4.0,<5.0" + ], + "license": "Apache 2.0", + "md5": "a85b64a5db8694201fe53ab82ee27a12", + "name": "airflow", + "sha256": "6cd327f853d9dc7383cc1abdb69ec09d7bd434587e192cf80fd32dec9e90ef65", + "size": 2540451, + "subdir": "linux-64", + "timestamp": 1593114363616, + "version": "1.10.10" + }, + "airflow-1.10.10-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "alembic >=1.0,<2.0", + "argcomplete >=1.10.0", + "attrs >=19.3,<19.4", + "cached-property >=1.5.0,<1.6.0", + "cattrs >=1.0,<1.1.0", + "colorlog >=4.0.2", + "configparser >=3.5.0", + "croniter >=0.3.17,<0.4", + "dill >=0.2.2,<0.4", + "flask >=1.1.0,<2.0", + "flask-admin 1.5.4", + "flask-appbuilder >=2.2,<2.3", + "flask-caching >=1.3.3", + "flask-login >=0.3,<0.5", + "flask-swagger 0.2.13", + "flask-wtf >=0.14.2,<0.15", + "funcsigs >=1.0.0,<2.0.0", + "future >=0.16.0,<0.19", + "gunicorn >=19.5.0", + "iso8601 >=0.1.12", + "jinja2 >=2.10.1", + "json-merge-patch 0.2", + "jsonschema >=3.1.0", + "lazy-object-proxy >=1.3.0", + "markdown >=2.5.2", + "pandas >=0.17.1", + "pendulum 1.4.4", + "psutil >=4.2.0,<6.0.0", + "pygments >=2.0.1,<3.0", + "python >=3.8,<3.9.0a0", + "python-daemon >=2.1.1", + "python-dateutil >=2.3,<3", + "python-graphviz >=0.12", + "pytzdata >=2018.3", + "requests >=2.20.0,<3", + "setproctitle >=1.1.8,<2", + "sqlalchemy >=1.3.0,<1.4.0", + "sqlalchemy-jsonfield >=0.9.0,<0.10.0", + "tabulate >=0.7.5,<0.9", + "tenacity", + "termcolor >=1.1.0", + "text-unidecode >=1.2,<2.0", + "thrift >=0.9.2", + "typing_extensions >=3.7.4", + "tzlocal >=1.4", + "unicodecsv >=0.14.1", + "werkzeug", + "zope.deprecation >=4.0,<5.0" + ], + "license": "Apache 2.0", + "md5": "2fb81d95c3b0ad86823bbdc62561e94b", + "name": "airflow", + "sha256": "bd5fb1dc112cfbb0ee222423ac5c2def716ee978af6bf7c68ca0fdf663ac38dd", + "size": 2548757, + "subdir": "linux-64", + "timestamp": 1593114387504, + "version": "1.10.10" + }, + "airflow-1.10.12-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.0,<2.0", + "argcomplete >=1.10.0", + "attrs >=19.3,<19.4", + "cached-property >=1.5.0,<1.6.0", + "cattrs >=1.0,<1.1.0", + "colorlog >=4.0.2", + "configparser >=3.5.0", + "croniter >=0.3.17,<0.4", + "dill >=0.2.2,<0.4", + "flask >=1.1.0,<2.0", + "flask-admin 1.5.4", + "flask-appbuilder >=2.2,<2.3", + "flask-caching >=1.3.3", + "flask-login >=0.3,<0.5", + "flask-swagger 0.2.13", + "flask-wtf >=0.14.2,<0.15", + "funcsigs >=1.0.0,<2.0.0", + "future >=0.16.0,<0.19", + "gunicorn >=19.5.0", + "iso8601 >=0.1.12", + "jinja2 >=2.10.1", + "json-merge-patch 0.2", + "jsonschema >=3.1.0", + "lazy-object-proxy >=1.3.0", + "markdown >=2.5.2", + "pandas >=0.17.1", + "pendulum 1.4.4", + "psutil >=4.2.0,<6.0.0", + "pygments >=2.0.1,<3.0", + "python >=3.10,<3.11.0a0", + "python-daemon >=2.1.1", + "python-dateutil >=2.3,<3", + "python-graphviz >=0.12", + "requests >=2.20.0,<3", + "setproctitle >=1.1.8,<2", + "sqlalchemy >=1.3.0,<1.4.0", + "sqlalchemy-jsonfield >=0.9.0,<0.10.0", + "tabulate >=0.7.5,<0.9", + "tenacity", + "termcolor >=1.1.0", + "text-unidecode >=1.2,<2.0", + "thrift >=0.9.2", + "typing_extensions >=3.7.4", + "tzlocal >=1.4", + "unicodecsv >=0.14.1", + "werkzeug", + "zope.deprecation >=4.0,<5.0" + ], + "license": "Apache 2.0", + "md5": "5232842e28d0bfeff765979e56a154a7", + "name": "airflow", + "sha256": "7794030a3890c4fe924e7b4d70758d8db749cc17e13bdeb6441eca68178982ba", + "size": 2626084, + "subdir": "linux-64", + "timestamp": 1640811623023, + "version": "1.10.12" + }, + "airflow-1.10.12-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.0,<2.0", + "argcomplete >=1.10.0", + "attrs >=19.3,<19.4", + "cached-property >=1.5.0,<1.6.0", + "cattrs >=0.9,<0.10.0", + "colorlog >=4.0.2", + "configparser >=3.5.0", + "croniter >=0.3.17,<0.4", + "dill >=0.2.2,<0.4", + "flask >=1.1.0,<2.0", + "flask-admin 1.5.4", + "flask-appbuilder >=2.2,<2.3", + "flask-caching >=1.3.3", + "flask-login >=0.3,<0.5", + "flask-swagger 0.2.13", + "flask-wtf >=0.14.2,<0.15", + "funcsigs >=1.0.0,<2.0.0", + "future >=0.16.0,<0.19", + "gunicorn >=19.5.0", + "iso8601 >=0.1.12", + "jinja2 >=2.10.1", + "json-merge-patch 0.2", + "jsonschema >=3.0.0,<3.1.0", + "lazy-object-proxy >=1.3.0", + "markdown >=2.5.2", + "pandas >=0.17.1", + "pendulum 1.4.4", + "psutil >=4.2.0,<6.0.0", + "pygments >=2.0.1,<3.0", + "python >=3.6,<3.7.0a0", + "python-daemon >=2.1.1", + "python-dateutil >=2.3,<3", + "python-graphviz >=0.12", + "requests >=2.20.0,<3", + "setproctitle >=1.1.8,<2", + "sqlalchemy >=1.3.0,<1.4.0", + "sqlalchemy-jsonfield >=0.9.0,<0.10.0", + "tabulate >=0.7.5,<0.9", + "tenacity", + "termcolor >=1.1.0", + "text-unidecode >=1.2,<2.0", + "thrift >=0.9.2", + "typing_extensions >=3.7.4", + "tzlocal >=1.4", + "unicodecsv >=0.14.1", + "werkzeug", + "zope.deprecation >=4.0,<5.0" + ], + "license": "Apache 2.0", + "md5": "9ef82c950d2506db2f3d81cab1d034cf", + "name": "airflow", + "sha256": "f67b7b67a8e1fc2ab9856bea3a4beb1698dbc7fbb05f7f5cff7258ea297969fe", + "size": 2607784, + "subdir": "linux-64", + "timestamp": 1605878117413, + "version": "1.10.12" + }, + "airflow-1.10.12-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.0,<2.0", + "argcomplete >=1.10.0", + "attrs >=19.3,<19.4", + "cached-property >=1.5.0,<1.6.0", + "cattrs >=0.9,<0.10.0", + "colorlog >=4.0.2", + "configparser >=3.5.0", + "croniter >=0.3.17,<0.4", + "dill >=0.2.2,<0.4", + "flask >=1.1.0,<2.0", + "flask-admin 1.5.4", + "flask-appbuilder >=2.2,<2.3", + "flask-caching >=1.3.3", + "flask-login >=0.3,<0.5", + "flask-swagger 0.2.13", + "flask-wtf >=0.14.2,<0.15", + "funcsigs >=1.0.0,<2.0.0", + "future >=0.16.0,<0.19", + "gunicorn >=19.5.0", + "iso8601 >=0.1.12", + "jinja2 >=2.10.1", + "json-merge-patch 0.2", + "jsonschema >=3.0.0,<3.1.0", + "lazy-object-proxy >=1.3.0", + "markdown >=2.5.2", + "pandas >=0.17.1", + "pendulum 1.4.4", + "psutil >=4.2.0,<6.0.0", + "pygments >=2.0.1,<3.0", + "python >=3.7,<3.8.0a0", + "python-daemon >=2.1.1", + "python-dateutil >=2.3,<3", + "python-graphviz >=0.12", + "requests >=2.20.0,<3", + "setproctitle >=1.1.8,<2", + "sqlalchemy >=1.3.0,<1.4.0", + "sqlalchemy-jsonfield >=0.9.0,<0.10.0", + "tabulate >=0.7.5,<0.9", + "tenacity", + "termcolor >=1.1.0", + "text-unidecode >=1.2,<2.0", + "thrift >=0.9.2", + "typing_extensions >=3.7.4", + "tzlocal >=1.4", + "unicodecsv >=0.14.1", + "werkzeug", + "zope.deprecation >=4.0,<5.0" + ], + "license": "Apache 2.0", + "md5": "621fa03d773bcc63de813c1527dac4f6", + "name": "airflow", + "sha256": "cec8101f512aef22738ea5f8d9a1da865e654735f5dbba16b76ac4a7b7800807", + "size": 2609539, + "subdir": "linux-64", + "timestamp": 1605878068062, + "version": "1.10.12" + }, + "airflow-1.10.12-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.0,<2.0", + "argcomplete >=1.10.0", + "attrs >=19.3,<19.4", + "cached-property >=1.5.0,<1.6.0", + "cattrs >=1.0,<1.1.0", + "colorlog >=4.0.2", + "configparser >=3.5.0", + "croniter >=0.3.17,<0.4", + "dill >=0.2.2,<0.4", + "flask >=1.1.0,<2.0", + "flask-admin 1.5.4", + "flask-appbuilder >=2.2,<2.3", + "flask-caching >=1.3.3", + "flask-login >=0.3,<0.5", + "flask-swagger 0.2.13", + "flask-wtf >=0.14.2,<0.15", + "funcsigs >=1.0.0,<2.0.0", + "future >=0.16.0,<0.19", + "gunicorn >=19.5.0", + "iso8601 >=0.1.12", + "jinja2 >=2.10.1", + "json-merge-patch 0.2", + "jsonschema >=3.1.0", + "lazy-object-proxy >=1.3.0", + "markdown >=2.5.2", + "pandas >=0.17.1", + "pendulum 1.4.4", + "psutil >=4.2.0,<6.0.0", + "pygments >=2.0.1,<3.0", + "python >=3.8,<3.9.0a0", + "python-daemon >=2.1.1", + "python-dateutil >=2.3,<3", + "python-graphviz >=0.12", + "requests >=2.20.0,<3", + "setproctitle >=1.1.8,<2", + "sqlalchemy >=1.3.0,<1.4.0", + "sqlalchemy-jsonfield >=0.9.0,<0.10.0", + "tabulate >=0.7.5,<0.9", + "tenacity", + "termcolor >=1.1.0", + "text-unidecode >=1.2,<2.0", + "thrift >=0.9.2", + "typing_extensions >=3.7.4", + "tzlocal >=1.4", + "unicodecsv >=0.14.1", + "werkzeug", + "zope.deprecation >=4.0,<5.0" + ], + "license": "Apache 2.0", + "md5": "73d1e642fc06e766bfafd25cc32572dd", + "name": "airflow", + "sha256": "90233ac10bffd026ff65487534a96e8f4a2e62e65c4363e1e16aa2c8524030d7", + "size": 2618006, + "subdir": "linux-64", + "timestamp": 1605878092698, + "version": "1.10.12" + }, + "airflow-1.10.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alembic >=1.0,<2.0", + "argcomplete >=1.10.0,<1.11.0", + "backports", + "cached-property >=1.5.0,<1.6.0", + "cattrs >=0.9,<0.10.0", + "colorlog 4.0.2", + "configparser >=3.5.0,<3.6.0", + "croniter >=0.3.17,<0.4", + "dill >=0.2.2,<0.4", + "flask >=1.1.0,<2.0", + "flask-admin 1.5.3", + "flask-appbuilder >=1.12.5,<2.0.0", + "flask-caching >=1.3.3,<1.4.0", + "flask-login >=0.3,<0.5", + "flask-swagger 0.2.13", + "flask-wtf >=0.14.2,<0.15", + "funcsigs >=1.0.2,<2.0.0", + "future >=0.16.0,<0.17", + "gunicorn >=19.5.0,<20.0", + "iso8601 >=0.1.12", + "jinja2 >=2.10.1,<2.11.0", + "json-merge-patch 0.2", + "jsonschema >=3.0.0,<4.0.0", + "lazy-object-proxy >=1.3.0,<1.4.0", + "markdown >=2.5.2,<3.0", + "pandas >=0.17.1,<1.0.0", + "pendulum 1.4.4", + "psutil >=4.2.0,<6.0.0", + "pygments >=2.0.1,<3.0", + "python >=3.6,<3.7.0a0", + "python-daemon >=2.1.1,<2.2", + "python-dateutil >=2.3,<3", + "python-graphviz >=0.12", + "requests >=2.20.0,<3", + "setproctitle >=1.1.8,<2", + "sqlalchemy >=1.3.0,<1.4.0", + "sqlalchemy-jsonfield >=0.9.0,<0.10.0", + "tabulate >=0.7.5,<0.9", + "tenacity 4.12.0", + "termcolor 1.1.0", + "text-unidecode 1.2", + "thrift >=0.9.2", + "typing_extensions >=3.7.4", + "tzlocal >=1.4,<2.0.0", + "unicodecsv >=0.14.1", + "zope.deprecation >=4.0,<5.0" + ], + "license": "Apache 2.0", + "md5": "1b8ef337e7c0b1041b3f14380027918b", + "name": "airflow", + "sha256": "3e85b224c86e89be179e731876506bfccf59512eb044f088553c7729fa29a7da", + "size": 2475956, + "subdir": "linux-64", + "timestamp": 1579721342751, + "version": "1.10.7" + }, + "airflow-1.10.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alembic >=1.0,<2.0", + "argcomplete >=1.10.0,<1.11.0", + "backports", + "cached-property >=1.5.0,<1.6.0", + "cattrs >=0.9,<0.10.0", + "colorlog 4.0.2", + "configparser >=3.5.0,<3.6.0", + "croniter >=0.3.17,<0.4", + "dill >=0.2.2,<0.4", + "flask >=1.1.0,<2.0", + "flask-admin 1.5.3", + "flask-appbuilder >=1.12.5,<2.0.0", + "flask-caching >=1.3.3,<1.4.0", + "flask-login >=0.3,<0.5", + "flask-swagger 0.2.13", + "flask-wtf >=0.14.2,<0.15", + "funcsigs >=1.0.2,<2.0.0", + "future >=0.16.0,<0.17", + "gunicorn >=19.5.0,<20.0", + "iso8601 >=0.1.12", + "jinja2 >=2.10.1,<2.11.0", + "json-merge-patch 0.2", + "jsonschema >=3.0.0,<4.0.0", + "lazy-object-proxy >=1.3.0,<1.4.0", + "markdown >=2.5.2,<3.0", + "pandas >=0.17.1,<1.0.0", + "pendulum 1.4.4", + "psutil >=4.2.0,<6.0.0", + "pygments >=2.0.1,<3.0", + "python >=3.7,<3.8.0a0", + "python-daemon >=2.1.1,<2.2", + "python-dateutil >=2.3,<3", + "python-graphviz >=0.12", + "requests >=2.20.0,<3", + "setproctitle >=1.1.8,<2", + "sqlalchemy >=1.3.0,<1.4.0", + "sqlalchemy-jsonfield >=0.9.0,<0.10.0", + "tabulate >=0.7.5,<0.9", + "tenacity 4.12.0", + "termcolor 1.1.0", + "text-unidecode 1.2", + "thrift >=0.9.2", + "typing_extensions >=3.7.4", + "tzlocal >=1.4,<2.0.0", + "unicodecsv >=0.14.1", + "zope.deprecation >=4.0,<5.0" + ], + "license": "Apache 2.0", + "md5": "3d8fef2bc830bd0bf08fc9f80cb68bdd", + "name": "airflow", + "sha256": "e15cf00237e2ee015eeead77857e913e6f4a1b5be3ff646ec0c44ca163b634fb", + "size": 2475379, + "subdir": "linux-64", + "timestamp": 1579721367255, + "version": "1.10.7" + }, + "airflow-2.3.3-py310h02b9991_0.conda": { + "build": "py310h02b9991_0", + "build_number": 0, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=20.0,<21.0", + "blinker", + "cattrs >=1.1,<2,!=1.7.*", + "colorlog >=4.0.2,<5.0", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=1.0.4,<3", + "flask >=2.0", + "flask-appbuilder 4.1.2.*", + "flask-caching >=1.5.0", + "flask-login >=0.5", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=19.5.0", + "httpx", + "itsdangerous >=0.24", + "itsdangerous >=2.0", + "jinja2 >=2.10.1", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1q,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.10,<3.11.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=3.7.4", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "md5": "758fe90b40ef99d8ed6b013489d7dd0c", + "name": "airflow", + "sha256": "befd1cbeec72f743de5ef479c66ea8ab916402c55b7eedbf650dd59bae86bb7f", + "size": 4384534, + "subdir": "linux-64", + "timestamp": 1659883887663, + "version": "2.3.3" + }, + "airflow-2.3.3-py310h02b9991_1.conda": { + "build": "py310h02b9991_1", + "build_number": 1, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=20.0,<21.0", + "blinker", + "cattrs >=1.1,<2,!=1.7.*", + "colorlog >=4.0.2,<5.0", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=1.0.4,<3", + "flask >=2.0", + "flask-appbuilder 4.1.2.*", + "flask-caching >=1.5.0", + "flask-login >=0.5", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=19.5.0", + "httpx", + "itsdangerous >=0.24", + "itsdangerous >=2.0", + "jinja2 >=2.10.1", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1q,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.10,<3.11.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=3.7.4", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "md5": "8ebab5c109df06d4a8987a2e3867fc43", + "name": "airflow", + "sha256": "598a8f668a9bdb3be90c5ebad067f2c184c2f270843cfca36d1e527627d426b1", + "size": 4367355, + "subdir": "linux-64", + "timestamp": 1659934742234, + "version": "2.3.3" + }, + "airflow-2.3.3-py37h02b9991_0.conda": { + "build": "py37h02b9991_0", + "build_number": 0, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=20.0,<21.0", + "blinker", + "cached-property >=1.5", + "cattrs >=1.1,<2,!=1.7.*", + "colorlog >=4.0.2,<5.0", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=1.0.4,<3", + "flask >=2.0", + "flask-appbuilder 4.1.2.*", + "flask-caching >=1.5.0", + "flask-login >=0.5", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=19.5.0", + "httpx", + "importlib_metadata >=1.7", + "importlib_resources >=5.2", + "itsdangerous >=0.24", + "itsdangerous >=2.0", + "jinja2 >=2.10.1", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1q,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.7,<3.8.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=3.7.4", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "md5": "ab7e7b60ebefccc11342d27194d0412c", + "name": "airflow", + "sha256": "4dcac5db04368f50391ca9cb56acc4b1aadef266fea79b68f05d8bdf4778cf43", + "size": 4356566, + "subdir": "linux-64", + "timestamp": 1659883681842, + "version": "2.3.3" + }, + "airflow-2.3.3-py37h02b9991_1.conda": { + "build": "py37h02b9991_1", + "build_number": 1, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=20.0,<21.0", + "blinker", + "cached-property >=1.5", + "cattrs >=1.1,<2,!=1.7.*", + "colorlog >=4.0.2,<5.0", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=1.0.4,<3", + "flask >=2.0", + "flask-appbuilder 4.1.2.*", + "flask-caching >=1.5.0", + "flask-login >=0.5", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=19.5.0", + "httpx", + "importlib_metadata >=1.7", + "importlib_resources >=5.2", + "itsdangerous >=0.24", + "itsdangerous >=2.0", + "jinja2 >=2.10.1", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1q,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.7,<3.8.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=3.7.4", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "md5": "f10a973dcc15dace13098c5ffcd6efd0", + "name": "airflow", + "sha256": "558a441054731f7d3d7d13b44a6f97d6e9a2d7d78f52efc3ee3e10864a0a9db5", + "size": 4364871, + "subdir": "linux-64", + "timestamp": 1659934601899, + "version": "2.3.3" + }, + "airflow-2.3.3-py38h02b9991_0.conda": { + "build": "py38h02b9991_0", + "build_number": 0, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=20.0,<21.0", + "blinker", + "cattrs >=1.1,<2,!=1.7.*", + "colorlog >=4.0.2,<5.0", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=1.0.4,<3", + "flask >=2.0", + "flask-appbuilder 4.1.2.*", + "flask-caching >=1.5.0", + "flask-login >=0.5", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=19.5.0", + "httpx", + "importlib_metadata >=1.7", + "importlib_resources >=5.2", + "itsdangerous >=0.24", + "itsdangerous >=2.0", + "jinja2 >=2.10.1", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1q,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.8,<3.9.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=3.7.4", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "md5": "7d4aec42002556b552b9a8b351c26842", + "name": "airflow", + "sha256": "5c8c6a81c3b5682da28c3fbbf39c06f8a66846794a7afbeb83ea7e6be9e35c6b", + "size": 4361077, + "subdir": "linux-64", + "timestamp": 1659883746797, + "version": "2.3.3" + }, + "airflow-2.3.3-py38h02b9991_1.conda": { + "build": "py38h02b9991_1", + "build_number": 1, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=20.0,<21.0", + "blinker", + "cattrs >=1.1,<2,!=1.7.*", + "colorlog >=4.0.2,<5.0", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=1.0.4,<3", + "flask >=2.0", + "flask-appbuilder 4.1.2.*", + "flask-caching >=1.5.0", + "flask-login >=0.5", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=19.5.0", + "httpx", + "importlib_metadata >=1.7", + "importlib_resources >=5.2", + "itsdangerous >=0.24", + "itsdangerous >=2.0", + "jinja2 >=2.10.1", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1q,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.8,<3.9.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=3.7.4", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "md5": "1e9e8abc19bd34b926e94c3cc5031761", + "name": "airflow", + "sha256": "3a01995bfb232756ee2fba6c2f80cd8a67cdd2637a7226b5e8901c17c0eb58b1", + "size": 4357754, + "subdir": "linux-64", + "timestamp": 1659934809407, + "version": "2.3.3" + }, + "airflow-2.3.3-py39h02b9991_0.conda": { + "build": "py39h02b9991_0", + "build_number": 0, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=20.0,<21.0", + "blinker", + "cattrs >=1.1,<2,!=1.7.*", + "colorlog >=4.0.2,<5.0", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=1.0.4,<3", + "flask >=2.0", + "flask-appbuilder 4.1.2.*", + "flask-caching >=1.5.0", + "flask-login >=0.5", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=19.5.0", + "httpx", + "itsdangerous >=0.24", + "itsdangerous >=2.0", + "jinja2 >=2.10.1", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1q,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.9,<3.10.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=3.7.4", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "md5": "14c82a014b866af1bfdfb35476d53117", + "name": "airflow", + "sha256": "a6ab7d53a264542420d4bf4a560dd546224d3efd0a4d568f5492167bed3cf34c", + "size": 4360750, + "subdir": "linux-64", + "timestamp": 1659883819307, + "version": "2.3.3" + }, + "airflow-2.3.3-py39h02b9991_1.conda": { + "build": "py39h02b9991_1", + "build_number": 1, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=20.0,<21.0", + "blinker", + "cattrs >=1.1,<2,!=1.7.*", + "colorlog >=4.0.2,<5.0", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=1.0.4,<3", + "flask >=2.0", + "flask-appbuilder 4.1.2.*", + "flask-caching >=1.5.0", + "flask-login >=0.5", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=19.5.0", + "httpx", + "itsdangerous >=0.24", + "itsdangerous >=2.0", + "jinja2 >=2.10.1", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1q,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.9,<3.10.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=3.7.4", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "md5": "2f19aec288dd28713197c3b1061247d4", + "name": "airflow", + "sha256": "e625c8f4dd38ad7043ee046c3c3b26f8e83508fb1f2b4b3c771ccd134f5326f6", + "size": 4359880, + "subdir": "linux-64", + "timestamp": 1659934674503, + "version": "2.3.3" + }, + "airflow-2.4.3-py310h02b9991_0.conda": { + "build": "py310h02b9991_0", + "build_number": 0, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-common-sql", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=22.1.0", + "blinker", + "cattrs >=22.1.0", + "colorlog >=4.0.2,<5.0", + "configupdater >=3.1.1", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=2.2,<2.3", + "flask-appbuilder 4.1.4.*", + "flask-caching >=1.5.0", + "flask-login >=0.6.2", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=20.1.0", + "httpx", + "itsdangerous >=2.0", + "jinja2 >=3.0.0", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1s,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.10,<3.11.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=4.0.0", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1530afc1cce824526e326110fd66082d", + "name": "airflow", + "sha256": "af1fea44dcca3507eaed58af82f21f9a2ee5dfeb1b1f274e770fbe973de63911", + "size": 5498821, + "subdir": "linux-64", + "timestamp": 1671226906064, + "version": "2.4.3" + }, + "airflow-2.4.3-py37h02b9991_0.conda": { + "build": "py37h02b9991_0", + "build_number": 0, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-common-sql", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=22.1.0", + "blinker", + "cached-property >=1.5.0", + "cattrs >=22.1.0", + "colorlog >=4.0.2,<5.0", + "configupdater >=3.1.1", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=2.2,<2.3", + "flask-appbuilder 4.1.4.*", + "flask-caching >=1.5.0", + "flask-login >=0.6.2", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=20.1.0", + "httpx", + "importlib_metadata >=1.7", + "importlib_resources >=5.2", + "itsdangerous >=2.0", + "jinja2 >=3.0.0", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1s,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.7,<3.8.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=4.0.0", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d68abc01f00ebc80b1a17d19eb486175", + "name": "airflow", + "sha256": "ff8801c92fb12eb4b072e0196fd2381748601b4708eb9af81ae95ae169bc28be", + "size": 5468188, + "subdir": "linux-64", + "timestamp": 1671226732680, + "version": "2.4.3" + }, + "airflow-2.4.3-py38h02b9991_0.conda": { + "build": "py38h02b9991_0", + "build_number": 0, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-common-sql", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=22.1.0", + "blinker", + "cattrs >=22.1.0", + "colorlog >=4.0.2,<5.0", + "configupdater >=3.1.1", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=2.2,<2.3", + "flask-appbuilder 4.1.4.*", + "flask-caching >=1.5.0", + "flask-login >=0.6.2", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=20.1.0", + "httpx", + "importlib_metadata >=1.7", + "importlib_resources >=5.2", + "itsdangerous >=2.0", + "jinja2 >=3.0.0", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1s,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.8,<3.9.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=4.0.0", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e7cdf6cbafd54f491b75524441f96f68", + "name": "airflow", + "sha256": "3db2d5cbd97f95826e1b27b3e8fa991159f20bebd0d39f1e81949f4a33c6dfc0", + "size": 5472384, + "subdir": "linux-64", + "timestamp": 1671226991456, + "version": "2.4.3" + }, + "airflow-2.4.3-py39h02b9991_0.conda": { + "build": "py39h02b9991_0", + "build_number": 0, + "depends": [ + "alembic >=1.5.1,<2.0", + "apache-airflow-providers-common-sql", + "apache-airflow-providers-ftp", + "apache-airflow-providers-http", + "apache-airflow-providers-imap", + "apache-airflow-providers-sqlite", + "argcomplete >=1.10", + "attrs >=22.1.0", + "blinker", + "cattrs >=22.1.0", + "colorlog >=4.0.2,<5.0", + "configupdater >=3.1.1", + "connexion >=2.10.0", + "cron-descriptor >=1.2.24", + "croniter >=0.3.17", + "cryptography >=0.9.3", + "deprecated >=1.2.13", + "dill >=0.2.2", + "flask >=2.2,<2.3", + "flask-appbuilder 4.1.4.*", + "flask-caching >=1.5.0", + "flask-login >=0.6.2", + "flask-session >=0.4.0", + "flask-wtf >=0.15", + "gunicorn >=20.1.0", + "httpx", + "itsdangerous >=2.0", + "jinja2 >=3.0.0", + "jsonschema >=3.2.0", + "lazy-object-proxy", + "linkify-it-py >=2.0.0", + "lockfile >=0.12.2", + "markdown >=3.0", + "markdown-it-py >=2.1.0", + "markupsafe >=1.1.1", + "marshmallow-oneofschema >=2.0.1", + "mdit-py-plugins >=0.3.0", + "openssl >=1.1.1s,<1.1.2a", + "packaging >=14.0", + "pathspec >=0.9.0,<1.0", + "pendulum >=2.0", + "pluggy >=1.0", + "psutil >=4.2.0", + "pygments >=2.0.1", + "pyjwt >=2.0.0", + "python >=3.9,<3.10.0a0", + "python-daemon >=2.2.4", + "python-dateutil >=2.3", + "python-graphviz >=0.12", + "python-nvd3 >=0.15.0", + "python-slugify >=5.0", + "rich >=12.4.4", + "setproctitle >=1.1.8", + "sqlalchemy >=1.4", + "sqlalchemy-jsonfield >=1.0", + "swagger-ui-bundle >=0.0.2,<0.1", + "tabulate >=0.7.5", + "tenacity >=6.2.0", + "termcolor >=1.1.0", + "typing-extensions >=4.0.0", + "unicodecsv >=0.14.1", + "werkzeug >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "82533ba964a5ecfb361e9d0731b15faa", + "name": "airflow", + "sha256": "622558eb7d0e9f3c5064894a8547b34907d30074c2439fbb577d4eed08f44131", + "size": 5469769, + "subdir": "linux-64", + "timestamp": 1671226820019, + "version": "2.4.3" + }, + "airflow-with-apache-atlas-2.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "atlasclient >=0.1.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "70bcdfb43de5e3f4a843ed7eb3f28b6a", + "name": "airflow-with-apache-atlas", + "sha256": "42075ee8ce4cb1c2830da6bbd9eef98594e67bb406f5fba05781f19c4bc7a57d", + "size": 12918, + "subdir": "linux-64", + "timestamp": 1659883914928, + "version": "2.3.3" + }, + "airflow-with-apache-atlas-2.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "atlasclient >=0.1.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "94278821273820a92a5d7e7e50dd93d2", + "name": "airflow-with-apache-atlas", + "sha256": "d448397d61b32c184f4801d35ea7792be2b7c0a445ea1131dde093145c97d8be", + "size": 12907, + "subdir": "linux-64", + "timestamp": 1659934831559, + "version": "2.3.3" + }, + "airflow-with-apache-atlas-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "atlasclient >=0.1.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "6242768a9e93c351f2f188f474c96bf5", + "name": "airflow-with-apache-atlas", + "sha256": "82eb39017bf6c00bbcc6d40dc6be181299cdefe0a48e5014f0510b9b47533eb1", + "size": 12886, + "subdir": "linux-64", + "timestamp": 1659883898463, + "version": "2.3.3" + }, + "airflow-with-apache-atlas-2.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "atlasclient >=0.1.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "c6c75edad357aff44e4fbd580f15508d", + "name": "airflow-with-apache-atlas", + "sha256": "ca87b55880ebd2595703e6811afa48a69198a621b51a3852fc79d0e83a828087", + "size": 12883, + "subdir": "linux-64", + "timestamp": 1659934820265, + "version": "2.3.3" + }, + "airflow-with-apache-atlas-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "atlasclient >=0.1.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "95248af7eb8d17b61026981045072011", + "name": "airflow-with-apache-atlas", + "sha256": "3df54df15d059b8838e2e448c04834c9b48e6eaf88e4c3b2833e06a26b503134", + "size": 12886, + "subdir": "linux-64", + "timestamp": 1659883903723, + "version": "2.3.3" + }, + "airflow-with-apache-atlas-2.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "atlasclient >=0.1.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "0cb5b3ecffcee8cf247c401c0164cbde", + "name": "airflow-with-apache-atlas", + "sha256": "ee7f6ba95ba9b1f6acb1cc157f1935ae8c2f305680b6f21ac6e813420bc4d96b", + "size": 12885, + "subdir": "linux-64", + "timestamp": 1659934836977, + "version": "2.3.3" + }, + "airflow-with-apache-atlas-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "atlasclient >=0.1.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "c4c234c8cd73bb994782cb131498f4e8", + "name": "airflow-with-apache-atlas", + "sha256": "055dd9dab7b5b24082957c248b34c0f4118aa36a2cf3f918d152d51cab6d6697", + "size": 12874, + "subdir": "linux-64", + "timestamp": 1659883909245, + "version": "2.3.3" + }, + "airflow-with-apache-atlas-2.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "atlasclient >=0.1.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "8fc02948edc8c457141d7add89430c7f", + "name": "airflow-with-apache-atlas", + "sha256": "66098bbee966df9f0895e7375da421a0ad003abcb2640bfd46ad192eb6c57c77", + "size": 12890, + "subdir": "linux-64", + "timestamp": 1659934825848, + "version": "2.3.3" + }, + "airflow-with-apache-atlas-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "atlasclient >=0.1.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "726b1b480af7731107d1a97af5eebacd", + "name": "airflow-with-apache-atlas", + "sha256": "70427897cfd082d982d76cbf0f09ce29bf9bd1ce1059b0448d7dcf36fd434a93", + "size": 13549, + "subdir": "linux-64", + "timestamp": 1671227014261, + "version": "2.4.3" + }, + "airflow-with-apache-atlas-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "atlasclient >=0.1.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "584356539253e0536f9ab81746313f19", + "name": "airflow-with-apache-atlas", + "sha256": "6c0469b5ae65670ace7e5db983ef3c7f47cebc353e40129dc4105e9b44c6d8ba", + "size": 13524, + "subdir": "linux-64", + "timestamp": 1671227002720, + "version": "2.4.3" + }, + "airflow-with-apache-atlas-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "atlasclient >=0.1.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "85fecbd32c66e01548cc7ab3e2513e89", + "name": "airflow-with-apache-atlas", + "sha256": "99b9c3fee161c69382ec22ab86db9ca35d3aceb26a4093630fa5d7225d525bf4", + "size": 13535, + "subdir": "linux-64", + "timestamp": 1671227019837, + "version": "2.4.3" + }, + "airflow-with-apache-atlas-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "atlasclient >=0.1.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "193c4304ddd3a8c5887ff8a382b4e53f", + "name": "airflow-with-apache-atlas", + "sha256": "6179e571361bed8c32bda5e928eb8aea800c7e6946ad39b41eb4cd625907ee5a", + "size": 13528, + "subdir": "linux-64", + "timestamp": 1671227008338, + "version": "2.4.3" + }, + "airflow-with-apache-webhdfs-2.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "apache-airflow-providers-apache-hdfs", + "python >=3.10,<3.11.0a0", + "python-hdfs >=2.0.4" + ], + "license": "Apache-2.0", + "md5": "ca573a18d505ca312efec0564a2919f2", + "name": "airflow-with-apache-webhdfs", + "sha256": "c42e590459fe425450864e4178d43f24509a2c29f2724037ffcee54157f46fa3", + "size": 12936, + "subdir": "linux-64", + "timestamp": 1659934853396, + "version": "2.3.3" + }, + "airflow-with-apache-webhdfs-2.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "apache-airflow-providers-apache-hdfs", + "python >=3.7,<3.8.0a0", + "python-hdfs >=2.0.4" + ], + "license": "Apache-2.0", + "md5": "ea0e0c2fd99e4f5ebeac1db642771601", + "name": "airflow-with-apache-webhdfs", + "sha256": "f19a4b5a551385bc91dd56e8df507f5df97b27f80b011d5ea970e5557d85ebbb", + "size": 12909, + "subdir": "linux-64", + "timestamp": 1659934842249, + "version": "2.3.3" + }, + "airflow-with-apache-webhdfs-2.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "apache-airflow-providers-apache-hdfs", + "python >=3.8,<3.9.0a0", + "python-hdfs >=2.0.4" + ], + "license": "Apache-2.0", + "md5": "a488ab0f5842d946e39b878d56054a00", + "name": "airflow-with-apache-webhdfs", + "sha256": "48494c436a0bc06b76e199e856bceb28c2cfd839b2ee302919f0dd784ead4799", + "size": 12906, + "subdir": "linux-64", + "timestamp": 1659934858763, + "version": "2.3.3" + }, + "airflow-with-apache-webhdfs-2.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "apache-airflow-providers-apache-hdfs", + "python >=3.9,<3.10.0a0", + "python-hdfs >=2.0.4" + ], + "license": "Apache-2.0", + "md5": "62dbf97dd960f40997d710a1a57cf850", + "name": "airflow-with-apache-webhdfs", + "sha256": "b44c292da242b1515887988f42adb16e448eca9e60605a85227b0e326ebb0e9c", + "size": 12908, + "subdir": "linux-64", + "timestamp": 1659934847664, + "version": "2.3.3" + }, + "airflow-with-apache-webhdfs-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "apache-airflow-providers-apache-hdfs", + "python >=3.10,<3.11.0a0", + "python-hdfs >=2.0.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "226cf63b25a06af88f2f1739c09fbfc7", + "name": "airflow-with-apache-webhdfs", + "sha256": "a50ad589360bcbf1045cb14de32094cffb79a8a97aab454993884432285ccce8", + "size": 13592, + "subdir": "linux-64", + "timestamp": 1671227036958, + "version": "2.4.3" + }, + "airflow-with-apache-webhdfs-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "apache-airflow-providers-apache-hdfs", + "python >=3.7,<3.8.0a0", + "python-hdfs >=2.0.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d089908ef485563de8365a7c088b58a7", + "name": "airflow-with-apache-webhdfs", + "sha256": "ecc721dc0c9849a91ef62cc323d74d47522b1e27499b48823cce4b53a6c12155", + "size": 13556, + "subdir": "linux-64", + "timestamp": 1671227025383, + "version": "2.4.3" + }, + "airflow-with-apache-webhdfs-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "apache-airflow-providers-apache-hdfs", + "python >=3.8,<3.9.0a0", + "python-hdfs >=2.0.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "33a3922c0bad4c4159b5488f81b7f265", + "name": "airflow-with-apache-webhdfs", + "sha256": "56ef06ff522d05033918b5c703412ab7cce951b51575d5f1eb5ba23b0ad0d4e1", + "size": 13556, + "subdir": "linux-64", + "timestamp": 1671227042547, + "version": "2.4.3" + }, + "airflow-with-apache-webhdfs-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "apache-airflow-providers-apache-hdfs", + "python >=3.9,<3.10.0a0", + "python-hdfs >=2.0.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "237c7ec3311239c803c48f8f070a6d2e", + "name": "airflow-with-apache-webhdfs", + "sha256": "5dd17f0fd1448eab0603d456e81706aea08a386b16bb6d74c893564a4ab79d9f", + "size": 13561, + "subdir": "linux-64", + "timestamp": 1671227031135, + "version": "2.4.3" + }, + "airflow-with-async-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9" + ], + "license": "Apache 2.0", + "md5": "b00aadb32182811c02f699d53a679c07", + "name": "airflow-with-async", + "sha256": "21260af28019f1749299d50d77d38ec12dfcd3f066d7e12b82d1ae18362012f0", + "size": 20281, + "subdir": "linux-64", + "timestamp": 1605878122113, + "version": "1.10.12" + }, + "airflow-with-async-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9" + ], + "license": "Apache 2.0", + "md5": "5d3a04a01cea285427122b06f9500532", + "name": "airflow-with-async", + "sha256": "49cf19b7c8d6fe6902d4f490ee98e8a770e887722b235d70e5c039b1d205ac9d", + "size": 18500, + "subdir": "linux-64", + "timestamp": 1579721373022, + "version": "1.10.7" + }, + "airflow-with-async-2.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "dnspython >=2", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "56001970968da925656f8159d9749f02", + "name": "airflow-with-async", + "sha256": "9a027e5efed5f2fcd89e7d34b82a991c94a6a62112fbcb571dea3a2606e2ed13", + "size": 12916, + "subdir": "linux-64", + "timestamp": 1659883936870, + "version": "2.3.3" + }, + "airflow-with-async-2.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "dnspython >=2", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "1e108b2e648cac5815f8f87f27f291f2", + "name": "airflow-with-async", + "sha256": "b6e9cbd5be8cdef218e928e2d3cb0b71bbfb52d8cb3bb31b01ab2efcd2b713fc", + "size": 12916, + "subdir": "linux-64", + "timestamp": 1659934875385, + "version": "2.3.3" + }, + "airflow-with-async-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "dnspython >=2", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "1db7a85db332599a71ac98a3ed1e2eb3", + "name": "airflow-with-async", + "sha256": "ba6e2a552aa52be9f086193ce120cf865271eeda9beb28a99136cc688a29482c", + "size": 12888, + "subdir": "linux-64", + "timestamp": 1659883920252, + "version": "2.3.3" + }, + "airflow-with-async-2.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "dnspython >=2", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "cfc32cbb86212cee13aba86301764f51", + "name": "airflow-with-async", + "sha256": "28216e4d8063008fe4938ee763f4fbbdaf18933968e938e77cfaa525c8caedd4", + "size": 12890, + "subdir": "linux-64", + "timestamp": 1659934864104, + "version": "2.3.3" + }, + "airflow-with-async-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "dnspython >=2", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "b77e609d6c714e0a7813b7c0934a4ef3", + "name": "airflow-with-async", + "sha256": "e00cce4d4dd0f3dec307f22f30363a0e8012684beeb14002847c3487c53d691f", + "size": 12891, + "subdir": "linux-64", + "timestamp": 1659883925604, + "version": "2.3.3" + }, + "airflow-with-async-2.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "dnspython >=2", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "8425c9a99d6b3d8e9b871deab1c7f9a0", + "name": "airflow-with-async", + "sha256": "ecfcbf19e2f8e6162f9a43077c4e624a1236bdf8797c1a98ccdc951d296dd089", + "size": 12891, + "subdir": "linux-64", + "timestamp": 1659934880811, + "version": "2.3.3" + }, + "airflow-with-async-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "dnspython >=2", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "5309ee0023f1622f7f29f6eda61f1df2", + "name": "airflow-with-async", + "sha256": "a6f17426ddc1aa249eca0f0d73a227582270d3ff62a6a201caefc4dece5242e7", + "size": 12887, + "subdir": "linux-64", + "timestamp": 1659883931194, + "version": "2.3.3" + }, + "airflow-with-async-2.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "dnspython >=2", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "150e6a6f9cb6faa263977fc09717bb52", + "name": "airflow-with-async", + "sha256": "b1fdbe9cfa225c07eeabc957ea20ef6f1ae5e288f96fc206a398ecf5a7b116e8", + "size": 12887, + "subdir": "linux-64", + "timestamp": 1659934869635, + "version": "2.3.3" + }, + "airflow-with-async-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a164209e237c3b92be4d14570a9d5dc3", + "name": "airflow-with-async", + "sha256": "eb793cb2b9e500949ed636636c1122df3bc7eec1c16a46356ed2be919c68087a", + "size": 13556, + "subdir": "linux-64", + "timestamp": 1671227059824, + "version": "2.4.3" + }, + "airflow-with-async-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "48e76dfd2bd14ebf85e419ffc7c4c41c", + "name": "airflow-with-async", + "sha256": "5fc348ca0be33882535f0ba9c3de9a132bac1f6f7a74aacc33f14fb942551945", + "size": 13526, + "subdir": "linux-64", + "timestamp": 1671227048105, + "version": "2.4.3" + }, + "airflow-with-async-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "53d0cfe6764837ad6f9a70303137e634", + "name": "airflow-with-async", + "sha256": "f84f80f5b3257e1605de48452e57d3e1c32ef31704a4211df4bce7dfb3454cac", + "size": 13525, + "subdir": "linux-64", + "timestamp": 1671227065320, + "version": "2.4.3" + }, + "airflow-with-async-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "eventlet >=0.9.7", + "gevent >=0.13", + "greenlet >=0.4.9", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b4d1a62cb332441843b89d5275cf63ac", + "name": "airflow-with-async", + "sha256": "fd66fb0b5406e92db6dd6fc9542e7b06fa92049c9b9bf753ae67d1f9177f589e", + "size": 13538, + "subdir": "linux-64", + "timestamp": 1671227053874, + "version": "2.4.3" + }, + "airflow-with-azure-mgmt-containerinstance-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "azure-mgmt-containerinstance >=1.5.0" + ], + "license": "Apache 2.0", + "md5": "5b5c18f16ea170211584ee4c3f88ff15", + "name": "airflow-with-azure-mgmt-containerinstance", + "sha256": "04603d00d1b15ee6e440915064b741e6bb3c2809873f91bf7685d20b33d0fc1f", + "size": 20372, + "subdir": "linux-64", + "timestamp": 1605878123115, + "version": "1.10.12" + }, + "airflow-with-azure-mgmt-containerinstance-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "azure-mgmt-containerinstance >=1.5.0" + ], + "license": "Apache 2.0", + "md5": "d95c177a04268e24ba47fb07aa9d8816", + "name": "airflow-with-azure-mgmt-containerinstance", + "sha256": "d3391bd47d4325f603f3d68445b98d43442d8649d0b72612b170e77948c417a6", + "size": 18592, + "subdir": "linux-64", + "timestamp": 1579721374654, + "version": "1.10.7" + }, + "airflow-with-azure_blob_storage-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "azure-storage >=0.34.0", + "azure-storage-blob <12.0" + ], + "license": "Apache 2.0", + "md5": "15cdc206441a149256b2fd9902b29836", + "name": "airflow-with-azure_blob_storage", + "sha256": "5842d4c179b5eb41183d64f1b261a64bdf21c01249027706da793151d6889fc0", + "size": 20329, + "subdir": "linux-64", + "timestamp": 1605878124098, + "version": "1.10.12" + }, + "airflow-with-azure_blob_storage-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "azure-storage >=0.34.0", + "azure-storage-blob <12.0" + ], + "license": "Apache 2.0", + "md5": "783151d4b3373ee1a92639d64290daf7", + "name": "airflow-with-azure_blob_storage", + "sha256": "d7ad7806baed1d6980ce51e36d7bf1fe92413d0c2acc06f1d069db39f88dfabf", + "size": 18541, + "subdir": "linux-64", + "timestamp": 1579721376228, + "version": "1.10.7" + }, + "airflow-with-azure_cosmos-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "azure-cosmos >=3.0.1" + ], + "license": "Apache 2.0", + "md5": "95fbdcb51b9aa1ef9f333e3d393f9d58", + "name": "airflow-with-azure_cosmos", + "sha256": "8da33200524b2e53b67deb12a336a05e0184ad04b80ddff45b51e7770b07179a", + "size": 20305, + "subdir": "linux-64", + "timestamp": 1605878125099, + "version": "1.10.12" + }, + "airflow-with-azure_cosmos-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "azure-cosmos >=3.0.1" + ], + "license": "Apache 2.0", + "md5": "bb6db1ea2b29ac7f3ff5723d9ddfcdff", + "name": "airflow-with-azure_cosmos", + "sha256": "aab29047e96164465d411f1ee9edd0600b774f0e95cda3ef7ca139a0ff207f86", + "size": 18526, + "subdir": "linux-64", + "timestamp": 1579721377851, + "version": "1.10.7" + }, + "airflow-with-cassandra-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "cassandra-driver >=3.13.0,<3.21.0" + ], + "license": "Apache 2.0", + "md5": "20e7ba5110ee3d034731dceac7a7c751", + "name": "airflow-with-cassandra", + "sha256": "265cbd1c33a44fca0a402fd94496d420dfad8e66d98f6bb3ed234c8eb8e7a95b", + "size": 20293, + "subdir": "linux-64", + "timestamp": 1605878126134, + "version": "1.10.12" + }, + "airflow-with-cassandra-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "cassandra-driver >=3.13.0" + ], + "license": "Apache 2.0", + "md5": "7ddeaeb144c988076b2a4b64982d98f1", + "name": "airflow-with-cassandra", + "sha256": "0b589c4cdd47390d4d600d377e9e52de8542f813c3c80749c1f8b8f78ad8db8c", + "size": 18517, + "subdir": "linux-64", + "timestamp": 1579721379465, + "version": "1.10.7" + }, + "airflow-with-celery-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "celery >=4.3.0,<4.4.0", + "flower >=0.7.3,<1.0", + "tornado >=4.2.0" + ], + "license": "Apache 2.0", + "md5": "967ae7b82d0a5c658c97d05cf95e1371", + "name": "airflow-with-celery", + "sha256": "5e465f9faa143fc0d00403dbe29ced5484d4fd862a593d83e3e18d0962c7ffec", + "size": 20297, + "subdir": "linux-64", + "timestamp": 1605878127163, + "version": "1.10.12" + }, + "airflow-with-celery-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "celery >=4.3.0,<4.4.0", + "flower >=0.7.3,<1.0", + "kombu 4.6.3", + "tornado >=4.2.0,<6.0" + ], + "license": "Apache 2.0", + "md5": "16b564c3ce5a095152e0fd6f14e3bc38", + "name": "airflow-with-celery", + "sha256": "a858e876a2621937c52feaf3369556549561ef03e75c33e4d7106d95368726f5", + "size": 18522, + "subdir": "linux-64", + "timestamp": 1579721381068, + "version": "1.10.7" + }, + "airflow-with-cgroups-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "cgroupspy >=0.1.4" + ], + "license": "Apache 2.0", + "md5": "3b6384095afbe37882bd932695ceae0b", + "name": "airflow-with-cgroups", + "sha256": "6febcab474f14e780e86b2116c213a2f896637c41c358b7454f1810956d237bd", + "size": 20285, + "subdir": "linux-64", + "timestamp": 1605878128167, + "version": "1.10.12" + }, + "airflow-with-cgroups-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "cgroupspy >=0.1.4" + ], + "license": "Apache 2.0", + "md5": "2ef09d7d2cca4d6bd9c6ca5e777ed714", + "name": "airflow-with-cgroups", + "sha256": "ffa7f0d7f9454f794b1b0630ec3d0096068111f6866ba8a56f3156cfef3309e3", + "size": 18505, + "subdir": "linux-64", + "timestamp": 1579721382690, + "version": "1.10.7" + }, + "airflow-with-cgroups-2.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "06c9ce3eb47f4e7ce7177d30c3d6f144", + "name": "airflow-with-cgroups", + "sha256": "c31c61db5d0f54f7b1da92e0d2b90dc69a20fc6c4e2db1ea968533fb6986a38c", + "size": 12905, + "subdir": "linux-64", + "timestamp": 1659883958648, + "version": "2.3.3" + }, + "airflow-with-cgroups-2.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "44641929d0ae63c650d0ef30e1ea105f", + "name": "airflow-with-cgroups", + "sha256": "36d2725e0309bcfa91abb55d0587aa5d1b44b544e0c58405bcf7a981eae721cc", + "size": 12913, + "subdir": "linux-64", + "timestamp": 1659934897338, + "version": "2.3.3" + }, + "airflow-with-cgroups-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "9503be066f72064dd54a76a8f83f6056", + "name": "airflow-with-cgroups", + "sha256": "59a0ace1f0dcdc18eeb4af23ce4ea25c6e943308906f807409c39b1ee7101e21", + "size": 12880, + "subdir": "linux-64", + "timestamp": 1659883942161, + "version": "2.3.3" + }, + "airflow-with-cgroups-2.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "9fd730c4e567fe1f94fc8b30a4fa38f4", + "name": "airflow-with-cgroups", + "sha256": "e25ea755dcc8d8e845a69763cdcc0fa1ae972abf8e52823bf4064164797978b4", + "size": 12890, + "subdir": "linux-64", + "timestamp": 1659934886163, + "version": "2.3.3" + }, + "airflow-with-cgroups-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "8d537a1017269f4b75ea3375a7c418bc", + "name": "airflow-with-cgroups", + "sha256": "857479785c762da7f45df4d2d6938a5e399b70a76f50da2370b3b06be5694f46", + "size": 12888, + "subdir": "linux-64", + "timestamp": 1659883947485, + "version": "2.3.3" + }, + "airflow-with-cgroups-2.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "dec8e132a07c1086fc47ff0ff52744c9", + "name": "airflow-with-cgroups", + "sha256": "ddf389f0804f62273df62e08969fcf6ac2c2e6684169d1e42e74c82fdbfbf16c", + "size": 12891, + "subdir": "linux-64", + "timestamp": 1659934902748, + "version": "2.3.3" + }, + "airflow-with-cgroups-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "12c50577ad24d79102897219182729b6", + "name": "airflow-with-cgroups", + "sha256": "8d0d0bd83a430d646f033eb42697d7716ae11a942d94d2c20b20455b1648e671", + "size": 12883, + "subdir": "linux-64", + "timestamp": 1659883952985, + "version": "2.3.3" + }, + "airflow-with-cgroups-2.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "c36aec0d9d6f91a5f5eed58dfe51473f", + "name": "airflow-with-cgroups", + "sha256": "e79ef81bdcaccd7816d72f711e92cfeb4b066ce143c5ebb696d3d7f4d28599de", + "size": 12885, + "subdir": "linux-64", + "timestamp": 1659934891772, + "version": "2.3.3" + }, + "airflow-with-cgroups-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eae12908e474b1585d59f6ef21df78f9", + "name": "airflow-with-cgroups", + "sha256": "a7399333d8e74b8d7041649178cae5ece18ae329d165136cab339710bbc4f128", + "size": 13552, + "subdir": "linux-64", + "timestamp": 1671227082652, + "version": "2.4.3" + }, + "airflow-with-cgroups-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bf537b876de812fcbccccf1e84f03dec", + "name": "airflow-with-cgroups", + "sha256": "9da91fc7d1d8be3f1c5deda500083c82a23fa768a182161bb74819d743e1d961", + "size": 13538, + "subdir": "linux-64", + "timestamp": 1671227070888, + "version": "2.4.3" + }, + "airflow-with-cgroups-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c196ca60b5898490185d89c97d156273", + "name": "airflow-with-cgroups", + "sha256": "b6c2a45294597665a5ea6596dd44f2df1a60a34e70fdddacbb9b471b7105fb40", + "size": 13530, + "subdir": "linux-64", + "timestamp": 1671227088114, + "version": "2.4.3" + }, + "airflow-with-cgroups-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cgroupspy >=0.2.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e939824ac39cf4deb6b611d0533b61a3", + "name": "airflow-with-cgroups", + "sha256": "2a8e1726ebc48379dd4349860858c66f8de7ab4edf01cfdc17c1973f8f6a866a", + "size": 13535, + "subdir": "linux-64", + "timestamp": 1671227076675, + "version": "2.4.3" + }, + "airflow-with-cloudant-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "cloudant >=2.0" + ], + "license": "Apache 2.0", + "md5": "f5a62b21350e07c1a08e08ba09414a2e", + "name": "airflow-with-cloudant", + "sha256": "f9d26b91d7cecb7d289b66fe0a38bd7dc8d8be898555474c6ec097b17b3662c0", + "size": 20290, + "subdir": "linux-64", + "timestamp": 1605878129166, + "version": "1.10.12" + }, + "airflow-with-cloudant-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "cloudant >=2.0" + ], + "license": "Apache 2.0", + "md5": "168a50e49f21cecba0a2037267651c59", + "name": "airflow-with-cloudant", + "sha256": "99f93b099729e1ba45c84788dfb9a2dae344f86f86de0ef7e502acd910557954", + "size": 18513, + "subdir": "linux-64", + "timestamp": 1579721384351, + "version": "1.10.7" + }, + "airflow-with-cncf-kubernetes-2.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cryptography >=2.0.0", + "python >=3.10,<3.11.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "md5": "462d3a4ba8ca7a881300d607495342cc", + "name": "airflow-with-cncf-kubernetes", + "sha256": "4b5e3acf70eda51f7e00ac3caf48c30892b637497b20370486aaa2885786dc62", + "size": 12917, + "subdir": "linux-64", + "timestamp": 1659883980320, + "version": "2.3.3" + }, + "airflow-with-cncf-kubernetes-2.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cryptography >=2.0.0", + "python >=3.10,<3.11.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "md5": "2fcbac3e1651566229adc04cbe278574", + "name": "airflow-with-cncf-kubernetes", + "sha256": "4be5e67d71263503ff7f1393dca74437c87b7f314ba15fe551274723c835219d", + "size": 12919, + "subdir": "linux-64", + "timestamp": 1659934919483, + "version": "2.3.3" + }, + "airflow-with-cncf-kubernetes-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cryptography >=2.0.0", + "python >=3.7,<3.8.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "md5": "b54f522e1864af3a587fa8986308d3da", + "name": "airflow-with-cncf-kubernetes", + "sha256": "af551021db0afaf63ba5facc53954b851eb8386eb6351b4a3687928d028c888c", + "size": 12895, + "subdir": "linux-64", + "timestamp": 1659883963949, + "version": "2.3.3" + }, + "airflow-with-cncf-kubernetes-2.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cryptography >=2.0.0", + "python >=3.7,<3.8.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "md5": "3023a2053b918e7a6248d128308546f1", + "name": "airflow-with-cncf-kubernetes", + "sha256": "9a0d22b93d161af2d2f3d38674339714f11b7347c9214c28fd5bb12f44454c98", + "size": 12889, + "subdir": "linux-64", + "timestamp": 1659934908111, + "version": "2.3.3" + }, + "airflow-with-cncf-kubernetes-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cryptography >=2.0.0", + "python >=3.8,<3.9.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "md5": "ae7dc28882de29e1324b939709e6eee9", + "name": "airflow-with-cncf-kubernetes", + "sha256": "699282aaf1869c8e14f94ccb33e746cc6e64c16cfabc039381cdbfb710850c2f", + "size": 12890, + "subdir": "linux-64", + "timestamp": 1659883969166, + "version": "2.3.3" + }, + "airflow-with-cncf-kubernetes-2.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cryptography >=2.0.0", + "python >=3.8,<3.9.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "md5": "498bb2bb3510a77890d3f76b29a9f383", + "name": "airflow-with-cncf-kubernetes", + "sha256": "4ae116ff171de4ced912d308dab292ac50a5b6665c720489fd97e612095e19a6", + "size": 12903, + "subdir": "linux-64", + "timestamp": 1659934924856, + "version": "2.3.3" + }, + "airflow-with-cncf-kubernetes-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cryptography >=2.0.0", + "python >=3.9,<3.10.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "md5": "18776779c2ced5d20acce7414a789efe", + "name": "airflow-with-cncf-kubernetes", + "sha256": "d326068dcf357c6b5e258b229c2c52b7af4aee0f136a0f58c82430ece31f50b0", + "size": 12893, + "subdir": "linux-64", + "timestamp": 1659883974663, + "version": "2.3.3" + }, + "airflow-with-cncf-kubernetes-2.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cryptography >=2.0.0", + "python >=3.9,<3.10.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "md5": "13f88c8084d986c9ce870814535681f5", + "name": "airflow-with-cncf-kubernetes", + "sha256": "48583402340712012f79e7bee2b6e4d3b8ffa2040c37e0f9a2ef7e8394b041d6", + "size": 12891, + "subdir": "linux-64", + "timestamp": 1659934913708, + "version": "2.3.3" + }, + "airflow-with-cncf-kubernetes-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cryptography >=2.0.0", + "python >=3.10,<3.11.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0e7a40256af1f8f091f2086b00e341ed", + "name": "airflow-with-cncf-kubernetes", + "sha256": "b6c6029a4af8d83384994d0dbe9bb3fd443005ac76e47bdd9349d1b41a6cbc03", + "size": 13563, + "subdir": "linux-64", + "timestamp": 1671227105420, + "version": "2.4.3" + }, + "airflow-with-cncf-kubernetes-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cryptography >=2.0.0", + "python >=3.7,<3.8.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5b3690993871eabee769b8ebc58a5d7f", + "name": "airflow-with-cncf-kubernetes", + "sha256": "eed3f04caa555aae7f066ba21140280cd312641ab3dd72777cffa2cdeb378770", + "size": 13542, + "subdir": "linux-64", + "timestamp": 1671227093674, + "version": "2.4.3" + }, + "airflow-with-cncf-kubernetes-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cryptography >=2.0.0", + "python >=3.8,<3.9.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4ac2173f18af14bd356baf7fcd7d20c8", + "name": "airflow-with-cncf-kubernetes", + "sha256": "15c4bc31ca7fb911b665f1e23a22e11482020a29e7ccd150fc6a99299597b655", + "size": 13542, + "subdir": "linux-64", + "timestamp": 1671227111014, + "version": "2.4.3" + }, + "airflow-with-cncf-kubernetes-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cryptography >=2.0.0", + "python >=3.9,<3.10.0a0", + "python-kubernetes >=21.7.0,<24" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9e8094b7672ddb989079b765f82e15ea", + "name": "airflow-with-cncf-kubernetes", + "sha256": "9b495edb69547700daa2fe1536a8a849936877c23068006b7269eed8185baa33", + "size": 13545, + "subdir": "linux-64", + "timestamp": 1671227099464, + "version": "2.4.3" + }, + "airflow-with-crypto-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "cryptography >=0.9.3" + ], + "license": "Apache 2.0", + "md5": "92eff61906c6e71d599d9b1c65ffbea9", + "name": "airflow-with-crypto", + "sha256": "395ccd16a8943ca76d54c8404a1d48adb85877b1cf13ccf4ce41db97b869e102", + "size": 20281, + "subdir": "linux-64", + "timestamp": 1605878130184, + "version": "1.10.12" + }, + "airflow-with-crypto-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "cryptography >=0.9.3" + ], + "license": "Apache 2.0", + "md5": "91bd880f728709319187b0a29466ca72", + "name": "airflow-with-crypto", + "sha256": "47e0ff2e51bc2db73f690a16095bfb52e72c156c22518f4d695a528d1848274b", + "size": 18496, + "subdir": "linux-64", + "timestamp": 1579721386044, + "version": "1.10.7" + }, + "airflow-with-dask-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "distributed >=1.17.1" + ], + "license": "Apache 2.0", + "md5": "bd6956f1d6ad808fc35e8b1e6531606a", + "name": "airflow-with-dask", + "sha256": "e2cb8ab5e842444542ac704e69c6969e222890f345c95b331e46eef75cda0618", + "size": 20268, + "subdir": "linux-64", + "timestamp": 1605878131206, + "version": "1.10.12" + }, + "airflow-with-dask-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "distributed >=1.17.1,<2" + ], + "license": "Apache 2.0", + "md5": "e453d38f9db61e35a6f7f41f11be3c40", + "name": "airflow-with-dask", + "sha256": "3b7b46d77cc8fb290d0a8ecd9fd12b6aa7515b2bd4707bd4ad723846931c0dea", + "size": 18491, + "subdir": "linux-64", + "timestamp": 1579721387698, + "version": "1.10.7" + }, + "airflow-with-dask-2.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "7e263387f8f46658faa612ea993e8a2e", + "name": "airflow-with-dask", + "sha256": "3c3f4eccb5726301704a826162a1499f0ea8eaf3e26865d97030b6d5155cb11a", + "size": 12907, + "subdir": "linux-64", + "timestamp": 1659884002406, + "version": "2.3.3" + }, + "airflow-with-dask-2.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "d0fdf207fc1c3f44453a52a50452d629", + "name": "airflow-with-dask", + "sha256": "659d563296e0854f2f952e6f96c9f75988e6010567efdc0230415b23a34b71c4", + "size": 12905, + "subdir": "linux-64", + "timestamp": 1659934941520, + "version": "2.3.3" + }, + "airflow-with-dask-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "9afc80658e563afa0dcfc34d8e8aa1c0", + "name": "airflow-with-dask", + "sha256": "ecf1023038accc585519caab7e26a25b18dccd7edaa8bbeb9a5350481d96d652", + "size": 12879, + "subdir": "linux-64", + "timestamp": 1659883985688, + "version": "2.3.3" + }, + "airflow-with-dask-2.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "a7d21b8eede8f95cf60a6350fbe95ca8", + "name": "airflow-with-dask", + "sha256": "dcc30e83835db81e83e904d66d5903c998f905583a58f00e34a6d976307b2c65", + "size": 12884, + "subdir": "linux-64", + "timestamp": 1659934930211, + "version": "2.3.3" + }, + "airflow-with-dask-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "ef2857aa7cf7fae02efa638ca7e76932", + "name": "airflow-with-dask", + "sha256": "861e995245d8f76df95a834a597170ffdfe9265abc26b5683a38df362979ff1a", + "size": 12880, + "subdir": "linux-64", + "timestamp": 1659883991081, + "version": "2.3.3" + }, + "airflow-with-dask-2.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "db87dc2faf73e9ead593df59e959cbfd", + "name": "airflow-with-dask", + "sha256": "01312a520a21a057aaa4a378f4e96c12a87b2f5f02b9bd8fde55c2e50772985e", + "size": 12889, + "subdir": "linux-64", + "timestamp": 1659934946982, + "version": "2.3.3" + }, + "airflow-with-dask-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "d2d6e05ee2aebad044385aac042f0b71", + "name": "airflow-with-dask", + "sha256": "6dc3c5a243980b3537ee3d196e889efc0d0a11220f7d2e3ebc52e3bf823199b3", + "size": 12879, + "subdir": "linux-64", + "timestamp": 1659883996642, + "version": "2.3.3" + }, + "airflow-with-dask-2.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "abc63d05c8654e46482a3e56e1ae8feb", + "name": "airflow-with-dask", + "sha256": "8a682640722128d664421b7ceb3cdf7be6f10260480644aaa8b5b53e3191b24a", + "size": 12883, + "subdir": "linux-64", + "timestamp": 1659934935797, + "version": "2.3.3" + }, + "airflow-with-dask-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ac2f84c7a23325aa0e576a0b5bc9faaa", + "name": "airflow-with-dask", + "sha256": "92fd19318d7f7df8b6a81ba85574a9c9f053fb63dc43a31dfa3a9c5d2ebc9160", + "size": 13549, + "subdir": "linux-64", + "timestamp": 1671227128143, + "version": "2.4.3" + }, + "airflow-with-dask-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8b1972fcae4eb2482175cc1c820430ea", + "name": "airflow-with-dask", + "sha256": "79f82e1367799955954db6b76c228a9a3bdc1eb16b95099102ff352524f554db", + "size": 13532, + "subdir": "linux-64", + "timestamp": 1671227116455, + "version": "2.4.3" + }, + "airflow-with-dask-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "980176506180c0032eb29863f913d79c", + "name": "airflow-with-dask", + "sha256": "73dfe42fc22d289a2184960b599b02b71228be89709ded1ba13cea950cd4d83c", + "size": 13530, + "subdir": "linux-64", + "timestamp": 1671227133735, + "version": "2.4.3" + }, + "airflow-with-dask-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "cloudpickle >=1.4.1", + "dask >=2.9.0", + "distributed >=2.11.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c6a7a53b686d72f057a74e1c8c1eec4b", + "name": "airflow-with-dask", + "sha256": "c7b4ad951329ee7e4bdd00d06dcebe31e4b6d2dff97587553b0f113037c7cbd1", + "size": 13531, + "subdir": "linux-64", + "timestamp": 1671227122223, + "version": "2.4.3" + }, + "airflow-with-databricks-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache 2.0", + "md5": "7ed22f7d5e86645bda52876633d9d802", + "name": "airflow-with-databricks", + "sha256": "be5a6bf87c3a64f2920e05d165b8141624c1689211596dc5c4cb86e374fabceb", + "size": 20299, + "subdir": "linux-64", + "timestamp": 1605878132239, + "version": "1.10.12" + }, + "airflow-with-databricks-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache 2.0", + "md5": "d5cb2523e596ad34e6c80987d401c0a1", + "name": "airflow-with-databricks", + "sha256": "90580bcf033fc0c699c2f7286478a6d64a00e23386ff84f801bf24f89415ec10", + "size": 18516, + "subdir": "linux-64", + "timestamp": 1579721389323, + "version": "1.10.7" + }, + "airflow-with-datadog-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "datadog >=0.14.0" + ], + "license": "Apache 2.0", + "md5": "e22f806538509fe531add9baec8eacc6", + "name": "airflow-with-datadog", + "sha256": "14b7d6a9cea1a7ae0b5d2a263c80f6ad10403b8f618e7b8e2c261f337aa35447", + "size": 20291, + "subdir": "linux-64", + "timestamp": 1605878133310, + "version": "1.10.12" + }, + "airflow-with-datadog-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "datadog >=0.14.0" + ], + "license": "Apache 2.0", + "md5": "270d5e8a276febcb48ef607c7d136410", + "name": "airflow-with-datadog", + "sha256": "b8eaf5bb9a29d33135e4b43523e3c193215f7abedd5c8e5dbca444955cccae78", + "size": 18502, + "subdir": "linux-64", + "timestamp": 1579721390958, + "version": "1.10.7" + }, + "airflow-with-deprecated-api-2.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.10,<3.11.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "md5": "0183aa7d5039148c888e935c5cfac045", + "name": "airflow-with-deprecated-api", + "sha256": "6eec2fa3cc0b748f0395d9e8982f842424224558eed9945c7f8f9ebc96c1620e", + "size": 12903, + "subdir": "linux-64", + "timestamp": 1659884024307, + "version": "2.3.3" + }, + "airflow-with-deprecated-api-2.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.10,<3.11.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "md5": "fa2954b970f06560f2e7b71f2d3428d8", + "name": "airflow-with-deprecated-api", + "sha256": "75102a86e342c50765af5dae2578c914e7e4b09f7a21f7cc71bd3b1d116b60b7", + "size": 12908, + "subdir": "linux-64", + "timestamp": 1659934963467, + "version": "2.3.3" + }, + "airflow-with-deprecated-api-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.7,<3.8.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "md5": "43d6d1645dc19cce3ccd729073e5ae58", + "name": "airflow-with-deprecated-api", + "sha256": "33f39a91c21f74defee092c5dd8d6f2038d8c826107f60ede8167ac8843a4eca", + "size": 12882, + "subdir": "linux-64", + "timestamp": 1659884007759, + "version": "2.3.3" + }, + "airflow-with-deprecated-api-2.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.7,<3.8.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "md5": "9b3ae94bab12bad2f7c29194ca9bfeb4", + "name": "airflow-with-deprecated-api", + "sha256": "25578012b4a5fcd8d38b73f19bc36bd154596dc1f9b450df645c66738da85735", + "size": 12877, + "subdir": "linux-64", + "timestamp": 1659934952145, + "version": "2.3.3" + }, + "airflow-with-deprecated-api-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.8,<3.9.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "md5": "f73798dc5162f82b80c62f223e2db091", + "name": "airflow-with-deprecated-api", + "sha256": "638340197bd4d7125f0f709b1d7bf1b5bd913a3ee3867821ed91454b303d3a50", + "size": 12886, + "subdir": "linux-64", + "timestamp": 1659884013025, + "version": "2.3.3" + }, + "airflow-with-deprecated-api-2.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.8,<3.9.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "md5": "199a5db3d6930f2906cd392be0fd500b", + "name": "airflow-with-deprecated-api", + "sha256": "d345d3060c3822f0cd37b6b86ee0e7ebf29b22a2cdf76cb660cfdba0e68fe80c", + "size": 12886, + "subdir": "linux-64", + "timestamp": 1659934968905, + "version": "2.3.3" + }, + "airflow-with-deprecated-api-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.9,<3.10.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "md5": "6218bea8dd91c2e3d1f35b4979f2d279", + "name": "airflow-with-deprecated-api", + "sha256": "4c828bd2ffd2aef4e374d206dda86bd651133443a244828dd8c615c04c959bb9", + "size": 12871, + "subdir": "linux-64", + "timestamp": 1659884018731, + "version": "2.3.3" + }, + "airflow-with-deprecated-api-2.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.9,<3.10.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "md5": "37351cc0e7c2a19744e0cf7aefb9fe73", + "name": "airflow-with-deprecated-api", + "sha256": "ce0d46a3900d9cd40ae1cece551c35a45fdf10980a8335203032f9755ea6e8ae", + "size": 12876, + "subdir": "linux-64", + "timestamp": 1659934957747, + "version": "2.3.3" + }, + "airflow-with-deprecated-api-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.10,<3.11.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3b0da98a381b1ba3e0a212ce5d235a59", + "name": "airflow-with-deprecated-api", + "sha256": "5eb24c8f2cdfd18dc330bf7eedc7589258c123beff883d162c37b9dcde9e2d55", + "size": 13557, + "subdir": "linux-64", + "timestamp": 1671227150857, + "version": "2.4.3" + }, + "airflow-with-deprecated-api-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.7,<3.8.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2b124dbc1125655c2c91a5ae4d6307a2", + "name": "airflow-with-deprecated-api", + "sha256": "b21152bec3ee245732ce5425d1db4b7c5591cfc8fbdfd6e7a9d3a77535e1c556", + "size": 13527, + "subdir": "linux-64", + "timestamp": 1671227139154, + "version": "2.4.3" + }, + "airflow-with-deprecated-api-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.8,<3.9.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "07afa8c7d13876c8cb4954a4556ffaff", + "name": "airflow-with-deprecated-api", + "sha256": "acda8543e2b9afa85865104a5c1da8270784383e529fae2ab8a463ab7aea7d24", + "size": 13529, + "subdir": "linux-64", + "timestamp": 1671227156449, + "version": "2.4.3" + }, + "airflow-with-deprecated-api-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.9,<3.10.0a0", + "requests >=2.26.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c320b292766d687fe58fb5007968af5f", + "name": "airflow-with-deprecated-api", + "sha256": "7cacf38a82cc74d730ef9aaa8cd169639665d91ded00fe92bafd465486924541", + "size": 13536, + "subdir": "linux-64", + "timestamp": 1671227144908, + "version": "2.4.3" + }, + "airflow-with-docker-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "docker-py >=3.0.0" + ], + "license": "Apache 2.0", + "md5": "93c3981aa2e8164a4f3a5f4850725554", + "name": "airflow-with-docker", + "sha256": "da68a2244eccfe48248a5de69e3bfea9ef0737ba928ef4b45ca6284cd33981f7", + "size": 20281, + "subdir": "linux-64", + "timestamp": 1605878134327, + "version": "1.10.12" + }, + "airflow-with-docker-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "docker-py >=3.0.0,<3.1.0" + ], + "license": "Apache 2.0", + "md5": "4991d18c3951496bcc05e4cd9bea6271", + "name": "airflow-with-docker", + "sha256": "e3a0fd3ac710196cbcfaa91b1e0700171a527f18b58da1fee827b543adb2c516", + "size": 18502, + "subdir": "linux-64", + "timestamp": 1579721392656, + "version": "1.10.7" + }, + "airflow-with-druid-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "pydruid >=0.4.1,<=0.5.8" + ], + "license": "Apache 2.0", + "md5": "e3674a191a3b0c9468b417c49f0fe69c", + "name": "airflow-with-druid", + "sha256": "f61d8366c87f1546722a8a98a13a23bac7ff505f8341485fa6fbefdade0c2909", + "size": 20287, + "subdir": "linux-64", + "timestamp": 1605878135342, + "version": "1.10.12" + }, + "airflow-with-druid-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "pydruid >=0.4.1" + ], + "license": "Apache 2.0", + "md5": "45a781f91f1073a36b192ce056246cde", + "name": "airflow-with-druid", + "sha256": "a26de375350be9bf93c136ea371a74a588083dd07fb441428ed5789b7fe3e4e4", + "size": 18498, + "subdir": "linux-64", + "timestamp": 1579721394459, + "version": "1.10.7" + }, + "airflow-with-elasticsearch-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "elasticsearch >=5.0.0", + "elasticsearch-dsl >=5.0.0" + ], + "license": "Apache 2.0", + "md5": "0c9c00f502935c6bbe8eb2fad1677490", + "name": "airflow-with-elasticsearch", + "sha256": "9335c2f35824d99a971d1339fa24a2d4dc125c6dd0b349fd9fe63f1b43d55f1b", + "size": 20311, + "subdir": "linux-64", + "timestamp": 1605878136402, + "version": "1.10.12" + }, + "airflow-with-elasticsearch-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "elasticsearch >=5.0.0,<6.0.0", + "elasticsearch-dsl >=5.0.0,<6.0.0" + ], + "license": "Apache 2.0", + "md5": "70802f2053c4dd661cddd0fd871b4c30", + "name": "airflow-with-elasticsearch", + "sha256": "578a01860ef29e646268813ee3a6a0b8353c5e635e82a40c9ba3b7ddd7017566", + "size": 18529, + "subdir": "linux-64", + "timestamp": 1579721396133, + "version": "1.10.7" + }, + "airflow-with-emr-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "boto3 >=1.0.0" + ], + "license": "Apache 2.0", + "md5": "03fc41f687b41e680cd7c2ba9ecde7c6", + "name": "airflow-with-emr", + "sha256": "4f43e77de7a110ecdc1c0c5def00578db04c2248aa82bad5aefa8f7a30dc5724", + "size": 20262, + "subdir": "linux-64", + "timestamp": 1605878137427, + "version": "1.10.12" + }, + "airflow-with-emr-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "boto3 >=1.0.0,<1.8.0" + ], + "license": "Apache 2.0", + "md5": "eb9efd33135e44363d1d1437cfb678b0", + "name": "airflow-with-emr", + "sha256": "9497790473c462f764f7326b7ace36b96999d6ecfe779ec5f310b4611f68c4a1", + "size": 18481, + "subdir": "linux-64", + "timestamp": 1579721397901, + "version": "1.10.7" + }, + "airflow-with-github_enterprise-2.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "cf64abe1a7ba4f4cbda9b5bd732f9eb3", + "name": "airflow-with-github_enterprise", + "sha256": "d07a6bdcba5af7a49e47d8a9a76884bc909288c5d20440b97128c73349ed8c65", + "size": 12936, + "subdir": "linux-64", + "timestamp": 1659884046459, + "version": "2.3.3" + }, + "airflow-with-github_enterprise-2.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "3dc9fb3fde67ee581b7898536750d480", + "name": "airflow-with-github_enterprise", + "sha256": "af4c937b8888e0a71b8e0f5eee826da217684d773fddd545df08e0afd0ef0b57", + "size": 12940, + "subdir": "linux-64", + "timestamp": 1659934985675, + "version": "2.3.3" + }, + "airflow-with-github_enterprise-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "11d63c1d7bc8f128c1393eae42d5e54f", + "name": "airflow-with-github_enterprise", + "sha256": "a6925d68a4def266d46c78694c00cf24c6a23d1e09523faad5ffb49c616f9985", + "size": 12917, + "subdir": "linux-64", + "timestamp": 1659884029711, + "version": "2.3.3" + }, + "airflow-with-github_enterprise-2.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "2eb2940d464a5e52dfac0f8942777d73", + "name": "airflow-with-github_enterprise", + "sha256": "c499351abdcc29f5bf22bd25eb889c6e2e678d2abd26cbbb0c7f74540fc13f50", + "size": 12916, + "subdir": "linux-64", + "timestamp": 1659934974325, + "version": "2.3.3" + }, + "airflow-with-github_enterprise-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "b6ddd04a34e04b5a4d901bbe7c5ded0e", + "name": "airflow-with-github_enterprise", + "sha256": "650e3bd92ae30466e08041598f0770ba03fc7017cd134220b71e530c1b6c15b0", + "size": 12911, + "subdir": "linux-64", + "timestamp": 1659884035096, + "version": "2.3.3" + }, + "airflow-with-github_enterprise-2.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "e68be4f584d47d2047f3596fe11484cf", + "name": "airflow-with-github_enterprise", + "sha256": "d56ecf7633e4b2890013efc86b87254a01f136599726412464df1b969dfd704c", + "size": 12918, + "subdir": "linux-64", + "timestamp": 1659934991081, + "version": "2.3.3" + }, + "airflow-with-github_enterprise-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "7ee1c2dd72ae2eaa028314d1af4e9f2d", + "name": "airflow-with-github_enterprise", + "sha256": "c274b03e8f968b06a0b29f66d0eb59e38155173f0076bef0e68f4b82e29e8f61", + "size": 12906, + "subdir": "linux-64", + "timestamp": 1659884040722, + "version": "2.3.3" + }, + "airflow-with-github_enterprise-2.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "373886d0f396cdb733bb1543d29005af", + "name": "airflow-with-github_enterprise", + "sha256": "c06f7cb237add387a35998976f5bbfd19e8a1082607c2ebe13051f554d47af90", + "size": 12919, + "subdir": "linux-64", + "timestamp": 1659934979899, + "version": "2.3.3" + }, + "airflow-with-github_enterprise-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "224e44e6b1a7d69958b8021ac4e98354", + "name": "airflow-with-github_enterprise", + "sha256": "49fde93bf23057b9ad4597f620f9bbe16d4b6ff9c00070a615febca6e89850bc", + "size": 13586, + "subdir": "linux-64", + "timestamp": 1671227173643, + "version": "2.4.3" + }, + "airflow-with-github_enterprise-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5ab7605f2073b36ad5a9969456a678b0", + "name": "airflow-with-github_enterprise", + "sha256": "c555a4a7d260947101b25ca2af595556f64a8199a68e15b2b7d9cda699118120", + "size": 13564, + "subdir": "linux-64", + "timestamp": 1671227161889, + "version": "2.4.3" + }, + "airflow-with-github_enterprise-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "42e2c01caa4947b8d582b6b8352b87ea", + "name": "airflow-with-github_enterprise", + "sha256": "0e78afac1c54d53d9436c12d8c66bb47d11dfd8ace9173b984bb0250bf29b7ef", + "size": 13561, + "subdir": "linux-64", + "timestamp": 1671227179253, + "version": "2.4.3" + }, + "airflow-with-github_enterprise-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8716eb01a959f23791c55f1d9c371010", + "name": "airflow-with-github_enterprise", + "sha256": "5921cc09a996bea524a307511fac9dd53d8cc6c4b530732ecb8c2753facfb292", + "size": 13564, + "subdir": "linux-64", + "timestamp": 1671227167690, + "version": "2.4.3" + }, + "airflow-with-google_auth-2.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "8eafaadd74cc74dd605f3c2239f36ae7", + "name": "airflow-with-google_auth", + "sha256": "d995db73ead858f082d30faaeb94d23508a7eba4b14a25976dcbda9ca6d8e440", + "size": 12917, + "subdir": "linux-64", + "timestamp": 1659884068631, + "version": "2.3.3" + }, + "airflow-with-google_auth-2.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "5bdd89f72bb61e798bb1bdc3a5011f09", + "name": "airflow-with-google_auth", + "sha256": "0e15efa14d1d8e798176832f879472dfcea669a5f47e234075be55ed3d6df6a8", + "size": 12925, + "subdir": "linux-64", + "timestamp": 1659935007815, + "version": "2.3.3" + }, + "airflow-with-google_auth-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "9ceee34652f5f896153f4e1625a06b76", + "name": "airflow-with-google_auth", + "sha256": "71725062894dbd47617b4134478e702f600ed9634b0232dcc67b664196185736", + "size": 12890, + "subdir": "linux-64", + "timestamp": 1659884051795, + "version": "2.3.3" + }, + "airflow-with-google_auth-2.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "c2c81f4c43de7d6021a54894adcee19c", + "name": "airflow-with-google_auth", + "sha256": "69ae695ae1381101d69ca7c4aab852c2379374b0a43665465c58bc6c9db72a68", + "size": 12891, + "subdir": "linux-64", + "timestamp": 1659934996473, + "version": "2.3.3" + }, + "airflow-with-google_auth-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "e0a97e1c5a42411b54c7ccc289aae5dc", + "name": "airflow-with-google_auth", + "sha256": "4439ef270c80cc519aa831b7b37c7b63e001433762eca88ba2e08726fde02007", + "size": 12884, + "subdir": "linux-64", + "timestamp": 1659884057255, + "version": "2.3.3" + }, + "airflow-with-google_auth-2.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "599b214bb9a9658f4f9f928ff5e8f725", + "name": "airflow-with-google_auth", + "sha256": "1d2f0726e976732ce9612ca23ab45c98d1b2201bcb34e395e3f4a71c5c81d685", + "size": 12897, + "subdir": "linux-64", + "timestamp": 1659935013162, + "version": "2.3.3" + }, + "airflow-with-google_auth-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "00dd51c32bc9a87a8e0e382acc2adaba", + "name": "airflow-with-google_auth", + "sha256": "96bba0d300ee9ee2a98d5b0c113599a36fe24b5c228ad3ad41310496c56beab7", + "size": 12904, + "subdir": "linux-64", + "timestamp": 1659884062887, + "version": "2.3.3" + }, + "airflow-with-google_auth-2.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "35b71dd9f7887f2e0138184fae4846f6", + "name": "airflow-with-google_auth", + "sha256": "f4c0a4f6dec08df5267228e256c3a810aaa2c39a80af4eeba546e8df6b49fc90", + "size": 12897, + "subdir": "linux-64", + "timestamp": 1659935001974, + "version": "2.3.3" + }, + "airflow-with-google_auth-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "13c1aab5054f4140243ec9d3f7bf30f3", + "name": "airflow-with-google_auth", + "sha256": "a441759a715ca38981da1314a18c18c330d7e8f281aa2768817c89fba46fdc0e", + "size": 13562, + "subdir": "linux-64", + "timestamp": 1671227196463, + "version": "2.4.3" + }, + "airflow-with-google_auth-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2baedead356673b5906ff0a377bcf315", + "name": "airflow-with-google_auth", + "sha256": "34c9f25688b1fc7736e1ebe653e6d9d2cf7ae052b81ef172c0bae74d6f0a3180", + "size": 13539, + "subdir": "linux-64", + "timestamp": 1671227184681, + "version": "2.4.3" + }, + "airflow-with-google_auth-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6c2a15cf52cffea6032afb94457cc68d", + "name": "airflow-with-google_auth", + "sha256": "a62e98c543ce5d09ee071239b89955f06277a14921e32a6bb281f725c117521d", + "size": 13536, + "subdir": "linux-64", + "timestamp": 1671227202061, + "version": "2.4.3" + }, + "airflow-with-google_auth-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "authlib >=0.14,<1.0.0", + "flask-appbuilder", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "afd559adb0bd6b8de63060a56d145803", + "name": "airflow-with-google_auth", + "sha256": "01d6f71d6ce5473e81a7198d9d969cdd45bd8220f85c40d4d198aa56980e5ba5", + "size": 13542, + "subdir": "linux-64", + "timestamp": 1671227190501, + "version": "2.4.3" + }, + "airflow-with-hdfs-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "snakebite >=2.7.8" + ], + "license": "Apache 2.0", + "md5": "9da0bde7d78c3dd271f44ee9f7bb11b8", + "name": "airflow-with-hdfs", + "sha256": "4976f5bffed6ceacea0702f3127b95ac0a91b7b6181990a874bdc9ba7998e3aa", + "size": 20275, + "subdir": "linux-64", + "timestamp": 1605878138462, + "version": "1.10.12" + }, + "airflow-with-hdfs-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "snakebite >=2.7.8" + ], + "license": "Apache 2.0", + "md5": "6024c5b40192b1f307c9cc0891c0705f", + "name": "airflow-with-hdfs", + "sha256": "04f057e2f28a049e495cfb5f3bda6ee4eabd4a22e54fd3fdd359a17b88ef1433", + "size": 18490, + "subdir": "linux-64", + "timestamp": 1579721399728, + "version": "1.10.7" + }, + "airflow-with-jdbc-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "jaydebeapi >=1.1.1" + ], + "license": "Apache 2.0", + "md5": "35eaf8e9c1e5cc8e92ba27ca406ce2c8", + "name": "airflow-with-jdbc", + "sha256": "ccf4d1abf2c8c2561a2f93eba75e0481a15405513c33631c741ca17de2dbf8ce", + "size": 20273, + "subdir": "linux-64", + "timestamp": 1605878139482, + "version": "1.10.12" + }, + "airflow-with-jdbc-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "jaydebeapi >=1.1.1" + ], + "license": "Apache 2.0", + "md5": "64ae9fc8de95d59deca7359e386719ec", + "name": "airflow-with-jdbc", + "sha256": "b026e3c6659ff776c0f6aa0d22ebbb7ebf126a9b072bd7a4e2a4b0a05b653aae", + "size": 18491, + "subdir": "linux-64", + "timestamp": 1579721401583, + "version": "1.10.7" + }, + "airflow-with-jenkins-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "python-jenkins >=1.0.0" + ], + "license": "Apache 2.0", + "md5": "fe6848102429dc6a7788cc4635982cfc", + "name": "airflow-with-jenkins", + "sha256": "cd3f85f2055033e9ef97eac071ab7969adbd79acf1dfa4c1765bacc92952c855", + "size": 20284, + "subdir": "linux-64", + "timestamp": 1605878140505, + "version": "1.10.12" + }, + "airflow-with-jenkins-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "python-jenkins >=1.0.0" + ], + "license": "Apache 2.0", + "md5": "d943d88eafd1776d6f0375dbf8da75b0", + "name": "airflow-with-jenkins", + "sha256": "24b858c4805075e8a3d2ddf3319885a8e1815c9b95039fe429ee88ff3fae228c", + "size": 18498, + "subdir": "linux-64", + "timestamp": 1579721403292, + "version": "1.10.7" + }, + "airflow-with-jira-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "jira >=1.0.7" + ], + "license": "Apache 2.0", + "md5": "2cb8994863d2829fb0c42f4f7cc2f2f4", + "name": "airflow-with-jira", + "sha256": "95caa8f8ac4d124651884cc24b6532d529121910dd4166c232369b855e8ce5a6", + "size": 20269, + "subdir": "linux-64", + "timestamp": 1605878141537, + "version": "1.10.12" + }, + "airflow-with-jira-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "jira >=1.0.7" + ], + "license": "Apache 2.0", + "md5": "d31e87944a0da1c48896343010998eba", + "name": "airflow-with-jira", + "sha256": "de2f69709d9a93bed742ad50a96d6cd68ed735348db75bf82efa8d5cb823fcd3", + "size": 18487, + "subdir": "linux-64", + "timestamp": 1579721405020, + "version": "1.10.7" + }, + "airflow-with-kerberos-2.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.10,<3.11.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "md5": "8ccb5a3f0dfdc6753d7a1f6435a2a841", + "name": "airflow-with-kerberos", + "sha256": "756dd36a18afd6459722fac8ea4ee0efe5ac5925c6e60282f954cf37be71c0c7", + "size": 12953, + "subdir": "linux-64", + "timestamp": 1659884090843, + "version": "2.3.3" + }, + "airflow-with-kerberos-2.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.10,<3.11.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "md5": "834dc3ac1ed1c588fb33f1991d0399e2", + "name": "airflow-with-kerberos", + "sha256": "7fc7f574160f11d796d356eccecb56ebd9d7765c9211ab5e16665b1cd7bec0a5", + "size": 12957, + "subdir": "linux-64", + "timestamp": 1659935029913, + "version": "2.3.3" + }, + "airflow-with-kerberos-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.7,<3.8.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "md5": "b450642803f03c8937f7fd934221199f", + "name": "airflow-with-kerberos", + "sha256": "078f3df7f5f519fea3e4d49573802f016d18cd725ae2bd3e834786a223a30d72", + "size": 12923, + "subdir": "linux-64", + "timestamp": 1659884074037, + "version": "2.3.3" + }, + "airflow-with-kerberos-2.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.7,<3.8.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "md5": "4d6c8862df91bffc246afc24ff19966f", + "name": "airflow-with-kerberos", + "sha256": "a0e69533e5a31c4fd8f7f2e31659cafff1ba493468c40fe22c5e5e084b5ef651", + "size": 12930, + "subdir": "linux-64", + "timestamp": 1659935018545, + "version": "2.3.3" + }, + "airflow-with-kerberos-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.8,<3.9.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "md5": "d877dde0d16cf917e013d2163cf1cb00", + "name": "airflow-with-kerberos", + "sha256": "3926c240ea4332a5c37b0143fa741461f62d0a29fd95b31ce375e326425ff684", + "size": 12924, + "subdir": "linux-64", + "timestamp": 1659884079425, + "version": "2.3.3" + }, + "airflow-with-kerberos-2.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.8,<3.9.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "md5": "ca46cd0b6d0fa0cbd0575dfc76c99d81", + "name": "airflow-with-kerberos", + "sha256": "8314c8264e0781aa31401ff95d4fc38b709dca82b98a41de38b04afec41a8426", + "size": 12931, + "subdir": "linux-64", + "timestamp": 1659935035337, + "version": "2.3.3" + }, + "airflow-with-kerberos-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.9,<3.10.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "md5": "ebc38f36e3ebda03c5eb7761c5acdaeb", + "name": "airflow-with-kerberos", + "sha256": "4de7e464b8fdc6ed5e22d93b0a551d68ebba19c2f49ce567111e17b841786c59", + "size": 12917, + "subdir": "linux-64", + "timestamp": 1659884085025, + "version": "2.3.3" + }, + "airflow-with-kerberos-2.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.9,<3.10.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "md5": "60fd718443e0286d69138cb22db045f8", + "name": "airflow-with-kerberos", + "sha256": "7d99ba96fe5ca84868f6db17476c189eb73874cbe9ab836f6f0cca0a8ec3047e", + "size": 12924, + "subdir": "linux-64", + "timestamp": 1659935024138, + "version": "2.3.3" + }, + "airflow-with-kerberos-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.10,<3.11.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "08687fa56f157726a5f161d0f13de377", + "name": "airflow-with-kerberos", + "sha256": "3b8d56ab1d99fc85a741ad602ec94f4119d11054d7cde921c8c4cc4b4147a086", + "size": 13601, + "subdir": "linux-64", + "timestamp": 1671227219289, + "version": "2.4.3" + }, + "airflow-with-kerberos-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.7,<3.8.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "19d7bad27db6a02c67271bffb9da68f0", + "name": "airflow-with-kerberos", + "sha256": "7f2dbd69d928987f2dd602fa23cefd6838c582c10956e0e58295e5abc977f188", + "size": 13579, + "subdir": "linux-64", + "timestamp": 1671227207517, + "version": "2.4.3" + }, + "airflow-with-kerberos-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.8,<3.9.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "828c4565cc89dd8aeadb3d2461794756", + "name": "airflow-with-kerberos", + "sha256": "21e800c04ec0aab5b785023fad2f0d6ff0f77496f3b480814f000abbea103fa0", + "size": 13588, + "subdir": "linux-64", + "timestamp": 1671227224901, + "version": "2.4.3" + }, + "airflow-with-kerberos-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "pure-sasl >=0.6.2", + "pykerberos >=1.1.13", + "python >=3.9,<3.10.0a0", + "requests-kerberos >=0.10.0", + "six >=1.13.0", + "thrift >=0.13", + "thrift_sasl >=0.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d72125d0f63efb6387ffff0c9602ea75", + "name": "airflow-with-kerberos", + "sha256": "3e7dddce82ed803554dee3f8a3c49dbf5115d7e48c97dc45ade3bc53195f3481", + "size": 13580, + "subdir": "linux-64", + "timestamp": 1671227213321, + "version": "2.4.3" + }, + "airflow-with-kubernetes-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "cryptography >=2.0.0", + "python-kubernetes >=3.0.0" + ], + "license": "Apache 2.0", + "md5": "02295626ce23daba2722f1852b503861", + "name": "airflow-with-kubernetes", + "sha256": "3de29b047169aeaa0816180e5205ee891cb8ac574e492acc2685ed83fb18189c", + "size": 20306, + "subdir": "linux-64", + "timestamp": 1605878142570, + "version": "1.10.12" + }, + "airflow-with-kubernetes-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "cryptography >=2.0.0", + "python-kubernetes >=3.0.0" + ], + "license": "Apache 2.0", + "md5": "2d43c17769cc322ad89b48ec7c59dca1", + "name": "airflow-with-kubernetes", + "sha256": "5a1594f939891149ccf1bc0eaa0caa231d090fcb67f0bc7b143eba089fe55254", + "size": 18524, + "subdir": "linux-64", + "timestamp": 1579721406717, + "version": "1.10.7" + }, + "airflow-with-ldap-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "ldap3 >=2.5.1" + ], + "license": "Apache 2.0", + "md5": "abf82d7791949835224b7fa4534156b4", + "name": "airflow-with-ldap", + "sha256": "f435df59eab16ae6a2ca5f1e12fd47d2871a78e57d7ed0d204e229a0d1c6134b", + "size": 20269, + "subdir": "linux-64", + "timestamp": 1605878143600, + "version": "1.10.12" + }, + "airflow-with-ldap-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "ldap3 >=2.5.1" + ], + "license": "Apache 2.0", + "md5": "a571290060ca2f9cf7c09e36874bce8f", + "name": "airflow-with-ldap", + "sha256": "12276db52626f53fe9161eeccd617acf4ce5bf1704d4465d8b6e5758fa02a13b", + "size": 18490, + "subdir": "linux-64", + "timestamp": 1579721408409, + "version": "1.10.7" + }, + "airflow-with-ldap-2.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "ldap3 >=2.5.1", + "python >=3.10,<3.11.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "md5": "6b5522b6bb1102569d3dce024b0ad9d7", + "name": "airflow-with-ldap", + "sha256": "3fac4491776af45a3da828732faee60667a3b9de21653330ad6ee8ca4ac14b7c", + "size": 12885, + "subdir": "linux-64", + "timestamp": 1659884112900, + "version": "2.3.3" + }, + "airflow-with-ldap-2.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "ldap3 >=2.5.1", + "python >=3.10,<3.11.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "md5": "08dbea9d05319867370bb209c5bbd87b", + "name": "airflow-with-ldap", + "sha256": "cfe9f046ea75b1d8309a3a1b7f5c147861e996b48373a6d62dffd417a53a44cb", + "size": 12881, + "subdir": "linux-64", + "timestamp": 1659935052161, + "version": "2.3.3" + }, + "airflow-with-ldap-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "ldap3 >=2.5.1", + "python >=3.7,<3.8.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "md5": "01f74ea833086fd7cac65874a1fd22d1", + "name": "airflow-with-ldap", + "sha256": "60b06e5c589a85046063ddabb03c39da39ecd038c025c804b9a64480449e56e6", + "size": 12854, + "subdir": "linux-64", + "timestamp": 1659884096228, + "version": "2.3.3" + }, + "airflow-with-ldap-2.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "ldap3 >=2.5.1", + "python >=3.7,<3.8.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "md5": "0459ee5e125d3c74981d71cb510e4c8f", + "name": "airflow-with-ldap", + "sha256": "b25436a03cc38c6d4e3051e15506d36a8c534191e325864e29840ded44c8144e", + "size": 12856, + "subdir": "linux-64", + "timestamp": 1659935040760, + "version": "2.3.3" + }, + "airflow-with-ldap-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "ldap3 >=2.5.1", + "python >=3.8,<3.9.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "md5": "e61b38b2b265056df3b425c448c66d27", + "name": "airflow-with-ldap", + "sha256": "bd5cda71d326ccdd7a0b12604007884c5e826382d94ce9c322e32e3b8baf7c11", + "size": 12858, + "subdir": "linux-64", + "timestamp": 1659884101554, + "version": "2.3.3" + }, + "airflow-with-ldap-2.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "ldap3 >=2.5.1", + "python >=3.8,<3.9.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "md5": "c3d1cd9a2b92c28c8b7e37663504619d", + "name": "airflow-with-ldap", + "sha256": "b1d8624f8ded95a5475c23b42d6bf8f030fcfcc18658dba42e9eb25daa64b71b", + "size": 12852, + "subdir": "linux-64", + "timestamp": 1659935057616, + "version": "2.3.3" + }, + "airflow-with-ldap-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "ldap3 >=2.5.1", + "python >=3.9,<3.10.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "md5": "4f2e8fcc26fafc2c940f160096c5f727", + "name": "airflow-with-ldap", + "sha256": "0a4ec38e81f44bed9c351bb88c0a3c70b528c8476d9bfc54df90efb1d7e51e18", + "size": 12849, + "subdir": "linux-64", + "timestamp": 1659884107123, + "version": "2.3.3" + }, + "airflow-with-ldap-2.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "ldap3 >=2.5.1", + "python >=3.9,<3.10.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "md5": "b380353add8b3c32e4d188ba51f6c0d2", + "name": "airflow-with-ldap", + "sha256": "8886926deb60d4531331e505897a5977d9e279943fd893af506636bc010f8998", + "size": 12854, + "subdir": "linux-64", + "timestamp": 1659935046394, + "version": "2.3.3" + }, + "airflow-with-ldap-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "ldap3 >=2.5.1", + "python >=3.10,<3.11.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "74370317c16a62b2f30a0a61d459bf83", + "name": "airflow-with-ldap", + "sha256": "29104839f336923c106e0b3c4372a30965e8e6e891e546c8c0a3610874ae0dcd", + "size": 13528, + "subdir": "linux-64", + "timestamp": 1671227242106, + "version": "2.4.3" + }, + "airflow-with-ldap-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "ldap3 >=2.5.1", + "python >=3.7,<3.8.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8be44f8996879cef278e1338ce169727", + "name": "airflow-with-ldap", + "sha256": "a557a1427fc402cfad5dd0ac14e9cddb0d0b5f8640f21149608f97b10be90ea3", + "size": 13507, + "subdir": "linux-64", + "timestamp": 1671227230343, + "version": "2.4.3" + }, + "airflow-with-ldap-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "ldap3 >=2.5.1", + "python >=3.8,<3.9.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a4bfa9463e596d43361ac9653196a5bf", + "name": "airflow-with-ldap", + "sha256": "154e3432e7cde76f9ae736fe560317fcd914a1f6d688fcf9446e1e1d6471370a", + "size": 13510, + "subdir": "linux-64", + "timestamp": 1671227247726, + "version": "2.4.3" + }, + "airflow-with-ldap-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "ldap3 >=2.5.1", + "python >=3.9,<3.10.0a0", + "python-ldap" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "64c5a145d7f09e620eb43c67438f0d7e", + "name": "airflow-with-ldap", + "sha256": "0cffca5599c5884968dd61c9c2c196999d19e2c52cbef0770f31f48ef5b75048", + "size": 13510, + "subdir": "linux-64", + "timestamp": 1671227236136, + "version": "2.4.3" + }, + "airflow-with-leveldb-2.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "plyvel", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "5a759ee8bbd5b35d2c8d2fd12cd7c69c", + "name": "airflow-with-leveldb", + "sha256": "ff946fa88237aa12970866a9dae47dde43f812ca8cb8e2ab2e7be863b15246a3", + "size": 12878, + "subdir": "linux-64", + "timestamp": 1659884135038, + "version": "2.3.3" + }, + "airflow-with-leveldb-2.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "plyvel", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "40c6956ed07c3abd5bbf5ad00c174817", + "name": "airflow-with-leveldb", + "sha256": "f30cc521fab2125af74ecf8864f82dcec83d43a23c12cf0936addc4c02e9dde2", + "size": 12887, + "subdir": "linux-64", + "timestamp": 1659935074243, + "version": "2.3.3" + }, + "airflow-with-leveldb-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "plyvel", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "514750408a3fefa8df7843e3968002f1", + "name": "airflow-with-leveldb", + "sha256": "866df9eeb41f910075e6e2bf75b26c6052cd4c2dcbc8af53f8fd63724ec3eeb7", + "size": 12856, + "subdir": "linux-64", + "timestamp": 1659884118275, + "version": "2.3.3" + }, + "airflow-with-leveldb-2.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "plyvel", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "d8468580f2d0bafadabf0cd23c44a3c3", + "name": "airflow-with-leveldb", + "sha256": "8fbfc76be77f4130675398cd09c07e3fca6cfb7162c296b4b581b28c0dc586a7", + "size": 12874, + "subdir": "linux-64", + "timestamp": 1659935062975, + "version": "2.3.3" + }, + "airflow-with-leveldb-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "plyvel", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "d02d8cb054669dbd92c9b070cfa85e21", + "name": "airflow-with-leveldb", + "sha256": "6e00c1056d749134af47b1c5751323f032c7af80d28bbfb9e3f7d8d9d01382d3", + "size": 12859, + "subdir": "linux-64", + "timestamp": 1659884123657, + "version": "2.3.3" + }, + "airflow-with-leveldb-2.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "plyvel", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "9b74f4248093b101eec58107f5fc064f", + "name": "airflow-with-leveldb", + "sha256": "92c2622c7992456bba1d7e57a97946d4cc45ab57d2cb1f9f6aaaa64f28082f34", + "size": 12866, + "subdir": "linux-64", + "timestamp": 1659935079702, + "version": "2.3.3" + }, + "airflow-with-leveldb-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "plyvel", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "3961c1c1f1c2f384b14f1ed0b8b5288b", + "name": "airflow-with-leveldb", + "sha256": "d8a280c75fd619e936a5d716c7a6647fb92f40b5290b9510bceb6c1057bce31e", + "size": 12851, + "subdir": "linux-64", + "timestamp": 1659884129234, + "version": "2.3.3" + }, + "airflow-with-leveldb-2.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "plyvel", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "471f9f8755f35b0584a868aa28fb114c", + "name": "airflow-with-leveldb", + "sha256": "f5f2f540002f11ff47fed8adfab189ed703b592a9aacbb8d1c2d6f2e6d1666d7", + "size": 12862, + "subdir": "linux-64", + "timestamp": 1659935068603, + "version": "2.3.3" + }, + "airflow-with-leveldb-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "plyvel", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7551b9c7ac254b34e7bb225d32a7dad7", + "name": "airflow-with-leveldb", + "sha256": "a94e9b2f786d4b55ece18b9f140ed51e6b7922ed86351b2a4b26a79f9e232b22", + "size": 13537, + "subdir": "linux-64", + "timestamp": 1671227264987, + "version": "2.4.3" + }, + "airflow-with-leveldb-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "plyvel", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1cb2f0415fb0837b3b513a8e5bf07446", + "name": "airflow-with-leveldb", + "sha256": "41557f7efbae30058b42ea5f26c77ab7f8449e00dc6b2434ac320fb917783089", + "size": 13506, + "subdir": "linux-64", + "timestamp": 1671227253319, + "version": "2.4.3" + }, + "airflow-with-leveldb-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "plyvel", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "db76d2dd2058daa51b7bfb839e7e21a3", + "name": "airflow-with-leveldb", + "sha256": "4fd51893fa14e33b891ad81dc9b1051ab1d9831feb0f28d46f73d15c7200aa32", + "size": 13510, + "subdir": "linux-64", + "timestamp": 1671227270658, + "version": "2.4.3" + }, + "airflow-with-leveldb-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "plyvel", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bffb025b63376aae645055596241b3a6", + "name": "airflow-with-leveldb", + "sha256": "f688970c8d3dfea0b326f3ea4cd7845bab8bf9f2ef08c50e437c2c3d6ea1a582", + "size": 13513, + "subdir": "linux-64", + "timestamp": 1671227259009, + "version": "2.4.3" + }, + "airflow-with-mongo-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "dnspython >=1.13.0,<2.0.0", + "pymongo >=3.6.0" + ], + "license": "Apache 2.0", + "md5": "4c5a2bd1d6d3de30c557c14a4abce4b0", + "name": "airflow-with-mongo", + "sha256": "5a8574f04838b8572bdba1c94a6f728147261b2ef199ead3ec6d0a284408dbe7", + "size": 20282, + "subdir": "linux-64", + "timestamp": 1605878144600, + "version": "1.10.12" + }, + "airflow-with-mongo-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "dnspython >=1.13.0,<2.0.0", + "pymongo >=3.6.0" + ], + "license": "Apache 2.0", + "md5": "e8d694aedc5ad154b680bfe72bfcf721", + "name": "airflow-with-mongo", + "sha256": "0687c8c850492076e89c06c8c65da95bac6db6ce19945e9bf63ef02a031efacb", + "size": 18509, + "subdir": "linux-64", + "timestamp": 1579721410046, + "version": "1.10.7" + }, + "airflow-with-mssql-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "pymssql >=2.1.1,<2.2.0" + ], + "license": "Apache 2.0", + "md5": "7eafa8d867583352d96c6fd1883e6fa3", + "name": "airflow-with-mssql", + "sha256": "bf7eb2db132085cf9bbfc89f17e0aa44e064f629f832793bd07672d8d081e766", + "size": 20279, + "subdir": "linux-64", + "timestamp": 1605878145614, + "version": "1.10.12" + }, + "airflow-with-mssql-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "pymssql >=2.1.1,<2.2.0" + ], + "license": "Apache 2.0", + "md5": "305fd0a56a95fca98d0bd1e73bb19e8e", + "name": "airflow-with-mssql", + "sha256": "39147e17ec78525f914b5ded56986b183de9fbfa6d7e70fcfc48cbe1505c85df", + "size": 18498, + "subdir": "linux-64", + "timestamp": 1579721411744, + "version": "1.10.7" + }, + "airflow-with-mysql-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "mysqlclient >=1.3.6" + ], + "license": "Apache 2.0", + "md5": "1ee831aef7290f25f28e062a6cd42a84", + "name": "airflow-with-mysql", + "sha256": "c515709b4d6658362226fa64a9208ed4a9a527a53fdb702501f266580246aeb4", + "size": 20271, + "subdir": "linux-64", + "timestamp": 1605878146639, + "version": "1.10.12" + }, + "airflow-with-mysql-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "mysqlclient >=1.3.6,<1.4" + ], + "license": "Apache 2.0", + "md5": "daa81ae3343cab5d8d1f43779e21da0d", + "name": "airflow-with-mysql", + "sha256": "23b6f992ef7ad590f16f1677524e074d17043542e29d2973e404cf0f8944a155", + "size": 18499, + "subdir": "linux-64", + "timestamp": 1579721413444, + "version": "1.10.7" + }, + "airflow-with-pandas-2.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pandas >=0.17.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "12f52acdeccfd4e6c31338a133a906aa", + "name": "airflow-with-pandas", + "sha256": "56d496f9e37906b74f7c978ba0ea06cb6a9400555a82c14abd018bbadb1110d0", + "size": 12881, + "subdir": "linux-64", + "timestamp": 1659884157277, + "version": "2.3.3" + }, + "airflow-with-pandas-2.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pandas >=0.17.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "e60fd10e4b28c8d23409f7c26fbb7615", + "name": "airflow-with-pandas", + "sha256": "a01e63654097fd398e65d2d7b3fd05e9570481ed79afaa916e48da19fc2ab35e", + "size": 12885, + "subdir": "linux-64", + "timestamp": 1659935096517, + "version": "2.3.3" + }, + "airflow-with-pandas-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pandas >=0.17.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "167baa7ea86042c8f417c89b92725ee6", + "name": "airflow-with-pandas", + "sha256": "e4aaeb59b9df2bda946e00430e7a9d2103e4b25d2b6ebce815e2ef1a788d29dc", + "size": 12856, + "subdir": "linux-64", + "timestamp": 1659884140443, + "version": "2.3.3" + }, + "airflow-with-pandas-2.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pandas >=0.17.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "34e1deaa27a35d9e9c516ab243239b7d", + "name": "airflow-with-pandas", + "sha256": "48d642d23f02f4a3407d541f3e267c63618893ce8e3d91185069bda5d4dbb213", + "size": 12859, + "subdir": "linux-64", + "timestamp": 1659935085075, + "version": "2.3.3" + }, + "airflow-with-pandas-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pandas >=0.17.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "2874db8290ec7ce72391278939b0576f", + "name": "airflow-with-pandas", + "sha256": "836cb823dadd19846b676dae483639b059a38eef1cc6e08750f6714b7bbe4904", + "size": 12860, + "subdir": "linux-64", + "timestamp": 1659884145925, + "version": "2.3.3" + }, + "airflow-with-pandas-2.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pandas >=0.17.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "bfebeaec9b9b3a7e402af6199659a3cc", + "name": "airflow-with-pandas", + "sha256": "eef3b6904c93cfa50c22e9c9ad9fbcfa560c2eb756b79f1110c738f14a9e8cee", + "size": 12866, + "subdir": "linux-64", + "timestamp": 1659935102005, + "version": "2.3.3" + }, + "airflow-with-pandas-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pandas >=0.17.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "1d5b521edee320b525b60261823f8dad", + "name": "airflow-with-pandas", + "sha256": "1da3a7af83183e255f33d6b3d61eff9cad58938768698ef60195376386680043", + "size": 12849, + "subdir": "linux-64", + "timestamp": 1659884151398, + "version": "2.3.3" + }, + "airflow-with-pandas-2.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "pandas >=0.17.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "479b2dede401c680c0c23aff9765552e", + "name": "airflow-with-pandas", + "sha256": "a8b1869cff98dbe427eaee26604b83af68ec5b819d6238983b989665a1718f8a", + "size": 12857, + "subdir": "linux-64", + "timestamp": 1659935090658, + "version": "2.3.3" + }, + "airflow-with-pandas-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "pandas >=0.17.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b2912ee757aec7a46bce26d4255d8ab0", + "name": "airflow-with-pandas", + "sha256": "4e1c96a3d052b9f14bda5bd9a785619e297b4ea6d2d6f668b34def4af4f91b22", + "size": 13539, + "subdir": "linux-64", + "timestamp": 1671227287999, + "version": "2.4.3" + }, + "airflow-with-pandas-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "pandas >=0.17.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "318489d7d5beff41cfee2babe9ebd3e4", + "name": "airflow-with-pandas", + "sha256": "299d8d5eb7e586c3862ff8f4efa41b4edcececf631af8f2fffeb49b9ac747559", + "size": 13507, + "subdir": "linux-64", + "timestamp": 1671227276289, + "version": "2.4.3" + }, + "airflow-with-pandas-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "pandas >=0.17.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "66cf417693ee2bb84327f4f8490d5ab4", + "name": "airflow-with-pandas", + "sha256": "7c282af4eccc3dc51258d9d161baae8d90790e92bb69ac9bf30b65e1b069bed4", + "size": 13508, + "subdir": "linux-64", + "timestamp": 1671227293637, + "version": "2.4.3" + }, + "airflow-with-pandas-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "pandas >=0.17.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "72b2b28fd1b485a822b33f2d292c4554", + "name": "airflow-with-pandas", + "sha256": "23e8157ee3caf9eaa16088b78d959c5f2a0d9bea4d615d37c6f167f50ad4b70b", + "size": 13509, + "subdir": "linux-64", + "timestamp": 1671227282129, + "version": "2.4.3" + }, + "airflow-with-password-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1" + ], + "license": "Apache 2.0", + "md5": "ca84fd61458598223a4313d486562277", + "name": "airflow-with-password", + "sha256": "1e60d6ae8f48c347c81fab66de7c9526254b3ea68da4609434d9b1ddec76810f", + "size": 20294, + "subdir": "linux-64", + "timestamp": 1605878147668, + "version": "1.10.12" + }, + "airflow-with-password-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1" + ], + "license": "Apache 2.0", + "md5": "148aa6347354bc37b396413688c84910", + "name": "airflow-with-password", + "sha256": "a94a2701a3dfef3adf5aec9eadad58fd70afad412f54e03d58dab186a5b3602d", + "size": 18514, + "subdir": "linux-64", + "timestamp": 1579721415038, + "version": "1.10.7" + }, + "airflow-with-password-2.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "e1c21d73294c7d44ad3ecd0cbafc8186", + "name": "airflow-with-password", + "sha256": "03705f383dd0cf6476e7b95ebfe7627f546e8220a8463497a13fc72121edd7f4", + "size": 12903, + "subdir": "linux-64", + "timestamp": 1659884179346, + "version": "2.3.3" + }, + "airflow-with-password-2.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "47e5167a9eed076147373ca3caa88f9a", + "name": "airflow-with-password", + "sha256": "561f24df42cba41c8b12bdb93f134814a884c26cc9b2da9b30c06abc2466f184", + "size": 12911, + "subdir": "linux-64", + "timestamp": 1659935118836, + "version": "2.3.3" + }, + "airflow-with-password-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "a34d0c105a609f1456531e918a94ef45", + "name": "airflow-with-password", + "sha256": "94c9c483ccdadef5e2fb13b927ab314ab419b55f056e3f54dc457a43f28a92a1", + "size": 12874, + "subdir": "linux-64", + "timestamp": 1659884162552, + "version": "2.3.3" + }, + "airflow-with-password-2.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "c78a52c89614a36bd422b7771d3119ac", + "name": "airflow-with-password", + "sha256": "cb6519967b923be21960368ce935e7d21970d7366ae6c6d11a3b741761e6bd35", + "size": 12881, + "subdir": "linux-64", + "timestamp": 1659935107394, + "version": "2.3.3" + }, + "airflow-with-password-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "7e9e30e12ac2fcdb3f001d34bf3b7f24", + "name": "airflow-with-password", + "sha256": "0a6f176318b1495b38db56eb576df7a9f9fef66e5d464a78d00479a02f649240", + "size": 12888, + "subdir": "linux-64", + "timestamp": 1659884167944, + "version": "2.3.3" + }, + "airflow-with-password-2.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "5e7282a4271a288ee712d7796bfbf74e", + "name": "airflow-with-password", + "sha256": "ceab6872932fbf1fd6cce65e5626828d7c8691c300d91b07db62c043b0a8b3fd", + "size": 12882, + "subdir": "linux-64", + "timestamp": 1659935124284, + "version": "2.3.3" + }, + "airflow-with-password-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "3a1a945607cbf1d05be41fdd11015d57", + "name": "airflow-with-password", + "sha256": "f83a3e04f753777aa8c29b080ac76e0e64dbbd15aa4da63ea884169310348453", + "size": 12875, + "subdir": "linux-64", + "timestamp": 1659884173573, + "version": "2.3.3" + }, + "airflow-with-password-2.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "f57b4fa062cfa79cc769211473dc19bb", + "name": "airflow-with-password", + "sha256": "78681fbcfec34a753ebbc947aaf5f5248cd7983fe6f0d0d2aa4b080b45504a1d", + "size": 12882, + "subdir": "linux-64", + "timestamp": 1659935112999, + "version": "2.3.3" + }, + "airflow-with-password-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "587fe1cff3bca96557b3b489fa0d8402", + "name": "airflow-with-password", + "sha256": "103a9e58d75ff071638030f4a70a28129611931d7020c457a913071b131737e3", + "size": 13556, + "subdir": "linux-64", + "timestamp": 1671227310953, + "version": "2.4.3" + }, + "airflow-with-password-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8005f57984eef50f65148f219db6a6e0", + "name": "airflow-with-password", + "sha256": "ddcf6cdc09d7f975f24af76de62dca79030be0471413f911efead08c25de3818", + "size": 13521, + "subdir": "linux-64", + "timestamp": 1671227299250, + "version": "2.4.3" + }, + "airflow-with-password-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ed1ed59aead71ca613613b349321b5ec", + "name": "airflow-with-password", + "sha256": "3004cb6dd2558b06b0b9726b652ebcb5f279dc661d5108948c5b95add7c1d82f", + "size": 13522, + "subdir": "linux-64", + "timestamp": 1671227316589, + "version": "2.4.3" + }, + "airflow-with-password-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "bcrypt >=2.0.0", + "flask-bcrypt >=0.7.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ed4b16b20429e6cade55651f311566d2", + "name": "airflow-with-password", + "sha256": "3efdb9c6b4ebd855e9093bf0a63a5c7ff0d3e679f81a622556213ed5d8ba1844", + "size": 13526, + "subdir": "linux-64", + "timestamp": 1671227305081, + "version": "2.4.3" + }, + "airflow-with-postgres-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "psycopg2 >=2.7.4" + ], + "license": "Apache 2.0", + "md5": "a37e2a540f8d4ca0f3720478902a4ef6", + "name": "airflow-with-postgres", + "sha256": "d6538da1849fccb0c993c11e447c9c308706bd838eda5415d1c83053c63f7ba3", + "size": 20300, + "subdir": "linux-64", + "timestamp": 1605878148717, + "version": "1.10.12" + }, + "airflow-with-postgres-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "psycopg2 >=2.7.4" + ], + "license": "Apache 2.0", + "md5": "267459331692fb34d27293536e0adbbb", + "name": "airflow-with-postgres", + "sha256": "ed8f4da2f49a1b2a306cb3b4f40b8df01a18051fc6dc86f45741cc5df79da8af", + "size": 18519, + "subdir": "linux-64", + "timestamp": 1579721416709, + "version": "1.10.7" + }, + "airflow-with-qds-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "qds-sdk >=1.10.4" + ], + "license": "Apache 2.0", + "md5": "b9f5a017d8dc4e8514cb772c59382e9c", + "name": "airflow-with-qds", + "sha256": "5c18c1a476caa8c84140299529936d30f51a5b215fafdbd5c528212af07c29da", + "size": 20279, + "subdir": "linux-64", + "timestamp": 1605878149756, + "version": "1.10.12" + }, + "airflow-with-qds-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "qds-sdk >=1.10.4" + ], + "license": "Apache 2.0", + "md5": "36944ddbd3404291906bb07baddb9e78", + "name": "airflow-with-qds", + "sha256": "33ca616d4b9a061f9675773423fc60b5a5e7a1c58a47d5b9e8df7ba1b432849a", + "size": 18484, + "subdir": "linux-64", + "timestamp": 1579721418353, + "version": "1.10.7" + }, + "airflow-with-rabbitmq-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "librabbitmq >=1.6.1" + ], + "license": "Apache 2.0", + "md5": "0ce71e500850415e9768c16c4dc521c3", + "name": "airflow-with-rabbitmq", + "sha256": "eb275f0b0b8e7e72f019dd771590c1fc8231df11c5b1af1569137a13f9a3406f", + "size": 20300, + "subdir": "linux-64", + "timestamp": 1605878150776, + "version": "1.10.12" + }, + "airflow-with-rabbitmq-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "librabbitmq >=1.6.1" + ], + "license": "Apache 2.0", + "md5": "ab8e42b3a3a9579d8c8aa8e9ee1cd609", + "name": "airflow-with-rabbitmq", + "sha256": "d7eb86327dffdcd39de271ba9e9a8ef257f1fccb786cf5cc1ecb36f4f3c3b284", + "size": 18505, + "subdir": "linux-64", + "timestamp": 1579721420187, + "version": "1.10.7" + }, + "airflow-with-rabbitmq-2.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "amqp", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "f1bd8d3745951bd194f35479ccaa5271", + "name": "airflow-with-rabbitmq", + "sha256": "111e36e6e9866a1446e13609e7be110735b6ba14bddaafa925d54fb28c8c03b7", + "size": 12884, + "subdir": "linux-64", + "timestamp": 1659884201443, + "version": "2.3.3" + }, + "airflow-with-rabbitmq-2.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "amqp", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "87e5822e1aeaa8114f852435ac172336", + "name": "airflow-with-rabbitmq", + "sha256": "70899e30d69831d995b8b0502b95a8a0aebaaba6eacd098cd14905798190bb53", + "size": 12899, + "subdir": "linux-64", + "timestamp": 1659935140926, + "version": "2.3.3" + }, + "airflow-with-rabbitmq-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "amqp", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "551f26f90f68f955709b510b7e6386b0", + "name": "airflow-with-rabbitmq", + "sha256": "b036f77640c7452a5707e718f49b3456ed8d6e22b5861e04e87559f46bce3d72", + "size": 12859, + "subdir": "linux-64", + "timestamp": 1659884184747, + "version": "2.3.3" + }, + "airflow-with-rabbitmq-2.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "amqp", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "6a74a08e83fc86513583a8aa02fb2b5d", + "name": "airflow-with-rabbitmq", + "sha256": "a85547e660452971e9200d7109408931ff367c41be02cc927d4c0ff0c2b84317", + "size": 12861, + "subdir": "linux-64", + "timestamp": 1659935129547, + "version": "2.3.3" + }, + "airflow-with-rabbitmq-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "amqp", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "054e170ae8d70e058539d27bbb47d8b1", + "name": "airflow-with-rabbitmq", + "sha256": "18b9b397794224bc590e654a28fe62b620b2e6fdf5aaf9e5028072023d4683dd", + "size": 12857, + "subdir": "linux-64", + "timestamp": 1659884190171, + "version": "2.3.3" + }, + "airflow-with-rabbitmq-2.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "amqp", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "8ac11fc12fcb9d4439aca04b93f31a58", + "name": "airflow-with-rabbitmq", + "sha256": "f7fb6c10153c3c632b341c7b0b2668fcd03467ed3ca19e0499de649ff2ee63d5", + "size": 12864, + "subdir": "linux-64", + "timestamp": 1659935146440, + "version": "2.3.3" + }, + "airflow-with-rabbitmq-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "amqp", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "9b83d95f37bbb66676b9a36c4fbc7cfc", + "name": "airflow-with-rabbitmq", + "sha256": "c32ce3d095f56b29c4bc15c67fa7162f4b0a343682da0920cb407fdda4c28152", + "size": 12866, + "subdir": "linux-64", + "timestamp": 1659884195752, + "version": "2.3.3" + }, + "airflow-with-rabbitmq-2.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "amqp", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "9263839d110ea99453a07d4a2f35d42a", + "name": "airflow-with-rabbitmq", + "sha256": "2a4098748309c49aa253fbf11e7d5f8e684eff0b75afbea6c0055156f19244e0", + "size": 12862, + "subdir": "linux-64", + "timestamp": 1659935135175, + "version": "2.3.3" + }, + "airflow-with-rabbitmq-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "amqp", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ce098aef496e347879d95aca762a103a", + "name": "airflow-with-rabbitmq", + "sha256": "a3db17ce428ac149ba296ee7c8fc8c8299ff11e524089834adc405bbab32f005", + "size": 13542, + "subdir": "linux-64", + "timestamp": 1671227333921, + "version": "2.4.3" + }, + "airflow-with-rabbitmq-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "amqp", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "af12279f6e6a3bce560a715a671aeeed", + "name": "airflow-with-rabbitmq", + "sha256": "f5049a3ead8d8cc6326266a897e5bdfbad58a768b88c0d70377363b4c45a2337", + "size": 13509, + "subdir": "linux-64", + "timestamp": 1671227322210, + "version": "2.4.3" + }, + "airflow-with-rabbitmq-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "amqp", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8ee40efc29f11cf9836d8dbb7b741ed4", + "name": "airflow-with-rabbitmq", + "sha256": "06b71ce9e7df66fe87f08b31b44e7c52da0a74f39c459c143812d5bd10c61865", + "size": 13512, + "subdir": "linux-64", + "timestamp": 1671227339542, + "version": "2.4.3" + }, + "airflow-with-rabbitmq-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "amqp", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1ad99f70a547410a0eab428c42772bd5", + "name": "airflow-with-rabbitmq", + "sha256": "39836a2fdebf2072eaf57eec3493ce71a1c2349afea52bda3d299a2d1af1e9a4", + "size": 13517, + "subdir": "linux-64", + "timestamp": 1671227328046, + "version": "2.4.3" + }, + "airflow-with-redis-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "redis-py >=3.2.0" + ], + "license": "Apache 2.0", + "md5": "7388cbb7dc103424cfc65862e152eaa8", + "name": "airflow-with-redis", + "sha256": "d74d7dc6bb10994dd641d03a96714af40c57a78f9e90ed5101278857d1d65965", + "size": 20288, + "subdir": "linux-64", + "timestamp": 1605878151857, + "version": "1.10.12" + }, + "airflow-with-redis-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "redis-py >=3.2.0,<3.3.0" + ], + "license": "Apache 2.0", + "md5": "790a6affcacfa5e40f784a50c399216c", + "name": "airflow-with-redis", + "sha256": "a699659a7646bb31107311eb8384d1ee9bff731308ba898a5531f6d278857bb9", + "size": 18502, + "subdir": "linux-64", + "timestamp": 1579721421882, + "version": "1.10.7" + }, + "airflow-with-salesforce-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "simple-salesforce >=0.72" + ], + "license": "Apache 2.0", + "md5": "5803ba005b405375abad2628d6643312", + "name": "airflow-with-salesforce", + "sha256": "74832cda506f524c58e6e158eef6fa295e2e38c56c052126458acb2ad4bf74ef", + "size": 20300, + "subdir": "linux-64", + "timestamp": 1605878152895, + "version": "1.10.12" + }, + "airflow-with-salesforce-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "simple-salesforce >=0.72" + ], + "license": "Apache 2.0", + "md5": "8f6386cec2034fbf1128f253d501fef9", + "name": "airflow-with-salesforce", + "sha256": "30e32ff5b4598db0077d0145185310ee94bddc3a714d7d74bcbc4c29bd2c2639", + "size": 18520, + "subdir": "linux-64", + "timestamp": 1579721423564, + "version": "1.10.7" + }, + "airflow-with-samba-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "pysmbclient >=0.1.3" + ], + "license": "Apache 2.0", + "md5": "35c17591e3670a826d2eabde046c77f1", + "name": "airflow-with-samba", + "sha256": "54ee77ed7d7e8d84aec2c0fde5ba89180aa72a8b1fdb9c7e4fe81b73089c4b34", + "size": 20286, + "subdir": "linux-64", + "timestamp": 1605878153928, + "version": "1.10.12" + }, + "airflow-with-samba-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "pysmbclient >=0.1.3" + ], + "license": "Apache 2.0", + "md5": "73d4e7b3f525bc4ee9ebbf881aafd0e7", + "name": "airflow-with-samba", + "sha256": "b05632ed84f0b81c58947ff907412502d551f598452479cb66612718aa9b40a9", + "size": 18498, + "subdir": "linux-64", + "timestamp": 1579721425260, + "version": "1.10.7" + }, + "airflow-with-sendgrid-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "sendgrid >=6.0.0" + ], + "license": "Apache 2.0", + "md5": "533480de25f8403c5a494ecd98104467", + "name": "airflow-with-sendgrid", + "sha256": "9c3b8ebb18fd0e7e23f3a9808efce431d558efca4b8409a3e122f41fb9138e92", + "size": 20293, + "subdir": "linux-64", + "timestamp": 1605878154940, + "version": "1.10.12" + }, + "airflow-with-sendgrid-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "sendgrid >=6.0.0,<7" + ], + "license": "Apache 2.0", + "md5": "e6d449ebfad9c2619bd22865140b4122", + "name": "airflow-with-sendgrid", + "sha256": "6a1c9cd55e81cf4a80fa1add9cbba71debcb9ebbebbc1457335bb8c6350e34f9", + "size": 18507, + "subdir": "linux-64", + "timestamp": 1579721426969, + "version": "1.10.7" + }, + "airflow-with-sentry-2.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "blinker >=1.1", + "python >=3.10,<3.11.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "md5": "64a1b13273575ac732c71472f91c0a48", + "name": "airflow-with-sentry", + "sha256": "1758bb6dfc052b6515e8530b9d5ee9f0163e511a262861088b9ee64a75d01f5d", + "size": 12902, + "subdir": "linux-64", + "timestamp": 1659884223661, + "version": "2.3.3" + }, + "airflow-with-sentry-2.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "blinker >=1.1", + "python >=3.10,<3.11.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "md5": "c087d6ca0c1f6fb3b69e3271cf047113", + "name": "airflow-with-sentry", + "sha256": "b8ccb422653ce1f9b7983389b2b540f563065fdd35130d866bffae6ad557672c", + "size": 12905, + "subdir": "linux-64", + "timestamp": 1659935163323, + "version": "2.3.3" + }, + "airflow-with-sentry-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "blinker >=1.1", + "python >=3.7,<3.8.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "md5": "d1f1dc6af3b017fb08255afc1d3ad5f8", + "name": "airflow-with-sentry", + "sha256": "5aa91f7bb453ff33e5b3a526099a4c6cf0d8d97f16c987611ab2dabcf1ec39e6", + "size": 12877, + "subdir": "linux-64", + "timestamp": 1659884206856, + "version": "2.3.3" + }, + "airflow-with-sentry-2.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "blinker >=1.1", + "python >=3.7,<3.8.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "md5": "25e0accf18deaa712fc94a61ab244bfc", + "name": "airflow-with-sentry", + "sha256": "7121e74f2f2597e334e8a28f75c39d457ac4c07a9a2b435e5d5caeb41b87a975", + "size": 12881, + "subdir": "linux-64", + "timestamp": 1659935151861, + "version": "2.3.3" + }, + "airflow-with-sentry-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "blinker >=1.1", + "python >=3.8,<3.9.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "md5": "019d9e98331ca5526708d967359cb4f9", + "name": "airflow-with-sentry", + "sha256": "f153be1c084498264c0edda4e8cd2579b7402b086368004945ac4457c1d8cc6c", + "size": 12879, + "subdir": "linux-64", + "timestamp": 1659884212293, + "version": "2.3.3" + }, + "airflow-with-sentry-2.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "blinker >=1.1", + "python >=3.8,<3.9.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "md5": "f82955cdcc40dc489c777c442d115146", + "name": "airflow-with-sentry", + "sha256": "8ce75ba6e65d34e2768b6d77f18d4da53d4fa8943a184fe385b1da74df9fa780", + "size": 12878, + "subdir": "linux-64", + "timestamp": 1659935168816, + "version": "2.3.3" + }, + "airflow-with-sentry-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "blinker >=1.1", + "python >=3.9,<3.10.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "md5": "e7b8ed9adb9246ae13b61657b96a6c24", + "name": "airflow-with-sentry", + "sha256": "93ea20ddb22310358a8f4bece48e70deee3f057645411c301c912fdc27ee41ae", + "size": 12887, + "subdir": "linux-64", + "timestamp": 1659884217909, + "version": "2.3.3" + }, + "airflow-with-sentry-2.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "blinker >=1.1", + "python >=3.9,<3.10.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "md5": "3f82a7f1189ddd20cb100240904c5f58", + "name": "airflow-with-sentry", + "sha256": "ffc4eb6f34b740c0b6e4c1d2f49b6483b90cf1bb43638ae87bde26372f2bae70", + "size": 12877, + "subdir": "linux-64", + "timestamp": 1659935157485, + "version": "2.3.3" + }, + "airflow-with-sentry-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "blinker >=1.1", + "python >=3.10,<3.11.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1ed62d5a633643c6d44a262b4733c4ae", + "name": "airflow-with-sentry", + "sha256": "1c2daa4a7f6777ba3dc684d41b0286fd8de49b52e8ab18b4ffbd80d85f3e4f45", + "size": 13561, + "subdir": "linux-64", + "timestamp": 1671227356840, + "version": "2.4.3" + }, + "airflow-with-sentry-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "blinker >=1.1", + "python >=3.7,<3.8.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8d66165d0e31595a213f98892d30d0ba", + "name": "airflow-with-sentry", + "sha256": "2c42b9a4c60f028e37281d21b759ec80a328f30f3596ba612d28ee4049950a6f", + "size": 13531, + "subdir": "linux-64", + "timestamp": 1671227345179, + "version": "2.4.3" + }, + "airflow-with-sentry-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "blinker >=1.1", + "python >=3.8,<3.9.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e76f64467a3e70201b7f75be9da136ab", + "name": "airflow-with-sentry", + "sha256": "348b57d025753187a2759a4b1a54e357e861e0cac413b1a990b6625c3ce573fe", + "size": 13531, + "subdir": "linux-64", + "timestamp": 1671227362496, + "version": "2.4.3" + }, + "airflow-with-sentry-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "blinker >=1.1", + "python >=3.9,<3.10.0a0", + "sentry-sdk >=0.8.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b8c3b922520068e8f824312bc3544658", + "name": "airflow-with-sentry", + "sha256": "d82bb8c01fc6e0e1599a6048fff96a10efceb9b3d0a0e463f165bcada46d456e", + "size": 13536, + "subdir": "linux-64", + "timestamp": 1671227351013, + "version": "2.4.3" + }, + "airflow-with-slack-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "slackclient >=1.0.0,<2.0.0" + ], + "license": "Apache 2.0", + "md5": "e584a7e0eff49820a0489302607ce163", + "name": "airflow-with-slack", + "sha256": "089bd5cf227ab0011ebe75b77832ba9514a3d89bae4c56b93c101f4b87cb5135", + "size": 20283, + "subdir": "linux-64", + "timestamp": 1605878155985, + "version": "1.10.12" + }, + "airflow-with-slack-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "slackclient >=1.0.0,<2.0.0" + ], + "license": "Apache 2.0", + "md5": "fe5626c1fefeca29182acec188ce35fd", + "name": "airflow-with-slack", + "sha256": "6e14defaaa8c24046861d37c47da131f3118a56e0281352760d5267d9f4e502a", + "size": 18497, + "subdir": "linux-64", + "timestamp": 1579721428904, + "version": "1.10.7" + }, + "airflow-with-ssh-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "paramiko >=2.1.1", + "pysftp >=0.2.9", + "sshtunnel >=0.1.4,<0.2" + ], + "license": "Apache 2.0", + "md5": "71374e032e4be53d9e9fdc5fb3ed9052", + "name": "airflow-with-ssh", + "sha256": "001a7f0044ffd2f641b2eb915f05ba3af6936efc57687ebfb3a74eb2082db008", + "size": 20278, + "subdir": "linux-64", + "timestamp": 1605878157136, + "version": "1.10.12" + }, + "airflow-with-ssh-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "paramiko >=2.1.1", + "pysftp >=0.2.9", + "sshtunnel >=0.1.4,<0.2" + ], + "license": "Apache 2.0", + "md5": "7d205525ff922ff6e4ddebfc09248961", + "name": "airflow-with-ssh", + "sha256": "82aad4f757b9e4e9ea09fbcdb3d975cb5e5db6fc9cd36472c9d4b7a14283343d", + "size": 18494, + "subdir": "linux-64", + "timestamp": 1579721430759, + "version": "1.10.7" + }, + "airflow-with-statsd-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "statsd >=3.3.0,<4.0" + ], + "license": "Apache 2.0", + "md5": "a624672c7992267ad33c61807369419b", + "name": "airflow-with-statsd", + "sha256": "681b7c7d219ff6a8a919a59f0249f87ed5053cc5f6a2aa85e62647174868a79b", + "size": 20283, + "subdir": "linux-64", + "timestamp": 1605878158174, + "version": "1.10.12" + }, + "airflow-with-statsd-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "statsd >=3.3.0,<4.0" + ], + "license": "Apache 2.0", + "md5": "0829eb65fdda4da6bd3a252314395afb", + "name": "airflow-with-statsd", + "sha256": "b721c3c1bdcbeb2d75c38e130b4f66c38982bcf7dfddcc2e471bc1700c09e66d", + "size": 18509, + "subdir": "linux-64", + "timestamp": 1579721432593, + "version": "1.10.7" + }, + "airflow-with-statsd-2.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.10,<3.11.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "md5": "4a1d17811dc5dd854150223cf561c32e", + "name": "airflow-with-statsd", + "sha256": "995d705e2655d436f4dae18996f94e2d2caad9b684277d7c61987f739f0649ec", + "size": 12891, + "subdir": "linux-64", + "timestamp": 1659884245843, + "version": "2.3.3" + }, + "airflow-with-statsd-2.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.10,<3.11.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "md5": "cc50aea33bf8f12abca033b90628cf57", + "name": "airflow-with-statsd", + "sha256": "2c34a38a344a6bcdda379972e303fb13954402341a40b7cc66b64751b3050cc3", + "size": 12883, + "subdir": "linux-64", + "timestamp": 1659935185681, + "version": "2.3.3" + }, + "airflow-with-statsd-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.7,<3.8.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "md5": "345c50b4deb3843c4842ae9fc68fa0a8", + "name": "airflow-with-statsd", + "sha256": "4c888e79d456e68d9c0e20f119ccedfd1a4da8b11aa5095d217000a23c026878", + "size": 12858, + "subdir": "linux-64", + "timestamp": 1659884229041, + "version": "2.3.3" + }, + "airflow-with-statsd-2.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.7,<3.8.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "md5": "503b2916d77fc42a54e569db0294ad15", + "name": "airflow-with-statsd", + "sha256": "b74fdc9b235bad23fa9e0e149b2093bc0404114bc22f777f122ae3938897a01c", + "size": 12861, + "subdir": "linux-64", + "timestamp": 1659935174309, + "version": "2.3.3" + }, + "airflow-with-statsd-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.8,<3.9.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "md5": "d40a6ab78b8f534af8260c00ca71e9cc", + "name": "airflow-with-statsd", + "sha256": "1e556986056453200f9ccb6edad010521780b55af3153ace3cc56ee1d9961a71", + "size": 12859, + "subdir": "linux-64", + "timestamp": 1659884234445, + "version": "2.3.3" + }, + "airflow-with-statsd-2.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.8,<3.9.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "md5": "da317cc1a7957b8fc469592ac93c14d4", + "name": "airflow-with-statsd", + "sha256": "d0f287f702c1e63b1568270d69455c207ff6eb5d9897a8c492d0889eed630280", + "size": 12858, + "subdir": "linux-64", + "timestamp": 1659935191152, + "version": "2.3.3" + }, + "airflow-with-statsd-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.9,<3.10.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "md5": "bdd62c032b03d98a144a0706349ae159", + "name": "airflow-with-statsd", + "sha256": "ab2055b138beb4a875d9f9295b5a0bc982a79d188156d80c0605dfa655ccae64", + "size": 12857, + "subdir": "linux-64", + "timestamp": 1659884240076, + "version": "2.3.3" + }, + "airflow-with-statsd-2.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.9,<3.10.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "md5": "90266a51b0d540d3da38d04f975eb6b5", + "name": "airflow-with-statsd", + "sha256": "a286fddb71f5756fd89d7e8323d257c0204c503a3ee1ffbca0290cbddd8fca5d", + "size": 12866, + "subdir": "linux-64", + "timestamp": 1659935179962, + "version": "2.3.3" + }, + "airflow-with-statsd-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.10,<3.11.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ad6b8da77c739d87697f27c8a05e3e67", + "name": "airflow-with-statsd", + "sha256": "3749afdc96b70559d46a20190fe96bbedbf6d0526456b886c37316024b6e6767", + "size": 13528, + "subdir": "linux-64", + "timestamp": 1671227379788, + "version": "2.4.3" + }, + "airflow-with-statsd-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.7,<3.8.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "38532d909a3636ae510ee2da82db0578", + "name": "airflow-with-statsd", + "sha256": "0cc12b359cf1f5c912057ea995726f4348852d5a5b57fa06330077f6ffd61a23", + "size": 13507, + "subdir": "linux-64", + "timestamp": 1671227368108, + "version": "2.4.3" + }, + "airflow-with-statsd-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.8,<3.9.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1edfe6ad3cca461ddc532dc3052175a4", + "name": "airflow-with-statsd", + "sha256": "de89df226f3cb97e849b02805aaaee2ddefac227ca22c7b145e9485b8b689365", + "size": 13507, + "subdir": "linux-64", + "timestamp": 1671227385459, + "version": "2.4.3" + }, + "airflow-with-statsd-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.9,<3.10.0a0", + "statsd >=3.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4a179f8232af5ee6862c263a4ae72ea5", + "name": "airflow-with-statsd", + "sha256": "5c64b64e4eaeadc7036e4f3bb0f0f38b8218924ff44c464d7b2b2e851a8d2be5", + "size": 13514, + "subdir": "linux-64", + "timestamp": 1671227373913, + "version": "2.4.3" + }, + "airflow-with-vertica-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "vertica-python >=0.5.1" + ], + "license": "Apache 2.0", + "md5": "511d43c9fedf95d75f00c1869e81a744", + "name": "airflow-with-vertica", + "sha256": "453460a4243642ec93b940c15bc03322cc5c81ae619daeb062180405068ac415", + "size": 20291, + "subdir": "linux-64", + "timestamp": 1605878159206, + "version": "1.10.12" + }, + "airflow-with-vertica-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "vertica-python >=0.5.1" + ], + "license": "Apache 2.0", + "md5": "3cf7434e95b4dd7353c7ca7bf908559b", + "name": "airflow-with-vertica", + "sha256": "733e4ea532b71f4d9ea473b4300d71ec20e4d7e889415a9f90181623b7f5ee76", + "size": 18503, + "subdir": "linux-64", + "timestamp": 1579721434275, + "version": "1.10.7" + }, + "airflow-with-virtualenv-2.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.10,<3.11.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "md5": "3561b87424d711e935b2109ef2b9fb82", + "name": "airflow-with-virtualenv", + "sha256": "98e614789d43ca2a7064aa8a5fbeb0a6dd71cc7b242fd0cc7298673419413cf7", + "size": 12897, + "subdir": "linux-64", + "timestamp": 1659884268023, + "version": "2.3.3" + }, + "airflow-with-virtualenv-2.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.10,<3.11.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "md5": "024a1fc17ad596c5fa67f328830920fc", + "name": "airflow-with-virtualenv", + "sha256": "032c6d2f512b0ceb0ce5f1ede630c71ed0657363c3d147ec11d9ce724878ad68", + "size": 12907, + "subdir": "linux-64", + "timestamp": 1659935207997, + "version": "2.3.3" + }, + "airflow-with-virtualenv-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.7,<3.8.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "md5": "873dd380a398582922807624933b51ad", + "name": "airflow-with-virtualenv", + "sha256": "ed784d0fcd9c3f6b0752746dfe5df069faada218cb7be7ef743df66143724dc4", + "size": 12872, + "subdir": "linux-64", + "timestamp": 1659884251255, + "version": "2.3.3" + }, + "airflow-with-virtualenv-2.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.7,<3.8.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "md5": "add84c9c2b08eb6ca43ecf76414b0858", + "name": "airflow-with-virtualenv", + "sha256": "862ac2f291a7718375792706f9a23c68b9e36c1c61caecc7a26e8c87b17dfaf2", + "size": 12876, + "subdir": "linux-64", + "timestamp": 1659935196533, + "version": "2.3.3" + }, + "airflow-with-virtualenv-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.8,<3.9.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "md5": "859f2016c59219199d98e5ce8c5b7679", + "name": "airflow-with-virtualenv", + "sha256": "cb24c7fc4c5e999da5f0ce1b964d98835ab2026a6d509df092b77dae7b58bfca", + "size": 12873, + "subdir": "linux-64", + "timestamp": 1659884256732, + "version": "2.3.3" + }, + "airflow-with-virtualenv-2.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.8,<3.9.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "md5": "f2faae7c0161f7a8740ca2857fdbedc6", + "name": "airflow-with-virtualenv", + "sha256": "f410be209e2e615881eb8cfe63abab9d7c52f8425f8f736f1e85d5d04ea34cb1", + "size": 12877, + "subdir": "linux-64", + "timestamp": 1659935213486, + "version": "2.3.3" + }, + "airflow-with-virtualenv-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.9,<3.10.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "md5": "e837b4b2bd46c41c9a53f73751821c68", + "name": "airflow-with-virtualenv", + "sha256": "e4d126ab752fd2b331c44c8a32bf10b3fb5f91a72382c9466a23367d643c724e", + "size": 12868, + "subdir": "linux-64", + "timestamp": 1659884262225, + "version": "2.3.3" + }, + "airflow-with-virtualenv-2.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.9,<3.10.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "md5": "df840c3548f3941189d8ab135aa44162", + "name": "airflow-with-virtualenv", + "sha256": "47da2e16a085d9d29f4673450cea010b586b15e2b63e5531d14cc249be3f8fad", + "size": 12870, + "subdir": "linux-64", + "timestamp": 1659935202231, + "version": "2.3.3" + }, + "airflow-with-virtualenv-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.10,<3.11.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3a21b6dd01f88a2d93f18c70b1f6f463", + "name": "airflow-with-virtualenv", + "sha256": "c949bafe0ccd4ea48fbfbd696bedaa4357811dfe712e136e39b9be49d7410b89", + "size": 13546, + "subdir": "linux-64", + "timestamp": 1671227402954, + "version": "2.4.3" + }, + "airflow-with-virtualenv-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.7,<3.8.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "341f31f527bd9034e78a7ce6ab73630b", + "name": "airflow-with-virtualenv", + "sha256": "2b1d08fd669ba3b927e1ed187693c05be227aa3dcb6a1f6982e45906201fe96c", + "size": 13520, + "subdir": "linux-64", + "timestamp": 1671227391105, + "version": "2.4.3" + }, + "airflow-with-virtualenv-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.8,<3.9.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6b53d4137ee77fdff3d65370bb9ac3c3", + "name": "airflow-with-virtualenv", + "sha256": "4bc6917525b610333fd6b13a230f44e8f87ed9b9ea97497eafd7788c35c1a1b5", + "size": 13521, + "subdir": "linux-64", + "timestamp": 1671227408471, + "version": "2.4.3" + }, + "airflow-with-virtualenv-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.9,<3.10.0a0", + "virtualenv" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3c2ba333c864ad73a915fbfa9daff165", + "name": "airflow-with-virtualenv", + "sha256": "b110e8fb64a637a6a281482b0787e3f3726ffd7ac390a58c5fa7b17d53c29346", + "size": 13529, + "subdir": "linux-64", + "timestamp": 1671227396958, + "version": "2.4.3" + }, + "airflow-with-webhdfs-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "python-hdfs >=0.5.1" + ], + "license": "Apache 2.0", + "md5": "56e47754b4ddc56ef440e83fa4b83372", + "name": "airflow-with-webhdfs", + "sha256": "6c76e2574c1c187e0c4ec0c2f897f25f794fb50eb14e04f5b9d8a0d8c58a84ee", + "size": 20298, + "subdir": "linux-64", + "timestamp": 1605878160246, + "version": "1.10.12" + }, + "airflow-with-webhdfs-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "python-hdfs >=0.5.1" + ], + "license": "Apache 2.0", + "md5": "aaf197c997edb4674700bd97ae430741", + "name": "airflow-with-webhdfs", + "sha256": "d461804538096880c21844357b20e617043183f4e2e7ffa49da9682490a7e25b", + "size": 18509, + "subdir": "linux-64", + "timestamp": 1579721436174, + "version": "1.10.7" + }, + "airflow-with-winrm-1.10.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=1.10.12,<1.10.13.0a0", + "pywinrm >=0.4.0,<0.5.0" + ], + "license": "Apache 2.0", + "md5": "eac9a53e9c1dcc47b104e27850f28599", + "name": "airflow-with-winrm", + "sha256": "a7ef4148cdb9f39301b105f854d26b3b8854eee743f3825e7e032acdbd204a8f", + "size": 20284, + "subdir": "linux-64", + "timestamp": 1605878161291, + "version": "1.10.12" + }, + "airflow-with-winrm-1.10.7-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "airflow >=1.10.7,<1.10.8.0a0", + "pywinrm >=0.4.0,<0.5.0" + ], + "license": "Apache 2.0", + "md5": "616003339aca834f878aea228e819066", + "name": "airflow-with-winrm", + "sha256": "9a1a48da3a60c688b7f1ee75d84f59649c45ae6b02f6f949c36c941ee6a0f55e", + "size": 18503, + "subdir": "linux-64", + "timestamp": 1579721437899, + "version": "1.10.7" + }, + "alabaster-0.7.10-py27he5a193a_0.conda": { + "build": "py27he5a193a_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f6105796a4174bd7f86940da86490d1d", + "name": "alabaster", + "sha256": "fcdaf6bacc220a67b29f3907a572e8728fa842617723b0a6735f891d722d6358", + "size": 15359, + "subdir": "linux-64", + "timestamp": 1505691153490, + "version": "0.7.10" + }, + "alabaster-0.7.10-py35h6fb19ab_0.conda": { + "build": "py35h6fb19ab_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1146e1388ec0f2e008af73893c52be93", + "name": "alabaster", + "sha256": "c3c8b36f32a6e1949ee0bee5e7e744bad312e1cdaef8e09dccf8c0335c357c54", + "size": 15456, + "subdir": "linux-64", + "timestamp": 1505691164612, + "version": "0.7.10" + }, + "alabaster-0.7.10-py36h306e16b_0.conda": { + "build": "py36h306e16b_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2eaa5307473a0751cec512ca401e9144", + "name": "alabaster", + "sha256": "d00b0d702881fcf9ab8da21e13a6d908a8971069fd17eb563b4221b5befdbee0", + "size": 15390, + "subdir": "linux-64", + "timestamp": 1505691175753, + "version": "0.7.10" + }, + "alabaster-0.7.11-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "92d12d41d10312bcafe412d79c03084f", + "name": "alabaster", + "sha256": "4d10b21f89d45b3e91ab77eb5aac17457f3a468bd952ad4cd7c446bc9644bab4", + "size": 17827, + "subdir": "linux-64", + "timestamp": 1529940183940, + "version": "0.7.11" + }, + "alabaster-0.7.11-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8302f404eaed3d558aa70b2c522d8702", + "name": "alabaster", + "sha256": "c6c31ede2a05dbf41b4ff3648003f60668e5aecbe1aaab0429befd2423672526", + "size": 17968, + "subdir": "linux-64", + "timestamp": 1529940257160, + "version": "0.7.11" + }, + "alabaster-0.7.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dd13a908c5ea77e6c46111f2c0545b75", + "name": "alabaster", + "sha256": "86971b1d76f0421d484db623a791dae9ed645c8eef1e8bb217dc5ee14743e90f", + "size": 17937, + "subdir": "linux-64", + "timestamp": 1529940165125, + "version": "0.7.11" + }, + "alabaster-0.7.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "31fc979607c09a9070178d151a68a0a5", + "name": "alabaster", + "sha256": "5c43690c3e0b6b7465ec91fcd4eb1ff44e31150c7981567e4afd080ca73a8d91", + "size": 17853, + "subdir": "linux-64", + "timestamp": 1530695334007, + "version": "0.7.11" + }, + "alabaster-0.7.12-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c3269798f9218d94c77828349b32d81c", + "name": "alabaster", + "sha256": "bf4fe3bd0692e3393fbf1c2c91816804055cefe9524beadae7b5603452cc84d0", + "size": 18388, + "subdir": "linux-64", + "timestamp": 1539023474930, + "version": "0.7.12" + }, + "alabaster-0.7.12-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "403838f334aec1c0ec8190fba0bf7570", + "name": "alabaster", + "sha256": "d006d4e0a8d736fff1dc2ed199153aba97de256d58ee7c3a5d82cebfaaed40a6", + "size": 18440, + "subdir": "linux-64", + "timestamp": 1539023484485, + "version": "0.7.12" + }, + "alabaster-0.7.12-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9c4a38dfb2328c1a74d64cd07879e232", + "name": "alabaster", + "sha256": "918b7300825c1e443066c141f439caaa866dda563342e14e553cd7d2f4758e2d", + "size": 18388, + "subdir": "linux-64", + "timestamp": 1539023442571, + "version": "0.7.12" + }, + "alembic-0.9.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7d4c34d2db2f502e6c7fe1b7305213dc", + "name": "alembic", + "sha256": "729c1cebe9711cedb3fd27c061209421e968f97243b3d8f5c708df57bba21531", + "size": 224718, + "subdir": "linux-64", + "timestamp": 1530593104099, + "version": "0.9.10" + }, + "alembic-0.9.10-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca3a5783da57db5059821c2f8750ebed", + "name": "alembic", + "sha256": "842c728e9de63d9a45d886dc4aec4c725aaa841d772cbc9626a7cdf6e62d99cd", + "size": 226913, + "subdir": "linux-64", + "timestamp": 1530593136543, + "version": "0.9.10" + }, + "alembic-0.9.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66d03b2043cacd853c3869b596b54711", + "name": "alembic", + "sha256": "802a6d2e49e0d2e045f9d359d3f6bc19c777e8d98fe12ffeecce60319fafc899", + "size": 224813, + "subdir": "linux-64", + "timestamp": 1530593124216, + "version": "0.9.10" + }, + "alembic-0.9.10-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "76dd740c8a2e556ee2543c2dd0db6f58", + "name": "alembic", + "sha256": "3f356522a13c4126a720fc3c88cb97824d7b1986502de7d828f4829e1cb6b437", + "size": 227949, + "subdir": "linux-64", + "timestamp": 1530737144841, + "version": "0.9.10" + }, + "alembic-0.9.5-py27h0668a64_0.conda": { + "build": "py27h0668a64_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa7be82e06e6319651b626f6cae88aaf", + "name": "alembic", + "sha256": "edd6c22232ebceffb1887768f5b99d13e0b42673c778c060d4f64fe806eb639d", + "size": 216257, + "subdir": "linux-64", + "timestamp": 1505691467247, + "version": "0.9.5" + }, + "alembic-0.9.5-py35h387e2dd_0.conda": { + "build": "py35h387e2dd_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a3b53468c1a58fe0419cea2042172b7", + "name": "alembic", + "sha256": "d3799b7f85692128ac13e91f7c7942c9082330593a84652b2d74850bc0116413", + "size": 224111, + "subdir": "linux-64", + "timestamp": 1505691483011, + "version": "0.9.5" + }, + "alembic-0.9.5-py36h968a0d3_0.conda": { + "build": "py36h968a0d3_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3dd18f2cf1a2ef281cbdb6030b405c9f", + "name": "alembic", + "sha256": "9a0a32536422c86dc09b9432ba310168f0f95ad8e06dc8a3dfd6d33e14675e10", + "size": 221847, + "subdir": "linux-64", + "timestamp": 1505691499009, + "version": "0.9.5" + }, + "alembic-0.9.6-py27he2127cc_0.conda": { + "build": "py27he2127cc_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1875c5ba38b1f4bce5718936d753d588", + "name": "alembic", + "sha256": "2553bdd2c7121554210df9d11c413e780ab57d9b3182934d726165583f3e20ff", + "size": 223099, + "subdir": "linux-64", + "timestamp": 1511837739079, + "version": "0.9.6" + }, + "alembic-0.9.6-py35h2ca1cdd_0.conda": { + "build": "py35h2ca1cdd_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2548abf8ef9c0ce9682239ccfefc5859", + "name": "alembic", + "sha256": "d2e87996d017d6a3ad66f6118f5906d07ed601f45ceb734ff033af57a121bb5a", + "size": 228424, + "subdir": "linux-64", + "timestamp": 1511837777294, + "version": "0.9.6" + }, + "alembic-0.9.6-py36h01b5dd9_0.conda": { + "build": "py36h01b5dd9_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "36391006d826a92021ecddd7097daafd", + "name": "alembic", + "sha256": "0c8edd95ab14669cf003c7f902544ab9192b2a9fa455030fb5efecf2a69015c9", + "size": 226342, + "subdir": "linux-64", + "timestamp": 1511837776582, + "version": "0.9.6" + }, + "alembic-0.9.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad5a674ded791f1cbf8655cd94540b39", + "name": "alembic", + "sha256": "f2e4bd872ca609f8d2a63c6791771fcd4b22dd66a5396f2221484e4830f8dd58", + "size": 221792, + "subdir": "linux-64", + "timestamp": 1522084443633, + "version": "0.9.9" + }, + "alembic-0.9.9-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c39c9b40ef3170dbb01485f3b462b9b", + "name": "alembic", + "sha256": "bf5227f0dbc51fabd848dcc0a2db99f0e8ef4158e63fc41ca48e63df8f042e00", + "size": 226705, + "subdir": "linux-64", + "timestamp": 1522084331091, + "version": "0.9.9" + }, + "alembic-0.9.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.7.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "26ce7d79d3d2623c4a8a2d61651d90ea", + "name": "alembic", + "sha256": "665123568f6b4254f304c9fb68ef9bdc5662bbb610a1e38ec3ee4d21b4063e7c", + "size": 227601, + "subdir": "linux-64", + "timestamp": 1522084467176, + "version": "0.9.9" + }, + "alembic-1.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3cb568e6a0d71de6397a94c4db534c13", + "name": "alembic", + "sha256": "37273c14750d37071d146235fe1d35813003d2fbebd4d75db28fcf129802801f", + "size": 221143, + "subdir": "linux-64", + "timestamp": 1535498805316, + "version": "1.0.0" + }, + "alembic-1.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd23f39f7703f28b2ad4b6340b14b85b", + "name": "alembic", + "sha256": "7e12f535e15117591b872677cc8ef0b8313f6322b9137119572920af3bbfb398", + "size": 228971, + "subdir": "linux-64", + "timestamp": 1535498819562, + "version": "1.0.0" + }, + "alembic-1.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c75e3e3e83275ef206388d1cdbdb6aed", + "name": "alembic", + "sha256": "ed25ce10f6beece92793b08d96d01c432d00750de96c5a4d66ee75f700571f10", + "size": 226623, + "subdir": "linux-64", + "timestamp": 1535498792032, + "version": "1.0.0" + }, + "alembic-1.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6bc1ff0fda37874a050a9dec76454cdb", + "name": "alembic", + "sha256": "8694a5a0ce20996526f448e5a1bc954793c6e49dcb66567f0f845b2a0e672336", + "size": 227244, + "subdir": "linux-64", + "timestamp": 1535498827972, + "version": "1.0.0" + }, + "alembic-1.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9173ccb11a322b1f1da718739c4f6261", + "name": "alembic", + "sha256": "d0963dd9c783943837937f7f356e369280239da8ea9178d43c9b1dfe6538bc11", + "size": 221465, + "subdir": "linux-64", + "timestamp": 1540955663531, + "version": "1.0.1" + }, + "alembic-1.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1bfffce80ea353a4bb3eaa56ec154094", + "name": "alembic", + "sha256": "b5c0ad8596261db58d4b1d37c4bba2a15eb514122d33f544f4f3522f4536baa9", + "size": 224348, + "subdir": "linux-64", + "timestamp": 1540955741397, + "version": "1.0.1" + }, + "alembic-1.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f837a8863a418dcb7f6078f9f928671", + "name": "alembic", + "sha256": "3abbda00d24201d537d5c1fa8048a06579a442105351e3516be2c752a9e244ab", + "size": 227391, + "subdir": "linux-64", + "timestamp": 1540955723847, + "version": "1.0.1" + }, + "alembic-1.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bbd56dc15d5dacdff84bd3f046137427", + "name": "alembic", + "sha256": "7537523fe7d06b5b375b366663e75f19457bff932ff1d05e909f4df87c7e9f17", + "size": 224550, + "subdir": "linux-64", + "timestamp": 1541134517150, + "version": "1.0.2" + }, + "alembic-1.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c7bce30601cd0e5353bbd4bde2517a8", + "name": "alembic", + "sha256": "226ca11e7754bc6ae12049e8f77600b8b0fde7b280d94a84deb567b3434070a4", + "size": 227310, + "subdir": "linux-64", + "timestamp": 1541134545219, + "version": "1.0.2" + }, + "alembic-1.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f9934cb6398275337dc475629ce8bcb", + "name": "alembic", + "sha256": "a5eb7a157b82384b4800a5228ff7cae5080909edec3d3b7c9c2f5122a5746335", + "size": 224919, + "subdir": "linux-64", + "timestamp": 1541134511613, + "version": "1.0.2" + }, + "alembic-1.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0e643a89cdceb747de1dee9ce23327f5", + "name": "alembic", + "sha256": "07c3b3cca6a2b016141e7697dd0cc63c9d792d80c8f1b658c011bfb8c41171cc", + "size": 224577, + "subdir": "linux-64", + "timestamp": 1542384908984, + "version": "1.0.3" + }, + "alembic-1.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "25f67ea3544695c7c2ac725e93e4240d", + "name": "alembic", + "sha256": "2259a0fbbb8423c793520dfef88b9944e528599d39e4995b6e62599c52708483", + "size": 227248, + "subdir": "linux-64", + "timestamp": 1542384929872, + "version": "1.0.3" + }, + "alembic-1.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "20dcaced8a31ea5b3f1e03e084d50ed6", + "name": "alembic", + "sha256": "7a5002169c4a58130986d74c35efbccd946dedcdf4fff842159fdb24b2a91fe8", + "size": 227660, + "subdir": "linux-64", + "timestamp": 1542385021150, + "version": "1.0.3" + }, + "alembic-1.0.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b539db436d989066a1cf89450e135587", + "name": "alembic", + "sha256": "380d79a3d56be8e68012bbc79d70dc8399b6171e2e4520b724fa92d6b4eddd73", + "size": 228549, + "subdir": "linux-64", + "timestamp": 1543447473746, + "version": "1.0.5" + }, + "alembic-1.0.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c35b25040079dc672b64a6ef5c1022c", + "name": "alembic", + "sha256": "0aee12fe1e379bccd9bcad0a0dcd19518575876770d22d908fc0a089abdf6669", + "size": 231418, + "subdir": "linux-64", + "timestamp": 1543447486330, + "version": "1.0.5" + }, + "alembic-1.0.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "311677e3fd6ecc808428a32e771fca07", + "name": "alembic", + "sha256": "3b50aefdc28463b774d0fa3564586acd8f58cb6e02a368cd37c4eee532426394", + "size": 231790, + "subdir": "linux-64", + "timestamp": 1543447469664, + "version": "1.0.5" + }, + "alembic-1.0.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e9fe489c8a6df211e5743ef351901af", + "name": "alembic", + "sha256": "22f150e10bfaadf2837bc69756c1f16a224970b93bbc945e217e5e0444d38114", + "size": 229939, + "subdir": "linux-64", + "timestamp": 1547746784785, + "version": "1.0.6" + }, + "alembic-1.0.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96008e1d829b39eab06ff46772426453", + "name": "alembic", + "sha256": "fed91ba28be7f15082b2901c9d44ad8835f717016cdea55febb0bd03d80bb844", + "size": 235932, + "subdir": "linux-64", + "timestamp": 1547746879191, + "version": "1.0.6" + }, + "alembic-1.0.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "598a96a9ebf27bd02259b4906a57d558", + "name": "alembic", + "sha256": "7d721741c8e3a8bb080f4ec0743b2fa2c2579f40939408b56b178b8e7ab514d4", + "size": 233401, + "subdir": "linux-64", + "timestamp": 1547746844533, + "version": "1.0.6" + }, + "alembic-1.0.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d174e79e8e875bb9fd2d3a9195159f31", + "name": "alembic", + "sha256": "d7b1583a0607f64d7051c079a8956f3dd24ddbe8efb2942b551a81464be48638", + "size": 232813, + "subdir": "linux-64", + "timestamp": 1550266237506, + "version": "1.0.7" + }, + "alembic-1.0.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d0a43a28debb86ee6f638fca3588a65", + "name": "alembic", + "sha256": "6d4004a639d862ec3d77984464e419b05a36d30d2cc8e7c3c0857a53a1a40385", + "size": 233113, + "subdir": "linux-64", + "timestamp": 1550266249719, + "version": "1.0.7" + }, + "alembic-1.0.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90388854b6b3b6fc03c3495cf3056278", + "name": "alembic", + "sha256": "99ca411a699f5045bad38796f26b725871d068217031574139b56e0357bd8a3d", + "size": 236449, + "subdir": "linux-64", + "timestamp": 1550266171298, + "version": "1.0.7" + }, + "alembic-1.0.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7dd3ad6d0d4b3b06009abc1fd605b171", + "name": "alembic", + "sha256": "b8fb2e3c8669e2b72eb5bf9bcc4b56205104259c866683f224831466c89cd2b0", + "size": 233707, + "subdir": "linux-64", + "timestamp": 1556061898947, + "version": "1.0.9" + }, + "alembic-1.0.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e415c56dd90a085ec95928e253baabe", + "name": "alembic", + "sha256": "676bf50e188016d2910935a9311fd5d973c39c44da59e5e4c919b7c2f92a778a", + "size": 239924, + "subdir": "linux-64", + "timestamp": 1556061765476, + "version": "1.0.9" + }, + "alembic-1.0.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-editor >=0.3", + "sqlalchemy >=0.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "099e71e9788910853a2e8f40bd4739cc", + "name": "alembic", + "sha256": "c5c4a8e9509fb419eb2e0305e616ae1e5ebf61f8696183f745f8bebafd33e59b", + "size": 240035, + "subdir": "linux-64", + "timestamp": 1556061885231, + "version": "1.0.9" + }, + "alembic-1.8.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "sqlalchemy >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6969f11b16ca3ce79ddc73bb847d2b10", + "name": "alembic", + "sha256": "8f33cf03998f746459a8929fce64ed389e2f69d210dd2bfca64358ba03bd1775", + "size": 298423, + "subdir": "linux-64", + "timestamp": 1666725262585, + "version": "1.8.1" + }, + "alembic-1.8.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.11,<3.12.0a0", + "python-dateutil", + "sqlalchemy >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b40e7fa2bfc9ebcaffee612e53d1208c", + "name": "alembic", + "sha256": "ea14c8269cb54900d73bcb37bd66568f9f7bb321e69b7265b4dc635a81a9f645", + "size": 388178, + "subdir": "linux-64", + "timestamp": 1676828949480, + "version": "1.8.1" + }, + "alembic-1.8.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "importlib_resources", + "mako", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "sqlalchemy >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb2d3394e83f9c75c59afea36bdb6c78", + "name": "alembic", + "sha256": "4e9f78cc4c2792ded5f854419c47de2cbff6eabc8228448c1e9701de0c33d604", + "size": 290383, + "subdir": "linux-64", + "timestamp": 1666725317651, + "version": "1.8.1" + }, + "alembic-1.8.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "importlib_resources", + "mako", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "sqlalchemy >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "36cfb052245e4aa721098590e36b891e", + "name": "alembic", + "sha256": "b7d1fd2af4308ba5aab782e0014408f10e593fcb783edd97e9c785a362c1cbec", + "size": 293999, + "subdir": "linux-64", + "timestamp": 1666725289571, + "version": "1.8.1" + }, + "alembic-1.8.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "mako", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "sqlalchemy >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f32e4247b8fb425c403d1e992414ea83", + "name": "alembic", + "sha256": "03aa8ba2559b1fa32a1cefd39319fcbe537c43e482220a59d5af89dcf3017be4", + "size": 293617, + "subdir": "linux-64", + "timestamp": 1666725345159, + "version": "1.8.1" + }, + "altair-3.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jinja2", + "jsonschema", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "six", + "toolz", + "typing >=3.6" + ], + "license": "BSD-3-Clause", + "md5": "f15ca128018dd7935204708ee9d17145", + "name": "altair", + "sha256": "a1d692e810854893bf741106d018ff855a418d72da4c99e8ef57871f88af0d3f", + "size": 766236, + "subdir": "linux-64", + "timestamp": 1567626337409, + "version": "3.2.0" + }, + "altair-3.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jinja2", + "jsonschema", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "six", + "toolz" + ], + "license": "BSD-3-Clause", + "md5": "9a9d6deb78af03013ea3ee83d77368e3", + "name": "altair", + "sha256": "e809ff5499c5cdc10d37aa53cbbeaf026542db992e6dea80758a199640dd0c5d", + "size": 770051, + "subdir": "linux-64", + "timestamp": 1567626343741, + "version": "3.2.0" + }, + "altair-3.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jinja2", + "jsonschema", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "six", + "toolz" + ], + "license": "BSD-3-Clause", + "md5": "e9a4aeac2afe106e1889022a991b2081", + "name": "altair", + "sha256": "d42704e0fb03430b495157638996db8a329711da9ef05d1997081c97eb4a6854", + "size": 770470, + "subdir": "linux-64", + "timestamp": 1567626396103, + "version": "3.2.0" + }, + "altair-3.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jinja2", + "jsonschema", + "numpy", + "pandas", + "python >=3.8,<3.9.0a0", + "six", + "toolz" + ], + "license": "BSD-3-Clause", + "md5": "70937e8bfdbf84c2ecaafa6f90145fe4", + "name": "altair", + "sha256": "191573790f50a076b4b5288560203c20ccf62a2a7c6bebd466f79251e284acaf", + "size": 611887, + "subdir": "linux-64", + "timestamp": 1574412817810, + "version": "3.2.0" + }, + "altgraph-0.17.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bf4c54e636de4bec80d68c79d245fcbc", + "name": "altgraph", + "sha256": "e11aebe59e941abe12226b7d47f79a4524aac54a38e94506dd6dfa9b13b72d55", + "size": 36458, + "subdir": "linux-64", + "timestamp": 1670426131517, + "version": "0.17.3" + }, + "altgraph-0.17.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dda981150bd6810e73e9fa015ac2b389", + "name": "altgraph", + "sha256": "cbbccae70a70630d3d62e4cdc88065118c22fad4e19f80a187ec9048f17f8703", + "size": 42909, + "subdir": "linux-64", + "timestamp": 1676828963834, + "version": "0.17.3" + }, + "altgraph-0.17.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a75c0cae42f50092cbbca1c8a57a4068", + "name": "altgraph", + "sha256": "dcf464c86a5bcda21c8544357531d3470e1a9f50605bad06abba41866d0cfa9d", + "size": 36284, + "subdir": "linux-64", + "timestamp": 1670426156483, + "version": "0.17.3" + }, + "altgraph-0.17.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4185fcd27886371823164e2b16d18bfc", + "name": "altgraph", + "sha256": "4462222b3ebca4169dd66a967db668a1f0b4be0d1f0bdc68d748887170746e9f", + "size": 36168, + "subdir": "linux-64", + "timestamp": 1670426180927, + "version": "0.17.3" + }, + "altgraph-0.17.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a53836fbc7af6f56638f31359bb41dc6", + "name": "altgraph", + "sha256": "efab0532859f29ca2daf0c1c666e4f20d5bf107f7f530ad0e7001f05ab2f0b10", + "size": 36176, + "subdir": "linux-64", + "timestamp": 1670426106548, + "version": "0.17.3" + }, + "ampl-mp-3.1.0-hf726d26_1005.conda": { + "build": "hf726d26_1005", + "build_number": 1005, + "depends": [ + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "HPND", + "md5": "8c5f36b0ca3ba5770b193fae1e382e6b", + "name": "ampl-mp", + "sha256": "48f167408fa1de307dbe6e8022444c7c037cfe361952c6ad23e6a130b63f8c12", + "size": 728796, + "subdir": "linux-64", + "timestamp": 1632752000990, + "version": "3.1.0" + }, + "anaconda-2018.12-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.12 py27_0", + "anaconda-client 1.7.2 py27_0", + "anaconda-project 0.8.2 py27_0", + "asn1crypto 0.24.0 py27_0", + "astroid 1.6.5 py27_0", + "astropy 2.0.9 py27hdd07704_0", + "atomicwrites 1.2.1 py27_0", + "attrs 18.2.0 py27h28b3542_0", + "babel 2.6.0 py27_0", + "backports 1.0 py27_1", + "backports.functools_lru_cache 1.5 py27_1", + "backports.os 0.1.1 py27_0", + "backports.shutil_get_terminal_size 1.0.0 py27_2", + "backports_abc 0.5 py27h7b3c97b_0", + "beautifulsoup4 4.6.3 py27_0", + "bitarray 0.8.3 py27h14c3975_0", + "bkcharts 0.2 py27h241ae91_0", + "blas 1.0 mkl", + "blaze 0.11.3 py27_0", + "bleach 3.0.2 py27_0", + "blosc 1.14.4 hdbcaa40_0", + "bokeh 1.0.2 py27_0", + "boto 2.49.0 py27_0", + "bottleneck 1.2.1 py27h035aef0_1", + "bzip2 1.0.6 h14c3975_5", + "ca-certificates 2018.03.07 0", + "cairo 1.14.12 h8948797_3", + "cdecimal 2.3 py27h14c3975_3", + "certifi 2018.11.29 py27_0", + "cffi 1.11.5 py27he75722e_1", + "chardet 3.0.4 py27_1", + "click 7.0 py27_0", + "cloudpickle 0.6.1 py27_0", + "clyent 1.2.2 py27_1", + "colorama 0.4.1 py27_0", + "configparser 3.5.0 py27h5117587_0", + "contextlib2 0.5.5 py27hbf4c468_0", + "cryptography 2.4.2 py27h1ba5d50_0", + "curl 7.63.0 hbc83047_1000", + "cycler 0.10.0 py27hc7354d3_0", + "cython 0.29.2 py27he6710b0_0", + "cytoolz 0.9.0.1 py27h14c3975_1", + "dask 1.0.0 py27_0", + "dask-core 1.0.0 py27_0", + "datashape 0.5.4 py27_1", + "dbus 1.13.2 h714fa37_1", + "decorator 4.3.0 py27_0", + "defusedxml 0.5.0 py27_1", + "distributed 1.25.1 py27_0", + "docutils 0.14 py27hae222c1_0", + "entrypoints 0.2.3 py27_2", + "enum34 1.1.6 py27_1", + "et_xmlfile 1.0.1 py27h75840f5_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.0.2 py27h14c3975_2", + "filelock 3.0.10 py27_0", + "flask 1.0.2 py27_1", + "flask-cors 3.0.7 py27_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "funcsigs 1.0.2 py27h83f16ab_0", + "functools32 3.2.3.2 py27_1", + "future 0.17.1 py27_0", + "futures 3.2.0 py27_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.3.7 py27h7b6447c_1", + "glib 2.56.2 hd408876_0", + "glob2 0.6 py27_1", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py27h10f8cd9_2", + "graphite2 1.3.12 h23475e2_2", + "greenlet 0.4.15 py27h7b6447c_0", + "grin 1.2.1 py27_4", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.8.0 py27h989c5e5_3", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.2 hba1933b_1", + "heapdict 1.0.0 py27_2", + "html5lib 1.0.1 py27_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py27_0", + "imageio 2.4.1 py27_0", + "imagesize 1.1.0 py27_0", + "importlib_metadata 0.6 py27_0", + "intel-openmp 2019.1 144", + "ipaddress 1.0.22 py27_0", + "ipykernel 4.10.0 py27_0", + "ipython 5.8.0 py27_0", + "ipython_genutils 0.2.0 py27h89fb69b_0", + "ipywidgets 7.4.2 py27_0", + "isort 4.3.4 py27_0", + "itsdangerous 1.1.0 py27_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4 py27_0", + "jedi 0.13.2 py27_0", + "jinja2 2.10 py27_0", + "jpeg 9b h024ee3a_2", + "jsonschema 2.6.0 py27h7ed5aa4_0", + "jupyter 1.0.0 py27_7", + "jupyter_client 5.2.4 py27_0", + "jupyter_console 5.2.0 py27_1", + "jupyter_core 4.4.0 py27_0", + "jupyterlab 0.33.11 py27_0", + "jupyterlab_launcher 0.11.2 py27h28b3542_0", + "kiwisolver 1.0.1 py27hf484d3e_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.3.1 py27h14c3975_2", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.63.0 h20c2e04_1000", + "libedit 3.1.20170329 h6b74fdf_2", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 8.2.0 hdf63c60_1", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_1", + "libpng 1.6.35 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.0 h1ba5d50_4", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "libtiff 4.0.9 he85c1e1_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.8 h26e45fe_1", + "libxslt 1.1.32 h1312cb7_0", + "linecache2 1.0.0 py27_0", + "llvmlite 0.26.0 py27hd408876_0", + "locket 0.2.0 py27h73929a2_1", + "lxml 4.2.5 py27hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.0 py27h7b6447c_0", + "matplotlib 2.2.3 py27hb69df0a_0", + "mccabe 0.6.1 py27_1", + "mistune 0.8.4 py27h7b6447c_0", + "mkl 2019.1 144", + "mkl-service 1.1.2 py27he904b0f_5", + "mkl_fft 1.0.6 py27hd81dba3_0", + "mkl_random 1.0.2 py27hd81dba3_0", + "more-itertools 4.3.0 py27_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py27_0", + "msgpack-python 0.5.6 py27h6bb024c_1", + "multipledispatch 0.6.0 py27_0", + "nbconvert 5.4.0 py27_1", + "nbformat 4.4.0 py27hed7f2b2_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.2 py27_1", + "nltk 3.4 py27_1", + "nose 1.3.7 py27_2", + "notebook 5.7.4 py27_0", + "numba 0.41.0 py27h962f231_0", + "numexpr 2.6.8 py27h9e4a6bb_0", + "numpy 1.15.4 py27h7e9f1db_0", + "numpy-base 1.15.4 py27hde5b4d6_0", + "numpydoc 0.8.0 py27_0", + "odo 0.5.1 py27h9170de3_0", + "olefile 0.46 py27_0", + "openpyxl 2.5.12 py27_0", + "openssl 1.1.1a h7b6447c_0", + "packaging 18.0 py27_0", + "pandas 0.23.4 py27h04863e7_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py27_1", + "pango 1.42.4 h049681c_0", + "parso 0.3.1 py27_0", + "partd 0.3.9 py27_0", + "patchelf 0.9 he6710b0_3", + "path.py 11.5.0 py27_0", + "pathlib2 2.3.3 py27_0", + "patsy 0.5.1 py27_0", + "pcre 8.42 h439df22_0", + "pep8 1.7.1 py27_0", + "pexpect 4.6.0 py27_0", + "pickleshare 0.7.5 py27_0", + "pillow 5.3.0 py27h34e0f95_0", + "pip 18.1 py27_0", + "pixman 0.34.0 hceecf20_3", + "pkginfo 1.4.2 py27_1", + "pluggy 0.8.0 py27_0", + "ply 3.11 py27_0", + "prometheus_client 0.5.0 py27_0", + "prompt_toolkit 1.0.15 py27h1b593e1_0", + "psutil 5.4.8 py27h7b6447c_0", + "ptyprocess 0.6.0 py27_0", + "py 1.7.0 py27_0", + "py-lief 0.9.0 py27h7725739_1", + "pycairo 1.18.0 py27h2a1e443_0", + "pycodestyle 2.4.0 py27_0", + "pycosat 0.6.3 py27h14c3975_0", + "pycparser 2.19 py27_0", + "pycrypto 2.6.1 py27h14c3975_9", + "pycurl 7.43.0.2 py27h1ba5d50_0", + "pyflakes 2.0.0 py27_0", + "pygments 2.3.1 py27_0", + "pylint 1.9.2 py27_0", + "pyodbc 4.0.25 py27he6710b0_0", + "pyopenssl 18.0.0 py27_0", + "pyparsing 2.3.0 py27_0", + "pyqt 5.9.2 py27h05f1152_2", + "pysocks 1.6.8 py27_0", + "pytables 3.4.4 py27ha205bf6_0", + "pytest 4.0.2 py27_0", + "python 2.7.15 h9bab390_6", + "python-dateutil 2.7.5 py27_0", + "python-libarchive-c 2.8 py27_6", + "pytz 2018.7 py27_0", + "pywavelets 1.0.1 py27hdd07704_0", + "pyyaml 3.13 py27h14c3975_0", + "pyzmq 17.1.2 py27h14c3975_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.5.3 py27_0", + "qtconsole 4.4.3 py27_0", + "qtpy 1.5.2 py27_0", + "readline 7.0 h7b6447c_5", + "requests 2.21.0 py27_0", + "rope 0.11.0 py27_0", + "ruamel_yaml 0.15.46 py27h14c3975_0", + "scandir 1.9.0 py27h14c3975_0", + "scikit-image 0.14.1 py27he6710b0_0", + "scikit-learn 0.20.1 py27hd81dba3_0", + "scipy 1.1.0 py27h7c811a0_2", + "seaborn 0.9.0 py27_0", + "send2trash 1.5.0 py27_0", + "setuptools 40.6.3 py27_0", + "simplegeneric 0.8.1 py27_2", + "singledispatch 3.4.0.3 py27h9bcb476_0", + "sip 4.19.8 py27hf484d3e_0", + "six 1.12.0 py27_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 1.2.1 py27h44e2768_0", + "sortedcollections 1.0.1 py27_0", + "sortedcontainers 2.1.0 py27_0", + "sphinx 1.8.2 py27_0", + "sphinxcontrib 1.0 py27_1", + "sphinxcontrib-websupport 1.1.0 py27_1", + "spyder 3.3.2 py27_0", + "spyder-kernels 0.3.0 py27_0", + "sqlalchemy 1.2.15 py27h7b6447c_0", + "sqlite 3.26.0 h7b6447c_0", + "ssl_match_hostname 3.5.0.1 py27_2", + "statsmodels 0.9.0 py27h035aef0_0", + "subprocess32 3.5.3 py27h7b6447c_0", + "sympy 1.3 py27_0", + "tblib 1.3.2 py27h51fe5ba_0", + "terminado 0.8.1 py27_1", + "testpath 0.4.2 py27_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.9.0 py27_0", + "tornado 5.1.1 py27h7b6447c_0", + "tqdm 4.28.1 py27h28b3542_0", + "traceback2 1.4.0 py27_0", + "traitlets 4.3.2 py27hd6ce930_0", + "typing 3.6.6 py27_0", + "unicodecsv 0.14.1 py27h5062da9_0", + "unittest2 1.1.0 py27_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.1 py27_0", + "wcwidth 0.1.7 py27h9e3e1ab_0", + "webencodings 0.5.1 py27_1", + "werkzeug 0.14.1 py27_0", + "wheel 0.32.3 py27_0", + "widgetsnbextension 3.4.2 py27_0", + "wrapt 1.10.11 py27h14c3975_2", + "wurlitzer 1.0.2 py27_0", + "xlrd 1.2.0 py27_0", + "xlsxwriter 1.1.2 py27_0", + "xlwt 1.3.0 py27h3d85d97_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.2.5 hf484d3e_1", + "zict 0.1.3 py27_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "73cc68434d89a14ed93f583433e97974", + "name": "anaconda", + "namespace": "python", + "sha256": "48788d9e77c60a927ea561e1a78e0a01fb889136b7047d6cdf91ef5e097c3faf", + "size": 10994, + "subdir": "linux-64", + "timestamp": 1545284932245, + "version": "2018.12" + }, + "anaconda-2018.12-py36h44efdcc_0.conda": { + "build": "py36h44efdcc_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "ca-certificates 2018.03.07 0", + "conda-env 2.6.0 1", + "intel-openmp 2019.1 144", + "libgcc-ng 8.2.0 hdf63c60_1", + "libgfortran-ng 7.3.0 hdf63c60_0", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "bzip2 1.0.6 h14c3975_5", + "expat 2.2.6 he6710b0_0", + "fribidi 1.0.5 h7b6447c_0", + "gmp 6.1.2 h6c8ec71_1", + "graphite2 1.3.12 h23475e2_2", + "icu 58.2 h9c2bf20_1", + "jbig 2.1 hdba287a_0", + "jpeg 9b h024ee3a_2", + "libffi 3.2.1 hd88cf55_4", + "liblief 0.9.0 h7725739_1", + "libsodium 1.0.16 h1bed415_0", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "mkl 2019.1 144", + "ncurses 6.1 he6710b0_1", + "openssl 1.1.1a h7b6447c_0", + "patchelf 0.9 he6710b0_3", + "pcre 8.42 h439df22_0", + "pixman 0.34.0 hceecf20_3", + "snappy 1.1.7 hbae5bb6_3", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zlib 1.2.11 h7b6447c_3", + "blosc 1.14.4 hdbcaa40_0", + "glib 2.56.2 hd408876_0", + "hdf5 1.10.2 hba1933b_1", + "libedit 3.1.20170329 h6b74fdf_2", + "libpng 1.6.35 hbc83047_0", + "libssh2 1.8.0 h1ba5d50_4", + "libtiff 4.0.9 he85c1e1_2", + "libxml2 2.9.8 h26e45fe_1", + "mpfr 4.0.1 hdf1c602_3", + "pandoc 1.19.2.1 hea2e7c5_1", + "readline 7.0 h7b6447c_5", + "tk 8.6.8 hbc83047_0", + "zeromq 4.2.5 hf484d3e_1", + "zstd 1.3.7 h0b5b093_0", + "dbus 1.13.2 h714fa37_1", + "freetype 2.9.1 h8a8886c_1", + "gstreamer 1.14.0 hb453b48_1", + "krb5 1.16.1 h173b8e3_7", + "libarchive 3.3.3 h5d8350f_5", + "libxslt 1.1.32 h1312cb7_0", + "mpc 1.1.0 h10f8cd9_1", + "sqlite 3.26.0 h7b6447c_0", + "unixodbc 2.3.7 h14c3975_0", + "fontconfig 2.13.0 h9420a91_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "libcurl 7.63.0 h20c2e04_1000", + "python 3.6.7 h0371630_0", + "alabaster 0.7.12 py36_0", + "asn1crypto 0.24.0 py36_0", + "atomicwrites 1.2.1 py36_0", + "attrs 18.2.0 py36h28b3542_0", + "backcall 0.1.0 py36_0", + "backports 1.0 py36_1", + "beautifulsoup4 4.6.3 py36_0", + "bitarray 0.8.3 py36h14c3975_0", + "boto 2.49.0 py36_0", + "cairo 1.14.12 h8948797_3", + "certifi 2018.11.29 py36_0", + "chardet 3.0.4 py36_1", + "click 7.0 py36_0", + "cloudpickle 0.6.1 py36_0", + "colorama 0.4.1 py36_0", + "contextlib2 0.5.5 py36h6c84a62_0", + "curl 7.63.0 hbc83047_1000", + "dask-core 1.0.0 py36_0", + "decorator 4.3.0 py36_0", + "defusedxml 0.5.0 py36_1", + "docutils 0.14 py36hb0f60f5_0", + "entrypoints 0.2.3 py36_2", + "et_xmlfile 1.0.1 py36hd6bccc3_0", + "fastcache 1.0.2 py36h14c3975_2", + "filelock 3.0.10 py36_0", + "glob2 0.6 py36_1", + "gmpy2 2.0.8 py36h10f8cd9_2", + "greenlet 0.4.15 py36h7b6447c_0", + "heapdict 1.0.0 py36_2", + "idna 2.8 py36_0", + "imagesize 1.1.0 py36_0", + "importlib_metadata 0.6 py36_0", + "ipython_genutils 0.2.0 py36hb52b0d5_0", + "itsdangerous 1.1.0 py36_0", + "jdcal 1.4 py36_0", + "jeepney 0.4 py36_0", + "kiwisolver 1.0.1 py36hf484d3e_0", + "lazy-object-proxy 1.3.1 py36h14c3975_2", + "llvmlite 0.26.0 py36hd408876_0", + "locket 0.2.0 py36h787c0ad_1", + "lxml 4.2.5 py36hefd8a0e_0", + "markupsafe 1.1.0 py36h7b6447c_0", + "mccabe 0.6.1 py36_1", + "mistune 0.8.4 py36h7b6447c_0", + "mkl-service 1.1.2 py36he904b0f_5", + "mpmath 1.1.0 py36_0", + "msgpack-python 0.5.6 py36h6bb024c_1", + "numpy-base 1.15.4 py36hde5b4d6_0", + "olefile 0.46 py36_0", + "pandocfilters 1.4.2 py36_1", + "parso 0.3.1 py36_0", + "pep8 1.7.1 py36_0", + "pickleshare 0.7.5 py36_0", + "pkginfo 1.4.2 py36_1", + "pluggy 0.8.0 py36_0", + "ply 3.11 py36_0", + "prometheus_client 0.5.0 py36_0", + "psutil 5.4.8 py36h7b6447c_0", + "ptyprocess 0.6.0 py36_0", + "py 1.7.0 py36_0", + "py-lief 0.9.0 py36h7725739_1", + "pycodestyle 2.4.0 py36_0", + "pycosat 0.6.3 py36h14c3975_0", + "pycparser 2.19 py36_0", + "pycrypto 2.6.1 py36h14c3975_9", + "pycurl 7.43.0.2 py36h1ba5d50_0", + "pyflakes 2.0.0 py36_0", + "pyodbc 4.0.25 py36he6710b0_0", + "pyparsing 2.3.0 py36_0", + "pysocks 1.6.8 py36_0", + "python-libarchive-c 2.8 py36_6", + "pytz 2018.7 py36_0", + "pyyaml 3.13 py36h14c3975_0", + "pyzmq 17.1.2 py36h14c3975_0", + "qt 5.9.7 h5867ecd_1", + "qtpy 1.5.2 py36_0", + "rope 0.11.0 py36_0", + "ruamel_yaml 0.15.46 py36h14c3975_0", + "send2trash 1.5.0 py36_0", + "simplegeneric 0.8.1 py36_2", + "sip 4.19.8 py36hf484d3e_0", + "six 1.12.0 py36_0", + "snowballstemmer 1.2.1 py36h6febd40_0", + "sortedcontainers 2.1.0 py36_0", + "sphinxcontrib 1.0 py36_1", + "sqlalchemy 1.2.15 py36h7b6447c_0", + "tblib 1.3.2 py36h34cf8b6_0", + "testpath 0.4.2 py36_0", + "toolz 0.9.0 py36_0", + "tornado 5.1.1 py36h7b6447c_0", + "tqdm 4.28.1 py36h28b3542_0", + "typed-ast 1.1.0 py36h14c3975_0", + "unicodecsv 0.14.1 py36ha668878_0", + "wcwidth 0.1.7 py36hdf4376a_0", + "webencodings 0.5.1 py36_1", + "werkzeug 0.14.1 py36_0", + "wrapt 1.10.11 py36h14c3975_2", + "wurlitzer 1.0.2 py36_0", + "xlrd 1.2.0 py36_0", + "xlsxwriter 1.1.2 py36_0", + "xlwt 1.3.0 py36h7b00a1f_0", + "astroid 2.1.0 py36_0", + "babel 2.6.0 py36_0", + "backports.os 0.1.1 py36_0", + "backports.shutil_get_terminal_size 1.0.0 py36_2", + "cffi 1.11.5 py36he75722e_1", + "cycler 0.10.0 py36h93f1223_0", + "cytoolz 0.9.0.1 py36h14c3975_1", + "harfbuzz 1.8.8 hffaf4a1_0", + "html5lib 1.0.1 py36_0", + "jedi 0.13.2 py36_0", + "mkl_fft 1.0.6 py36hd81dba3_0", + "mkl_random 1.0.2 py36hd81dba3_0", + "more-itertools 4.3.0 py36_0", + "multipledispatch 0.6.0 py36_0", + "nltk 3.4 py36_1", + "openpyxl 2.5.12 py36_0", + "packaging 18.0 py36_0", + "partd 0.3.9 py36_0", + "pathlib2 2.3.3 py36_0", + "pexpect 4.6.0 py36_0", + "pillow 5.3.0 py36h34e0f95_0", + "pyqt 5.9.2 py36h05f1152_2", + "python-dateutil 2.7.5 py36_0", + "qtawesome 0.5.3 py36_0", + "setuptools 40.6.3 py36_0", + "singledispatch 3.4.0.3 py36h7a266c3_0", + "sortedcollections 1.0.1 py36_0", + "sphinxcontrib-websupport 1.1.0 py36_1", + "sympy 1.3 py36_0", + "terminado 0.8.1 py36_1", + "traitlets 4.3.2 py36h674d592_0", + "zict 0.1.3 py36_0", + "bleach 3.0.2 py36_0", + "clyent 1.2.2 py36_1", + "cryptography 2.4.2 py36h1ba5d50_0", + "cython 0.29.2 py36he6710b0_0", + "distributed 1.25.1 py36_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.3.7 py36h7b6447c_1", + "isort 4.3.4 py36_0", + "jinja2 2.10 py36_0", + "jsonschema 2.6.0 py36h006f8b5_0", + "jupyter_core 4.4.0 py36_0", + "networkx 2.2 py36_1", + "nose 1.3.7 py36_2", + "numpy 1.15.4 py36h7e9f1db_0", + "pango 1.42.4 h049681c_0", + "path.py 11.5.0 py36_0", + "pygments 2.3.1 py36_0", + "pytest 4.0.2 py36_0", + "wheel 0.32.3 py36_0", + "bokeh 1.0.2 py36_0", + "bottleneck 1.2.1 py36h035aef0_1", + "datashape 0.5.4 py36_1", + "flask 1.0.2 py36_1", + "h5py 2.8.0 py36h989c5e5_3", + "imageio 2.4.1 py36_0", + "jupyter_client 5.2.4 py36_0", + "matplotlib 3.0.2 py36h5429711_0", + "nbformat 4.4.0 py36h31c9010_0", + "numba 0.41.0 py36h962f231_0", + "numexpr 2.6.8 py36h9e4a6bb_0", + "pandas 0.23.4 py36h04863e7_0", + "pip 18.1 py36_0", + "prompt_toolkit 2.0.7 py36_0", + "pylint 2.2.2 py36_0", + "pyopenssl 18.0.0 py36_0", + "pytest-arraydiff 0.3 py36h39e3cac_0", + "pytest-doctestplus 0.2.0 py36_0", + "pytest-openfiles 0.3.1 py36_0", + "pytest-remotedata 0.3.1 py36_0", + "pywavelets 1.0.1 py36hdd07704_0", + "scipy 1.1.0 py36h7c811a0_2", + "secretstorage 3.1.0 py36_0", + "bkcharts 0.2 py36h735825a_0", + "dask 1.0.0 py36_0", + "flask-cors 3.0.7 py36_0", + "ipython 7.2.0 py36h39e3cac_0", + "keyring 17.0.0 py36_0", + "nbconvert 5.4.0 py36_1", + "patsy 0.5.1 py36_0", + "pytables 3.4.4 py36ha205bf6_0", + "pytest-astropy 0.5.0 py36_0", + "scikit-image 0.14.1 py36he6710b0_0", + "scikit-learn 0.20.1 py36hd81dba3_0", + "urllib3 1.24.1 py36_0", + "astropy 3.1 py36h7b6447c_0", + "ipykernel 5.1.0 py36h39e3cac_0", + "odo 0.5.1 py36h90ed295_0", + "requests 2.21.0 py36_0", + "statsmodels 0.9.0 py36h035aef0_0", + "anaconda-client 1.7.2 py36_0", + "blaze 0.11.3 py36_0", + "jupyter_console 6.0.0 py36_0", + "notebook 5.7.4 py36_0", + "qtconsole 4.4.3 py36_0", + "seaborn 0.9.0 py36_0", + "sphinx 1.8.2 py36_0", + "spyder-kernels 0.3.0 py36_0", + "anaconda-project 0.8.2 py36_0", + "jupyterlab_server 0.2.0 py36_0", + "numpydoc 0.8.0 py36_0", + "widgetsnbextension 3.4.2 py36_0", + "ipywidgets 7.4.2 py36_0", + "jupyterlab 0.35.3 py36_0", + "spyder 3.3.2 py36_0", + "jupyter 1.0.0 py36_7", + "conda 4.5.12 py36_0", + "conda-build 3.17.6 py36_0" + ], + "license": "BSD", + "md5": "aedb66cf575ac94bea2e60b32994eae4", + "name": "anaconda", + "namespace": "python", + "sha256": "e5069facc18e65bc2cfe63005c0a2e0037b2d0d2c932f2a4524507ee281bfb4f", + "size": 53256, + "subdir": "linux-64", + "timestamp": 1545401296310, + "version": "2018.12" + }, + "anaconda-2018.12-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.12 py37_0", + "anaconda-client 1.7.2 py37_0", + "anaconda-project 0.8.2 py37_0", + "asn1crypto 0.24.0 py37_0", + "astroid 2.1.0 py37_0", + "astropy 3.1 py37h7b6447c_0", + "atomicwrites 1.2.1 py37_0", + "attrs 18.2.0 py37h28b3542_0", + "babel 2.6.0 py37_0", + "backcall 0.1.0 py37_0", + "backports 1.0 py37_1", + "backports.os 0.1.1 py37_0", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "beautifulsoup4 4.6.3 py37_0", + "bitarray 0.8.3 py37h14c3975_0", + "bkcharts 0.2 py37_0", + "blas 1.0 mkl", + "blaze 0.11.3 py37_0", + "bleach 3.0.2 py37_0", + "blosc 1.14.4 hdbcaa40_0", + "bokeh 1.0.2 py37_0", + "boto 2.49.0 py37_0", + "bottleneck 1.2.1 py37h035aef0_1", + "bzip2 1.0.6 h14c3975_5", + "ca-certificates 2018.03.07 0", + "cairo 1.14.12 h8948797_3", + "certifi 2018.11.29 py37_0", + "cffi 1.11.5 py37he75722e_1", + "chardet 3.0.4 py37_1", + "click 7.0 py37_0", + "cloudpickle 0.6.1 py37_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.1 py37_0", + "contextlib2 0.5.5 py37_0", + "cryptography 2.4.2 py37h1ba5d50_0", + "curl 7.63.0 hbc83047_1000", + "cycler 0.10.0 py37_0", + "cython 0.29.2 py37he6710b0_0", + "cytoolz 0.9.0.1 py37h14c3975_1", + "dask 1.0.0 py37_0", + "dask-core 1.0.0 py37_0", + "datashape 0.5.4 py37_1", + "dbus 1.13.2 h714fa37_1", + "decorator 4.3.0 py37_0", + "defusedxml 0.5.0 py37_1", + "distributed 1.25.1 py37_0", + "docutils 0.14 py37_0", + "entrypoints 0.2.3 py37_2", + "et_xmlfile 1.0.1 py37_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.0.2 py37h14c3975_2", + "filelock 3.0.10 py37_0", + "flask 1.0.2 py37_1", + "flask-cors 3.0.7 py37_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.3.7 py37h7b6447c_1", + "glib 2.56.2 hd408876_0", + "glob2 0.6 py37_1", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.12 h23475e2_2", + "greenlet 0.4.15 py37h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.8.0 py37h989c5e5_3", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.2 hba1933b_1", + "heapdict 1.0.0 py37_2", + "html5lib 1.0.1 py37_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py37_0", + "imageio 2.4.1 py37_0", + "imagesize 1.1.0 py37_0", + "importlib_metadata 0.6 py37_0", + "intel-openmp 2019.1 144", + "ipykernel 5.1.0 py37h39e3cac_0", + "ipython 7.2.0 py37h39e3cac_0", + "ipython_genutils 0.2.0 py37_0", + "ipywidgets 7.4.2 py37_0", + "isort 4.3.4 py37_0", + "itsdangerous 1.1.0 py37_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4 py37_0", + "jedi 0.13.2 py37_0", + "jeepney 0.4 py37_0", + "jinja2 2.10 py37_0", + "jpeg 9b h024ee3a_2", + "jsonschema 2.6.0 py37_0", + "jupyter 1.0.0 py37_7", + "jupyter_client 5.2.4 py37_0", + "jupyter_console 6.0.0 py37_0", + "jupyter_core 4.4.0 py37_0", + "jupyterlab 0.35.3 py37_0", + "jupyterlab_server 0.2.0 py37_0", + "keyring 17.0.0 py37_0", + "kiwisolver 1.0.1 py37hf484d3e_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.3.1 py37h14c3975_2", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.63.0 h20c2e04_1000", + "libedit 3.1.20170329 h6b74fdf_2", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 8.2.0 hdf63c60_1", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_1", + "libpng 1.6.35 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.0 h1ba5d50_4", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "libtiff 4.0.9 he85c1e1_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.8 h26e45fe_1", + "libxslt 1.1.32 h1312cb7_0", + "llvmlite 0.26.0 py37hd408876_0", + "locket 0.2.0 py37_1", + "lxml 4.2.5 py37hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.0 py37h7b6447c_0", + "matplotlib 3.0.2 py37h5429711_0", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h7b6447c_0", + "mkl 2019.1 144", + "mkl-service 1.1.2 py37he904b0f_5", + "mkl_fft 1.0.6 py37hd81dba3_0", + "mkl_random 1.0.2 py37hd81dba3_0", + "more-itertools 4.3.0 py37_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py37_0", + "msgpack-python 0.5.6 py37h6bb024c_1", + "multipledispatch 0.6.0 py37_0", + "nbconvert 5.4.0 py37_1", + "nbformat 4.4.0 py37_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.2 py37_1", + "nltk 3.4 py37_1", + "nose 1.3.7 py37_2", + "notebook 5.7.4 py37_0", + "numba 0.41.0 py37h962f231_0", + "numexpr 2.6.8 py37h9e4a6bb_0", + "numpy 1.15.4 py37h7e9f1db_0", + "numpy-base 1.15.4 py37hde5b4d6_0", + "numpydoc 0.8.0 py37_0", + "odo 0.5.1 py37_0", + "olefile 0.46 py37_0", + "openpyxl 2.5.12 py37_0", + "openssl 1.1.1a h7b6447c_0", + "packaging 18.0 py37_0", + "pandas 0.23.4 py37h04863e7_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py37_1", + "pango 1.42.4 h049681c_0", + "parso 0.3.1 py37_0", + "partd 0.3.9 py37_0", + "patchelf 0.9 he6710b0_3", + "path.py 11.5.0 py37_0", + "pathlib2 2.3.3 py37_0", + "patsy 0.5.1 py37_0", + "pcre 8.42 h439df22_0", + "pep8 1.7.1 py37_0", + "pexpect 4.6.0 py37_0", + "pickleshare 0.7.5 py37_0", + "pillow 5.3.0 py37h34e0f95_0", + "pip 18.1 py37_0", + "pixman 0.34.0 hceecf20_3", + "pkginfo 1.4.2 py37_1", + "pluggy 0.8.0 py37_0", + "ply 3.11 py37_0", + "prometheus_client 0.5.0 py37_0", + "prompt_toolkit 2.0.7 py37_0", + "psutil 5.4.8 py37h7b6447c_0", + "ptyprocess 0.6.0 py37_0", + "py 1.7.0 py37_0", + "py-lief 0.9.0 py37h7725739_1", + "pycodestyle 2.4.0 py37_0", + "pycosat 0.6.3 py37h14c3975_0", + "pycparser 2.19 py37_0", + "pycrypto 2.6.1 py37h14c3975_9", + "pycurl 7.43.0.2 py37h1ba5d50_0", + "pyflakes 2.0.0 py37_0", + "pygments 2.3.1 py37_0", + "pylint 2.2.2 py37_0", + "pyodbc 4.0.25 py37he6710b0_0", + "pyopenssl 18.0.0 py37_0", + "pyparsing 2.3.0 py37_0", + "pyqt 5.9.2 py37h05f1152_2", + "pysocks 1.6.8 py37_0", + "pytables 3.4.4 py37ha205bf6_0", + "pytest 4.0.2 py37_0", + "pytest-arraydiff 0.3 py37h39e3cac_0", + "pytest-astropy 0.5.0 py37_0", + "pytest-doctestplus 0.2.0 py37_0", + "pytest-openfiles 0.3.1 py37_0", + "pytest-remotedata 0.3.1 py37_0", + "python 3.7.1 h0371630_7", + "python-dateutil 2.7.5 py37_0", + "python-libarchive-c 2.8 py37_6", + "pytz 2018.7 py37_0", + "pywavelets 1.0.1 py37hdd07704_0", + "pyyaml 3.13 py37h14c3975_0", + "pyzmq 17.1.2 py37h14c3975_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.5.3 py37_0", + "qtconsole 4.4.3 py37_0", + "qtpy 1.5.2 py37_0", + "readline 7.0 h7b6447c_5", + "requests 2.21.0 py37_0", + "rope 0.11.0 py37_0", + "ruamel_yaml 0.15.46 py37h14c3975_0", + "scikit-image 0.14.1 py37he6710b0_0", + "scikit-learn 0.20.1 py37hd81dba3_0", + "scipy 1.1.0 py37h7c811a0_2", + "seaborn 0.9.0 py37_0", + "secretstorage 3.1.0 py37_0", + "send2trash 1.5.0 py37_0", + "setuptools 40.6.3 py37_0", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.4.0.3 py37_0", + "sip 4.19.8 py37hf484d3e_0", + "six 1.12.0 py37_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 1.2.1 py37_0", + "sortedcollections 1.0.1 py37_0", + "sortedcontainers 2.1.0 py37_0", + "sphinx 1.8.2 py37_0", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-websupport 1.1.0 py37_1", + "spyder 3.3.2 py37_0", + "spyder-kernels 0.3.0 py37_0", + "sqlalchemy 1.2.15 py37h7b6447c_0", + "sqlite 3.26.0 h7b6447c_0", + "statsmodels 0.9.0 py37h035aef0_0", + "sympy 1.3 py37_0", + "tblib 1.3.2 py37_0", + "terminado 0.8.1 py37_1", + "testpath 0.4.2 py37_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.9.0 py37_0", + "tornado 5.1.1 py37h7b6447c_0", + "tqdm 4.28.1 py37h28b3542_0", + "traitlets 4.3.2 py37_0", + "unicodecsv 0.14.1 py37_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.1 py37_0", + "wcwidth 0.1.7 py37_0", + "webencodings 0.5.1 py37_1", + "werkzeug 0.14.1 py37_0", + "wheel 0.32.3 py37_0", + "widgetsnbextension 3.4.2 py37_0", + "wrapt 1.10.11 py37h14c3975_2", + "wurlitzer 1.0.2 py37_0", + "xlrd 1.2.0 py37_0", + "xlsxwriter 1.1.2 py37_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.2.5 hf484d3e_1", + "zict 0.1.3 py37_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "e451c7ebb745a8907995321e097883f1", + "name": "anaconda", + "namespace": "python", + "sha256": "7ed4c7260cdd78093d738d5e2108d125e2596f9830fcd6cfa2484b6e1d6676cf", + "size": 10500, + "subdir": "linux-64", + "timestamp": 1545285186418, + "version": "2018.12" + }, + "anaconda-2019.03-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.12 py27_0", + "anaconda-client 1.7.2 py27_0", + "anaconda-project 0.8.2 py27_0", + "asn1crypto 0.24.0 py27_0", + "astroid 1.6.5 py27_0", + "astropy 2.0.9 py27hdd07704_0", + "atomicwrites 1.3.0 py27_1", + "attrs 19.1.0 py27_1", + "babel 2.6.0 py27_0", + "backports 1.0 py27_1", + "backports.functools_lru_cache 1.5 py27_1", + "backports.os 0.1.1 py27_0", + "backports.shutil_get_terminal_size 1.0.0 py27_2", + "backports_abc 0.5 py27h7b3c97b_0", + "beautifulsoup4 4.7.1 py27_1", + "bitarray 0.8.3 py27h14c3975_0", + "bkcharts 0.2 py27h241ae91_0", + "blas 1.0 mkl", + "bleach 3.1.0 py27_0", + "blosc 1.15.0 hd408876_0", + "bokeh 1.0.4 py27_0", + "boto 2.49.0 py27_0", + "bottleneck 1.2.1 py27h035aef0_1", + "bzip2 1.0.6 h14c3975_5", + "ca-certificates 2019.1.23 0", + "cairo 1.14.12 h8948797_3", + "cdecimal 2.3 py27h14c3975_3", + "certifi 2019.3.9 py27_0", + "cffi 1.12.2 py27h2e261b9_1", + "chardet 3.0.4 py27_1", + "click 7.0 py27_0", + "cloudpickle 0.8.0 py27_0", + "clyent 1.2.2 py27_1", + "colorama 0.4.1 py27_0", + "configparser 3.7.3 py27_1", + "contextlib2 0.5.5 py27hbf4c468_0", + "cryptography 2.6.1 py27h1ba5d50_0", + "curl 7.64.0 hbc83047_2", + "cycler 0.10.0 py27hc7354d3_0", + "cython 0.29.6 py27he6710b0_0", + "cytoolz 0.9.0.1 py27h14c3975_1", + "dask 1.1.4 py27_1", + "dask-core 1.1.4 py27_1", + "dbus 1.13.6 h746ee38_0", + "decorator 4.4.0 py27_1", + "defusedxml 0.5.0 py27_1", + "distributed 1.26.0 py27_1", + "docutils 0.14 py27hae222c1_0", + "entrypoints 0.3 py27_0", + "enum34 1.1.6 py27_1", + "et_xmlfile 1.0.1 py27h75840f5_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.0.2 py27h14c3975_2", + "filelock 3.0.10 py27_0", + "flask 1.0.2 py27_1", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "funcsigs 1.0.2 py27h83f16ab_0", + "functools32 3.2.3.2 py27_1", + "future 0.17.1 py27_0", + "futures 3.2.0 py27_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py27h7b6447c_0", + "glib 2.56.2 hd408876_0", + "glob2 0.6 py27_1", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py27h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py27h7b6447c_0", + "grin 1.2.1 py27_4", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.9.0 py27h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.0 py27_2", + "html5lib 1.0.1 py27_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py27_0", + "imageio 2.5.0 py27_0", + "imagesize 1.1.0 py27_0", + "importlib_metadata 0.8 py27_0", + "intel-openmp 2019.3 199", + "ipaddress 1.0.22 py27_0", + "ipykernel 4.10.0 py27_0", + "ipython 5.8.0 py27_0", + "ipython_genutils 0.2.0 py27h89fb69b_0", + "ipywidgets 7.4.2 py27_0", + "isort 4.3.16 py27_0", + "itsdangerous 1.1.0 py27_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4 py27_0", + "jedi 0.13.3 py27_0", + "jinja2 2.10 py27_0", + "jpeg 9b h024ee3a_2", + "jsonschema 3.0.1 py27_0", + "jupyter 1.0.0 py27_7", + "jupyter_client 5.2.4 py27_0", + "jupyter_console 5.2.0 py27_1", + "jupyter_core 4.4.0 py27_0", + "jupyterlab 0.33.11 py27_0", + "jupyterlab_launcher 0.11.2 py27h28b3542_0", + "kiwisolver 1.0.1 py27hf484d3e_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.3.1 py27h14c3975_2", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.64.0 h20c2e04_2", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 8.2.0 hdf63c60_1", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.36 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.0 h1ba5d50_4", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "libtiff 4.0.10 h2733197_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 he19cac6_0", + "libxslt 1.1.33 h7d1a2b0_0", + "linecache2 1.0.0 py27_0", + "llvmlite 0.28.0 py27hd408876_0", + "locket 0.2.0 py27h73929a2_1", + "lxml 4.3.2 py27hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py27h7b6447c_0", + "matplotlib 2.2.3 py27hb69df0a_0", + "mccabe 0.6.1 py27_1", + "mistune 0.8.4 py27h7b6447c_0", + "mkl 2019.3 199", + "mkl-service 1.1.2 py27he904b0f_5", + "mkl_fft 1.0.10 py27ha843d7b_0", + "mkl_random 1.0.2 py27hd81dba3_0", + "more-itertools 5.0.0 py27_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py27_0", + "msgpack-python 0.6.1 py27hfd86e86_1", + "multipledispatch 0.6.0 py27_0", + "nbconvert 5.4.1 py27_3", + "nbformat 4.4.0 py27hed7f2b2_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.2 py27_1", + "nltk 3.4 py27_1", + "nose 1.3.7 py27_2", + "notebook 5.7.8 py27_0", + "numba 0.43.1 py27h962f231_0", + "numexpr 2.6.9 py27h9e4a6bb_0", + "numpy 1.16.2 py27h7e9f1db_0", + "numpy-base 1.16.2 py27hde5b4d6_0", + "numpydoc 0.8.0 py27_0", + "olefile 0.46 py27_0", + "openpyxl 2.6.1 py27_1", + "openssl 1.1.1b h7b6447c_1", + "packaging 19.0 py27_0", + "pandas 0.24.2 py27he6710b0_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py27_1", + "pango 1.42.4 h049681c_0", + "parso 0.3.4 py27_0", + "partd 0.3.10 py27_1", + "patchelf 0.9 he6710b0_3", + "path.py 11.5.0 py27_0", + "pathlib2 2.3.3 py27_0", + "patsy 0.5.1 py27_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py27_0", + "pexpect 4.6.0 py27_0", + "pickleshare 0.7.5 py27_0", + "pillow 5.4.1 py27h34e0f95_0", + "pip 19.0.3 py27_0", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py27_0", + "pluggy 0.9.0 py27_0", + "ply 3.11 py27_0", + "prometheus_client 0.6.0 py27_0", + "prompt_toolkit 1.0.15 py27h1b593e1_0", + "psutil 5.6.1 py27h7b6447c_0", + "ptyprocess 0.6.0 py27_0", + "py 1.8.0 py27_0", + "py-lief 0.9.0 py27h7725739_2", + "pycairo 1.18.0 py27h2a1e443_0", + "pycodestyle 2.5.0 py27_0", + "pycosat 0.6.3 py27h14c3975_0", + "pycparser 2.19 py27_0", + "pycrypto 2.6.1 py27h14c3975_9", + "pycurl 7.43.0.2 py27h1ba5d50_0", + "pyflakes 2.1.1 py27_0", + "pygments 2.3.1 py27_0", + "pylint 1.9.2 py27_0", + "pyodbc 4.0.26 py27he6710b0_0", + "pyopenssl 19.0.0 py27_0", + "pyparsing 2.3.1 py27_0", + "pyqt 5.9.2 py27h05f1152_2", + "pyrsistent 0.14.11 py27h7b6447c_0", + "pysocks 1.6.8 py27_0", + "pytables 3.5.1 py27h71ec239_0", + "pytest 4.3.1 py27_0", + "python 2.7.16 h9bab390_0", + "python-dateutil 2.8.0 py27_0", + "python-libarchive-c 2.8 py27_6", + "pytz 2018.9 py27_0", + "pywavelets 1.0.2 py27hdd07704_0", + "pyyaml 5.1 py27h7b6447c_0", + "pyzmq 18.0.0 py27he6710b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.5.7 py27_1", + "qtconsole 4.4.3 py27_0", + "qtpy 1.7.0 py27_1", + "readline 7.0 h7b6447c_5", + "requests 2.21.0 py27_0", + "rope 0.12.0 py27_0", + "ruamel_yaml 0.15.46 py27h14c3975_0", + "scandir 1.10.0 py27h7b6447c_0", + "scikit-image 0.14.2 py27he6710b0_0", + "scikit-learn 0.20.3 py27hd81dba3_0", + "scipy 1.2.1 py27h7c811a0_0", + "seaborn 0.9.0 py27_0", + "send2trash 1.5.0 py27_0", + "setuptools 40.8.0 py27_0", + "simplegeneric 0.8.1 py27_2", + "singledispatch 3.4.0.3 py27h9bcb476_0", + "sip 4.19.8 py27hf484d3e_0", + "six 1.12.0 py27_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 1.2.1 py27h44e2768_0", + "sortedcollections 1.1.2 py27_0", + "sortedcontainers 2.1.0 py27_0", + "soupsieve 1.8 py27_0", + "sphinx 1.8.5 py27_0", + "sphinxcontrib 1.0 py27_1", + "sphinxcontrib-websupport 1.1.0 py27_1", + "spyder 3.3.3 py27_0", + "spyder-kernels 0.4.2 py27_0", + "sqlalchemy 1.3.1 py27h7b6447c_0", + "sqlite 3.27.2 h7b6447c_0", + "ssl_match_hostname 3.7.0.1 py27_0", + "statsmodels 0.9.0 py27h035aef0_0", + "subprocess32 3.5.3 py27h7b6447c_0", + "sympy 1.3 py27_0", + "tblib 1.3.2 py27h51fe5ba_0", + "terminado 0.8.1 py27_1", + "testpath 0.4.2 py27_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.9.0 py27_0", + "tornado 5.1.1 py27h7b6447c_0", + "tqdm 4.31.1 py27_1", + "traceback2 1.4.0 py27_0", + "traitlets 4.3.2 py27hd6ce930_0", + "typing 3.6.6 py27_0", + "unicodecsv 0.14.1 py27h5062da9_0", + "unittest2 1.1.0 py27_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.1 py27_0", + "wcwidth 0.1.7 py27h9e3e1ab_0", + "webencodings 0.5.1 py27_1", + "werkzeug 0.14.1 py27_0", + "wheel 0.33.1 py27_0", + "widgetsnbextension 3.4.2 py27_0", + "wrapt 1.11.1 py27h7b6447c_0", + "wurlitzer 1.0.2 py27_0", + "xlrd 1.2.0 py27_0", + "xlsxwriter 1.1.5 py27_0", + "xlwt 1.3.0 py27h3d85d97_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.3.1 he6710b0_3", + "zict 0.1.4 py27_0", + "zipp 0.3.3 py27_1", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "549917827abd027cef95014d7fe80a10", + "name": "anaconda", + "namespace": "python", + "sha256": "ddd04c55248dd3f82894456cf5ec28ea47bb09c0157077aca670527fb4095be5", + "size": 10828, + "subdir": "linux-64", + "timestamp": 1554398667125, + "version": "2019.03" + }, + "anaconda-2019.03-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "ca-certificates 2019.1.23 0", + "intel-openmp 2019.3 199", + "libgcc-ng 8.2.0 hdf63c60_1", + "libgfortran-ng 7.3.0 hdf63c60_0", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "bzip2 1.0.6 h14c3975_5", + "expat 2.2.6 he6710b0_0", + "fribidi 1.0.5 h7b6447c_0", + "gmp 6.1.2 h6c8ec71_1", + "graphite2 1.3.13 h23475e2_0", + "icu 58.2 h9c2bf20_1", + "jbig 2.1 hdba287a_0", + "jpeg 9b h024ee3a_2", + "libffi 3.2.1 hd88cf55_4", + "libsodium 1.0.16 h1bed415_0", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "lzo 2.10 h49e0be7_2", + "mkl 2019.3 199", + "ncurses 6.1 he6710b0_1", + "openssl 1.1.1b h7b6447c_1", + "pcre 8.43 he6710b0_0", + "pixman 0.38.0 h7b6447c_0", + "snappy 1.1.7 hbae5bb6_3", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zlib 1.2.11 h7b6447c_3", + "blosc 1.15.0 hd408876_0", + "glib 2.56.2 hd408876_0", + "hdf5 1.10.4 hb1b8bf9_0", + "libedit 3.1.20181209 hc058e9b_0", + "libpng 1.6.36 hbc83047_0", + "libssh2 1.8.0 h1ba5d50_4", + "libxml2 2.9.9 he19cac6_0", + "mpfr 4.0.1 hdf1c602_3", + "pandoc 2.2.3.2 0", + "readline 7.0 h7b6447c_5", + "tk 8.6.8 hbc83047_0", + "zeromq 4.3.1 he6710b0_3", + "zstd 1.3.7 h0b5b093_0", + "dbus 1.13.6 h746ee38_0", + "freetype 2.9.1 h8a8886c_1", + "gstreamer 1.14.0 hb453b48_1", + "krb5 1.16.1 h173b8e3_7", + "libtiff 4.0.10 h2733197_2", + "libxslt 1.1.33 h7d1a2b0_0", + "mpc 1.1.0 h10f8cd9_1", + "sqlite 3.27.2 h7b6447c_0", + "unixodbc 2.3.7 h14c3975_0", + "fontconfig 2.13.0 h9420a91_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "libcurl 7.64.0 h20c2e04_2", + "python 3.6.8 h0371630_0", + "alabaster 0.7.12 py36_0", + "asn1crypto 0.24.0 py36_0", + "atomicwrites 1.3.0 py36_1", + "attrs 19.1.0 py36_1", + "backcall 0.1.0 py36_0", + "backports 1.0 py36_1", + "bitarray 0.8.3 py36h14c3975_0", + "boto 2.49.0 py36_0", + "cairo 1.14.12 h8948797_3", + "certifi 2019.3.9 py36_0", + "chardet 3.0.4 py36_1", + "click 7.0 py36_0", + "cloudpickle 0.8.0 py36_0", + "colorama 0.4.1 py36_0", + "contextlib2 0.5.5 py36h6c84a62_0", + "curl 7.64.0 hbc83047_2", + "dask-core 1.1.4 py36_1", + "decorator 4.4.0 py36_1", + "defusedxml 0.5.0 py36_1", + "docutils 0.14 py36hb0f60f5_0", + "entrypoints 0.3 py36_0", + "et_xmlfile 1.0.1 py36hd6bccc3_0", + "fastcache 1.0.2 py36h14c3975_2", + "gmpy2 2.0.8 py36h10f8cd9_2", + "greenlet 0.4.15 py36h7b6447c_0", + "heapdict 1.0.0 py36_2", + "idna 2.8 py36_0", + "imagesize 1.1.0 py36_0", + "ipython_genutils 0.2.0 py36hb52b0d5_0", + "itsdangerous 1.1.0 py36_0", + "jdcal 1.4 py36_0", + "jeepney 0.4 py36_0", + "kiwisolver 1.0.1 py36hf484d3e_0", + "lazy-object-proxy 1.3.1 py36h14c3975_2", + "llvmlite 0.28.0 py36hd408876_0", + "locket 0.2.0 py36h787c0ad_1", + "lxml 4.3.2 py36hefd8a0e_0", + "markupsafe 1.1.1 py36h7b6447c_0", + "mccabe 0.6.1 py36_1", + "mistune 0.8.4 py36h7b6447c_0", + "mkl-service 1.1.2 py36he904b0f_5", + "more-itertools 6.0.0 py36_0", + "mpmath 1.1.0 py36_0", + "msgpack-python 0.6.1 py36hfd86e86_1", + "numpy-base 1.16.2 py36hde5b4d6_0", + "olefile 0.46 py36_0", + "pandocfilters 1.4.2 py36_1", + "parso 0.3.4 py36_0", + "pep8 1.7.1 py36_0", + "pickleshare 0.7.5 py36_0", + "pluggy 0.9.0 py36_0", + "ply 3.11 py36_0", + "prometheus_client 0.6.0 py36_0", + "psutil 5.6.1 py36h7b6447c_0", + "ptyprocess 0.6.0 py36_0", + "py 1.8.0 py36_0", + "pycodestyle 2.5.0 py36_0", + "pycosat 0.6.3 py36h14c3975_0", + "pycparser 2.19 py36_0", + "pycrypto 2.6.1 py36h14c3975_9", + "pycurl 7.43.0.2 py36h1ba5d50_0", + "pyflakes 2.1.1 py36_0", + "pyodbc 4.0.26 py36he6710b0_0", + "pyparsing 2.3.1 py36_0", + "pysocks 1.6.8 py36_0", + "pytz 2018.9 py36_0", + "pyyaml 5.1 py36h7b6447c_0", + "pyzmq 18.0.0 py36he6710b0_0", + "qt 5.9.7 h5867ecd_1", + "qtpy 1.7.0 py36_1", + "rope 0.12.0 py36_0", + "ruamel_yaml 0.15.46 py36h14c3975_0", + "send2trash 1.5.0 py36_0", + "simplegeneric 0.8.1 py36_2", + "sip 4.19.8 py36hf484d3e_0", + "six 1.12.0 py36_0", + "snowballstemmer 1.2.1 py36h6febd40_0", + "sortedcontainers 2.1.0 py36_0", + "soupsieve 1.8 py36_0", + "sphinxcontrib 1.0 py36_1", + "sqlalchemy 1.3.1 py36h7b6447c_0", + "tblib 1.3.2 py36h34cf8b6_0", + "testpath 0.4.2 py36_0", + "toolz 0.9.0 py36_0", + "tornado 6.0.2 py36h7b6447c_0", + "typed-ast 1.3.1 py36h7b6447c_0", + "unicodecsv 0.14.1 py36ha668878_0", + "wcwidth 0.1.7 py36hdf4376a_0", + "webencodings 0.5.1 py36_1", + "werkzeug 0.14.1 py36_0", + "wrapt 1.11.1 py36h7b6447c_0", + "wurlitzer 1.0.2 py36_0", + "xlrd 1.2.0 py36_0", + "xlsxwriter 1.1.5 py36_0", + "xlwt 1.3.0 py36h7b00a1f_0", + "zipp 0.3.3 py36_1", + "babel 2.6.0 py36_0", + "backports.os 0.1.1 py36_0", + "backports.shutil_get_terminal_size 1.0.0 py36_2", + "beautifulsoup4 4.7.1 py36_1", + "cffi 1.12.2 py36h2e261b9_1", + "cycler 0.10.0 py36h93f1223_0", + "cytoolz 0.9.0.1 py36h14c3975_1", + "harfbuzz 1.8.8 hffaf4a1_0", + "html5lib 1.0.1 py36_0", + "importlib_metadata 0.8 py36_0", + "jedi 0.13.3 py36_0", + "mkl_random 1.0.2 py36hd81dba3_0", + "multipledispatch 0.6.0 py36_0", + "nltk 3.4 py36_1", + "openpyxl 2.6.1 py36_1", + "packaging 19.0 py36_0", + "partd 0.3.10 py36_1", + "pathlib2 2.3.3 py36_0", + "pexpect 4.6.0 py36_0", + "pillow 5.4.1 py36h34e0f95_0", + "pyqt 5.9.2 py36h05f1152_2", + "pyrsistent 0.14.11 py36h7b6447c_0", + "python-dateutil 2.8.0 py36_0", + "qtawesome 0.5.7 py36_1", + "setuptools 40.8.0 py36_0", + "singledispatch 3.4.0.3 py36h7a266c3_0", + "sortedcollections 1.1.2 py36_0", + "sphinxcontrib-websupport 1.1.0 py36_1", + "sympy 1.3 py36_0", + "terminado 0.8.1 py36_1", + "traitlets 4.3.2 py36h674d592_0", + "zict 0.1.4 py36_0", + "astroid 2.2.5 py36_0", + "bleach 3.1.0 py36_0", + "clyent 1.2.2 py36_1", + "cryptography 2.6.1 py36h1ba5d50_0", + "cython 0.29.6 py36he6710b0_0", + "distributed 1.26.0 py36_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py36h7b6447c_0", + "isort 4.3.16 py36_0", + "jinja2 2.10 py36_0", + "jsonschema 3.0.1 py36_0", + "jupyter_core 4.4.0 py36_0", + "networkx 2.2 py36_1", + "nose 1.3.7 py36_2", + "pango 1.42.4 h049681c_0", + "path.py 11.5.0 py36_0", + "pygments 2.3.1 py36_0", + "pytest 4.3.1 py36_0", + "wheel 0.33.1 py36_0", + "flask 1.0.2 py36_1", + "jupyter_client 5.2.4 py36_0", + "nbformat 4.4.0 py36h31c9010_0", + "pip 19.0.3 py36_0", + "prompt_toolkit 2.0.9 py36_0", + "pylint 2.3.1 py36_0", + "pyopenssl 19.0.0 py36_0", + "pytest-openfiles 0.3.2 py36_0", + "pytest-remotedata 0.3.1 py36_0", + "secretstorage 3.1.1 py36_0", + "ipython 7.4.0 py36h39e3cac_0", + "keyring 18.0.0 py36_0", + "nbconvert 5.4.1 py36_3", + "urllib3 1.24.1 py36_0", + "ipykernel 5.1.0 py36h39e3cac_0", + "requests 2.21.0 py36_0", + "anaconda-client 1.7.2 py36_0", + "jupyter_console 6.0.0 py36_0", + "notebook 5.7.8 py36_0", + "qtconsole 4.4.3 py36_0", + "sphinx 1.8.5 py36_0", + "spyder-kernels 0.4.2 py36_0", + "anaconda-project 0.8.2 py36_0", + "jupyterlab_server 0.2.0 py36_0", + "numpydoc 0.8.0 py36_0", + "widgetsnbextension 3.4.2 py36_0", + "ipywidgets 7.4.2 py36_0", + "jupyterlab 0.35.4 py36hf63ae98_0", + "spyder 3.3.3 py36_0", + "jupyter 1.0.0 py36_7", + "bokeh 1.0.4 py36_0", + "bottleneck 1.2.1 py36h035aef0_1", + "h5py 2.9.0 py36h7918eee_0", + "imageio 2.5.0 py36_0", + "matplotlib 3.0.3 py36h5429711_0", + "mkl_fft 1.0.10 py36ha843d7b_0", + "numpy 1.16.2 py36h7e9f1db_0", + "numba 0.43.1 py36h962f231_0", + "numexpr 2.6.9 py36h9e4a6bb_0", + "pandas 0.24.2 py36he6710b0_0", + "pytest-arraydiff 0.3 py36h39e3cac_0", + "pytest-doctestplus 0.3.0 py36_0", + "pywavelets 1.0.2 py36hdd07704_0", + "scipy 1.2.1 py36h7c811a0_0", + "bkcharts 0.2 py36h735825a_0", + "dask 1.1.4 py36_1", + "patsy 0.5.1 py36_0", + "pytables 3.5.1 py36h71ec239_0", + "pytest-astropy 0.5.0 py36_0", + "scikit-image 0.14.2 py36he6710b0_0", + "scikit-learn 0.20.3 py36hd81dba3_0", + "astropy 3.1.2 py36h7b6447c_0", + "statsmodels 0.9.0 py36h035aef0_0", + "seaborn 0.9.0 py36_0" + ], + "license": "BSD", + "md5": "6a7eb28a3117261c9a591080014bdfd8", + "name": "anaconda", + "namespace": "python", + "sha256": "eb7220eeba42a2e1c2957f913e3c85c713bbaca1aed98f8c9f740a98c27d9692", + "size": 55046, + "subdir": "linux-64", + "timestamp": 1554420441441, + "version": "2019.03" + }, + "anaconda-2019.03-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.12 py37_0", + "anaconda-client 1.7.2 py37_0", + "anaconda-project 0.8.2 py37_0", + "asn1crypto 0.24.0 py37_0", + "astroid 2.2.5 py37_0", + "astropy 3.1.2 py37h7b6447c_0", + "atomicwrites 1.3.0 py37_1", + "attrs 19.1.0 py37_1", + "babel 2.6.0 py37_0", + "backcall 0.1.0 py37_0", + "backports 1.0 py37_1", + "backports.os 0.1.1 py37_0", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "beautifulsoup4 4.7.1 py37_1", + "bitarray 0.8.3 py37h14c3975_0", + "bkcharts 0.2 py37_0", + "blas 1.0 mkl", + "bleach 3.1.0 py37_0", + "blosc 1.15.0 hd408876_0", + "bokeh 1.0.4 py37_0", + "boto 2.49.0 py37_0", + "bottleneck 1.2.1 py37h035aef0_1", + "bzip2 1.0.6 h14c3975_5", + "ca-certificates 2019.1.23 0", + "cairo 1.14.12 h8948797_3", + "certifi 2019.3.9 py37_0", + "cffi 1.12.2 py37h2e261b9_1", + "chardet 3.0.4 py37_1", + "click 7.0 py37_0", + "cloudpickle 0.8.0 py37_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.1 py37_0", + "contextlib2 0.5.5 py37_0", + "cryptography 2.6.1 py37h1ba5d50_0", + "curl 7.64.0 hbc83047_2", + "cycler 0.10.0 py37_0", + "cython 0.29.6 py37he6710b0_0", + "cytoolz 0.9.0.1 py37h14c3975_1", + "dask 1.1.4 py37_1", + "dask-core 1.1.4 py37_1", + "dbus 1.13.6 h746ee38_0", + "decorator 4.4.0 py37_1", + "defusedxml 0.5.0 py37_1", + "distributed 1.26.0 py37_1", + "docutils 0.14 py37_0", + "entrypoints 0.3 py37_0", + "et_xmlfile 1.0.1 py37_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.0.2 py37h14c3975_2", + "filelock 3.0.10 py37_0", + "flask 1.0.2 py37_1", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py37h7b6447c_0", + "glib 2.56.2 hd408876_0", + "glob2 0.6 py37_1", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py37h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.9.0 py37h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.0 py37_2", + "html5lib 1.0.1 py37_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py37_0", + "imageio 2.5.0 py37_0", + "imagesize 1.1.0 py37_0", + "importlib_metadata 0.8 py37_0", + "intel-openmp 2019.3 199", + "ipykernel 5.1.0 py37h39e3cac_0", + "ipython 7.4.0 py37h39e3cac_0", + "ipython_genutils 0.2.0 py37_0", + "ipywidgets 7.4.2 py37_0", + "isort 4.3.16 py37_0", + "itsdangerous 1.1.0 py37_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4 py37_0", + "jedi 0.13.3 py37_0", + "jeepney 0.4 py37_0", + "jinja2 2.10 py37_0", + "jpeg 9b h024ee3a_2", + "jsonschema 3.0.1 py37_0", + "jupyter 1.0.0 py37_7", + "jupyter_client 5.2.4 py37_0", + "jupyter_console 6.0.0 py37_0", + "jupyter_core 4.4.0 py37_0", + "jupyterlab 0.35.4 py37hf63ae98_0", + "jupyterlab_server 0.2.0 py37_0", + "keyring 18.0.0 py37_0", + "kiwisolver 1.0.1 py37hf484d3e_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.3.1 py37h14c3975_2", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.64.0 h20c2e04_2", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 8.2.0 hdf63c60_1", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.36 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.0 h1ba5d50_4", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "libtiff 4.0.10 h2733197_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 he19cac6_0", + "libxslt 1.1.33 h7d1a2b0_0", + "llvmlite 0.28.0 py37hd408876_0", + "locket 0.2.0 py37_1", + "lxml 4.3.2 py37hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py37h7b6447c_0", + "matplotlib 3.0.3 py37h5429711_0", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h7b6447c_0", + "mkl 2019.3 199", + "mkl-service 1.1.2 py37he904b0f_5", + "mkl_fft 1.0.10 py37ha843d7b_0", + "mkl_random 1.0.2 py37hd81dba3_0", + "more-itertools 6.0.0 py37_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py37_0", + "msgpack-python 0.6.1 py37hfd86e86_1", + "multipledispatch 0.6.0 py37_0", + "nbconvert 5.4.1 py37_3", + "nbformat 4.4.0 py37_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.2 py37_1", + "nltk 3.4 py37_1", + "nose 1.3.7 py37_2", + "notebook 5.7.8 py37_0", + "numba 0.43.1 py37h962f231_0", + "numexpr 2.6.9 py37h9e4a6bb_0", + "numpy 1.16.2 py37h7e9f1db_0", + "numpy-base 1.16.2 py37hde5b4d6_0", + "numpydoc 0.8.0 py37_0", + "olefile 0.46 py37_0", + "openpyxl 2.6.1 py37_1", + "openssl 1.1.1b h7b6447c_1", + "packaging 19.0 py37_0", + "pandas 0.24.2 py37he6710b0_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py37_1", + "pango 1.42.4 h049681c_0", + "parso 0.3.4 py37_0", + "partd 0.3.10 py37_1", + "patchelf 0.9 he6710b0_3", + "path.py 11.5.0 py37_0", + "pathlib2 2.3.3 py37_0", + "patsy 0.5.1 py37_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py37_0", + "pexpect 4.6.0 py37_0", + "pickleshare 0.7.5 py37_0", + "pillow 5.4.1 py37h34e0f95_0", + "pip 19.0.3 py37_0", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py37_0", + "pluggy 0.9.0 py37_0", + "ply 3.11 py37_0", + "prometheus_client 0.6.0 py37_0", + "prompt_toolkit 2.0.9 py37_0", + "psutil 5.6.1 py37h7b6447c_0", + "ptyprocess 0.6.0 py37_0", + "py 1.8.0 py37_0", + "py-lief 0.9.0 py37h7725739_2", + "pycodestyle 2.5.0 py37_0", + "pycosat 0.6.3 py37h14c3975_0", + "pycparser 2.19 py37_0", + "pycrypto 2.6.1 py37h14c3975_9", + "pycurl 7.43.0.2 py37h1ba5d50_0", + "pyflakes 2.1.1 py37_0", + "pygments 2.3.1 py37_0", + "pylint 2.3.1 py37_0", + "pyodbc 4.0.26 py37he6710b0_0", + "pyopenssl 19.0.0 py37_0", + "pyparsing 2.3.1 py37_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.14.11 py37h7b6447c_0", + "pysocks 1.6.8 py37_0", + "pytables 3.5.1 py37h71ec239_0", + "pytest 4.3.1 py37_0", + "pytest-arraydiff 0.3 py37h39e3cac_0", + "pytest-astropy 0.5.0 py37_0", + "pytest-doctestplus 0.3.0 py37_0", + "pytest-openfiles 0.3.2 py37_0", + "pytest-remotedata 0.3.1 py37_0", + "python 3.7.3 h0371630_0", + "python-dateutil 2.8.0 py37_0", + "python-libarchive-c 2.8 py37_6", + "pytz 2018.9 py37_0", + "pywavelets 1.0.2 py37hdd07704_0", + "pyyaml 5.1 py37h7b6447c_0", + "pyzmq 18.0.0 py37he6710b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.5.7 py37_1", + "qtconsole 4.4.3 py37_0", + "qtpy 1.7.0 py37_1", + "readline 7.0 h7b6447c_5", + "requests 2.21.0 py37_0", + "rope 0.12.0 py37_0", + "ruamel_yaml 0.15.46 py37h14c3975_0", + "scikit-image 0.14.2 py37he6710b0_0", + "scikit-learn 0.20.3 py37hd81dba3_0", + "scipy 1.2.1 py37h7c811a0_0", + "seaborn 0.9.0 py37_0", + "secretstorage 3.1.1 py37_0", + "send2trash 1.5.0 py37_0", + "setuptools 40.8.0 py37_0", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.4.0.3 py37_0", + "sip 4.19.8 py37hf484d3e_0", + "six 1.12.0 py37_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 1.2.1 py37_0", + "sortedcollections 1.1.2 py37_0", + "sortedcontainers 2.1.0 py37_0", + "soupsieve 1.8 py37_0", + "sphinx 1.8.5 py37_0", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-websupport 1.1.0 py37_1", + "spyder 3.3.3 py37_0", + "spyder-kernels 0.4.2 py37_0", + "sqlalchemy 1.3.1 py37h7b6447c_0", + "sqlite 3.27.2 h7b6447c_0", + "statsmodels 0.9.0 py37h035aef0_0", + "sympy 1.3 py37_0", + "tblib 1.3.2 py37_0", + "terminado 0.8.1 py37_1", + "testpath 0.4.2 py37_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.9.0 py37_0", + "tornado 6.0.2 py37h7b6447c_0", + "tqdm 4.31.1 py37_1", + "traitlets 4.3.2 py37_0", + "unicodecsv 0.14.1 py37_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.1 py37_0", + "wcwidth 0.1.7 py37_0", + "webencodings 0.5.1 py37_1", + "werkzeug 0.14.1 py37_0", + "wheel 0.33.1 py37_0", + "widgetsnbextension 3.4.2 py37_0", + "wrapt 1.11.1 py37h7b6447c_0", + "wurlitzer 1.0.2 py37_0", + "xlrd 1.2.0 py37_0", + "xlsxwriter 1.1.5 py37_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.3.1 he6710b0_3", + "zict 0.1.4 py37_0", + "zipp 0.3.3 py37_1", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "caa622f4390a17496c6c6d4a604e1356", + "name": "anaconda", + "namespace": "python", + "sha256": "d3e1392144ed8a9c83e3024da91869496c873b4d3900a0b0ff16d67fcdd9af51", + "size": 10359, + "subdir": "linux-64", + "timestamp": 1554399120759, + "version": "2019.03" + }, + "anaconda-2019.07-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py27_0", + "anaconda-client 1.7.2 py27_0", + "anaconda-project 0.8.3 py_0", + "asn1crypto 0.24.0 py27_0", + "astroid 1.6.5 py27_0", + "astropy 2.0.9 py27hdd07704_0", + "atomicwrites 1.3.0 py27_1", + "attrs 19.1.0 py27_1", + "babel 2.7.0 py_0", + "backports 1.0 py_2", + "backports.functools_lru_cache 1.5 py_2", + "backports.os 0.1.1 py27_0", + "backports.shutil_get_terminal_size 1.0.0 py27_2", + "backports_abc 0.5 py27_0", + "beautifulsoup4 4.7.1 py27_1", + "bitarray 0.9.3 py27h7b6447c_0", + "bkcharts 0.2 py27_0", + "blas 1.0 mkl", + "bleach 3.1.0 py27_0", + "blosc 1.16.3 hd408876_0", + "bokeh 1.2.0 py27_0", + "boto 2.49.0 py27_0", + "bottleneck 1.2.1 py27h035aef0_1", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2019.5.15 0", + "cairo 1.14.12 h8948797_3", + "cdecimal 2.3 py27h14c3975_3", + "certifi 2019.6.16 py27_0", + "cffi 1.12.3 py27h2e261b9_0", + "chardet 3.0.4 py27_1", + "click 7.0 py27_0", + "cloudpickle 1.2.1 py_0", + "clyent 1.2.2 py27_1", + "colorama 0.4.1 py27_0", + "configparser 3.7.4 py27_0", + "contextlib2 0.5.5 py27_0", + "cryptography 2.7 py27h1ba5d50_0", + "curl 7.65.2 hbc83047_0", + "cycler 0.10.0 py27_0", + "cython 0.29.12 py27he6710b0_0", + "cytoolz 0.10.0 py27h7b6447c_0", + "dask 1.2.2 py_0", + "dask-core 1.2.2 py_0", + "dbus 1.13.6 h746ee38_0", + "decorator 4.4.0 py27_1", + "defusedxml 0.6.0 py_0", + "distributed 1.28.1 py27_0", + "docutils 0.14 py27_0", + "entrypoints 0.3 py27_0", + "enum34 1.1.6 py27_1", + "et_xmlfile 1.0.1 py27_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.1.0 py27h7b6447c_0", + "filelock 3.0.12 py_0", + "flask 1.1.1 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "funcsigs 1.0.2 py27_0", + "functools32 3.2.3.2 py27_1", + "future 0.17.1 py27_0", + "futures 3.3.0 py27_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py27h7b6447c_0", + "glib 2.56.2 hd408876_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py27h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py27h7b6447c_0", + "grin 1.2.1 py27_4", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.9.0 py27h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.0 py27_2", + "html5lib 1.0.1 py27_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py27_0", + "imageio 2.5.0 py27_0", + "imagesize 1.1.0 py27_0", + "importlib_metadata 0.17 py27_1", + "intel-openmp 2019.4 243", + "ipaddress 1.0.22 py27_0", + "ipykernel 4.10.0 py27_0", + "ipython 5.8.0 py27_0", + "ipython_genutils 0.2.0 py27_0", + "ipywidgets 7.5.0 py_0", + "isort 4.3.21 py27_0", + "itsdangerous 1.1.0 py27_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.13.3 py27_0", + "jinja2 2.10.1 py27_0", + "jpeg 9b h024ee3a_2", + "jsonschema 3.0.1 py27_0", + "jupyter 1.0.0 py27_7", + "jupyter_client 5.3.1 py_0", + "jupyter_console 5.2.0 py27_1", + "jupyter_core 4.5.0 py_0", + "jupyterlab 0.33.11 py27_0", + "jupyterlab_launcher 0.11.2 py27h28b3542_0", + "kiwisolver 1.1.0 py27he6710b0_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.4.1 py27h7b6447c_0", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.65.2 h20c2e04_0", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.2 h1ba5d50_0", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.0.10 h2733197_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 hea5a465_1", + "libxslt 1.1.33 h7d1a2b0_0", + "linecache2 1.0.0 py27_0", + "llvmlite 0.29.0 py27hd408876_0", + "locket 0.2.0 py27_1", + "lxml 4.3.4 py27hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py27h7b6447c_0", + "matplotlib 2.2.3 py27hb69df0a_0", + "mccabe 0.6.1 py27_1", + "mistune 0.8.4 py27h7b6447c_0", + "mkl 2019.4 243", + "mkl-service 2.0.2 py27h7b6447c_0", + "mkl_fft 1.0.12 py27ha843d7b_0", + "mkl_random 1.0.2 py27hd81dba3_0", + "mock 3.0.5 py27_0", + "more-itertools 5.0.0 py27_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py27_0", + "msgpack-python 0.6.1 py27hfd86e86_1", + "multipledispatch 0.6.0 py27_0", + "nbconvert 5.5.0 py_0", + "nbformat 4.4.0 py27_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.2 py27_1", + "nltk 3.4.4 py27_0", + "nose 1.3.7 py27_2", + "notebook 5.7.8 py27_0", + "numba 0.44.1 py27h962f231_0", + "numexpr 2.6.9 py27h9e4a6bb_0", + "numpy 1.16.4 py27h7e9f1db_0", + "numpy-base 1.16.4 py27hde5b4d6_0", + "numpydoc 0.9.1 py_0", + "olefile 0.46 py27_0", + "openpyxl 2.6.2 py_0", + "openssl 1.1.1c h7b6447c_1", + "packaging 19.0 py27_0", + "pandas 0.24.2 py27he6710b0_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py27_1", + "pango 1.42.4 h049681c_0", + "parso 0.5.0 py_0", + "partd 1.0.0 py_0", + "patchelf 0.9 he6710b0_3", + "path.py 11.5.0 py27_0", + "pathlib2 2.3.4 py27_0", + "patsy 0.5.1 py27_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py27_0", + "pexpect 4.7.0 py27_0", + "pickleshare 0.7.5 py27_0", + "pillow 6.1.0 py27h34e0f95_0", + "pip 19.1.1 py27_0", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py27_0", + "pluggy 0.12.0 py_0", + "ply 3.11 py27_0", + "prometheus_client 0.7.1 py_0", + "prompt_toolkit 1.0.15 py27_0", + "psutil 5.6.3 py27h7b6447c_0", + "ptyprocess 0.6.0 py27_0", + "py 1.8.0 py27_0", + "py-lief 0.9.0 py27h7725739_2", + "pycairo 1.18.1 py27h2a1e443_0", + "pycodestyle 2.5.0 py27_0", + "pycosat 0.6.3 py27h14c3975_0", + "pycparser 2.19 py27_0", + "pycrypto 2.6.1 py27h14c3975_9", + "pycurl 7.43.0.3 py27h1ba5d50_0", + "pyflakes 2.1.1 py27_0", + "pygments 2.4.2 py_0", + "pylint 1.9.2 py27_0", + "pyodbc 4.0.26 py27he6710b0_0", + "pyopenssl 19.0.0 py27_0", + "pyparsing 2.4.0 py_0", + "pyqt 5.9.2 py27h05f1152_2", + "pyrsistent 0.14.11 py27h7b6447c_0", + "pysocks 1.7.0 py27_0", + "pytables 3.5.2 py27h71ec239_1", + "pytest 4.6.2 py27_0", + "python 2.7.16 h9bab390_0", + "python-dateutil 2.8.0 py27_0", + "python-libarchive-c 2.8 py27_11", + "pytz 2019.1 py_0", + "pywavelets 1.0.3 py27hdd07704_1", + "pyyaml 5.1.1 py27h7b6447c_0", + "pyzmq 18.0.0 py27he6710b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.5.7 py27_1", + "qtconsole 4.5.1 py_0", + "qtpy 1.8.0 py_0", + "readline 7.0 h7b6447c_5", + "requests 2.22.0 py27_0", + "rope 0.14.0 py_0", + "ruamel_yaml 0.15.46 py27h14c3975_0", + "scandir 1.10.0 py27h7b6447c_0", + "scikit-image 0.14.2 py27he6710b0_0", + "scikit-learn 0.20.3 py27hd81dba3_0", + "scipy 1.2.1 py27h7c811a0_0", + "seaborn 0.9.0 py27_0", + "send2trash 1.5.0 py27_0", + "setuptools 41.0.1 py27_0", + "simplegeneric 0.8.1 py27_2", + "singledispatch 3.4.0.3 py27_0", + "sip 4.19.8 py27hf484d3e_0", + "six 1.12.0 py27_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 1.9.0 py_0", + "sortedcollections 1.1.2 py27_0", + "sortedcontainers 2.1.0 py27_0", + "soupsieve 1.8 py27_0", + "sphinx 1.8.5 py27_0", + "sphinxcontrib 1.0 py27_1", + "sphinxcontrib-websupport 1.1.2 py_0", + "spyder 3.3.6 py27_0", + "spyder-kernels 0.5.1 py27_0", + "sqlalchemy 1.3.5 py27h7b6447c_0", + "sqlite 3.29.0 h7b6447c_0", + "ssl_match_hostname 3.7.0.1 py27_0", + "statsmodels 0.10.0 py27hdd07704_0", + "subprocess32 3.5.4 py27h7b6447c_0", + "sympy 1.4 py27_0", + "tblib 1.4.0 py_0", + "terminado 0.8.2 py27_0", + "testpath 0.4.2 py27_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.10.0 py_0", + "tornado 5.1.1 py27h7b6447c_0", + "tqdm 4.32.1 py_0", + "traceback2 1.4.0 py27_0", + "traitlets 4.3.2 py27_0", + "typing 3.7.4 py27_0", + "unicodecsv 0.14.1 py27_0", + "unittest2 1.1.0 py27_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.2 py27_0", + "wcwidth 0.1.7 py27_0", + "webencodings 0.5.1 py27_1", + "werkzeug 0.15.4 py_0", + "wheel 0.33.4 py27_0", + "widgetsnbextension 3.5.0 py27_0", + "wrapt 1.11.2 py27h7b6447c_0", + "wurlitzer 1.0.2 py27_0", + "xlrd 1.2.0 py27_0", + "xlsxwriter 1.1.8 py_0", + "xlwt 1.3.0 py27_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.3.1 he6710b0_3", + "zict 1.0.0 py_0", + "zipp 0.5.1 py_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "99057fd72f33ef9e473f1e69beef4c5e", + "name": "anaconda", + "namespace": "python", + "sha256": "71d6f21ad607a4b6eb57a9a3ee77d2a4c64b0eac82cb6f4d2c6443f1314b1aba", + "size": 13123, + "subdir": "linux-64", + "timestamp": 1563737544632, + "version": "2019.07" + }, + "anaconda-2019.07-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py36_0", + "anaconda-client 1.7.2 py36_0", + "anaconda-project 0.8.3 py_0", + "asn1crypto 0.24.0 py36_0", + "astroid 2.2.5 py36_0", + "astropy 3.2.1 py36h7b6447c_0", + "atomicwrites 1.3.0 py36_1", + "attrs 19.1.0 py36_1", + "babel 2.7.0 py_0", + "backcall 0.1.0 py36_0", + "backports 1.0 py_2", + "backports.os 0.1.1 py36_0", + "backports.shutil_get_terminal_size 1.0.0 py36_2", + "beautifulsoup4 4.7.1 py36_1", + "bitarray 0.9.3 py36h7b6447c_0", + "bkcharts 0.2 py36_0", + "blas 1.0 mkl", + "bleach 3.1.0 py36_0", + "blosc 1.16.3 hd408876_0", + "bokeh 1.2.0 py36_0", + "boto 2.49.0 py36_0", + "bottleneck 1.2.1 py36h035aef0_1", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2019.5.15 0", + "cairo 1.14.12 h8948797_3", + "certifi 2019.6.16 py36_0", + "cffi 1.12.3 py36h2e261b9_0", + "chardet 3.0.4 py36_1", + "click 7.0 py36_0", + "cloudpickle 1.2.1 py_0", + "clyent 1.2.2 py36_1", + "colorama 0.4.1 py36_0", + "contextlib2 0.5.5 py36_0", + "cryptography 2.7 py36h1ba5d50_0", + "curl 7.65.2 hbc83047_0", + "cycler 0.10.0 py36_0", + "cython 0.29.12 py36he6710b0_0", + "cytoolz 0.10.0 py36h7b6447c_0", + "dask 2.1.0 py_0", + "dask-core 2.1.0 py_0", + "dbus 1.13.6 h746ee38_0", + "decorator 4.4.0 py36_1", + "defusedxml 0.6.0 py_0", + "distributed 2.1.0 py_0", + "docutils 0.14 py36_0", + "entrypoints 0.3 py36_0", + "et_xmlfile 1.0.1 py36_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.1.0 py36h7b6447c_0", + "filelock 3.0.12 py_0", + "flask 1.1.1 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py36h7b6447c_0", + "glib 2.56.2 hd408876_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py36h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py36h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.9.0 py36h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.0 py36_2", + "html5lib 1.0.1 py36_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py36_0", + "imageio 2.5.0 py36_0", + "imagesize 1.1.0 py36_0", + "importlib_metadata 0.17 py36_1", + "intel-openmp 2019.4 243", + "ipykernel 5.1.1 py36h39e3cac_0", + "ipython 7.6.1 py36h39e3cac_0", + "ipython_genutils 0.2.0 py36_0", + "ipywidgets 7.5.0 py_0", + "isort 4.3.21 py36_0", + "itsdangerous 1.1.0 py36_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.13.3 py36_0", + "jeepney 0.4 py36_0", + "jinja2 2.10.1 py36_0", + "joblib 0.13.2 py36_0", + "jpeg 9b h024ee3a_2", + "json5 0.8.4 py_0", + "jsonschema 3.0.1 py36_0", + "jupyter 1.0.0 py36_7", + "jupyter_client 5.3.1 py_0", + "jupyter_console 6.0.0 py36_0", + "jupyter_core 4.5.0 py_0", + "jupyterlab 1.0.2 py36hf63ae98_0", + "jupyterlab_server 1.0.0 py_0", + "keyring 18.0.0 py36_0", + "kiwisolver 1.1.0 py36he6710b0_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.4.1 py36h7b6447c_0", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.65.2 h20c2e04_0", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.2 h1ba5d50_0", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.0.10 h2733197_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 hea5a465_1", + "libxslt 1.1.33 h7d1a2b0_0", + "llvmlite 0.29.0 py36hd408876_0", + "locket 0.2.0 py36_1", + "lxml 4.3.4 py36hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py36h7b6447c_0", + "matplotlib 3.1.0 py36h5429711_0", + "mccabe 0.6.1 py36_1", + "mistune 0.8.4 py36h7b6447c_0", + "mkl 2019.4 243", + "mkl-service 2.0.2 py36h7b6447c_0", + "mkl_fft 1.0.12 py36ha843d7b_0", + "mkl_random 1.0.2 py36hd81dba3_0", + "mock 3.0.5 py36_0", + "more-itertools 7.0.0 py36_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py36_0", + "msgpack-python 0.6.1 py36hfd86e86_1", + "multipledispatch 0.6.0 py36_0", + "nbconvert 5.5.0 py_0", + "nbformat 4.4.0 py36_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.3 py_0", + "nltk 3.4.4 py36_0", + "nose 1.3.7 py36_2", + "notebook 6.0.0 py36_0", + "numba 0.45.0 py36h962f231_0", + "numexpr 2.6.9 py36h9e4a6bb_0", + "numpy 1.16.4 py36h7e9f1db_0", + "numpy-base 1.16.4 py36hde5b4d6_0", + "numpydoc 0.9.1 py_0", + "olefile 0.46 py36_0", + "openpyxl 2.6.2 py_0", + "openssl 1.1.1c h7b6447c_1", + "packaging 19.0 py36_0", + "pandas 0.24.2 py36he6710b0_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py36_1", + "pango 1.42.4 h049681c_0", + "parso 0.5.0 py_0", + "partd 1.0.0 py_0", + "patchelf 0.9 he6710b0_3", + "path.py 12.0.1 py_0", + "pathlib2 2.3.4 py36_0", + "patsy 0.5.1 py36_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py36_0", + "pexpect 4.7.0 py36_0", + "pickleshare 0.7.5 py36_0", + "pillow 6.1.0 py36h34e0f95_0", + "pip 19.1.1 py36_0", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py36_0", + "pluggy 0.12.0 py_0", + "ply 3.11 py36_0", + "prometheus_client 0.7.1 py_0", + "prompt_toolkit 2.0.9 py36_0", + "psutil 5.6.3 py36h7b6447c_0", + "ptyprocess 0.6.0 py36_0", + "py 1.8.0 py36_0", + "py-lief 0.9.0 py36h7725739_2", + "pycodestyle 2.5.0 py36_0", + "pycosat 0.6.3 py36h14c3975_0", + "pycparser 2.19 py36_0", + "pycrypto 2.6.1 py36h14c3975_9", + "pycurl 7.43.0.3 py36h1ba5d50_0", + "pyflakes 2.1.1 py36_0", + "pygments 2.4.2 py_0", + "pylint 2.3.1 py36_0", + "pyodbc 4.0.26 py36he6710b0_0", + "pyopenssl 19.0.0 py36_0", + "pyparsing 2.4.0 py_0", + "pyqt 5.9.2 py36h05f1152_2", + "pyrsistent 0.14.11 py36h7b6447c_0", + "pysocks 1.7.0 py36_0", + "pytables 3.5.2 py36h71ec239_1", + "pytest 5.0.1 py36_0", + "pytest-arraydiff 0.3 py36h39e3cac_0", + "pytest-astropy 0.5.0 py36_0", + "pytest-doctestplus 0.3.0 py36_0", + "pytest-openfiles 0.3.2 py36_0", + "pytest-remotedata 0.3.1 py36_0", + "python 3.6.8 h0371630_0", + "python-dateutil 2.8.0 py36_0", + "python-libarchive-c 2.8 py36_11", + "pytz 2019.1 py_0", + "pywavelets 1.0.3 py36hdd07704_1", + "pyyaml 5.1.1 py36h7b6447c_0", + "pyzmq 18.0.0 py36he6710b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.5.7 py36_1", + "qtconsole 4.5.1 py_0", + "qtpy 1.8.0 py_0", + "readline 7.0 h7b6447c_5", + "requests 2.22.0 py36_0", + "rope 0.14.0 py_0", + "ruamel_yaml 0.15.46 py36h14c3975_0", + "scikit-image 0.15.0 py36he6710b0_0", + "scikit-learn 0.21.2 py36hd81dba3_0", + "scipy 1.3.0 py36h7c811a0_0", + "seaborn 0.9.0 py36_0", + "secretstorage 3.1.1 py36_0", + "send2trash 1.5.0 py36_0", + "setuptools 41.0.1 py36_0", + "simplegeneric 0.8.1 py36_2", + "singledispatch 3.4.0.3 py36_0", + "sip 4.19.8 py36hf484d3e_0", + "six 1.12.0 py36_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 1.9.0 py_0", + "sortedcollections 1.1.2 py36_0", + "sortedcontainers 2.1.0 py36_0", + "soupsieve 1.8 py36_0", + "sphinx 2.1.2 py_0", + "sphinxcontrib 1.0 py36_1", + "sphinxcontrib-applehelp 1.0.1 py_0", + "sphinxcontrib-devhelp 1.0.1 py_0", + "sphinxcontrib-htmlhelp 1.0.2 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.2 py_0", + "sphinxcontrib-serializinghtml 1.1.3 py_0", + "sphinxcontrib-websupport 1.1.2 py_0", + "spyder 3.3.6 py36_0", + "spyder-kernels 0.5.1 py36_0", + "sqlalchemy 1.3.5 py36h7b6447c_0", + "sqlite 3.29.0 h7b6447c_0", + "statsmodels 0.10.0 py36hdd07704_0", + "sympy 1.4 py36_0", + "tblib 1.4.0 py_0", + "terminado 0.8.2 py36_0", + "testpath 0.4.2 py36_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.10.0 py_0", + "tornado 6.0.3 py36h7b6447c_0", + "tqdm 4.32.1 py_0", + "traitlets 4.3.2 py36_0", + "typed-ast 1.3.4 py36h7b6447c_0", + "unicodecsv 0.14.1 py36_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.2 py36_0", + "wcwidth 0.1.7 py36_0", + "webencodings 0.5.1 py36_1", + "werkzeug 0.15.4 py_0", + "wheel 0.33.4 py36_0", + "widgetsnbextension 3.5.0 py36_0", + "wrapt 1.11.2 py36h7b6447c_0", + "wurlitzer 1.0.2 py36_0", + "xlrd 1.2.0 py36_0", + "xlsxwriter 1.1.8 py_0", + "xlwt 1.3.0 py36_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.3.1 he6710b0_3", + "zict 1.0.0 py_0", + "zipp 0.5.1 py_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "9d762bfaec5ec3f707f03170b3a14e02", + "name": "anaconda", + "namespace": "python", + "sha256": "0dd0c4387ce121ccf5f69fbefea97e8054304edb8535db4fb4ed6aa4a8c222e9", + "size": 13048, + "subdir": "linux-64", + "timestamp": 1563823219641, + "version": "2019.07" + }, + "anaconda-2019.07-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.7.2 py37_0", + "anaconda-project 0.8.3 py_0", + "asn1crypto 0.24.0 py37_0", + "astroid 2.2.5 py37_0", + "astropy 3.2.1 py37h7b6447c_0", + "atomicwrites 1.3.0 py37_1", + "attrs 19.1.0 py37_1", + "babel 2.7.0 py_0", + "backcall 0.1.0 py37_0", + "backports 1.0 py_2", + "backports.os 0.1.1 py37_0", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "beautifulsoup4 4.7.1 py37_1", + "bitarray 0.9.3 py37h7b6447c_0", + "bkcharts 0.2 py37_0", + "blas 1.0 mkl", + "bleach 3.1.0 py37_0", + "blosc 1.16.3 hd408876_0", + "bokeh 1.2.0 py37_0", + "boto 2.49.0 py37_0", + "bottleneck 1.2.1 py37h035aef0_1", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2019.5.15 0", + "cairo 1.14.12 h8948797_3", + "certifi 2019.6.16 py37_0", + "cffi 1.12.3 py37h2e261b9_0", + "chardet 3.0.4 py37_1", + "click 7.0 py37_0", + "cloudpickle 1.2.1 py_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.1 py37_0", + "contextlib2 0.5.5 py37_0", + "cryptography 2.7 py37h1ba5d50_0", + "curl 7.65.2 hbc83047_0", + "cycler 0.10.0 py37_0", + "cython 0.29.12 py37he6710b0_0", + "cytoolz 0.10.0 py37h7b6447c_0", + "dask 2.1.0 py_0", + "dask-core 2.1.0 py_0", + "dbus 1.13.6 h746ee38_0", + "decorator 4.4.0 py37_1", + "defusedxml 0.6.0 py_0", + "distributed 2.1.0 py_0", + "docutils 0.14 py37_0", + "entrypoints 0.3 py37_0", + "et_xmlfile 1.0.1 py37_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.1.0 py37h7b6447c_0", + "filelock 3.0.12 py_0", + "flask 1.1.1 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py37h7b6447c_0", + "glib 2.56.2 hd408876_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py37h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.9.0 py37h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.0 py37_2", + "html5lib 1.0.1 py37_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py37_0", + "imageio 2.5.0 py37_0", + "imagesize 1.1.0 py37_0", + "importlib_metadata 0.17 py37_1", + "intel-openmp 2019.4 243", + "ipykernel 5.1.1 py37h39e3cac_0", + "ipython 7.6.1 py37h39e3cac_0", + "ipython_genutils 0.2.0 py37_0", + "ipywidgets 7.5.0 py_0", + "isort 4.3.21 py37_0", + "itsdangerous 1.1.0 py37_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.13.3 py37_0", + "jeepney 0.4 py37_0", + "jinja2 2.10.1 py37_0", + "joblib 0.13.2 py37_0", + "jpeg 9b h024ee3a_2", + "json5 0.8.4 py_0", + "jsonschema 3.0.1 py37_0", + "jupyter 1.0.0 py37_7", + "jupyter_client 5.3.1 py_0", + "jupyter_console 6.0.0 py37_0", + "jupyter_core 4.5.0 py_0", + "jupyterlab 1.0.2 py37hf63ae98_0", + "jupyterlab_server 1.0.0 py_0", + "keyring 18.0.0 py37_0", + "kiwisolver 1.1.0 py37he6710b0_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.4.1 py37h7b6447c_0", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.65.2 h20c2e04_0", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.2 h1ba5d50_0", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.0.10 h2733197_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 hea5a465_1", + "libxslt 1.1.33 h7d1a2b0_0", + "llvmlite 0.29.0 py37hd408876_0", + "locket 0.2.0 py37_1", + "lxml 4.3.4 py37hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py37h7b6447c_0", + "matplotlib 3.1.0 py37h5429711_0", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h7b6447c_0", + "mkl 2019.4 243", + "mkl-service 2.0.2 py37h7b6447c_0", + "mkl_fft 1.0.12 py37ha843d7b_0", + "mkl_random 1.0.2 py37hd81dba3_0", + "mock 3.0.5 py37_0", + "more-itertools 7.0.0 py37_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py37_0", + "msgpack-python 0.6.1 py37hfd86e86_1", + "multipledispatch 0.6.0 py37_0", + "nbconvert 5.5.0 py_0", + "nbformat 4.4.0 py37_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.3 py_0", + "nltk 3.4.4 py37_0", + "nose 1.3.7 py37_2", + "notebook 6.0.0 py37_0", + "numba 0.44.1 py37h962f231_0", + "numexpr 2.6.9 py37h9e4a6bb_0", + "numpy 1.16.4 py37h7e9f1db_0", + "numpy-base 1.16.4 py37hde5b4d6_0", + "numpydoc 0.9.1 py_0", + "olefile 0.46 py37_0", + "openpyxl 2.6.2 py_0", + "openssl 1.1.1c h7b6447c_1", + "packaging 19.0 py37_0", + "pandas 0.24.2 py37he6710b0_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py37_1", + "pango 1.42.4 h049681c_0", + "parso 0.5.0 py_0", + "partd 1.0.0 py_0", + "patchelf 0.9 he6710b0_3", + "path.py 12.0.1 py_0", + "pathlib2 2.3.4 py37_0", + "patsy 0.5.1 py37_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py37_0", + "pexpect 4.7.0 py37_0", + "pickleshare 0.7.5 py37_0", + "pillow 6.1.0 py37h34e0f95_0", + "pip 19.1.1 py37_0", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py37_0", + "pluggy 0.12.0 py_0", + "ply 3.11 py37_0", + "prometheus_client 0.7.1 py_0", + "prompt_toolkit 2.0.9 py37_0", + "psutil 5.6.3 py37h7b6447c_0", + "ptyprocess 0.6.0 py37_0", + "py 1.8.0 py37_0", + "py-lief 0.9.0 py37h7725739_2", + "pycodestyle 2.5.0 py37_0", + "pycosat 0.6.3 py37h14c3975_0", + "pycparser 2.19 py37_0", + "pycrypto 2.6.1 py37h14c3975_9", + "pycurl 7.43.0.3 py37h1ba5d50_0", + "pyflakes 2.1.1 py37_0", + "pygments 2.4.2 py_0", + "pylint 2.3.1 py37_0", + "pyodbc 4.0.26 py37he6710b0_0", + "pyopenssl 19.0.0 py37_0", + "pyparsing 2.4.0 py_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.14.11 py37h7b6447c_0", + "pysocks 1.7.0 py37_0", + "pytables 3.5.2 py37h71ec239_1", + "pytest 5.0.1 py37_0", + "pytest-arraydiff 0.3 py37h39e3cac_0", + "pytest-astropy 0.5.0 py37_0", + "pytest-doctestplus 0.3.0 py37_0", + "pytest-openfiles 0.3.2 py37_0", + "pytest-remotedata 0.3.1 py37_0", + "python 3.7.3 h0371630_0", + "python-dateutil 2.8.0 py37_0", + "python-libarchive-c 2.8 py37_11", + "pytz 2019.1 py_0", + "pywavelets 1.0.3 py37hdd07704_1", + "pyyaml 5.1.1 py37h7b6447c_0", + "pyzmq 18.0.0 py37he6710b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.5.7 py37_1", + "qtconsole 4.5.1 py_0", + "qtpy 1.8.0 py_0", + "readline 7.0 h7b6447c_5", + "requests 2.22.0 py37_0", + "rope 0.14.0 py_0", + "ruamel_yaml 0.15.46 py37h14c3975_0", + "scikit-image 0.15.0 py37he6710b0_0", + "scikit-learn 0.21.2 py37hd81dba3_0", + "scipy 1.3.0 py37h7c811a0_0", + "seaborn 0.9.0 py37_0", + "secretstorage 3.1.1 py37_0", + "send2trash 1.5.0 py37_0", + "setuptools 41.0.1 py37_0", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.4.0.3 py37_0", + "sip 4.19.8 py37hf484d3e_0", + "six 1.12.0 py37_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 1.9.0 py_0", + "sortedcollections 1.1.2 py37_0", + "sortedcontainers 2.1.0 py37_0", + "soupsieve 1.8 py37_0", + "sphinx 2.1.2 py_0", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-applehelp 1.0.1 py_0", + "sphinxcontrib-devhelp 1.0.1 py_0", + "sphinxcontrib-htmlhelp 1.0.2 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.2 py_0", + "sphinxcontrib-serializinghtml 1.1.3 py_0", + "sphinxcontrib-websupport 1.1.2 py_0", + "spyder 3.3.6 py37_0", + "spyder-kernels 0.5.1 py37_0", + "sqlalchemy 1.3.5 py37h7b6447c_0", + "sqlite 3.29.0 h7b6447c_0", + "statsmodels 0.10.0 py37hdd07704_0", + "sympy 1.4 py37_0", + "tblib 1.4.0 py_0", + "terminado 0.8.2 py37_0", + "testpath 0.4.2 py37_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.10.0 py_0", + "tornado 6.0.3 py37h7b6447c_0", + "tqdm 4.32.1 py_0", + "traitlets 4.3.2 py37_0", + "unicodecsv 0.14.1 py37_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.2 py37_0", + "wcwidth 0.1.7 py37_0", + "webencodings 0.5.1 py37_1", + "werkzeug 0.15.4 py_0", + "wheel 0.33.4 py37_0", + "widgetsnbextension 3.5.0 py37_0", + "wrapt 1.11.2 py37h7b6447c_0", + "wurlitzer 1.0.2 py37_0", + "xlrd 1.2.0 py37_0", + "xlsxwriter 1.1.8 py_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.3.1 he6710b0_3", + "zict 1.0.0 py_0", + "zipp 0.5.1 py_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "a75936fa95d64cafcefd88accf6298c5", + "name": "anaconda", + "namespace": "python", + "sha256": "f8027246978b961c4635ac509094c5f4357a6d4ec9fe574bc2391394245752cb", + "size": 12952, + "subdir": "linux-64", + "timestamp": 1563737521446, + "version": "2019.07" + }, + "anaconda-2019.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py27_0", + "anaconda-client 1.7.2 py27_0", + "anaconda-project 0.8.3 py_0", + "asn1crypto 1.0.1 py27_0", + "astroid 1.6.5 py27_0", + "astropy 2.0.9 py27hdd07704_0", + "atomicwrites 1.3.0 py27_1", + "attrs 19.2.0 py_0", + "babel 2.7.0 py_0", + "backports 1.0 py_2", + "backports.functools_lru_cache 1.5 py_2", + "backports.os 0.1.1 py27_0", + "backports.shutil_get_terminal_size 1.0.0 py27_2", + "backports_abc 0.5 py27_0", + "beautifulsoup4 4.8.0 py27_0", + "bitarray 1.0.1 py27h7b6447c_0", + "bkcharts 0.2 py27_0", + "blas 1.0 mkl", + "bleach 3.1.0 py27_0", + "blosc 1.16.3 hd408876_0", + "bokeh 1.3.4 py27_0", + "boto 2.49.0 py27_0", + "bottleneck 1.2.1 py27h035aef0_1", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2019.8.28 0", + "cairo 1.14.12 h8948797_3", + "cdecimal 2.3 py27h14c3975_3", + "certifi 2019.9.11 py27_0", + "cffi 1.12.3 py27h2e261b9_0", + "chardet 3.0.4 py27_1003", + "click 7.0 py27_0", + "cloudpickle 1.2.2 py_0", + "clyent 1.2.2 py27_1", + "colorama 0.4.1 py27_0", + "configparser 4.0.2 py27_0", + "contextlib2 0.6.0 py_0", + "cryptography 2.7 py27h1ba5d50_0", + "curl 7.65.3 hbc83047_0", + "cycler 0.10.0 py27_0", + "cython 0.29.13 py27he6710b0_0", + "cytoolz 0.10.0 py27h7b6447c_0", + "dask 1.2.2 py_0", + "dask-core 1.2.2 py_0", + "dbus 1.13.6 h746ee38_0", + "decorator 4.4.0 py27_1", + "defusedxml 0.6.0 py_0", + "distributed 1.28.1 py27_0", + "docutils 0.15.2 py27_0", + "entrypoints 0.3 py27_0", + "enum34 1.1.6 py27_1", + "et_xmlfile 1.0.1 py27_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.1.0 py27h7b6447c_0", + "filelock 3.0.12 py_0", + "flask 1.1.1 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "funcsigs 1.0.2 py27_0", + "functools32 3.2.3.2 py27_1", + "future 0.17.1 py27_0", + "futures 3.3.0 py27_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py27h7b6447c_0", + "glib 2.56.2 hd408876_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py27h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py27h7b6447c_0", + "grin 1.2.1 py27_4", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.9.0 py27h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.0.1 py27_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py27_0", + "imageio 2.6.0 py27_0", + "imagesize 1.1.0 py27_0", + "importlib_metadata 0.23 py27_0", + "intel-openmp 2019.4 243", + "ipaddress 1.0.22 py27_0", + "ipykernel 4.10.0 py27_0", + "ipython 5.8.0 py27_0", + "ipython_genutils 0.2.0 py27_0", + "ipywidgets 7.5.1 py_0", + "isort 4.3.21 py27_0", + "itsdangerous 1.1.0 py27_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.15.1 py27_0", + "jinja2 2.10.3 py_0", + "jpeg 9b h024ee3a_2", + "jsonschema 3.0.2 py27_0", + "jupyter 1.0.0 py27_7", + "jupyter_client 5.3.3 py27_1", + "jupyter_console 5.2.0 py27_1", + "jupyter_core 4.5.0 py_0", + "jupyterlab 0.33.11 py27_0", + "jupyterlab_launcher 0.11.2 py27h28b3542_0", + "kiwisolver 1.1.0 py27he6710b0_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.4.2 py27h7b6447c_0", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.65.3 h20c2e04_0", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.2 h1ba5d50_0", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.0.10 h2733197_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 hea5a465_1", + "libxslt 1.1.33 h7d1a2b0_0", + "linecache2 1.0.0 py27_0", + "llvmlite 0.29.0 py27hd408876_0", + "locket 0.2.0 py27_1", + "lxml 4.4.1 py27hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py27h7b6447c_0", + "matplotlib 2.2.3 py27hb69df0a_0", + "mccabe 0.6.1 py27_1", + "mistune 0.8.4 py27h7b6447c_0", + "mkl 2019.4 243", + "mkl-service 2.3.0 py27he904b0f_0", + "mkl_fft 1.0.14 py27ha843d7b_0", + "mkl_random 1.1.0 py27hd6b4f25_0", + "mock 3.0.5 py27_0", + "more-itertools 5.0.0 py27_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py27_0", + "msgpack-python 0.6.1 py27hfd86e86_1", + "multipledispatch 0.6.0 py27_0", + "nbconvert 5.6.0 py27_1", + "nbformat 4.4.0 py27_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.2 py27_1", + "nltk 3.4.5 py27_0", + "nose 1.3.7 py27_2", + "notebook 5.7.8 py27_0", + "numba 0.45.1 py27h962f231_0", + "numexpr 2.7.0 py27h9e4a6bb_0", + "numpy 1.16.5 py27h7e9f1db_0", + "numpy-base 1.16.5 py27hde5b4d6_0", + "numpydoc 0.9.1 py_0", + "olefile 0.46 py27_0", + "openpyxl 2.6.3 py_0", + "openssl 1.1.1d h7b6447c_2", + "packaging 19.2 py_0", + "pandas 0.24.2 py27he6710b0_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py27_1", + "pango 1.42.4 h049681c_0", + "parso 0.5.1 py_0", + "partd 1.0.0 py_0", + "patchelf 0.9 he6710b0_3", + "path.py 11.5.0 py27_0", + "pathlib2 2.3.5 py27_0", + "patsy 0.5.1 py27_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py27_0", + "pexpect 4.7.0 py27_0", + "pickleshare 0.7.5 py27_0", + "pillow 6.2.0 py27h34e0f95_0", + "pip 19.2.3 py27_0", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py27_0", + "pluggy 0.13.0 py27_0", + "ply 3.11 py27_0", + "prometheus_client 0.7.1 py_0", + "prompt_toolkit 1.0.15 py27_0", + "psutil 5.6.3 py27h7b6447c_0", + "ptyprocess 0.6.0 py27_0", + "py 1.8.0 py27_0", + "py-lief 0.9.0 py27h7725739_2", + "pycairo 1.18.1 py27h2a1e443_0", + "pycodestyle 2.5.0 py27_0", + "pycosat 0.6.3 py27h14c3975_0", + "pycparser 2.19 py27_0", + "pycrypto 2.6.1 py27h14c3975_9", + "pycurl 7.43.0.3 py27h1ba5d50_0", + "pyflakes 2.1.1 py27_0", + "pygments 2.4.2 py_0", + "pylint 1.9.2 py27_0", + "pyodbc 4.0.27 py27he6710b0_0", + "pyopenssl 19.0.0 py27_0", + "pyparsing 2.4.2 py_0", + "pyqt 5.9.2 py27h05f1152_2", + "pyrsistent 0.15.4 py27h7b6447c_0", + "pysocks 1.7.1 py27_0", + "pytables 3.5.2 py27h71ec239_1", + "pytest 4.6.2 py27_0", + "python 2.7.16 h9bab390_7", + "python-dateutil 2.8.0 py27_0", + "python-libarchive-c 2.8 py27_13", + "pytz 2019.3 py_0", + "pywavelets 1.0.3 py27hdd07704_1", + "pyyaml 5.1.2 py27h7b6447c_0", + "pyzmq 18.1.0 py27he6710b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.6.0 py_0", + "qtconsole 4.5.5 py_0", + "qtpy 1.9.0 py_0", + "readline 7.0 h7b6447c_5", + "requests 2.22.0 py27_0", + "ripgrep 0.10.0 hc07d326_0", + "rope 0.14.0 py_0", + "ruamel_yaml 0.15.46 py27h14c3975_0", + "scandir 1.10.0 py27h7b6447c_0", + "scikit-image 0.14.2 py27he6710b0_0", + "scikit-learn 0.20.3 py27hd81dba3_0", + "scipy 1.2.1 py27h7c811a0_0", + "seaborn 0.9.0 py27_0", + "send2trash 1.5.0 py27_0", + "setuptools 41.4.0 py27_0", + "simplegeneric 0.8.1 py27_2", + "singledispatch 3.4.0.3 py27_0", + "sip 4.19.8 py27hf484d3e_0", + "six 1.12.0 py27_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.1.2 py27_0", + "sortedcontainers 2.1.0 py27_0", + "soupsieve 1.9.3 py27_0", + "sphinx 1.8.5 py27_0", + "sphinxcontrib 1.0 py27_1", + "sphinxcontrib-websupport 1.1.2 py_0", + "spyder 3.3.6 py27_0", + "spyder-kernels 0.5.2 py27_0", + "sqlalchemy 1.3.9 py27h7b6447c_0", + "sqlite 3.30.0 h7b6447c_0", + "ssl_match_hostname 3.7.0.1 py27_0", + "statsmodels 0.10.1 py27hdd07704_0", + "subprocess32 3.5.4 py27h7b6447c_0", + "sympy 1.4 py27_0", + "tbb 2019.4 hfd86e86_0", + "tblib 1.4.0 py_0", + "terminado 0.8.2 py27_0", + "testpath 0.4.2 py27_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.10.0 py_0", + "tornado 5.1.1 py27h7b6447c_0", + "tqdm 4.36.1 py_0", + "traceback2 1.4.0 py27_0", + "traitlets 4.3.3 py27_0", + "typing 3.7.4.1 py27_0", + "unicodecsv 0.14.1 py27_0", + "unittest2 1.1.0 py27_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.2 py27_0", + "wcwidth 0.1.7 py27_0", + "webencodings 0.5.1 py27_1", + "werkzeug 0.16.0 py_0", + "wheel 0.33.6 py27_0", + "widgetsnbextension 3.5.1 py27_0", + "wrapt 1.11.2 py27h7b6447c_0", + "wurlitzer 1.0.3 py27_0", + "xlrd 1.2.0 py27_0", + "xlsxwriter 1.2.1 py_0", + "xlwt 1.3.0 py27_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.3.1 he6710b0_3", + "zict 1.0.0 py_0", + "zipp 0.6.0 py_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "4105321cbb0a63a74cad083706c1f2dd", + "name": "anaconda", + "namespace": "python", + "sha256": "ae9a79e460e97c239d1af2bd802abdeee410f6207df38536636d281aa12e1887", + "size": 13198, + "subdir": "linux-64", + "timestamp": 1570553783701, + "version": "2019.10" + }, + "anaconda-2019.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py36_0", + "anaconda-client 1.7.2 py36_0", + "anaconda-project 0.8.3 py_0", + "asn1crypto 1.0.1 py36_0", + "astroid 2.3.1 py36_0", + "astropy 3.2.1 py36h7b6447c_0", + "atomicwrites 1.3.0 py36_1", + "attrs 19.2.0 py_0", + "babel 2.7.0 py_0", + "backcall 0.1.0 py36_0", + "backports 1.0 py_2", + "backports.os 0.1.1 py36_0", + "backports.shutil_get_terminal_size 1.0.0 py36_2", + "beautifulsoup4 4.8.0 py36_0", + "bitarray 1.0.1 py36h7b6447c_0", + "bkcharts 0.2 py36_0", + "blas 1.0 mkl", + "bleach 3.1.0 py36_0", + "blosc 1.16.3 hd408876_0", + "bokeh 1.3.4 py36_0", + "boto 2.49.0 py36_0", + "bottleneck 1.2.1 py36h035aef0_1", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2019.8.28 0", + "cairo 1.14.12 h8948797_3", + "certifi 2019.9.11 py36_0", + "cffi 1.12.3 py36h2e261b9_0", + "chardet 3.0.4 py36_1003", + "click 7.0 py36_0", + "cloudpickle 1.2.2 py_0", + "clyent 1.2.2 py36_1", + "colorama 0.4.1 py36_0", + "contextlib2 0.6.0 py_0", + "cryptography 2.7 py36h1ba5d50_0", + "curl 7.65.3 hbc83047_0", + "cycler 0.10.0 py36_0", + "cython 0.29.13 py36he6710b0_0", + "cytoolz 0.10.0 py36h7b6447c_0", + "dask 2.5.2 py_0", + "dask-core 2.5.2 py_0", + "dbus 1.13.6 h746ee38_0", + "decorator 4.4.0 py36_1", + "defusedxml 0.6.0 py_0", + "distributed 2.5.2 py_0", + "docutils 0.15.2 py36_0", + "entrypoints 0.3 py36_0", + "et_xmlfile 1.0.1 py36_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.1.0 py36h7b6447c_0", + "filelock 3.0.12 py_0", + "flask 1.1.1 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "fsspec 0.5.2 py_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py36h7b6447c_0", + "glib 2.56.2 hd408876_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py36h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py36h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.9.0 py36h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.0.1 py36_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py36_0", + "imageio 2.6.0 py36_0", + "imagesize 1.1.0 py36_0", + "importlib_metadata 0.23 py36_0", + "intel-openmp 2019.4 243", + "ipykernel 5.1.2 py36h39e3cac_0", + "ipython 7.8.0 py36h39e3cac_0", + "ipython_genutils 0.2.0 py36_0", + "ipywidgets 7.5.1 py_0", + "isort 4.3.21 py36_0", + "itsdangerous 1.1.0 py36_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.15.1 py36_0", + "jeepney 0.4.1 py_0", + "jinja2 2.10.3 py_0", + "joblib 0.13.2 py36_0", + "jpeg 9b h024ee3a_2", + "json5 0.8.5 py_0", + "jsonschema 3.0.2 py36_0", + "jupyter 1.0.0 py36_7", + "jupyter_client 5.3.3 py36_1", + "jupyter_console 6.0.0 py36_0", + "jupyter_core 4.5.0 py_0", + "jupyterlab 1.1.4 pyhf63ae98_0", + "jupyterlab_server 1.0.6 py_0", + "keyring 18.0.0 py36_0", + "kiwisolver 1.1.0 py36he6710b0_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.4.2 py36h7b6447c_0", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.65.3 h20c2e04_0", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.2 h1ba5d50_0", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.0.10 h2733197_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 hea5a465_1", + "libxslt 1.1.33 h7d1a2b0_0", + "llvmlite 0.29.0 py36hd408876_0", + "locket 0.2.0 py36_1", + "lxml 4.4.1 py36hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py36h7b6447c_0", + "matplotlib 3.1.1 py36h5429711_0", + "mccabe 0.6.1 py36_1", + "mistune 0.8.4 py36h7b6447c_0", + "mkl 2019.4 243", + "mkl-service 2.3.0 py36he904b0f_0", + "mkl_fft 1.0.14 py36ha843d7b_0", + "mkl_random 1.1.0 py36hd6b4f25_0", + "mock 3.0.5 py36_0", + "more-itertools 7.2.0 py36_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py36_0", + "msgpack-python 0.6.1 py36hfd86e86_1", + "multipledispatch 0.6.0 py36_0", + "nbconvert 5.6.0 py36_1", + "nbformat 4.4.0 py36_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.3 py_0", + "nltk 3.4.5 py36_0", + "nose 1.3.7 py36_2", + "notebook 6.0.1 py36_0", + "numba 0.45.1 py36h962f231_0", + "numexpr 2.7.0 py36h9e4a6bb_0", + "numpy 1.17.2 py36haad9e8e_0", + "numpy-base 1.17.2 py36hde5b4d6_0", + "numpydoc 0.9.1 py_0", + "olefile 0.46 py36_0", + "openpyxl 3.0.0 py_0", + "openssl 1.1.1d h7b6447c_2", + "packaging 19.2 py_0", + "pandas 0.25.1 py36he6710b0_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py36_1", + "pango 1.42.4 h049681c_0", + "parso 0.5.1 py_0", + "partd 1.0.0 py_0", + "patchelf 0.9 he6710b0_3", + "path.py 12.0.1 py_0", + "pathlib2 2.3.5 py36_0", + "patsy 0.5.1 py36_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py36_0", + "pexpect 4.7.0 py36_0", + "pickleshare 0.7.5 py36_0", + "pillow 6.2.0 py36h34e0f95_0", + "pip 19.2.3 py36_0", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py36_0", + "pluggy 0.13.0 py36_0", + "ply 3.11 py36_0", + "prometheus_client 0.7.1 py_0", + "prompt_toolkit 2.0.10 py_0", + "psutil 5.6.3 py36h7b6447c_0", + "ptyprocess 0.6.0 py36_0", + "py 1.8.0 py36_0", + "py-lief 0.9.0 py36h7725739_2", + "pycodestyle 2.5.0 py36_0", + "pycosat 0.6.3 py36h14c3975_0", + "pycparser 2.19 py36_0", + "pycrypto 2.6.1 py36h14c3975_9", + "pycurl 7.43.0.3 py36h1ba5d50_0", + "pyflakes 2.1.1 py36_0", + "pygments 2.4.2 py_0", + "pylint 2.4.2 py36_0", + "pyodbc 4.0.27 py36he6710b0_0", + "pyopenssl 19.0.0 py36_0", + "pyparsing 2.4.2 py_0", + "pyqt 5.9.2 py36h05f1152_2", + "pyrsistent 0.15.4 py36h7b6447c_0", + "pysocks 1.7.1 py36_0", + "pytables 3.5.2 py36h71ec239_1", + "pytest 5.2.1 py36_0", + "pytest-arraydiff 0.3 py36h39e3cac_0", + "pytest-astropy 0.5.0 py36_0", + "pytest-doctestplus 0.4.0 py_0", + "pytest-openfiles 0.4.0 py_0", + "pytest-remotedata 0.3.2 py36_0", + "python 3.6.9 h265db76_0", + "python-dateutil 2.8.0 py36_0", + "python-libarchive-c 2.8 py36_13", + "pytz 2019.3 py_0", + "pywavelets 1.0.3 py36hdd07704_1", + "pyyaml 5.1.2 py36h7b6447c_0", + "pyzmq 18.1.0 py36he6710b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.6.0 py_0", + "qtconsole 4.5.5 py_0", + "qtpy 1.9.0 py_0", + "readline 7.0 h7b6447c_5", + "requests 2.22.0 py36_0", + "ripgrep 0.10.0 hc07d326_0", + "rope 0.14.0 py_0", + "ruamel_yaml 0.15.46 py36h14c3975_0", + "scikit-image 0.15.0 py36he6710b0_0", + "scikit-learn 0.21.3 py36hd81dba3_0", + "scipy 1.3.1 py36h7c811a0_0", + "seaborn 0.9.0 py36_0", + "secretstorage 3.1.1 py36_0", + "send2trash 1.5.0 py36_0", + "setuptools 41.4.0 py36_0", + "simplegeneric 0.8.1 py36_2", + "singledispatch 3.4.0.3 py36_0", + "sip 4.19.8 py36hf484d3e_0", + "six 1.12.0 py36_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.1.2 py36_0", + "sortedcontainers 2.1.0 py36_0", + "soupsieve 1.9.3 py36_0", + "sphinx 2.2.0 py_0", + "sphinxcontrib 1.0 py36_1", + "sphinxcontrib-applehelp 1.0.1 py_0", + "sphinxcontrib-devhelp 1.0.1 py_0", + "sphinxcontrib-htmlhelp 1.0.2 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.2 py_0", + "sphinxcontrib-serializinghtml 1.1.3 py_0", + "sphinxcontrib-websupport 1.1.2 py_0", + "spyder 3.3.6 py36_0", + "spyder-kernels 0.5.2 py36_0", + "sqlalchemy 1.3.9 py36h7b6447c_0", + "sqlite 3.30.0 h7b6447c_0", + "statsmodels 0.10.1 py36hdd07704_0", + "sympy 1.4 py36_0", + "tbb 2019.4 hfd86e86_0", + "tblib 1.4.0 py_0", + "terminado 0.8.2 py36_0", + "testpath 0.4.2 py36_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.10.0 py_0", + "tornado 6.0.3 py36h7b6447c_0", + "tqdm 4.36.1 py_0", + "traitlets 4.3.3 py36_0", + "typed-ast 1.4.0 py36h7b6447c_0", + "unicodecsv 0.14.1 py36_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.2 py36_0", + "wcwidth 0.1.7 py36_0", + "webencodings 0.5.1 py36_1", + "werkzeug 0.16.0 py_0", + "wheel 0.33.6 py36_0", + "widgetsnbextension 3.5.1 py36_0", + "wrapt 1.11.2 py36h7b6447c_0", + "wurlitzer 1.0.3 py36_0", + "xlrd 1.2.0 py36_0", + "xlsxwriter 1.2.1 py_0", + "xlwt 1.3.0 py36_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.3.1 he6710b0_3", + "zict 1.0.0 py_0", + "zipp 0.6.0 py_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "4b9854d8856767807c502003018521e5", + "name": "anaconda", + "namespace": "python", + "sha256": "dcfccf561db615e2ada627cb8c64c65808a3c64c3c9fbff341391a58dc16275e", + "size": 13129, + "subdir": "linux-64", + "timestamp": 1570484044367, + "version": "2019.10" + }, + "anaconda-2019.10-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.7.2 py37_0", + "anaconda-project 0.8.3 py_0", + "asn1crypto 1.0.1 py37_0", + "astroid 2.3.1 py37_0", + "astropy 3.2.2 py37h7b6447c_0", + "atomicwrites 1.3.0 py37_1", + "attrs 19.2.0 py_0", + "babel 2.7.0 py_0", + "backcall 0.1.0 py37_0", + "backports 1.0 py_2", + "backports.os 0.1.1 py37_0", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "beautifulsoup4 4.8.0 py37_0", + "bitarray 1.0.1 py37h7b6447c_0", + "bkcharts 0.2 py37_0", + "blas 1.0 mkl", + "bleach 3.1.0 py37_0", + "blosc 1.16.3 hd408876_0", + "bokeh 1.3.4 py37_0", + "boto 2.49.0 py37_0", + "bottleneck 1.2.1 py37h035aef0_1", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2019.8.28 0", + "cairo 1.14.12 h8948797_3", + "certifi 2019.9.11 py37_0", + "cffi 1.12.3 py37h2e261b9_0", + "chardet 3.0.4 py37_1003", + "click 7.0 py37_0", + "cloudpickle 1.2.2 py_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.1 py37_0", + "contextlib2 0.6.0 py_0", + "cryptography 2.7 py37h1ba5d50_0", + "curl 7.65.3 hbc83047_0", + "cycler 0.10.0 py37_0", + "cython 0.29.13 py37he6710b0_0", + "cytoolz 0.10.0 py37h7b6447c_0", + "dask 2.5.2 py_0", + "dask-core 2.5.2 py_0", + "dbus 1.13.6 h746ee38_0", + "decorator 4.4.0 py37_1", + "defusedxml 0.6.0 py_0", + "distributed 2.5.2 py_0", + "docutils 0.15.2 py37_0", + "entrypoints 0.3 py37_0", + "et_xmlfile 1.0.1 py37_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.1.0 py37h7b6447c_0", + "filelock 3.0.12 py_0", + "flask 1.1.1 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "fsspec 0.5.2 py_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py37h7b6447c_0", + "glib 2.56.2 hd408876_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py37h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.9.0 py37h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.0.1 py37_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py37_0", + "imageio 2.6.0 py37_0", + "imagesize 1.1.0 py37_0", + "importlib_metadata 0.23 py37_0", + "intel-openmp 2019.4 243", + "ipykernel 5.1.2 py37h39e3cac_0", + "ipython 7.8.0 py37h39e3cac_0", + "ipython_genutils 0.2.0 py37_0", + "ipywidgets 7.5.1 py_0", + "isort 4.3.21 py37_0", + "itsdangerous 1.1.0 py37_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.15.1 py37_0", + "jeepney 0.4.1 py_0", + "jinja2 2.10.3 py_0", + "joblib 0.13.2 py37_0", + "jpeg 9b h024ee3a_2", + "json5 0.8.5 py_0", + "jsonschema 3.0.2 py37_0", + "jupyter 1.0.0 py37_7", + "jupyter_client 5.3.3 py37_1", + "jupyter_console 6.0.0 py37_0", + "jupyter_core 4.5.0 py_0", + "jupyterlab 1.1.4 pyhf63ae98_0", + "jupyterlab_server 1.0.6 py_0", + "keyring 18.0.0 py37_0", + "kiwisolver 1.1.0 py37he6710b0_0", + "krb5 1.16.1 h173b8e3_7", + "lazy-object-proxy 1.4.2 py37h7b6447c_0", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.65.3 h20c2e04_0", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libssh2 1.8.2 h1ba5d50_0", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.0.10 h2733197_2", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 hea5a465_1", + "libxslt 1.1.33 h7d1a2b0_0", + "llvmlite 0.29.0 py37hd408876_0", + "locket 0.2.0 py37_1", + "lxml 4.4.1 py37hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py37h7b6447c_0", + "matplotlib 3.1.1 py37h5429711_0", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h7b6447c_0", + "mkl 2019.4 243", + "mkl-service 2.3.0 py37he904b0f_0", + "mkl_fft 1.0.14 py37ha843d7b_0", + "mkl_random 1.1.0 py37hd6b4f25_0", + "mock 3.0.5 py37_0", + "more-itertools 7.2.0 py37_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py37_0", + "msgpack-python 0.6.1 py37hfd86e86_1", + "multipledispatch 0.6.0 py37_0", + "nbconvert 5.6.0 py37_1", + "nbformat 4.4.0 py37_0", + "ncurses 6.1 he6710b0_1", + "networkx 2.3 py_0", + "nltk 3.4.5 py37_0", + "nose 1.3.7 py37_2", + "notebook 6.0.1 py37_0", + "numba 0.45.1 py37h962f231_0", + "numexpr 2.7.0 py37h9e4a6bb_0", + "numpy 1.17.2 py37haad9e8e_0", + "numpy-base 1.17.2 py37hde5b4d6_0", + "numpydoc 0.9.1 py_0", + "olefile 0.46 py37_0", + "openpyxl 3.0.0 py_0", + "openssl 1.1.1d h7b6447c_2", + "packaging 19.2 py_0", + "pandas 0.25.1 py37he6710b0_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py37_1", + "pango 1.42.4 h049681c_0", + "parso 0.5.1 py_0", + "partd 1.0.0 py_0", + "patchelf 0.9 he6710b0_3", + "path.py 12.0.1 py_0", + "pathlib2 2.3.5 py37_0", + "patsy 0.5.1 py37_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py37_0", + "pexpect 4.7.0 py37_0", + "pickleshare 0.7.5 py37_0", + "pillow 6.2.0 py37h34e0f95_0", + "pip 19.2.3 py37_0", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py37_0", + "pluggy 0.13.0 py37_0", + "ply 3.11 py37_0", + "prometheus_client 0.7.1 py_0", + "prompt_toolkit 2.0.10 py_0", + "psutil 5.6.3 py37h7b6447c_0", + "ptyprocess 0.6.0 py37_0", + "py 1.8.0 py37_0", + "py-lief 0.9.0 py37h7725739_2", + "pycodestyle 2.5.0 py37_0", + "pycosat 0.6.3 py37h14c3975_0", + "pycparser 2.19 py37_0", + "pycrypto 2.6.1 py37h14c3975_9", + "pycurl 7.43.0.3 py37h1ba5d50_0", + "pyflakes 2.1.1 py37_0", + "pygments 2.4.2 py_0", + "pylint 2.4.2 py37_0", + "pyodbc 4.0.27 py37he6710b0_0", + "pyopenssl 19.0.0 py37_0", + "pyparsing 2.4.2 py_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.15.4 py37h7b6447c_0", + "pysocks 1.7.1 py37_0", + "pytables 3.5.2 py37h71ec239_1", + "pytest 5.2.1 py37_0", + "pytest-arraydiff 0.3 py37h39e3cac_0", + "pytest-astropy 0.5.0 py37_0", + "pytest-doctestplus 0.4.0 py_0", + "pytest-openfiles 0.4.0 py_0", + "pytest-remotedata 0.3.2 py37_0", + "python 3.7.4 h265db76_1", + "python-dateutil 2.8.0 py37_0", + "python-libarchive-c 2.8 py37_13", + "pytz 2019.3 py_0", + "pywavelets 1.0.3 py37hdd07704_1", + "pyyaml 5.1.2 py37h7b6447c_0", + "pyzmq 18.1.0 py37he6710b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.6.0 py_0", + "qtconsole 4.5.5 py_0", + "qtpy 1.9.0 py_0", + "readline 7.0 h7b6447c_5", + "requests 2.22.0 py37_0", + "ripgrep 0.10.0 hc07d326_0", + "rope 0.14.0 py_0", + "ruamel_yaml 0.15.46 py37h14c3975_0", + "scikit-image 0.15.0 py37he6710b0_0", + "scikit-learn 0.21.3 py37hd81dba3_0", + "scipy 1.3.1 py37h7c811a0_0", + "seaborn 0.9.0 py37_0", + "secretstorage 3.1.1 py37_0", + "send2trash 1.5.0 py37_0", + "setuptools 41.4.0 py37_0", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.4.0.3 py37_0", + "sip 4.19.8 py37hf484d3e_0", + "six 1.12.0 py37_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.1.2 py37_0", + "sortedcontainers 2.1.0 py37_0", + "soupsieve 1.9.3 py37_0", + "sphinx 2.2.0 py_0", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-applehelp 1.0.1 py_0", + "sphinxcontrib-devhelp 1.0.1 py_0", + "sphinxcontrib-htmlhelp 1.0.2 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.2 py_0", + "sphinxcontrib-serializinghtml 1.1.3 py_0", + "sphinxcontrib-websupport 1.1.2 py_0", + "spyder 3.3.6 py37_0", + "spyder-kernels 0.5.2 py37_0", + "sqlalchemy 1.3.9 py37h7b6447c_0", + "sqlite 3.30.0 h7b6447c_0", + "statsmodels 0.10.1 py37hdd07704_0", + "sympy 1.4 py37_0", + "tbb 2019.4 hfd86e86_0", + "tblib 1.4.0 py_0", + "terminado 0.8.2 py37_0", + "testpath 0.4.2 py37_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.10.0 py_0", + "tornado 6.0.3 py37h7b6447c_0", + "tqdm 4.36.1 py_0", + "traitlets 4.3.3 py37_0", + "unicodecsv 0.14.1 py37_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.24.2 py37_0", + "wcwidth 0.1.7 py37_0", + "webencodings 0.5.1 py37_1", + "werkzeug 0.16.0 py_0", + "wheel 0.33.6 py37_0", + "widgetsnbextension 3.5.1 py37_0", + "wrapt 1.11.2 py37h7b6447c_0", + "wurlitzer 1.0.3 py37_0", + "xlrd 1.2.0 py37_0", + "xlsxwriter 1.2.1 py_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "zeromq 4.3.1 he6710b0_3", + "zict 1.0.0 py_0", + "zipp 0.6.0 py_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "b507ded14f423e02304f8f5c72e22b28", + "name": "anaconda", + "namespace": "python", + "sha256": "f37409e87062930fee2b7abbc38482c556b6d04517bbefa71d0fa6a0bc23ba39", + "size": 13045, + "subdir": "linux-64", + "timestamp": 1570553776012, + "version": "2019.10" + }, + "anaconda-2020.02-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py36_0", + "anaconda-client 1.7.2 py36_0", + "anaconda-project 0.8.4 py_0", + "argh 0.26.2 py36_0", + "asn1crypto 1.3.0 py36_0", + "astroid 2.3.3 py36_0", + "astropy 4.0 py36h7b6447c_0", + "atomicwrites 1.3.0 py36_1", + "attrs 19.3.0 py_0", + "autopep8 1.4.4 py_0", + "babel 2.8.0 py_0", + "backcall 0.1.0 py36_0", + "backports 1.0 py_2", + "backports.shutil_get_terminal_size 1.0.0 py36_2", + "beautifulsoup4 4.8.2 py36_0", + "bitarray 1.2.1 py36h7b6447c_0", + "bkcharts 0.2 py36_0", + "blas 1.0 mkl", + "bleach 3.1.0 py36_0", + "blosc 1.16.3 hd408876_0", + "bokeh 1.4.0 py36_0", + "boto 2.49.0 py36_0", + "bottleneck 1.3.2 py36heb32a55_0", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2020.1.1 0", + "cairo 1.14.12 h8948797_3", + "certifi 2019.11.28 py36_0", + "cffi 1.14.0 py36h2e261b9_0", + "chardet 3.0.4 py36_1003", + "click 7.0 py36_0", + "cloudpickle 1.3.0 py_0", + "clyent 1.2.2 py36_1", + "colorama 0.4.3 py_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 2.8 py36h1ba5d50_0", + "curl 7.68.0 hbc83047_0", + "cycler 0.10.0 py36_0", + "cython 0.29.15 py36he6710b0_0", + "cytoolz 0.10.1 py36h7b6447c_0", + "dask 2.11.0 py_0", + "dask-core 2.11.0 py_0", + "dbus 1.13.12 h746ee38_0", + "decorator 4.4.1 py_0", + "defusedxml 0.6.0 py_0", + "diff-match-patch 20181111 py_0", + "distributed 2.11.0 py36_0", + "docutils 0.16 py36_0", + "entrypoints 0.3 py36_0", + "et_xmlfile 1.0.1 py36_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.1.0 py36h7b6447c_0", + "filelock 3.0.12 py_0", + "flake8 3.7.9 py36_0", + "flask 1.1.1 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "fsspec 0.6.2 py_0", + "future 0.18.2 py36_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py36h7b6447c_0", + "glib 2.63.1 h5a9c865_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py36h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py36h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.10.0 py36h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.0.1 py36_0", + "hypothesis 5.5.4 py_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py36_0", + "imageio 2.6.1 py36_0", + "imagesize 1.2.0 py_0", + "importlib_metadata 1.5.0 py36_0", + "intel-openmp 2020.0 166", + "intervaltree 3.0.2 py_0", + "ipykernel 5.1.4 py36h39e3cac_0", + "ipython 7.12.0 py36h5ca1d4c_0", + "ipython_genutils 0.2.0 py36_0", + "ipywidgets 7.5.1 py_0", + "isort 4.3.21 py36_0", + "itsdangerous 1.1.0 py36_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.14.1 py36_0", + "jeepney 0.4.2 py_0", + "jinja2 2.11.1 py_0", + "joblib 0.14.1 py_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.1 py_0", + "jsonschema 3.2.0 py36_0", + "jupyter 1.0.0 py36_7", + "jupyter_client 5.3.4 py36_0", + "jupyter_console 6.1.0 py_0", + "jupyter_core 4.6.1 py36_0", + "jupyterlab 1.2.6 pyhf63ae98_0", + "jupyterlab_server 1.0.6 py_0", + "keyring 21.1.0 py36_0", + "kiwisolver 1.1.0 py36he6710b0_0", + "krb5 1.17.1 h173b8e3_0", + "lazy-object-proxy 1.4.3 py36h7b6447c_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.68.0 h20c2e04_0", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libspatialindex 1.9.3 he6710b0_0", + "libssh2 1.8.2 h1ba5d50_0", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_0", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 hea5a465_1", + "libxslt 1.1.33 h7d1a2b0_0", + "llvmlite 0.31.0 py36hd408876_0", + "locket 0.2.0 py36_1", + "lxml 4.5.0 py36hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py36h7b6447c_0", + "matplotlib 3.1.3 py36_0", + "matplotlib-base 3.1.3 py36hef1b27d_0", + "mccabe 0.6.1 py36_1", + "mistune 0.8.4 py36h7b6447c_0", + "mkl 2020.0 166", + "mkl-service 2.3.0 py36he904b0f_0", + "mkl_fft 1.0.15 py36ha843d7b_0", + "mkl_random 1.1.0 py36hd6b4f25_0", + "mock 4.0.1 py_0", + "more-itertools 8.2.0 py_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py36_0", + "msgpack-python 0.6.1 py36hfd86e86_1", + "multipledispatch 0.6.0 py36_0", + "nbconvert 5.6.1 py36_0", + "nbformat 5.0.4 py_0", + "ncurses 6.2 he6710b0_0", + "networkx 2.4 py_0", + "nltk 3.4.5 py36_0", + "nose 1.3.7 py36_2", + "notebook 6.0.3 py36_0", + "numba 0.48.0 py36h0573a6f_0", + "numexpr 2.7.1 py36h423224d_0", + "numpy 1.18.1 py36h4f9e942_0", + "numpy-base 1.18.1 py36hde5b4d6_1", + "numpydoc 0.9.2 py_0", + "olefile 0.46 py36_0", + "openpyxl 3.0.3 py_0", + "openssl 1.1.1d h7b6447c_4", + "packaging 20.1 py_0", + "pandas 1.0.1 py36h0573a6f_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py36_1", + "pango 1.42.4 h049681c_0", + "parso 0.5.2 py_0", + "partd 1.1.0 py_0", + "patchelf 0.10 he6710b0_0", + "path 13.1.0 py36_0", + "path.py 12.4.0 0", + "pathlib2 2.3.5 py36_0", + "pathtools 0.1.2 py_1", + "patsy 0.5.1 py36_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py36_0", + "pexpect 4.8.0 py36_0", + "pickleshare 0.7.5 py36_0", + "pillow 7.0.0 py36hb39fc2d_0", + "pip 20.0.2 py36_1", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py36_0", + "pluggy 0.13.1 py36_0", + "ply 3.11 py36_0", + "prometheus_client 0.7.1 py_0", + "prompt_toolkit 3.0.3 py_0", + "psutil 5.6.7 py36h7b6447c_0", + "ptyprocess 0.6.0 py36_0", + "py 1.8.1 py_0", + "py-lief 0.9.0 py36h7725739_2", + "pycodestyle 2.5.0 py36_0", + "pycosat 0.6.3 py36h7b6447c_0", + "pycparser 2.19 py36_0", + "pycrypto 2.6.1 py36h14c3975_9", + "pycurl 7.43.0.5 py36h1ba5d50_0", + "pydocstyle 4.0.1 py_0", + "pyflakes 2.1.1 py36_0", + "pygments 2.5.2 py_0", + "pylint 2.4.4 py36_0", + "pyodbc 4.0.30 py36he6710b0_0", + "pyopenssl 19.1.0 py36_0", + "pyparsing 2.4.6 py_0", + "pyqt 5.9.2 py36h05f1152_2", + "pyrsistent 0.15.7 py36h7b6447c_0", + "pysocks 1.7.1 py36_0", + "pytables 3.6.1 py36h71ec239_0", + "pytest 5.3.5 py36_0", + "pytest-arraydiff 0.3 py36h39e3cac_0", + "pytest-astropy 0.8.0 py_0", + "pytest-astropy-header 0.1.2 py_0", + "pytest-doctestplus 0.5.0 py_0", + "pytest-openfiles 0.4.0 py_0", + "pytest-remotedata 0.3.2 py36_0", + "python 3.6.10 h0371630_0", + "python-dateutil 2.8.1 py_0", + "python-jsonrpc-server 0.3.4 py_0", + "python-language-server 0.31.7 py36_0", + "python-libarchive-c 2.8 py36_13", + "pytz 2019.3 py_0", + "pywavelets 1.1.1 py36h7b6447c_0", + "pyxdg 0.26 py_0", + "pyyaml 5.3 py36h7b6447c_0", + "pyzmq 18.1.1 py36he6710b0_0", + "qdarkstyle 2.8 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.6.1 py_0", + "qtconsole 4.6.0 py_1", + "qtpy 1.9.0 py_0", + "readline 7.0 h7b6447c_5", + "requests 2.22.0 py36_1", + "ripgrep 11.0.2 he32d670_0", + "rope 0.16.0 py_0", + "rtree 0.9.3 py36_0", + "ruamel_yaml 0.15.87 py36h7b6447c_0", + "scikit-image 0.16.2 py36h0573a6f_0", + "scikit-learn 0.22.1 py36hd81dba3_0", + "scipy 1.4.1 py36h0b6359f_0", + "seaborn 0.10.0 py_0", + "secretstorage 3.1.2 py36_0", + "send2trash 1.5.0 py36_0", + "setuptools 45.2.0 py36_0", + "simplegeneric 0.8.1 py36_2", + "singledispatch 3.4.0.3 py36_0", + "sip 4.19.8 py36hf484d3e_0", + "six 1.14.0 py36_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.1.2 py36_0", + "sortedcontainers 2.1.0 py36_0", + "soupsieve 1.9.5 py36_0", + "sphinx 2.4.0 py_0", + "sphinxcontrib 1.0 py36_1", + "sphinxcontrib-applehelp 1.0.1 py_0", + "sphinxcontrib-devhelp 1.0.1 py_0", + "sphinxcontrib-htmlhelp 1.0.2 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.2 py_0", + "sphinxcontrib-serializinghtml 1.1.3 py_0", + "sphinxcontrib-websupport 1.2.0 py_0", + "spyder 4.0.1 py36_0", + "spyder-kernels 1.8.1 py36_0", + "sqlalchemy 1.3.13 py36h7b6447c_0", + "sqlite 3.31.1 h7b6447c_0", + "statsmodels 0.11.0 py36h7b6447c_0", + "sympy 1.5.1 py36_0", + "tbb 2020.0 hfd86e86_0", + "tblib 1.6.0 py_0", + "terminado 0.8.3 py36_0", + "testpath 0.4.4 py_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.10.0 py_0", + "tornado 6.0.3 py36h7b6447c_3", + "tqdm 4.42.1 py_0", + "traitlets 4.3.3 py36_0", + "typed-ast 1.4.1 py36h7b6447c_0", + "ujson 1.35 py36h14c3975_0", + "unicodecsv 0.14.1 py36_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.25.8 py36_0", + "watchdog 0.10.2 py36_0", + "wcwidth 0.1.8 py_0", + "webencodings 0.5.1 py36_1", + "werkzeug 1.0.0 py_0", + "wheel 0.34.2 py36_0", + "widgetsnbextension 3.5.1 py36_0", + "wrapt 1.11.2 py36h7b6447c_0", + "wurlitzer 2.0.0 py36_0", + "xlrd 1.2.0 py36_0", + "xlsxwriter 1.2.7 py_0", + "xlwt 1.3.0 py36_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "yapf 0.28.0 py_0", + "zeromq 4.3.1 he6710b0_3", + "zict 1.0.0 py_0", + "zipp 2.2.0 py_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "43dd1603cbb3309f6c312c5fbc184a8e", + "name": "anaconda", + "namespace": "python", + "sha256": "a952eb8a15ec66557327d621b74ab73f6ea48dca962fe617ed61b6a79500a4ff", + "size": 17210, + "subdir": "linux-64", + "timestamp": 1583251729803, + "version": "2020.02" + }, + "anaconda-2020.02-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.7.2 py37_0", + "anaconda-project 0.8.4 py_0", + "argh 0.26.2 py37_0", + "asn1crypto 1.3.0 py37_0", + "astroid 2.3.3 py37_0", + "astropy 4.0 py37h7b6447c_0", + "atomicwrites 1.3.0 py37_1", + "attrs 19.3.0 py_0", + "autopep8 1.4.4 py_0", + "babel 2.8.0 py_0", + "backcall 0.1.0 py37_0", + "backports 1.0 py_2", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "beautifulsoup4 4.8.2 py37_0", + "bitarray 1.2.1 py37h7b6447c_0", + "bkcharts 0.2 py37_0", + "blas 1.0 mkl", + "bleach 3.1.0 py37_0", + "blosc 1.16.3 hd408876_0", + "bokeh 1.4.0 py37_0", + "boto 2.49.0 py37_0", + "bottleneck 1.3.2 py37heb32a55_0", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2020.1.1 0", + "cairo 1.14.12 h8948797_3", + "certifi 2019.11.28 py37_0", + "cffi 1.14.0 py37h2e261b9_0", + "chardet 3.0.4 py37_1003", + "click 7.0 py37_0", + "cloudpickle 1.3.0 py_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.3 py_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 2.8 py37h1ba5d50_0", + "curl 7.68.0 hbc83047_0", + "cycler 0.10.0 py37_0", + "cython 0.29.15 py37he6710b0_0", + "cytoolz 0.10.1 py37h7b6447c_0", + "dask 2.11.0 py_0", + "dask-core 2.11.0 py_0", + "dbus 1.13.12 h746ee38_0", + "decorator 4.4.1 py_0", + "defusedxml 0.6.0 py_0", + "diff-match-patch 20181111 py_0", + "distributed 2.11.0 py37_0", + "docutils 0.16 py37_0", + "entrypoints 0.3 py37_0", + "et_xmlfile 1.0.1 py37_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.1.0 py37h7b6447c_0", + "filelock 3.0.12 py_0", + "flake8 3.7.9 py37_0", + "flask 1.1.1 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "fsspec 0.6.2 py_0", + "future 0.18.2 py37_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.4.0 py37h7b6447c_0", + "glib 2.63.1 h5a9c865_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py37h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.10.0 py37h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.0.1 py37_0", + "hypothesis 5.5.4 py_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py37_0", + "imageio 2.6.1 py37_0", + "imagesize 1.2.0 py_0", + "importlib_metadata 1.5.0 py37_0", + "intel-openmp 2020.0 166", + "intervaltree 3.0.2 py_0", + "ipykernel 5.1.4 py37h39e3cac_0", + "ipython 7.12.0 py37h5ca1d4c_0", + "ipython_genutils 0.2.0 py37_0", + "ipywidgets 7.5.1 py_0", + "isort 4.3.21 py37_0", + "itsdangerous 1.1.0 py37_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.14.1 py37_0", + "jeepney 0.4.2 py_0", + "jinja2 2.11.1 py_0", + "joblib 0.14.1 py_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.1 py_0", + "jsonschema 3.2.0 py37_0", + "jupyter 1.0.0 py37_7", + "jupyter_client 5.3.4 py37_0", + "jupyter_console 6.1.0 py_0", + "jupyter_core 4.6.1 py37_0", + "jupyterlab 1.2.6 pyhf63ae98_0", + "jupyterlab_server 1.0.6 py_0", + "keyring 21.1.0 py37_0", + "kiwisolver 1.1.0 py37he6710b0_0", + "krb5 1.17.1 h173b8e3_0", + "lazy-object-proxy 1.4.3 py37h7b6447c_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.68.0 h20c2e04_0", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.9.0 h7725739_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libspatialindex 1.9.3 he6710b0_0", + "libssh2 1.8.2 h1ba5d50_0", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_0", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 hea5a465_1", + "libxslt 1.1.33 h7d1a2b0_0", + "llvmlite 0.31.0 py37hd408876_0", + "locket 0.2.0 py37_1", + "lxml 4.5.0 py37hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py37h7b6447c_0", + "matplotlib 3.1.3 py37_0", + "matplotlib-base 3.1.3 py37hef1b27d_0", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h7b6447c_0", + "mkl 2020.0 166", + "mkl-service 2.3.0 py37he904b0f_0", + "mkl_fft 1.0.15 py37ha843d7b_0", + "mkl_random 1.1.0 py37hd6b4f25_0", + "mock 4.0.1 py_0", + "more-itertools 8.2.0 py_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py37_0", + "msgpack-python 0.6.1 py37hfd86e86_1", + "multipledispatch 0.6.0 py37_0", + "nbconvert 5.6.1 py37_0", + "nbformat 5.0.4 py_0", + "ncurses 6.2 he6710b0_0", + "networkx 2.4 py_0", + "nltk 3.4.5 py37_0", + "nose 1.3.7 py37_2", + "notebook 6.0.3 py37_0", + "numba 0.48.0 py37h0573a6f_0", + "numexpr 2.7.1 py37h423224d_0", + "numpy 1.18.1 py37h4f9e942_0", + "numpy-base 1.18.1 py37hde5b4d6_1", + "numpydoc 0.9.2 py_0", + "olefile 0.46 py37_0", + "openpyxl 3.0.3 py_0", + "openssl 1.1.1d h7b6447c_4", + "packaging 20.1 py_0", + "pandas 1.0.1 py37h0573a6f_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py37_1", + "pango 1.42.4 h049681c_0", + "parso 0.5.2 py_0", + "partd 1.1.0 py_0", + "patchelf 0.10 he6710b0_0", + "path 13.1.0 py37_0", + "path.py 12.4.0 0", + "pathlib2 2.3.5 py37_0", + "pathtools 0.1.2 py_1", + "patsy 0.5.1 py37_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py37_0", + "pexpect 4.8.0 py37_0", + "pickleshare 0.7.5 py37_0", + "pillow 7.0.0 py37hb39fc2d_0", + "pip 20.0.2 py37_1", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py37_0", + "pluggy 0.13.1 py37_0", + "ply 3.11 py37_0", + "prometheus_client 0.7.1 py_0", + "prompt_toolkit 3.0.3 py_0", + "psutil 5.6.7 py37h7b6447c_0", + "ptyprocess 0.6.0 py37_0", + "py 1.8.1 py_0", + "py-lief 0.9.0 py37h7725739_2", + "pycodestyle 2.5.0 py37_0", + "pycosat 0.6.3 py37h7b6447c_0", + "pycparser 2.19 py37_0", + "pycrypto 2.6.1 py37h14c3975_9", + "pycurl 7.43.0.5 py37h1ba5d50_0", + "pydocstyle 4.0.1 py_0", + "pyflakes 2.1.1 py37_0", + "pygments 2.5.2 py_0", + "pylint 2.4.4 py37_0", + "pyodbc 4.0.30 py37he6710b0_0", + "pyopenssl 19.1.0 py37_0", + "pyparsing 2.4.6 py_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.15.7 py37h7b6447c_0", + "pysocks 1.7.1 py37_0", + "pytables 3.6.1 py37h71ec239_0", + "pytest 5.3.5 py37_0", + "pytest-arraydiff 0.3 py37h39e3cac_0", + "pytest-astropy 0.8.0 py_0", + "pytest-astropy-header 0.1.2 py_0", + "pytest-doctestplus 0.5.0 py_0", + "pytest-openfiles 0.4.0 py_0", + "pytest-remotedata 0.3.2 py37_0", + "python 3.7.6 h0371630_2", + "python-dateutil 2.8.1 py_0", + "python-jsonrpc-server 0.3.4 py_0", + "python-language-server 0.31.7 py37_0", + "python-libarchive-c 2.8 py37_13", + "pytz 2019.3 py_0", + "pywavelets 1.1.1 py37h7b6447c_0", + "pyxdg 0.26 py_0", + "pyyaml 5.3 py37h7b6447c_0", + "pyzmq 18.1.1 py37he6710b0_0", + "qdarkstyle 2.8 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.6.1 py_0", + "qtconsole 4.6.0 py_1", + "qtpy 1.9.0 py_0", + "readline 7.0 h7b6447c_5", + "requests 2.22.0 py37_1", + "ripgrep 11.0.2 he32d670_0", + "rope 0.16.0 py_0", + "rtree 0.9.3 py37_0", + "ruamel_yaml 0.15.87 py37h7b6447c_0", + "scikit-image 0.16.2 py37h0573a6f_0", + "scikit-learn 0.22.1 py37hd81dba3_0", + "scipy 1.4.1 py37h0b6359f_0", + "seaborn 0.10.0 py_0", + "secretstorage 3.1.2 py37_0", + "send2trash 1.5.0 py37_0", + "setuptools 45.2.0 py37_0", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.4.0.3 py37_0", + "sip 4.19.8 py37hf484d3e_0", + "six 1.14.0 py37_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.1.2 py37_0", + "sortedcontainers 2.1.0 py37_0", + "soupsieve 1.9.5 py37_0", + "sphinx 2.4.0 py_0", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-applehelp 1.0.1 py_0", + "sphinxcontrib-devhelp 1.0.1 py_0", + "sphinxcontrib-htmlhelp 1.0.2 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.2 py_0", + "sphinxcontrib-serializinghtml 1.1.3 py_0", + "sphinxcontrib-websupport 1.2.0 py_0", + "spyder 4.0.1 py37_0", + "spyder-kernels 1.8.1 py37_0", + "sqlalchemy 1.3.13 py37h7b6447c_0", + "sqlite 3.31.1 h7b6447c_0", + "statsmodels 0.11.0 py37h7b6447c_0", + "sympy 1.5.1 py37_0", + "tbb 2020.0 hfd86e86_0", + "tblib 1.6.0 py_0", + "terminado 0.8.3 py37_0", + "testpath 0.4.4 py_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.10.0 py_0", + "tornado 6.0.3 py37h7b6447c_3", + "tqdm 4.42.1 py_0", + "traitlets 4.3.3 py37_0", + "ujson 1.35 py37h14c3975_0", + "unicodecsv 0.14.1 py37_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.25.8 py37_0", + "watchdog 0.10.2 py37_0", + "wcwidth 0.1.8 py_0", + "webencodings 0.5.1 py37_1", + "werkzeug 1.0.0 py_0", + "wheel 0.34.2 py37_0", + "widgetsnbextension 3.5.1 py37_0", + "wrapt 1.11.2 py37h7b6447c_0", + "wurlitzer 2.0.0 py37_0", + "xlrd 1.2.0 py37_0", + "xlsxwriter 1.2.7 py_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "yapf 0.28.0 py_0", + "zeromq 4.3.1 he6710b0_3", + "zict 1.0.0 py_0", + "zipp 2.2.0 py_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "38b545a8df19d76743127ad0ea5b39b7", + "name": "anaconda", + "namespace": "python", + "sha256": "c84b4326cf7547b674e936cdcdea4b2c28740e95261da1ace1110de0d27269ee", + "size": 17119, + "subdir": "linux-64", + "timestamp": 1583202226185, + "version": "2020.02" + }, + "anaconda-2020.02-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py_0", + "anaconda-client 1.7.2 py38_0", + "anaconda-project 0.8.4 py_0", + "argh 0.26.2 py38_0", + "asn1crypto 1.3.0 py38_0", + "astroid 2.3.3 py38_0", + "astropy 4.0 py38h7b6447c_0", + "atomicwrites 1.3.0 py_0", + "attrs 19.3.0 py_0", + "autopep8 1.4.4 py_0", + "babel 2.8.0 py_0", + "backcall 0.1.0 py38_0", + "backports 1.0 py_2", + "backports.shutil_get_terminal_size 1.0.0 py38_2", + "beautifulsoup4 4.8.2 py38_0", + "bitarray 1.2.1 py38h7b6447c_0", + "bkcharts 0.2 py38_0", + "blas 1.0 mkl", + "bleach 3.1.0 py_0", + "blosc 1.16.3 hd408876_0", + "bokeh 1.4.0 py38_0", + "boto 2.49.0 py38_0", + "bottleneck 1.3.2 py38heb32a55_0", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2020.1.1 0", + "cairo 1.14.12 h8948797_3", + "certifi 2019.11.28 py38_0", + "cffi 1.14.0 py38h2e261b9_0", + "chardet 3.0.4 py38_1003", + "click 7.0 py_0", + "cloudpickle 1.3.0 py_0", + "clyent 1.2.2 py38_1", + "colorama 0.4.3 py_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 2.8 py38h1ba5d50_0", + "curl 7.68.0 hbc83047_0", + "cycler 0.10.0 py38_0", + "cython 0.29.15 py38he6710b0_0", + "cytoolz 0.10.1 py38h7b6447c_0", + "dask 2.11.0 py_0", + "dask-core 2.11.0 py_0", + "dbus 1.13.12 h746ee38_0", + "decorator 4.4.1 py_0", + "defusedxml 0.6.0 py_0", + "diff-match-patch 20181111 py_0", + "distributed 2.11.0 py38_0", + "docutils 0.16 py38_0", + "entrypoints 0.3 py38_0", + "et_xmlfile 1.0.1 py38_0", + "expat 2.2.6 he6710b0_0", + "fastcache 1.1.0 py38h7b6447c_0", + "filelock 3.0.12 py_0", + "flake8 3.7.9 py38_0", + "flask 1.1.1 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.9.1 h8a8886c_1", + "fribidi 1.0.5 h7b6447c_0", + "fsspec 0.6.2 py_0", + "future 0.18.2 py38_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.3.7 py38h7b6447c_1", + "glib 2.63.1 h5a9c865_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py38hd5f6e3b_3", + "graphite2 1.3.13 h23475e2_0", + "greenlet 0.4.15 py38h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb453b48_1", + "h5py 2.10.0 py38h7918eee_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.0.1 py_0", + "hypothesis 5.5.4 py_0", + "icu 58.2 h9c2bf20_1", + "idna 2.8 py38_1000", + "imageio 2.6.1 py38_0", + "imagesize 1.2.0 py_0", + "importlib_metadata 1.5.0 py38_0", + "intel-openmp 2020.0 166", + "intervaltree 3.0.2 py_0", + "ipykernel 5.1.4 py38h39e3cac_0", + "ipython 7.12.0 py38h5ca1d4c_0", + "ipython_genutils 0.2.0 py38_0", + "ipywidgets 7.5.1 py_0", + "isort 4.3.21 py38_0", + "itsdangerous 1.1.0 py_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.14.1 py38_0", + "jeepney 0.4.2 py_0", + "jinja2 2.11.1 py_0", + "joblib 0.14.1 py_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.1 py_0", + "jsonschema 3.2.0 py38_0", + "jupyter 1.0.0 py38_7", + "jupyter_client 5.3.4 py38_0", + "jupyter_console 6.1.0 py_0", + "jupyter_core 4.6.1 py38_0", + "jupyterlab 1.2.6 pyhf63ae98_0", + "jupyterlab_server 1.0.6 py_0", + "keyring 21.1.0 py38_0", + "kiwisolver 1.0.1 py38he6710b0_0", + "krb5 1.17.1 h173b8e3_0", + "lazy-object-proxy 1.4.3 py38h7b6447c_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.3.3 h5d8350f_5", + "libcurl 7.68.0 h20c2e04_0", + "libedit 3.1.20181209 hc058e9b_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.16 h1bed415_0", + "libspatialindex 1.9.3 he6710b0_0", + "libssh2 1.8.2 h1ba5d50_0", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_0", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.13 h1bed415_1", + "libxml2 2.9.9 hea5a465_1", + "libxslt 1.1.33 h7d1a2b0_0", + "llvmlite 0.31.0 py38hd408876_0", + "locket 0.2.0 py38_1", + "lxml 4.5.0 py38hefd8a0e_0", + "lz4-c 1.8.1.2 h14c3975_0", + "lzo 2.10 h49e0be7_2", + "markupsafe 1.1.1 py38h7b6447c_0", + "matplotlib 3.1.3 py38_0", + "matplotlib-base 3.1.3 py38hef1b27d_0", + "mccabe 0.6.1 py38_1", + "mistune 0.8.4 py38h7b6447c_1000", + "mkl 2020.0 166", + "mkl-service 2.3.0 py38he904b0f_0", + "mkl_fft 1.0.15 py38ha843d7b_0", + "mkl_random 1.1.0 py38h962f231_0", + "mock 4.0.1 py_0", + "more-itertools 8.2.0 py_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.1 hdf1c602_3", + "mpmath 1.1.0 py38_0", + "msgpack-python 0.6.1 py38hfd86e86_1", + "multipledispatch 0.6.0 py38_0", + "nbconvert 5.6.1 py38_0", + "nbformat 5.0.4 py_0", + "ncurses 6.2 he6710b0_0", + "networkx 2.4 py_0", + "nltk 3.4.5 py38_0", + "nose 1.3.7 py38_2", + "notebook 6.0.3 py38_0", + "numba 0.48.0 py38h0573a6f_0", + "numexpr 2.7.1 py38h423224d_0", + "numpy 1.18.1 py38h4f9e942_0", + "numpy-base 1.18.1 py38hde5b4d6_1", + "numpydoc 0.9.2 py_0", + "olefile 0.46 py_0", + "openpyxl 3.0.3 py_0", + "openssl 1.1.1d h7b6447c_4", + "packaging 20.1 py_0", + "pandas 1.0.1 py38h0573a6f_0", + "pandoc 2.2.3.2 0", + "pandocfilters 1.4.2 py38_1", + "pango 1.42.4 h049681c_0", + "parso 0.5.2 py_0", + "partd 1.1.0 py_0", + "patchelf 0.10 he6710b0_0", + "path 13.1.0 py38_0", + "path.py 12.4.0 0", + "pathlib2 2.3.5 py38_0", + "pathtools 0.1.2 py_1", + "patsy 0.5.1 py38_0", + "pcre 8.43 he6710b0_0", + "pep8 1.7.1 py38_0", + "pexpect 4.8.0 py38_0", + "pickleshare 0.7.5 py38_1000", + "pillow 7.0.0 py38hb39fc2d_0", + "pip 20.0.2 py38_1", + "pixman 0.38.0 h7b6447c_0", + "pkginfo 1.5.0.1 py38_0", + "pluggy 0.13.1 py38_0", + "ply 3.11 py38_0", + "prometheus_client 0.7.1 py_0", + "prompt_toolkit 3.0.3 py_0", + "psutil 5.6.7 py38h7b6447c_0", + "ptyprocess 0.6.0 py38_0", + "py 1.8.1 py_0", + "pycodestyle 2.5.0 py38_0", + "pycosat 0.6.3 py38h7b6447c_0", + "pycparser 2.19 py_0", + "pycurl 7.43.0.5 py38h1ba5d50_0", + "pydocstyle 4.0.1 py_0", + "pyflakes 2.1.1 py38_0", + "pygments 2.5.2 py_0", + "pylint 2.4.4 py38_0", + "pyodbc 4.0.30 py38he6710b0_0", + "pyopenssl 19.1.0 py38_0", + "pyparsing 2.4.6 py_0", + "pyqt 5.9.2 py38h05f1152_4", + "pyrsistent 0.15.7 py38h7b6447c_0", + "pysocks 1.7.1 py38_0", + "pytables 3.6.1 py38h9fd0a39_0", + "pytest 5.3.5 py38_0", + "pytest-arraydiff 0.2 py38h39e3cac_0", + "pytest-astropy 0.8.0 py_0", + "pytest-astropy-header 0.1.2 py_0", + "pytest-doctestplus 0.5.0 py_0", + "pytest-openfiles 0.4.0 py_0", + "pytest-remotedata 0.3.2 py38_0", + "python 3.8.1 h0371630_1", + "python-dateutil 2.8.1 py_0", + "python-jsonrpc-server 0.3.4 py_0", + "python-language-server 0.31.7 py38_0", + "python-libarchive-c 2.8 py38_7", + "pytz 2019.3 py_0", + "pywavelets 1.1.1 py38h7b6447c_0", + "pyxdg 0.26 py_0", + "pyyaml 5.3 py38h7b6447c_0", + "pyzmq 18.1.1 py38he6710b0_0", + "qdarkstyle 2.8 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.6.1 py_0", + "qtconsole 4.6.0 py_1", + "qtpy 1.9.0 py_0", + "readline 7.0 h7b6447c_5", + "requests 2.22.0 py38_1", + "ripgrep 11.0.2 he32d670_0", + "rope 0.16.0 py_0", + "rtree 0.9.3 py38_0", + "ruamel_yaml 0.15.87 py38h7b6447c_0", + "scikit-image 0.16.2 py38h0573a6f_0", + "scikit-learn 0.22.1 py38hd81dba3_0", + "scipy 1.4.1 py38h0b6359f_0", + "seaborn 0.10.0 py_0", + "secretstorage 3.1.2 py38_0", + "send2trash 1.5.0 py38_0", + "setuptools 45.2.0 py38_0", + "simplegeneric 0.8.1 py38_2", + "singledispatch 3.4.0.3 py38_0", + "sip 4.19.13 py38he6710b0_0", + "six 1.14.0 py38_0", + "snappy 1.1.7 hbae5bb6_3", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.1.1 py_0", + "sortedcontainers 2.1.0 py38_0", + "soupsieve 1.9.5 py38_0", + "sphinx 2.4.0 py_0", + "sphinxcontrib 1.0 py38_1", + "sphinxcontrib-applehelp 1.0.1 py_0", + "sphinxcontrib-devhelp 1.0.1 py_0", + "sphinxcontrib-htmlhelp 1.0.2 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.2 py_0", + "sphinxcontrib-serializinghtml 1.1.3 py_0", + "sphinxcontrib-websupport 1.2.0 py_0", + "spyder 4.0.1 py38_0", + "spyder-kernels 1.8.1 py38_0", + "sqlalchemy 1.3.13 py38h7b6447c_0", + "sqlite 3.31.1 h7b6447c_0", + "statsmodels 0.11.0 py38h7b6447c_0", + "sympy 1.5.1 py38_0", + "tbb 2020.0 hfd86e86_0", + "tblib 1.6.0 py_0", + "terminado 0.8.3 py38_0", + "testpath 0.4.4 py_0", + "tk 8.6.8 hbc83047_0", + "toolz 0.10.0 py_0", + "tornado 6.0.3 py38h7b6447c_3", + "tqdm 4.42.1 py_0", + "traitlets 4.3.3 py38_0", + "ujson 1.35 py38h7b6447c_0", + "unicodecsv 0.14.1 py38_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.25.8 py38_0", + "watchdog 0.10.2 py38_0", + "wcwidth 0.1.8 py_0", + "webencodings 0.5.1 py38_1", + "werkzeug 1.0.0 py_0", + "wheel 0.34.2 py38_0", + "widgetsnbextension 3.5.1 py38_0", + "wrapt 1.11.2 py38h7b6447c_0", + "wurlitzer 2.0.0 py38_0", + "xlrd 1.2.0 py_0", + "xlsxwriter 1.2.7 py_0", + "xlwt 1.3.0 py38_0", + "xz 5.2.4 h14c3975_4", + "yaml 0.1.7 had09818_2", + "yapf 0.28.0 py_0", + "zeromq 4.3.1 he6710b0_3", + "zict 1.0.0 py_0", + "zipp 2.2.0 py_0", + "zlib 1.2.11 h7b6447c_3", + "zstd 1.3.7 h0b5b093_0" + ], + "license": "BSD", + "md5": "8a4124650e1581bfa1b9c216aa63a965", + "name": "anaconda", + "namespace": "python", + "sha256": "6a3df8fc432cf3a5d4e354a29c5ab38408b7fc21c419dc51a87f6ff715289868", + "size": 17136, + "subdir": "linux-64", + "timestamp": 1583202304295, + "version": "2020.02" + }, + "anaconda-2020.07-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py36_0", + "anaconda-client 1.7.2 py36_0", + "anaconda-project 0.8.4 py_0", + "argh 0.26.2 py36_0", + "asn1crypto 1.3.0 py36_0", + "astroid 2.4.2 py36_0", + "astropy 4.0.1.post1 py36h7b6447c_1", + "atomicwrites 1.4.0 py_0", + "attrs 19.3.0 py_0", + "autopep8 1.5.3 py_0", + "babel 2.8.0 py_0", + "backcall 0.2.0 py_0", + "backports 1.0 py_2", + "backports.shutil_get_terminal_size 1.0.0 py36_2", + "beautifulsoup4 4.9.1 py36_0", + "bitarray 1.4.0 py36h7b6447c_0", + "bkcharts 0.2 py36_0", + "blas 1.0 mkl", + "bleach 3.1.5 py_0", + "blosc 1.19.0 hd408876_0", + "bokeh 2.1.1 py36_0", + "boto 2.49.0 py36_0", + "bottleneck 1.3.2 py36heb32a55_1", + "brotlipy 0.7.0 py36h7b6447c_1000", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2020.6.24 0", + "cairo 1.14.12 h8948797_3", + "certifi 2020.6.20 py36_0", + "cffi 1.14.0 py36he30daa8_1", + "chardet 3.0.4 py36_1003", + "click 7.1.2 py_0", + "cloudpickle 1.5.0 py_0", + "clyent 1.2.2 py36_1", + "colorama 0.4.3 py_0", + "contextlib2 0.6.0.post1 py_0", + "contextvars 2.4 py_0", + "cryptography 2.9.2 py36h1ba5d50_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py36_0", + "cython 0.29.21 py36he6710b0_0", + "cytoolz 0.10.1 py36h7b6447c_0", + "dask 2.20.0 py_0", + "dask-core 2.20.0 py_0", + "dbus 1.13.16 hb2f20db_0", + "decorator 4.4.2 py_0", + "defusedxml 0.6.0 py_0", + "diff-match-patch 20200713 py_0", + "distributed 2.20.0 py36_0", + "docutils 0.16 py36_1", + "entrypoints 0.3 py36_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.2.9 he6710b0_2", + "fastcache 1.1.0 py36h7b6447c_0", + "filelock 3.0.12 py_0", + "flake8 3.8.3 py_0", + "flask 1.1.2 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.10.2 h5ab3b9f_0", + "fribidi 1.0.9 h7b6447c_0", + "fsspec 0.7.4 py_0", + "future 0.18.2 py36_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 20.6.2 py36h7b6447c_0", + "glib 2.65.0 h3eb4bd4_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py36h10f8cd9_2", + "graphite2 1.3.14 h23475e2_0", + "greenlet 0.4.16 py36h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb31296c_0", + "h5py 2.10.0 py36h7918eee_0", + "harfbuzz 2.4.0 hca77d97_1", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 py_0", + "imageio 2.9.0 py_0", + "imagesize 1.2.0 py_0", + "immutables 0.14 py36h7b6447c_0", + "importlib-metadata 1.7.0 py36_0", + "importlib_metadata 1.7.0 0", + "intel-openmp 2020.1 217", + "intervaltree 3.0.2 py_1", + "ipykernel 5.3.2 py36h5ca1d4c_0", + "ipython 7.16.1 py36h5ca1d4c_0", + "ipython_genutils 0.2.0 py36_0", + "ipywidgets 7.5.1 py_0", + "isort 4.3.21 py36_0", + "itsdangerous 1.1.0 py36_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.1 py36_0", + "jeepney 0.4.3 py_0", + "jinja2 2.11.2 py_0", + "joblib 0.16.0 py_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py36_0", + "jupyter 1.0.0 py36_7", + "jupyter_client 6.1.6 py_0", + "jupyter_console 6.1.0 py_0", + "jupyter_core 4.6.3 py36_0", + "jupyterlab 2.1.5 py_0", + "jupyterlab_server 1.2.0 py_0", + "keyring 21.2.1 py36_0", + "kiwisolver 1.2.0 py36hfd86e86_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.4.3 py36h7b6447c_0", + "lcms2 2.11 h396b838_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libedit 3.1.20191231 h14c3975_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 he6710b0_0", + "libllvm9 9.0.1 h4a3c616_1", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 he6710b0_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_1", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 he19cac6_1", + "libxslt 1.1.34 hc22bd24_0", + "llvmlite 0.33.0 py36hc6ec683_1", + "locket 0.2.0 py36_1", + "lxml 4.5.2 py36hefd8a0e_0", + "lz4-c 1.9.2 he6710b0_0", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py36h7b6447c_0", + "matplotlib 3.2.2 0", + "matplotlib-base 3.2.2 py36hef1b27d_0", + "mccabe 0.6.1 py36_1", + "mistune 0.8.4 py36h7b6447c_0", + "mkl 2020.1 217", + "mkl-service 2.3.0 py36he904b0f_0", + "mkl_fft 1.1.0 py36h23d657b_0", + "mkl_random 1.1.1 py36h0573a6f_0", + "mock 4.0.2 py_0", + "more-itertools 8.4.0 py_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.1.0 py36_0", + "msgpack-python 1.0.0 py36hfd86e86_1", + "multipledispatch 0.6.0 py36_0", + "nbconvert 5.6.1 py36_0", + "nbformat 5.0.7 py_0", + "ncurses 6.2 he6710b0_1", + "networkx 2.4 py_1", + "nltk 3.5 py_0", + "nose 1.3.7 py36_2", + "notebook 6.0.3 py36_0", + "numba 0.50.1 py36h0573a6f_1", + "numexpr 2.7.1 py36h423224d_0", + "numpy 1.18.5 py36ha1c710e_0", + "numpy-base 1.18.5 py36hde5b4d6_0", + "numpydoc 1.1.0 py_0", + "olefile 0.46 py36_0", + "openpyxl 3.0.4 py_0", + "openssl 1.1.1g h7b6447c_0", + "packaging 20.4 py_0", + "pandas 1.0.5 py36h0573a6f_0", + "pandoc 2.10 0", + "pandocfilters 1.4.2 py36_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.1.0 py_0", + "patchelf 0.11 he6710b0_0", + "path 13.1.0 py36_0", + "path.py 12.4.0 0", + "pathlib2 2.3.5 py36_0", + "pathtools 0.1.2 py_1", + "patsy 0.5.1 py36_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py36_0", + "pexpect 4.8.0 py36_0", + "pickleshare 0.7.5 py36_0", + "pillow 7.2.0 py36hb39fc2d_0", + "pip 20.1.1 py36_1", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.5.0.1 py36_0", + "pluggy 0.13.1 py36_0", + "ply 3.11 py36_0", + "prometheus_client 0.8.0 py_0", + "prompt-toolkit 3.0.5 py_0", + "prompt_toolkit 3.0.5 0", + "psutil 5.7.0 py36h7b6447c_0", + "ptyprocess 0.6.0 py36_0", + "py 1.9.0 py_0", + "py-lief 0.10.1 py36h403a769_0", + "pycodestyle 2.6.0 py_0", + "pycosat 0.6.3 py36h7b6447c_0", + "pycparser 2.20 py_2", + "pycrypto 2.6.1 py36h7b6447c_10", + "pycurl 7.43.0.5 py36h1ba5d50_0", + "pydocstyle 5.0.2 py_0", + "pyflakes 2.2.0 py_0", + "pygments 2.6.1 py_0", + "pylint 2.5.3 py36_0", + "pyodbc 4.0.30 py36he6710b0_0", + "pyopenssl 19.1.0 py_1", + "pyparsing 2.4.7 py_0", + "pyqt 5.9.2 py36h05f1152_2", + "pyrsistent 0.16.0 py36h7b6447c_0", + "pysocks 1.7.1 py36_0", + "pytables 3.6.1 py36h71ec239_0", + "pytest 5.4.3 py36_0", + "python 3.6.10 h7579374_2", + "python-dateutil 2.8.1 py_0", + "python-jsonrpc-server 0.3.4 py_1", + "python-language-server 0.34.1 py36_0", + "python-libarchive-c 2.9 py_0", + "pytz 2020.1 py_0", + "pywavelets 1.1.1 py36h7b6447c_0", + "pyxdg 0.26 py_0", + "pyyaml 5.3.1 py36h7b6447c_1", + "pyzmq 19.0.1 py36he6710b0_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.7.2 py_0", + "qtconsole 4.7.5 py_0", + "qtpy 1.9.0 py_0", + "readline 8.0 h7b6447c_0", + "regex 2020.6.8 py36h7b6447c_0", + "requests 2.24.0 py_0", + "ripgrep 11.0.2 he32d670_0", + "rope 0.17.0 py_0", + "rtree 0.9.4 py36_1", + "ruamel_yaml 0.15.87 py36h7b6447c_1", + "scikit-image 0.16.2 py36h0573a6f_0", + "scikit-learn 0.23.1 py36h423224d_0", + "scipy 1.5.0 py36h0b6359f_0", + "seaborn 0.10.1 py_0", + "secretstorage 3.1.2 py36_0", + "send2trash 1.5.0 py36_0", + "setuptools 49.2.0 py36_0", + "simplegeneric 0.8.1 py36_2", + "singledispatch 3.4.0.3 py36_0", + "sip 4.19.8 py36hf484d3e_0", + "six 1.15.0 py_0", + "snappy 1.1.8 he6710b0_0", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.2.1 py_0", + "sortedcontainers 2.2.2 py_0", + "soupsieve 2.0.1 py_0", + "sphinx 3.1.2 py_0", + "sphinxcontrib 1.0 py36_1", + "sphinxcontrib-applehelp 1.0.2 py_0", + "sphinxcontrib-devhelp 1.0.2 py_0", + "sphinxcontrib-htmlhelp 1.0.3 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.3 py_0", + "sphinxcontrib-serializinghtml 1.1.4 py_0", + "sphinxcontrib-websupport 1.2.3 py_0", + "spyder 4.1.4 py36_0", + "spyder-kernels 1.9.2 py36_0", + "sqlalchemy 1.3.18 py36h7b6447c_0", + "sqlite 3.32.3 h62c20be_0", + "statsmodels 0.11.1 py36h7b6447c_0", + "sympy 1.6.1 py36_0", + "tbb 2020.0 hfd86e86_0", + "tblib 1.6.0 py_0", + "terminado 0.8.3 py36_0", + "testpath 0.4.4 py_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "tk 8.6.10 hbc83047_0", + "toml 0.10.1 py_0", + "toolz 0.10.0 py_0", + "tornado 6.0.4 py36h7b6447c_1", + "tqdm 4.47.0 py_0", + "traitlets 4.3.3 py36_0", + "typed-ast 1.4.1 py36h7b6447c_0", + "typing_extensions 3.7.4.2 py_0", + "ujson 1.35 py36h14c3975_0", + "unicodecsv 0.14.1 py36_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.25.9 py_0", + "watchdog 0.10.3 py36_0", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py36_1", + "werkzeug 1.0.1 py_0", + "wheel 0.34.2 py36_0", + "widgetsnbextension 3.5.1 py36_0", + "wrapt 1.11.2 py36h7b6447c_0", + "wurlitzer 2.0.1 py36_0", + "xlrd 1.2.0 py36_0", + "xlsxwriter 1.2.9 py_0", + "xlwt 1.3.0 py36_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.30.0 py_0", + "zeromq 4.3.2 he6710b0_2", + "zict 2.0.0 py_0", + "zipp 3.1.0 py_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py36_1", + "zope.event 4.4 py36_0", + "zope.interface 4.7.1 py36h7b6447c_0", + "zstd 1.4.5 h0b5b093_0" + ], + "license": "BSD", + "md5": "6c691d698596f1f18dca09edecef1ddd", + "name": "anaconda", + "namespace": "python", + "sha256": "a02ffec02b05c137eac10902a7742cd25ddd4b3affa25f67672e778c2a6ab807", + "size": 17342, + "subdir": "linux-64", + "timestamp": 1595029547527, + "version": "2020.07" + }, + "anaconda-2020.07-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.7.2 py37_0", + "anaconda-project 0.8.4 py_0", + "argh 0.26.2 py37_0", + "asn1crypto 1.3.0 py37_1", + "astroid 2.4.2 py37_0", + "astropy 4.0.1.post1 py37h7b6447c_1", + "atomicwrites 1.4.0 py_0", + "attrs 19.3.0 py_0", + "autopep8 1.5.3 py_0", + "babel 2.8.0 py_0", + "backcall 0.2.0 py_0", + "backports 1.0 py_2", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "beautifulsoup4 4.9.1 py37_0", + "bitarray 1.4.0 py37h7b6447c_0", + "bkcharts 0.2 py37_0", + "blas 1.0 mkl", + "bleach 3.1.5 py_0", + "blosc 1.19.0 hd408876_0", + "bokeh 2.1.1 py37_0", + "boto 2.49.0 py37_0", + "bottleneck 1.3.2 py37heb32a55_1", + "brotlipy 0.7.0 py37h7b6447c_1000", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2020.6.24 0", + "cairo 1.14.12 h8948797_3", + "certifi 2020.6.20 py37_0", + "cffi 1.14.0 py37he30daa8_1", + "chardet 3.0.4 py37_1003", + "click 7.1.2 py_0", + "cloudpickle 1.5.0 py_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.3 py_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 2.9.2 py37h1ba5d50_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py37_0", + "cython 0.29.21 py37he6710b0_0", + "cytoolz 0.10.1 py37h7b6447c_0", + "dask 2.20.0 py_0", + "dask-core 2.20.0 py_0", + "dbus 1.13.16 hb2f20db_0", + "decorator 4.4.2 py_0", + "defusedxml 0.6.0 py_0", + "diff-match-patch 20200713 py_0", + "distributed 2.20.0 py37_0", + "docutils 0.16 py37_1", + "entrypoints 0.3 py37_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.2.9 he6710b0_2", + "fastcache 1.1.0 py37h7b6447c_0", + "filelock 3.0.12 py_0", + "flake8 3.8.3 py_0", + "flask 1.1.2 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.10.2 h5ab3b9f_0", + "fribidi 1.0.9 h7b6447c_0", + "fsspec 0.7.4 py_0", + "future 0.18.2 py37_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 20.6.2 py37h7b6447c_0", + "glib 2.65.0 h3eb4bd4_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.14 h23475e2_0", + "greenlet 0.4.16 py37h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb31296c_0", + "h5py 2.10.0 py37h7918eee_0", + "harfbuzz 2.4.0 hca77d97_1", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 py_0", + "imageio 2.9.0 py_0", + "imagesize 1.2.0 py_0", + "importlib-metadata 1.7.0 py37_0", + "importlib_metadata 1.7.0 0", + "intel-openmp 2020.1 217", + "intervaltree 3.0.2 py_1", + "ipykernel 5.3.2 py37h5ca1d4c_0", + "ipython 7.16.1 py37h5ca1d4c_0", + "ipython_genutils 0.2.0 py37_0", + "ipywidgets 7.5.1 py_0", + "isort 4.3.21 py37_0", + "itsdangerous 1.1.0 py37_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.1 py37_0", + "jeepney 0.4.3 py_0", + "jinja2 2.11.2 py_0", + "joblib 0.16.0 py_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py37_1", + "jupyter 1.0.0 py37_7", + "jupyter_client 6.1.6 py_0", + "jupyter_console 6.1.0 py_0", + "jupyter_core 4.6.3 py37_0", + "jupyterlab 2.1.5 py_0", + "jupyterlab_server 1.2.0 py_0", + "keyring 21.2.1 py37_0", + "kiwisolver 1.2.0 py37hfd86e86_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.4.3 py37h7b6447c_0", + "lcms2 2.11 h396b838_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libedit 3.1.20191231 h14c3975_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 he6710b0_0", + "libllvm9 9.0.1 h4a3c616_1", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 he6710b0_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_1", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 he19cac6_1", + "libxslt 1.1.34 hc22bd24_0", + "llvmlite 0.33.0 py37hc6ec683_1", + "locket 0.2.0 py37_1", + "lxml 4.5.2 py37hefd8a0e_0", + "lz4-c 1.9.2 he6710b0_0", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py37h14c3975_1", + "matplotlib 3.2.2 0", + "matplotlib-base 3.2.2 py37hef1b27d_0", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h14c3975_1001", + "mkl 2020.1 217", + "mkl-service 2.3.0 py37he904b0f_0", + "mkl_fft 1.1.0 py37h23d657b_0", + "mkl_random 1.1.1 py37h0573a6f_0", + "mock 4.0.2 py_0", + "more-itertools 8.4.0 py_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.1.0 py37_0", + "msgpack-python 1.0.0 py37hfd86e86_1", + "multipledispatch 0.6.0 py37_0", + "nbconvert 5.6.1 py37_1", + "nbformat 5.0.7 py_0", + "ncurses 6.2 he6710b0_1", + "networkx 2.4 py_1", + "nltk 3.5 py_0", + "nose 1.3.7 py37_1004", + "notebook 6.0.3 py37_0", + "numba 0.50.1 py37h0573a6f_1", + "numexpr 2.7.1 py37h423224d_0", + "numpy 1.18.5 py37ha1c710e_0", + "numpy-base 1.18.5 py37hde5b4d6_0", + "numpydoc 1.1.0 py_0", + "olefile 0.46 py37_0", + "openpyxl 3.0.4 py_0", + "openssl 1.1.1g h7b6447c_0", + "packaging 20.4 py_0", + "pandas 1.0.5 py37h0573a6f_0", + "pandoc 2.10 0", + "pandocfilters 1.4.2 py37_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.1.0 py_0", + "patchelf 0.11 he6710b0_0", + "path 13.1.0 py37_0", + "path.py 12.4.0 0", + "pathlib2 2.3.5 py37_1", + "pathtools 0.1.2 py_1", + "patsy 0.5.1 py37_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py37_0", + "pexpect 4.8.0 py37_1", + "pickleshare 0.7.5 py37_1001", + "pillow 7.2.0 py37hb39fc2d_0", + "pip 20.1.1 py37_1", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.5.0.1 py37_0", + "pluggy 0.13.1 py37_0", + "ply 3.11 py37_0", + "prometheus_client 0.8.0 py_0", + "prompt-toolkit 3.0.5 py_0", + "prompt_toolkit 3.0.5 0", + "psutil 5.7.0 py37h7b6447c_0", + "ptyprocess 0.6.0 py37_0", + "py 1.9.0 py_0", + "py-lief 0.10.1 py37h403a769_0", + "pycodestyle 2.6.0 py_0", + "pycosat 0.6.3 py37h7b6447c_0", + "pycparser 2.20 py_2", + "pycrypto 2.6.1 py37h7b6447c_10", + "pycurl 7.43.0.5 py37h1ba5d50_0", + "pydocstyle 5.0.2 py_0", + "pyflakes 2.2.0 py_0", + "pygments 2.6.1 py_0", + "pylint 2.5.3 py37_0", + "pyodbc 4.0.30 py37he6710b0_0", + "pyopenssl 19.1.0 py_1", + "pyparsing 2.4.7 py_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.16.0 py37h7b6447c_0", + "pysocks 1.7.1 py37_1", + "pytables 3.6.1 py37h71ec239_0", + "pytest 5.4.3 py37_0", + "python 3.7.7 hcff3b4d_5", + "python-dateutil 2.8.1 py_0", + "python-jsonrpc-server 0.3.4 py_1", + "python-language-server 0.34.1 py37_0", + "python-libarchive-c 2.9 py_0", + "pytz 2020.1 py_0", + "pywavelets 1.1.1 py37h7b6447c_0", + "pyxdg 0.26 py_0", + "pyyaml 5.3.1 py37h7b6447c_1", + "pyzmq 19.0.1 py37he6710b0_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.7.2 py_0", + "qtconsole 4.7.5 py_0", + "qtpy 1.9.0 py_0", + "readline 8.0 h7b6447c_0", + "regex 2020.6.8 py37h7b6447c_0", + "requests 2.24.0 py_0", + "ripgrep 11.0.2 he32d670_0", + "rope 0.17.0 py_0", + "rtree 0.9.4 py37_1", + "ruamel_yaml 0.15.87 py37h7b6447c_1", + "scikit-image 0.16.2 py37h0573a6f_0", + "scikit-learn 0.23.1 py37h423224d_0", + "scipy 1.5.0 py37h0b6359f_0", + "seaborn 0.10.1 py_0", + "secretstorage 3.1.2 py37_1", + "send2trash 1.5.0 py37_0", + "setuptools 49.2.0 py37_0", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.4.0.3 py37_0", + "sip 4.19.8 py37hf484d3e_0", + "six 1.15.0 py_0", + "snappy 1.1.8 he6710b0_0", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.2.1 py_0", + "sortedcontainers 2.2.2 py_0", + "soupsieve 2.0.1 py_0", + "sphinx 3.1.2 py_0", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-applehelp 1.0.2 py_0", + "sphinxcontrib-devhelp 1.0.2 py_0", + "sphinxcontrib-htmlhelp 1.0.3 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.3 py_0", + "sphinxcontrib-serializinghtml 1.1.4 py_0", + "sphinxcontrib-websupport 1.2.3 py_0", + "spyder 4.1.4 py37_0", + "spyder-kernels 1.9.2 py37_0", + "sqlalchemy 1.3.18 py37h7b6447c_0", + "sqlite 3.32.3 h62c20be_0", + "statsmodels 0.11.1 py37h7b6447c_0", + "sympy 1.6.1 py37_0", + "tbb 2020.0 hfd86e86_0", + "tblib 1.6.0 py_0", + "terminado 0.8.3 py37_0", + "testpath 0.4.4 py_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "tk 8.6.10 hbc83047_0", + "toml 0.10.1 py_0", + "toolz 0.10.0 py_0", + "tornado 6.0.4 py37h7b6447c_1", + "tqdm 4.47.0 py_0", + "traitlets 4.3.3 py37_0", + "typed-ast 1.4.1 py37h7b6447c_0", + "typing_extensions 3.7.4.2 py_0", + "ujson 1.35 py37h14c3975_0", + "unicodecsv 0.14.1 py37_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.25.9 py_0", + "watchdog 0.10.3 py37_0", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py37_1", + "werkzeug 1.0.1 py_0", + "wheel 0.34.2 py37_0", + "widgetsnbextension 3.5.1 py37_0", + "wrapt 1.11.2 py37h7b6447c_0", + "wurlitzer 2.0.1 py37_0", + "xlrd 1.2.0 py37_0", + "xlsxwriter 1.2.9 py_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.30.0 py_0", + "zeromq 4.3.2 he6710b0_2", + "zict 2.0.0 py_0", + "zipp 3.1.0 py_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py37_1", + "zope.event 4.4 py37_0", + "zope.interface 4.7.1 py37h7b6447c_0", + "zstd 1.4.5 h0b5b093_0" + ], + "license": "BSD", + "md5": "4f9b95057d7200b16dfd20058df3eba1", + "name": "anaconda", + "namespace": "python", + "sha256": "a035b86564b686e09af262ed7aaf718399033497ca9da753739810eb3bf4113f", + "size": 17293, + "subdir": "linux-64", + "timestamp": 1595029546784, + "version": "2020.07" + }, + "anaconda-2020.07-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py_0", + "anaconda-client 1.7.2 py38_0", + "anaconda-project 0.8.4 py_0", + "argh 0.26.2 py38_0", + "asn1crypto 1.3.0 py38_0", + "astroid 2.4.2 py38_0", + "astropy 4.0.1.post1 py38h7b6447c_1", + "atomicwrites 1.4.0 py_0", + "attrs 19.3.0 py_0", + "autopep8 1.5.3 py_0", + "babel 2.8.0 py_0", + "backcall 0.2.0 py_0", + "backports 1.0 py_2", + "backports.shutil_get_terminal_size 1.0.0 py38_2", + "beautifulsoup4 4.9.1 py38_0", + "bitarray 1.4.0 py38h7b6447c_0", + "bkcharts 0.2 py38_0", + "blas 1.0 mkl", + "bleach 3.1.5 py_0", + "blosc 1.19.0 hd408876_0", + "bokeh 2.1.1 py38_0", + "boto 2.49.0 py38_0", + "bottleneck 1.3.2 py38heb32a55_1", + "brotlipy 0.7.0 py38h7b6447c_1000", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2020.6.24 0", + "cairo 1.14.12 h8948797_3", + "certifi 2020.6.20 py38_0", + "cffi 1.14.0 py38he30daa8_1", + "chardet 3.0.4 py38_1003", + "click 7.1.2 py_0", + "cloudpickle 1.5.0 py_0", + "clyent 1.2.2 py38_1", + "colorama 0.4.3 py_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 2.9.2 py38h1ba5d50_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py38_0", + "cython 0.29.21 py38he6710b0_0", + "cytoolz 0.10.1 py38h7b6447c_0", + "dask 2.20.0 py_0", + "dask-core 2.20.0 py_0", + "dbus 1.13.16 hb2f20db_0", + "decorator 4.4.2 py_0", + "defusedxml 0.6.0 py_0", + "diff-match-patch 20200713 py_0", + "distributed 2.20.0 py38_0", + "docutils 0.16 py38_1", + "entrypoints 0.3 py38_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.2.9 he6710b0_2", + "fastcache 1.1.0 py38h7b6447c_0", + "filelock 3.0.12 py_0", + "flake8 3.8.3 py_0", + "flask 1.1.2 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.10.2 h5ab3b9f_0", + "fribidi 1.0.9 h7b6447c_0", + "fsspec 0.7.4 py_0", + "future 0.18.2 py38_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 20.6.2 py38h7b6447c_0", + "glib 2.65.0 h3eb4bd4_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py38hd5f6e3b_3", + "graphite2 1.3.14 h23475e2_0", + "greenlet 0.4.16 py38h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb31296c_0", + "h5py 2.10.0 py38h7918eee_0", + "harfbuzz 2.4.0 hca77d97_1", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 py_0", + "imageio 2.9.0 py_0", + "imagesize 1.2.0 py_0", + "importlib-metadata 1.7.0 py38_0", + "importlib_metadata 1.7.0 0", + "intel-openmp 2020.1 217", + "intervaltree 3.0.2 py_1", + "ipykernel 5.3.2 py38h5ca1d4c_0", + "ipython 7.16.1 py38h5ca1d4c_0", + "ipython_genutils 0.2.0 py38_0", + "ipywidgets 7.5.1 py_0", + "isort 4.3.21 py38_0", + "itsdangerous 1.1.0 py_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.1 py38_0", + "jeepney 0.4.3 py_0", + "jinja2 2.11.2 py_0", + "joblib 0.16.0 py_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py38_0", + "jupyter 1.0.0 py38_7", + "jupyter_client 6.1.6 py_0", + "jupyter_console 6.1.0 py_0", + "jupyter_core 4.6.3 py38_0", + "jupyterlab 2.1.5 py_0", + "jupyterlab_server 1.2.0 py_0", + "keyring 21.2.1 py38_0", + "kiwisolver 1.2.0 py38hfd86e86_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.4.3 py38h7b6447c_0", + "lcms2 2.11 h396b838_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libedit 3.1.20191231 h14c3975_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 he6710b0_0", + "libllvm9 9.0.1 h4a3c616_1", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 he6710b0_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_1", + "libtool 2.4.6 h7b6447c_5", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 he19cac6_1", + "libxslt 1.1.34 hc22bd24_0", + "llvmlite 0.33.0 py38hc6ec683_1", + "locket 0.2.0 py38_1", + "lxml 4.5.2 py38hefd8a0e_0", + "lz4-c 1.9.2 he6710b0_0", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py38h7b6447c_0", + "matplotlib 3.2.2 0", + "matplotlib-base 3.2.2 py38hef1b27d_0", + "mccabe 0.6.1 py38_1", + "mistune 0.8.4 py38h7b6447c_1000", + "mkl 2020.1 217", + "mkl-service 2.3.0 py38he904b0f_0", + "mkl_fft 1.1.0 py38h23d657b_0", + "mkl_random 1.1.1 py38h0573a6f_0", + "mock 4.0.2 py_0", + "more-itertools 8.4.0 py_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.1.0 py38_0", + "msgpack-python 1.0.0 py38hfd86e86_1", + "multipledispatch 0.6.0 py38_0", + "nbconvert 5.6.1 py38_0", + "nbformat 5.0.7 py_0", + "ncurses 6.2 he6710b0_1", + "networkx 2.4 py_1", + "nltk 3.5 py_0", + "nose 1.3.7 py38_2", + "notebook 6.0.3 py38_0", + "numba 0.50.1 py38h0573a6f_1", + "numexpr 2.7.1 py38h423224d_0", + "numpy 1.18.5 py38ha1c710e_0", + "numpy-base 1.18.5 py38hde5b4d6_0", + "numpydoc 1.1.0 py_0", + "olefile 0.46 py_0", + "openpyxl 3.0.4 py_0", + "openssl 1.1.1g h7b6447c_0", + "packaging 20.4 py_0", + "pandas 1.0.5 py38h0573a6f_0", + "pandoc 2.10 0", + "pandocfilters 1.4.2 py38_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.1.0 py_0", + "patchelf 0.11 he6710b0_0", + "path 13.1.0 py38_0", + "path.py 12.4.0 0", + "pathlib2 2.3.5 py38_0", + "pathtools 0.1.2 py_1", + "patsy 0.5.1 py38_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py38_0", + "pexpect 4.8.0 py38_0", + "pickleshare 0.7.5 py38_1000", + "pillow 7.2.0 py38hb39fc2d_0", + "pip 20.1.1 py38_1", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.5.0.1 py38_0", + "pluggy 0.13.1 py38_0", + "ply 3.11 py38_0", + "prometheus_client 0.8.0 py_0", + "prompt-toolkit 3.0.5 py_0", + "prompt_toolkit 3.0.5 0", + "psutil 5.7.0 py38h7b6447c_0", + "ptyprocess 0.6.0 py38_0", + "py 1.9.0 py_0", + "py-lief 0.10.1 py38h403a769_0", + "pycodestyle 2.6.0 py_0", + "pycosat 0.6.3 py38h7b6447c_1", + "pycparser 2.20 py_2", + "pycurl 7.43.0.5 py38h1ba5d50_0", + "pydocstyle 5.0.2 py_0", + "pyflakes 2.2.0 py_0", + "pygments 2.6.1 py_0", + "pylint 2.5.3 py38_0", + "pyodbc 4.0.30 py38he6710b0_0", + "pyopenssl 19.1.0 py_1", + "pyparsing 2.4.7 py_0", + "pyqt 5.9.2 py38h05f1152_4", + "pyrsistent 0.16.0 py38h7b6447c_0", + "pysocks 1.7.1 py38_0", + "pytables 3.6.1 py38h9fd0a39_0", + "pytest 5.4.3 py38_0", + "python 3.8.3 hcff3b4d_2", + "python-dateutil 2.8.1 py_0", + "python-jsonrpc-server 0.3.4 py_1", + "python-language-server 0.34.1 py38_0", + "python-libarchive-c 2.9 py_0", + "pytz 2020.1 py_0", + "pywavelets 1.1.1 py38h7b6447c_0", + "pyxdg 0.26 py_0", + "pyyaml 5.3.1 py38h7b6447c_1", + "pyzmq 19.0.1 py38he6710b0_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 0.7.2 py_0", + "qtconsole 4.7.5 py_0", + "qtpy 1.9.0 py_0", + "readline 8.0 h7b6447c_0", + "regex 2020.6.8 py38h7b6447c_0", + "requests 2.24.0 py_0", + "ripgrep 11.0.2 he32d670_0", + "rope 0.17.0 py_0", + "rtree 0.9.4 py38_1", + "ruamel_yaml 0.15.87 py38h7b6447c_1", + "scikit-image 0.16.2 py38h0573a6f_0", + "scikit-learn 0.23.1 py38h423224d_0", + "scipy 1.5.0 py38h0b6359f_0", + "seaborn 0.10.1 py_0", + "secretstorage 3.1.2 py38_0", + "send2trash 1.5.0 py38_0", + "setuptools 49.2.0 py38_0", + "simplegeneric 0.8.1 py38_2", + "singledispatch 3.4.0.3 py38_0", + "sip 4.19.13 py38he6710b0_0", + "six 1.15.0 py_0", + "snappy 1.1.8 he6710b0_0", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.2.1 py_0", + "sortedcontainers 2.2.2 py_0", + "soupsieve 2.0.1 py_0", + "sphinx 3.1.2 py_0", + "sphinxcontrib 1.0 py38_1", + "sphinxcontrib-applehelp 1.0.2 py_0", + "sphinxcontrib-devhelp 1.0.2 py_0", + "sphinxcontrib-htmlhelp 1.0.3 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.3 py_0", + "sphinxcontrib-serializinghtml 1.1.4 py_0", + "sphinxcontrib-websupport 1.2.3 py_0", + "spyder 4.1.4 py38_0", + "spyder-kernels 1.9.2 py38_0", + "sqlalchemy 1.3.18 py38h7b6447c_0", + "sqlite 3.32.3 h62c20be_0", + "statsmodels 0.11.1 py38h7b6447c_0", + "sympy 1.6.1 py38_0", + "tbb 2020.0 hfd86e86_0", + "tblib 1.6.0 py_0", + "terminado 0.8.3 py38_0", + "testpath 0.4.4 py_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "tk 8.6.10 hbc83047_0", + "toml 0.10.1 py_0", + "toolz 0.10.0 py_0", + "tornado 6.0.4 py38h7b6447c_1", + "tqdm 4.47.0 py_0", + "traitlets 4.3.3 py38_0", + "typing_extensions 3.7.4.2 py_0", + "ujson 1.35 py38h7b6447c_0", + "unicodecsv 0.14.1 py38_0", + "unixodbc 2.3.7 h14c3975_0", + "urllib3 1.25.9 py_0", + "watchdog 0.10.3 py38_0", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py38_1", + "werkzeug 1.0.1 py_0", + "wheel 0.34.2 py38_0", + "widgetsnbextension 3.5.1 py38_0", + "wrapt 1.11.2 py38h7b6447c_0", + "wurlitzer 2.0.1 py38_0", + "xlrd 1.2.0 py_0", + "xlsxwriter 1.2.9 py_0", + "xlwt 1.3.0 py38_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.30.0 py_0", + "zeromq 4.3.2 he6710b0_2", + "zict 2.0.0 py_0", + "zipp 3.1.0 py_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py38_1", + "zope.event 4.4 py38_0", + "zope.interface 4.7.1 py38h7b6447c_0", + "zstd 1.4.5 h0b5b093_0" + ], + "license": "BSD", + "md5": "ecccce6b83f2a8ec62d450064f252517", + "name": "anaconda", + "namespace": "python", + "sha256": "a0c322368a2b3caf25c7253e5e91e5433f0c9a14075053a549751a42cfeee345", + "size": 17288, + "subdir": "linux-64", + "timestamp": 1595029540792, + "version": "2020.07" + }, + "anaconda-2020.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.7.2 py37_0", + "anaconda-project 0.8.4 py_0", + "argh 0.26.2 py37_0", + "argon2-cffi 20.1.0 py37h7b6447c_1", + "asn1crypto 1.4.0 py_0", + "astroid 2.4.2 py37_0", + "astropy 4.0.2 py37h7b6447c_0", + "async_generator 1.10 py37h28b3542_0", + "atomicwrites 1.4.0 py_0", + "attrs 20.3.0 pyhd3eb1b0_0", + "autopep8 1.5.4 py_0", + "babel 2.8.1 pyhd3eb1b0_0", + "backcall 0.2.0 py_0", + "backports 1.0 py_2", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "beautifulsoup4 4.9.3 pyhb0f4dca_0", + "bitarray 1.6.1 py37h27cfd23_0", + "bkcharts 0.2 py37_0", + "blas 1.0 mkl", + "bleach 3.2.1 py_0", + "blosc 1.20.1 hd408876_0", + "bokeh 2.2.3 py37_0", + "boto 2.49.0 py37_0", + "bottleneck 1.3.2 py37heb32a55_1", + "brotlipy 0.7.0 py37h7b6447c_1000", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2020.10.14 0", + "cairo 1.14.12 h8948797_3", + "certifi 2020.6.20 pyhd3eb1b0_3", + "cffi 1.14.3 py37he30daa8_0", + "chardet 3.0.4 py37_1003", + "click 7.1.2 py_0", + "cloudpickle 1.6.0 py_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.4 py_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 3.1.1 py37h1ba5d50_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py37_0", + "cython 0.29.21 py37he6710b0_0", + "cytoolz 0.11.0 py37h7b6447c_0", + "dask 2.30.0 py_0", + "dask-core 2.30.0 py_0", + "dbus 1.13.18 hb2f20db_0", + "decorator 4.4.2 py_0", + "defusedxml 0.6.0 py_0", + "diff-match-patch 20200713 py_0", + "distributed 2.30.1 py37h06a4308_0", + "docutils 0.16 py37_1", + "entrypoints 0.3 py37_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.2.10 he6710b0_2", + "fastcache 1.1.0 py37h7b6447c_0", + "filelock 3.0.12 py_0", + "flake8 3.8.4 py_0", + "flask 1.1.2 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 0.8.3 py_0", + "future 0.18.2 py37_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 20.9.0 py37h7b6447c_0", + "glib 2.66.1 h92f7085_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.14 h23475e2_0", + "greenlet 0.4.17 py37h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb31296c_0", + "h5py 2.10.0 py37h7918eee_0", + "harfbuzz 2.4.0 hca77d97_1", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 py_0", + "imageio 2.9.0 py_0", + "imagesize 1.2.0 py_0", + "importlib-metadata 2.0.0 py_1", + "importlib_metadata 2.0.0 1", + "iniconfig 1.1.1 py_0", + "intel-openmp 2020.2 254", + "intervaltree 3.1.0 py_0", + "ipykernel 5.3.4 py37h5ca1d4c_0", + "ipython 7.19.0 py37hb070fc8_0", + "ipython_genutils 0.2.0 py37_0", + "ipywidgets 7.5.1 py_1", + "isort 5.6.4 py_0", + "itsdangerous 1.1.0 py37_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.1 py37_0", + "jeepney 0.5.0 pyhd3eb1b0_0", + "jinja2 2.11.2 py_0", + "joblib 0.17.0 py_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py_2", + "jupyter 1.0.0 py37_7", + "jupyter_client 6.1.7 py_0", + "jupyter_console 6.2.0 py_0", + "jupyter_core 4.6.3 py37_0", + "jupyterlab 2.2.6 py_0", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 1.2.0 py_0", + "keyring 21.4.0 py37_1", + "kiwisolver 1.3.0 py37h2531618_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.4.3 py37h7b6447c_0", + "lcms2 2.11 h396b838_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libedit 3.1.20191231 h14c3975_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 he6710b0_0", + "libllvm10 10.0.1 hbcb73fb_5", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 he6710b0_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_1", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 hb55368b_3", + "libxslt 1.1.34 hc22bd24_0", + "llvmlite 0.34.0 py37h269e1b5_4", + "locket 0.2.0 py37_1", + "lxml 4.6.1 py37hefd8a0e_0", + "lz4-c 1.9.2 heb0550a_3", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py37h14c3975_1", + "matplotlib 3.3.2 0", + "matplotlib-base 3.3.2 py37h817c723_0", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h14c3975_1001", + "mkl 2020.2 256", + "mkl-service 2.3.0 py37he904b0f_0", + "mkl_fft 1.2.0 py37h23d657b_0", + "mkl_random 1.1.1 py37h0573a6f_0", + "mock 4.0.2 py_0", + "more-itertools 8.6.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.1.0 py37_0", + "msgpack-python 1.0.0 py37hfd86e86_1", + "multipledispatch 0.6.0 py37_0", + "nbclient 0.5.1 py_0", + "nbconvert 6.0.7 py37_0", + "nbformat 5.0.8 py_0", + "ncurses 6.2 he6710b0_1", + "nest-asyncio 1.4.2 pyhd3eb1b0_0", + "networkx 2.5 py_0", + "nltk 3.5 py_0", + "nose 1.3.7 py37_1004", + "notebook 6.1.4 py37_0", + "numba 0.51.2 py37h04863e7_1", + "numexpr 2.7.1 py37h423224d_0", + "numpy 1.19.2 py37h54aff64_0", + "numpy-base 1.19.2 py37hfa32c7d_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 py37_0", + "openpyxl 3.0.5 py_0", + "openssl 1.1.1h h7b6447c_0", + "packaging 20.4 py_0", + "pandas 1.1.3 py37he6710b0_0", + "pandoc 2.11 hb0f4dca_0", + "pandocfilters 1.4.3 py37h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.1.0 py_0", + "patchelf 0.12 he6710b0_0", + "path 15.0.0 py37_0", + "path.py 12.5.0 0", + "pathlib2 2.3.5 py37_1", + "pathtools 0.1.2 py_1", + "patsy 0.5.1 py37_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py37_0", + "pexpect 4.8.0 py37_1", + "pickleshare 0.7.5 py37_1001", + "pillow 8.0.1 py37he98fc37_0", + "pip 20.2.4 py37h06a4308_0", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.6.1 py37h06a4308_0", + "pluggy 0.13.1 py37_0", + "ply 3.11 py37_0", + "prometheus_client 0.8.0 py_0", + "prompt-toolkit 3.0.8 py_0", + "prompt_toolkit 3.0.8 0", + "psutil 5.7.2 py37h7b6447c_0", + "ptyprocess 0.6.0 py37_0", + "py 1.9.0 py_0", + "py-lief 0.10.1 py37h403a769_0", + "pycodestyle 2.6.0 py_0", + "pycosat 0.6.3 py37h7b6447c_0", + "pycparser 2.20 py_2", + "pycrypto 2.6.1 py37h7b6447c_10", + "pycurl 7.43.0.6 py37h1ba5d50_0", + "pydocstyle 5.1.1 py_0", + "pyflakes 2.2.0 py_0", + "pygments 2.7.2 pyhd3eb1b0_0", + "pylint 2.6.0 py37_0", + "pyodbc 4.0.30 py37he6710b0_0", + "pyopenssl 19.1.0 py_1", + "pyparsing 2.4.7 py_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.17.3 py37h7b6447c_0", + "pysocks 1.7.1 py37_1", + "pytables 3.6.1 py37h71ec239_0", + "pytest 6.1.1 py37_0", + "python 3.7.9 h7579374_0", + "python-dateutil 2.8.1 py_0", + "python-jsonrpc-server 0.4.0 py_0", + "python-language-server 0.35.1 py_0", + "python-libarchive-c 2.9 py_0", + "pytz 2020.1 py_0", + "pywavelets 1.1.1 py37h7b6447c_2", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 5.3.1 py37h7b6447c_1", + "pyzmq 19.0.2 py37he6710b0_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.1 py_0", + "qtconsole 4.7.7 py_0", + "qtpy 1.9.0 py_0", + "readline 8.0 h7b6447c_0", + "regex 2020.10.15 py37h7b6447c_0", + "requests 2.24.0 py_0", + "ripgrep 12.1.1 0", + "rope 0.18.0 py_0", + "rtree 0.9.4 py37_1", + "ruamel_yaml 0.15.87 py37h7b6447c_1", + "scikit-image 0.17.2 py37hdf5156a_0", + "scikit-learn 0.23.2 py37h0573a6f_0", + "scipy 1.5.2 py37h0b6359f_0", + "seaborn 0.11.0 py_0", + "secretstorage 3.1.2 py37_1", + "send2trash 1.5.0 py37_0", + "setuptools 50.3.1 py37h06a4308_1", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.4.0.3 py_1001", + "sip 4.19.8 py37hf484d3e_0", + "six 1.15.0 py37h06a4308_0", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.2.1 py_0", + "sortedcontainers 2.2.2 py_0", + "soupsieve 2.0.1 py_0", + "sphinx 3.2.1 py_0", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-applehelp 1.0.2 py_0", + "sphinxcontrib-devhelp 1.0.2 py_0", + "sphinxcontrib-htmlhelp 1.0.3 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.3 py_0", + "sphinxcontrib-serializinghtml 1.1.4 py_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 4.1.5 py37_0", + "spyder-kernels 1.9.4 py37_0", + "sqlalchemy 1.3.20 py37h27cfd23_0", + "sqlite 3.33.0 h62c20be_0", + "statsmodels 0.12.0 py37h7b6447c_0", + "sympy 1.6.2 py37h06a4308_1", + "tbb 2020.3 hfd86e86_0", + "tblib 1.7.0 py_0", + "terminado 0.9.1 py37_0", + "testpath 0.4.4 py_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "tifffile 2020.10.1 py37hdd07704_2", + "tk 8.6.10 hbc83047_0", + "toml 0.10.1 py_0", + "toolz 0.11.1 py_0", + "tornado 6.0.4 py37h7b6447c_1", + "tqdm 4.50.2 py_0", + "traitlets 5.0.5 py_0", + "typed-ast 1.4.1 py37h7b6447c_0", + "typing_extensions 3.7.4.3 py_0", + "ujson 4.0.1 py37he6710b0_0", + "unicodecsv 0.14.1 py37_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.25.11 py_0", + "watchdog 0.10.3 py37_0", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py37_1", + "werkzeug 1.0.1 py_0", + "wheel 0.35.1 py_0", + "widgetsnbextension 3.5.1 py37_0", + "wrapt 1.11.2 py37h7b6447c_0", + "wurlitzer 2.0.1 py37_0", + "xlrd 1.2.0 py37_0", + "xlsxwriter 1.3.7 py_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.30.0 py_0", + "zeromq 4.3.3 he6710b0_3", + "zict 2.0.0 py_0", + "zipp 3.4.0 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py37_1", + "zope.event 4.5.0 py37_0", + "zope.interface 5.1.2 py37h7b6447c_0", + "zstd 1.4.5 h9ceee32_0" + ], + "license": "BSD", + "md5": "aefa61ac0d931ea2efcd6d6edce76d22", + "name": "anaconda", + "namespace": "python", + "sha256": "36f03a211d91a1ee03c8cd81328d3b40111306afa4e2f1fba875902c9ac4a4db", + "size": 17678, + "subdir": "linux-64", + "timestamp": 1605289428528, + "version": "2020.11" + }, + "anaconda-2020.11-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py_0", + "anaconda-client 1.7.2 py38_0", + "anaconda-project 0.8.4 py_0", + "argh 0.26.2 py38_0", + "argon2-cffi 20.1.0 py38h7b6447c_1", + "asn1crypto 1.4.0 py_0", + "astroid 2.4.2 py38_0", + "astropy 4.0.2 py38h7b6447c_0", + "async_generator 1.10 py_0", + "atomicwrites 1.4.0 py_0", + "attrs 20.3.0 pyhd3eb1b0_0", + "autopep8 1.5.4 py_0", + "babel 2.8.1 pyhd3eb1b0_0", + "backcall 0.2.0 py_0", + "backports 1.0 py_2", + "backports.shutil_get_terminal_size 1.0.0 py38_2", + "beautifulsoup4 4.9.3 pyhb0f4dca_0", + "bitarray 1.6.1 py38h27cfd23_0", + "bkcharts 0.2 py38_0", + "blas 1.0 mkl", + "bleach 3.2.1 py_0", + "blosc 1.20.1 hd408876_0", + "bokeh 2.2.3 py38_0", + "boto 2.49.0 py38_0", + "bottleneck 1.3.2 py38heb32a55_1", + "brotlipy 0.7.0 py38h7b6447c_1000", + "bzip2 1.0.8 h7b6447c_0", + "ca-certificates 2020.10.14 0", + "cairo 1.14.12 h8948797_3", + "certifi 2020.6.20 pyhd3eb1b0_3", + "cffi 1.14.3 py38he30daa8_0", + "chardet 3.0.4 py38_1003", + "click 7.1.2 py_0", + "cloudpickle 1.6.0 py_0", + "clyent 1.2.2 py38_1", + "colorama 0.4.4 py_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 3.1.1 py38h1ba5d50_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py38_0", + "cython 0.29.21 py38he6710b0_0", + "cytoolz 0.11.0 py38h7b6447c_0", + "dask 2.30.0 py_0", + "dask-core 2.30.0 py_0", + "dbus 1.13.18 hb2f20db_0", + "decorator 4.4.2 py_0", + "defusedxml 0.6.0 py_0", + "diff-match-patch 20200713 py_0", + "distributed 2.30.1 py38h06a4308_0", + "docutils 0.16 py38_1", + "entrypoints 0.3 py38_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.2.10 he6710b0_2", + "fastcache 1.1.0 py38h7b6447c_0", + "filelock 3.0.12 py_0", + "flake8 3.8.4 py_0", + "flask 1.1.2 py_0", + "fontconfig 2.13.0 h9420a91_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 0.8.3 py_0", + "future 0.18.2 py38_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 20.9.0 py38h7b6447c_0", + "glib 2.66.1 h92f7085_0", + "glob2 0.7 py_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py38hd5f6e3b_3", + "graphite2 1.3.14 h23475e2_0", + "greenlet 0.4.17 py38h7b6447c_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "gstreamer 1.14.0 hb31296c_0", + "h5py 2.10.0 py38h7918eee_0", + "harfbuzz 2.4.0 hca77d97_1", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 py_0", + "imageio 2.9.0 py_0", + "imagesize 1.2.0 py_0", + "importlib-metadata 2.0.0 py_1", + "importlib_metadata 2.0.0 1", + "iniconfig 1.1.1 py_0", + "intel-openmp 2020.2 254", + "intervaltree 3.1.0 py_0", + "ipykernel 5.3.4 py38h5ca1d4c_0", + "ipython 7.19.0 py38hb070fc8_0", + "ipython_genutils 0.2.0 py38_0", + "ipywidgets 7.5.1 py_1", + "isort 5.6.4 py_0", + "itsdangerous 1.1.0 py_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.1 py38_0", + "jeepney 0.5.0 pyhd3eb1b0_0", + "jinja2 2.11.2 py_0", + "joblib 0.17.0 py_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py_2", + "jupyter 1.0.0 py38_7", + "jupyter_client 6.1.7 py_0", + "jupyter_console 6.2.0 py_0", + "jupyter_core 4.6.3 py38_0", + "jupyterlab 2.2.6 py_0", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 1.2.0 py_0", + "keyring 21.4.0 py38_1", + "kiwisolver 1.3.0 py38h2531618_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.4.3 py38h7b6447c_0", + "lcms2 2.11 h396b838_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libedit 3.1.20191231 h14c3975_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 he6710b0_0", + "libllvm10 10.0.1 hbcb73fb_5", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 he6710b0_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_1", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h1bed415_2", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 hb55368b_3", + "libxslt 1.1.34 hc22bd24_0", + "llvmlite 0.34.0 py38h269e1b5_4", + "locket 0.2.0 py38_1", + "lxml 4.6.1 py38hefd8a0e_0", + "lz4-c 1.9.2 heb0550a_3", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py38h7b6447c_0", + "matplotlib 3.3.2 0", + "matplotlib-base 3.3.2 py38h817c723_0", + "mccabe 0.6.1 py38_1", + "mistune 0.8.4 py38h7b6447c_1000", + "mkl 2020.2 256", + "mkl-service 2.3.0 py38he904b0f_0", + "mkl_fft 1.2.0 py38h23d657b_0", + "mkl_random 1.1.1 py38h0573a6f_0", + "mock 4.0.2 py_0", + "more-itertools 8.6.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.1.0 py38_0", + "msgpack-python 1.0.0 py38hfd86e86_1", + "multipledispatch 0.6.0 py38_0", + "nbclient 0.5.1 py_0", + "nbconvert 6.0.7 py38_0", + "nbformat 5.0.8 py_0", + "ncurses 6.2 he6710b0_1", + "nest-asyncio 1.4.2 pyhd3eb1b0_0", + "networkx 2.5 py_0", + "nltk 3.5 py_0", + "nose 1.3.7 py38_2", + "notebook 6.1.4 py38_0", + "numba 0.51.2 py38h0573a6f_1", + "numexpr 2.7.1 py38h423224d_0", + "numpy 1.19.2 py38h54aff64_0", + "numpy-base 1.19.2 py38hfa32c7d_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 py_0", + "openpyxl 3.0.5 py_0", + "openssl 1.1.1h h7b6447c_0", + "packaging 20.4 py_0", + "pandas 1.1.3 py38he6710b0_0", + "pandoc 2.11 hb0f4dca_0", + "pandocfilters 1.4.3 py38h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.1.0 py_0", + "patchelf 0.12 he6710b0_0", + "path 15.0.0 py38_0", + "path.py 12.5.0 0", + "pathlib2 2.3.5 py38_0", + "pathtools 0.1.2 py_1", + "patsy 0.5.1 py38_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py38_0", + "pexpect 4.8.0 py38_0", + "pickleshare 0.7.5 py38_1000", + "pillow 8.0.1 py38he98fc37_0", + "pip 20.2.4 py38h06a4308_0", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.6.1 py38h06a4308_0", + "pluggy 0.13.1 py38_0", + "ply 3.11 py38_0", + "prometheus_client 0.8.0 py_0", + "prompt-toolkit 3.0.8 py_0", + "prompt_toolkit 3.0.8 0", + "psutil 5.7.2 py38h7b6447c_0", + "ptyprocess 0.6.0 py38_0", + "py 1.9.0 py_0", + "py-lief 0.10.1 py38h403a769_0", + "pycodestyle 2.6.0 py_0", + "pycosat 0.6.3 py38h7b6447c_1", + "pycparser 2.20 py_2", + "pycurl 7.43.0.6 py38h1ba5d50_0", + "pydocstyle 5.1.1 py_0", + "pyflakes 2.2.0 py_0", + "pygments 2.7.2 pyhd3eb1b0_0", + "pylint 2.6.0 py38_0", + "pyodbc 4.0.30 py38he6710b0_0", + "pyopenssl 19.1.0 py_1", + "pyparsing 2.4.7 py_0", + "pyqt 5.9.2 py38h05f1152_4", + "pyrsistent 0.17.3 py38h7b6447c_0", + "pysocks 1.7.1 py38_0", + "pytables 3.6.1 py38h9fd0a39_0", + "pytest 6.1.1 py38_0", + "python 3.8.5 h7579374_1", + "python-dateutil 2.8.1 py_0", + "python-jsonrpc-server 0.4.0 py_0", + "python-language-server 0.35.1 py_0", + "python-libarchive-c 2.9 py_0", + "pytz 2020.1 py_0", + "pywavelets 1.1.1 py38h7b6447c_2", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 5.3.1 py38h7b6447c_1", + "pyzmq 19.0.2 py38he6710b0_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.1 py_0", + "qtconsole 4.7.7 py_0", + "qtpy 1.9.0 py_0", + "readline 8.0 h7b6447c_0", + "regex 2020.10.15 py38h7b6447c_0", + "requests 2.24.0 py_0", + "ripgrep 12.1.1 0", + "rope 0.18.0 py_0", + "rtree 0.9.4 py38_1", + "ruamel_yaml 0.15.87 py38h7b6447c_1", + "scikit-image 0.17.2 py38hdf5156a_0", + "scikit-learn 0.23.2 py38h0573a6f_0", + "scipy 1.5.2 py38h0b6359f_0", + "seaborn 0.11.0 py_0", + "secretstorage 3.1.2 py38_0", + "send2trash 1.5.0 py38_0", + "setuptools 50.3.1 py38h06a4308_1", + "simplegeneric 0.8.1 py38_2", + "singledispatch 3.4.0.3 py_1001", + "sip 4.19.13 py38he6710b0_0", + "six 1.15.0 py38h06a4308_0", + "snowballstemmer 2.0.0 py_0", + "sortedcollections 1.2.1 py_0", + "sortedcontainers 2.2.2 py_0", + "soupsieve 2.0.1 py_0", + "sphinx 3.2.1 py_0", + "sphinxcontrib 1.0 py38_1", + "sphinxcontrib-applehelp 1.0.2 py_0", + "sphinxcontrib-devhelp 1.0.2 py_0", + "sphinxcontrib-htmlhelp 1.0.3 py_0", + "sphinxcontrib-jsmath 1.0.1 py_0", + "sphinxcontrib-qthelp 1.0.3 py_0", + "sphinxcontrib-serializinghtml 1.1.4 py_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 4.1.5 py38_0", + "spyder-kernels 1.9.4 py38_0", + "sqlalchemy 1.3.20 py38h7b6447c_0", + "sqlite 3.33.0 h62c20be_0", + "statsmodels 0.12.0 py38h7b6447c_0", + "sympy 1.6.2 py38h06a4308_1", + "tbb 2020.3 hfd86e86_0", + "tblib 1.7.0 py_0", + "terminado 0.9.1 py38_0", + "testpath 0.4.4 py_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "tifffile 2020.10.1 py38hdd07704_2", + "tk 8.6.10 hbc83047_0", + "toml 0.10.1 py_0", + "toolz 0.11.1 py_0", + "tornado 6.0.4 py38h7b6447c_1", + "tqdm 4.50.2 py_0", + "traitlets 5.0.5 py_0", + "typing_extensions 3.7.4.3 py_0", + "ujson 4.0.1 py38he6710b0_0", + "unicodecsv 0.14.1 py38_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.25.11 py_0", + "watchdog 0.10.3 py38_0", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py38_1", + "werkzeug 1.0.1 py_0", + "wheel 0.35.1 py_0", + "widgetsnbextension 3.5.1 py38_0", + "wrapt 1.11.2 py38h7b6447c_0", + "wurlitzer 2.0.1 py38_0", + "xlrd 1.2.0 py_0", + "xlsxwriter 1.3.7 py_0", + "xlwt 1.3.0 py38_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.30.0 py_0", + "zeromq 4.3.3 he6710b0_3", + "zict 2.0.0 py_0", + "zipp 3.4.0 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py38_1", + "zope.event 4.5.0 py38_0", + "zope.interface 5.1.2 py38h7b6447c_0", + "zstd 1.4.5 h9ceee32_0" + ], + "license": "BSD", + "md5": "4cdfd3fa4e2feb9ef075fddc8cf716e6", + "name": "anaconda", + "namespace": "python", + "sha256": "1570efc62f2eb4499f7623238645e355965b6797e260335929dfff9c46a70b15", + "size": 17659, + "subdir": "linux-64", + "timestamp": 1605289363851, + "version": "2020.11" + }, + "anaconda-2021.04-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.7.2 py37_0", + "anaconda-project 0.9.1 pyhd3eb1b0_1", + "anyio 2.2.0 py37h06a4308_1", + "appdirs 1.4.4 py_0", + "argh 0.26.2 py37_0", + "argon2-cffi 20.1.0 py37h27cfd23_1", + "asn1crypto 1.4.0 py_0", + "astroid 2.5 py37h06a4308_1", + "astropy 4.2.1 py37h27cfd23_1", + "async_generator 1.10 py37h28b3542_0", + "atomicwrites 1.4.0 py_0", + "attrs 20.3.0 pyhd3eb1b0_0", + "autopep8 1.5.6 pyhd3eb1b0_0", + "babel 2.9.0 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.0 pyhd3eb1b0_2", + "backports.shutil_get_terminal_size 1.0.0 pyhd3eb1b0_3", + "beautifulsoup4 4.9.3 pyha847dfd_0", + "bitarray 1.9.2 py37h27cfd23_1", + "bkcharts 0.2 py37_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 3.3.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.3.1 py37h06a4308_0", + "boto 2.49.0 py37_0", + "bottleneck 1.3.2 py37heb32a55_1", + "brotlipy 0.7.0 py37h27cfd23_1003", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.17.1 h27cfd23_0", + "ca-certificates 2021.4.13 h06a4308_1", + "cairo 1.16.0 hf32fb01_1", + "certifi 2020.12.5 py37h06a4308_0", + "cffi 1.14.5 py37h261ae71_0", + "chardet 4.0.0 py37h06a4308_1003", + "click 7.1.2 pyhd3eb1b0_0", + "cloudpickle 1.6.0 py_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 3.4.7 py37hd23ed53_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py37_0", + "cython 0.29.23 py37h2531618_0", + "cytoolz 0.11.0 py37h7b6447c_0", + "dask 2021.4.0 pyhd3eb1b0_0", + "dask-core 2021.4.0 pyhd3eb1b0_0", + "dbus 1.13.18 hb2f20db_0", + "decorator 5.0.6 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 py_0", + "distributed 2021.4.0 py37h06a4308_0", + "docutils 0.17 py37h06a4308_1", + "entrypoints 0.3 py37_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.3.0 h2531618_2", + "fastcache 1.1.0 py37h7b6447c_0", + "filelock 3.0.12 pyhd3eb1b0_1", + "flake8 3.9.0 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 0.9.0 pyhd3eb1b0_0", + "future 0.18.2 py37_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 21.1.2 py37h27cfd23_1", + "glib 2.68.1 h36276a3_0", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.14 h23475e2_0", + "greenlet 1.0.0 py37h2531618_2", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py37h7918eee_0", + "harfbuzz 2.8.0 h6f93f22_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 pyhd3eb1b0_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.2.0 pyhd3eb1b0_0", + "importlib-metadata 3.10.0 py37h06a4308_0", + "importlib_metadata 3.10.0 hd3eb1b0_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intel-openmp 2021.2.0 h06a4308_610", + "intervaltree 3.1.0 py_0", + "ipykernel 5.3.4 py37h5ca1d4c_0", + "ipython 7.22.0 py37hb070fc8_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.3 pyhd3eb1b0_1", + "isort 5.8.0 pyhd3eb1b0_0", + "itsdangerous 1.1.0 py37_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.2 py37h06a4308_1", + "jeepney 0.6.0 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "joblib 1.0.1 pyhd3eb1b0_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py_2", + "jupyter 1.0.0 py37_7", + "jupyter-packaging 0.7.12 pyhd3eb1b0_0", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.7.1 py37h06a4308_0", + "jupyter_server 1.4.1 py37h06a4308_0", + "jupyterlab 3.0.14 pyhd3eb1b0_1", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.4.0 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "keyring 22.3.0 py37h06a4308_0", + "kiwisolver 1.3.1 py37h2531618_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.6.0 py37h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libedit 3.1.20210216 h27cfd23_1", + "libev 4.33 h7b6447c_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 he6710b0_0", + "libllvm10 10.0.1 hbcb73fb_5", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.2.0 h85742a9_0", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h1bed415_2", + "libuv 1.40.0 h7b6447c_0", + "libwebp-base 1.2.0 h27cfd23_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 hb55368b_3", + "libxslt 1.1.34 hc22bd24_0", + "llvmlite 0.36.0 py37h612dafd_4", + "locket 0.2.1 py37h06a4308_1", + "lxml 4.6.3 py37h9120a33_0", + "lz4-c 1.9.3 h2531618_0", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py37h14c3975_1", + "matplotlib 3.3.4 py37h06a4308_0", + "matplotlib-base 3.3.4 py37h62a2d02_0", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h14c3975_1001", + "mkl 2021.2.0 h06a4308_296", + "mkl-service 2.3.0 py37h27cfd23_1", + "mkl_fft 1.3.0 py37h42c9631_2", + "mkl_random 1.2.1 py37ha9443f7_2", + "mock 4.0.3 pyhd3eb1b0_0", + "more-itertools 8.7.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.2.1 py37h06a4308_0", + "msgpack-python 1.0.2 py37hff7bd54_1", + "multipledispatch 0.6.0 py37_0", + "mypy_extensions 0.4.3 py37_0", + "nbclassic 0.2.6 pyhd3eb1b0_0", + "nbclient 0.5.3 pyhd3eb1b0_0", + "nbconvert 6.0.7 py37_0", + "nbformat 5.1.3 pyhd3eb1b0_0", + "ncurses 6.2 he6710b0_1", + "nest-asyncio 1.5.1 pyhd3eb1b0_0", + "networkx 2.5 py_0", + "nltk 3.6.1 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1006", + "notebook 6.3.0 py37h06a4308_0", + "numexpr 2.7.3 py37h22e1b3c_1", + "numpy 1.20.1 py37h93e21f0_0", + "numpy-base 1.20.1 py37h7d8b39e_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 py37_0", + "openpyxl 3.0.7 pyhd3eb1b0_0", + "openssl 1.1.1k h27cfd23_0", + "packaging 20.9 pyhd3eb1b0_0", + "pandas 1.2.4 py37h2531618_0", + "pandoc 2.12 h06a4308_0", + "pandocfilters 1.4.3 py37h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.2.0 pyhd3eb1b0_0", + "patchelf 0.12 h2531618_1", + "path 15.1.2 py37h06a4308_0", + "path.py 12.5.0 0", + "pathlib2 2.3.5 py37h06a4308_2", + "pathspec 0.7.0 py_0", + "patsy 0.5.1 py37_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py37_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 8.2.0 py37he98fc37_0", + "pip 21.0.1 py37h06a4308_0", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.7.0 py37h06a4308_0", + "pluggy 0.13.1 py37h06a4308_0", + "ply 3.11 py37_0", + "prometheus_client 0.10.1 pyhd3eb1b0_0", + "prompt-toolkit 3.0.17 pyh06a4308_0", + "prompt_toolkit 3.0.17 hd3eb1b0_0", + "psutil 5.8.0 py37h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.10.0 pyhd3eb1b0_0", + "py-lief 0.10.1 py37h403a769_0", + "pycodestyle 2.6.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py37h27cfd23_0", + "pycparser 2.20 py_2", + "pycrypto 2.6.1 py37h7b6447c_10", + "pycurl 7.43.0.6 py37h1ba5d50_0", + "pydocstyle 6.0.0 pyhd3eb1b0_0", + "pyerfa 1.7.3 py37h27cfd23_0", + "pyflakes 2.2.0 pyhd3eb1b0_0", + "pygments 2.8.1 pyhd3eb1b0_0", + "pylint 2.7.4 py37h06a4308_1", + "pyls-black 0.4.6 hd3eb1b0_0", + "pyls-spyder 0.3.2 pyhd3eb1b0_0", + "pyodbc 4.0.30 py37he6710b0_0", + "pyopenssl 20.0.1 pyhd3eb1b0_1", + "pyparsing 2.4.7 pyhd3eb1b0_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.17.3 py37h7b6447c_0", + "pysocks 1.7.1 py37_1", + "pytables 3.6.1 py37h71ec239_0", + "pytest 6.2.3 py37h06a4308_2", + "python 3.7.10 hdb3f193_0", + "python-dateutil 2.8.1 pyhd3eb1b0_0", + "python-jsonrpc-server 0.4.0 py_0", + "python-language-server 0.36.2 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "pytz 2021.1 pyhd3eb1b0_0", + "pywavelets 1.1.1 py37h7b6447c_2", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 5.4.1 py37h27cfd23_1", + "pyzmq 20.0.0 py37h2531618_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.2 pyhd3eb1b0_0", + "qtconsole 5.0.3 pyhd3eb1b0_0", + "qtpy 1.9.0 py_0", + "readline 8.1 h27cfd23_0", + "regex 2021.4.4 py37h27cfd23_0", + "requests 2.25.1 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.18.0 py_0", + "rtree 0.9.7 py37h06a4308_1", + "ruamel_yaml 0.15.100 py37h27cfd23_0", + "scikit-image 0.18.1 py37ha9443f7_0", + "scikit-learn 0.24.1 py37ha9443f7_0", + "scipy 1.6.2 py37had2a1c9_1", + "seaborn 0.11.1 pyhd3eb1b0_0", + "secretstorage 3.3.1 py37h06a4308_0", + "send2trash 1.5.0 pyhd3eb1b0_1", + "setuptools 52.0.0 py37h06a4308_0", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.6.1 pyhd3eb1b0_1001", + "sip 4.19.8 py37hf484d3e_0", + "six 1.15.0 py37h06a4308_0", + "sniffio 1.2.0 py37h06a4308_1", + "snowballstemmer 2.1.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.3.0 pyhd3eb1b0_0", + "soupsieve 2.2.1 pyhd3eb1b0_0", + "sphinx 3.5.3 pyhd3eb1b0_0", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.4 pyhd3eb1b0_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 4.2.5 py37h06a4308_0", + "spyder-kernels 1.10.2 py37h06a4308_0", + "sqlalchemy 1.4.7 py37h27cfd23_0", + "sqlite 3.35.4 hdfb4753_0", + "statsmodels 0.12.2 py37h27cfd23_0", + "sympy 1.8 py37h06a4308_0", + "tblib 1.7.0 py_0", + "terminado 0.9.4 py37h06a4308_0", + "testpath 0.4.4 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2020.10.1 py37hdd07704_2", + "tk 8.6.10 hbc83047_0", + "toml 0.10.2 pyhd3eb1b0_0", + "toolz 0.11.1 pyhd3eb1b0_0", + "tornado 6.1 py37h27cfd23_0", + "tqdm 4.59.0 pyhd3eb1b0_1", + "traitlets 5.0.5 pyhd3eb1b0_0", + "typed-ast 1.4.2 py37h27cfd23_1", + "typing_extensions 3.7.4.3 pyha847dfd_0", + "ujson 4.0.2 py37h2531618_0", + "unicodecsv 0.14.1 py37_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.4 pyhd3eb1b0_0", + "watchdog 1.0.2 py37h06a4308_1", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py37_1", + "werkzeug 1.0.1 pyhd3eb1b0_0", + "wheel 0.36.2 pyhd3eb1b0_0", + "widgetsnbextension 3.5.1 py37_0", + "wrapt 1.12.1 py37h7b6447c_1", + "wurlitzer 2.1.0 py37h06a4308_0", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 1.3.8 pyhd3eb1b0_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.4.1 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py37_1", + "zope.event 4.5.0 py37_0", + "zope.interface 5.3.0 py37h27cfd23_0", + "zstd 1.4.5 h9ceee32_0" + ], + "license": "BSD", + "md5": "476995f862042cd19a6068b44779aa96", + "name": "anaconda", + "namespace": "python", + "sha256": "51192a70bfc7900a6a8e0b5be86ef60dd9ff038d39de2d43d3f27908b422da0d", + "size": 17038, + "subdir": "linux-64", + "timestamp": 1620769972566, + "version": "2021.04" + }, + "anaconda-2021.04-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.7.2 py38_0", + "anaconda-project 0.9.1 pyhd3eb1b0_1", + "anyio 2.2.0 py38h06a4308_1", + "appdirs 1.4.4 py_0", + "argh 0.26.2 py38_0", + "argon2-cffi 20.1.0 py38h27cfd23_1", + "asn1crypto 1.4.0 py_0", + "astroid 2.5 py38h06a4308_1", + "astropy 4.2.1 py38h27cfd23_1", + "async_generator 1.10 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 20.3.0 pyhd3eb1b0_0", + "autopep8 1.5.6 pyhd3eb1b0_0", + "babel 2.9.0 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.0 pyhd3eb1b0_2", + "backports.shutil_get_terminal_size 1.0.0 pyhd3eb1b0_3", + "beautifulsoup4 4.9.3 pyha847dfd_0", + "bitarray 1.9.2 py38h27cfd23_1", + "bkcharts 0.2 py38_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 3.3.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.3.1 py38h06a4308_0", + "boto 2.49.0 py38_0", + "bottleneck 1.3.2 py38heb32a55_1", + "brotlipy 0.7.0 py38h27cfd23_1003", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.17.1 h27cfd23_0", + "ca-certificates 2021.4.13 h06a4308_1", + "cairo 1.16.0 hf32fb01_1", + "certifi 2020.12.5 py38h06a4308_0", + "cffi 1.14.5 py38h261ae71_0", + "chardet 4.0.0 py38h06a4308_1003", + "click 7.1.2 pyhd3eb1b0_0", + "cloudpickle 1.6.0 py_0", + "clyent 1.2.2 py38_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 3.4.7 py38hd23ed53_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py38_0", + "cython 0.29.23 py38h2531618_0", + "cytoolz 0.11.0 py38h7b6447c_0", + "dask 2021.4.0 pyhd3eb1b0_0", + "dask-core 2021.4.0 pyhd3eb1b0_0", + "dbus 1.13.18 hb2f20db_0", + "decorator 5.0.6 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 py_0", + "distributed 2021.4.0 py38h06a4308_0", + "docutils 0.17 py38h06a4308_1", + "entrypoints 0.3 py38_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.3.0 h2531618_2", + "fastcache 1.1.0 py38h7b6447c_0", + "filelock 3.0.12 pyhd3eb1b0_1", + "flake8 3.9.0 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 0.9.0 pyhd3eb1b0_0", + "future 0.18.2 py38_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 21.1.2 py38h27cfd23_1", + "glib 2.68.1 h36276a3_0", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.0.8 py38hd5f6e3b_3", + "graphite2 1.3.14 h23475e2_0", + "greenlet 1.0.0 py38h2531618_2", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py38h7918eee_0", + "harfbuzz 2.8.0 h6f93f22_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 pyhd3eb1b0_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.2.0 pyhd3eb1b0_0", + "importlib-metadata 3.10.0 py38h06a4308_0", + "importlib_metadata 3.10.0 hd3eb1b0_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intel-openmp 2021.2.0 h06a4308_610", + "intervaltree 3.1.0 py_0", + "ipykernel 5.3.4 py38h5ca1d4c_0", + "ipython 7.22.0 py38hb070fc8_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.3 pyhd3eb1b0_1", + "isort 5.8.0 pyhd3eb1b0_0", + "itsdangerous 1.1.0 pyhd3eb1b0_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.2 py38h06a4308_1", + "jeepney 0.6.0 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "joblib 1.0.1 pyhd3eb1b0_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py_2", + "jupyter 1.0.0 py38_7", + "jupyter-packaging 0.7.12 pyhd3eb1b0_0", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.7.1 py38h06a4308_0", + "jupyter_server 1.4.1 py38h06a4308_0", + "jupyterlab 3.0.14 pyhd3eb1b0_1", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.4.0 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "keyring 22.3.0 py38h06a4308_0", + "kiwisolver 1.3.1 py38h2531618_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.6.0 py38h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libedit 3.1.20210216 h27cfd23_1", + "libev 4.33 h7b6447c_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 he6710b0_0", + "libllvm10 10.0.1 hbcb73fb_5", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.2.0 h85742a9_0", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h1bed415_2", + "libuv 1.40.0 h7b6447c_0", + "libwebp-base 1.2.0 h27cfd23_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 hb55368b_3", + "libxslt 1.1.34 hc22bd24_0", + "llvmlite 0.36.0 py38h612dafd_4", + "locket 0.2.1 py38h06a4308_1", + "lxml 4.6.3 py38h9120a33_0", + "lz4-c 1.9.3 h2531618_0", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py38h7b6447c_0", + "matplotlib 3.3.4 py38h06a4308_0", + "matplotlib-base 3.3.4 py38h62a2d02_0", + "mccabe 0.6.1 py38_1", + "mistune 0.8.4 py38h7b6447c_1000", + "mkl 2021.2.0 h06a4308_296", + "mkl-service 2.3.0 py38h27cfd23_1", + "mkl_fft 1.3.0 py38h42c9631_2", + "mkl_random 1.2.1 py38ha9443f7_2", + "mock 4.0.3 pyhd3eb1b0_0", + "more-itertools 8.7.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.2.1 py38h06a4308_0", + "msgpack-python 1.0.2 py38hff7bd54_1", + "multipledispatch 0.6.0 py38_0", + "mypy_extensions 0.4.3 py38_0", + "nbclassic 0.2.6 pyhd3eb1b0_0", + "nbclient 0.5.3 pyhd3eb1b0_0", + "nbconvert 6.0.7 py38_0", + "nbformat 5.1.3 pyhd3eb1b0_0", + "ncurses 6.2 he6710b0_1", + "nest-asyncio 1.5.1 pyhd3eb1b0_0", + "networkx 2.5 py_0", + "nltk 3.6.1 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1006", + "notebook 6.3.0 py38h06a4308_0", + "numexpr 2.7.3 py38h22e1b3c_1", + "numpy 1.20.1 py38h93e21f0_0", + "numpy-base 1.20.1 py38h7d8b39e_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 py_0", + "openpyxl 3.0.7 pyhd3eb1b0_0", + "openssl 1.1.1k h27cfd23_0", + "packaging 20.9 pyhd3eb1b0_0", + "pandas 1.2.4 py38h2531618_0", + "pandoc 2.12 h06a4308_0", + "pandocfilters 1.4.3 py38h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.2.0 pyhd3eb1b0_0", + "patchelf 0.12 h2531618_1", + "path 15.1.2 py38h06a4308_0", + "path.py 12.5.0 0", + "pathlib2 2.3.5 py38h06a4308_2", + "pathspec 0.7.0 py_0", + "patsy 0.5.1 py38_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py38_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 8.2.0 py38he98fc37_0", + "pip 21.0.1 py38h06a4308_0", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.7.0 py38h06a4308_0", + "pluggy 0.13.1 py38h06a4308_0", + "ply 3.11 py38_0", + "prometheus_client 0.10.1 pyhd3eb1b0_0", + "prompt-toolkit 3.0.17 pyh06a4308_0", + "prompt_toolkit 3.0.17 hd3eb1b0_0", + "psutil 5.8.0 py38h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.10.0 pyhd3eb1b0_0", + "py-lief 0.10.1 py38h403a769_0", + "pycodestyle 2.6.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py38h7b6447c_1", + "pycparser 2.20 py_2", + "pycurl 7.43.0.6 py38h1ba5d50_0", + "pydocstyle 6.0.0 pyhd3eb1b0_0", + "pyerfa 1.7.3 py38h27cfd23_0", + "pyflakes 2.2.0 pyhd3eb1b0_0", + "pygments 2.8.1 pyhd3eb1b0_0", + "pylint 2.7.4 py38h06a4308_1", + "pyls-black 0.4.6 hd3eb1b0_0", + "pyls-spyder 0.3.2 pyhd3eb1b0_0", + "pyodbc 4.0.30 py38he6710b0_0", + "pyopenssl 20.0.1 pyhd3eb1b0_1", + "pyparsing 2.4.7 pyhd3eb1b0_0", + "pyqt 5.9.2 py38h05f1152_4", + "pyrsistent 0.17.3 py38h7b6447c_0", + "pysocks 1.7.1 py38h06a4308_0", + "pytables 3.6.1 py38h9fd0a39_0", + "pytest 6.2.3 py38h06a4308_2", + "python 3.8.8 hdb3f193_5", + "python-dateutil 2.8.1 pyhd3eb1b0_0", + "python-jsonrpc-server 0.4.0 py_0", + "python-language-server 0.36.2 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "pytz 2021.1 pyhd3eb1b0_0", + "pywavelets 1.1.1 py38h7b6447c_2", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 5.4.1 py38h27cfd23_1", + "pyzmq 20.0.0 py38h2531618_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.2 pyhd3eb1b0_0", + "qtconsole 5.0.3 pyhd3eb1b0_0", + "qtpy 1.9.0 py_0", + "readline 8.1 h27cfd23_0", + "regex 2021.4.4 py38h27cfd23_0", + "requests 2.25.1 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.18.0 py_0", + "rtree 0.9.7 py38h06a4308_1", + "ruamel_yaml 0.15.100 py38h27cfd23_0", + "scikit-image 0.18.1 py38ha9443f7_0", + "scikit-learn 0.24.1 py38ha9443f7_0", + "scipy 1.6.2 py38had2a1c9_1", + "seaborn 0.11.1 pyhd3eb1b0_0", + "secretstorage 3.3.1 py38h06a4308_0", + "send2trash 1.5.0 pyhd3eb1b0_1", + "setuptools 52.0.0 py38h06a4308_0", + "simplegeneric 0.8.1 py38_2", + "singledispatch 3.6.1 pyhd3eb1b0_1001", + "sip 4.19.13 py38he6710b0_0", + "six 1.15.0 py38h06a4308_0", + "sniffio 1.2.0 py38h06a4308_1", + "snowballstemmer 2.1.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.3.0 pyhd3eb1b0_0", + "soupsieve 2.2.1 pyhd3eb1b0_0", + "sphinx 3.5.3 pyhd3eb1b0_0", + "sphinxcontrib 1.0 py38_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.4 pyhd3eb1b0_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 4.2.5 py38h06a4308_0", + "spyder-kernels 1.10.2 py38h06a4308_0", + "sqlalchemy 1.4.7 py38h27cfd23_0", + "sqlite 3.35.4 hdfb4753_0", + "statsmodels 0.12.2 py38h27cfd23_0", + "sympy 1.8 py38h06a4308_0", + "tblib 1.7.0 py_0", + "terminado 0.9.4 py38h06a4308_0", + "testpath 0.4.4 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2020.10.1 py38hdd07704_2", + "tk 8.6.10 hbc83047_0", + "toml 0.10.2 pyhd3eb1b0_0", + "toolz 0.11.1 pyhd3eb1b0_0", + "tornado 6.1 py38h27cfd23_0", + "tqdm 4.59.0 pyhd3eb1b0_1", + "traitlets 5.0.5 pyhd3eb1b0_0", + "typed-ast 1.4.2 py38h27cfd23_1", + "typing_extensions 3.7.4.3 pyha847dfd_0", + "ujson 4.0.2 py38h2531618_0", + "unicodecsv 0.14.1 py38_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.4 pyhd3eb1b0_0", + "watchdog 1.0.2 py38h06a4308_1", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py38_1", + "werkzeug 1.0.1 pyhd3eb1b0_0", + "wheel 0.36.2 pyhd3eb1b0_0", + "widgetsnbextension 3.5.1 py38_0", + "wrapt 1.12.1 py38h7b6447c_1", + "wurlitzer 2.1.0 py38h06a4308_0", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 1.3.8 pyhd3eb1b0_0", + "xlwt 1.3.0 py38_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.4.1 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py38_1", + "zope.event 4.5.0 py38_0", + "zope.interface 5.3.0 py38h27cfd23_0", + "zstd 1.4.5 h9ceee32_0" + ], + "license": "BSD", + "md5": "c65831d7bdc41be2a4bcfeed69f06b26", + "name": "anaconda", + "namespace": "python", + "sha256": "a5365b7cb016d42bd318f5244794b28d501be130282db7c1b8466019d5847d4f", + "size": 17053, + "subdir": "linux-64", + "timestamp": 1620769962374, + "version": "2021.04" + }, + "anaconda-2021.04-py39_0.conda": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.7.2 py39h06a4308_0", + "anaconda-project 0.9.1 pyhd3eb1b0_1", + "anyio 2.2.0 py39h06a4308_1", + "appdirs 1.4.4 py_0", + "argh 0.26.2 py39h06a4308_0", + "argon2-cffi 20.1.0 py39h27cfd23_1", + "asn1crypto 1.4.0 py_0", + "astroid 2.5 py39h06a4308_1", + "astropy 4.2.1 py39h27cfd23_1", + "async_generator 1.10 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 20.3.0 pyhd3eb1b0_0", + "autopep8 1.5.6 pyhd3eb1b0_0", + "babel 2.9.0 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.0 pyhd3eb1b0_2", + "backports.shutil_get_terminal_size 1.0.0 pyhd3eb1b0_3", + "beautifulsoup4 4.9.3 pyha847dfd_0", + "bitarray 1.9.2 py39h27cfd23_1", + "bkcharts 0.2 py39h06a4308_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 3.3.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.3.1 py39h06a4308_0", + "boto 2.49.0 py39h06a4308_0", + "bottleneck 1.3.2 py39hdd57654_1", + "brotli 1.0.9 he6710b0_2", + "brotlipy 0.7.0 py39h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.17.1 h27cfd23_0", + "ca-certificates 2021.4.13 h06a4308_1", + "cairo 1.16.0 hf32fb01_1", + "certifi 2020.12.5 py39h06a4308_0", + "cffi 1.14.5 py39h261ae71_0", + "chardet 4.0.0 py39h06a4308_1003", + "charls 2.2.0 h2531618_0", + "click 7.1.2 pyhd3eb1b0_0", + "cloudpickle 1.6.0 py_0", + "clyent 1.2.2 py39h06a4308_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 3.4.7 py39hd23ed53_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py39h06a4308_0", + "cython 0.29.23 py39h2531618_0", + "cytoolz 0.11.0 py39h27cfd23_0", + "dask 2021.4.0 pyhd3eb1b0_0", + "dask-core 2021.4.0 pyhd3eb1b0_0", + "dbus 1.13.18 hb2f20db_0", + "decorator 5.0.6 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 py_0", + "distributed 2021.4.0 py39h06a4308_0", + "docutils 0.17 py39h06a4308_1", + "entrypoints 0.3 py39h06a4308_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.3.0 h2531618_2", + "fastcache 1.1.0 py39he8ac12f_0", + "filelock 3.0.12 pyhd3eb1b0_1", + "flake8 3.9.0 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 0.9.0 pyhd3eb1b0_0", + "future 0.18.2 py39h06a4308_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 21.1.2 py39h27cfd23_1", + "giflib 5.1.4 h14c3975_1", + "glib 2.68.1 h36276a3_0", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.0.8 py39h8083e48_3", + "graphite2 1.3.14 h23475e2_0", + "greenlet 1.0.0 py39h2531618_2", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py39hec9cf62_0", + "harfbuzz 2.8.0 h6f93f22_0", + "hdf5 1.10.6 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 pyhd3eb1b0_0", + "imagecodecs 2021.3.31 py39h581e88b_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.2.0 pyhd3eb1b0_0", + "importlib-metadata 3.10.0 py39h06a4308_0", + "importlib_metadata 3.10.0 hd3eb1b0_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intel-openmp 2021.2.0 h06a4308_610", + "intervaltree 3.1.0 py_0", + "ipykernel 5.3.4 py39hb070fc8_0", + "ipython 7.22.0 py39hb070fc8_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.3 pyhd3eb1b0_1", + "isort 5.8.0 pyhd3eb1b0_0", + "itsdangerous 1.1.0 pyhd3eb1b0_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.2 py39h06a4308_1", + "jeepney 0.6.0 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "joblib 1.0.1 pyhd3eb1b0_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py_2", + "jupyter 1.0.0 py39h06a4308_7", + "jupyter-packaging 0.7.12 pyhd3eb1b0_0", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.7.1 py39h06a4308_0", + "jupyter_server 1.4.1 py39h06a4308_0", + "jupyterlab 3.0.14 pyhd3eb1b0_1", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.4.0 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 22.3.0 py39h06a4308_0", + "kiwisolver 1.3.1 py39h2531618_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.6.0 py39h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "lerc 2.2.1 h2531618_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libdeflate 1.7 h27cfd23_5", + "libedit 3.1.20210216 h27cfd23_1", + "libev 4.33 h7b6447c_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 h2531618_1", + "libllvm10 10.0.1 hbcb73fb_5", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_1", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h1bed415_2", + "libuv 1.40.0 h7b6447c_0", + "libwebp 1.0.1 h8e7db2f_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 hb55368b_3", + "libxslt 1.1.34 hc22bd24_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.36.0 py39h612dafd_4", + "locket 0.2.1 py39h06a4308_1", + "lxml 4.6.3 py39h9120a33_0", + "lz4-c 1.9.3 h2531618_0", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py39h27cfd23_0", + "matplotlib 3.3.4 py39h06a4308_0", + "matplotlib-base 3.3.4 py39h62a2d02_0", + "mccabe 0.6.1 py39h06a4308_1", + "mistune 0.8.4 py39h27cfd23_1000", + "mkl 2021.2.0 h06a4308_296", + "mkl-service 2.3.0 py39h27cfd23_1", + "mkl_fft 1.3.0 py39h42c9631_2", + "mkl_random 1.2.1 py39ha9443f7_2", + "mock 4.0.3 pyhd3eb1b0_0", + "more-itertools 8.7.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.2.1 py39h06a4308_0", + "msgpack-python 1.0.2 py39hff7bd54_1", + "multipledispatch 0.6.0 py39h06a4308_0", + "mypy_extensions 0.4.1 py39h06a4308_0", + "nbclassic 0.2.6 pyhd3eb1b0_0", + "nbclient 0.5.3 pyhd3eb1b0_0", + "nbconvert 6.0.7 py39h06a4308_0", + "nbformat 5.1.3 pyhd3eb1b0_0", + "ncurses 6.2 he6710b0_1", + "nest-asyncio 1.5.1 pyhd3eb1b0_0", + "networkx 2.5 py_0", + "nltk 3.6.1 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1006", + "notebook 6.3.0 py39h06a4308_0", + "numexpr 2.7.3 py39h22e1b3c_1", + "numpy 1.20.1 py39h93e21f0_0", + "numpy-base 1.20.1 py39h7d8b39e_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 py_0", + "openjpeg 2.3.0 h05c96fa_1", + "openpyxl 3.0.7 pyhd3eb1b0_0", + "openssl 1.1.1k h27cfd23_0", + "packaging 20.9 pyhd3eb1b0_0", + "pandas 1.2.4 py39h2531618_0", + "pandoc 2.12 h06a4308_0", + "pandocfilters 1.4.3 py39h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.2.0 pyhd3eb1b0_0", + "patchelf 0.12 h2531618_1", + "path 15.1.2 py39h06a4308_0", + "path.py 12.5.0 0", + "pathlib2 2.3.5 py39h06a4308_2", + "pathspec 0.7.0 py_0", + "patsy 0.5.1 py39h06a4308_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py39h06a4308_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 8.2.0 py39he98fc37_0", + "pip 21.0.1 py39h06a4308_0", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.7.0 py39h06a4308_0", + "pluggy 0.13.1 py39h06a4308_0", + "ply 3.11 py39h06a4308_0", + "prometheus_client 0.10.1 pyhd3eb1b0_0", + "prompt-toolkit 3.0.17 pyh06a4308_0", + "prompt_toolkit 3.0.17 hd3eb1b0_0", + "psutil 5.8.0 py39h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.10.0 pyhd3eb1b0_0", + "py-lief 0.10.1 py39h2531618_1", + "pycodestyle 2.6.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py39h27cfd23_0", + "pycparser 2.20 py_2", + "pycurl 7.43.0.6 py39h8b3b800_0", + "pydocstyle 6.0.0 pyhd3eb1b0_0", + "pyerfa 1.7.3 py39h27cfd23_0", + "pyflakes 2.2.0 pyhd3eb1b0_0", + "pygments 2.8.1 pyhd3eb1b0_0", + "pylint 2.7.4 py39h06a4308_1", + "pyls-black 0.4.6 hd3eb1b0_0", + "pyls-spyder 0.3.2 pyhd3eb1b0_0", + "pyodbc 4.0.30 py39h66f3464_0", + "pyopenssl 20.0.1 pyhd3eb1b0_1", + "pyparsing 2.4.7 pyhd3eb1b0_0", + "pyqt 5.9.2 py39h2531618_6", + "pyrsistent 0.17.3 py39h27cfd23_0", + "pysocks 1.7.1 py39h06a4308_0", + "pytables 3.6.1 py39h77479fe_1", + "pytest 6.2.3 py39h06a4308_2", + "python 3.9.4 hdb3f193_0", + "python-dateutil 2.8.1 pyhd3eb1b0_0", + "python-jsonrpc-server 0.4.0 py_0", + "python-language-server 0.36.2 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "pytz 2021.1 pyhd3eb1b0_0", + "pywavelets 1.1.1 py39h6323ea4_4", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 5.4.1 py39h27cfd23_1", + "pyzmq 20.0.0 py39h2531618_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.2 pyhd3eb1b0_0", + "qtconsole 5.0.3 pyhd3eb1b0_0", + "qtpy 1.9.0 py_0", + "readline 8.1 h27cfd23_0", + "regex 2021.4.4 py39h27cfd23_0", + "requests 2.25.1 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.18.0 py_0", + "rtree 0.9.7 py39h06a4308_1", + "ruamel_yaml 0.15.100 py39h27cfd23_0", + "scikit-image 0.18.1 py39ha9443f7_0", + "scikit-learn 0.24.1 py39ha9443f7_0", + "scipy 1.6.2 py39had2a1c9_1", + "seaborn 0.11.1 pyhd3eb1b0_0", + "secretstorage 3.3.1 py39h06a4308_0", + "send2trash 1.5.0 pyhd3eb1b0_1", + "setuptools 52.0.0 py39h06a4308_0", + "simplegeneric 0.8.1 py39h06a4308_2", + "singledispatch 3.6.1 pyhd3eb1b0_1001", + "sip 4.19.13 py39h2531618_0", + "six 1.15.0 py39h06a4308_0", + "snappy 1.1.8 he6710b0_0", + "sniffio 1.2.0 py39h06a4308_1", + "snowballstemmer 2.1.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.3.0 pyhd3eb1b0_0", + "soupsieve 2.2.1 pyhd3eb1b0_0", + "sphinx 3.5.3 pyhd3eb1b0_0", + "sphinxcontrib 1.0 py39h06a4308_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.4 pyhd3eb1b0_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 4.2.5 py39h06a4308_0", + "spyder-kernels 1.10.2 py39h06a4308_0", + "sqlalchemy 1.4.7 py39h27cfd23_0", + "sqlite 3.35.4 hdfb4753_0", + "statsmodels 0.12.2 py39h27cfd23_0", + "sympy 1.8 py39h06a4308_0", + "tblib 1.7.0 py_0", + "terminado 0.9.4 py39h06a4308_0", + "testpath 0.4.4 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.4.8 pyhd3eb1b0_2", + "tk 8.6.10 hbc83047_0", + "toml 0.10.2 pyhd3eb1b0_0", + "toolz 0.11.1 pyhd3eb1b0_0", + "tornado 6.1 py39h27cfd23_0", + "tqdm 4.59.0 pyhd3eb1b0_1", + "traitlets 5.0.5 pyhd3eb1b0_0", + "typed-ast 1.4.2 py39h27cfd23_1", + "typing_extensions 3.7.4.3 pyha847dfd_0", + "tzdata 2020f h52ac0ba_0", + "ujson 4.0.2 py39h2531618_0", + "unicodecsv 0.14.1 py39h06a4308_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.4 pyhd3eb1b0_0", + "watchdog 1.0.2 py39h06a4308_1", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py39h06a4308_1", + "werkzeug 1.0.1 pyhd3eb1b0_0", + "wheel 0.36.2 pyhd3eb1b0_0", + "widgetsnbextension 3.5.1 py39h06a4308_0", + "wrapt 1.12.1 py39he8ac12f_1", + "wurlitzer 2.1.0 py39h06a4308_0", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 1.3.8 pyhd3eb1b0_0", + "xlwt 1.3.0 py39h06a4308_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h2531618_6", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.4.1 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py39h06a4308_1", + "zope.event 4.5.0 py39h06a4308_0", + "zope.interface 5.3.0 py39h27cfd23_0", + "zstd 1.4.5 h9ceee32_0" + ], + "license": "BSD", + "md5": "9da57a22658d04c0d69e83c00bbcae4d", + "name": "anaconda", + "namespace": "python", + "sha256": "dd721bf8714ee8793232363c073164a715be1751061d0b15f4107adc8a22d8be", + "size": 17376, + "subdir": "linux-64", + "timestamp": 1620769939078, + "version": "2021.04" + }, + "anaconda-2021.05-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.7.2 py37_0", + "anaconda-project 0.9.1 pyhd3eb1b0_1", + "anyio 2.2.0 py37h06a4308_1", + "appdirs 1.4.4 py_0", + "argh 0.26.2 py37_0", + "argon2-cffi 20.1.0 py37h27cfd23_1", + "asn1crypto 1.4.0 py_0", + "astroid 2.5 py37h06a4308_1", + "astropy 4.2.1 py37h27cfd23_1", + "async_generator 1.10 py37h28b3542_0", + "atomicwrites 1.4.0 py_0", + "attrs 20.3.0 pyhd3eb1b0_0", + "autopep8 1.5.6 pyhd3eb1b0_0", + "babel 2.9.0 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.0 pyhd3eb1b0_2", + "backports.shutil_get_terminal_size 1.0.0 pyhd3eb1b0_3", + "beautifulsoup4 4.9.3 pyha847dfd_0", + "bitarray 2.1.0 py37h27cfd23_1", + "bkcharts 0.2 py37_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 3.3.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.3.2 py37h06a4308_0", + "boto 2.49.0 py37_0", + "bottleneck 1.3.2 py37heb32a55_1", + "brotlipy 0.7.0 py37h27cfd23_1003", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.17.1 h27cfd23_0", + "ca-certificates 2021.4.13 h06a4308_1", + "cairo 1.16.0 hf32fb01_1", + "certifi 2020.12.5 py37h06a4308_0", + "cffi 1.14.5 py37h261ae71_0", + "chardet 4.0.0 py37h06a4308_1003", + "click 7.1.2 pyhd3eb1b0_0", + "cloudpickle 1.6.0 py_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 3.4.7 py37hd23ed53_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py37_0", + "cython 0.29.23 py37h2531618_0", + "cytoolz 0.11.0 py37h7b6447c_0", + "dask 2021.4.0 pyhd3eb1b0_0", + "dask-core 2021.4.0 pyhd3eb1b0_0", + "dbus 1.13.18 hb2f20db_0", + "decorator 5.0.6 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 py_0", + "distributed 2021.4.1 py37h06a4308_0", + "docutils 0.17.1 py37h06a4308_1", + "entrypoints 0.3 py37_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.3.0 h2531618_2", + "fastcache 1.1.0 py37h7b6447c_0", + "filelock 3.0.12 pyhd3eb1b0_1", + "flake8 3.9.0 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 0.9.0 pyhd3eb1b0_0", + "future 0.18.2 py37_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 21.1.2 py37h27cfd23_1", + "glib 2.68.1 h36276a3_0", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.14 h23475e2_0", + "greenlet 1.0.0 py37h2531618_2", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py37h7918eee_0", + "harfbuzz 2.8.0 h6f93f22_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 pyhd3eb1b0_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.2.0 pyhd3eb1b0_0", + "importlib-metadata 3.10.0 py37h06a4308_0", + "importlib_metadata 3.10.0 hd3eb1b0_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intel-openmp 2021.2.0 h06a4308_610", + "intervaltree 3.1.0 py_0", + "ipykernel 5.3.4 py37h5ca1d4c_0", + "ipython 7.22.0 py37hb070fc8_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.3 pyhd3eb1b0_1", + "isort 5.8.0 pyhd3eb1b0_0", + "itsdangerous 1.1.0 py37_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.2 py37h06a4308_1", + "jeepney 0.6.0 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "joblib 1.0.1 pyhd3eb1b0_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py_2", + "jupyter 1.0.0 py37_7", + "jupyter-packaging 0.7.12 pyhd3eb1b0_0", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.7.1 py37h06a4308_0", + "jupyter_server 1.4.1 py37h06a4308_0", + "jupyterlab 3.0.14 pyhd3eb1b0_1", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.4.0 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "keyring 22.3.0 py37h06a4308_0", + "kiwisolver 1.3.1 py37h2531618_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.6.0 py37h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libedit 3.1.20210216 h27cfd23_1", + "libev 4.33 h7b6447c_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 he6710b0_0", + "libllvm10 10.0.1 hbcb73fb_5", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.2.0 h85742a9_0", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h1bed415_2", + "libuv 1.40.0 h7b6447c_0", + "libwebp-base 1.2.0 h27cfd23_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 hb55368b_3", + "libxslt 1.1.34 hc22bd24_0", + "llvmlite 0.36.0 py37h612dafd_4", + "locket 0.2.1 py37h06a4308_1", + "lxml 4.6.3 py37h9120a33_0", + "lz4-c 1.9.3 h2531618_0", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py37h14c3975_1", + "matplotlib 3.3.4 py37h06a4308_0", + "matplotlib-base 3.3.4 py37h62a2d02_0", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h14c3975_1001", + "mkl 2021.2.0 h06a4308_296", + "mkl-service 2.3.0 py37h27cfd23_1", + "mkl_fft 1.3.0 py37h42c9631_2", + "mkl_random 1.2.1 py37ha9443f7_2", + "mock 4.0.3 pyhd3eb1b0_0", + "more-itertools 8.7.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.2.1 py37h06a4308_0", + "msgpack-python 1.0.2 py37hff7bd54_1", + "multipledispatch 0.6.0 py37_0", + "mypy_extensions 0.4.3 py37_0", + "nbclassic 0.2.6 pyhd3eb1b0_0", + "nbclient 0.5.3 pyhd3eb1b0_0", + "nbconvert 6.0.7 py37_0", + "nbformat 5.1.3 pyhd3eb1b0_0", + "ncurses 6.2 he6710b0_1", + "nest-asyncio 1.5.1 pyhd3eb1b0_0", + "networkx 2.5 py_0", + "nltk 3.6.1 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1006", + "notebook 6.3.0 py37h06a4308_0", + "numba 0.53.1 py37ha9443f7_0", + "numexpr 2.7.3 py37h22e1b3c_1", + "numpy 1.20.1 py37h93e21f0_0", + "numpy-base 1.20.1 py37h7d8b39e_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 py37_0", + "openpyxl 3.0.7 pyhd3eb1b0_0", + "openssl 1.1.1k h27cfd23_0", + "packaging 20.9 pyhd3eb1b0_0", + "pandas 1.2.4 py37h2531618_0", + "pandoc 2.12 h06a4308_0", + "pandocfilters 1.4.3 py37h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.2.0 pyhd3eb1b0_0", + "patchelf 0.12 h2531618_1", + "path 15.1.2 py37h06a4308_0", + "path.py 12.5.0 0", + "pathlib2 2.3.5 py37h06a4308_2", + "pathspec 0.7.0 py_0", + "patsy 0.5.1 py37_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py37_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 8.2.0 py37he98fc37_0", + "pip 21.0.1 py37h06a4308_0", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.7.0 py37h06a4308_0", + "pluggy 0.13.1 py37h06a4308_0", + "ply 3.11 py37_0", + "prometheus_client 0.10.1 pyhd3eb1b0_0", + "prompt-toolkit 3.0.17 pyh06a4308_0", + "prompt_toolkit 3.0.17 hd3eb1b0_0", + "psutil 5.8.0 py37h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.10.0 pyhd3eb1b0_0", + "py-lief 0.10.1 py37h403a769_0", + "pycodestyle 2.6.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py37h27cfd23_0", + "pycparser 2.20 py_2", + "pycrypto 2.6.1 py37h7b6447c_10", + "pycurl 7.43.0.6 py37h1ba5d50_0", + "pydocstyle 6.0.0 pyhd3eb1b0_0", + "pyerfa 1.7.3 py37h27cfd23_0", + "pyflakes 2.2.0 pyhd3eb1b0_0", + "pygments 2.8.1 pyhd3eb1b0_0", + "pylint 2.7.4 py37h06a4308_1", + "pyls-black 0.4.6 hd3eb1b0_0", + "pyls-spyder 0.3.2 pyhd3eb1b0_0", + "pyodbc 4.0.30 py37he6710b0_0", + "pyopenssl 20.0.1 pyhd3eb1b0_1", + "pyparsing 2.4.7 pyhd3eb1b0_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.17.3 py37h7b6447c_0", + "pysocks 1.7.1 py37_1", + "pytables 3.6.1 py37h71ec239_0", + "pytest 6.2.3 py37h06a4308_2", + "python 3.7.10 hdb3f193_0", + "python-dateutil 2.8.1 pyhd3eb1b0_0", + "python-jsonrpc-server 0.4.0 py_0", + "python-language-server 0.36.2 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "pytz 2021.1 pyhd3eb1b0_0", + "pywavelets 1.1.1 py37h7b6447c_2", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 5.4.1 py37h27cfd23_1", + "pyzmq 20.0.0 py37h2531618_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.2 pyhd3eb1b0_0", + "qtconsole 5.0.3 pyhd3eb1b0_0", + "qtpy 1.9.0 py_0", + "readline 8.1 h27cfd23_0", + "regex 2021.4.4 py37h27cfd23_0", + "requests 2.25.1 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.18.0 py_0", + "rtree 0.9.7 py37h06a4308_1", + "ruamel_yaml 0.15.100 py37h27cfd23_0", + "scikit-image 0.18.1 py37ha9443f7_0", + "scikit-learn 0.24.1 py37ha9443f7_0", + "scipy 1.6.2 py37had2a1c9_1", + "seaborn 0.11.1 pyhd3eb1b0_0", + "secretstorage 3.3.1 py37h06a4308_0", + "send2trash 1.5.0 pyhd3eb1b0_1", + "setuptools 52.0.0 py37h06a4308_0", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.6.1 pyhd3eb1b0_1001", + "sip 4.19.8 py37hf484d3e_0", + "six 1.15.0 py37h06a4308_0", + "sniffio 1.2.0 py37h06a4308_1", + "snowballstemmer 2.1.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.3.0 pyhd3eb1b0_0", + "soupsieve 2.2.1 pyhd3eb1b0_0", + "sphinx 4.0.1 pyhd3eb1b0_0", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.4 pyhd3eb1b0_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 4.2.5 py37h06a4308_0", + "spyder-kernels 1.10.2 py37h06a4308_0", + "sqlalchemy 1.4.15 py37h27cfd23_0", + "sqlite 3.35.4 hdfb4753_0", + "statsmodels 0.12.2 py37h27cfd23_0", + "sympy 1.8 py37h06a4308_0", + "tbb 2020.3 hfd86e86_0", + "tblib 1.7.0 py_0", + "terminado 0.9.4 py37h06a4308_0", + "testpath 0.4.4 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2020.10.1 py37hdd07704_2", + "tk 8.6.10 hbc83047_0", + "toml 0.10.2 pyhd3eb1b0_0", + "toolz 0.11.1 pyhd3eb1b0_0", + "tornado 6.1 py37h27cfd23_0", + "tqdm 4.59.0 pyhd3eb1b0_1", + "traitlets 5.0.5 pyhd3eb1b0_0", + "typed-ast 1.4.2 py37h27cfd23_1", + "typing_extensions 3.7.4.3 pyha847dfd_0", + "ujson 4.0.2 py37h2531618_0", + "unicodecsv 0.14.1 py37_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.4 pyhd3eb1b0_0", + "watchdog 1.0.2 py37h06a4308_1", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py37_1", + "werkzeug 1.0.1 pyhd3eb1b0_0", + "wheel 0.36.2 pyhd3eb1b0_0", + "widgetsnbextension 3.5.1 py37_0", + "wrapt 1.12.1 py37h7b6447c_1", + "wurlitzer 2.1.0 py37h06a4308_0", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 1.3.8 pyhd3eb1b0_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.4.1 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py37_1", + "zope.event 4.5.0 py37_0", + "zope.interface 5.3.0 py37h27cfd23_0", + "zstd 1.4.5 h9ceee32_0" + ], + "license": "BSD", + "md5": "0b42bcba1aae4713347a36728de9fe05", + "name": "anaconda", + "namespace": "python", + "sha256": "0851ae62e093401908b9a7736b6d41c7188f784bdbd7a443d0a3dbbdf4149499", + "size": 16971, + "subdir": "linux-64", + "timestamp": 1620924558991, + "version": "2021.05" + }, + "anaconda-2021.05-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.7.2 py38_0", + "anaconda-project 0.9.1 pyhd3eb1b0_1", + "anyio 2.2.0 py38h06a4308_1", + "appdirs 1.4.4 py_0", + "argh 0.26.2 py38_0", + "argon2-cffi 20.1.0 py38h27cfd23_1", + "asn1crypto 1.4.0 py_0", + "astroid 2.5 py38h06a4308_1", + "astropy 4.2.1 py38h27cfd23_1", + "async_generator 1.10 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 20.3.0 pyhd3eb1b0_0", + "autopep8 1.5.6 pyhd3eb1b0_0", + "babel 2.9.0 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.0 pyhd3eb1b0_2", + "backports.shutil_get_terminal_size 1.0.0 pyhd3eb1b0_3", + "beautifulsoup4 4.9.3 pyha847dfd_0", + "bitarray 2.1.0 py38h27cfd23_1", + "bkcharts 0.2 py38_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 3.3.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.3.2 py38h06a4308_0", + "boto 2.49.0 py38_0", + "bottleneck 1.3.2 py38heb32a55_1", + "brotlipy 0.7.0 py38h27cfd23_1003", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.17.1 h27cfd23_0", + "ca-certificates 2021.4.13 h06a4308_1", + "cairo 1.16.0 hf32fb01_1", + "certifi 2020.12.5 py38h06a4308_0", + "cffi 1.14.5 py38h261ae71_0", + "chardet 4.0.0 py38h06a4308_1003", + "click 7.1.2 pyhd3eb1b0_0", + "cloudpickle 1.6.0 py_0", + "clyent 1.2.2 py38_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 3.4.7 py38hd23ed53_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py38_0", + "cython 0.29.23 py38h2531618_0", + "cytoolz 0.11.0 py38h7b6447c_0", + "dask 2021.4.0 pyhd3eb1b0_0", + "dask-core 2021.4.0 pyhd3eb1b0_0", + "dbus 1.13.18 hb2f20db_0", + "decorator 5.0.6 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 py_0", + "distributed 2021.4.1 py38h06a4308_0", + "docutils 0.17.1 py38h06a4308_1", + "entrypoints 0.3 py38_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.3.0 h2531618_2", + "fastcache 1.1.0 py38h7b6447c_0", + "filelock 3.0.12 pyhd3eb1b0_1", + "flake8 3.9.0 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 0.9.0 pyhd3eb1b0_0", + "future 0.18.2 py38_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 21.1.2 py38h27cfd23_1", + "glib 2.68.1 h36276a3_0", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.0.8 py38hd5f6e3b_3", + "graphite2 1.3.14 h23475e2_0", + "greenlet 1.0.0 py38h2531618_2", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py38h7918eee_0", + "harfbuzz 2.8.0 h6f93f22_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 pyhd3eb1b0_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.2.0 pyhd3eb1b0_0", + "importlib-metadata 3.10.0 py38h06a4308_0", + "importlib_metadata 3.10.0 hd3eb1b0_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intel-openmp 2021.2.0 h06a4308_610", + "intervaltree 3.1.0 py_0", + "ipykernel 5.3.4 py38h5ca1d4c_0", + "ipython 7.22.0 py38hb070fc8_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.3 pyhd3eb1b0_1", + "isort 5.8.0 pyhd3eb1b0_0", + "itsdangerous 1.1.0 pyhd3eb1b0_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.2 py38h06a4308_1", + "jeepney 0.6.0 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "joblib 1.0.1 pyhd3eb1b0_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py_2", + "jupyter 1.0.0 py38_7", + "jupyter-packaging 0.7.12 pyhd3eb1b0_0", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.7.1 py38h06a4308_0", + "jupyter_server 1.4.1 py38h06a4308_0", + "jupyterlab 3.0.14 pyhd3eb1b0_1", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.4.0 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "keyring 22.3.0 py38h06a4308_0", + "kiwisolver 1.3.1 py38h2531618_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.6.0 py38h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libedit 3.1.20210216 h27cfd23_1", + "libev 4.33 h7b6447c_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 he6710b0_0", + "libllvm10 10.0.1 hbcb73fb_5", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.2.0 h85742a9_0", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h1bed415_2", + "libuv 1.40.0 h7b6447c_0", + "libwebp-base 1.2.0 h27cfd23_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 hb55368b_3", + "libxslt 1.1.34 hc22bd24_0", + "llvmlite 0.36.0 py38h612dafd_4", + "locket 0.2.1 py38h06a4308_1", + "lxml 4.6.3 py38h9120a33_0", + "lz4-c 1.9.3 h2531618_0", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py38h7b6447c_0", + "matplotlib 3.3.4 py38h06a4308_0", + "matplotlib-base 3.3.4 py38h62a2d02_0", + "mccabe 0.6.1 py38_1", + "mistune 0.8.4 py38h7b6447c_1000", + "mkl 2021.2.0 h06a4308_296", + "mkl-service 2.3.0 py38h27cfd23_1", + "mkl_fft 1.3.0 py38h42c9631_2", + "mkl_random 1.2.1 py38ha9443f7_2", + "mock 4.0.3 pyhd3eb1b0_0", + "more-itertools 8.7.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.2.1 py38h06a4308_0", + "msgpack-python 1.0.2 py38hff7bd54_1", + "multipledispatch 0.6.0 py38_0", + "mypy_extensions 0.4.3 py38_0", + "nbclassic 0.2.6 pyhd3eb1b0_0", + "nbclient 0.5.3 pyhd3eb1b0_0", + "nbconvert 6.0.7 py38_0", + "nbformat 5.1.3 pyhd3eb1b0_0", + "ncurses 6.2 he6710b0_1", + "nest-asyncio 1.5.1 pyhd3eb1b0_0", + "networkx 2.5 py_0", + "nltk 3.6.1 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1006", + "notebook 6.3.0 py38h06a4308_0", + "numba 0.53.1 py38ha9443f7_0", + "numexpr 2.7.3 py38h22e1b3c_1", + "numpy 1.20.1 py38h93e21f0_0", + "numpy-base 1.20.1 py38h7d8b39e_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 py_0", + "openpyxl 3.0.7 pyhd3eb1b0_0", + "openssl 1.1.1k h27cfd23_0", + "packaging 20.9 pyhd3eb1b0_0", + "pandas 1.2.4 py38h2531618_0", + "pandoc 2.12 h06a4308_0", + "pandocfilters 1.4.3 py38h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.2.0 pyhd3eb1b0_0", + "patchelf 0.12 h2531618_1", + "path 15.1.2 py38h06a4308_0", + "path.py 12.5.0 0", + "pathlib2 2.3.5 py38h06a4308_2", + "pathspec 0.7.0 py_0", + "patsy 0.5.1 py38_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py38_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 8.2.0 py38he98fc37_0", + "pip 21.0.1 py38h06a4308_0", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.7.0 py38h06a4308_0", + "pluggy 0.13.1 py38h06a4308_0", + "ply 3.11 py38_0", + "prometheus_client 0.10.1 pyhd3eb1b0_0", + "prompt-toolkit 3.0.17 pyh06a4308_0", + "prompt_toolkit 3.0.17 hd3eb1b0_0", + "psutil 5.8.0 py38h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.10.0 pyhd3eb1b0_0", + "py-lief 0.10.1 py38h403a769_0", + "pycodestyle 2.6.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py38h7b6447c_1", + "pycparser 2.20 py_2", + "pycurl 7.43.0.6 py38h1ba5d50_0", + "pydocstyle 6.0.0 pyhd3eb1b0_0", + "pyerfa 1.7.3 py38h27cfd23_0", + "pyflakes 2.2.0 pyhd3eb1b0_0", + "pygments 2.8.1 pyhd3eb1b0_0", + "pylint 2.7.4 py38h06a4308_1", + "pyls-black 0.4.6 hd3eb1b0_0", + "pyls-spyder 0.3.2 pyhd3eb1b0_0", + "pyodbc 4.0.30 py38he6710b0_0", + "pyopenssl 20.0.1 pyhd3eb1b0_1", + "pyparsing 2.4.7 pyhd3eb1b0_0", + "pyqt 5.9.2 py38h05f1152_4", + "pyrsistent 0.17.3 py38h7b6447c_0", + "pysocks 1.7.1 py38h06a4308_0", + "pytables 3.6.1 py38h9fd0a39_0", + "pytest 6.2.3 py38h06a4308_2", + "python 3.8.8 hdb3f193_5", + "python-dateutil 2.8.1 pyhd3eb1b0_0", + "python-jsonrpc-server 0.4.0 py_0", + "python-language-server 0.36.2 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "pytz 2021.1 pyhd3eb1b0_0", + "pywavelets 1.1.1 py38h7b6447c_2", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 5.4.1 py38h27cfd23_1", + "pyzmq 20.0.0 py38h2531618_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.2 pyhd3eb1b0_0", + "qtconsole 5.0.3 pyhd3eb1b0_0", + "qtpy 1.9.0 py_0", + "readline 8.1 h27cfd23_0", + "regex 2021.4.4 py38h27cfd23_0", + "requests 2.25.1 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.18.0 py_0", + "rtree 0.9.7 py38h06a4308_1", + "ruamel_yaml 0.15.100 py38h27cfd23_0", + "scikit-image 0.18.1 py38ha9443f7_0", + "scikit-learn 0.24.1 py38ha9443f7_0", + "scipy 1.6.2 py38had2a1c9_1", + "seaborn 0.11.1 pyhd3eb1b0_0", + "secretstorage 3.3.1 py38h06a4308_0", + "send2trash 1.5.0 pyhd3eb1b0_1", + "setuptools 52.0.0 py38h06a4308_0", + "simplegeneric 0.8.1 py38_2", + "singledispatch 3.6.1 pyhd3eb1b0_1001", + "sip 4.19.13 py38he6710b0_0", + "six 1.15.0 py38h06a4308_0", + "sniffio 1.2.0 py38h06a4308_1", + "snowballstemmer 2.1.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.3.0 pyhd3eb1b0_0", + "soupsieve 2.2.1 pyhd3eb1b0_0", + "sphinx 4.0.1 pyhd3eb1b0_0", + "sphinxcontrib 1.0 py38_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.4 pyhd3eb1b0_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 4.2.5 py38h06a4308_0", + "spyder-kernels 1.10.2 py38h06a4308_0", + "sqlalchemy 1.4.15 py38h27cfd23_0", + "sqlite 3.35.4 hdfb4753_0", + "statsmodels 0.12.2 py38h27cfd23_0", + "sympy 1.8 py38h06a4308_0", + "tbb 2020.3 hfd86e86_0", + "tblib 1.7.0 py_0", + "terminado 0.9.4 py38h06a4308_0", + "testpath 0.4.4 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2020.10.1 py38hdd07704_2", + "tk 8.6.10 hbc83047_0", + "toml 0.10.2 pyhd3eb1b0_0", + "toolz 0.11.1 pyhd3eb1b0_0", + "tornado 6.1 py38h27cfd23_0", + "tqdm 4.59.0 pyhd3eb1b0_1", + "traitlets 5.0.5 pyhd3eb1b0_0", + "typed-ast 1.4.2 py38h27cfd23_1", + "typing_extensions 3.7.4.3 pyha847dfd_0", + "ujson 4.0.2 py38h2531618_0", + "unicodecsv 0.14.1 py38_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.4 pyhd3eb1b0_0", + "watchdog 1.0.2 py38h06a4308_1", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py38_1", + "werkzeug 1.0.1 pyhd3eb1b0_0", + "wheel 0.36.2 pyhd3eb1b0_0", + "widgetsnbextension 3.5.1 py38_0", + "wrapt 1.12.1 py38h7b6447c_1", + "wurlitzer 2.1.0 py38h06a4308_0", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 1.3.8 pyhd3eb1b0_0", + "xlwt 1.3.0 py38_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.4.1 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py38_1", + "zope.event 4.5.0 py38_0", + "zope.interface 5.3.0 py38h27cfd23_0", + "zstd 1.4.5 h9ceee32_0" + ], + "license": "BSD", + "md5": "d6ddba989cc2ce6ca6feede996051c2b", + "name": "anaconda", + "namespace": "python", + "sha256": "1fdc23da16a21d25fa84ca920b1b643db035c04c6fd073b815b9b8d34bbf0a38", + "size": 16992, + "subdir": "linux-64", + "timestamp": 1620924351236, + "version": "2021.05" + }, + "anaconda-2021.05-py39_0.conda": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.7.2 py39h06a4308_0", + "anaconda-project 0.9.1 pyhd3eb1b0_1", + "anyio 2.2.0 py39h06a4308_1", + "appdirs 1.4.4 py_0", + "argh 0.26.2 py39h06a4308_0", + "argon2-cffi 20.1.0 py39h27cfd23_1", + "asn1crypto 1.4.0 py_0", + "astroid 2.5 py39h06a4308_1", + "astropy 4.2.1 py39h27cfd23_1", + "async_generator 1.10 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 20.3.0 pyhd3eb1b0_0", + "autopep8 1.5.6 pyhd3eb1b0_0", + "babel 2.9.0 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.0 pyhd3eb1b0_2", + "backports.shutil_get_terminal_size 1.0.0 pyhd3eb1b0_3", + "beautifulsoup4 4.9.3 pyha847dfd_0", + "bitarray 2.1.0 py39h27cfd23_1", + "bkcharts 0.2 py39h06a4308_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 3.3.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.3.2 py39h06a4308_0", + "boto 2.49.0 py39h06a4308_0", + "bottleneck 1.3.2 py39hdd57654_1", + "brotli 1.0.9 he6710b0_2", + "brotlipy 0.7.0 py39h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.17.1 h27cfd23_0", + "ca-certificates 2021.4.13 h06a4308_1", + "cairo 1.16.0 hf32fb01_1", + "certifi 2020.12.5 py39h06a4308_0", + "cffi 1.14.5 py39h261ae71_0", + "chardet 4.0.0 py39h06a4308_1003", + "charls 2.2.0 h2531618_0", + "click 7.1.2 pyhd3eb1b0_0", + "cloudpickle 1.6.0 py_0", + "clyent 1.2.2 py39h06a4308_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "contextlib2 0.6.0.post1 py_0", + "cryptography 3.4.7 py39hd23ed53_0", + "curl 7.71.1 hbc83047_1", + "cycler 0.10.0 py39h06a4308_0", + "cython 0.29.23 py39h2531618_0", + "cytoolz 0.11.0 py39h27cfd23_0", + "dask 2021.4.0 pyhd3eb1b0_0", + "dask-core 2021.4.0 pyhd3eb1b0_0", + "dbus 1.13.18 hb2f20db_0", + "decorator 5.0.6 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 py_0", + "distributed 2021.4.1 py39h06a4308_0", + "docutils 0.17.1 py39h06a4308_1", + "entrypoints 0.3 py39h06a4308_0", + "et_xmlfile 1.0.1 py_1001", + "expat 2.3.0 h2531618_2", + "fastcache 1.1.0 py39he8ac12f_0", + "filelock 3.0.12 pyhd3eb1b0_1", + "flake8 3.9.0 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 0.9.0 pyhd3eb1b0_0", + "future 0.18.2 py39h06a4308_1", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 21.1.2 py39h27cfd23_1", + "giflib 5.1.4 h14c3975_1", + "glib 2.68.1 h36276a3_0", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.0.8 py39h8083e48_3", + "graphite2 1.3.14 h23475e2_0", + "greenlet 1.0.0 py39h2531618_2", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py39hec9cf62_0", + "harfbuzz 2.8.0 h6f93f22_0", + "hdf5 1.10.6 hb1b8bf9_0", + "heapdict 1.0.1 py_0", + "html5lib 1.1 py_0", + "icu 58.2 he6710b0_3", + "idna 2.10 pyhd3eb1b0_0", + "imagecodecs 2021.3.31 py39h581e88b_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.2.0 pyhd3eb1b0_0", + "importlib-metadata 3.10.0 py39h06a4308_0", + "importlib_metadata 3.10.0 hd3eb1b0_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intel-openmp 2021.2.0 h06a4308_610", + "intervaltree 3.1.0 py_0", + "ipykernel 5.3.4 py39hb070fc8_0", + "ipython 7.22.0 py39hb070fc8_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.3 pyhd3eb1b0_1", + "isort 5.8.0 pyhd3eb1b0_0", + "itsdangerous 1.1.0 pyhd3eb1b0_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 py_0", + "jedi 0.17.2 py39h06a4308_1", + "jeepney 0.6.0 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "joblib 1.0.1 pyhd3eb1b0_0", + "jpeg 9b h024ee3a_2", + "json5 0.9.5 py_0", + "jsonschema 3.2.0 py_2", + "jupyter 1.0.0 py39h06a4308_7", + "jupyter-packaging 0.7.12 pyhd3eb1b0_0", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.7.1 py39h06a4308_0", + "jupyter_server 1.4.1 py39h06a4308_0", + "jupyterlab 3.0.14 pyhd3eb1b0_1", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.4.0 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 22.3.0 py39h06a4308_0", + "kiwisolver 1.3.1 py39h2531618_0", + "krb5 1.18.2 h173b8e3_0", + "lazy-object-proxy 1.6.0 py39h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.33.1 h53a641e_7", + "lerc 2.2.1 h2531618_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.71.1 h20c2e04_1", + "libdeflate 1.7 h27cfd23_5", + "libedit 3.1.20210216 h27cfd23_1", + "libev 4.33 h7b6447c_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.1.0 hdf63c60_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "liblief 0.10.1 h2531618_1", + "libllvm10 10.0.1 hbcb73fb_5", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.1.0 hdf63c60_0", + "libtiff 4.1.0 h2733197_1", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h1bed415_2", + "libuv 1.40.0 h7b6447c_0", + "libwebp 1.0.1 h8e7db2f_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.10 hb55368b_3", + "libxslt 1.1.34 hc22bd24_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.36.0 py39h612dafd_4", + "locket 0.2.1 py39h06a4308_1", + "lxml 4.6.3 py39h9120a33_0", + "lz4-c 1.9.3 h2531618_0", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py39h27cfd23_0", + "matplotlib 3.3.4 py39h06a4308_0", + "matplotlib-base 3.3.4 py39h62a2d02_0", + "mccabe 0.6.1 py39h06a4308_1", + "mistune 0.8.4 py39h27cfd23_1000", + "mkl 2021.2.0 h06a4308_296", + "mkl-service 2.3.0 py39h27cfd23_1", + "mkl_fft 1.3.0 py39h42c9631_2", + "mkl_random 1.2.1 py39ha9443f7_2", + "mock 4.0.3 pyhd3eb1b0_0", + "more-itertools 8.7.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpmath 1.2.1 py39h06a4308_0", + "msgpack-python 1.0.2 py39hff7bd54_1", + "multipledispatch 0.6.0 py39h06a4308_0", + "mypy_extensions 0.4.1 py39h06a4308_0", + "nbclassic 0.2.6 pyhd3eb1b0_0", + "nbclient 0.5.3 pyhd3eb1b0_0", + "nbconvert 6.0.7 py39h06a4308_0", + "nbformat 5.1.3 pyhd3eb1b0_0", + "ncurses 6.2 he6710b0_1", + "nest-asyncio 1.5.1 pyhd3eb1b0_0", + "networkx 2.5 py_0", + "nltk 3.6.1 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1006", + "notebook 6.3.0 py39h06a4308_0", + "numba 0.53.1 py39ha9443f7_0", + "numexpr 2.7.3 py39h22e1b3c_1", + "numpy 1.20.1 py39h93e21f0_0", + "numpy-base 1.20.1 py39h7d8b39e_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 py_0", + "openjpeg 2.3.0 h05c96fa_1", + "openpyxl 3.0.7 pyhd3eb1b0_0", + "openssl 1.1.1k h27cfd23_0", + "packaging 20.9 pyhd3eb1b0_0", + "pandas 1.2.4 py39h2531618_0", + "pandoc 2.12 h06a4308_0", + "pandocfilters 1.4.3 py39h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.7.0 py_0", + "partd 1.2.0 pyhd3eb1b0_0", + "patchelf 0.12 h2531618_1", + "path 15.1.2 py39h06a4308_0", + "path.py 12.5.0 0", + "pathlib2 2.3.5 py39h06a4308_2", + "pathspec 0.7.0 py_0", + "patsy 0.5.1 py39h06a4308_0", + "pcre 8.44 he6710b0_0", + "pep8 1.7.1 py39h06a4308_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 8.2.0 py39he98fc37_0", + "pip 21.0.1 py39h06a4308_0", + "pixman 0.40.0 h7b6447c_0", + "pkginfo 1.7.0 py39h06a4308_0", + "pluggy 0.13.1 py39h06a4308_0", + "ply 3.11 py39h06a4308_0", + "prometheus_client 0.10.1 pyhd3eb1b0_0", + "prompt-toolkit 3.0.17 pyh06a4308_0", + "prompt_toolkit 3.0.17 hd3eb1b0_0", + "psutil 5.8.0 py39h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.10.0 pyhd3eb1b0_0", + "py-lief 0.10.1 py39h2531618_1", + "pycodestyle 2.6.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py39h27cfd23_0", + "pycparser 2.20 py_2", + "pycurl 7.43.0.6 py39h8b3b800_0", + "pydocstyle 6.0.0 pyhd3eb1b0_0", + "pyerfa 1.7.3 py39h27cfd23_0", + "pyflakes 2.2.0 pyhd3eb1b0_0", + "pygments 2.8.1 pyhd3eb1b0_0", + "pylint 2.7.4 py39h06a4308_1", + "pyls-black 0.4.6 hd3eb1b0_0", + "pyls-spyder 0.3.2 pyhd3eb1b0_0", + "pyodbc 4.0.30 py39h66f3464_0", + "pyopenssl 20.0.1 pyhd3eb1b0_1", + "pyparsing 2.4.7 pyhd3eb1b0_0", + "pyqt 5.9.2 py39h2531618_6", + "pyrsistent 0.17.3 py39h27cfd23_0", + "pysocks 1.7.1 py39h06a4308_0", + "pytables 3.6.1 py39h77479fe_1", + "pytest 6.2.3 py39h06a4308_2", + "python 3.9.4 hdb3f193_0", + "python-dateutil 2.8.1 pyhd3eb1b0_0", + "python-jsonrpc-server 0.4.0 py_0", + "python-language-server 0.36.2 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "pytz 2021.1 pyhd3eb1b0_0", + "pywavelets 1.1.1 py39h6323ea4_4", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 5.4.1 py39h27cfd23_1", + "pyzmq 20.0.0 py39h2531618_1", + "qdarkstyle 2.8.1 py_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.2 pyhd3eb1b0_0", + "qtconsole 5.0.3 pyhd3eb1b0_0", + "qtpy 1.9.0 py_0", + "readline 8.1 h27cfd23_0", + "regex 2021.4.4 py39h27cfd23_0", + "requests 2.25.1 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.18.0 py_0", + "rtree 0.9.7 py39h06a4308_1", + "ruamel_yaml 0.15.100 py39h27cfd23_0", + "scikit-image 0.18.1 py39ha9443f7_0", + "scikit-learn 0.24.1 py39ha9443f7_0", + "scipy 1.6.2 py39had2a1c9_1", + "seaborn 0.11.1 pyhd3eb1b0_0", + "secretstorage 3.3.1 py39h06a4308_0", + "send2trash 1.5.0 pyhd3eb1b0_1", + "setuptools 52.0.0 py39h06a4308_0", + "simplegeneric 0.8.1 py39h06a4308_2", + "singledispatch 3.6.1 pyhd3eb1b0_1001", + "sip 4.19.13 py39h2531618_0", + "six 1.15.0 py39h06a4308_0", + "snappy 1.1.8 he6710b0_0", + "sniffio 1.2.0 py39h06a4308_1", + "snowballstemmer 2.1.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.3.0 pyhd3eb1b0_0", + "soupsieve 2.2.1 pyhd3eb1b0_0", + "sphinx 4.0.1 pyhd3eb1b0_0", + "sphinxcontrib 1.0 py39h06a4308_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.4 pyhd3eb1b0_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 4.2.5 py39h06a4308_0", + "spyder-kernels 1.10.2 py39h06a4308_0", + "sqlalchemy 1.4.15 py39h27cfd23_0", + "sqlite 3.35.4 hdfb4753_0", + "statsmodels 0.12.2 py39h27cfd23_0", + "sympy 1.8 py39h06a4308_0", + "tbb 2020.3 hfd86e86_0", + "tblib 1.7.0 py_0", + "terminado 0.9.4 py39h06a4308_0", + "testpath 0.4.4 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.1.0 pyh5ca1d4c_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.4.8 pyhd3eb1b0_2", + "tk 8.6.10 hbc83047_0", + "toml 0.10.2 pyhd3eb1b0_0", + "toolz 0.11.1 pyhd3eb1b0_0", + "tornado 6.1 py39h27cfd23_0", + "tqdm 4.59.0 pyhd3eb1b0_1", + "traitlets 5.0.5 pyhd3eb1b0_0", + "typed-ast 1.4.2 py39h27cfd23_1", + "typing_extensions 3.7.4.3 pyha847dfd_0", + "tzdata 2020f h52ac0ba_0", + "ujson 4.0.2 py39h2531618_0", + "unicodecsv 0.14.1 py39h06a4308_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.4 pyhd3eb1b0_0", + "watchdog 1.0.2 py39h06a4308_1", + "wcwidth 0.2.5 py_0", + "webencodings 0.5.1 py39h06a4308_1", + "werkzeug 1.0.1 pyhd3eb1b0_0", + "wheel 0.36.2 pyhd3eb1b0_0", + "widgetsnbextension 3.5.1 py39h06a4308_0", + "wrapt 1.12.1 py39he8ac12f_1", + "wurlitzer 2.1.0 py39h06a4308_0", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 1.3.8 pyhd3eb1b0_0", + "xlwt 1.3.0 py39h06a4308_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h2531618_6", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.4.1 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py39h06a4308_1", + "zope.event 4.5.0 py39h06a4308_0", + "zope.interface 5.3.0 py39h27cfd23_0", + "zstd 1.4.5 h9ceee32_0" + ], + "license": "BSD", + "md5": "3820627447c3675c87ea8a559e526955", + "name": "anaconda", + "namespace": "python", + "sha256": "99cf5a775fc25e222b0b8af07b210211a6f6d636ea261891fcca6bc5e761830c", + "size": 17293, + "subdir": "linux-64", + "timestamp": 1620924553671, + "version": "2021.05" + }, + "anaconda-2021.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 4.5 1_gnu", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.9.0 py37h06a4308_0", + "anaconda-project 0.10.1 pyhd3eb1b0_0", + "anyio 2.2.0 py37h06a4308_1", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argcomplete 1.12.3 pyhd3eb1b0_0", + "argh 0.26.2 py37_0", + "argon2-cffi 20.1.0 py37h27cfd23_1", + "arrow 0.13.1 py37_0", + "asn1crypto 1.4.0 py_0", + "astroid 2.6.6 py37h06a4308_0", + "astropy 4.3.1 py37h09021b7_0", + "async_generator 1.10 py37h28b3542_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.2.0 pyhd3eb1b0_0", + "autopep8 1.5.7 pyhd3eb1b0_0", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.0 pyhd3eb1b0_2", + "backports.shutil_get_terminal_size 1.0.0 pyhd3eb1b0_3", + "beautifulsoup4 4.10.0 pyh06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.3.0 py37h7f8727e_1", + "bkcharts 0.2 py37_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 4.0.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.4.1 py37h06a4308_0", + "boto 2.49.0 py37_0", + "bottleneck 1.3.2 py37heb32a55_1", + "brotli 1.0.9 he6710b0_2", + "brotlipy 0.7.0 py37h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.17.1 h27cfd23_0", + "ca-certificates 2021.10.26 h06a4308_2", + "cairo 1.16.0 hf32fb01_1", + "certifi 2021.10.8 py37h06a4308_0", + "cffi 1.14.6 py37h400218f_0", + "cfitsio 3.470 hf0d0db6_6", + "chardet 4.0.0 py37h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.3 pyhd3eb1b0_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "conda-content-trust 0.1.1 pyhd3eb1b0_0", + "conda-token 0.3.0 pyhd3eb1b0_0", + "contextlib2 0.6.0.post1 pyhd3eb1b0_0", + "cookiecutter 1.7.2 pyhd3eb1b0_0", + "cryptography 3.4.8 py37hd23ed53_0", + "curl 7.78.0 h1ccaba5_0", + "cycler 0.10.0 py37_0", + "cython 0.29.24 py37hdbfa776_0", + "cytoolz 0.11.0 py37h7b6447c_0", + "daal4py 2021.3.0 py37hae6d005_0", + "dal 2021.3.0 h06a4308_557", + "dask 2021.10.0 pyhd3eb1b0_0", + "dask-core 2021.10.0 pyhd3eb1b0_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.4.1 py37h295c915_0", + "decorator 5.1.0 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "distributed 2021.10.0 py37h06a4308_0", + "docutils 0.17.1 py37h06a4308_1", + "entrypoints 0.3 py37_0", + "et_xmlfile 1.1.0 py37h06a4308_0", + "expat 2.4.1 h2531618_2", + "fastcache 1.1.0 py37h7b6447c_0", + "filelock 3.3.1 pyhd3eb1b0_1", + "flake8 3.9.2 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 2021.8.1 pyhd3eb1b0_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 21.8.0 py37h7f8727e_1", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h5202010_0", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.0.8 py37h10f8cd9_2", + "graphite2 1.3.14 h23475e2_0", + "greenlet 1.1.1 py37h295c915_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py37h7918eee_0", + "harfbuzz 2.8.1 h6f93f22_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "html5lib 1.1 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.2 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py37h4cda21f_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.2.0 pyhd3eb1b0_0", + "importlib-metadata 4.8.1 py37h06a4308_0", + "importlib_metadata 4.8.1 hd3eb1b0_0", + "inflection 0.5.1 py37h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.4.1 py37h06a4308_1", + "ipython 7.29.0 py37hb070fc8_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.0 py37h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_2", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9d h7f8727e_0", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 3.2.0 pyhd3eb1b0_2", + "jupyter 1.0.0 py37_7", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.8.1 py37h06a4308_0", + "jupyter_server 1.4.1 py37h06a4308_0", + "jupyterlab 3.2.1 pyhd3eb1b0_1", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.8.2 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.1.0 py37h06a4308_0", + "kiwisolver 1.3.1 py37h2531618_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py37h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.35.1 h7274673_9", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.78.0 h0b77cf5_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.3.0 h5101ec6_17", + "libgfortran-ng 7.5.0 ha8ba4b0_17", + "libgfortran4 7.5.0 ha8ba4b0_17", + "libgomp 9.3.0 h5101ec6_17", + "liblief 0.10.1 he6710b0_0", + "libllvm11 11.1.0 h3826bc1_0", + "libnghttp2 1.41.0 hf8bcb03_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.3.0 hd4cf53a_17", + "libtiff 4.2.0 h85742a9_0", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h7f8727e_2", + "libuv 1.40.0 h7b6447c_0", + "libwebp 1.2.0 h89dd481_0", + "libwebp-base 1.2.0 h27cfd23_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.12 h03d6c58_0", + "libxslt 1.1.34 hc22bd24_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.37.0 py37h295c915_1", + "locket 0.2.1 py37h06a4308_1", + "lxml 4.6.3 py37h9120a33_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py37h14c3975_1", + "matplotlib 3.4.3 py37h06a4308_0", + "matplotlib-base 3.4.3 py37hbbc1b5f_0", + "matplotlib-inline 0.1.2 pyhd3eb1b0_2", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h14c3975_1001", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py37h7f8727e_0", + "mkl_fft 1.3.1 py37hd3c417c_0", + "mkl_random 1.2.2 py37h51133e4_0", + "mock 4.0.3 pyhd3eb1b0_0", + "more-itertools 8.10.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 hc856adb_0", + "mpmath 1.2.1 py37h06a4308_0", + "msgpack-python 1.0.2 py37hff7bd54_1", + "multipledispatch 0.6.0 py37_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py37_0", + "nbclassic 0.2.6 pyhd3eb1b0_0", + "nbclient 0.5.3 pyhd3eb1b0_0", + "nbconvert 6.1.0 py37h06a4308_0", + "nbformat 5.1.3 pyhd3eb1b0_0", + "ncurses 6.3 heee7806_1", + "nest-asyncio 1.5.1 pyhd3eb1b0_0", + "networkx 2.6.3 pyhd3eb1b0_0", + "nltk 3.6.5 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1006", + "notebook 6.4.5 py37h06a4308_0", + "numba 0.54.1 py37h51133e4_0", + "numexpr 2.7.3 py37h22e1b3c_1", + "numpy 1.20.3 py37hf144106_0", + "numpy-base 1.20.3 py37h74d4b33_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 py37_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.9 pyhd3eb1b0_0", + "openssl 1.1.1l h7f8727e_0", + "packaging 21.0 pyhd3eb1b0_0", + "pandas 1.3.4 py37h8c16a72_0", + "pandocfilters 1.4.3 py37h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.8.2 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_0", + "patchelf 0.13 h295c915_0", + "path 16.0.0 py37h06a4308_0", + "path.py 12.5.0 hd3eb1b0_0", + "pathlib2 2.3.6 py37h06a4308_2", + "pathspec 0.7.0 py_0", + "patsy 0.5.2 py37h06a4308_0", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py37_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 8.4.0 py37h5aabda8_0", + "pip 21.2.2 py37h06a4308_0", + "pixman 0.40.0 h7f8727e_1", + "pkginfo 1.7.1 py37h06a4308_0", + "pluggy 0.13.1 py37h06a4308_0", + "ply 3.11 py37_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.11.0 pyhd3eb1b0_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "psutil 5.8.0 py37h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.10.0 pyhd3eb1b0_0", + "py-lief 0.10.1 py37h403a769_0", + "pycodestyle 2.7.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py37h27cfd23_0", + "pycparser 2.20 py_2", + "pycrypto 2.6.1 py37h7b6447c_10", + "pycurl 7.44.1 py37h8f2d780_1", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py37h27cfd23_0", + "pyflakes 2.3.1 pyhd3eb1b0_0", + "pygments 2.10.0 pyhd3eb1b0_0", + "pylint 2.9.6 py37h06a4308_1", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.31 py37h295c915_0", + "pyopenssl 21.0.0 pyhd3eb1b0_1", + "pyparsing 3.0.4 pyhd3eb1b0_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.18.0 py37heee7806_0", + "pysocks 1.7.1 py37_1", + "pytables 3.6.1 py37h71ec239_0", + "pytest 6.2.4 py37h06a4308_2", + "python 3.7.11 h12debd9_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.0.0 pyhd3eb1b0_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.2.4 pyhd3eb1b0_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "pytz 2021.3 pyhd3eb1b0_0", + "pywavelets 1.1.1 py37h7b6447c_2", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py37h7f8727e_1", + "pyzmq 22.2.1 py37h295c915_1", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.2 pyhd3eb1b0_0", + "qtconsole 5.1.1 pyhd3eb1b0_0", + "qtpy 1.10.0 pyhd3eb1b0_0", + "readline 8.1 h27cfd23_0", + "regex 2021.8.3 py37h7f8727e_0", + "requests 2.26.0 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.19.0 pyhd3eb1b0_0", + "rtree 0.9.7 py37h06a4308_1", + "ruamel_yaml 0.15.100 py37h27cfd23_0", + "scikit-image 0.18.3 py37h51133e4_0", + "scikit-learn 0.24.2 py37ha9443f7_0", + "scikit-learn-intelex 2021.3.0 py37h06a4308_0", + "scipy 1.7.1 py37h292c36d_2", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py37h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "setuptools 58.0.4 py37h06a4308_0", + "simplegeneric 0.8.1 py37_2", + "singledispatch 3.7.0 pyhd3eb1b0_1001", + "sip 4.19.8 py37hf484d3e_0", + "six 1.16.0 pyhd3eb1b0_0", + "snappy 1.1.8 he6710b0_0", + "sniffio 1.2.0 py37h06a4308_1", + "snowballstemmer 2.1.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.2.1 pyhd3eb1b0_0", + "sphinx 4.2.0 pyhd3eb1b0_1", + "sphinxcontrib 1.0 py37_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 5.1.5 py37h06a4308_1", + "spyder-kernels 2.1.3 py37h06a4308_0", + "sqlalchemy 1.4.22 py37h7f8727e_0", + "sqlite 3.36.0 hc218d9a_0", + "statsmodels 0.12.2 py37h27cfd23_0", + "sympy 1.9 py37h06a4308_0", + "tbb 2021.4.0 hd09550d_0", + "tbb4py 2021.4.0 py37hd09550d_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "terminado 0.9.4 py37h06a4308_0", + "testpath 0.5.0 pyhd3eb1b0_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.11 h1ccaba5_0", + "toml 0.10.2 pyhd3eb1b0_0", + "toolz 0.11.1 pyhd3eb1b0_0", + "tornado 6.1 py37h27cfd23_0", + "tqdm 4.62.3 pyhd3eb1b0_1", + "traitlets 5.1.0 pyhd3eb1b0_0", + "typed-ast 1.4.3 py37h7f8727e_1", + "typing-extensions 3.10.0.2 hd3eb1b0_0", + "typing_extensions 3.10.0.2 pyh06a4308_0", + "ujson 4.0.2 py37h2531618_0", + "unicodecsv 0.14.1 py37_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.7 pyhd3eb1b0_0", + "watchdog 2.1.3 py37h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py37_1", + "werkzeug 2.0.2 pyhd3eb1b0_0", + "wheel 0.37.0 pyhd3eb1b0_1", + "whichcraft 0.6.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.1 py37_0", + "wrapt 1.12.1 py37h7b6447c_1", + "wurlitzer 2.1.1 py37h06a4308_0", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.1 pyhd3eb1b0_0", + "xlwt 1.3.0 py37_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h2531618_6", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.6.0 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py37_1", + "zope.event 4.5.0 py37_0", + "zope.interface 5.4.0 py37h7f8727e_0", + "zstd 1.4.9 haebb681_0" + ], + "license": "BSD", + "md5": "ee99c42793981056c51f9c89d48603e5", + "name": "anaconda", + "namespace": "python", + "sha256": "0807751d6fb07c58e3ee548e8863192ef8c651f07824a977e11e7571fd2e4a58", + "size": 18338, + "subdir": "linux-64", + "timestamp": 1636485500907, + "version": "2021.11" + }, + "anaconda-2021.11-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 4.5 1_gnu", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.9.0 py38h06a4308_0", + "anaconda-project 0.10.1 pyhd3eb1b0_0", + "anyio 2.2.0 py38h06a4308_1", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argh 0.26.2 py38_0", + "argon2-cffi 20.1.0 py38h27cfd23_1", + "arrow 0.13.1 py38_0", + "asn1crypto 1.4.0 py_0", + "astroid 2.6.6 py38h06a4308_0", + "astropy 4.3.1 py38h09021b7_0", + "async_generator 1.10 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.2.0 pyhd3eb1b0_0", + "autopep8 1.5.7 pyhd3eb1b0_0", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.0 pyhd3eb1b0_2", + "backports.shutil_get_terminal_size 1.0.0 pyhd3eb1b0_3", + "beautifulsoup4 4.10.0 pyh06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.3.0 py38h7f8727e_1", + "bkcharts 0.2 py38_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 4.0.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.4.1 py38h06a4308_0", + "boto 2.49.0 py38_0", + "bottleneck 1.3.2 py38heb32a55_1", + "brotli 1.0.9 he6710b0_2", + "brotlipy 0.7.0 py38h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.17.1 h27cfd23_0", + "ca-certificates 2021.10.26 h06a4308_2", + "cairo 1.16.0 hf32fb01_1", + "certifi 2021.10.8 py38h06a4308_0", + "cffi 1.14.6 py38h400218f_0", + "cfitsio 3.470 hf0d0db6_6", + "chardet 4.0.0 py38h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.3 pyhd3eb1b0_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py38_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "conda-content-trust 0.1.1 pyhd3eb1b0_0", + "conda-token 0.3.0 pyhd3eb1b0_0", + "contextlib2 0.6.0.post1 pyhd3eb1b0_0", + "cookiecutter 1.7.2 pyhd3eb1b0_0", + "cryptography 3.4.8 py38hd23ed53_0", + "curl 7.78.0 h1ccaba5_0", + "cycler 0.10.0 py38_0", + "cython 0.29.24 py38hdbfa776_0", + "cytoolz 0.11.0 py38h7b6447c_0", + "daal4py 2021.3.0 py38hae6d005_0", + "dal 2021.3.0 h06a4308_557", + "dask 2021.10.0 pyhd3eb1b0_0", + "dask-core 2021.10.0 pyhd3eb1b0_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.4.1 py38h295c915_0", + "decorator 5.1.0 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "distributed 2021.10.0 py38h06a4308_0", + "docutils 0.17.1 py38h06a4308_1", + "entrypoints 0.3 py38_0", + "et_xmlfile 1.1.0 py38h06a4308_0", + "expat 2.4.1 h2531618_2", + "fastcache 1.1.0 py38h7b6447c_0", + "filelock 3.3.1 pyhd3eb1b0_1", + "flake8 3.9.2 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 2021.8.1 pyhd3eb1b0_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 21.8.0 py38h7f8727e_1", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h5202010_0", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.0.8 py38hd5f6e3b_3", + "graphite2 1.3.14 h23475e2_0", + "greenlet 1.1.1 py38h295c915_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py38h7918eee_0", + "harfbuzz 2.8.1 h6f93f22_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "html5lib 1.1 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.2 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py38h4cda21f_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.2.0 pyhd3eb1b0_0", + "importlib-metadata 4.8.1 py38h06a4308_0", + "importlib_metadata 4.8.1 hd3eb1b0_0", + "inflection 0.5.1 py38h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.4.1 py38h06a4308_1", + "ipython 7.29.0 py38hb070fc8_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.0 py38h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_2", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9d h7f8727e_0", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 3.2.0 pyhd3eb1b0_2", + "jupyter 1.0.0 py38_7", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.8.1 py38h06a4308_0", + "jupyter_server 1.4.1 py38h06a4308_0", + "jupyterlab 3.2.1 pyhd3eb1b0_1", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.8.2 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.1.0 py38h06a4308_0", + "kiwisolver 1.3.1 py38h2531618_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py38h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.35.1 h7274673_9", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.78.0 h0b77cf5_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.3.0 h5101ec6_17", + "libgfortran-ng 7.5.0 ha8ba4b0_17", + "libgfortran4 7.5.0 ha8ba4b0_17", + "libgomp 9.3.0 h5101ec6_17", + "liblief 0.10.1 he6710b0_0", + "libllvm11 11.1.0 h3826bc1_0", + "libnghttp2 1.41.0 hf8bcb03_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.3.0 hd4cf53a_17", + "libtiff 4.2.0 h85742a9_0", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h7f8727e_2", + "libuv 1.40.0 h7b6447c_0", + "libwebp 1.2.0 h89dd481_0", + "libwebp-base 1.2.0 h27cfd23_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.12 h03d6c58_0", + "libxslt 1.1.34 hc22bd24_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.37.0 py38h295c915_1", + "locket 0.2.1 py38h06a4308_1", + "lxml 4.6.3 py38h9120a33_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py38h7b6447c_0", + "matplotlib 3.4.3 py38h06a4308_0", + "matplotlib-base 3.4.3 py38hbbc1b5f_0", + "matplotlib-inline 0.1.2 pyhd3eb1b0_2", + "mccabe 0.6.1 py38_1", + "mistune 0.8.4 py38h7b6447c_1000", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py38h7f8727e_0", + "mkl_fft 1.3.1 py38hd3c417c_0", + "mkl_random 1.2.2 py38h51133e4_0", + "mock 4.0.3 pyhd3eb1b0_0", + "more-itertools 8.10.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 hc856adb_0", + "mpmath 1.2.1 py38h06a4308_0", + "msgpack-python 1.0.2 py38hff7bd54_1", + "multipledispatch 0.6.0 py38_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py38_0", + "nbclassic 0.2.6 pyhd3eb1b0_0", + "nbclient 0.5.3 pyhd3eb1b0_0", + "nbconvert 6.1.0 py38h06a4308_0", + "nbformat 5.1.3 pyhd3eb1b0_0", + "ncurses 6.3 heee7806_1", + "nest-asyncio 1.5.1 pyhd3eb1b0_0", + "networkx 2.6.3 pyhd3eb1b0_0", + "nltk 3.6.5 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1006", + "notebook 6.4.5 py38h06a4308_0", + "numba 0.54.1 py38h51133e4_0", + "numexpr 2.7.3 py38h22e1b3c_1", + "numpy 1.20.3 py38hf144106_0", + "numpy-base 1.20.3 py38h74d4b33_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 pyhd3eb1b0_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.9 pyhd3eb1b0_0", + "openssl 1.1.1l h7f8727e_0", + "packaging 21.0 pyhd3eb1b0_0", + "pandas 1.3.4 py38h8c16a72_0", + "pandocfilters 1.4.3 py38h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.8.2 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_0", + "patchelf 0.13 h295c915_0", + "path 16.0.0 py38h06a4308_0", + "path.py 12.5.0 hd3eb1b0_0", + "pathlib2 2.3.6 py38h06a4308_2", + "pathspec 0.7.0 py_0", + "patsy 0.5.2 py38h06a4308_0", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py38_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 8.4.0 py38h5aabda8_0", + "pip 21.2.4 py38h06a4308_0", + "pixman 0.40.0 h7f8727e_1", + "pkginfo 1.7.1 py38h06a4308_0", + "pluggy 0.13.1 py38h06a4308_0", + "ply 3.11 py38_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.11.0 pyhd3eb1b0_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "psutil 5.8.0 py38h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.10.0 pyhd3eb1b0_0", + "py-lief 0.10.1 py38h403a769_0", + "pycodestyle 2.7.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py38h7b6447c_1", + "pycparser 2.20 py_2", + "pycurl 7.44.1 py38h8f2d780_1", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py38h27cfd23_0", + "pyflakes 2.3.1 pyhd3eb1b0_0", + "pygments 2.10.0 pyhd3eb1b0_0", + "pylint 2.9.6 py38h06a4308_1", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.31 py38h295c915_0", + "pyopenssl 21.0.0 pyhd3eb1b0_1", + "pyparsing 3.0.4 pyhd3eb1b0_0", + "pyqt 5.9.2 py38h05f1152_4", + "pyrsistent 0.18.0 py38heee7806_0", + "pysocks 1.7.1 py38h06a4308_0", + "pytables 3.6.1 py38h9fd0a39_0", + "pytest 6.2.4 py38h06a4308_2", + "python 3.8.12 h12debd9_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.0.0 pyhd3eb1b0_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.2.4 pyhd3eb1b0_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "pytz 2021.3 pyhd3eb1b0_0", + "pywavelets 1.1.1 py38h7b6447c_2", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py38h7f8727e_1", + "pyzmq 22.2.1 py38h295c915_1", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.2 pyhd3eb1b0_0", + "qtconsole 5.1.1 pyhd3eb1b0_0", + "qtpy 1.10.0 pyhd3eb1b0_0", + "readline 8.1 h27cfd23_0", + "regex 2021.8.3 py38h7f8727e_0", + "requests 2.26.0 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.19.0 pyhd3eb1b0_0", + "rtree 0.9.7 py38h06a4308_1", + "ruamel_yaml 0.15.100 py38h27cfd23_0", + "scikit-image 0.18.3 py38h51133e4_0", + "scikit-learn 0.24.2 py38ha9443f7_0", + "scikit-learn-intelex 2021.3.0 py38h06a4308_0", + "scipy 1.7.1 py38h292c36d_2", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py38h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "setuptools 58.0.4 py38h06a4308_0", + "simplegeneric 0.8.1 py38_2", + "singledispatch 3.7.0 pyhd3eb1b0_1001", + "sip 4.19.13 py38he6710b0_0", + "six 1.16.0 pyhd3eb1b0_0", + "snappy 1.1.8 he6710b0_0", + "sniffio 1.2.0 py38h06a4308_1", + "snowballstemmer 2.1.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.2.1 pyhd3eb1b0_0", + "sphinx 4.2.0 pyhd3eb1b0_1", + "sphinxcontrib 1.0 py38_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 5.1.5 py38h06a4308_1", + "spyder-kernels 2.1.3 py38h06a4308_0", + "sqlalchemy 1.4.22 py38h7f8727e_0", + "sqlite 3.36.0 hc218d9a_0", + "statsmodels 0.12.2 py38h27cfd23_0", + "sympy 1.9 py38h06a4308_0", + "tbb 2021.4.0 hd09550d_0", + "tbb4py 2021.4.0 py38hd09550d_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "terminado 0.9.4 py38h06a4308_0", + "testpath 0.5.0 pyhd3eb1b0_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.11 h1ccaba5_0", + "toml 0.10.2 pyhd3eb1b0_0", + "toolz 0.11.1 pyhd3eb1b0_0", + "tornado 6.1 py38h27cfd23_0", + "tqdm 4.62.3 pyhd3eb1b0_1", + "traitlets 5.1.0 pyhd3eb1b0_0", + "typed-ast 1.4.3 py38h7f8727e_1", + "typing_extensions 3.10.0.2 pyh06a4308_0", + "ujson 4.0.2 py38h2531618_0", + "unicodecsv 0.14.1 py38_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.7 pyhd3eb1b0_0", + "watchdog 2.1.3 py38h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py38_1", + "werkzeug 2.0.2 pyhd3eb1b0_0", + "wheel 0.37.0 pyhd3eb1b0_1", + "whichcraft 0.6.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.1 py38_0", + "wrapt 1.12.1 py38h7b6447c_1", + "wurlitzer 2.1.1 py38h06a4308_0", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.1 pyhd3eb1b0_0", + "xlwt 1.3.0 py38_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h2531618_6", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.6.0 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py38_1", + "zope.event 4.5.0 py38_0", + "zope.interface 5.4.0 py38h7f8727e_0", + "zstd 1.4.9 haebb681_0" + ], + "license": "BSD", + "md5": "01b99eb65359151964117da2aad32316", + "name": "anaconda", + "namespace": "python", + "sha256": "cff58193b564e2bd17c2643c75ab65770a821c67a50758409132511bdddfec0b", + "size": 18262, + "subdir": "linux-64", + "timestamp": 1636485274528, + "version": "2021.11" + }, + "anaconda-2021.11-py39_0.conda": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 4.5 1_gnu", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.9.0 py39h06a4308_0", + "anaconda-project 0.10.1 pyhd3eb1b0_0", + "anyio 2.2.0 py39h06a4308_1", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argh 0.26.2 py39h06a4308_0", + "argon2-cffi 20.1.0 py39h27cfd23_1", + "arrow 0.13.1 py39h06a4308_0", + "asn1crypto 1.4.0 py_0", + "astroid 2.6.6 py39h06a4308_0", + "astropy 4.3.1 py39h09021b7_0", + "async_generator 1.10 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.2.0 pyhd3eb1b0_0", + "autopep8 1.5.7 pyhd3eb1b0_0", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.0 pyhd3eb1b0_2", + "backports.shutil_get_terminal_size 1.0.0 pyhd3eb1b0_3", + "beautifulsoup4 4.10.0 pyh06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.3.0 py39h7f8727e_1", + "bkcharts 0.2 py39h06a4308_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 4.0.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.4.1 py39h06a4308_0", + "boto 2.49.0 py39h06a4308_0", + "bottleneck 1.3.2 py39hdd57654_1", + "brotli 1.0.9 he6710b0_2", + "brotlipy 0.7.0 py39h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.17.1 h27cfd23_0", + "ca-certificates 2021.10.26 h06a4308_2", + "cached-property 1.5.2 py_0", + "cairo 1.16.0 hf32fb01_1", + "certifi 2021.10.8 py39h06a4308_0", + "cffi 1.14.6 py39h400218f_0", + "cfitsio 3.470 hf0d0db6_6", + "chardet 4.0.0 py39h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.3 pyhd3eb1b0_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py39h06a4308_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "conda-content-trust 0.1.1 pyhd3eb1b0_0", + "conda-token 0.3.0 pyhd3eb1b0_0", + "contextlib2 0.6.0.post1 pyhd3eb1b0_0", + "cookiecutter 1.7.2 pyhd3eb1b0_0", + "cryptography 3.4.8 py39hd23ed53_0", + "curl 7.78.0 h1ccaba5_0", + "cycler 0.10.0 py39h06a4308_0", + "cython 0.29.24 py39hdbfa776_0", + "cytoolz 0.11.0 py39h27cfd23_0", + "daal4py 2021.3.0 py39hae6d005_0", + "dal 2021.3.0 h06a4308_557", + "dask 2021.10.0 pyhd3eb1b0_0", + "dask-core 2021.10.0 pyhd3eb1b0_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.4.1 py39h295c915_0", + "decorator 5.1.0 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "distributed 2021.10.0 py39h06a4308_0", + "docutils 0.17.1 py39h06a4308_1", + "entrypoints 0.3 py39h06a4308_0", + "et_xmlfile 1.1.0 py39h06a4308_0", + "expat 2.4.1 h2531618_2", + "fastcache 1.1.0 py39he8ac12f_0", + "filelock 3.3.1 pyhd3eb1b0_1", + "flake8 3.9.2 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.10.4 h5ab3b9f_0", + "fribidi 1.0.10 h7b6447c_0", + "fsspec 2021.8.1 pyhd3eb1b0_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 21.8.0 py39h7f8727e_1", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h5202010_0", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.0.8 py39h8083e48_3", + "graphite2 1.3.14 h23475e2_0", + "greenlet 1.1.1 py39h295c915_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 3.3.0 py39h930cdd6_0", + "harfbuzz 2.8.1 h6f93f22_0", + "hdf5 1.10.6 hb1b8bf9_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "html5lib 1.1 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.2 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py39h4cda21f_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.2.0 pyhd3eb1b0_0", + "importlib-metadata 4.8.1 py39h06a4308_0", + "importlib_metadata 4.8.1 hd3eb1b0_0", + "inflection 0.5.1 py39h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.4.1 py39h06a4308_1", + "ipython 7.29.0 py39hb070fc8_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jbig 2.1 hdba287a_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.0 py39h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_2", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9d h7f8727e_0", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 3.2.0 pyhd3eb1b0_2", + "jupyter 1.0.0 py39h06a4308_7", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.8.1 py39h06a4308_0", + "jupyter_server 1.4.1 py39h06a4308_0", + "jupyterlab 3.2.1 pyhd3eb1b0_1", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.8.2 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.1.0 py39h06a4308_0", + "kiwisolver 1.3.1 py39h2531618_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py39h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.35.1 h7274673_9", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.4.2 h62408e4_0", + "libcurl 7.78.0 h0b77cf5_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.3.0 h5101ec6_17", + "libgfortran-ng 7.5.0 ha8ba4b0_17", + "libgfortran4 7.5.0 ha8ba4b0_17", + "libgomp 9.3.0 h5101ec6_17", + "liblief 0.10.1 h2531618_1", + "libllvm11 11.1.0 h3826bc1_0", + "libnghttp2 1.41.0 hf8bcb03_2", + "libpng 1.6.37 hbc83047_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.9.0 h1ba5d50_1", + "libstdcxx-ng 9.3.0 hd4cf53a_17", + "libtiff 4.2.0 h85742a9_0", + "libtool 2.4.6 h7b6447c_1005", + "libuuid 1.0.3 h7f8727e_2", + "libuv 1.40.0 h7b6447c_0", + "libwebp 1.2.0 h89dd481_0", + "libwebp-base 1.2.0 h27cfd23_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.12 h03d6c58_0", + "libxslt 1.1.34 hc22bd24_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.37.0 py39h295c915_1", + "locket 0.2.1 py39h06a4308_1", + "lxml 4.6.3 py39h9120a33_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markupsafe 1.1.1 py39h27cfd23_0", + "matplotlib 3.4.3 py39h06a4308_0", + "matplotlib-base 3.4.3 py39hbbc1b5f_0", + "matplotlib-inline 0.1.2 pyhd3eb1b0_2", + "mccabe 0.6.1 py39h06a4308_1", + "mistune 0.8.4 py39h27cfd23_1000", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py39h7f8727e_0", + "mkl_fft 1.3.1 py39hd3c417c_0", + "mkl_random 1.2.2 py39h51133e4_0", + "mock 4.0.3 pyhd3eb1b0_0", + "more-itertools 8.10.0 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 hc856adb_0", + "mpmath 1.2.1 py39h06a4308_0", + "msgpack-python 1.0.2 py39hff7bd54_1", + "multipledispatch 0.6.0 py39h06a4308_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py39h06a4308_0", + "nbclassic 0.2.6 pyhd3eb1b0_0", + "nbclient 0.5.3 pyhd3eb1b0_0", + "nbconvert 6.1.0 py39h06a4308_0", + "nbformat 5.1.3 pyhd3eb1b0_0", + "ncurses 6.3 heee7806_1", + "nest-asyncio 1.5.1 pyhd3eb1b0_0", + "networkx 2.6.3 pyhd3eb1b0_0", + "nltk 3.6.5 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1006", + "notebook 6.4.5 py39h06a4308_0", + "numba 0.54.1 py39h51133e4_0", + "numexpr 2.7.3 py39h22e1b3c_1", + "numpy 1.20.3 py39hf144106_0", + "numpy-base 1.20.3 py39h74d4b33_0", + "numpydoc 1.1.0 pyhd3eb1b0_1", + "olefile 0.46 pyhd3eb1b0_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.9 pyhd3eb1b0_0", + "openssl 1.1.1l h7f8727e_0", + "packaging 21.0 pyhd3eb1b0_0", + "pandas 1.3.4 py39h8c16a72_0", + "pandocfilters 1.4.3 py39h06a4308_1", + "pango 1.45.3 hd140c19_0", + "parso 0.8.2 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_0", + "patchelf 0.13 h295c915_0", + "path 16.0.0 py39h06a4308_0", + "path.py 12.5.0 hd3eb1b0_0", + "pathlib2 2.3.6 py39h06a4308_2", + "pathspec 0.7.0 py_0", + "patsy 0.5.2 py39h06a4308_0", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py39h06a4308_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 8.4.0 py39h5aabda8_0", + "pip 21.2.4 py39h06a4308_0", + "pixman 0.40.0 h7f8727e_1", + "pkginfo 1.7.1 py39h06a4308_0", + "pluggy 0.13.1 py39h06a4308_0", + "ply 3.11 py39h06a4308_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.11.0 pyhd3eb1b0_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "psutil 5.8.0 py39h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.10.0 pyhd3eb1b0_0", + "py-lief 0.10.1 py39h2531618_1", + "pycodestyle 2.7.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py39h27cfd23_0", + "pycparser 2.20 py_2", + "pycurl 7.44.1 py39h8f2d780_1", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py39h27cfd23_0", + "pyflakes 2.3.1 pyhd3eb1b0_0", + "pygments 2.10.0 pyhd3eb1b0_0", + "pylint 2.9.6 py39h06a4308_1", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.31 py39h295c915_0", + "pyopenssl 21.0.0 pyhd3eb1b0_1", + "pyparsing 3.0.4 pyhd3eb1b0_0", + "pyqt 5.9.2 py39h2531618_6", + "pyrsistent 0.18.0 py39heee7806_0", + "pysocks 1.7.1 py39h06a4308_0", + "pytables 3.6.1 py39h77479fe_1", + "pytest 6.2.4 py39h06a4308_2", + "python 3.9.7 h12debd9_1", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.0.0 pyhd3eb1b0_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.2.4 pyhd3eb1b0_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "pytz 2021.3 pyhd3eb1b0_0", + "pywavelets 1.1.1 py39h6323ea4_4", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py39h7f8727e_1", + "pyzmq 22.2.1 py39h295c915_1", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.2 pyhd3eb1b0_0", + "qtconsole 5.1.1 pyhd3eb1b0_0", + "qtpy 1.10.0 pyhd3eb1b0_0", + "readline 8.1 h27cfd23_0", + "regex 2021.8.3 py39h7f8727e_0", + "requests 2.26.0 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.19.0 pyhd3eb1b0_0", + "rtree 0.9.7 py39h06a4308_1", + "ruamel_yaml 0.15.100 py39h27cfd23_0", + "scikit-image 0.18.3 py39h51133e4_0", + "scikit-learn 0.24.2 py39ha9443f7_0", + "scikit-learn-intelex 2021.3.0 py39h06a4308_0", + "scipy 1.7.1 py39h292c36d_2", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py39h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "setuptools 58.0.4 py39h06a4308_0", + "simplegeneric 0.8.1 py39h06a4308_2", + "singledispatch 3.7.0 pyhd3eb1b0_1001", + "sip 4.19.13 py39h2531618_0", + "six 1.16.0 pyhd3eb1b0_0", + "snappy 1.1.8 he6710b0_0", + "sniffio 1.2.0 py39h06a4308_1", + "snowballstemmer 2.1.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.2.1 pyhd3eb1b0_0", + "sphinx 4.2.0 pyhd3eb1b0_1", + "sphinxcontrib 1.0 py39h06a4308_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "sphinxcontrib-websupport 1.2.4 py_0", + "spyder 5.1.5 py39h06a4308_1", + "spyder-kernels 2.1.3 py39h06a4308_0", + "sqlalchemy 1.4.22 py39h7f8727e_0", + "sqlite 3.36.0 hc218d9a_0", + "statsmodels 0.12.2 py39h27cfd23_0", + "sympy 1.9 py39h06a4308_0", + "tbb 2021.4.0 hd09550d_0", + "tbb4py 2021.4.0 py39hd09550d_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "terminado 0.9.4 py39h06a4308_0", + "testpath 0.5.0 pyhd3eb1b0_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.11 h1ccaba5_0", + "toml 0.10.2 pyhd3eb1b0_0", + "toolz 0.11.1 pyhd3eb1b0_0", + "tornado 6.1 py39h27cfd23_0", + "tqdm 4.62.3 pyhd3eb1b0_1", + "traitlets 5.1.0 pyhd3eb1b0_0", + "typed-ast 1.4.3 py39h7f8727e_1", + "typing_extensions 3.10.0.2 pyh06a4308_0", + "tzdata 2021e hda174b7_0", + "ujson 4.0.2 py39h2531618_0", + "unicodecsv 0.14.1 py39h06a4308_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.7 pyhd3eb1b0_0", + "watchdog 2.1.3 py39h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py39h06a4308_1", + "werkzeug 2.0.2 pyhd3eb1b0_0", + "wheel 0.37.0 pyhd3eb1b0_1", + "whichcraft 0.6.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.1 py39h06a4308_0", + "wrapt 1.12.1 py39he8ac12f_1", + "wurlitzer 2.1.1 py39h06a4308_0", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.1 pyhd3eb1b0_0", + "xlwt 1.3.0 py39h06a4308_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h2531618_6", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.6.0 pyhd3eb1b0_0", + "zlib 1.2.11 h7b6447c_3", + "zope 1.0 py39h06a4308_1", + "zope.event 4.5.0 py39h06a4308_0", + "zope.interface 5.4.0 py39h7f8727e_0", + "zstd 1.4.9 haebb681_0" + ], + "license": "BSD", + "md5": "6aec0d588e99202ef837d3bab4dac900", + "name": "anaconda", + "namespace": "python", + "sha256": "1785c7dda9681332ad2aad28f594ab8e27da0dbad670f3268632114fbc030a57", + "size": 18228, + "subdir": "linux-64", + "timestamp": 1636485484252, + "version": "2021.11" + }, + "anaconda-2022.05-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 4.5 1_gnu", + "aiohttp 3.8.1 py37h7f8727e_1", + "aiosignal 1.2.0 pyhd3eb1b0_0", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.9.0 py37h06a4308_0", + "anaconda-project 0.10.2 pyhd3eb1b0_0", + "anyio 3.5.0 py37h06a4308_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "argon2-cffi-bindings 21.2.0 py37h7f8727e_0", + "arrow 1.2.2 pyhd3eb1b0_0", + "astroid 2.6.6 py37h06a4308_0", + "astropy 4.3.1 py37h09021b7_0", + "async-timeout 4.0.1 pyhd3eb1b0_0", + "asynctest 0.13.0 py_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.4.0 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_0", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.1 pyhd3eb1b0_0", + "backports.functools_lru_cache 1.6.4 pyhd3eb1b0_0", + "backports.tempfile 1.0 pyhd3eb1b0_1", + "backports.weakref 1.0.post1 py_1", + "bcrypt 3.2.0 py37h7b6447c_0", + "beautifulsoup4 4.11.1 py37h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.4.1 py37h7f8727e_0", + "bkcharts 0.2 py37_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 4.1.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.4.2 py37h06a4308_0", + "boto3 1.21.32 pyhd3eb1b0_0", + "botocore 1.24.32 pyhd3eb1b0_0", + "bottleneck 1.3.4 py37hce1f21e_0", + "brotli 1.0.9 he6710b0_2", + "brotlipy 0.7.0 py37h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "ca-certificates 2022.3.29 h06a4308_1", + "cachetools 4.2.2 pyhd3eb1b0_0", + "certifi 2021.10.8 py37h06a4308_2", + "cffi 1.15.0 py37hd667e15_1", + "cfitsio 3.470 hf0d0db6_6", + "chardet 4.0.0 py37h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py37h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "colorcet 2.0.6 pyhd3eb1b0_0", + "conda-content-trust 0.1.1 pyhd3eb1b0_0", + "conda-token 0.3.0 pyhd3eb1b0_0", + "constantly 15.1.0 py37h28b3542_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "cryptography 3.4.8 py37hd23ed53_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.82.0 h7f8727e_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "cython 0.29.28 py37h295c915_0", + "cytoolz 0.11.0 py37h7b6447c_0", + "daal4py 2021.5.0 py37h78b71dc_0", + "dal 2021.5.1 h06a4308_803", + "dask 2021.10.0 pyhd3eb1b0_0", + "dask-core 2021.10.0 pyhd3eb1b0_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "datashader 0.13.0 pyhd3eb1b0_1", + "datashape 0.5.4 py37h06a4308_1", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.5.1 py37h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "distributed 2021.10.0 py37h06a4308_0", + "docutils 0.17.1 py37h06a4308_1", + "entrypoints 0.4 py37h06a4308_0", + "et_xmlfile 1.1.0 py37h06a4308_0", + "expat 2.4.4 h295c915_0", + "filelock 3.6.0 pyhd3eb1b0_0", + "flake8 3.9.2 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.11.0 h70c0345_0", + "frozenlist 1.2.0 py37h7f8727e_0", + "fsspec 2022.2.0 pyhd3eb1b0_0", + "future 0.18.2 py37_1", + "gensim 4.1.2 py37h295c915_0", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h4ff587b_1", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.1.2 py37heeb90bb_0", + "google-api-core 1.25.1 pyhd3eb1b0_0", + "google-auth 1.33.0 pyhd3eb1b0_0", + "google-cloud-core 1.7.1 pyhd3eb1b0_0", + "google-cloud-storage 1.41.0 pyhd3eb1b0_0", + "google-crc32c 1.1.2 py37h27cfd23_0", + "google-resumable-media 1.3.1 pyhd3eb1b0_1", + "googleapis-common-protos 1.53.0 py37h06a4308_0", + "greenlet 1.1.1 py37h295c915_0", + "grpcio 1.42.0 py37hce63b2e_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py37h7918eee_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "holoviews 1.14.8 pyhd3eb1b0_0", + "hvplot 0.7.3 pyhd3eb1b0_1", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.3 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py37h4cda21f_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.3.0 pyhd3eb1b0_0", + "importlib-metadata 4.11.3 py37h06a4308_0", + "importlib_metadata 4.11.3 hd3eb1b0_0", + "importlib_resources 5.2.0 pyhd3eb1b0_1", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py37h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intake 0.6.5 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.9.1 py37h06a4308_0", + "ipython 7.31.1 py37h06a4308_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.1 py37h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9e h7f8727e_0", + "jq 1.6 h27cfd23_1000", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 4.4.0 py37h06a4308_0", + "jupyter 1.0.0 py37_7", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.9.2 py37h06a4308_0", + "jupyter_server 1.13.5 pyhd3eb1b0_0", + "jupyterlab 3.3.2 pyhd3eb1b0_0", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.10.3 pyhd3eb1b0_1", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.4.0 py37h06a4308_0", + "kiwisolver 1.3.2 py37h295c915_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py37h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.35.1 h7274673_9", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.4.2 h62408e4_0", + "libcrc32c 1.1.1 he6710b0_2", + "libcurl 7.82.0 h0b77cf5_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.3.0 h5101ec6_17", + "libgfortran-ng 7.5.0 ha8ba4b0_17", + "libgfortran4 7.5.0 ha8ba4b0_17", + "libgomp 9.3.0 h5101ec6_17", + "libidn2 2.3.2 h7f8727e_0", + "liblief 0.11.5 h295c915_1", + "libllvm11 11.1.0 h3826bc1_1", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.37 hbc83047_0", + "libprotobuf 3.19.1 h4ff587b_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.10.0 h8f2d780_0", + "libstdcxx-ng 9.3.0 hd4cf53a_17", + "libtiff 4.2.0 h85742a9_0", + "libunistring 0.9.10 h27cfd23_0", + "libuuid 1.0.3 h7f8727e_2", + "libwebp 1.2.2 h55f646e_0", + "libwebp-base 1.2.2 h7f8727e_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.12 h03d6c58_0", + "libxslt 1.1.34 hc22bd24_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.38.0 py37h4ff587b_0", + "locket 0.2.1 py37h06a4308_2", + "lxml 4.8.0 py37h1f438cf_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markdown 3.3.4 py37h06a4308_0", + "markupsafe 2.0.1 py37h27cfd23_0", + "matplotlib 3.5.1 py37h06a4308_1", + "matplotlib-base 3.5.1 py37ha18d171_1", + "matplotlib-inline 0.1.2 pyhd3eb1b0_2", + "mccabe 0.6.1 py37_1", + "mistune 0.8.4 py37h14c3975_1001", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py37h7f8727e_0", + "mkl_fft 1.3.1 py37hd3c417c_0", + "mkl_random 1.2.2 py37h51133e4_0", + "mock 4.0.3 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 hc856adb_0", + "mpmath 1.2.1 py37h06a4308_0", + "msgpack-python 1.0.2 py37hff7bd54_1", + "multidict 5.2.0 py37h7f8727e_2", + "multipledispatch 0.6.0 py37_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py37h06a4308_1", + "nbclassic 0.3.5 pyhd3eb1b0_0", + "nbclient 0.5.13 py37h06a4308_0", + "nbconvert 6.4.4 py37h06a4308_0", + "nbformat 5.3.0 py37h06a4308_0", + "ncurses 6.3 h7f8727e_2", + "nest-asyncio 1.5.5 py37h06a4308_0", + "networkx 2.6.3 pyhd3eb1b0_0", + "nltk 3.7 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1008", + "notebook 6.4.8 py37h06a4308_0", + "numba 0.55.1 py37h51133e4_0", + "numexpr 2.8.1 py37h6abb31d_0", + "numpy 1.21.5 py37he7a7128_1", + "numpy-base 1.21.5 py37hf524024_1", + "numpydoc 1.2 pyhd3eb1b0_0", + "olefile 0.46 py37_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.9 pyhd3eb1b0_0", + "openssl 1.1.1n h7f8727e_0", + "packaging 21.3 pyhd3eb1b0_0", + "pandas 1.3.5 py37h8c16a72_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "panel 0.13.0 py37h06a4308_0", + "param 1.12.0 pyhd3eb1b0_0", + "parsel 1.6.0 py37h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_1", + "patchelf 0.13 h295c915_0", + "pathspec 0.7.0 py_0", + "patsy 0.5.2 py37h06a4308_1", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py37_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.0.1 py37h22f2fdc_0", + "pip 21.2.2 py37h06a4308_0", + "pkginfo 1.8.2 pyhd3eb1b0_0", + "plotly 5.6.0 pyhd3eb1b0_0", + "pluggy 1.0.0 py37h06a4308_1", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.13.1 pyhd3eb1b0_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "protego 0.1.16 py_0", + "protobuf 3.19.1 py37h295c915_0", + "psutil 5.8.0 py37h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.11.0 pyhd3eb1b0_0", + "py-lief 0.11.5 py37h295c915_1", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pyasn1-modules 0.2.8 py_0", + "pycodestyle 2.7.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py37h27cfd23_0", + "pycparser 2.21 pyhd3eb1b0_0", + "pycrypto 2.6.1 py37h7b6447c_10", + "pyct 0.4.8 py37_0", + "pycurl 7.44.1 py37h8f2d780_1", + "pydispatcher 2.0.5 py37h06a4308_2", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py37h27cfd23_0", + "pyflakes 2.3.1 pyhd3eb1b0_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pylint 2.9.6 py37h06a4308_1", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.32 py37h295c915_1", + "pyopenssl 21.0.0 pyhd3eb1b0_1", + "pyparsing 3.0.4 pyhd3eb1b0_0", + "pyqt 5.9.2 py37h05f1152_2", + "pyrsistent 0.18.0 py37heee7806_0", + "pysocks 1.7.1 py37_1", + "pytables 3.6.1 py37h71ec239_0", + "pytest 7.1.1 py37h06a4308_0", + "python 3.7.13 h12debd9_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-fastjsonschema 2.15.1 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.0.0 pyhd3eb1b0_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.2.4 pyhd3eb1b0_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "python-snappy 0.6.0 py37h2531618_3", + "pytz 2021.3 pyhd3eb1b0_0", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "pywavelets 1.3.0 py37h7f8727e_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py37h7f8727e_1", + "pyzmq 22.3.0 py37h295c915_2", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.3 pyhd3eb1b0_0", + "qtconsole 5.3.0 pyhd3eb1b0_0", + "qtpy 2.0.1 pyhd3eb1b0_0", + "queuelib 1.5.0 py37h06a4308_0", + "readline 8.1.2 h7f8727e_1", + "regex 2022.3.15 py37h7f8727e_0", + "requests 2.27.1 pyhd3eb1b0_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.22.0 pyhd3eb1b0_0", + "rsa 4.7.2 pyhd3eb1b0_1", + "rtree 0.9.7 py37h06a4308_1", + "ruamel_yaml 0.15.100 py37h27cfd23_0", + "s3transfer 0.5.0 pyhd3eb1b0_0", + "scikit-image 0.19.2 py37h51133e4_0", + "scikit-learn 1.0.2 py37h51133e4_1", + "scikit-learn-intelex 2021.5.0 py37h06a4308_0", + "scipy 1.7.3 py37hc147768_0", + "scrapy 2.6.1 py37h06a4308_0", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py37h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "service_identity 18.1.0 pyhd3eb1b0_1", + "setuptools 61.2.0 py37h06a4308_0", + "sip 4.19.8 py37hf484d3e_0", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.1.0 pyhd3eb1b0_0", + "snappy 1.1.9 h295c915_0", + "sniffio 1.2.0 py37h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.1 pyhd3eb1b0_0", + "sphinx 4.4.0 pyhd3eb1b0_0", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "spyder 5.1.5 py37h06a4308_1", + "spyder-kernels 2.1.3 py37h06a4308_0", + "sqlalchemy 1.4.32 py37h7f8727e_0", + "sqlite 3.38.2 hc218d9a_0", + "statsmodels 0.13.2 py37h7f8727e_0", + "sympy 1.10.1 py37h06a4308_0", + "tabulate 0.8.9 py37h06a4308_0", + "tbb 2021.5.0 hd09550d_0", + "tbb4py 2021.5.0 py37hd09550d_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py37h06a4308_0", + "terminado 0.13.1 py37h06a4308_0", + "testpath 0.5.0 pyhd3eb1b0_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.11 h1ccaba5_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 1.2.2 pyhd3eb1b0_0", + "toolz 0.11.2 pyhd3eb1b0_0", + "tornado 6.1 py37h27cfd23_0", + "tqdm 4.64.0 py37h06a4308_0", + "traitlets 5.1.1 pyhd3eb1b0_0", + "twisted 22.2.0 py37h7f8727e_0", + "typed-ast 1.4.3 py37h7f8727e_1", + "typing-extensions 4.1.1 hd3eb1b0_0", + "typing_extensions 4.1.1 pyh06a4308_0", + "ujson 5.1.0 py37h295c915_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.9 py37h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py37h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py37_1", + "websocket-client 0.58.0 py37h06a4308_4", + "werkzeug 2.0.3 pyhd3eb1b0_0", + "wget 1.21.3 h0b77cf5_0", + "wheel 0.37.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.2 py37h06a4308_0", + "wrapt 1.12.1 py37h7b6447c_1", + "wurlitzer 3.0.2 py37h06a4308_0", + "xarray 0.20.1 pyhd3eb1b0_1", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.3 pyhd3eb1b0_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "yarl 1.5.1 py37h7b6447c_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h295c915_6", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.7.0 pyhd3eb1b0_0", + "zlib 1.2.12 h7f8727e_2", + "zope 1.0 py37_1", + "zope.interface 5.4.0 py37h7f8727e_0", + "zstd 1.4.9 haebb681_0" + ], + "license": "BSD", + "md5": "78fa32ce1e3d59c3e61d44ca1814b700", + "name": "anaconda", + "namespace": "python", + "sha256": "4e282fa77d2461719ff309e4e841f5bd51af9ec0fd8bc5b52d3d55bb3f721138", + "size": 19225, + "subdir": "linux-64", + "timestamp": 1651177267633, + "version": "2022.05" + }, + "anaconda-2022.05-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 4.5 1_gnu", + "aiohttp 3.8.1 py38h7f8727e_1", + "aiosignal 1.2.0 pyhd3eb1b0_0", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.9.0 py38h06a4308_0", + "anaconda-project 0.10.2 pyhd3eb1b0_0", + "anyio 3.5.0 py38h06a4308_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "argon2-cffi-bindings 21.2.0 py38h7f8727e_0", + "arrow 1.2.2 pyhd3eb1b0_0", + "astroid 2.6.6 py38h06a4308_0", + "astropy 5.0.4 py38hce1f21e_0", + "asttokens 2.0.5 pyhd3eb1b0_0", + "async-timeout 4.0.1 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.4.0 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_0", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.1 pyhd3eb1b0_0", + "backports.functools_lru_cache 1.6.4 pyhd3eb1b0_0", + "backports.tempfile 1.0 pyhd3eb1b0_1", + "backports.weakref 1.0.post1 py_1", + "bcrypt 3.2.0 py38h7b6447c_0", + "beautifulsoup4 4.11.1 py38h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.4.1 py38h7f8727e_0", + "bkcharts 0.2 py38_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 4.1.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.4.2 py38h06a4308_0", + "boto3 1.21.32 pyhd3eb1b0_0", + "botocore 1.24.32 pyhd3eb1b0_0", + "bottleneck 1.3.4 py38hce1f21e_0", + "brotli 1.0.9 he6710b0_2", + "brotlipy 0.7.0 py38h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "ca-certificates 2022.3.29 h06a4308_1", + "cachetools 4.2.2 pyhd3eb1b0_0", + "certifi 2021.10.8 py38h06a4308_2", + "cffi 1.15.0 py38hd667e15_1", + "cfitsio 3.470 hf0d0db6_6", + "chardet 4.0.0 py38h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py38h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py38_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "colorcet 2.0.6 pyhd3eb1b0_0", + "conda-content-trust 0.1.1 pyhd3eb1b0_0", + "conda-token 0.3.0 pyhd3eb1b0_0", + "constantly 15.1.0 pyh2b92418_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "cryptography 3.4.8 py38hd23ed53_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.82.0 h7f8727e_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "cython 0.29.28 py38h295c915_0", + "cytoolz 0.11.0 py38h7b6447c_0", + "daal4py 2021.5.0 py38h78b71dc_0", + "dal 2021.5.1 h06a4308_803", + "dask 2022.2.1 pyhd3eb1b0_0", + "dask-core 2022.2.1 pyhd3eb1b0_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "datashader 0.13.0 pyhd3eb1b0_1", + "datashape 0.5.4 py38h06a4308_1", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.5.1 py38h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "distributed 2022.2.1 pyhd3eb1b0_0", + "docutils 0.17.1 py38h06a4308_1", + "entrypoints 0.4 py38h06a4308_0", + "et_xmlfile 1.1.0 py38h06a4308_0", + "executing 0.8.3 pyhd3eb1b0_0", + "expat 2.4.4 h295c915_0", + "filelock 3.6.0 pyhd3eb1b0_0", + "flake8 3.9.2 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.11.0 h70c0345_0", + "frozenlist 1.2.0 py38h7f8727e_0", + "fsspec 2022.2.0 pyhd3eb1b0_0", + "future 0.18.2 py38_1", + "gensim 4.1.2 py38h295c915_0", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h4ff587b_1", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.1.2 py38heeb90bb_0", + "google-api-core 1.25.1 pyhd3eb1b0_0", + "google-auth 1.33.0 pyhd3eb1b0_0", + "google-cloud-core 1.7.1 pyhd3eb1b0_0", + "google-cloud-storage 1.41.0 pyhd3eb1b0_0", + "google-crc32c 1.1.2 py38h27cfd23_0", + "google-resumable-media 1.3.1 pyhd3eb1b0_1", + "googleapis-common-protos 1.53.0 py38h06a4308_0", + "greenlet 1.1.1 py38h295c915_0", + "grpcio 1.42.0 py38hce63b2e_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py38h7918eee_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "holoviews 1.14.8 pyhd3eb1b0_0", + "hvplot 0.7.3 pyhd3eb1b0_1", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.3 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py38h4cda21f_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.3.0 pyhd3eb1b0_0", + "importlib-metadata 4.11.3 py38h06a4308_0", + "importlib_metadata 4.11.3 hd3eb1b0_0", + "importlib_resources 5.2.0 pyhd3eb1b0_1", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py38h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intake 0.6.5 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.9.1 py38h06a4308_0", + "ipython 8.2.0 py38h06a4308_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.1 py38h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9e h7f8727e_0", + "jq 1.6 h27cfd23_1000", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 4.4.0 py38h06a4308_0", + "jupyter 1.0.0 py38_7", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.9.2 py38h06a4308_0", + "jupyter_server 1.13.5 pyhd3eb1b0_0", + "jupyterlab 3.3.2 pyhd3eb1b0_0", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.10.3 pyhd3eb1b0_1", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.4.0 py38h06a4308_0", + "kiwisolver 1.3.2 py38h295c915_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py38h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.35.1 h7274673_9", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.4.2 h62408e4_0", + "libcrc32c 1.1.1 he6710b0_2", + "libcurl 7.82.0 h0b77cf5_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.3.0 h5101ec6_17", + "libgfortran-ng 7.5.0 ha8ba4b0_17", + "libgfortran4 7.5.0 ha8ba4b0_17", + "libgomp 9.3.0 h5101ec6_17", + "libidn2 2.3.2 h7f8727e_0", + "liblief 0.11.5 h295c915_1", + "libllvm11 11.1.0 h3826bc1_1", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.37 hbc83047_0", + "libprotobuf 3.19.1 h4ff587b_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.10.0 h8f2d780_0", + "libstdcxx-ng 9.3.0 hd4cf53a_17", + "libtiff 4.2.0 h85742a9_0", + "libunistring 0.9.10 h27cfd23_0", + "libuuid 1.0.3 h7f8727e_2", + "libwebp 1.2.2 h55f646e_0", + "libwebp-base 1.2.2 h7f8727e_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.12 h03d6c58_0", + "libxslt 1.1.34 hc22bd24_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.38.0 py38h4ff587b_0", + "locket 0.2.1 py38h06a4308_2", + "lxml 4.8.0 py38h1f438cf_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markdown 3.3.4 py38h06a4308_0", + "markupsafe 2.0.1 py38h27cfd23_0", + "matplotlib 3.5.1 py38h06a4308_1", + "matplotlib-base 3.5.1 py38ha18d171_1", + "matplotlib-inline 0.1.2 pyhd3eb1b0_2", + "mccabe 0.6.1 py38_1", + "mistune 0.8.4 py38h7b6447c_1000", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py38h7f8727e_0", + "mkl_fft 1.3.1 py38hd3c417c_0", + "mkl_random 1.2.2 py38h51133e4_0", + "mock 4.0.3 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 hc856adb_0", + "mpmath 1.2.1 py38h06a4308_0", + "msgpack-python 1.0.2 py38hff7bd54_1", + "multidict 5.2.0 py38h7f8727e_2", + "multipledispatch 0.6.0 py38_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py38h06a4308_1", + "nbclassic 0.3.5 pyhd3eb1b0_0", + "nbclient 0.5.13 py38h06a4308_0", + "nbconvert 6.4.4 py38h06a4308_0", + "nbformat 5.3.0 py38h06a4308_0", + "ncurses 6.3 h7f8727e_2", + "nest-asyncio 1.5.5 py38h06a4308_0", + "networkx 2.7.1 pyhd3eb1b0_0", + "nltk 3.7 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1008", + "notebook 6.4.8 py38h06a4308_0", + "numba 0.55.1 py38h51133e4_0", + "numexpr 2.8.1 py38h6abb31d_0", + "numpy 1.21.5 py38he7a7128_1", + "numpy-base 1.21.5 py38hf524024_1", + "numpydoc 1.2 pyhd3eb1b0_0", + "olefile 0.46 pyhd3eb1b0_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.9 pyhd3eb1b0_0", + "openssl 1.1.1n h7f8727e_0", + "packaging 21.3 pyhd3eb1b0_0", + "pandas 1.4.2 py38h295c915_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "panel 0.13.0 py38h06a4308_0", + "param 1.12.0 pyhd3eb1b0_0", + "parsel 1.6.0 py38h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_1", + "patchelf 0.13 h295c915_0", + "pathspec 0.7.0 py_0", + "patsy 0.5.2 py38h06a4308_1", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py38_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.0.1 py38h22f2fdc_0", + "pip 21.2.4 py38h06a4308_0", + "pkginfo 1.8.2 pyhd3eb1b0_0", + "plotly 5.6.0 pyhd3eb1b0_0", + "pluggy 1.0.0 py38h06a4308_1", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.13.1 pyhd3eb1b0_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "protego 0.1.16 py_0", + "protobuf 3.19.1 py38h295c915_0", + "psutil 5.8.0 py38h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "pure_eval 0.2.2 pyhd3eb1b0_0", + "py 1.11.0 pyhd3eb1b0_0", + "py-lief 0.11.5 py38h295c915_1", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pyasn1-modules 0.2.8 py_0", + "pycodestyle 2.7.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py38h7b6447c_1", + "pycparser 2.21 pyhd3eb1b0_0", + "pyct 0.4.8 py38_0", + "pycurl 7.44.1 py38h8f2d780_1", + "pydispatcher 2.0.5 py38h06a4308_2", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py38h27cfd23_0", + "pyflakes 2.3.1 pyhd3eb1b0_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pylint 2.9.6 py38h06a4308_1", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.32 py38h295c915_1", + "pyopenssl 21.0.0 pyhd3eb1b0_1", + "pyparsing 3.0.4 pyhd3eb1b0_0", + "pyqt 5.9.2 py38h05f1152_4", + "pyrsistent 0.18.0 py38heee7806_0", + "pysocks 1.7.1 py38h06a4308_0", + "pytables 3.6.1 py38h9fd0a39_0", + "pytest 7.1.1 py38h06a4308_0", + "python 3.8.13 h12debd9_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-fastjsonschema 2.15.1 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.0.0 pyhd3eb1b0_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.2.4 pyhd3eb1b0_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "python-snappy 0.6.0 py38h2531618_3", + "pytz 2021.3 pyhd3eb1b0_0", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "pywavelets 1.3.0 py38h7f8727e_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py38h7f8727e_1", + "pyzmq 22.3.0 py38h295c915_2", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.3 pyhd3eb1b0_0", + "qtconsole 5.3.0 pyhd3eb1b0_0", + "qtpy 2.0.1 pyhd3eb1b0_0", + "queuelib 1.5.0 py38h06a4308_0", + "readline 8.1.2 h7f8727e_1", + "regex 2022.3.15 py38h7f8727e_0", + "requests 2.27.1 pyhd3eb1b0_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.22.0 pyhd3eb1b0_0", + "rsa 4.7.2 pyhd3eb1b0_1", + "rtree 0.9.7 py38h06a4308_1", + "ruamel_yaml 0.15.100 py38h27cfd23_0", + "s3transfer 0.5.0 pyhd3eb1b0_0", + "scikit-image 0.19.2 py38h51133e4_0", + "scikit-learn 1.0.2 py38h51133e4_1", + "scikit-learn-intelex 2021.5.0 py38h06a4308_0", + "scipy 1.7.3 py38hc147768_0", + "scrapy 2.6.1 py38h06a4308_0", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py38h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "service_identity 18.1.0 pyhd3eb1b0_1", + "setuptools 61.2.0 py38h06a4308_0", + "sip 4.19.13 py38h295c915_0", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.1.0 pyhd3eb1b0_0", + "snappy 1.1.9 h295c915_0", + "sniffio 1.2.0 py38h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.1 pyhd3eb1b0_0", + "sphinx 4.4.0 pyhd3eb1b0_0", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "spyder 5.1.5 py38h06a4308_1", + "spyder-kernels 2.1.3 py38h06a4308_0", + "sqlalchemy 1.4.32 py38h7f8727e_0", + "sqlite 3.38.2 hc218d9a_0", + "stack_data 0.2.0 pyhd3eb1b0_0", + "statsmodels 0.13.2 py38h7f8727e_0", + "sympy 1.10.1 py38h06a4308_0", + "tabulate 0.8.9 py38h06a4308_0", + "tbb 2021.5.0 hd09550d_0", + "tbb4py 2021.5.0 py38hd09550d_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py38h06a4308_0", + "terminado 0.13.1 py38h06a4308_0", + "testpath 0.5.0 pyhd3eb1b0_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.11 h1ccaba5_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 1.2.2 pyhd3eb1b0_0", + "toolz 0.11.2 pyhd3eb1b0_0", + "tornado 6.1 py38h27cfd23_0", + "tqdm 4.64.0 py38h06a4308_0", + "traitlets 5.1.1 pyhd3eb1b0_0", + "twisted 22.2.0 py38h7f8727e_0", + "typed-ast 1.4.3 py38h7f8727e_1", + "typing-extensions 4.1.1 hd3eb1b0_0", + "typing_extensions 4.1.1 pyh06a4308_0", + "ujson 5.1.0 py38h295c915_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.9 py38h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py38h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py38_1", + "websocket-client 0.58.0 py38h06a4308_4", + "werkzeug 2.0.3 pyhd3eb1b0_0", + "wget 1.21.3 h0b77cf5_0", + "wheel 0.37.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.2 py38h06a4308_0", + "wrapt 1.12.1 py38h7b6447c_1", + "wurlitzer 3.0.2 py38h06a4308_0", + "xarray 0.20.1 pyhd3eb1b0_1", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.3 pyhd3eb1b0_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "yarl 1.5.1 py38h7b6447c_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h295c915_6", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.7.0 pyhd3eb1b0_0", + "zlib 1.2.12 h7f8727e_2", + "zope 1.0 py38_1", + "zope.interface 5.4.0 py38h7f8727e_0", + "zstd 1.4.9 haebb681_0" + ], + "license": "BSD", + "md5": "3906a17cf3bdb2276b13cb5af80ca4d6", + "name": "anaconda", + "namespace": "python", + "sha256": "1ea1e0029cb5b5da8587e9c81b0b70edcc00ec82873cded1ee9deab71d8e2a9a", + "size": 19224, + "subdir": "linux-64", + "timestamp": 1651176352469, + "version": "2022.05" + }, + "anaconda-2022.05-py39_0.conda": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 4.5 1_gnu", + "aiohttp 3.8.1 py39h7f8727e_1", + "aiosignal 1.2.0 pyhd3eb1b0_0", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.9.0 py39h06a4308_0", + "anaconda-project 0.10.2 pyhd3eb1b0_0", + "anyio 3.5.0 py39h06a4308_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "argon2-cffi-bindings 21.2.0 py39h7f8727e_0", + "arrow 1.2.2 pyhd3eb1b0_0", + "astroid 2.6.6 py39h06a4308_0", + "astropy 5.0.4 py39hce1f21e_0", + "asttokens 2.0.5 pyhd3eb1b0_0", + "async-timeout 4.0.1 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.4.0 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_0", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.1 pyhd3eb1b0_0", + "backports.functools_lru_cache 1.6.4 pyhd3eb1b0_0", + "backports.tempfile 1.0 pyhd3eb1b0_1", + "backports.weakref 1.0.post1 py_1", + "bcrypt 3.2.0 py39he8ac12f_0", + "beautifulsoup4 4.11.1 py39h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.4.1 py39h7f8727e_0", + "bkcharts 0.2 py39h06a4308_0", + "black 19.10b0 py_0", + "blas 1.0 mkl", + "bleach 4.1.0 pyhd3eb1b0_0", + "blosc 1.21.0 h8c45485_0", + "bokeh 2.4.2 py39h06a4308_0", + "boto3 1.21.32 pyhd3eb1b0_0", + "botocore 1.24.32 pyhd3eb1b0_0", + "bottleneck 1.3.4 py39hce1f21e_0", + "brotli 1.0.9 he6710b0_2", + "brotlipy 0.7.0 py39h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "ca-certificates 2022.3.29 h06a4308_1", + "cachetools 4.2.2 pyhd3eb1b0_0", + "certifi 2021.10.8 py39h06a4308_2", + "cffi 1.15.0 py39hd667e15_1", + "cfitsio 3.470 hf0d0db6_6", + "chardet 4.0.0 py39h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py39h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py39h06a4308_1", + "colorama 0.4.4 pyhd3eb1b0_0", + "colorcet 2.0.6 pyhd3eb1b0_0", + "conda-content-trust 0.1.1 pyhd3eb1b0_0", + "conda-token 0.3.0 pyhd3eb1b0_0", + "constantly 15.1.0 pyh2b92418_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "cryptography 3.4.8 py39hd23ed53_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.82.0 h7f8727e_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "cython 0.29.28 py39h295c915_0", + "cytoolz 0.11.0 py39h27cfd23_0", + "daal4py 2021.5.0 py39h78b71dc_0", + "dal 2021.5.1 h06a4308_803", + "dask 2022.2.1 pyhd3eb1b0_0", + "dask-core 2022.2.1 pyhd3eb1b0_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "datashader 0.13.0 pyhd3eb1b0_1", + "datashape 0.5.4 py39h06a4308_1", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.5.1 py39h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "distributed 2022.2.1 pyhd3eb1b0_0", + "docutils 0.17.1 py39h06a4308_1", + "entrypoints 0.4 py39h06a4308_0", + "et_xmlfile 1.1.0 py39h06a4308_0", + "executing 0.8.3 pyhd3eb1b0_0", + "expat 2.4.4 h295c915_0", + "filelock 3.6.0 pyhd3eb1b0_0", + "flake8 3.9.2 pyhd3eb1b0_0", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.11.0 h70c0345_0", + "frozenlist 1.2.0 py39h7f8727e_0", + "fsspec 2022.2.0 pyhd3eb1b0_0", + "future 0.18.2 py39h06a4308_1", + "gensim 4.1.2 py39h295c915_0", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h4ff587b_1", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h2531618_2", + "gmpy2 2.1.2 py39heeb90bb_0", + "google-api-core 1.25.1 pyhd3eb1b0_0", + "google-auth 1.33.0 pyhd3eb1b0_0", + "google-cloud-core 1.7.1 pyhd3eb1b0_0", + "google-cloud-storage 1.31.0 py_0", + "google-crc32c 1.1.2 py39h27cfd23_0", + "google-resumable-media 1.3.1 pyhd3eb1b0_1", + "googleapis-common-protos 1.53.0 py39h06a4308_0", + "greenlet 1.1.1 py39h295c915_0", + "grpcio 1.42.0 py39hce63b2e_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 3.6.0 py39ha0f2276_0", + "hdf5 1.10.6 hb1b8bf9_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "holoviews 1.14.8 pyhd3eb1b0_0", + "hvplot 0.7.3 pyhd3eb1b0_1", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.3 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py39h4cda21f_0", + "imageio 2.9.0 pyhd3eb1b0_0", + "imagesize 1.3.0 pyhd3eb1b0_0", + "importlib-metadata 4.11.3 py39h06a4308_0", + "importlib_metadata 4.11.3 hd3eb1b0_0", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py39h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intake 0.6.5 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.9.1 py39h06a4308_0", + "ipython 8.2.0 py39h06a4308_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.1 py39h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9e h7f8727e_0", + "jq 1.6 h27cfd23_1000", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 4.4.0 py39h06a4308_0", + "jupyter 1.0.0 py39h06a4308_7", + "jupyter_client 6.1.12 pyhd3eb1b0_0", + "jupyter_console 6.4.0 pyhd3eb1b0_0", + "jupyter_core 4.9.2 py39h06a4308_0", + "jupyter_server 1.13.5 pyhd3eb1b0_0", + "jupyterlab 3.3.2 pyhd3eb1b0_0", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.10.3 pyhd3eb1b0_1", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.4.0 py39h06a4308_0", + "kiwisolver 1.3.2 py39h295c915_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py39h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.35.1 h7274673_9", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.4.2 h62408e4_0", + "libcrc32c 1.1.1 he6710b0_2", + "libcurl 7.82.0 h0b77cf5_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libffi 3.3 he6710b0_2", + "libgcc-ng 9.3.0 h5101ec6_17", + "libgfortran-ng 7.5.0 ha8ba4b0_17", + "libgfortran4 7.5.0 ha8ba4b0_17", + "libgomp 9.3.0 h5101ec6_17", + "libidn2 2.3.2 h7f8727e_0", + "liblief 0.11.5 h295c915_1", + "libllvm11 11.1.0 h3826bc1_1", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.37 hbc83047_0", + "libprotobuf 3.19.1 h4ff587b_0", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.10.0 h8f2d780_0", + "libstdcxx-ng 9.3.0 hd4cf53a_17", + "libtiff 4.2.0 h85742a9_0", + "libunistring 0.9.10 h27cfd23_0", + "libuuid 1.0.3 h7f8727e_2", + "libwebp 1.2.2 h55f646e_0", + "libwebp-base 1.2.2 h7f8727e_0", + "libxcb 1.14 h7b6447c_0", + "libxml2 2.9.12 h03d6c58_0", + "libxslt 1.1.34 hc22bd24_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.38.0 py39h4ff587b_0", + "locket 0.2.1 py39h06a4308_2", + "lxml 4.8.0 py39h1f438cf_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markdown 3.3.4 py39h06a4308_0", + "markupsafe 2.0.1 py39h27cfd23_0", + "matplotlib 3.5.1 py39h06a4308_1", + "matplotlib-base 3.5.1 py39ha18d171_1", + "matplotlib-inline 0.1.2 pyhd3eb1b0_2", + "mccabe 0.6.1 py39h06a4308_1", + "mistune 0.8.4 py39h27cfd23_1000", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py39h7f8727e_0", + "mkl_fft 1.3.1 py39hd3c417c_0", + "mkl_random 1.2.2 py39h51133e4_0", + "mock 4.0.3 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 hc856adb_0", + "mpmath 1.2.1 py39h06a4308_0", + "msgpack-python 1.0.2 py39hff7bd54_1", + "multidict 5.2.0 py39h7f8727e_2", + "multipledispatch 0.6.0 py39h06a4308_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py39h06a4308_1", + "nbclassic 0.3.5 pyhd3eb1b0_0", + "nbclient 0.5.13 py39h06a4308_0", + "nbconvert 6.4.4 py39h06a4308_0", + "nbformat 5.3.0 py39h06a4308_0", + "ncurses 6.3 h7f8727e_2", + "nest-asyncio 1.5.5 py39h06a4308_0", + "networkx 2.7.1 pyhd3eb1b0_0", + "nltk 3.7 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1008", + "notebook 6.4.8 py39h06a4308_0", + "numba 0.55.1 py39h51133e4_0", + "numexpr 2.8.1 py39h6abb31d_0", + "numpy 1.21.5 py39he7a7128_1", + "numpy-base 1.21.5 py39hf524024_1", + "numpydoc 1.2 pyhd3eb1b0_0", + "olefile 0.46 pyhd3eb1b0_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.9 pyhd3eb1b0_0", + "openssl 1.1.1n h7f8727e_0", + "packaging 21.3 pyhd3eb1b0_0", + "pandas 1.4.2 py39h295c915_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "panel 0.13.0 py39h06a4308_0", + "param 1.12.0 pyhd3eb1b0_0", + "parsel 1.6.0 py39h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_1", + "patchelf 0.13 h295c915_0", + "pathspec 0.7.0 py_0", + "patsy 0.5.2 py39h06a4308_1", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py39h06a4308_0", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.0.1 py39h22f2fdc_0", + "pip 21.2.4 py39h06a4308_0", + "pkginfo 1.8.2 pyhd3eb1b0_0", + "plotly 5.6.0 pyhd3eb1b0_0", + "pluggy 1.0.0 py39h06a4308_1", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.13.1 pyhd3eb1b0_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "protego 0.1.16 py_0", + "protobuf 3.19.1 py39h295c915_0", + "psutil 5.8.0 py39h27cfd23_1", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "pure_eval 0.2.2 pyhd3eb1b0_0", + "py 1.11.0 pyhd3eb1b0_0", + "py-lief 0.11.5 py39h295c915_1", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pyasn1-modules 0.2.8 py_0", + "pycodestyle 2.7.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py39h27cfd23_0", + "pycparser 2.21 pyhd3eb1b0_0", + "pyct 0.4.6 py39h06a4308_0", + "pycurl 7.44.1 py39h8f2d780_1", + "pydispatcher 2.0.5 py39h06a4308_2", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py39h27cfd23_0", + "pyflakes 2.3.1 pyhd3eb1b0_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pylint 2.9.6 py39h06a4308_1", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.32 py39h295c915_1", + "pyopenssl 21.0.0 pyhd3eb1b0_1", + "pyparsing 3.0.4 pyhd3eb1b0_0", + "pyqt 5.9.2 py39h2531618_6", + "pyrsistent 0.18.0 py39heee7806_0", + "pysocks 1.7.1 py39h06a4308_0", + "pytables 3.6.1 py39h77479fe_1", + "pytest 7.1.1 py39h06a4308_0", + "python 3.9.12 h12debd9_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-fastjsonschema 2.15.1 pyhd3eb1b0_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.0.0 pyhd3eb1b0_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.2.4 pyhd3eb1b0_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "python-snappy 0.6.0 py39h2531618_3", + "pytz 2021.3 pyhd3eb1b0_0", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "pywavelets 1.3.0 py39h7f8727e_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py39h7f8727e_1", + "pyzmq 22.3.0 py39h295c915_2", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.9.7 h5867ecd_1", + "qtawesome 1.0.3 pyhd3eb1b0_0", + "qtconsole 5.3.0 pyhd3eb1b0_0", + "qtpy 2.0.1 pyhd3eb1b0_0", + "queuelib 1.5.0 py39h06a4308_0", + "readline 8.1.2 h7f8727e_1", + "regex 2022.3.15 py39h7f8727e_0", + "requests 2.27.1 pyhd3eb1b0_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "ripgrep 12.1.1 0", + "rope 0.22.0 pyhd3eb1b0_0", + "rsa 4.7.2 pyhd3eb1b0_1", + "rtree 0.9.7 py39h06a4308_1", + "ruamel_yaml 0.15.100 py39h27cfd23_0", + "s3transfer 0.5.0 pyhd3eb1b0_0", + "scikit-image 0.19.2 py39h51133e4_0", + "scikit-learn 1.0.2 py39h51133e4_1", + "scikit-learn-intelex 2021.5.0 py39h06a4308_0", + "scipy 1.7.3 py39hc147768_0", + "scrapy 2.6.1 py39h06a4308_0", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py39h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "service_identity 18.1.0 pyhd3eb1b0_1", + "setuptools 61.2.0 py39h06a4308_0", + "sip 4.19.13 py39h295c915_0", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.1.0 pyhd3eb1b0_0", + "snappy 1.1.9 h295c915_0", + "sniffio 1.2.0 py39h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.1 pyhd3eb1b0_0", + "sphinx 4.4.0 pyhd3eb1b0_0", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "spyder 5.1.5 py39h06a4308_1", + "spyder-kernels 2.1.3 py39h06a4308_0", + "sqlalchemy 1.4.32 py39h7f8727e_0", + "sqlite 3.38.2 hc218d9a_0", + "stack_data 0.2.0 pyhd3eb1b0_0", + "statsmodels 0.13.2 py39h7f8727e_0", + "sympy 1.10.1 py39h06a4308_0", + "tabulate 0.8.9 py39h06a4308_0", + "tbb 2021.5.0 hd09550d_0", + "tbb4py 2021.5.0 py39hd09550d_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py39h06a4308_0", + "terminado 0.13.1 py39h06a4308_0", + "testpath 0.5.0 pyhd3eb1b0_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.11 h1ccaba5_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 1.2.2 pyhd3eb1b0_0", + "toolz 0.11.2 pyhd3eb1b0_0", + "tornado 6.1 py39h27cfd23_0", + "tqdm 4.64.0 py39h06a4308_0", + "traitlets 5.1.1 pyhd3eb1b0_0", + "twisted 22.2.0 py39h7f8727e_0", + "typed-ast 1.4.3 py39h7f8727e_1", + "typing-extensions 4.1.1 hd3eb1b0_0", + "typing_extensions 4.1.1 pyh06a4308_0", + "tzdata 2022a hda174b7_0", + "ujson 5.1.0 py39h295c915_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.9 h7b6447c_0", + "urllib3 1.26.9 py39h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py39h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py39h06a4308_1", + "websocket-client 0.58.0 py39h06a4308_4", + "werkzeug 2.0.3 pyhd3eb1b0_0", + "wget 1.21.3 h0b77cf5_0", + "wheel 0.37.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.2 py39h06a4308_0", + "wrapt 1.12.1 py39he8ac12f_1", + "wurlitzer 3.0.2 py39h06a4308_0", + "xarray 0.20.1 pyhd3eb1b0_1", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.3 pyhd3eb1b0_0", + "xz 5.2.5 h7b6447c_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "yarl 1.6.3 py39h27cfd23_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h295c915_6", + "zict 2.0.0 pyhd3eb1b0_0", + "zipp 3.7.0 pyhd3eb1b0_0", + "zlib 1.2.12 h7f8727e_2", + "zope 1.0 py39h06a4308_1", + "zope.interface 5.4.0 py39h7f8727e_0", + "zstd 1.4.9 haebb681_0" + ], + "license": "BSD", + "md5": "e81500464f2176706ffef909cd1d6ae6", + "name": "anaconda", + "namespace": "python", + "sha256": "fa5755d94242cd8cb1eb8ac758c32c7d579dfa50d808115a1dae8664c1bb75d9", + "size": 19197, + "subdir": "linux-64", + "timestamp": 1651176341931, + "version": "2022.05" + }, + "anaconda-2022.10-py310_0.conda": { + "build": "py310_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 5.1 1_gnu", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.11.0 py310h06a4308_0", + "anaconda-project 0.11.1 py310h06a4308_0", + "anyio 3.5.0 py310h06a4308_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "argon2-cffi-bindings 21.2.0 py310h7f8727e_0", + "arrow 1.2.2 pyhd3eb1b0_0", + "astroid 2.11.7 py310h06a4308_0", + "astropy 5.1 py310ha9d4c09_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.4.0 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_1", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.1 pyhd3eb1b0_0", + "backports.functools_lru_cache 1.6.4 pyhd3eb1b0_0", + "backports.tempfile 1.0 pyhd3eb1b0_1", + "backports.weakref 1.0.post1 py_1", + "bcrypt 3.2.0 py310h5eee18b_1", + "beautifulsoup4 4.11.1 py310h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.5.1 py310h5eee18b_0", + "bkcharts 0.2 py310h06a4308_1", + "black 22.6.0 py310h06a4308_0", + "blas 1.0 mkl", + "bleach 4.1.0 pyhd3eb1b0_0", + "blosc 1.21.0 h4ff587b_1", + "bokeh 2.4.3 py310h06a4308_0", + "boto3 1.24.28 py310h06a4308_0", + "botocore 1.27.28 py310h06a4308_0", + "bottleneck 1.3.5 py310ha9d4c09_0", + "brotli 1.0.9 h5eee18b_7", + "brotli-bin 1.0.9 h5eee18b_7", + "brotlipy 0.7.0 py310h7f8727e_1002", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "ca-certificates 2022.07.19 h06a4308_0", + "certifi 2022.9.14 py310h06a4308_0", + "cffi 1.15.1 py310h74dc2b5_0", + "cfitsio 3.470 h5893167_7", + "chardet 4.0.0 py310h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py310h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py310h06a4308_1", + "colorama 0.4.5 py310h06a4308_0", + "colorcet 3.0.0 py310h06a4308_0", + "conda-content-trust 0.1.3 py310h06a4308_0", + "conda-token 0.4.0 pyhd3eb1b0_0", + "constantly 15.1.0 py310h06a4308_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "cryptography 37.0.1 py310h9ce1e76_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.84.0 h5eee18b_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "cython 0.29.32 py310h6a678d5_0", + "cytoolz 0.11.0 py310h7f8727e_0", + "daal4py 2021.6.0 py310h3c18c91_1", + "dal 2021.6.0 hdb19cb5_916", + "dask 2022.7.0 py310h06a4308_0", + "dask-core 2022.7.0 py310h06a4308_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "datashader 0.14.1 py310h06a4308_0", + "datashape 0.5.4 py310h06a4308_1", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.5.1 py310h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "dill 0.3.4 pyhd3eb1b0_0", + "distributed 2022.7.0 py310h06a4308_0", + "docutils 0.18.1 py310h06a4308_3", + "entrypoints 0.4 py310h06a4308_0", + "et_xmlfile 1.1.0 py310h06a4308_0", + "expat 2.4.9 h6a678d5_0", + "fftw 3.3.9 h27cfd23_1", + "filelock 3.6.0 pyhd3eb1b0_0", + "flake8 4.0.1 pyhd3eb1b0_1", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.11.0 h70c0345_0", + "fsspec 2022.7.1 py310h06a4308_0", + "future 0.18.2 py310h06a4308_1", + "gensim 4.1.2 py310h295c915_0", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h4ff587b_1", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h295c915_3", + "gmpy2 2.1.2 py310heeb90bb_0", + "greenlet 1.1.1 py310h295c915_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 3.7.0 py310he06866b_0", + "hdf5 1.10.6 h3ffc7dd_1", + "heapdict 1.0.1 pyhd3eb1b0_0", + "holoviews 1.15.0 py310h06a4308_0", + "hvplot 0.8.0 py310h06a4308_0", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.3 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py310hecf7e94_1", + "imageio 2.19.3 py310h06a4308_0", + "imagesize 1.4.1 py310h06a4308_0", + "importlib-metadata 4.11.3 py310h06a4308_0", + "importlib_metadata 4.11.3 hd3eb1b0_0", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py310h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intake 0.6.5 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.15.2 py310h06a4308_0", + "ipython 7.31.1 py310h06a4308_1", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.1 py310h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jellyfish 0.9.0 py310h7f8727e_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9e h7f8727e_0", + "jq 1.6 h27cfd23_1000", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 4.16.0 py310h06a4308_0", + "jupyter 1.0.0 py310h06a4308_8", + "jupyter_client 7.3.4 py310h06a4308_0", + "jupyter_console 6.4.3 pyhd3eb1b0_0", + "jupyter_core 4.11.1 py310h06a4308_0", + "jupyter_server 1.18.1 py310h06a4308_0", + "jupyterlab 3.4.4 py310h06a4308_0", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.10.3 pyhd3eb1b0_1", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.4.0 py310h06a4308_0", + "kiwisolver 1.4.2 py310h295c915_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py310h7f8727e_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.38 h1181459_1", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.6.1 hab531cd_0", + "libbrotlicommon 1.0.9 h5eee18b_7", + "libbrotlidec 1.0.9 h5eee18b_7", + "libbrotlienc 1.0.9 h5eee18b_7", + "libclang 10.0.1 default_hb85057a_2", + "libcurl 7.84.0 h91b91d3_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libevent 2.1.12 h8f2d780_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 11.2.0 h1234567_1", + "libgfortran-ng 11.2.0 h00389a5_1", + "libgfortran5 11.2.0 h1234567_1", + "libgomp 11.2.0 h1234567_1", + "libidn2 2.3.2 h7f8727e_0", + "liblief 0.11.5 h295c915_1", + "libllvm10 10.0.1 hbcb73fb_5", + "libllvm11 11.1.0 h9e868ea_5", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.37 hbc83047_0", + "libpq 12.9 h16c4e8d_3", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.10.0 h8f2d780_0", + "libstdcxx-ng 11.2.0 h1234567_1", + "libtiff 4.4.0 hecacb30_0", + "libunistring 0.9.10 h27cfd23_0", + "libuuid 1.0.3 h7f8727e_2", + "libwebp 1.2.2 h55f646e_0", + "libwebp-base 1.2.2 h7f8727e_0", + "libxcb 1.15 h7f8727e_0", + "libxkbcommon 1.0.1 hfa300c1_0", + "libxml2 2.9.14 h74e7548_0", + "libxslt 1.1.35 h4e12654_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.38.0 py310h4ff587b_0", + "locket 1.0.0 py310h06a4308_0", + "lxml 4.9.1 py310h1edc446_0", + "lz4 3.1.3 py310h7f8727e_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markdown 3.3.4 py310h06a4308_0", + "markupsafe 2.0.1 py310h7f8727e_0", + "matplotlib 3.5.2 py310h06a4308_0", + "matplotlib-base 3.5.2 py310hf590b9c_0", + "matplotlib-inline 0.1.6 py310h06a4308_0", + "mccabe 0.7.0 pyhd3eb1b0_0", + "mistune 0.8.4 py310h7f8727e_1000", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py310h7f8727e_0", + "mkl_fft 1.3.1 py310hd6ae3a3_0", + "mkl_random 1.2.2 py310h00e6091_0", + "mock 4.0.3 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 external_0", + "mpmath 1.2.1 py310h06a4308_0", + "msgpack-python 1.0.3 py310hd09550d_0", + "multipledispatch 0.6.0 py310h06a4308_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py310h06a4308_0", + "nbclassic 0.3.5 pyhd3eb1b0_0", + "nbclient 0.5.13 py310h06a4308_0", + "nbconvert 6.4.4 py310h06a4308_0", + "nbformat 5.5.0 py310h06a4308_0", + "ncurses 6.3 h5eee18b_3", + "nest-asyncio 1.5.5 py310h06a4308_0", + "networkx 2.8.4 py310h06a4308_0", + "nltk 3.7 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1008", + "notebook 6.4.12 py310h06a4308_0", + "nspr 4.33 h295c915_0", + "nss 3.74 h0370c37_0", + "numba 0.55.1 py310h00e6091_0", + "numexpr 2.8.3 py310hcea2de6_0", + "numpy 1.21.5 py310h1794996_3", + "numpy-base 1.21.5 py310hcba007f_3", + "numpydoc 1.4.0 py310h06a4308_0", + "olefile 0.46 pyhd3eb1b0_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.10 py310h5eee18b_0", + "openssl 1.1.1q h7f8727e_0", + "packaging 21.3 pyhd3eb1b0_0", + "pandas 1.4.4 py310h6a678d5_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "panel 0.13.1 py310h06a4308_0", + "param 1.12.0 pyhd3eb1b0_0", + "parsel 1.6.0 py310h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_1", + "patch 2.7.6 h7b6447c_1001", + "patchelf 0.13 h295c915_0", + "pathspec 0.9.0 py310h06a4308_0", + "patsy 0.5.2 py310h06a4308_1", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py310h06a4308_1", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.2.0 py310hace64e9_1", + "pip 22.2.2 py310h06a4308_0", + "pkginfo 1.8.2 pyhd3eb1b0_0", + "platformdirs 2.5.2 py310h06a4308_0", + "plotly 5.9.0 py310h06a4308_0", + "pluggy 1.0.0 py310h06a4308_1", + "ply 3.11 py310h06a4308_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.14.1 py310h06a4308_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "protego 0.1.16 py_0", + "psutil 5.9.0 py310h5eee18b_0", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.11.0 pyhd3eb1b0_0", + "py-lief 0.11.5 py310h295c915_1", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pyasn1-modules 0.2.8 py_0", + "pycodestyle 2.8.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py310h7f8727e_0", + "pycparser 2.21 pyhd3eb1b0_0", + "pyct 0.4.8 py310h06a4308_1", + "pycurl 7.45.1 py310h8f2d780_0", + "pydispatcher 2.0.5 py310h06a4308_2", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py310h7f8727e_0", + "pyflakes 2.4.0 pyhd3eb1b0_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pylint 2.14.5 py310h06a4308_0", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.34 py310h6a678d5_0", + "pyopenssl 22.0.0 pyhd3eb1b0_0", + "pyparsing 3.0.9 py310h06a4308_0", + "pyqt 5.15.7 py310h6a678d5_1", + "pyqt5-sip 12.11.0 py310h6a678d5_1", + "pyqtwebengine 5.15.7 py310h6a678d5_1", + "pyrsistent 0.18.0 py310h7f8727e_0", + "pysocks 1.7.1 py310h06a4308_0", + "pytables 3.6.1 py310hadd16c1_1", + "pytest 7.1.2 py310h06a4308_0", + "python 3.10.4 h12debd9_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-fastjsonschema 2.16.2 py310h06a4308_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.2.1 py310h06a4308_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.5.0 py310h06a4308_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "python-snappy 0.6.0 py310h295c915_0", + "pytz 2022.1 py310h06a4308_0", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "pywavelets 1.3.0 py310h7f8727e_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py310h7f8727e_0", + "pyzmq 23.2.0 py310h6a678d5_0", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.15.9 h06a4308_0", + "qt-main 5.15.2 h327a75a_7", + "qt-webengine 5.15.9 hd2b0992_4", + "qtawesome 1.0.3 pyhd3eb1b0_0", + "qtconsole 5.3.2 py310h06a4308_0", + "qtpy 2.2.0 py310h06a4308_0", + "qtwebkit 5.212 h4eab89a_4", + "queuelib 1.5.0 py310h06a4308_0", + "readline 8.1.2 h7f8727e_1", + "regex 2022.7.9 py310h5eee18b_0", + "requests 2.28.1 py310h06a4308_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "ripgrep 13.0.0 hbdeaff8_0", + "rope 0.22.0 pyhd3eb1b0_0", + "rtree 0.9.7 py310h06a4308_1", + "ruamel_yaml 0.15.100 py310h7f8727e_0", + "s3transfer 0.6.0 py310h06a4308_0", + "scikit-image 0.19.2 py310h00e6091_0", + "scikit-learn 1.0.1 py310h00e6091_0", + "scikit-learn-intelex 2021.6.0 py310h06a4308_0", + "scipy 1.9.1 py310hd5efca6_0", + "scrapy 2.6.2 py310h06a4308_0", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py310h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "service_identity 18.1.0 pyhd3eb1b0_1", + "setuptools 63.4.1 py310h06a4308_0", + "sip 6.6.2 py310h6a678d5_0", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.2.1 py310h06a4308_0", + "snappy 1.1.9 h295c915_0", + "sniffio 1.2.0 py310h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.1 pyhd3eb1b0_0", + "sphinx 5.0.2 py310h06a4308_0", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "spyder 5.3.3 py310h06a4308_0", + "spyder-kernels 2.3.3 py310h06a4308_0", + "sqlalchemy 1.4.39 py310h5eee18b_0", + "sqlite 3.39.3 h5082296_0", + "statsmodels 0.13.2 py310h7f8727e_0", + "sympy 1.10.1 py310h06a4308_0", + "tabulate 0.8.10 py310h06a4308_0", + "tbb 2021.6.0 hdb19cb5_0", + "tbb4py 2021.6.0 py310hdb19cb5_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py310h06a4308_1", + "terminado 0.13.1 py310h06a4308_0", + "testpath 0.6.0 py310h06a4308_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.12 h1ccaba5_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 2.0.1 py310h06a4308_0", + "tomlkit 0.11.1 py310h06a4308_0", + "toolz 0.11.2 pyhd3eb1b0_0", + "tornado 6.1 py310h7f8727e_0", + "tqdm 4.64.1 py310h06a4308_0", + "traitlets 5.1.1 pyhd3eb1b0_0", + "twisted 22.2.0 py310h5eee18b_1", + "typing-extensions 4.3.0 py310h06a4308_0", + "typing_extensions 4.3.0 py310h06a4308_0", + "tzdata 2022c h04d1e81_0", + "ujson 5.4.0 py310h6a678d5_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.11 h5eee18b_0", + "urllib3 1.26.11 py310h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py310h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py310h06a4308_1", + "websocket-client 0.58.0 py310h06a4308_4", + "werkzeug 2.0.3 pyhd3eb1b0_0", + "wget 1.21.3 h0b77cf5_0", + "whatthepatch 1.0.2 py310h06a4308_0", + "wheel 0.37.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.2 py310h06a4308_0", + "wrapt 1.14.1 py310h5eee18b_0", + "wurlitzer 3.0.2 py310h06a4308_0", + "xarray 0.20.1 pyhd3eb1b0_1", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.3 pyhd3eb1b0_0", + "xz 5.2.6 h5eee18b_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h295c915_6", + "zict 2.1.0 py310h06a4308_0", + "zipp 3.8.0 py310h06a4308_0", + "zlib 1.2.12 h5eee18b_3", + "zope 1.0 py310h06a4308_1", + "zope.interface 5.4.0 py310h7f8727e_0", + "zstd 1.5.2 ha4553b6_0" + ], + "license": "BSD", + "md5": "ad8dc30f9ed8257fc17d26747424acbe", + "name": "anaconda", + "namespace": "python", + "sha256": "28d1d6302619221ede16db101025335232bca170be671302d3e1c081e1c46a3f", + "size": 19328, + "subdir": "linux-64", + "timestamp": 1665077665890, + "version": "2022.10" + }, + "anaconda-2022.10-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 5.1 1_gnu", + "alabaster 0.7.12 py37_0", + "anaconda-client 1.11.0 py37h06a4308_0", + "anaconda-project 0.11.1 py37h06a4308_0", + "anyio 3.5.0 py37h06a4308_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "argon2-cffi-bindings 21.2.0 py37h7f8727e_0", + "arrow 1.2.2 pyhd3eb1b0_0", + "astroid 2.11.7 py37h06a4308_0", + "astropy 4.3.1 py37h09021b7_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.4.0 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_1", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.1 pyhd3eb1b0_0", + "backports.functools_lru_cache 1.6.4 pyhd3eb1b0_0", + "backports.tempfile 1.0 pyhd3eb1b0_1", + "backports.weakref 1.0.post1 py_1", + "bcrypt 3.2.0 py37h5eee18b_1", + "beautifulsoup4 4.11.1 py37h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.5.1 py37h5eee18b_0", + "bkcharts 0.2 py37h06a4308_1", + "black 22.6.0 py37h06a4308_0", + "blas 1.0 mkl", + "bleach 4.1.0 pyhd3eb1b0_0", + "blosc 1.21.0 h4ff587b_1", + "bokeh 2.4.3 py37h06a4308_0", + "boto3 1.24.28 py37h06a4308_0", + "botocore 1.27.28 py37h06a4308_0", + "bottleneck 1.3.5 py37h7deecbd_0", + "brotli 1.0.9 h5eee18b_7", + "brotli-bin 1.0.9 h5eee18b_7", + "brotlipy 0.7.0 py37h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "ca-certificates 2022.07.19 h06a4308_0", + "certifi 2022.9.14 py37h06a4308_0", + "cffi 1.15.1 py37h74dc2b5_0", + "cfitsio 3.470 hf0d0db6_6", + "chardet 4.0.0 py37h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py37h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py37_1", + "colorama 0.4.5 py37h06a4308_0", + "colorcet 3.0.0 py37h06a4308_0", + "conda-content-trust 0.1.3 py37h06a4308_0", + "conda-token 0.4.0 pyhd3eb1b0_0", + "constantly 15.1.0 py37h28b3542_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "cryptography 37.0.1 py37h9ce1e76_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.84.0 h5eee18b_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "cython 0.29.32 py37h6a678d5_0", + "cytoolz 0.11.0 py37h7b6447c_0", + "daal4py 2021.6.0 py37h79cecc1_1", + "dal 2021.6.0 hdb19cb5_916", + "dask 2021.10.0 pyhd3eb1b0_0", + "dask-core 2021.10.0 pyhd3eb1b0_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "datashader 0.14.1 py37h06a4308_0", + "datashape 0.5.4 py37h06a4308_1", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.5.1 py37h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "dill 0.3.4 pyhd3eb1b0_0", + "distributed 2021.10.0 py37h06a4308_0", + "docutils 0.17.1 py37h06a4308_1", + "entrypoints 0.4 py37h06a4308_0", + "et_xmlfile 1.1.0 py37h06a4308_0", + "expat 2.4.9 h6a678d5_0", + "filelock 3.6.0 pyhd3eb1b0_0", + "flake8 4.0.1 pyhd3eb1b0_1", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.11.0 h70c0345_0", + "fsspec 2022.7.1 py37h06a4308_0", + "future 0.18.2 py37_1", + "gensim 4.1.2 py37h295c915_0", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h4ff587b_1", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h295c915_3", + "gmpy2 2.1.2 py37heeb90bb_0", + "greenlet 1.1.1 py37h295c915_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py37h7918eee_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "holoviews 1.15.0 py37h06a4308_0", + "hvplot 0.8.0 py37h06a4308_0", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.3 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py37hf0132c2_1", + "imageio 2.19.3 py37h06a4308_0", + "imagesize 1.4.1 py37h06a4308_0", + "importlib-metadata 3.10.0 py37h06a4308_0", + "importlib_metadata 3.10.0 hd3eb1b0_0", + "importlib_resources 5.2.0 pyhd3eb1b0_1", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py37h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intake 0.6.5 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.15.2 py37h06a4308_0", + "ipython 7.31.1 py37h06a4308_1", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.1 py37h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jellyfish 0.9.0 py37h7f8727e_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9e h7f8727e_0", + "jq 1.6 h27cfd23_1000", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 4.16.0 py37h06a4308_0", + "jupyter 1.0.0 py37h06a4308_8", + "jupyter_client 7.3.5 py37h06a4308_0", + "jupyter_console 6.4.3 pyhd3eb1b0_0", + "jupyter_core 4.11.1 py37h06a4308_0", + "jupyter_server 1.18.1 py37h06a4308_0", + "jupyterlab 3.4.4 py37h06a4308_0", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.10.3 pyhd3eb1b0_1", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.4.0 py37h06a4308_0", + "kiwisolver 1.4.2 py37h295c915_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py37h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.38 h1181459_1", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.6.1 hab531cd_0", + "libbrotlicommon 1.0.9 h5eee18b_7", + "libbrotlidec 1.0.9 h5eee18b_7", + "libbrotlienc 1.0.9 h5eee18b_7", + "libclang 10.0.1 default_hb85057a_2", + "libcurl 7.84.0 h91b91d3_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libevent 2.1.12 h8f2d780_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 11.2.0 h1234567_1", + "libgfortran-ng 7.5.0 ha8ba4b0_17", + "libgfortran4 7.5.0 ha8ba4b0_17", + "libgomp 11.2.0 h1234567_1", + "libidn2 2.3.2 h7f8727e_0", + "liblief 0.11.5 h295c915_1", + "libllvm10 10.0.1 hbcb73fb_5", + "libllvm11 11.1.0 h9e868ea_5", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.37 hbc83047_0", + "libpq 12.9 h16c4e8d_3", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.10.0 h8f2d780_0", + "libstdcxx-ng 11.2.0 h1234567_1", + "libtiff 4.4.0 hecacb30_0", + "libunistring 0.9.10 h27cfd23_0", + "libuuid 1.0.3 h7f8727e_2", + "libwebp 1.2.2 h55f646e_0", + "libwebp-base 1.2.2 h7f8727e_0", + "libxcb 1.15 h7f8727e_0", + "libxkbcommon 1.0.1 hfa300c1_0", + "libxml2 2.9.14 h74e7548_0", + "libxslt 1.1.35 h4e12654_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.38.0 py37h4ff587b_0", + "locket 1.0.0 py37h06a4308_0", + "lxml 4.9.1 py37h1edc446_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markdown 3.3.4 py37h06a4308_0", + "markupsafe 2.0.1 py37h27cfd23_0", + "matplotlib 3.5.2 py37h06a4308_0", + "matplotlib-base 3.5.2 py37hf590b9c_0", + "matplotlib-inline 0.1.6 py37h06a4308_0", + "mccabe 0.7.0 pyhd3eb1b0_0", + "mistune 0.8.4 py37h14c3975_1001", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py37h7f8727e_0", + "mkl_fft 1.3.1 py37hd3c417c_0", + "mkl_random 1.2.2 py37h51133e4_0", + "mock 4.0.3 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 hc856adb_0", + "mpmath 1.2.1 py37h06a4308_0", + "msgpack-python 1.0.3 py37hd09550d_0", + "multipledispatch 0.6.0 py37_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py37h06a4308_1", + "nbclassic 0.3.5 pyhd3eb1b0_0", + "nbclient 0.5.13 py37h06a4308_0", + "nbconvert 6.4.4 py37h06a4308_0", + "nbformat 5.5.0 py37h06a4308_0", + "ncurses 6.3 h5eee18b_3", + "nest-asyncio 1.5.5 py37h06a4308_0", + "networkx 2.6.3 pyhd3eb1b0_0", + "nltk 3.7 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1008", + "notebook 6.4.12 py37h06a4308_0", + "nspr 4.33 h295c915_0", + "nss 3.74 h0370c37_0", + "numba 0.55.1 py37h51133e4_0", + "numexpr 2.8.3 py37h807cd23_0", + "numpy 1.21.5 py37h6c91a56_3", + "numpy-base 1.21.5 py37ha15fc14_3", + "numpydoc 1.4.0 py37h06a4308_0", + "olefile 0.46 py37_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.10 py37h5eee18b_0", + "openssl 1.1.1q h7f8727e_0", + "packaging 21.3 pyhd3eb1b0_0", + "pandas 1.3.5 py37h8c16a72_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "panel 0.13.1 py37h06a4308_0", + "param 1.12.0 pyhd3eb1b0_0", + "parsel 1.6.0 py37h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_1", + "patch 2.7.6 h7b6447c_1001", + "patchelf 0.13 h295c915_0", + "pathspec 0.9.0 py37h06a4308_0", + "patsy 0.5.2 py37h06a4308_1", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py37h06a4308_1", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.2.0 py37hace64e9_1", + "pip 22.2.2 py37h06a4308_0", + "pkginfo 1.8.2 pyhd3eb1b0_0", + "pkgutil-resolve-name 1.3.10 py37h06a4308_0", + "platformdirs 2.5.2 py37h06a4308_0", + "plotly 5.9.0 py37h06a4308_0", + "pluggy 1.0.0 py37h06a4308_1", + "ply 3.11 py37_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.14.1 py37h06a4308_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "protego 0.1.16 py_0", + "psutil 5.9.0 py37h5eee18b_0", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.11.0 pyhd3eb1b0_0", + "py-lief 0.11.5 py37h295c915_1", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pyasn1-modules 0.2.8 py_0", + "pycodestyle 2.8.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py37h27cfd23_0", + "pycparser 2.21 pyhd3eb1b0_0", + "pycrypto 2.6.1 py37h7b6447c_10", + "pyct 0.4.8 py37h06a4308_1", + "pycurl 7.45.1 py37h8f2d780_0", + "pydispatcher 2.0.5 py37h06a4308_2", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py37h27cfd23_0", + "pyflakes 2.4.0 pyhd3eb1b0_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pylint 2.14.5 py37h06a4308_0", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.34 py37h6a678d5_0", + "pyopenssl 22.0.0 pyhd3eb1b0_0", + "pyparsing 3.0.9 py37h06a4308_0", + "pyqt 5.15.7 py37h6a678d5_1", + "pyqt5-sip 12.11.0 py37h6a678d5_1", + "pyqtwebengine 5.15.7 py37h6a678d5_1", + "pyrsistent 0.18.0 py37heee7806_0", + "pysocks 1.7.1 py37_1", + "pytables 3.6.1 py37h71ec239_0", + "pytest 7.1.2 py37h06a4308_0", + "python 3.7.13 h12debd9_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-fastjsonschema 2.16.2 py37h06a4308_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.2.1 py37h06a4308_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.5.0 py37h06a4308_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "python-snappy 0.6.0 py37h2531618_3", + "pytz 2022.1 py37h06a4308_0", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "pywavelets 1.3.0 py37h7f8727e_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py37h7f8727e_1", + "pyzmq 23.2.0 py37h6a678d5_0", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.15.9 h06a4308_0", + "qt-main 5.15.2 h327a75a_7", + "qt-webengine 5.15.9 hd2b0992_4", + "qtawesome 1.0.3 pyhd3eb1b0_0", + "qtconsole 5.3.2 py37h06a4308_0", + "qtpy 2.2.0 py37h06a4308_0", + "qtwebkit 5.212 h4eab89a_4", + "queuelib 1.5.0 py37h06a4308_0", + "readline 8.1.2 h7f8727e_1", + "regex 2022.7.9 py37h5eee18b_0", + "requests 2.28.1 py37h06a4308_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "ripgrep 13.0.0 hbdeaff8_0", + "rope 0.22.0 pyhd3eb1b0_0", + "rtree 0.9.7 py37h06a4308_1", + "ruamel_yaml 0.15.100 py37h27cfd23_0", + "s3transfer 0.6.0 py37h06a4308_0", + "scikit-image 0.19.2 py37h51133e4_0", + "scikit-learn 1.0.2 py37h51133e4_1", + "scikit-learn-intelex 2021.6.0 py37h06a4308_0", + "scipy 1.7.3 py37hc147768_0", + "scrapy 2.6.2 py37h06a4308_0", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py37h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "service_identity 18.1.0 pyhd3eb1b0_1", + "setuptools 63.4.1 py37h06a4308_0", + "sip 6.6.2 py37h6a678d5_0", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.2.1 py37h06a4308_0", + "snappy 1.1.9 h295c915_0", + "sniffio 1.2.0 py37h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.1 pyhd3eb1b0_0", + "sphinx 4.2.0 pyhd3eb1b0_1", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "spyder 5.3.3 py37h06a4308_0", + "spyder-kernels 2.3.3 py37h06a4308_0", + "sqlalchemy 1.4.39 py37h5eee18b_0", + "sqlite 3.39.3 h5082296_0", + "statsmodels 0.13.2 py37h7f8727e_0", + "sympy 1.10.1 py37h06a4308_0", + "tabulate 0.8.10 py37h06a4308_0", + "tbb 2021.6.0 hdb19cb5_0", + "tbb4py 2021.6.0 py37hdb19cb5_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py37h06a4308_1", + "terminado 0.13.1 py37h06a4308_0", + "testpath 0.6.0 py37h06a4308_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.12 h1ccaba5_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 2.0.1 py37h06a4308_0", + "tomlkit 0.11.1 py37h06a4308_0", + "toolz 0.11.2 pyhd3eb1b0_0", + "tornado 6.2 py37h5eee18b_0", + "tqdm 4.64.1 py37h06a4308_0", + "traitlets 5.1.1 pyhd3eb1b0_0", + "twisted 22.2.0 py37h5eee18b_1", + "typed-ast 1.4.3 py37h7f8727e_1", + "typing-extensions 4.3.0 py37h06a4308_0", + "typing_extensions 4.3.0 py37h06a4308_0", + "ujson 5.4.0 py37h6a678d5_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.11 h5eee18b_0", + "urllib3 1.26.11 py37h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py37h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py37_1", + "websocket-client 0.58.0 py37h06a4308_4", + "werkzeug 2.0.3 pyhd3eb1b0_0", + "wget 1.21.3 h0b77cf5_0", + "whatthepatch 1.0.2 py37h06a4308_0", + "wheel 0.37.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.2 py37h06a4308_0", + "wrapt 1.14.1 py37h5eee18b_0", + "wurlitzer 3.0.2 py37h06a4308_0", + "xarray 0.20.1 pyhd3eb1b0_1", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.3 pyhd3eb1b0_0", + "xz 5.2.6 h5eee18b_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h295c915_6", + "zict 2.1.0 py37h06a4308_0", + "zipp 3.8.0 py37h06a4308_0", + "zlib 1.2.12 h5eee18b_3", + "zope 1.0 py37_1", + "zope.interface 5.4.0 py37h7f8727e_0", + "zstd 1.5.2 ha4553b6_0" + ], + "license": "BSD", + "md5": "e49b4e9ad53d42a2aad61271a9506d36", + "name": "anaconda", + "namespace": "python", + "sha256": "ca944ebbee2735ae1f2444a6646bb9ed1b879fa160c8eb6ee8be8c25a11e6a64", + "size": 19394, + "subdir": "linux-64", + "timestamp": 1665076072933, + "version": "2022.10" + }, + "anaconda-2022.10-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 5.1 1_gnu", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.11.0 py38h06a4308_0", + "anaconda-project 0.11.1 py38h06a4308_0", + "anyio 3.5.0 py38h06a4308_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "argon2-cffi-bindings 21.2.0 py38h7f8727e_0", + "arrow 1.2.2 pyhd3eb1b0_0", + "astroid 2.11.7 py38h06a4308_0", + "astropy 5.1 py38h7deecbd_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.4.0 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_1", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.1 pyhd3eb1b0_0", + "backports.functools_lru_cache 1.6.4 pyhd3eb1b0_0", + "backports.tempfile 1.0 pyhd3eb1b0_1", + "backports.weakref 1.0.post1 py_1", + "bcrypt 3.2.0 py38h5eee18b_1", + "beautifulsoup4 4.11.1 py38h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.5.1 py38h5eee18b_0", + "bkcharts 0.2 py38h06a4308_1", + "black 22.6.0 py38h06a4308_0", + "blas 1.0 mkl", + "bleach 4.1.0 pyhd3eb1b0_0", + "blosc 1.21.0 h4ff587b_1", + "bokeh 2.4.3 py38h06a4308_0", + "boto3 1.24.28 py38h06a4308_0", + "botocore 1.27.28 py38h06a4308_0", + "bottleneck 1.3.5 py38h7deecbd_0", + "brotli 1.0.9 h5eee18b_7", + "brotli-bin 1.0.9 h5eee18b_7", + "brotlipy 0.7.0 py38h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "ca-certificates 2022.07.19 h06a4308_0", + "certifi 2022.9.14 py38h06a4308_0", + "cffi 1.15.1 py38h74dc2b5_0", + "cfitsio 3.470 hf0d0db6_6", + "chardet 4.0.0 py38h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py38h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py38_1", + "colorama 0.4.5 py38h06a4308_0", + "colorcet 3.0.0 py38h06a4308_0", + "conda-content-trust 0.1.3 py38h06a4308_0", + "conda-token 0.4.0 pyhd3eb1b0_0", + "constantly 15.1.0 pyh2b92418_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "cryptography 37.0.1 py38h9ce1e76_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.84.0 h5eee18b_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "cython 0.29.32 py38h6a678d5_0", + "cytoolz 0.11.0 py38h7b6447c_0", + "daal4py 2021.6.0 py38h79cecc1_1", + "dal 2021.6.0 hdb19cb5_916", + "dask 2022.7.0 py38h06a4308_0", + "dask-core 2022.7.0 py38h06a4308_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "datashader 0.14.1 py38h06a4308_0", + "datashape 0.5.4 py38h06a4308_1", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.5.1 py38h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "dill 0.3.4 pyhd3eb1b0_0", + "distributed 2022.7.0 py38h06a4308_0", + "docutils 0.18.1 py38h06a4308_3", + "entrypoints 0.4 py38h06a4308_0", + "et_xmlfile 1.1.0 py38h06a4308_0", + "expat 2.4.9 h6a678d5_0", + "filelock 3.6.0 pyhd3eb1b0_0", + "flake8 4.0.1 pyhd3eb1b0_1", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.11.0 h70c0345_0", + "fsspec 2022.7.1 py38h06a4308_0", + "future 0.18.2 py38_1", + "gensim 4.1.2 py38h295c915_0", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h4ff587b_1", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h295c915_3", + "gmpy2 2.1.2 py38heeb90bb_0", + "greenlet 1.1.1 py38h295c915_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 2.10.0 py38h7918eee_0", + "hdf5 1.10.4 hb1b8bf9_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "holoviews 1.15.0 py38h06a4308_0", + "hvplot 0.8.0 py38h06a4308_0", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.3 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py38hf0132c2_1", + "imageio 2.19.3 py38h06a4308_0", + "imagesize 1.4.1 py38h06a4308_0", + "importlib-metadata 4.11.3 py38h06a4308_0", + "importlib_metadata 4.11.3 hd3eb1b0_0", + "importlib_resources 5.2.0 pyhd3eb1b0_1", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py38h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intake 0.6.5 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.15.2 py38h06a4308_0", + "ipython 7.31.1 py38h06a4308_1", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.1 py38h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jellyfish 0.9.0 py38h7f8727e_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9e h7f8727e_0", + "jq 1.6 h27cfd23_1000", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 4.16.0 py38h06a4308_0", + "jupyter 1.0.0 py38h06a4308_8", + "jupyter_client 7.3.4 py38h06a4308_0", + "jupyter_console 6.4.3 pyhd3eb1b0_0", + "jupyter_core 4.11.1 py38h06a4308_0", + "jupyter_server 1.18.1 py38h06a4308_0", + "jupyterlab 3.4.4 py38h06a4308_0", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.10.3 pyhd3eb1b0_1", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.4.0 py38h06a4308_0", + "kiwisolver 1.4.2 py38h295c915_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py38h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.38 h1181459_1", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.6.1 hab531cd_0", + "libbrotlicommon 1.0.9 h5eee18b_7", + "libbrotlidec 1.0.9 h5eee18b_7", + "libbrotlienc 1.0.9 h5eee18b_7", + "libclang 10.0.1 default_hb85057a_2", + "libcurl 7.84.0 h91b91d3_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libevent 2.1.12 h8f2d780_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 11.2.0 h1234567_1", + "libgfortran-ng 7.5.0 ha8ba4b0_17", + "libgfortran4 7.5.0 ha8ba4b0_17", + "libgomp 11.2.0 h1234567_1", + "libidn2 2.3.2 h7f8727e_0", + "liblief 0.11.5 h295c915_1", + "libllvm10 10.0.1 hbcb73fb_5", + "libllvm11 11.1.0 h9e868ea_5", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.37 hbc83047_0", + "libpq 12.9 h16c4e8d_3", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.10.0 h8f2d780_0", + "libstdcxx-ng 11.2.0 h1234567_1", + "libtiff 4.4.0 hecacb30_0", + "libunistring 0.9.10 h27cfd23_0", + "libuuid 1.0.3 h7f8727e_2", + "libwebp 1.2.2 h55f646e_0", + "libwebp-base 1.2.2 h7f8727e_0", + "libxcb 1.15 h7f8727e_0", + "libxkbcommon 1.0.1 hfa300c1_0", + "libxml2 2.9.14 h74e7548_0", + "libxslt 1.1.35 h4e12654_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.38.0 py38h4ff587b_0", + "locket 1.0.0 py38h06a4308_0", + "lxml 4.9.1 py38h1edc446_0", + "lz4 3.1.3 py38h27cfd23_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markdown 3.3.4 py38h06a4308_0", + "markupsafe 2.0.1 py38h27cfd23_0", + "matplotlib 3.5.2 py38h06a4308_0", + "matplotlib-base 3.5.2 py38hf590b9c_0", + "matplotlib-inline 0.1.6 py38h06a4308_0", + "mccabe 0.7.0 pyhd3eb1b0_0", + "mistune 0.8.4 py38h7b6447c_1000", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py38h7f8727e_0", + "mkl_fft 1.3.1 py38hd3c417c_0", + "mkl_random 1.2.2 py38h51133e4_0", + "mock 4.0.3 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 hc856adb_0", + "mpmath 1.2.1 py38h06a4308_0", + "msgpack-python 1.0.3 py38hd09550d_0", + "multipledispatch 0.6.0 py38_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py38h06a4308_1", + "nbclassic 0.3.5 pyhd3eb1b0_0", + "nbclient 0.5.13 py38h06a4308_0", + "nbconvert 6.4.4 py38h06a4308_0", + "nbformat 5.5.0 py38h06a4308_0", + "ncurses 6.3 h5eee18b_3", + "nest-asyncio 1.5.5 py38h06a4308_0", + "networkx 2.8.4 py38h06a4308_0", + "nltk 3.7 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1008", + "notebook 6.4.12 py38h06a4308_0", + "nspr 4.33 h295c915_0", + "nss 3.74 h0370c37_0", + "numba 0.55.1 py38h51133e4_0", + "numexpr 2.8.3 py38h807cd23_0", + "numpy 1.21.5 py38h6c91a56_3", + "numpy-base 1.21.5 py38ha15fc14_3", + "numpydoc 1.4.0 py38h06a4308_0", + "olefile 0.46 pyhd3eb1b0_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.10 py38h5eee18b_0", + "openssl 1.1.1q h7f8727e_0", + "packaging 21.3 pyhd3eb1b0_0", + "pandas 1.4.4 py38h6a678d5_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "panel 0.13.1 py38h06a4308_0", + "param 1.12.0 pyhd3eb1b0_0", + "parsel 1.6.0 py38h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_1", + "patch 2.7.6 h7b6447c_1001", + "patchelf 0.13 h295c915_0", + "pathspec 0.9.0 py38h06a4308_0", + "patsy 0.5.2 py38h06a4308_1", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py38h06a4308_1", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.2.0 py38hace64e9_1", + "pip 22.2.2 py38h06a4308_0", + "pkginfo 1.8.2 pyhd3eb1b0_0", + "pkgutil-resolve-name 1.3.10 py38h06a4308_0", + "platformdirs 2.5.2 py38h06a4308_0", + "plotly 5.9.0 py38h06a4308_0", + "pluggy 1.0.0 py38h06a4308_1", + "ply 3.11 py38_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.14.1 py38h06a4308_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "protego 0.1.16 py_0", + "psutil 5.9.0 py38h5eee18b_0", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.11.0 pyhd3eb1b0_0", + "py-lief 0.11.5 py38h295c915_1", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pyasn1-modules 0.2.8 py_0", + "pycodestyle 2.8.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py38h7b6447c_1", + "pycparser 2.21 pyhd3eb1b0_0", + "pyct 0.4.8 py38h06a4308_1", + "pycurl 7.45.1 py38h8f2d780_0", + "pydispatcher 2.0.5 py38h06a4308_2", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py38h27cfd23_0", + "pyflakes 2.4.0 pyhd3eb1b0_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pylint 2.14.5 py38h06a4308_0", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.34 py38h6a678d5_0", + "pyopenssl 22.0.0 pyhd3eb1b0_0", + "pyparsing 3.0.9 py38h06a4308_0", + "pyqt 5.15.7 py38h6a678d5_1", + "pyqt5-sip 12.11.0 py38h6a678d5_1", + "pyqtwebengine 5.15.7 py38h6a678d5_1", + "pyrsistent 0.18.0 py38heee7806_0", + "pysocks 1.7.1 py38h06a4308_0", + "pytables 3.6.1 py38h9fd0a39_0", + "pytest 7.1.2 py38h06a4308_0", + "python 3.8.13 h12debd9_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-fastjsonschema 2.16.2 py38h06a4308_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.2.1 py38h06a4308_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.5.0 py38h06a4308_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "python-snappy 0.6.0 py38h2531618_3", + "pytz 2022.1 py38h06a4308_0", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "pywavelets 1.3.0 py38h7f8727e_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py38h7f8727e_1", + "pyzmq 23.2.0 py38h6a678d5_0", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.15.9 h06a4308_0", + "qt-main 5.15.2 h327a75a_7", + "qt-webengine 5.15.9 hd2b0992_4", + "qtawesome 1.0.3 pyhd3eb1b0_0", + "qtconsole 5.3.2 py38h06a4308_0", + "qtpy 2.2.0 py38h06a4308_0", + "qtwebkit 5.212 h4eab89a_4", + "queuelib 1.5.0 py38h06a4308_0", + "readline 8.1.2 h7f8727e_1", + "regex 2022.7.9 py38h5eee18b_0", + "requests 2.28.1 py38h06a4308_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "ripgrep 13.0.0 hbdeaff8_0", + "rope 0.22.0 pyhd3eb1b0_0", + "rtree 0.9.7 py38h06a4308_1", + "ruamel_yaml 0.15.100 py38h27cfd23_0", + "s3transfer 0.6.0 py38h06a4308_0", + "scikit-image 0.19.2 py38h51133e4_0", + "scikit-learn 1.0.2 py38h51133e4_1", + "scikit-learn-intelex 2021.6.0 py38h06a4308_0", + "scipy 1.7.3 py38hc147768_0", + "scrapy 2.6.2 py38h06a4308_0", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py38h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "service_identity 18.1.0 pyhd3eb1b0_1", + "setuptools 63.4.1 py38h06a4308_0", + "sip 6.6.2 py38h6a678d5_0", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.2.1 py38h06a4308_0", + "snappy 1.1.9 h295c915_0", + "sniffio 1.2.0 py38h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.1 pyhd3eb1b0_0", + "sphinx 5.0.2 py38h06a4308_0", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "spyder 5.3.3 py38h06a4308_0", + "spyder-kernels 2.3.3 py38h06a4308_0", + "sqlalchemy 1.4.39 py38h5eee18b_0", + "sqlite 3.39.3 h5082296_0", + "statsmodels 0.13.2 py38h7f8727e_0", + "sympy 1.10.1 py38h06a4308_0", + "tabulate 0.8.10 py38h06a4308_0", + "tbb 2021.6.0 hdb19cb5_0", + "tbb4py 2021.6.0 py38hdb19cb5_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py38h06a4308_1", + "terminado 0.13.1 py38h06a4308_0", + "testpath 0.6.0 py38h06a4308_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.12 h1ccaba5_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 2.0.1 py38h06a4308_0", + "tomlkit 0.11.1 py38h06a4308_0", + "toolz 0.11.2 pyhd3eb1b0_0", + "tornado 6.1 py38h27cfd23_0", + "tqdm 4.64.1 py38h06a4308_0", + "traitlets 5.1.1 pyhd3eb1b0_0", + "twisted 22.2.0 py38h5eee18b_1", + "typing-extensions 4.3.0 py38h06a4308_0", + "typing_extensions 4.3.0 py38h06a4308_0", + "ujson 5.4.0 py38h6a678d5_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.11 h5eee18b_0", + "urllib3 1.26.11 py38h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py38h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py38_1", + "websocket-client 0.58.0 py38h06a4308_4", + "werkzeug 2.0.3 pyhd3eb1b0_0", + "wget 1.21.3 h0b77cf5_0", + "whatthepatch 1.0.2 py38h06a4308_0", + "wheel 0.37.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.2 py38h06a4308_0", + "wrapt 1.14.1 py38h5eee18b_0", + "wurlitzer 3.0.2 py38h06a4308_0", + "xarray 0.20.1 pyhd3eb1b0_1", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.3 pyhd3eb1b0_0", + "xz 5.2.6 h5eee18b_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h295c915_6", + "zict 2.1.0 py38h06a4308_0", + "zipp 3.8.0 py38h06a4308_0", + "zlib 1.2.12 h5eee18b_3", + "zope 1.0 py38_1", + "zope.interface 5.4.0 py38h7f8727e_0", + "zstd 1.5.2 ha4553b6_0" + ], + "license": "BSD", + "md5": "52a38eeb1a0dfc7349de0babf373553a", + "name": "anaconda", + "namespace": "python", + "sha256": "74f2a02c0568ad219568a02e400a33bb8bdf237db6cb92ef1a5665fc46f0b624", + "size": 19356, + "subdir": "linux-64", + "timestamp": 1665077601773, + "version": "2022.10" + }, + "anaconda-2022.10-py39_0.conda": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 5.1 1_gnu", + "alabaster 0.7.12 pyhd3eb1b0_0", + "anaconda-client 1.11.0 py39h06a4308_0", + "anaconda-project 0.11.1 py39h06a4308_0", + "anyio 3.5.0 py39h06a4308_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "argon2-cffi-bindings 21.2.0 py39h7f8727e_0", + "arrow 1.2.2 pyhd3eb1b0_0", + "astroid 2.11.7 py39h06a4308_0", + "astropy 5.1 py39h7deecbd_0", + "atomicwrites 1.4.0 py_0", + "attrs 21.4.0 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_1", + "babel 2.9.1 pyhd3eb1b0_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "backports 1.1 pyhd3eb1b0_0", + "backports.functools_lru_cache 1.6.4 pyhd3eb1b0_0", + "backports.tempfile 1.0 pyhd3eb1b0_1", + "backports.weakref 1.0.post1 py_1", + "bcrypt 3.2.0 py39h5eee18b_1", + "beautifulsoup4 4.11.1 py39h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bitarray 2.5.1 py39h5eee18b_0", + "bkcharts 0.2 py39h06a4308_1", + "black 22.6.0 py39h06a4308_0", + "blas 1.0 mkl", + "bleach 4.1.0 pyhd3eb1b0_0", + "blosc 1.21.0 h4ff587b_1", + "bokeh 2.4.3 py39h06a4308_0", + "boto3 1.24.28 py39h06a4308_0", + "botocore 1.27.28 py39h06a4308_0", + "bottleneck 1.3.5 py39h7deecbd_0", + "brotli 1.0.9 h5eee18b_7", + "brotli-bin 1.0.9 h5eee18b_7", + "brotlipy 0.7.0 py39h27cfd23_1003", + "brunsli 0.1 h2531618_0", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "ca-certificates 2022.07.19 h06a4308_0", + "certifi 2022.9.14 py39h06a4308_0", + "cffi 1.15.1 py39h74dc2b5_0", + "cfitsio 3.470 h5893167_7", + "chardet 4.0.0 py39h06a4308_1003", + "charls 2.2.0 h2531618_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py39h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "clyent 1.2.2 py39h06a4308_1", + "colorama 0.4.5 py39h06a4308_0", + "colorcet 3.0.0 py39h06a4308_0", + "conda-content-trust 0.1.3 py39h06a4308_0", + "conda-token 0.4.0 pyhd3eb1b0_0", + "constantly 15.1.0 pyh2b92418_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "cryptography 37.0.1 py39h9ce1e76_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.84.0 h5eee18b_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "cython 0.29.32 py39h6a678d5_0", + "cytoolz 0.11.0 py39h27cfd23_0", + "daal4py 2021.6.0 py39h79cecc1_1", + "dal 2021.6.0 hdb19cb5_916", + "dask 2022.7.0 py39h06a4308_0", + "dask-core 2022.7.0 py39h06a4308_0", + "dataclasses 0.8 pyh6d0b6a4_7", + "datashader 0.14.1 py39h06a4308_0", + "datashape 0.5.4 py39h06a4308_1", + "dbus 1.13.18 hb2f20db_0", + "debugpy 1.5.1 py39h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "dill 0.3.4 pyhd3eb1b0_0", + "distributed 2022.7.0 py39h06a4308_0", + "docutils 0.18.1 py39h06a4308_3", + "entrypoints 0.4 py39h06a4308_0", + "et_xmlfile 1.1.0 py39h06a4308_0", + "expat 2.4.9 h6a678d5_0", + "fftw 3.3.9 h27cfd23_1", + "filelock 3.6.0 pyhd3eb1b0_0", + "flake8 4.0.1 pyhd3eb1b0_1", + "flask 1.1.2 pyhd3eb1b0_0", + "fontconfig 2.13.1 h6c09931_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "freetype 2.11.0 h70c0345_0", + "fsspec 2022.7.1 py39h06a4308_0", + "future 0.18.2 py39h06a4308_1", + "gensim 4.1.2 py39h295c915_0", + "giflib 5.2.1 h7b6447c_0", + "glib 2.69.1 h4ff587b_1", + "glob2 0.7 pyhd3eb1b0_0", + "gmp 6.2.1 h295c915_3", + "gmpy2 2.1.2 py39heeb90bb_0", + "greenlet 1.1.1 py39h295c915_0", + "gst-plugins-base 1.14.0 h8213a91_2", + "gstreamer 1.14.0 h28cd5cc_2", + "h5py 3.7.0 py39h737f45e_0", + "hdf5 1.10.6 h3ffc7dd_1", + "heapdict 1.0.1 pyhd3eb1b0_0", + "holoviews 1.15.0 py39h06a4308_0", + "hvplot 0.8.0 py39h06a4308_0", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "icu 58.2 he6710b0_3", + "idna 3.3 pyhd3eb1b0_0", + "imagecodecs 2021.8.26 py39hf0132c2_1", + "imageio 2.19.3 py39h06a4308_0", + "imagesize 1.4.1 py39h06a4308_0", + "importlib-metadata 4.11.3 py39h06a4308_0", + "importlib_metadata 4.11.3 hd3eb1b0_0", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py39h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "intake 0.6.5 pyhd3eb1b0_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "ipykernel 6.15.2 py39h06a4308_0", + "ipython 7.31.1 py39h06a4308_1", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jdcal 1.4.1 pyhd3eb1b0_0", + "jedi 0.18.1 py39h06a4308_1", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jellyfish 0.9.0 py39h7f8727e_0", + "jinja2 2.11.3 pyhd3eb1b0_0", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.0 pyhd3eb1b0_0", + "jpeg 9e h7f8727e_0", + "jq 1.6 h27cfd23_1000", + "json5 0.9.6 pyhd3eb1b0_0", + "jsonschema 4.16.0 py39h06a4308_0", + "jupyter 1.0.0 py39h06a4308_8", + "jupyter_client 7.3.4 py39h06a4308_0", + "jupyter_console 6.4.3 pyhd3eb1b0_0", + "jupyter_core 4.11.1 py39h06a4308_0", + "jupyter_server 1.18.1 py39h06a4308_0", + "jupyterlab 3.4.4 py39h06a4308_0", + "jupyterlab_pygments 0.1.2 py_0", + "jupyterlab_server 2.10.3 pyhd3eb1b0_1", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "jxrlib 1.1 h7b6447c_2", + "keyring 23.4.0 py39h06a4308_0", + "kiwisolver 1.4.2 py39h295c915_0", + "krb5 1.19.2 hac12032_0", + "lazy-object-proxy 1.6.0 py39h27cfd23_0", + "lcms2 2.12 h3be6417_0", + "ld_impl_linux-64 2.38 h1181459_1", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libarchive 3.6.1 hab531cd_0", + "libbrotlicommon 1.0.9 h5eee18b_7", + "libbrotlidec 1.0.9 h5eee18b_7", + "libbrotlienc 1.0.9 h5eee18b_7", + "libclang 10.0.1 default_hb85057a_2", + "libcurl 7.84.0 h91b91d3_0", + "libdeflate 1.8 h7f8727e_5", + "libedit 3.1.20210910 h7f8727e_0", + "libev 4.33 h7f8727e_1", + "libevent 2.1.12 h8f2d780_0", + "libffi 3.3 he6710b0_2", + "libgcc-ng 11.2.0 h1234567_1", + "libgfortran-ng 11.2.0 h00389a5_1", + "libgfortran5 11.2.0 h1234567_1", + "libgomp 11.2.0 h1234567_1", + "libidn2 2.3.2 h7f8727e_0", + "liblief 0.11.5 h295c915_1", + "libllvm10 10.0.1 hbcb73fb_5", + "libllvm11 11.1.0 h9e868ea_5", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.37 hbc83047_0", + "libpq 12.9 h16c4e8d_3", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libssh2 1.10.0 h8f2d780_0", + "libstdcxx-ng 11.2.0 h1234567_1", + "libtiff 4.4.0 hecacb30_0", + "libunistring 0.9.10 h27cfd23_0", + "libuuid 1.0.3 h7f8727e_2", + "libwebp 1.2.2 h55f646e_0", + "libwebp-base 1.2.2 h7f8727e_0", + "libxcb 1.15 h7f8727e_0", + "libxkbcommon 1.0.1 hfa300c1_0", + "libxml2 2.9.14 h74e7548_0", + "libxslt 1.1.35 h4e12654_0", + "libzopfli 1.0.3 he6710b0_0", + "llvmlite 0.38.0 py39h4ff587b_0", + "locket 1.0.0 py39h06a4308_0", + "lxml 4.9.1 py39h1edc446_0", + "lz4 3.1.3 py39h27cfd23_0", + "lz4-c 1.9.3 h295c915_1", + "lzo 2.10 h7b6447c_2", + "markdown 3.3.4 py39h06a4308_0", + "markupsafe 2.0.1 py39h27cfd23_0", + "matplotlib 3.5.2 py39h06a4308_0", + "matplotlib-base 3.5.2 py39hf590b9c_0", + "matplotlib-inline 0.1.6 py39h06a4308_0", + "mccabe 0.7.0 pyhd3eb1b0_0", + "mistune 0.8.4 py39h27cfd23_1000", + "mkl 2021.4.0 h06a4308_640", + "mkl-service 2.4.0 py39h7f8727e_0", + "mkl_fft 1.3.1 py39hd3c417c_0", + "mkl_random 1.2.2 py39h51133e4_0", + "mock 4.0.3 pyhd3eb1b0_0", + "mpc 1.1.0 h10f8cd9_1", + "mpfr 4.0.2 hb69a4c5_1", + "mpi 1.0 mpich", + "mpich 3.3.2 external_0", + "mpmath 1.2.1 py39h06a4308_0", + "msgpack-python 1.0.3 py39hd09550d_0", + "multipledispatch 0.6.0 py39h06a4308_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py39h06a4308_1", + "nbclassic 0.3.5 pyhd3eb1b0_0", + "nbclient 0.5.13 py39h06a4308_0", + "nbconvert 6.4.4 py39h06a4308_0", + "nbformat 5.5.0 py39h06a4308_0", + "ncurses 6.3 h5eee18b_3", + "nest-asyncio 1.5.5 py39h06a4308_0", + "networkx 2.8.4 py39h06a4308_0", + "nltk 3.7 pyhd3eb1b0_0", + "nose 1.3.7 pyhd3eb1b0_1008", + "notebook 6.4.12 py39h06a4308_0", + "nspr 4.33 h295c915_0", + "nss 3.74 h0370c37_0", + "numba 0.55.1 py39h51133e4_0", + "numexpr 2.8.3 py39h807cd23_0", + "numpy 1.21.5 py39h6c91a56_3", + "numpy-base 1.21.5 py39ha15fc14_3", + "numpydoc 1.4.0 py39h06a4308_0", + "olefile 0.46 pyhd3eb1b0_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openjpeg 2.4.0 h3ad879b_0", + "openpyxl 3.0.10 py39h5eee18b_0", + "openssl 1.1.1q h7f8727e_0", + "packaging 21.3 pyhd3eb1b0_0", + "pandas 1.4.4 py39h6a678d5_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "panel 0.13.1 py39h06a4308_0", + "param 1.12.0 pyhd3eb1b0_0", + "parsel 1.6.0 py39h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "partd 1.2.0 pyhd3eb1b0_1", + "patch 2.7.6 h7b6447c_1001", + "patchelf 0.13 h295c915_0", + "pathspec 0.9.0 py39h06a4308_0", + "patsy 0.5.2 py39h06a4308_1", + "pcre 8.45 h295c915_0", + "pep8 1.7.1 py39h06a4308_1", + "pexpect 4.8.0 pyhd3eb1b0_3", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.2.0 py39hace64e9_1", + "pip 22.2.2 py39h06a4308_0", + "pkginfo 1.8.2 pyhd3eb1b0_0", + "platformdirs 2.5.2 py39h06a4308_0", + "plotly 5.9.0 py39h06a4308_0", + "pluggy 1.0.0 py39h06a4308_1", + "ply 3.11 py39h06a4308_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.14.1 py39h06a4308_0", + "prompt-toolkit 3.0.20 pyhd3eb1b0_0", + "prompt_toolkit 3.0.20 hd3eb1b0_0", + "protego 0.1.16 py_0", + "psutil 5.9.0 py39h5eee18b_0", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "py 1.11.0 pyhd3eb1b0_0", + "py-lief 0.11.5 py39h295c915_1", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pyasn1-modules 0.2.8 py_0", + "pycodestyle 2.8.0 pyhd3eb1b0_0", + "pycosat 0.6.3 py39h27cfd23_0", + "pycparser 2.21 pyhd3eb1b0_0", + "pyct 0.4.8 py39h06a4308_1", + "pycurl 7.45.1 py39h8f2d780_0", + "pydispatcher 2.0.5 py39h06a4308_2", + "pydocstyle 6.1.1 pyhd3eb1b0_0", + "pyerfa 2.0.0 py39h27cfd23_0", + "pyflakes 2.4.0 pyhd3eb1b0_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pylint 2.14.5 py39h06a4308_0", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "pyodbc 4.0.34 py39h6a678d5_0", + "pyopenssl 22.0.0 pyhd3eb1b0_0", + "pyparsing 3.0.9 py39h06a4308_0", + "pyqt 5.15.7 py39h6a678d5_1", + "pyqt5-sip 12.11.0 py39h6a678d5_1", + "pyqtwebengine 5.15.7 py39h6a678d5_1", + "pyrsistent 0.18.0 py39heee7806_0", + "pysocks 1.7.1 py39h06a4308_0", + "pytables 3.6.1 py39h77479fe_1", + "pytest 7.1.2 py39h06a4308_0", + "python 3.9.13 haa1d7c7_1", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-fastjsonschema 2.16.2 py39h06a4308_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "python-lsp-black 1.2.1 py39h06a4308_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-lsp-server 1.5.0 py39h06a4308_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "python-snappy 0.6.0 py39h2531618_3", + "pytz 2022.1 py39h06a4308_0", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "pywavelets 1.3.0 py39h7f8727e_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py39h7f8727e_1", + "pyzmq 23.2.0 py39h6a678d5_0", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qstylizer 0.1.10 pyhd3eb1b0_0", + "qt 5.15.9 h06a4308_0", + "qt-main 5.15.2 h327a75a_7", + "qt-webengine 5.15.9 hd2b0992_4", + "qtawesome 1.0.3 pyhd3eb1b0_0", + "qtconsole 5.3.2 py39h06a4308_0", + "qtpy 2.2.0 py39h06a4308_0", + "qtwebkit 5.212 h4eab89a_4", + "queuelib 1.5.0 py39h06a4308_0", + "readline 8.1.2 h7f8727e_1", + "regex 2022.7.9 py39h5eee18b_0", + "requests 2.28.1 py39h06a4308_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "ripgrep 13.0.0 hbdeaff8_0", + "rope 0.22.0 pyhd3eb1b0_0", + "rtree 0.9.7 py39h06a4308_1", + "ruamel_yaml 0.15.100 py39h27cfd23_0", + "s3transfer 0.6.0 py39h06a4308_0", + "scikit-image 0.19.2 py39h51133e4_0", + "scikit-learn 1.0.2 py39h51133e4_1", + "scikit-learn-intelex 2021.6.0 py39h06a4308_0", + "scipy 1.9.1 py39h14f4228_0", + "scrapy 2.6.2 py39h06a4308_0", + "seaborn 0.11.2 pyhd3eb1b0_0", + "secretstorage 3.3.1 py39h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "service_identity 18.1.0 pyhd3eb1b0_1", + "setuptools 63.4.1 py39h06a4308_0", + "sip 6.6.2 py39h6a678d5_0", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.2.1 py39h06a4308_0", + "snappy 1.1.9 h295c915_0", + "sniffio 1.2.0 py39h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcollections 2.1.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.1 pyhd3eb1b0_0", + "sphinx 5.0.2 py39h06a4308_0", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "spyder 5.3.3 py39h06a4308_0", + "spyder-kernels 2.3.3 py39h06a4308_0", + "sqlalchemy 1.4.39 py39h5eee18b_0", + "sqlite 3.39.3 h5082296_0", + "statsmodels 0.13.2 py39h7f8727e_0", + "sympy 1.10.1 py39h06a4308_0", + "tabulate 0.8.10 py39h06a4308_0", + "tbb 2021.6.0 hdb19cb5_0", + "tbb4py 2021.6.0 py39hdb19cb5_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py39h06a4308_1", + "terminado 0.13.1 py39h06a4308_0", + "testpath 0.6.0 py39h06a4308_0", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "tinycss 0.4 pyhd3eb1b0_1002", + "tk 8.6.12 h1ccaba5_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 2.0.1 py39h06a4308_0", + "tomlkit 0.11.1 py39h06a4308_0", + "toolz 0.11.2 pyhd3eb1b0_0", + "tornado 6.1 py39h27cfd23_0", + "tqdm 4.64.1 py39h06a4308_0", + "traitlets 5.1.1 pyhd3eb1b0_0", + "twisted 22.2.0 py39h5eee18b_1", + "typing-extensions 4.3.0 py39h06a4308_0", + "typing_extensions 4.3.0 py39h06a4308_0", + "tzdata 2022c h04d1e81_0", + "ujson 5.4.0 py39h6a678d5_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "unixodbc 2.3.11 h5eee18b_0", + "urllib3 1.26.11 py39h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py39h06a4308_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py39h06a4308_1", + "websocket-client 0.58.0 py39h06a4308_4", + "werkzeug 2.0.3 pyhd3eb1b0_0", + "wget 1.21.3 h0b77cf5_0", + "whatthepatch 1.0.2 py39h06a4308_0", + "wheel 0.37.1 pyhd3eb1b0_0", + "widgetsnbextension 3.5.2 py39h06a4308_0", + "wrapt 1.14.1 py39h5eee18b_0", + "wurlitzer 3.0.2 py39h06a4308_0", + "xarray 0.20.1 pyhd3eb1b0_1", + "xlrd 2.0.1 pyhd3eb1b0_0", + "xlsxwriter 3.0.3 pyhd3eb1b0_0", + "xz 5.2.6 h5eee18b_0", + "yaml 0.2.5 h7b6447c_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zeromq 4.3.4 h2531618_0", + "zfp 0.5.5 h295c915_6", + "zict 2.1.0 py39h06a4308_0", + "zipp 3.8.0 py39h06a4308_0", + "zlib 1.2.12 h5eee18b_3", + "zope 1.0 py39h06a4308_1", + "zope.interface 5.4.0 py39h7f8727e_0", + "zstd 1.5.2 ha4553b6_0" + ], + "license": "BSD", + "md5": "dc499e9f42520069f903f76add644b9c", + "name": "anaconda", + "namespace": "python", + "sha256": "f3fa44495b4a5186c6ecae97e71aec1d5f07d007a9b78ef6c050649f69f45331", + "size": 19288, + "subdir": "linux-64", + "timestamp": 1665057949251, + "version": "2022.10" + }, + "anaconda-2023.03-py310_0.conda": { + "build": "py310_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "blas 1.0 mkl", + "ca-certificates 2023.01.10 h06a4308_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "ld_impl_linux-64 2.38 h1181459_1", + "libgfortran5 11.2.0 h1234567_1", + "libstdcxx-ng 11.2.0 h1234567_1", + "mpi 1.0 mpich", + "tzdata 2022g h04d1e81_0", + "libgfortran-ng 11.2.0 h00389a5_1", + "libgomp 11.2.0 h1234567_1", + "mkl 2021.4.0 h06a4308_640", + "mpich 3.3.2 external_0", + "_openmp_mutex 5.1 1_gnu", + "libgcc-ng 11.2.0 h1234567_1", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "charls 2.2.0 h2531618_0", + "expat 2.4.9 h6a678d5_0", + "giflib 5.2.1 h5eee18b_3", + "gmp 6.2.1 h295c915_3", + "icu 58.2 he6710b0_3", + "jpeg 9e h5eee18b_1", + "jxrlib 1.1 h7b6447c_2", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libbrotlicommon 1.0.9 h5eee18b_7", + "libdeflate 1.17 h5eee18b_0", + "libev 4.33 h7f8727e_1", + "libffi 3.4.2 h6a678d5_6", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libuuid 1.41.5 h5eee18b_0", + "libwebp-base 1.2.4 h5eee18b_1", + "libxcb 1.15 h7f8727e_0", + "libzopfli 1.0.3 he6710b0_0", + "lz4-c 1.9.4 h6a678d5_0", + "lzo 2.10 h7b6447c_2", + "ncurses 6.4 h6a678d5_0", + "ninja-base 1.10.2 hd09550d_5", + "nspr 4.33 h295c915_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openssl 1.1.1t h7f8727e_0", + "pcre 8.45 h295c915_0", + "snappy 1.1.9 h295c915_0", + "tbb 2021.7.0 hdb19cb5_0", + "xz 5.2.10 h5eee18b_1", + "yaml 0.2.5 h7b6447c_0", + "zfp 0.5.5 h295c915_6", + "zlib 1.2.13 h5eee18b_0", + "dal 2023.0.1 hdb19cb5_26647", + "glib 2.69.1 he621ea3_2", + "hdf5 1.10.6 h3ffc7dd_1", + "jq 1.6 h27cfd23_1000", + "libbrotlidec 1.0.9 h5eee18b_7", + "libbrotlienc 1.0.9 h5eee18b_7", + "libedit 3.1.20221030 h5eee18b_0", + "libevent 2.1.12 h8f2d780_0", + "libllvm10 10.0.1 hbcb73fb_5", + "libllvm11 11.1.0 h9e868ea_6", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.39 h5eee18b_0", + "libprotobuf 3.20.3 he621ea3_0", + "libssh2 1.10.0 h8f2d780_0", + "libxml2 2.9.14 h74e7548_0", + "mpfr 4.0.2 hb69a4c5_1", + "readline 8.2 h5eee18b_0", + "tk 8.6.12 h1ccaba5_0", + "zeromq 4.3.4 h2531618_0", + "zstd 1.5.2 ha4553b6_0", + "blosc 1.21.3 h6a678d5_0", + "brotli-bin 1.0.9 h5eee18b_7", + "dbus 1.13.18 hb2f20db_0", + "freetype 2.12.1 h4a9f257_0", + "gstreamer 1.14.1 h5eee18b_1", + "krb5 1.19.4 h568e23c_0", + "libclang 10.0.1 default_hb85057a_2", + "libtiff 4.5.0 h6a678d5_2", + "libxkbcommon 1.0.1 hfa300c1_0", + "libxslt 1.1.35 h4e12654_0", + "mpc 1.1.0 h10f8cd9_1", + "sqlite 3.40.1 h5082296_0", + "unixodbc 2.3.11 h5eee18b_0", + "brotli 1.0.9 h5eee18b_7", + "fontconfig 2.14.1 h52c9d5c_1", + "gst-plugins-base 1.14.1 h6a678d5_1", + "lcms2 2.12 h3be6417_0", + "libcurl 7.87.0 h91b91d3_0", + "libpq 12.9 h16c4e8d_3", + "libwebp 1.2.4 h11a3e52_1", + "nss 3.74 h0370c37_0", + "openjpeg 2.4.0 h3ad879b_0", + "python 3.10.9 h7a1cb2a_1", + "alabaster 0.7.12 pyhd3eb1b0_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 22.1.0 py310h06a4308_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "brunsli 0.1 h2531618_0", + "certifi 2022.12.7 py310h06a4308_0", + "cfitsio 3.470 h5893167_7", + "chardet 4.0.0 py310h06a4308_1003", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py310h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "colorama 0.4.6 py310h06a4308_0", + "constantly 15.1.0 py310h06a4308_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.87.0 h5eee18b_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "debugpy 1.5.1 py310h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "dill 0.3.6 py310h06a4308_0", + "docstring-to-markdown 0.11 py310h06a4308_0", + "docutils 0.18.1 py310h06a4308_3", + "entrypoints 0.4 py310h06a4308_0", + "et_xmlfile 1.1.0 py310h06a4308_0", + "executing 0.8.3 pyhd3eb1b0_0", + "filelock 3.9.0 py310h06a4308_0", + "flit-core 3.6.0 pyhd3eb1b0_0", + "fsspec 2022.11.0 py310h06a4308_0", + "future 0.18.3 py310h06a4308_0", + "gmpy2 2.1.2 py310heeb90bb_0", + "greenlet 2.0.1 py310h6a678d5_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "idna 3.4 py310h06a4308_0", + "imagesize 1.4.1 py310h06a4308_0", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py310h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jellyfish 0.9.0 py310h7f8727e_0", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.1 py310h06a4308_0", + "json5 0.9.6 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "kiwisolver 1.4.4 py310h6a678d5_0", + "lazy-object-proxy 1.6.0 py310h7f8727e_0", + "llvmlite 0.39.1 py310he621ea3_0", + "locket 1.0.0 py310h06a4308_0", + "lxml 4.9.1 py310h1edc446_0", + "lz4 3.1.3 py310h7f8727e_0", + "markdown 3.4.1 py310h06a4308_0", + "markupsafe 2.1.1 py310h7f8727e_0", + "mccabe 0.7.0 pyhd3eb1b0_0", + "mistune 0.8.4 py310h7f8727e_1000", + "mock 4.0.3 pyhd3eb1b0_0", + "mpmath 1.2.1 py310h06a4308_0", + "msgpack-python 1.0.3 py310hd09550d_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py310h06a4308_0", + "nest-asyncio 1.5.6 py310h06a4308_0", + "networkx 2.8.4 py310h06a4308_0", + "ninja 1.10.2 h06a4308_5", + "packaging 22.0 py310h06a4308_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "param 1.12.3 py310h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "pathspec 0.10.3 py310h06a4308_0", + "pep8 1.7.1 py310h06a4308_1", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.4.0 py310h6a678d5_0", + "platformdirs 2.5.2 py310h06a4308_0", + "pluggy 1.0.0 py310h06a4308_1", + "ply 3.11 py310h06a4308_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.14.1 py310h06a4308_0", + "psutil 5.9.0 py310h5eee18b_0", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "pure_eval 0.2.2 pyhd3eb1b0_0", + "py 1.11.0 pyhd3eb1b0_0", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pycodestyle 2.10.0 py310h06a4308_0", + "pycparser 2.21 pyhd3eb1b0_0", + "pycurl 7.45.1 py310h8f2d780_0", + "pydispatcher 2.0.5 py310h06a4308_2", + "pyflakes 3.0.1 py310h06a4308_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pylint-venv 2.3.0 py310h06a4308_0", + "pyodbc 4.0.34 py310h6a678d5_0", + "pyparsing 3.0.9 py310h06a4308_0", + "pyrsistent 0.18.0 py310h7f8727e_0", + "pysocks 1.7.1 py310h06a4308_0", + "python-fastjsonschema 2.16.2 py310h06a4308_0", + "python-snappy 0.6.1 py310h6a678d5_0", + "pytz 2022.7 py310h06a4308_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py310h5eee18b_1", + "pyzmq 23.2.0 py310h6a678d5_0", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qt-main 5.15.2 h327a75a_7", + "queuelib 1.5.0 py310h06a4308_0", + "regex 2022.7.9 py310h5eee18b_0", + "rtree 1.0.1 py310h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.2.1 py310h06a4308_0", + "sniffio 1.2.0 py310h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.2.post1 py310h06a4308_0", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "tabulate 0.8.10 py310h06a4308_0", + "tbb4py 2021.7.0 py310hdb19cb5_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py310h06a4308_1", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "tokenizers 0.11.4 py310h3dcd8bd_1", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 2.0.1 py310h06a4308_0", + "tomlkit 0.11.1 py310h06a4308_0", + "toolz 0.12.0 py310h06a4308_0", + "tornado 6.1 py310h7f8727e_0", + "tqdm 4.64.1 py310h06a4308_0", + "traitlets 5.7.1 py310h06a4308_0", + "ujson 5.4.0 py310h6a678d5_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py310h06a4308_1", + "whatthepatch 1.0.2 py310h06a4308_0", + "wheel 0.38.4 py310h06a4308_0", + "wrapt 1.14.1 py310h5eee18b_0", + "wurlitzer 3.0.2 py310h06a4308_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zipp 3.11.0 py310h06a4308_0", + "zope 1.0 py310h06a4308_1", + "anyio 3.5.0 py310h06a4308_0", + "asttokens 2.0.5 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_1", + "babel 2.11.0 py310h06a4308_0", + "beautifulsoup4 4.11.1 py310h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "black 22.6.0 py310h06a4308_0", + "bleach 4.1.0 pyhd3eb1b0_0", + "cffi 1.15.1 py310h5eee18b_3", + "comm 0.1.2 py310h06a4308_0", + "cytoolz 0.12.0 py310h5eee18b_0", + "flake8 6.0.0 py310h06a4308_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "importlib-metadata 4.11.3 py310h06a4308_0", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "jedi 0.18.1 py310h06a4308_1", + "jinja2 3.1.2 py310h06a4308_0", + "jsonschema 4.17.3 py310h06a4308_0", + "jupyter_core 5.2.0 py310h06a4308_0", + "jupyterlab_pygments 0.1.2 py_0", + "matplotlib-inline 0.1.6 py310h06a4308_0", + "mkl-service 2.4.0 py310h7f8727e_0", + "multipledispatch 0.6.0 py310h06a4308_0", + "nltk 3.7 pyhd3eb1b0_0", + "openpyxl 3.0.10 py310h5eee18b_0", + "partd 1.2.0 pyhd3eb1b0_1", + "pexpect 4.8.0 pyhd3eb1b0_3", + "plotly 5.9.0 py310h06a4308_0", + "prompt-toolkit 3.0.36 py310h06a4308_0", + "protego 0.1.16 py_0", + "pyasn1-modules 0.2.8 py_0", + "pydocstyle 6.3.0 py310h06a4308_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pytest 7.1.2 py310h06a4308_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "pytoolconfig 1.2.5 py310h06a4308_1", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "qt-webengine 5.15.9 hd2b0992_4", + "qtpy 2.2.0 py310h06a4308_0", + "setuptools 65.6.3 py310h06a4308_0", + "sip 6.6.2 py310h6a678d5_0", + "sqlalchemy 1.4.39 py310h5eee18b_0", + "sympy 1.11.1 py310h06a4308_0", + "terminado 0.17.1 py310h06a4308_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tinycss2 1.2.1 py310h06a4308_0", + "typing_extensions 4.4.0 py310h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py310h06a4308_0", + "websocket-client 0.58.0 py310h06a4308_4", + "werkzeug 2.2.2 py310h06a4308_0", + "zict 2.1.0 py310h06a4308_0", + "argon2-cffi-bindings 21.2.0 py310h7f8727e_0", + "arrow 1.2.3 py310h06a4308_1", + "brotlipy 0.7.0 py310h7f8727e_1002", + "cryptography 39.0.1 py310h9ce1e76_0", + "dask-core 2022.7.0 py310h06a4308_0", + "flask 2.2.2 py310h06a4308_0", + "importlib_metadata 4.11.3 hd3eb1b0_0", + "jupyter_client 7.3.4 py310h06a4308_0", + "nbformat 5.7.0 py310h06a4308_0", + "numpy-base 1.23.5 py310h8e6c178_0", + "parsel 1.6.0 py310h06a4308_0", + "pip 22.3.1 py310h06a4308_0", + "prompt_toolkit 3.0.36 hd3eb1b0_0", + "pyqt5-sip 12.11.0 py310h6a678d5_1", + "qstylizer 0.2.2 py310h06a4308_0", + "qtawesome 1.2.2 py310h06a4308_0", + "qtwebkit 5.212 h4eab89a_4", + "rope 1.7.0 py310h06a4308_0", + "stack_data 0.2.0 pyhd3eb1b0_0", + "typing-extensions 4.4.0 py310h06a4308_0", + "zope.interface 5.4.0 py310h7f8727e_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "astroid 2.14.2 py310h06a4308_0", + "bcrypt 3.2.0 py310h5eee18b_1", + "ipython 8.10.0 py310h06a4308_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "nbclient 0.5.13 py310h06a4308_0", + "pyopenssl 23.0.0 py310h06a4308_0", + "pyqt 5.15.7 py310h6a678d5_1", + "secretstorage 3.3.1 py310h06a4308_0", + "service_identity 18.1.0 pyhd3eb1b0_1", + "ipykernel 6.19.2 py310h2f386ee_0", + "keyring 23.4.0 py310h06a4308_0", + "nbconvert 6.5.4 py310h06a4308_0", + "pylint 2.16.2 py310h06a4308_0", + "pyqtwebengine 5.15.7 py310h6a678d5_1", + "twisted 22.2.0 py310h5eee18b_1", + "urllib3 1.26.14 py310h06a4308_0", + "distributed 2022.7.0 py310h06a4308_0", + "jupyter_console 6.6.2 py310h06a4308_0", + "jupyter_server 1.23.4 py310h06a4308_0", + "python-lsp-server 1.7.1 py310h06a4308_0", + "qtconsole 5.4.0 py310h06a4308_0", + "requests 2.28.1 py310h06a4308_0", + "spyder-kernels 2.4.1 py310h06a4308_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "huggingface_hub 0.10.1 py310h06a4308_0", + "jupyterlab_server 2.19.0 py310h06a4308_0", + "notebook-shim 0.2.2 py310h06a4308_0", + "pooch 1.4.0 pyhd3eb1b0_0", + "pyct 0.5.0 py310h06a4308_0", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "python-lsp-black 1.2.1 py310h06a4308_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "sphinx 5.0.2 py310h06a4308_0", + "colorcet 3.0.1 py310h06a4308_0", + "nbclassic 0.5.2 py310h06a4308_0", + "numpydoc 1.5.0 py310h06a4308_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "notebook 6.5.2 py310h06a4308_0", + "scrapy 2.8.0 py310h06a4308_0", + "spyder 5.4.1 py310h06a4308_0", + "jupyterlab 3.5.3 py310h06a4308_0", + "widgetsnbextension 3.5.2 py310h06a4308_0", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "jupyter 1.0.0 py310h06a4308_8", + "bokeh 2.4.3 py310h06a4308_0", + "panel 0.14.3 py310h06a4308_0", + "bottleneck 1.3.5 py310ha9d4c09_0", + "contourpy 1.0.5 py310hdb19cb5_0", + "daal4py 2023.0.2 py310h3c18c91_0", + "datashape 0.5.4 py310h06a4308_1", + "h5py 3.7.0 py310he06866b_0", + "imagecodecs 2021.8.26 py310h46e8fbd_2", + "imageio 2.26.0 py310h06a4308_0", + "intake 0.6.7 py310h06a4308_0", + "matplotlib 3.7.0 py310h06a4308_0", + "matplotlib-base 3.7.0 py310h1128e8f_0", + "mkl_fft 1.3.1 py310hd6ae3a3_0", + "mkl_random 1.2.2 py310h00e6091_0", + "numpy 1.23.5 py310hd5efca6_0", + "numba 0.56.4 py310h1128e8f_0", + "numexpr 2.8.4 py310h8879344_0", + "patsy 0.5.3 py310h06a4308_0", + "pyerfa 2.0.0 py310h7f8727e_0", + "pytorch 1.12.1 cpu_py310hb1f1ab4_1", + "pywavelets 1.4.1 py310h5eee18b_0", + "scipy 1.10.0 py310hd5efca6_1", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "astropy 5.1 py310ha9d4c09_0", + "gensim 4.3.0 py310h1128e8f_0", + "pandas 1.5.3 py310h1128e8f_0", + "pytables 3.7.0 py310hf19a122_1", + "scikit-image 0.19.3 py310h6a678d5_1", + "scikit-learn 1.2.1 py310h6a678d5_0", + "transformers 4.24.0 py310h06a4308_0", + "dask 2022.7.0 py310h06a4308_0", + "holoviews 1.15.4 py310h06a4308_0", + "imbalanced-learn 0.10.1 py310h06a4308_0", + "scikit-learn-intelex 2023.0.2 py310h06a4308_0", + "seaborn 0.12.2 py310h06a4308_0", + "statsmodels 0.13.5 py310ha9d4c09_1", + "xarray 2022.11.0 py310h06a4308_0", + "datashader 0.14.4 py310h06a4308_0", + "hvplot 0.8.2 py310h06a4308_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20259fb9833894d4822c9235000ac17b", + "name": "anaconda", + "namespace": "python", + "sha256": "739ddf968946936e8758e1092abb9de1817c70e416e2d967446ee6c6b37a103e", + "size": 75981, + "subdir": "linux-64", + "timestamp": 1678132269861, + "version": "2023.03" + }, + "anaconda-2023.03-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "blas 1.0 mkl", + "ca-certificates 2023.01.10 h06a4308_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "ld_impl_linux-64 2.38 h1181459_1", + "libgfortran5 11.2.0 h1234567_1", + "libstdcxx-ng 11.2.0 h1234567_1", + "mpi 1.0 mpich", + "libgfortran-ng 11.2.0 h00389a5_1", + "libgomp 11.2.0 h1234567_1", + "mkl 2021.4.0 h06a4308_640", + "mpich 3.3.2 external_0", + "_openmp_mutex 5.1 1_gnu", + "libgcc-ng 11.2.0 h1234567_1", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "charls 2.2.0 h2531618_0", + "expat 2.4.9 h6a678d5_0", + "giflib 5.2.1 h5eee18b_3", + "gmp 6.2.1 h295c915_3", + "icu 58.2 he6710b0_3", + "jpeg 9e h5eee18b_1", + "jxrlib 1.1 h7b6447c_2", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libbrotlicommon 1.0.9 h5eee18b_7", + "libdeflate 1.17 h5eee18b_0", + "libev 4.33 h7f8727e_1", + "libffi 3.4.2 h6a678d5_6", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libuuid 1.41.5 h5eee18b_0", + "libwebp-base 1.2.4 h5eee18b_1", + "libxcb 1.15 h7f8727e_0", + "libzopfli 1.0.3 he6710b0_0", + "lz4-c 1.9.4 h6a678d5_0", + "lzo 2.10 h7b6447c_2", + "ncurses 6.4 h6a678d5_0", + "ninja-base 1.10.2 hd09550d_5", + "nspr 4.33 h295c915_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openssl 1.1.1t h7f8727e_0", + "pcre 8.45 h295c915_0", + "snappy 1.1.9 h295c915_0", + "tbb 2021.7.0 hdb19cb5_0", + "xz 5.2.10 h5eee18b_1", + "yaml 0.2.5 h7b6447c_0", + "zfp 0.5.5 h295c915_6", + "zlib 1.2.13 h5eee18b_0", + "dal 2023.0.1 hdb19cb5_26647", + "glib 2.69.1 he621ea3_2", + "hdf5 1.10.6 h3ffc7dd_1", + "jq 1.6 h27cfd23_1000", + "libbrotlidec 1.0.9 h5eee18b_7", + "libbrotlienc 1.0.9 h5eee18b_7", + "libedit 3.1.20221030 h5eee18b_0", + "libevent 2.1.12 h8f2d780_0", + "libllvm10 10.0.1 hbcb73fb_5", + "libllvm11 11.1.0 h9e868ea_6", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.39 h5eee18b_0", + "libprotobuf 3.20.3 he621ea3_0", + "libssh2 1.10.0 h8f2d780_0", + "libxml2 2.9.14 h74e7548_0", + "mpfr 4.0.2 hb69a4c5_1", + "readline 8.2 h5eee18b_0", + "tk 8.6.12 h1ccaba5_0", + "zeromq 4.3.4 h2531618_0", + "zstd 1.5.2 ha4553b6_0", + "blosc 1.21.3 h6a678d5_0", + "brotli-bin 1.0.9 h5eee18b_7", + "dbus 1.13.18 hb2f20db_0", + "freetype 2.12.1 h4a9f257_0", + "gstreamer 1.14.1 h5eee18b_1", + "krb5 1.19.4 h568e23c_0", + "libclang 10.0.1 default_hb85057a_2", + "libtiff 4.5.0 h6a678d5_2", + "libxkbcommon 1.0.1 hfa300c1_0", + "libxslt 1.1.35 h4e12654_0", + "mpc 1.1.0 h10f8cd9_1", + "sqlite 3.40.1 h5082296_0", + "unixodbc 2.3.11 h5eee18b_0", + "brotli 1.0.9 h5eee18b_7", + "fontconfig 2.14.1 h52c9d5c_1", + "gst-plugins-base 1.14.1 h6a678d5_1", + "lcms2 2.12 h3be6417_0", + "libcurl 7.87.0 h91b91d3_0", + "libpq 12.9 h16c4e8d_3", + "libwebp 1.2.4 h11a3e52_1", + "nss 3.74 h0370c37_0", + "openjpeg 2.4.0 h3ad879b_0", + "python 3.8.16 h7a1cb2a_3", + "alabaster 0.7.12 pyhd3eb1b0_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 22.1.0 py38h06a4308_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "brunsli 0.1 h2531618_0", + "certifi 2022.12.7 py38h06a4308_0", + "cfitsio 3.470 h5893167_7", + "chardet 4.0.0 py38h06a4308_1003", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py38h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "colorama 0.4.6 py38h06a4308_0", + "constantly 15.1.0 pyh2b92418_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.87.0 h5eee18b_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "debugpy 1.5.1 py38h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "dill 0.3.6 py38h06a4308_0", + "docstring-to-markdown 0.11 py38h06a4308_0", + "docutils 0.18.1 py38h06a4308_3", + "entrypoints 0.4 py38h06a4308_0", + "et_xmlfile 1.1.0 py38h06a4308_0", + "executing 0.8.3 pyhd3eb1b0_0", + "filelock 3.9.0 py38h06a4308_0", + "flit-core 3.6.0 pyhd3eb1b0_0", + "fsspec 2022.11.0 py38h06a4308_0", + "future 0.18.3 py38h06a4308_0", + "gmpy2 2.1.2 py38heeb90bb_0", + "greenlet 2.0.1 py38h6a678d5_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "idna 3.4 py38h06a4308_0", + "imagesize 1.4.1 py38h06a4308_0", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py38h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jellyfish 0.9.0 py38h7f8727e_0", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.1 py38h06a4308_0", + "json5 0.9.6 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "kiwisolver 1.4.4 py38h6a678d5_0", + "lazy-object-proxy 1.6.0 py38h27cfd23_0", + "llvmlite 0.39.1 py38he621ea3_0", + "locket 1.0.0 py38h06a4308_0", + "lxml 4.9.1 py38h1edc446_0", + "lz4 3.1.3 py38h27cfd23_0", + "markupsafe 2.1.1 py38h7f8727e_0", + "mccabe 0.7.0 pyhd3eb1b0_0", + "mistune 0.8.4 py38h7b6447c_1000", + "mock 4.0.3 pyhd3eb1b0_0", + "mpmath 1.2.1 py38h06a4308_0", + "msgpack-python 1.0.3 py38hd09550d_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py38h06a4308_1", + "nest-asyncio 1.5.6 py38h06a4308_0", + "networkx 2.8.4 py38h06a4308_0", + "ninja 1.10.2 h06a4308_5", + "packaging 22.0 py38h06a4308_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "param 1.12.3 py38h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "pathspec 0.10.3 py38h06a4308_0", + "pep8 1.7.1 py38h06a4308_1", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.4.0 py38h6a678d5_0", + "pkgutil-resolve-name 1.3.10 py38h06a4308_0", + "platformdirs 2.5.2 py38h06a4308_0", + "pluggy 1.0.0 py38h06a4308_1", + "ply 3.11 py38_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.14.1 py38h06a4308_0", + "psutil 5.9.0 py38h5eee18b_0", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "pure_eval 0.2.2 pyhd3eb1b0_0", + "py 1.11.0 pyhd3eb1b0_0", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pycodestyle 2.10.0 py38h06a4308_0", + "pycparser 2.21 pyhd3eb1b0_0", + "pycurl 7.45.1 py38h8f2d780_0", + "pydispatcher 2.0.5 py38h06a4308_2", + "pyflakes 3.0.1 py38h06a4308_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pylint-venv 2.3.0 py38h06a4308_0", + "pyodbc 4.0.34 py38h6a678d5_0", + "pyparsing 3.0.9 py38h06a4308_0", + "pyrsistent 0.18.0 py38heee7806_0", + "pysocks 1.7.1 py38h06a4308_0", + "python-fastjsonschema 2.16.2 py38h06a4308_0", + "python-snappy 0.6.1 py38h6a678d5_0", + "pytz 2022.7 py38h06a4308_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py38h5eee18b_1", + "pyzmq 23.2.0 py38h6a678d5_0", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qt-main 5.15.2 h327a75a_7", + "queuelib 1.5.0 py38h06a4308_0", + "regex 2022.7.9 py38h5eee18b_0", + "rtree 1.0.1 py38h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.2.1 py38h06a4308_0", + "sniffio 1.2.0 py38h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.2.post1 py38h06a4308_0", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "tabulate 0.8.10 py38h06a4308_0", + "tbb4py 2021.7.0 py38hdb19cb5_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py38h06a4308_1", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "tokenizers 0.11.4 py38h3dcd8bd_1", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 2.0.1 py38h06a4308_0", + "tomlkit 0.11.1 py38h06a4308_0", + "toolz 0.12.0 py38h06a4308_0", + "tornado 6.1 py38h27cfd23_0", + "tqdm 4.64.1 py38h06a4308_0", + "traitlets 5.7.1 py38h06a4308_0", + "ujson 5.4.0 py38h6a678d5_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py38_1", + "whatthepatch 1.0.2 py38h06a4308_0", + "wheel 0.38.4 py38h06a4308_0", + "wrapt 1.14.1 py38h5eee18b_0", + "wurlitzer 3.0.2 py38h06a4308_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zipp 3.11.0 py38h06a4308_0", + "zope 1.0 py38_1", + "anyio 3.5.0 py38h06a4308_0", + "asttokens 2.0.5 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_1", + "babel 2.11.0 py38h06a4308_0", + "beautifulsoup4 4.11.1 py38h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bleach 4.1.0 pyhd3eb1b0_0", + "cffi 1.15.1 py38h5eee18b_3", + "comm 0.1.2 py38h06a4308_0", + "cytoolz 0.12.0 py38h5eee18b_0", + "flake8 6.0.0 py38h06a4308_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "importlib-metadata 4.11.3 py38h06a4308_0", + "importlib_resources 5.2.0 pyhd3eb1b0_1", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "jedi 0.18.1 py38h06a4308_1", + "jinja2 3.1.2 py38h06a4308_0", + "jupyter_core 5.2.0 py38h06a4308_0", + "jupyterlab_pygments 0.1.2 py_0", + "matplotlib-inline 0.1.6 py38h06a4308_0", + "mkl-service 2.4.0 py38h7f8727e_0", + "multipledispatch 0.6.0 py38_0", + "nltk 3.7 pyhd3eb1b0_0", + "openpyxl 3.0.10 py38h5eee18b_0", + "partd 1.2.0 pyhd3eb1b0_1", + "pexpect 4.8.0 pyhd3eb1b0_3", + "plotly 5.9.0 py38h06a4308_0", + "prompt-toolkit 3.0.36 py38h06a4308_0", + "protego 0.1.16 py_0", + "pyasn1-modules 0.2.8 py_0", + "pydocstyle 6.3.0 py38h06a4308_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pytest 7.1.2 py38h06a4308_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "pytoolconfig 1.2.5 py38h06a4308_1", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "qt-webengine 5.15.9 hd2b0992_4", + "qtpy 2.2.0 py38h06a4308_0", + "setuptools 65.6.3 py38h06a4308_0", + "sip 6.6.2 py38h6a678d5_0", + "sqlalchemy 1.4.39 py38h5eee18b_0", + "sympy 1.11.1 py38h06a4308_0", + "terminado 0.17.1 py38h06a4308_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tinycss2 1.2.1 py38h06a4308_0", + "typing_extensions 4.4.0 py38h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py38h06a4308_0", + "websocket-client 0.58.0 py38h06a4308_4", + "werkzeug 2.2.2 py38h06a4308_0", + "zict 2.1.0 py38h06a4308_0", + "argon2-cffi-bindings 21.2.0 py38h7f8727e_0", + "arrow 1.2.3 py38h06a4308_1", + "black 22.6.0 py38h06a4308_0", + "brotlipy 0.7.0 py38h27cfd23_1003", + "cryptography 39.0.1 py38h9ce1e76_0", + "dask-core 2022.7.0 py38h06a4308_0", + "flask 2.2.2 py38h06a4308_0", + "importlib_metadata 4.11.3 hd3eb1b0_0", + "jsonschema 4.17.3 py38h06a4308_0", + "jupyter_client 7.3.4 py38h06a4308_0", + "markdown 3.4.1 py38h06a4308_0", + "numpy-base 1.23.5 py38h31eccc5_0", + "parsel 1.6.0 py38h06a4308_0", + "pip 22.3.1 py38h06a4308_0", + "prompt_toolkit 3.0.36 hd3eb1b0_0", + "pyqt5-sip 12.11.0 py38h6a678d5_1", + "qstylizer 0.2.2 py38h06a4308_0", + "qtawesome 1.2.2 py38h06a4308_0", + "qtwebkit 5.212 h4eab89a_4", + "rope 1.7.0 py38h06a4308_0", + "stack_data 0.2.0 pyhd3eb1b0_0", + "typing-extensions 4.4.0 py38h06a4308_0", + "zope.interface 5.4.0 py38h7f8727e_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "astroid 2.14.2 py38h06a4308_0", + "bcrypt 3.2.0 py38h5eee18b_1", + "ipython 8.10.0 py38h06a4308_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "nbformat 5.7.0 py38h06a4308_0", + "pyopenssl 23.0.0 py38h06a4308_0", + "pyqt 5.15.7 py38h6a678d5_1", + "secretstorage 3.3.1 py38h06a4308_0", + "service_identity 18.1.0 pyhd3eb1b0_1", + "ipykernel 6.19.2 py38hb070fc8_0", + "keyring 23.4.0 py38h06a4308_0", + "nbclient 0.5.13 py38h06a4308_0", + "pylint 2.16.2 py38h06a4308_0", + "pyqtwebengine 5.15.7 py38h6a678d5_1", + "twisted 22.2.0 py38h5eee18b_1", + "urllib3 1.26.14 py38h06a4308_0", + "distributed 2022.7.0 py38h06a4308_0", + "jupyter_console 6.6.2 py38h06a4308_0", + "nbconvert 6.5.4 py38h06a4308_0", + "python-lsp-server 1.7.1 py38h06a4308_0", + "qtconsole 5.4.0 py38h06a4308_0", + "requests 2.28.1 py38h06a4308_0", + "spyder-kernels 2.4.1 py38h06a4308_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "huggingface_hub 0.10.1 py38h06a4308_0", + "jupyter_server 1.23.4 py38h06a4308_0", + "pooch 1.4.0 pyhd3eb1b0_0", + "pyct 0.5.0 py38h06a4308_0", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "python-lsp-black 1.2.1 py38h06a4308_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "sphinx 5.0.2 py38h06a4308_0", + "colorcet 3.0.1 py38h06a4308_0", + "jupyterlab_server 2.19.0 py38h06a4308_0", + "notebook-shim 0.2.2 py38h06a4308_0", + "numpydoc 1.5.0 py38h06a4308_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "nbclassic 0.5.2 py38h06a4308_0", + "scrapy 2.8.0 py38h06a4308_0", + "spyder 5.4.1 py38h06a4308_0", + "notebook 6.5.2 py38h06a4308_0", + "jupyterlab 3.5.3 py38h06a4308_0", + "widgetsnbextension 3.5.2 py38h06a4308_0", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "jupyter 1.0.0 py38h06a4308_8", + "bokeh 2.4.3 py38h06a4308_0", + "panel 0.14.3 py38h06a4308_0", + "bottleneck 1.3.5 py38h7deecbd_0", + "contourpy 1.0.5 py38hdb19cb5_0", + "daal4py 2023.0.2 py38h79cecc1_0", + "datashape 0.5.4 py38h06a4308_1", + "h5py 3.7.0 py38h737f45e_0", + "imagecodecs 2021.8.26 py38hfcb8610_2", + "imageio 2.26.0 py38h06a4308_0", + "intake 0.6.7 py38h06a4308_0", + "matplotlib 3.7.0 py38h06a4308_0", + "matplotlib-base 3.7.0 py38h417a72b_0", + "mkl_fft 1.3.1 py38hd3c417c_0", + "mkl_random 1.2.2 py38h51133e4_0", + "numpy 1.23.5 py38h14f4228_0", + "numba 0.56.4 py38h417a72b_0", + "numexpr 2.8.4 py38he184ba9_0", + "patsy 0.5.3 py38h06a4308_0", + "pyerfa 2.0.0 py38h27cfd23_0", + "pytorch 1.12.1 cpu_py38hb1f1ab4_1", + "pywavelets 1.4.1 py38h5eee18b_0", + "scipy 1.10.0 py38h14f4228_1", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "astropy 5.1 py38h7deecbd_0", + "gensim 4.3.0 py38h6a678d5_0", + "pandas 1.5.3 py38h417a72b_0", + "pytables 3.7.0 py38hf19a122_1", + "scikit-image 0.19.3 py38h6a678d5_1", + "scikit-learn 1.2.1 py38h6a678d5_0", + "transformers 4.24.0 py38h06a4308_0", + "dask 2022.7.0 py38h06a4308_0", + "holoviews 1.15.4 py38h06a4308_0", + "imbalanced-learn 0.10.1 py38h06a4308_0", + "scikit-learn-intelex 2023.0.2 py38h06a4308_0", + "seaborn 0.12.2 py38h06a4308_0", + "statsmodels 0.13.5 py38h7deecbd_1", + "xarray 2022.11.0 py38h06a4308_0", + "datashader 0.14.4 py38h06a4308_0", + "hvplot 0.8.2 py38h06a4308_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a4487eb62cf9a97a22d3d66146a3da4", + "name": "anaconda", + "namespace": "python", + "sha256": "609f0355ea926b07545b1e1100402ad1ca042e0cec6ec8557516578098c43f1f", + "size": 76004, + "subdir": "linux-64", + "timestamp": 1678132281417, + "version": "2023.03" + }, + "anaconda-2023.03-py39_0.conda": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main", + "blas 1.0 mkl", + "ca-certificates 2023.01.10 h06a4308_0", + "intel-openmp 2021.4.0 h06a4308_3561", + "ld_impl_linux-64 2.38 h1181459_1", + "libgfortran5 11.2.0 h1234567_1", + "libstdcxx-ng 11.2.0 h1234567_1", + "mpi 1.0 mpich", + "tzdata 2022g h04d1e81_0", + "libgfortran-ng 11.2.0 h00389a5_1", + "libgomp 11.2.0 h1234567_1", + "mkl 2021.4.0 h06a4308_640", + "mpich 3.3.2 external_0", + "_openmp_mutex 5.1 1_gnu", + "libgcc-ng 11.2.0 h1234567_1", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.18.1 h7f8727e_0", + "charls 2.2.0 h2531618_0", + "expat 2.4.9 h6a678d5_0", + "giflib 5.2.1 h5eee18b_3", + "gmp 6.2.1 h295c915_3", + "icu 58.2 he6710b0_3", + "jpeg 9e h5eee18b_1", + "jxrlib 1.1 h7b6447c_2", + "lerc 3.0 h295c915_0", + "libaec 1.0.4 he6710b0_1", + "libbrotlicommon 1.0.9 h5eee18b_7", + "libdeflate 1.17 h5eee18b_0", + "libev 4.33 h7f8727e_1", + "libffi 3.4.2 h6a678d5_6", + "libsodium 1.0.18 h7b6447c_0", + "libspatialindex 1.9.3 h2531618_0", + "libuuid 1.41.5 h5eee18b_0", + "libwebp-base 1.2.4 h5eee18b_1", + "libxcb 1.15 h7f8727e_0", + "libzopfli 1.0.3 he6710b0_0", + "lz4-c 1.9.4 h6a678d5_0", + "lzo 2.10 h7b6447c_2", + "ncurses 6.4 h6a678d5_0", + "ninja-base 1.10.2 hd09550d_5", + "nspr 4.33 h295c915_0", + "oniguruma 6.9.7.1 h27cfd23_0", + "openssl 1.1.1t h7f8727e_0", + "pcre 8.45 h295c915_0", + "snappy 1.1.9 h295c915_0", + "tbb 2021.7.0 hdb19cb5_0", + "xz 5.2.10 h5eee18b_1", + "yaml 0.2.5 h7b6447c_0", + "zfp 0.5.5 h295c915_6", + "zlib 1.2.13 h5eee18b_0", + "dal 2023.0.1 hdb19cb5_26647", + "glib 2.69.1 he621ea3_2", + "hdf5 1.10.6 h3ffc7dd_1", + "jq 1.6 h27cfd23_1000", + "libbrotlidec 1.0.9 h5eee18b_7", + "libbrotlienc 1.0.9 h5eee18b_7", + "libedit 3.1.20221030 h5eee18b_0", + "libevent 2.1.12 h8f2d780_0", + "libllvm10 10.0.1 hbcb73fb_5", + "libllvm11 11.1.0 h9e868ea_6", + "libnghttp2 1.46.0 hce63b2e_0", + "libpng 1.6.39 h5eee18b_0", + "libprotobuf 3.20.3 he621ea3_0", + "libssh2 1.10.0 h8f2d780_0", + "libxml2 2.9.14 h74e7548_0", + "mpfr 4.0.2 hb69a4c5_1", + "readline 8.2 h5eee18b_0", + "tk 8.6.12 h1ccaba5_0", + "zeromq 4.3.4 h2531618_0", + "zstd 1.5.2 ha4553b6_0", + "blosc 1.21.3 h6a678d5_0", + "brotli-bin 1.0.9 h5eee18b_7", + "dbus 1.13.18 hb2f20db_0", + "freetype 2.12.1 h4a9f257_0", + "gstreamer 1.14.1 h5eee18b_1", + "krb5 1.19.4 h568e23c_0", + "libclang 10.0.1 default_hb85057a_2", + "libtiff 4.5.0 h6a678d5_2", + "libxkbcommon 1.0.1 hfa300c1_0", + "libxslt 1.1.35 h4e12654_0", + "mpc 1.1.0 h10f8cd9_1", + "sqlite 3.40.1 h5082296_0", + "unixodbc 2.3.11 h5eee18b_0", + "brotli 1.0.9 h5eee18b_7", + "fontconfig 2.14.1 h52c9d5c_1", + "gst-plugins-base 1.14.1 h6a678d5_1", + "lcms2 2.12 h3be6417_0", + "libcurl 7.87.0 h91b91d3_0", + "libpq 12.9 h16c4e8d_3", + "libwebp 1.2.4 h11a3e52_1", + "nss 3.74 h0370c37_0", + "openjpeg 2.4.0 h3ad879b_0", + "python 3.9.16 h7a1cb2a_1", + "alabaster 0.7.12 pyhd3eb1b0_0", + "appdirs 1.4.4 pyhd3eb1b0_0", + "atomicwrites 1.4.0 py_0", + "attrs 22.1.0 py39h06a4308_0", + "backcall 0.2.0 pyhd3eb1b0_0", + "brunsli 0.1 h2531618_0", + "certifi 2022.12.7 py39h06a4308_0", + "cfitsio 3.470 h5893167_7", + "chardet 4.0.0 py39h06a4308_1003", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "click 8.0.4 py39h06a4308_0", + "cloudpickle 2.0.0 pyhd3eb1b0_0", + "colorama 0.4.6 py39h06a4308_0", + "constantly 15.1.0 pyh2b92418_0", + "cssselect 1.1.0 pyhd3eb1b0_0", + "curl 7.87.0 h5eee18b_0", + "cycler 0.11.0 pyhd3eb1b0_0", + "debugpy 1.5.1 py39h295c915_0", + "decorator 5.1.1 pyhd3eb1b0_0", + "defusedxml 0.7.1 pyhd3eb1b0_0", + "diff-match-patch 20200713 pyhd3eb1b0_0", + "dill 0.3.6 py39h06a4308_0", + "docstring-to-markdown 0.11 py39h06a4308_0", + "docutils 0.18.1 py39h06a4308_3", + "entrypoints 0.4 py39h06a4308_0", + "et_xmlfile 1.1.0 py39h06a4308_0", + "executing 0.8.3 pyhd3eb1b0_0", + "filelock 3.9.0 py39h06a4308_0", + "flit-core 3.6.0 pyhd3eb1b0_0", + "fsspec 2022.11.0 py39h06a4308_0", + "future 0.18.3 py39h06a4308_0", + "gmpy2 2.1.2 py39heeb90bb_0", + "greenlet 2.0.1 py39h6a678d5_0", + "heapdict 1.0.1 pyhd3eb1b0_0", + "idna 3.4 py39h06a4308_0", + "imagesize 1.4.1 py39h06a4308_0", + "incremental 21.3.0 pyhd3eb1b0_0", + "inflection 0.5.1 py39h06a4308_0", + "iniconfig 1.1.1 pyhd3eb1b0_0", + "ipython_genutils 0.2.0 pyhd3eb1b0_1", + "isort 5.9.3 pyhd3eb1b0_0", + "itemadapter 0.3.0 pyhd3eb1b0_0", + "itsdangerous 2.0.1 pyhd3eb1b0_0", + "jeepney 0.7.1 pyhd3eb1b0_0", + "jellyfish 0.9.0 py39h7f8727e_0", + "jmespath 0.10.0 pyhd3eb1b0_0", + "joblib 1.1.1 py39h06a4308_0", + "json5 0.9.6 pyhd3eb1b0_0", + "jupyterlab_widgets 1.0.0 pyhd3eb1b0_1", + "kiwisolver 1.4.4 py39h6a678d5_0", + "lazy-object-proxy 1.6.0 py39h27cfd23_0", + "llvmlite 0.39.1 py39he621ea3_0", + "locket 1.0.0 py39h06a4308_0", + "lxml 4.9.1 py39h1edc446_0", + "lz4 3.1.3 py39h27cfd23_0", + "markupsafe 2.1.1 py39h7f8727e_0", + "mccabe 0.7.0 pyhd3eb1b0_0", + "mistune 0.8.4 py39h27cfd23_1000", + "mock 4.0.3 pyhd3eb1b0_0", + "mpmath 1.2.1 py39h06a4308_0", + "msgpack-python 1.0.3 py39hd09550d_0", + "munkres 1.1.4 py_0", + "mypy_extensions 0.4.3 py39h06a4308_1", + "nest-asyncio 1.5.6 py39h06a4308_0", + "networkx 2.8.4 py39h06a4308_0", + "ninja 1.10.2 h06a4308_5", + "packaging 22.0 py39h06a4308_0", + "pandocfilters 1.5.0 pyhd3eb1b0_0", + "param 1.12.3 py39h06a4308_0", + "parso 0.8.3 pyhd3eb1b0_0", + "pathspec 0.10.3 py39h06a4308_0", + "pep8 1.7.1 py39h06a4308_1", + "pickleshare 0.7.5 pyhd3eb1b0_1003", + "pillow 9.4.0 py39h6a678d5_0", + "platformdirs 2.5.2 py39h06a4308_0", + "pluggy 1.0.0 py39h06a4308_1", + "ply 3.11 py39h06a4308_0", + "poyo 0.5.0 pyhd3eb1b0_0", + "prometheus_client 0.14.1 py39h06a4308_0", + "psutil 5.9.0 py39h5eee18b_0", + "ptyprocess 0.7.0 pyhd3eb1b0_2", + "pure_eval 0.2.2 pyhd3eb1b0_0", + "py 1.11.0 pyhd3eb1b0_0", + "pyasn1 0.4.8 pyhd3eb1b0_0", + "pycodestyle 2.10.0 py39h06a4308_0", + "pycparser 2.21 pyhd3eb1b0_0", + "pycurl 7.45.1 py39h8f2d780_0", + "pydispatcher 2.0.5 py39h06a4308_2", + "pyflakes 3.0.1 py39h06a4308_0", + "pygments 2.11.2 pyhd3eb1b0_0", + "pylint-venv 2.3.0 py39h06a4308_0", + "pyodbc 4.0.34 py39h6a678d5_0", + "pyparsing 3.0.9 py39h06a4308_0", + "pyrsistent 0.18.0 py39heee7806_0", + "pysocks 1.7.1 py39h06a4308_0", + "python-fastjsonschema 2.16.2 py39h06a4308_0", + "python-snappy 0.6.1 py39h6a678d5_0", + "pytz 2022.7 py39h06a4308_0", + "pyxdg 0.27 pyhd3eb1b0_0", + "pyyaml 6.0 py39h5eee18b_1", + "pyzmq 23.2.0 py39h6a678d5_0", + "qdarkstyle 3.0.2 pyhd3eb1b0_0", + "qt-main 5.15.2 h327a75a_7", + "queuelib 1.5.0 py39h06a4308_0", + "regex 2022.7.9 py39h5eee18b_0", + "rtree 1.0.1 py39h06a4308_0", + "send2trash 1.8.0 pyhd3eb1b0_1", + "six 1.16.0 pyhd3eb1b0_1", + "smart_open 5.2.1 py39h06a4308_0", + "sniffio 1.2.0 py39h06a4308_1", + "snowballstemmer 2.2.0 pyhd3eb1b0_0", + "sortedcontainers 2.4.0 pyhd3eb1b0_0", + "soupsieve 2.3.2.post1 py39h06a4308_0", + "sphinxcontrib-applehelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-devhelp 1.0.2 pyhd3eb1b0_0", + "sphinxcontrib-htmlhelp 2.0.0 pyhd3eb1b0_0", + "sphinxcontrib-jsmath 1.0.1 pyhd3eb1b0_0", + "sphinxcontrib-qthelp 1.0.3 pyhd3eb1b0_0", + "sphinxcontrib-serializinghtml 1.1.5 pyhd3eb1b0_0", + "tabulate 0.8.10 py39h06a4308_0", + "tbb4py 2021.7.0 py39hdb19cb5_0", + "tblib 1.7.0 pyhd3eb1b0_0", + "tenacity 8.0.1 py39h06a4308_1", + "text-unidecode 1.3 pyhd3eb1b0_0", + "textdistance 4.2.1 pyhd3eb1b0_0", + "threadpoolctl 2.2.0 pyh0d69192_0", + "tokenizers 0.11.4 py39h3dcd8bd_1", + "toml 0.10.2 pyhd3eb1b0_0", + "tomli 2.0.1 py39h06a4308_0", + "tomlkit 0.11.1 py39h06a4308_0", + "toolz 0.12.0 py39h06a4308_0", + "tornado 6.1 py39h27cfd23_0", + "tqdm 4.64.1 py39h06a4308_0", + "traitlets 5.7.1 py39h06a4308_0", + "ujson 5.4.0 py39h6a678d5_0", + "unidecode 1.2.0 pyhd3eb1b0_0", + "wcwidth 0.2.5 pyhd3eb1b0_0", + "webencodings 0.5.1 py39h06a4308_1", + "whatthepatch 1.0.2 py39h06a4308_0", + "wheel 0.38.4 py39h06a4308_0", + "wrapt 1.14.1 py39h5eee18b_0", + "wurlitzer 3.0.2 py39h06a4308_0", + "yapf 0.31.0 pyhd3eb1b0_0", + "zipp 3.11.0 py39h06a4308_0", + "zope 1.0 py39h06a4308_1", + "anyio 3.5.0 py39h06a4308_0", + "asttokens 2.0.5 pyhd3eb1b0_0", + "automat 20.2.0 py_0", + "autopep8 1.6.0 pyhd3eb1b0_1", + "babel 2.11.0 py39h06a4308_0", + "beautifulsoup4 4.11.1 py39h06a4308_0", + "binaryornot 0.4.4 pyhd3eb1b0_1", + "bleach 4.1.0 pyhd3eb1b0_0", + "cffi 1.15.1 py39h5eee18b_3", + "comm 0.1.2 py39h06a4308_0", + "cytoolz 0.12.0 py39h5eee18b_0", + "flake8 6.0.0 py39h06a4308_0", + "fonttools 4.25.0 pyhd3eb1b0_0", + "hyperlink 21.0.0 pyhd3eb1b0_0", + "importlib-metadata 4.11.3 py39h06a4308_0", + "importlib_resources 5.2.0 pyhd3eb1b0_1", + "intervaltree 3.1.0 pyhd3eb1b0_0", + "jedi 0.18.1 py39h06a4308_1", + "jinja2 3.1.2 py39h06a4308_0", + "jsonschema 4.17.3 py39h06a4308_0", + "jupyter_core 5.2.0 py39h06a4308_0", + "jupyterlab_pygments 0.1.2 py_0", + "matplotlib-inline 0.1.6 py39h06a4308_0", + "mkl-service 2.4.0 py39h7f8727e_0", + "multipledispatch 0.6.0 py39h06a4308_0", + "nltk 3.7 pyhd3eb1b0_0", + "openpyxl 3.0.10 py39h5eee18b_0", + "partd 1.2.0 pyhd3eb1b0_1", + "pexpect 4.8.0 pyhd3eb1b0_3", + "plotly 5.9.0 py39h06a4308_0", + "prompt-toolkit 3.0.36 py39h06a4308_0", + "protego 0.1.16 py_0", + "pyasn1-modules 0.2.8 py_0", + "pydocstyle 6.3.0 py39h06a4308_0", + "pyhamcrest 2.0.2 pyhd3eb1b0_2", + "pytest 7.1.2 py39h06a4308_0", + "python-dateutil 2.8.2 pyhd3eb1b0_0", + "python-lsp-jsonrpc 1.0.0 pyhd3eb1b0_0", + "python-slugify 5.0.2 pyhd3eb1b0_0", + "pytoolconfig 1.2.5 py39h06a4308_1", + "pyviz_comms 2.0.2 pyhd3eb1b0_0", + "qt-webengine 5.15.9 hd2b0992_4", + "qtpy 2.2.0 py39h06a4308_0", + "setuptools 65.6.3 py39h06a4308_0", + "sip 6.6.2 py39h6a678d5_0", + "sqlalchemy 1.4.39 py39h5eee18b_0", + "sympy 1.11.1 py39h06a4308_0", + "terminado 0.17.1 py39h06a4308_0", + "three-merge 0.1.1 pyhd3eb1b0_0", + "tinycss2 1.2.1 py39h06a4308_0", + "typing_extensions 4.4.0 py39h06a4308_0", + "w3lib 1.21.0 pyhd3eb1b0_0", + "watchdog 2.1.6 py39h06a4308_0", + "websocket-client 0.58.0 py39h06a4308_4", + "werkzeug 2.2.2 py39h06a4308_0", + "zict 2.1.0 py39h06a4308_0", + "argon2-cffi-bindings 21.2.0 py39h7f8727e_0", + "arrow 1.2.3 py39h06a4308_1", + "black 22.6.0 py39h06a4308_0", + "brotlipy 0.7.0 py39h27cfd23_1003", + "cryptography 39.0.1 py39h9ce1e76_0", + "dask-core 2022.7.0 py39h06a4308_0", + "flask 2.2.2 py39h06a4308_0", + "importlib_metadata 4.11.3 hd3eb1b0_0", + "jupyter_client 7.3.4 py39h06a4308_0", + "markdown 3.4.1 py39h06a4308_0", + "nbformat 5.7.0 py39h06a4308_0", + "numpy-base 1.23.5 py39h31eccc5_0", + "parsel 1.6.0 py39h06a4308_0", + "pip 22.3.1 py39h06a4308_0", + "prompt_toolkit 3.0.36 hd3eb1b0_0", + "pyqt5-sip 12.11.0 py39h6a678d5_1", + "qstylizer 0.2.2 py39h06a4308_0", + "qtawesome 1.2.2 py39h06a4308_0", + "qtwebkit 5.212 h4eab89a_4", + "rope 1.7.0 py39h06a4308_0", + "stack_data 0.2.0 pyhd3eb1b0_0", + "typing-extensions 4.4.0 py39h06a4308_0", + "zope.interface 5.4.0 py39h7f8727e_0", + "argon2-cffi 21.3.0 pyhd3eb1b0_0", + "astroid 2.14.2 py39h06a4308_0", + "bcrypt 3.2.0 py39h5eee18b_1", + "ipython 8.10.0 py39h06a4308_0", + "itemloaders 1.0.4 pyhd3eb1b0_1", + "jinja2-time 0.2.0 pyhd3eb1b0_3", + "nbclient 0.5.13 py39h06a4308_0", + "pyopenssl 23.0.0 py39h06a4308_0", + "pyqt 5.15.7 py39h6a678d5_1", + "secretstorage 3.3.1 py39h06a4308_0", + "service_identity 18.1.0 pyhd3eb1b0_1", + "ipykernel 6.19.2 py39hb070fc8_0", + "keyring 23.4.0 py39h06a4308_0", + "nbconvert 6.5.4 py39h06a4308_0", + "pylint 2.16.2 py39h06a4308_0", + "pyqtwebengine 5.15.7 py39h6a678d5_1", + "twisted 22.2.0 py39h5eee18b_1", + "urllib3 1.26.14 py39h06a4308_0", + "distributed 2022.7.0 py39h06a4308_0", + "jupyter_console 6.6.2 py39h06a4308_0", + "jupyter_server 1.23.4 py39h06a4308_0", + "python-lsp-server 1.7.1 py39h06a4308_0", + "qtconsole 5.4.0 py39h06a4308_0", + "requests 2.28.1 py39h06a4308_0", + "spyder-kernels 2.4.1 py39h06a4308_0", + "cookiecutter 1.7.3 pyhd3eb1b0_0", + "huggingface_hub 0.10.1 py39h06a4308_0", + "jupyterlab_server 2.19.0 py39h06a4308_0", + "notebook-shim 0.2.2 py39h06a4308_0", + "pooch 1.4.0 pyhd3eb1b0_0", + "pyct 0.5.0 py39h06a4308_0", + "pyls-spyder 0.4.0 pyhd3eb1b0_0", + "python-lsp-black 1.2.1 py39h06a4308_0", + "requests-file 1.5.1 pyhd3eb1b0_0", + "sphinx 5.0.2 py39h06a4308_0", + "colorcet 3.0.1 py39h06a4308_0", + "nbclassic 0.5.2 py39h06a4308_0", + "numpydoc 1.5.0 py39h06a4308_0", + "tldextract 3.2.0 pyhd3eb1b0_0", + "notebook 6.5.2 py39h06a4308_0", + "scrapy 2.8.0 py39h06a4308_0", + "spyder 5.4.1 py39h06a4308_0", + "jupyterlab 3.5.3 py39h06a4308_0", + "widgetsnbextension 3.5.2 py39h06a4308_0", + "ipywidgets 7.6.5 pyhd3eb1b0_1", + "jupyter 1.0.0 py39h06a4308_8", + "bokeh 2.4.3 py39h06a4308_0", + "panel 0.14.3 py39h06a4308_0", + "bottleneck 1.3.5 py39h7deecbd_0", + "contourpy 1.0.5 py39hdb19cb5_0", + "daal4py 2023.0.2 py39h79cecc1_0", + "datashape 0.5.4 py39h06a4308_1", + "h5py 3.7.0 py39h737f45e_0", + "imagecodecs 2021.8.26 py39hfcb8610_2", + "imageio 2.26.0 py39h06a4308_0", + "intake 0.6.7 py39h06a4308_0", + "matplotlib 3.7.0 py39h06a4308_0", + "matplotlib-base 3.7.0 py39h417a72b_0", + "mkl_fft 1.3.1 py39hd3c417c_0", + "mkl_random 1.2.2 py39h51133e4_0", + "numpy 1.23.5 py39h14f4228_0", + "numba 0.56.4 py39h417a72b_0", + "numexpr 2.8.4 py39he184ba9_0", + "patsy 0.5.3 py39h06a4308_0", + "pyerfa 2.0.0 py39h27cfd23_0", + "pytorch 1.12.1 cpu_py39hb1f1ab4_1", + "pywavelets 1.4.1 py39h5eee18b_0", + "scipy 1.10.0 py39h14f4228_1", + "tifffile 2021.7.2 pyhd3eb1b0_2", + "astropy 5.1 py39h7deecbd_0", + "gensim 4.3.0 py39h6a678d5_0", + "pandas 1.5.3 py39h417a72b_0", + "pytables 3.7.0 py39hf19a122_1", + "scikit-image 0.19.3 py39h6a678d5_1", + "scikit-learn 1.2.1 py39h6a678d5_0", + "transformers 4.24.0 py39h06a4308_0", + "dask 2022.7.0 py39h06a4308_0", + "holoviews 1.15.4 py39h06a4308_0", + "imbalanced-learn 0.10.1 py39h06a4308_0", + "scikit-learn-intelex 2023.0.2 py39h06a4308_0", + "seaborn 0.12.2 py39h06a4308_0", + "statsmodels 0.13.5 py39h7deecbd_1", + "xarray 2022.11.0 py39h06a4308_0", + "datashader 0.14.4 py39h06a4308_0", + "hvplot 0.8.2 py39h06a4308_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1f34c1611b49195a278b676d450d264d", + "name": "anaconda", + "namespace": "python", + "sha256": "ae57d83e6d8bad8d36f12d373e7edbe2ee3ffa7942b3f8ce88ca6febdb272973", + "size": 75971, + "subdir": "linux-64", + "timestamp": 1678132275650, + "version": "2023.03" + }, + "anaconda-5.0.0-py27he0e5e41_0.conda": { + "build": "py27he0e5e41_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.10 py27he5a193a_0", + "anaconda-client 1.6.5 py27hc8169bf_0", + "anaconda-navigator 1.6.8 py27h2ea4365_0", + "anaconda-project 0.8.0 py27hd7a9a97_0", + "asn1crypto 0.22.0 py27h94ebe91_1", + "astroid 1.5.3 py27h8f8f47c_0", + "astropy 2.0.2 py27h57072c0_4", + "babel 2.5.0 py27h20693cd_0", + "backports 1.0 py27h63c9359_1", + "backports.functools_lru_cache 1.4 py27he8db605_1", + "backports.shutil_get_terminal_size 1.0.0 py27h5bc021e_2", + "backports_abc 0.5 py27h7b3c97b_0", + "beautifulsoup4 4.6.0 py27h3f86ba9_1", + "bitarray 0.8.1 py27h304d4c6_0", + "bkcharts 0.2 py27h241ae91_0", + "blaze 0.11.3 py27h5f341da_0", + "bleach 2.0.0 py27h3a0dcc8_0", + "bokeh 0.12.7 py27he0197c9_1", + "boto 2.48.0 py27h9556ac2_1", + "bottleneck 1.2.1 py27h21b16a3_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 h58b644b_4", + "cdecimal 2.3 py27h4e63abe_1", + "certifi 2017.7.27.1 py27h9ceb091_0", + "cffi 1.10.0 py27hf1aaaf4_1", + "chardet 3.0.4 py27hfa10054_1", + "click 6.7 py27h4225b90_0", + "cloudpickle 0.4.0 py27ha64365b_0", + "clyent 1.2.2 py27h7276e6c_1", + "colorama 0.3.9 py27h5cde069_0", + "configparser 3.5.0 py27h5117587_0", + "contextlib2 0.5.5 py27hbf4c468_0", + "cryptography 2.0.3 py27hea39389_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py27hc7354d3_0", + "cython 0.26.1 py27hdbcff32_0", + "cytoolz 0.8.2 py27hf14aec9_0", + "dask 0.15.2 py27h7693082_0", + "dask-core 0.15.2 py27heedc4a4_0", + "datashape 0.5.4 py27hf507385_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py27h1544723_0", + "distributed 1.18.3 py27h5e7c565_0", + "docutils 0.14 py27hae222c1_0", + "entrypoints 0.2.3 py27h502b47d_2", + "enum34 1.1.6 py27h99a27e9_1", + "et_xmlfile 1.0.1 py27h75840f5_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py27h4cb8e01_0", + "filelock 2.0.12 py27h38fa839_0", + "flask 0.12.2 py27h6d5c1cd_0", + "flask-cors 3.0.3 py27h1a8a27f_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "funcsigs 1.0.2 py27h83f16ab_0", + "functools32 3.2.3.2 py27h4ead58f_1", + "futures 3.1.1 py27hdbc8cbb_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py27h475ea6a_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py27hd3b7d1f_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py27hc856308_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py27hac09c53_0", + "grin 1.2.1 py27h54abee7_1", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py27h71d1790_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py27h33770af_0", + "html5lib 0.999999999 py27hdf15f34_0", + "icu 58.2 h211956c_0", + "idna 2.6 py27h5722d68_1", + "imageio 2.2.0 py27hf108a7f_0", + "imagesize 0.7.1 py27hd17bf80_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipaddress 1.0.18 py27h337fd85_0", + "ipykernel 4.6.1 py27hc93e584_0", + "ipython 5.4.1 py27h36c99b6_1", + "ipython_genutils 0.2.0 py27h89fb69b_0", + "ipywidgets 7.0.0 py27h4fda95d_0", + "isort 4.2.15 py27hcfa4749_0", + "itsdangerous 0.24 py27hb8295c1_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py27h2cc5433_0", + "jedi 0.10.2 py27h8af4e35_0", + "jinja2 2.9.6 py27h82327ae_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py27h7ed5aa4_0", + "jupyter 1.0.0 py27h505fd4b_0", + "jupyter_client 5.1.0 py27hbee1118_0", + "jupyter_console 5.2.0 py27hc6bee7e_1", + "jupyter_core 4.3.0 py27hcd9ae3a_0", + "jupyterlab 0.27.0 py27h42ebfef_2", + "jupyterlab_launcher 0.4.0 py27h0e16d15_0", + "lazy-object-proxy 1.3.1 py27h682c727_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 hcbc56d2_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h24385c6_1", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 he6ee5dd_2", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py27_0", + "locket 0.2.0 py27h73929a2_1", + "lxml 3.8.0 py27hb3ac1f5_0", + "lzo 2.10 hc0eb8fc_0", + "markupsafe 1.0 py27h97b2822_1", + "matplotlib 2.0.2 py27h334a7c2_1", + "mccabe 0.6.1 py27h0e7c7be_1", + "mistune 0.7.4 py27h6da7e90_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py27hb2d42c5_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py27h4bb41bd_2", + "msgpack-python 0.4.8 py27hc2fa789_0", + "multipledispatch 0.4.9 py27h9b5f95a_0", + "navigator-updater 0.1.0 py27h0f9cd39_0", + "nbconvert 5.3.1 py27he041f76_0", + "nbformat 4.4.0 py27hed7f2b2_0", + "ncurses 6.0 h06874d7_1", + "networkx 1.11 py27h7358325_0", + "nltk 3.2.4 py27h41293c3_0", + "nose 1.3.7 py27heec2199_2", + "notebook 5.0.0 py27h3661c2b_2", + "numba 0.35.0 np113py27_10", + "numexpr 2.6.2 py27he5efce1_1", + "numpy 1.13.1 py27hd1b6e02_2", + "numpydoc 0.7.0 py27h9647a75_0", + "odo 0.5.1 py27h9170de3_0", + "olefile 0.44 py27h4bd3e3c_0", + "openpyxl 2.4.8 py27h9f0c937_1", + "openssl 1.0.2l h9d1a558_3", + "packaging 16.8 py27h5e07c7c_1", + "pandas 0.20.3 py27h820b67f_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py27h428e1e5_1", + "pango 1.40.11 hedb6d6b_0", + "partd 0.3.8 py27h4e55004_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py27hc258cac_0", + "pathlib2 2.3.0 py27h6e9d198_0", + "patsy 0.4.1 py27hd1cf8c0_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py27h444351c_0", + "pexpect 4.2.1 py27hcf82287_0", + "pickleshare 0.7.4 py27h09770e1_0", + "pillow 4.2.1 py27h7cd2321_0", + "pip 9.0.1 py27h4c18a59_2", + "pixman 0.34.0 ha72d70b_1", + "pkginfo 1.4.1 py27hee1a9ad_1", + "ply 3.10 py27hd6d9ae5_0", + "prompt_toolkit 1.0.15 py27h1b593e1_0", + "psutil 5.2.2 py27h9b5ba61_0", + "ptyprocess 0.5.2 py27h4ccb14c_0", + "py 1.4.34 py27he5894e4_1", + "pycairo 1.13.3 py27hea6d626_0", + "pycodestyle 2.3.1 py27h904819d_0", + "pycosat 0.6.2 py27h1cf261c_1", + "pycparser 2.18 py27hefa08c5_1", + "pycrypto 2.6.1 py27h9abbf5c_1", + "pycurl 7.43.0 py27hcf8ebea_3", + "pyflakes 1.5.0 py27hfba2528_1", + "pygments 2.2.0 py27h4a8b6f5_0", + "pylint 1.7.2 py27h77e98c6_0", + "pyodbc 4.0.17 py27h7f7627d_0", + "pyopenssl 17.2.0 py27h189ff3b_0", + "pyparsing 2.2.0 py27hf1513f8_1", + "pyqt 5.6.0 py27h4b1e83c_5", + "pysocks 1.6.7 py27he2db6d2_1", + "pytables 3.4.2 py27ha79ee23_1", + "pytest 3.2.1 py27h98000ae_1", + "python 2.7.13 hfff3488_13", + "python-dateutil 2.6.1 py27h4ca5741_1", + "pytz 2017.2 py27hcac29fa_1", + "pywavelets 0.5.2 py27hecda097_0", + "pyyaml 3.12 py27h2d70dd7_1", + "pyzmq 16.0.2 py27h297844f_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py27hd7914c3_0", + "qtconsole 4.3.1 py27hc444b0d_0", + "qtpy 1.3.1 py27h63d3751_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py27hc5b0589_1", + "rope 0.10.5 py27hcb0a616_0", + "ruamel_yaml 0.11.14 py27h672d447_2", + "scandir 1.5 py27h1c9e1f8_1", + "scikit-image 0.13.0 py27h06cb35d_1", + "scikit-learn 0.19.0 py27hd893acb_2", + "scipy 0.19.1 py27h1edc525_3", + "seaborn 0.8.0 py27h9d2aaa1_0", + "setuptools 36.5.0 py27h68b189e_0", + "simplegeneric 0.8.1 py27h19e43cd_0", + "singledispatch 3.4.0.3 py27h9bcb476_0", + "sip 4.18.1 py27he9ba0ab_2", + "six 1.10.0 py27hdcd7534_1", + "snowballstemmer 1.2.1 py27h44e2768_0", + "sortedcollections 0.5.3 py27h135218e_0", + "sortedcontainers 1.5.7 py27he59936f_0", + "sphinx 1.6.3 py27hf9b1778_0", + "sphinxcontrib 1.0 py27h1512b58_1", + "sphinxcontrib-websupport 1.0.1 py27hf906f22_1", + "spyder 3.2.3 py27hbf281d3_1", + "sqlalchemy 1.1.13 py27hb0a01da_0", + "sqlite 3.20.1 h6d8b0f3_1", + "ssl_match_hostname 3.5.0.1 py27h4ec10b9_2", + "statsmodels 0.8.0 py27hc87d62d_0", + "subprocess32 3.2.7 py27h373dbce_0", + "sympy 1.1.1 py27hc28188a_0", + "tblib 1.3.2 py27h51fe5ba_0", + "terminado 0.6 py27h4be8df9_0", + "testpath 0.3.1 py27hc38d2c4_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py27hd3b1e7e_0", + "tornado 4.5.2 py27h97b179f_0", + "traitlets 4.3.2 py27hd6ce930_0", + "typing 3.6.2 py27h66f49e2_0", + "unicodecsv 0.14.1 py27h5062da9_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py27ha55213b_0", + "wcwidth 0.1.7 py27h9e3e1ab_0", + "webencodings 0.5.1 py27hff10b21_1", + "werkzeug 0.12.2 py27hbf75dff_0", + "wheel 0.29.0 py27h411dd7b_1", + "widgetsnbextension 3.0.2 py27hcb77dec_1", + "wrapt 1.10.11 py27h04f6869_0", + "xlrd 1.1.0 py27ha77178f_1", + "xlsxwriter 0.9.8 py27h260ecd4_0", + "xlwt 1.3.0 py27h3d85d97_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.2 py27hd58a209_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "98b5361408bf889a6ae2241d0fbeae74", + "name": "anaconda", + "namespace": "python", + "sha256": "71e1b4eed5f757ce7e7d8ed08b3007b7ec45776b12f92c19d873cd9ec9e7b362", + "size": 12179, + "subdir": "linux-64", + "timestamp": 1506443355790, + "version": "5.0.0" + }, + "anaconda-5.0.0-py35h81e3b35_0.conda": { + "build": "py35h81e3b35_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.10 py35h6fb19ab_0", + "anaconda-client 1.6.5 py35hd900ed1_0", + "anaconda-navigator 1.6.8 py35haed54dd_0", + "anaconda-project 0.8.0 py35hb597f32_0", + "asn1crypto 0.22.0 py35h0d675fe_1", + "astroid 1.5.3 py35h1d0c565_0", + "astropy 2.0.2 py35h2d2a8a6_4", + "babel 2.5.0 py35ha5fc564_0", + "backports 1.0 py35hd471ac7_1", + "backports.shutil_get_terminal_size 1.0.0 py35h40844db_2", + "beautifulsoup4 4.6.0 py35h442a8c9_1", + "bitarray 0.8.1 py35h7540340_0", + "bkcharts 0.2 py35he4f7e30_0", + "blaze 0.11.3 py35ha2c9137_0", + "bleach 2.0.0 py35h055c768_0", + "bokeh 0.12.7 py35h4751c18_1", + "boto 2.48.0 py35h2cfd601_1", + "bottleneck 1.2.1 py35he1b16f1_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 h58b644b_4", + "certifi 2017.7.27.1 py35h19f42a1_0", + "cffi 1.10.0 py35h796c292_1", + "chardet 3.0.4 py35hb6e9ddf_1", + "click 6.7 py35h353a69f_0", + "cloudpickle 0.4.0 py35h10376d1_0", + "clyent 1.2.2 py35h491ffcb_1", + "colorama 0.3.9 py35h81e2b6c_0", + "contextlib2 0.5.5 py35h6690dba_0", + "cryptography 2.0.3 py35hef72dfd_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py35hc4d5149_0", + "cython 0.26.1 py35h636ebcb_0", + "cytoolz 0.8.2 py35ha53021f_0", + "dask 0.15.2 py35h08b2748_0", + "dask-core 0.15.2 py35h79caba8_0", + "datashape 0.5.4 py35h5b068ae_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py35h3a268aa_0", + "distributed 1.18.3 py35h076cbad_0", + "docutils 0.14 py35hd11081d_0", + "entrypoints 0.2.3 py35h48174a2_2", + "et_xmlfile 1.0.1 py35hde8d43e_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py35hec2bbaa_0", + "filelock 2.0.12 py35h7855d60_0", + "flask 0.12.2 py35h679e90e_0", + "flask-cors 3.0.3 py35h9b2065d_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py35he064abf_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py35h98a1f2a_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py35h89a7545_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py35h2547b41_0", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py35h41d5d6e_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py35h51e6c10_0", + "html5lib 0.999999999 py35h0543385_0", + "icu 58.2 h211956c_0", + "idna 2.6 py35h8605a33_1", + "imageio 2.2.0 py35hd0a6de2_0", + "imagesize 0.7.1 py35hf008fae_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipykernel 4.6.1 py35h29d130c_0", + "ipython 6.1.0 py35h1b71439_1", + "ipython_genutils 0.2.0 py35hc9e07d0_0", + "ipywidgets 7.0.0 py35h8ebd919_0", + "isort 4.2.15 py35h44a00d2_0", + "itsdangerous 0.24 py35h7c46880_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py35hf1f7175_0", + "jedi 0.10.2 py35hc33c70f_0", + "jinja2 2.9.6 py35h90b8645_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py35h4395190_0", + "jupyter 1.0.0 py35hd38625c_0", + "jupyter_client 5.1.0 py35h2bff583_0", + "jupyter_console 5.2.0 py35h4044a63_1", + "jupyter_core 4.3.0 py35he2f7985_0", + "jupyterlab 0.27.0 py35h29561ed_2", + "jupyterlab_launcher 0.4.0 py35ha4e430f_0", + "lazy-object-proxy 1.3.1 py35h4c720c6_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 hcbc56d2_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h24385c6_1", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 he6ee5dd_2", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py35_0", + "locket 0.2.0 py35h170bc82_1", + "lxml 3.8.0 py35h4935ab9_0", + "lzo 2.10 hc0eb8fc_0", + "markupsafe 1.0 py35h4f4fcf6_1", + "matplotlib 2.0.2 py35hdbc49ba_1", + "mccabe 0.6.1 py35hd8c1f23_1", + "mistune 0.7.4 py35hfd0f961_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py35h0fc7090_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py35h5a16178_2", + "msgpack-python 0.4.8 py35h783f4c8_0", + "multipledispatch 0.4.9 py35h2ff591a_0", + "navigator-updater 0.1.0 py35h2ff6758_0", + "nbconvert 5.3.1 py35hc5194e3_0", + "nbformat 4.4.0 py35h12e6e07_0", + "ncurses 6.0 h06874d7_1", + "networkx 1.11 py35hf333c83_0", + "nltk 3.2.4 py35h7ba7875_0", + "nose 1.3.7 py35hdc64897_2", + "notebook 5.0.0 py35h65c930e_2", + "numba 0.35.0 np113py35_10", + "numexpr 2.6.2 py35h5f89caa_1", + "numpy 1.13.1 py35h8926d81_2", + "numpydoc 0.7.0 py35he089a57_0", + "odo 0.5.1 py35h102315f_0", + "olefile 0.44 py35h2c86149_0", + "openpyxl 2.4.8 py35hd6c89d3_1", + "openssl 1.0.2l h9d1a558_3", + "packaging 16.8 py35h2260b46_1", + "pandas 0.20.3 py35h85c2c75_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py35h1565a15_1", + "pango 1.40.11 hedb6d6b_0", + "partd 0.3.8 py35h68187f2_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py35hb82cfee_0", + "pathlib2 2.3.0 py35hd637de4_0", + "patsy 0.4.1 py35h51b66d5_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py35hee76f29_0", + "pexpect 4.2.1 py35h8b56cb4_0", + "pickleshare 0.7.4 py35hd57304d_0", + "pillow 4.2.1 py35h03abc04_0", + "pip 9.0.1 py35he1b8d41_2", + "pixman 0.34.0 ha72d70b_1", + "pkginfo 1.4.1 py35hb526c55_1", + "ply 3.10 py35h459f1a0_0", + "prompt_toolkit 1.0.15 py35hc09de7a_0", + "psutil 5.2.2 py35h75e6a48_0", + "ptyprocess 0.5.2 py35h38ce0a3_0", + "py 1.4.34 py35hd71111f_1", + "pycodestyle 2.3.1 py35h8d2105a_0", + "pycosat 0.6.2 py35h9693557_1", + "pycparser 2.18 py35h61b3040_1", + "pycrypto 2.6.1 py35h9852db7_1", + "pycurl 7.43.0 py35h7a9665c_3", + "pyflakes 1.5.0 py35h06f3f26_1", + "pygments 2.2.0 py35h0f41973_0", + "pylint 1.7.2 py35hc802fb1_0", + "pyodbc 4.0.17 py35h89a430b_0", + "pyopenssl 17.2.0 py35h1d2a76c_0", + "pyparsing 2.2.0 py35h041ed72_1", + "pyqt 5.6.0 py35h0e41ada_5", + "pysocks 1.6.7 py35h6aefbb0_1", + "pytables 3.4.2 py35hc74b6c3_1", + "pytest 3.2.1 py35hc97c719_1", + "python 3.5.4 h2170f06_12", + "python-dateutil 2.6.1 py35h90d5b31_1", + "pytz 2017.2 py35h9225bff_1", + "pywavelets 0.5.2 py35h53ec731_0", + "pyyaml 3.12 py35h46ef4ae_1", + "pyzmq 16.0.2 py35h4be1f71_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py35hd68ff89_0", + "qtconsole 4.3.1 py35h4626a06_0", + "qtpy 1.3.1 py35h881af26_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py35hb9e6ad1_1", + "rope 0.10.5 py35h31d6b7c_0", + "ruamel_yaml 0.11.14 py35h8e2c16b_2", + "scikit-image 0.13.0 py35h3573165_1", + "scikit-learn 0.19.0 py35h25e8076_2", + "scipy 0.19.1 py35ha8f041b_3", + "seaborn 0.8.0 py35h15a2772_0", + "setuptools 36.5.0 py35ha8c1747_0", + "simplegeneric 0.8.1 py35h2ec4104_0", + "singledispatch 3.4.0.3 py35h0cd4ec3_0", + "sip 4.18.1 py35h9eaea60_2", + "six 1.10.0 py35h5312c1b_1", + "snowballstemmer 1.2.1 py35h5435977_0", + "sortedcollections 0.5.3 py35hb2f60ff_0", + "sortedcontainers 1.5.7 py35h683703c_0", + "sphinx 1.6.3 py35hea25a1c_0", + "sphinxcontrib 1.0 py35hcb7efd2_1", + "sphinxcontrib-websupport 1.0.1 py35h3537809_1", + "spyder 3.2.3 py35h49e6fe2_1", + "sqlalchemy 1.1.13 py35h4911131_0", + "sqlite 3.20.1 h6d8b0f3_1", + "statsmodels 0.8.0 py35haa9d50b_0", + "sympy 1.1.1 py35h919b29a_0", + "tblib 1.3.2 py35hf1eb0b4_0", + "terminado 0.6 py35hce234ed_0", + "testpath 0.3.1 py35had42eaf_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py35h90f1797_0", + "tornado 4.5.2 py35hf879e1d_0", + "traitlets 4.3.2 py35ha522a97_0", + "typing 3.6.2 py35hcadae7e_0", + "unicodecsv 0.14.1 py35h4805c0c_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py35h2ab6e29_0", + "wcwidth 0.1.7 py35hcd08066_0", + "webencodings 0.5.1 py35hb6cf162_1", + "werkzeug 0.12.2 py35hbfc1ea6_0", + "wheel 0.29.0 py35h601ca99_1", + "widgetsnbextension 3.0.2 py35h0be620c_1", + "wrapt 1.10.11 py35hfdafd39_0", + "xlrd 1.1.0 py35h45a0a2a_1", + "xlsxwriter 0.9.8 py35hc9d400f_0", + "xlwt 1.3.0 py35h884a0cf_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.2 py35h00a3a39_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "b1e54c89dd132078aa5127bc8afa91c8", + "name": "anaconda", + "namespace": "python", + "sha256": "597897d273fd2eb0cc19fdcba83bbb7a1d0148f8d7062d78e46708e928e87a1f", + "size": 11763, + "subdir": "linux-64", + "timestamp": 1506428953055, + "version": "5.0.0" + }, + "anaconda-5.0.0-py36h06de3c5_0.conda": { + "build": "py36h06de3c5_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.10 py36h306e16b_0", + "anaconda-client 1.6.5 py36h19c0dcd_0", + "anaconda-navigator 1.6.8 py36h672ccc7_0", + "anaconda-project 0.8.0 py36h29abdf5_0", + "asn1crypto 0.22.0 py36h265ca7c_1", + "astroid 1.5.3 py36hbdb9df2_0", + "astropy 2.0.2 py36ha51211e_4", + "babel 2.5.0 py36h7d14adf_0", + "backports 1.0 py36hfa02d7e_1", + "backports.shutil_get_terminal_size 1.0.0 py36hfea85ff_2", + "beautifulsoup4 4.6.0 py36h49b8c8c_1", + "bitarray 0.8.1 py36h5834eb8_0", + "bkcharts 0.2 py36h735825a_0", + "blaze 0.11.3 py36h4e06776_0", + "bleach 2.0.0 py36h688b259_0", + "bokeh 0.12.7 py36h169c5fd_1", + "boto 2.48.0 py36h6e4cd66_1", + "bottleneck 1.2.1 py36haac1ea0_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 h58b644b_4", + "certifi 2017.7.27.1 py36h8b7b77e_0", + "cffi 1.10.0 py36had8d393_1", + "chardet 3.0.4 py36h0f667ec_1", + "click 6.7 py36h5253387_0", + "cloudpickle 0.4.0 py36h30f8c20_0", + "clyent 1.2.2 py36h7e57e65_1", + "colorama 0.3.9 py36h489cec4_0", + "contextlib2 0.5.5 py36h6c84a62_0", + "cryptography 2.0.3 py36ha225213_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py36h93f1223_0", + "cython 0.26.1 py36h21c49d0_0", + "cytoolz 0.8.2 py36h708bfd4_0", + "dask 0.15.2 py36h9b48dc4_0", + "dask-core 0.15.2 py36h0f988a8_0", + "datashape 0.5.4 py36h3ad6b5c_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py36hd076ac8_0", + "distributed 1.18.3 py36h73cd4ae_0", + "docutils 0.14 py36hb0f60f5_0", + "entrypoints 0.2.3 py36h1aec115_2", + "et_xmlfile 1.0.1 py36hd6bccc3_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py36h5b0c431_0", + "filelock 2.0.12 py36hacfa1f5_0", + "flask 0.12.2 py36hb24657c_0", + "flask-cors 3.0.3 py36h2d857d3_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py36h2fe25dc_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py36h2c1b292_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py36h55090d7_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py36h2d503a6_0", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py36he81ebca_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py36h79797d7_0", + "html5lib 0.999999999 py36h2cfc398_0", + "icu 58.2 h211956c_0", + "idna 2.6 py36h82fb2a8_1", + "imageio 2.2.0 py36he555465_0", + "imagesize 0.7.1 py36h52d8127_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipykernel 4.6.1 py36hbf841aa_0", + "ipython 6.1.0 py36hc72a948_1", + "ipython_genutils 0.2.0 py36hb52b0d5_0", + "ipywidgets 7.0.0 py36h7b55c3a_0", + "isort 4.2.15 py36had401c0_0", + "itsdangerous 0.24 py36h93cc618_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py36h4c697fb_0", + "jedi 0.10.2 py36h552def0_0", + "jinja2 2.9.6 py36h489bce4_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py36h006f8b5_0", + "jupyter 1.0.0 py36h9896ce5_0", + "jupyter_client 5.1.0 py36h614e9ea_0", + "jupyter_console 5.2.0 py36he59e554_1", + "jupyter_core 4.3.0 py36h357a921_0", + "jupyterlab 0.27.0 py36h86377d0_2", + "jupyterlab_launcher 0.4.0 py36h4d8058d_0", + "lazy-object-proxy 1.3.1 py36h10fcdad_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 hcbc56d2_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h24385c6_1", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 he6ee5dd_2", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py36_0", + "locket 0.2.0 py36h787c0ad_1", + "lxml 3.8.0 py36h6c6e760_0", + "lzo 2.10 hc0eb8fc_0", + "markupsafe 1.0 py36hd9260cd_1", + "matplotlib 2.0.2 py36h2acb4ad_1", + "mccabe 0.6.1 py36h5ad9710_1", + "mistune 0.7.4 py36hbab8784_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py36h17a0993_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py36h8cc018b_2", + "msgpack-python 0.4.8 py36hec4c5d1_0", + "multipledispatch 0.4.9 py36h41da3fb_0", + "navigator-updater 0.1.0 py36h14770f7_0", + "nbconvert 5.3.1 py36hb41ffb7_0", + "nbformat 4.4.0 py36h31c9010_0", + "ncurses 6.0 h06874d7_1", + "networkx 1.11 py36hfb3574a_0", + "nltk 3.2.4 py36h1a0979f_0", + "nose 1.3.7 py36hcdf7029_2", + "notebook 5.0.0 py36h0b20546_2", + "numba 0.35.0 np113py36_10", + "numexpr 2.6.2 py36hdd3393f_1", + "numpy 1.13.1 py36h5bc529a_2", + "numpydoc 0.7.0 py36h18f165f_0", + "odo 0.5.1 py36h90ed295_0", + "olefile 0.44 py36h79f9f78_0", + "openpyxl 2.4.8 py36h41dd2a8_1", + "openssl 1.0.2l h9d1a558_3", + "packaging 16.8 py36ha668100_1", + "pandas 0.20.3 py36h842e28d_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py36ha6701b7_1", + "pango 1.40.11 hedb6d6b_0", + "partd 0.3.8 py36h36fd896_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py36he0c6f6d_0", + "pathlib2 2.3.0 py36h49efa8e_0", + "patsy 0.4.1 py36ha3be15e_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py36h26ade29_0", + "pexpect 4.2.1 py36h3b9d41b_0", + "pickleshare 0.7.4 py36h63277f8_0", + "pillow 4.2.1 py36h9119f52_0", + "pip 9.0.1 py36h30f8307_2", + "pixman 0.34.0 ha72d70b_1", + "pkginfo 1.4.1 py36h215d178_1", + "ply 3.10 py36hed35086_0", + "prompt_toolkit 1.0.15 py36h17d85b1_0", + "psutil 5.2.2 py36h74c8701_0", + "ptyprocess 0.5.2 py36h69acd42_0", + "py 1.4.34 py36h0712aa3_1", + "pycodestyle 2.3.1 py36hf609f19_0", + "pycosat 0.6.2 py36h1a0ea17_1", + "pycparser 2.18 py36hf9f622e_1", + "pycrypto 2.6.1 py36h6998063_1", + "pycurl 7.43.0 py36h5e72054_3", + "pyflakes 1.5.0 py36h5510808_1", + "pygments 2.2.0 py36h0d3125c_0", + "pylint 1.7.2 py36h484ab97_0", + "pyodbc 4.0.17 py36h999153c_0", + "pyopenssl 17.2.0 py36h5cc804b_0", + "pyparsing 2.2.0 py36hee85983_1", + "pyqt 5.6.0 py36h0386399_5", + "pysocks 1.6.7 py36hd97a5b1_1", + "pytables 3.4.2 py36hdce54c9_1", + "pytest 3.2.1 py36h11ad3bb_1", + "python 3.6.2 h02fb82a_12", + "python-dateutil 2.6.1 py36h88d3b88_1", + "pytz 2017.2 py36hc2ccc2a_1", + "pywavelets 0.5.2 py36he602eb0_0", + "pyyaml 3.12 py36hafb9ca4_1", + "pyzmq 16.0.2 py36h3b0cf96_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py36h609ed8c_0", + "qtconsole 4.3.1 py36h8f73b5b_0", + "qtpy 1.3.1 py36h3691cc8_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py36he2e5f8d_1", + "rope 0.10.5 py36h1f8c17e_0", + "ruamel_yaml 0.11.14 py36ha2fb22d_2", + "scikit-image 0.13.0 py36had3c07a_1", + "scikit-learn 0.19.0 py36h97ac459_2", + "scipy 0.19.1 py36h9976243_3", + "seaborn 0.8.0 py36h197244f_0", + "setuptools 36.5.0 py36he42e2e1_0", + "simplegeneric 0.8.1 py36h2cb9092_0", + "singledispatch 3.4.0.3 py36h7a266c3_0", + "sip 4.18.1 py36h51ed4ed_2", + "six 1.10.0 py36hcac75e4_1", + "snowballstemmer 1.2.1 py36h6febd40_0", + "sortedcollections 0.5.3 py36h3c761f9_0", + "sortedcontainers 1.5.7 py36hdf89491_0", + "sphinx 1.6.3 py36he5f0bdb_0", + "sphinxcontrib 1.0 py36h6d0f590_1", + "sphinxcontrib-websupport 1.0.1 py36hb5cb234_1", + "spyder 3.2.3 py36he38cbf7_1", + "sqlalchemy 1.1.13 py36hfb5efd7_0", + "sqlite 3.20.1 h6d8b0f3_1", + "statsmodels 0.8.0 py36h8533d0b_0", + "sympy 1.1.1 py36hc6d1c1c_0", + "tblib 1.3.2 py36h34cf8b6_0", + "terminado 0.6 py36ha25a19f_0", + "testpath 0.3.1 py36h8cadb63_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py36h81f2dff_0", + "tornado 4.5.2 py36h1283b2a_0", + "traitlets 4.3.2 py36h674d592_0", + "typing 3.6.2 py36h7da032a_0", + "unicodecsv 0.14.1 py36ha668878_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py36hbe7ace6_0", + "wcwidth 0.1.7 py36hdf4376a_0", + "webencodings 0.5.1 py36h800622e_1", + "werkzeug 0.12.2 py36hc703753_0", + "wheel 0.29.0 py36he7f4e38_1", + "widgetsnbextension 3.0.2 py36hd01bb71_1", + "wrapt 1.10.11 py36h28b7045_0", + "xlrd 1.1.0 py36h1db9f0c_1", + "xlsxwriter 0.9.8 py36hf41c223_0", + "xlwt 1.3.0 py36h7b00a1f_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.2 py36ha0d441b_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "73d1b476df1d96b833e56a2989c766cf", + "name": "anaconda", + "namespace": "python", + "sha256": "8b4f6e5bdee20c9c58262bcffa4c122d536ba42b8a2c3dd53aaf16bf2b70de82", + "size": 11621, + "subdir": "linux-64", + "timestamp": 1506429096109, + "version": "5.0.0" + }, + "anaconda-5.0.0.1-py27h1e3bc52_1.conda": { + "build": "py27h1e3bc52_1", + "build_number": 1, + "depends": [ + "alabaster 0.7.10 py27he5a193a_0", + "anaconda-client 1.6.5 py27hc8169bf_0", + "anaconda-navigator 1.6.8 py27h2ea4365_0", + "anaconda-project 0.8.0 py27hd7a9a97_0", + "asn1crypto 0.22.0 py27h94ebe91_1", + "astroid 1.5.3 py27h8f8f47c_0", + "astropy 2.0.2 py27h57072c0_4", + "babel 2.5.0 py27h20693cd_0", + "backports 1.0 py27h63c9359_1", + "backports.functools_lru_cache 1.4 py27he8db605_1", + "backports.shutil_get_terminal_size 1.0.0 py27h5bc021e_2", + "backports_abc 0.5 py27h7b3c97b_0", + "beautifulsoup4 4.6.0 py27h3f86ba9_1", + "bitarray 0.8.1 py27h304d4c6_0", + "bkcharts 0.2 py27h241ae91_0", + "blaze 0.11.3 py27h5f341da_0", + "bleach 2.0.0 py27h3a0dcc8_0", + "bokeh 0.12.7 py27he0197c9_1", + "boto 2.48.0 py27h9556ac2_1", + "bottleneck 1.2.1 py27h21b16a3_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 h58b644b_4", + "cdecimal 2.3 py27h4e63abe_1", + "certifi 2017.7.27.1 py27h9ceb091_0", + "cffi 1.10.0 py27hf1aaaf4_1", + "chardet 3.0.4 py27hfa10054_1", + "click 6.7 py27h4225b90_0", + "cloudpickle 0.4.0 py27ha64365b_0", + "clyent 1.2.2 py27h7276e6c_1", + "colorama 0.3.9 py27h5cde069_0", + "configparser 3.5.0 py27h5117587_0", + "contextlib2 0.5.5 py27hbf4c468_0", + "cryptography 2.0.3 py27hea39389_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py27hc7354d3_0", + "cython 0.26.1 py27hdbcff32_0", + "cytoolz 0.8.2 py27hf14aec9_0", + "dask 0.15.2 py27h7693082_0", + "dask-core 0.15.2 py27heedc4a4_0", + "datashape 0.5.4 py27hf507385_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py27h1544723_0", + "distributed 1.18.3 py27h5e7c565_0", + "docutils 0.14 py27hae222c1_0", + "entrypoints 0.2.3 py27h502b47d_2", + "enum34 1.1.6 py27h99a27e9_1", + "et_xmlfile 1.0.1 py27h75840f5_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py27h4cb8e01_0", + "filelock 2.0.12 py27h38fa839_0", + "flask 0.12.2 py27h6d5c1cd_0", + "flask-cors 3.0.3 py27h1a8a27f_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "funcsigs 1.0.2 py27h83f16ab_0", + "functools32 3.2.3.2 py27h4ead58f_1", + "futures 3.1.1 py27hdbc8cbb_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py27h475ea6a_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py27hd3b7d1f_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py27hc856308_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py27hac09c53_0", + "grin 1.2.1 py27h54abee7_1", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py27h71d1790_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py27h33770af_0", + "html5lib 0.999999999 py27hdf15f34_0", + "icu 58.2 h211956c_0", + "idna 2.6 py27h5722d68_1", + "imageio 2.2.0 py27hf108a7f_0", + "imagesize 0.7.1 py27hd17bf80_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipaddress 1.0.18 py27h337fd85_0", + "ipykernel 4.6.1 py27hc93e584_0", + "ipython 5.4.1 py27h36c99b6_1", + "ipython_genutils 0.2.0 py27h89fb69b_0", + "ipywidgets 7.0.0 py27h4fda95d_0", + "isort 4.2.15 py27hcfa4749_0", + "itsdangerous 0.24 py27hb8295c1_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py27h2cc5433_0", + "jedi 0.10.2 py27h8af4e35_0", + "jinja2 2.9.6 py27h82327ae_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py27h7ed5aa4_0", + "jupyter 1.0.0 py27h505fd4b_0", + "jupyter_client 5.1.0 py27hbee1118_0", + "jupyter_console 5.2.0 py27hc6bee7e_1", + "jupyter_core 4.3.0 py27hcd9ae3a_0", + "jupyterlab 0.27.0 py27h42ebfef_2", + "jupyterlab_launcher 0.4.0 py27h0e16d15_0", + "lazy-object-proxy 1.3.1 py27h682c727_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 hcbc56d2_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h24385c6_1", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 he6ee5dd_2", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py27_0", + "locket 0.2.0 py27h73929a2_1", + "lxml 3.8.0 py27hb3ac1f5_0", + "lzo 2.10 hc0eb8fc_0", + "markupsafe 1.0 py27h97b2822_1", + "matplotlib 2.0.2 py27h334a7c2_1", + "mccabe 0.6.1 py27h0e7c7be_1", + "mistune 0.7.4 py27h6da7e90_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py27hb2d42c5_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py27h4bb41bd_2", + "msgpack-python 0.4.8 py27hc2fa789_0", + "multipledispatch 0.4.9 py27h9b5f95a_0", + "navigator-updater 0.1.0 py27h0f9cd39_0", + "nbconvert 5.3.1 py27he041f76_0", + "nbformat 4.4.0 py27hed7f2b2_0", + "ncurses 6.0 h06874d7_1", + "networkx 1.11 py27h7358325_0", + "nltk 3.2.4 py27h41293c3_0", + "nose 1.3.7 py27heec2199_2", + "notebook 5.0.0 py27h3661c2b_2", + "numba 0.35.0 np113py27_10", + "numexpr 2.6.2 py27he5efce1_1", + "numpy 1.13.1 py27hd1b6e02_2", + "numpydoc 0.7.0 py27h9647a75_0", + "odo 0.5.1 py27h9170de3_0", + "olefile 0.44 py27h4bd3e3c_0", + "openpyxl 2.4.8 py27h9f0c937_1", + "openssl 1.0.2l h9d1a558_3", + "packaging 16.8 py27h5e07c7c_1", + "pandas 0.20.3 py27h820b67f_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py27h428e1e5_1", + "pango 1.40.11 hedb6d6b_0", + "partd 0.3.8 py27h4e55004_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py27hc258cac_0", + "pathlib2 2.3.0 py27h6e9d198_0", + "patsy 0.4.1 py27hd1cf8c0_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py27h444351c_0", + "pexpect 4.2.1 py27hcf82287_0", + "pickleshare 0.7.4 py27h09770e1_0", + "pillow 4.2.1 py27h7cd2321_0", + "pip 9.0.1 py27h4c18a59_2", + "pixman 0.34.0 ha72d70b_1", + "pkginfo 1.4.1 py27hee1a9ad_1", + "ply 3.10 py27hd6d9ae5_0", + "prompt_toolkit 1.0.15 py27h1b593e1_0", + "psutil 5.2.2 py27h9b5ba61_0", + "ptyprocess 0.5.2 py27h4ccb14c_0", + "py 1.4.34 py27he5894e4_1", + "pycairo 1.13.3 py27hea6d626_0", + "pycodestyle 2.3.1 py27h904819d_0", + "pycosat 0.6.2 py27h1cf261c_1", + "pycparser 2.18 py27hefa08c5_1", + "pycrypto 2.6.1 py27h9abbf5c_1", + "pycurl 7.43.0 py27hcf8ebea_3", + "pyflakes 1.5.0 py27hfba2528_1", + "pygments 2.2.0 py27h4a8b6f5_0", + "pylint 1.7.2 py27h77e98c6_0", + "pyodbc 4.0.17 py27h7f7627d_0", + "pyopenssl 17.2.0 py27h189ff3b_0", + "pyparsing 2.2.0 py27hf1513f8_1", + "pyqt 5.6.0 py27h4b1e83c_5", + "pysocks 1.6.7 py27he2db6d2_1", + "pytables 3.4.2 py27ha79ee23_1", + "pytest 3.2.1 py27h98000ae_1", + "python 2.7.13 heccc3f1_16", + "python-dateutil 2.6.1 py27h4ca5741_1", + "pytz 2017.2 py27hcac29fa_1", + "pywavelets 0.5.2 py27hecda097_0", + "pyyaml 3.12 py27h2d70dd7_1", + "pyzmq 16.0.2 py27h297844f_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py27hd7914c3_0", + "qtconsole 4.3.1 py27hc444b0d_0", + "qtpy 1.3.1 py27h63d3751_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py27hc5b0589_1", + "rope 0.10.5 py27hcb0a616_0", + "ruamel_yaml 0.11.14 py27h672d447_2", + "scandir 1.5 py27h1c9e1f8_1", + "scikit-image 0.13.0 py27h06cb35d_1", + "scikit-learn 0.19.0 py27hd893acb_2", + "scipy 0.19.1 py27h1edc525_3", + "seaborn 0.8.0 py27h9d2aaa1_0", + "setuptools 36.5.0 py27h68b189e_0", + "simplegeneric 0.8.1 py27h19e43cd_0", + "singledispatch 3.4.0.3 py27h9bcb476_0", + "sip 4.18.1 py27he9ba0ab_2", + "six 1.10.0 py27hdcd7534_1", + "snowballstemmer 1.2.1 py27h44e2768_0", + "sortedcollections 0.5.3 py27h135218e_0", + "sortedcontainers 1.5.7 py27he59936f_0", + "sphinx 1.6.3 py27hf9b1778_0", + "sphinxcontrib 1.0 py27h1512b58_1", + "sphinxcontrib-websupport 1.0.1 py27hf906f22_1", + "spyder 3.2.3 py27hbf281d3_1", + "sqlalchemy 1.1.13 py27hb0a01da_0", + "sqlite 3.20.1 h6d8b0f3_1", + "ssl_match_hostname 3.5.0.1 py27h4ec10b9_2", + "statsmodels 0.8.0 py27hc87d62d_0", + "subprocess32 3.2.7 py27h373dbce_0", + "sympy 1.1.1 py27hc28188a_0", + "tblib 1.3.2 py27h51fe5ba_0", + "terminado 0.6 py27h4be8df9_0", + "testpath 0.3.1 py27hc38d2c4_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py27hd3b1e7e_0", + "tornado 4.5.2 py27h97b179f_0", + "traitlets 4.3.2 py27hd6ce930_0", + "typing 3.6.2 py27h66f49e2_0", + "unicodecsv 0.14.1 py27h5062da9_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py27ha55213b_0", + "wcwidth 0.1.7 py27h9e3e1ab_0", + "webencodings 0.5.1 py27hff10b21_1", + "werkzeug 0.12.2 py27hbf75dff_0", + "wheel 0.29.0 py27h411dd7b_1", + "widgetsnbextension 3.0.2 py27hcb77dec_1", + "wrapt 1.10.11 py27h04f6869_0", + "xlrd 1.1.0 py27ha77178f_1", + "xlsxwriter 0.9.8 py27h260ecd4_0", + "xlwt 1.3.0 py27h3d85d97_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.2 py27hd58a209_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "d206294533990d3e8d584067472ae0fb", + "name": "anaconda", + "namespace": "python", + "sha256": "26a0253c4cdf0d2c2f5ab4da949b1328cf38efe4fb86ed3b370aee43c0e8003b", + "size": 12204, + "subdir": "linux-64", + "timestamp": 1506833783638, + "version": "5.0.0.1" + }, + "anaconda-5.0.0.1-py27hfd10420_0.conda": { + "build": "py27hfd10420_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.10 py27he5a193a_0", + "anaconda-client 1.6.5 py27hc8169bf_0", + "anaconda-navigator 1.6.8 py27h2ea4365_0", + "anaconda-project 0.8.0 py27hd7a9a97_0", + "asn1crypto 0.22.0 py27h94ebe91_1", + "astroid 1.5.3 py27h8f8f47c_0", + "astropy 2.0.2 py27h57072c0_4", + "babel 2.5.0 py27h20693cd_0", + "backports 1.0 py27h63c9359_1", + "backports.functools_lru_cache 1.4 py27he8db605_1", + "backports.shutil_get_terminal_size 1.0.0 py27h5bc021e_2", + "backports_abc 0.5 py27h7b3c97b_0", + "beautifulsoup4 4.6.0 py27h3f86ba9_1", + "bitarray 0.8.1 py27h304d4c6_0", + "bkcharts 0.2 py27h241ae91_0", + "blaze 0.11.3 py27h5f341da_0", + "bleach 2.0.0 py27h3a0dcc8_0", + "bokeh 0.12.7 py27he0197c9_1", + "boto 2.48.0 py27h9556ac2_1", + "bottleneck 1.2.1 py27h21b16a3_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 h58b644b_4", + "cdecimal 2.3 py27h4e63abe_1", + "certifi 2017.7.27.1 py27h9ceb091_0", + "cffi 1.10.0 py27hf1aaaf4_1", + "chardet 3.0.4 py27hfa10054_1", + "click 6.7 py27h4225b90_0", + "cloudpickle 0.4.0 py27ha64365b_0", + "clyent 1.2.2 py27h7276e6c_1", + "colorama 0.3.9 py27h5cde069_0", + "configparser 3.5.0 py27h5117587_0", + "contextlib2 0.5.5 py27hbf4c468_0", + "cryptography 2.0.3 py27hea39389_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py27hc7354d3_0", + "cython 0.26.1 py27hdbcff32_0", + "cytoolz 0.8.2 py27hf14aec9_0", + "dask 0.15.2 py27h7693082_0", + "dask-core 0.15.2 py27heedc4a4_0", + "datashape 0.5.4 py27hf507385_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py27h1544723_0", + "distributed 1.18.3 py27h5e7c565_0", + "docutils 0.14 py27hae222c1_0", + "entrypoints 0.2.3 py27h502b47d_2", + "enum34 1.1.6 py27h99a27e9_1", + "et_xmlfile 1.0.1 py27h75840f5_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py27h4cb8e01_0", + "filelock 2.0.12 py27h38fa839_0", + "flask 0.12.2 py27h6d5c1cd_0", + "flask-cors 3.0.3 py27h1a8a27f_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "funcsigs 1.0.2 py27h83f16ab_0", + "functools32 3.2.3.2 py27h4ead58f_1", + "futures 3.1.1 py27hdbc8cbb_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py27h475ea6a_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py27hd3b7d1f_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py27hc856308_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py27hac09c53_0", + "grin 1.2.1 py27h54abee7_1", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py27h71d1790_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py27h33770af_0", + "html5lib 0.999999999 py27hdf15f34_0", + "icu 58.2 h211956c_0", + "idna 2.6 py27h5722d68_1", + "imageio 2.2.0 py27hf108a7f_0", + "imagesize 0.7.1 py27hd17bf80_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipaddress 1.0.18 py27h337fd85_0", + "ipykernel 4.6.1 py27hc93e584_0", + "ipython 5.4.1 py27h36c99b6_1", + "ipython_genutils 0.2.0 py27h89fb69b_0", + "ipywidgets 7.0.0 py27h4fda95d_0", + "isort 4.2.15 py27hcfa4749_0", + "itsdangerous 0.24 py27hb8295c1_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py27h2cc5433_0", + "jedi 0.10.2 py27h8af4e35_0", + "jinja2 2.9.6 py27h82327ae_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py27h7ed5aa4_0", + "jupyter 1.0.0 py27h505fd4b_0", + "jupyter_client 5.1.0 py27hbee1118_0", + "jupyter_console 5.2.0 py27hc6bee7e_1", + "jupyter_core 4.3.0 py27hcd9ae3a_0", + "jupyterlab 0.27.0 py27h42ebfef_2", + "jupyterlab_launcher 0.4.0 py27h0e16d15_0", + "lazy-object-proxy 1.3.1 py27h682c727_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 hcbc56d2_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h24385c6_1", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 he6ee5dd_2", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py27_0", + "locket 0.2.0 py27h73929a2_1", + "lxml 3.8.0 py27hb3ac1f5_0", + "lzo 2.10 hc0eb8fc_0", + "markupsafe 1.0 py27h97b2822_1", + "matplotlib 2.0.2 py27h334a7c2_1", + "mccabe 0.6.1 py27h0e7c7be_1", + "mistune 0.7.4 py27h6da7e90_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py27hb2d42c5_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py27h4bb41bd_2", + "msgpack-python 0.4.8 py27hc2fa789_0", + "multipledispatch 0.4.9 py27h9b5f95a_0", + "navigator-updater 0.1.0 py27h0f9cd39_0", + "nbconvert 5.3.1 py27he041f76_0", + "nbformat 4.4.0 py27hed7f2b2_0", + "ncurses 6.0 h06874d7_1", + "networkx 1.11 py27h7358325_0", + "nltk 3.2.4 py27h41293c3_0", + "nose 1.3.7 py27heec2199_2", + "notebook 5.0.0 py27h3661c2b_2", + "numba 0.35.0 np113py27_10", + "numexpr 2.6.2 py27he5efce1_1", + "numpy 1.13.1 py27hd1b6e02_2", + "numpydoc 0.7.0 py27h9647a75_0", + "odo 0.5.1 py27h9170de3_0", + "olefile 0.44 py27h4bd3e3c_0", + "openpyxl 2.4.8 py27h9f0c937_1", + "openssl 1.0.2l h9d1a558_3", + "packaging 16.8 py27h5e07c7c_1", + "pandas 0.20.3 py27h820b67f_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py27h428e1e5_1", + "pango 1.40.11 hedb6d6b_0", + "partd 0.3.8 py27h4e55004_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py27hc258cac_0", + "pathlib2 2.3.0 py27h6e9d198_0", + "patsy 0.4.1 py27hd1cf8c0_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py27h444351c_0", + "pexpect 4.2.1 py27hcf82287_0", + "pickleshare 0.7.4 py27h09770e1_0", + "pillow 4.2.1 py27h7cd2321_0", + "pip 9.0.1 py27h4c18a59_2", + "pixman 0.34.0 ha72d70b_1", + "pkginfo 1.4.1 py27hee1a9ad_1", + "ply 3.10 py27hd6d9ae5_0", + "prompt_toolkit 1.0.15 py27h1b593e1_0", + "psutil 5.2.2 py27h9b5ba61_0", + "ptyprocess 0.5.2 py27h4ccb14c_0", + "py 1.4.34 py27he5894e4_1", + "pycairo 1.13.3 py27hea6d626_0", + "pycodestyle 2.3.1 py27h904819d_0", + "pycosat 0.6.2 py27h1cf261c_1", + "pycparser 2.18 py27hefa08c5_1", + "pycrypto 2.6.1 py27h9abbf5c_1", + "pycurl 7.43.0 py27hcf8ebea_3", + "pyflakes 1.5.0 py27hfba2528_1", + "pygments 2.2.0 py27h4a8b6f5_0", + "pylint 1.7.2 py27h77e98c6_0", + "pyodbc 4.0.17 py27h7f7627d_0", + "pyopenssl 17.2.0 py27h189ff3b_0", + "pyparsing 2.2.0 py27hf1513f8_1", + "pyqt 5.6.0 py27h4b1e83c_5", + "pysocks 1.6.7 py27he2db6d2_1", + "pytables 3.4.2 py27ha79ee23_1", + "pytest 3.2.1 py27h98000ae_1", + "python 2.7.13 hac47a24_15", + "python-dateutil 2.6.1 py27h4ca5741_1", + "pytz 2017.2 py27hcac29fa_1", + "pywavelets 0.5.2 py27hecda097_0", + "pyyaml 3.12 py27h2d70dd7_1", + "pyzmq 16.0.2 py27h297844f_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py27hd7914c3_0", + "qtconsole 4.3.1 py27hc444b0d_0", + "qtpy 1.3.1 py27h63d3751_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py27hc5b0589_1", + "rope 0.10.5 py27hcb0a616_0", + "ruamel_yaml 0.11.14 py27h672d447_2", + "scandir 1.5 py27h1c9e1f8_1", + "scikit-image 0.13.0 py27h06cb35d_1", + "scikit-learn 0.19.0 py27hd893acb_2", + "scipy 0.19.1 py27h1edc525_3", + "seaborn 0.8.0 py27h9d2aaa1_0", + "setuptools 36.5.0 py27h68b189e_0", + "simplegeneric 0.8.1 py27h19e43cd_0", + "singledispatch 3.4.0.3 py27h9bcb476_0", + "sip 4.18.1 py27he9ba0ab_2", + "six 1.10.0 py27hdcd7534_1", + "snowballstemmer 1.2.1 py27h44e2768_0", + "sortedcollections 0.5.3 py27h135218e_0", + "sortedcontainers 1.5.7 py27he59936f_0", + "sphinx 1.6.3 py27hf9b1778_0", + "sphinxcontrib 1.0 py27h1512b58_1", + "sphinxcontrib-websupport 1.0.1 py27hf906f22_1", + "spyder 3.2.3 py27hbf281d3_1", + "sqlalchemy 1.1.13 py27hb0a01da_0", + "sqlite 3.20.1 h6d8b0f3_1", + "ssl_match_hostname 3.5.0.1 py27h4ec10b9_2", + "statsmodels 0.8.0 py27hc87d62d_0", + "subprocess32 3.2.7 py27h373dbce_0", + "sympy 1.1.1 py27hc28188a_0", + "tblib 1.3.2 py27h51fe5ba_0", + "terminado 0.6 py27h4be8df9_0", + "testpath 0.3.1 py27hc38d2c4_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py27hd3b1e7e_0", + "tornado 4.5.2 py27h97b179f_0", + "traitlets 4.3.2 py27hd6ce930_0", + "typing 3.6.2 py27h66f49e2_0", + "unicodecsv 0.14.1 py27h5062da9_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py27ha55213b_0", + "wcwidth 0.1.7 py27h9e3e1ab_0", + "webencodings 0.5.1 py27hff10b21_1", + "werkzeug 0.12.2 py27hbf75dff_0", + "wheel 0.29.0 py27h411dd7b_1", + "widgetsnbextension 3.0.2 py27hcb77dec_1", + "wrapt 1.10.11 py27h04f6869_0", + "xlrd 1.1.0 py27ha77178f_1", + "xlsxwriter 0.9.8 py27h260ecd4_0", + "xlwt 1.3.0 py27h3d85d97_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.2 py27hd58a209_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "ef309a0b526477b8239e86edc82ad9c7", + "name": "anaconda", + "namespace": "python", + "sha256": "e540b2d7ee71a27750b54eac312dca3f3946cfa57814438764d74dfafeb371b9", + "size": 12188, + "subdir": "linux-64", + "timestamp": 1506715108696, + "version": "5.0.0.1" + }, + "anaconda-5.0.0.1-py35h1ed3d8c_0.conda": { + "build": "py35h1ed3d8c_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.10 py35h6fb19ab_0", + "anaconda-client 1.6.5 py35hd900ed1_0", + "anaconda-navigator 1.6.8 py35haed54dd_0", + "anaconda-project 0.8.0 py35hb597f32_0", + "asn1crypto 0.22.0 py35h0d675fe_1", + "astroid 1.5.3 py35h1d0c565_0", + "astropy 2.0.2 py35h2d2a8a6_4", + "babel 2.5.0 py35ha5fc564_0", + "backports 1.0 py35hd471ac7_1", + "backports.shutil_get_terminal_size 1.0.0 py35h40844db_2", + "beautifulsoup4 4.6.0 py35h442a8c9_1", + "bitarray 0.8.1 py35h7540340_0", + "bkcharts 0.2 py35he4f7e30_0", + "blaze 0.11.3 py35ha2c9137_0", + "bleach 2.0.0 py35h055c768_0", + "bokeh 0.12.7 py35h4751c18_1", + "boto 2.48.0 py35h2cfd601_1", + "bottleneck 1.2.1 py35he1b16f1_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 h58b644b_4", + "certifi 2017.7.27.1 py35h19f42a1_0", + "cffi 1.10.0 py35h796c292_1", + "chardet 3.0.4 py35hb6e9ddf_1", + "click 6.7 py35h353a69f_0", + "cloudpickle 0.4.0 py35h10376d1_0", + "clyent 1.2.2 py35h491ffcb_1", + "colorama 0.3.9 py35h81e2b6c_0", + "contextlib2 0.5.5 py35h6690dba_0", + "cryptography 2.0.3 py35hef72dfd_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py35hc4d5149_0", + "cython 0.26.1 py35h636ebcb_0", + "cytoolz 0.8.2 py35ha53021f_0", + "dask 0.15.2 py35h08b2748_0", + "dask-core 0.15.2 py35h79caba8_0", + "datashape 0.5.4 py35h5b068ae_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py35h3a268aa_0", + "distributed 1.18.3 py35h076cbad_0", + "docutils 0.14 py35hd11081d_0", + "entrypoints 0.2.3 py35h48174a2_2", + "et_xmlfile 1.0.1 py35hde8d43e_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py35hec2bbaa_0", + "filelock 2.0.12 py35h7855d60_0", + "flask 0.12.2 py35h679e90e_0", + "flask-cors 3.0.3 py35h9b2065d_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py35he064abf_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py35h98a1f2a_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py35h89a7545_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py35h2547b41_0", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py35h41d5d6e_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py35h51e6c10_0", + "html5lib 0.999999999 py35h0543385_0", + "icu 58.2 h211956c_0", + "idna 2.6 py35h8605a33_1", + "imageio 2.2.0 py35hd0a6de2_0", + "imagesize 0.7.1 py35hf008fae_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipykernel 4.6.1 py35h29d130c_0", + "ipython 6.1.0 py35h1b71439_1", + "ipython_genutils 0.2.0 py35hc9e07d0_0", + "ipywidgets 7.0.0 py35h8ebd919_0", + "isort 4.2.15 py35h44a00d2_0", + "itsdangerous 0.24 py35h7c46880_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py35hf1f7175_0", + "jedi 0.10.2 py35hc33c70f_0", + "jinja2 2.9.6 py35h90b8645_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py35h4395190_0", + "jupyter 1.0.0 py35hd38625c_0", + "jupyter_client 5.1.0 py35h2bff583_0", + "jupyter_console 5.2.0 py35h4044a63_1", + "jupyter_core 4.3.0 py35he2f7985_0", + "jupyterlab 0.27.0 py35h29561ed_2", + "jupyterlab_launcher 0.4.0 py35ha4e430f_0", + "lazy-object-proxy 1.3.1 py35h4c720c6_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 hcbc56d2_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h24385c6_1", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 he6ee5dd_2", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py35_0", + "locket 0.2.0 py35h170bc82_1", + "lxml 3.8.0 py35h4935ab9_0", + "lzo 2.10 hc0eb8fc_0", + "markupsafe 1.0 py35h4f4fcf6_1", + "matplotlib 2.0.2 py35hdbc49ba_1", + "mccabe 0.6.1 py35hd8c1f23_1", + "mistune 0.7.4 py35hfd0f961_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py35h0fc7090_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py35h5a16178_2", + "msgpack-python 0.4.8 py35h783f4c8_0", + "multipledispatch 0.4.9 py35h2ff591a_0", + "navigator-updater 0.1.0 py35h2ff6758_0", + "nbconvert 5.3.1 py35hc5194e3_0", + "nbformat 4.4.0 py35h12e6e07_0", + "ncurses 6.0 h06874d7_1", + "networkx 1.11 py35hf333c83_0", + "nltk 3.2.4 py35h7ba7875_0", + "nose 1.3.7 py35hdc64897_2", + "notebook 5.0.0 py35h65c930e_2", + "numba 0.35.0 np113py35_10", + "numexpr 2.6.2 py35h5f89caa_1", + "numpy 1.13.1 py35h8926d81_2", + "numpydoc 0.7.0 py35he089a57_0", + "odo 0.5.1 py35h102315f_0", + "olefile 0.44 py35h2c86149_0", + "openpyxl 2.4.8 py35hd6c89d3_1", + "openssl 1.0.2l h9d1a558_3", + "packaging 16.8 py35h2260b46_1", + "pandas 0.20.3 py35h85c2c75_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py35h1565a15_1", + "pango 1.40.11 hedb6d6b_0", + "partd 0.3.8 py35h68187f2_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py35hb82cfee_0", + "pathlib2 2.3.0 py35hd637de4_0", + "patsy 0.4.1 py35h51b66d5_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py35hee76f29_0", + "pexpect 4.2.1 py35h8b56cb4_0", + "pickleshare 0.7.4 py35hd57304d_0", + "pillow 4.2.1 py35h03abc04_0", + "pip 9.0.1 py35he1b8d41_2", + "pixman 0.34.0 ha72d70b_1", + "pkginfo 1.4.1 py35hb526c55_1", + "ply 3.10 py35h459f1a0_0", + "prompt_toolkit 1.0.15 py35hc09de7a_0", + "psutil 5.2.2 py35h75e6a48_0", + "ptyprocess 0.5.2 py35h38ce0a3_0", + "py 1.4.34 py35hd71111f_1", + "pycodestyle 2.3.1 py35h8d2105a_0", + "pycosat 0.6.2 py35h9693557_1", + "pycparser 2.18 py35h61b3040_1", + "pycrypto 2.6.1 py35h9852db7_1", + "pycurl 7.43.0 py35h7a9665c_3", + "pyflakes 1.5.0 py35h06f3f26_1", + "pygments 2.2.0 py35h0f41973_0", + "pylint 1.7.2 py35hc802fb1_0", + "pyodbc 4.0.17 py35h89a430b_0", + "pyopenssl 17.2.0 py35h1d2a76c_0", + "pyparsing 2.2.0 py35h041ed72_1", + "pyqt 5.6.0 py35h0e41ada_5", + "pysocks 1.6.7 py35h6aefbb0_1", + "pytables 3.4.2 py35hc74b6c3_1", + "pytest 3.2.1 py35hc97c719_1", + "python 3.5.4 hc053d89_14", + "python-dateutil 2.6.1 py35h90d5b31_1", + "pytz 2017.2 py35h9225bff_1", + "pywavelets 0.5.2 py35h53ec731_0", + "pyyaml 3.12 py35h46ef4ae_1", + "pyzmq 16.0.2 py35h4be1f71_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py35hd68ff89_0", + "qtconsole 4.3.1 py35h4626a06_0", + "qtpy 1.3.1 py35h881af26_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py35hb9e6ad1_1", + "rope 0.10.5 py35h31d6b7c_0", + "ruamel_yaml 0.11.14 py35h8e2c16b_2", + "scikit-image 0.13.0 py35h3573165_1", + "scikit-learn 0.19.0 py35h25e8076_2", + "scipy 0.19.1 py35ha8f041b_3", + "seaborn 0.8.0 py35h15a2772_0", + "setuptools 36.5.0 py35ha8c1747_0", + "simplegeneric 0.8.1 py35h2ec4104_0", + "singledispatch 3.4.0.3 py35h0cd4ec3_0", + "sip 4.18.1 py35h9eaea60_2", + "six 1.10.0 py35h5312c1b_1", + "snowballstemmer 1.2.1 py35h5435977_0", + "sortedcollections 0.5.3 py35hb2f60ff_0", + "sortedcontainers 1.5.7 py35h683703c_0", + "sphinx 1.6.3 py35hea25a1c_0", + "sphinxcontrib 1.0 py35hcb7efd2_1", + "sphinxcontrib-websupport 1.0.1 py35h3537809_1", + "spyder 3.2.3 py35h49e6fe2_1", + "sqlalchemy 1.1.13 py35h4911131_0", + "sqlite 3.20.1 h6d8b0f3_1", + "statsmodels 0.8.0 py35haa9d50b_0", + "sympy 1.1.1 py35h919b29a_0", + "tblib 1.3.2 py35hf1eb0b4_0", + "terminado 0.6 py35hce234ed_0", + "testpath 0.3.1 py35had42eaf_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py35h90f1797_0", + "tornado 4.5.2 py35hf879e1d_0", + "traitlets 4.3.2 py35ha522a97_0", + "typing 3.6.2 py35hcadae7e_0", + "unicodecsv 0.14.1 py35h4805c0c_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py35h2ab6e29_0", + "wcwidth 0.1.7 py35hcd08066_0", + "webencodings 0.5.1 py35hb6cf162_1", + "werkzeug 0.12.2 py35hbfc1ea6_0", + "wheel 0.29.0 py35h601ca99_1", + "widgetsnbextension 3.0.2 py35h0be620c_1", + "wrapt 1.10.11 py35hfdafd39_0", + "xlrd 1.1.0 py35h45a0a2a_1", + "xlsxwriter 0.9.8 py35hc9d400f_0", + "xlwt 1.3.0 py35h884a0cf_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.2 py35h00a3a39_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "004d0c15b45cb97cc8dd69b4143f2efd", + "name": "anaconda", + "namespace": "python", + "sha256": "af55a95767df9abb8ca2b2551fada3fdb6dd808b216b15b4b2ca213633102f40", + "size": 11776, + "subdir": "linux-64", + "timestamp": 1506752668772, + "version": "5.0.0.1" + }, + "anaconda-5.0.0.1-py35h6d98c0b_1.conda": { + "build": "py35h6d98c0b_1", + "build_number": 1, + "depends": [ + "alabaster 0.7.10 py35h6fb19ab_0", + "anaconda-client 1.6.5 py35hd900ed1_0", + "anaconda-navigator 1.6.8 py35haed54dd_0", + "anaconda-project 0.8.0 py35hb597f32_0", + "asn1crypto 0.22.0 py35h0d675fe_1", + "astroid 1.5.3 py35h1d0c565_0", + "astropy 2.0.2 py35h2d2a8a6_4", + "babel 2.5.0 py35ha5fc564_0", + "backports 1.0 py35hd471ac7_1", + "backports.shutil_get_terminal_size 1.0.0 py35h40844db_2", + "beautifulsoup4 4.6.0 py35h442a8c9_1", + "bitarray 0.8.1 py35h7540340_0", + "bkcharts 0.2 py35he4f7e30_0", + "blaze 0.11.3 py35ha2c9137_0", + "bleach 2.0.0 py35h055c768_0", + "bokeh 0.12.7 py35h4751c18_1", + "boto 2.48.0 py35h2cfd601_1", + "bottleneck 1.2.1 py35he1b16f1_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 h58b644b_4", + "certifi 2017.7.27.1 py35h19f42a1_0", + "cffi 1.10.0 py35h796c292_1", + "chardet 3.0.4 py35hb6e9ddf_1", + "click 6.7 py35h353a69f_0", + "cloudpickle 0.4.0 py35h10376d1_0", + "clyent 1.2.2 py35h491ffcb_1", + "colorama 0.3.9 py35h81e2b6c_0", + "contextlib2 0.5.5 py35h6690dba_0", + "cryptography 2.0.3 py35hef72dfd_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py35hc4d5149_0", + "cython 0.26.1 py35h636ebcb_0", + "cytoolz 0.8.2 py35ha53021f_0", + "dask 0.15.2 py35h08b2748_0", + "dask-core 0.15.2 py35h79caba8_0", + "datashape 0.5.4 py35h5b068ae_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py35h3a268aa_0", + "distributed 1.18.3 py35h076cbad_0", + "docutils 0.14 py35hd11081d_0", + "entrypoints 0.2.3 py35h48174a2_2", + "et_xmlfile 1.0.1 py35hde8d43e_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py35hec2bbaa_0", + "filelock 2.0.12 py35h7855d60_0", + "flask 0.12.2 py35h679e90e_0", + "flask-cors 3.0.3 py35h9b2065d_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py35he064abf_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py35h98a1f2a_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py35h89a7545_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py35h2547b41_0", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py35h41d5d6e_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py35h51e6c10_0", + "html5lib 0.999999999 py35h0543385_0", + "icu 58.2 h211956c_0", + "idna 2.6 py35h8605a33_1", + "imageio 2.2.0 py35hd0a6de2_0", + "imagesize 0.7.1 py35hf008fae_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipykernel 4.6.1 py35h29d130c_0", + "ipython 6.1.0 py35h1b71439_1", + "ipython_genutils 0.2.0 py35hc9e07d0_0", + "ipywidgets 7.0.0 py35h8ebd919_0", + "isort 4.2.15 py35h44a00d2_0", + "itsdangerous 0.24 py35h7c46880_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py35hf1f7175_0", + "jedi 0.10.2 py35hc33c70f_0", + "jinja2 2.9.6 py35h90b8645_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py35h4395190_0", + "jupyter 1.0.0 py35hd38625c_0", + "jupyter_client 5.1.0 py35h2bff583_0", + "jupyter_console 5.2.0 py35h4044a63_1", + "jupyter_core 4.3.0 py35he2f7985_0", + "jupyterlab 0.27.0 py35h29561ed_2", + "jupyterlab_launcher 0.4.0 py35ha4e430f_0", + "lazy-object-proxy 1.3.1 py35h4c720c6_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 hcbc56d2_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h24385c6_1", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 he6ee5dd_2", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py35_0", + "locket 0.2.0 py35h170bc82_1", + "lxml 3.8.0 py35h4935ab9_0", + "lzo 2.10 hc0eb8fc_0", + "markupsafe 1.0 py35h4f4fcf6_1", + "matplotlib 2.0.2 py35hdbc49ba_1", + "mccabe 0.6.1 py35hd8c1f23_1", + "mistune 0.7.4 py35hfd0f961_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py35h0fc7090_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py35h5a16178_2", + "msgpack-python 0.4.8 py35h783f4c8_0", + "multipledispatch 0.4.9 py35h2ff591a_0", + "navigator-updater 0.1.0 py35h2ff6758_0", + "nbconvert 5.3.1 py35hc5194e3_0", + "nbformat 4.4.0 py35h12e6e07_0", + "ncurses 6.0 h06874d7_1", + "networkx 1.11 py35hf333c83_0", + "nltk 3.2.4 py35h7ba7875_0", + "nose 1.3.7 py35hdc64897_2", + "notebook 5.0.0 py35h65c930e_2", + "numba 0.35.0 np113py35_10", + "numexpr 2.6.2 py35h5f89caa_1", + "numpy 1.13.1 py35h8926d81_2", + "numpydoc 0.7.0 py35he089a57_0", + "odo 0.5.1 py35h102315f_0", + "olefile 0.44 py35h2c86149_0", + "openpyxl 2.4.8 py35hd6c89d3_1", + "openssl 1.0.2l h9d1a558_3", + "packaging 16.8 py35h2260b46_1", + "pandas 0.20.3 py35h85c2c75_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py35h1565a15_1", + "pango 1.40.11 hedb6d6b_0", + "partd 0.3.8 py35h68187f2_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py35hb82cfee_0", + "pathlib2 2.3.0 py35hd637de4_0", + "patsy 0.4.1 py35h51b66d5_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py35hee76f29_0", + "pexpect 4.2.1 py35h8b56cb4_0", + "pickleshare 0.7.4 py35hd57304d_0", + "pillow 4.2.1 py35h03abc04_0", + "pip 9.0.1 py35he1b8d41_2", + "pixman 0.34.0 ha72d70b_1", + "pkginfo 1.4.1 py35hb526c55_1", + "ply 3.10 py35h459f1a0_0", + "prompt_toolkit 1.0.15 py35hc09de7a_0", + "psutil 5.2.2 py35h75e6a48_0", + "ptyprocess 0.5.2 py35h38ce0a3_0", + "py 1.4.34 py35hd71111f_1", + "pycodestyle 2.3.1 py35h8d2105a_0", + "pycosat 0.6.2 py35h9693557_1", + "pycparser 2.18 py35h61b3040_1", + "pycrypto 2.6.1 py35h9852db7_1", + "pycurl 7.43.0 py35h7a9665c_3", + "pyflakes 1.5.0 py35h06f3f26_1", + "pygments 2.2.0 py35h0f41973_0", + "pylint 1.7.2 py35hc802fb1_0", + "pyodbc 4.0.17 py35h89a430b_0", + "pyopenssl 17.2.0 py35h1d2a76c_0", + "pyparsing 2.2.0 py35h041ed72_1", + "pyqt 5.6.0 py35h0e41ada_5", + "pysocks 1.6.7 py35h6aefbb0_1", + "pytables 3.4.2 py35hc74b6c3_1", + "pytest 3.2.1 py35hc97c719_1", + "python 3.5.4 h72f0b78_15", + "python-dateutil 2.6.1 py35h90d5b31_1", + "pytz 2017.2 py35h9225bff_1", + "pywavelets 0.5.2 py35h53ec731_0", + "pyyaml 3.12 py35h46ef4ae_1", + "pyzmq 16.0.2 py35h4be1f71_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py35hd68ff89_0", + "qtconsole 4.3.1 py35h4626a06_0", + "qtpy 1.3.1 py35h881af26_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py35hb9e6ad1_1", + "rope 0.10.5 py35h31d6b7c_0", + "ruamel_yaml 0.11.14 py35h8e2c16b_2", + "scikit-image 0.13.0 py35h3573165_1", + "scikit-learn 0.19.0 py35h25e8076_2", + "scipy 0.19.1 py35ha8f041b_3", + "seaborn 0.8.0 py35h15a2772_0", + "setuptools 36.5.0 py35ha8c1747_0", + "simplegeneric 0.8.1 py35h2ec4104_0", + "singledispatch 3.4.0.3 py35h0cd4ec3_0", + "sip 4.18.1 py35h9eaea60_2", + "six 1.10.0 py35h5312c1b_1", + "snowballstemmer 1.2.1 py35h5435977_0", + "sortedcollections 0.5.3 py35hb2f60ff_0", + "sortedcontainers 1.5.7 py35h683703c_0", + "sphinx 1.6.3 py35hea25a1c_0", + "sphinxcontrib 1.0 py35hcb7efd2_1", + "sphinxcontrib-websupport 1.0.1 py35h3537809_1", + "spyder 3.2.3 py35h49e6fe2_1", + "sqlalchemy 1.1.13 py35h4911131_0", + "sqlite 3.20.1 h6d8b0f3_1", + "statsmodels 0.8.0 py35haa9d50b_0", + "sympy 1.1.1 py35h919b29a_0", + "tblib 1.3.2 py35hf1eb0b4_0", + "terminado 0.6 py35hce234ed_0", + "testpath 0.3.1 py35had42eaf_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py35h90f1797_0", + "tornado 4.5.2 py35hf879e1d_0", + "traitlets 4.3.2 py35ha522a97_0", + "typing 3.6.2 py35hcadae7e_0", + "unicodecsv 0.14.1 py35h4805c0c_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py35h2ab6e29_0", + "wcwidth 0.1.7 py35hcd08066_0", + "webencodings 0.5.1 py35hb6cf162_1", + "werkzeug 0.12.2 py35hbfc1ea6_0", + "wheel 0.29.0 py35h601ca99_1", + "widgetsnbextension 3.0.2 py35h0be620c_1", + "wrapt 1.10.11 py35hfdafd39_0", + "xlrd 1.1.0 py35h45a0a2a_1", + "xlsxwriter 0.9.8 py35hc9d400f_0", + "xlwt 1.3.0 py35h884a0cf_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.2 py35h00a3a39_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "1f489fe07c15f46fd400250c05f98278", + "name": "anaconda", + "namespace": "python", + "sha256": "1d8d679cb149b09af7d8078ee567966e71a5c87e5fea311811efe29599df7a4f", + "size": 11775, + "subdir": "linux-64", + "timestamp": 1506833951274, + "version": "5.0.0.1" + }, + "anaconda-5.0.0.1-py36h6c6c83f_0.conda": { + "build": "py36h6c6c83f_0", + "build_number": 0, + "depends": [ + "alabaster 0.7.10 py36h306e16b_0", + "anaconda-client 1.6.5 py36h19c0dcd_0", + "anaconda-navigator 1.6.8 py36h672ccc7_0", + "anaconda-project 0.8.0 py36h29abdf5_0", + "asn1crypto 0.22.0 py36h265ca7c_1", + "astroid 1.5.3 py36hbdb9df2_0", + "astropy 2.0.2 py36ha51211e_4", + "babel 2.5.0 py36h7d14adf_0", + "backports 1.0 py36hfa02d7e_1", + "backports.shutil_get_terminal_size 1.0.0 py36hfea85ff_2", + "beautifulsoup4 4.6.0 py36h49b8c8c_1", + "bitarray 0.8.1 py36h5834eb8_0", + "bkcharts 0.2 py36h735825a_0", + "blaze 0.11.3 py36h4e06776_0", + "bleach 2.0.0 py36h688b259_0", + "bokeh 0.12.7 py36h169c5fd_1", + "boto 2.48.0 py36h6e4cd66_1", + "bottleneck 1.2.1 py36haac1ea0_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 h58b644b_4", + "certifi 2017.7.27.1 py36h8b7b77e_0", + "cffi 1.10.0 py36had8d393_1", + "chardet 3.0.4 py36h0f667ec_1", + "click 6.7 py36h5253387_0", + "cloudpickle 0.4.0 py36h30f8c20_0", + "clyent 1.2.2 py36h7e57e65_1", + "colorama 0.3.9 py36h489cec4_0", + "contextlib2 0.5.5 py36h6c84a62_0", + "cryptography 2.0.3 py36ha225213_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py36h93f1223_0", + "cython 0.26.1 py36h21c49d0_0", + "cytoolz 0.8.2 py36h708bfd4_0", + "dask 0.15.2 py36h9b48dc4_0", + "dask-core 0.15.2 py36h0f988a8_0", + "datashape 0.5.4 py36h3ad6b5c_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py36hd076ac8_0", + "distributed 1.18.3 py36h73cd4ae_0", + "docutils 0.14 py36hb0f60f5_0", + "entrypoints 0.2.3 py36h1aec115_2", + "et_xmlfile 1.0.1 py36hd6bccc3_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py36h5b0c431_0", + "filelock 2.0.12 py36hacfa1f5_0", + "flask 0.12.2 py36hb24657c_0", + "flask-cors 3.0.3 py36h2d857d3_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py36h2fe25dc_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py36h2c1b292_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py36h55090d7_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py36h2d503a6_0", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py36he81ebca_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py36h79797d7_0", + "html5lib 0.999999999 py36h2cfc398_0", + "icu 58.2 h211956c_0", + "idna 2.6 py36h82fb2a8_1", + "imageio 2.2.0 py36he555465_0", + "imagesize 0.7.1 py36h52d8127_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipykernel 4.6.1 py36hbf841aa_0", + "ipython 6.1.0 py36hc72a948_1", + "ipython_genutils 0.2.0 py36hb52b0d5_0", + "ipywidgets 7.0.0 py36h7b55c3a_0", + "isort 4.2.15 py36had401c0_0", + "itsdangerous 0.24 py36h93cc618_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py36h4c697fb_0", + "jedi 0.10.2 py36h552def0_0", + "jinja2 2.9.6 py36h489bce4_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py36h006f8b5_0", + "jupyter 1.0.0 py36h9896ce5_0", + "jupyter_client 5.1.0 py36h614e9ea_0", + "jupyter_console 5.2.0 py36he59e554_1", + "jupyter_core 4.3.0 py36h357a921_0", + "jupyterlab 0.27.0 py36h86377d0_2", + "jupyterlab_launcher 0.4.0 py36h4d8058d_0", + "lazy-object-proxy 1.3.1 py36h10fcdad_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 hcbc56d2_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h24385c6_1", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 he6ee5dd_2", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py36_0", + "locket 0.2.0 py36h787c0ad_1", + "lxml 3.8.0 py36h6c6e760_0", + "lzo 2.10 hc0eb8fc_0", + "markupsafe 1.0 py36hd9260cd_1", + "matplotlib 2.0.2 py36h2acb4ad_1", + "mccabe 0.6.1 py36h5ad9710_1", + "mistune 0.7.4 py36hbab8784_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py36h17a0993_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py36h8cc018b_2", + "msgpack-python 0.4.8 py36hec4c5d1_0", + "multipledispatch 0.4.9 py36h41da3fb_0", + "navigator-updater 0.1.0 py36h14770f7_0", + "nbconvert 5.3.1 py36hb41ffb7_0", + "nbformat 4.4.0 py36h31c9010_0", + "ncurses 6.0 h06874d7_1", + "networkx 1.11 py36hfb3574a_0", + "nltk 3.2.4 py36h1a0979f_0", + "nose 1.3.7 py36hcdf7029_2", + "notebook 5.0.0 py36h0b20546_2", + "numba 0.35.0 np113py36_10", + "numexpr 2.6.2 py36hdd3393f_1", + "numpy 1.13.1 py36h5bc529a_2", + "numpydoc 0.7.0 py36h18f165f_0", + "odo 0.5.1 py36h90ed295_0", + "olefile 0.44 py36h79f9f78_0", + "openpyxl 2.4.8 py36h41dd2a8_1", + "openssl 1.0.2l h9d1a558_3", + "packaging 16.8 py36ha668100_1", + "pandas 0.20.3 py36h842e28d_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py36ha6701b7_1", + "pango 1.40.11 hedb6d6b_0", + "partd 0.3.8 py36h36fd896_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py36he0c6f6d_0", + "pathlib2 2.3.0 py36h49efa8e_0", + "patsy 0.4.1 py36ha3be15e_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py36h26ade29_0", + "pexpect 4.2.1 py36h3b9d41b_0", + "pickleshare 0.7.4 py36h63277f8_0", + "pillow 4.2.1 py36h9119f52_0", + "pip 9.0.1 py36h30f8307_2", + "pixman 0.34.0 ha72d70b_1", + "pkginfo 1.4.1 py36h215d178_1", + "ply 3.10 py36hed35086_0", + "prompt_toolkit 1.0.15 py36h17d85b1_0", + "psutil 5.2.2 py36h74c8701_0", + "ptyprocess 0.5.2 py36h69acd42_0", + "py 1.4.34 py36h0712aa3_1", + "pycodestyle 2.3.1 py36hf609f19_0", + "pycosat 0.6.2 py36h1a0ea17_1", + "pycparser 2.18 py36hf9f622e_1", + "pycrypto 2.6.1 py36h6998063_1", + "pycurl 7.43.0 py36h5e72054_3", + "pyflakes 1.5.0 py36h5510808_1", + "pygments 2.2.0 py36h0d3125c_0", + "pylint 1.7.2 py36h484ab97_0", + "pyodbc 4.0.17 py36h999153c_0", + "pyopenssl 17.2.0 py36h5cc804b_0", + "pyparsing 2.2.0 py36hee85983_1", + "pyqt 5.6.0 py36h0386399_5", + "pysocks 1.6.7 py36hd97a5b1_1", + "pytables 3.4.2 py36hdce54c9_1", + "pytest 3.2.1 py36h11ad3bb_1", + "python 3.6.2 h0b30769_14", + "python-dateutil 2.6.1 py36h88d3b88_1", + "pytz 2017.2 py36hc2ccc2a_1", + "pywavelets 0.5.2 py36he602eb0_0", + "pyyaml 3.12 py36hafb9ca4_1", + "pyzmq 16.0.2 py36h3b0cf96_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py36h609ed8c_0", + "qtconsole 4.3.1 py36h8f73b5b_0", + "qtpy 1.3.1 py36h3691cc8_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py36he2e5f8d_1", + "rope 0.10.5 py36h1f8c17e_0", + "ruamel_yaml 0.11.14 py36ha2fb22d_2", + "scikit-image 0.13.0 py36had3c07a_1", + "scikit-learn 0.19.0 py36h97ac459_2", + "scipy 0.19.1 py36h9976243_3", + "seaborn 0.8.0 py36h197244f_0", + "setuptools 36.5.0 py36he42e2e1_0", + "simplegeneric 0.8.1 py36h2cb9092_0", + "singledispatch 3.4.0.3 py36h7a266c3_0", + "sip 4.18.1 py36h51ed4ed_2", + "six 1.10.0 py36hcac75e4_1", + "snowballstemmer 1.2.1 py36h6febd40_0", + "sortedcollections 0.5.3 py36h3c761f9_0", + "sortedcontainers 1.5.7 py36hdf89491_0", + "sphinx 1.6.3 py36he5f0bdb_0", + "sphinxcontrib 1.0 py36h6d0f590_1", + "sphinxcontrib-websupport 1.0.1 py36hb5cb234_1", + "spyder 3.2.3 py36he38cbf7_1", + "sqlalchemy 1.1.13 py36hfb5efd7_0", + "sqlite 3.20.1 h6d8b0f3_1", + "statsmodels 0.8.0 py36h8533d0b_0", + "sympy 1.1.1 py36hc6d1c1c_0", + "tblib 1.3.2 py36h34cf8b6_0", + "terminado 0.6 py36ha25a19f_0", + "testpath 0.3.1 py36h8cadb63_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py36h81f2dff_0", + "tornado 4.5.2 py36h1283b2a_0", + "traitlets 4.3.2 py36h674d592_0", + "typing 3.6.2 py36h7da032a_0", + "unicodecsv 0.14.1 py36ha668878_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py36hbe7ace6_0", + "wcwidth 0.1.7 py36hdf4376a_0", + "webencodings 0.5.1 py36h800622e_1", + "werkzeug 0.12.2 py36hc703753_0", + "wheel 0.29.0 py36he7f4e38_1", + "widgetsnbextension 3.0.2 py36hd01bb71_1", + "wrapt 1.10.11 py36h28b7045_0", + "xlrd 1.1.0 py36h1db9f0c_1", + "xlsxwriter 0.9.8 py36hf41c223_0", + "xlwt 1.3.0 py36h7b00a1f_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.2 py36ha0d441b_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "869373c9bdd084c8f4cd20bb1ca0722d", + "name": "anaconda", + "namespace": "python", + "sha256": "f45d4c482411c32e13fef7a7cb3cb2a1a2cf3ed77c62277e93f9278f2259db5e", + "size": 11634, + "subdir": "linux-64", + "timestamp": 1506790331786, + "version": "5.0.0.1" + }, + "anaconda-5.0.0.1-py36hfb0b618_1.conda": { + "build": "py36hfb0b618_1", + "build_number": 1, + "depends": [ + "alabaster 0.7.10 py36h306e16b_0", + "anaconda-client 1.6.5 py36h19c0dcd_0", + "anaconda-navigator 1.6.8 py36h672ccc7_0", + "anaconda-project 0.8.0 py36h29abdf5_0", + "asn1crypto 0.22.0 py36h265ca7c_1", + "astroid 1.5.3 py36hbdb9df2_0", + "astropy 2.0.2 py36ha51211e_4", + "babel 2.5.0 py36h7d14adf_0", + "backports 1.0 py36hfa02d7e_1", + "backports.shutil_get_terminal_size 1.0.0 py36hfea85ff_2", + "beautifulsoup4 4.6.0 py36h49b8c8c_1", + "bitarray 0.8.1 py36h5834eb8_0", + "bkcharts 0.2 py36h735825a_0", + "blaze 0.11.3 py36h4e06776_0", + "bleach 2.0.0 py36h688b259_0", + "bokeh 0.12.7 py36h169c5fd_1", + "boto 2.48.0 py36h6e4cd66_1", + "bottleneck 1.2.1 py36haac1ea0_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 h58b644b_4", + "certifi 2017.7.27.1 py36h8b7b77e_0", + "cffi 1.10.0 py36had8d393_1", + "chardet 3.0.4 py36h0f667ec_1", + "click 6.7 py36h5253387_0", + "cloudpickle 0.4.0 py36h30f8c20_0", + "clyent 1.2.2 py36h7e57e65_1", + "colorama 0.3.9 py36h489cec4_0", + "contextlib2 0.5.5 py36h6c84a62_0", + "cryptography 2.0.3 py36ha225213_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py36h93f1223_0", + "cython 0.26.1 py36h21c49d0_0", + "cytoolz 0.8.2 py36h708bfd4_0", + "dask 0.15.2 py36h9b48dc4_0", + "dask-core 0.15.2 py36h0f988a8_0", + "datashape 0.5.4 py36h3ad6b5c_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py36hd076ac8_0", + "distributed 1.18.3 py36h73cd4ae_0", + "docutils 0.14 py36hb0f60f5_0", + "entrypoints 0.2.3 py36h1aec115_2", + "et_xmlfile 1.0.1 py36hd6bccc3_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py36h5b0c431_0", + "filelock 2.0.12 py36hacfa1f5_0", + "flask 0.12.2 py36hb24657c_0", + "flask-cors 3.0.3 py36h2d857d3_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py36h2fe25dc_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py36h2c1b292_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py36h55090d7_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py36h2d503a6_0", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py36he81ebca_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py36h79797d7_0", + "html5lib 0.999999999 py36h2cfc398_0", + "icu 58.2 h211956c_0", + "idna 2.6 py36h82fb2a8_1", + "imageio 2.2.0 py36he555465_0", + "imagesize 0.7.1 py36h52d8127_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipykernel 4.6.1 py36hbf841aa_0", + "ipython 6.1.0 py36hc72a948_1", + "ipython_genutils 0.2.0 py36hb52b0d5_0", + "ipywidgets 7.0.0 py36h7b55c3a_0", + "isort 4.2.15 py36had401c0_0", + "itsdangerous 0.24 py36h93cc618_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py36h4c697fb_0", + "jedi 0.10.2 py36h552def0_0", + "jinja2 2.9.6 py36h489bce4_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py36h006f8b5_0", + "jupyter 1.0.0 py36h9896ce5_0", + "jupyter_client 5.1.0 py36h614e9ea_0", + "jupyter_console 5.2.0 py36he59e554_1", + "jupyter_core 4.3.0 py36h357a921_0", + "jupyterlab 0.27.0 py36h86377d0_2", + "jupyterlab_launcher 0.4.0 py36h4d8058d_0", + "lazy-object-proxy 1.3.1 py36h10fcdad_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 hcbc56d2_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h24385c6_1", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 he6ee5dd_2", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py36_0", + "locket 0.2.0 py36h787c0ad_1", + "lxml 3.8.0 py36h6c6e760_0", + "lzo 2.10 hc0eb8fc_0", + "markupsafe 1.0 py36hd9260cd_1", + "matplotlib 2.0.2 py36h2acb4ad_1", + "mccabe 0.6.1 py36h5ad9710_1", + "mistune 0.7.4 py36hbab8784_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py36h17a0993_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py36h8cc018b_2", + "msgpack-python 0.4.8 py36hec4c5d1_0", + "multipledispatch 0.4.9 py36h41da3fb_0", + "navigator-updater 0.1.0 py36h14770f7_0", + "nbconvert 5.3.1 py36hb41ffb7_0", + "nbformat 4.4.0 py36h31c9010_0", + "ncurses 6.0 h06874d7_1", + "networkx 1.11 py36hfb3574a_0", + "nltk 3.2.4 py36h1a0979f_0", + "nose 1.3.7 py36hcdf7029_2", + "notebook 5.0.0 py36h0b20546_2", + "numba 0.35.0 np113py36_10", + "numexpr 2.6.2 py36hdd3393f_1", + "numpy 1.13.1 py36h5bc529a_2", + "numpydoc 0.7.0 py36h18f165f_0", + "odo 0.5.1 py36h90ed295_0", + "olefile 0.44 py36h79f9f78_0", + "openpyxl 2.4.8 py36h41dd2a8_1", + "openssl 1.0.2l h9d1a558_3", + "packaging 16.8 py36ha668100_1", + "pandas 0.20.3 py36h842e28d_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py36ha6701b7_1", + "pango 1.40.11 hedb6d6b_0", + "partd 0.3.8 py36h36fd896_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py36he0c6f6d_0", + "pathlib2 2.3.0 py36h49efa8e_0", + "patsy 0.4.1 py36ha3be15e_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py36h26ade29_0", + "pexpect 4.2.1 py36h3b9d41b_0", + "pickleshare 0.7.4 py36h63277f8_0", + "pillow 4.2.1 py36h9119f52_0", + "pip 9.0.1 py36h30f8307_2", + "pixman 0.34.0 ha72d70b_1", + "pkginfo 1.4.1 py36h215d178_1", + "ply 3.10 py36hed35086_0", + "prompt_toolkit 1.0.15 py36h17d85b1_0", + "psutil 5.2.2 py36h74c8701_0", + "ptyprocess 0.5.2 py36h69acd42_0", + "py 1.4.34 py36h0712aa3_1", + "pycodestyle 2.3.1 py36hf609f19_0", + "pycosat 0.6.2 py36h1a0ea17_1", + "pycparser 2.18 py36hf9f622e_1", + "pycrypto 2.6.1 py36h6998063_1", + "pycurl 7.43.0 py36h5e72054_3", + "pyflakes 1.5.0 py36h5510808_1", + "pygments 2.2.0 py36h0d3125c_0", + "pylint 1.7.2 py36h484ab97_0", + "pyodbc 4.0.17 py36h999153c_0", + "pyopenssl 17.2.0 py36h5cc804b_0", + "pyparsing 2.2.0 py36hee85983_1", + "pyqt 5.6.0 py36h0386399_5", + "pysocks 1.6.7 py36hd97a5b1_1", + "pytables 3.4.2 py36hdce54c9_1", + "pytest 3.2.1 py36h11ad3bb_1", + "python 3.6.2 hdfe5801_15", + "python-dateutil 2.6.1 py36h88d3b88_1", + "pytz 2017.2 py36hc2ccc2a_1", + "pywavelets 0.5.2 py36he602eb0_0", + "pyyaml 3.12 py36hafb9ca4_1", + "pyzmq 16.0.2 py36h3b0cf96_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py36h609ed8c_0", + "qtconsole 4.3.1 py36h8f73b5b_0", + "qtpy 1.3.1 py36h3691cc8_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py36he2e5f8d_1", + "rope 0.10.5 py36h1f8c17e_0", + "ruamel_yaml 0.11.14 py36ha2fb22d_2", + "scikit-image 0.13.0 py36had3c07a_1", + "scikit-learn 0.19.0 py36h97ac459_2", + "scipy 0.19.1 py36h9976243_3", + "seaborn 0.8.0 py36h197244f_0", + "setuptools 36.5.0 py36he42e2e1_0", + "simplegeneric 0.8.1 py36h2cb9092_0", + "singledispatch 3.4.0.3 py36h7a266c3_0", + "sip 4.18.1 py36h51ed4ed_2", + "six 1.10.0 py36hcac75e4_1", + "snowballstemmer 1.2.1 py36h6febd40_0", + "sortedcollections 0.5.3 py36h3c761f9_0", + "sortedcontainers 1.5.7 py36hdf89491_0", + "sphinx 1.6.3 py36he5f0bdb_0", + "sphinxcontrib 1.0 py36h6d0f590_1", + "sphinxcontrib-websupport 1.0.1 py36hb5cb234_1", + "spyder 3.2.3 py36he38cbf7_1", + "sqlalchemy 1.1.13 py36hfb5efd7_0", + "sqlite 3.20.1 h6d8b0f3_1", + "statsmodels 0.8.0 py36h8533d0b_0", + "sympy 1.1.1 py36hc6d1c1c_0", + "tblib 1.3.2 py36h34cf8b6_0", + "terminado 0.6 py36ha25a19f_0", + "testpath 0.3.1 py36h8cadb63_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py36h81f2dff_0", + "tornado 4.5.2 py36h1283b2a_0", + "traitlets 4.3.2 py36h674d592_0", + "typing 3.6.2 py36h7da032a_0", + "unicodecsv 0.14.1 py36ha668878_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py36hbe7ace6_0", + "wcwidth 0.1.7 py36hdf4376a_0", + "webencodings 0.5.1 py36h800622e_1", + "werkzeug 0.12.2 py36hc703753_0", + "wheel 0.29.0 py36he7f4e38_1", + "widgetsnbextension 3.0.2 py36hd01bb71_1", + "wrapt 1.10.11 py36h28b7045_0", + "xlrd 1.1.0 py36h1db9f0c_1", + "xlsxwriter 0.9.8 py36hf41c223_0", + "xlwt 1.3.0 py36h7b00a1f_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.2 py36ha0d441b_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "c99aa87186ef927180c097f9cc9ed215", + "name": "anaconda", + "namespace": "python", + "sha256": "f365529a50fa1d942b322f4cf9c8c4000a47cf09c062477d5078ab5b9a6592be", + "size": 11639, + "subdir": "linux-64", + "timestamp": 1506842869773, + "version": "5.0.0.1" + }, + "anaconda-5.0.1-py27hd9359a7_1.conda": { + "build": "py27hd9359a7_1", + "build_number": 1, + "depends": [ + "alabaster 0.7.10 py27he5a193a_0", + "anaconda-client 1.6.5 py27hc8169bf_0", + "anaconda-navigator 1.6.9 py27hfbc306d_0", + "anaconda-project 0.8.0 py27hd7a9a97_0", + "asn1crypto 0.22.0 py27h94ebe91_1", + "astroid 1.5.3 py27h8f8f47c_0", + "astropy 2.0.2 py27h57072c0_4", + "babel 2.5.0 py27h20693cd_0", + "backports 1.0 py27h63c9359_1", + "backports.functools_lru_cache 1.4 py27he8db605_1", + "backports.shutil_get_terminal_size 1.0.0 py27h5bc021e_2", + "backports_abc 0.5 py27h7b3c97b_0", + "beautifulsoup4 4.6.0 py27h3f86ba9_1", + "bitarray 0.8.1 py27h304d4c6_0", + "bkcharts 0.2 py27h241ae91_0", + "blaze 0.11.3 py27h5f341da_0", + "bleach 2.0.0 py27h3a0dcc8_0", + "bokeh 0.12.10 py27he46cc6b_0", + "boto 2.48.0 py27h9556ac2_1", + "bottleneck 1.2.1 py27h21b16a3_0", + "bzip2 1.0.6 h0376d23_1", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 haa5651f_5", + "cdecimal 2.3 py27h4e63abe_1", + "certifi 2017.7.27.1 py27h9ceb091_0", + "cffi 1.10.0 py27hf1aaaf4_1", + "chardet 3.0.4 py27hfa10054_1", + "click 6.7 py27h4225b90_0", + "cloudpickle 0.4.0 py27ha64365b_0", + "clyent 1.2.2 py27h7276e6c_1", + "colorama 0.3.9 py27h5cde069_0", + "configparser 3.5.0 py27h5117587_0", + "contextlib2 0.5.5 py27hbf4c468_0", + "cryptography 2.0.3 py27hea39389_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py27hc7354d3_0", + "cython 0.26.1 py27hdbcff32_0", + "cytoolz 0.8.2 py27hf14aec9_0", + "dask 0.15.3 py27hb94b45f_0", + "dask-core 0.15.3 py27h53a7ee6_0", + "datashape 0.5.4 py27hf507385_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py27h1544723_0", + "distributed 1.19.1 py27h38c4a05_0", + "docutils 0.14 py27hae222c1_0", + "entrypoints 0.2.3 py27h502b47d_2", + "enum34 1.1.6 py27h99a27e9_1", + "et_xmlfile 1.0.1 py27h75840f5_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py27h4cb8e01_0", + "filelock 2.0.12 py27h38fa839_0", + "flask 0.12.2 py27h6d5c1cd_0", + "flask-cors 3.0.3 py27h1a8a27f_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "funcsigs 1.0.2 py27h83f16ab_0", + "functools32 3.2.3.2 py27h4ead58f_1", + "futures 3.1.1 py27hdbc8cbb_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py27h475ea6a_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py27hd3b7d1f_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py27hc856308_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py27hac09c53_0", + "grin 1.2.1 py27h54abee7_1", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py27h71d1790_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py27h33770af_0", + "html5lib 0.999999999 py27hdf15f34_0", + "icu 58.2 h211956c_0", + "idna 2.6 py27h5722d68_1", + "imageio 2.2.0 py27hf108a7f_0", + "imagesize 0.7.1 py27hd17bf80_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipaddress 1.0.18 py27h337fd85_0", + "ipykernel 4.6.1 py27hc93e584_0", + "ipython 5.4.1 py27h36c99b6_1", + "ipython_genutils 0.2.0 py27h89fb69b_0", + "ipywidgets 7.0.0 py27h4fda95d_0", + "isort 4.2.15 py27hcfa4749_0", + "itsdangerous 0.24 py27hb8295c1_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py27h2cc5433_0", + "jedi 0.10.2 py27h8af4e35_0", + "jinja2 2.9.6 py27h82327ae_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py27h7ed5aa4_0", + "jupyter 1.0.0 py27h505fd4b_0", + "jupyter_client 5.1.0 py27hbee1118_0", + "jupyter_console 5.2.0 py27hc6bee7e_1", + "jupyter_core 4.3.0 py27hcd9ae3a_0", + "jupyterlab 0.27.0 py27h42ebfef_2", + "jupyterlab_launcher 0.4.0 py27h0e16d15_0", + "lazy-object-proxy 1.3.1 py27h682c727_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 h7cc24e2_2", + "libgfortran-ng 7.2.0 h9f7466a_2", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h7a57d05_2", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 h84ff03f_3", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py27_0", + "locket 0.2.0 py27h73929a2_1", + "lxml 4.1.0 py27hb025457_0", + "lzo 2.10 h1bfc0ba_1", + "markupsafe 1.0 py27h97b2822_1", + "matplotlib 2.1.0 py27h09aba24_0", + "mccabe 0.6.1 py27h0e7c7be_1", + "mistune 0.7.4 py27h6da7e90_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py27hb2d42c5_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py27h4bb41bd_2", + "msgpack-python 0.4.8 py27hc2fa789_0", + "multipledispatch 0.4.9 py27h9b5f95a_0", + "navigator-updater 0.1.0 py27h0f9cd39_0", + "nbconvert 5.3.1 py27he041f76_0", + "nbformat 4.4.0 py27hed7f2b2_0", + "ncurses 6.0 h06874d7_1", + "networkx 2.0 py27hfc23926_0", + "nltk 3.2.4 py27h41293c3_0", + "nose 1.3.7 py27heec2199_2", + "notebook 5.0.0 py27h3661c2b_2", + "numba 0.35.0 np113py27_10", + "numexpr 2.6.2 py27he5efce1_1", + "numpy 1.13.3 py27hbcc08e0_0", + "numpydoc 0.7.0 py27h9647a75_0", + "odo 0.5.1 py27h9170de3_0", + "olefile 0.44 py27h4bd3e3c_0", + "openpyxl 2.4.8 py27h9f0c937_1", + "openssl 1.0.2l h077ae2c_5", + "packaging 16.8 py27h5e07c7c_1", + "pandas 0.20.3 py27h820b67f_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py27h428e1e5_1", + "pango 1.40.11 h8191d47_0", + "partd 0.3.8 py27h4e55004_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py27hc258cac_0", + "pathlib2 2.3.0 py27h6e9d198_0", + "patsy 0.4.1 py27hd1cf8c0_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py27h444351c_0", + "pexpect 4.2.1 py27hcf82287_0", + "pickleshare 0.7.4 py27h09770e1_0", + "pillow 4.2.1 py27h7cd2321_0", + "pip 9.0.1 py27hbf658b2_3", + "pixman 0.34.0 h83dc358_2", + "pkginfo 1.4.1 py27hee1a9ad_1", + "ply 3.10 py27hd6d9ae5_0", + "prompt_toolkit 1.0.15 py27h1b593e1_0", + "psutil 5.4.0 py27h7da3062_0", + "ptyprocess 0.5.2 py27h4ccb14c_0", + "py 1.4.34 py27he5894e4_1", + "pycairo 1.13.3 py27hea6d626_0", + "pycodestyle 2.3.1 py27h904819d_0", + "pycosat 0.6.2 py27h1cf261c_1", + "pycparser 2.18 py27hefa08c5_1", + "pycrypto 2.6.1 py27h9abbf5c_1", + "pycurl 7.43.0 py27hcf8ebea_3", + "pyflakes 1.6.0 py27h904a57d_0", + "pygments 2.2.0 py27h4a8b6f5_0", + "pylint 1.7.4 py27h6bc7935_0", + "pyodbc 4.0.17 py27h7f7627d_0", + "pyopenssl 17.2.0 py27h189ff3b_0", + "pyparsing 2.2.0 py27hf1513f8_1", + "pyqt 5.6.0 py27h4b1e83c_5", + "pysocks 1.6.7 py27he2db6d2_1", + "pytables 3.4.2 py27h1f7bffc_2", + "pytest 3.2.1 py27h98000ae_1", + "python 2.7.14 hc2b0042_21", + "python-dateutil 2.6.1 py27h4ca5741_1", + "pytz 2017.2 py27hcac29fa_1", + "pywavelets 0.5.2 py27hecda097_0", + "pyyaml 3.12 py27h2d70dd7_1", + "pyzmq 16.0.2 py27h297844f_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py27hd7914c3_0", + "qtconsole 4.3.1 py27hc444b0d_0", + "qtpy 1.3.1 py27h63d3751_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py27hc5b0589_1", + "rope 0.10.5 py27hcb0a616_0", + "ruamel_yaml 0.11.14 py27h672d447_2", + "scandir 1.6 py27hf7388dc_0", + "scikit-image 0.13.0 py27h06cb35d_1", + "scikit-learn 0.19.1 py27h445a80a_0", + "scipy 0.19.1 py27h1edc525_3", + "seaborn 0.8.0 py27h9d2aaa1_0", + "setuptools 36.5.0 py27h68b189e_0", + "simplegeneric 0.8.1 py27h19e43cd_0", + "singledispatch 3.4.0.3 py27h9bcb476_0", + "sip 4.18.1 py27he9ba0ab_2", + "six 1.11.0 py27h5f960f1_1", + "snowballstemmer 1.2.1 py27h44e2768_0", + "sortedcollections 0.5.3 py27h135218e_0", + "sortedcontainers 1.5.7 py27he59936f_0", + "sphinx 1.6.3 py27hf9b1778_0", + "sphinxcontrib 1.0 py27h1512b58_1", + "sphinxcontrib-websupport 1.0.1 py27hf906f22_1", + "spyder 3.2.4 py27h04a3490_0", + "sqlalchemy 1.1.13 py27hb0a01da_0", + "sqlite 3.20.1 h6d8b0f3_1", + "ssl_match_hostname 3.5.0.1 py27h4ec10b9_2", + "statsmodels 0.8.0 py27hc87d62d_0", + "subprocess32 3.2.7 py27h373dbce_0", + "sympy 1.1.1 py27hc28188a_0", + "tblib 1.3.2 py27h51fe5ba_0", + "terminado 0.6 py27h4be8df9_0", + "testpath 0.3.1 py27hc38d2c4_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py27hd3b1e7e_0", + "tornado 4.5.2 py27h97b179f_0", + "traitlets 4.3.2 py27hd6ce930_0", + "typing 3.6.2 py27h66f49e2_0", + "unicodecsv 0.14.1 py27h5062da9_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py27ha55213b_0", + "wcwidth 0.1.7 py27h9e3e1ab_0", + "webencodings 0.5.1 py27hff10b21_1", + "werkzeug 0.12.2 py27hbf75dff_0", + "wheel 0.29.0 py27h411dd7b_1", + "widgetsnbextension 3.0.2 py27hcb77dec_1", + "wrapt 1.10.11 py27h04f6869_0", + "xlrd 1.1.0 py27ha77178f_1", + "xlsxwriter 1.0.2 py27h12cbc6b_0", + "xlwt 1.3.0 py27h3d85d97_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.3 py27h12c336c_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "8098d7c531eae1c12e5db775c62ffbe7", + "name": "anaconda", + "namespace": "python", + "sha256": "4b3db97898c5dced78d8688b5f425fa8acedbfe5bb378c0b27c23b24b8096ed2", + "size": 12316, + "subdir": "linux-64", + "timestamp": 1508799416292, + "version": "5.0.1" + }, + "anaconda-5.0.1-py35h6f6dcbc_1.conda": { + "build": "py35h6f6dcbc_1", + "build_number": 1, + "depends": [ + "alabaster 0.7.10 py35h6fb19ab_0", + "anaconda-client 1.6.5 py35hd900ed1_0", + "anaconda-navigator 1.6.9 py35h5f5ee00_0", + "anaconda-project 0.8.0 py35hb597f32_0", + "asn1crypto 0.22.0 py35h0d675fe_1", + "astroid 1.5.3 py35h1d0c565_0", + "astropy 2.0.2 py35h2d2a8a6_4", + "babel 2.5.0 py35ha5fc564_0", + "backports 1.0 py35hd471ac7_1", + "backports.shutil_get_terminal_size 1.0.0 py35h40844db_2", + "beautifulsoup4 4.6.0 py35h442a8c9_1", + "bitarray 0.8.1 py35h7540340_0", + "bkcharts 0.2 py35he4f7e30_0", + "blaze 0.11.3 py35ha2c9137_0", + "bleach 2.0.0 py35h055c768_0", + "bokeh 0.12.10 py35hfdb0b1d_0", + "boto 2.48.0 py35h2cfd601_1", + "bottleneck 1.2.1 py35he1b16f1_0", + "bzip2 1.0.6 h0376d23_1", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 haa5651f_5", + "certifi 2017.7.27.1 py35h19f42a1_0", + "cffi 1.10.0 py35h796c292_1", + "chardet 3.0.4 py35hb6e9ddf_1", + "click 6.7 py35h353a69f_0", + "cloudpickle 0.4.0 py35h10376d1_0", + "clyent 1.2.2 py35h491ffcb_1", + "colorama 0.3.9 py35h81e2b6c_0", + "contextlib2 0.5.5 py35h6690dba_0", + "cryptography 2.0.3 py35hef72dfd_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py35hc4d5149_0", + "cython 0.26.1 py35h636ebcb_0", + "cytoolz 0.8.2 py35ha53021f_0", + "dask 0.15.3 py35h52d6c43_0", + "dask-core 0.15.3 py35hdf4792c_0", + "datashape 0.5.4 py35h5b068ae_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py35h3a268aa_0", + "distributed 1.19.1 py35h399b246_0", + "docutils 0.14 py35hd11081d_0", + "entrypoints 0.2.3 py35h48174a2_2", + "et_xmlfile 1.0.1 py35hde8d43e_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py35hec2bbaa_0", + "filelock 2.0.12 py35h7855d60_0", + "flask 0.12.2 py35h679e90e_0", + "flask-cors 3.0.3 py35h9b2065d_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py35he064abf_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py35h98a1f2a_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py35h89a7545_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py35h2547b41_0", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py35h41d5d6e_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py35h51e6c10_0", + "html5lib 0.999999999 py35h0543385_0", + "icu 58.2 h211956c_0", + "idna 2.6 py35h8605a33_1", + "imageio 2.2.0 py35hd0a6de2_0", + "imagesize 0.7.1 py35hf008fae_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipykernel 4.6.1 py35h29d130c_0", + "ipython 6.1.0 py35h1b71439_1", + "ipython_genutils 0.2.0 py35hc9e07d0_0", + "ipywidgets 7.0.0 py35h8ebd919_0", + "isort 4.2.15 py35h44a00d2_0", + "itsdangerous 0.24 py35h7c46880_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py35hf1f7175_0", + "jedi 0.10.2 py35hc33c70f_0", + "jinja2 2.9.6 py35h90b8645_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py35h4395190_0", + "jupyter 1.0.0 py35hd38625c_0", + "jupyter_client 5.1.0 py35h2bff583_0", + "jupyter_console 5.2.0 py35h4044a63_1", + "jupyter_core 4.3.0 py35he2f7985_0", + "jupyterlab 0.27.0 py35h29561ed_2", + "jupyterlab_launcher 0.4.0 py35ha4e430f_0", + "lazy-object-proxy 1.3.1 py35h4c720c6_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 h7cc24e2_2", + "libgfortran-ng 7.2.0 h9f7466a_2", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h7a57d05_2", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 h84ff03f_3", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py35_0", + "locket 0.2.0 py35h170bc82_1", + "lxml 4.1.0 py35ha401a81_0", + "lzo 2.10 h1bfc0ba_1", + "markupsafe 1.0 py35h4f4fcf6_1", + "matplotlib 2.1.0 py35h2cbf27e_0", + "mccabe 0.6.1 py35hd8c1f23_1", + "mistune 0.7.4 py35hfd0f961_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py35h0fc7090_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py35h5a16178_2", + "msgpack-python 0.4.8 py35h783f4c8_0", + "multipledispatch 0.4.9 py35h2ff591a_0", + "navigator-updater 0.1.0 py35h2ff6758_0", + "nbconvert 5.3.1 py35hc5194e3_0", + "nbformat 4.4.0 py35h12e6e07_0", + "ncurses 6.0 h06874d7_1", + "networkx 2.0 py35hc690e10_0", + "nltk 3.2.4 py35h7ba7875_0", + "nose 1.3.7 py35hdc64897_2", + "notebook 5.0.0 py35h65c930e_2", + "numba 0.35.0 np113py35_10", + "numexpr 2.6.2 py35h5f89caa_1", + "numpy 1.13.3 py35hd829ed6_0", + "numpydoc 0.7.0 py35he089a57_0", + "odo 0.5.1 py35h102315f_0", + "olefile 0.44 py35h2c86149_0", + "openpyxl 2.4.8 py35hd6c89d3_1", + "openssl 1.0.2l h077ae2c_5", + "packaging 16.8 py35h2260b46_1", + "pandas 0.20.3 py35h85c2c75_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py35h1565a15_1", + "pango 1.40.11 h8191d47_0", + "partd 0.3.8 py35h68187f2_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py35hb82cfee_0", + "pathlib2 2.3.0 py35hd637de4_0", + "patsy 0.4.1 py35h51b66d5_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py35hee76f29_0", + "pexpect 4.2.1 py35h8b56cb4_0", + "pickleshare 0.7.4 py35hd57304d_0", + "pillow 4.2.1 py35h03abc04_0", + "pip 9.0.1 py35haa8ec2a_3", + "pixman 0.34.0 h83dc358_2", + "pkginfo 1.4.1 py35hb526c55_1", + "ply 3.10 py35h459f1a0_0", + "prompt_toolkit 1.0.15 py35hc09de7a_0", + "psutil 5.4.0 py35ha5baf80_0", + "ptyprocess 0.5.2 py35h38ce0a3_0", + "py 1.4.34 py35hd71111f_1", + "pycodestyle 2.3.1 py35h8d2105a_0", + "pycosat 0.6.2 py35h9693557_1", + "pycparser 2.18 py35h61b3040_1", + "pycrypto 2.6.1 py35h9852db7_1", + "pycurl 7.43.0 py35h7a9665c_3", + "pyflakes 1.6.0 py35hd1da72e_0", + "pygments 2.2.0 py35h0f41973_0", + "pylint 1.7.4 py35h319e60b_0", + "pyodbc 4.0.17 py35h89a430b_0", + "pyopenssl 17.2.0 py35h1d2a76c_0", + "pyparsing 2.2.0 py35h041ed72_1", + "pyqt 5.6.0 py35h0e41ada_5", + "pysocks 1.6.7 py35h6aefbb0_1", + "pytables 3.4.2 py35hfa98db7_2", + "pytest 3.2.1 py35hc97c719_1", + "python 3.5.4 he2c66cf_20", + "python-dateutil 2.6.1 py35h90d5b31_1", + "pytz 2017.2 py35h9225bff_1", + "pywavelets 0.5.2 py35h53ec731_0", + "pyyaml 3.12 py35h46ef4ae_1", + "pyzmq 16.0.2 py35h4be1f71_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py35hd68ff89_0", + "qtconsole 4.3.1 py35h4626a06_0", + "qtpy 1.3.1 py35h881af26_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py35hb9e6ad1_1", + "rope 0.10.5 py35h31d6b7c_0", + "ruamel_yaml 0.11.14 py35h8e2c16b_2", + "scikit-image 0.13.0 py35h3573165_1", + "scikit-learn 0.19.1 py35hbf1f462_0", + "scipy 0.19.1 py35ha8f041b_3", + "seaborn 0.8.0 py35h15a2772_0", + "setuptools 36.5.0 py35ha8c1747_0", + "simplegeneric 0.8.1 py35h2ec4104_0", + "singledispatch 3.4.0.3 py35h0cd4ec3_0", + "sip 4.18.1 py35h9eaea60_2", + "six 1.11.0 py35h423b573_1", + "snowballstemmer 1.2.1 py35h5435977_0", + "sortedcollections 0.5.3 py35hb2f60ff_0", + "sortedcontainers 1.5.7 py35h683703c_0", + "sphinx 1.6.3 py35hea25a1c_0", + "sphinxcontrib 1.0 py35hcb7efd2_1", + "sphinxcontrib-websupport 1.0.1 py35h3537809_1", + "spyder 3.2.4 py35h27cea69_0", + "sqlalchemy 1.1.13 py35h4911131_0", + "sqlite 3.20.1 h6d8b0f3_1", + "statsmodels 0.8.0 py35haa9d50b_0", + "sympy 1.1.1 py35h919b29a_0", + "tblib 1.3.2 py35hf1eb0b4_0", + "terminado 0.6 py35hce234ed_0", + "testpath 0.3.1 py35had42eaf_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py35h90f1797_0", + "tornado 4.5.2 py35hf879e1d_0", + "traitlets 4.3.2 py35ha522a97_0", + "typing 3.6.2 py35hcadae7e_0", + "unicodecsv 0.14.1 py35h4805c0c_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py35h2ab6e29_0", + "wcwidth 0.1.7 py35hcd08066_0", + "webencodings 0.5.1 py35hb6cf162_1", + "werkzeug 0.12.2 py35hbfc1ea6_0", + "wheel 0.29.0 py35h601ca99_1", + "widgetsnbextension 3.0.2 py35h0be620c_1", + "wrapt 1.10.11 py35hfdafd39_0", + "xlrd 1.1.0 py35h45a0a2a_1", + "xlsxwriter 1.0.2 py35h8ee9321_0", + "xlwt 1.3.0 py35h884a0cf_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.3 py35h29275ca_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "0a121a181cd217696af890ee689138ac", + "name": "anaconda", + "namespace": "python", + "sha256": "4102fcbfc3c172e58f26f9b7202f1e109f9e06c17af0d5cc39fe680999d7baf1", + "size": 11880, + "subdir": "linux-64", + "timestamp": 1508799451658, + "version": "5.0.1" + }, + "anaconda-5.0.1-py36hd30a520_1.conda": { + "build": "py36hd30a520_1", + "build_number": 1, + "depends": [ + "alabaster 0.7.10 py36h306e16b_0", + "anaconda-client 1.6.5 py36h19c0dcd_0", + "anaconda-navigator 1.6.9 py36h11ddaaa_0", + "anaconda-project 0.8.0 py36h29abdf5_0", + "asn1crypto 0.22.0 py36h265ca7c_1", + "astroid 1.5.3 py36hbdb9df2_0", + "astropy 2.0.2 py36ha51211e_4", + "babel 2.5.0 py36h7d14adf_0", + "backports 1.0 py36hfa02d7e_1", + "backports.shutil_get_terminal_size 1.0.0 py36hfea85ff_2", + "beautifulsoup4 4.6.0 py36h49b8c8c_1", + "bitarray 0.8.1 py36h5834eb8_0", + "bkcharts 0.2 py36h735825a_0", + "blaze 0.11.3 py36h4e06776_0", + "bleach 2.0.0 py36h688b259_0", + "bokeh 0.12.10 py36hbb0e44a_0", + "boto 2.48.0 py36h6e4cd66_1", + "bottleneck 1.2.1 py36haac1ea0_0", + "bzip2 1.0.6 h0376d23_1", + "ca-certificates 2017.08.26 h1d4fec5_0", + "cairo 1.14.10 haa5651f_5", + "certifi 2017.7.27.1 py36h8b7b77e_0", + "cffi 1.10.0 py36had8d393_1", + "chardet 3.0.4 py36h0f667ec_1", + "click 6.7 py36h5253387_0", + "cloudpickle 0.4.0 py36h30f8c20_0", + "clyent 1.2.2 py36h7e57e65_1", + "colorama 0.3.9 py36h489cec4_0", + "contextlib2 0.5.5 py36h6c84a62_0", + "cryptography 2.0.3 py36ha225213_1", + "curl 7.55.1 hcb0b314_2", + "cycler 0.10.0 py36h93f1223_0", + "cython 0.26.1 py36h21c49d0_0", + "cytoolz 0.8.2 py36h708bfd4_0", + "dask 0.15.3 py36hdc2c8aa_0", + "dask-core 0.15.3 py36h10e6167_0", + "datashape 0.5.4 py36h3ad6b5c_0", + "dbus 1.10.22 h3b5a359_0", + "decorator 4.1.2 py36hd076ac8_0", + "distributed 1.19.1 py36h25f3894_0", + "docutils 0.14 py36hb0f60f5_0", + "entrypoints 0.2.3 py36h1aec115_2", + "et_xmlfile 1.0.1 py36hd6bccc3_0", + "expat 2.2.4 hc00ebd1_1", + "fastcache 1.0.2 py36h5b0c431_0", + "filelock 2.0.12 py36hacfa1f5_0", + "flask 0.12.2 py36hb24657c_0", + "flask-cors 3.0.3 py36h2d857d3_0", + "fontconfig 2.12.4 h88586e7_1", + "freetype 2.8 h52ed37b_0", + "get_terminal_size 1.0.0 haa9412d_0", + "gevent 1.2.2 py36h2fe25dc_0", + "glib 2.53.6 hc861d11_1", + "glob2 0.5 py36h2c1b292_1", + "gmp 6.1.2 hb3b607b_0", + "gmpy2 2.0.8 py36h55090d7_1", + "graphite2 1.3.10 hc526e54_0", + "greenlet 0.4.12 py36h2d503a6_0", + "gst-plugins-base 1.12.2 he3457e5_0", + "gstreamer 1.12.2 h4f93127_0", + "h5py 2.7.0 py36he81ebca_1", + "harfbuzz 1.5.0 h2545bd6_0", + "hdf5 1.10.1 hb0523eb_0", + "heapdict 1.0.0 py36h79797d7_0", + "html5lib 0.999999999 py36h2cfc398_0", + "icu 58.2 h211956c_0", + "idna 2.6 py36h82fb2a8_1", + "imageio 2.2.0 py36he555465_0", + "imagesize 0.7.1 py36h52d8127_0", + "intel-openmp 2018.0.0 h15fc484_7", + "ipykernel 4.6.1 py36hbf841aa_0", + "ipython 6.1.0 py36hc72a948_1", + "ipython_genutils 0.2.0 py36hb52b0d5_0", + "ipywidgets 7.0.0 py36h7b55c3a_0", + "isort 4.2.15 py36had401c0_0", + "itsdangerous 0.24 py36h93cc618_1", + "jbig 2.1 hdba287a_0", + "jdcal 1.3 py36h4c697fb_0", + "jedi 0.10.2 py36h552def0_0", + "jinja2 2.9.6 py36h489bce4_1", + "jpeg 9b habf39ab_1", + "jsonschema 2.6.0 py36h006f8b5_0", + "jupyter 1.0.0 py36h9896ce5_0", + "jupyter_client 5.1.0 py36h614e9ea_0", + "jupyter_console 5.2.0 py36he59e554_1", + "jupyter_core 4.3.0 py36h357a921_0", + "jupyterlab 0.27.0 py36h86377d0_2", + "jupyterlab_launcher 0.4.0 py36h4d8058d_0", + "lazy-object-proxy 1.3.1 py36h10fcdad_0", + "libedit 3.1 heed3624_0", + "libffi 3.2.1 h4deb6c0_3", + "libgcc-ng 7.2.0 h7cc24e2_2", + "libgfortran-ng 7.2.0 h9f7466a_2", + "libpng 1.6.32 hda9c8bc_2", + "libsodium 1.0.13 h31c71d8_2", + "libssh2 1.8.0 h8c220ad_2", + "libstdcxx-ng 7.2.0 h7a57d05_2", + "libtiff 4.0.8 h90200ff_9", + "libtool 2.4.6 hd50d1a6_0", + "libxcb 1.12 h84ff03f_3", + "libxml2 2.9.4 h6b072ca_5", + "libxslt 1.1.29 hcf9102b_5", + "llvmlite 0.20.0 py36_0", + "locket 0.2.0 py36h787c0ad_1", + "lxml 4.1.0 py36h5b66e50_0", + "lzo 2.10 h1bfc0ba_1", + "markupsafe 1.0 py36hd9260cd_1", + "matplotlib 2.1.0 py36hba5de38_0", + "mccabe 0.6.1 py36h5ad9710_1", + "mistune 0.7.4 py36hbab8784_0", + "mkl 2018.0.0 hb491cac_4", + "mkl-service 1.1.2 py36h17a0993_4", + "mpc 1.0.3 hf803216_4", + "mpfr 3.1.5 h12ff648_1", + "mpmath 0.19 py36h8cc018b_2", + "msgpack-python 0.4.8 py36hec4c5d1_0", + "multipledispatch 0.4.9 py36h41da3fb_0", + "navigator-updater 0.1.0 py36h14770f7_0", + "nbconvert 5.3.1 py36hb41ffb7_0", + "nbformat 4.4.0 py36h31c9010_0", + "ncurses 6.0 h06874d7_1", + "networkx 2.0 py36h7e96fb8_0", + "nltk 3.2.4 py36h1a0979f_0", + "nose 1.3.7 py36hcdf7029_2", + "notebook 5.0.0 py36h0b20546_2", + "numba 0.35.0 np113py36_10", + "numexpr 2.6.2 py36hdd3393f_1", + "numpy 1.13.3 py36ha12f23b_0", + "numpydoc 0.7.0 py36h18f165f_0", + "odo 0.5.1 py36h90ed295_0", + "olefile 0.44 py36h79f9f78_0", + "openpyxl 2.4.8 py36h41dd2a8_1", + "openssl 1.0.2l h077ae2c_5", + "packaging 16.8 py36ha668100_1", + "pandas 0.20.3 py36h842e28d_2", + "pandoc 1.19.2.1 hea2e7c5_1", + "pandocfilters 1.4.2 py36ha6701b7_1", + "pango 1.40.11 h8191d47_0", + "partd 0.3.8 py36h36fd896_0", + "patchelf 0.9 hf79760b_2", + "path.py 10.3.1 py36he0c6f6d_0", + "pathlib2 2.3.0 py36h49efa8e_0", + "patsy 0.4.1 py36ha3be15e_0", + "pcre 8.41 hc71a17e_0", + "pep8 1.7.0 py36h26ade29_0", + "pexpect 4.2.1 py36h3b9d41b_0", + "pickleshare 0.7.4 py36h63277f8_0", + "pillow 4.2.1 py36h9119f52_0", + "pip 9.0.1 py36h8ec8b28_3", + "pixman 0.34.0 h83dc358_2", + "pkginfo 1.4.1 py36h215d178_1", + "ply 3.10 py36hed35086_0", + "prompt_toolkit 1.0.15 py36h17d85b1_0", + "psutil 5.4.0 py36h84c53db_0", + "ptyprocess 0.5.2 py36h69acd42_0", + "py 1.4.34 py36h0712aa3_1", + "pycodestyle 2.3.1 py36hf609f19_0", + "pycosat 0.6.2 py36h1a0ea17_1", + "pycparser 2.18 py36hf9f622e_1", + "pycrypto 2.6.1 py36h6998063_1", + "pycurl 7.43.0 py36h5e72054_3", + "pyflakes 1.6.0 py36h7bd6a15_0", + "pygments 2.2.0 py36h0d3125c_0", + "pylint 1.7.4 py36hb9d4533_0", + "pyodbc 4.0.17 py36h999153c_0", + "pyopenssl 17.2.0 py36h5cc804b_0", + "pyparsing 2.2.0 py36hee85983_1", + "pyqt 5.6.0 py36h0386399_5", + "pysocks 1.6.7 py36hd97a5b1_1", + "pytables 3.4.2 py36h3b5282a_2", + "pytest 3.2.1 py36h11ad3bb_1", + "python 3.6.3 hc9025b9_1", + "python-dateutil 2.6.1 py36h88d3b88_1", + "pytz 2017.2 py36hc2ccc2a_1", + "pywavelets 0.5.2 py36he602eb0_0", + "pyyaml 3.12 py36hafb9ca4_1", + "pyzmq 16.0.2 py36h3b0cf96_2", + "qt 5.6.2 h974d657_12", + "qtawesome 0.4.4 py36h609ed8c_0", + "qtconsole 4.3.1 py36h8f73b5b_0", + "qtpy 1.3.1 py36h3691cc8_0", + "readline 7.0 hac23ff0_3", + "requests 2.18.4 py36he2e5f8d_1", + "rope 0.10.5 py36h1f8c17e_0", + "ruamel_yaml 0.11.14 py36ha2fb22d_2", + "scikit-image 0.13.0 py36had3c07a_1", + "scikit-learn 0.19.1 py36h7aa7ec6_0", + "scipy 0.19.1 py36h9976243_3", + "seaborn 0.8.0 py36h197244f_0", + "setuptools 36.5.0 py36he42e2e1_0", + "simplegeneric 0.8.1 py36h2cb9092_0", + "singledispatch 3.4.0.3 py36h7a266c3_0", + "sip 4.18.1 py36h51ed4ed_2", + "six 1.11.0 py36h372c433_1", + "snowballstemmer 1.2.1 py36h6febd40_0", + "sortedcollections 0.5.3 py36h3c761f9_0", + "sortedcontainers 1.5.7 py36hdf89491_0", + "sphinx 1.6.3 py36he5f0bdb_0", + "sphinxcontrib 1.0 py36h6d0f590_1", + "sphinxcontrib-websupport 1.0.1 py36hb5cb234_1", + "spyder 3.2.4 py36hbe6152b_0", + "sqlalchemy 1.1.13 py36hfb5efd7_0", + "sqlite 3.20.1 h6d8b0f3_1", + "statsmodels 0.8.0 py36h8533d0b_0", + "sympy 1.1.1 py36hc6d1c1c_0", + "tblib 1.3.2 py36h34cf8b6_0", + "terminado 0.6 py36ha25a19f_0", + "testpath 0.3.1 py36h8cadb63_0", + "tk 8.6.7 h5979e9b_1", + "toolz 0.8.2 py36h81f2dff_0", + "tornado 4.5.2 py36h1283b2a_0", + "traitlets 4.3.2 py36h674d592_0", + "typing 3.6.2 py36h7da032a_0", + "unicodecsv 0.14.1 py36ha668878_0", + "unixodbc 2.3.4 hc36303a_1", + "urllib3 1.22 py36hbe7ace6_0", + "wcwidth 0.1.7 py36hdf4376a_0", + "webencodings 0.5.1 py36h800622e_1", + "werkzeug 0.12.2 py36hc703753_0", + "wheel 0.29.0 py36he7f4e38_1", + "widgetsnbextension 3.0.2 py36hd01bb71_1", + "wrapt 1.10.11 py36h28b7045_0", + "xlrd 1.1.0 py36h1db9f0c_1", + "xlsxwriter 1.0.2 py36h3de1aca_0", + "xlwt 1.3.0 py36h7b00a1f_0", + "xz 5.2.3 h2bcbf08_1", + "yaml 0.1.7 h96e3832_1", + "zeromq 4.2.2 hb0b69da_1", + "zict 0.1.3 py36h3a3bf81_0", + "zlib 1.2.11 hfbfcf68_1" + ], + "license": "BSD", + "md5": "73020863be03e96b9da5fce3d271882e", + "name": "anaconda", + "namespace": "python", + "sha256": "51ff3f582d3a101b03c0f08118b244145efa3f0850e80e4eefd7dd156090610a", + "size": 11777, + "subdir": "linux-64", + "timestamp": 1508799487342, + "version": "5.0.1" + }, + "anaconda-5.1.0-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "et_xmlfile 1.0.1 py27h75840f5_0", + "jbig 2.1 hdba287a_0", + "qt 5.6.2 h974d657_12", + "expat 2.2.5 he0dffb1_0", + "sqlite 3.22.0 h1bed415_0", + "simplegeneric 0.8.1 py27_2", + "ptyprocess 0.5.2 py27h4ccb14c_0", + "pytz 2017.3 py27h001bace_0", + "jinja2 2.10 py27h4114e70_0", + "libedit 3.1 heed3624_0", + "rope 0.10.7 py27hfe459b0_0", + "gst-plugins-base 1.12.4 h33fb286_0", + "boto 2.48.0 py27h9556ac2_1", + "pixman >=0.34.0,<1.0a0", + "libxml2 >=2.9.7,<2.10.0a0", + "pandas 0.22.0 py27hf484d3e_0", + "qtconsole 4.3.1 py27hc444b0d_0", + "gstreamer >=1.12.4,<1.13.0a0", + "seaborn 0.8.1 py27h633ea1e_0", + "flask 0.12.2 py27h6d5c1cd_0", + "pysocks 1.6.7 py27he2db6d2_1", + "backports 1.0 py27h63c9359_1", + "pytest 3.3.2 py27_0", + "distributed 1.20.2 py27_0", + "pyzmq 16.0.3 py27hc579512_0", + "xlrd 1.1.0 py27ha77178f_1", + "pathlib2 2.3.0 py27h6e9d198_0", + "flask-cors 3.0.3 py27h1a8a27f_0", + "pyodbc 4.0.22 py27hf484d3e_0", + "matplotlib 2.1.2 py27h0e671d2_0", + "ncurses >=6.0,<7.0a0", + "zlib >=1.2.11,<1.3.0a0", + "mccabe 0.6.1 py27h0e7c7be_1", + "entrypoints 0.2.3 py27h502b47d_2", + "ssl_match_hostname 3.5.0.1 py27h4ec10b9_2", + "ruamel_yaml 0.15.35 py27h14c3975_1", + "lzo >=2.10,<3.0a0", + "certifi 2018.1.18 py27_0", + "freetype 2.8 hab7d2ae_1", + "openssl 1.0.2n hb7f436b_0", + "prompt_toolkit 1.0.15 py27h1b593e1_0", + "pycodestyle 2.3.1 py27h904819d_0", + "jpeg 9b h024ee3a_2", + "dask 0.16.1 py27_0", + "pluggy 0.6.0 py27h1f4f128_0", + "xz >=5.2.3,<6.0a0", + "libpng >=1.6.34,<1.7.0a0", + "h5py 2.7.1 py27h2697762_0", + "gmp 6.1.2 h6c8ec71_1", + "libtiff >=4.0.9,<5.0a0", + "libpng 1.6.34 hb9fc6fc_0", + "datashape 0.5.4 py27hf507385_0", + "jdcal 1.3 py27h2cc5433_0", + "graphite2 1.3.10 hf63cedd_1", + "python 2.7.14 h1571d57_29", + "functools32 3.2.3.2 py27h4ead58f_1", + "wheel 0.30.0 py27h2bc6bb2_1", + "cdecimal 2.3 py27h14c3975_3", + "scandir 1.6 py27hf7388dc_0", + "urllib3 1.22 py27ha55213b_0", + "jupyter_core 4.4.0 py27h345911c_0", + "pyqt 5.6.0 py27h4b1e83c_5", + "bzip2 1.0.6 h9a117a8_4", + "pylint 1.8.2 py27_0", + "expat >=2.2.5,<3.0a0", + "bottleneck 1.2.1 py27h21b16a3_0", + "bzip2 >=1.0.6,<2.0a0", + "pycurl 7.43.0.1 py27hb7f436b_0", + "libssh2 >=1.8.0,<2.0a0", + "mpmath 1.0.0 py27h9669132_2", + "beautifulsoup4 4.6.0 py27h3f86ba9_1", + "glib 2.53.6 h5d9569c_2", + "readline 7.0 ha6073c6_4", + "ipykernel 4.8.0 py27_0", + "ipython 5.4.1 py27_2", + "clyent 1.2.2 py27h7276e6c_1", + "isort 4.2.15 py27hcfa4749_0", + "packaging 16.8 py27h5e07c7c_1", + "traitlets 4.3.2 py27hd6ce930_0", + "tornado 4.5.3 py27_0", + "olefile 0.45.1 py27_0", + "pillow 5.0.0 py27h3deb7b8_0", + "greenlet 0.4.12 py27hac09c53_0", + "itsdangerous 0.24 py27hb8295c1_1", + "scikit-image 0.13.1 py27h14c3975_1", + "psutil 5.4.3 py27h14c3975_0", + "dbus 1.12.2 hc3f9b76_1", + "idna 2.6 py27h5722d68_1", + "yaml 0.1.7 had09818_2", + "scikit-learn 0.19.1 py27h445a80a_0", + "pycparser 2.18 py27hefa08c5_1", + "ply 3.10 py27hd6d9ae5_0", + "snowballstemmer 1.2.1 py27h44e2768_0", + "xlwt 1.3.0 py27h3d85d97_0", + "bkcharts 0.2 py27h241ae91_0", + "lzo 2.10 h49e0be7_2", + "pip 9.0.1 py27ha730c48_4", + "jsonschema 2.6.0 py27h7ed5aa4_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "toolz 0.9.0 py27_0", + "pyflakes 1.6.0 py27h904a57d_0", + "bleach 2.1.2 py27_0", + "six 1.11.0 py27h5f960f1_1", + "zict 0.1.3 py27h12c336c_0", + "openssl >=1.0.2n,<1.0.3a", + "markupsafe 1.0 py27h97b2822_1", + "jupyter_client 5.2.2 py27_0", + "bitarray 0.8.1 py27h14c3975_1", + "sympy 1.1.1 py27hc28188a_0", + "sphinxcontrib-websupport 1.0.1 py27hf906f22_1", + "libstdcxx-ng 7.2.0 h7a57d05_2", + "libffi >=3.2.1,<3.3a0", + "notebook 5.4.0 py27_0", + "testpath 0.3.1 py27hc38d2c4_0", + "harfbuzz >=1.7.4,<2.0a0", + "babel 2.5.3 py27_0", + "wcwidth 0.1.7 py27h9e3e1ab_0", + "xlsxwriter 1.0.2 py27h12cbc6b_0", + "cairo >=1.14.12,<2.0a0", + "mistune 0.8.3 py27_0", + "networkx 2.1 py27_0", + "pickleshare 0.7.4 py27h09770e1_0", + "unixodbc 2.3.4 hc36303a_1", + "pywavelets 0.5.2 py27hecda097_0", + "futures 3.2.0 py27h7b459c0_0", + "numpy 1.14.0 py27h3dfced4_1", + "nose 1.3.7 py27heec2199_2", + "zeromq 4.2.2 hbedb6e5_2", + "setuptools 38.4.0 py27_0", + "patsy 0.5.0 py27_0", + "fontconfig 2.12.4 h88586e7_1", + "gevent 1.2.2 py27h475ea6a_0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "colorama 0.3.9 py27h5cde069_0", + "jpeg >=9b,<10a", + "libxcb >=1.12,<2.0a0", + "python-dateutil 2.6.1 py27h4ca5741_1", + "nltk 3.2.5 py27hec5f4de_0", + "bokeh 0.12.13 py27h5233db4_0", + "sphinx 1.6.6 py27_0", + "llvmlite 0.21.0 py27h6dad3f9_0", + "asn1crypto 0.24.0 py27_0", + "qtpy 1.3.1 py27h63d3751_0", + "pkginfo 1.4.1 py27hee1a9ad_1", + "heapdict 1.0.0 py27_2", + "cairo 1.14.12 h77bcde2_0", + "cytoolz 0.9.0 py27h14c3975_0", + "wrapt 1.10.11 py27h04f6869_0", + "chardet 3.0.4 py27hfa10054_1", + "blaze 0.11.3 py27h5f341da_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "libffi 3.2.1 hd88cf55_4", + "decorator 4.2.1 py27_0", + "libcurl 7.58.0 h1ad7b7a_0", + "grin 1.2.1 py27_4", + "pyyaml 3.12 py27h2d70dd7_1", + "gmpy2 2.0.8 py27h4cf3fa8_2", + "intel-openmp 2018.0.0 hc7b2577_8", + "pycairo 1.15.4 py27h1b9232e_1", + "harfbuzz 1.7.4 hc5b324e_0", + "tblib 1.3.2 py27h51fe5ba_0", + "ncurses 6.0 h9df7e31_2", + "py 1.5.2 py27h203d672_0", + "pango >=1.41.0,<2.0a0", + "gstreamer 1.12.4 hb53b477_0", + "spyder 3.2.6 py27_0", + "openpyxl 2.4.10 py27_0", + "pep8 1.7.1 py27_0", + "icu 58.2 h9c2bf20_1", + "cython 0.27.3 py27hc56b35e_0", + "mpfr 3.1.5 h11a74b3_2", + "libxslt 1.1.32 h1312cb7_0", + "dbus >=1.12.2,<2.0a0", + "numba 0.36.2 np114py27he2868da_0", + "odo 0.5.1 py27h9170de3_0", + "docutils 0.14 py27hae222c1_0", + "terminado 0.8.1 py27_1", + "msgpack-python 0.5.1 py27h6bb024c_0", + "backports.shutil_get_terminal_size 1.0.0 py27h5bc021e_2", + "fontconfig >=2.12.4,<3.0a0", + "jupyter 1.0.0 py27_4", + "sortedcontainers 1.5.9 py27_0", + "backports.functools_lru_cache 1.4 py27he8db605_1", + "pcre 8.41 hc27e229_1", + "mpc 1.0.3 hec55b23_5", + "tk 8.6.7 hc745277_3", + "lxml 4.1.1 py27hf71bdeb_1", + "freetype >=2.8,<2.9.0a0", + "tk >=8.6.7,<8.7.0a0", + "ipython_genutils 0.2.0 py27h89fb69b_0", + "pycosat 0.6.3 py27ha4109ae_0", + "pexpect 4.3.1 py27_0", + "anaconda-client 1.6.9 py27_0", + "imageio 2.2.0 py27hf108a7f_0", + "send2trash 1.4.2 py27_0", + "nbformat 4.4.0 py27hed7f2b2_0", + "numexpr 2.6.4 py27hd318778_0", + "enum34 1.1.6 py27h99a27e9_1", + "ipaddress 1.0.19 py27_0", + "libxslt >=1.1.32,<2.0a0", + "multipledispatch 0.4.9 py27h9b5f95a_0", + "yaml >=0.1.7,<0.2.0a0", + "pandocfilters 1.4.2 py27h428e1e5_1", + "contextlib2 0.5.5 py27hbf4c468_0", + "pygments 2.2.0 py27h4a8b6f5_0", + "click 6.7 py27h4225b90_0", + "nbconvert 5.3.1 py27he041f76_0", + "jupyter_console 5.2.0 py27hc6bee7e_1", + "cffi 1.11.4 py27h9745a5d_0", + "pyparsing 2.2.0 py27hf1513f8_1", + "subprocess32 3.2.7 py27h373dbce_0", + "sortedcollections 0.5.3 py27h135218e_0", + "anaconda-project 0.8.2 py27h236b58a_0", + "lazy-object-proxy 1.3.1 py27h682c727_0", + "libgcc-ng 7.2.0 h7cc24e2_2", + "html5lib 1.0.1 py27h5233db4_0", + "curl 7.58.0 h84994c4_0", + "filelock 2.0.13 py27h61a9c69_0", + "libtiff 4.0.9 h28f6b97_0", + "sphinxcontrib 1.0 py27h1512b58_1", + "pyopenssl 17.5.0 py27hcee3be0_0", + "pycrypto 2.6.1 py27h14c3975_7", + "cycler 0.10.0 py27hc7354d3_0", + "mkl-service 1.1.2 py27hb2d42c5_4", + "dask-core 0.16.1 py27_0", + "sqlite >=3.22.0,<4.0a0", + "cloudpickle 0.5.2 py27_1", + "cryptography 2.1.4 py27h6697b16_0", + "sqlalchemy 1.2.1 py27h14c3975_0", + "qtawesome 0.4.4 py27hd7914c3_0", + "libsodium 1.0.15 hf101ebd_0", + "parso 0.1.1 py27h718acc2_0", + "libxml2 2.9.7 h26e45fe_0", + "astropy 2.0.3 py27h14c3975_0", + "scipy 1.0.0 py27hf5f0f52_0", + "astroid 1.6.1 py27_0", + "fastcache 1.0.2 py27h14c3975_2", + "pango 1.41.0 hd475d92_0", + "partd 0.3.8 py27h4e55004_0", + "pytables 3.4.2 py27h1f7bffc_2", + "graphite2 >=1.3.10,<2.0a0", + "singledispatch 3.4.0.3 py27h9bcb476_0", + "attrs 17.4.0 py27_0", + "glob2 0.6 py27hcea9cbd_0", + "locket 0.2.0 py27h73929a2_1", + "patchelf 0.9 hf79760b_2", + "werkzeug 0.14.1 py27_0", + "numpydoc 0.7.0 py27h9647a75_0", + "libxcb 1.12 hcd93eb1_4", + "libssh2 1.8.0 h9cfc8f7_4", + "zlib 1.2.11 ha838bed_2", + "requests 2.18.4 py27hc5b0589_1", + "typing 3.6.2 py27h66f49e2_0", + "mkl 2018.0.1 h19d6760_4", + "imagesize 0.7.1 py27hd17bf80_0", + "pixman 0.34.0 hceecf20_3", + "gmp >=6.1.2", + "sip 4.18.1 py27he9ba0ab_2", + "icu >=58.2,<59.0a0", + "jupyterlab 0.31.5 py27_0", + "webencodings 0.5.1 py27hff10b21_1", + "path.py 10.5 py27hefe4bee_0", + "libcurl >=7.58.0,<8.0a0", + "alabaster 0.7.10 py27he5a193a_0", + "configparser 3.5.0 py27h5117587_0", + "glib >=2.53.6,<3.0a0", + "get_terminal_size 1.0.0 haa9412d_0", + "gst-plugins-base >=1.12.4,<1.13.0a0", + "libgfortran-ng 7.2.0 h9f7466a_2", + "libtool 2.4.6 h544aabb_3", + "xz 5.2.3 h55aa19d_2", + "hdf5 1.10.1 h9caa474_1", + "jedi 0.11.1 py27_0", + "unicodecsv 0.14.1 py27h5062da9_0", + "widgetsnbextension 3.1.0 py27_0", + "funcsigs 1.0.2 py27h83f16ab_0", + "jupyterlab_launcher 0.10.2 py27_0", + "readline >=7.0,<8.0a0", + "backports_abc 0.5 py27h7b3c97b_0", + "ipywidgets 7.1.1 py27_0", + "statsmodels 0.8.0 py27hc87d62d_0" + ], + "license": "BSD", + "md5": "39f472efa2c07ce56bfd7d56cdfae4da", + "name": "anaconda", + "namespace": "python", + "sha256": "b436c7548e980a96e83b1d5088932ea785f47f9ee16f156ffd84c0e3d635087a", + "size": 11992, + "subdir": "linux-64", + "timestamp": 1518523519130, + "version": "5.1.0" + }, + "anaconda-5.1.0-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "lxml 4.1.1 py35hf71bdeb_1", + "patchelf 0.9 hf79760b_2", + "bitarray 0.8.1 py35h14c3975_1", + "libpng 1.6.34 hb9fc6fc_0", + "gmp 6.1.2 h6c8ec71_1", + "libtiff >=4.0.9,<5.0a0", + "qtawesome 0.4.4 py35hd68ff89_0", + "pango >=1.41.0,<2.0a0", + "blaze 0.11.3 py35ha2c9137_0", + "pygments 2.2.0 py35h0f41973_0", + "gstreamer >=1.12.4,<1.13.0a0", + "statsmodels 0.8.0 py35haa9d50b_0", + "jupyter 1.0.0 py35_4", + "jbig 2.1 hdba287a_0", + "libxcb >=1.12,<2.0a0", + "pylint 1.8.2 py35_0", + "pandas 0.22.0 py35hf484d3e_0", + "pip 9.0.1 py35h7e7da9d_4", + "libxcb 1.12 hcd93eb1_4", + "h5py 2.7.1 py35h8d53cdc_0", + "requests 2.18.4 py35hb9e6ad1_1", + "jpeg 9b h024ee3a_2", + "libssh2 1.8.0 h9cfc8f7_4", + "ply 3.10 py35h459f1a0_0", + "sympy 1.1.1 py35h919b29a_0", + "freetype 2.8 hab7d2ae_1", + "jupyter_console 5.2.0 py35h4044a63_1", + "boto 2.48.0 py35h2cfd601_1", + "lazy-object-proxy 1.3.1 py35h4c720c6_0", + "pyopenssl 17.5.0 py35h4f8b8c8_0", + "xz 5.2.3 h55aa19d_2", + "bleach 2.1.2 py35_0", + "pluggy 0.6.0 py35hb428803_0", + "pycparser 2.18 py35h61b3040_1", + "toolz 0.9.0 py35_0", + "contextlib2 0.5.5 py35h6690dba_0", + "dask 0.16.1 py35_0", + "libstdcxx-ng 7.2.0 h7a57d05_2", + "expat >=2.2.5,<3.0a0", + "packaging 16.8 py35h2260b46_1", + "qtconsole 4.3.1 py35h4626a06_0", + "mistune 0.8.3 py35_0", + "libxml2 >=2.9.7,<2.10.0a0", + "gmpy2 2.0.8 py35hd0a1c9a_2", + "harfbuzz 1.7.4 hc5b324e_0", + "fontconfig >=2.12.4,<3.0a0", + "bzip2 1.0.6 h9a117a8_4", + "jupyterlab_launcher 0.10.2 py35_0", + "six 1.11.0 py35h423b573_1", + "cycler 0.10.0 py35hc4d5149_0", + "idna 2.6 py35h8605a33_1", + "mpmath 1.0.0 py35h7ce6e34_2", + "sip 4.18.1 py35h9eaea60_2", + "gevent 1.2.2 py35he064abf_0", + "libffi >=3.2.1,<3.3a0", + "numpy 1.14.0 py35h3dfced4_1", + "python-dateutil 2.6.1 py35h90d5b31_1", + "pango 1.41.0 hd475d92_0", + "wheel 0.30.0 py35hd3883cf_1", + "unicodecsv 0.14.1 py35h4805c0c_0", + "zlib 1.2.11 ha838bed_2", + "pycodestyle 2.3.1 py35h8d2105a_0", + "et_xmlfile 1.0.1 py35hde8d43e_0", + "html5lib 1.0.1 py35h2f9c1c0_0", + "markupsafe 1.0 py35h4f4fcf6_1", + "decorator 4.2.1 py35_0", + "wrapt 1.10.11 py35hfdafd39_0", + "numba 0.36.2 np114py35ha126a20_0", + "parso 0.1.1 py35h1b200a3_0", + "ptyprocess 0.5.2 py35h38ce0a3_0", + "glib >=2.53.6,<3.0a0", + "xlrd 1.1.0 py35h45a0a2a_1", + "glib 2.53.6 h5d9569c_2", + "sqlite 3.22.0 h1bed415_0", + "tk >=8.6.7,<8.7.0a0", + "python 3.5.4 h417fded_24", + "pyflakes 1.6.0 py35hd1da72e_0", + "zict 0.1.3 py35h29275ca_0", + "prompt_toolkit 1.0.15 py35hc09de7a_0", + "pywavelets 0.5.2 py35h53ec731_0", + "astroid 1.6.1 py35_0", + "ipython_genutils 0.2.0 py35hc9e07d0_0", + "jpeg >=9b,<10a", + "certifi 2018.1.18 py35_0", + "asn1crypto 0.24.0 py35_0", + "cython 0.27.3 py35h6cdc64b_0", + "zlib >=1.2.11,<1.3.0a0", + "colorama 0.3.9 py35h81e2b6c_0", + "bkcharts 0.2 py35he4f7e30_0", + "hdf5 1.10.1 h9caa474_1", + "distributed 1.20.2 py35_0", + "libffi 3.2.1 hd88cf55_4", + "nbformat 4.4.0 py35h12e6e07_0", + "partd 0.3.8 py35h68187f2_0", + "chardet 3.0.4 py35hb6e9ddf_1", + "pycurl 7.43.0.1 py35hb7f436b_0", + "ca-certificates 2017.08.26 h1d4fec5_0", + "imageio 2.2.0 py35hd0a6de2_0", + "gst-plugins-base 1.12.4 h33fb286_0", + "curl 7.58.0 h84994c4_0", + "sphinxcontrib 1.0 py35hcb7efd2_1", + "cloudpickle 0.5.2 py35_1", + "anaconda-project 0.8.2 py35h7d62c80_0", + "cryptography 2.1.4 py35hbeb2da1_0", + "lzo >=2.10,<3.0a0", + "sqlalchemy 1.2.1 py35h14c3975_0", + "freetype >=2.8,<2.9.0a0", + "libgfortran-ng 7.2.0 h9f7466a_2", + "attrs 17.4.0 py35_0", + "networkx 2.1 py35_0", + "isort 4.2.15 py35h44a00d2_0", + "snowballstemmer 1.2.1 py35h5435977_0", + "nose 1.3.7 py35hdc64897_2", + "filelock 2.0.13 py35h4160c53_0", + "simplegeneric 0.8.1 py35_2", + "expat 2.2.5 he0dffb1_0", + "rope 0.10.7 py35h986144c_0", + "lzo 2.10 h49e0be7_2", + "dbus >=1.12.2,<2.0a0", + "jsonschema 2.6.0 py35h4395190_0", + "mkl-service 1.1.2 py35h0fc7090_4", + "backports.shutil_get_terminal_size 1.0.0 py35h40844db_2", + "py 1.5.2 py35hfe8c5ce_0", + "openssl >=1.0.2n,<1.0.3a", + "flask-cors 3.0.3 py35h9b2065d_0", + "bokeh 0.12.13 py35h2f9c1c0_0", + "pixman 0.34.0 hceecf20_3", + "seaborn 0.8.1 py35h04cba02_0", + "itsdangerous 0.24 py35h7c46880_1", + "dask-core 0.16.1 py35_0", + "send2trash 1.4.2 py35_0", + "pathlib2 2.3.0 py35hd637de4_0", + "heapdict 1.0.0 py35_2", + "odo 0.5.1 py35h102315f_0", + "pycrypto 2.6.1 py35h14c3975_7", + "yaml >=0.1.7,<0.2.0a0", + "graphite2 >=1.3.10,<2.0a0", + "bottleneck 1.2.1 py35he1b16f1_0", + "pcre 8.41 hc27e229_1", + "pandoc 1.19.2.1 hea2e7c5_1", + "ipywidgets 7.1.1 py35_0", + "ruamel_yaml 0.15.35 py35h14c3975_1", + "multipledispatch 0.4.9 py35h2ff591a_0", + "pyparsing 2.2.0 py35h041ed72_1", + "clyent 1.2.2 py35h491ffcb_1", + "libpng >=1.6.34,<1.7.0a0", + "typing 3.6.2 py35hcadae7e_0", + "mpfr 3.1.5 h11a74b3_2", + "get_terminal_size 1.0.0 haa9412d_0", + "libxml2 2.9.7 h26e45fe_0", + "libtool 2.4.6 h544aabb_3", + "glob2 0.6 py35hff66265_0", + "numexpr 2.6.4 py35h119f745_0", + "greenlet 0.4.12 py35h2547b41_0", + "testpath 0.3.1 py35had42eaf_0", + "traitlets 4.3.2 py35ha522a97_0", + "openpyxl 2.4.10 py35_0", + "mpc 1.0.3 hec55b23_5", + "cairo >=1.14.12,<2.0a0", + "pyodbc 4.0.22 py35hf484d3e_0", + "werkzeug 0.14.1 py35_0", + "ncurses >=6.0,<7.0a0", + "click 6.7 py35h353a69f_0", + "pandocfilters 1.4.2 py35h1565a15_1", + "pyzmq 16.0.3 py35ha889422_0", + "singledispatch 3.4.0.3 py35h0cd4ec3_0", + "pycosat 0.6.3 py35h6b6bb97_0", + "graphite2 1.3.10 hf63cedd_1", + "intel-openmp 2018.0.0 hc7b2577_8", + "scikit-image 0.13.1 py35h14c3975_1", + "libssh2 >=1.8.0,<2.0a0", + "setuptools 38.4.0 py35_0", + "jupyterlab 0.31.5 py35_0", + "fontconfig 2.12.4 h88586e7_1", + "qtpy 1.3.1 py35h881af26_0", + "readline 7.0 ha6073c6_4", + "libxslt 1.1.32 h1312cb7_0", + "dbus 1.12.2 hc3f9b76_1", + "cytoolz 0.9.0 py35h14c3975_0", + "numpydoc 0.7.0 py35he089a57_0", + "astropy 2.0.3 py35h14c3975_0", + "ipykernel 4.8.0 py35_0", + "imagesize 0.7.1 py35hf008fae_0", + "psutil 5.4.3 py35h14c3975_0", + "pytables 3.4.2 py35hfa98db7_2", + "spyder 3.2.6 py35_0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "datashape 0.5.4 py35h5b068ae_0", + "babel 2.5.3 py35_0", + "anaconda-client 1.6.9 py35_0", + "pickleshare 0.7.4 py35hd57304d_0", + "path.py 10.5 py35h39c98c1_0", + "xz >=5.2.3,<6.0a0", + "tblib 1.3.2 py35hf1eb0b4_0", + "libcurl 7.58.0 h1ad7b7a_0", + "pillow 5.0.0 py35h3deb7b8_0", + "urllib3 1.22 py35h2ab6e29_0", + "icu >=58.2,<59.0a0", + "libsodium 1.0.15 hf101ebd_0", + "nbconvert 5.3.1 py35hc5194e3_0", + "patsy 0.5.0 py35_0", + "pixman >=0.34.0,<1.0a0", + "readline >=7.0,<8.0a0", + "openssl 1.0.2n hb7f436b_0", + "harfbuzz >=1.7.4,<2.0a0", + "pytz 2017.3 py35hb13c558_0", + "pep8 1.7.1 py35_0", + "jupyter_core 4.4.0 py35ha89e94b_0", + "mccabe 0.6.1 py35hd8c1f23_1", + "cairo 1.14.12 h77bcde2_0", + "pytest 3.3.2 py35_0", + "beautifulsoup4 4.6.0 py35h442a8c9_1", + "jinja2 2.10 py35h480ab6d_0", + "flask 0.12.2 py35h679e90e_0", + "pkginfo 1.4.1 py35hb526c55_1", + "notebook 5.4.0 py35_0", + "msgpack-python 0.5.1 py35h6bb024c_0", + "gst-plugins-base >=1.12.4,<1.13.0a0", + "cffi 1.11.4 py35h9745a5d_0", + "scipy 1.0.0 py35hcbbe4a2_0", + "bzip2 >=1.0.6,<2.0a0", + "sortedcollections 0.5.3 py35hb2f60ff_0", + "fastcache 1.0.2 py35h14c3975_2", + "matplotlib 2.1.2 py35h0e671d2_0", + "tk 8.6.7 hc745277_3", + "terminado 0.8.1 py35_1", + "ncurses 6.0 h9df7e31_2", + "gstreamer 1.12.4 hb53b477_0", + "unixodbc 2.3.4 hc36303a_1", + "webencodings 0.5.1 py35hb6cf162_1", + "nltk 3.2.5 py35h09ad193_0", + "sqlite >=3.22.0,<4.0a0", + "libxslt >=1.1.32,<2.0a0", + "jupyter_client 5.2.2 py35_0", + "gmp >=6.1.2", + "icu 58.2 h9c2bf20_1", + "scikit-learn 0.19.1 py35hbf1f462_0", + "sphinxcontrib-websupport 1.0.1 py35h3537809_1", + "libcurl >=7.58.0,<8.0a0", + "locket 0.2.0 py35h170bc82_1", + "mkl 2018.0.1 h19d6760_4", + "jdcal 1.3 py35hf1f7175_0", + "entrypoints 0.2.3 py35h48174a2_2", + "xlsxwriter 1.0.2 py35h8ee9321_0", + "sortedcontainers 1.5.9 py35_0", + "ipython 6.2.1 py35hd850d2a_1", + "widgetsnbextension 3.1.0 py35_0", + "pyyaml 3.12 py35h46ef4ae_1", + "backports 1.0 py35hd471ac7_1", + "pexpect 4.3.1 py35_0", + "xlwt 1.3.0 py35h884a0cf_0", + "yaml 0.1.7 had09818_2", + "qt 5.6.2 h974d657_12", + "pyqt 5.6.0 py35h0e41ada_5", + "olefile 0.45.1 py35_0", + "llvmlite 0.21.0 py35hcfd7307_0", + "wcwidth 0.1.7 py35hcd08066_0", + "docutils 0.14 py35hd11081d_0", + "libedit 3.1 heed3624_0", + "tornado 4.5.3 py35_0", + "sphinx 1.6.6 py35_0", + "alabaster 0.7.10 py35h6fb19ab_0", + "libgcc-ng 7.2.0 h7cc24e2_2", + "pysocks 1.6.7 py35h6aefbb0_1", + "zeromq 4.2.2 hbedb6e5_2", + "jedi 0.11.1 py35_0", + "libtiff 4.0.9 h28f6b97_0" + ], + "license": "BSD", + "md5": "6e2d48fae53f704a5b06b5fab1d894df", + "name": "anaconda", + "namespace": "python", + "sha256": "56c06fecebae11d2c45a2c773c8c5baf4810f62550000461257611feb41db2da", + "size": 11601, + "subdir": "linux-64", + "timestamp": 1518523630663, + "version": "5.1.0" + }, + "anaconda-5.1.0-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "jupyterlab_launcher 0.10.2 py36_0", + "mccabe 0.6.1 py36h5ad9710_1", + "bottleneck 1.2.1 py36haac1ea0_0", + "spyder 3.2.6 py36_0", + "numexpr 2.6.4 py36hc4a3f9a_0", + "pep8 1.7.1 py36_0", + "flask 0.12.2 py36hb24657c_0", + "beautifulsoup4 4.6.0 py36h49b8c8c_1", + "cryptography 2.1.4 py36hd09be54_0", + "pixman >=0.34.0,<1.0a0", + "expat 2.2.5 he0dffb1_0", + "qtconsole 4.3.1 py36h8f73b5b_0", + "libtool 2.4.6 h544aabb_3", + "dask 0.16.1 py36_0", + "libcurl >=7.58.0,<8.0a0", + "jupyter_core 4.4.0 py36h7c827e3_0", + "pyzmq 16.0.3 py36he2533c7_0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "send2trash 1.4.2 py36_0", + "sortedcollections 0.5.3 py36h3c761f9_0", + "glob2 0.6 py36he249c77_0", + "py 1.5.2 py36h29bf505_0", + "pluggy 0.6.0 py36hb689045_0", + "fontconfig >=2.12.4,<3.0a0", + "qtpy 1.3.1 py36h3691cc8_0", + "sqlite >=3.22.0,<4.0a0", + "locket 0.2.0 py36h787c0ad_1", + "scikit-learn 0.19.1 py36h7aa7ec6_0", + "lazy-object-proxy 1.3.1 py36h10fcdad_0", + "html5lib 1.0.1 py36h2f9c1c0_0", + "gmpy2 2.0.8 py36hc8893dd_2", + "cython 0.27.3 py36h1860423_0", + "bkcharts 0.2 py36h735825a_0", + "msgpack-python 0.5.1 py36h6bb024c_0", + "backports.shutil_get_terminal_size 1.0.0 py36hfea85ff_2", + "pixman 0.34.0 hceecf20_3", + "pango >=1.41.0,<2.0a0", + "partd 0.3.8 py36h36fd896_0", + "harfbuzz 1.7.4 hc5b324e_0", + "python-dateutil 2.6.1 py36h88d3b88_1", + "pip 9.0.1 py36h6c6f9ce_4", + "networkx 2.1 py36_0", + "libxslt 1.1.32 h1312cb7_0", + "tk 8.6.7 hc745277_3", + "scikit-image 0.13.1 py36h14c3975_1", + "bzip2 1.0.6 h9a117a8_4", + "pylint 1.8.2 py36_0", + "tk >=8.6.7,<8.7.0a0", + "wcwidth 0.1.7 py36hdf4376a_0", + "pywavelets 0.5.2 py36he602eb0_0", + "docutils 0.14 py36hb0f60f5_0", + "colorama 0.3.9 py36h489cec4_0", + "cycler 0.10.0 py36h93f1223_0", + "parso 0.1.1 py36h35f843b_0", + "cytoolz 0.9.0 py36h14c3975_0", + "gst-plugins-base >=1.12.4,<1.13.0a0", + "odo 0.5.1 py36h90ed295_0", + "contextlib2 0.5.5 py36h6c84a62_0", + "testpath 0.3.1 py36h8cadb63_0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "pycosat 0.6.3 py36h0a5515d_0", + "ply 3.10 py36hed35086_0", + "mpfr 3.1.5 h11a74b3_2", + "wrapt 1.10.11 py36h28b7045_0", + "xz 5.2.3 h55aa19d_2", + "markupsafe 1.0 py36hd9260cd_1", + "graphite2 1.3.10 hf63cedd_1", + "heapdict 1.0.0 py36_2", + "prompt_toolkit 1.0.15 py36h17d85b1_0", + "scipy 1.0.0 py36hbf646e7_0", + "numpydoc 0.7.0 py36h18f165f_0", + "certifi 2018.1.18 py36_0", + "bzip2 >=1.0.6,<2.0a0", + "ruamel_yaml 0.15.35 py36h14c3975_1", + "attrs 17.4.0 py36_0", + "cairo >=1.14.12,<2.0a0", + "jdcal 1.3 py36h4c697fb_0", + "mpmath 1.0.0 py36hfeacd6b_2", + "curl 7.58.0 h84994c4_0", + "expat >=2.2.5,<3.0a0", + "xlsxwriter 1.0.2 py36h3de1aca_0", + "zlib 1.2.11 ha838bed_2", + "imagesize 0.7.1 py36h52d8127_0", + "anaconda-project 0.8.2 py36h44fb852_0", + "libxml2 2.9.7 h26e45fe_0", + "nltk 3.2.5 py36h7532b22_0", + "terminado 0.8.1 py36_1", + "qt 5.6.2 h974d657_12", + "pickleshare 0.7.4 py36h63277f8_0", + "lxml 4.1.1 py36hf71bdeb_1", + "typing 3.6.2 py36h7da032a_0", + "mkl 2018.0.1 h19d6760_4", + "graphite2 >=1.3.10,<2.0a0", + "freetype >=2.8,<2.9.0a0", + "click 6.7 py36h5253387_0", + "libffi 3.2.1 hd88cf55_4", + "libtiff >=4.0.9,<5.0a0", + "distributed 1.20.2 py36_0", + "jupyter_console 5.2.0 py36he59e554_1", + "webencodings 0.5.1 py36h800622e_1", + "llvmlite 0.21.0 py36ha241eea_0", + "gmp >=6.1.2", + "libsodium 1.0.15 hf101ebd_0", + "pyopenssl 17.5.0 py36h20ba746_0", + "toolz 0.9.0 py36_0", + "zlib >=1.2.11,<1.3.0a0", + "widgetsnbextension 3.1.0 py36_0", + "pyyaml 3.12 py36hafb9ca4_1", + "multipledispatch 0.4.9 py36h41da3fb_0", + "matplotlib 2.1.2 py36h0e671d2_0", + "unicodecsv 0.14.1 py36ha668878_0", + "flask-cors 3.0.3 py36h2d857d3_0", + "sphinxcontrib-websupport 1.0.1 py36hb5cb234_1", + "dbus 1.12.2 hc3f9b76_1", + "jpeg 9b h024ee3a_2", + "lzo 2.10 h49e0be7_2", + "libedit 3.1 heed3624_0", + "notebook 5.4.0 py36_0", + "pycrypto 2.6.1 py36h14c3975_7", + "pathlib2 2.3.0 py36h49efa8e_0", + "dbus >=1.12.2,<2.0a0", + "harfbuzz >=1.7.4,<2.0a0", + "ipykernel 4.8.0 py36_0", + "bleach 2.1.2 py36_0", + "libcurl 7.58.0 h1ad7b7a_0", + "xlwt 1.3.0 py36h7b00a1f_0", + "pexpect 4.3.1 py36_0", + "tblib 1.3.2 py36h34cf8b6_0", + "cloudpickle 0.5.2 py36_1", + "wheel 0.30.0 py36hfd4bba0_1", + "astropy 2.0.3 py36h14c3975_0", + "patsy 0.5.0 py36_0", + "gstreamer >=1.12.4,<1.13.0a0", + "jupyterlab 0.31.5 py36_0", + "sympy 1.1.1 py36hc6d1c1c_0", + "filelock 2.0.13 py36h646ffb5_0", + "python 3.6.4 hc3d631a_1", + "libssh2 >=1.8.0,<2.0a0", + "ipywidgets 7.1.1 py36_0", + "jupyter_client 5.2.2 py36_0", + "numba 0.36.2 np114py36hc6662d5_0", + "boto 2.48.0 py36h6e4cd66_1", + "statsmodels 0.8.0 py36h8533d0b_0", + "glib >=2.53.6,<3.0a0", + "pyflakes 1.6.0 py36h7bd6a15_0", + "pytz 2017.3 py36h63b9c63_0", + "pycurl 7.43.0.1 py36hb7f436b_0", + "traitlets 4.3.2 py36h674d592_0", + "cffi 1.11.4 py36h9745a5d_0", + "simplegeneric 0.8.1 py36_2", + "libffi >=3.2.1,<3.3a0", + "pandocfilters 1.4.2 py36ha6701b7_1", + "mkl-service 1.1.2 py36h17a0993_4", + "bokeh 0.12.13 py36h2f9c1c0_0", + "imageio 2.2.0 py36he555465_0", + "pytest 3.3.2 py36_0", + "numpy 1.14.0 py36h3dfced4_1", + "pandoc 1.19.2.1 hea2e7c5_1", + "libstdcxx-ng 7.2.0 h7a57d05_2", + "babel 2.5.3 py36_0", + "pillow 5.0.0 py36h3deb7b8_0", + "nose 1.3.7 py36hcdf7029_2", + "icu 58.2 h9c2bf20_1", + "yaml 0.1.7 had09818_2", + "libtiff 4.0.9 h28f6b97_0", + "openssl >=1.0.2n,<1.0.3a", + "mpc 1.0.3 hec55b23_5", + "pygments 2.2.0 py36h0d3125c_0", + "gmp 6.1.2 h6c8ec71_1", + "six 1.11.0 py36h372c433_1", + "sphinx 1.6.6 py36_0", + "readline 7.0 ha6073c6_4", + "jsonschema 2.6.0 py36h006f8b5_0", + "sortedcontainers 1.5.9 py36_0", + "libgfortran-ng 7.2.0 h9f7466a_2", + "glib 2.53.6 h5d9569c_2", + "werkzeug 0.14.1 py36_0", + "blaze 0.11.3 py36h4e06776_0", + "gevent 1.2.2 py36h2fe25dc_0", + "unixodbc 2.3.4 hc36303a_1", + "intel-openmp 2018.0.0 hc7b2577_8", + "nbformat 4.4.0 py36h31c9010_0", + "jedi 0.11.1 py36_0", + "readline >=7.0,<8.0a0", + "pkginfo 1.4.1 py36h215d178_1", + "backports 1.0 py36hfa02d7e_1", + "sqlite 3.22.0 h1bed415_0", + "zeromq 4.2.2 hbedb6e5_2", + "urllib3 1.22 py36hbe7ace6_0", + "libssh2 1.8.0 h9cfc8f7_4", + "dask-core 0.16.1 py36_0", + "pyparsing 2.2.0 py36hee85983_1", + "openssl 1.0.2n hb7f436b_0", + "qtawesome 0.4.4 py36h609ed8c_0", + "chardet 3.0.4 py36h0f667ec_1", + "sqlalchemy 1.2.1 py36h14c3975_0", + "libxslt >=1.1.32,<2.0a0", + "libpng 1.6.34 hb9fc6fc_0", + "patchelf 0.9 hf79760b_2", + "clyent 1.2.2 py36h7e57e65_1", + "ipython 6.2.1 py36h88c514a_1", + "sip 4.18.1 py36h51ed4ed_2", + "ncurses >=6.0,<7.0a0", + "cairo 1.14.12 h77bcde2_0", + "ipython_genutils 0.2.0 py36hb52b0d5_0", + "libpng >=1.6.34,<1.7.0a0", + "libxcb >=1.12,<2.0a0", + "xz >=5.2.3,<6.0a0", + "fastcache 1.0.2 py36h14c3975_2", + "sphinxcontrib 1.0 py36h6d0f590_1", + "asn1crypto 0.24.0 py36_0", + "ptyprocess 0.5.2 py36h69acd42_0", + "gstreamer 1.12.4 hb53b477_0", + "olefile 0.45.1 py36_0", + "fontconfig 2.12.4 h88586e7_1", + "get_terminal_size 1.0.0 haa9412d_0", + "pandas 0.22.0 py36hf484d3e_0", + "libxml2 >=2.9.7,<2.10.0a0", + "pango 1.41.0 hd475d92_0", + "entrypoints 0.2.3 py36h1aec115_2", + "jinja2 2.10 py36ha16c418_0", + "nbconvert 5.3.1 py36hb41ffb7_0", + "pcre 8.41 hc27e229_1", + "bitarray 0.8.1 py36h14c3975_1", + "isort 4.2.15 py36had401c0_0", + "libgcc-ng 7.2.0 h7cc24e2_2", + "anaconda-client 1.6.9 py36_0", + "jupyter 1.0.0 py36_4", + "itsdangerous 0.24 py36h93cc618_1", + "pyodbc 4.0.22 py36hf484d3e_0", + "ncurses 6.0 h9df7e31_2", + "mistune 0.8.3 py36_0", + "packaging 16.8 py36ha668100_1", + "singledispatch 3.4.0.3 py36h7a266c3_0", + "decorator 4.2.1 py36_0", + "pycodestyle 2.3.1 py36hf609f19_0", + "hdf5 1.10.1 h9caa474_1", + "seaborn 0.8.1 py36hfad7ec4_0", + "et_xmlfile 1.0.1 py36hd6bccc3_0", + "zict 0.1.3 py36h3a3bf81_0", + "tornado 4.5.3 py36_0", + "lzo >=2.10,<3.0a0", + "rope 0.10.7 py36h147e2ec_0", + "requests 2.18.4 py36he2e5f8d_1", + "libxcb 1.12 hcd93eb1_4", + "yaml >=0.1.7,<0.2.0a0", + "path.py 10.5 py36h55ceabb_0", + "datashape 0.5.4 py36h3ad6b5c_0", + "astroid 1.6.1 py36_0", + "freetype 2.8 hab7d2ae_1", + "h5py 2.7.1 py36h3585f63_0", + "jbig 2.1 hdba287a_0", + "snowballstemmer 1.2.1 py36h6febd40_0", + "gst-plugins-base 1.12.4 h33fb286_0", + "greenlet 0.4.12 py36h2d503a6_0", + "pycparser 2.18 py36hf9f622e_1", + "ca-certificates 2017.08.26 h1d4fec5_0", + "alabaster 0.7.10 py36h306e16b_0", + "psutil 5.4.3 py36h14c3975_0", + "pyqt 5.6.0 py36h0386399_5", + "openpyxl 2.4.10 py36_0", + "pysocks 1.6.7 py36hd97a5b1_1", + "idna 2.6 py36h82fb2a8_1", + "xlrd 1.1.0 py36h1db9f0c_1", + "setuptools 38.4.0 py36_0", + "pytables 3.4.2 py36h3b5282a_2" + ], + "license": "BSD", + "md5": "31e01d8d6aff0e5e68e0687d33869c24", + "name": "anaconda", + "namespace": "python", + "sha256": "f2863e00603cdd651006ad2ce4d809ce676f5642a6cce08e4e31505d6bf32da7", + "size": 11390, + "subdir": "linux-64", + "timestamp": 1518523732355, + "version": "5.1.0" + }, + "anaconda-5.2.0-py27_3.conda": { + "build": "py27_3", + "build_number": 3, + "depends": [ + "olefile 0.45.1 py27_0", + "ca-certificates 2018.03.07 0", + "docutils 0.14 py27hae222c1_0", + "pycrypto 2.6.1 py27h14c3975_8", + "setuptools 39.1.0 py27_0", + "terminado 0.8.1 py27_1", + "odo 0.5.1 py27h9170de3_0", + "flask 1.0.2 py27_1", + "mpc 1.0.3 hec55b23_5", + "blosc 1.14.3 hdbcaa40_0", + "typing 3.6.4 py27_0", + "libffi 3.2.1 hd88cf55_4", + "chardet 3.0.4 py27hfa10054_1", + "jedi 0.12.0 py27_1", + "libpng 1.6.34 hb9fc6fc_0", + "dask-core 0.17.5 py27_0", + "parso 0.2.0 py27_0", + "boto 2.48.0 py27h9556ac2_1", + "blas 1.0 mkl", + "yaml 0.1.7 had09818_2", + "ipython_genutils 0.2.0 py27h89fb69b_0", + "libstdcxx-ng 7.2.0 hdf63c60_3", + "libssh2 1.8.0 h9cfc8f7_4", + "tk 8.6.7 hc745277_3", + "zict 0.1.3 py27h12c336c_0", + "webencodings 0.5.1 py27hff10b21_1", + "ipython 5.7.0 py27_0", + "filelock 3.0.4 py27_0", + "xlrd 1.1.0 py27ha77178f_1", + "nltk 3.3.0 py27_0", + "jupyter_client 5.2.3 py27_0", + "psutil 5.4.5 py27h14c3975_0", + "wheel 0.31.1 py27_0", + "lazy-object-proxy 1.3.1 py27h682c727_0", + "jupyter_core 4.4.0 py27h345911c_0", + "pillow 5.1.0 py27h3deb7b8_0", + "seaborn 0.8.1 py27h633ea1e_0", + "sphinxcontrib-websupport 1.0.1 py27hf906f22_1", + "werkzeug 0.14.1 py27_0", + "bokeh 0.12.16 py27_0", + "ipykernel 4.8.2 py27_0", + "mkl_random 1.0.1 py27h629b387_0", + "libxml2 2.9.8 h26e45fe_1", + "ncurses 6.1 hf484d3e_0", + "xlsxwriter 1.0.4 py27_0", + "fastcache 1.0.2 py27h14c3975_2", + "freetype 2.8 hab7d2ae_1", + "libcurl 7.60.0 h1ad7b7a_0", + "mistune 0.8.3 py27h14c3975_1", + "pandas 0.23.0 py27h637b7d7_0", + "pluggy 0.6.0 py27h1f4f128_0", + "configparser 3.5.0 py27h5117587_0", + "jupyterlab 0.32.1 py27_0", + "pygments 2.2.0 py27h4a8b6f5_0", + "pylint 1.8.4 py27_0", + "jpeg 9b h024ee3a_2", + "qtawesome 0.4.4 py27hd7914c3_0", + "qtconsole 4.3.1 py27hc444b0d_0", + "sqlite 3.23.1 he433501_0", + "traitlets 4.3.2 py27hd6ce930_0", + "scikit-image 0.13.1 py27h14c3975_1", + "qt 5.9.5 h7e424d6_0", + "astroid 1.6.3 py27_0", + "path.py 11.0.1 py27_0", + "pyparsing 2.2.0 py27hf1513f8_1", + "jupyter_console 5.2.0 py27hc6bee7e_1", + "scandir 1.7 py27h14c3975_0", + "mccabe 0.6.1 py27h0e7c7be_1", + "backports.functools_lru_cache 1.5 py27_1", + "expat 2.2.5 he0dffb1_0", + "sip 4.19.8 py27hf484d3e_0", + "msgpack-python 0.5.6 py27h6bb024c_0", + "ipywidgets 7.2.1 py27_0", + "decorator 4.3.0 py27_0", + "imagesize 1.0.0 py27_0", + "matplotlib 2.2.2 py27h0e671d2_1", + "locket 0.2.0 py27h73929a2_1", + "pycparser 2.18 py27hefa08c5_1", + "numpy 1.14.3 py27hcd700cb_1", + "dask 0.17.5 py27_0", + "contextlib2 0.5.5 py27hbf4c468_0", + "pickleshare 0.7.4 py27h09770e1_0", + "openpyxl 2.5.3 py27_0", + "functools32 3.2.3.2 py27h4ead58f_1", + "pcre 8.42 h439df22_0", + "alabaster 0.7.10 py27he5a193a_0", + "xz 5.2.4 h14c3975_4", + "hdf5 1.10.2 hba1933b_1", + "mkl_fft 1.0.1 py27h3010b51_0", + "patsy 0.5.0 py27_0", + "icu 58.2 h9c2bf20_1", + "jsonschema 2.6.0 py27h7ed5aa4_0", + "tblib 1.3.2 py27h51fe5ba_0", + "harfbuzz 1.7.6 h5f0a787_1", + "cython 0.28.2 py27h14c3975_0", + "gmpy2 2.0.8 py27h4cf3fa8_2", + "babel 2.5.3 py27_0", + "jdcal 1.4 py27_0", + "asn1crypto 0.24.0 py27_0", + "six 1.11.0 py27h5f960f1_1", + "pyyaml 3.12 py27h2d70dd7_1", + "gstreamer 1.14.0 hb453b48_1", + "itsdangerous 0.24 py27hb8295c1_1", + "pyopenssl 18.0.0 py27_0", + "clyent 1.2.2 py27h7276e6c_1", + "imageio 2.3.0 py27_0", + "statsmodels 0.9.0 py27h3010b51_0", + "pytables 3.4.3 py27h02b9ad4_2", + "intel-openmp 2018.0.0 8", + "pkginfo 1.4.2 py27_1", + "cytoolz 0.9.0.1 py27h14c3975_0", + "jbig 2.1 hdba287a_0", + "sqlalchemy 1.2.7 py27h6b74fdf_0", + "backports.shutil_get_terminal_size 1.0.0 py27h5bc021e_2", + "h5py 2.7.1 py27ha1f6525_2", + "bleach 2.1.3 py27_0", + "partd 0.3.8 py27h4e55004_0", + "mkl-service 1.1.2 py27hb2d42c5_4", + "wcwidth 0.1.7 py27h9e3e1ab_0", + "blaze 0.11.3 py27h5f341da_0", + "certifi 2018.4.16 py27_0", + "markupsafe 1.0 py27h97b2822_1", + "requests 2.18.4 py27hc5b0589_1", + "rope 0.10.7 py27hfe459b0_0", + "pycurl 7.43.0.1 py27hb7f436b_0", + "spyder 3.2.8 py27_0", + "dbus 1.13.2 h714fa37_1", + "cffi 1.11.5 py27h9745a5d_0", + "get_terminal_size 1.0.0 haa9412d_0", + "snowballstemmer 1.2.1 py27h44e2768_0", + "send2trash 1.5.0 py27_0", + "sympy 1.1.1 py27hc28188a_0", + "lxml 4.2.1 py27h23eabaa_0", + "gevent 1.3.0 py27h14c3975_0", + "openssl 1.0.2o h20670df_0", + "distributed 1.21.8 py27_0", + "pywavelets 0.5.2 py27hecda097_0", + "sphinxcontrib 1.0 py27h1512b58_1", + "widgetsnbextension 3.2.1 py27_0", + "jinja2 2.10 py27h4114e70_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "greenlet 0.4.13 py27h14c3975_0", + "bottleneck 1.2.1 py27h21b16a3_0", + "bzip2 1.0.6 h14c3975_5", + "cairo 1.14.12 h7636065_2", + "pyflakes 1.6.0 py27h904a57d_0", + "scipy 1.1.0 py27hfc37229_0", + "backports_abc 0.5 py27h7b3c97b_0", + "libxcb 1.13 h1bed415_1", + "libsodium 1.0.16 h1bed415_0", + "notebook 5.5.0 py27_0", + "libedit 3.1.20170329 h6b74fdf_2", + "python 2.7.15 h1571d57_0", + "pycosat 0.6.3 py27ha4109ae_0", + "nbformat 4.4.0 py27hed7f2b2_0", + "datashape 0.5.4 py27hf507385_0", + "packaging 17.1 py27_0", + "python-dateutil 2.7.3 py27_0", + "ipaddress 1.0.22 py27_0", + "flask-cors 3.0.4 py27_0", + "gmp 6.1.2 h6c8ec71_1", + "more-itertools 4.1.0 py27_0", + "mpmath 1.0.0 py27h9669132_2", + "cdecimal 2.3 py27h14c3975_3", + "attrs 18.1.0 py27_0", + "pycodestyle 2.4.0 py27_0", + "py 1.5.3 py27_0", + "ptyprocess 0.5.2 py27h4ccb14c_0", + "anaconda-project 0.8.2 py27h236b58a_0", + "mkl 2018.0.2 1", + "pycairo 1.15.4 py27h1b9232e_1", + "astropy 2.0.6 py27h3010b51_1", + "libgcc-ng 7.2.0 hdf63c60_3", + "nose 1.3.7 py27heec2199_2", + "futures 3.2.0 py27h7b459c0_0", + "pexpect 4.5.0 py27_0", + "ply 3.11 py27_0", + "singledispatch 3.4.0.3 py27h9bcb476_0", + "idna 2.6 py27h5722d68_1", + "glib 2.56.1 h000015b_0", + "html5lib 1.0.1 py27h5233db4_0", + "jupyter 1.0.0 py27_4", + "sortedcontainers 1.5.10 py27_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "lzo 2.10 h49e0be7_2", + "zlib 1.2.11 ha838bed_2", + "bkcharts 0.2 py27h241ae91_0", + "numexpr 2.6.5 py27h7bf3b9c_0", + "bitarray 0.8.1 py27h14c3975_1", + "pytz 2018.4 py27_0", + "libtool 2.4.6 h544aabb_3", + "wrapt 1.10.11 py27h04f6869_0", + "colorama 0.3.9 py27h5cde069_0", + "networkx 2.1 py27_0", + "pytest 3.5.1 py27_0", + "ssl_match_hostname 3.5.0.1 py27h4ec10b9_2", + "patchelf 0.9 hf79760b_2", + "subprocess32 3.5.0 py27h14c3975_0", + "fontconfig 2.12.6 h49f89f6_0", + "urllib3 1.22 py27ha55213b_0", + "zeromq 4.2.5 h439df22_0", + "prompt_toolkit 1.0.15 py27h1b593e1_0", + "llvmlite 0.23.1 py27hdbcaa40_0", + "unixodbc 2.3.6 h1bed415_0", + "pyqt 5.9.2 py27h751905a_0", + "numpy-base 1.14.3 py27h9be14a7_1", + "testpath 0.3.1 py27hc38d2c4_0", + "multipledispatch 0.5.0 py27_0", + "click 6.7 py27h4225b90_0", + "snappy 1.1.7 hbae5bb6_3", + "libgfortran-ng 7.2.0 hdf63c60_3", + "unicodecsv 0.14.1 py27h5062da9_0", + "funcsigs 1.0.2 py27h83f16ab_0", + "pyodbc 4.0.23 py27hf484d3e_0", + "pyzmq 17.0.0 py27h14c3975_1", + "cryptography 2.2.2 py27h14c3975_0", + "scikit-learn 0.19.1 py27h445a80a_0", + "xlwt 1.3.0 py27h3d85d97_0", + "libtiff 4.0.9 he85c1e1_1", + "mpfr 3.1.5 h11a74b3_2", + "pysocks 1.6.8 py27_0", + "toolz 0.9.0 py27_0", + "graphite2 1.3.11 h16798f4_2", + "anaconda-client 1.6.14 py27_0", + "jupyterlab_launcher 0.10.5 py27_0", + "kiwisolver 1.0.1 py27hc15e7b5_0", + "curl 7.60.0 h84994c4_0", + "pixman 0.34.0 hceecf20_3", + "beautifulsoup4 4.6.0 py27h3f86ba9_1", + "ruamel_yaml 0.15.35 py27h14c3975_1", + "nbconvert 5.3.1 py27he041f76_0", + "cycler 0.10.0 py27hc7354d3_0", + "enum34 1.1.6 py27h99a27e9_1", + "glob2 0.6 py27hcea9cbd_0", + "numba 0.38.0 py27h637b7d7_0", + "numpydoc 0.8.0 py27_0", + "pango 1.41.0 hd475d92_0", + "tornado 5.0.2 py27_0", + "backports 1.0 py27h63c9359_1", + "cloudpickle 0.5.3 py27_0", + "pathlib2 2.3.2 py27_0", + "isort 4.3.4 py27_0", + "pandocfilters 1.4.2 py27h428e1e5_1", + "pep8 1.7.1 py27_0", + "pip 10.0.1 py27_0", + "readline 7.0 ha6073c6_4", + "simplegeneric 0.8.1 py27_2", + "heapdict 1.0.0 py27_2", + "libxslt 1.1.32 h1312cb7_0", + "et_xmlfile 1.0.1 py27h75840f5_0", + "entrypoints 0.2.3 py27h502b47d_2", + "grin 1.2.1 py27_4", + "qtpy 1.4.1 py27_0", + "sortedcollections 0.6.1 py27_0", + "sphinx 1.7.4 py27_0" + ], + "license": "BSD", + "md5": "3e21966a97c697ddfdb686522ffe7f87", + "name": "anaconda", + "namespace": "python", + "sha256": "03f5accc379cb62e3a70db80900d5f5ba47be99160ca7c8b334c80255e7c8e31", + "size": 11030, + "subdir": "linux-64", + "timestamp": 1527224280569, + "version": "5.2.0" + }, + "anaconda-5.2.0-py35_3.conda": { + "build": "py35_3", + "build_number": 3, + "depends": [ + "cython 0.28.2 py35h14c3975_0", + "astropy 3.0.2 py35h3010b51_1", + "fastcache 1.0.2 py35h14c3975_2", + "statsmodels 0.9.0 py35h3010b51_0", + "pytables 3.4.3 py35h02b9ad4_2", + "anaconda-client 1.6.14 py35_0", + "hdf5 1.10.2 hba1933b_1", + "setuptools 39.1.0 py35_0", + "urllib3 1.22 py35h2ab6e29_0", + "zict 0.1.3 py35h29275ca_0", + "partd 0.3.8 py35h68187f2_0", + "jupyter_console 5.2.0 py35h4044a63_1", + "jupyterlab 0.32.1 py35_0", + "psutil 5.4.5 py35h14c3975_0", + "colorama 0.3.9 py35h81e2b6c_0", + "jupyter_core 4.4.0 py35ha89e94b_0", + "more-itertools 4.1.0 py35_0", + "typing 3.6.4 py35_0", + "boto 2.48.0 py35h2cfd601_1", + "greenlet 0.4.13 py35h14c3975_0", + "qtconsole 4.3.1 py35h4626a06_0", + "unixodbc 2.3.6 h1bed415_0", + "pycrypto 2.6.1 py35h14c3975_8", + "certifi 2018.4.16 py35_0", + "scipy 1.1.0 py35hfc37229_0", + "lxml 4.2.1 py35h23eabaa_0", + "pycparser 2.18 py35h61b3040_1", + "cffi 1.11.5 py35h9745a5d_0", + "pathlib2 2.3.2 py35_0", + "sortedcollections 0.6.1 py35_0", + "jedi 0.12.0 py35_1", + "multipledispatch 0.5.0 py35_0", + "unicodecsv 0.14.1 py35h4805c0c_0", + "harfbuzz 1.7.6 h5f0a787_1", + "pep8 1.7.1 py35_0", + "flask-cors 3.0.4 py35_0", + "jdcal 1.4 py35_0", + "backports.shutil_get_terminal_size 1.0.0 py35h40844db_2", + "flask 1.0.2 py35_1", + "numexpr 2.6.5 py35h7bf3b9c_0", + "packaging 17.1 py35_0", + "xlsxwriter 1.0.4 py35_0", + "pillow 5.1.0 py35h3deb7b8_0", + "pytest 3.5.1 py35_0", + "astroid 1.6.3 py35_0", + "cloudpickle 0.5.3 py35_0", + "pandas 0.23.0 py35h637b7d7_0", + "pytest-astropy 0.3.0 py35_0", + "cairo 1.14.12 h7636065_2", + "click 6.7 py35h353a69f_0", + "parso 0.2.0 py35_0", + "chardet 3.0.4 py35hb6e9ddf_1", + "backports 1.0 py35hd471ac7_1", + "pango 1.41.0 hd475d92_0", + "jupyter 1.0.0 py35_4", + "pywavelets 0.5.2 py35h53ec731_0", + "readline 7.0 ha6073c6_4", + "pysocks 1.6.8 py35_0", + "lazy-object-proxy 1.3.1 py35h4c720c6_0", + "markupsafe 1.0 py35h4f4fcf6_1", + "rope 0.10.7 py35h986144c_0", + "cryptography 2.2.2 py35h14c3975_0", + "ca-certificates 2018.03.07 0", + "h5py 2.7.1 py35ha1f6525_2", + "terminado 0.8.1 py35_1", + "libxcb 1.13 h1bed415_1", + "ptyprocess 0.5.2 py35h38ce0a3_0", + "libgfortran-ng 7.2.0 hdf63c60_3", + "nltk 3.3.0 py35_0", + "six 1.11.0 py35h423b573_1", + "openssl 1.0.2o h20670df_0", + "et_xmlfile 1.0.1 py35hde8d43e_0", + "pycodestyle 2.4.0 py35_0", + "beautifulsoup4 4.6.0 py35h442a8c9_1", + "olefile 0.45.1 py35_0", + "py 1.5.3 py35_0", + "llvmlite 0.23.1 py35hdbcaa40_0", + "imageio 2.3.0 py35_0", + "sqlite 3.23.1 he433501_0", + "python 3.5.5 hc3d631a_4", + "pandoc 1.19.2.1 hea2e7c5_1", + "cycler 0.10.0 py35hc4d5149_0", + "gmpy2 2.0.8 py35hd0a1c9a_2", + "anaconda-project 0.8.2 py35h7d62c80_0", + "pytz 2018.4 py35_0", + "pandocfilters 1.4.2 py35h1565a15_1", + "python-dateutil 2.7.3 py35_0", + "sip 4.19.8 py35hf484d3e_0", + "pickleshare 0.7.4 py35hd57304d_0", + "fontconfig 2.12.6 h49f89f6_0", + "qtawesome 0.4.4 py35hd68ff89_0", + "ipykernel 4.8.2 py35_0", + "itsdangerous 0.24 py35h7c46880_1", + "locket 0.2.0 py35h170bc82_1", + "pyflakes 1.6.0 py35hd1da72e_0", + "icu 58.2 h9c2bf20_1", + "ply 3.11 py35_0", + "numpy-base 1.14.3 py35h9be14a7_1", + "pluggy 0.6.0 py35hb428803_0", + "ipywidgets 7.2.1 py35_0", + "pylint 1.8.4 py35_0", + "pyopenssl 18.0.0 py35_0", + "mkl-service 1.1.2 py35h0fc7090_4", + "libxml2 2.9.8 h26e45fe_1", + "numba 0.38.0 py35h637b7d7_0", + "gstreamer 1.14.0 hb453b48_1", + "wrapt 1.10.11 py35hfdafd39_0", + "bkcharts 0.2 py35he4f7e30_0", + "sphinxcontrib-websupport 1.0.1 py35h3537809_1", + "webencodings 0.5.1 py35hb6cf162_1", + "mpfr 3.1.5 h11a74b3_2", + "nose 1.3.7 py35hdc64897_2", + "pyyaml 3.12 py35h46ef4ae_1", + "pycurl 7.43.0.1 py35hb7f436b_0", + "nbformat 4.4.0 py35h12e6e07_0", + "expat 2.2.5 he0dffb1_0", + "pcre 8.42 h439df22_0", + "dbus 1.13.2 h714fa37_1", + "libgcc-ng 7.2.0 hdf63c60_3", + "qt 5.9.5 h7e424d6_0", + "libcurl 7.60.0 h1ad7b7a_0", + "prompt_toolkit 1.0.15 py35hc09de7a_0", + "libffi 3.2.1 hd88cf55_4", + "mpc 1.0.3 hec55b23_5", + "datashape 0.5.4 py35h5b068ae_0", + "kiwisolver 1.0.1 py35hcb1117a_0", + "qtpy 1.4.1 py35_0", + "mkl 2018.0.2 1", + "singledispatch 3.4.0.3 py35h0cd4ec3_0", + "toolz 0.9.0 py35_0", + "heapdict 1.0.0 py35_2", + "mkl_random 1.0.1 py35h629b387_0", + "distributed 1.21.8 py35_0", + "imagesize 1.0.0 py35_0", + "clyent 1.2.2 py35h491ffcb_1", + "mpmath 1.0.0 py35h7ce6e34_2", + "requests 2.18.4 py35hb9e6ad1_1", + "odo 0.5.1 py35h102315f_0", + "libpng 1.6.34 hb9fc6fc_0", + "simplegeneric 0.8.1 py35_2", + "msgpack-python 0.5.6 py35h6bb024c_0", + "werkzeug 0.14.1 py35_0", + "sphinxcontrib 1.0 py35hcb7efd2_1", + "xz 5.2.4 h14c3975_4", + "pytest-openfiles 0.3.0 py35_0", + "get_terminal_size 1.0.0 haa9412d_0", + "pytest-remotedata 0.2.1 py35_0", + "gevent 1.3.0 py35h14c3975_0", + "libsodium 1.0.16 h1bed415_0", + "pkginfo 1.4.2 py35_1", + "pip 10.0.1 py35_0", + "mccabe 0.6.1 py35hd8c1f23_1", + "intel-openmp 2018.0.0 8", + "jinja2 2.10 py35h480ab6d_0", + "ncurses 6.1 hf484d3e_0", + "asn1crypto 0.24.0 py35_0", + "sortedcontainers 1.5.10 py35_0", + "snappy 1.1.7 hbae5bb6_3", + "spyder 3.2.8 py35_0", + "mkl_fft 1.0.1 py35h3010b51_0", + "pyqt 5.9.2 py35h751905a_0", + "bottleneck 1.2.1 py35he1b16f1_0", + "ipython 6.4.0 py35_0", + "pyparsing 2.2.0 py35h041ed72_1", + "pexpect 4.5.0 py35_0", + "libstdcxx-ng 7.2.0 hdf63c60_3", + "isort 4.3.4 py35_0", + "cytoolz 0.9.0.1 py35h14c3975_0", + "gmp 6.1.2 h6c8ec71_1", + "tornado 5.0.2 py35_0", + "pyzmq 17.0.0 py35h14c3975_0", + "glob2 0.6 py35hff66265_0", + "patchelf 0.9 hf79760b_2", + "blosc 1.14.3 hdbcaa40_0", + "tk 8.6.7 hc745277_3", + "patsy 0.5.0 py35_0", + "contextlib2 0.5.5 py35h6690dba_0", + "jupyter_client 5.2.3 py35_0", + "snowballstemmer 1.2.1 py35h5435977_0", + "bitarray 0.8.1 py35h14c3975_1", + "xlwt 1.3.0 py35h884a0cf_0", + "lzo 2.10 h49e0be7_2", + "html5lib 1.0.1 py35h2f9c1c0_0", + "pyodbc 4.0.23 py35hf484d3e_0", + "libtool 2.4.6 h544aabb_3", + "pytest-doctestplus 0.1.3 py35_0", + "nbconvert 5.3.1 py35hc5194e3_0", + "jbig 2.1 hdba287a_0", + "ruamel_yaml 0.15.35 py35h14c3975_1", + "ipython_genutils 0.2.0 py35hc9e07d0_0", + "pixman 0.34.0 hceecf20_3", + "pycosat 0.6.3 py35h6b6bb97_0", + "alabaster 0.7.10 py35h6fb19ab_0", + "yaml 0.1.7 had09818_2", + "seaborn 0.8.1 py35h04cba02_0", + "jsonschema 2.6.0 py35h4395190_0", + "networkx 2.1 py35_0", + "libxslt 1.1.32 h1312cb7_0", + "graphite2 1.3.11 h16798f4_2", + "attrs 18.1.0 py35_0", + "backcall 0.1.0 py35_0", + "dask 0.17.5 py35_0", + "curl 7.60.0 h84994c4_0", + "path.py 11.0.1 py35_0", + "sqlalchemy 1.2.7 py35h6b74fdf_0", + "zeromq 4.2.5 h439df22_0", + "pygments 2.2.0 py35h0f41973_0", + "traitlets 4.3.2 py35ha522a97_0", + "jpeg 9b h024ee3a_2", + "jupyterlab_launcher 0.10.5 py35_0", + "widgetsnbextension 3.2.1 py35_0", + "libssh2 1.8.0 h9cfc8f7_4", + "entrypoints 0.2.3 py35h48174a2_2", + "matplotlib 2.2.2 py35h0e671d2_1", + "xlrd 1.1.0 py35h45a0a2a_1", + "pytest-arraydiff 0.2 py35_0", + "babel 2.5.3 py35_0", + "freetype 2.8 hab7d2ae_1", + "wheel 0.31.1 py35_0", + "mistune 0.8.3 py35h14c3975_1", + "blas 1.0 mkl", + "scikit-image 0.13.1 py35h14c3975_1", + "numpydoc 0.8.0 py35_0", + "zlib 1.2.11 ha838bed_2", + "libedit 3.1.20170329 h6b74fdf_2", + "bokeh 0.12.16 py35_0", + "notebook 5.5.0 py35_0", + "filelock 3.0.4 py35_0", + "numpy 1.14.3 py35hcd700cb_1", + "openpyxl 2.5.3 py35_0", + "send2trash 1.5.0 py35_0", + "docutils 0.14 py35hd11081d_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "dask-core 0.17.5 py35_0", + "bzip2 1.0.6 h14c3975_5", + "sympy 1.1.1 py35h919b29a_0", + "glib 2.56.1 h000015b_0", + "sphinx 1.7.4 py35_0", + "wcwidth 0.1.7 py35hcd08066_0", + "blaze 0.11.3 py35ha2c9137_0", + "tblib 1.3.2 py35hf1eb0b4_0", + "scikit-learn 0.19.1 py35hbf1f462_0", + "idna 2.6 py35h8605a33_1", + "bleach 2.1.3 py35_0", + "decorator 4.3.0 py35_0", + "libtiff 4.0.9 he85c1e1_1", + "testpath 0.3.1 py35had42eaf_0" + ], + "license": "BSD", + "md5": "1ae7ec4e9b6fdac55a7b4c09c5011bab", + "name": "anaconda", + "namespace": "python", + "sha256": "9227802d1c4a2d45f76dfd23fee76f0ed16da827771257e9add8f2b63239f7ff", + "size": 10768, + "subdir": "linux-64", + "timestamp": 1527224567217, + "version": "5.2.0" + }, + "anaconda-5.2.0-py36_3.conda": { + "build": "py36_3", + "build_number": 3, + "depends": [ + "zlib 1.2.11 ha838bed_2", + "astroid 1.6.3 py36_0", + "statsmodels 0.9.0 py36h3010b51_0", + "asn1crypto 0.24.0 py36_0", + "click 6.7 py36h5253387_0", + "pyyaml 3.12 py36hafb9ca4_1", + "pytest-remotedata 0.2.1 py36_0", + "qtpy 1.4.1 py36_0", + "pandocfilters 1.4.2 py36ha6701b7_1", + "curl 7.60.0 h84994c4_0", + "alabaster 0.7.10 py36h306e16b_0", + "filelock 3.0.4 py36_0", + "pexpect 4.5.0 py36_0", + "jupyter 1.0.0 py36_4", + "sphinx 1.7.4 py36_0", + "bitarray 0.8.1 py36h14c3975_1", + "partd 0.3.8 py36h36fd896_0", + "pycodestyle 2.4.0 py36_0", + "bottleneck 1.2.1 py36haac1ea0_0", + "tblib 1.3.2 py36h34cf8b6_0", + "mccabe 0.6.1 py36h5ad9710_1", + "certifi 2018.4.16 py36_0", + "nltk 3.3.0 py36_0", + "xz 5.2.4 h14c3975_4", + "et_xmlfile 1.0.1 py36hd6bccc3_0", + "msgpack-python 0.5.6 py36h6bb024c_0", + "cytoolz 0.9.0.1 py36h14c3975_0", + "libssh2 1.8.0 h9cfc8f7_4", + "pycosat 0.6.3 py36h0a5515d_0", + "lazy-object-proxy 1.3.1 py36h10fcdad_0", + "xlwt 1.3.0 py36h7b00a1f_0", + "lzo 2.10 h49e0be7_2", + "fontconfig 2.12.6 h49f89f6_0", + "nbformat 4.4.0 py36h31c9010_0", + "mkl_random 1.0.1 py36h629b387_0", + "pillow 5.1.0 py36h3deb7b8_0", + "qtconsole 4.3.1 py36h8f73b5b_0", + "scipy 1.1.0 py36hfc37229_0", + "hdf5 1.10.2 hba1933b_1", + "olefile 0.45.1 py36_0", + "patsy 0.5.0 py36_0", + "libxslt 1.1.32 h1312cb7_0", + "pytest 3.5.1 py36_0", + "kiwisolver 1.0.1 py36h764f252_0", + "glib 2.56.1 h000015b_0", + "ncurses 6.1 hf484d3e_0", + "libgcc-ng 7.2.0 hdf63c60_3", + "flask-cors 3.0.4 py36_0", + "multipledispatch 0.5.0 py36_0", + "contextlib2 0.5.5 py36h6c84a62_0", + "libtiff 4.0.9 he85c1e1_1", + "more-itertools 4.1.0 py36_0", + "sortedcontainers 1.5.10 py36_0", + "traitlets 4.3.2 py36h674d592_0", + "bzip2 1.0.6 h14c3975_5", + "scikit-image 0.13.1 py36h14c3975_1", + "zeromq 4.2.5 h439df22_0", + "mistune 0.8.3 py36h14c3975_1", + "pip 10.0.1 py36_0", + "pcre 8.42 h439df22_0", + "jinja2 2.10 py36ha16c418_0", + "ptyprocess 0.5.2 py36h69acd42_0", + "locket 0.2.0 py36h787c0ad_1", + "psutil 5.4.5 py36h14c3975_0", + "ply 3.11 py36_0", + "itsdangerous 0.24 py36h93cc618_1", + "libpng 1.6.34 hb9fc6fc_0", + "py 1.5.3 py36_0", + "backports 1.0 py36hfa02d7e_1", + "ipython 6.4.0 py36_0", + "pysocks 1.6.8 py36_0", + "zict 0.1.3 py36h3a3bf81_0", + "python 3.6.5 hc3d631a_2", + "jupyterlab 0.32.1 py36_0", + "xlsxwriter 1.0.4 py36_0", + "libxml2 2.9.8 h26e45fe_1", + "odo 0.5.1 py36h90ed295_0", + "dask-core 0.17.5 py36_0", + "datashape 0.5.4 py36h3ad6b5c_0", + "mkl 2018.0.2 1", + "gevent 1.3.0 py36h14c3975_0", + "pandas 0.23.0 py36h637b7d7_0", + "lxml 4.2.1 py36h23eabaa_0", + "cloudpickle 0.5.3 py36_0", + "libffi 3.2.1 hd88cf55_4", + "libstdcxx-ng 7.2.0 hdf63c60_3", + "pyzmq 17.0.0 py36h14c3975_0", + "qt 5.9.5 h7e424d6_0", + "distributed 1.21.8 py36_0", + "llvmlite 0.23.1 py36hdbcaa40_0", + "flask 1.0.2 py36_1", + "blaze 0.11.3 py36h4e06776_0", + "entrypoints 0.2.3 py36h1aec115_2", + "tk 8.6.7 hc745277_3", + "attrs 18.1.0 py36_0", + "unixodbc 2.3.6 h1bed415_0", + "pyflakes 1.6.0 py36h7bd6a15_0", + "pkginfo 1.4.2 py36_1", + "gstreamer 1.14.0 hb453b48_1", + "mpc 1.0.3 hec55b23_5", + "pathlib2 2.3.2 py36_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "unicodecsv 0.14.1 py36ha668878_0", + "python-dateutil 2.7.3 py36_0", + "seaborn 0.8.1 py36hfad7ec4_0", + "html5lib 1.0.1 py36h2f9c1c0_0", + "werkzeug 0.14.1 py36_0", + "isort 4.3.4 py36_0", + "pylint 1.8.4 py36_0", + "testpath 0.3.1 py36h8cadb63_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "expat 2.2.5 he0dffb1_0", + "get_terminal_size 1.0.0 haa9412d_0", + "six 1.11.0 py36h372c433_1", + "nbconvert 5.3.1 py36hb41ffb7_0", + "pytest-openfiles 0.3.0 py36_0", + "jedi 0.12.0 py36_1", + "pywavelets 0.5.2 py36he602eb0_0", + "markupsafe 1.0 py36hd9260cd_1", + "sphinxcontrib 1.0 py36h6d0f590_1", + "pytables 3.4.3 py36h02b9ad4_2", + "rope 0.10.7 py36h147e2ec_0", + "packaging 17.1 py36_0", + "numpy 1.14.3 py36hcd700cb_1", + "libcurl 7.60.0 h1ad7b7a_0", + "pyodbc 4.0.23 py36hf484d3e_0", + "requests 2.18.4 py36he2e5f8d_1", + "sphinxcontrib-websupport 1.0.1 py36hb5cb234_1", + "pycparser 2.18 py36hf9f622e_1", + "webencodings 0.5.1 py36h800622e_1", + "blosc 1.14.3 hdbcaa40_0", + "ipython_genutils 0.2.0 py36hb52b0d5_0", + "bkcharts 0.2 py36h735825a_0", + "pytest-astropy 0.3.0 py36_0", + "pickleshare 0.7.4 py36h63277f8_0", + "pygments 2.2.0 py36h0d3125c_0", + "babel 2.5.3 py36_0", + "singledispatch 3.4.0.3 py36h7a266c3_0", + "yaml 0.1.7 had09818_2", + "notebook 5.5.0 py36_0", + "pep8 1.7.1 py36_0", + "tornado 5.0.2 py36_0", + "pyopenssl 18.0.0 py36_0", + "urllib3 1.22 py36hbe7ace6_0", + "patchelf 0.9 hf79760b_2", + "icu 58.2 h9c2bf20_1", + "nose 1.3.7 py36hcdf7029_2", + "heapdict 1.0.0 py36_2", + "jpeg 9b h024ee3a_2", + "mkl_fft 1.0.1 py36h3010b51_0", + "networkx 2.1 py36_0", + "snowballstemmer 1.2.1 py36h6febd40_0", + "numba 0.38.0 py36h637b7d7_0", + "pyqt 5.9.2 py36h751905a_0", + "clyent 1.2.2 py36h7e57e65_1", + "backports.shutil_get_terminal_size 1.0.0 py36hfea85ff_2", + "anaconda-project 0.8.2 py36h44fb852_0", + "pyparsing 2.2.0 py36hee85983_1", + "docutils 0.14 py36hb0f60f5_0", + "send2trash 1.5.0 py36_0", + "mpmath 1.0.0 py36hfeacd6b_2", + "libxcb 1.13 h1bed415_1", + "mkl-service 1.1.2 py36h17a0993_4", + "graphite2 1.3.11 h16798f4_2", + "widgetsnbextension 3.2.1 py36_0", + "matplotlib 2.2.2 py36h0e671d2_1", + "pixman 0.34.0 hceecf20_3", + "qtawesome 0.4.4 py36h609ed8c_0", + "ca-certificates 2018.03.07 0", + "idna 2.6 py36h82fb2a8_1", + "libedit 3.1.20170329 h6b74fdf_2", + "pytest-doctestplus 0.1.3 py36_0", + "beautifulsoup4 4.6.0 py36h49b8c8c_1", + "gmpy2 2.0.8 py36hc8893dd_2", + "greenlet 0.4.13 py36h14c3975_0", + "pycurl 7.43.0.1 py36hb7f436b_0", + "bleach 2.1.3 py36_0", + "fastcache 1.0.2 py36h14c3975_2", + "h5py 2.7.1 py36ha1f6525_2", + "mpfr 3.1.5 h11a74b3_2", + "imageio 2.3.0 py36_0", + "ruamel_yaml 0.15.35 py36h14c3975_1", + "simplegeneric 0.8.1 py36_2", + "wcwidth 0.1.7 py36hdf4376a_0", + "jupyter_core 4.4.0 py36h7c827e3_0", + "readline 7.0 ha6073c6_4", + "pytz 2018.4 py36_0", + "imagesize 1.0.0 py36_0", + "jupyter_client 5.2.3 py36_0", + "terminado 0.8.1 py36_1", + "cycler 0.10.0 py36h93f1223_0", + "cryptography 2.2.2 py36h14c3975_0", + "pango 1.41.0 hd475d92_0", + "prompt_toolkit 1.0.15 py36h17d85b1_0", + "sqlalchemy 1.2.7 py36h6b74fdf_0", + "dbus 1.13.2 h714fa37_1", + "cffi 1.11.5 py36h9745a5d_0", + "typing 3.6.4 py36_0", + "freetype 2.8 hab7d2ae_1", + "jbig 2.1 hdba287a_0", + "sympy 1.1.1 py36hc6d1c1c_0", + "cython 0.28.2 py36h14c3975_0", + "openpyxl 2.5.3 py36_0", + "pytest-arraydiff 0.2 py36_0", + "snappy 1.1.7 hbae5bb6_3", + "pycrypto 2.6.1 py36h14c3975_8", + "chardet 3.0.4 py36h0f667ec_1", + "libsodium 1.0.16 h1bed415_0", + "parso 0.2.0 py36_0", + "jupyter_console 5.2.0 py36he59e554_1", + "harfbuzz 1.7.6 h5f0a787_1", + "astropy 3.0.2 py36h3010b51_1", + "pluggy 0.6.0 py36hb689045_0", + "setuptools 39.1.0 py36_0", + "libtool 2.4.6 h544aabb_3", + "jdcal 1.4 py36_0", + "numexpr 2.6.5 py36h7bf3b9c_0", + "jsonschema 2.6.0 py36h006f8b5_0", + "gmp 6.1.2 h6c8ec71_1", + "ipywidgets 7.2.1 py36_0", + "dask 0.17.5 py36_0", + "spyder 3.2.8 py36_0", + "backcall 0.1.0 py36_0", + "libgfortran-ng 7.2.0 hdf63c60_3", + "xlrd 1.1.0 py36h1db9f0c_1", + "sip 4.19.8 py36hf484d3e_0", + "intel-openmp 2018.0.0 8", + "decorator 4.3.0 py36_0", + "blas 1.0 mkl", + "glob2 0.6 py36he249c77_0", + "ipykernel 4.8.2 py36_0", + "scikit-learn 0.19.1 py36h7aa7ec6_0", + "cairo 1.14.12 h7636065_2", + "openssl 1.0.2o h20670df_0", + "sortedcollections 0.6.1 py36_0", + "sqlite 3.23.1 he433501_0", + "wheel 0.31.1 py36_0", + "colorama 0.3.9 py36h489cec4_0", + "wrapt 1.10.11 py36h28b7045_0", + "toolz 0.9.0 py36_0", + "anaconda-client 1.6.14 py36_0", + "path.py 11.0.1 py36_0", + "boto 2.48.0 py36h6e4cd66_1", + "bokeh 0.12.16 py36_0", + "jupyterlab_launcher 0.10.5 py36_0", + "numpydoc 0.8.0 py36_0", + "numpy-base 1.14.3 py36h9be14a7_1" + ], + "license": "BSD", + "md5": "455782577d46788f5c366c188b37225b", + "name": "anaconda", + "namespace": "python", + "sha256": "df16ed25dc10a999a9cfdf4ffb7fba054d956c6de63f27df1092a3dc695e4027", + "size": 10649, + "subdir": "linux-64", + "timestamp": 1527224860738, + "version": "5.2.0" + }, + "anaconda-5.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "scandir 1.9.0 py27h14c3975_0", + "pickleshare 0.7.4 py27_0", + "scikit-learn 0.19.2 py27h4989274_0", + "cloudpickle 0.5.5 py27_0", + "markupsafe 1.0 py27h14c3975_1", + "enum34 1.1.6 py27_1", + "bleach 2.1.4 py27_0", + "ipywidgets 7.4.1 py27_0", + "mkl_random 1.0.1 py27h4414c95_1", + "h5py 2.8.0 py27h989c5e5_3", + "appdirs 1.4.3 py27h28b3542_0", + "greenlet 0.4.15 py27h7b6447c_0", + "et_xmlfile 1.0.1 py27_0", + "boto 2.49.0 py27_0", + "cdecimal 2.3 py27h14c3975_3", + "ssl_match_hostname 3.5.0.1 py27_2", + "xz 5.2.4 h14c3975_4", + "ptyprocess 0.6.0 py27_0", + "prompt_toolkit 1.0.15 py27_0", + "alabaster 0.7.11 py27_0", + "pylint 1.9.2 py27_0", + "mistune 0.8.3 py27h14c3975_1", + "datashape 0.5.4 py27_1", + "pcre 8.42 h439df22_0", + "packaging 17.1 py27_0", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "pycrypto 2.6.1 py27h14c3975_9", + "python-dateutil 2.7.3 py27_0", + "libuuid 1.0.3 h1bed415_2", + "jpeg 9b h024ee3a_2", + "networkx 2.1 py27_0", + "readline 7.0 h7b6447c_5", + "fribidi 1.0.5 h7b6447c_0", + "pyzmq 17.1.2 py27h14c3975_0", + "pywavelets 1.0.0 py27hdd07704_0", + "mccabe 0.6.1 py27_1", + "expat 2.2.6 he6710b0_0", + "odo 0.5.1 py27_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "pyasn1-modules 0.2.2 py27_0", + "pandocfilters 1.4.2 py27_1", + "ipython_genutils 0.2.0 py27_0", + "grin 1.2.1 py27_4", + "jupyterlab 0.33.11 py27_0", + "hdf5 1.10.2 hba1933b_1", + "openssl 1.0.2p h14c3975_0", + "widgetsnbextension 3.4.1 py27_0", + "funcsigs 1.0.2 py27_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "pathlib2 2.3.2 py27_0", + "gmp 6.1.2 h6c8ec71_1", + "libxslt 1.1.32 h1312cb7_0", + "sphinx 1.7.9 py27_0", + "html5lib 1.0.1 py27_0", + "docutils 0.14 py27_0", + "parso 0.3.1 py27_0", + "babel 2.6.0 py27_0", + "pycosat 0.6.3 py27h14c3975_0", + "pycparser 2.18 py27_1", + "libcurl 7.61.0 h1ad7b7a_0", + "anaconda-client 1.7.2 py27_0", + "patchelf 0.9 hf484d3e_2", + "numexpr 2.6.8 py27hd89afb7_0", + "blaze 0.11.3 py27_0", + "pango 1.42.4 h049681c_0", + "libgcc-ng 8.2.0 hdf63c60_1", + "blas 1.0 mkl", + "dask-core 0.19.1 py27_0", + "xlwt 1.3.0 py27_0", + "zope 1.0 py27_1", + "icu 58.2 h9c2bf20_1", + "qt 5.9.6 h8703b6f_2", + "typing 3.6.6 py27_0", + "idna 2.7 py27_0", + "pyyaml 3.13 py27h14c3975_0", + "cython 0.28.5 py27hf484d3e_0", + "backports_abc 0.5 py27_0", + "python 2.7.15 h1571d57_0", + "lazy-object-proxy 1.3.1 py27h14c3975_2", + "pillow 5.2.0 py27heded4f4_0", + "jsonschema 2.6.0 py27_0", + "pycurl 7.43.0.2 py27hb7f436b_0", + "pep8 1.7.1 py27_0", + "graphite2 1.3.12 h23475e2_2", + "asn1crypto 0.24.0 py27_0", + "libxml2 2.9.8 h26e45fe_1", + "glob2 0.6 py27_0", + "ply 3.11 py27_0", + "distributed 1.23.1 py27_0", + "libtiff 4.0.9 he85c1e1_2", + "astropy 2.0.8 py27h035aef0_0", + "wcwidth 0.1.7 py27_0", + "astroid 1.6.5 py27_0", + "yaml 0.1.7 had09818_2", + "beautifulsoup4 4.6.3 py27_0", + "decorator 4.3.0 py27_0", + "spyder 3.3.1 py27_1", + "pysocks 1.6.8 py27_0", + "backports 1.0 py27_1", + "psutil 5.4.7 py27h14c3975_0", + "ncurses 6.1 hf484d3e_0", + "sip 4.19.8 py27hf484d3e_0", + "freetype 2.9.1 h8a8886c_1", + "jupyter_core 4.4.0 py27_0", + "nbconvert 5.4.0 py27_1", + "ruamel_yaml 0.15.46 py27h14c3975_0", + "ca-certificates 2018.03.07 0", + "filelock 3.0.8 py27_0", + "pytest 3.8.0 py27_0", + "ipykernel 4.9.0 py27_1", + "webencodings 0.5.1 py27_1", + "libsodium 1.0.16 h1bed415_0", + "pexpect 4.6.0 py27_0", + "notebook 5.6.0 py27_0", + "terminado 0.8.1 py27_1", + "cffi 1.11.5 py27he75722e_1", + "blosc 1.14.4 hdbcaa40_0", + "pixman 0.34.0 hceecf20_3", + "sqlite 3.24.0 h84994c4_0", + "py 1.6.0 py27_0", + "clyent 1.2.2 py27_1", + "llvmlite 0.24.0 py27hdbcaa40_0", + "snappy 1.1.7 hbae5bb6_3", + "spyder-kernels 0.2.6 py27_0", + "pytz 2018.5 py27_0", + "sortedcontainers 2.0.5 py27_0", + "jupyter_console 5.2.0 py27_1", + "gstreamer 1.14.0 hb453b48_1", + "jbig 2.1 hdba287a_0", + "heapdict 1.0.0 py27_2", + "pip 10.0.1 py27_0", + "zope.interface 4.5.0 py27h14c3975_0", + "testpath 0.3.1 py27_0", + "mkl_fft 1.0.4 py27h4414c95_1", + "send2trash 1.5.0 py27_0", + "sqlalchemy 1.2.11 py27h7b6447c_0", + "colorama 0.3.9 py27_0", + "sphinxcontrib-websupport 1.1.0 py27_1", + "futures 3.2.0 py27_0", + "jupyter_client 5.2.3 py27_0", + "mpmath 1.0.0 py27_2", + "dask 0.19.1 py27_0", + "pyodbc 4.0.24 py27he6710b0_0", + "fastcache 1.0.2 py27h14c3975_2", + "libedit 3.1.20170329 h6b74fdf_2", + "kiwisolver 1.0.1 py27hf484d3e_0", + "more-itertools 4.3.0 py27_0", + "cryptography 2.3.1 py27hc365091_0", + "partd 0.3.8 py27_0", + "libpng 1.6.34 hb9fc6fc_0", + "attrs 18.2.0 py27h28b3542_0", + "mpfr 4.0.1 hdf1c602_3", + "bottleneck 1.2.1 py27h035aef0_1", + "jupyter 1.0.0 py27_7", + "imageio 2.4.1 py27_0", + "certifi 2018.8.24 py27_1", + "dbus 1.13.2 h714fa37_1", + "numpy 1.15.1 py27h1d66e8a_0", + "backports.functools_lru_cache 1.5 py27_1", + "cytoolz 0.9.0.1 py27h14c3975_1", + "qtawesome 0.4.4 py27_0", + "locket 0.2.0 py27_1", + "jinja2 2.10 py27_0", + "wheel 0.31.1 py27_0", + "cairo 1.14.12 h8948797_3", + "bzip2 1.0.6 h14c3975_5", + "nose 1.3.7 py27_2", + "defusedxml 0.5.0 py27_1", + "zict 0.1.3 py27_0", + "setuptools 40.2.0 py27_0", + "nltk 3.3.0 py27_0", + "matplotlib 2.2.3 py27hb69df0a_0", + "incremental 17.5.0 py27_0", + "snowballstemmer 1.2.1 py27_0", + "olefile 0.46 py27_0", + "atomicwrites 1.2.1 py27_0", + "linecache2 1.0.0 py27_0", + "fontconfig 2.13.0 h9420a91_0", + "ipython 5.8.0 py27_0", + "gevent 1.3.6 py27h7b6447c_0", + "multipledispatch 0.6.0 py27_0", + "singledispatch 3.4.0.3 py27_0", + "urllib3 1.23 py27_0", + "functools32 3.2.3.2 py27_1", + "msgpack-python 0.5.6 py27h6bb024c_1", + "isort 4.3.4 py27_0", + "bkcharts 0.2 py27_0", + "twisted 18.7.0 py27h14c3975_1", + "chardet 3.0.4 py27_1", + "automat 0.7.0 py27_0", + "itsdangerous 0.24 py27_1", + "glib 2.56.2 hd408876_0", + "curl 7.61.0 h84994c4_0", + "pygments 2.2.0 py27_0", + "requests 2.19.1 py27_0", + "unixodbc 2.3.7 h14c3975_0", + "imagesize 1.1.0 py27_0", + "gmpy2 2.0.8 py27h10f8cd9_2", + "cycler 0.10.0 py27_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "pyflakes 2.0.0 py27_0", + "zlib 1.2.11 ha838bed_2", + "toolz 0.9.0 py27_0", + "pycairo 1.17.1 py27h2a1e443_0", + "xlrd 1.1.0 py27_1", + "sortedcollections 1.0.1 py27_0", + "numba 0.39.0 py27h04863e7_0", + "pkginfo 1.4.2 py27_1", + "patsy 0.5.0 py27_0", + "contextlib2 0.5.5 py27_0", + "path.py 11.1.0 py27_0", + "entrypoints 0.2.3 py27_2", + "pandas 0.23.4 py27h04863e7_0", + "sphinxcontrib 1.0 py27_1", + "zeromq 4.2.5 hf484d3e_1", + "libffi 3.2.1 hd88cf55_4", + "intel-openmp 2019.0 118", + "bitarray 0.8.3 py27h14c3975_0", + "mkl-service 1.1.2 py27h90e4bf4_5", + "lxml 4.2.5 py27hefd8a0e_0", + "qtpy 1.5.0 py27_0", + "scikit-image 0.14.0 py27hf484d3e_1", + "simplegeneric 0.8.1 py27_2", + "lzo 2.10 h49e0be7_2", + "wrapt 1.10.11 py27h14c3975_2", + "libssh2 1.8.0 h9cfc8f7_4", + "traceback2 1.4.0 py27_0", + "anaconda-project 0.8.2 py27_0", + "rope 0.11.0 py27_0", + "werkzeug 0.14.1 py27_0", + "unicodecsv 0.14.1 py27_0", + "scipy 1.1.0 py27hfa4b5c9_1", + "backports.shutil_get_terminal_size 1.0.0 py27_2", + "unittest2 1.1.0 py27_0", + "flask-cors 3.0.6 py27_0", + "prometheus_client 0.3.1 py27h28b3542_0", + "pluggy 0.7.1 py27h28b3542_0", + "openpyxl 2.5.6 py27_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "jupyterlab_launcher 0.11.2 py27h28b3542_0", + "libxcb 1.13 h1bed415_1", + "pyasn1 0.4.4 py27h28b3542_0", + "mpc 1.1.0 h10f8cd9_1", + "jdcal 1.4 py27_0", + "service_identity 17.0.0 py27h28b3542_0", + "configparser 3.5.0 py27_0", + "nbformat 4.4.0 py27_0", + "constantly 15.1.0 py27h28b3542_0", + "get_terminal_size 1.0.0 haa9412d_0", + "seaborn 0.9.0 py27_0", + "tblib 1.3.2 py27_0", + "bokeh 0.13.0 py27_0", + "hyperlink 18.0.0 py27_0", + "ipaddress 1.0.22 py27_0", + "numpydoc 0.8.0 py27_0", + "libtool 2.4.6 h544aabb_3", + "statsmodels 0.9.0 py27h035aef0_0", + "pyparsing 2.2.0 py27_1", + "six 1.11.0 py27_1", + "pyopenssl 18.0.0 py27_0", + "subprocess32 3.5.2 py27h14c3975_0", + "tornado 5.1 py27h14c3975_0", + "tqdm 4.26.0 py27h28b3542_0", + "flask 1.0.2 py27_1", + "pyqt 5.9.2 py27h05f1152_2", + "numpy-base 1.15.1 py27h81de0dd_0", + "pytables 3.4.4 py27ha205bf6_0", + "traitlets 4.3.2 py27_0", + "jedi 0.12.1 py27_0", + "qtconsole 4.4.1 py27_0", + "xlsxwriter 1.1.0 py27_0", + "sympy 1.2 py27_0", + "click 6.7 py27_0", + "pycodestyle 2.4.0 py27_0", + "tk 8.6.8 hbc83047_0", + "mkl 2018.0.3 1" + ], + "license": "BSD", + "md5": "764a1256e60d287595a19077fe923d61", + "name": "anaconda", + "namespace": "python", + "sha256": "0f10908ab1bfdd5c930d3b4cf96ce30937e3b218723257d5b005e01f5a1221b6", + "size": 10881, + "subdir": "linux-64", + "timestamp": 1537855543424, + "version": "5.3.0" + }, + "anaconda-5.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "requests 2.19.1 py36_0", + "appdirs 1.4.3 py36h28b3542_0", + "h5py 2.8.0 py36h989c5e5_3", + "send2trash 1.5.0 py36_0", + "psutil 5.4.7 py36h14c3975_0", + "backports.shutil_get_terminal_size 1.0.0 py36_2", + "qtpy 1.5.0 py36_0", + "jupyter_client 5.2.3 py36_0", + "filelock 3.0.8 py36_0", + "pycodestyle 2.4.0 py36_0", + "multipledispatch 0.6.0 py36_0", + "cryptography 2.3.1 py36hc365091_0", + "pytables 3.4.4 py36ha205bf6_0", + "curl 7.61.0 h84994c4_0", + "et_xmlfile 1.0.1 py36_0", + "pycosat 0.6.3 py36h14c3975_0", + "tblib 1.3.2 py36_0", + "spyder-kernels 0.2.6 py36_0", + "blosc 1.14.4 hdbcaa40_0", + "pkginfo 1.4.2 py36_1", + "unicodecsv 0.14.1 py36_0", + "babel 2.6.0 py36_0", + "sqlite 3.24.0 h84994c4_0", + "colorama 0.3.9 py36_0", + "dask-core 0.19.1 py36_0", + "pango 1.42.4 h049681c_0", + "nbconvert 5.4.0 py36_1", + "cytoolz 0.9.0.1 py36h14c3975_1", + "twisted 18.7.0 py36h14c3975_1", + "automat 0.7.0 py36_0", + "llvmlite 0.24.0 py36hdbcaa40_0", + "openssl 1.0.2p h14c3975_0", + "toolz 0.9.0 py36_0", + "gevent 1.3.6 py36h7b6447c_0", + "entrypoints 0.2.3 py36_2", + "pytest-openfiles 0.3.0 py36_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "prometheus_client 0.3.1 py36h28b3542_0", + "jeepney 0.3.1 py36_0", + "nltk 3.3.0 py36_0", + "ipython_genutils 0.2.0 py36_0", + "zlib 1.2.11 ha838bed_2", + "pywavelets 1.0.0 py36hdd07704_0", + "mccabe 0.6.1 py36_1", + "certifi 2018.8.24 py36_1", + "numexpr 2.6.8 py36hd89afb7_0", + "backports 1.0 py36_1", + "mkl_fft 1.0.4 py36h4414c95_1", + "glib 2.56.2 hd408876_0", + "tornado 5.1 py36h14c3975_0", + "zeromq 4.2.5 hf484d3e_1", + "notebook 5.6.0 py36_0", + "datashape 0.5.4 py36_1", + "bitarray 0.8.3 py36h14c3975_0", + "icu 58.2 h9c2bf20_1", + "six 1.11.0 py36_1", + "jupyter_core 4.4.0 py36_0", + "libtool 2.4.6 h544aabb_3", + "ipython 6.5.0 py36_0", + "fastcache 1.0.2 py36h14c3975_2", + "greenlet 0.4.15 py36h7b6447c_0", + "werkzeug 0.14.1 py36_0", + "flask-cors 3.0.6 py36_0", + "matplotlib 2.2.3 py36hb69df0a_0", + "snowballstemmer 1.2.1 py36_0", + "qtawesome 0.4.4 py36_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py36h10f8cd9_2", + "pygments 2.2.0 py36_0", + "pyparsing 2.2.0 py36_1", + "freetype 2.9.1 h8a8886c_1", + "astroid 2.0.4 py36_0", + "pyasn1-modules 0.2.2 py36_0", + "sip 4.19.8 py36hf484d3e_0", + "service_identity 17.0.0 py36h28b3542_0", + "dbus 1.13.2 h714fa37_1", + "pytest-remotedata 0.3.0 py36_0", + "statsmodels 0.9.0 py36h035aef0_0", + "pillow 5.2.0 py36heded4f4_0", + "jinja2 2.10 py36_0", + "sqlalchemy 1.2.11 py36h7b6447c_0", + "wrapt 1.10.11 py36h14c3975_2", + "qt 5.9.6 h8703b6f_2", + "path.py 11.1.0 py36_0", + "dask 0.19.1 py36_0", + "pexpect 4.6.0 py36_0", + "jupyter 1.0.0 py36_7", + "odo 0.5.1 py36_0", + "pycparser 2.18 py36_1", + "snappy 1.1.7 hbae5bb6_3", + "parso 0.3.1 py36_0", + "html5lib 1.0.1 py36_0", + "itsdangerous 0.24 py36_1", + "libpng 1.6.34 hb9fc6fc_0", + "nose 1.3.7 py36_2", + "numba 0.39.0 py36h04863e7_0", + "packaging 17.1 py36_0", + "pyflakes 2.0.0 py36_0", + "mkl-service 1.1.2 py36h90e4bf4_5", + "nbformat 4.4.0 py36_0", + "sphinxcontrib-websupport 1.1.0 py36_1", + "cython 0.28.5 py36hf484d3e_0", + "lzo 2.10 h49e0be7_2", + "wheel 0.31.1 py36_0", + "python-dateutil 2.7.3 py36_0", + "patsy 0.5.0 py36_0", + "graphite2 1.3.12 h23475e2_2", + "pip 10.0.1 py36_0", + "webencodings 0.5.1 py36_1", + "gstreamer 1.14.0 hb453b48_1", + "python 3.6.6 hc3d631a_0", + "libgcc-ng 8.2.0 hdf63c60_1", + "secretstorage 3.1.0 py36_0", + "spyder 3.3.1 py36_1", + "heapdict 1.0.0 py36_2", + "idna 2.7 py36_0", + "libtiff 4.0.9 he85c1e1_2", + "more-itertools 4.3.0 py36_0", + "mpc 1.1.0 h10f8cd9_1", + "distributed 1.23.1 py36_0", + "constantly 15.1.0 py36h28b3542_0", + "fribidi 1.0.5 h7b6447c_0", + "clyent 1.2.2 py36_1", + "libxcb 1.13 h1bed415_1", + "pyasn1 0.4.4 py36h28b3542_0", + "ca-certificates 2018.03.07 0", + "bkcharts 0.2 py36_0", + "jdcal 1.4 py36_0", + "tk 8.6.8 hbc83047_0", + "docutils 0.14 py36_0", + "imageio 2.4.1 py36_0", + "boto 2.49.0 py36_0", + "libxslt 1.1.32 h1312cb7_0", + "imagesize 1.1.0 py36_0", + "click 6.7 py36_0", + "pytest-arraydiff 0.2 py36h39e3cac_0", + "asn1crypto 0.24.0 py36_0", + "markupsafe 1.0 py36h14c3975_1", + "scikit-learn 0.19.2 py36h4989274_0", + "scikit-image 0.14.0 py36hf484d3e_1", + "pickleshare 0.7.4 py36_0", + "libuuid 1.0.3 h1bed415_2", + "hyperlink 18.0.0 py36_0", + "glob2 0.6 py36_0", + "olefile 0.46 py36_0", + "lxml 4.2.5 py36hefd8a0e_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "numpy-base 1.15.1 py36h81de0dd_0", + "seaborn 0.9.0 py36_0", + "backcall 0.1.0 py36_0", + "mpmath 1.0.0 py36_2", + "sortedcollections 1.0.1 py36_0", + "sphinx 1.7.9 py36_0", + "yaml 0.1.7 had09818_2", + "blas 1.0 mkl", + "testpath 0.3.1 py36_0", + "lazy-object-proxy 1.3.1 py36h14c3975_2", + "astropy 3.0.4 py36h14c3975_0", + "ipykernel 4.9.0 py36_1", + "cffi 1.11.5 py36he75722e_1", + "sympy 1.2 py36_0", + "expat 2.2.6 he6710b0_0", + "networkx 2.1 py36_0", + "zope.interface 4.5.0 py36h14c3975_0", + "xz 5.2.4 h14c3975_4", + "pytest-astropy 0.4.0 py36_0", + "traitlets 4.3.2 py36_0", + "bzip2 1.0.6 h14c3975_5", + "py 1.6.0 py36_0", + "ncurses 6.1 hf484d3e_0", + "zict 0.1.3 py36_0", + "terminado 0.8.1 py36_1", + "jupyter_console 5.2.0 py36_1", + "numpy 1.15.1 py36h1d66e8a_0", + "jupyterlab_launcher 0.13.1 py36_0", + "libsodium 1.0.16 h1bed415_0", + "libedit 3.1.20170329 h6b74fdf_2", + "jsonschema 2.6.0 py36_0", + "pysocks 1.6.8 py36_0", + "bokeh 0.13.0 py36_0", + "typed-ast 1.1.0 py36h14c3975_0", + "jbig 2.1 hdba287a_0", + "kiwisolver 1.0.1 py36hf484d3e_0", + "cloudpickle 0.5.5 py36_0", + "libxml2 2.9.8 h26e45fe_1", + "pcre 8.42 h439df22_0", + "qtconsole 4.4.1 py36_0", + "zope 1.0 py36_1", + "simplegeneric 0.8.1 py36_2", + "widgetsnbextension 3.4.1 py36_0", + "cycler 0.10.0 py36_0", + "xlwt 1.3.0 py36_0", + "pytz 2018.5 py36_0", + "numpydoc 0.8.0 py36_0", + "sphinxcontrib 1.0 py36_1", + "pixman 0.34.0 hceecf20_3", + "prompt_toolkit 1.0.15 py36_0", + "pyopenssl 18.0.0 py36_0", + "ptyprocess 0.6.0 py36_0", + "xlrd 1.1.0 py36_1", + "ruamel_yaml 0.15.46 py36h14c3975_0", + "jupyterlab 0.34.9 py36_0", + "openpyxl 2.5.6 py36_0", + "tqdm 4.26.0 py36h28b3542_0", + "decorator 4.3.0 py36_0", + "incremental 17.5.0 py36_0", + "urllib3 1.23 py36_0", + "ipywidgets 7.4.1 py36_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "ply 3.11 py36_0", + "alabaster 0.7.11 py36_0", + "partd 0.3.8 py36_0", + "pylint 2.1.1 py36_0", + "anaconda-project 0.8.2 py36_0", + "hdf5 1.10.2 hba1933b_1", + "pandas 0.23.4 py36h04863e7_0", + "blaze 0.11.3 py36_0", + "pyodbc 4.0.24 py36he6710b0_0", + "wcwidth 0.1.7 py36_0", + "locket 0.2.0 py36_1", + "intel-openmp 2019.0 118", + "pyqt 5.9.2 py36h05f1152_2", + "pytest 3.8.0 py36_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "pyzmq 17.1.2 py36h14c3975_0", + "flask 1.0.2 py36_1", + "sortedcontainers 2.0.5 py36_0", + "unixodbc 2.3.7 h14c3975_0", + "rope 0.11.0 py36_0", + "pep8 1.7.1 py36_0", + "pyyaml 3.13 py36h14c3975_0", + "patchelf 0.9 hf484d3e_2", + "mpfr 4.0.1 hdf1c602_3", + "contextlib2 0.5.5 py36_0", + "defusedxml 0.5.0 py36_1", + "keyring 13.2.1 py36_0", + "jpeg 9b h024ee3a_2", + "mkl_random 1.0.1 py36h4414c95_1", + "fontconfig 2.13.0 h9420a91_0", + "libffi 3.2.1 hd88cf55_4", + "pandocfilters 1.4.2 py36_1", + "singledispatch 3.4.0.3 py36_0", + "libcurl 7.61.0 h1ad7b7a_0", + "pluggy 0.7.1 py36h28b3542_0", + "mistune 0.8.3 py36h14c3975_1", + "xlsxwriter 1.1.0 py36_0", + "attrs 18.2.0 py36h28b3542_0", + "pycurl 7.43.0.2 py36hb7f436b_0", + "pathlib2 2.3.2 py36_0", + "get_terminal_size 1.0.0 haa9412d_0", + "pycrypto 2.6.1 py36h14c3975_9", + "pytest-doctestplus 0.1.3 py36_0", + "jedi 0.12.1 py36_0", + "cairo 1.14.12 h8948797_3", + "scipy 1.1.0 py36hfa4b5c9_1", + "anaconda-client 1.7.2 py36_0", + "bottleneck 1.2.1 py36h035aef0_1", + "libssh2 1.8.0 h9cfc8f7_4", + "beautifulsoup4 4.6.3 py36_0", + "msgpack-python 0.5.6 py36h6bb024c_1", + "readline 7.0 h7b6447c_5", + "isort 4.3.4 py36_0", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "chardet 3.0.4 py36_1", + "bleach 2.1.4 py36_0", + "setuptools 40.2.0 py36_0", + "atomicwrites 1.2.1 py36_0", + "mkl 2018.0.3 1" + ], + "license": "BSD", + "md5": "d510179546d05d53163f0a8a2ae369fa", + "name": "anaconda", + "namespace": "python", + "sha256": "f32a33e31572e5d3c0ee2bd736eb1cb4b717df9cf94d84fbdc0e4f26db282b6b", + "size": 10683, + "subdir": "linux-64", + "timestamp": 1538077226235, + "version": "5.3.0" + }, + "anaconda-5.3.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "requests 2.19.1 py36_0", + "appdirs 1.4.3 py36h28b3542_0", + "h5py 2.8.0 py36h989c5e5_3", + "send2trash 1.5.0 py36_0", + "psutil 5.4.7 py36h14c3975_0", + "backports.shutil_get_terminal_size 1.0.0 py36_2", + "qtpy 1.5.0 py36_0", + "jupyter_client 5.2.3 py36_0", + "filelock 3.0.8 py36_0", + "pycodestyle 2.4.0 py36_0", + "multipledispatch 0.6.0 py36_0", + "cryptography 2.3.1 py36hc365091_0", + "pytables 3.4.4 py36ha205bf6_0", + "curl 7.61.0 h84994c4_0", + "et_xmlfile 1.0.1 py36_0", + "pycosat 0.6.3 py36h14c3975_0", + "tblib 1.3.2 py36_0", + "spyder-kernels 0.2.6 py36_0", + "blosc 1.14.4 hdbcaa40_0", + "pkginfo 1.4.2 py36_1", + "unicodecsv 0.14.1 py36_0", + "babel 2.6.0 py36_0", + "sqlite 3.24.0 h84994c4_0", + "colorama 0.3.9 py36_0", + "dask-core 0.19.1 py36_0", + "pango 1.42.4 h049681c_0", + "nbconvert 5.4.0 py36_1", + "cytoolz 0.9.0.1 py36h14c3975_1", + "twisted 18.7.0 py36h14c3975_1", + "automat 0.7.0 py36_0", + "llvmlite 0.24.0 py36hdbcaa40_0", + "openssl 1.0.2p h14c3975_0", + "toolz 0.9.0 py36_0", + "gevent 1.3.6 py36h7b6447c_0", + "entrypoints 0.2.3 py36_2", + "pytest-openfiles 0.3.0 py36_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "prometheus_client 0.3.1 py36h28b3542_0", + "jeepney 0.3.1 py36_0", + "nltk 3.3.0 py36_0", + "ipython_genutils 0.2.0 py36_0", + "zlib 1.2.11 ha838bed_2", + "pywavelets 1.0.0 py36hdd07704_0", + "mccabe 0.6.1 py36_1", + "certifi 2018.8.24 py36_1", + "numexpr 2.6.8 py36hd89afb7_0", + "backports 1.0 py36_1", + "mkl_fft 1.0.4 py36h4414c95_1", + "glib 2.56.2 hd408876_0", + "tornado 5.1 py36h14c3975_0", + "zeromq 4.2.5 hf484d3e_1", + "notebook 5.6.0 py36_0", + "datashape 0.5.4 py36_1", + "bitarray 0.8.3 py36h14c3975_0", + "icu 58.2 h9c2bf20_1", + "six 1.11.0 py36_1", + "jupyter_core 4.4.0 py36_0", + "libtool 2.4.6 h544aabb_3", + "ipython 6.5.0 py36_0", + "fastcache 1.0.2 py36h14c3975_2", + "greenlet 0.4.15 py36h7b6447c_0", + "werkzeug 0.14.1 py36_0", + "flask-cors 3.0.6 py36_0", + "matplotlib 2.2.3 py36hb69df0a_0", + "snowballstemmer 1.2.1 py36_0", + "qtawesome 0.4.4 py36_0", + "gmp 6.1.2 h6c8ec71_1", + "gmpy2 2.0.8 py36h10f8cd9_2", + "pygments 2.2.0 py36_0", + "pyparsing 2.2.0 py36_1", + "freetype 2.9.1 h8a8886c_1", + "astroid 2.0.4 py36_0", + "pyasn1-modules 0.2.2 py36_0", + "sip 4.19.8 py36hf484d3e_0", + "service_identity 17.0.0 py36h28b3542_0", + "dbus 1.13.2 h714fa37_1", + "pytest-remotedata 0.3.0 py36_0", + "statsmodels 0.9.0 py36h035aef0_0", + "pillow 5.2.0 py36heded4f4_0", + "jinja2 2.10 py36_0", + "sqlalchemy 1.2.11 py36h7b6447c_0", + "wrapt 1.10.11 py36h14c3975_2", + "qt 5.9.6 h8703b6f_2", + "path.py 11.1.0 py36_0", + "dask 0.19.1 py36_0", + "pexpect 4.6.0 py36_0", + "jupyter 1.0.0 py36_7", + "odo 0.5.1 py36_0", + "pycparser 2.18 py36_1", + "snappy 1.1.7 hbae5bb6_3", + "parso 0.3.1 py36_0", + "html5lib 1.0.1 py36_0", + "itsdangerous 0.24 py36_1", + "libpng 1.6.34 hb9fc6fc_0", + "nose 1.3.7 py36_2", + "numba 0.39.0 py36h04863e7_0", + "packaging 17.1 py36_0", + "pyflakes 2.0.0 py36_0", + "mkl-service 1.1.2 py36h90e4bf4_5", + "nbformat 4.4.0 py36_0", + "sphinxcontrib-websupport 1.1.0 py36_1", + "cython 0.28.5 py36hf484d3e_0", + "lzo 2.10 h49e0be7_2", + "wheel 0.31.1 py36_0", + "python-dateutil 2.7.3 py36_0", + "patsy 0.5.0 py36_0", + "graphite2 1.3.12 h23475e2_2", + "pip 10.0.1 py36_0", + "webencodings 0.5.1 py36_1", + "gstreamer 1.14.0 hb453b48_1", + "python 3.6.6 hc3d631a_0", + "libgcc-ng 8.2.0 hdf63c60_1", + "secretstorage 3.1.0 py36_0", + "spyder 3.3.1 py36_1", + "heapdict 1.0.0 py36_2", + "idna 2.7 py36_0", + "libtiff 4.0.9 he85c1e1_2", + "more-itertools 4.3.0 py36_0", + "mpc 1.1.0 h10f8cd9_1", + "distributed 1.23.1 py36_0", + "constantly 15.1.0 py36h28b3542_0", + "fribidi 1.0.5 h7b6447c_0", + "clyent 1.2.2 py36_1", + "libxcb 1.13 h1bed415_1", + "pyasn1 0.4.4 py36h28b3542_0", + "ca-certificates 2018.03.07 0", + "bkcharts 0.2 py36_0", + "jdcal 1.4 py36_0", + "tk 8.6.8 hbc83047_0", + "docutils 0.14 py36_0", + "imageio 2.4.1 py36_0", + "boto 2.49.0 py36_0", + "libxslt 1.1.32 h1312cb7_0", + "imagesize 1.1.0 py36_0", + "click 6.7 py36_0", + "pytest-arraydiff 0.2 py36h39e3cac_0", + "asn1crypto 0.24.0 py36_0", + "markupsafe 1.0 py36h14c3975_1", + "scikit-learn 0.19.2 py36h4989274_0", + "scikit-image 0.14.0 py36hf484d3e_1", + "pickleshare 0.7.4 py36_0", + "libuuid 1.0.3 h1bed415_2", + "hyperlink 18.0.0 py36_0", + "glob2 0.6 py36_0", + "olefile 0.46 py36_0", + "lxml 4.2.5 py36hefd8a0e_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "numpy-base 1.15.1 py36h81de0dd_0", + "seaborn 0.9.0 py36_0", + "backcall 0.1.0 py36_0", + "mpmath 1.0.0 py36_2", + "sortedcollections 1.0.1 py36_0", + "sphinx 1.7.9 py36_0", + "yaml 0.1.7 had09818_2", + "blas 1.0 mkl", + "testpath 0.3.1 py36_0", + "lazy-object-proxy 1.3.1 py36h14c3975_2", + "astropy 3.0.4 py36h14c3975_0", + "ipykernel 4.9.0 py36_1", + "cffi 1.11.5 py36he75722e_1", + "sympy 1.2 py36_0", + "expat 2.2.6 he6710b0_0", + "networkx 2.1 py36_0", + "zope.interface 4.5.0 py36h14c3975_0", + "xz 5.2.4 h14c3975_4", + "pytest-astropy 0.4.0 py36_0", + "traitlets 4.3.2 py36_0", + "bzip2 1.0.6 h14c3975_5", + "py 1.6.0 py36_0", + "ncurses 6.1 hf484d3e_0", + "zict 0.1.3 py36_0", + "terminado 0.8.1 py36_1", + "jupyter_console 5.2.0 py36_1", + "numpy 1.15.1 py36h3b04361_0", + "jupyterlab_launcher 0.13.1 py36_0", + "libsodium 1.0.16 h1bed415_0", + "libedit 3.1.20170329 h6b74fdf_2", + "jsonschema 2.6.0 py36_0", + "pysocks 1.6.8 py36_0", + "bokeh 0.13.0 py36_0", + "typed-ast 1.1.0 py36h14c3975_0", + "jbig 2.1 hdba287a_0", + "kiwisolver 1.0.1 py36hf484d3e_0", + "cloudpickle 0.5.5 py36_0", + "libxml2 2.9.8 h26e45fe_1", + "pcre 8.42 h439df22_0", + "qtconsole 4.4.1 py36_0", + "zope 1.0 py36_1", + "simplegeneric 0.8.1 py36_2", + "widgetsnbextension 3.4.1 py36_0", + "cycler 0.10.0 py36_0", + "xlwt 1.3.0 py36_0", + "pytz 2018.5 py36_0", + "numpydoc 0.8.0 py36_0", + "sphinxcontrib 1.0 py36_1", + "pixman 0.34.0 hceecf20_3", + "prompt_toolkit 1.0.15 py36_0", + "pyopenssl 18.0.0 py36_0", + "ptyprocess 0.6.0 py36_0", + "xlrd 1.1.0 py36_1", + "ruamel_yaml 0.15.46 py36h14c3975_0", + "jupyterlab 0.34.9 py36_0", + "openpyxl 2.5.6 py36_0", + "tqdm 4.26.0 py36h28b3542_0", + "decorator 4.3.0 py36_0", + "incremental 17.5.0 py36_0", + "urllib3 1.23 py36_0", + "ipywidgets 7.4.1 py36_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "ply 3.11 py36_0", + "alabaster 0.7.11 py36_0", + "partd 0.3.8 py36_0", + "pylint 2.1.1 py36_0", + "anaconda-project 0.8.2 py36_0", + "hdf5 1.10.2 hba1933b_1", + "pandas 0.23.4 py36h04863e7_0", + "blaze 0.11.3 py36_0", + "pyodbc 4.0.24 py36he6710b0_0", + "wcwidth 0.1.7 py36_0", + "locket 0.2.0 py36_1", + "intel-openmp 2019.0 118", + "pyqt 5.9.2 py36h05f1152_2", + "pytest 3.8.0 py36_0", + "harfbuzz 1.8.8 hffaf4a1_0", + "pyzmq 17.1.2 py36h14c3975_0", + "flask 1.0.2 py36_1", + "sortedcontainers 2.0.5 py36_0", + "unixodbc 2.3.7 h14c3975_0", + "rope 0.11.0 py36_0", + "pep8 1.7.1 py36_0", + "pyyaml 3.13 py36h14c3975_0", + "patchelf 0.9 hf484d3e_2", + "mpfr 4.0.1 hdf1c602_3", + "contextlib2 0.5.5 py36_0", + "defusedxml 0.5.0 py36_1", + "keyring 13.2.1 py36_0", + "jpeg 9b h024ee3a_2", + "mkl_random 1.0.1 py36h4414c95_1", + "fontconfig 2.13.0 h9420a91_0", + "libffi 3.2.1 hd88cf55_4", + "pandocfilters 1.4.2 py36_1", + "singledispatch 3.4.0.3 py36_0", + "libcurl 7.61.0 h1ad7b7a_0", + "pluggy 0.7.1 py36h28b3542_0", + "mistune 0.8.3 py36h14c3975_1", + "xlsxwriter 1.1.0 py36_0", + "attrs 18.2.0 py36h28b3542_0", + "pycurl 7.43.0.2 py36hb7f436b_0", + "pathlib2 2.3.2 py36_0", + "mkl 2018.0.3 1", + "get_terminal_size 1.0.0 haa9412d_0", + "pycrypto 2.6.1 py36h14c3975_9", + "pytest-doctestplus 0.1.3 py36_0", + "jedi 0.12.1 py36_0", + "cairo 1.14.12 h8948797_3", + "scipy 1.1.0 py36hfa4b5c9_1", + "anaconda-client 1.7.2 py36_0", + "bottleneck 1.2.1 py36h035aef0_1", + "libssh2 1.8.0 h9cfc8f7_4", + "beautifulsoup4 4.6.3 py36_0", + "msgpack-python 0.5.6 py36h6bb024c_1", + "readline 7.0 h7b6447c_5", + "isort 4.3.4 py36_0", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "chardet 3.0.4 py36_1", + "bleach 2.1.4 py36_0", + "setuptools 40.2.0 py36_0", + "atomicwrites 1.2.1 py36_0" + ], + "license": "BSD", + "md5": "446195fc04061550f75f412870a5b8f8", + "name": "anaconda", + "namespace": "python", + "sha256": "1fd64d76a56931423886966a427019a9b5b9a7006e0fe3fa266bdde2e88a3f39", + "size": 10686, + "subdir": "linux-64", + "timestamp": 1538077226235, + "version": "5.3.0" + }, + "anaconda-5.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python-dateutil 2.7.3 py37_0", + "clyent 1.2.2 py37_1", + "alabaster 0.7.11 py37_0", + "numba 0.39.0 py37h04863e7_0", + "jpeg 9b h024ee3a_2", + "mpmath 1.0.0 py37_2", + "click 6.7 py37_0", + "fastcache 1.0.2 py37h14c3975_2", + "pycodestyle 2.4.0 py37_0", + "astropy 3.0.4 py37h14c3975_0", + "automat 0.7.0 py37_0", + "fribidi 1.0.5 h7b6447c_0", + "xlrd 1.1.0 py37_1", + "pytest 3.8.0 py37_0", + "parso 0.3.1 py37_0", + "isort 4.3.4 py37_0", + "pango 1.42.4 h049681c_0", + "libpng 1.6.34 hb9fc6fc_0", + "nltk 3.3.0 py37_0", + "pytest-astropy 0.4.0 py37_0", + "secretstorage 3.1.0 py37_0", + "incremental 17.5.0 py37_0", + "qtconsole 4.4.1 py37_0", + "jinja2 2.10 py37_0", + "prompt_toolkit 1.0.15 py37_0", + "appdirs 1.4.3 py37h28b3542_0", + "olefile 0.46 py37_0", + "setuptools 40.2.0 py37_0", + "msgpack-python 0.5.6 py37h6bb024c_1", + "qtawesome 0.4.4 py37_0", + "zeromq 4.2.5 hf484d3e_1", + "beautifulsoup4 4.6.3 py37_0", + "get_terminal_size 1.0.0 haa9412d_0", + "colorama 0.3.9 py37_0", + "six 1.11.0 py37_1", + "spyder-kernels 0.2.6 py37_0", + "ca-certificates 2018.03.07 0", + "gevent 1.3.6 py37h7b6447c_0", + "numpy 1.15.1 py37h1d66e8a_0", + "pytest-arraydiff 0.2 py37h39e3cac_0", + "pyflakes 2.0.0 py37_0", + "hyperlink 18.0.0 py37_0", + "pyzmq 17.1.2 py37h14c3975_0", + "tk 8.6.8 hbc83047_0", + "statsmodels 0.9.0 py37h035aef0_0", + "flask 1.0.2 py37_1", + "cloudpickle 0.5.5 py37_0", + "pexpect 4.6.0 py37_0", + "jupyter_core 4.4.0 py37_0", + "wheel 0.31.1 py37_0", + "ipykernel 4.9.0 py37_1", + "werkzeug 0.14.1 py37_0", + "numexpr 2.6.8 py37hd89afb7_0", + "pickleshare 0.7.4 py37_0", + "libxslt 1.1.32 h1312cb7_0", + "xlwt 1.3.0 py37_0", + "cytoolz 0.9.0.1 py37h14c3975_1", + "imagesize 1.1.0 py37_0", + "pygments 2.2.0 py37_0", + "dbus 1.13.2 h714fa37_1", + "pytz 2018.5 py37_0", + "hdf5 1.10.2 hba1933b_1", + "webencodings 0.5.1 py37_1", + "ipywidgets 7.4.1 py37_0", + "nose 1.3.7 py37_2", + "openssl 1.0.2p h14c3975_0", + "py 1.6.0 py37_0", + "pytest-doctestplus 0.1.3 py37_0", + "bkcharts 0.2 py37_0", + "jupyterlab_launcher 0.13.1 py37_0", + "libtool 2.4.6 h544aabb_3", + "pytest-openfiles 0.3.0 py37_0", + "send2trash 1.5.0 py37_0", + "pathlib2 2.3.2 py37_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "qtpy 1.5.0 py37_0", + "locket 0.2.0 py37_1", + "ipython 6.5.0 py37_0", + "yaml 0.1.7 had09818_2", + "greenlet 0.4.15 py37h7b6447c_0", + "backcall 0.1.0 py37_0", + "dask 0.19.1 py37_0", + "toolz 0.9.0 py37_0", + "xlsxwriter 1.1.0 py37_0", + "gmpy2 2.0.8 py37h10f8cd9_2", + "cython 0.28.5 py37hf484d3e_0", + "nbconvert 5.4.0 py37_1", + "pillow 5.2.0 py37heded4f4_0", + "sphinxcontrib-websupport 1.1.0 py37_1", + "zope.interface 4.5.0 py37h14c3975_0", + "mpc 1.1.0 h10f8cd9_1", + "wcwidth 0.1.7 py37_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "itsdangerous 0.24 py37_1", + "pyparsing 2.2.0 py37_1", + "odo 0.5.1 py37_0", + "sortedcontainers 2.0.5 py37_0", + "libxml2 2.9.8 h26e45fe_1", + "ply 3.11 py37_0", + "ptyprocess 0.6.0 py37_0", + "python 3.7.0 hc3d631a_0", + "cffi 1.11.5 py37he75722e_1", + "et_xmlfile 1.0.1 py37_0", + "expat 2.2.6 he6710b0_0", + "cycler 0.10.0 py37_0", + "ncurses 6.1 hf484d3e_0", + "simplegeneric 0.8.1 py37_2", + "numpy-base 1.15.1 py37h81de0dd_0", + "mkl-service 1.1.2 py37h90e4bf4_5", + "asn1crypto 0.24.0 py37_0", + "bleach 2.1.4 py37_0", + "service_identity 17.0.0 py37h28b3542_0", + "pyqt 5.9.2 py37h05f1152_2", + "blaze 0.11.3 py37_0", + "jdcal 1.4 py37_0", + "path.py 11.1.0 py37_0", + "widgetsnbextension 3.4.1 py37_0", + "idna 2.7 py37_0", + "lazy-object-proxy 1.3.1 py37h14c3975_2", + "markupsafe 1.0 py37h14c3975_1", + "glob2 0.6 py37_0", + "ruamel_yaml 0.15.46 py37h14c3975_0", + "snappy 1.1.7 hbae5bb6_3", + "sympy 1.2 py37_0", + "libgcc-ng 8.2.0 hdf63c60_1", + "jupyter 1.0.0 py37_7", + "decorator 4.3.0 py37_0", + "libsodium 1.0.16 h1bed415_0", + "mccabe 0.6.1 py37_1", + "zlib 1.2.11 ha838bed_2", + "harfbuzz 1.8.8 hffaf4a1_0", + "prometheus_client 0.3.1 py37h28b3542_0", + "intel-openmp 2019.0 118", + "patchelf 0.9 hf484d3e_2", + "testpath 0.3.1 py37_0", + "cairo 1.14.12 h8948797_3", + "constantly 15.1.0 py37h28b3542_0", + "mpfr 4.0.1 hdf1c602_3", + "twisted 18.7.0 py37h14c3975_1", + "cryptography 2.3.1 py37hc365091_0", + "jbig 2.1 hdba287a_0", + "bottleneck 1.2.1 py37h035aef0_1", + "backports 1.0 py37_1", + "pluggy 0.7.1 py37h28b3542_0", + "patsy 0.5.0 py37_0", + "spyder 3.3.1 py37_1", + "pycrypto 2.6.1 py37h14c3975_9", + "sqlalchemy 1.2.11 py37h7b6447c_0", + "matplotlib 2.2.3 py37hb69df0a_0", + "sip 4.19.8 py37hf484d3e_0", + "pylint 2.1.1 py37_0", + "pywavelets 1.0.0 py37hdd07704_0", + "tqdm 4.26.0 py37h28b3542_0", + "qt 5.9.6 h8703b6f_2", + "networkx 2.1 py37_0", + "zict 0.1.3 py37_0", + "defusedxml 0.5.0 py37_1", + "libffi 3.2.1 hd88cf55_4", + "distributed 1.23.1 py37_0", + "more-itertools 4.3.0 py37_0", + "bzip2 1.0.6 h14c3975_5", + "jupyter_console 5.2.0 py37_1", + "numpydoc 0.8.0 py37_0", + "urllib3 1.23 py37_0", + "pyodbc 4.0.24 py37he6710b0_0", + "pyasn1 0.4.4 py37h28b3542_0", + "babel 2.6.0 py37_0", + "anaconda-project 0.8.2 py37_0", + "sqlite 3.24.0 h84994c4_0", + "tornado 5.1 py37h14c3975_0", + "requests 2.19.1 py37_0", + "libcurl 7.61.0 h1ad7b7a_0", + "fontconfig 2.13.0 h9420a91_0", + "gstreamer 1.14.0 hb453b48_1", + "jupyter_client 5.2.3 py37_0", + "pyopenssl 18.0.0 py37_0", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "seaborn 0.9.0 py37_0", + "bitarray 0.8.3 py37h14c3975_0", + "llvmlite 0.24.0 py37hdbcaa40_0", + "tblib 1.3.2 py37_0", + "lxml 4.2.5 py37hefd8a0e_0", + "libxcb 1.13 h1bed415_1", + "icu 58.2 h9c2bf20_1", + "pytables 3.4.4 py37ha205bf6_0", + "attrs 18.2.0 py37h28b3542_0", + "singledispatch 3.4.0.3 py37_0", + "unixodbc 2.3.7 h14c3975_0", + "heapdict 1.0.0 py37_2", + "pycosat 0.6.3 py37h14c3975_0", + "curl 7.61.0 h84994c4_0", + "pandocfilters 1.4.2 py37_1", + "pandoc 1.19.2.1 hea2e7c5_1", + "docutils 0.14 py37_0", + "entrypoints 0.2.3 py37_2", + "jeepney 0.3.1 py37_0", + "lzo 2.10 h49e0be7_2", + "pip 10.0.1 py37_0", + "notebook 5.6.0 py37_0", + "scikit-learn 0.19.2 py37h4989274_0", + "unicodecsv 0.14.1 py37_0", + "mkl_random 1.0.1 py37h4414c95_1", + "partd 0.3.8 py37_0", + "libtiff 4.0.9 he85c1e1_2", + "atomicwrites 1.2.1 py37_0", + "graphite2 1.3.12 h23475e2_2", + "zope 1.0 py37_1", + "flask-cors 3.0.6 py37_0", + "blosc 1.14.4 hdbcaa40_0", + "boto 2.49.0 py37_0", + "multipledispatch 0.6.0 py37_0", + "ipython_genutils 0.2.0 py37_0", + "certifi 2018.8.24 py37_1", + "freetype 2.9.1 h8a8886c_1", + "dask-core 0.19.1 py37_0", + "terminado 0.8.1 py37_1", + "glib 2.56.2 hd408876_0", + "sortedcollections 1.0.1 py37_0", + "anaconda-client 1.7.2 py37_0", + "pysocks 1.6.8 py37_0", + "scikit-image 0.14.0 py37hf484d3e_1", + "bokeh 0.13.0 py37_0", + "pyasn1-modules 0.2.2 py37_0", + "libuuid 1.0.3 h1bed415_2", + "h5py 2.8.0 py37h989c5e5_3", + "pyyaml 3.13 py37h14c3975_0", + "jupyterlab 0.34.9 py37_0", + "packaging 17.1 py37_0", + "readline 7.0 h7b6447c_5", + "libssh2 1.8.0 h9cfc8f7_4", + "pixman 0.34.0 hceecf20_3", + "jsonschema 2.6.0 py37_0", + "contextlib2 0.5.5 py37_0", + "pcre 8.42 h439df22_0", + "wrapt 1.10.11 py37h14c3975_2", + "blas 1.0 mkl", + "rope 0.11.0 py37_0", + "astroid 2.0.4 py37_0", + "pandas 0.23.4 py37h04863e7_0", + "gmp 6.1.2 h6c8ec71_1", + "mkl_fft 1.0.4 py37h4414c95_1", + "jedi 0.12.1 py37_0", + "sphinxcontrib 1.0 py37_1", + "openpyxl 2.5.6 py37_0", + "sphinx 1.7.9 py37_0", + "html5lib 1.0.1 py37_0", + "filelock 3.0.8 py37_0", + "imageio 2.4.1 py37_0", + "chardet 3.0.4 py37_1", + "mistune 0.8.3 py37h14c3975_1", + "pytest-remotedata 0.3.0 py37_0", + "libedit 3.1.20170329 h6b74fdf_2", + "keyring 13.2.1 py37_0", + "kiwisolver 1.0.1 py37hf484d3e_0", + "xz 5.2.4 h14c3975_4", + "pkginfo 1.4.2 py37_1", + "nbformat 4.4.0 py37_0", + "pycurl 7.43.0.2 py37hb7f436b_0", + "traitlets 4.3.2 py37_0", + "datashape 0.5.4 py37_1", + "scipy 1.1.0 py37hfa4b5c9_1", + "pep8 1.7.1 py37_0", + "snowballstemmer 1.2.1 py37_0", + "pycparser 2.18 py37_1", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "psutil 5.4.7 py37h14c3975_0", + "mkl 2018.0.3 1" + ], + "license": "BSD", + "md5": "f2769248ace941c6a2cfabefc967471f", + "name": "anaconda", + "namespace": "python", + "sha256": "a06968933eab83413ce80038085a2f59aa3937552c738946a090e8c6ee93dd35", + "size": 10610, + "subdir": "linux-64", + "timestamp": 1537856603411, + "version": "5.3.0" + }, + "anaconda-5.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bzip2 1.0.6 h14c3975_5", + "jupyter 1.0.0 py27_7", + "snappy 1.1.7 hbae5bb6_3", + "bitarray 0.8.3 py27h14c3975_0", + "qtawesome 0.4.4 py27_0", + "msgpack-python 0.5.6 py27h6bb024c_1", + "clyent 1.2.2 py27_1", + "flask-cors 3.0.6 py27_0", + "gstreamer 1.14.0 hb453b48_1", + "libedit 3.1.20170329 h6b74fdf_2", + "lzo 2.10 h49e0be7_2", + "filelock 3.0.8 py27_0", + "sphinx 1.7.9 py27_0", + "intel-openmp 2019.0 118", + "bkcharts 0.2 py27_0", + "subprocess32 3.5.2 py27h14c3975_0", + "yaml 0.1.7 had09818_2", + "atomicwrites 1.2.1 py27_0", + "pexpect 4.6.0 py27_0", + "funcsigs 1.0.2 py27_0", + "isort 4.3.4 py27_0", + "h5py 2.8.0 py27h989c5e5_3", + "openssl 1.0.2p h14c3975_0", + "pycurl 7.43.0.2 py27hb7f436b_0", + "pyflakes 2.0.0 py27_0", + "astropy 2.0.8 py27h035aef0_0", + "contextlib2 0.5.5 py27_0", + "xlwt 1.3.0 py27_0", + "numpy 1.15.1 py27h1d66e8a_0", + "hyperlink 18.0.0 py27_0", + "backports.functools_lru_cache 1.5 py27_1", + "scikit-image 0.14.0 py27hf484d3e_1", + "beautifulsoup4 4.6.3 py27_0", + "chardet 3.0.4 py27_1", + "get_terminal_size 1.0.0 haa9412d_0", + "xlsxwriter 1.1.0 py27_0", + "alabaster 0.7.11 py27_0", + "mpfr 4.0.1 hdf1c602_3", + "prompt_toolkit 1.0.15 py27_0", + "dask 0.19.1 py27_0", + "pyodbc 4.0.24 py27he6710b0_0", + "pyzmq 17.1.2 py27h14c3975_0", + "ruamel_yaml 0.15.46 py27h14c3975_0", + "partd 0.3.8 py27_0", + "datashape 0.5.4 py27_1", + "greenlet 0.4.15 py27h7b6447c_0", + "more-itertools 4.3.0 py27_0", + "libtiff 4.0.9 he85c1e1_2", + "incremental 17.5.0 py27_0", + "lazy-object-proxy 1.3.1 py27h14c3975_2", + "mpc 1.1.0 h10f8cd9_1", + "ipython_genutils 0.2.0 py27_0", + "scipy 1.1.0 py27hfa4b5c9_1", + "sortedcontainers 2.0.5 py27_0", + "nose 1.3.7 py27_2", + "locket 0.2.0 py27_1", + "imageio 2.4.1 py27_0", + "ca-certificates 2018.03.07 0", + "pytz 2018.5 py27_0", + "twisted 18.7.0 py27h14c3975_1", + "zope 1.0 py27_1", + "jsonschema 2.6.0 py27_0", + "pywavelets 1.0.0 py27hdd07704_0", + "odo 0.5.1 py27_0", + "pycodestyle 2.4.0 py27_0", + "gmp 6.1.2 h6c8ec71_1", + "notebook 5.6.0 py27_0", + "futures 3.2.0 py27_0", + "sphinxcontrib-websupport 1.1.0 py27_1", + "toolz 0.9.0 py27_0", + "pkginfo 1.4.2 py27_1", + "traceback2 1.4.0 py27_0", + "pcre 8.42 h439df22_0", + "numba 0.39.0 py27h04863e7_0", + "libssh2 1.8.0 h9cfc8f7_4", + "bleach 2.1.4 py27_0", + "typing 3.6.6 py27_0", + "markupsafe 1.0 py27h14c3975_1", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "icu 58.2 h9c2bf20_1", + "cloudpickle 0.5.5 py27_0", + "cycler 0.10.0 py27_0", + "nltk 3.3.0 py27_0", + "testpath 0.3.1 py27_0", + "idna 2.7 py27_0", + "unittest2 1.1.0 py27_0", + "glob2 0.6 py27_0", + "pytables 3.4.4 py27ha205bf6_0", + "networkx 2.1 py27_0", + "singledispatch 3.4.0.3 py27_0", + "patsy 0.5.0 py27_0", + "pyyaml 3.13 py27h14c3975_0", + "simplegeneric 0.8.1 py27_2", + "scandir 1.9.0 py27h14c3975_0", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "unicodecsv 0.14.1 py27_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 8.2.0 hdf63c60_1", + "jbig 2.1 hdba287a_0", + "jupyter_client 5.2.3 py27_0", + "astroid 1.6.5 py27_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "parso 0.3.1 py27_0", + "pandocfilters 1.4.2 py27_1", + "terminado 0.8.1 py27_1", + "entrypoints 0.2.3 py27_2", + "widgetsnbextension 3.4.1 py27_0", + "libxslt 1.1.32 h1312cb7_0", + "pyasn1 0.4.4 py27h28b3542_0", + "graphite2 1.3.12 h23475e2_2", + "python 2.7.15 h1571d57_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "colorama 0.3.9 py27_0", + "libpng 1.6.34 hb9fc6fc_0", + "constantly 15.1.0 py27h28b3542_0", + "wheel 0.31.1 py27_0", + "matplotlib 2.2.3 py27hb69df0a_0", + "jpeg 9b h024ee3a_2", + "ncurses 6.1 hf484d3e_0", + "itsdangerous 0.24 py27_1", + "linecache2 1.0.0 py27_0", + "multipledispatch 0.6.0 py27_0", + "sip 4.19.8 py27hf484d3e_0", + "ipython 5.8.0 py27_0", + "defusedxml 0.5.0 py27_1", + "cython 0.28.5 py27hf484d3e_0", + "tornado 5.1 py27h14c3975_0", + "pango 1.42.4 h049681c_0", + "cryptography 2.3.1 py27hc365091_0", + "sqlalchemy 1.2.11 py27h7b6447c_0", + "service_identity 17.0.0 py27h28b3542_0", + "python-dateutil 2.7.3 py27_0", + "sympy 1.2 py27_0", + "requests 2.19.1 py27_0", + "libcurl 7.61.0 h1ad7b7a_0", + "grin 1.2.1 py27_4", + "pylint 1.9.2 py27_0", + "decorator 4.3.0 py27_0", + "xz 5.2.4 h14c3975_4", + "qtconsole 4.4.1 py27_0", + "gmpy2 2.0.8 py27h10f8cd9_2", + "ipaddress 1.0.22 py27_0", + "py 1.6.0 py27_0", + "imagesize 1.1.0 py27_0", + "pluggy 0.7.1 py27h28b3542_0", + "pandas 0.23.4 py27h04863e7_0", + "cffi 1.11.5 py27he75722e_1", + "harfbuzz 1.8.8 hffaf4a1_0", + "pixman 0.34.0 hceecf20_3", + "html5lib 1.0.1 py27_0", + "kiwisolver 1.0.1 py27hf484d3e_0", + "pickleshare 0.7.4 py27_0", + "glib 2.56.2 hd408876_0", + "dbus 1.13.2 h714fa37_1", + "jinja2 2.10 py27_0", + "prometheus_client 0.3.1 py27h28b3542_0", + "jupyter_core 4.4.0 py27_0", + "backports_abc 0.5 py27_0", + "pip 10.0.1 py27_0", + "ipykernel 4.9.0 py27_1", + "jdcal 1.4 py27_0", + "blosc 1.14.4 hdbcaa40_0", + "asn1crypto 0.24.0 py27_0", + "click 6.7 py27_0", + "dask-core 0.19.1 py27_0", + "packaging 17.1 py27_0", + "pycosat 0.6.3 py27h14c3975_0", + "appdirs 1.4.3 py27h28b3542_0", + "curl 7.61.0 h84994c4_0", + "snowballstemmer 1.2.1 py27_0", + "setuptools 40.2.0 py27_0", + "readline 7.0 h7b6447c_5", + "automat 0.7.0 py27_0", + "spyder-kernels 0.2.6 py27_0", + "ipywidgets 7.4.1 py27_0", + "lxml 4.2.5 py27hefd8a0e_0", + "pyopenssl 18.0.0 py27_0", + "seaborn 0.9.0 py27_0", + "jupyter_console 5.2.0 py27_1", + "rope 0.11.0 py27_0", + "olefile 0.46 py27_0", + "numpydoc 0.8.0 py27_0", + "pyparsing 2.2.0 py27_1", + "ptyprocess 0.6.0 py27_0", + "nbformat 4.4.0 py27_0", + "cytoolz 0.9.0.1 py27h14c3975_1", + "webencodings 0.5.1 py27_1", + "libsodium 1.0.16 h1bed415_0", + "functools32 3.2.3.2 py27_1", + "statsmodels 0.9.0 py27h035aef0_0", + "flask 1.0.2 py27_1", + "docutils 0.14 py27_0", + "llvmlite 0.24.0 py27hdbcaa40_0", + "attrs 18.2.0 py27h28b3542_0", + "pygments 2.2.0 py27_0", + "mccabe 0.6.1 py27_1", + "backports.shutil_get_terminal_size 1.0.0 py27_2", + "six 1.11.0 py27_1", + "pytest 3.8.0 py27_0", + "blaze 0.11.3 py27_0", + "et_xmlfile 1.0.1 py27_0", + "spyder 3.3.1 py27_1", + "fastcache 1.0.2 py27h14c3975_2", + "unixodbc 2.3.7 h14c3975_0", + "numexpr 2.6.8 py27hd89afb7_0", + "ply 3.11 py27_0", + "numpy-base 1.15.1 py27h81de0dd_0", + "wrapt 1.10.11 py27h14c3975_2", + "tblib 1.3.2 py27_0", + "freetype 2.9.1 h8a8886c_1", + "qt 5.9.6 h8703b6f_2", + "cairo 1.14.12 h8948797_3", + "pep8 1.7.1 py27_0", + "certifi 2018.8.24 py27_1", + "psutil 5.4.7 py27h14c3975_0", + "heapdict 1.0.0 py27_2", + "mpmath 1.0.0 py27_2", + "ssl_match_hostname 3.5.0.1 py27_2", + "boto 2.49.0 py27_0", + "mistune 0.8.3 py27h14c3975_1", + "babel 2.6.0 py27_0", + "mkl_fft 1.0.4 py27h4414c95_1", + "anaconda-client 1.7.2 py27_0", + "urllib3 1.23 py27_0", + "zlib 1.2.11 ha838bed_2", + "xlrd 1.1.0 py27_1", + "sqlite 3.24.0 h84994c4_0", + "bottleneck 1.2.1 py27h035aef0_1", + "zope.interface 4.5.0 py27h14c3975_0", + "expat 2.2.6 he6710b0_0", + "pysocks 1.6.8 py27_0", + "bokeh 0.13.0 py27_0", + "fribidi 1.0.5 h7b6447c_0", + "pathlib2 2.3.2 py27_0", + "jupyterlab 0.33.11 py27_0", + "enum34 1.1.6 py27_1", + "cdecimal 2.3 py27h14c3975_3", + "configparser 3.5.0 py27_0", + "patchelf 0.9 hf484d3e_2", + "sortedcollections 1.0.1 py27_0", + "nbconvert 5.4.0 py27_1", + "anaconda-project 0.8.2 py27_0", + "libtool 2.4.6 h544aabb_3", + "werkzeug 0.14.1 py27_0", + "fontconfig 2.13.0 h9420a91_0", + "scikit-learn 0.19.2 py27h4989274_0", + "pycparser 2.18 py27_1", + "pycairo 1.17.1 py27h2a1e443_0", + "tk 8.6.8 hbc83047_0", + "jedi 0.12.1 py27_0", + "send2trash 1.5.0 py27_0", + "backports 1.0 py27_1", + "pycrypto 2.6.1 py27h14c3975_9", + "pyqt 5.9.2 py27h05f1152_2", + "qtpy 1.5.0 py27_0", + "libxcb 1.13 h1bed415_1", + "distributed 1.23.1 py27_0", + "pyasn1-modules 0.2.2 py27_0", + "libxml2 2.9.8 h26e45fe_1", + "mkl_random 1.0.1 py27h4414c95_1", + "hdf5 1.10.2 hba1933b_1", + "tqdm 4.26.0 py27h28b3542_0", + "path.py 11.1.0 py27_0", + "jupyterlab_launcher 0.11.2 py27h28b3542_0", + "libuuid 1.0.3 h1bed415_2", + "mkl-service 1.1.2 py27h90e4bf4_5", + "wcwidth 0.1.7 py27_0", + "traitlets 4.3.2 py27_0", + "zict 0.1.3 py27_0", + "zeromq 4.2.5 hf484d3e_1", + "openpyxl 2.5.6 py27_0", + "sphinxcontrib 1.0 py27_1", + "blas 1.0 mkl", + "pillow 5.2.0 py27heded4f4_0", + "gevent 1.3.6 py27h7b6447c_0", + "mkl 2018.0.3 1" + ], + "license": "BSD", + "md5": "161c4babc2a84867a109e2a75d6610b1", + "name": "anaconda", + "namespace": "python", + "sha256": "70c94e4f9408e13cd3aa8cbb2af714cd3246ee04e96ed11ae0fa9573949a8279", + "size": 10758, + "subdir": "linux-64", + "timestamp": 1541667463333, + "version": "5.3.1" + }, + "anaconda-5.3.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "bzip2 1.0.6 h14c3975_5", + "jupyter 1.0.0 py27_7", + "snappy 1.1.7 hbae5bb6_3", + "bitarray 0.8.3 py27h14c3975_0", + "mkl 2018.0.3 1", + "qtawesome 0.4.4 py27_0", + "msgpack-python 0.5.6 py27h6bb024c_1", + "clyent 1.2.2 py27_1", + "flask-cors 3.0.6 py27_0", + "gstreamer 1.14.0 hb453b48_1", + "libedit 3.1.20170329 h6b74fdf_2", + "lzo 2.10 h49e0be7_2", + "filelock 3.0.8 py27_0", + "sphinx 1.7.9 py27_0", + "intel-openmp 2019.0 118", + "bkcharts 0.2 py27_0", + "subprocess32 3.5.2 py27h14c3975_0", + "yaml 0.1.7 had09818_2", + "atomicwrites 1.2.1 py27_0", + "pexpect 4.6.0 py27_0", + "funcsigs 1.0.2 py27_0", + "isort 4.3.4 py27_0", + "h5py 2.8.0 py27h989c5e5_3", + "openssl 1.0.2p h14c3975_0", + "pycurl 7.43.0.2 py27hb7f436b_0", + "pyflakes 2.0.0 py27_0", + "astropy 2.0.8 py27h035aef0_0", + "contextlib2 0.5.5 py27_0", + "xlwt 1.3.0 py27_0", + "numpy 1.15.1 py27h3b04361_0", + "hyperlink 18.0.0 py27_0", + "backports.functools_lru_cache 1.5 py27_1", + "scikit-image 0.14.0 py27hf484d3e_1", + "beautifulsoup4 4.6.3 py27_0", + "chardet 3.0.4 py27_1", + "get_terminal_size 1.0.0 haa9412d_0", + "xlsxwriter 1.1.0 py27_0", + "alabaster 0.7.11 py27_0", + "mpfr 4.0.1 hdf1c602_3", + "prompt_toolkit 1.0.15 py27_0", + "dask 0.19.1 py27_0", + "pyodbc 4.0.24 py27he6710b0_0", + "pyzmq 17.1.2 py27h14c3975_0", + "ruamel_yaml 0.15.46 py27h14c3975_0", + "partd 0.3.8 py27_0", + "datashape 0.5.4 py27_1", + "greenlet 0.4.15 py27h7b6447c_0", + "more-itertools 4.3.0 py27_0", + "libtiff 4.0.9 he85c1e1_2", + "incremental 17.5.0 py27_0", + "lazy-object-proxy 1.3.1 py27h14c3975_2", + "mpc 1.1.0 h10f8cd9_1", + "ipython_genutils 0.2.0 py27_0", + "scipy 1.1.0 py27hfa4b5c9_1", + "sortedcontainers 2.0.5 py27_0", + "nose 1.3.7 py27_2", + "locket 0.2.0 py27_1", + "imageio 2.4.1 py27_0", + "ca-certificates 2018.03.07 0", + "pytz 2018.5 py27_0", + "twisted 18.7.0 py27h14c3975_1", + "zope 1.0 py27_1", + "jsonschema 2.6.0 py27_0", + "pywavelets 1.0.0 py27hdd07704_0", + "odo 0.5.1 py27_0", + "pycodestyle 2.4.0 py27_0", + "gmp 6.1.2 h6c8ec71_1", + "notebook 5.6.0 py27_0", + "futures 3.2.0 py27_0", + "sphinxcontrib-websupport 1.1.0 py27_1", + "toolz 0.9.0 py27_0", + "pkginfo 1.4.2 py27_1", + "traceback2 1.4.0 py27_0", + "pcre 8.42 h439df22_0", + "numba 0.39.0 py27h04863e7_0", + "libssh2 1.8.0 h9cfc8f7_4", + "bleach 2.1.4 py27_0", + "typing 3.6.6 py27_0", + "markupsafe 1.0 py27h14c3975_1", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "icu 58.2 h9c2bf20_1", + "cloudpickle 0.5.5 py27_0", + "cycler 0.10.0 py27_0", + "nltk 3.3.0 py27_0", + "testpath 0.3.1 py27_0", + "idna 2.7 py27_0", + "unittest2 1.1.0 py27_0", + "glob2 0.6 py27_0", + "pytables 3.4.4 py27ha205bf6_0", + "networkx 2.1 py27_0", + "singledispatch 3.4.0.3 py27_0", + "patsy 0.5.0 py27_0", + "pyyaml 3.13 py27h14c3975_0", + "simplegeneric 0.8.1 py27_2", + "scandir 1.9.0 py27h14c3975_0", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "unicodecsv 0.14.1 py27_0", + "libffi 3.2.1 hd88cf55_4", + "libgcc-ng 8.2.0 hdf63c60_1", + "jbig 2.1 hdba287a_0", + "jupyter_client 5.2.3 py27_0", + "astroid 1.6.5 py27_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "parso 0.3.1 py27_0", + "pandocfilters 1.4.2 py27_1", + "terminado 0.8.1 py27_1", + "entrypoints 0.2.3 py27_2", + "widgetsnbextension 3.4.1 py27_0", + "libxslt 1.1.32 h1312cb7_0", + "pyasn1 0.4.4 py27h28b3542_0", + "graphite2 1.3.12 h23475e2_2", + "python 2.7.15 h1571d57_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "colorama 0.3.9 py27_0", + "libpng 1.6.34 hb9fc6fc_0", + "constantly 15.1.0 py27h28b3542_0", + "wheel 0.31.1 py27_0", + "matplotlib 2.2.3 py27hb69df0a_0", + "jpeg 9b h024ee3a_2", + "ncurses 6.1 hf484d3e_0", + "itsdangerous 0.24 py27_1", + "linecache2 1.0.0 py27_0", + "multipledispatch 0.6.0 py27_0", + "sip 4.19.8 py27hf484d3e_0", + "ipython 5.8.0 py27_0", + "defusedxml 0.5.0 py27_1", + "cython 0.28.5 py27hf484d3e_0", + "tornado 5.1 py27h14c3975_0", + "pango 1.42.4 h049681c_0", + "cryptography 2.3.1 py27hc365091_0", + "sqlalchemy 1.2.11 py27h7b6447c_0", + "service_identity 17.0.0 py27h28b3542_0", + "python-dateutil 2.7.3 py27_0", + "sympy 1.2 py27_0", + "requests 2.19.1 py27_0", + "libcurl 7.61.0 h1ad7b7a_0", + "grin 1.2.1 py27_4", + "pylint 1.9.2 py27_0", + "decorator 4.3.0 py27_0", + "xz 5.2.4 h14c3975_4", + "qtconsole 4.4.1 py27_0", + "gmpy2 2.0.8 py27h10f8cd9_2", + "ipaddress 1.0.22 py27_0", + "py 1.6.0 py27_0", + "imagesize 1.1.0 py27_0", + "pluggy 0.7.1 py27h28b3542_0", + "pandas 0.23.4 py27h04863e7_0", + "cffi 1.11.5 py27he75722e_1", + "harfbuzz 1.8.8 hffaf4a1_0", + "pixman 0.34.0 hceecf20_3", + "html5lib 1.0.1 py27_0", + "kiwisolver 1.0.1 py27hf484d3e_0", + "pickleshare 0.7.4 py27_0", + "glib 2.56.2 hd408876_0", + "dbus 1.13.2 h714fa37_1", + "jinja2 2.10 py27_0", + "prometheus_client 0.3.1 py27h28b3542_0", + "jupyter_core 4.4.0 py27_0", + "backports_abc 0.5 py27_0", + "pip 10.0.1 py27_0", + "ipykernel 4.9.0 py27_1", + "jdcal 1.4 py27_0", + "blosc 1.14.4 hdbcaa40_0", + "asn1crypto 0.24.0 py27_0", + "click 6.7 py27_0", + "dask-core 0.19.1 py27_0", + "packaging 17.1 py27_0", + "pycosat 0.6.3 py27h14c3975_0", + "appdirs 1.4.3 py27h28b3542_0", + "curl 7.61.0 h84994c4_0", + "snowballstemmer 1.2.1 py27_0", + "setuptools 40.2.0 py27_0", + "readline 7.0 h7b6447c_5", + "automat 0.7.0 py27_0", + "spyder-kernels 0.2.6 py27_0", + "ipywidgets 7.4.1 py27_0", + "lxml 4.2.5 py27hefd8a0e_0", + "pyopenssl 18.0.0 py27_0", + "seaborn 0.9.0 py27_0", + "jupyter_console 5.2.0 py27_1", + "rope 0.11.0 py27_0", + "olefile 0.46 py27_0", + "numpydoc 0.8.0 py27_0", + "pyparsing 2.2.0 py27_1", + "ptyprocess 0.6.0 py27_0", + "nbformat 4.4.0 py27_0", + "cytoolz 0.9.0.1 py27h14c3975_1", + "webencodings 0.5.1 py27_1", + "libsodium 1.0.16 h1bed415_0", + "functools32 3.2.3.2 py27_1", + "statsmodels 0.9.0 py27h035aef0_0", + "flask 1.0.2 py27_1", + "docutils 0.14 py27_0", + "llvmlite 0.24.0 py27hdbcaa40_0", + "attrs 18.2.0 py27h28b3542_0", + "pygments 2.2.0 py27_0", + "mccabe 0.6.1 py27_1", + "backports.shutil_get_terminal_size 1.0.0 py27_2", + "six 1.11.0 py27_1", + "pytest 3.8.0 py27_0", + "blaze 0.11.3 py27_0", + "et_xmlfile 1.0.1 py27_0", + "spyder 3.3.1 py27_1", + "fastcache 1.0.2 py27h14c3975_2", + "unixodbc 2.3.7 h14c3975_0", + "numexpr 2.6.8 py27hd89afb7_0", + "ply 3.11 py27_0", + "numpy-base 1.15.1 py27h81de0dd_0", + "wrapt 1.10.11 py27h14c3975_2", + "tblib 1.3.2 py27_0", + "freetype 2.9.1 h8a8886c_1", + "qt 5.9.6 h8703b6f_2", + "cairo 1.14.12 h8948797_3", + "pep8 1.7.1 py27_0", + "certifi 2018.8.24 py27_1", + "psutil 5.4.7 py27h14c3975_0", + "heapdict 1.0.0 py27_2", + "mpmath 1.0.0 py27_2", + "ssl_match_hostname 3.5.0.1 py27_2", + "boto 2.49.0 py27_0", + "mistune 0.8.3 py27h14c3975_1", + "babel 2.6.0 py27_0", + "mkl_fft 1.0.4 py27h4414c95_1", + "anaconda-client 1.7.2 py27_0", + "urllib3 1.23 py27_0", + "zlib 1.2.11 ha838bed_2", + "xlrd 1.1.0 py27_1", + "sqlite 3.24.0 h84994c4_0", + "bottleneck 1.2.1 py27h035aef0_1", + "zope.interface 4.5.0 py27h14c3975_0", + "expat 2.2.6 he6710b0_0", + "pysocks 1.6.8 py27_0", + "bokeh 0.13.0 py27_0", + "fribidi 1.0.5 h7b6447c_0", + "pathlib2 2.3.2 py27_0", + "jupyterlab 0.33.11 py27_0", + "enum34 1.1.6 py27_1", + "cdecimal 2.3 py27h14c3975_3", + "configparser 3.5.0 py27_0", + "patchelf 0.9 hf484d3e_2", + "sortedcollections 1.0.1 py27_0", + "nbconvert 5.4.0 py27_1", + "anaconda-project 0.8.2 py27_0", + "libtool 2.4.6 h544aabb_3", + "werkzeug 0.14.1 py27_0", + "fontconfig 2.13.0 h9420a91_0", + "scikit-learn 0.19.2 py27h4989274_0", + "pycparser 2.18 py27_1", + "pycairo 1.17.1 py27h2a1e443_0", + "tk 8.6.8 hbc83047_0", + "jedi 0.12.1 py27_0", + "send2trash 1.5.0 py27_0", + "backports 1.0 py27_1", + "pycrypto 2.6.1 py27h14c3975_9", + "pyqt 5.9.2 py27h05f1152_2", + "qtpy 1.5.0 py27_0", + "libxcb 1.13 h1bed415_1", + "distributed 1.23.1 py27_0", + "pyasn1-modules 0.2.2 py27_0", + "libxml2 2.9.8 h26e45fe_1", + "mkl_random 1.0.1 py27h4414c95_1", + "hdf5 1.10.2 hba1933b_1", + "tqdm 4.26.0 py27h28b3542_0", + "path.py 11.1.0 py27_0", + "jupyterlab_launcher 0.11.2 py27h28b3542_0", + "libuuid 1.0.3 h1bed415_2", + "mkl-service 1.1.2 py27h90e4bf4_5", + "wcwidth 0.1.7 py27_0", + "traitlets 4.3.2 py27_0", + "zict 0.1.3 py27_0", + "zeromq 4.2.5 hf484d3e_1", + "openpyxl 2.5.6 py27_0", + "sphinxcontrib 1.0 py27_1", + "blas 1.0 mkl", + "pillow 5.2.0 py27heded4f4_0", + "gevent 1.3.6 py27h7b6447c_0" + ], + "license": "BSD", + "md5": "bcb397d4cfcbb64b866282a5cb7665e5", + "name": "anaconda", + "namespace": "python", + "sha256": "2a7ed5ace5a45311411ddd1a3e92fc610dd67c4769a838af5cb8cf45e0c4556a", + "size": 10727, + "subdir": "linux-64", + "timestamp": 1541667463333, + "version": "5.3.1" + }, + "anaconda-5.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "intel-openmp 2019.0 118", + "libcurl 7.61.0 h1ad7b7a_0", + "nbconvert 5.4.0 py37_1", + "ncurses 6.1 hf484d3e_0", + "prometheus_client 0.3.1 py37h28b3542_0", + "libtool 2.4.6 h544aabb_3", + "numba 0.39.0 py37h04863e7_0", + "pip 10.0.1 py37_0", + "pyasn1-modules 0.2.2 py37_0", + "astropy 3.0.4 py37h14c3975_0", + "traitlets 4.3.2 py37_0", + "ipython_genutils 0.2.0 py37_0", + "backports 1.0 py37_1", + "colorama 0.3.9 py37_0", + "pygments 2.2.0 py37_0", + "parso 0.3.1 py37_0", + "tk 8.6.8 hbc83047_0", + "pytest-arraydiff 0.2 py37h39e3cac_0", + "jinja2 2.10 py37_0", + "jpeg 9b h024ee3a_2", + "click 6.7 py37_0", + "ca-certificates 2018.03.07 0", + "bitarray 0.8.3 py37h14c3975_0", + "libtiff 4.0.9 he85c1e1_2", + "markupsafe 1.0 py37h14c3975_1", + "simplegeneric 0.8.1 py37_2", + "backcall 0.1.0 py37_0", + "pyodbc 4.0.24 py37he6710b0_0", + "jupyterlab 0.34.9 py37_0", + "path.py 11.1.0 py37_0", + "unicodecsv 0.14.1 py37_0", + "mkl-service 1.1.2 py37h90e4bf4_5", + "alabaster 0.7.11 py37_0", + "olefile 0.46 py37_0", + "chardet 3.0.4 py37_1", + "patsy 0.5.0 py37_0", + "pandocfilters 1.4.2 py37_1", + "entrypoints 0.2.3 py37_2", + "pycparser 2.18 py37_1", + "itsdangerous 0.24 py37_1", + "zlib 1.2.11 ha838bed_2", + "pyopenssl 18.0.0 py37_0", + "secretstorage 3.1.0 py37_0", + "mpmath 1.0.0 py37_2", + "hdf5 1.10.2 hba1933b_1", + "pango 1.42.4 h049681c_0", + "libgcc-ng 8.2.0 hdf63c60_1", + "llvmlite 0.24.0 py37hdbcaa40_0", + "pytest-openfiles 0.3.0 py37_0", + "webencodings 0.5.1 py37_1", + "graphite2 1.3.12 h23475e2_2", + "docutils 0.14 py37_0", + "dask 0.19.1 py37_0", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "get_terminal_size 1.0.0 haa9412d_0", + "pytest 3.8.0 py37_0", + "openpyxl 2.5.6 py37_0", + "jbig 2.1 hdba287a_0", + "fontconfig 2.13.0 h9420a91_0", + "zict 0.1.3 py37_0", + "clyent 1.2.2 py37_1", + "jedi 0.12.1 py37_0", + "xz 5.2.4 h14c3975_4", + "notebook 5.6.0 py37_0", + "snappy 1.1.7 hbae5bb6_3", + "heapdict 1.0.0 py37_2", + "msgpack-python 0.5.6 py37h6bb024c_1", + "bottleneck 1.2.1 py37h035aef0_1", + "six 1.11.0 py37_1", + "h5py 2.8.0 py37h989c5e5_3", + "blas 1.0 mkl", + "pixman 0.34.0 hceecf20_3", + "requests 2.19.1 py37_0", + "sphinxcontrib-websupport 1.1.0 py37_1", + "ipywidgets 7.4.1 py37_0", + "tblib 1.3.2 py37_0", + "anaconda-project 0.8.2 py37_0", + "mkl_fft 1.0.4 py37h4414c95_1", + "packaging 17.1 py37_0", + "glib 2.56.2 hd408876_0", + "fastcache 1.0.2 py37h14c3975_2", + "curl 7.61.0 h84994c4_0", + "pexpect 4.6.0 py37_0", + "zeromq 4.2.5 hf484d3e_1", + "ipykernel 4.9.0 py37_1", + "libxml2 2.9.8 h26e45fe_1", + "sympy 1.2 py37_0", + "certifi 2018.8.24 py37_1", + "cycler 0.10.0 py37_0", + "asn1crypto 0.24.0 py37_0", + "icu 58.2 h9c2bf20_1", + "spyder-kernels 0.2.6 py37_0", + "terminado 0.8.1 py37_1", + "nbformat 4.4.0 py37_0", + "python 3.7.0 hc3d631a_0", + "qtawesome 0.4.4 py37_0", + "gevent 1.3.6 py37h7b6447c_0", + "mccabe 0.6.1 py37_1", + "widgetsnbextension 3.4.1 py37_0", + "fribidi 1.0.5 h7b6447c_0", + "kiwisolver 1.0.1 py37hf484d3e_0", + "patchelf 0.9 hf484d3e_2", + "pycurl 7.43.0.2 py37hb7f436b_0", + "libedit 3.1.20170329 h6b74fdf_2", + "pywavelets 1.0.0 py37hdd07704_0", + "send2trash 1.5.0 py37_0", + "greenlet 0.4.15 py37h7b6447c_0", + "numpy 1.15.1 py37h1d66e8a_0", + "jupyter_core 4.4.0 py37_0", + "pycrypto 2.6.1 py37h14c3975_9", + "bkcharts 0.2 py37_0", + "tornado 5.1 py37h14c3975_0", + "flask 1.0.2 py37_1", + "beautifulsoup4 4.6.3 py37_0", + "py 1.6.0 py37_0", + "pyzmq 17.1.2 py37h14c3975_0", + "pytest-astropy 0.4.0 py37_0", + "ipython 6.5.0 py37_0", + "distributed 1.23.1 py37_0", + "jupyterlab_launcher 0.13.1 py37_0", + "defusedxml 0.5.0 py37_1", + "singledispatch 3.4.0.3 py37_0", + "automat 0.7.0 py37_0", + "pytest-remotedata 0.3.0 py37_0", + "cloudpickle 0.5.5 py37_0", + "bleach 2.1.4 py37_0", + "yaml 0.1.7 had09818_2", + "libssh2 1.8.0 h9cfc8f7_4", + "attrs 18.2.0 py37h28b3542_0", + "xlrd 1.1.0 py37_1", + "statsmodels 0.9.0 py37h035aef0_0", + "dbus 1.13.2 h714fa37_1", + "networkx 2.1 py37_0", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "openssl 1.0.2p h14c3975_0", + "freetype 2.9.1 h8a8886c_1", + "pyflakes 2.0.0 py37_0", + "wheel 0.31.1 py37_0", + "filelock 3.0.8 py37_0", + "matplotlib 2.2.3 py37hb69df0a_0", + "tqdm 4.26.0 py37h28b3542_0", + "prompt_toolkit 1.0.15 py37_0", + "libffi 3.2.1 hd88cf55_4", + "pytz 2018.5 py37_0", + "html5lib 1.0.1 py37_0", + "nltk 3.3.0 py37_0", + "cytoolz 0.9.0.1 py37h14c3975_1", + "ply 3.11 py37_0", + "setuptools 40.2.0 py37_0", + "pytables 3.4.4 py37ha205bf6_0", + "pep8 1.7.1 py37_0", + "sphinxcontrib 1.0 py37_1", + "jdcal 1.4 py37_0", + "libpng 1.6.34 hb9fc6fc_0", + "pkginfo 1.4.2 py37_1", + "zope 1.0 py37_1", + "lxml 4.2.5 py37hefd8a0e_0", + "sphinx 1.7.9 py37_0", + "numpy-base 1.15.1 py37h81de0dd_0", + "scikit-learn 0.19.2 py37h4989274_0", + "jeepney 0.3.1 py37_0", + "cython 0.28.5 py37hf484d3e_0", + "numpydoc 0.8.0 py37_0", + "libxcb 1.13 h1bed415_1", + "ptyprocess 0.6.0 py37_0", + "wcwidth 0.1.7 py37_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "urllib3 1.23 py37_0", + "lazy-object-proxy 1.3.1 py37h14c3975_2", + "libuuid 1.0.3 h1bed415_2", + "sip 4.19.8 py37hf484d3e_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "astroid 2.0.4 py37_0", + "sqlalchemy 1.2.11 py37h7b6447c_0", + "qtconsole 4.4.1 py37_0", + "zope.interface 4.5.0 py37h14c3975_0", + "pyparsing 2.2.0 py37_1", + "unixodbc 2.3.7 h14c3975_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "jupyter_console 5.2.0 py37_1", + "sortedcollections 1.0.1 py37_0", + "pickleshare 0.7.4 py37_0", + "pycodestyle 2.4.0 py37_0", + "psutil 5.4.7 py37h14c3975_0", + "gmpy2 2.0.8 py37h10f8cd9_2", + "numexpr 2.6.8 py37hd89afb7_0", + "service_identity 17.0.0 py37h28b3542_0", + "nose 1.3.7 py37_2", + "wrapt 1.10.11 py37h14c3975_2", + "pillow 5.2.0 py37heded4f4_0", + "cffi 1.11.5 py37he75722e_1", + "werkzeug 0.14.1 py37_0", + "jupyter 1.0.0 py37_7", + "scipy 1.1.0 py37hfa4b5c9_1", + "scikit-image 0.14.0 py37hf484d3e_1", + "sortedcontainers 2.0.5 py37_0", + "flask-cors 3.0.6 py37_0", + "locket 0.2.0 py37_1", + "pyasn1 0.4.4 py37h28b3542_0", + "gmp 6.1.2 h6c8ec71_1", + "partd 0.3.8 py37_0", + "libsodium 1.0.16 h1bed415_0", + "gstreamer 1.14.0 hb453b48_1", + "twisted 18.7.0 py37h14c3975_1", + "pcre 8.42 h439df22_0", + "hyperlink 18.0.0 py37_0", + "qtpy 1.5.0 py37_0", + "pytest-doctestplus 0.1.3 py37_0", + "imageio 2.4.1 py37_0", + "qt 5.9.6 h8703b6f_2", + "xlsxwriter 1.1.0 py37_0", + "snowballstemmer 1.2.1 py37_0", + "pathlib2 2.3.2 py37_0", + "more-itertools 4.3.0 py37_0", + "atomicwrites 1.2.1 py37_0", + "blaze 0.11.3 py37_0", + "mpfr 4.0.1 hdf1c602_3", + "xlwt 1.3.0 py37_0", + "jsonschema 2.6.0 py37_0", + "constantly 15.1.0 py37h28b3542_0", + "mkl_random 1.0.1 py37h4414c95_1", + "spyder 3.3.1 py37_1", + "decorator 4.3.0 py37_0", + "anaconda-client 1.7.2 py37_0", + "pysocks 1.6.8 py37_0", + "pyqt 5.9.2 py37h05f1152_2", + "et_xmlfile 1.0.1 py37_0", + "pandas 0.23.4 py37h04863e7_0", + "sqlite 3.24.0 h84994c4_0", + "toolz 0.9.0 py37_0", + "babel 2.6.0 py37_0", + "mistune 0.8.3 py37h14c3975_1", + "harfbuzz 1.8.8 hffaf4a1_0", + "imagesize 1.1.0 py37_0", + "bzip2 1.0.6 h14c3975_5", + "readline 7.0 h7b6447c_5", + "idna 2.7 py37_0", + "odo 0.5.1 py37_0", + "multipledispatch 0.6.0 py37_0", + "python-dateutil 2.7.3 py37_0", + "rope 0.11.0 py37_0", + "cryptography 2.3.1 py37hc365091_0", + "glob2 0.6 py37_0", + "jupyter_client 5.2.3 py37_0", + "blosc 1.14.4 hdbcaa40_0", + "incremental 17.5.0 py37_0", + "ruamel_yaml 0.15.46 py37h14c3975_0", + "pylint 2.1.1 py37_0", + "dask-core 0.19.1 py37_0", + "datashape 0.5.4 py37_1", + "mpc 1.1.0 h10f8cd9_1", + "pycosat 0.6.3 py37h14c3975_0", + "contextlib2 0.5.5 py37_0", + "bokeh 0.13.0 py37_0", + "boto 2.49.0 py37_0", + "keyring 13.2.1 py37_0", + "seaborn 0.9.0 py37_0", + "expat 2.2.6 he6710b0_0", + "libxslt 1.1.32 h1312cb7_0", + "isort 4.3.4 py37_0", + "testpath 0.3.1 py37_0", + "appdirs 1.4.3 py37h28b3542_0", + "pyyaml 3.13 py37h14c3975_0", + "cairo 1.14.12 h8948797_3", + "pluggy 0.7.1 py37h28b3542_0", + "lzo 2.10 h49e0be7_2", + "mkl 2018.0.3 1" + ], + "license": "BSD", + "md5": "8a9fae2cc865a015a9449359ba67831c", + "name": "anaconda", + "namespace": "python", + "sha256": "f8686daf6a32c44a194fb807c273efecc20e6e8e84addcbb071715baabf6d94f", + "size": 10493, + "subdir": "linux-64", + "timestamp": 1541668089358, + "version": "5.3.1" + }, + "anaconda-5.3.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "intel-openmp 2019.0 118", + "libcurl 7.61.0 h1ad7b7a_0", + "nbconvert 5.4.0 py37_1", + "ncurses 6.1 hf484d3e_0", + "prometheus_client 0.3.1 py37h28b3542_0", + "libtool 2.4.6 h544aabb_3", + "numba 0.39.0 py37h04863e7_0", + "pip 10.0.1 py37_0", + "pyasn1-modules 0.2.2 py37_0", + "astropy 3.0.4 py37h14c3975_0", + "traitlets 4.3.2 py37_0", + "ipython_genutils 0.2.0 py37_0", + "backports 1.0 py37_1", + "colorama 0.3.9 py37_0", + "pygments 2.2.0 py37_0", + "parso 0.3.1 py37_0", + "tk 8.6.8 hbc83047_0", + "pytest-arraydiff 0.2 py37h39e3cac_0", + "jinja2 2.10 py37_0", + "jpeg 9b h024ee3a_2", + "click 6.7 py37_0", + "ca-certificates 2018.03.07 0", + "bitarray 0.8.3 py37h14c3975_0", + "libtiff 4.0.9 he85c1e1_2", + "markupsafe 1.0 py37h14c3975_1", + "simplegeneric 0.8.1 py37_2", + "backcall 0.1.0 py37_0", + "pyodbc 4.0.24 py37he6710b0_0", + "jupyterlab 0.34.9 py37_0", + "path.py 11.1.0 py37_0", + "mkl 2018.0.3 1", + "unicodecsv 0.14.1 py37_0", + "mkl-service 1.1.2 py37h90e4bf4_5", + "alabaster 0.7.11 py37_0", + "olefile 0.46 py37_0", + "chardet 3.0.4 py37_1", + "patsy 0.5.0 py37_0", + "pandocfilters 1.4.2 py37_1", + "entrypoints 0.2.3 py37_2", + "pycparser 2.18 py37_1", + "itsdangerous 0.24 py37_1", + "zlib 1.2.11 ha838bed_2", + "pyopenssl 18.0.0 py37_0", + "secretstorage 3.1.0 py37_0", + "mpmath 1.0.0 py37_2", + "hdf5 1.10.2 hba1933b_1", + "pango 1.42.4 h049681c_0", + "libgcc-ng 8.2.0 hdf63c60_1", + "llvmlite 0.24.0 py37hdbcaa40_0", + "pytest-openfiles 0.3.0 py37_0", + "webencodings 0.5.1 py37_1", + "graphite2 1.3.12 h23475e2_2", + "docutils 0.14 py37_0", + "dask 0.19.1 py37_0", + "backports.shutil_get_terminal_size 1.0.0 py37_2", + "get_terminal_size 1.0.0 haa9412d_0", + "pytest 3.8.0 py37_0", + "openpyxl 2.5.6 py37_0", + "jbig 2.1 hdba287a_0", + "fontconfig 2.13.0 h9420a91_0", + "zict 0.1.3 py37_0", + "clyent 1.2.2 py37_1", + "jedi 0.12.1 py37_0", + "xz 5.2.4 h14c3975_4", + "notebook 5.6.0 py37_0", + "snappy 1.1.7 hbae5bb6_3", + "heapdict 1.0.0 py37_2", + "msgpack-python 0.5.6 py37h6bb024c_1", + "bottleneck 1.2.1 py37h035aef0_1", + "six 1.11.0 py37_1", + "h5py 2.8.0 py37h989c5e5_3", + "blas 1.0 mkl", + "pixman 0.34.0 hceecf20_3", + "requests 2.19.1 py37_0", + "sphinxcontrib-websupport 1.1.0 py37_1", + "ipywidgets 7.4.1 py37_0", + "tblib 1.3.2 py37_0", + "anaconda-project 0.8.2 py37_0", + "mkl_fft 1.0.4 py37h4414c95_1", + "packaging 17.1 py37_0", + "glib 2.56.2 hd408876_0", + "fastcache 1.0.2 py37h14c3975_2", + "curl 7.61.0 h84994c4_0", + "pexpect 4.6.0 py37_0", + "zeromq 4.2.5 hf484d3e_1", + "ipykernel 4.9.0 py37_1", + "libxml2 2.9.8 h26e45fe_1", + "sympy 1.2 py37_0", + "certifi 2018.8.24 py37_1", + "cycler 0.10.0 py37_0", + "asn1crypto 0.24.0 py37_0", + "icu 58.2 h9c2bf20_1", + "spyder-kernels 0.2.6 py37_0", + "terminado 0.8.1 py37_1", + "nbformat 4.4.0 py37_0", + "python 3.7.0 hc3d631a_0", + "qtawesome 0.4.4 py37_0", + "gevent 1.3.6 py37h7b6447c_0", + "mccabe 0.6.1 py37_1", + "widgetsnbextension 3.4.1 py37_0", + "fribidi 1.0.5 h7b6447c_0", + "kiwisolver 1.0.1 py37hf484d3e_0", + "patchelf 0.9 hf484d3e_2", + "pycurl 7.43.0.2 py37hb7f436b_0", + "libedit 3.1.20170329 h6b74fdf_2", + "pywavelets 1.0.0 py37hdd07704_0", + "send2trash 1.5.0 py37_0", + "greenlet 0.4.15 py37h7b6447c_0", + "numpy 1.15.1 py37h3b04361_0", + "jupyter_core 4.4.0 py37_0", + "pycrypto 2.6.1 py37h14c3975_9", + "bkcharts 0.2 py37_0", + "tornado 5.1 py37h14c3975_0", + "flask 1.0.2 py37_1", + "beautifulsoup4 4.6.3 py37_0", + "py 1.6.0 py37_0", + "pyzmq 17.1.2 py37h14c3975_0", + "pytest-astropy 0.4.0 py37_0", + "ipython 6.5.0 py37_0", + "distributed 1.23.1 py37_0", + "jupyterlab_launcher 0.13.1 py37_0", + "defusedxml 0.5.0 py37_1", + "singledispatch 3.4.0.3 py37_0", + "automat 0.7.0 py37_0", + "pytest-remotedata 0.3.0 py37_0", + "cloudpickle 0.5.5 py37_0", + "bleach 2.1.4 py37_0", + "yaml 0.1.7 had09818_2", + "libssh2 1.8.0 h9cfc8f7_4", + "attrs 18.2.0 py37h28b3542_0", + "xlrd 1.1.0 py37_1", + "statsmodels 0.9.0 py37h035aef0_0", + "dbus 1.13.2 h714fa37_1", + "networkx 2.1 py37_0", + "libstdcxx-ng 8.2.0 hdf63c60_1", + "openssl 1.0.2p h14c3975_0", + "freetype 2.9.1 h8a8886c_1", + "pyflakes 2.0.0 py37_0", + "wheel 0.31.1 py37_0", + "filelock 3.0.8 py37_0", + "matplotlib 2.2.3 py37hb69df0a_0", + "tqdm 4.26.0 py37h28b3542_0", + "prompt_toolkit 1.0.15 py37_0", + "libffi 3.2.1 hd88cf55_4", + "pytz 2018.5 py37_0", + "html5lib 1.0.1 py37_0", + "nltk 3.3.0 py37_0", + "cytoolz 0.9.0.1 py37h14c3975_1", + "ply 3.11 py37_0", + "setuptools 40.2.0 py37_0", + "pytables 3.4.4 py37ha205bf6_0", + "pep8 1.7.1 py37_0", + "sphinxcontrib 1.0 py37_1", + "jdcal 1.4 py37_0", + "libpng 1.6.34 hb9fc6fc_0", + "pkginfo 1.4.2 py37_1", + "zope 1.0 py37_1", + "lxml 4.2.5 py37hefd8a0e_0", + "sphinx 1.7.9 py37_0", + "numpy-base 1.15.1 py37h81de0dd_0", + "scikit-learn 0.19.2 py37h4989274_0", + "jeepney 0.3.1 py37_0", + "cython 0.28.5 py37hf484d3e_0", + "numpydoc 0.8.0 py37_0", + "libxcb 1.13 h1bed415_1", + "ptyprocess 0.6.0 py37_0", + "wcwidth 0.1.7 py37_0", + "libgfortran-ng 7.3.0 hdf63c60_0", + "urllib3 1.23 py37_0", + "lazy-object-proxy 1.3.1 py37h14c3975_2", + "libuuid 1.0.3 h1bed415_2", + "sip 4.19.8 py37hf484d3e_0", + "gst-plugins-base 1.14.0 hbbd80ab_1", + "astroid 2.0.4 py37_0", + "sqlalchemy 1.2.11 py37h7b6447c_0", + "qtconsole 4.4.1 py37_0", + "zope.interface 4.5.0 py37h14c3975_0", + "pyparsing 2.2.0 py37_1", + "unixodbc 2.3.7 h14c3975_0", + "pandoc 1.19.2.1 hea2e7c5_1", + "jupyter_console 5.2.0 py37_1", + "sortedcollections 1.0.1 py37_0", + "pickleshare 0.7.4 py37_0", + "pycodestyle 2.4.0 py37_0", + "psutil 5.4.7 py37h14c3975_0", + "gmpy2 2.0.8 py37h10f8cd9_2", + "numexpr 2.6.8 py37hd89afb7_0", + "service_identity 17.0.0 py37h28b3542_0", + "nose 1.3.7 py37_2", + "wrapt 1.10.11 py37h14c3975_2", + "pillow 5.2.0 py37heded4f4_0", + "cffi 1.11.5 py37he75722e_1", + "werkzeug 0.14.1 py37_0", + "jupyter 1.0.0 py37_7", + "scipy 1.1.0 py37hfa4b5c9_1", + "scikit-image 0.14.0 py37hf484d3e_1", + "sortedcontainers 2.0.5 py37_0", + "flask-cors 3.0.6 py37_0", + "locket 0.2.0 py37_1", + "pyasn1 0.4.4 py37h28b3542_0", + "gmp 6.1.2 h6c8ec71_1", + "partd 0.3.8 py37_0", + "libsodium 1.0.16 h1bed415_0", + "gstreamer 1.14.0 hb453b48_1", + "twisted 18.7.0 py37h14c3975_1", + "pcre 8.42 h439df22_0", + "hyperlink 18.0.0 py37_0", + "qtpy 1.5.0 py37_0", + "pytest-doctestplus 0.1.3 py37_0", + "imageio 2.4.1 py37_0", + "qt 5.9.6 h8703b6f_2", + "xlsxwriter 1.1.0 py37_0", + "snowballstemmer 1.2.1 py37_0", + "pathlib2 2.3.2 py37_0", + "more-itertools 4.3.0 py37_0", + "atomicwrites 1.2.1 py37_0", + "blaze 0.11.3 py37_0", + "mpfr 4.0.1 hdf1c602_3", + "xlwt 1.3.0 py37_0", + "jsonschema 2.6.0 py37_0", + "constantly 15.1.0 py37h28b3542_0", + "mkl_random 1.0.1 py37h4414c95_1", + "spyder 3.3.1 py37_1", + "decorator 4.3.0 py37_0", + "anaconda-client 1.7.2 py37_0", + "pysocks 1.6.8 py37_0", + "pyqt 5.9.2 py37h05f1152_2", + "et_xmlfile 1.0.1 py37_0", + "pandas 0.23.4 py37h04863e7_0", + "sqlite 3.24.0 h84994c4_0", + "toolz 0.9.0 py37_0", + "babel 2.6.0 py37_0", + "mistune 0.8.3 py37h14c3975_1", + "harfbuzz 1.8.8 hffaf4a1_0", + "imagesize 1.1.0 py37_0", + "bzip2 1.0.6 h14c3975_5", + "readline 7.0 h7b6447c_5", + "idna 2.7 py37_0", + "odo 0.5.1 py37_0", + "multipledispatch 0.6.0 py37_0", + "python-dateutil 2.7.3 py37_0", + "rope 0.11.0 py37_0", + "cryptography 2.3.1 py37hc365091_0", + "glob2 0.6 py37_0", + "jupyter_client 5.2.3 py37_0", + "blosc 1.14.4 hdbcaa40_0", + "incremental 17.5.0 py37_0", + "ruamel_yaml 0.15.46 py37h14c3975_0", + "pylint 2.1.1 py37_0", + "dask-core 0.19.1 py37_0", + "datashape 0.5.4 py37_1", + "mpc 1.1.0 h10f8cd9_1", + "pycosat 0.6.3 py37h14c3975_0", + "contextlib2 0.5.5 py37_0", + "bokeh 0.13.0 py37_0", + "boto 2.49.0 py37_0", + "keyring 13.2.1 py37_0", + "seaborn 0.9.0 py37_0", + "expat 2.2.6 he6710b0_0", + "libxslt 1.1.32 h1312cb7_0", + "isort 4.3.4 py37_0", + "testpath 0.3.1 py37_0", + "appdirs 1.4.3 py37h28b3542_0", + "pyyaml 3.13 py37h14c3975_0", + "cairo 1.14.12 h8948797_3", + "pluggy 0.7.1 py37h28b3542_0", + "lzo 2.10 h49e0be7_2" + ], + "license": "BSD", + "md5": "4ffa02bc6d8c18400b60f53dc8b60494", + "name": "anaconda", + "namespace": "python", + "sha256": "7a9608f8d5c2b00d9be3d4f72c0cab8dffc35c1c1fe4a720ef21553f6a740609", + "size": 10489, + "subdir": "linux-64", + "timestamp": 1541668089358, + "version": "5.3.1" + }, + "anaconda-clean-1.1.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "805d9187b9ef7ad0e22f633674e64927", + "name": "anaconda-clean", + "sha256": "31aa1268abadc2b974d014d1be536af61f7eaa5ef7ca22eaa725f8649a1c2b46", + "size": 7350, + "subdir": "linux-64", + "timestamp": 1537209301049, + "version": "1.1.0" + }, + "anaconda-clean-1.1.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "0ea8945b5fd0fd2cf86624dd5405763c", + "name": "anaconda-clean", + "sha256": "4925a2cf1bad34eda114a5bccdf29e57127129b6526176eff8122fc36d4d93a5", + "size": 7831, + "subdir": "linux-64", + "timestamp": 1640788087918, + "version": "1.1.0" + }, + "anaconda-clean-1.1.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "bbab091a7e0b29f5fae79b188207c8ac", + "name": "anaconda-clean", + "sha256": "68c7c9a56f4d0cc34bd8c8185bfc9341f312af13d7d09e8537e63f18a3030a19", + "size": 7414, + "subdir": "linux-64", + "timestamp": 1537209332330, + "version": "1.1.0" + }, + "anaconda-clean-1.1.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "e39a49151c5197d631898a5e413ef9ce", + "name": "anaconda-clean", + "sha256": "c1c1072c5b39cfb512e5fc0cd2338d2af31c28ce0d6306969091f5cd56f3ad72", + "size": 7343, + "subdir": "linux-64", + "timestamp": 1537209320513, + "version": "1.1.0" + }, + "anaconda-clean-1.1.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "ec4161dea4477f29f60d91351532fcc2", + "name": "anaconda-clean", + "sha256": "d13ab40ae7f750a7f49da81aa72589a98e7e844d84d2e9088f8b5a1410eaeec2", + "size": 250123, + "subdir": "linux-64", + "timestamp": 1614067934327, + "version": "1.1.0" + }, + "anaconda-clean-1.1.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "9d8c937737a609b96a551a734ac15eaa", + "name": "anaconda-clean", + "sha256": "5567af58d15cf830a9cce51c5f4ecb95dc81c0a1196849ae87e5a57f1b8584ba", + "size": 7355, + "subdir": "linux-64", + "timestamp": 1537209278724, + "version": "1.1.0" + }, + "anaconda-clean-1.1.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "6294fbfba63095dee9c72b5849a1ce94", + "name": "anaconda-clean", + "sha256": "000951282de98a4305230a324cfbcabef3a03f04b1a85399cb54802c015059a0", + "size": 250146, + "subdir": "linux-64", + "timestamp": 1614068853208, + "version": "1.1.0" + }, + "anaconda-clean-1.1.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "b9777cca430f01fc8d090c4953158a90", + "name": "anaconda-clean", + "sha256": "669c0f0bce9e85d43a8ecac0de2dca2c93da34e3996b74a20d664687a6913e17", + "size": 7725, + "subdir": "linux-64", + "timestamp": 1572437622112, + "version": "1.1.0" + }, + "anaconda-clean-1.1.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "baff4c859a93d3fe3fdaff729b97aa92", + "name": "anaconda-clean", + "sha256": "d350fd4251c32b35ea5b46a36be7108ba3ac1a1d082156e709246ea7ca11f672", + "size": 249447, + "subdir": "linux-64", + "timestamp": 1614068776853, + "version": "1.1.0" + }, + "anaconda-clean-1.1.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "323d0f7055250bc4336f1fdf7a1dfe65", + "name": "anaconda-clean", + "sha256": "cde448b0462d833316ab97cd02deef7bc7eceb974442ce8829cee5f0a1d1abce", + "size": 8670, + "subdir": "linux-64", + "timestamp": 1652723762856, + "version": "1.1.1" + }, + "anaconda-clean-1.1.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "179d8114275481050f9b4773958490c3", + "name": "anaconda-clean", + "sha256": "dcde876e6c514bb24425e214fc31f34442edf17e6c9c2040f3c0707daeea855d", + "size": 9833, + "subdir": "linux-64", + "timestamp": 1676846710925, + "version": "1.1.1" + }, + "anaconda-clean-1.1.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "539a2fa88a3cd4f7d54ad6e66b26ae8e", + "name": "anaconda-clean", + "sha256": "660b4547b4de4b932037ac7956ce4b481626943d7945669072dc3d929028e966", + "size": 8643, + "subdir": "linux-64", + "timestamp": 1652723836933, + "version": "1.1.1" + }, + "anaconda-clean-1.1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5a1e02dfcf656c90ab8b0e43610fa01f", + "name": "anaconda-clean", + "sha256": "d1c0b2effe7c1858fa9451ac3c67cf71898b18796d0bae7aabed0f2aa6a0a718", + "size": 8653, + "subdir": "linux-64", + "timestamp": 1652723813231, + "version": "1.1.1" + }, + "anaconda-clean-1.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8228b4fb8cd90fc59c0f36b6d1921a52", + "name": "anaconda-clean", + "sha256": "44d8b1a21410c971ffb84c74a557acfc63aeab4803dd8b4106859d2d2c8096e6", + "size": 8621, + "subdir": "linux-64", + "timestamp": 1652723789616, + "version": "1.1.1" + }, + "anaconda-client-1.10.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "nbformat >=4.4.0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d29a78500b3bfa8d36c9e8738c4f3f6b", + "name": "anaconda-client", + "sha256": "e353cfc71cfbb51e4accd2c27f88d1a0f02a23645494ecba55256c21bb30a8da", + "size": 155051, + "subdir": "linux-64", + "timestamp": 1655307980993, + "version": "1.10.0" + }, + "anaconda-client-1.10.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "nbformat >=4.4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "349c77345497b8a5715882ea3903f7de", + "name": "anaconda-client", + "sha256": "c50db321a7f43f94ccbedda3821ee5a95985c1def425243ae089a0d185eed5ba", + "size": 152362, + "subdir": "linux-64", + "timestamp": 1655307898556, + "version": "1.10.0" + }, + "anaconda-client-1.10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "nbformat >=4.4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "579730818b384f502473ca111a4117d8", + "name": "anaconda-client", + "sha256": "82b67aaf34e513058481933094e8283fd173ad4dda9f7225f0debf2776d3736d", + "size": 153499, + "subdir": "linux-64", + "timestamp": 1655307933286, + "version": "1.10.0" + }, + "anaconda-client-1.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "nbformat >=4.4.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e2189822a48cd9c78d54670ca519e9cf", + "name": "anaconda-client", + "sha256": "cffbdc2fd4e3f61a54b54731a97f05954112225deb64e01a5257e9aaedae9e48", + "size": 153458, + "subdir": "linux-64", + "timestamp": 1655308016313, + "version": "1.10.0" + }, + "anaconda-client-1.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "nbformat >=4.4.0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.20.0", + "setuptools >=58.0.4", + "six >=1.15.0", + "tqdm >=4.56.0", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "48231f80d5bbeb4d84e5502c845b6f3b", + "name": "anaconda-client", + "sha256": "d9edf5d4a59db236a9da40dc0e71e66d5d596d6842f1952efcb51942b63f11f7", + "size": 154648, + "subdir": "linux-64", + "timestamp": 1662708425081, + "version": "1.11.0" + }, + "anaconda-client-1.11.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "nbformat >=4.4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.20.0", + "setuptools >=58.0.4", + "six >=1.15.0", + "tqdm >=4.56.0", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "403832a749ef3d57a2c94b7643b3d17b", + "name": "anaconda-client", + "sha256": "efa242ca917561bc67aae9e516396da3441e5e0eb26eeb77ff233fde272bf777", + "size": 151933, + "subdir": "linux-64", + "timestamp": 1662708376827, + "version": "1.11.0" + }, + "anaconda-client-1.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "nbformat >=4.4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.20.0", + "setuptools >=58.0.4", + "six >=1.15.0", + "tqdm >=4.56.0", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "798ebc3bac6157dc76eba2c6bc6f22e1", + "name": "anaconda-client", + "sha256": "98d87d6f10dbb0b709c2bccbae2794f1d51ae355fe70008443636a242199e6c3", + "size": 152978, + "subdir": "linux-64", + "timestamp": 1662708341199, + "version": "1.11.0" + }, + "anaconda-client-1.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "nbformat >=4.4.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.20.0", + "setuptools >=58.0.4", + "six >=1.15.0", + "tqdm >=4.56.0", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f464a9a429c3e50eca3397e88e3059f", + "name": "anaconda-client", + "sha256": "95b7465c179b8194cfaf297c3aa91d6172cd13ce6a5124feda0bb45bb65193bf", + "size": 152982, + "subdir": "linux-64", + "timestamp": 1662708458561, + "version": "1.11.0" + }, + "anaconda-client-1.11.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "defusedxml >=0.7.1", + "nbformat >=4.4.0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.6.1", + "pytz >=2021.3", + "pyyaml >=3.12", + "requests >=2.20.0", + "setuptools >=58.0.4", + "six >=1.15.0", + "tqdm >=4.56.0", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dceab0577aee36a4925a0cdabeb0bc66", + "name": "anaconda-client", + "sha256": "85c962d1f8db6445b54d34b17b3f0704213565987b950ad4a49ac53f2dca90da", + "size": 140116, + "subdir": "linux-64", + "timestamp": 1678123178096, + "version": "1.11.1" + }, + "anaconda-client-1.11.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "defusedxml >=0.7.1", + "nbformat >=4.4.0", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.6.1", + "pytz >=2021.3", + "pyyaml >=3.12", + "requests >=2.20.0", + "setuptools >=58.0.4", + "six >=1.15.0", + "tqdm >=4.56.0", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3441f6acd35b524258489fb4cd0e58c7", + "name": "anaconda-client", + "sha256": "a26fa7c22735a08bb49c62d2c2a01815457a815a1fa54ea4dba73e39cb23e85d", + "size": 191614, + "subdir": "linux-64", + "timestamp": 1679523571141, + "version": "1.11.1" + }, + "anaconda-client-1.11.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "defusedxml >=0.7.1", + "nbformat >=4.4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz >=2021.3", + "pyyaml >=3.12", + "requests >=2.20.0", + "setuptools >=58.0.4", + "six >=1.15.0", + "tqdm >=4.56.0", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f29f9b553924542eaa375e8cf783bed9", + "name": "anaconda-client", + "sha256": "65c8c63b867bf2e993f3415e0f78b4fb9cf0b89e188a8643f382719eff9538fd", + "size": 138853, + "subdir": "linux-64", + "timestamp": 1678123216202, + "version": "1.11.1" + }, + "anaconda-client-1.11.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "conda-package-handling >=1.7.3", + "defusedxml >=0.7.1", + "nbformat >=4.4.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.6.1", + "pytz >=2021.3", + "pyyaml >=3.12", + "requests >=2.20.0", + "setuptools >=58.0.4", + "six >=1.15.0", + "tqdm >=4.56.0", + "urllib3 >=1.26.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b220f3b8f74ad13ddd3fbe6383a2856e", + "name": "anaconda-client", + "sha256": "61e852a31ed006064d854339397d0d13eaa8aa543463e75eacc9e25bd77547bd", + "size": 138814, + "subdir": "linux-64", + "timestamp": 1678123255009, + "version": "1.11.1" + }, + "anaconda-client-1.6.11-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a069c2b8b4a9d8632749cfbcdf2f0255", + "name": "anaconda-client", + "sha256": "5823a0562391df1e72737eaaaabc256e092f1b123613e357d1d6598fa56829b6", + "size": 142757, + "subdir": "linux-64", + "timestamp": 1519174369397, + "version": "1.6.11" + }, + "anaconda-client-1.6.11-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "634b8ca5f5947b3b12fa88ffe6839069", + "name": "anaconda-client", + "sha256": "c1a154d0725273b8b64984d21842834227b12dce6dea5bfa2927efa86f65c8a3", + "size": 145570, + "subdir": "linux-64", + "timestamp": 1519174392105, + "version": "1.6.11" + }, + "anaconda-client-1.6.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5d6e191a9bb605f5a7213e5f7404f040", + "name": "anaconda-client", + "sha256": "9e55e3ceb70309e96e6208cb4028cab6db809779e853e1501ebd4da6e0ef838e", + "size": 142385, + "subdir": "linux-64", + "timestamp": 1519174355108, + "version": "1.6.11" + }, + "anaconda-client-1.6.12-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "be9c2e1d8604ed64b6ab14490822673a", + "name": "anaconda-client", + "sha256": "3d4f13a1e45c71646eeba41e428d22b861f8d63afbd9adad514bc6173fce2d34", + "size": 144930, + "subdir": "linux-64", + "timestamp": 1520872536733, + "version": "1.6.12" + }, + "anaconda-client-1.6.12-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dafce13823e30008a9b5f2e1dd2c8069", + "name": "anaconda-client", + "sha256": "472c6cf1786574934cf53bdf73509939e2330f14998fd53b0a09c5bfa3977bd4", + "size": 146289, + "subdir": "linux-64", + "timestamp": 1520872582147, + "version": "1.6.12" + }, + "anaconda-client-1.6.12-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fc44e052a88cde38d9ae1b4207c5b5e3", + "name": "anaconda-client", + "sha256": "277b08e424c4145b610c5cffda068738369536b047ff647668a8d9e85ce5e317", + "size": 143116, + "subdir": "linux-64", + "timestamp": 1520872587736, + "version": "1.6.12" + }, + "anaconda-client-1.6.13-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4756628b5e7a7146d96b37e783324f8b", + "name": "anaconda-client", + "sha256": "c529d7cff10fed734ce7bd295913bc975c9f18d57181d39056d1df99a4fe9f02", + "size": 144605, + "subdir": "linux-64", + "timestamp": 1521477746752, + "version": "1.6.13" + }, + "anaconda-client-1.6.13-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "199929e44a6409c250f78ad8591620ba", + "name": "anaconda-client", + "sha256": "e3380176504849379af23f6fd0ba215ac1a801c4e3f80985a8285c8d574e4c8b", + "size": 147527, + "subdir": "linux-64", + "timestamp": 1521477804708, + "version": "1.6.13" + }, + "anaconda-client-1.6.13-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9975e376d03217ce4f8f51c43f00772d", + "name": "anaconda-client", + "sha256": "f80201b666f937beb5337c89edade373cbf66885bb2e9870ad33ef9020f15c39", + "size": 145793, + "subdir": "linux-64", + "timestamp": 1521477805036, + "version": "1.6.13" + }, + "anaconda-client-1.6.14-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6218f30b52aae22d0d5e93988c41afb6", + "name": "anaconda-client", + "sha256": "77b4200c78880638f9f03b2cf5af92a35f978cc6570c40d7d509287d11abe59d", + "size": 145956, + "subdir": "linux-64", + "timestamp": 1521488609449, + "version": "1.6.14" + }, + "anaconda-client-1.6.14-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ca07db6f04f29eba876d93b899d83572", + "name": "anaconda-client", + "sha256": "776e92f375ac7e7b50196ca2e301ed2ce1a52423cbfa045ea948cce053df784a", + "size": 145638, + "subdir": "linux-64", + "timestamp": 1521488582183, + "version": "1.6.14" + }, + "anaconda-client-1.6.14-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e7b19f9c5e9fa7d99fd7513c09370252", + "name": "anaconda-client", + "sha256": "7e8dd1bab1475c8219941ff496e1e41db227a8038a60dfd93fdf3a282f6605a2", + "size": 145787, + "subdir": "linux-64", + "timestamp": 1521488635150, + "version": "1.6.14" + }, + "anaconda-client-1.6.14-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "63d6484622c23e42d94899b353e38502", + "name": "anaconda-client", + "sha256": "b047376931f6a4f428b2304666127b271e928d3a3aa17d09b30e275da950e5c2", + "size": 148955, + "subdir": "linux-64", + "timestamp": 1530737372183, + "version": "1.6.14" + }, + "anaconda-client-1.6.5-py27hc8169bf_0.conda": { + "build": "py27hc8169bf_0", + "build_number": 0, + "depends": [ + "clyent", + "nbformat", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0efe3e21deda40ca631904222eac2a28", + "name": "anaconda-client", + "sha256": "e53b1122c0dbca3432fb3b93204c654d4a4e93c75ed6e54d9a87d86e7163a808", + "size": 143029, + "subdir": "linux-64", + "timestamp": 1505746003134, + "version": "1.6.5" + }, + "anaconda-client-1.6.5-py35hd900ed1_0.conda": { + "build": "py35hd900ed1_0", + "build_number": 0, + "depends": [ + "clyent", + "nbformat", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d0dbd3ac6e7199a99658fa86e539433b", + "name": "anaconda-client", + "sha256": "f055f4cc24cc33b147a525aebe516a0bc5ecb79c9c41c66b7fc427f630204be6", + "size": 143792, + "subdir": "linux-64", + "timestamp": 1505746027690, + "version": "1.6.5" + }, + "anaconda-client-1.6.5-py36h19c0dcd_0.conda": { + "build": "py36h19c0dcd_0", + "build_number": 0, + "depends": [ + "clyent", + "nbformat", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d3f7d0616afe054feab641707e8203c8", + "name": "anaconda-client", + "sha256": "07ade1c7fe3a2c52def62de30d911b608a9956d577fdfc321a869f94e02e700a", + "size": 142263, + "subdir": "linux-64", + "timestamp": 1505746050364, + "version": "1.6.5" + }, + "anaconda-client-1.6.6-py27heac1a27_0.conda": { + "build": "py27heac1a27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3cfb4b1aa2f0000d2774abf515669e91", + "name": "anaconda-client", + "sha256": "17b577cbfb9ba781ef228454f35c3621253768e8de3c1ad845493af1c75a951b", + "size": 145571, + "subdir": "linux-64", + "timestamp": 1512418729750, + "version": "1.6.6" + }, + "anaconda-client-1.6.6-py35h6b90917_0.conda": { + "build": "py35h6b90917_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "51df1c68c957f833054011fa4ccf5ec4", + "name": "anaconda-client", + "sha256": "a2402d96f40b1c681146d63147304456ab84fa54fa7d090729e680738d1af83d", + "size": 145077, + "subdir": "linux-64", + "timestamp": 1512418662683, + "version": "1.6.6" + }, + "anaconda-client-1.6.6-py36h59e3ba0_0.conda": { + "build": "py36h59e3ba0_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6aa045cdf990b4285dd7fe473f7834df", + "name": "anaconda-client", + "sha256": "0ae8d54bdfd9d05edeeb7bca920f3756d1749ae302109e08220c0b9307f87f6a", + "size": 143611, + "subdir": "linux-64", + "timestamp": 1512418697686, + "version": "1.6.6" + }, + "anaconda-client-1.6.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "requests >=2.9.1", + "ruamel_yaml <0.15", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c5fb4cfa636c2afe9b08ffd3f4e647e7", + "name": "anaconda-client", + "sha256": "69def3046ce53ed557f31d22ac8c008cbe4c76da0f7b594a237969db10be332d", + "size": 144682, + "subdir": "linux-64", + "timestamp": 1516725593537, + "version": "1.6.7" + }, + "anaconda-client-1.6.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.6.1", + "pytz", + "requests >=2.9.1", + "ruamel_yaml <0.15", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4d330a3ebdda2a7a85013e5886bf3737", + "name": "anaconda-client", + "sha256": "c7dc86101312b88fa300a61ce7a1c2a350ad327fbe5004c2dbc10afb817ab567", + "size": 146187, + "subdir": "linux-64", + "timestamp": 1516725654051, + "version": "1.6.7" + }, + "anaconda-client-1.6.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz", + "requests >=2.9.1", + "ruamel_yaml <0.15", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4c277773e030c8223539bceb47232b79", + "name": "anaconda-client", + "sha256": "19373d066de8a41079d9fba38d1ca15f7bb574cb4b06adffd2a4398e6fcba533", + "size": 144534, + "subdir": "linux-64", + "timestamp": 1516725616174, + "version": "1.6.7" + }, + "anaconda-client-1.6.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "requests >=2.9.1", + "ruamel_yaml >=0.11.14", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cdcc218b9b88f56a31e7c8acc98387e5", + "name": "anaconda-client", + "sha256": "657aeb77f2b04a62f65f82bc8c9c5ea477873c00f3310f4aa7eb900cf6f5d4dd", + "size": 144689, + "subdir": "linux-64", + "timestamp": 1516814824176, + "version": "1.6.8" + }, + "anaconda-client-1.6.8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.6.1", + "pytz", + "requests >=2.9.1", + "ruamel_yaml >=0.11.14", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1c5b36e06f90aecb51c534d9d17dfb0e", + "name": "anaconda-client", + "sha256": "1c7f29bc81cd039504248e9cbeaa8553072edf72f8290ed6c6fb9067908ea68a", + "size": 146212, + "subdir": "linux-64", + "timestamp": 1516814852393, + "version": "1.6.8" + }, + "anaconda-client-1.6.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz", + "requests >=2.9.1", + "ruamel_yaml >=0.11.14", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "84b795d0bb834b9eea7df5f11ba0ea76", + "name": "anaconda-client", + "sha256": "4b4ed7da455dee6d4b47b21028c739fa792534f6989ae59d11a6af707618d03f", + "size": 144498, + "subdir": "linux-64", + "timestamp": 1516814850480, + "version": "1.6.8" + }, + "anaconda-client-1.6.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6db0bcb4c72a4132304572b95e39ed14", + "name": "anaconda-client", + "sha256": "2d73960cf1f21df6e60a788463d5ff9c9fdc63bc46b226d36d2fd5352708021a", + "size": 144349, + "subdir": "linux-64", + "timestamp": 1517420962081, + "version": "1.6.9" + }, + "anaconda-client-1.6.9-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9b255f5987cae7ddd88d6e4b52c228cd", + "name": "anaconda-client", + "sha256": "c4cc5595229b03800b8db0f56e3f9948c7d2097493cbc220f35837de01bdc011", + "size": 145932, + "subdir": "linux-64", + "timestamp": 1517420999479, + "version": "1.6.9" + }, + "anaconda-client-1.6.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "949d941309337ab899f4519aa517220e", + "name": "anaconda-client", + "sha256": "60533e15d2f030e6959ceff9926de213fa79261b18dc83da4bd7065b2c59662d", + "size": 144341, + "subdir": "linux-64", + "timestamp": 1517420992103, + "version": "1.6.9" + }, + "anaconda-client-1.7.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6fe87142ed0a80fe4403e26dd32ee9a4", + "name": "anaconda-client", + "sha256": "f1d6490d19dd0ae7f162f2aa71a91baaa307b637e251c254915e72e6a7de0d0e", + "size": 147343, + "subdir": "linux-64", + "timestamp": 1533203937381, + "version": "1.7.1" + }, + "anaconda-client-1.7.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7b7093dd590ba6a0479b96bc4d3e018c", + "name": "anaconda-client", + "sha256": "6e01a9037c0b43c21f1384ea11ef3a44a94210e7e45885182070d65c37262e21", + "size": 149707, + "subdir": "linux-64", + "timestamp": 1533203958617, + "version": "1.7.1" + }, + "anaconda-client-1.7.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "39692ca4f604508554916d5df4da4d53", + "name": "anaconda-client", + "sha256": "5111283275c92c0aa53b0af237334d4b7ce8becac6993392b25ce987c88881fb", + "size": 148120, + "subdir": "linux-64", + "timestamp": 1533203894500, + "version": "1.7.1" + }, + "anaconda-client-1.7.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "085b93f1cc86e66bd39a165a0f7d5f99", + "name": "anaconda-client", + "sha256": "0715fa2c195fb4bc4f1a075a2b5cf359f486e5be0f89bd1c6ea054b276e0f8bf", + "size": 146490, + "subdir": "linux-64", + "timestamp": 1533203949660, + "version": "1.7.1" + }, + "anaconda-client-1.7.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e8839fa5d682dee9d8be0aec8bc4eb22", + "name": "anaconda-client", + "sha256": "9b3fb2f6376c2ff2dd08ff47b98a0f81e3bcfd856cc13c9109871a1d7a4d0868", + "size": 153099, + "subdir": "linux-64", + "timestamp": 1535570503476, + "version": "1.7.2" + }, + "anaconda-client-1.7.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b3a737c9157caf0ce8721e52c4d200d4", + "name": "anaconda-client", + "sha256": "9b649ca6e1eaf0a8cb7e8960001d4d57568144455f81fbbeabab176b8666f296", + "size": 152449, + "subdir": "linux-64", + "timestamp": 1535570506164, + "version": "1.7.2" + }, + "anaconda-client-1.7.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4b84669195d378646231a35772ee5cd6", + "name": "anaconda-client", + "sha256": "627b196437baa2b10cf77b8ca7761869b653d9dbcb72cf420ff0c6fa6ebd5a50", + "size": 150618, + "subdir": "linux-64", + "timestamp": 1535570482984, + "version": "1.7.2" + }, + "anaconda-client-1.7.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.2", + "nbformat", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "pyyaml", + "requests >=2.9.1", + "setuptools" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5e8085c658b7cfc53411a7b298ad5aac", + "name": "anaconda-client", + "sha256": "6a35a949df53b6f4ec383c933c802c3f36a7e5134f529e977018a68f9be0a160", + "size": 150586, + "subdir": "linux-64", + "timestamp": 1535570528927, + "version": "1.7.2" + }, + "anaconda-client-1.7.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ddc0ff43c2836ac0b59042010ed08592", + "name": "anaconda-client", + "sha256": "39335f908c56c43be6143acb3cf1247dc55fd2843689d232d2841aa0c883d78b", + "size": 159755, + "subdir": "linux-64", + "timestamp": 1580246317117, + "version": "1.7.2" + }, + "anaconda-client-1.7.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2738910739c55d0b2cb9b92f60aa02bd", + "name": "anaconda-client", + "sha256": "b1daac4fef547a5e1b8ec55cc20cbd4c6cc33de3100e690981ee226a11886cbd", + "size": 160607, + "subdir": "linux-64", + "timestamp": 1607980774188, + "version": "1.7.2" + }, + "anaconda-client-1.8.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a2ca8d0ccfca5d4ec2f08880137c3c76", + "name": "anaconda-client", + "sha256": "e9911f3dea3b3f1b6be607bac1f8752780c4ff0ed92493a6fe290c76093e442e", + "size": 155628, + "subdir": "linux-64", + "timestamp": 1624480211365, + "version": "1.8.0" + }, + "anaconda-client-1.8.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "03d8e17828691e462291b82ed1299775", + "name": "anaconda-client", + "sha256": "6a206d99ec8794a4a6839b66b067d920ae1db6b140a73fdff1bd909ebc69694c", + "size": 153765, + "subdir": "linux-64", + "timestamp": 1624480121888, + "version": "1.8.0" + }, + "anaconda-client-1.8.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3aa8cf60754e4ea72887d604a0c9f67f", + "name": "anaconda-client", + "sha256": "3cdeda6db9638bedfffd8bbbbeb05203aca29ced15021280427da77af2346a90", + "size": 155520, + "subdir": "linux-64", + "timestamp": 1624474020991, + "version": "1.8.0" + }, + "anaconda-client-1.8.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "36a7d3831f080ccce45852e5a9b1d34c", + "name": "anaconda-client", + "sha256": "d54f54449fdb8c45c1d6c15dae3a4246df436da9458daff1647bd00385a9c6eb", + "size": 156644, + "subdir": "linux-64", + "timestamp": 1624480201370, + "version": "1.8.0" + }, + "anaconda-client-1.9.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1b9c144d5ef2a7de848fbb84c3b79080", + "name": "anaconda-client", + "sha256": "a864c8e437a9be09c3899a8b42cc3a0eda54f69c89ea520751271ec45d6775de", + "size": 219649, + "subdir": "linux-64", + "timestamp": 1676843180879, + "version": "1.9.0" + }, + "anaconda-client-1.9.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2fbd9120753d893cfc2450246083555c", + "name": "anaconda-client", + "sha256": "55813f5cc28525497588243b41195567494e6b86f496681ace0fb16e9d5cac79", + "size": 157282, + "subdir": "linux-64", + "timestamp": 1635342473670, + "version": "1.9.0" + }, + "anaconda-client-1.9.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1ab97208c96047d93ab2bcbaaf83cd4f", + "name": "anaconda-client", + "sha256": "adc94fab333ce4aa42a11ca9abcfb1784b6e77661b5cdfdb6aa191638e4ba29e", + "size": 159325, + "subdir": "linux-64", + "timestamp": 1635330928093, + "version": "1.9.0" + }, + "anaconda-client-1.9.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "clyent >=1.2.0", + "nbformat >=4.4.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "79453871d1ef3c66b27be0bf5c14d0fd", + "name": "anaconda-client", + "sha256": "c2e34057a8284a25fbeaa42897ba133fe47bc287f3de2846aac36b2faaa0ae02", + "size": 157559, + "subdir": "linux-64", + "timestamp": 1635342585953, + "version": "1.9.0" + }, + "anaconda-custom-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "_anaconda_depends", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "03782b24c70ee1cbbba329701582681f", + "name": "anaconda", + "namespace": "python", + "sha256": "e93394fb73430580d673b3408f5905fad8bebec7011eb4be111c8fce6abb8a24", + "size": 3225, + "subdir": "linux-64", + "timestamp": 1562174475944, + "version": "custom" + }, + "anaconda-custom-py27h4a00acb_0.conda": { + "build": "py27h4a00acb_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "_anaconda_depends" + ], + "license": "BSD", + "md5": "5a9fe541236250ad222a870b59f457f2", + "name": "anaconda", + "namespace": "python", + "sha256": "5ced62abd043685bedd3c3d629b835f08fbbd261800f7797375601fd14797bbe", + "size": 5537, + "subdir": "linux-64", + "timestamp": 1508808912627, + "version": "custom" + }, + "anaconda-custom-py310_1.conda": { + "build": "py310_1", + "build_number": 1, + "depends": [ + "_anaconda_depends", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1f96797d6a6addfabee0c5f0f100207d", + "name": "anaconda", + "namespace": "python", + "sha256": "ba828b80d59a302bf7ecf480552f2133ddb1644b5b2a0c561e5c11a81796c8bf", + "size": 11875, + "subdir": "linux-64", + "timestamp": 1674154116491, + "version": "custom" + }, + "anaconda-custom-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "_anaconda_depends", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "8a2bbf4e3ba19c374fa068806d49ba13", + "name": "anaconda", + "namespace": "python", + "sha256": "3d89bfb0c01f2a8ea2bb3580bbd2d7419daf627306a92ea283d89e82c396b9a9", + "size": 3221, + "subdir": "linux-64", + "timestamp": 1562174447436, + "version": "custom" + }, + "anaconda-custom-py35h104c396_0.conda": { + "build": "py35h104c396_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "_anaconda_depends" + ], + "license": "BSD", + "md5": "f42cfb1a4b19817b19150faf9584fb78", + "name": "anaconda", + "namespace": "python", + "sha256": "717fbe789b53fe59e286943beacc36fca050fd9fbd291d5e6525e912ab5cd8d0", + "size": 5538, + "subdir": "linux-64", + "timestamp": 1508808901528, + "version": "custom" + }, + "anaconda-custom-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "_anaconda_depends", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "57401106b0d56ec4ab2ed44655f448fa", + "name": "anaconda", + "namespace": "python", + "sha256": "6adfeea594841009acec5a79a1e834e8e3080f33f669a0df64715a94cdb9eedc", + "size": 3212, + "subdir": "linux-64", + "timestamp": 1562174457474, + "version": "custom" + }, + "anaconda-custom-py36hbbc8b67_0.conda": { + "build": "py36hbbc8b67_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "_anaconda_depends" + ], + "license": "BSD", + "md5": "90604cbf598b671a1d3fe31e720efa59", + "name": "anaconda", + "namespace": "python", + "sha256": "a73b3dc2645bb389ad08d48803bfb21f41d68a089acb0db65ae0c5d27706c943", + "size": 5561, + "subdir": "linux-64", + "timestamp": 1508808890508, + "version": "custom" + }, + "anaconda-custom-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "_anaconda_depends" + ], + "license": "BSD", + "md5": "a420d69fb2081e97129f4ffeacf19cc7", + "name": "anaconda", + "namespace": "python", + "sha256": "ad53eb948808686ee9b6cf9371d1e9caeafa4cee4b3aee3428856233f280b296", + "size": 5989, + "subdir": "linux-64", + "timestamp": 1531513560056, + "version": "custom" + }, + "anaconda-custom-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "_anaconda_depends", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "f29bb7404129fe09e5fd0bb326795dbe", + "name": "anaconda", + "namespace": "python", + "sha256": "ed298d2b227710ea65e2e88d2c3d5033bb73307278fb71930076a799e682c589", + "size": 3212, + "subdir": "linux-64", + "timestamp": 1562174465581, + "version": "custom" + }, + "anaconda-custom-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "_anaconda_depends", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "aa930c1da2c77c8085222108d4311d72", + "name": "anaconda", + "namespace": "python", + "sha256": "f51af587a60c266d21f220d7d68115440f1702b624bf2631f3cf4c7c1b36e9b5", + "size": 35968, + "subdir": "linux-64", + "timestamp": 1587071572818, + "version": "custom" + }, + "anaconda-custom-py39_1.conda": { + "build": "py39_1", + "build_number": 1, + "depends": [ + "_anaconda_depends", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "36a792595f9f51a8333162fecba66b7f", + "name": "anaconda", + "namespace": "python", + "sha256": "c0271bbf40075d93d284599c637ad34e4b5a4155a813678a0b37fbc4d2521a46", + "size": 3520, + "subdir": "linux-64", + "timestamp": 1636993662746, + "version": "custom" + }, + "anaconda-docs-2.0.18-hb3a96d1_0.conda": { + "build": "hb3a96d1_0", + "build_number": 0, + "depends": [], + "md5": "eb5978f7b67ee11bb194bc5d289e1c81", + "name": "anaconda-docs", + "sha256": "24804f8b0771258f771d2227107267e0ef09055ce6f7dec9aa1cea17235e323f", + "size": 42762961, + "subdir": "linux-64", + "timestamp": 1510870072425, + "version": "2.0.18" + }, + "anaconda-docs-2.0.19-hb3a96d1_0.conda": { + "build": "hb3a96d1_0", + "build_number": 0, + "depends": [], + "md5": "25a9921c746cc0964114533481ef93c8", + "name": "anaconda-docs", + "sha256": "c8b66a84beac27b3b0dfa4ff31b335684bf0bfe6f58eaa0669134a2b4126b480", + "size": 42953642, + "subdir": "linux-64", + "timestamp": 1512077805825, + "version": "2.0.19" + }, + "anaconda-docs-2.0.20-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "md5": "d213ca637a5108e7aabef3daf1e0c771", + "name": "anaconda-docs", + "sha256": "831ab750b1c98182f1b3fe84f34e8158ebe74267080d0ca8aff2b58efb10edc6", + "size": 33387133, + "subdir": "linux-64", + "timestamp": 1513628344280, + "version": "2.0.20" + }, + "anaconda-docs-2.0.21-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "md5": "ad49b4e6c47ee0a6d367e59f957e7210", + "name": "anaconda-docs", + "sha256": "2491e9813cbdb1d5d7634b17c7891f7a3dcae2251963a3dbcd29932054c257e5", + "size": 33429375, + "subdir": "linux-64", + "timestamp": 1516911564970, + "version": "2.0.21" + }, + "anaconda-docs-2.0.22-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "md5": "9e8f9945837ebd2e5a15d2040c4c5c53", + "name": "anaconda-docs", + "sha256": "b47f9f65ed6af7128da4ca07b0161c669f559adf0b05d2ce03e6d705872c2322", + "size": 33430051, + "subdir": "linux-64", + "timestamp": 1518115447238, + "version": "2.0.22" + }, + "anaconda-docs-2.0.23-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "md5": "3c4155e709a9d21de61138815077a1b8", + "name": "anaconda-docs", + "sha256": "a5c5adf95aaa6dc08e0594ec684a57c8d61cf8c1ec5c6031055b1ffd466d1903", + "size": 35516196, + "subdir": "linux-64", + "timestamp": 1520636361902, + "version": "2.0.23" + }, + "anaconda-linter-0.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.10,<3.11.0a0", + "pyyaml", + "ruamel.yaml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "41aaf604276d08d3644ad84849608ebe", + "name": "anaconda-linter", + "sha256": "ed7007eb7a0c6207c34b83141474447118a80f2c762e8a4279b70bff5c290400", + "size": 66944, + "subdir": "linux-64", + "timestamp": 1664274122751, + "version": "0.0.1" + }, + "anaconda-linter-0.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "ruamel.yaml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ae41b91129cc0ce929e918074fe24c87", + "name": "anaconda-linter", + "sha256": "45d4e71384a23e27af5a4b60e1435d85fcce70fe4cb037b68951b5c7b52454dd", + "size": 66453, + "subdir": "linux-64", + "timestamp": 1664274204825, + "version": "0.0.1" + }, + "anaconda-linter-0.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "ruamel.yaml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "80a3c14bc3569a8bb000cfb6f8f57a27", + "name": "anaconda-linter", + "sha256": "5d9722b75e6247dfa0656d7ce30b4bb224fbc45c731a6cfdea619ab2b970b5b1", + "size": 66385, + "subdir": "linux-64", + "timestamp": 1664274164964, + "version": "0.0.1" + }, + "anaconda-linter-0.0.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.10,<3.11.0a0", + "pyyaml", + "ruamel.yaml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9366dde0988c247049f12423da1020c0", + "name": "anaconda-linter", + "sha256": "319ae5f4f3985cedefc991bff87415784b0fa6661ed25070a9a33405590c1430", + "size": 68036, + "subdir": "linux-64", + "timestamp": 1664990462435, + "version": "0.0.2" + }, + "anaconda-linter-0.0.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "ruamel.yaml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "82695301a8c619031b434af7eb33fb69", + "name": "anaconda-linter", + "sha256": "280b47951c494c11d0804672edcc433d4b97da3c1bf801804cb65fccdf012c05", + "size": 67326, + "subdir": "linux-64", + "timestamp": 1664990543231, + "version": "0.0.2" + }, + "anaconda-linter-0.0.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "ruamel.yaml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "77c1276fd6f141a646dce8b3cbd9e49f", + "name": "anaconda-linter", + "sha256": "0fb94b9c3a51d6e5c7b51f785a59c13374e66af2a4c2c38f10541af069d0ec54", + "size": 67295, + "subdir": "linux-64", + "timestamp": 1664990503241, + "version": "0.0.2" + }, + "anaconda-linter-0.0.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "git", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.10,<3.11.0a0", + "pyyaml", + "ruamel.yaml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "53fed45836dbb51b4218d990a7e5ce0c", + "name": "anaconda-linter", + "sha256": "b01e88029fca12c8add20ccfe9e6a77f512219f713d6590eda79c294595d0c23", + "size": 69645, + "subdir": "linux-64", + "timestamp": 1666097766665, + "version": "0.0.3" + }, + "anaconda-linter-0.0.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "git", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "ruamel.yaml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b17de481f62c5f7d822c9ea8c5a8334b", + "name": "anaconda-linter", + "sha256": "dedd379675994e6211bf8e1d6cad4c47298d6ee83c2e8a797fb72cf64c2648ef", + "size": 69129, + "subdir": "linux-64", + "timestamp": 1666097727485, + "version": "0.0.3" + }, + "anaconda-linter-0.0.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "git", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "ruamel.yaml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "46188b3856c7bac5721b1e770b1e293b", + "name": "anaconda-linter", + "sha256": "3b10854fd371f257fa101cb2acc2f1db1e9b6f8453ef503975ae3b65de5a0f53", + "size": 69070, + "subdir": "linux-64", + "timestamp": 1666097803222, + "version": "0.0.3" + }, + "anaconda-linter-0.0.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.10,<3.11.0a0", + "requests", + "ruamel.yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cd224c771b6385efe78a9b924ada70c9", + "name": "anaconda-linter", + "sha256": "ceb69e62f579e058e6bc2d5eb1bf44175dfdd3725d8e7aa0604bf1530983174b", + "size": 86619, + "subdir": "linux-64", + "timestamp": 1673455981833, + "version": "0.0.4" + }, + "anaconda-linter-0.0.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.11,<3.12.0a0", + "requests", + "ruamel.yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7fd22cb83d347944b88e78faad80a30f", + "name": "anaconda-linter", + "sha256": "9a9b3f6e647091846c0a1b998aa870e67e6da910493ed200f53ceca9a73c52af", + "size": 106101, + "subdir": "linux-64", + "timestamp": 1676846725731, + "version": "0.0.4" + }, + "anaconda-linter-0.0.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.8,<3.9.0a0", + "requests", + "ruamel.yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0b172a69bfbe78f3e5a8fd36f9da4249", + "name": "anaconda-linter", + "sha256": "c07f6dd48d01942af16f5b9423826aeec2f82d397229bf6aa9bcebc6ff053de9", + "size": 85885, + "subdir": "linux-64", + "timestamp": 1673456031489, + "version": "0.0.4" + }, + "anaconda-linter-0.0.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "conda-build", + "jinja2", + "jsonschema", + "license-expression", + "networkx", + "python >=3.9,<3.10.0a0", + "requests", + "ruamel.yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e13f9a00ec25e119908c554d51f37a4a", + "name": "anaconda-linter", + "sha256": "f2a02c80163e96d1fa7f9514741653163a505ff9eea69a0a7f331d06895368ca", + "size": 85962, + "subdir": "linux-64", + "timestamp": 1673456081830, + "version": "0.0.4" + }, + "anaconda-navigator-1.10.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "e09a3e0ecde0e4f5d03ffe37f8554a3a", + "name": "anaconda-navigator", + "sha256": "baf0dbf55901decd83c8fbd81c97252e88bdcb5d271173a5703b858ae0459b40", + "size": 5132685, + "subdir": "linux-64", + "timestamp": 1603202715080, + "version": "1.10.0" + }, + "anaconda-navigator-1.10.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "f68662c23f6c69aa3b07db7497a1225d", + "name": "anaconda-navigator", + "sha256": "3e1cde9a4592f7ad7b11d55f1b1ab6d001c8b45e530d8a0006af7592d2674c8a", + "size": 5130145, + "subdir": "linux-64", + "timestamp": 1603202736877, + "version": "1.10.0" + }, + "anaconda-navigator-1.10.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "ac81c27aa1dda691ef8a546ec8d08a0a", + "name": "anaconda-navigator", + "sha256": "65ac9365a1fbfb0675b8a0f2b4d676203763f506f6f4c362a55aa127b3afb6b5", + "size": 5136684, + "subdir": "linux-64", + "timestamp": 1603202740802, + "version": "1.10.0" + }, + "anaconda-navigator-1.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "dda4dbcf86976c7b8d05461ce5ee502d", + "name": "anaconda-navigator", + "sha256": "282d01edcb3aac8a84a8eaa332531bfc6f51f5b2cef60c30349f229f7add83b6", + "size": 5138168, + "subdir": "linux-64", + "timestamp": 1608055386186, + "version": "1.10.0" + }, + "anaconda-navigator-1.6.10-py27h4abd9a3_0.conda": { + "build": "py27h4abd9a3_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "61131c732e6ac96aa37e87e4f984a7af", + "name": "anaconda-navigator", + "sha256": "04d73cab6578cfccc2ed017809b383928f143197f33ed895759c74cb8690e081", + "size": 3691244, + "subdir": "linux-64", + "timestamp": 1512412230550, + "version": "1.6.10" + }, + "anaconda-navigator-1.6.10-py35h6c327bc_0.conda": { + "build": "py35h6c327bc_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "5feae3af2258cab42daa622fe46a5616", + "name": "anaconda-navigator", + "sha256": "d674a8ebeb0f92cb8ce94119fc8f129ce20431458cfabe68c1d2588511f73417", + "size": 3695836, + "subdir": "linux-64", + "timestamp": 1512412286971, + "version": "1.6.10" + }, + "anaconda-navigator-1.6.10-py36hca14bee_0.conda": { + "build": "py36hca14bee_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "c3cdb6dfcc1ec6b6a74c16c2ef60e809", + "name": "anaconda-navigator", + "sha256": "9079959585dde4c3c3f3ef0845e23efedcea550e7fd3b86cc29986118ec814d6", + "size": 3691961, + "subdir": "linux-64", + "timestamp": 1512412379542, + "version": "1.6.10" + }, + "anaconda-navigator-1.6.11-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "dfc05a692d9e9ef76ef096969b14aac7", + "name": "anaconda-navigator", + "sha256": "2e0c7680cca237ba1afa0d419c6cfd31989fcbf776f861aab0f6d22783effc07", + "size": 3694039, + "subdir": "linux-64", + "timestamp": 1514307421088, + "version": "1.6.11" + }, + "anaconda-navigator-1.6.11-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "fa1dc4e47547a302e79fc22125d55bf7", + "name": "anaconda-navigator", + "sha256": "d978d8582198dc8afabc5ebd9644727ee54899eea7d412f58105df3bcb902be6", + "size": 3696446, + "subdir": "linux-64", + "timestamp": 1514307535641, + "version": "1.6.11" + }, + "anaconda-navigator-1.6.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "0322e60cf234c23c0dcfd9773a76ce8e", + "name": "anaconda-navigator", + "sha256": "c0dd03b534edcc80ef6fcabbd23b5ec5c2f8720019dae58abdcd1db454698e6c", + "size": 3698673, + "subdir": "linux-64", + "timestamp": 1514307609830, + "version": "1.6.11" + }, + "anaconda-navigator-1.6.12-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "fecc5112f8286a4ae3320bea84872ccd", + "name": "anaconda-navigator", + "sha256": "d270056fbe6fafbead8d4aa655b46e73b457161da84c15e5d0d3d1bc47c86c72", + "size": 3693472, + "subdir": "linux-64", + "timestamp": 1515547197712, + "version": "1.6.12" + }, + "anaconda-navigator-1.6.12-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "ced422e91912dae43f37cce044d2ec14", + "name": "anaconda-navigator", + "sha256": "5f18d31cf852083d2af01c2099a5dfd340254e1afac1cb9870d0fd073e897dad", + "size": 3696236, + "subdir": "linux-64", + "timestamp": 1515547250027, + "version": "1.6.12" + }, + "anaconda-navigator-1.6.12-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "7bd76c5cf565254ccf7b8fb21b6f6e3d", + "name": "anaconda-navigator", + "sha256": "e1080714a3b5bf880344e59c6998276abeee02fbd9b92f8dc9714e01b1e82e95", + "size": 3698284, + "subdir": "linux-64", + "timestamp": 1515547299228, + "version": "1.6.12" + }, + "anaconda-navigator-1.6.8-py27h2ea4365_0.conda": { + "build": "py27h2ea4365_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "074edfd21d07920b28cd086c8470496e", + "name": "anaconda-navigator", + "sha256": "6e53e0370b378b9c076f4f581476dc4245158bf1adae195d871770946d2bcb79", + "size": 3660097, + "subdir": "linux-64", + "timestamp": 1506046175072, + "version": "1.6.8" + }, + "anaconda-navigator-1.6.8-py35haed54dd_0.conda": { + "build": "py35haed54dd_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "295dc9190cb7a1c76c4e1bdae13dd44d", + "name": "anaconda-navigator", + "sha256": "a4d12be65a80a3096613707323bb9facadf54daccad2f31df09fd811b00591f9", + "size": 3671144, + "subdir": "linux-64", + "timestamp": 1506046205874, + "version": "1.6.8" + }, + "anaconda-navigator-1.6.8-py36h672ccc7_0.conda": { + "build": "py36h672ccc7_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "b2374f0d50c781cf9d1c9e9f5f7257cd", + "name": "anaconda-navigator", + "sha256": "1305f374da553b79d57802ba8ca3a9d493058931cd11c95d8863d6b27b590d43", + "size": 3664877, + "subdir": "linux-64", + "timestamp": 1506046235237, + "version": "1.6.8" + }, + "anaconda-navigator-1.6.9-py27hfbc306d_0.conda": { + "build": "py27hfbc306d_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "aa620e86350fbc2224390763b2f1d569", + "name": "anaconda-navigator", + "sha256": "c47e71d351db7c4ce8e312de050f6e1029e9447587e2ff8c1b0df3f879a67b0a", + "size": 3660178, + "subdir": "linux-64", + "timestamp": 1508349050688, + "version": "1.6.9" + }, + "anaconda-navigator-1.6.9-py35h5f5ee00_0.conda": { + "build": "py35h5f5ee00_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "aed76b214cef655c8cc5e0f420cdd7e1", + "name": "anaconda-navigator", + "sha256": "0a9d09fe620f46c6f07130ead0deb03f3022d9d71daa32fd4d68b99ab09e45ce", + "size": 3671736, + "subdir": "linux-64", + "timestamp": 1508348993235, + "version": "1.6.9" + }, + "anaconda-navigator-1.6.9-py36h11ddaaa_0.conda": { + "build": "py36h11ddaaa_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "cf9817304b96d254313b20df8bb2e564", + "name": "anaconda-navigator", + "sha256": "303a670be4088faad14bb2feafb213c393b628a9b9aab6580c0648bc03303eae", + "size": 3660993, + "subdir": "linux-64", + "timestamp": 1508348933488, + "version": "1.6.9" + }, + "anaconda-navigator-1.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "320fa8af879311712d860ac849eb16a2", + "name": "anaconda-navigator", + "sha256": "fef161ba2202998045568b86c2c14e3f40360190ec2d6bee62fe571dfd6e8dfe", + "size": 3953003, + "subdir": "linux-64", + "timestamp": 1518512189311, + "version": "1.7.0" + }, + "anaconda-navigator-1.7.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "0842bd421fb5a7f6dbff2c40502074f4", + "name": "anaconda-navigator", + "sha256": "5d32937272ec969fd1a65af9bfb9f888562944bad9e218a52b280743eefec36d", + "size": 3965385, + "subdir": "linux-64", + "timestamp": 1518512240814, + "version": "1.7.0" + }, + "anaconda-navigator-1.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "4207c05f6a3f1a1c19dc4d6a75b844c6", + "name": "anaconda-navigator", + "sha256": "4fe61fece4be8f832386414a5b72694843462e15ce1747313597a6af01112fde", + "size": 3955606, + "subdir": "linux-64", + "timestamp": 1518512293013, + "version": "1.7.0" + }, + "anaconda-navigator-1.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.12", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "779acbce0ac29e26df94380111ad9d54", + "name": "anaconda-navigator", + "sha256": "bd36df49702ba85aacebba3d9442a2ed6c481bfd35c64d890ad4e322c8fb6f04", + "size": 3953546, + "subdir": "linux-64", + "timestamp": 1520917799722, + "version": "1.8.1" + }, + "anaconda-navigator-1.8.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.12", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "399e7eb5852d64f6694f7ea3999cbfa1", + "name": "anaconda-navigator", + "sha256": "15a887c93d001fc6191f08140833077764bce5699d56eed20ab6ebbde9d905b3", + "size": 3966020, + "subdir": "linux-64", + "timestamp": 1520917899862, + "version": "1.8.1" + }, + "anaconda-navigator-1.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.12", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "97867b2c541848e41c7434b091266f2e", + "name": "anaconda-navigator", + "sha256": "6ee39b8a9731a157511bcd2d62ba3ad919d7f08356a464895b2abcedb85a59b6", + "size": 3956807, + "subdir": "linux-64", + "timestamp": 1520917962183, + "version": "1.8.1" + }, + "anaconda-navigator-1.8.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.12", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "d5a3e384269a300ccceb5f05fc1008cc", + "name": "anaconda-navigator", + "sha256": "eb6bd333bc8466a33989590c04fb571a3ea590a759fbee71fc7d401f7617b798", + "size": 3953825, + "subdir": "linux-64", + "timestamp": 1521773110540, + "version": "1.8.2" + }, + "anaconda-navigator-1.8.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.12", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "a8c566b1ac2438ccc0f7d862ae52de6d", + "name": "anaconda-navigator", + "sha256": "290d817440710cccf70f159e5b368575feb5aafc6512557adb821ccc1d8668ed", + "size": 3967112, + "subdir": "linux-64", + "timestamp": 1521773196024, + "version": "1.8.2" + }, + "anaconda-navigator-1.8.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.12", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "e444ba0487aab8a6de386914c0ba41d9", + "name": "anaconda-navigator", + "sha256": "2a60bc300f31737571e68271abc4139b7349e52350d543ce0b2c6339643ac447", + "size": 3954338, + "subdir": "linux-64", + "timestamp": 1521773256475, + "version": "1.8.2" + }, + "anaconda-navigator-1.8.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.12", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "c0ce0b19606c3d319174b2739b4066a8", + "name": "anaconda-navigator", + "sha256": "f68976b020403c80c1a82cdd739df4333f27970f142477820b71e31c663f8aed", + "size": 4390243, + "subdir": "linux-64", + "timestamp": 1523356559372, + "version": "1.8.3" + }, + "anaconda-navigator-1.8.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.12", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "71cd738b142c634b31c0e2cba0d96c9b", + "name": "anaconda-navigator", + "sha256": "300a17f1e95cc095c195e553146926088877ad52d810c10f4612a391c3781021", + "size": 4395110, + "subdir": "linux-64", + "timestamp": 1523356631642, + "version": "1.8.3" + }, + "anaconda-navigator-1.8.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.12", + "anaconda-project >=0.4", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.2", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "b0ce9334b680340bfb7ee5fa9fdca027", + "name": "anaconda-navigator", + "sha256": "67da0614e7e3d417fc68f8800ed047e5884ef45d757b8a26d33a49a4594cae7b", + "size": 4390647, + "subdir": "linux-64", + "timestamp": 1523356715104, + "version": "1.8.3" + }, + "anaconda-navigator-1.8.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "anaconda-project", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "722231a34b67136b41b8c430f96c060c", + "name": "anaconda-navigator", + "sha256": "f55fc478c255dbc60c57414f46bb17b93a0431bec78081a33937afd683a6deb7", + "size": 4391184, + "subdir": "linux-64", + "timestamp": 1524671459436, + "version": "1.8.4" + }, + "anaconda-navigator-1.8.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "anaconda-project", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "eddeff4233b3321d872bc9bd2a00d9cb", + "name": "anaconda-navigator", + "sha256": "178e142a06805335e19c91eb8856f23f5fecc77f309760dd98d493a7c9a7f377", + "size": 4402476, + "subdir": "linux-64", + "timestamp": 1524671586445, + "version": "1.8.4" + }, + "anaconda-navigator-1.8.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "anaconda-project", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "131294cc8d9aacab89f21249c3ac505e", + "name": "anaconda-navigator", + "sha256": "cbd64cddfb51ddee8bfec95025d0783827a2160cec6cdec73868edaff4131249", + "size": 4394745, + "subdir": "linux-64", + "timestamp": 1524671650262, + "version": "1.8.4" + }, + "anaconda-navigator-1.8.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "9697a481bc46afcd1ca3a7f5f1c688db", + "name": "anaconda-navigator", + "sha256": "f616af392e882ad436ab8a4dfe51bebe8e4fd3a912f3ab44ba90e1ca708e94d1", + "size": 4392592, + "subdir": "linux-64", + "timestamp": 1525799641170, + "version": "1.8.5" + }, + "anaconda-navigator-1.8.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "310863d3244ab30771be1de1d7debf2b", + "name": "anaconda-navigator", + "sha256": "9bf870588079ba0241370947c4c69d67954249fa925e6ad857fa03db9bb67e30", + "size": 4397620, + "subdir": "linux-64", + "timestamp": 1525799712978, + "version": "1.8.5" + }, + "anaconda-navigator-1.8.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "1649ca790ae9d4a005ab6fcf95e44a8f", + "name": "anaconda-navigator", + "sha256": "43315468e269d3b4e462badd7ee5b7cb9e50f6fb23cc96f6f52d1b45e9c323bc", + "size": 4395586, + "subdir": "linux-64", + "timestamp": 1525799589770, + "version": "1.8.5" + }, + "anaconda-navigator-1.8.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "5df9007d411fcaf5b2c75c2c69ad9fe3", + "name": "anaconda-navigator", + "sha256": "373c8aa8a2e20c2728d71e89c70b0790157158e07334d357977ca3c7293538a0", + "size": 4398912, + "subdir": "linux-64", + "timestamp": 1527010709910, + "version": "1.8.7" + }, + "anaconda-navigator-1.8.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "d8c734f1a195e34cf5acbf98eced8516", + "name": "anaconda-navigator", + "sha256": "e6d5d2c91a9ee96d0880fe56ebcbff9de5f130789fe211d0614b468e87874d62", + "size": 4405599, + "subdir": "linux-64", + "timestamp": 1527010914001, + "version": "1.8.7" + }, + "anaconda-navigator-1.8.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "0007e742ff4f9c5c692534615b96097c", + "name": "anaconda-navigator", + "sha256": "cdb585b32fcc0fe6ebcd48e6c2701965566af1cd1a3a0ebef1475f0ff8fc4785", + "size": 4393939, + "subdir": "linux-64", + "timestamp": 1527010836995, + "version": "1.8.7" + }, + "anaconda-navigator-1.8.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "c0ccfe6a0c8932b7fde04c1fb91f1dcc", + "name": "anaconda-navigator", + "sha256": "fc92cccc75cb27b89017411186dec1711304220f7e4d97109c50e95ba7eebb87", + "size": 4397172, + "subdir": "linux-64", + "timestamp": 1531442652515, + "version": "1.8.7" + }, + "anaconda-navigator-1.9.12-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "e15fdcbe12c420defbd2866f0dfb7910", + "name": "anaconda-navigator", + "sha256": "f2af2d17fb32952ee8449a18214b281876115b904bd9c4859765a80a906656b7", + "size": 4628295, + "subdir": "linux-64", + "timestamp": 1582555334041, + "version": "1.9.12" + }, + "anaconda-navigator-1.9.12-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "122ab2f58b105ac0acde30e03e0dc208", + "name": "anaconda-navigator", + "sha256": "64aedb40c04fc57890d8315b3a250256d85acf1538952b335230848b95f473d3", + "size": 4632560, + "subdir": "linux-64", + "timestamp": 1583190949954, + "version": "1.9.12" + }, + "anaconda-navigator-1.9.12-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "9f26fcb8c3be17f990002ac9d1060c57", + "name": "anaconda-navigator", + "sha256": "d937d132d5ea5f8652f599a17651db3e21b4a1315a228dad12ee1fb1929fa812", + "size": 4629591, + "subdir": "linux-64", + "timestamp": 1582555324532, + "version": "1.9.12" + }, + "anaconda-navigator-1.9.12-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "a84c3df2a461d5fb1df537fcbb375129", + "name": "anaconda-navigator", + "sha256": "61d6f904e546415790817f5667ada821c7fdaca7d7adc6910c3d80e63291024c", + "size": 4630799, + "subdir": "linux-64", + "timestamp": 1583190944530, + "version": "1.9.12" + }, + "anaconda-navigator-1.9.12-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "932b1cff6c2466a2a70567f735a783b2", + "name": "anaconda-navigator", + "sha256": "13f237f11b0f919c661d55e2695ab9cbbafd244699171e68090baf82ca41ad7e", + "size": 4633801, + "subdir": "linux-64", + "timestamp": 1582555326892, + "version": "1.9.12" + }, + "anaconda-navigator-1.9.12-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "2afb982072b62958bf3b1ca91e48480c", + "name": "anaconda-navigator", + "sha256": "dbb1f9994f4f479110b1ee073bbce19930133ba581b15fbe426f403c645cc917", + "size": 4635791, + "subdir": "linux-64", + "timestamp": 1583190933696, + "version": "1.9.12" + }, + "anaconda-navigator-1.9.12-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "013541f661d1643c469a66dff9ac8be8", + "name": "anaconda-navigator", + "sha256": "9233cf9c7a6d46ecd87ff6acf177c16f48f69c8fd96db29d27d2293420e236f5", + "size": 4632859, + "subdir": "linux-64", + "timestamp": 1582555327695, + "version": "1.9.12" + }, + "anaconda-navigator-1.9.12-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "db9d0b75e7886292dbcdfa9072ef7b7d", + "name": "anaconda-navigator", + "sha256": "1afc71caf001302376bfe35f583b738f1c7aea9ff1b799628656e87865705bc7", + "size": 4638383, + "subdir": "linux-64", + "timestamp": 1583190951229, + "version": "1.9.12" + }, + "anaconda-navigator-1.9.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "c548aade768045f316b35932e513cf3e", + "name": "anaconda-navigator", + "sha256": "0d6db0b2ce8f11559b1a0655741f9ec13c801db081ac39a07cd4a6f0614ca7f1", + "size": 4449154, + "subdir": "linux-64", + "timestamp": 1537565894569, + "version": "1.9.2" + }, + "anaconda-navigator-1.9.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.5,<3.6.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "9c957f32a5e7bb8ab752c7f17989ba30", + "name": "anaconda-navigator", + "sha256": "1b1b60eff706567a6c7fc6b79ea885f56bf7d312734f2711e9e43d5deedfc036", + "size": 4449486, + "subdir": "linux-64", + "timestamp": 1537565896303, + "version": "1.9.2" + }, + "anaconda-navigator-1.9.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "6e2e43e47c97510944190cf7f1616f9e", + "name": "anaconda-navigator", + "sha256": "08a7786b0405caed4941885a0f333cd2f2dd962a7bbaa932cc6a49b87655d8a0", + "size": 4444185, + "subdir": "linux-64", + "timestamp": 1537565903677, + "version": "1.9.2" + }, + "anaconda-navigator-1.9.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "ec27279840a6c8dcf62fca0c228fd8bb", + "name": "anaconda-navigator", + "sha256": "1c7b1c406ab5e874afcb8547d8dda80e568d6998b79825609a7b2c3e265b9387", + "size": 4444707, + "subdir": "linux-64", + "timestamp": 1537565897442, + "version": "1.9.2" + }, + "anaconda-navigator-1.9.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "3b0eea210ba6c9c87a737e36b2a2f7fb", + "name": "anaconda-navigator", + "sha256": "c8e66c17a864f9cfc9394276798e4de43f378ea9145d41195389e93b9d9c3ff9", + "size": 4476232, + "subdir": "linux-64", + "timestamp": 1543860113290, + "version": "1.9.4" + }, + "anaconda-navigator-1.9.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "0bdfaffb85bbe65650bcd6fa9cb46a89", + "name": "anaconda-navigator", + "sha256": "49378061271800a5e5d4ee4e49998302c190422ceea08fd8eca4ca10fba1c539", + "size": 4476726, + "subdir": "linux-64", + "timestamp": 1543860117695, + "version": "1.9.4" + }, + "anaconda-navigator-1.9.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "539d7d0cba195089274c623b2739ac6a", + "name": "anaconda-navigator", + "sha256": "fbac3596ea75cedf68694b6bc3868ebcce3abeaf352d9e3dbce23e0cf9d84ca3", + "size": 4479113, + "subdir": "linux-64", + "timestamp": 1543860102357, + "version": "1.9.4" + }, + "anaconda-navigator-1.9.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "ab330214ce353a16b8d2cdd12966fa7e", + "name": "anaconda-navigator", + "sha256": "fda8ea5bd94627fe756cca85de4b8fd4d3ca82fba1d7c6f2ae529274b3307957", + "size": 4477360, + "subdir": "linux-64", + "timestamp": 1544841515790, + "version": "1.9.6" + }, + "anaconda-navigator-1.9.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "89698c279ea904dd23ec0f8d7be6d796", + "name": "anaconda-navigator", + "sha256": "ad11c7126501e1ac625ac0b4f122460b45f7dd6b4e868596b283f2f71e483e7d", + "size": 4477804, + "subdir": "linux-64", + "timestamp": 1544841528268, + "version": "1.9.6" + }, + "anaconda-navigator-1.9.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "883c5f745bee0a13bd682617585c1a17", + "name": "anaconda-navigator", + "sha256": "722a88a1d43451242fb2103669a63817ed1d4ff07ef3c6eb3fe5f8cbba3e7178", + "size": 4480256, + "subdir": "linux-64", + "timestamp": 1544841607254, + "version": "1.9.6" + }, + "anaconda-navigator-1.9.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=2.7,<2.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "d0561d8c69d775cce14e5dc554a73676", + "name": "anaconda-navigator", + "sha256": "e1807a0dab58d70d306fe0ebc0b80a9d6a6680f78f070909744f7ebb0ffbf3c8", + "size": 4485118, + "subdir": "linux-64", + "timestamp": 1553808090876, + "version": "1.9.7" + }, + "anaconda-navigator-1.9.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "a9815936faf40e30be8b0508e2cd5acc", + "name": "anaconda-navigator", + "sha256": "2b622a0bec6dcdea7fd6d8942370652d2c112593677473db84d706b762c80da3", + "size": 4480340, + "subdir": "linux-64", + "timestamp": 1553807898596, + "version": "1.9.7" + }, + "anaconda-navigator-1.9.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml", + "qtpy >=1.4.1", + "requests", + "setuptools" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "304f77c7de08101505201a6cd754e165", + "name": "anaconda-navigator", + "sha256": "9af2e304d2a5864a1b1a7290c80b75c5f834dce406158400bc1b3eb3c5014811", + "size": 4480507, + "subdir": "linux-64", + "timestamp": 1553807946513, + "version": "1.9.7" + }, + "anaconda-navigator-2.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "01310e39e42b8633d584d748565dc479", + "name": "anaconda-navigator", + "sha256": "348258ccd6ea5b89ec9ebf4802cb13bf7ea85caccae62868ea8ab09c433130bb", + "size": 5445250, + "subdir": "linux-64", + "timestamp": 1619555576218, + "version": "2.0.1" + }, + "anaconda-navigator-2.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "d12c6da09dfdd3835c2d22b845801c76", + "name": "anaconda-navigator", + "sha256": "1624bbac1cf4205d003f07b60b75899b7964b9eff540825d90b5f01b3d2f7bc9", + "size": 5445679, + "subdir": "linux-64", + "timestamp": 1619551892953, + "version": "2.0.1" + }, + "anaconda-navigator-2.0.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "22fed74948e386f7b72bd2c4fd593655", + "name": "anaconda-navigator", + "sha256": "d74a8f7b9338cc0e044595757ca4e2be93c485ab684ee8aedc5df96dc4e66238", + "size": 5449838, + "subdir": "linux-64", + "timestamp": 1619555584477, + "version": "2.0.1" + }, + "anaconda-navigator-2.0.1-py39_0.conda": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "374f91495cb08c8115b11da58a84833c", + "name": "anaconda-navigator", + "sha256": "992b80a95066fe828d16370b6939dde941ef5fb26cc51cffa40f53b96defb1fb", + "size": 5452282, + "subdir": "linux-64", + "timestamp": 1619555575897, + "version": "2.0.1" + }, + "anaconda-navigator-2.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "29c9926806ce41fc4eb032f9ce63320e", + "name": "anaconda-navigator", + "sha256": "fe7cb9cf69c4f5d2f5ed9227d2fc21ae47c33c0fc84be6234efb52d69f1a2dee", + "size": 5445448, + "subdir": "linux-64", + "timestamp": 1620241072957, + "version": "2.0.3" + }, + "anaconda-navigator-2.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "30110efbf5183c3c9dffef390e3d00fb", + "name": "anaconda-navigator", + "sha256": "48feaaa48c3446d2e25a9ff4e87d312f109f61816700f3fda0cd6388a1ec0c6a", + "size": 5451553, + "subdir": "linux-64", + "timestamp": 1620244740967, + "version": "2.0.3" + }, + "anaconda-navigator-2.0.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "66a88da164e186d8b9f69205488d1a32", + "name": "anaconda-navigator", + "sha256": "352826ee9408755e555ab6894b38f52da76dd003f295b19bbc2b71b53b4a95d6", + "size": 5452833, + "subdir": "linux-64", + "timestamp": 1620245110376, + "version": "2.0.3" + }, + "anaconda-navigator-2.0.3-py39_0.conda": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "b16ed7f9535508d3c559be10b536cf3a", + "name": "anaconda-navigator", + "sha256": "05e7300b8d8293d8b026a8fa2c8861a8aecd5dc9292c000a158720d73a7fc02a", + "size": 5449559, + "subdir": "linux-64", + "timestamp": 1620245089868, + "version": "2.0.3" + }, + "anaconda-navigator-2.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "f1898d3f38ecfd1956520f131a392bf8", + "name": "anaconda-navigator", + "sha256": "02d06acace2cde6f41ae5e755b58f5564d39848384b0cc8048c965a9c8d6e0c5", + "size": 5386966, + "subdir": "linux-64", + "timestamp": 1626167384329, + "version": "2.0.4" + }, + "anaconda-navigator-2.0.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "263f1a9712cb8bd7cecce89edb59ca37", + "name": "anaconda-navigator", + "sha256": "e9324c0413a563654abd17efe2d15b74f11f1f4a2e1b9312a17332f60c7c67d4", + "size": 5396334, + "subdir": "linux-64", + "timestamp": 1626167547722, + "version": "2.0.4" + }, + "anaconda-navigator-2.0.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "846876aea2ece9c9aee4d41a6caab2e2", + "name": "anaconda-navigator", + "sha256": "4edd896fdd1b89a5c01a81939c082cad9c793e581fe4276e3a9ae6f55c14fa8b", + "size": 5396221, + "subdir": "linux-64", + "timestamp": 1626167545661, + "version": "2.0.4" + }, + "anaconda-navigator-2.0.4-py39_0.conda": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyqt >=5.6,<5.15", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "3b2d8874f173b2dc35698551c21c607e", + "name": "anaconda-navigator", + "sha256": "f46bd561c2e2cb946c9a5510db0f01bf4ea6ae6c193b961b36782f275c170fb5", + "size": 5398708, + "subdir": "linux-64", + "timestamp": 1626167557168, + "version": "2.0.4" + }, + "anaconda-navigator-2.1.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "8c0948e72360010bca6399c2474f0b80", + "name": "anaconda-navigator", + "sha256": "e40a97d76526160d006d76b2dcb114910e88a782bc3b89ee3ab7a37a85041ef1", + "size": 5571182, + "subdir": "linux-64", + "timestamp": 1632168954719, + "version": "2.1.0" + }, + "anaconda-navigator-2.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "9ac5728c3e162b1eae23be917ee9f12c", + "name": "anaconda-navigator", + "sha256": "657d30c789c1613f4aea46c9e8a66a18b053b5c7c3cc3e6804d5c0e7829fd3fb", + "size": 5568664, + "subdir": "linux-64", + "timestamp": 1632158876414, + "version": "2.1.0" + }, + "anaconda-navigator-2.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "a81ae8f5de7fc793cdf9e0dd68035286", + "name": "anaconda-navigator", + "sha256": "18d003bb8a0cdc66c4ae378dcece499e0f79745bc8103a068e54b02fa1b0215c", + "size": 5571054, + "subdir": "linux-64", + "timestamp": 1632168933600, + "version": "2.1.0" + }, + "anaconda-navigator-2.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "590e7ca7c1cf18e3cb31375de89bbbf6", + "name": "anaconda-navigator", + "sha256": "54519dae4edb2e103626a4b9f066dc48d5640d6fed5b21f93450687862d3e0ee", + "size": 5574471, + "subdir": "linux-64", + "timestamp": 1632168935833, + "version": "2.1.0" + }, + "anaconda-navigator-2.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "ujson", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "56aba260754e0168508cc87366fd07d3", + "name": "anaconda-navigator", + "sha256": "4ea36dc5036fb5d4e10c9976194b8fc1b3704b7d29e187f176ee7b082f804436", + "size": 5588693, + "subdir": "linux-64", + "timestamp": 1636985566974, + "version": "2.1.1" + }, + "anaconda-navigator-2.1.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "ujson", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "808c0c130abb045748aa56272dd5926f", + "name": "anaconda-navigator", + "sha256": "92c8d08f8d5ca0702c1ea1c287ddf846eabec21a8b1489e7c1b84b24ac63db8d", + "size": 5588375, + "subdir": "linux-64", + "timestamp": 1636973071857, + "version": "2.1.1" + }, + "anaconda-navigator-2.1.1-py39_0.conda": { + "build": "py39_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.6.14", + "chardet", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow", + "psutil", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "qtpy >=1.4.1", + "requests", + "setuptools", + "ujson", + "xmltodict" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "e4637eeff828f416ce2dc18b53ca9d16", + "name": "anaconda-navigator", + "sha256": "22efcd8b6eb223effcebb2d2b8752b1fcb57d60a1a3e5b234f264201e1086f7c", + "size": 5600735, + "subdir": "linux-64", + "timestamp": 1636985570308, + "version": "2.1.1" + }, + "anaconda-navigator-2.1.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.2", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0", + "urllib3 >=1.26.4", + "libxml2 >=2.9.10", + "expat >=2.2.8" + ], + "depends": [ + "anaconda-client >=1.6.14", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "4cc834b096689aec60367ecd27acf052", + "name": "anaconda-navigator", + "sha256": "beeb9bfeeaaeaa7efd0b050ba665b3dcfed0dbb76671d5b484a9c343ef6265b2", + "size": 5512545, + "subdir": "linux-64", + "timestamp": 1645725779508, + "version": "2.1.2" + }, + "anaconda-navigator-2.1.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "libxml2 >=2.9.10", + "cryptography >=3.3.2", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0" + ], + "depends": [ + "anaconda-client >=1.6.14", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "adea00fd225e89edab26bb32bc525785", + "name": "anaconda-navigator", + "sha256": "11f298e0dc4920dee409353e7d0041f60f37c52716ba8231f00e660d282520f3", + "size": 5523258, + "subdir": "linux-64", + "timestamp": 1645707648819, + "version": "2.1.2" + }, + "anaconda-navigator-2.1.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl >=1.1.1k", + "libxml2 >=2.9.10", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "pyopenssl >=17.5.0", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "e71457ef5c4ef882aee27d39e41851f5", + "name": "anaconda-navigator", + "sha256": "22e2020bfbeb0d7060b166cdf3dba78b8b683e62e09b9372bb3946220af1164f", + "size": 5520930, + "subdir": "linux-64", + "timestamp": 1645725774874, + "version": "2.1.2" + }, + "anaconda-navigator-2.1.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=17.5.0", + "expat >=2.2.8", + "cryptography >=3.3.2", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "libxml2 >=2.9.10" + ], + "depends": [ + "anaconda-client >=1.6.14", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "932adf07d2a9c0095ba70701b265d1e4", + "name": "anaconda-navigator", + "sha256": "5d30ae8032d7de99df769d2f3f7986fdb0727e2847ec53ee02b26bd52a0aec5b", + "size": 5336492, + "subdir": "linux-64", + "timestamp": 1648477412106, + "version": "2.1.4" + }, + "anaconda-navigator-2.1.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl >=1.1.1k", + "pyopenssl >=17.5.0", + "urllib3 >=1.26.4", + "libxml2 >=2.9.10", + "expat >=2.2.8", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "68cf7aa07e697057593f3386d94bbec3", + "name": "anaconda-navigator", + "sha256": "2e2cb28cd2ac33a9236a9a04e525acb066e4f69969205c58ef6ee569c89e8d0d", + "size": 5330864, + "subdir": "linux-64", + "timestamp": 1648459548808, + "version": "2.1.4" + }, + "anaconda-navigator-2.1.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "libxml2 >=2.9.10", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0", + "urllib3 >=1.26.4", + "expat >=2.2.8", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "2f5e8b57c767db75e7a8319181f3fb12", + "name": "anaconda-navigator", + "sha256": "8cba45d8789ba81b041ccbb6bb76954da0981d3f07c4cd4283cbdd853bcc2970", + "size": 5336500, + "subdir": "linux-64", + "timestamp": 1648477410209, + "version": "2.1.4" + }, + "anaconda-navigator-2.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.2", + "libxml2 >=2.9.10", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0" + ], + "depends": [ + "anaconda-client >=1.6.14", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "3a2bb3cf2a6b353ff4ebc885b1aec38b", + "name": "anaconda-navigator", + "sha256": "fa30608f44027d77e0172f6e1004393068fa3341c21792006188743e1085fc1e", + "size": 5392379, + "subdir": "linux-64", + "timestamp": 1653376703152, + "version": "2.2.0" + }, + "anaconda-navigator-2.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.2", + "libxml2 >=2.9.10", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0" + ], + "depends": [ + "anaconda-client >=1.6.14", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "8629ace4fa209a8f341961caa675d70f", + "name": "anaconda-navigator", + "sha256": "8c07daec8b8a17cc866f43e314259d09b5f00cb639a5e41220f9b42c53b915c2", + "size": 5396403, + "subdir": "linux-64", + "timestamp": 1653376749882, + "version": "2.2.0" + }, + "anaconda-navigator-2.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.2", + "libxml2 >=2.9.10", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0" + ], + "depends": [ + "anaconda-client >=1.6.14", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<5.15", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "65c3b98125bdc2cdc361e1147361501e", + "name": "anaconda-navigator", + "sha256": "8645c265f4dd998e2f6634de1e988d8937257c1c93d9362a19fe59c19b122d52", + "size": 5396724, + "subdir": "linux-64", + "timestamp": 1653376650070, + "version": "2.2.0" + }, + "anaconda-navigator-2.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl >=1.1.1k", + "cryptography >=3.3.2", + "pyopenssl >=17.5.0", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "libxml2 >=2.9.10" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "e281c0fab01a2f67cb1b2b2c256d5318", + "name": "anaconda-navigator", + "sha256": "2def85fefa5e29de806914d3d4a9288674b811a15e65ce98223a9fa7a0ec431f", + "size": 5473771, + "subdir": "linux-64", + "timestamp": 1662652275105, + "version": "2.3.0" + }, + "anaconda-navigator-2.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl >=1.1.1k", + "cryptography >=3.3.2", + "pyopenssl >=17.5.0", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "libxml2 >=2.9.10" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "ade28aca30ac2b47d2d142a0bee900ff", + "name": "anaconda-navigator", + "sha256": "c22d3684e9f94a0c4b712d30c46cf1bad7ba9439cc1d5f815163cd1240a5cde0", + "size": 5463119, + "subdir": "linux-64", + "timestamp": 1662652374798, + "version": "2.3.0" + }, + "anaconda-navigator-2.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl >=1.1.1k", + "cryptography >=3.3.2", + "pyopenssl >=17.5.0", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "libxml2 >=2.9.10" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "94f0dc525ad3ca4eb9eb5531d8c9d8e6", + "name": "anaconda-navigator", + "sha256": "165d71d206c63253434f48924438c20daa2299c0e43f1dab1c9c02d6679580b4", + "size": 5465436, + "subdir": "linux-64", + "timestamp": 1662652324251, + "version": "2.3.0" + }, + "anaconda-navigator-2.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl >=1.1.1k", + "cryptography >=3.3.2", + "pyopenssl >=17.5.0", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "libxml2 >=2.9.10" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "cea653a913953a1e93521635049e85e3", + "name": "anaconda-navigator", + "sha256": "bcc6bf047862309ed0054206888a77c18b11cc930ab3d779024b0118f641c876", + "size": 5465947, + "subdir": "linux-64", + "timestamp": 1662652197748, + "version": "2.3.0" + }, + "anaconda-navigator-2.3.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "libxml2 >=2.9.10", + "expat >=2.2.8", + "cryptography >=3.3.2", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "6b3b8054527a03285e8bafcfd75fe7ac", + "name": "anaconda-navigator", + "sha256": "11a794e1ab7dc10b87c083ede8adb35405e68fcf9c4f75d909c3bebac439c31d", + "size": 5474009, + "subdir": "linux-64", + "timestamp": 1664460760359, + "version": "2.3.1" + }, + "anaconda-navigator-2.3.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "libxml2 >=2.9.10", + "expat >=2.2.8", + "cryptography >=3.3.2", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "73407d8e5dd200f8e0128c941875f87f", + "name": "anaconda-navigator", + "sha256": "49a629e32026d3ff99ea5acf53b231bea0e24669d9fbf8b2a299ba756722e748", + "size": 5464006, + "subdir": "linux-64", + "timestamp": 1664460811085, + "version": "2.3.1" + }, + "anaconda-navigator-2.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "libxml2 >=2.9.10", + "expat >=2.2.8", + "cryptography >=3.3.2", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "ff078b459d24cca05f2ab31ef0c5401e", + "name": "anaconda-navigator", + "sha256": "6da49c1aa6891826714e4d0c0044ca965ac3565e24ea0b694c902fc91786a0b3", + "size": 5468108, + "subdir": "linux-64", + "timestamp": 1664460901271, + "version": "2.3.1" + }, + "anaconda-navigator-2.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "libxml2 >=2.9.10", + "expat >=2.2.8", + "cryptography >=3.3.2", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "pyopenssl >=17.5.0" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "dc4bda4ab14dfa7cf2ed2e5902b0f6ec", + "name": "anaconda-navigator", + "sha256": "de1f388fba2078f1b812f4e9dfc1a01536613391301b9b55b12a8a26e850433b", + "size": 5467693, + "subdir": "linux-64", + "timestamp": 1664460857519, + "version": "2.3.1" + }, + "anaconda-navigator-2.3.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "expat >=2.2.8", + "pyopenssl >=17.5.0", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "libxml2 >=2.9.10", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "5751d7333cb0b27ab5fec00c19ecf40b", + "name": "anaconda-navigator", + "sha256": "61a1e4f7aeba5ddd58fc314afddd7a2f329c8a97efae7e3e9593ead77fc9ea3a", + "size": 5480728, + "subdir": "linux-64", + "timestamp": 1665154193033, + "version": "2.3.2" + }, + "anaconda-navigator-2.3.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "expat >=2.2.8", + "pyopenssl >=17.5.0", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "libxml2 >=2.9.10", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "61340b218739869c4383ed8932c6be84", + "name": "anaconda-navigator", + "sha256": "47e80bf8d2f77438272755787c43a6983b81b22c99854071a37db6f768f52437", + "size": 5469279, + "subdir": "linux-64", + "timestamp": 1665154241348, + "version": "2.3.2" + }, + "anaconda-navigator-2.3.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "expat >=2.2.8", + "pyopenssl >=17.5.0", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "libxml2 >=2.9.10", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "97847726329d862935020000303ff9de", + "name": "anaconda-navigator", + "sha256": "1132d59f24784a4f90584d463f56d7ff747fd2fe36dbc99c8cf28fcd13e1c89b", + "size": 5471471, + "subdir": "linux-64", + "timestamp": 1665154287866, + "version": "2.3.2" + }, + "anaconda-navigator-2.3.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "expat >=2.2.8", + "pyopenssl >=17.5.0", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "libxml2 >=2.9.10", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda <22.11.0", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "11c050fd6b40f3337c6be71484d36d65", + "name": "anaconda-navigator", + "sha256": "079f944cd79af1be5d06687cd0dee98123239b4752d34257cfa1715e49bbd1c1", + "size": 5472124, + "subdir": "linux-64", + "timestamp": 1665154126313, + "version": "2.3.2" + }, + "anaconda-navigator-2.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=17.5.0", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "libxml2 >=2.9.10", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda !=22.11.*", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "482184b9de72edeedbb5a9ea280bd01c", + "name": "anaconda-navigator", + "sha256": "29c4bc726e9815ac0b07241aa8e86450506dd9d11748ceca95e8ee2821058001", + "size": 5773915, + "subdir": "linux-64", + "timestamp": 1677517204438, + "version": "2.4.0" + }, + "anaconda-navigator-2.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=17.5.0", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "libxml2 >=2.9.10", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda !=22.11.*", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "88fda68ccdcd5b5e0e0c355a17e971ec", + "name": "anaconda-navigator", + "sha256": "0b2718f21788be631bffe834200e258527fb1c1c59059b9d76aee4e3e9db9398", + "size": 5760575, + "subdir": "linux-64", + "timestamp": 1677517251279, + "version": "2.4.0" + }, + "anaconda-navigator-2.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=17.5.0", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "libxml2 >=2.9.10", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda !=22.11.*", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "c7e33d1bcad715d966520fe06b6d7964", + "name": "anaconda-navigator", + "sha256": "8499b7bf5f1fb7e789d660c249861057e1cb566ad79c6b452e1f57490c20c443", + "size": 5761697, + "subdir": "linux-64", + "timestamp": 1677517108772, + "version": "2.4.0" + }, + "anaconda-navigator-2.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=17.5.0", + "expat >=2.2.8", + "urllib3 >=1.26.4", + "openssl >=1.1.1k", + "libxml2 >=2.9.10", + "cryptography >=3.3.2" + ], + "depends": [ + "anaconda-client >=1.6.14", + "attrs >=20.3.0", + "chardet >=3.0.4", + "conda !=22.11.*", + "conda-repo-cli", + "conda-token", + "navigator-updater", + "pillow >=8.2", + "psutil >=5.6.5", + "pyjwt >=2.1.0", + "pyqt >=5.6,<6.0a0", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "requests >=2.20.0", + "setuptools", + "six >=1.15.0", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "12bc581d38440dd2358e094d2074d678", + "name": "anaconda-navigator", + "sha256": "e4a1383a5b4d248b918a460e96164752a429b0942f20dc4196c6301b37600286", + "size": 5762421, + "subdir": "linux-64", + "timestamp": 1677517159436, + "version": "2.4.0" + }, + "anaconda-oss-docs-1.0.1-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "md5": "eb9246ffc6157b130f5fd91072948f4a", + "name": "anaconda-oss-docs", + "sha256": "ffe97f68eae432b57cda28999648a9108c975e51684e172d1a5bae45230b9233", + "size": 177860047, + "subdir": "linux-64", + "timestamp": 1516913566172, + "version": "1.0.1" + }, + "anaconda-oss-docs-1.0.2-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "md5": "e1655244d3ff04bb6bbc7e9813f48ae0", + "name": "anaconda-oss-docs", + "sha256": "80bce5165e0f33de4561741a8a2e518c09805e04832af2593f225c27847a8330", + "size": 216516112, + "subdir": "linux-64", + "timestamp": 1520632294339, + "version": "1.0.2" + }, + "anaconda-project-0.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "conda-pack", + "jinja2", + "python >=3.10,<3.11.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3672f5459a024ff862fd0786f8fd118e", + "name": "anaconda-project", + "sha256": "666d2e66bedf3829bd64f510ffa9ed67ef03e98e2d406c3fa12a3c9cef311f39", + "size": 506418, + "subdir": "linux-64", + "timestamp": 1658929530190, + "version": "0.11.0" + }, + "anaconda-project-0.11.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "conda-pack", + "jinja2", + "python >=3.7,<3.8.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d54a9173562d86eff7d7a10fa6472838", + "name": "anaconda-project", + "sha256": "30d406ad1ed14e8b655b6bbb4548a8072e0fb886668e09829823429b868df6e6", + "size": 498281, + "subdir": "linux-64", + "timestamp": 1658929559737, + "version": "0.11.0" + }, + "anaconda-project-0.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "conda-pack", + "jinja2", + "python >=3.8,<3.9.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a505f83ce7fd0bc80a21380a0010f8bb", + "name": "anaconda-project", + "sha256": "ee94a717cefbee2f0fb5dacc74ec7a0c184e692a2f7590fdc39495b5d96254bf", + "size": 502671, + "subdir": "linux-64", + "timestamp": 1658929489276, + "version": "0.11.0" + }, + "anaconda-project-0.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "conda-pack", + "jinja2", + "python >=3.9,<3.10.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "32d982de306f17d8b11cc0f1d2d010f6", + "name": "anaconda-project", + "sha256": "75fcd9c0ad5cd98b0295f1c2fa78a07f473a1972187e2992fd0a7aa946957b03", + "size": 501206, + "subdir": "linux-64", + "timestamp": 1658929589824, + "version": "0.11.0" + }, + "anaconda-project-0.11.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "conda-pack", + "jinja2", + "python >=3.10,<3.11.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "859e3dcafefe72b2d1933a32ebdbce51", + "name": "anaconda-project", + "sha256": "c384066dbc52c0aeb25444084a96b8d2b52a9d465d89a5a09d8b0e4c5c661e25", + "size": 512241, + "subdir": "linux-64", + "timestamp": 1660340010423, + "version": "0.11.1" + }, + "anaconda-project-0.11.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "conda-pack", + "jinja2", + "python >=3.11,<3.12.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "af5f89a078245be312bf9f0dd1af7d74", + "name": "anaconda-project", + "sha256": "e2861effceddd19ed7215693a4fecf5876844563f1e43297c29228fe9b578930", + "size": 685316, + "subdir": "linux-64", + "timestamp": 1676846743376, + "version": "0.11.1" + }, + "anaconda-project-0.11.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "conda-pack", + "jinja2", + "python >=3.7,<3.8.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c8f7aa7a291383793e48371ab70441c8", + "name": "anaconda-project", + "sha256": "f08ef33778cb769654bd39e269eef43ce0de2b87100c6b69afa2078210a67956", + "size": 504238, + "subdir": "linux-64", + "timestamp": 1660340044818, + "version": "0.11.1" + }, + "anaconda-project-0.11.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "conda-pack", + "jinja2", + "python >=3.8,<3.9.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6e859a643e5da33b412ba320e223cc3a", + "name": "anaconda-project", + "sha256": "a62bf86a9f942132ad093713db95c86a4c490a1f51e3d464d0c74b546e7f074c", + "size": 508017, + "subdir": "linux-64", + "timestamp": 1660339965043, + "version": "0.11.1" + }, + "anaconda-project-0.11.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "conda-pack", + "jinja2", + "python >=3.9,<3.10.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "99be8bfa2e76da1bf5f2e966b53fb157", + "name": "anaconda-project", + "sha256": "0ed2205f7c81979ccb2c4932c99a2c732bd9404599cb174bbcecf9e5341cb4b4", + "size": 505746, + "subdir": "linux-64", + "timestamp": 1660339931462, + "version": "0.11.1" + }, + "anaconda-project-0.8.0-py27hd7a9a97_0.conda": { + "build": "py27hd7a9a97_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=2.7,<2.8.0a0", + "requests", + "ruamel_yaml", + "tornado" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "482b39a7ccb7ecc13dca8053bc9f184a", + "name": "anaconda-project", + "sha256": "015177b57b25bb69dfda43fc334b21bb05e0d06762c3e1dd9a570ecbd70e7a71", + "size": 215842, + "subdir": "linux-64", + "timestamp": 1505852237048, + "version": "0.8.0" + }, + "anaconda-project-0.8.0-py35hb597f32_0.conda": { + "build": "py35hb597f32_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=3.5,<3.6.0a0", + "requests", + "ruamel_yaml", + "tornado" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c5cc4b1dd0d923dc1e5681b09e23f1d5", + "name": "anaconda-project", + "sha256": "fd0ba8b9077e82df2169ce3ebe2cae851e213d190248cc983cdf8fae5eca9f93", + "size": 218978, + "subdir": "linux-64", + "timestamp": 1505852256583, + "version": "0.8.0" + }, + "anaconda-project-0.8.0-py36h29abdf5_0.conda": { + "build": "py36h29abdf5_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=3.6,<3.7.0a0", + "requests", + "ruamel_yaml", + "tornado" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "483fff2b1554b23d49a52cf21808f74e", + "name": "anaconda-project", + "sha256": "b571038aaf2d959839bd89321b392b656e7b64250ca2d9d033d3c39816123aca", + "size": 219846, + "subdir": "linux-64", + "timestamp": 1505852276338, + "version": "0.8.0" + }, + "anaconda-project-0.8.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=2.7,<2.8.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "519d6d085b2a67e61f5a6826d9d61c8a", + "name": "anaconda-project", + "sha256": "5575ccda07631bba0da9a253722a0fcd4a2e1315a53f33f8d6830f1235108c68", + "size": 461842, + "subdir": "linux-64", + "timestamp": 1530737483623, + "version": "0.8.2" + }, + "anaconda-project-0.8.2-py27h236b58a_0.conda": { + "build": "py27h236b58a_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=2.7,<2.8.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "95e58401c3031bc119f3f17e8ab5afe4", + "name": "anaconda-project", + "sha256": "835f79349ec957545d4aea8883adab5ee1e8e7829af8b9095381ce64f4fe2819", + "size": 462350, + "subdir": "linux-64", + "timestamp": 1511980353055, + "version": "0.8.2" + }, + "anaconda-project-0.8.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=3.5,<3.6.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ecc0fcecec4b87ac26b40cb106cf87f9", + "name": "anaconda-project", + "sha256": "ab360bce807d1509b6194f4cead09a6909cfdc61b04f43cbe804d0a7070f64f8", + "size": 467412, + "subdir": "linux-64", + "timestamp": 1534352711805, + "version": "0.8.2" + }, + "anaconda-project-0.8.2-py35h7d62c80_0.conda": { + "build": "py35h7d62c80_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=3.5,<3.6.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "70b54d6e2b77cd9690eedac43b432ce6", + "name": "anaconda-project", + "sha256": "2337a700c1eb109f147e19cb2400138d318b640c2d07df4bb86eed5273023421", + "size": 473528, + "subdir": "linux-64", + "timestamp": 1511980366712, + "version": "0.8.2" + }, + "anaconda-project-0.8.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=3.6,<3.7.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2b065586503ac931f88aec2a21b53e7e", + "name": "anaconda-project", + "sha256": "f213207cc78eb5ecad52ae5282d348d909165766260059eb1d85ff66e3c45f60", + "size": 468238, + "subdir": "linux-64", + "timestamp": 1530737448701, + "version": "0.8.2" + }, + "anaconda-project-0.8.2-py36h44fb852_0.conda": { + "build": "py36h44fb852_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=3.6,<3.7.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4c37c5356b0aeae1395b0f5aeea7880a", + "name": "anaconda-project", + "sha256": "c8bcd137d1bc53444200e284a8b31bdab06bfc99791148bec316df304103d997", + "size": 464039, + "subdir": "linux-64", + "timestamp": 1511980346467, + "version": "0.8.2" + }, + "anaconda-project-0.8.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "python >=3.7,<3.8.0a0", + "requests", + "ruamel_yaml", + "tornado >=4.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2fd8a057852d9aa0d2a308c5079b7f3a", + "name": "anaconda-project", + "sha256": "f197f4b7776ec15a26ac478a22c8882c67a72ebff94d998a751825ccd58f6e82", + "size": 467109, + "subdir": "linux-64", + "timestamp": 1530737521161, + "version": "0.8.2" + }, + "ansi2html-1.2.0-py27h9a6bcf5_0.conda": { + "build": "py27h9a6bcf5_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "General Public License v3.0", + "license_family": "GPL3", + "md5": "65332abd10a9f6613f7775e7b31caac5", + "name": "ansi2html", + "sha256": "364f111a00e9477b229bc2c3f10080feb27ef76a4414e2294cbf1dd1031f6100", + "size": 32173, + "subdir": "linux-64", + "timestamp": 1507576415372, + "version": "1.2.0" + }, + "ansi2html-1.2.0-py35h38623d0_0.conda": { + "build": "py35h38623d0_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "General Public License v3.0", + "license_family": "GPL3", + "md5": "c764d51bce388053c1383b7754979209", + "name": "ansi2html", + "sha256": "dad0bd2281224c7c7d492514215729a9356a4f2754f3c47ac13e8192ac128ce0", + "size": 32595, + "subdir": "linux-64", + "timestamp": 1507576440142, + "version": "1.2.0" + }, + "ansi2html-1.2.0-py36h7be8927_0.conda": { + "build": "py36h7be8927_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "General Public License v3.0", + "license_family": "GPL3", + "md5": "93ba75b53bad4266a3a867be4078fc49", + "name": "ansi2html", + "sha256": "87f49f8d61102b799b2e13d4afad3d7450a4ee52997d958a00332dbbfa6a42fa", + "size": 32449, + "subdir": "linux-64", + "timestamp": 1507576438789, + "version": "1.2.0" + }, + "ansi2html-1.3.0-py27hb02a7bf_0.conda": { + "build": "py27hb02a7bf_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "84e58e990bae5eb09480cd5f82a75c87", + "name": "ansi2html", + "sha256": "a3c74e0b793c7cf83c44b755d42a21aa8c6d9cf4d1e7dd43cadee8a89fcad9f6", + "size": 32179, + "subdir": "linux-64", + "timestamp": 1512033326674, + "version": "1.3.0" + }, + "ansi2html-1.3.0-py35h81cba0a_0.conda": { + "build": "py35h81cba0a_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "8a0e4727df767dd3818980cde35aaa64", + "name": "ansi2html", + "sha256": "a3320e3d31e67e9c9851ef60a7e4875673d2a991dc9454db8299ceb3c6c78ce2", + "size": 32500, + "subdir": "linux-64", + "timestamp": 1512033327264, + "version": "1.3.0" + }, + "ansi2html-1.3.0-py36haaf8d63_0.conda": { + "build": "py36haaf8d63_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "9a51b3119050a76f64ce2ed906e20f82", + "name": "ansi2html", + "sha256": "ebbdd0b17c1019aa45935aa5b2ae240b4a49e7a5c418c115fbe448cb517a3c16", + "size": 32405, + "subdir": "linux-64", + "timestamp": 1512033297870, + "version": "1.3.0" + }, + "ansi2html-1.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "156afe314a0e1cfdc05b6f95c511263b", + "name": "ansi2html", + "sha256": "42ccaaa973acfe7a5568eda99f547895b04a6804df0a2d31b7fba36ac2e8e245", + "size": 32667, + "subdir": "linux-64", + "timestamp": 1523944021068, + "version": "1.4.2" + }, + "ansi2html-1.4.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "24dc21d2105c8e2f192dd6c3a326ce79", + "name": "ansi2html", + "sha256": "ad97c898a86af4360c7c92d8122b1f3ef56181c080101308e11dd035c29e8ab8", + "size": 32881, + "subdir": "linux-64", + "timestamp": 1523944004132, + "version": "1.4.2" + }, + "ansi2html-1.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "6c83971bbb4de4f790a5d382c606d3db", + "name": "ansi2html", + "sha256": "ee5f933cde1e7e62cb6231ea8c7ada532bae82d5d3a2538719d7ce4199ab2c1f", + "size": 32681, + "subdir": "linux-64", + "timestamp": 1523944050920, + "version": "1.4.2" + }, + "ansi2html-1.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "bec326da66493dce8e6a38c775577c2a", + "name": "ansi2html", + "sha256": "9dcff12b07fe6d92e29326489b146b0ce22b331d994bb4178ad1d69a371eccda", + "size": 32442, + "subdir": "linux-64", + "timestamp": 1530737551994, + "version": "1.4.2" + }, + "ansi2html-1.5.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "c800984184cf4b6a05de9875d85ca926", + "name": "ansi2html", + "sha256": "aa5ae266c724120a67b96c3fbba2b73e4a6831b9dfdd4284ac17caf548dc9fec", + "size": 34175, + "subdir": "linux-64", + "timestamp": 1540956030819, + "version": "1.5.2" + }, + "ansi2html-1.5.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "f015fc1dc529d5c4d44336975e03273e", + "name": "ansi2html", + "sha256": "298459faf910c556ca128f60775f4cbd4138df1a9b14090350fe2bdbe983c1cb", + "size": 34131, + "subdir": "linux-64", + "timestamp": 1640788105362, + "version": "1.5.2" + }, + "ansi2html-1.5.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "6365a15c9733a82c446ae0435b3c5fed", + "name": "ansi2html", + "sha256": "ddf49b8b5f033d66de200dbb08a7a520b63fdc595eb9803675d81c049f596419", + "size": 39944, + "subdir": "linux-64", + "timestamp": 1676906868140, + "version": "1.5.2" + }, + "ansi2html-1.5.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "b55be860ab74ff8b8e8b137b51b04016", + "name": "ansi2html", + "sha256": "5319ebcf7d14b542cf951a9fb8ff3592e2f836414fd9f5b1c1f4016127b1203c", + "size": 34363, + "subdir": "linux-64", + "timestamp": 1540956036923, + "version": "1.5.2" + }, + "ansi2html-1.5.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "61f3fd2e555c196f5e35d3adc613ac0c", + "name": "ansi2html", + "sha256": "bf50149802cd09c0f7ca060c4ea279b8893d53139b81adbf98aa3c1294b75285", + "size": 270838, + "subdir": "linux-64", + "timestamp": 1613036330166, + "version": "1.5.2" + }, + "ansi2html-1.5.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "c911043be910f82af71afb753e56a350", + "name": "ansi2html", + "sha256": "d99e02e28f65196901a94446b2e9705e83838609bcbebfcddd619ebf17fce668", + "size": 34256, + "subdir": "linux-64", + "timestamp": 1540956031369, + "version": "1.5.2" + }, + "ansi2html-1.5.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "d5d3960ef716427b1d1e4ca7840d4f01", + "name": "ansi2html", + "sha256": "9ae7a8a4d089624fe52dd9749794c757026926db5c898e72cb003111b0543b8f", + "size": 271843, + "subdir": "linux-64", + "timestamp": 1613036317889, + "version": "1.5.2" + }, + "ansi2html-1.5.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "ba6ee06fe7fa9de34c4feeb3a2123e23", + "name": "ansi2html", + "sha256": "f94f9fd72db9164cf6c3815640cbe4026da20e648c5764bdf9484ad62b75ea53", + "size": 34463, + "subdir": "linux-64", + "timestamp": 1574097791164, + "version": "1.5.2" + }, + "ansi2html-1.5.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "33ac305d89e5b92323263c90f8968b54", + "name": "ansi2html", + "sha256": "402b67a7b94eafc260de911967ff68932be864d5f162e8be14d25c4611a00fa8", + "size": 271437, + "subdir": "linux-64", + "timestamp": 1613036318366, + "version": "1.5.2" + }, + "ansi2html-1.5.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "six" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "031a95f0922d6eaa4a01acb848de1ab2", + "name": "ansi2html", + "sha256": "aae6d489bc6ce4d661f4a684051740276e72ce2bca94fdb7f104ac1007a48c10", + "size": 271180, + "subdir": "linux-64", + "timestamp": 1613035573249, + "version": "1.5.2" + }, + "ansi2html-1.8.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "159b1aee4746c232de18363b30f6e997", + "name": "ansi2html", + "sha256": "873127f2e00190cc107efc077d03fe8cb5ee600b19aff3aeaf0d438392386f97", + "size": 43894, + "subdir": "linux-64", + "timestamp": 1678961260267, + "version": "1.8.0" + }, + "ansi2html-1.8.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "932fc50ae97225b38ded87081bc3adfc", + "name": "ansi2html", + "sha256": "77249e467802933b087af109c3abf6d72cdce332b29ec49239ceba895e0a6fd5", + "size": 51626, + "subdir": "linux-64", + "timestamp": 1678961207688, + "version": "1.8.0" + }, + "ansi2html-1.8.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "1afc28fc23c70746e79063a4e1576cfe", + "name": "ansi2html", + "sha256": "9efda22682cc7d11e4e5d607d8621d5daabb03d9001222641e4874ad81ac0a78", + "size": 43746, + "subdir": "linux-64", + "timestamp": 1678961180675, + "version": "1.8.0" + }, + "ansi2html-1.8.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "46d73ff94b7463d76d56fb476cf81543", + "name": "ansi2html", + "sha256": "8b14e6335a22418687bd2ab563c79551cf92447f10d89fd87639470705c8639c", + "size": 43659, + "subdir": "linux-64", + "timestamp": 1678961233272, + "version": "1.8.0" + }, + "ant-1.10.8-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "openjdk" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ca1edcd4afda06f67652b7a2fd05a9fb", + "name": "ant", + "sha256": "8114ed0f3d70def1fad16c106071c5d6b05532255ffd011147ccfb6299fbda1d", + "size": 2627284, + "subdir": "linux-64", + "timestamp": 1631882736310, + "version": "1.10.8" + }, + "ant-1.9.9-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "openjdk" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "459be1fbfd383a7d7b8c610ad47e45d9", + "name": "ant", + "sha256": "cdd0cc62d76a550b7110db24537f19fb9098396a030c12ce5ae223ed4d1981a1", + "size": 2078744, + "subdir": "linux-64", + "timestamp": 1516111132973, + "version": "1.9.9" + }, + "anyio-2.0.2-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "constrains": [ + "trio >=0.16", + "curio >=1.4" + ], + "depends": [ + "async_generator", + "dataclasses", + "idna >=2.8", + "python >=3.6,<3.7.0a0", + "sniffio >=1.1", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9056e801e6df44a61338b9c9e48d5247", + "name": "anyio", + "sha256": "e5111b55dcfb36cd31d406f9f4c75417796bfb34d7322e9e5d8acb02dcef374c", + "size": 120249, + "subdir": "linux-64", + "timestamp": 1616017052845, + "version": "2.0.2" + }, + "anyio-2.0.2-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.7,<3.8.0a0", + "sniffio >=1.1", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b5d8953b8a8561f4c5f4bee06c56d15", + "name": "anyio", + "sha256": "56e4814ef92fef9fd90a43c377ea3e84ef66299974ba14dcb68507ec8bfc9f8b", + "size": 119734, + "subdir": "linux-64", + "timestamp": 1616015142117, + "version": "2.0.2" + }, + "anyio-2.0.2-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "constrains": [ + "trio >=0.16", + "curio >=1.4" + ], + "depends": [ + "idna >=2.8", + "python >=3.8,<3.9.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9690a4284f60eca83e800f5c52345620", + "name": "anyio", + "sha256": "cc83460d12c9349190fb56be6f31aa85efaff7689df1478c72bcd4fc44aaf7b0", + "size": 121408, + "subdir": "linux-64", + "timestamp": 1616016581817, + "version": "2.0.2" + }, + "anyio-2.0.2-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "constrains": [ + "trio >=0.16", + "curio >=1.4" + ], + "depends": [ + "idna >=2.8", + "python >=3.9,<3.10.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ddcbdb357f72885cd36d4afcfd0e5a8", + "name": "anyio", + "sha256": "b2cf205813ba139cfa9bf04e0d2afdef2856e4caea27494bb628302f1c06d85c", + "size": 120294, + "subdir": "linux-64", + "timestamp": 1616017051405, + "version": "2.0.2" + }, + "anyio-2.1.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "async_generator", + "dataclasses", + "idna >=2.8", + "python >=3.6,<3.7.0a0", + "sniffio >=1.1", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "908a9159c194d519fd69fd77bc9b6754", + "name": "anyio", + "sha256": "72a5947e37c3d99fab7443719bc00a213214bdbb488f3189a9ced3678ce09cda", + "size": 119610, + "subdir": "linux-64", + "timestamp": 1616176646585, + "version": "2.1.0" + }, + "anyio-2.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "trio >=0.16", + "curio >=1.4" + ], + "depends": [ + "idna >=2.8", + "python >=3.7,<3.8.0a0", + "sniffio >=1.1", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "656960a61ee21c9602e3a7b0ee807578", + "name": "anyio", + "sha256": "e819f3b45000e69f44e2fda50616cbbf2d8f903ae7544ff31be2735b1be22f86", + "size": 121165, + "subdir": "linux-64", + "timestamp": 1616174653938, + "version": "2.1.0" + }, + "anyio-2.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.8,<3.9.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e3274c8d45583249bd6d804604f2151", + "name": "anyio", + "sha256": "2b6d0c00198b771d2be204af1ab4ab3046bf5e3ee524a69d3b8d8edb946beacf", + "size": 121367, + "subdir": "linux-64", + "timestamp": 1616176645255, + "version": "2.1.0" + }, + "anyio-2.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.9,<3.10.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "350969db3633987e593bf2f792853399", + "name": "anyio", + "sha256": "bb4c69baff893d6082dce64aa4a323de34da7984a8d87ab288ab2eef1555e22e", + "size": 120988, + "subdir": "linux-64", + "timestamp": 1616176642548, + "version": "2.1.0" + }, + "anyio-2.2.0-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "constrains": [ + "trio >=0.16", + "curio >=1.4" + ], + "depends": [ + "idna >=2.8", + "python >=3.10,<3.11.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0ff39d446806302df6c39d28aa3439d", + "name": "anyio", + "sha256": "b70332298227bad7410e9cc499226534b4564b2d0523b1007383c364f24529c5", + "size": 127402, + "subdir": "linux-64", + "timestamp": 1641551281407, + "version": "2.2.0" + }, + "anyio-2.2.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "trio >=0.16", + "curio >=1.4" + ], + "depends": [ + "async_generator", + "dataclasses", + "idna >=2.8", + "python >=3.6,<3.7.0a0", + "sniffio >=1.1", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1abc3e5edf63a1f7c1a091983ec495c", + "name": "anyio", + "sha256": "19c9b4323e1d82d185060c6388ee3ca92df57dfc51a4c243f365fffff5fc5166", + "size": 123178, + "subdir": "linux-64", + "timestamp": 1616177531626, + "version": "2.2.0" + }, + "anyio-2.2.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "constrains": [ + "trio >=0.16", + "curio >=1.4" + ], + "depends": [ + "async_generator", + "dataclasses", + "idna >=2.8", + "python >=3.6,<3.7.0a0", + "sniffio >=1.1", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d213d20889c842653a8f16249c532cc", + "name": "anyio", + "sha256": "5756aa8eb14fa03fc46eaf8c9971a8454d0034e803251f0e846f963804e6ad2d", + "size": 127152, + "subdir": "linux-64", + "timestamp": 1617783327676, + "version": "2.2.0" + }, + "anyio-2.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.7,<3.8.0a0", + "sniffio >=1.1", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4444286ee3f8ee4c13375f85df75cb0", + "name": "anyio", + "sha256": "e127cd3a75c5edd0e376942248b907410a4952f6a123e890d67322df1a2fe5f8", + "size": 122070, + "subdir": "linux-64", + "timestamp": 1616177799105, + "version": "2.2.0" + }, + "anyio-2.2.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.7,<3.8.0a0", + "sniffio >=1.1", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "81ce7a201c26a2dee17a09bb7b78fdf2", + "name": "anyio", + "sha256": "b605729f9b333ad0eeb2a2f0d896afdb2cbf54b8299b20958eb2bf7ce08af38b", + "size": 125833, + "subdir": "linux-64", + "timestamp": 1617783315538, + "version": "2.2.0" + }, + "anyio-2.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.8,<3.9.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4658ee58a5358ec778e778877388c65", + "name": "anyio", + "sha256": "6825b82232fec932fb2af23ea23674d752b82a13178ddaa5219d53f2b92ad80b", + "size": 122666, + "subdir": "linux-64", + "timestamp": 1616177804582, + "version": "2.2.0" + }, + "anyio-2.2.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.8,<3.9.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b07f32aaa14d46a73df2b269959c11ed", + "name": "anyio", + "sha256": "fd03a970761152f1bd4f8a58bfc25aa3054319bfb478b53d6535b2b1020f418a", + "size": 128098, + "subdir": "linux-64", + "timestamp": 1617783319863, + "version": "2.2.0" + }, + "anyio-2.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.9,<3.10.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f66a81cc720edb9f879ca5ba6ae36ead", + "name": "anyio", + "sha256": "6c3d1964e3546f4bef78a8bccb09ba07f6d09df201fd56c991c3ec2db0ddd3d9", + "size": 124566, + "subdir": "linux-64", + "timestamp": 1616175815468, + "version": "2.2.0" + }, + "anyio-2.2.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "curio >=1.4", + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.9,<3.10.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39d777bbbb848f547fb1e7925a256615", + "name": "anyio", + "sha256": "2e17ba3272c7f3ad944c79d93a9c198c97a9da67c8733fa62b65a629c0963ec6", + "size": 127750, + "subdir": "linux-64", + "timestamp": 1617783322568, + "version": "2.2.0" + }, + "anyio-3.5.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.10,<3.11.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fab2355c6822f8ec97a428e93f87a6c5", + "name": "anyio", + "sha256": "8d5e5c8c3d465255864ad8c0a69cc876bbf0adff8589e7542b266308bf0e2014", + "size": 172181, + "subdir": "linux-64", + "timestamp": 1644481743158, + "version": "3.5.0" + }, + "anyio-3.5.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.11,<3.12.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16fa44a3dc87d1d931c865cfa652601c", + "name": "anyio", + "sha256": "2393c664d4c0db866edbcb4c8c86e886f1aa8bcd7693b50df2107c13716f9e91", + "size": 219377, + "subdir": "linux-64", + "timestamp": 1676823785292, + "version": "3.5.0" + }, + "anyio-3.5.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.7,<3.8.0a0", + "sniffio >=1.1", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6489413ceaef9b798796c5abf525d2f0", + "name": "anyio", + "sha256": "1ac5b95653bd268c270f147d017b3e7a1c37f6ae829ff57508b994dbb58753bb", + "size": 169327, + "subdir": "linux-64", + "timestamp": 1644481739584, + "version": "3.5.0" + }, + "anyio-3.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.8,<3.9.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85440472f52d5b17de2ca8d27d41d21d", + "name": "anyio", + "sha256": "09cd1c0e0821edb34ef03418ddf1cc920001cfbbcf212c00cea13c7af5d0d007", + "size": 168941, + "subdir": "linux-64", + "timestamp": 1644481732835, + "version": "3.5.0" + }, + "anyio-3.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "trio >=0.16" + ], + "depends": [ + "idna >=2.8", + "python >=3.9,<3.10.0a0", + "sniffio >=1.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6be85241d4cccd0bdc2786ed7d0d817a", + "name": "anyio", + "sha256": "ad5e086f2426e3d42430e4e66abbb85a37f9991769d373302558544f997a2908", + "size": 170784, + "subdir": "linux-64", + "timestamp": 1644463608931, + "version": "3.5.0" + }, + "anyjson-0.3.3-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ce769a3bca79805d5d1dff8855983ac3", + "name": "anyjson", + "sha256": "2e2380c53d28df466b89e095c9350f1cfca67a6fef14c56d014f6e55fd6df282", + "size": 9993, + "subdir": "linux-64", + "timestamp": 1530737594719, + "version": "0.3.3" + }, + "anyjson-0.3.3-py27hdf0fd94_1.conda": { + "build": "py27hdf0fd94_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7357cbacba46485550d1b25fbb4be9b2", + "name": "anyjson", + "sha256": "9d570fc4fd44c65df8025276a92f6fd0eba3f3d2cd757ef590d7bd5852a70d8e", + "size": 9761, + "subdir": "linux-64", + "timestamp": 1505693661176, + "version": "0.3.3" + }, + "anyjson-0.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "be693435a76221000f887a8f15c89029", + "name": "anyjson", + "sha256": "7fb9a5b47704698a35ae546531c1740c35d09f88b797c5f640282a8ee30db346", + "size": 10316, + "subdir": "linux-64", + "timestamp": 1641552318774, + "version": "0.3.3" + }, + "anyjson-0.3.3-py310h06a4308_1002.conda": { + "build": "py310h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "345d26ec6b4f33d0869b54912f8ee4b7", + "name": "anyjson", + "sha256": "b0c9d20882a312bd3546788a5faedae905d059ced1b631ecdc629b0f6729fc19", + "size": 13003, + "subdir": "linux-64", + "timestamp": 1659702775213, + "version": "0.3.3" + }, + "anyjson-0.3.3-py311h06a4308_1002.conda": { + "build": "py311h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c27a392ea1ea1ee1f80e15585adc04a4", + "name": "anyjson", + "sha256": "fa3f8a280460b33820fbaf05acefc72793db4d218fda8ca32fe3f4c44fa9e4d9", + "size": 13864, + "subdir": "linux-64", + "timestamp": 1676826945247, + "version": "0.3.3" + }, + "anyjson-0.3.3-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d5d6f221a229ad7273850c94e73513c5", + "name": "anyjson", + "sha256": "ebefff316e98ee4c22c00f3776d736bcdf5242a02923586715aea29e7e903796", + "size": 10054, + "subdir": "linux-64", + "timestamp": 1534352749216, + "version": "0.3.3" + }, + "anyjson-0.3.3-py35h3cd284d_1.conda": { + "build": "py35h3cd284d_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b108b3a0a9e1308cb7fb4fec1934f18d", + "name": "anyjson", + "sha256": "cb0393527d7236d700ebd37f7a76d9f2a1d75aeee4fa34479864302be80064da", + "size": 9884, + "subdir": "linux-64", + "timestamp": 1505693672797, + "version": "0.3.3" + }, + "anyjson-0.3.3-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "85256fcf106b3d9b0ef9af4fffd7a5d3", + "name": "anyjson", + "sha256": "b19cf17fa66d5ff83e219f4eef7404199cc08585d6697ab48e0257e5ae17aaf6", + "size": 9995, + "subdir": "linux-64", + "timestamp": 1530737574415, + "version": "0.3.3" + }, + "anyjson-0.3.3-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "efcd9fcdb4ab749b4dfc9abd5d28e82f", + "name": "anyjson", + "sha256": "9cc1f832cfa515fc673f2197d73e4c32c94a4072ef52c15766e12b562d3a5ed2", + "size": 11357, + "subdir": "linux-64", + "timestamp": 1611675299022, + "version": "0.3.3" + }, + "anyjson-0.3.3-py36hcd494a7_1.conda": { + "build": "py36hcd494a7_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8850b353b73eb7a16f896d6502a20796", + "name": "anyjson", + "sha256": "69cdc3aa04cf2e468cb78437d66016c049e2a7cf46c8d46a0225d0a7df67b7ce", + "size": 9793, + "subdir": "linux-64", + "timestamp": 1505693684597, + "version": "0.3.3" + }, + "anyjson-0.3.3-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "35dbd59cc8037339ad9d8050bcfff98b", + "name": "anyjson", + "sha256": "cd350528f188d78860a7dd0c32725ea335ad7fd4f5a7273202aa1e9429f3f8c0", + "size": 10012, + "subdir": "linux-64", + "timestamp": 1530737615846, + "version": "0.3.3" + }, + "anyjson-0.3.3-py37_1001.conda": { + "build": "py37_1001", + "build_number": 1001, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ed052592760bb48f87cda2fd0a91bb11", + "name": "anyjson", + "sha256": "ad01d3637efefa144c2bd8522b417dddff64c1cfd6d10581ff75089d94f5e3a7", + "size": 9709, + "subdir": "linux-64", + "timestamp": 1594337572329, + "version": "0.3.3" + }, + "anyjson-0.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "63d3914dd5bc28973edbe51b3b4f0b60", + "name": "anyjson", + "sha256": "df3ed33e921679ff5706039d52ece626f23c7ba0a47b8a5e28a604528fd291a0", + "size": 11337, + "subdir": "linux-64", + "timestamp": 1611675309646, + "version": "0.3.3" + }, + "anyjson-0.3.3-py37h06a4308_1002.conda": { + "build": "py37h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8ef0a52dadfc877da77c18501a9c8468", + "name": "anyjson", + "sha256": "6f8ba33b4bae79f73f97cac29db1d5dd02bb912d119da6f2139090e30ebaf1c4", + "size": 12986, + "subdir": "linux-64", + "timestamp": 1659702794790, + "version": "0.3.3" + }, + "anyjson-0.3.3-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "31fb3dd32cccae9c04d6f1709e46c9cc", + "name": "anyjson", + "sha256": "64fb1a07d5cc1bfe00eb498fd1702c00b4e1f88116ffab96187a40aefc7b54a2", + "size": 10433, + "subdir": "linux-64", + "timestamp": 1572437643987, + "version": "0.3.3" + }, + "anyjson-0.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "843ff3524cdf6fbb06463cab8f347670", + "name": "anyjson", + "sha256": "172aa5c3e9de7651890650a9847facbb9e94503a7555438ebf6297aae33d81af", + "size": 11314, + "subdir": "linux-64", + "timestamp": 1611675362229, + "version": "0.3.3" + }, + "anyjson-0.3.3-py38h06a4308_1002.conda": { + "build": "py38h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4d97ab416356d122c75108b0d5de5623", + "name": "anyjson", + "sha256": "b343cc5a3c5f87eb41ef6467f02c1d5ef648528ee4e0da9fc0d1b7fa149506d6", + "size": 12970, + "subdir": "linux-64", + "timestamp": 1659702813931, + "version": "0.3.3" + }, + "anyjson-0.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c7d56a49a6a13c599ea36c28c1c6bed9", + "name": "anyjson", + "sha256": "58e366bf7f2c782d8bf179c912b0b0ee7dd0cdb9701715e66e1acd8cae20e359", + "size": 11390, + "subdir": "linux-64", + "timestamp": 1611675307879, + "version": "0.3.3" + }, + "anyjson-0.3.3-py39h06a4308_1002.conda": { + "build": "py39h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "680b181230d948c99100e26cf120f5ce", + "name": "anyjson", + "sha256": "ffad9d3514d2b55112b1b4fb5d382ed4b8074a7c17cfda0611da4176653de96a", + "size": 12964, + "subdir": "linux-64", + "timestamp": 1659702745651, + "version": "0.3.3" + }, + "anyqt-0.0.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "ea67d9450c93be800fb3368dad48d678", + "name": "anyqt", + "sha256": "68d3747c411ac6f6e380227805af9f2cdc3abfb069441aead934049598d62411", + "size": 46417, + "subdir": "linux-64", + "timestamp": 1539466176637, + "version": "0.0.10" + }, + "anyqt-0.0.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "8ec71502dc9ad181517015f929193420", + "name": "anyqt", + "sha256": "900bfec353871f2eb3490bca1aa5dacbc55570790f77adc3eb727d9a8ca9f0eb", + "size": 47651, + "subdir": "linux-64", + "timestamp": 1539466202473, + "version": "0.0.10" + }, + "anyqt-0.0.10-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "f4522324f1402b7571e26010ab481682", + "name": "anyqt", + "sha256": "e1162dca949c9b907f2afe44f296c21fcf00bf1bc6e8e20f3566713a281d1109", + "size": 48979, + "subdir": "linux-64", + "timestamp": 1613037522420, + "version": "0.0.10" + }, + "anyqt-0.0.10-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "eb1879e0622e670ebcec11ba97ec0962", + "name": "anyqt", + "sha256": "91d1289c34c526171a13b647f8fd9aca86044303159afe17ad31fa5e7e11fcea", + "size": 47681, + "subdir": "linux-64", + "timestamp": 1539466181246, + "version": "0.0.10" + }, + "anyqt-0.0.10-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "dff4af7a510bad22f0f15ac153a24f1c", + "name": "anyqt", + "sha256": "6d57a98de10ee7571b8e746769735e8b63d9607ebd492cafef308f0d58fe2186", + "size": 48326, + "subdir": "linux-64", + "timestamp": 1613037525579, + "version": "0.0.10" + }, + "anyqt-0.0.10-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "d9b92f014865de7998638ed4b768426f", + "name": "anyqt", + "sha256": "e2840779acb15e7d97f0be1c51ad37bf549d999be7431b7095cfdd719d5a46d1", + "size": 48023, + "subdir": "linux-64", + "timestamp": 1574097806978, + "version": "0.0.10" + }, + "anyqt-0.0.10-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "cae88a41b94837c77230e522098e93e7", + "name": "anyqt", + "sha256": "4626cbd320bf85631d646fa5249aa4bb74e59527e3260e9e64ad4776b431df79", + "size": 49236, + "subdir": "linux-64", + "timestamp": 1613037532417, + "version": "0.0.10" + }, + "anyqt-0.0.10-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "e20feb27483f902859d036eea79abe4c", + "name": "anyqt", + "sha256": "d37c850c12c145a371058e9655a8bdf47ac588ef3a16382d457b00762a778aa2", + "size": 47377, + "subdir": "linux-64", + "timestamp": 1613037530537, + "version": "0.0.10" + }, + "anyqt-0.0.13-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.10,<3.11.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "bc9f8f8d239ec607a489015dd9d83a32", + "name": "anyqt", + "sha256": "90b93b30048e696b76a80c979d74bd8d3bff25e7e5960d2b59b4562966030059", + "size": 64228, + "subdir": "linux-64", + "timestamp": 1642512735516, + "version": "0.0.13" + }, + "anyqt-0.0.13-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "5e65dd52e500bc1d55c17a25288dd672", + "name": "anyqt", + "sha256": "a92fb47a6a54f2623e387b92cde5dc7e06bb10ccd16fe7037e2338844e1229f5", + "size": 64936, + "subdir": "linux-64", + "timestamp": 1620315969008, + "version": "0.0.13" + }, + "anyqt-0.0.8-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pyqt", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "ff9aff0fcd3332b3601f0e334bd147d5", + "name": "anyqt", + "sha256": "b4b1e9457365c457d7fc8931be4b793211f81ae8a023d86d73cb90fa13600d01", + "size": 45617, + "subdir": "linux-64", + "timestamp": 1530902605859, + "version": "0.0.8" + }, + "anyqt-0.0.8-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "pyqt", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "9085ac8b107e1571432eb7b068e022f9", + "name": "anyqt", + "sha256": "8f29fc94d5a58e54d04eadeb6fed632930e20ee7ac9f28a2f900ed402b4234bb", + "size": 47258, + "subdir": "linux-64", + "timestamp": 1537856045263, + "version": "0.0.8" + }, + "anyqt-0.0.8-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pyqt", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "c80e7313591313f7ffc7cdfaac705c4d", + "name": "anyqt", + "sha256": "1f6b8bd0263a7cf1d5788774d1e166ac6a4326422b6cf8676e5082194e13f981", + "size": 46263, + "subdir": "linux-64", + "timestamp": 1530902573077, + "version": "0.0.8" + }, + "anyqt-0.0.8-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "59c58d967d021d106f1d6ffc3bf99ca5", + "name": "anyqt", + "sha256": "01eaf2e4f3b061eb821c8b98f6dbec2606aac1e506d90bd694498d30df4775ae", + "size": 46251, + "subdir": "linux-64", + "timestamp": 1530902537956, + "version": "0.0.8" + }, + "anyqt-0.1.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.10,<3.11.0a0" + ], + "license": "GPL-3.0-or-later", + "md5": "27b65207388f4d402b8b54307581808e", + "name": "anyqt", + "sha256": "4a85cd821da8a20064e206ad3b733e40ef0916c413527b422057d9ddd42ad656", + "size": 76229, + "subdir": "linux-64", + "timestamp": 1659334947286, + "version": "0.1.1" + }, + "anyqt-0.1.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.11,<3.12.0a0" + ], + "license": "GPL-3.0-or-later", + "md5": "f2339a99c68993a3a68fd5de2299e30f", + "name": "anyqt", + "sha256": "3d90bc9dba59e46ba83ac2d47bace9d26cda4e516e83805f2b4f1066f50da152", + "size": 89565, + "subdir": "linux-64", + "timestamp": 1676838973035, + "version": "0.1.1" + }, + "anyqt-0.1.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0-or-later", + "md5": "cb92ed8d1046e82cc284b8794e548a2c", + "name": "anyqt", + "sha256": "e1870611b2efe4e956f00875cd917aadab4178a0d37158f4d8e40f31ae8629f0", + "size": 76573, + "subdir": "linux-64", + "timestamp": 1659335065976, + "version": "0.1.1" + }, + "anyqt-0.1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0-or-later", + "md5": "d1258cfb6f0ff9f523f6fbc322f0abf7", + "name": "anyqt", + "sha256": "127b015d288d1c83cc8f8c73b318c2de29528d16a9e0420ff3ae99422abd306c", + "size": 76841, + "subdir": "linux-64", + "timestamp": 1659334991194, + "version": "0.1.1" + }, + "anyqt-0.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-3.0-or-later", + "md5": "d94718334832c6cbd5d8e1a658b324f8", + "name": "anyqt", + "sha256": "3b4df990197be9246ce02df0d55f8e0471e1777b00598ace337c3aeef9764d9e", + "size": 75809, + "subdir": "linux-64", + "timestamp": 1659335028502, + "version": "0.1.1" + }, + "apache-airflow-2.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "c7a3c0b96af3ee6168338fee4500cfcf", + "name": "apache-airflow", + "sha256": "b650285f0f9d46d3a3eb17a15b870665cc2e1b5e998451e66e6692e82c0a2245", + "size": 12832, + "subdir": "linux-64", + "timestamp": 1659884290255, + "version": "2.3.3" + }, + "apache-airflow-2.3.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "cbd1df2c78bcfcaec839dfa9b6cd9005", + "name": "apache-airflow", + "sha256": "67faefa9bdd680e472a169e81d00589c4f1b7ab44243ce9d91676aec44ca5260", + "size": 12837, + "subdir": "linux-64", + "timestamp": 1659935230453, + "version": "2.3.3" + }, + "apache-airflow-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "312bd2758daa2892bf07a0588f7cfc1e", + "name": "apache-airflow", + "sha256": "ee3207c1fee5e45f373bc11da6a78c6194679b694e6ef5a0b76cc3e805be22bc", + "size": 12806, + "subdir": "linux-64", + "timestamp": 1659884273435, + "version": "2.3.3" + }, + "apache-airflow-2.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "f15ca339b4abcf873b437bbc83de089e", + "name": "apache-airflow", + "sha256": "27be912003607eec163bb9ffeff6d1f8a3090c9962417090bf2f3cfbba07fbf0", + "size": 12819, + "subdir": "linux-64", + "timestamp": 1659935218923, + "version": "2.3.3" + }, + "apache-airflow-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "ab1011ede85648a8c22317d6d1dcbc1f", + "name": "apache-airflow", + "sha256": "3b7d11d3cf13b8703e3baababa933cab0feeaf9e70b73637798d4dcd3ae4f6f2", + "size": 12811, + "subdir": "linux-64", + "timestamp": 1659884278857, + "version": "2.3.3" + }, + "apache-airflow-2.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "74326956d7e5c5d0604eaf27b0a2a0e9", + "name": "apache-airflow", + "sha256": "c4eeab53b528a5ffe134dfb4e89b37639f9ef3e7cb0fa5096fd9ba4210f31c35", + "size": 12816, + "subdir": "linux-64", + "timestamp": 1659935235916, + "version": "2.3.3" + }, + "apache-airflow-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "d11f0a16cddebf605d3a834cd98fb2c2", + "name": "apache-airflow", + "sha256": "6dcf129da34d9ee2459e4e0709afddae3e8e3b0cdffc199877ad261558b39d1f", + "size": 12805, + "subdir": "linux-64", + "timestamp": 1659884284508, + "version": "2.3.3" + }, + "apache-airflow-2.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "airflow >=2.3.3,<2.3.4.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "b61f148899a83efe781fe67a3f8f1cc8", + "name": "apache-airflow", + "sha256": "cf7dba7f35ceb8d5f091506fc0e18d22d366d95e877ced7d3892faad8a4fdd77", + "size": 12814, + "subdir": "linux-64", + "timestamp": 1659935224580, + "version": "2.3.3" + }, + "apache-airflow-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7be3df04df8bbbb2d0324bbb364385df", + "name": "apache-airflow", + "sha256": "e0ad41a89a5eebb4e5b0c23283bd2a36faf9d7b7728df44f67abfc501a7dad3a", + "size": 13491, + "subdir": "linux-64", + "timestamp": 1671227425912, + "version": "2.4.3" + }, + "apache-airflow-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f9d1870af6bf535f1239bf82297576fc", + "name": "apache-airflow", + "sha256": "5fe17fe4f5577b333a98e947192af237af0aea1e0f1c0692842b45be343371b2", + "size": 13462, + "subdir": "linux-64", + "timestamp": 1671227414097, + "version": "2.4.3" + }, + "apache-airflow-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cf766412799a69c6cf1130264da0c3cf", + "name": "apache-airflow", + "sha256": "e4d2ce40f427a191303bad4eebf62bddfe5e8ac90202174a22d65370abbd7e9b", + "size": 13463, + "subdir": "linux-64", + "timestamp": 1671227431597, + "version": "2.4.3" + }, + "apache-airflow-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "airflow >=2.4.3,<2.4.4.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "75e2cd4addcf748473e527cfa3a16944", + "name": "apache-airflow", + "sha256": "4a9360980ffe00d727f78b591aa39cd2b664d4ef449b23000cf462d71cba8ad9", + "size": 13474, + "subdir": "linux-64", + "timestamp": 1671227419928, + "version": "2.4.3" + }, + "apache-airflow-providers-apache-hdfs-3.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "apache-airflow >=2.2.0", + "python >=3.10,<3.11.0a0", + "python-hdfs >=2.0.4", + "snakebite-py3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ce2030079248d857be83a02d75135f5a", + "name": "apache-airflow-providers-apache-hdfs", + "sha256": "93a607170111997966ebc44d7414c46b00c1c9cd89e8ed26002371e9a773443c", + "size": 24351, + "subdir": "linux-64", + "timestamp": 1659891394161, + "version": "3.0.1" + }, + "apache-airflow-providers-apache-hdfs-3.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "apache-airflow >=2.2.0", + "python >=3.7,<3.8.0a0", + "python-hdfs >=2.0.4", + "snakebite-py3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "638fb8c00a70aefe2114f925af0b9cae", + "name": "apache-airflow-providers-apache-hdfs", + "sha256": "7d89fd519c7d1d76faefb4f860eee28d906c23346c2ccf22a298fbaa9c6988db", + "size": 24058, + "subdir": "linux-64", + "timestamp": 1659891449255, + "version": "3.0.1" + }, + "apache-airflow-providers-apache-hdfs-3.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "apache-airflow >=2.2.0", + "python >=3.8,<3.9.0a0", + "python-hdfs >=2.0.4", + "snakebite-py3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d6d5bf8b7688557def4ecbbdf6d56fbf", + "name": "apache-airflow-providers-apache-hdfs", + "sha256": "0112c8ab9e6c93452d4c82ad124ac42916e74881fa91a3b1b9de158f0e5b38fa", + "size": 24237, + "subdir": "linux-64", + "timestamp": 1659891258513, + "version": "3.0.1" + }, + "apache-airflow-providers-apache-hdfs-3.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "apache-airflow >=2.2.0", + "python >=3.9,<3.10.0a0", + "python-hdfs >=2.0.4", + "snakebite-py3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "92c36b4ee4b13693c1edd72027aa6146", + "name": "apache-airflow-providers-apache-hdfs", + "sha256": "3ed403b307a99721e190a37bfa7b0cedc8e2f94ceb3fff4cb58645aa579edf44", + "size": 24148, + "subdir": "linux-64", + "timestamp": 1659891327815, + "version": "3.0.1" + }, + "apache-airflow-providers-common-sql-1.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "sqlparse >=0.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "da14b32ea045ffe22d4052d899dc1dc4", + "name": "apache-airflow-providers-common-sql", + "sha256": "db0804c1a124b2db68f7f9dce7a8a93d1cb0fb994639e3227564ff8dfabfdfcf", + "size": 41668, + "subdir": "linux-64", + "timestamp": 1669056807749, + "version": "1.2.0" + }, + "apache-airflow-providers-common-sql-1.2.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "sqlparse >=0.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c2116971f456f52cc1f0d2ef11a8a361", + "name": "apache-airflow-providers-common-sql", + "sha256": "2aef39587f31a2a8b1d3e1c57d0e9851f142bd2c1ddeff361b299741e5f3d04d", + "size": 48693, + "subdir": "linux-64", + "timestamp": 1676828978987, + "version": "1.2.0" + }, + "apache-airflow-providers-common-sql-1.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "sqlparse >=0.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cf43a532d1e4fcf03fcd0cabf23063dd", + "name": "apache-airflow-providers-common-sql", + "sha256": "8d495528e332fe6c5ba5f171a3008fc5f8b7b61f640e1cf04622852fcc6a8aec", + "size": 40835, + "subdir": "linux-64", + "timestamp": 1669056720084, + "version": "1.2.0" + }, + "apache-airflow-providers-common-sql-1.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "sqlparse >=0.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fa182fde1d22ce2c4eb7842ef82736a2", + "name": "apache-airflow-providers-common-sql", + "sha256": "da71b7eea5b74ddcf36837b35da0e08607b7764bc75fb94c8ee35717dc838869", + "size": 41166, + "subdir": "linux-64", + "timestamp": 1669056749948, + "version": "1.2.0" + }, + "apache-airflow-providers-common-sql-1.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "sqlparse >=0.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "faca8959529006f0bed26d38b3b9a61c", + "name": "apache-airflow-providers-common-sql", + "sha256": "314c772ad8e32eb83070b3fa7cbec85efaa8105de7e403178b25064844840689", + "size": 41234, + "subdir": "linux-64", + "timestamp": 1669056778506, + "version": "1.2.0" + }, + "apache-airflow-providers-ftp-3.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4c422e2c29d61463f0291e384678c9c2", + "name": "apache-airflow-providers-ftp", + "sha256": "9e821e89c9dceff7ef69c8e19c9b7349cf7eb712f914707091984fea4cb56277", + "size": 20317, + "subdir": "linux-64", + "timestamp": 1659864383174, + "version": "3.1.0" + }, + "apache-airflow-providers-ftp-3.1.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eddfce13dc5a038141fc910afc4ce7e5", + "name": "apache-airflow-providers-ftp", + "sha256": "5db88a526692bc7cae2d2f542bd99a0a103f148632679b85ecdad10ac348e3c6", + "size": 22553, + "subdir": "linux-64", + "timestamp": 1676828992859, + "version": "3.1.0" + }, + "apache-airflow-providers-ftp-3.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9be727d31bc2805512567dac2fe3c012", + "name": "apache-airflow-providers-ftp", + "sha256": "d8ac634a67d0a5708a9b623fc9146150ac9f93afff3daa39641352415e5d02a1", + "size": 20140, + "subdir": "linux-64", + "timestamp": 1659864343458, + "version": "3.1.0" + }, + "apache-airflow-providers-ftp-3.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "714f7aa463b1ed7c3884a5d99eb592e3", + "name": "apache-airflow-providers-ftp", + "sha256": "8cea0ba7b5052d853e43589fdeb8b334b4063b870852af04129d4a73598a1058", + "size": 20209, + "subdir": "linux-64", + "timestamp": 1659864409037, + "version": "3.1.0" + }, + "apache-airflow-providers-ftp-3.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "07dab9df067e338896515bdb2c34d614", + "name": "apache-airflow-providers-ftp", + "sha256": "105a5d9798e4ae7f0bd27c143d2f616caefc88c3bed0e7beb22b18d5faa22322", + "size": 20246, + "subdir": "linux-64", + "timestamp": 1659864438750, + "version": "3.1.0" + }, + "apache-airflow-providers-http-4.0.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "requests >=2.26.0", + "requests-toolbelt" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c8758e7c64e4969888d68cee879820ca", + "name": "apache-airflow-providers-http", + "sha256": "9b6ee9c2d54e85397e0ce07fb131178cd4c7aae412d9f2ee5e6b10e25e3d4b0f", + "size": 23599, + "subdir": "linux-64", + "timestamp": 1659865202296, + "version": "4.0.0" + }, + "apache-airflow-providers-http-4.0.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "requests >=2.26.0", + "requests-toolbelt" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4ab76e42dbe53979afd414652c1e5fe9", + "name": "apache-airflow-providers-http", + "sha256": "61e966cb90d885a59e3b5036b57be6b7cfb3ee29cccae2ab2945e06539580ba4", + "size": 26578, + "subdir": "linux-64", + "timestamp": 1676829006751, + "version": "4.0.0" + }, + "apache-airflow-providers-http-4.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.26.0", + "requests-toolbelt" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "415174e6d027d1ce5ccd75a3a7ee73cf", + "name": "apache-airflow-providers-http", + "sha256": "e2cc4c1830c3d947722d2f714b9eaf49b7d53541f9af648b231b0304b4bb1898", + "size": 23317, + "subdir": "linux-64", + "timestamp": 1659865161607, + "version": "4.0.0" + }, + "apache-airflow-providers-http-4.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.26.0", + "requests-toolbelt" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a7bfaeccace5b593fc08d9f26119bb47", + "name": "apache-airflow-providers-http", + "sha256": "5789c389bbd2bddb02fcb1b59c8250ec8edd22aa652b24d2c667608898753cd2", + "size": 23423, + "subdir": "linux-64", + "timestamp": 1659865229581, + "version": "4.0.0" + }, + "apache-airflow-providers-http-4.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.26.0", + "requests-toolbelt" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b4e6a3899655a716ea3812f1f7651478", + "name": "apache-airflow-providers-http", + "sha256": "a59c8d7d576221209823edfa3e1408670176e14eaa9cd8ce79eeafee0afb9069", + "size": 23410, + "subdir": "linux-64", + "timestamp": 1659865133415, + "version": "4.0.0" + }, + "apache-airflow-providers-imap-3.0.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b1f41146a1ff62eaad8408d155776d41", + "name": "apache-airflow-providers-imap", + "sha256": "2d09bdec0c0d33433532774c8452bcbf91f8ecd76970b0aa179ee97ba2f10193", + "size": 21573, + "subdir": "linux-64", + "timestamp": 1659865289956, + "version": "3.0.0" + }, + "apache-airflow-providers-imap-3.0.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b37cf6fbc2052fe36048884f020f8958", + "name": "apache-airflow-providers-imap", + "sha256": "809bebecce59b1b60006381f54d3719170084557a2728b5bcac214a80c9905d9", + "size": 24711, + "subdir": "linux-64", + "timestamp": 1676829020621, + "version": "3.0.0" + }, + "apache-airflow-providers-imap-3.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5cc343fd80132d8fada405c5a22632a6", + "name": "apache-airflow-providers-imap", + "sha256": "e65dde8bddec1c2293a03a7bd7df11fa25b50ce4825a9fc72582afc7a1141716", + "size": 21441, + "subdir": "linux-64", + "timestamp": 1659865315798, + "version": "3.0.0" + }, + "apache-airflow-providers-imap-3.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "903fa8ba8602c38086bd37ad790e758b", + "name": "apache-airflow-providers-imap", + "sha256": "b0aa151f4186ad0bad7f4737fc109c548bc940fe77672f0ed250ece619c23178", + "size": 21394, + "subdir": "linux-64", + "timestamp": 1659865251323, + "version": "3.0.0" + }, + "apache-airflow-providers-imap-3.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7e7c261999595d50fe8add48dd28e033", + "name": "apache-airflow-providers-imap", + "sha256": "f7cbfa2f17d4c294c423dfdc8bfae288c4a0ccc4ed37ba8f00b690ef753d25dc", + "size": 21386, + "subdir": "linux-64", + "timestamp": 1659865225889, + "version": "3.0.0" + }, + "apache-airflow-providers-sqlite-3.0.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "60a8617c7e87cce4b7c61c5b0b1b864a", + "name": "apache-airflow-providers-sqlite", + "sha256": "ff4a48eb98eff5b96abdadabd9150ce969a1a41bf6e06e08a592e1649a0b669c", + "size": 16760, + "subdir": "linux-64", + "timestamp": 1659865501066, + "version": "3.0.0" + }, + "apache-airflow-providers-sqlite-3.0.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "62d4b84fd38a4a83f91f35744ee328cd", + "name": "apache-airflow-providers-sqlite", + "sha256": "11f2f10b9b41972fb780c7329a05f64a3630440a357c1a9d114f689b0db4e110", + "size": 17972, + "subdir": "linux-64", + "timestamp": 1676829034522, + "version": "3.0.0" + }, + "apache-airflow-providers-sqlite-3.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "83a10f2bff00763b8e0de9e3e3206f37", + "name": "apache-airflow-providers-sqlite", + "sha256": "dfddf5c18cf7c370aa748c61acc54dc49f6c3f574c42f9233ccafbdce23c2360", + "size": 16624, + "subdir": "linux-64", + "timestamp": 1659865554230, + "version": "3.0.0" + }, + "apache-airflow-providers-sqlite-3.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "40ba93493ae80a3b203adc1deb3e4aa5", + "name": "apache-airflow-providers-sqlite", + "sha256": "2263fadf10fd6ddb18c0ef923572840d3f0ecf2fe15ae7a565d63ae639e8c8e8", + "size": 16745, + "subdir": "linux-64", + "timestamp": 1659865527386, + "version": "3.0.0" + }, + "apache-airflow-providers-sqlite-3.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4bb9c940e2bab5acac10c49a9e2f60c2", + "name": "apache-airflow-providers-sqlite", + "sha256": "50363f37a0c06302d780b9de1d6ee1fb3ac5583a442f63f583e98447ebb9796b", + "size": 16717, + "subdir": "linux-64", + "timestamp": 1659865461356, + "version": "3.0.0" + }, + "apache-libcloud-1.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "md5": "edb1ced0b9f8067ce7cfc5cb8cb86d7f", + "name": "apache-libcloud", + "sha256": "20da67dead40ea08dc23ea8fa16c49bea79f1f7298762170e3e19e9b6059dd5d", + "size": 1799786, + "subdir": "linux-64", + "timestamp": 1640788144465, + "version": "1.3.0" + }, + "apache-libcloud-1.3.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache 2.0", + "md5": "bfa48b307bfab9de2be459a754b983da", + "name": "apache-libcloud", + "sha256": "5fe228de463f1dcca4219a42ca1304ba787f25bfcd2e622244a146e8e8510aa5", + "size": 2225257, + "subdir": "linux-64", + "timestamp": 1676846782748, + "version": "1.3.0" + }, + "apache-libcloud-1.3.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "cb7971a52fca381d4fa22e13a3520a89", + "name": "apache-libcloud", + "sha256": "9c7d5914e3ad0ef92cb15600655e4e3f16f277c82d90ae94b53ab61fa8eae418", + "size": 1792556, + "subdir": "linux-64", + "timestamp": 1632751731955, + "version": "1.3.0" + }, + "apache-libcloud-1.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "4691c943484a399ac22cd91da4a17e3e", + "name": "apache-libcloud", + "sha256": "88e31a1ba2479ae31cb0d5a71475a70f5251a3c8d7e4df2b23ef56b2304034d6", + "size": 1757288, + "subdir": "linux-64", + "timestamp": 1632751720175, + "version": "1.3.0" + }, + "apache-libcloud-1.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "af14a42be9b696a35cb2b8c601ec0433", + "name": "apache-libcloud", + "sha256": "2c47da574dd50f7dd03c227d09d68c367694c5c2f45e020da1db26339a82a00d", + "size": 1772625, + "subdir": "linux-64", + "timestamp": 1632741357768, + "version": "1.3.0" + }, + "apache-libcloud-1.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "5a98dc48659881005a7f4a0f50003a52", + "name": "apache-libcloud", + "sha256": "bff5216cb1b552402d84baef9543208925779bcd6bd7ebb686fdbd99c81bc535", + "size": 1767748, + "subdir": "linux-64", + "timestamp": 1632741358315, + "version": "1.3.0" + }, + "apipkg-1.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b1fcfbf6fcf6ecb2053a9bb6134329f5", + "name": "apipkg", + "sha256": "c651d306c7d9a9234d0bc1f1bdb50d06108dd2bca1c46a0225e7269b97057890", + "size": 10942, + "subdir": "linux-64", + "timestamp": 1530727837542, + "version": "1.4" + }, + "apipkg-1.4-py27hab8e363_0.conda": { + "build": "py27hab8e363_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "689d3ec11b865e543274e6da0491fc2c", + "name": "apipkg", + "sha256": "f522c9fd620df2b53d8b6bb456c5282dc5d4d78595945bd59c387575435c2b76", + "size": 11274, + "subdir": "linux-64", + "timestamp": 1510986429497, + "version": "1.4" + }, + "apipkg-1.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "9b400c9d7f8844bfa389216d125a4959", + "name": "apipkg", + "sha256": "8fe07eb23b4fe66087fe66a18bc2773364b1263049fea04863fcaab1e13e9404", + "size": 11134, + "subdir": "linux-64", + "timestamp": 1534347539051, + "version": "1.4" + }, + "apipkg-1.4-py35h53e6e68_0.conda": { + "build": "py35h53e6e68_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "cf4dfb46db787a7fad43a359381159ba", + "name": "apipkg", + "sha256": "c2d66eeb0be4517d13889bd60b4cdc67bf2c1d7704cd435dfddcb35c5b39a945", + "size": 11543, + "subdir": "linux-64", + "timestamp": 1510986448257, + "version": "1.4" + }, + "apipkg-1.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9f08b8aedeefc827c85ee175aeb6efbf", + "name": "apipkg", + "sha256": "64c641339bb8664f2984cf49021634c33927aadf4c5b3d79bcc3b9f54e8b563e", + "size": 11065, + "subdir": "linux-64", + "timestamp": 1530727877535, + "version": "1.4" + }, + "apipkg-1.4-py36he372753_0.conda": { + "build": "py36he372753_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a424f488e62f35daf24549b2cbd05c9f", + "name": "apipkg", + "sha256": "c2a9fbc18361aade189387c164c9839e5cf2bd78640fe3fa60682eec116457fd", + "size": 11417, + "subdir": "linux-64", + "timestamp": 1510986442087, + "version": "1.4" + }, + "apipkg-1.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2be2442582764bc99ad52ff02bbb818f", + "name": "apipkg", + "sha256": "8ed2b577a7929be7f49d778a403c09f9997e40c17f85e5a2ceae309c1c96c034", + "size": 11043, + "subdir": "linux-64", + "timestamp": 1530727857359, + "version": "1.4" + }, + "apipkg-1.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7918b81a183ac1e52ac6958af3364303", + "name": "apipkg", + "sha256": "e01ceae9f199b38f4e6711b8b13157ce80021bc8b1ef6c3f60e2447ad2c9ebcd", + "size": 11605, + "subdir": "linux-64", + "timestamp": 1534394710802, + "version": "1.5" + }, + "apipkg-1.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "0f5790329f0dafef333e14f7db6571e2", + "name": "apipkg", + "sha256": "eb46b39bb761d7938c92c8c7ad68d7200423bf6214dc661dd0e11f7e2da9c11b", + "size": 12547, + "subdir": "linux-64", + "timestamp": 1640788167919, + "version": "1.5" + }, + "apipkg-1.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "b7babd5209935423f26e5c425e66ae8e", + "name": "apipkg", + "sha256": "da2515180afc425d5998372da304f5be37c488177f4d3400954a68d0e2eef415", + "size": 15027, + "subdir": "linux-64", + "timestamp": 1676846802380, + "version": "1.5" + }, + "apipkg-1.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "e608268abb4d221667ba78a6d889618e", + "name": "apipkg", + "sha256": "1f5290da613798d3eb55a9a9eed2d9c5348fc8796a8529117df49f452b5d7c5b", + "size": 11737, + "subdir": "linux-64", + "timestamp": 1534394840884, + "version": "1.5" + }, + "apipkg-1.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2a1c737494eb1add0fe45b3b4edb2d74", + "name": "apipkg", + "sha256": "886af973ec394d615ac4e25db0217115aa3fc96b92e05b563ead22d996c67511", + "size": 11644, + "subdir": "linux-64", + "timestamp": 1534394798150, + "version": "1.5" + }, + "apipkg-1.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3ed206427b042106b4c7d06c66ed059b", + "name": "apipkg", + "sha256": "daa43e9de4fad151cc480178882b8c7059e21343da737016d274ce47c0b129b7", + "size": 11746, + "subdir": "linux-64", + "timestamp": 1534394734687, + "version": "1.5" + }, + "apipkg-1.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "4773bde3461428325434ca673db48da3", + "name": "apipkg", + "sha256": "bbe70299cfa8dbace0370ac9a6a889eeec4b4d763fae46f33d4e33fd7ca1fc45", + "size": 12373, + "subdir": "linux-64", + "timestamp": 1572437675640, + "version": "1.5" + }, + "apipkg-1.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "70f71b1fc48d7702ea32484beb292998", + "name": "apipkg", + "sha256": "ad5dadbd739c6776455e9dc63b9325d802286ba1fcf17e61856d459005a58577", + "size": 13851, + "subdir": "linux-64", + "timestamp": 1607615881767, + "version": "1.5" + }, + "apispec-0.39.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pyyaml >=3.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "596110b4d1de55d6d0f6a133bb7f2112", + "name": "apispec", + "sha256": "18786d27a86585bd153ce8bf3822263da5a971272add8b761e8cb6af39ba7ba4", + "size": 45208, + "subdir": "linux-64", + "timestamp": 1543147352438, + "version": "0.39.0" + }, + "apispec-0.39.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c9c8720b7562b9ec4a7b08f68489411c", + "name": "apispec", + "sha256": "ccba5a9b76e08107506ce5f2aa0a8577c46fe6f50f5f0ef07587f3faf368ae0c", + "size": 45216, + "subdir": "linux-64", + "timestamp": 1543147395134, + "version": "0.39.0" + }, + "apispec-0.39.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31efba16316e68ba192a38f4f245a793", + "name": "apispec", + "sha256": "d002873c6e8219e15e1120ec96c6ddecaa369d304bbbe944434f8737892ca53e", + "size": 45845, + "subdir": "linux-64", + "timestamp": 1543147330916, + "version": "0.39.0" + }, + "appdirs-1.4.3-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7307cde8256550035ac84e67d073ef91", + "name": "appdirs", + "sha256": "97ca94c27222adcf2b528016dafe608258927af53bf3a7331d9238bf0964ef45", + "size": 15528, + "subdir": "linux-64", + "timestamp": 1530919483921, + "version": "1.4.3" + }, + "appdirs-1.4.3-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "7da8068e69f5403843b19e1e3fbf4f32", + "name": "appdirs", + "sha256": "08f3cadf2e793d824cf7fbb9a169ee60b5d1b6423f8faa39de2fb2e54acefeb6", + "size": 15613, + "subdir": "linux-64", + "timestamp": 1534351155796, + "version": "1.4.3" + }, + "appdirs-1.4.3-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e1f09939f03802678eb414179d436a73", + "name": "appdirs", + "sha256": "e2b09027f24a94d94f7885957c86a7dca8ce5ca5f202b405519f4f63f514520b", + "size": 15580, + "subdir": "linux-64", + "timestamp": 1530919426471, + "version": "1.4.3" + }, + "appdirs-1.4.3-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6b990ae1bc0012f6f212166164132f8f", + "name": "appdirs", + "sha256": "4c3b2ecc9a35e0fc21c2b3683773baac7c958c927facdc236c68f288db1320f2", + "size": 15518, + "subdir": "linux-64", + "timestamp": 1530919455697, + "version": "1.4.3" + }, + "apptools-4.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configobj", + "pyface", + "python >=2.7,<2.8.0a0", + "traits", + "traitsui" + ], + "license": "BSD 3-clause", + "md5": "988c1b0d2d46b963d19beaf520def1ae", + "name": "apptools", + "sha256": "c4c55fcdaed78f656c2a9b9adb8f7abe45df0f7d2bb9246da46f612fffac5890", + "size": 392124, + "subdir": "linux-64", + "timestamp": 1530874852706, + "version": "4.4.0" + }, + "apptools-4.4.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "configobj", + "pyface", + "python >=2.7,<2.8.0a0", + "traits", + "traitsui" + ], + "license": "BSD 3-clause", + "md5": "38718c4edff8ec4c196002b9fb49a123", + "name": "apptools", + "sha256": "69ec9962c73ffde0227e573df4092b6943b4bb850cad1c7c80368205829da71e", + "size": 392255, + "subdir": "linux-64", + "timestamp": 1536253684521, + "version": "4.4.0" + }, + "apptools-4.4.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "configobj", + "pyface", + "python >=3.5,<3.6.0a0", + "traits", + "traitsui" + ], + "license": "BSD 3-clause", + "md5": "96f42fa46fda40e1da556a8ed0ab91b3", + "name": "apptools", + "sha256": "62b8fd2adac9ffdec584de00cbe06c5ba71f3bd9c9e6301487c9f2684c4d2715", + "size": 403361, + "subdir": "linux-64", + "timestamp": 1536253883550, + "version": "4.4.0" + }, + "apptools-4.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "configobj", + "pyface", + "python >=3.6,<3.7.0a0", + "traits", + "traitsui" + ], + "license": "BSD 3-clause", + "md5": "ee31790c394c036593f758b8ebede127", + "name": "apptools", + "sha256": "76297d66980c08a61264eaf39c06b8196c43d2def816169718d3e1f16059898b", + "size": 395355, + "subdir": "linux-64", + "timestamp": 1530874752549, + "version": "4.4.0" + }, + "apptools-4.4.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "configobj", + "pyface", + "python >=3.6,<3.7.0a0", + "traits", + "traitsui" + ], + "license": "BSD 3-clause", + "md5": "e68f80aa28cc81d523328988f44ebd19", + "name": "apptools", + "sha256": "f028a88b7d8bea06d859d04ab17a4ba7f3588576e471ae4d215c07d3893ef8de", + "size": 395713, + "subdir": "linux-64", + "timestamp": 1536253661051, + "version": "4.4.0" + }, + "apptools-4.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "configobj", + "pyface", + "python >=3.7,<3.8.0a0", + "traits", + "traitsui" + ], + "license": "BSD 3-clause", + "md5": "2cce1cb837aefdedb4a3328ce1081a7c", + "name": "apptools", + "sha256": "62a223c543f652f7b2d9d1cfa98f697f94a064b450546d2b1569244d965fe509", + "size": 395585, + "subdir": "linux-64", + "timestamp": 1530874809149, + "version": "4.4.0" + }, + "apptools-4.4.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "configobj", + "pyface", + "python >=3.7,<3.8.0a0", + "traits", + "traitsui" + ], + "license": "BSD 3-clause", + "md5": "2f4562d5ff2f559c6294b183ea41d91b", + "name": "apptools", + "sha256": "f21ed8ff2f2ce01c0d90048bf81a26b500ba5af186720adb4712d5e763305fa3", + "size": 395691, + "subdir": "linux-64", + "timestamp": 1536253845929, + "version": "4.4.0" + }, + "apptools-4.4.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "configobj", + "pyface", + "python >=3.8,<3.9.0a0", + "traits", + "traitsui" + ], + "license": "BSD 3-clause", + "md5": "4128bd5d09c4ce9129da79dc2dcc8a93", + "name": "apptools", + "sha256": "933a77bde07e5f50684c462abe79eee318fe87c5f2639049bc1e618fa4e69d4b", + "size": 401725, + "subdir": "linux-64", + "timestamp": 1574182135455, + "version": "4.4.0" + }, + "apr-1.6.3-he40df45_0.conda": { + "build": "he40df45_0", + "build_number": 0, + "depends": [ + "expat >=2.2.5,<3.0a0", + "libgcc-ng >=7.2.0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "6541c8bfc0e3591dcce6b27b141e741a", + "name": "apr", + "sha256": "76ab577c2e7490d198d35682dd0a920f5c470eec4d73850a9eb0cee8cefc24f8", + "size": 1061871, + "subdir": "linux-64", + "timestamp": 1513183900514, + "version": "1.6.3" + }, + "apr-1.7.0-hf178f73_5.conda": { + "build": "hf178f73_5", + "build_number": 5, + "depends": [ + "libapr", + "libapriconv", + "libaprutil", + "libgcc-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5209784c466984f9807c6f8b8fc91166", + "name": "apr", + "sha256": "e8ff8eb58f05b4292a95363c9d9df1aaad0f468c20853717008cb30009e0473c", + "size": 336554, + "subdir": "linux-64", + "timestamp": 1631785384660, + "version": "1.7.0" + }, + "apscheduler-3.6.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "funcsigs", + "futures", + "python >=2.7,<2.8.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "trollius", + "tzlocal >=1.2" + ], + "license": "MIT", + "md5": "1da68055f94bf18c3e16e680e13bcd69", + "name": "apscheduler", + "sha256": "7d92aa6ed86104e18e53a7248d7867d8ccebad38b4f4325530e064e16e6a7dd4", + "size": 86786, + "subdir": "linux-64", + "timestamp": 1575668867235, + "version": "3.6.3" + }, + "apscheduler-3.6.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=1.2" + ], + "license": "MIT", + "md5": "c3ebd0e64c545de17d1b2173ab342e29", + "name": "apscheduler", + "sha256": "20a125d055e2ca49d18d3ce2d276aabf8a6983331109260634fea21d218489e2", + "size": 87995, + "subdir": "linux-64", + "timestamp": 1575668904710, + "version": "3.6.3" + }, + "apscheduler-3.6.3-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=1.2" + ], + "license": "MIT", + "md5": "e8a0bd0ecb80ecea9e5b567b834abb07", + "name": "apscheduler", + "sha256": "772087b0871e56c7b55297ce1b87127276eb969c4311ca9f7fe0bbe7a66142ad", + "size": 87310, + "subdir": "linux-64", + "timestamp": 1590508705154, + "version": "3.6.3" + }, + "apscheduler-3.6.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=1.2" + ], + "license": "MIT", + "md5": "b12cdba7a53874a77d2a95d10173ed91", + "name": "apscheduler", + "sha256": "8fdc10bea1792cbe3a0afef890ae09f8499e754484301600da1406f0e8dae23e", + "size": 88165, + "subdir": "linux-64", + "timestamp": 1575668923941, + "version": "3.6.3" + }, + "apscheduler-3.6.3-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=1.2" + ], + "license": "MIT", + "md5": "20f0656ccb44d87df7d21aaa591f74ae", + "name": "apscheduler", + "sha256": "5609e4d3d3feeb52b7a6e95ac3bd80fc823d4990bd6a593090f14cd5cd944d5b", + "size": 87180, + "subdir": "linux-64", + "timestamp": 1590508731149, + "version": "3.6.3" + }, + "apscheduler-3.6.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=1.2" + ], + "license": "MIT", + "md5": "3c30c1d1181b51afc64174763fa6343e", + "name": "apscheduler", + "sha256": "8daa66cf613607103ccdb3d827ca799228d2031a9b0db8a67f3268bc1fcf195e", + "size": 88452, + "subdir": "linux-64", + "timestamp": 1575668934296, + "version": "3.6.3" + }, + "apscheduler-3.6.3-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=1.2" + ], + "license": "MIT", + "md5": "7381bb6332ce9325af64b51eb4c5da60", + "name": "apscheduler", + "sha256": "a0ea74df9e89f0ac8df3c0bf6a646f8f1da3c10a8a513f8b69f18131a97c5648", + "size": 87845, + "subdir": "linux-64", + "timestamp": 1590508743899, + "version": "3.6.3" + }, + "apscheduler-3.7.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=2.0,<2.1" + ], + "license": "MIT", + "md5": "f383fa33cb32f5bc63ab58ec5c7621e6", + "name": "apscheduler", + "sha256": "a248e3c98e42e8afd5bfe0a74c046bc739dacda25918a64151a1e5d5389e3c4d", + "size": 86122, + "subdir": "linux-64", + "timestamp": 1640803376607, + "version": "3.7.0" + }, + "apscheduler-3.7.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=2.0,<2.1" + ], + "license": "MIT", + "md5": "1d21630a57cbcc8305de7de94e97b5af", + "name": "apscheduler", + "sha256": "5853fdb7584fc09a2fbc7d4cd48fd76b2f02a34b6461e7c6109b5d3ff7205b34", + "size": 86157, + "subdir": "linux-64", + "timestamp": 1612239290582, + "version": "3.7.0" + }, + "apscheduler-3.7.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=2.0,<2.1" + ], + "license": "MIT", + "md5": "d360486801bddadc1287ae84459ec8cb", + "name": "apscheduler", + "sha256": "bf72f0dcd233f163b05f0dc12dd568c5783d161d3c9e39d6418ce986637fed53", + "size": 85942, + "subdir": "linux-64", + "timestamp": 1612239292113, + "version": "3.7.0" + }, + "apscheduler-3.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=2.0,<2.1" + ], + "license": "MIT", + "md5": "5c92ecd55f38e7d8d316fe7c8b0c3bbc", + "name": "apscheduler", + "sha256": "93b9c5bd3d051359bfd2a9584e564ff1b27aec555ea33810d2d42cb91ea21a75", + "size": 86638, + "subdir": "linux-64", + "timestamp": 1612239285579, + "version": "3.7.0" + }, + "apscheduler-3.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytz", + "setuptools", + "six >=1.4.0", + "tzlocal >=2.0,<2.1" + ], + "license": "MIT", + "md5": "e51835dc425e3d8cd0fcc4bb5c631b25", + "name": "apscheduler", + "sha256": "32cb7d73b5282410e3fc8e4c7b10c80e50603aeb6a7fda56c5746ec9c6cffb48", + "size": 86545, + "subdir": "linux-64", + "timestamp": 1613146952111, + "version": "3.7.0" + }, + "apscheduler-3.9.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytz", + "setuptools >=0.7", + "six >=1.4.0", + "tzlocal >=2.0,!=3.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14b3b6e7e068eb76b4229fb0f14b2921", + "name": "apscheduler", + "sha256": "b4bc8d0a46feb7d49f7984c90f71fb28a984e21aeb3a977b869cd1ca8635aaad", + "size": 91611, + "subdir": "linux-64", + "timestamp": 1668633088189, + "version": "3.9.0" + }, + "apscheduler-3.9.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "pytz", + "setuptools >=0.7", + "six >=1.4.0", + "tzlocal >=2.0,!=3.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eff5062c6f97c8548d9f2545ed5720ab", + "name": "apscheduler", + "sha256": "0585259841431b8b65b855ef24e9e5cf6efceb4c325e8479a392046fcb23a4ef", + "size": 118281, + "subdir": "linux-64", + "timestamp": 1676843197486, + "version": "3.9.0" + }, + "apscheduler-3.9.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz", + "setuptools >=0.7", + "six >=1.4.0", + "tzlocal >=2.0,!=3.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff9b716cb3b3f0a2b0784f8c3d86ec61", + "name": "apscheduler", + "sha256": "e6f0e3b5ba193d98d40c75b4bfa947b5044a19f5d7b5c8b946761086a2a35f0d", + "size": 90003, + "subdir": "linux-64", + "timestamp": 1668633025910, + "version": "3.9.0" + }, + "apscheduler-3.9.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz", + "setuptools >=0.7", + "six >=1.4.0", + "tzlocal >=2.0,!=3.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a5b20e52e99e2dbf73f911779ba1e4a7", + "name": "apscheduler", + "sha256": "9a7f44e68ec7194d98d4a829bdd0d3ca6dbc7b0eade8903df25406c9d9456c37", + "size": 90509, + "subdir": "linux-64", + "timestamp": 1668632993932, + "version": "3.9.0" + }, + "apscheduler-3.9.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytz", + "setuptools >=0.7", + "six >=1.4.0", + "tzlocal >=2.0,!=3.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b451d7642f208bf7c3691600fd9c23a5", + "name": "apscheduler", + "sha256": "73bd6515cff23354fb7737af772523e12c50397528b4b901b17f3d943517e6bd", + "size": 90562, + "subdir": "linux-64", + "timestamp": 1668633057116, + "version": "3.9.0" + }, + "aredis-1.1.7-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "contextvars", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "045f4d52fb58d03323ac3f7aeebd3bb8", + "name": "aredis", + "sha256": "4f812a4b6d5a75cc957dcfee7f01f10eb053584092f5f03dfab5f38c9010429f", + "size": 317120, + "subdir": "linux-64", + "timestamp": 1585086137748, + "version": "1.1.7" + }, + "aredis-1.1.7-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1afb1852673103f6e465138d9b341eda", + "name": "aredis", + "sha256": "0dac82c69480ad1ce24ab5510b4c905fe4a880c76e5a31494b77e23d9ad7347f", + "size": 318029, + "subdir": "linux-64", + "timestamp": 1585086131984, + "version": "1.1.7" + }, + "aredis-1.1.7-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b58e0402e800042c6fe9c591ab85e10", + "name": "aredis", + "sha256": "f3c74de53dfcee11310fab62b17f7d0b761c9f6af6857be5d548ff4756efef1e", + "size": 320331, + "subdir": "linux-64", + "timestamp": 1585086131335, + "version": "1.1.7" + }, + "aredis-1.1.8-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5b2fb4aeb7f691f1f291e2251b8fe39", + "name": "aredis", + "sha256": "fd35ed8546596390cc2de7627c2d4322a49be73bf769f552f235240caea9bc82", + "size": 152120, + "subdir": "linux-64", + "timestamp": 1640788191766, + "version": "1.1.8" + }, + "aredis-1.1.8-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98d73bf7f1fc64092b056589a3091e8f", + "name": "aredis", + "sha256": "e50cfc62cda97a76452c1927a683bb6fd0affdcd73da4668faa94c592032ac64", + "size": 185890, + "subdir": "linux-64", + "timestamp": 1676906886545, + "version": "1.1.8" + }, + "aredis-1.1.8-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "contextvars", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8d4102579134db39069eb98ca48fab1", + "name": "aredis", + "sha256": "389fb1d670898f1fba92c99ad43d1b7042bba4a9b8eb9a723a09d183265af7d1", + "size": 377727, + "subdir": "linux-64", + "timestamp": 1613036344544, + "version": "1.1.8" + }, + "aredis-1.1.8-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "contextvars", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e00629d40a11b6a18e0d25fa62651717", + "name": "aredis", + "sha256": "97e05f4da64a77ea101e85e3418acdf99e07bf3baea90344ccbbdb05d40c4f72", + "size": 317425, + "subdir": "linux-64", + "timestamp": 1585083627852, + "version": "1.1.8" + }, + "aredis-1.1.8-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad7c419d2680f9fc48d1c7dab70dae43", + "name": "aredis", + "sha256": "10c1c9eab472e5d41908e6dbd9264d324bbe7685a5ef0a8ac1c3bb30f9aeb45e", + "size": 376411, + "subdir": "linux-64", + "timestamp": 1613036337244, + "version": "1.1.8" + }, + "aredis-1.1.8-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f19049d056f1c2c7298a2b739099df9c", + "name": "aredis", + "sha256": "f8f0627f2d3b8087dabeb2edd8106ff4d065cb865e8d5fa6ef77dc4c30334259", + "size": 318584, + "subdir": "linux-64", + "timestamp": 1585083602002, + "version": "1.1.8" + }, + "aredis-1.1.8-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "783cd4dfbb3aadc8b5d7dbead32403ba", + "name": "aredis", + "sha256": "2ba06b65c16414ab1e083a355643f644c1df904ef9eef3dcf905b5926da05cc9", + "size": 380452, + "subdir": "linux-64", + "timestamp": 1613035938433, + "version": "1.1.8" + }, + "aredis-1.1.8-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a136af33b8aab854a68c659ea248f5ae", + "name": "aredis", + "sha256": "63f0a3ceeb3fb0ddcdf40e5990be5aba5be4ffa284ba46ca265109e795b3abeb", + "size": 317868, + "subdir": "linux-64", + "timestamp": 1585083633896, + "version": "1.1.8" + }, + "aredis-1.1.8-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "659062a7eb12995a146566bc0f14d611", + "name": "aredis", + "sha256": "4bc5d4ce9b30aba46e4b4bfc020b4794aad3260c08c6f00b6816c54687bc5eb9", + "size": 377599, + "subdir": "linux-64", + "timestamp": 1613036328438, + "version": "1.1.8" + }, + "argcomplete-1.10.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "db2833f622f38ffa3c61455f0f322a86", + "name": "argcomplete", + "sha256": "6900652310c521cb16c9c79ef127ee78e95086d0c0ccf15847b4cd5a58d0ca30", + "size": 49316, + "subdir": "linux-64", + "timestamp": 1559927327650, + "version": "1.10.0" + }, + "argcomplete-1.10.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f99e62a170b6dd2c7f70abdaebb4de2f", + "name": "argcomplete", + "sha256": "e4c7cff2207242e9ec97b12dfd3c9942d322dc4f094276038cb86d826e8d17d6", + "size": 49363, + "subdir": "linux-64", + "timestamp": 1559927347700, + "version": "1.10.0" + }, + "argcomplete-1.10.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bf51d69dc0011bae9b90d283937fba3a", + "name": "argcomplete", + "sha256": "ddf4b8d7690b003f3fc607ec388e4d653bb63be78bd97415783cadc8cd0081a5", + "size": 49532, + "subdir": "linux-64", + "timestamp": 1559927314245, + "version": "1.10.0" + }, + "argcomplete-1.10.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "72145f80e5f09943db165added1d4d00", + "name": "argcomplete", + "sha256": "d3282932e5c64dc90e0a6001d8b7aa7b5709b51165e6c2a9a562cef7bb52f04a", + "size": 48134, + "subdir": "linux-64", + "timestamp": 1572437716942, + "version": "1.10.0" + }, + "argcomplete-1.9.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "31e61ff1f61080eda20496e05547b39b", + "name": "argcomplete", + "sha256": "70f209a23614fb7aa6df2875a371736aba1ce72c881ff7191007a1288c9e5d46", + "size": 46027, + "subdir": "linux-64", + "timestamp": 1516391575589, + "version": "1.9.3" + }, + "argcomplete-1.9.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ccd2006979b96748e4b58cf718c5911b", + "name": "argcomplete", + "sha256": "1d474ec32d7e735a1d9120e16f4fb4d92105a952323f464e7236cda09dc4c9f5", + "size": 46856, + "subdir": "linux-64", + "timestamp": 1516391594085, + "version": "1.9.3" + }, + "argcomplete-1.9.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c5477722e2ee48f3218fb7f19a65b981", + "name": "argcomplete", + "sha256": "8ec8c0b21b47059686f887edeb786ed4f766e2365f34d6c3785f6cc49a239cf3", + "size": 46456, + "subdir": "linux-64", + "timestamp": 1516391593020, + "version": "1.9.3" + }, + "argcomplete-1.9.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "426919a0ce92ed36812ef2b1f9fc55cb", + "name": "argcomplete", + "sha256": "d2c3692826d7e54b5c843273b2de5eb6325e56f22a84265d9335bd2ce2f07c63", + "size": 46963, + "subdir": "linux-64", + "timestamp": 1522705810096, + "version": "1.9.4" + }, + "argcomplete-1.9.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "99f3d71ea9be02634416d99efcbb8836", + "name": "argcomplete", + "sha256": "208b9221f19b1ca1dea14045054d8f30adf4e0d8bec31899b21f88e37eebff32", + "size": 47621, + "subdir": "linux-64", + "timestamp": 1522704479474, + "version": "1.9.4" + }, + "argcomplete-1.9.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "66bdfa6e474f51a8c096c7f64d8b6242", + "name": "argcomplete", + "sha256": "7f8b36965b53fadf52691e4d6667c4954601656faf9e491dfe0eb301a36efed4", + "size": 46813, + "subdir": "linux-64", + "timestamp": 1522703919779, + "version": "1.9.4" + }, + "argcomplete-1.9.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3f64aaf6341e8886925190b80afbea4a", + "name": "argcomplete", + "sha256": "a200940ec0f3df919f746f32153c27e4892ae3dcfe54b1f7c7761908ddee37ac", + "size": 47161, + "subdir": "linux-64", + "timestamp": 1530737639150, + "version": "1.9.4" + }, + "argcomplete-1.9.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f7bde43167a0f5f544c86ec689708074", + "name": "argcomplete", + "sha256": "58bc47d10fd2b6a3bcac01e6625ef91b9d7cac4157760b0ea6f5043c797b5982", + "size": 48296, + "subdir": "linux-64", + "timestamp": 1556062326505, + "version": "1.9.5" + }, + "argcomplete-1.9.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "da5b72099e643b325c62444041afee82", + "name": "argcomplete", + "sha256": "bd14815bb5e29f79f68bdf84f753b3ee830cd54ded9a76e1a6f09b14694bdbd8", + "size": 48168, + "subdir": "linux-64", + "timestamp": 1556062355062, + "version": "1.9.5" + }, + "argcomplete-1.9.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3018e9b187ad2ae6d6adf9da85fcbfd3", + "name": "argcomplete", + "sha256": "781cc9bd0479f325c1d0d95c12afbef2ffb0d1898e46e2d6b6c113805a98db1e", + "size": 48248, + "subdir": "linux-64", + "timestamp": 1556062168308, + "version": "1.9.5" + }, + "argh-0.26.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 3", + "md5": "d2202b07a18b47cb891f395f36fa6e97", + "name": "argh", + "sha256": "daa5409c906093d523ccc7bcfb49017b6d110ed2288f1153235d0826363cda2c", + "size": 36577, + "subdir": "linux-64", + "timestamp": 1575415955533, + "version": "0.26.2" + }, + "argh-0.26.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL 3", + "md5": "c741531c34cd51ead7b0b838a5becad3", + "name": "argh", + "sha256": "0b7a14345f5530fa2c0309d82eb7519c3c171ecebbb5f78b537826152d8fdfc9", + "size": 34928, + "subdir": "linux-64", + "timestamp": 1640788209534, + "version": "0.26.2" + }, + "argh-0.26.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL 3", + "md5": "fa6d318dbf2be0cd08357eea5181d4ab", + "name": "argh", + "sha256": "0a13e5287a11649f7f579e69b460e92484dc0e75b35a2b11ca0e755bcb2e0d88", + "size": 41960, + "subdir": "linux-64", + "timestamp": 1676846816291, + "version": "0.26.2" + }, + "argh-0.26.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 3", + "md5": "94d57a44037af2a50a5ffb3d98519be2", + "name": "argh", + "sha256": "3235665bcbc010399fae8574f53db291e237c307bc4df25a2c5e0de2d72a0860", + "size": 36871, + "subdir": "linux-64", + "timestamp": 1575416058307, + "version": "0.26.2" + }, + "argh-0.26.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 3", + "md5": "f9c42e754719f59f4024bbe56708b1d5", + "name": "argh", + "sha256": "0a47b1dde4c6495212aae738cea79dd22d368573f06214f3ab12ce6048a4421f", + "size": 36844, + "subdir": "linux-64", + "timestamp": 1575416113205, + "version": "0.26.2" + }, + "argh-0.26.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL 3", + "md5": "f2c6a5fbf4df0a12a71d9afa3faeaf20", + "name": "argh", + "sha256": "e4525839b4944ad44ed47bc1d79945e8333b509cd8be3634a2f1d98c0ea0dd69", + "size": 36906, + "subdir": "linux-64", + "timestamp": 1575416089430, + "version": "0.26.2" + }, + "argh-0.26.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL 3", + "md5": "984d7e2100429685263613b0a4af48a6", + "name": "argh", + "sha256": "345fcd03c324ba73ec01efd0aa1fd05d74505e3ff75ee6cee3b514957890eda8", + "size": 37094, + "subdir": "linux-64", + "timestamp": 1607464191822, + "version": "0.26.2" + }, + "argon2-cffi-20.1.0-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "constrains": [ + "argon2_cffi ==999" + ], + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bfc0ef1e97fdb123322e81083f4dd8b0", + "name": "argon2-cffi", + "sha256": "b5d973c94a91c402a643a2651579c2b9da1ab0a2d977576d1cd39d43836977d6", + "size": 85742, + "subdir": "linux-64", + "timestamp": 1641902210667, + "version": "20.1.0" + }, + "argon2-cffi-20.1.0-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "constrains": [ + "argon2_cffi ==999" + ], + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b7a1c6d3a657626fce3392d34bf9c85", + "name": "argon2-cffi", + "sha256": "9af826ac58bc3163592c912c00724f8764007d9151e1d9947d38a7242e4d8fd4", + "size": 47345, + "subdir": "linux-64", + "timestamp": 1613037547824, + "version": "20.1.0" + }, + "argon2-cffi-20.1.0-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "constrains": [ + "argon2_cffi ==999" + ], + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb8304107f6dce5a5d3be66fd7517cda", + "name": "argon2-cffi", + "sha256": "2019ea86c61fdf82ee211cd16da57a3ab0cf1ebc41ba51516a723b6c77f6bf9f", + "size": 47095, + "subdir": "linux-64", + "timestamp": 1596828535063, + "version": "20.1.0" + }, + "argon2-cffi-20.1.0-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "constrains": [ + "argon2_cffi ==999" + ], + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f7df97ce90a0ccd1f45c57539baa84bf", + "name": "argon2-cffi", + "sha256": "51169273e56a8a9c870b6005d1ecbd85c20292f5e3e848614542f9649342af97", + "size": 47332, + "subdir": "linux-64", + "timestamp": 1613036689103, + "version": "20.1.0" + }, + "argon2-cffi-20.1.0-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "constrains": [ + "argon2_cffi ==999" + ], + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "480dfc89aaafc9fed3639e0fc1099ec5", + "name": "argon2-cffi", + "sha256": "6c8a1179c8605b2d5b3d7cbbccc4a268ae3a23ea840985715528fd082d89c757", + "size": 47180, + "subdir": "linux-64", + "timestamp": 1596828486772, + "version": "20.1.0" + }, + "argon2-cffi-20.1.0-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "constrains": [ + "argon2_cffi ==999" + ], + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d915ab1205a2e1881bb28fde360630b", + "name": "argon2-cffi", + "sha256": "4e720aa8383cb2a58b5af982eec0de7fa193ec9ffb6c80d56c029c1354d18a90", + "size": 47426, + "subdir": "linux-64", + "timestamp": 1613037152435, + "version": "20.1.0" + }, + "argon2-cffi-20.1.0-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "constrains": [ + "argon2_cffi ==999" + ], + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fbfc8c7a911cd972b320d3116df00079", + "name": "argon2-cffi", + "sha256": "abdf4b79a0a5573758a5a8dfe72845dfa8765e2b5d016f61e35d5cd3a0921f52", + "size": 47386, + "subdir": "linux-64", + "timestamp": 1596828538063, + "version": "20.1.0" + }, + "argon2-cffi-20.1.0-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "constrains": [ + "argon2_cffi ==999" + ], + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d511b854c06c232018b909a1b80b3a75", + "name": "argon2-cffi", + "sha256": "512b42c4b737ffd21d5f97e92650f5c422300fd2e3e0a8fe03b6a3fc93813dbe", + "size": 47372, + "subdir": "linux-64", + "timestamp": 1613037556701, + "version": "20.1.0" + }, + "argon2-cffi-20.1.0-py39he8ac12f_1.conda": { + "build": "py39he8ac12f_1", + "build_number": 1, + "constrains": [ + "argon2_cffi ==999" + ], + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39307731746b9c1634bbd67939a5609e", + "name": "argon2-cffi", + "sha256": "e5a9375eb78112b44b9c6fe19049b1f134ad008bf5aba1815551afcd77d119b9", + "size": 47483, + "subdir": "linux-64", + "timestamp": 1607022511360, + "version": "20.1.0" + }, + "argon2-cffi-bindings-21.2.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.1", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d70cc9c1ada3adfbe0f8912f43b3f7e6", + "name": "argon2-cffi-bindings", + "sha256": "9b28e9c71766ffaca51b804f4f6983ce6d0b6d59af40669e345fb244d0b9ca9c", + "size": 74040, + "subdir": "linux-64", + "timestamp": 1644553401362, + "version": "21.2.0" + }, + "argon2-cffi-bindings-21.2.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.1", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d55780f1b0565117ec0f9154fd533be8", + "name": "argon2-cffi-bindings", + "sha256": "aa857b98b45541d1337cbaed209ea211baa3986f6956fd42fea92f1d11b38d3b", + "size": 33565, + "subdir": "linux-64", + "timestamp": 1676823571351, + "version": "21.2.0" + }, + "argon2-cffi-bindings-21.2.0-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.1", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bbb6f2eb49c32ad500edc1cd8eb7d0d8", + "name": "argon2-cffi-bindings", + "sha256": "9e176586125b89fd24a4e9028c4d28e1046538b0c97053ee805d5cca6750c420", + "size": 33317, + "subdir": "linux-64", + "timestamp": 1644569720887, + "version": "21.2.0" + }, + "argon2-cffi-bindings-21.2.0-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.1", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "933eaa8ad180b8fb3b0e2ca36fb6954e", + "name": "argon2-cffi-bindings", + "sha256": "375b07446fe55a74a1d23da4b4e74d542e73aa67b43fad7ebd9e2bf0f044ca15", + "size": 33340, + "subdir": "linux-64", + "timestamp": 1644569723962, + "version": "21.2.0" + }, + "argon2-cffi-bindings-21.2.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.1", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c8ffbd66912b614dc1803a385db161b0", + "name": "argon2-cffi-bindings", + "sha256": "3a4ec2db2ff78f1e50e4c99e72c6b6cad78ae849983fd74defb451a3a4c35537", + "size": 33330, + "subdir": "linux-64", + "timestamp": 1644569715988, + "version": "21.2.0" + }, + "argon2_cffi-18.1.0-py27h14c3975_2.conda": { + "build": "py27h14c3975_2", + "build_number": 2, + "depends": [ + "cffi >=1.0.0", + "enum34", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "78e0e1f2025d52f624746d33800d9ed3", + "name": "argon2_cffi", + "sha256": "7102fbf4d390518e65ea69e9b327ea48a2adeca04b9b7a7de888654bd22a2abf", + "size": 40549, + "subdir": "linux-64", + "timestamp": 1530736241255, + "version": "18.1.0" + }, + "argon2_cffi-18.1.0-py35h14c3975_2.conda": { + "build": "py35h14c3975_2", + "build_number": 2, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "649935750f837cb6c24203aef1ab1d89", + "name": "argon2_cffi", + "sha256": "bff81a85ed7053395c56f272e8f140b060908e8389b7104ad96abec59e2bf148", + "size": 40730, + "subdir": "linux-64", + "timestamp": 1534352230703, + "version": "18.1.0" + }, + "argon2_cffi-18.1.0-py36h14c3975_2.conda": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9dead2f115cfdf2937630f1193106d9", + "name": "argon2_cffi", + "sha256": "1ed7d97247a81c40bf847b61ccf2472041a9c66574fc5288719a37be2846721a", + "size": 40502, + "subdir": "linux-64", + "timestamp": 1530736216724, + "version": "18.1.0" + }, + "argon2_cffi-18.1.0-py37h14c3975_2.conda": { + "build": "py37h14c3975_2", + "build_number": 2, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a6327dc0d11e72b5237567538c3ed84", + "name": "argon2_cffi", + "sha256": "5b27c8e57be3edc9a4f9c722791c28290f24b8cc3e4f85aa5799192790b578f6", + "size": 40628, + "subdir": "linux-64", + "timestamp": 1530736265061, + "version": "18.1.0" + }, + "argon2_cffi-18.3.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "enum34", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cafdfe94757c52578d06ab09c21cf9d2", + "name": "argon2_cffi", + "sha256": "a821514fe16771d04162645d2bf939566249186a6776c820ab1e2ea7efe8fcaa", + "size": 44713, + "subdir": "linux-64", + "timestamp": 1535422627228, + "version": "18.3.0" + }, + "argon2_cffi-18.3.0-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b74f76881911102ccc91179fbd12d39e", + "name": "argon2_cffi", + "sha256": "e3222cfd4ff88eebd6cbf39ad95b482ee4d3d5c85f3cd23936ce9a930af623bf", + "size": 45047, + "subdir": "linux-64", + "timestamp": 1535422942699, + "version": "18.3.0" + }, + "argon2_cffi-18.3.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08c3440d1c8a3eac04e29f6dbe9d1b37", + "name": "argon2_cffi", + "sha256": "aa91f077a15ee5bfa5c7c988dc959933edf35e48e1590a3515df72ffc122b130", + "size": 45640, + "subdir": "linux-64", + "timestamp": 1535422802102, + "version": "18.3.0" + }, + "argon2_cffi-18.3.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2820f2277b655ddb8383dcc33002412", + "name": "argon2_cffi", + "sha256": "96ebadad79069cb7b5877f70b76a549f81444fb73641366dbf19d800bce42453", + "size": 44989, + "subdir": "linux-64", + "timestamp": 1535423075430, + "version": "18.3.0" + }, + "argon2_cffi-19.1.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "enum34", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f7efb9b57b79c0b0add5b72b058c6682", + "name": "argon2_cffi", + "sha256": "db7dc54f61e7b9cc965a5291ee2e313aed39acb61ab3c73e7b8a2bf6d0af2c79", + "size": 47020, + "subdir": "linux-64", + "timestamp": 1547746836072, + "version": "19.1.0" + }, + "argon2_cffi-19.1.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74c1fe2ac26e6dac32d555b5c12b5f44", + "name": "argon2_cffi", + "sha256": "09268dedcb26451704c18813d788d329ea4f5061c578c3f132f1d789297d3415", + "size": 47615, + "subdir": "linux-64", + "timestamp": 1547746876470, + "version": "19.1.0" + }, + "argon2_cffi-19.1.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c2944842c8e8582376d9226a9e20320", + "name": "argon2_cffi", + "sha256": "a211b90ec14c03e61f12fb2bd8fb2b1822d2d565dbe89be3ce6d6c9828c24b7f", + "size": 46985, + "subdir": "linux-64", + "timestamp": 1547746954001, + "version": "19.1.0" + }, + "argon2_cffi-19.1.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66bb9ec116303598c8d8fc46e0a89eec", + "name": "argon2_cffi", + "sha256": "0bc7946ac65d879eeaaa0c2e50580023601353ec48c21e95f0f6d8b23bf10740", + "size": 45005, + "subdir": "linux-64", + "timestamp": 1574097565199, + "version": "19.1.0" + }, + "arrow-0.10.0-py27hc811e17_0.conda": { + "build": "py27hc811e17_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "md5": "5aa66f8495293b584260f80143574663", + "name": "arrow", + "sha256": "8f26c2410f56ae4a22456fc4ac790ab9a55cb58b8835fb82db3c68fc408c222c", + "size": 71090, + "subdir": "linux-64", + "timestamp": 1505693773499, + "version": "0.10.0" + }, + "arrow-0.10.0-py35h5f21c2d_0.conda": { + "build": "py35h5f21c2d_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "md5": "7165023f825d39bc4091665f53335c27", + "name": "arrow", + "sha256": "b3a463226ab80db3eb4caa330cf22b1cae9307e73d6564f64aad1995aa55ea30", + "size": 71805, + "subdir": "linux-64", + "timestamp": 1505693785721, + "version": "0.10.0" + }, + "arrow-0.10.0-py36h012aaaf_0.conda": { + "build": "py36h012aaaf_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "md5": "a9c913f22771bfee22e3c8d6f060420e", + "name": "arrow", + "sha256": "674c2f2f8887fa20f72efd985ebb4dfc784f9c5b81b80e37907d7a3501c47392", + "size": 70527, + "subdir": "linux-64", + "timestamp": 1505693797990, + "version": "0.10.0" + }, + "arrow-0.12.0-py27hc0e3b90_0.conda": { + "build": "py27hc0e3b90_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "python >=2.7,<2.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3882a25f5e4c3784fccc66863ff0b5c2", + "name": "arrow", + "sha256": "6144191b89b5bde40daf2a01920f5161550203fe96c6ab2a0a5eb8bb7c68cdc7", + "size": 77433, + "subdir": "linux-64", + "timestamp": 1512027609502, + "version": "0.12.0" + }, + "arrow-0.12.0-py35h71c922e_0.conda": { + "build": "py35h71c922e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "caef1e585180f20711830341c6e45b07", + "name": "arrow", + "sha256": "81bcb4098dd371c58d6455efdca0c061094dd68bf79afa015d454605a661170c", + "size": 78198, + "subdir": "linux-64", + "timestamp": 1512027610325, + "version": "0.12.0" + }, + "arrow-0.12.0-py36h92fbc78_0.conda": { + "build": "py36h92fbc78_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "15b1c4d3c523c4cf27bd304e6f071f06", + "name": "arrow", + "sha256": "0f2a0a209325e2d9c7924082849eb2b28e33761cf5986ef8b3925e366baa8bf3", + "size": 77537, + "subdir": "linux-64", + "timestamp": 1512027601232, + "version": "0.12.0" + }, + "arrow-0.12.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "backports.functools_lru_cache", + "python >=2.7,<2.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d982d5e4783b057e239e9b30cfb3d1b0", + "name": "arrow", + "sha256": "b7509f1aefd6c03aa5ef0f0c0e2b07b811c15ff5dbdbf3fb27104415845e68c4", + "size": 77210, + "subdir": "linux-64", + "timestamp": 1520882477481, + "version": "0.12.1" + }, + "arrow-0.12.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bc4e9ac9ed7a5688ba8a9409b8b9e8fa", + "name": "arrow", + "sha256": "acb7c4c2b29a6f47744c0316f195a97215c430efe957133967298b54c919a735", + "size": 77978, + "subdir": "linux-64", + "timestamp": 1520882507070, + "version": "0.12.1" + }, + "arrow-0.12.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fa766b8da6fef0a23d681144dde3359a", + "name": "arrow", + "sha256": "90efbd072be0f0aa4379502217b38bcb810467703c407439d17e61450a29ea33", + "size": 76862, + "subdir": "linux-64", + "timestamp": 1520905296301, + "version": "0.12.1" + }, + "arrow-0.12.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0ac73b11713c014d43026267fe74cac8", + "name": "arrow", + "sha256": "8367edf242761e027cc58b5b9623c0eb3716034b8c395576c81a500311d418e9", + "size": 77109, + "subdir": "linux-64", + "timestamp": 1530737757161, + "version": "0.12.1" + }, + "arrow-0.13.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "python >=2.7,<2.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4e616055c66a8eaf30cc086a66a7b3c8", + "name": "arrow", + "sha256": "d2705a4a55ab46bf9a44eed2606cc1d6ff64c933c358f65e50cca09f0a04a041", + "size": 84910, + "subdir": "linux-64", + "timestamp": 1550266373138, + "version": "0.13.1" + }, + "arrow-0.13.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0a551a9c1e9d968c8aff3388283d5428", + "name": "arrow", + "sha256": "bd0127bd7d1ccfdad956c435aab2f0a697cf84ca9d31fb87b3293e778ad463ab", + "size": 84243, + "subdir": "linux-64", + "timestamp": 1550266412556, + "version": "0.13.1" + }, + "arrow-0.13.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "708cf0fe9469366cdc44a0529544d161", + "name": "arrow", + "sha256": "40dfaa40a0a206265b24368615e177710151ccade00d924e262d2fa10e5b7a91", + "size": 84198, + "subdir": "linux-64", + "timestamp": 1550266335026, + "version": "0.13.1" + }, + "arrow-0.13.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0531095eaeb079ce618207c7e52b0b84", + "name": "arrow", + "sha256": "ffaf0055297ea169158d5a78682c8cbef01d7239c7d8fe6280310e66d2c5872c", + "size": 82566, + "subdir": "linux-64", + "timestamp": 1574097587346, + "version": "0.13.1" + }, + "arrow-0.13.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a1ad97b165aa6019f98ddea2f6551511", + "name": "arrow", + "sha256": "0a70ae7d68894b3e0b0c2072fded696a3eddd4e86a5f4db836959cd6734cc3a0", + "size": 85031, + "subdir": "linux-64", + "timestamp": 1617737723768, + "version": "0.13.1" + }, + "arrow-0.15.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cdb510989d4a586796d7771365bd2bd9", + "name": "arrow", + "sha256": "2550578ee3db51b3ac92f5b542c3155a12775691ce589605bdfa4b7461eb0768", + "size": 104155, + "subdir": "linux-64", + "timestamp": 1601735553387, + "version": "0.15.6" + }, + "arrow-0.15.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7d1bda674b1996d34cf4d8bee890e874", + "name": "arrow", + "sha256": "c014808d3eb43f46e4c74917c5727f9f42895d02fe98774790a1f1483fdd7575", + "size": 104401, + "subdir": "linux-64", + "timestamp": 1601735543978, + "version": "0.15.6" + }, + "arrow-0.15.6-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f2bda43f77cd4fd09d190255f6496b77", + "name": "arrow", + "sha256": "a26e58948e4ea5e770efac0495ab98eabe443e99d2a429dc0c413c2ee5a98f6d", + "size": 104949, + "subdir": "linux-64", + "timestamp": 1591915706854, + "version": "0.15.6" + }, + "arrow-0.15.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "752dc677aebeebbe542c4a4489a7e226", + "name": "arrow", + "sha256": "45478d00abf48cb466987796cbef9adfdd18e250bb648605279e1a1904eafafd", + "size": 110864, + "subdir": "linux-64", + "timestamp": 1597097805450, + "version": "0.15.8" + }, + "arrow-0.15.8-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "94825efea30644ff7cdfdfce761cfe72", + "name": "arrow", + "sha256": "df2a0f5cd339738c067d999ee18ebbaf5d7dbd71dddc4049eac9d15757abd426", + "size": 109783, + "subdir": "linux-64", + "timestamp": 1614002840308, + "version": "0.15.8" + }, + "arrow-0.15.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c8113bd77d5edb1af16bdf636a1c5cc0", + "name": "arrow", + "sha256": "91795befaeaa6a7ea5b688f728a115c3bef43bbc7bd1e92ea915fb997c586fbd", + "size": 110666, + "subdir": "linux-64", + "timestamp": 1597085457007, + "version": "0.15.8" + }, + "arrow-0.15.8-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "579db6cfb294116576ece7c6e12968cf", + "name": "arrow", + "sha256": "a0f7b059371a8809267702694fa4d63693db786acda2f3e8584b703faf3b8555", + "size": 109901, + "subdir": "linux-64", + "timestamp": 1614001956698, + "version": "0.15.8" + }, + "arrow-0.15.8-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a9a1ec455c7424418ecec10d82b17d93", + "name": "arrow", + "sha256": "960eb7e964df6f39ec2e29cb33d579e490cdb80d4e8c03e1ef3e11b5fb8af781", + "size": 111764, + "subdir": "linux-64", + "timestamp": 1597097814080, + "version": "0.15.8" + }, + "arrow-0.15.8-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "418d2fd84f28de6c660b9fb8094bcd18", + "name": "arrow", + "sha256": "a4c44790dad7aae43dc11aec5c4f097ae42ea2c5e5b1125fa6e626b457dc9452", + "size": 110563, + "subdir": "linux-64", + "timestamp": 1614002416711, + "version": "0.15.8" + }, + "arrow-0.15.8-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c9a3b26799870204eae0978c6b78bed8", + "name": "arrow", + "sha256": "9d884500dd1a0476ebb693e6f1f76938ada57f27a31ba6370cb2768e81c6d1c5", + "size": 110013, + "subdir": "linux-64", + "timestamp": 1614009238269, + "version": "0.15.8" + }, + "arrow-0.16.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "58a7f56d80f2c8c020f73b02d09633fd", + "name": "arrow", + "sha256": "9c0c1d1f04f9ce48f907d6db20c01527c9ccd2f2a47d4ce5f2ade309b7892808", + "size": 111527, + "subdir": "linux-64", + "timestamp": 1599270387420, + "version": "0.16.0" + }, + "arrow-0.16.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6cb952b412e4bf3d0f37a1508e8d4e3e", + "name": "arrow", + "sha256": "b91af4fe72090ac8078b9c16da44f68a3388adb6ee9b9863c9285e8b75de7aae", + "size": 111563, + "subdir": "linux-64", + "timestamp": 1599270405948, + "version": "0.16.0" + }, + "arrow-0.16.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dbda721f8a4887fd229ec2e32f06d217", + "name": "arrow", + "sha256": "5caf958b323da5fc1ffd3b8db0cdc2d1c6f8bf60067313da050472754d2e19d4", + "size": 112162, + "subdir": "linux-64", + "timestamp": 1599270454152, + "version": "0.16.0" + }, + "arrow-1.0.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cc491766141f039e12983520d5c989a5", + "name": "arrow", + "sha256": "db1aa7d9e895adfe6b7a198dae226358606e02e6973f6e9c543644c4c820ea3a", + "size": 120114, + "subdir": "linux-64", + "timestamp": 1615555990965, + "version": "1.0.3" + }, + "arrow-1.0.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ed8918c33efdfc04caad27f3db5beec6", + "name": "arrow", + "sha256": "c2010838486d176bfca38a0fb0aa3afd2f05e3ac7c0e43c8787cb1ac34e4b1c6", + "size": 119802, + "subdir": "linux-64", + "timestamp": 1615555987627, + "version": "1.0.3" + }, + "arrow-1.0.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6a0c6fc8c101fd35ce2d8deffd34c355", + "name": "arrow", + "sha256": "dbceb825b45b928dac1f0409c8303cae08ca376675d79503cdfc66c02da96fdc", + "size": 120016, + "subdir": "linux-64", + "timestamp": 1615555993582, + "version": "1.0.3" + }, + "arrow-1.0.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "33902f1194e28f2a5f3cef39f60ada19", + "name": "arrow", + "sha256": "6a2da2947e4f7d7a802b19535b4b19cde25bacdc8c496dcc6b9cee3f3160b432", + "size": 120627, + "subdir": "linux-64", + "timestamp": 1615555988318, + "version": "1.0.3" + }, + "arrow-1.1.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.7.0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "329084450028ef822423d2544c7fcdad", + "name": "arrow", + "sha256": "406444c4965302ef9558c121559c57be633bd4f37a2589f0f54ee246a920db08", + "size": 126286, + "subdir": "linux-64", + "timestamp": 1619685708145, + "version": "1.1.0" + }, + "arrow-1.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ab186527f5bcddc82a6ca94119cb3991", + "name": "arrow", + "sha256": "49775c14c59b1ec000fa96ea5c9ce9dd4be1c47cfcece8320ae2fe15d7c9be5b", + "size": 126243, + "subdir": "linux-64", + "timestamp": 1619685813094, + "version": "1.1.0" + }, + "arrow-1.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f672af1bc05c4274209326db138b0c03", + "name": "arrow", + "sha256": "9953180e6dd78912df24edb04b6f38e9ad20d5574e857e53e2c63460ca8e203a", + "size": 129138, + "subdir": "linux-64", + "timestamp": 1619685812299, + "version": "1.1.0" + }, + "arrow-1.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ee5272de06d4533797c7b6f2a5611911", + "name": "arrow", + "sha256": "1daf0e5c33855ddd39c7b2d8ad4b903d994718d03aae60f3f147819d1ae7f5c2", + "size": 128484, + "subdir": "linux-64", + "timestamp": 1619685811420, + "version": "1.1.0" + }, + "arrow-1.1.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3f859e9f64ad9f9bd7926a88fbefc35f", + "name": "arrow", + "sha256": "587fa4e51f35d458320e9b06f3d6bfe72e35898592cd2d8968f1036087b93384", + "size": 131654, + "subdir": "linux-64", + "timestamp": 1641902016982, + "version": "1.1.1" + }, + "arrow-1.1.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.7.0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6cb451027a9d2e5f19ae409beb24cbe8", + "name": "arrow", + "sha256": "6c655c16bab8338511bba99079f1bd082acff5b1a7bdaba8e2258cea95ebc9ff", + "size": 130370, + "subdir": "linux-64", + "timestamp": 1624645869670, + "version": "1.1.1" + }, + "arrow-1.1.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "df2431e19d9e0ea7cdbb70a8c2ecd78e", + "name": "arrow", + "sha256": "10c5a7784c854851ecb988c197cc4fe5ba062e11d1588e79346e73b456fc67e3", + "size": 131130, + "subdir": "linux-64", + "timestamp": 1624646050579, + "version": "1.1.1" + }, + "arrow-1.1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4f335980fe10905ed752b0c010fccd27", + "name": "arrow", + "sha256": "cf2bf37eb3d4139755b2c4e030b2979e57d7f312b9b8f26aec25df062e0761c7", + "size": 131577, + "subdir": "linux-64", + "timestamp": 1624646019194, + "version": "1.1.1" + }, + "arrow-1.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "813a3ebfdfb18aefc934e0e0ae5acfc7", + "name": "arrow", + "sha256": "e980f6cbbef5e1e37559ee80d60d8e027ed20dceb06e9c3fe94e662ac9b81987", + "size": 130969, + "subdir": "linux-64", + "timestamp": 1624639786282, + "version": "1.1.1" + }, + "arrow-1.2.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "009f6979897501c571a1a09cce6fe354", + "name": "arrow", + "sha256": "879a53f9a5fc4daf3201ee47c98b46b35129c6d66e02667ca10a27a6523e0308", + "size": 148135, + "subdir": "linux-64", + "timestamp": 1666726982067, + "version": "1.2.3" + }, + "arrow-1.2.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1e784b183b58f1539b74ce7b6a18a118", + "name": "arrow", + "sha256": "7b78f6c13e86341c648621976823724f9d537c46734c36a324a2ecea3acf9538", + "size": 159285, + "subdir": "linux-64", + "timestamp": 1676588289228, + "version": "1.2.3" + }, + "arrow-1.2.3-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "84604553262f8f1c3aa4904f45ffabb8", + "name": "arrow", + "sha256": "40ee908d511376afe1ff8d93d52d94c404c5de3f977625291ef70888e7901d4e", + "size": 172215, + "subdir": "linux-64", + "timestamp": 1677696260356, + "version": "1.2.3" + }, + "arrow-1.2.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "719173aa813bda17e41bd15d7a6ca8f3", + "name": "arrow", + "sha256": "85aa2308783e3d24a27ccc135fea5c9d6a315d4a029b8aefd9be33a0302071cc", + "size": 146386, + "subdir": "linux-64", + "timestamp": 1666727022943, + "version": "1.2.3" + }, + "arrow-1.2.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "43ece9992021f9a46b9e0e5655dd9091", + "name": "arrow", + "sha256": "31e8733819d93f4a0982fca0553956fd83afe1b04f618f497debc4a129e7202d", + "size": 157604, + "subdir": "linux-64", + "timestamp": 1676588165040, + "version": "1.2.3" + }, + "arrow-1.2.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "693b3a837ecf3a651070cf34dde617d8", + "name": "arrow", + "sha256": "034caebfc52e5443af77a285b12b4a8edefd607ee6131f18221f99d9beddc05b", + "size": 147743, + "subdir": "linux-64", + "timestamp": 1666726902336, + "version": "1.2.3" + }, + "arrow-1.2.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "133be556575ef59c5ee897e34ed35239", + "name": "arrow", + "sha256": "516e0f5c0f8bf03ea114d4f67fd333a7e8508d65639b53ceffb4d365dacb2216", + "size": 158752, + "subdir": "linux-64", + "timestamp": 1676588248915, + "version": "1.2.3" + }, + "arrow-1.2.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ca9dd9c98c25191bdc1a737f8003f0c8", + "name": "arrow", + "sha256": "220bd74968fe0fa87b827e0ad841fae4399623d2bb8125248e57569eb320321e", + "size": 146921, + "subdir": "linux-64", + "timestamp": 1666726941316, + "version": "1.2.3" + }, + "arrow-1.2.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "45fdb285744b9b040dc2842af77ff1cd", + "name": "arrow", + "sha256": "3659c1d7f59da91dc605230d339e8b78dc052cf69f9a9e00ba7e55f0ca4eefba", + "size": 157887, + "subdir": "linux-64", + "timestamp": 1676588206741, + "version": "1.2.3" + }, + "arrow-cpp-0.11.0-py27h5c3f529_0.conda": { + "build": "py27h5c3f529_0", + "build_number": 0, + "depends": [ + "glog >=0.3.5,<0.3.6.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "c0c374966d43cf79e1ed43f282a8265e", + "name": "arrow-cpp", + "sha256": "4131d6648ad9c9b1ac00f99828ffeed2554ce48ed4f5a4f95f228351b153ad66", + "size": 4600107, + "subdir": "linux-64", + "timestamp": 1539967702856, + "version": "0.11.0" + }, + "arrow-cpp-0.11.0-py36h5c3f529_0.conda": { + "build": "py36h5c3f529_0", + "build_number": 0, + "depends": [ + "glog >=0.3.5,<0.3.6.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "d500e1ab8ca3575e14e5b5f8cf6e3295", + "name": "arrow-cpp", + "sha256": "3685bb2129dabbc315d47aa3d3a8e2a5fd28880d43171b9b50be86560dde305d", + "size": 4629201, + "subdir": "linux-64", + "timestamp": 1539967743950, + "version": "0.11.0" + }, + "arrow-cpp-0.11.0-py37h5c3f529_0.conda": { + "build": "py37h5c3f529_0", + "build_number": 0, + "depends": [ + "glog >=0.3.5,<0.3.6.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "5f82afde25c809518fe385ca107cff9d", + "name": "arrow-cpp", + "sha256": "c0394d29ecfe6407f0ccc88c6db98b62ebd0fe9c232ee0780a7fdb3951e12309", + "size": 4599506, + "subdir": "linux-64", + "timestamp": 1539967797477, + "version": "0.11.0" + }, + "arrow-cpp-0.11.1-py27h5c3f529_0.conda": { + "build": "py27h5c3f529_0", + "build_number": 0, + "depends": [ + "glog >=0.3.5,<0.3.6.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "7a5890ddd07b35dbcf82a229a23c6cbc", + "name": "arrow-cpp", + "sha256": "0c34c6ac5770e4683de69f22fed2954b0b2abc6f770a86bc2b2ebd389a84ae6d", + "size": 4619783, + "subdir": "linux-64", + "timestamp": 1540956814333, + "version": "0.11.1" + }, + "arrow-cpp-0.11.1-py27h5c3f529_1.conda": { + "build": "py27h5c3f529_1", + "build_number": 1, + "depends": [ + "glog >=0.3.5,<0.3.6.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "6cd469b2781a040f427bb80652003aef", + "name": "arrow-cpp", + "sha256": "a66cadde27607d15fc2600399a0d336512d0df248f53a2922e84b61f0b6ad0b7", + "size": 4680802, + "subdir": "linux-64", + "timestamp": 1559845998170, + "version": "0.11.1" + }, + "arrow-cpp-0.11.1-py36h5c3f529_0.conda": { + "build": "py36h5c3f529_0", + "build_number": 0, + "depends": [ + "glog >=0.3.5,<0.3.6.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "21228693765376761b933e547a720697", + "name": "arrow-cpp", + "sha256": "69bd35a8b185efb1d29346327c7b7ef33fc14d6fe7730ce6135fcd4ea9f0d6e1", + "size": 4594324, + "subdir": "linux-64", + "timestamp": 1540956676259, + "version": "0.11.1" + }, + "arrow-cpp-0.11.1-py36h5c3f529_1.conda": { + "build": "py36h5c3f529_1", + "build_number": 1, + "depends": [ + "glog >=0.3.5,<0.3.6.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "89d987208b98f336e62a22931f516da5", + "name": "arrow-cpp", + "sha256": "47e8b5790baa1241b18a13b0bb9b94d77e66cfedf937cf4567afbd3f82d3d8e8", + "size": 4675918, + "subdir": "linux-64", + "timestamp": 1559846008443, + "version": "0.11.1" + }, + "arrow-cpp-0.11.1-py37h5c3f529_0.conda": { + "build": "py37h5c3f529_0", + "build_number": 0, + "depends": [ + "glog >=0.3.5,<0.3.6.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "6a0882529c0bf76591510fd772431df2", + "name": "arrow-cpp", + "sha256": "98195a3619ede40fd3dbf09cb2f3a62b4f31e3556c604bdeedbd8eff4e1ce5bb", + "size": 4624327, + "subdir": "linux-64", + "timestamp": 1540956823016, + "version": "0.11.1" + }, + "arrow-cpp-0.11.1-py37h5c3f529_1.conda": { + "build": "py37h5c3f529_1", + "build_number": 1, + "depends": [ + "glog >=0.3.5,<0.3.6.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "6d659be28c9699a99cd00d1068befcad", + "name": "arrow-cpp", + "sha256": "60dceb07f36d7d3879c19fe59b3a0ab501250f564ce406d75dee13c38cf6532e", + "size": 4675891, + "subdir": "linux-64", + "timestamp": 1559845984569, + "version": "0.11.1" + }, + "arrow-cpp-0.13.0-py27h117bdfb_0.conda": { + "build": "py27h117bdfb_0", + "build_number": 0, + "depends": [ + "brotli", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.14,<2.0a0", + "python >=2.7,<2.8.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "9bbd7c70d1bda01e93c9f4c0039478a2", + "name": "arrow-cpp", + "sha256": "28ea1ec5cf6e61ebb3bf046e4516d7369fe4d29f509fceee7856f862578592bc", + "size": 3048227, + "subdir": "linux-64", + "timestamp": 1567110131307, + "version": "0.13.0" + }, + "arrow-cpp-0.13.0-py36h117bdfb_0.conda": { + "build": "py36h117bdfb_0", + "build_number": 0, + "depends": [ + "brotli", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.14,<2.0a0", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "a3ee37f7c018027f5d62e5dd0eeaddd8", + "name": "arrow-cpp", + "sha256": "e6d200ede31f58a1a0562668cc6c5265297fc9ebd0f3dc86245990824a86441a", + "size": 3047979, + "subdir": "linux-64", + "timestamp": 1567110229267, + "version": "0.13.0" + }, + "arrow-cpp-0.13.0-py37h117bdfb_0.conda": { + "build": "py37h117bdfb_0", + "build_number": 0, + "depends": [ + "brotli", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.14,<2.0a0", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "d276ca909eb399477ff87be1cb8155ca", + "name": "arrow-cpp", + "sha256": "15f2f7dfe356852c1184db50417208e21c50b5b67c0f843847dc2a6e760e0ae2", + "size": 3049207, + "subdir": "linux-64", + "timestamp": 1567110371697, + "version": "0.13.0" + }, + "arrow-cpp-0.13.0-py38h117bdfb_0.conda": { + "build": "py38h117bdfb_0", + "build_number": 0, + "depends": [ + "brotli", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.14,<2.0a0", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "3a553b7a711fcc52c5735fc6fd2d8e59", + "name": "arrow-cpp", + "sha256": "946369925ed3489c225514d2fc85e0d6075847db1f968be6f4a9e135cec546de", + "size": 3051133, + "subdir": "linux-64", + "timestamp": 1574092470347, + "version": "0.13.0" + }, + "arrow-cpp-0.15.1-py36h248a92f_5.conda": { + "build": "py36h248a92f_5", + "build_number": 5, + "depends": [ + "boost-cpp", + "brotli", + "bzip2 >=1.0.8,<2.0a0", + "c-ares", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libboost >=1.71.0,<1.71.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11,<2.0a0", + "openssl", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "uriparser", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "9c7a7ddcd9b8a2af98e148eb8de4d37d", + "name": "arrow-cpp", + "sha256": "e4cbb0827355f2ad095f87a301a5195e2112f831863f949308f2254b224ab8c0", + "size": 6001663, + "subdir": "linux-64", + "timestamp": 1580504282119, + "version": "0.15.1" + }, + "arrow-cpp-0.15.1-py36h7cd5009_5.conda": { + "build": "py36h7cd5009_5", + "build_number": 5, + "depends": [ + "boost-cpp", + "brotli", + "bzip2 >=1.0.8,<2.0a0", + "c-ares", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libboost >=1.71.0,<1.71.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11,<2.0a0", + "openssl", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "uriparser", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "9d092df835b952c0d72bfe5191dd35c0", + "name": "arrow-cpp", + "sha256": "9c62f28f38009baa1fcb2f44bc95bf042f09dd332a611c276096b7839598c045", + "size": 5986243, + "subdir": "linux-64", + "timestamp": 1582236502057, + "version": "0.15.1" + }, + "arrow-cpp-0.15.1-py36hfa00764_6.conda": { + "build": "py36hfa00764_6", + "build_number": 6, + "depends": [ + "boost-cpp", + "brotli", + "bzip2 >=1.0.8,<2.0a0", + "c-ares", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11,<2.0a0", + "openssl", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "uriparser", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "9fba392c07ee4a14a71a4b5ff0d4b184", + "name": "arrow-cpp", + "sha256": "93192e88ef01dbda29a58e1114c6a1fa257c9b0cdf5654ecf0b873ab49c38972", + "size": 5989759, + "subdir": "linux-64", + "timestamp": 1583165501727, + "version": "0.15.1" + }, + "arrow-cpp-0.15.1-py37h248a92f_5.conda": { + "build": "py37h248a92f_5", + "build_number": 5, + "depends": [ + "boost-cpp", + "brotli", + "bzip2 >=1.0.8,<2.0a0", + "c-ares", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libboost >=1.71.0,<1.71.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11,<2.0a0", + "openssl", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "uriparser", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "1d3d96d3a3acf8c4533e07088071369c", + "name": "arrow-cpp", + "sha256": "d3f006b4bf3f5971e45cf3e426e09433feb833856575aa8e296c0f99a5febd4e", + "size": 6001126, + "subdir": "linux-64", + "timestamp": 1580504130319, + "version": "0.15.1" + }, + "arrow-cpp-0.15.1-py37h7cd5009_5.conda": { + "build": "py37h7cd5009_5", + "build_number": 5, + "depends": [ + "boost-cpp", + "brotli", + "bzip2 >=1.0.8,<2.0a0", + "c-ares", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libboost >=1.71.0,<1.71.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11,<2.0a0", + "openssl", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "uriparser", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "be497fa9d97fbd7ae51402bdeddcfa9e", + "name": "arrow-cpp", + "sha256": "78de9d7e94d40ed39274654f1d61cb32b803adb98d855444c84088f6b5c2d55f", + "size": 5986117, + "subdir": "linux-64", + "timestamp": 1582236797441, + "version": "0.15.1" + }, + "arrow-cpp-0.15.1-py37hfa00764_6.conda": { + "build": "py37hfa00764_6", + "build_number": 6, + "depends": [ + "boost-cpp", + "brotli", + "bzip2 >=1.0.8,<2.0a0", + "c-ares", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11,<2.0a0", + "openssl", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "uriparser", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "009d5c94d26603fa2a353104c762d6e4", + "name": "arrow-cpp", + "sha256": "7108b6bda9796d291ec332385fa5a61f51762d29b1ac5720b0a473adeeda46d9", + "size": 5992134, + "subdir": "linux-64", + "timestamp": 1583165495260, + "version": "0.15.1" + }, + "arrow-cpp-0.15.1-py38h248a92f_5.conda": { + "build": "py38h248a92f_5", + "build_number": 5, + "depends": [ + "boost-cpp", + "brotli", + "bzip2 >=1.0.8,<2.0a0", + "c-ares", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libboost >=1.71.0,<1.71.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11,<2.0a0", + "openssl", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "uriparser", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "1ed5bfe127db7a7ef4438a3f862c792b", + "name": "arrow-cpp", + "sha256": "ebadd42c324ff80e95b6e46a20d8e1aed835f835b9203af70038316ce6f0e035", + "size": 5993057, + "subdir": "linux-64", + "timestamp": 1580504226514, + "version": "0.15.1" + }, + "arrow-cpp-0.15.1-py38h7cd5009_5.conda": { + "build": "py38h7cd5009_5", + "build_number": 5, + "depends": [ + "boost-cpp", + "brotli", + "bzip2 >=1.0.8,<2.0a0", + "c-ares", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libboost >=1.71.0,<1.71.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11,<2.0a0", + "openssl", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "uriparser", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "86dcbaa46fadd37c0864f81466ab2fda", + "name": "arrow-cpp", + "sha256": "1ed43905ca22491ac7aa3bef284f19d018bece2be63250f9651d8a0e379c1a44", + "size": 6003367, + "subdir": "linux-64", + "timestamp": 1582236472370, + "version": "0.15.1" + }, + "arrow-cpp-0.15.1-py38hfa00764_6.conda": { + "build": "py38hfa00764_6", + "build_number": 6, + "depends": [ + "boost-cpp", + "brotli", + "bzip2 >=1.0.8,<2.0a0", + "c-ares", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.4.0,<1.0a0", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11,<2.0a0", + "openssl", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.7,<2.0a0", + "thrift-cpp >=0.11.0,<0.12.0a0", + "uriparser", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "63883635e5d27d231273e7d7451a744c", + "name": "arrow-cpp", + "sha256": "56881d3951f76fdbc61f38942228bdb645b6d426ebdf6aeed55fe85ccfdf2b74", + "size": 6005452, + "subdir": "linux-64", + "timestamp": 1583165493860, + "version": "0.15.1" + }, + "arrow-cpp-0.9.0-py27h165c0fa_6.conda": { + "build": "py27h165c0fa_6", + "build_number": 6, + "depends": [ + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "ad042cb07cfb1a4e558fbb1fff5953de", + "name": "arrow-cpp", + "sha256": "cc94802b2fe515207f820a0d346ebae54683dddcd02a1582adc318071034bbae", + "size": 3687795, + "subdir": "linux-64", + "timestamp": 1529459519289, + "version": "0.9.0" + }, + "arrow-cpp-0.9.0-py27h165c0fa_7.conda": { + "build": "py27h165c0fa_7", + "build_number": 7, + "depends": [ + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "6e4641035bba32fc91b02202b226220c", + "name": "arrow-cpp", + "sha256": "1ad24633198e6edb99c375360c35ec33838375ab296312e31896f9d92425a8aa", + "size": 3732629, + "subdir": "linux-64", + "timestamp": 1529509448786, + "version": "0.9.0" + }, + "arrow-cpp-0.9.0-py35h165c0fa_6.conda": { + "build": "py35h165c0fa_6", + "build_number": 6, + "depends": [ + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "dd999816bd3c026554acc6b958a58afd", + "name": "arrow-cpp", + "sha256": "af3f8e1ac177eeed89bf3acb5dc3209b1822deda840d02e6fab080dc68e18d9e", + "size": 3667720, + "subdir": "linux-64", + "timestamp": 1529459307601, + "version": "0.9.0" + }, + "arrow-cpp-0.9.0-py35h165c0fa_7.conda": { + "build": "py35h165c0fa_7", + "build_number": 7, + "depends": [ + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "ff18bea75d3c31407ad20ca9f2a878cf", + "name": "arrow-cpp", + "sha256": "3b53b3e5ef9156cd689db7b198abdc80e0e368a1ea70c43032654c33c2005b69", + "size": 3730956, + "subdir": "linux-64", + "timestamp": 1529509358071, + "version": "0.9.0" + }, + "arrow-cpp-0.9.0-py36h165c0fa_6.conda": { + "build": "py36h165c0fa_6", + "build_number": 6, + "depends": [ + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "b1a2089f17966e3a4b16e30d2235f93d", + "name": "arrow-cpp", + "sha256": "413d672928b97cc47b6ef8150c2c6dd11cd0c5f9bddb01adac976e62f71698ae", + "size": 3667621, + "subdir": "linux-64", + "timestamp": 1529459515154, + "version": "0.9.0" + }, + "arrow-cpp-0.9.0-py36h165c0fa_7.conda": { + "build": "py36h165c0fa_7", + "build_number": 7, + "depends": [ + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "Apache 2.0", + "md5": "bcd434c96a4b5fe7ad13f9c0d24ab4e0", + "name": "arrow-cpp", + "sha256": "354cc7099023437a4d446f6c857001887844d602224cbc3de854c85a7b23ad3e", + "size": 3704864, + "subdir": "linux-64", + "timestamp": 1529509443411, + "version": "0.9.0" + }, + "arrow-cpp-10.0.1-py310h7516544_0.conda": { + "build": "py310h7516544_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.5.0,<0.6.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "openssl >=1.1.1t,<1.1.2a", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.10,<3.11.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "95bce5adb3aec7e880a07d1c052b3afb", + "name": "arrow-cpp", + "sha256": "dacde0858a79c6c77ffb9d1c40619df0504a106238128e31d89ba7bdb673e557", + "size": 10455517, + "subdir": "linux-64", + "timestamp": 1680127369757, + "version": "10.0.1" + }, + "arrow-cpp-10.0.1-py311ha0d4687_0.conda": { + "build": "py311ha0d4687_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.5.0,<0.6.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "openssl >=1.1.1t,<1.1.2a", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.11,<3.12.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b77f7bbbdece87543eebdd6d5fc8f53c", + "name": "arrow-cpp", + "sha256": "da37b5c39fb4a2c0895e295a36b6b9b54304bb8e4572599d9d7835ea7079c544", + "size": 10455530, + "subdir": "linux-64", + "timestamp": 1680128491333, + "version": "10.0.1" + }, + "arrow-cpp-10.0.1-py38h613000e_0.conda": { + "build": "py38h613000e_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.5.0,<0.6.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "openssl >=1.1.1t,<1.1.2a", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.8,<3.9.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0ece5c95dcc5a984b126638992ad5d7e", + "name": "arrow-cpp", + "sha256": "83e0abd7183e69e0559e574d397d15f4288d05d3048c8c9ec0909da167ae4c52", + "size": 10455534, + "subdir": "linux-64", + "timestamp": 1680129618662, + "version": "10.0.1" + }, + "arrow-cpp-10.0.1-py39h613000e_0.conda": { + "build": "py39h613000e_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.5.0,<0.6.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "openssl >=1.1.1t,<1.1.2a", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.9,<3.10.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e91d4a577e4fbbbf4bc9e6f671dfc885", + "name": "arrow-cpp", + "sha256": "fc98fcd20934b44908318cd32011dfd23e6e1d35da3bf290488dc122ac61290d", + "size": 10455577, + "subdir": "linux-64", + "timestamp": 1680130747308, + "version": "10.0.1" + }, + "arrow-cpp-2.0.0-py36hced866c_0.conda": { + "build": "py36hced866c_0", + "build_number": 0, + "depends": [ + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "7489d304c31abedf318034d725dced17", + "name": "arrow-cpp", + "sha256": "9f8510f314efc3ff5074f1dcadc0200680d1311d57d8bdb232086d648f029e98", + "size": 6558009, + "subdir": "linux-64", + "timestamp": 1612017629716, + "version": "2.0.0" + }, + "arrow-cpp-2.0.0-py37hced866c_0.conda": { + "build": "py37hced866c_0", + "build_number": 0, + "depends": [ + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "42d16af6da38abfca32cd6c5f895dbc9", + "name": "arrow-cpp", + "sha256": "8540be0d47455cffad4fd0ffc47725e785219e40eb3cab1b5e55e337e363a00d", + "size": 6548452, + "subdir": "linux-64", + "timestamp": 1612017570014, + "version": "2.0.0" + }, + "arrow-cpp-2.0.0-py38hced866c_0.conda": { + "build": "py38hced866c_0", + "build_number": 0, + "depends": [ + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "8189aa56e930234b0c7b17e304472ec2", + "name": "arrow-cpp", + "sha256": "5027ac6e0dc11bae76212e5b52621e1a6ac243ad8265cdb61cb536ef14366d19", + "size": 6556165, + "subdir": "linux-64", + "timestamp": 1612017618265, + "version": "2.0.0" + }, + "arrow-cpp-2.0.0-py39hced866c_0.conda": { + "build": "py39hced866c_0", + "build_number": 0, + "depends": [ + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.9,<3.10.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "bad4f6667dddf523c6ae49c5e8d0b593", + "name": "arrow-cpp", + "sha256": "4093891c898b3ed50be3f8a996f133dcdb345d021e95b9bace8e57731d233a69", + "size": 6545142, + "subdir": "linux-64", + "timestamp": 1612017551376, + "version": "2.0.0" + }, + "arrow-cpp-3.0.0-py36h6b21186_4.conda": { + "build": "py36h6b21186_4", + "build_number": 4, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.5.0", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "libthrift >=0.14.2,<0.14.3.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1l,<1.1.2a", + "orc >=1.6.9,<1.6.10.0a0", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "5bc2d53d91b3ab611b223ada376874fa", + "name": "arrow-cpp", + "sha256": "b905ccd95e971fab0ea1de24c24ba2537b52ffce78683622d14453d47c795e89", + "size": 7449140, + "subdir": "linux-64", + "timestamp": 1632947201175, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py36hced866c_0.conda": { + "build": "py36hced866c_0", + "build_number": 0, + "depends": [ + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "0f9334654b84d6c77182e4299ddf67ef", + "name": "arrow-cpp", + "sha256": "15a34078e7bb8be35129d0b84611f6df754f209e07f37f84d7d1812341d2367e", + "size": 6786213, + "subdir": "linux-64", + "timestamp": 1612106232014, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py36hced866c_1.conda": { + "build": "py36hced866c_1", + "build_number": 1, + "depends": [ + "aws-sdk-cpp >=1.8.133,<1.8.134.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "0257cb993e56e3a414c1debfced20bc4", + "name": "arrow-cpp", + "sha256": "cb1841d06b0be2e9c6fd018b640ddd0ffb40f083690cf2061870a06c9ecaaba9", + "size": 6906011, + "subdir": "linux-64", + "timestamp": 1612957969429, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py36hced866c_2.conda": { + "build": "py36hced866c_2", + "build_number": 2, + "depends": [ + "aws-sdk-cpp >=1.8.133,<1.8.134.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "2d836595e44d4265f18337325c066c5e", + "name": "arrow-cpp", + "sha256": "b6f2774d3149b9802461c35a0b20bc0fba58a14aa51eca89703c3c7c728e2a1a", + "size": 6904927, + "subdir": "linux-64", + "timestamp": 1613148162745, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py36hced866c_3.conda": { + "build": "py36hced866c_3", + "build_number": 3, + "depends": [ + "aws-sdk-cpp >=1.8.156,<1.8.157.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1j,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "1ebafea1e366ee8c9c3d20906f3bde2a", + "name": "arrow-cpp", + "sha256": "a991191cd8bafeaffe424790fc03d45fd595eba30d16d568ee6c1ec0acf81abd", + "size": 6900925, + "subdir": "linux-64", + "timestamp": 1615274475638, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py37h6b21186_4.conda": { + "build": "py37h6b21186_4", + "build_number": 4, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.5.0", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "libthrift >=0.14.2,<0.14.3.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1l,<1.1.2a", + "orc >=1.6.9,<1.6.10.0a0", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "02453fec1d128806b584f7feedcc85b3", + "name": "arrow-cpp", + "sha256": "f69d17c2ffb603a94be13e982896adc2af5ebfc006630b331ce1ab011f97c408", + "size": 7448916, + "subdir": "linux-64", + "timestamp": 1632936756667, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py37hced866c_0.conda": { + "build": "py37hced866c_0", + "build_number": 0, + "depends": [ + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "4ce9c26c375f43ba277002f370b05274", + "name": "arrow-cpp", + "sha256": "0416335af25433d4a6def6ee92d899490dadbfce253cbef1b02d0daa67bb4e9d", + "size": 6784577, + "subdir": "linux-64", + "timestamp": 1612106226070, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py37hced866c_1.conda": { + "build": "py37hced866c_1", + "build_number": 1, + "depends": [ + "aws-sdk-cpp >=1.8.133,<1.8.134.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "a15d511fdf36a1cef952bf2755543816", + "name": "arrow-cpp", + "sha256": "8191bbf155cd2514b8b03491fcb04d721d6b8a2eda700f148349f78b714ecb8c", + "size": 6898477, + "subdir": "linux-64", + "timestamp": 1612958256465, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py37hced866c_2.conda": { + "build": "py37hced866c_2", + "build_number": 2, + "depends": [ + "aws-sdk-cpp >=1.8.133,<1.8.134.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "c31cac8ae8e1bbb84752aaeaf9673e98", + "name": "arrow-cpp", + "sha256": "8556a728820af151a6d4ed9cfb095e624754fe09ab4aed435378866e62df0413", + "size": 6895081, + "subdir": "linux-64", + "timestamp": 1613147928025, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py37hced866c_3.conda": { + "build": "py37hced866c_3", + "build_number": 3, + "depends": [ + "aws-sdk-cpp >=1.8.156,<1.8.157.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1j,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "d4baa06e2da2b1c9759e9a0e55028400", + "name": "arrow-cpp", + "sha256": "8b9b04450c75888a4805a073489f21b6da6bdc4e3266fc910109f2aad4faa5b2", + "size": 6905785, + "subdir": "linux-64", + "timestamp": 1615272907886, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py38h6b21186_4.conda": { + "build": "py38h6b21186_4", + "build_number": 4, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.5.0", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "libthrift >=0.14.2,<0.14.3.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1l,<1.1.2a", + "orc >=1.6.9,<1.6.10.0a0", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "8d5b001efd4d5f40be5ad8c0e2013d45", + "name": "arrow-cpp", + "sha256": "72577722477fadf60686cffca74724c3deab9200ec92913816bd8a760aa6a10b", + "size": 7462897, + "subdir": "linux-64", + "timestamp": 1632947199850, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py38hced866c_0.conda": { + "build": "py38hced866c_0", + "build_number": 0, + "depends": [ + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "ce4705f6c415538fe66d8428d6cbe95d", + "name": "arrow-cpp", + "sha256": "30b8608990e85845d26eeaa5bc23ab036730ee4dc59d429bed4b4728ba6c335f", + "size": 6793996, + "subdir": "linux-64", + "timestamp": 1612106336112, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py38hced866c_1.conda": { + "build": "py38hced866c_1", + "build_number": 1, + "depends": [ + "aws-sdk-cpp >=1.8.133,<1.8.134.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "f82e8ed2ade14816bf111bcda236b7e4", + "name": "arrow-cpp", + "sha256": "adc628f54ce6b302397f5779b82ccb851dbf443fae8b454f2d3db2c0463926f3", + "size": 6905476, + "subdir": "linux-64", + "timestamp": 1612957745121, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py38hced866c_2.conda": { + "build": "py38hced866c_2", + "build_number": 2, + "depends": [ + "aws-sdk-cpp >=1.8.133,<1.8.134.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "761414de77e813ff884942c9a449a008", + "name": "arrow-cpp", + "sha256": "a53fe7777376fba785a66b24a247a31b02f1adf69c7751d5fc26f7ce9bfc05cf", + "size": 6910339, + "subdir": "linux-64", + "timestamp": 1613147656598, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py38hced866c_3.conda": { + "build": "py38hced866c_3", + "build_number": 3, + "depends": [ + "aws-sdk-cpp >=1.8.156,<1.8.157.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1j,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "e02556f407ded414386dbb6a009fc5ad", + "name": "arrow-cpp", + "sha256": "facf5ce80be4dc93c436132b098b8d1808708840f6a9eb2049f880762370f729", + "size": 6914856, + "subdir": "linux-64", + "timestamp": 1615274084938, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py39h6b21186_4.conda": { + "build": "py39h6b21186_4", + "build_number": 4, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.5.0", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "libthrift >=0.14.2,<0.14.3.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1l,<1.1.2a", + "orc >=1.6.9,<1.6.10.0a0", + "python >=3.9,<3.10.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "e26a76e7c7df66ad39b409831097c6ab", + "name": "arrow-cpp", + "sha256": "8d4497cb2cb22635375f01a9e6bc883d10b52bed3fd65e837734407eeeb68136", + "size": 7444899, + "subdir": "linux-64", + "timestamp": 1632947238091, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py39hced866c_0.conda": { + "build": "py39hced866c_0", + "build_number": 0, + "depends": [ + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.9,<3.10.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "24755e40c3cf8c0b1a9082b4acccc56d", + "name": "arrow-cpp", + "sha256": "b5af588bd24c8bc6b4489b0bc89f3dc25166cf7e8c741bb5172c556560b97d12", + "size": 6797589, + "subdir": "linux-64", + "timestamp": 1612106335127, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py39hced866c_1.conda": { + "build": "py39hced866c_1", + "build_number": 1, + "depends": [ + "aws-sdk-cpp >=1.8.133,<1.8.134.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.9,<3.10.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "e85b035dfcd9c72222c56943d83f257e", + "name": "arrow-cpp", + "sha256": "b927f7cf72554a468999d0b7954e0c768e0d264b5f8f4ecd852de5ef334143f0", + "size": 6905226, + "subdir": "linux-64", + "timestamp": 1612958263853, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py39hced866c_2.conda": { + "build": "py39hced866c_2", + "build_number": 2, + "depends": [ + "aws-sdk-cpp >=1.8.133,<1.8.134.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1i,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.9,<3.10.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "e88be5705ac67eb49131ccc957a76c6a", + "name": "arrow-cpp", + "sha256": "963aff8261df872e8a36ed57253e19363fb07b02ebd39b1a4087b5c69e910982", + "size": 6905281, + "subdir": "linux-64", + "timestamp": 1613148098530, + "version": "3.0.0" + }, + "arrow-cpp-3.0.0-py39hced866c_3.conda": { + "build": "py39hced866c_3", + "build_number": 3, + "depends": [ + "aws-sdk-cpp >=1.8.156,<1.8.157.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1j,<1.1.2a", + "orc >=1.6.5,<1.6.6.0a0", + "python >=3.9,<3.10.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache 2.0", + "md5": "abd5fadca13099806a5bdb9c6ea14f7c", + "name": "arrow-cpp", + "sha256": "563d6709d616e542d15a634aad463f784e1c31041915b0f95957f2b4b454e7da", + "size": 6907214, + "subdir": "linux-64", + "timestamp": 1615274567424, + "version": "3.0.0" + }, + "arrow-cpp-4.0.1-py36hced866c_3.conda": { + "build": "py36hced866c_3", + "build_number": 3, + "depends": [ + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1k,<1.1.2a", + "orc >=1.6.7,<1.6.8.0a0", + "python >=3.6,<3.7.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "86da562135be464a9b2939d4beded51d", + "name": "arrow-cpp", + "sha256": "5b4653a642e072ecbae8faa778dda28aec05f95e6900b931674cbf6662a446c4", + "size": 7297961, + "subdir": "linux-64", + "timestamp": 1622567876795, + "version": "4.0.1" + }, + "arrow-cpp-4.0.1-py37hced866c_3.conda": { + "build": "py37hced866c_3", + "build_number": 3, + "depends": [ + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1k,<1.1.2a", + "orc >=1.6.7,<1.6.8.0a0", + "python >=3.7,<3.8.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5f26455c03331560d938b367ccf0e5c9", + "name": "arrow-cpp", + "sha256": "d87836d7e8e383f315bc3cb06f003caa59c2e5d1d0f60f76cea50bcf2925f9a0", + "size": 7303878, + "subdir": "linux-64", + "timestamp": 1622568407994, + "version": "4.0.1" + }, + "arrow-cpp-4.0.1-py38hced866c_3.conda": { + "build": "py38hced866c_3", + "build_number": 3, + "depends": [ + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1k,<1.1.2a", + "orc >=1.6.7,<1.6.8.0a0", + "python >=3.8,<3.9.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "655814807d87058bf1d73279a2737505", + "name": "arrow-cpp", + "sha256": "f42922b10bf1065fa4221c8382efad11f4acd31e52a6b8f079f9fabd9d16aabe", + "size": 7305022, + "subdir": "linux-64", + "timestamp": 1622563173502, + "version": "4.0.1" + }, + "arrow-cpp-4.0.1-py39hced866c_3.conda": { + "build": "py39hced866c_3", + "build_number": 3, + "depends": [ + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "boost-cpp", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "c-ares >=1.17.1,<2.0a0", + "double-conversion", + "gflags >=2.2.2,<2.3.0a0", + "glog", + "grpc-cpp", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.11,<2.0a0", + "openssl >=1.1.1k,<1.1.2a", + "orc >=1.6.7,<1.6.8.0a0", + "python >=3.9,<3.10.0a0", + "re2", + "snappy >=1.1.8,<2.0a0", + "uriparser", + "utf8proc", + "zlib", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7f48e02a5995d030df43904a4f9c16a2", + "name": "arrow-cpp", + "sha256": "5992a53344f2c426593231a07ab5713707d1f5920176c0caf68c9d158d6a1f33", + "size": 7294722, + "subdir": "linux-64", + "timestamp": 1622568430312, + "version": "4.0.1" + }, + "arrow-cpp-8.0.0-py310h3098874_0.conda": { + "build": "py310h3098874_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.10,<3.11.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0e922fe2cf95dc362d5b62c724d6f5ed", + "name": "arrow-cpp", + "sha256": "22f98af03fe1fb4cfdce2a7bc68edf73c3ea0132e0965e2c36bbdfd872790fe1", + "size": 9944754, + "subdir": "linux-64", + "timestamp": 1657132836159, + "version": "8.0.0" + }, + "arrow-cpp-8.0.0-py310h3098874_1.conda": { + "build": "py310h3098874_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.10,<3.11.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zlib", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "af6bc0a977774675ce1ec5fdaaf76303", + "name": "arrow-cpp", + "sha256": "a5ec71b6569af88e5b176f58f4479fe2a4d1898a3263d22680d61134ee60f9f7", + "size": 11162868, + "subdir": "linux-64", + "timestamp": 1676606956695, + "version": "8.0.0" + }, + "arrow-cpp-8.0.0-py311hf0d91b4_0.conda": { + "build": "py311hf0d91b4_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.11,<3.12.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "647e0a38fcbfae448c9bf8f8c06f3bc2", + "name": "arrow-cpp", + "sha256": "61b2a4093dfeb0ba1d8d6e9e4ebf954271762250675fc50d8dd8c94a0aac39f1", + "size": 10062481, + "subdir": "linux-64", + "timestamp": 1676829996079, + "version": "8.0.0" + }, + "arrow-cpp-8.0.0-py311hf0d91b4_1.conda": { + "build": "py311hf0d91b4_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.11,<3.12.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zlib", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b2e0dd6174a14901c55b7cfc77a72981", + "name": "arrow-cpp", + "sha256": "d537b3c7b1253127ff8d692220a6ede9580313f599d81ab91aa0414ecbeeecb4", + "size": 10065243, + "subdir": "linux-64", + "timestamp": 1679335203714, + "version": "8.0.0" + }, + "arrow-cpp-8.0.0-py37h60b952e_0.conda": { + "build": "py37h60b952e_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.7,<3.8.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d08f907ec25e7d8e5817abf3becd84c1", + "name": "arrow-cpp", + "sha256": "b1e693cc736494bbcd9e85e55478ec3d6b6cbe196cbd7e04bc6bd8797603b087", + "size": 9943925, + "subdir": "linux-64", + "timestamp": 1657133586737, + "version": "8.0.0" + }, + "arrow-cpp-8.0.0-py37h60b952e_1.conda": { + "build": "py37h60b952e_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.7,<3.8.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zlib", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0c3301c475fea09fb7ec2ce028fa9cc1", + "name": "arrow-cpp", + "sha256": "0b43258d88415d188856f4de8644d60cd20767dd4198cfac9856523532e59952", + "size": 11157066, + "subdir": "linux-64", + "timestamp": 1676605795255, + "version": "8.0.0" + }, + "arrow-cpp-8.0.0-py38h60b952e_0.conda": { + "build": "py38h60b952e_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.8,<3.9.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "00a67f93e0492bd99323a8f283b2c005", + "name": "arrow-cpp", + "sha256": "54ecf834384cb19bc5fc7482f9e72ed29b2546a98fa792190f6aba9e198aa040", + "size": 9943448, + "subdir": "linux-64", + "timestamp": 1657134336925, + "version": "8.0.0" + }, + "arrow-cpp-8.0.0-py38h60b952e_1.conda": { + "build": "py38h60b952e_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.8,<3.9.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zlib", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "43646b378eac952f588340e4891d8622", + "name": "arrow-cpp", + "sha256": "1f398f7a234c258acef4bd9832fad897993f428b1ef36e686946a3258d602f67", + "size": 11162501, + "subdir": "linux-64", + "timestamp": 1676608116854, + "version": "8.0.0" + }, + "arrow-cpp-8.0.0-py39h60b952e_0.conda": { + "build": "py39h60b952e_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.9,<3.10.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3fa0186c4824ee7fd54cfad3b59e7e4d", + "name": "arrow-cpp", + "sha256": "786dafc517f8b7b5be1d9d9e1c209a2d817a182e4758110d9461592706ed234a", + "size": 9943426, + "subdir": "linux-64", + "timestamp": 1657132089745, + "version": "8.0.0" + }, + "arrow-cpp-8.0.0-py39h60b952e_1.conda": { + "build": "py39h60b952e_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16,<2.0a0", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.9,<3.10.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "utf8proc", + "zlib", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "67b94837fc39f5b8b5ac0d391ddb30f9", + "name": "arrow-cpp", + "sha256": "3724999574b9569ff52887b208c25a35aaeac85c5d446abfe9c631de6ffe27bc", + "size": 11162929, + "subdir": "linux-64", + "timestamp": 1676604633237, + "version": "8.0.0" + }, + "asgiref-3.5.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "06be86ff5865326644e7e3f8433e293b", + "name": "asgiref", + "sha256": "5f26c4472f8587a362fb1edee7002e393ed543e1d342626fdd732e064acac419", + "size": 39219, + "subdir": "linux-64", + "timestamp": 1661287637684, + "version": "3.5.2" + }, + "asgiref-3.5.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7294bbacd358e1dedfc6ef45b8ce6104", + "name": "asgiref", + "sha256": "5daa8b137033b97403a985d360583b496a0cf139f5ab6d23746f602dcec23803", + "size": 48210, + "subdir": "linux-64", + "timestamp": 1676843211900, + "version": "3.5.2" + }, + "asgiref-3.5.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6f4e7eaa86fbf9641640046ad1e4a519", + "name": "asgiref", + "sha256": "d05026f7b6c144925ad47af46d7836f04ec6a220b73284db342638e780fdd15d", + "size": 38534, + "subdir": "linux-64", + "timestamp": 1661287663867, + "version": "3.5.2" + }, + "asgiref-3.5.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a35b30438f1d6cdf02ef660bdc785448", + "name": "asgiref", + "sha256": "95dbf5280a55c3563ab2af6abc6ca32cd739132ed6e172330ef582d2dab31ade", + "size": 38706, + "subdir": "linux-64", + "timestamp": 1661287565794, + "version": "3.5.2" + }, + "asgiref-3.5.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2c86dbed0026371efe17d4a995b2f46f", + "name": "asgiref", + "sha256": "0d3c4390f5da97be34e0997896b0e4975bafbc7a869d2b4bb177d2af30a12bdf", + "size": 38850, + "subdir": "linux-64", + "timestamp": 1661287596785, + "version": "3.5.2" + }, + "asn1crypto-0.22.0-py27h94ebe91_1.conda": { + "build": "py27h94ebe91_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "caa36d08f34138b8111528c174cda644", + "name": "asn1crypto", + "sha256": "ad022463b5fdce536f455632884aca82040d05129a8e501b1c1cdf3983b90644", + "size": 153735, + "subdir": "linux-64", + "timestamp": 1505691748075, + "version": "0.22.0" + }, + "asn1crypto-0.22.0-py35h0d675fe_1.conda": { + "build": "py35h0d675fe_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "d1ed6ca6188e38ad9059c1bcc97d1c7f", + "name": "asn1crypto", + "sha256": "256fd2339378191d6c4b59172d03c369d52fbc9db8200e23d447aa9822961d68", + "size": 155549, + "subdir": "linux-64", + "timestamp": 1505691760988, + "version": "0.22.0" + }, + "asn1crypto-0.22.0-py36h265ca7c_1.conda": { + "build": "py36h265ca7c_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f3e1b9c8676ac753a0757147bda3db46", + "name": "asn1crypto", + "sha256": "8a5b93564853fd12ddef9baa20d1654df7733b8bf42155e63578be0a5f377f7d", + "size": 156156, + "subdir": "linux-64", + "timestamp": 1505691774144, + "version": "0.22.0" + }, + "asn1crypto-0.23.0-py27h7b0c810_0.conda": { + "build": "py27h7b0c810_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9ab5926881e792dffaaacccc6848d7be", + "name": "asn1crypto", + "sha256": "27d947b3a819c61e926fa8498e6f0f9c4f3ed79d54f74597b834333922166c6f", + "size": 157261, + "subdir": "linux-64", + "timestamp": 1511838836126, + "version": "0.23.0" + }, + "asn1crypto-0.23.0-py35h4ab26a5_0.conda": { + "build": "py35h4ab26a5_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "944d356439cc7a110a23cf3f1b2afa87", + "name": "asn1crypto", + "sha256": "ab259821d31cf61f285930b01571e0b2a451305d0d2f9c5d4300440f1802c571", + "size": 162024, + "subdir": "linux-64", + "timestamp": 1511838842795, + "version": "0.23.0" + }, + "asn1crypto-0.23.0-py36h4639342_0.conda": { + "build": "py36h4639342_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ff40f6c39cc0971442aa0b3d68b84a08", + "name": "asn1crypto", + "sha256": "6887699733193c4f3b9e0ed93e528efb6185a48531fcf83db3d8384e87f65fdd", + "size": 159901, + "subdir": "linux-64", + "timestamp": 1511838853469, + "version": "0.23.0" + }, + "asn1crypto-0.24.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d92c0a1b9872975aefa81a2ebb1dd51f", + "name": "asn1crypto", + "sha256": "dd230f3b473d0c05882beef5e063e99c9ed1a7e11e6f964feaf10fe2c1c2e6d2", + "size": 163194, + "subdir": "linux-64", + "timestamp": 1515702537268, + "version": "0.24.0" + }, + "asn1crypto-0.24.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "8846cb526c31f1801bcb4b1cc7b971f8", + "name": "asn1crypto", + "sha256": "426cc76abc6718520c7cfaeea242a15893e7eec7186a8b4ca49784c49b47e666", + "size": 165471, + "subdir": "linux-64", + "timestamp": 1515702654575, + "version": "0.24.0" + }, + "asn1crypto-0.24.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7c58d867eb24092ee77591e19095db79", + "name": "asn1crypto", + "sha256": "f5f6ac02904d2ea53bfd002b2296a77b6d55fbbe25102ee30c49970adf729566", + "size": 163470, + "subdir": "linux-64", + "timestamp": 1515702503934, + "version": "0.24.0" + }, + "asn1crypto-0.24.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "480990b5011ba9b309b51d3e2baecf35", + "name": "asn1crypto", + "sha256": "8cc7801017d74ee0f9a9719b9525e874fbf8218dfeda0532c6d12fb2f38831ae", + "size": 160191, + "subdir": "linux-64", + "timestamp": 1530695849202, + "version": "0.24.0" + }, + "asn1crypto-1.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c2601772c465db17056997fb6c2d5667", + "name": "asn1crypto", + "sha256": "ab81be3bc9d47436a0167fa850bbe1083ba7a325bf6d6d98337c71d71df5d681", + "size": 168902, + "subdir": "linux-64", + "timestamp": 1570463086473, + "version": "1.0.1" + }, + "asn1crypto-1.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a372564021feacf0ecba1687fe9ce0aa", + "name": "asn1crypto", + "sha256": "dee394dd1e9a8234f03a6211d9317462f056da6bfae5d6cb0ae6fa68b79d1b50", + "size": 169506, + "subdir": "linux-64", + "timestamp": 1570463077759, + "version": "1.0.1" + }, + "asn1crypto-1.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6750467992acb76e80858ac75eb006e5", + "name": "asn1crypto", + "sha256": "99f794e4ce1a96fbb931a7b52152ba7e71cfc63f1998b92b5f7ca402ee54d244", + "size": 169758, + "subdir": "linux-64", + "timestamp": 1570463088980, + "version": "1.0.1" + }, + "asn1crypto-1.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f706687e20f811fce5c02807c46e500f", + "name": "asn1crypto", + "sha256": "892600ff91204f1423578b1282b10fd20402c127672cc6455a1174cf4dbbf223", + "size": 170167, + "subdir": "linux-64", + "timestamp": 1571757139897, + "version": "1.2.0" + }, + "asn1crypto-1.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "142aaa08eeafa69e818982e1787f6833", + "name": "asn1crypto", + "sha256": "2aa391e739676b5d1b7b31f68c78e55e58c24d1d0d9bcbfb84dcd1304ea93b4f", + "size": 171703, + "subdir": "linux-64", + "timestamp": 1642498959513, + "version": "1.2.0" + }, + "asn1crypto-1.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "af8741f3965d37925e0702171d0e0284", + "name": "asn1crypto", + "sha256": "44f3ff7d3abb975e002a5a230e79475e360cb1df8a10c7908276735cf741b7e8", + "size": 170271, + "subdir": "linux-64", + "timestamp": 1571757153773, + "version": "1.2.0" + }, + "asn1crypto-1.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8d2067d439fc46176cd8efa80d4f7bc2", + "name": "asn1crypto", + "sha256": "f4ad85c5a9a172cbca918e5734801d04220e83676209df683a95d5936d33290e", + "size": 170444, + "subdir": "linux-64", + "timestamp": 1571757136264, + "version": "1.2.0" + }, + "asn1crypto-1.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "a035b830b8dd9eb3fe94f65a54d25c4c", + "name": "asn1crypto", + "sha256": "d2030411eaaee91dba7b38d21c7a32ec18ec890da5ab0bd981c7acec222934fc", + "size": 169003, + "subdir": "linux-64", + "timestamp": 1572437739325, + "version": "1.2.0" + }, + "asn1crypto-1.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ce9fa09e5b2b1a8dedf14fc0c37b995b", + "name": "asn1crypto", + "sha256": "875afeed7f40b0a7f5a91c327f341aeb439e75978ad9b851811bc4b2dd2ff56b", + "size": 168142, + "subdir": "linux-64", + "timestamp": 1578427450649, + "version": "1.3.0" + }, + "asn1crypto-1.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "047868f4744de321fcb83bdb46085392", + "name": "asn1crypto", + "sha256": "c565db73f43db03c45c9c377cb10eb3b9fef8656efb933b09e3276a3c24ecebf", + "size": 167793, + "subdir": "linux-64", + "timestamp": 1578427456613, + "version": "1.3.0" + }, + "asn1crypto-1.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b0a648e6f2c275333e6a72f210ffa220", + "name": "asn1crypto", + "sha256": "802477786c7e8479c20fcb4bd63eba0acff1f0befa086a0a4fa6dbb744708d31", + "size": 168008, + "subdir": "linux-64", + "timestamp": 1578427420462, + "version": "1.3.0" + }, + "asn1crypto-1.3.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b4f37f3e9cb9ee6bf020df4d366e298f", + "name": "asn1crypto", + "sha256": "cdfc3f6fa3e8261148812209eae1a62253de1c2e81f7c1f3b465ff111997b479", + "size": 168013, + "subdir": "linux-64", + "timestamp": 1594339154083, + "version": "1.3.0" + }, + "asn1crypto-1.3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "961947ce1ca1172f712cb6d18cd3dc20", + "name": "asn1crypto", + "sha256": "534525de963e074191d4a7d9b516fac90fb7be49009004ab3c8ebe54ccaaa2cd", + "size": 168343, + "subdir": "linux-64", + "timestamp": 1578427459388, + "version": "1.3.0" + }, + "asn1crypto-1.5.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9f69890a43de63a4ab5d974a8b76ed6", + "name": "asn1crypto", + "sha256": "b247aa37a88e098f7b83abedadc551d769747509a6d1b4f55cc9069ebe80f074", + "size": 170578, + "subdir": "linux-64", + "timestamp": 1652362734721, + "version": "1.5.1" + }, + "asn1crypto-1.5.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "049e080700fd691a33bf2b67c01a1627", + "name": "asn1crypto", + "sha256": "c883f5ef4fe45820a9e139a69392c0638954306bb8cacc41e5b1ab0a18cb79b9", + "size": 225272, + "subdir": "linux-64", + "timestamp": 1676838987340, + "version": "1.5.1" + }, + "asn1crypto-1.5.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2668a2b7d9e2e24829eb0e9e1ababc31", + "name": "asn1crypto", + "sha256": "c5d646c68f9005a1b2d79d60c5c4927ac31089ab3c2c23564922749ed1196f3d", + "size": 165948, + "subdir": "linux-64", + "timestamp": 1652362697562, + "version": "1.5.1" + }, + "asn1crypto-1.5.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7eb82bec1557290ceaa8e989a9e43fab", + "name": "asn1crypto", + "sha256": "75e766a65890bb779957a33252623ef1a7a85397bf338e6f13f9f216cf980940", + "size": 166498, + "subdir": "linux-64", + "timestamp": 1652362672251, + "version": "1.5.1" + }, + "asn1crypto-1.5.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fab72b4731790e9cf472da01239ae193", + "name": "asn1crypto", + "sha256": "b071927d69e9182bfd17b7a3595f0854fcf3f2085d496179750b61024a4a0b53", + "size": 166487, + "subdir": "linux-64", + "timestamp": 1652362761112, + "version": "1.5.1" + }, + "assimp-5.0.1-h01202fb_6.conda": { + "build": "h01202fb_6", + "build_number": 6, + "depends": [ + "boost-cpp", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Modified BSD", + "license_family": "BSD", + "md5": "40c44e11954ea30040aa7be65ceef3ee", + "name": "assimp", + "sha256": "e04e43fe8fa5f43ebf5f589f25e13fe10b5c0150c25810ac32e270bb3bbefed5", + "size": 3815025, + "subdir": "linux-64", + "timestamp": 1631694843607, + "version": "5.0.1" + }, + "astor-0.6.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6f5a7fe6231c1a841dafc72590b281f5", + "name": "astor", + "sha256": "c31c2302fa7f6f8160a4479723ad4d9f922941839ab3268cd0a2d34b26605f18", + "size": 44338, + "subdir": "linux-64", + "timestamp": 1519944910897, + "version": "0.6.2" + }, + "astor-0.6.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d6fe3e60954d2d9b97224355bf17558c", + "name": "astor", + "sha256": "8be54dc22ca1f75629f458e557ecfb5983ff54a365fa7d49cd68ef97595f5cba", + "size": 45318, + "subdir": "linux-64", + "timestamp": 1530737866048, + "version": "0.6.2" + }, + "astor-0.6.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "30b154845762c313d5778aac166e7c71", + "name": "astor", + "sha256": "efe1aa4f582d71bde0f9b47a91dfce87be0e7c31ff95630de21972e075eb7b09", + "size": 45582, + "subdir": "linux-64", + "timestamp": 1519944897880, + "version": "0.6.2" + }, + "astor-0.6.2-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a13a505a1961da4df8e23db6de3f5d79", + "name": "astor", + "sha256": "185a53964307e00cae3dc9d3627ba4a988902686560afc306defab1751d75d9d", + "size": 45909, + "subdir": "linux-64", + "timestamp": 1534352825921, + "version": "0.6.2" + }, + "astor-0.6.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4fabf4b2052448dc425a236f653ea99d", + "name": "astor", + "sha256": "b6a31565bd544a46732d1b9ab10687bccb9d7bd3d00c06bcaa62a4d2838c7951", + "size": 45116, + "subdir": "linux-64", + "timestamp": 1519944924716, + "version": "0.6.2" + }, + "astor-0.6.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "233ac95533787af48a05858bf9a74ce7", + "name": "astor", + "sha256": "b928d0b7dbaba21c9deb75d287ae7c0ebc5d82a94c938b61d48498d82e4f57e9", + "size": 45507, + "subdir": "linux-64", + "timestamp": 1530737845039, + "version": "0.6.2" + }, + "astor-0.6.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee8c1cef80ecfaf6dbc9f5dc63ef3876", + "name": "astor", + "sha256": "258a95f5bb4d3d08197ba48f7813be60e7f12ea788e6a485c458ab65a7c0e35e", + "size": 45519, + "subdir": "linux-64", + "timestamp": 1530737887311, + "version": "0.6.2" + }, + "astor-0.7.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c4ebcbbe8d445491c133757a152d72d6", + "name": "astor", + "sha256": "9382a668b1e4c629db5923603153933f2ceeeff51497d79820275a8fb8f8f6d9", + "size": 44806, + "subdir": "linux-64", + "timestamp": 1532577518214, + "version": "0.7.1" + }, + "astor-0.7.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f38daa6ecf30bc8b95a0959eed396d78", + "name": "astor", + "sha256": "18b1876bb856e54b5368ceddb276424dd0414db2e7657196b216a1dccf5e2113", + "size": 46074, + "subdir": "linux-64", + "timestamp": 1532577564363, + "version": "0.7.1" + }, + "astor-0.7.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "298679fc7c164dba1b3521d9d16a9d46", + "name": "astor", + "sha256": "8a20cb4f183922e7abbfb63e9e750696a71300e1816a14968680de04329a819e", + "size": 45223, + "subdir": "linux-64", + "timestamp": 1532577486577, + "version": "0.7.1" + }, + "astor-0.7.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6b2e4b7dfb804834088a6c8d4bea13f5", + "name": "astor", + "sha256": "1fa56adff83aa2242e4df1b88bf878712ac85c89dd54914c0faa68b3dbf44cc3", + "size": 45268, + "subdir": "linux-64", + "timestamp": 1532577566420, + "version": "0.7.1" + }, + "astor-0.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "722a641acdc5404b1f35485767860281", + "name": "astor", + "sha256": "b277ebf739d9ab2d18b8f8e7b1253bd64dd5dbab2168f24e35f9d10bd3720d55", + "size": 46925, + "subdir": "linux-64", + "timestamp": 1564694743781, + "version": "0.8.0" + }, + "astor-0.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "06154d7134cded1d34759a3acb527555", + "name": "astor", + "sha256": "ef9b220f47960d8ffb0e212cc22600c6647ab993235bbb1aae1fc51bc84c0b10", + "size": 47348, + "subdir": "linux-64", + "timestamp": 1564694383983, + "version": "0.8.0" + }, + "astor-0.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "29b9d7b1108dfb17493f5b2ca7cf0dd0", + "name": "astor", + "sha256": "e7688fd64ec3b7aeb328eb9793a6b0f618faa95c432ae840e844d78f64450a35", + "size": 47255, + "subdir": "linux-64", + "timestamp": 1564694755303, + "version": "0.8.0" + }, + "astor-0.8.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c72a7ea396b63d75ea6371377be0b949", + "name": "astor", + "sha256": "61f43123acdbea0a31507dfe8c263d1e7360cd491ed33c7d316672d664c5ce4b", + "size": 47113, + "subdir": "linux-64", + "timestamp": 1640788313822, + "version": "0.8.1" + }, + "astor-0.8.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "785c207dd95d39a51ba2aa8c4ef08418", + "name": "astor", + "sha256": "f0b81c410b16f9c1463ef7a623b7cb131e863d77b4a2f94d14173acdc3f56a80", + "size": 63725, + "subdir": "linux-64", + "timestamp": 1676846829744, + "version": "0.8.1" + }, + "astor-0.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3b7f39da1dc9f4fd5c17e24095348114", + "name": "astor", + "sha256": "75da2343271e586847024ea487ee0e7226622d6fb55f0c41b161e98873f104f5", + "size": 47691, + "subdir": "linux-64", + "timestamp": 1597430670981, + "version": "0.8.1" + }, + "astor-0.8.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3fb3a9d0d5fc9286534f3bb6790887c5", + "name": "astor", + "sha256": "51ba89dbb49e445b96ee5ca77d3b8e7429982dfad6ee3bccdc56b7fd0b3429fb", + "size": 47844, + "subdir": "linux-64", + "timestamp": 1611675367996, + "version": "0.8.1" + }, + "astor-0.8.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "14db690bdf055e444f0c1928e39d7b12", + "name": "astor", + "sha256": "f35a31e819ec83f83f201b7825021e5446324c196abac93a41b7de6c4f070937", + "size": 47850, + "subdir": "linux-64", + "timestamp": 1597430671659, + "version": "0.8.1" + }, + "astor-0.8.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9c2fe5ff1be993571ad3689f98391bd5", + "name": "astor", + "sha256": "383caa54aa417aa40296ed9b800dff8750c775be56f401de47b1b601dd8bc3e4", + "size": 47751, + "subdir": "linux-64", + "timestamp": 1611675301760, + "version": "0.8.1" + }, + "astor-0.8.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "59c4f47873843878324138627ca343ab", + "name": "astor", + "sha256": "e0d439adc7f5034c52d97f6fc8a2a954ad7e153949ecefc9cf8d9847fe16b258", + "size": 47855, + "subdir": "linux-64", + "timestamp": 1597430688759, + "version": "0.8.1" + }, + "astor-0.8.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5e941fc6ab325e64da73267f9a47f464", + "name": "astor", + "sha256": "7f7b79ab3222ed26ddbe8f4d63427d298596cd3c9b08398a94521c1fc5a3a8ff", + "size": 47648, + "subdir": "linux-64", + "timestamp": 1611674896017, + "version": "0.8.1" + }, + "astor-0.8.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cba82e4a7629689f2cb02109ac54e089", + "name": "astor", + "sha256": "b6d8de42dda704b72805f9c73653a49c0804b76ebc1e7c16b1049c62e9e7f310", + "size": 47844, + "subdir": "linux-64", + "timestamp": 1611675342284, + "version": "0.8.1" + }, + "astroid-1.5.3-py27h8f8f47c_0.conda": { + "build": "py27h8f8f47c_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "enum34", + "lazy-object-proxy", + "python >=2.7,<2.8.0a0", + "setuptools", + "singledispatch", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "2bc00e262d0c1a384bac274f708c4e48", + "name": "astroid", + "sha256": "d1df5bdaa5f8a0f6d6d7e47015abf56e13f65af3892e045453b2d1965c0433f8", + "size": 371067, + "subdir": "linux-64", + "timestamp": 1505693943294, + "version": "1.5.3" + }, + "astroid-1.5.3-py35h1d0c565_0.conda": { + "build": "py35h1d0c565_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "4a3b76af320258be63bbba5d27e07382", + "name": "astroid", + "sha256": "cbd23efa2bbdff897254e13bee504ae69f96ef342467479563097345a2c4234a", + "size": 382170, + "subdir": "linux-64", + "timestamp": 1505693966826, + "version": "1.5.3" + }, + "astroid-1.5.3-py36hbdb9df2_0.conda": { + "build": "py36hbdb9df2_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "6e1c508347a4bc61f346e1074564481f", + "name": "astroid", + "sha256": "c90b4b85b1f1b12d6f39ee76d2876a27e5aeccf78dcad712ba06960c33b5709d", + "size": 373384, + "subdir": "linux-64", + "timestamp": 1505693990671, + "version": "1.5.3" + }, + "astroid-1.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "enum34", + "lazy-object-proxy", + "python >=2.7,<2.8.0a0", + "setuptools", + "singledispatch", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "61f3a98010c6a9972a7626091d071d84", + "name": "astroid", + "sha256": "72741f1e657643ff26c64ae1c014c5a29392c9a50674cf1c8273bb4a2544cc2f", + "size": 387532, + "subdir": "linux-64", + "timestamp": 1515702615294, + "version": "1.6.0" + }, + "astroid-1.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "a207b0dc8c0fa67ff82e32d63f04fa6b", + "name": "astroid", + "sha256": "d54f7b1c0f4567b98149711cf4cf2eb78cf59de2f0f8051739fcbec508442e54", + "size": 398416, + "subdir": "linux-64", + "timestamp": 1515702604924, + "version": "1.6.0" + }, + "astroid-1.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "46483fe1a11797cf1c9dc2e2a59126c0", + "name": "astroid", + "sha256": "34357ae61c663019bc17d05d48108dbec9f04a878189a55b30469fec08f60909", + "size": 400182, + "subdir": "linux-64", + "timestamp": 1515702519415, + "version": "1.6.0" + }, + "astroid-1.6.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "enum34", + "lazy-object-proxy", + "python >=2.7,<2.8.0a0", + "setuptools", + "singledispatch", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "6920d7c001221752afc982857a6b7477", + "name": "astroid", + "sha256": "ba6cb9da05837f175d4c367c30e384911097a3bec88375eff1923335c848185c", + "size": 387289, + "subdir": "linux-64", + "timestamp": 1517330644124, + "version": "1.6.1" + }, + "astroid-1.6.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "ee7661afd0e2dae623fe4e4d657bc1c4", + "name": "astroid", + "sha256": "22b1000b1cf4b1c8ab46b393102551b8025cb294a1d8c390346fd6aad57c47bc", + "size": 404034, + "subdir": "linux-64", + "timestamp": 1517330571094, + "version": "1.6.1" + }, + "astroid-1.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "f123c072482bd29e6caf3c9b57df57ed", + "name": "astroid", + "sha256": "09da60f254cd73295bcdc6435a26bbd046daf7c2cdc47a6741a02097466af1b7", + "size": 394225, + "subdir": "linux-64", + "timestamp": 1517330662366, + "version": "1.6.1" + }, + "astroid-1.6.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "enum34", + "lazy-object-proxy", + "python >=2.7,<2.8.0a0", + "setuptools", + "singledispatch", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "466f0bd51f44b1715db3fce31e417059", + "name": "astroid", + "sha256": "835bb723ec8f4f2c5fc993e1dea06e2e8a41b4b8900a186fb867d87905723957", + "size": 399940, + "subdir": "linux-64", + "timestamp": 1521568055947, + "version": "1.6.2" + }, + "astroid-1.6.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "c8aab9d1986bcd784c0e4a643c934b37", + "name": "astroid", + "sha256": "2bd86ca7103471d3a5e61068ca6ebc2dc41fd2b875db8398fec439b8433e90fb", + "size": 405780, + "subdir": "linux-64", + "timestamp": 1521568066646, + "version": "1.6.2" + }, + "astroid-1.6.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "57d05ffc05ac334ef4343b2c7032adba", + "name": "astroid", + "sha256": "9e2431c8f96f5120b47a083a9fdcef6aadacd2e2b19328460e114a8a4adb08bc", + "size": 407396, + "subdir": "linux-64", + "timestamp": 1521568062357, + "version": "1.6.2" + }, + "astroid-1.6.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "enum34", + "lazy-object-proxy", + "python >=2.7,<2.8.0a0", + "setuptools", + "singledispatch", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "bfd9208d2971114936261bd026af8475", + "name": "astroid", + "sha256": "6dc07d1797c560c8a832fbc841f85a5757401d6b99529ab1aee39fb989d0562c", + "size": 400228, + "subdir": "linux-64", + "timestamp": 1523291230340, + "version": "1.6.3" + }, + "astroid-1.6.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "c9057c3bbac325b055b9e0af7f57e398", + "name": "astroid", + "sha256": "840e384b4ac083a4c79dad053a979ce454beaa16c8cbd949e08824d0cde3e2df", + "size": 405314, + "subdir": "linux-64", + "timestamp": 1523291249951, + "version": "1.6.3" + }, + "astroid-1.6.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "1e099417d2442f1b339f6bca2622e813", + "name": "astroid", + "sha256": "d96910b8f573b68e124ea1fc360194610ab07934caad136cdb67aa9104f89896", + "size": 416871, + "subdir": "linux-64", + "timestamp": 1523291191189, + "version": "1.6.3" + }, + "astroid-1.6.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "enum34", + "lazy-object-proxy", + "python >=2.7,<2.8.0a0", + "setuptools", + "singledispatch", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "1f186865b80cf3f1c2f050e5d3dbdddb", + "name": "astroid", + "sha256": "c36d2609970f4e9b24f789b5859574beb3b0723c2d5a8cdb7ab1e9c331b24bba", + "size": 399777, + "subdir": "linux-64", + "timestamp": 1527828476000, + "version": "1.6.4" + }, + "astroid-1.6.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "ca43042232befc325667121a33908df8", + "name": "astroid", + "sha256": "506dc612c50cda97b1f6d4cc467f7f91bdd3eb17629ed4172df09982c342d248", + "size": 416488, + "subdir": "linux-64", + "timestamp": 1527828498562, + "version": "1.6.4" + }, + "astroid-1.6.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "f7acc5cd4714497e2bf3dae498130725", + "name": "astroid", + "sha256": "848d97dbad9e6ca52de74cf77b7553a70ff7e4fd3b7fb8835c128849dd7efe1b", + "size": 429477, + "subdir": "linux-64", + "timestamp": 1527828455691, + "version": "1.6.4" + }, + "astroid-1.6.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "enum34", + "lazy-object-proxy", + "python >=2.7,<2.8.0a0", + "setuptools", + "singledispatch", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "40c43540f4b173a71a57d7480bdafa68", + "name": "astroid", + "sha256": "03ff6ae02484f3a2627d5d08519c18f96db40e787bba7f097e4b4696ee13c50d", + "size": 405306, + "subdir": "linux-64", + "timestamp": 1528899080081, + "version": "1.6.5" + }, + "astroid-1.6.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "e2e82a2442d73e8be1842f6cac39bfed", + "name": "astroid", + "sha256": "444dfeb3871e17343253544c5941e7f7568c6516356a9b56ab4fc6ce818bdea9", + "size": 416429, + "subdir": "linux-64", + "timestamp": 1528899122678, + "version": "1.6.5" + }, + "astroid-1.6.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "0b6e1111b0ca1f080e2261619ca92fc2", + "name": "astroid", + "sha256": "6b0c33517f3455bed34f9efbc6e1c50548c366e07f89fdc7232addc41d8f655a", + "size": 429368, + "subdir": "linux-64", + "timestamp": 1528899074078, + "version": "1.6.5" + }, + "astroid-1.6.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "dae3b199da2b6d5a354cbf3cb6d1359b", + "name": "astroid", + "sha256": "9d26fa9f995d37c342e11fdf73f98dff3c339f29114914fdf5b63239404255cf", + "size": 412322, + "subdir": "linux-64", + "timestamp": 1530737996675, + "version": "1.6.5" + }, + "astroid-2.0.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.5,<3.6.0a0", + "six", + "typed-ast", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "4ccd0814ab94b427d653694e3d318fde", + "name": "astroid", + "sha256": "fe8137d045e3e2f2bc4bfc3e0d7e9a3d9900a309fde6bff6bb3e14625b38de4a", + "size": 259053, + "subdir": "linux-64", + "timestamp": 1533749500246, + "version": "2.0.2" + }, + "astroid-2.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "six", + "typed-ast", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "78072cced6c5e626d826e237102ad2f3", + "name": "astroid", + "sha256": "c5ceb5a2c5e0538078f62b2f8cbacc126899edea365b2da3019d4041fbb4546e", + "size": 252664, + "subdir": "linux-64", + "timestamp": 1533749521895, + "version": "2.0.2" + }, + "astroid-2.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.7,<3.8.0a0", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "d622baece3bd4846f6fdeaafa254df25", + "name": "astroid", + "sha256": "0cf23fbd366d2144f676337c13219ae49c2c0da54a43d193e1883ce297866cdf", + "size": 256470, + "subdir": "linux-64", + "timestamp": 1533749550251, + "version": "2.0.2" + }, + "astroid-2.0.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.5,<3.6.0a0", + "six", + "typed-ast", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "44fa5941ecf4299b024bc8f5f1fa20f7", + "name": "astroid", + "sha256": "75d78c7bbcee7e61657fe75f5598f4b36f17a2b605b163f112cccd89361b6bbb", + "size": 258889, + "subdir": "linux-64", + "timestamp": 1534175352450, + "version": "2.0.4" + }, + "astroid-2.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "six", + "typed-ast", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "963b6c70adc80386823abac86dd4cf4b", + "name": "astroid", + "sha256": "04527d545a59b0d5f6137f93db0d08e4e93f1fd71413c7aa8d1e983b310d306a", + "size": 256407, + "subdir": "linux-64", + "timestamp": 1534175375678, + "version": "2.0.4" + }, + "astroid-2.0.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.7,<3.8.0a0", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "5943ca828970f3d4d169871b14ac5a0e", + "name": "astroid", + "sha256": "d84c7ce3d01cedf8cd4ae39925af6145b95e486ad60fefbe7b92b6f4c7ff2e21", + "size": 256450, + "subdir": "linux-64", + "timestamp": 1534175238280, + "version": "2.0.4" + }, + "astroid-2.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "six", + "typed-ast", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "90ee77f2bb2d47cb4fcb653bc4407b29", + "name": "astroid", + "sha256": "86a6856c53d613a9649e38b89b790a9d1f5dd435f2302d7e4cf5995fac812163", + "size": 268982, + "subdir": "linux-64", + "timestamp": 1543517454612, + "version": "2.1.0" + }, + "astroid-2.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.7,<3.8.0a0", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "a37af8ed4f79dad8db2c26ca9a739404", + "name": "astroid", + "sha256": "a1234332e2f6649605f3e8f8325f696c3158c4c1967044a4b9fa831f5f7fefde", + "size": 269047, + "subdir": "linux-64", + "timestamp": 1543517424809, + "version": "2.1.0" + }, + "astroid-2.11.7-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.10,<3.11.0a0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "99761bd8158a8dfc56376b1c84bd16b8", + "name": "astroid", + "sha256": "069d9dc267abb3fca7d4146bfb9b6ff957e118e4ae04d0ad2aaca54cbb93ced0", + "size": 354239, + "subdir": "linux-64", + "timestamp": 1659023175933, + "version": "2.11.7" + }, + "astroid-2.11.7-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.4.0,<2.0", + "typing-extensions >=3.10", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "413836c1939906423adc328dada26ae6", + "name": "astroid", + "sha256": "54cc5b2739594d82a33791c91ac0f09a4988177edb738f33871ba8d272f1b7f9", + "size": 347079, + "subdir": "linux-64", + "timestamp": 1659023282162, + "version": "2.11.7" + }, + "astroid-2.11.7-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.10", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "f75d73022de3727db21b9511ffaa8608", + "name": "astroid", + "sha256": "13b19a757de6f2ae618d6cc341f1e348d4638dfd5bac72c94cb6d813e348e4f1", + "size": 349868, + "subdir": "linux-64", + "timestamp": 1659023210887, + "version": "2.11.7" + }, + "astroid-2.11.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.10", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "9551a05723c53ad421cce58ae86265fb", + "name": "astroid", + "sha256": "708ba65f14c2a155cbfac025817ece6e14fa801dd7497a9612557a88b5726d72", + "size": 349656, + "subdir": "linux-64", + "timestamp": 1659023246187, + "version": "2.11.7" + }, + "astroid-2.12.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.10,<3.11.0a0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "9447ba5d8ca967f1b0ea55355e2d6677", + "name": "astroid", + "sha256": "ee707c4e34e8d317c526edf5317fb865fdf241b675c336171d399e57c9288901", + "size": 374028, + "subdir": "linux-64", + "timestamp": 1660081269921, + "version": "2.12.2" + }, + "astroid-2.12.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.4.0,<2.0", + "typing-extensions >=3.10", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "357242e82f1363773514b8b7dbd055c0", + "name": "astroid", + "sha256": "ea3549056f0753de981d33cbf62e7c37c1937a771ebaadd98ea193801a6b2799", + "size": 365931, + "subdir": "linux-64", + "timestamp": 1660081301868, + "version": "2.12.2" + }, + "astroid-2.12.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.10", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "938b8d0f8899ac3fdc381e64e54d0098", + "name": "astroid", + "sha256": "c9d33e380dab513217116e80a635052b7320558448fb1bc8b2a9629b396b234f", + "size": 368724, + "subdir": "linux-64", + "timestamp": 1660081332487, + "version": "2.12.2" + }, + "astroid-2.12.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.10", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "5dbeff255b1c9d07025fd591cf3f57fc", + "name": "astroid", + "sha256": "0ee68e0e9634d9abf613de4a0ea7d849c69894c6b9ff7c144295cbda68c0ec19", + "size": 368300, + "subdir": "linux-64", + "timestamp": 1660081226293, + "version": "2.12.2" + }, + "astroid-2.13.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.10,<3.11.0a0", + "typing-extensions >=4.0.0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "9ed0b777243766193fc38ed23baf51b8", + "name": "astroid", + "sha256": "c1653a320b64ac7ba6270608e8c4c9e1c3ca50f22b1fac9d0ea56a7e0d8f561f", + "size": 406694, + "subdir": "linux-64", + "timestamp": 1674746033341, + "version": "2.13.3" + }, + "astroid-2.13.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.11,<3.12.0a0", + "wrapt >=1.14,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "2f92d66c2dff601c7c0c5a834ea63c06", + "name": "astroid", + "sha256": "5b63db52cb45853343fbd3e79c024b8c5baf20de3b87a5f9ccff19d1dfbdeb66", + "size": 503021, + "subdir": "linux-64", + "timestamp": 1676827676495, + "version": "2.13.3" + }, + "astroid-2.13.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.4.0,<2.0", + "typing-extensions >=4.0.0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "07e48d6667b1b211642a0ce05b0f31bc", + "name": "astroid", + "sha256": "9a58897147a7488c54d58c454b85d1678f1a6c7e908b8f2570f83b649ca1eb3d", + "size": 398188, + "subdir": "linux-64", + "timestamp": 1674745951896, + "version": "2.13.3" + }, + "astroid-2.13.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=4.0.0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "a17417920438769a192772c38586bfa1", + "name": "astroid", + "sha256": "3080ef13433c053905588e5148da2452c139da806471c0a98cc583955b408a8b", + "size": 400727, + "subdir": "linux-64", + "timestamp": 1674745978909, + "version": "2.13.3" + }, + "astroid-2.13.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=4.0.0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "53c485f1419fb233c782a61fcd3fdbb5", + "name": "astroid", + "sha256": "60a0fcd28c78e68a72cdca91f7a2a6c351db1473e5699db6b9f8fa82845cb01d", + "size": 400481, + "subdir": "linux-64", + "timestamp": 1674746006038, + "version": "2.13.3" + }, + "astroid-2.14.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.10,<3.11.0a0", + "typing-extensions >=4.0.0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "c957c19479b54516120dc9dbc31ccf07", + "name": "astroid", + "sha256": "a4793234d440aff0070dcf8f925cca4817900ede185ae1de2a31e483df322e3d", + "size": 408942, + "subdir": "linux-64", + "timestamp": 1676904351680, + "version": "2.14.2" + }, + "astroid-2.14.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.11,<3.12.0a0", + "wrapt >=1.14,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "24b1eb3b8f74e0c46e948b5c0003edb5", + "name": "astroid", + "sha256": "5d7b49a80047538ddc4b51bd8858c77dfc50656103d55b3061410d07322cf341", + "size": 498069, + "subdir": "linux-64", + "timestamp": 1676920994815, + "version": "2.14.2" + }, + "astroid-2.14.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.4.0,<2.0", + "typing-extensions >=4.0.0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "2437e45d20b7de0ac9bb22ecb589b6a5", + "name": "astroid", + "sha256": "fa9d960f59f9c2523394c90613c2a1361ae15b8fc6a63734300c61070a7b205e", + "size": 400234, + "subdir": "linux-64", + "timestamp": 1676904377138, + "version": "2.14.2" + }, + "astroid-2.14.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=4.0.0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "35ec7c997983a01642608456728ae885", + "name": "astroid", + "sha256": "a67f5eb4113d01ca418df617b4c6b3d50dc4274c9397b2716d590e0d3fab9e3f", + "size": 402953, + "subdir": "linux-64", + "timestamp": 1676904402481, + "version": "2.14.2" + }, + "astroid-2.14.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=4.0.0", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "195ea43d441f2e1e06df7ec1354f1f82", + "name": "astroid", + "sha256": "e83cc4af4cd919a8c80c7ba089d2dc29bdcd5835c47b485f19a769dfd35293d6", + "size": 402766, + "subdir": "linux-64", + "timestamp": 1676904325876, + "version": "2.14.2" + }, + "astroid-2.2.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "typed-ast >=1.3.0", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "ef0ebd56977a6b62597e675d5624afa8", + "name": "astroid", + "sha256": "eda3489f8f7420e78ffec6bf8030ccd64369e0ef54778a7b42f533768b016470", + "size": 273650, + "subdir": "linux-64", + "timestamp": 1552327580067, + "version": "2.2.5" + }, + "astroid-2.2.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "29b28bb0e929b070288c6b1240c64fd2", + "name": "astroid", + "sha256": "9836b71045d0d1a034f42ead43cb6a05b6ac9edafea14e184bf1364b3c7d9a23", + "size": 278562, + "subdir": "linux-64", + "timestamp": 1552327512916, + "version": "2.2.5" + }, + "astroid-2.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "typed-ast", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "44f3a979965d23ef4f270896b4270972", + "name": "astroid", + "sha256": "056470deb6f67058ee73a4d0d7f1825e3ccf5abe37063ba9492f309e07da48ca", + "size": 278121, + "subdir": "linux-64", + "timestamp": 1569854542805, + "version": "2.3.1" + }, + "astroid-2.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "d1fa63a1141bfec22c4e68096464f038", + "name": "astroid", + "sha256": "3e7570a308148594a654b7d95d3efd29bf1bbfd122f26814f0ec8ffe2969dba2", + "size": 278413, + "subdir": "linux-64", + "timestamp": 1569854554228, + "version": "2.3.1" + }, + "astroid-2.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "typed-ast", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "4ab3bf3b2b148c6c48540d4425dcd7e5", + "name": "astroid", + "sha256": "c8a8286e3f61d10a507d09e5c71312d174206f62037932f71f9bc13093c1ce04", + "size": 278493, + "subdir": "linux-64", + "timestamp": 1571758695069, + "version": "2.3.2" + }, + "astroid-2.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "bec2bc0e13521d71ce88ec7b92057e31", + "name": "astroid", + "sha256": "15064be30bdf83b4fa100f0d50b896221820309c08e34e647376a1583de068eb", + "size": 278381, + "subdir": "linux-64", + "timestamp": 1571758690804, + "version": "2.3.2" + }, + "astroid-2.3.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.8,<3.9.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "f61ea16bd81ba00493ba6e4012411723", + "name": "astroid", + "sha256": "a54a08f1b91917436a8c2ecd791adb850f346512ab8b8b740e8346cfc604a1ba", + "size": 277216, + "subdir": "linux-64", + "timestamp": 1574097612292, + "version": "2.3.2" + }, + "astroid-2.3.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "typed-ast", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "e382555458a1076e9250b2f06f483020", + "name": "astroid", + "sha256": "14739a94461ce51ac48425b0c14e4adb4151d482b2ccb6216d15fbce65a566ff", + "size": 278832, + "subdir": "linux-64", + "timestamp": 1573937291952, + "version": "2.3.3" + }, + "astroid-2.3.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "40ac7bd23d2ca5f934ffe294ad4faceb", + "name": "astroid", + "sha256": "a57ce99b6694e7aa910c8b9284f77ba604449387247489b01e388ed88b68d339", + "size": 278715, + "subdir": "linux-64", + "timestamp": 1573937268657, + "version": "2.3.3" + }, + "astroid-2.3.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy", + "python >=3.8,<3.9.0a0", + "setuptools", + "six", + "wrapt" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "2195d3dd37ceec7620664e8962d98355", + "name": "astroid", + "sha256": "8a74cdc36b2e88bdd66f118d22cb39f16fc8076b224dd84b037748f6779f1f2d", + "size": 280477, + "subdir": "linux-64", + "timestamp": 1573937315583, + "version": "2.3.3" + }, + "astroid-2.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "b9f28653686b857986631ffa9e90608e", + "name": "astroid", + "sha256": "cc2fbb9e5a2f6cf8c8227bf84e62502a22f0feb35ee1fb773d42c2c7750d750b", + "size": 461787, + "subdir": "linux-64", + "timestamp": 1588203883419, + "version": "2.4.0" + }, + "astroid-2.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "7d12c5a354172136ae4a77aadc8e8fa3", + "name": "astroid", + "sha256": "1d42286417eaef4c7974e8c2516a32ad403c700f6ed1dff915aed3b4d207b0b0", + "size": 453395, + "subdir": "linux-64", + "timestamp": 1588203883330, + "version": "2.4.0" + }, + "astroid-2.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "8aa890b44b3c1733b1d7d19e2e88b90f", + "name": "astroid", + "sha256": "fb2caf38151d1cc830823c9b6435d056e7893642da3d986bf943c2b38cb39cbe", + "size": 456485, + "subdir": "linux-64", + "timestamp": 1588203888806, + "version": "2.4.0" + }, + "astroid-2.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "b1c9199e749a1e4fa15d4b0d59d1cbcc", + "name": "astroid", + "sha256": "d923d8d79a7c7f304b366f671c0f314e179724912ec40f22b080635d3333dcdb", + "size": 285225, + "subdir": "linux-64", + "timestamp": 1590114513377, + "version": "2.4.1" + }, + "astroid-2.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "b33fc93e5a76bc9d2eb185adcf0c9e83", + "name": "astroid", + "sha256": "257e62d441b047a768779ba2991d4d184e0875d01c5132790b5146848ca7e3e0", + "size": 289236, + "subdir": "linux-64", + "timestamp": 1590114539285, + "version": "2.4.1" + }, + "astroid-2.4.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "b842e50d3eae7bfe0ab3987d42539ea3", + "name": "astroid", + "sha256": "6b3ad0d057fa1b643212041afe33d5acf9966beab52e4886fd0b8a416f920553", + "size": 291073, + "subdir": "linux-64", + "timestamp": 1590114502513, + "version": "2.4.1" + }, + "astroid-2.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "7bc1dde8fad1ee43d45017bf71e6fb6b", + "name": "astroid", + "sha256": "46931ad8a3834bf47efea073202cdaebe2248f047cd635eff7d9f98834d158bc", + "size": 285698, + "subdir": "linux-64", + "timestamp": 1592495948230, + "version": "2.4.2" + }, + "astroid-2.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "b16525ac64df9810a18608cb5161b0e4", + "name": "astroid", + "sha256": "9d88b1b7bcddb28f0f24e5d3da1a4812fba93842c921bcb288dac15aa2156e4e", + "size": 285282, + "subdir": "linux-64", + "timestamp": 1592495911734, + "version": "2.4.2" + }, + "astroid-2.4.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "6ebe41596b8f0d2debe875701928c02d", + "name": "astroid", + "sha256": "3708f4737138cbf7205ac7acc2a67945f1249f852d09e0f2593cc077bf9b7b7d", + "size": 291773, + "subdir": "linux-64", + "timestamp": 1592495946453, + "version": "2.4.2" + }, + "astroid-2.4.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy 1.4.*", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt 1.11.*" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "7a47c4af49a6b472a9abdce9b894d3e9", + "name": "astroid", + "sha256": "a5c94401ccfa21abc72dedae8fa7b37a4dfaf28640acb241afab22aedf04e562", + "size": 291346, + "subdir": "linux-64", + "timestamp": 1607714549670, + "version": "2.4.2" + }, + "astroid-2.5-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "8e1937211f9f420ad89e2a4f1373aac7", + "name": "astroid", + "sha256": "e24e9ee7e0b39dee826e9a789abd20145c277a014a756e7c7c0f4818bb34b0de", + "size": 285522, + "subdir": "linux-64", + "timestamp": 1613500902885, + "version": "2.5" + }, + "astroid-2.5-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "37cf370b23f32ad3fea737c5c0df36de", + "name": "astroid", + "sha256": "58692b55464c70fc0aec0fe5ccd67fa48e0dd49bd683b70cc0216152b6e4904b", + "size": 284731, + "subdir": "linux-64", + "timestamp": 1613500891813, + "version": "2.5" + }, + "astroid-2.5-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "da30981baf8ced269891284a13395382", + "name": "astroid", + "sha256": "bb8fa6cedf054990ac79f7e6d84ea09e1a226f4c96b2685835af534c4a5665d2", + "size": 291300, + "subdir": "linux-64", + "timestamp": 1613500893514, + "version": "2.5" + }, + "astroid-2.5-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "c9f2a10bdcfccb53ccff5d97e23e22ba", + "name": "astroid", + "sha256": "a2f440ef5f9e41efa69effe40fe684c572040bf01c40ea7eb2b2bd3f5e008659", + "size": 291299, + "subdir": "linux-64", + "timestamp": 1613500900672, + "version": "2.5" + }, + "astroid-2.5.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "1b025a4815c71ca1dd5aeb3ed146866c", + "name": "astroid", + "sha256": "2361792b8e0de5a77a37fcc37b2068a6cdb326de12f8bcead34a44683d3dcde9", + "size": 297323, + "subdir": "linux-64", + "timestamp": 1616532521427, + "version": "2.5.1" + }, + "astroid-2.5.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "28b5d0fc96a559dc989c74226b935be1", + "name": "astroid", + "sha256": "04848c689e5571e78e9517473baecedeb255e7e517051a0b25a5b7af201aa29c", + "size": 293550, + "subdir": "linux-64", + "timestamp": 1616530367658, + "version": "2.5.1" + }, + "astroid-2.5.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "bc315c62b654a07456d834fcac9d8019", + "name": "astroid", + "sha256": "9c021ca1af0eb98c3004b2896e35069c860741d4721f7c2afc2d171a8cb0ce21", + "size": 295591, + "subdir": "linux-64", + "timestamp": 1616532273080, + "version": "2.5.1" + }, + "astroid-2.5.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "c280ca5c61cdbd423166d6e9a4381442", + "name": "astroid", + "sha256": "936add2f50c687c06a38e309502381083db962da62dc28d3e4a503f36ebf7514", + "size": 295294, + "subdir": "linux-64", + "timestamp": 1616532520773, + "version": "2.5.1" + }, + "astroid-2.5.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "04c39ca4101e37ec8017546f9ad959a6", + "name": "astroid", + "sha256": "2139cbeaf370d37fd81dcc57d8694c49f3b6cf1eb30afafe3dd29387de042ac2", + "size": 291093, + "subdir": "linux-64", + "timestamp": 1617119300366, + "version": "2.5.2" + }, + "astroid-2.5.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "22e42d636dec728c483e19191f60c928", + "name": "astroid", + "sha256": "f18fb2889a79ae77525234567c733e4b4e103f4f9e5d9841f4e087109698bd84", + "size": 287365, + "subdir": "linux-64", + "timestamp": 1617116835148, + "version": "2.5.2" + }, + "astroid-2.5.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "a82d507394e0a3e14550410957fe8757", + "name": "astroid", + "sha256": "ef512247ea56c48be372d5ee76e14cd37c8cb4ef148b0990d15f5e969a1e9de2", + "size": 289381, + "subdir": "linux-64", + "timestamp": 1617119291008, + "version": "2.5.2" + }, + "astroid-2.5.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "2795810cc970b2f408ca4fe32570f140", + "name": "astroid", + "sha256": "7b0371b4da1bf7bd11cbdb8683cb7adfbfc5a26513f435957c067e658fd65526", + "size": 288725, + "subdir": "linux-64", + "timestamp": 1617119289988, + "version": "2.5.2" + }, + "astroid-2.5.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "63c4c97061b86f864d18216e7b6793c1", + "name": "astroid", + "sha256": "b1a4ee5844b7cceecf44bbe4249f3d4abaa85c8787e18131e6546e359205b02e", + "size": 294966, + "subdir": "linux-64", + "timestamp": 1618348287791, + "version": "2.5.3" + }, + "astroid-2.5.3-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "44b29ce5f1b7414185b2748ca22b327f", + "name": "astroid", + "sha256": "8b84ab374e666cba664dd150b68fb3df760e5c278768bc380d8ab47e4b135326", + "size": 304264, + "subdir": "linux-64", + "timestamp": 1618392814636, + "version": "2.5.3" + }, + "astroid-2.5.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "07435a4728f94aa8b60dc39cad6f59c0", + "name": "astroid", + "sha256": "37ebd649186ef2f6efdbd1238df3aa0183642b680166acc76a67f8684384d27c", + "size": 290624, + "subdir": "linux-64", + "timestamp": 1618348280194, + "version": "2.5.3" + }, + "astroid-2.5.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "67e38f5ab21c2e9462c4ec4b5b917846", + "name": "astroid", + "sha256": "f53ba9adc0eb4b4e2fdb6db40d0be989eb9258d0dda2fcf462c058fdbd716cba", + "size": 304322, + "subdir": "linux-64", + "timestamp": 1618392813939, + "version": "2.5.3" + }, + "astroid-2.5.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "0e4ab7c2c4f4784946adc939d2f17096", + "name": "astroid", + "sha256": "71b58eaf0a88487e53eae7b99d85cb42d2092b335259262a12823ca39b4bbb1b", + "size": 291696, + "subdir": "linux-64", + "timestamp": 1618348286329, + "version": "2.5.3" + }, + "astroid-2.5.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "33c57359d836dbbda3a5fc64d420715e", + "name": "astroid", + "sha256": "657ab3194a20a3a9eb7d657c12be31ddfe73936a792f06a698647d0438b106ed", + "size": 306326, + "subdir": "linux-64", + "timestamp": 1618392814666, + "version": "2.5.3" + }, + "astroid-2.5.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "2fc8a451f73352f47faa81ef7a237944", + "name": "astroid", + "sha256": "4c7f57933c88e1ca331bfd609608bb6b1c79e869ddc186515b1bb095c09c3616", + "size": 291495, + "subdir": "linux-64", + "timestamp": 1618345204746, + "version": "2.5.3" + }, + "astroid-2.5.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "3ab2a50a2328e287af5d7ba5521ddc44", + "name": "astroid", + "sha256": "eb4e7d98745b66f31a09c9f4e67d31c66ae479d69ba88be0a8b41644bc23c4d2", + "size": 301613, + "subdir": "linux-64", + "timestamp": 1618389713111, + "version": "2.5.3" + }, + "astroid-2.5.6-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "17bbebacf9a1cc300cfffc41d6570d87", + "name": "astroid", + "sha256": "9caba7d5e58a4e7207942be4f171908d33ad2a8c092c56526f7541da41a1ec13", + "size": 302333, + "subdir": "linux-64", + "timestamp": 1620869746373, + "version": "2.5.6" + }, + "astroid-2.5.6-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "95d090bf7339b9489f20f3ddd36d6036", + "name": "astroid", + "sha256": "9f79f1a7b377e75cb517fb7fc6379464bcb3c6aade45bf62aced36d4e37b0101", + "size": 297581, + "subdir": "linux-64", + "timestamp": 1620822947194, + "version": "2.5.6" + }, + "astroid-2.5.6-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "398c04751a1cb7a067f71511dca4636a", + "name": "astroid", + "sha256": "76b229ca4a22775d90b7279d2abcc27a1fbfbe12f7a8b945ebc5dde54882eb31", + "size": 297872, + "subdir": "linux-64", + "timestamp": 1620869668143, + "version": "2.5.6" + }, + "astroid-2.5.6-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.12,<2", + "typed-ast >=1.4.0,<1.5", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "04ad128e815acf3db6dc6c971f7f5a58", + "name": "astroid", + "sha256": "272b4655b6a7158c26cb163fc7162539ad22d40344e2be9f5ef08fcba935725c", + "size": 297517, + "subdir": "linux-64", + "timestamp": 1620827279090, + "version": "2.5.6" + }, + "astroid-2.5.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "6a73ed65af5981387a07d051752dbaf3", + "name": "astroid", + "sha256": "39ced68a9f135954d8fe220b64273d700fcdd9ca908c93dc08e862ba9a2e332a", + "size": 304447, + "subdir": "linux-64", + "timestamp": 1620865400578, + "version": "2.5.6" + }, + "astroid-2.5.6-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "9e12e7ee29337c6a8de1a88e836a0d38", + "name": "astroid", + "sha256": "429b8182a9beef8fed357e6102e53cd1c2a58dfdce4bb9fe0727f2bc5966bba9", + "size": 300725, + "subdir": "linux-64", + "timestamp": 1620827173677, + "version": "2.5.6" + }, + "astroid-2.5.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "dd9a3d5a86ca7ea1cb7233a6b88fd8f6", + "name": "astroid", + "sha256": "73642c4fa55891e181e8c86893556f20662526a086a1597bca2581689cc0a6c3", + "size": 304193, + "subdir": "linux-64", + "timestamp": 1620869742691, + "version": "2.5.6" + }, + "astroid-2.5.6-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "lazy-object-proxy >=1.4,<2", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.12,<2", + "wrapt >=1.11,<2" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "1f5f8664549094fd74aa85082e1ea519", + "name": "astroid", + "sha256": "87050c79beb6a9007b1e9219e06de76476eb1891aefc629eb1b52286f3c10a79", + "size": 304021, + "subdir": "linux-64", + "timestamp": 1620827282482, + "version": "2.5.6" + }, + "astroid-2.5.7-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "022aa8fc0b79e22195856fc0b0057a17", + "name": "astroid", + "sha256": "90688ceff73791cae87a23f398a6e1cdcf11935fbff718aeb0a62b27511b6472", + "size": 306024, + "subdir": "linux-64", + "timestamp": 1622551468168, + "version": "2.5.7" + }, + "astroid-2.5.7-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "ab9b2b9e66ea6da503559b261dfc4d62", + "name": "astroid", + "sha256": "b6ec316e51602800c8b23d9665f60ce1a1e8abceaa7464952fbb9379daf5872a", + "size": 301299, + "subdir": "linux-64", + "timestamp": 1622556626935, + "version": "2.5.7" + }, + "astroid-2.5.7-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "ed32caf0e2adfcc3687a9a23c4af0b03", + "name": "astroid", + "sha256": "75a6c22c41885f5810c61f550e34825eb12b8a4c0687fda4534c44019d043675", + "size": 303131, + "subdir": "linux-64", + "timestamp": 1622556676443, + "version": "2.5.7" + }, + "astroid-2.5.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "245e6854a9f737d4677588ad430377fc", + "name": "astroid", + "sha256": "6d229ffac3e3618e5c1dc8d3b1b7e2dfa256405235342b68dcbdbf1278508b4f", + "size": 308309, + "subdir": "linux-64", + "timestamp": 1622556657799, + "version": "2.5.7" + }, + "astroid-2.5.8-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "be0d6324fd3c96e6b76dc1da0a1c6582", + "name": "astroid", + "sha256": "ebf4f96dd2f30c1aca8f599fee96c0641e3b7a7bd7e9c7ed57ff4aa604a26633", + "size": 304404, + "subdir": "linux-64", + "timestamp": 1623156821515, + "version": "2.5.8" + }, + "astroid-2.5.8-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "5e892cdb4f2d314d5103c2917223c645", + "name": "astroid", + "sha256": "8551a219790018745921e23073cde3d8115ef8490077a7a44e132e9098d22b38", + "size": 304106, + "subdir": "linux-64", + "timestamp": 1623156818335, + "version": "2.5.8" + }, + "astroid-2.5.8-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "9731c88090a93d1b467bcbfaf1e0ec76", + "name": "astroid", + "sha256": "da08850a9a9aec792c8c99ccdbd44fca685a859e6bd9455874814e3e238db1ce", + "size": 311130, + "subdir": "linux-64", + "timestamp": 1623156827002, + "version": "2.5.8" + }, + "astroid-2.5.8-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "2732d96ce495b1a0bc87b67eb44c2d11", + "name": "astroid", + "sha256": "45c0ca2a8043ff71c969c71c26638b95f6d4a9591f8c191650db1143d0504e60", + "size": 306204, + "subdir": "linux-64", + "timestamp": 1623162315545, + "version": "2.5.8" + }, + "astroid-2.6.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "d677c97e901ce72c3b09e73612298d4e", + "name": "astroid", + "sha256": "012345ca7808c867745556331cf254a687fb208e23b02634236ad3e08483558d", + "size": 314570, + "subdir": "linux-64", + "timestamp": 1624519696827, + "version": "2.6.0" + }, + "astroid-2.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "82b44bde690c6d8f4bdc3084023bdbf9", + "name": "astroid", + "sha256": "4a1de6491c65114dc267eec0f4c8792f9bf1a6b921aa29c1ce86fa8432693350", + "size": 314379, + "subdir": "linux-64", + "timestamp": 1624519646341, + "version": "2.6.0" + }, + "astroid-2.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "16b42da76f82c704238a31124b129ab0", + "name": "astroid", + "sha256": "d29ad42a7dbc50ca1d1f948724bda33e949a0711db689b077973c77ab4ed98ad", + "size": 316709, + "subdir": "linux-64", + "timestamp": 1624519678502, + "version": "2.6.0" + }, + "astroid-2.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "5c462e98f5b4f6e4f8b26e636a181740", + "name": "astroid", + "sha256": "5a15eb43eba38b569744e946fe0d030d39accbfa2e1837cdf9e37ea6bed2143f", + "size": 316741, + "subdir": "linux-64", + "timestamp": 1624519692344, + "version": "2.6.0" + }, + "astroid-2.6.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "08d878911bdddf7dddf2417efd23b38e", + "name": "astroid", + "sha256": "9a872a7c067b0e351f99c8681684eb63d8a9e273f7bf047c1929feff405661e5", + "size": 311434, + "subdir": "linux-64", + "timestamp": 1625075616272, + "version": "2.6.2" + }, + "astroid-2.6.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "ee289c040d7e7c88c827dc46534d9ff7", + "name": "astroid", + "sha256": "ac041771c194f52fa67343f2e51351d39b687e2953ad2cd38fc077d2d222b751", + "size": 315710, + "subdir": "linux-64", + "timestamp": 1625075852359, + "version": "2.6.2" + }, + "astroid-2.6.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "0b43d2aee755f2d04f7383dde6e6fa25", + "name": "astroid", + "sha256": "841fc8c2f3ae203ec5a4a8d602813f6a39753f9f54a4cddf5b8a1143c8dfa4a8", + "size": 313442, + "subdir": "linux-64", + "timestamp": 1625075849761, + "version": "2.6.2" + }, + "astroid-2.6.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "576ff93dbca037ea087397aeb351b0d5", + "name": "astroid", + "sha256": "3a0b420d92d97bfb098c29ce0181e60f19c40970e9d4bf5b0c5b8da46f4cd2ac", + "size": 317537, + "subdir": "linux-64", + "timestamp": 1625075863650, + "version": "2.6.2" + }, + "astroid-2.6.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.6,<3.7.0a0", + "setuptools >=20.0", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "2dc00a474c97c1beca96ce7d2be1762a", + "name": "astroid", + "sha256": "7de384757b7599495ec96f6416312073354ffa75fbe76ac4e7e470a0b47a88ff", + "size": 313391, + "subdir": "linux-64", + "timestamp": 1626766704919, + "version": "2.6.4" + }, + "astroid-2.6.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools >=20.0", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "d0430db90d1fcbff61e97cc3be662d0a", + "name": "astroid", + "sha256": "052abf6871bedbfa5fb6f3e4274ad95aea2910ee8cff6f6fca6bd012e64f52da", + "size": 317910, + "subdir": "linux-64", + "timestamp": 1626766125085, + "version": "2.6.4" + }, + "astroid-2.6.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools >=20.0", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "591893b6767a03f0b5383c48e0e5cac6", + "name": "astroid", + "sha256": "eec39158c611fb9ff5f48a49351712f269f27c8a6e2921071d4b7a7be18f6c0b", + "size": 319495, + "subdir": "linux-64", + "timestamp": 1626766690659, + "version": "2.6.4" + }, + "astroid-2.6.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools >=20.0", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "280e33966a7caaa424250345476e0809", + "name": "astroid", + "sha256": "0f91e4401aa7427cda1bc2c96c61a98cae792d2e4e9cbc7961b6d6b5903d64d4", + "size": 319562, + "subdir": "linux-64", + "timestamp": 1626759376345, + "version": "2.6.4" + }, + "astroid-2.6.5-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.6,<3.7.0a0", + "setuptools >=20.0", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "e3df88d1030240861330bc0c62c1be69", + "name": "astroid", + "sha256": "195bb061a775f64a1172f21d1285f330af4a7608f31fb6b01bb9e5f0ebcfcd22", + "size": 313302, + "subdir": "linux-64", + "timestamp": 1626943060189, + "version": "2.6.5" + }, + "astroid-2.6.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools >=20.0", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "4d86b55a9c68017016daa007c24e2652", + "name": "astroid", + "sha256": "18921323eb11dd6edf395a5fe2fbe2a7b21676b01af53ee7cbcdc49d0ad2d8c3", + "size": 313242, + "subdir": "linux-64", + "timestamp": 1626950458991, + "version": "2.6.5" + }, + "astroid-2.6.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools >=20.0", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "0320edc4c3fb033abfec1376e480500b", + "name": "astroid", + "sha256": "57a11e84b2eb86f1ac934b246f0b0d73ecaaff6563ab633148644abbeaf1a096", + "size": 319630, + "subdir": "linux-64", + "timestamp": 1626950455997, + "version": "2.6.5" + }, + "astroid-2.6.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools >=20.0", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "ba3d2e4832162dd6496fc71dc50a262d", + "name": "astroid", + "sha256": "5bb4edf9a6fd4c4a4210ae54d815dad44f757243db98ec227f6c8249f2734387", + "size": 319359, + "subdir": "linux-64", + "timestamp": 1626950477950, + "version": "2.6.5" + }, + "astroid-2.6.6-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.6,<3.7.0a0", + "setuptools >=20.0", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "8a17b4e18672c3ed3ec794d055905200", + "name": "astroid", + "sha256": "feeb4ba97c3db0d782e4bde1d903dc95ee611007cba30e7dcb27c5543896e014", + "size": 318743, + "subdir": "linux-64", + "timestamp": 1628055210573, + "version": "2.6.6" + }, + "astroid-2.6.6-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools >=20.0", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "38b42a470c394d9eb68359a50b0652f0", + "name": "astroid", + "sha256": "611d9ab591379b5829aaa3cb4fd9b6d5e49dfd2a37b6976ebd831afa47305f73", + "size": 318064, + "subdir": "linux-64", + "timestamp": 1628063095474, + "version": "2.6.6" + }, + "astroid-2.6.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools >=20.0", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "c71f41bb412240d38666c0bfa024a27e", + "name": "astroid", + "sha256": "662fcda44454d3ef283570c1d072f1353a487ccb8521d96390dd40febade03d8", + "size": 316763, + "subdir": "linux-64", + "timestamp": 1628063176156, + "version": "2.6.6" + }, + "astroid-2.6.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools >=20.0", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "637f7edf093e102791a1cbe6b77bcc21", + "name": "astroid", + "sha256": "c1f252f51e9fe9d8e5c73228515e81f13ebb5c85c037949c345571b6a5cdb2d4", + "size": 315699, + "subdir": "linux-64", + "timestamp": 1628063174058, + "version": "2.6.6" + }, + "astroid-2.7.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.6,<3.7.0a0", + "setuptools >=20.0", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "71fabebf1020f990b19913137f684464", + "name": "astroid", + "sha256": "d93a6fd7833724f32229a6295d8e877942c45c9860661b287f1773209e860f3f", + "size": 319494, + "subdir": "linux-64", + "timestamp": 1629320225149, + "version": "2.7.1" + }, + "astroid-2.7.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools >=20.0", + "typed-ast >=1.4.0,<1.5", + "typing-extensions >=3.7.4", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "eb05b8c325b8752d6bde6b3d41716b22", + "name": "astroid", + "sha256": "33e342d1944ff1019ead86efd47c6d30a1d856075f5609da2624582fa48ef761", + "size": 323913, + "subdir": "linux-64", + "timestamp": 1629320310953, + "version": "2.7.1" + }, + "astroid-2.7.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools >=20.0", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "4f241598c083d31297ef780ee85ba3e5", + "name": "astroid", + "sha256": "b811a54c368231cec04583cbb4e272df554182a8b031df890aa6aa4531f9b9b0", + "size": 325859, + "subdir": "linux-64", + "timestamp": 1629320313072, + "version": "2.7.1" + }, + "astroid-2.7.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools >=20.0", + "wrapt >=1.11,<1.13" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "a65df8dcd6247b7dbbf6fcba9d107e92", + "name": "astroid", + "sha256": "cc75a63e7a8a82169e782b395a157899cf0ed4dea61f9a5a3a52a83663902cfe", + "size": 320972, + "subdir": "linux-64", + "timestamp": 1629311689638, + "version": "2.7.1" + }, + "astroid-2.9.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.10,<3.11.0a0", + "setuptools >=20.0", + "wrapt >=1.11,<1.14" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "6a71afad10dce4418c1fb164147cbed3", + "name": "astroid", + "sha256": "f1cdbdca87921d66233cbfd1e62c0aaf0e0466a21b5b56f3b8725d2c1d9acedf", + "size": 342185, + "subdir": "linux-64", + "timestamp": 1640803436356, + "version": "2.9.0" + }, + "astroid-2.9.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.7,<3.8.0a0", + "setuptools >=20.0", + "typed-ast >=1.4.0,<2.0", + "typing-extensions >=3.10", + "wrapt >=1.11,<1.14" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "9daa918b5706f7cc7234ac379f71ae5c", + "name": "astroid", + "sha256": "0be65932b659edf5232030e50621cdaba54b37516c0b8d49e60c037b03f89ce6", + "size": 347288, + "subdir": "linux-64", + "timestamp": 1639026138678, + "version": "2.9.0" + }, + "astroid-2.9.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.8,<3.9.0a0", + "setuptools >=20.0", + "typing-extensions >=3.10", + "wrapt >=1.11,<1.14" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "f4b5c2567fcc27d693abfbfcad2701e2", + "name": "astroid", + "sha256": "c7754211e85aa0463609c9db73e87fd040145562bcba09cddba7167058885383", + "size": 344343, + "subdir": "linux-64", + "timestamp": 1639030713960, + "version": "2.9.0" + }, + "astroid-2.9.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "lazy-object-proxy >=1.4.0", + "python >=3.9,<3.10.0a0", + "setuptools >=20.0", + "typing-extensions >=3.10", + "wrapt >=1.11,<1.14" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "57f0920d7b6c86bdf92f58e2bbc52e98", + "name": "astroid", + "sha256": "3fec310153150c89c085844ae115c6b085e37e38839a28769a3b99111533a8a2", + "size": 349819, + "subdir": "linux-64", + "timestamp": 1639044253882, + "version": "2.9.0" + }, + "astropy-2.0.11-py27hdd07704_0.conda": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest <3.7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "e7acdff429304f53c827708bc919c19e", + "name": "astropy", + "sha256": "de9a33b9fafe4f83533bcbb36cac6a96eb4ac530d1cbc1e74c067cd12a0bc9bb", + "size": 5793776, + "subdir": "linux-64", + "timestamp": 1546570651213, + "version": "2.0.11" + }, + "astropy-2.0.11-py36hdd07704_0.conda": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest <3.7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "525271d6dcdaecaeee190912fc2462d2", + "name": "astropy", + "sha256": "62360a699556c4ed0b9015510444a10ead79a61b60797586ad735bfe4e5f2dff", + "size": 5794491, + "subdir": "linux-64", + "timestamp": 1546570580670, + "version": "2.0.11" + }, + "astropy-2.0.11-py37hdd07704_0.conda": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest <3.7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "9817724267a085dbbac4e1f75afa86de", + "name": "astropy", + "sha256": "5428841f6aaa7fbe7f3a5d0098111ccb2048654eeeba4ba6d6df9785d9be4afd", + "size": 5741682, + "subdir": "linux-64", + "timestamp": 1546570652369, + "version": "2.0.11" + }, + "astropy-2.0.12-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.9", + "pytest <3.7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "f70834d333386a97de8dd581916cd99e", + "name": "astropy", + "sha256": "0f5746649f9150843c9cfaae313a36e53fc12a496ee7c25f7a9ba08c9cb170a5", + "size": 5781792, + "subdir": "linux-64", + "timestamp": 1551202000566, + "version": "2.0.12" + }, + "astropy-2.0.12-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11", + "pytest <3.7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "e07f1ce9b1037b572dbde6981d5e470d", + "name": "astropy", + "sha256": "097c00eebc15fee71b042cfa6aaec5620d8df7372677791df4be5efa45616eef", + "size": 5788586, + "subdir": "linux-64", + "timestamp": 1551198524776, + "version": "2.0.12" + }, + "astropy-2.0.12-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14", + "pytest <3.7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "92ac1f41313a1e78935fceee8d3fdf9c", + "name": "astropy", + "sha256": "6528ef9912ac6e0fc1e6639cd2cf5bc11f3e9551d0ebdb19bcf0a248105b2d2d", + "size": 5774007, + "subdir": "linux-64", + "timestamp": 1551201861659, + "version": "2.0.12" + }, + "astropy-2.0.13-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.9", + "pytest <3.7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "43b53dd5a8d105dd916d0c2753535322", + "name": "astropy", + "sha256": "72e7bb349dd9fd4bd19ab06f0ebcb8b425f204090d4f23060162b9bc87d7293c", + "size": 5783372, + "subdir": "linux-64", + "timestamp": 1560312619523, + "version": "2.0.13" + }, + "astropy-2.0.13-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11", + "pytest <3.7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "8d1395e1cc3977179a5da6caa6bcef5e", + "name": "astropy", + "sha256": "125a6867b8b0b45b09bec3b9a4aeb137654a3cb63fd0c46c62beacb929eb74c6", + "size": 5748694, + "subdir": "linux-64", + "timestamp": 1560312655458, + "version": "2.0.13" + }, + "astropy-2.0.13-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14", + "pytest <3.7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "adf90f454811a3b42af0753f303d88dc", + "name": "astropy", + "sha256": "792e8a840aa410cec93d50d5d37ee2061ea8afdce628f94ea97ad57047441e32", + "size": 5743483, + "subdir": "linux-64", + "timestamp": 1560312606571, + "version": "2.0.13" + }, + "astropy-2.0.14-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.9", + "pytest <3.7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "6eced4d47054f6a3d20f7584e8b4951f", + "name": "astropy", + "sha256": "0218efe2eff1f925f9ec738709d84c55d6686b5aba9a5361144f4dbc312f2659", + "size": 5784648, + "subdir": "linux-64", + "timestamp": 1560671193993, + "version": "2.0.14" + }, + "astropy-2.0.14-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11", + "pytest <3.7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "569c67d301824963e99b2784293a784f", + "name": "astropy", + "sha256": "c181acd566818f6f67f84e282973476724f5d29fa5dce92a214d11ddc0397db4", + "size": 5791617, + "subdir": "linux-64", + "timestamp": 1560671203964, + "version": "2.0.14" + }, + "astropy-2.0.14-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14", + "pytest <3.7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "ebd8dee28716ca73dbe0df1a49589e7f", + "name": "astropy", + "sha256": "29f55ca51a3090e1e68566356dfcbf41e5bbd9a241d1eb5ecbfc945930194e75", + "size": 5781249, + "subdir": "linux-64", + "timestamp": 1560671223765, + "version": "2.0.14" + }, + "astropy-2.0.15-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.9", + "pytest <3.7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "897d596e3465a15e4a2f937767416470", + "name": "astropy", + "sha256": "fb54e905a4e53b217a44490c9d40072daa126edb79cbffc21acb10220b75ea22", + "size": 5794839, + "subdir": "linux-64", + "timestamp": 1570568351653, + "version": "2.0.15" + }, + "astropy-2.0.15-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11", + "pytest <3.7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "3bd8a5d6356f00ccac1fd70d07c54896", + "name": "astropy", + "sha256": "e2bd225cb3744b6b846db291abc2246374defd5c81fa9747b7e33a925e8651d1", + "size": 5795101, + "subdir": "linux-64", + "timestamp": 1570568350509, + "version": "2.0.15" + }, + "astropy-2.0.15-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14", + "pytest <3.7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "003882218bd7de7971cca9a80723a49f", + "name": "astropy", + "sha256": "fd138334a6ccd1b21385915403f9a12867e3a58c8945d606b48b28bf78abbc94", + "size": 5789065, + "subdir": "linux-64", + "timestamp": 1570568335682, + "version": "2.0.15" + }, + "astropy-2.0.16-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.9", + "pytest <3.7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "3a966185b21eb00374257af9b1cbb839", + "name": "astropy", + "sha256": "9ecbf242438950b0b5f0c526f39b50bb35da8c953536a2f411e603f663a4a860", + "size": 5792704, + "subdir": "linux-64", + "timestamp": 1572991754339, + "version": "2.0.16" + }, + "astropy-2.0.16-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11", + "pytest <3.7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "7d47edfd55b45cd22b805cbb9457d8c0", + "name": "astropy", + "sha256": "f3c4bcfcd0c99dbf478a592c92ff89f0b5204f13be9c926b6f2d5d73f0d38c5d", + "size": 5798421, + "subdir": "linux-64", + "timestamp": 1572991813167, + "version": "2.0.16" + }, + "astropy-2.0.16-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14", + "pytest <3.7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "d8ad3c699abec085df4ea2463795c49b", + "name": "astropy", + "sha256": "31dcaee2d998b27e2b60e53943923bef52655f9bbf79b3e8edf823d3f4c892d4", + "size": 5789536, + "subdir": "linux-64", + "timestamp": 1572991739693, + "version": "2.0.16" + }, + "astropy-2.0.2-py27h57072c0_4.conda": { + "build": "py27h57072c0_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "a4e76c807b988cab45e17e3268649aed", + "name": "astropy", + "sha256": "f3c54e0bbb959d625bac9547a2e245b7b04996b4366f8ef5f2ecdfbf896c39d6", + "size": 5688365, + "subdir": "linux-64", + "timestamp": 1505723452634, + "version": "2.0.2" + }, + "astropy-2.0.2-py35h2d2a8a6_4.conda": { + "build": "py35h2d2a8a6_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "b9c9da6b1e279a93195cc89f044ef15a", + "name": "astropy", + "sha256": "d4d895d63210f8100be24eb8615832c53a00023fa21fdd2b2d497a3e725c15fe", + "size": 5709173, + "subdir": "linux-64", + "timestamp": 1505723661897, + "version": "2.0.2" + }, + "astropy-2.0.2-py36ha51211e_4.conda": { + "build": "py36ha51211e_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "1bc83c01d1c04b5e141761858d59c68e", + "name": "astropy", + "sha256": "b8ed713128f9ebc8ba2eff07c502291aafe8c866a522e9b1b2df44443551f412", + "size": 5650570, + "subdir": "linux-64", + "timestamp": 1505723856865, + "version": "2.0.2" + }, + "astropy-2.0.3-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "e8b43df2b5acb9d73ba0eedd6f124ef9", + "name": "astropy", + "sha256": "5c0a4b2d51c80d8fdc737846561e56927113e084f6db96a1eda91ffbd468f948", + "size": 5718991, + "subdir": "linux-64", + "timestamp": 1513803232772, + "version": "2.0.3" + }, + "astropy-2.0.3-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "ed27c0387dc6634b649b8f9b91037538", + "name": "astropy", + "sha256": "1cdbbf3d1926b16c7e9453186ec5a4311587b9800fd80eee5b187c3d0fb0fbbe", + "size": 5749008, + "subdir": "linux-64", + "timestamp": 1513803287166, + "version": "2.0.3" + }, + "astropy-2.0.3-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "02b1b01466b9ff1253e07e5c1824818c", + "name": "astropy", + "sha256": "7de305e212dafef1fbeb6e263b2c87fb6c8e48745a46f3a8a9e019fcd027eb9a", + "size": 5687716, + "subdir": "linux-64", + "timestamp": 1513803293928, + "version": "2.0.3" + }, + "astropy-2.0.4-py27h3010b51_1.conda": { + "build": "py27h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.14.0,<2.0a0", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "497ce5f13cceec0ec9853e2d81e46657", + "name": "astropy", + "sha256": "dc5ed5d0c418df90f376a8f07eb1ff5fc5b3648f29cfefabf596cb9d2b1852dd", + "size": 5692732, + "subdir": "linux-64", + "timestamp": 1518728641748, + "version": "2.0.4" + }, + "astropy-2.0.4-py35h3010b51_1.conda": { + "build": "py35h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "f387283925f72afad8a8979d9d4c1a34", + "name": "astropy", + "sha256": "be004b17729f5968b8b840b7da3641c0f525ad680b3dbbe21bee498c7d85d638", + "size": 5713670, + "subdir": "linux-64", + "timestamp": 1518728742895, + "version": "2.0.4" + }, + "astropy-2.0.4-py36h3010b51_1.conda": { + "build": "py36h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "259ac97a8c11d08cefd479d572683619", + "name": "astropy", + "sha256": "ced73082e31bb05e275631ee09ef11aed78d0a5a7f27bf5e6b8f2dccc39debcb", + "size": 5693324, + "subdir": "linux-64", + "timestamp": 1518728746207, + "version": "2.0.4" + }, + "astropy-2.0.5-py27h3010b51_1.conda": { + "build": "py27h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.14.1,<2.0a0", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "21fcdac9fc4d00cd8bf7f628e931b652", + "name": "astropy", + "sha256": "5ee9833a99ff450aa29c69627f648b32f6adf6ca8dd8d14483c61636450ae6f7", + "size": 5734643, + "subdir": "linux-64", + "timestamp": 1520968102206, + "version": "2.0.5" + }, + "astropy-2.0.5-py27h3010b51_2.conda": { + "build": "py27h3010b51_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "d91798657c4fa43cfae18a68789406f1", + "name": "astropy", + "sha256": "2441ebcb6c6e94bec3e910f16ac7a0ffc3cd49577ff1cfe0f9019bb366325cf7", + "size": 5734901, + "subdir": "linux-64", + "timestamp": 1521477783284, + "version": "2.0.5" + }, + "astropy-2.0.5-py35h3010b51_1.conda": { + "build": "py35h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.14.1,<2.0a0", + "pytest", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "fa7434aa13ac6dc1ac5fbe54ccdba5c8", + "name": "astropy", + "sha256": "b004eca8234997e030036611e6b5b1b5fc14090d6fb5d7b2d023421874fc32ce", + "size": 5762421, + "subdir": "linux-64", + "timestamp": 1520968158099, + "version": "2.0.5" + }, + "astropy-2.0.5-py35h3010b51_2.conda": { + "build": "py35h3010b51_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "e1d735fd34bfd6363e5cdec40dcf9038", + "name": "astropy", + "sha256": "e6c8550d257416453a4b9bbd9d91821059034a208e0ef9a9eca062afcec30e88", + "size": 5762519, + "subdir": "linux-64", + "timestamp": 1521477905907, + "version": "2.0.5" + }, + "astropy-2.0.5-py36h3010b51_1.conda": { + "build": "py36h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.14.1,<2.0a0", + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "4bdfca4b996ac7cafa9d366c2886a491", + "name": "astropy", + "sha256": "d7b9a24939a7d679a55eafd4be8a2964d5e30efbc903f3d7b637cfff0ba8de17", + "size": 5705130, + "subdir": "linux-64", + "timestamp": 1520968036456, + "version": "2.0.5" + }, + "astropy-2.0.5-py36h3010b51_2.conda": { + "build": "py36h3010b51_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "261afbb2f4edbacb43141388f203b1e0", + "name": "astropy", + "sha256": "eb41eea2bbd80dbdda1cbb949ad59afa42b415b90800e099e79e93656d2e4c73", + "size": 5734630, + "subdir": "linux-64", + "timestamp": 1521477640677, + "version": "2.0.5" + }, + "astropy-2.0.6-py27h3010b51_1.conda": { + "build": "py27h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "cd3b18c054df6b8d5667d576a832228e", + "name": "astropy", + "sha256": "492664c2fa52f1515e1e9a68447d21fa82783e05a07475940776fbc746fbcbdd", + "size": 5714389, + "subdir": "linux-64", + "timestamp": 1524571321797, + "version": "2.0.6" + }, + "astropy-2.0.6-py35h3010b51_1.conda": { + "build": "py35h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "9b037c693181e64c5a133c95c64ca36e", + "name": "astropy", + "sha256": "882e625b7db7e743af1f3f4a58ad13b6e3aa5da94ddb67180c1b512526957cbf", + "size": 5789065, + "subdir": "linux-64", + "timestamp": 1524571377335, + "version": "2.0.6" + }, + "astropy-2.0.6-py36h3010b51_1.conda": { + "build": "py36h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "594e4d29c1ce5ac6ebc8d5bcf8644ecb", + "name": "astropy", + "sha256": "b7011f158f02d9c4d7193a864fdf1f8c208d6bce7688353713d169fa0111ee17", + "size": 5750452, + "subdir": "linux-64", + "timestamp": 1524571380518, + "version": "2.0.6" + }, + "astropy-2.0.7-py27h3010b51_1.conda": { + "build": "py27h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "e1c6fe7bfd9112b508aa1d7f20bc874c", + "name": "astropy", + "sha256": "bf815bc53726d3575f0825befa5f8bc5407152e6885745d652627b26fd9af514", + "size": 5717231, + "subdir": "linux-64", + "timestamp": 1528031289928, + "version": "2.0.7" + }, + "astropy-2.0.7-py35h3010b51_1.conda": { + "build": "py35h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "aa1091ba0dcd4e92d74fd58963b2914e", + "name": "astropy", + "sha256": "a8404b7db97fda253b97a8584e18da7bb6d00264e03c5bfa2cab25c113cb6dae", + "size": 5790489, + "subdir": "linux-64", + "timestamp": 1528031319662, + "version": "2.0.7" + }, + "astropy-2.0.7-py36h3010b51_1.conda": { + "build": "py36h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "651afe85a867c22913a5fd2eb7adf90e", + "name": "astropy", + "sha256": "e155d7ca1af52b9c24996b2a4a3e63e88e5cc822006dfe0c572b7c4db3c59b59", + "size": 5751118, + "subdir": "linux-64", + "timestamp": 1528031291431, + "version": "2.0.7" + }, + "astropy-2.0.8-py27h035aef0_0.conda": { + "build": "py27h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "9213e8827544ff72ab191eff1198a984", + "name": "astropy", + "sha256": "129c01674b44b12ad820fc368c63863f0af6f0d2504d1f0f0eb0a59cd2a4872b", + "size": 5717383, + "subdir": "linux-64", + "timestamp": 1533324118493, + "version": "2.0.8" + }, + "astropy-2.0.8-py35h035aef0_0.conda": { + "build": "py35h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "c8c798dd7d09421ab39d315fac55b874", + "name": "astropy", + "sha256": "fa94ea62a8f60a24d70365d94fd8921827dd08d82f62842841f3adf491f12500", + "size": 5743826, + "subdir": "linux-64", + "timestamp": 1533323867838, + "version": "2.0.8" + }, + "astropy-2.0.8-py36h035aef0_0.conda": { + "build": "py36h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "097e1b9075714fa8914b4e991e8e543b", + "name": "astropy", + "sha256": "4f079692498b6c1dc5336ce9b3c821eb8339e243f7034c1f850fdb02a0037c0f", + "size": 5719145, + "subdir": "linux-64", + "timestamp": 1533324153209, + "version": "2.0.8" + }, + "astropy-2.0.8-py37h035aef0_0.conda": { + "build": "py37h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "34f0e20110de5dc8d652ce6bae965f82", + "name": "astropy", + "sha256": "52eead81669b9380af6c0d63d167f7bd064dde998e80346dd0908dd969d9e6b2", + "size": 5741036, + "subdir": "linux-64", + "timestamp": 1533324141017, + "version": "2.0.8" + }, + "astropy-2.0.9-py27hdd07704_0.conda": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "fc858b3013475d09f7d0ac8862873a63", + "name": "astropy", + "sha256": "635345552bd2b6890f01956b6f3c583cb01b717e16e2f8b37e5e39d2f031f474", + "size": 5752188, + "subdir": "linux-64", + "timestamp": 1539981516627, + "version": "2.0.9" + }, + "astropy-2.0.9-py27hdd07704_1.conda": { + "build": "py27hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest <3.7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "0eb055d8eb1155e57839afefa7243c43", + "name": "astropy", + "sha256": "5ecf549bcc2b15abb619b46e5be3ffac246a46e7787801eff67e00de6a983809", + "size": 5755411, + "subdir": "linux-64", + "timestamp": 1543593605258, + "version": "2.0.9" + }, + "astropy-2.0.9-py36hdd07704_0.conda": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "a6f6efb4705a03b934e7bd669e5fccf5", + "name": "astropy", + "sha256": "bee420648759815951d01455e308c39073d74daee90e30c20f797f3d869a1759", + "size": 5745808, + "subdir": "linux-64", + "timestamp": 1539981576840, + "version": "2.0.9" + }, + "astropy-2.0.9-py36hdd07704_1.conda": { + "build": "py36hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest <3.7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "d66aeabe63384687b30327c30756f688", + "name": "astropy", + "sha256": "5dc07dab9e99b7e9b003abd11e2cacfa8f41584c3fb02d6acda71744a4d428d6", + "size": 5749286, + "subdir": "linux-64", + "timestamp": 1543593753973, + "version": "2.0.9" + }, + "astropy-2.0.9-py37hdd07704_0.conda": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "4856c67ff951d14012dae82071a3b71d", + "name": "astropy", + "sha256": "d73e8f26998066eb5fae8fb03b97ee12557ce0b84f4db7d98d3b56633ae1341f", + "size": 5732655, + "subdir": "linux-64", + "timestamp": 1539981566326, + "version": "2.0.9" + }, + "astropy-2.0.9-py37hdd07704_1.conda": { + "build": "py37hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest <3.7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "83e00154325eec88655591888a29b146", + "name": "astropy", + "sha256": "44025b431ea97bb0a0df66b433459ec3337dd4b3fd453596e8b71da8dbb564ae", + "size": 5769318, + "subdir": "linux-64", + "timestamp": 1543593660663, + "version": "2.0.9" + }, + "astropy-3.0-py35h3010b51_1.conda": { + "build": "py35h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.10.4,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "6554dcd1506235f24047882e18f9c2b2", + "name": "astropy", + "sha256": "89d706e8e1d690cbc2977f35238bf18ba8f1878f1ef0569b91a2685debd05bbd", + "size": 5734396, + "subdir": "linux-64", + "timestamp": 1518800618490, + "version": "3.0" + }, + "astropy-3.0-py36h3010b51_1.conda": { + "build": "py36h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "423bf95bdc0ed9cfe861a3c67a1262a6", + "name": "astropy", + "sha256": "75d493c7643a694528eaf00f9742e1460aae2a6a9c9c62f65199990cc108b261", + "size": 5703913, + "subdir": "linux-64", + "timestamp": 1518800773617, + "version": "3.0" + }, + "astropy-3.0.1-py35h3010b51_1.conda": { + "build": "py35h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.10.4,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "5015d44d4f93cd4bfb31b7b49086f6b4", + "name": "astropy", + "sha256": "a5612e070324491ae485e1505db236152ab569e023b2419f523b3e899042eb0c", + "size": 5706648, + "subdir": "linux-64", + "timestamp": 1520967809862, + "version": "3.0.1" + }, + "astropy-3.0.1-py36h3010b51_1.conda": { + "build": "py36h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "7ad8c8488cd80a6a7a251d23f79d3c05", + "name": "astropy", + "sha256": "861bf39bcc81ae659e160e6d48f21aa9a833ec0d40e9cefcd046c284651bb773", + "size": 5715921, + "subdir": "linux-64", + "timestamp": 1520967837867, + "version": "3.0.1" + }, + "astropy-3.0.2-py35h3010b51_1.conda": { + "build": "py35h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.10.4,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "ebb6946cb0a9bd25b3c5644eb9d99782", + "name": "astropy", + "sha256": "9ced42b1187c76818b3bd7825a44c4780af308cbd812dc892e67e1a693950051", + "size": 5725278, + "subdir": "linux-64", + "timestamp": 1524573805927, + "version": "3.0.2" + }, + "astropy-3.0.2-py36h3010b51_1.conda": { + "build": "py36h3010b51_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "b5033d9179c881967ea450a3e227d6a9", + "name": "astropy", + "sha256": "ccbf88207cd12a25b599eb3599ee83729b34734406d354ec614ac68683fb7fe1", + "size": 5733737, + "subdir": "linux-64", + "timestamp": 1524573917775, + "version": "3.0.2" + }, + "astropy-3.0.3-py35h14c3975_2.conda": { + "build": "py35h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.10.4,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "f4a2681796fa5a4250eb40aed7be6242", + "name": "astropy", + "sha256": "bc4e9901144aa5465707c69756cf64f0ff15964af2555159630f7ed9579993ee", + "size": 5726689, + "subdir": "linux-64", + "timestamp": 1528029980737, + "version": "3.0.3" + }, + "astropy-3.0.3-py36h14c3975_2.conda": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "11191d9d9161b4a915ac38c0dc927266", + "name": "astropy", + "sha256": "d48007e6ce29e030250b46bdb48d54f2514f910fb33455d007addd912f79bf71", + "size": 5739030, + "subdir": "linux-64", + "timestamp": 1528030007674, + "version": "3.0.3" + }, + "astropy-3.0.3-py37h14c3975_2.conda": { + "build": "py37h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "fa75c3dbee762d4d1add6075028a0c62", + "name": "astropy", + "sha256": "3c30db0c775ea739d39808a2952a0ee61304d4dd1cf00a6d3386c7826f65be2b", + "size": 5688426, + "subdir": "linux-64", + "timestamp": 1530738380024, + "version": "3.0.3" + }, + "astropy-3.0.4-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.10.4,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "5ba6a9942c91466fadca14115f4418e2", + "name": "astropy", + "sha256": "63a61239cda039efc51e377bca55e9349c4cb8b24bb4d058740ecc477c3345ec", + "size": 5765315, + "subdir": "linux-64", + "timestamp": 1533315809595, + "version": "3.0.4" + }, + "astropy-3.0.4-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "dc77af1d8a31cd76cb0088e27e622d9a", + "name": "astropy", + "sha256": "71f667df45dd53fa644e44e78ce898bb805b0b467b0d78451b17432966dc0f6f", + "size": 5739288, + "subdir": "linux-64", + "timestamp": 1533315871495, + "version": "3.0.4" + }, + "astropy-3.0.4-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "b761072f9da744c4d1cd36ba5d3c681b", + "name": "astropy", + "sha256": "832fa6e08d5059ffb9173fd27fb909892ef992291f88ca04fd316fdf3e64d006", + "size": 5727127, + "subdir": "linux-64", + "timestamp": 1533315927165, + "version": "3.0.4" + }, + "astropy-3.0.5-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "d9c6d4ba8160a0188537ea3b0dc747e4", + "name": "astropy", + "sha256": "acd5192887b2f2db9e42fc55dbb947b6ae8d1aea0cd73231365428e53617022d", + "size": 5735860, + "subdir": "linux-64", + "timestamp": 1539975858072, + "version": "3.0.5" + }, + "astropy-3.0.5-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest <4", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "ea23d1b0ab4bee352e8b87d4989f38b0", + "name": "astropy", + "sha256": "acce27d50dc991699b67251df8e75d20fac60a11ebd960ece2e9964bc6c65f2a", + "size": 5739787, + "subdir": "linux-64", + "timestamp": 1543592253704, + "version": "3.0.5" + }, + "astropy-3.0.5-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "b801512e331829ff857e270aa6b29a51", + "name": "astropy", + "sha256": "e235e201c06253841fd480547bfd974da11bf1460f893fec5826492bb3922f02", + "size": 5753418, + "subdir": "linux-64", + "timestamp": 1539975845778, + "version": "3.0.5" + }, + "astropy-3.0.5-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pytest <4", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "9c298b919d912c4b2354246caa603021", + "name": "astropy", + "sha256": "a3c4a7c994bb1f26e16f1b8296910b105cf37ab2ba339d662f8ec4b995ac8014", + "size": 5757386, + "subdir": "linux-64", + "timestamp": 1543592316340, + "version": "3.0.5" + }, + "astropy-3.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "917187557a5a4e11d6c6b443265fcff1", + "name": "astropy", + "sha256": "afa091d47a72c36c3cf7842a346bad5d925d52e011c8bc1b0384ff58c7d6c243", + "size": 5959376, + "subdir": "linux-64", + "timestamp": 1544162225493, + "version": "3.1" + }, + "astropy-3.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "96742c62b9b9346f24e095cfdbd51ee2", + "name": "astropy", + "sha256": "58fe9dad9fc42bfc1d7679cb7c59b3ba50ef3de5988758bfc8a055e664f7d126", + "size": 5982066, + "subdir": "linux-64", + "timestamp": 1544162152961, + "version": "3.1" + }, + "astropy-3.1.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "c7a8ea556506c2a8c696d468d0c9a644", + "name": "astropy", + "sha256": "b9a9e0b588abb6cf04334d23a3defdd30cdd8438570e0ba7bcd18b85f1e45fc3", + "size": 5961330, + "subdir": "linux-64", + "timestamp": 1546568781483, + "version": "3.1.1" + }, + "astropy-3.1.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "188cd7ed373813bdf4b6c31aef4a392f", + "name": "astropy", + "sha256": "8dadc8dc36da90dfa7d2b94e694c0a1c2f2e232b97e332c2b6292281733c5292", + "size": 5984329, + "subdir": "linux-64", + "timestamp": 1546568767483, + "version": "3.1.1" + }, + "astropy-3.1.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "1e82580a00925ed3d6a0e3958469cf8c", + "name": "astropy", + "sha256": "d6d34f50549317141350a6b3c9961a19b9839b2c59acf271311e576b55e33695", + "size": 5954734, + "subdir": "linux-64", + "timestamp": 1551194671945, + "version": "3.1.2" + }, + "astropy-3.1.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "e84bd39840793124cd3460963fe291b3", + "name": "astropy", + "sha256": "656072ca448c30351c9079906db3d7d6764ec832513f58bc8b1f19799558eada", + "size": 5939155, + "subdir": "linux-64", + "timestamp": 1551194643643, + "version": "3.1.2" + }, + "astropy-3.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "ac7ed0e32ffcddc9dff69fc34de9c38c", + "name": "astropy", + "sha256": "38aab869f2c8253e3457ea3876165581fd0af9188944742244cae575c630b4d6", + "size": 6122285, + "subdir": "linux-64", + "timestamp": 1560313999867, + "version": "3.2" + }, + "astropy-3.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "baff71cdd79b8fee7baa488c909894a9", + "name": "astropy", + "sha256": "8fb34fdd304ea02a7c4134afab25b96e98355264679740009f25e2ff7c2ea8b1", + "size": 6060065, + "subdir": "linux-64", + "timestamp": 1560313960853, + "version": "3.2" + }, + "astropy-3.2.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "a2594a476477ab5787ed539c2bce3530", + "name": "astropy", + "sha256": "429a7d52bda7e58ef62a739e843c83dcbbd140f33a4d0265df4d19ae796c4ab2", + "size": 6121136, + "subdir": "linux-64", + "timestamp": 1560691419058, + "version": "3.2.1" + }, + "astropy-3.2.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "dde2c7a72545f7047a7459b53d190247", + "name": "astropy", + "sha256": "4daf4645d81c3c756ac5ae31a4cb0fe4c8c1e623e74f72bb8345feb4be62e4d9", + "size": 6098356, + "subdir": "linux-64", + "timestamp": 1560691418362, + "version": "3.2.1" + }, + "astropy-3.2.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "91f40fb478bad8bc20b5431b2e35ef3d", + "name": "astropy", + "sha256": "4c6d537e5ebf7d0ae90aa0e7eec4eb3f0ab16a7b40256a6738f417ce1a33148d", + "size": 6144772, + "subdir": "linux-64", + "timestamp": 1570543579627, + "version": "3.2.2" + }, + "astropy-3.2.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "9e4d1c00ba68108f7404a019172e03cc", + "name": "astropy", + "sha256": "e250b3a663d06239aa2c4de993226df0109afafc90b9c16f1239db3de6f7bddf", + "size": 6120933, + "subdir": "linux-64", + "timestamp": 1570543570246, + "version": "3.2.2" + }, + "astropy-3.2.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "41f6ea1204b6eccac154329e91334e23", + "name": "astropy", + "sha256": "1984a53ce8863dc30c9d38c4aff80cffa39cb5d0c0c9b53457107a323041d71d", + "size": 6142944, + "subdir": "linux-64", + "timestamp": 1572895768097, + "version": "3.2.3" + }, + "astropy-3.2.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "a41b40c23a8d31a2201b241081202c58", + "name": "astropy", + "sha256": "85e783c9cd2f1a8da978b80a082538a1bfa8004a9add41a05796e77e6953b583", + "size": 6121539, + "subdir": "linux-64", + "timestamp": 1572895738356, + "version": "3.2.3" + }, + "astropy-4.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.5,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "93771b04120e5817623f6810a0f7fbfb", + "name": "astropy", + "sha256": "dda6c0102aae30475c6405c4f6444db8a8dd95712308ee7050a556b8e120f228", + "size": 6386353, + "subdir": "linux-64", + "timestamp": 1578326007187, + "version": "4.0" + }, + "astropy-4.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.5,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "ef0f6e685d8427186014e4064d36862e", + "name": "astropy", + "sha256": "eda49b09b799e8f42a3ecfef820b7ad5a113aa0fb1cb2a133ee012f3fd4d3f45", + "size": 6341969, + "subdir": "linux-64", + "timestamp": 1578325888236, + "version": "4.0" + }, + "astropy-4.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.4,<2.0a0", + "pytest-astropy", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "md5": "da86d5269cbc9d83990ddfa551317434", + "name": "astropy", + "sha256": "b1a8ab30ffa71fe61a572f910118ca243d4ced6752d2bbacea51b7f610a53449", + "size": 6402971, + "subdir": "linux-64", + "timestamp": 1580249770818, + "version": "4.0" + }, + "astropy-4.0.1.post1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pytest-astropy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "5681c71b7e00f35fa351ca17db6899b7", + "name": "astropy", + "sha256": "3d3675c18872e849bcb348dc9e0c7cc0d440f5b5d89d7b0dcbfc3369bf8419ad", + "size": 6409898, + "subdir": "linux-64", + "timestamp": 1585926100570, + "version": "4.0.1.post1" + }, + "astropy-4.0.1.post1-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f30ebfad023f0c6c79d23a48c0cdcf19", + "name": "astropy", + "sha256": "7d471f9595487309260b17955055ba879d951e65756f03b8e2fb1219509bacbf", + "size": 6376108, + "subdir": "linux-64", + "timestamp": 1589296846209, + "version": "4.0.1.post1" + }, + "astropy-4.0.1.post1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pytest-astropy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "3956842fe1531fdd778d8a5e829e76f2", + "name": "astropy", + "sha256": "7fcf00449c831de4d929be0e9554ce0a8e31294ae912a3f38f0f6cf4ba4da8f2", + "size": 6384720, + "subdir": "linux-64", + "timestamp": 1585926127322, + "version": "4.0.1.post1" + }, + "astropy-4.0.1.post1-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "4b509513bd250b129eb594cb446eb358", + "name": "astropy", + "sha256": "f8ba6bd4e26ed2f540d9493e387cf50f5a5ffbcf8fb0f8230b001c76d0d8be2d", + "size": 6390533, + "subdir": "linux-64", + "timestamp": 1589296659522, + "version": "4.0.1.post1" + }, + "astropy-4.0.1.post1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pytest-astropy", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "06c0518c3062dab5ad9d6d68691446a9", + "name": "astropy", + "sha256": "f15dcfa6292515a85dd5c9ea4096a46ab91f27de64d620d1a6e6808ad8e9718a", + "size": 6422926, + "subdir": "linux-64", + "timestamp": 1585926111124, + "version": "4.0.1.post1" + }, + "astropy-4.0.1.post1-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "54a789661a71ce47f03a5c11007f763f", + "name": "astropy", + "sha256": "c473a8e957f2d1c1e6c83c8a8eb2311677d90bb265b4486fac0998c749a7fd56", + "size": 6392380, + "subdir": "linux-64", + "timestamp": 1589296846934, + "version": "4.0.1.post1" + }, + "astropy-4.0.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "md5": "1b49da26b860d48c96d3be01266b9ad8", + "name": "astropy", + "sha256": "0416b857c485266f753b0e5180b11079e934c76143b4b641c1e7fe156d415b0b", + "size": 6425668, + "subdir": "linux-64", + "timestamp": 1602602038096, + "version": "4.0.2" + }, + "astropy-4.0.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "md5": "6a3d4e750db60a585ecc4ec084b2cc37", + "name": "astropy", + "sha256": "01ae02669bfec079455f633a65b4924ba8c86497e607c88cdbdb1d5f9a73348f", + "size": 6422206, + "subdir": "linux-64", + "timestamp": 1602602044236, + "version": "4.0.2" + }, + "astropy-4.0.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "md5": "4cd220b24d992c75b9b419b6ab385a7a", + "name": "astropy", + "sha256": "cafaa5cd25624798fedf35e1561d01ee30386f620bea055a919070862fbe173a", + "size": 6459064, + "subdir": "linux-64", + "timestamp": 1602602035881, + "version": "4.0.2" + }, + "astropy-4.2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "pyerfa", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "6ba74b5d1f918d0b4edb511c825673e2", + "name": "astropy", + "sha256": "31eaba74d509fa60be41a57e613817df3638ecef6f2f604154b18e282568533c", + "size": 6385276, + "subdir": "linux-64", + "timestamp": 1606923092313, + "version": "4.2" + }, + "astropy-4.2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "pyerfa", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e37b47920b02a86bb1fa498da9f21d2c", + "name": "astropy", + "sha256": "977258526b0a7a2fc861f8c82da6d38872deba291c52ef758bb894e02e4daeb5", + "size": 6378825, + "subdir": "linux-64", + "timestamp": 1606923117320, + "version": "4.2" + }, + "astropy-4.2-py39h6323ea4_1.conda": { + "build": "py39h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "pyerfa", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "95c23eae0361143404e54498e2a880cd", + "name": "astropy", + "sha256": "2cf84316d4be023826ff214f27499ae4a3580c6bdf8c38c072436e0d58baef82", + "size": 6440597, + "subdir": "linux-64", + "timestamp": 1607713368513, + "version": "4.2" + }, + "astropy-4.2.1-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "matplotlib >=3.0", + "numpy >=1.17", + "pyerfa", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.13", + "scipy >=1.1" + ], + "license": "BSD-3-Clause", + "md5": "2b5a0058a20aeff3a29aa9c8691bb696", + "name": "astropy", + "sha256": "b497bd4eae1e5e259c279c6aceaaa8eeda40def0cc048e59838f6f6f66dabab0", + "size": 6410898, + "subdir": "linux-64", + "timestamp": 1617745702214, + "version": "4.2.1" + }, + "astropy-4.2.1-py37h6323ea4_1.conda": { + "build": "py37h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pyerfa", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "79d77de8d76fc06cf7952331d4f4eddc", + "name": "astropy", + "sha256": "5b5150d61109a81a8c362cf8f491c3987d0b75f860218656cbdefcffaaa25370", + "size": 6370051, + "subdir": "linux-64", + "timestamp": 1617383634746, + "version": "4.2.1" + }, + "astropy-4.2.1-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "matplotlib >=3.0", + "numpy >=1.17", + "pyerfa", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.13", + "scipy >=1.1" + ], + "license": "BSD-3-Clause", + "md5": "15de928db540382edbdd1b60fdff1f0f", + "name": "astropy", + "sha256": "1bbc3b00965755d1aae19c3106863259f1b1ca2c021ebd54ac4afae779dbd9ca", + "size": 6434493, + "subdir": "linux-64", + "timestamp": 1617745571803, + "version": "4.2.1" + }, + "astropy-4.2.1-py38h6323ea4_1.conda": { + "build": "py38h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pyerfa", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e7158c53478afaf7d7388ba9cef071f5", + "name": "astropy", + "sha256": "953ffc3373af3414a9bb5306c3da07a59b95e29bd080e10f92e2b7a875b39756", + "size": 6446230, + "subdir": "linux-64", + "timestamp": 1617381053189, + "version": "4.2.1" + }, + "astropy-4.2.1-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "matplotlib >=3.0", + "numpy >=1.17", + "pyerfa", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.13", + "scipy >=1.1" + ], + "license": "BSD-3-Clause", + "md5": "924da6897bafb193b30180d0184bde44", + "name": "astropy", + "sha256": "63a83e042b35dd0d6c2f060d7387f4073e7f3c3c4db9a3ce39e9448af31a58a7", + "size": 6470753, + "subdir": "linux-64", + "timestamp": 1617745729372, + "version": "4.2.1" + }, + "astropy-4.2.1-py39h6323ea4_1.conda": { + "build": "py39h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pyerfa", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "17131121bdaa48470c7dd721d995010c", + "name": "astropy", + "sha256": "aa2b2f4853018b737af5e27cd59b785b53ac0ac39e87511385a327afdfeac6f3", + "size": 6461192, + "subdir": "linux-64", + "timestamp": 1617383282845, + "version": "4.2.1" + }, + "astropy-4.3.1-py37h09021b7_0.conda": { + "build": "py37h09021b7_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "matplotlib >=3.0,!=3.4.0", + "numpy >=1.19.2,<2.0a0", + "pyerfa >=1.7.3", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.13", + "scipy >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6cc09f8644713993e3680d83a95cfe7b", + "name": "astropy", + "sha256": "68e9de80027a198e8e9f930c550cf64dd91eaa1afa464ca55ee5748148161ceb", + "size": 6607537, + "subdir": "linux-64", + "timestamp": 1629829452312, + "version": "4.3.1" + }, + "astropy-4.3.1-py38h09021b7_0.conda": { + "build": "py38h09021b7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "matplotlib >=3.0,!=3.4.0", + "numpy >=1.19.2,<2.0a0", + "pyerfa >=1.7.3", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.13", + "scipy >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "837117cb8c93409247eaa2290311bdd5", + "name": "astropy", + "sha256": "9588fc14e4b794375bd11c8fe52ea5d915a6db986a20d7b7f2ad693f30b4c6b1", + "size": 6707393, + "subdir": "linux-64", + "timestamp": 1629829421338, + "version": "4.3.1" + }, + "astropy-4.3.1-py39h09021b7_0.conda": { + "build": "py39h09021b7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "matplotlib >=3.0,!=3.4.0", + "numpy >=1.19.2,<2.0a0", + "pyerfa >=1.7.3", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.13", + "scipy >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3c8d01d57d6ca79d6f72623c881f5ef0", + "name": "astropy", + "sha256": "0857ee976f94d353ce1ecb986e09a1279dbec207f27dfccc4e5a1dd0f86690c6", + "size": 6693655, + "subdir": "linux-64", + "timestamp": 1629820543127, + "version": "4.3.1" + }, + "astropy-4.3.post1-py37h7f8727e_1.conda": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "matplotlib >=3.0", + "numpy >=1.17", + "pyerfa", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.13", + "scipy >=1.1" + ], + "license": "BSD-3-Clause", + "md5": "b8f1de1df54d794b42bdd3fde079f2da", + "name": "astropy", + "sha256": "7d913a3cf4ef117ecb699b1b30305cce534369a97833c76537ee2843940b3828", + "size": 6598646, + "subdir": "linux-64", + "timestamp": 1628150410194, + "version": "4.3.post1" + }, + "astropy-4.3.post1-py37hce1f21e_1.conda": { + "build": "py37hce1f21e_1", + "build_number": 1, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "matplotlib >=3.0,!=3.4.0", + "numpy >=1.16.6,<2.0a0", + "pyerfa >=2.0", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.13", + "scipy >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e2dddddb1a5ae525bcef879bd666da55", + "name": "astropy", + "sha256": "be5852e8228cc0e54711d1f199ba27b252379a28646f1887ef3846bd4e3612d9", + "size": 6641047, + "subdir": "linux-64", + "timestamp": 1628529188292, + "version": "4.3.post1" + }, + "astropy-4.3.post1-py38h7f8727e_1.conda": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "matplotlib >=3.0", + "numpy >=1.17", + "pyerfa", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.13", + "scipy >=1.1" + ], + "license": "BSD-3-Clause", + "md5": "4e73865f96525d0461538ca7c3882172", + "name": "astropy", + "sha256": "f40e4140e79acea7dcf795a1b41423ae01a33d1be107cc2bb52f571faa29f7e3", + "size": 6641986, + "subdir": "linux-64", + "timestamp": 1628150406859, + "version": "4.3.post1" + }, + "astropy-4.3.post1-py38hce1f21e_1.conda": { + "build": "py38hce1f21e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "matplotlib >=3.0,!=3.4.0", + "numpy >=1.16.6,<2.0a0", + "pyerfa >=2.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.13", + "scipy >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "da3be06c14349f40c46786ac9a144833", + "name": "astropy", + "sha256": "1d35b5fd49a5469f01aba32757c220196eb8535523f1a5c40a2e00dee148db28", + "size": 6687861, + "subdir": "linux-64", + "timestamp": 1628520977249, + "version": "4.3.post1" + }, + "astropy-4.3.post1-py39h7f8727e_1.conda": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "matplotlib >=3.0", + "numpy >=1.17", + "pyerfa", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.13", + "scipy >=1.1" + ], + "license": "BSD-3-Clause", + "md5": "cf51659f8f8ca3ab39f7aecec81f3776", + "name": "astropy", + "sha256": "44363910324d13dabd70ade5696847cfc4e54bcc947aa28f39dc4f1a88433092", + "size": 6692354, + "subdir": "linux-64", + "timestamp": 1628150314696, + "version": "4.3.post1" + }, + "astropy-4.3.post1-py39hce1f21e_1.conda": { + "build": "py39hce1f21e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "matplotlib >=3.0,!=3.4.0", + "numpy >=1.16.6,<2.0a0", + "pyerfa >=2.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.13", + "scipy >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cfa88ea07e93a8bf4906da4831966467", + "name": "astropy", + "sha256": "25abfd37f3a178fa0ba9ceb1ce8236dff27128a3f8f89962ff8f5ae7c714d105", + "size": 6681141, + "subdir": "linux-64", + "timestamp": 1628529190152, + "version": "4.3.post1" + }, + "astropy-5.0-py310h9102076_0.conda": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a3e9df179bd8ac3b8553c6d9334de60", + "name": "astropy", + "sha256": "93c752f0937aaa24b5befddafb98aab8d8f276ebc3a86d5a8d698d8ea868fab6", + "size": 9510071, + "subdir": "linux-64", + "timestamp": 1640808397416, + "version": "5.0" + }, + "astropy-5.0-py38h09021b7_0.conda": { + "build": "py38h09021b7_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eefee4c4715d894b034340c3bf974120", + "name": "astropy", + "sha256": "aa8bd6b7d744e09d901491460bd52c7bc47318613e4221b524c594f49eb4af48", + "size": 6930667, + "subdir": "linux-64", + "timestamp": 1638772250226, + "version": "5.0" + }, + "astropy-5.0-py39h09021b7_0.conda": { + "build": "py39h09021b7_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9b22539342ae7bf08979698cc7227cd5", + "name": "astropy", + "sha256": "9472fc8c8f2989c4128ae4c837eee42d35da5faacb5ed08c6cf4df0659279c93", + "size": 6931523, + "subdir": "linux-64", + "timestamp": 1638767546928, + "version": "5.0" + }, + "astropy-5.0.2-py310h9102076_0.conda": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d88c9a53cc569cb833b4bb833913e462", + "name": "astropy", + "sha256": "0a9ea3adf0c7b4ea9c2eb6afffe96eb313938df96eed3761a7160f291727ed9a", + "size": 9567079, + "subdir": "linux-64", + "timestamp": 1647852356310, + "version": "5.0.2" + }, + "astropy-5.0.2-py38hce1f21e_0.conda": { + "build": "py38hce1f21e_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "42c4ad6c534433bc1a86ad0737766c2e", + "name": "astropy", + "sha256": "ba815600897ea6e52c71eec3fac0588bbafc757025b6b578102b4185f67baad2", + "size": 7008015, + "subdir": "linux-64", + "timestamp": 1647834199484, + "version": "5.0.2" + }, + "astropy-5.0.2-py39hce1f21e_0.conda": { + "build": "py39hce1f21e_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b3864ea5b4f9b93ba9f021f5c6a453e4", + "name": "astropy", + "sha256": "603bec7ca4df217b5f21ec91a9992e1e3a11283588f84292874fbdde881721c1", + "size": 7004979, + "subdir": "linux-64", + "timestamp": 1647834465719, + "version": "5.0.2" + }, + "astropy-5.0.3-py310h9102076_0.conda": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4a4212c221b352b15d6a4cb2cb4bb256", + "name": "astropy", + "sha256": "7093661dcaf4cdb5df049f2c404f5261bf08e5d8572ef32f2400bf58c31ab295", + "size": 9581705, + "subdir": "linux-64", + "timestamp": 1648712702806, + "version": "5.0.3" + }, + "astropy-5.0.3-py38hce1f21e_0.conda": { + "build": "py38hce1f21e_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8ff78f34d1faf6a6a5f79ddd053be91f", + "name": "astropy", + "sha256": "584f036abd8f207fa8c9fbaa8af93d259a74e1b501c4fcab33b9be42bdd14350", + "size": 6954514, + "subdir": "linux-64", + "timestamp": 1648694562304, + "version": "5.0.3" + }, + "astropy-5.0.3-py39hce1f21e_0.conda": { + "build": "py39hce1f21e_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85cc973ea0f65220a2a6880df9b0ec44", + "name": "astropy", + "sha256": "fa9c850554c29a2ba2a115b7b8e57aa9c82447598c77c7933cd8d55dd7680631", + "size": 7009542, + "subdir": "linux-64", + "timestamp": 1648712685357, + "version": "5.0.3" + }, + "astropy-5.0.4-py310h9102076_0.conda": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9f358d68adb9bedb91c7e5f0c2318692", + "name": "astropy", + "sha256": "4a135b2183ed76df0b927a1b656ada7f93b47ff0d2d5a49f9d9aa51581cbcb29", + "size": 9518986, + "subdir": "linux-64", + "timestamp": 1650891651455, + "version": "5.0.4" + }, + "astropy-5.0.4-py311hbed6279_0.conda": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.11,<3.12.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa5062efaf65336db1a0aa71d47b0a18", + "name": "astropy", + "sha256": "d72ad76010bb010c7e44361f87e493c7dea8a0afe37f757b208dba489c933506", + "size": 8971588, + "subdir": "linux-64", + "timestamp": 1676839082776, + "version": "5.0.4" + }, + "astropy-5.0.4-py38hce1f21e_0.conda": { + "build": "py38hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cabc3cc3181a5dd6564455a211469fb4", + "name": "astropy", + "sha256": "207a70e90f0caef2e6b63aabd87723d3217a3fb6c7f05b5fbdec23158c55b591", + "size": 6953207, + "subdir": "linux-64", + "timestamp": 1650891439641, + "version": "5.0.4" + }, + "astropy-5.0.4-py39hce1f21e_0.conda": { + "build": "py39hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "be3c743f89bf229a50c07e2989a212c4", + "name": "astropy", + "sha256": "3bef74ae34d63fd5368ea1357b377d04567f51bbae252589c2f0d0f749c3b755", + "size": 6956723, + "subdir": "linux-64", + "timestamp": 1650891246872, + "version": "5.0.4" + }, + "astropy-5.1-py310ha9d4c09_0.conda": { + "build": "py310ha9d4c09_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b309d014972dc4d4634340c43bddf547", + "name": "astropy", + "sha256": "cc86639b1f20a9312f731a85d9e144dd869087d50ea00777aacf5177aaa23df7", + "size": 10050164, + "subdir": "linux-64", + "timestamp": 1657786479850, + "version": "5.1" + }, + "astropy-5.1-py311hbed6279_0.conda": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.11,<3.12.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b9e0bcdfecb6e1afa723d222828f286c", + "name": "astropy", + "sha256": "fd810f4d40f1d6e93b401f595b31046d99c074690100c44dd4d587dc2a580a72", + "size": 9088761, + "subdir": "linux-64", + "timestamp": 1679335324791, + "version": "5.1" + }, + "astropy-5.1-py38h7deecbd_0.conda": { + "build": "py38h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f0670d00bf3ea568d5f32626c5aca35a", + "name": "astropy", + "sha256": "d5faf0fbb3670785d52c6b4b4ece5749ad7e6540d71f3451ec59eab3c6b71c57", + "size": 7052156, + "subdir": "linux-64", + "timestamp": 1657786681078, + "version": "5.1" + }, + "astropy-5.1-py39h7deecbd_0.conda": { + "build": "py39h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=19.0", + "pyerfa >=2.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.13" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6fb55032cf21b0f35e409764aae81f1a", + "name": "astropy", + "sha256": "d95f5a01d26d9fa01cfaa0abb33ff516b8111d4b5eb4335a3154fedd0efcb3db", + "size": 7050465, + "subdir": "linux-64", + "timestamp": 1657786253878, + "version": "5.1" + }, + "async-timeout-2.0.0-py35h12a94dc_0.conda": { + "build": "py35h12a94dc_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "711f77cc57866e78a6431ce5df2c85ef", + "name": "async-timeout", + "sha256": "4f56e928546b4b3cf348f369916b4977cf33dda41d3715068e1fb0d35d16b0a9", + "size": 11867, + "subdir": "linux-64", + "timestamp": 1508005818622, + "version": "2.0.0" + }, + "async-timeout-2.0.0-py36h92a791d_0.conda": { + "build": "py36h92a791d_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5b063675b6a9f5b4cdedaa032901109f", + "name": "async-timeout", + "sha256": "66b068d36ee916f8510717a3a1930209310627dbd7209fd0c9a552c55c420122", + "size": 11786, + "subdir": "linux-64", + "timestamp": 1508005827209, + "version": "2.0.0" + }, + "async-timeout-2.0.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ce0f8644a621ac5ed4c84a60b19c2894", + "name": "async-timeout", + "sha256": "9ecd9ca3d760187940f8d340b611db9a6909c22586ab664ee3ef5bffdd8c972a", + "size": 11997, + "subdir": "linux-64", + "timestamp": 1521603990265, + "version": "2.0.1" + }, + "async-timeout-2.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "14a4996e6028ef488d684fa08c9885a2", + "name": "async-timeout", + "sha256": "16b0bb4a24a8b5aaabee10b349fe5c898454af1be2941f02e43931c9b9735552", + "size": 11922, + "subdir": "linux-64", + "timestamp": 1521604000907, + "version": "2.0.1" + }, + "async-timeout-3.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2eeaa3e04fb4c0472f306f1f7ec674e3", + "name": "async-timeout", + "sha256": "07f919b793dc9c763a024b0befae26204e039ebf00f53b9cb440dda9478f614b", + "size": 12296, + "subdir": "linux-64", + "timestamp": 1526920910271, + "version": "3.0.0" + }, + "async-timeout-3.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0feaae63238d3dbb1d7e1163f4309eff", + "name": "async-timeout", + "sha256": "cc93eb8c4c09ca24a83b5c5076968304440e808a01e9eda82550764e27c0086e", + "size": 12254, + "subdir": "linux-64", + "timestamp": 1526920884980, + "version": "3.0.0" + }, + "async-timeout-3.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2ee40df7664abd6def39bc851c76bf06", + "name": "async-timeout", + "sha256": "3df55f7fc52faa5800166b6a3b7e69c5bfc7ade78c49b764b22a1e3021d3ad74", + "size": 12265, + "subdir": "linux-64", + "timestamp": 1530736505104, + "version": "3.0.0" + }, + "async-timeout-3.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "946bf110946c24347d3de7f54c89255c", + "name": "async-timeout", + "sha256": "290d71085a7fc650643ce692719337132e9bcf9ae407db606165bff66347732b", + "size": 12644, + "subdir": "linux-64", + "timestamp": 1539466795616, + "version": "3.0.1" + }, + "async-timeout-3.0.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "803fb4468a65ffb5b7726f78b7b698aa", + "name": "async-timeout", + "sha256": "a5c2ef513159674c8039d49c3b3468b78c2c77ac18633e4432a5d46e3ff18b4f", + "size": 13684, + "subdir": "linux-64", + "timestamp": 1611675370971, + "version": "3.0.1" + }, + "async-timeout-3.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2a2d450d0e364d24e23c1ce451d271e5", + "name": "async-timeout", + "sha256": "21548c1889fb9cd52cfdac76698126afa1765b4b159c3272cd695aa15e784368", + "size": 12635, + "subdir": "linux-64", + "timestamp": 1539466794244, + "version": "3.0.1" + }, + "async-timeout-3.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bfbe8609ea4430460ce9da5181e9ed76", + "name": "async-timeout", + "sha256": "e0638d58ebe9203db86dacb99348a8d1c746011b680c5111764756012cc76727", + "size": 13723, + "subdir": "linux-64", + "timestamp": 1611675346486, + "version": "3.0.1" + }, + "async-timeout-3.0.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "294674820136b0385067b942a316c7f5", + "name": "async-timeout", + "sha256": "1b7df58547057b091917a4b3b067e04c5a20a22555fd85a051631b4e1800b424", + "size": 12749, + "subdir": "linux-64", + "timestamp": 1572437164699, + "version": "3.0.1" + }, + "async-timeout-3.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bdaccfd5319c9f296784e7309f97f87d", + "name": "async-timeout", + "sha256": "54f43dfec2f896456a4aa4366c5cf8c52a38e846b9d937093d57d9c705d8b56a", + "size": 13741, + "subdir": "linux-64", + "timestamp": 1611675371571, + "version": "3.0.1" + }, + "async-timeout-3.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "99eab834c0858e781d7b45749d752b84", + "name": "async-timeout", + "sha256": "c3d28103be081e1b44bc03e81c46a158cdb69f6563566462b4eafd6436f2462a", + "size": 13749, + "subdir": "linux-64", + "timestamp": 1611675303382, + "version": "3.0.1" + }, + "async-timeout-4.0.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "783c2037c95a51fb0816dcddec3f25ce", + "name": "async-timeout", + "sha256": "050e0e505fd1ce1af8ccea7fda485f7fde07200d46c3dd88b108a30add039352", + "size": 11859, + "subdir": "linux-64", + "timestamp": 1664876431563, + "version": "4.0.2" + }, + "async-timeout-4.0.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4295fc328c597e85bb895e7b5074e15c", + "name": "async-timeout", + "sha256": "f64d6b2fd33d00028ffab522f631d674fb2c327097e2b776d55f2830a5b8cd78", + "size": 13457, + "subdir": "linux-64", + "timestamp": 1676826974110, + "version": "4.0.2" + }, + "async-timeout-4.0.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a4dfe54b585cf5438510724f175f5d3e", + "name": "async-timeout", + "sha256": "94382bf6a88f673e5d8b708d9aa5bb09a3a1c6468a2ed3275caf00c778d07d42", + "size": 11713, + "subdir": "linux-64", + "timestamp": 1664876455852, + "version": "4.0.2" + }, + "async-timeout-4.0.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d08306937c185565f0e51ce3dbd4cf85", + "name": "async-timeout", + "sha256": "7a88e1b2cca0dfe0440292c76e981957958a645587d94b1ce3543d659e4c4298", + "size": 11766, + "subdir": "linux-64", + "timestamp": 1664876480012, + "version": "4.0.2" + }, + "async-timeout-4.0.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3cbd9e45b0f6322b3e0b4207252e42f3", + "name": "async-timeout", + "sha256": "317ed3f6c2b332d5fafa1dcaaee7804a4c84bb6182b2ad5ca4bb0729f1ccc85d", + "size": 11756, + "subdir": "linux-64", + "timestamp": 1664876394563, + "version": "4.0.2" + }, + "async_generator-1.10-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ce6122db4ea9a9d4e477688b670e7e1", + "name": "async_generator", + "sha256": "93e6e0006f7ea9ea21de1e8f3378b69f10febaf16d83137f838a4d83400c29a4", + "size": 40348, + "subdir": "linux-64", + "timestamp": 1540861518525, + "version": "1.10" + }, + "async_generator-1.10-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14f1f20225516d0847d60f49c8371e89", + "name": "async_generator", + "sha256": "0d155456bce0d3c2a6003f6e948931a0ed2d58268559236ded9dccbd9ed9b638", + "size": 40345, + "subdir": "linux-64", + "timestamp": 1540861479372, + "version": "1.10" + }, + "asyncpg-0.12.0-py35hb66dd5d_0.conda": { + "build": "py35hb66dd5d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a6d7ad3b214412849d5ca6df37718333", + "name": "asyncpg", + "sha256": "8257f1e23f28d2dafd33fe6c5c5f1fa2b181a2da7863fde7a1cb4e43180e6c05", + "size": 717240, + "subdir": "linux-64", + "timestamp": 1507238629916, + "version": "0.12.0" + }, + "asyncpg-0.12.0-py36hf34a55f_0.conda": { + "build": "py36hf34a55f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7f97b70d0f3c82e800aadf246e1afbeb", + "name": "asyncpg", + "sha256": "3d104c4c8b5c38f5569e656af2c8032fb368047a499f237115b689d53c42ecd8", + "size": 731498, + "subdir": "linux-64", + "timestamp": 1507238630141, + "version": "0.12.0" + }, + "asyncpg-0.13.0-py35ha95cecb_0.conda": { + "build": "py35ha95cecb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2532d397986d47d4b910550851be5811", + "name": "asyncpg", + "sha256": "79dca22c43cc9ad2e2d2231a12e30b07264c17b48dbb8d61894ee7115c902759", + "size": 737754, + "subdir": "linux-64", + "timestamp": 1511843181136, + "version": "0.13.0" + }, + "asyncpg-0.13.0-py36h98f7829_0.conda": { + "build": "py36h98f7829_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ce388063959d3d4445187a5143e1c441", + "name": "asyncpg", + "sha256": "e64039478ee4cadb87a792ef33a46798dfb82d9eca874e8ad412e9a7d68c98a9", + "size": 751838, + "subdir": "linux-64", + "timestamp": 1511843172973, + "version": "0.13.0" + }, + "asyncpg-0.14.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "75395b315b3e90fab3dc5ecf365cda47", + "name": "asyncpg", + "sha256": "2e60a102ca025f8e9fcaab03c5bdcd379ecaf4c7e32d85d3f8a3738c25f068fe", + "size": 760790, + "subdir": "linux-64", + "timestamp": 1519481562311, + "version": "0.14.0" + }, + "asyncpg-0.14.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c8e8d8bd83f404ea9e77d1b2e925f54a", + "name": "asyncpg", + "sha256": "02af7df9ef76b76c684ff4c12753746cbe3a7225f2b49870781faabce5e542ec", + "size": 771153, + "subdir": "linux-64", + "timestamp": 1519481547108, + "version": "0.14.0" + }, + "asyncpg-0.15.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a25cf319fc3966303c428995322e6b07", + "name": "asyncpg", + "sha256": "839866e5a82ac7e4f3d2e51c21e6bc43da4389e76e497a87e6f05003a06eacac", + "size": 761934, + "subdir": "linux-64", + "timestamp": 1519369500853, + "version": "0.15.0" + }, + "asyncpg-0.15.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8ab0b274a9dc9adbee551838db091744", + "name": "asyncpg", + "sha256": "81e0b22c61aeea7235dc46dbd4fb7bcc3ebd3528e033da375e6fb00c0b338fa5", + "size": 772658, + "subdir": "linux-64", + "timestamp": 1519369491808, + "version": "0.15.0" + }, + "asyncpg-0.16.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "570d47ee483db9470a903895d25fcb3a", + "name": "asyncpg", + "sha256": "9c3807f702ccf18a51f64b4def2498085f570c3bb1b8f9fab1755c8faebcf9cd", + "size": 781273, + "subdir": "linux-64", + "timestamp": 1529425277774, + "version": "0.16.0" + }, + "asyncpg-0.16.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d6b2f4ba03c499e2ae495165f7845061", + "name": "asyncpg", + "sha256": "65810ee9e86b925c4f90fa7b1053b33b8e68570af87d9d76767db52d4be64c5f", + "size": 793223, + "subdir": "linux-64", + "timestamp": 1529425236222, + "version": "0.16.0" + }, + "asyncpg-0.16.0-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "81cf58386f3b4205e609ddcd6be61c09", + "name": "asyncpg", + "sha256": "cc319adf8446d95feffeeda09b46aa1cf54aa62ff2301201e0b3c32c996fb757", + "size": 788555, + "subdir": "linux-64", + "timestamp": 1530738483174, + "version": "0.16.0" + }, + "asyncpg-0.17.0-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5e0e0c84c6301e7b50a25a710d8b916c", + "name": "asyncpg", + "sha256": "c9c5d2b57108ca3766bd84b88708da49980090567fab5459d08f33c0e899655f", + "size": 786487, + "subdir": "linux-64", + "timestamp": 1536170243361, + "version": "0.17.0" + }, + "asyncpg-0.17.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "46afbf98ef1ea7da0b7d352d3d5df036", + "name": "asyncpg", + "sha256": "4928fbdebaad837519190429eabf568682ec1ce6df85b12357c52fd30df41065", + "size": 798564, + "subdir": "linux-64", + "timestamp": 1536170563656, + "version": "0.17.0" + }, + "asyncpg-0.17.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3dca9a756743c3361de68401b20a8544", + "name": "asyncpg", + "sha256": "869475fb6d698f0c1b3f54c5de703e355417ccf1bc45ce8fec6c4e073853f935", + "size": 791976, + "subdir": "linux-64", + "timestamp": 1536170638790, + "version": "0.17.0" + }, + "asyncpg-0.17.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cdae5ec632b752908244800c76e9927a", + "name": "asyncpg", + "sha256": "a251bdcdae5b68c1c89c46150eff5636ab5bb35289ed692e8eb15282c7d05316", + "size": 830192, + "subdir": "linux-64", + "timestamp": 1572860800615, + "version": "0.17.0" + }, + "asyncpg-0.18.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ce1c1fa8c261e05f504ad180bc53e01d", + "name": "asyncpg", + "sha256": "2f9957af22d9dc6b981a8b69036ab607f177420faa1bb3e28c30faf0d9c5165e", + "size": 834101, + "subdir": "linux-64", + "timestamp": 1545163251544, + "version": "0.18.2" + }, + "asyncpg-0.18.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d6a487ab35739648a7acb3cf69c7b9b7", + "name": "asyncpg", + "sha256": "9e53e86e1f4224a818040c407b4d89a2b0e74512d296d5689c311d813f7fc607", + "size": 832673, + "subdir": "linux-64", + "timestamp": 1545163249940, + "version": "0.18.2" + }, + "asyncpg-0.18.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c9727f7c0809ebca5e2185a13f8d6a45", + "name": "asyncpg", + "sha256": "014adf83f2a04502a3a8a1bb60a020bfd35663f36c8bb5933347a0d69ffb3b23", + "size": 837195, + "subdir": "linux-64", + "timestamp": 1547222630876, + "version": "0.18.3" + }, + "asyncpg-0.18.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e78fea1c351e314658472312b7b40687", + "name": "asyncpg", + "sha256": "8bf111e773c1450504a760c84bc806a7f22b16322176393db713e1213e7c2a83", + "size": 833725, + "subdir": "linux-64", + "timestamp": 1547222630830, + "version": "0.18.3" + }, + "asyncpg-0.20.1-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a57a54bf56a73a9eaa149384b3482512", + "name": "asyncpg", + "sha256": "c6a73c44945f197b2d1a5df8bc1b706fb8a8fd57d5ccb48dbddca28ac4e310f7", + "size": 932694, + "subdir": "linux-64", + "timestamp": 1611675407880, + "version": "0.20.1" + }, + "asyncpg-0.20.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d9698585cabf31d63eb8d6d51a5995a2", + "name": "asyncpg", + "sha256": "59d1b0a94c3828f17386795428312d4849a779ce8672e91303527292b97cc3c0", + "size": 934793, + "subdir": "linux-64", + "timestamp": 1591917879783, + "version": "0.20.1" + }, + "asyncpg-0.20.1-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0c8cfae32859e2fcf0dfa713f1cd339f", + "name": "asyncpg", + "sha256": "efd6c773dfbbbbb1f98eefffd5b576a3cad27209dae20ad7c2188e2368403a81", + "size": 930482, + "subdir": "linux-64", + "timestamp": 1611674957635, + "version": "0.20.1" + }, + "asyncpg-0.20.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b7889b1803fb5b3f3bb63b4088d29c8b", + "name": "asyncpg", + "sha256": "fe0912f327d180fcceef6cf943edab4aa0fd3ec7dee44b1313b8aa8b2925e427", + "size": 928229, + "subdir": "linux-64", + "timestamp": 1591917872286, + "version": "0.20.1" + }, + "asyncpg-0.20.1-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7bc71b1d864534545c2c40c9c8908550", + "name": "asyncpg", + "sha256": "7ba639fe0d96da6e000deba7e181455b3d22e58dbcd6e8d476ea1e9cd20a758a", + "size": 970334, + "subdir": "linux-64", + "timestamp": 1611674957542, + "version": "0.20.1" + }, + "asyncpg-0.20.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "09ec40c071e415c6beb53aca487853fa", + "name": "asyncpg", + "sha256": "9e03aedcbba4769583dca37d2be8d9ace4bf3462520db186d879f64aca438af9", + "size": 968463, + "subdir": "linux-64", + "timestamp": 1591917825262, + "version": "0.20.1" + }, + "asyncpg-0.20.1-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4467caed35b31893273c90c8e6a8be69", + "name": "asyncpg", + "sha256": "fde03c1f712c47660273e2eafcf5a77eef739e33e3de78f651d86cb9ffeda545", + "size": 969253, + "subdir": "linux-64", + "timestamp": 1611675408848, + "version": "0.20.1" + }, + "asyncpg-0.21.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8ebfb8e816f217e6ae7f803c9ba7c0fa", + "name": "asyncpg", + "sha256": "d3dd65d8f42b6617d4edc71b2d3ef4f66efbb74f25e4ef6294d16477db27255e", + "size": 869027, + "subdir": "linux-64", + "timestamp": 1600298307703, + "version": "0.21.0" + }, + "asyncpg-0.21.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f8de11c6f6dfb99045f46be113acedc1", + "name": "asyncpg", + "sha256": "8ff94e8d233f5905f35d2e8953f00bb9f027340aa9605b7c4e0054c1c1e14608", + "size": 865549, + "subdir": "linux-64", + "timestamp": 1600298295531, + "version": "0.21.0" + }, + "asyncpg-0.21.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f255ccf940e52d304ff11a72ba182c8e", + "name": "asyncpg", + "sha256": "887dfe0b64439c845a00ef38d19a4a2e7fcdd38ca741e5c2985bf436044159ec", + "size": 903001, + "subdir": "linux-64", + "timestamp": 1600298287151, + "version": "0.21.0" + }, + "asyncpg-0.22.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "typing_extensions" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ef32cb796b9f2cbf4eeb3c89bb164631", + "name": "asyncpg", + "sha256": "c01e3f9dd55a60231a93df193b79a148b6ce9f0fa16fb526a4abf64e7fb22a4c", + "size": 901666, + "subdir": "linux-64", + "timestamp": 1613246955002, + "version": "0.22.0" + }, + "asyncpg-0.22.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a344da26e24deccb14f0a2a2023c3a54", + "name": "asyncpg", + "sha256": "73208ebe0775df7ca7757168fee3c75048d2a1aba49e11ba3303199c1f86fe06", + "size": 896992, + "subdir": "linux-64", + "timestamp": 1613247117003, + "version": "0.22.0" + }, + "asyncpg-0.22.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "typing_extensions" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5876bdfd933c15559e4fbf0d00d9ea69", + "name": "asyncpg", + "sha256": "6b8ff926347e22659549e0701aad629991e6adffe88db514f56aff2e726791f9", + "size": 930270, + "subdir": "linux-64", + "timestamp": 1613246606232, + "version": "0.22.0" + }, + "asyncpg-0.22.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "typing_extensions" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c95052237f0898648641c7271d97f233", + "name": "asyncpg", + "sha256": "1bbeb74de682ff5c4895ab5d5698f4dc29778ed82fee7da6b595ee0ad717ccbe", + "size": 933671, + "subdir": "linux-64", + "timestamp": 1613247111157, + "version": "0.22.0" + }, + "asyncpg-0.23.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f23c291aa764bf0d82d005db76aa21b8", + "name": "asyncpg", + "sha256": "4442959c28d28c01178b524499c6f48be3e93b100c05db70d50ca08656db2f39", + "size": 2183977, + "subdir": "linux-64", + "timestamp": 1640788362236, + "version": "0.23.0" + }, + "asyncpg-0.23.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "typing_extensions >=3.7.4.3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "310587fcbf65ba629d504e8a7802b7a4", + "name": "asyncpg", + "sha256": "8018bbf3cf8ff6a6a0eae5edace5c13677800665ff37412e62aac5864cfe3ecd", + "size": 901633, + "subdir": "linux-64", + "timestamp": 1621368531630, + "version": "0.23.0" + }, + "asyncpg-0.23.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.7.4.3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f3f7d0f08a96481b6dc00a91abcee6dc", + "name": "asyncpg", + "sha256": "f2f20164c9adbbf1d763503cfe1de526e00295be0873af46d44eda276e15b04a", + "size": 898028, + "subdir": "linux-64", + "timestamp": 1621368400272, + "version": "0.23.0" + }, + "asyncpg-0.23.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "78c561003a7fbf1aa8ae55b1533d1d99", + "name": "asyncpg", + "sha256": "46f104152d164396fa1394a783cc23a44b96fa766639a097fa4be0b3ccbf19a7", + "size": 936790, + "subdir": "linux-64", + "timestamp": 1621368529426, + "version": "0.23.0" + }, + "asyncpg-0.23.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "aedca3241d8282cb53ee52dfa6ccf3eb", + "name": "asyncpg", + "sha256": "0e21ce2b1318d626388f93be14a9c1c3b7fac99d0d2a6a6e37f8d42ed1803e78", + "size": 940169, + "subdir": "linux-64", + "timestamp": 1621368540525, + "version": "0.23.0" + }, + "asyncpg-0.27.0-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f07f61faf9efae2e4d1b6f825e10bd2f", + "name": "asyncpg", + "sha256": "d12799b2e786c356896108a584fa5827cd88bdb0ba239fc0a747e8f87d9558d5", + "size": 660223, + "subdir": "linux-64", + "timestamp": 1670955811455, + "version": "0.27.0" + }, + "asyncpg-0.27.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "54b050f68239375cc310bc1ec4b14b21", + "name": "asyncpg", + "sha256": "e3b35fddb493d1c7247e8d0eed0576114478ef5c373a254b2337588db955c643", + "size": 634248, + "subdir": "linux-64", + "timestamp": 1676843250770, + "version": "0.27.0" + }, + "asyncpg-0.27.0-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.7.4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9188d0be759f2a97d83774edd24986c8", + "name": "asyncpg", + "sha256": "d99a0a847ddc508fbe756598fb475255911ba413325a399c2deb27f79b4d23d1", + "size": 658866, + "subdir": "linux-64", + "timestamp": 1670955708432, + "version": "0.27.0" + }, + "asyncpg-0.27.0-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9e0d4c2ef23be77335a8c8e4ca7fda20", + "name": "asyncpg", + "sha256": "57b5cb0fe71858633e93372ae49e1dbcae88c7539de2d633a89e23baae7236da", + "size": 697022, + "subdir": "linux-64", + "timestamp": 1670955864884, + "version": "0.27.0" + }, + "asyncpg-0.27.0-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1cd79a936ceba8d4fef3d3bc22d23fbb", + "name": "asyncpg", + "sha256": "0baf246f76f4075617c40b03c81092292e8a4ad82cf591bfe9e9ce14e3af8504", + "size": 671729, + "subdir": "linux-64", + "timestamp": 1670955760033, + "version": "0.27.0" + }, + "asyncpgsa-0.17.0-py35h9bdfc20_0.conda": { + "build": "py35h9bdfc20_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.12.0,<0.13", + "python >=3.5,<3.6.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3f5c06e36a51f98b602111887673b742", + "name": "asyncpgsa", + "sha256": "fb666f6f6592774e4b0ed89083920f3216d262a440f120e96fb104a94eec822a", + "size": 23389, + "subdir": "linux-64", + "timestamp": 1507239572244, + "version": "0.17.0" + }, + "asyncpgsa-0.17.0-py36h31b4eaa_0.conda": { + "build": "py36h31b4eaa_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.12.0,<0.13", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7c72570a731b70915c326d70874c3857", + "name": "asyncpgsa", + "sha256": "81d562a41f07a6506db5cb34c82f128e2ae2781af09e54e7c89d83216b0a2444", + "size": 23297, + "subdir": "linux-64", + "timestamp": 1507239583505, + "version": "0.17.0" + }, + "asyncpgsa-0.18.1-py35h3cb9e5d_0.conda": { + "build": "py35h3cb9e5d_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.12.0,<0.13", + "python >=3.5,<3.6.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c9e00f2c69bf016f0a45325e06496c76", + "name": "asyncpgsa", + "sha256": "c1cb963749c5c6003a586bde10c99013ac30335f19be862dfa856c3e40a7b4c9", + "size": 22222, + "subdir": "linux-64", + "timestamp": 1511982078424, + "version": "0.18.1" + }, + "asyncpgsa-0.18.1-py36hb35d077_0.conda": { + "build": "py36hb35d077_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.12.0,<0.13", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2bc44f8f2e676558f8b993f3a6ca6ade", + "name": "asyncpgsa", + "sha256": "b24cd045b063357fa92e41f6c4baa300ba944df5ed5bc50d4e0dca52c8e597d2", + "size": 22165, + "subdir": "linux-64", + "timestamp": 1511982082920, + "version": "0.18.1" + }, + "asyncpgsa-0.19.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.14.0,<0.15", + "python >=3.5,<3.6.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e16cbba67cc20cf9ad8481e94de2cfec", + "name": "asyncpgsa", + "sha256": "dbcd8f600554a2e3d258829fcc0f4709b441f788d64d56736198fe3282dca425", + "size": 22649, + "subdir": "linux-64", + "timestamp": 1519481668306, + "version": "0.19.2" + }, + "asyncpgsa-0.19.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.14.0,<0.15", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1e67041d177690b2fb3f32ccc9e976bf", + "name": "asyncpgsa", + "sha256": "d4c09cc8e48e81b7e2b3cacdbe583d3b7ede922d5b6ad48790a432bcf7ad1ffd", + "size": 22457, + "subdir": "linux-64", + "timestamp": 1519481630707, + "version": "0.19.2" + }, + "asyncpgsa-0.22.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.15.0,<0.16", + "python >=3.5,<3.6.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9b3452b412fadd517eea918b6ed50a39", + "name": "asyncpgsa", + "sha256": "6063fe660579fbfda8fd0ef72470a142476980619865ed4cdac621824f1121b7", + "size": 22237, + "subdir": "linux-64", + "timestamp": 1523436488096, + "version": "0.22.0" + }, + "asyncpgsa-0.22.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.15.0,<0.16", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ec358fa7d6630340da10a3645e67c433", + "name": "asyncpgsa", + "sha256": "99223ef85fa16ae05572970d31376f315a573a11421be3a18d14494e340673d4", + "size": 22155, + "subdir": "linux-64", + "timestamp": 1523436478694, + "version": "0.22.0" + }, + "asyncpgsa-0.23.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.15.0,<0.16", + "python >=3.5,<3.6.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "24607bc094c18efd87e209bc01c77c9a", + "name": "asyncpgsa", + "sha256": "853093502b1fe29ccf65f00c003bf9cf9fd4b8bd92aeb13fe8136429f5c43866", + "size": 22151, + "subdir": "linux-64", + "timestamp": 1526929622961, + "version": "0.23.0" + }, + "asyncpgsa-0.23.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.15.0,<0.16", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6af5aca470d4bf915b7eb8307c09f824", + "name": "asyncpgsa", + "sha256": "ee1df248f9aa5fdef3054841f381195ec9c35512283e6cd442d3a5ab6f6632f7", + "size": 22106, + "subdir": "linux-64", + "timestamp": 1526929590994, + "version": "0.23.0" + }, + "asyncpgsa-0.23.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.15.0,<0.17", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fb7ff074e47e160ac81af7f7955d348a", + "name": "asyncpgsa", + "sha256": "43eb3596c2561b4d9be6eb1ae293fdfd3f6e8e66ce13d7d832601965787dc98c", + "size": 22102, + "subdir": "linux-64", + "timestamp": 1530738513732, + "version": "0.23.0" + }, + "asyncpgsa-0.24.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.16.0,<0.17", + "python >=3.5,<3.6.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "27baf2fb649f1cd6127b80a2a2d8477d", + "name": "asyncpgsa", + "sha256": "2bd0914948b58706a45b7038ddcbf61a15322454110b5947603da86159757339", + "size": 22282, + "subdir": "linux-64", + "timestamp": 1536111084566, + "version": "0.24.0" + }, + "asyncpgsa-0.24.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.16.0,<0.17", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c35d4fb053b1b6dd2e1a49e2079e9ec9", + "name": "asyncpgsa", + "sha256": "52676a251128bdbaa21cf420d70e4e792e757db00f19a1af9a1705565c54c5fe", + "size": 22257, + "subdir": "linux-64", + "timestamp": 1536111011299, + "version": "0.24.0" + }, + "asyncpgsa-0.24.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.16.0,<0.17", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a52fb71e0be461b4b8a615cf8a2a53fe", + "name": "asyncpgsa", + "sha256": "8a4d7560f8f8607179e052a382be15792c3b9cdb6c82ffe77170613acc325242", + "size": 22227, + "subdir": "linux-64", + "timestamp": 1536111081705, + "version": "0.24.0" + }, + "asyncpgsa-0.25.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.16.0,<0.17", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "941cbd53f16cad98cb289adf1da51b49", + "name": "asyncpgsa", + "sha256": "176961ca6c6646ead2fa08fdbe602229e8c54a59c6ad250f30e6c8d4abcc23b2", + "size": 22407, + "subdir": "linux-64", + "timestamp": 1540957360097, + "version": "0.25.2" + }, + "asyncpgsa-0.25.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "asyncpg >=0.16.0,<0.17", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a22c24908e06f43646462d3aca196882", + "name": "asyncpgsa", + "sha256": "0e4146729211dbfc8f8b7621071090a1afd14db2384f4de2b21d2c98dbfd19a9", + "size": 22433, + "subdir": "linux-64", + "timestamp": 1540957406995, + "version": "0.25.2" + }, + "asyncpgsa-0.26.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "874c46e6c5964d8354fbf8ba34c77b82", + "name": "asyncpgsa", + "sha256": "91dc0d92dc54e5f682aa2a19f428b5730e281d785300bef72612100e73fc6491", + "size": 25415, + "subdir": "linux-64", + "timestamp": 1552357522635, + "version": "0.26.0" + }, + "asyncpgsa-0.26.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e2d574595dde50953d127c7d6da85590", + "name": "asyncpgsa", + "sha256": "de9cf8b0644449774d12577d206651cf0a114286ac7e6a3991055f930eb239d8", + "size": 25347, + "subdir": "linux-64", + "timestamp": 1552357436809, + "version": "0.26.0" + }, + "asyncpgsa-0.26.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.8,<3.9.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6071085bf251892a39031f1b2b8caa55", + "name": "asyncpgsa", + "sha256": "119796959457406bd0fdc0b52f3839c8d616c29a8a60250f60f49199d6c60e62", + "size": 27678, + "subdir": "linux-64", + "timestamp": 1573738145460, + "version": "0.26.0" + }, + "asyncpgsa-0.26.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a9032f68a0ea9dc00270895bc0067126", + "name": "asyncpgsa", + "sha256": "343d306932f84b4273dc7b7ff1ebfd39ab0eef411a760ee3cff353407bacc66a", + "size": 30081, + "subdir": "linux-64", + "timestamp": 1573962150940, + "version": "0.26.1" + }, + "asyncpgsa-0.26.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3cb88a99e9f2a8342446aeeae4107ce3", + "name": "asyncpgsa", + "sha256": "9eca08e8ae3a62527375a3b0702cbb78fb865007c4e0cc41ab5d691c2c215559", + "size": 30059, + "subdir": "linux-64", + "timestamp": 1573962165852, + "version": "0.26.1" + }, + "asyncpgsa-0.26.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.8,<3.9.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "47240afcdc4e5f158e4125481397a85b", + "name": "asyncpgsa", + "sha256": "47690696866bfec4e7b5f50895e26db6a67ef59e4fc9d00729bb39a157920072", + "size": 30255, + "subdir": "linux-64", + "timestamp": 1573962170343, + "version": "0.26.1" + }, + "asyncpgsa-0.26.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7e0d8f313e1ed06bfa2ce8e1ccb1cf1a", + "name": "asyncpgsa", + "sha256": "17e1e8cc5f15ede6b4d3a60801584057246f3b4969e78f2d43bd12b912b686e1", + "size": 29984, + "subdir": "linux-64", + "timestamp": 1592209009382, + "version": "0.26.3" + }, + "asyncpgsa-0.26.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9161bbe4750e45c049d8683254be4a6f", + "name": "asyncpgsa", + "sha256": "6e9be88b8770417d87e6bb4264833b07833e6e031125675c9e952c4c48324355", + "size": 30391, + "subdir": "linux-64", + "timestamp": 1613153888141, + "version": "0.26.3" + }, + "asyncpgsa-0.26.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b87c30ab9d0d930879f6ee3c324cb5d0", + "name": "asyncpgsa", + "sha256": "9a7866dc87936ae1d8da0086c05b5c20b77e3d05ce768bfcdc6a58a6e74ff38c", + "size": 30005, + "subdir": "linux-64", + "timestamp": 1592209011413, + "version": "0.26.3" + }, + "asyncpgsa-0.26.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "de2cf1f710b2869cd0642b23f817eac9", + "name": "asyncpgsa", + "sha256": "ade7374c774e5bb437ee4501ed098ecbaf017bf15e39c001b53a6983189d6060", + "size": 30441, + "subdir": "linux-64", + "timestamp": 1613154337180, + "version": "0.26.3" + }, + "asyncpgsa-0.26.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.8,<3.9.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dc57962de6fccad2ac6876f897bd2ffd", + "name": "asyncpgsa", + "sha256": "5aa7f60f25529de58a986ce0594d478e1742a519db754f9745135de632150c4d", + "size": 30197, + "subdir": "linux-64", + "timestamp": 1592209009442, + "version": "0.26.3" + }, + "asyncpgsa-0.26.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.8,<3.9.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b7dd61088dd9dfa5b805a10f4cd22970", + "name": "asyncpgsa", + "sha256": "8e4d0858ab7e8be687c5d3c25aa6c7a75d7af6593c437cf75ba936dce38c51f9", + "size": 30623, + "subdir": "linux-64", + "timestamp": 1613154343792, + "version": "0.26.3" + }, + "asyncpgsa-0.26.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.9,<3.10.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a62e8522029faa3f90ddbdfb5d36a05b", + "name": "asyncpgsa", + "sha256": "abc1fd111e8d838f74c4f92ba4bba350bbcc43ff9b24c29f4d55824932c2941a", + "size": 30563, + "subdir": "linux-64", + "timestamp": 1613154336061, + "version": "0.26.3" + }, + "asyncpgsa-0.27.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5a62c3318af7ed607a2ac60d3bdb2900", + "name": "asyncpgsa", + "sha256": "bf27c4ae37e6438a33f5514b04d7b1e25f448210d5b49a259a29153b51e16610", + "size": 27980, + "subdir": "linux-64", + "timestamp": 1613245827756, + "version": "0.27.0" + }, + "asyncpgsa-0.27.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "85261230ade23abc0e7baa5c020ca197", + "name": "asyncpgsa", + "sha256": "dd9a102cb1eda8b3271fec3230087a02985474d2f35ece70809ccd01d77dceba", + "size": 27928, + "subdir": "linux-64", + "timestamp": 1613246323012, + "version": "0.27.0" + }, + "asyncpgsa-0.27.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.8,<3.9.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "03907a7ef87f6dacfbeeaddcc031b199", + "name": "asyncpgsa", + "sha256": "f4992384f838f4c57a67edc4b200c42ab31a33e0f5dfa7fd75cb883367cadeea", + "size": 28179, + "subdir": "linux-64", + "timestamp": 1613246320343, + "version": "0.27.0" + }, + "asyncpgsa-0.27.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.9,<3.10.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5dc7bebd7bcc6712be0e6e7ef9384b17", + "name": "asyncpgsa", + "sha256": "7b76e3842823d19264bf39f592242ad1386ea296f95885f7039f005c7a98f3cf", + "size": 28138, + "subdir": "linux-64", + "timestamp": 1613246331655, + "version": "0.27.0" + }, + "asyncpgsa-0.27.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.10,<3.11.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "302b2d166a793df2b708c91447bd3e39", + "name": "asyncpgsa", + "sha256": "6123ea6e8c9ab25911cd29909d1e2862aa5d26436b472a72b140c6a92d7e7324", + "size": 28286, + "subdir": "linux-64", + "timestamp": 1640803462171, + "version": "0.27.1" + }, + "asyncpgsa-0.27.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.11,<3.12.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bc1166e22a72da36bb1dccec214ea7c7", + "name": "asyncpgsa", + "sha256": "ec1571a3a320c0cf0d338dbf6d642315e46e22fba4ba8e8c14120a75039dcddc", + "size": 33311, + "subdir": "linux-64", + "timestamp": 1676846846875, + "version": "0.27.1" + }, + "asyncpgsa-0.27.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0c4bb3d35917fc1847a6bf8f698bd306", + "name": "asyncpgsa", + "sha256": "f199910444b016fc565f8046b50c2b8437db379e96ce9a7042036e2bedc03247", + "size": 27988, + "subdir": "linux-64", + "timestamp": 1614361181049, + "version": "0.27.1" + }, + "asyncpgsa-0.27.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4f1158c87f8997f8537e034e1b9aff62", + "name": "asyncpgsa", + "sha256": "dfbc9f5c8f1de049356697cff7e20cbbe7de662e590e268f6d4093d750e5654f", + "size": 27981, + "subdir": "linux-64", + "timestamp": 1614361159178, + "version": "0.27.1" + }, + "asyncpgsa-0.27.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.8,<3.9.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c14986606863dac43c1951f4ca370194", + "name": "asyncpgsa", + "sha256": "e083a2fb152ddd18ad5ad3a06cf3fb6e29055d692ffc9980fc0f8d157f6eab35", + "size": 28195, + "subdir": "linux-64", + "timestamp": 1614361161590, + "version": "0.27.1" + }, + "asyncpgsa-0.27.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "asyncpg", + "python >=3.9,<3.10.0a0", + "sqlalchemy" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a9818a4797a0edb2e4f57f82d68851c4", + "name": "asyncpgsa", + "sha256": "d278a9451e7d8cd2419a8f6f0195d3bb650f9f1b7e9d1dc56b583ca6dc3c6736", + "size": 28303, + "subdir": "linux-64", + "timestamp": 1614360112003, + "version": "0.27.1" + }, + "asynctest-0.11.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "601fb09d27b86a86a80098271a36052d", + "name": "asynctest", + "sha256": "b9613f208499ae5aa5792143ec2d327fcc17704b49ad66e0449479f3fbb4be78", + "size": 37808, + "subdir": "linux-64", + "timestamp": 1543150776895, + "version": "0.11.1" + }, + "asynctest-0.11.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6ff4df5d4d73c05c9edd9b883af14e1c", + "name": "asynctest", + "sha256": "2b4009bf3ed029a9ddce21ce42bf8511071bdb4dd08bdb72189e097e89295231", + "size": 37862, + "subdir": "linux-64", + "timestamp": 1543150731451, + "version": "0.11.1" + }, + "asynctest-0.12.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0d9f510f8431fe81e4ee796d81c1327a", + "name": "asynctest", + "sha256": "209b51802a18d21b4155cafc8c084f2e96249d29010e44586b0b4d85b323aaa8", + "size": 45243, + "subdir": "linux-64", + "timestamp": 1543147007418, + "version": "0.12.2" + }, + "asynctest-0.12.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "72f0f823aedd5eb213b8dcf1ab3baa6c", + "name": "asynctest", + "sha256": "ff2af46d67220dbdee7085972b99c4ab240bc3d7e0d3d8a16bce47ad191bfc1d", + "size": 45865, + "subdir": "linux-64", + "timestamp": 1543146987601, + "version": "0.12.2" + }, + "at-spi2-atk-2.34.2-hdb5d850_0.conda": { + "build": "hdb5d850_0", + "build_number": 0, + "depends": [ + "at-spi2-core >=2.36.0,<2.37.0a0", + "atk-1.0 >=2.36.0", + "dbus >=1.13.18,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=7.5.0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "23a8694f896799826c49fe264f301959", + "name": "at-spi2-atk", + "sha256": "a3b7b808b3d541c8e329aa62738fb8c276e905f54abee3f86996a069aa8f9eb4", + "size": 254331, + "subdir": "linux-64", + "timestamp": 1632416503727, + "version": "2.34.2" + }, + "at-spi2-core-2.36.0-hdb5d850_1.conda": { + "build": "hdb5d850_1", + "build_number": 1, + "depends": [ + "dbus >=1.13.18,<2.0a0", + "gettext", + "glib >=2.69.1,<3.0a0", + "gobject-introspection", + "libgcc-ng >=7.5.0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "50ab3d44587ed9b97944a8b9474f39bb", + "name": "at-spi2-core", + "sha256": "61e873f55a3dbe382b17b5f2c273913665d559188275bc0497a21e1edbeb5d4c", + "size": 424460, + "subdir": "linux-64", + "timestamp": 1632414669897, + "version": "2.36.0" + }, + "atk-1.0-2.36.0-h28cd5cc_0.conda": { + "build": "h28cd5cc_0", + "build_number": 0, + "constrains": [ + "atk-1.0 2.36.0" + ], + "depends": [ + "glib >=2.65.0,<3.0a0", + "gobject-introspection 1.*", + "libgcc-ng >=7.3.0", + "ninja" + ], + "license": "LGPL-2.0-or-later", + "md5": "a29443916bcf7d76eeedd66cc204a09d", + "name": "atk-1.0", + "sha256": "f5989c1fc2c550b2e111cdf6f7c31010959091503b414245f182a6d31e28b391", + "size": 466544, + "subdir": "linux-64", + "timestamp": 1596107197873, + "version": "2.36.0" + }, + "atk-1.0-2.36.0-ha1a6a79_0.conda": { + "build": "ha1a6a79_0", + "build_number": 0, + "constrains": [ + "atk-1.0 2.36.0" + ], + "depends": [ + "glib >=2.69.1,<3.0a0", + "gobject-introspection 1.*", + "libgcc-ng >=7.5.0", + "ninja" + ], + "license": "LGPL-2.0-or-later", + "md5": "059ccf0f188e5238343a74d2ac97e697", + "name": "atk-1.0", + "sha256": "93d9cb17ae823fec60eab4c01281186418c2e1e9f0e953ae79f82d34ed7733ef", + "size": 476867, + "subdir": "linux-64", + "timestamp": 1631792905282, + "version": "2.36.0" + }, + "atk-2.36.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "atk-1.0 2.36.0.*" + ], + "license": "LGPL-2.0-or-later", + "md5": "1d6693a7a8f6417d7738bcb8fc338363", + "name": "atk", + "sha256": "08af408a9f603ade89cced25fff6cde32bf577ecfee588cda3e72e84878e8c54", + "size": 17901, + "subdir": "linux-64", + "timestamp": 1596107200505, + "version": "2.36.0" + }, + "atk-2.36.0-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "atk-1.0 2.36.0.*" + ], + "license": "LGPL-2.0-or-later", + "md5": "80489733d5f514cbdf8252c47f33b87f", + "name": "atk", + "sha256": "1aa3e1af61a0cb20ca84f2a631ae7b8e2d414a9c943db638e2141a30c6a78870", + "size": 18210, + "subdir": "linux-64", + "timestamp": 1631792907180, + "version": "2.36.0" + }, + "atlasclient-0.1.7-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.10,<3.11.0a0", + "requests", + "six" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "9ff962eb07cbe822bbef978287b04357", + "name": "atlasclient", + "sha256": "cf38a0cf5176f2a9594533726f875fe6d8094dcdd756db532b803983f041ab2d", + "size": 46384, + "subdir": "linux-64", + "timestamp": 1659859286964, + "version": "0.1.7" + }, + "atlasclient-0.1.7-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.11,<3.12.0a0", + "requests", + "six" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "01e6abdea6801dfbdbcb0d2bf08ed0a1", + "name": "atlasclient", + "sha256": "c56a3592cddb2fd0a1470f9ffdc4d221364ac399722bdc9683e26dfef1e47288", + "size": 57088, + "subdir": "linux-64", + "timestamp": 1676846861830, + "version": "0.1.7" + }, + "atlasclient-0.1.7-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.7,<3.8.0a0", + "requests", + "six" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "9bbf96c4ab6f088f9b646db21fa6f8f3", + "name": "atlasclient", + "sha256": "fd10b7811469545620d9fc14c4d83117bb4d78177f9dc58bfc1ea75f089abb14", + "size": 45695, + "subdir": "linux-64", + "timestamp": 1659859244516, + "version": "0.1.7" + }, + "atlasclient-0.1.7-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.8,<3.9.0a0", + "requests", + "six" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "9aa7a20019c1f3b33300755c705fa76e", + "name": "atlasclient", + "sha256": "aba4b6775c01c13c4723923e7e8f662bcec15f1d30d44a930feb3005a3ea038b", + "size": 45856, + "subdir": "linux-64", + "timestamp": 1659859316291, + "version": "0.1.7" + }, + "atlasclient-0.1.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.9,<3.10.0a0", + "requests", + "six" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "aadde71dd32059c84bd0969af381fd80", + "name": "atlasclient", + "sha256": "2f64a931f68ab18e523125bb2c11c64e9b7dcdbd15d08e89c67daccf5220b416", + "size": 45809, + "subdir": "linux-64", + "timestamp": 1659859213989, + "version": "0.1.7" + }, + "atom-0.4.0-py27he38824b_0.conda": { + "build": "py27he38824b_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "d053eb053c8428d777fde4895249e933", + "name": "atom", + "sha256": "397dbbbf2d911c6f211060ca540ee6d377c9dbdca49cde8b5cd17111e7cdceef", + "size": 108980, + "subdir": "linux-64", + "timestamp": 1509083692854, + "version": "0.4.0" + }, + "atom-0.4.0-py35h6c17750_0.conda": { + "build": "py35h6c17750_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "ba0cc4aa106d5cddf5b76a29c3b9fc19", + "name": "atom", + "sha256": "a46358923c68d9ad4327625b0effbd1938e4ba0d9ee27723281bffa41e0b92a1", + "size": 109202, + "subdir": "linux-64", + "timestamp": 1509083729207, + "version": "0.4.0" + }, + "atom-0.4.0-py36hed3e896_0.conda": { + "build": "py36hed3e896_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "3e4628748461c2ce2473767a92b82b24", + "name": "atom", + "sha256": "0a6ba3685f9ab34984a6423c956916e52b53f4f39c1dd0acbc879b6bac5da55a", + "size": 108580, + "subdir": "linux-64", + "timestamp": 1509083737326, + "version": "0.4.0" + }, + "atom-0.4.1-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "f9e9db6671275cb0a918151c47281226", + "name": "atom", + "sha256": "7510c432af62146beec16d0d7da44d43f5d8077338ec8dda37f927c822d54c70", + "size": 109527, + "subdir": "linux-64", + "timestamp": 1519174652366, + "version": "0.4.1" + }, + "atom-0.4.1-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "f06b29c9dfd67cb0dc8326e5f65de28b", + "name": "atom", + "sha256": "f17fda81604415821fe6abfdf846dc681a8c1775c686fcbd13f2e3896a1a9816", + "size": 109096, + "subdir": "linux-64", + "timestamp": 1519174669607, + "version": "0.4.1" + }, + "atom-0.4.1-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "e5bd4cda110cebb54affcf8ef1742200", + "name": "atom", + "sha256": "f779584ecc60f3f34312f329e2425f8bdebcb296fdcc97068ccc216d51e2191d", + "size": 109283, + "subdir": "linux-64", + "timestamp": 1519174627987, + "version": "0.4.1" + }, + "atom-0.4.1-py37hf484d3e_0.conda": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "e0e4cfe2bf46d0a33cb45ffdbe5147ec", + "name": "atom", + "sha256": "cbda766735c0718a04d1a721492bb3bfb476b9dc16dd3281d9f7b1cab5fe12ff", + "size": 108796, + "subdir": "linux-64", + "timestamp": 1530738558810, + "version": "0.4.1" + }, + "atom-0.4.3-py27hfd86e86_0.conda": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "8ff9431e1a29bae132d71db64c23231c", + "name": "atom", + "sha256": "edf57be8b676648277db524f01a02de9fcfbe279b62b2292d7f55547e3457dc8", + "size": 118065, + "subdir": "linux-64", + "timestamp": 1552357773033, + "version": "0.4.3" + }, + "atom-0.4.3-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "b1358f55ff681b04dccb1e7f54dcc41f", + "name": "atom", + "sha256": "b6cab874c77178dc0ddede8273fb1454db38a7a8812cbcf0a91676d1b52b8ad9", + "size": 117973, + "subdir": "linux-64", + "timestamp": 1552357837114, + "version": "0.4.3" + }, + "atom-0.4.3-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "a7eb23671c3d587915758e2a6706a275", + "name": "atom", + "sha256": "f53a74d6953298a7288e067a16003ad1568f35321ba63602532bebb34ec9d5b0", + "size": 118266, + "subdir": "linux-64", + "timestamp": 1552357787861, + "version": "0.4.3" + }, + "atom-0.4.3-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "658ebfedee3d2f464222005bbcd687cb", + "name": "atom", + "sha256": "0a5a7cd40eb93ecfb748c216426cf46602663ccd41ad1ab58d4335273f08e3f6", + "size": 129499, + "subdir": "linux-64", + "timestamp": 1573738048341, + "version": "0.4.3" + }, + "atom-0.5.0-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7caf8299aacd76b08a8d15bf6a0fe23d", + "name": "atom", + "sha256": "6fdc435ebe359e60ae4192fce9f544b3a0489755a4616af70fcc5760645d3910", + "size": 121410, + "subdir": "linux-64", + "timestamp": 1588478279678, + "version": "0.5.0" + }, + "atom-0.5.0-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9666a4cc5aee24373ebcf02ce396a9d7", + "name": "atom", + "sha256": "21c28866f1fab93e7b946693e71a0db9225625b9ec578e28b746dc02e73c159b", + "size": 121128, + "subdir": "linux-64", + "timestamp": 1588478267172, + "version": "0.5.0" + }, + "atom-0.5.0-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e6af19059b2ffefb19f725fd56d86c7d", + "name": "atom", + "sha256": "9310817c4c20bb6c87a0981681366ef08b19da720978f58b74604ae83372f57c", + "size": 127516, + "subdir": "linux-64", + "timestamp": 1588478269920, + "version": "0.5.0" + }, + "atom-0.5.1-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "57a35ad023af6d521da19469f5c242c6", + "name": "atom", + "sha256": "f6ddcb645d2dbc382eb4768c278668b751af7e52d00ce43f1bcf1575b291053e", + "size": 121982, + "subdir": "linux-64", + "timestamp": 1593440044850, + "version": "0.5.1" + }, + "atom-0.5.1-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b83d6d1fe4b86b9282eda0c2320036bc", + "name": "atom", + "sha256": "b6166add4c0afcbdee33ae55026a1d1ee93286c8f0496b73bb15eb8e91846e0c", + "size": 121229, + "subdir": "linux-64", + "timestamp": 1593440044881, + "version": "0.5.1" + }, + "atom-0.5.1-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d0c847f5d1da7fa450539f9943bac491", + "name": "atom", + "sha256": "82231c1e0c5739bcc4d90c9d722d27fe01c8b26430d90c7b9db509dcf0678990", + "size": 128527, + "subdir": "linux-64", + "timestamp": 1593440055064, + "version": "0.5.1" + }, + "atom-0.5.2-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "1368db955e41d95751d3c2ff45d5519c", + "name": "atom", + "sha256": "81ad390e522536f30a38fbad1d938b1e2ecb8979787d5bcaebe799e81409d771", + "size": 121139, + "subdir": "linux-64", + "timestamp": 1600298433142, + "version": "0.5.2" + }, + "atom-0.5.2-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7d48e9782e6a669a5dbd12592ce8c4a3", + "name": "atom", + "sha256": "0195a38c8c0fee0bcc4b4793af4f275c0de009b25248355c4eb8a2473d7b7e58", + "size": 121171, + "subdir": "linux-64", + "timestamp": 1600298389240, + "version": "0.5.2" + }, + "atom-0.5.2-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "68305019fcd6521cb138eb5e9cb8a1d2", + "name": "atom", + "sha256": "52442242f0be283761d822a3b4db72ec788d675365b9db32aba7998738945927", + "size": 128036, + "subdir": "linux-64", + "timestamp": 1600298373531, + "version": "0.5.2" + }, + "atom-0.6.0-py310hd09550d_0.conda": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "8ab439df56e1cc2744ef0d8c93ea5dc6", + "name": "atom", + "sha256": "331b5d45402b0c45d1abeb4b04df232a3a90f980948e00f839222672523d2b87", + "size": 768915, + "subdir": "linux-64", + "timestamp": 1640803508267, + "version": "0.6.0" + }, + "atom-0.6.0-py36hff7bd54_0.conda": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "775e2961104a70b39722def24db73e20", + "name": "atom", + "sha256": "a2dcffa1154a32c2d9acef443c2e1e3f67f31b8e9a3e8b93d82d0553e3851b56", + "size": 121090, + "subdir": "linux-64", + "timestamp": 1604765633728, + "version": "0.6.0" + }, + "atom-0.6.0-py37hff7bd54_0.conda": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2eeb5c5f2f76fb649b8963935ab9a4a5", + "name": "atom", + "sha256": "18bdfbe625bf241984764620e9773e3c73824a0ab755b56e6f13df311fa5b7c6", + "size": 120532, + "subdir": "linux-64", + "timestamp": 1604765604266, + "version": "0.6.0" + }, + "atom-0.6.0-py38hff7bd54_0.conda": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2702898342d6d7abf8161f7f5f6a2af9", + "name": "atom", + "sha256": "ffc9bfc2b89e24255ef9affc45e899110df40c174aa986217473d091ebc33da0", + "size": 128076, + "subdir": "linux-64", + "timestamp": 1604765634056, + "version": "0.6.0" + }, + "atom-0.6.0-py39hff7bd54_0.conda": { + "build": "py39hff7bd54_0", + "build_number": 0, + "depends": [ + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "34eb2ed505051bd475fa49f1b4794289", + "name": "atom", + "sha256": "2d1fc14c1a129c159d08b9daf23978d4ec7f60c9202b02839310c59d2b9414be", + "size": 131312, + "subdir": "linux-64", + "timestamp": 1613154383787, + "version": "0.6.0" + }, + "atom-0.8.2-py310hdb19cb5_0.conda": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07585d9bda7df0131a10fd10d8f0b2e8", + "name": "atom", + "sha256": "89abaa4ae32b8de2523c1e2d57f6b5ddc455de5491ab756c8363d17587b120d0", + "size": 150081, + "subdir": "linux-64", + "timestamp": 1670614501495, + "version": "0.8.2" + }, + "atom-0.8.2-py311hdb19cb5_0.conda": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5771937c7be7a649551b0f185ff51cee", + "name": "atom", + "sha256": "7e0e6229b4b7425e8f709d494bdc279395ade2c914d23f3593c6b8d74b47b6c3", + "size": 148018, + "subdir": "linux-64", + "timestamp": 1676843280622, + "version": "0.8.2" + }, + "atom-0.8.2-py38hdb19cb5_0.conda": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c1de0fb9b1a212e0f980d7f0fb1002d1", + "name": "atom", + "sha256": "25212ed773a391092ddbeaad4ddb928d23ffeaa5b697d3f2810cd89ff2bfc5e5", + "size": 149576, + "subdir": "linux-64", + "timestamp": 1670614462096, + "version": "0.8.2" + }, + "atom-0.8.2-py39hdb19cb5_0.conda": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "42d5ff16667ce97afa3b80034a7f8764", + "name": "atom", + "sha256": "631acf14ed5f3459aba1a922378535b864254455e6e0d651439e4db6a8a1ef80", + "size": 150039, + "subdir": "linux-64", + "timestamp": 1670614541129, + "version": "0.8.2" + }, + "atom-0.9.0-py310hdb19cb5_0.conda": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aa1984546bcb6aec2c25af8b3e2a8f61", + "name": "atom", + "sha256": "7261427f6b4b6b6e7ac15f78452b579d73ac492fd03355c16b1cd8e265fdbb2e", + "size": 155724, + "subdir": "linux-64", + "timestamp": 1678313705225, + "version": "0.9.0" + }, + "atom-0.9.0-py311hdb19cb5_0.conda": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "319c9c964757e02b8662085352fc2ff2", + "name": "atom", + "sha256": "7ef6eca6a01b1c6a9ccc21e3c33c7ad925e9fdc2a8b6b8558b8cddc3715f8318", + "size": 152389, + "subdir": "linux-64", + "timestamp": 1679335377766, + "version": "0.9.0" + }, + "atom-0.9.0-py38hdb19cb5_0.conda": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f4374a6e84a6e238dd1b5151c5b0c387", + "name": "atom", + "sha256": "100e8a4a8df9fab9f801eac8cf32634e0e936346dd118eee094c5c495b9a6d97", + "size": 154064, + "subdir": "linux-64", + "timestamp": 1678313746950, + "version": "0.9.0" + }, + "atom-0.9.0-py39hdb19cb5_0.conda": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f6d83fc2522b2872ea26bd7602cc135", + "name": "atom", + "sha256": "70a8a281402ea4ef314341b45110b681503eb43061a6d05d790ab53ddeb6f0d0", + "size": 154387, + "subdir": "linux-64", + "timestamp": 1678313788641, + "version": "0.9.0" + }, + "atomicwrites-1.1.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f400ab654aa44ac6e46627cb3d1ea68", + "name": "atomicwrites", + "sha256": "03184540e7540062bb40da093d92eeb6508ff1b11c3f9e24eb0b4a81b1bcf3ed", + "size": 10740, + "subdir": "linux-64", + "timestamp": 1527822258707, + "version": "1.1.5" + }, + "atomicwrites-1.1.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d0f8d9769bd9f4928d0b8ea6f24d6f8", + "name": "atomicwrites", + "sha256": "12403a2e72b239690ebc1dd98f7714c76f3036f7f586037f6e3b94342e0cb4b3", + "size": 10844, + "subdir": "linux-64", + "timestamp": 1527822267829, + "version": "1.1.5" + }, + "atomicwrites-1.1.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9fcbe841e755be7787f39be9e54e5d21", + "name": "atomicwrites", + "sha256": "e9f99992fa4c33963da4a85b15670390ff49d9a6b6a0abc5d5ef18ec11ffeac6", + "size": 10754, + "subdir": "linux-64", + "timestamp": 1527822238826, + "version": "1.1.5" + }, + "atomicwrites-1.1.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c7271c76a4faaa2fc582707fc98247f9", + "name": "atomicwrites", + "sha256": "0d275694b5d862b11707d9f70816b2528519da44d029daf42f3c662c94a5f20f", + "size": 10804, + "subdir": "linux-64", + "timestamp": 1530693994220, + "version": "1.1.5" + }, + "atomicwrites-1.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3da5a91052b0f594375daf3b4079fb52", + "name": "atomicwrites", + "sha256": "cec28e647f54f242ebd88b58af0488dc784c02ed8611925c9ddcb005dcd0557e", + "size": 11693, + "subdir": "linux-64", + "timestamp": 1535384578210, + "version": "1.2.0" + }, + "atomicwrites-1.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "415203434a25d26967ae52350a762297", + "name": "atomicwrites", + "sha256": "701049cbb9656df3817cd8790d52547d1d4eaae2a2d28c17961b35f3d0cf8262", + "size": 11722, + "subdir": "linux-64", + "timestamp": 1535384597575, + "version": "1.2.0" + }, + "atomicwrites-1.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d7a158308016265e8e044a533388be55", + "name": "atomicwrites", + "sha256": "d1fec9ae169be7fad78c174031e52aee46b909bc94f4b4091a594541e77103d6", + "size": 11636, + "subdir": "linux-64", + "timestamp": 1535384510133, + "version": "1.2.0" + }, + "atomicwrites-1.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01547667eced62938c01033652c1217c", + "name": "atomicwrites", + "sha256": "f81964072019ad1286584c5b859df3a2ec50eb43b66f49f9dc36fbb316ec0748", + "size": 11702, + "subdir": "linux-64", + "timestamp": 1535384457944, + "version": "1.2.0" + }, + "atomicwrites-1.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8fc8d988cc5d61565684949c3d1df168", + "name": "atomicwrites", + "sha256": "515a580e68e3d0da8dc19cb26fcc7ea6fd6ee4ac2f599e0b855cf7cfe39f7188", + "size": 11661, + "subdir": "linux-64", + "timestamp": 1536085949560, + "version": "1.2.1" + }, + "atomicwrites-1.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9000fe89a0d546ed3144bffcb0a3cdaa", + "name": "atomicwrites", + "sha256": "0e2948163468527012d64b7cd33f6df0f1ef0cdf36ec2de1969ba2962aafb1c3", + "size": 11723, + "subdir": "linux-64", + "timestamp": 1536085985420, + "version": "1.2.1" + }, + "atomicwrites-1.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad651172aa322108ee9b09199f9c8966", + "name": "atomicwrites", + "sha256": "71fc454adf7265b91e20e0153aefa7da907bc993aec3b997fb4d42076a9ff74a", + "size": 11664, + "subdir": "linux-64", + "timestamp": 1536085923786, + "version": "1.2.1" + }, + "atomicwrites-1.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a5fd9b80f738d298d2e998d55339a2dc", + "name": "atomicwrites", + "sha256": "e4ca368a83a1cfd375e98d9ffa551405f53fff752047a6e975ac5ac8f48ea9f6", + "size": 11656, + "subdir": "linux-64", + "timestamp": 1536085952529, + "version": "1.2.1" + }, + "atomicwrites-1.3.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7833ae567cc9a3471fb72220541262be", + "name": "atomicwrites", + "sha256": "a828128445e47eb10593613c6077b23f6f6d79c9d73267e1770276e9015eb478", + "size": 13443, + "subdir": "linux-64", + "timestamp": 1553289194852, + "version": "1.3.0" + }, + "atomicwrites-1.3.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e111c51aea4428b9b5a8f26adc1c51f", + "name": "atomicwrites", + "sha256": "9738b9404717f3cf3b2a9ddb1f2c39b25d7bdd06d4ab92ec696ba51b2932f39f", + "size": 13404, + "subdir": "linux-64", + "timestamp": 1553289296269, + "version": "1.3.0" + }, + "atomicwrites-1.3.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be2df2b0a78c9914006eb21820e55f04", + "name": "atomicwrites", + "sha256": "281363a506becd141c83e672537e60423ff19b52b23ff626fe1261d53a32f3eb", + "size": 13389, + "subdir": "linux-64", + "timestamp": 1553289196962, + "version": "1.3.0" + }, + "attrs-17.2.0-py27h25ce645_0.conda": { + "build": "py27h25ce645_0", + "build_number": 0, + "depends": [ + "hypothesis", + "pympler", + "python >=2.7,<2.8.0a0", + "zope", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bed3aca23131b7898bf1f3937d5b48d8", + "name": "attrs", + "sha256": "a241d1331a8744aa86041ebda1edd848d89202b28a438a9eb8b7240b44b97739", + "size": 34754, + "subdir": "linux-64", + "timestamp": 1507745271697, + "version": "17.2.0" + }, + "attrs-17.2.0-py35hde4ea97_0.conda": { + "build": "py35hde4ea97_0", + "build_number": 0, + "depends": [ + "hypothesis", + "pympler", + "python >=3.5,<3.6.0a0", + "zope", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39dfc091ce11daa0ecc702f6057fddbc", + "name": "attrs", + "sha256": "d4622d67e047d0c583c3c6829307db62a4577a7d48d806683802fca2d37a83a9", + "size": 35188, + "subdir": "linux-64", + "timestamp": 1507745282460, + "version": "17.2.0" + }, + "attrs-17.2.0-py36h8d46266_0.conda": { + "build": "py36h8d46266_0", + "build_number": 0, + "depends": [ + "hypothesis", + "pympler", + "python >=3.6,<3.7.0a0", + "zope", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "652b3a044834886d66ff45f8ec8040cb", + "name": "attrs", + "sha256": "26d030694806952521b07c0241bcd9c946e2555cd24312bef65e3fb99b5e8b11", + "size": 35102, + "subdir": "linux-64", + "timestamp": 1507745282943, + "version": "17.2.0" + }, + "attrs-17.3.0-py27hf19f258_0.conda": { + "build": "py27hf19f258_0", + "build_number": 0, + "depends": [ + "hypothesis", + "pympler", + "python >=2.7,<2.8.0a0", + "zope", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc06134b54f2a0f23fc47dd9602c8a20", + "name": "attrs", + "sha256": "fe3023efbd63d12d2107f12673e83c09a11feb9de7ad9f09d14ec1c9cafeb62d", + "size": 40336, + "subdir": "linux-64", + "timestamp": 1511834537314, + "version": "17.3.0" + }, + "attrs-17.3.0-py35h20e33bf_0.conda": { + "build": "py35h20e33bf_0", + "build_number": 0, + "depends": [ + "hypothesis", + "pympler", + "python >=3.5,<3.6.0a0", + "zope", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef13a8b531cd40f0732514ca990cbe72", + "name": "attrs", + "sha256": "800cb4ead9ca28a98208966de03c2fb3d764cdacff0a2d8be63ce76bdc5927a7", + "size": 40586, + "subdir": "linux-64", + "timestamp": 1511834546950, + "version": "17.3.0" + }, + "attrs-17.3.0-py36h5ab58ff_0.conda": { + "build": "py36h5ab58ff_0", + "build_number": 0, + "depends": [ + "hypothesis", + "pympler", + "python >=3.6,<3.7.0a0", + "zope", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3072a8791488fa5eca8b6e0d54d235da", + "name": "attrs", + "sha256": "7013648e6fe5f3a10d30303886ed4b41e4e33de722ec6e191f6d08ff8a61fd78", + "size": 40565, + "subdir": "linux-64", + "timestamp": 1511834550234, + "version": "17.3.0" + }, + "attrs-17.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dcdb8b789361f6fad9ca3698379372d5", + "name": "attrs", + "sha256": "d06f841b87462012702aab8a67b10586c61fa0b52ef15123e77e6e31f3dd031b", + "size": 42610, + "subdir": "linux-64", + "timestamp": 1516977226372, + "version": "17.4.0" + }, + "attrs-17.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "93762f395ab32d6981b19ea0e3682350", + "name": "attrs", + "sha256": "ab8380fad96e6ffa89a293b227e798367bdc2da71fe643d399edbb2d08ba5444", + "size": 42821, + "subdir": "linux-64", + "timestamp": 1516977260555, + "version": "17.4.0" + }, + "attrs-17.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6294ec5346a886149461cdf8b7b2fbb", + "name": "attrs", + "sha256": "4fc3d43490f41b206613c5656f3b2f314085e1fbe6d710046c061886111fa344", + "size": 42904, + "subdir": "linux-64", + "timestamp": 1516977256826, + "version": "17.4.0" + }, + "attrs-18.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e60eb46ee3eb7e05848b0be326078df1", + "name": "attrs", + "sha256": "ed9c92671d31af786d9385b7882c6085ccaf7c2d4eb8097bf69dd5b72f44beed", + "size": 44229, + "subdir": "linux-64", + "timestamp": 1525810155325, + "version": "18.1.0" + }, + "attrs-18.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc2562974c25ebdd6f01698cca097dd3", + "name": "attrs", + "sha256": "34d47cf80cbb8b5058c0807a76f4903ec492827ef91336e5a9cbdb5018daf2d8", + "size": 45014, + "subdir": "linux-64", + "timestamp": 1525810189469, + "version": "18.1.0" + }, + "attrs-18.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e99c7aee48429c641d9873fc5fa657b9", + "name": "attrs", + "sha256": "4fdc55fa99250a16621ac2f5b31f201d2154898fac057f82d9ef9f00ecb7c55a", + "size": 45080, + "subdir": "linux-64", + "timestamp": 1525810189528, + "version": "18.1.0" + }, + "attrs-18.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48cf32e082d064fba16649e1fbeeb0b0", + "name": "attrs", + "sha256": "11e237d029fc29181c20c2c182208b3b48a502b2fe8e291ac1355ab2c1862716", + "size": 44900, + "subdir": "linux-64", + "timestamp": 1530693641746, + "version": "18.1.0" + }, + "attrs-18.2.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87c3aa4c050ef1c778305eb8e54d0fb9", + "name": "attrs", + "sha256": "da4e4741e2fc488c78e5f141e848c0b1ac2d62cac127bc05b33c9627b4b3e87c", + "size": 51622, + "subdir": "linux-64", + "timestamp": 1536072296955, + "version": "18.2.0" + }, + "attrs-18.2.0-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6a6e4f40e1c4c6fb626ff95f772df9f", + "name": "attrs", + "sha256": "f19a9235f6157f770921a92c760b37c12ac70e7908645690b4d7ee502b6127c7", + "size": 52452, + "subdir": "linux-64", + "timestamp": 1536072365713, + "version": "18.2.0" + }, + "attrs-18.2.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e812598657f2b73879cbe07c2c132a97", + "name": "attrs", + "sha256": "09ed4eabe66f6c5f76dccb2d6c0abcff7b439b99e589c2338443bff673328cb9", + "size": 51926, + "subdir": "linux-64", + "timestamp": 1536072258249, + "version": "18.2.0" + }, + "attrs-18.2.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4b4edb6c51a3d7435f4f227fd73fb652", + "name": "attrs", + "sha256": "76069ea2e3f3ba9526be460b4bcf20e736aebdb74b5cabf670a12827c92f5403", + "size": 51102, + "subdir": "linux-64", + "timestamp": 1536072427256, + "version": "18.2.0" + }, + "attrs-19.1.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "50cc414b45ed8c6d1884e996282c5afe", + "name": "attrs", + "sha256": "2390334f28a51255fd48bc958f61d0ed0067f8b423ef0f6066b99092316d0bcc", + "size": 57789, + "subdir": "linux-64", + "timestamp": 1553289142932, + "version": "19.1.0" + }, + "attrs-19.1.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "823f90feadf1397138d696669dc238fa", + "name": "attrs", + "sha256": "7064830579615f87b2b4dc13381226c65cca286a271b50d1c09760256b34a5b1", + "size": 57251, + "subdir": "linux-64", + "timestamp": 1553289440204, + "version": "19.1.0" + }, + "attrs-19.1.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b412fcbff3b656fcba67f735da9be63", + "name": "attrs", + "sha256": "04722fc01cfa5fb35a3041ddedf62e688291e07e72260e8d91b2269eb0ece052", + "size": 58040, + "subdir": "linux-64", + "timestamp": 1553290542480, + "version": "19.1.0" + }, + "attrs-22.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13aaefafba6e2e216b8587947eabd409", + "name": "attrs", + "sha256": "8fec596cd33491febc9fbb0744c06b71396b46ece1036c9cc9d0b0809f82ffcc", + "size": 87646, + "subdir": "linux-64", + "timestamp": 1668696274924, + "version": "22.1.0" + }, + "attrs-22.1.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8152cbb594ceb9c35f693d98dd6fa2a", + "name": "attrs", + "sha256": "9f904e5fd1187804526e41bb886d5095a8425c3fdc0b3859c867d5b296160008", + "size": 102873, + "subdir": "linux-64", + "timestamp": 1676822771018, + "version": "22.1.0" + }, + "attrs-22.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9252587708a25fbc1c021b648cc4ddb", + "name": "attrs", + "sha256": "433f38c2b41eeaa99e65f2e0daa97d9858ad507d9f68c1de2a11b176e1c27941", + "size": 86450, + "subdir": "linux-64", + "timestamp": 1668696301528, + "version": "22.1.0" + }, + "attrs-22.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51beb64c6f06b5a69529df7ecaccc3f9", + "name": "attrs", + "sha256": "eb8cc0fa9a8ca84196a7f8110a0f63669b972dd4f85ad1f524fcc94d2a63a707", + "size": 87097, + "subdir": "linux-64", + "timestamp": 1668696245523, + "version": "22.1.0" + }, + "attrs-22.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "539d5a954b41d0bf15a5ee4faf177987", + "name": "attrs", + "sha256": "46d121b0f5edc2db8372fba11c341989ad5317a067eaf56ad6a4e0df40d42ff7", + "size": 86863, + "subdir": "linux-64", + "timestamp": 1668696216395, + "version": "22.1.0" + }, + "authlib-0.15.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.2", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3805445b03c1633640bc86f0d38d74ff", + "name": "authlib", + "sha256": "1d414b72e702c3176c1149e2484632244086629db8fac01d6034b023f5083cd3", + "size": 235969, + "subdir": "linux-64", + "timestamp": 1659982995344, + "version": "0.15.5" + }, + "authlib-0.15.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.2", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22dbfe87788faa22c3175b851f27856e", + "name": "authlib", + "sha256": "a97dfd418ab9eb8385cf07b93b6c7c238eaaf0552e9a74825cf7c5b28c597e3f", + "size": 232790, + "subdir": "linux-64", + "timestamp": 1659982949506, + "version": "0.15.5" + }, + "authlib-0.15.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.2", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3b7a99e91cb6173bb550e929739d4b43", + "name": "authlib", + "sha256": "40d54aa43a8984c661348503a89f59dacac57ec98408ad0803ce83920cd9d586", + "size": 234227, + "subdir": "linux-64", + "timestamp": 1659982916529, + "version": "0.15.5" + }, + "authlib-0.15.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.2", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4a382aab0f4c150ee45c172558fbb1e6", + "name": "authlib", + "sha256": "bfe66bcf75b04057cf4d604e24d97b6bc0935eeb6545bf6e372e11a75cec1205", + "size": 233655, + "subdir": "linux-64", + "timestamp": 1659982884221, + "version": "0.15.5" + }, + "authlib-1.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.2", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "288f0417029a5eea433910a420143094", + "name": "authlib", + "sha256": "b58fdfc1eff2464242e82fe3122e08c6530a87afff21be748761dc311682e947", + "size": 253094, + "subdir": "linux-64", + "timestamp": 1659988161869, + "version": "1.0.1" + }, + "authlib-1.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.2", + "python >=3.11,<3.12.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2d761b23a616b4a7dc3c8d7879288c19", + "name": "authlib", + "sha256": "af9069213ba8e0c980bfa0c1c24d9cd27522aec0ab0c7215c56844c983cc70bd", + "size": 319271, + "subdir": "linux-64", + "timestamp": 1676846879489, + "version": "1.0.1" + }, + "authlib-1.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.2", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "609e5814260e54db29c0ca3d883f51fc", + "name": "authlib", + "sha256": "d108611f103f978b52f3f04aaa9bb823443f06b02fb795bfb863c022d80766b6", + "size": 249739, + "subdir": "linux-64", + "timestamp": 1659988222470, + "version": "1.0.1" + }, + "authlib-1.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.2", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "69890f092e7ba7832e049d763330bd38", + "name": "authlib", + "sha256": "3f5898ceec824c3d7fd525964cc7e97fda1ebbf54800ce9676c91baf93fbb990", + "size": 251045, + "subdir": "linux-64", + "timestamp": 1659988192102, + "version": "1.0.1" + }, + "authlib-1.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.2", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "348b47d8a324c0bf48efede143786f81", + "name": "authlib", + "sha256": "1616fa0c3329220a944a1d56326065e7d33a2ca6f10273ae2c0416bb54bc4834", + "size": 250301, + "subdir": "linux-64", + "timestamp": 1659988117573, + "version": "1.0.1" + }, + "autoconf-2.69-pl526hebd4dad_5.conda": { + "build": "pl526hebd4dad_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0", + "m4", + "perl" + ], + "license": "GPL-3.0", + "md5": "47a71adf05857657cb04350b518ec9e4", + "name": "autoconf", + "sha256": "8f1abc3e2bfcb225611f26f516826e7d45e1f72693eb7c4f366e0cb1e299e17f", + "size": 576430, + "subdir": "linux-64", + "timestamp": 1505666339973, + "version": "2.69" + }, + "autoconf-2.71-pl5340h5eee18b_0.conda": { + "build": "pl5340h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "m4", + "perl 5.*" + ], + "license": "GPL-3.0-or-later WITH Autoconf-exception-3.0", + "license_family": "GPL", + "md5": "1eb9254cf120e1a44c97de33972c427a", + "name": "autoconf", + "sha256": "011b2d07d82c4db7622fcaf62c6c95b29862135f8eabbcc2b63ff1799067d8b7", + "size": 672391, + "subdir": "linux-64", + "timestamp": 1670317070801, + "version": "2.71" + }, + "automake-1.15.1-pl526h7747ae0_0.conda": { + "build": "pl526h7747ae0_0", + "build_number": 0, + "depends": [ + "autoconf", + "m4", + "perl" + ], + "license": "GPL 3", + "md5": "5fbce2f2b68aff45f7192b5e9a3bd756", + "name": "automake", + "sha256": "cb474dc03e29c9df49dca5225faf714007da47dfce377382026bb18b507b4995", + "size": 566240, + "subdir": "linux-64", + "timestamp": 1505666355234, + "version": "1.15.1" + }, + "automake-1.16.1-pl526_0.conda": { + "build": "pl526_0", + "build_number": 0, + "depends": [ + "autoconf", + "m4", + "perl" + ], + "license": "GPL3", + "md5": "8b95508ad5fcea25c729a03d939cc8c4", + "name": "automake", + "sha256": "a96d5d937c71e932f65868ce22d4e6eaa6cb6e1b37a6825d0fd20b9400b815d9", + "size": 571776, + "subdir": "linux-64", + "timestamp": 1539255799332, + "version": "1.16.1" + }, + "automake-1.16.2-pl526_0.conda": { + "build": "pl526_0", + "build_number": 0, + "depends": [ + "autoconf", + "m4", + "perl" + ], + "license": "GPL 3", + "md5": "e1699c484e9291f0b6bf0bf3a824ccc5", + "name": "automake", + "sha256": "8937adcb7142e1c8c4c806efc0daf92cdde8f434856eb2f449f8efa1b601df7d", + "size": 569274, + "subdir": "linux-64", + "timestamp": 1588537633205, + "version": "1.16.2" + }, + "automake-1.16.5-pl5321h06a4308_0.conda": { + "build": "pl5321h06a4308_0", + "build_number": 0, + "depends": [ + "autoconf", + "m4", + "perl 5.*" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "661252e026be3d4ba4e6a7f51cd4cc15", + "name": "automake", + "sha256": "81d825c244959f43881808b188621600163d2b621ea18fd3506cb44609f7609a", + "size": 605564, + "subdir": "linux-64", + "timestamp": 1667595730986, + "version": "1.16.5" + }, + "automake-1.16.5-pl5340h06a4308_1.conda": { + "build": "pl5340h06a4308_1", + "build_number": 1, + "depends": [ + "autoconf", + "m4", + "perl 5.*" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "cff0066b97a9653996903cd528297eb6", + "name": "automake", + "sha256": "52973e4bdff47d4d2104be0d8bd0f48ee4b3bab718321baffd35efc2c91596c9", + "size": 607822, + "subdir": "linux-64", + "timestamp": 1670317968752, + "version": "1.16.5" + }, + "automat-0.6.0-py27hfed452d_0.conda": { + "build": "py27hfed452d_0", + "build_number": 0, + "depends": [ + "attrs", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96168e70e289c1f537c923086df01351", + "name": "automat", + "sha256": "ccf9edc939628d88536ab61fa1b81e227ab17cd3d92cdc995fcaa43ba5e601b5", + "size": 51034, + "subdir": "linux-64", + "timestamp": 1508093183500, + "version": "0.6.0" + }, + "automat-0.6.0-py35h367829d_0.conda": { + "build": "py35h367829d_0", + "build_number": 0, + "depends": [ + "attrs", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eae41728ed85fedfaceb3c1fd51d39a1", + "name": "automat", + "sha256": "cd8b591f6d1da674de8a3c2730bf32237caeb7b407d4fde4d4cad8b6e7f11931", + "size": 52785, + "subdir": "linux-64", + "timestamp": 1508093208378, + "version": "0.6.0" + }, + "automat-0.6.0-py36ha140c00_0.conda": { + "build": "py36ha140c00_0", + "build_number": 0, + "depends": [ + "attrs", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b3184ea2ceb31ae8397e26988ac39e53", + "name": "automat", + "sha256": "8804962d2be3234c5de237a37e200010f21e5dec4f738ecf4c9af92a95bd1918", + "size": 52282, + "subdir": "linux-64", + "timestamp": 1508093210211, + "version": "0.6.0" + }, + "automat-0.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b70575c70dd9687b877094e0fadaaef1", + "name": "automat", + "sha256": "d92ce937a6b620b6680eb70787000c9852c60987ac7362ae382fd0c95c8b8547", + "size": 54133, + "subdir": "linux-64", + "timestamp": 1529431687803, + "version": "0.7.0" + }, + "automat-0.7.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3a37edbd968617f90cbd8bb85b221fd", + "name": "automat", + "sha256": "558fd2a6f5e37afe94d353607d50ff3ddb102426db4559314f2896b34c07e2d1", + "size": 56096, + "subdir": "linux-64", + "timestamp": 1529431717338, + "version": "0.7.0" + }, + "automat-0.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ac3823384f4d2c71e2f2e0658643c64", + "name": "automat", + "sha256": "95977a50f9bc482b716bbf2303141bd37de73363c24b7ca873cbf0102f96ccd6", + "size": 54187, + "subdir": "linux-64", + "timestamp": 1529431733766, + "version": "0.7.0" + }, + "automat-0.7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e30cf34f76c18b8b8c164bb11b39bd8", + "name": "automat", + "sha256": "e45818f811d8d49d27983469ff2a3aca24053cd001c23ff86a1676481d1b3825", + "size": 54165, + "subdir": "linux-64", + "timestamp": 1530738583742, + "version": "0.7.0" + }, + "automat-0.7.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "attrs", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ee8faa1129ef05db988a5db667e5da0", + "name": "automat", + "sha256": "068933dd607cde61eebe9f66cd5bc1769d11b74d4b82e770bf3e4236839e11a4", + "size": 56346, + "subdir": "linux-64", + "timestamp": 1573738065140, + "version": "0.7.0" + }, + "autopep8-1.3.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a58917a69a6ba4291364ff2c370842b", + "name": "autopep8", + "sha256": "f57a51725a22661bd5f84e9f503db1e24ff986de8086d331863aaaa197c9c337", + "size": 69289, + "subdir": "linux-64", + "timestamp": 1536861257811, + "version": "1.3.4" + }, + "autopep8-1.3.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e5dc84015115b759e0a9f669c33c1341", + "name": "autopep8", + "sha256": "d9e3813935553aa017c2a097dacadba0b34db3baf4cbcdda60ecb886fe6fb747", + "size": 70907, + "subdir": "linux-64", + "timestamp": 1536861366443, + "version": "1.3.4" + }, + "autopep8-1.3.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "06e9ceb902436235eae5a4ecbc075dc3", + "name": "autopep8", + "sha256": "229afdee65ce131aaa6a2218c3b8a8c87336f036ea54e2cce96200b0ee75e05e", + "size": 68879, + "subdir": "linux-64", + "timestamp": 1536861365276, + "version": "1.3.4" + }, + "autopep8-1.3.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6190d46c415cf269d236da745fd39b8", + "name": "autopep8", + "sha256": "10f8d994e6c69d0b0702391b653c07409a7333933e76408d863c6b1e7778af73", + "size": 69915, + "subdir": "linux-64", + "timestamp": 1536861149790, + "version": "1.3.4" + }, + "autopep8-1.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16033ee7fcf6723100dd81bde0410c9c", + "name": "autopep8", + "sha256": "f6b5981c59fa34d970472ba1bcf89ca1ba0627f6c391669d52331c478da4ba78", + "size": 71517, + "subdir": "linux-64", + "timestamp": 1538362278422, + "version": "1.4" + }, + "autopep8-1.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1d96bb2be68fd1fac6625929cdc2837", + "name": "autopep8", + "sha256": "acf07dca4f15b34e004797dfb53a0f18d4c8f1e1bcb1b1cc1a63182fae8da560", + "size": 71537, + "subdir": "linux-64", + "timestamp": 1538362300291, + "version": "1.4" + }, + "autopep8-1.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "19abfe118087e1b7a6ba184c0227c6e3", + "name": "autopep8", + "sha256": "49fdc6699d5f07277b1db0a6d9ad8b12a4b73c6e9c2fff671459768f61a65402", + "size": 70211, + "subdir": "linux-64", + "timestamp": 1538362293584, + "version": "1.4" + }, + "autopep8-1.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f71070c33f6b6aa527bd17e0ec252ac9", + "name": "autopep8", + "sha256": "9cdeb7b4b71323aeaedc514894d75625718336234b805cc75c8e64d65cc9ce8e", + "size": 74288, + "subdir": "linux-64", + "timestamp": 1540957926560, + "version": "1.4.2" + }, + "autopep8-1.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a6e20407efbbdd234ae8f7e98cb5d3b", + "name": "autopep8", + "sha256": "623e98b5158c931102820e8f93473c6438c55670f45e2c0e0c78e7a86a6365f3", + "size": 75066, + "subdir": "linux-64", + "timestamp": 1540957962676, + "version": "1.4.2" + }, + "autopep8-1.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da70993eff497fb78f562ce844213670", + "name": "autopep8", + "sha256": "48be9ee644916386814e860674440a179213d1a4e8b06fe23e076fe6cd52f184", + "size": 74649, + "subdir": "linux-64", + "timestamp": 1540957899242, + "version": "1.4.2" + }, + "autopep8-1.4.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "228bb43b4c2935ee84e06da5acaf30fb", + "name": "autopep8", + "sha256": "a2994612d4b7191677e41d2f7f359712b5b596d927c5816387d328ab3e8358f6", + "size": 74477, + "subdir": "linux-64", + "timestamp": 1542075859270, + "version": "1.4.3" + }, + "autopep8-1.4.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16d8a5dfe367bb4a83347e8239867005", + "name": "autopep8", + "sha256": "63f156ac7a99f9b9fee5ab8900e636c126ad91c5a5875262399955dbc3afda31", + "size": 74378, + "subdir": "linux-64", + "timestamp": 1542075886294, + "version": "1.4.3" + }, + "autopep8-1.4.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pycodestyle >=2.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71c3bccc2792bf16f2fc3c0f06aecd56", + "name": "autopep8", + "sha256": "0a756ed0ff8e1266438f009015495d2a7576cdc2b24df5beccd3cc113ffbddd3", + "size": 74796, + "subdir": "linux-64", + "timestamp": 1542075837448, + "version": "1.4.3" + }, + "autovizwidget-0.12.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3eae280ca4ab264cdb7dd0d89f3b4404", + "name": "autovizwidget", + "sha256": "31a6ec5fbaf1b0d1b5752c1aaf563fad9bfc0f06e58b8cce45b950ba10ea3b80", + "size": 21452, + "subdir": "linux-64", + "timestamp": 1530738796573, + "version": "0.12.5" + }, + "autovizwidget-0.12.5-py27h255d36a_0.conda": { + "build": "py27h255d36a_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a3f1528b1fa2e07b0999eadba8214814", + "name": "autovizwidget", + "sha256": "beaccf3207401569faea437b8ac9002acb32eeeecb3bde7426b61faffbe23cc2", + "size": 21752, + "subdir": "linux-64", + "timestamp": 1511838190576, + "version": "0.12.5" + }, + "autovizwidget-0.12.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6784f77c81c07a04ffc2e928608ce253", + "name": "autovizwidget", + "sha256": "012335050527e5f5c2a0cdeb50373a6f3c6a8b8d8075063da56e04bc1e24f0c0", + "size": 22027, + "subdir": "linux-64", + "timestamp": 1534355244029, + "version": "0.12.5" + }, + "autovizwidget-0.12.5-py35h67041e2_0.conda": { + "build": "py35h67041e2_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "537e503fc3de5231e66fb8103b28f2d8", + "name": "autovizwidget", + "sha256": "575a30227b2eccf742b9fc4a46fd15a4f6ece3028c274d6ce71c31352a3dbcf4", + "size": 22258, + "subdir": "linux-64", + "timestamp": 1511838206082, + "version": "0.12.5" + }, + "autovizwidget-0.12.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "84d70767d665c3f60c99838f5c22eaf0", + "name": "autovizwidget", + "sha256": "3c264234bde6c757c81afc7489cd6076348318304a30b1f4a49ccbb87a0afa48", + "size": 21861, + "subdir": "linux-64", + "timestamp": 1530738762062, + "version": "0.12.5" + }, + "autovizwidget-0.12.5-py36hb2c7800_0.conda": { + "build": "py36hb2c7800_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c2bbad242dff3c1fd594143bda3b7d43", + "name": "autovizwidget", + "sha256": "323d67ebd45710155b83ff79d69b4c21b3c8881cd0d0109047ea3a73db1e1b7f", + "size": 22159, + "subdir": "linux-64", + "timestamp": 1511838205022, + "version": "0.12.5" + }, + "autovizwidget-0.12.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "947f7c2d9ccdd5d49cbb4302d409db95", + "name": "autovizwidget", + "sha256": "7623a08338c6b009e0f3c6d426bbefe5913d69dcc2faf58fc070d7be9b9732b3", + "size": 21898, + "subdir": "linux-64", + "timestamp": 1530738836491, + "version": "0.12.5" + }, + "autovizwidget-0.12.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "975ce0ea6c6193e77d7ddf6a4fb741cc", + "name": "autovizwidget", + "sha256": "728969db6762771e92104e8aad389e8df8f8c64bd411de1da5c674233f55be9a", + "size": 21867, + "subdir": "linux-64", + "timestamp": 1539467289600, + "version": "0.12.6" + }, + "autovizwidget-0.12.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7f3584e51eefe9ed5b3b7f37c3b5462b", + "name": "autovizwidget", + "sha256": "1a2ac2ce07487f04326f7047209778e6d591f73a70461734581d8889e8bbd3e1", + "size": 22310, + "subdir": "linux-64", + "timestamp": 1539467326133, + "version": "0.12.6" + }, + "autovizwidget-0.12.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6.0", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "plotly", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "de16171ac2bd3f7088ed321dc7fad923", + "name": "autovizwidget", + "sha256": "40d0efd72947143f8f41c2acfccf6b4e35e33dfb2d2e1dce8f157014ac517408", + "size": 22300, + "subdir": "linux-64", + "timestamp": 1539467304610, + "version": "0.12.6" + }, + "autovizwidget-0.20.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6", + "ipywidgets >5.0.0", + "notebook >=4.2", + "pandas >=0.20.1", + "plotly >=3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "45e3c658a1defec5d412ade1ae3dc126", + "name": "autovizwidget", + "sha256": "76d2b0023ed693b1e320189bfeaa2ab66c6967a6c7f343ae8e45890b7be5c9ba", + "size": 27746, + "subdir": "linux-64", + "timestamp": 1663056656414, + "version": "0.20.0" + }, + "autovizwidget-0.20.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6", + "ipywidgets >5.0.0", + "notebook >=4.2", + "pandas >=0.20.1", + "plotly >=3", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "29ee9fcc4e05656a24ea6035df704ce2", + "name": "autovizwidget", + "sha256": "4e3e2dbfaa60fe7d1f7277276e90a285201cdf0708c08a5919437c70920e1dae", + "size": 34135, + "subdir": "linux-64", + "timestamp": 1676843295615, + "version": "0.20.0" + }, + "autovizwidget-0.20.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6", + "ipywidgets >5.0.0", + "notebook >=4.2", + "pandas >=0.20.1", + "plotly >=3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a7f0b160f02c6561f55eacc415f0e2fe", + "name": "autovizwidget", + "sha256": "6394e7a32693474b3adcd07670b0d1d49ddf664909759b6434fb5275116c0665", + "size": 27276, + "subdir": "linux-64", + "timestamp": 1663056722832, + "version": "0.20.0" + }, + "autovizwidget-0.20.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6", + "ipywidgets >5.0.0", + "notebook >=4.2", + "pandas >=0.20.1", + "plotly >=3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a5f891c193ee655cac126c326eef8f14", + "name": "autovizwidget", + "sha256": "6718d102632b1909184b23f5a2586bec51bad3fb51129c88f0a1bb4c6c8b57e3", + "size": 27467, + "subdir": "linux-64", + "timestamp": 1663056779490, + "version": "0.20.0" + }, + "autovizwidget-0.20.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "hdijupyterutils >=0.6", + "ipywidgets >5.0.0", + "notebook >=4.2", + "pandas >=0.20.1", + "plotly >=3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8e9413a3530bf5cd2486e679831be80c", + "name": "autovizwidget", + "sha256": "b00062fb0d37657c042544c75e20340774c4ecc54ee36966d2df01d0af552bb8", + "size": 27469, + "subdir": "linux-64", + "timestamp": 1663056838075, + "version": "0.20.0" + }, + "aws-c-common-0.4.57-he6710b0_1.conda": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4edfe93fe0082848136baf678cc0fb5c", + "name": "aws-c-common", + "sha256": "89587577e2319d5bc225d48d303848b18d60a31ed31b9e5aa2cfe02bb63ec4f4", + "size": 159587, + "subdir": "linux-64", + "timestamp": 1601398346279, + "version": "0.4.57" + }, + "aws-c-common-0.4.58-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3d2084675511e2739152628f3c28060d", + "name": "aws-c-common", + "sha256": "e00c810a287af64fccbe1867eff79c58ae6845526955fc27f9b9b2304c7241d0", + "size": 161333, + "subdir": "linux-64", + "timestamp": 1601487531644, + "version": "0.4.58" + }, + "aws-c-common-0.4.59-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5841cc1ea5eb4c2dbc58698c700a2c52", + "name": "aws-c-common", + "sha256": "14f62299cc021fa7cc3760df7254551bd9dd04ddd2f86df3e66c8ea5f2440a3f", + "size": 159085, + "subdir": "linux-64", + "timestamp": 1601494937544, + "version": "0.4.59" + }, + "aws-c-common-0.4.63-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "30950f12a9fcd2cfccbf2afde0e23304", + "name": "aws-c-common", + "sha256": "f0b8d0ef5503eb6a52613aa31c25958689786f39189a0b9566dc55e2eaf46ad0", + "size": 161285, + "subdir": "linux-64", + "timestamp": 1607533685043, + "version": "0.4.63" + }, + "aws-c-common-0.4.65-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d26cff6ec46303bd7754515f56b9fa1f", + "name": "aws-c-common", + "sha256": "8d12085acf78505c19d084169ffa434ddec4aeb437c9115f83d139311f9d42c1", + "size": 166495, + "subdir": "linux-64", + "timestamp": 1612239590013, + "version": "0.4.65" + }, + "aws-c-common-0.4.67-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1d02c481f75f984be04e32b14dce25dd", + "name": "aws-c-common", + "sha256": "3ca1b42236f0185c97ad26550e164366ec5f86bc5e93fd29f3c53e313e239101", + "size": 166451, + "subdir": "linux-64", + "timestamp": 1613246373585, + "version": "0.4.67" + }, + "aws-c-common-0.4.68-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "69adbc90792b9de67b02996dde4bb586", + "name": "aws-c-common", + "sha256": "7b94f515d6140146aa1996251ff66a404db5108a5003c40d586fe0e7b448f493", + "size": 164309, + "subdir": "linux-64", + "timestamp": 1613500960907, + "version": "0.4.68" + }, + "aws-c-common-0.5.1-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fb8d3341ad3885a6d388d87e8d4fe14c", + "name": "aws-c-common", + "sha256": "ae5ba3a6340a2dd96dc40cbd2970677d36f4a54412bf74a1e503be2c500b8ba3", + "size": 168174, + "subdir": "linux-64", + "timestamp": 1614020190484, + "version": "0.5.1" + }, + "aws-c-common-0.5.10-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2f6454abb37323840efe00b41b382a34", + "name": "aws-c-common", + "sha256": "898f007232aa0b81d989eb7f69b3c2c54670119d16cfc26d3b3b1d421e475bf2", + "size": 167560, + "subdir": "linux-64", + "timestamp": 1620169320584, + "version": "0.5.10" + }, + "aws-c-common-0.5.11-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f8c573b2d33aa208fddcb9aca1141b12", + "name": "aws-c-common", + "sha256": "3e576248c64b0b12c8d97cbdfcab0c28d67ae49c3497d9bdf9b41f135c33109a", + "size": 166698, + "subdir": "linux-64", + "timestamp": 1620309041499, + "version": "0.5.11" + }, + "aws-c-common-0.5.2-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "99a58b26d3e963230b711c66e5c40559", + "name": "aws-c-common", + "sha256": "8ee91883d4c331136093493ca617f118189905b196bedde4315d89ea3e12d364", + "size": 165465, + "subdir": "linux-64", + "timestamp": 1614967949195, + "version": "0.5.2" + }, + "aws-c-common-0.5.4-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "45a48a6f874058d43d8b079e0aa5b0a9", + "name": "aws-c-common", + "sha256": "b42e074a5cc2cb0022e86bbcc3064103aa1f06cdcca907bee5110983be1eba7c", + "size": 165929, + "subdir": "linux-64", + "timestamp": 1617985051193, + "version": "0.5.4" + }, + "aws-c-common-0.5.6-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d020bbc63b42a4de7f7b1707faeab014", + "name": "aws-c-common", + "sha256": "a95e2bd07301c81d961fc23fdf985b003a51d957b20eab0e439fbe98d8406f16", + "size": 168969, + "subdir": "linux-64", + "timestamp": 1618693677487, + "version": "0.5.6" + }, + "aws-c-common-0.5.7-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "128326939151095b85bc8554db12a699", + "name": "aws-c-common", + "sha256": "1aedfb34b24bf54908498fc477326078d4f1f79241c38ff19a4651bee1c89962", + "size": 167315, + "subdir": "linux-64", + "timestamp": 1618953284138, + "version": "0.5.7" + }, + "aws-c-common-0.5.8-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3090dd204208d62d1bd22239d64df0bb", + "name": "aws-c-common", + "sha256": "6da2a9f6e2899364290ae9af0ef4cee1f58c70c465a6be908303342b6355650b", + "size": 167443, + "subdir": "linux-64", + "timestamp": 1619475184698, + "version": "0.5.8" + }, + "aws-c-common-0.6.1-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "824f13b7dd70f590fe3c40a2a3e9893d", + "name": "aws-c-common", + "sha256": "a12bbaa7524eaacb0bc251e7618a80dff7fec93c176b560e2dbe3c2fd96d8275", + "size": 169494, + "subdir": "linux-64", + "timestamp": 1623317369463, + "version": "0.6.1" + }, + "aws-c-common-0.6.2-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eaf1e5d51fb1a3610b2507449627b462", + "name": "aws-c-common", + "sha256": "c5578ccc799e08a6a000c459c60d3878f5db079eaf59f000e7ece02883f26818", + "size": 168439, + "subdir": "linux-64", + "timestamp": 1623861534141, + "version": "0.6.2" + }, + "aws-c-common-0.6.5-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4a01b5ec940db55aeef37414659ac887", + "name": "aws-c-common", + "sha256": "b38b537509a729075580e01a4ad67711316eff402eebbe45d4e671793ec9e34f", + "size": 168468, + "subdir": "linux-64", + "timestamp": 1625077054778, + "version": "0.6.5" + }, + "aws-c-common-0.6.8-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "afe5492d1f56f8469422b6f28c075046", + "name": "aws-c-common", + "sha256": "aa5b3d836158aa6e2f6317baa069a29add9bbb62cb8cdb94319e12b706bf1d3d", + "size": 169602, + "subdir": "linux-64", + "timestamp": 1626499836370, + "version": "0.6.8" + }, + "aws-c-event-stream-0.1.6-h2531618_5.conda": { + "build": "h2531618_5", + "build_number": 5, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-checksums >=0.1.9,<0.1.10.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9f79cc0162f2605f1ee11c3f209aa1b6", + "name": "aws-c-event-stream", + "sha256": "244accbf9cfeee6f41723d6706751a3f94dd0d1b516d1788c354a02c69425682", + "size": 25186, + "subdir": "linux-64", + "timestamp": 1603894551837, + "version": "0.1.6" + }, + "aws-c-event-stream-0.1.6-he6710b0_3.conda": { + "build": "he6710b0_3", + "build_number": 3, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-checksums >=0.1.9,<0.1.10.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e776f073010ab2b1a3e3f908d6d910f1", + "name": "aws-c-event-stream", + "sha256": "149143efd663403cc1b4afe6673bb083f0a6689fa3385fae1a9785804c07b134", + "size": 26165, + "subdir": "linux-64", + "timestamp": 1601398726771, + "version": "0.1.6" + }, + "aws-checksums-0.1.10-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.59,<0.4.60.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "df4ca6736fa3b5a452ecee1c68777002", + "name": "aws-checksums", + "sha256": "4de1676064eb2388f6b2ac165d352d4915c13a7b4e5c89acd9fbb827f5c19dcb", + "size": 48910, + "subdir": "linux-64", + "timestamp": 1607110350008, + "version": "0.1.10" + }, + "aws-checksums-0.1.11-h27cfd23_1.conda": { + "build": "h27cfd23_1", + "build_number": 1, + "depends": [ + "aws-c-common >=0.4.65,<0.4.66.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b93de7d7a35aec65f5aeba221eaac556", + "name": "aws-checksums", + "sha256": "ac1caffac7908e1bf3e7ab7427af8eb9230645a3c65ae174f33bdf5e52bea69e", + "size": 48739, + "subdir": "linux-64", + "timestamp": 1613246541923, + "version": "0.1.11" + }, + "aws-checksums-0.1.9-h2531618_2.conda": { + "build": "h2531618_2", + "build_number": 2, + "depends": [ + "aws-c-common >=0.4.59,<0.4.60.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "99a66393b908f715c1a9f151e09a6922", + "name": "aws-checksums", + "sha256": "a7e5ab4834acb8121a8b60814d87af41b6b8f037356a71e87f5f37e4847820e8", + "size": 48796, + "subdir": "linux-64", + "timestamp": 1603894579237, + "version": "0.1.9" + }, + "aws-checksums-0.1.9-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fa91fe9b59c45256bdb531f6dfb4905a", + "name": "aws-checksums", + "sha256": "a6edb1233d2511b1e6615cf8fbb93b672ce6b5bff9245c367c766eb2c8437038", + "size": 49751, + "subdir": "linux-64", + "timestamp": 1601398555928, + "version": "0.1.9" + }, + "aws-sam-translator-1.22.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto3 >=1.5,<2.0a0", + "jsonschema >=3.0,<4.0a0", + "python >=3.6,<3.7.0a0", + "six >=1.11,<2.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "153530c4255ef3cd44c1b7eb3227efa8", + "name": "aws-sam-translator", + "sha256": "0775d19c2b1583595262e9f8992247e849bd89dd1449decd349ecce5300fead8", + "size": 202294, + "subdir": "linux-64", + "timestamp": 1588567745413, + "version": "1.22.0" + }, + "aws-sam-translator-1.22.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "boto3 >=1.5,<2.0a0", + "jsonschema >=3.0,<4.0a0", + "python >=3.7,<3.8.0a0", + "six >=1.11,<2.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c2286bcc43f59d6c6bdd25e34e4a1a55", + "name": "aws-sam-translator", + "sha256": "42ab29e90e5231fb0b5aa9d3732d78968048ae92c4be729b6f1f1d16a044cc82", + "size": 202896, + "subdir": "linux-64", + "timestamp": 1588567749755, + "version": "1.22.0" + }, + "aws-sam-translator-1.22.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "boto3 >=1.5,<2.0a0", + "jsonschema >=3.0,<4.0a0", + "python >=3.8,<3.9.0a0", + "six >=1.11,<2.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "841b833e95afcab904175eec1c79f38c", + "name": "aws-sam-translator", + "sha256": "f7b510dc78ad6bb3f9df024c8a90c7dd7a9679359626d34ccdbb7fce2b5cdf91", + "size": 205607, + "subdir": "linux-64", + "timestamp": 1588567762245, + "version": "1.22.0" + }, + "aws-sdk-cpp-1.8.127-h9ba82fa_0.conda": { + "build": "h9ba82fa_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9ea542b1854a7b5f810caf5f1cc74e5a", + "name": "aws-sdk-cpp", + "sha256": "abd957f44f85146b88afd66df9826b18702099cad693f972858048183560e91f", + "size": 1966713, + "subdir": "linux-64", + "timestamp": 1611188588916, + "version": "1.8.127" + }, + "aws-sdk-cpp-1.8.129-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "840fe090e62e9e10a46d06b1583e9cb3", + "name": "aws-sdk-cpp", + "sha256": "0617214ef36b93b8011b2cf40aa2f54d06a53da50a5af93f99ecdf4ace2e5d6b", + "size": 1960648, + "subdir": "linux-64", + "timestamp": 1611513718014, + "version": "1.8.129" + }, + "aws-sdk-cpp-1.8.130-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ac4050ac3267c2bbb4718c97e14e6d88", + "name": "aws-sdk-cpp", + "sha256": "db1a54c83d5752afdcfd701372dd66735d171840bb9e46a231af3c5e3268a578", + "size": 1952278, + "subdir": "linux-64", + "timestamp": 1611777004405, + "version": "1.8.130" + }, + "aws-sdk-cpp-1.8.131-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1c296a9b3383f6b7d2715c7d183e7fa3", + "name": "aws-sdk-cpp", + "sha256": "9d10977a8d47083690a0e1594d764473ade1cdb30f70747e3000c047dd65bcc3", + "size": 1956739, + "subdir": "linux-64", + "timestamp": 1611863590230, + "version": "1.8.131" + }, + "aws-sdk-cpp-1.8.132-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a9f6de2e0a045da56398537d817f2269", + "name": "aws-sdk-cpp", + "sha256": "6ed29a74ad9df8ed80aa3a3c651db1df499e5285c642b35b9407898cf97d2d03", + "size": 1960691, + "subdir": "linux-64", + "timestamp": 1611949858248, + "version": "1.8.132" + }, + "aws-sdk-cpp-1.8.133-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4101fed9a4248bef447097df69f0c7da", + "name": "aws-sdk-cpp", + "sha256": "d209a21439c6c0103fd011caaa868c0249fb7d7795e9113ecf0d451f96968988", + "size": 1960860, + "subdir": "linux-64", + "timestamp": 1612239824541, + "version": "1.8.133" + }, + "aws-sdk-cpp-1.8.141-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e592763a6847a9981145c00ce04857ed", + "name": "aws-sdk-cpp", + "sha256": "c5aa8b4372731e87ea4b740c86f3bb0302f68cfa8626be68593817c27b325417", + "size": 1956102, + "subdir": "linux-64", + "timestamp": 1613246694772, + "version": "1.8.141" + }, + "aws-sdk-cpp-1.8.142-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7f6e04ac55020277feeae24ac16457b4", + "name": "aws-sdk-cpp", + "sha256": "e544ddb0c9d2b80e29514a3f073f4a14138964e492dc578dbfc889ded818e213", + "size": 1959199, + "subdir": "linux-64", + "timestamp": 1613501139694, + "version": "1.8.142" + }, + "aws-sdk-cpp-1.8.143-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "82e0cebf4877ea32354696a428fe08ec", + "name": "aws-sdk-cpp", + "sha256": "73f6263e84984d35b7d21eb12c3a732aa265dd562b7ab1ef0b22033666917ba9", + "size": 1956072, + "subdir": "linux-64", + "timestamp": 1613587349285, + "version": "1.8.143" + }, + "aws-sdk-cpp-1.8.144-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c414979f12a01732450908fb64ca39bc", + "name": "aws-sdk-cpp", + "sha256": "25d97332d5fb8b26dc3b9c51d4ed1e8dbe63d64e15d0f672e2baa9801041e229", + "size": 1955481, + "subdir": "linux-64", + "timestamp": 1613674514053, + "version": "1.8.144" + }, + "aws-sdk-cpp-1.8.145-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2e10ae98c2d849ebae8b47e135230d3e", + "name": "aws-sdk-cpp", + "sha256": "a3139b45c2c0db769eefe135aa605dabc6ee2da358fc4a74680467ff20c6bd84", + "size": 1962211, + "subdir": "linux-64", + "timestamp": 1613761800639, + "version": "1.8.145" + }, + "aws-sdk-cpp-1.8.146-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b2b7e498e0b9baf2fad8f3c93cb31b22", + "name": "aws-sdk-cpp", + "sha256": "17ae4896c06565d8c475968bdc99169b55db0f0944913d47307de37e95941df9", + "size": 1962249, + "subdir": "linux-64", + "timestamp": 1613847396713, + "version": "1.8.146" + }, + "aws-sdk-cpp-1.8.150-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "77dd0065e63c5eba1d14f3345a2a2165", + "name": "aws-sdk-cpp", + "sha256": "5571729b7028d58f1586ea846e6e57f72c152e059f2768f2dc00bccdd3f5b5f0", + "size": 1962150, + "subdir": "linux-64", + "timestamp": 1614361534872, + "version": "1.8.150" + }, + "aws-sdk-cpp-1.8.151-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d500f300a695df45afed4c63f201112e", + "name": "aws-sdk-cpp", + "sha256": "a7cc1387dd9d5c3716378958ed37139a866170d485122c6178afbb1e538eef53", + "size": 1958349, + "subdir": "linux-64", + "timestamp": 1614614536394, + "version": "1.8.151" + }, + "aws-sdk-cpp-1.8.152-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e3e047b3accbf4267b628991703d84bd", + "name": "aws-sdk-cpp", + "sha256": "ad80bf1d614828205d6aa07617b05809c49bde259b3e05d5ab0c812c8a72c3b4", + "size": 1954857, + "subdir": "linux-64", + "timestamp": 1614709161690, + "version": "1.8.152" + }, + "aws-sdk-cpp-1.8.153-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ffbf5f1496becacd1712f2852549573b", + "name": "aws-sdk-cpp", + "sha256": "e746822a298ef1f645d48e892834af9743bb101b107f50251cb9dccd6b0efe66", + "size": 1966841, + "subdir": "linux-64", + "timestamp": 1614794705382, + "version": "1.8.153" + }, + "aws-sdk-cpp-1.8.154-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "75fc83692b9b8e580aa92d32fa832816", + "name": "aws-sdk-cpp", + "sha256": "d7d4e38661279d04e14586b8b464be6387be91c735aa5e678e232d4c5599c1c0", + "size": 1964380, + "subdir": "linux-64", + "timestamp": 1614882586233, + "version": "1.8.154" + }, + "aws-sdk-cpp-1.8.155-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "50faa851721b7f3c308c9a5b799c7b26", + "name": "aws-sdk-cpp", + "sha256": "9ed6d48423ce803390881ce88c2c5976a44d5b45cfba89b28176c4b11a6c86df", + "size": 1963062, + "subdir": "linux-64", + "timestamp": 1614968105969, + "version": "1.8.155" + }, + "aws-sdk-cpp-1.8.156-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "17eba798dbdd5f2b1090dd5ae65099fc", + "name": "aws-sdk-cpp", + "sha256": "9eabb5ca34045852e579d750374564f83794eb6d47e2327e47e1070268bca539", + "size": 1963256, + "subdir": "linux-64", + "timestamp": 1615054861731, + "version": "1.8.156" + }, + "aws-sdk-cpp-1.8.157-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "87885846debcd6ee8ee5ecd1e485b6b0", + "name": "aws-sdk-cpp", + "sha256": "0fa4ed10cfd2ff1bd8c59db403d7a3f462439d80528538b8cf65ab2e7a288e6c", + "size": 1958359, + "subdir": "linux-64", + "timestamp": 1615314875909, + "version": "1.8.157" + }, + "aws-sdk-cpp-1.8.159-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a940496826c11208a6f48e060da90f7b", + "name": "aws-sdk-cpp", + "sha256": "c0b55bbe960bb2016cb6106babbddeaf37f1e7ad8580eb0dc23acc2cf40cb827", + "size": 1956765, + "subdir": "linux-64", + "timestamp": 1615411469097, + "version": "1.8.159" + }, + "aws-sdk-cpp-1.8.161-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "60522488023a4a1cea46edc0e32fe14c", + "name": "aws-sdk-cpp", + "sha256": "efe7b56bcdbcd93c137648af55af9910331acd2ce2c3d35b540e89ebaf066b13", + "size": 1975226, + "subdir": "linux-64", + "timestamp": 1615661073307, + "version": "1.8.161" + }, + "aws-sdk-cpp-1.8.162-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "25288132e06500847b61d2419e017599", + "name": "aws-sdk-cpp", + "sha256": "6bda57dd0f1844d8f887698be953889b64b692503ad0e2c07dea333ee80c6e29", + "size": 1970572, + "subdir": "linux-64", + "timestamp": 1615920922679, + "version": "1.8.162" + }, + "aws-sdk-cpp-1.8.163-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8feecc47c510eca881fa7a37eb5e03c7", + "name": "aws-sdk-cpp", + "sha256": "1d5af74f7a40b1b7b3fd77fe7e9acd4abd90ab5f7421260fec27419db8fde675", + "size": 1968499, + "subdir": "linux-64", + "timestamp": 1616005462218, + "version": "1.8.163" + }, + "aws-sdk-cpp-1.8.164-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d42785a63e9b0afddf4c03e388d62543", + "name": "aws-sdk-cpp", + "sha256": "4a2a24df84c1e4ce97c23fe02a0570e6875803eecb0876c8b9c541cb6307bbf6", + "size": 1968473, + "subdir": "linux-64", + "timestamp": 1616091882324, + "version": "1.8.164" + }, + "aws-sdk-cpp-1.8.165-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cd3bb4d79485d5b99b078ddafeb1c9f0", + "name": "aws-sdk-cpp", + "sha256": "8040e826f22dff1dcd516fa3c08bac653e88dfb3d63529ac0abee2571d1e7268", + "size": 1983473, + "subdir": "linux-64", + "timestamp": 1616180530648, + "version": "1.8.165" + }, + "aws-sdk-cpp-1.8.166-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ac52196b7fb68ef749f83a2852fd787e", + "name": "aws-sdk-cpp", + "sha256": "93ce7df302ce3c2294b1b01d4c23a15932d1d1676a096f490ed505bb5900c9cf", + "size": 1980038, + "subdir": "linux-64", + "timestamp": 1616268668583, + "version": "1.8.166" + }, + "aws-sdk-cpp-1.8.167-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2779584c88a5f2911211bac8adc4fa7b", + "name": "aws-sdk-cpp", + "sha256": "73178037f11b266e12ba97e7dd59bbd48f0e46ae407a80c080982073d05a3ee2", + "size": 1980167, + "subdir": "linux-64", + "timestamp": 1616442952944, + "version": "1.8.167" + }, + "aws-sdk-cpp-1.8.168-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2f74661a7e51593a15e59c678c126d3f", + "name": "aws-sdk-cpp", + "sha256": "587d16bc770b1fed2507d88f4c5f964f2baaff36ff22f13719da071c81e64d65", + "size": 1985204, + "subdir": "linux-64", + "timestamp": 1616527611609, + "version": "1.8.168" + }, + "aws-sdk-cpp-1.8.169-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f2db899c1fb47ecc421f202be8189004", + "name": "aws-sdk-cpp", + "sha256": "f8fe14f726a9597afd994d48a9150538964dd25686e7ebc6097524f5a1739d8f", + "size": 1978060, + "subdir": "linux-64", + "timestamp": 1616614410991, + "version": "1.8.169" + }, + "aws-sdk-cpp-1.8.170-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "435b8e69f6999536f67e339a52daedfd", + "name": "aws-sdk-cpp", + "sha256": "0c97424b1c93500c8283a5a9ba3a5b8d1f2f9e1158246d95f41f40e823775dd5", + "size": 1983554, + "subdir": "linux-64", + "timestamp": 1616700856358, + "version": "1.8.170" + }, + "aws-sdk-cpp-1.8.173-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b5ec59ebd96646846c4e29534550ef23", + "name": "aws-sdk-cpp", + "sha256": "658a007117b120298e58957ca327a2e3fcaedadb3970b92f073cd865267c7299", + "size": 1986554, + "subdir": "linux-64", + "timestamp": 1617117080646, + "version": "1.8.173" + }, + "aws-sdk-cpp-1.8.174-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9af2a189618d1cda6c0d44fe20222882", + "name": "aws-sdk-cpp", + "sha256": "99067845c0b52a8c41026b4381d675cc5d62696bc17d3237e827a9a540bc910d", + "size": 2000119, + "subdir": "linux-64", + "timestamp": 1617133484311, + "version": "1.8.174" + }, + "aws-sdk-cpp-1.8.175-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4a1864d897c15723d76378b4c91400fb", + "name": "aws-sdk-cpp", + "sha256": "d9f96dd3204a32c9d6bcbcc1dfe8f41bdccb5a7ae1d83bcd1d3e0be24c6628e7", + "size": 2001518, + "subdir": "linux-64", + "timestamp": 1617221600812, + "version": "1.8.175" + }, + "aws-sdk-cpp-1.8.176-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a1ed1a075070e82ed79f38de29e9752a", + "name": "aws-sdk-cpp", + "sha256": "18e5112b783f3634e92796b9e983fe8a9c18c318d12994cfc028774e2df29491", + "size": 1994441, + "subdir": "linux-64", + "timestamp": 1617383733578, + "version": "1.8.176" + }, + "aws-sdk-cpp-1.8.177-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8cdc8ea2a51f1a9d0bf861f3fae6238e", + "name": "aws-sdk-cpp", + "sha256": "4e7229657b68c72455f88069575fad6560cdf4103fe39e9017524acd87377f3f", + "size": 1996188, + "subdir": "linux-64", + "timestamp": 1617394251848, + "version": "1.8.177" + }, + "aws-sdk-cpp-1.8.181-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2439f61294bb99370305e72c8247814b", + "name": "aws-sdk-cpp", + "sha256": "ff6a35050bf0b9fa1a328762247593590c98eda8849e54b1a6ebeae0f592f8fe", + "size": 1997914, + "subdir": "linux-64", + "timestamp": 1617915978251, + "version": "1.8.181" + }, + "aws-sdk-cpp-1.8.182-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e8be34407231c8b09e88e5ab77296346", + "name": "aws-sdk-cpp", + "sha256": "f09af880fe7a9f071a6223f340bad341f0e6ec964d66df190b7f08487e6f1b70", + "size": 2001229, + "subdir": "linux-64", + "timestamp": 1618000607417, + "version": "1.8.182" + }, + "aws-sdk-cpp-1.8.183-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6388d6dbf93b243dedd3700b46b236a4", + "name": "aws-sdk-cpp", + "sha256": "f8fe539d4938b44324097729854424ce247610fdefece22204bd127cc94254f3", + "size": 1994853, + "subdir": "linux-64", + "timestamp": 1618262047782, + "version": "1.8.183" + }, + "aws-sdk-cpp-1.8.184-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b70727c12224759716606c7e1d799de7", + "name": "aws-sdk-cpp", + "sha256": "491a097c861256a76463dd6198332e50d9ff12c1e73a8910b9971a4a393f03db", + "size": 1996795, + "subdir": "linux-64", + "timestamp": 1618345401900, + "version": "1.8.184" + }, + "aws-sdk-cpp-1.8.185-hce553d0_0.conda": { + "build": "hce553d0_0", + "build_number": 0, + "depends": [ + "aws-c-common >=0.4.57,<0.4.58.0a0", + "aws-c-event-stream >=0.1.6,<0.1.7.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "07ad3e020a18d1204d777588a4153426", + "name": "aws-sdk-cpp", + "sha256": "73c243e776a83e7d25548f3761d19388e90b37ceeb5f81cee0036c357480d774", + "size": 1997226, + "subdir": "linux-64", + "timestamp": 1618434946994, + "version": "1.8.185" + }, + "aws-xray-sdk-2.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "enum34", + "future", + "jsonpickle", + "python >=2.7,<2.8.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "2a0b75158c9d19aa857524cd9ed1a5d3", + "name": "aws-xray-sdk", + "sha256": "55b69d4afd00d69408fabda209f8c142086b683c92ff0b1b20928c417459bc7a", + "size": 108813, + "subdir": "linux-64", + "timestamp": 1552375046903, + "version": "2.4.2" + }, + "aws-xray-sdk-2.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "jsonpickle", + "python >=3.6,<3.7.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "3e46af444c4843f7b6cbe015e230c266", + "name": "aws-xray-sdk", + "sha256": "480117d4169e55c14947881f02f88237d363856b05b2a36bd7dc7aa5735a5cf3", + "size": 112225, + "subdir": "linux-64", + "timestamp": 1552375124960, + "version": "2.4.2" + }, + "aws-xray-sdk-2.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "jsonpickle", + "python >=3.7,<3.8.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "8ca1374b144a8cfe8154686878aafae8", + "name": "aws-xray-sdk", + "sha256": "13d6f2f023f6c31424ee7593b468b613768dc7c34ece9d4ee5e63521a6be3de4", + "size": 113779, + "subdir": "linux-64", + "timestamp": 1552375068425, + "version": "2.4.2" + }, + "aws-xray-sdk-2.4.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "jsonpickle", + "python >=3.8,<3.9.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "9c0b87720920ea07c2944b8905869d92", + "name": "aws-xray-sdk", + "sha256": "1c653f713fbd7c7a7328299ed6c94f02957849bea70bd97bee4980fa8fc96bad", + "size": 116119, + "subdir": "linux-64", + "timestamp": 1574237367538, + "version": "2.4.2" + }, + "aws-xray-sdk-2.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "jsonpickle", + "python >=3.6,<3.7.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "1eaf90c579e9930ac5f1116934d0fc46", + "name": "aws-xray-sdk", + "sha256": "4ee5cc5330cda8f4794672924342ba28a740e6591fb1b73d7399d731eaddea0d", + "size": 119346, + "subdir": "linux-64", + "timestamp": 1592209225673, + "version": "2.6.0" + }, + "aws-xray-sdk-2.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "jsonpickle", + "python >=3.7,<3.8.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "ef5e8982c7a0167cbba90cd33bec05b9", + "name": "aws-xray-sdk", + "sha256": "63648dd2905734d9a0fa38663ba4f812931f10952720876d1b3f6fab9af9a272", + "size": 119724, + "subdir": "linux-64", + "timestamp": 1592209049898, + "version": "2.6.0" + }, + "aws-xray-sdk-2.6.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "jsonpickle", + "python >=3.8,<3.9.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "d7d4970291deb68327722717a0c3c732", + "name": "aws-xray-sdk", + "sha256": "ac3a2b8b4b2c212b9085e540c9d7c2f355739ed13f70dbb82f178f74e0be04a2", + "size": 119773, + "subdir": "linux-64", + "timestamp": 1592209221502, + "version": "2.6.0" + }, + "aws-xray-sdk-2.8.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "python >=3.10,<3.11.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "329006670e766c9d9d18b5951de75fc7", + "name": "aws-xray-sdk", + "sha256": "00ee04525a1ca2dd8bb77998c3a30c2fda74ec8642b9faf4cbe394309151c804", + "size": 124632, + "subdir": "linux-64", + "timestamp": 1642519393864, + "version": "2.8.0" + }, + "aws-xray-sdk-2.8.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "python >=3.11,<3.12.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "87f1810bf01628f1270e7ca434a2191d", + "name": "aws-xray-sdk", + "sha256": "80f7d24821eeb0f19f40fe45650829a50c74b44e2fe9e4bfc334676f4d7265ae", + "size": 160363, + "subdir": "linux-64", + "timestamp": 1676843310393, + "version": "2.8.0" + }, + "aws-xray-sdk-2.8.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "python >=3.6,<3.7.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "1a88bafed40e1d76a94b24418e9323bd", + "name": "aws-xray-sdk", + "sha256": "d27a2d240b34b4b41d06f63fe209b07d0e3b22c3610a89af3c5704a18f7e5377", + "size": 124253, + "subdir": "linux-64", + "timestamp": 1621941891593, + "version": "2.8.0" + }, + "aws-xray-sdk-2.8.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "python >=3.7,<3.8.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a82a9ee0f2716b4562753aa4a901daf3", + "name": "aws-xray-sdk", + "sha256": "b619b4c98f1be4bedf12c128fae95096ab144ce40eff34d7d6f2f725bd2a041d", + "size": 123904, + "subdir": "linux-64", + "timestamp": 1621946787074, + "version": "2.8.0" + }, + "aws-xray-sdk-2.8.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "python >=3.8,<3.9.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "af56f87873e4eac42fe22d446de90e99", + "name": "aws-xray-sdk", + "sha256": "7d62bbf44dfe7c672eb7ffcf5debd73ff3cd0b884f7b7fe772c5c3648787c488", + "size": 123277, + "subdir": "linux-64", + "timestamp": 1621946537491, + "version": "2.8.0" + }, + "aws-xray-sdk-2.8.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.3", + "future", + "python >=3.9,<3.10.0a0", + "setuptools", + "wrapt" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b3efbc9ca704dd0726ea6908dadf7477", + "name": "aws-xray-sdk", + "sha256": "55615176f41b522be2f2681f49aab261dd367195c0afbf859009afa97e76a813", + "size": 125156, + "subdir": "linux-64", + "timestamp": 1621946782048, + "version": "2.8.0" + }, + "azure-1.0.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests", + "setuptools" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "0bee648dbfb1d009632f66da2bdc9296", + "name": "azure", + "sha256": "2478c779b59e198118fcf3d81221d2c6fa54218fa39c261bef96ecc8661f783d", + "size": 330058, + "subdir": "linux-64", + "timestamp": 1537285532853, + "version": "1.0.2" + }, + "azure-1.0.2-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests", + "setuptools" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "894ba156e4c2b0fbc7dd4fcf3555223e", + "name": "azure", + "sha256": "cc71abed2510113c7183e20690e66306a3afcbdae803b01948ddd5dd5b4935cf", + "size": 334690, + "subdir": "linux-64", + "timestamp": 1537285499354, + "version": "1.0.2" + }, + "azure-1.0.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests", + "setuptools" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "d9b3ee93d413ba841ad01a1ead003ffb", + "name": "azure", + "sha256": "5fdce04c7fa8186aba6518811b8cddc132c57ca96f6128c2e91832af11a42afe", + "size": 328907, + "subdir": "linux-64", + "timestamp": 1537285535402, + "version": "1.0.2" + }, + "babel-2.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytz >=2015.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1eff25d9f192342c01d960c6bae79c32", + "name": "babel", + "sha256": "f0156d4ec5400fdbd77ece47657beb59022308008105620bf6a4f1d05c61d603", + "size": 7101866, + "subdir": "linux-64", + "timestamp": 1671782043176, + "version": "2.11.0" + }, + "babel-2.11.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "pytz >=2015.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b0e1c6be7b334706670ed7d203b61775", + "name": "babel", + "sha256": "c925e8e13b03c47584aa6a5979df561162c5064c2bb253677db8dd9506dba15c", + "size": 6447775, + "subdir": "linux-64", + "timestamp": 1676825038806, + "version": "2.11.0" + }, + "babel-2.11.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz >=2015.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0406ce0dd56472eb4ade639379a55412", + "name": "babel", + "sha256": "73eadf7c7f7d634381b7bab02af7d484f70c8fc9ae280efca587c97414df0d0d", + "size": 7101905, + "subdir": "linux-64", + "timestamp": 1671781965544, + "version": "2.11.0" + }, + "babel-2.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz >=2015.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4a1f0918ea46c98574a4e5d2341815a6", + "name": "babel", + "sha256": "ed6091d30b6fe6d55ed2a3d39670576080a9ce12fdcd8003f265d9247bca2f05", + "size": 7103198, + "subdir": "linux-64", + "timestamp": 1671782004532, + "version": "2.11.0" + }, + "babel-2.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytz >=2015.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "57afaec3ce18928835e87fa5187ef22c", + "name": "babel", + "sha256": "b472334b4efd78b914d128be191886d6f969c24f72d689fe103bd8a7bab98b6d", + "size": 7102556, + "subdir": "linux-64", + "timestamp": 1671782080890, + "version": "2.11.0" + }, + "babel-2.5.0-py27h20693cd_0.conda": { + "build": "py27h20693cd_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "822251527fce26850109824c48596583", + "name": "babel", + "sha256": "909db7b22fa4d89b54877283e2c521112300220dc918a30223737fccbf2c44a1", + "size": 4411407, + "subdir": "linux-64", + "timestamp": 1505728506605, + "version": "2.5.0" + }, + "babel-2.5.0-py35ha5fc564_0.conda": { + "build": "py35ha5fc564_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "a4c6639c682fb2b2ad51edba7920b997", + "name": "babel", + "sha256": "eacefa205931a53c6a84ace3744698a46bc0646da7925316cb27694a7279a1d5", + "size": 4410268, + "subdir": "linux-64", + "timestamp": 1505728533655, + "version": "2.5.0" + }, + "babel-2.5.0-py36h7d14adf_0.conda": { + "build": "py36h7d14adf_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "097df15c9ec09f6e3632dc3ebd5bb00c", + "name": "babel", + "sha256": "abb82da3dea9810fbd082a77c1398a682a2e6630c8637c50e9ca4d4f9f18c73f", + "size": 4410835, + "subdir": "linux-64", + "timestamp": 1505728560805, + "version": "2.5.0" + }, + "babel-2.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "9cfb10937bfe5cc5042b2d98d9bc095a", + "name": "babel", + "sha256": "031bf88c24ff9eb004fa7c93662817886e26d40679b10ecacce924ee88eb922b", + "size": 4410808, + "subdir": "linux-64", + "timestamp": 1515702580954, + "version": "2.5.1" + }, + "babel-2.5.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "89f9d7bd683261b372cf3ce85bff373b", + "name": "babel", + "sha256": "1fc8acd395aaeed47e8e7bb5da1700e5834a7eed55a19a0ddb99dfba3bfb13ab", + "size": 4409760, + "subdir": "linux-64", + "timestamp": 1515702688520, + "version": "2.5.1" + }, + "babel-2.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "3bca31dffaccd6bddf33fc477c29d722", + "name": "babel", + "sha256": "ad5d6d83492586583e93f5126e9fed94244bd5bf2b6f9fd8411d25baca2bb167", + "size": 4402956, + "subdir": "linux-64", + "timestamp": 1515702538520, + "version": "2.5.1" + }, + "babel-2.5.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "2caa4c94f48fbe73bcc5f276feb837b0", + "name": "babel", + "sha256": "33c2c9285b518b577bca25ff133d98e84fe303e756622a216f2e12f99e386a9e", + "size": 4409129, + "subdir": "linux-64", + "timestamp": 1516378719309, + "version": "2.5.3" + }, + "babel-2.5.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "c23ce77cda627574551620f4b2723f2b", + "name": "babel", + "sha256": "4769a0032301d6c6ef5e6c580d07c59fdd7dfe11a2ee81c5cbc3db732bbbd32e", + "size": 4405990, + "subdir": "linux-64", + "timestamp": 1516378782330, + "version": "2.5.3" + }, + "babel-2.5.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "d0dcbdc74df715758be065b41708d3bd", + "name": "babel", + "sha256": "a2f5cf565ea499b5c97e1ae9fa882b4f06b7cf42456c3d95f2024f6b88ee67a8", + "size": 4402757, + "subdir": "linux-64", + "timestamp": 1516378782334, + "version": "2.5.3" + }, + "babel-2.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "04371cc13e02ddf072b767d5729ccc75", + "name": "babel", + "sha256": "bf26bd905617a844c403a184427c1b1764412a8b76e1832b341e215896a22149", + "size": 5255643, + "subdir": "linux-64", + "timestamp": 1527827831797, + "version": "2.6.0" + }, + "babel-2.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "9343890126d6c2233f53052bf47f5f84", + "name": "babel", + "sha256": "847190eaf2127d83c3df8c0b2f07a9807b61b92bbb10be2b32f4f43d1bd66868", + "size": 5256166, + "subdir": "linux-64", + "timestamp": 1527827839450, + "version": "2.6.0" + }, + "babel-2.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "a3e5b201713a3c666ed27341862f5f63", + "name": "babel", + "sha256": "df1b217e4f8ce43b85ac441fe741aa69cfb6bbc459cb862f18e64a242028f2c1", + "size": 5254001, + "subdir": "linux-64", + "timestamp": 1527827807195, + "version": "2.6.0" + }, + "babel-2.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "23010c55b3e66601f25b945fb9fd7c7d", + "name": "babel", + "sha256": "9ae4996dcf23da4e9235a9f098a004b5973ec13dd745e8a865bea4022d63efb3", + "size": 5251473, + "subdir": "linux-64", + "timestamp": 1530695304357, + "version": "2.6.0" + }, + "backcall-0.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "042c8e91debd8800a64126b4922f6c07", + "name": "backcall", + "sha256": "80449bc2b91faa2ce398b1ecd33e61cec1d39430fea57a33302cb00fc13b36ba", + "size": 20533, + "subdir": "linux-64", + "timestamp": 1522690904215, + "version": "0.1.0" + }, + "backcall-0.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50440eb0518852fb5733224309704ad8", + "name": "backcall", + "sha256": "8401627679c2fb6bbde3196069917675d2fc502ff45317df355931fe8e4e7edc", + "size": 20756, + "subdir": "linux-64", + "timestamp": 1522690911313, + "version": "0.1.0" + }, + "backcall-0.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "711d9a08cf7c053a4d1cb537870c251e", + "name": "backcall", + "sha256": "0c04439996bcfc3a1256877fea595e4beb9f1650787e57d912fc43ca12f017f5", + "size": 20442, + "subdir": "linux-64", + "timestamp": 1522690976979, + "version": "0.1.0" + }, + "backcall-0.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b6b56726b371aa7ba90fa78a75e98e09", + "name": "backcall", + "sha256": "56bac065bbd1680606bf083367cd7a729cc532aec21cd07389cbeadf19b01be0", + "size": 20591, + "subdir": "linux-64", + "timestamp": 1530733699748, + "version": "0.1.0" + }, + "backcall-0.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9d70ca1229f686a7248bee1d2a668598", + "name": "backcall", + "sha256": "38408662f9a57ada1540e2f244aaea3be0f203933deaad61b32b94135c3dfe06", + "size": 21212, + "subdir": "linux-64", + "timestamp": 1572437351326, + "version": "0.1.0" + }, + "backports-1.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "221d61d71da35be5b6b0e29b34619362", + "name": "backports", + "sha256": "18e21d4477f700dfae27f26f5c0304b33ddebc5333ff65a44864fcc73ef1d8c9", + "size": 3958, + "subdir": "linux-64", + "timestamp": 1530737800625, + "version": "1.0" + }, + "backports-1.0-py27h63c9359_1.conda": { + "build": "py27h63c9359_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "2c97c148551816a1883edae8f3e40177", + "name": "backports", + "sha256": "3d6cc1e3fd1a33ef49a0d427baba78e29257c30af8ea422ddac810bdc65b63e7", + "size": 3722, + "subdir": "linux-64", + "timestamp": 1505956835859, + "version": "1.0" + }, + "backports-1.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "45623d68bf2a5cebbc15e5cbce24cafa", + "name": "backports", + "sha256": "58180163eb820753c224d6799a73c253d7b183c1ec30eeba4c22788c90992012", + "size": 3930, + "subdir": "linux-64", + "timestamp": 1534352800109, + "version": "1.0" + }, + "backports-1.0-py35hd471ac7_1.conda": { + "build": "py35hd471ac7_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "55eba6cd2dde2e7b1a3d31ea7cf9eb44", + "name": "backports", + "sha256": "48232fd225996334faa29cef3455ddcb76b6eab1a5df57f6e74d8f59a609eec6", + "size": 3810, + "subdir": "linux-64", + "timestamp": 1505956848475, + "version": "1.0" + }, + "backports-1.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "0d1e3f66c450c6d613f15db6bebc748e", + "name": "backports", + "sha256": "9cb47d92e4752e679d9991c95f8de2072a8eddf33e73b49e564e7cf1bc52dc9c", + "size": 4004, + "subdir": "linux-64", + "timestamp": 1530737780068, + "version": "1.0" + }, + "backports-1.0-py36hfa02d7e_1.conda": { + "build": "py36hfa02d7e_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "3ca8a3e3ce7464abe44a4180f2f45224", + "name": "backports", + "sha256": "7f93ea3704b11b1600ce9f3aac2b1dcf605514df4ddbad759ee3003fa070afaa", + "size": 3802, + "subdir": "linux-64", + "timestamp": 1505956861253, + "version": "1.0" + }, + "backports-1.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "ae74e43ebbaba25bd614c9efe0b35e03", + "name": "backports", + "sha256": "2685ae5fa620fad4b5db83b02deceb60fef1121c69bc3c26b6c16f9a64000a05", + "size": 4008, + "subdir": "linux-64", + "timestamp": 1530737821507, + "version": "1.0" + }, + "backports.functools_lru_cache-1.4-py27he8db605_1.conda": { + "build": "py27he8db605_1", + "build_number": 1, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b99bc76b1a7d49b1a4b7a991ab3f69f0", + "name": "backports.functools_lru_cache", + "sha256": "9bbcc719d1a3e8290adc79f4ce88a998ded696072bbf99c2ece9e17bb0dfe601", + "size": 9471, + "subdir": "linux-64", + "timestamp": 1505693903100, + "version": "1.4" + }, + "backports.functools_lru_cache-1.5-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77b80f81c6cf52bc9bf4d81b64869200", + "name": "backports.functools_lru_cache", + "sha256": "8f7b11ded76c8441ceb1fe57c6a5dbcf9dea2d439639a40a7d36520c4416ddcf", + "size": 9908, + "subdir": "linux-64", + "timestamp": 1519170609770, + "version": "1.5" + }, + "backports.lzma-0.0.10-py27hfe699d2_0.conda": { + "build": "py27hfe699d2_0", + "build_number": 0, + "depends": [ + "backports", + "future", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "xz >=5.2.3,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4da86f69cfbc2cd310e5ae47748be167", + "name": "backports.lzma", + "sha256": "f9771f36f039a788caacff58e890cd4add0309f5998c9e4e134bdfa7c4f3f5c9", + "size": 44947, + "subdir": "linux-64", + "timestamp": 1524584565815, + "version": "0.0.10" + }, + "backports.lzma-0.0.10-py35hfe699d2_0.conda": { + "build": "py35hfe699d2_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "xz >=5.2.3,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4e175565b75900b0a2e117df90b61372", + "name": "backports.lzma", + "sha256": "0402562391a83abf5bd3cab81d19258b70dac89f380e9c8ab68c9ee3891f1982", + "size": 44798, + "subdir": "linux-64", + "timestamp": 1524584565517, + "version": "0.0.10" + }, + "backports.lzma-0.0.10-py36hfe699d2_0.conda": { + "build": "py36hfe699d2_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "xz >=5.2.3,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c59de1c49bf2eabbf3f01f11f800ce74", + "name": "backports.lzma", + "sha256": "df8d10549f208f5d191a9bee60f247c53a934d10324e8b4dc6128874a07dfe90", + "size": 44676, + "subdir": "linux-64", + "timestamp": 1524584565652, + "version": "0.0.10" + }, + "backports.lzma-0.0.11-py27hfe699d2_0.conda": { + "build": "py27hfe699d2_0", + "build_number": 0, + "depends": [ + "backports", + "future", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fdd305516fe36cead0e7a40fd952ff1f", + "name": "backports.lzma", + "sha256": "3b8b7cbb6059daa099c28c24d47bd30bce994307f1f46d61a35a4a6e84ff720c", + "size": 45070, + "subdir": "linux-64", + "timestamp": 1526939800393, + "version": "0.0.11" + }, + "backports.lzma-0.0.11-py35hfe699d2_0.conda": { + "build": "py35hfe699d2_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b772e9bd4343b4df5f3066cf68640e5c", + "name": "backports.lzma", + "sha256": "5d03e6e824af20519f5cff34e7861d67897bc763b9dc4fe2ee953a261aa06885", + "size": 45041, + "subdir": "linux-64", + "timestamp": 1526939957886, + "version": "0.0.11" + }, + "backports.lzma-0.0.11-py36hfe699d2_0.conda": { + "build": "py36hfe699d2_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "50b9f2ce19cc40536c21e33e427d2729", + "name": "backports.lzma", + "sha256": "eb7e5cf36e19ea32be918a34ba00e27d0f38e6859dfe8f51acb1901e04cd35cf", + "size": 44780, + "subdir": "linux-64", + "timestamp": 1526939861240, + "version": "0.0.11" + }, + "backports.lzma-0.0.11-py37hfe699d2_0.conda": { + "build": "py37hfe699d2_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a30f2a08011856eca1fa5a44ed69b561", + "name": "backports.lzma", + "sha256": "7e5b0b8505d3e801fad192a47ea7648e7dd6c7dcf16c256ef5d63a89fc050ac4", + "size": 44879, + "subdir": "linux-64", + "timestamp": 1530738871755, + "version": "0.0.11" + }, + "backports.lzma-0.0.13-py27hd36a4d9_0.conda": { + "build": "py27hd36a4d9_0", + "build_number": 0, + "depends": [ + "backports", + "future", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bbc919d6202ca5b443125e153def2dd3", + "name": "backports.lzma", + "sha256": "d9c7b2d9368cc5a3287a74d95a7193dd496c1c51049815e58487de5566699058", + "size": 45501, + "subdir": "linux-64", + "timestamp": 1535509512034, + "version": "0.0.13" + }, + "backports.lzma-0.0.13-py35hd36a4d9_0.conda": { + "build": "py35hd36a4d9_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "67b56de059f250d4a3995cc32cb95d52", + "name": "backports.lzma", + "sha256": "7186bdcd925ea980f49bde54ac20ad6afd6447ae8ccd170aaeb8c3955b96dd9e", + "size": 45343, + "subdir": "linux-64", + "timestamp": 1535509544196, + "version": "0.0.13" + }, + "backports.lzma-0.0.13-py36hd36a4d9_0.conda": { + "build": "py36hd36a4d9_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7a4b398979652860fd38e8bc56f506ef", + "name": "backports.lzma", + "sha256": "6e73c8f30c0239569100b62bde951356b2c159fc70c18b0f872199a996c6a412", + "size": 45139, + "subdir": "linux-64", + "timestamp": 1535509482926, + "version": "0.0.13" + }, + "backports.lzma-0.0.13-py37hd36a4d9_0.conda": { + "build": "py37hd36a4d9_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "698095b6e406410daaccdeea55dd51cc", + "name": "backports.lzma", + "sha256": "5448e3fb6bb93f926cfb1e4376bfe81cad3027eeddfd8f07c373fd826232575c", + "size": 45173, + "subdir": "linux-64", + "timestamp": 1535509534553, + "version": "0.0.13" + }, + "backports.lzma-0.0.14-py27hd36a4d9_0.conda": { + "build": "py27hd36a4d9_0", + "build_number": 0, + "depends": [ + "backports", + "future", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0c8f3fed13131482a47ba95d4b8a08a4", + "name": "backports.lzma", + "sha256": "760e17041e08ddd099aae9ad43ab95bd3c92cec7fd88345a5fd8e6eee5e8da9b", + "size": 53259, + "subdir": "linux-64", + "timestamp": 1569508892998, + "version": "0.0.14" + }, + "backports.lzma-0.0.14-py310h5cf449c_0.conda": { + "build": "py310h5cf449c_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "xz >=5.2.5,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0b1a7ac97999a0c91de027f9db8ef294", + "name": "backports.lzma", + "sha256": "f2331dfd9b2dc4e7e894d0743c232ecfc9103578e776039eabfa33147b1c35c7", + "size": 73772, + "subdir": "linux-64", + "timestamp": 1640788393727, + "version": "0.0.14" + }, + "backports.lzma-0.0.14-py36h5905bc5_0.conda": { + "build": "py36h5905bc5_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "xz >=5.2.5,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "df8804a676269881c05cd63fd51114e4", + "name": "backports.lzma", + "sha256": "237b8a4fa34e827031aad6eca5615e9cf36261af0af79f02f30e78366c7de882", + "size": 53189, + "subdir": "linux-64", + "timestamp": 1613153890561, + "version": "0.0.14" + }, + "backports.lzma-0.0.14-py36hd36a4d9_0.conda": { + "build": "py36hd36a4d9_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4e2a07f7053619f285fae810cba96c5c", + "name": "backports.lzma", + "sha256": "fb091d7f6686fe2db65fd510c58e7ac9b311c1b7c360a77b9bbf4fb317ef3d94", + "size": 52838, + "subdir": "linux-64", + "timestamp": 1569508861261, + "version": "0.0.14" + }, + "backports.lzma-0.0.14-py37h5905bc5_0.conda": { + "build": "py37h5905bc5_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "xz >=5.2.5,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e0419714c30ade9b5e6d6804b7f30ad8", + "name": "backports.lzma", + "sha256": "8ce7badb916074c832ab549364eeb4b4901f6c2eca6fbd509fe2ef72648615f0", + "size": 53163, + "subdir": "linux-64", + "timestamp": 1613154350137, + "version": "0.0.14" + }, + "backports.lzma-0.0.14-py37hd36a4d9_0.conda": { + "build": "py37hd36a4d9_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "840840a7a22560294f01a89a447c4251", + "name": "backports.lzma", + "sha256": "2ff9e3bd8ba105515be6c01b98253586b2e8841f43b6ca90f06e4be16ae1998e", + "size": 52811, + "subdir": "linux-64", + "timestamp": 1569508871582, + "version": "0.0.14" + }, + "backports.lzma-0.0.14-py38h5905bc5_0.conda": { + "build": "py38h5905bc5_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "xz >=5.2.5,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9c587d4746af4638f375f999667ae083", + "name": "backports.lzma", + "sha256": "98b34d75f02e7044e4f27ba143a9ced2921f8b8fa24002818f3f8feba1cba389", + "size": 53262, + "subdir": "linux-64", + "timestamp": 1613153532351, + "version": "0.0.14" + }, + "backports.lzma-0.0.14-py38hd36a4d9_0.conda": { + "build": "py38hd36a4d9_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "xz >=5.2.4,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "91112acce850ba33c584a51fc1b461c4", + "name": "backports.lzma", + "sha256": "504fa9bc9ada6f33306ce3a446a517074faf4dcba414f4e2c27dfe640390328a", + "size": 56733, + "subdir": "linux-64", + "timestamp": 1573738089071, + "version": "0.0.14" + }, + "backports.lzma-0.0.14-py39h5905bc5_0.conda": { + "build": "py39h5905bc5_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "xz >=5.2.5,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3756d74c111bb58a66dfc644cbe86037", + "name": "backports.lzma", + "sha256": "7492db32015acf98b10d415bbb643af00e3858840c32b572c751626c9df96ad7", + "size": 52868, + "subdir": "linux-64", + "timestamp": 1613154340484, + "version": "0.0.14" + }, + "backports.lzma-0.0.8-py27hfe699d2_2.conda": { + "build": "py27hfe699d2_2", + "build_number": 2, + "depends": [ + "backports", + "future", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "xz >=5.2.3,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "680de71901e53a2d62c2179d5e5f2318", + "name": "backports.lzma", + "sha256": "2f13e52cf3c1bc56caf5e64a75073abfecba5d1f92237467952f451a31ea19a9", + "size": 43482, + "subdir": "linux-64", + "timestamp": 1514119908334, + "version": "0.0.8" + }, + "backports.lzma-0.0.8-py35hfe699d2_2.conda": { + "build": "py35hfe699d2_2", + "build_number": 2, + "depends": [ + "backports", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "xz >=5.2.3,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fcdcc8a77d35b6ea294bf5366f006489", + "name": "backports.lzma", + "sha256": "e41209fe4fd8725cf91f80187599ab37a6e5ad20924de87cf05e5421c6bcfeb0", + "size": 43412, + "subdir": "linux-64", + "timestamp": 1514119920290, + "version": "0.0.8" + }, + "backports.lzma-0.0.8-py36hfe699d2_2.conda": { + "build": "py36hfe699d2_2", + "build_number": 2, + "depends": [ + "backports", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "xz >=5.2.3,<6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d966bdd42e9d3c5c16a4c320bb6a808b", + "name": "backports.lzma", + "sha256": "55ce945b1724fe640146c04eed411e8bfbf3d0ade365d1e7b431d2c00403462a", + "size": 43133, + "subdir": "linux-64", + "timestamp": 1514119920248, + "version": "0.0.8" + }, + "backports.os-0.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports", + "future", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "1b4ff2de9a31cfbc655b504bb44c04aa", + "name": "backports.os", + "sha256": "89d9d2976bbcaa1a27ca453d7cd4422e628a9dc34a1505a9ca7d89dd2105bbce", + "size": 15946, + "subdir": "linux-64", + "timestamp": 1539703281762, + "version": "0.1.1" + }, + "backports.os-0.1.1-py310h06a4308_1002.conda": { + "build": "py310h06a4308_1002", + "build_number": 1002, + "depends": [ + "backports", + "python >=3.10,<3.11.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "0b3840d98f5a5225e94c37fc36ca8939", + "name": "backports.os", + "sha256": "c7d9abc06c198014aefa0767c64a25db8323b43067d2b6bad6436371b4d8c8fa", + "size": 15858, + "subdir": "linux-64", + "timestamp": 1642511329373, + "version": "0.1.1" + }, + "backports.os-0.1.1-py311h06a4308_1000.conda": { + "build": "py311h06a4308_1000", + "build_number": 1000, + "depends": [ + "backports", + "python >=3.11,<3.12.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "c69d2d7710789d44b7d26e70b0f0fafd", + "name": "backports.os", + "sha256": "509d7b3834ce0820e536dd6959e3039d5d2e1e96377eb4488ac33b027aef6602", + "size": 17642, + "subdir": "linux-64", + "timestamp": 1676846894543, + "version": "0.1.1" + }, + "backports.os-0.1.1-py311h06a4308_1002.conda": { + "build": "py311h06a4308_1002", + "build_number": 1002, + "depends": [ + "backports", + "python >=3.11,<3.12.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "c0badb632ff449cb0d3893a229c5c5bb", + "name": "backports.os", + "sha256": "27b056cc7394fc8f58678c02b0c9b3a4e68dfb21b209c03ca9a3557ed1a213c0", + "size": 17340, + "subdir": "linux-64", + "timestamp": 1679335401093, + "version": "0.1.1" + }, + "backports.os-0.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "73d4f439de9dea6f61e3ae072d4ea9fa", + "name": "backports.os", + "sha256": "77afe4e27621fd0417d7f7eaff617f7344a159ab1e65056b1af3aa3f6206b052", + "size": 15868, + "subdir": "linux-64", + "timestamp": 1539703309776, + "version": "0.1.1" + }, + "backports.os-0.1.1-py36h06a4308_1000.conda": { + "build": "py36h06a4308_1000", + "build_number": 1000, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "5146c384aafb3626e368b9dc655d2dcc", + "name": "backports.os", + "sha256": "d9086729000d72c3893888c9c531b5cf3db9cb3d0fe04ed1184508f51b5be1a2", + "size": 16722, + "subdir": "linux-64", + "timestamp": 1613157576534, + "version": "0.1.1" + }, + "backports.os-0.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "d5cff4cdfefc6748ebe384e6f1142571", + "name": "backports.os", + "sha256": "e31640320db9b4f30020a98ca9c9a2f893f08b6e6b2330cef0b444ab20b1b4a3", + "size": 15867, + "subdir": "linux-64", + "timestamp": 1539703308789, + "version": "0.1.1" + }, + "backports.os-0.1.1-py37_1002.conda": { + "build": "py37_1002", + "build_number": 1002, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "fd50411f75d44e56216144e4ad5a156d", + "name": "backports.os", + "sha256": "bd27361e11244bddb62cbaa566a2c26c1ab08ec1775e91272de3391a08f07053", + "size": 15245, + "subdir": "linux-64", + "timestamp": 1594340489856, + "version": "0.1.1" + }, + "backports.os-0.1.1-py37h06a4308_1000.conda": { + "build": "py37h06a4308_1000", + "build_number": 1000, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "aab09e1b7339864dd65333fef0eaa83d", + "name": "backports.os", + "sha256": "5d7f00fe1dd6551f14c052a5227eff66fd9865b89579b6d988c33f9b4e369ab2", + "size": 16666, + "subdir": "linux-64", + "timestamp": 1613157572542, + "version": "0.1.1" + }, + "backports.os-0.1.1-py38_1000.conda": { + "build": "py38_1000", + "build_number": 1000, + "depends": [ + "backports", + "python >=3.8,<3.9.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "a4e4bed363068d865b74f99bcae35dc1", + "name": "backports.os", + "sha256": "2f32e9e215f4d07552166ea5531921b3e2244437ac2277bd2be91b09818e5f5d", + "size": 16087, + "subdir": "linux-64", + "timestamp": 1573738104895, + "version": "0.1.1" + }, + "backports.os-0.1.1-py38h06a4308_1000.conda": { + "build": "py38h06a4308_1000", + "build_number": 1000, + "depends": [ + "backports", + "python >=3.8,<3.9.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "2294d0ee2942650242e36b6784b93cff", + "name": "backports.os", + "sha256": "2bcbe84f8393e5609e0238c0863ca02e2e374551bdb6b13047e63ee82b955ca1", + "size": 16707, + "subdir": "linux-64", + "timestamp": 1613157579626, + "version": "0.1.1" + }, + "backports.os-0.1.1-py39h06a4308_1000.conda": { + "build": "py39h06a4308_1000", + "build_number": 1000, + "depends": [ + "backports", + "python >=3.9,<3.10.0a0" + ], + "license": "Python Software Foundation", + "license_family": "PSF", + "md5": "05707061951fb54000517bcd37fe3d9c", + "name": "backports.os", + "sha256": "a83555c31310f6817e5e077dd71a4c02e8b36bf841947d1862a3185df22d8093", + "size": 16726, + "subdir": "linux-64", + "timestamp": 1613157569689, + "version": "0.1.1" + }, + "backports.shutil_get_terminal_size-1.0.0-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "59e9e4e48059e9e5130e8a8f5f78c3a5", + "name": "backports.shutil_get_terminal_size", + "sha256": "95dbb44a2f234f84ac531b8936ddde656e35a7bd1566c8ca8084331c18143892", + "size": 8427, + "subdir": "linux-64", + "timestamp": 1530738921693, + "version": "1.0.0" + }, + "backports.shutil_get_terminal_size-1.0.0-py27h5bc021e_2.conda": { + "build": "py27h5bc021e_2", + "build_number": 2, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b213c6e5d3a80702603eda60d7bdbb38", + "name": "backports.shutil_get_terminal_size", + "sha256": "4da4a13f11ca768d984881eb6178be1ef0e5e9f118e82916184114d58f18ff9f", + "size": 8166, + "subdir": "linux-64", + "timestamp": 1505956875861, + "version": "1.0.0" + }, + "backports.shutil_get_terminal_size-1.0.0-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "backports", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "4d8335a536f0d6286529b413e685ca93", + "name": "backports.shutil_get_terminal_size", + "sha256": "37c4232f9e711ef2f5ed4ca0d49cea09e7507fd17e443fe024a14c8d02be9a41", + "size": 8479, + "subdir": "linux-64", + "timestamp": 1534355311565, + "version": "1.0.0" + }, + "backports.shutil_get_terminal_size-1.0.0-py35h40844db_2.conda": { + "build": "py35h40844db_2", + "build_number": 2, + "depends": [ + "backports", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "c180986417a1c2479041b2099bcb3b99", + "name": "backports.shutil_get_terminal_size", + "sha256": "aa1498899ded8852f0f629771278c2d021411c78ffd86a694007d6ccca4d0517", + "size": 8230, + "subdir": "linux-64", + "timestamp": 1505956890176, + "version": "1.0.0" + }, + "backports.shutil_get_terminal_size-1.0.0-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2b8cdab6cb6d49e9c6539eb3a47e717c", + "name": "backports.shutil_get_terminal_size", + "sha256": "9e5fee00a8aa7006bb98d06631dae498653b3a61b333dce17ba32fe8e7a81898", + "size": 8516, + "subdir": "linux-64", + "timestamp": 1530738899753, + "version": "1.0.0" + }, + "backports.shutil_get_terminal_size-1.0.0-py36hfea85ff_2.conda": { + "build": "py36hfea85ff_2", + "build_number": 2, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3c37b2d7256af44b7bfcb99657934333", + "name": "backports.shutil_get_terminal_size", + "sha256": "87b23b725589c344f40e66d6c91d56876a98f58f2b621279ace3a2d099d09dc5", + "size": 8150, + "subdir": "linux-64", + "timestamp": 1505956904525, + "version": "1.0.0" + }, + "backports.shutil_get_terminal_size-1.0.0-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f91f766abcd1b56aab33973992c097ac", + "name": "backports.shutil_get_terminal_size", + "sha256": "daf70c0a538e1f0ae33e1b2decd94dc8bbfb63a5b9009ee35be1e17151f578b1", + "size": 8459, + "subdir": "linux-64", + "timestamp": 1530738943847, + "version": "1.0.0" + }, + "backports.shutil_get_terminal_size-1.0.0-py38_2.conda": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "backports", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "871287bb4aa38d5d515877efe638438c", + "name": "backports.shutil_get_terminal_size", + "sha256": "166305c836ea87bb9cdb84f3f46b5361ad858c014863a97b3972a9b0cd9138e2", + "size": 9060, + "subdir": "linux-64", + "timestamp": 1573738123335, + "version": "1.0.0" + }, + "backports.shutil_which-3.5.1-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF2 & MIT", + "md5": "c592a3fc74f8047d2b76536fefb36182", + "name": "backports.shutil_which", + "sha256": "780d1e7210530c5f62422d05ad3b142e2a03b503831a556c2a88ffa6d4ed7bde", + "size": 7498, + "subdir": "linux-64", + "timestamp": 1517592920144, + "version": "3.5.1" + }, + "backports.shutil_which-3.5.1-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "backports", + "python >=3.5,<3.6.0a0" + ], + "license": "PSF2 & MIT", + "md5": "74da7b55eead8519b13ad9f1e426acb4", + "name": "backports.shutil_which", + "sha256": "294bf9291cbae8b9e6dd9efecfa21b62edb1362b0e5bd5a2a598c9898c5541e3", + "size": 7620, + "subdir": "linux-64", + "timestamp": 1517592920406, + "version": "3.5.1" + }, + "backports.shutil_which-3.5.1-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF2 & MIT", + "md5": "681f6fc122b134d524b483cae8fc7514", + "name": "backports.shutil_which", + "sha256": "0e8bbea44674b32bec62e169f8fca628957aeed42ff71b41c512d55c641f7e7d", + "size": 7556, + "subdir": "linux-64", + "timestamp": 1517592920348, + "version": "3.5.1" + }, + "backports.shutil_which-3.5.1-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF2 & MIT", + "md5": "3f373396e3fbdedc3f2a50df92f5293c", + "name": "backports.shutil_which", + "sha256": "7e7bbd40c84e80274f7c306bea4fd0416cb167aa27e5d61d2b0aedc0ab84edcb", + "size": 7687, + "subdir": "linux-64", + "timestamp": 1530738967438, + "version": "3.5.1" + }, + "backports.shutil_which-3.5.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF2 & MIT", + "md5": "248ef07332818c2dbd41f8d6ca959acc", + "name": "backports.shutil_which", + "sha256": "6d83508aa133d94c83966d4d812d8ab991983e58b1a276769ff8be8fe06db8d3", + "size": 8988, + "subdir": "linux-64", + "timestamp": 1542385258333, + "version": "3.5.2" + }, + "backports.shutil_which-3.5.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.10,<3.11.0a0" + ], + "license": "PSF2 & MIT", + "md5": "c6eafd16ad1e3fd1c355f4806fc5d7c4", + "name": "backports.shutil_which", + "sha256": "45d4a1b273118a5e07b2c5d4ca9dfedf71ffe76c4ac73ce347a4b9832e15a1c1", + "size": 8562, + "subdir": "linux-64", + "timestamp": 1640788411608, + "version": "3.5.2" + }, + "backports.shutil_which-3.5.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.11,<3.12.0a0" + ], + "license": "PSF2 & MIT", + "md5": "8e03b1ba9d724db46b53026e1b06d094", + "name": "backports.shutil_which", + "sha256": "9f2787c11bed5db2c8719869d537e82f9d85ff2bd3c59880d68a9c6a5ef1f0b3", + "size": 9777, + "subdir": "linux-64", + "timestamp": 1676846911013, + "version": "3.5.2" + }, + "backports.shutil_which-3.5.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF2 & MIT", + "md5": "0412635435154467a223b8ef7ff090bd", + "name": "backports.shutil_which", + "sha256": "411833912b31d7b2c0d6669bfae22d5ada9461570709a96835860624fc982b33", + "size": 9036, + "subdir": "linux-64", + "timestamp": 1542385264385, + "version": "3.5.2" + }, + "backports.shutil_which-3.5.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF2 & MIT", + "md5": "1d38a136c27a942967fbf1167bc61380", + "name": "backports.shutil_which", + "sha256": "55f2c08d2f3b1d48434c874c88c313542ffc13cfaa136643d987bbfa0cd4149e", + "size": 9506, + "subdir": "linux-64", + "timestamp": 1613157452281, + "version": "3.5.2" + }, + "backports.shutil_which-3.5.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF2 & MIT", + "md5": "807f4c2bc140c48f8cac38f16ed581bc", + "name": "backports.shutil_which", + "sha256": "a97c583cf4ce8019f4ee40df43b9262fd179e2e2a95f74e988621692216756d4", + "size": 9047, + "subdir": "linux-64", + "timestamp": 1542385227034, + "version": "3.5.2" + }, + "backports.shutil_which-3.5.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF2 & MIT", + "md5": "085b4586b97f37c618b960580b70b25e", + "name": "backports.shutil_which", + "sha256": "11f420ac85ac8d9e051cf4cc33e140dac10c28005e8ba54f5d684142eaaaea10", + "size": 9458, + "subdir": "linux-64", + "timestamp": 1613157116283, + "version": "3.5.2" + }, + "backports.shutil_which-3.5.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF2 & MIT", + "md5": "f2b2e516d14a4e1a92ed2415c6345833", + "name": "backports.shutil_which", + "sha256": "108177652a17b1e420f9ae29421edbf8c44fdd312c8a5ec8c5e296890afd091a", + "size": 8475, + "subdir": "linux-64", + "timestamp": 1573738136954, + "version": "3.5.2" + }, + "backports.shutil_which-3.5.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF2 & MIT", + "md5": "9513f55055c8f1e0ae89e9c075305f2a", + "name": "backports.shutil_which", + "sha256": "5e9eed891895e4fff9e7836676b66a81be2106da7dc93397fd4f006769a6752a", + "size": 9451, + "subdir": "linux-64", + "timestamp": 1613157577033, + "version": "3.5.2" + }, + "backports.shutil_which-3.5.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF2 & MIT", + "md5": "821e25835b5133a9cf2836c42ee0ff7c", + "name": "backports.shutil_which", + "sha256": "ae63ce252dbb60651d8acd38e815a608479aa1817375de023e1a7c6e4e65d9fd", + "size": 9498, + "subdir": "linux-64", + "timestamp": 1613157452323, + "version": "3.5.2" + }, + "backports.weakref-1.0.post1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "958e0a9b1cc2696c0455f076d111f923", + "name": "backports.weakref", + "sha256": "ca5fa635e965ef8e87d4add6f7fb11c410136351cf3f66b948e64a5e46ad48a3", + "size": 8444, + "subdir": "linux-64", + "timestamp": 1530739012541, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py27h0df1112_0.conda": { + "build": "py27h0df1112_0", + "build_number": 0, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "4cca923c7e81ea99fd4078f9bcbd719c", + "name": "backports.weakref", + "sha256": "d00065b8a10e76cbd063885ed34ea71ce2d60f009c7f32935c0d04780e1355b6", + "size": 8723, + "subdir": "linux-64", + "timestamp": 1509121908904, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.10,<3.11.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "35a3013992a0d18ebd3ccc108058d84c", + "name": "backports.weakref", + "sha256": "a063c1de26c40d31ec7c8c0f7403650eed78d692460f01dadcbf3240a7b409c2", + "size": 8856, + "subdir": "linux-64", + "timestamp": 1642510041164, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.11,<3.12.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "e1439f971efe67492c46d4fef31a35e1", + "name": "backports.weakref", + "sha256": "5695d1a08c77f6dc7b352ac0a28e03c65f173d36b5bc1fe26e9ff1f52ef7228a", + "size": 10449, + "subdir": "linux-64", + "timestamp": 1676846925488, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "e2d865f1ad9f58decadd47db08b4dea4", + "name": "backports.weakref", + "sha256": "b7a71e974fd42852707cd01011860e20e02d2ebdb49a53023596125f39b7dafd", + "size": 8547, + "subdir": "linux-64", + "timestamp": 1534355342000, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py35h2eecce5_0.conda": { + "build": "py35h2eecce5_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "854a81bab44d6b91713be9f3a5ecf31a", + "name": "backports.weakref", + "sha256": "719c0da3acfaf610a4093b15af156d0d7d2c6670304d52a8fd542cf5f9557765", + "size": 8887, + "subdir": "linux-64", + "timestamp": 1509121943526, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "559ff732a0c81952862db3406a3a5e4a", + "name": "backports.weakref", + "sha256": "1669800bddae8300d70219a33dd5b4e2b6fd45fbd568a7fb928e31cfdabc969a", + "size": 8503, + "subdir": "linux-64", + "timestamp": 1530738990774, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "c3cd128a13ee181cd78c1db2e4d61f0c", + "name": "backports.weakref", + "sha256": "4bcd7384baf15ede862e8c96440936cc984725bfbc6bcce6464ee015d511fd09", + "size": 9516, + "subdir": "linux-64", + "timestamp": 1632738101978, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py36h39d5b32_0.conda": { + "build": "py36h39d5b32_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "1125178e909450dfb9ccd7b25f4afdad", + "name": "backports.weakref", + "sha256": "5c6cbee9550ec8c341ab3430376ae96b9d4f181dd7f04003cf070691623fb98c", + "size": 8770, + "subdir": "linux-64", + "timestamp": 1509121973183, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "c274d0326332128fdd247f8410278e37", + "name": "backports.weakref", + "sha256": "be3010115962bb12692f9b148734544e039ebb96b02b08957b0a91064a1f7ccf", + "size": 8536, + "subdir": "linux-64", + "timestamp": 1530739034545, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "aa1e52d5668cef8115c0d1ef9a22c371", + "name": "backports.weakref", + "sha256": "c2fd29040460d6e51a4400a6b9ff2695e80651e6b1145139854833f5eb1abdae", + "size": 9524, + "subdir": "linux-64", + "timestamp": 1632748454692, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "33e2803d1af2eee1add7dff8b038abe6", + "name": "backports.weakref", + "sha256": "b1836fcf4ead71b9d023508fa6c3f5ea57408f4b36436da180833fea53c486ff", + "size": 8988, + "subdir": "linux-64", + "timestamp": 1573469550093, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "01a0cb83d7dec643d831b8d8e1b714a0", + "name": "backports.weakref", + "sha256": "be4ba3c4c348f1b32fc28da430df4aeec3cb9157a03dfc8a42699ad4290f6f70", + "size": 9538, + "subdir": "linux-64", + "timestamp": 1632748447723, + "version": "1.0.post1" + }, + "backports.weakref-1.0.post1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.9,<3.10.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "fb4d559857b7ef5b378c4d3e11722d1a", + "name": "backports.weakref", + "sha256": "49f539fddaff31866f062ccb273086da483a41e359125f95db5c4a2cd4cab76f", + "size": 9543, + "subdir": "linux-64", + "timestamp": 1632748450409, + "version": "1.0.post1" + }, + "backports.zoneinfo-0.2.1-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "tzdata" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "907a74485a974eb7ffc61a6868cefd47", + "name": "backports.zoneinfo", + "sha256": "b62165f98be6a73f0b6e060a7484ecccb90380706d50bc97710d115274924cae", + "size": 52479, + "subdir": "linux-64", + "timestamp": 1661287625567, + "version": "0.2.1" + }, + "backports.zoneinfo-0.2.1-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "backports", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "tzdata" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "74e2d4e5d651f257c2d06b7e0e821273", + "name": "backports.zoneinfo", + "sha256": "cdad39fc3393a8b6618d14a96cbbf8a3a78fecaf3d7d4045dcbd0c6a97ad3661", + "size": 52154, + "subdir": "linux-64", + "timestamp": 1661287593720, + "version": "0.2.1" + }, + "backports_abc-0.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "ae8cb9608bf72945302a8ba7e0645f50", + "name": "backports_abc", + "sha256": "e397d32c18fa009b991c1040ed43d0dc34420551b55fd67b01be368dd4b77c52", + "size": 12671, + "subdir": "linux-64", + "timestamp": 1530735311903, + "version": "0.5" + }, + "backports_abc-0.5-py27h7b3c97b_0.conda": { + "build": "py27h7b3c97b_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "ea030f7c86492505b54f41691f4a7fe4", + "name": "backports_abc", + "sha256": "c5402294e8ec8339e76675053f042447361936fc1a52645ff3a3c00d7117eee9", + "size": 12344, + "subdir": "linux-64", + "timestamp": 1505690433274, + "version": "0.5" + }, + "backports_abc-0.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "PSF 2", + "md5": "56eadfb924e38d05f57588aaad24e8c9", + "name": "backports_abc", + "sha256": "f7f0dfa866e2fc4099f940b918817fabd93eb292a466412cedf9bc70b549f2d2", + "size": 12857, + "subdir": "linux-64", + "timestamp": 1642498996191, + "version": "0.5" + }, + "backports_abc-0.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "PSF 2", + "md5": "cc619fa33ebc1ffb2c15ba1a854fcaa5", + "name": "backports_abc", + "sha256": "f677f181464f4ee80de7d6879a6fc015855fd302edaf7ca50a58f3965119f543", + "size": 14398, + "subdir": "linux-64", + "timestamp": 1676846940266, + "version": "0.5" + }, + "backports_abc-0.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "PSF 2", + "md5": "7d36c075f388a9f88431058fa9fa99df", + "name": "backports_abc", + "sha256": "7e32ce5085028559a0b1e0608289c9f77bf08708837372673f1e416a1dea7faa", + "size": 12657, + "subdir": "linux-64", + "timestamp": 1534351858877, + "version": "0.5" + }, + "backports_abc-0.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF 2", + "md5": "389ac4768831e634e461b68a55257f37", + "name": "backports_abc", + "sha256": "9f289a10bdb80e20fc8d49514085b32d7b42ff2a9bc32755d6f278a385962d91", + "size": 12657, + "subdir": "linux-64", + "timestamp": 1530735292148, + "version": "0.5" + }, + "backports_abc-0.5-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF 2", + "md5": "a9a951fb8f57070b0b7c540b91f898d0", + "name": "backports_abc", + "sha256": "733ef7a9614f38fdeb0587f17da5bf06cc4e9b21edfdf446309524b7a7e4f148", + "size": 13653, + "subdir": "linux-64", + "timestamp": 1632738098617, + "version": "0.5" + }, + "backports_abc-0.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF 2", + "md5": "ee011b2fd294a33af1755bbac9723ac1", + "name": "backports_abc", + "sha256": "e591b2c5ad8a36447c1b8cc334771c112705c3d3977157cbdbdfee63e1210ba5", + "size": 12677, + "subdir": "linux-64", + "timestamp": 1530735332167, + "version": "0.5" + }, + "backports_abc-0.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF 2", + "md5": "4669fb6df6b33a38220a3ad57b585e46", + "name": "backports_abc", + "sha256": "e905dcc0ae1a6e7bcde429c52fdbee771b5fd4e723b71f895ceff48f7deb5129", + "size": 13714, + "subdir": "linux-64", + "timestamp": 1632748090739, + "version": "0.5" + }, + "backports_abc-0.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF 2", + "md5": "34ec33313194b877ba8811b6c33f9d3d", + "name": "backports_abc", + "sha256": "65fa572325c4c6bfd9fe293e96e71a222c67aa55a3b8029f1a70ff4f0c013b12", + "size": 13013, + "subdir": "linux-64", + "timestamp": 1572437398732, + "version": "0.5" + }, + "backports_abc-0.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF 2", + "md5": "d41769cae2567dd01d27f465aa2e2b24", + "name": "backports_abc", + "sha256": "c57193935a60e79d21c83cd1e1ccd4aabef263146220a891fc036039611882c7", + "size": 13692, + "subdir": "linux-64", + "timestamp": 1632748438490, + "version": "0.5" + }, + "backports_abc-0.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF 2", + "md5": "a1245c4479e56319c20992f84ae0ff85", + "name": "backports_abc", + "sha256": "8fc35f2bcee4c6527848e3e02c89230cfb9f04eec8d84d20e1f75dcef46d341e", + "size": 13710, + "subdir": "linux-64", + "timestamp": 1632748438517, + "version": "0.5" + }, + "bandersnatch-2.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.5,<3.6.0a0", + "requests", + "setuptools", + "xmlrpc2" + ], + "license": "Academic Free License", + "license_family": "Other", + "md5": "a92eb201bf91ff05279b047a6de048f9", + "name": "bandersnatch", + "sha256": "3d73ac7ddbbdc6cf0d5ba27db12d11dfa6713e036321644da3b31a93595c953b", + "size": 35474, + "subdir": "linux-64", + "timestamp": 1530023291902, + "version": "2.2.1" + }, + "bandersnatch-2.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.6,<3.7.0a0", + "requests", + "setuptools", + "xmlrpc2" + ], + "license": "Academic Free License", + "license_family": "Other", + "md5": "3ab55b8730f54283761a4add3fad5140", + "name": "bandersnatch", + "sha256": "3d3646cda155ec6bf6a29102c418b3e90e52e2770fba34f842767215e570cc29", + "size": 35218, + "subdir": "linux-64", + "timestamp": 1530022681382, + "version": "2.2.1" + }, + "bandersnatch-3.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp", + "filelock", + "packaging", + "python >=3.6,<3.7.0a0", + "requests", + "setuptools", + "xmlrpc2" + ], + "license": "Academic Free License", + "license_family": "Other", + "md5": "b90b4acf15e1cdf4336a74eeef9d7aa3", + "name": "bandersnatch", + "sha256": "81e956b6fa6c4bd76465651d92f081d0bd4bcf1f9d02df7a1ba15c0dd053c6f8", + "size": 51009, + "subdir": "linux-64", + "timestamp": 1545163880831, + "version": "3.1.2" + }, + "bandersnatch-3.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiohttp", + "filelock", + "packaging", + "python >=3.7,<3.8.0a0", + "requests", + "setuptools", + "xmlrpc2" + ], + "license": "Academic Free License", + "license_family": "Other", + "md5": "9e4a66c0bd3bf55be6ac3d318c0af528", + "name": "bandersnatch", + "sha256": "f6b61e62487436a0f0e3e63d599dc0a2d7cbe43eaf1b3f5b39184540428d4e46", + "size": 50440, + "subdir": "linux-64", + "timestamp": 1545235778115, + "version": "3.1.2" + }, + "bandersnatch-3.1.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp", + "filelock", + "packaging", + "python >=3.6,<3.7.0a0", + "requests", + "setuptools", + "xmlrpc2" + ], + "license": "Academic Free License", + "license_family": "Other", + "md5": "66f30a5fda7adb9b5ce87b7c7b673b58", + "name": "bandersnatch", + "sha256": "3e65141ec63e314c9b0cfff2541cc3a8d47c209de322d660f162b2fe01743c58", + "size": 193045, + "subdir": "linux-64", + "timestamp": 1547222959183, + "version": "3.1.3" + }, + "bandersnatch-3.1.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiohttp", + "filelock", + "packaging", + "python >=3.7,<3.8.0a0", + "requests", + "setuptools", + "xmlrpc2" + ], + "license": "Academic Free License", + "license_family": "Other", + "md5": "e181c5c1244d0a45082cbfe39ddaf475", + "name": "bandersnatch", + "sha256": "d4c4eadc737ca4538c495092075cd16f8abc56a4d527f6ea99ce1e860ac14119", + "size": 193742, + "subdir": "linux-64", + "timestamp": 1547222978481, + "version": "3.1.3" + }, + "bandersnatch-3.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp", + "filelock", + "packaging", + "python >=3.6,<3.7.0a0", + "requests", + "setuptools", + "xmlrpc2" + ], + "license": "Academic Free License", + "license_family": "Other", + "md5": "520d348fb9ada1871a95ef4630e8f2d6", + "name": "bandersnatch", + "sha256": "babc7da25b67669b8d00c588aebb7850a2ea973e315c170fbfa1a88886a128e7", + "size": 198140, + "subdir": "linux-64", + "timestamp": 1550266673092, + "version": "3.2.0" + }, + "bandersnatch-3.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiohttp", + "filelock", + "packaging", + "python >=3.7,<3.8.0a0", + "requests", + "setuptools", + "xmlrpc2" + ], + "license": "Academic Free License", + "license_family": "Other", + "md5": "b532143f022516eaee0e4b2007601a0b", + "name": "bandersnatch", + "sha256": "fb99af557a96ee5cf865ecc602fc758a1caa9c2333c6367f820872cbca5a4a6f", + "size": 198928, + "subdir": "linux-64", + "timestamp": 1550266590553, + "version": "3.2.0" + }, + "basemap-1.2.0-py27h705c2d8_0.conda": { + "build": "py27h705c2d8_0", + "build_number": 0, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=1.0.0", + "numpy >=1.11.3,<2.0a0", + "pyproj >=1.9.3", + "pyshp >=1.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "84dd047350403f852f909337b2fb031a", + "name": "basemap", + "sha256": "f3d684bff4fb350f3e67bc18ff2d789120c986bc061f7301c20223f331a20164", + "size": 15116822, + "subdir": "linux-64", + "timestamp": 1539182469126, + "version": "1.2.0" + }, + "basemap-1.2.0-py36h705c2d8_0.conda": { + "build": "py36h705c2d8_0", + "build_number": 0, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=1.0.0", + "numpy >=1.11.3,<2.0a0", + "pyproj >=1.9.3", + "pyshp >=1.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "664e72c09e397dd35c49bddf976a4066", + "name": "basemap", + "sha256": "e22d54b66f5364189656e4122ce4906cc9aefbad18e7e6fda287d91c195a926d", + "size": 15117209, + "subdir": "linux-64", + "timestamp": 1539182487464, + "version": "1.2.0" + }, + "basemap-1.2.0-py36h856778e_4.conda": { + "build": "py36h856778e_4", + "build_number": 4, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=1.0.0", + "numpy >=1.14.6,<2.0a0", + "pyproj >=1.9.3,<2", + "pyshp >=1.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "a673b5ef5ca7e3f65074b14f0bd06600", + "name": "basemap", + "sha256": "bb6989d3f54858c599bcadc2f68658482018540b1ae65dda2e28ab6e122ce265", + "size": 15122416, + "subdir": "linux-64", + "timestamp": 1596635593097, + "version": "1.2.0" + }, + "basemap-1.2.0-py37h705c2d8_0.conda": { + "build": "py37h705c2d8_0", + "build_number": 0, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=1.0.0", + "numpy >=1.11.3,<2.0a0", + "pyproj >=1.9.3", + "pyshp >=1.2.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "6b08c97f6f6f74f3844ccada30dbb763", + "name": "basemap", + "sha256": "14e147a860882a00e064cdf88231537b7b8a9f36630f288461b3ceda8a86f4e4", + "size": 15117953, + "subdir": "linux-64", + "timestamp": 1539182483238, + "version": "1.2.0" + }, + "basemap-1.2.0-py37h856778e_4.conda": { + "build": "py37h856778e_4", + "build_number": 4, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=1.0.0", + "numpy >=1.14.6,<2.0a0", + "pyproj >=1.9.3,<2", + "pyshp >=1.2.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "e858d347a0497428e50d637a1d3a2457", + "name": "basemap", + "sha256": "5f66d677c803a796039fd3275f731ca625a18690bda1c4ba9463ce2256aeccd6", + "size": 15129347, + "subdir": "linux-64", + "timestamp": 1596635582974, + "version": "1.2.0" + }, + "basemap-1.2.0-py38h856778e_4.conda": { + "build": "py38h856778e_4", + "build_number": 4, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=1.0.0", + "numpy >=1.14.6,<2.0a0", + "pyproj >=1.9.3,<2", + "pyshp >=1.2.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "md5": "51e31daf205118bdd49a62a632043be8", + "name": "basemap", + "sha256": "e9730e74941769eb34286be353f69f82df769b972b2a9eaf174ffa52d55d52cd", + "size": 15114122, + "subdir": "linux-64", + "timestamp": 1596635583089, + "version": "1.2.0" + }, + "basemap-1.2.2-py37hc66db60_2.conda": { + "build": "py37hc66db60_2", + "build_number": 2, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.0.0,!=3.0.1", + "numpy >=1.16.6,<2.0a0", + "proj", + "pyproj >=1.9.3", + "pyshp >=1.2.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a5063d07f1a93b111c97ac9e2d70466", + "name": "basemap", + "sha256": "289e99307e219324b2f18712ea3eb502bf3b922b43ce122444ae4a5b6ba9c7e4", + "size": 15181554, + "subdir": "linux-64", + "timestamp": 1640155046735, + "version": "1.2.2" + }, + "basemap-1.2.2-py38hc66db60_2.conda": { + "build": "py38hc66db60_2", + "build_number": 2, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.0.0,!=3.0.1", + "numpy >=1.16.6,<2.0a0", + "proj", + "pyproj >=1.9.3", + "pyshp >=1.2.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0bb414d086c8f25442858bdfb5ff3cd3", + "name": "basemap", + "sha256": "74205a54784cb56f8d9a142f90287eb682c4fe377a4f99767048307be6d1f04c", + "size": 15179181, + "subdir": "linux-64", + "timestamp": 1640169161133, + "version": "1.2.2" + }, + "basemap-1.2.2-py39hc66db60_2.conda": { + "build": "py39hc66db60_2", + "build_number": 2, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.0.0,!=3.0.1", + "numpy >=1.16.6,<2.0a0", + "proj", + "pyproj >=1.9.3", + "pyshp >=1.2.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6b784f1281dbe3070858be9d49f7df6", + "name": "basemap", + "sha256": "a4aeaee4646ed39ecc4bcd54d3ab63a547e187005182e0eda7903ac67fc8ab83", + "size": 15178871, + "subdir": "linux-64", + "timestamp": 1640169154374, + "version": "1.2.2" + }, + "basemap-1.3.2-py310hb079758_1.conda": { + "build": "py310hb079758_1", + "build_number": 1, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "basemap-data >=1.3.2,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geos >=3.8.0,<4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.5,!=3.0.1", + "numpy >=1.21.2,<2.0a0", + "pyproj >=1.9.3,<3.4", + "pyshp >=1.2.0,<2.2", + "python >=3.10,<3.11.0a0", + "six >=1.10,<1.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85336b3fa226c77d455bda9e7b90a247", + "name": "basemap", + "sha256": "37fc9b8a61f4a03a6b2754a116396d8afedb3145f456d966729d6506f16b4885", + "size": 237004, + "subdir": "linux-64", + "timestamp": 1645455834328, + "version": "1.3.2" + }, + "basemap-1.3.2-py38hb079758_1.conda": { + "build": "py38hb079758_1", + "build_number": 1, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "basemap-data >=1.3.2,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geos >=3.8.0,<4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.5,!=3.0.1", + "numpy >=1.21.2,<2.0a0", + "pyproj >=1.9.3,<3.4", + "pyshp >=1.2.0,<2.2", + "python >=3.8,<3.9.0a0", + "six >=1.10,<1.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a2d82078e5cb09a7f8e12f85c0e19a20", + "name": "basemap", + "sha256": "1d8ce24a019f400bf4fdb2051a0e42ba5ec063b933e4f2906342fb13f8de521b", + "size": 164341, + "subdir": "linux-64", + "timestamp": 1645455808582, + "version": "1.3.2" + }, + "basemap-1.3.2-py39hb079758_1.conda": { + "build": "py39hb079758_1", + "build_number": 1, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "basemap-data >=1.3.2,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geos >=3.8.0,<4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.5,!=3.0.1", + "numpy >=1.21.2,<2.0a0", + "pyproj >=1.9.3,<3.4", + "pyshp >=1.2.0,<2.2", + "python >=3.9,<3.10.0a0", + "six >=1.10,<1.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0228ebe76d8374d2fbc73cbe88c6a851", + "name": "basemap", + "sha256": "291b0d7d9c2b671463c068378a9ca8d8a7d9102ca74239061cdf4c0e1bd9c2a4", + "size": 162851, + "subdir": "linux-64", + "timestamp": 1645455856256, + "version": "1.3.2" + }, + "basemap-1.3.6-py310h1176785_1.conda": { + "build": "py310h1176785_1", + "build_number": 1, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geos >=3.8.0,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=1.5,!=3.0.1,<3.7", + "numpy >=1.21.5,<2.0a0", + "pyproj >=1.9.3,<3.5.0", + "pyshp >=1.2.0,<2.4", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e24f1c3a856ca451432f0301b4a79c6c", + "name": "basemap", + "sha256": "5153b9023ba11a530a8740f495de4a2e250c1e2437233e17081bf5d0e6159a90", + "size": 165742, + "subdir": "linux-64", + "timestamp": 1674758299728, + "version": "1.3.6" + }, + "basemap-1.3.6-py311h1176785_1.conda": { + "build": "py311h1176785_1", + "build_number": 1, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geos >=3.8.0,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=1.5,!=3.0.1,<3.7", + "numpy >=1.22.3,<2.0a0", + "pyproj >=1.9.3,<3.5.0", + "pyshp >=1.2.0,<2.4", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16041e4d27fbf41e602a55d39160363f", + "name": "basemap", + "sha256": "53a72a15b7f6d5fb7826e23bfa8e69f4aaed497cb0738f986c229820ec18351c", + "size": 187110, + "subdir": "linux-64", + "timestamp": 1676843374497, + "version": "1.3.6" + }, + "basemap-1.3.6-py37h1176785_1.conda": { + "build": "py37h1176785_1", + "build_number": 1, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geos >=3.8.0,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=1.5,!=3.0.1,<3.7", + "numpy >=1.21.5,<2.0a0", + "pyproj >=1.9.3,<3.5.0", + "pyshp >=1.2.0,<2.4", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b7b8aa75642ed2e7caa1e9088327a81", + "name": "basemap", + "sha256": "44f29ccd765417903fa34d7a3f8830b7d0507e5025142164ee8caa58245747d6", + "size": 165316, + "subdir": "linux-64", + "timestamp": 1674758317223, + "version": "1.3.6" + }, + "basemap-1.3.6-py38h1176785_1.conda": { + "build": "py38h1176785_1", + "build_number": 1, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geos >=3.8.0,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=1.5,!=3.0.1,<3.7", + "numpy >=1.21.5,<2.0a0", + "pyproj >=1.9.3,<3.5.0", + "pyshp >=1.2.0,<2.4", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e0ce411c5c6045cd8d6b84e2df62614", + "name": "basemap", + "sha256": "ba6323f9e344bcf66fa015df85da259c2c61161e98c0e29ebd700e7ddebdc856", + "size": 167195, + "subdir": "linux-64", + "timestamp": 1674758334717, + "version": "1.3.6" + }, + "basemap-1.3.6-py39h1176785_1.conda": { + "build": "py39h1176785_1", + "build_number": 1, + "constrains": [ + "proj4 <6", + "proj <6" + ], + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geos >=3.8.0,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=1.5,!=3.0.1,<3.7", + "numpy >=1.21.5,<2.0a0", + "pyproj >=1.9.3,<3.5.0", + "pyshp >=1.2.0,<2.4", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ded502d0ae9b0a8e144113e8285385f", + "name": "basemap", + "sha256": "6f172bab89fad5a10d1a46fc41247d00c4e6dc93f2c4efdfd00b0225a99233d8", + "size": 165084, + "subdir": "linux-64", + "timestamp": 1674758281859, + "version": "1.3.6" + }, + "basemap-data-1.3.6-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "0178b0e6d829fc999bec29ce271889e2", + "name": "basemap-data", + "sha256": "086c8a79b32323eba06fc63db0f582490813cc905a767fefc1a409c081e2d716", + "size": 26981979, + "subdir": "linux-64", + "timestamp": 1674758203303, + "version": "1.3.6" + }, + "basemap-data-1.3.6-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "7db980a03731b6754f7283a1648b5fe6", + "name": "basemap-data", + "sha256": "8f3c62edab85509b014c5fd03085cb034698eaf25bd1a5649baf611dafacc819", + "size": 24916794, + "subdir": "linux-64", + "timestamp": 1676843349813, + "version": "1.3.6" + }, + "basemap-data-1.3.6-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "f9601a61112ceacf03508c51ea0e9768", + "name": "basemap-data", + "sha256": "d5bf6b088dbc8ff71ad4cffb4cfd3cc8ced3126491713f1bde74dc81745feb57", + "size": 26992221, + "subdir": "linux-64", + "timestamp": 1674758225238, + "version": "1.3.6" + }, + "basemap-data-1.3.6-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "b1949566ae138620715b62faa7bf21f9", + "name": "basemap-data", + "sha256": "a9014ff0741e01c224a26aaef1e82ca7e32af71e14543f8f14b342478e2c75a3", + "size": 26980043, + "subdir": "linux-64", + "timestamp": 1674758247310, + "version": "1.3.6" + }, + "basemap-data-1.3.6-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "f96f82961867a8af78476b36b9c76176", + "name": "basemap-data", + "sha256": "d701de9a9ae5468d0cc577fe8d0e0967a34e1e2fb4998d7cd1eb7d58116d99ed", + "size": 26982419, + "subdir": "linux-64", + "timestamp": 1674758180977, + "version": "1.3.6" + }, + "basemap-data-hires-1.2.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "basemap >1.0.7" + ], + "license": "GPL-2.0", + "md5": "c685737af151874f248303b54ea43ea7", + "name": "basemap-data-hires", + "sha256": "bbe0c01fcdc943f579b4153fc14b071ffde833c9e03fc17b1913c692a7cf28a5", + "size": 87917168, + "subdir": "linux-64", + "timestamp": 1539184858018, + "version": "1.2.0" + }, + "basemap-data-hires-1.3.6-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "e8d18c2029762e5768a02b047b81f1ca", + "name": "basemap-data-hires", + "sha256": "5e1c79d7f12504b9aa30c4acaa80a1b1e48f9d2854753b2c3da97669b7dcb31e", + "size": 102514748, + "subdir": "linux-64", + "timestamp": 1674758409330, + "version": "1.3.6" + }, + "basemap-data-hires-1.3.6-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "83c3fc7ea234c0c71afc9e929a21ab43", + "name": "basemap-data-hires", + "sha256": "38f43376ce01c48ca4fa62deeae79ab99ac8952439eb7b52f3292518de4e36f3", + "size": 84801587, + "subdir": "linux-64", + "timestamp": 1676843392282, + "version": "1.3.6" + }, + "basemap-data-hires-1.3.6-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "72f21acd2213bae1cdf4c975d43f1df8", + "name": "basemap-data-hires", + "sha256": "f30612194b3796bab4ffb9887725e042d9fe897100da9d30032f0670d82d4064", + "size": 102499659, + "subdir": "linux-64", + "timestamp": 1674758463947, + "version": "1.3.6" + }, + "basemap-data-hires-1.3.6-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "55c3bd9caa67e2a4b8746857ac93682f", + "name": "basemap-data-hires", + "sha256": "54d3a0cf443e4069e95364ef2359bfa923183689b5e1f093cfed13a7c8a2b007", + "size": 102514725, + "subdir": "linux-64", + "timestamp": 1674758518221, + "version": "1.3.6" + }, + "basemap-data-hires-1.3.6-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "basemap-data >=1.3.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "4e5e9bd08f013475d90e996736a48d0f", + "name": "basemap-data-hires", + "sha256": "a808f804ffeab7ee0a38b3cc93592e7650d8db6234616f6124ad8146b0bea3c3", + "size": 102514708, + "subdir": "linux-64", + "timestamp": 1674758354336, + "version": "1.3.6" + }, + "bash-5.0.018-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "readline >=8.0,<9.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "d5489b440708d631b656cd956311dce9", + "name": "bash", + "sha256": "ff05224ff733fce0290737d49f809bbbb0f36d473feb47fa5b9664b992d205d7", + "size": 1628798, + "subdir": "linux-64", + "timestamp": 1600093348344, + "version": "5.0.018" + }, + "bash-5.0.018-hf6cebf6_0.conda": { + "build": "hf6cebf6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "readline >=8.0,<9.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "f955729e14dc4d7de83b8d97d1078720", + "name": "bash", + "sha256": "a2dd94fef5b7629805725e83235654a39e4cb756b2fc333d97d615a376f9f2b7", + "size": 1629802, + "subdir": "linux-64", + "timestamp": 1600093036752, + "version": "5.0.018" + }, + "bazel-0.11.1-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3395dd02773bc4536679adb562b6601d", + "name": "bazel", + "sha256": "688c28505826adcc766752e73ed1fda558b756c92bf17d34519e5924e01a5c2c", + "size": 95899008, + "subdir": "linux-64", + "timestamp": 1521222548963, + "version": "0.11.1" + }, + "bazel-0.12.0-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1382605cc3ed189796ec5efb76f4f95d", + "name": "bazel", + "sha256": "4ae2a02330f28cb898d1bd1783a34350d9750d5b91077d4a01bd5733c74f27a5", + "size": 101913577, + "subdir": "linux-64", + "timestamp": 1524779316808, + "version": "0.12.0" + }, + "bazel-0.14.0-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0e124a80a4cecdbf5f7658da0928a9e0", + "name": "bazel", + "sha256": "a9be13ea04a8a79c97260e9caf34533326c232b704fb8016c3e875ca2abae119", + "size": 111578878, + "subdir": "linux-64", + "timestamp": 1528051265615, + "version": "0.14.0" + }, + "bazel-0.15.2-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a5189c215dba21691eadd511b6af482a", + "name": "bazel", + "sha256": "308501a3e3b425ac54bfb10cb81eebbda952e0fc9f6ab30f447b1022a3940501", + "size": 111609929, + "subdir": "linux-64", + "timestamp": 1532770048926, + "version": "0.15.2" + }, + "bazel-0.16.1-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3dd9c5c3fd1dd87e0b4a9f060c19e853", + "name": "bazel", + "sha256": "4849dada3ec56017c3feb579bc349caf88bbff36390ff259211fb01bb09982cf", + "size": 116313975, + "subdir": "linux-64", + "timestamp": 1536529851920, + "version": "0.16.1" + }, + "bazel-0.17.2-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6d716abbb195d5ba0bef7ddbd6b06f3f", + "name": "bazel", + "sha256": "8c3f5c0db74f88ed5fdf0c67a646d0e21229959e2fb809df0f2ca10a9102098c", + "size": 119623754, + "subdir": "linux-64", + "timestamp": 1539499169818, + "version": "0.17.2" + }, + "bazel-0.18.0-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "25524db500af51752327d216c55c2a55", + "name": "bazel", + "sha256": "3277397e87eb780de9f07633352dfa7f5dd86b0a7191b9bd3ea42cd685e95d0d", + "size": 119456748, + "subdir": "linux-64", + "timestamp": 1540700745611, + "version": "0.18.0" + }, + "bazel-0.20.0-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c14dc110374dff04cf47f212489612b4", + "name": "bazel", + "sha256": "782db722425d4902f9148c06d2f0bc894a86f52d289587792cbbbdb0a8e9ffee", + "size": 124656625, + "subdir": "linux-64", + "timestamp": 1551306162127, + "version": "0.20.0" + }, + "bazel-0.22.0-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8a9549d86fb33c6199a90393aaf88446", + "name": "bazel", + "sha256": "c43f5d62c7c0ed2fc156b3084df732ef354d2fede712408d8957986ab610e2fe", + "size": 122125847, + "subdir": "linux-64", + "timestamp": 1550319721199, + "version": "0.22.0" + }, + "bazel-0.24.1-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "68f5752d742db1c47f1e10813e5e5594", + "name": "bazel", + "sha256": "2d53990bccded36c3cf5c50a0d55c158f4d80812026f43657de8d0599fee4f99", + "size": 75353527, + "subdir": "linux-64", + "timestamp": 1560980359581, + "version": "0.24.1" + }, + "bazel-0.26.1-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f1ab6a2eca7594fa69083195c26c6191", + "name": "bazel", + "sha256": "bfb27fd937a4b20e23a68b511cf191bba84857d8a4f9235f1467da457c0d439e", + "size": 38933185, + "subdir": "linux-64", + "timestamp": 1571428987182, + "version": "0.26.1" + }, + "bazel-0.29.1-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1002df5849e130659cfbf9080ba43a0b", + "name": "bazel", + "sha256": "3809a5f4ec89202f4c1ad4f92d89403f1ece811fb5c9bfbd5c197ab23904f86a", + "size": 34997950, + "subdir": "linux-64", + "timestamp": 1581955009645, + "version": "0.29.1" + }, + "bazel-0.5.4-hf484d3e_1.conda": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "afaa49d6260931121754eb20d9706e12", + "name": "bazel", + "sha256": "4d76b358ab4720125841454a8fb83c58db6d24fe1c424f995d592e31a57f2e75", + "size": 119148661, + "subdir": "linux-64", + "timestamp": 1516395214083, + "version": "0.5.4" + }, + "bazel-2.0.0-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a315648200a8dde27b7da7a851b23e45", + "name": "bazel", + "sha256": "0dc50977068cc94720920b626d9e3b6825d0c3b334c4369e49279b05d7503e7d", + "size": 30496701, + "subdir": "linux-64", + "timestamp": 1589913678600, + "version": "2.0.0" + }, + "bazel-3.1.0-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7dd1ba41f82a6879fa5bdb1a9143263a", + "name": "bazel", + "sha256": "ae9203870e77cffff742d03e652bdfec8c0c2e55e2c6012c84ba06fb197b4ef7", + "size": 31093752, + "subdir": "linux-64", + "timestamp": 1597657999852, + "version": "3.1.0" + }, + "bazel-3.7.2-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openjdk >=8" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "de2ae2af789741f119d1c987a867df7d", + "name": "bazel", + "sha256": "ee10f20f054b951fc4f1dc32057b397431323fdfa79c9a31b9405dbf95fe1840", + "size": 32281433, + "subdir": "linux-64", + "timestamp": 1621946165467, + "version": "3.7.2" + }, + "bazel-4.2.2-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "openjdk >=8" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "068c7f1a4de72de4d4e223f70594d75f", + "name": "bazel", + "sha256": "e8bdb5ef4c93dd55e1124f74571146d1408074988c884446761b89290c363f29", + "size": 28715891, + "subdir": "linux-64", + "timestamp": 1657727073757, + "version": "4.2.2" + }, + "bazel-4.2.2-h6a678d5_1.conda": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "openjdk >=8" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d383e72d47a0a338f77adcc24a2ecc02", + "name": "bazel", + "sha256": "d0fc76508948c14f5cf4b980350698f4aad7822869e6a6a4001d0c8a635ade3a", + "size": 40115864, + "subdir": "linux-64", + "timestamp": 1658237334221, + "version": "4.2.2" + }, + "bazel-5.2.0-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "openjdk >=8" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c49485848cc95f86fac4d6bee4580558", + "name": "bazel", + "sha256": "7ad06aa3350fc1bc53ae1c250eee5f9ec7471e4c3dbf08da599b47b8db88ef22", + "size": 41517338, + "subdir": "linux-64", + "timestamp": 1660817280139, + "version": "5.2.0" + }, + "bcj-cffi-0.5.1-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.14.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1", + "md5": "21e04d31b4df21933747688594da7c94", + "name": "bcj-cffi", + "sha256": "5a68a89620f64781459c7d46df2c0831ae16ef615d55509e8829a7ffbea186de", + "size": 36641, + "subdir": "linux-64", + "timestamp": 1640803537941, + "version": "0.5.1" + }, + "bcj-cffi-0.5.1-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "cffi >=1.14.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.1", + "md5": "cb111da32b57be683865c720957aa9de", + "name": "bcj-cffi", + "sha256": "ceec2afe97af5efb7146d4907c568df265d19332a1b879ec2a7e25f70ef02bb1", + "size": 25650, + "subdir": "linux-64", + "timestamp": 1676846959934, + "version": "0.5.1" + }, + "bcj-cffi-0.5.1-py36h295c915_0.conda": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.14.0", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "7497001a8daae1f0166efd1eea8e9112", + "name": "bcj-cffi", + "sha256": "d5269a516f3ab5ba56d7f02684be68c9d003140a4dfbc7a48dbbe3c356084de2", + "size": 25706, + "subdir": "linux-64", + "timestamp": 1633080167777, + "version": "0.5.1" + }, + "bcj-cffi-0.5.1-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.14.0", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1", + "md5": "ef3b24df543dde4a1fd690fb0056c748", + "name": "bcj-cffi", + "sha256": "9ffeee6ad8ebae7bbdf49da2ae2663ab713403c21dd93a5d1b0413b4f40f29fa", + "size": 25666, + "subdir": "linux-64", + "timestamp": 1633090680742, + "version": "0.5.1" + }, + "bcj-cffi-0.5.1-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.14.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1", + "md5": "7554a22319a91261d73ed17cae9df01d", + "name": "bcj-cffi", + "sha256": "39f7a311ab138577ed0591b29ecb95eaffeed98853c088a0831b9f349c0fe33d", + "size": 25722, + "subdir": "linux-64", + "timestamp": 1633090671797, + "version": "0.5.1" + }, + "bcj-cffi-0.5.1-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.14.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1", + "md5": "5e556fb5d739aaee322973746f3ba8f8", + "name": "bcj-cffi", + "sha256": "42b8fe627c0a600166a5b45d8fbbafc5f9e4e1d4b79a5d1816000457ac036295", + "size": 25711, + "subdir": "linux-64", + "timestamp": 1633090541820, + "version": "0.5.1" + }, + "bcolz-1.1.2-py27hde39a96_0.conda": { + "build": "py27hde39a96_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytables", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e7f95e7f7d6efa487a19282f4f69557f", + "name": "bcolz", + "sha256": "71be1389581209ddb831e4b5ab5cd1af5f8759786403f38e51c91011172d773e", + "size": 622494, + "subdir": "linux-64", + "timestamp": 1509220450109, + "version": "1.1.2" + }, + "bcolz-1.1.2-py35hcb27967_0.conda": { + "build": "py35hcb27967_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytables", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c737f1a90632e8d94ad4a78faf7897dc", + "name": "bcolz", + "sha256": "8edbad8400ee6d795dcca4ca72ec5df932bfe9ca16713788d7e53890fff09016", + "size": 624047, + "subdir": "linux-64", + "timestamp": 1509220409885, + "version": "1.1.2" + }, + "bcolz-1.1.2-py36h00f5784_0.conda": { + "build": "py36h00f5784_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytables", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0049c03a34b59fcfd4c43604a2f6f3e", + "name": "bcolz", + "sha256": "0e99fc15c5771a5a74e1566424e0afec4eb00ea60805a67f23925097169e0a8f", + "size": 619983, + "subdir": "linux-64", + "timestamp": 1509220309435, + "version": "1.1.2" + }, + "bcolz-1.2.0-py27h637b7d7_0.conda": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytables", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cf4371480f47fa6b6ac691751e50ff98", + "name": "bcolz", + "sha256": "9ea9d24efe9c796d39577fa9dbfca566cfdddbd94bc3ed02ad5b36f73a23e31a", + "size": 698771, + "subdir": "linux-64", + "timestamp": 1522705130413, + "version": "1.2.0" + }, + "bcolz-1.2.0-py35h637b7d7_0.conda": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytables", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce65ca47eda8f17ad5a282cf37eeb735", + "name": "bcolz", + "sha256": "640fbd2cb990ada67462f3077c5eebed08c4d85f391bb8161aaa245a5b2a0a34", + "size": 702669, + "subdir": "linux-64", + "timestamp": 1522705178876, + "version": "1.2.0" + }, + "bcolz-1.2.0-py36h637b7d7_0.conda": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytables", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "145500360b93bb893605739f8e7618f0", + "name": "bcolz", + "sha256": "938f83a7df75ace1221b026659685e0092dc1e79d5b661d00e8e43f8843b4026", + "size": 708739, + "subdir": "linux-64", + "timestamp": 1522704711877, + "version": "1.2.0" + }, + "bcolz-1.2.1-py27h04863e7_0.conda": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.11.3,<2.0a0", + "pandas", + "pytables", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d7e8ff1deaaca00578f75008e0f31fb", + "name": "bcolz", + "sha256": "874f285f8a6eb2fcabb9335c74cb3d4612ddd3eeaa5118f46e04f7048c489361", + "size": 713868, + "subdir": "linux-64", + "timestamp": 1530742231552, + "version": "1.2.1" + }, + "bcolz-1.2.1-py27h637b7d7_0.conda": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytables", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "332d1d62a7c4194dd439a15166f7a9e1", + "name": "bcolz", + "sha256": "c31cc799f735c46381fdeb3d4341bf3ea0aeaa2a1ecb34dc4af4f1a944afd792", + "size": 714378, + "subdir": "linux-64", + "timestamp": 1523992838201, + "version": "1.2.1" + }, + "bcolz-1.2.1-py35h04863e7_0.conda": { + "build": "py35h04863e7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.11.3,<2.0a0", + "pandas", + "pytables", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e09065ed09aefb50410519e5aeb32c6", + "name": "bcolz", + "sha256": "f098e462fc337733595367807075c1e2d15206a7c28f209150f8c959cdc4c6c7", + "size": 717904, + "subdir": "linux-64", + "timestamp": 1534356711001, + "version": "1.2.1" + }, + "bcolz-1.2.1-py35h637b7d7_0.conda": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytables", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebb5a36c66ecffef49fba8880db44b3b", + "name": "bcolz", + "sha256": "8b1f863cc81b5977be69b674cfb9697737f6a04e234fb013651c0d14e1dc6dd2", + "size": 721157, + "subdir": "linux-64", + "timestamp": 1523992232979, + "version": "1.2.1" + }, + "bcolz-1.2.1-py36h04863e7_0.conda": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.11.3,<2.0a0", + "pandas", + "pytables", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "38538804ecffcbb511d840035c186a99", + "name": "bcolz", + "sha256": "1b278cce28578a434ef44765bdc1a50cdc8c86ff241022c25520264c0b47790b", + "size": 723559, + "subdir": "linux-64", + "timestamp": 1530742036156, + "version": "1.2.1" + }, + "bcolz-1.2.1-py36h637b7d7_0.conda": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytables", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba37634e23a16cea25aa9892b192e60c", + "name": "bcolz", + "sha256": "c9c2d349578656b9723f1f8cd1ee1321c478594de8aef4ed2c2114a75cc04fb2", + "size": 724018, + "subdir": "linux-64", + "timestamp": 1523992848531, + "version": "1.2.1" + }, + "bcolz-1.2.1-py37h04863e7_0.conda": { + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numexpr >=2.5.2", + "numpy >=1.11.3,<2.0a0", + "pandas", + "pytables", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f80f828c1cab2b7737acadc18aaa7f87", + "name": "bcolz", + "sha256": "dd924cdf29b57f4c66ea0fe39b1da66af4dde2816babf581dec661899923c011", + "size": 723029, + "subdir": "linux-64", + "timestamp": 1530742412794, + "version": "1.2.1" + }, + "bcolz-1.2.1-py37h51133e4_1.conda": { + "build": "py37h51133e4_1", + "build_number": 1, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.5.2", + "numpy >=1.16.6,<2.0a0", + "pandas", + "pytables", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "7aeee92142f0035ebf85cd7bde1217b4", + "name": "bcolz", + "sha256": "322198af3700ca09a092fedbcb4551485b3310f5c28cd62645602f6c6753e49b", + "size": 734838, + "subdir": "linux-64", + "timestamp": 1639546151131, + "version": "1.2.1" + }, + "bcolz-1.2.1-py38h51133e4_1.conda": { + "build": "py38h51133e4_1", + "build_number": 1, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.5.2", + "numpy >=1.16.6,<2.0a0", + "pandas", + "pytables", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "bc7ffcd93a11ff607eba421b4c043bcf", + "name": "bcolz", + "sha256": "069c7eaa492d261659a1967cd4b62a80cc3b99a7173a4b97428f7fa139cdee09", + "size": 751917, + "subdir": "linux-64", + "timestamp": 1639550466469, + "version": "1.2.1" + }, + "bcolz-1.2.1-py38h962f231_0.conda": { + "build": "py38h962f231_0", + "build_number": 0, + "depends": [ + "dask >=0.9.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numexpr >=2.5.2", + "numpy >=1.11.3,<2.0a0", + "pandas", + "pytables", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "201757a685ca807f2f81382cea407071", + "name": "bcolz", + "sha256": "8c8c9c36b2815859d145171a2437446c282e7ad5096275a29bac519c1a56b156", + "size": 751184, + "subdir": "linux-64", + "timestamp": 1574182281437, + "version": "1.2.1" + }, + "bcrypt-3.1.4-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "cb7b2813426d810189384aa3075fff8d", + "name": "bcrypt", + "sha256": "76d1f832eef3368b5110ed7560f3bce12b23197c69e0e382f66c3a5963d810f6", + "size": 38952, + "subdir": "linux-64", + "timestamp": 1530736167577, + "version": "3.1.4" + }, + "bcrypt-3.1.4-py27h8473b39_0.conda": { + "build": "py27h8473b39_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "9e32367a6b327a22a48f7810288484eb", + "name": "bcrypt", + "sha256": "a6dd461476bb57226785d804e193157a9f159d82ce7d56531ecdda8d25b033a5", + "size": 39169, + "subdir": "linux-64", + "timestamp": 1508998461925, + "version": "3.1.4" + }, + "bcrypt-3.1.4-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "654b1517b4efa9a4db457b75b0e09a72", + "name": "bcrypt", + "sha256": "3b9a57f1cb831d2ae34b18dc13e8cd814293b245b2266e99debeaf04cacda5d9", + "size": 38947, + "subdir": "linux-64", + "timestamp": 1534352194214, + "version": "3.1.4" + }, + "bcrypt-3.1.4-py35ha35c455_0.conda": { + "build": "py35ha35c455_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "6c8174b75014ba5161920eb9cc4e3407", + "name": "bcrypt", + "sha256": "a34d761360cdd48f5e941dcc343fd57fd2b61125a57a536c3a982a20df8848a1", + "size": 39249, + "subdir": "linux-64", + "timestamp": 1508998464712, + "version": "3.1.4" + }, + "bcrypt-3.1.4-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "58843572f2f5697784fae35957cfbdc4", + "name": "bcrypt", + "sha256": "b0c0286babf921de2317e14b788c174099d9d4694bbeeb941208a79cd7b9b83f", + "size": 38982, + "subdir": "linux-64", + "timestamp": 1530736143460, + "version": "3.1.4" + }, + "bcrypt-3.1.4-py36h621fe67_0.conda": { + "build": "py36h621fe67_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "f90122501c41731a1829432bf9f34f87", + "name": "bcrypt", + "sha256": "381b0d4cb794b53e0254315b43e4ea78785c6be4bd0d0b3cad26bf9d52fa07d2", + "size": 39439, + "subdir": "linux-64", + "timestamp": 1508998405525, + "version": "3.1.4" + }, + "bcrypt-3.1.4-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "e845c5e654561a410dfda983b0838190", + "name": "bcrypt", + "sha256": "2761162a9ecc95740b4c9228eff7d2aec55ac26e9afdf0d94f165fbacb67961c", + "size": 38985, + "subdir": "linux-64", + "timestamp": 1530736190483, + "version": "3.1.4" + }, + "bcrypt-3.1.5-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "0db5460d9b62238de9311385feb156da", + "name": "bcrypt", + "sha256": "a880e2fece2accb6a8bea5a214459944c06604365d3d505960ad50b9b0a752d3", + "size": 40316, + "subdir": "linux-64", + "timestamp": 1545091270205, + "version": "3.1.5" + }, + "bcrypt-3.1.5-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "8fd0d2acdda8658105c8f77cb159a2cd", + "name": "bcrypt", + "sha256": "c7b80b62687900da5cb27fba53eeacd87935678c9475acc75fae9f9a6a406282", + "size": 39947, + "subdir": "linux-64", + "timestamp": 1545091262470, + "version": "3.1.5" + }, + "bcrypt-3.1.5-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "ad68d9303f8fc3fbfed2fe0f70ef119c", + "name": "bcrypt", + "sha256": "6b986cb8a61a6f96dcc332533fd9c02646da5dec21a83649067b9e57403efc9c", + "size": 39941, + "subdir": "linux-64", + "timestamp": 1545091288236, + "version": "3.1.5" + }, + "bcrypt-3.1.6-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "3ebd4a41992d1c701eb383607a989860", + "name": "bcrypt", + "sha256": "8b018d5b46eff458a8539421909bacda1f97edcd1b67384d1d7931557d67a4ce", + "size": 184350, + "subdir": "linux-64", + "timestamp": 1547747204016, + "version": "3.1.6" + }, + "bcrypt-3.1.6-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "f5b93a2e9d2c62d3d240aa5ff44d6a5f", + "name": "bcrypt", + "sha256": "877673adb58c8c18da3eea4aafa99197367ed76e06e4515366693aa675c0187e", + "size": 184122, + "subdir": "linux-64", + "timestamp": 1547747246680, + "version": "3.1.6" + }, + "bcrypt-3.1.6-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "74c312f34936d004e7229658f43ac87f", + "name": "bcrypt", + "sha256": "f5d72389fb1dc5ffdf8bf1615c29a8645f7b8b13755d6d7e0063580a1037e67c", + "size": 184415, + "subdir": "linux-64", + "timestamp": 1547747333365, + "version": "3.1.6" + }, + "bcrypt-3.1.7-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6191d8eda4033eb110bfbae0960d2c6c", + "name": "bcrypt", + "sha256": "28eb430c3d448899553b09c32884f865758fd3c13686e499cc62f638c838b011", + "size": 41524, + "subdir": "linux-64", + "timestamp": 1569335757419, + "version": "3.1.7" + }, + "bcrypt-3.1.7-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "04946a73735a10ab07e3d73f2a640cab", + "name": "bcrypt", + "sha256": "1837d5ed2c6c128678028e47ac445f4ebaf145cc5f89b32a7a1812a9ff888369", + "size": 41378, + "subdir": "linux-64", + "timestamp": 1569335751086, + "version": "3.1.7" + }, + "bcrypt-3.1.7-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "pip", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cd48fdbd8c29764da950afcaf027996f", + "name": "bcrypt", + "sha256": "1e7f1cbaa3dfa717074febc008c8f4a8b8af1f3abbf1c463c3d8276dd8410bd2", + "size": 42764, + "subdir": "linux-64", + "timestamp": 1591779988799, + "version": "3.1.7" + }, + "bcrypt-3.1.7-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1f4a7ddef3b47dfaa61e55164d7e9189", + "name": "bcrypt", + "sha256": "e02d62cd7ca7d568b94c5a26b08d429136f316887a377b5eb3947f4883152498", + "size": 41363, + "subdir": "linux-64", + "timestamp": 1569335757392, + "version": "3.1.7" + }, + "bcrypt-3.1.7-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "pip", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3df452a3428addb6b017fe3d163ab7a4", + "name": "bcrypt", + "sha256": "e11dd0409b7b50ff188cb97a55df475761e0a70e415594d291566bf049048d1a", + "size": 42423, + "subdir": "linux-64", + "timestamp": 1591779976848, + "version": "3.1.7" + }, + "bcrypt-3.1.7-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "929c0bc30664e21df020566502eb3b51", + "name": "bcrypt", + "sha256": "68e873b8e1189b61acce6b43591f89503f300e01d8773a1f7401b07ae6fac4cd", + "size": 40584, + "subdir": "linux-64", + "timestamp": 1574097639792, + "version": "3.1.7" + }, + "bcrypt-3.1.7-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "pip", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "909a6b7fe3b717d2f27474f27654df8a", + "name": "bcrypt", + "sha256": "c6faf82de02647f0152cb79376ec206b2de740354f134341282daceb85f6cf23", + "size": 42550, + "subdir": "linux-64", + "timestamp": 1591779985418, + "version": "3.1.7" + }, + "bcrypt-3.2.0-py310h5eee18b_1.conda": { + "build": "py310h5eee18b_1", + "build_number": 1, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=11.2.0", + "pip", + "python >=3.10,<3.11.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7224543b22fff50496690dd0141fbaf9", + "name": "bcrypt", + "sha256": "886b2734f3d78c3836cdc1ff594832d1cd7a48856c1141e35fcff744a7311917", + "size": 66741, + "subdir": "linux-64", + "timestamp": 1659554528313, + "version": "3.2.0" + }, + "bcrypt-3.2.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.5.0", + "pip", + "python >=3.10,<3.11.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e5c2649b0d55fdf2bc8c3beea6a5ef38", + "name": "bcrypt", + "sha256": "d3242934a3434d02a83065aff7ec846e5010d781a03573bb593f544d4dda4bf0", + "size": 64278, + "subdir": "linux-64", + "timestamp": 1640803569515, + "version": "3.2.0" + }, + "bcrypt-3.2.0-py311h5eee18b_1.conda": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=11.2.0", + "pip", + "python >=3.11,<3.12.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9726aafdbe70b8f4283f1612fa328bb0", + "name": "bcrypt", + "sha256": "57c3fc6b2c8d7b00420ca15aa1c1b8af3b9b5339dcfeaff8105925f905207c48", + "size": 42222, + "subdir": "linux-64", + "timestamp": 1676825161053, + "version": "3.2.0" + }, + "bcrypt-3.2.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "pip", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e205b2d8cdb0c4ca48735727f3944960", + "name": "bcrypt", + "sha256": "fde1f20d44a3093591e2848e0af0a4bacda6fe02577ede30e11191ed0d3e0086", + "size": 44007, + "subdir": "linux-64", + "timestamp": 1597936248557, + "version": "3.2.0" + }, + "bcrypt-3.2.0-py37h5eee18b_1.conda": { + "build": "py37h5eee18b_1", + "build_number": 1, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=11.2.0", + "pip", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "18e530f29e6db34f50fdcd020fee5136", + "name": "bcrypt", + "sha256": "18c8a801645f54bbd134ddd617a1d75acced9967b8192d201ae9362edcc27786", + "size": 41969, + "subdir": "linux-64", + "timestamp": 1659554471582, + "version": "3.2.0" + }, + "bcrypt-3.2.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "pip", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "78dc45a0e34df04f5ca6e6c218cc6182", + "name": "bcrypt", + "sha256": "56ce7684437bd96fa26d1c734591d1be6500070c5b13438ec0db2b5ebffb9a59", + "size": 44010, + "subdir": "linux-64", + "timestamp": 1597936271367, + "version": "3.2.0" + }, + "bcrypt-3.2.0-py38h5eee18b_1.conda": { + "build": "py38h5eee18b_1", + "build_number": 1, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=11.2.0", + "pip", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7d1dffed5ba21253e33b3f402d107a6f", + "name": "bcrypt", + "sha256": "c36f3713c6388c2a6b08f409286dc163bba4547ed17f5533144cc46309671a1e", + "size": 42090, + "subdir": "linux-64", + "timestamp": 1659554390046, + "version": "3.2.0" + }, + "bcrypt-3.2.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "pip", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5151ee477970aeb5e35e5a557abb3a66", + "name": "bcrypt", + "sha256": "f10aa36b6eaa092b69c39daa667e7edc75f9f94012dd8c2a4aa6397ba29b70aa", + "size": 44100, + "subdir": "linux-64", + "timestamp": 1597936267082, + "version": "3.2.0" + }, + "bcrypt-3.2.0-py39h5eee18b_1.conda": { + "build": "py39h5eee18b_1", + "build_number": 1, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=11.2.0", + "pip", + "python >=3.9,<3.10.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3c5fa21f035c7ae1c30112bb36295217", + "name": "bcrypt", + "sha256": "8b60f4e946948c92881d3676d9839e04a0c7e2d205dd667f70112c73cb9d6d48", + "size": 42052, + "subdir": "linux-64", + "timestamp": 1659554431121, + "version": "3.2.0" + }, + "bcrypt-3.2.0-py39he8ac12f_0.conda": { + "build": "py39he8ac12f_0", + "build_number": 0, + "depends": [ + "cffi >=1.1", + "libgcc-ng >=7.3.0", + "pip", + "python >=3.9,<3.10.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b62e453ce211d24616e44aab0641ae41", + "name": "bcrypt", + "sha256": "9e061ca2c0fc9d6ccc9b8e362c314c777f8deab4f5d7eb4086330b91befb627f", + "size": 43821, + "subdir": "linux-64", + "timestamp": 1607022689227, + "version": "3.2.0" + }, + "beautifulsoup4-4.11.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "859a38644a6d4003d00276e11d5f1d5b", + "name": "beautifulsoup4", + "sha256": "e81aa1386c787b65ce15926be815418009c015fde50da24ba12f7386637d49cb", + "size": 192154, + "subdir": "linux-64", + "timestamp": 1650462272428, + "version": "4.11.1" + }, + "beautifulsoup4-4.11.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec882ca504d7cc08740be4efdf53030c", + "name": "beautifulsoup4", + "sha256": "0d106b8afe45a67028190936783e2bf191f2659ecde29b7b505dbdd2f085bde1", + "size": 251138, + "subdir": "linux-64", + "timestamp": 1676823585195, + "version": "4.11.1" + }, + "beautifulsoup4-4.11.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5fa3cd288e227a118313cc293dff3a1c", + "name": "beautifulsoup4", + "sha256": "ad1540407312972d36d9691ac12ecf5ce004be81c5dd4c80e3918b53bc606b39", + "size": 189055, + "subdir": "linux-64", + "timestamp": 1650462305655, + "version": "4.11.1" + }, + "beautifulsoup4-4.11.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ee5227b070777715545dd8a9e66de17", + "name": "beautifulsoup4", + "sha256": "6e440d734276de1d02fa4a82417df78308a4c6f259710a328ba4ff9d11b0473a", + "size": 189654, + "subdir": "linux-64", + "timestamp": 1650462229973, + "version": "4.11.1" + }, + "beautifulsoup4-4.11.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f2b6dbcdbd21e365b894d1153335ef6", + "name": "beautifulsoup4", + "sha256": "c10a5a72dcd96c7f1ab59dc1fcff144b5e8168a6e1bead0cc2abc4fe644871e3", + "size": 189466, + "subdir": "linux-64", + "timestamp": 1650462197669, + "version": "4.11.1" + }, + "beautifulsoup4-4.12.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "soupsieve >1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a79e36088de14897e0cecea9e2141ab1", + "name": "beautifulsoup4", + "sha256": "f80a3ebb8ece6cf1bfe97e286bd450d18b20afe32efe3dd21ef0f8327eaf2c19", + "size": 210889, + "subdir": "linux-64", + "timestamp": 1680590007316, + "version": "4.12.0" + }, + "beautifulsoup4-4.12.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "soupsieve >1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c301d285f2ad3ff3e738568fa23293d3", + "name": "beautifulsoup4", + "sha256": "3516de6157fd520ecd22379a3d9dbf097586e9f08c34c36fc010168f74960009", + "size": 267781, + "subdir": "linux-64", + "timestamp": 1680589998073, + "version": "4.12.0" + }, + "beautifulsoup4-4.12.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "soupsieve >1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6661534fb39bd2ba20132a7cccaf6e18", + "name": "beautifulsoup4", + "sha256": "891e883d6623eeef07d2834ac1d224ceac094eef635d357ba1385c2b45189892", + "size": 207975, + "subdir": "linux-64", + "timestamp": 1680590025234, + "version": "4.12.0" + }, + "beautifulsoup4-4.12.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "soupsieve >1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96903ce85d0a005c5038a43c4b86e7b6", + "name": "beautifulsoup4", + "sha256": "38a0fb1012aa3b0a0afd53a33576896d4d47c3b3e704d912614e6308f4e4e77b", + "size": 207429, + "subdir": "linux-64", + "timestamp": 1680590016327, + "version": "4.12.0" + }, + "beautifulsoup4-4.6.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "076ab769f8ded3539c037a9d6eab83d9", + "name": "beautifulsoup4", + "sha256": "14b4e02b72dff2ac02207ddcfd03121dbcb6020fd0a7bc3fd57f882f92083ba7", + "size": 140580, + "subdir": "linux-64", + "timestamp": 1530742551705, + "version": "4.6.0" + }, + "beautifulsoup4-4.6.0-py27h3f86ba9_1.conda": { + "build": "py27h3f86ba9_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77fec4d8c459b5a63c00ec011f16095e", + "name": "beautifulsoup4", + "sha256": "291b84605ff7f1e562174773572a147f6a74e00d89c5f93f1c45fe6777fde58f", + "size": 140299, + "subdir": "linux-64", + "timestamp": 1505728580658, + "version": "4.6.0" + }, + "beautifulsoup4-4.6.0-py35h442a8c9_1.conda": { + "build": "py35h442a8c9_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e9647f4ae96c03b5c109a4141c2cb4f", + "name": "beautifulsoup4", + "sha256": "18ea778d5dd24561d96d8d07e52256ee5e9f41ee3e52a42867aa16ddc6bfd078", + "size": 144224, + "subdir": "linux-64", + "timestamp": 1505728596970, + "version": "4.6.0" + }, + "beautifulsoup4-4.6.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b256c0d85a2af513c5b2f962ca93166", + "name": "beautifulsoup4", + "sha256": "e44f9d9f5ec9507d674098c491dfa22afab12a5eba284721e7a3cdd9cf0e8b0f", + "size": 140642, + "subdir": "linux-64", + "timestamp": 1530742529492, + "version": "4.6.0" + }, + "beautifulsoup4-4.6.0-py36h49b8c8c_1.conda": { + "build": "py36h49b8c8c_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "915f92143d7b71674d34e7c0920aa5eb", + "name": "beautifulsoup4", + "sha256": "bc5d48809d219ac700ab8a1bea5ca45792086716a1e4127a6f28ee425b5d200b", + "size": 140407, + "subdir": "linux-64", + "timestamp": 1505728613264, + "version": "4.6.0" + }, + "beautifulsoup4-4.6.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4a25d2ae14e4a8c9e5e642f4046b710c", + "name": "beautifulsoup4", + "sha256": "ebc3596ee689c4f2a9c67986f9b6cbe62b2def020b4693aadbf90abf1917715e", + "size": 140462, + "subdir": "linux-64", + "timestamp": 1530742579013, + "version": "4.6.0" + }, + "beautifulsoup4-4.6.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1217377c8bd0bb022e4513c13b9fae0a", + "name": "beautifulsoup4", + "sha256": "6403945c5cf9dbf25313697cd8e0bf3886f836461c13f7d6f2c00e7533430266", + "size": 144128, + "subdir": "linux-64", + "timestamp": 1532973305531, + "version": "4.6.1" + }, + "beautifulsoup4-4.6.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e8ac62022835f421b2377e995fde5cb", + "name": "beautifulsoup4", + "sha256": "784a05568c6ca6f3928643e7569ffe0bf5f4a2f1b2f5e380e0c017ebee8bde3b", + "size": 149977, + "subdir": "linux-64", + "timestamp": 1532973243650, + "version": "4.6.1" + }, + "beautifulsoup4-4.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7a1fab4e61f1d833bc3ac9bd43ea96a5", + "name": "beautifulsoup4", + "sha256": "ca992f61630a81efc72a8a30511f863697ada83844e70088135e81d223623f2c", + "size": 145740, + "subdir": "linux-64", + "timestamp": 1532973156126, + "version": "4.6.1" + }, + "beautifulsoup4-4.6.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "67ff754cb25c8860166962a1da0b5cc2", + "name": "beautifulsoup4", + "sha256": "6319029dc66453443b141d4b41c6fa3ea762ec3a93640cf6dcd5043e5cf90c22", + "size": 147840, + "subdir": "linux-64", + "timestamp": 1532973192723, + "version": "4.6.1" + }, + "beautifulsoup4-4.6.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a664edb78eb779c88318a8f955710642", + "name": "beautifulsoup4", + "sha256": "5b014e898f7fba48491126823efeb372a30314b6d3bb16507ff1f52511bd1f75", + "size": 146288, + "subdir": "linux-64", + "timestamp": 1534176345959, + "version": "4.6.3" + }, + "beautifulsoup4-4.6.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c120de1b4dcab4ecceabb212769b185e", + "name": "beautifulsoup4", + "sha256": "1ff9d3956b49fb4a2e98646b3a97824231d3437e88b673e44461c888adbd7719", + "size": 148095, + "subdir": "linux-64", + "timestamp": 1534176363905, + "version": "4.6.3" + }, + "beautifulsoup4-4.6.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5efbae3bd5a3da14b0d3aa62283702ec", + "name": "beautifulsoup4", + "sha256": "eb17be4ba27caa637bcf4bc2936c4517d7cc7e767d26fce31e7e933f0f417959", + "size": 148374, + "subdir": "linux-64", + "timestamp": 1534176283803, + "version": "4.6.3" + }, + "beautifulsoup4-4.6.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9405a22767a571c0fe795601a2350158", + "name": "beautifulsoup4", + "sha256": "ce082e5c56d720ce23026a02e0b9980056262d40a854d9074f263f7919952f96", + "size": 148179, + "subdir": "linux-64", + "timestamp": 1534176360400, + "version": "4.6.3" + }, + "beautifulsoup4-4.7.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "soupsieve" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e458f70ae1f4d8bda07ed6c614017db", + "name": "beautifulsoup4", + "sha256": "7cd5da9938c068d35303f085725add3ea893d480b62a13a1b314408d146ffde9", + "size": 149906, + "subdir": "linux-64", + "timestamp": 1547909423219, + "version": "4.7.1" + }, + "beautifulsoup4-4.7.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "soupsieve" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ca32a7534b278731bc85c6e4d7f2298", + "name": "beautifulsoup4", + "sha256": "b1b9faf488f54606fae3f751fb290b817d82d6b36255ee2f13e49abbb04e42bf", + "size": 150064, + "subdir": "linux-64", + "timestamp": 1547908574740, + "version": "4.7.1" + }, + "beautifulsoup4-4.7.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "soupsieve" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1eff5c9fb0779f9c2cf3dc2e9acd6cb1", + "name": "beautifulsoup4", + "sha256": "21a36565893af9ff0818f3483a114ca4cd19e46a48ddba4b0bbd191fe8182ed3", + "size": 152202, + "subdir": "linux-64", + "timestamp": 1547909489392, + "version": "4.7.1" + }, + "beautifulsoup4-4.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "soupsieve" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aefa8188d696d10176873f238fe8cd6a", + "name": "beautifulsoup4", + "sha256": "7cd9c9eaa6b5b8b0609d3e20f8ebe8e69430d027ed93a1540582efd38ee2fed6", + "size": 153572, + "subdir": "linux-64", + "timestamp": 1565961484122, + "version": "4.8.0" + }, + "beautifulsoup4-4.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "soupsieve" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "753c8c66654fbe82791e437f6506b909", + "name": "beautifulsoup4", + "sha256": "69abdff42c5a6ea888eb6b89a8820b1593ced9abbc72f78d99ad445ba729a6a7", + "size": 155878, + "subdir": "linux-64", + "timestamp": 1565961614075, + "version": "4.8.0" + }, + "beautifulsoup4-4.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "soupsieve" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd6dfe65cd2f85754f2c2bea7cf69652", + "name": "beautifulsoup4", + "sha256": "de0266a15835aa7b7b2cce68d4ba048707aaabb59ab537b61f1b90af44037caa", + "size": 155659, + "subdir": "linux-64", + "timestamp": 1565961695934, + "version": "4.8.0" + }, + "beautifulsoup4-4.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c71b614422f6fb48b29bf0b973aab1e", + "name": "beautifulsoup4", + "sha256": "41502c5462f8efc09239109d3a9f78d14437e6c6c833b05615116171f55d6cc8", + "size": 159703, + "subdir": "linux-64", + "timestamp": 1571761151596, + "version": "4.8.1" + }, + "beautifulsoup4-4.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0e2c9ece04b9d4506d5075e5ee7cde9", + "name": "beautifulsoup4", + "sha256": "66cf5f4c88c1af3d64d5e3fedbe452562c0354a66277156b2ae0ad2422d0886a", + "size": 162058, + "subdir": "linux-64", + "timestamp": 1571761170567, + "version": "4.8.1" + }, + "beautifulsoup4-4.8.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ac9394ef0fe1f3c7d6d2dbadf7ac1ab", + "name": "beautifulsoup4", + "sha256": "a33333502993004bc4a4e5e8bef3abda2eab1270782a196580a3d01be3b904d0", + "size": 161978, + "subdir": "linux-64", + "timestamp": 1571761151365, + "version": "4.8.1" + }, + "beautifulsoup4-4.8.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e41531dd8149a6bab52c50d27f3ff4a", + "name": "beautifulsoup4", + "sha256": "c85e012aee06323fe65bf90cda94f53b0750aaeecc162698335e2d91bb96308b", + "size": 160501, + "subdir": "linux-64", + "timestamp": 1572608998702, + "version": "4.8.1" + }, + "beautifulsoup4-4.8.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ed12223b7b595dabc63de3d2ae9cf3f", + "name": "beautifulsoup4", + "sha256": "ca8f370ef4460bd17f7e4f6c7313a66578b996bf557152f316ea3688110f3ae0", + "size": 167118, + "subdir": "linux-64", + "timestamp": 1578411539622, + "version": "4.8.2" + }, + "beautifulsoup4-4.8.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "865eab744d42581b1c7b62c6386c3fab", + "name": "beautifulsoup4", + "sha256": "ca9e3ff9aa2cd0149a3bd4e8e5e8e58bb64ce3d78b0f924bc029b02cf4e81a45", + "size": 166253, + "subdir": "linux-64", + "timestamp": 1578411552357, + "version": "4.8.2" + }, + "beautifulsoup4-4.8.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e5e0c0a7dde52d7162e929470ccbedb", + "name": "beautifulsoup4", + "sha256": "14dc53a780fe455621c1d5c5429ae5b8fe598d1922a6e34280ad3f44f490f78d", + "size": 166316, + "subdir": "linux-64", + "timestamp": 1578411508139, + "version": "4.8.2" + }, + "beautifulsoup4-4.8.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb6e1a0392b0ea99e336112444abdca0", + "name": "beautifulsoup4", + "sha256": "2091ec62b0858431d0a920b9366bae2049b673fae555c37030718a27b3bd4012", + "size": 167332, + "subdir": "linux-64", + "timestamp": 1578411541192, + "version": "4.8.2" + }, + "beautifulsoup4-4.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f76cb1e2da5d3748b74109f6fa7841e3", + "name": "beautifulsoup4", + "sha256": "9dc33725301447eb7f2585ccdc19e4a9303e8836dda6d81b2fd0b2aca5a39c7a", + "size": 170584, + "subdir": "linux-64", + "timestamp": 1587477917662, + "version": "4.9.0" + }, + "beautifulsoup4-4.9.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "533445ab45e7daabe8205c0b533348a3", + "name": "beautifulsoup4", + "sha256": "c6f45d9e055e7f27a8c01d469f0b15ccce114d734e9fe90c54cb8605ec8923b1", + "size": 170372, + "subdir": "linux-64", + "timestamp": 1587477904074, + "version": "4.9.0" + }, + "beautifulsoup4-4.9.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c6ab37db05a6a136b93d48d22f9a80d2", + "name": "beautifulsoup4", + "sha256": "1f2bd859034aa698f1576c13bb127c7c6e2de0ba91b57c4146f15637b02295c1", + "size": 171419, + "subdir": "linux-64", + "timestamp": 1587477907162, + "version": "4.9.0" + }, + "beautifulsoup4-4.9.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "19f9f945a82fb0e42d5b1349bf84ab71", + "name": "beautifulsoup4", + "sha256": "b1e9812a15100b680526805b53e66e17ab3249c9480be94d5cbe4c5086c59009", + "size": 176193, + "subdir": "linux-64", + "timestamp": 1591779961460, + "version": "4.9.1" + }, + "beautifulsoup4-4.9.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c6781881598478e9ed3af111128e7177", + "name": "beautifulsoup4", + "sha256": "c256ec51f895d05f6762a61a5f82ca4a94fcfdbf548c05a8c60641aaec250a09", + "size": 173963, + "subdir": "linux-64", + "timestamp": 1605302258590, + "version": "4.9.1" + }, + "beautifulsoup4-4.9.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f997ec27da23250e3622e0c5a612ffc", + "name": "beautifulsoup4", + "sha256": "cfcd30c0e6190fe25cdefa6fde8bce2054c56cba0be1c1693ad93947dcc5cb06", + "size": 168998, + "subdir": "linux-64", + "timestamp": 1590693581365, + "version": "4.9.1" + }, + "beautifulsoup4-4.9.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a17616584a80ce3d9731840775336eb", + "name": "beautifulsoup4", + "sha256": "7a5a6275eb025a789abb5ce4a596d33f4e99e113bde5636a88e97f2c8635cc05", + "size": 173935, + "subdir": "linux-64", + "timestamp": 1605302295434, + "version": "4.9.1" + }, + "beautifulsoup4-4.9.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af0388d492f6b688db77297a8378b1b6", + "name": "beautifulsoup4", + "sha256": "a2416a42c6687541033d4c8c666db5862727b24c78e7eb8315922d1de150ab76", + "size": 174597, + "subdir": "linux-64", + "timestamp": 1591779974749, + "version": "4.9.1" + }, + "beautifulsoup4-4.9.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "edf6611cf98dc87117dc44b201e266ec", + "name": "beautifulsoup4", + "sha256": "5f44dcc613f4a84b95971d3020a1d4d9a93b29fe88e1db7fee0ec1f2d99daffa", + "size": 174699, + "subdir": "linux-64", + "timestamp": 1605302290368, + "version": "4.9.1" + }, + "beautifulsoup4-4.9.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "soupsieve >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d47bb5c43a6e4523205aa4e7b51c048c", + "name": "beautifulsoup4", + "sha256": "025a85062e5dfb300709fda32d28de16af396bb3c2837acf0ee36b043b748457", + "size": 174729, + "subdir": "linux-64", + "timestamp": 1605302277441, + "version": "4.9.1" + }, + "billiard-3.6.0.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c7afcc627c073bb56ceab84b686019f3", + "name": "billiard", + "sha256": "ad7afc78afbe5f3d92f7dbf8aa7e07f50ae0a72308d557c2e04a1f99c512c86c", + "size": 163801, + "subdir": "linux-64", + "timestamp": 1574184925133, + "version": "3.6.0.0" + }, + "billiard-3.6.0.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "60a92d106d674260fadcb5b2183c9689", + "name": "billiard", + "sha256": "2c316603ec8eeb58127f59153619ece2867976305dcf9f9781a58d1434b6683d", + "size": 157480, + "subdir": "linux-64", + "timestamp": 1574184898893, + "version": "3.6.0.0" + }, + "billiard-3.6.0.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "954343b97edc1dc6a106db58fd5af48e", + "name": "billiard", + "sha256": "facb3e6a5d860d13b6efc0301fb744a316e66b598f553cb78f83e47f95e007d8", + "size": 156512, + "subdir": "linux-64", + "timestamp": 1574184896563, + "version": "3.6.0.0" + }, + "billiard-3.6.0.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "57bfc3a56ccf73c68ccadad2fca9b120", + "name": "billiard", + "sha256": "ae6175fe782dfce2f4cdb45024eadf175a77496b054cc0803fa776815a7d74d9", + "size": 166063, + "subdir": "linux-64", + "timestamp": 1574184921630, + "version": "3.6.0.0" + }, + "billiard-3.6.2.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5c77a99cf67cd16ed258d9788265bfc9", + "name": "billiard", + "sha256": "b7356d6609d501027b5ef4f6999deace461c21fc70637601c44f9d9a1367175a", + "size": 158845, + "subdir": "linux-64", + "timestamp": 1582148527531, + "version": "3.6.2.0" + }, + "billiard-3.6.2.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0b3eec0f6fa299f0d57744fb2a849189", + "name": "billiard", + "sha256": "98204553cd6907bb384386c736d69b0c0d32143b5bbefe23ff8d92d841bc1220", + "size": 157881, + "subdir": "linux-64", + "timestamp": 1582148492524, + "version": "3.6.2.0" + }, + "billiard-3.6.2.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bd7811c653a9ac54fba5aa9c310588bc", + "name": "billiard", + "sha256": "a44aa478da87b5ba9b69c5241a512b62b75fddce4f2dcbfe6b734cd86c5d3436", + "size": 159359, + "subdir": "linux-64", + "timestamp": 1582148529553, + "version": "3.6.2.0" + }, + "billiard-3.6.3.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b4c1e471b79ceb2cda87ae61043d4567", + "name": "billiard", + "sha256": "fe3d6bf70002c80cca41bff82f324763826f83baac68fc82676716076f9ad415", + "size": 157944, + "subdir": "linux-64", + "timestamp": 1614257642660, + "version": "3.6.3.0" + }, + "billiard-3.6.3.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9b6a48745325b3c8261eb63cff70d0c1", + "name": "billiard", + "sha256": "f3d00753c96013991abf6c6bf5519ea6a12af5bed7cda8e20c018dd98c4242f6", + "size": 159267, + "subdir": "linux-64", + "timestamp": 1584971936409, + "version": "3.6.3.0" + }, + "billiard-3.6.3.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e0ce654eaabd3a31a11ee08fc47bb800", + "name": "billiard", + "sha256": "fac352a6aa25eeb75c53f958e06d376854f2055a89fac6957463cfc5658fc1c3", + "size": 158204, + "subdir": "linux-64", + "timestamp": 1614257639458, + "version": "3.6.3.0" + }, + "billiard-3.6.3.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e923457e42c52e3f7af822cd22baa60c", + "name": "billiard", + "sha256": "93e52982d261ff26e48870c79f28559ce55a28bd855ffde106ec638461c503b6", + "size": 159513, + "subdir": "linux-64", + "timestamp": 1584971900637, + "version": "3.6.3.0" + }, + "billiard-3.6.3.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9f83f418ec7e755a9bd4c2283951a24e", + "name": "billiard", + "sha256": "b70f33af4d343d78342af99bbd2c3c5384fa87f66bb9c5286d4383c8826a0b7e", + "size": 160025, + "subdir": "linux-64", + "timestamp": 1614257632836, + "version": "3.6.3.0" + }, + "billiard-3.6.3.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7cc2bd41ef9f7c5899116ffb8643f38c", + "name": "billiard", + "sha256": "b65a8dd98b571983edacd9c528c0b2933af88f498ab81d450d32975568849f52", + "size": 160927, + "subdir": "linux-64", + "timestamp": 1584971966088, + "version": "3.6.3.0" + }, + "billiard-3.6.3.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1af8e279ae9678f700dd6feba13ce178", + "name": "billiard", + "sha256": "dd499540a6bf3d34399cbacc39dc7c513cb1b576e19516c48e65d546336f0f64", + "size": 161384, + "subdir": "linux-64", + "timestamp": 1614257644003, + "version": "3.6.3.0" + }, + "billiard-3.6.4.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a25cb5e598b5b65cc33db393493cb3e3", + "name": "billiard", + "sha256": "5ef0bfb9e2dd852ebf1b865d2f5ad4f3cddd7e7d51c90d2eccbbff663ae3f9fa", + "size": 158148, + "subdir": "linux-64", + "timestamp": 1640788435619, + "version": "3.6.4.0" + }, + "billiard-3.6.4.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a5f7662172c62fe65beeeef3ae8f5e3c", + "name": "billiard", + "sha256": "45caeae281512e3f9fcb8f2ae841083b384a517f62add2290b59da353ec5b0e9", + "size": 219998, + "subdir": "linux-64", + "timestamp": 1676846978084, + "version": "3.6.4.0" + }, + "billiard-3.6.4.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "958e5a614730844e7d2631ffb7462857", + "name": "billiard", + "sha256": "fa45cabb18ff28319b0de54d071f7a99bbdcaf3927b026e6ee7542db4d2df184", + "size": 153996, + "subdir": "linux-64", + "timestamp": 1617383702833, + "version": "3.6.4.0" + }, + "billiard-3.6.4.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b9688e90bea4bddb9809196770953e15", + "name": "billiard", + "sha256": "57299e5c691826b1573f9ef96d39c383901aca5020c021b188482e0e63d58506", + "size": 154194, + "subdir": "linux-64", + "timestamp": 1617381120094, + "version": "3.6.4.0" + }, + "billiard-3.6.4.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d0fb0fc3b8d01bfc6124d6650e65a753", + "name": "billiard", + "sha256": "10e2a7ea819e4de4a9b0d0820cac01f42c9581cf2516dc67fad7f81b869ca666", + "size": 155765, + "subdir": "linux-64", + "timestamp": 1617383702482, + "version": "3.6.4.0" + }, + "billiard-3.6.4.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "caf638b3bb0e1bedf912cc2d19f5ab41", + "name": "billiard", + "sha256": "a2c6495d138da0ca6416af2d6469cd0f12cfac52e1bb5d36c6c91871039b04dc", + "size": 155932, + "subdir": "linux-64", + "timestamp": 1617383698299, + "version": "3.6.4.0" + }, + "binsort-0.4.1-h7b6447c_1.conda": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license_family": "BSD", + "md5": "6bfdac8f926860acf1555bcd711d45af", + "name": "binsort", + "sha256": "622c462bdf6820709685b864048e83c37325f8fb9cd3107a4e25f444f9fab0ad", + "size": 166346, + "subdir": "linux-64", + "timestamp": 1539329724346, + "version": "0.4.1" + }, + "binsort-0.4.1-h7b6447c_2.conda": { + "build": "h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license_family": "BSD", + "md5": "617ed17ce3d84ce176e92947e31aac48", + "name": "binsort", + "sha256": "afe1bea035fecdcf09965f9673218973418974d2cd3ddaabeec4d0e3c6590553", + "size": 167220, + "subdir": "linux-64", + "timestamp": 1539349745535, + "version": "0.4.1" + }, + "binsort-0.4_1-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license_family": "BSD", + "md5": "aadc8e1ec412200145bd5c16119a0429", + "name": "binsort", + "sha256": "6b0d3556bd5e4dd4edb2573811961707c968584367afae24affb5b286e33e568", + "size": 167171, + "subdir": "linux-64", + "timestamp": 1539289443877, + "version": "0.4_1" + }, + "binutils-2.33.1-h53a641e_7.conda": { + "build": "h53a641e_7", + "build_number": 7, + "depends": [ + "binutils_impl_linux-64 >=2.33.1,<2.33.2.0a0" + ], + "license": "GPL 3", + "md5": "2829e7509b071fe35245071aa86d5d4c", + "name": "binutils", + "sha256": "a138d41d69bf01ab39faab521ac9e481d3fbe8b902d3270131af4851aaa365ef", + "size": 30245, + "subdir": "linux-64", + "timestamp": 1576704292863, + "version": "2.33.1" + }, + "binutils-2.38-h1680402_0.conda": { + "build": "h1680402_0", + "build_number": 0, + "depends": [ + "binutils_impl_linux-64 >=2.38,<2.39.0a0" + ], + "license": "GPL-3.0-only", + "md5": "f039198f237ea1587ee9e6ea7ce05ef2", + "name": "binutils", + "sha256": "4d610fdc13b1ec1618d8fb47df011316ea743810b497d9a2599deacf77a147c6", + "size": 33989, + "subdir": "linux-64", + "timestamp": 1652588250497, + "version": "2.38" + }, + "binutils-2.38-h1680402_1.conda": { + "build": "h1680402_1", + "build_number": 1, + "depends": [ + "binutils_impl_linux-64 >=2.38,<2.39.0a0" + ], + "license": "GPL-3.0-only", + "md5": "2ed0365d99c3d474448b353ee3700d6f", + "name": "binutils", + "sha256": "e5f3661c9f8e95d57bf618efe9d9e2c36826ac376705d8d30c0a5dd6f2041b94", + "size": 34474, + "subdir": "linux-64", + "timestamp": 1652971380391, + "version": "2.38" + }, + "binutils_impl_linux-64-2.28.1-h04c84fa_2.conda": { + "build": "h04c84fa_2", + "build_number": 2, + "depends": [], + "license": "GPL", + "md5": "f2cc9a22b0a14dbe05dad3f6eb3dd074", + "name": "binutils_impl_linux-64", + "sha256": "2f68f4656bc4ce2c8fdabe32b35b46f32c1e04b86edb006d7db3279f7401d4d9", + "size": 3655667, + "subdir": "linux-64", + "timestamp": 1507262688378, + "version": "2.28.1" + }, + "binutils_impl_linux-64-2.28.1-had2808c_3.conda": { + "build": "had2808c_3", + "build_number": 3, + "depends": [], + "license": "GPL", + "md5": "dcf9237233f44c9d871c8de058df9e1e", + "name": "binutils_impl_linux-64", + "sha256": "7345529e640c6f22e73fdd27574d3f3ec1709eca89a670baba0133c1eebd285b", + "size": 3666900, + "subdir": "linux-64", + "timestamp": 1520534476655, + "version": "2.28.1" + }, + "binutils_impl_linux-64-2.31.1-h6176602_0.conda": { + "build": "h6176602_0", + "build_number": 0, + "depends": [], + "license": "GPL", + "md5": "c3205fe2ab6d21e3b5f87827ef03cbec", + "name": "binutils_impl_linux-64", + "sha256": "87a504876b6792753662ce30ed74e2307bbb505742fa6818e439d1b60d2ad5d6", + "size": 3701838, + "subdir": "linux-64", + "timestamp": 1534628424822, + "version": "2.31.1" + }, + "binutils_impl_linux-64-2.31.1-h6176602_1.conda": { + "build": "h6176602_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "0ab9a74b74bfe72f96f26b6fa0df588d", + "name": "binutils_impl_linux-64", + "sha256": "42ffbc8bb85cdcb620ef16250756f537f7a60c54505511c9d7091ad6012868ac", + "size": 4141603, + "subdir": "linux-64", + "timestamp": 1534502899018, + "version": "2.31.1" + }, + "binutils_impl_linux-64-2.33.1-he6710b0_7.conda": { + "build": "he6710b0_7", + "build_number": 7, + "depends": [ + "ld_impl_linux-64 2.33.1 h53a641e_7", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL 3", + "md5": "5391fac57187954a295288d895bc4ac8", + "name": "binutils_impl_linux-64", + "sha256": "067739c2e85b86912dfe349d7e4f6c178ad4455a9a7a95a7352b69a1889c3991", + "size": 3832528, + "subdir": "linux-64", + "timestamp": 1576704272512, + "version": "2.33.1" + }, + "binutils_impl_linux-64-2.35.1-h27ae35d_9.conda": { + "build": "h27ae35d_9", + "build_number": 9, + "depends": [ + "ld_impl_linux-64 2.35.1 h7274673_9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only", + "md5": "42736a6d37909b524deb09994ae6efe3", + "name": "binutils_impl_linux-64", + "sha256": "3f31abee52e31be63aef8f0d3a37dd3b6a205294ac4722d342dd4fe9e382a8e0", + "size": 3748423, + "subdir": "linux-64", + "timestamp": 1622698557758, + "version": "2.35.1" + }, + "binutils_impl_linux-64-2.38-h2a08ee3_0.conda": { + "build": "h2a08ee3_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64 2.38 h1181459_0", + "libstdcxx-ng >=4.9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only", + "md5": "d199cbceec733496ca10f34735e042f6", + "name": "binutils_impl_linux-64", + "sha256": "8029d96486afa77db3b3b480a55a098c4178b2304585d47ee54010028293334e", + "size": 5216251, + "subdir": "linux-64", + "timestamp": 1652588237243, + "version": "2.38" + }, + "binutils_impl_linux-64-2.38-h2a08ee3_1.conda": { + "build": "h2a08ee3_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64 2.38 h1181459_1", + "libstdcxx-ng >=4.9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only", + "md5": "2edd7299b320921c66eddbdfa5351b89", + "name": "binutils_impl_linux-64", + "sha256": "8ff7a1d0d4b6d53d1f665a9d2383718505cfa1cfb753a8330235ebc058779981", + "size": 5429472, + "subdir": "linux-64", + "timestamp": 1652971366937, + "version": "2.38" + }, + "binutils_linux-64-2.28.1-he4fe6c7_1.conda": { + "build": "he4fe6c7_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "a0a83de306420993c275ae3993f60bfb", + "name": "binutils_linux-64", + "sha256": "8c2205db32e98acb993a76b40e7c691ffd8b5e250d0d672e930b4d4f8f406a19", + "size": 3656356, + "subdir": "linux-64", + "timestamp": 1505665541698, + "version": "2.28.1" + }, + "binutils_linux-64-2.31.1-h6176602_1.conda": { + "build": "h6176602_1", + "build_number": 1, + "depends": [ + "binutils_impl_linux-64 2.31.1.*" + ], + "license": "GPL", + "md5": "a36a577b176bb4cd8b833642be7ffb87", + "name": "binutils_linux-64", + "sha256": "31b0c5697de3a1f8b22aca4e6bb3aaa21c2d3a317f85550cb41920ffb7a7f71a", + "size": 9920, + "subdir": "linux-64", + "timestamp": 1534628899031, + "version": "2.31.1" + }, + "binutils_linux-64-2.31.1-h6176602_2.conda": { + "build": "h6176602_2", + "build_number": 2, + "depends": [ + "binutils_impl_linux-64 2.31.1.*" + ], + "license": "GPL", + "md5": "f892d0cfb1f7964da50907c8b295e6cc", + "name": "binutils_linux-64", + "sha256": "22e00a65c4882dd081ac7d3971fdb26dbfdaa8f86e979f9d62781e7698673902", + "size": 9781, + "subdir": "linux-64", + "timestamp": 1534794486416, + "version": "2.31.1" + }, + "binutils_linux-64-2.31.1-h6176602_3.conda": { + "build": "h6176602_3", + "build_number": 3, + "depends": [ + "binutils_impl_linux-64 2.31.1.*" + ], + "license": "GPL", + "md5": "7c058199b05b8cdf1eaa7f6bb281e752", + "name": "binutils_linux-64", + "sha256": "5d6b95a4a394ce097bf56729b31241bfe94ac8ae643e62f9503ded72ad11f8a1", + "size": 9813, + "subdir": "linux-64", + "timestamp": 1534948636063, + "version": "2.31.1" + }, + "binutils_linux-64-2.31.1-h6176602_6.conda": { + "build": "h6176602_6", + "build_number": 6, + "depends": [ + "binutils_impl_linux-64 2.31.1.*" + ], + "license": "GPL", + "md5": "e6d19e1399e007770be6685b8f2b0515", + "name": "binutils_linux-64", + "sha256": "c6ea70baf72dbf3f9ebdb78e8542e2cf43f839b63c4e34e74a35ff14ddbb5b06", + "size": 10838, + "subdir": "linux-64", + "timestamp": 1546883607112, + "version": "2.31.1" + }, + "binutils_linux-64-2.31.1-h6176602_7.conda": { + "build": "h6176602_7", + "build_number": 7, + "depends": [ + "binutils_impl_linux-64 2.31.1.*" + ], + "license": "GPL", + "md5": "e72eb68ff5e919de7db7fa3eed089df9", + "name": "binutils_linux-64", + "sha256": "2ad239f2bb430dd9be837f73f8e2482b735a025455863aaaaf84ef78cfa5f8f8", + "size": 9934, + "subdir": "linux-64", + "timestamp": 1556137062358, + "version": "2.31.1" + }, + "binutils_linux-64-2.31.1-h6176602_8.conda": { + "build": "h6176602_8", + "build_number": 8, + "depends": [ + "binutils_impl_linux-64 2.31.1.*" + ], + "license": "GPL", + "md5": "2d1b7439687ea367d7ce3ca5218140d9", + "name": "binutils_linux-64", + "sha256": "70ba175d1a9e98096b5b00da8bb66a0b85dcc7c9366df1e418d5ba2d90f8051d", + "size": 172021, + "subdir": "linux-64", + "timestamp": 1565123314418, + "version": "2.31.1" + }, + "binutils_linux-64-2.31.1-h6176602_9.conda": { + "build": "h6176602_9", + "build_number": 9, + "depends": [ + "binutils_impl_linux-64 2.31.1.*" + ], + "license": "BSD-3-Clause", + "md5": "8be4d48cf90dd52cf7d3d794b90db0da", + "name": "binutils_linux-64", + "sha256": "4e3779ecbbb4ac6932f3c7b0f7b46f6cd930b66f347efae3f58c6dbff2a440eb", + "size": 26563, + "subdir": "linux-64", + "timestamp": 1576689706275, + "version": "2.31.1" + }, + "binutils_linux-64-2.33.1-h9595d00_15.conda": { + "build": "h9595d00_15", + "build_number": 15, + "depends": [ + "binutils_impl_linux-64 2.33.1.*" + ], + "license": "BSD-3-Clause", + "md5": "2c6a6d3a84766aad02715b677c151630", + "name": "binutils_linux-64", + "sha256": "d79b877d52bfaba2b374024ab35b7feea30a1d5e63fea3e3bfc6e39e0a86d5e2", + "size": 26586, + "subdir": "linux-64", + "timestamp": 1576707744942, + "version": "2.33.1" + }, + "binutils_linux-64-2.35.1-h454624a_30.conda": { + "build": "h454624a_30", + "build_number": 30, + "depends": [ + "binutils_impl_linux-64 2.35.1.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "26ecde56c830c54e1e931b25b8de8f1c", + "name": "binutils_linux-64", + "sha256": "3c4f0c2c168c0adaa62b5c49c43664bcb3ef979dadc027a5f51f390396962488", + "size": 24257, + "subdir": "linux-64", + "timestamp": 1623135022525, + "version": "2.35.1" + }, + "binutils_linux-64-2.38.0-hc2dff05_0.conda": { + "build": "hc2dff05_0", + "build_number": 0, + "depends": [ + "binutils_impl_linux-64 2.38.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "8263bd6bc475ac73215c8a67eadcccb3", + "name": "binutils_linux-64", + "sha256": "3af60f19d6c011db181d9cadcc83d88a07de145deff1b2bca02fc44e2f074069", + "size": 24595, + "subdir": "linux-64", + "timestamp": 1652867209144, + "version": "2.38.0" + }, + "binutils_linux-64-5.4.0-had2808c_24.conda": { + "build": "had2808c_24", + "build_number": 24, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "592c2869ae9c6ce49c3fe5b25edf6e49", + "name": "binutils_linux-64", + "sha256": "5051d9f6d3fd7c09810e2bc9f0be966b0603cdf30e8fa3c76ab8c7aeb99e47b4", + "size": 8872, + "subdir": "linux-64", + "timestamp": 1520970078674, + "version": "5.4.0" + }, + "binutils_linux-64-7.2.0-19.conda": { + "build": "19", + "build_number": 19, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "d4568a7abdae709d22f31694bc2bc19f", + "name": "binutils_linux-64", + "sha256": "2d82fb40c0319b4be14b69b64eba78ffbc123e8fbe5606503af3b6a31c50e055", + "size": 5630, + "subdir": "linux-64", + "timestamp": 1513886592695, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-24.conda": { + "build": "24", + "build_number": 24, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "814c3779f2a68714f3a921223f5dcb1f", + "name": "binutils_linux-64", + "sha256": "12c8af1a5e54106cf1511a94962cb782b4109b7e4454f1e32e9c59d17fd4180c", + "size": 5079, + "subdir": "linux-64", + "timestamp": 1514480887163, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-25.conda": { + "build": "25", + "build_number": 25, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "f58298d7ab01bc4019af0ea781468386", + "name": "binutils_linux-64", + "sha256": "ba05e070ee2b8ef559bbd383e58bb42c3e32fe27f8b84933bd219fe8f18f13c6", + "size": 5081, + "subdir": "linux-64", + "timestamp": 1515156399480, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-26.conda": { + "build": "26", + "build_number": 26, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "16a788d1b7434e173fc65021d4bdfed1", + "name": "binutils_linux-64", + "sha256": "519f0635cd53d089ed7834ec687aaef2bbecbc969a45cf37d4ed9e95ea6d7304", + "size": 9004, + "subdir": "linux-64", + "timestamp": 1521829422874, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-had2808c_27.conda": { + "build": "had2808c_27", + "build_number": 27, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "4d84422fce975290dbf31af245d31005", + "name": "binutils_linux-64", + "sha256": "781f5af2be8b2ebe52c83247f0cb1206fdba5568780d635a3ead3ef8f8de048f", + "size": 8991, + "subdir": "linux-64", + "timestamp": 1526461250603, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_10.conda": { + "build": "hc67e822_10", + "build_number": 10, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "9c134ce8105b56faf1acc7fb9e033fb5", + "name": "binutils_linux-64", + "sha256": "dce31c1d3376e8b686b555e10f24e61b4c2c58d4a7edf968beafad350a7225a9", + "size": 5281, + "subdir": "linux-64", + "timestamp": 1510244818045, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_11.conda": { + "build": "hc67e822_11", + "build_number": 11, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "d83f8278bb57c01b54b57f22c875a659", + "name": "binutils_linux-64", + "sha256": "92aa806d145a008b29e74dc7af6633871e6a2f3a83efce919796ea63a86a23e6", + "size": 5195, + "subdir": "linux-64", + "timestamp": 1510566119271, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_12.conda": { + "build": "hc67e822_12", + "build_number": 12, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "89bf34b455278a4b6bd67089c6c2f0db", + "name": "binutils_linux-64", + "sha256": "4932a421682d452721197f03f0f3bbb2559017152a9f38ee6ba4c3c261c842b9", + "size": 5605, + "subdir": "linux-64", + "timestamp": 1510792708713, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_13.conda": { + "build": "hc67e822_13", + "build_number": 13, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "0ca28fa5c7f528e298b0a95739cb93aa", + "name": "binutils_linux-64", + "sha256": "b76dab5f337f83a7760c4b1266df34ae50713a84e4efdcdd6ad90225a9f25dbd", + "size": 5204, + "subdir": "linux-64", + "timestamp": 1510925047122, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_14.conda": { + "build": "hc67e822_14", + "build_number": 14, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "2ca26cd4da301b7bb5a2b941d0adcb10", + "name": "binutils_linux-64", + "sha256": "91bb3203cb8dbacb4b3de6c2ba5bb42fece606fe28cf29c87dcecd3b048c5760", + "size": 5203, + "subdir": "linux-64", + "timestamp": 1510930963086, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_15.conda": { + "build": "hc67e822_15", + "build_number": 15, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "1793d62db18da7f105fb3dc9de27e285", + "name": "binutils_linux-64", + "sha256": "6e386d5cc5cdc1303bb6edd58914696b88624bf31b06af64cb54acea379c2492", + "size": 5204, + "subdir": "linux-64", + "timestamp": 1511640857209, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_2.conda": { + "build": "hc67e822_2", + "build_number": 2, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "acc8f99ea920cff6785448962886baef", + "name": "binutils_linux-64", + "sha256": "d857164ea6022535d66b6c3f67d960369e04c836dcc51abdfa814e4c47007a20", + "size": 5274, + "subdir": "linux-64", + "timestamp": 1507320096319, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_3.conda": { + "build": "hc67e822_3", + "build_number": 3, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "d88bf0e2b0c8bc4c910df93f3bfb6bd2", + "name": "binutils_linux-64", + "sha256": "efc8f1cded2f47b36893410deb0606742590a9a34c6556e60f0d8a8ef85a2f2d", + "size": 5267, + "subdir": "linux-64", + "timestamp": 1507320233202, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_7.conda": { + "build": "hc67e822_7", + "build_number": 7, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "23ed22e955da5d49dd456bd0fb3cb7b6", + "name": "binutils_linux-64", + "sha256": "f21486ddb28ebb64bd7a955ca0707464ae2a99b0dbdb2e031c5c24def4510e89", + "size": 4981, + "subdir": "linux-64", + "timestamp": 1507845399625, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_8.conda": { + "build": "hc67e822_8", + "build_number": 8, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "f3e64f6ba7089af1f6bb3f99351fc70f", + "name": "binutils_linux-64", + "sha256": "42b7bd42c09233fd4048b7080c031256db3136913791d2453ed3fb277752b316", + "size": 4941, + "subdir": "linux-64", + "timestamp": 1509635177775, + "version": "7.2.0" + }, + "binutils_linux-64-7.2.0-hc67e822_9.conda": { + "build": "hc67e822_9", + "build_number": 9, + "depends": [ + "binutils_impl_linux-64 2.28.1.*" + ], + "license": "GPL", + "md5": "e6abfa78f48cffd68d8f141dc93787ea", + "name": "binutils_linux-64", + "sha256": "06e30b4f2da6ca4d00f1dde3b45113053595d349d4a7c8ba59fc8211440dd7fe", + "size": 5209, + "subdir": "linux-64", + "timestamp": 1509836579647, + "version": "7.2.0" + }, + "binutils_linux-64-7.3.0-h6176602_26.conda": { + "build": "h6176602_26", + "build_number": 26, + "depends": [ + "binutils_impl_linux-64 2.31.1.*" + ], + "license": "GPL", + "md5": "6695d980322058527d10917b768cd8c8", + "name": "binutils_linux-64", + "sha256": "b5c1e439fd2534cd85bc4a93777e3152a7b12fbcb7963275709fe24154dd39d0", + "size": 9280, + "subdir": "linux-64", + "timestamp": 1534693897217, + "version": "7.3.0" + }, + "binutils_linux-64-8.2.0-h6176602_26.conda": { + "build": "h6176602_26", + "build_number": 26, + "depends": [ + "binutils_impl_linux-64 2.31.1.*" + ], + "license": "GPL", + "md5": "c0e6f09287149432bff88a23485b105b", + "name": "binutils_linux-64", + "sha256": "4fc2248f1f4bce2d0627e9000b9fbb20f42595f76937bf3fa03881c4eae3d8b6", + "size": 9279, + "subdir": "linux-64", + "timestamp": 1534693813493, + "version": "8.2.0" + }, + "biopython-1.70-py27h637b7d7_0.conda": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.14.1,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "ae86b0cc5cff8f3708c7a77cdfd8329d", + "name": "biopython", + "sha256": "7c33e5ca4a4b1fb13743847f3b3a6fbfebcd689c4700886a54f7e83935233f66", + "size": 1982666, + "subdir": "linux-64", + "timestamp": 1519234431708, + "version": "1.70" + }, + "biopython-1.70-py35h637b7d7_0.conda": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "5d39db8d9697204cc675a3c3c7e7e4a4", + "name": "biopython", + "sha256": "278e382fd5e4c6ef730be478458a3b54b8fe3c4788b759d10acc8e6727565b3d", + "size": 2009961, + "subdir": "linux-64", + "timestamp": 1519234481501, + "version": "1.70" + }, + "biopython-1.70-py36h637b7d7_0.conda": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "2345e18a1774961bda27a29d60843ffa", + "name": "biopython", + "sha256": "722f87dffe9d0cb752dac297529783c4d6ed3aac473477a1b9848444533d0f8d", + "size": 1994369, + "subdir": "linux-64", + "timestamp": 1519234258645, + "version": "1.70" + }, + "biopython-1.71-py27h04863e7_0.conda": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "fbe2be2d28ecc43746f81f85c64ce209", + "name": "biopython", + "sha256": "c28dd2fcb808dcef2e3a80dbf71545d5ec47631dc348e762cf60c1042a93605c", + "size": 2026826, + "subdir": "linux-64", + "timestamp": 1530742710288, + "version": "1.71" + }, + "biopython-1.71-py27h637b7d7_0.conda": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "d84b424861bf57a08b0a8c7125123203", + "name": "biopython", + "sha256": "a908a150efb3bc855caef7d1720040434ed11e42d28f37cf80284389f74b477c", + "size": 2026876, + "subdir": "linux-64", + "timestamp": 1523991471899, + "version": "1.71" + }, + "biopython-1.71-py35h637b7d7_0.conda": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "fbe77fe3f87a8d453d072c5710f0acba", + "name": "biopython", + "sha256": "6d47524ec49d58bb3123b2556bf035e7379a168e62e472269045fa63036191f2", + "size": 2033859, + "subdir": "linux-64", + "timestamp": 1523991906361, + "version": "1.71" + }, + "biopython-1.71-py36h04863e7_0.conda": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "5cc85182809535ad933fef3b4be8cc5c", + "name": "biopython", + "sha256": "52e20ed5083f722684214ddefd3ca00fca32ff20faea40e02e3705d760a3eb3b", + "size": 2019671, + "subdir": "linux-64", + "timestamp": 1530742648277, + "version": "1.71" + }, + "biopython-1.71-py36h637b7d7_0.conda": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "71b9534478025c6588489e8542f806ba", + "name": "biopython", + "sha256": "fdd4496483f80601711adaeb2904e34a6b9603e5dd80c110ec008f8e056a6628", + "size": 2046112, + "subdir": "linux-64", + "timestamp": 1523991906970, + "version": "1.71" + }, + "biopython-1.71-py37h04863e7_0.conda": { + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "23dc029cb993e24a1d8b518ec48185ef", + "name": "biopython", + "sha256": "9334a7b2afc8b00958a743651913da76339e0a501ff5a5279cd8af2a4b2ef85b", + "size": 1994179, + "subdir": "linux-64", + "timestamp": 1530770848574, + "version": "1.71" + }, + "biopython-1.72-py27h04863e7_0.conda": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "af4f759fcc9492e1174343af38e957b5", + "name": "biopython", + "sha256": "083ac91064d14c11bced57ae505e0161c46c806e5048d1ef35417431efd0edcf", + "size": 2055282, + "subdir": "linux-64", + "timestamp": 1532542364205, + "version": "1.72" + }, + "biopython-1.72-py35h04863e7_0.conda": { + "build": "py35h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "1455b776eeb4be7ce00442d5778d999c", + "name": "biopython", + "sha256": "e5e7faca86734a04238b0e6a2f6db10ae00c9483d06816c0cee4352a2707cadb", + "size": 2086150, + "subdir": "linux-64", + "timestamp": 1532542394791, + "version": "1.72" + }, + "biopython-1.72-py36h04863e7_0.conda": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "0ef8a6d6dd64010d301f3fd06bedb056", + "name": "biopython", + "sha256": "246a84c6d4f6c64f0763d0f435cd9eeae2b0627da1856aa216919a007d86f637", + "size": 2095265, + "subdir": "linux-64", + "timestamp": 1532542411893, + "version": "1.72" + }, + "biopython-1.72-py37h04863e7_0.conda": { + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Biopython License Agreement", + "license_family": "Other", + "md5": "5bd40cc7781388200e69075f51fb2d11", + "name": "biopython", + "sha256": "4ba9c908b1821fd63333dd5ad34ab74265a6bfbba241789637e504cb8a178b8a", + "size": 2071486, + "subdir": "linux-64", + "timestamp": 1532542408961, + "version": "1.72" + }, + "biopython-1.73-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "Biopython License Agreement", + "md5": "c44cb2c3953e24dd9b4dfc998b66da19", + "name": "biopython", + "sha256": "7c7c3638921ab10238ed2f819cbc96eabddb5b70894b0d01773cdf97ce93f0e3", + "size": 2114559, + "subdir": "linux-64", + "timestamp": 1556062547283, + "version": "1.73" + }, + "biopython-1.73-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "md5": "fe4d1e731194d61a13a2f033f1e263e5", + "name": "biopython", + "sha256": "439c689cf4e27ff53dbd7d2a1339c29ae9e106c42f9e63c811c1d7226297c7c8", + "size": 2127755, + "subdir": "linux-64", + "timestamp": 1556062691349, + "version": "1.73" + }, + "biopython-1.73-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Biopython License Agreement", + "md5": "64efa8708d34cd9ca8cdd206d16e1d90", + "name": "biopython", + "sha256": "efe4f12da00af1b20de6fb6f986bcb37d31fd6f30ab028b268cb802cebf79ee4", + "size": 2128635, + "subdir": "linux-64", + "timestamp": 1556062539816, + "version": "1.73" + }, + "biopython-1.74-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "Biopython License Agreement", + "md5": "6ea949fc0dbeddaa806fa6417d0109b3", + "name": "biopython", + "sha256": "65940a15d7e4460616db075935b400ab14f75915017b5a91c0b7f53eed5772a6", + "size": 2181857, + "subdir": "linux-64", + "timestamp": 1564133769765, + "version": "1.74" + }, + "biopython-1.74-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "md5": "b1bab7065fc33982af0df3dc3cb08730", + "name": "biopython", + "sha256": "0c327a3e7142392f83a9801a4bdc595fc853bff6ed16c30f5448a54fc258acb4", + "size": 2195711, + "subdir": "linux-64", + "timestamp": 1564133754490, + "version": "1.74" + }, + "biopython-1.74-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Biopython License Agreement", + "md5": "d2cad29f08e92b5cc32bb7a8dc95ad9d", + "name": "biopython", + "sha256": "cc124488eecaa694414b6e6841dd1ed1fdef651b75681409b97c77604b509ca4", + "size": 2146650, + "subdir": "linux-64", + "timestamp": 1564133768576, + "version": "1.74" + }, + "biopython-1.74-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "Biopython License Agreement", + "md5": "3d1db9c3984d38376289765eb9cb8fb4", + "name": "biopython", + "sha256": "0b0588484a14417264004699be249684042ded7ec69019a4d10f05642cdc02ee", + "size": 2181828, + "subdir": "linux-64", + "timestamp": 1573738261593, + "version": "1.74" + }, + "biopython-1.76-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "md5": "2ce553bc50d7a7ddd8a3d94cf9313eb0", + "name": "biopython", + "sha256": "806829c7937c1045bdd3c389aa534c55906b9d96f28268d8ce547e967371dc22", + "size": 2239941, + "subdir": "linux-64", + "timestamp": 1581952481548, + "version": "1.76" + }, + "biopython-1.76-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Biopython License Agreement", + "md5": "9840968891102e40e537e5e48456abef", + "name": "biopython", + "sha256": "2b29d36e845978eb9a743beadcf212b74ef53bfbe91554233a91970656702841", + "size": 2240978, + "subdir": "linux-64", + "timestamp": 1581952536712, + "version": "1.76" + }, + "biopython-1.76-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "Biopython License Agreement", + "md5": "16f9455827e83423edbd172200aeff58", + "name": "biopython", + "sha256": "c4e0774be555397d510714ee7358c1f19bef6d5cf60668c21ca1a66508b7f744", + "size": 2219168, + "subdir": "linux-64", + "timestamp": 1581952360642, + "version": "1.76" + }, + "biopython-1.77-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "md5": "e30f4476c8be29b177cdcb51ef1d00cb", + "name": "biopython", + "sha256": "5f0faa2824bcee5bd165bf02849913d23f6cd63c9bd2043c8cd1b7e9d21056e8", + "size": 2307607, + "subdir": "linux-64", + "timestamp": 1613155485809, + "version": "1.77" + }, + "biopython-1.77-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "md5": "d63af9997892cec1108eb386079cf02a", + "name": "biopython", + "sha256": "5825c5da978295b3beb65386780e1efb249b6c6dfa5935480ff36238fd740ca3", + "size": 2281153, + "subdir": "linux-64", + "timestamp": 1593539388816, + "version": "1.77" + }, + "biopython-1.77-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Biopython License Agreement", + "md5": "1c5aeb6c74f579a2cab5cd0bcb84713b", + "name": "biopython", + "sha256": "63c6983cfdf2561ff8e654711ec3b6e4d68f1b2698356eac44ad9edc1091952e", + "size": 2242551, + "subdir": "linux-64", + "timestamp": 1613155480711, + "version": "1.77" + }, + "biopython-1.77-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Biopython License Agreement", + "md5": "cfbcdcdea284264982b75e5ebfe91a88", + "name": "biopython", + "sha256": "47aba83a59359ea1d2b96b23b56d2632ea102c79fda17a650ef6857bb5991c04", + "size": 2243889, + "subdir": "linux-64", + "timestamp": 1593539375308, + "version": "1.77" + }, + "biopython-1.77-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "Biopython License Agreement", + "md5": "13bbcd305edf96b53b22a1fa545cd65f", + "name": "biopython", + "sha256": "53f1f2a2dfb4070658df9b78bd9554634e54ae7c3c00c782c8d036c50198a459", + "size": 2249972, + "subdir": "linux-64", + "timestamp": 1613155453063, + "version": "1.77" + }, + "biopython-1.77-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "Biopython License Agreement", + "md5": "ad599d1fb8222d90bb76ab3f8b4b00b2", + "name": "biopython", + "sha256": "6971ec6940b50f76da2539fa8730e386cb98da3cc37b51b61c9b0d1ba07dad49", + "size": 2253271, + "subdir": "linux-64", + "timestamp": 1593539397791, + "version": "1.77" + }, + "biopython-1.77-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "Biopython License Agreement", + "md5": "f9055317f511a1718b84e0279b68e134", + "name": "biopython", + "sha256": "1432848bfd4aaf4275f5ada8c2fc3d2a28addcc8ba55d3e4d5704decf20ed0bf", + "size": 2249587, + "subdir": "linux-64", + "timestamp": 1613155493601, + "version": "1.77" + }, + "biopython-1.78-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy", + "python >=3.10,<3.11.0a0" + ], + "license": "Biopython License Agreement", + "md5": "1ff7a99b3368b82138cfe4e5b774ab75", + "name": "biopython", + "sha256": "f62966821ec32824d6cc8cd5b4f233fec60495eb4a1604e322b5b3ec335463da", + "size": 2480093, + "subdir": "linux-64", + "timestamp": 1640788472679, + "version": "1.78" + }, + "biopython-1.78-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy", + "python >=3.11,<3.12.0a0" + ], + "license": "Biopython License Agreement", + "md5": "be95b1d56dc66c624c0e66fd7bed23c7", + "name": "biopython", + "sha256": "57255923fdd48505482759a091aab62ee871c997db8251d59f781016f23dd874", + "size": 2792001, + "subdir": "linux-64", + "timestamp": 1676847008152, + "version": "1.78" + }, + "biopython-1.78-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "md5": "eb65b9db87f21ec171278102db4bcb23", + "name": "biopython", + "sha256": "44e4ea246625eae7f4f15293c4abb891ad4e2b43ecdabe215b82e7548a8dae10", + "size": 2263214, + "subdir": "linux-64", + "timestamp": 1600298950921, + "version": "1.78" + }, + "biopython-1.78-py36h7f8727e_0.conda": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Biopython License Agreement", + "md5": "b7ac1e912595205f6c43a0031d190506", + "name": "biopython", + "sha256": "2ce6e5a5a6f7d496359b17ee7d87e8c6ee4d80687cdeaa97bb088fe97b7da251", + "size": 2286062, + "subdir": "linux-64", + "timestamp": 1632748513007, + "version": "1.78" + }, + "biopython-1.78-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Biopython License Agreement", + "md5": "dab26186ad5b4522178dbe8f6fc34e28", + "name": "biopython", + "sha256": "b62c12564c53794eb0eb237f0672fdcf52359bf5305ff2d9e016253930d8007c", + "size": 2247851, + "subdir": "linux-64", + "timestamp": 1600298915577, + "version": "1.78" + }, + "biopython-1.78-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Biopython License Agreement", + "md5": "8934a3ac3aa9b1ddf38977de101f0276", + "name": "biopython", + "sha256": "3556d177c55da59e8a2b67adf157bebea3857dfcb2062a33e039ac9800fa6db1", + "size": 2252127, + "subdir": "linux-64", + "timestamp": 1632738127026, + "version": "1.78" + }, + "biopython-1.78-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "Biopython License Agreement", + "md5": "35806e5110173cb60ecda1bd9674841c", + "name": "biopython", + "sha256": "cbeebf00f886dd76f57d1cbc9c71827151c26c188b8a7c1f1994bd7cf041c91c", + "size": 2228456, + "subdir": "linux-64", + "timestamp": 1600351962281, + "version": "1.78" + }, + "biopython-1.78-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "Biopython License Agreement", + "md5": "2de6d54a0fcd768fd0a8716ee0eb3c02", + "name": "biopython", + "sha256": "8584ad5c872430a00f218c8a813676669e5a9d7771409389b09046c339256e27", + "size": 2257964, + "subdir": "linux-64", + "timestamp": 1632748128146, + "version": "1.78" + }, + "biopython-1.78-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "Biopython License Agreement", + "md5": "8a6178e3d4abe52c01c8af2a3845b287", + "name": "biopython", + "sha256": "52927f818af5b5a4dec703a2c370c1715e6c9e832d0f8d94f00002d29a8c1957", + "size": 2257510, + "subdir": "linux-64", + "timestamp": 1632748490860, + "version": "1.78" + }, + "bison-3.0.4-h2db1b24_1.conda": { + "build": "h2db1b24_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "b52d712941afb33d9fce4bf4c09f5b2f", + "name": "bison", + "sha256": "f58b5fa44a1387d7c5be15860e543d8fd71fd6f2664099a7f2674a81dad158b2", + "size": 587214, + "subdir": "linux-64", + "timestamp": 1505728684179, + "version": "3.0.4" + }, + "bison-3.0.4-hf484d3e_2.conda": { + "build": "hf484d3e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "d48d0ec15d9e6609bfd9688f904acb1e", + "name": "bison", + "sha256": "990e4ba9dac98905056e7f1e90d2642a5b99290b910662819c2290af54e574a6", + "size": 584816, + "subdir": "linux-64", + "timestamp": 1529348703923, + "version": "3.0.4" + }, + "bison-3.0.5-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "40ab069f8d0cf806798d01de075a1cf9", + "name": "bison", + "sha256": "8ae7f07b153329056e202d7d026c6647fd8d79bbbe700fa82ab3fa6b10248e6a", + "size": 596389, + "subdir": "linux-64", + "timestamp": 1529566255098, + "version": "3.0.5" + }, + "bison-3.0.5-hf484d3e_1.conda": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "4979f69912e823bbfbb37551682d13bb", + "name": "bison", + "sha256": "47a2bc8758a25fcc53a9b5c13728979416bde4dbb5f926ecf6d9713965ddfcf7", + "size": 596448, + "subdir": "linux-64", + "timestamp": 1530648327360, + "version": "3.0.5" + }, + "bison-3.1-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL 3", + "md5": "abaa914a61153899a288d8abf29a213f", + "name": "bison", + "sha256": "861317cfc74f41fc6143692bd9bcdb8972830e69240e34f80ab0f6e23e9e9a5b", + "size": 602025, + "subdir": "linux-64", + "timestamp": 1539468543978, + "version": "3.1" + }, + "bison-3.4-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0", + "md5": "1958118760b1afbbcb234a0a8c1ed504", + "name": "bison", + "sha256": "53205201b3e0a23dddd39d2f4ba7a3423332d799f19cc58231a093f33e08b63b", + "size": 629233, + "subdir": "linux-64", + "timestamp": 1564614713849, + "version": "3.4" + }, + "bison-3.4-he6710b0_1.conda": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "flex", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0", + "md5": "10a394284bfcf77dd49262be5c451352", + "name": "bison", + "sha256": "a89404be4c3918ea90f5c0be1bd18bffaea26bfa84b16c83c6d8110671c9253d", + "size": 629395, + "subdir": "linux-64", + "timestamp": 1573952797905, + "version": "3.4" + }, + "bison-3.7.2-he6710b0_1.conda": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "flex", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0", + "md5": "b9f34df27a876746c641e5414d47640d", + "name": "bison", + "sha256": "caf18e5cd6a80318d8409708499562c97e33806dc86dc39e44a127b85c495d5f", + "size": 720143, + "subdir": "linux-64", + "timestamp": 1601406052972, + "version": "3.7.2" + }, + "bison-3.7.3-he6710b0_1.conda": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "flex", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0", + "md5": "34e7c858b9f325c9f3b96abcac5fd11c", + "name": "bison", + "sha256": "3914c05f0cc1a724b6da6390287bd5e08a9c7affe5592f53fb54d06bb361506a", + "size": 719572, + "subdir": "linux-64", + "timestamp": 1602605985078, + "version": "3.7.3" + }, + "bison-3.7.4-h2531618_1.conda": { + "build": "h2531618_1", + "build_number": 1, + "depends": [ + "flex", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0", + "md5": "304b469641c04bd63f0a5aa8fe0f4d47", + "name": "bison", + "sha256": "99cb0ca732d3dfea5127a1a50b95ef01f70f1902dd7b9d8d125e49b8c6553187", + "size": 721812, + "subdir": "linux-64", + "timestamp": 1607111502162, + "version": "3.7.4" + }, + "bison-3.7.5-h2531618_1.conda": { + "build": "h2531618_1", + "build_number": 1, + "depends": [ + "flex", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0", + "md5": "c6597bb708170310879896ee9ac51637", + "name": "bison", + "sha256": "9ff57e3cf0f58f53904cb1395330d1987dd2f89788d5e624911754bbbf35bc7d", + "size": 725443, + "subdir": "linux-64", + "timestamp": 1611514570295, + "version": "3.7.5" + }, + "bisonpp-1.21_45-hff7bd54_1002.conda": { + "build": "hff7bd54_1002", + "build_number": 1002, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "85c06fd4db9be9fa6fbd34c655ae31f3", + "name": "bisonpp", + "sha256": "79c23a7b82fba392f6d08c3307bcf0828ca77564dc385ef67334613d76209346", + "size": 131070, + "subdir": "linux-64", + "timestamp": 1622236637389, + "version": "1.21_45" + }, + "bitarray-0.8.1-py27h14c3975_1.conda": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "4e168e890494d942200a52c964274277", + "name": "bitarray", + "sha256": "60bed42d94bac0934941f62f363b1f5ce644e4fb992786c66e5557ec1cdaf8f6", + "size": 61831, + "subdir": "linux-64", + "timestamp": 1518032537360, + "version": "0.8.1" + }, + "bitarray-0.8.1-py27h304d4c6_0.conda": { + "build": "py27h304d4c6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "a7c23aa4784915447128b62357250d48", + "name": "bitarray", + "sha256": "33aa98c7beb27e3df8912971338659e7a3635cdfb9141d4b7a12b606580ebe6a", + "size": 61438, + "subdir": "linux-64", + "timestamp": 1505728699639, + "version": "0.8.1" + }, + "bitarray-0.8.1-py35h14c3975_1.conda": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "PSF", + "md5": "1dfec02904cebbaab3485448c91a8976", + "name": "bitarray", + "sha256": "352d05aad3f3685a87790f326ea684a2732a1bbe9ff2464d38f18ae4a348869b", + "size": 62861, + "subdir": "linux-64", + "timestamp": 1518030913269, + "version": "0.8.1" + }, + "bitarray-0.8.1-py35h7540340_0.conda": { + "build": "py35h7540340_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "PSF", + "md5": "13e0af57e3b4dbaa90fcfe665d6eed4e", + "name": "bitarray", + "sha256": "d4abb5d7a7a1895894824851ea2167b20d9eac09838458d596b3d4cae670b581", + "size": 62662, + "subdir": "linux-64", + "timestamp": 1505728715854, + "version": "0.8.1" + }, + "bitarray-0.8.1-py36h14c3975_1.conda": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "569e10e0b07cf92fef877c3b6a84904d", + "name": "bitarray", + "sha256": "278d91cf2052607110d0e64b7f46c7cb4508e108c0fac1074a69962851e3ea23", + "size": 62439, + "subdir": "linux-64", + "timestamp": 1518031506246, + "version": "0.8.1" + }, + "bitarray-0.8.1-py36h5834eb8_0.conda": { + "build": "py36h5834eb8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "10343e4881fe56bf15e4e2729d6cc0dc", + "name": "bitarray", + "sha256": "0b467caf46a2ce1b685a0ca544b99e8a0682e93c0336d7ebf289383dc03580a7", + "size": 62301, + "subdir": "linux-64", + "timestamp": 1505728732318, + "version": "0.8.1" + }, + "bitarray-0.8.2-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "5b97fa21d53ff57acce1a7c54d79ddec", + "name": "bitarray", + "sha256": "288d9b0caf6d5c824b19db25349debd721be818240dd8046266849f881b0ec68", + "size": 56773, + "subdir": "linux-64", + "timestamp": 1528210442336, + "version": "0.8.2" + }, + "bitarray-0.8.2-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "PSF", + "md5": "75d97082103b27a2e2da144e9610f37e", + "name": "bitarray", + "sha256": "449336eab2225f9d119d61a3738bd5207762c28ae6dfdb4c6fdcd9b3ee28f597", + "size": 57207, + "subdir": "linux-64", + "timestamp": 1528210515389, + "version": "0.8.2" + }, + "bitarray-0.8.2-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "1dde8c01e42a69a8dc8b7907fcb9b6bb", + "name": "bitarray", + "sha256": "848bbec96452e08cf392fc934afaebf06cb3e5c51fbec275df3a84cd8b057acf", + "size": 56690, + "subdir": "linux-64", + "timestamp": 1528210490763, + "version": "0.8.2" + }, + "bitarray-0.8.2-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "42d549c91b054586ce42a797ca7abca7", + "name": "bitarray", + "sha256": "f51e8bf567bdf5f5088ebb193fbdf881cf652820ca622647016193dff9e09149", + "size": 56307, + "subdir": "linux-64", + "timestamp": 1530770880878, + "version": "0.8.2" + }, + "bitarray-0.8.3-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "ccb84555f1b20f4deca812faebb718db", + "name": "bitarray", + "sha256": "41187a6ce84c45c39151bdbe85f14995b71cfac9573f61f2b53e1ea50f2cc8b0", + "size": 56706, + "subdir": "linux-64", + "timestamp": 1532525189576, + "version": "0.8.3" + }, + "bitarray-0.8.3-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "PSF", + "md5": "906eacdd74d72089389b0f41ae6e648a", + "name": "bitarray", + "sha256": "e13817e5390e1761fd2a6a3808f859da3757f5aaa1810c49e2e821874565d5ce", + "size": 57398, + "subdir": "linux-64", + "timestamp": 1532525186028, + "version": "0.8.3" + }, + "bitarray-0.8.3-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "8ce4901aaae81364ea036efefae8543b", + "name": "bitarray", + "sha256": "daabb5012562dcaeaca3d0755d707794dfe4f719efed2f45a320cc65f1de8af4", + "size": 56645, + "subdir": "linux-64", + "timestamp": 1532525131596, + "version": "0.8.3" + }, + "bitarray-0.8.3-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "3f807653f76624b571212c95b50c4a5c", + "name": "bitarray", + "sha256": "6a9531943e47a54fa62c1fb08ed3e74d4c77708da607be4e232c1cfef3a8630e", + "size": 56173, + "subdir": "linux-64", + "timestamp": 1532525193185, + "version": "0.8.3" + }, + "bitarray-0.9.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "b0aafed7c4afb0c64ff289fb16982676", + "name": "bitarray", + "sha256": "7de5e3bd9afcd8083e9cf023a3c9ba64a38e2b7e6e97746ae59bed7a09588925", + "size": 59243, + "subdir": "linux-64", + "timestamp": 1555954589643, + "version": "0.9.0" + }, + "bitarray-0.9.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "09e1743c5e07ad5c19e35c5c5bf1e878", + "name": "bitarray", + "sha256": "08890a30f3a38a07e1e95dba4f3e395eae69814bd98701d9f64c3d76c40de722", + "size": 59793, + "subdir": "linux-64", + "timestamp": 1555954747421, + "version": "0.9.0" + }, + "bitarray-0.9.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "7f6261c6cb552600c06877bb5b735f1f", + "name": "bitarray", + "sha256": "658ae55d5e4d1f9bfed30b2460844b086e676e12d9b46b5437777470a705dd92", + "size": 59461, + "subdir": "linux-64", + "timestamp": 1555954723605, + "version": "0.9.0" + }, + "bitarray-0.9.2-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "7f536b016164c16f098243322b9ef9f3", + "name": "bitarray", + "sha256": "1b8207bf359be5b8e9b751541b2ef26682a5f6b3d291593620704b5b7517cb80", + "size": 60018, + "subdir": "linux-64", + "timestamp": 1557507385920, + "version": "0.9.2" + }, + "bitarray-0.9.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "27cc4f77544dbb13870ddd77a9c4b341", + "name": "bitarray", + "sha256": "dee99bb567e0b1815db2b488dd127e6ef445aa2b03c8636b4fa7ea2ef87eadf2", + "size": 60209, + "subdir": "linux-64", + "timestamp": 1557507404064, + "version": "0.9.2" + }, + "bitarray-0.9.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "7912bdbc866da417f0f2cb7f2e8ae937", + "name": "bitarray", + "sha256": "7aeefa05d2825bc6cd8d09ae66cf9d998914a6dff0c4f10618b9567cb5ec8962", + "size": 59952, + "subdir": "linux-64", + "timestamp": 1557507368929, + "version": "0.9.2" + }, + "bitarray-0.9.3-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "e8c14484c3785e7e3355e7ba5aab223e", + "name": "bitarray", + "sha256": "92b0ddb7478e6364cd0cb524a90668f4587c928fcad65fd1a137dd3c330ded8b", + "size": 61602, + "subdir": "linux-64", + "timestamp": 1558553847917, + "version": "0.9.3" + }, + "bitarray-0.9.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "09ee69c68b3abbc5218f1d7ad3600450", + "name": "bitarray", + "sha256": "f762e3cdeaddcab8252ce493783307df2007ae965d247928f327ab3585e8b873", + "size": 61748, + "subdir": "linux-64", + "timestamp": 1558553876584, + "version": "0.9.3" + }, + "bitarray-0.9.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "fe1c3e9d97a45aa5fb3eb3c8aaaa809d", + "name": "bitarray", + "sha256": "a8ebab236c1e6460281e9fb8f5cb8d2ca9c42df44a05862c6ba15a841e09b640", + "size": 61054, + "subdir": "linux-64", + "timestamp": 1558553807689, + "version": "0.9.3" + }, + "bitarray-1.0.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "48e0bf86a55ca2fac5d0d9261da1f404", + "name": "bitarray", + "sha256": "3dc5d90d38655f6287f02b83293ff19949be9a570fe8897dfd2f3a266ea06769", + "size": 61647, + "subdir": "linux-64", + "timestamp": 1565962341213, + "version": "1.0.1" + }, + "bitarray-1.0.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "bee9a873fee980fe8714252dc779f0fc", + "name": "bitarray", + "sha256": "74cc2a5028fefa46b5f8e56a9827920baf19a09979c907f13ce2d3fa6714708c", + "size": 61850, + "subdir": "linux-64", + "timestamp": 1565962309794, + "version": "1.0.1" + }, + "bitarray-1.0.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "2dd284cfbdafa7e77ee744fba45da586", + "name": "bitarray", + "sha256": "992f2d9cfab9cef9c749ea9b7b354cd029c6dff6be0fc1a017cef60d9a9b93c6", + "size": 61795, + "subdir": "linux-64", + "timestamp": 1565962284646, + "version": "1.0.1" + }, + "bitarray-1.0.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "a6d20c68a43e5e5cb891ca08070d2b5e", + "name": "bitarray", + "sha256": "6e8978436d57fa85fb0205690e74858d1dbbcfe2f80785055b4d296878691f46", + "size": 66734, + "subdir": "linux-64", + "timestamp": 1572609073689, + "version": "1.0.1" + }, + "bitarray-1.1.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "0dbf53008ad710482cbe6c8c13b36056", + "name": "bitarray", + "sha256": "99c95b45ee86c0d80bfd9431737884a5c447ae3dc8ea51b03cc3fd593cf7e7bb", + "size": 69847, + "subdir": "linux-64", + "timestamp": 1573937671633, + "version": "1.1.0" + }, + "bitarray-1.1.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "41ad2c486ee9e4f6f7f2e63066904b8e", + "name": "bitarray", + "sha256": "94ea05dc327d56e50e5868eb472c68ab55615037a4a070fba17450dac591fd53", + "size": 69887, + "subdir": "linux-64", + "timestamp": 1573937655717, + "version": "1.1.0" + }, + "bitarray-1.1.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "31e8fe497ea0c68b60892643f29c3ecc", + "name": "bitarray", + "sha256": "a2d1c1ad4ddc01e5cdd4d518a775d1a022d3c3fbb6eba57654f0a019aa62cc2a", + "size": 69466, + "subdir": "linux-64", + "timestamp": 1573937634800, + "version": "1.1.0" + }, + "bitarray-1.1.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "15c8a3f18e2642496135a6eafd6f3f5f", + "name": "bitarray", + "sha256": "56a5231ec654a5597625ccb0fbb3b5215c372039f07d45a8db4e2f7e6f882a8c", + "size": 76685, + "subdir": "linux-64", + "timestamp": 1573937687889, + "version": "1.1.0" + }, + "bitarray-1.2.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "a3f472bba711e3898bb976517611e17c", + "name": "bitarray", + "sha256": "34b5b6ad1c3f46ecd427345bb5fed1a92e5a13a17aea4624cbd2781ac2f446b0", + "size": 84677, + "subdir": "linux-64", + "timestamp": 1576537929528, + "version": "1.2.0" + }, + "bitarray-1.2.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "7c60233ff9aa18982e7ffad530926264", + "name": "bitarray", + "sha256": "8f7e924ae78802bf66b306b2e039dbaafb56323ffd36c5e83f04fae1b2363877", + "size": 85486, + "subdir": "linux-64", + "timestamp": 1576537906127, + "version": "1.2.0" + }, + "bitarray-1.2.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "2a7eb9deff02a4979a1fedd52b33b9f8", + "name": "bitarray", + "sha256": "ef23d0ac4acff9f1fcc90c78152d7a4309225039be8c0032863b501c4b164f9d", + "size": 84145, + "subdir": "linux-64", + "timestamp": 1576537932412, + "version": "1.2.0" + }, + "bitarray-1.2.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "d8494d246b6b488ac3067f407fd1e4fc", + "name": "bitarray", + "sha256": "eb76849e07a865de619d229c13da62d2d36d0b87413a90ef0d4c0bb8301abfb7", + "size": 91658, + "subdir": "linux-64", + "timestamp": 1576537962705, + "version": "1.2.0" + }, + "bitarray-1.2.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "66d5b2dc71694380d140487ab9e1de4e", + "name": "bitarray", + "sha256": "af387cba84d19c15edc258bb18ce7c53b562b6dc6fdab3d73a6228e6a8ab7ef3", + "size": 85070, + "subdir": "linux-64", + "timestamp": 1580153030553, + "version": "1.2.1" + }, + "bitarray-1.2.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "349db62679255dbfc92dc6ffed8cd096", + "name": "bitarray", + "sha256": "275c7dfbf9c16521ff2a829253c4ec95a4eadc176c4a954d03a2564b8dfe6f53", + "size": 84464, + "subdir": "linux-64", + "timestamp": 1580153141996, + "version": "1.2.1" + }, + "bitarray-1.2.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "69ed38e1fc0ce117f3f5528778ba6587", + "name": "bitarray", + "sha256": "77a7844e8f841fc1189bf360142f7bf0b03ac593f963e5c4bdf6dfe780891c73", + "size": 84788, + "subdir": "linux-64", + "timestamp": 1580153033390, + "version": "1.2.1" + }, + "bitarray-1.2.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "dc654c73f8dd1bf72b3bd11a9dfa6ff7", + "name": "bitarray", + "sha256": "79d46bbc23bf644a3c6caa242349b7e26cb93511dc7bf843195c5981e884807a", + "size": 85656, + "subdir": "linux-64", + "timestamp": 1591724817528, + "version": "1.2.2" + }, + "bitarray-1.2.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "9779995da4a3da9a90019edcf40a7021", + "name": "bitarray", + "sha256": "813e92f32f2dafeb48cbca2475b80d04409b3693ad4fc9d862a95976bd2dacd1", + "size": 84978, + "subdir": "linux-64", + "timestamp": 1591724824789, + "version": "1.2.2" + }, + "bitarray-1.2.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "4df3aeed2d8669af81bfe152a1e09ab6", + "name": "bitarray", + "sha256": "2f60a5f4f260339a3fc1592da0aacd8049af1defb52442e177c3177758e2aafd", + "size": 84642, + "subdir": "linux-64", + "timestamp": 1591724823309, + "version": "1.2.2" + }, + "bitarray-1.3.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "1c6357f0b75c2039b31160b55f4b51ec", + "name": "bitarray", + "sha256": "6679e5f9116575d9f7d9e7d13a1f02e3b876dc8a3c26dcccfe79a3515e62fd21", + "size": 88827, + "subdir": "linux-64", + "timestamp": 1594237136902, + "version": "1.3.0" + }, + "bitarray-1.3.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "de5262558c9297daa3d6c4ddc17a7c57", + "name": "bitarray", + "sha256": "694db5706654b9653db21af3cd1cfcbf3fbcf474533458a7da00af130071b21b", + "size": 87601, + "subdir": "linux-64", + "timestamp": 1594237120475, + "version": "1.3.0" + }, + "bitarray-1.3.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "5a425eb546883d6340f6d4b50d1598ab", + "name": "bitarray", + "sha256": "1fc052d577a95a95b24de6c35233d8e7fe91b6a644b7e8cc81686d593dee88af", + "size": 88423, + "subdir": "linux-64", + "timestamp": 1594237153182, + "version": "1.3.0" + }, + "bitarray-1.4.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "c0750a4db3853dc64035e0dead692260", + "name": "bitarray", + "sha256": "a6bc9d121d333565957c9d11151835728963b988b0028d194911816fb36ae088", + "size": 90727, + "subdir": "linux-64", + "timestamp": 1594753917320, + "version": "1.4.0" + }, + "bitarray-1.4.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "4390ea153e07bbd9103fe8212ba3f82d", + "name": "bitarray", + "sha256": "a1f80363d1252c4fe298fb576578446a062e94212d3a6d5bcc22d747bd2619e9", + "size": 89965, + "subdir": "linux-64", + "timestamp": 1594753964179, + "version": "1.4.0" + }, + "bitarray-1.4.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "2a8dc30674e57da68934e6d85432d45e", + "name": "bitarray", + "sha256": "6c5112aabb7b2beae958b66dfd0414320bd25c1c89daa1976dbe044fdd1187e2", + "size": 88896, + "subdir": "linux-64", + "timestamp": 1594753917558, + "version": "1.4.0" + }, + "bitarray-1.4.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "3eb842b50291056b6d05952467ae78a6", + "name": "bitarray", + "sha256": "689093f3176afaf474f66cc5c37025260786cd44ee96570d85c9cd9b21d99bf4", + "size": 91748, + "subdir": "linux-64", + "timestamp": 1596108569879, + "version": "1.4.2" + }, + "bitarray-1.4.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "acb4b60ec7337c00aba25107e952ca5f", + "name": "bitarray", + "sha256": "ae0beb3df020863d9a58488242f572e308dbf4b6ea9d8f82d0460c7ac3ea4f09", + "size": 91152, + "subdir": "linux-64", + "timestamp": 1596108562750, + "version": "1.4.2" + }, + "bitarray-1.4.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "b4722f7a6f17ecd20afae7afa298a29d", + "name": "bitarray", + "sha256": "0933115c53fc46ca2a75c3a1c80c8ad08543eec2b3b4a64e15a5078fa1f294af", + "size": 92399, + "subdir": "linux-64", + "timestamp": 1596108599253, + "version": "1.4.2" + }, + "bitarray-1.5.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "eddf67aa636d93100de6d14578affb06", + "name": "bitarray", + "sha256": "bb6d26d3bb1deb6cadcd872210778e44bf09ecf00f4f13cbb318784728da59e1", + "size": 94404, + "subdir": "linux-64", + "timestamp": 1597678783286, + "version": "1.5.2" + }, + "bitarray-1.5.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "ce791dc37ce52e67a45a873b9c0e5faf", + "name": "bitarray", + "sha256": "e744c7f7cddc5528633ca09528733c43d09625f3e15c9bca79fc541095651cad", + "size": 94540, + "subdir": "linux-64", + "timestamp": 1597678804683, + "version": "1.5.2" + }, + "bitarray-1.5.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "d4e42b3d01c85b16ffcccb03f0dae641", + "name": "bitarray", + "sha256": "aab9ddc058c059d4e6e30476ace605e472bbbddcb81859a879dc1ea647d26833", + "size": 94156, + "subdir": "linux-64", + "timestamp": 1597678783344, + "version": "1.5.2" + }, + "bitarray-1.5.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "3332bc31f963d46fdf73f7fe32a96f99", + "name": "bitarray", + "sha256": "bf89a9b1ff4a36d778e2bbad70b8e770e7b794cabc191d2a63fb971b580ada7a", + "size": 95895, + "subdir": "linux-64", + "timestamp": 1598885003484, + "version": "1.5.3" + }, + "bitarray-1.5.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "dc29c2d22fca4ce2931cf5d63b7d27c7", + "name": "bitarray", + "sha256": "2a5ba43e088f79a58e643cd6728712164a5cd7f4e7e0e3e1f0028bcd29912e07", + "size": 95655, + "subdir": "linux-64", + "timestamp": 1598885036711, + "version": "1.5.3" + }, + "bitarray-1.5.3-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "fa2a28a556d7888baee84b7dea5a28b1", + "name": "bitarray", + "sha256": "b42dc121d6c696925e5253e13d39a87136d3ee7ee31ae24345878d3f8fbce5fa", + "size": 94946, + "subdir": "linux-64", + "timestamp": 1598884962413, + "version": "1.5.3" + }, + "bitarray-1.6.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "b03fddda2696ef0834b84c9bd9a00146", + "name": "bitarray", + "sha256": "c75cef41c43523d5742817e4ab90d0703d9211d3e47646c97b4aa1c68de303f6", + "size": 94053, + "subdir": "linux-64", + "timestamp": 1603210389514, + "version": "1.6.0" + }, + "bitarray-1.6.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "c71771c0f357031198ec6b47d8dc3c85", + "name": "bitarray", + "sha256": "054049d4e8bb72ad053854d631a6ba6a3d08fa6ca698767ad4983984ac042056", + "size": 93131, + "subdir": "linux-64", + "timestamp": 1603210389814, + "version": "1.6.0" + }, + "bitarray-1.6.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "9abafebe1d49889b3a880759b0a437c5", + "name": "bitarray", + "sha256": "6ff729807b7fe5cab52832a838af318c5a5b036fab37467b646ceb101ab6e1b0", + "size": 92997, + "subdir": "linux-64", + "timestamp": 1603210421851, + "version": "1.6.0" + }, + "bitarray-1.6.1-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "83759b784752384de05bb590371b9c36", + "name": "bitarray", + "sha256": "96e48d6abcb886878149213861919c9980d2839fa3c2689c08528dac914c2d3d", + "size": 94174, + "subdir": "linux-64", + "timestamp": 1605065168405, + "version": "1.6.1" + }, + "bitarray-1.6.1-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "56e23f567787e879e2c484ac54bb6d7d", + "name": "bitarray", + "sha256": "3d1a09701fc38290336331920102569737a750e85682daeeaaf36aa733050fd1", + "size": 93247, + "subdir": "linux-64", + "timestamp": 1605065184417, + "version": "1.6.1" + }, + "bitarray-1.6.1-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "d2508585597d0d6b3e909b1f09b907dd", + "name": "bitarray", + "sha256": "3857ef01a3a9346d1d8d9eb0608b806f2c6db0982feace256ab5e5b084995c6e", + "size": 93469, + "subdir": "linux-64", + "timestamp": 1605065149477, + "version": "1.6.1" + }, + "bitarray-1.6.1-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "773d4fb04a76ae87076891b12705ee54", + "name": "bitarray", + "sha256": "5022e05e02a516fe06d5f608c61f43fcfb8e4dfcdd645792bd5b642abdd57086", + "size": 93548, + "subdir": "linux-64", + "timestamp": 1605065157725, + "version": "1.6.1" + }, + "bitarray-1.6.3-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "52ed481976a6119af6221bc7072fc60d", + "name": "bitarray", + "sha256": "368a051c2d4deb8a434c0b3e61c0db91402259fac3c8eed4b96e7d62ccc375ff", + "size": 98485, + "subdir": "linux-64", + "timestamp": 1611254302557, + "version": "1.6.3" + }, + "bitarray-1.6.3-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "b9477781a7601e3ccc2fe2a85b412f7e", + "name": "bitarray", + "sha256": "2d1d49d5d841d06a68fcea5d86125a64de0986297aa4cf34397ceaf14bbb013a", + "size": 97623, + "subdir": "linux-64", + "timestamp": 1611254407815, + "version": "1.6.3" + }, + "bitarray-1.6.3-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "a8a26ebe87c6408f55fe7186ace65f73", + "name": "bitarray", + "sha256": "c6ed55114023e6f893bc4f9b32e290bd81e65ee89c113498a71ed7f5e16a2864", + "size": 97438, + "subdir": "linux-64", + "timestamp": 1611254399540, + "version": "1.6.3" + }, + "bitarray-1.6.3-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "d3eabbc68425d13e45c8b8637a977455", + "name": "bitarray", + "sha256": "9b9384fbd8fae0c134606bc209370063a238bc3e4a949ce79308b026419a75a9", + "size": 97131, + "subdir": "linux-64", + "timestamp": 1611254430049, + "version": "1.6.3" + }, + "bitarray-1.7.0-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "3ab339dbfc706e4df9060f6cfe433731", + "name": "bitarray", + "sha256": "b85aae5161a1def99760ee540893ba39a64e74c6c3bc8bd0f57b8b7994e520e1", + "size": 98710, + "subdir": "linux-64", + "timestamp": 1614627880520, + "version": "1.7.0" + }, + "bitarray-1.7.0-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "9d3c7af096e137ec3f01e0d20d3f5a28", + "name": "bitarray", + "sha256": "fd11a8b029a3f4015996bd136c88a82f248bb92e8a19f3f39a68b836ad70f61f", + "size": 98010, + "subdir": "linux-64", + "timestamp": 1614614612726, + "version": "1.7.0" + }, + "bitarray-1.7.0-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "d701eccad9e7ad3d4aa2324a5a6af42b", + "name": "bitarray", + "sha256": "b38e8d89d217f947efa160bbf648962b8d0fd6044af7dafec47ba561d6d49849", + "size": 98379, + "subdir": "linux-64", + "timestamp": 1614628205158, + "version": "1.7.0" + }, + "bitarray-1.7.0-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "eeeca1fab75213352fca4d2291b6c00e", + "name": "bitarray", + "sha256": "def240c5d17080d1e635508a0516be12be04c6f3102b3a4dfcffae8d72fbc4ad", + "size": 97887, + "subdir": "linux-64", + "timestamp": 1614613977471, + "version": "1.7.0" + }, + "bitarray-1.7.1-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "4c6a138425368e2cf1dc90ee468a1127", + "name": "bitarray", + "sha256": "a67cb6b3e6e1bd018828cdc1d2af2f2c6e65bae8f0507b6572552a84e0b2a558", + "size": 99353, + "subdir": "linux-64", + "timestamp": 1615661016737, + "version": "1.7.1" + }, + "bitarray-1.7.1-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "38a74d264deee9dbe0cf26c71cbfc7c7", + "name": "bitarray", + "sha256": "443d6c1bd9acb1c0d071029eb4f63a87ca3fd120404b4ad4843f88e0d78ecabd", + "size": 97744, + "subdir": "linux-64", + "timestamp": 1615660280755, + "version": "1.7.1" + }, + "bitarray-1.7.1-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "7da8d518789b850e5b3638be314d5412", + "name": "bitarray", + "sha256": "d5e193d113dbe393a17993d9a028ddfb81aae449c93583e036dc30afb300af8e", + "size": 97779, + "subdir": "linux-64", + "timestamp": 1615661011517, + "version": "1.7.1" + }, + "bitarray-1.7.1-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "22273dd214a87136a784d75ed955c477", + "name": "bitarray", + "sha256": "21d2176a0113a24da1e81b52e8e4c2c89c9aea766d3edc9d614b3ab198cd2a01", + "size": 98223, + "subdir": "linux-64", + "timestamp": 1615661017115, + "version": "1.7.1" + }, + "bitarray-1.8.0-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "fb64c201c9f4f70114a82e2c9b002da1", + "name": "bitarray", + "sha256": "2e9a811f02a365773fceced1fd18e3e5145a7c788de29b47f72da35318b21302", + "size": 104370, + "subdir": "linux-64", + "timestamp": 1616441486971, + "version": "1.8.0" + }, + "bitarray-1.8.0-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "d88e1891f7ddb779641e43338100ac1c", + "name": "bitarray", + "sha256": "757129ed238ba311b070a6782bf6038a30d6f9698bbddb163cb61daf6f85737c", + "size": 103020, + "subdir": "linux-64", + "timestamp": 1616441336780, + "version": "1.8.0" + }, + "bitarray-1.8.0-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "75b56dad500defd0e7b6268f40f66656", + "name": "bitarray", + "sha256": "405d548eb94e8aa2b357af7ffe8cadfa7be4e9f817cfbd3a141e2bf6b5ed97f8", + "size": 103147, + "subdir": "linux-64", + "timestamp": 1616441490709, + "version": "1.8.0" + }, + "bitarray-1.8.0-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "9cc9b288bf1b79c8014158982e540eb1", + "name": "bitarray", + "sha256": "92c833c7ad63129e6734e09b8c33be6758bb01c25b467bbad1ab51a3100b0859", + "size": 103905, + "subdir": "linux-64", + "timestamp": 1616441506797, + "version": "1.8.0" + }, + "bitarray-1.8.2-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "0cf904d3d833eace85bfb12ed14589e4", + "name": "bitarray", + "sha256": "2e0de3a3c82387d2ffb1ff6f7d8eb611bfd53e2286b7413a313ebc92f489418c", + "size": 106311, + "subdir": "linux-64", + "timestamp": 1617219400683, + "version": "1.8.2" + }, + "bitarray-1.8.2-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "1041818a2d25193e7686dc28bfa4b706", + "name": "bitarray", + "sha256": "63104842dfb063dd61bcf6eccce0bc44e48ec8ac3b4eef79ebeb98ecb8a70723", + "size": 105460, + "subdir": "linux-64", + "timestamp": 1617221904141, + "version": "1.8.2" + }, + "bitarray-1.8.2-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "51aec679d2076f1c2443787f36780992", + "name": "bitarray", + "sha256": "bd519547ef39896d9cc99690a1a938dc062c073c86a1de0c48b05b40c3bcc418", + "size": 105539, + "subdir": "linux-64", + "timestamp": 1617221902114, + "version": "1.8.2" + }, + "bitarray-1.8.2-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "291961f9a0ebc578cda53247df1e795b", + "name": "bitarray", + "sha256": "77cda5b21fe48b5d69c94b20070c87cf0a0b2bd0127131e4bd64309414b4cb7e", + "size": 105573, + "subdir": "linux-64", + "timestamp": 1617221903416, + "version": "1.8.2" + }, + "bitarray-1.9.0-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "333f0a3ea47b6de6d49f7ba2f8ea81ac", + "name": "bitarray", + "sha256": "d9993d1efe3357ea545a86785c22af2df8dcc9a8c97c78bb565f69e6b20fec01", + "size": 113781, + "subdir": "linux-64", + "timestamp": 1617622055646, + "version": "1.9.0" + }, + "bitarray-1.9.0-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "3cf81926d22d619408745221e6c8f2c7", + "name": "bitarray", + "sha256": "5c557477e4f494cae04ba935ff7a15f6a746f47072f6f898cc1bf993e0746c4e", + "size": 113082, + "subdir": "linux-64", + "timestamp": 1617624769757, + "version": "1.9.0" + }, + "bitarray-1.9.0-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "084a4f2d07dc88c0a052a44eae9716de", + "name": "bitarray", + "sha256": "1e4760c4e0b06b806c5b11f1ee672391c46397984df995c5f483b2828b6c8b84", + "size": 112973, + "subdir": "linux-64", + "timestamp": 1617481189695, + "version": "1.9.0" + }, + "bitarray-1.9.0-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "da4d58672c43b3ce9f954a6f50d0c70d", + "name": "bitarray", + "sha256": "eaeb4b00178a9335e9f8e105d0f49abc541b90a8b5d94b105c7527a6a842e1a5", + "size": 113697, + "subdir": "linux-64", + "timestamp": 1617481198573, + "version": "1.9.0" + }, + "bitarray-1.9.1-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "c086a0042ee6ffcef7f8f7d43f9fb7f5", + "name": "bitarray", + "sha256": "b7773d55232ada47c237bf252d3060c42c41f5b1070ad3696482c9ded4cb36e8", + "size": 120889, + "subdir": "linux-64", + "timestamp": 1617654724478, + "version": "1.9.1" + }, + "bitarray-1.9.1-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "bfd5695c5285023bbf7a9e02b54ca622", + "name": "bitarray", + "sha256": "ad55ee0bfdd42072c4f7e5c0296a61007fc4624df5b3c2ca071ada2184b2b9c2", + "size": 118971, + "subdir": "linux-64", + "timestamp": 1617654722457, + "version": "1.9.1" + }, + "bitarray-1.9.1-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "6a08fcb46f4422c1c46a88fa1402f13c", + "name": "bitarray", + "sha256": "ab6c2ce8a348276c4897f10f84e8342933c9d8a025ed44cf8fef520453d534c3", + "size": 118900, + "subdir": "linux-64", + "timestamp": 1617654724820, + "version": "1.9.1" + }, + "bitarray-1.9.1-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "9cc5fd3e646237b5aa0068fb358c523e", + "name": "bitarray", + "sha256": "279513aef75e13d679f60ca68b32fb315c15b25d6fc7a7080b2428338500c27c", + "size": 118833, + "subdir": "linux-64", + "timestamp": 1617654396983, + "version": "1.9.1" + }, + "bitarray-1.9.2-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "a13df184b6c80c4db2282130d4cbc174", + "name": "bitarray", + "sha256": "31135e580fa9ef6002f9b482f715045914a826152171f90378fbb5f0cbe662c1", + "size": 120824, + "subdir": "linux-64", + "timestamp": 1618434919599, + "version": "1.9.2" + }, + "bitarray-1.9.2-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "930b45c4ebde9c3d3259408fe45dcab9", + "name": "bitarray", + "sha256": "1c9ce37b4350b0ad79ed310450279080a5bc7c1ed2ead03352fbecd8f4800774", + "size": 119268, + "subdir": "linux-64", + "timestamp": 1618434920232, + "version": "1.9.2" + }, + "bitarray-1.9.2-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "2d0c1aa8519cbf0975840b62e1f065a2", + "name": "bitarray", + "sha256": "b0b5b8125709da432ff1cafe9f20cf6add074a737b5049f37b6ae91fa0cd37e7", + "size": 119663, + "subdir": "linux-64", + "timestamp": 1618431804744, + "version": "1.9.2" + }, + "bitarray-1.9.2-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "2a774d2d7e7d97e05dd2b7c96cb12029", + "name": "bitarray", + "sha256": "e1896747d38256d761aecc43b970808a2e3dc8ae3a845056a5672e2b882b9224", + "size": 119504, + "subdir": "linux-64", + "timestamp": 1618434915421, + "version": "1.9.2" + }, + "bitarray-2.1.0-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "f05997b2fa6133025da6aedd51559067", + "name": "bitarray", + "sha256": "f3c9e00a70e9879baba5f4ae96bea8d80e4a1d604beb6a26aa6c345c4dff65c2", + "size": 124308, + "subdir": "linux-64", + "timestamp": 1620823284203, + "version": "2.1.0" + }, + "bitarray-2.1.0-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "81eb3318a31feab636547bb1b959e642", + "name": "bitarray", + "sha256": "bb7399e3b49a90f00302c86e2c4be3394d36cc33a980ac5b08715a8ccfd08965", + "size": 122488, + "subdir": "linux-64", + "timestamp": 1620827457178, + "version": "2.1.0" + }, + "bitarray-2.1.0-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "58f90a7a78b1a1f64db7badfb32efb6d", + "name": "bitarray", + "sha256": "38a7b53237212fe917b5d1f0cfa46e6e324c0043e27587e8b458ed69da30c6d6", + "size": 122980, + "subdir": "linux-64", + "timestamp": 1620827598629, + "version": "2.1.0" + }, + "bitarray-2.1.0-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "8bc9a1ea9d01998950998f82088dccdd", + "name": "bitarray", + "sha256": "1a8db827c7b5b82f8120371f79fd3414bd2cc2fcaf96e6c4a83258f3ffbd6c4e", + "size": 122809, + "subdir": "linux-64", + "timestamp": 1620827598531, + "version": "2.1.0" + }, + "bitarray-2.2.3-py36h7f8727e_1.conda": { + "build": "py36h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "bc7a0689405ee343e80f0babc0a7a39d", + "name": "bitarray", + "sha256": "e4ff729cce286c9d71738d7bf98d4a43069e6495fbd56f2f950fbae86f7ad58e", + "size": 132237, + "subdir": "linux-64", + "timestamp": 1627479976196, + "version": "2.2.3" + }, + "bitarray-2.2.3-py37h7f8727e_1.conda": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "d7d2f39871a46467011a9920feb47299", + "name": "bitarray", + "sha256": "b4d4423e00777d5df8ff600d03a42a41743144f4b1ec33029cab562c60e93ef4", + "size": 130530, + "subdir": "linux-64", + "timestamp": 1627480561890, + "version": "2.2.3" + }, + "bitarray-2.2.3-py38h7f8727e_1.conda": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "558d3fda80d480df640b922188f49b0c", + "name": "bitarray", + "sha256": "8b6b0da652f04b6268154103032c618cd6a98a06c20872446aa556b2104b2c28", + "size": 130377, + "subdir": "linux-64", + "timestamp": 1627480563868, + "version": "2.2.3" + }, + "bitarray-2.2.3-py39h7f8727e_1.conda": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "edc36f97e77ea6d14fc9480f41ed4f03", + "name": "bitarray", + "sha256": "2bf9e83ff74f70dfd863e72039abc07d70531a8fed3f38c2b5a8a8b7e1bd7cf9", + "size": 130988, + "subdir": "linux-64", + "timestamp": 1627472882689, + "version": "2.2.3" + }, + "bitarray-2.2.5-py36h7f8727e_1.conda": { + "build": "py36h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "febada330d89dbe17175aad0371d7c91", + "name": "bitarray", + "sha256": "ed894c4f4d214f6ca4de8c257ad8e631d0e38ebaafeeb819dcb5db36ab5d615a", + "size": 137020, + "subdir": "linux-64", + "timestamp": 1628540510364, + "version": "2.2.5" + }, + "bitarray-2.2.5-py37h7f8727e_1.conda": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "715f63ee0f3f9a6eb783928eb52215d4", + "name": "bitarray", + "sha256": "750630942b93c9d7d3c593908429090b79e4e8563cba7cc86b30a7ff4d05be8c", + "size": 135579, + "subdir": "linux-64", + "timestamp": 1628540359507, + "version": "2.2.5" + }, + "bitarray-2.2.5-py38h7f8727e_1.conda": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "8ca4eebbfa56c4aac59d7ff6d34d050d", + "name": "bitarray", + "sha256": "c36b9ac4a358cc0677929a7412456bdd4799c97676dd931f9d85452900b7a070", + "size": 135736, + "subdir": "linux-64", + "timestamp": 1628540490017, + "version": "2.2.5" + }, + "bitarray-2.2.5-py39h7f8727e_1.conda": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "ebe871216ee2e3505444472bed279978", + "name": "bitarray", + "sha256": "a50210657f7ee7921e3f52f7a72ae64f74b38e119f847cc9e764d80567d3e73b", + "size": 136053, + "subdir": "linux-64", + "timestamp": 1628532269490, + "version": "2.2.5" + }, + "bitarray-2.3.0-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "d18eb8f56b17a15a8dfac69aee8ea311", + "name": "bitarray", + "sha256": "c5f6240e0ef230ea21c22cb1327263a4f3056c63e20de6cd55737d9c77247589", + "size": 209102, + "subdir": "linux-64", + "timestamp": 1640788499308, + "version": "2.3.0" + }, + "bitarray-2.3.0-py36h7f8727e_1.conda": { + "build": "py36h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "65fef23755ba82a045a07bcf4426f8e5", + "name": "bitarray", + "sha256": "83fb51ae12d40fec1fa3a15d6751b1bac9c4b13f851889e8f5c2de964e12ec18", + "size": 142760, + "subdir": "linux-64", + "timestamp": 1629132540068, + "version": "2.3.0" + }, + "bitarray-2.3.0-py37h7f8727e_1.conda": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "9e4b22f48f2f3fc50126386faa63b02e", + "name": "bitarray", + "sha256": "b70188fc5b322a7654fafda0841dab2d0f74bb0717efa026c0d5da3dabc4122b", + "size": 141661, + "subdir": "linux-64", + "timestamp": 1629132898382, + "version": "2.3.0" + }, + "bitarray-2.3.0-py38h7f8727e_1.conda": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "2734f75b08cfba8cffeb98692a5cc96f", + "name": "bitarray", + "sha256": "e8cab2d082d1a395d51ba3ab4251ee2b055796c53bba28482f23b3d47e10a01e", + "size": 142424, + "subdir": "linux-64", + "timestamp": 1629132897274, + "version": "2.3.0" + }, + "bitarray-2.3.0-py39h7f8727e_1.conda": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "3c3c370a28ee05f3ddab5fff8de8adab", + "name": "bitarray", + "sha256": "ae8ce2b469a2aaa8bc7507c84810c045c3acde17a2c9451b89d7993aff3281af", + "size": 143454, + "subdir": "linux-64", + "timestamp": 1629132900346, + "version": "2.3.0" + }, + "bitarray-2.3.5-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "f4b912c162362619daa41e78d8a629b2", + "name": "bitarray", + "sha256": "3f6386be9ff7fb89e591f79450643b277278bb507395ca6588c8888a719ee977", + "size": 151565, + "subdir": "linux-64", + "timestamp": 1641817300354, + "version": "2.3.5" + }, + "bitarray-2.3.5-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "c2bc7074a892bb2ed100cbdea7f520d0", + "name": "bitarray", + "sha256": "814871b08a4a2f4fdf03e7d5b2bda6d968784561a17da5416d0b013e18f6b81f", + "size": 151121, + "subdir": "linux-64", + "timestamp": 1641817297225, + "version": "2.3.5" + }, + "bitarray-2.3.5-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "1e09cc2f3747726dac1c6ddf70c1c3a1", + "name": "bitarray", + "sha256": "cd8f1f05a9ed347fbbb77ea4489d1126827eb6b4dd4e3ba708e3bad478b1611d", + "size": 150093, + "subdir": "linux-64", + "timestamp": 1641817297272, + "version": "2.3.5" + }, + "bitarray-2.4.1-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "e64b23ec7afc0caf16439debcb13a6fb", + "name": "bitarray", + "sha256": "8101dc3f3deb5597c9b53734ebba29da864138d475186853d650b1d145b2c026", + "size": 217022, + "subdir": "linux-64", + "timestamp": 1648721688428, + "version": "2.4.1" + }, + "bitarray-2.4.1-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "da4b169e4ec1cd4bfa80c3b181c9c6f3", + "name": "bitarray", + "sha256": "c41b12978974d930d0c3c29ac1b640309353cfa7fe3d18681f448d3c46d10211", + "size": 151926, + "subdir": "linux-64", + "timestamp": 1648739544627, + "version": "2.4.1" + }, + "bitarray-2.4.1-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "3d2509fa1a9ac82391c75b83ab288538", + "name": "bitarray", + "sha256": "9d1b4106b7c0ee145ed0e4fa80c9f15d8e628c3b670fd5bd029935b72439a975", + "size": 153075, + "subdir": "linux-64", + "timestamp": 1648739540078, + "version": "2.4.1" + }, + "bitarray-2.4.1-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "014a2bb8219ae19fc504f5debfe0971f", + "name": "bitarray", + "sha256": "590e59ba5e2650ba9fc5433ae5af708f96f1669cabe8bce5c9bf0588732ed589", + "size": 152217, + "subdir": "linux-64", + "timestamp": 1648739529000, + "version": "2.4.1" + }, + "bitarray-2.5.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "56ced09a6742461ae12835ecbb8cb06c", + "name": "bitarray", + "sha256": "5902b5ce13c624198819a5338644ea16913454e02ba250011f15164047f083ae", + "size": 223973, + "subdir": "linux-64", + "timestamp": 1652189573686, + "version": "2.5.0" + }, + "bitarray-2.5.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "0d0c5e084f55cc18b76990f2d62ffec3", + "name": "bitarray", + "sha256": "5dd1e1bca4b04e3a480001d63627d2d86645d0fca918b54c42e0577f60def9a5", + "size": 204798, + "subdir": "linux-64", + "timestamp": 1676839113633, + "version": "2.5.0" + }, + "bitarray-2.5.0-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "a0b83a48f2333c1e8831ea5c76284694", + "name": "bitarray", + "sha256": "18404b9f0d3b4fc48f2c1299e37ece73ff69881b67d8142a186c151ad0344f2d", + "size": 156776, + "subdir": "linux-64", + "timestamp": 1652189503604, + "version": "2.5.0" + }, + "bitarray-2.5.0-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "6302a7cbde0e35dad6d69670b3691051", + "name": "bitarray", + "sha256": "4baf72782522db03514b92466565bbde373a7eb0dea6a9c176bfab5c5d0faf4e", + "size": 156793, + "subdir": "linux-64", + "timestamp": 1652189602283, + "version": "2.5.0" + }, + "bitarray-2.5.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "f6fc3cf468e328ef0c8b03d797c1ac83", + "name": "bitarray", + "sha256": "a8ee963fc18ac0975fc1d82ed5a9e9cea664a4150fdf810400ed79cd9fbf0e01", + "size": 156754, + "subdir": "linux-64", + "timestamp": 1652189533560, + "version": "2.5.0" + }, + "bitarray-2.5.1-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "2fdd4f91ec3fb84158f39a7fe5c098c6", + "name": "bitarray", + "sha256": "14a9dfb07a7970bb323ca6bf36b1690168f123defeee895159e3a098888e73a0", + "size": 237835, + "subdir": "linux-64", + "timestamp": 1657739768652, + "version": "2.5.1" + }, + "bitarray-2.5.1-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "43b837782f0b2431f153be45c85885f6", + "name": "bitarray", + "sha256": "0fa96116963ebb3bf3f91681b21b52a1a750e5f654d31ed84f9ec4bb34ab81de", + "size": 205259, + "subdir": "linux-64", + "timestamp": 1679335431387, + "version": "2.5.1" + }, + "bitarray-2.5.1-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "8a907e2d7aa7e4f4a7b05e345584e77e", + "name": "bitarray", + "sha256": "c79b95a3b615189cd79a25827313853831440d55ce5d781fb96e2fb1d9ea8edd", + "size": 158445, + "subdir": "linux-64", + "timestamp": 1657739799825, + "version": "2.5.1" + }, + "bitarray-2.5.1-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "8458d3cdf1a4610458c6a40bbe2461c2", + "name": "bitarray", + "sha256": "75cba74b45f4dc1db3f1988d50814da6d6012d608380134c381b1cfdf9f4c996", + "size": 158506, + "subdir": "linux-64", + "timestamp": 1657739695140, + "version": "2.5.1" + }, + "bitarray-2.5.1-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "7a73685fc618881d5e38a382107ff674", + "name": "bitarray", + "sha256": "7f200839cdbc9c31af79f94dcc644d85ea2e1651abfee05565ddfc4ad9843737", + "size": 158454, + "subdir": "linux-64", + "timestamp": 1657739725939, + "version": "2.5.1" + }, + "bkcharts-0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=2.7,<2.8.0a0", + "six >=1.5.2" + ], + "license": "BSD 3-Clause", + "md5": "82cb0596fda569f2407bc93e69235f1d", + "name": "bkcharts", + "sha256": "5e71de0e15ecd6b261355e3eae33403897f6779b2e63eacc9fabd275113be3e7", + "size": 134580, + "subdir": "linux-64", + "timestamp": 1530770924680, + "version": "0.2" + }, + "bkcharts-0.2-py27h241ae91_0.conda": { + "build": "py27h241ae91_0", + "build_number": 0, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=2.7,<2.8.0a0", + "six >=1.5.2" + ], + "license": "BSD 3-Clause", + "md5": "f9c0eb30741ba76457646582838826a6", + "name": "bkcharts", + "sha256": "3dee3e54a92fb33b64c6467a6f7b4bf280a945dfe131695a21097f6626086de2", + "size": 132363, + "subdir": "linux-64", + "timestamp": 1505728747105, + "version": "0.2" + }, + "bkcharts-0.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.10,<3.11.0a0", + "six >=1.5.2" + ], + "license": "BSD 3-Clause", + "md5": "130c9f7a73301910ebd267772107ffc7", + "name": "bkcharts", + "sha256": "6e4430c76572437ddb00da7e917c6d11189379e3e73d3ecbf4b6767288eee688", + "size": 135849, + "subdir": "linux-64", + "timestamp": 1640788516837, + "version": "0.2" + }, + "bkcharts-0.2-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.10,<3.11.0a0", + "six >=1.5.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "26d838f7b3e04eaf1783f351a6653b52", + "name": "bkcharts", + "sha256": "f230bda547f0cc21ba7816bcbab1c0315e1550d9cc80f3115cfe280937de78da", + "size": 135967, + "subdir": "linux-64", + "timestamp": 1657175960644, + "version": "0.2" + }, + "bkcharts-0.2-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.11,<3.12.0a0", + "six >=1.5.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee7979d62871bb403437e8f7b2d3f2d0", + "name": "bkcharts", + "sha256": "bfc9302ecfbfe4637e3c3835034743f6d85059fbbe3dfe759e6484098d925590", + "size": 183200, + "subdir": "linux-64", + "timestamp": 1676847028305, + "version": "0.2" + }, + "bkcharts-0.2-py35he4f7e30_0.conda": { + "build": "py35he4f7e30_0", + "build_number": 0, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.5,<3.6.0a0", + "six >=1.5.2" + ], + "license": "BSD 3-Clause", + "md5": "f30ad224e1b75f12dfa8cb5ed5b8d1a6", + "name": "bkcharts", + "sha256": "772816299002a033983fdee1beef8ac6e72534c007ff9408014197f6271c47f9", + "size": 137679, + "subdir": "linux-64", + "timestamp": 1505728757269, + "version": "0.2" + }, + "bkcharts-0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.6,<3.7.0a0", + "six >=1.5.2" + ], + "license": "BSD 3-Clause", + "md5": "054caab0dd76235d492926f1740e3ece", + "name": "bkcharts", + "sha256": "f71e0b24ba598f903cb0213e97543abb8b3c415e244d6df1fc45de7f49b2d04f", + "size": 136364, + "subdir": "linux-64", + "timestamp": 1530770943834, + "version": "0.2" + }, + "bkcharts-0.2-py36h735825a_0.conda": { + "build": "py36h735825a_0", + "build_number": 0, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.6,<3.7.0a0", + "six >=1.5.2" + ], + "license": "BSD 3-Clause", + "md5": "0f6f737d7e0125f9b65044a96cbfa8bf", + "name": "bkcharts", + "sha256": "d7dd83c583b96bb9f01fb05fe27178e1c3b6292527894baa88fad7eb4b5bc446", + "size": 136156, + "subdir": "linux-64", + "timestamp": 1505728767491, + "version": "0.2" + }, + "bkcharts-0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.7,<3.8.0a0", + "six >=1.5.2" + ], + "license": "BSD 3-Clause", + "md5": "84e6c5c4af0917e37201280f0f593762", + "name": "bkcharts", + "sha256": "58928d7c838edc9b0b84330be4c8c3ab7f9d6d889425358085924dbf8c0acfb3", + "size": 136471, + "subdir": "linux-64", + "timestamp": 1530770907422, + "version": "0.2" + }, + "bkcharts-0.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.7,<3.8.0a0", + "six >=1.5.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "544318cff29c3a1d6de3685509f3a0f7", + "name": "bkcharts", + "sha256": "93a13db32278098b7db112c57194c4244d1df18c4ea6ab5eae8d0aeee5434841", + "size": 134544, + "subdir": "linux-64", + "timestamp": 1657175881002, + "version": "0.2" + }, + "bkcharts-0.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.8,<3.9.0a0", + "six >=1.5.2" + ], + "license": "BSD 3-Clause", + "md5": "925e6929a5ee85b13d2fa3e93a1b1f62", + "name": "bkcharts", + "sha256": "5f3b7133b114f9febc06b347efee69e77cf69a931301c27184c573a8fe74f982", + "size": 137582, + "subdir": "linux-64", + "timestamp": 1580239165886, + "version": "0.2" + }, + "bkcharts-0.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.8,<3.9.0a0", + "six >=1.5.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "21e6e45822bd064e4f62c7f219068b5b", + "name": "bkcharts", + "sha256": "d893a3cc1c6f4c3925860bc25359f802f166bf2d48f1910c46dfb0407d86f97e", + "size": 134914, + "subdir": "linux-64", + "timestamp": 1657175841883, + "version": "0.2" + }, + "bkcharts-0.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.9,<3.10.0a0", + "six >=1.5.2" + ], + "license": "BSD 3-Clause", + "md5": "c34defeeed9bdccbcaff9b19fe200ed1", + "name": "bkcharts", + "sha256": "63dd0df9403ff834b40a8ff25ccf329fd9a50c3b25eaeefd0c5beea816f549a6", + "size": 135462, + "subdir": "linux-64", + "timestamp": 1607709584650, + "version": "0.2" + }, + "bkcharts-0.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "numpy >=1.7.1", + "pandas", + "python >=3.9,<3.10.0a0", + "six >=1.5.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "832cfb722104ae2949bf560f55917789", + "name": "bkcharts", + "sha256": "a4f90d18efc06d49cfad27061ab820a385f44ab00d7bffa14ff1b23639042edc", + "size": 134732, + "subdir": "linux-64", + "timestamp": 1657175915809, + "version": "0.2" + }, + "black-22.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "uvloop >=0.15.2", + "colorama >=0.4.3", + "aiohttp >=3.7.4" + ], + "depends": [ + "click >=8.0.0", + "mypy_extensions >=0.4.3", + "pathspec >=0.9.0", + "platformdirs >=2", + "python >=3.10,<3.11.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db743622c5c1ad2ea81f9876ad8bce44", + "name": "black", + "sha256": "a56e66b98d3cd37ce1436c6a18cb506d82ffa1ed0da9b2f4d12d6ba00c2592b2", + "size": 230175, + "subdir": "linux-64", + "timestamp": 1660237926739, + "version": "22.6.0" + }, + "black-22.6.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "uvloop >=0.15.2", + "aiohttp >=3.7.4", + "colorama >=0.4.3" + ], + "depends": [ + "click >=8.0.0", + "mypy_extensions >=0.4.3", + "pathspec >=0.9.0", + "platformdirs >=2", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "89088d86d1200a653ce43a30fe4c74c6", + "name": "black", + "sha256": "36b4f2699e7db66588b8252bc913acddfc5ec8f6cf3f4cb1ca7f2dcf0d134926", + "size": 311760, + "subdir": "linux-64", + "timestamp": 1676839128413, + "version": "22.6.0" + }, + "black-22.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "uvloop >=0.15.2", + "colorama >=0.4.3", + "aiohttp >=3.7.4" + ], + "depends": [ + "click >=8.0.0", + "mypy_extensions >=0.4.3", + "pathspec >=0.9.0", + "platformdirs >=2", + "python >=3.7,<3.8.0a0", + "tomli >=1.1.0", + "typed-ast >=1.4.2", + "typing_extensions >=3.10.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a841371d83dcba87937534f756f4d2bf", + "name": "black", + "sha256": "41674a4321befbf5d65102c02c25df65cc54016e7635e20e11dc81311d06e283", + "size": 229600, + "subdir": "linux-64", + "timestamp": 1660237881530, + "version": "22.6.0" + }, + "black-22.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "uvloop >=0.15.2", + "colorama >=0.4.3", + "aiohttp >=3.7.4" + ], + "depends": [ + "click >=8.0.0", + "mypy_extensions >=0.4.3", + "pathspec >=0.9.0", + "platformdirs >=2", + "python >=3.8,<3.9.0a0", + "tomli >=1.1.0", + "typing_extensions >=3.10.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cf554debe36a0aab2e00db7e0e608f1d", + "name": "black", + "sha256": "78cc9c99615a2aca182f10cde6d2b4d5e78dd5e8b62c41a0659abdf58cadc26b", + "size": 228724, + "subdir": "linux-64", + "timestamp": 1660237849477, + "version": "22.6.0" + }, + "black-22.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "uvloop >=0.15.2", + "colorama >=0.4.3", + "aiohttp >=3.7.4" + ], + "depends": [ + "click >=8.0.0", + "mypy_extensions >=0.4.3", + "pathspec >=0.9.0", + "platformdirs >=2", + "python >=3.9,<3.10.0a0", + "tomli >=1.1.0", + "typing_extensions >=3.10.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "329ea903e0a9839c8ea0ddbb25c77164", + "name": "black", + "sha256": "7eb9d3970b3852ec22efa84ddbeb12ca5cf9441908018c4c482f56d6d33fd172", + "size": 228725, + "subdir": "linux-64", + "timestamp": 1660237961998, + "version": "22.6.0" + }, + "black-23.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "aiohttp >=3.7.4", + "colorama >=0.4.3", + "uvloop >=0.15.2" + ], + "depends": [ + "click >=8.0.0", + "mypy_extensions >=0.4.3", + "packaging >=22.0", + "pathspec >=0.9.0", + "platformdirs >=2", + "python >=3.10,<3.11.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e8629c4e95119b0debfc09889430a4a", + "name": "black", + "sha256": "1d6e458e21f3ed89f65c8a3eae724439cefbfe37f2fe15ad8513f13cce7345cc", + "size": 265658, + "subdir": "linux-64", + "timestamp": 1680737285835, + "version": "23.3.0" + }, + "black-23.3.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "aiohttp >=3.7.4", + "colorama >=0.4.3", + "uvloop >=0.15.2" + ], + "depends": [ + "click >=8.0.0", + "mypy_extensions >=0.4.3", + "packaging >=22.0", + "pathspec >=0.9.0", + "platformdirs >=2", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e055ecc243693c97d06ecce51aad497", + "name": "black", + "sha256": "612f583433659f9fcbb1a721be0aef8be661e2cf76268911ebfdf7959f039be0", + "size": 353736, + "subdir": "linux-64", + "timestamp": 1680737314559, + "version": "23.3.0" + }, + "black-23.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "aiohttp >=3.7.4", + "colorama >=0.4.3", + "uvloop >=0.15.2" + ], + "depends": [ + "click >=8.0.0", + "mypy_extensions >=0.4.3", + "packaging >=22.0", + "pathspec >=0.9.0", + "platformdirs >=2", + "python >=3.8,<3.9.0a0", + "tomli >=1.1.0", + "typing_extensions >=3.10.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d9502786483917f385310a374e1281f", + "name": "black", + "sha256": "99a00b14efd911a2ddf908182df737c9d10c80d91847e437b152409676d4e72d", + "size": 265033, + "subdir": "linux-64", + "timestamp": 1680737370804, + "version": "23.3.0" + }, + "black-23.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "aiohttp >=3.7.4", + "colorama >=0.4.3", + "uvloop >=0.15.2" + ], + "depends": [ + "click >=8.0.0", + "mypy_extensions >=0.4.3", + "packaging >=22.0", + "pathspec >=0.9.0", + "platformdirs >=2", + "python >=3.9,<3.10.0a0", + "tomli >=1.1.0", + "typing_extensions >=3.10.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e6fbe0d44abe5c623e20ff218392fae", + "name": "black", + "sha256": "978ef6ee4e8261f55238caf38df7d2e7913bfab7c22eec66c206097a21defd47", + "size": 264021, + "subdir": "linux-64", + "timestamp": 1680737342173, + "version": "23.3.0" + }, + "blas-1.0-mkl.conda": { + "build": "mkl", + "build_number": 1, + "depends": [], + "md5": "9a7a051e9bd41da46523acb017d8a517", + "name": "blas", + "sha256": "05f806e9b610f80e15f2c8d7b4e9a7a2817ed4870b85427acb2a89a1db44ec0e", + "size": 6031, + "subdir": "linux-64", + "timestamp": 1528122042945, + "version": "1.0" + }, + "blas-1.0-openblas.conda": { + "build": "openblas", + "build_number": 7, + "depends": [], + "md5": "9ddfcaef10d79366c90128f5dc444be8", + "name": "blas", + "sha256": "c85b5d0a336b5be0f415c71fd7fe2eca59e09f42221bfa684aafef5510ba5487", + "size": 46671, + "subdir": "linux-64", + "timestamp": 1528224118045, + "track_features": "nomkl", + "version": "1.0" + }, + "blaze-0.11.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "cytoolz", + "dask", + "datashape >=0.5.3", + "flask >=0.10.1", + "flask-cors", + "h5py", + "numba", + "odo >=0.5.0", + "psutil", + "pytables >=3.0.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "requests", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0340615d17a58d590819ec4a978fb075", + "name": "blaze", + "sha256": "633d7c13cb02adc1e55189df34d3eff674e14f5b18c713e10e82452a4bcec4d8", + "size": 621571, + "subdir": "linux-64", + "timestamp": 1530780942896, + "version": "0.11.3" + }, + "blaze-0.11.3-py27h5f341da_0.conda": { + "build": "py27h5f341da_0", + "build_number": 0, + "depends": [ + "contextlib2", + "cytoolz", + "dask", + "datashape >=0.5.3", + "flask >=0.10.1", + "flask-cors", + "h5py", + "numba", + "odo >=0.5.0", + "psutil", + "pytables >=3.0.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "requests", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ee770dde13fdfe841e90eb5174431783", + "name": "blaze", + "sha256": "146af248d654cc85cc76d178194d5b55010c7a3d8e38c95572b695deb7565075", + "size": 622455, + "subdir": "linux-64", + "timestamp": 1505740501448, + "version": "0.11.3" + }, + "blaze-0.11.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cytoolz", + "dask", + "datashape >=0.5.3", + "flask >=0.10.1", + "flask-cors", + "h5py", + "numba", + "odo >=0.5.0", + "psutil", + "pytables >=3.0.0", + "python >=3.5,<3.6.0a0", + "pyyaml", + "requests", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "67aa99e5e6d2d1ded14bc302bfe95393", + "name": "blaze", + "sha256": "54a65d210babe31491c1e4f29a4304699908ac75f8daa7aa5ae6b10a820f5731", + "size": 625493, + "subdir": "linux-64", + "timestamp": 1534899847824, + "version": "0.11.3" + }, + "blaze-0.11.3-py35ha2c9137_0.conda": { + "build": "py35ha2c9137_0", + "build_number": 0, + "depends": [ + "cytoolz", + "dask", + "datashape >=0.5.3", + "flask >=0.10.1", + "flask-cors", + "h5py", + "numba", + "odo >=0.5.0", + "psutil", + "pytables >=3.0.0", + "python >=3.5,<3.6.0a0", + "pyyaml", + "requests", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "78aa461160abb147ca11260abff2f93b", + "name": "blaze", + "sha256": "5c00ef61a631a78d9250362e855d7d6e1cf805a1790966575199418d384a8046", + "size": 625906, + "subdir": "linux-64", + "timestamp": 1505740543559, + "version": "0.11.3" + }, + "blaze-0.11.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cytoolz", + "dask", + "datashape >=0.5.3", + "flask >=0.10.1", + "flask-cors", + "h5py", + "numba", + "odo >=0.5.0", + "psutil", + "pytables >=3.0.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "requests", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e2143147bbf4628551acc2da45de4389", + "name": "blaze", + "sha256": "736376b1471c87a6aed713fea2a3a4a1df4f98e984912f9a3f364243597f603a", + "size": 624157, + "subdir": "linux-64", + "timestamp": 1530781003590, + "version": "0.11.3" + }, + "blaze-0.11.3-py36h4e06776_0.conda": { + "build": "py36h4e06776_0", + "build_number": 0, + "depends": [ + "cytoolz", + "dask", + "datashape >=0.5.3", + "flask >=0.10.1", + "flask-cors", + "h5py", + "numba", + "odo >=0.5.0", + "psutil", + "pytables >=3.0.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "requests", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cb593d6fc441abbd3bfd8c6c3353789d", + "name": "blaze", + "sha256": "ff6e7ad6d6ee0645e52227fa47cd24877fe7d0fb4da7b34cb90e49a7ef349e9d", + "size": 624792, + "subdir": "linux-64", + "timestamp": 1505740585432, + "version": "0.11.3" + }, + "blaze-0.11.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cytoolz", + "dask", + "datashape >=0.5.3", + "flask >=0.10.1", + "flask-cors", + "h5py", + "numba", + "odo >=0.5.0", + "psutil", + "pytables >=3.0.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "requests", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5efc4c1da1376a30826b07df5fbff261", + "name": "blaze", + "sha256": "37fe0debe063fa052fc8e923dd9e1587516d9e6ff27a19ba7be7e1a648e99c18", + "size": 618935, + "subdir": "linux-64", + "timestamp": 1530781054271, + "version": "0.11.3" + }, + "bleach-2.0.0-py27h3a0dcc8_0.conda": { + "build": "py27h3a0dcc8_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "df3315470575c00b119315b4eb1d21d2", + "name": "bleach", + "sha256": "07948dc953bcc79430d095ed313ba03e9eb19044adf8ef1bc3b00d0e11445156", + "size": 26681, + "subdir": "linux-64", + "timestamp": 1505688758599, + "version": "2.0.0" + }, + "bleach-2.0.0-py35h055c768_0.conda": { + "build": "py35h055c768_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "13ee90babe302f499e628a8bd067b050", + "name": "bleach", + "sha256": "4ac29d8c861245229581271dc043dff67e2fd51be273c0ed316f20bafcae86fd", + "size": 27175, + "subdir": "linux-64", + "timestamp": 1505688771064, + "version": "2.0.0" + }, + "bleach-2.0.0-py36h688b259_0.conda": { + "build": "py36h688b259_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4ff454ae8c983a2a55fef141cebe36c5", + "name": "bleach", + "sha256": "ecb0029d1ecd6a15e7ac0ae02864acc94b0ea67cbb6228ad510dc4f8f8b21600", + "size": 27012, + "subdir": "linux-64", + "timestamp": 1505688783589, + "version": "2.0.0" + }, + "bleach-2.1.1-py27h655ea9b_0.conda": { + "build": "py27h655ea9b_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8a584c86eadb2d5206be32dc4f1079c4", + "name": "bleach", + "sha256": "9fd7406c03e8f9b1685be49baf1c86c373ef60bb4463df6003859ea5d8e04a3b", + "size": 31940, + "subdir": "linux-64", + "timestamp": 1512064528809, + "version": "2.1.1" + }, + "bleach-2.1.1-py35hd5e75dd_0.conda": { + "build": "py35hd5e75dd_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9b3d72d03b56ea90953f2a843ea4e2b1", + "name": "bleach", + "sha256": "53fca8ff4e16758aaf3c7f789436a4414b3c1b1fe8a0971eb9d2399e19dadb81", + "size": 32375, + "subdir": "linux-64", + "timestamp": 1512064565029, + "version": "2.1.1" + }, + "bleach-2.1.1-py36hd521086_0.conda": { + "build": "py36hd521086_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3d2a690086a953301377ddfed9bf914c", + "name": "bleach", + "sha256": "7342a9788c84ff7e077cbadfe96b6ac394792ba176bdbd9c176da3539a02dad2", + "size": 31941, + "subdir": "linux-64", + "timestamp": 1512064564671, + "version": "2.1.1" + }, + "bleach-2.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "25845366f7190c3316922e31df33d9e7", + "name": "bleach", + "sha256": "16b53eb63edef056ff8379e7016d1f93042de2296b1148efcf141df3e3908329", + "size": 32427, + "subdir": "linux-64", + "timestamp": 1515702634158, + "version": "2.1.2" + }, + "bleach-2.1.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "855ead6a35f8b23998949150f4e0c27b", + "name": "bleach", + "sha256": "75467e0c3e2398861ab2ada359089203a28881543bd5c79f5e50732898c5a1c3", + "size": 32496, + "subdir": "linux-64", + "timestamp": 1515702673828, + "version": "2.1.2" + }, + "bleach-2.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1c67dfde3496e49eef1037779bdbb3ef", + "name": "bleach", + "sha256": "04ed23cfbb324006bfc1ad7c8124ec86e605927817e39814574bbb444beab795", + "size": 32511, + "subdir": "linux-64", + "timestamp": 1515702495118, + "version": "2.1.2" + }, + "bleach-2.1.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "59266117880c9216839b394ae49720c7", + "name": "bleach", + "sha256": "6add2f7f564cb5dd6ad3a0b2056730bf77980c5fe29709ce3c1ff28f433a31eb", + "size": 33652, + "subdir": "linux-64", + "timestamp": 1520367410667, + "version": "2.1.3" + }, + "bleach-2.1.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4a3ca55af174706264618d5ad0d8471b", + "name": "bleach", + "sha256": "f8561935d2989d803cdeec3baa16c4e8a729efe7f6eb60f5a8e0e5359d64338c", + "size": 33727, + "subdir": "linux-64", + "timestamp": 1520367417266, + "version": "2.1.3" + }, + "bleach-2.1.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "94a7254c4a9170aba14290c08e7375a1", + "name": "bleach", + "sha256": "6d31a028d00833f06e661c92dcf3872b48e09b0034daed660cf9b998751c8bc0", + "size": 33474, + "subdir": "linux-64", + "timestamp": 1520367429044, + "version": "2.1.3" + }, + "bleach-2.1.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eff578606c75cc836ffe526f4b5dcd0a", + "name": "bleach", + "sha256": "c0d164f58664351655e382823ab5690b8e1073c50e8e3476dd114f8bc72d1de9", + "size": 33428, + "subdir": "linux-64", + "timestamp": 1530734219576, + "version": "2.1.3" + }, + "bleach-2.1.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999pre,!=1.0b1,!=1.0b2,!=1.0b3,!=1.0b4,!=1.0b5,!=1.0b6,!=1.0b7,!=1.0b8", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "35b8e4c2266477124bcddfc8fb41cdd9", + "name": "bleach", + "sha256": "93abbc8b86c447a6281fc3138671584d70791fe6d04dab6d24b4f286b30ee648", + "size": 34306, + "subdir": "linux-64", + "timestamp": 1534944575286, + "version": "2.1.4" + }, + "bleach-2.1.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999pre,!=1.0b1,!=1.0b2,!=1.0b3,!=1.0b4,!=1.0b5,!=1.0b6,!=1.0b7,!=1.0b8", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a8eb945a2a60bf9351467b560236c2ef", + "name": "bleach", + "sha256": "c744b22ee0b336c4d93df3e47d3b0d875a2c79d051cd7ff9059db37b36fc8176", + "size": 34457, + "subdir": "linux-64", + "timestamp": 1534944645634, + "version": "2.1.4" + }, + "bleach-2.1.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999pre,!=1.0b1,!=1.0b2,!=1.0b3,!=1.0b4,!=1.0b5,!=1.0b6,!=1.0b7,!=1.0b8", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d6c5d7a676be8291f8c4c1c9c0b789fc", + "name": "bleach", + "sha256": "13057428fb5895a06078bf9eae537a17f743e6a854d5334e138a636fabd54112", + "size": 34200, + "subdir": "linux-64", + "timestamp": 1534944493180, + "version": "2.1.4" + }, + "bleach-2.1.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "html5lib >=0.99999999pre,!=1.0b1,!=1.0b2,!=1.0b3,!=1.0b4,!=1.0b5,!=1.0b6,!=1.0b7,!=1.0b8", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fa974dd3ffd82662aa918acfcedeadd8", + "name": "bleach", + "sha256": "e1e917aa79a619debb8c4e24486c54c6d99e4d560cb47bc23328270f25bc1cc0", + "size": 34127, + "subdir": "linux-64", + "timestamp": 1534944606658, + "version": "2.1.4" + }, + "bleach-3.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "webencodings" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c1bb9662a49c450aea9862ca9bf4b34c", + "name": "bleach", + "sha256": "cfb9a329e354ecb75473bc8722f64bc355b19bbe33d4f419ee6e7186e1abe6fb", + "size": 227924, + "subdir": "linux-64", + "timestamp": 1539024426445, + "version": "3.0.0" + }, + "bleach-3.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "webencodings" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "44b84ebaa428cb6e49e42a42731fd2f9", + "name": "bleach", + "sha256": "4fb6559420eac6781b25b4657a4fab3ea25eb2b56dcfa5af2c8c215bac8cbe68", + "size": 222939, + "subdir": "linux-64", + "timestamp": 1539024442724, + "version": "3.0.0" + }, + "bleach-3.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "webencodings" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a9f8eac3e8f27f763778158cbd46e72d", + "name": "bleach", + "sha256": "4fd7bd2b2473ca9a2b7bbbbc82d6cd01029e7093549de50e8918bcabda6dea75", + "size": 221362, + "subdir": "linux-64", + "timestamp": 1539024401251, + "version": "3.0.0" + }, + "bleach-3.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "webencodings" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e21cea0e3279f63befade5a04237e6f8", + "name": "bleach", + "sha256": "f8db5ee70aee6ee52de99635c9a8d613df295cf0cee912d1bcdb1a9be92b173e", + "size": 228318, + "subdir": "linux-64", + "timestamp": 1539468266778, + "version": "3.0.2" + }, + "bleach-3.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "webencodings" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3e61516b7b7484e78c62c197aa440cc7", + "name": "bleach", + "sha256": "c0e066c1f5062e0b4c34aa4b4a5c6793f1c9ba5ca2071750a3301727e3eac2f2", + "size": 220491, + "subdir": "linux-64", + "timestamp": 1539468301368, + "version": "3.0.2" + }, + "bleach-3.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "webencodings" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2da0e545a133bad9294957bf5a37b4f5", + "name": "bleach", + "sha256": "aa1c149a00500dc980637432bc0b2be3e100d221df04f891016762958fb4d3b0", + "size": 219263, + "subdir": "linux-64", + "timestamp": 1539468289948, + "version": "3.0.2" + }, + "bleach-3.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "webencodings" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6d976ec50c7d2b373186aa71afd7b76d", + "name": "bleach", + "sha256": "12d96f7cff0aed3a78d95fc7ceabc5c5157853273a50ea2671de9e8f439e9af1", + "size": 230149, + "subdir": "linux-64", + "timestamp": 1547747374249, + "version": "3.1.0" + }, + "bleach-3.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "webencodings" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "08a0352bea4f083bb390b7c2ff33448a", + "name": "bleach", + "sha256": "6409f5921e800625213b084725ec041ae54d4b3ef6da8c7c466137bf4def01b3", + "size": 226308, + "subdir": "linux-64", + "timestamp": 1547747468102, + "version": "3.1.0" + }, + "bleach-3.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "webencodings" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "700527178f3790c80abfff645eb3160c", + "name": "bleach", + "sha256": "07a9aa3daaf433439f86376326fddd4e1525dac81054abca6ed957839d07283f", + "size": 225740, + "subdir": "linux-64", + "timestamp": 1547747439520, + "version": "3.1.0" + }, + "blessings-1.7-py310h06a4308_1002.conda": { + "build": "py310h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d4691028300fa9c32dbfd467f5adce47", + "name": "blessings", + "sha256": "e5a170b99cb4973c3474c74f78a786f38dd64639c68cd5e9979db254fef6e66a", + "size": 28615, + "subdir": "linux-64", + "timestamp": 1640788534345, + "version": "1.7" + }, + "blessings-1.7-py311h06a4308_1002.conda": { + "build": "py311h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7af6ee106cd691a524f4ff00e153f0e2", + "name": "blessings", + "sha256": "d157eb8671a9cd06ce98140c18c7b7a78b4ac5052bf0dc722735f25fc2333c34", + "size": 33073, + "subdir": "linux-64", + "timestamp": 1676839144008, + "version": "1.7" + }, + "blessings-1.7-py36_1002.conda": { + "build": "py36_1002", + "build_number": 1002, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b39dd9bc1eaf886941954beca94a56f2", + "name": "blessings", + "sha256": "5d418825f9be59c13ec82ba44f68242f1f2e267c511c2f29ceebc28fe9d74bee", + "size": 30683, + "subdir": "linux-64", + "timestamp": 1598661766747, + "version": "1.7" + }, + "blessings-1.7-py36h06a4308_1002.conda": { + "build": "py36h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "463f0c0620dc3f560e07cef16a2c8420", + "name": "blessings", + "sha256": "6d00f101b780034e64b7bb2812eaa230515996dd9788adcdfd064ecaa835b5d8", + "size": 30679, + "subdir": "linux-64", + "timestamp": 1614076480860, + "version": "1.7" + }, + "blessings-1.7-py37_1002.conda": { + "build": "py37_1002", + "build_number": 1002, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b17a63f9b0174a748420fdf13f64194", + "name": "blessings", + "sha256": "57aeb807f1df09218ce2efbae098e1e251cb8ea068f160486fd6e78b5b98dc96", + "size": 30462, + "subdir": "linux-64", + "timestamp": 1598661743793, + "version": "1.7" + }, + "blessings-1.7-py37h06a4308_1002.conda": { + "build": "py37h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64a56e13e202780c715419e6ec7af6d7", + "name": "blessings", + "sha256": "26ced9fca5ec2b96a666f6bb683a195d196a834360a00969d35039b20cec0314", + "size": 30409, + "subdir": "linux-64", + "timestamp": 1614076478572, + "version": "1.7" + }, + "blessings-1.7-py38_1002.conda": { + "build": "py38_1002", + "build_number": 1002, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16caf7d65cfac32b18653569543878d1", + "name": "blessings", + "sha256": "78eaabb4078116fb27b193649e3559255e3e685206a709af2a714ce94adcf37c", + "size": 30822, + "subdir": "linux-64", + "timestamp": 1598661799634, + "version": "1.7" + }, + "blessings-1.7-py38h06a4308_1002.conda": { + "build": "py38h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "30c13fe9fa9ae34ded416cc52ef13cda", + "name": "blessings", + "sha256": "f6202299405a507cba702280d9055e406be41ad4b2ed5c046b8c1f707df76f19", + "size": 30646, + "subdir": "linux-64", + "timestamp": 1614076475848, + "version": "1.7" + }, + "blessings-1.7-py39h06a4308_1002.conda": { + "build": "py39h06a4308_1002", + "build_number": 1002, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "506d6d4b9ebeeb0e14dfe3aff1273218", + "name": "blessings", + "sha256": "c0ec269871f707c13c7390d888265f8cdd655eeb2c6b97ee9611c1e26ce3de3f", + "size": 30903, + "subdir": "linux-64", + "timestamp": 1614075542803, + "version": "1.7" + }, + "blinker-1.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f576c624f4fc5abb8389365ccacdeac3", + "name": "blinker", + "sha256": "5a9009aa61747dafcb7db783c16d76c37eb9f20bc5e33492c9b3482a85b2e438", + "size": 21614, + "subdir": "linux-64", + "timestamp": 1525813093679, + "version": "1.4" + }, + "blinker-1.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "3abc8d6455c693e19b542d49a546b84d", + "name": "blinker", + "sha256": "872d48290b0f0cc7933a85363a98c9c74d7ed93583db97e7dd35939c6ad6f911", + "size": 21852, + "subdir": "linux-64", + "timestamp": 1640788551724, + "version": "1.4" + }, + "blinker-1.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "59c69876948efd3c137619091d67caf5", + "name": "blinker", + "sha256": "481fb4c9805b0f0261c82704aa8f4a05dc365d589964ebad62dabfef1b408723", + "size": 26467, + "subdir": "linux-64", + "timestamp": 1676830022360, + "version": "1.4" + }, + "blinker-1.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "40723e58c312a2cc00ebc3762ce8c1b4", + "name": "blinker", + "sha256": "846ff5f45984b671c289c99c027e1a4fdf69d1d46d494eccbf4db54e11fe1705", + "size": 22045, + "subdir": "linux-64", + "timestamp": 1525813132877, + "version": "1.4" + }, + "blinker-1.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "67d7eda8adc6bf62fb48e672d270bd1f", + "name": "blinker", + "sha256": "f66ddbd17e6798db7b778e7d96dab806dd15a124bbc6d2fd429ec06daecfcb84", + "size": 22067, + "subdir": "linux-64", + "timestamp": 1525813135425, + "version": "1.4" + }, + "blinker-1.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d00cb0c31312588da65cef45ce094eab", + "name": "blinker", + "sha256": "5f2cb4e4e2c59badbaad5222a6e863ff48b8b3164b158e576466857a6c424a39", + "size": 22992, + "subdir": "linux-64", + "timestamp": 1611676518660, + "version": "1.4" + }, + "blinker-1.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2efb99772b8bcd253398eaede90fe3b1", + "name": "blinker", + "sha256": "eef9698d5411faf1bd1489e66c195e0cedbdf584937fc8d7446ed31f689f93a3", + "size": 22018, + "subdir": "linux-64", + "timestamp": 1545089085448, + "version": "1.4" + }, + "blinker-1.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5c6025ad1ce540a52edc63ae25f8cf58", + "name": "blinker", + "sha256": "edf5580c23311a314a6e8765e113f5783c03b651124a46dbb8dc5f06436f7c3c", + "size": 23237, + "subdir": "linux-64", + "timestamp": 1611676540031, + "version": "1.4" + }, + "blinker-1.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "90a66878d88be21789b74fb87d3e107f", + "name": "blinker", + "sha256": "235f0ad860655c17ca08be5f8b0abb8cfdfa5606f2a8289c51c5c349d2facec4", + "size": 22111, + "subdir": "linux-64", + "timestamp": 1572609087727, + "version": "1.4" + }, + "blinker-1.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "04034846d0ff608c23f978d3ec6671bd", + "name": "blinker", + "sha256": "c92df079eb6588a01f4eaa16cfe2e78710997f398dab079f917ef50f5fd7003c", + "size": 23098, + "subdir": "linux-64", + "timestamp": 1611676524575, + "version": "1.4" + }, + "blinker-1.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "53b9823dc19ee4e99dfd9e87afdba29e", + "name": "blinker", + "sha256": "ac444f5e591558e98899a9658653a33849467424784010409bead6c469196d09", + "size": 23336, + "subdir": "linux-64", + "timestamp": 1611676456194, + "version": "1.4" + }, + "blist-1.3.6-py27h7b6447c_1.conda": { + "build": "py27h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5cf487ca34fc7b4deeae53c9af6aae76", + "name": "blist", + "sha256": "b0a855b8bfb646714f721237375e2fcff0af607b921af0e97c7dc1ae630293c0", + "size": 61624, + "subdir": "linux-64", + "timestamp": 1537205236613, + "version": "1.3.6" + }, + "blist-1.3.6-py35h7b6447c_1.conda": { + "build": "py35h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b8981f77d0cf97b130ff764a1d1c6544", + "name": "blist", + "sha256": "a5395384278cf30aa74a55ae895d7ab21b26b16d2586fcf8a3f20a8686fc0281", + "size": 60650, + "subdir": "linux-64", + "timestamp": 1537205253760, + "version": "1.3.6" + }, + "blist-1.3.6-py36h27cfd23_2.conda": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "430eaa1acd1d1894d115985961e47cb9", + "name": "blist", + "sha256": "c343b723bb0deed2377fffe5291a24824b5f841e776a33f9f087cac1951fa5db", + "size": 148987, + "subdir": "linux-64", + "timestamp": 1613399583575, + "version": "1.3.6" + }, + "blist-1.3.6-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9c047231ddc457fd08b64242b595319f", + "name": "blist", + "sha256": "4e61778d4230cacd2f5b70d3d4eab65b1b786a0c599e9f7a368e71654ad1bf1b", + "size": 60088, + "subdir": "linux-64", + "timestamp": 1537205271004, + "version": "1.3.6" + }, + "blist-1.3.6-py37h27cfd23_2.conda": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cafe9c47bd00c6937dbf19fba1bf70f2", + "name": "blist", + "sha256": "65975d092fd786307154c7a605d9b4696616ff91ace7a70e51cc1becd609b4e9", + "size": 147655, + "subdir": "linux-64", + "timestamp": 1613398923726, + "version": "1.3.6" + }, + "blist-1.3.6-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a2d649294ed72856dee981a4b197b823", + "name": "blist", + "sha256": "06795606c0e7f6e8f12de81cf7a60f0a642febf00add619032e0815417a36385", + "size": 60919, + "subdir": "linux-64", + "timestamp": 1537205210130, + "version": "1.3.6" + }, + "blist-1.3.6-py38h27cfd23_2.conda": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "548a262b9c2fa3fdc6a132f91add5317", + "name": "blist", + "sha256": "7af6f410a5c1137d5a6db6b7d05f6d7183dd5ffd98f8e6675d4663acece87a1e", + "size": 148525, + "subdir": "linux-64", + "timestamp": 1613399594675, + "version": "1.3.6" + }, + "blist-1.3.6-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "50caf93473dde3366552fe6bd9eecd08", + "name": "blist", + "sha256": "a09cc07a5e9b816bdf61d572452c58e69493d90962ee93ed272ffb06506894fd", + "size": 68120, + "subdir": "linux-64", + "timestamp": 1572357260435, + "version": "1.3.6" + }, + "blist-1.3.6-py39h27cfd23_2.conda": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "be2e2dc216b11b0684b1a7dd0ca0ad6d", + "name": "blist", + "sha256": "fc3d358d6f33837100bf06244cd715d04571679f4ca862b674d050569775a3b8", + "size": 148520, + "subdir": "linux-64", + "timestamp": 1613399584437, + "version": "1.3.6" + }, + "blosc-1.12.0-ha156899_0.conda": { + "build": "ha156899_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "834c86cfb5d7323b2ae1b8aaa452ed06", + "name": "blosc", + "sha256": "3d8a5dd338de907d524181271166ee46703d4894434d512372b0756de5be903b", + "size": 222338, + "subdir": "linux-64", + "timestamp": 1511806287973, + "version": "1.12.0" + }, + "blosc-1.12.0-he42ba99_0.conda": { + "build": "he42ba99_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "snappy", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8cdcc9cc33fff57b181075edd35bdbc8", + "name": "blosc", + "sha256": "fbdfe6b4af9dc49f22aa431d6f65b0771cfb5afeaaa0ec0abc2a602c27be0770", + "size": 326621, + "subdir": "linux-64", + "timestamp": 1505740856997, + "version": "1.12.0" + }, + "blosc-1.14.0-hdbcaa40_0.conda": { + "build": "hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "190452fa7f36fc425d8e225f61d43ca6", + "name": "blosc", + "sha256": "bfa8ef728829c7102511102a4b4ea3c0c5aa49600dd8f7b2aa7471e6c4cbeaeb", + "size": 310475, + "subdir": "linux-64", + "timestamp": 1522427056054, + "version": "1.14.0" + }, + "blosc-1.14.2-hdbcaa40_0.conda": { + "build": "hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "485ed0778e7e051bf3191827e33567eb", + "name": "blosc", + "sha256": "edc5a19063b651536dd044b97d0aa7abfab70309b6bbe3da114284985939c9b3", + "size": 309792, + "subdir": "linux-64", + "timestamp": 1522800994854, + "version": "1.14.2" + }, + "blosc-1.14.3-hdbcaa40_0.conda": { + "build": "hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "113929f2705eefe5a0dc29743fb25bd1", + "name": "blosc", + "sha256": "444871f9bbef72898d7a238e06fb630393c7176e0da8700b45c60d1357501586", + "size": 337180, + "subdir": "linux-64", + "timestamp": 1524177690023, + "version": "1.14.3" + }, + "blosc-1.14.4-hdbcaa40_0.conda": { + "build": "hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6f97681a15c7966e778a8451f61e7fed", + "name": "blosc", + "sha256": "8d4f3011ae7cdf1b0f166e813bea27cdd8f3e3641ca399ff96ba32de38aa6903", + "size": 337177, + "subdir": "linux-64", + "timestamp": 1534676150270, + "version": "1.14.4" + }, + "blosc-1.15.0-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a937d2961a0f1d5f2824e38fb21b3e57", + "name": "blosc", + "sha256": "f639b67227136a9c0c6d79f20738d527055abb8b5a6acbe1a9debe99e4f4d5fa", + "size": 406391, + "subdir": "linux-64", + "timestamp": 1547757103906, + "version": "1.15.0" + }, + "blosc-1.16.3-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a14fe192da283c28862e0c20c2a99687", + "name": "blosc", + "sha256": "0a5fbd481c57eacce3eac16101f0f67a2ab7c5a7432d117be2bf7124a496b74a", + "size": 72885, + "subdir": "linux-64", + "timestamp": 1558554355436, + "version": "1.16.3" + }, + "blosc-1.19.0-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.4,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "md5": "da283bd28d6376fee8831d355eedfe1f", + "name": "blosc", + "sha256": "7769c0487cb2b4acbf35d02573c35536d8f5f836f37fcafc57b81f840bfaa2f7", + "size": 72360, + "subdir": "linux-64", + "timestamp": 1592515136878, + "version": "1.19.0" + }, + "blosc-1.20.0-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "snappy >=1.1.8,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "md5": "3384cc8e3bdbbb5754a655c83b0c07f1", + "name": "blosc", + "sha256": "df085177fbd8499df06016dabd728dc3949175c1910172474d3a3ff2ece06e22", + "size": 72815, + "subdir": "linux-64", + "timestamp": 1597945777239, + "version": "1.20.0" + }, + "blosc-1.20.1-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f945d4bea4efb1362cbea553b00c2f42", + "name": "blosc", + "sha256": "15ef826a22c6597aee263d82ddb6c35608bddabe1740a776b77fc043c8ac3ead", + "size": 72257, + "subdir": "linux-64", + "timestamp": 1602700193466, + "version": "1.20.1" + }, + "blosc-1.21.0-h4ff587b_1.conda": { + "build": "h4ff587b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "md5": "945fec40403606af7a5c97bd8ee7f0cd", + "name": "blosc", + "sha256": "6a704c21970a101ee1a2cb78580d2446f2104ec581f74988cf325156978bc56e", + "size": 60438, + "subdir": "linux-64", + "timestamp": 1653036606205, + "version": "1.21.0" + }, + "blosc-1.21.0-h8c45485_0.conda": { + "build": "h8c45485_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "md5": "34cd84f63d186aa8c921317683523a25", + "name": "blosc", + "sha256": "a176a2b7b1ea9f30c5e11925dddc151690173f38bcde1386433291291737056e", + "size": 65781, + "subdir": "linux-64", + "timestamp": 1613249468528, + "version": "1.21.0" + }, + "blosc-1.21.3-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "lz4-c >=1.9.4,<1.10.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4a82e776d992a517ada3bdcede331ae8", + "name": "blosc", + "sha256": "c594dc4bde0621bbb37bbef36dd802b777502edb1cd67a48bc16b5d4820e5b15", + "size": 64418, + "subdir": "linux-64", + "timestamp": 1675247642609, + "version": "1.21.3" + }, + "bokeh-0.12.10-py27he46cc6b_0.conda": { + "build": "py27he46cc6b_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6ffa21cd0edaa1a59189b1fa879e1bf2", + "name": "bokeh", + "sha256": "15e5de30c0321996304b9a743233b677d7e4b3068ca41111930fdf487ab53a6c", + "size": 3378756, + "subdir": "linux-64", + "timestamp": 1508263083255, + "version": "0.12.10" + }, + "bokeh-0.12.10-py35hfdb0b1d_0.conda": { + "build": "py35hfdb0b1d_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "db73a090e620ab998d0a4584badaceff", + "name": "bokeh", + "sha256": "a3334602e79e75a9212d06fabb6445b8e057deb7648127795f6d5983804dc65d", + "size": 3379902, + "subdir": "linux-64", + "timestamp": 1508263108730, + "version": "0.12.10" + }, + "bokeh-0.12.10-py36hbb0e44a_0.conda": { + "build": "py36hbb0e44a_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9eb17d57c0bc772eecce45ce57618203", + "name": "bokeh", + "sha256": "ab17349ac28937191431fb8a9128fa5e0722ea5a37a97a140d24a36ddfa80ec5", + "size": 3387873, + "subdir": "linux-64", + "timestamp": 1508263109298, + "version": "0.12.10" + }, + "bokeh-0.12.11-py27h8429e54_0.conda": { + "build": "py27h8429e54_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2b303f4e26504f9c110cb1916baa10f9", + "name": "bokeh", + "sha256": "c6c06840142372a5327d252ed45ee464cd8dc9bc34d281cafeded5c05aba862b", + "size": 3511474, + "subdir": "linux-64", + "timestamp": 1511894158421, + "version": "0.12.11" + }, + "bokeh-0.12.11-py35hf9fdf3f_0.conda": { + "build": "py35hf9fdf3f_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f543f4c457f6700d95b7872451c4bead", + "name": "bokeh", + "sha256": "b08117a75863d940a6947a9b506b7bac122c2d372d4b76737a5f34080b9e2d41", + "size": 3523846, + "subdir": "linux-64", + "timestamp": 1511894189372, + "version": "0.12.11" + }, + "bokeh-0.12.11-py36hc91ac8f_0.conda": { + "build": "py36hc91ac8f_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5b9eb053f7b28b863d495a2a7b6980ec", + "name": "bokeh", + "sha256": "ef5f3cdacff3294b14e0f274cf6615cd765530a8aef97274f8e0f0234d11f28d", + "size": 3516337, + "subdir": "linux-64", + "timestamp": 1511894201475, + "version": "0.12.11" + }, + "bokeh-0.12.13-py27h5233db4_0.conda": { + "build": "py27h5233db4_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c4edd435da9114b5660e6d8e9eb98364", + "name": "bokeh", + "sha256": "aab3008efc6d90ffefb50e86d1641b08e0f0f0565d02973e0a54880a16a7224b", + "size": 3463493, + "subdir": "linux-64", + "timestamp": 1513097509467, + "version": "0.12.13" + }, + "bokeh-0.12.13-py35h2f9c1c0_0.conda": { + "build": "py35h2f9c1c0_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0fd50c58f1ccf0d0c126b4aea7deff0c", + "name": "bokeh", + "sha256": "704f8ba5c5201f2e33480d4c28308446c12c3b95628f78b6865a8c6e6e5f6407", + "size": 3466413, + "subdir": "linux-64", + "timestamp": 1513097549660, + "version": "0.12.13" + }, + "bokeh-0.12.13-py36h2f9c1c0_0.conda": { + "build": "py36h2f9c1c0_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d3487c67dffa190a5aa3ffb55e31e926", + "name": "bokeh", + "sha256": "595b05f6d1b11055c4fd676b78c5456e4b35b9b908d9fdd51c0dd1b1f9008193", + "size": 3468680, + "subdir": "linux-64", + "timestamp": 1513097592734, + "version": "0.12.13" + }, + "bokeh-0.12.14-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f113f2774d9f6a52d0905b59a8380073", + "name": "bokeh", + "sha256": "cc617776c701eb9c4c1f0b41f16028ed6981b3799a25f8558b86bf4c13ed5d12", + "size": 3477964, + "subdir": "linux-64", + "timestamp": 1519070341767, + "version": "0.12.14" + }, + "bokeh-0.12.14-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d1ea7cf13db78fe83d668ba4b062c8b0", + "name": "bokeh", + "sha256": "011868913e7a4dd20b9f750b4d31e466e711fba31f40e1fb95f07d44de17c51f", + "size": 3501127, + "subdir": "linux-64", + "timestamp": 1519070401771, + "version": "0.12.14" + }, + "bokeh-0.12.14-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9a3077f04062e7f27aa27a3bd8b345c2", + "name": "bokeh", + "sha256": "c124af14e2356e6365c17546b63f93dd3a3593554ca0a02a9b3464dcc9ae0188", + "size": 3493787, + "subdir": "linux-64", + "timestamp": 1519070402955, + "version": "0.12.14" + }, + "bokeh-0.12.15-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aa646b8a7585e75d97d9d6bfdd488222", + "name": "bokeh", + "sha256": "48268efa7d2091dfb4866184a6da0eecc1df38973f66d954cc1b83a63fcd5780", + "size": 3525235, + "subdir": "linux-64", + "timestamp": 1522345606685, + "version": "0.12.15" + }, + "bokeh-0.12.15-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "03cebe49bb4887f8ac6898023469f246", + "name": "bokeh", + "sha256": "d7e83e9de8593676e1647bb19822db3e523f6e4a8ab93b6ddb58f4eec44aad2e", + "size": 3549279, + "subdir": "linux-64", + "timestamp": 1522345570375, + "version": "0.12.15" + }, + "bokeh-0.12.15-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e13f0573b67edbd6df91670e8082f25f", + "name": "bokeh", + "sha256": "352fda1a608582eb4e6ef6a6732bbd66b1d64718fdeffbec93a45b0aff8ecdb0", + "size": 3543454, + "subdir": "linux-64", + "timestamp": 1522345631596, + "version": "0.12.15" + }, + "bokeh-0.12.16-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "361f1029fa3b62edd4696605f5bee26c", + "name": "bokeh", + "sha256": "4e3cdbe3d2b054797a6bbdfff63e66c8187a20af1b71ea4ac7fbbed606f9e670", + "size": 3540910, + "subdir": "linux-64", + "timestamp": 1526329854918, + "version": "0.12.16" + }, + "bokeh-0.12.16-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "577e3a0da0eafcddd2edb7c6ce7d5ce3", + "name": "bokeh", + "sha256": "70fb0d6465c046b95561c7e5090563e6b340decdb5a777cc725874121a12e70f", + "size": 3564334, + "subdir": "linux-64", + "timestamp": 1526329980731, + "version": "0.12.16" + }, + "bokeh-0.12.16-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c217baa47399c4035b3291d76fdebed8", + "name": "bokeh", + "sha256": "d581416ee09bc029e57dd62545be1b48049532012a2de0b475b5264baa5a5b47", + "size": 3546850, + "subdir": "linux-64", + "timestamp": 1526329935059, + "version": "0.12.16" + }, + "bokeh-0.12.7-py27he0197c9_1.conda": { + "build": "py27he0197c9_1", + "build_number": 1, + "depends": [ + "bkcharts >=0.2", + "futures >=3.0.3", + "jinja2 >=2.7", + "matplotlib", + "numpy >=1.7.1", + "pandas", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "requests >=1.2.3", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4d689d90bbea556fd28c1ddb520a8e4f", + "name": "bokeh", + "sha256": "0846ba578d5e14434f4870138f69ae4897dc42f29febf58a762ddaeed9b40a16", + "size": 3308119, + "subdir": "linux-64", + "timestamp": 1505739753633, + "version": "0.12.7" + }, + "bokeh-0.12.7-py35h4751c18_1.conda": { + "build": "py35h4751c18_1", + "build_number": 1, + "depends": [ + "bkcharts >=0.2", + "jinja2 >=2.7", + "matplotlib", + "numpy >=1.7.1", + "pandas", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "requests >=1.2.3", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "62936f4f01cdb63662a2c9922c894b6c", + "name": "bokeh", + "sha256": "044ca6e217590359ef9898bc6afb906e0868a061a28988819147145fe750cd9d", + "size": 3324633, + "subdir": "linux-64", + "timestamp": 1505739800717, + "version": "0.12.7" + }, + "bokeh-0.12.7-py36h169c5fd_1.conda": { + "build": "py36h169c5fd_1", + "build_number": 1, + "depends": [ + "bkcharts >=0.2", + "jinja2 >=2.7", + "matplotlib", + "numpy >=1.7.1", + "pandas", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "requests >=1.2.3", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2233680c92075ae736ac4f6e4d344d7d", + "name": "bokeh", + "sha256": "359e9a130853834be3138eb1039267061bcffe725c2601948fa557043befe0ac", + "size": 3320851, + "subdir": "linux-64", + "timestamp": 1505739848870, + "version": "0.12.7" + }, + "bokeh-0.12.9-py27h403a6de_0.conda": { + "build": "py27h403a6de_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "739cc94a160842d7e2bbf12fd9d37f4f", + "name": "bokeh", + "sha256": "0e66788539078258594a19bd98b16bc510ea18daef1eb16c7d8e547a8d072147", + "size": 3325057, + "subdir": "linux-64", + "timestamp": 1506621189022, + "version": "0.12.9" + }, + "bokeh-0.12.9-py35hebc9bbc_0.conda": { + "build": "py35hebc9bbc_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "442f18c7257fc211f78cbc41e2d34c14", + "name": "bokeh", + "sha256": "95b0bad5172be1f22e366ce793d58c0d0ba99c12cd12cdea3257d085fa7b5b6f", + "size": 3324005, + "subdir": "linux-64", + "timestamp": 1506621211683, + "version": "0.12.9" + }, + "bokeh-0.12.9-py36hca3971f_0.conda": { + "build": "py36hca3971f_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6d17cba0bb0836e633a77c42b1a661f8", + "name": "bokeh", + "sha256": "1aa85b8d1bce1cc3fe58b5c3763295739b205f79d6aa0449aeaa90d4bc49ee46", + "size": 3335710, + "subdir": "linux-64", + "timestamp": 1506621219178, + "version": "0.12.9" + }, + "bokeh-0.13.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a06160ca8f367b5532a232c3fe65322e", + "name": "bokeh", + "sha256": "205617cbab1b856d478ae72c3b6253c811a7fdb838e03b3514ba1534e06c1474", + "size": 4285643, + "subdir": "linux-64", + "timestamp": 1529505432491, + "version": "0.13.0" + }, + "bokeh-0.13.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fa6e5b6472daaa2abceb0e9f5abd52c5", + "name": "bokeh", + "sha256": "6119c508f81d15a0e10153ee413b03c2a0c5981ea77f68febe389c9aa3040a7a", + "size": 4294604, + "subdir": "linux-64", + "timestamp": 1529505466272, + "version": "0.13.0" + }, + "bokeh-0.13.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "68f53e28b8a6672258535799ac94c450", + "name": "bokeh", + "sha256": "5cc7b582bc488f2db2d0f5060dac2ac0944e7cf5f65a9da51946c1944565a93e", + "size": 4315740, + "subdir": "linux-64", + "timestamp": 1529505448310, + "version": "0.13.0" + }, + "bokeh-0.13.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "680720ead6cfb0cc2f2e72c71794acdb", + "name": "bokeh", + "sha256": "9b6eebd4faf2f8f7c44ad7af7a1b72f81c0503ad643dcd7eaaf8900f600c07b7", + "size": 4284200, + "subdir": "linux-64", + "timestamp": 1530741904337, + "version": "0.13.0" + }, + "bokeh-1.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dcb9f09fba8aa9c700f5abe4d7daf7c2", + "name": "bokeh", + "sha256": "1064a11d8338897367c34c03dd4c079c04a702ce7898b7c506f178ef4964a8e9", + "size": 4454994, + "subdir": "linux-64", + "timestamp": 1540399472457, + "version": "1.0.0" + }, + "bokeh-1.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6ef111da26591f922236c8169b9cd5b1", + "name": "bokeh", + "sha256": "4a28204c594d7563b4845323157221a6ff7f4b3761df5838bec692b74e3cf200", + "size": 4463904, + "subdir": "linux-64", + "timestamp": 1540399497766, + "version": "1.0.0" + }, + "bokeh-1.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8e240518c395e3f46c6ebc0f6cdf1111", + "name": "bokeh", + "sha256": "755cef8021759464982df6125332c84f590fdf9cc8247a33856ebb7ac61d13dd", + "size": 4448250, + "subdir": "linux-64", + "timestamp": 1540399512486, + "version": "1.0.0" + }, + "bokeh-1.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8d629581fa01e948d739d76d883f1b86", + "name": "bokeh", + "sha256": "e1283f60e2a51c18de095493b72fafdc1932b520d6f327f4bc03434783b34a81", + "size": 4452208, + "subdir": "linux-64", + "timestamp": 1541047782301, + "version": "1.0.1" + }, + "bokeh-1.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8dc221afc1db7c1147bf0ab619ce91c2", + "name": "bokeh", + "sha256": "60ce7dc05818505c7db24c3a70d02cecfd714bb67b30540da74cfb289f627b45", + "size": 4455498, + "subdir": "linux-64", + "timestamp": 1541047787819, + "version": "1.0.1" + }, + "bokeh-1.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c08bc4f25af9adf88fde72ff64ca850b", + "name": "bokeh", + "sha256": "a32e95cf354ada3962caddaf50f6fb4c4e0baf871faa13bcb875030819e52e00", + "size": 4454577, + "subdir": "linux-64", + "timestamp": 1541047740473, + "version": "1.0.1" + }, + "bokeh-1.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f83cc2596c1cb4b85f21bfdae01e4f47", + "name": "bokeh", + "sha256": "b010cae2cdd2ff7975831e0ca75a7fc6dc6adc7e3ff75cb590bf14cabd0135e0", + "size": 4491846, + "subdir": "linux-64", + "timestamp": 1543527825897, + "version": "1.0.2" + }, + "bokeh-1.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6bcf16154950825b554bacd03e911d0e", + "name": "bokeh", + "sha256": "9ad73e16c6cfb5d6e5f00111c8e49067a7893965055ee9863cf386750ec6806b", + "size": 4499013, + "subdir": "linux-64", + "timestamp": 1543527867089, + "version": "1.0.2" + }, + "bokeh-1.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3f33c00406c5d5eab0a493f962aac0d6", + "name": "bokeh", + "sha256": "671b599a0cbdfbea03f0b94438886af217d4c90a4ec310752dbb9ef915996b97", + "size": 4509680, + "subdir": "linux-64", + "timestamp": 1543527817681, + "version": "1.0.2" + }, + "bokeh-1.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "46af6430c5ee971545f76ec652646f61", + "name": "bokeh", + "sha256": "6e0b5c2fb9c455b1f30c2c8c1d61e3a315e7dfe8ceef9e70944050ca03fcf2ce", + "size": 4552333, + "subdir": "linux-64", + "timestamp": 1546406186823, + "version": "1.0.3" + }, + "bokeh-1.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "30ec512146bb91b96d3bf5202b823f14", + "name": "bokeh", + "sha256": "95a8b256a83d704c9c302107f75318c5928c489e426725bf69e4bab21ab4a3bd", + "size": 4555834, + "subdir": "linux-64", + "timestamp": 1546406207062, + "version": "1.0.3" + }, + "bokeh-1.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fae24fce239df159804b92dd9b541a80", + "name": "bokeh", + "sha256": "08c380b8c72118a0f6647d1f1813967c6971def2bf36eda3cd2ae950bc75cb9a", + "size": 4555983, + "subdir": "linux-64", + "timestamp": 1546406207157, + "version": "1.0.3" + }, + "bokeh-1.0.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9bebd318e17f20dcd8c1e6fa21b87e1d", + "name": "bokeh", + "sha256": "bbba168480c00da272b6b701abef2b5abb7fcf9609218438ea1df84cfaad3db1", + "size": 4554965, + "subdir": "linux-64", + "timestamp": 1547757249215, + "version": "1.0.4" + }, + "bokeh-1.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2807337d457e7db4e555dd8e496d2bcd", + "name": "bokeh", + "sha256": "be251ed771775e870eb80796dc41c5bb11e903e8e9d3c71bcaabc6d7f7297af6", + "size": 4558677, + "subdir": "linux-64", + "timestamp": 1547757251917, + "version": "1.0.4" + }, + "bokeh-1.0.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d860b5868c83eb947a5298123e0b3769", + "name": "bokeh", + "sha256": "6474f6459ab01c11758adc7d74f55542c63c24a530bfc565abd0e793244a1675", + "size": 4557961, + "subdir": "linux-64", + "timestamp": 1547757216073, + "version": "1.0.4" + }, + "bokeh-1.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9e99fb668e3b0a7aabfe02f5550a0201", + "name": "bokeh", + "sha256": "934a3dbe411f4f86cef85d2562fd1a74c25c73c1bea63a4c4123e58afa0b4692", + "size": 5007426, + "subdir": "linux-64", + "timestamp": 1554927352633, + "version": "1.1.0" + }, + "bokeh-1.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "60529dc085aea35593b9e6b62c7daf5b", + "name": "bokeh", + "sha256": "eb289d606a465fe7c9c8f76438b298c7eb32d119ceb33bc701ef3628264da96f", + "size": 5018019, + "subdir": "linux-64", + "timestamp": 1554927279375, + "version": "1.1.0" + }, + "bokeh-1.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7eeb2cf0b08001c392320b98ac0dd76a", + "name": "bokeh", + "sha256": "fecf8ac47a47526b6842adf531a5057910832dc5814c24842a0f0a9c38742a5b", + "size": 4990452, + "subdir": "linux-64", + "timestamp": 1554927362128, + "version": "1.1.0" + }, + "bokeh-1.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ac5459896a75d49cedb39a0a018c39f2", + "name": "bokeh", + "sha256": "ad3fb66a8855fa1502e081f8d70e36143263d4df1236abc4d87616f47dd1adb6", + "size": 3666997, + "subdir": "linux-64", + "timestamp": 1559140944218, + "version": "1.2.0" + }, + "bokeh-1.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "318ebbd30652515e5cbe77c43f5a6ea4", + "name": "bokeh", + "sha256": "920f7687b6566201f59d96518ab9c3d20629c33f73753b407f675206f4714f86", + "size": 3671161, + "subdir": "linux-64", + "timestamp": 1559141330221, + "version": "1.2.0" + }, + "bokeh-1.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e5c4cf7be4db80d279756f1b738fbad1", + "name": "bokeh", + "sha256": "a05636bd5490313bf852492f8649fcb97bf51a2162149b628bdaa868799a1abe", + "size": 3671269, + "subdir": "linux-64", + "timestamp": 1559140933930, + "version": "1.2.0" + }, + "bokeh-1.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fc52c5449e913a7a29d935573301183b", + "name": "bokeh", + "sha256": "ae0d781c0986631e07bf5e27d90577ad7ef4b79b80d401e013e6561313d84bdd", + "size": 3719993, + "subdir": "linux-64", + "timestamp": 1563895753628, + "version": "1.3.0" + }, + "bokeh-1.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6e9c9f5c469c6bf6446492f173b0af90", + "name": "bokeh", + "sha256": "b28acc0e2d68d71c795f07a6693c152c0243e7130aa505ea016bd5a7c7d4eb17", + "size": 3728674, + "subdir": "linux-64", + "timestamp": 1563895759970, + "version": "1.3.0" + }, + "bokeh-1.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "04f38483d0d01da4318e7c92e5966e03", + "name": "bokeh", + "sha256": "42177497de7dd7dc1c6b2d81126ab206a2e6e393d6fd8c969ba604562c9a50fc", + "size": 3712304, + "subdir": "linux-64", + "timestamp": 1563895757920, + "version": "1.3.0" + }, + "bokeh-1.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ed3a96e594718a8f76633fb39f914139", + "name": "bokeh", + "sha256": "53069839e2f572c89ceb02696f050af1a637c939d364a717d43c700736cc12be", + "size": 3722925, + "subdir": "linux-64", + "timestamp": 1564518423051, + "version": "1.3.1" + }, + "bokeh-1.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6981a3acfa0d6dc5253356ae5dc9ac3c", + "name": "bokeh", + "sha256": "dca7da44a2be56fa50c728dd3b49af176bd6903c932f3e94d64ff0f2b7c9db6e", + "size": 3715888, + "subdir": "linux-64", + "timestamp": 1564518473337, + "version": "1.3.1" + }, + "bokeh-1.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e513cf7f14bd99ef6b93c8f7617a6d19", + "name": "bokeh", + "sha256": "67e11e5ab460e3b856e545a0830f6a23f31e68e4cf4887ecbf116a19d86651a5", + "size": 3726438, + "subdir": "linux-64", + "timestamp": 1564518446681, + "version": "1.3.1" + }, + "bokeh-1.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2b230353a8e3e0593cafd34a0878806b", + "name": "bokeh", + "sha256": "470aa56dcf27197230116cbd2e7d1794477da2ddd08da4d0208443f589186dfe", + "size": 3708205, + "subdir": "linux-64", + "timestamp": 1565026226978, + "version": "1.3.2" + }, + "bokeh-1.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7c7c5a0f90017e5e33cd5544ff166e5e", + "name": "bokeh", + "sha256": "35b3665c4968c808f0f61a8f610973975a7a9070a5e80a1f92e102547a487f3d", + "size": 3727628, + "subdir": "linux-64", + "timestamp": 1565018104201, + "version": "1.3.2" + }, + "bokeh-1.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "215053aa14eca2a5fe47a6b0b4af5691", + "name": "bokeh", + "sha256": "08cc3125501eafb0b80a407f83c54d65784e54cfd69de1403b7ed120af323315", + "size": 3727224, + "subdir": "linux-64", + "timestamp": 1565016998073, + "version": "1.3.2" + }, + "bokeh-1.3.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dda7d643303f0b49c2d778fbff1bdeb6", + "name": "bokeh", + "sha256": "0e334d8c1672d5018393b2240063c616239e83848725e6253c96e9970c2e6f81", + "size": 3717977, + "subdir": "linux-64", + "timestamp": 1565187191399, + "version": "1.3.4" + }, + "bokeh-1.3.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d2b553bc26d3cdb01786e9b212eceaf7", + "name": "bokeh", + "sha256": "a62d75e5dbf64f8b75f6aa135ddebbb99e5e7e979a2fadbc6f73ac0a64e68787", + "size": 3715530, + "subdir": "linux-64", + "timestamp": 1565187211496, + "version": "1.3.4" + }, + "bokeh-1.3.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d9d5e0de2a0d2cd9bac976942ec378a5", + "name": "bokeh", + "sha256": "ff4fadc5b04cd1381c43184e694d49a3794ff13c4e008bdc60d7025d2190b7c7", + "size": 3724964, + "subdir": "linux-64", + "timestamp": 1565187201838, + "version": "1.3.4" + }, + "bokeh-1.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3.0.3", + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e8613e1343d4dd09780e519c8ae33f93", + "name": "bokeh", + "sha256": "c717ebace60cf56c5270e0d21440a3575ce9758c5998a954a15f85b24e830eea", + "size": 8592931, + "subdir": "linux-64", + "timestamp": 1572890767580, + "version": "1.4.0" + }, + "bokeh-1.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6f34a6e4e1aae80339f58805673ada2a", + "name": "bokeh", + "sha256": "a6e566a0efbc01f901dd3d0e54a0f5be4ae09e5b318265e99c154086b5ef55c8", + "size": 8608708, + "subdir": "linux-64", + "timestamp": 1572890763851, + "version": "1.4.0" + }, + "bokeh-1.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3f190a0408ea1aff992551f7d4280cd0", + "name": "bokeh", + "sha256": "f65b1773a49c5c1aebd98616aaf5efa6c384fc72aa9d7e0d15e5c0748f897f3e", + "size": 8603404, + "subdir": "linux-64", + "timestamp": 1572890744406, + "version": "1.4.0" + }, + "bokeh-1.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.7.1", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "six >=1.5.2", + "tornado >=4.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6844bc6fadb8069f714399ccab60687f", + "name": "bokeh", + "sha256": "14719c3b1fee33d5b77ab3112d2b9bfa5b19bd7d27adb34ba8589b4d8c5349bf", + "size": 8699011, + "subdir": "linux-64", + "timestamp": 1580236714426, + "version": "1.4.0" + }, + "bokeh-2.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7aeb1a0042a2ae227fb74faf4ade7809", + "name": "bokeh", + "sha256": "67c4193033e6b6dd9e218b0cc8554cec9dc916fccc640ea3fa88f70699fcd114", + "size": 5493364, + "subdir": "linux-64", + "timestamp": 1584020889121, + "version": "2.0.0" + }, + "bokeh-2.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2c188b7e11abe973bba47642d341ccc1", + "name": "bokeh", + "sha256": "aedf85abb97df0cf9ead1784d5bf1042811210739c965b1a201fccab7f81e308", + "size": 5531245, + "subdir": "linux-64", + "timestamp": 1584020856541, + "version": "2.0.0" + }, + "bokeh-2.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "434aa33a9233359c0caf7c6932a29192", + "name": "bokeh", + "sha256": "b46658f1c2376f81ca724a3051aa5bc3cf71b93e410e199b9e081b55a499ca10", + "size": 5526106, + "subdir": "linux-64", + "timestamp": 1584020901756, + "version": "2.0.0" + }, + "bokeh-2.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ad3a06edf363301cc4d704244733ef24", + "name": "bokeh", + "sha256": "64df644d3b8eb29da36e99716389affda87c6002a7c02ec5703d01b6c09a4fb4", + "size": 5558276, + "subdir": "linux-64", + "timestamp": 1585589047134, + "version": "2.0.1" + }, + "bokeh-2.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0584a8c28e902a1870c3ea10bf913de9", + "name": "bokeh", + "sha256": "926a53998a5b1ad9a64c4b2d559737be07ba8570ca7bf2739f0cc07d9a995ab4", + "size": 5598464, + "subdir": "linux-64", + "timestamp": 1585589020163, + "version": "2.0.1" + }, + "bokeh-2.0.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "321eedbf611fb4c50a5549003a3a0c42", + "name": "bokeh", + "sha256": "cc1a28f32b4948e374128d947fa8e8b2b44cf6202086073d05101b6196f82d33", + "size": 5613605, + "subdir": "linux-64", + "timestamp": 1585589028176, + "version": "2.0.1" + }, + "bokeh-2.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "af2fcff87adb916d4b077be98acb78f8", + "name": "bokeh", + "sha256": "f7c5af864ebe322f1f2ddb464aa402ba82ae84ceeff10cafee378b6335386c97", + "size": 5548054, + "subdir": "linux-64", + "timestamp": 1588263382310, + "version": "2.0.2" + }, + "bokeh-2.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "24bfb02d0d786420be80ed14479ef350", + "name": "bokeh", + "sha256": "0b032da119b74dc66425356710846510a31f738486cdcac0153071c45f935435", + "size": 5544778, + "subdir": "linux-64", + "timestamp": 1588263382709, + "version": "2.0.2" + }, + "bokeh-2.0.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8cc1444ca3a2edcbc2660179d3971b9b", + "name": "bokeh", + "sha256": "022f562dd8249998b77f469067108453c14d0a85685fe1bbdd64663d5cb88062", + "size": 5548771, + "subdir": "linux-64", + "timestamp": 1588263399726, + "version": "2.0.2" + }, + "bokeh-2.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22fdaac4456342864bd8a3eab7142233", + "name": "bokeh", + "sha256": "1139e37b32eda55539155ba313f006c9c05d84d7612c223ef55ca9ddbeebb8e5", + "size": 5631735, + "subdir": "linux-64", + "timestamp": 1592319694418, + "version": "2.1.0" + }, + "bokeh-2.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "30835493466a7e00f304a143d51a8cdc", + "name": "bokeh", + "sha256": "86f23ae75cec0e4eb7cf272b7a28956ba6ee09fbe16cc8e2fa7f1f5a9acd13cf", + "size": 5673895, + "subdir": "linux-64", + "timestamp": 1592319703967, + "version": "2.1.0" + }, + "bokeh-2.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "14f3983c998e18b34c8d248ef0765f2d", + "name": "bokeh", + "sha256": "3391eabd6ba064a1524bb2964aee715b27b53cb7bc45dae2293fcc5944ee901d", + "size": 5664617, + "subdir": "linux-64", + "timestamp": 1592319692861, + "version": "2.1.0" + }, + "bokeh-2.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d363b96a3ba18650f962be475d0d1106", + "name": "bokeh", + "sha256": "71562d2a0446d3115484f0f1e5bfa28a23ca5c62f73bdfdc460a761ac2f67046", + "size": 5681100, + "subdir": "linux-64", + "timestamp": 1593187650020, + "version": "2.1.1" + }, + "bokeh-2.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eae5093132b956631ef05374e5c032a1", + "name": "bokeh", + "sha256": "e36100e726171513b1e3bfc13680df029e68e3baa769aaeebb49bec6b12c46ea", + "size": 5622275, + "subdir": "linux-64", + "timestamp": 1593187630801, + "version": "2.1.1" + }, + "bokeh-2.1.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7584e23a6b4c75ed436d0d456d0dfb14", + "name": "bokeh", + "sha256": "90bc13dfe2fdbba1c47fb36135f962c7d4802b2e8d54295c06d654a66fc8c6ee", + "size": 5682826, + "subdir": "linux-64", + "timestamp": 1593187649634, + "version": "2.1.1" + }, + "bokeh-2.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b5c16dd144ada552eb4a2bce00aa6049", + "name": "bokeh", + "sha256": "1f90578f578a391aa67aca4bf98d65598f956c9e2ececfeba078194d67b74d2b", + "size": 5663369, + "subdir": "linux-64", + "timestamp": 1598371092245, + "version": "2.2.0" + }, + "bokeh-2.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3715f83b5b75e829beb7759ba7b46ffa", + "name": "bokeh", + "sha256": "ab6f749f68d9a863d6ae425bd9a426f571fd651ba7503cddaa9e6f994319de10", + "size": 5601774, + "subdir": "linux-64", + "timestamp": 1598293368906, + "version": "2.2.0" + }, + "bokeh-2.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9fe5c81be1d7fcb883c0ad36cebbdc86", + "name": "bokeh", + "sha256": "1f0d89ce045fb77259dfdb2c7d3b2c42f4ce7bf39967475e3d399d6546fc82c4", + "size": 5604085, + "subdir": "linux-64", + "timestamp": 1598371068490, + "version": "2.2.0" + }, + "bokeh-2.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "735293b24b5aa3fa82d78a37825be576", + "name": "bokeh", + "sha256": "07f753a08b54fef9ca9c1608ceb360e3f6892dc4e512a431afac01ae7adc8ffe", + "size": 5626332, + "subdir": "linux-64", + "timestamp": 1598903603131, + "version": "2.2.1" + }, + "bokeh-2.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "13382cbf06052fb3f67001a92b6913b7", + "name": "bokeh", + "sha256": "bd95eff6170893ddc184fa5fce0fa01eac06955b0b65d1a023c04ae48060036b", + "size": 5662667, + "subdir": "linux-64", + "timestamp": 1598903543975, + "version": "2.2.1" + }, + "bokeh-2.2.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b7a27dd706dbe5d992028287342cc3df", + "name": "bokeh", + "sha256": "c730509ed54d3ada9acd1b8236d1adecee6c409ff32e5f16ecb6ce76ef337c4d", + "size": 5663243, + "subdir": "linux-64", + "timestamp": 1598903574802, + "version": "2.2.1" + }, + "bokeh-2.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "828c98bd598645c4632d2ff5a39700de", + "name": "bokeh", + "sha256": "efbaadcd204ddb0ba23f5ee230006074ab0f1ca6368e7129e92b455bfc419f59", + "size": 5597387, + "subdir": "linux-64", + "timestamp": 1602773489868, + "version": "2.2.2" + }, + "bokeh-2.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "682367e794214410c4868426851fd946", + "name": "bokeh", + "sha256": "1c5a860f5d27d7c5c5fa7566d706bf095383e6c7d52ecbb6f27af251fa35644d", + "size": 5605866, + "subdir": "linux-64", + "timestamp": 1602773497366, + "version": "2.2.2" + }, + "bokeh-2.2.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "56db1c551232ab5b6f1b7d1ac8aa060f", + "name": "bokeh", + "sha256": "37790616e5fa41b2a851a36c87029ca6389d491f028ec7c83b6f71652286161c", + "size": 5599463, + "subdir": "linux-64", + "timestamp": 1602773501582, + "version": "2.2.2" + }, + "bokeh-2.2.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07edbcb4e3898e13dc2f78498c849b6f", + "name": "bokeh", + "sha256": "de0bdf6fb1057cd0c4a890e2894b1673e42da5c9f1ce748d6b77ae3651254fb0", + "size": 5660548, + "subdir": "linux-64", + "timestamp": 1603297862304, + "version": "2.2.3" + }, + "bokeh-2.2.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "37d88121c8edf1c742b4a5240b93ca50", + "name": "bokeh", + "sha256": "9c6c8ea633b15047ecf9c569390cd5791e0a106c68b8da76590bda1a227e59e2", + "size": 5603121, + "subdir": "linux-64", + "timestamp": 1603297887233, + "version": "2.2.3" + }, + "bokeh-2.2.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e9c010af1fa03e198f3143d5838bd5c", + "name": "bokeh", + "sha256": "aec14d271a603eb3e5577be4b0f45968a2757a9cb9530bd0fef6b7b5ffe23262", + "size": 5593800, + "subdir": "linux-64", + "timestamp": 1603297872516, + "version": "2.2.3" + }, + "bokeh-2.2.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2b85bb39885d4d50b676313472e03039", + "name": "bokeh", + "sha256": "ffa82e159cb049f9559bf558ca76408b7bd392ace8e0c81ede1e60c672190c86", + "size": 5620072, + "subdir": "linux-64", + "timestamp": 1607609923036, + "version": "2.2.3" + }, + "bokeh-2.3.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9b6e1e9edb839df95b4f55bc33952e78", + "name": "bokeh", + "sha256": "5e8354ba0a0dbadc06e41a3898b4845e24af06d0a46894d6e381c68393d5316e", + "size": 6053853, + "subdir": "linux-64", + "timestamp": 1614700680186, + "version": "2.3.0" + }, + "bokeh-2.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "40ae61007ec6bc5fdc1d77575d475eef", + "name": "bokeh", + "sha256": "c548884b20203900621e1fa6acd233b804fd8c39dd3ec66962a142f55e639cb2", + "size": 6049520, + "subdir": "linux-64", + "timestamp": 1614699441310, + "version": "2.3.0" + }, + "bokeh-2.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fc5c54a6df6a709980e99646a2d5810d", + "name": "bokeh", + "sha256": "e89355932c2251b9e0294e1be7753e016da37d75831c685a3e3c92b578b01820", + "size": 6071392, + "subdir": "linux-64", + "timestamp": 1614700676001, + "version": "2.3.0" + }, + "bokeh-2.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1eb800d8c163da6fd987f50bc5eea48e", + "name": "bokeh", + "sha256": "e7abce6c199407670858f2cfdc9196a2865c3d3550c2e2ed2d06198703fc2a2c", + "size": 6051790, + "subdir": "linux-64", + "timestamp": 1614700680235, + "version": "2.3.0" + }, + "bokeh-2.3.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cd0694bebaa069d142577706df1446d6", + "name": "bokeh", + "sha256": "81b63e097a2ec42b515e3e488937bfd434d0b6afd5dfeacbbeff2d5d117e2f76", + "size": 6137414, + "subdir": "linux-64", + "timestamp": 1617827408739, + "version": "2.3.1" + }, + "bokeh-2.3.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "77ef6db08509f94544df7a94b4f7d1cc", + "name": "bokeh", + "sha256": "2558f6e59c24c18a1605e14e23f397893c2b696969bc4c0d86a232f8ea6fd8cd", + "size": 6143234, + "subdir": "linux-64", + "timestamp": 1617827411766, + "version": "2.3.1" + }, + "bokeh-2.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "43d8253ed9ef2452f86d9ce5aba4f506", + "name": "bokeh", + "sha256": "ba0138722a11655a5687dfd5a44efa70641d3fe3c85cb87d11b5486382283238", + "size": 6071138, + "subdir": "linux-64", + "timestamp": 1617824600429, + "version": "2.3.1" + }, + "bokeh-2.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2771f08b3cf555e203e5810eaf4f1b8f", + "name": "bokeh", + "sha256": "c99ff8920712dcb94d87d644a6e6071734ea9b35d6e3b995524daff2953eee01", + "size": 6130495, + "subdir": "linux-64", + "timestamp": 1617826622252, + "version": "2.3.1" + }, + "bokeh-2.3.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.7", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "11d31080817195ce33206e4595853fb7", + "name": "bokeh", + "sha256": "1a51cc02e87c7117d277dc812b28801e68165f657057015f9648a583357b512f", + "size": 6078754, + "subdir": "linux-64", + "timestamp": 1620710103177, + "version": "2.3.2" + }, + "bokeh-2.3.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9e720bbf421d092dc76849c5f5104457", + "name": "bokeh", + "sha256": "11e1c7f42e168fee1e2cced48ace9b2dec297dccbd6a7d9d01fbd1e1dae12fb3", + "size": 6067739, + "subdir": "linux-64", + "timestamp": 1620783950233, + "version": "2.3.2" + }, + "bokeh-2.3.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7c4ee008313b0fd16bc1dbd6e2744876", + "name": "bokeh", + "sha256": "b10e37a7e79b42a2bfe12083aee8ca24e22bee9d99472098489ee26aedea8282", + "size": 6082652, + "subdir": "linux-64", + "timestamp": 1620779653740, + "version": "2.3.2" + }, + "bokeh-2.3.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "31f631b66cf5212e54aeccc1e49e08c6", + "name": "bokeh", + "sha256": "42daeef1c640ed25a3e234dbd9eabc6028751111bfa3c0971bcdb9f5dd94183c", + "size": 6156231, + "subdir": "linux-64", + "timestamp": 1620783948095, + "version": "2.3.2" + }, + "bokeh-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e773aabe19e21ff47b15460d0e8b4987", + "name": "bokeh", + "sha256": "d1c1d760358b4d832feb9859a997bcb0d56774258459f76232b6ab58e411b20f", + "size": 6146549, + "subdir": "linux-64", + "timestamp": 1625760725077, + "version": "2.3.3" + }, + "bokeh-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "016bd430fc99c63d0bda9844be09677f", + "name": "bokeh", + "sha256": "57d26eda8704e8e16c8452ebf4a809f10e3937e3dd546d13062ea45e377bd0b9", + "size": 6149574, + "subdir": "linux-64", + "timestamp": 1625766948987, + "version": "2.3.3" + }, + "bokeh-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7a279d843b04a435abdabd206595d6c7", + "name": "bokeh", + "sha256": "1c8935f8344e15ad4c5acac5f955cd4073f6622e69698210649ca380e55e8f60", + "size": 6070841, + "subdir": "linux-64", + "timestamp": 1625767563920, + "version": "2.3.3" + }, + "bokeh-2.4.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "038c9b8a762140717ee870c9cfab709f", + "name": "bokeh", + "sha256": "91f6f51f5c578f5837f020164486b1c33c831b3f1ce6ba406ea0c1c9f9f54561", + "size": 8064989, + "subdir": "linux-64", + "timestamp": 1640803601079, + "version": "2.4.1" + }, + "bokeh-2.4.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "897c1d42039fafff85f662979a532bed", + "name": "bokeh", + "sha256": "64c6eea7efc414126d90f01a1b93174a19d954136e42886c5873217c9fd8597a", + "size": 8060288, + "subdir": "linux-64", + "timestamp": 1635324527945, + "version": "2.4.1" + }, + "bokeh-2.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b5a51e63004c7f90b1f8b4941c667d63", + "name": "bokeh", + "sha256": "e30a470368f87cd609c34f8573a091aff42a7413767b5e94954157ed1df691f0", + "size": 8072542, + "subdir": "linux-64", + "timestamp": 1635324513029, + "version": "2.4.1" + }, + "bokeh-2.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a825671ebd8aaee5f6f1e7ffd09ce02", + "name": "bokeh", + "sha256": "3c0e4069885a3cd6b8d06d03632124afefee3b5b1ec90e15021737b3b7c663ce", + "size": 8070416, + "subdir": "linux-64", + "timestamp": 1635312856155, + "version": "2.4.1" + }, + "bokeh-2.4.2-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8173bcd4171cdbc9dc2776b171b918cf", + "name": "bokeh", + "sha256": "c93dd8df0d0040e94c0a6fd5d82cdfdea6e4486812b62019fefd5927e40653ac", + "size": 8069547, + "subdir": "linux-64", + "timestamp": 1652966940960, + "version": "2.4.2" + }, + "bokeh-2.4.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6183d8fdd256c61a73c5c90bd968ab41", + "name": "bokeh", + "sha256": "2a1519cd040f19475a27efc9ddb2ce073d28e1440fc61cb4d33e114fb10cf6d4", + "size": 7966211, + "subdir": "linux-64", + "timestamp": 1638362875270, + "version": "2.4.2" + }, + "bokeh-2.4.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3a99fd2ae4dca6c08d9277cd65498616", + "name": "bokeh", + "sha256": "f30b150dba3691bcb13ce0bbc7fe1892ffc7575f4fa168a6cba3f47e4282e1aa", + "size": 8059954, + "subdir": "linux-64", + "timestamp": 1652967007925, + "version": "2.4.2" + }, + "bokeh-2.4.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5cbe2c274a324f1c19a984fe62205e0c", + "name": "bokeh", + "sha256": "2014b0c5d9a580ae7a67385cd9de7f1b9eaeab5f7216a8256b2ffc72938cbef8", + "size": 8065795, + "subdir": "linux-64", + "timestamp": 1638349687511, + "version": "2.4.2" + }, + "bokeh-2.4.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6d5e0dc1a1c8d99540cf1e1b7e460bcd", + "name": "bokeh", + "sha256": "8712291d9061fd77ded0c9802f0b05459a4b8b1887ac97a3668937ff0d71a35d", + "size": 8059666, + "subdir": "linux-64", + "timestamp": 1652966792810, + "version": "2.4.2" + }, + "bokeh-2.4.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1723ef88fe112ead1fe35d7d3ade5d18", + "name": "bokeh", + "sha256": "4eea7b7956e6df49139c9d7182e748e75d6ffcae9522c8df43d458e3c51265a1", + "size": 8061050, + "subdir": "linux-64", + "timestamp": 1638362869859, + "version": "2.4.2" + }, + "bokeh-2.4.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "79bfe3e87384f85d2e75167bdd6c0a76", + "name": "bokeh", + "sha256": "69c07f0e948d3c39c9a5d9132428a8bbdab5b575cbd400de2c40d355a0438c4a", + "size": 8065457, + "subdir": "linux-64", + "timestamp": 1652966864360, + "version": "2.4.2" + }, + "bokeh-2.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "af0098c8fdc97428dad6c26306ad6388", + "name": "bokeh", + "sha256": "347754318cd6edd2dabeedd3041e5c0777893913df20fc5d828b0f9e6104783f", + "size": 8089926, + "subdir": "linux-64", + "timestamp": 1658136717996, + "version": "2.4.3" + }, + "bokeh-2.4.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.11,<3.12.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cb2e86271f77e0b8b1890a540ba66efe", + "name": "bokeh", + "sha256": "b51293c3a153e2111cf5320856d769823e55dc31205bc8dd5006a2466c2731f9", + "size": 9918659, + "subdir": "linux-64", + "timestamp": 1676830090434, + "version": "2.4.3" + }, + "bokeh-2.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "35ebdcdd27ef35762da1d3d26600129c", + "name": "bokeh", + "sha256": "b3b76c736b62b9de7c9cb612e15df54533d055de012408089b9a545cd978c0ab", + "size": 8073748, + "subdir": "linux-64", + "timestamp": 1658136848424, + "version": "2.4.3" + }, + "bokeh-2.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dce4ecfc5de6165a92fddccea389d2ac", + "name": "bokeh", + "sha256": "76953e7386d11d43d8f203a87aaedbc432558e5623fb30d1271335ef15514e06", + "size": 8077559, + "subdir": "linux-64", + "timestamp": 1658136913187, + "version": "2.4.3" + }, + "bokeh-2.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "typing_extensions >=3.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "126fc30875e1074fe74ca5a267e16256", + "name": "bokeh", + "sha256": "104333ef4bd6887a2547237a797594357f4f6e3e3fee690f3ecd91bf28e93179", + "size": 8087146, + "subdir": "linux-64", + "timestamp": 1658136783940, + "version": "2.4.3" + }, + "bokeh-3.0.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "80ca2a5d7fc5e59a350d76a20df7bfd3", + "name": "bokeh", + "sha256": "b51704cee254b056819e31bf2f1dfaadb20d82dfc8e0b38cc06a05ea33ed440a", + "size": 10666121, + "subdir": "linux-64", + "timestamp": 1668678923015, + "version": "3.0.2" + }, + "bokeh-3.0.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e31d7d427a21fcbc36845df46b3b3c74", + "name": "bokeh", + "sha256": "cb4aeb22cb809540e9d8338a77f082efa1b9371135427ec0a4605346a244f13e", + "size": 10655525, + "subdir": "linux-64", + "timestamp": 1668678850353, + "version": "3.0.2" + }, + "bokeh-3.0.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07c1b45e25194411fe3f2645185f1621", + "name": "bokeh", + "sha256": "8635b046ece962a7a7c83c065b1eff4b53f16569bae3393b355d783b6dffe1c2", + "size": 10654516, + "subdir": "linux-64", + "timestamp": 1668678773229, + "version": "3.0.2" + }, + "bokeh-3.0.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "653bcdb2cf2d561c8747330b531b52d2", + "name": "bokeh", + "sha256": "f610a649fc1dc20237249ccb59240c84e9f9921c9cb5e6ab77fb75d5c2202200", + "size": 10673638, + "subdir": "linux-64", + "timestamp": 1671781971237, + "version": "3.0.3" + }, + "bokeh-3.0.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.11,<3.12.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7da8b8d6e739fe7dbbb8e9243f59491f", + "name": "bokeh", + "sha256": "e308e097f8853931fff269bea6635367dfb9a70efe8b5647f1023d29a6d1b390", + "size": 9893398, + "subdir": "linux-64", + "timestamp": 1676830047435, + "version": "3.0.3" + }, + "bokeh-3.0.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2bbe9d960a7bbd66e05b6ebf16ff5bfa", + "name": "bokeh", + "sha256": "7b89c95629f59b940bbd3888f0eace1b501907c21acbb947cbdaa37121988e94", + "size": 10664719, + "subdir": "linux-64", + "timestamp": 1671782042064, + "version": "3.0.3" + }, + "bokeh-3.0.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.11.3", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "403f06f262d796fda31c82dcef418d62", + "name": "bokeh", + "sha256": "f0c1a43b677ce72a0782bd94f9924005c001b37f0ea444735f8e65ce4bd015d6", + "size": 10664429, + "subdir": "linux-64", + "timestamp": 1671782109717, + "version": "3.0.3" + }, + "bokeh-3.1.0-py310h2f386ee_0.conda": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.21.5,<2.0a0", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e8fd6aaa022d659f2dde778406948c53", + "name": "bokeh", + "sha256": "e64bcbcb1a1038bf6e16f8480fd039405731e6b2afdcee0b903a459c0f8a72f5", + "size": 6845338, + "subdir": "linux-64", + "timestamp": 1678869962030, + "version": "3.1.0" + }, + "bokeh-3.1.0-py311h6410fe4_0.conda": { + "build": "py311h6410fe4_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.22.3,<2.0a0", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.11,<3.12.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "116d6e4e5bbdbfde410306d82628f5f7", + "name": "bokeh", + "sha256": "ce231860dd0f9eb316959765b752d03d05c8c9a0541b8f23f302122fe82c4bb3", + "size": 6248291, + "subdir": "linux-64", + "timestamp": 1679335466362, + "version": "3.1.0" + }, + "bokeh-3.1.0-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.16.6,<2.0a0", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a13c56aa80fd0c3f9224934fe21d5951", + "name": "bokeh", + "sha256": "32d74b6ceb82b139d6444a631efed59cc9da9a36dc5d03feda8cce6ac861ff47", + "size": 6834874, + "subdir": "linux-64", + "timestamp": 1678870118561, + "version": "3.1.0" + }, + "bokeh-3.1.0-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "contourpy >=1", + "jinja2 >=2.9", + "numpy >=1.16.6,<2.0a0", + "packaging >=16.8", + "pandas >=1.2", + "pillow >=7.1.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10", + "tornado >=5.1", + "xyzservices >=2021.09.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c10c6b2ab50926f41c3db7d4a7a6b0fe", + "name": "bokeh", + "sha256": "103e9d9189e558e7dc6a95134c51ba7a7a5bc839ba0bc40c3f1b653e9a450ae7", + "size": 6834496, + "subdir": "linux-64", + "timestamp": 1678870037213, + "version": "3.1.0" + }, + "boltons-21.0.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "47696793c1867a82b4c80b8f691e16bd", + "name": "boltons", + "sha256": "cd482352630f1b74384465a234adc53931b6151f9918e2349948291c091fd7af", + "size": 436761, + "subdir": "linux-64", + "timestamp": 1674527461213, + "version": "21.0.0" + }, + "boltons-21.0.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "48f5541ff32e3aaf1469bdceebc43943", + "name": "boltons", + "sha256": "64c794502fddadfe641ca40b846a440dc3ad8a920da45c3a78a7c01959b6d905", + "size": 432258, + "subdir": "linux-64", + "timestamp": 1674527398794, + "version": "21.0.0" + }, + "boltons-21.0.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3dc3ae74407df6352e4b120bef98a454", + "name": "boltons", + "sha256": "ea6cd2499ba3b3799998f41293eeeb3cd96061a995c1765292e667dd95f5bbcf", + "size": 433503, + "subdir": "linux-64", + "timestamp": 1674527428212, + "version": "21.0.0" + }, + "boltons-21.0.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "76235af46f9657a3a56c55ede1de9f44", + "name": "boltons", + "sha256": "d5614691dab3cbc5d081f1a66b8f3cad8a96f20099e8f6b91e630c32de1f2316", + "size": 433145, + "subdir": "linux-64", + "timestamp": 1674527490592, + "version": "21.0.0" + }, + "boltons-23.0.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "69248b87edfba6b1abba3a25e6cfd992", + "name": "boltons", + "sha256": "d606fbabd6782a66f1afd77e42fb6474c4677524264c5548d845729444f965c2", + "size": 440072, + "subdir": "linux-64", + "timestamp": 1677628810225, + "version": "23.0.0" + }, + "boltons-23.0.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4e71bdc81d6cc98f2aec524dd112af37", + "name": "boltons", + "sha256": "587242fe8e8843cb397dc2a2cbb3d3ff29c9499d98703fa82255aba1e2ad080c", + "size": 488776, + "subdir": "linux-64", + "timestamp": 1677685215859, + "version": "23.0.0" + }, + "boltons-23.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "745fcf8820a334412f21778d880e30f7", + "name": "boltons", + "sha256": "14ec98ff1f103e382a674eab2dbf44d9ede337010d1514eee14b43d9e1ee09cb", + "size": 435481, + "subdir": "linux-64", + "timestamp": 1677628780937, + "version": "23.0.0" + }, + "boltons-23.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5abd59a6215751d4aef0f0bb1bde3678", + "name": "boltons", + "sha256": "fa2d063c128b426ac87b9a9c2ac2c454009637eb9f8ab8a1d1ce4c33c0ec67ed", + "size": 436705, + "subdir": "linux-64", + "timestamp": 1677628751883, + "version": "23.0.0" + }, + "boltons-23.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "29e878a86c5b81d2c752268e08b38360", + "name": "boltons", + "sha256": "ca731e1ca756816daccb2448542175158a51121c43db2493655d749bc38dcfa7", + "size": 436314, + "subdir": "linux-64", + "timestamp": 1677628723275, + "version": "23.0.0" + }, + "boolean.py-4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "dfb91f5ade6adbb6f7e67a6e8fa2dd6f", + "name": "boolean.py", + "sha256": "f3fa342fa7ccff7773c42755da60da07eeef06a6fb65aeb904bddad5687683bf", + "size": 48889, + "subdir": "linux-64", + "timestamp": 1663018505825, + "version": "4.0" + }, + "boolean.py-4.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "cc92adc726e81ea684b5b828f4def36e", + "name": "boolean.py", + "sha256": "7a6d0c596dc2dfa92498462e1d242f05b229d5016f84befafe4f55dc68c45954", + "size": 65663, + "subdir": "linux-64", + "timestamp": 1676839157950, + "version": "4.0" + }, + "boolean.py-4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8b239ce2b373251408b71a861a631197", + "name": "boolean.py", + "sha256": "413d22cd61928fc329142e16489d16c5bae10c7be6d66c290e889fcc88aa26c4", + "size": 48081, + "subdir": "linux-64", + "timestamp": 1663018530852, + "version": "4.0" + }, + "boolean.py-4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "02472ddccc53a9c9d7abbfa2440813c0", + "name": "boolean.py", + "sha256": "bf7b5feaf515a09e43a3f26c3578a28cc327544ef74a937da047fc9a4b8ef897", + "size": 48319, + "subdir": "linux-64", + "timestamp": 1663018555714, + "version": "4.0" + }, + "boolean.py-4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9a5b8094f2fe2601bcf1ad771ece59f6", + "name": "boolean.py", + "sha256": "5aedb07b10e2723252c2f5f203323deee77ede0621686b275e65f37565d1476c", + "size": 48182, + "subdir": "linux-64", + "timestamp": 1663018467614, + "version": "4.0" + }, + "boost-1.65.1-py27_4.conda": { + "build": "py27_4", + "build_number": 4, + "depends": [ + "libboost 1.65.1 habcd387_4", + "py-boost", + "python >=2.7,<2.8.0a0" + ], + "license": "Boost-1.0", + "md5": "ee8cb8ef80a100596bdde82cc8e02d24", + "name": "boost", + "namespace": "python", + "sha256": "0533b75a0f030df244e0e780a6a2d7f9d58477920ed8b8d47ebce083d97dba8d", + "size": 4500, + "subdir": "linux-64", + "timestamp": 1515095691660, + "version": "1.65.1" + }, + "boost-1.65.1-py27h0eb07c9_3.conda": { + "build": "py27h0eb07c9_3", + "build_number": 3, + "depends": [ + "libboost 1.65.1 h4055789_3", + "py-boost 1.65.1 py27h3b928e7_3", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Boost-1.0", + "md5": "6d9b486ef55a2ed3072f93c5c767cbe3", + "name": "boost", + "namespace": "python", + "sha256": "59d0eba2af003ca1e9cd82293ec026bfb627edb81187238360bfce1d262b7ec9", + "size": 4448, + "subdir": "linux-64", + "timestamp": 1508786740243, + "version": "1.65.1" + }, + "boost-1.65.1-py35_4.conda": { + "build": "py35_4", + "build_number": 4, + "depends": [ + "libboost 1.65.1 habcd387_4", + "py-boost", + "python >=3.5,<3.6.0a0" + ], + "license": "Boost-1.0", + "md5": "465c93018e5fc41441c1531f9b37697d", + "name": "boost", + "namespace": "python", + "sha256": "726e4f3cb4695b8440fa19e0ed42da16eddcaf9d18926cef826f9ff0b25601ac", + "size": 4488, + "subdir": "linux-64", + "timestamp": 1515095684781, + "version": "1.65.1" + }, + "boost-1.65.1-py35heb9229b_3.conda": { + "build": "py35heb9229b_3", + "build_number": 3, + "depends": [ + "libboost 1.65.1 h4055789_3", + "py-boost 1.65.1 py35hdf000e1_3", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Boost-1.0", + "md5": "bb6579bb6cc0a892c706cf683a7f83d4", + "name": "boost", + "namespace": "python", + "sha256": "2f56099ad34e468c193ba928b2f8ebbd6fd9d3c54c6236a7c017b078a3b321bf", + "size": 4433, + "subdir": "linux-64", + "timestamp": 1508786737842, + "version": "1.65.1" + }, + "boost-1.65.1-py36_4.conda": { + "build": "py36_4", + "build_number": 4, + "depends": [ + "libboost 1.65.1 habcd387_4", + "py-boost", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "959ad2a1897a66e4557df6e45ab5561d", + "name": "boost", + "namespace": "python", + "sha256": "b60b655ceeee87c598f0fc9a169b460ad474155ed1bda316b39253f4f022a928", + "size": 4486, + "subdir": "linux-64", + "timestamp": 1515095677075, + "version": "1.65.1" + }, + "boost-1.65.1-py36hfaba7b9_3.conda": { + "build": "py36hfaba7b9_3", + "build_number": 3, + "depends": [ + "libboost 1.65.1 h4055789_3", + "py-boost 1.65.1 py36hff4598c_3", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Boost-1.0", + "md5": "4437da04b6f0e484edfd787070c9eea7", + "name": "boost", + "namespace": "python", + "sha256": "6b4749b53f5cd58c4335389e9291dc36b02f8ef139c52289078c393b7a334f9a", + "size": 4418, + "subdir": "linux-64", + "timestamp": 1508786742887, + "version": "1.65.1" + }, + "boost-1.67.0-py27_4.conda": { + "build": "py27_4", + "build_number": 4, + "depends": [ + "libboost 1.67.0 h46d08c1_4", + "py-boost 1.67.0 py27h04863e7_4", + "python >=2.7,<2.8.0a0" + ], + "license": "Boost-1.0", + "md5": "6c0593f9fccf6ce5322a4ea24869dd20", + "name": "boost", + "namespace": "python", + "sha256": "4450e9a8613d4a146759e359bceab2d91e7836e311a918c737dc58a803ba18b8", + "size": 11405, + "subdir": "linux-64", + "timestamp": 1530782276179, + "version": "1.67.0" + }, + "boost-1.67.0-py35_4.conda": { + "build": "py35_4", + "build_number": 4, + "depends": [ + "libboost 1.67.0 h46d08c1_4", + "py-boost 1.67.0 py35h04863e7_4", + "python >=3.5,<3.6.0a0" + ], + "license": "Boost-1.0", + "md5": "8cc5e1e3ee8c21bd2500697c59f48887", + "name": "boost", + "namespace": "python", + "sha256": "30529836270f5e3a9b16bdb8ebf0c5db54c1aafdbe945f59fbf009ba65aa2851", + "size": 12462, + "subdir": "linux-64", + "timestamp": 1534944651149, + "version": "1.67.0" + }, + "boost-1.67.0-py36_4.conda": { + "build": "py36_4", + "build_number": 4, + "depends": [ + "libboost 1.67.0 h46d08c1_4", + "py-boost 1.67.0 py36h04863e7_4", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "d7f5d499417ee2a3e17f75efe5938fef", + "name": "boost", + "namespace": "python", + "sha256": "9d6e3cd80084d181b26b7bd5faedf7365706bccf72184247cef1eb810836a492", + "size": 11398, + "subdir": "linux-64", + "timestamp": 1530782283623, + "version": "1.67.0" + }, + "boost-1.67.0-py37_4.conda": { + "build": "py37_4", + "build_number": 4, + "depends": [ + "libboost 1.67.0 h46d08c1_4", + "py-boost 1.67.0 py37h04863e7_4", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "caa13e12b63cf5f5a38e81da3b231bc2", + "name": "boost", + "namespace": "python", + "sha256": "3182d46f1d8309f6d979b7de48e6450621699ad2bb818b5d88a9fc3d6816f4bf", + "size": 11393, + "subdir": "linux-64", + "timestamp": 1530782291004, + "version": "1.67.0" + }, + "boost-1.71.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "libboost 1.71.0 haf77d95_0", + "py-boost 1.71.0 py310h00e6091_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Boost-1.0", + "md5": "f37de573229bb3829dacaf13d8a7b08b", + "name": "boost", + "namespace": "python", + "sha256": "244f34865923b74377a418e95fd37a67fa228661f3339083c21a32b383dedd80", + "size": 15358, + "subdir": "linux-64", + "timestamp": 1640823530363, + "version": "1.71.0" + }, + "boost-1.71.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "libboost 1.71.0 haf77d95_1", + "py-boost 1.71.0 py310h00e6091_1", + "python >=3.10,<3.11.0a0" + ], + "license": "Boost-1.0", + "md5": "13cafe2e881532226e8566359c05f750", + "name": "boost", + "namespace": "python", + "sha256": "f38e5f426c08f4e6e4ac6a8b6f150f047d5e4433e0136763b061d9a9bc1d4fa4", + "size": 15647, + "subdir": "linux-64", + "timestamp": 1642425249226, + "version": "1.71.0" + }, + "boost-1.71.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libboost 1.71.0 h97c9712_0", + "py-boost 1.71.0 py36h0573a6f_0", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "0e858e6f1e5ba8c6bacbc7577e4bb467", + "name": "boost", + "namespace": "python", + "sha256": "ad6bb459feb98ead55c05c52e2fb03456c1a2796ca17b5dde586bdd826b870f6", + "size": 31525, + "subdir": "linux-64", + "timestamp": 1597486065584, + "version": "1.71.0" + }, + "boost-1.71.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libboost 1.71.0 h97c9712_0", + "py-boost 1.71.0 py37h0573a6f_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "af0438469412978bce8e4255659dc3c1", + "name": "boost", + "namespace": "python", + "sha256": "fbe285e187c6a1ec6c54238643b1711ccea41a1f28945d782d0fb9a81bdbfde0", + "size": 31511, + "subdir": "linux-64", + "timestamp": 1597486071955, + "version": "1.71.0" + }, + "boost-1.71.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "libboost 1.71.0 haf77d95_1", + "py-boost 1.71.0 py37h51133e4_1", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "1628c3b68c85e2cb09236b3e7c936f68", + "name": "boost", + "namespace": "python", + "sha256": "dc72a3fd7bcc95691b6ab98b5c6297dbdd32aa2e6273a9f19fc3cd1dc6c19128", + "size": 15555, + "subdir": "linux-64", + "timestamp": 1642425237764, + "version": "1.71.0" + }, + "boost-1.71.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "libboost 1.71.0 h97c9712_0", + "py-boost 1.71.0 py38h962f231_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "70005c12f1d629ff1702cdaf443f8828", + "name": "boost", + "namespace": "python", + "sha256": "ad0cbfbe59db2df09e3b2590ea1b9acaa83708a79e52ccbeae6290c8f36d1cde", + "size": 13636, + "subdir": "linux-64", + "timestamp": 1572611055949, + "version": "1.71.0" + }, + "boost-1.71.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "libboost 1.71.0 haf77d95_1", + "py-boost 1.71.0 py38h51133e4_1", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "b435a3639669c1465717e012beec657e", + "name": "boost", + "namespace": "python", + "sha256": "315506c7e34d202a450c91e7c923597e748b0b2d6eeec6b3ceb4f4e4200359d9", + "size": 15602, + "subdir": "linux-64", + "timestamp": 1642425254700, + "version": "1.71.0" + }, + "boost-1.71.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "libboost 1.71.0 haf77d95_1", + "py-boost 1.71.0 py39h51133e4_1", + "python >=3.9,<3.10.0a0" + ], + "license": "Boost-1.0", + "md5": "92e5a985020a6a6e7d029b8b1a60fbbc", + "name": "boost", + "namespace": "python", + "sha256": "ab222946f00ecbc6dcdf59838c29449b08b7fab8a849ac5ed7d3be1ed8bdee4f", + "size": 15632, + "subdir": "linux-64", + "timestamp": 1642425243380, + "version": "1.71.0" + }, + "boost-1.73.0-py310h06a4308_12.conda": { + "build": "py310h06a4308_12", + "build_number": 12, + "depends": [ + "libboost 1.73.0 h28710b8_12", + "py-boost 1.73.0 py310h00e6091_12", + "python >=3.10,<3.11.0a0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "a944a63cf2bf9342747bd459aa15dd28", + "name": "boost", + "namespace": "python", + "sha256": "f6da396c20e5bb02f789671c84a8c51bf718693de216fa41fa5cae4899a005c0", + "size": 16765, + "subdir": "linux-64", + "timestamp": 1655880137540, + "version": "1.73.0" + }, + "boost-1.73.0-py36_10.conda": { + "build": "py36_10", + "build_number": 10, + "depends": [ + "libboost 1.73.0 h37e3b65_10", + "py-boost 1.73.0 py36h962f231_10", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "eca41a23684048ed6d307423a6beb835", + "name": "boost", + "namespace": "python", + "sha256": "690dfeed80a8dbdadfd5e92ce4ec8f5a44e521e232e8bf1614e9fb71cf036256", + "size": 25251, + "subdir": "linux-64", + "timestamp": 1601386287546, + "version": "1.73.0" + }, + "boost-1.73.0-py36_11.conda": { + "build": "py36_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 h37e3b65_11", + "py-boost 1.73.0 py36h962f231_11", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "03f7ad9435b5a025ca37fa8cfaf1d44f", + "name": "boost", + "namespace": "python", + "sha256": "47f6daed8dc720575236d925e67a4ef1a3392e14054707e7e61f7922b6273928", + "size": 25800, + "subdir": "linux-64", + "timestamp": 1601470809852, + "version": "1.73.0" + }, + "boost-1.73.0-py36h06a4308_11.conda": { + "build": "py36h06a4308_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 h3ff78a5_11", + "py-boost 1.73.0 py36ha9443f7_11", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "f75723933cb1a6afdd26496b3e7ce5ba", + "name": "boost", + "namespace": "python", + "sha256": "889f26041d1dd9f1ea34e72dc1676e4f4aa057724aa99206530a714cf51384bf", + "size": 25132, + "subdir": "linux-64", + "timestamp": 1611677531747, + "version": "1.73.0" + }, + "boost-1.73.0-py37_10.conda": { + "build": "py37_10", + "build_number": 10, + "depends": [ + "libboost 1.73.0 h37e3b65_10", + "py-boost 1.73.0 py37h962f231_10", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "7ad9a4c828c30b4e41c7e25fc37561d5", + "name": "boost", + "namespace": "python", + "sha256": "99aaacdf79d6c68c40df28c1aa3ee8a8a83e1d3629d9363042956d10104612ca", + "size": 25239, + "subdir": "linux-64", + "timestamp": 1601386276547, + "version": "1.73.0" + }, + "boost-1.73.0-py37_11.conda": { + "build": "py37_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 h37e3b65_11", + "py-boost 1.73.0 py37h962f231_11", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "51d02d0905a44d030ffb02a113f71a6a", + "name": "boost", + "namespace": "python", + "sha256": "4bc6f06954fa8c969665be3fe3890fe72ffc81417473c6fadf26c41276706542", + "size": 25783, + "subdir": "linux-64", + "timestamp": 1601470821053, + "version": "1.73.0" + }, + "boost-1.73.0-py37h06a4308_11.conda": { + "build": "py37h06a4308_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 h3ff78a5_11", + "py-boost 1.73.0 py37ha9443f7_11", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "73b503b44b7a5d7da80f3aa339ea4b89", + "name": "boost", + "namespace": "python", + "sha256": "c2fda7e740231562b8e7fb9b51be45509a6db7f1d6ffd24c065a9b4ece9050b0", + "size": 25113, + "subdir": "linux-64", + "timestamp": 1611677510190, + "version": "1.73.0" + }, + "boost-1.73.0-py37h06a4308_12.conda": { + "build": "py37h06a4308_12", + "build_number": 12, + "depends": [ + "libboost 1.73.0 h28710b8_12", + "py-boost 1.73.0 py37h51133e4_12", + "python >=3.7,<3.8.0a0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "efbc1f0857ef5d8c4bf94e19407af2eb", + "name": "boost", + "namespace": "python", + "sha256": "751e03b3c7c77e18461f731466dd2e9b2afa911e00ce786fa363f0e26e5c9a33", + "size": 16742, + "subdir": "linux-64", + "timestamp": 1655880132198, + "version": "1.73.0" + }, + "boost-1.73.0-py38_10.conda": { + "build": "py38_10", + "build_number": 10, + "depends": [ + "libboost 1.73.0 h37e3b65_10", + "py-boost 1.73.0 py38h962f231_10", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "785bafe036123d974f8229d0729f7eb9", + "name": "boost", + "namespace": "python", + "sha256": "d0fbad6705fafa0f1f50bab7784c98402a03093be71295828c6df1af23d1e51f", + "size": 25248, + "subdir": "linux-64", + "timestamp": 1601386282049, + "version": "1.73.0" + }, + "boost-1.73.0-py38_11.conda": { + "build": "py38_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 h37e3b65_11", + "py-boost 1.73.0 py38h962f231_11", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "82d9218358eb90f8457e3936f2c21917", + "name": "boost", + "namespace": "python", + "sha256": "7beeca445eb5a49823224801f2a772daf541cfe72210c175829def10da3c65f1", + "size": 25786, + "subdir": "linux-64", + "timestamp": 1601470815576, + "version": "1.73.0" + }, + "boost-1.73.0-py38h06a4308_11.conda": { + "build": "py38h06a4308_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 h3ff78a5_11", + "py-boost 1.73.0 py38ha9443f7_11", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "691c2d83a3158ed8dc54df2784f8cc81", + "name": "boost", + "namespace": "python", + "sha256": "26f10c81ae0512e6107495413ad61f0fef4d5aba201bcbe25754f2746910dd10", + "size": 25120, + "subdir": "linux-64", + "timestamp": 1611677521145, + "version": "1.73.0" + }, + "boost-1.73.0-py38h06a4308_12.conda": { + "build": "py38h06a4308_12", + "build_number": 12, + "depends": [ + "libboost 1.73.0 h28710b8_12", + "py-boost 1.73.0 py38h51133e4_12", + "python >=3.8,<3.9.0a0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "469228ed23d8e72087a47468a4fea4c0", + "name": "boost", + "namespace": "python", + "sha256": "9a58bc72d1bb1a85953434de21247294dfc2c2d343503e3f559207beed6ef9b2", + "size": 16746, + "subdir": "linux-64", + "timestamp": 1655880121901, + "version": "1.73.0" + }, + "boost-1.73.0-py39h06a4308_11.conda": { + "build": "py39h06a4308_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 h3ff78a5_11", + "py-boost 1.73.0 py39ha9443f7_11", + "python >=3.9,<3.10.0a0" + ], + "license": "Boost-1.0", + "md5": "d3b712554a91353313cb755514bfa2d1", + "name": "boost", + "namespace": "python", + "sha256": "984513654f059eecdf5fea16a01f24df0e05db99e60157e5e2d41e7ae5ae84d0", + "size": 25141, + "subdir": "linux-64", + "timestamp": 1611677542448, + "version": "1.73.0" + }, + "boost-1.73.0-py39h06a4308_12.conda": { + "build": "py39h06a4308_12", + "build_number": 12, + "depends": [ + "libboost 1.73.0 h28710b8_12", + "py-boost 1.73.0 py39h51133e4_12", + "python >=3.9,<3.10.0a0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "42caaf2cf4c1352838547c15fe5104f8", + "name": "boost", + "namespace": "python", + "sha256": "08843c9af3bab0f99ccdf91cb72228c13f1269a6cbb3d09564ddc32072b3d95b", + "size": 16748, + "subdir": "linux-64", + "timestamp": 1655880127215, + "version": "1.73.0" + }, + "boost-cpp-1.65.1-h14c3975_4.conda": { + "build": "h14c3975_4", + "build_number": 4, + "depends": [ + "libboost 1.65.1 habcd387_4", + "libgcc-ng >=7.2.0" + ], + "license": "Boost-1.0", + "md5": "9f21157ed5c9a66b136ad10ca27e54cc", + "name": "boost-cpp", + "sha256": "7222d7b88bce1484fe22678f0da4e19e37f5f08f863a37b0c4f3c65190fe9205", + "size": 4463, + "subdir": "linux-64", + "timestamp": 1515095238142, + "version": "1.65.1" + }, + "boost-cpp-1.65.1-h2690925_3.conda": { + "build": "h2690925_3", + "build_number": 3, + "depends": [ + "libboost 1.65.1 h4055789_3" + ], + "license": "Boost-1.0", + "md5": "4424191719f1a0bab0c61167ee50a13d", + "name": "boost-cpp", + "sha256": "ce8b128a24e10f9825d07e7d28ae8ac05dde7cb8f1867d2c74b27a5ef5429b59", + "size": 4218, + "subdir": "linux-64", + "timestamp": 1508786615175, + "version": "1.65.1" + }, + "boost-cpp-1.67.0-h14c3975_4.conda": { + "build": "h14c3975_4", + "build_number": 4, + "depends": [ + "libboost 1.67.0 h46d08c1_4", + "libgcc-ng >=7.2.0" + ], + "license": "Boost-1.0", + "md5": "1d4db126fd0620fe08f43b437ac91dbb", + "name": "boost-cpp", + "sha256": "ab801f44767658f346e5d3b0c32ec39cb602feaf52213756404ede77beccbfb7", + "size": 11418, + "subdir": "linux-64", + "timestamp": 1530782098829, + "version": "1.67.0" + }, + "boost-cpp-1.71.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libboost 1.71.0 h97c9712_0", + "libgcc-ng >=7.3.0" + ], + "license": "Boost-1.0", + "md5": "579c364ca87d9c16ef50c29ae41e5708", + "name": "boost-cpp", + "sha256": "12e74e64a2937c1e91d7a0cb95784463b0453cd1e4e8a05bc6aef6764b92dd7a", + "size": 13612, + "subdir": "linux-64", + "timestamp": 1572610585349, + "version": "1.71.0" + }, + "boost-cpp-1.71.0-h7f8727e_1.conda": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libboost 1.71.0 haf77d95_1", + "libgcc-ng >=7.5.0" + ], + "license": "Boost-1.0", + "md5": "4426226059ee87e93dadf7fdc1bdf5b2", + "name": "boost-cpp", + "sha256": "b447b8bb5445442526795e562240970747b70aed66dcd0514cb8cba8133a326b", + "size": 15646, + "subdir": "linux-64", + "timestamp": 1642425076791, + "version": "1.71.0" + }, + "boost-cpp-1.73.0-h14c3975_10.conda": { + "build": "h14c3975_10", + "build_number": 10, + "depends": [ + "libboost 1.73.0 hf484d3e_10", + "libgcc-ng >=7.3.0" + ], + "license": "Boost-1.0", + "md5": "b6f690e73c16d769dee443674237aee9", + "name": "boost-cpp", + "sha256": "fc483ab36ed3472eb97fe0f65842a4775aa79d2aa092d742f9165ce91103aeab", + "size": 24109, + "subdir": "linux-64", + "timestamp": 1601386811313, + "version": "1.73.0" + }, + "boost-cpp-1.73.0-h14c3975_11.conda": { + "build": "h14c3975_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 hf484d3e_11", + "libgcc-ng >=7.3.0" + ], + "license": "Boost-1.0", + "md5": "b71cf6868b4d3f9122088a1afb7ec8b8", + "name": "boost-cpp", + "sha256": "0e41db316d6f1ae477140dd69724e2c871e63d512de6bd4d660cafd4d8eb13e0", + "size": 24093, + "subdir": "linux-64", + "timestamp": 1601471332071, + "version": "1.73.0" + }, + "boost-cpp-1.73.0-h27cfd23_11.conda": { + "build": "h27cfd23_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 h3ff78a5_11", + "libgcc-ng >=7.3.0" + ], + "license": "Boost-1.0", + "md5": "7cf1ce49541f70e7443cae9fc435510e", + "name": "boost-cpp", + "sha256": "045bd461b357392cda1ce477e26658e624bd96d906699db4a001c70d49f426f2", + "size": 25092, + "subdir": "linux-64", + "timestamp": 1611677121434, + "version": "1.73.0" + }, + "boost-cpp-1.73.0-h7b6447c_10.conda": { + "build": "h7b6447c_10", + "build_number": 10, + "depends": [ + "libboost 1.73.0 h37e3b65_10", + "libgcc-ng >=7.3.0" + ], + "license": "Boost-1.0", + "md5": "8b88f5ceb710d2fc4da0f69cb2cee0d7", + "name": "boost-cpp", + "sha256": "70a88e54420261f9e8b2f762c313b8e2b986606a48e611869de97251245d598b", + "size": 25247, + "subdir": "linux-64", + "timestamp": 1601386077245, + "version": "1.73.0" + }, + "boost-cpp-1.73.0-h7b6447c_11.conda": { + "build": "h7b6447c_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 h37e3b65_11", + "libgcc-ng >=7.3.0" + ], + "license": "Boost-1.0", + "md5": "e21f43514e7d9d617179bc12654fe0f2", + "name": "boost-cpp", + "sha256": "4ed598a2a846ff4c29d79b905b31d9ebe0f3a0cb476ac3233b7e8f2ec6f8cd67", + "size": 25790, + "subdir": "linux-64", + "timestamp": 1601470583445, + "version": "1.73.0" + }, + "boost-cpp-1.73.0-h7f8727e_12.conda": { + "build": "h7f8727e_12", + "build_number": 12, + "depends": [ + "libboost 1.73.0 h28710b8_12", + "libgcc-ng >=7.5.0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "2fca7d54dcdf329710dac0d315b730bf", + "name": "boost-cpp", + "sha256": "308e204cfe1b923b4178c64a2b16ce12eee0350aed6eb1eb874b2790a7685d31", + "size": 16780, + "subdir": "linux-64", + "timestamp": 1655879868222, + "version": "1.73.0" + }, + "boost_mp11-1.79.0-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "constrains": [ + "boost-cpp <0a0" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSL-1.0", + "license_family": "Other", + "md5": "796512fb67eda1b6c19aecb4c0c04846", + "name": "boost_mp11", + "sha256": "aac0cdd1c96fb0ab5d27b3f9512f3b2025ec145fa664b5ddc4a1e101114f6959", + "size": 27157, + "subdir": "linux-64", + "timestamp": 1659013173912, + "version": "1.79.0" + }, + "boto-2.48.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "267bf286194ac8356b8be8779e25f70c", + "name": "boto", + "sha256": "e50813564694dde4c9e04d8fb53f97c53b2344b73556a6cd021c06fa1cd4f713", + "size": 1247362, + "subdir": "linux-64", + "timestamp": 1530781166098, + "version": "2.48.0" + }, + "boto-2.48.0-py27h9556ac2_1.conda": { + "build": "py27h9556ac2_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c81ef27cb79a2ddcdf358d586aa55841", + "name": "boto", + "sha256": "3e698615a6c30f0b9ec6225ed6d8bf904f9356580f24c6ccc920c00b775f313c", + "size": 1247433, + "subdir": "linux-64", + "timestamp": 1505740882116, + "version": "2.48.0" + }, + "boto-2.48.0-py35h2cfd601_1.conda": { + "build": "py35h2cfd601_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "e81d744cdebeffb21bb331a70361b5df", + "name": "boto", + "sha256": "646df555f335dd8e60c703c815bc91c419e75c21e5d7184e3e5fe4aacdce7e5d", + "size": 1281623, + "subdir": "linux-64", + "timestamp": 1505740921493, + "version": "2.48.0" + }, + "boto-2.48.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "5d416c1f099a50d971cee38ecb01b387", + "name": "boto", + "sha256": "fb3d6f08d040e38e3603051a0c202b18bf25b4877904db7d992402dca9037a2a", + "size": 1272853, + "subdir": "linux-64", + "timestamp": 1530781214525, + "version": "2.48.0" + }, + "boto-2.48.0-py36h6e4cd66_1.conda": { + "build": "py36h6e4cd66_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c2adec33e7fa8578c6d9b353265d7fa9", + "name": "boto", + "sha256": "fc27a15fadc79bdc377b12a72c44b2db29ab1b3c51b334d0d905ade4d02346da", + "size": 1272490, + "subdir": "linux-64", + "timestamp": 1505740960874, + "version": "2.48.0" + }, + "boto-2.48.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "dbfd516f982a1837c40e26d810df4ba2", + "name": "boto", + "sha256": "117c8ee2fa8950eb3b4f7aa6397f2fca9dc6c78885a983400e7333d8f5f993dc", + "size": 1258789, + "subdir": "linux-64", + "timestamp": 1530781261443, + "version": "2.48.0" + }, + "boto-2.49.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "2a1f4d507c777084a4dadba859a83134", + "name": "boto", + "sha256": "746710084335a27f409dcb947b42554d46749709ec69c44073bc9128b38ba210", + "size": 1257658, + "subdir": "linux-64", + "timestamp": 1532524715871, + "version": "2.49.0" + }, + "boto-2.49.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "9549fa9b411ad0fc9f263247e0cd7fde", + "name": "boto", + "sha256": "dd219bc2ee3c7c7858ba00d335744822cabdd140ae6e3e7b400045c2f7a40dd7", + "size": 1293759, + "subdir": "linux-64", + "timestamp": 1640788595428, + "version": "2.49.0" + }, + "boto-2.49.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "9433b2726ce633d7c100347fc3300936", + "name": "boto", + "sha256": "08351857102d00b99b5229ce5636001b1661d2afc966ecfaf7185706063a1f3c", + "size": 1561159, + "subdir": "linux-64", + "timestamp": 1676906903510, + "version": "2.49.0" + }, + "boto-2.49.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "748d2853e6d77eabcf93f46dc9c098a3", + "name": "boto", + "sha256": "bb1d67ab4f55e080c546734c0fe121c7632c0241e77476cb28207cdaf72c1cf5", + "size": 1276815, + "subdir": "linux-64", + "timestamp": 1532524805640, + "version": "2.49.0" + }, + "boto-2.49.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1be7ed470fce11d82cf6cd0d617d1f7e", + "name": "boto", + "sha256": "6f5420d36aaaa9c42c15af9fc67f3013162cdb18eebacfaea326d87266252ed6", + "size": 1269180, + "subdir": "linux-64", + "timestamp": 1532524714494, + "version": "2.49.0" + }, + "boto-2.49.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4cf97441050974e6fe71360c2d4965da", + "name": "boto", + "sha256": "804d9a073925cbad7fd2ff24f6323325443e36e46a0dc8d69f9b5f8b46bdf20e", + "size": 1283457, + "subdir": "linux-64", + "timestamp": 1532524881080, + "version": "2.49.0" + }, + "boto-2.49.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "cfceed4c0e8727be8425000c0b9179a1", + "name": "boto", + "sha256": "f64cd7e309a0a769c723aafd0aecf154d0f2de4e5126d461ac18c60844bb061e", + "size": 1287224, + "subdir": "linux-64", + "timestamp": 1572357295863, + "version": "2.49.0" + }, + "boto3-1.24.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.2,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.10,<3.11.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5845c134cdaa32d2041c9d3b7ecb5fdb", + "name": "boto3", + "sha256": "6fa03f942b7acb4bbe865936f6a56c3ef1287035947b36d1338f6756b1221040", + "size": 118536, + "subdir": "linux-64", + "timestamp": 1654534691194, + "version": "1.24.2" + }, + "boto3-1.24.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.2,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.11,<3.12.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cf767bd40a9628d8f1372f2ed30db35d", + "name": "boto3", + "sha256": "ac0d73d8ec5aa612661b33bf00e95c3da60fe78346f959db965d3630c5c3c0af", + "size": 143981, + "subdir": "linux-64", + "timestamp": 1676830122666, + "version": "1.24.2" + }, + "boto3-1.24.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.2,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e1b17e403db4dba408576dd137795443", + "name": "boto3", + "sha256": "7088109af82e3b6dc518055c55aa2b79f2dc326619d7167563ee3866b8a254b6", + "size": 116882, + "subdir": "linux-64", + "timestamp": 1654534652033, + "version": "1.24.2" + }, + "boto3-1.24.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.2,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.8,<3.9.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7fc0e080c841644432fe7e452dcb7749", + "name": "boto3", + "sha256": "beb4bc23e506d9a67b71f5bf4eaa5526f979b1723a4beba6ab7cc7b2d495e2c7", + "size": 117575, + "subdir": "linux-64", + "timestamp": 1654534623511, + "version": "1.24.2" + }, + "boto3-1.24.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.2,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.9,<3.10.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "57896974e2f8eb612d5f05f88a3952de", + "name": "boto3", + "sha256": "15843ffdf66fbde0ed52ed54f696cfc06f5fa9477b82fa48dc65ca6f532b26c0", + "size": 117895, + "subdir": "linux-64", + "timestamp": 1654534720010, + "version": "1.24.2" + }, + "boto3-1.24.28-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.28,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.10,<3.11.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8fcb73039483aac915cda1bd9e8f1519", + "name": "boto3", + "sha256": "d7204c1f44d4aa6f8cdde09b475a0a7bc7a23eb48aa88a8396d7f39716c5e4a1", + "size": 118561, + "subdir": "linux-64", + "timestamp": 1657820151872, + "version": "1.24.28" + }, + "boto3-1.24.28-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.28,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.11,<3.12.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ee2216e26a7445a55aa4eb4882f68646", + "name": "boto3", + "sha256": "f372c3cf8acaea5e02396309c7728b39c6259fec7ce6da20abe93244db0ae556", + "size": 142872, + "subdir": "linux-64", + "timestamp": 1679335497387, + "version": "1.24.28" + }, + "boto3-1.24.28-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.28,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "24571403b3c130b7eab9dd9c59fed7c2", + "name": "boto3", + "sha256": "602b00ece779d4b5aa2616a44a57abd952745553426b543ee511f9347c4098d9", + "size": 116901, + "subdir": "linux-64", + "timestamp": 1657820238000, + "version": "1.24.28" + }, + "boto3-1.24.28-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.28,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.8,<3.9.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cccfef4815a96c7a66cda97ec8a33b7e", + "name": "boto3", + "sha256": "e04262d05ebacf8c8fb5864c9de2005d9e4903256a39923f6c53c01c5ec856c4", + "size": 117020, + "subdir": "linux-64", + "timestamp": 1657820180517, + "version": "1.24.28" + }, + "boto3-1.24.28-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.27.28,<1.28.0", + "jmespath >=0.7.1,<2.0.0", + "python >=3.9,<3.10.0a0", + "s3transfer >=0.6.0,<0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f393db1e1594b385eb29f9fffb9b4b46", + "name": "boto3", + "sha256": "61ceade6b5578bd23bdca9c16dd7993b863a95d7716558bb7a0e9b649e01a2ff", + "size": 116963, + "subdir": "linux-64", + "timestamp": 1657820209526, + "version": "1.24.28" + }, + "boto3-1.4.7-py27h11b3982_0.conda": { + "build": "py27h11b3982_0", + "build_number": 0, + "depends": [ + "botocore >=1.7.0,<1.8.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ecd3d9332de5435ec90d591d0c8dae2b", + "name": "boto3", + "sha256": "170545ddbae85d2e9347a777d421c2c2a86d2019560233859c47015ed227358e", + "size": 104978, + "subdir": "linux-64", + "timestamp": 1505957017930, + "version": "1.4.7" + }, + "boto3-1.4.7-py35h2161c00_0.conda": { + "build": "py35h2161c00_0", + "build_number": 0, + "depends": [ + "botocore >=1.7.0,<1.8.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fa4f4325e765631c15c01d6a9c92d02c", + "name": "boto3", + "sha256": "5d1e62b3a990a96c3e786d408c7b41a1caedd7878b90c66b1a4645a7830283b2", + "size": 108571, + "subdir": "linux-64", + "timestamp": 1505957034722, + "version": "1.4.7" + }, + "boto3-1.4.7-py36h4cc92d5_0.conda": { + "build": "py36h4cc92d5_0", + "build_number": 0, + "depends": [ + "botocore >=1.7.0,<1.8.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d06132e7de4c38de0b490b000cb77374", + "name": "boto3", + "sha256": "291d42b1d649c197a943ce091d80f0da9382c5ffc006eeebf942bea95ff32c02", + "size": 107601, + "subdir": "linux-64", + "timestamp": 1505957051488, + "version": "1.4.7" + }, + "boto3-1.4.8-py27h67bc657_0.conda": { + "build": "py27h67bc657_0", + "build_number": 0, + "depends": [ + "botocore >=1.8.0,<1.9.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1a04d4a715b0157df8f0f7e67fcedfa0", + "name": "boto3", + "sha256": "4f10e4d79b2f7418f6920794bf3de559bb174e9626eb5c861b0a5ee328ead577", + "size": 107060, + "subdir": "linux-64", + "timestamp": 1512061373088, + "version": "1.4.8" + }, + "boto3-1.4.8-py35h4658e5d_0.conda": { + "build": "py35h4658e5d_0", + "build_number": 0, + "depends": [ + "botocore >=1.8.0,<1.9.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9f05a695768e7224dcb7b3d480426a68", + "name": "boto3", + "sha256": "bf469bbeb8f72a1ac98f7348303beced09be07e4b9f310707bdd09752cdfcb21", + "size": 107481, + "subdir": "linux-64", + "timestamp": 1512061379255, + "version": "1.4.8" + }, + "boto3-1.4.8-py36h0bb4d74_0.conda": { + "build": "py36h0bb4d74_0", + "build_number": 0, + "depends": [ + "botocore >=1.8.0,<1.9.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "77f71a5d8b729ff4600fe0b58624f8bc", + "name": "boto3", + "sha256": "f488cbc39a778cd867a5524927a38d0b627aa1122d7fd2b345d84afa7e506f49", + "size": 108109, + "subdir": "linux-64", + "timestamp": 1512061375880, + "version": "1.4.8" + }, + "boto3-1.5.32-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.8.46,<1.9.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d8737abcb70b965fa05a6fc6f661e352", + "name": "boto3", + "sha256": "6ec8dfb001c8c624c48a7c9d2863fa148ed83f5f6fde88cf061bbfa07cf4ef9a", + "size": 105460, + "subdir": "linux-64", + "timestamp": 1519189157328, + "version": "1.5.32" + }, + "boto3-1.5.32-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "botocore >=1.8.46,<1.9.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "53b9305cf828c5e2499c683c942499df", + "name": "boto3", + "sha256": "69b84a0691ff50ef68dc68ef26d0ceb489b12bd210a509d915b7ea5dd95174b4", + "size": 107277, + "subdir": "linux-64", + "timestamp": 1519189191788, + "version": "1.5.32" + }, + "boto3-1.5.32-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.8.46,<1.9.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c0fa852ffa99ea112d1fece5dc9d662d", + "name": "boto3", + "sha256": "e467916e5235cf498d0977bfe6bca408f63047eb6f7b4fb10de1bead0878cc5c", + "size": 106358, + "subdir": "linux-64", + "timestamp": 1519189155479, + "version": "1.5.32" + }, + "boto3-1.6.18-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.9.18,<1.10.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "297a483ddcfd437e697f3f0dd1b61fe9", + "name": "boto3", + "sha256": "7fbf73d386635aa3694faa453b91d13601cb52a7a3b8f393a47a2284cd0f3c72", + "size": 107033, + "subdir": "linux-64", + "timestamp": 1522277941071, + "version": "1.6.18" + }, + "boto3-1.6.18-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "botocore >=1.9.18,<1.10.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c8ff29f8e2becf2e6b36589e2ad5335e", + "name": "boto3", + "sha256": "94aa74473d9c324710d7d1b52b23a13523f4fa6691b3f8c0a22f3dc3832e8db5", + "size": 108963, + "subdir": "linux-64", + "timestamp": 1522278028398, + "version": "1.6.18" + }, + "boto3-1.6.18-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.9.18,<1.10.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b9cac25489fa961b42d32505f67de9e4", + "name": "boto3", + "sha256": "691b37f3bf2ba325190601c5410689aadb042172bb334b1d1e8b3c5574fef47b", + "size": 106581, + "subdir": "linux-64", + "timestamp": 1522277961479, + "version": "1.6.18" + }, + "boto3-1.7.24-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.24,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ea26276ff7fdc02e88b2a6ef7387b35d", + "name": "boto3", + "sha256": "dd368d5e7574c48a509f94b5be231f6b945c79fb843209c200d3469be8ca6bdd", + "size": 107529, + "subdir": "linux-64", + "timestamp": 1526915374842, + "version": "1.7.24" + }, + "boto3-1.7.24-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.24,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5847e02581bf85febffb6f132054f234", + "name": "boto3", + "sha256": "f8b4539d981cc4c5380a583021a620f26b168db8880b450698f294d903e16318", + "size": 111369, + "subdir": "linux-64", + "timestamp": 1526915468300, + "version": "1.7.24" + }, + "boto3-1.7.24-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.24,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "769cfa1beba8f1b3f4cfd75467bbc6df", + "name": "boto3", + "sha256": "4ec7a84813dd195ac12ebec1c68973fbfc5a029a02d6083b8953db00091dce1e", + "size": 110383, + "subdir": "linux-64", + "timestamp": 1526916099021, + "version": "1.7.24" + }, + "boto3-1.7.32-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.32,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "72239268039d5ae870421ef956bcc694", + "name": "boto3", + "sha256": "7325a4c3faac202d8c914af780649c18c20b2ec9e40e1d925f2bf3c3c546d629", + "size": 109309, + "subdir": "linux-64", + "timestamp": 1528209128653, + "version": "1.7.32" + }, + "boto3-1.7.32-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.32,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7b10df051d5efccf63e0a4eee8899e7e", + "name": "boto3", + "sha256": "91345e8e0e37ce5e06e9e3302a3e3fb1e5fb557d4561b028da5e1303d9e1726e", + "size": 111465, + "subdir": "linux-64", + "timestamp": 1528209166051, + "version": "1.7.32" + }, + "boto3-1.7.32-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.32,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d41ac4544c64715469e3e15260f2f945", + "name": "boto3", + "sha256": "baa359fbf729b8d00cc5bb943c38dad55850706c5372c7276971c737e0366f38", + "size": 108763, + "subdir": "linux-64", + "timestamp": 1528209078931, + "version": "1.7.32" + }, + "boto3-1.7.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.4,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a92bb77fdff87fbcbf5d4ebd3f005a19", + "name": "boto3", + "sha256": "784489d268a8b0fb433e1505b2ac1a26d8b56819b76061e4eaffc143bcb54d66", + "size": 107011, + "subdir": "linux-64", + "timestamp": 1523980412013, + "version": "1.7.4" + }, + "boto3-1.7.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.4,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e222332c34d49fd4067cf56bbaea63d0", + "name": "boto3", + "sha256": "c1ad3294f8e340e999de5c691ac5d5ec5a6653607c22d2a8ddb779f9e0aed5a6", + "size": 108904, + "subdir": "linux-64", + "timestamp": 1523980518210, + "version": "1.7.4" + }, + "boto3-1.7.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.4,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c3e6f90951a8b6c8c78e33f29476971a", + "name": "boto3", + "sha256": "56085e6b293f7179e572344c0791add9bbb6d925c882a50d09c7deeed02ec06d", + "size": 106404, + "subdir": "linux-64", + "timestamp": 1523980522738, + "version": "1.7.4" + }, + "boto3-1.7.45-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.45,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c6783dc1dab41197dba039e13822d9c0", + "name": "boto3", + "sha256": "40a94d2f631e8d8bcf89e4d2a412730070d147d08963ffece5e5853b56b50e5d", + "size": 107667, + "subdir": "linux-64", + "timestamp": 1529947509809, + "version": "1.7.45" + }, + "boto3-1.7.45-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.45,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "93ff6ce92b9a9fdddde9323bde3b6d8a", + "name": "boto3", + "sha256": "28f2c7ba910da67bef5f6a92859e348436cb6f33245794d0051e0c48a9eb833f", + "size": 109785, + "subdir": "linux-64", + "timestamp": 1529947631645, + "version": "1.7.45" + }, + "boto3-1.7.45-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.45,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "17ff1b3d6f06a10054968399e3b2ecd4", + "name": "boto3", + "sha256": "cb8f9a11d7ecba004cc9f10ee3aa3aa93d89f099d45d2e0d4ad70cdd2a514f20", + "size": 110591, + "subdir": "linux-64", + "timestamp": 1529947454834, + "version": "1.7.45" + }, + "boto3-1.7.45-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.10.45,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "936a6c81b1fd50809a32a7607ad51aeb", + "name": "boto3", + "sha256": "6ab4cf99d6004d046c8ddc9a583da77966529fdacf479ca9d97565209921482e", + "size": 108950, + "subdir": "linux-64", + "timestamp": 1530888154408, + "version": "1.7.45" + }, + "boto3-1.7.62-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "botocore >=1.10.62,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7736e2c8cd5e66fcaa62ee871cfbccc4", + "name": "boto3", + "sha256": "7c4b247288c4fcfe3652ef7553c957fd3db8ac7ee47a424befc2068f0568f3d0", + "size": 107627, + "subdir": "linux-64", + "timestamp": 1532448324153, + "version": "1.7.62" + }, + "boto3-1.7.62-py27h28b3542_1.conda": { + "build": "py27h28b3542_1", + "build_number": 1, + "depends": [ + "botocore >=1.10.62,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "73aeadbb419a3ef222b49b10bff66d99", + "name": "boto3", + "sha256": "c97ab07f3f5330f570ede8456f6b002f321af9a18ecdd8235131868d4becbb4b", + "size": 107757, + "subdir": "linux-64", + "timestamp": 1534899981853, + "version": "1.7.62" + }, + "boto3-1.7.62-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "botocore >=1.10.62,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "357adc530621b497dbe89840cfa2ee42", + "name": "boto3", + "sha256": "3d6457e1b472947ce35b07f96c1a416c32ca2c1857bda94057ff674d5979d24e", + "size": 111633, + "subdir": "linux-64", + "timestamp": 1532448365968, + "version": "1.7.62" + }, + "boto3-1.7.62-py35h28b3542_1.conda": { + "build": "py35h28b3542_1", + "build_number": 1, + "depends": [ + "botocore >=1.10.62,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "66c46af9e224602e84bd0ed6f896f7f8", + "name": "boto3", + "sha256": "bc22cff1cb7e0cf0ede4474f3ad5a19548d1d3e0b296ddd6cb65f0e9ad1bb386", + "size": 109881, + "subdir": "linux-64", + "timestamp": 1534899929993, + "version": "1.7.62" + }, + "boto3-1.7.62-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "botocore >=1.10.62,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e6d894c2390970a513457f4c13bc0734", + "name": "boto3", + "sha256": "af4c0848993fa4d26293d5bded0831956a525dbfda9e835491456b028472f324", + "size": 108583, + "subdir": "linux-64", + "timestamp": 1532448374367, + "version": "1.7.62" + }, + "boto3-1.7.62-py36h28b3542_1.conda": { + "build": "py36h28b3542_1", + "build_number": 1, + "depends": [ + "botocore >=1.10.62,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "63ff5333f15f11789f8e451762d5f591", + "name": "boto3", + "sha256": "c1c304990326f0b603e5ebeeff85a2aceb946a4f7ddd0df15c8fa1f0132d0a29", + "size": 108793, + "subdir": "linux-64", + "timestamp": 1534900008147, + "version": "1.7.62" + }, + "boto3-1.7.62-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "botocore >=1.10.62,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4373d8e9c31ddd7e4c02e2f765b5b47b", + "name": "boto3", + "sha256": "eabfd51b45bde62490b7704d55ec1b5df7c2ed37f4b8dee704ffc09e40d7a455", + "size": 110758, + "subdir": "linux-64", + "timestamp": 1532448462584, + "version": "1.7.62" + }, + "boto3-1.7.62-py37h28b3542_1.conda": { + "build": "py37h28b3542_1", + "build_number": 1, + "depends": [ + "botocore >=1.10.62,<1.11.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "56d57ca8653fdb48b95b65619c6ecb46", + "name": "boto3", + "sha256": "0e73c7bcd3f97d03438fbec68c3d1cae5762ed1fa2199ac64c1a82ef03b6a34d", + "size": 109131, + "subdir": "linux-64", + "timestamp": 1534899956812, + "version": "1.7.62" + }, + "boto3-1.8.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.2,<1.12.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "20901e3f8bb437604c873aa48b67928c", + "name": "boto3", + "sha256": "2416d3a35590307a166bd62888eed8b902f8abb6f3e264268e9e0c118f65c2b4", + "size": 105934, + "subdir": "linux-64", + "timestamp": 1535493443040, + "version": "1.8.2" + }, + "boto3-1.8.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.2,<1.12.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3b2dc27a57487111c280184bdab3437a", + "name": "boto3", + "sha256": "98e626a2060959263d1c09e2292b253f7fcbcc4122cd13c7caa4477ab45ca1f0", + "size": 109741, + "subdir": "linux-64", + "timestamp": 1535493494363, + "version": "1.8.2" + }, + "boto3-1.8.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.2,<1.12.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "61b26d04566b34b0eb44523f1d9a666d", + "name": "boto3", + "sha256": "34d2809166000c5b3adb1890e3b5e40e6db761652f7042d9182cb77fa03be3f6", + "size": 107089, + "subdir": "linux-64", + "timestamp": 1535493496689, + "version": "1.8.2" + }, + "boto3-1.8.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.11.2,<1.12.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d1ae2eee9223348bbacbf1ab9632955b", + "name": "boto3", + "sha256": "dc6be39ec3ccab128d8f973f9f7a9cf89d375fe6a9680ab90fd65533665b319a", + "size": 107240, + "subdir": "linux-64", + "timestamp": 1535493451622, + "version": "1.8.2" + }, + "boto3-1.9.13-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.13,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a7ff66549cd2f4ad99f8f6fdf3ffd8c8", + "name": "boto3", + "sha256": "6d9258ba03199b47850c51972c7a2ce5656339f14d75908b9256c60809ad1093", + "size": 107839, + "subdir": "linux-64", + "timestamp": 1538172968610, + "version": "1.9.13" + }, + "boto3-1.9.13-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.13,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "29bdd754061cefa732123ab2e849658a", + "name": "boto3", + "sha256": "4b6a52b6c16c9afa3a52de74ff4c9a1792c6ffcb372cc9954611051051163f04", + "size": 108832, + "subdir": "linux-64", + "timestamp": 1538173036387, + "version": "1.9.13" + }, + "boto3-1.9.13-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.13,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "71301d3266a442ee9730deb9d10e5894", + "name": "boto3", + "sha256": "296cef77b4ccc8e8ac3a4c732a70bf167ee24916a53a1452dd56750dec658720", + "size": 109050, + "subdir": "linux-64", + "timestamp": 1538172966493, + "version": "1.9.13" + }, + "boto3-1.9.21-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.21,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "49de64b9c85fed4b24a5d7a20f5a1ab9", + "name": "boto3", + "sha256": "2d8d527e509f52429fa019828084430da3286a4208c2661a9b4e1d78d0a9663e", + "size": 106226, + "subdir": "linux-64", + "timestamp": 1539637016762, + "version": "1.9.21" + }, + "boto3-1.9.21-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.21,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6429a65c87b25aa946b126dc4c26ef84", + "name": "boto3", + "sha256": "579e9d75d8ce6aeae79c4cf5c7ca49d417a5a7552b085e818564d7f896ba8b5c", + "size": 107400, + "subdir": "linux-64", + "timestamp": 1539637037756, + "version": "1.9.21" + }, + "boto3-1.9.21-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.21,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1ec8a949f0aa48aff4a54a66d105ab15", + "name": "boto3", + "sha256": "36404d68bc1118dedc829d034c1a434f18b27d5dac7c5cb456301e655c00ec5c", + "size": 109168, + "subdir": "linux-64", + "timestamp": 1539637031785, + "version": "1.9.21" + }, + "boto3-1.9.35-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.35,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "44df2f78261bef5f30cbcd7bd2d8119e", + "name": "boto3", + "sha256": "33e6663b8ed397e4706be6cfbb5d04071f409688c37cba3001d84e938e6724f2", + "size": 106387, + "subdir": "linux-64", + "timestamp": 1541134353635, + "version": "1.9.35" + }, + "boto3-1.9.35-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.35,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7022858d79fe3c100ee6b16255fb8d2a", + "name": "boto3", + "sha256": "637bc131085ab74f1b3aed46c69ad767b7da8989d2f9065da37682c83c249922", + "size": 109117, + "subdir": "linux-64", + "timestamp": 1541134439198, + "version": "1.9.35" + }, + "boto3-1.9.35-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.35,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ab81a6e31a646a2a3fd459781f067fd7", + "name": "boto3", + "sha256": "ed30d47ffc38b5b08e46814680d9a4a1c7b44ab1cb03ea13d57714649485bb44", + "size": 107647, + "subdir": "linux-64", + "timestamp": 1541102824590, + "version": "1.9.35" + }, + "boto3-1.9.66-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.66,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dd09e3d17e7e86f29d628afea53345a8", + "name": "boto3", + "sha256": "d4588e7cfc13019f7af6875f44d4c4b37e79ac23d13e2349e7eb4fa321e20cd9", + "size": 108033, + "subdir": "linux-64", + "timestamp": 1545106058969, + "version": "1.9.66" + }, + "boto3-1.9.66-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.66,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b054c21a0f61456b7d07151b8c9b1cd5", + "name": "boto3", + "sha256": "4a60c5e571e824724f3e56b0e487e4a946592ffe5a6d4342c5b714505663b1d2", + "size": 107491, + "subdir": "linux-64", + "timestamp": 1545106050402, + "version": "1.9.66" + }, + "boto3-1.9.66-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.66,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "74c137d6d6391b0168e371d61d85cba9", + "name": "boto3", + "sha256": "a7e8719eacbe6a1397fac8289a3dcb48b0c2955b2f40507773e50ff1578a902d", + "size": 109345, + "subdir": "linux-64", + "timestamp": 1545106066876, + "version": "1.9.66" + }, + "boto3-1.9.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.7,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8ae9690a826baf32407bed8932cde9e1", + "name": "boto3", + "sha256": "e8b34f59340b5cd806d122e0680a192d52d26f75e96be161309d2d5711a031d6", + "size": 107735, + "subdir": "linux-64", + "timestamp": 1537466511886, + "version": "1.9.7" + }, + "boto3-1.9.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.7,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0b7e68f8ab2eff791e94fb1df79ce595", + "name": "boto3", + "sha256": "d69746b62f0deee95a053c331b9827e3dfc5596f2a88b3facf366f0448605242", + "size": 108176, + "subdir": "linux-64", + "timestamp": 1537466546956, + "version": "1.9.7" + }, + "boto3-1.9.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.7,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4255e6e71d802a273c0b5c4b7ed09a64", + "name": "boto3", + "sha256": "8d081394fcdca4788a32c9ea1c29d8c68b97dcb6ea621a612d18f1e407509010", + "size": 108771, + "subdir": "linux-64", + "timestamp": 1537466585628, + "version": "1.9.7" + }, + "boto3-1.9.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.7,<1.13.0", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "s3transfer >=0.1.10,<0.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ca0ccf4931f7fa1b7f03143a3e51b968", + "name": "boto3", + "sha256": "58ab98943c740088ad2831169f5cc06bb9f7c0b4f112126f6917cdc48832e99e", + "size": 107319, + "subdir": "linux-64", + "timestamp": 1537466512452, + "version": "1.9.7" + }, + "botocore-1.10.12-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a55a7e84005cbcf1ff307970c4cccb8e", + "name": "botocore", + "sha256": "99b04956be84e1fa41effe7b1fd3900fa5672a1e918e028b6228c642111a1092", + "size": 2453794, + "subdir": "linux-64", + "timestamp": 1527700806086, + "version": "1.10.12" + }, + "botocore-1.10.12-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7893fdded3f04a1630bce1c450ea4787", + "name": "botocore", + "sha256": "869d4ab541e094603075ee94b62c5f6a898221bd9a01e151565196f697ac6628", + "size": 2485727, + "subdir": "linux-64", + "timestamp": 1527700830712, + "version": "1.10.12" + }, + "botocore-1.10.12-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "117aba0ab15ea9152b806e7f6958adbd", + "name": "botocore", + "sha256": "512377c6e96313c0e0f4f7205d2ed2878c54e2643d57dff8818980f388be117d", + "size": 2442636, + "subdir": "linux-64", + "timestamp": 1527700758900, + "version": "1.10.12" + }, + "botocore-1.10.12-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "01b8738a5b8d300efd41200ea5a1a1d8", + "name": "botocore", + "sha256": "f8fe50aa7d7ded383b3e4eaa0d7e1e36f74545266ce0e3247a779938a58b9e35", + "size": 2437809, + "subdir": "linux-64", + "timestamp": 1530736797146, + "version": "1.10.12" + }, + "botocore-1.10.24-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3baca61b2c4e7df7ef9ecb322b676ea6", + "name": "botocore", + "sha256": "17bb645fb8e98ba101eefeb71c6baf390e6f9426e234b7b0741db3dfa2da93b4", + "size": 2470811, + "subdir": "linux-64", + "timestamp": 1526915030750, + "version": "1.10.24" + }, + "botocore-1.10.24-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bd3828c673a53105c9f035e1055249ea", + "name": "botocore", + "sha256": "89d2d711bcbc213550544c5b5021d501cc6b0726eedd4b058432f3487f2851c8", + "size": 2484301, + "subdir": "linux-64", + "timestamp": 1526915031664, + "version": "1.10.24" + }, + "botocore-1.10.24-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "05d73f2a0b69f2edb5f458c3419db7a9", + "name": "botocore", + "sha256": "d30420bd1fc081b68808893169d1fac818a3a5c833acf44081a702272c921484", + "size": 2460815, + "subdir": "linux-64", + "timestamp": 1526915002172, + "version": "1.10.24" + }, + "botocore-1.10.32-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "973093ca1e6e85143ac7993761cdf3f6", + "name": "botocore", + "sha256": "107d2d6933ccefd4aa418b2e809ee776686e6a0c041c963ef08d42fe6571e2e1", + "size": 2487363, + "subdir": "linux-64", + "timestamp": 1528208787830, + "version": "1.10.32" + }, + "botocore-1.10.32-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "58018bb71d3df56c893e5d4208c04a21", + "name": "botocore", + "sha256": "64c957021bac655d39465c35606d54a6d9e01a888ee6e6de655a119947b7bf95", + "size": 2520396, + "subdir": "linux-64", + "timestamp": 1528208799920, + "version": "1.10.32" + }, + "botocore-1.10.32-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2ab125991333a8a785429501fb6d1dd4", + "name": "botocore", + "sha256": "ac1c60ea8fd0bbea04fdacc58519c3b3e6ffa794d0132038f76d3d679865ba71", + "size": 2482052, + "subdir": "linux-64", + "timestamp": 1528208797049, + "version": "1.10.32" + }, + "botocore-1.10.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<2.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "256c7fe56b9534d0af1a787184911bda", + "name": "botocore", + "sha256": "9df2c54f4351bc567e027ac5548c6e6bbf5dad148020e4fd4b29ba44e502c043", + "size": 2419953, + "subdir": "linux-64", + "timestamp": 1523980253360, + "version": "1.10.4" + }, + "botocore-1.10.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<2.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5ca2865a660e96990cd45b4c2251083b", + "name": "botocore", + "sha256": "5b94055bc879e08ec6e0ea6ea3fff29bcd946628d1b4be5d4155db457835fb3a", + "size": 2453482, + "subdir": "linux-64", + "timestamp": 1523980280442, + "version": "1.10.4" + }, + "botocore-1.10.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<2.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5e62d34da6fd58acc3a2431a1bb1e7b1", + "name": "botocore", + "sha256": "367222321dc5fc21b8bc07db1f5256fdc696070589b368f7d2d6b0d3677926f3", + "size": 2409619, + "subdir": "linux-64", + "timestamp": 1523980309966, + "version": "1.10.4" + }, + "botocore-1.10.45-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0331d49b77f70f6359ad53af3cb02fb6", + "name": "botocore", + "sha256": "5759de853e1fdcc17fa5f8e9f76d37ea3aa9bc56c0fddfbf501fc91c4a2c1cb7", + "size": 2503524, + "subdir": "linux-64", + "timestamp": 1529947284826, + "version": "1.10.45" + }, + "botocore-1.10.45-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bdf159a572467e11a1f8d02c43ec55ec", + "name": "botocore", + "sha256": "2608c490fd9aa20b6603635659adf26ffc15cfbd46655a53300ebc9af636ba46", + "size": 2531846, + "subdir": "linux-64", + "timestamp": 1529947321349, + "version": "1.10.45" + }, + "botocore-1.10.45-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "507c9b13c3c6ff9bbfa362421ac57fe9", + "name": "botocore", + "sha256": "eb068d7014d87e653d152486727ec4cee70da3d63ed236440b83c3fdf9a47662", + "size": 2489973, + "subdir": "linux-64", + "timestamp": 1529947247654, + "version": "1.10.45" + }, + "botocore-1.10.45-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6eca583009cceee0032fae305cd80286", + "name": "botocore", + "sha256": "ac75c34787dc5425098516589f7eea47b82055cd1c49a3d83e47c7d1421833e4", + "size": 2475722, + "subdir": "linux-64", + "timestamp": 1530736747615, + "version": "1.10.45" + }, + "botocore-1.10.58-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "573b93894cf7e4282efa451da8b74555", + "name": "botocore", + "sha256": "e744a9c09a87ac4cd51d9f7d2e0c2b21515936f96ad586bb9a88dbc81afd0974", + "size": 2518613, + "subdir": "linux-64", + "timestamp": 1536111452248, + "version": "1.10.58" + }, + "botocore-1.10.58-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a33c458c05b017b88e1150556ad96a15", + "name": "botocore", + "sha256": "ca578d22e056b0672f4f1323694c8455abb5d765a8311a4a5e8af96f30faad70", + "size": 2551920, + "subdir": "linux-64", + "timestamp": 1536111488691, + "version": "1.10.58" + }, + "botocore-1.10.58-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "579ff6ab35caea80261e02c70751584e", + "name": "botocore", + "sha256": "5a15b41c7e0880caa4f194cb81696ceecdd783b6f40136bbc06f6d10407d91ed", + "size": 2517527, + "subdir": "linux-64", + "timestamp": 1536111450646, + "version": "1.10.58" + }, + "botocore-1.10.58-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "73740c42ef7a35dd7fb277cbafc7da75", + "name": "botocore", + "sha256": "9aba3a909469591c6a1e45e2598f6edbe81b0a8db8dfd26a719fcaf8b50bf95e", + "size": 2497779, + "subdir": "linux-64", + "timestamp": 1536113143009, + "version": "1.10.58" + }, + "botocore-1.10.62-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3a5be546906db5d2e4643324840b83c2", + "name": "botocore", + "sha256": "26177d29e318c62da0ed4c00d9c2d2dfd2ca44f6e62851511155f82f0a5238c6", + "size": 2519673, + "subdir": "linux-64", + "timestamp": 1532448144246, + "version": "1.10.62" + }, + "botocore-1.10.62-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5c54dd989e2a8b574dc8b5624e57c8ad", + "name": "botocore", + "sha256": "54e0ca60cd785c95395bb9080df8a7f206d6053bbeedc4e30ef11e707e626bf8", + "size": 2525530, + "subdir": "linux-64", + "timestamp": 1534352421062, + "version": "1.10.62" + }, + "botocore-1.10.62-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "449e82aaece51d78c2ad45b9e6fe0ca0", + "name": "botocore", + "sha256": "8dc6562e302a5c035c5d23cbac2772fe43641b7127f139e1ab44ac9b3f6b81af", + "size": 2559637, + "subdir": "linux-64", + "timestamp": 1532448153588, + "version": "1.10.62" + }, + "botocore-1.10.62-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f6a150b6e129ef2dc09c962b02033b1a", + "name": "botocore", + "sha256": "eab65f22b954de988b7b1ffe270c245da156d4241e640778bdb5ee71aefd2aa9", + "size": 2559930, + "subdir": "linux-64", + "timestamp": 1534352470318, + "version": "1.10.62" + }, + "botocore-1.10.62-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "552ab33ef6121dabc4ded8de0c804814", + "name": "botocore", + "sha256": "c5366ad5c439093ad5e20db8fb37aae7a0066313f867e10a24e5e499f15685a5", + "size": 2514257, + "subdir": "linux-64", + "timestamp": 1532448108012, + "version": "1.10.62" + }, + "botocore-1.10.62-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "366e057e0ba4f7d33bcaae45ec80775a", + "name": "botocore", + "sha256": "1ed5ded86613b115c459176f6a96e5bda6ddb667a0be9c60f7aaf214df0025b3", + "size": 2513913, + "subdir": "linux-64", + "timestamp": 1534352520978, + "version": "1.10.62" + }, + "botocore-1.10.62-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "274e346bff4e3c203f3da4ec1def8ed7", + "name": "botocore", + "sha256": "4b7e284c3f272d90e75fd3733ae32fcbe28d93ffce39bf710f18b7539990342d", + "size": 2502258, + "subdir": "linux-64", + "timestamp": 1532448208128, + "version": "1.10.62" + }, + "botocore-1.10.62-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8431b3adff944f31c399bd67d697e20d", + "name": "botocore", + "sha256": "128d1eee12a0acb8572f8a67317f400ae0c28b65bf94b155e0cadccf5770de36", + "size": 2507290, + "subdir": "linux-64", + "timestamp": 1534352374688, + "version": "1.10.62" + }, + "botocore-1.11.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6c059a6750652cf2c03b60179117e766", + "name": "botocore", + "sha256": "c06141f546c532eb13198f4d3c1fb02b53300d25c730801a322c300ecec98ee8", + "size": 2558379, + "subdir": "linux-64", + "timestamp": 1535493282567, + "version": "1.11.2" + }, + "botocore-1.11.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e3c6a8420a9318dfb7823b8bec0e6aa9", + "name": "botocore", + "sha256": "fcf9d81f3491daa948decda6fce52964699456e66b50511b24c916d5ab9aba2c", + "size": 2577078, + "subdir": "linux-64", + "timestamp": 1535493323777, + "version": "1.11.2" + }, + "botocore-1.11.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0a505363d7001d9d02eba02aba9faa1a", + "name": "botocore", + "sha256": "24990b872a153cf51c3947c68b74252be9cdc78cdda0a77a998e7f47147e0d4e", + "size": 2544449, + "subdir": "linux-64", + "timestamp": 1535493294918, + "version": "1.11.2" + }, + "botocore-1.11.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "10f5fbd8a97f8c1fc09a33126c491b16", + "name": "botocore", + "sha256": "b41c6558ae21db2f4646a2f28b8dfee1f360787d3ba9ea302480e3e3f06f44ab", + "size": 2533488, + "subdir": "linux-64", + "timestamp": 1535493292064, + "version": "1.11.2" + }, + "botocore-1.12.14-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cbfdb7416b93f4058ca01c2e599ebbb6", + "name": "botocore", + "sha256": "0b79c17131a43acd5240f1b2822e95e5847dd673888627b6d80317b4a7901a00", + "size": 2587129, + "subdir": "linux-64", + "timestamp": 1538172860881, + "version": "1.12.14" + }, + "botocore-1.12.14-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6025c51c86a775644bf3b5ca8a4c8576", + "name": "botocore", + "sha256": "cb0dc936f091236b5e7ece5555875feb0eea3c6b8904f31c6f59e865345601d6", + "size": 2573315, + "subdir": "linux-64", + "timestamp": 1538172850112, + "version": "1.12.14" + }, + "botocore-1.12.14-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "09ff1efd0a0a09e492574f6236b742e1", + "name": "botocore", + "sha256": "d2b7428c9d362786bfb4316554011cac3adc0ec0ef7d73d759ed61b1acfc7a8f", + "size": 2566283, + "subdir": "linux-64", + "timestamp": 1538172822368, + "version": "1.12.14" + }, + "botocore-1.12.23-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fd8d56a1111d5a4c22ca381b2a2a22e2", + "name": "botocore", + "sha256": "2af2c04d3c767779fff0377bdbd5f82ab2f0ee62aee7e71009b7259d04e18612", + "size": 2586155, + "subdir": "linux-64", + "timestamp": 1539470370195, + "version": "1.12.23" + }, + "botocore-1.12.23-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4593c46170fde49b5c32f0381a7802ef", + "name": "botocore", + "sha256": "e6aaaf46e62cdde13a9f1543f0c382213c52a5788bf7a578d790cd2baa606c01", + "size": 2579607, + "subdir": "linux-64", + "timestamp": 1539470373649, + "version": "1.12.23" + }, + "botocore-1.12.23-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "39654ad86bdf7d4861b3a1965e6f5544", + "name": "botocore", + "sha256": "defe6be971ef5d539caec19f287d7d200f16dfabb63bc80f747630e292ba811d", + "size": 2565874, + "subdir": "linux-64", + "timestamp": 1539470373509, + "version": "1.12.23" + }, + "botocore-1.12.35-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.25" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "67ccf5da09a1ab7abe3d040f6bf7cdf0", + "name": "botocore", + "sha256": "4bb6119f80b788c58e78e89fb973852049edd6e8be7ffcea3843224fa6e5dcba", + "size": 2613239, + "subdir": "linux-64", + "timestamp": 1541134545527, + "version": "1.12.35" + }, + "botocore-1.12.35-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.25" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c71643068ab1179ae3b6143acc706940", + "name": "botocore", + "sha256": "a2165a7a2ca9a2116aad60dbbc31ee7adc69ae27d3e4467407e2a14dce86dfd9", + "size": 2604097, + "subdir": "linux-64", + "timestamp": 1541134514085, + "version": "1.12.35" + }, + "botocore-1.12.35-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.25" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4a70764c24378488145da54bbd61cdcd", + "name": "botocore", + "sha256": "dbba5bf6457ecc414155937b8d769158a3cfa478777e24370950a49bcdc8a773", + "size": 2590159, + "subdir": "linux-64", + "timestamp": 1541134401811, + "version": "1.12.35" + }, + "botocore-1.12.49-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.25" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f3b9ac026d2de873b8b3aa584a4dc0e3", + "name": "botocore", + "sha256": "f778bdacf21e24c5e88f646711f71daf18b850dd1eaa4421d05388b9fca3bb06", + "size": 2689715, + "subdir": "linux-64", + "timestamp": 1545161958654, + "version": "1.12.49" + }, + "botocore-1.12.49-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.25" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4ea6e50bffe0d73a54f68d21e016d56c", + "name": "botocore", + "sha256": "2d6b12a723cc3ca6fed587eeab81bb5e47982656626ca81040a16cd5b6cc8a6a", + "size": 2677771, + "subdir": "linux-64", + "timestamp": 1545161987543, + "version": "1.12.49" + }, + "botocore-1.12.49-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.25" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1cc45810b0619de836a8f2a85e64b33e", + "name": "botocore", + "sha256": "cfef4991f274a371143373182a5696ca1aa8a0d6cb27e4e194fbe73042bb064a", + "size": 2669672, + "subdir": "linux-64", + "timestamp": 1545161987825, + "version": "1.12.49" + }, + "botocore-1.12.67-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.25" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3cc71c4eb03ccfb9c146ba8e5f2a27ee", + "name": "botocore", + "sha256": "0a38471b682447f2f4b3bc483bf34f7dd8aba64f0629a1009386fb900c14a21b", + "size": 2817757, + "subdir": "linux-64", + "timestamp": 1545105871995, + "version": "1.12.67" + }, + "botocore-1.12.67-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.25" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4710629431d16606853949371848da02", + "name": "botocore", + "sha256": "c929aa974a442952c42822a139dd18438f1571fdeb88c6d2b33e0be2d4da8f9c", + "size": 2805151, + "subdir": "linux-64", + "timestamp": 1545105873265, + "version": "1.12.67" + }, + "botocore-1.12.67-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.25" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2ef1fb7a6ccb71db638814bf039003d9", + "name": "botocore", + "sha256": "ef78fc5e1c8d7771cdbf7e16b5cc908a09a6c9abf780c6faaedaf6e3b647efe7", + "size": 2801564, + "subdir": "linux-64", + "timestamp": 1545105880652, + "version": "1.12.67" + }, + "botocore-1.12.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "af89173a516ce04254df3c79f85fe35a", + "name": "botocore", + "sha256": "e11bc7f355ef0b73c9a024e0f85dc5c6ce8a851af4405dc945f7ba78e94ca015", + "size": 2578477, + "subdir": "linux-64", + "timestamp": 1537466407911, + "version": "1.12.7" + }, + "botocore-1.12.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9d0ed3aa769f77dd84903fc52e41380a", + "name": "botocore", + "sha256": "275a6a1b0d4a2c5646511d11945441205c7049babd1875e47719b5112f5d730b", + "size": 2596208, + "subdir": "linux-64", + "timestamp": 1537466412051, + "version": "1.12.7" + }, + "botocore-1.12.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "104874ede14bf53786956df215774cc9", + "name": "botocore", + "sha256": "22df1249e1342a76217178b6da13f851f1c91dc74b879298f7cbd9e42aca0bd3", + "size": 2566966, + "subdir": "linux-64", + "timestamp": 1537466396007, + "version": "1.12.7" + }, + "botocore-1.12.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.20,<1.24" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "863980595c739d68d913098e97bc99a4", + "name": "botocore", + "sha256": "c07c3d8ec16bb0a032efc04bbd871edec2c126d851da0da697a14438efee95ee", + "size": 2558689, + "subdir": "linux-64", + "timestamp": 1537466408954, + "version": "1.12.7" + }, + "botocore-1.27.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f2718bc18ec62dd174a7a7007ab11532", + "name": "botocore", + "sha256": "a3e1796d9f99902b1ae70375fea339ac46834ae43dbb14e2b50e926d10ce5a28", + "size": 4765708, + "subdir": "linux-64", + "timestamp": 1654523912261, + "version": "1.27.2" + }, + "botocore-1.27.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "85379ff2c3fe2a372f8587e06b775e25", + "name": "botocore", + "sha256": "96909326231b7cbb221ff33cd64a684b6e5ac6beb70be3b3e9776d91320331e4", + "size": 4769354, + "subdir": "linux-64", + "timestamp": 1654523751049, + "version": "1.27.2" + }, + "botocore-1.27.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2ae8edf8ffdf8822b5bdc002432a439f", + "name": "botocore", + "sha256": "99a23258c7a35b7328f84a0a4dba3ea7fad78a0b48924f029b196abdb56380f3", + "size": 4770637, + "subdir": "linux-64", + "timestamp": 1654523851287, + "version": "1.27.2" + }, + "botocore-1.27.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9800b4e2cd2ec09b62a863a143daacf3", + "name": "botocore", + "sha256": "3978b69d35eee0342faecf02b26f300f639468e62363694379828b68c3525b2c", + "size": 4758974, + "subdir": "linux-64", + "timestamp": 1654523802138, + "version": "1.27.2" + }, + "botocore-1.27.28-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f3cc24f961591816ede1dd1f08cf4960", + "name": "botocore", + "sha256": "81063c733b950ccb01065a8c2ce39c054bcce44d5cf88c3da6f6f72a8502b20d", + "size": 4844319, + "subdir": "linux-64", + "timestamp": 1657739695346, + "version": "1.27.28" + }, + "botocore-1.27.28-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c03f0dc9160c12f667efde988097bcd2", + "name": "botocore", + "sha256": "0a63acef0bb5a587f4b25aa0ec3dc015744613ad2ce6666b31bb82c15c263e41", + "size": 4839916, + "subdir": "linux-64", + "timestamp": 1657739630194, + "version": "1.27.28" + }, + "botocore-1.27.28-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ab7a982095559e226618c5e85496a9d6", + "name": "botocore", + "sha256": "21b45aba0ad4bf41ddc3da6715511acd2a987882d8fea4b8684a695ee0639b8b", + "size": 4847099, + "subdir": "linux-64", + "timestamp": 1657739525662, + "version": "1.27.28" + }, + "botocore-1.27.28-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e5ff4ab58c32f5889aa585561652edcc", + "name": "botocore", + "sha256": "c2ff5bf8ef50339e86b0dbe336b44158d0a842b31a09dc29d0a2c27372e4c156", + "size": 4842578, + "subdir": "linux-64", + "timestamp": 1657739578013, + "version": "1.27.28" + }, + "botocore-1.27.59-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "babc187a27f3168bdca0d81c14309cbd", + "name": "botocore", + "sha256": "cae2af2aea43da26a895b3dc83442414063f5a8d472483e8f76fbd127341d0ad", + "size": 5931709, + "subdir": "linux-64", + "timestamp": 1667494149317, + "version": "1.27.59" + }, + "botocore-1.27.59-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "84d3d0378fe1fc3b1f0c2d6034cfc137", + "name": "botocore", + "sha256": "df2d4e05dc38a4f7cdcdb9fb86e7db544fc3e6d9ba1910b1adbc60d6616abfc8", + "size": 5376932, + "subdir": "linux-64", + "timestamp": 1676826996328, + "version": "1.27.59" + }, + "botocore-1.27.59-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9d2b078c1fb5eea55cb2f256b04d0bf1", + "name": "botocore", + "sha256": "a560e0d787faed778e6390dd6b345b3512bf51fda7877ca3febf957399de7a13", + "size": 5922591, + "subdir": "linux-64", + "timestamp": 1667494099564, + "version": "1.27.59" + }, + "botocore-1.27.59-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f410acb6528eb2c6ed074ac7bb4707cc", + "name": "botocore", + "sha256": "2847cae7f05a765227f8fc8fe722549b963207efa60096485f44226d6ef2b17f", + "size": 5926081, + "subdir": "linux-64", + "timestamp": 1667494046753, + "version": "1.27.59" + }, + "botocore-1.27.59-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jmespath >=0.7.1,<2.0.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1,<3.0.0", + "urllib3 >=1.25.4,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "56d7c7df5edd5f3c828d8a881f421da2", + "name": "botocore", + "sha256": "2a717a81f545ecfdbba8706e4502cfa63ef605b41e58300a2c48b67ef3e8d73d", + "size": 5925214, + "subdir": "linux-64", + "timestamp": 1667494199151, + "version": "1.27.59" + }, + "botocore-1.5.78-py27hd4e8fcf_0.conda": { + "build": "py27hd4e8fcf_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ef20f62f7465bbdf5ba79b9eb5ed0f1a", + "name": "botocore", + "sha256": "2d72094b5a09ba7ad66fd0f307101df3639f9389906b5ed804709b7a3263d95c", + "size": 2032854, + "subdir": "linux-64", + "timestamp": 1507368009467, + "version": "1.5.78" + }, + "botocore-1.5.78-py35h796d66b_0.conda": { + "build": "py35h796d66b_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "59167bcdcce18d2425fb1819b7d75ff3", + "name": "botocore", + "sha256": "3426aaafcf6b9d8e872c93ce5d3842d5fe976c9c2cd0d5f95e622c2181608208", + "size": 2064457, + "subdir": "linux-64", + "timestamp": 1507368021215, + "version": "1.5.78" + }, + "botocore-1.5.78-py36h2caa6e9_0.conda": { + "build": "py36h2caa6e9_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "232d100723b477c9fd858117a7ee607d", + "name": "botocore", + "sha256": "889df50a7fab55b92b331a6cd43d131a953db4d13de0939e7045eb328782ae86", + "size": 2027025, + "subdir": "linux-64", + "timestamp": 1507368015422, + "version": "1.5.78" + }, + "botocore-1.7.14-py27h48f721b_0.conda": { + "build": "py27h48f721b_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3b745335c4d04df9eeea5434485fc8d8", + "name": "botocore", + "sha256": "cd2117aa36960250dfff462f08bb789cf06ad9daa197c31558617af7c967353d", + "size": 2107876, + "subdir": "linux-64", + "timestamp": 1505956926449, + "version": "1.7.14" + }, + "botocore-1.7.14-py35h1ea1bdf_0.conda": { + "build": "py35h1ea1bdf_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "623f1508ff5e550ec85069f1cff8cc46", + "name": "botocore", + "sha256": "e4b38630c1e2399ba93513e27f0c906b45a151253d41e0875695d8d77d6fc733", + "size": 2137690, + "subdir": "linux-64", + "timestamp": 1505956959560, + "version": "1.7.14" + }, + "botocore-1.7.14-py36h38b1d61_0.conda": { + "build": "py36h38b1d61_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3f3afa47ce707728daadfbee8056ced2", + "name": "botocore", + "sha256": "34f572d1b052e80a4955fa1efdd44a31d2984c446d3d20cf50d9d1218c379a84", + "size": 2095722, + "subdir": "linux-64", + "timestamp": 1505956993084, + "version": "1.7.14" + }, + "botocore-1.7.20-py27h89f32a6_0.conda": { + "build": "py27h89f32a6_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c80140449f54102b17186aee67601393", + "name": "botocore", + "sha256": "d55935ef2a9523589db804663fdb99694678012c55f9f7ce5a637018af7f38b3", + "size": 2104759, + "subdir": "linux-64", + "timestamp": 1507364922448, + "version": "1.7.20" + }, + "botocore-1.7.20-py35h627d9b9_0.conda": { + "build": "py35h627d9b9_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6e769069b91811fedacca40a06069a09", + "name": "botocore", + "sha256": "94c77f2f3393db60ef1446f40601a7171370cd35c8b0ae0e8ed70188a5964e3d", + "size": 2141449, + "subdir": "linux-64", + "timestamp": 1507364941552, + "version": "1.7.20" + }, + "botocore-1.7.20-py36h085fff1_0.conda": { + "build": "py36h085fff1_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bc15d26e146d62bce0bbf47ba57fae04", + "name": "botocore", + "sha256": "fdb6dd5b4d1d04ba088e3799c24c0ed4ab7216ef8893a2666afff27f2ca4e2d7", + "size": 2102967, + "subdir": "linux-64", + "timestamp": 1507364959402, + "version": "1.7.20" + }, + "botocore-1.7.40-py27h5bcc104_0.conda": { + "build": "py27h5bcc104_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "01d42e3ffbe9d024be90b9aebf008dd6", + "name": "botocore", + "sha256": "8dc1f56bba9653fa4805f7c3ddb265af52454fdbace883bcb1afd7734d6665fc", + "size": 2136764, + "subdir": "linux-64", + "timestamp": 1511928319887, + "version": "1.7.40" + }, + "botocore-1.7.40-py35hd756da5_0.conda": { + "build": "py35hd756da5_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b3b18b349cb909eb0e25e85950aa614d", + "name": "botocore", + "sha256": "55468a4002b92e23ce7ba4d7c395ed9b272ffad3b03853378cc818cf26e43344", + "size": 2162835, + "subdir": "linux-64", + "timestamp": 1511928329843, + "version": "1.7.40" + }, + "botocore-1.7.40-py36h1ef979c_0.conda": { + "build": "py36h1ef979c_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3dea2ae947f985e11f23c6dc5fb62f30", + "name": "botocore", + "sha256": "a6b7f51ce7251596f077eba20ab78edd1eb54f23ab675d6c0b35ec4dc73be6ae", + "size": 2128014, + "subdir": "linux-64", + "timestamp": 1511928342972, + "version": "1.7.40" + }, + "botocore-1.7.5-py27h902c29d_0.conda": { + "build": "py27h902c29d_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fa3e22ef11b185b4d04f32e619349235", + "name": "botocore", + "sha256": "8af3ae90dbddc5a94f32adf30bb85f076508de52bf6d75003ee91a951b8a584e", + "size": 2099784, + "subdir": "linux-64", + "timestamp": 1507371777862, + "version": "1.7.5" + }, + "botocore-1.7.5-py35h5941762_0.conda": { + "build": "py35h5941762_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d82e5c7e0c2c1de526103510d5f075d9", + "name": "botocore", + "sha256": "7cc73f5e6aa404be3a26036f641a73b09cb2d8ea0bad2d376c355da32a95bd43", + "size": 2130228, + "subdir": "linux-64", + "timestamp": 1507371771755, + "version": "1.7.5" + }, + "botocore-1.7.5-py36ha445209_0.conda": { + "build": "py36ha445209_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6a5e5e33d4b41e3887740961c64474f3", + "name": "botocore", + "sha256": "e4d6f7a49746063367241360fe0266bfa00253b23d0667d76373ad12c1688540", + "size": 2084838, + "subdir": "linux-64", + "timestamp": 1507371803010, + "version": "1.7.5" + }, + "botocore-1.8.21-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9e4e9fbedacbbf3d7d4fb2b200f4c3b4", + "name": "botocore", + "sha256": "73ee0f9ee4c54bebde13a9057d7536a8a8e3f32ebeb0b21905580c9c10660093", + "size": 2344827, + "subdir": "linux-64", + "timestamp": 1530736883145, + "version": "1.8.21" + }, + "botocore-1.8.21-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b363d70cfea6f1e1d5010c9bb1f9f900", + "name": "botocore", + "sha256": "a96530d6f0ea3a8bba3e70a97d0467502b646a1b691de70be619cdd63d225227", + "size": 2372817, + "subdir": "linux-64", + "timestamp": 1534352574639, + "version": "1.8.21" + }, + "botocore-1.8.21-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4151231aa1b56ddd921dc1f06bab4735", + "name": "botocore", + "sha256": "b8f740a9dcb006c928a5557f79e83530a4187ef1a2299237176480cf3c73ba4b", + "size": 2338333, + "subdir": "linux-64", + "timestamp": 1530736842824, + "version": "1.8.21" + }, + "botocore-1.8.21-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3b2a6e138f528b665992677900220c74", + "name": "botocore", + "sha256": "ce83d5408d1e69097de7a7e0c2543773d6fae34bc0e620a15b4ec9391452a87b", + "size": 2324101, + "subdir": "linux-64", + "timestamp": 1530736926495, + "version": "1.8.21" + }, + "botocore-1.8.46-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "893681abaf2196875403e203f8a6e487", + "name": "botocore", + "sha256": "65c96d2a3b7b2f3d7e2e8624a44677b3cd5d0242e526c87c0ef723a1e0fb8595", + "size": 2358221, + "subdir": "linux-64", + "timestamp": 1519157353811, + "version": "1.8.46" + }, + "botocore-1.8.46-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3d13ff4ded707d9a1557b02b39460b95", + "name": "botocore", + "sha256": "0542b052a0bda592d02bacde2f9801d198eb407f2197e43df67880beac00969c", + "size": 2382880, + "subdir": "linux-64", + "timestamp": 1519157373176, + "version": "1.8.46" + }, + "botocore-1.8.46-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6b4b7d8c65a54f720b066c435029832d", + "name": "botocore", + "sha256": "919ca6563558f366c2d874d7eb4fb945d0d93057988a50bfe2b801648b53b17f", + "size": 2345131, + "subdir": "linux-64", + "timestamp": 1519157345099, + "version": "1.8.46" + }, + "botocore-1.8.5-py27h60a76c8_0.conda": { + "build": "py27h60a76c8_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2092ecde0708ceabeb8bea21e7869543", + "name": "botocore", + "sha256": "a73f64edc5ada079ca0871329a09e2f5f08cbf277a771aa1a67af65498d9a914", + "size": 2316677, + "subdir": "linux-64", + "timestamp": 1512024626509, + "version": "1.8.5" + }, + "botocore-1.8.5-py35hbe5d90e_0.conda": { + "build": "py35hbe5d90e_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9c0985304ddedb54d4dcb6da7b85b133", + "name": "botocore", + "sha256": "edb0a28fd997e2d5dc4cb5f6a554cc69f0d5a2ede22ce2afa3e9de9df34bfd39", + "size": 2333315, + "subdir": "linux-64", + "timestamp": 1512024602762, + "version": "1.8.5" + }, + "botocore-1.8.5-py36hac303ac_0.conda": { + "build": "py36hac303ac_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<3.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2a39a06aa86abd2db9014df634e26b37", + "name": "botocore", + "sha256": "5437e6292cf085bb27192587368a446583f8a7fbf0f0a30c2d8735a2a263e093", + "size": 2302388, + "subdir": "linux-64", + "timestamp": 1512024647749, + "version": "1.8.5" + }, + "botocore-1.9.18-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1,<2.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5bfb465c8531efc73deaacb5f78b260b", + "name": "botocore", + "sha256": "080a1ff80d649f69a1f725f17ce66fa916b271b3902afd8239e9cc009d6d25a7", + "size": 2374144, + "subdir": "linux-64", + "timestamp": 1522277694343, + "version": "1.9.18" + }, + "botocore-1.9.18-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1,<2.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "127d5bdc549c1fd64778b44fcdbbae13", + "name": "botocore", + "sha256": "7d892b730b56716e08a26a02082a19cf197cce6428b0327d1996220ac2a79db0", + "size": 2398495, + "subdir": "linux-64", + "timestamp": 1522277697313, + "version": "1.9.18" + }, + "botocore-1.9.18-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils >=0.10", + "jmespath >=0.7.1,<1.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1,<2.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ba486ed4be2f43aa21b4e5e134b1423a", + "name": "botocore", + "sha256": "af9b9aa45d3ce89715002e1fdea98d495e35ed0987c2c50bcf278142b7c10e79", + "size": 2363360, + "subdir": "linux-64", + "timestamp": 1522277757370, + "version": "1.9.18" + }, + "bottlechest-0.7.1-py27hdd07704_1.conda": { + "build": "py27hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "e52a22c1b51e251838f6289e5a371c44", + "name": "bottlechest", + "sha256": "c9183ee937b52a7d32648b61aa547b6d933f3167612d719161d477747d925c3c", + "size": 1418342, + "subdir": "linux-64", + "timestamp": 1537300478330, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py310h9102076_1.conda": { + "build": "py310h9102076_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "4a7c68d61e66fd213b267b91ba1a113e", + "name": "bottlechest", + "sha256": "a26b6971d6da287d36fdcb658587845d4fa2a25fa992c9fea842b0000540f6e4", + "size": 5464881, + "subdir": "linux-64", + "timestamp": 1641556019107, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py35hdd07704_1.conda": { + "build": "py35hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "06101b7e33c94b2fb2a624e8add18ff0", + "name": "bottlechest", + "sha256": "84ee3c4380fe5c2ace29dbc9b8018b2e1187de6b16e8afe7366179c78c974476", + "size": 1364346, + "subdir": "linux-64", + "timestamp": 1537300534838, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py36h6323ea4_1.conda": { + "build": "py36h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "77a9692d30223675812d9c070ab2f328", + "name": "bottlechest", + "sha256": "c0d47b1986e9cbec416d6ff1cb722bdfd6378e872c9642921e512aa2128c3101", + "size": 1405309, + "subdir": "linux-64", + "timestamp": 1614264423808, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py36hdd07704_1.conda": { + "build": "py36hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "2f20c9aade57ef184515060020583352", + "name": "bottlechest", + "sha256": "cecbb2b36effb88a5371d2e76e5220670d530711d1ffae8ce9de13161063f972", + "size": 1370121, + "subdir": "linux-64", + "timestamp": 1537300535374, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py36heb32a55_1.conda": { + "build": "py36heb32a55_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "79b8f9282b247f277c53d002584b3bb7", + "name": "bottlechest", + "sha256": "44a5ff49bcdca30f650982bb53a8fe9b5ea8ff20aec5ea5980c7ee7bf5fef8fe", + "size": 1709916, + "subdir": "linux-64", + "timestamp": 1592211866222, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py37h6323ea4_1.conda": { + "build": "py37h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "6e12fe1a84a173f6d5758827340444ea", + "name": "bottlechest", + "sha256": "ca44da6331c9d3892400302775fe40d90ca52ace6808191bfc535890e71552ab", + "size": 1408516, + "subdir": "linux-64", + "timestamp": 1614264438304, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py37hdd07704_1.conda": { + "build": "py37hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "67049576e3943b6264a9c09f71892031", + "name": "bottlechest", + "sha256": "dce4943d1601b59af61dcf1d6092bde0ec19e9bdcfc9b5817163ee3ec045fbe9", + "size": 1375080, + "subdir": "linux-64", + "timestamp": 1537300607640, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py37heb32a55_1.conda": { + "build": "py37heb32a55_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "5e2bdb575b3b7a141e557fea3ce1fb18", + "name": "bottlechest", + "sha256": "e6541c19175c41eef4b5e53c13d288510faa0ad2397147331ee1f5811b18ce11", + "size": 1709847, + "subdir": "linux-64", + "timestamp": 1592211848085, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py38h6323ea4_1.conda": { + "build": "py38h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "8fc0af99217764144b1452a496616279", + "name": "bottlechest", + "sha256": "f9963eb557704cc8e3eb006c6848d39ef95c57d8bca9223e89cee9e7cc49ccf0", + "size": 1474197, + "subdir": "linux-64", + "timestamp": 1614265465637, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py38hdd07704_1.conda": { + "build": "py38hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "14ce6088c1d305c0e785de7458ed799d", + "name": "bottlechest", + "sha256": "d4fc333edaf95e57da8e5edf0be186db1ff845c35f9de3f04d59952ddc55ecc5", + "size": 1612569, + "subdir": "linux-64", + "timestamp": 1574097910436, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py38heb32a55_1.conda": { + "build": "py38heb32a55_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "f3f32d10c957b6679c381132ab71c841", + "name": "bottlechest", + "sha256": "e2651b8bb40828031f3e0961b63a51050bfd452d3fa30158f14765c4a73c6517", + "size": 1796869, + "subdir": "linux-64", + "timestamp": 1592211851628, + "version": "0.7.1" + }, + "bottlechest-0.7.1-py39h6323ea4_1.conda": { + "build": "py39h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "bf942a732e68de75997d8f122ba998c4", + "name": "bottlechest", + "sha256": "fbcd3bea11d624d39d92aad2acc87b3fb21a5feaa9e7bf8e299513ef3b3d15ab", + "size": 1481162, + "subdir": "linux-64", + "timestamp": 1614265423527, + "version": "0.7.1" + }, + "bottleneck-1.2.1-py27h035aef0_1.conda": { + "build": "py27h035aef0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8b510046f84334fca32e2d4e2e18c8cd", + "name": "bottleneck", + "sha256": "f519a694dbe40d472cfd3d13c5b7f61c79b4a5f5c0a99dcaa0108da35559bacd", + "size": 123601, + "subdir": "linux-64", + "timestamp": 1530781356566, + "version": "1.2.1" + }, + "bottleneck-1.2.1-py27h21b16a3_0.conda": { + "build": "py27h21b16a3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7a73899fcef589ed56654916bdaf0723", + "name": "bottleneck", + "sha256": "8b56d21650c7592c9a5e828462a3f93d434e89097ec848f440a111b565e328bc", + "size": 123180, + "subdir": "linux-64", + "timestamp": 1505741383374, + "version": "1.2.1" + }, + "bottleneck-1.2.1-py35h035aef0_1.conda": { + "build": "py35h035aef0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b33af924f732d2891d029ad1cc74576b", + "name": "bottleneck", + "sha256": "27476a2098a0e2e1350aa9d8a8d176ec845d9a9b5a7971c80be1817e570fc3e3", + "size": 124508, + "subdir": "linux-64", + "timestamp": 1534900049153, + "version": "1.2.1" + }, + "bottleneck-1.2.1-py35he1b16f1_0.conda": { + "build": "py35he1b16f1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "1680b8839ed0b571daddc1cc653a0a37", + "name": "bottleneck", + "sha256": "21676f7724ec08e5f5be0b0b831eda4401d27e1ee9a14c762c81d7f885ebd966", + "size": 123483, + "subdir": "linux-64", + "timestamp": 1505741474900, + "version": "1.2.1" + }, + "bottleneck-1.2.1-py36h035aef0_1.conda": { + "build": "py36h035aef0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a0546ac5a0b879bd1626c70ca64d0fa8", + "name": "bottleneck", + "sha256": "7918eb84c808e753698b0b5fac3375f17759913b613cc822e512dd98019a229c", + "size": 123114, + "subdir": "linux-64", + "timestamp": 1530781453043, + "version": "1.2.1" + }, + "bottleneck-1.2.1-py36haac1ea0_0.conda": { + "build": "py36haac1ea0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "19ae19efcd9001b413c53a086b038334", + "name": "bottleneck", + "sha256": "6a4365e0315121570a380de7fad2706fc3cd43f456c6f881ebb6eea45f868c60", + "size": 122912, + "subdir": "linux-64", + "timestamp": 1505741565283, + "version": "1.2.1" + }, + "bottleneck-1.2.1-py37h035aef0_1.conda": { + "build": "py37h035aef0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "dc727252b8eed29b3052c5f528ed37b6", + "name": "bottleneck", + "sha256": "2146c038446030cf576d0ebc21864f7c9eed4c6062a6ced090a901aa94eb7c97", + "size": 123149, + "subdir": "linux-64", + "timestamp": 1530781554326, + "version": "1.2.1" + }, + "bottleneck-1.2.1-py38hdd07704_1.conda": { + "build": "py38hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ee03e1181a5fe432db1c4241fd2b15c1", + "name": "bottleneck", + "sha256": "a28214b369155f88c2d33c99e272db8b73a8c7753f46e26e3aa6b208b7b60399", + "size": 125201, + "subdir": "linux-64", + "timestamp": 1573738311599, + "version": "1.2.1" + }, + "bottleneck-1.3.1-py27hdd07704_0.conda": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a3666d1a7bd4db86129ffb4516a50f8e", + "name": "bottleneck", + "sha256": "2dcd49f799ddeeaa8d187450ac8cbd6bdc756f9dad3984f81399b88ed9c99ad9", + "size": 123375, + "subdir": "linux-64", + "timestamp": 1574272450049, + "version": "1.3.1" + }, + "bottleneck-1.3.1-py36hdd07704_0.conda": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5179dc11699300fbaac4bee53b4263ec", + "name": "bottleneck", + "sha256": "ffbc75a11eeb31ac82b34a71c6fbf33fee0ec7a5da796b1bddb82d76ecb2c2cf", + "size": 127611, + "subdir": "linux-64", + "timestamp": 1574272572014, + "version": "1.3.1" + }, + "bottleneck-1.3.1-py37hdd07704_0.conda": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "260d411624be06b4d4829f433808437d", + "name": "bottleneck", + "sha256": "6d81289f9ff614aeca8ac1e005df1743a0c363da1d958ffce5c2d26fd3fb6584", + "size": 127474, + "subdir": "linux-64", + "timestamp": 1574272572236, + "version": "1.3.1" + }, + "bottleneck-1.3.1-py38hdd07704_0.conda": { + "build": "py38hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b4a206626d442b891cb1332ec21b2b2a", + "name": "bottleneck", + "sha256": "ec5bf921648d92bfcf4235d9c5390c8871bbb05bbe37ddf51d3cdb1c0836c3fa", + "size": 134397, + "subdir": "linux-64", + "timestamp": 1574272601264, + "version": "1.3.1" + }, + "bottleneck-1.3.2-py310h9102076_1.conda": { + "build": "py310h9102076_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a571bcc481a05fc080a29b286c4facfc", + "name": "bottleneck", + "sha256": "4db19c279d0e8991b529fc127cc32bc9fb8a4a7c376ef441a71618e59d547289", + "size": 279304, + "subdir": "linux-64", + "timestamp": 1640788630779, + "version": "1.3.2" + }, + "bottleneck-1.3.2-py36heb32a55_0.conda": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3d8459acb4bfc07b3dc6c648b0a12051", + "name": "bottleneck", + "sha256": "efd7c996d55b6dc48ae34e91e399c5e1cd58e80cbad50a6172c3c09f22ad71a6", + "size": 126970, + "subdir": "linux-64", + "timestamp": 1582558461005, + "version": "1.3.2" + }, + "bottleneck-1.3.2-py36heb32a55_1.conda": { + "build": "py36heb32a55_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "851422a824038522dd0575984662ec37", + "name": "bottleneck", + "sha256": "0a013919eb7fae68f680cd633bac10c43413c1514d70f72e36cd5e3d7573e401", + "size": 127233, + "subdir": "linux-64", + "timestamp": 1591780002024, + "version": "1.3.2" + }, + "bottleneck-1.3.2-py37heb32a55_0.conda": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "61d539dd3a55e4942ff6c3bdf87390e6", + "name": "bottleneck", + "sha256": "9362f818ae61e36a6f724b7ab5fbdbd69f94ed547a300d31e93bd56bb995443f", + "size": 127874, + "subdir": "linux-64", + "timestamp": 1582558307373, + "version": "1.3.2" + }, + "bottleneck-1.3.2-py37heb32a55_1.conda": { + "build": "py37heb32a55_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e8fed432509703319d9652cac8097b07", + "name": "bottleneck", + "sha256": "b85b388b5ca5eeb785ff13903c9e5c84459cf8a1adf25111c13b91b8757c2cbf", + "size": 128176, + "subdir": "linux-64", + "timestamp": 1591779991402, + "version": "1.3.2" + }, + "bottleneck-1.3.2-py38heb32a55_0.conda": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3f67698879b00e902c1136c2457142bb", + "name": "bottleneck", + "sha256": "c8799e46c909384008fd9ed2e410e9cd6bfb9c4ea97cca09ebf07804e420eb93", + "size": 127196, + "subdir": "linux-64", + "timestamp": 1582558513996, + "version": "1.3.2" + }, + "bottleneck-1.3.2-py38heb32a55_1.conda": { + "build": "py38heb32a55_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "987384f93dd2bac7a44b2c4a914ddbdd", + "name": "bottleneck", + "sha256": "fd5c024dbe9dbf0a846b9098df3bc2bd66426409a63285984c69e17637b5d444", + "size": 127529, + "subdir": "linux-64", + "timestamp": 1591780001947, + "version": "1.3.2" + }, + "bottleneck-1.3.2-py39hdd57654_1.conda": { + "build": "py39hdd57654_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b88c90705a1a4eb1a2463bccd7e879a7", + "name": "bottleneck", + "sha256": "08a3371b653f544d5298cc78a979abd97c16c05943453d211b385b2eb09bc491", + "size": 127780, + "subdir": "linux-64", + "timestamp": 1607575194408, + "version": "1.3.2" + }, + "bottleneck-1.3.4-py310h9102076_0.conda": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9264e2d725a24e1d0c8c91359aa23645", + "name": "bottleneck", + "sha256": "582e6eb6406dc8c0c8f13a71691615a94fe4940f4a34bf857ea6fb1d0c3088a1", + "size": 282563, + "subdir": "linux-64", + "timestamp": 1648010842036, + "version": "1.3.4" + }, + "bottleneck-1.3.4-py37hce1f21e_0.conda": { + "build": "py37hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5984cb90fcf74559fd46e5a1c6248d31", + "name": "bottleneck", + "sha256": "4a67cd066afb889fdfa4081169b45d9d01d3a4a00583a1bfca831aad21971400", + "size": 129105, + "subdir": "linux-64", + "timestamp": 1648028959702, + "version": "1.3.4" + }, + "bottleneck-1.3.4-py38hce1f21e_0.conda": { + "build": "py38hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9ca7b8cff6a7f97cd2395f20dd46bc90", + "name": "bottleneck", + "sha256": "6495ba0a480430131662421476c0d1b75d78ebe4f29a768d9e0ea693fee6ad46", + "size": 129721, + "subdir": "linux-64", + "timestamp": 1648028960341, + "version": "1.3.4" + }, + "bottleneck-1.3.4-py39hce1f21e_0.conda": { + "build": "py39hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "fa03814cac34e59716ad45841f1bd13c", + "name": "bottleneck", + "sha256": "80f9fe50cb5d2596074ad959114ebf7d3f95e43829b849683dabcb95fd4d96e5", + "size": 129324, + "subdir": "linux-64", + "timestamp": 1648028958291, + "version": "1.3.4" + }, + "bottleneck-1.3.5-py310ha9d4c09_0.conda": { + "build": "py310ha9d4c09_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d2eff72acd7c666bc90875d7eb44b924", + "name": "bottleneck", + "sha256": "e0c83435cf7b1f3f76f41058b3f230459d3a3ad15cf16f6a9a723b7d30538061", + "size": 280732, + "subdir": "linux-64", + "timestamp": 1657175754974, + "version": "1.3.5" + }, + "bottleneck-1.3.5-py311hbed6279_0.conda": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "35195672b4ed743049dfe1d10d05658a", + "name": "bottleneck", + "sha256": "e1bad8c8c9c3779f8717b42d1c2afe381e0e115bb473cb38be9144f9531c608d", + "size": 135692, + "subdir": "linux-64", + "timestamp": 1676827036328, + "version": "1.3.5" + }, + "bottleneck-1.3.5-py37h7deecbd_0.conda": { + "build": "py37h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9f8bee8c09ddd5fa01d0c41bef18d1b3", + "name": "bottleneck", + "sha256": "4bbda8d5e514082b5c47f1ee513459bc6620acf595e9aa641fa1839103aeea0b", + "size": 117636, + "subdir": "linux-64", + "timestamp": 1657175860628, + "version": "1.3.5" + }, + "bottleneck-1.3.5-py38h7deecbd_0.conda": { + "build": "py38h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9159f47d7dd4245fb71c3e4d3e60b609", + "name": "bottleneck", + "sha256": "017f6ac23a39b3e3f29332bceb9947c301ab1a527f5a529737f1daa10f4ad2b0", + "size": 117636, + "subdir": "linux-64", + "timestamp": 1657175632234, + "version": "1.3.5" + }, + "bottleneck-1.3.5-py39h7deecbd_0.conda": { + "build": "py39h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c07c855de7bcef6b409ef1460dea7438", + "name": "bottleneck", + "sha256": "76e4e23790e1729a9a4308352cf973fc7a0eec365281c524de0973dcacf53c13", + "size": 117879, + "subdir": "linux-64", + "timestamp": 1657175966755, + "version": "1.3.5" + }, + "bpython-0.19-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9466cae5574148fe15fc7c66d13e29e", + "name": "bpython", + "sha256": "3e3324c4d08f56d95b8ad9f686eb25cba3d5e08f118e504e4dd8c82280d5bd70", + "size": 279107, + "subdir": "linux-64", + "timestamp": 1598666112481, + "version": "0.19" + }, + "bpython-0.19-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.7,<3.8.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62944f3568b711bdac8ce4cefefedb8d", + "name": "bpython", + "sha256": "2597784413be6c4b2aa0b2a8efb18c0121756083eebe51f5e42eca70dbf1f8c3", + "size": 278872, + "subdir": "linux-64", + "timestamp": 1598666072517, + "version": "0.19" + }, + "bpython-0.19-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.8,<3.9.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5804e0144f67f02e21c7cbec5f504754", + "name": "bpython", + "sha256": "5179ec673abdeb8f665e6ea24b585504d1c981a943c66b5e8a58692ad0fd1a4b", + "size": 277960, + "subdir": "linux-64", + "timestamp": 1598666065779, + "version": "0.19" + }, + "bpython-0.20-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92abbe184fc79080c7ae608d56c81c89", + "name": "bpython", + "sha256": "78e4cd85c6fb05105ab7b6ab95982fd0a13733b1c17c1aeb210fa058b9f9486d", + "size": 279936, + "subdir": "linux-64", + "timestamp": 1602685981053, + "version": "0.20" + }, + "bpython-0.20-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.7,<3.8.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f150fc24b48e17220b9085790a73c879", + "name": "bpython", + "sha256": "ef3ef877f90c78ebf296e7f9084cc3d4f2b3f340d5f140c05ee13b3e4fa454e1", + "size": 279290, + "subdir": "linux-64", + "timestamp": 1602685993209, + "version": "0.20" + }, + "bpython-0.20-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.8,<3.9.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c9a66351acf483f63150ff290e9d05ae", + "name": "bpython", + "sha256": "e866a7f825844ce969713399ea64f9490db1f3136a0792241743ef5a68f125c8", + "size": 284592, + "subdir": "linux-64", + "timestamp": 1602685972217, + "version": "0.20" + }, + "bpython-0.20.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.10,<3.11.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c082bf81696cc64247130b2af5a218c0", + "name": "bpython", + "sha256": "e6abdf9ced7237a7acdc66f0f6a2cacb002d7dc930843cdd659b153f3a6fb950", + "size": 284500, + "subdir": "linux-64", + "timestamp": 1640811684203, + "version": "0.20.1" + }, + "bpython-0.20.1-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.11,<3.12.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39dd36dcc2fdd49773463e7cb9227149", + "name": "bpython", + "sha256": "9eb454cda8c4b30116a67e4b27c6f5c8c5d66ba15d6ba4317bad1ab6a9fb9642", + "size": 385193, + "subdir": "linux-64", + "timestamp": 1676847062224, + "version": "0.20.1" + }, + "bpython-0.20.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "54913c9c0569ce6286afae3a88c9c4b5", + "name": "bpython", + "sha256": "7ecb8925980d08a7a88112ef2eef8aaff0b297457a12bfcc4e1a077a996ba7ad", + "size": 279659, + "subdir": "linux-64", + "timestamp": 1605061413862, + "version": "0.20.1" + }, + "bpython-0.20.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.7,<3.8.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d59d58f85cb3b925dac68cfc13cd704d", + "name": "bpython", + "sha256": "10568d36c1fa760f61e4ceec11e120ed3016f946bd9de44e4e444f58d7f1651d", + "size": 279539, + "subdir": "linux-64", + "timestamp": 1605061456925, + "version": "0.20.1" + }, + "bpython-0.20.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.8,<3.9.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64d3a0daf7ece01b9491c679c1eb4dcb", + "name": "bpython", + "sha256": "188a74461592ce2b64eb18bf4b9f84b681f9de3eeb791dd33f0951ebb3758e72", + "size": 281941, + "subdir": "linux-64", + "timestamp": 1605061442254, + "version": "0.20.1" + }, + "bpython-0.20.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "curtsies >=0.1.18", + "greenlet", + "pygments", + "python >=3.9,<3.10.0a0", + "requests", + "six >=1.5", + "urwid", + "watchdog" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dfa7fc4533a3ee5820ce4036ee1d51fd", + "name": "bpython", + "sha256": "754179fab4f398f2d4dbc800532963bec70c2071647954d1e01cd448911f5fc0", + "size": 283002, + "subdir": "linux-64", + "timestamp": 1614265244859, + "version": "0.20.1" + }, + "branca-0.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d022e94089abc0f02c69f50b877e464", + "name": "branca", + "sha256": "f4da70e39d58c056edaf310e10ba0d2712b799043e958e1b35ab34ce36114450", + "size": 43488, + "subdir": "linux-64", + "timestamp": 1675157666140, + "version": "0.6.0" + }, + "branca-0.6.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bde810d9bc3dbe58fdd2c29021d41011", + "name": "branca", + "sha256": "0efaf31ea77d15e06dff9dffc12eab8ad91cb25cec43c71afb1c758df9e338d4", + "size": 51274, + "subdir": "linux-64", + "timestamp": 1676843457111, + "version": "0.6.0" + }, + "branca-0.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3ee09c101270ae2bbb6bcb86f407524", + "name": "branca", + "sha256": "422d99efd0946357df69b23953c5a2be434965e70a7cc110c986b5ac81266164", + "size": 42986, + "subdir": "linux-64", + "timestamp": 1675157639302, + "version": "0.6.0" + }, + "branca-0.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "373b9f3ab7999080adabb6137358474b", + "name": "branca", + "sha256": "417f4dccad4810e1a05459b5f9c4e09fb4b49c961518e6bc1aceb72a38cc69de", + "size": 43147, + "subdir": "linux-64", + "timestamp": 1675157693121, + "version": "0.6.0" + }, + "branca-0.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e910f2504123a88d2edf483eb602fa0b", + "name": "branca", + "sha256": "226f976ee404ccf92a37d2330f7019b422862c19e9b5ed451fb5106b2f59d92d", + "size": 43198, + "subdir": "linux-64", + "timestamp": 1675157720392, + "version": "0.6.0" + }, + "brotli-1.0.3-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "b0111ab4f8f6baa7b764ea580a0aea91", + "name": "brotli", + "sha256": "fc2e6cb6f1359b683ec2a8f9f8c81952d5d0f23dbbe5f02ff71f4b67ef414ad0", + "size": 381323, + "subdir": "linux-64", + "timestamp": 1529361891183, + "version": "1.0.3" + }, + "brotli-1.0.6-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "99de26a79c82ea47f4621e0a7f192c3a", + "name": "brotli", + "sha256": "e3a8effc9da248bc0f27e707afb1eb0438f6e09985424fbed563d4380600ec30", + "size": 397031, + "subdir": "linux-64", + "timestamp": 1539470596251, + "version": "1.0.6" + }, + "brotli-1.0.7-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "91999c06bef834abeb13219e141da03f", + "name": "brotli", + "sha256": "bbd4d114a5d43a19d2c1c1a3b2cc130258b4c567a56de8069124cf79da6ffc39", + "size": 400352, + "subdir": "linux-64", + "timestamp": 1611773863624, + "version": "1.0.7" + }, + "brotli-1.0.7-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "df0998a89e2619a90178e9edc32f3b7a", + "name": "brotli", + "sha256": "20f3581b99b1ce2dfd1eb8a0c78343f295e373e552f6acaa22ad04a34cfbd099", + "size": 396682, + "subdir": "linux-64", + "timestamp": 1540961274180, + "version": "1.0.7" + }, + "brotli-1.0.9-h5eee18b_7.conda": { + "build": "h5eee18b_7", + "build_number": 7, + "depends": [ + "brotli-bin 1.0.9 h5eee18b_7", + "libbrotlidec 1.0.9 h5eee18b_7", + "libbrotlienc 1.0.9 h5eee18b_7", + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "md5": "fb777289bceecf617ca9e35dd4484c86", + "name": "brotli", + "sha256": "cd45931a272f8ad43073af4bc2aebfdfeffc1b5ecad715706f19079f6e5eff9d", + "size": 18852, + "subdir": "linux-64", + "timestamp": 1659616178155, + "version": "1.0.9" + }, + "brotli-1.0.9-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "9a13ce85a6018891d8e713845b98a0a1", + "name": "brotli", + "sha256": "3a7c363b3d24cf595fa6ce4ffc4ac8df6e03f9b5f3ba30781dfc0ead545fe5da", + "size": 405557, + "subdir": "linux-64", + "timestamp": 1600352203181, + "version": "1.0.9" + }, + "brotli-1.0.9-he6710b0_2.conda": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "6513a2c97bd29ec2978d163c7e1f7932", + "name": "brotli", + "sha256": "9e936304be2da4ca78b208d52c09a3511a36c07ce2e2de7108f29da35bc36753", + "size": 384508, + "subdir": "linux-64", + "timestamp": 1602517685375, + "version": "1.0.9" + }, + "brotli-bin-1.0.9-h5eee18b_7.conda": { + "build": "h5eee18b_7", + "build_number": 7, + "depends": [ + "libbrotlidec 1.0.9 h5eee18b_7", + "libbrotlienc 1.0.9 h5eee18b_7", + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "md5": "1cc9b5d3edf7bf3247941f4b5c083242", + "name": "brotli-bin", + "sha256": "ea5d7916a2856e0b0f004cf7a181430df3f22f72eedb391f96c030b237d1f1a8", + "size": 19069, + "subdir": "linux-64", + "timestamp": 1659616170430, + "version": "1.0.9" + }, + "brotli-python-1.0.9-py310h6a678d5_7.conda": { + "build": "py310h6a678d5_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "a3301b37d90d92a449832850ad20bbc8", + "name": "brotli-python", + "sha256": "a08ea0fbd5a3b8490fa8f4b03afd033e643a793da3f1d16c8383f60f57ea34f1", + "size": 928345, + "subdir": "linux-64", + "timestamp": 1659616230938, + "version": "1.0.9" + }, + "brotli-python-1.0.9-py311h6a678d5_7.conda": { + "build": "py311h6a678d5_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "e7ad3b066db40f54d37099e58fef130a", + "name": "brotli-python", + "sha256": "d317c3d6460f62c7acf40d27c4e86b6dc8d6eb91549b88d6fdda9bc1d365d8bb", + "size": 325409, + "subdir": "linux-64", + "timestamp": 1676830217115, + "version": "1.0.9" + }, + "brotli-python-1.0.9-py36heb0550a_2.conda": { + "build": "py36heb0550a_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "04837652eea534f974a412dfd7b8806e", + "name": "brotli-python", + "sha256": "fb6edf824893a1f25fd8f5847e44cd61ecef98e532e5aa980348143de3850af5", + "size": 348986, + "subdir": "linux-64", + "timestamp": 1602517752387, + "version": "1.0.9" + }, + "brotli-python-1.0.9-py37h6a678d5_7.conda": { + "build": "py37h6a678d5_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5a3f68b1c6fd37f2e5c1b97223661fd4", + "name": "brotli-python", + "sha256": "1a909e5f1f4c3eb5d440cf770e143f85b79973cd733821ec64d627c62d794e1d", + "size": 336785, + "subdir": "linux-64", + "timestamp": 1659616205123, + "version": "1.0.9" + }, + "brotli-python-1.0.9-py37heb0550a_2.conda": { + "build": "py37heb0550a_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8e7983ee4b8eabde75b3530681aec31f", + "name": "brotli-python", + "sha256": "ff3d532b0fa476e7c744ddf5940ae7bedf46c4c63386be85b53e9f1a7c438a3f", + "size": 348913, + "subdir": "linux-64", + "timestamp": 1602517718707, + "version": "1.0.9" + }, + "brotli-python-1.0.9-py38h6a678d5_7.conda": { + "build": "py38h6a678d5_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "201cd6e63815f03bc5dc714e0ff6772d", + "name": "brotli-python", + "sha256": "46810640a13814077d527ec13a5d8c9e41c447285b75df6a094dbfae9456934e", + "size": 337084, + "subdir": "linux-64", + "timestamp": 1659616279024, + "version": "1.0.9" + }, + "brotli-python-1.0.9-py38heb0550a_2.conda": { + "build": "py38heb0550a_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "72fba48c118a6c7a7857350afe2051b0", + "name": "brotli-python", + "sha256": "6a6e46d479a609df03f53eff6c9d89883fb57dd0520a2108a86e83bbd87e9942", + "size": 348435, + "subdir": "linux-64", + "timestamp": 1602517785841, + "version": "1.0.9" + }, + "brotli-python-1.0.9-py39h6a678d5_7.conda": { + "build": "py39h6a678d5_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "36019f0e5c2782cf316394a3d6796f11", + "name": "brotli-python", + "sha256": "7320dc95e6d77a8df3e161c4ce6f8416d5ea55c602b0de8ecb26c43c053d39d1", + "size": 337783, + "subdir": "linux-64", + "timestamp": 1659616255400, + "version": "1.0.9" + }, + "brotlicffi-1.0.9.2-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "fec4e91cd1d2451c541a213637605bb4", + "name": "brotlicffi", + "sha256": "855797661e2c63f87c3d87aa5a1e2ed6654b2f290fd2b2333ff495caec65a53a", + "size": 803151, + "subdir": "linux-64", + "timestamp": 1640803742140, + "version": "1.0.9.2" + }, + "brotlicffi-1.0.9.2-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "80a07cd332d7d75088beb0031cfe3167", + "name": "brotlicffi", + "sha256": "cf9733765775c83bdec6ba2b8b6325c4eaecd52e6f5f11221426e141e4c0ff3e", + "size": 333995, + "subdir": "linux-64", + "timestamp": 1676847092255, + "version": "1.0.9.2" + }, + "brotlicffi-1.0.9.2-py36h295c915_0.conda": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b5fb08aa3c83a3d95299048e04438134", + "name": "brotlicffi", + "sha256": "7d0edb22d01c91ced3f872b50f4095eb8ce1ed64015e84abedf8a7c6c6fc79ca", + "size": 350384, + "subdir": "linux-64", + "timestamp": 1633095409517, + "version": "1.0.9.2" + }, + "brotlicffi-1.0.9.2-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "88fca1905609dd49f5726f2ad125ee18", + "name": "brotlicffi", + "sha256": "ce1ffddf4594ee2ed333173e7be9da04eafe486449e34b3ec40663650f0d2c13", + "size": 350538, + "subdir": "linux-64", + "timestamp": 1633095396351, + "version": "1.0.9.2" + }, + "brotlicffi-1.0.9.2-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "05bba3490e9836ef238c4cbddbeccf51", + "name": "brotlicffi", + "sha256": "bc5c327158bcd4743122fbbc26a71241482150af96811169edd6b388fd8f7d37", + "size": 350666, + "subdir": "linux-64", + "timestamp": 1633095388364, + "version": "1.0.9.2" + }, + "brotlicffi-1.0.9.2-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "9de657ed2f3c877d2538c23f440ed191", + "name": "brotlicffi", + "sha256": "a43b40bbf4a7a45bd615610bc5f454106ffb92bf6b1c902bf063bf0f6d2f2a30", + "size": 350948, + "subdir": "linux-64", + "timestamp": 1633095396381, + "version": "1.0.9.2" + }, + "brotlipy-0.7.0-py310h7f8727e_1002.conda": { + "build": "py310h7f8727e_1002", + "build_number": 1002, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8dfa5aefcc49d5e78000b16d2b7714e", + "name": "brotlipy", + "sha256": "c887a0aeba9ce2dab9ad891b676f0c1e43ca1fe7c6075ac3f14a052ccaa31d4a", + "size": 729237, + "subdir": "linux-64", + "timestamp": 1640803794269, + "version": "0.7.0" + }, + "brotlipy-0.7.0-py311h5eee18b_1002.conda": { + "build": "py311h5eee18b_1002", + "build_number": 1002, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d0decdefee9dcf89dcbaad2ffd30b830", + "name": "brotlipy", + "sha256": "8fc67d103f8a9281e721ed2dae64324f6200ba48db2263c70408d06bdc01753f", + "size": 314700, + "subdir": "linux-64", + "timestamp": 1676822696758, + "version": "0.7.0" + }, + "brotlipy-0.7.0-py36h27cfd23_1003.conda": { + "build": "py36h27cfd23_1003", + "build_number": 1003, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8ecfc2d70b69971633ad4cc60fd0e53", + "name": "brotlipy", + "sha256": "dada2e3a1cc6d7421eba94a91642115ddd9295980605ea3819317be41ddbf356", + "size": 327449, + "subdir": "linux-64", + "timestamp": 1605539571026, + "version": "0.7.0" + }, + "brotlipy-0.7.0-py36h7b6447c_1000.conda": { + "build": "py36h7b6447c_1000", + "build_number": 1000, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c520ed31117eb89156ac8e5350d9095b", + "name": "brotlipy", + "sha256": "d4c56f0bd7d34d2e8f901b0a48c9b8426f9c83ae5b510e0c77927b7d9dc28f9c", + "size": 330564, + "subdir": "linux-64", + "timestamp": 1591177768833, + "version": "0.7.0" + }, + "brotlipy-0.7.0-py37h27cfd23_1003.conda": { + "build": "py37h27cfd23_1003", + "build_number": 1003, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "35791ca9efc640b7a0fe32fd2ac32386", + "name": "brotlipy", + "sha256": "72ba4e54dd82ad4b527471780609e032eb6ba0a258a802e4458cac8f3fc11e0a", + "size": 327745, + "subdir": "linux-64", + "timestamp": 1605539573316, + "version": "0.7.0" + }, + "brotlipy-0.7.0-py37h7b6447c_1000.conda": { + "build": "py37h7b6447c_1000", + "build_number": 1000, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8bfc09a7f37652de488e85c177aa963", + "name": "brotlipy", + "sha256": "43f65ef625db84f0c853e7acf2af8cbca86b333c71a581a07fa33144ea792c86", + "size": 330085, + "subdir": "linux-64", + "timestamp": 1591177750189, + "version": "0.7.0" + }, + "brotlipy-0.7.0-py38h27cfd23_1003.conda": { + "build": "py38h27cfd23_1003", + "build_number": 1003, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e881c8ee8a4048f29da5d20f0330fe37", + "name": "brotlipy", + "sha256": "42f83ff56466f4e83ad8c29b3cf1f396cd9e1278f8158331c8ac9687b4da8052", + "size": 330737, + "subdir": "linux-64", + "timestamp": 1605539542867, + "version": "0.7.0" + }, + "brotlipy-0.7.0-py38h7b6447c_1000.conda": { + "build": "py38h7b6447c_1000", + "build_number": 1000, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb72879bd0a40e155cd4a5bc02b0dcdb", + "name": "brotlipy", + "sha256": "00fe4a46a7bee0f1fe8f3c96902d18f6c5eb57a78f2ce7304f89609b3c2cda13", + "size": 330189, + "subdir": "linux-64", + "timestamp": 1591177769422, + "version": "0.7.0" + }, + "brotlipy-0.7.0-py39h27cfd23_1003.conda": { + "build": "py39h27cfd23_1003", + "build_number": 1003, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be47bcffb9e3e7495897b02589f5ad1a", + "name": "brotlipy", + "sha256": "17420d4eea48a3e89aa260c9233ba96815ea40d07702d7554b27f30f3ecdc2fb", + "size": 331770, + "subdir": "linux-64", + "timestamp": 1605539534667, + "version": "0.7.0" + }, + "brunsli-0.1-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "brotli >=1.0.9,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6777d1b10f8e02143f9708699f7ab354", + "name": "brunsli", + "sha256": "931b2dfe51265fa8c1d240a91fd4b763302ec3a550e7ff0b0ab5ed68ff17b6c7", + "size": 168297, + "subdir": "linux-64", + "timestamp": 1611240485163, + "version": "0.1" + }, + "bsdiff4-1.1.5-py27h7b6447c_1.conda": { + "build": "py27h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "b04800c2331cc012a9e80b30ecc8202c", + "name": "bsdiff4", + "sha256": "4afef688be5e5fba970a928c9515fcbd7e8cd0bb690e5ffc68039863f6c9fa74", + "size": 20687, + "subdir": "linux-64", + "timestamp": 1537205910054, + "version": "1.1.5" + }, + "bsdiff4-1.1.5-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "7e5d152e9acab0686a15198d552c235f", + "name": "bsdiff4", + "sha256": "a0e4b6539917f73fabcc93d2cae535c0a3c852bde2db2291db2bf8c1d5739766", + "size": 36265, + "subdir": "linux-64", + "timestamp": 1640788655826, + "version": "1.1.5" + }, + "bsdiff4-1.1.5-py311h5eee18b_1.conda": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "md5": "9bfde98d7b67faad9df8b20afc053b98", + "name": "bsdiff4", + "sha256": "38054233128d567bdb76ca0da78c2781dd64f61897cda7dd4d6d43efc4c434f7", + "size": 25149, + "subdir": "linux-64", + "timestamp": 1676906926072, + "version": "1.1.5" + }, + "bsdiff4-1.1.5-py35h7b6447c_1.conda": { + "build": "py35h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "42f022fac184f643812fac66183b5370", + "name": "bsdiff4", + "sha256": "c7f3e4a1d2a16227255542917826c75c84161d98ae36ab438777b08c327aa7fa", + "size": 21134, + "subdir": "linux-64", + "timestamp": 1537205919078, + "version": "1.1.5" + }, + "bsdiff4-1.1.5-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "bc087bde78bf79dd304ac1a84734d142", + "name": "bsdiff4", + "sha256": "2ac17ba55c367e3b5ba8f28fd12436bc20585c91adb814dbe1b8b64c363b426a", + "size": 258520, + "subdir": "linux-64", + "timestamp": 1613038496631, + "version": "1.1.5" + }, + "bsdiff4-1.1.5-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "98d4dde1137b436ebb54e8bb6c257091", + "name": "bsdiff4", + "sha256": "d819b6fe916efbb54781abd95964dd5b36d66be5c2a95986bfaa38f6c4cfa43f", + "size": 21069, + "subdir": "linux-64", + "timestamp": 1537205947964, + "version": "1.1.5" + }, + "bsdiff4-1.1.5-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "f81aa41365c242cc96a8235d794606c8", + "name": "bsdiff4", + "sha256": "9445ce06798756965ca3f6c61c8f1c0e2dacb0005e30800923f5eddf21394c9a", + "size": 259399, + "subdir": "linux-64", + "timestamp": 1613039262364, + "version": "1.1.5" + }, + "bsdiff4-1.1.5-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "69f214e2e259e0eca835941fd0f64e15", + "name": "bsdiff4", + "sha256": "d67fcc66e97b9f4765a9450b1fd4dda2a5c585b12f36f6583487f4037a969771", + "size": 21009, + "subdir": "linux-64", + "timestamp": 1537205866625, + "version": "1.1.5" + }, + "bsdiff4-1.1.5-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "740373386a06fc061ca9850db1b86085", + "name": "bsdiff4", + "sha256": "f4915dc45904ce2608f2128c2762363ab5c49d98f87d059d8ef613b4bc8065be", + "size": 258287, + "subdir": "linux-64", + "timestamp": 1613038489926, + "version": "1.1.5" + }, + "bsdiff4-1.1.5-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "2a40a8e85c480fd7ab173c819e6d91bd", + "name": "bsdiff4", + "sha256": "6b97be9dc4994365db524be8002ee1f8bd6393c580f0e8bffa9341b1bdd50e08", + "size": 28014, + "subdir": "linux-64", + "timestamp": 1572357374467, + "version": "1.1.5" + }, + "btrees-4.5.0-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "persistent >=4.1.0", + "python >=2.7,<2.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "6c69911552452d6f62168b04ae01f0a3", + "name": "btrees", + "sha256": "964172e0aa985296eb51feab1ede1df2c8527255d33d402a974964289a684944", + "size": 345927, + "subdir": "linux-64", + "timestamp": 1529983460615, + "version": "4.5.0" + }, + "btrees-4.5.0-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "persistent >=4.1.0", + "python >=3.5,<3.6.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "e77a523bd39680aa0b29df695b2dea23", + "name": "btrees", + "sha256": "c63a7809f529e32cc9d121e54fe856b089c08b9d096a8b439e09c35d666a6d1c", + "size": 356328, + "subdir": "linux-64", + "timestamp": 1529983486755, + "version": "4.5.0" + }, + "btrees-4.5.0-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "persistent >=4.1.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "86f511ff75818f480229905505367a9d", + "name": "btrees", + "sha256": "6a5140f3de8e304967481eaf94558f4aa49d0ae9bdce0227bd40580d63a5b30a", + "size": 354973, + "subdir": "linux-64", + "timestamp": 1529983425674, + "version": "4.5.0" + }, + "btrees-4.5.1-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "persistent >=4.1.0", + "python >=2.7,<2.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "33490fae4fbd278b2de1303bfa04d6f8", + "name": "btrees", + "sha256": "11d5b69e7cbff855d57c203800ced310327bab88befaafd7f216d875bfb1b870", + "size": 347067, + "subdir": "linux-64", + "timestamp": 1534660230764, + "version": "4.5.1" + }, + "btrees-4.5.1-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "persistent >=4.1.0", + "python >=3.5,<3.6.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "a709d802c184d23981c0d6e3c8cce24b", + "name": "btrees", + "sha256": "487b8a5c35a42c2543e0246e590afe9873087460fb5533f0374a46b9b2f62c33", + "size": 356546, + "subdir": "linux-64", + "timestamp": 1534660240544, + "version": "4.5.1" + }, + "btrees-4.5.1-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "persistent >=4.1.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "16ecb06c6bf38a58fcae7b3af4e8d8b8", + "name": "btrees", + "sha256": "082f37d986435c355207774de2fd771d23c2df233ad5e9a773da44b3dc7179d3", + "size": 353636, + "subdir": "linux-64", + "timestamp": 1534660140346, + "version": "4.5.1" + }, + "btrees-4.5.1-py37hf484d3e_0.conda": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "persistent >=4.1.0", + "python >=3.7,<3.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "04e8c2957b48a93b04dbc1c71c3942c0", + "name": "btrees", + "sha256": "279e36891803185510cad2a6a6d81c5b85be823290f7d37c9cc369a889dfd56a", + "size": 352899, + "subdir": "linux-64", + "timestamp": 1534660282780, + "version": "4.5.1" + }, + "btrees-4.6.0-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "persistent >=4.1.0", + "python >=2.7,<2.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "5c72a1b4845d012ea070f92e352291d2", + "name": "btrees", + "sha256": "d9b64f6a75ebac3729ff7a8d5c4ca02881e8d6ea82ba74d93d707e8861e5fe30", + "size": 510650, + "subdir": "linux-64", + "timestamp": 1569443802551, + "version": "4.6.0" + }, + "btrees-4.6.0-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "persistent >=4.1.0", + "python >=3.10,<3.11.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "482ebd5f5324ef0e63c0a5e88d6344f4", + "name": "btrees", + "sha256": "f3f18bdaeaab51f6f54942ce6f01f4565dd903dbd9b9150421bdd835fd350140", + "size": 734272, + "subdir": "linux-64", + "timestamp": 1640813441563, + "version": "4.6.0" + }, + "btrees-4.6.0-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "persistent >=4.1.0", + "python >=3.11,<3.12.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "3c6b130a5c53a5147cb424db5794f390", + "name": "btrees", + "sha256": "244b40513a8f953f75dd5c46a9daf014da0ad69f6708fa582cd4033eb9cb4855", + "size": 414178, + "subdir": "linux-64", + "timestamp": 1676906958117, + "version": "4.6.0" + }, + "btrees-4.6.0-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "persistent >=4.1.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "cf3a24dc5367188f592ee5975430d952", + "name": "btrees", + "sha256": "080f86c31c0cbf9d54009203de1da47a103842afcc1f40e82aab7f6157ae0274", + "size": 590672, + "subdir": "linux-64", + "timestamp": 1613043508000, + "version": "4.6.0" + }, + "btrees-4.6.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "persistent >=4.1.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "4d948e95d259bd8e585d1747a819dab5", + "name": "btrees", + "sha256": "42b8c28e757edbca5a8188d7ac37b500fe9db3da6088e23f750f6680163695f9", + "size": 517757, + "subdir": "linux-64", + "timestamp": 1569443804073, + "version": "4.6.0" + }, + "btrees-4.6.0-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "persistent >=4.1.0", + "python >=3.7,<3.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "ac2242c1ad53af718e6b9235bf883e2a", + "name": "btrees", + "sha256": "21ba191e935bbc7d0f965070972249937ecbff795ae7d1f560df3758eceea555", + "size": 590776, + "subdir": "linux-64", + "timestamp": 1613043008497, + "version": "4.6.0" + }, + "btrees-4.6.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "persistent >=4.1.0", + "python >=3.7,<3.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "6175b6e54f9fc247a9365d2fd7130102", + "name": "btrees", + "sha256": "169c058ce529c8d56363a6806892dd3b464a31428475525673bba1d34791676b", + "size": 517020, + "subdir": "linux-64", + "timestamp": 1569443800194, + "version": "4.6.0" + }, + "btrees-4.6.0-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "persistent >=4.1.0", + "python >=3.8,<3.9.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "2ba827d06ad2e4e1a2dad2754f5263fe", + "name": "btrees", + "sha256": "82c2fe744a384a5bc9a94d31f870d316eb4dce4dffb3ea4eb20b68e26596c71c", + "size": 598206, + "subdir": "linux-64", + "timestamp": 1613043508993, + "version": "4.6.0" + }, + "btrees-4.6.0-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "persistent >=4.1.0", + "python >=3.9,<3.10.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "d8fc5d7cbc945aad9dea5de4d9d25497", + "name": "btrees", + "sha256": "0d15d5a3e1a8f3d96113846d23e1690990d3709233000f4318d515f7829c4a18", + "size": 597804, + "subdir": "linux-64", + "timestamp": 1613043505724, + "version": "4.6.0" + }, + "bwidget-1.9.11-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "tk" + ], + "license": "Tcl/Tk", + "license_family": "BSD", + "md5": "da3e47ab53550fa372457e34ecc9375d", + "name": "bwidget", + "sha256": "767512b6d67b26429658fd4abea4a8b737c60b166a5e5d20cb33f91ba4a18f31", + "size": 117470, + "subdir": "linux-64", + "timestamp": 1515593869976, + "version": "1.9.11" + }, + "bwidget-1.9.11-1.conda": { + "build": "1", + "build_number": 1, + "depends": [ + "tk" + ], + "license": "Tcl/Tk", + "license_family": "BSD", + "md5": "476c833c6e38d0b59cd4b7484686c600", + "name": "bwidget", + "sha256": "88f4af44f9918f33d13ac799a4ea8f84bddc1f7db3f99c9e396f5f6c1094ec65", + "size": 118460, + "subdir": "linux-64", + "timestamp": 1537997223350, + "version": "1.9.11" + }, + "bytecode-0.14.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12de30f41d0e74698e34a2a26f6395c9", + "name": "bytecode", + "sha256": "851f8f73c3b913caab9416839180a55dbf17abdad2cfb3c115ffda6569631c06", + "size": 71429, + "subdir": "linux-64", + "timestamp": 1678314984864, + "version": "0.14.0" + }, + "bytecode-0.14.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d5394155528ed6c30a9618eb850d8e3", + "name": "bytecode", + "sha256": "4f758f25575b069e36accce638b211c7a73acc24a9fd4c5f82a318258fbb18b1", + "size": 91471, + "subdir": "linux-64", + "timestamp": 1679339995580, + "version": "0.14.0" + }, + "bytecode-0.14.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2664f9eab19d79f1d76aa2c831c6115b", + "name": "bytecode", + "sha256": "4488d1d9bd03d98a12f8928ff5a61621c338522435a823ad57280b679eb74d16", + "size": 70734, + "subdir": "linux-64", + "timestamp": 1678314957362, + "version": "0.14.0" + }, + "bytecode-0.14.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a9c2d0e5164d9108b9a3e43de977ed2", + "name": "bytecode", + "sha256": "fe64f62a074c209a066c86ef5e5ad4cedb8dbe799fa54875e6e87dc6b79a6a29", + "size": 70628, + "subdir": "linux-64", + "timestamp": 1678314930222, + "version": "0.14.0" + }, + "bz2file-0.98-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "52902a659104a757a0adcd42fe160e13", + "name": "bz2file", + "sha256": "b03b363db0b2ec985c6de540f1f9bebed7b181e95647425b7e30db271b0f9496", + "size": 13458, + "subdir": "linux-64", + "timestamp": 1530889166182, + "version": "0.98" + }, + "bz2file-0.98-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "fc3171b175c3ee738b72ce083dfc6997", + "name": "bz2file", + "sha256": "fc2dd115020a6a4ac5eb8be835a6c4bd961f921ad905590495e157b6e747f193", + "size": 14000, + "subdir": "linux-64", + "timestamp": 1640788673276, + "version": "0.98" + }, + "bz2file-0.98-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "a0fe914c9e042039fa2179904b14c334", + "name": "bz2file", + "sha256": "e22a984291d4d0975a8de894a4c067a7e15b5af8979bde9fb0971c879b1eda4d", + "size": 17716, + "subdir": "linux-64", + "timestamp": 1676906973704, + "version": "0.98" + }, + "bz2file-0.98-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "4b645255fb9346634c6d369b8acfc7fa", + "name": "bz2file", + "sha256": "eb27bdc8788d7866648043e8c73a02d70abbac8380e748c95826e970e05baccc", + "size": 13859, + "subdir": "linux-64", + "timestamp": 1537808400501, + "version": "0.98" + }, + "bz2file-0.98-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "1b38b3aebc35e8f3a4fb66261f6f7956", + "name": "bz2file", + "sha256": "81730b2af25db049c3a6527fbabb38866c6d12e34cdf458fd93f391ea212a67a", + "size": 13579, + "subdir": "linux-64", + "timestamp": 1530889204425, + "version": "0.98" + }, + "bz2file-0.98-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "657a8fd2619c5d34214531e368dac785", + "name": "bz2file", + "sha256": "1adf6f8c6e256403477d78fd960f08f64f26c1a2d68e909d36f02324599391d0", + "size": 250959, + "subdir": "linux-64", + "timestamp": 1613038465784, + "version": "0.98" + }, + "bz2file-0.98-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "5eac3b809b7ca7ad301e711d6b5b6b32", + "name": "bz2file", + "sha256": "90285ab2184ae0645c56ade657877dd3bafb1582296bb032371fc4a61034d8c3", + "size": 13452, + "subdir": "linux-64", + "timestamp": 1530889185069, + "version": "0.98" + }, + "bz2file-0.98-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "a05263fc0dac60b74cbeecb79328b34b", + "name": "bz2file", + "sha256": "081b86a40dd7d66ffee324c442bdcab1d808542616b226138fde75eaac2928f0", + "size": 251237, + "subdir": "linux-64", + "timestamp": 1613038470925, + "version": "0.98" + }, + "bz2file-0.98-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "8de159404fe40e9af8e4200df2535a96", + "name": "bz2file", + "sha256": "b18e4ab33badefcbbe99b0a2fc425d3546d414b26807794cd437a82b7f2b0479", + "size": 14024, + "subdir": "linux-64", + "timestamp": 1572357395557, + "version": "0.98" + }, + "bz2file-0.98-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "642b292d738f7d7beb07a98ff10686a3", + "name": "bz2file", + "sha256": "c45b6e2bbbc22956899954687077390eb6fcfc178ec362b2ce7253ad29c19f28", + "size": 251098, + "subdir": "linux-64", + "timestamp": 1613038473589, + "version": "0.98" + }, + "bzip2-1.0.6-h0376d23_1.conda": { + "build": "h0376d23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "bzip2", + "license_family": "BSD", + "md5": "c7b75365017775f91e0bfad470813091", + "name": "bzip2", + "sha256": "dd6749399513bb74f769afa1e60a5da4a2cb05cb0d0a71531d0b4d5ac9769644", + "size": 213403, + "subdir": "linux-64", + "timestamp": 1505667020622, + "version": "1.0.6" + }, + "bzip2-1.0.6-h14c3975_5.conda": { + "build": "h14c3975_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "bzip2", + "license_family": "BSD", + "md5": "038d1deec864a30791bfc0fb55fcd204", + "name": "bzip2", + "sha256": "f467c10ac4f3f78e8567942c3380d2db6c1b62c9d2f2e22764905ccfa96613ca", + "size": 213977, + "subdir": "linux-64", + "timestamp": 1527013477802, + "version": "1.0.6" + }, + "bzip2-1.0.6-h6d464ef_2.conda": { + "build": "h6d464ef_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "bzip2", + "license_family": "BSD", + "md5": "bacf5bc4e7907b077e89cc16e3685b1f", + "name": "bzip2", + "sha256": "7272b208306414a65b1980d96b37539222ee3f3df16b6fa0b89eba8d501cbde2", + "size": 215749, + "subdir": "linux-64", + "timestamp": 1510603142558, + "version": "1.0.6" + }, + "bzip2-1.0.6-h9a117a8_4.conda": { + "build": "h9a117a8_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "bzip2", + "license_family": "BSD", + "md5": "52463ba1c84b88d7a8a1e93bac86afe8", + "name": "bzip2", + "sha256": "cdaebeea586ef10a5d2306ae1e97168eedb340c955be0b4d618a956166c96993", + "size": 213735, + "subdir": "linux-64", + "timestamp": 1518029681210, + "version": "1.0.6" + }, + "bzip2-1.0.7-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "bzip2", + "license_family": "BSD", + "md5": "7f036ffa7e8d49e86eb79e7a76824ab6", + "name": "bzip2", + "sha256": "680b380d47cc2fb08297fb2c9184518e6d19609fe49bd4d3ff9eb9c557d212e6", + "size": 79799, + "subdir": "linux-64", + "timestamp": 1562538098825, + "version": "1.0.7" + }, + "bzip2-1.0.8-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "bzip2", + "license_family": "BSD", + "md5": "9303f4af7c004e069bae22bde8d800ee", + "name": "bzip2", + "sha256": "d3fa503351a53692866182a3819fb28d105e32c25d177bf6a9444c4153215e0d", + "size": 80125, + "subdir": "linux-64", + "timestamp": 1563219611337, + "version": "1.0.8" + }, + "c-ares-1.15.0-h7b6447c_1.conda": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "213f2a192be321fed9f431e0ced2d20f", + "name": "c-ares", + "sha256": "d164bf9d40461bfccbb6bba9da508ff5cc980392cab25ae45809787d8a77735a", + "size": 87584, + "subdir": "linux-64", + "timestamp": 1541523564509, + "version": "1.15.0" + }, + "c-ares-1.15.0-h7b6447c_1001.conda": { + "build": "h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "969c29c6c1eec8bd18103eb59405e5c7", + "name": "c-ares", + "sha256": "943f0c651767f71d8e2e7a09d0098f9629ebdde3d6e3f5645edd3f0229c4accb", + "size": 90713, + "subdir": "linux-64", + "timestamp": 1564157440657, + "version": "1.15.0" + }, + "c-ares-1.16.1-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5a9a16da9816f2cb810d9e96ea3f29c8", + "name": "c-ares", + "sha256": "37d005af7a22519443cece6e5c7ed13abe265d78226b8234ee1d653a21a1cf57", + "size": 110217, + "subdir": "linux-64", + "timestamp": 1600467303482, + "version": "1.16.1" + }, + "c-ares-1.17.1-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e5b4f78e590914237307029282c971b", + "name": "c-ares", + "sha256": "fe3dd95fd0c54b967a4db44aa3e1fe81c614a51d6a8d0b9f5232a7226045a555", + "size": 110293, + "subdir": "linux-64", + "timestamp": 1605995594332, + "version": "1.17.1" + }, + "c-ares-1.18.1-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "677634b170f698ba548ca8d57aa3fd1a", + "name": "c-ares", + "sha256": "b4fac6b42ba3e06457b70723e88f43d7a7905288e5f8e3226687b0b9bdfc62f4", + "size": 116463, + "subdir": "linux-64", + "timestamp": 1641918271715, + "version": "1.18.1" + }, + "c-ares-1.19.0-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc9682c02b142d9d9c36aac3b1c87561", + "name": "c-ares", + "sha256": "9dc6071ead1a6a30a995052e26ba231149043fc9ed0e6ad924de71db5f7df944", + "size": 120935, + "subdir": "linux-64", + "timestamp": 1678793752036, + "version": "1.19.0" + }, + "c-ares-static-1.16.1-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d628ebca5d189c91316944890a0dccad", + "name": "c-ares-static", + "sha256": "58341b684ad9c02ae02815a6318e9d11e39f471dd13c8ecf6e5b70bda9146d28", + "size": 137232, + "subdir": "linux-64", + "timestamp": 1600467325041, + "version": "1.16.1" + }, + "c-ares-static-1.17.1-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d94ef071c9e30ef5d78671064673c05b", + "name": "c-ares-static", + "sha256": "5a33dcd40378eadbffb3db2492dacda06c1089078d5a0b3bb958c013cd2d771a", + "size": 138063, + "subdir": "linux-64", + "timestamp": 1605995620606, + "version": "1.17.1" + }, + "c-ares-static-1.18.1-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe5d77b8013b5c1332fd62927c9dae90", + "name": "c-ares-static", + "sha256": "e868f23c48831fa938ddc7a91fc876f4a167ff54e12e2c6f403cc743fbe01ebe", + "size": 144086, + "subdir": "linux-64", + "timestamp": 1641918295514, + "version": "1.18.1" + }, + "c-ares-static-1.19.0-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0149de5a92667712b50a012e1e600099", + "name": "c-ares-static", + "sha256": "d9fb0f62e2f3e2730631effffdb512b7e7b44826c990587aec5e11666e202251", + "size": 148563, + "subdir": "linux-64", + "timestamp": 1678793767671, + "version": "1.19.0" + }, + "ca-certificates-2017.08.26-h1d4fec5_0.conda": { + "build": "h1d4fec5_0", + "build_number": 0, + "depends": [], + "license": "ISC", + "md5": "df1785108554e5001a5a7d238ed3b04f", + "name": "ca-certificates", + "sha256": "d26c21deeb58b836feebdcff01ab5c9bb3d5c39c793eb264777f4d0f5f418bae", + "size": 297170, + "subdir": "linux-64", + "timestamp": 1505666760156, + "version": "2017.08.26" + }, + "ca-certificates-2018.03.07-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "ISC", + "md5": "b016502cf447e85a6373547c5ed8bad6", + "name": "ca-certificates", + "sha256": "142bd944e4c370aafb10a2458aa27251fa0f3dfb139562d492cd7da5ef452627", + "size": 120594, + "subdir": "linux-64", + "timestamp": 1522697436619, + "version": "2018.03.07" + }, + "ca-certificates-2018.12.5-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "ISC", + "md5": "774321129ca46844dcf463b9d576dce2", + "name": "ca-certificates", + "sha256": "183016491b6cef55d0b98e09cc2ea131721dd8de506f5896538b05aaf6e2fc30", + "size": 118922, + "subdir": "linux-64", + "timestamp": 1547904614146, + "version": "2018.12.5" + }, + "ca-certificates-2019.1.23-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "ISC", + "md5": "e5da6ab8ae9930e097629a3e3c74ee44", + "name": "ca-certificates", + "sha256": "a3a933e746e2a0f8667b5d1236a32cb8b523b38cd42e629e5b4d5de4c5a2eca5", + "size": 122834, + "subdir": "linux-64", + "timestamp": 1549469958294, + "version": "2019.1.23" + }, + "ca-certificates-2019.10.16-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MPL 2.0", + "md5": "5a39c8676b3e852e884ae67503e71889", + "name": "ca-certificates", + "sha256": "cbcd975dfc0f6a4015f518755a2db1c5a96539b720fbaf165c59eaf099336d17", + "size": 126843, + "subdir": "linux-64", + "timestamp": 1571667840027, + "version": "2019.10.16" + }, + "ca-certificates-2019.11.27-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MPL 2.0", + "md5": "d5ca9822f5f4cc2f45d55f5bb7528d0e", + "name": "ca-certificates", + "sha256": "e03711f27f1d24b79a4c115e63079547dcc85e8e94fe88bf2424b70d61dbe071", + "size": 127033, + "subdir": "linux-64", + "timestamp": 1575390278009, + "version": "2019.11.27" + }, + "ca-certificates-2019.5.15-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "ISC", + "md5": "d3b5e5a33d42fc8e1906dad3aa936c0e", + "name": "ca-certificates", + "sha256": "37efbe76380bd9297b47d96ad9aec45df28445c536ab69bcea7442c2cd4e8995", + "size": 128906, + "subdir": "linux-64", + "timestamp": 1559573053639, + "version": "2019.5.15" + }, + "ca-certificates-2019.5.15-1.conda": { + "build": "1", + "build_number": 1, + "depends": [], + "license": "MPL 2.0", + "md5": "8d67f618993359e975f1e079655b5843", + "name": "ca-certificates", + "sha256": "6d144fcfd9339cc5855ba528134c74d90c6aebeb52786878afdc70d54f45957f", + "size": 129498, + "subdir": "linux-64", + "timestamp": 1565373897594, + "version": "2019.5.15" + }, + "ca-certificates-2019.8.28-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MPL 2.0", + "md5": "aad98fcdcd78a08eaf6ddde388ee9a52", + "name": "ca-certificates", + "sha256": "d8e4be5a499f2b58dc23d8fad6792b0bd60a0bd2d9b68a8c9b8f6a503242f935", + "size": 128265, + "subdir": "linux-64", + "timestamp": 1569263563402, + "version": "2019.8.28" + }, + "ca-certificates-2020.1.1-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MPL 2.0", + "md5": "fa1bb4e047490072651f66470156fcab", + "name": "ca-certificates", + "sha256": "1e49d4d849b989d744b360c8231d7aa887ebe1b2ecce634763cce35149d20f7a", + "size": 128129, + "subdir": "linux-64", + "timestamp": 1580397398199, + "version": "2020.1.1" + }, + "ca-certificates-2020.10.14-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MPL 2.0", + "md5": "1566514c1d3dd7d171f1623bae95df41", + "name": "ca-certificates", + "sha256": "e2fea9ffd9e1c31b4201cf26ea173532e7c081e32b4188d739b33485f206a794", + "size": 124281, + "subdir": "linux-64", + "timestamp": 1602686167355, + "version": "2020.10.14" + }, + "ca-certificates-2020.10.14-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "MPL 2.0", + "md5": "2b808c38e5dc9135fcd7f09627aa0941", + "name": "ca-certificates", + "sha256": "e9c0c3d7023bac6b15f5769b422abde87ea6d1dc70dcefddd1b88fb355623535", + "size": 126686, + "subdir": "linux-64", + "timestamp": 1615235699903, + "version": "2020.10.14" + }, + "ca-certificates-2020.12.8-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MPL 2.0", + "md5": "5fa954be2b648b25b03f685f66600065", + "name": "ca-certificates", + "sha256": "df78f0798e0b78035a04026aff24dd68f96a083db94dba5ac93538591c97f200", + "size": 124367, + "subdir": "linux-64", + "timestamp": 1607534080645, + "version": "2020.12.8" + }, + "ca-certificates-2020.12.8-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "MPL 2.0", + "md5": "57698d05dd3b34462694f360bb5ca817", + "name": "ca-certificates", + "sha256": "90751fe22c5365d965de80f784a4c2181bd53e367ec373462e650696f462affe", + "size": 126714, + "subdir": "linux-64", + "timestamp": 1615235836155, + "version": "2020.12.8" + }, + "ca-certificates-2020.6.24-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MPL 2.0", + "md5": "88806efb4b82b835538c934b2e0d3cfb", + "name": "ca-certificates", + "sha256": "8325167ff5a4bf5e6e472279167d835ff3cd2baac2daa44d669db5a7f79a9a4d", + "size": 128197, + "subdir": "linux-64", + "timestamp": 1593447023312, + "version": "2020.6.24" + }, + "ca-certificates-2020.7.22-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MPL 2.0", + "md5": "3efde69d1bd20bac0b3be953e0c26114", + "name": "ca-certificates", + "sha256": "33cf0a0d3e8a1e768ccd82c1b65c7ce932105991d348e694881204c1ba139af1", + "size": 127561, + "subdir": "linux-64", + "timestamp": 1598370614858, + "version": "2020.7.22" + }, + "ca-certificates-2021.1.19-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MPL 2.0", + "md5": "c73203541f779cf79629e9dbe62f5e0b", + "name": "ca-certificates", + "sha256": "9076a0b499133c87b3ae1817e09e0b70548e654ad9852a87a68b5527634d8063", + "size": 124389, + "subdir": "linux-64", + "timestamp": 1611080983330, + "version": "2021.1.19" + }, + "ca-certificates-2021.1.19-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "MPL 2.0", + "md5": "b1d800948038de3f943c3e81fe7febee", + "name": "ca-certificates", + "sha256": "e99bfa3339cd7a0166b053841a1603a24cac9856741e07d848cfa6b3e6fe06a7", + "size": 121120, + "subdir": "linux-64", + "timestamp": 1615236578251, + "version": "2021.1.19" + }, + "ca-certificates-2021.10.26-h06a4308_2.conda": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [], + "license": "MPL 2.0", + "md5": "55d8c51214ce7b3ddf594da13848a122", + "name": "ca-certificates", + "sha256": "21c5250eaf84aa88798be552362c3c1565924a8892d6bc4bedb14f531083a9aa", + "size": 117595, + "subdir": "linux-64", + "timestamp": 1635220140842, + "version": "2021.10.26" + }, + "ca-certificates-2021.4.13-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "MPL 2.0", + "md5": "d6952de0f4013b4e0edc84e9b61613f4", + "name": "ca-certificates", + "sha256": "674973d801d26a55f9ceeea36d15d34fd465466364d8933b669bf087616fa527", + "size": 117148, + "subdir": "linux-64", + "timestamp": 1618348422167, + "version": "2021.4.13" + }, + "ca-certificates-2021.5.25-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "MPL 2.0", + "md5": "3a2f8a1a5c82296693933f8c3f236fcb", + "name": "ca-certificates", + "sha256": "6f88ed7629479ae99fb8b75a64aaf46a12a445e981f2c9353a8f3128b944ee1a", + "size": 114222, + "subdir": "linux-64", + "timestamp": 1621995548182, + "version": "2021.5.25" + }, + "ca-certificates-2021.7.5-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "MPL 2.0", + "md5": "b2fecf5efa58597ba5f49c6b8217dee4", + "name": "ca-certificates", + "sha256": "62ce49d5262991b1d2ad46e47b2ea53c793c65f98d4c210bbf17a89a25d837ae", + "size": 115448, + "subdir": "linux-64", + "timestamp": 1625555175911, + "version": "2021.7.5" + }, + "ca-certificates-2021.9.30-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "MPL 2.0", + "md5": "9c653cb24cdb68831f8884b0e29a0dbc", + "name": "ca-certificates", + "sha256": "02909c3dbadd7100227cfbbbeb610f65a555ab6587957acacc3adc0a036fa33c", + "size": 118658, + "subdir": "linux-64", + "timestamp": 1633726261918, + "version": "2021.9.30" + }, + "ca-certificates-2022.07.19-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "6d4c2a14b2bdebc9507442efbda8208e", + "name": "ca-certificates", + "sha256": "d7bff8f6f6662c1d35fb3b353635e574e1ee8b59dbef78626c398aac0872e9ca", + "size": 126735, + "subdir": "linux-64", + "timestamp": 1658515750713, + "version": "2022.07.19" + }, + "ca-certificates-2022.10.11-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "e9b86b388e2cf59585fefca34037b783", + "name": "ca-certificates", + "sha256": "f4aacc185db1364a6fd424449b8cfed41fb81236ce5b2ed94ee02147348e8110", + "size": 127486, + "subdir": "linux-64", + "timestamp": 1666896166290, + "version": "2022.10.11" + }, + "ca-certificates-2022.2.1-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MPL-2.0", + "md5": "86abb087a0e31eb952e7204a7b9291e8", + "name": "ca-certificates", + "sha256": "58b47e2c507eec8a07771a84b57fae72d67813c2efe45e06229b2831af073fd3", + "size": 120330, + "subdir": "linux-64", + "timestamp": 1646123316724, + "version": "2022.2.1" + }, + "ca-certificates-2022.3.18-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MPL-2.0", + "md5": "adbff70d0bc1d3a07db4efc995ee7fee", + "name": "ca-certificates", + "sha256": "baebb0253c3c89611e9cbdbb62f2d0f547c2d6172b054f82b4b67801c7dfbb09", + "size": 119344, + "subdir": "linux-64", + "timestamp": 1648041530952, + "version": "2022.3.18" + }, + "ca-certificates-2022.3.29-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MPL-2.0", + "md5": "405c137b818ce227351539aadf9c7699", + "name": "ca-certificates", + "sha256": "ded1963a4fedd3d0b6079fe439580b463c8b1221a6c9912fd7763a410091227f", + "size": 119350, + "subdir": "linux-64", + "timestamp": 1648715659867, + "version": "2022.3.29" + }, + "ca-certificates-2022.3.29-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "MPL-2.0", + "md5": "24b7f127a225bf5a559f440e289d8fe8", + "name": "ca-certificates", + "sha256": "21c035182733089067835dae937cf9d0420af15783c4f66bf5be59b1680b7186", + "size": 119560, + "subdir": "linux-64", + "timestamp": 1650465431383, + "version": "2022.3.29" + }, + "ca-certificates-2022.4.26-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "fc9c0bf2e7893f5407ff74289dbcf295", + "name": "ca-certificates", + "sha256": "cd75d93dfee17a55d1a05fa2a791432649cf6e7b6ee240c7707310ec75e70880", + "size": 126721, + "subdir": "linux-64", + "timestamp": 1651525656359, + "version": "2022.4.26" + }, + "ca-certificates-2023.01.10-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "7704989a2ccf6c1f5a50c985509841c4", + "name": "ca-certificates", + "sha256": "55b0c8de2a7a4a0d82b8f4a27d0ef60ba4bed5bf7c907090442f1b42279149e9", + "size": 122761, + "subdir": "linux-64", + "timestamp": 1674218473994, + "version": "2023.01.10" + }, + "cachecontrol-0.12.11-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c3c1b6522e57930c865bb7c1a4326092", + "name": "cachecontrol", + "sha256": "c1e7c84538d2f7c328ee316105ec192df19ddbb1b3c8745e8665eb0e76aca440", + "size": 36504, + "subdir": "linux-64", + "timestamp": 1669763996925, + "version": "0.12.11" + }, + "cachecontrol-0.12.11-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "msgpack-python >=0.5.2", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ccd7aac19ce0f4f779b0a30deb454329", + "name": "cachecontrol", + "sha256": "68368bd113e38857c28a9bc90ad4c28234df6588cb369ab476464c99c85d5399", + "size": 36390, + "subdir": "linux-64", + "timestamp": 1676365779369, + "version": "0.12.11" + }, + "cachecontrol-0.12.11-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "msgpack-python >=0.5.2", + "python >=3.11,<3.12.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "afd564f993e85b5d870d52754bfb9618", + "name": "cachecontrol", + "sha256": "56a9366b559ade59cea168361705adac396e277d8eb935381a1fd557ce5f0454", + "size": 43074, + "subdir": "linux-64", + "timestamp": 1676823146481, + "version": "0.12.11" + }, + "cachecontrol-0.12.11-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4f6cb892f50ea1b07dd5514813927652", + "name": "cachecontrol", + "sha256": "ab1c9c0da0cfddb787a612e805a867e74a20b8c28072a5726b5c1d5062a610c1", + "size": 36103, + "subdir": "linux-64", + "timestamp": 1669763970943, + "version": "0.12.11" + }, + "cachecontrol-0.12.11-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "msgpack-python >=0.5.2", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bf5f936d517fbdcda362ec662eaebf95", + "name": "cachecontrol", + "sha256": "0321a522b330c4b6d8ee30613e7a6e1d4f2d247d838f792873f913922f71d8c2", + "size": 35999, + "subdir": "linux-64", + "timestamp": 1676365654469, + "version": "0.12.11" + }, + "cachecontrol-0.12.11-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "368e3df4742f663a460dd99895cd7c86", + "name": "cachecontrol", + "sha256": "ec862c63f3cd940557070b3b9611a47743955b1f9dfc95170bf80ab1fe83a70d", + "size": 36326, + "subdir": "linux-64", + "timestamp": 1669764022425, + "version": "0.12.11" + }, + "cachecontrol-0.12.11-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "msgpack-python >=0.5.2", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "728b2527c39aeca55dbf11f346948aa3", + "name": "cachecontrol", + "sha256": "d840b194b0eb55f550d24ee098087e85db1f674ab0c6455427fbf40950eac03b", + "size": 36211, + "subdir": "linux-64", + "timestamp": 1676365717078, + "version": "0.12.11" + }, + "cachecontrol-0.12.11-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "15014cca3958f52a31a7b83948aff92c", + "name": "cachecontrol", + "sha256": "c8111b37574c2d1f821a827b39a2af4960c0cbf6de16e0192bc51270399f57bd", + "size": 36271, + "subdir": "linux-64", + "timestamp": 1669764047994, + "version": "0.12.11" + }, + "cachecontrol-0.12.11-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "msgpack-python >=0.5.2", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7cb28c6fae676fea9d0f6cdabff2bb18", + "name": "cachecontrol", + "sha256": "b8fe77a8ec221cad04f70de9c3a23e0400cecda739f3e4192131ebb99b388536", + "size": 36181, + "subdir": "linux-64", + "timestamp": 1676365592172, + "version": "0.12.11" + }, + "cachecontrol-0.12.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "msgpack-python", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "53489048033370d5ea4c819de5dc96e0", + "name": "cachecontrol", + "sha256": "434d567ac8f11bfe8d29e79c904da8810ad3130a050bbfe13c909d561a09943a", + "size": 30286, + "subdir": "linux-64", + "timestamp": 1519226605932, + "version": "0.12.4" + }, + "cachecontrol-0.12.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "msgpack-python", + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "c2797712fae1e795ab514d4d3e105fa9", + "name": "cachecontrol", + "sha256": "43f69fe98d73301312e0fb7800bc46a5c33adaf32c4a39939b699066e231bd7b", + "size": 30580, + "subdir": "linux-64", + "timestamp": 1519226615491, + "version": "0.12.4" + }, + "cachecontrol-0.12.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "msgpack-python", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "092d3fac4728f49469cde922613926e2", + "name": "cachecontrol", + "sha256": "cd4e344cce11d5916913de49e1f40def3ee1af16db84227238f278ead79912b3", + "size": 30119, + "subdir": "linux-64", + "timestamp": 1519226580627, + "version": "0.12.4" + }, + "cachecontrol-0.12.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "msgpack-python", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3a74d190a56b0498bdd21e9ad0c2eb74", + "name": "cachecontrol", + "sha256": "673a201e8495611828a6dc527ec421ec8a90e05b81a223c4d6ec28ef2baa1e5c", + "size": 29878, + "subdir": "linux-64", + "timestamp": 1529417555467, + "version": "0.12.5" + }, + "cachecontrol-0.12.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "msgpack-python", + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ee7fbea2864f27936477d8e84451168b", + "name": "cachecontrol", + "sha256": "cbcb029cf2323ce8c995deb576707538486f28256e08dbdde3c04749a8730e85", + "size": 30210, + "subdir": "linux-64", + "timestamp": 1529417617404, + "version": "0.12.5" + }, + "cachecontrol-0.12.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "msgpack-python", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a081a712867295233501d27c0d5ee8b0", + "name": "cachecontrol", + "sha256": "f014ed3bdf40ac6bf78eeedf538ec950a24edaceacf33340fccaf07aabdd17e5", + "size": 29931, + "subdir": "linux-64", + "timestamp": 1529417537312, + "version": "0.12.5" + }, + "cachecontrol-0.12.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "msgpack-python", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d07317d8847fa79aff20f4f31bec09b4", + "name": "cachecontrol", + "sha256": "ca7989e01abaeaba64f0c3842768a314c33df822cedfe8b0b965f829f560834d", + "size": 29963, + "subdir": "linux-64", + "timestamp": 1530781638386, + "version": "0.12.5" + }, + "cachecontrol-0.12.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "msgpack-python", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0c3ff04b1975d83f8f5d72c2119c15f4", + "name": "cachecontrol", + "sha256": "521a5dc32b42cfd113e37e4d19598a69c316f7b4757b695f71f7ddd9f5415a15", + "size": 220412, + "subdir": "linux-64", + "timestamp": 1592211698539, + "version": "0.12.5" + }, + "cachecontrol-with-filecache-0.12.11-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py310h06a4308_1", + "lockfile >=0.9", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b9fbbb852908dce0ce900c01fb2682d1", + "name": "cachecontrol-with-filecache", + "sha256": "8584b6ba9278d0be56e0bdfa5557e78247240b6d95653f376ee2db636a6a25e7", + "size": 4772, + "subdir": "linux-64", + "timestamp": 1676365786667, + "version": "0.12.11" + }, + "cachecontrol-with-filecache-0.12.11-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py311h06a4308_1", + "lockfile >=0.9", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "735c36f8730c5683d80b32df3d66e466", + "name": "cachecontrol-with-filecache", + "sha256": "04c84a192ac6f980eb5a4e4b9a1627a363b94865958fa2bc34682408c7cba2f4", + "size": 4720, + "subdir": "linux-64", + "timestamp": 1679517108772, + "version": "0.12.11" + }, + "cachecontrol-with-filecache-0.12.11-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py37h06a4308_1", + "lockfile >=0.9", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c7cc3cf6cb4d986d4e2f5becc157d8f4", + "name": "cachecontrol-with-filecache", + "sha256": "3cbff72f911a961184fdcb0757bc3512384f8f2ecfbcfdf6433a9590c93de055", + "size": 4744, + "subdir": "linux-64", + "timestamp": 1676365661351, + "version": "0.12.11" + }, + "cachecontrol-with-filecache-0.12.11-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py38h06a4308_1", + "lockfile >=0.9", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aa79209ade9d06dfe4dc2555e6d83ccd", + "name": "cachecontrol-with-filecache", + "sha256": "5d691aac99c70eccd5c3042500cbc260835b003778d2f05d1212c4f7932e71ae", + "size": 4749, + "subdir": "linux-64", + "timestamp": 1676365723863, + "version": "0.12.11" + }, + "cachecontrol-with-filecache-0.12.11-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py39h06a4308_1", + "lockfile >=0.9", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ac6acde0fa3e428fa2c10c91765e7d85", + "name": "cachecontrol-with-filecache", + "sha256": "ab58c2306c3925591a3986808cf6d9041cf00925851446270a8461a99bfa051e", + "size": 4749, + "subdir": "linux-64", + "timestamp": 1676365599295, + "version": "0.12.11" + }, + "cachecontrol-with-redis-0.12.11-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py310h06a4308_1", + "python >=3.10,<3.11.0a0", + "redis-py >=2.10.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bb3ce806229eef8c880f63b1c451f42e", + "name": "cachecontrol-with-redis", + "sha256": "75fc0190d53bb1a1e9f00eaa217ba163d334528c0281499e79e06505ea1f6bd8", + "size": 4752, + "subdir": "linux-64", + "timestamp": 1676365793911, + "version": "0.12.11" + }, + "cachecontrol-with-redis-0.12.11-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py311h06a4308_1", + "python >=3.11,<3.12.0a0", + "redis-py >=2.10.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "60d2112447e00ac0d51feeb471dda108", + "name": "cachecontrol-with-redis", + "sha256": "30ac11ce8297dcefa1a268bc9bc9af6a380c63fd504bb968e7307386770e84ea", + "size": 4700, + "subdir": "linux-64", + "timestamp": 1679517115954, + "version": "0.12.11" + }, + "cachecontrol-with-redis-0.12.11-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py37h06a4308_1", + "python >=3.7,<3.8.0a0", + "redis-py >=2.10.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d7f22cea8faf0eece64f1722a8187b4a", + "name": "cachecontrol-with-redis", + "sha256": "9f38cd0e154a3ff0d077156093ba4816bc45a92801817d04a67102ffd466c228", + "size": 4729, + "subdir": "linux-64", + "timestamp": 1676365668147, + "version": "0.12.11" + }, + "cachecontrol-with-redis-0.12.11-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py38h06a4308_1", + "python >=3.8,<3.9.0a0", + "redis-py >=2.10.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d9edc2e87d068f43ff156ed7ad4c3139", + "name": "cachecontrol-with-redis", + "sha256": "44f93eac2658f338095d03f1a14b91316ad7acc9d728e887377782dfdecef9b8", + "size": 4731, + "subdir": "linux-64", + "timestamp": 1676365730656, + "version": "0.12.11" + }, + "cachecontrol-with-redis-0.12.11-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol 0.12.11 py39h06a4308_1", + "python >=3.9,<3.10.0a0", + "redis-py >=2.10.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2f11c07d287d12d0a236ae9ee5e96056", + "name": "cachecontrol-with-redis", + "sha256": "4740918bf7e72e55c0d810e09bf6b51c5fc4952a322330a6181a0b20bba3bfbd", + "size": 4733, + "subdir": "linux-64", + "timestamp": 1676365606278, + "version": "0.12.11" + }, + "cached-property-1.3.1-py27h5a28e80_0.conda": { + "build": "py27h5a28e80_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f9aeb497c02734afca49971fd4e7ed57", + "name": "cached-property", + "sha256": "f6f873a3a1f24b8f3b2cb850849e35169d683f0e9b6ca096e94f802c3375e051", + "size": 10946, + "subdir": "linux-64", + "timestamp": 1507578601685, + "version": "1.3.1" + }, + "cached-property-1.3.1-py35hbda3ba5_0.conda": { + "build": "py35hbda3ba5_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d5e356847bbcef1c16fdb5a10055d438", + "name": "cached-property", + "sha256": "13461fe3139dfce6361626bce880e29156f1ee7e9a2cd20abc9e631e4d49411a", + "size": 11137, + "subdir": "linux-64", + "timestamp": 1507578602481, + "version": "1.3.1" + }, + "cached-property-1.3.1-py36h8cf1ab6_0.conda": { + "build": "py36h8cf1ab6_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f325407c7cb24fd40d396ba07d50076", + "name": "cached-property", + "sha256": "64e9f7276fddb84f3619d442280d4ca9155349116a46d57420fe4b5892c9cba5", + "size": 11089, + "subdir": "linux-64", + "timestamp": 1507578622991, + "version": "1.3.1" + }, + "cached-property-1.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6c7b03e2542f02adb7ec462e34734afe", + "name": "cached-property", + "sha256": "e88126394e24923c87531dd03afe330bce16d37c19f05d2f7303334d9c669834", + "size": 11596, + "subdir": "linux-64", + "timestamp": 1519671776419, + "version": "1.4.0" + }, + "cached-property-1.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8dd7eaaec26056d34991e70c6d03ed17", + "name": "cached-property", + "sha256": "cdd562a05d3f53171640540795f977d89281e219eb5c22a41925db9e02b71463", + "size": 11755, + "subdir": "linux-64", + "timestamp": 1519671862783, + "version": "1.4.0" + }, + "cached-property-1.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5867f721cf8dcd4a45f798154b9fce7b", + "name": "cached-property", + "sha256": "12ef412d348b09a8a60a4c2886dc72eb583db52a29f914c5a5b06a9b004ed3f7", + "size": 11732, + "subdir": "linux-64", + "timestamp": 1519671894584, + "version": "1.4.0" + }, + "cached-property-1.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "812433f8c3ae5fa20ece1ae838acc026", + "name": "cached-property", + "sha256": "1c0ef7127c73ef3e19d6a50463fbcb928f176e811c6780f0ada6d7ddca9a6546", + "size": 11771, + "subdir": "linux-64", + "timestamp": 1524002018575, + "version": "1.4.2" + }, + "cached-property-1.4.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "16acb965c372694983c40bed3e75bb1d", + "name": "cached-property", + "sha256": "59b13114b5089f6b8329098d64345473fa16fba4577ba0750776f935e474701d", + "size": 11986, + "subdir": "linux-64", + "timestamp": 1524001977491, + "version": "1.4.2" + }, + "cached-property-1.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e17f436daab5ab55c040a0130e03a40e", + "name": "cached-property", + "sha256": "c47b35d57760b476d8aa678f584ade22c713cedf1a909df0653764e63e19c4bb", + "size": 11959, + "subdir": "linux-64", + "timestamp": 1524002551290, + "version": "1.4.2" + }, + "cached-property-1.4.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1f841c276a4f7af082b1980696abda76", + "name": "cached-property", + "sha256": "b042e0765229f51aa5dc778fc0fbc9afa57d18557c10b1f4596fc85c0bb61562", + "size": 11760, + "subdir": "linux-64", + "timestamp": 1529418805430, + "version": "1.4.3" + }, + "cached-property-1.4.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "35b1b624b4c2884d6198f78603cfdb22", + "name": "cached-property", + "sha256": "1e8150a5d247d225bd842a6a7b7971f44bfb407eb9468c91bbd6937539ac9654", + "size": 11875, + "subdir": "linux-64", + "timestamp": 1529418840641, + "version": "1.4.3" + }, + "cached-property-1.4.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1168636d45a163d26c8c91fbda12e368", + "name": "cached-property", + "sha256": "4ac9232434db5e22f953eeae35e688f198ff6dbe24f50f3a353d3062253f31ee", + "size": 11835, + "subdir": "linux-64", + "timestamp": 1529418805036, + "version": "1.4.3" + }, + "cached-property-1.4.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b8014430fa66e46b7c80347a92d52358", + "name": "cached-property", + "sha256": "d1087cf973b5ced32e60e68b8fecfcd8e1c000db3fa87cbcaf37156416f887d3", + "size": 11833, + "subdir": "linux-64", + "timestamp": 1530781664320, + "version": "1.4.3" + }, + "cached-property-1.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fe9178b1208f18d4aeb58e774f8190c7", + "name": "cached-property", + "sha256": "041cd6538c0f7cb3c446e6aafabccb3f03e69959a1f5b7fdf53b78bcf8979ea2", + "size": 11959, + "subdir": "linux-64", + "timestamp": 1539470848370, + "version": "1.5.1" + }, + "cached-property-1.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fdc954387a9bdc3eeb161ff44d8da64a", + "name": "cached-property", + "sha256": "7a65aa4ce6f8cc699c1baa75eb00d2ebaef4c76308a11064bac240e3f766c9d5", + "size": 12132, + "subdir": "linux-64", + "timestamp": 1539470867839, + "version": "1.5.1" + }, + "cached-property-1.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b80beb6b1174c9a0ce3651057567ffaf", + "name": "cached-property", + "sha256": "008e6405028d996fdfffde1e778e0f2fd5703327e81532fd4498613da31dfa29", + "size": 12158, + "subdir": "linux-64", + "timestamp": 1539470869897, + "version": "1.5.1" + }, + "cached-property-1.5.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "658a535512864a93a9d580f4be9bdb96", + "name": "cached-property", + "sha256": "fd2911b8cf1c31895e71048a764016d5713d86ead36f0defaa11ab9dcf333fac", + "size": 14488, + "subdir": "linux-64", + "timestamp": 1593094918833, + "version": "1.5.1" + }, + "cachelib-0.9.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ec695408cc33c79a9467ca09f58445d5", + "name": "cachelib", + "sha256": "48955113567bae4b18e3ce4b3cffafaee21c854a24faa41b302144f7fd9546e9", + "size": 28753, + "subdir": "linux-64", + "timestamp": 1659783135203, + "version": "0.9.0" + }, + "cachelib-0.9.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "226c596fb569c72ee0c41e707de0911f", + "name": "cachelib", + "sha256": "89953fb7a8672a71ad4a051340a5ffa1b85827fa7bbc037f2980e41238eb2a3c", + "size": 36807, + "subdir": "linux-64", + "timestamp": 1676827690863, + "version": "0.9.0" + }, + "cachelib-0.9.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c73233b255cac108ed6c5bae6d12af39", + "name": "cachelib", + "sha256": "2e3254cfed8bf3aaca24a518350c5caebfe75d35da4fa4a24fe4d68ae4ac44fd", + "size": 28122, + "subdir": "linux-64", + "timestamp": 1659783189062, + "version": "0.9.0" + }, + "cachelib-0.9.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a1c90504d657f5bbe31fc2a2fd52640e", + "name": "cachelib", + "sha256": "d4bd73eb302ac72111646fb736796f5f4930135dc3b206d14fe51c4674c6c95d", + "size": 28410, + "subdir": "linux-64", + "timestamp": 1659783161685, + "version": "0.9.0" + }, + "cachelib-0.9.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "88562364283d22d9d62f9354e7d758b7", + "name": "cachelib", + "sha256": "736b81fc553cd8f05605b85deb6f4d052bc5ca2ad2db16e71c229f576615b4c7", + "size": 28342, + "subdir": "linux-64", + "timestamp": 1659783220196, + "version": "0.9.0" + }, + "caffe-1.0-py27h0c9280d_3.conda": { + "build": "py27h0c9280d_3", + "build_number": 3, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ea18dd15479330e4eadf8935a3b52098", + "name": "caffe", + "sha256": "1848efa692e4fe06218e09bff1a1e216ecd618f7dd70e09778aeea8c046342a8", + "size": 1995204, + "subdir": "linux-64", + "timestamp": 1525318182663, + "version": "1.0" + }, + "caffe-1.0-py27h2a89de5_5.conda": { + "build": "py27h2a89de5_5", + "build_number": 5, + "depends": [ + "blas * openblas", + "boost", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "961be3f8a5e67174e504f684dcdb9918", + "name": "caffe", + "sha256": "db7009bd376dd209bf4bc1eef2af915b52787c798923c625dee1d873daf7001d", + "size": 2968862, + "subdir": "linux-64", + "timestamp": 1548969146475, + "version": "1.0" + }, + "caffe-1.0-py27h620bdfb_4.conda": { + "build": "py27h620bdfb_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "23b0fbf3a1d79b12b187de44641f6366", + "name": "caffe", + "sha256": "b6f50a9c0707dbe0982969e791d01fceb67bd83788fec4c1be1f5dfec651fa0b", + "size": 2946250, + "subdir": "linux-64", + "timestamp": 1537898701678, + "version": "1.0" + }, + "caffe-1.0-py27h69a20d1_2.conda": { + "build": "py27h69a20d1_2", + "build_number": 2, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "249c634f3ec5bba66c471cacb8e619b6", + "name": "caffe", + "sha256": "0fcd1a92f0e71b9f994488e52d4e6036cb9f92eb3f180e41af3bc0e813322e0b", + "size": 1992631, + "subdir": "linux-64", + "timestamp": 1515108207217, + "version": "1.0" + }, + "caffe-1.0-py27h7073e3f_4.conda": { + "build": "py27h7073e3f_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e43620a3e145535b2333fda1e4211f7d", + "name": "caffe", + "sha256": "097dfa4a04113203304656eec0eb37a26864bdcfb338587cbdcfb787dbf332cf", + "size": 2947274, + "subdir": "linux-64", + "timestamp": 1537898983653, + "version": "1.0" + }, + "caffe-1.0-py27h851f731_2.conda": { + "build": "py27h851f731_2", + "build_number": 2, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a1b2f4385c9fe41327d6a822e8ef0d61", + "name": "caffe", + "sha256": "5dafc058ae5ed3f0d8b5c6a09776fa51912bfb8be0f87fb9ef380ff8a5b01467", + "size": 1996494, + "subdir": "linux-64", + "timestamp": 1515110383495, + "version": "1.0" + }, + "caffe-1.0-py27hbab4207_5.conda": { + "build": "py27hbab4207_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5c278a5c9a5e98de7bd30b69da198dc1", + "name": "caffe", + "sha256": "7dcdae3f1e69f99ae613e3b0a5d26da138de88adb104decaa930f645f70c084c", + "size": 2967137, + "subdir": "linux-64", + "timestamp": 1548968910815, + "version": "1.0" + }, + "caffe-1.0-py27hdb41b07_3.conda": { + "build": "py27hdb41b07_3", + "build_number": 3, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "282cf069ea590b1a4d285b4acc01a82f", + "name": "caffe", + "sha256": "e4dec1cd7d34c45eb0a5b159e1805ce9c5e64c607e0303a8a3365230a5526b02", + "size": 1996683, + "subdir": "linux-64", + "timestamp": 1525317622520, + "version": "1.0" + }, + "caffe-1.0-py35h0c9280d_3.conda": { + "build": "py35h0c9280d_3", + "build_number": 3, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a19a7d8aa7419188dc71268f6b58206e", + "name": "caffe", + "sha256": "2efe6bef01344dd5316ba60638798c0dde1971647d507d71c6729498315024e1", + "size": 1988054, + "subdir": "linux-64", + "timestamp": 1525317957659, + "version": "1.0" + }, + "caffe-1.0-py35h620bdfb_4.conda": { + "build": "py35h620bdfb_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "cd1bcd0650d16cf0bd4234feb30e2e69", + "name": "caffe", + "sha256": "935d148c95004a086c4704227f88ec74d20c39f7d81abfe6b9cc06495bf75fc7", + "size": 2953460, + "subdir": "linux-64", + "timestamp": 1537899251537, + "version": "1.0" + }, + "caffe-1.0-py35h69a20d1_2.conda": { + "build": "py35h69a20d1_2", + "build_number": 2, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3c90723e1d59c6af6e4f533615ae2e72", + "name": "caffe", + "sha256": "94b3c8d578a99b33ead914d9a4bf780b6a7cec5388d984ea0527349af82b5b1d", + "size": 1992798, + "subdir": "linux-64", + "timestamp": 1515108537810, + "version": "1.0" + }, + "caffe-1.0-py35h7073e3f_4.conda": { + "build": "py35h7073e3f_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c155d3e6d2d419804b0fd091b30c9bff", + "name": "caffe", + "sha256": "a140317ac004a794b6f1fbbe0be3fdf3a2766793b7a5573e3924ddb1b0595071", + "size": 2953616, + "subdir": "linux-64", + "timestamp": 1537899470193, + "version": "1.0" + }, + "caffe-1.0-py35h851f731_2.conda": { + "build": "py35h851f731_2", + "build_number": 2, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.13.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7ddf5e5604a4a6c747927de04b53abfe", + "name": "caffe", + "sha256": "ac8040b26af531f4fb4611b12ffe398be0e25eef3306726eb1d0c367e5bc5b7a", + "size": 1994036, + "subdir": "linux-64", + "timestamp": 1515108535455, + "version": "1.0" + }, + "caffe-1.0-py35hdb41b07_3.conda": { + "build": "py35hdb41b07_3", + "build_number": 3, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "92e9913ca13ddc0b8afcdf73dd3b85d9", + "name": "caffe", + "sha256": "3808758f0e81326d6b049216fc10c0d634ecc663f57881c58661b452adf5e1f6", + "size": 1987069, + "subdir": "linux-64", + "timestamp": 1525319248537, + "version": "1.0" + }, + "caffe-1.0-py36h0c9280d_3.conda": { + "build": "py36h0c9280d_3", + "build_number": 3, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "dd90777a07f15d3aff1858c3dd0ba8c9", + "name": "caffe", + "sha256": "69631f700578f9ef1acb1654fb4dbbcb29519abe51231cbea3d4417a8a589a64", + "size": 1991976, + "subdir": "linux-64", + "timestamp": 1525318168765, + "version": "1.0" + }, + "caffe-1.0-py36h2a89de5_5.conda": { + "build": "py36h2a89de5_5", + "build_number": 5, + "depends": [ + "blas * openblas", + "boost", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "35dccbf2376945028895d9b463e11a57", + "name": "caffe", + "sha256": "ec607c598950b6fa71b780dcfacb34229d29549a03a813d0116d6efdbba3dbf6", + "size": 2967842, + "subdir": "linux-64", + "timestamp": 1548969624107, + "version": "1.0" + }, + "caffe-1.0-py36h620bdfb_4.conda": { + "build": "py36h620bdfb_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8d8c855e304f8544bb7dd04a664e6918", + "name": "caffe", + "sha256": "2d88c670f2380bc937021992e49e701f7090d623692c929923e14a7ff13c7995", + "size": 2952659, + "subdir": "linux-64", + "timestamp": 1537899720366, + "version": "1.0" + }, + "caffe-1.0-py36h69a20d1_2.conda": { + "build": "py36h69a20d1_2", + "build_number": 2, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "1bb2e5c27b5eab2d48a7a84b5a625914", + "name": "caffe", + "sha256": "260eb2aa613cadd13f028d620b768070cd3fda343465d9aa133e49a19b00d026", + "size": 1995918, + "subdir": "linux-64", + "timestamp": 1515110361321, + "version": "1.0" + }, + "caffe-1.0-py36h7073e3f_4.conda": { + "build": "py36h7073e3f_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4f4256e6beb5e3546a80d93048a3f504", + "name": "caffe", + "sha256": "8a53aa904b436dc8d62d8b8440f24e7849bf24d8095ef9d9891763a94a8ff91b", + "size": 2947141, + "subdir": "linux-64", + "timestamp": 1537899945757, + "version": "1.0" + }, + "caffe-1.0-py36h851f731_2.conda": { + "build": "py36h851f731_2", + "build_number": 2, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.13.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ee923dbbf283c31c6962225f72890f23", + "name": "caffe", + "sha256": "c7d8b6e1cc7373fe34bc332871ec251fcc2e7c4f2aeeb79cbd16185bd23c1091", + "size": 1990627, + "subdir": "linux-64", + "timestamp": 1515108536483, + "version": "1.0" + }, + "caffe-1.0-py36hbab4207_5.conda": { + "build": "py36hbab4207_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8c8c1550fffd843c8f11812c9262eb5f", + "name": "caffe", + "sha256": "ab922371676fc57e746cd0a17c028ddace2a0c200003d77e15157168b6a5161f", + "size": 2965508, + "subdir": "linux-64", + "timestamp": 1548969387400, + "version": "1.0" + }, + "caffe-1.0-py36hdb41b07_3.conda": { + "build": "py36hdb41b07_3", + "build_number": 3, + "depends": [ + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "65b2e0b78d050aa6f986beaa4eb651e6", + "name": "caffe", + "sha256": "ef718f0b1988df6a85a029341da6dcd6129eb047055af6a0027ff0efd01a0c2f", + "size": 1999107, + "subdir": "linux-64", + "timestamp": 1525317355483, + "version": "1.0" + }, + "caffe-1.0-py37h2a89de5_5.conda": { + "build": "py37h2a89de5_5", + "build_number": 5, + "depends": [ + "blas * openblas", + "boost", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "345abf51f13065110313dc955fcc7595", + "name": "caffe", + "sha256": "bd970ee7086a8f59e9f91c9b51033a9206b6b7001e2c7334d3a8b8f77396aa69", + "size": 2967790, + "subdir": "linux-64", + "timestamp": 1548968669209, + "version": "1.0" + }, + "caffe-1.0-py37h620bdfb_4.conda": { + "build": "py37h620bdfb_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7ad4ae57caae8e9158c759afe3862bc9", + "name": "caffe", + "sha256": "ec1c28560914063c639fdbd55ad5a18dd5f1180ae09af9d4e32e73ff9b36190e", + "size": 2951721, + "subdir": "linux-64", + "timestamp": 1537900208451, + "version": "1.0" + }, + "caffe-1.0-py37h7073e3f_4.conda": { + "build": "py37h7073e3f_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4bd36f7dd5e53956178aca1a26f64249", + "name": "caffe", + "sha256": "e43805a33586dd0a776f44377f0e6e965ff31ff54a7cfda12030027c9cf8533a", + "size": 2952703, + "subdir": "linux-64", + "timestamp": 1537900421901, + "version": "1.0" + }, + "caffe-1.0-py37hbab4207_5.conda": { + "build": "py37hbab4207_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3f0b0e199c8df192328c24b6623fa3ad", + "name": "caffe", + "sha256": "ae87911b227c81e15d6cc8a02378895d9b15e4c39a4481f4db2a76338c811fd5", + "size": 2965230, + "subdir": "linux-64", + "timestamp": 1548968397900, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h03f526a_2.conda": { + "build": "py27h03f526a_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn 6.0.*", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9bdc1812b421cf3d151e3a3f49584a9b", + "name": "caffe-gpu", + "sha256": "733829db1ba27411cdd2d495116684fbe86db35c0ba782e2d33ba1a761f4c50e", + "size": 3069316, + "subdir": "linux-64", + "timestamp": 1516471394391, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h1450b91_5.conda": { + "build": "py27h1450b91_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=8.0,<8.1.0a0", + "cudnn >=7.1.3,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "517f8bd07af3c76a69951ae51d0e848e", + "name": "caffe-gpu", + "sha256": "5ce7c46f2e6bb94997c77e0d55840e968edeb25a14e2abf52891f81162a4bc45", + "size": 3709250, + "subdir": "linux-64", + "timestamp": 1548972055799, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h16099b3_4.conda": { + "build": "py27h16099b3_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4d7d154722f1038ef896a2322ce41145", + "name": "caffe-gpu", + "sha256": "2bd86b72aa75bca9e7d3c6f4080b6d2e8d461c655fa8979c2d17602508f6a6ea", + "size": 4048308, + "subdir": "linux-64", + "timestamp": 1537911142368, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h2b1a04e_4.conda": { + "build": "py27h2b1a04e_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "eb08b1ad1c52e531d98b1a4003d4c549", + "name": "caffe-gpu", + "sha256": "4238afac047e1a85524925a721afe14a1972f6c410d1f261d397c0332d41ff38", + "size": 3954345, + "subdir": "linux-64", + "timestamp": 1537916475026, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h37b1cb2_3.conda": { + "build": "py27h37b1cb2_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9eb86520c5cf57f92f5c63a7a589183a", + "name": "caffe-gpu", + "sha256": "3247c033fd969336f02f0a75a4220f288fb1726ae23c303a1cc7cf235db3c629", + "size": 3072369, + "subdir": "linux-64", + "timestamp": 1525808621008, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h4dc7405_3.conda": { + "build": "py27h4dc7405_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "200cbaa93b5190a275651dee67c9ca30", + "name": "caffe-gpu", + "sha256": "179e9ac17e12941b859128ce3e7eed12a4009eb963cd092a47e91065173101c0", + "size": 3393740, + "subdir": "linux-64", + "timestamp": 1525911729195, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h51fbcb3_4.conda": { + "build": "py27h51fbcb3_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "6561d0c2f9cb198fb161f08bce406929", + "name": "caffe-gpu", + "sha256": "183b63410d4373b3d8517a126fd84e7fc78a0dcef9943a0cf014302109da5253", + "size": 3953925, + "subdir": "linux-64", + "timestamp": 1537918154342, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h550cbc0_5.conda": { + "build": "py27h550cbc0_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "2352b1725cdd141ce796b1a7a3a883bf", + "name": "caffe-gpu", + "sha256": "2c44c51ce306f893c408c0876a21b57eb82b98222ead4f4c4088c93715509e75", + "size": 4040631, + "subdir": "linux-64", + "timestamp": 1548975700843, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h62894bf_4.conda": { + "build": "py27h62894bf_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "614d05c6af316bf39417a233a5f001af", + "name": "caffe-gpu", + "sha256": "6360f86e8d38a75e31eb8fa43db77f673440d8d9071795220b9124285f41f2e4", + "size": 3716363, + "subdir": "linux-64", + "timestamp": 1537914585776, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h749159d_2.conda": { + "build": "py27h749159d_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn 6.0.*", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "2d75358ed4d3a31db7eccbc04c01d7c7", + "name": "caffe-gpu", + "sha256": "93916a9cdbb90c8d17bc492ae1e2661d5e04fcf0f4a567bd09412848e7336e98", + "size": 3072211, + "subdir": "linux-64", + "timestamp": 1516473015834, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h7b71608_4.conda": { + "build": "py27h7b71608_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "842f86db9fdef17b066f589a4b7219d7", + "name": "caffe-gpu", + "sha256": "1d8120d75e2c83c0af04ec74620aca5434099c4f0d7a02627d8bbf15250463ca", + "size": 4030482, + "subdir": "linux-64", + "timestamp": 1537912640657, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h960b796_3.conda": { + "build": "py27h960b796_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a7b3010cd092f191d66e06eaa7b1311d", + "name": "caffe-gpu", + "sha256": "8c37a5848abd81bb0faffaf3d019810b150b9b8b0f7c15a48bbaf038b68efc83", + "size": 3068973, + "subdir": "linux-64", + "timestamp": 1525808966899, + "version": "1.0" + }, + "caffe-gpu-1.0-py27h999e8d7_5.conda": { + "build": "py27h999e8d7_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f11039d375d4ceda1598283cf47aacc9", + "name": "caffe-gpu", + "sha256": "894cbfcbf584774aecd29a5ab6551a46891aa15442c33ba149823b6ea74c3dbe", + "size": 4003898, + "subdir": "linux-64", + "timestamp": 1549043122655, + "version": "1.0" + }, + "caffe-gpu-1.0-py27hdb72b7a_4.conda": { + "build": "py27hdb72b7a_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8aa4ae77d2d70b2bb1b664532717ee42", + "name": "caffe-gpu", + "sha256": "c953a77ce2886b6121e3f01f1008286348de3b8ddf25fbb38cd9c7de9417a220", + "size": 3711758, + "subdir": "linux-64", + "timestamp": 1537916183628, + "version": "1.0" + }, + "caffe-gpu-1.0-py27hdc87d0a_5.conda": { + "build": "py27hdc87d0a_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3196bc075dba10c691f29d524ae37d9c", + "name": "caffe-gpu", + "sha256": "c28a6304b4a95884c3affeda1dfee14a85fe50ae39b122e3bfd887e116dd044a", + "size": 3948884, + "subdir": "linux-64", + "timestamp": 1549039664610, + "version": "1.0" + }, + "caffe-gpu-1.0-py27hdfd716b_2.conda": { + "build": "py27hdfd716b_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8109921ba95a2e4bb993c3bffce28da0", + "name": "caffe-gpu", + "sha256": "5ea8d1ee367dac70b82aeec1d655d6f49e18d4b67f254eb90488a4f16e645623", + "size": 3070241, + "subdir": "linux-64", + "timestamp": 1516462111582, + "version": "1.0" + }, + "caffe-gpu-1.0-py27he096b04_2.conda": { + "build": "py27he096b04_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a1fadb262d4834f57c6509bff7ab53f4", + "name": "caffe-gpu", + "sha256": "d678b620fb17030e28e5baf88ebadb63a523dd4fb7694a0b092ac76885e07187", + "size": 3072109, + "subdir": "linux-64", + "timestamp": 1516463216041, + "version": "1.0" + }, + "caffe-gpu-1.0-py27heda4471_3.conda": { + "build": "py27heda4471_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "2ba8eace1afd862cb3cb07b643d1e297", + "name": "caffe-gpu", + "sha256": "812519da2954f3a2d558f514cf5bc4246202a75bd142a9ef1033b9e6e5bfc002", + "size": 3391662, + "subdir": "linux-64", + "timestamp": 1525912059513, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h03f526a_2.conda": { + "build": "py35h03f526a_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn 6.0.*", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c7551a09cc72f698d4e130210e91165c", + "name": "caffe-gpu", + "sha256": "130fc9c67a7cac28a1a43ed28deeb847f95d09801d4fdd4511ec0bfab6701b1b", + "size": 3065866, + "subdir": "linux-64", + "timestamp": 1516474798355, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h16099b3_4.conda": { + "build": "py35h16099b3_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "898e809cdbeae402e2d8c348f5d73c81", + "name": "caffe-gpu", + "sha256": "fc91d810a306d330ff1734f65ed865fcde5b92c2604078d9fa0ccb008a9337de", + "size": 4035251, + "subdir": "linux-64", + "timestamp": 1537913882161, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h2b1a04e_4.conda": { + "build": "py35h2b1a04e_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "fa4a8c951be0f8a66e66b9f63240439a", + "name": "caffe-gpu", + "sha256": "1e140eca84eda3724230392f1a941d36531efe6e1d702c14819f289a70806090", + "size": 3957760, + "subdir": "linux-64", + "timestamp": 1537920014436, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h37b1cb2_3.conda": { + "build": "py35h37b1cb2_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "dc45d61f9486afe66324099481d5d561", + "name": "caffe-gpu", + "sha256": "2d5c31f3135608bae622a4500857efe23570f9eea17578f53dc886af3044a5bf", + "size": 3070707, + "subdir": "linux-64", + "timestamp": 1525807366361, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h4dc7405_3.conda": { + "build": "py35h4dc7405_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ca406262ec022351570a0536dfbf8da7", + "name": "caffe-gpu", + "sha256": "478f00f9b957a110b05527cf0ce933440e3567ffe88fe25569e57b2a9863735d", + "size": 3385485, + "subdir": "linux-64", + "timestamp": 1525910312849, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h51fbcb3_4.conda": { + "build": "py35h51fbcb3_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5b1baadaae8e926b38a7b627ac234c6e", + "name": "caffe-gpu", + "sha256": "6389167874c5067099ee5bb9b4211d762bcb7beb7d5685a5d57864ba792aba18", + "size": 3954026, + "subdir": "linux-64", + "timestamp": 1537921689639, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h62894bf_4.conda": { + "build": "py35h62894bf_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4d66ba16a7f5c40ce88a028e96001893", + "name": "caffe-gpu", + "sha256": "42dab89ff2629e70e99d02b21a5bdf3c7c722190e1b27f0bc9517035043867c5", + "size": 3710624, + "subdir": "linux-64", + "timestamp": 1537917953120, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h749159d_2.conda": { + "build": "py35h749159d_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn 6.0.*", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "78a4a893333bf523a66d8bf153b395cb", + "name": "caffe-gpu", + "sha256": "3930ea1b45cbf6157283ae8af6d21c9cd35ad4aa116d2e0f5b38e6291a6c56af", + "size": 3067593, + "subdir": "linux-64", + "timestamp": 1516476662103, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h7b71608_4.conda": { + "build": "py35h7b71608_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "44cbc63bc69a2e50c264367e775f8ecd", + "name": "caffe-gpu", + "sha256": "e1841b38a142da1260a8a22c52fcd05f68f37d8f766e9d708053e05344ad8d9a", + "size": 4043720, + "subdir": "linux-64", + "timestamp": 1537915448753, + "version": "1.0" + }, + "caffe-gpu-1.0-py35h960b796_3.conda": { + "build": "py35h960b796_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "bfe8c53c5a0ab5a829cb236528460b79", + "name": "caffe-gpu", + "sha256": "e56980df96d2d8d640e3deab087d6535925dc992a7511dc0781d09604e9fa5ff", + "size": 3067947, + "subdir": "linux-64", + "timestamp": 1525807687971, + "version": "1.0" + }, + "caffe-gpu-1.0-py35hdb72b7a_4.conda": { + "build": "py35hdb72b7a_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7724b5c7b1c4e79215bd72fa22c300f4", + "name": "caffe-gpu", + "sha256": "a5cf62b12b2a83732d0ef662ead00af93293e0c25f3e08aacbb0f701513074b5", + "size": 3718197, + "subdir": "linux-64", + "timestamp": 1537918944060, + "version": "1.0" + }, + "caffe-gpu-1.0-py35hdfd716b_2.conda": { + "build": "py35hdfd716b_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "724b20ca6a831ec84d2d5babc3d4b882", + "name": "caffe-gpu", + "sha256": "d1454ffa6f0fd6c94feae58e5fadff5f7c7003a9222fb67a2d948223462ddc6c", + "size": 3065741, + "subdir": "linux-64", + "timestamp": 1516464417042, + "version": "1.0" + }, + "caffe-gpu-1.0-py35he096b04_2.conda": { + "build": "py35he096b04_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "22a0fdcc33b69a30785de4ce9f9f199b", + "name": "caffe-gpu", + "sha256": "a250b6a724429cb48d95879a6a9325c8d77b1ed1d40323bd555c52e65c0d90d8", + "size": 3064433, + "subdir": "linux-64", + "timestamp": 1516465662094, + "version": "1.0" + }, + "caffe-gpu-1.0-py35heda4471_3.conda": { + "build": "py35heda4471_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ea1fa99c42337d0e07681e0bb4e5ae82", + "name": "caffe-gpu", + "sha256": "9444d9e539629bb57c9968c0f4719cc942ac180862bde4bb50d6f537a6cf208a", + "size": 3387022, + "subdir": "linux-64", + "timestamp": 1525910747060, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h03f526a_2.conda": { + "build": "py36h03f526a_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn 6.0.*", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4594393e7683ef430285b05105909776", + "name": "caffe-gpu", + "sha256": "dfd51525810b7e43b93190bb338c995168422b4d4498f41ca090b790c0ef9fe4", + "size": 3058887, + "subdir": "linux-64", + "timestamp": 1516478711062, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h1450b91_5.conda": { + "build": "py36h1450b91_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=8.0,<8.1.0a0", + "cudnn >=7.1.3,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a72106c1a954472f8b1c27598d19e163", + "name": "caffe-gpu", + "sha256": "58ecf60ab01bc8fb59c03afcbd32d8bb5459447e8d47d41d8df7bc090f54b9f9", + "size": 3723012, + "subdir": "linux-64", + "timestamp": 1548972704586, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h16099b3_4.conda": { + "build": "py36h16099b3_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b8835ee679cd9e9c98bef63bcb8d9bea", + "name": "caffe-gpu", + "sha256": "bed6c0ff1c3968cc522e109d9eb37c2b5e80db18f59ab0a719484d7c32b0d0d9", + "size": 4041873, + "subdir": "linux-64", + "timestamp": 1537920067009, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h2b1a04e_4.conda": { + "build": "py36h2b1a04e_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "2bd0f9f8f1a9db866fab1e6c70ce5bdc", + "name": "caffe-gpu", + "sha256": "a2579759b0d2bf7fa6ef233b27f3bb76cf533a7690f305ebcfc9f2cd1155b613", + "size": 3952706, + "subdir": "linux-64", + "timestamp": 1537913157589, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h37b1cb2_3.conda": { + "build": "py36h37b1cb2_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "2a8ddb8be8e9eebe82337feb96f5d4d2", + "name": "caffe-gpu", + "sha256": "3be5b4c372966a9d676ccbc9f9ec608fb409a0301605293f7ed7f8576f3c6ea7", + "size": 3069913, + "subdir": "linux-64", + "timestamp": 1525807980648, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h4dc7405_3.conda": { + "build": "py36h4dc7405_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b5cc45e974ce680936034679aaeb763f", + "name": "caffe-gpu", + "sha256": "0f0254da501bbee42639c2ec07db65d2eebb7d40330f25cafcd24815a1fc8ec4", + "size": 3391983, + "subdir": "linux-64", + "timestamp": 1525911043209, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h51fbcb3_4.conda": { + "build": "py36h51fbcb3_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "82d7de817055b6a2c206a49af5fb45a4", + "name": "caffe-gpu", + "sha256": "e9732b401635b129fd7807945c1e1710a3c61f9931b1d3f219ffc734ae856ae6", + "size": 3957774, + "subdir": "linux-64", + "timestamp": 1537914863584, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h550cbc0_5.conda": { + "build": "py36h550cbc0_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a746a2349449d5bde87628c5adf5984e", + "name": "caffe-gpu", + "sha256": "330fbe4d3d33039ba084d2f8b5fedcab046ccdf86b5ce8eb3244cd95a553d16c", + "size": 4043974, + "subdir": "linux-64", + "timestamp": 1548974354567, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h62894bf_4.conda": { + "build": "py36h62894bf_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7f3d2e91f8c747b9dc84bbfd329bedf2", + "name": "caffe-gpu", + "sha256": "cfadcd358d9f98e4311bf6cb7af29223ced167db08a8568acc91d0cfef851052", + "size": 3721443, + "subdir": "linux-64", + "timestamp": 1537911156749, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h749159d_2.conda": { + "build": "py36h749159d_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn 6.0.*", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e4584c6c5c2853e9fdea4343ac3ef66a", + "name": "caffe-gpu", + "sha256": "c0120192d735a0e2f4e20acc823a1de4949debc20184029958dc1d354b8d2ce3", + "size": 3059275, + "subdir": "linux-64", + "timestamp": 1516480905629, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h7b71608_4.conda": { + "build": "py36h7b71608_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3831149f416e9143d0a3167f61ee9c3c", + "name": "caffe-gpu", + "sha256": "43242914a8e2226400444429fdbcd2346b69188ef101986820d65199901a3ebd", + "size": 4043014, + "subdir": "linux-64", + "timestamp": 1537921915399, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h960b796_3.conda": { + "build": "py36h960b796_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "92dcd6ee0bfe5fa3cb0b196716b3a744", + "name": "caffe-gpu", + "sha256": "a7980cf9f653b5a1cc64bf4ff419ec0bb8e97e71d2ddf1a2b09dc5cde7d22a42", + "size": 3071467, + "subdir": "linux-64", + "timestamp": 1525808255320, + "version": "1.0" + }, + "caffe-gpu-1.0-py36h999e8d7_5.conda": { + "build": "py36h999e8d7_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "6767bb5fabe9003f82224b9b1e0ccd9c", + "name": "caffe-gpu", + "sha256": "93465a96bdc95934741cf2d0da87fb028f22153c07f08024b95ea67469c26ee2", + "size": 4008439, + "subdir": "linux-64", + "timestamp": 1549043771851, + "version": "1.0" + }, + "caffe-gpu-1.0-py36hdb72b7a_4.conda": { + "build": "py36hdb72b7a_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c596449edbd8df852348099db5c92145", + "name": "caffe-gpu", + "sha256": "6c63cb99bd0d210cc48d78e65085b3c37131a124fefd678102fca7879c419e5c", + "size": 3718517, + "subdir": "linux-64", + "timestamp": 1537912920112, + "version": "1.0" + }, + "caffe-gpu-1.0-py36hdc87d0a_5.conda": { + "build": "py36hdc87d0a_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "910f2a3445ab73e3a12c6846cd37e33f", + "name": "caffe-gpu", + "sha256": "9c57e2a46ff3f65c2578666bbf358ce0dcdf8c7cf364e5fd2f64b5f55e033da9", + "size": 3958156, + "subdir": "linux-64", + "timestamp": 1549039037429, + "version": "1.0" + }, + "caffe-gpu-1.0-py36hdfd716b_2.conda": { + "build": "py36hdfd716b_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.18,<1.8.19.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "986b0b13fba3571021aade531a0a2ab4", + "name": "caffe-gpu", + "sha256": "e00e7b852f1218d3aa0eef6d3779bba6ddbe312d0306b05a659d720ba88e1724", + "size": 3058785, + "subdir": "linux-64", + "timestamp": 1516467025205, + "version": "1.0" + }, + "caffe-gpu-1.0-py36he096b04_2.conda": { + "build": "py36he096b04_2", + "build_number": 2, + "depends": [ + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.5.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=5.5.0", + "lmdb >=0.9.21,<1.0a0", + "matplotlib", + "mkl >=2018.0.1,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "6666ff2e9ef47cad1fdace51f1019851", + "name": "caffe-gpu", + "sha256": "42104caa673b7f7ea638202523eb9321b40ce4767447704102eb36a683d176cf", + "size": 3066689, + "subdir": "linux-64", + "timestamp": 1516468458312, + "version": "1.0" + }, + "caffe-gpu-1.0-py36heda4471_3.conda": { + "build": "py36heda4471_3", + "build_number": 3, + "depends": [ + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.1,<1.10.2.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=5.4.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.2,<2019.0a0", + "networkx", + "numpy >=1.9.3,<2.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "pandas", + "protobuf", + "py-boost", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "12a15bfde1aa7d25e58040ee6bebc691", + "name": "caffe-gpu", + "sha256": "fa9a005175f046b1bb10e2bc2b518cf2b2426ab8eaffc51605009e4bcce4ed26", + "size": 3388785, + "subdir": "linux-64", + "timestamp": 1525911334121, + "version": "1.0" + }, + "caffe-gpu-1.0-py37h1450b91_5.conda": { + "build": "py37h1450b91_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=8.0,<8.1.0a0", + "cudnn >=7.1.3,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "18a625ed8f964aa8d4d5a7896323d808", + "name": "caffe-gpu", + "sha256": "219572dace1fa5e54a8d048aff4640d82461030b97dba6aeaf18b7995956306d", + "size": 3721847, + "subdir": "linux-64", + "timestamp": 1548971411101, + "version": "1.0" + }, + "caffe-gpu-1.0-py37h16099b3_4.conda": { + "build": "py37h16099b3_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d159dba4480cabfc8ac513261c6b4ced", + "name": "caffe-gpu", + "sha256": "9e7fc42c22c6fbccd891a165629f3639295378fedd22fe5c73a4550ff3589576", + "size": 4044745, + "subdir": "linux-64", + "timestamp": 1537916878497, + "version": "1.0" + }, + "caffe-gpu-1.0-py37h2b1a04e_4.conda": { + "build": "py37h2b1a04e_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5d53e815673fe5c31fff85c5a8410e9d", + "name": "caffe-gpu", + "sha256": "dc72055a401d46f431bc03357f82eda85be2753db54dd8ad2ce00da840cc9d94", + "size": 3952596, + "subdir": "linux-64", + "timestamp": 1537922360994, + "version": "1.0" + }, + "caffe-gpu-1.0-py37h51fbcb3_4.conda": { + "build": "py37h51fbcb3_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f0fd9b9de31288680c3a74e0a0212366", + "name": "caffe-gpu", + "sha256": "c99bc1569a2cfe1d544e6b3aaed70001ce78a97eaadb2e2f25877f789c571a49", + "size": 3953762, + "subdir": "linux-64", + "timestamp": 1537922961829, + "version": "1.0" + }, + "caffe-gpu-1.0-py37h550cbc0_5.conda": { + "build": "py37h550cbc0_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "41011b7494c613e277b9709b22cf80da", + "name": "caffe-gpu", + "sha256": "07c9ee4477bad94f5be0ecba50fe3cdec47c1ec60044f7deb039f5284d95362c", + "size": 4044043, + "subdir": "linux-64", + "timestamp": 1548975026670, + "version": "1.0" + }, + "caffe-gpu-1.0-py37h62894bf_4.conda": { + "build": "py37h62894bf_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "979bb9512a60231400fb1f9a0bd1f115", + "name": "caffe-gpu", + "sha256": "081043aa18613357522b6bc032f7ae51b46fe9f380826da22400e30909f2ff26", + "size": 3721375, + "subdir": "linux-64", + "timestamp": 1537920293519, + "version": "1.0" + }, + "caffe-gpu-1.0-py37h7b71608_4.conda": { + "build": "py37h7b71608_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d51318b6926d2c0a154d3b7305f84299", + "name": "caffe-gpu", + "sha256": "e63c27ad4d8af4eddbf2f6431772e63f84fd67fa6a9e7fc3ef81b768e2d2909e", + "size": 4041527, + "subdir": "linux-64", + "timestamp": 1537918258878, + "version": "1.0" + }, + "caffe-gpu-1.0-py37h999e8d7_5.conda": { + "build": "py37h999e8d7_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "37758d02b9c99cd7046dc3e565cb010d", + "name": "caffe-gpu", + "sha256": "80c345f4601dbfc04c3a9782aab05d0a15ef342a69e3e5963f774ef745ab6072", + "size": 4002760, + "subdir": "linux-64", + "timestamp": 1549044412277, + "version": "1.0" + }, + "caffe-gpu-1.0-py37hdb72b7a_4.conda": { + "build": "py37hdb72b7a_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "gflags >=2.2.1,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.8.20,<1.9.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.22,<1.0a0", + "matplotlib", + "mkl >=2018.0.3,<2019.0a0", + "networkx", + "numpy >=1.15.1,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9d3a73581cac79d9480f758ccb4977a6", + "name": "caffe-gpu", + "sha256": "7ee84a532439fe94fb7e11f4c88b1f8efcb52e3cbe9104ed4541981426c690c1", + "size": 3721051, + "subdir": "linux-64", + "timestamp": 1537921967489, + "version": "1.0" + }, + "caffe-gpu-1.0-py37hdc87d0a_5.conda": { + "build": "py37hdc87d0a_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "boost", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "gflags >=2.2.2,<2.3.0a0", + "glog >=0.3.5,<0.3.6.0a0", + "h5py", + "hdf5 >=1.10.2,<1.10.3.0a0", + "ipython", + "leveldb >=1.20,<1.21.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=5.4.0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=5.4.0", + "lmdb >=0.9.23,<1.0a0", + "matplotlib", + "mkl >=2019.1,<2021.0a0", + "networkx", + "numpy >=1.15.4,<2.0a0", + "pandas", + "protobuf", + "py-boost", + "py-opencv >=3.4.2,<3.5.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-gflags", + "python-leveldb", + "pyyaml", + "scikit-image", + "scipy", + "six", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "66e135d0ccf326f303913adebd5f36eb", + "name": "caffe-gpu", + "sha256": "7e4ffe09ec7d126f70d8a4ad38125fee14e451fac5727bf291e1a9c87b4f065b", + "size": 3958255, + "subdir": "linux-64", + "timestamp": 1549040294835, + "version": "1.0" + }, + "cairo-1.14.10-h58b644b_4.conda": { + "build": "h58b644b_4", + "build_number": 4, + "depends": [ + "fontconfig >=2.12.4,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb", + "pixman 0.34.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL 2.1 or MPL 1.1", + "md5": "6f2aad7e1e284f2efb6b167149ff539b", + "name": "cairo", + "sha256": "3ec17df8f230cd71e6720e5e8c586452e8c7c055d19964c8c1fd2868baf2be52", + "size": 975722, + "subdir": "linux-64", + "timestamp": 1505741820132, + "version": "1.14.10" + }, + "cairo-1.14.10-haa5651f_5.conda": { + "build": "haa5651f_5", + "build_number": 5, + "depends": [ + "fontconfig >=2.12.4,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL 2.1 or MPL 1.1", + "md5": "62127ed9a41bfc5701235159bf42531e", + "name": "cairo", + "sha256": "c8981262ac358e80649049c34108f3356c2f00be0d372ebe1efc8534f2c37b10", + "size": 974025, + "subdir": "linux-64", + "timestamp": 1507907806254, + "version": "1.14.10" + }, + "cairo-1.14.10-hdf128ce_6.conda": { + "build": "hdf128ce_6", + "build_number": 6, + "depends": [ + "fontconfig >=2.12.4,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.12,<2.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL 2.1 or MPL 1.1", + "md5": "8bcc915873c510a57faa897f1e7c7625", + "name": "cairo", + "sha256": "21ec87687e806c317e4e7b5e8594b78e8cb74c77ce5b89f7861b1b42db971240", + "size": 975446, + "subdir": "linux-64", + "timestamp": 1510603633036, + "version": "1.14.10" + }, + "cairo-1.14.12-h7636065_2.conda": { + "build": "h7636065_2", + "build_number": 2, + "depends": [ + "fontconfig >=2.12.6,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.56.1,<3.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL 2.1 or MPL 1.1", + "md5": "ef94c2a239875da5fb744d9060a4ab35", + "name": "cairo", + "sha256": "4106f20c3d8852e398b2d440ba3b5cc3c9af80f28f2b75a7dc44bdd3c258d678", + "size": 926878, + "subdir": "linux-64", + "timestamp": 1523667635809, + "version": "1.14.12" + }, + "cairo-1.14.12-h77bcde2_0.conda": { + "build": "h77bcde2_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.4,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.12,<2.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL 2.1 or MPL 1.1", + "md5": "47d21c7dd1a69b5d9937295ee0201047", + "name": "cairo", + "sha256": "afb2a23de6fe14d5bc24546d5f041ada0c0fb4b5dffbbf34ff107d907f688e27", + "size": 927106, + "subdir": "linux-64", + "timestamp": 1516745357146, + "version": "1.14.12" + }, + "cairo-1.14.12-h8948797_3.conda": { + "build": "h8948797_3", + "build_number": 3, + "depends": [ + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.1,<3.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL 2.1 or MPL 1.1", + "md5": "3436994526c285053941c46049cd943c", + "name": "cairo", + "sha256": "9214543a472bbe744aad2666c3f669b5ebab222db9e1b8349ae542324556a0de", + "size": 927248, + "subdir": "linux-64", + "timestamp": 1527255730563, + "version": "1.14.12" + }, + "cairo-1.16.0-h19f5f5c_2.conda": { + "build": "h19f5f5c_2", + "build_number": 2, + "depends": [ + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libxcb >=1.15,<2.0a0", + "pixman >=0.40.0,<1.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later or MPL-1.1", + "license_family": "LGPL", + "md5": "d6771ae052a6e7cd3364e1f1ae754f12", + "name": "cairo", + "sha256": "437ab9a1783b342665ca5af2f8c4593d94e2cef85c3d10d098e33217d9995a15", + "size": 1103598, + "subdir": "linux-64", + "timestamp": 1654193721539, + "version": "1.16.0" + }, + "cairo-1.16.0-hb05425b_3.conda": { + "build": "hb05425b_3", + "build_number": 3, + "depends": [ + "fontconfig >=2.14.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libxcb >=1.15,<2.0a0", + "pixman >=0.40.0,<1.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later or MPL-1.1", + "license_family": "LGPL", + "md5": "2665d8ef5200bb327b36cca1089439a3", + "name": "cairo", + "sha256": "1deeba445677336677f9e4e08225bc53cf13308375fbbf1b3cf3466640f637f1", + "size": 1231798, + "subdir": "linux-64", + "timestamp": 1671102123693, + "version": "1.16.0" + }, + "cairo-1.16.0-hb05425b_4.conda": { + "build": "hb05425b_4", + "build_number": 4, + "depends": [ + "fontconfig >=2.14.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.39,<1.7.0a0", + "libxcb >=1.15,<2.0a0", + "pixman >=0.40.0,<1.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later or MPL-1.1", + "license_family": "LGPL", + "md5": "39bccc889b858dfa69f8e90426efbde2", + "name": "cairo", + "sha256": "3a2ea4f688edca799af4d9051d9525391e6e7997fa515cf4c8fba71266f871ec", + "size": 1493886, + "subdir": "linux-64", + "timestamp": 1678783282904, + "version": "1.16.0" + }, + "cairo-1.16.0-hf32fb01_1.conda": { + "build": "hf32fb01_1", + "build_number": 1, + "depends": [ + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.67.4,<3.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libxcb >=1.14,<2.0a0", + "pixman >=0.40.0,<1.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL 2.1 or MPL 1.1", + "md5": "be4e74767c0d456b92b8839db13f5549", + "name": "cairo", + "sha256": "fd91f38c7d2db418c55cf5baca57f651551d0b948a66fb240ec223d5441d2ad7", + "size": 1098877, + "subdir": "linux-64", + "timestamp": 1615260566990, + "version": "1.16.0" + }, + "calver-2022.6.26-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "3d08bc51de614c21ff88c5a922ba596b", + "name": "calver", + "sha256": "f1489e7855dfec7cb4d13680455d83bb5370573302bac87038f7a92b95347c80", + "size": 12716, + "subdir": "linux-64", + "timestamp": 1679595815695, + "version": "2022.6.26" + }, + "calver-2022.6.26-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "1463e016a8cd0b289663c59f3183ea7b", + "name": "calver", + "sha256": "ea8dc7a9d021d3f8b5613f164fcc81c1685df81fcfa4fa5e767bea88d4818a5f", + "size": 13414, + "subdir": "linux-64", + "timestamp": 1679595866767, + "version": "2022.6.26" + }, + "calver-2022.6.26-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "10835277f9b15a0dd24a1b9eaf005dab", + "name": "calver", + "sha256": "6e2b8d2cc298249f0aa8f6fe3beac8ecbab18dd9c5a8f326fff025d9954b2875", + "size": 12654, + "subdir": "linux-64", + "timestamp": 1679595841062, + "version": "2022.6.26" + }, + "calver-2022.6.26-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "07c56c50ad31d32312e01e53026a5be6", + "name": "calver", + "sha256": "e0e677c124b1ed6fc989e0fcf68bc98f301b7c180a9ee46ac12130c0e805ed0f", + "size": 12635, + "subdir": "linux-64", + "timestamp": 1679595789365, + "version": "2022.6.26" + }, + "capnproto-0.9.1-h4ff587b_0.conda": { + "build": "h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1m,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "2f62547e88eada7d2a1685e386afb603", + "name": "capnproto", + "sha256": "469f43ad78477bf1cbde25a56bf82c7e0d7584503b29d761a3764e80c5ac4c19", + "size": 2964751, + "subdir": "linux-64", + "timestamp": 1643906202839, + "version": "0.9.1" + }, + "capturer-2.1.1-py27h33f98cf_0.conda": { + "build": "py27h33f98cf_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "4a18abcafc7fdbe9a5af7da36eba16f7", + "name": "capturer", + "sha256": "c78ddd7a68569f2472c151497314d8a9956a96ff2b80d70661c59d5dcd722636", + "size": 23026, + "subdir": "linux-64", + "timestamp": 1505741836589, + "version": "2.1.1" + }, + "capturer-2.1.1-py35h41e74de_0.conda": { + "build": "py35h41e74de_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "4ad53df3e9d25feb65bd33b00672f127", + "name": "capturer", + "sha256": "8df2b653526908c48073fafcbc8b5e8fa0ae65d30f8de6b06cc41aad9429a03a", + "size": 23461, + "subdir": "linux-64", + "timestamp": 1505741848526, + "version": "2.1.1" + }, + "capturer-2.1.1-py36h1fde460_0.conda": { + "build": "py36h1fde460_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "87eb8d8794a35573862912e22e0fa6c2", + "name": "capturer", + "sha256": "b9846e93b809d999e180ba18af2e1eb915f8c80731ce04e68faa48c339df3d0e", + "size": 23492, + "subdir": "linux-64", + "timestamp": 1505741860549, + "version": "2.1.1" + }, + "capturer-2.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "91720c256651357a0f0d91447791083e", + "name": "capturer", + "sha256": "99c6485c5774bb29293969037b727bcca03229cf3c573cb77b285c370a486790", + "size": 24289, + "subdir": "linux-64", + "timestamp": 1530811030222, + "version": "2.4" + }, + "capturer-2.4-py27h249d9a3_0.conda": { + "build": "py27h249d9a3_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "6bfe391f4a50228a0feb53ef569f084c", + "name": "capturer", + "sha256": "d4ceb6bec56b3c62bd4a1d003099544a97294b10d482fa6665516388edfbca2b", + "size": 24814, + "subdir": "linux-64", + "timestamp": 1511924992135, + "version": "2.4" + }, + "capturer-2.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "70c29acb1b2deb263bfabc1900ad0293", + "name": "capturer", + "sha256": "b818d8dc92e02d361c36abda0fc62d88a769f6449264313457c2b9479581ddc2", + "size": 24876, + "subdir": "linux-64", + "timestamp": 1640803813430, + "version": "2.4" + }, + "capturer-2.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "01c2bc33d046e5f575a2f75a39847c07", + "name": "capturer", + "sha256": "1be498e2280b3cd28e5803a19fd9689da10ea168c0c51ace050a39233025b9ef", + "size": 30124, + "subdir": "linux-64", + "timestamp": 1676847107476, + "version": "2.4" + }, + "capturer-2.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "8f9afd4cf11cdc7fd172c9451c558ac3", + "name": "capturer", + "sha256": "7af7891fb0ff6d612320a689e9a3e968634bb60ddd13a323021bede01f879ff2", + "size": 24697, + "subdir": "linux-64", + "timestamp": 1535129591650, + "version": "2.4" + }, + "capturer-2.4-py35h861ddf8_0.conda": { + "build": "py35h861ddf8_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "ba9f5a1c9f898756f268bcad343285bb", + "name": "capturer", + "sha256": "ab4dff58f523a1b06a8e592523975eb029171ebe293febda69b8672fee18e495", + "size": 25182, + "subdir": "linux-64", + "timestamp": 1511925007516, + "version": "2.4" + }, + "capturer-2.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "500f1041c958d5659007d31869f38d0a", + "name": "capturer", + "sha256": "b743467cff158969611f311a80c6d40b6ec80d252e22c280c30602c27db649fa", + "size": 24628, + "subdir": "linux-64", + "timestamp": 1530811078614, + "version": "2.4" + }, + "capturer-2.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ccb6624aa8ff8b7d3af1bda4e58c9fac", + "name": "capturer", + "sha256": "5483618e673c74175ecc6d45497c7c27775c38de933806c25a2677b87a73bb78", + "size": 26056, + "subdir": "linux-64", + "timestamp": 1614257642712, + "version": "2.4" + }, + "capturer-2.4-py36hed228ed_0.conda": { + "build": "py36hed228ed_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "091b06e2c9c34c08abebc14f1991004f", + "name": "capturer", + "sha256": "2d3b100d3ef6e9abcb645eae3ecae96ba2bbd9fd34d8f021a5cbf376ab59d843", + "size": 24996, + "subdir": "linux-64", + "timestamp": 1511925020260, + "version": "2.4" + }, + "capturer-2.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3d76d2452c2b364a11b1940c56acae53", + "name": "capturer", + "sha256": "c23fffe5368ee77d74680ed5f5f4bb8d6d1c99d995b375ba1a209ddd97eb53c4", + "size": 24517, + "subdir": "linux-64", + "timestamp": 1530811054198, + "version": "2.4" + }, + "capturer-2.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a1238d2f04d113f33dff0fce4c3f0003", + "name": "capturer", + "sha256": "0db3973a17bbb2e6248ae4e9688e8489f73ceb82f3b3b8c244171ce47cd5a3a3", + "size": 26119, + "subdir": "linux-64", + "timestamp": 1614257625191, + "version": "2.4" + }, + "capturer-2.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "e30b2b9e5eb210b2d1aff4236f38f60d", + "name": "capturer", + "sha256": "97ca69e2053a0ff8f8823aecffe0fd19d940092238e174c677911711e5b1ed61", + "size": 25092, + "subdir": "linux-64", + "timestamp": 1573738326660, + "version": "2.4" + }, + "capturer-2.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "796dbf402ed63fd57b31ae9154a63d42", + "name": "capturer", + "sha256": "dcd2d23055dea8a00fea528d7c8999435f0c218dd43cd6c76169bcb909f43076", + "size": 25994, + "subdir": "linux-64", + "timestamp": 1614257623967, + "version": "2.4" + }, + "capturer-2.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "bd297867e9269df6cda7fb0a5a06d92a", + "name": "capturer", + "sha256": "299856b04f5801fbe3734d14eadef072a56955f0069b7403f582711d217017e3", + "size": 25990, + "subdir": "linux-64", + "timestamp": 1614257626329, + "version": "2.4" + }, + "capturer-3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1f01e9ad3e6001861d71b3be7ed5045c", + "name": "capturer", + "sha256": "b383501cd37e1718f9b20ebc93580e022326d395c9b4d7bd835b2cb47280aaf1", + "size": 24599, + "subdir": "linux-64", + "timestamp": 1601395328798, + "version": "3.0" + }, + "capturer-3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "9eabd5b234202150aa51be7397e15568", + "name": "capturer", + "sha256": "fe67b63eff9b41fbaa3f464afadf10c8d842935d2ae0d62c0d5b2acd054115f1", + "size": 24588, + "subdir": "linux-64", + "timestamp": 1601397570968, + "version": "3.0" + }, + "capturer-3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "humanfriendly >=2.1", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "51ce500f80b2e638a8eaf1c7289d9065", + "name": "capturer", + "sha256": "207a1b47ba020f7cb4da39d82b2353c29145d424e173d38d22999334066021bc", + "size": 24643, + "subdir": "linux-64", + "timestamp": 1601395326160, + "version": "3.0" + }, + "cargo-bundle-licenses-0.5.0-h52d8a92_0.conda": { + "build": "h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT and Apache-2.0", + "license_family": "MIT", + "md5": "44fcb83d3103b727693cce822414d6b3", + "name": "cargo-bundle-licenses", + "sha256": "29dbd89a2e1e5eb01f7e7f9c9303fd87e0fc0b611e1db5595b6e4857e07b0719", + "size": 1149820, + "subdir": "linux-64", + "timestamp": 1667957596970, + "version": "0.5.0" + }, + "cartopy-0.15.1-py27h29bd39c_5.conda": { + "build": "py27h29bd39c_5", + "build_number": 5, + "depends": [ + "geos", + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "owslib", + "pillow", + "proj4", + "proj4 >=4.9.3,<4.9.4.0a0", + "pyepsg", + "pyshp", + "python >=2.7,<2.8.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "de2b7abc97b2879326390e0b5b871bba", + "name": "cartopy", + "sha256": "54ae3ba2aa325de6855cb5aa6e91f40ac75b2588f89f679ad4e419ff0dd65f08", + "size": 1634781, + "subdir": "linux-64", + "timestamp": 1511996597261, + "version": "0.15.1" + }, + "cartopy-0.15.1-py35h94dd845_5.conda": { + "build": "py35h94dd845_5", + "build_number": 5, + "depends": [ + "geos", + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "owslib", + "pillow", + "proj4", + "proj4 >=4.9.3,<4.9.4.0a0", + "pyepsg", + "pyshp", + "python >=3.5,<3.6.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "e95885d3f41d68690dd4438cc910682c", + "name": "cartopy", + "sha256": "b3a4876ebb81fbb9d743ba7d992be86a260841caaf048dadeacec5c2fef3f52d", + "size": 1625424, + "subdir": "linux-64", + "timestamp": 1511996621529, + "version": "0.15.1" + }, + "cartopy-0.15.1-py36hab8bdb6_5.conda": { + "build": "py36hab8bdb6_5", + "build_number": 5, + "depends": [ + "geos", + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "owslib", + "pillow", + "proj4", + "proj4 >=4.9.3,<4.9.4.0a0", + "pyepsg", + "pyshp", + "python >=3.6,<3.7.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "24cd917e315d1968af6ab9cb3c88f988", + "name": "cartopy", + "sha256": "56c02c99c2c569b7074b18508cf979f8135c22db3009ed9c1c0f1c45c8ac330f", + "size": 1632311, + "subdir": "linux-64", + "timestamp": 1511996475493, + "version": "0.15.1" + }, + "cartopy-0.16.0-py27hf32a85a_0.conda": { + "build": "py27hf32a85a_0", + "build_number": 0, + "depends": [ + "geos", + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "owslib", + "pillow", + "proj4", + "proj4 >=4.9.3,<4.9.4.0a0", + "pyepsg", + "pyshp", + "python >=2.7,<2.8.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "d8813b0a94227f4c18e19a49369be89b", + "name": "cartopy", + "sha256": "736c3fdbad6891c30186e3a224af3af1e0c280186beb77058058117db24079b1", + "size": 1633833, + "subdir": "linux-64", + "timestamp": 1519496881617, + "version": "0.16.0" + }, + "cartopy-0.16.0-py27hfa13621_0.conda": { + "build": "py27hfa13621_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "owslib", + "pillow", + "proj4 >=5.0.1,<5.0.2.0a0", + "pyepsg", + "pyshp", + "python >=2.7,<2.8.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "a78b1cb8a48a1d8711fcb741136e1a72", + "name": "cartopy", + "sha256": "82731e47d13ab38b2f3551a37dfa12f8f208742a40d408b897f9681175a1f563", + "size": 1635843, + "subdir": "linux-64", + "timestamp": 1530811722611, + "version": "0.16.0" + }, + "cartopy-0.16.0-py35hf32a85a_0.conda": { + "build": "py35hf32a85a_0", + "build_number": 0, + "depends": [ + "geos", + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "owslib", + "pillow", + "proj4", + "proj4 >=4.9.3,<4.9.4.0a0", + "pyepsg", + "pyshp", + "python >=3.5,<3.6.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "190b34069d95028ce54b20af33d1a2ed", + "name": "cartopy", + "sha256": "c8b5c8f974813fdb695efbd0c11ff6145e13ecbcd736e30df706b61abe0de737", + "size": 1633005, + "subdir": "linux-64", + "timestamp": 1519495364225, + "version": "0.16.0" + }, + "cartopy-0.16.0-py35hfa13621_0.conda": { + "build": "py35hfa13621_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "owslib", + "pillow", + "proj4 >=5.1.0,<5.1.1.0a0", + "pyepsg", + "pyshp", + "python >=3.5,<3.6.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "090259fe7dc8e655c765548b2aa2471f", + "name": "cartopy", + "sha256": "92b052cf073311d8fdec1c723ee950033b1aa97882e08fd51314e1bc4a1f4ecb", + "size": 1641944, + "subdir": "linux-64", + "timestamp": 1535129804361, + "version": "0.16.0" + }, + "cartopy-0.16.0-py36hf32a85a_0.conda": { + "build": "py36hf32a85a_0", + "build_number": 0, + "depends": [ + "geos", + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "owslib", + "pillow", + "proj4", + "proj4 >=4.9.3,<4.9.4.0a0", + "pyepsg", + "pyshp", + "python >=3.6,<3.7.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "4b38869b3ccfc5e85d081f2ac3084e3f", + "name": "cartopy", + "sha256": "9c33d2f1ab3c4d453906766bd686a1a161d987b2d7cb39b238fb138bb84bf022", + "size": 1633962, + "subdir": "linux-64", + "timestamp": 1519496704139, + "version": "0.16.0" + }, + "cartopy-0.16.0-py36hfa13621_0.conda": { + "build": "py36hfa13621_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "owslib", + "pillow", + "proj4 >=5.0.1,<5.0.2.0a0", + "pyepsg", + "pyshp", + "python >=3.6,<3.7.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "a9f7114544bc53a42a15893be1b0c7ec", + "name": "cartopy", + "sha256": "4e70b62969b0749509781a6d54287ccadeead0b94e59283a04157ed3dcac8970", + "size": 1634276, + "subdir": "linux-64", + "timestamp": 1530811855609, + "version": "0.16.0" + }, + "cartopy-0.16.0-py37hfa13621_0.conda": { + "build": "py37hfa13621_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "owslib", + "pillow", + "proj4 >=5.0.1,<5.0.2.0a0", + "pyepsg", + "pyshp", + "python >=3.7,<3.8.0a0", + "scipy", + "shapely", + "six" + ], + "license": "GNU LGPL", + "md5": "1734f675294400a660afecba4e101ec1", + "name": "cartopy", + "sha256": "31afcb9d1db49a5d45371e53c58f6253bf335c4d84b3cc72a02db312f419f105", + "size": 1637420, + "subdir": "linux-64", + "timestamp": 1530811789382, + "version": "0.16.0" + }, + "cartopy-0.17.0-py27hbb7e04d_1.conda": { + "build": "py27hbb7e04d_1", + "build_number": 1, + "depends": [ + "geos >=3.7.1,<3.7.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "owslib", + "pillow", + "proj4 >=5.2.0,<5.2.1.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=2.7,<2.8.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "1e1c311a2f749ab122a52a431b5afa57", + "name": "cartopy", + "sha256": "7d10322f335b0775005476abf9ebc735fbffb0c50d9c83f878d1d02412e745de", + "size": 1705958, + "subdir": "linux-64", + "timestamp": 1545322749856, + "version": "0.17.0" + }, + "cartopy-0.17.0-py36h3e2e9bd_1.conda": { + "build": "py36h3e2e9bd_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.14.6,<2.0a0", + "owslib", + "pillow", + "proj >=7.0.1,<7.0.2.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.6,<3.7.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "9a823265fd02f1b54af06dbecfba6b40", + "name": "cartopy", + "sha256": "d0a87dafcb55e4ff025685e583431d8cc66f14ca0101565b477b1e1f924370a3", + "size": 1701675, + "subdir": "linux-64", + "timestamp": 1590596247047, + "version": "0.17.0" + }, + "cartopy-0.17.0-py36hbb7e04d_1.conda": { + "build": "py36hbb7e04d_1", + "build_number": 1, + "depends": [ + "geos >=3.7.1,<3.7.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "owslib", + "pillow", + "proj4 >=5.2.0,<5.2.1.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.6,<3.7.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "a112e713e828d1dfe2f6f522b2cc562b", + "name": "cartopy", + "sha256": "d606bc0d07dba80f4cf2c9c1a6cd43a84e31dcd3b8e512a2e3633d554b2fa319", + "size": 1710086, + "subdir": "linux-64", + "timestamp": 1545322754374, + "version": "0.17.0" + }, + "cartopy-0.17.0-py36hee755e7_1.conda": { + "build": "py36hee755e7_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.14.6,<2.0a0", + "owslib", + "pillow", + "proj >=6.2.1,<6.2.2.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.6,<3.7.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "4b5eddf4b78c1729fd75759a90426315", + "name": "cartopy", + "sha256": "16e498a29179a311c6cd2af75881e79a6e36b4aa99339505bcbc69b6b8123322", + "size": 1701261, + "subdir": "linux-64", + "timestamp": 1590596220582, + "version": "0.17.0" + }, + "cartopy-0.17.0-py37h3e2e9bd_1.conda": { + "build": "py37h3e2e9bd_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.14.6,<2.0a0", + "owslib", + "pillow", + "proj >=7.0.1,<7.0.2.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.7,<3.8.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "f9e78fba63a5ae9fa44939699851bf86", + "name": "cartopy", + "sha256": "be076a1d21cb45f4ef03b2328a3eb8f071ef531358d39facb8989fea88aee667", + "size": 1704538, + "subdir": "linux-64", + "timestamp": 1590596252010, + "version": "0.17.0" + }, + "cartopy-0.17.0-py37hbb7e04d_1.conda": { + "build": "py37hbb7e04d_1", + "build_number": 1, + "depends": [ + "geos >=3.7.1,<3.7.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "owslib", + "pillow", + "proj4 >=5.2.0,<5.2.1.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.7,<3.8.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "14aee4b7a1c9c8d50925e53fac3c8a19", + "name": "cartopy", + "sha256": "0115955f927268f53e07ea8486c1f546ac7593f4c510f30b79f8c365d60af6d8", + "size": 1706112, + "subdir": "linux-64", + "timestamp": 1545322747480, + "version": "0.17.0" + }, + "cartopy-0.17.0-py37hee755e7_1.conda": { + "build": "py37hee755e7_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.14.6,<2.0a0", + "owslib", + "pillow", + "proj >=6.2.1,<6.2.2.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.7,<3.8.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "0f7500c458046cd7882fe91c8016f7c6", + "name": "cartopy", + "sha256": "0cca84ee00d054d5f95904dc21aaebe15047bdb1f77a1aa56f1d17e917c5129c", + "size": 1695896, + "subdir": "linux-64", + "timestamp": 1590596185086, + "version": "0.17.0" + }, + "cartopy-0.17.0-py38h3e2e9bd_1.conda": { + "build": "py38h3e2e9bd_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.14.6,<2.0a0", + "owslib", + "pillow", + "proj >=7.0.1,<7.0.2.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.8,<3.9.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "ef2516a9bbbf174e1f3a44022b65a05a", + "name": "cartopy", + "sha256": "0c8dc63ff9799385f075f2bb751bd6bc8fdf1d6e9e21e2b879554647ef287771", + "size": 1706991, + "subdir": "linux-64", + "timestamp": 1590596184903, + "version": "0.17.0" + }, + "cartopy-0.17.0-py38hee755e7_1.conda": { + "build": "py38hee755e7_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.14.6,<2.0a0", + "owslib", + "pillow", + "proj >=6.2.1,<6.2.2.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.8,<3.9.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "034dc839cb991b7c2d83c7f08ec80797", + "name": "cartopy", + "sha256": "0ab8b9d55b2aa79f1ac927ce03bc2325acb69209b11bf44b1c3ac50d330615df", + "size": 1705870, + "subdir": "linux-64", + "timestamp": 1590596246402, + "version": "0.17.0" + }, + "cartopy-0.18.0-py310h95ad73f_2.conda": { + "build": "py310h95ad73f_2", + "build_number": 2, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.5.1", + "numpy >=1.21.2,<2.0a0", + "proj <8.0.0", + "proj >=7.2.0,<7.2.1.0a0", + "pyshp >=1.1.4", + "python >=3.10,<3.11.0a0", + "scipy >=0.10", + "shapely >=1.5.6", + "six >=1.3.0" + ], + "license": "LGPL-3", + "md5": "bbdaca252a3af6b721b0dd7f5f3d3832", + "name": "cartopy", + "sha256": "27cdd63ea02429b58d13dfd0698bb33814868fd5c4c2fa7f7587718a99f0b6ba", + "size": 2537846, + "subdir": "linux-64", + "timestamp": 1643105523404, + "version": "0.18.0" + }, + "cartopy-0.18.0-py36h0d9ca2b_1.conda": { + "build": "py36h0d9ca2b_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=1.5.1", + "numpy >=1.16.6,<2.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "pyshp >=1.1.4", + "python >=3.6,<3.7.0a0", + "scipy >=0.10", + "shapely >=1.5.6", + "six >=1.3.0" + ], + "license": "LGPL-3", + "md5": "e46a02666e425bb51d9f9913e18d7f82", + "name": "cartopy", + "sha256": "0c20d3c591c71667b2b236f2e361eac949ab93460c43c3b21dbc68e2536b1fec", + "size": 1786357, + "subdir": "linux-64", + "timestamp": 1612289905649, + "version": "0.18.0" + }, + "cartopy-0.18.0-py36hee755e7_0.conda": { + "build": "py36hee755e7_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.14.6,<2.0a0", + "owslib", + "pillow", + "proj >=6.2.1,<6.2.2.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.6,<3.7.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "aed84ac071f527f47dc9fa515bc0d5cb", + "name": "cartopy", + "sha256": "f45388c65621a2736e35ccd52f9954f18f9f6bade664b3687dde4865e07b1ac6", + "size": 1804045, + "subdir": "linux-64", + "timestamp": 1594325513199, + "version": "0.18.0" + }, + "cartopy-0.18.0-py37h0d9ca2b_1.conda": { + "build": "py37h0d9ca2b_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=1.5.1", + "numpy >=1.16.6,<2.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "pyshp >=1.1.4", + "python >=3.7,<3.8.0a0", + "scipy >=0.10", + "shapely >=1.5.6", + "six >=1.3.0" + ], + "license": "LGPL-3", + "md5": "903eaded467bc1acc27db7eaac19fed8", + "name": "cartopy", + "sha256": "c97f8fa379915c1b81f11676b5d235ed735d689e0f703624f368bf39b623c086", + "size": 1792301, + "subdir": "linux-64", + "timestamp": 1612289899445, + "version": "0.18.0" + }, + "cartopy-0.18.0-py37hc576cba_1.conda": { + "build": "py37hc576cba_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.5.1", + "numpy >=1.16.6,<2.0a0", + "proj <8.0.0", + "proj >=7.0.1,<7.0.2.0a0", + "pyshp >=1.1.4", + "python >=3.7,<3.8.0a0", + "scipy >=0.10", + "shapely >=1.5.6", + "six >=1.3.0" + ], + "license": "LGPL-3", + "md5": "d1f62758c4498f66772a79f3ee9f712b", + "name": "cartopy", + "sha256": "06e724bd89cb13e5cae3caab7ef359b75dd6994387bd8f9557dd4038064a8598", + "size": 1799300, + "subdir": "linux-64", + "timestamp": 1636039169806, + "version": "0.18.0" + }, + "cartopy-0.18.0-py37hee755e7_0.conda": { + "build": "py37hee755e7_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.14.6,<2.0a0", + "owslib", + "pillow", + "proj >=6.2.1,<6.2.2.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.7,<3.8.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "c9dad2cac8954acfba8591241e3520ed", + "name": "cartopy", + "sha256": "d2e5708cf2b775fff949ca1930abd37c0d61f40230aeaf297e97426e98dfc255", + "size": 1796358, + "subdir": "linux-64", + "timestamp": 1594325525207, + "version": "0.18.0" + }, + "cartopy-0.18.0-py38h0d9ca2b_1.conda": { + "build": "py38h0d9ca2b_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=1.5.1", + "numpy >=1.16.6,<2.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "pyshp >=1.1.4", + "python >=3.8,<3.9.0a0", + "scipy >=0.10", + "shapely >=1.5.6", + "six >=1.3.0" + ], + "license": "LGPL-3", + "md5": "8911c7154b225f77347b1fcb97f892b6", + "name": "cartopy", + "sha256": "a5ef72d7b7d0583d4ad06f981bfed9a133fb5a0266f8db788245f188645a2a9a", + "size": 1803825, + "subdir": "linux-64", + "timestamp": 1612289540164, + "version": "0.18.0" + }, + "cartopy-0.18.0-py38hc576cba_1.conda": { + "build": "py38hc576cba_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.5.1", + "numpy >=1.16.6,<2.0a0", + "proj <8.0.0", + "proj >=7.0.1,<7.0.2.0a0", + "pyshp >=1.1.4", + "python >=3.8,<3.9.0a0", + "scipy >=0.10", + "shapely >=1.5.6", + "six >=1.3.0" + ], + "license": "LGPL-3", + "md5": "cf965e59fc005da8888a90bcb3567950", + "name": "cartopy", + "sha256": "d693310d36b2484d02d227a9bbb97b3cf8c824f54f9c415777273632bd2dd992", + "size": 1808290, + "subdir": "linux-64", + "timestamp": 1636039142654, + "version": "0.18.0" + }, + "cartopy-0.18.0-py38hee755e7_0.conda": { + "build": "py38hee755e7_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.14.6,<2.0a0", + "owslib", + "pillow", + "proj >=6.2.1,<6.2.2.0a0", + "pyepsg", + "pykdtree", + "pyshp", + "python >=3.8,<3.9.0a0", + "scipy", + "shapely", + "six" + ], + "license": "LGPL-3.0", + "md5": "21db8cf697071451ce4c04b5f0435d42", + "name": "cartopy", + "sha256": "000a41b7c400319999e580138c344fbbc1e63e55fa40cec7ce2ad65f13013e45", + "size": 1809735, + "subdir": "linux-64", + "timestamp": 1594325513176, + "version": "0.18.0" + }, + "cartopy-0.18.0-py39h0d9ca2b_1.conda": { + "build": "py39h0d9ca2b_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=1.5.1", + "numpy >=1.16.6,<2.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "pyshp >=1.1.4", + "python >=3.9,<3.10.0a0", + "scipy >=0.10", + "shapely >=1.5.6", + "six >=1.3.0" + ], + "license": "LGPL-3", + "md5": "f554958fc2162750ea60db3fb1df7699", + "name": "cartopy", + "sha256": "588917b62bf3a599a061df03f895f7f16bf75a9a75be25ec4354232960c587d7", + "size": 1801638, + "subdir": "linux-64", + "timestamp": 1613152008142, + "version": "0.18.0" + }, + "cartopy-0.18.0-py39hc576cba_1.conda": { + "build": "py39hc576cba_1", + "build_number": 1, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=1.5.1", + "numpy >=1.16.6,<2.0a0", + "proj <8.0.0", + "proj >=7.0.1,<7.0.2.0a0", + "pyshp >=1.1.4", + "python >=3.9,<3.10.0a0", + "scipy >=0.10", + "shapely >=1.5.6", + "six >=1.3.0" + ], + "license": "LGPL-3", + "md5": "2ec7368336235926fc33e390b2cec94a", + "name": "cartopy", + "sha256": "d0a815e1c4bafd13dea9ca179e5d2dfec7ad77da425b42470b1d45985edf731a", + "size": 1814109, + "subdir": "linux-64", + "timestamp": 1636027144755, + "version": "0.18.0" + }, + "cartopy-0.21.1-py310h1176785_0.conda": { + "build": "py310h1176785_0", + "build_number": 0, + "constrains": [ + "scipy >=1.3.1" + ], + "depends": [ + "geos >=3.7.2", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=3.1", + "numpy >=1.21.5,<2.0a0", + "pyproj >=3.0.0", + "pyshp >=2.1", + "python >=3.10,<3.11.0a0", + "shapely >=1.6.4" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "87e66c18bb42475d87eaf547a47891b1", + "name": "cartopy", + "sha256": "ad203626c0717c918ca72161cda3dc6b616fe317301e4e2fdafca04684c613da", + "size": 1666866, + "subdir": "linux-64", + "timestamp": 1674677817010, + "version": "0.21.1" + }, + "cartopy-0.21.1-py311h1176785_0.conda": { + "build": "py311h1176785_0", + "build_number": 0, + "constrains": [ + "scipy >=1.3.1" + ], + "depends": [ + "geos >=3.7.2", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=3.1", + "numpy >=1.23.5,<2.0a0", + "pyproj >=3.0.0", + "pyshp >=2.1", + "python >=3.11,<3.12.0a0", + "shapely >=1.6.4" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "e21f48d4b38fa70252f2e795cd74c021", + "name": "cartopy", + "sha256": "cd327df41538d69940cf76c08a931e2983b6d69b51d971839b37e5acc1a447ff", + "size": 1691392, + "subdir": "linux-64", + "timestamp": 1676843481637, + "version": "0.21.1" + }, + "cartopy-0.21.1-py38h1176785_0.conda": { + "build": "py38h1176785_0", + "build_number": 0, + "constrains": [ + "scipy >=1.3.1" + ], + "depends": [ + "geos >=3.7.2", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=3.1", + "numpy >=1.19.2,<2.0a0", + "pyproj >=3.0.0", + "pyshp >=2.1", + "python >=3.8,<3.9.0a0", + "shapely >=1.6.4" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "52cbac81459f1e90a3714511dbcd94b3", + "name": "cartopy", + "sha256": "533bcba1748fee70acd4446a4d9a3595dc20f23a95ffa5549adcafae4261d286", + "size": 1667391, + "subdir": "linux-64", + "timestamp": 1674677911535, + "version": "0.21.1" + }, + "cartopy-0.21.1-py39h1176785_0.conda": { + "build": "py39h1176785_0", + "build_number": 0, + "constrains": [ + "scipy >=1.3.1" + ], + "depends": [ + "geos >=3.7.2", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=3.1", + "numpy >=1.19.2,<2.0a0", + "pyproj >=3.0.0", + "pyshp >=2.1", + "python >=3.9,<3.10.0a0", + "shapely >=1.6.4" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "0b30ef72d58445a9b5e472d3d005b93a", + "name": "cartopy", + "sha256": "e87f106fca6a6a6b85d7fe6938eced7467c2ab485193d6abce0e238412b91869", + "size": 1674685, + "subdir": "linux-64", + "timestamp": 1674677999263, + "version": "0.21.1" + }, + "cassandra-driver-3.18.0-py36h27cfd23_2.conda": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "d042301ae410849e02a0ec2a1f2ffaac", + "name": "cassandra-driver", + "sha256": "232171e8fac5859ccfb2199a68758d5d7e1afbe206669c2e9c39928f4e574108", + "size": 2485942, + "subdir": "linux-64", + "timestamp": 1614177027262, + "version": "3.18.0" + }, + "cassandra-driver-3.18.0-py37h27cfd23_2.conda": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "df8086797f47692029c209cf8bcaacf9", + "name": "cassandra-driver", + "sha256": "8a07831466af8c74b418cb1739bae3538a08a038cb261cf798bfb8d99fb3329e", + "size": 2466354, + "subdir": "linux-64", + "timestamp": 1614177019761, + "version": "3.18.0" + }, + "cassandra-driver-3.18.0-py38h27cfd23_2.conda": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "0e40ccdfa16f9b112c8a7813f92e9dc6", + "name": "cassandra-driver", + "sha256": "7f4d982f7099525b096d16de72ee141d3882853bf5a3a453405946336fb7abcb", + "size": 2672411, + "subdir": "linux-64", + "timestamp": 1614177022898, + "version": "3.18.0" + }, + "cassandra-driver-3.18.0-py39h27cfd23_2.conda": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.9,<3.10.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "b527c64894238c95cac583a6afbc3ec0", + "name": "cassandra-driver", + "sha256": "520b131c10ad17ee4cb48d017b7c92e425a04a5f0ef3a5b62709a17465fa5552", + "size": 2673044, + "subdir": "linux-64", + "timestamp": 1614175979264, + "version": "3.18.0" + }, + "cassandra-driver-3.24.0-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "0baa91a9e2902c25c4b67c9fcd8b75eb", + "name": "cassandra-driver", + "sha256": "1455e38d1c335c237aeda7be602a0630bb2374fa7c264ff95049440e31c63e5e", + "size": 2863434, + "subdir": "linux-64", + "timestamp": 1597171160469, + "version": "3.24.0" + }, + "cassandra-driver-3.25.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.5.0", + "numpy", + "python >=3.10,<3.11.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "f3f9256bf9e9c74b29d3a1f6599a3a5f", + "name": "cassandra-driver", + "sha256": "bdb1ae9053bdfa1518b93aeb9e4c6cf7d43cbcbbabee639be518c06f71ca9e57", + "size": 11000183, + "subdir": "linux-64", + "timestamp": 1640788884143, + "version": "3.25.0" + }, + "cassandra-driver-3.25.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=11.2.0", + "numpy", + "python >=3.11,<3.12.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "3ddfaa9213135c42d268bfd70ae8e1d2", + "name": "cassandra-driver", + "sha256": "99cd89ae6e118fd0cf41f94703793912d188a9f0eff3d29de261ecc191477a2c", + "size": 3124460, + "subdir": "linux-64", + "timestamp": 1676847260590, + "version": "3.25.0" + }, + "cassandra-driver-3.25.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "4fb9a6014b29bcb341493f141d72cacc", + "name": "cassandra-driver", + "sha256": "fadda93e9aee4928193d231a2c6945e690b2767e572bf8984e45370e0b79814f", + "size": 2916501, + "subdir": "linux-64", + "timestamp": 1616180875876, + "version": "3.25.0" + }, + "cassandra-driver-3.25.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "84fb7d1293dae63891784254eed8f414", + "name": "cassandra-driver", + "sha256": "de1f06f07874b31c55eff8e5f6e20edc3395db4a1963feaad9aec8774f29efb2", + "size": 2901233, + "subdir": "linux-64", + "timestamp": 1616178885333, + "version": "3.25.0" + }, + "cassandra-driver-3.25.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "6b42e82b6fc32732da6d01435e7515b0", + "name": "cassandra-driver", + "sha256": "76be5ca1f8ddf3ec271853d47bed2649d3abcce35f63b47b4ec5cdd3817c874e", + "size": 3125732, + "subdir": "linux-64", + "timestamp": 1616180301368, + "version": "3.25.0" + }, + "cassandra-driver-3.25.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.9,<3.10.0a0", + "six >=1.9" + ], + "license": "Apache", + "license_family": "Apache", + "md5": "b7f51d95a5233eb484d5d57eef0c8834", + "name": "cassandra-driver", + "sha256": "4f6c6b6055f3a035c8c83bc10d2cd182eb37010c16ba9a6e25aa54665f1cb700", + "size": 3142424, + "subdir": "linux-64", + "timestamp": 1616178876800, + "version": "3.25.0" + }, + "casuarius-1.1-py27he6710b0_2.conda": { + "build": "py27he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL", + "md5": "5d65f5c75d5a2a2d9dc3e07cf367f6be", + "name": "casuarius", + "sha256": "298b8216142900818f177d9c0b69419c9c510368f307c4f410d83e5304b962d0", + "size": 158088, + "subdir": "linux-64", + "timestamp": 1539203345644, + "version": "1.1" + }, + "catalogue-1.0.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b69cc8bda7d4218b839ff86d62322c04", + "name": "catalogue", + "sha256": "33d95112a250c3dba81d1f91572fe6507ca840c10b515a14f0f3b0631079cb6c", + "size": 15816, + "subdir": "linux-64", + "timestamp": 1590154470697, + "version": "1.0.0" + }, + "catalogue-1.0.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31d848891c4a63cfb6c075a675657bdb", + "name": "catalogue", + "sha256": "91fa4792ac85d1fca168ef5badffb78b6e8951ba7b91fc1082b4e7dadd203307", + "size": 15879, + "subdir": "linux-64", + "timestamp": 1590154513828, + "version": "1.0.0" + }, + "catalogue-1.0.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "602fbd483b33a3a493cbc020866ed409", + "name": "catalogue", + "sha256": "f14af7fc6e6f5e75cbc62feb0a50fd46b199ab2f52ac580262777890abc9ab1c", + "size": 15973, + "subdir": "linux-64", + "timestamp": 1590154504705, + "version": "1.0.0" + }, + "catalogue-2.0.0-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "616e74c1e1443291d3c01fd1bf953c9e", + "name": "catalogue", + "sha256": "2b1556436ce4a634dc378b796cc0d9e7e613c7d2bc139790bfbaae2b82c77f6b", + "size": 17168, + "subdir": "linux-64", + "timestamp": 1599271379513, + "version": "2.0.0" + }, + "catalogue-2.0.0-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4bb9c9b6338ad33bc54b73281f37502a", + "name": "catalogue", + "sha256": "78fe964a35dc7a1bfce3fa4593c118e80d72baa2a2b9449a12d27098f9a53aae", + "size": 14157, + "subdir": "linux-64", + "timestamp": 1594342616857, + "version": "2.0.0" + }, + "catalogue-2.0.0-py38_2.conda": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f0a9aa9e10873be777d6805f95ef841", + "name": "catalogue", + "sha256": "a8c071189d82d2070c15caefc8b1ecfc6b6b871c41c2b2aa7b3f2ec52821c555", + "size": 17254, + "subdir": "linux-64", + "timestamp": 1599271374064, + "version": "2.0.0" + }, + "catalogue-2.0.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "911d7d3d0adb21545f949b2cb0f4c27f", + "name": "catalogue", + "sha256": "9fd1ef9ef4d54324c5b6a5226b4abf0ac36796a7c1d3a52615d861b53c90f6db", + "size": 20728, + "subdir": "linux-64", + "timestamp": 1608234321678, + "version": "2.0.1" + }, + "catalogue-2.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e424dd871c2d50440ea29c778604b15", + "name": "catalogue", + "sha256": "57d02bd5e1c14c0494852a60fc74372e5f10d0da5ffc16fb864d0072ccd226bb", + "size": 20756, + "subdir": "linux-64", + "timestamp": 1608234324237, + "version": "2.0.1" + }, + "catalogue-2.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e69242416ef303dcaa928e7d9527019f", + "name": "catalogue", + "sha256": "f43d9217d87f97cb1e6c31395ead088b4794ec9c8898b0ee9d7ef9f75914692a", + "size": 20750, + "subdir": "linux-64", + "timestamp": 1608234344953, + "version": "2.0.1" + }, + "catalogue-2.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b8218ad991664ac6fc528ba241c2a4e", + "name": "catalogue", + "sha256": "2fcdc5ea34be97793bafac52d753b35295c34106dfd389c547d11ac0f77fd0b0", + "size": 20817, + "subdir": "linux-64", + "timestamp": 1608234337396, + "version": "2.0.1" + }, + "catalogue-2.0.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8d05f02f1da2918300d72c253bfda2a", + "name": "catalogue", + "sha256": "c142b2094d53ddc060f34222ae9eb7bbfbabaa59d8785b705f02c0b6278de6db", + "size": 18517, + "subdir": "linux-64", + "timestamp": 1618348502777, + "version": "2.0.2" + }, + "catalogue-2.0.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e406a2430a0576064ba5a76cd51704b", + "name": "catalogue", + "sha256": "13bd1495789e63c663eb0fd06069601710c06a161a239ec21eccc88430473d20", + "size": 18415, + "subdir": "linux-64", + "timestamp": 1618348496478, + "version": "2.0.2" + }, + "catalogue-2.0.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "55f397b44ac47561da59f7bdd3bdbe9b", + "name": "catalogue", + "sha256": "3fa5fbf4ad351dfcf32643342eb901820ae572c666e4fe611403a6d4da481816", + "size": 18391, + "subdir": "linux-64", + "timestamp": 1618345422186, + "version": "2.0.2" + }, + "catalogue-2.0.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.20,<3.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "76bf09edfd6df1d80354af6271809856", + "name": "catalogue", + "sha256": "cbc2e0aeded8449f33c026b2d9abd9e4807196e2361e1080eac1dcc969de7637", + "size": 18395, + "subdir": "linux-64", + "timestamp": 1618390218807, + "version": "2.0.2" + }, + "catalogue-2.0.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5164a8c426fb248dfc5bcbb0c0c8c1d8", + "name": "catalogue", + "sha256": "2430e5108cf275a06caf1da264ee06f3a892bd6ceaa1e1ad37178302b87a4ec1", + "size": 32017, + "subdir": "linux-64", + "timestamp": 1618521455476, + "version": "2.0.3" + }, + "catalogue-2.0.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.20", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b189561961c4b9105454d3cebb768057", + "name": "catalogue", + "sha256": "b1ac5e2183a83ee7784b0ba750ae0a3125aece910a1ae6e26bc39c6ac5d8177d", + "size": 32143, + "subdir": "linux-64", + "timestamp": 1618521367759, + "version": "2.0.3" + }, + "catalogue-2.0.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "beb638aa3196a8b27bee5dc0830f70f7", + "name": "catalogue", + "sha256": "b7ce85540c007cf6bd91c48477c72a6c891d42be9db236fc082ecb1f457faa93", + "size": 32418, + "subdir": "linux-64", + "timestamp": 1618518296370, + "version": "2.0.3" + }, + "catalogue-2.0.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "241776fcd929f3bb812b1252fcfc86e7", + "name": "catalogue", + "sha256": "f43838a408c5bd0997f453ac5d7cd41496fc73f518282b6e01af080fd3295525", + "size": 32540, + "subdir": "linux-64", + "timestamp": 1618601326474, + "version": "2.0.3" + }, + "catalogue-2.0.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f190eee7f222c9d71a03bebfc0cb3df2", + "name": "catalogue", + "sha256": "9c249294e60e16ca7e41614411e9d8cbb7ad86f76a254ecf560310fe47faa641", + "size": 32691, + "subdir": "linux-64", + "timestamp": 1642503940277, + "version": "2.0.4" + }, + "catalogue-2.0.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "typing-extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a82aa472dc81674283aab8c386500624", + "name": "catalogue", + "sha256": "38462063675918f7cd5fc9763ebc5e84eed1b36cf5514dcaa2b4cbe2cbb4577c", + "size": 34766, + "subdir": "linux-64", + "timestamp": 1632751065615, + "version": "2.0.4" + }, + "catalogue-2.0.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "50f9753f7350232e91e0fe68357dc55f", + "name": "catalogue", + "sha256": "55d66fa2c03b753ce565d386edaa3c634fbf516b82a935c88b090b29cdd4a77d", + "size": 34621, + "subdir": "linux-64", + "timestamp": 1632751053029, + "version": "2.0.4" + }, + "catalogue-2.0.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fdaee9a7b3f22172f41b8a4bf97b4b68", + "name": "catalogue", + "sha256": "10c28c927208b830e2b8481d25b216cc6d737e2c60c7e9c426679bd310fee748", + "size": 34635, + "subdir": "linux-64", + "timestamp": 1632751049991, + "version": "2.0.4" + }, + "catalogue-2.0.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6a2384336a0438ca3c181101436f0f5", + "name": "catalogue", + "sha256": "6b95ead1d5e185d200d31bac918c1e0bf36130f94f7babe69d51f6528d70375f", + "size": 32700, + "subdir": "linux-64", + "timestamp": 1619735034393, + "version": "2.0.4" + }, + "catalogue-2.0.6-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b1990f68ed30885c58571793e0d71d9", + "name": "catalogue", + "sha256": "cce4d308d6fabd90d9f4eae8b95a12ac5dffb27db369147df67018246c2b545d", + "size": 32258, + "subdir": "linux-64", + "timestamp": 1643444403187, + "version": "2.0.6" + }, + "catalogue-2.0.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0e94dab605dae64b6420c3c47390d8cf", + "name": "catalogue", + "sha256": "123d1e855193de22884e7cfb4082c1d74772dad1398ad47cf4a22271e026ee0e", + "size": 32392, + "subdir": "linux-64", + "timestamp": 1643444380620, + "version": "2.0.6" + }, + "catalogue-2.0.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e3c8739ec94944ceff917f9046e7d38", + "name": "catalogue", + "sha256": "a99726cdcce3d89703f1b918c3b59ad6e94cf58690dc70cbb11f01e542113e09", + "size": 32369, + "subdir": "linux-64", + "timestamp": 1643444431792, + "version": "2.0.6" + }, + "catalogue-2.0.7-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f0c4874655c0753b66153d4f9172836c", + "name": "catalogue", + "sha256": "ad52d4cf920bf020e3e0cf3b5bd729dbbbb7ba66f865e5b2e5f05d15b8c2554c", + "size": 33411, + "subdir": "linux-64", + "timestamp": 1651218842323, + "version": "2.0.7" + }, + "catalogue-2.0.7-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df1c960c1d768fa43da079f41b787596", + "name": "catalogue", + "sha256": "1c6d9badc18e40826a172928f9bc3e75d5eae171446a76d721b0a06068cf2bd4", + "size": 40890, + "subdir": "linux-64", + "timestamp": 1676830233084, + "version": "2.0.7" + }, + "catalogue-2.0.7-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d1a7f08633bf1f4b42ecdcd30ae3c4b", + "name": "catalogue", + "sha256": "f5a1aced504f998f466a856a12c9a1a09599f040f1ddeb0fbb8d86f3c9484805", + "size": 32918, + "subdir": "linux-64", + "timestamp": 1651218804423, + "version": "2.0.7" + }, + "catalogue-2.0.7-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4a5a1e384927cf2754654b45d6e88d7", + "name": "catalogue", + "sha256": "2ecdc0e4b3e843a26e20eebc87ea2ac027e4c9bef1b4f717e88842b6d2d5cf1f", + "size": 33126, + "subdir": "linux-64", + "timestamp": 1651218867632, + "version": "2.0.7" + }, + "catalogue-2.0.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7368765b1e31eda756dd6b88643414f9", + "name": "catalogue", + "sha256": "77ee556768514cb0d254cb18372288f9b785ce46cb4d8e5ff92e0dcb7113fff1", + "size": 33102, + "subdir": "linux-64", + "timestamp": 1651218776537, + "version": "2.0.7" + }, + "catboost-0.26.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.0", + "pandas >=0.24.0", + "python >=3.6,<3.7.0a0", + "scipy", + "six" + ], + "license": "Apache-2.0", + "license_family": "MIT", + "md5": "0ba6320bec257cd1f9a7aaf0e837ec35", + "name": "catboost", + "sha256": "be3d4a06776a73756beb484f7c3bab17df24f0ceb32e7c3ee73ea5b20d4b011c", + "size": 30814373, + "subdir": "linux-64", + "timestamp": 1633420395777, + "version": "0.26.1" + }, + "catboost-0.26.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.0", + "pandas >=0.24.0", + "python >=3.7,<3.8.0a0", + "scipy", + "six" + ], + "license": "Apache-2.0", + "license_family": "MIT", + "md5": "7d2da12041fa5176a4fe26739514fda4", + "name": "catboost", + "sha256": "7925e38998adc6f06afc57946aa06921b17263cf9c2953bb9673134559b11e10", + "size": 30789292, + "subdir": "linux-64", + "timestamp": 1633409729760, + "version": "0.26.1" + }, + "catboost-0.26.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.0", + "pandas >=0.24.0", + "python >=3.8,<3.9.0a0", + "scipy", + "six" + ], + "license": "Apache-2.0", + "license_family": "MIT", + "md5": "33ea88cceca2a16ce24a662236ab377f", + "name": "catboost", + "sha256": "874127876746bd7d278218617d71dc0d507308568adb704a789337140af1c535", + "size": 30804474, + "subdir": "linux-64", + "timestamp": 1633420419255, + "version": "0.26.1" + }, + "catboost-0.26.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.0", + "pandas >=0.24.0", + "python >=3.9,<3.10.0a0", + "scipy", + "six" + ], + "license": "Apache-2.0", + "license_family": "MIT", + "md5": "651d88827ee689654bea166b28b18084", + "name": "catboost", + "sha256": "26af959da7eeb139a59b9d7dc9303ed0a796943e1f58c8f556a6084b1f88e24a", + "size": 30851927, + "subdir": "linux-64", + "timestamp": 1633420405679, + "version": "0.26.1" + }, + "catboost-1.0.6-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base", + "numpy >=1.16.0", + "pandas >=0.24.0", + "plotly", + "python >=3.10,<3.11.0a0", + "python-graphviz", + "scipy", + "six" + ], + "license": "Apache-2.0", + "license_family": "MIT", + "md5": "e304d275e2f93d438731b3481b43d74d", + "name": "catboost", + "sha256": "b85292e3267ce41d568147d7030ab0ffe5564c7c84a427b8fcde9687b83f8364", + "size": 34546776, + "subdir": "linux-64", + "timestamp": 1659346493976, + "version": "1.0.6" + }, + "catboost-1.0.6-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base", + "numpy >=1.16.0", + "pandas >=0.24.0", + "plotly", + "python >=3.7,<3.8.0a0", + "python-graphviz", + "scipy", + "six" + ], + "license": "Apache-2.0", + "license_family": "MIT", + "md5": "f3c2f53df340e07eacfc3aa0e1f1c9fb", + "name": "catboost", + "sha256": "dae5d440a718cc65029ad8b5f81c2c2b134968e3545ae561e9cb32fab7f60868", + "size": 34515851, + "subdir": "linux-64", + "timestamp": 1659346398317, + "version": "1.0.6" + }, + "catboost-1.0.6-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base", + "numpy >=1.16.0", + "pandas >=0.24.0", + "plotly", + "python >=3.8,<3.9.0a0", + "python-graphviz", + "scipy", + "six" + ], + "license": "Apache-2.0", + "license_family": "MIT", + "md5": "23819ae13cca529abcfab5d4ff65970d", + "name": "catboost", + "sha256": "33d3b6cc30c557b9621425e10c44093f5db8f19c965d40da9121ef3a5c312e45", + "size": 34536143, + "subdir": "linux-64", + "timestamp": 1659346576135, + "version": "1.0.6" + }, + "catboost-1.0.6-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base", + "numpy >=1.16.0", + "pandas >=0.24.0", + "plotly", + "python >=3.9,<3.10.0a0", + "python-graphviz", + "scipy", + "six" + ], + "license": "Apache-2.0", + "license_family": "MIT", + "md5": "455a3a46359f714f74dff04a0efb8a52", + "name": "catboost", + "sha256": "c02e532a0ddab5672517003403120f6f0d70603eb79aa8db5697d9e68432ca9b", + "size": 34547840, + "subdir": "linux-64", + "timestamp": 1659346657673, + "version": "1.0.6" + }, + "category_encoders-2.5.0-py310h2f386ee_0.conda": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "numpy >=1.21.5,<2.0a0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dadd7e1fcf80f3a046694a9896cd997e", + "name": "category_encoders", + "sha256": "1f9770ab336990d2c01654a99e46ec58d88e1841107e81bec4f73561b8541248", + "size": 89105, + "subdir": "linux-64", + "timestamp": 1659117878729, + "version": "2.5.0" + }, + "category_encoders-2.5.0-py310h2f386ee_1.conda": { + "build": "py310h2f386ee_1", + "build_number": 1, + "depends": [ + "numpy >=1.21.5,<2.0a0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "271de455a7b09174cbdfd55fd89cae9b", + "name": "category_encoders", + "sha256": "a9d6be2602e46f5307d4dc0e01ac4a96a9896fdebf7b5fe24a2821f6fc62f671", + "size": 88535, + "subdir": "linux-64", + "timestamp": 1663430348828, + "version": "2.5.0" + }, + "category_encoders-2.5.0-py37hb070fc8_0.conda": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.6,<2.0a0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e3a597e2bd0f4d5bd5a6b6bc941d2a3b", + "name": "category_encoders", + "sha256": "33d3c409ef52e2cbb80a3572c83496657affd046cde45f33763de54d12bf3fc4", + "size": 88669, + "subdir": "linux-64", + "timestamp": 1659117739573, + "version": "2.5.0" + }, + "category_encoders-2.5.0-py37hb070fc8_1.conda": { + "build": "py37hb070fc8_1", + "build_number": 1, + "depends": [ + "numpy >=1.16.6,<2.0a0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3189a02c2faeba1fbdcb2371eaa71787", + "name": "category_encoders", + "sha256": "a1f5d50b9e4cdc26661c5864cb5f6ff0dc5aa4563c3f2cc7baf2fab3e7b850e1", + "size": 88296, + "subdir": "linux-64", + "timestamp": 1663430237199, + "version": "2.5.0" + }, + "category_encoders-2.5.0-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.6,<2.0a0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c9f0abd9b00c6658e0695857ce2d1163", + "name": "category_encoders", + "sha256": "e9f4e68951af999311ece68452c1f16736fadc1807d9c747b90da29cd4de942f", + "size": 88806, + "subdir": "linux-64", + "timestamp": 1659117989943, + "version": "2.5.0" + }, + "category_encoders-2.5.0-py38hb070fc8_1.conda": { + "build": "py38hb070fc8_1", + "build_number": 1, + "depends": [ + "numpy >=1.16.6,<2.0a0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8fc84df6f6d1c069d367ecc0b996dc54", + "name": "category_encoders", + "sha256": "eb0878833402180b12a5e74b41c140eedc821c9a8a3dacb831ad3ca77f3ebe55", + "size": 88290, + "subdir": "linux-64", + "timestamp": 1663430444065, + "version": "2.5.0" + }, + "category_encoders-2.5.0-py39hb070fc8_1.conda": { + "build": "py39hb070fc8_1", + "build_number": 1, + "depends": [ + "numpy >=1.19.2,<2.0a0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "955f17badaf33af4ccb2bc3d01028f96", + "name": "category_encoders", + "sha256": "4b5557e7065243e405c8be22c1addd29beacb7f382ce096c349faccd60812b3f", + "size": 88312, + "subdir": "linux-64", + "timestamp": 1663430139225, + "version": "2.5.0" + }, + "category_encoders-2.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14.0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f13774880ebeaafca2dd630eb2a83e09", + "name": "category_encoders", + "sha256": "e09e7c139c97a932042f1816ee485b03cf3ed757bc070dd54eb7221d05e2cdf7", + "size": 109987, + "subdir": "linux-64", + "timestamp": 1677012721167, + "version": "2.6.0" + }, + "category_encoders-2.6.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14.0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.11,<3.12.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c985af78172c73025017cc50f6e7f21c", + "name": "category_encoders", + "sha256": "d3c1f3b42cc3fe03b96cbd115e5078e1f1b568e4906c02eb20c7c1ddb8484ec4", + "size": 128394, + "subdir": "linux-64", + "timestamp": 1676930344034, + "version": "2.6.0" + }, + "category_encoders-2.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14.0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "28387df67feaa76d70543ad6ec4f865d", + "name": "category_encoders", + "sha256": "fd041a348ea6b0d8aaaae5dec039a75f260cf364ca00f5a421270451bc09fdfd", + "size": 109523, + "subdir": "linux-64", + "timestamp": 1677012905152, + "version": "2.6.0" + }, + "category_encoders-2.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14.0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7affc96d7252dd312c3823ad30f1a233", + "name": "category_encoders", + "sha256": "01232333f1c9dcd0a1314554ed2c4b6194b2ba422ecb0507ce1ec5564a2edcfd", + "size": 109741, + "subdir": "linux-64", + "timestamp": 1677012998327, + "version": "2.6.0" + }, + "category_encoders-2.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14.0", + "pandas >=1.0.5", + "patsy >=0.5.1", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.20.0", + "scipy >=1.0.0", + "statsmodels >=0.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "63a7e4d1d907e084f634a69e40627f2b", + "name": "category_encoders", + "sha256": "d0d2a58f18842988b02094a497e2909bbbe4deaa171132c1c1d171cc32ac75ea", + "size": 109680, + "subdir": "linux-64", + "timestamp": 1677012817135, + "version": "2.6.0" + }, + "cattrs-22.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=20.1.0", + "exceptiongroup", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "496ecc92c011a0796e03a9621302447b", + "name": "cattrs", + "sha256": "1a0a838c3616178b32e8e899ee3ea2eb477481c4e12cd783e9a0d811acae41b7", + "size": 57716, + "subdir": "linux-64", + "timestamp": 1668797341925, + "version": "22.1.0" + }, + "cattrs-22.1.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=20.1.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "82688e90b3b763deec9e5f150eb30703", + "name": "cattrs", + "sha256": "92959b448bab3b2dc526c65fd3d411459e665c022385450bd25b11256e26073a", + "size": 73198, + "subdir": "linux-64", + "timestamp": 1676830247251, + "version": "22.1.0" + }, + "cattrs-22.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=20.1.0", + "exceptiongroup", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56c9ed1c761d3db41430f8c01cdd873d", + "name": "cattrs", + "sha256": "c86097d4978ab3bfa6996ebd3fa00f50d863a4b3cebab573bfcc7e095c837a2a", + "size": 56809, + "subdir": "linux-64", + "timestamp": 1668797312972, + "version": "22.1.0" + }, + "cattrs-22.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=20.1.0", + "exceptiongroup", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d22ddc20270280bab10282ae3efefa2", + "name": "cattrs", + "sha256": "2e7e4dde3fa0d7ab24bb177eee1158545e3cf71f6091ba1e41c0b13b43bb6d12", + "size": 58141, + "subdir": "linux-64", + "timestamp": 1668797284319, + "version": "22.1.0" + }, + "cattrs-22.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=20.1.0", + "exceptiongroup", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3020bb043364d4fb4bf9bd1c34e85a4c", + "name": "cattrs", + "sha256": "fd1c4f8c449435e7bf3edfe76ef4f202f2ce608ad6bf8be203f270d844dd6c3e", + "size": 58030, + "subdir": "linux-64", + "timestamp": 1668797370411, + "version": "22.1.0" + }, + "ccache-3.7.1-h0b5b093_0.conda": { + "build": "h0b5b093_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "19c1ee01e48d864da6fe82b2147ead5b", + "name": "ccache", + "sha256": "e638048f6918d390cd8c788e1cfb1589aa0d88948631fe8121d9e5f2f1ed8f54", + "size": 101562, + "subdir": "linux-64", + "timestamp": 1564158593231, + "version": "3.7.1" + }, + "ccache-3.7.9-hfe4627d_0.conda": { + "build": "hfe4627d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "bef6fc681c273bb7bd0c67d1a591365e", + "name": "ccache", + "sha256": "7a1f378ae68480515d539709b65873dbb454b0e79d561eff86f6147e080672fb", + "size": 106175, + "subdir": "linux-64", + "timestamp": 1588382484110, + "version": "3.7.9" + }, + "cctools-949.0.1-h2b5a052_25.conda": { + "build": "h2b5a052_25", + "build_number": 25, + "depends": [ + "cctools_linux-64 949.0.1 h4441c4d_25", + "ld64 530 h0c34534_25" + ], + "license": "APSL-2.0", + "license_family": "Other", + "md5": "b7d3e4e883dd5bfa716739f1eac7e364", + "name": "cctools", + "sha256": "980894d5883bfae2f8deff784c8e48dbe3b2710e36b36d0aa94a5024bbd251bd", + "size": 17861, + "subdir": "linux-64", + "timestamp": 1662554237741, + "version": "949.0.1" + }, + "cctools_linux-64-949.0.1-h4441c4d_25.conda": { + "build": "h4441c4d_25", + "build_number": 25, + "constrains": [ + "cctools 949.0.1.*" + ], + "depends": [ + "ld64_linux-64 >=530,<531.0a0", + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0" + ], + "license": "APSL-2.0", + "license_family": "Other", + "md5": "3b646a1255d1a819700f8287232dcd32", + "name": "cctools_linux-64", + "sha256": "ebc34d7570d5108b6e419b79d08e695691f6f364949ec2d6d1fd2fd1d767d6d9", + "size": 4534972, + "subdir": "linux-64", + "timestamp": 1662554217006, + "version": "949.0.1" + }, + "cdecimal-2.3-py27h14c3975_3.conda": { + "build": "py27h14c3975_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "96b15f3bf5d7d4d8bb6da944a58ff396", + "name": "cdecimal", + "sha256": "c4cfa58cb54fab7ff660d70eb1099efc434b34ec61500bff6392a1db4bf44c8d", + "size": 133275, + "subdir": "linux-64", + "timestamp": 1518031534982, + "version": "2.3" + }, + "cdecimal-2.3-py27h4e63abe_1.conda": { + "build": "py27h4e63abe_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "0fad437dda611a6e6b9a8fb04727ae4a", + "name": "cdecimal", + "sha256": "4117f40518f0194ae000f11bcdc27aef444ee41e3aee74456072beda9e12c2a5", + "size": 132815, + "subdir": "linux-64", + "timestamp": 1505741889808, + "version": "2.3" + }, + "certifi-2017.11.5-py27h71e7faf_0.conda": { + "build": "py27h71e7faf_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "50bb5d058bfd506461e070ebb55c2b3e", + "name": "certifi", + "sha256": "e8a7686c1dd8c573f599428c86e0b5260b56fa8ce938d3312d4c313797bcd753", + "size": 159239, + "subdir": "linux-64", + "timestamp": 1511294655335, + "version": "2017.11.5" + }, + "certifi-2017.11.5-py35h9749603_0.conda": { + "build": "py35h9749603_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "bbe07fe9cd4b7281626b41e68297ceab", + "name": "certifi", + "sha256": "32283c1e72479edb3af50b8d8b36816ae24cdf1ab358f6e3855daea97d7114b8", + "size": 159328, + "subdir": "linux-64", + "timestamp": 1511294731064, + "version": "2017.11.5" + }, + "certifi-2017.11.5-py36hf29ccca_0.conda": { + "build": "py36hf29ccca_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "d91d669baf42b77b4e374b385d35639b", + "name": "certifi", + "sha256": "aa98342c2c4cecc5e017b56f6f3503e04a4a0f5f49467518072e1976e98fc48e", + "size": 159338, + "subdir": "linux-64", + "timestamp": 1511294734842, + "version": "2017.11.5" + }, + "certifi-2017.7.27.1-py27h9ceb091_0.conda": { + "build": "py27h9ceb091_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "d9de102a4bd34ff53484241862cc9d1c", + "name": "certifi", + "sha256": "b06a7fd3b977b4ba7a344814b7a1326f5fb0f5eaf3b20cbdcc78ed30aee8251c", + "size": 166095, + "subdir": "linux-64", + "timestamp": 1505671803420, + "version": "2017.7.27.1" + }, + "certifi-2017.7.27.1-py35h19f42a1_0.conda": { + "build": "py35h19f42a1_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "3961c063aa2e09ac0bc9b8adb67e3229", + "name": "certifi", + "sha256": "4c8d77df17c1bb5ffe41023a3cb7e0cc120e1d1b7a2b42630e76401e2ec17d82", + "size": 166031, + "subdir": "linux-64", + "timestamp": 1505671814237, + "version": "2017.7.27.1" + }, + "certifi-2017.7.27.1-py36h8b7b77e_0.conda": { + "build": "py36h8b7b77e_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "3e50b87984cdfd2dcb0fe5ac953d197c", + "name": "certifi", + "sha256": "901d227c0a2101667e0387f1f78585443b84c33647e86dff217f9666cf4facf2", + "size": 165903, + "subdir": "linux-64", + "timestamp": 1505671825111, + "version": "2017.7.27.1" + }, + "certifi-2018.1.18-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "68267c63e87089de0e858e06a3b78a08", + "name": "certifi", + "sha256": "e7cf0174eb295eb9d691a4d768a0d8f37131f088142966353dbc510ec5f4e5c6", + "size": 144909, + "subdir": "linux-64", + "timestamp": 1516980213122, + "version": "2018.1.18" + }, + "certifi-2018.1.18-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "ef324e8dbc8f2a674924c2b15a8f9614", + "name": "certifi", + "sha256": "ed968832758511f310e9c63dc94eb875c6209d5dd9597b42485a32678f6daa02", + "size": 144708, + "subdir": "linux-64", + "timestamp": 1516980230430, + "version": "2018.1.18" + }, + "certifi-2018.1.18-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "05b84e9930ba764c276013685cb9cc4e", + "name": "certifi", + "sha256": "fa7b76bc4c7febfc19b99c3233dbb7fc54969ec99d7659ac4077aa05580831d5", + "size": 144591, + "subdir": "linux-64", + "timestamp": 1516980228329, + "version": "2018.1.18" + }, + "certifi-2018.10.15-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "3a88b304f7a51dcfc99668b6b09ba231", + "name": "certifi", + "sha256": "6e333e488259ef15bf048570b77f4cdd4aadaa735f2d35eeb975517dbe306772", + "size": 139826, + "subdir": "linux-64", + "timestamp": 1539630880376, + "version": "2018.10.15" + }, + "certifi-2018.10.15-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "1ad06c947d0ed4da9a9746c4fe544fa9", + "name": "certifi", + "sha256": "5d704ce1a69533568e32d676569ed9a85eafbafbe441f72ca635c5a8c2f07418", + "size": 139504, + "subdir": "linux-64", + "timestamp": 1539630907448, + "version": "2018.10.15" + }, + "certifi-2018.10.15-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "1de7c36160604f189a3dbe9ac512ba85", + "name": "certifi", + "sha256": "28bca9b29871c12d9c2eeeb26e80013866b6d7bd04586cb1d8b23b3d23357fac", + "size": 139999, + "subdir": "linux-64", + "timestamp": 1539630902508, + "version": "2018.10.15" + }, + "certifi-2018.11.29-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "32a713f1366caed8642b3af86c5ff96c", + "name": "certifi", + "sha256": "1bf741c8ab38d9458415a4b293c84f4d75a39cca1afac72f3afc1d3c5679de2a", + "size": 146701, + "subdir": "linux-64", + "timestamp": 1544460991682, + "version": "2018.11.29" + }, + "certifi-2018.11.29-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "7a69c0cf7b53caa57f7ae5da72a1de4e", + "name": "certifi", + "sha256": "a5e95820efa5d2306270b92844fd6e59613352b291bad012acb641fda7b33045", + "size": 146976, + "subdir": "linux-64", + "timestamp": 1544461005201, + "version": "2018.11.29" + }, + "certifi-2018.11.29-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "3578ab42b5af0e430309d52f06c2e7b4", + "name": "certifi", + "sha256": "993239a1686603a71988035b78bbeb2fd55faf9336d7f6dde49fa14de9712af8", + "size": 146745, + "subdir": "linux-64", + "timestamp": 1544460981237, + "version": "2018.11.29" + }, + "certifi-2018.4.16-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "86a60311db694315f5d098922606bec4", + "name": "certifi", + "sha256": "68dddc92a05449686172c2a7a321a842cdaf5c976859e352f46b994250c3ebf6", + "size": 143393, + "subdir": "linux-64", + "timestamp": 1524178079027, + "version": "2018.4.16" + }, + "certifi-2018.4.16-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "8ff4e98de84f602fdbd5ec9527381ca7", + "name": "certifi", + "sha256": "10b5c5e3652d438443750ce683170c4e7a9e8d25a2c8d53ffea5abc1ed47ed86", + "size": 143803, + "subdir": "linux-64", + "timestamp": 1524178040705, + "version": "2018.4.16" + }, + "certifi-2018.4.16-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "47ccc911307d4c2841d3626049d54621", + "name": "certifi", + "sha256": "e4e8c0ad8a6386df840f571f69c86c84dc2ac9c923ae15c29234fc55d2a0dca4", + "size": 143763, + "subdir": "linux-64", + "timestamp": 1524178083336, + "version": "2018.4.16" + }, + "certifi-2018.4.16-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "5526f495ae4eb6190373ab4b827ed584", + "name": "certifi", + "sha256": "1faf59a362526e1dc82722276af8354c58c2455d6b150be722dcaaff58f33c89", + "size": 143492, + "subdir": "linux-64", + "timestamp": 1530212464154, + "version": "2018.4.16" + }, + "certifi-2018.8.13-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "c9269c295be70b2f9fd00a18d64a7199", + "name": "certifi", + "sha256": "b52f230585a94a610fab20c73dcefab503112b1f6a5aa04257108e192e762674", + "size": 139557, + "subdir": "linux-64", + "timestamp": 1534172229646, + "version": "2018.8.13" + }, + "certifi-2018.8.13-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "8da075e477af56a215e83e2c5076a4b2", + "name": "certifi", + "sha256": "248beb032e349fecb02d89304aef925d1835fc7ff38ab82bf99d461f13e5d24c", + "size": 139990, + "subdir": "linux-64", + "timestamp": 1534172260589, + "version": "2018.8.13" + }, + "certifi-2018.8.13-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "3c445273934bb74f2d276b1734f1e737", + "name": "certifi", + "sha256": "5c69ef278fdc7b7bf465c3596b9bc08a28d5ac00b01997af54615f5d550bc918", + "size": 139610, + "subdir": "linux-64", + "timestamp": 1534172212969, + "version": "2018.8.13" + }, + "certifi-2018.8.13-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "55991c1cf07019b49450c0688a54a83e", + "name": "certifi", + "sha256": "8ba2b07f36c44550aa03f2ac67b4e85922f2ed53260c7e416d617ab7e8744125", + "size": 139655, + "subdir": "linux-64", + "timestamp": 1534172661432, + "version": "2018.8.13" + }, + "certifi-2018.8.24-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "5827d33f3e2802b1b6209bb54e4982d0", + "name": "certifi", + "sha256": "ce0a546d1cef7d74f293fda96de69e96087077082be3dad5cce7755d6406b2cb", + "size": 140144, + "subdir": "linux-64", + "timestamp": 1535377823170, + "version": "2018.8.24" + }, + "certifi-2018.8.24-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "2f3ed17329d14bf4f90d998432b24c66", + "name": "certifi", + "sha256": "fcf7fe319e68fa29a3354f93cea101c29fbf24d2f6491c81baa4499a4f028385", + "size": 140351, + "subdir": "linux-64", + "timestamp": 1535377839241, + "version": "2018.8.24" + }, + "certifi-2018.8.24-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "751a46b04a37666bfe90391369155233", + "name": "certifi", + "sha256": "9a22b1fb2d50cf4b9cee6b27aaf38299bcf760259aeb13d3b0c5d6b7302c3d00", + "size": 140185, + "subdir": "linux-64", + "timestamp": 1535377801428, + "version": "2018.8.24" + }, + "certifi-2018.8.24-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "aafeccdd4ebe4b670479e57591878032", + "name": "certifi", + "sha256": "20ee8e1c8a5632f0f627a107d7d2d6e9e639a164828907cf068a327cf8327ba2", + "size": 140211, + "subdir": "linux-64", + "timestamp": 1535377830376, + "version": "2018.8.24" + }, + "certifi-2019.11.28-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "2b88707fb994339421000edc33e2419e", + "name": "certifi", + "sha256": "acc13cb008b0e3508f9037fe13dbd54480196e6a09745394dad3637f0e1eefb1", + "size": 156298, + "subdir": "linux-64", + "timestamp": 1575390236154, + "version": "2019.11.28" + }, + "certifi-2019.11.28-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "b9785b5c712a93498f6753ed0b73d0c3", + "name": "certifi", + "sha256": "eb4116fc73c2766f0958f9b372fde5eb7b630fe7677f115ba4b2c64946446d41", + "size": 156500, + "subdir": "linux-64", + "timestamp": 1575390251400, + "version": "2019.11.28" + }, + "certifi-2019.11.28-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "363861a7e6008f76b9e089458d4c33d6", + "name": "certifi", + "sha256": "31399e741241de2afd88c42cc612e6d27803469542e8efd7ca368dd77afe0c78", + "size": 157027, + "subdir": "linux-64", + "timestamp": 1584971938832, + "version": "2019.11.28" + }, + "certifi-2019.11.28-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "38d2ab3843ec44c5975a17eabe686d2b", + "name": "certifi", + "sha256": "b2aa759f28289aa20f4b0bd1faae84ab24f5aacb9d44b3a3f55acc84c0a0b700", + "size": 156390, + "subdir": "linux-64", + "timestamp": 1575390189519, + "version": "2019.11.28" + }, + "certifi-2019.11.28-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "a9319c640377aff021c37c39230dcbad", + "name": "certifi", + "sha256": "3a75d0fe491b1682400218d7d9fe9f6f5277d22b1fa40f412131cf5931bf1533", + "size": 157047, + "subdir": "linux-64", + "timestamp": 1584971732458, + "version": "2019.11.28" + }, + "certifi-2019.11.28-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "5995992676390e6621568b863c7595e2", + "name": "certifi", + "sha256": "e8d580717f5bf2084c9a84db6dbfc20ea2e8ad80e92ed6fdd12cf3a79734e1cd", + "size": 156763, + "subdir": "linux-64", + "timestamp": 1575390379048, + "version": "2019.11.28" + }, + "certifi-2019.11.28-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "27ad7526792c702d7400dc1f1e8d2d5f", + "name": "certifi", + "sha256": "d2e60002d0ac7f1113ec560270d0270fa97806e935c9253cb26dd5f3885cbaf2", + "size": 157008, + "subdir": "linux-64", + "timestamp": 1584972000953, + "version": "2019.11.28" + }, + "certifi-2019.3.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "8b9667b364b8b467c58f5e15528e7667", + "name": "certifi", + "sha256": "e150ae6b8f8ce404de54771112e9cfb68948b5f38ada8c1b465f8deca1f29386", + "size": 155671, + "subdir": "linux-64", + "timestamp": 1552318228443, + "version": "2019.3.9" + }, + "certifi-2019.3.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "4ad6d5841a62d4598ed86e5cab38158f", + "name": "certifi", + "sha256": "e478f5dbb2bf31e31cf6dd5495a025a07348bef42464f66b94616e91a385748d", + "size": 155605, + "subdir": "linux-64", + "timestamp": 1552318251063, + "version": "2019.3.9" + }, + "certifi-2019.3.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "f1e25c36854a1a592130bd6f77c07bac", + "name": "certifi", + "sha256": "496be64fca9ea30a0b5b6d3cf7a0e44773f7f24f4ff6495d044c51727a92f2c5", + "size": 155610, + "subdir": "linux-64", + "timestamp": 1552318217480, + "version": "2019.3.9" + }, + "certifi-2019.6.16-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "d3df81f1f4c8ad8f7d1afb248e2c821a", + "name": "certifi", + "sha256": "7a5af9456510040d8fda9c8ae14c6f5b1341b8c0b88405cb98fbd96486a901fb", + "size": 153958, + "subdir": "linux-64", + "timestamp": 1561070541544, + "version": "2019.6.16" + }, + "certifi-2019.6.16-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "0d1e4cacc46655a0fd719748dc9a7860", + "name": "certifi", + "sha256": "3c56ca3dcff4138bc770bf6067c7d230fa91a9c1f2f1769dfa941ef3111150e8", + "size": 155972, + "subdir": "linux-64", + "timestamp": 1564158793063, + "version": "2019.6.16" + }, + "certifi-2019.6.16-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "f14e14314acdcbc01eed95daa29198d2", + "name": "certifi", + "sha256": "94b98016950bf90ccd473d43a1a3b1d8cf59d10bbd4258e8e5e6bd16114ff365", + "size": 154034, + "subdir": "linux-64", + "timestamp": 1561070584249, + "version": "2019.6.16" + }, + "certifi-2019.6.16-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "fb413c96a8fd48db372f99240b4187cd", + "name": "certifi", + "sha256": "3a45ae62e24d0dbafbc6558bda60f8a282f455f15d335d58ffc442c0ff687f44", + "size": 156063, + "subdir": "linux-64", + "timestamp": 1564158793222, + "version": "2019.6.16" + }, + "certifi-2019.6.16-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "1856d9b4c20c48e35420aa1550a6ab50", + "name": "certifi", + "sha256": "e3261944bf4f606a59aa385934f9f2974cf46a5299827e2409f60518f05ea9e7", + "size": 154058, + "subdir": "linux-64", + "timestamp": 1561070559881, + "version": "2019.6.16" + }, + "certifi-2019.6.16-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "3042a4ef94f822f0b31ab30833f6a259", + "name": "certifi", + "sha256": "d3ff348be4288c89d4a94c36310dd293c34083df324cb341755dd42bf402d72e", + "size": 155590, + "subdir": "linux-64", + "timestamp": 1564158795394, + "version": "2019.6.16" + }, + "certifi-2019.9.11-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "db235035eefff32e8dbde1e1379d910b", + "name": "certifi", + "sha256": "cb3dc967eea4e51d0a958af6eba6428ba498460edc7e3385e0460e98a7a350e5", + "size": 154598, + "subdir": "linux-64", + "timestamp": 1569254339192, + "version": "2019.9.11" + }, + "certifi-2019.9.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "7d945a4a1967a696ebc6e40bb555d487", + "name": "certifi", + "sha256": "19e887da285684a07f9315208f61705cd06a0e9ee58bc8257373a86b9c5490d7", + "size": 154668, + "subdir": "linux-64", + "timestamp": 1569254356942, + "version": "2019.9.11" + }, + "certifi-2019.9.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "49cc05d5f9d6a56f219f1d558f87af30", + "name": "certifi", + "sha256": "ba302b79da91710eb983b6baa1734d1b297228766b1f56dbaae95ae225403f28", + "size": 154743, + "subdir": "linux-64", + "timestamp": 1569254344723, + "version": "2019.9.11" + }, + "certifi-2019.9.11-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "f340a2e60f6b056faf1ca79af880fd14", + "name": "certifi", + "sha256": "c19272f6f32d56e585ce6c92253db0c704a684c85347281b81e37affe42e0f2d", + "size": 154584, + "subdir": "linux-64", + "timestamp": 1571953056223, + "version": "2019.9.11" + }, + "certifi-2020.11.8-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "57a9f357393c8701d8bb5b8923f74754", + "name": "certifi", + "sha256": "259af99d76da6a11e3785d82c7de6ad14f9f1dfa9af56662faa64f43534f76ee", + "size": 150626, + "subdir": "linux-64", + "timestamp": 1606143378686, + "version": "2020.11.8" + }, + "certifi-2020.11.8-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "d42cb8eedb55c3fad2da7f83a53bec85", + "name": "certifi", + "sha256": "9fc20cd9474608f616a1d621ddfdfe6a88432d849179e639a947d575ce4818dc", + "size": 151302, + "subdir": "linux-64", + "timestamp": 1606143381203, + "version": "2020.11.8" + }, + "certifi-2020.11.8-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "b1037328d49d656ad9ede44d2049f564", + "name": "certifi", + "sha256": "e46eee6fae3a82aaf87090c2d167fa331cec37855e05aa98b502c4fcc0d4c512", + "size": 150675, + "subdir": "linux-64", + "timestamp": 1606143374950, + "version": "2020.11.8" + }, + "certifi-2020.11.8-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "md5": "67d9c04cc1324ac9da2ed5b97902992d", + "name": "certifi", + "sha256": "52af225619aeca5ab9fc589b1a4a2df32d84d291eaa3c7d9e1c5a7097fa6346f", + "size": 151711, + "subdir": "linux-64", + "timestamp": 1606143386176, + "version": "2020.11.8" + }, + "certifi-2020.12.5-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "40f599422f77a1abbfb62cf998eb316a", + "name": "certifi", + "sha256": "f194b02d82b46ed3e5a4d2844c54395ce9b9fc961ebb1822b618e474c0303138", + "size": 143653, + "subdir": "linux-64", + "timestamp": 1607365724491, + "version": "2020.12.5" + }, + "certifi-2020.12.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "7141e36776976ba17fcf6859f840cdfd", + "name": "certifi", + "sha256": "779107bb516619b70193806b5c5135e226b4b4378835fa2e4502fc03162d954d", + "size": 144324, + "subdir": "linux-64", + "timestamp": 1607365768496, + "version": "2020.12.5" + }, + "certifi-2020.12.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "a0284d282349498e5e88dd3be1a4b61d", + "name": "certifi", + "sha256": "3ada7feea92eada57161fe8b6b32399d15ada9c4f29c5d2818f84502b9505920", + "size": 144178, + "subdir": "linux-64", + "timestamp": 1607365752742, + "version": "2020.12.5" + }, + "certifi-2020.12.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "md5": "a0f4bb2d94e03aec1788fcc4c3e9a199", + "name": "certifi", + "sha256": "543d789a55e37556385f0c7c7529911e8ba5653e457571d561b047be20886864", + "size": 143322, + "subdir": "linux-64", + "timestamp": 1607365763827, + "version": "2020.12.5" + }, + "certifi-2020.4.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "ec90b8d26f55106654f13997b4a3d185", + "name": "certifi", + "sha256": "34b5c0dc1b08db97919261908fba3a0c53b4afafc7c95197b1c7dd5e4dcd71b5", + "size": 158848, + "subdir": "linux-64", + "timestamp": 1586198631628, + "version": "2020.4.5.1" + }, + "certifi-2020.4.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "e513b6794fd5afef1d299c1b6efcbb0b", + "name": "certifi", + "sha256": "79277868c5b86593cc5b3ea59ba1b458ffceab9c1f0d4907ccad0a9f0abfadcc", + "size": 159126, + "subdir": "linux-64", + "timestamp": 1586198629955, + "version": "2020.4.5.1" + }, + "certifi-2020.4.5.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "36dbb822ad0ab2cc418f8c2a941f6170", + "name": "certifi", + "sha256": "f7799f5b7699286ac88ee6f48889cd3db74a4c7f61a02599efa9e089ab5412ab", + "size": 159537, + "subdir": "linux-64", + "timestamp": 1586198646161, + "version": "2020.4.5.1" + }, + "certifi-2020.4.5.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "4ad446086c6ffd0bb48daef877e5ef5f", + "name": "certifi", + "sha256": "e46b5c1275de5bf4c7685306b7d50ec38e640ca50decd5051fe01fe61d370165", + "size": 160570, + "subdir": "linux-64", + "timestamp": 1592250826099, + "version": "2020.4.5.2" + }, + "certifi-2020.4.5.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "35f53821d1554ef901defb21e31a5d3e", + "name": "certifi", + "sha256": "f1862e86fca98a4dbab43ecb7e1ace37308c07f97bda49659296fa7caf6c1b55", + "size": 160507, + "subdir": "linux-64", + "timestamp": 1592250824309, + "version": "2020.4.5.2" + }, + "certifi-2020.4.5.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "5bdfdc27dbbe18c5f4f4e87414257faf", + "name": "certifi", + "sha256": "fb526fba09e8b4cc45b476756ba1f85ab600c296339cde68b79e2f68f9e01679", + "size": 160186, + "subdir": "linux-64", + "timestamp": 1592250824310, + "version": "2020.4.5.2" + }, + "certifi-2020.6.20-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "e7b87a43a4a26e29dd1bd203445f5da3", + "name": "certifi", + "sha256": "25e7ba509b08acb45fb81e145c22984961de5269000e4ad56ad98a954817938d", + "size": 159696, + "subdir": "linux-64", + "timestamp": 1592841344695, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "ca6540f464b0b34103362ac0fdac365c", + "name": "certifi", + "sha256": "55a4564d6ff9897e860ed526274d58cc38196ee93ab45b9281e7492809f5364c", + "size": 159227, + "subdir": "linux-64", + "timestamp": 1604429341748, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "385aa7f99f6699c932a301eb418ca59c", + "name": "certifi", + "sha256": "8875afa5944885855a8c6cfc55d70eb73f3e12452078ba250a0b5213692712b1", + "size": 152209, + "subdir": "linux-64", + "timestamp": 1603840232396, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "df9cdad83d32dee48b24f94696e3fac6", + "name": "certifi", + "sha256": "167757a40e4d3e8beee12c6bf2b5b8b62c8ee4eabdf4c93906943504f7c00c85", + "size": 159652, + "subdir": "linux-64", + "timestamp": 1592841294400, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "c271437ca21a83d81ca78f54ef27f10a", + "name": "certifi", + "sha256": "c2f5075b9221511506ce9a5723f90c8f1676c5e10ad37b2a45e720a3ae5709f7", + "size": 159867, + "subdir": "linux-64", + "timestamp": 1604429357693, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "abd96f850bbff469f915cf3ab966aff6", + "name": "certifi", + "sha256": "33956e92c44760f901207a173711fcf567fd8ff7187032714a408ff46f03ce68", + "size": 152627, + "subdir": "linux-64", + "timestamp": 1603840246934, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "7881da1725fe5021071979e3566e3141", + "name": "certifi", + "sha256": "ae4d2358a403cb1dc34c38965d5540d66050c4f4df14c72d3e338f1acd239d71", + "size": 159789, + "subdir": "linux-64", + "timestamp": 1592841307034, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "4c16f4ee8bf5ea06a4c9dca757505dd4", + "name": "certifi", + "sha256": "0b394c0f322a07b6f9add07f26450e868f0b8a2ec459ab61d24fe596e2e832da", + "size": 159225, + "subdir": "linux-64", + "timestamp": 1604429383407, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "f212df6bd0d81b0fd2283545fba36080", + "name": "certifi", + "sha256": "6e5041377fad6c78f00f7e459538e11f8f4f800a991ef59867ecd4bb92d13ea9", + "size": 152692, + "subdir": "linux-64", + "timestamp": 1603840253164, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "md5": "fb6e1e16d78d6a5e2ee356295fde8f9a", + "name": "certifi", + "sha256": "b2dca36f2004b88ab4bcbcc72d6ecdd965c8f9039bb22b4781da76057b529db9", + "size": 159799, + "subdir": "linux-64", + "timestamp": 1604429385138, + "version": "2020.6.20" + }, + "certifi-2020.6.20-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "md5": "0a1f0e537a27d109029e112f27dff7a1", + "name": "certifi", + "sha256": "8668b8f44be6f9d3729c19dd8a2fd53f072304447bc5f01aa362b283a02a5552", + "size": 152352, + "subdir": "linux-64", + "timestamp": 1603840204591, + "version": "2020.6.20" + }, + "certifi-2021.10.8-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "185f976a142a88ef45d6f934dfcc646b", + "name": "certifi", + "sha256": "ae539a384b466ba51e44f7dc9cffde53fce374fb873f1e15f32dfffc584dd698", + "size": 154766, + "subdir": "linux-64", + "timestamp": 1634050492891, + "version": "2021.10.8" + }, + "certifi-2021.10.8-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0", + "md5": "deaf5eb9c22d3bfb2c9ea488f5ec1eef", + "name": "certifi", + "sha256": "528c11a2065dcd8d3e3db5786e59d994ebf026aa89e188169a5ed899d964a502", + "size": 154769, + "subdir": "linux-64", + "timestamp": 1641900025688, + "version": "2021.10.8" + }, + "certifi-2021.10.8-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "31f2f30f6bb54a73b89a814e2e6d60af", + "name": "certifi", + "sha256": "c3b71a3c9b0e6c2079ac242c5faf05faa4c7ad8e8ec2e24c692e409d3caafb35", + "size": 154946, + "subdir": "linux-64", + "timestamp": 1634039482254, + "version": "2021.10.8" + }, + "certifi-2021.10.8-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0", + "md5": "5b1b38defe6479dcc64df1bc4dfb587d", + "name": "certifi", + "sha256": "c7f0b2b5de9afb20a0fcf1d2f8e5912b5ee638ff6508e02b0cae66d57c1de4c0", + "size": 155315, + "subdir": "linux-64", + "timestamp": 1641900025463, + "version": "2021.10.8" + }, + "certifi-2021.10.8-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "md5": "3a79ff24d25f491dc672fc8cee7b2483", + "name": "certifi", + "sha256": "0f4b29b954e6f72de112e1866d3b2580bbbc84f8170801cf2b0c551069f5f282", + "size": 154465, + "subdir": "linux-64", + "timestamp": 1634050491429, + "version": "2021.10.8" + }, + "certifi-2021.10.8-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0", + "md5": "471b9268be2134d5e875de762b71d922", + "name": "certifi", + "sha256": "c3af2170783dc8d3b0cddca2c8e9457c1662bca5e0d1d52959fb702a3bb44586", + "size": 154195, + "subdir": "linux-64", + "timestamp": 1641885050341, + "version": "2021.10.8" + }, + "certifi-2021.5.30-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0", + "md5": "803b97c2b3265bd360e303e133352b31", + "name": "certifi", + "sha256": "b9979ab6cc4df53bda0f857abb395c39df528c159fc8f51b2a56c9ac49b8762e", + "size": 151408, + "subdir": "linux-64", + "timestamp": 1633015810184, + "version": "2021.5.30" + }, + "certifi-2021.5.30-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPL-2.0", + "md5": "c584ff949db09621526ffc6f706f494f", + "name": "certifi", + "sha256": "7b1e690a42105c5fdc48a77531a381a91253c2e41722c082f161f53c91c12156", + "size": 142495, + "subdir": "linux-64", + "timestamp": 1622567725440, + "version": "2021.5.30" + }, + "certifi-2021.5.30-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0", + "md5": "814520489d52921daf90974e88d5267a", + "name": "certifi", + "sha256": "7f22e43f2b812752b897d7529313c8d46db489877b0cd1972bf9f46dbec519f5", + "size": 142230, + "subdir": "linux-64", + "timestamp": 1622567245455, + "version": "2021.5.30" + }, + "certifi-2021.5.30-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0", + "md5": "72292dd88ab45323a890685c90c271e3", + "name": "certifi", + "sha256": "5af70eb33567553f7ddd967b0d5290213c50dc2f7da6a1c8c3ce7e925e8aa774", + "size": 141349, + "subdir": "linux-64", + "timestamp": 1622562517906, + "version": "2021.5.30" + }, + "certifi-2021.5.30-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0", + "md5": "dae0964c9bedbb1ad47dfab36ea2a310", + "name": "certifi", + "sha256": "42918dff25511e3d8d82c51ef16d26ef50b6d52ec59a9aaf3ac25c90561d1723", + "size": 142604, + "subdir": "linux-64", + "timestamp": 1622562526194, + "version": "2021.5.30" + }, + "certifi-2022.12.7-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "1f28faeb97a361c9998090edc4e7d729", + "name": "certifi", + "sha256": "db512b2e63178e6244e889a17553f2bd7fb60c7caed9fb7997e938bb2d9feef5", + "size": 153593, + "subdir": "linux-64", + "timestamp": 1671487846135, + "version": "2022.12.7" + }, + "certifi-2022.12.7-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "c83da4712f456a311a15392186b607a3", + "name": "certifi", + "sha256": "2c7b82ce146264459c9a40934a735b35e56e213390a247679548be4ae7d40b8d", + "size": 152823, + "subdir": "linux-64", + "timestamp": 1676822455336, + "version": "2022.12.7" + }, + "certifi-2022.12.7-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "f71525bff3708b8c6232bd7535c032ca", + "name": "certifi", + "sha256": "4454ee56e62fbb7981c3db8be74bab42598d03a9c68a505b3eb330b0a5fa80ee", + "size": 153417, + "subdir": "linux-64", + "timestamp": 1671487798259, + "version": "2022.12.7" + }, + "certifi-2022.12.7-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "243cddde550e2c3e765db25cdea99a13", + "name": "certifi", + "sha256": "2e992c4c07e8531b1b8afc39133e668530bb2818aa6c9657e92bbbf909e8d1a1", + "size": 153514, + "subdir": "linux-64", + "timestamp": 1671487821981, + "version": "2022.12.7" + }, + "certifi-2022.12.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "b4238d910e43d09651eebe8db79b5c68", + "name": "certifi", + "sha256": "ba656c279d0c733ceb5fa1201f4a02ca525e73b7e963b6709f9f878e5bc8ede5", + "size": 153500, + "subdir": "linux-64", + "timestamp": 1671487870106, + "version": "2022.12.7" + }, + "certifi-2022.5.18.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "8773bfc3338ab0b30f0a93067517fb0e", + "name": "certifi", + "sha256": "9b10605886b608817d6d3c7c07c723f09db503a730b17961511167499eddf5cf", + "size": 150768, + "subdir": "linux-64", + "timestamp": 1653078274304, + "version": "2022.5.18.1" + }, + "certifi-2022.5.18.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "cf0c21052ae4ac0b44e1bd81877aabcc", + "name": "certifi", + "sha256": "c191dc9de2557e98f2bd884bafa2d83e635e5585a4956a46f704b511b8bd4566", + "size": 150643, + "subdir": "linux-64", + "timestamp": 1653078324238, + "version": "2022.5.18.1" + }, + "certifi-2022.5.18.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "dee2837b4ce535119636eb15ab312fd2", + "name": "certifi", + "sha256": "d34416942dee94a56eb2e1a66205194e093ec7dcb197c19c1a0fdb016f750640", + "size": 150671, + "subdir": "linux-64", + "timestamp": 1653078345303, + "version": "2022.5.18.1" + }, + "certifi-2022.5.18.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "23cf7855837fec26c2ab8de97b95ef1d", + "name": "certifi", + "sha256": "5f7aee2bf8bbb9cb06c331fc6a4e64ac5fd6cf139ec43d0b00c1dc5929315c76", + "size": 150661, + "subdir": "linux-64", + "timestamp": 1653078300808, + "version": "2022.5.18.1" + }, + "certifi-2022.6.15-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "36486307238f598fbbbd575aeb741752", + "name": "certifi", + "sha256": "d6ca4cdefb1b708fc463a30910c92333bb0447b25c55ad034d17f33b8f2d9a58", + "size": 156657, + "subdir": "linux-64", + "timestamp": 1655968847382, + "version": "2022.6.15" + }, + "certifi-2022.6.15-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "a5ad28afa78daec3fcbd6cf2a9df5301", + "name": "certifi", + "sha256": "fb98aebe3ebc170b81718487ff94758763571e1c4b44f2c1f8a1235499e0bbb0", + "size": 156707, + "subdir": "linux-64", + "timestamp": 1655968895591, + "version": "2022.6.15" + }, + "certifi-2022.6.15-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "ebd13bbcc4bd93d8e743be775cc9b865", + "name": "certifi", + "sha256": "90d7b4addc2aa077fbd00c4d7600b616dd85fe4aca9778efbc558c0927a79459", + "size": 156765, + "subdir": "linux-64", + "timestamp": 1655968918305, + "version": "2022.6.15" + }, + "certifi-2022.6.15-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "2f715a68f1be9125f5c8f0425ea6eb30", + "name": "certifi", + "sha256": "397b7731c35b14042f960a1ecb858f433dc90d9a0d62405b848d90672346f839", + "size": 156712, + "subdir": "linux-64", + "timestamp": 1655968870556, + "version": "2022.6.15" + }, + "certifi-2022.9.14-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "9e94bc017a7298bb59371c640d784281", + "name": "certifi", + "sha256": "4c73775ae0f610a6c366a71e816f95dfaf54caec19786afed76758bbe524b236", + "size": 158454, + "subdir": "linux-64", + "timestamp": 1663615766023, + "version": "2022.9.14" + }, + "certifi-2022.9.14-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "f03b60f5d5c531e4b155a92455d7657a", + "name": "certifi", + "sha256": "30b337d08a78bd3ea52704314f57dd16c37d1a869338be451380c6f9b84728cc", + "size": 158286, + "subdir": "linux-64", + "timestamp": 1663615790034, + "version": "2022.9.14" + }, + "certifi-2022.9.14-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "e125d45829ea1764034620de0020f75b", + "name": "certifi", + "sha256": "296e82d8eea5304c8511b38cbde970b1856d53ad60a28a9cb593ae3af10a295a", + "size": 157612, + "subdir": "linux-64", + "timestamp": 1663615729013, + "version": "2022.9.14" + }, + "certifi-2022.9.14-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "3972b3e18b3cf4b51539f18fee855fe9", + "name": "certifi", + "sha256": "3ef49548d018940afb7a7b4eaa1a2ab45831c00bec1c95c89a66e42377a64d5f", + "size": 158384, + "subdir": "linux-64", + "timestamp": 1663615704117, + "version": "2022.9.14" + }, + "certifi-2022.9.24-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "20f896f4142bbcf3f4e932082c40ee43", + "name": "certifi", + "sha256": "d834718886806ab77a269302957d8e065be70b0f5a5d1a15eda2f8d062d4f643", + "size": 157389, + "subdir": "linux-64", + "timestamp": 1665076714071, + "version": "2022.9.24" + }, + "certifi-2022.9.24-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "3762d5e1e942b1db2b8cf1732fd7ae85", + "name": "certifi", + "sha256": "72029584c307196d4889729f45d6776fbc7756f6487062002ed48083a321ed75", + "size": 158773, + "subdir": "linux-64", + "timestamp": 1669749585103, + "version": "2022.9.24" + }, + "certifi-2022.9.24-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "625c67aeb519192649910174675214eb", + "name": "certifi", + "sha256": "a75cef1003789c6737c66df8f05a6669f64bc997f250204a034daa4a2f4d1b1c", + "size": 157232, + "subdir": "linux-64", + "timestamp": 1665076738459, + "version": "2022.9.24" + }, + "certifi-2022.9.24-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "2c24987d7c70c1c4c3a8c0f0e744b853", + "name": "certifi", + "sha256": "78886fc9afd1e203bdf883a1ca4301d1c91657a730d845ce4833b233da9b51a1", + "size": 157337, + "subdir": "linux-64", + "timestamp": 1665076786045, + "version": "2022.9.24" + }, + "certifi-2022.9.24-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "1e3ca01764ce78e609ab61b8067734eb", + "name": "certifi", + "sha256": "8c0971827087548cfc3370c437059536fc1b76e84ec679da1be15ff7d0b82535", + "size": 157264, + "subdir": "linux-64", + "timestamp": 1665076762069, + "version": "2022.9.24" + }, + "cffi-1.10.0-py27hf1aaaf4_1.conda": { + "build": "py27hf1aaaf4_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c015eaa42c43ca8916088a4e28e91e92", + "name": "cffi", + "sha256": "f2e96189ec59a5df35593ce0fcfdfa4b7339018ee22627f184cad1636cc0357a", + "size": 208562, + "subdir": "linux-64", + "timestamp": 1505691660494, + "version": "1.10.0" + }, + "cffi-1.10.0-py35h796c292_1.conda": { + "build": "py35h796c292_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "60714730362f910404ce967e4de37973", + "name": "cffi", + "sha256": "fdf75fa22f674b760fd75e14d910b47d3ff9288e6386dcb27c4ced9f0176b5a1", + "size": 211338, + "subdir": "linux-64", + "timestamp": 1505691679697, + "version": "1.10.0" + }, + "cffi-1.10.0-py36had8d393_1.conda": { + "build": "py36had8d393_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8e896b2ca34decd22e6ae906d70c6296", + "name": "cffi", + "sha256": "a24592c6ea94441cb45177fbb7d5b739d33fc8acdbbd2b492c2fa2ae891e8490", + "size": 209663, + "subdir": "linux-64", + "timestamp": 1505691698902, + "version": "1.10.0" + }, + "cffi-1.11.2-py27ha7929c6_0.conda": { + "build": "py27ha7929c6_0", + "build_number": 0, + "depends": [ + "libffi", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ee6c7be82e639c0ea8a82cdf241c57d1", + "name": "cffi", + "sha256": "19ec545c4055923ffb8044cf14dc7968aade852fbb37b5fe719f3dbfc7b601bb", + "size": 214090, + "subdir": "linux-64", + "timestamp": 1511926624689, + "version": "1.11.2" + }, + "cffi-1.11.2-py35hc7b2db7_0.conda": { + "build": "py35hc7b2db7_0", + "build_number": 0, + "depends": [ + "libffi", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "cba6c9dece5670ba067aca2cf9269ebc", + "name": "cffi", + "sha256": "8b2f8101d594d996520c62bfedf0b90f29f89a5a35b43fb36dacefceccebfba5", + "size": 217679, + "subdir": "linux-64", + "timestamp": 1511926661365, + "version": "1.11.2" + }, + "cffi-1.11.2-py36h2825082_0.conda": { + "build": "py36h2825082_0", + "build_number": 0, + "depends": [ + "libffi", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b59fedaab3598345bddb802070717c62", + "name": "cffi", + "sha256": "9253f2750ddb238c690ff3c120b72a197a49d78d77f3371eecbc5814812f4142", + "size": 216047, + "subdir": "linux-64", + "timestamp": 1511926623315, + "version": "1.11.2" + }, + "cffi-1.11.4-py27h9745a5d_0.conda": { + "build": "py27h9745a5d_0", + "build_number": 0, + "depends": [ + "libffi", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b8cda92c815fb512a7e4a88903c96533", + "name": "cffi", + "sha256": "67c6b645cd971930356009ca4b50b2d141ef818cc78560f6ab078d6707b86547", + "size": 214022, + "subdir": "linux-64", + "timestamp": 1516376437583, + "version": "1.11.4" + }, + "cffi-1.11.4-py35h9745a5d_0.conda": { + "build": "py35h9745a5d_0", + "build_number": 0, + "depends": [ + "libffi", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "350b7a2b98edf805e92dd9ae786c7a67", + "name": "cffi", + "sha256": "6387de1d6d184995ada956696a7bbcf64a1d939b73bc2e478059ce227906316f", + "size": 218743, + "subdir": "linux-64", + "timestamp": 1516376731232, + "version": "1.11.4" + }, + "cffi-1.11.4-py36h9745a5d_0.conda": { + "build": "py36h9745a5d_0", + "build_number": 0, + "depends": [ + "libffi", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "71955c4bda88b2adbef2f54b50abbede", + "name": "cffi", + "sha256": "d247ff8abc8e749eccf08940b37127fd6bd1451555615905a989d301c1190d5d", + "size": 216157, + "subdir": "linux-64", + "timestamp": 1516376729727, + "version": "1.11.4" + }, + "cffi-1.11.5-py27h9745a5d_0.conda": { + "build": "py27h9745a5d_0", + "build_number": 0, + "depends": [ + "libffi", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "56b869b52c7b8d500e20b9cb9220a639", + "name": "cffi", + "sha256": "02fc7b0ac76b80ed2b5017706d93784aa95876902172ae68264daa386a569f0a", + "size": 214399, + "subdir": "linux-64", + "timestamp": 1520360926669, + "version": "1.11.5" + }, + "cffi-1.11.5-py27he75722e_1.conda": { + "build": "py27he75722e_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "005ac260f73640b5064af902739544b2", + "name": "cffi", + "sha256": "26362353f37c6214b183a301cac8bc17f74b5eef86355d384d7451efdb7df7b9", + "size": 214501, + "subdir": "linux-64", + "timestamp": 1534345160165, + "version": "1.11.5" + }, + "cffi-1.11.5-py35h9745a5d_0.conda": { + "build": "py35h9745a5d_0", + "build_number": 0, + "depends": [ + "libffi", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "3c4304798e510bedd1154360edb6824a", + "name": "cffi", + "sha256": "682abc539f3eaf2aa7e3149be80606df1d1d2c36b38b05ead300670f2d38bf67", + "size": 219300, + "subdir": "linux-64", + "timestamp": 1520360926837, + "version": "1.11.5" + }, + "cffi-1.11.5-py35he75722e_1.conda": { + "build": "py35he75722e_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "b65caaafc7e5a23114490aae98f0d184", + "name": "cffi", + "sha256": "9ff80ea6dd9c4c6c6a8e14246ff3976c3291b49201197cde5041952487a8bcf5", + "size": 219286, + "subdir": "linux-64", + "timestamp": 1534345223944, + "version": "1.11.5" + }, + "cffi-1.11.5-py36h9745a5d_0.conda": { + "build": "py36h9745a5d_0", + "build_number": 0, + "depends": [ + "libffi", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "bfcaa0f35a47154e2e5d3889d340ad15", + "name": "cffi", + "sha256": "a4bacba44cf78557a627b09f25fe1a42250d097107fb6b309b8e9d42957905e3", + "size": 216626, + "subdir": "linux-64", + "timestamp": 1520360727295, + "version": "1.11.5" + }, + "cffi-1.11.5-py36he75722e_1.conda": { + "build": "py36he75722e_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "edbb85d87b7da351f192d934b7960c55", + "name": "cffi", + "sha256": "30f213a7a86ebfbc12821b03f37bdb64d70523a81de722e8f4c4f1bbcc76181a", + "size": 216437, + "subdir": "linux-64", + "timestamp": 1534345191589, + "version": "1.11.5" + }, + "cffi-1.11.5-py37h9745a5d_0.conda": { + "build": "py37h9745a5d_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "59cec58ad4c9652685d292bd9c7029ed", + "name": "cffi", + "sha256": "166bd5bb12f752510ae6bff6d9c72603da868e39ce1740c73824bd5598edf2e4", + "size": 217257, + "subdir": "linux-64", + "timestamp": 1530694169135, + "version": "1.11.5" + }, + "cffi-1.11.5-py37he75722e_1.conda": { + "build": "py37he75722e_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "50a3ebf03308cde36afba912da3d9be1", + "name": "cffi", + "sha256": "587a989442ce84d74337721e781e9a5e161ed882575380f65650390173f38a4c", + "size": 216672, + "subdir": "linux-64", + "timestamp": 1534345255936, + "version": "1.11.5" + }, + "cffi-1.12.1-py27h2e261b9_0.conda": { + "build": "py27h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f8a9b33b6d69527702ec1c19bf0fc940", + "name": "cffi", + "sha256": "cbd93e23be1f3a95d24b4d467dea23ffa2732996bf8faffd05da5b709fb5ed27", + "size": 222452, + "subdir": "linux-64", + "timestamp": 1551137423021, + "version": "1.12.1" + }, + "cffi-1.12.1-py36h2e261b9_0.conda": { + "build": "py36h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "fd07852e01504047a20edfd1127539fb", + "name": "cffi", + "sha256": "94d819f304fdbae6d73bfb06de1028584bf88f645deee6c49631d3606fd69f24", + "size": 225271, + "subdir": "linux-64", + "timestamp": 1551137447149, + "version": "1.12.1" + }, + "cffi-1.12.1-py37h2e261b9_0.conda": { + "build": "py37h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c4339022d2fad761e7a43c8f9b088f08", + "name": "cffi", + "sha256": "28ce3bb178323d774672a3b78af5d2dac15192efed84d3287a411302f6bd9155", + "size": 225701, + "subdir": "linux-64", + "timestamp": 1551137419682, + "version": "1.12.1" + }, + "cffi-1.12.2-py27h2e261b9_1.conda": { + "build": "py27h2e261b9_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "80025b6e8415abea6ba27131d1c85d64", + "name": "cffi", + "sha256": "778c8902f6fc7287947e55c2d3850836af9e5c2230da66a5ba2e7cb30e2c0901", + "size": 224934, + "subdir": "linux-64", + "timestamp": 1552319963035, + "version": "1.12.2" + }, + "cffi-1.12.2-py36h2e261b9_1.conda": { + "build": "py36h2e261b9_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b6045c0984a49e247cd89d9af18cfd69", + "name": "cffi", + "sha256": "ef3a3c6eeccf2afa7c463bac57e5b36204be24156aa5d53bca3b151292e24b4f", + "size": 226946, + "subdir": "linux-64", + "timestamp": 1552320022707, + "version": "1.12.2" + }, + "cffi-1.12.2-py37h2e261b9_1.conda": { + "build": "py37h2e261b9_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "23631e8dd65dc7ea617b04e727150342", + "name": "cffi", + "sha256": "305ff155cd4c03d86af475276b57caaca90818a2885e6a73e1e6106f7d3a7d18", + "size": 226286, + "subdir": "linux-64", + "timestamp": 1552319931240, + "version": "1.12.2" + }, + "cffi-1.12.3-py27h2e261b9_0.conda": { + "build": "py27h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "45f5c71a5582cb85aa03fcfa904fdec3", + "name": "cffi", + "sha256": "e1f7eda08de1113308f83b4f3becd89a8d5c5e2bc4e8c3cef0000869845f16dc", + "size": 225568, + "subdir": "linux-64", + "timestamp": 1555948990818, + "version": "1.12.3" + }, + "cffi-1.12.3-py36h2e261b9_0.conda": { + "build": "py36h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e8c3df5c32d21737e3db5557c2be5fa5", + "name": "cffi", + "sha256": "c4848b6e03ddbc2a113bf32464fd9fcd13fe8ebda6df6b91185920c6f8b59728", + "size": 227085, + "subdir": "linux-64", + "timestamp": 1555949007649, + "version": "1.12.3" + }, + "cffi-1.12.3-py37h2e261b9_0.conda": { + "build": "py37h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ee3f28d89adb040015146c05bbd34843", + "name": "cffi", + "sha256": "e87568ce5f77fc797c13a490ef484357f5026e0e59bf7687e16366a0709ff5f7", + "size": 227020, + "subdir": "linux-64", + "timestamp": 1555948976976, + "version": "1.12.3" + }, + "cffi-1.13.0-py27h2e261b9_0.conda": { + "build": "py27h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "af1a545e639ede424b2bd46579806d45", + "name": "cffi", + "sha256": "6f776843eebdc61c20314bcd215d213da8af347b15ad67e53917e6f2dff7b35a", + "size": 226314, + "subdir": "linux-64", + "timestamp": 1571756504209, + "version": "1.13.0" + }, + "cffi-1.13.0-py36h2e261b9_0.conda": { + "build": "py36h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "abbe2aaab7dc23c5ba4f04d873b5279b", + "name": "cffi", + "sha256": "43a2c79c98448efbabae53e16774178efac3099eaea6401db823e55db58bf594", + "size": 228346, + "subdir": "linux-64", + "timestamp": 1571756515633, + "version": "1.13.0" + }, + "cffi-1.13.0-py37h2e261b9_0.conda": { + "build": "py37h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d1c159252ec6ce23d097a6a85b60585f", + "name": "cffi", + "sha256": "ff874456bb38afd036948882152a31e1e2002886d857906677d9f5a0d8c90f56", + "size": 228501, + "subdir": "linux-64", + "timestamp": 1571756504978, + "version": "1.13.0" + }, + "cffi-1.13.1-py27h2e261b9_0.conda": { + "build": "py27h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "466d9b4df21a3b114386d411f2c3ac50", + "name": "cffi", + "sha256": "166a1bec666db087378ae9157979339c906d595ed842ee27eb1c110628f2c93e", + "size": 226634, + "subdir": "linux-64", + "timestamp": 1572455338276, + "version": "1.13.1" + }, + "cffi-1.13.1-py36h2e261b9_0.conda": { + "build": "py36h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3dcff727ac2c580a3edcd6207edd8862", + "name": "cffi", + "sha256": "e345a3cdbb2c8b3a367e8ded166c4f13970cb00fa5ca1732b63cf0c74f04f4d2", + "size": 228764, + "subdir": "linux-64", + "timestamp": 1572455370751, + "version": "1.13.1" + }, + "cffi-1.13.1-py37h2e261b9_0.conda": { + "build": "py37h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f51c6a7825b9d209c5e52a3534afac69", + "name": "cffi", + "sha256": "991c54db57e34955fcdd7bf85908bb2f78481e6902a6c52568b84f44450be982", + "size": 229030, + "subdir": "linux-64", + "timestamp": 1572455357772, + "version": "1.13.1" + }, + "cffi-1.13.1-py38h2e261b9_0.conda": { + "build": "py38h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "e414e517bd2b2a13d706798a2f57ca98", + "name": "cffi", + "sha256": "0f3b30de58e37d1bf1366394599d9074c4e837a2879e04d0e8ba6dbfb21ec0b0", + "size": 235095, + "subdir": "linux-64", + "timestamp": 1573738352852, + "version": "1.13.1" + }, + "cffi-1.13.2-py27h2e261b9_0.conda": { + "build": "py27h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "3177eeb0224d671cd9c6bdec08839a42", + "name": "cffi", + "sha256": "497b7ad38e82d199de59d6b7a37171c4c987ee75f63daf7f09ba02683bb43ad2", + "size": 226934, + "subdir": "linux-64", + "timestamp": 1573833169634, + "version": "1.13.2" + }, + "cffi-1.13.2-py36h2e261b9_0.conda": { + "build": "py36h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b93ce447325e7b26f8eac2ff12e5a1e5", + "name": "cffi", + "sha256": "6ff5777426fb9fe9348c5d91a2abc1d44b03ddcd77c244b2fd6cdafd231df9fa", + "size": 229083, + "subdir": "linux-64", + "timestamp": 1573833198359, + "version": "1.13.2" + }, + "cffi-1.13.2-py37h2e261b9_0.conda": { + "build": "py37h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "dc539bddbef56863184e7dd4e4c4d5e7", + "name": "cffi", + "sha256": "87531249fb36abfbef24372781a302a9b4d585be2f6cff106ff2d7519032251e", + "size": 229217, + "subdir": "linux-64", + "timestamp": 1573833173761, + "version": "1.13.2" + }, + "cffi-1.13.2-py38h2e261b9_0.conda": { + "build": "py38h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "e7ba4649bd21f82630fd432e6a24994c", + "name": "cffi", + "sha256": "167a9fee61fe0c8bd69fd6ca64939d3e82d58e696ddc4eeb18a279fe153d47dc", + "size": 238487, + "subdir": "linux-64", + "timestamp": 1573833219570, + "version": "1.13.2" + }, + "cffi-1.14.0-py27he30daa8_1.conda": { + "build": "py27he30daa8_1", + "build_number": 1, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e063da13df7c8e1d33d811ff7a589e99", + "name": "cffi", + "sha256": "f16b48a9da6cb7237ffae36db2a7460bff3b6f6b46f38ef413591ec1035a603b", + "size": 226685, + "subdir": "linux-64", + "timestamp": 1589396238714, + "version": "1.14.0" + }, + "cffi-1.14.0-py36h2e261b9_0.conda": { + "build": "py36h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "aa064a2e50d87af2e8352d5aea4fb194", + "name": "cffi", + "sha256": "c6020c95c89a89d9ee48e21916402a048852b56b9301c33488a674a49ad436c2", + "size": 228691, + "subdir": "linux-64", + "timestamp": 1581351798636, + "version": "1.14.0" + }, + "cffi-1.14.0-py36he30daa8_1.conda": { + "build": "py36he30daa8_1", + "build_number": 1, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "475852d32b3d957431b3304cb6944a07", + "name": "cffi", + "sha256": "6cdc6bd2012f1f72876eb7f7b75cb408cf02b70948abeb214a873478d7c2a8bb", + "size": 229926, + "subdir": "linux-64", + "timestamp": 1588943529697, + "version": "1.14.0" + }, + "cffi-1.14.0-py37h2e261b9_0.conda": { + "build": "py37h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "994d327ea637ccc243b025a6c989098d", + "name": "cffi", + "sha256": "224f48cc34863c59504143cf4b929a9be8d4712d45028fb8ec21d0ebc2469d67", + "size": 228946, + "subdir": "linux-64", + "timestamp": 1581351687214, + "version": "1.14.0" + }, + "cffi-1.14.0-py37he30daa8_1.conda": { + "build": "py37he30daa8_1", + "build_number": 1, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ac0ea972105896592e07a81347fbcfe4", + "name": "cffi", + "sha256": "455660b95c8d87a67e0ee44b1bf80ae1eb6da3b11ded3324eb0b185554cf5ea4", + "size": 229334, + "subdir": "linux-64", + "timestamp": 1588897787322, + "version": "1.14.0" + }, + "cffi-1.14.0-py38h2e261b9_0.conda": { + "build": "py38h2e261b9_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "d74ec377e649b6ea1f47d8c68859419c", + "name": "cffi", + "sha256": "515ef483ebfc700e9fbf4d504648b7684ee0a72d6ad1e3aff5f7885f0c5b65e4", + "size": 231035, + "subdir": "linux-64", + "timestamp": 1581351818767, + "version": "1.14.0" + }, + "cffi-1.14.0-py38he30daa8_1.conda": { + "build": "py38he30daa8_1", + "build_number": 1, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "73626b486fc179af0ebfed6e7f7027d5", + "name": "cffi", + "sha256": "583bc084dbcfa7803e2b7c9bbed82957215210f0dd929cd119ed08caceaf1790", + "size": 230348, + "subdir": "linux-64", + "timestamp": 1588897929886, + "version": "1.14.0" + }, + "cffi-1.14.1-py36he30daa8_0.conda": { + "build": "py36he30daa8_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6ba30d8caf2a6972d6c5cda0d0526966", + "name": "cffi", + "sha256": "47b940ec6d9dd6080fbe87cca7f7cfe069e089bf39f22cff077b06ca875c050d", + "size": 230785, + "subdir": "linux-64", + "timestamp": 1596809908559, + "version": "1.14.1" + }, + "cffi-1.14.1-py37he30daa8_0.conda": { + "build": "py37he30daa8_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1ecae8a1a0a71f2510f76b7504719571", + "name": "cffi", + "sha256": "3447186198a58940f7c70c61ede458be7c6591523560b4f52053613a7bfb2329", + "size": 231906, + "subdir": "linux-64", + "timestamp": 1596809895216, + "version": "1.14.1" + }, + "cffi-1.14.1-py38he30daa8_0.conda": { + "build": "py38he30daa8_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "539d2cffabda669208852ca56b08e6c9", + "name": "cffi", + "sha256": "5b7dfa076f6624265865ac388b9f989a890381c63d4de2d02985a40ad5175106", + "size": 233915, + "subdir": "linux-64", + "timestamp": 1596809891164, + "version": "1.14.1" + }, + "cffi-1.14.2-py36he30daa8_0.conda": { + "build": "py36he30daa8_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6486df07709aff3637dc6bc38782d222", + "name": "cffi", + "sha256": "6d5ebf9e882d3a24a60616581bf9049d4ba2c396d85fbe24f60f7b7b71345566", + "size": 232004, + "subdir": "linux-64", + "timestamp": 1598370838618, + "version": "1.14.2" + }, + "cffi-1.14.2-py37he30daa8_0.conda": { + "build": "py37he30daa8_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d45cdd54cc70d5479355a6f17dfbf836", + "name": "cffi", + "sha256": "46c8becdca94914456c94c509b1b04a689f316d11f5a7ba3a5f125fe15c88b3e", + "size": 229765, + "subdir": "linux-64", + "timestamp": 1598370857899, + "version": "1.14.2" + }, + "cffi-1.14.2-py38he30daa8_0.conda": { + "build": "py38he30daa8_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "88a65218813428797b75c6613c5a88a6", + "name": "cffi", + "sha256": "04093fb8fd34b6e7d7a0986517d4ae1fd7b17827a406ac49d77b337be56d4024", + "size": 232459, + "subdir": "linux-64", + "timestamp": 1598370811016, + "version": "1.14.2" + }, + "cffi-1.14.3-py36h261ae71_2.conda": { + "build": "py36h261ae71_2", + "build_number": 2, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "927b48e5083da00dcc5637a956eeb29b", + "name": "cffi", + "sha256": "6247945e15d0725082b5ebeb2421d09f0c75fd95c8a0ef1389ae2df600c916df", + "size": 232813, + "subdir": "linux-64", + "timestamp": 1605538130011, + "version": "1.14.3" + }, + "cffi-1.14.3-py36he30daa8_0.conda": { + "build": "py36he30daa8_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e4e0f998219a7e8952f56cb78935784c", + "name": "cffi", + "sha256": "0849a965ea64129d8c5d5a09fabbcf78cf62596503f3b1d38c10203e1bfd2c99", + "size": 227600, + "subdir": "linux-64", + "timestamp": 1600699204564, + "version": "1.14.3" + }, + "cffi-1.14.3-py37h261ae71_2.conda": { + "build": "py37h261ae71_2", + "build_number": 2, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "11b647d6f219d4219caebf45e331e237", + "name": "cffi", + "sha256": "808682c254bd073914731a534e367e83767ec52e78eff639678577c4f56f7c98", + "size": 233833, + "subdir": "linux-64", + "timestamp": 1605538083720, + "version": "1.14.3" + }, + "cffi-1.14.3-py37he30daa8_0.conda": { + "build": "py37he30daa8_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6c2f8e0193e7a98a244b00d4544a1fe2", + "name": "cffi", + "sha256": "93627d8d89e0c2aab2fcc087bf9b28f2ebcab9073de4d786a48298ca375d6416", + "size": 227911, + "subdir": "linux-64", + "timestamp": 1600699221512, + "version": "1.14.3" + }, + "cffi-1.14.3-py38h261ae71_2.conda": { + "build": "py38h261ae71_2", + "build_number": 2, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "2bb2d51a41b9eb489354178a17c79a98", + "name": "cffi", + "sha256": "4bbacbde1d5c3d7895c1cfc281cfe0ff2f4f8881d20176caedfffe12b05f1ba8", + "size": 235208, + "subdir": "linux-64", + "timestamp": 1605538109665, + "version": "1.14.3" + }, + "cffi-1.14.3-py38he30daa8_0.conda": { + "build": "py38he30daa8_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "2d3cef6f2210d252273024392fff7fcf", + "name": "cffi", + "sha256": "7e25e57ed8c5e0e647949f06f8639116f1f6ec13daa80166da05e8906249ca71", + "size": 230901, + "subdir": "linux-64", + "timestamp": 1600699230784, + "version": "1.14.3" + }, + "cffi-1.14.3-py39h261ae71_2.conda": { + "build": "py39h261ae71_2", + "build_number": 2, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "1ca3fe9641dd77bfa6065500e9d58e5e", + "name": "cffi", + "sha256": "6d590f9becf816fd738143de9c516e61af95eb3c1b2a80303324f647198b5288", + "size": 235545, + "subdir": "linux-64", + "timestamp": 1605538099397, + "version": "1.14.3" + }, + "cffi-1.14.4-py36h261ae71_0.conda": { + "build": "py36h261ae71_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6ba21172094ec9a86fa81dbbc5b9e905", + "name": "cffi", + "sha256": "54fd14124871061dd1a70aa40f1d8114e8e3706ffe5d9f3eb37af693299bf5c9", + "size": 228146, + "subdir": "linux-64", + "timestamp": 1606255140696, + "version": "1.14.4" + }, + "cffi-1.14.4-py37h261ae71_0.conda": { + "build": "py37h261ae71_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "0ecda601cfb52812a385acc4e2ccab44", + "name": "cffi", + "sha256": "9cfa54c7d54822d74bf98c6a2b595f4e2c4854148d8494516150d4d1562c4ece", + "size": 229036, + "subdir": "linux-64", + "timestamp": 1606255140718, + "version": "1.14.4" + }, + "cffi-1.14.4-py38h261ae71_0.conda": { + "build": "py38h261ae71_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "6f72f71644220f8dc174e5df5a22ed65", + "name": "cffi", + "sha256": "244a7a00f14bc3d11b5866dec68e7009371136c16525118ec640d664d0d595b5", + "size": 231451, + "subdir": "linux-64", + "timestamp": 1606255128630, + "version": "1.14.4" + }, + "cffi-1.14.4-py39h261ae71_0.conda": { + "build": "py39h261ae71_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "be5494da94dbe5e20bfea402e93eff03", + "name": "cffi", + "sha256": "939dcc6a4e4cc4cd22393f639360a71b3be41a74f437823f08bc8fbafa3ff82b", + "size": 231051, + "subdir": "linux-64", + "timestamp": 1606255169067, + "version": "1.14.4" + }, + "cffi-1.14.5-py36h261ae71_0.conda": { + "build": "py36h261ae71_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "502163104ee0b625ef6cb429a1ecf6ed", + "name": "cffi", + "sha256": "cd53ddc8c23848928434de6e61a92d7904d6d1c2f457006982824049e65edae6", + "size": 227083, + "subdir": "linux-64", + "timestamp": 1613246487719, + "version": "1.14.5" + }, + "cffi-1.14.5-py37h261ae71_0.conda": { + "build": "py37h261ae71_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d546edab3216969bd45ad16c77d30aa7", + "name": "cffi", + "sha256": "582ae8340b9b3d316494042cab1def4368a8d62441b8e7c6ada2b1e204b283ac", + "size": 228990, + "subdir": "linux-64", + "timestamp": 1613246984885, + "version": "1.14.5" + }, + "cffi-1.14.5-py38h261ae71_0.conda": { + "build": "py38h261ae71_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "85022d8ccedf5b740fb631aefd93c011", + "name": "cffi", + "sha256": "deb486c69025b979ea813bfc8e412ba19b2dc1efe5ecffaa5d87ac3c83928704", + "size": 229394, + "subdir": "linux-64", + "timestamp": 1613246996334, + "version": "1.14.5" + }, + "cffi-1.14.5-py39h261ae71_0.conda": { + "build": "py39h261ae71_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "pycparser", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "8b371e85362f192614184ef66c9e05ae", + "name": "cffi", + "sha256": "ea3160a1537296a9fa1940279640486a22705a96d598002313cced8da7842c26", + "size": 231892, + "subdir": "linux-64", + "timestamp": 1613246999673, + "version": "1.14.5" + }, + "cffi-1.14.6-py36h400218f_0.conda": { + "build": "py36h400218f_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "07e7e35d67eb675c6b7dadc56013d93a", + "name": "cffi", + "sha256": "0c5fe9c14f41b86b5d7e54e0e9fa5f9a4b2702bd0f39ca1faa64fd09ca162c5a", + "size": 225651, + "subdir": "linux-64", + "timestamp": 1625814764180, + "version": "1.14.6" + }, + "cffi-1.14.6-py37h400218f_0.conda": { + "build": "py37h400218f_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a808bcc13e7750f3c22e4806050fc2b3", + "name": "cffi", + "sha256": "0ee337dae01cb7d7d7394e3e1e4c43d93eeb91ff604b7afac2cdcf7bee533991", + "size": 227887, + "subdir": "linux-64", + "timestamp": 1625814747956, + "version": "1.14.6" + }, + "cffi-1.14.6-py38h400218f_0.conda": { + "build": "py38h400218f_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "cd530b3739b7bfeac4b260c8c72fbe72", + "name": "cffi", + "sha256": "d753cedb0c6052559bcd898a52016f2cba0cd472325c6751867aa9cddc9024cc", + "size": 229582, + "subdir": "linux-64", + "timestamp": 1625807894199, + "version": "1.14.6" + }, + "cffi-1.14.6-py39h400218f_0.conda": { + "build": "py39h400218f_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "fca4518c1c2e92c1d4656193fc3fe419", + "name": "cffi", + "sha256": "38d3e37841f39758dd36f196296d689110449a99ef287591ccf97ccc4247e8fc", + "size": 230164, + "subdir": "linux-64", + "timestamp": 1625814763237, + "version": "1.14.6" + }, + "cffi-1.15.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "684ceee8063909d905dc81fb9bae9328", + "name": "cffi", + "sha256": "d768d8f1d8d1c965f5e7b6c7e10ed96f9daaa2eba238be1f7bb401555f35c883", + "size": 369112, + "subdir": "linux-64", + "timestamp": 1640788918553, + "version": "1.15.0" + }, + "cffi-1.15.0-py310hd667e15_1.conda": { + "build": "py310hd667e15_1", + "build_number": 1, + "depends": [ + "libffi >=3.3", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5999c18ac0a4d99bd6d8a828da52b95e", + "name": "cffi", + "sha256": "6b35cbf870dcaee9eb775c9a6caf69416556a8ef3421fb70ef80ab9e04d0ef92", + "size": 372043, + "subdir": "linux-64", + "timestamp": 1642753394042, + "version": "1.15.0" + }, + "cffi-1.15.0-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51565e32727a652680ea6368bc18f8e5", + "name": "cffi", + "sha256": "9acd9bbd4b14ad6c9d40dc2b0197b1b2acfb6102ecd5f99b134cabbbafaadccc", + "size": 227641, + "subdir": "linux-64", + "timestamp": 1636541970065, + "version": "1.15.0" + }, + "cffi-1.15.0-py37hd667e15_1.conda": { + "build": "py37hd667e15_1", + "build_number": 1, + "depends": [ + "libffi >=3.3", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "19b50f62f8106a0e7f38cb8c5904d283", + "name": "cffi", + "sha256": "3caf7b5a54a237c98c147f91da7411885f954a0034504b0369209795b0c4e86d", + "size": 227765, + "subdir": "linux-64", + "timestamp": 1642701175698, + "version": "1.15.0" + }, + "cffi-1.15.0-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5afdcbf42eee63293e289af6c3d97923", + "name": "cffi", + "sha256": "8c596548d97b1b88dc3e4377fceee3bf78fcebd9e1929966d9aa5a97d31e4d43", + "size": 230972, + "subdir": "linux-64", + "timestamp": 1636541976524, + "version": "1.15.0" + }, + "cffi-1.15.0-py38hd667e15_1.conda": { + "build": "py38hd667e15_1", + "build_number": 1, + "depends": [ + "libffi >=3.3", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b12fe728b28de7b8851af1eb1ba1d38", + "name": "cffi", + "sha256": "ec03d92948951097c46e89e378b082035dab7963fefb71a874f50eecfd7a907f", + "size": 229604, + "subdir": "linux-64", + "timestamp": 1642701149006, + "version": "1.15.0" + }, + "cffi-1.15.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80f9c2c5bb444bcc73675b3abbfff5de", + "name": "cffi", + "sha256": "15240344e5124b4b68fe23b22f38ad22eb05d3239d51b42afefdfbaa7502b0a9", + "size": 228035, + "subdir": "linux-64", + "timestamp": 1636529700462, + "version": "1.15.0" + }, + "cffi-1.15.0-py39hd667e15_1.conda": { + "build": "py39hd667e15_1", + "build_number": 1, + "depends": [ + "libffi >=3.3", + "libgcc-ng >=7.5.0", + "pycparser", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ef8e0071a3c72670f3ee8e3a5cd2a6b", + "name": "cffi", + "sha256": "7a8e49df026df61318ee5c280416fd7835de89e089e56321c7a780ac23ca6ad8", + "size": 230028, + "subdir": "linux-64", + "timestamp": 1642701209740, + "version": "1.15.0" + }, + "cffi-1.15.1-py310h5eee18b_2.conda": { + "build": "py310h5eee18b_2", + "build_number": 2, + "depends": [ + "libffi >=3.4,<3.5", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "274c030ae29c47749ad25500bac0c857", + "name": "cffi", + "sha256": "f9766435f8ad847a4bd90582b2a0df9d5ddfa31d41ec586cae725a841f541947", + "size": 239699, + "subdir": "linux-64", + "timestamp": 1669355805636, + "version": "1.15.1" + }, + "cffi-1.15.1-py310h5eee18b_3.conda": { + "build": "py310h5eee18b_3", + "build_number": 3, + "depends": [ + "libffi >=3.4,<3.5", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d65505a7028c5cb1d6a078fa688be2be", + "name": "cffi", + "sha256": "6439ba585aff2f07eb246cb3dfcb957ff51f624891c38130656f0b353694b8f0", + "size": 248975, + "subdir": "linux-64", + "timestamp": 1670423250002, + "version": "1.15.1" + }, + "cffi-1.15.1-py310h74dc2b5_0.conda": { + "build": "py310h74dc2b5_0", + "build_number": 0, + "depends": [ + "libffi >=3.3", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c47907709f029aaadcbc15abb1c28e41", + "name": "cffi", + "sha256": "746b21967a3fb8fd16c1ab7c40b44774ff9415ceb17815789cc00a3a9d04c178", + "size": 416323, + "subdir": "linux-64", + "timestamp": 1659598699171, + "version": "1.15.1" + }, + "cffi-1.15.1-py311h5eee18b_3.conda": { + "build": "py311h5eee18b_3", + "build_number": 3, + "depends": [ + "libffi >=3.4,<3.5", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "82ea1fb8934a7e4b93298cdee7d7628d", + "name": "cffi", + "sha256": "c9fd0f0b32671b3ddc021d6f91fe7a12cdc11771a3f5d4fbb25f66d342eaed00", + "size": 290022, + "subdir": "linux-64", + "timestamp": 1676822552354, + "version": "1.15.1" + }, + "cffi-1.15.1-py37h5eee18b_2.conda": { + "build": "py37h5eee18b_2", + "build_number": 2, + "depends": [ + "libffi >=3.4,<3.5", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "592b8e0a8ea94ca7333b804934979daa", + "name": "cffi", + "sha256": "840c37ab19d97c914ac8269e6c82129cbeca959289397e47add0f6d25d3261fe", + "size": 237585, + "subdir": "linux-64", + "timestamp": 1669355800053, + "version": "1.15.1" + }, + "cffi-1.15.1-py37h5eee18b_3.conda": { + "build": "py37h5eee18b_3", + "build_number": 3, + "depends": [ + "libffi >=3.4,<3.5", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f35174ca1e83f299e04eadb80f6ab7f", + "name": "cffi", + "sha256": "e6586c334ff8202d6174513193bea45df04a4b44468ad0997971d65f9be75edb", + "size": 245331, + "subdir": "linux-64", + "timestamp": 1670423312176, + "version": "1.15.1" + }, + "cffi-1.15.1-py37h74dc2b5_0.conda": { + "build": "py37h74dc2b5_0", + "build_number": 0, + "depends": [ + "libffi >=3.3", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "78302b1d5451ae1ed72322ee8aa31b08", + "name": "cffi", + "sha256": "9b8a540ae386c4bbe40e5cc326c8144ab9c03f319456c755d06086c60485e0fc", + "size": 232667, + "subdir": "linux-64", + "timestamp": 1659598775030, + "version": "1.15.1" + }, + "cffi-1.15.1-py38h5eee18b_2.conda": { + "build": "py38h5eee18b_2", + "build_number": 2, + "depends": [ + "libffi >=3.4,<3.5", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9944df4e263642d5ba4a65f791b406e", + "name": "cffi", + "sha256": "5d40033ce3df68158aa769e4fdb2f35cb96ca870f733dc2c90d9d30788a51529", + "size": 238789, + "subdir": "linux-64", + "timestamp": 1669355800711, + "version": "1.15.1" + }, + "cffi-1.15.1-py38h5eee18b_3.conda": { + "build": "py38h5eee18b_3", + "build_number": 3, + "depends": [ + "libffi >=3.4,<3.5", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebf03031554d834c5aafdbed9be24f7f", + "name": "cffi", + "sha256": "14384e843dfafa3c5ba26f625a2defe7dd7268f33c0172a06e52e3cf48c29b9c", + "size": 247275, + "subdir": "linux-64", + "timestamp": 1670423342840, + "version": "1.15.1" + }, + "cffi-1.15.1-py38h74dc2b5_0.conda": { + "build": "py38h74dc2b5_0", + "build_number": 0, + "depends": [ + "libffi >=3.3", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca2d78b41be0525b8d328c078dfadfb9", + "name": "cffi", + "sha256": "a127faa91002decce4570efa514637fa95468c1348f90780cc7743b637aa5cdb", + "size": 233961, + "subdir": "linux-64", + "timestamp": 1659598724314, + "version": "1.15.1" + }, + "cffi-1.15.1-py39h5eee18b_2.conda": { + "build": "py39h5eee18b_2", + "build_number": 2, + "depends": [ + "libffi >=3.4,<3.5", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8735d8d77ab90e478eeb832765431110", + "name": "cffi", + "sha256": "d32631d7cf31a18df915d5f998f1254c96c5b9d5543be0388afb9b1f1757a5c7", + "size": 237546, + "subdir": "linux-64", + "timestamp": 1669355794965, + "version": "1.15.1" + }, + "cffi-1.15.1-py39h5eee18b_3.conda": { + "build": "py39h5eee18b_3", + "build_number": 3, + "depends": [ + "libffi >=3.4,<3.5", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "89bf9aee92a2429222630337bec3d73f", + "name": "cffi", + "sha256": "615ee3d5ace767c7a5dee570b9a5afa21ce3125f3ff0c77af906f8c39f6340c2", + "size": 247423, + "subdir": "linux-64", + "timestamp": 1670423281079, + "version": "1.15.1" + }, + "cffi-1.15.1-py39h74dc2b5_0.conda": { + "build": "py39h74dc2b5_0", + "build_number": 0, + "depends": [ + "libffi >=3.3", + "libgcc-ng >=11.2.0", + "pycparser", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebf7649f0c1ef085bd69c785e1ea433a", + "name": "cffi", + "sha256": "e1af66cdeba836d9b2aedf6ccde2d49f42a8183e9f0b8bd653180e6842418705", + "size": 233787, + "subdir": "linux-64", + "timestamp": 1659598749654, + "version": "1.15.1" + }, + "cfgv-3.3.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "079bf96fbe89e5ac1f7691e87c63f7e6", + "name": "cfgv", + "sha256": "7711c2ea375eac9f504dd45048a9c7d93b3a5ab8295ecea561cb118efedd8a5a", + "size": 16221, + "subdir": "linux-64", + "timestamp": 1663174700493, + "version": "3.3.1" + }, + "cfgv-3.3.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1f72596f60b84059238cc78092e083d", + "name": "cfgv", + "sha256": "4e951c73cb59c82fcebfccf453803a770af0a122e72fa7276de6ecfe26d3d5f2", + "size": 19838, + "subdir": "linux-64", + "timestamp": 1676843499073, + "version": "3.3.1" + }, + "cfgv-3.3.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dad8c69ce0faf27c184560ee0c33e8f2", + "name": "cfgv", + "sha256": "38a12f3021ff1704eca6732f06f808e0d800fab2b24a389753dff56986ba0b68", + "size": 15865, + "subdir": "linux-64", + "timestamp": 1663174750093, + "version": "3.3.1" + }, + "cfgv-3.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "911fc222e7666aba662a88288ced15d6", + "name": "cfgv", + "sha256": "c5cf56b608b19ecd16e3d566d7c576c5c565c0a94385ba24585fb8b05a38e141", + "size": 15868, + "subdir": "linux-64", + "timestamp": 1663174724979, + "version": "3.3.1" + }, + "cfgv-3.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e5a60c8ce06d92055dddd4b03b8f38e8", + "name": "cfgv", + "sha256": "860c66c044f42fa8dc7bc3db3bf64570b2a3a7a34044a48789ff39818a24bba9", + "size": 15932, + "subdir": "linux-64", + "timestamp": 1663174776084, + "version": "3.3.1" + }, + "cfitsio-3.470-h5893167_7.conda": { + "build": "h5893167_7", + "build_number": 7, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Other", + "license_family": "Other", + "md5": "a4d4f7d9d9ee35e6abdd4acb1c14afea", + "name": "cfitsio", + "sha256": "6a125b70e3f1508bf93602323c0cfaa631435f4d9c76c387c8aa397ad2ea29a3", + "size": 852825, + "subdir": "linux-64", + "timestamp": 1655814890848, + "version": "3.470" + }, + "cfitsio-3.470-hb7c8383_2.conda": { + "build": "hb7c8383_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libcurl >=7.65.3,<8.0a0", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "fitsio", + "md5": "a14bea9d751704a520812f226bcb8d7e", + "name": "cfitsio", + "sha256": "b329fecca2474642b5f24e8b559e14e7c6d974a645a937c323f1d62182a18621", + "size": 896950, + "subdir": "linux-64", + "timestamp": 1573142889363, + "version": "3.470" + }, + "cfitsio-3.470-hf0d0db6_5.conda": { + "build": "hf0d0db6_5", + "build_number": 5, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libcurl >=7.69.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "fitsio", + "md5": "84c5013cc078983831d27e5ef3157e80", + "name": "cfitsio", + "sha256": "b9d51d9c8d38a8d97521c8395f1f90e7846948d45c2d8fd85b64a9c9feb0120e", + "size": 852669, + "subdir": "linux-64", + "timestamp": 1591781091219, + "version": "3.470" + }, + "cfitsio-3.470-hf0d0db6_6.conda": { + "build": "hf0d0db6_6", + "build_number": 6, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "fitsio", + "md5": "f590184d85f5ba8564bcfd052c09862d", + "name": "cfitsio", + "sha256": "4d63abb7c67aed8eca1d887433b829c2195911ab4ad492261216dd3fbba6caba", + "size": 833660, + "subdir": "linux-64", + "timestamp": 1601308736676, + "version": "3.470" + }, + "cfn-lint-0.24.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "0c0850ad03402adf9ee5ebf783ad97ad", + "name": "cfn-lint", + "sha256": "0087975fe07ab0f4c9a7a62a837a7fb21ae11a159b8be00422f8b5700c11e1a7", + "size": 400749, + "subdir": "linux-64", + "timestamp": 1588569235808, + "version": "0.24.4" + }, + "cfn-lint-0.24.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "4b9d90bb14b5ca0d07def732e2b705e0", + "name": "cfn-lint", + "sha256": "58cd2e3eb35bef2dc429f92bc64ee6280e0861b28224cee6e28d7a3a3abc70e9", + "size": 400153, + "subdir": "linux-64", + "timestamp": 1588569234018, + "version": "0.24.4" + }, + "cfn-lint-0.24.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "bd9092078aee5af241f80eda50508270", + "name": "cfn-lint", + "sha256": "bff3b61e1d916f72cc6d18806f9b4055cec089d21776000195a3242d435bff40", + "size": 403439, + "subdir": "linux-64", + "timestamp": 1588569234163, + "version": "0.24.4" + }, + "cfn-lint-0.36.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "85ddc5bc7491d1486d7a5093d55f9794", + "name": "cfn-lint", + "sha256": "31ffbd3622d119265451939ae36dcf5d4f8c530320aee5d1f2cd00171c1775e0", + "size": 504153, + "subdir": "linux-64", + "timestamp": 1601051505833, + "version": "0.36.1" + }, + "cfn-lint-0.36.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "14aad7b5967ad6ee9d56d06015170100", + "name": "cfn-lint", + "sha256": "b9b1d8b3ccd396d73077e355606d9af0b9b66b5b5940498470b0b77f0b7d3e05", + "size": 503845, + "subdir": "linux-64", + "timestamp": 1601051552705, + "version": "0.36.1" + }, + "cfn-lint-0.36.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "a50d5ec6a3f5b65108f244d661cebbca", + "name": "cfn-lint", + "sha256": "9c7e7f99d439d00b5b41f20bb6ec6cb6961b946cf5981be9f55dcb0f9a3daf9b", + "size": 501531, + "subdir": "linux-64", + "timestamp": 1601051682504, + "version": "0.36.1" + }, + "cfn-lint-0.37.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "6e4d33ae25f368ecdc1157df4df69677", + "name": "cfn-lint", + "sha256": "a087fb0a90522caba762a0fc47c78f4e7c456d4cd17b5c92257eb49a9e997ba5", + "size": 511409, + "subdir": "linux-64", + "timestamp": 1601488370353, + "version": "0.37.0" + }, + "cfn-lint-0.37.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "1f0cf60501e179e61ec682f8edaac78c", + "name": "cfn-lint", + "sha256": "421eb705e28c1dc756684b32ab08748a319d187499e6ff5b25bfb0e8d959cfe8", + "size": 502984, + "subdir": "linux-64", + "timestamp": 1601488342170, + "version": "0.37.0" + }, + "cfn-lint-0.37.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "a95bd0723a5d5e182ba6482d4fdaf652", + "name": "cfn-lint", + "sha256": "f7cf9b188c626a571efe7808ab4e112f36aabbfc8119dffc5d661dc312a996ad", + "size": 510576, + "subdir": "linux-64", + "timestamp": 1601488369194, + "version": "0.37.0" + }, + "cfn-lint-0.37.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "7097e73959a4821d7099ad348292db91", + "name": "cfn-lint", + "sha256": "fd685b7a37371544435efc7b56e88b610393843787755b9acf19f22ef8b04d0c", + "size": 511149, + "subdir": "linux-64", + "timestamp": 1602083228792, + "version": "0.37.1" + }, + "cfn-lint-0.37.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "ffc16506e57de47ed930c261ef80260a", + "name": "cfn-lint", + "sha256": "7aaef407696fa73022083c5b6e2fcbf7c4fa19f98734fdb7842ec1d0cec834e3", + "size": 504810, + "subdir": "linux-64", + "timestamp": 1602083275364, + "version": "0.37.1" + }, + "cfn-lint-0.37.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "bdaa71cd7e29671adfe5cff0d0abbc00", + "name": "cfn-lint", + "sha256": "ec54bd18a0854c1c92d538008d68c38280c10e6723d22d8111deb97020e28621", + "size": 505107, + "subdir": "linux-64", + "timestamp": 1602083250608, + "version": "0.37.1" + }, + "cfn-lint-0.38.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "21000591850ea22292f919bbaeff17c8", + "name": "cfn-lint", + "sha256": "6a2b4cd3ef8a69b23244f523166e3ae83b3ffbe2c4c5f41b246981b631938239", + "size": 505210, + "subdir": "linux-64", + "timestamp": 1602622948523, + "version": "0.38.0" + }, + "cfn-lint-0.38.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "a395757f9a9c389460e3ef207abea92e", + "name": "cfn-lint", + "sha256": "6e256c377a7f1eaa98742a71c9daaddaa815d6c8b7dbfec96aacc21f58848edb", + "size": 503465, + "subdir": "linux-64", + "timestamp": 1602622975600, + "version": "0.38.0" + }, + "cfn-lint-0.38.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "9914859ef2646f8db12fa4f9187d5b87", + "name": "cfn-lint", + "sha256": "4c5a87c75e08c940ab16f80ca9812dc37905c1a8d3775266c67ac4fc887d5d22", + "size": 504720, + "subdir": "linux-64", + "timestamp": 1602622977759, + "version": "0.38.0" + }, + "cfn-lint-0.39.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "32a64aaa581c2b45a15fd4183c1db492", + "name": "cfn-lint", + "sha256": "fb939e2cede8e4127cb2009d34d8a9a71dfab264400e9382cee32a9511e8f72f", + "size": 509718, + "subdir": "linux-64", + "timestamp": 1603896284961, + "version": "0.39.0" + }, + "cfn-lint-0.39.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "76be000c1aae0b58f484691757feb546", + "name": "cfn-lint", + "sha256": "2d8907c0ebe31235894f64755fd3e72bfc51d6491fea420f3d5d942ebdc35abf", + "size": 514509, + "subdir": "linux-64", + "timestamp": 1603896258132, + "version": "0.39.0" + }, + "cfn-lint-0.39.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "c6c3bd07bc8f3a8e36afdd6c3de03276", + "name": "cfn-lint", + "sha256": "a6be801d15132d7ef2aa1f91f1b426bd6eb87b8605a45b63fe8bd4c00f718083", + "size": 510196, + "subdir": "linux-64", + "timestamp": 1603896255343, + "version": "0.39.0" + }, + "cfn-lint-0.40.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "270634daac4f1691338ff2f111571a6b", + "name": "cfn-lint", + "sha256": "17e1d59b780fef9eda774dd207c3fdf249a3967b88f3e668d208066fc253c701", + "size": 512646, + "subdir": "linux-64", + "timestamp": 1605061847620, + "version": "0.40.0" + }, + "cfn-lint-0.40.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "1abec95ee175eca08b973d5c110e8e0e", + "name": "cfn-lint", + "sha256": "acabd61a18028427fcdf6925c099030ed63ce477cf587bcc939e96eba73c5437", + "size": 519313, + "subdir": "linux-64", + "timestamp": 1605061835301, + "version": "0.40.0" + }, + "cfn-lint-0.40.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "a1c5ac2ec2711af3b8103a2fcf7a59c6", + "name": "cfn-lint", + "sha256": "6a0403d0b261f9305e69139edf82812a09023101432325e52fc5b7c750b6ce22", + "size": 519620, + "subdir": "linux-64", + "timestamp": 1605061850358, + "version": "0.40.0" + }, + "cfn-lint-0.41.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "6601cf2a4410421fd8bc02593fcfd41c", + "name": "cfn-lint", + "sha256": "d69cae2d3691e409568e427cb0c983b1021be753191a3d567d7c6a6de7f1f9e3", + "size": 510186, + "subdir": "linux-64", + "timestamp": 1605995728363, + "version": "0.41.0" + }, + "cfn-lint-0.41.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "553a9260cd770423439a2a2eb70757f1", + "name": "cfn-lint", + "sha256": "a4f4a2d8ff384fe9040595aadf44eb3906d6c3249912d624841beafa5d707340", + "size": 511532, + "subdir": "linux-64", + "timestamp": 1605995744220, + "version": "0.41.0" + }, + "cfn-lint-0.41.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "48bbc068eb67dfa63af5a48f9173bfb3", + "name": "cfn-lint", + "sha256": "1d902a236728f4f539ce438cd3fd85c0b89fb8f32c7ce51041d889dbd79fcb50", + "size": 509405, + "subdir": "linux-64", + "timestamp": 1605995763162, + "version": "0.41.0" + }, + "cfn-lint-0.42.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "7d0b0c3b42d42339db7060b72eacf8cb", + "name": "cfn-lint", + "sha256": "ddae900b88c6dab28b8bf10168b6802e851fbda9aa47cd9d0d3ce9f780588965", + "size": 523376, + "subdir": "linux-64", + "timestamp": 1606255233257, + "version": "0.42.0" + }, + "cfn-lint-0.42.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "2986ff122a89f5c88cadbc8e1a48b61a", + "name": "cfn-lint", + "sha256": "f6847a41db139c4a489c07eccf3e884c3729bb3833221882e7fa548cdf11d7ce", + "size": 520222, + "subdir": "linux-64", + "timestamp": 1606255199047, + "version": "0.42.0" + }, + "cfn-lint-0.42.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "e1395d4b2551018980d7bbfc949a002e", + "name": "cfn-lint", + "sha256": "31dec95a72ea3e5feec97850c8b6c41f5991b137c6549b3f89bacab0b1a66bbf", + "size": 529371, + "subdir": "linux-64", + "timestamp": 1606255202435, + "version": "0.42.0" + }, + "cfn-lint-0.43.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "fef8f4201e85a5526ee227289b47628f", + "name": "cfn-lint", + "sha256": "d3d2945959e2062c00ac8e4f6ca35c82fa712e3d6aaf416cc98b1dd12c7b023e", + "size": 532044, + "subdir": "linux-64", + "timestamp": 1607111182417, + "version": "0.43.0" + }, + "cfn-lint-0.43.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "4c0edf12c9c52043bd45b0f506b88639", + "name": "cfn-lint", + "sha256": "28186de3052d582ad1d97d45f0b5f7139b39451a182b0d722d4d914431e94322", + "size": 531226, + "subdir": "linux-64", + "timestamp": 1607111179496, + "version": "0.43.0" + }, + "cfn-lint-0.43.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "4f057f13cd630268f4f532fa8a067fc5", + "name": "cfn-lint", + "sha256": "3de973d08b04ad86468e0232079babd6af11f7375c87b0bebef8385970392f10", + "size": 524160, + "subdir": "linux-64", + "timestamp": 1607111192534, + "version": "0.43.0" + }, + "cfn-lint-0.44.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "61d52166b0d6b2b6f71b5b6fa2809d7c", + "name": "cfn-lint", + "sha256": "245b4e39c7967981870b99ecbd4f50fe95d627bb51265f96da1cb96228709245", + "size": 534118, + "subdir": "linux-64", + "timestamp": 1608055503276, + "version": "0.44.0" + }, + "cfn-lint-0.44.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "118b45a62a993303e2308d4855d7cc50", + "name": "cfn-lint", + "sha256": "f89c34ccf77265510ab7be3f28c7b14a1eed184d00bcdad6eeea10f4da55cba4", + "size": 526347, + "subdir": "linux-64", + "timestamp": 1608055509572, + "version": "0.44.0" + }, + "cfn-lint-0.44.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "2199616af4216d586049ec632612f88e", + "name": "cfn-lint", + "sha256": "4048de41ac0a3cea773b915c5e156c0d6d81857e356544c00251dd0882d0fec7", + "size": 532911, + "subdir": "linux-64", + "timestamp": 1608055518667, + "version": "0.44.0" + }, + "cfn-lint-0.44.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "8ac5dc6bd4ab7194592f8f9d0aca64f8", + "name": "cfn-lint", + "sha256": "5938ccfd4e2b88b725e0472c07241a9a6ec25ba918304df1bc207a0a38935343", + "size": 539149, + "subdir": "linux-64", + "timestamp": 1609352259006, + "version": "0.44.2" + }, + "cfn-lint-0.44.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "eaa0cc47eed4c786a19b0741f82bef61", + "name": "cfn-lint", + "sha256": "79116ea7c8b0c62673552a98ae9bc0a08c2ea814af4dd5e70682216970f4fb56", + "size": 540048, + "subdir": "linux-64", + "timestamp": 1609352234148, + "version": "0.44.2" + }, + "cfn-lint-0.44.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "c2df699bb68c39345cff3d1bcccd8a8f", + "name": "cfn-lint", + "sha256": "7a1401bfc1fadca965fd32ddb275feecedba913e6a06732142d4af5d821c52a8", + "size": 542415, + "subdir": "linux-64", + "timestamp": 1609352232454, + "version": "0.44.2" + }, + "cfn-lint-0.44.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "d5fd2007cb5784a509e00373978bf2f7", + "name": "cfn-lint", + "sha256": "92c281ac76a76057e7356a48fbc7a319874ca5a35f44fb25ec31ce147a356711", + "size": 546444, + "subdir": "linux-64", + "timestamp": 1610130043675, + "version": "0.44.3" + }, + "cfn-lint-0.44.3-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "9d73ad95656b58e7e21e05c1d3eec58b", + "name": "cfn-lint", + "sha256": "c2482a7c0d96f6918d65a402ba66cfdcc0f18ae489d6db032ed2584b634fd58b", + "size": 550202, + "subdir": "linux-64", + "timestamp": 1610479855007, + "version": "0.44.3" + }, + "cfn-lint-0.44.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "9a07cfc854fc8d52da4e8e1a17244d03", + "name": "cfn-lint", + "sha256": "01f88e814a7b654e466347d9212106d5716c3c937070daac2b45b2c2dde54144", + "size": 546192, + "subdir": "linux-64", + "timestamp": 1610129741443, + "version": "0.44.3" + }, + "cfn-lint-0.44.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "0828cc60283fca73cddbef5402db97ba", + "name": "cfn-lint", + "sha256": "60fd798fa0113edd4813489c8c8f404c6a7af77f692b6a05ef0792a78e885cbf", + "size": 550074, + "subdir": "linux-64", + "timestamp": 1610479825456, + "version": "0.44.3" + }, + "cfn-lint-0.44.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "d25dbf26c400f53f4657bc4d259216e5", + "name": "cfn-lint", + "sha256": "692ef2892ea298a58db0499d6b3bd50476c4278658ec931189853c3f3e40a5b9", + "size": 551536, + "subdir": "linux-64", + "timestamp": 1610130038543, + "version": "0.44.3" + }, + "cfn-lint-0.44.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "081ceacca26c980207702a11236bba64", + "name": "cfn-lint", + "sha256": "ee4f5d92d9f111a7099f52b2a1ae0b4ef2286f25d38252db446b57aac7f1a2f3", + "size": 555742, + "subdir": "linux-64", + "timestamp": 1610479814013, + "version": "0.44.3" + }, + "cfn-lint-0.44.5-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "c82abc682c3752c168c79da6a11a09a9", + "name": "cfn-lint", + "sha256": "fdd65eb7d08424fbc8f2797192e4c72d62c4e1eb46ab2b78d17038eff5127870", + "size": 546599, + "subdir": "linux-64", + "timestamp": 1612240296295, + "version": "0.44.5" + }, + "cfn-lint-0.44.5-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "5fa91f127e637b504a50bb6bb1fcedff", + "name": "cfn-lint", + "sha256": "6edc432c234da514b1dea5613b1ae7ac95b89d0c2176dc8a9e3f75290a42a041", + "size": 554057, + "subdir": "linux-64", + "timestamp": 1612240282965, + "version": "0.44.5" + }, + "cfn-lint-0.44.5-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "b7c72cb7985f1bb0678b52e502838757", + "name": "cfn-lint", + "sha256": "06bd57ccbd8dd979ee266854d567994c0b2572412789556334eac2985c2ae6a6", + "size": 548347, + "subdir": "linux-64", + "timestamp": 1612240292615, + "version": "0.44.5" + }, + "cfn-lint-0.44.5-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "8c48e656c901d6cf68f7671fd20ac0d9", + "name": "cfn-lint", + "sha256": "ddb92ca106adf2db04e47f972ca0f7d6ad2e4e5e024287777155744eef1616a3", + "size": 554709, + "subdir": "linux-64", + "timestamp": 1613160895665, + "version": "0.44.5" + }, + "cfn-lint-0.44.7-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "8ba559328d20a19cab17d730042e6af8", + "name": "cfn-lint", + "sha256": "6f7c8d23c14a9d260b1ff5e2ff225654d5d76a643e3f5990a3dfd16b07e7d52b", + "size": 549992, + "subdir": "linux-64", + "timestamp": 1613246895405, + "version": "0.44.7" + }, + "cfn-lint-0.44.7-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "501c5bc077192bde9de7d1086a98433e", + "name": "cfn-lint", + "sha256": "70b7011a3e2e3edeeab6df6cdf6774407e3816bbd4a4018cc90dc24edf188732", + "size": 557702, + "subdir": "linux-64", + "timestamp": 1613246550194, + "version": "0.44.7" + }, + "cfn-lint-0.44.7-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "2959d91da0c2bd21f871b06e5e9ca79b", + "name": "cfn-lint", + "sha256": "9494f42bce08c11078840cf639990c2a221fc6afbf42bb87fdb71ffa0145238d", + "size": 557248, + "subdir": "linux-64", + "timestamp": 1613247054023, + "version": "0.44.7" + }, + "cfn-lint-0.44.7-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "f5c8a0a0776d8f7b5def8d7791e9ad6b", + "name": "cfn-lint", + "sha256": "9c0e0e70c7940c67134c812352d7c871a8c1889551044695634436e8f068339c", + "size": 555897, + "subdir": "linux-64", + "timestamp": 1613246894114, + "version": "0.44.7" + }, + "cfn-lint-0.45.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "48815df4201c8955eeef52644ca8a359", + "name": "cfn-lint", + "sha256": "09d236003951eaf24111f393fde1ac58f65742a6cd72525562cc31b1a01f9467", + "size": 584641, + "subdir": "linux-64", + "timestamp": 1613501254475, + "version": "0.45.0" + }, + "cfn-lint-0.45.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "cfaa029431324a4c92b7d2a7cd504b5f", + "name": "cfn-lint", + "sha256": "c1a8e0f8e925cdf67d1d052d79c3f90ab786a1e3f6fafa15cf4c65f271198bd8", + "size": 581872, + "subdir": "linux-64", + "timestamp": 1613501253139, + "version": "0.45.0" + }, + "cfn-lint-0.45.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "4b0b69c5f5b9a8f447a33fd5bac8958e", + "name": "cfn-lint", + "sha256": "15f4d6bb10f0a01ff9dc31b33e87328a886ae0db2a03cb047238eb2856251e9f", + "size": 584065, + "subdir": "linux-64", + "timestamp": 1613500622025, + "version": "0.45.0" + }, + "cfn-lint-0.45.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "4464736180f52abf719da2187f3294e9", + "name": "cfn-lint", + "sha256": "6165ad7013af7b78ea350b2ea479b13614de0dcdbacfebf66d9d5d0e9e882a88", + "size": 583786, + "subdir": "linux-64", + "timestamp": 1613501269169, + "version": "0.45.0" + }, + "cfn-lint-0.46.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "31d51d0c6f9bb885bcbc694d4d561b96", + "name": "cfn-lint", + "sha256": "4c3ab3f1f54dacd71d7319d9eba898c7a5c9ac60d5fd9a9f680c65ea01ed91ce", + "size": 591093, + "subdir": "linux-64", + "timestamp": 1614361641259, + "version": "0.46.0" + }, + "cfn-lint-0.46.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "c2e4e96df3bc2b616ee9d5b071129d93", + "name": "cfn-lint", + "sha256": "b3061ccb47bbe314d0318575f66d72ec76ec717d068cef8df615ec1c60df3cfa", + "size": 591714, + "subdir": "linux-64", + "timestamp": 1614361645901, + "version": "0.46.0" + }, + "cfn-lint-0.46.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "f4e0d89f3f4bf14771c8f3a134457c4d", + "name": "cfn-lint", + "sha256": "c7245fbc8066d82ff92b8d709460dfaa70a9bf6a02d76c7a6b73eb5ce0abe48d", + "size": 585542, + "subdir": "linux-64", + "timestamp": 1614361649803, + "version": "0.46.0" + }, + "cfn-lint-0.46.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "ee4b1da9b0aed84e2b382b432121f604", + "name": "cfn-lint", + "sha256": "777e215dbfe34da5b7d3da69d3ff142e4e1a2de2a2aac913f6c22a88576a306d", + "size": 584564, + "subdir": "linux-64", + "timestamp": 1614361549090, + "version": "0.46.0" + }, + "cfn-lint-0.47.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "ec1ebcb8661c4d9cddd79492062dadac", + "name": "cfn-lint", + "sha256": "57a54ecffabfa620f3e19931791e48dd5411a875c13bacca1b634f4f8833d904", + "size": 585686, + "subdir": "linux-64", + "timestamp": 1615411597322, + "version": "0.47.0" + }, + "cfn-lint-0.47.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "aafdcc3712b20adffdbafa25e74e72f4", + "name": "cfn-lint", + "sha256": "f69085caf953b860764c59c4bf8e3e4c50735cd607751d7b58eb08a559795519", + "size": 587076, + "subdir": "linux-64", + "timestamp": 1615411597328, + "version": "0.47.0" + }, + "cfn-lint-0.47.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "2b0c40661c80c846f0ec10300487f6b6", + "name": "cfn-lint", + "sha256": "84b11e01d4cdb2ede42f162074585e33ebe81f49cebff674932d50e05037e6dc", + "size": 593531, + "subdir": "linux-64", + "timestamp": 1615411599477, + "version": "0.47.0" + }, + "cfn-lint-0.47.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "256cd40f1689d184ef94f6a13355d9e5", + "name": "cfn-lint", + "sha256": "2476abc9bb36887bef5f8d694d356e05c9390123fa2749951928f35497dc3ccb", + "size": 587174, + "subdir": "linux-64", + "timestamp": 1615411602299, + "version": "0.47.0" + }, + "cfn-lint-0.47.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "ac588f288b6ef0f62f431ec64f0be7a1", + "name": "cfn-lint", + "sha256": "276cf62ed9c7e2df5d9a31acec709f78f0db7061df7867e62c887da0f0e12690", + "size": 590018, + "subdir": "linux-64", + "timestamp": 1615486241644, + "version": "0.47.1" + }, + "cfn-lint-0.47.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "d7222a20d46bb42a131f41ab380b8479", + "name": "cfn-lint", + "sha256": "20483d705922d2562c5010a7c8f210c384a522f9bf9ca0ee3b07b58ff9d13dd9", + "size": 597555, + "subdir": "linux-64", + "timestamp": 1615487859145, + "version": "0.47.1" + }, + "cfn-lint-0.47.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "ad5e16792e7e8298abce560d5c8db9de", + "name": "cfn-lint", + "sha256": "dff9f010f321921bb5cfc1f62f1700356c97c8f5ad012e7bebaaa78af5ad84b6", + "size": 596851, + "subdir": "linux-64", + "timestamp": 1615487866170, + "version": "0.47.1" + }, + "cfn-lint-0.47.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "808e5fc9806d882a75eb93c2f454c17d", + "name": "cfn-lint", + "sha256": "9bcba34a1db444fec09c336c6dd9667c0764b2fa3e79af7806d237009fe14f47", + "size": 597829, + "subdir": "linux-64", + "timestamp": 1615487878726, + "version": "0.47.1" + }, + "cfn-lint-0.47.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "ddc878bb400b701898ab38b2380de1a5", + "name": "cfn-lint", + "sha256": "542c06f1eeabb8476f794cbdffccf3b34bebc5b8e77b0df11e02669235cec709", + "size": 592629, + "subdir": "linux-64", + "timestamp": 1615661226310, + "version": "0.47.2" + }, + "cfn-lint-0.47.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "035521749245655d35a3565d5bf6c988", + "name": "cfn-lint", + "sha256": "afcbb4b94f718839733c3d952e111a6067c1ccedab80851999654ab8a5fff6d1", + "size": 592183, + "subdir": "linux-64", + "timestamp": 1615659528329, + "version": "0.47.2" + }, + "cfn-lint-0.47.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "c51901b5207cd9b95d525705fa6e3d63", + "name": "cfn-lint", + "sha256": "f58c688c339985a8ab47bbba8c5bb0ec4d7ad154c5d0a0e90cc21fa9d2703f85", + "size": 599747, + "subdir": "linux-64", + "timestamp": 1615661233931, + "version": "0.47.2" + }, + "cfn-lint-0.47.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "1ade59474addf89764971cdb003c637c", + "name": "cfn-lint", + "sha256": "e69ea2678e208c52b0b6401d16d8832467e055f1e52b898020d3bae08f31d6de", + "size": 590507, + "subdir": "linux-64", + "timestamp": 1615660467885, + "version": "0.47.2" + }, + "cfn-lint-0.48.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "0be1ff4069e207becef2d38cca5ff344", + "name": "cfn-lint", + "sha256": "3dae5a72c619d062fc948d771ab21919a61d7dff27eb4392bfeab29ac4ad5ee7", + "size": 596893, + "subdir": "linux-64", + "timestamp": 1616441645597, + "version": "0.48.0" + }, + "cfn-lint-0.48.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "7f5f67f891f295da08b26ade4a371514", + "name": "cfn-lint", + "sha256": "a9e7a011001ec267e78b92b8fea19736b09a7b5771e5ca02ee467d625c17dc61", + "size": 597550, + "subdir": "linux-64", + "timestamp": 1616441638857, + "version": "0.48.0" + }, + "cfn-lint-0.48.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "b68665acd0a53cf56e43b63b9a10cee7", + "name": "cfn-lint", + "sha256": "40edc110d1625073403765ba8f7bfbc4b0f717f07335c5a6eb3d2ee60cf1cd1f", + "size": 595382, + "subdir": "linux-64", + "timestamp": 1616441475985, + "version": "0.48.0" + }, + "cfn-lint-0.48.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "9fbe0236b0e8cd44494d4f14e5ac75ed", + "name": "cfn-lint", + "sha256": "e7f54627aa0e1a6c59425f00fb84669b7d69e706b26c5e2ef59972e06783e0ec", + "size": 598982, + "subdir": "linux-64", + "timestamp": 1616441475665, + "version": "0.48.0" + }, + "cfn-lint-0.48.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "e3038ca171a1947cc8e8f1341e169401", + "name": "cfn-lint", + "sha256": "d3a8f4d16bd1f74af1ac806e0fa8bcd2862f74e27f30b52dad8d7642d6dcb7b2", + "size": 605433, + "subdir": "linux-64", + "timestamp": 1617119707345, + "version": "0.48.1" + }, + "cfn-lint-0.48.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "902ef1f8dd45cc0a95a99df11d29a913", + "name": "cfn-lint", + "sha256": "eee9f569e2a9b8c6eeba20c9f4c78c3a1d1ae87cd2e73f314e314f9f258ef3c0", + "size": 604252, + "subdir": "linux-64", + "timestamp": 1617117249297, + "version": "0.48.1" + }, + "cfn-lint-0.48.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "adb2876105c54b256eee91c998a86133", + "name": "cfn-lint", + "sha256": "85f388a966ba02ee7aeb523737b0c9ca76e5070f420fdc7913a0e9d44e49c664", + "size": 596052, + "subdir": "linux-64", + "timestamp": 1617119720651, + "version": "0.48.1" + }, + "cfn-lint-0.48.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "0f4846b8092ada5a045a0f19b1e320c3", + "name": "cfn-lint", + "sha256": "34791538dcebf1e142d4a16c079f84f8c40ce26a1b4638333eba822326a87349", + "size": 604996, + "subdir": "linux-64", + "timestamp": 1617119711118, + "version": "0.48.1" + }, + "cfn-lint-0.48.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "70815550c076de92e5821af2b8266655", + "name": "cfn-lint", + "sha256": "7bcc51a2a044f50646635a62f5b49ed508565aa8ece5ec8a99e7f582596c46e9", + "size": 617062, + "subdir": "linux-64", + "timestamp": 1617740770058, + "version": "0.48.2" + }, + "cfn-lint-0.48.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "375765bb0081b7e6c55fe0834d9ad6a3", + "name": "cfn-lint", + "sha256": "c02b2713f84131cc3edbf29831dbde2e2aa0ebccf12fde8b2457f964407c3262", + "size": 617593, + "subdir": "linux-64", + "timestamp": 1617740766954, + "version": "0.48.2" + }, + "cfn-lint-0.48.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "464b80406f252dd2e2fa9878e075732f", + "name": "cfn-lint", + "sha256": "42c8cee272ee8dc9b449cd1b8ca1ef65c4df7f0ce4adc31057174338b9daff8e", + "size": 609670, + "subdir": "linux-64", + "timestamp": 1617740197732, + "version": "0.48.2" + }, + "cfn-lint-0.48.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "2c6b54da759d6ded10885bd8c08265e2", + "name": "cfn-lint", + "sha256": "6f86a2a74917550c7fd740bea0eb0fd763731a60832a5cab628bcfb3122765e2", + "size": 609024, + "subdir": "linux-64", + "timestamp": 1617740767975, + "version": "0.48.2" + }, + "cfn-lint-0.48.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.34.0", + "importlib_resources >=1.4,<4", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "b17ca69707ab06da65ec52b802a6be45", + "name": "cfn-lint", + "sha256": "94b67d66918d74f56bf27af076d563e4fd1533a26fba82c2442fcf50e9f91503", + "size": 610487, + "subdir": "linux-64", + "timestamp": 1618856211868, + "version": "0.48.3" + }, + "cfn-lint-0.48.3-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "b8a0bf22911dbd0248196ffc5b5b4dc0", + "name": "cfn-lint", + "sha256": "686204fa91a098df0755be5fc55d0a519fbd8df4ab955a67096093002b05b168", + "size": 612003, + "subdir": "linux-64", + "timestamp": 1618607863234, + "version": "0.48.3" + }, + "cfn-lint-0.48.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.34.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "befc3815b687e546d584d5d8f69846f6", + "name": "cfn-lint", + "sha256": "b0cae1513ddaffb1d64292372bc400774806f5a3352dfc874a2dcdcb07fde187", + "size": 618330, + "subdir": "linux-64", + "timestamp": 1618856202186, + "version": "0.48.3" + }, + "cfn-lint-0.48.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "655f2805bc2b1b26bd9967caa6047e40", + "name": "cfn-lint", + "sha256": "64f9965e342bde4b6351e353851f2157db3cd16e538cc88993ab6abd41db2008", + "size": 609617, + "subdir": "linux-64", + "timestamp": 1618607848978, + "version": "0.48.3" + }, + "cfn-lint-0.48.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.34.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "27235ff17dad3641a3a0896286ce3f6d", + "name": "cfn-lint", + "sha256": "23f234902330868eec6986bd4a2b21acab221bdb39cab30154cacfa47fcd006d", + "size": 613785, + "subdir": "linux-64", + "timestamp": 1618855876450, + "version": "0.48.3" + }, + "cfn-lint-0.48.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "42aa03ccfe8f7e80f876b032139b4a16", + "name": "cfn-lint", + "sha256": "414d3937ef1a6a67138dc631bdd099dcc692b5ff213458f3f4b0bb5fb6abbe6a", + "size": 611005, + "subdir": "linux-64", + "timestamp": 1618607855166, + "version": "0.48.3" + }, + "cfn-lint-0.48.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.34.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "183b17693ad744abfd88ef01cdddea6e", + "name": "cfn-lint", + "sha256": "58df17d94142951c3927a21b60bee6ed624a009e1c2dfa32ed8bac9288c4ebbd", + "size": 609637, + "subdir": "linux-64", + "timestamp": 1618856319759, + "version": "0.48.3" + }, + "cfn-lint-0.48.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "aws-sam-translator >=1.13.0", + "jsonpatch", + "jsonschema >=3,<4", + "networkx", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11,<2" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "1ebf6e835a3f79d93873832a7d29ea18", + "name": "cfn-lint", + "sha256": "5b53166ab89c17843c3d5105a0220b06519880b5264fb176d47a25c73d1df706", + "size": 610686, + "subdir": "linux-64", + "timestamp": 1618607505734, + "version": "0.48.3" + }, + "cfn-lint-0.49.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "importlib_resources >=1.4,<4", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "900271f941d6d8945773fe4f670feed8", + "name": "cfn-lint", + "sha256": "1c531017cd427bab1851e01666ebb174d1b044af7b2ebef4f9d397fb74de1164", + "size": 616417, + "subdir": "linux-64", + "timestamp": 1619605965213, + "version": "0.49.0" + }, + "cfn-lint-0.49.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "ec1aea3ad9731374182229907caadbef", + "name": "cfn-lint", + "sha256": "5d18c308be012fb4a4344cb9d62726544cc63929ce265f1c99eb01934a4a5733", + "size": 622532, + "subdir": "linux-64", + "timestamp": 1619605998263, + "version": "0.49.0" + }, + "cfn-lint-0.49.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "2e2ac90cd008f0979e0a2192410b7b8d", + "name": "cfn-lint", + "sha256": "a7af0c4c4051d01dd43166656cb9a87d26c4182cf9e72269ad39ad92843c0734", + "size": 614955, + "subdir": "linux-64", + "timestamp": 1619606001037, + "version": "0.49.0" + }, + "cfn-lint-0.49.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "21c706b933a130b4ff5bbe03edfdc084", + "name": "cfn-lint", + "sha256": "94ed4d4e4a803711c902b84a14b0ebd0d898b936d038dacd9c5f36f9358268c2", + "size": 621809, + "subdir": "linux-64", + "timestamp": 1619605999315, + "version": "0.49.0" + }, + "cfn-lint-0.49.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "importlib_resources >=1.4,<4", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "d5a289b36fdbe0bac491240e3cc350a0", + "name": "cfn-lint", + "sha256": "067260479da12229f2087eb77dcc42e24334d488ca97ecdf88776829930ee3dd", + "size": 630118, + "subdir": "linux-64", + "timestamp": 1620710207314, + "version": "0.49.1" + }, + "cfn-lint-0.49.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "e7c0fb55d45e5cbebcd9927453096b41", + "name": "cfn-lint", + "sha256": "dda16ce5055ad4a6a9a17d64e49a17c8df0d4fbd08073c87b20c9ebce83bbd3a", + "size": 630494, + "subdir": "linux-64", + "timestamp": 1620710204881, + "version": "0.49.1" + }, + "cfn-lint-0.49.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "6ec6785fb4c057ef3c0c97e93ac2b8d0", + "name": "cfn-lint", + "sha256": "d3599582b34c52a2644206385a2b0018940b74f96feae20ecf258820f35996bd", + "size": 624671, + "subdir": "linux-64", + "timestamp": 1620710197136, + "version": "0.49.1" + }, + "cfn-lint-0.49.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "5a55f55b7da63e9c664715f72f676011", + "name": "cfn-lint", + "sha256": "829eac2807622522b612f3ec6224a56f2499a7d3b58338304d9a34d12184eee4", + "size": 621631, + "subdir": "linux-64", + "timestamp": 1620710121772, + "version": "0.49.1" + }, + "cfn-lint-0.49.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "importlib_resources >=1.4,<4", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "86b49b696a328bdec43ee608feec09b6", + "name": "cfn-lint", + "sha256": "f721b1842b0ba1e4ec3e61f0e9ef078a9fe13c94967529d20ad3ca1d7348f1df", + "size": 635836, + "subdir": "linux-64", + "timestamp": 1621427026316, + "version": "0.49.2" + }, + "cfn-lint-0.49.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "73a696ea6168c664aa11b4bdaf6ca3eb", + "name": "cfn-lint", + "sha256": "3b2481ef3789c9b12fd6edb3a637540e31dfeccf55e4b1ed1cc53c199f80e8bb", + "size": 630634, + "subdir": "linux-64", + "timestamp": 1621431664075, + "version": "0.49.2" + }, + "cfn-lint-0.49.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "d5c40f2397a2b345d19f787ca8c51632", + "name": "cfn-lint", + "sha256": "231d6e17161bcf7e1c4768e0a2dc7b50c2d3a7cab9b6f5dbff7e7252c658819e", + "size": 626819, + "subdir": "linux-64", + "timestamp": 1621431658198, + "version": "0.49.2" + }, + "cfn-lint-0.49.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "50ed8f4b551e7704b9a92eaecc0e6ebf", + "name": "cfn-lint", + "sha256": "be4f81be39da6cfc2dbfcd6a95fab5194c6164abe75498d4e4b6aa32d54f2479", + "size": 626756, + "subdir": "linux-64", + "timestamp": 1621431655141, + "version": "0.49.2" + }, + "cfn-lint-0.50.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "importlib_resources >=1.4,<4", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "f858a6147fa9e57d658f4c41b779afc1", + "name": "cfn-lint", + "sha256": "780ae123699604087ccc24d24af5b6e3863a42156283a0d6b24897fd558aac21", + "size": 631942, + "subdir": "linux-64", + "timestamp": 1622824518816, + "version": "0.50.0" + }, + "cfn-lint-0.50.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "d22fb05048f52056a693fdc2b71d7b84", + "name": "cfn-lint", + "sha256": "0d7537c2cd1faec728892ed028cb9e4887abe91d52d93fbcf18266d85c2101aa", + "size": 637253, + "subdir": "linux-64", + "timestamp": 1622825024681, + "version": "0.50.0" + }, + "cfn-lint-0.50.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "e451a97cced0fee23aca7ec5a5c29ad6", + "name": "cfn-lint", + "sha256": "21de0446035f3ca0a23e32fd2c51a0e76c6bd25cf46189949c0230b53d24a78d", + "size": 638648, + "subdir": "linux-64", + "timestamp": 1622819701092, + "version": "0.50.0" + }, + "cfn-lint-0.50.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.35.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "3cac9bf7f70ac57c3008b2e2e65d6bf6", + "name": "cfn-lint", + "sha256": "8c8059b99db0dcc728a3437c8dcedb229fa4694144ca77cd9e4f656ac643a6b4", + "size": 638327, + "subdir": "linux-64", + "timestamp": 1622825018153, + "version": "0.50.0" + }, + "cfn-lint-0.52.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.36.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.10,<3.11.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "79dad3316f9f97fce06a4485946a1e7b", + "name": "cfn-lint", + "sha256": "c50f1fef7ff974b589e9b9969d4f829efc8a1aa4d70a8e2b59dc30114b6ca261", + "size": 646863, + "subdir": "linux-64", + "timestamp": 1640803855222, + "version": "0.52.0" + }, + "cfn-lint-0.52.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.36.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.11,<3.12.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "90e5fa26a81cff4c727ed09f6efa218d", + "name": "cfn-lint", + "sha256": "9f639abd7af324a3f73b3f8f750042ae68eb66de8e90ce7d37765adaf078231d", + "size": 1168175, + "subdir": "linux-64", + "timestamp": 1676843518024, + "version": "0.52.0" + }, + "cfn-lint-0.52.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.36.0", + "importlib_resources >=1.4,<4", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "0006154cdf8f0aaa976c4c93664bc55d", + "name": "cfn-lint", + "sha256": "8f89845bf4214a1d68643460774621b15768b5f5160d957024980752508c3313", + "size": 636263, + "subdir": "linux-64", + "timestamp": 1625154340520, + "version": "0.52.0" + }, + "cfn-lint-0.52.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.36.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "a1ff4c46d4e18f71b06b2bfea17df8ef", + "name": "cfn-lint", + "sha256": "8b49f10eea4635f2a8b8aabb50fe4efcb9dc5e947a89c3879d465ace29cc958f", + "size": 636670, + "subdir": "linux-64", + "timestamp": 1625147807451, + "version": "0.52.0" + }, + "cfn-lint-0.52.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.36.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "3cfdf6643fbcf49d49a0a95fedc3ff2b", + "name": "cfn-lint", + "sha256": "0407b0f1c2cc38ecab172d002afd6b39e75745296effe645dd620b8ff915e46e", + "size": 644445, + "subdir": "linux-64", + "timestamp": 1625154312199, + "version": "0.52.0" + }, + "cfn-lint-0.52.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aws-sam-translator >=1.36.0", + "jsonpatch", + "jsonschema ~=3.0", + "junit-xml ~=1.9", + "networkx ~=2.4", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "six >=1.11" + ], + "license": "MIT No Attribution", + "license_family": "MIT", + "md5": "75960182cfc3d47b0b86cdade8b21024", + "name": "cfn-lint", + "sha256": "a351e07ba55fe4fbf7436465f73a8a44953d3a4e78e853f24d391fd63a094253", + "size": 644853, + "subdir": "linux-64", + "timestamp": 1625154325370, + "version": "0.52.0" + }, + "cftime-1.0.0b1-py27h035aef0_0.conda": { + "build": "py27h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "1da4c48b0f074bb32f209c0a4f68696f", + "name": "cftime", + "sha256": "1490074e45d25fc4e404983a965cd12da70ad71a853117ed421641bc9b762a39", + "size": 233570, + "subdir": "linux-64", + "timestamp": 1530901725246, + "version": "1.0.0b1" + }, + "cftime-1.0.0b1-py27h3010b51_0.conda": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c2911fd0d7141de4486c7b0113696b97", + "name": "cftime", + "sha256": "4983c00e9fed12584a979fa2ee8cc072cd34a1536ffaa577e05dfe90a4cbacc1", + "size": 233499, + "subdir": "linux-64", + "timestamp": 1526227679757, + "version": "1.0.0b1" + }, + "cftime-1.0.0b1-py35h3010b51_0.conda": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "0ee94eb06901cf90bbde837dc03bc3cc", + "name": "cftime", + "sha256": "d599e8659af5f6309b71ec60ae181cece5e8f010c83974e5cb182ebbb26bf533", + "size": 233806, + "subdir": "linux-64", + "timestamp": 1526227678116, + "version": "1.0.0b1" + }, + "cftime-1.0.0b1-py36h035aef0_0.conda": { + "build": "py36h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "aebdd348d1f030c04fe4def3ac02d6ef", + "name": "cftime", + "sha256": "a0cd98d8d7a767b771458a95e3e2e1ac588e903fe82f601812a95fd5baec0cb7", + "size": 246775, + "subdir": "linux-64", + "timestamp": 1530901655774, + "version": "1.0.0b1" + }, + "cftime-1.0.0b1-py36h3010b51_0.conda": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "81fbeb8953e103ec7b6d4a6528d7cbcf", + "name": "cftime", + "sha256": "480b372fb4b37049c2776b355f94d0423988efa5b8026ecf0126012091b12aaf", + "size": 246999, + "subdir": "linux-64", + "timestamp": 1526227651020, + "version": "1.0.0b1" + }, + "cftime-1.0.0b1-py37h035aef0_0.conda": { + "build": "py37h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a18ebec348e57ad6e6db73f88932723c", + "name": "cftime", + "sha256": "b7e8549e26a6da7333b7cd3255d76ed83916ca37375ff3cb210f6b6a1317a9ed", + "size": 244342, + "subdir": "linux-64", + "timestamp": 1530901578989, + "version": "1.0.0b1" + }, + "cftime-1.0.2.1-py27hdd07704_0.conda": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5f245f0cf71ce40032c3a0ee03d50c39", + "name": "cftime", + "sha256": "82360c29c575f8a7ecb8c924328cb0a4428e2cd2ab8028a0b6d0c2900963ab60", + "size": 264692, + "subdir": "linux-64", + "timestamp": 1541017009095, + "version": "1.0.2.1" + }, + "cftime-1.0.2.1-py36hdd07704_0.conda": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f95690f032fa3c0ebd7280a5c760c3ea", + "name": "cftime", + "sha256": "d02986a447f73d186da07608a31d6ca2ed461766b25af248b46389fa747c84df", + "size": 285079, + "subdir": "linux-64", + "timestamp": 1541017146693, + "version": "1.0.2.1" + }, + "cftime-1.0.2.1-py37hdd07704_0.conda": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d1d0aeda95b7c038ebeeb39a1608ade0", + "name": "cftime", + "sha256": "e89ec5698a4d4014753346649a892e64fc7f9164344a58bc1cdc6dbaaa57cbef", + "size": 281938, + "subdir": "linux-64", + "timestamp": 1541016960929, + "version": "1.0.2.1" + }, + "cftime-1.0.3.4-py27hdd07704_0.conda": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d03f881c99a93282155af1682650665e", + "name": "cftime", + "sha256": "008a5d0309a1f72eebdc617bd5d5dcbc941bf2f39bf6709628034e43801919d7", + "size": 271262, + "subdir": "linux-64", + "timestamp": 1545080497228, + "version": "1.0.3.4" + }, + "cftime-1.0.3.4-py27hdd07704_1.conda": { + "build": "py27hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT and GPL", + "md5": "c028edbecaedf79b61043a662d8a70be", + "name": "cftime", + "sha256": "bbedfca1c7a6f34736b68227ba2b70720bc3b01a2fcebe844ef5ac71d9d4c10a", + "size": 284636, + "subdir": "linux-64", + "timestamp": 1559233539694, + "version": "1.0.3.4" + }, + "cftime-1.0.3.4-py27hdd07704_1001.conda": { + "build": "py27hdd07704_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT and GPL", + "md5": "5e1cf9e955b581da92b77cf2da2962fc", + "name": "cftime", + "sha256": "d04b992d418e75547ff6e0181321a954f37f0c9f9a4ddd892442f533ed9c455c", + "size": 275402, + "subdir": "linux-64", + "timestamp": 1564159297759, + "version": "1.0.3.4" + }, + "cftime-1.0.3.4-py36hdd07704_0.conda": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4f1cfd439de6d603050c3af5953c6e95", + "name": "cftime", + "sha256": "83de727f905e5e615c31877c94116ea517efa0260d528b92e72fba37f9dc4368", + "size": 291496, + "subdir": "linux-64", + "timestamp": 1545080479868, + "version": "1.0.3.4" + }, + "cftime-1.0.3.4-py36hdd07704_1.conda": { + "build": "py36hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT and GPL", + "md5": "268644b6b031b4bebbb7a33c70f897df", + "name": "cftime", + "sha256": "3065ff150282b6f68570955e1998625e808f6e0a984a9af55a0a1875498f1e82", + "size": 304317, + "subdir": "linux-64", + "timestamp": 1559233520455, + "version": "1.0.3.4" + }, + "cftime-1.0.3.4-py36hdd07704_1001.conda": { + "build": "py36hdd07704_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT and GPL", + "md5": "5a6b98fc29a58475a2872760a9128bd8", + "name": "cftime", + "sha256": "1239f2c706cce965616e43c916ab00fef5773aad538ed9033a972135e1f12002", + "size": 295211, + "subdir": "linux-64", + "timestamp": 1564159309618, + "version": "1.0.3.4" + }, + "cftime-1.0.3.4-py37hdd07704_0.conda": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2101059080642890af196958c2e43a11", + "name": "cftime", + "sha256": "d9c7c0fffc2ff97865ff7bc16081b92b893ff99b7b288c070e16e2b6ce1d32b8", + "size": 287386, + "subdir": "linux-64", + "timestamp": 1545080547106, + "version": "1.0.3.4" + }, + "cftime-1.0.3.4-py37hdd07704_1.conda": { + "build": "py37hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT and GPL", + "md5": "37ac715824f875b676378f8810827b57", + "name": "cftime", + "sha256": "95e0e50a8a9ef776783dac39f29147d86fe4509335f09f1420940bcd8468d712", + "size": 300519, + "subdir": "linux-64", + "timestamp": 1559233482448, + "version": "1.0.3.4" + }, + "cftime-1.0.3.4-py37hdd07704_1001.conda": { + "build": "py37hdd07704_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT and GPL", + "md5": "6124f03b280e1eb8d004b3052486a600", + "name": "cftime", + "sha256": "113a751c79cbb4fbf304158d6f1d0959d9d234237d7164b525595a6f99f6749d", + "size": 290985, + "subdir": "linux-64", + "timestamp": 1564159270984, + "version": "1.0.3.4" + }, + "cftime-1.0.4.2-py27hdd07704_0.conda": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT and GPL", + "md5": "968caf83c1ac2966bc5d5363927fba12", + "name": "cftime", + "sha256": "85563f6b91c3d0039950b4dbc1d700e6dd458aef856295b1b1880b0aaac6b9ea", + "size": 278780, + "subdir": "linux-64", + "timestamp": 1573081710466, + "version": "1.0.4.2" + }, + "cftime-1.0.4.2-py36hdd07704_0.conda": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT and GPL", + "md5": "728dc2cac1686a8c3b3f5d7d61cbaa2f", + "name": "cftime", + "sha256": "18370649b77d517ba93a2fed653d5550f550301df820e486971984655bc15047", + "size": 297961, + "subdir": "linux-64", + "timestamp": 1573081275666, + "version": "1.0.4.2" + }, + "cftime-1.0.4.2-py37hdd07704_0.conda": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT and GPL", + "md5": "420273572ba1786afc762caf03c34516", + "name": "cftime", + "sha256": "795a4bfefa4d93c80f9aa5c4e5a6b7f3dfba53b7c9ceb78dbf458dd98dc08de6", + "size": 294455, + "subdir": "linux-64", + "timestamp": 1573081239601, + "version": "1.0.4.2" + }, + "cftime-1.0.4.2-py38hdd07704_0.conda": { + "build": "py38hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT and GPL", + "md5": "cb5e1abbdb86ee68aa091c48441704e4", + "name": "cftime", + "sha256": "dff86e99adcc4be8a8d7573c6b67a6ed64e09d5dcaa13531a551acfed4edbb2a", + "size": 310461, + "subdir": "linux-64", + "timestamp": 1573081229298, + "version": "1.0.4.2" + }, + "cftime-1.1.1.1-py36heb32a55_0.conda": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT and GPL-3.0", + "md5": "04111b5a3e2a92e53aa95d91111d9658", + "name": "cftime", + "sha256": "5a9c514721bb3672d96cb53f9559064a125751085a1725815b84ade34aa5a35c", + "size": 305118, + "subdir": "linux-64", + "timestamp": 1585044655316, + "version": "1.1.1.1" + }, + "cftime-1.1.1.1-py37heb32a55_0.conda": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT and GPL-3.0", + "md5": "15b4d9cb74ac3e5f42e5db3496b3ddc0", + "name": "cftime", + "sha256": "2125958a0be73224f268dba2f2f5beeee93fc231e75e5bca913cab2542d6435a", + "size": 301944, + "subdir": "linux-64", + "timestamp": 1585044613102, + "version": "1.1.1.1" + }, + "cftime-1.1.1.1-py38heb32a55_0.conda": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT and GPL-3.0", + "md5": "057d4525a767b6c1bcd78505faf54fb7", + "name": "cftime", + "sha256": "b6eaa0def8e4ccf90eeac19ee9832ff62511190f19eca1e3d9d318cd3c898c95", + "size": 317790, + "subdir": "linux-64", + "timestamp": 1585044630018, + "version": "1.1.1.1" + }, + "cftime-1.1.1.2-py36h035aef0_0.conda": { + "build": "py36h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT and GPL-3.0", + "md5": "18caa850659d129ac5a63a4ccf216cb0", + "name": "cftime", + "sha256": "3728b5e808ae2c2fef4a25a3371f3c0bc34eb75450904a7b63e478dce0d2c910", + "size": 305216, + "subdir": "linux-64", + "timestamp": 1586838345001, + "version": "1.1.1.2" + }, + "cftime-1.1.2-py36heb32a55_0.conda": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT and GPL-3.0", + "md5": "7428780610025d34783ba72fc0208f14", + "name": "cftime", + "sha256": "bcedd21740de1307ab4f6436d59e231775db8736785f9c6c279f442a802d88bf", + "size": 299616, + "subdir": "linux-64", + "timestamp": 1588595322459, + "version": "1.1.2" + }, + "cftime-1.1.2-py37heb32a55_0.conda": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT and GPL-3.0", + "md5": "aa6680de4175197cb9c1e5f420205486", + "name": "cftime", + "sha256": "a0edc3cdc7574738b222dde9a737ad46efe6d05f94bd255571918a63a5fe63f0", + "size": 295320, + "subdir": "linux-64", + "timestamp": 1588595263403, + "version": "1.1.2" + }, + "cftime-1.1.2-py38heb32a55_0.conda": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT and GPL-3.0", + "md5": "7e72533e70ef0943018a0be0ff23036a", + "name": "cftime", + "sha256": "671687305a0e16d3dcf303d4e84f87072be78ecd4fe757ecb13614228fbc92d3", + "size": 310772, + "subdir": "linux-64", + "timestamp": 1588595239135, + "version": "1.1.2" + }, + "cftime-1.2.1-py36heb32a55_0.conda": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "ec7008f5c8009687bc27a6169cfbd8e4", + "name": "cftime", + "sha256": "a2e6569030ddab3d7946997b6851bdca3a422764afd2a2b5de8de3f5f51dff00", + "size": 271094, + "subdir": "linux-64", + "timestamp": 1595379809144, + "version": "1.2.1" + }, + "cftime-1.2.1-py37heb32a55_0.conda": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "19e286b4cb4fa7239a213e4d75c31df8", + "name": "cftime", + "sha256": "93920522ecd5d38b0e21c64a98587d5a6dedd5049c516e97891db7b1b81492f4", + "size": 269197, + "subdir": "linux-64", + "timestamp": 1595379790816, + "version": "1.2.1" + }, + "cftime-1.2.1-py38heb32a55_0.conda": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "1b39e39050f219202474d9cc04288315", + "name": "cftime", + "sha256": "ceb7baa5d7bfe3e787e6be9b10da1dce8662a31ef41ff00bef03328e51edb3c7", + "size": 286086, + "subdir": "linux-64", + "timestamp": 1595379809750, + "version": "1.2.1" + }, + "cftime-1.3.0-py36h6323ea4_0.conda": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "73b388afa0d1fbe6edba7d6c8fb3efbf", + "name": "cftime", + "sha256": "8a0a84f82fd29e4eeef397176d30475000da03f8ad2d7b100a9980d219ee2cf4", + "size": 273770, + "subdir": "linux-64", + "timestamp": 1605995866554, + "version": "1.3.0" + }, + "cftime-1.3.0-py37h6323ea4_0.conda": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "bb3c4626c97984ebad5291beeaab788c", + "name": "cftime", + "sha256": "5448a5f2f28b41e5f5d24b7027371d14752a4ed6fd45bac5f148e0e0507ca0fe", + "size": 271254, + "subdir": "linux-64", + "timestamp": 1605995874870, + "version": "1.3.0" + }, + "cftime-1.3.0-py38h6323ea4_0.conda": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "9554cb3bde8b41f24dce284971a4bc7d", + "name": "cftime", + "sha256": "7aad904c6067e96f08e9371a1b980ad0b4e2f7248d500fda71390124d3c5813d", + "size": 288158, + "subdir": "linux-64", + "timestamp": 1605995820846, + "version": "1.3.0" + }, + "cftime-1.3.1-py36h6323ea4_0.conda": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "16d5fc3aac4d51b98fbf1c8b398f1ad2", + "name": "cftime", + "sha256": "d56494d28cdf423f98044b83c29665a37a04d86d3d457c72e2800f0586ab774e", + "size": 275768, + "subdir": "linux-64", + "timestamp": 1610908485058, + "version": "1.3.1" + }, + "cftime-1.3.1-py37h6323ea4_0.conda": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "bd9365f7e79a0461e1bbe4d1a74b5ec3", + "name": "cftime", + "sha256": "1dcafd43d50bd03385164bbed018fedf570ed04d3dcb1320f5b89181cf363cd2", + "size": 273051, + "subdir": "linux-64", + "timestamp": 1610907812422, + "version": "1.3.1" + }, + "cftime-1.3.1-py38h6323ea4_0.conda": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "8ef6d47f9bb6c4191534c632dc94b191", + "name": "cftime", + "sha256": "bface56e7fa7d3af97daf1f208ea10748a16fb572a2e7a9b9e7ace47fe780fcf", + "size": 289696, + "subdir": "linux-64", + "timestamp": 1610908496915, + "version": "1.3.1" + }, + "cftime-1.3.1-py39h6323ea4_0.conda": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT and GPL-3.0-only", + "md5": "62c765869146aea1a89df6a22c08b897", + "name": "cftime", + "sha256": "ced5b509f8e1fe12c80e3173088d489fbd6eb3bc1a10f2af875b5b965caae202", + "size": 291117, + "subdir": "linux-64", + "timestamp": 1610908507161, + "version": "1.3.1" + }, + "cftime-1.4.1-py36h6323ea4_0.conda": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d2f710a9c40843dbce257c1822518f8d", + "name": "cftime", + "sha256": "b0ef6fb50824acdbda7826ceab80b6074eb0aebd84c0e25c99c9d647a7c745e0", + "size": 267662, + "subdir": "linux-64", + "timestamp": 1613248322706, + "version": "1.4.1" + }, + "cftime-1.4.1-py37h6323ea4_0.conda": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1d1e404a95b646c662c9116a5d2c6bf6", + "name": "cftime", + "sha256": "d44e6771f9d4e0fa712b136245411d3ddf7b99b9e89b7a56e4de323e36a66785", + "size": 264422, + "subdir": "linux-64", + "timestamp": 1613248322915, + "version": "1.4.1" + }, + "cftime-1.4.1-py38h6323ea4_0.conda": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "d017fa87c04e4cb4d2013925a8fe1778", + "name": "cftime", + "sha256": "279c1b5728f8a0ef41051717fb8eab0d71bbe599c440ffe34f416872253114e2", + "size": 281687, + "subdir": "linux-64", + "timestamp": 1613248325487, + "version": "1.4.1" + }, + "cftime-1.4.1-py39h6323ea4_0.conda": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "9ef5cd1a3197ac5dcb7c71fe8b8bd967", + "name": "cftime", + "sha256": "fbd761de64e8d04c02c0e5785f55f3cb952f1f51d55bab52099e2108033db090", + "size": 282004, + "subdir": "linux-64", + "timestamp": 1613248041365, + "version": "1.4.1" + }, + "cftime-1.5.0-py36h6323ea4_0.conda": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b81312faf904bc30580e64841ad0b825", + "name": "cftime", + "sha256": "4b9554083655ca1e61a8ad666905aabde209504feef373b4475da8d9e7521c11", + "size": 197552, + "subdir": "linux-64", + "timestamp": 1621828261633, + "version": "1.5.0" + }, + "cftime-1.5.0-py37h6323ea4_0.conda": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "cad5bcd78fed792acacef3c6670d00dd", + "name": "cftime", + "sha256": "a06f466f9d8edbb008f81a1f8c843f04da308833f942e145c832d93d77ad89ff", + "size": 194603, + "subdir": "linux-64", + "timestamp": 1621823425231, + "version": "1.5.0" + }, + "cftime-1.5.0-py38h6323ea4_0.conda": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "659de1478a2ad8f47b1c2cbff8866309", + "name": "cftime", + "sha256": "05e08e3d15dfe628d11d77fa52e59645539e8147490844ad62da1693bc2e0f7f", + "size": 207353, + "subdir": "linux-64", + "timestamp": 1621828277925, + "version": "1.5.0" + }, + "cftime-1.5.0-py39h6323ea4_0.conda": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "a8737c16a77d3dbd69121894a8025bc4", + "name": "cftime", + "sha256": "b14c967ed37ab628786dffe86714ba9b8a29272d47f9a663bf2100d2aec2da1f", + "size": 206869, + "subdir": "linux-64", + "timestamp": 1621823422463, + "version": "1.5.0" + }, + "cftime-1.5.1.1-py310h9102076_0.conda": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5453e1d4ec367b54a13c865750f5c861", + "name": "cftime", + "sha256": "1421d9736c31d67ceac4523b9d4483502f2df3fce8f8f72a83f74a8f2fc5930e", + "size": 654698, + "subdir": "linux-64", + "timestamp": 1640788956666, + "version": "1.5.1.1" + }, + "cftime-1.5.1.1-py311hbed6279_0.conda": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0dbab729254dc29d656adddefc29f526", + "name": "cftime", + "sha256": "383f0eaa91f42b9889cd0c4b6a739f3df9a9f4621f4a64b65d00713628bdcc37", + "size": 201581, + "subdir": "linux-64", + "timestamp": 1676830273637, + "version": "1.5.1.1" + }, + "cftime-1.5.1.1-py37hce1f21e_0.conda": { + "build": "py37hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7464c6538d870da253975442247a1244", + "name": "cftime", + "sha256": "bdce2c59441a2dc216e1ce9cbee5bc036001e58ce99dc26d3d7fcfc22121524f", + "size": 199308, + "subdir": "linux-64", + "timestamp": 1638345354687, + "version": "1.5.1.1" + }, + "cftime-1.5.1.1-py38hce1f21e_0.conda": { + "build": "py38hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49703c1bcbe02f6590c9a8de0fbe4233", + "name": "cftime", + "sha256": "944f1ed2f058f7bfde5d1c37851c71a5ff245dd145842c6d8db673c966d65c2a", + "size": 211374, + "subdir": "linux-64", + "timestamp": 1638357968908, + "version": "1.5.1.1" + }, + "cftime-1.5.1.1-py39hce1f21e_0.conda": { + "build": "py39hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d72d257503abbeed84a462cb733fbfd9", + "name": "cftime", + "sha256": "ce7c69ea0ac046b140923af2e4e600c2902f6a016fe033d434ec5655cb3f8067", + "size": 211710, + "subdir": "linux-64", + "timestamp": 1638358542039, + "version": "1.5.1.1" + }, + "cftime-1.6.2-py310ha9d4c09_0.conda": { + "build": "py310ha9d4c09_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80a651a48b7e1a19b23f5af5efe9f30f", + "name": "cftime", + "sha256": "8616a8f1a36be575cecb50dbbbeec7f18198d5b8773910d6bff60a41ef80b282", + "size": 259234, + "subdir": "linux-64", + "timestamp": 1678830501437, + "version": "1.6.2" + }, + "cftime-1.6.2-py311hbed6279_0.conda": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd01c804a934ef92a634f3ce1bb94310", + "name": "cftime", + "sha256": "bd2ddcfe5c5f0ae53d8d3f55d69ee408d62e970f72e687fd77f072354a78ff23", + "size": 238643, + "subdir": "linux-64", + "timestamp": 1679335541002, + "version": "1.6.2" + }, + "cftime-1.6.2-py38h7deecbd_0.conda": { + "build": "py38h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c24fadc40bb776340984a91f94ae56ad", + "name": "cftime", + "sha256": "0cb67e4352a4d2175eb3350f6e517b3daa55996724b05c3651437464b95a84b2", + "size": 277255, + "subdir": "linux-64", + "timestamp": 1678830575912, + "version": "1.6.2" + }, + "cftime-1.6.2-py39h7deecbd_0.conda": { + "build": "py39h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "09a0f3909df30bca02109fa7aa884d1a", + "name": "cftime", + "sha256": "07409e735d9c935bc18896bd43245b37db323b740c87c392a980a88aa610554b", + "size": 269046, + "subdir": "linux-64", + "timestamp": 1678830429451, + "version": "1.6.2" + }, + "cgroupspy-0.2.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1c84ebbe745fae9f9cf7d03746c10ae1", + "name": "cgroupspy", + "sha256": "4edf3b7d5f013607943f48964d30de9dfec05fcae2f285cfb4d4bed2a38e9560", + "size": 30082, + "subdir": "linux-64", + "timestamp": 1659858273842, + "version": "0.2.2" + }, + "cgroupspy-0.2.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7a9900e0864263b11c38b42f4161fcab", + "name": "cgroupspy", + "sha256": "3f41b30fdc5fdad04cb3c15a0dfa2864ebe149fbdf29c59cb71d2cf99350e24f", + "size": 39618, + "subdir": "linux-64", + "timestamp": 1676847288384, + "version": "0.2.2" + }, + "cgroupspy-0.2.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7192de6cef67c9f5bb30512dd37c7cc0", + "name": "cgroupspy", + "sha256": "a194313de57cc8ed312d3b84c38cc84f8083a21a709c05786aa38cd8c2cb563c", + "size": 29709, + "subdir": "linux-64", + "timestamp": 1659858299943, + "version": "0.2.2" + }, + "cgroupspy-0.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f123afb6ae4798d728b4b2c470c3fb02", + "name": "cgroupspy", + "sha256": "b6d047a9c735fe7a5871762cfbe1e723f9dd53e0cab8c53d60a3024670b6d870", + "size": 29705, + "subdir": "linux-64", + "timestamp": 1659858234143, + "version": "0.2.2" + }, + "cgroupspy-0.2.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6bb2e8400a59b6258bcb4bb57e2b2fcf", + "name": "cgroupspy", + "sha256": "a925f3c8f9043578cfc8a3fd9fbeae3d12cbccd063f968d3fae02f349e6781d9", + "size": 29641, + "subdir": "linux-64", + "timestamp": 1659858329359, + "version": "0.2.2" + }, + "chai-1.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fe0d3041057b6faf7e67706d19491b1d", + "name": "chai", + "sha256": "bd6aa1233fdc272ab516e0d273dd63dabd40c6ec3c96e355f6656160c6b9a107", + "size": 40008, + "subdir": "linux-64", + "timestamp": 1530737712703, + "version": "1.1.2" + }, + "chai-1.1.2-py27h6243097_0.conda": { + "build": "py27h6243097_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "20e5ede9280103e6cb21ba2667b4b289", + "name": "chai", + "sha256": "980b005599f59b5c03e6dd7a839ad43b80ced50a84023e1134995d8a42a48f8d", + "size": 39773, + "subdir": "linux-64", + "timestamp": 1505693737803, + "version": "1.1.2" + }, + "chai-1.1.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "745d828bd2528e899b137c2836fca11a", + "name": "chai", + "sha256": "b9505b725942893290b8e964448508c8a71c3221b143492de26446d8d3190780", + "size": 41361, + "subdir": "linux-64", + "timestamp": 1640788975170, + "version": "1.1.2" + }, + "chai-1.1.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1eeba9c612c7c91c0336db2cca08d14f", + "name": "chai", + "sha256": "1f47407e64285a611fa5dded8e24a6a445c8f788bd4173bc46dbda41c5a15a8a", + "size": 52276, + "subdir": "linux-64", + "timestamp": 1676847301930, + "version": "1.1.2" + }, + "chai-1.1.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "655a0c9805f1fee44c4fa77dd257bc05", + "name": "chai", + "sha256": "c613284009d031dbfe06e41abc5bd7177c7fd369412538d98786d3d7cf6456da", + "size": 40872, + "subdir": "linux-64", + "timestamp": 1534352776004, + "version": "1.1.2" + }, + "chai-1.1.2-py35hb5482d5_0.conda": { + "build": "py35hb5482d5_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "82e96d7d86ffd0183a390361ec43e678", + "name": "chai", + "sha256": "fed722599fa95030c01d27784511d66c0106d6875c15c0cd1999653f603be792", + "size": 40693, + "subdir": "linux-64", + "timestamp": 1505693749584, + "version": "1.1.2" + }, + "chai-1.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bfbc609d958412c65dd22e71b63f28a7", + "name": "chai", + "sha256": "722935adb33aa2e47284f89bc9d266c1455c7c226092bfdf0cb08328315b6f77", + "size": 41178, + "subdir": "linux-64", + "timestamp": 1530737691878, + "version": "1.1.2" + }, + "chai-1.1.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3e4e6a481e0a8577456d909f7f5787f0", + "name": "chai", + "sha256": "5a05e61bda2238a556481f32ed3a98aec1d3f6e22d9dff2905947d17e81ee3f5", + "size": 42452, + "subdir": "linux-64", + "timestamp": 1611677541915, + "version": "1.1.2" + }, + "chai-1.1.2-py36hf4a44a8_0.conda": { + "build": "py36hf4a44a8_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "77a3188d8abd00e951b12194e60f75e9", + "name": "chai", + "sha256": "78a8c428decac59363218a8f7d92156f59648ab989530434de31b5839f30e080", + "size": 40979, + "subdir": "linux-64", + "timestamp": 1505693761636, + "version": "1.1.2" + }, + "chai-1.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ce2ca17558a68bcb55c5a74ea4aad971", + "name": "chai", + "sha256": "b3a4675ee0cde9542f12e749247d135652333f74f9b17bfa5431046515599cea", + "size": 40727, + "subdir": "linux-64", + "timestamp": 1530737733850, + "version": "1.1.2" + }, + "chai-1.1.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1d1159bce17a0469708518c15dfb7d65", + "name": "chai", + "sha256": "9891b86c6af8fa1f172a6579e3d2c98e70fc94251da198f800d0720c7ecbb071", + "size": 41939, + "subdir": "linux-64", + "timestamp": 1611677513721, + "version": "1.1.2" + }, + "chai-1.1.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "24be9baa6b0a3cb3b034bc787f6c0be2", + "name": "chai", + "sha256": "28b28fc6431c79b9c246f80c354b59fe8ba88f87f2efa69e34b3176ed555ec41", + "size": 41735, + "subdir": "linux-64", + "timestamp": 1572621590546, + "version": "1.1.2" + }, + "chai-1.1.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ee830feb238a39b6e79874a5eb25337e", + "name": "chai", + "sha256": "dc3cd30805636e3c9856aa2e2e5aa63c9d82f70b508e58a3e4cefeea24b864c3", + "size": 42658, + "subdir": "linux-64", + "timestamp": 1611677542792, + "version": "1.1.2" + }, + "chai-1.1.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "97229ddcfe80623430330b4b3bb1eaff", + "name": "chai", + "sha256": "9f222a37d12cce625e728403470a359005332fe47798e0e0f4ef70e752396be7", + "size": 42405, + "subdir": "linux-64", + "timestamp": 1611677519874, + "version": "1.1.2" + }, + "chainer-2.1.0-py27h229789d_0.conda": { + "build": "py27h229789d_0", + "build_number": 0, + "depends": [ + "filelock", + "mock", + "nose", + "numpy >=1.9.0", + "protobuf >=2.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "7c23294d34278cb9d8c7f9c98569a164", + "name": "chainer", + "sha256": "c983bdcc4049149771fd8d713c0cc839e0a91625464f7e4c93cdda72dea16b2e", + "size": 520483, + "subdir": "linux-64", + "timestamp": 1507580718449, + "version": "2.1.0" + }, + "chainer-2.1.0-py35hca77101_0.conda": { + "build": "py35hca77101_0", + "build_number": 0, + "depends": [ + "filelock", + "mock", + "nose", + "numpy >=1.9.0", + "protobuf >=2.6.0", + "python >=3.5,<3.6.0a0", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "b02679fef48b9bb2adedd84dc4c44615", + "name": "chainer", + "sha256": "86a09e0b6c501e6a4ada1c7a50a672f4bbce9058743cf101bee34ca69707c217", + "size": 521474, + "subdir": "linux-64", + "timestamp": 1507580713032, + "version": "2.1.0" + }, + "chainer-2.1.0-py36hc23aa98_0.conda": { + "build": "py36hc23aa98_0", + "build_number": 0, + "depends": [ + "filelock", + "mock", + "nose", + "numpy >=1.9.0", + "protobuf >=2.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "7c7f9d2dfc7b7af6a32542a52a3606cd", + "name": "chainer", + "sha256": "623930f91e70cb916f4a02bd1d44f356292cbbb5190f5e56c4aaddda0004eb4d", + "size": 525109, + "subdir": "linux-64", + "timestamp": 1507580739679, + "version": "2.1.0" + }, + "chainer-3.1.0-py27h5d1875a_0.conda": { + "build": "py27h5d1875a_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "513cf872ec9cfee5f42af20a1eba1632", + "name": "chainer", + "sha256": "cc09d2a696a5e19ffda5fdd2c4da9b7af7c2f5370d48df63f50de2f0aff48293", + "size": 930726, + "subdir": "linux-64", + "timestamp": 1511676077039, + "version": "3.1.0" + }, + "chainer-3.1.0-py35h1c65560_0.conda": { + "build": "py35h1c65560_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "f0bed165067bf91401a664dcdbc6bbff", + "name": "chainer", + "sha256": "136fd27009ece6dae6fb1f4deb822d638d6b43104df61247ff4591dd62821b36", + "size": 941170, + "subdir": "linux-64", + "timestamp": 1511676099859, + "version": "3.1.0" + }, + "chainer-3.1.0-py36h5dba765_0.conda": { + "build": "py36h5dba765_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "1d98d2958181e2c3a276536889f1f014", + "name": "chainer", + "sha256": "d1f4c9841f6289f81232a4c09633535e1bda2d2926171f7726037f3e9224ecc4", + "size": 929163, + "subdir": "linux-64", + "timestamp": 1511676103326, + "version": "3.1.0" + }, + "chainer-3.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "5cf9a4bf2c0472568faa9a5339f29b30", + "name": "chainer", + "sha256": "519885b330f09f75364585246f2e26f851c264fbcce1f2daf2498c2d3fd76666", + "size": 589620, + "subdir": "linux-64", + "timestamp": 1519252393527, + "version": "3.4.0" + }, + "chainer-3.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "25f0d77ac9a60a46370b97e1648ac2a8", + "name": "chainer", + "sha256": "5d9aa5eeb5bedd54fbb4e7e6ca74e7c9ac322186f11fbf64d51c945f93f8d7f6", + "size": 592811, + "subdir": "linux-64", + "timestamp": 1519252423092, + "version": "3.4.0" + }, + "chainer-3.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "94bb9740b7034cf2462b17335bd26861", + "name": "chainer", + "sha256": "e3502617f42cff12ae7c0b2c1cdf95622d289235eb4d9f3f43e6328a8f7320e9", + "size": 587940, + "subdir": "linux-64", + "timestamp": 1519252396780, + "version": "3.4.0" + }, + "chainer-4.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "83ecd4d59ed68da7fc08d13858bb0abb", + "name": "chainer", + "sha256": "f8797d8cedeaa5298b0eb557ce4fa0088405dc4a26107b2926381f03ac39e94e", + "size": 661662, + "subdir": "linux-64", + "timestamp": 1524107393914, + "version": "4.0.0" + }, + "chainer-4.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "41ffb1e906e8704d3d013ff701a01165", + "name": "chainer", + "sha256": "65c1538f87c3efe0b94948626a3e11712de20eaeb688e4cf33f080dda2bf6f46", + "size": 664323, + "subdir": "linux-64", + "timestamp": 1524107558500, + "version": "4.0.0" + }, + "chainer-4.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "ab9c8aaef9cef057a80decad7e926cf8", + "name": "chainer", + "sha256": "a0cc76c422448907964f68da65f43292adf294bae74a6b02aa242f024732a778", + "size": 668549, + "subdir": "linux-64", + "timestamp": 1524107601340, + "version": "4.0.0" + }, + "chainer-4.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "82a95de8fa1c87a04fdd6768072593e3", + "name": "chainer", + "sha256": "4519b8679753d9ecb3cd8872f1cfeef80cc20ae2e84f3eacc19631cb6219cc9c", + "size": 654942, + "subdir": "linux-64", + "timestamp": 1527697967273, + "version": "4.1.0" + }, + "chainer-4.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "d9c0a3b9d7ca731199d4e4fe1e79dccc", + "name": "chainer", + "sha256": "fa22b4438f9f33b7a255032148760c71d6e054080ba7b5e073b88adb54935357", + "size": 667539, + "subdir": "linux-64", + "timestamp": 1527697995270, + "version": "4.1.0" + }, + "chainer-4.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "f2ab76ab799bf832ec0cccc0866363a8", + "name": "chainer", + "sha256": "f2833671fb9ae0211d519d3885006133772d3ac0f90b3a8c5e7860c8efe25fcb", + "size": 671329, + "subdir": "linux-64", + "timestamp": 1527697953590, + "version": "4.1.0" + }, + "chainer-4.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "ffd6a41e7bdd2876c1fc62891bd6716b", + "name": "chainer", + "sha256": "c49f5eb0870354482b76ecb49861ac3df3576afec1575bb7ad10d5d9e27757c8", + "size": 668555, + "subdir": "linux-64", + "timestamp": 1529952032145, + "version": "4.2.0" + }, + "chainer-4.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "193bef799e1a67848876a2396756f10c", + "name": "chainer", + "sha256": "e79b57a71a1316bf50bb441a720dd3229a029f395cb20eb376cc87564b8c39b1", + "size": 670483, + "subdir": "linux-64", + "timestamp": 1529952059260, + "version": "4.2.0" + }, + "chainer-4.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "e43715f3452d5dd08eb5617e87181293", + "name": "chainer", + "sha256": "6a9da3822885cc0ab2ca3cb01001755398f36d61c1dd48469881b7207ddbd588", + "size": 675005, + "subdir": "linux-64", + "timestamp": 1529952041010, + "version": "4.2.0" + }, + "chainer-4.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "4a6ba748cc20df7cd41149de576577e1", + "name": "chainer", + "sha256": "290316c3f5064910644f97b4d2693a6ea2fa11e8468637296a9333ac2f352427", + "size": 675963, + "subdir": "linux-64", + "timestamp": 1530811940933, + "version": "4.2.0" + }, + "chainer-4.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "0e48e260afd8cbbb83929d3945645257", + "name": "chainer", + "sha256": "40c7ab69b15782701c071e9ee9fbf10dac58212b906510d02207be50777ebe3d", + "size": 660326, + "subdir": "linux-64", + "timestamp": 1534606454491, + "version": "4.3.1" + }, + "chainer-4.3.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "25cd07acfd4954f2ccf721962997d91c", + "name": "chainer", + "sha256": "5aafc2dfd9f1a7ba6cd529e499d44ac1de4f1e862207295ee78a7698765870dc", + "size": 672702, + "subdir": "linux-64", + "timestamp": 1534606495521, + "version": "4.3.1" + }, + "chainer-4.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "1346d4b2bd52b1f734a2e6407ee12be0", + "name": "chainer", + "sha256": "8bdcfa8eeebbf3478225f5608dc0abbc626ce12d9afc61dcea7898c28eeb3591", + "size": 677156, + "subdir": "linux-64", + "timestamp": 1534606448424, + "version": "4.3.1" + }, + "chainer-4.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "823c6cf4c2f63190ca84749da1ca1c7a", + "name": "chainer", + "sha256": "c78c074d179d585b111f0b19a37c14989bfb9d3be2bc814674be507df7499a5c", + "size": 668000, + "subdir": "linux-64", + "timestamp": 1534606491904, + "version": "4.3.1" + }, + "chainer-4.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "b585854b07339f0bbbe5b705e28f2e77", + "name": "chainer", + "sha256": "c683c8f8c75a1ae1a34bf1a9addcd93c38634d0a887f407dded0381e9b8e54f1", + "size": 660697, + "subdir": "linux-64", + "timestamp": 1536108118241, + "version": "4.4.0" + }, + "chainer-4.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "4bcc033f3fe978ae13c260636564735a", + "name": "chainer", + "sha256": "6605847ec9895bc45cbcb99ac846fa4aa179738bca9090a7c6d910a4ec983bd7", + "size": 682876, + "subdir": "linux-64", + "timestamp": 1536108131822, + "version": "4.4.0" + }, + "chainer-4.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "60bfbb213e6dac4747febbc9f11c2e08", + "name": "chainer", + "sha256": "056b390acc7f3144cc079768c28efe3d55a1c8afe2535406d79e4915834baa94", + "size": 667403, + "subdir": "linux-64", + "timestamp": 1536105473880, + "version": "4.4.0" + }, + "chainer-4.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "bffa0758a04c3fcae3dcd95462094b32", + "name": "chainer", + "sha256": "65ba65deae5919e8fb27e3c1e49fbedb7e34464c43287ed1bac44c4c3cd3472c", + "size": 669102, + "subdir": "linux-64", + "timestamp": 1536105457946, + "version": "4.4.0" + }, + "chainer-4.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "b277306159860c0cf799652f3190e232", + "name": "chainer", + "sha256": "a310176a05d4a205cbca91ff56c938075b5661b2932352d8fdfbfeeb71ab2e23", + "size": 662274, + "subdir": "linux-64", + "timestamp": 1539471090873, + "version": "4.5.0" + }, + "chainer-4.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "dd95cf636d2b8f80536d8de4e6e3a858", + "name": "chainer", + "sha256": "3a836467f63dd9d829d89305021652bd11802eb637b922230b3ade32e599d40c", + "size": 678662, + "subdir": "linux-64", + "timestamp": 1539471142687, + "version": "4.5.0" + }, + "chainer-4.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "86237f2f0fdc8772f1245361fac7e442", + "name": "chainer", + "sha256": "1612832f3efb0a8d8ee252c141c41fe800240612516b725b9a8c95871502dd6a", + "size": 669794, + "subdir": "linux-64", + "timestamp": 1539471139734, + "version": "4.5.0" + }, + "chainer-5.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "ee20c59a3f01c411e8efbbedd1279887", + "name": "chainer", + "sha256": "6ae616a00b5327fecfeb19790a52574d1c233444633c1299fe151e7a36f4016c", + "size": 832249, + "subdir": "linux-64", + "timestamp": 1545161909972, + "version": "5.1.0" + }, + "chainer-5.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "a18eff941906777e332552c6e8736504", + "name": "chainer", + "sha256": "f8b949b72fda71ab8857baacbc7141fb5a57a26c0526f4c2c45db809e7443f3e", + "size": 841188, + "subdir": "linux-64", + "timestamp": 1545161960387, + "version": "5.1.0" + }, + "chainer-5.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "f10ce28e3cf206f54a9fe2573e6ee5eb", + "name": "chainer", + "sha256": "55981d580ff195e2c62f01529286349501669daec99a1923437360ca84ae5505", + "size": 853724, + "subdir": "linux-64", + "timestamp": 1545161964777, + "version": "5.1.0" + }, + "chainer-5.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "09654eb6df7e80de27a63e4307c7fc3d", + "name": "chainer", + "sha256": "650505769f7e650a0eb6c19345b9814b2a97d598bb3fd840af1f750381d3ae72", + "size": 979054, + "subdir": "linux-64", + "timestamp": 1550266928787, + "version": "5.2.0" + }, + "chainer-5.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "89ee0d5b3c1284424baf7a1c4a17db4d", + "name": "chainer", + "sha256": "ddda9582980c95dba6e794a93cb8a6ef642f8c00660e86845d9b132df7af9450", + "size": 1000236, + "subdir": "linux-64", + "timestamp": 1550267005505, + "version": "5.2.0" + }, + "chainer-5.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "e8a9ceef7fb5005aeeed35ca341d3fc9", + "name": "chainer", + "sha256": "a3a360d771d58c5b86058cf476805079d3baa3a14a50525663408c64bf93b6c8", + "size": 990075, + "subdir": "linux-64", + "timestamp": 1550266883576, + "version": "5.2.0" + }, + "chainer-5.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "ab6cd0d0e82e26b70bcc532d5baf9b2e", + "name": "chainer", + "sha256": "3876e9ea0a968e54d8bfae2f9988a4819dbe16eef9e8987d1260ee7b67b56ce4", + "size": 984891, + "subdir": "linux-64", + "timestamp": 1552358438673, + "version": "5.3.0" + }, + "chainer-5.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "60bf09e5d6278aeb6ed28404a06be057", + "name": "chainer", + "sha256": "0fa5f7713e75ea1647b401a7dc1f1acbaa3b887fa9bed90c3cc02b4e7cd440fb", + "size": 1006578, + "subdir": "linux-64", + "timestamp": 1552358479384, + "version": "5.3.0" + }, + "chainer-5.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "filelock", + "numpy >=1.9.0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "4dacb50cb3d19645ad8a6cc600b7a074", + "name": "chainer", + "sha256": "663dbbc36ebfb0ea8495d57a0e769380949bb53d90cbb869cf04c1861a935f94", + "size": 1007101, + "subdir": "linux-64", + "timestamp": 1552358459038, + "version": "5.3.0" + }, + "chameleon-3.2-py27h2e5116c_0.conda": { + "build": "py27h2e5116c_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "efde28dc6e74bb188dc2e6e8580cd927", + "name": "chameleon", + "sha256": "75304df314dccb9cb32705bbb0a8ba7527c27b7f9c87e29c521e578525c8bbfd", + "size": 170985, + "subdir": "linux-64", + "timestamp": 1507582208516, + "version": "3.2" + }, + "chameleon-3.2-py35h85e62d6_0.conda": { + "build": "py35h85e62d6_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "a2fc7b488cc62ae53a82d26b2203c9f6", + "name": "chameleon", + "sha256": "51a6759128d3519887d7696dbe2451c538bef607b8a756b1204034e35e039ddc", + "size": 175554, + "subdir": "linux-64", + "timestamp": 1507582211232, + "version": "3.2" + }, + "chameleon-3.2-py36hd22e8fc_0.conda": { + "build": "py36hd22e8fc_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "2c2f4c43bd71a33555bcb0ca739b91e1", + "name": "chameleon", + "sha256": "a2ad2156573e7a2d86a0fb1f7ade20224fd02818aa16b8bffdd1aca8b772089c", + "size": 174162, + "subdir": "linux-64", + "timestamp": 1507582213413, + "version": "3.2" + }, + "chameleon-3.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "35ac785f585db418a77840069b8254f4", + "name": "chameleon", + "sha256": "f024bd5bfa3e1dfe17d15f4401c2a3b4c9c6e7f09da6e67d387553e8e1647ec0", + "size": 171108, + "subdir": "linux-64", + "timestamp": 1527695343832, + "version": "3.3" + }, + "chameleon-3.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "1b05f21a941c065ac060347c3815d8de", + "name": "chameleon", + "sha256": "ddef35cd49226678774773387d17b3fd9b3e23144d1b3f1dd990046f6a3afd73", + "size": 174037, + "subdir": "linux-64", + "timestamp": 1527695368462, + "version": "3.3" + }, + "chameleon-3.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "0391a6935f01e4126fc34f56baf7c064", + "name": "chameleon", + "sha256": "5f68ca4fea3a2f5b052ea3d2372bdab4348175af7b20010a048203feb20ca9bf", + "size": 174333, + "subdir": "linux-64", + "timestamp": 1527695376096, + "version": "3.3" + }, + "chameleon-3.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "54d59a58c2b12075ee317834ae1b87f8", + "name": "chameleon", + "sha256": "3912b421c9ca5944e917830475e6c78cca8e48a641d58b616bed7a4c2a18dac2", + "size": 174243, + "subdir": "linux-64", + "timestamp": 1530811975324, + "version": "3.3" + }, + "chameleon-3.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "f0e19bce80f6e6a66e6bddd7ea23c354", + "name": "chameleon", + "sha256": "8cbbbd7cd64085354fc6dc1a98e9d1ba95f99d50341ee13efecba43794eca685", + "size": 171651, + "subdir": "linux-64", + "timestamp": 1532873018991, + "version": "3.4" + }, + "chameleon-3.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "e84d13778f5131d135d95766b7f4221c", + "name": "chameleon", + "sha256": "19d1566b5cb2f9118e4cae3e57949959103c0d615cf8884e633d4806c655524a", + "size": 176420, + "subdir": "linux-64", + "timestamp": 1532873059980, + "version": "3.4" + }, + "chameleon-3.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "aad291cd98ff77e73f45f86277304125", + "name": "chameleon", + "sha256": "fe5b1c71e8d81f99c52e7968af254668c831afd7d098513769f834d17550f9c5", + "size": 173099, + "subdir": "linux-64", + "timestamp": 1532872977952, + "version": "3.4" + }, + "chameleon-3.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "3eef1ec92145c860936aeebb2fea4d66", + "name": "chameleon", + "sha256": "8b6e9f1f0cd4fbd7118d49f67cf91e98fec523a9c3f4afb45fe2626ba2ee749d", + "size": 173074, + "subdir": "linux-64", + "timestamp": 1532873065809, + "version": "3.4" + }, + "chameleon-3.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "782f5420332b27e7dec1b57e5d5bbaa8", + "name": "chameleon", + "sha256": "c1bc4d81eeb7dfbb2e292bec05e85669ff54b78bff9894b2f975bef0b1cfcf61", + "size": 174072, + "subdir": "linux-64", + "timestamp": 1540962184564, + "version": "3.5" + }, + "chameleon-3.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "c653295072af242a5b5a92f70f36c2c8", + "name": "chameleon", + "sha256": "ecdbd34635f5d9bb3d8283d9f7889a4ad568b20aada195fc0f76f45067ca1868", + "size": 175891, + "subdir": "linux-64", + "timestamp": 1540962152623, + "version": "3.5" + }, + "chameleon-3.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "3303ba42d9b28ae1ffd574e4b5030726", + "name": "chameleon", + "sha256": "f83c848f65d5655c6efa869799253ef055c6d0f934bd364846775590b43ced1d", + "size": 174091, + "subdir": "linux-64", + "timestamp": 1540962195170, + "version": "3.5" + }, + "chameleon-3.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "00fceeb576e988de19c32d0ea78b5f88", + "name": "chameleon", + "sha256": "56c6626b4e868613711a413002920db2b2177efe186c7b54d334761b8f6dc077", + "size": 327807, + "subdir": "linux-64", + "timestamp": 1552359114411, + "version": "3.6" + }, + "chameleon-3.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "90cc4f478d520d9ea195b023614d7803", + "name": "chameleon", + "sha256": "bde6d4b426f9ec2a39a33749e377082a068128f6325f4189b7705f1272f632fa", + "size": 329235, + "subdir": "linux-64", + "timestamp": 1552359110550, + "version": "3.6" + }, + "chameleon-3.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Repoze", + "license_family": "BSD", + "md5": "024e7b1fe05f1d81917ed4f39137d90f", + "name": "chameleon", + "sha256": "277f2715eb639160caaf212194cbba8feb00b23b4aedb3f6bffe767bd695ebfe", + "size": 327826, + "subdir": "linux-64", + "timestamp": 1552359092545, + "version": "3.6" + }, + "characteristic-14.3.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d33c413c1d5a51cc71f14783494a4948", + "name": "characteristic", + "sha256": "d5ec7a8f202fd7ee522aa65a08491dd018c503c1a7f00837a61b28e6281b3681", + "size": 27891, + "subdir": "linux-64", + "timestamp": 1540321205081, + "version": "14.3.0" + }, + "characteristic-14.3.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "29de5851b1c0181d2fa01796b7c72a95", + "name": "characteristic", + "sha256": "b504a21d06fbb57717d384ca33581dd40216a064a4f152cafafa7bb5b28d39b6", + "size": 28781, + "subdir": "linux-64", + "timestamp": 1640788992376, + "version": "14.3.0" + }, + "characteristic-14.3.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1a64ac865b7b4bb19d0da226d69a12c1", + "name": "characteristic", + "sha256": "9ed9de475420333b78e7356e87e1e528706f5bb4079b0083e1a2417376cfec87", + "size": 28687, + "subdir": "linux-64", + "timestamp": 1540321239835, + "version": "14.3.0" + }, + "characteristic-14.3.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d8d8dec8280885a614c93b59c30ec4af", + "name": "characteristic", + "sha256": "2f0a4aa6d9f1b71a97348c48469c915781b2cb33a2c4a162071b16c29014a935", + "size": 28098, + "subdir": "linux-64", + "timestamp": 1613154992415, + "version": "14.3.0" + }, + "characteristic-14.3.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "daa44b6c69a97f331104235137be9f93", + "name": "characteristic", + "sha256": "2794cb41b5fdb65ba73ccb1b09907111ba09de53e3dd8b6fff51c5afabff04e7", + "size": 28295, + "subdir": "linux-64", + "timestamp": 1540321237486, + "version": "14.3.0" + }, + "characteristic-14.3.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4c05c01ab04ecf0eb8a940c6b3f32534", + "name": "characteristic", + "sha256": "94863200a8f3ff8fdcdbbfc5fa8d210b37c23a2f50927147e6d5d44b97712de4", + "size": 28088, + "subdir": "linux-64", + "timestamp": 1613155456912, + "version": "14.3.0" + }, + "characteristic-14.3.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "bac9318d2a49392b35075575abe66856", + "name": "characteristic", + "sha256": "565f903c84999c449b42c2a90d4194fa2749dfa6c8e4c3daaa2733d53845e02f", + "size": 28297, + "subdir": "linux-64", + "timestamp": 1572357193248, + "version": "14.3.0" + }, + "characteristic-14.3.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "cf2bf641aeb3383e8b9dee70b6c58c34", + "name": "characteristic", + "sha256": "a9e1afdf13f0aa2016b9f3375f1b0e66c8a45fdcb641ef1053be2b018fc29fa2", + "size": 28770, + "subdir": "linux-64", + "timestamp": 1613155455049, + "version": "14.3.0" + }, + "chardet-3.0.4-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "116332b72f648a639d869fe6690a8ab8", + "name": "chardet", + "sha256": "2ff5ab8f5e7831570552b3b70b0703c583fd15e62be688bf30175514ae3b7ca7", + "size": 174160, + "subdir": "linux-64", + "timestamp": 1530733536657, + "version": "3.0.4" + }, + "chardet-3.0.4-py27_1003.conda": { + "build": "py27_1003", + "build_number": 1003, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "2d8aa75c473a3f0c4c1a72ed147ee0dc", + "name": "chardet", + "sha256": "d5e7c3733b7e558ea85ab53a8482d7b52cc6d2021546e7baccf1f5136b9dff85", + "size": 174638, + "subdir": "linux-64", + "timestamp": 1564159616672, + "version": "3.0.4" + }, + "chardet-3.0.4-py27hfa10054_1.conda": { + "build": "py27hfa10054_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "d3b02658bd00bc9073b0df50f5e424f5", + "name": "chardet", + "sha256": "f85d7661744426331b6183497ad3ba80a1cb8b6b3fb7755e687287857bc56db5", + "size": 173314, + "subdir": "linux-64", + "timestamp": 1505691573037, + "version": "3.0.4" + }, + "chardet-3.0.4-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "6e3000bfbd7ed8957a5caf9886877049", + "name": "chardet", + "sha256": "edb6e9cb69a261981fe9653828025737803deafe6a8bded877458ae062407b48", + "size": 181845, + "subdir": "linux-64", + "timestamp": 1534350673281, + "version": "3.0.4" + }, + "chardet-3.0.4-py35hb6e9ddf_1.conda": { + "build": "py35hb6e9ddf_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "97997932fcffeb75f3410a5efc2b428a", + "name": "chardet", + "sha256": "f22ad9750b747c6c8bfd0ab1656b17769d8b9734c71d2d518639bb7f22ddc8c4", + "size": 182043, + "subdir": "linux-64", + "timestamp": 1505691587564, + "version": "3.0.4" + }, + "chardet-3.0.4-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "93360ce6096cd034408b3fb32cabd780", + "name": "chardet", + "sha256": "05dbb154ab368305afcfc090861c36c8a5302528efaf8cd3dd468c566e9be550", + "size": 182389, + "subdir": "linux-64", + "timestamp": 1530733513654, + "version": "3.0.4" + }, + "chardet-3.0.4-py36_1003.conda": { + "build": "py36_1003", + "build_number": 1003, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "5d226fcb00a14eec094dede843ef6a76", + "name": "chardet", + "sha256": "766372282296a480ffa144459fe012be56c758ff9208cd8139a8381957fc6b01", + "size": 184043, + "subdir": "linux-64", + "timestamp": 1564159614223, + "version": "3.0.4" + }, + "chardet-3.0.4-py36h06a4308_1003.conda": { + "build": "py36h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "633696db96d04eed8fd2f465a09136a8", + "name": "chardet", + "sha256": "adc841b75122925c6b2705cce976808c0444fc699691feb12c3e1528bc620963", + "size": 184727, + "subdir": "linux-64", + "timestamp": 1605303211592, + "version": "3.0.4" + }, + "chardet-3.0.4-py36h0f667ec_1.conda": { + "build": "py36h0f667ec_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "9f858da985fca0ee4818c92ed2a45bd0", + "name": "chardet", + "sha256": "c2e05e27f7c030edfff67d9ce6d4b7ed3e9e4b30d83df5eaf3e08a097a01cf52", + "size": 182147, + "subdir": "linux-64", + "timestamp": 1505691602341, + "version": "3.0.4" + }, + "chardet-3.0.4-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "6604d6598671724eb7048d4268aa3321", + "name": "chardet", + "sha256": "8fedccffa66b19ad7f259b05bc2f7d593d23e22a1a930a35be4324fce0bfa8ab", + "size": 177307, + "subdir": "linux-64", + "timestamp": 1530733560448, + "version": "3.0.4" + }, + "chardet-3.0.4-py37_1003.conda": { + "build": "py37_1003", + "build_number": 1003, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "02680f0360197c9674931e7f32ba360f", + "name": "chardet", + "sha256": "6d0dc4489d1a37f137434a0d1bf02fda728f39617c364cb11f0b83ad28c12a24", + "size": 178202, + "subdir": "linux-64", + "timestamp": 1564159612371, + "version": "3.0.4" + }, + "chardet-3.0.4-py37h06a4308_1003.conda": { + "build": "py37h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "50b99f90d89e60ec60c169a8b0999101", + "name": "chardet", + "sha256": "1af783dc99b385c6cdbd42d684da13a11e50aa87b7370c3e2fd2541568d2d886", + "size": 179538, + "subdir": "linux-64", + "timestamp": 1605303192201, + "version": "3.0.4" + }, + "chardet-3.0.4-py38_1003.conda": { + "build": "py38_1003", + "build_number": 1003, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "c28b6ec71e01bbe6200d6953f67e4ef4", + "name": "chardet", + "sha256": "a7a53824a7df602d5f458af0b65266ad45346212ba87511c8fae8e7521135a89", + "size": 178280, + "subdir": "linux-64", + "timestamp": 1573033833227, + "version": "3.0.4" + }, + "chardet-3.0.4-py38h06a4308_1003.conda": { + "build": "py38h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "8fbe25c5c5ab9f6d55914843c17654cb", + "name": "chardet", + "sha256": "ad970623ebd0f564d7383ed1ca038cc5105aa54116b195075f815daa73da96b9", + "size": 179660, + "subdir": "linux-64", + "timestamp": 1605303218365, + "version": "3.0.4" + }, + "chardet-3.0.4-py39h06a4308_1003.conda": { + "build": "py39h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "252776ddcd3e5038b1cb0f63577a9da6", + "name": "chardet", + "sha256": "1977a0bbe077fe271ac0b1a423ad64961af2fbc4a7777b38376cd7335510e205", + "size": 178376, + "subdir": "linux-64", + "timestamp": 1605303233050, + "version": "3.0.4" + }, + "chardet-4.0.0-py310h06a4308_1003.conda": { + "build": "py310h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "29ec302e607a23642d21c1ae323757b9", + "name": "chardet", + "sha256": "bba440a7eeda2be19a661b5bc79434cf9923c5e5c3db714b74778a19de7596b4", + "size": 206485, + "subdir": "linux-64", + "timestamp": 1640804906675, + "version": "4.0.0" + }, + "chardet-4.0.0-py311h06a4308_1003.conda": { + "build": "py311h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "6efa6e9b342ac96252eae3e0271ec13f", + "name": "chardet", + "sha256": "907af9cbfd5eb4a87078285c0c59178a8732245f4d8b5ef4eb26256b0a9e8895", + "size": 222732, + "subdir": "linux-64", + "timestamp": 1676830288728, + "version": "4.0.0" + }, + "chardet-4.0.0-py36h06a4308_1003.conda": { + "build": "py36h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "010f15d8bf9b1f95f4845475c57ce80b", + "name": "chardet", + "sha256": "94468c1aaedef4abbedb7e7c4a58945a4a1f7db191c37022922fcf9779a90db3", + "size": 203720, + "subdir": "linux-64", + "timestamp": 1607706773449, + "version": "4.0.0" + }, + "chardet-4.0.0-py37h06a4308_1003.conda": { + "build": "py37h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "68af08280a04e0478088c41311c011c6", + "name": "chardet", + "sha256": "4eab1893fbe4c9d6a248b61098ab7d89b7597770a2a034d86a5167e7912f7161", + "size": 199738, + "subdir": "linux-64", + "timestamp": 1607706803691, + "version": "4.0.0" + }, + "chardet-4.0.0-py38h06a4308_1003.conda": { + "build": "py38h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "a45f3efc4830696e43d55bca0626f750", + "name": "chardet", + "sha256": "07a6c4f03bb9547ba4e99f72a9b7ad45d3e238d7b41c41fa47e67715a20cb240", + "size": 198856, + "subdir": "linux-64", + "timestamp": 1607706782476, + "version": "4.0.0" + }, + "chardet-4.0.0-py39h06a4308_1003.conda": { + "build": "py39h06a4308_1003", + "build_number": 1003, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL2", + "license_family": "GPL", + "md5": "0877ca349e39ca1ed8a716e59e1273a2", + "name": "chardet", + "sha256": "f46e3e9a3536b25ced4a56fa7fadf833fa51beb4e27662967999082935d69d0a", + "size": 198761, + "subdir": "linux-64", + "timestamp": 1607706813216, + "version": "4.0.0" + }, + "charls-2.1.0-he6710b0_2.conda": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cf437750d6e420d3ebff1f1d62980391", + "name": "charls", + "sha256": "7fe2751b7dd020b82035d7c535be32490a28b4433cec2ca609a13729e79c73dc", + "size": 138842, + "subdir": "linux-64", + "timestamp": 1593198212427, + "version": "2.1.0" + }, + "charls-2.2.0-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "abcace262ab5673ba2b89c658b7bc846", + "name": "charls", + "sha256": "f4ed7440c21b469e10b84a6bd5a3bc9a59147526e9b6ec06b51b9d92724db169", + "size": 119911, + "subdir": "linux-64", + "timestamp": 1612240399775, + "version": "2.2.0" + }, + "cheetah-2.4.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "markdown >=2.0.1", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "fa33b6ef8cac7c9c784d7865e4f3055b", + "name": "cheetah", + "sha256": "0198dc45074567d8fea11efdc07811bf3fa592eb9d4968bd3f072e3d030fd3f0", + "size": 266510, + "subdir": "linux-64", + "timestamp": 1535823341542, + "version": "2.4.4" + }, + "cheroot-5.10.0-py27hc35b459_0.conda": { + "build": "py27hc35b459_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6a71446b25ec877020bac0ad9d286604", + "name": "cheroot", + "sha256": "b15701d613a3e1b7cdc6f38fc61dde82e254246b0eda046c22040f7a510fe237", + "size": 95645, + "subdir": "linux-64", + "timestamp": 1511701582644, + "version": "5.10.0" + }, + "cheroot-5.10.0-py35hcddde38_0.conda": { + "build": "py35hcddde38_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3af2b6a655d45ce7549cdb55ae552b8c", + "name": "cheroot", + "sha256": "66d178e0f69769960df041cd952a5c4dc70a57172058e97405c3deb2b7964e73", + "size": 95926, + "subdir": "linux-64", + "timestamp": 1511701586459, + "version": "5.10.0" + }, + "cheroot-5.10.0-py36h87f841d_0.conda": { + "build": "py36h87f841d_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dc2c05fa510838a8ccaf3b64603754cb", + "name": "cheroot", + "sha256": "b9f52ce86b0db0859ae1b5365af3c01d2909a141a2b55df58bcc06952fa33855", + "size": 96553, + "subdir": "linux-64", + "timestamp": 1511701588141, + "version": "5.10.0" + }, + "cheroot-5.8.3-py27hc34bea3_0.conda": { + "build": "py27hc34bea3_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cbcbe8741b347d1aafaf2d7f47ffa3b3", + "name": "cheroot", + "sha256": "6055c124414e2d874d44d3ba47662a268a9c4b5c4d034df4b0e7a450ca6e3139", + "size": 102344, + "subdir": "linux-64", + "timestamp": 1507584175851, + "version": "5.8.3" + }, + "cheroot-5.8.3-py35h0be0224_0.conda": { + "build": "py35h0be0224_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2caa873f7284301c84f8517acca269a1", + "name": "cheroot", + "sha256": "007cdfc9480d400d6aa3fa0d50ec0886792c810ef45fa7012df67925047d55a9", + "size": 102546, + "subdir": "linux-64", + "timestamp": 1507584186533, + "version": "5.8.3" + }, + "cheroot-5.8.3-py36hbe33c39_0.conda": { + "build": "py36hbe33c39_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a1466ade4bd8400af5ef0c9259e1fb22", + "name": "cheroot", + "sha256": "c49fb87f9c4b3b3359f5e1900b574481e4eb99e82f04a96625b76e9d3641a6a5", + "size": 103231, + "subdir": "linux-64", + "timestamp": 1507584180964, + "version": "5.8.3" + }, + "cheroot-6.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fed5ef7f75dd04ad1b6f5500bc6b97c1", + "name": "cheroot", + "sha256": "ce3fada531114fdff8660af0a109f97bdffce61ade067fcf8275af7097425897", + "size": 95553, + "subdir": "linux-64", + "timestamp": 1519019251001, + "version": "6.0.0" + }, + "cheroot-6.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.5,<3.6.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "392bfc50234a77fde7811fc9422b1dcd", + "name": "cheroot", + "sha256": "6386af0a64b0d2b872e7584d21bb4283229c5af905760293f7ccbeab8d7dff8a", + "size": 97432, + "subdir": "linux-64", + "timestamp": 1519019267772, + "version": "6.0.0" + }, + "cheroot-6.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4dcd97a0c8ab996c22385c045185addd", + "name": "cheroot", + "sha256": "bf2ccc25860d44b40711c1f059d75c9457b4156978e05ac36a44f6df747d80ff", + "size": 94886, + "subdir": "linux-64", + "timestamp": 1519019267864, + "version": "6.0.0" + }, + "cheroot-6.2.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "42388ff61bb144ff5434d4bd7cb6f926", + "name": "cheroot", + "sha256": "11034ed54497b3153727edaae72b2f92f46cf633cda8606bc924719379355a4e", + "size": 98230, + "subdir": "linux-64", + "timestamp": 1524082578899, + "version": "6.2.3" + }, + "cheroot-6.2.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.5,<3.6.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e0878c89490752553a9544360026439d", + "name": "cheroot", + "sha256": "ba47b557965679089018fb1bad9cb0427ded89acb74d45155f195e5b0b8a6874", + "size": 101492, + "subdir": "linux-64", + "timestamp": 1524082566249, + "version": "6.2.3" + }, + "cheroot-6.2.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fa171dd5df1b09033cff2b7d93274e59", + "name": "cheroot", + "sha256": "8dadcfddece31733310376019c861d540e148e498de221cca11c839882fd6fab", + "size": 98757, + "subdir": "linux-64", + "timestamp": 1524082576086, + "version": "6.2.3" + }, + "cheroot-6.2.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4750c0aedd7a25d1a932eea1089d7b12", + "name": "cheroot", + "sha256": "60fd8dc00a36a1baaf3c76d7e034d6ddf73dd89e9059b2546ab78cda27e1b116", + "size": 98337, + "subdir": "linux-64", + "timestamp": 1524513705646, + "version": "6.2.4" + }, + "cheroot-6.2.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.5,<3.6.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5ed04748aa1dc9eed91076fdc17d56e7", + "name": "cheroot", + "sha256": "0de6a4554b22458afd1a0896ab602cb38f66cd6805c9682079490a415391da68", + "size": 101488, + "subdir": "linux-64", + "timestamp": 1524513725440, + "version": "6.2.4" + }, + "cheroot-6.2.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9465b4bd92023942ac6c3533fa3533af", + "name": "cheroot", + "sha256": "d309711cf3cc32f4b00c6872e24d993ceba98e9170699dc3821421112efbff9f", + "size": 98723, + "subdir": "linux-64", + "timestamp": 1524513725540, + "version": "6.2.4" + }, + "cheroot-6.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0b7c60ae98a700c6ecb4106c286e99b5", + "name": "cheroot", + "sha256": "ee32d0ec8133fea45b4675014eaff1a0ff15f4d3712a52b7b94a45723f8e19e1", + "size": 106157, + "subdir": "linux-64", + "timestamp": 1526927023715, + "version": "6.3.0" + }, + "cheroot-6.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.5,<3.6.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "37a3389758d171b8362973bf79432059", + "name": "cheroot", + "sha256": "febdbf9e1313078d435509470181cf08d4a40ec302e95a62782af4bd59c920b0", + "size": 105556, + "subdir": "linux-64", + "timestamp": 1526927063434, + "version": "6.3.0" + }, + "cheroot-6.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b338ae308102ca41c8823a4e7790db4c", + "name": "cheroot", + "sha256": "d98c50d5f0998e375c268d59a44c091559667b950113bf1c9bd2f25bd708295f", + "size": 105261, + "subdir": "linux-64", + "timestamp": 1526927014458, + "version": "6.3.0" + }, + "cheroot-6.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c3c4f1ec1ea8485390d781e1b99831a8", + "name": "cheroot", + "sha256": "b8ec5323e1b2f7cf4d22c85f238dec04626dd20c9ae492f7a2e2250599b61980", + "size": 105868, + "subdir": "linux-64", + "timestamp": 1526937290557, + "version": "6.3.1" + }, + "cheroot-6.3.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.5,<3.6.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b05a564ab2ec7a21c1d4a5cdef54445d", + "name": "cheroot", + "sha256": "b0a5630305b95443a876b5a6b388861e3101fc0d35a6fde3fb440af5de054123", + "size": 105483, + "subdir": "linux-64", + "timestamp": 1526937311377, + "version": "6.3.1" + }, + "cheroot-6.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2b73bf8dd382874f11f2be858df97a3d", + "name": "cheroot", + "sha256": "ae976cee223ce1cec8cfc64a304a10542da937ccc42b643593e9bbd8424d720c", + "size": 104427, + "subdir": "linux-64", + "timestamp": 1526937277712, + "version": "6.3.1" + }, + "cheroot-6.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fe490d3e313d788270d897e38ff76c4e", + "name": "cheroot", + "sha256": "2111dda7486fd129658de85e3f0854c442e4ac1660ddfaa1859d8ee7355f1821", + "size": 104511, + "subdir": "linux-64", + "timestamp": 1529437922426, + "version": "6.3.2" + }, + "cheroot-6.3.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.5,<3.6.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f6c6126ddabb5281ba7c7172c4455f02", + "name": "cheroot", + "sha256": "671b23fcf4e0507593a66652ec62753609d04696c614736f35dab2c312a02b0b", + "size": 105659, + "subdir": "linux-64", + "timestamp": 1529438198521, + "version": "6.3.2" + }, + "cheroot-6.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "74b8219b5ea21247a402c1bd007b2fb9", + "name": "cheroot", + "sha256": "f09597592643cb6a3f9c6e744bf42c36580f506960f9ab9afd22fa60a04efab4", + "size": 104715, + "subdir": "linux-64", + "timestamp": 1529438027574, + "version": "6.3.2" + }, + "cheroot-6.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e7757fe5197354ca264347d419f4ab1d", + "name": "cheroot", + "sha256": "786f39d9b552868b568aaa1fe7110d22efbbe279d6a6b725cfe2a1fe3a0c5932", + "size": 104575, + "subdir": "linux-64", + "timestamp": 1530812033596, + "version": "6.3.2" + }, + "cheroot-6.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7d5e01ae01e01574e37ac58e2b782c91", + "name": "cheroot", + "sha256": "5449cad1e0f7689d07ef56662d1713c50dcdf01a72b7458f4e75f7903c0fa7dc", + "size": 105492, + "subdir": "linux-64", + "timestamp": 1534395619548, + "version": "6.4.0" + }, + "cheroot-6.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.5,<3.6.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "61df6c5a6ea9746a14d323f8dcf3e8ea", + "name": "cheroot", + "sha256": "e61e883807c616bef67dba556acfc78a8132ede665a79e6618c247c03ef1b067", + "size": 105107, + "subdir": "linux-64", + "timestamp": 1534395630028, + "version": "6.4.0" + }, + "cheroot-6.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dfcf03f3ac8b07f5593be70a0d02bf04", + "name": "cheroot", + "sha256": "2404d8b573840fe3b477f72ffb988c8e562dde37a81e8d4d2ed52e2e2d28ece9", + "size": 104148, + "subdir": "linux-64", + "timestamp": 1534804132881, + "version": "6.4.0" + }, + "cheroot-6.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "552e1d44d7635d2ab7c5f19af898dc6e", + "name": "cheroot", + "sha256": "e01aeb23582a394e26c30fdfad41ac67a51f2ee90f7da45d869cdb7ce27f0ed1", + "size": 103991, + "subdir": "linux-64", + "timestamp": 1534395631831, + "version": "6.4.0" + }, + "cheroot-6.5.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "539651a75b12ca9301564b416d6f8b23", + "name": "cheroot", + "sha256": "b1e0b60b0eb8c2082f4cbbaf527760934fcd40fe6b0437fd698563fba57eee90", + "size": 128169, + "subdir": "linux-64", + "timestamp": 1539471461870, + "version": "6.5.2" + }, + "cheroot-6.5.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "837551fef96d3fd87c4df8e55a65443f", + "name": "cheroot", + "sha256": "9b5ee3b80dea67a0fe4fa4e458273aa27f6a65e968bb4125c8dff98a51f70437", + "size": 130828, + "subdir": "linux-64", + "timestamp": 1539471483050, + "version": "6.5.2" + }, + "cheroot-6.5.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e1a1a2b2b909af10c08b491948d5a14d", + "name": "cheroot", + "sha256": "bf670bb75f0d31319594d8d624d87786209e42b26ba0a04e5827376e4f53a021", + "size": 129093, + "subdir": "linux-64", + "timestamp": 1539471477703, + "version": "6.5.2" + }, + "cheroot-6.5.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e51c6d138eb1d45a1ae8c168babe4d4c", + "name": "cheroot", + "sha256": "b8d10baba908b1581715fdf65aab231cf9087ca13c838168344d3e6c646b7f1f", + "size": 119711, + "subdir": "linux-64", + "timestamp": 1547224499302, + "version": "6.5.4" + }, + "cheroot-6.5.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a90d5632c76ed4277d8914818530eeee", + "name": "cheroot", + "sha256": "77b1e0cdc30878baf5db8054f96c300dcf305174c1ce9792ef2715468a17cb14", + "size": 122016, + "subdir": "linux-64", + "timestamp": 1547224568349, + "version": "6.5.4" + }, + "cheroot-6.5.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "667c7a05f278b5087653c0ae5aa90dde", + "name": "cheroot", + "sha256": "caa0cce29e7ff9c5f4f73ccc9126da4e173f1f69e6b88936f866f0ff81ca8899", + "size": 119911, + "subdir": "linux-64", + "timestamp": 1547224575038, + "version": "6.5.4" + }, + "cheroot-6.5.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1d42a90f8727ca82e9524baf2acb1458", + "name": "cheroot", + "sha256": "c2bf85f7537d104550c13b531eeadc62f0e197eadbb23f2dc801eddc42315785", + "size": 123142, + "subdir": "linux-64", + "timestamp": 1558556632793, + "version": "6.5.5" + }, + "cheroot-6.5.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d20f77eeb44c0d143618ca49e20bcfc5", + "name": "cheroot", + "sha256": "28b184d942036072ea6ddb96ca6574b41eff4155ab6844788ff586af62eeda3a", + "size": 123751, + "subdir": "linux-64", + "timestamp": 1558556666478, + "version": "6.5.5" + }, + "cheroot-6.5.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d80b900f960d45f70b911c34c31a82e5", + "name": "cheroot", + "sha256": "8c4a8eb734283be86e956c8ca360b2b56d4ade51f3953b75c092cc397b0324a9", + "size": 121743, + "subdir": "linux-64", + "timestamp": 1558556605262, + "version": "6.5.5" + }, + "cheroot-8.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "jaraco.functools", + "more-itertools >=2.6", + "python >=2.7,<2.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "11cccceeda66cea02c50565a5925ffc3", + "name": "cheroot", + "sha256": "bae33fa84e61fe27f8da458566866b09a7d0f898074e651915d9aa21fa5ff2e3", + "size": 128890, + "subdir": "linux-64", + "timestamp": 1574366453439, + "version": "8.2.1" + }, + "cheroot-8.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6b98199243543490ac4d58e9b10c2d7c", + "name": "cheroot", + "sha256": "9095b1f861565d918b150e0db47665179a154f97db485a14f07ed22198f1fb41", + "size": 129490, + "subdir": "linux-64", + "timestamp": 1574366452759, + "version": "8.2.1" + }, + "cheroot-8.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9be0e8b153d7d3c83c7d86ec45b6900f", + "name": "cheroot", + "sha256": "c30d13be4eb7507abe7cfabb1a94ef530ed518c9e3956841f3db57fcc4d845d0", + "size": 129222, + "subdir": "linux-64", + "timestamp": 1574366442419, + "version": "8.2.1" + }, + "cheroot-8.2.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.8,<3.9.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2be3a76a912ae9ee0f0251536aed0256", + "name": "cheroot", + "sha256": "d85bd408bdeebc2cdcd1f55fb8c111a3f7d71b5bbe1676e62351bb7be2f28a83", + "size": 129979, + "subdir": "linux-64", + "timestamp": 1574366595684, + "version": "8.2.1" + }, + "cheroot-8.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0b4c248c99cc0a1fe7d31fb9eab3caa4", + "name": "cheroot", + "sha256": "1377626e115e7d4d154e57e8527fa9a6d8436e3730d3e6bdeafda6e15609b1b6", + "size": 138599, + "subdir": "linux-64", + "timestamp": 1585046518565, + "version": "8.3.0" + }, + "cheroot-8.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "78faf07848ceb7404bddde02b3ae8c46", + "name": "cheroot", + "sha256": "5f5d6ffc6faed734c96b2cf33ecb4fe98cd99e55cf051c10991883579fec2f89", + "size": 138565, + "subdir": "linux-64", + "timestamp": 1585044449596, + "version": "8.3.0" + }, + "cheroot-8.3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.8,<3.9.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ff91796ca4a015a5fab0338c5ec43ab5", + "name": "cheroot", + "sha256": "a00c075f27d84618cc786470445bcdc07cdecfa00a2a2b6b0a46d3027d3b8d82", + "size": 139526, + "subdir": "linux-64", + "timestamp": 1585044463473, + "version": "8.3.0" + }, + "cheroot-8.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5176933466f6ce74255246a90ac6afeb", + "name": "cheroot", + "sha256": "89bdc7d291f85026ceb2e4c048ae724516149e3d8efdb1081205afbe1084c7a6", + "size": 139886, + "subdir": "linux-64", + "timestamp": 1596823968945, + "version": "8.4.2" + }, + "cheroot-8.4.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "86c5a88b2ca9f8dadd1ecf2079160a89", + "name": "cheroot", + "sha256": "fcad854642f93d0567145518376b3bf67d968b487f8935a46e9e6877bf1244fe", + "size": 140420, + "subdir": "linux-64", + "timestamp": 1597684745509, + "version": "8.4.4" + }, + "cheroot-8.4.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "72eda9aef349ab723699a5b4b90dabb7", + "name": "cheroot", + "sha256": "ba75b8ffc3ff95e83d228852e8f0836f350915dd7ad535b75cf75c94078c2046", + "size": 143383, + "subdir": "linux-64", + "timestamp": 1601308725463, + "version": "8.4.5" + }, + "cheroot-8.4.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4fb37c58d07f2370a4a3490b8ab47c56", + "name": "cheroot", + "sha256": "7df9988246068e73d4036e7f35fe45153137bfacff80e2665f0ea2862d233efc", + "size": 141564, + "subdir": "linux-64", + "timestamp": 1601308710721, + "version": "8.4.5" + }, + "cheroot-8.4.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.8,<3.9.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "97aaacf1b87c818911e22959d06894a4", + "name": "cheroot", + "sha256": "ca335babc0dc02f4e8a1c0d577ca410d9fa75e1260989393de4a7c8ce33ae045", + "size": 144149, + "subdir": "linux-64", + "timestamp": 1601308716492, + "version": "8.4.5" + }, + "cheroot-8.4.7-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "270e474341abf5a71a25f0685bc0bb1e", + "name": "cheroot", + "sha256": "400695cadaf874cf764b2eb6ed6d920df1fca479b3415d7d40e2ee2dd4024ec3", + "size": 144001, + "subdir": "linux-64", + "timestamp": 1605995837362, + "version": "8.4.7" + }, + "cheroot-8.4.7-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d31ae29d859f1fe950a75d789e2feed0", + "name": "cheroot", + "sha256": "ecde81fdbe6c5db7ada9b7157dcedaec91a12b3f713b4a2eedc50c888391a8f5", + "size": 142637, + "subdir": "linux-64", + "timestamp": 1605995870571, + "version": "8.4.7" + }, + "cheroot-8.4.7-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.8,<3.9.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0669d794373580f506ad32b94c259fc5", + "name": "cheroot", + "sha256": "068f124e3eee8cf7f060c0b0c527b87ee811bd47ff80b6d4172d4d193b3f4cdc", + "size": 145121, + "subdir": "linux-64", + "timestamp": 1605995830364, + "version": "8.4.7" + }, + "cheroot-8.4.8-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "983662a54ad37499b4dbaed6b4be8f0c", + "name": "cheroot", + "sha256": "7adaa1eef51f980d7ad3f8fa992b0de1083ddc662bf72eb508559a451227d63c", + "size": 145228, + "subdir": "linux-64", + "timestamp": 1606255254149, + "version": "8.4.8" + }, + "cheroot-8.4.8-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "25b8ed21bfd14e6de405a3de16b2b675", + "name": "cheroot", + "sha256": "b2b98ead360eedb8db52cace73671d51be8aa5437b1556edf6390db0aed83b2f", + "size": 145080, + "subdir": "linux-64", + "timestamp": 1606255249696, + "version": "8.4.8" + }, + "cheroot-8.4.8-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.8,<3.9.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f36a2c99116080a527085201d59eac04", + "name": "cheroot", + "sha256": "391d5e68c738f06261c18bfdb8bfce6f12320f4958f015ee1894f4620ad89d43", + "size": 145746, + "subdir": "linux-64", + "timestamp": 1606255281563, + "version": "8.4.8" + }, + "cheroot-8.5.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3e03d591ee8c0d5a2e35d1cf2baaa2ce", + "name": "cheroot", + "sha256": "d9e3ec3f6ab15ddc24783b0deeb115a7a5ef5280bc4dbc4ae3a0019f6ae04778", + "size": 144432, + "subdir": "linux-64", + "timestamp": 1607365788129, + "version": "8.5.0" + }, + "cheroot-8.5.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "32175735811b7362daf311621e99583b", + "name": "cheroot", + "sha256": "cdf5e6c6c95e351c3c5ef26b6dedbfc274114fb551956a032efe646500316ea4", + "size": 145790, + "subdir": "linux-64", + "timestamp": 1607365827327, + "version": "8.5.0" + }, + "cheroot-8.5.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.8,<3.9.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8a56eaf952491663f69c23bbe8a2deef", + "name": "cheroot", + "sha256": "222c94b6cb15d6d958cf7a8ee9d1e0319870df25a2b28b12b536d2b9492c7d7d", + "size": 146744, + "subdir": "linux-64", + "timestamp": 1607365843852, + "version": "8.5.0" + }, + "cheroot-8.5.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "004384bb207d362c02fd7d84f636b2e0", + "name": "cheroot", + "sha256": "12d92615d8e01e0aa53110f23345dfde13c67ac386d4a91d0bf644d2b36e84f2", + "size": 147159, + "subdir": "linux-64", + "timestamp": 1607969234735, + "version": "8.5.1" + }, + "cheroot-8.5.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "219c45cd05be060ddbf9167c5efba384", + "name": "cheroot", + "sha256": "aa40aaa6f930623fe043065afd1fe2cdf8e5018ab1d64e2215da757a31f845f3", + "size": 148180, + "subdir": "linux-64", + "timestamp": 1607969225021, + "version": "8.5.1" + }, + "cheroot-8.5.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.8,<3.9.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f03c0c29c2da3d37215f7e540ba98105", + "name": "cheroot", + "sha256": "90529530d472193d6ae621aaa1f572f1d4226c675668cae1b8ce4a0d1b20c66b", + "size": 147912, + "subdir": "linux-64", + "timestamp": 1607969157869, + "version": "8.5.1" + }, + "cheroot-8.5.2-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.10,<3.11.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ca7fbfad3cdad4e6fc7605af9d8ee2dd", + "name": "cheroot", + "sha256": "c179d2050f052224e56ee5af1a3a04c7f7044948245ba05e0e37ae5ccacb7260", + "size": 151519, + "subdir": "linux-64", + "timestamp": 1642512773690, + "version": "8.5.2" + }, + "cheroot-8.5.2-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.11,<3.12.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7ec297167353818982cf77337162e4e4", + "name": "cheroot", + "sha256": "d0f3a587e99aca4119541802e09b7eaca17145ba6e4cc58f94152b78e826527a", + "size": 195672, + "subdir": "linux-64", + "timestamp": 1676843553621, + "version": "8.5.2" + }, + "cheroot-8.5.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.6,<3.7.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b0d4da70b6d7948f4b875c243965e57a", + "name": "cheroot", + "sha256": "24a2c9b45f29092005b2ece6e765eafe67898cb4b9d3db7ff1b93a72d5238460", + "size": 149454, + "subdir": "linux-64", + "timestamp": 1611596681704, + "version": "8.5.2" + }, + "cheroot-8.5.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.7,<3.8.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9565ca2bfbd2f251608d0bbcdb4cf689", + "name": "cheroot", + "sha256": "b6a2bf93a777ccde4e87127a0bacd18ff90bf0c3ee33ff4d596c8e2ec459accb", + "size": 147158, + "subdir": "linux-64", + "timestamp": 1611595855896, + "version": "8.5.2" + }, + "cheroot-8.5.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.8,<3.9.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aa69b466ae46b7642f8b0d2ca7c86d81", + "name": "cheroot", + "sha256": "44f322a7c1f9e82a305a0e0a1b104ca5431511dac6de548e054bfde33ab3561f", + "size": 148593, + "subdir": "linux-64", + "timestamp": 1611596695373, + "version": "8.5.2" + }, + "cheroot-8.5.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "more-itertools >=2.6", + "python >=3.9,<3.10.0a0", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5379c5b482360396d98e6eef5d120797", + "name": "cheroot", + "sha256": "11572daf36da5ae10afb16413e80bbf77c6e7ae03454fd31223d3407239c06f0", + "size": 150106, + "subdir": "linux-64", + "timestamp": 1611596695382, + "version": "8.5.2" + }, + "cherrypy-11.0.0-py27h05564f0_0.conda": { + "build": "py27h05564f0_0", + "build_number": 0, + "depends": [ + "cheroot >=5.8.3", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3ca83a1f42ed2ddd37f1a8d891a6d702", + "name": "cherrypy", + "sha256": "5679c25afa24b6879d388d660b4ed4638653f5e54916519bd7cea95cd7ffcc9d", + "size": 544003, + "subdir": "linux-64", + "timestamp": 1507586943067, + "version": "11.0.0" + }, + "cherrypy-11.0.0-py35hf2b23f5_0.conda": { + "build": "py35hf2b23f5_0", + "build_number": 0, + "depends": [ + "cheroot >=5.8.3", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "88cd4bc1824f4afc787e16ebc1127d76", + "name": "cherrypy", + "sha256": "4251c4ed86cb2705eb4aaf7a81d26c52ee1d771b6aa7ad54d66462768db0d033", + "size": 545370, + "subdir": "linux-64", + "timestamp": 1507586949445, + "version": "11.0.0" + }, + "cherrypy-11.0.0-py36h0635bd1_0.conda": { + "build": "py36h0635bd1_0", + "build_number": 0, + "depends": [ + "cheroot >=5.8.3", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5c1c10a66b86b9f0256f85e56bf33138", + "name": "cherrypy", + "sha256": "22ed8c5f9208adbb621fb568766251f357bf4a0d39e5ba37949121577280c55d", + "size": 541569, + "subdir": "linux-64", + "timestamp": 1507586952205, + "version": "11.0.0" + }, + "cherrypy-12.0.1-py27h0f69e9d_0.conda": { + "build": "py27h0f69e9d_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "jaraco.classes", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cc3460f1501616c7893c67ad24d0353f", + "name": "cherrypy", + "sha256": "44234b688aaf3772367d951136277b9f5ceec806d4e0e5298f71f3b7dc441422", + "size": 531253, + "subdir": "linux-64", + "timestamp": 1511705282317, + "version": "12.0.1" + }, + "cherrypy-12.0.1-py35h41829b4_0.conda": { + "build": "py35h41829b4_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "jaraco.classes", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d5b2bc28e63b9e1337a3f863733547ff", + "name": "cherrypy", + "sha256": "291fac2f4501b66569973aa26925c51ea0d896dfc4f8c9e85afab639105f5f7b", + "size": 537134, + "subdir": "linux-64", + "timestamp": 1511705283441, + "version": "12.0.1" + }, + "cherrypy-12.0.1-py36h952b05f_0.conda": { + "build": "py36h952b05f_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "jaraco.classes", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c9f0d7e15eb122dd464c5ab7449c47ea", + "name": "cherrypy", + "sha256": "4c7133b83d0534cfc48192569c3724c5663873835bdd7590781a9e03351d2410", + "size": 539345, + "subdir": "linux-64", + "timestamp": 1511705288409, + "version": "12.0.1" + }, + "cherrypy-13.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "jaraco.classes", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7ebf41552451baaab70079ad3af86394", + "name": "cherrypy", + "sha256": "96200880715cf6fc8b8cd0f48ddbddda35629666a57829e858874e155f878f27", + "size": 536828, + "subdir": "linux-64", + "timestamp": 1516981344092, + "version": "13.1.0" + }, + "cherrypy-13.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "jaraco.classes", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8f58cd01f79051c02cdabf910896a7fd", + "name": "cherrypy", + "sha256": "b8eb7c5ab0955064a7255c9c107164bb2cc82e4b68916a68e6290dc302ee5d9d", + "size": 537394, + "subdir": "linux-64", + "timestamp": 1516981370157, + "version": "13.1.0" + }, + "cherrypy-13.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "jaraco.classes", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a786551335f5ad37823adb7b54f4b564", + "name": "cherrypy", + "sha256": "d36008970fe4d574bff27e058e35e0f88f557cc0e338a4ec92540c4bf9e8fce4", + "size": 534040, + "subdir": "linux-64", + "timestamp": 1516981373255, + "version": "13.1.0" + }, + "cherrypy-14.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "47bfb0eb9ff837ab89b5f247ec7ea83e", + "name": "cherrypy", + "sha256": "d7ff27913bb3b73061cc416d001701997df4f9f295ab1c76881468c599908e6b", + "size": 537524, + "subdir": "linux-64", + "timestamp": 1519016532665, + "version": "14.0.0" + }, + "cherrypy-14.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "11f0e313a271ffaa50d45e06466b0329", + "name": "cherrypy", + "sha256": "511d2625fbb25f215b78ff5c4dd8f8194fa5ff332ca7ec07ed938e53e6ef9527", + "size": 538624, + "subdir": "linux-64", + "timestamp": 1519016549945, + "version": "14.0.0" + }, + "cherrypy-14.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7c86aaacbda8ac6d016e97c38a3dcb3f", + "name": "cherrypy", + "sha256": "dbec7cc452e072e9778a8cde670786d5043365dfef9fb5f7295a30014bf53586", + "size": 540838, + "subdir": "linux-64", + "timestamp": 1519016548296, + "version": "14.0.0" + }, + "cherrypy-14.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "69575ce3185045a8adb59fb6b98bac70", + "name": "cherrypy", + "sha256": "5a93748645c04356a3caaae283b795003316af553580997f974e218fb9669d51", + "size": 537797, + "subdir": "linux-64", + "timestamp": 1522714461833, + "version": "14.0.1" + }, + "cherrypy-14.0.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b1ba59c4d93d0cfcb5a0c2b0d1b3de8f", + "name": "cherrypy", + "sha256": "21c2ee311906f9329637933d2e38487e5dd40cea7d1a2c262335d369f5095c5c", + "size": 538894, + "subdir": "linux-64", + "timestamp": 1522715119957, + "version": "14.0.1" + }, + "cherrypy-14.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=5.9.1", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bb55da3ac069b7ee8e767d9aa9d09cb0", + "name": "cherrypy", + "sha256": "f236cbcae7d41b61236b9b39da90919ec343a4e095c024d5b0f12edf817a84a4", + "size": 541217, + "subdir": "linux-64", + "timestamp": 1522715119432, + "version": "14.0.1" + }, + "cherrypy-14.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b36ebf50b0edaa432b4349ca0cccba73", + "name": "cherrypy", + "sha256": "af6af1d296fd486f0f743ebbaddfe366583ec6ce3e7676594287b663fa503ac1", + "size": 533550, + "subdir": "linux-64", + "timestamp": 1524520109920, + "version": "14.2.0" + }, + "cherrypy-14.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8369969c7dc3094f93d0b0e6d7516599", + "name": "cherrypy", + "sha256": "c10d8db50d23eaa4041b9980cdf67373c2dce47fc627c87827a9ab277a3f6f29", + "size": 545620, + "subdir": "linux-64", + "timestamp": 1524520264926, + "version": "14.2.0" + }, + "cherrypy-14.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9cfaed3f9f0977461a7778f0715408ff", + "name": "cherrypy", + "sha256": "8343012902ba85f31466c1050c260a17f038d6a917cc14c85ee14395a2eb797f", + "size": 536524, + "subdir": "linux-64", + "timestamp": 1524520264927, + "version": "14.2.0" + }, + "cherrypy-15.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2e6a7526b4e86283be663651fbfa7afd", + "name": "cherrypy", + "sha256": "93cd67e874f9874a2d491105efcc6833c0c5e795b59e6f42160f4700c6205b44", + "size": 543864, + "subdir": "linux-64", + "timestamp": 1526927170064, + "version": "15.0.0" + }, + "cherrypy-15.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "346c87ba2f47d99469287246b6da7d91", + "name": "cherrypy", + "sha256": "ab2d1585b1c17683f4ee6bb241d71f4be8ef0a345d0fb4805ceff6bf3c426728", + "size": 544189, + "subdir": "linux-64", + "timestamp": 1526927223597, + "version": "15.0.0" + }, + "cherrypy-15.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7378c3acf5fde2b6f0ef7a19f3e6c930", + "name": "cherrypy", + "sha256": "3bb0febef73df654388d42af1d3325281223ca38f93acd3b7464067e7d800631", + "size": 547344, + "subdir": "linux-64", + "timestamp": 1526927162214, + "version": "15.0.0" + }, + "cherrypy-16.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f5cf0d9f02a41854d6b01ff0e3703ab0", + "name": "cherrypy", + "sha256": "0c0254f15c07cf214d4949f702b16a5e635edd48dd5bb8d7ea84975fd8b39b04", + "size": 533613, + "subdir": "linux-64", + "timestamp": 1529417897044, + "version": "16.0.2" + }, + "cherrypy-16.0.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1c86225e6220fcacd32dca0de8cf59d2", + "name": "cherrypy", + "sha256": "10136e8bbc87d3840d56e426d7e46d7a91b998f4546476a98e93dea7b3f949b8", + "size": 538966, + "subdir": "linux-64", + "timestamp": 1529417918690, + "version": "16.0.2" + }, + "cherrypy-16.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "768a25f0477996760ee5f3246734cb07", + "name": "cherrypy", + "sha256": "275d1c4769ad75773ff9f4c587b250fafda4ca881358e4bf9c583308257344be", + "size": 541263, + "subdir": "linux-64", + "timestamp": 1529417879105, + "version": "16.0.2" + }, + "cherrypy-16.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0a79d8524aaa1708cd90764837e4eaa1", + "name": "cherrypy", + "sha256": "903620a1f9b5b7e72f79703efb6f3d458828d1efa60b5a54601e41d232135847", + "size": 535042, + "subdir": "linux-64", + "timestamp": 1530812121706, + "version": "16.0.2" + }, + "cherrypy-17.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a913bc9d9d851aec0edc07dacc16f006", + "name": "cherrypy", + "sha256": "932591846c9e63a48d3df29b65431188ef8447aad0a6ee41274f5b3e3d483984", + "size": 538085, + "subdir": "linux-64", + "timestamp": 1533042198115, + "version": "17.0.0" + }, + "cherrypy-17.0.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "300b1c85f01cd9d9241c064106b92287", + "name": "cherrypy", + "sha256": "0c2e3023d93da9bad601e2839d241bd91dc4580d0eaac32a59402f067d7a21d9", + "size": 538189, + "subdir": "linux-64", + "timestamp": 1535129906190, + "version": "17.0.0" + }, + "cherrypy-17.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f773b9f6218f05afc55a31ae6feeb4d9", + "name": "cherrypy", + "sha256": "16da8eae69b3302ef93625bb1e966203511b199b3ba8ad973ae5cbdddf3b50f4", + "size": 540019, + "subdir": "linux-64", + "timestamp": 1533042217866, + "version": "17.0.0" + }, + "cherrypy-17.0.0-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f4e9a959676e523261ceefda031ab3e1", + "name": "cherrypy", + "sha256": "3cc1ac1cda1971896004dd1b3e47ae71087c5cc4c5d2cdc5477035ad45c70ff3", + "size": 544810, + "subdir": "linux-64", + "timestamp": 1535129939559, + "version": "17.0.0" + }, + "cherrypy-17.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0e2b359df3d4b51d8f813e5b68d88de5", + "name": "cherrypy", + "sha256": "9ef8fb2e6e083340b2ce5761d65a43711535d9ec53972702c57ae59b07059ebb", + "size": 535252, + "subdir": "linux-64", + "timestamp": 1533042160581, + "version": "17.0.0" + }, + "cherrypy-17.0.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "176e8a6628ec03b3f3d4132792017427", + "name": "cherrypy", + "sha256": "4925803a5340e964de3818c0c210d45d847d28cbec328389b9f51b8cc1c08ad2", + "size": 540884, + "subdir": "linux-64", + "timestamp": 1535129973763, + "version": "17.0.0" + }, + "cherrypy-17.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ad4a7fde355ed97588606713ac01e3c8", + "name": "cherrypy", + "sha256": "3f897f3c47d0822d814a03703263f5b4cce52c17edd65f324bb90d62b7678fb4", + "size": 541577, + "subdir": "linux-64", + "timestamp": 1533042238210, + "version": "17.0.0" + }, + "cherrypy-17.0.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "portend >=2.1.1", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "da39dc1d7fb795d4dfa5e66db4fbd2f9", + "name": "cherrypy", + "sha256": "b227dd9ad8e5264685570be49a3b33cca1aa70eca56fd28da17dbc91a19ea81d", + "size": 535321, + "subdir": "linux-64", + "timestamp": 1535129876050, + "version": "17.0.0" + }, + "cherrypy-17.3.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a2be8f8b1a837fc700e08a2ee0bc70d8", + "name": "cherrypy", + "sha256": "aa6c91dac623082388624b1fb0801798d188160975dd368ce05fb038ca2eb35d", + "size": 526300, + "subdir": "linux-64", + "timestamp": 1535301197039, + "version": "17.3.0" + }, + "cherrypy-17.3.0-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.5,<3.6.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6e8f2a54c3e6a7ba8bbfe12a25eba566", + "name": "cherrypy", + "sha256": "f23265a92d43cb14db3632723d6943af5d08675353d9b0a7f209f478fd2ba462", + "size": 538853, + "subdir": "linux-64", + "timestamp": 1535301241313, + "version": "17.3.0" + }, + "cherrypy-17.3.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ff44a67aad879650a95f9aa537613c63", + "name": "cherrypy", + "sha256": "048e5930f65691a6cc9efd891bfcbed8beb68945002bb0ffc602ed3af3d98cdc", + "size": 535475, + "subdir": "linux-64", + "timestamp": 1535301176024, + "version": "17.3.0" + }, + "cherrypy-17.3.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b1837044339f24b9ccaf6e01063df25c", + "name": "cherrypy", + "sha256": "fcb4d38f90aa5f412536a615a213f4b1e859563b81051c31ab95a9b2708baec1", + "size": 535062, + "subdir": "linux-64", + "timestamp": 1535301219352, + "version": "17.3.0" + }, + "cherrypy-18.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.5,<3.6.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e68ff3f88f25d761e29f8f799b93f646", + "name": "cherrypy", + "sha256": "c2cbe0caaa4f29c986747184792c2c8ecc163587f732020e24131f2f3950947a", + "size": 538684, + "subdir": "linux-64", + "timestamp": 1536109270615, + "version": "18.0.0" + }, + "cherrypy-18.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8217fb13ccfe33fdd2dad5cc7b1058c3", + "name": "cherrypy", + "sha256": "8783e3c6bffe4dec774aee22263717d3b3aabe2e7091ad6376670895d33074b0", + "size": 529279, + "subdir": "linux-64", + "timestamp": 1536109232616, + "version": "18.0.0" + }, + "cherrypy-18.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e367b3c1c95568cff24db1f9eb1eebaa", + "name": "cherrypy", + "sha256": "5c7e9728b80d567104488089120d4a5256e923bff7bc75d51ac3615d4c0f45c6", + "size": 529006, + "subdir": "linux-64", + "timestamp": 1536109285532, + "version": "18.0.0" + }, + "cherrypy-18.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f1d3acb9a4cdfdd5ee4bfa312a1d462d", + "name": "cherrypy", + "sha256": "0a4b9e0f3c776b592d7d8ead16a10420df75a2f813ab079bccc3c1e0473f0955", + "size": 531237, + "subdir": "linux-64", + "timestamp": 1538175065370, + "version": "18.0.1" + }, + "cherrypy-18.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7b15f3a26e9525eca5ff5f6f724027c7", + "name": "cherrypy", + "sha256": "a7c72947d44ace319139304133fbb45b88aaf7cc8e25b3b2f1193189d8ba3155", + "size": 530613, + "subdir": "linux-64", + "timestamp": 1538175054945, + "version": "18.0.1" + }, + "cherrypy-18.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4442f3ac66d70c89b59486a69b0493ab", + "name": "cherrypy", + "sha256": "027f4f6f6cfb6bc2880060d60cb826127ec13b00684ec12d9b772ce8144e53f6", + "size": 525140, + "subdir": "linux-64", + "timestamp": 1545103709421, + "version": "18.1.0" + }, + "cherrypy-18.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e38e3df18779f742a7cd00f36ce0733a", + "name": "cherrypy", + "sha256": "8ca4c0a776e5af0dd5c57cb172f780ad662ca17b075fb07904d826f4fdd29f94", + "size": 530087, + "subdir": "linux-64", + "timestamp": 1545103697506, + "version": "18.1.0" + }, + "cherrypy-18.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "50116c3bf3db440c861c2cc53d05bc22", + "name": "cherrypy", + "sha256": "02aaf6e9d88ce0638449cd97852a25ede6c9b5d27f4ff8a8efac6d4dccc89e33", + "size": 534030, + "subdir": "linux-64", + "timestamp": 1556063278934, + "version": "18.1.1" + }, + "cherrypy-18.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "contextlib2", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "six >=1.11.0", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "afa602a2bf6d0aacfc3a38450f09d08a", + "name": "cherrypy", + "sha256": "77a1057d6a8b67c299797f44bb788e1a3fd6aac0a9d2f2368b80bd0be287a92f", + "size": 539697, + "subdir": "linux-64", + "timestamp": 1556063376794, + "version": "18.1.1" + }, + "cherrypy-18.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3f70a49a801942fa836fedb8a45e19bf", + "name": "cherrypy", + "sha256": "ccae11e9b463c6a80d03a62708b92dc7816740142297982aeb1dd3613ffb296b", + "size": 539547, + "subdir": "linux-64", + "timestamp": 1569355309673, + "version": "18.2.0" + }, + "cherrypy-18.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8f81e916a5651ea4ec7be09bfc12412b", + "name": "cherrypy", + "sha256": "810497fc6467b626e20cfb560ee55ee6660bd033d138ff435a6f6687c08954ac", + "size": 538907, + "subdir": "linux-64", + "timestamp": 1569355313431, + "version": "18.2.0" + }, + "cherrypy-18.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cheroot >=6.2.4", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4f84f1a8b3991b976253e37f3e4f1101", + "name": "cherrypy", + "sha256": "644d53bb8eef102d9af2f130d7d9382fc22f2d21bdafb2e8327f608513e7f2d1", + "size": 537348, + "subdir": "linux-64", + "timestamp": 1574182307880, + "version": "18.2.0" + }, + "cherrypy-18.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b415be582b19866713b09674a5eb5bdb", + "name": "cherrypy", + "sha256": "d4680d6bfb3212768ca49c2e28210b7a27cca1b18d77cd39f7a031e6b9574614", + "size": 540301, + "subdir": "linux-64", + "timestamp": 1574366701685, + "version": "18.4.0" + }, + "cherrypy-18.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aa04f99005d7451b494c5c1752ed61b5", + "name": "cherrypy", + "sha256": "a2af1ef8f301cb608a80a5fc76f6b9d2ed20a44f50ba88f9c8deb2bbd3cfcab5", + "size": 541772, + "subdir": "linux-64", + "timestamp": 1574366695145, + "version": "18.4.0" + }, + "cherrypy-18.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e98282a2ade04bbf65529ab5e2f183b8", + "name": "cherrypy", + "sha256": "f0b4c355462221519dcd44b694fd438b921ba48c2a5a1e738b916a3db3d9bbfd", + "size": 542240, + "subdir": "linux-64", + "timestamp": 1574366807393, + "version": "18.4.0" + }, + "cherrypy-18.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5794c9aa576512dae488cc607e40e4a4", + "name": "cherrypy", + "sha256": "f938cd79f101620d55ffc0ef2457d7b65ce03af4eef09b697b399ecd88fc96d5", + "size": 541871, + "subdir": "linux-64", + "timestamp": 1585062029167, + "version": "18.5.0" + }, + "cherrypy-18.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "41be52d55c2a49ad81d16b80c8860fc2", + "name": "cherrypy", + "sha256": "a80de79ad1f7976c2114c4b6149ec894a843d210ded20c3ee227998c46c3ee80", + "size": 541438, + "subdir": "linux-64", + "timestamp": 1585062034939, + "version": "18.5.0" + }, + "cherrypy-18.5.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1ab341caa6ec20fc4cbb94c3c1dc6a87", + "name": "cherrypy", + "sha256": "d62487cf1a8e6169280afde179cb695fc27f05691f93b246ed21770bb3225fd6", + "size": 544033, + "subdir": "linux-64", + "timestamp": 1585062032195, + "version": "18.5.0" + }, + "cherrypy-18.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.10,<3.11.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bc35377c24075c8f34bd80e7f2ac58f0", + "name": "cherrypy", + "sha256": "42066ffe686402310ec02ef4545e13eb7d7bc1e2669d3b00aaaf9eb372e7cdab", + "size": 541918, + "subdir": "linux-64", + "timestamp": 1640789053832, + "version": "18.6.0" + }, + "cherrypy-18.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "27b5569da67f054b684085d5bf186cb8", + "name": "cherrypy", + "sha256": "082b32d3c8f590176f0d4540c92a9ab321f328c9166ac112983301048a77bcf8", + "size": 537272, + "subdir": "linux-64", + "timestamp": 1588080779185, + "version": "18.6.0" + }, + "cherrypy-18.6.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e138ec0c96999c29b9dff692fdcb3eda", + "name": "cherrypy", + "sha256": "3e2c1ff77cd7332165bd0c74ec08180df6dd9705678b8741658d52549276c4e1", + "size": 543746, + "subdir": "linux-64", + "timestamp": 1614257639375, + "version": "18.6.0" + }, + "cherrypy-18.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bef598c543e3515a289848bda15ee896", + "name": "cherrypy", + "sha256": "a26aad99d04d8dc20aec13c6d2461e46f69f1317b4ca08897f9c4af7c13d9504", + "size": 536616, + "subdir": "linux-64", + "timestamp": 1588080889281, + "version": "18.6.0" + }, + "cherrypy-18.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b8836c0dc313c9c6319c9ce536ffd593", + "name": "cherrypy", + "sha256": "76178ccf4f776267aa3dc7bb1f256f480fb01e99a20d430ae0ca667d35de4f4e", + "size": 541953, + "subdir": "linux-64", + "timestamp": 1614257632444, + "version": "18.6.0" + }, + "cherrypy-18.6.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9ba0b0e88b62f8b3107553ef40498682", + "name": "cherrypy", + "sha256": "e4fedb16158969de4576161a59abc2b826ca1ed1ef6fa36c6adb78e1d4918cff", + "size": 545957, + "subdir": "linux-64", + "timestamp": 1588080365213, + "version": "18.6.0" + }, + "cherrypy-18.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cdcab436922264d9ec74177f85a34021", + "name": "cherrypy", + "sha256": "ec15c1b3b48eed598a9586eea5eb3ed9cec680e8314358836b801d177fc7783d", + "size": 538169, + "subdir": "linux-64", + "timestamp": 1614257619312, + "version": "18.6.0" + }, + "cherrypy-18.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.9,<3.10.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "141fe8ff01ebc4c46ded9e6dfbfec6a3", + "name": "cherrypy", + "sha256": "c13b51cdb344dbe02b7af1b895711dab0d52d349d0b6d4a70f758985cc9f6cac", + "size": 543766, + "subdir": "linux-64", + "timestamp": 1632880794513, + "version": "18.6.0" + }, + "cherrypy-18.8.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.10,<3.11.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "af9f16a44e47cbb31edf7f5b7e66ed4b", + "name": "cherrypy", + "sha256": "27758a4542bfc21e0d57718b0ee815319619dfba7f342238e32175b3c58cb381", + "size": 499762, + "subdir": "linux-64", + "timestamp": 1677013089859, + "version": "18.8.0" + }, + "cherrypy-18.8.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.11,<3.12.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7581ee7e04ed6371ab759d937c3bff2d", + "name": "cherrypy", + "sha256": "4e140d5c23d9707fab73d114420af1e180f550b1dcc191560e5dfa323bc46ed8", + "size": 609699, + "subdir": "linux-64", + "timestamp": 1677014153244, + "version": "18.8.0" + }, + "cherrypy-18.8.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d07ce0d4a47728c6d54fc120d00dc613", + "name": "cherrypy", + "sha256": "501b2cec280880ad86741a873856983f35f5d954e72d961bbf6bdedaf3c63993", + "size": 492218, + "subdir": "linux-64", + "timestamp": 1677013055183, + "version": "18.8.0" + }, + "cherrypy-18.8.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "69b8b4ad186df7770fe675a18fd481b1", + "name": "cherrypy", + "sha256": "d2a800d4cbbd9b3867f41cdb23bb008466274ef95660390a14bd36036475a19e", + "size": 494629, + "subdir": "linux-64", + "timestamp": 1677013119471, + "version": "18.8.0" + }, + "cherrypy-18.8.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cheroot >=8.2.1", + "jaraco.collections", + "more-itertools", + "portend >=2.1.1", + "pyopenssl", + "python >=3.9,<3.10.0a0", + "routes >=2.3.1", + "simplejson", + "zc.lockfile" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f7585011c0d15203649682ea68128fc1", + "name": "cherrypy", + "sha256": "e1847e18ad3b26d97b1531cc2f895047653e117bd71cc6edfc46494f7993ea84", + "size": 494401, + "subdir": "linux-64", + "timestamp": 1677013018375, + "version": "18.8.0" + }, + "chest-0.2.3-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "heapdict", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "91761be849e2e3550f32d3ed538410e3", + "name": "chest", + "sha256": "f59b3dfbec8c365d27937a2416582a58c466b632182bf9a14561c5420427d096", + "size": 15202, + "subdir": "linux-64", + "timestamp": 1537197814645, + "version": "0.2.3" + }, + "chest-0.2.3-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "heapdict", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b2316c07f95a2905005720935c7d5d2c", + "name": "chest", + "sha256": "b20cba8493c0c0b9d1d4b11d37c4b231f401e4821c086e48b88d29a9872019e6", + "size": 15593, + "subdir": "linux-64", + "timestamp": 1537197835075, + "version": "0.2.3" + }, + "chest-0.2.3-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "heapdict", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0de25c0a3c0604afa5f991a484150534", + "name": "chest", + "sha256": "af229408c31d29b615091b33789f1671c72fd921249059b5c00ef8ab19a89d64", + "size": 15331, + "subdir": "linux-64", + "timestamp": 1537197837382, + "version": "0.2.3" + }, + "chest-0.2.3-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "heapdict", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "796542b1a6de6d2ec22118d5da9b3fcb", + "name": "chest", + "sha256": "33ceb8150b4e3a7d141fd77b548539e3fd8cc30e6d3d0972279ff9b926775707", + "size": 15405, + "subdir": "linux-64", + "timestamp": 1537197789220, + "version": "0.2.3" + }, + "chex-0.1.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.9.0", + "dm-tree >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.21,<2", + "python >=3.10,<3.11.0a0", + "toolz >=0.9.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "085297a93e8f1492d61f92cf96c842a5", + "name": "chex", + "sha256": "955c2b4412b36938038714ce85fd566145c6c848046ea048cfec567af87c188e", + "size": 145341, + "subdir": "linux-64", + "timestamp": 1670000795955, + "version": "0.1.5" + }, + "chex-0.1.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.9.0", + "dm-tree >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.21,<2", + "python >=3.11,<3.12.0a0", + "toolz >=0.9.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "43e7a1f23ea66adcff60201a83aed91a", + "name": "chex", + "sha256": "540e2642e5f9ee22339879bd1d7dbd4fc5b1e21a1df97ff23973f97c097f71b9", + "size": 186681, + "subdir": "linux-64", + "timestamp": 1676843568349, + "version": "0.1.5" + }, + "chex-0.1.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.9.0", + "dm-tree >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.20,<2", + "python >=3.7,<3.8.0a0", + "toolz >=0.9.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a10c436220dcbfe46708b0471f7c6ed7", + "name": "chex", + "sha256": "e1c9fdca5edecbdddeb1341e62269ad3110be4fa606f100eb256c3107ff8ebd9", + "size": 141163, + "subdir": "linux-64", + "timestamp": 1670000857248, + "version": "0.1.5" + }, + "chex-0.1.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.9.0", + "dm-tree >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.20,<2", + "python >=3.8,<3.9.0a0", + "toolz >=0.9.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1043be08435615fc9d5e167a047cc922", + "name": "chex", + "sha256": "1c6dc10a16b21b9781bbf5ffd2516563c5cbc0cdf39097f408a929959bbecef0", + "size": 142534, + "subdir": "linux-64", + "timestamp": 1670000826879, + "version": "0.1.5" + }, + "chex-0.1.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.9.0", + "dm-tree >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.20,<2", + "python >=3.9,<3.10.0a0", + "toolz >=0.9.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ecc7b83f7a299299b591bc13a8943b29", + "name": "chex", + "sha256": "230b22238a3d7ea4a935a65b4589e109b6ec86a28c6f176c3f1183d686190a1e", + "size": 143388, + "subdir": "linux-64", + "timestamp": 1670000763073, + "version": "0.1.5" + }, + "chromedriver-binary-2.38-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "md5": "52ce34967ef9b984260d26fe4c52a730", + "name": "chromedriver-binary", + "sha256": "8c6f1e40567f3ec0ea36fd65e5a41f86a6f76e438bc80bd29b7c7771e16c7f38", + "size": 3182615, + "subdir": "linux-64", + "timestamp": 1527559975380, + "version": "2.38" + }, + "ciocheck-0.1.1-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "autopep8", + "coverage", + "flake8", + "isort", + "pydocstyle", + "pylint", + "pytest", + "pytest-cov", + "pytest-json", + "pytest-xdist", + "python >=2.7,<2.8.0a0", + "six", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1de128d775dfa3efe1f0b4fc04256fad", + "name": "ciocheck", + "sha256": "f90d263891a24012e94fc12ae92f701c7cb3ad3526c7cac4622ebe2b23f2ebd4", + "size": 46387, + "subdir": "linux-64", + "timestamp": 1536869370437, + "version": "0.1.1" + }, + "ciocheck-0.1.1-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "autopep8", + "coverage", + "flake8", + "isort", + "pydocstyle", + "pylint", + "pytest", + "pytest-cov", + "pytest-json", + "pytest-xdist", + "python >=3.5,<3.6.0a0", + "six", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e31ef76616c39f5f7f834cb1e7be72f", + "name": "ciocheck", + "sha256": "5904229eb5f6347dd770f3cb401a92547caf24c24905bb242292d1ac3d2e1f77", + "size": 47541, + "subdir": "linux-64", + "timestamp": 1536869413211, + "version": "0.1.1" + }, + "ciocheck-0.1.1-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "autopep8", + "coverage", + "flake8", + "isort", + "pydocstyle", + "pylint", + "pytest", + "pytest-cov", + "pytest-json", + "pytest-xdist", + "python >=3.6,<3.7.0a0", + "six", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "20178f404685e2092b0bcb4ff779609e", + "name": "ciocheck", + "sha256": "e1a816f3144b06f55cac91228d2d29bf04a0379195e7ff1f7e1e8aad18708830", + "size": 46954, + "subdir": "linux-64", + "timestamp": 1536869405309, + "version": "0.1.1" + }, + "ciocheck-0.1.1-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "autopep8", + "coverage", + "flake8", + "isort", + "pydocstyle", + "pylint", + "pytest", + "pytest-cov", + "pytest-json", + "pytest-xdist", + "python >=3.7,<3.8.0a0", + "six", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f16e1b19fbbd63a1a8d99e60e21b3cf", + "name": "ciocheck", + "sha256": "2a3fb3dfe01be8fba52e80c3d5d4611741f269ef5f886c321ffefc2dec1432d6", + "size": 47111, + "subdir": "linux-64", + "timestamp": 1536869351846, + "version": "0.1.1" + }, + "clang-10.0.1-default_h658b4fb_2.conda": { + "build": "default_h658b4fb_2", + "build_number": 2, + "constrains": [ + "clangdev 10.0.1", + "clangxx 10.0.1", + "clang-tools 10.0.1", + "llvm-tools 10.0.1" + ], + "depends": [ + "libclang-cpp10 10.0.1.*", + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "05ff5bf92a6898ea9ce615279837674d", + "name": "clang", + "sha256": "4cd11099687a9e6cfc46743a2a20fd5009cfae030b61e5b5c026992c1ab1dbd5", + "size": 13806544, + "subdir": "linux-64", + "timestamp": 1601485925562, + "version": "10.0.1" + }, + "clang-10.0.1-default_hb85057a_2.conda": { + "build": "default_hb85057a_2", + "build_number": 2, + "constrains": [ + "clangdev 10.0.1", + "clangxx 10.0.1", + "clang-tools 10.0.1", + "llvm-tools 10.0.1" + ], + "depends": [ + "libclang-cpp10 10.0.1.*", + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "64bf28a4eaed3d77f14c7e486aa8978e", + "name": "clang", + "sha256": "acb00e041eb245fa82ba111e301171b9a18ff46ab09cd261afb1a9a03ea37a47", + "size": 13804279, + "subdir": "linux-64", + "timestamp": 1601487856843, + "version": "10.0.1" + }, + "clang-14-14.0.6-default_hc1a23ef_0.conda": { + "build": "default_hc1a23ef_0", + "build_number": 0, + "constrains": [ + "clang-tools 14.0.6", + "llvm-tools 14.0.6", + "clangxx 14.0.6", + "clangdev 14.0.6" + ], + "depends": [ + "libclang-cpp14 14.0.6 default_hc1a23ef_0", + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "933558f6933afba95408c42f57f7af40", + "name": "clang-14", + "sha256": "22247c3a2dd268b8056cb2d4598b3fe5cbb0a3e72dc17b56ba8ba80da1491568", + "size": 1017385, + "subdir": "linux-64", + "timestamp": 1661930327198, + "version": "14.0.6" + }, + "clang-14.0.6-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "clang-14 14.0.6 default_hc1a23ef_0", + "gcc_impl_linux-64" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "6d561d112ce12085a036449ceed8b2fb", + "name": "clang", + "sha256": "adf8fdffd0c5aa0815391d881efb904555bb72d8942f9988493244b5cfaedded", + "size": 130956, + "subdir": "linux-64", + "timestamp": 1661930354501, + "version": "14.0.6" + }, + "clang-format-14-14.0.6-default_hc1a23ef_0.conda": { + "build": "default_hc1a23ef_0", + "build_number": 0, + "depends": [ + "libclang-cpp14 >=14.0.6,<14.1.0a0", + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "ccbaa29fb72f4384b6ef402696a45bef", + "name": "clang-format-14", + "sha256": "d156f1b238053382d5ff2fbe99d88565e047d554e323178aea61940c7bc65843", + "size": 235717, + "subdir": "linux-64", + "timestamp": 1661930430261, + "version": "14.0.6" + }, + "clang-format-14.0.6-default_hc1a23ef_0.conda": { + "build": "default_hc1a23ef_0", + "build_number": 0, + "depends": [ + "clang-format-14 14.0.6 default_hc1a23ef_0", + "libclang-cpp14 >=14.0.6,<14.1.0a0", + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "96306ef2ae79a9cb76791043302711ef", + "name": "clang-format", + "sha256": "f634d8f6e624fd710068241b0d26e2fcb5f4717c096a10de6d5a828cd225f397", + "size": 131387, + "subdir": "linux-64", + "timestamp": 1661930485021, + "version": "14.0.6" + }, + "clang-tools-10.0.1-default_h658b4fb_2.conda": { + "build": "default_h658b4fb_2", + "build_number": 2, + "constrains": [ + "clangdev 10.0.1" + ], + "depends": [ + "clang 10.0.1 default_h658b4fb_2", + "clangxx 10.0.1 default_h7cdf25a_2", + "libclang 10.0.1.*", + "libclang-cpp10", + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "f0b17e2b115309fe8c5d2b8303207d28", + "name": "clang-tools", + "sha256": "5891c1b5b4d58b5c5f15bd7a0cc762dfe07d207766abf41f6c5f291c374e4568", + "size": 11972363, + "subdir": "linux-64", + "timestamp": 1601486062497, + "version": "10.0.1" + }, + "clang-tools-10.0.1-default_hb85057a_2.conda": { + "build": "default_hb85057a_2", + "build_number": 2, + "constrains": [ + "clangdev 10.0.1" + ], + "depends": [ + "clang 10.0.1 default_hb85057a_2", + "clangxx 10.0.1 default_hb85057a_2", + "libclang 10.0.1.*", + "libclang-cpp10", + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "92d4140646e93ef39f120d3921e04e59", + "name": "clang-tools", + "sha256": "4cc20c540cbf081c8af3cfe6651aab5ff4d3d465a5fe07820fac7b85a9bfaa5b", + "size": 11970708, + "subdir": "linux-64", + "timestamp": 1601487988256, + "version": "10.0.1" + }, + "clang-tools-14.0.6-default_hc1a23ef_0.conda": { + "build": "default_hc1a23ef_0", + "build_number": 0, + "constrains": [ + "clangdev 14.0.6" + ], + "depends": [ + "clang-format 14.0.6 default_hc1a23ef_0", + "libclang >=14.0.6,<14.1.0a0", + "libclang-cpp14 >=14.0.6,<14.1.0a0", + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "90d03c08d968ab750dfda8d948e2cd73", + "name": "clang-tools", + "sha256": "e69705a46050a4b72e39087a02c233436103eff88075d7c63b1e973b2c32164a", + "size": 14407316, + "subdir": "linux-64", + "timestamp": 1661930506777, + "version": "14.0.6" + }, + "clang_win-64-14.0.6-hc402f9b_0.conda": { + "build": "hc402f9b_0", + "build_number": 0, + "depends": [ + "clangxx 14.0.6.*", + "compiler-rt 14.0.6.*", + "compiler-rt_win-64 14.0.6.*", + "lld 14.0.6.*", + "llvm-tools 14.0.6.*", + "msvc-headers-libs >=14.15.26706,<14.15.26707.0a0", + "winsdk >=10.0.17763.0,<10.0.17764.0a0" + ], + "license": "BSD-3-Clause", + "md5": "232533a22ccedb876620b999f3450792", + "name": "clang_win-64", + "sha256": "1d0dafbae5dcaa6725c38fdb0c07bcaf82cd5d06a69f5fd9e30bb498d9047d0b", + "size": 27146, + "subdir": "linux-64", + "timestamp": 1668352710185, + "version": "14.0.6" + }, + "clangdev-10.0.1-default_h658b4fb_2.conda": { + "build": "default_h658b4fb_2", + "build_number": 2, + "depends": [ + "clang 10.0.1 default_h658b4fb_2", + "clang-tools 10.0.1 default_h658b4fb_2", + "clangxx 10.0.1 default_h7cdf25a_2", + "libclang 10.0.1 default_h658b4fb_2", + "libclang-cpp 10.0.1 default_h658b4fb_2", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmdev 10.0.1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "7a079bff4a0959a02a1f3fcc2bb986c6", + "name": "clangdev", + "sha256": "4d3bb6f54031d783400ea0c313cd36af006828a269d5688025d3bb875ab7d6be", + "size": 30308952, + "subdir": "linux-64", + "timestamp": 1601486108091, + "version": "10.0.1" + }, + "clangdev-10.0.1-default_hb85057a_2.conda": { + "build": "default_hb85057a_2", + "build_number": 2, + "depends": [ + "clang 10.0.1 default_hb85057a_2", + "clang-tools 10.0.1 default_hb85057a_2", + "clangxx 10.0.1 default_hb85057a_2", + "libclang 10.0.1 default_hb85057a_2", + "libclang-cpp 10.0.1 default_hb85057a_2", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmdev 10.0.1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "9c4837e8b84ae1d6c37abdd9e87e5e63", + "name": "clangdev", + "sha256": "0eab444efd6cffd09306282ac5d55f79de072c87ee92a673eb486e064a3a3f90", + "size": 30307075, + "subdir": "linux-64", + "timestamp": 1601488023578, + "version": "10.0.1" + }, + "clangdev-14.0.6-default_hc1a23ef_0.conda": { + "build": "default_hc1a23ef_0", + "build_number": 0, + "depends": [ + "clang 14.0.6 h06a4308_0", + "clang-tools 14.0.6 default_hc1a23ef_0", + "clangxx 14.0.6 default_hc6dbbc7_0", + "libclang 14.0.6 default_hc1a23ef_0", + "libclang-cpp 14.0.6 default_hc1a23ef_0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "llvmdev 14.0.6", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "0dac60606fb98ec27d0f777ec802c04e", + "name": "clangdev", + "sha256": "5c6979b3d045de67e9fa83b4aa0ff6ccd93fc02b65e945ec6f1fbc328496c838", + "size": 37496594, + "subdir": "linux-64", + "timestamp": 1661930538906, + "version": "14.0.6" + }, + "clangxx-10.0.1-default_h7cdf25a_2.conda": { + "build": "default_h7cdf25a_2", + "build_number": 2, + "depends": [ + "clang 10.0.1 default_h658b4fb_2", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "47930c1ad6621bca22cc0c74b5126564", + "name": "clangxx", + "sha256": "94f98660a0b1c36122a4b0ce65b8825ac17f00fe61089106e612da799ce66e4d", + "size": 137888, + "subdir": "linux-64", + "timestamp": 1601485988617, + "version": "10.0.1" + }, + "clangxx-10.0.1-default_hb85057a_2.conda": { + "build": "default_hb85057a_2", + "build_number": 2, + "depends": [ + "clang 10.0.1 default_hb85057a_2", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "69f589ad9ecbef8f64427171fd4f6c8a", + "name": "clangxx", + "sha256": "ab1bf27eb189895e20c5f5666f67892f1ee92735f702ed4346734f55609fdb63", + "size": 136255, + "subdir": "linux-64", + "timestamp": 1601487915127, + "version": "10.0.1" + }, + "clangxx-14.0.6-default_hc6dbbc7_0.conda": { + "build": "default_hc6dbbc7_0", + "build_number": 0, + "depends": [ + "clang 14.0.6 h06a4308_0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "1e24b2b421c50a37baa747a44b2fa781", + "name": "clangxx", + "sha256": "23e07da81105e0d7251c07276afec13219bd4ec36bf535862399760005f94fe6", + "size": 130922, + "subdir": "linux-64", + "timestamp": 1661930362206, + "version": "14.0.6" + }, + "cleo-2.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "crashtest >=0.4.1,<0.5.0", + "python >=3.10,<3.11.0a0", + "rapidfuzz >=2.2.0,<3.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3cb78bc5f4e4876c028ee58989afd72d", + "name": "cleo", + "sha256": "49a2b68d5d1d3997421f7a2a0412751bf1d93af24e6f9e0c5e3afcef5a4cd604", + "size": 136858, + "subdir": "linux-64", + "timestamp": 1679610039500, + "version": "2.0.1" + }, + "cleo-2.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "crashtest >=0.4.1,<0.5.0", + "python >=3.11,<3.12.0a0", + "rapidfuzz >=2.2.0,<3.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ecb6c2d8730a4351e7ae1ca8e81a736a", + "name": "cleo", + "sha256": "7785e406db8d792dd338120e4703f72d6a2d7eaf56c9082de83845d316f48aaa", + "size": 179700, + "subdir": "linux-64", + "timestamp": 1679610007778, + "version": "2.0.1" + }, + "cleo-2.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "crashtest >=0.4.1,<0.5.0", + "python >=3.8,<3.9.0a0", + "rapidfuzz >=2.2.0,<3.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7325c78849d3b459a1e49523e6fd5488", + "name": "cleo", + "sha256": "e4d1b69976c76896dd1c3ac6c14a319d126880269cc3ac6ccbbabb145f594721", + "size": 135732, + "subdir": "linux-64", + "timestamp": 1679610069630, + "version": "2.0.1" + }, + "cleo-2.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "crashtest >=0.4.1,<0.5.0", + "python >=3.9,<3.10.0a0", + "rapidfuzz >=2.2.0,<3.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c692510d6614efcc7e1cd64685a7281", + "name": "cleo", + "sha256": "cf41a9e15dea174098c0e32ce60cbefbf7c049b4a0cfca3f3d24f9a81ab1c2fc", + "size": 134281, + "subdir": "linux-64", + "timestamp": 1679610099523, + "version": "2.0.1" + }, + "cli11-2.1.2-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aedf875cb81ecf03942898cceb7bf0a8", + "name": "cli11", + "sha256": "3f7401c603f0ae37da60ceb3a03d6af23409c4502386732f3582e61c199de23f", + "size": 72672, + "subdir": "linux-64", + "timestamp": 1646233473772, + "version": "2.1.2" + }, + "click-6.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c92421da5f2036c8e4e2fb98f2575c75", + "name": "click", + "sha256": "cc2b57c1541fce68feac6a66bc44aa3e16dad5a096dd986e8565ed97a2bb678d", + "size": 110725, + "subdir": "linux-64", + "timestamp": 1530741489137, + "version": "6.7" + }, + "click-6.7-py27h4225b90_0.conda": { + "build": "py27h4225b90_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9ad64e1d8aabfcdcfa8a2565a86c20ac", + "name": "click", + "sha256": "c91b497333a6951fcd15ca9741f15b231fdb0e8e5e4e3203e30f8e777d0ad265", + "size": 110478, + "subdir": "linux-64", + "timestamp": 1505733208892, + "version": "6.7" + }, + "click-6.7-py35h353a69f_0.conda": { + "build": "py35h353a69f_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d3dae92381ec1b1eb2eaa28e4149a0f4", + "name": "click", + "sha256": "7e1048a55641a49f8b2c21f96470c0b6b2146945111abc6ebf71c9c2cdc029c1", + "size": 110285, + "subdir": "linux-64", + "timestamp": 1505733221436, + "version": "6.7" + }, + "click-6.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3aa81a01c80f910b9bddba311882e563", + "name": "click", + "sha256": "72eb797f15cee702be93cc87cb809382a8e105720cbfaba01d85f23f51bd8264", + "size": 109289, + "subdir": "linux-64", + "timestamp": 1530741467249, + "version": "6.7" + }, + "click-6.7-py36h5253387_0.conda": { + "build": "py36h5253387_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8a67da12417408e5bfa78a4ec20cd52c", + "name": "click", + "sha256": "a8412892b99ffa7125bc64f432d2853a2a336a18d89ef11061832b879982f406", + "size": 109071, + "subdir": "linux-64", + "timestamp": 1505733234112, + "version": "6.7" + }, + "click-6.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dfb1af594310dab4f94a35122667c123", + "name": "click", + "sha256": "6f69b5fc64c1e21fb4f2849ab6d3f0a3c95dd4a45f7c9b886314a6b7d03b1483", + "size": 109400, + "subdir": "linux-64", + "timestamp": 1530741512018, + "version": "6.7" + }, + "click-7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e052cf4c7e6aa9e58d48995ce301d731", + "name": "click", + "sha256": "6d9d6d0fdf3fef187e3269484176a3ddedbaf9ff4870514597100fba97d9a2b2", + "size": 122963, + "subdir": "linux-64", + "timestamp": 1538599063028, + "version": "7.0" + }, + "click-7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5a798b208d6e2447895cd17fbbb678cb", + "name": "click", + "sha256": "fe0eb6fff1f850b8193fee72fb77b3fb18ba3340e42b5544b313a9ca1c5f138d", + "size": 125100, + "subdir": "linux-64", + "timestamp": 1538599056995, + "version": "7.0" + }, + "click-7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c0e569954f95f3fd52c5be8af60bd1fc", + "name": "click", + "sha256": "bef9601ac9473c75c1f37c0cf0009a58a1f4feb3d28d52c945fbda5264b86b1e", + "size": 123328, + "subdir": "linux-64", + "timestamp": 1538599032841, + "version": "7.0" + }, + "click-8.0.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e03ab0e3888bccb78f9fc8ad170cdaf", + "name": "click", + "sha256": "cf83af3fa088d2d351f6e84e0b864894bfd36697dfb01c9c129971f7475eac9a", + "size": 160075, + "subdir": "linux-64", + "timestamp": 1646056747929, + "version": "8.0.4" + }, + "click-8.0.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e81ac3f1dd264c02712d9e898bf35a8", + "name": "click", + "sha256": "c50349dbe1374cf884d23b74aae23dce47bd78eb5232ee883b719d73dc5d09d5", + "size": 211073, + "subdir": "linux-64", + "timestamp": 1676825175185, + "version": "8.0.4" + }, + "click-8.0.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7ba27f07d8e9b167cde0a171f5788094", + "name": "click", + "sha256": "bf9a8e38d624c083d69d4007d167d7f6e8ad90660f25df01b158c466c3ca307d", + "size": 156006, + "subdir": "linux-64", + "timestamp": 1646056620858, + "version": "8.0.4" + }, + "click-8.0.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bfbfb45e560159ec3a8ee264ccb1e415", + "name": "click", + "sha256": "087392a423a070866664c6cd3f56df9c7d78a4ea4c2833c7403c10ead5922b39", + "size": 155072, + "subdir": "linux-64", + "timestamp": 1646038492813, + "version": "8.0.4" + }, + "click-8.0.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7cfd6b8309bab5f2733eb9a08039d75b", + "name": "click", + "sha256": "5cfeaf5d4047ebc4afdee43a2907044421566cca885cd0a4e5f5b5e14a7651f4", + "size": 155278, + "subdir": "linux-64", + "timestamp": 1646056616713, + "version": "8.0.4" + }, + "click-default-group-1.2.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b17e079ca3414b537b9af198858efd0e", + "name": "click-default-group", + "sha256": "cdf8049fb103e9f9720eb79bb023fe2eaf1a25f524ae09b80b1144d3031e2809", + "size": 11291, + "subdir": "linux-64", + "timestamp": 1676366363293, + "version": "1.2.2" + }, + "click-default-group-1.2.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6d15c5383bd67509b4369c48ef5cdc42", + "name": "click-default-group", + "sha256": "84ee4e62fd4f5dae5fb9e5314a67d40e31ce4f91052416ac67a9ee3e8f6d5411", + "size": 11841, + "subdir": "linux-64", + "timestamp": 1679339621946, + "version": "1.2.2" + }, + "click-default-group-1.2.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a6b834e5b4ac27d4d9e8135d1930ee5", + "name": "click-default-group", + "sha256": "c6de8495a8b8ca82daf7d50c66e718c7a2992a8fa5095b5dbb48d8f13b8c8861", + "size": 11215, + "subdir": "linux-64", + "timestamp": 1676366388789, + "version": "1.2.2" + }, + "click-default-group-1.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38f81f0627f8558c973ed3ee38f66d28", + "name": "click-default-group", + "sha256": "eeec7b12c6ba6a229116ca22ad9b84bfc5bf5fe515badf916bab24a0940f690d", + "size": 11237, + "subdir": "linux-64", + "timestamp": 1676366414277, + "version": "1.2.2" + }, + "click-default-group-1.2.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ea14ff1fac03624bb88f6acbad0293e0", + "name": "click-default-group", + "sha256": "9e0e6d25e02290cf83e769fdbc8a911ab70ea49e3c91b7545f5f56024253edc4", + "size": 11220, + "subdir": "linux-64", + "timestamp": 1676366337872, + "version": "1.2.2" + }, + "click-plugins-1.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b8b7ceeb77b016bd56544537586c667b", + "name": "click-plugins", + "sha256": "335f9326ec44ae6c9144c7cec3d920ed5d26fbd027e9a6bc04f449b926caf071", + "size": 10841, + "subdir": "linux-64", + "timestamp": 1530812149468, + "version": "1.0.3" + }, + "click-plugins-1.0.3-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "click >=3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bb84ea2a315e3d5ddfe8c86a118082cf", + "name": "click-plugins", + "sha256": "17569ea630a148e9577d8cfd0782f1df00f71457ebeceb8d420e6928e42626b6", + "size": 10996, + "subdir": "linux-64", + "timestamp": 1536261772021, + "version": "1.0.3" + }, + "click-plugins-1.0.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4c7e466cc3a6b18e9e48293812f302c0", + "name": "click-plugins", + "sha256": "2306d166cb0a9e9b62e984ae533a823f0136ab42763f89202f8a5bc40c75baa2", + "size": 11010, + "subdir": "linux-64", + "timestamp": 1535130001359, + "version": "1.0.3" + }, + "click-plugins-1.0.3-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "click >=3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "90e14f9367bf167d637a7bfed6e4e3f9", + "name": "click-plugins", + "sha256": "8dd51aa217c4585500746346a273c734c7fc514aa776820c64f58a4c3fb0216e", + "size": 11029, + "subdir": "linux-64", + "timestamp": 1536261843766, + "version": "1.0.3" + }, + "click-plugins-1.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e28ff9333b7db9bc81fb9caa420dc5ec", + "name": "click-plugins", + "sha256": "ca1f7d0c56d97908ba834ded05e2a8cdc37fe9a702b5451e7b26019801ca847c", + "size": 10945, + "subdir": "linux-64", + "timestamp": 1530812198015, + "version": "1.0.3" + }, + "click-plugins-1.0.3-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "click >=3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c77b73b2e6cd650a01c7b8c6910aa24e", + "name": "click-plugins", + "sha256": "b93fde93a096dadf7ed985f24db1326df5738b7963e77b00f6a2063f098b162d", + "size": 11005, + "subdir": "linux-64", + "timestamp": 1536261658956, + "version": "1.0.3" + }, + "click-plugins-1.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7b0ba3f1d20390dd2bd7f0fedab70e35", + "name": "click-plugins", + "sha256": "f333c03bc49b33590136168788abea6047290bf737aef8ae95aa6ff294d4f079", + "size": 10912, + "subdir": "linux-64", + "timestamp": 1530812173192, + "version": "1.0.3" + }, + "click-plugins-1.0.3-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "click >=3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9b793f03434209fad67afd4a10c3d4fe", + "name": "click-plugins", + "sha256": "c608d8167b81bb56dedcedb84d60b70c0a4dc45c731ce511ed6f1bd64473ecd5", + "size": 11007, + "subdir": "linux-64", + "timestamp": 1536261878556, + "version": "1.0.3" + }, + "click-plugins-1.0.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7e03de3b5e3f67dd4d350e6d9b4f2a5e", + "name": "click-plugins", + "sha256": "3c89916aee470fc74a06bf12854365aa8ae68a956f5b94289263042afb27fb56", + "size": 11136, + "subdir": "linux-64", + "timestamp": 1539471838852, + "version": "1.0.4" + }, + "click-plugins-1.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5438cf2d5e8cb08349b56f5eb3d4a58b", + "name": "click-plugins", + "sha256": "c3a14b696bb566999d4b9f2bf4da2d656f91fa392c8e455b0173189100196ca1", + "size": 11210, + "subdir": "linux-64", + "timestamp": 1539471847673, + "version": "1.0.4" + }, + "click-plugins-1.0.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "810e62778fc2d8693245f8712d6fab66", + "name": "click-plugins", + "sha256": "1a8dfc147cad49b0d3d466551c1e5bce9def086fd3c224a5563e7252e91052a5", + "size": 11212, + "subdir": "linux-64", + "timestamp": 1539471853897, + "version": "1.0.4" + }, + "clickhouse-cityhash-1.0.2.3-py310h295c915_2.conda": { + "build": "py310h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "89873b7f9c432db98667cc61b6786881", + "name": "clickhouse-cityhash", + "sha256": "9b8e8fd09b1220bf3d5fa17ef095442bcc605a3d3b63e29c40abd613c3f22d95", + "size": 73762, + "subdir": "linux-64", + "timestamp": 1640789078822, + "version": "1.0.2.3" + }, + "clickhouse-cityhash-1.0.2.3-py36h2531618_2.conda": { + "build": "py36h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c3077154edb660d29cabcbf4cb76324", + "name": "clickhouse-cityhash", + "sha256": "bc70ad3d4df1b2062f946cb60537c915f23ed20abda5b8e92cdc574d33e4b121", + "size": 27581, + "subdir": "linux-64", + "timestamp": 1606150616715, + "version": "1.0.2.3" + }, + "clickhouse-cityhash-1.0.2.3-py37h2531618_2.conda": { + "build": "py37h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "181e10bc43667248cafb5a140e7e3535", + "name": "clickhouse-cityhash", + "sha256": "145a311931db6c2a0be51bb7b910b0bcab9e1ceead9e452e0d04a28e88dbbea9", + "size": 27173, + "subdir": "linux-64", + "timestamp": 1606150617265, + "version": "1.0.2.3" + }, + "clickhouse-cityhash-1.0.2.3-py38h2531618_2.conda": { + "build": "py38h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3da598a52a40785c4dc947ad810e6317", + "name": "clickhouse-cityhash", + "sha256": "6d81ff2e328f669e942c5164e03b1e66d93907f2eac7280371e50daff36ba664", + "size": 27501, + "subdir": "linux-64", + "timestamp": 1606150623060, + "version": "1.0.2.3" + }, + "clickhouse-cityhash-1.0.2.3-py39h2531618_2.conda": { + "build": "py39h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ac02a5cf5d9d4933cdbccc5fb2bc08c6", + "name": "clickhouse-cityhash", + "sha256": "6b5d754d766dfedb074500897db8a7842794cf752c169d38a7383319f1a4f18a", + "size": 27381, + "subdir": "linux-64", + "timestamp": 1606150608041, + "version": "1.0.2.3" + }, + "clickhouse-cityhash-1.0.2.4-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6dc47105495f129495638d575c6ef592", + "name": "clickhouse-cityhash", + "sha256": "8eed767577ae2efae4e759e625b0cbcb072732d75872b33bc31d5ecf4bf86afe", + "size": 27030, + "subdir": "linux-64", + "timestamp": 1674745971274, + "version": "1.0.2.4" + }, + "clickhouse-cityhash-1.0.2.4-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ef6f6f6f7ff2adecd6c96f44c288b14", + "name": "clickhouse-cityhash", + "sha256": "96fa827ec751be02eeca89b945090041ff588fd4b809a787d7a13737e7904139", + "size": 25675, + "subdir": "linux-64", + "timestamp": 1676851284966, + "version": "1.0.2.4" + }, + "clickhouse-cityhash-1.0.2.4-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "389b1be6202c825e27628de3f6eef696", + "name": "clickhouse-cityhash", + "sha256": "ade31f94b2e71d6ab3da902393dddc47e530685bf2ff594cc03375410fc55365", + "size": 27003, + "subdir": "linux-64", + "timestamp": 1674746061889, + "version": "1.0.2.4" + }, + "clickhouse-cityhash-1.0.2.4-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f426e29ea1bbd981b06beb3ccacf00d9", + "name": "clickhouse-cityhash", + "sha256": "8f4172ffc2004a7fa813f6c0edccddaeea3b52ede5963a65204eab0c36c2f52c", + "size": 27410, + "subdir": "linux-64", + "timestamp": 1674746031364, + "version": "1.0.2.4" + }, + "clickhouse-cityhash-1.0.2.4-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2154d53c94af1cf501656c663cf41f1", + "name": "clickhouse-cityhash", + "sha256": "c1e98ec88091c54f8f7d7fc0782b21f95b1b34826dbd8fa1faa61447eda315ba", + "size": 27186, + "subdir": "linux-64", + "timestamp": 1674746001400, + "version": "1.0.2.4" + }, + "clickhouse-driver-0.1.5-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8de86098cf651fb427308a1df44a6974", + "name": "clickhouse-driver", + "sha256": "30a530b3eeade3fc1d40f06ca5559e20483a26ba772677b959040252c6ca7534", + "size": 194038, + "subdir": "linux-64", + "timestamp": 1606150793954, + "version": "0.1.5" + }, + "clickhouse-driver-0.1.5-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ffc03bae5d36b43f7e4965acca2ff1b", + "name": "clickhouse-driver", + "sha256": "3a6f21243d7f54165521e474368afc7a039aac7461ca14457bc3c2da0abe888d", + "size": 195721, + "subdir": "linux-64", + "timestamp": 1606150815976, + "version": "0.1.5" + }, + "clickhouse-driver-0.1.5-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7455a8e8717104720a878cb273e5f9f4", + "name": "clickhouse-driver", + "sha256": "e517ade8afe1b6b50be460f7e8ca1433753751df2df766e26d9916fc4103e51b", + "size": 202182, + "subdir": "linux-64", + "timestamp": 1606150811835, + "version": "0.1.5" + }, + "clickhouse-driver-0.2.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc3ec8cc52ad1a11a20039746b8b4bb3", + "name": "clickhouse-driver", + "sha256": "ec24d22c2e8bef76ac6aa01688bef95b8e2b638d6ffe55c13c11a0700b2c65e2", + "size": 175439, + "subdir": "linux-64", + "timestamp": 1608229092929, + "version": "0.2.0" + }, + "clickhouse-driver-0.2.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e3de3c6eaf03d2031bb7cad4a17ff665", + "name": "clickhouse-driver", + "sha256": "9fc8d094b04e2688cf0dce7233c2d4192b731b9083012d9cbdac38abb1c52fe3", + "size": 173953, + "subdir": "linux-64", + "timestamp": 1608229046476, + "version": "0.2.0" + }, + "clickhouse-driver-0.2.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a1405d456d4a78cd5c844659b868a14", + "name": "clickhouse-driver", + "sha256": "8cb1b66e359c3dcb1147997e9b33ca8979b93ca1bc21dbb8df6bff8b66449762", + "size": 182840, + "subdir": "linux-64", + "timestamp": 1608229096167, + "version": "0.2.0" + }, + "clickhouse-driver-0.2.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e95e5436ec9efbf976190009440d5776", + "name": "clickhouse-driver", + "sha256": "5cac281ba3f2d140017e534b1759f84eb0b79bd151bf0bc794edeecbbe2c9e3a", + "size": 182892, + "subdir": "linux-64", + "timestamp": 1608246516063, + "version": "0.2.0" + }, + "clickhouse-driver-0.2.1-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "pytz", + "six", + "tzlocal <3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a6558bdbf132a1157de1884b3502fd5", + "name": "clickhouse-driver", + "sha256": "70b0b26da672825e7df98c4f91be1cfd8949e1c015be248e496f3f578aab8aa9", + "size": 488819, + "subdir": "linux-64", + "timestamp": 1640803906405, + "version": "0.2.1" + }, + "clickhouse-driver-0.2.1-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "pytz", + "six", + "tzlocal <3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33c8210709a0f1c4970e0a63dd9a8c33", + "name": "clickhouse-driver", + "sha256": "2d48dd302756f64f3474a88df95e13f971722a03d36c137a96729e5b76d5e8c5", + "size": 231386, + "subdir": "linux-64", + "timestamp": 1676851309143, + "version": "0.2.1" + }, + "clickhouse-driver-0.2.1-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "26d10f69219dca52fd60d8ee59c4bf44", + "name": "clickhouse-driver", + "sha256": "a75213e3284a45f1873d82b98a55ab0c4fd140e65fd9a7fde12d4c5fb94a2027", + "size": 189856, + "subdir": "linux-64", + "timestamp": 1622753230923, + "version": "0.2.1" + }, + "clickhouse-driver-0.2.1-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "599b62cf3ee2117616eebaca8c2583ed", + "name": "clickhouse-driver", + "sha256": "94fd761a6990d10011c3395e3c3668d3fb34f7d5b0328a9860dc0151379d17fd", + "size": 191805, + "subdir": "linux-64", + "timestamp": 1622758518809, + "version": "0.2.1" + }, + "clickhouse-driver-0.2.1-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz", + "six", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "59bf33931a29645423e1551618e51fc0", + "name": "clickhouse-driver", + "sha256": "b82b92a4859ece5051e52a1e5d85780e8742266fb40508baa0c1ee7840716104", + "size": 199797, + "subdir": "linux-64", + "timestamp": 1622753219217, + "version": "0.2.1" + }, + "clickhouse-driver-0.2.1-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz", + "six", + "tzlocal <3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1641b0e2afed7d0620affcc703ee27af", + "name": "clickhouse-driver", + "sha256": "4b915444f2ed26f197c8b57036c3eb465220532a7a7d3e858e22edf022535fd5", + "size": 201548, + "subdir": "linux-64", + "timestamp": 1623054762548, + "version": "0.2.1" + }, + "cligj-0.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b1ed1e9ae7a201c14727903c417f952f", + "name": "cligj", + "sha256": "1d4d171acae61e6302f1bb69d50321e40ad8449c88e8ea3f627a56624c09de70", + "size": 14481, + "subdir": "linux-64", + "timestamp": 1530812221968, + "version": "0.4.0" + }, + "cligj-0.4.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "click >=4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "18a05891e8cc83fd68fab24f99566a01", + "name": "cligj", + "sha256": "d658dcee32af4a40f0299e8d984b4a8010baaddd79bdf6ee7a62a9ac0615ce67", + "size": 14454, + "subdir": "linux-64", + "timestamp": 1536261674257, + "version": "0.4.0" + }, + "cligj-0.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7b61b2b30a20449d328ada161b5fb971", + "name": "cligj", + "sha256": "08c25e6b703d2d8313139898d40ffe501e859339940070bcca9246dc056975ac", + "size": 14693, + "subdir": "linux-64", + "timestamp": 1535130026653, + "version": "0.4.0" + }, + "cligj-0.4.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "click >=4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "58b02f27dfcfde80655eb60ffb719a72", + "name": "cligj", + "sha256": "e35d8121b7d50415259a4950d0ae6cbfe6816c34c8d8063764845f1750b76b4c", + "size": 14623, + "subdir": "linux-64", + "timestamp": 1536261732927, + "version": "0.4.0" + }, + "cligj-0.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c990d7254f323080f5ff4ce55e7fe865", + "name": "cligj", + "sha256": "d7f00a23473c8d030c0d95788188990111e878887134a33d3da6a986bb17433c", + "size": 14456, + "subdir": "linux-64", + "timestamp": 1530812269796, + "version": "0.4.0" + }, + "cligj-0.4.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "click >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d122c46bde1a7a0a57c386067e7ebbc9", + "name": "cligj", + "sha256": "f0024a9ceed6ca97897c0c4ef222f34763b28ee495628fe229c8caa48f83feba", + "size": 14600, + "subdir": "linux-64", + "timestamp": 1536261661043, + "version": "0.4.0" + }, + "cligj-0.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4d14ee1a96802664598e5c79011ed6a1", + "name": "cligj", + "sha256": "df9a2c2c74076d11cddf3aedf1b0a478636e85fae75c5fdec77e55779e9d95ad", + "size": 14468, + "subdir": "linux-64", + "timestamp": 1530812245512, + "version": "0.4.0" + }, + "cligj-0.4.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "click >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8f405eda189f35dd6ee898ead6c7b761", + "name": "cligj", + "sha256": "fd84d3955a4e836a7ef824d2c94621c140239730083bcdddf28885afdd44f9e3", + "size": 14573, + "subdir": "linux-64", + "timestamp": 1536261780556, + "version": "0.4.0" + }, + "cligj-0.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "335a079c1deea91d44c873f9bddee735", + "name": "cligj", + "sha256": "b9466b2933c1d8c07358c81de8f8c43fd315e28bbf7815863814b79bf5773ea1", + "size": 12144, + "subdir": "linux-64", + "timestamp": 1539472064559, + "version": "0.5.0" + }, + "cligj-0.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "92dbc35075f67d37e77dcf166aec6817", + "name": "cligj", + "sha256": "fd9874ccc17d0155a82008b901e1daf0dd00667d06c8b1f89137253cf67acd37", + "size": 12104, + "subdir": "linux-64", + "timestamp": 1539472095738, + "version": "0.5.0" + }, + "cligj-0.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "adaa0f119c607b7d5f39f595a5464670", + "name": "cligj", + "sha256": "70f59601b6556960ab69d984d93536d3478a95153556baa3d7174f65e0935036", + "size": 12099, + "subdir": "linux-64", + "timestamp": 1539472104637, + "version": "0.5.0" + }, + "cligj-0.5.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6dc6fc2b05b52f3dabc065abbab0496f", + "name": "cligj", + "sha256": "623046d8acf672134dc6ff3aeb3b1815ae4f4f345ad1783d519fa3a81acaf995", + "size": 13087, + "subdir": "linux-64", + "timestamp": 1573741534837, + "version": "0.5.0" + }, + "cligj-0.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "017d0dbb70ef0d1468ae74cec7915518", + "name": "cligj", + "sha256": "fefb315b3a25dccaaeb724faf96b6e8c0af91f30b9e32b5aae231ba4e6776964", + "size": 13286, + "subdir": "linux-64", + "timestamp": 1603211118835, + "version": "0.6.0" + }, + "cligj-0.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ed8351f47799a3d8a1ef8696145abd3a", + "name": "cligj", + "sha256": "79d11a4e6fa4700d0fb6d66f8bc7cc0e1e9c17ed5b48b6fc6e7c3ccc56ba616d", + "size": 13302, + "subdir": "linux-64", + "timestamp": 1603211127700, + "version": "0.6.0" + }, + "cligj-0.6.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "31f609638bfbb217bcda2a110e9ddf8f", + "name": "cligj", + "sha256": "9ebf59236800e635cd592adc5819565f641cd097b7a31149256d0717f3a65972", + "size": 13241, + "subdir": "linux-64", + "timestamp": 1603211124625, + "version": "0.6.0" + }, + "cligj-0.7.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1e6c646723e86bf834a4ce421614cca8", + "name": "cligj", + "sha256": "601861923498e42ab4f59e2a45622575e7b0cd6c9c7c3933f9da75d92c177abe", + "size": 13675, + "subdir": "linux-64", + "timestamp": 1603821810573, + "version": "0.7.0" + }, + "cligj-0.7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "989a4c09f39b2a8d28f3130be73c5ebc", + "name": "cligj", + "sha256": "e325d3c144ad78008b3e145b339f576cde2c61a0bf24dc22d8230e9c2e40f44a", + "size": 13589, + "subdir": "linux-64", + "timestamp": 1603487582976, + "version": "0.7.0" + }, + "cligj-0.7.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "83b4290032434e7004363f53fc85c784", + "name": "cligj", + "sha256": "c46236023e1bb2e561b257c82562ad5a4fd21c5bf6a403fc4df646f16531d756", + "size": 13625, + "subdir": "linux-64", + "timestamp": 1603821848400, + "version": "0.7.0" + }, + "cligj-0.7.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "027ac32ca9a13b9b31271e5cd1604598", + "name": "cligj", + "sha256": "54ac2384705230ddc19d78fe62db826ba1ff1289d3fcf0ca516829851c157601", + "size": 13601, + "subdir": "linux-64", + "timestamp": 1603721945093, + "version": "0.7.0" + }, + "cligj-0.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ca0fd591fb5249b7e64f683c83d12c90", + "name": "cligj", + "sha256": "bafbcbd317a53557fe891da88c77dd3e6f6860042e6d5a769742f21fa4976dcd", + "size": 13605, + "subdir": "linux-64", + "timestamp": 1603821844890, + "version": "0.7.0" + }, + "cligj-0.7.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f82610bd3ffa483ba3c9513860ac5aa8", + "name": "cligj", + "sha256": "94022bbb2f3cb3b7a3ce396da0c44e427f4efac78553d3bcbb1c92001649a5cb", + "size": 13610, + "subdir": "linux-64", + "timestamp": 1605996049981, + "version": "0.7.1" + }, + "cligj-0.7.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3ffe0f4c6fbf01418a9f7e1714dc8979", + "name": "cligj", + "sha256": "8ea00427a8720ed35398bbbb29927b14702ecaa0b3991ae5ba8cc9265657718d", + "size": 13619, + "subdir": "linux-64", + "timestamp": 1605996074069, + "version": "0.7.1" + }, + "cligj-0.7.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dbc12023a26b4d0c16030d307c13b15d", + "name": "cligj", + "sha256": "a360178dac6575044979ef3487bd9a13fb6650c64133e4756e38e7b438b4b2f6", + "size": 13651, + "subdir": "linux-64", + "timestamp": 1605996053751, + "version": "0.7.1" + }, + "cligj-0.7.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "00a88a63fd2d58feaf580841668f2659", + "name": "cligj", + "sha256": "08537e69c3b15706aa97534ea94f82b673f99c776d9996ee55998bd6e0662134", + "size": 13651, + "subdir": "linux-64", + "timestamp": 1605996040272, + "version": "0.7.1" + }, + "cligj-0.7.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "93d3e4b9311b778346b87591ed3addc6", + "name": "cligj", + "sha256": "f19086fc17de4b935372d5c13ba8305866429eb0422e8c82fd0b112d233be45a", + "size": 13654, + "subdir": "linux-64", + "timestamp": 1622490976388, + "version": "0.7.2" + }, + "cligj-0.7.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f19167c40d2a7ac979131a17ea70e4a5", + "name": "cligj", + "sha256": "bb292a1b63364bac38df1a16ba5c7452235badf8b8607cf8b3bb717c09139947", + "size": 13643, + "subdir": "linux-64", + "timestamp": 1622490977960, + "version": "0.7.2" + }, + "cligj-0.7.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "865ee2b12d08cb0e98ce0cce840b415b", + "name": "cligj", + "sha256": "eba316c99b453bd449486a6a49067604ef8fd2ca9c7dd47a28e763bf9187f816", + "size": 13658, + "subdir": "linux-64", + "timestamp": 1622485801746, + "version": "0.7.2" + }, + "cligj-0.7.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ac0bba18d0168fe445f6d15b00dd9ddb", + "name": "cligj", + "sha256": "2f28adf937937c5ffa9fa1a6da2cd892455b25cfd2c3a73e7a3a174df4b50641", + "size": 13606, + "subdir": "linux-64", + "timestamp": 1622490985594, + "version": "0.7.2" + }, + "cloog-0.18.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "gmp", + "isl" + ], + "license": null, + "md5": "6aedfd519728c5f71bf126bfe8bad496", + "name": "cloog", + "sha256": "2d982056bccf3d3c2a2a991fa864cbda3c590e4f98cbbe765a1093cce6c24bbe", + "size": 578909, + "version": "0.18.0" + }, + "cloudpickle-0.4.0-py27ha64365b_0.conda": { + "build": "py27ha64365b_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6d58505b80458a0583f1daa692c3872e", + "name": "cloudpickle", + "sha256": "67bc3867dddc3293d55cfc40cbae4e212649825663d2b4c2bd4b568d9ad21b94", + "size": 26293, + "subdir": "linux-64", + "timestamp": 1505732853036, + "version": "0.4.0" + }, + "cloudpickle-0.4.0-py35h10376d1_0.conda": { + "build": "py35h10376d1_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f43423d1cb26d9c337682e0347777342", + "name": "cloudpickle", + "sha256": "4c06620e65e8f7daffec550e661be9a442b5ee658e73ba724cb402d0f012a15e", + "size": 26686, + "subdir": "linux-64", + "timestamp": 1505732864342, + "version": "0.4.0" + }, + "cloudpickle-0.4.0-py36h30f8c20_0.conda": { + "build": "py36h30f8c20_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0e05d7236e3ed2596671823244fe34a1", + "name": "cloudpickle", + "sha256": "46d2f82a6f38f0e811135836ecc977bafbc11cedd77ef5fc1e09b96366ff8aa7", + "size": 26426, + "subdir": "linux-64", + "timestamp": 1505732875767, + "version": "0.4.0" + }, + "cloudpickle-0.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "375a90e19ffd96e453d154ed021ddc9d", + "name": "cloudpickle", + "sha256": "1a58ff3d71b5e16479b3864565fe4bc954ea60a710d2ae682064d2fae4588961", + "size": 26658, + "subdir": "linux-64", + "timestamp": 1514447156804, + "version": "0.4.2" + }, + "cloudpickle-0.4.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8d2e19120c5cb8d9aa13ed4a3134033b", + "name": "cloudpickle", + "sha256": "67c3efa91e8ac3475a54df475343495aa52aed32790ec425018eb9e8ef629741", + "size": 26663, + "subdir": "linux-64", + "timestamp": 1514447178940, + "version": "0.4.2" + }, + "cloudpickle-0.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0a28514b5d9bce0c5f21c1db40de2a18", + "name": "cloudpickle", + "sha256": "5901e92cbcf71e65c6e06bedb2081e385b3d3d83e0ae24847cc4997d1ce8fd51", + "size": 26344, + "subdir": "linux-64", + "timestamp": 1514447173289, + "version": "0.4.2" + }, + "cloudpickle-0.5.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "20e4b0f0ff5f92880c3e679a62f9ad50", + "name": "cloudpickle", + "sha256": "7f1c777eadb0523c1bf8865b01d9b91350558b99954edc2f7c17d006ad1a245c", + "size": 27079, + "subdir": "linux-64", + "timestamp": 1517509743334, + "version": "0.5.2" + }, + "cloudpickle-0.5.2-py27hc3dac03_0.conda": { + "build": "py27hc3dac03_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "09ed214b446a3787ddc8769188e1a1c7", + "name": "cloudpickle", + "sha256": "d48435c74142556f93214c552867f8e4a2ed918afe97309eff179dbdbfd31e1a", + "size": 27284, + "subdir": "linux-64", + "timestamp": 1511277646816, + "version": "0.5.2" + }, + "cloudpickle-0.5.2-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3694edfde998f044c04ac8ee5ce3a010", + "name": "cloudpickle", + "sha256": "0a3b08101c0f47583bb644e27921d58180da54f732ba1603db98d8ae7699b2d3", + "size": 27075, + "subdir": "linux-64", + "timestamp": 1517509764215, + "version": "0.5.2" + }, + "cloudpickle-0.5.2-py35hbe86bc5_0.conda": { + "build": "py35hbe86bc5_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ecf92fe2ef63d9d003f5095cb4181976", + "name": "cloudpickle", + "sha256": "ad47f48058dd8762dc610ba68e30bf9ea736ce2a8e3b332fd8d268bca0ad54fc", + "size": 27298, + "subdir": "linux-64", + "timestamp": 1511277647214, + "version": "0.5.2" + }, + "cloudpickle-0.5.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a9ed4182b801c441e8ab697bb5b5ee5d", + "name": "cloudpickle", + "sha256": "6b3dc90815d0ae65215e19b60ce83abbc34bc95a280a043114a9982e92dc1ee9", + "size": 27033, + "subdir": "linux-64", + "timestamp": 1517509753367, + "version": "0.5.2" + }, + "cloudpickle-0.5.2-py36h84cdd9c_0.conda": { + "build": "py36h84cdd9c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "884a86acfa4c676f7ab39ef79e14ab96", + "name": "cloudpickle", + "sha256": "afc65dae788c48ffe3ad6c99a6cb6f2d800082c89838131eee5e4dd9f7cf6628", + "size": 27226, + "subdir": "linux-64", + "timestamp": 1511277647660, + "version": "0.5.2" + }, + "cloudpickle-0.5.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5b087f54b7899092dd6ff9b62e493ad6", + "name": "cloudpickle", + "sha256": "11f462b989474e94e8d8c5339843f92ea62d26158fb35378816d2d28cbbec30b", + "size": 27527, + "subdir": "linux-64", + "timestamp": 1526402395304, + "version": "0.5.3" + }, + "cloudpickle-0.5.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ad721b4da8e7ce82391b68cf99224a3a", + "name": "cloudpickle", + "sha256": "2168c27f20cd5f041b1148174e724e963aab59665bb2580d4310d18e3da105e5", + "size": 27752, + "subdir": "linux-64", + "timestamp": 1526402425194, + "version": "0.5.3" + }, + "cloudpickle-0.5.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "559b87614941a97785f8151c2f2356e6", + "name": "cloudpickle", + "sha256": "a8fe5a8c420bee074e0d2001ec4ebaa23a82ea334b5f9a25675c449375b46418", + "size": 27430, + "subdir": "linux-64", + "timestamp": 1526402358774, + "version": "0.5.3" + }, + "cloudpickle-0.5.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b018848f87300f18b3fd1fcf49d91d2d", + "name": "cloudpickle", + "sha256": "b2f267b58c9d05c7908df3b621bb7ffa3df0de555c22a3ac9b87c4a71af248e9", + "size": 27303, + "subdir": "linux-64", + "timestamp": 1530741238482, + "version": "0.5.3" + }, + "cloudpickle-0.5.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ecebe71182b3ac58b243246ba326a5ce", + "name": "cloudpickle", + "sha256": "cf4ca1ded0688f67dbfd1f0fbe649418717e0159597319360117d0059ed07010", + "size": 27848, + "subdir": "linux-64", + "timestamp": 1535378791627, + "version": "0.5.5" + }, + "cloudpickle-0.5.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "344547cfc18a3def27cc7d2665aad559", + "name": "cloudpickle", + "sha256": "ea668f8bc807caf35c33b9d8c937ba7c52c2690b2783c52ae1e6711fbb4fd729", + "size": 28322, + "subdir": "linux-64", + "timestamp": 1535378797892, + "version": "0.5.5" + }, + "cloudpickle-0.5.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "627d471ab31514481c40dcd31c5e5767", + "name": "cloudpickle", + "sha256": "7de235da0c2ca012d0d50293a58d385ccb87089184c542439a05623e3d16ae6a", + "size": 28009, + "subdir": "linux-64", + "timestamp": 1535378789908, + "version": "0.5.5" + }, + "cloudpickle-0.5.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "eeaa889df6f87333ae4eaa6a31573186", + "name": "cloudpickle", + "sha256": "1e86c196882aa1999a999b745e54041abb28310f107acf186a076e784802d390", + "size": 28073, + "subdir": "linux-64", + "timestamp": 1535378798702, + "version": "0.5.5" + }, + "cloudpickle-0.5.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f23474aac922883d6129e316a3158847", + "name": "cloudpickle", + "sha256": "e88d92a56d2d585e5d15b9b67e5fd0b27605215962db22198141484f0dd1d0f2", + "size": 28393, + "subdir": "linux-64", + "timestamp": 1538158374155, + "version": "0.5.6" + }, + "cloudpickle-0.5.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a7ffea5d530ce45d1a7ba42d78f55adc", + "name": "cloudpickle", + "sha256": "e9f777b3fd866683eb94aa568680292d0b7abc7fcf1e95470f65fce6b6eb8505", + "size": 28098, + "subdir": "linux-64", + "timestamp": 1538158381757, + "version": "0.5.6" + }, + "cloudpickle-0.5.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5a962eab86df6e44d43722e8ddff6edd", + "name": "cloudpickle", + "sha256": "c418b94aa1540853e3c9e38a471eb95a7e197a6688a18a8647f9124945448c2f", + "size": 28419, + "subdir": "linux-64", + "timestamp": 1538158335374, + "version": "0.5.6" + }, + "cloudpickle-0.6.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2295e8dd9def022be6349d49fd69b426", + "name": "cloudpickle", + "sha256": "3889083d51c1ee5dbf70e66f700a3596e96a5a950988ef5448e3c25c14ed4260", + "size": 28987, + "subdir": "linux-64", + "timestamp": 1539472335877, + "version": "0.6.1" + }, + "cloudpickle-0.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c77aecc23f5143f14c3e60a5d3003572", + "name": "cloudpickle", + "sha256": "dba04128504cd52f62576a4451baa051dadfdce76c9b93705bcd6eeb34f29203", + "size": 28900, + "subdir": "linux-64", + "timestamp": 1539472350456, + "version": "0.6.1" + }, + "cloudpickle-0.6.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6677fbd2505e52fa66907695a30568ba", + "name": "cloudpickle", + "sha256": "36d7b9b1e62b5005a9e511ee300f75cc2255b4bcb6be812b20c48290b92a9204", + "size": 29163, + "subdir": "linux-64", + "timestamp": 1539472357360, + "version": "0.6.1" + }, + "cloudpickle-0.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "108dff6bab6cfb319b129302def8b586", + "name": "cloudpickle", + "sha256": "eafa6d9a882e4653f988e1854107a7eaf77e5827d8834c068dbe3b8a690c397b", + "size": 33215, + "subdir": "linux-64", + "timestamp": 1551138027423, + "version": "0.8.0" + }, + "cloudpickle-0.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b8f542af3e7fccf548ae249bc2a070c1", + "name": "cloudpickle", + "sha256": "ab111556a27edc331a99bf815aa6dc3c96477843badc5843f0fd9aed287efbc9", + "size": 33173, + "subdir": "linux-64", + "timestamp": 1551138025276, + "version": "0.8.0" + }, + "cloudpickle-0.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4a852646dd4633104cb6a4e4528ec6fc", + "name": "cloudpickle", + "sha256": "13bcc2e9469db489a30d1d5b1a90d8c26e9a9c7524e25016d73ff94d1efbeca4", + "size": 33173, + "subdir": "linux-64", + "timestamp": 1551137988363, + "version": "0.8.0" + }, + "clr_loader-0.2.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cffi >=1.13", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "edfa41dd6b88f38105c10c2aa97aa80f", + "name": "clr_loader", + "sha256": "7aa0861eb995e2309b2ba500e8b729293d8117dc9a0fb73b8fb69e922a639c59", + "size": 72196, + "subdir": "linux-64", + "timestamp": 1675268076894, + "version": "0.2.5" + }, + "clr_loader-0.2.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cffi >=1.13", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ab396dac3b88052eb2e35f1c159ca21", + "name": "clr_loader", + "sha256": "d4bc0c1cf0d46a91f8311209f54b9a048acf2c4b758e6c2bff367e72595a920c", + "size": 75788, + "subdir": "linux-64", + "timestamp": 1676843610450, + "version": "0.2.5" + }, + "clr_loader-0.2.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cffi >=1.13", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45ac32edba7bdd89638001b722cfe6f7", + "name": "clr_loader", + "sha256": "dbd475fb3f048988d01ad97d8b8cf077d93fefb756c5616a18da0780b55addad", + "size": 71447, + "subdir": "linux-64", + "timestamp": 1675268115096, + "version": "0.2.5" + }, + "clr_loader-0.2.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cffi >=1.13", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "591fc4801d4833d659a220c0c69acb6d", + "name": "clr_loader", + "sha256": "af57d8f921dd59f1add611831813caa9faf9d998e064ae7342b277ea55804f60", + "size": 71643, + "subdir": "linux-64", + "timestamp": 1675268190302, + "version": "0.2.5" + }, + "clr_loader-0.2.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cffi >=1.13", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a12aa93f91607b4757c3409abf0a3963", + "name": "clr_loader", + "sha256": "ad589e6294b15f457f288f1cec2d3c237a9db253e16ec68194e367ad0f06a31b", + "size": 71615, + "subdir": "linux-64", + "timestamp": 1675268152820, + "version": "0.2.5" + }, + "clyent-1.2.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "cd76fee754ab4ddd3c6d7c445aea2dd1", + "name": "clyent", + "sha256": "29234ecb847d26baf12150b065b2572ccef5d64a4146cbda85e46707b14ac02a", + "size": 19785, + "subdir": "linux-64", + "timestamp": 1530737320590, + "version": "1.2.2" + }, + "clyent-1.2.2-py27h7276e6c_1.conda": { + "build": "py27h7276e6c_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "f904b92967775df428f877459aa43bf4", + "name": "clyent", + "sha256": "d3c27c33f9d6746658ba2166e8e1fa7167894c09dfae53edaaac737ef57f0aef", + "size": 19554, + "subdir": "linux-64", + "timestamp": 1505741906264, + "version": "1.2.2" + }, + "clyent-1.2.2-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "436323fafdddec7e057bdbf2edf88621", + "name": "clyent", + "sha256": "929aa2aa7b2079cfb8fda2ba2421b3e5019f9107d937bbf74ee4018ac24aebad", + "size": 20254, + "subdir": "linux-64", + "timestamp": 1640789096647, + "version": "1.2.2" + }, + "clyent-1.2.2-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "d85edf9b4f5543cb5797df78fe3fa410", + "name": "clyent", + "sha256": "f3e407700b7e38e026a5f221cc5bf8bd5aae3af89f2568c07b56194ad538d29a", + "size": 26281, + "subdir": "linux-64", + "timestamp": 1676839171226, + "version": "1.2.2" + }, + "clyent-1.2.2-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "549b35e8397c2eb44cbde63877b69733", + "name": "clyent", + "sha256": "613e36011c70d2ca1f38ad1886fff1316e3e356f2979a7875522c50a4e8fd871", + "size": 19984, + "subdir": "linux-64", + "timestamp": 1534352672232, + "version": "1.2.2" + }, + "clyent-1.2.2-py35h491ffcb_1.conda": { + "build": "py35h491ffcb_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "e855c717cfee8ed0074cd28fa30bfd0e", + "name": "clyent", + "sha256": "4bef67daa2f4ff7913be15fd8f50915bcbe5729d95ab88406b219d653bbea825", + "size": 19799, + "subdir": "linux-64", + "timestamp": 1505741919060, + "version": "1.2.2" + }, + "clyent-1.2.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "9176a514411a8b584f8526d99f455425", + "name": "clyent", + "sha256": "5ca472fe79458c32ecd010349c05afdf65a86bfa870616d12df0449da3ae919b", + "size": 19721, + "subdir": "linux-64", + "timestamp": 1530737299716, + "version": "1.2.2" + }, + "clyent-1.2.2-py36h7e57e65_1.conda": { + "build": "py36h7e57e65_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "8c9a0a9858ea9bea07c6076b238f1b9d", + "name": "clyent", + "sha256": "8b0b1ba4eb5edd68915b27c2dbf95dc21d18168c6bba90a85f6cb90234ae0273", + "size": 19533, + "subdir": "linux-64", + "timestamp": 1505741931933, + "version": "1.2.2" + }, + "clyent-1.2.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "f3ee0ec3f94e72b0c6632033084d0998", + "name": "clyent", + "sha256": "e57cf84bcafda2c5973208ec33e34b8e6a32981ecc32ed472b37d4539849f3f0", + "size": 19859, + "subdir": "linux-64", + "timestamp": 1530737341908, + "version": "1.2.2" + }, + "clyent-1.2.2-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "178f9f5f690b893d3bb9d450db581adc", + "name": "clyent", + "sha256": "7f5d3cb80b6ba7cc00928e31da5cdf3008e26723fe028f299cf769450d80fd28", + "size": 20377, + "subdir": "linux-64", + "timestamp": 1574097928918, + "version": "1.2.2" + }, + "clyent-1.2.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "md5": "10f5c196772cfe120860fd1c0ed4b076", + "name": "clyent", + "sha256": "2f2f960dba4cff1e258b49b210c41d52ef2f504319fa71572323ca2e2cc0af28", + "size": 21330, + "subdir": "linux-64", + "timestamp": 1607025264853, + "version": "1.2.2" + }, + "cmake-3.11.1-h307fef2_1.conda": { + "build": "h307fef2_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "expat >=2.2.5,<3.0a0", + "libcurl >=7.59.0,<8.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.1,<7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "411d513d631680e1248802c7ace3dc59", + "name": "cmake", + "sha256": "adbc7a9f4fcb6cf83f99ae3758c9b21380cfb94976e705a85525a9068256ca12", + "size": 6299949, + "subdir": "linux-64", + "timestamp": 1525871702287, + "version": "3.11.1" + }, + "cmake-3.12.0-h307fef2_0.conda": { + "build": "h307fef2_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "expat >=2.2.5,<3.0a0", + "libcurl >=7.61.0,<8.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.1,<7.0a0", + "rhash >=1.3.6,<2.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3f5f1827be621ec0291151ec1f81f1da", + "name": "cmake", + "sha256": "1007ebe0628cf40d717a5db222d3a48cb4a6c79c5c69e62d49388c646d2046c1", + "size": 5757776, + "subdir": "linux-64", + "timestamp": 1532874097999, + "version": "3.12.0" + }, + "cmake-3.12.2-h52cb24c_0.conda": { + "build": "h52cb24c_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "expat >=2.2.6,<3.0a0", + "libcurl >=7.61.0,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "rhash >=1.3.6,<2.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ad37bd4b573f714739e4dc95cceb36b7", + "name": "cmake", + "sha256": "39192d400c11b5c6e514edc3f91c2ae4111c9582108ca43a43deb1899f7df833", + "size": 5829488, + "subdir": "linux-64", + "timestamp": 1536508969962, + "version": "3.12.2" + }, + "cmake-3.14.0-h52cb24c_0.conda": { + "build": "h52cb24c_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "expat >=2.2.6,<3.0a0", + "libcurl >=7.64.0,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "rhash >=1.3.8,<2.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c5e35e39f2666948e784feb45eba3d58", + "name": "cmake", + "sha256": "92a2797c1ea0bd0eecb5705352170d2078667eaf971874af09834fa67ac69716", + "size": 5716069, + "subdir": "linux-64", + "timestamp": 1553108390531, + "version": "3.14.0" + }, + "cmake-3.18.2-ha30ef3c_0.conda": { + "build": "ha30ef3c_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "expat >=2.2.9,<3.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libuv >=1.39.0,<2.0a0", + "ncurses >=6.2,<7.0a0", + "rhash >=1.4.0,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "fcc43d5786127f01e1031137f7cb7190", + "name": "cmake", + "sha256": "5085acb7432b6c88e9ba4407660837a2b626758eaa94f0fcab0f348c2690f810", + "size": 6955177, + "subdir": "linux-64", + "timestamp": 1600446037330, + "version": "3.18.2" + }, + "cmake-3.19.3-h973ab73_0.conda": { + "build": "h973ab73_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "expat >=2.2.10,<3.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "ncurses >=6.2,<7.0a0", + "rhash >=1.4.1,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e886fcc49e1109a71702e53c95ec00e3", + "name": "cmake", + "sha256": "7982f5b9f8253f6ee56783358e1222f221ba69ec43917a91386a9e63d55d931a", + "size": 7160934, + "subdir": "linux-64", + "timestamp": 1611330763643, + "version": "3.19.3" + }, + "cmake-3.19.4-h973ab73_0.conda": { + "build": "h973ab73_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "expat >=2.2.10,<3.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "ncurses >=6.2,<7.0a0", + "rhash >=1.4.1,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "869c61b433f88031b494b3e2eb2af82f", + "name": "cmake", + "sha256": "eaf9f65b419c1f7752d5ebe3742e2edef4f0494715bf296bea2145dd8087f160", + "size": 7146250, + "subdir": "linux-64", + "timestamp": 1612282542254, + "version": "3.19.4" + }, + "cmake-3.19.6-h973ab73_0.conda": { + "build": "h973ab73_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "expat >=2.2.10,<3.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "ncurses >=6.2,<7.0a0", + "rhash >=1.4.1,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c89812aae9190d72c3fb0ec3fcb66f69", + "name": "cmake", + "sha256": "a3270bf9527a6a80cb77831c0c2a773a2a4c943f12d4d6588922e05077497b8a", + "size": 7144678, + "subdir": "linux-64", + "timestamp": 1614679386931, + "version": "3.19.6" + }, + "cmake-3.22.1-h1fce559_0.conda": { + "build": "h1fce559_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "expat >=2.2.10,<3.0a0", + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "ncurses >=6.3,<7.0a0", + "rhash >=1.4.1,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.5.0,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07ed9deb86e841591193eb4f385b5f3f", + "name": "cmake", + "sha256": "13ae6746acdf96d1f0cf8960ca3c4b82ffda5198e583f206cbafee0d6172e8d2", + "size": 7666362, + "subdir": "linux-64", + "timestamp": 1641977657928, + "version": "3.22.1" + }, + "cmake-3.9.1-hd1fb129_0.conda": { + "build": "hd1fb129_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "expat", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libuv", + "ncurses 6.*", + "rhash", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "eefdc18a93a94cc83ac13a89fae1b58b", + "name": "cmake", + "sha256": "18153e3e0d3b1a23bfc7ebb65198fbc7610f27edf981e70c6edb43d8123bda45", + "size": 5836839, + "subdir": "linux-64", + "timestamp": 1505688081867, + "version": "3.9.1" + }, + "cmake-3.9.3-h61fe106_0.conda": { + "build": "h61fe106_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "expat", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libuv", + "ncurses 6.*", + "rhash", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "94d2240c7aaf3f7de299677c81d6cb65", + "name": "cmake", + "sha256": "48d9448e5dfa38ffdbb8eba37d486a45a09f40f8a5f4031b1124d6e13b4d39ee", + "size": 5838800, + "subdir": "linux-64", + "timestamp": 1508295453536, + "version": "3.9.3" + }, + "cmake-3.9.4-h142f0e9_0.conda": { + "build": "h142f0e9_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "expat", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libuv", + "ncurses 6.*", + "rhash", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c56f21e1eb3b3f7c0c75856f786d05ce", + "name": "cmake", + "sha256": "ef4648499332f42586fc88504ead21f7deb2a55303e46c908ac21388e17a2630", + "size": 5839240, + "subdir": "linux-64", + "timestamp": 1509214369515, + "version": "3.9.4" + }, + "cmake-binary-3.9.1-h2f8e2a0_1.conda": { + "build": "h2f8e2a0_1", + "build_number": 1, + "depends": [], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "050ad1d750b7257fc6752958a8ab7281", + "name": "cmake-binary", + "sha256": "9281fe20f38d3b9e1a07956fdf12993bf3223b36c086f5fa445f4a60f4e23ce4", + "size": 15675332, + "subdir": "linux-64", + "timestamp": 1510244381704, + "version": "3.9.1" + }, + "cmake-binary-3.9.1-h3db6e14_0.conda": { + "build": "h3db6e14_0", + "build_number": 0, + "depends": [], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5f9063e88a3f09387d55c4fbaa4ce2e4", + "name": "cmake-binary", + "sha256": "2f720d03c630645856055ed1953a72192c0dc2baaf35745a3ecf8d54d1b070ff", + "size": 15673410, + "subdir": "linux-64", + "timestamp": 1505687617283, + "version": "3.9.1" + }, + "cmake-no-system-3.16.5-h295c915_1.conda": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f8af84ea541df45e9d48029695d7e2e9", + "name": "cmake-no-system", + "sha256": "1a8506fd530eef8f1e7c4686237101555fdd038e21d27a8d4de8dec8af98629f", + "size": 6493782, + "subdir": "linux-64", + "timestamp": 1635449577071, + "version": "3.16.5" + }, + "cmake-no-system-3.25.3-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a57c7a00aed52f0d01794b43582a2be2", + "name": "cmake-no-system", + "sha256": "14e76677a13d225574211b9456bad24c524eddba56f5569c77158114bd2bcf61", + "size": 15904269, + "subdir": "linux-64", + "timestamp": 1679924216623, + "version": "3.25.3" + }, + "cmarkgfm-0.4.2-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8abde2eea1527a4b2cc894d9da77bd76", + "name": "cmarkgfm", + "sha256": "2e807c96cdf960f8a507bbab0c918e8d4a3c9e2d15aa98eae0f35caaf79f9cf9", + "size": 142357, + "subdir": "linux-64", + "timestamp": 1539899981585, + "version": "0.4.2" + }, + "cmarkgfm-0.4.2-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b30eef0967e0bcabff7a96f2feec4f1", + "name": "cmarkgfm", + "sha256": "8342d1e731d860b52ed5bdf380fa059d5d3a132f2f2889e1e7dc936cfb2c74b4", + "size": 346079, + "subdir": "linux-64", + "timestamp": 1640803944970, + "version": "0.4.2" + }, + "cmarkgfm-0.4.2-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8ac1d2ebbae19b0d61c20e340d7172e", + "name": "cmarkgfm", + "sha256": "fc329538925f47570f9990c084603ee4aef151afb33d3592e8b3e1fbcb8cfca8", + "size": 135483, + "subdir": "linux-64", + "timestamp": 1676903901053, + "version": "0.4.2" + }, + "cmarkgfm-0.4.2-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f61f30b369cca6f5eca5ecb810e8d41", + "name": "cmarkgfm", + "sha256": "b6c921cf0965b92574aa4b0cf3397a5263a54ff2ce5c01bf5b313955dd568cc8", + "size": 381466, + "subdir": "linux-64", + "timestamp": 1613500968049, + "version": "0.4.2" + }, + "cmarkgfm-0.4.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "375fc1139b1ff30967a68d74ade52f2e", + "name": "cmarkgfm", + "sha256": "65fa3a9961cadd3d419719b5c46d0310c3d82cc79ccfaf0ab91a59199fad8f34", + "size": 142381, + "subdir": "linux-64", + "timestamp": 1539900015606, + "version": "0.4.2" + }, + "cmarkgfm-0.4.2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47d49443b0bfd34bc3212f3f0d7a93e3", + "name": "cmarkgfm", + "sha256": "5e12f92b2673b89b70d1867b3efbae153339ee0af447cbce59b7e50f5a4a9a43", + "size": 382224, + "subdir": "linux-64", + "timestamp": 1613500810785, + "version": "0.4.2" + }, + "cmarkgfm-0.4.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d98a8a50af6a57166a79da7a4f3aae56", + "name": "cmarkgfm", + "sha256": "9dfb81b9268583cfca99bf7f6ccf0bacd59536f681f7bd3b49a7071ae81aacbd", + "size": 142399, + "subdir": "linux-64", + "timestamp": 1539900006243, + "version": "0.4.2" + }, + "cmarkgfm-0.4.2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e1f48784946f7363c9a60de747f84b42", + "name": "cmarkgfm", + "sha256": "3625e5eb9d7515606ae59f95d5df5116c4b45a0a8b7a2ad281fb5d0eba35c410", + "size": 381500, + "subdir": "linux-64", + "timestamp": 1613500329786, + "version": "0.4.2" + }, + "cmarkgfm-0.4.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd4c2df862070ec453842bbcce972fb4", + "name": "cmarkgfm", + "sha256": "8dc9da15175e69013da9c3843733aac1cb2d4c91a40a0d9945372153e3005f96", + "size": 141453, + "subdir": "linux-64", + "timestamp": 1574097959886, + "version": "0.4.2" + }, + "cmarkgfm-0.4.2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eaf0ff7a9ccb3185ce03e28bb8d912e1", + "name": "cmarkgfm", + "sha256": "59cb97d7a9cedb0041237ec63bb7f953df1b52afd5424a107e6f403ead796a70", + "size": 382312, + "subdir": "linux-64", + "timestamp": 1613500960325, + "version": "0.4.2" + }, + "cmyt-1.1.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "colorspacious >=1.1.2", + "matplotlib-base >=3.2.0", + "more-itertools >=8.4", + "numpy >=1.17.4", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fc2bccc64ce2a5058e4aef5e2fefd8a3", + "name": "cmyt", + "sha256": "3f7c1edf768b4744fd293c3bb5546b257f91c635d1df17c72c94c883ef92c943", + "size": 68774, + "subdir": "linux-64", + "timestamp": 1680641771977, + "version": "1.1.3" + }, + "cmyt-1.1.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "colorspacious >=1.1.2", + "matplotlib-base >=3.2.0", + "more-itertools >=8.4", + "numpy >=1.17.4", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2c76cfa4b86187569e72844600cd48cb", + "name": "cmyt", + "sha256": "f62812c5336c5a388ed078f5e915b5c0411ecc17c2632d8b66a8128c6393ef60", + "size": 73233, + "subdir": "linux-64", + "timestamp": 1680641733632, + "version": "1.1.3" + }, + "cmyt-1.1.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "colorspacious >=1.1.2", + "matplotlib-base >=3.2.0", + "more-itertools >=8.4", + "numpy >=1.17.4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "80cedafe552bbedb2604f29addf06397", + "name": "cmyt", + "sha256": "2d383c7b11e166abff05bb65bb8b00613bedf59ec9d18689968e219ff9625cd0", + "size": 71170, + "subdir": "linux-64", + "timestamp": 1680641844750, + "version": "1.1.3" + }, + "cmyt-1.1.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "colorspacious >=1.1.2", + "matplotlib-base >=3.2.0", + "more-itertools >=8.4", + "numpy >=1.17.4", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "92ce8effa494bebe45e7eae0686c539f", + "name": "cmyt", + "sha256": "7480c12abc5ddac74c7e7005a572a81726b841f20aeda6e9cf5da600bf21f03d", + "size": 69893, + "subdir": "linux-64", + "timestamp": 1680641807315, + "version": "1.1.3" + }, + "colander-1.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=2.7,<2.8.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "fa15419caded9a8aa73ba56d101f7491", + "name": "colander", + "sha256": "0354063ddb5c0b8cac53bc0539b07b64c01f16bbf60726f6f7b1a5f0dae70e33", + "size": 109694, + "subdir": "linux-64", + "timestamp": 1530875884332, + "version": "1.4" + }, + "colander-1.4-py27h37c4d75_0.conda": { + "build": "py27h37c4d75_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=2.7,<2.8.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "63ca2369190fbb70cebe559d27975feb", + "name": "colander", + "sha256": "4b6fb611903e8ca9cea6b2201f82e7c97cc000865cdd0f37ef87adc66cf3423c", + "size": 110487, + "subdir": "linux-64", + "timestamp": 1507613925792, + "version": "1.4" + }, + "colander-1.4-py35h9147586_0.conda": { + "build": "py35h9147586_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.5,<3.6.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "c66ce347f01345e6c0b7470c5a6b17d5", + "name": "colander", + "sha256": "3f52afe7e58c90dfb640b3563627fe7f5eea79b74c1333301c85f4050ffa9dba", + "size": 113291, + "subdir": "linux-64", + "timestamp": 1507613930803, + "version": "1.4" + }, + "colander-1.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.6,<3.7.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "6d2c7c873db9541c5441d640b727b0a8", + "name": "colander", + "sha256": "e0555d01598d9d04281d95fc66ba868148565bee953271293b2d85f46a793ffc", + "size": 112189, + "subdir": "linux-64", + "timestamp": 1530875831727, + "version": "1.4" + }, + "colander-1.4-py36h3dcf288_0.conda": { + "build": "py36h3dcf288_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.6,<3.7.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "1fbc3022bc51c04be9b802bc0f18f2bc", + "name": "colander", + "sha256": "2752dccf1ce0f62d5f7cbe83e35770e394f1fc778943087e117ffa62c53b74a9", + "size": 112759, + "subdir": "linux-64", + "timestamp": 1507613915462, + "version": "1.4" + }, + "colander-1.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.7,<3.8.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "18eb8e52cf4ba5f52f94cc41baf6801d", + "name": "colander", + "sha256": "cc5364182695b84b4d2f958945c3b6fcf864ff2b81ac5249d74016d28a89d205", + "size": 111981, + "subdir": "linux-64", + "timestamp": 1530875858346, + "version": "1.4" + }, + "colander-1.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "iso8601", + "python >=2.7,<2.8.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "27670d42f998764062b62d532bacc2fa", + "name": "colander", + "sha256": "2b5333a709df04c264237a19500b410f84f31776ebc9830eff66825ef3b22028", + "size": 111987, + "subdir": "linux-64", + "timestamp": 1539621008878, + "version": "1.5.1" + }, + "colander-1.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.6,<3.7.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "b0c89b47c4f695f5d0722a5513e105dc", + "name": "colander", + "sha256": "4bd75f9c0a1c58f20bf2aa4f1282f364fdcaddc0bbb15b462688c7c985daf1d4", + "size": 114713, + "subdir": "linux-64", + "timestamp": 1539621044694, + "version": "1.5.1" + }, + "colander-1.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.7,<3.8.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "0cdb510ccd84e94950c5d33045ec7768", + "name": "colander", + "sha256": "349a4e854e85625c0bec03abd58f521b0d1a16fc6abed071b1611967a71ced37", + "size": 116341, + "subdir": "linux-64", + "timestamp": 1539621049116, + "version": "1.5.1" + }, + "colander-1.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "iso8601", + "python >=2.7,<2.8.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "6b6ac491e06788c7b6729464f9dc311b", + "name": "colander", + "sha256": "c046dc76f8fa53c5262741a41095bad19f9c8202e9c4248fab724deb5fd898d0", + "size": 269630, + "subdir": "linux-64", + "timestamp": 1552359626736, + "version": "1.7.0" + }, + "colander-1.7.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.10,<3.11.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "4e5fbd3e1f4dc6ea3c80f51980bf3d36", + "name": "colander", + "sha256": "739e5077c269ff5543c34cac711652cf01fad1ac5ba3e3f1214b41d3c29f96b0", + "size": 121923, + "subdir": "linux-64", + "timestamp": 1640808631291, + "version": "1.7.0" + }, + "colander-1.7.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.11,<3.12.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "5e99303da89e3be585dca9e7df5e8184", + "name": "colander", + "sha256": "d8f1cd568b2c5b378383002d6e16c956b54703cfd8056e6ea93022180aa0723b", + "size": 149684, + "subdir": "linux-64", + "timestamp": 1676906997104, + "version": "1.7.0" + }, + "colander-1.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.6,<3.7.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "e190379afc01d3eaa3902aca3c936d0b", + "name": "colander", + "sha256": "eaf3ba2502c81a84c2ab76dbb5799a375f07b23464eb76a9ccbc1b46439a039d", + "size": 270197, + "subdir": "linux-64", + "timestamp": 1552359648869, + "version": "1.7.0" + }, + "colander-1.7.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.6,<3.7.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "73d169a38bc67f3a2fe5d960dd674629", + "name": "colander", + "sha256": "3a678a49a6c5151efe8098d2f382d22d625977d278309887d91f801c64193420", + "size": 358633, + "subdir": "linux-64", + "timestamp": 1613568578901, + "version": "1.7.0" + }, + "colander-1.7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.7,<3.8.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "106475be6c14191933baff8e13851e7b", + "name": "colander", + "sha256": "dc0593d3f3afeb1be6248e4f190355fef98e5e85d41142537dccd7cbaaca88c3", + "size": 272209, + "subdir": "linux-64", + "timestamp": 1552359556270, + "version": "1.7.0" + }, + "colander-1.7.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.7,<3.8.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "6ddaf5f43533a951527f28b4d2e6fb29", + "name": "colander", + "sha256": "8e9fed7e91067f9f5bde50eab50ba96079ad0e7a58a48b68909dcbe0549265d8", + "size": 358578, + "subdir": "linux-64", + "timestamp": 1613569009183, + "version": "1.7.0" + }, + "colander-1.7.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.8,<3.9.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "1c1c0cca2b2b4c16ee402f128b39f199", + "name": "colander", + "sha256": "f93d856172802fab4aa5f4281fe0fab7311915238dbebd958a8e52702bb954c0", + "size": 120586, + "subdir": "linux-64", + "timestamp": 1573741552028, + "version": "1.7.0" + }, + "colander-1.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "iso8601", + "python >=3.9,<3.10.0a0", + "translationstring" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "5b5f196f98879caeeabad4df7875481d", + "name": "colander", + "sha256": "7ffa684647572600936963b2313d7b00767a472687e4463166c6e8d704fd604f", + "size": 358599, + "subdir": "linux-64", + "timestamp": 1613568347088, + "version": "1.7.0" + }, + "colorama-0.3.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "be6679295a63c1e2d4a18028e4fa1452", + "name": "colorama", + "sha256": "ae1a9cdf6d40cec04f80c09e941463d9b6dfbe70b757da22d3b576f60180ff3b", + "size": 24557, + "subdir": "linux-64", + "timestamp": 1530693854914, + "version": "0.3.9" + }, + "colorama-0.3.9-py27h5cde069_0.conda": { + "build": "py27h5cde069_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7da49eff93e1e0b199f2d944f6be5796", + "name": "colorama", + "sha256": "04af62c5e7eaf41d8d0280854e4feb7958486ad8bdde5a889d892e1074393395", + "size": 24313, + "subdir": "linux-64", + "timestamp": 1505741945172, + "version": "0.3.9" + }, + "colorama-0.3.9-py35h81e2b6c_0.conda": { + "build": "py35h81e2b6c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "161913e5b445a3f2baa4db0d7c853121", + "name": "colorama", + "sha256": "512fc64d8fae8e627f9d193f2932cb138ce0317f31d45cca1878cf9f81f46b35", + "size": 24499, + "subdir": "linux-64", + "timestamp": 1505741957440, + "version": "0.3.9" + }, + "colorama-0.3.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c2289f042fd1279d6d28645b12eb9494", + "name": "colorama", + "sha256": "d283d8a4ccfc90de94bdd58fd0359359843ae0dc48e513f20009fa5fac370d37", + "size": 24673, + "subdir": "linux-64", + "timestamp": 1530693817961, + "version": "0.3.9" + }, + "colorama-0.3.9-py36h489cec4_0.conda": { + "build": "py36h489cec4_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3776eb18de2d91b94f75dffbeffa5b1f", + "name": "colorama", + "sha256": "2f47c477f223cd4c3d8e1b540c1b4f713ad2ad91498ac68f982b56ebb9c35ccb", + "size": 24335, + "subdir": "linux-64", + "timestamp": 1505741969960, + "version": "0.3.9" + }, + "colorama-0.3.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4442021c6d7c3e7cb7937fd3fbc089a5", + "name": "colorama", + "sha256": "851241b3cb1b2582177bf3163be777bf1c23184f96ed318b3d47446c1d39571e", + "size": 24651, + "subdir": "linux-64", + "timestamp": 1530693837145, + "version": "0.3.9" + }, + "colorama-0.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5c59c40c08aab9aeb863458f3fe1adcf", + "name": "colorama", + "sha256": "7974643ae8d6d7921e876821deadd9e3fd8f24332bfcdeadd12b38bf28cbbc6d", + "size": 24781, + "subdir": "linux-64", + "timestamp": 1539634932996, + "version": "0.4.0" + }, + "colorama-0.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d67fef07b8806b589530fe95531c08a4", + "name": "colorama", + "sha256": "3b485a0da1180c51db41dc6371a28e627ae8ffde0cbdc81c3c83acf8c809f58b", + "size": 25098, + "subdir": "linux-64", + "timestamp": 1539634959615, + "version": "0.4.0" + }, + "colorama-0.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c470245ad82ce9423d95a12521670475", + "name": "colorama", + "sha256": "988d37efda97e0c569e4b2019e5f84f64483593ea03999ac84f6eec323e1a8eb", + "size": 25004, + "subdir": "linux-64", + "timestamp": 1539634949048, + "version": "0.4.0" + }, + "colorama-0.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "aee4ae988d6f944ba776f7eba80f5b21", + "name": "colorama", + "sha256": "dff862344d2ea69ef0f6398a78b50f6503a161157c1adc21403d91b2518e24a9", + "size": 25316, + "subdir": "linux-64", + "timestamp": 1545083895059, + "version": "0.4.1" + }, + "colorama-0.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "85b9abb3b8f916aa36be5a596b9069ca", + "name": "colorama", + "sha256": "74f8983ff3656ade06388639da285437ee6d4a1b8c19c16d29285a93f80d8335", + "size": 25327, + "subdir": "linux-64", + "timestamp": 1545083921207, + "version": "0.4.1" + }, + "colorama-0.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "00a9ba71a3df784e1c23f0146554a16f", + "name": "colorama", + "sha256": "f4fa28999f1317a63cf856db5aafa1d725a0ad6f3073fb7dfc85eba35077897d", + "size": 25377, + "subdir": "linux-64", + "timestamp": 1545083945930, + "version": "0.4.1" + }, + "colorama-0.4.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c28650df4ba1883a9bb02046f19b5cea", + "name": "colorama", + "sha256": "7a24a534cef96c747596b18e0e29c7f7e702d708476bc92bba080f0b9161e15e", + "size": 28091, + "subdir": "linux-64", + "timestamp": 1657009213022, + "version": "0.4.5" + }, + "colorama-0.4.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "83cc7af2ca3968d67b01b49607a2a7f5", + "name": "colorama", + "sha256": "47ac39596bff75c2a6c34276718557b1131ae034e87b4dfd75905405117d465a", + "size": 27692, + "subdir": "linux-64", + "timestamp": 1657009175352, + "version": "0.4.5" + }, + "colorama-0.4.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7b820389a5f1692aa64b1cf5611cc3af", + "name": "colorama", + "sha256": "ddf6e6638afef02e668326ca5651c3cf0846f8f1d0231f361f848322b9a0ea23", + "size": 27729, + "subdir": "linux-64", + "timestamp": 1657009149122, + "version": "0.4.5" + }, + "colorama-0.4.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "78a932366685b400ea358a2204a3854f", + "name": "colorama", + "sha256": "31f8737012e7eb2282bc4027be1a82f83b5c623a314848d2efd4fe4c2db8c311", + "size": 27769, + "subdir": "linux-64", + "timestamp": 1657009123127, + "version": "0.4.5" + }, + "colorama-0.4.6-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7af8aba349d231595e84a92b6eede917", + "name": "colorama", + "sha256": "5ecff6ab64187bb83694ffab78287f04ee2f3ce0ae989b5912207eef31e83b51", + "size": 32145, + "subdir": "linux-64", + "timestamp": 1672386582651, + "version": "0.4.6" + }, + "colorama-0.4.6-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e9e95330183ae1f49a4448bc772c0f86", + "name": "colorama", + "sha256": "c7f59d124c0ff97aa3813de589e93f31172210823f9eab3b34a7944a66885114", + "size": 36496, + "subdir": "linux-64", + "timestamp": 1676827050831, + "version": "0.4.6" + }, + "colorama-0.4.6-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "969493459912f6292afd86bc5916be98", + "name": "colorama", + "sha256": "01fb460ad7a04949f7f98864b637779bce161e562ca2b65f3680d1dc849ec566", + "size": 31811, + "subdir": "linux-64", + "timestamp": 1672386609875, + "version": "0.4.6" + }, + "colorama-0.4.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "95aeda2b2d5ac3d7eb743485309c00f1", + "name": "colorama", + "sha256": "72f10fa6df6d5bb8fa8bc28e2a6f967c32e09b9911a85f1d6f9ca9eb5feb382c", + "size": 31756, + "subdir": "linux-64", + "timestamp": 1672386556566, + "version": "0.4.6" + }, + "colorama-0.4.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ae47f0eeea0e7780ddd4b269884b3e99", + "name": "colorama", + "sha256": "9ef54e9f4208c29988232b1b37e33c6ea6462fbce42b5117d1e5ea70ff10c8c7", + "size": 31659, + "subdir": "linux-64", + "timestamp": 1672386636044, + "version": "0.4.6" + }, + "colorcet-1.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "CC-BY-4.0", + "md5": "57f4565d76d78aeafbf88e6c4941f65d", + "name": "colorcet", + "sha256": "ed6d3fce5056c02122d1ed2cd0ab60087054ccd6e0649a6f0f6ef2ce63ce2b06", + "size": 282604, + "subdir": "linux-64", + "timestamp": 1519145496168, + "version": "1.0.0" + }, + "colorcet-1.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "CC-BY-4.0", + "md5": "b15792a54136ce2be1cd6e6444c905ad", + "name": "colorcet", + "sha256": "93a0cccdea399a0716b26d68d2dc33faeda42c93ff22f271942d95bd9875cc95", + "size": 283076, + "subdir": "linux-64", + "timestamp": 1519145501571, + "version": "1.0.0" + }, + "colorcet-1.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "CC-BY-4.0", + "md5": "2ebecac0ce5b3b7577abff039a9708da", + "name": "colorcet", + "sha256": "2e10a7387be1a3d74ffbbf3115aba37328247bcfb94c3f230b82f003d203c248", + "size": 265721, + "subdir": "linux-64", + "timestamp": 1519145504598, + "version": "1.0.0" + }, + "colorcet-1.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "CC-BY-4.0", + "md5": "632dc34c13d9c47c1802040614de25a5", + "name": "colorcet", + "sha256": "422b58a75fdde7439b87050d214732f6d657f103c300677d942287e232c41115", + "size": 265593, + "subdir": "linux-64", + "timestamp": 1530812294620, + "version": "1.0.0" + }, + "colorcet-3.0.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "pyct >=0.4.4", + "python >=3.10,<3.11.0a0" + ], + "license": "CC-BY-4.0", + "license_family": "CC", + "md5": "8cb3f3eb127d287cca2e513e06ab50f2", + "name": "colorcet", + "sha256": "97b9e9a0d29dd76bbe4a9f259ebc7a5b847da2276a80c5c17d2ae06f58a8e05d", + "size": 1859956, + "subdir": "linux-64", + "timestamp": 1651833376951, + "version": "3.0.0" + }, + "colorcet-3.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "pyct >=0.4.4", + "python >=3.7,<3.8.0a0" + ], + "license": "CC-BY-4.0", + "license_family": "CC", + "md5": "317f4f4aca132ca0f4caae66b3e9a43a", + "name": "colorcet", + "sha256": "b94f4dd4b5498f3fd38aa42968e5e941e89ad1f7de57775175464c5220e1a42a", + "size": 1869774, + "subdir": "linux-64", + "timestamp": 1651833625549, + "version": "3.0.0" + }, + "colorcet-3.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "pyct >=0.4.4", + "python >=3.8,<3.9.0a0" + ], + "license": "CC-BY-4.0", + "license_family": "CC", + "md5": "0dc4c52de80736a9045497d14b3e0080", + "name": "colorcet", + "sha256": "9988a102d4f18aca43cf125bb0659075a16c9a968f302a447ee701c750bc5acf", + "size": 1870479, + "subdir": "linux-64", + "timestamp": 1651851479791, + "version": "3.0.0" + }, + "colorcet-3.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "pyct >=0.4.4", + "python >=3.9,<3.10.0a0" + ], + "license": "CC-BY-4.0", + "license_family": "CC", + "md5": "c8d175c21c55ce0d5f18fbd2703ab38e", + "name": "colorcet", + "sha256": "a7ce0f9ea363005fc49c4cbed8240c685a0b34dbb46a1b60b75ad7cce653aa47", + "size": 1854926, + "subdir": "linux-64", + "timestamp": 1651851479683, + "version": "3.0.0" + }, + "colorcet-3.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pyct >=0.4.4", + "python >=3.10,<3.11.0a0" + ], + "license": "CC-BY-4.0", + "license_family": "CC", + "md5": "4cd4d359c6cfaae5ee2ca70d6d569d87", + "name": "colorcet", + "sha256": "a1f4211e75cffbfc3df48b72eebd65b832e104e315b3fc1fa9985b8c544853df", + "size": 1989019, + "subdir": "linux-64", + "timestamp": 1668084644133, + "version": "3.0.1" + }, + "colorcet-3.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pyct >=0.4.4", + "python >=3.11,<3.12.0a0" + ], + "license": "CC-BY-4.0", + "license_family": "CC", + "md5": "45af5f92bb805ea78a802a82434e2bed", + "name": "colorcet", + "sha256": "6419825105778d98e78ccdf597e78ae5e09f1bdd2493677b4f330d349304ca32", + "size": 1924424, + "subdir": "linux-64", + "timestamp": 1676839188918, + "version": "3.0.1" + }, + "colorcet-3.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pyct >=0.4.4", + "python >=3.7,<3.8.0a0" + ], + "license": "CC-BY-4.0", + "license_family": "CC", + "md5": "bf359b0b0abdac4b28983743c37bf8ff", + "name": "colorcet", + "sha256": "2d7f3bff69aacfa00986256340839e224fdb7e2b46940c52e4712d02639308f5", + "size": 1999318, + "subdir": "linux-64", + "timestamp": 1668084611209, + "version": "3.0.1" + }, + "colorcet-3.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pyct >=0.4.4", + "python >=3.8,<3.9.0a0" + ], + "license": "CC-BY-4.0", + "license_family": "CC", + "md5": "25be73c979921a530af8deb6f2b18180", + "name": "colorcet", + "sha256": "a104fc74bb1c3fe0fcb3d91e2fea71254b0c3a2625cb76699392062f67f0da66", + "size": 2000224, + "subdir": "linux-64", + "timestamp": 1668084578291, + "version": "3.0.1" + }, + "colorcet-3.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pyct >=0.4.4", + "python >=3.9,<3.10.0a0" + ], + "license": "CC-BY-4.0", + "license_family": "CC", + "md5": "92de92d5c174710b9762860666c9ed1e", + "name": "colorcet", + "sha256": "2fc0eb6d84e4f87ea5c174c85a9428f86411b6ba24c824b66d3e15a196401c9e", + "size": 1982240, + "subdir": "linux-64", + "timestamp": 1668084545510, + "version": "3.0.1" + }, + "coloredlogs-10.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "20117e095629bf099c284cbe1f2c389a", + "name": "coloredlogs", + "sha256": "0a0ac16902678b036f30eb784bb12ec52539679764c8a9f121b61b9108b42878", + "size": 58886, + "subdir": "linux-64", + "timestamp": 1526411758154, + "version": "10.0" + }, + "coloredlogs-10.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "e237ea20061a11b2239c8e6d2bd42a64", + "name": "coloredlogs", + "sha256": "7d33bc285d8f6a1934ca558668ea809f80dbd5c080fd4d8a577c61a6629111d8", + "size": 60695, + "subdir": "linux-64", + "timestamp": 1526411743260, + "version": "10.0" + }, + "coloredlogs-10.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "56ecbaffbb1eb48c02e70868290265bb", + "name": "coloredlogs", + "sha256": "f52999d93a26645b3a5a8060a60b999540c512d45d24751e8602052c9783f660", + "size": 60205, + "subdir": "linux-64", + "timestamp": 1526411730051, + "version": "10.0" + }, + "coloredlogs-10.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a8b00565dc67669b7c97f458317a56e1", + "name": "coloredlogs", + "sha256": "a6f733c7f33fae76ddbb718bbd53bf52795ce6643c87d6cf030dba7683d95642", + "size": 59646, + "subdir": "linux-64", + "timestamp": 1530812322273, + "version": "10.0" + }, + "coloredlogs-10.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "a4e10ab6558fdc10e47fb3bf4160f6e5", + "name": "coloredlogs", + "sha256": "748d76ea0a56e590e9bbbb4a5e2171b1357306b02573a9ceaecd9c689f99d409", + "size": 60233, + "subdir": "linux-64", + "timestamp": 1573741571593, + "version": "10.0" + }, + "coloredlogs-14.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "974a4b858fd448d35e387465702db435", + "name": "coloredlogs", + "sha256": "5147732c1074ee6dfe8be758a1727fabce2af8795d8846733fd0a10f495f03d1", + "size": 61965, + "subdir": "linux-64", + "timestamp": 1598402400480, + "version": "14.0" + }, + "coloredlogs-14.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "67fdd230b9186f749044a76212527f77", + "name": "coloredlogs", + "sha256": "76fed01d0a1a048b8eb6322f779d425f27f64ec5348f5d7458c561793aa3d333", + "size": 61744, + "subdir": "linux-64", + "timestamp": 1598402372710, + "version": "14.0" + }, + "coloredlogs-14.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "a2077916df3d09d8d9b36122e12b97e3", + "name": "coloredlogs", + "sha256": "80cf9017bc6ea6fbfd07ff895c53172a0bad0363208ed5f37dec4cbb6ac303c4", + "size": 62676, + "subdir": "linux-64", + "timestamp": 1598402365865, + "version": "14.0" + }, + "coloredlogs-15.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9b31a1cb9285d815bd2221af62363315", + "name": "coloredlogs", + "sha256": "03025ca39651929a3c2c4ea34d4072b1c427776691667d4b12b95ffae2cfa66d", + "size": 62548, + "subdir": "linux-64", + "timestamp": 1607620761711, + "version": "15.0" + }, + "coloredlogs-15.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "61c0cb22f2f2f9344d8113588f864618", + "name": "coloredlogs", + "sha256": "b921c2a4a619cdaefec0b80795fc0fd676a5ab24f97e4df23849e52991312300", + "size": 62986, + "subdir": "linux-64", + "timestamp": 1607620750476, + "version": "15.0" + }, + "coloredlogs-15.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "2461ade008203a0c27e9ef723c774069", + "name": "coloredlogs", + "sha256": "3d49ebe38edcb4eec713f811ae8ddb7b7c2dcb2319256057e707616c7b625379", + "size": 62188, + "subdir": "linux-64", + "timestamp": 1607620756949, + "version": "15.0" + }, + "coloredlogs-15.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "b6301198e4ea8aa2016035063fd527c7", + "name": "coloredlogs", + "sha256": "08f1c795ae41eb30cf44c595970294986f9b294ca8c9d33991ca21e0dece256c", + "size": 63193, + "subdir": "linux-64", + "timestamp": 1607620704588, + "version": "15.0" + }, + "coloredlogs-15.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=9.1", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e65a410ebeef0859283c5c8b735f312b", + "name": "coloredlogs", + "sha256": "c479ef58cbf65798cda45b51db35e897111aafccb0b84cd3b98d19c31f8e6c74", + "size": 63853, + "subdir": "linux-64", + "timestamp": 1640808650082, + "version": "15.0.1" + }, + "coloredlogs-15.0.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "humanfriendly >=9.1", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be6048dcc4ab85835f20780dd56388c1", + "name": "coloredlogs", + "sha256": "18b24fc1fd987326bd48bc7d69342316833ba73cd922bd5eb7cd252004c5d759", + "size": 66013, + "subdir": "linux-64", + "timestamp": 1668097846243, + "version": "15.0.1" + }, + "coloredlogs-15.0.1-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "humanfriendly >=9.1", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ae080211da99568b30900086b5d9894b", + "name": "coloredlogs", + "sha256": "f9982dbd88d1be534e4915976ff8e7a8470cb3367410b74c8c5ac9c9b5e5771f", + "size": 77393, + "subdir": "linux-64", + "timestamp": 1676843626781, + "version": "15.0.1" + }, + "coloredlogs-15.0.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=9.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ad71337465ea12937b16d9d13a7153f", + "name": "coloredlogs", + "sha256": "5861c0c52f54a96b46d6002d002597f1c017acdd379aba8f89ea15531240b5f1", + "size": 62702, + "subdir": "linux-64", + "timestamp": 1623652097798, + "version": "15.0.1" + }, + "coloredlogs-15.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=9.1", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be5d8df27db616cb474baa72e376ca26", + "name": "coloredlogs", + "sha256": "415447bb31140454d36b6c9f76f2d0ecfb3afc03a094c706d0a2a2d3ad8bc547", + "size": 62261, + "subdir": "linux-64", + "timestamp": 1623657678958, + "version": "15.0.1" + }, + "coloredlogs-15.0.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "humanfriendly >=9.1", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec2370f7a5219c8a8e9a23b057ed083f", + "name": "coloredlogs", + "sha256": "1e715cd4382329fed9a104396a75119aa0181ef3ff3b729a1762db68692a3afd", + "size": 65851, + "subdir": "linux-64", + "timestamp": 1668097795444, + "version": "15.0.1" + }, + "coloredlogs-15.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=9.1", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e5bce7b51b06881f2e543c59b08b8e5f", + "name": "coloredlogs", + "sha256": "0ae8e6fb36c8f0927ebb087da0c1cd35e743c5812154a07d6959cbdc7e961ab1", + "size": 62444, + "subdir": "linux-64", + "timestamp": 1623657837461, + "version": "15.0.1" + }, + "coloredlogs-15.0.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "humanfriendly >=9.1", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e31ca526003e626c041b3f6f870e18a1", + "name": "coloredlogs", + "sha256": "137c9b05666850013bd7fae4353152834f651d663416b8c7e410092c4ebe37c6", + "size": 65794, + "subdir": "linux-64", + "timestamp": 1668097820634, + "version": "15.0.1" + }, + "coloredlogs-15.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "humanfriendly >=9.1", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bdb29fe038bc9fa2915b87bdb7b369e4", + "name": "coloredlogs", + "sha256": "fbc5445a3e442d506f626a565f15b76d0828da35edffe94828c2d9f8817cc65c", + "size": 62221, + "subdir": "linux-64", + "timestamp": 1623657861874, + "version": "15.0.1" + }, + "coloredlogs-15.0.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "humanfriendly >=9.1", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "764aa544f6fa339aefb8fd283e5df5b8", + "name": "coloredlogs", + "sha256": "f770b8909ccb368e488d1ba0f576cdcbf8966e9e4a7e13b81cd7a39fd6277f72", + "size": 65949, + "subdir": "linux-64", + "timestamp": 1668097871432, + "version": "15.0.1" + }, + "coloredlogs-7.1-py27h929f1d2_0.conda": { + "build": "py27h929f1d2_0", + "build_number": 0, + "depends": [ + "humanfriendly >=3.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9d5219be11b42310397ba8b18c22578d", + "name": "coloredlogs", + "sha256": "5be7163b3a3faeec2a4b4a030c839e6935828e8ba76e7e8e02a4bef303aa77a8", + "size": 46076, + "subdir": "linux-64", + "timestamp": 1505742020128, + "version": "7.1" + }, + "coloredlogs-7.1-py35h5a61da6_0.conda": { + "build": "py35h5a61da6_0", + "build_number": 0, + "depends": [ + "humanfriendly >=3.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "4426c60e73d1a083eb2c96146c493af5", + "name": "coloredlogs", + "sha256": "a0a062a264c6d4d6f09fdd5418f39078b4d169c815c5be46dd169f46724fc587", + "size": 46877, + "subdir": "linux-64", + "timestamp": 1505742032983, + "version": "7.1" + }, + "coloredlogs-7.1-py36h6efce94_0.conda": { + "build": "py36h6efce94_0", + "build_number": 0, + "depends": [ + "humanfriendly >=3.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "bd73bd54472a56a7ee18fb862e3b5c0c", + "name": "coloredlogs", + "sha256": "68ead601fc2b38b647865e6eb177796af2926505084df7652b20b1c215b30e57", + "size": 45918, + "subdir": "linux-64", + "timestamp": 1505742045841, + "version": "7.1" + }, + "coloredlogs-7.3.1-py27ha28782c_0.conda": { + "build": "py27ha28782c_0", + "build_number": 0, + "depends": [ + "humanfriendly >=3.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "8407904328e706d1e6d24dcbb46f8914", + "name": "coloredlogs", + "sha256": "8b78d7b1eaf6b20ecc7f15768b91a5982421c17b5d9aab8c7555ee0db26cd62e", + "size": 46423, + "subdir": "linux-64", + "timestamp": 1511833935054, + "version": "7.3.1" + }, + "coloredlogs-7.3.1-py35hcde8493_0.conda": { + "build": "py35hcde8493_0", + "build_number": 0, + "depends": [ + "humanfriendly >=3.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "f0b09984b4622d9cd734b8b293ba8a72", + "name": "coloredlogs", + "sha256": "d07e49aba38e18533d2c74307d04929dd2e51c30b0a8a12d95f5da35e44b2e67", + "size": 46955, + "subdir": "linux-64", + "timestamp": 1511833934162, + "version": "7.3.1" + }, + "coloredlogs-7.3.1-py36h93c201e_0.conda": { + "build": "py36h93c201e_0", + "build_number": 0, + "depends": [ + "humanfriendly >=3.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3b5453229ec7c6d5f0c0429705799df6", + "name": "coloredlogs", + "sha256": "ff874f4b2b99209306709480511055d42328f7b2e36cfbdca1c5bfd3eaf4fe1a", + "size": 47275, + "subdir": "linux-64", + "timestamp": 1511833935373, + "version": "7.3.1" + }, + "coloredlogs-9.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "086ad586173c6f2a3ce80a1957b6760f", + "name": "coloredlogs", + "sha256": "58a1caa65425eac7a07014115a26ad5742bbabb84c0c308cb3e51cb8d9e1bd1e", + "size": 53731, + "subdir": "linux-64", + "timestamp": 1519067891598, + "version": "9.0" + }, + "coloredlogs-9.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "bbc717aa21b7d59f05d5f779cda74066", + "name": "coloredlogs", + "sha256": "e7336eddd809d19b570c4ffb2c98b4a4687fce1d9e892e10b544bbe5e28e5525", + "size": 54331, + "subdir": "linux-64", + "timestamp": 1519067955825, + "version": "9.0" + }, + "coloredlogs-9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "humanfriendly >=4.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "acfcbb27509df3c4f05aff326f26a25c", + "name": "coloredlogs", + "sha256": "1ee159a9eec0860553ff8fbfc3f31e591c67a583eb214561197c109e0c1c2471", + "size": 55211, + "subdir": "linux-64", + "timestamp": 1519067933353, + "version": "9.0" + }, + "colorlog-4.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "49fa470dfbcc7f2880ba495058fc9eaf", + "name": "colorlog", + "sha256": "420d8332df06446d2c783d6f987eccbd0635320a9dd1653f294e5c721dbc093f", + "size": 23409, + "subdir": "linux-64", + "timestamp": 1579610324373, + "version": "4.0.2" + }, + "colorlog-4.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3dc98a9ad8ab78b0d8f987b3641bdf70", + "name": "colorlog", + "sha256": "3a4189bf4e60c846a1f4f14443d6033da43ffdaa9c8ce22ad55be4ee9d508b8b", + "size": 23496, + "subdir": "linux-64", + "timestamp": 1579610327632, + "version": "4.0.2" + }, + "colorlog-4.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c3a3d511f17103709900e70bad255cd2", + "name": "colorlog", + "sha256": "4b39a16dc39953c41a546fdbcd9cefe0b1ccd606ea39d2154f81a1ffc85e6fc7", + "size": 23311, + "subdir": "linux-64", + "timestamp": 1579610297445, + "version": "4.0.2" + }, + "colorlog-4.0.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "93ad7468bbc29bbb9b412a8360a884de", + "name": "colorlog", + "sha256": "204f61f11ff2bfe05cd6b033e273faecb37db782ac9c0cd75b239ad0c9528a9e", + "size": 23668, + "subdir": "linux-64", + "timestamp": 1579610328408, + "version": "4.0.2" + }, + "colorlog-4.1.0-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7e140eeac4715d4889bc2f87d878c6d0", + "name": "colorlog", + "sha256": "9a231086712f0b3c6d12780f806ed1fa9eda244b2f10eff5c879a4e92f96d7e2", + "size": 20890, + "subdir": "linux-64", + "timestamp": 1594344360049, + "version": "4.1.0" + }, + "colorlog-4.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f59813a561a549a5aee6cf451113e1b0", + "name": "colorlog", + "sha256": "1d1daa832a03032052bb3199bb90c92c75c85a12bbcbe267e4da8497d6e50b61", + "size": 24150, + "subdir": "linux-64", + "timestamp": 1596109906115, + "version": "4.2.1" + }, + "colorlog-4.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3b500887a85737584ceab3140656a1dd", + "name": "colorlog", + "sha256": "3e86f07340335dec6d64e799b009fa50b9ec1d28d637388b92d1d48458d351e0", + "size": 24092, + "subdir": "linux-64", + "timestamp": 1596128714439, + "version": "4.2.1" + }, + "colorlog-4.2.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "bf093b5c2542a3a38348aaa4c77515ed", + "name": "colorlog", + "sha256": "937fb31efc4b457b34fdb898422c6174729b381c918de424446920324a55d92f", + "size": 24391, + "subdir": "linux-64", + "timestamp": 1596109909721, + "version": "4.2.1" + }, + "colorlog-4.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "aa2c6e01ea81fa16f882b38d880cfced", + "name": "colorlog", + "sha256": "978303f51203f790c42d7968ff56d932533c8345be0cdbecbbb8ea7741d39a63", + "size": 21764, + "subdir": "linux-64", + "timestamp": 1602256051993, + "version": "4.4.0" + }, + "colorlog-4.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4d252fb08439e2b83b1bb111e020a815", + "name": "colorlog", + "sha256": "9df93920e704ce108e112084f2ce25e1738c77d28f0306f6e8bf4e489a047fd5", + "size": 21800, + "subdir": "linux-64", + "timestamp": 1602256058298, + "version": "4.4.0" + }, + "colorlog-4.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "3a532bab08f343564f945b216698912c", + "name": "colorlog", + "sha256": "d3306abfba8be7052c3ec6311592a364b766b9484c3884b3c26954f098001cbd", + "size": 21940, + "subdir": "linux-64", + "timestamp": 1602256061991, + "version": "4.4.0" + }, + "colorlog-4.6.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "fbe7655b69b8a02dd23e2f4df98f6758", + "name": "colorlog", + "sha256": "addf06d6fb80b052c6212a33e02b49990469c5873f9eff9ffe5a89f98dda834e", + "size": 15523, + "subdir": "linux-64", + "timestamp": 1605061878597, + "version": "4.6.2" + }, + "colorlog-4.6.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7b61ed6b6be566f77220fa3cec285259", + "name": "colorlog", + "sha256": "190e1773ef5e7e35a559b268cdfff4fcb3c70f94c76c8c19b4af820e62844413", + "size": 15505, + "subdir": "linux-64", + "timestamp": 1605061909588, + "version": "4.6.2" + }, + "colorlog-4.6.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "38dec7d1367f40af317077442e3954e8", + "name": "colorlog", + "sha256": "649bea28d2ab58caadde30df47f919599f40ddb9ccb77869d5a5230c9c219273", + "size": 15482, + "subdir": "linux-64", + "timestamp": 1605061906741, + "version": "4.6.2" + }, + "colorlog-4.6.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "4c1d2b7e8c7b12d9ce2003e6a48a1a2c", + "name": "colorlog", + "sha256": "2515880242731e5891831698d1b7ce725e802ba31e57afdb940528bea5e1d679", + "size": 15538, + "subdir": "linux-64", + "timestamp": 1605061879582, + "version": "4.6.2" + }, + "colorlog-4.7.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "15916301bb5d027d8791abb8fe971ea5", + "name": "colorlog", + "sha256": "c87ca2a7dfef0a680e05b67e02e75e90ebd616195f98c2d8fa9b0dd1fdb132c4", + "size": 15711, + "subdir": "linux-64", + "timestamp": 1610638734062, + "version": "4.7.2" + }, + "colorlog-4.7.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "778977709f5abfdfc1c6ac86b5bb4738", + "name": "colorlog", + "sha256": "51816dcf1ef1e8e6e1e672a4ea96d8b2caef8b5aec6a5a64ddb68bf354b15b73", + "size": 15700, + "subdir": "linux-64", + "timestamp": 1610638718685, + "version": "4.7.2" + }, + "colorlog-4.7.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "d7d33c0be640fb55c06697361c101cf1", + "name": "colorlog", + "sha256": "83ddbc9adcde8de3b2c418b65e65fb8440bc06d4e30e8faf6c0e0b4baee2c1e1", + "size": 15663, + "subdir": "linux-64", + "timestamp": 1610638762014, + "version": "4.7.2" + }, + "colorlog-4.7.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "3b943e2836d05d7a0772fd46c1cdb239", + "name": "colorlog", + "sha256": "4c3cf44b9c82d835e2e4ff60606691a0f1654f0abc18eedd8483be8e2316d638", + "size": 15672, + "subdir": "linux-64", + "timestamp": 1610638731314, + "version": "4.7.2" + }, + "colorlog-4.8.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "8c346367cd91347cf60b732e49ef26a6", + "name": "colorlog", + "sha256": "91900f4ebd0c4dbfe724d12d77ab5eb3c8f401de71a6d39fd5d6644cb1bf71ac", + "size": 15315, + "subdir": "linux-64", + "timestamp": 1659787862390, + "version": "4.8.0" + }, + "colorlog-4.8.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a44cd725d32dd41954f5aae6bd3f4c92", + "name": "colorlog", + "sha256": "d8b4106a996cb84ab2032e5a8e56e7b84bdd6355fadc0d6351896fc327e25b6f", + "size": 15656, + "subdir": "linux-64", + "timestamp": 1616441703366, + "version": "4.8.0" + }, + "colorlog-4.8.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "40b242e0fb71f1076fd0addf9fd74659", + "name": "colorlog", + "sha256": "3a3477b54b2929b63632059efd884ecfb2700206cfc0f6254ec7ba1e1e5ef44e", + "size": 15628, + "subdir": "linux-64", + "timestamp": 1616441690750, + "version": "4.8.0" + }, + "colorlog-4.8.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "04ec3b6d756923c587be9de234f1a83a", + "name": "colorlog", + "sha256": "4721801e633c6dfd24804db98f0bce7979ed2767f3ec7d9f293bafd45e0cb1f5", + "size": 15545, + "subdir": "linux-64", + "timestamp": 1616441701284, + "version": "4.8.0" + }, + "colorlog-4.8.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "c69864d3ad1ee139add8d353577e0f4a", + "name": "colorlog", + "sha256": "0b4402cdbe4fe942342f846107db2c46af6e851c5a3f5af0dfdcf41670419308", + "size": 15616, + "subdir": "linux-64", + "timestamp": 1616442749917, + "version": "4.8.0" + }, + "colorlog-5.0.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "64a92ac12453dd582561b08f226c34cb", + "name": "colorlog", + "sha256": "9801bb755df05ce10038abf7ee047ad7372c58f1fa27377e278b2d52da960629", + "size": 15797, + "subdir": "linux-64", + "timestamp": 1640789113782, + "version": "5.0.1" + }, + "colorlog-5.0.1-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "959760da5f05c9da72f938411c6d67a8", + "name": "colorlog", + "sha256": "91fde83ae2b4f1f057b324d945f859f56b7ec8aa8f04a5f41650da070f8bef43", + "size": 18468, + "subdir": "linux-64", + "timestamp": 1676830303273, + "version": "5.0.1" + }, + "colorlog-5.0.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "fccf6a2b39289e8466042c3b3aa95737", + "name": "colorlog", + "sha256": "396248b69ed6334e0d66c1fdaf5f60abea6a4b44804463794c26fb4dc4bd451d", + "size": 15976, + "subdir": "linux-64", + "timestamp": 1618421517613, + "version": "5.0.1" + }, + "colorlog-5.0.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8544e365011f871a777fb150f9bedf14", + "name": "colorlog", + "sha256": "6de8a4d10c52b89e7098452e8d3403f45151c87753c98f2c40a0605dcb0fd518", + "size": 15977, + "subdir": "linux-64", + "timestamp": 1618424631529, + "version": "5.0.1" + }, + "colorlog-5.0.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "fa68cb4042eab939a334b0a9faf37700", + "name": "colorlog", + "sha256": "fba0f7ff3b234eb4556828724a2a830bae003c453cc0a3623932b79469c6b544", + "size": 15992, + "subdir": "linux-64", + "timestamp": 1618424636494, + "version": "5.0.1" + }, + "colorlog-5.0.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "a48c6d4e7774c97ee4e32f05fcdee8e4", + "name": "colorlog", + "sha256": "59d06d5a951b923ace352351a4d547461c1792fe93cd0d4affc19dff474180ea", + "size": 16003, + "subdir": "linux-64", + "timestamp": 1618424627858, + "version": "5.0.1" + }, + "colorspacious-1.1.2-py310h2f386ee_0.conda": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "919b9e2811819000784de961d46dc847", + "name": "colorspacious", + "sha256": "bcc86c877b5f5eab8321f2ded0456038aec230dd92e49bf9730638c903cf3cf1", + "size": 64642, + "subdir": "linux-64", + "timestamp": 1680616714545, + "version": "1.1.2" + }, + "colorspacious-1.1.2-py311h92b7b1e_0.conda": { + "build": "py311h92b7b1e_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b425a5db4fe150366379c9c66a001b7", + "name": "colorspacious", + "sha256": "29cd36855c840e3aa08838d47d07e0f3eadd95a76b7786e90981fb63c475f33f", + "size": 81497, + "subdir": "linux-64", + "timestamp": 1680616749222, + "version": "1.1.2" + }, + "colorspacious-1.1.2-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d72b66aa02ebddf8eccb44577adfc0e", + "name": "colorspacious", + "sha256": "d1813c7a56fd4440a465c9652187f353a7400d37adde3cf5d839548ac2a41c8c", + "size": 64767, + "subdir": "linux-64", + "timestamp": 1680616784262, + "version": "1.1.2" + }, + "colorspacious-1.1.2-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83b21289db788577cc68c5e2958b5cbc", + "name": "colorspacious", + "sha256": "7646fe0afa9f9c5c8820df381475c84e8b50533d962642468b08cf6fd3d75399", + "size": 64311, + "subdir": "linux-64", + "timestamp": 1680616818907, + "version": "1.1.2" + }, + "colour-0.1.4-py27hfe1fa20_0.conda": { + "build": "py27hfe1fa20_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a34a4b38b18c0a9df9af1f2450bf4af2", + "name": "colour", + "sha256": "4c39c8db775e62d74e73c81989f9192c4994827fbc794e3d9e82e3594a23171f", + "size": 26890, + "subdir": "linux-64", + "timestamp": 1507380363367, + "version": "0.1.4" + }, + "colour-0.1.4-py35h9dd72a6_0.conda": { + "build": "py35h9dd72a6_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "786838d2ddb9b070c3f8e0a9c2a5a5c7", + "name": "colour", + "sha256": "89515e397cfc20f36740946386733e489f90905ab86c6be63b1b7787409fc558", + "size": 27285, + "subdir": "linux-64", + "timestamp": 1507380305267, + "version": "0.1.4" + }, + "colour-0.1.4-py36hc4b9af0_0.conda": { + "build": "py36hc4b9af0_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "873e43dfe1913bb2100b2648c4b873bc", + "name": "colour", + "sha256": "76472e3876c0c59a8fd1ecd28c7493da0cc48a25a086c09439c86d316da37ebb", + "size": 27622, + "subdir": "linux-64", + "timestamp": 1507380373084, + "version": "0.1.4" + }, + "colour-0.1.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "90b118e94d36b914d7493b685d873d93", + "name": "colour", + "sha256": "69e821f07927b4a3273e384365f6b8bfc81d88714977ea612401e811e5ad0b4b", + "size": 26412, + "subdir": "linux-64", + "timestamp": 1530812421995, + "version": "0.1.5" + }, + "colour-0.1.5-py27hc2ab70b_0.conda": { + "build": "py27hc2ab70b_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "02b89b267915f46fa6000b2d8b6a1a8f", + "name": "colour", + "sha256": "9371ea6bc3b2f7508cd6d7a5ab0c5fbea1af71d7968eaedec999c22d0c75c623", + "size": 26719, + "subdir": "linux-64", + "timestamp": 1511838122845, + "version": "0.1.5" + }, + "colour-0.1.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8f41673ba13b252285088be6f85c97d4", + "name": "colour", + "sha256": "6b53a680361a204a609a156757a409140dbcfb14734afd2bcc92fed52d2d25de", + "size": 27674, + "subdir": "linux-64", + "timestamp": 1642498789456, + "version": "0.1.5" + }, + "colour-0.1.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "6d7a429235dbff3cc36c2be8d1e94f5a", + "name": "colour", + "sha256": "72bd0305cd5abb2924c33ee38200b371d747eb708a26364c2348c93650bbea0a", + "size": 31941, + "subdir": "linux-64", + "timestamp": 1676827064417, + "version": "0.1.5" + }, + "colour-0.1.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "16f36657ce3d0ecaa9b73920eecbd809", + "name": "colour", + "sha256": "4065ac57183ed85e256f87373d729de0102a3a366de47f3fe5e1d4419be0d2e8", + "size": 27031, + "subdir": "linux-64", + "timestamp": 1535130080582, + "version": "0.1.5" + }, + "colour-0.1.5-py35h628fc48_0.conda": { + "build": "py35h628fc48_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ba5e32b541591eb47897069a8482c401", + "name": "colour", + "sha256": "f3743acd2180dc1908f2bddaa488ed7200e4930461fd3ebdf0b64f8f5b491c32", + "size": 27291, + "subdir": "linux-64", + "timestamp": 1511838150145, + "version": "0.1.5" + }, + "colour-0.1.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "764f5b069b63d5a9b638ccccc84a66c7", + "name": "colour", + "sha256": "d9f79197b44b0a0fbc42116326819d4cbe1d04c4f923030d3d1cf63f58c47586", + "size": 27371, + "subdir": "linux-64", + "timestamp": 1530812470200, + "version": "0.1.5" + }, + "colour-0.1.5-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "0fea93d302c5f7fd8aba73f46615e162", + "name": "colour", + "sha256": "74ae5ffb58ccf2e3751a9b546bd4b652eec75825ad31ee3abed16ff4fe166b19", + "size": 27962, + "subdir": "linux-64", + "timestamp": 1611677515338, + "version": "0.1.5" + }, + "colour-0.1.5-py36ha0e6178_0.conda": { + "build": "py36ha0e6178_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "fc379aaf93f49330fbde26d1828332fa", + "name": "colour", + "sha256": "780959a24b165aba33ba52288391ffb60531af03bf1796426a2cef19915b54ce", + "size": 27693, + "subdir": "linux-64", + "timestamp": 1511838159395, + "version": "0.1.5" + }, + "colour-0.1.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a3eb7618fcdf3c1ebdbf37c9b80115cf", + "name": "colour", + "sha256": "a2add75d2cc1bd9093762ff97ec8de8e39690e6595dded24f22895a07fe02b03", + "size": 26608, + "subdir": "linux-64", + "timestamp": 1530812445891, + "version": "0.1.5" + }, + "colour-0.1.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5404bd02af5db13783595c62dbf7c7fe", + "name": "colour", + "sha256": "b2309ed5f0358efae03f68b18876faeeb3c963741ceb736cdd1e63236d075482", + "size": 27382, + "subdir": "linux-64", + "timestamp": 1611678448752, + "version": "0.1.5" + }, + "colour-0.1.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "38f5bfc55f17fc99d79cec318812e951", + "name": "colour", + "sha256": "a972110822ff859000ae19a12fb4394855cf0c0df7e3461ecf05ff0504a32a5a", + "size": 27252, + "subdir": "linux-64", + "timestamp": 1573033880420, + "version": "0.1.5" + }, + "colour-0.1.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "83d999fe063e7780a304c2008b2a5522", + "name": "colour", + "sha256": "feb7f0e121c3542763ce3890ba2d1a7fcca7f3a4b2dab0e58b3063a2e60aeb9f", + "size": 27510, + "subdir": "linux-64", + "timestamp": 1611677567509, + "version": "0.1.5" + }, + "colour-0.1.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d206f37be215ab0ccacf1dc1604cf010", + "name": "colour", + "sha256": "d3d3559e04f4c913ddb3a56fa5ad1a4fa9e6d08813a54a234345293d1bfc3463", + "size": 27734, + "subdir": "linux-64", + "timestamp": 1611677549843, + "version": "0.1.5" + }, + "comm-0.1.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fd29ad6f2786467048e4b9d3b9078a1d", + "name": "comm", + "sha256": "30a612387662a18f1b7ef8fe744092bb7a8181fb56bcae7e3505406b89eef837", + "size": 13461, + "subdir": "linux-64", + "timestamp": 1671231151980, + "version": "0.1.2" + }, + "comm-0.1.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "671a6ef124e78b17208a9f246b350ba7", + "name": "comm", + "sha256": "68b943710b6b8b7eb8e1645d8f1e4fcb7d58e4a29b3bfa5551b2a23abe50f551", + "size": 14461, + "subdir": "linux-64", + "timestamp": 1677709155428, + "version": "0.1.2" + }, + "comm-0.1.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fd078c0c92ae912f22c88bc21f0b6e7c", + "name": "comm", + "sha256": "c5c5332b4e5b1721ce4217fa4c66c1a7deedb12193e0a447c69fc10c6a50a5d9", + "size": 13379, + "subdir": "linux-64", + "timestamp": 1671231179439, + "version": "0.1.2" + }, + "comm-0.1.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e03a316451ed28d30858010ca0c2796", + "name": "comm", + "sha256": "56636cb7ce44bb24949d08843dbfa855b7e43d119e79319b2c388e252c37247d", + "size": 13413, + "subdir": "linux-64", + "timestamp": 1671231231929, + "version": "0.1.2" + }, + "comm-0.1.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e0750c886f348ab2917ad5075b5de92c", + "name": "comm", + "sha256": "8d33af93eb2e4bae07fae15df71b0a6589c298c22ef5ff2675ae2c718bd9ac68", + "size": 13393, + "subdir": "linux-64", + "timestamp": 1671231205875, + "version": "0.1.2" + }, + "commonmark-0.7.4-py27h72fa2ff_0.conda": { + "build": "py27h72fa2ff_0", + "build_number": 0, + "depends": [ + "future", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "37102f5c90c16c3e282e6e59e0cc9fd9", + "name": "commonmark", + "sha256": "af248ac00356ed5de5e7c890dcebb56a4767f94a51afba7b3eada41664c1a610", + "size": 133149, + "subdir": "linux-64", + "timestamp": 1509258327521, + "version": "0.7.4" + }, + "commonmark-0.7.4-py35h6786c5e_0.conda": { + "build": "py35h6786c5e_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1b03317e8a037f0ac4808a659d86ec28", + "name": "commonmark", + "sha256": "b615c1db144d6d20698882c67ea2f1b821faa913ec1c84225dace3db4673854e", + "size": 132878, + "subdir": "linux-64", + "timestamp": 1509258340432, + "version": "0.7.4" + }, + "commonmark-0.7.4-py36h4201aee_0.conda": { + "build": "py36h4201aee_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f1dfabf58a2d657648459e5dc802ed3d", + "name": "commonmark", + "sha256": "3d6155b10b4e750e9c76605a40ab2deeb9407e4c38d3ad85e96d59f34682c0e7", + "size": 126267, + "subdir": "linux-64", + "timestamp": 1509258329934, + "version": "0.7.4" + }, + "commonmark-0.7.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "future", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2f6d5e66bd7ee009a9c663f71c6fb373", + "name": "commonmark", + "sha256": "286bc17d65d3354ba74b92f2483220488170c7dd0bc34fdac21109db5cf8dc2d", + "size": 134316, + "subdir": "linux-64", + "timestamp": 1522193091440, + "version": "0.7.5" + }, + "commonmark-0.7.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "faa0ccf2817c3cec249920b56e5bbf7a", + "name": "commonmark", + "sha256": "28ebb963c785f099910da67b9c279da6ccdd42a7a454115efb99252ddb4993d9", + "size": 134050, + "subdir": "linux-64", + "timestamp": 1522193123699, + "version": "0.7.5" + }, + "commonmark-0.7.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8e24da8546f41f5b6f0d176eb2e28367", + "name": "commonmark", + "sha256": "9010920f9e81af8719279383dcb74d0ba490f9d47b61ddd788a1bcdccf8167fa", + "size": 127027, + "subdir": "linux-64", + "timestamp": 1522193118643, + "version": "0.7.5" + }, + "commonmark-0.7.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b74cef5437999878a8fb836d79e7b697", + "name": "commonmark", + "sha256": "63b276df8099f592790a61a8c75ac587ac58f3006500977d2dabf442b22183a1", + "size": 126608, + "subdir": "linux-64", + "timestamp": 1530812730975, + "version": "0.7.5" + }, + "commonmark-0.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "future", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cfcc260f21bcfb3c71f48ab49d52e14a", + "name": "commonmark", + "sha256": "5714e1d36e7b05cb6972582bfb94b5e291ee70aa20440db5a7e3df74993aa294", + "size": 135549, + "subdir": "linux-64", + "timestamp": 1536272679477, + "version": "0.8.1" + }, + "commonmark-0.8.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3ccbed42f86a2aeed28326d7f86c4e93", + "name": "commonmark", + "sha256": "4c75b179e2dfc8b1b49b932a13ad9ffbeb8c9b8568a170f207250b2f2d74bf0f", + "size": 135921, + "subdir": "linux-64", + "timestamp": 1536272711658, + "version": "0.8.1" + }, + "commonmark-0.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f3f699eb496ed6a6587b5fc730f0fbeb", + "name": "commonmark", + "sha256": "95960b66d72e6c548f18eabbba29858ab1f0568a921c83d14c9a09da9f6a1cc5", + "size": 128505, + "subdir": "linux-64", + "timestamp": 1536272650309, + "version": "0.8.1" + }, + "commonmark-0.8.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a641ef474c8c3c2af89835ac4d1d05d0", + "name": "commonmark", + "sha256": "2fa89dedacc1f40815f1402d3105692a8a9e76259c72392f9f367adb1f171c19", + "size": 128718, + "subdir": "linux-64", + "timestamp": 1536272709325, + "version": "0.8.1" + }, + "compiler-rt-14.0.6-hdb19cb5_0.conda": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "clang 14.0.6.*", + "clangxx 14.0.6.*", + "compiler-rt_linux-64 14.0.6.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "c989823952df29b837850301df72803c", + "name": "compiler-rt", + "sha256": "652e6a06f55df45e8ea736200eb9e1b28cb4005ef7b85d7c06bd89ea974e9947", + "size": 104028, + "subdir": "linux-64", + "timestamp": 1662620696837, + "version": "14.0.6" + }, + "compiler-rt_linux-64-14.0.6-h2bdc9af_0.conda": { + "build": "h2bdc9af_0", + "build_number": 0, + "constrains": [ + "compiler-rt 14.0.6" + ], + "depends": [ + "clang 14.0.6.*", + "clangxx 14.0.6.*" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "069e1dbc3a4446bd0754249254c96ad8", + "name": "compiler-rt_linux-64", + "sha256": "32cc3d240d02597b442e861e8003c6b7a87decfa6e52c2cbe8ccc88acbd142c3", + "size": 24739162, + "subdir": "linux-64", + "timestamp": 1662620653781, + "version": "14.0.6" + }, + "conda-22.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-libmamba-solver >=22.12.0" + ], + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0f13921d67b437a8a5ab5d088eaae6a3", + "name": "conda", + "sha256": "bc45d01970593aba85fbe59af5afd4d8fd5dabb6d0ed3463c9d860a0c45db12b", + "size": 902929, + "subdir": "linux-64", + "timestamp": 1669901399831, + "version": "22.11.0" + }, + "conda-22.11.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a206ea93c731ad83f52d4377797f756", + "name": "conda", + "sha256": "504797b4f65307cec724015eaa225922f3231a70fe45c5852c9c12a2039bc341", + "size": 959411, + "subdir": "linux-64", + "timestamp": 1669926935220, + "version": "22.11.0" + }, + "conda-22.11.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b06bebacae16c841b70250955e384e80", + "name": "conda", + "sha256": "0dd5439918f89ea71d1af02548e4739fc11aa337d14d24baf7f76aa5d33cd69e", + "size": 886268, + "subdir": "linux-64", + "timestamp": 1669901305611, + "version": "22.11.0" + }, + "conda-22.11.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1fe71700d69e54e7ec1fe9715216be58", + "name": "conda", + "sha256": "1ae0fdb99aa53df760826a204d6e21248b14d012b34bffa7c41085a791354504", + "size": 943132, + "subdir": "linux-64", + "timestamp": 1669927063632, + "version": "22.11.0" + }, + "conda-22.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e77539339c3612ee79a3eee24c671e5b", + "name": "conda", + "sha256": "5979469e8dacd404b6bbb75d3e4a025b80c33fa45a36b5e9d7192dc0deaac3a8", + "size": 901391, + "subdir": "linux-64", + "timestamp": 1669901258138, + "version": "22.11.0" + }, + "conda-22.11.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7d1c05caf8f1a99a98f63921233a3ad4", + "name": "conda", + "sha256": "48d81cde9a77ffd670114da36a90317c26e102e1d4170e2f1ec10afc6d89a05f", + "size": 949289, + "subdir": "linux-64", + "timestamp": 1669927018283, + "version": "22.11.0" + }, + "conda-22.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c01aaa9200e54abea5e4d15ecc76cd14", + "name": "conda", + "sha256": "4fec0bc446bfbfbaafa52e39ff7e39885e355c6224db1ef2daff075ae8b033b1", + "size": 893424, + "subdir": "linux-64", + "timestamp": 1669901353874, + "version": "22.11.0" + }, + "conda-22.11.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "43d7accce4c7d866031eba6d1e837503", + "name": "conda", + "sha256": "d2c7fc387a8180f0808e7bcef273fc86549fa4faedcd046fd2aab177a81591e7", + "size": 948907, + "subdir": "linux-64", + "timestamp": 1669926974969, + "version": "22.11.0" + }, + "conda-22.11.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "constrains": [ + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-build >=3", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "361b11efd1a12f5f36a01617739aae7e", + "name": "conda", + "sha256": "479b9002ca89fd7cb0cccef3aa643306d077503ad857a721ad0e35a9697f4347", + "size": 972035, + "subdir": "linux-64", + "timestamp": 1670407562645, + "version": "22.11.1" + }, + "conda-22.11.1-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "constrains": [ + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-env >=2.6", + "conda-build >=3", + "conda-libmamba-solver >=22.12.0" + ], + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "32ba81d3eeb41780653063321515d5a7", + "name": "conda", + "sha256": "6ccb76df1216d6732e3b9727bd6f464abad0000c3ffce470c8e7e8c88a226131", + "size": 959390, + "subdir": "linux-64", + "timestamp": 1670449284179, + "version": "22.11.1" + }, + "conda-22.11.1-py310h06a4308_3.conda": { + "build": "py310h06a4308_3", + "build_number": 3, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1b30503fcf535fc58e88e85cbd640af2", + "name": "conda", + "sha256": "f4ca8cc2491cb15d8590d91d949797a97dedd5ac4b9792a9f2a92a4f4b4e56f0", + "size": 971185, + "subdir": "linux-64", + "timestamp": 1670452086904, + "version": "22.11.1" + }, + "conda-22.11.1-py310h06a4308_4.conda": { + "build": "py310h06a4308_4", + "build_number": 4, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-libmamba-solver >=22.12.0" + ], + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07e2e8a698cf1e7f580b9efcae72184e", + "name": "conda", + "sha256": "700a77b65f403c3605b6bf41049ffa78b62ee4df81321312fdaaabe163f35808", + "size": 959748, + "subdir": "linux-64", + "timestamp": 1671037196475, + "version": "22.11.1" + }, + "conda-22.11.1-py310h06a4308_5.conda": { + "build": "py310h06a4308_5", + "build_number": 5, + "constrains": [ + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "conda-libmamba-solver >=22.12.0" + ], + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9db84caf81560e0b04bc9f8fc9c132f6", + "name": "conda", + "sha256": "40929e270052e21afdda56ecfc37c31d59de8e536adea96cca49c9176feb4286", + "size": 976734, + "subdir": "linux-64", + "timestamp": 1680642425986, + "version": "22.11.1" + }, + "conda-22.11.1-py311h06a4308_5.conda": { + "build": "py311h06a4308_5", + "build_number": 5, + "constrains": [ + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.11,<3.12.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3f3d927e99f6dc0775be6071eebb0db9", + "name": "conda", + "sha256": "77b2e3f7d282f5fc58130b68cfc401341c1e211a0f5cbe4e513fe343125340b5", + "size": 1294941, + "subdir": "linux-64", + "timestamp": 1680642376298, + "version": "22.11.1" + }, + "conda-22.11.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-build >=3", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4a8a6d68e619cec680e5d5d7654ab796", + "name": "conda", + "sha256": "72351cf52c110676f231de5eb07e24a5235a42e7145d9084dafdb2f7317d58bb", + "size": 955438, + "subdir": "linux-64", + "timestamp": 1670407521352, + "version": "22.11.1" + }, + "conda-22.11.1-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "constrains": [ + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-env >=2.6", + "conda-build >=3", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "254ca44f172de0f480fac2cb43126113", + "name": "conda", + "sha256": "bb1ae8e061b2585c53d914390fb6ee4610dfea8c8cf7ad1dba2c6448170600a6", + "size": 942897, + "subdir": "linux-64", + "timestamp": 1670449326542, + "version": "22.11.1" + }, + "conda-22.11.1-py37h06a4308_3.conda": { + "build": "py37h06a4308_3", + "build_number": 3, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "889e505fc3fb4951fb2da15021654a12", + "name": "conda", + "sha256": "1c73ec7167a80112c13ef609384acb500a5164a506f29d1ccb7b4ad8ac5bd7cb", + "size": 954743, + "subdir": "linux-64", + "timestamp": 1670452045358, + "version": "22.11.1" + }, + "conda-22.11.1-py37h06a4308_4.conda": { + "build": "py37h06a4308_4", + "build_number": 4, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1f45ddc288759bde46b9b11f68c8738e", + "name": "conda", + "sha256": "41ab260f56f2f36a2b8043e7f66e80d3a0b2ef3966e7d19059f2ab56cdcd2dbe", + "size": 943257, + "subdir": "linux-64", + "timestamp": 1671037153602, + "version": "22.11.1" + }, + "conda-22.11.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-build >=3", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bea430a5eb2ff15f4c06995eb8e60ca9", + "name": "conda", + "sha256": "ca7c4747528692647f6a8957c7b1b1bc4eb4502f4834fafce31d517eca43076a", + "size": 961707, + "subdir": "linux-64", + "timestamp": 1670407601851, + "version": "22.11.1" + }, + "conda-22.11.1-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "constrains": [ + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-env >=2.6", + "conda-build >=3", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "33649a890ba00520b6260ae9578fca94", + "name": "conda", + "sha256": "47b3cb078c98e8239062dcb9fc4666ae4112bbfd460ba448d92a14a897c7d2ef", + "size": 949019, + "subdir": "linux-64", + "timestamp": 1670449410623, + "version": "22.11.1" + }, + "conda-22.11.1-py38h06a4308_3.conda": { + "build": "py38h06a4308_3", + "build_number": 3, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2c449cb3c1657d1356e5731fe860cc91", + "name": "conda", + "sha256": "c8ca6d06e0290e9fa6e31ce8067dc9de53a1d291e7df14a17b8f512d401476d2", + "size": 960869, + "subdir": "linux-64", + "timestamp": 1670452167935, + "version": "22.11.1" + }, + "conda-22.11.1-py38h06a4308_4.conda": { + "build": "py38h06a4308_4", + "build_number": 4, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88c85feee56f6cd38c3728bd609cd6c2", + "name": "conda", + "sha256": "0caf4dfd96ce274ec0f84b33f65515a1de82036c11c80e3924004c2a0885eb62", + "size": 949212, + "subdir": "linux-64", + "timestamp": 1671037238124, + "version": "22.11.1" + }, + "conda-22.11.1-py38h06a4308_5.conda": { + "build": "py38h06a4308_5", + "build_number": 5, + "constrains": [ + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "002bd1626a8c9c7ab07d05062de9dc2c", + "name": "conda", + "sha256": "bbee6e845b9c35931eef934471f30afb0d0d5d099d8042132acb25ac04dea698", + "size": 966751, + "subdir": "linux-64", + "timestamp": 1680642323658, + "version": "22.11.1" + }, + "conda-22.11.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-build >=3", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e7d0cca70710f0c3f6e8b28cee96af01", + "name": "conda", + "sha256": "6c7401adf7ac06dc94883503f2824c690da8efadcac0225aabf739d63cedc361", + "size": 961362, + "subdir": "linux-64", + "timestamp": 1670407478425, + "version": "22.11.1" + }, + "conda-22.11.1-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "constrains": [ + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-env >=2.6", + "conda-build >=3", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8ede970be9c8c03c5d522a19d4699c11", + "name": "conda", + "sha256": "a0d08dec07b934cf9c861e3b77b370217ed53e8f69638eab651483f085c524ad", + "size": 948682, + "subdir": "linux-64", + "timestamp": 1670449368715, + "version": "22.11.1" + }, + "conda-22.11.1-py39h06a4308_3.conda": { + "build": "py39h06a4308_3", + "build_number": 3, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9dbbab0afb8b0d42e9b4e826883d7aaa", + "name": "conda", + "sha256": "46e5904fa5d222e4ca01f243ccb6367ab8e7a019542f0a5b52d475be11ad0813", + "size": 960787, + "subdir": "linux-64", + "timestamp": 1670452126708, + "version": "22.11.1" + }, + "conda-22.11.1-py39h06a4308_4.conda": { + "build": "py39h06a4308_4", + "build_number": 4, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a1f3382cfb05859ece67005f718d4a04", + "name": "conda", + "sha256": "7a680e4568ff98eade1eec6667866747b9d9cd50ece90a88fb666f3cfc4041a1", + "size": 948995, + "subdir": "linux-64", + "timestamp": 1671037280814, + "version": "22.11.1" + }, + "conda-22.11.1-py39h06a4308_5.conda": { + "build": "py39h06a4308_5", + "build_number": 5, + "constrains": [ + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "conda-libmamba-solver >=22.12.0" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d487ee8198506bbcaacfc38ed4d1b1ba", + "name": "conda", + "sha256": "9f1d8027f3dbbcd8d4aab63f57ec4b5267bd3ea5360de4c773c929201eb9a867", + "size": 966356, + "subdir": "linux-64", + "timestamp": 1680642267542, + "version": "22.11.1" + }, + "conda-22.9.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.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.17", + "setuptools >=31.0.1", + "toolz >=0.8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "db399c55a2074835b5fa8648e7c5e305", + "name": "conda", + "sha256": "a3825e3298968290d96297c44f83224ce703146a929f00183e55b4c16ddfc9bb", + "size": 915554, + "subdir": "linux-64", + "timestamp": 1664201248220, + "version": "22.9.0" + }, + "conda-22.9.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.1,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1", + "toolz >=0.8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ec38a249dbfd0a033fa993ced033fa41", + "name": "conda", + "sha256": "3a8164df8921bd9d4376bce698eb302372908317917c1ce33a3595472e558969", + "size": 898989, + "subdir": "linux-64", + "timestamp": 1664201142672, + "version": "22.9.0" + }, + "conda-22.9.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1", + "toolz >=0.8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "13e82366c1f391a21087b0d740cee3cb", + "name": "conda", + "sha256": "dd92ed7948b07eb8f040c163f086426364eddc6e64531f7e7cc7778f9f0761e6", + "size": 905198, + "subdir": "linux-64", + "timestamp": 1664201188124, + "version": "22.9.0" + }, + "conda-22.9.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1", + "toolz >=0.8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d5c3aca97252c0d00db2b1a8595a6908", + "name": "conda", + "sha256": "a13535b3caca044b53ba7478e8caa4fa1c39a7c15c2559634cb03f198e9bffe2", + "size": 905392, + "subdir": "linux-64", + "timestamp": 1664201100594, + "version": "22.9.0" + }, + "conda-23.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-libmamba-solver >=22.12.0", + "conda-env >=2.6", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1" + ], + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d9750df6d38dc51cd1c5394454f7d60c", + "name": "conda", + "sha256": "0a710358aa7f780920e1f5d702b2249cdffdcacfe6370761190866690b6ef832", + "size": 976062, + "subdir": "linux-64", + "timestamp": 1674574758862, + "version": "23.1.0" + }, + "conda-23.1.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0", + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.11,<3.12.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f26937b508538e237eba0c387fbf7cc0", + "name": "conda", + "sha256": "e27b07a211329652b75367bf6e82a4b9dcdd60f8f334807ddde475bf55973528", + "size": 1221940, + "subdir": "linux-64", + "timestamp": 1676839209630, + "version": "23.1.0" + }, + "conda-23.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-libmamba-solver >=22.12.0", + "conda-env >=2.6", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a52dbbb8240819c5846f90f9b1adc2eb", + "name": "conda", + "sha256": "b131f6b93756de9c85454728626a1d0a43c3ba1571b29ef732ce0ef9bf9e5d10", + "size": 959074, + "subdir": "linux-64", + "timestamp": 1674574666076, + "version": "23.1.0" + }, + "conda-23.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-libmamba-solver >=22.12.0", + "conda-env >=2.6", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a39a74c9273c134d07b7f4c1136de6ce", + "name": "conda", + "sha256": "3610156de9e7a62af8a15bb3844722cac46666726362898b96fda9a511647bcd", + "size": 965051, + "subdir": "linux-64", + "timestamp": 1674574711525, + "version": "23.1.0" + }, + "conda-23.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-libmamba-solver >=22.12.0", + "conda-env >=2.6", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cd2d9b5b998f3de3ceab46207130082b", + "name": "conda", + "sha256": "2d5f60e607960654f86072753170c9df69be39a49df60d79c5951195d3bb7e47", + "size": 964984, + "subdir": "linux-64", + "timestamp": 1674574803362, + "version": "23.1.0" + }, + "conda-23.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-build >=3.18.3" + ], + "depends": [ + "boltons >=23.0.0", + "conda-package-handling >=1.3.0", + "packaging", + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f186504a1b9b875baf954e6579584a74", + "name": "conda", + "sha256": "a0f09eb149ab9399da79a5608fe9f9da6ca0af2a2508c5d3ec65b026385b96c6", + "size": 995742, + "subdir": "linux-64", + "timestamp": 1680020056801, + "version": "23.3.0" + }, + "conda-23.3.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-build >=3.18.3" + ], + "depends": [ + "boltons >=23.0.0", + "conda-package-handling >=1.3.0", + "packaging", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.11,<3.12.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "667e2bc64a9d704241e701a38a31ab82", + "name": "conda", + "sha256": "e9b21ca6507e16050a4b3a63523a6ea05a498202c25dab2c39763c5e3c0f7fdc", + "size": 1318190, + "subdir": "linux-64", + "timestamp": 1680020006591, + "version": "23.3.0" + }, + "conda-23.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-build >=3.18.3" + ], + "depends": [ + "boltons >=23.0.0", + "conda-package-handling >=1.3.0", + "packaging", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa2bc58be0062dccbf5799ae116aefcc", + "name": "conda", + "sha256": "a4a29d46ba052a32e6fd07f70f7318b8cd3551a896f5d880c8488f4fb6e5211b", + "size": 985123, + "subdir": "linux-64", + "timestamp": 1680019953677, + "version": "23.3.0" + }, + "conda-23.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-build >=3.18.3" + ], + "depends": [ + "boltons >=23.0.0", + "conda-package-handling >=1.3.0", + "packaging", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e92a80afb05047c2749db3d7a078bfa9", + "name": "conda", + "sha256": "e576a9fade2d3aff1bf804495b1f65b2cda3527fd47a0fa1218dcdc111d6b6d9", + "size": 984991, + "subdir": "linux-64", + "timestamp": 1680020107154, + "version": "23.3.0" + }, + "conda-23.3.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0", + "conda-build >=3.18.3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "boltons >=23.0.0", + "conda-package-handling >=1.3.0", + "jsonpatch >=1.32", + "packaging", + "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" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8c7017b50e71a22d54df7ebd437bfdd0", + "name": "conda", + "sha256": "27dc57e442702d99d3dfa6030bed270106ab8e527dc197c0ac4fed2a3e62c4fd", + "size": 992965, + "subdir": "linux-64", + "timestamp": 1680188212787, + "version": "23.3.1" + }, + "conda-23.3.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0", + "conda-build >=3.18.3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "boltons >=23.0.0", + "conda-package-handling >=1.3.0", + "jsonpatch >=1.32", + "packaging", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.11,<3.12.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fd419c1599ef2ebf9fbe0e5ee0fd37cb", + "name": "conda", + "sha256": "312868397383c0874be3b544af5fcb40ea820e7b2478a999c107d82befc3c8a7", + "size": 1316091, + "subdir": "linux-64", + "timestamp": 1680188266874, + "version": "23.3.1" + }, + "conda-23.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0", + "conda-build >=3.18.3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "boltons >=23.0.0", + "conda-package-handling >=1.3.0", + "jsonpatch >=1.32", + "packaging", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d69e489f5279bba94f699f7e349e8d67", + "name": "conda", + "sha256": "12a4bf4ddb1d4bdd7ff38e3e2934074729b51f8bba92199bafc328f438985249", + "size": 982764, + "subdir": "linux-64", + "timestamp": 1680188158834, + "version": "23.3.1" + }, + "conda-23.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-libmamba-solver >=22.12.0", + "conda-build >=3.18.3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "boltons >=23.0.0", + "conda-package-handling >=1.3.0", + "jsonpatch >=1.32", + "packaging", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1b931f571828cfcf7717a7427f3cdbe8", + "name": "conda", + "sha256": "17bcd93d40e2c9a9a87a69e2b39b1ad5623e9a389f32fc55ce1d94c84103db03", + "size": 982411, + "subdir": "linux-64", + "timestamp": 1680188315862, + "version": "23.3.1" + }, + "conda-4.10.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-build >=3", + "conda-content-trust >=0.1.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "537bee3196cab905ee28fdac8634e44d", + "name": "conda", + "sha256": "e8c99eb54b46e6fd19a8d08db6b4a2d7cef2dab4bbf977ba2793ff5660d9f172", + "size": 3017248, + "subdir": "linux-64", + "timestamp": 1617139894333, + "version": "4.10.0" + }, + "conda-4.10.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "81a9bc60e37adc78d5766ec48b597d66", + "name": "conda", + "sha256": "fe255d19fca904e2cf9b43277b62e320c5f023e6f1cacc415ae26c5148c38b9b", + "size": 3012384, + "subdir": "linux-64", + "timestamp": 1617142368150, + "version": "4.10.0" + }, + "conda-4.10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-env >=2.6", + "conda-build >=3", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "144d012a11bc7c47b15c49fe9cab734c", + "name": "conda", + "sha256": "266f51cddac8881d0350c38cb927554473b60d17f5e67ed0579f854f9c7f02f6", + "size": 3020023, + "subdir": "linux-64", + "timestamp": 1617142371162, + "version": "4.10.0" + }, + "conda-4.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "e1465d09be4dfef66dac29fb3f8099f4", + "name": "conda", + "sha256": "f270e6324dd521f282b5c02d8c42b9375f4fad15c3441f3eff44ac0cccade4eb", + "size": 3020908, + "subdir": "linux-64", + "timestamp": 1617142264793, + "version": "4.10.0" + }, + "conda-4.10.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "704965dd28dafdda6ed3111652dc9e18", + "name": "conda", + "sha256": "a565eb4df83b9e4948d69d41b2df4e45507d700a2e26a36d6d9d64ec24a776d5", + "size": 3010123, + "subdir": "linux-64", + "timestamp": 1618432968113, + "version": "4.10.1" + }, + "conda-4.10.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-build >=3" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "e0acc5e947ba1c82ab8146a578fa854c", + "name": "conda", + "sha256": "15d8270122a51dce4dd8419440c40ffc2dd5040e9d73b38601631aad603b84b2", + "size": 3001723, + "subdir": "linux-64", + "timestamp": 1618432966117, + "version": "4.10.1" + }, + "conda-4.10.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-env >=2.6", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "fe0b4de768b61f4f58f506b6c27baa30", + "name": "conda", + "sha256": "07b2ade57711125adad5b22b73ce08fc42eba92b55865710a3a293e81746e283", + "size": 3020787, + "subdir": "linux-64", + "timestamp": 1618432967623, + "version": "4.10.1" + }, + "conda-4.10.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-content-trust >=0.1.1", + "cytoolz >=0.8.1", + "conda-build >=3", + "conda-env >=2.6" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "104c928b92feeb30e3058b0ccfad1c06", + "name": "conda", + "sha256": "50d5858a192fe35f092e09a088f6d9e003260a8792d7a2a59f0bb17ef815d9d7", + "size": 3018874, + "subdir": "linux-64", + "timestamp": 1618429842712, + "version": "4.10.1" + }, + "conda-4.10.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.10,<3.11.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "bdf60e3be508b1f9bc4267e4b9e0b476", + "name": "conda", + "sha256": "aed7a925743565ec3a4da4129c52bc5d30730d879b644e49e1ddd337e2d890ae", + "size": 3007586, + "subdir": "linux-64", + "timestamp": 1641552181014, + "version": "4.10.3" + }, + "conda-4.10.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "89a93a6b6a7654eb7edbafc5935feb7f", + "name": "conda", + "sha256": "56ca71b878add93a73fd5e040cf4aaedf9c60123e8521a0480d50705f0783149", + "size": 3005931, + "subdir": "linux-64", + "timestamp": 1625030514499, + "version": "4.10.3" + }, + "conda-4.10.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "cytoolz >=0.8.1", + "conda-build >=3", + "conda-env >=2.6", + "conda-content-trust >=0.1.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "63d4317c77b37566294cd905a6af2c85", + "name": "conda", + "sha256": "1b1116a58426b13d63ceb31efb9f1a5f08758bfcc4aa8666e7b0019862093a98", + "size": 2999789, + "subdir": "linux-64", + "timestamp": 1625024046170, + "version": "4.10.3" + }, + "conda-4.10.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "f536999382b83b3eadf48f79aa13eabb", + "name": "conda", + "sha256": "c68208b223a67a1de5551a16c3a17fbbf482f5e947387df69e4dd9ec8f273771", + "size": 3019180, + "subdir": "linux-64", + "timestamp": 1625030488252, + "version": "4.10.3" + }, + "conda-4.10.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "cytoolz >=0.8.1", + "conda-content-trust >=0.1.1", + "conda-build >=3" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "69b24cdcda60f9986131d87296ffb9ba", + "name": "conda", + "sha256": "65896906d90bc269819a942f56621474e0d67c6f2cf9dc3f1b4806ad0b47e238", + "size": 3006567, + "subdir": "linux-64", + "timestamp": 1625030433316, + "version": "4.10.3" + }, + "conda-4.11.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-build >=3" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "md5": "d20928252959439515f38dcaf7a0d1d8", + "name": "conda", + "sha256": "e8f7a83743633243eb900cbd1008fdbab1a2596a85b3ee68014d81161e59708d", + "size": 15135701, + "subdir": "linux-64", + "timestamp": 1638994131574, + "version": "4.11.0" + }, + "conda-4.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-content-trust >=0.1.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "md5": "1e1e7c2861201e33275df3d286762079", + "name": "conda", + "sha256": "8f7c46f827a04e9fc42ff6607622fc48daca68b754e6f22f68119b8954346104", + "size": 15126854, + "subdir": "linux-64", + "timestamp": 1638994117932, + "version": "4.11.0" + }, + "conda-4.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "cytoolz >=0.8.1", + "conda-build >=3", + "conda-content-trust >=0.1.1", + "conda-env >=2.6" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "md5": "1dc1591ca86366076b1d04de97aa8cdb", + "name": "conda", + "sha256": "0a6266811dd9ee3f9f9a86362a9420b90c4e7afcff5e99bf6b5505d8bc213263", + "size": 15130851, + "subdir": "linux-64", + "timestamp": 1638976012244, + "version": "4.11.0" + }, + "conda-4.12.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.10,<3.11.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "md5": "d75986c15d6a155f89c37bf8f33ba1e5", + "name": "conda", + "sha256": "c8e87b4d0699918306b7b30297af67eb5ec25cb325d193d52a7352c86c35443d", + "size": 15171219, + "subdir": "linux-64", + "timestamp": 1647367215594, + "version": "4.12.0" + }, + "conda-4.12.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "cytoolz >=0.8.1", + "conda-build >=3" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "md5": "2d45e9226de1c7de6c834c5d5c56a476", + "name": "conda", + "sha256": "37cb308f1268667fe759c617fe11d4bea0bec28bca3bab2f24532ced1b89b75d", + "size": 15170420, + "subdir": "linux-64", + "timestamp": 1647349076328, + "version": "4.12.0" + }, + "conda-4.12.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1", + "conda-env >=2.6" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "md5": "6f226d0faeae1aed7878259b1eaa9f5f", + "name": "conda", + "sha256": "4c7a6d6c1b681997b81093e8723ce9db0a33e7d0aeed6b7077d3d7242b68cdfd", + "size": 15170897, + "subdir": "linux-64", + "timestamp": 1647367203770, + "version": "4.12.0" + }, + "conda-4.12.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "cytoolz >=0.8.1", + "conda-build >=3", + "conda-env >=2.6", + "conda-content-trust >=0.1.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "md5": "b1e6bc0245c1faa572ee539f5ac6695e", + "name": "conda", + "sha256": "1f8676d2efa4a185aefb997a44bb0ccaa029d3cbe130d2cf675f3ed41a2d61a9", + "size": 15162490, + "subdir": "linux-64", + "timestamp": 1647349451314, + "version": "4.12.0" + }, + "conda-4.13.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.10,<3.11.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "19d4136a06eae54da3078649a58c5267", + "name": "conda", + "sha256": "fb6c437887707fee0295505620f1a75482d434fde2f82f84a19748d5435cef72", + "size": 926709, + "subdir": "linux-64", + "timestamp": 1653598337616, + "version": "4.13.0" + }, + "conda-4.13.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "339153a50844878c44f73674768c684f", + "name": "conda", + "sha256": "4a0e5aaaceb38c431e8f89bc382ff1c73214631c764709dd609b3b4e4449596f", + "size": 911386, + "subdir": "linux-64", + "timestamp": 1653598422506, + "version": "4.13.0" + }, + "conda-4.13.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5fbdc65a264ff7d636fb7670c7a0b313", + "name": "conda", + "sha256": "016c5190376c8f27d0dd874665952677b171b0c84abc9b595909d68034dde3cd", + "size": 917002, + "subdir": "linux-64", + "timestamp": 1653598464610, + "version": "4.13.0" + }, + "conda-4.13.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-env >=2.6", + "conda-content-trust >=0.1.1", + "conda-build >=3", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cf6cbdf2089c72e5c402da3bf7d6a549", + "name": "conda", + "sha256": "74ae2d47fd21a4c62707a7a6eb118b56a38f00f0444b482de462c668d8e433e4", + "size": 916702, + "subdir": "linux-64", + "timestamp": 1653598379612, + "version": "4.13.0" + }, + "conda-4.14.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-content-trust >=0.1.1", + "conda-env >=2.6" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "cytoolz >=0.8.1", + "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.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "947dc1a55ae2e93bc0b0669523658455", + "name": "conda", + "sha256": "6f70176b3ea493e27d6bea9c6cd09c44be622a096a06369091c6bce4dc593efc", + "size": 947325, + "subdir": "linux-64", + "timestamp": 1661203888116, + "version": "4.14.0" + }, + "conda-4.14.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-content-trust >=0.1.1", + "conda-env >=2.6" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "cytoolz >=0.8.1", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.1,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2b38e0826c8a3cab44fbcccd27941d0c", + "name": "conda", + "sha256": "5c5aca1377456736d666c369c1cf0ca74a5a69926badc073e9eaaf894f1d2188", + "size": 930794, + "subdir": "linux-64", + "timestamp": 1661203726602, + "version": "4.14.0" + }, + "conda-4.14.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-content-trust >=0.1.1", + "conda-env >=2.6" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "cytoolz >=0.8.1", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.1,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "91de5803ed2a1eda20157a3558a6b6b5", + "name": "conda", + "sha256": "ffcc4a31472f84c6a14317e6c1fd1705ec00f7f519335ca9f09680da570be24e", + "size": 937631, + "subdir": "linux-64", + "timestamp": 1661203773929, + "version": "4.14.0" + }, + "conda-4.14.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-content-trust >=0.1.1", + "conda-env >=2.6" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "cytoolz >=0.8.1", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.1,<3", + "ruamel_yaml >=0.11.14,<0.17", + "setuptools >=31.0.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "de254704dbb49acd755d13cbf8b91fd9", + "name": "conda", + "sha256": "9d94bae82b38848238d2de0f0a241c9611637af4422867822e2c822309237a30", + "size": 937105, + "subdir": "linux-64", + "timestamp": 1661203822352, + "version": "4.14.0" + }, + "conda-4.3.27-py27hff99c7a_0.conda": { + "build": "py27hff99c7a_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "enum34", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "0bd97b517e4c67d178e6b2806f253c69", + "name": "conda", + "sha256": "a76be7a59417b0879b190415ee271ee20f581b86cdc2ac6776adb743b139260b", + "size": 506928, + "subdir": "linux-64", + "timestamp": 1506080072319, + "version": "4.3.27" + }, + "conda-4.3.27-py35h1706b01_0.conda": { + "build": "py35h1706b01_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "2562419786d306f6c89c3934d855e6e8", + "name": "conda", + "sha256": "35bdbf7d7ba1381988564ef344401b59a15c3031501a94c0feccb1ca590e632a", + "size": 513757, + "subdir": "linux-64", + "timestamp": 1506080093174, + "version": "4.3.27" + }, + "conda-4.3.27-py36h2866c0b_0.conda": { + "build": "py36h2866c0b_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "23597cf40737903ed1ab77e48285cecf", + "name": "conda", + "sha256": "65125a96187fc114b9f203c6f43cfc0df5fc3d76518c207472988daeb157cdd3", + "size": 501478, + "subdir": "linux-64", + "timestamp": 1506080114791, + "version": "4.3.27" + }, + "conda-4.3.29-py27h13e2077_0.conda": { + "build": "py27h13e2077_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "enum34", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "8ffd5ee6cbac24f68e1d84f828ed0b10", + "name": "conda", + "sha256": "b26f5758bc27d76b11fea2ce5504478d53c744e2dd1c63c2a382549365ec5849", + "size": 507674, + "subdir": "linux-64", + "timestamp": 1507581131695, + "version": "4.3.29" + }, + "conda-4.3.29-py34h14158f2_0.conda": { + "build": "py34h14158f2_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.4,<3.5.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "fdefbd18f2a340a3b3add3305f31eb36", + "name": "conda", + "sha256": "6779d811d150000d32e3e5b08add6786a596ea6cec98d0b30e9d448602302b11", + "size": 511280, + "subdir": "linux-64", + "timestamp": 1507581148853, + "version": "4.3.29" + }, + "conda-4.3.29-py35h8b93296_0.conda": { + "build": "py35h8b93296_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "c5c3c6c86c5583c366d07ee036013b51", + "name": "conda", + "sha256": "511856c2a8a6751577e9effed87e11fd98b9ea65101131402c68d1046252b15b", + "size": 514704, + "subdir": "linux-64", + "timestamp": 1507581159664, + "version": "4.3.29" + }, + "conda-4.3.29-py36ha26b0c0_0.conda": { + "build": "py36ha26b0c0_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "5425ba092d2be23500ea66b7a80d46b3", + "name": "conda", + "sha256": "0f383cf8b48344ac3ae7c507e4f28b189d5880b72e3476a8d8c2dee37ab5142a", + "size": 508630, + "subdir": "linux-64", + "timestamp": 1507581177439, + "version": "4.3.29" + }, + "conda-4.3.30-py27h6ae6dc7_0.conda": { + "build": "py27h6ae6dc7_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "enum34", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "02851f177636398bc6452b468e606fce", + "name": "conda", + "sha256": "cfd29b78c87dd5163329c7ef672083158422ba441af3e15c7f74b57f59dece3f", + "size": 501636, + "subdir": "linux-64", + "timestamp": 1508271588500, + "version": "4.3.30" + }, + "conda-4.3.30-py34h69bfab2_0.conda": { + "build": "py34h69bfab2_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.4,<3.5.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "0a78ab74680a48d84070f6121ddf0fce", + "name": "conda", + "sha256": "1024e8600b6dea92a89faa5afe0cc15396985c1474b90e02816febb241954fe8", + "size": 511464, + "subdir": "linux-64", + "timestamp": 1508271577660, + "version": "4.3.30" + }, + "conda-4.3.30-py35hf9359ed_0.conda": { + "build": "py35hf9359ed_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "a65f8dd94e63cafaf9b38cf196b1e6b2", + "name": "conda", + "sha256": "b037e6b30471df42b9b57a168264a2cc89d33b5d0cc878629cbbb610ddc265f8", + "size": 514396, + "subdir": "linux-64", + "timestamp": 1508271605880, + "version": "4.3.30" + }, + "conda-4.3.30-py36h5d9f9f4_0.conda": { + "build": "py36h5d9f9f4_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "5840b8e36253552a9cf4c6b720d93046", + "name": "conda", + "sha256": "376337c93fed573854a33ddf2c43b116f206bfb522eff6c3e2d516aeb8832a75", + "size": 502065, + "subdir": "linux-64", + "timestamp": 1508271608124, + "version": "4.3.30" + }, + "conda-4.3.31-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "enum34", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "21d0ae784e422a56b3093a945b454572", + "name": "conda", + "sha256": "df68911b3bff926d6527f0fb21abfc6f0128c02b20e272b614c2b91b0d3a4686", + "size": 508755, + "subdir": "linux-64", + "timestamp": 1513473428958, + "version": "4.3.31" + }, + "conda-4.3.31-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "1cc3da858210e3363338bb30a78e8de8", + "name": "conda", + "sha256": "d31e981c9983369a21123ab7e238cf4de4fd06b02902c43339f20b0ba5926aaf", + "size": 515657, + "subdir": "linux-64", + "timestamp": 1513473460302, + "version": "4.3.31" + }, + "conda-4.3.31-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "9552884aad9265dd05c50c5a6d43b90d", + "name": "conda", + "sha256": "56fb71c074e67663a0a8c9962b071d39ae533b932fbca52a0327eee9e7c592aa", + "size": 509528, + "subdir": "linux-64", + "timestamp": 1513473472598, + "version": "4.3.31" + }, + "conda-4.3.32-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "enum34", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "b6a77fa9aad2f4adac1fe655f0bba298", + "name": "conda", + "sha256": "cd26fc3c276ba0a3a7b23532cbdd5b658ea7efe97c005a309c651a88ff60b7d2", + "size": 509497, + "subdir": "linux-64", + "timestamp": 1515643374244, + "version": "4.3.32" + }, + "conda-4.3.32-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "e50b911ca0a488375e82842872077553", + "name": "conda", + "sha256": "9b149c5fef3cf12dabb9abf3021e26c381c8b30286d5484e2771c556e44b3ccc", + "size": 510189, + "subdir": "linux-64", + "timestamp": 1515643395340, + "version": "4.3.32" + }, + "conda-4.3.32-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "31f9399901dabee9bb8d05a492276a17", + "name": "conda", + "sha256": "4e422ecdecde5d7fdb46c4840f0a932dba9f02427e3042d8332c1764e5a1e482", + "size": 504087, + "subdir": "linux-64", + "timestamp": 1515643363956, + "version": "4.3.32" + }, + "conda-4.3.33-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "enum34", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "31c44aef72f19a04116a0a9ad363608c", + "name": "conda", + "sha256": "b72637a7e76af67e033aa396a8da10e934a72af78512fdebbd1d308c0d9fb291", + "size": 504020, + "subdir": "linux-64", + "timestamp": 1516815972650, + "version": "4.3.33" + }, + "conda-4.3.33-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "5695239caa132d50db762aa2e9e04516", + "name": "conda", + "sha256": "7968d6afb8b4b2cd8caf9a02aa15172333e6102c7ff903546b7073c577393db3", + "size": 516679, + "subdir": "linux-64", + "timestamp": 1516815991836, + "version": "4.3.33" + }, + "conda-4.3.33-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "c0703b8ebdd560cdaa9004fb6664d6c6", + "name": "conda", + "sha256": "45e536fa706722af0783403f3a9274179a9b1e671cdfb869bf44167ef1e06461", + "size": 510351, + "subdir": "linux-64", + "timestamp": 1516815990887, + "version": "4.3.33" + }, + "conda-4.3.34-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "enum34", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "f6b3fff2a25bae0855c305e8c952f3cc", + "name": "conda", + "sha256": "9fcd2214f211a81b40dda21a106ca32f75de5b9bc5d3071e2a59c26cb5ebf1fb", + "size": 509802, + "subdir": "linux-64", + "timestamp": 1518212800884, + "version": "4.3.34" + }, + "conda-4.3.34-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "5deb2168eb3f2ba1356db9801940bbe1", + "name": "conda", + "sha256": "e7731dce012321d2f7b71c4cc72b96da3eddf89a9d55edf0b2e94ff970e68a2d", + "size": 510647, + "subdir": "linux-64", + "timestamp": 1518212819737, + "version": "4.3.34" + }, + "conda-4.3.34-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.1", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "b6e7c3a25ac97a196fb2334e1fd431bb", + "name": "conda", + "sha256": "5bf3e8f085cd40af8773d2c3889ba39fdef5f77570bca09180a3d8d0fa45820a", + "size": 504627, + "subdir": "linux-64", + "timestamp": 1518212819998, + "version": "4.3.34" + }, + "conda-4.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "7cee2a1c397bfb5f22e65be6b293e235", + "name": "conda", + "sha256": "6efa8c898704a7ca80efab9fb23de5e736033532c5ba6d95858ebfe2bdaf144d", + "size": 605429, + "subdir": "linux-64", + "timestamp": 1513805553579, + "version": "4.4.0" + }, + "conda-4.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "1807561e8dd6268e2afbb59cd3484b9a", + "name": "conda", + "sha256": "e93aa7d2aefca2224252a1c5e63304d841ae943e0c4f293f9e7694ac164c3087", + "size": 604965, + "subdir": "linux-64", + "timestamp": 1513805545251, + "version": "4.4.0" + }, + "conda-4.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "f430930684a5f8377b8b865e27722ab8", + "name": "conda", + "sha256": "f8cd6a568de685f723bad37bfd907c27c59f117ce9b5a56b9e456c6f9dc8b5c4", + "size": 598203, + "subdir": "linux-64", + "timestamp": 1513805547373, + "version": "4.4.0" + }, + "conda-4.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "6454f843d298d584b48411f9d957cb9b", + "name": "conda", + "sha256": "b1d8ad7cd194b6d06eca3181bd9ff1b06349fe0b8e9a8c381918af9b333ca0c7", + "size": 598169, + "subdir": "linux-64", + "timestamp": 1513894888818, + "version": "4.4.1" + }, + "conda-4.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "f3345038d545c1fbeae60e0285add435", + "name": "conda", + "sha256": "16b855c577987d8ef5b6ddd570bf540bf91ef27092aa1eebe168d7f2feba8289", + "size": 612772, + "subdir": "linux-64", + "timestamp": 1513894906248, + "version": "4.4.1" + }, + "conda-4.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "3f9c7eea9b86af234f5198540f759519", + "name": "conda", + "sha256": "fee9c5b0107d39011dd700ac7220f45ee128bda4c09d8499647e253032c56971", + "size": 598126, + "subdir": "linux-64", + "timestamp": 1513894873142, + "version": "4.4.1" + }, + "conda-4.4.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "f0b74ac27cdc179a7b9f1a77c8272423", + "name": "conda", + "sha256": "2dcea597f71953d063bfc9e41c42987a94a470e2140c012d5a7423bd01354d5f", + "size": 893224, + "subdir": "linux-64", + "timestamp": 1518214159606, + "version": "4.4.10" + }, + "conda-4.4.10-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "3028d967b79925d3f911db91437c084f", + "name": "conda", + "sha256": "1f2a879c952ff8f38e065a4d3dd086937c28d48897a32e430f709ae2e227359a", + "size": 892536, + "subdir": "linux-64", + "timestamp": 1518214199239, + "version": "4.4.10" + }, + "conda-4.4.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "bca1e94f3a98a945ffb911dad75cde88", + "name": "conda", + "sha256": "bad127847d5375042e1dfc401cf1f00815c3ed96e0432b6494f969ea98ab9e2d", + "size": 893391, + "subdir": "linux-64", + "timestamp": 1518214199031, + "version": "4.4.10" + }, + "conda-4.4.11-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "0c07cff3008a1c647731d53373f36daa", + "name": "conda", + "sha256": "dd1fd6d530134adeb7c0d6ca9fb05561e6cf220e7f691fb0712d381b8d074bd0", + "size": 886542, + "subdir": "linux-64", + "timestamp": 1519392559843, + "version": "4.4.11" + }, + "conda-4.4.11-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "1b36c5f6002fe10d8951ec50477890bf", + "name": "conda", + "sha256": "7bf84609bef0d8ee30cdeb56d8c7acda182aed8d13673956c5dd2fab8ccd9636", + "size": 893013, + "subdir": "linux-64", + "timestamp": 1519392648815, + "version": "4.4.11" + }, + "conda-4.4.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "d229984f013021b5fafa0aa1e3ddc01c", + "name": "conda", + "sha256": "2aaf57d931e33ee0291e1a325d846343d809dee7a3aae4ba4ca599ccd91a8aa5", + "size": 886550, + "subdir": "linux-64", + "timestamp": 1519392566975, + "version": "4.4.11" + }, + "conda-4.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "8755e5b171e29ec4b87caf7b9ab0729f", + "name": "conda", + "sha256": "9a59bd2a3fa10f220ed185423712a6a481c87b6f1cd62952d41a834fc39a2598", + "size": 598465, + "subdir": "linux-64", + "timestamp": 1513927293965, + "version": "4.4.2" + }, + "conda-4.4.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "4a4ee7ee7d6b3ebd018694932b249814", + "name": "conda", + "sha256": "c8e55aed8a50d807fc498904056c3ba8848e967dd28f393d1d8526ede68804ea", + "size": 605467, + "subdir": "linux-64", + "timestamp": 1513927323404, + "version": "4.4.2" + }, + "conda-4.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "ec3467679b1812cdf891d3ed4cda432d", + "name": "conda", + "sha256": "fcdad7c2768d23b4c5984978bf53cea608a59c0f0e8c3a78396fa51001ecba80", + "size": 605661, + "subdir": "linux-64", + "timestamp": 1513927322049, + "version": "4.4.2" + }, + "conda-4.4.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "ae63a4d723997ff8b3b54291b8a84e89", + "name": "conda", + "sha256": "eef87b3efaffb4dd7050cc31460b0e0b689d7ebe47a184832b5d7abcad8ac690", + "size": 599450, + "subdir": "linux-64", + "timestamp": 1513981237801, + "version": "4.4.3" + }, + "conda-4.4.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "6571aa01341cf7f41e8db02c577bc8ef", + "name": "conda", + "sha256": "c95f61a6e7e339bf9c86480188db75fd5d7cd4c80e6c8147df4790daca91be10", + "size": 606188, + "subdir": "linux-64", + "timestamp": 1513981260124, + "version": "4.4.3" + }, + "conda-4.4.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "225b26171430e450b50a7db8affaaeb0", + "name": "conda", + "sha256": "17b95818e009790dd87788ab2fe95438fba984b117f444305b418071e4ec74fd", + "size": 606536, + "subdir": "linux-64", + "timestamp": 1513981267816, + "version": "4.4.3" + }, + "conda-4.4.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "69661982cb8eb9b9a422a8131de9236d", + "name": "conda", + "sha256": "e96236005ec7b477ec4fbac7a25e09861e8efdd93c42e76d5d37fc8410276290", + "size": 607708, + "subdir": "linux-64", + "timestamp": 1514155527337, + "version": "4.4.4" + }, + "conda-4.4.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "c8bfe9e82d8c97903a6465877cf7e65e", + "name": "conda", + "sha256": "23fffa3f2488d97792912131090fffb1ba23a35b5ac34189ab9eeb6c2dfb862e", + "size": 615061, + "subdir": "linux-64", + "timestamp": 1514155548163, + "version": "4.4.4" + }, + "conda-4.4.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "0974c0a21eebb62dd97d4f423416626a", + "name": "conda", + "sha256": "bec207f6483ea37a75792839983d3dbbb3497ca9b52a4c3aa6283b5ddd6d3a35", + "size": 600241, + "subdir": "linux-64", + "timestamp": 1514155543474, + "version": "4.4.4" + }, + "conda-4.4.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "ed0b47a8e2b5b02da98a0f05ecbf52ab", + "name": "conda", + "sha256": "9e6a50835b53c5c76992d9de34fcc6e496bd94a7f59630394c20b7a6ab55f748", + "size": 887265, + "subdir": "linux-64", + "timestamp": 1514749553694, + "version": "4.4.6" + }, + "conda-4.4.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "8e4a21f1dbffa39d6eca9ec5bd83e35d", + "name": "conda", + "sha256": "fdd44d83559667cc56e0fa450e400db1973f0cc155c58e2612ef9cfaf67dcf6f", + "size": 886801, + "subdir": "linux-64", + "timestamp": 1514749567875, + "version": "4.4.6" + }, + "conda-4.4.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "e6e31d9858a1b8f3484b0eeac4ff1063", + "name": "conda", + "sha256": "1dab83369ed3e6a2e95659cbc5deb3b8ae1eed9a1d48858d23f245a6fe1f9d2e", + "size": 880181, + "subdir": "linux-64", + "timestamp": 1514749576329, + "version": "4.4.6" + }, + "conda-4.4.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "3be57549f81dcbb4433fe356a3736519", + "name": "conda", + "sha256": "3b331c7b2fbc7daa77322d388b236eba8ac10f084409c385449bbdd1cac8b7d6", + "size": 887923, + "subdir": "linux-64", + "timestamp": 1515435700131, + "version": "4.4.7" + }, + "conda-4.4.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "a12869b087c0388e339b2097c4a9e00f", + "name": "conda", + "sha256": "3cc84d6bec737cf1a83c16bdcd8472de2fe31bfb3a241909d83e95ec0c45b2ae", + "size": 895295, + "subdir": "linux-64", + "timestamp": 1515435726029, + "version": "4.4.7" + }, + "conda-4.4.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "d0c7b49ca04f356c10587379a4c6eec2", + "name": "conda", + "sha256": "0bddf6f5595dc00d9fe16da7044aa7e1721564b3a11ab54088440b0018712806", + "size": 880862, + "subdir": "linux-64", + "timestamp": 1515435737571, + "version": "4.4.7" + }, + "conda-4.4.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "7be16cd3bf3c3cb3c09d15d8da7e6d6d", + "name": "conda", + "sha256": "6643873dc54441ebd3aa20fb133035c7eeaf2d0addf07d07d4cb70e84e1be2e1", + "size": 884494, + "subdir": "linux-64", + "timestamp": 1516977114204, + "version": "4.4.8" + }, + "conda-4.4.8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "c5c67e6ec5dc15cb7935ef1fd3cfc27e", + "name": "conda", + "sha256": "d37c77149c8d6b6a6fa37bd8c928a81de6ae7e609b6f862342aaaa14611ee494", + "size": 891024, + "subdir": "linux-64", + "timestamp": 1516977128282, + "version": "4.4.8" + }, + "conda-4.4.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "7eb3b5871108d7c501490c8b620877d6", + "name": "conda", + "sha256": "04bd420f0fbfdcbd0c2145e175c8b573ccda6a62761efee984d58eda8dd97dce", + "size": 884373, + "subdir": "linux-64", + "timestamp": 1516977128407, + "version": "4.4.8" + }, + "conda-4.4.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "55534e848be938ded8d27b1676330b29", + "name": "conda", + "sha256": "e86ae03d68a97c50cbc08799ec553c43b4a9cc3b70747ec48baa5e248953ae04", + "size": 885369, + "subdir": "linux-64", + "timestamp": 1517949728142, + "version": "4.4.9" + }, + "conda-4.4.9-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "3d2ddc539051fd275bd82f7f87284371", + "name": "conda", + "sha256": "069533ec2e5236ce32285403f68be8411f3098bcea1bbd9bb0b32e32335c47bd", + "size": 899673, + "subdir": "linux-64", + "timestamp": 1517949752376, + "version": "4.4.9" + }, + "conda-4.4.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "6f3a4f73f9b006dec536c8cf05028a2a", + "name": "conda", + "sha256": "4c913324762a46460b103def284e1b436be762d231a4a25b61f61c17ce033765", + "size": 885720, + "subdir": "linux-64", + "timestamp": 1517949761552, + "version": "4.4.9" + }, + "conda-4.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "984d9f0f87086bf89112dbc8795343cd", + "name": "conda", + "sha256": "7af567cf502c078fb76c6e1dd9b04b1a22aab67d2f635331847dec61f4a79aac", + "size": 988915, + "subdir": "linux-64", + "timestamp": 1521550345778, + "version": "4.5.0" + }, + "conda-4.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "2c1a7f5a0de6d3b02ee94c01cce2d772", + "name": "conda", + "sha256": "094bb35c39af1363c8b4851125b1cb4e1a899d2e85c6bfb3a8e01a1a8a78e75b", + "size": 995307, + "subdir": "linux-64", + "timestamp": 1521550360889, + "version": "4.5.0" + }, + "conda-4.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "3125751229af7f6b6509d6a2a5d2f49a", + "name": "conda", + "sha256": "645ae205117ba2caa61a59558f7d9f71aac01fda732e31535e3adaba44c5aa0d", + "size": 996074, + "subdir": "linux-64", + "timestamp": 1521550366989, + "version": "4.5.0" + }, + "conda-4.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "304af09ebdebb6e47add28176c4274dd", + "name": "conda", + "sha256": "32198b2fccf23b4dea08b061545869c49272816d87b5db097eec1352c44ddbb1", + "size": 983658, + "subdir": "linux-64", + "timestamp": 1523601378712, + "version": "4.5.1" + }, + "conda-4.5.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "1dfb972330a46dada84355aa338c20d4", + "name": "conda", + "sha256": "6f7d45ed36c25e280a35ce81aaf875a7674497154f082236fbbaa3a539bb914c", + "size": 997592, + "subdir": "linux-64", + "timestamp": 1523601393192, + "version": "4.5.1" + }, + "conda-4.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "293cd7bc6f21194cd9b2a7e85e7b211e", + "name": "conda", + "sha256": "8113dc442f615ab242499e9006427ae02d503261f5bb83e529054480e105b401", + "size": 990557, + "subdir": "linux-64", + "timestamp": 1523601429609, + "version": "4.5.1" + }, + "conda-4.5.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "b2de30e8beeacbbde99933f5131e0593", + "name": "conda", + "sha256": "61dcd173999947cb6c9ad58fc108812628b4cc79fe7d78d2a8405229d6d02403", + "size": 988066, + "subdir": "linux-64", + "timestamp": 1534186238582, + "version": "4.5.10" + }, + "conda-4.5.10-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "ae27abce6e900a71beaf18c8103adf10", + "name": "conda", + "sha256": "e135e957c9d20f9536345f153b5f13faa89974a619dcf14f99ea20e8cacc6650", + "size": 1001597, + "subdir": "linux-64", + "timestamp": 1534186251677, + "version": "4.5.10" + }, + "conda-4.5.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "480838280504e833e93df6bb43245016", + "name": "conda", + "sha256": "ff5e4f639652b76bedb36ece60b566f01c9f16690a6eaf9eb47f1e56279c5ef1", + "size": 995077, + "subdir": "linux-64", + "timestamp": 1534184231222, + "version": "4.5.10" + }, + "conda-4.5.10-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "3c58115b4eed80f1bd3f7c1cb9e57ac2", + "name": "conda", + "sha256": "669d4b750fc53d44710f91dfdd77bcea3fff53219a45a2fd6d5c1e855db95c6e", + "size": 995158, + "subdir": "linux-64", + "timestamp": 1534184299444, + "version": "4.5.10" + }, + "conda-4.5.11-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "c3e8dcbf13f5d9253398a94f1f6bb32e", + "name": "conda", + "sha256": "100308ae3bbbdf47514cc01a9b5bb35c556e3965986735b3b1a8470872558e67", + "size": 988440, + "subdir": "linux-64", + "timestamp": 1534866800219, + "version": "4.5.11" + }, + "conda-4.5.11-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "51e20a0f752f93d2fd70f27814cee4e6", + "name": "conda", + "sha256": "6ab4f8c8357b6ea91102a7c12aaaa50a2440b71e8a4addf085767a7642105ebc", + "size": 994838, + "subdir": "linux-64", + "timestamp": 1534866561441, + "version": "4.5.11" + }, + "conda-4.5.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "23671db5d4b31a75fbd1654899ae8da6", + "name": "conda", + "sha256": "a065a268150a7082bd96f9efca4582fe5176a3aa6c52c4ec75da5284c930e635", + "size": 995026, + "subdir": "linux-64", + "timestamp": 1534866762236, + "version": "4.5.11" + }, + "conda-4.5.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "daf3d48fe91932ceb2b526b9a22fcd90", + "name": "conda", + "sha256": "0f880d8b636b1f4ddb58470ab541d205869c03783a7bb25e08ca0884a756e4ed", + "size": 988688, + "subdir": "linux-64", + "timestamp": 1534866843846, + "version": "4.5.11" + }, + "conda-4.5.12-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "55210adae1fdb819b2b0e5cb0f0b1740", + "name": "conda", + "sha256": "ff5243c7ba5ecd6917c1d57368bfbbcbaa9f722201f4e660de42bbf69215062f", + "size": 998699, + "subdir": "linux-64", + "timestamp": 1544488020290, + "version": "4.5.12" + }, + "conda-4.5.12-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "1fb70621384347f349ca149eb4ddc983", + "name": "conda", + "sha256": "03e815726a1d1d5f2aabe0075bf47f74a9643112b70230c7b0fb81e05b69ff33", + "size": 991639, + "subdir": "linux-64", + "timestamp": 1544488049463, + "version": "4.5.12" + }, + "conda-4.5.12-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "8e5f8e7e20f0043cc0c0bbe274ee8a7e", + "name": "conda", + "sha256": "793c55947407ffbc8b050f2bb613eba42c73f0be342f0be2f334b304bf341247", + "size": 992452, + "subdir": "linux-64", + "timestamp": 1544488015340, + "version": "4.5.12" + }, + "conda-4.5.13-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "f27093e15e6fc0814333e36823453d82", + "name": "conda", + "sha256": "e908835ab26da0b3707162bc141935b1fb5f3662bd46c2bf6d163fc3e501f4e9", + "size": 998741, + "subdir": "linux-64", + "timestamp": 1548809668528, + "version": "4.5.13" + }, + "conda-4.5.13-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "e4b63e41638db8d357be363d48cfd4b1", + "name": "conda", + "sha256": "cd52289a0cad59135dcfe0ac7583bcc9642117729a047276b8585ff73a67d3fb", + "size": 991999, + "subdir": "linux-64", + "timestamp": 1548809678647, + "version": "4.5.13" + }, + "conda-4.5.13-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "717ec64eb9a5aa1e7e7c56ba0a78df31", + "name": "conda", + "sha256": "78ae281f41dc7befa9f1e422381090e8ce211b6aadfac12613f058c84a1a8989", + "size": 992827, + "subdir": "linux-64", + "timestamp": 1548809744380, + "version": "4.5.13" + }, + "conda-4.5.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env", + "enum34", + "futures", + "pycosat", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml" + ], + "license": "BSD 3-Clause", + "md5": "f794f8f04ee0eea3945932125ca0d46f", + "name": "conda", + "sha256": "157f947c17add60cdb0ac4b48629d1376f1ab7ed79f433fb40d860b64da59ca5", + "size": 983287, + "subdir": "linux-64", + "timestamp": 1524848322387, + "version": "4.5.2" + }, + "conda-4.5.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env", + "pycosat", + "pyopenssl", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml" + ], + "license": "BSD 3-Clause", + "md5": "43549d5ba26b9bd765d3b49c8aab3cd6", + "name": "conda", + "sha256": "4eab0cdd20cb2144bbc127a42a5ac87a5a809b4eb033f960f787d9f666a366b8", + "size": 997304, + "subdir": "linux-64", + "timestamp": 1524848342576, + "version": "4.5.2" + }, + "conda-4.5.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env", + "pycosat", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml" + ], + "license": "BSD 3-Clause", + "md5": "834a00d6e68216b34dd5bd1333b931a0", + "name": "conda", + "sha256": "e79e5b1a67f02acf7546a462e8ba22c31518525925b3005cae56135e74a6f38b", + "size": 989981, + "subdir": "linux-64", + "timestamp": 1524848341661, + "version": "4.5.2" + }, + "conda-4.5.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "77b57b2aa3d284b998d464ca5b01897a", + "name": "conda", + "sha256": "1dd66009702e51e9fc6f23370d985840adb99c8fca1fe1d97f1d454791a2f759", + "size": 990316, + "subdir": "linux-64", + "timestamp": 1525719552511, + "version": "4.5.3" + }, + "conda-4.5.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "95646006978ef31d2b744b73f99267d7", + "name": "conda", + "sha256": "e7cb720a25559656ffb4f352d9fa7765b1b9c9bc50ce523533c166d400e6050a", + "size": 997328, + "subdir": "linux-64", + "timestamp": 1525719658067, + "version": "4.5.3" + }, + "conda-4.5.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "34cd185ca24c3a9eaff8649bce1ac439", + "name": "conda", + "sha256": "52c6b993e52e333190b27817c56bbcc44a9b35d79fcf2838e1523de3b3c356b4", + "size": 983558, + "subdir": "linux-64", + "timestamp": 1525719581394, + "version": "4.5.3" + }, + "conda-4.5.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "a33dd607cfc7f219a9f8d90496853799", + "name": "conda", + "sha256": "50c39e680e91d4f3fd3704534011cc37ecb71da4329f419f060b6aec4a8fd0be", + "size": 983940, + "subdir": "linux-64", + "timestamp": 1526301722414, + "version": "4.5.4" + }, + "conda-4.5.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "0390c66020e37dfa26fbca478d0c2536", + "name": "conda", + "sha256": "39aecf25791058ae3178af3ca3702c329f40f8696ed016a7f6b3c0dc72fbc06a", + "size": 990377, + "subdir": "linux-64", + "timestamp": 1526301728570, + "version": "4.5.4" + }, + "conda-4.5.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "6f351e99d1cc0502c6a7f09b2ba8e995", + "name": "conda", + "sha256": "f483db23f486dbbb4e2038e55e9015fb3e6ea0ab47b935ac2905f6583962ef0e", + "size": 984118, + "subdir": "linux-64", + "timestamp": 1526301698736, + "version": "4.5.4" + }, + "conda-4.5.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "4a74b2465361836eb0c385a900eaf445", + "name": "conda", + "sha256": "73fc79bfbd3165aef206a2460efdeea8f6f26bdd20e8aa5202145a30aae78c40", + "size": 985774, + "subdir": "linux-64", + "timestamp": 1530287624556, + "version": "4.5.5" + }, + "conda-4.5.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "fd88883fce03c3c6ca97fabdf7ce4ff9", + "name": "conda", + "sha256": "e51c31eb1f34522eb54ee46c8d14493aff38bd1d6a33926c3047c8172ece4ec8", + "size": 992133, + "subdir": "linux-64", + "timestamp": 1530287707793, + "version": "4.5.5" + }, + "conda-4.5.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "1ae2e532ed210b4fdbb4cbdc7ca1406e", + "name": "conda", + "sha256": "1ce3bf33c983cb047d9960e0e122c483554d5e5584c5ca7e734c2501be285b4b", + "size": 992362, + "subdir": "linux-64", + "timestamp": 1530287666218, + "version": "4.5.5" + }, + "conda-4.5.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "8098780d4930d14db3eb1842106ef0c1", + "name": "conda", + "sha256": "1bfd8009fad967cc14c70a209e5b5b3dbbd22564930c19662a26b7b09f5052dd", + "size": 987575, + "subdir": "linux-64", + "timestamp": 1531233259376, + "version": "4.5.8" + }, + "conda-4.5.8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "00ae4f1ee29434f70a24ddd9d24d6914", + "name": "conda", + "sha256": "c765b9bbeaa98840dd9b6208dcae38c1bd2442d738857c9ce7a8f82acbcd7acf", + "size": 993597, + "subdir": "linux-64", + "timestamp": 1531233339709, + "version": "4.5.8" + }, + "conda-4.5.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "b4c318dee6c0b8b0244f6abf0f731b94", + "name": "conda", + "sha256": "39f245203e542e73ebbd6327d50323302b094eddc90188290dd958990e3d9bb1", + "size": 986433, + "subdir": "linux-64", + "timestamp": 1531233340587, + "version": "4.5.8" + }, + "conda-4.5.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "1f9e0ca9089cff900ccd821a3742364a", + "name": "conda", + "sha256": "b4c48bea5374cb0fe62b50fb3fff889af22458ab294756df0c8ef94183fe2422", + "size": 994245, + "subdir": "linux-64", + "timestamp": 1531255947204, + "version": "4.5.8" + }, + "conda-4.5.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "enum34", + "futures", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "858c3d4f6174bb8a0d1731511de47374", + "name": "conda", + "sha256": "655eb86657a4a68a178952829e5bbf4ad1ce105ed40e2145e2cf55fb8c0b6e13", + "size": 987958, + "subdir": "linux-64", + "timestamp": 1532976248465, + "version": "4.5.9" + }, + "conda-4.5.9-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "74ef7e685ba13064e1c7160118388762", + "name": "conda", + "sha256": "bce77cf625bb9cb6d8af732420b9eed20cb52770e61137d361c1f2d80b44367c", + "size": 994374, + "subdir": "linux-64", + "timestamp": 1532976207113, + "version": "4.5.9" + }, + "conda-4.5.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "08d3a9a24e650d31c78104283dd14a3c", + "name": "conda", + "sha256": "b08ca66b5f5998fd4139df405ecbd5826af153700f4324333005285450675089", + "size": 995046, + "subdir": "linux-64", + "timestamp": 1532976244994, + "version": "4.5.9" + }, + "conda-4.5.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=2.1", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-env >=2.6", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.12.4,<3", + "ruamel_yaml >=0.11.14" + ], + "license": "BSD 3-Clause", + "md5": "d04960b3bde06405e897d6c6c8fb5fc3", + "name": "conda", + "sha256": "107cdd1f3f85620513a80e55499c393dd9db0a713bc3661e1eb5cab37274b8e4", + "size": 995025, + "subdir": "linux-64", + "timestamp": 1532976265906, + "version": "4.5.9" + }, + "conda-4.6.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "6be4228e839c1ed6fa99233054c07182", + "name": "conda", + "sha256": "0c08ddffb77f3ca3d1d4ba74b4737c7077d3cb877bb50bb4951f7465529c6925", + "size": 1569718, + "subdir": "linux-64", + "timestamp": 1548128995986, + "version": "4.6.1" + }, + "conda-4.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "a549f5af71119b7412894fd5fb450e50", + "name": "conda", + "sha256": "e8bef5e68d32a804554df165e5554e7b01fcf61f8ec0f1aff5932405bf67ca5f", + "size": 1576305, + "subdir": "linux-64", + "timestamp": 1548129036378, + "version": "4.6.1" + }, + "conda-4.6.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "3723aa5bc1e7d895008b243adbe12270", + "name": "conda", + "sha256": "6d795d2092aca750cfcedf02c5e0cc76d36a7db82d8fb4ccf90f75b06d9d2ffc", + "size": 1577375, + "subdir": "linux-64", + "timestamp": 1548129029327, + "version": "4.6.1" + }, + "conda-4.6.11-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "835031174dbf2b509a14307f07a8db06", + "name": "conda", + "sha256": "44b6ceda5be2b665f0e47a4282c07592f7ce7683def7c30a058cec4dad6317fb", + "size": 1606166, + "subdir": "linux-64", + "timestamp": 1554393717675, + "version": "4.6.11" + }, + "conda-4.6.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "62688aefb5793c78df56eca2ffe64df4", + "name": "conda", + "sha256": "87bb7386229194490120332d8c3ff1abe3df36a2a0656a17ef59f8f3a710da33", + "size": 1606260, + "subdir": "linux-64", + "timestamp": 1554393742094, + "version": "4.6.11" + }, + "conda-4.6.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "d8a2a81c402fe506c9cac35a765862a5", + "name": "conda", + "sha256": "05691b90a2256585596adc8a981476de3a3e359f9aae8c27ca539a20a0ac0377", + "size": 1606404, + "subdir": "linux-64", + "timestamp": 1554393737758, + "version": "4.6.11" + }, + "conda-4.6.12-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "339e78d1ed4a6bea1a1bd4ff25da47f6", + "name": "conda", + "sha256": "06f936e3fe4ca510178d2e2385e8740796599249ff23f0d337f58553d52e57e6", + "size": 2011391, + "subdir": "linux-64", + "timestamp": 1555005101890, + "version": "4.6.12" + }, + "conda-4.6.12-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "e0987a1d80b51e2a47d8cea37d999d6d", + "name": "conda", + "sha256": "ccb66cc55b17b193403c1de0edf1cdbc131144dc6483d9d180997a0eeb3de100", + "size": 2010682, + "subdir": "linux-64", + "timestamp": 1555005111370, + "version": "4.6.12" + }, + "conda-4.6.12-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "3764f765a9446f7c09fc0c7d74978b5c", + "name": "conda", + "sha256": "888dcc98a3dec820ece271d68ba761e2c0f05a96d5e6a5d6b7957285a6b3e5e4", + "size": 2019135, + "subdir": "linux-64", + "timestamp": 1555005086845, + "version": "4.6.12" + }, + "conda-4.6.14-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "159bd8bf7395cdaef3ad4d4b0b95f2a0", + "name": "conda", + "sha256": "7d740a1a2cee53d1eb37afee007a682f3eebeb452fcfd12bd47b778b873d4d9c", + "size": 2018153, + "subdir": "linux-64", + "timestamp": 1555533509159, + "version": "4.6.14" + }, + "conda-4.6.14-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "ea54769ac8ff41154b011a5fb3c9dacc", + "name": "conda", + "sha256": "b2d615af1fc516fa2d16e7c610e5186149b91d2f41b93d79300ee3f202eb80f0", + "size": 2025694, + "subdir": "linux-64", + "timestamp": 1555533655890, + "version": "4.6.14" + }, + "conda-4.6.14-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "a7076505d99a50fae252eae9e79c4720", + "name": "conda", + "sha256": "19333b2c91a172e22d46a7761bd7cb9c66e029894cfc12fc40ce6f43abf34343", + "size": 2018634, + "subdir": "linux-64", + "timestamp": 1555533610175, + "version": "4.6.14" + }, + "conda-4.6.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "8549427712950ccb948e0d7792f4597c", + "name": "conda", + "sha256": "ada62eba7b64701afb27b3b6d71a2d208d0d539b0e64941d6520d0f2c7fdfc58", + "size": 1565848, + "subdir": "linux-64", + "timestamp": 1548813703174, + "version": "4.6.2" + }, + "conda-4.6.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "9eae7cf91a87c12cb8bdd2d2fc44536a", + "name": "conda", + "sha256": "519d4e89e29964a24bb146c3ed8ea230ef3142277a2e2a780be30bc0595220ea", + "size": 1565669, + "subdir": "linux-64", + "timestamp": 1548813722240, + "version": "4.6.2" + }, + "conda-4.6.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "75c56f6f19dd13efdfaf1b123b98a109", + "name": "conda", + "sha256": "cdefda2198346a7f2724f9f7fa5f8509bfd4e9c9f52cb0c1fc5887100e26ef4a", + "size": 1573419, + "subdir": "linux-64", + "timestamp": 1548813723745, + "version": "4.6.2" + }, + "conda-4.6.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "d67033e40c87aaf3c9e4454677504eda", + "name": "conda", + "sha256": "ade2efe1221c3509d780fd004730b3c1b7b255a568aef68d4638cd9adb6224b3", + "size": 1567384, + "subdir": "linux-64", + "timestamp": 1549604018496, + "version": "4.6.3" + }, + "conda-4.6.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "26d4d636974167dbacf1bb15a302a2df", + "name": "conda", + "sha256": "b27107267201d3b9ca361eeb24b2f8b2feb65f34d2c87ae029f5d7cebeb644dc", + "size": 1574670, + "subdir": "linux-64", + "timestamp": 1549604060738, + "version": "4.6.3" + }, + "conda-4.6.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "40ea4c53aa62c1f10f1cb798fac2ec84", + "name": "conda", + "sha256": "86a5caa46ed029a359db2fe8a70e7d82d856be854292d84e53c6dad90ea75788", + "size": 1575908, + "subdir": "linux-64", + "timestamp": 1549603971568, + "version": "4.6.3" + }, + "conda-4.6.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "2216aa7d2cc35da9f64d64f8b64247ed", + "name": "conda", + "sha256": "a37140e4ac214b30aa4475d9e88cc298954f04fb1d7e97f1471477adf2b84e9c", + "size": 1568757, + "subdir": "linux-64", + "timestamp": 1550087104197, + "version": "4.6.4" + }, + "conda-4.6.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "b848b143c35e17c8825e996c59318fdf", + "name": "conda", + "sha256": "994a4cfae4fba39ed7c374990368f1eff1e9958943e1a6ece17f9708db320554", + "size": 1575297, + "subdir": "linux-64", + "timestamp": 1550087107769, + "version": "4.6.4" + }, + "conda-4.6.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "bcd2fb4202ff3e6d94e5990b8f8675c6", + "name": "conda", + "sha256": "93d1826a8cb30fd943e7670be713e725811ab1f032daaf8cbeea0c1b06680c0b", + "size": 1576622, + "subdir": "linux-64", + "timestamp": 1550087037738, + "version": "4.6.4" + }, + "conda-4.6.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "18634877eccaf8e9699882d9e3e83195", + "name": "conda", + "sha256": "f997e8e1fd8c86b4b8a14e9ed9357e01ef0ce49989e4ccd98e392db18b0183d5", + "size": 1575117, + "subdir": "linux-64", + "timestamp": 1550800422647, + "version": "4.6.7" + }, + "conda-4.6.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "54d2dae99b5d0c06589dce902b0125a2", + "name": "conda", + "sha256": "94866d59143010a16a6009896d6096378d20100b6c7f51c224f7487836779987", + "size": 1575590, + "subdir": "linux-64", + "timestamp": 1550800421013, + "version": "4.6.7" + }, + "conda-4.6.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "20ea818788e63aa7fc1d54641de563f8", + "name": "conda", + "sha256": "ca17781ba733f90ad26fec1bd23564167ee31d7b6043db2522856c4159c40233", + "size": 1576825, + "subdir": "linux-64", + "timestamp": 1550800382306, + "version": "4.6.7" + }, + "conda-4.6.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "54db5ed8f4b3bec0eff15b8ac00b2a64", + "name": "conda", + "sha256": "bc632191bd43820abbc780df1e4b7aefdffccea8afd4852beca3d4c33b108ca8", + "size": 1578082, + "subdir": "linux-64", + "timestamp": 1551930516190, + "version": "4.6.8" + }, + "conda-4.6.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "91fdc65f4d35a6b952a6af1557382a11", + "name": "conda", + "sha256": "38f5d4abc49c7dab15dbf0516ebecb096d4dd6a9d15737e379585e35283e449c", + "size": 1577625, + "subdir": "linux-64", + "timestamp": 1551930498590, + "version": "4.6.8" + }, + "conda-4.6.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "c8477fb6454aaa8906d9cf4cbe2533b1", + "name": "conda", + "sha256": "2ee323db10c56feceac2f3e14138268979aeffc912c4c7c7672150bf9b0eddd9", + "size": 1579011, + "subdir": "linux-64", + "timestamp": 1551930515604, + "version": "4.6.8" + }, + "conda-4.6.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "66c907d8df9ce025ed0ad440871d372c", + "name": "conda", + "sha256": "162a059a3d6bb7695c7932096643f2a605418afd6855dc84db08357e4bcf62a8", + "size": 1605668, + "subdir": "linux-64", + "timestamp": 1553910093735, + "version": "4.6.9" + }, + "conda-4.6.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "38df0dbb679a7c22c6f9a5661b9acc83", + "name": "conda", + "sha256": "91e6406a8d3079e0b875a342c4ebb45cad78a8f1e9f0b37d2112e494f5094c3b", + "size": 1605856, + "subdir": "linux-64", + "timestamp": 1553910106036, + "version": "4.6.9" + }, + "conda-4.6.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "753121f2a0a130a33dc60df9507e8b73", + "name": "conda", + "sha256": "48184bc1eee31b078f6e79fc91c9d56d5e99af1df11cbaf5bf907ccb1b54e515", + "size": 1606053, + "subdir": "linux-64", + "timestamp": 1553910107710, + "version": "4.6.9" + }, + "conda-4.7.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "483be040320bf4ff35f1d9acace2e0a7", + "name": "conda", + "sha256": "b49b2d4ca36ffdeb99e3dd04597401bb510eb82efea341b532d7480deaaadaf0", + "size": 2945500, + "subdir": "linux-64", + "timestamp": 1563566243809, + "version": "4.7.10" + }, + "conda-4.7.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "e13da0cc261436350e74e171f8ad66ca", + "name": "conda", + "sha256": "a265fb32d160dd22980f378057ea8dbcc26d5a8fa6767760c1188bfee4ea4eec", + "size": 2945460, + "subdir": "linux-64", + "timestamp": 1563566230627, + "version": "4.7.10" + }, + "conda-4.7.10-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "3d8ada94e4be0717c7183d67023094ae", + "name": "conda", + "sha256": "12fbb9fe1b31fb570999269bbcab4e38f895a4bc43e359e1f74085af8d02fa04", + "size": 2945961, + "subdir": "linux-64", + "timestamp": 1563566210774, + "version": "4.7.10" + }, + "conda-4.7.11-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "0b37c2010d2406d1bdc6f6407f165378", + "name": "conda", + "sha256": "db38ad45f429ff6c97ae5eecb56a712ac812449132dbca609aff78096c381ddf", + "size": 2948921, + "subdir": "linux-64", + "timestamp": 1565121783266, + "version": "4.7.11" + }, + "conda-4.7.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "f87f2563a0302c7f65e865593a5006a7", + "name": "conda", + "sha256": "0dae739cbf8c70a5923146e6ee41ff62e60b08511a039299a1578d6f089c4938", + "size": 2949229, + "subdir": "linux-64", + "timestamp": 1565121923236, + "version": "4.7.11" + }, + "conda-4.7.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "ad669e4ee83adf01db80961df85e1ea1", + "name": "conda", + "sha256": "f5c7bac05649d18b74015a32ef8ace77ca103696a9b2078ae77c73ae79317e65", + "size": 2949663, + "subdir": "linux-64", + "timestamp": 1565121200033, + "version": "4.7.11" + }, + "conda-4.7.12-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "77076e23b738e546146c558bdfba18ba", + "name": "conda", + "sha256": "4f26ebac032f23ce0bb5e6d4495e0a4ca082fb5bea3ab9e8046a1cdbd7bfd1e4", + "size": 2949962, + "subdir": "linux-64", + "timestamp": 1568310299047, + "version": "4.7.12" + }, + "conda-4.7.12-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "23a91ac724320e835ffa351a26a304c8", + "name": "conda", + "sha256": "b3656b6c27070d2d80fabf75af8024297d81c177ee07c4dc360eea4796664e79", + "size": 2952327, + "subdir": "linux-64", + "timestamp": 1568310314336, + "version": "4.7.12" + }, + "conda-4.7.12-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "bfb70d9ca84d9fceee231df82e770ccd", + "name": "conda", + "sha256": "39611a9cf764324a9004f50db3696447beae0a74742c0c10a89c16d50a4263f3", + "size": 2952188, + "subdir": "linux-64", + "timestamp": 1568310307400, + "version": "4.7.12" + }, + "conda-4.7.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "a3e19bc0236e777a3d45e7f884b377f8", + "name": "conda", + "sha256": "e47f740e87bb646cb0708ee5cf75e9f23443961b8b790c91db913b1f3d477575", + "size": 2934201, + "subdir": "linux-64", + "timestamp": 1561412192588, + "version": "4.7.5" + }, + "conda-4.7.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "edd904902e6f5b95415a5939d37970aa", + "name": "conda", + "sha256": "350b1dadcac2d186a684b4262b3f8c431b78b1de72838988ad8ecf52fd244757", + "size": 2930512, + "subdir": "linux-64", + "timestamp": 1561412219811, + "version": "4.7.5" + }, + "conda-4.7.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "3f03d5338bd0be3647eb9154ac7068cd", + "name": "conda", + "sha256": "e8be5de9a8f11393251e4b6bfa5e95e979f73d5c3a2c0e2a7b342bec0e3c664d", + "size": 2930668, + "subdir": "linux-64", + "timestamp": 1561412180014, + "version": "4.7.5" + }, + "conda-4.7.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "723de699f4124440fd48a8dece64e603", + "name": "conda", + "sha256": "60f077c37b8591adb66c10b8b24a8ce5bbbeaa32a59b35cca21b20fa98818c3a", + "size": 2939296, + "subdir": "linux-64", + "timestamp": 1563398543033, + "version": "4.7.8" + }, + "conda-4.7.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "e36746a5a240db5122785672a89a7576", + "name": "conda", + "sha256": "609ef60702d9057e98cdc9f14ee456066190cf970fc970c0581bb1c0e6e0d23a", + "size": 2946135, + "subdir": "linux-64", + "timestamp": 1563398558776, + "version": "4.7.8" + }, + "conda-4.7.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "37ae6960fc4d37c8c2bf0f46076a155e", + "name": "conda", + "sha256": "3df8cde612d6b61153e676b4a80580f375c49870914cd9565b371c3a1c36099f", + "size": 2946834, + "subdir": "linux-64", + "timestamp": 1563398529351, + "version": "4.7.8" + }, + "conda-4.7.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "f7ff2d42d5c80e755922ae17003fdcb1", + "name": "conda", + "sha256": "e81772cdace6c25c50f816b3996355462945cb0dcfaccc987dcd4e088e8c6549", + "size": 2945457, + "subdir": "linux-64", + "timestamp": 1563478137013, + "version": "4.7.9" + }, + "conda-4.7.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "2354b1ed7b17671a93975238e9830ff3", + "name": "conda", + "sha256": "8758a45081870533f35f661a43ea27277200623518430b434ce44593f32d7bd1", + "size": 2938726, + "subdir": "linux-64", + "timestamp": 1563478135332, + "version": "4.7.9" + }, + "conda-4.7.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "64a6b241557123857dbcad89afb834f0", + "name": "conda", + "sha256": "d4b29801db94a946020a826726069237dfd323c79f81cdf31951aabfef2e2e09", + "size": 2938799, + "subdir": "linux-64", + "timestamp": 1563478138590, + "version": "4.7.9" + }, + "conda-4.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "cfb2fcb99bc94bf1c662cec66ce9ec28", + "name": "conda", + "sha256": "a3b367bdc028357d9005bfe54bc084d64db680080b34308d59c2dee5e8b9b768", + "size": 2966700, + "subdir": "linux-64", + "timestamp": 1576014409455, + "version": "4.8.0" + }, + "conda-4.8.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "1e27ee3b1fc02bccae79483e52e70894", + "name": "conda", + "sha256": "c9bb5bc5444fd73e8bf238d2719278f1c08ed1f166b4f651529c3c24b7eb76da", + "size": 2963304, + "subdir": "linux-64", + "timestamp": 1576518384621, + "version": "4.8.0" + }, + "conda-4.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "4f29aa4ad4e545edfee885ab0d44db5b", + "name": "conda", + "sha256": "12cd01a2bf1e02ddd4da52e0c2770377937ea8f9440f4283d9944bb9d57599e6", + "size": 2955855, + "subdir": "linux-64", + "timestamp": 1576014317588, + "version": "4.8.0" + }, + "conda-4.8.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "3e6e842b7b9abea4896d87bcfc5a24fa", + "name": "conda", + "sha256": "083b075e998fe1e8b49b25dcd5ba489176031c36bc93d56de63babf7b44b62a7", + "size": 2960262, + "subdir": "linux-64", + "timestamp": 1576518364899, + "version": "4.8.0" + }, + "conda-4.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "eba429f0319c02475fd32fbfea6824b5", + "name": "conda", + "sha256": "a32a1fbd617efd9788410f540ca728e935b09a4595b5539634d6676f2e2a0e8b", + "size": 2956909, + "subdir": "linux-64", + "timestamp": 1576014426650, + "version": "4.8.0" + }, + "conda-4.8.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "69fcd99f0d118438195c80d45bb9004b", + "name": "conda", + "sha256": "0a39616ec70b176d58351f02f65966ed9dd8a8abb9597dbc29aca77daf48a727", + "size": 2964097, + "subdir": "linux-64", + "timestamp": 1576518373377, + "version": "4.8.0" + }, + "conda-4.8.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "82e7ab9121246abee8c99b3c4295596a", + "name": "conda", + "sha256": "e0baddb77adec17e66ee5c69f2707b0d124013d08774799afb6ee27a44e3da74", + "size": 2962881, + "subdir": "linux-64", + "timestamp": 1576518374003, + "version": "4.8.0" + }, + "conda-4.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "46c4e44b832831516d0c84185e1d11c7", + "name": "conda", + "sha256": "700e687620e18517db7e5bc12d7ec82d84fc72e18677455c3ece555107655eae", + "size": 2963927, + "subdir": "linux-64", + "timestamp": 1576798189451, + "version": "4.8.1" + }, + "conda-4.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "080eb3e8d418f645eb1319a857f4ae56", + "name": "conda", + "sha256": "c4c98e0d5497b4d46df4bb36e678240c0d6d654c5bb0d70078543803066dda5c", + "size": 2961643, + "subdir": "linux-64", + "timestamp": 1576798197060, + "version": "4.8.1" + }, + "conda-4.8.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "0184b64161dcd0ef3513a91e23d76bbb", + "name": "conda", + "sha256": "07680dff81122ddd059f3c053923f1a771089ad629609d25a29f8f70a5409ec5", + "size": 2970239, + "subdir": "linux-64", + "timestamp": 1576798200015, + "version": "4.8.1" + }, + "conda-4.8.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "194c8b47b0d74a5478581958cb022283", + "name": "conda", + "sha256": "6a99122447c0a0200c532dd61cb8df364f18487b854d980ceb99603395e34a61", + "size": 2983580, + "subdir": "linux-64", + "timestamp": 1576798226942, + "version": "4.8.1" + }, + "conda-4.8.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "19c8da0c6495edffe8b3ad9665ae4bc7", + "name": "conda", + "sha256": "5487fa85696ca68331281bc3e9aebfe9e962e6db7492dc8ecf6a58529a1a6574", + "size": 2962769, + "subdir": "linux-64", + "timestamp": 1579893287075, + "version": "4.8.2" + }, + "conda-4.8.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "d2b363a3fde6df8795d260f297a2a3e7", + "name": "conda", + "sha256": "2a58a7af929cadd9de3ac899c64bb795aed25bc51dec044a9c61b941f509e860", + "size": 2972414, + "subdir": "linux-64", + "timestamp": 1579892872863, + "version": "4.8.2" + }, + "conda-4.8.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "7aa69a81c9f0fbc3024169b4705bc245", + "name": "conda", + "sha256": "20381d6f933a48b3a3ee05e1055f2eac0e6f4791b3b12bc8bffaf0a62676e059", + "size": 2961690, + "subdir": "linux-64", + "timestamp": 1579892868224, + "version": "4.8.2" + }, + "conda-4.8.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "a00a186bddf7eab58d5875282457a7aa", + "name": "conda", + "sha256": "19d8ca36eb320505bee4eb0187c35de19b7ba01039c6ae18b093119bdb0e3edf", + "size": 2977937, + "subdir": "linux-64", + "timestamp": 1579892881591, + "version": "4.8.2" + }, + "conda-4.8.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "f7b2f885a443910df5886f46da9257b2", + "name": "conda", + "sha256": "de7be882f6f2325ac8bface83627b8059c59e6f17f37e57cfcbd0f2947406f1c", + "size": 2967297, + "subdir": "linux-64", + "timestamp": 1584118806192, + "version": "4.8.3" + }, + "conda-4.8.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "c3299735857b3d648b42ba60760eae6d", + "name": "conda", + "sha256": "bdb43c2bab304b70d52defb6c01e9bf80b608d24f4ef06e17565795d46e70da8", + "size": 2964036, + "subdir": "linux-64", + "timestamp": 1584118803492, + "version": "4.8.3" + }, + "conda-4.8.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "9b4a02f43a3cda30abc0133f377971cf", + "name": "conda", + "sha256": "2add7ec3b27204f4894b1e64d359328f61ede57b59ceacf7fb61276d93cbdd58", + "size": 2971558, + "subdir": "linux-64", + "timestamp": 1584118827005, + "version": "4.8.3" + }, + "conda-4.8.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "4221fef92e92b4f20c24978638a59fb0", + "name": "conda", + "sha256": "a59a2119758ec27c48ed2fbf04e6e56faec7f1fdfe56738c55a31a4ed0b2084f", + "size": 2972812, + "subdir": "linux-64", + "timestamp": 1584118815255, + "version": "4.8.3" + }, + "conda-4.8.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "enum34", + "futures >=3.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "scandir", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "d90a42fcef7b070940f6896a31fdc888", + "name": "conda", + "sha256": "6e78ff92a4e5107f592ccdd5e049d9a8c24650697e38d4bbf2b03d1412574a49", + "size": 2988189, + "subdir": "linux-64", + "timestamp": 1596806961431, + "version": "4.8.4" + }, + "conda-4.8.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "fa5fddfa79decc6bdaa1fbf45c17ccbb", + "name": "conda", + "sha256": "730721d2beb73334c96d9ef61a4f46089f026bf099558f1f7327aefc53d91953", + "size": 2979322, + "subdir": "linux-64", + "timestamp": 1596806942726, + "version": "4.8.4" + }, + "conda-4.8.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "de36b8d66edce7e934ac2d5ddd270d35", + "name": "conda", + "sha256": "fbcaf3da6ff5064663039efdacd486aa7652928d80b146f6dd70200c02a43c24", + "size": 2989388, + "subdir": "linux-64", + "timestamp": 1596806949701, + "version": "4.8.4" + }, + "conda-4.8.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "f3193e96dcdbc612b1538fecc71f8d2a", + "name": "conda", + "sha256": "1778d075811ec7a26f6c97c4cc5d3f757e1a506f9681470519c45524c4515ee6", + "size": 2986897, + "subdir": "linux-64", + "timestamp": 1596806960404, + "version": "4.8.4" + }, + "conda-4.8.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "98ff47d0adf4412e640e3068b6e9f9ae", + "name": "conda", + "sha256": "c2b5875dd783d8659a9202e5cc4190c3f3e0ffffaf1d672c6f4bdc37ed6ae7c8", + "size": 2982831, + "subdir": "linux-64", + "timestamp": 1600101159916, + "version": "4.8.5" + }, + "conda-4.8.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "2b27ec8f0d88368f7c98446bb41b9215", + "name": "conda", + "sha256": "f71867091b7d6ea641dce6db9ef2745776605efd6d4f60fdf7cb5ee05145c724", + "size": 2982233, + "subdir": "linux-64", + "timestamp": 1600101130890, + "version": "4.8.5" + }, + "conda-4.8.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "e34c2035bfbde266e2f0c59261af3803", + "name": "conda", + "sha256": "aab1a8a7b234b2220fbcab10f4c8c5c7337d37c3c2e493b5de3abc26ab9a14b9", + "size": 3001618, + "subdir": "linux-64", + "timestamp": 1600101132847, + "version": "4.8.5" + }, + "conda-4.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "84c246d28c74cbc1a4e95bab7fe3e81d", + "name": "conda", + "sha256": "a619a289829d7223266ac8e0a47bc47f907a2a6794896fe52d293befee52d810", + "size": 3006172, + "subdir": "linux-64", + "timestamp": 1602695677366, + "version": "4.9.0" + }, + "conda-4.9.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "47f500d96b28fdee99000b63c3368603", + "name": "conda", + "sha256": "1bfd524faf8d2756d626dcca96e7a1512989818b52219084d8d9d428b6491368", + "size": 3005316, + "subdir": "linux-64", + "timestamp": 1602695672504, + "version": "4.9.0" + }, + "conda-4.9.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "531d273c48d1201f991b447e63f46df2", + "name": "conda", + "sha256": "eaf69927c3c156563faa2600ff58f6fb380ae9dbde98ba35e49b8a99c6a2ec7d", + "size": 2998411, + "subdir": "linux-64", + "timestamp": 1602695672853, + "version": "4.9.0" + }, + "conda-4.9.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "4a7589e4d3475c59fb91e32324bd015b", + "name": "conda", + "sha256": "515922d3b355fef64bc8c4ebda5ae201dd8bed43c650fb89de7ca42e5edcc462", + "size": 2991324, + "subdir": "linux-64", + "timestamp": 1603740915199, + "version": "4.9.1" + }, + "conda-4.9.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "e482dd4e262b539421e94d5e00c9d80e", + "name": "conda", + "sha256": "f38fca6d5683849523574d56798050c4c874c6619b5d01ae51f7c7c947b0fedf", + "size": 2998662, + "subdir": "linux-64", + "timestamp": 1603738964215, + "version": "4.9.1" + }, + "conda-4.9.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "d8e1f62429ee6d699a088adc75459b77", + "name": "conda", + "sha256": "a9040ce755e2c57e107f7329ce88a94502ed6452a030976fb8d6d2e970364844", + "size": 3009688, + "subdir": "linux-64", + "timestamp": 1603738979273, + "version": "4.9.1" + }, + "conda-4.9.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "3d64ba8f5c7ae19af015900378ab5b39", + "name": "conda", + "sha256": "7b6a02ccc5030a4bacf5072e0e6d406eb82c9bda778593e3280f7d560fed7752", + "size": 2993138, + "subdir": "linux-64", + "timestamp": 1605067712825, + "version": "4.9.2" + }, + "conda-4.9.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "65f98cc22a1568edf3c4fe26ca226455", + "name": "conda", + "sha256": "aa29e8bcb128ea992950ace90fc866e0fd0bd6a0b2e4bd474c21f380b32fb806", + "size": 2993892, + "subdir": "linux-64", + "timestamp": 1605068097561, + "version": "4.9.2" + }, + "conda-4.9.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "82788e195ae9d6aedea017c9d48727ec", + "name": "conda", + "sha256": "86e82913c8dfdeaad8587659dd08d203da1c25af5800972793dd42419bc1bef6", + "size": 3002118, + "subdir": "linux-64", + "timestamp": 1605067666167, + "version": "4.9.2" + }, + "conda-4.9.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-build >=3", + "conda-env >=2.6", + "cytoolz >=0.8.1" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18.4,<3", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools >=31.0.1" + ], + "license": "BSD 3-Clause", + "md5": "5c0336781e4c8a55b0d204182018a7de", + "name": "conda", + "sha256": "5b6b25b7560a384478de78fa0daeb56ca0c71b7e88c7a700502b399b95c07df5", + "size": 3006876, + "subdir": "linux-64", + "timestamp": 1607006162985, + "version": "4.9.2" + }, + "conda-audit-0.8.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "conda", + "conda-repo-cli", + "python >=3.10,<3.11.0a0", + "requests", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d4c6c0d7d3fe35a5532a19090edbc1a7", + "name": "conda-audit", + "sha256": "d5e1f43b59f23927326e74672b2499cc5479cb5a5b10a1297569093be5893004", + "size": 15518, + "subdir": "linux-64", + "timestamp": 1655392299750, + "version": "0.8.1" + }, + "conda-audit-0.8.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "conda", + "conda-repo-cli", + "python >=3.7,<3.8.0a0", + "requests", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1a3f0080671bf29be2b7c6e0cf3dd5be", + "name": "conda-audit", + "sha256": "e8b20d1da76880ba3c964c1bfef9e172f41265ae675902a5a69651392963aca8", + "size": 15512, + "subdir": "linux-64", + "timestamp": 1655392254734, + "version": "0.8.1" + }, + "conda-audit-0.8.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "conda", + "conda-repo-cli", + "python >=3.8,<3.9.0a0", + "requests", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5ef0bb4132786eb1d385e3bd1103fc34", + "name": "conda-audit", + "sha256": "5d17d294d5709389a35ce4a4ec373cc7f4947200d9488aa254672c230bc77904", + "size": 15493, + "subdir": "linux-64", + "timestamp": 1655392184141, + "version": "0.8.1" + }, + "conda-audit-0.8.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "conda", + "conda-repo-cli", + "python >=3.9,<3.10.0a0", + "requests", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a8a4e31b8e37035816a22299dbe93f22", + "name": "conda-audit", + "sha256": "536c08fd4cd76a074444bdaf552d309887acda5dbb8e4b7be0b26b549cedfe43", + "size": 15445, + "subdir": "linux-64", + "timestamp": 1655392221156, + "version": "0.8.1" + }, + "conda-build-3.0.22-py27h62b9468_0.conda": { + "build": "py27h62b9468_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5da4204f8be6334dbd183c8216c153b1", + "name": "conda-build", + "sha256": "50128b8e27f316f72f3d824418a051140bf7361616bca1b72271a6624c0c5a65", + "size": 375350, + "subdir": "linux-64", + "timestamp": 1505957115271, + "version": "3.0.22" + }, + "conda-build-3.0.22-py35h43e46ce_0.conda": { + "build": "py35h43e46ce_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "840976a3d930966995c6f0f72ecefae7", + "name": "conda-build", + "sha256": "4684d9f1065133827a7ce6cd468edc06c1a7d0b38c17ed61c401fcba4967ddc3", + "size": 373816, + "subdir": "linux-64", + "timestamp": 1505957138698, + "version": "3.0.22" + }, + "conda-build-3.0.22-py36ha23cd1e_0.conda": { + "build": "py36ha23cd1e_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a7278897de00c41da7fc56643ab140b0", + "name": "conda-build", + "sha256": "7b5b0f43d3e1c1a47942ff7105577e30574f29d6d51bfd319295fd6c957810d1", + "size": 369383, + "subdir": "linux-64", + "timestamp": 1505957162933, + "version": "3.0.22" + }, + "conda-build-3.0.23-py27h7bd6724_0.conda": { + "build": "py27h7bd6724_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eae35cafdf4035d7865857b486cc5e10", + "name": "conda-build", + "sha256": "b3782c591ecfd4f6f008e0c3460ad8a1ec7881ce67dd7d88916eaa46b59e5ce3", + "size": 375678, + "subdir": "linux-64", + "timestamp": 1506713835808, + "version": "3.0.23" + }, + "conda-build-3.0.23-py35hea4baf8_0.conda": { + "build": "py35hea4baf8_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f536593bccc1e52669880efaa22e22f7", + "name": "conda-build", + "sha256": "6cf357cf28747e75cc6f891e15e880c9573642b01719fabdcce411cd177219d8", + "size": 374114, + "subdir": "linux-64", + "timestamp": 1506713848497, + "version": "3.0.23" + }, + "conda-build-3.0.23-py36h1da9bb0_0.conda": { + "build": "py36h1da9bb0_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "70333bbc4b7cf0b69bfe1edf8228ace3", + "name": "conda-build", + "sha256": "b8cf4766b21142460471aa45ba7e58fbc2b98a587bf4fa1a6d272cc6446e97eb", + "size": 373350, + "subdir": "linux-64", + "timestamp": 1506713850026, + "version": "3.0.23" + }, + "conda-build-3.0.25-py27h9e7ea37_0.conda": { + "build": "py27h9e7ea37_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d62ccc6aac847f3ef68eb28bb31cd286", + "name": "conda-build", + "sha256": "83f47bdc5fc332400db617546c54aebf98f8bfd4a689d133ca4ed34461dfda93", + "size": 374722, + "subdir": "linux-64", + "timestamp": 1507323544381, + "version": "3.0.25" + }, + "conda-build-3.0.25-py35h519b4b2_0.conda": { + "build": "py35h519b4b2_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c2edd5d2c54fcd6fed35b4239ee7352e", + "name": "conda-build", + "sha256": "17eb2a2d6e21c1f124eab7d7c19d274f1828ae6798ee8bef779bd432d5121cb2", + "size": 376157, + "subdir": "linux-64", + "timestamp": 1507323529255, + "version": "3.0.25" + }, + "conda-build-3.0.25-py36hd2c3b30_0.conda": { + "build": "py36hd2c3b30_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dcf22963deaa4a0e5f89f4a9c0827a4f", + "name": "conda-build", + "sha256": "37773d5b778429b3860497f7f89ff79c3bf939fb9c351cbf1c48d0af238e7ef1", + "size": 371687, + "subdir": "linux-64", + "timestamp": 1507323609964, + "version": "3.0.25" + }, + "conda-build-3.0.26-py27h07bdda1_0.conda": { + "build": "py27h07bdda1_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "65f4be4604e5e0c6093da96dc31dc60b", + "name": "conda-build", + "sha256": "de05ec65a6454b8e17286702fc6d048f4c273615a72ee64ff54753a6d76f92ec", + "size": 377044, + "subdir": "linux-64", + "timestamp": 1508170500586, + "version": "3.0.26" + }, + "conda-build-3.0.26-py35h4278e0b_0.conda": { + "build": "py35h4278e0b_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7dde53d31dc3cafedd5f52c59caccfb4", + "name": "conda-build", + "sha256": "2808cf79c574abc0e3fdafa6b1ffe298c8169bfe536ec1858d54c71bba588787", + "size": 378538, + "subdir": "linux-64", + "timestamp": 1508170502021, + "version": "3.0.26" + }, + "conda-build-3.0.26-py36he907c6d_0.conda": { + "build": "py36he907c6d_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "27dc0f6c29865fd571a163cb3e70da07", + "name": "conda-build", + "sha256": "c672ca1e1df50dcb4944a12a884fb8c5a10f63c795776abcecb098095da22a5a", + "size": 374254, + "subdir": "linux-64", + "timestamp": 1508170527899, + "version": "3.0.26" + }, + "conda-build-3.0.27-py27hff9f855_0.conda": { + "build": "py27hff9f855_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "083a8c5db479ff45ec3fc985d15e0364", + "name": "conda-build", + "sha256": "e4c422a8b2816e09d04bad9f52fb92da8547e0ac14369d42f91025a9923e7fa1", + "size": 380154, + "subdir": "linux-64", + "timestamp": 1508268461537, + "version": "3.0.27" + }, + "conda-build-3.0.27-py35h86d73a5_0.conda": { + "build": "py35h86d73a5_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f1bef04161f1352368b1e9e6b36a3d90", + "name": "conda-build", + "sha256": "faf5c4b934869cc6cef44c39bb3773fb7176cc6e4bd9eb678cce5a80443fb45a", + "size": 381938, + "subdir": "linux-64", + "timestamp": 1508268464038, + "version": "3.0.27" + }, + "conda-build-3.0.27-py36h940a66d_0.conda": { + "build": "py36h940a66d_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1f45a6fd1b7f68595f73a833408bc074", + "name": "conda-build", + "sha256": "c2791fafd7efba77a24f3eb1d90c4653bcb93c74f5ffa5b18b511afa3553b577", + "size": 377676, + "subdir": "linux-64", + "timestamp": 1508268468009, + "version": "3.0.27" + }, + "conda-build-3.0.28-py27h7ba76ae_0.conda": { + "build": "py27h7ba76ae_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "50348cd3fdd1233c5a2a1d01210795b8", + "name": "conda-build", + "sha256": "6f06cc56c4953d14a3fdfcbc5c17053dbe28c2478445b8eba78d0d74f5fc9fa7", + "size": 383929, + "subdir": "linux-64", + "timestamp": 1509654249031, + "version": "3.0.28" + }, + "conda-build-3.0.28-py35hf80548c_0.conda": { + "build": "py35hf80548c_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0f219f98496b03e6ba47a59f233ce0ef", + "name": "conda-build", + "sha256": "fcb5fc8f3c50bd42d3d885c7aeb9c8d73780edefb857c2a0ce2198754c945d8d", + "size": 385463, + "subdir": "linux-64", + "timestamp": 1509654259481, + "version": "3.0.28" + }, + "conda-build-3.0.28-py36h4c1d7b2_0.conda": { + "build": "py36h4c1d7b2_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0bd99b0f40ceb7b1ca24a81dfe70b7fc", + "name": "conda-build", + "sha256": "2768f8acd5aaab79396a796c58b810a002259eebe0adbf259e909c68f8d89ca4", + "size": 381082, + "subdir": "linux-64", + "timestamp": 1509654263871, + "version": "3.0.28" + }, + "conda-build-3.0.29-py27hd1a3dae_0.conda": { + "build": "py27hd1a3dae_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "25e2fb81ce62fa6e2ed36dc199194032", + "name": "conda-build", + "sha256": "11337db7c0c1937ac39d8aa7f94a910a0a8ce41a6500b0a11607118d7c0512ce", + "size": 393609, + "subdir": "linux-64", + "timestamp": 1510352388336, + "version": "3.0.29" + }, + "conda-build-3.0.29-py35hf44b5de_0.conda": { + "build": "py35hf44b5de_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aa7de57f29938465e044524474a6662c", + "name": "conda-build", + "sha256": "46e1b282342b3280e9e4af5d4264ed6327a48c359b769710ca4db6a60d9f1670", + "size": 392560, + "subdir": "linux-64", + "timestamp": 1510352388661, + "version": "3.0.29" + }, + "conda-build-3.0.29-py36h7319bf4_0.conda": { + "build": "py36h7319bf4_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6c09a5f25eaff5d971d6e85d83ed2d17", + "name": "conda-build", + "sha256": "63bc71a8d739eb470c8625aed15768fbb84f3c9d1e8ef431af03c72862e3e019", + "size": 388167, + "subdir": "linux-64", + "timestamp": 1510352349266, + "version": "3.0.29" + }, + "conda-build-3.0.30-py27h5c0a2bd_0.conda": { + "build": "py27h5c0a2bd_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9a591f78fd88ec656b6b6e9bd339d160", + "name": "conda-build", + "sha256": "b6d509de0551d42f67cbc650ce01994045b3adc0b336084c7bcda0b5161659d9", + "size": 393864, + "subdir": "linux-64", + "timestamp": 1510794545986, + "version": "3.0.30" + }, + "conda-build-3.0.30-py35hd089694_0.conda": { + "build": "py35hd089694_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1a443f9f363baf67209177fbed543c1a", + "name": "conda-build", + "sha256": "895fae9ca9cd2170cfdb40dab132d0fdc00cefb445492b94350a5d2064436fd2", + "size": 392813, + "subdir": "linux-64", + "timestamp": 1510794555919, + "version": "3.0.30" + }, + "conda-build-3.0.30-py36hc0a0e36_0.conda": { + "build": "py36hc0a0e36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c7d88850c7dfac926e5f94914fac26a2", + "name": "conda-build", + "sha256": "eaa6873ae7263d39251fe81aa3d1c7bb148452cad17d38209e06c89ce5316a21", + "size": 391522, + "subdir": "linux-64", + "timestamp": 1510794558562, + "version": "3.0.30" + }, + "conda-build-3.0.31-py27h49342b2_0.conda": { + "build": "py27h49342b2_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5a9aa03e07dfc0ab50fa6b0e3aa0b4a5", + "name": "conda-build", + "sha256": "fb656a2474e3fd7f7e108a4db4e1f0935cfabbc139e59c2ac52f779dad707dc2", + "size": 395088, + "subdir": "linux-64", + "timestamp": 1512072485097, + "version": "3.0.31" + }, + "conda-build-3.0.31-py35h9a3bff0_0.conda": { + "build": "py35h9a3bff0_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "71851b1c26100f19a4f382f78f68fc29", + "name": "conda-build", + "sha256": "fa08068bfa89ef121cb4b627fcd8e8c0e943721262790b409f3e7fd3f82a730c", + "size": 393884, + "subdir": "linux-64", + "timestamp": 1512072488385, + "version": "3.0.31" + }, + "conda-build-3.0.31-py36h269c84b_0.conda": { + "build": "py36h269c84b_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "99455ed234a118ca866d92aab5c79ae3", + "name": "conda-build", + "sha256": "8c58963f48c9ae442dddc063af68aa1015e05b19c9583940cfb5637120887a2e", + "size": 389601, + "subdir": "linux-64", + "timestamp": 1512072549760, + "version": "3.0.31" + }, + "conda-build-3.1.0-py27h049eb84_0.conda": { + "build": "py27h049eb84_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "38a8510f752df16a0c2468e44b39e2c5", + "name": "conda-build", + "sha256": "d27430512ad1ca9579d18b4d7abc69a6fd02c44b54ebca690a37564cddd045f8", + "size": 396615, + "subdir": "linux-64", + "timestamp": 1512509604602, + "version": "3.1.0" + }, + "conda-build-3.1.0-py35h0f6ab93_0.conda": { + "build": "py35h0f6ab93_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b3c4e3fb5612a315471d517b1e76fab7", + "name": "conda-build", + "sha256": "ad316d7bc6e07d28550ecdb3eb81f486bf5b3cba872a82e5e70a32eebafcc60b", + "size": 395738, + "subdir": "linux-64", + "timestamp": 1512509604903, + "version": "3.1.0" + }, + "conda-build-3.1.0-py36h13c0544_0.conda": { + "build": "py36h13c0544_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "750e1a0a48a897abc4494b95f07e5eb5", + "name": "conda-build", + "sha256": "f3466e5116031545ad3cc6753600c0217daed04a8da652cb45e3ff127c5407dc", + "size": 394237, + "subdir": "linux-64", + "timestamp": 1512509601203, + "version": "3.1.0" + }, + "conda-build-3.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7be9baf1b44779b3cd63269f2821db5d", + "name": "conda-build", + "sha256": "0c1e5cbb42360cb68376e06fb83d5807eed8ec85dd82919dfbbed9eb310416b9", + "size": 394215, + "subdir": "linux-64", + "timestamp": 1512615345342, + "version": "3.1.1" + }, + "conda-build-3.1.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5cb2264ce7430504bf1ece62f64cd43a", + "name": "conda-build", + "sha256": "b6af7365186a1cd547e6e6a9132825a3f90e91880c06a379be07180c5b701da1", + "size": 399320, + "subdir": "linux-64", + "timestamp": 1512615331100, + "version": "3.1.1" + }, + "conda-build-3.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3d78a68ac7842cabc9c27de56159a9ad", + "name": "conda-build", + "sha256": "a65567dc28bf9b87897a700be15cd57c8f2a448e5f6f685f4d7d131b2d5290b8", + "size": 394032, + "subdir": "linux-64", + "timestamp": 1512615374704, + "version": "3.1.1" + }, + "conda-build-3.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cf420a5b729547df4b5eea4221e15d8f", + "name": "conda-build", + "sha256": "d53b8c32e86e84d42ed60bdd37bcb3f1dfe8858eaa22510c2bce3a48afbe2b72", + "size": 394881, + "subdir": "linux-64", + "timestamp": 1512873509214, + "version": "3.1.2" + }, + "conda-build-3.1.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "74c7b089c11bb71a9d23a55e7931e361", + "name": "conda-build", + "sha256": "35f0a26268cfcf4f86af1da638177ff7fc088eb05a0558b35b79d4f025409aaf", + "size": 396345, + "subdir": "linux-64", + "timestamp": 1512873560949, + "version": "3.1.2" + }, + "conda-build-3.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fa2bb8d0d56d4cf5568a01adda01d063", + "name": "conda-build", + "sha256": "86b658fc43bdf98b8971a2f492a701691f72617b5d966dd2679ddbd28a0fffd5", + "size": 395184, + "subdir": "linux-64", + "timestamp": 1512873583094, + "version": "3.1.2" + }, + "conda-build-3.1.3-py27h5233db4_0.conda": { + "build": "py27h5233db4_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "838176d32228efeae0daa1711ace497c", + "name": "conda-build", + "sha256": "b903514936847e33e532a5793138c31badd7dbb5dadbf94ffb35d327d9f473ca", + "size": 395858, + "subdir": "linux-64", + "timestamp": 1513182704168, + "version": "3.1.3" + }, + "conda-build-3.1.3-py35h2f9c1c0_0.conda": { + "build": "py35h2f9c1c0_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c92e5019485a1b76852606bb6e4d4adf", + "name": "conda-build", + "sha256": "dd1d21cb599cf3b2ce897403272fb2787cf554123f368f00bebf7bd326982aee", + "size": 397456, + "subdir": "linux-64", + "timestamp": 1513182722690, + "version": "3.1.3" + }, + "conda-build-3.1.3-py36h2f9c1c0_0.conda": { + "build": "py36h2f9c1c0_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e4efa84741c2ca29401bd4e8ac00665d", + "name": "conda-build", + "sha256": "793a1ae0a7467e46b78ba5d88c2e7c381a1427ec65cf30e334e1ec92e4059bd9", + "size": 392572, + "subdir": "linux-64", + "timestamp": 1513182759795, + "version": "3.1.3" + }, + "conda-build-3.1.4-py27h5233db4_0.conda": { + "build": "py27h5233db4_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "de8c8dcbfa27e647ff95acee0fdfa0e7", + "name": "conda-build", + "sha256": "798153fcb329902fe6302a31fa5767065056575977f8972e3507becb45e6e0e4", + "size": 396671, + "subdir": "linux-64", + "timestamp": 1513307105807, + "version": "3.1.4" + }, + "conda-build-3.1.4-py35h2f9c1c0_0.conda": { + "build": "py35h2f9c1c0_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a617a2b571a1c9e12171a422cb86f81e", + "name": "conda-build", + "sha256": "fe4365cba77a5a57b6ee2fd3ff2080aa5a271dd16fbe428c1fd526d6119cf734", + "size": 401581, + "subdir": "linux-64", + "timestamp": 1513307146217, + "version": "3.1.4" + }, + "conda-build-3.1.4-py36h2f9c1c0_0.conda": { + "build": "py36h2f9c1c0_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5a5cd32c261042805136f995f02f8a38", + "name": "conda-build", + "sha256": "0e192f187578acc2e8baf4361d521ada05b32a9ac225ef355d563802ed2b10ee", + "size": 396896, + "subdir": "linux-64", + "timestamp": 1513307159935, + "version": "3.1.4" + }, + "conda-build-3.1.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8d796d4a8985a25b7c5e3e183d7ccb0c", + "name": "conda-build", + "sha256": "48c7886e2878d3e9c380bd91738b477f735a84918e745398198993838653ccd2", + "size": 396802, + "subdir": "linux-64", + "timestamp": 1513358799189, + "version": "3.1.5" + }, + "conda-build-3.1.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5eb5e39517af821b0fd7e95da2651d5d", + "name": "conda-build", + "sha256": "081f1dfb9ff18f1c99823f2a96fd1fedefcbc9112eb30f1aab3afed884a0420c", + "size": 398350, + "subdir": "linux-64", + "timestamp": 1513358804677, + "version": "3.1.5" + }, + "conda-build-3.1.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "287b43607246dc36d87f60c0eabaed31", + "name": "conda-build", + "sha256": "d5ac04f57b3c794889954c4e0f1725e6d38bdffe3e85d151b082e1ac7f73ac94", + "size": 397135, + "subdir": "linux-64", + "timestamp": 1513358780636, + "version": "3.1.5" + }, + "conda-build-3.1.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8fed089bada5257989d0a465fd895e71", + "name": "conda-build", + "sha256": "3a21374f2fe5e75b2d8de79c493f53af37f22f43b5d664c13ec03b994b8ba209", + "size": 397128, + "subdir": "linux-64", + "timestamp": 1513378876982, + "version": "3.1.6" + }, + "conda-build-3.1.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5ad2f8415c32dce48fd634eb63917d9c", + "name": "conda-build", + "sha256": "83acd0bd1edbf940579d441602258ae877e3c4c5fe8f6c91723d2bd2003b2eba", + "size": 401162, + "subdir": "linux-64", + "timestamp": 1513378887150, + "version": "3.1.6" + }, + "conda-build-3.1.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e33bae2a90da9614907a38c396556845", + "name": "conda-build", + "sha256": "8fe960b869e5c39bb486f19e5efa91126274cdedee6e9a117b92dfcbe7da4dbd", + "size": 394173, + "subdir": "linux-64", + "timestamp": 1513378886639, + "version": "3.1.6" + }, + "conda-build-3.10.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4c347796a1ace1d0f05efe503a92136e", + "name": "conda-build", + "sha256": "c9723ace8676a6a98c72c1155fae79b61f1c2cf96211a2da26c4046d5eab28de", + "size": 427971, + "subdir": "linux-64", + "timestamp": 1525183655487, + "version": "3.10.0" + }, + "conda-build-3.10.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "55cef9e3d0a94db1b7aba7e133fc6485", + "name": "conda-build", + "sha256": "66c548dae1219597441ee179ee633ecde6e03b10ecd1a10dfea1cc8c78ccc58d", + "size": 433314, + "subdir": "linux-64", + "timestamp": 1525183680844, + "version": "3.10.0" + }, + "conda-build-3.10.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "65bf8d06ac995a0fd1b476f1c9949eaa", + "name": "conda-build", + "sha256": "5fdb378591413126f1560c48c43dc890dab5e46a630c5358e9bf13f6cd67ba90", + "size": 429228, + "subdir": "linux-64", + "timestamp": 1525183677072, + "version": "3.10.0" + }, + "conda-build-3.10.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ddb74f8b25576ad78252271d5be2f951", + "name": "conda-build", + "sha256": "8cde8c05aac0290fbc255935cfd4fecb379b1f333794fe0cb735c976ada71cf3", + "size": 428193, + "subdir": "linux-64", + "timestamp": 1525209201678, + "version": "3.10.1" + }, + "conda-build-3.10.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3582c84083bbefbd698c546423f40b8e", + "name": "conda-build", + "sha256": "6cf0ccfee01dbcb41e135d9975bc707c92cbf96f6e1326c765e9f8a8bf3b81cb", + "size": 430074, + "subdir": "linux-64", + "timestamp": 1525209215113, + "version": "3.10.1" + }, + "conda-build-3.10.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3289b14b5658722a5549f17a92d2fef5", + "name": "conda-build", + "sha256": "4b57024ea2888805536919029b748931878f07b6c42f6ec4aa7812eae84cc5e7", + "size": 429760, + "subdir": "linux-64", + "timestamp": 1525209251831, + "version": "3.10.1" + }, + "conda-build-3.10.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0082505cad98b1f9280ea952775eb706", + "name": "conda-build", + "sha256": "afc11aa3cc83d61518fe2b5db2c8a2933c4d956e306b8ce8ba9e1b76ade4390d", + "size": 429052, + "subdir": "linux-64", + "timestamp": 1525818018886, + "version": "3.10.2" + }, + "conda-build-3.10.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "419dcd012a38ba356515f24c01217b9f", + "name": "conda-build", + "sha256": "77a04d90e5a1e5ae279088d1cf07b838adac602700f22e79d45bfb05f12ecfea", + "size": 430883, + "subdir": "linux-64", + "timestamp": 1525818085109, + "version": "3.10.2" + }, + "conda-build-3.10.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e46b5df8756b05384d11dd61b7f7cf61", + "name": "conda-build", + "sha256": "80bc32fd094c5adbc3cedb7ffa44b925c9827c742c84fb560302c4dfcee7d0ef", + "size": 425820, + "subdir": "linux-64", + "timestamp": 1525818085489, + "version": "3.10.2" + }, + "conda-build-3.10.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a1cbbac1e9d399ec1c4160e740681405", + "name": "conda-build", + "sha256": "6a7f034f5583e4a8f696d0929d8e67070fdcb2b832c44be71e30d14b47c7dcb0", + "size": 429814, + "subdir": "linux-64", + "timestamp": 1526584916225, + "version": "3.10.3" + }, + "conda-build-3.10.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c24c00cc460c524c2e95882563ef7023", + "name": "conda-build", + "sha256": "3b3d28eb5892b049e19ff8a8e9635193860f447030f3e7d50f81abcae781042e", + "size": 435090, + "subdir": "linux-64", + "timestamp": 1526584942406, + "version": "3.10.3" + }, + "conda-build-3.10.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b91f2e1e9759942f6c232702e4b15a1b", + "name": "conda-build", + "sha256": "7b1105f2ddf26b49c377ccdf8aa0adb087fbe058d2794f34344dac6c84c7c76e", + "size": 430676, + "subdir": "linux-64", + "timestamp": 1526584913108, + "version": "3.10.3" + }, + "conda-build-3.10.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7aaf8d0af23e992bab04aeb6552b761c", + "name": "conda-build", + "sha256": "b26035285e1358582153cb22c7368fa37512f79f90d43ac4c0411e35f7e87255", + "size": 433070, + "subdir": "linux-64", + "timestamp": 1526827648866, + "version": "3.10.4" + }, + "conda-build-3.10.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "23a0ce5ecd6bc8ef49c1d75c4de765ba", + "name": "conda-build", + "sha256": "34444979d17345ced2f81ed22cfb68f7cabf9a463f067e756892b512395db416", + "size": 431449, + "subdir": "linux-64", + "timestamp": 1526827682500, + "version": "3.10.4" + }, + "conda-build-3.10.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8199140d5029b105a232e24675658200", + "name": "conda-build", + "sha256": "34722f98ec56b0a944cc07b403db71d04552bbfc1df8486d41437c7d26c1f255", + "size": 430801, + "subdir": "linux-64", + "timestamp": 1526827648501, + "version": "3.10.4" + }, + "conda-build-3.10.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a89cfa7269e5869e114ca65af9e73e78", + "name": "conda-build", + "sha256": "fc7fbe2d6e779abb04cae40d1156caf37fa9e945e9ad32b9f414beb658500ec8", + "size": 433495, + "subdir": "linux-64", + "timestamp": 1527098088971, + "version": "3.10.5" + }, + "conda-build-3.10.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e385163ad1262501293abb2344715705", + "name": "conda-build", + "sha256": "cec306efb9f542519e0dfec8cb4e8bf83165f91c37cef1fd9811301f8fe41054", + "size": 432155, + "subdir": "linux-64", + "timestamp": 1527098110400, + "version": "3.10.5" + }, + "conda-build-3.10.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4b97a472d41eebf2230951afcde12a71", + "name": "conda-build", + "sha256": "04370a3cac9d44ff1c903860ef2c5df08e249099e96f0338b222bc978b03b95b", + "size": 426892, + "subdir": "linux-64", + "timestamp": 1527098086468, + "version": "3.10.5" + }, + "conda-build-3.10.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0340ac1033931f0b56b4ab624a927736", + "name": "conda-build", + "sha256": "d2a80d27db52099896e770699a42d07e31965ec3d837beeb78d6f21f4de669e1", + "size": 434292, + "subdir": "linux-64", + "timestamp": 1527826079738, + "version": "3.10.6" + }, + "conda-build-3.10.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d950b54b6190912628cd5d97a6adff6e", + "name": "conda-build", + "sha256": "b73b5c8d20fbfcfe77aa77a86655739faa57314f695bd63d817d45d78c956935", + "size": 436429, + "subdir": "linux-64", + "timestamp": 1527826121147, + "version": "3.10.6" + }, + "conda-build-3.10.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6f9e26c33a6002be0382bdbab98b2345", + "name": "conda-build", + "sha256": "c6074b75fdfd6a99caad8995d7bf6f8a4cd1a7612136a96492be49c21de74482", + "size": 427958, + "subdir": "linux-64", + "timestamp": 1527826076779, + "version": "3.10.6" + }, + "conda-build-3.10.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "77dddc9d2d0cf61d2fc8d7c3c813fc97", + "name": "conda-build", + "sha256": "1b7816a1633c1ac80aea9bc0f90631e41b6103f47be8e57ac5d64c07596fd377", + "size": 434967, + "subdir": "linux-64", + "timestamp": 1527907070076, + "version": "3.10.7" + }, + "conda-build-3.10.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d2e357c8a6f45126e34aa025d9654fbd", + "name": "conda-build", + "sha256": "42ed874b4b1c995cbe5720804a795bfbad21158b80a8098d781cf5f140b98587", + "size": 433164, + "subdir": "linux-64", + "timestamp": 1527907094524, + "version": "3.10.7" + }, + "conda-build-3.10.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9b8f4a33fe2ed8ecebfd67f280371cc7", + "name": "conda-build", + "sha256": "f2e576cefd035b8bb013dfabece22731623c2936c90e191ef3ccecd08cebe4eb", + "size": 428422, + "subdir": "linux-64", + "timestamp": 1527907078069, + "version": "3.10.7" + }, + "conda-build-3.10.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "05a17a1686656ad647613f080e89ce61", + "name": "conda-build", + "sha256": "fd1910948c0aced032e182985501458df3bfdc24740bed5010d1be4b554f6757", + "size": 435059, + "subdir": "linux-64", + "timestamp": 1528812761733, + "version": "3.10.8" + }, + "conda-build-3.10.8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0fed9218da3c86588d6f4d081d893946", + "name": "conda-build", + "sha256": "7f9a8dcc642065d9a2124b4f571f226520d79303ab9763bc9a0ca9ccd8612a35", + "size": 437076, + "subdir": "linux-64", + "timestamp": 1528812803858, + "version": "3.10.8" + }, + "conda-build-3.10.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6bbd60158aee8750cec4849eddc6718b", + "name": "conda-build", + "sha256": "0b34c3df090fcdef1e3773ea8161d9286595823e32f820818e133e4c44abd8f6", + "size": 432416, + "subdir": "linux-64", + "timestamp": 1528812744683, + "version": "3.10.8" + }, + "conda-build-3.10.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d09a837b724198b3cfcb6ba16b5997cf", + "name": "conda-build", + "sha256": "813789d8947647fd6290718a0d112e2cb2a8fdef7f1d0536a58d924dbb0d4861", + "size": 431464, + "subdir": "linux-64", + "timestamp": 1529089652595, + "version": "3.10.9" + }, + "conda-build-3.10.9-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "324bf85b4a581655510f459757789f11", + "name": "conda-build", + "sha256": "01e0556d3f32f6b49aaabdae829e7165092b2804dd0038e003e2f8f7d4cf539f", + "size": 437028, + "subdir": "linux-64", + "timestamp": 1529089674706, + "version": "3.10.9" + }, + "conda-build-3.10.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cc2a784640df79a515e02fc83c8e5fcd", + "name": "conda-build", + "sha256": "4c170bebfd70230a141a40405a5eace0796f38ed385791c67d7ab097b7030842", + "size": 428489, + "subdir": "linux-64", + "timestamp": 1529089660668, + "version": "3.10.9" + }, + "conda-build-3.10.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4e73c4341fb44fea7861b430abb5bc24", + "name": "conda-build", + "sha256": "9a4eab2a3451473b5f33799f777565464c9fd2088ca1ac21ae3d940d5715f920", + "size": 431982, + "subdir": "linux-64", + "timestamp": 1530813751494, + "version": "3.10.9" + }, + "conda-build-3.11.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "30a398ee2d13745dc5340e92a68d52ac", + "name": "conda-build", + "sha256": "c99542191e7db4edf4faf3b29607001e7a7b527e3a36960a826fd60df59dbb6e", + "size": 434067, + "subdir": "linux-64", + "timestamp": 1532137821471, + "version": "3.11.0" + }, + "conda-build-3.11.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "168942e17016d34dec00fbc18a027c99", + "name": "conda-build", + "sha256": "68205c875d2bc4a5f8b615964bd9a039ec9312043616777520e6e27e3b2b7f73", + "size": 435177, + "subdir": "linux-64", + "timestamp": 1532137846504, + "version": "3.11.0" + }, + "conda-build-3.11.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d1929ff64796ea9ebed8f415f9e07ae8", + "name": "conda-build", + "sha256": "9344abcca1250ea3fc51a56215b7bbcf25ed562de8b7cbbba7277c5b1f2a7426", + "size": 434635, + "subdir": "linux-64", + "timestamp": 1532137774703, + "version": "3.11.0" + }, + "conda-build-3.12.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "320585b86e04c392fd00874d3e15ac12", + "name": "conda-build", + "sha256": "5c5d2702e19c8b35b26323a7eb8bbc80ba9c382b893a1eb592ae5302cc0cbcbe", + "size": 437425, + "subdir": "linux-64", + "timestamp": 1532477204233, + "version": "3.12.0" + }, + "conda-build-3.12.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7bfcee4acde34e79d4c092e0b3b43f1b", + "name": "conda-build", + "sha256": "3d249eaddb9c6c74787c673e19921f233adcd4435661c9ea12e56d49b9893610", + "size": 436383, + "subdir": "linux-64", + "timestamp": 1532477257075, + "version": "3.12.0" + }, + "conda-build-3.12.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a34075a58fcc5590215bb7605c85b014", + "name": "conda-build", + "sha256": "3dbd293214eecf75a193a46d4504b0cda1c91f55c5fb66a0d0cac3351fb2d930", + "size": 431459, + "subdir": "linux-64", + "timestamp": 1532477257894, + "version": "3.12.0" + }, + "conda-build-3.12.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "099e578c098dfa7d27213bffca7593a5", + "name": "conda-build", + "sha256": "ab157ad1e540ea857bd2919b4e69ca7f90803b4b80f64e7214157438e61d224f", + "size": 434905, + "subdir": "linux-64", + "timestamp": 1532477266496, + "version": "3.12.0" + }, + "conda-build-3.12.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "991e136aa31a48bf8e613367239e7a42", + "name": "conda-build", + "sha256": "01b95eeb63d89d3bbb6ae69db84206c2ba4503483cdbc55c8132901d503e4cb1", + "size": 437672, + "subdir": "linux-64", + "timestamp": 1533582542454, + "version": "3.12.1" + }, + "conda-build-3.12.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b922bb0d660f2cca486b32c1962b7a18", + "name": "conda-build", + "sha256": "daa0949a156202c1f514d30a167e47dbbbc441ddb315a327e0352636fd78db3e", + "size": 440345, + "subdir": "linux-64", + "timestamp": 1533582573378, + "version": "3.12.1" + }, + "conda-build-3.12.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7dda5f3845c2a8eab81d05235d52c102", + "name": "conda-build", + "sha256": "e1ee763a2c7caf0c7cbf52492597eea2d281a88ecb5f4370548482e986822fa4", + "size": 431529, + "subdir": "linux-64", + "timestamp": 1533582516741, + "version": "3.12.1" + }, + "conda-build-3.12.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b49b5fa865b702522900c11e5d14b0f4", + "name": "conda-build", + "sha256": "c5e235823fc5426d8d48d283f3ac9ec6272ec2b27cb4bdf4aa93c3a330400a95", + "size": 435095, + "subdir": "linux-64", + "timestamp": 1533582575039, + "version": "3.12.1" + }, + "conda-build-3.13.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5b88640654082bfe40507808ba901f9c", + "name": "conda-build", + "sha256": "1b0cd2c7a4fe32157f26edf1f14a28f3c33f9706f3065e19235a677115776d00", + "size": 435799, + "subdir": "linux-64", + "timestamp": 1534804626457, + "version": "3.13.0" + }, + "conda-build-3.13.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "554d15bad43ff6ec2110ec73e435271f", + "name": "conda-build", + "sha256": "8eb22728a62541fa93818fa495e21e28ab350b4baae69b546e1e18122a5f0545", + "size": 437789, + "subdir": "linux-64", + "timestamp": 1534804699903, + "version": "3.13.0" + }, + "conda-build-3.13.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d959cec2d92c86effe7ed09ef95f53ca", + "name": "conda-build", + "sha256": "1242021b87e9bb230cd46a53200b1a876cfa23f3d2c050b273d3241901598ee2", + "size": 436757, + "subdir": "linux-64", + "timestamp": 1534804576717, + "version": "3.13.0" + }, + "conda-build-3.13.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "85205028952c13423d04a4aac68a47f7", + "name": "conda-build", + "sha256": "53e40dfe9df1310ef188f2a2829593d0992199c990599dd7db5ac85962ce0f8b", + "size": 436395, + "subdir": "linux-64", + "timestamp": 1534804703569, + "version": "3.13.0" + }, + "conda-build-3.14.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ad13ed6f3559816a62c7cd482ce6e6d7", + "name": "conda-build", + "sha256": "1c9221f02d27c6f8f3892bdf6b7fb8fdc4baa9fbbc740971b8c40b35a59ddb81", + "size": 450218, + "subdir": "linux-64", + "timestamp": 1536106586343, + "version": "3.14.0" + }, + "conda-build-3.14.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pytz", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ff780158c8a986268401162c2d12e362", + "name": "conda-build", + "sha256": "69c24d35cfa97b6819a649308f2b41ceaa80862c9c876d153faf6d70258d9d4b", + "size": 455979, + "subdir": "linux-64", + "timestamp": 1536106606734, + "version": "3.14.0" + }, + "conda-build-3.14.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8e148529f6747d791a441d540fa2c0e9", + "name": "conda-build", + "sha256": "1f53c283933a9b7a8f20b2469bb075e19e2f12448152879076171e661fb93b98", + "size": 447267, + "subdir": "linux-64", + "timestamp": 1536106562091, + "version": "3.14.0" + }, + "conda-build-3.14.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "61a9fdc778b357573baf84ed2880c8d2", + "name": "conda-build", + "sha256": "daaa19d42462b907088a2750c077d9bafe140bfa4724a5135e67f52fbe69e7c6", + "size": 450145, + "subdir": "linux-64", + "timestamp": 1536106615424, + "version": "3.14.0" + }, + "conda-build-3.14.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "29f2f8294a5e6bc0ce717de4cd2dd8d2", + "name": "conda-build", + "sha256": "11a6191f532ab27be14028cfb4e421ee309dec9fc8d89e83960fa72fd72ab9e1", + "size": 453060, + "subdir": "linux-64", + "timestamp": 1536257498627, + "version": "3.14.1" + }, + "conda-build-3.14.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pytz", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "18c34218413d294805b64e592953c5b9", + "name": "conda-build", + "sha256": "db7ba8bec3cb83c8de1b8a6713e59399dc79558dc2b45c263c255d049eb7b5e4", + "size": 456168, + "subdir": "linux-64", + "timestamp": 1536257521282, + "version": "3.14.1" + }, + "conda-build-3.14.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "71c8d4863a93a420fc8a6bdf656fbcc0", + "name": "conda-build", + "sha256": "6aaa448fffff882546f8604a01afc64a9d23a30a3716145386f972681e3ab474", + "size": 450537, + "subdir": "linux-64", + "timestamp": 1536257477848, + "version": "3.14.1" + }, + "conda-build-3.14.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1cba99de7e6cbefd9d01dd1ca510958b", + "name": "conda-build", + "sha256": "705ec709b8f15a16e6083499744a83dabdc7326144e30488d87c4d35f37bef8d", + "size": 450346, + "subdir": "linux-64", + "timestamp": 1536257559170, + "version": "3.14.1" + }, + "conda-build-3.14.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "54f6e20744c376c8f6cc409e4c7039cc", + "name": "conda-build", + "sha256": "39636804c5631b9d2500810fcd5c1e21f4296d5928336266774b3b80d8d2c2ec", + "size": 462880, + "subdir": "linux-64", + "timestamp": 1536358405292, + "version": "3.14.2" + }, + "conda-build-3.14.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pytz", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "924f05cddb251a7a3f4271b2ff48c631", + "name": "conda-build", + "sha256": "cdf1ca596fc0a887af4f21a9bc9ecdf2a21fe0bce06386b10068e999a63d73d3", + "size": 462381, + "subdir": "linux-64", + "timestamp": 1536358407107, + "version": "3.14.2" + }, + "conda-build-3.14.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f4027b092de4759cb7af4541449f19a8", + "name": "conda-build", + "sha256": "8b640dac09e20b4c2038e6681e337aa5bdb615a91587f5717c50a5496c291843", + "size": 457257, + "subdir": "linux-64", + "timestamp": 1536358446931, + "version": "3.14.2" + }, + "conda-build-3.14.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1713005359b505c06fdc6034c14be4d4", + "name": "conda-build", + "sha256": "5cad3ce1480ba3dd4530213e345da2c614fa60031aef5325481bd4d679a2385e", + "size": 460105, + "subdir": "linux-64", + "timestamp": 1536358365791, + "version": "3.14.2" + }, + "conda-build-3.14.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a2133e51cbaf4627f17f43d6ad29446f", + "name": "conda-build", + "sha256": "432ed9146efd9114025b17a360f94fcf39c82b454a729a83d710721f50f658ad", + "size": 451644, + "subdir": "linux-64", + "timestamp": 1536688067330, + "version": "3.14.4" + }, + "conda-build-3.14.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f47e2f5ffcadd9f4ab99d4cd00fe54c1", + "name": "conda-build", + "sha256": "0949cd4b1af9f52b4b15163b2b95cc4876016eb54a3b61c3315d42f66f7ee04e", + "size": 457335, + "subdir": "linux-64", + "timestamp": 1536688097982, + "version": "3.14.4" + }, + "conda-build-3.14.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b0b88f913aeaa7986d960c40fd94cc38", + "name": "conda-build", + "sha256": "b6b676190f1af25c10c6b44babb95cac6399ed02c8dca7eb12d4e938c1da4af7", + "size": 452269, + "subdir": "linux-64", + "timestamp": 1536688087562, + "version": "3.14.4" + }, + "conda-build-3.14.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6aea33043d3164acc191c076deb04554", + "name": "conda-build", + "sha256": "4d470057830d84e6edfda51b1f29b8f452e116d2d7dd478eae69c68accc90e50", + "size": 448290, + "subdir": "linux-64", + "timestamp": 1536688047809, + "version": "3.14.4" + }, + "conda-build-3.15.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0466fcb1c7279cf52ad6aa8505b3dbf9", + "name": "conda-build", + "sha256": "467b0751d34abb3ffc1e47c17f8c8c8bb4d19e36631b93ef00578aa8e47313d7", + "size": 457924, + "subdir": "linux-64", + "timestamp": 1537238077061, + "version": "3.15.0" + }, + "conda-build-3.15.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1379e65c500e39a5f8e143dcf0fbe1d4", + "name": "conda-build", + "sha256": "3cc0a627dad18b9a42d11331198f804b246d1d0abc6171845b5b015cd11eb327", + "size": 459928, + "subdir": "linux-64", + "timestamp": 1537238094065, + "version": "3.15.0" + }, + "conda-build-3.15.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cce7fac13fb5e8cf5b271bba948b0e7a", + "name": "conda-build", + "sha256": "7875e4715f1e1c43772042542414c15244e199cf2cf167612b7ceedf3cb50036", + "size": 457945, + "subdir": "linux-64", + "timestamp": 1537238102038, + "version": "3.15.0" + }, + "conda-build-3.15.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d9f66ce0fa8c7e415c4f0298e9dcf1c0", + "name": "conda-build", + "sha256": "d979aa10030d7f35485c9da5e34c870d4b3475ac8d5ceef94f50a04f289df094", + "size": 457759, + "subdir": "linux-64", + "timestamp": 1537238063621, + "version": "3.15.0" + }, + "conda-build-3.15.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5852d347c38569baac46f2621e868700", + "name": "conda-build", + "sha256": "097d3d75d1b712eff2989cdc6847d00edd59a83e29615f3972e0f7fbac1a0c89", + "size": 457417, + "subdir": "linux-64", + "timestamp": 1537289922402, + "version": "3.15.1" + }, + "conda-build-3.15.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ccc00354f4a5b3385a706c201cc3af5e", + "name": "conda-build", + "sha256": "3fa104ad9c96378361007c3da8c3c4188c59192a026f9498bb586c545bf10fe4", + "size": 463279, + "subdir": "linux-64", + "timestamp": 1537289946616, + "version": "3.15.1" + }, + "conda-build-3.15.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5fe52a5ec7c812deddcb36bd0f1025fd", + "name": "conda-build", + "sha256": "aa777344ab48ae1257cbd847571089c545167c5d37078d7320b135c3f103479b", + "size": 457914, + "subdir": "linux-64", + "timestamp": 1537289950076, + "version": "3.15.1" + }, + "conda-build-3.15.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e95e0b37412a45efb3037433e4b4f28b", + "name": "conda-build", + "sha256": "cc08de41e878d9628852e65412dd4d4f856b86f0d7572dfce53b889cfed7f64c", + "size": 457535, + "subdir": "linux-64", + "timestamp": 1537289907866, + "version": "3.15.1" + }, + "conda-build-3.16.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7af3834cde6f19123dbcb51d77f28cda", + "name": "conda-build", + "sha256": "a85ad2699e384f1c60308c6baffb77425bdd7111c3832e6dd51db2a06af32dd4", + "size": 467979, + "subdir": "linux-64", + "timestamp": 1538760246080, + "version": "3.16.0" + }, + "conda-build-3.16.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bebcd71269293068ddbfea986cd10abf", + "name": "conda-build", + "sha256": "0739837e79ff2a3ff7c3e6313d635747c2a31ed218c55dbbcdf2c1e7e2440264", + "size": 465068, + "subdir": "linux-64", + "timestamp": 1538760328287, + "version": "3.16.0" + }, + "conda-build-3.16.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "42137472185052586a0e37960f69729e", + "name": "conda-build", + "sha256": "c65c3e1c7746c1fc44757856983c18baa5f913fca086f6ebafdeee9b9141f8a1", + "size": 468217, + "subdir": "linux-64", + "timestamp": 1538760386964, + "version": "3.16.0" + }, + "conda-build-3.16.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2efe40467cc895f015c4d487e9630d91", + "name": "conda-build", + "sha256": "66a61686231ce5f5fa1d0fa97d8675f896fbb8a718b4a5ee354d643ea7d4ccea", + "size": 472465, + "subdir": "linux-64", + "timestamp": 1539369908715, + "version": "3.16.1" + }, + "conda-build-3.16.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cba59ff059742bf9df92070dee5b8b35", + "name": "conda-build", + "sha256": "309afd21d2dbf5993e839c93110140d1241767e9e8eb6d80a49471b23dcfb828", + "size": 469876, + "subdir": "linux-64", + "timestamp": 1539369581775, + "version": "3.16.1" + }, + "conda-build-3.16.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c93418c60092031eb4cf9758d97b9179", + "name": "conda-build", + "sha256": "35f0d7e1fbb8a844916f6bafb430beaea1265619779a06ef5d54820ad07b3064", + "size": 469585, + "subdir": "linux-64", + "timestamp": 1539369913621, + "version": "3.16.1" + }, + "conda-build-3.16.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8be8871c9515a953ef872ac09f956f10", + "name": "conda-build", + "sha256": "5728890d5beb93bf890ec84c301e28d7496bfd60bd5b167d7da17220a5a141d9", + "size": 470522, + "subdir": "linux-64", + "timestamp": 1540853947173, + "version": "3.16.2" + }, + "conda-build-3.16.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "907ed1265e8f66418b8ab7b226f6637b", + "name": "conda-build", + "sha256": "1bd4e1660464e758ab78628ad2745ce979339ccecaedaa778033d6bdeaa56787", + "size": 470947, + "subdir": "linux-64", + "timestamp": 1540854021139, + "version": "3.16.2" + }, + "conda-build-3.16.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "407a266412e36d7ed39b68c79d385a68", + "name": "conda-build", + "sha256": "3766cca3e42187f1c8f239975ce970bce4a762de65258cd15c18a6159e8b8473", + "size": 467277, + "subdir": "linux-64", + "timestamp": 1540853961580, + "version": "3.16.2" + }, + "conda-build-3.16.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cad63df70e7b8d00893af93fc56300cf", + "name": "conda-build", + "sha256": "fd2c429d00dc115b39e5a0bd1bc0754ae187d1c6a6b7ab1c459eeaa8d66b27a9", + "size": 476004, + "subdir": "linux-64", + "timestamp": 1542851057581, + "version": "3.16.3" + }, + "conda-build-3.16.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e0e4f9c1bbb343fceff2f3670f24e4a3", + "name": "conda-build", + "sha256": "fa2c30f9b7de5128ea1c2160e8beb799e10451293e5fc42adc35feb127623f4e", + "size": 470011, + "subdir": "linux-64", + "timestamp": 1542851073148, + "version": "3.16.3" + }, + "conda-build-3.16.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dc3d6e12ebfbd535f563f51a015e548d", + "name": "conda-build", + "sha256": "8e299efeff38f58e453c7692273272001358d7288c733c994dae65b5e1d1b10d", + "size": 473176, + "subdir": "linux-64", + "timestamp": 1542851021169, + "version": "3.16.3" + }, + "conda-build-3.17.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "79a57513f72992c89526450cec2c4e12", + "name": "conda-build", + "sha256": "d003c178cdb9e37c62ee024c0ae8153cce924753e7906e1d9212179ef625177d", + "size": 495697, + "subdir": "linux-64", + "timestamp": 1543629277104, + "version": "3.17.0" + }, + "conda-build-3.17.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cd0f75ea04b67f05902f1c919a8b1428", + "name": "conda-build", + "sha256": "1d2871d321b0c951c41f27400db4e34eaa0a6685d3bd6eb334c960c567e76b85", + "size": 496063, + "subdir": "linux-64", + "timestamp": 1543629335893, + "version": "3.17.0" + }, + "conda-build-3.17.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "52fed6db37455e01737881bbd81a6518", + "name": "conda-build", + "sha256": "d63894c4a738d8ae1d9e4e811b9928424447c45025affec4ffa4d814704eec51", + "size": 495574, + "subdir": "linux-64", + "timestamp": 1543629259179, + "version": "3.17.0" + }, + "conda-build-3.17.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d701b843357039540809b33270ff667d", + "name": "conda-build", + "sha256": "345065ac229f24b754a16672e2f5e57bb82a7795e25bbaa8ad287daadda90f4b", + "size": 499210, + "subdir": "linux-64", + "timestamp": 1543944593997, + "version": "3.17.1" + }, + "conda-build-3.17.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d1a692218e150921cd071b54d9b9046e", + "name": "conda-build", + "sha256": "9d038f9f692f35b54b092ce237c6ab9b0f3e8f38f91ff4301111ad774351a8c9", + "size": 492589, + "subdir": "linux-64", + "timestamp": 1543944637695, + "version": "3.17.1" + }, + "conda-build-3.17.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bdc8459cad567f4d5508fcf0343cfa17", + "name": "conda-build", + "sha256": "e6e4cddd9915e7ff235eb268cf236de0793fcd8454e234554a523c0793eb780b", + "size": 492170, + "subdir": "linux-64", + "timestamp": 1543944601943, + "version": "3.17.1" + }, + "conda-build-3.17.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5cacaf2719d3da057e3e088bf327478e", + "name": "conda-build", + "sha256": "2cff8db72bfcd511500bf21257f8918b9044c33ee2c8b6193566c909a63de045", + "size": 500533, + "subdir": "linux-64", + "timestamp": 1544565187156, + "version": "3.17.3" + }, + "conda-build-3.17.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b5e6cd5b1ba71e73acb904be968d4115", + "name": "conda-build", + "sha256": "4d674a1ad12c1aba3142c824591dd695042524fc51bb8429d7d3b70c9c71947c", + "size": 493767, + "subdir": "linux-64", + "timestamp": 1544565222774, + "version": "3.17.3" + }, + "conda-build-3.17.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1d3c735f07ca607a72362f50e276e843", + "name": "conda-build", + "sha256": "75535779859139061c5a7c16afe29717eeeec54df16b1817dad1c26d74df108e", + "size": 496990, + "subdir": "linux-64", + "timestamp": 1544565150647, + "version": "3.17.3" + }, + "conda-build-3.17.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c4431862c65d9d8a52c1a36086152d02", + "name": "conda-build", + "sha256": "c0758c19c5fc7275a1fc09ebb13dc32bf29cb7b578de4312cd58b33ccad39ac3", + "size": 497503, + "subdir": "linux-64", + "timestamp": 1544668356577, + "version": "3.17.4" + }, + "conda-build-3.17.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bab7467b2b048546f4b86851c7bcda2a", + "name": "conda-build", + "sha256": "71ac1dc601781ae498cb41905c852b2a67c9d9b4f0965e074d5d1fff0e4fbf55", + "size": 493816, + "subdir": "linux-64", + "timestamp": 1544668401888, + "version": "3.17.4" + }, + "conda-build-3.17.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d3b442fec376a5196e8dab1f78aad2e5", + "name": "conda-build", + "sha256": "a52b1ba5751fa9c29abc26279adb7dd03a8e0bccd47fd2007365b047a088525f", + "size": 493338, + "subdir": "linux-64", + "timestamp": 1544668354314, + "version": "3.17.4" + }, + "conda-build-3.17.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c24d9f664b824b8ea03793d5567b6588", + "name": "conda-build", + "sha256": "66bad506740a24e375085b08486d1be694908976e59a150345a86cb547499926", + "size": 500822, + "subdir": "linux-64", + "timestamp": 1544807607455, + "version": "3.17.5" + }, + "conda-build-3.17.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "faff48d1b4400f5d72a2033d6d9ed224", + "name": "conda-build", + "sha256": "3c14e81125a8fdd5936ee9be08e9efac284d0377a025ad74206b7e2581893cf2", + "size": 497854, + "subdir": "linux-64", + "timestamp": 1544807667128, + "version": "3.17.5" + }, + "conda-build-3.17.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4b48bd34a871f42d392b8d1cb2da1820", + "name": "conda-build", + "sha256": "9a19f9afc0bac46f914d3954eb7eed9e9dc435a33eab9fc99bd006e465950c89", + "size": 497232, + "subdir": "linux-64", + "timestamp": 1544807607966, + "version": "3.17.5" + }, + "conda-build-3.17.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6a6f6e96332ba403d6538334effe2f51", + "name": "conda-build", + "sha256": "70f22ab958b714efbfffc4254420f641d19ba7ea9f8e82a0d0f649105e91ef00", + "size": 497491, + "subdir": "linux-64", + "timestamp": 1545270081220, + "version": "3.17.6" + }, + "conda-build-3.17.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7f805f341c47c8ae19e90888c03bc4d5", + "name": "conda-build", + "sha256": "9ef825c2e13bfdbdd198836ac50ffc983a988c1eeba69f3bdbe002415897621b", + "size": 497827, + "subdir": "linux-64", + "timestamp": 1545270104521, + "version": "3.17.6" + }, + "conda-build-3.17.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "727ad8b5c615179e5c14b95e56ea3605", + "name": "conda-build", + "sha256": "a0615d9f07d729a24b535c66cfa755f3422897bab6d982112bdb1a7bc348375b", + "size": 497200, + "subdir": "linux-64", + "timestamp": 1545270107473, + "version": "3.17.6" + }, + "conda-build-3.17.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cadcea2bf6a22b3d12cb97a09c33c221", + "name": "conda-build", + "sha256": "91178b27c0157b0f1982b051c1332719778b28bfced158cb22a46eaa02918540", + "size": 500918, + "subdir": "linux-64", + "timestamp": 1547669070129, + "version": "3.17.7" + }, + "conda-build-3.17.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6b542c1635edaf43e58aed2350e68941", + "name": "conda-build", + "sha256": "16f619b7368b59a63fa9b9f1fc9a7048212f46cbb3045fa7f35f9a7c278d067e", + "size": 498571, + "subdir": "linux-64", + "timestamp": 1547669145254, + "version": "3.17.7" + }, + "conda-build-3.17.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "libarchive", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "426e04eadcef404d2e934ddf0a32d180", + "name": "conda-build", + "sha256": "31877b47a50a9457a41be96f6bbcdba5a11182a80d055fffb42e9271a909fb75", + "size": 497994, + "subdir": "linux-64", + "timestamp": 1547669138831, + "version": "3.17.7" + }, + "conda-build-3.17.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8d604dd4639fce8eb51256eb35a8ee93", + "name": "conda-build", + "sha256": "20993cfeb408f51d48f9698e6d71446205e80f6fd43a32ce83be66a4121f82c3", + "size": 502496, + "subdir": "linux-64", + "timestamp": 1548701011604, + "version": "3.17.8" + }, + "conda-build-3.17.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ce5f8afe9f632930e7ad124bac4eb550", + "name": "conda-build", + "sha256": "c22e6878978e079728ba447ac6cf306eb484f074c5c5ca127b5a180b79e9c4c8", + "size": 503015, + "subdir": "linux-64", + "timestamp": 1548700999636, + "version": "3.17.8" + }, + "conda-build-3.17.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2ad54fa24d70930697c4e2ef102e0b9e", + "name": "conda-build", + "sha256": "761edde0c9595ec39b97e1064582c68599f531c68cc0f6d465d2020fa6f6dc59", + "size": 498817, + "subdir": "linux-64", + "timestamp": 1548701025033, + "version": "3.17.8" + }, + "conda-build-3.18.10-py27_3.conda": { + "build": "py27_3", + "build_number": 3, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "ripgrep", + "scandir", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eb647f28ba2f38dd7b73dbfe75e6cde0", + "name": "conda-build", + "sha256": "85a22257157906fd4d7beb5ba285a993a0897fe3abd6dfaa91e20631c8ce2261", + "size": 525039, + "subdir": "linux-64", + "timestamp": 1571074614243, + "version": "3.18.10" + }, + "conda-build-3.18.10-py36_3.conda": { + "build": "py36_3", + "build_number": 3, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4cde1fdae79b6338b6bb5af3366d1d48", + "name": "conda-build", + "sha256": "02faed3c40b74f9e3b810912b63216ddbbe448fe326ed11d30f5f697d12a670f", + "size": 521814, + "subdir": "linux-64", + "timestamp": 1571074612524, + "version": "3.18.10" + }, + "conda-build-3.18.10-py37_3.conda": { + "build": "py37_3", + "build_number": 3, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9f18ba17f62a14105db40b2ac6d2b1ee", + "name": "conda-build", + "sha256": "3d0d2f6bc123ad4f0a140ca7eb762bf365bf29ca943b48e1adc743de7da5d852", + "size": 521909, + "subdir": "linux-64", + "timestamp": 1571074612052, + "version": "3.18.10" + }, + "conda-build-3.18.11-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "scandir", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dba8310d9b352c7796e1a9cd2b538e20", + "name": "conda-build", + "sha256": "8804b8ebfebef272ffb93c0a0f1f74f2a98c100983f4bbdfe784cb8e4b07e82c", + "size": 525934, + "subdir": "linux-64", + "timestamp": 1573068085155, + "version": "3.18.11" + }, + "conda-build-3.18.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c1ca5c5dc04230721958b890cd409a53", + "name": "conda-build", + "sha256": "b5b3b8273e500f7e9df980c4971e4eccfa26f2874ad7a97209a4ed302407618e", + "size": 523119, + "subdir": "linux-64", + "timestamp": 1573068101962, + "version": "3.18.11" + }, + "conda-build-3.18.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "16681542d30c518c13340bc6b27be56c", + "name": "conda-build", + "sha256": "7ff5a0642c1dd75c3b86821dfbdbd67099e208bd31c2dc838b99ac859b4ab008", + "size": 518583, + "subdir": "linux-64", + "timestamp": 1573068218878, + "version": "3.18.11" + }, + "conda-build-3.18.11-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a9e30292eb7dad3457b9e5e3154e9300", + "name": "conda-build", + "sha256": "f4a0143a90e8efc7c2ca65cf1d8c14cfbdfedc3249c56d14c9850983a4b09c2a", + "size": 520009, + "subdir": "linux-64", + "timestamp": 1589919229680, + "version": "3.18.11" + }, + "conda-build-3.18.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6d4bbb9565aea5153283bc50794c2f8c", + "name": "conda-build", + "sha256": "e1d4e56ddb798fcdb24966138b67162e03cb3a8db39d932985b4b54c6574e17b", + "size": 514936, + "subdir": "linux-64", + "timestamp": 1561496296183, + "version": "3.18.5" + }, + "conda-build-3.18.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5a2ea6b333852aef924331437b98397f", + "name": "conda-build", + "sha256": "90ab413eb61a420cc711b6d0ce316a7a4de8c477fdd2c880f7f9ca82e3f73e92", + "size": 511489, + "subdir": "linux-64", + "timestamp": 1561496330680, + "version": "3.18.5" + }, + "conda-build-3.18.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b0ff17c0e18958bf82107a828c9e50d6", + "name": "conda-build", + "sha256": "623dcf911124f5c6a1edea2b91cf3fb026048b6c49b099a26118e68d04d00355", + "size": 511257, + "subdir": "linux-64", + "timestamp": 1561496288540, + "version": "3.18.5" + }, + "conda-build-3.18.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9b7b2d024b4d639d700746ee3016eee9", + "name": "conda-build", + "sha256": "00e18cd6202eec85afd6735d2bf78c5227d4eca817b2acc253abd2106905f851", + "size": 517673, + "subdir": "linux-64", + "timestamp": 1562725154461, + "version": "3.18.7" + }, + "conda-build-3.18.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f3772e7a00b487c1a4a58e23c8011a5d", + "name": "conda-build", + "sha256": "200d172d995b4db0b71abd975b857fcfe1abb7e399c132d00f6c6e4458622a02", + "size": 514706, + "subdir": "linux-64", + "timestamp": 1562725229304, + "version": "3.18.7" + }, + "conda-build-3.18.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "05071dd63c8d0b70c55078786115c65b", + "name": "conda-build", + "sha256": "af349ed84e32eee5a55d2e9a8fcde5ddc8785efc74c4e6f6d033907b75f29d57", + "size": 514554, + "subdir": "linux-64", + "timestamp": 1562725177360, + "version": "3.18.7" + }, + "conda-build-3.18.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "deaf5989bf720902ee759fb9c2da1955", + "name": "conda-build", + "sha256": "1304ea391010c972071721c798a987800e0e619c1fc4bfc04d749b0eb1020bdf", + "size": 517783, + "subdir": "linux-64", + "timestamp": 1563464967674, + "version": "3.18.8" + }, + "conda-build-3.18.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "669736e1dbdf2697ba0bca2b8e40152f", + "name": "conda-build", + "sha256": "40beb9030efc0671fecc41141602e7c36117584cee3ef57ec5eef34e9bec5b81", + "size": 515022, + "subdir": "linux-64", + "timestamp": 1563464983366, + "version": "3.18.8" + }, + "conda-build-3.18.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9d543d6e1eaa5a53acd362cf0cfec47f", + "name": "conda-build", + "sha256": "1bc0b9bbcc412fb6eee9fc2d0dfec5714c32b9af8d5b046e367e8fa9ab890bc4", + "size": 512021, + "subdir": "linux-64", + "timestamp": 1563464946994, + "version": "3.18.8" + }, + "conda-build-3.18.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "scandir", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a8f5d95fe1c7a5078f5fcd81b11bcfd6", + "name": "conda-build", + "sha256": "356c9aa126f66b18744c6c4df02e6630a9be9ced7035baba6f8b0607cd94f9bd", + "size": 518276, + "subdir": "linux-64", + "timestamp": 1563905264317, + "version": "3.18.9" + }, + "conda-build-3.18.9-py27_3.conda": { + "build": "py27_3", + "build_number": 3, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=2.7,<2.8.0a0", + "pytz", + "pyyaml", + "ripgrep", + "scandir", + "setuptools", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7c1b54f7c530950c42d1cdb24e0328b6", + "name": "conda-build", + "sha256": "8214416f5cfc9d2bc9aa13f71e775440658a686ecf3ebd9bdc1adb004790d2d5", + "size": 521619, + "subdir": "linux-64", + "timestamp": 1565627455082, + "version": "3.18.9" + }, + "conda-build-3.18.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6531217b7664089db2e8bc82607b69d8", + "name": "conda-build", + "sha256": "d8f23128bb199f75cf72e76d2d89c0d8a57c1004ac171f565f200d04b22b2905", + "size": 515386, + "subdir": "linux-64", + "timestamp": 1563905270069, + "version": "3.18.9" + }, + "conda-build-3.18.9-py36_3.conda": { + "build": "py36_3", + "build_number": 3, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "pytz", + "pyyaml", + "ripgrep", + "setuptools", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "acfc829716bf04ed44d8a1d48410050d", + "name": "conda-build", + "sha256": "3b86172f9692acaecd863640a6c3e8ccbfd68a1f32c0aa2127d7286bba0d6f62", + "size": 516023, + "subdir": "linux-64", + "timestamp": 1565627494711, + "version": "3.18.9" + }, + "conda-build-3.18.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.1", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ca3493271753f47a23005ac6f1d05813", + "name": "conda-build", + "sha256": "ccc384c49b702d1c0ece9e44f77a6010535e93cf77e746e96114bb85266dd7e4", + "size": 514921, + "subdir": "linux-64", + "timestamp": 1563905257648, + "version": "3.18.9" + }, + "conda-build-3.18.9-py37_3.conda": { + "build": "py37_3", + "build_number": 3, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "pytz", + "pyyaml", + "ripgrep", + "setuptools", + "six", + "tqdm", + "python-libarchive-c" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "80bc242803d0a0b8b16643a2eccfb0dc", + "name": "conda-build", + "sha256": "f5725958d419504785c6f675fa4c0dfe98e244412216850d988658d06a78312e", + "size": 518489, + "subdir": "linux-64", + "timestamp": 1565627330606, + "version": "3.18.9" + }, + "conda-build-3.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8bc0d04d5aae6fe35d37132641ebbb42", + "name": "conda-build", + "sha256": "63dec5a6e60b8dae4cc68147cf1518e293edff0cae1fa322c920f9bb8df1149b", + "size": 400440, + "subdir": "linux-64", + "timestamp": 1513870014011, + "version": "3.2.0" + }, + "conda-build-3.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ec52ec5c14cf6d5ca996bc7dd85f96cb", + "name": "conda-build", + "sha256": "627c8838fb16d845f76d9675d3b2b7fad4598e034fe1890658f1f24f6f50ec0a", + "size": 402683, + "subdir": "linux-64", + "timestamp": 1513870039352, + "version": "3.2.0" + }, + "conda-build-3.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "48a72158e144ccbb011553bbc5d8e1f4", + "name": "conda-build", + "sha256": "65beb28df58b65154eb6f2ec89afcbe0070f3f71ebda830efb21a9a8e30d7443", + "size": 394858, + "subdir": "linux-64", + "timestamp": 1513870055417, + "version": "3.2.0" + }, + "conda-build-3.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c2604215d35f7db8ac9e4deb8cd71846", + "name": "conda-build", + "sha256": "1e7d7619afd18c4e7ea68ca44d6785c7763ffd6c9e6ee3f8e752b47222b304c6", + "size": 401643, + "subdir": "linux-64", + "timestamp": 1514949252983, + "version": "3.2.1" + }, + "conda-build-3.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "20542f10a439ad7cb75af5aa0aaf5092", + "name": "conda-build", + "sha256": "41fefe938c65e2891478b3a0e27bcfde6a415786214f9e1eed3045e1e462c03d", + "size": 403097, + "subdir": "linux-64", + "timestamp": 1514949274781, + "version": "3.2.1" + }, + "conda-build-3.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8434ad6fc40e6730c29bed3a0b2b49e7", + "name": "conda-build", + "sha256": "fe53d4018b99a643319c32e2579a4fa0cb041ffcc7c22c056499d139f320c343", + "size": 399048, + "subdir": "linux-64", + "timestamp": 1514949274841, + "version": "3.2.1" + }, + "conda-build-3.2.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b8d6b22b86b662ffe89aea3b8977469b", + "name": "conda-build", + "sha256": "4a1c722d2bfc4b2346edcc13346dffead605437d6a85fd3f6576a00371fe493e", + "size": 402287, + "subdir": "linux-64", + "timestamp": 1515794424462, + "version": "3.2.2" + }, + "conda-build-3.2.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "21308da51c8feae5d34624ee10e5b6bd", + "name": "conda-build", + "sha256": "5d96bc6c5e5bac6a7b43e3da2ffe0615928c0665832cfe7f25048c21bb93b846", + "size": 401497, + "subdir": "linux-64", + "timestamp": 1515794153928, + "version": "3.2.2" + }, + "conda-build-3.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "51ecaefcd4dd9b479bbbc8dd7a13a2a4", + "name": "conda-build", + "sha256": "b07fea578f3c6cdedcb7e2539fbcf1fc2eab1625356eb28639720f734faad678", + "size": 396871, + "subdir": "linux-64", + "timestamp": 1515794146574, + "version": "3.2.2" + }, + "conda-build-3.20.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5330b2f5f302d9dcf17d1ec6e1a1f39f", + "name": "conda-build", + "sha256": "df71cb59bb80170fcb272ebda77977927ef84504008ac91b47eb0f9e5869865b", + "size": 549444, + "subdir": "linux-64", + "timestamp": 1598592525986, + "version": "3.20.0" + }, + "conda-build-3.20.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7a2ee13ddd8894c8765a8d39fee914ff", + "name": "conda-build", + "sha256": "20fcefbdd810272213d30430c423bb5758217495a0a77b784e0540c9c781d9d7", + "size": 549074, + "subdir": "linux-64", + "timestamp": 1598592514962, + "version": "3.20.0" + }, + "conda-build-3.20.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a34da7e8597917d86bb1f6f3eb07e479", + "name": "conda-build", + "sha256": "15d3408db3d364061b5d7171b4580d53eb59acc632aad0044101629cf7cb3553", + "size": 554678, + "subdir": "linux-64", + "timestamp": 1598592504123, + "version": "3.20.0" + }, + "conda-build-3.20.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8c049bb84d1bfb7634ba5cedb3d6ce76", + "name": "conda-build", + "sha256": "daf44a277070f757f803547610d454ea878b41ecdb78f5c5e1db9d5bbf7d81ed", + "size": 548466, + "subdir": "linux-64", + "timestamp": 1599174383796, + "version": "3.20.1" + }, + "conda-build-3.20.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "39f6109b5fca2f475863ab8d087a944b", + "name": "conda-build", + "sha256": "617139396db81d1b1d1859fa240cdf3510abd9be2207767366d09155649b4cde", + "size": 552379, + "subdir": "linux-64", + "timestamp": 1599174389388, + "version": "3.20.1" + }, + "conda-build-3.20.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c1788b7f5ac9bdb42433e90e6073fa3e", + "name": "conda-build", + "sha256": "2c93f2401a0bd9065b240cbd5a351bcb718857cb1cd789138921a1437b52114e", + "size": 550331, + "subdir": "linux-64", + "timestamp": 1599174406015, + "version": "3.20.1" + }, + "conda-build-3.20.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9be50418f6d4def28d2a1b94570b8934", + "name": "conda-build", + "sha256": "bc53fe229b43d46ab4b2f47989d4d191a47019e2f6f08fdd46264b1521788836", + "size": 553187, + "subdir": "linux-64", + "timestamp": 1599595110075, + "version": "3.20.2" + }, + "conda-build-3.20.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "03fee8c1120b27e14b5234496b7d3266", + "name": "conda-build", + "sha256": "2b80055f0627ac27179f625234245636f8ac194ec2c2d8a732e3d4902f982faa", + "size": 548274, + "subdir": "linux-64", + "timestamp": 1599595079435, + "version": "3.20.2" + }, + "conda-build-3.20.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ea8e0d1d3a57f16e55e191b4ca93f702", + "name": "conda-build", + "sha256": "0f0d2a08264c05b1e080ca0eb3b1707ada5177db6af224e1bff35b2da305e0a7", + "size": 550980, + "subdir": "linux-64", + "timestamp": 1599595093445, + "version": "3.20.2" + }, + "conda-build-3.20.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "828787fa9860c16e4156e06fa6a4e4b4", + "name": "conda-build", + "sha256": "a33efd96182fbfd0fa442d5ac7963a619af30ac81a8e0d80ad0ad7871af54c4c", + "size": 553606, + "subdir": "linux-64", + "timestamp": 1601412150785, + "version": "3.20.3" + }, + "conda-build-3.20.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7ed050265f8ad0f2050fb13fb5e687ab", + "name": "conda-build", + "sha256": "52d8c9d70aaced19bb1cc677f58c2f2619aeeb26bc4bb2ef823d53f78d303a4b", + "size": 552119, + "subdir": "linux-64", + "timestamp": 1601412189909, + "version": "3.20.3" + }, + "conda-build-3.20.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a71982710e2dd79497c6b872f5892dac", + "name": "conda-build", + "sha256": "441cfd0296d53d2ff2ca67d7c0d31a40435f57163dcdb139cde074d6b7a749e6", + "size": 551029, + "subdir": "linux-64", + "timestamp": 1601412172118, + "version": "3.20.3" + }, + "conda-build-3.20.4-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a2733031de36ebd1f46571963da2c128", + "name": "conda-build", + "sha256": "5e29d3e25bd8d4cdef94074df8a78bc2330b3dc3b100089d3191bc4a56f26e10", + "size": 553536, + "subdir": "linux-64", + "timestamp": 1603213675342, + "version": "3.20.4" + }, + "conda-build-3.20.4-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0b0f176a32ff4450214177c6f0b75e44", + "name": "conda-build", + "sha256": "82e1f6ce055df5f9800c879624926bb1f0938bbe6f1569cee2cb823253266f49", + "size": 556256, + "subdir": "linux-64", + "timestamp": 1603213666616, + "version": "3.20.4" + }, + "conda-build-3.20.4-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "918507d3ab360b51a3352c31346fe1d2", + "name": "conda-build", + "sha256": "c1897ec081ba5db52dc0ef4ae58ecbe43f062a161713d24aa9d1b118cc4cba1e", + "size": 559049, + "subdir": "linux-64", + "timestamp": 1603213700075, + "version": "3.20.4" + }, + "conda-build-3.20.4-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6d28698fd95b618af1839dfbc3af7925", + "name": "conda-build", + "sha256": "2052cf0fb916ad8f1e84cdf97fe9902f80808a32097fd97684794929ff52a888", + "size": 555587, + "subdir": "linux-64", + "timestamp": 1607404895886, + "version": "3.20.4" + }, + "conda-build-3.20.5-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "495de6719f010d7dd043e45420acce2b", + "name": "conda-build", + "sha256": "a6060ea87fa8bbbcbb5383209c0e14b2c50d5bff1a43cf028294f73311ddf6af", + "size": 559562, + "subdir": "linux-64", + "timestamp": 1603728004542, + "version": "3.20.5" + }, + "conda-build-3.20.5-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b693e4fc4147cb08ac6c9c940645546d", + "name": "conda-build", + "sha256": "b2e4d001ad27ffb6727d8399f6eacabbcb6abca1a372aa5b970c9988a1e2a340", + "size": 559658, + "subdir": "linux-64", + "timestamp": 1603728241269, + "version": "3.20.5" + }, + "conda-build-3.20.5-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bccd80ba8faa667406c9fc96698b42a2", + "name": "conda-build", + "sha256": "8c49a91ea6764856c9964dff9ca99b482e8a7704da2c533114d4d2feedb51b7d", + "size": 561550, + "subdir": "linux-64", + "timestamp": 1603727977150, + "version": "3.20.5" + }, + "conda-build-3.20.5-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8ba92e7271149076cf8a623a0294f580", + "name": "conda-build", + "sha256": "0b2c6e2e39b38d2117418c24e4b65c1a5a7d6eea400f7b783e7fc7d7f9bb0b24", + "size": 557505, + "subdir": "linux-64", + "timestamp": 1608506024386, + "version": "3.20.5" + }, + "conda-build-3.21.0-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "806d39edcadb0bc81ccaa993361aec51", + "name": "conda-build", + "sha256": "c155ad37722714328dc6b3ef6689833be9a25b74fddc26b5bf05970ae80b6b98", + "size": 558239, + "subdir": "linux-64", + "timestamp": 1610313608099, + "version": "3.21.0" + }, + "conda-build-3.21.0-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "11e644215594f780cdbbe330f601d7a5", + "name": "conda-build", + "sha256": "6921ff6ac65553b65b2c636e3375640666a8c899d0699b950e5a82042a761fab", + "size": 561342, + "subdir": "linux-64", + "timestamp": 1610313609166, + "version": "3.21.0" + }, + "conda-build-3.21.0-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "016b630a91a18a005bc028168c034b9c", + "name": "conda-build", + "sha256": "5edc4298850c30725c4322e0855d26bb879b3b1bf87347e78a5c7fb5bd9f7737", + "size": 563516, + "subdir": "linux-64", + "timestamp": 1610313586942, + "version": "3.21.0" + }, + "conda-build-3.21.0-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "45ec0304099a63b150eaa14db69a8aeb", + "name": "conda-build", + "sha256": "af097e5b6d04e9bb9e6656503a26595fa3e41f20e20d9f8ee5036d05da1334da", + "size": 560537, + "subdir": "linux-64", + "timestamp": 1610313588601, + "version": "3.21.0" + }, + "conda-build-3.21.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6330760445a2ab57d5cd41d5a89d21ec", + "name": "conda-build", + "sha256": "6f2b9a81abc317353b579c91d2b63b1196ae8f611f5055636ee4cacc907f1f96", + "size": 561430, + "subdir": "linux-64", + "timestamp": 1610372909384, + "version": "3.21.1" + }, + "conda-build-3.21.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "43d2f3312ec9b0dc68fd4f5493098e43", + "name": "conda-build", + "sha256": "b45423ea5397319edbb71b11b508d4cee5899116e083f43d7a939ee9171742ec", + "size": 557072, + "subdir": "linux-64", + "timestamp": 1610372509461, + "version": "3.21.1" + }, + "conda-build-3.21.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "71443d53a2d9cdd4a9e602d5387ec3df", + "name": "conda-build", + "sha256": "1dad53d6fec4fffe3190342f4c348ea5099149fb349b3a9946182627053fb5d8", + "size": 560537, + "subdir": "linux-64", + "timestamp": 1610372937794, + "version": "3.21.1" + }, + "conda-build-3.21.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "98c8ec9e7a87e54637ddc8be24078533", + "name": "conda-build", + "sha256": "1a30093dc9711ea0c00846f2f729ec38568da5c79865fa958de2d3e7e5ab7267", + "size": 560464, + "subdir": "linux-64", + "timestamp": 1610372946406, + "version": "3.21.1" + }, + "conda-build-3.21.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "551fc03e488b20622439b90d334bd5ec", + "name": "conda-build", + "sha256": "62106b6d947d346d17564cfffe9c8465cf0658bce0bc73a2fdba6974e09f3829", + "size": 557418, + "subdir": "linux-64", + "timestamp": 1610396924914, + "version": "3.21.3" + }, + "conda-build-3.21.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9e44ec1947a4ab0752c04e68bdaf6064", + "name": "conda-build", + "sha256": "fd5c940e6e876fb819ffa8866bbeb08e0f5aaf3c7ae02e2efadd051ec190d973", + "size": 561054, + "subdir": "linux-64", + "timestamp": 1610396926411, + "version": "3.21.3" + }, + "conda-build-3.21.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2e821c6e1c9cfd12dd3b3d9493e351fc", + "name": "conda-build", + "sha256": "269dceec940f0cf0f9818f7a7d6faebe22612478e8831280b41127682f66c6b3", + "size": 563329, + "subdir": "linux-64", + "timestamp": 1610396924805, + "version": "3.21.3" + }, + "conda-build-3.21.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a493a888b868a66af08706f635c757f4", + "name": "conda-build", + "sha256": "77b3e77f45bbde903e45ccbb03dd6b4d6bad3d8631a39f8980a5dc3521fc410f", + "size": 564203, + "subdir": "linux-64", + "timestamp": 1610396919661, + "version": "3.21.3" + }, + "conda-build-3.21.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e6ca57ad512ad90ef874f87d96696c11", + "name": "conda-build", + "sha256": "1a397b7efd8da37c38da97b7b9fdb3ef32ad48e2e1e507d1c7023a991ec2547e", + "size": 558875, + "subdir": "linux-64", + "timestamp": 1610705903614, + "version": "3.21.4" + }, + "conda-build-3.21.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0dea39aa65fefb85286f6f86164a50c9", + "name": "conda-build", + "sha256": "fa34b8a286c3af802e922a1a80191c2c19785ef116779030c19a9c089e27399e", + "size": 561427, + "subdir": "linux-64", + "timestamp": 1610706477633, + "version": "3.21.4" + }, + "conda-build-3.21.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2b443dcdb54441396c13c2135158a008", + "name": "conda-build", + "sha256": "67dded3682554a7f9d322a4f9309273409f15509ec8bf58de488ee6de66a1d05", + "size": 560639, + "subdir": "linux-64", + "timestamp": 1610706477346, + "version": "3.21.4" + }, + "conda-build-3.21.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8f950f219882dccf9c7ff9cdbd0ec5a1", + "name": "conda-build", + "sha256": "bd9687da71913b5b8e5ae234a171efe8a8cc28f96bd0ea0daaf913eddd59d259", + "size": 564787, + "subdir": "linux-64", + "timestamp": 1610706501872, + "version": "3.21.4" + }, + "conda-build-3.21.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9ec61ea18a960822803fe7dfe3080b2a", + "name": "conda-build", + "sha256": "b0078e2daecd10b172d07c2e696d2c5fa233376006b77b9be36471c3065a7141", + "size": 549280, + "subdir": "linux-64", + "timestamp": 1641552066265, + "version": "3.21.5" + }, + "conda-build-3.21.5-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f104d36e86015a7a4ebd155f7a8e287b", + "name": "conda-build", + "sha256": "5560081d00b5c39d89707f7258bbd4d3dcad72e50cb3477b62d8044c82ef419f", + "size": 558803, + "subdir": "linux-64", + "timestamp": 1630349073840, + "version": "3.21.5" + }, + "conda-build-3.21.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0ad775ce72983c7c773d026d82b819a4", + "name": "conda-build", + "sha256": "f56f035daae9507c9020b1b45961e4064a568182cef06befd6c46b3a52b281a8", + "size": 561808, + "subdir": "linux-64", + "timestamp": 1630349056749, + "version": "3.21.5" + }, + "conda-build-3.21.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4779abd20a9faa6e7eb57568d2f412ee", + "name": "conda-build", + "sha256": "3df41e66efc392b5c006c50965db3224773d1a9756d85f807ce411f44af14100", + "size": 563982, + "subdir": "linux-64", + "timestamp": 1630349054134, + "version": "3.21.5" + }, + "conda-build-3.21.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5c7f89faf1cbe6e4eb95f902962d4d36", + "name": "conda-build", + "sha256": "ad83f90117448f65d73b642f5a0b25c2c3f0bcb293bcfda53e8fb53d02a22509", + "size": 565047, + "subdir": "linux-64", + "timestamp": 1630348855613, + "version": "3.21.5" + }, + "conda-build-3.21.6-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "973aa8150eb7b1a1d9133e56985ac336", + "name": "conda-build", + "sha256": "f1b451fc721ed76725dd6d32c05d174cdbd975871f441fd3e3452fc888f63610", + "size": 542347, + "subdir": "linux-64", + "timestamp": 1636555500049, + "version": "3.21.6" + }, + "conda-build-3.21.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c11961f9232c4339f7586c838d6d65fe", + "name": "conda-build", + "sha256": "6d7cd9d038c9eec16c6e35bb123d44583fab8f040f0b7b8e052107ff6b4f6fdd", + "size": 544863, + "subdir": "linux-64", + "timestamp": 1636555463052, + "version": "3.21.6" + }, + "conda-build-3.21.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ae30fff467cefda5ab4e538d99cdfcc7", + "name": "conda-build", + "sha256": "aaacbaf0b1d237786720eaeb27cc24a1b133f27ccd98a4254284d074f7c05861", + "size": 545492, + "subdir": "linux-64", + "timestamp": 1636555535640, + "version": "3.21.6" + }, + "conda-build-3.21.7-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4e3bfe62ec87ee565edbeb38f7c841ae", + "name": "conda-build", + "sha256": "3006ff5dd450a777211004a9d6430842fac32f6a4061ece50877e4d98e0a0e6f", + "size": 546608, + "subdir": "linux-64", + "timestamp": 1638465792107, + "version": "3.21.7" + }, + "conda-build-3.21.7-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee2cda4cf3d49dfc1a49adfb007292e0", + "name": "conda-build", + "sha256": "35a1d0895b3df92ed7eb27ea2d562eec3a1da9697e95f25fb11b7be33f6eacc2", + "size": 549704, + "subdir": "linux-64", + "timestamp": 1638465757142, + "version": "3.21.7" + }, + "conda-build-3.21.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ebe13d9c4f0c11ba164237fd768ecc3", + "name": "conda-build", + "sha256": "6ec17fda3cb293d2506c11efc9822fe01a1ec310f387cd1f121932124a7c019c", + "size": 549709, + "subdir": "linux-64", + "timestamp": 1638465827520, + "version": "3.21.7" + }, + "conda-build-3.21.8-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "be577162740907129ea03d5f3347aa8f", + "name": "conda-build", + "sha256": "e155440e25c2cf0fbdf58896bb772b645aebd9234c68fc52b8fae61f720e5a21", + "size": 566163, + "subdir": "linux-64", + "timestamp": 1648588119319, + "version": "3.21.8" + }, + "conda-build-3.21.8-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f49814041d10ea8f6aff3d6c4358844f", + "name": "conda-build", + "sha256": "f5b321d0a13404646f5b63b57044707b9b8b66bba3978d8fb3471598035890e8", + "size": 546434, + "subdir": "linux-64", + "timestamp": 1647017307727, + "version": "3.21.8" + }, + "conda-build-3.21.8-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "529a52f4d5dc674bafc3f2791d1b3bde", + "name": "conda-build", + "sha256": "cc852cea25b8c78e21af4726e9266c29dbf66c6c50255234058044e3e5cb6656", + "size": 559858, + "subdir": "linux-64", + "timestamp": 1648588106608, + "version": "3.21.8" + }, + "conda-build-3.21.8-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "797430bbc19f167250d7cb3641165810", + "name": "conda-build", + "sha256": "6850d725f0c5051a2e528d9da57d1f57a3227dfa47a6a0a71750ac23bdd23beb", + "size": 548895, + "subdir": "linux-64", + "timestamp": 1647017156610, + "version": "3.21.8" + }, + "conda-build-3.21.8-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "085b552fabd849361bb3bc1d7cdbc8cd", + "name": "conda-build", + "sha256": "56332bbcfaa8c2ecbaf634164c6b4662a997050a5b69f3c788674ed4af5ae1a6", + "size": 561399, + "subdir": "linux-64", + "timestamp": 1648588107293, + "version": "3.21.8" + }, + "conda-build-3.21.8-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5e73ecec0f2eb5aaa9b20668410978cd", + "name": "conda-build", + "sha256": "b0293221fa2f3de0bf3df251b351c63e4f3bc6f789c9c300559680f46e81bca1", + "size": 549678, + "subdir": "linux-64", + "timestamp": 1647017236719, + "version": "3.21.8" + }, + "conda-build-3.21.8-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5,<4.13.0", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0cbd4c50bffaec332f385aa6bff1db37", + "name": "conda-build", + "sha256": "1df32cd3c9aef63d7d634adad093e6dbf8809be0c4aa922278aac6c73a4fb331", + "size": 566047, + "subdir": "linux-64", + "timestamp": 1648569978663, + "version": "3.21.8" + }, + "conda-build-3.21.9-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dfb9fc9e84bffa83ee1e1671a6a473c4", + "name": "conda-build", + "sha256": "3f4c5ef004ed1339c19818d7726c7f844daf96cfa7062185377ca86e14e02971", + "size": 550648, + "subdir": "linux-64", + "timestamp": 1654011569390, + "version": "3.21.9" + }, + "conda-build-3.21.9-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "98c59c01619cfcdfe6bb6fb60c371620", + "name": "conda-build", + "sha256": "78b6271fcf0613c607cce6d292c775accfbaff34d598f9b5800eb8526a39a9a3", + "size": 543047, + "subdir": "linux-64", + "timestamp": 1654011522330, + "version": "3.21.9" + }, + "conda-build-3.21.9-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fc59c7d688a22ea47217ed77a7b53df0", + "name": "conda-build", + "sha256": "107364c9f255b8bb831d4a6ffb4ebbf2cf0526e70a71fc24ae54a60cff779ace", + "size": 545503, + "subdir": "linux-64", + "timestamp": 1654011485803, + "version": "3.21.9" + }, + "conda-build-3.21.9-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cf509cd4ae8ef6e64ddc1519c2b850a5", + "name": "conda-build", + "sha256": "6ed81a22843f7f519bca4c9bee2f9cbec663ee13381e980cdb8f5d5f1f8fbc0f", + "size": 545968, + "subdir": "linux-64", + "timestamp": 1654011446762, + "version": "3.21.9" + }, + "conda-build-3.22.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8c3f105a4f4514f5c0f9c5253f17e6eb", + "name": "conda-build", + "sha256": "02dbe9b0a7175c3ababf5cbd70c04ef03ffac87779e0525e5f9992f287369bb8", + "size": 552774, + "subdir": "linux-64", + "timestamp": 1661284142646, + "version": "3.22.0" + }, + "conda-build-3.22.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0782967047b809ee40c7dbe835490b8b", + "name": "conda-build", + "sha256": "d354c1702b909ea0f0f83ca37e7cbe84eb8935ff3f3a07b0eef79bee9fc7d02b", + "size": 545343, + "subdir": "linux-64", + "timestamp": 1661284262470, + "version": "3.22.0" + }, + "conda-build-3.22.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "19607da59ca246c4b896e814f0d6d5f2", + "name": "conda-build", + "sha256": "671cfa345cbb884a5360370d6bad629269d0fe34b6c6348ebb25b96e81f7e3e9", + "size": 547657, + "subdir": "linux-64", + "timestamp": 1661284181519, + "version": "3.22.0" + }, + "conda-build-3.22.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e0a54bc9f5c6ab0c681770b2b5fe6238", + "name": "conda-build", + "sha256": "8e9a847cf6df728d088d3c59480cd0faef0304be06a5813da0fcffe8bd9b0e93", + "size": 548283, + "subdir": "linux-64", + "timestamp": 1661284222590, + "version": "3.22.0" + }, + "conda-build-3.23.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d4711af98d6893bf1e7b21101f6a9d73", + "name": "conda-build", + "sha256": "10d51408e1ea2af23b69efbc5edd4431e5d4ac58ad2f90bb06fa4d8e53202410", + "size": 593867, + "subdir": "linux-64", + "timestamp": 1668696010303, + "version": "3.23.0" + }, + "conda-build-3.23.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "81693d8d0be3d7c4ea3f73678ff0d6b1", + "name": "conda-build", + "sha256": "f7c2f36eef42c2155134ef46895e2d8732dce9f5947048b90970a0bb15e85956", + "size": 585813, + "subdir": "linux-64", + "timestamp": 1668702291125, + "version": "3.23.0" + }, + "conda-build-3.23.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "993c844f243bb354f79a7ca2f860faea", + "name": "conda-build", + "sha256": "8735e84d3f838b63350e77d4c2672cf5963abf61dfcd72a1eb70c5beba033d36", + "size": 585912, + "subdir": "linux-64", + "timestamp": 1668695969311, + "version": "3.23.0" + }, + "conda-build-3.23.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "501ce238ad829a161daa4da2d861d4a7", + "name": "conda-build", + "sha256": "7020d7c72d6b1a1557e5f7fac6bea16110796478f968055f946f1aa6723a2315", + "size": 578016, + "subdir": "linux-64", + "timestamp": 1668702252328, + "version": "3.23.0" + }, + "conda-build-3.23.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1ffb0e36c119a4228180da4f581bcada", + "name": "conda-build", + "sha256": "c893785f1b4682ce264cdea826c1aa4ae6a9a4794bc7f4aaae715b8f06164435", + "size": 588740, + "subdir": "linux-64", + "timestamp": 1668696050861, + "version": "3.23.0" + }, + "conda-build-3.23.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "063ce4ef2a0faa01680e567beea54459", + "name": "conda-build", + "sha256": "2d6e91552eed13cddec44bd49297f35d1235b7ef1b72f068e563c8ab54a4533a", + "size": 580564, + "subdir": "linux-64", + "timestamp": 1668702366535, + "version": "3.23.0" + }, + "conda-build-3.23.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.5", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0160adfacba4a75c6ed775a72e8f0a3e", + "name": "conda-build", + "sha256": "03909ceef6829cd31c7e172f9ce1861fc93643419024a4986d1429a8a91d0743", + "size": 588950, + "subdir": "linux-64", + "timestamp": 1668696089790, + "version": "3.23.0" + }, + "conda-build-3.23.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "73e46b96b84808e611310556c4b0e93c", + "name": "conda-build", + "sha256": "b0977b29d10036fc68fbe2c05d06136ba3d13e6a9ed5ad7583ffd30162f5a2ab", + "size": 580967, + "subdir": "linux-64", + "timestamp": 1668702329235, + "version": "3.23.0" + }, + "conda-build-3.23.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2dc5ff6fb8a65090f9443efca4bef2ba", + "name": "conda-build", + "sha256": "782a1e7ac6d61a85e4168d1ea09bab55f3eb632f8f4fa15f4ddc39121213950d", + "size": 556203, + "subdir": "linux-64", + "timestamp": 1668781369259, + "version": "3.23.1" + }, + "conda-build-3.23.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ddf47e575b526a8d6f60c87f4f67b705", + "name": "conda-build", + "sha256": "525c67aeb37a69d047f111cd23d0889873d331fa66c5cd851bd906b516f6ab09", + "size": 548742, + "subdir": "linux-64", + "timestamp": 1668781409571, + "version": "3.23.1" + }, + "conda-build-3.23.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f90b553dd78afb88395a46a1f1ba09e4", + "name": "conda-build", + "sha256": "9f82350d26134ea7464dfb9ded877ba3cf25ef32117f11740f34e7b3b28eca71", + "size": 551587, + "subdir": "linux-64", + "timestamp": 1668781449390, + "version": "3.23.1" + }, + "conda-build-3.23.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e59ba65652a9d94aaeae771ea85f3147", + "name": "conda-build", + "sha256": "867f6df31bbd39f6bedbabde4d92dc0d4e729c1668455f2829b4d3b9817e9f20", + "size": 547539, + "subdir": "linux-64", + "timestamp": 1668781328292, + "version": "3.23.1" + }, + "conda-build-3.23.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e15120eb8ba24076bdc7c322385f68cf", + "name": "conda-build", + "sha256": "d3899dee08bfe13eb84f413b6ca3891ce77d0b5ece1a542cd5d66871998a3fc8", + "size": 592562, + "subdir": "linux-64", + "timestamp": 1669899795673, + "version": "3.23.2" + }, + "conda-build-3.23.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0d604d4e8cfc17e7ccc67b6e46042f73", + "name": "conda-build", + "sha256": "a34b7b63c0f8e144d13a0a79f0f19f325ce881490677497470f6ac522971b8e3", + "size": 584452, + "subdir": "linux-64", + "timestamp": 1669899759589, + "version": "3.23.2" + }, + "conda-build-3.23.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50d19a6671747a1566092302ae03f16e", + "name": "conda-build", + "sha256": "2b3da8acc64c84f54f0d6773867337b32c869945d0a17a5eb4d531b64e25bfaa", + "size": 587253, + "subdir": "linux-64", + "timestamp": 1669899723005, + "version": "3.23.2" + }, + "conda-build-3.23.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "afcca2f17fe05f2697fb7ff41b29abc7", + "name": "conda-build", + "sha256": "50e6a650404036d3c3412bd5067f459d577f80c8961fc9cc809f53acdab113bc", + "size": 587539, + "subdir": "linux-64", + "timestamp": 1669899687838, + "version": "3.23.2" + }, + "conda-build-3.23.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "73177447c7f5e5cd199fe8dac968371d", + "name": "conda-build", + "sha256": "f878f10f0f9b538f5d86fdf8cc644a526b25f8b6e7ab015f0ce0f42285deb033", + "size": 593969, + "subdir": "linux-64", + "timestamp": 1670407408424, + "version": "3.23.3" + }, + "conda-build-3.23.3-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.11,<3.12.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2093f7ca44d88fd27848802e1edd97da", + "name": "conda-build", + "sha256": "21e939a25e5c1ff6ec09ab741b20cf615c07c98b3783eb024714b62c8e15e77e", + "size": 772334, + "subdir": "linux-64", + "timestamp": 1676843642890, + "version": "3.23.3" + }, + "conda-build-3.23.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1ad46bbffd636a274a37969adc9f4814", + "name": "conda-build", + "sha256": "a8ee7c373103c089ed45265e29c5b0bd041886674db5b9f6ce8c49b31f0150fc", + "size": 585803, + "subdir": "linux-64", + "timestamp": 1670407443666, + "version": "3.23.3" + }, + "conda-build-3.23.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22839b81bf3f672b9ad08fe414abd4d9", + "name": "conda-build", + "sha256": "fcdf2ae450115032f67f060efbcf13a18ca458b7a70b76a69461f2ed26ccd8a5", + "size": 588746, + "subdir": "linux-64", + "timestamp": 1670407479275, + "version": "3.23.3" + }, + "conda-build-3.23.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "setuptools", + "six", + "toml", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "63364c0c2de6579588bf9ca6db3d7192", + "name": "conda-build", + "sha256": "a7780c2fd1814e98f39e787106654624e9c8b6a3a9528572ba906ca36007f0b0", + "size": 589092, + "subdir": "linux-64", + "timestamp": 1670407374247, + "version": "3.23.3" + }, + "conda-build-3.24.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "packaging", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "six", + "tomli", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "90b6cae0d7a2d3f808839b8479e6a6c1", + "name": "conda-build", + "sha256": "3f9c42369155ca6458946e534e497a0782187ddea087b538928643788f9e64cd", + "size": 594687, + "subdir": "linux-64", + "timestamp": 1679586285493, + "version": "3.24.0" + }, + "conda-build-3.24.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "packaging", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.11,<3.12.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "325a0105dd81ad7c512f1ec49932de7e", + "name": "conda-build", + "sha256": "bcb2d9f7bc839c9e3b7b29249a49edbe415c53a9661a6b7b6fedfb03ca90ccc1", + "size": 828826, + "subdir": "linux-64", + "timestamp": 1679586242679, + "version": "3.24.0" + }, + "conda-build-3.24.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "packaging", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.8,<3.9.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "six", + "tomli", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "db65a54f2db7bff499ce97f8a0ef9318", + "name": "conda-build", + "sha256": "718d043d5363a8c683a4545ad184395a6cf9b2f16987934c5f3de54f5a4ec2e5", + "size": 589187, + "subdir": "linux-64", + "timestamp": 1679586329035, + "version": "3.24.0" + }, + "conda-build-3.24.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "packaging", + "patch >=2.6", + "patchelf", + "pkginfo", + "psutil", + "py-lief", + "python >=3.9,<3.10.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "ripgrep", + "six", + "tomli", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6c7b5a47e79883a0ee6a7b5780dd89d8", + "name": "conda-build", + "sha256": "734ada945108dc061525b43e20295fd904240a9fccc3bb5f72caca98b52b5ba3", + "size": 589643, + "subdir": "linux-64", + "timestamp": 1679586370919, + "version": "3.24.0" + }, + "conda-build-3.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3eadcd2f2490e95f617535705670fc1b", + "name": "conda-build", + "sha256": "25e61c97c08ef26a4fedde1338bfd8125cfcf1c47643a10d0773574fc50db783", + "size": 406734, + "subdir": "linux-64", + "timestamp": 1516747442586, + "version": "3.3.0" + }, + "conda-build-3.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "36b013dc2c986df4c76c81b71e399bd2", + "name": "conda-build", + "sha256": "024b9d2989abc25939642a8151da747d9f3f5f1f26e7d3be4e300e8dec07e0e9", + "size": 408422, + "subdir": "linux-64", + "timestamp": 1516747468072, + "version": "3.3.0" + }, + "conda-build-3.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ed43303cba5b841fefd4e055640d9dd8", + "name": "conda-build", + "sha256": "0ecbbdcf4b17d9de6e2c3cbcc1c996734c709e7c711d47576f9272362567cf16", + "size": 403365, + "subdir": "linux-64", + "timestamp": 1516747462460, + "version": "3.3.0" + }, + "conda-build-3.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f29606b6816702f3c74bbd985a5304ac", + "name": "conda-build", + "sha256": "e4b9d0ce2c3c1edbc2569db08f1dcb0cbbc1e825afaed9ff224f406c2bb37333", + "size": 408554, + "subdir": "linux-64", + "timestamp": 1517457129035, + "version": "3.4.0" + }, + "conda-build-3.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "54ed9cccc9224c8ad12fb17298f3ea62", + "name": "conda-build", + "sha256": "f9ecf14b6c8f6109bbd30a49fca7dbf31ddff3e02ef0a7ef09fb1717169f6284", + "size": 413980, + "subdir": "linux-64", + "timestamp": 1517457193650, + "version": "3.4.0" + }, + "conda-build-3.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b560a984d59ed28113164313233d0ff0", + "name": "conda-build", + "sha256": "93c51072603f2a089b647443b67ebdd0c42ddb94fdcda10d9a3d809522a7a777", + "size": 405578, + "subdir": "linux-64", + "timestamp": 1517457185574, + "version": "3.4.0" + }, + "conda-build-3.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "623055e6db2ce5b19a8b3697a38f8f11", + "name": "conda-build", + "sha256": "b1ec9bb14fe4e2a5c15345a5da8d108cd20c104038b70100486a8c8a33347ae7", + "size": 408969, + "subdir": "linux-64", + "timestamp": 1518118480816, + "version": "3.4.1" + }, + "conda-build-3.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d6f7706fcaf134fcc57cc3fafeba20f2", + "name": "conda-build", + "sha256": "d5b828b8d569044d89798a032a86cdbef63928f740634a32f8d95f85fc0227cb", + "size": 413963, + "subdir": "linux-64", + "timestamp": 1518118500756, + "version": "3.4.1" + }, + "conda-build-3.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "13f0f59e1d8f87cfa400370c0e2bd0bd", + "name": "conda-build", + "sha256": "21e03229a04bcda8abe5842dcb97f09e6585ffe512c41a051bc8bcbe087f9a7a", + "size": 408357, + "subdir": "linux-64", + "timestamp": 1518118508683, + "version": "3.4.1" + }, + "conda-build-3.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4bf97ce7f77ae29044227f67438b8281", + "name": "conda-build", + "sha256": "9c59c6ac8e4cfb7e58035af8c70b5fb64c1a1b27da20afa8b1db96487d2dcdde", + "size": 409432, + "subdir": "linux-64", + "timestamp": 1518724300284, + "version": "3.4.2" + }, + "conda-build-3.4.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d92c618befdbb94672b7f04d22384d85", + "name": "conda-build", + "sha256": "8bf115b07c608e2b53a9e52cf51b32820338e05ad5a0ea2c8418eb5e31f0ff85", + "size": 414620, + "subdir": "linux-64", + "timestamp": 1518724562944, + "version": "3.4.2" + }, + "conda-build-3.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ebacab93f6f2bbdc6a697f04a27452f4", + "name": "conda-build", + "sha256": "56ecd163c011790e441df64ae3b0f9611be8a27b77da76a08563226d26b73c83", + "size": 406443, + "subdir": "linux-64", + "timestamp": 1518724365184, + "version": "3.4.2" + }, + "conda-build-3.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ffe84ce1d4bf2100e0dffa4e5a3c4b3c", + "name": "conda-build", + "sha256": "750457e474141b1cfdad156b8a5f8fb752d720c43e6fc33bfa8cdb0742fea763", + "size": 416030, + "subdir": "linux-64", + "timestamp": 1519160839848, + "version": "3.5.0" + }, + "conda-build-3.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a5eb7bafb366935d86292c8661e47d70", + "name": "conda-build", + "sha256": "09805a25d86f0de8616121fde28305512d38c196874cf7641d9a73e0f728443d", + "size": 419985, + "subdir": "linux-64", + "timestamp": 1519160862393, + "version": "3.5.0" + }, + "conda-build-3.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4e2521e0eb9a6bb2165a08a728e0c7ba", + "name": "conda-build", + "sha256": "3d50fce9d2fb98a39a5f077da8d5e5f687569f95811bba952e0634390fce1517", + "size": 413664, + "subdir": "linux-64", + "timestamp": 1519160839399, + "version": "3.5.0" + }, + "conda-build-3.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2298f56caf02a05cc25d052e94a61a56", + "name": "conda-build", + "sha256": "566c28d53421da1ef06c99ca76b664fc16a70bd26f94c207f1cea392f61adfeb", + "size": 416668, + "subdir": "linux-64", + "timestamp": 1519330131261, + "version": "3.5.1" + }, + "conda-build-3.5.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "88e4ee311cfec1a340230948a4d5ac6e", + "name": "conda-build", + "sha256": "eabf596e7f48064a4e91bba67c346b7e2234cfccb54a7ff246b3f1417c5d6f26", + "size": 416730, + "subdir": "linux-64", + "timestamp": 1519330182078, + "version": "3.5.1" + }, + "conda-build-3.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fdef6bbe0e5044593a3f896d658d59ad", + "name": "conda-build", + "sha256": "b0fc2016d5fa735bde375aef5ccc547b1fb94bf2bd2f629b8ca7b1071bf2a4f4", + "size": 411971, + "subdir": "linux-64", + "timestamp": 1519330118248, + "version": "3.5.1" + }, + "conda-build-3.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4ad790e2725ea7a333b95a039fe9a005", + "name": "conda-build", + "sha256": "8454d545eca0042c30816b401b02e2d7ac25e2ce24b8a06932d7e1ff4269bdf7", + "size": 423854, + "subdir": "linux-64", + "timestamp": 1519858554742, + "version": "3.6.0" + }, + "conda-build-3.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e30eb76fb877337531b845ca0514f58e", + "name": "conda-build", + "sha256": "96ba6df51a3cb46fdede7e57785b8357531c3963bafacd65e70f738dbfb066dd", + "size": 426722, + "subdir": "linux-64", + "timestamp": 1519858578301, + "version": "3.6.0" + }, + "conda-build-3.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5cbadc0ad0291fdd798979746fc6bea8", + "name": "conda-build", + "sha256": "f2e1cdbfd8df06347d07acff5ff184857fbaa527e8a691dfeb54c36e3c304544", + "size": 417479, + "subdir": "linux-64", + "timestamp": 1519858499587, + "version": "3.6.0" + }, + "conda-build-3.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cd9b410c68d66d1571c0706fd43ae123", + "name": "conda-build", + "sha256": "934c803ab0c6c686bd5e9e480edefb51a98cda6e23a7a07295e48991bea647c9", + "size": 424786, + "subdir": "linux-64", + "timestamp": 1520262267195, + "version": "3.7.0" + }, + "conda-build-3.7.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6454fb4d44f9b0ced0030d884ecf814f", + "name": "conda-build", + "sha256": "dcf5ded68e03c11b2f00a01f462ea06d7a763aefa99213a504856886303863df", + "size": 427707, + "subdir": "linux-64", + "timestamp": 1520262308903, + "version": "3.7.0" + }, + "conda-build-3.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5c16db149e43d9e9c8d9a1f6763c5b66", + "name": "conda-build", + "sha256": "c622415a97dd905672a46bdc1f202ee2ad9a0555d4d2dda491058417b1e87eac", + "size": 418735, + "subdir": "linux-64", + "timestamp": 1520262275898, + "version": "3.7.0" + }, + "conda-build-3.7.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5b3421e31ecb85b49573aa8df9b5e23b", + "name": "conda-build", + "sha256": "86e92929e54d433c269880906eebde895d6ddac3fee419f4ce8e2b7e4549057b", + "size": 425725, + "subdir": "linux-64", + "timestamp": 1520545334753, + "version": "3.7.1" + }, + "conda-build-3.7.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b1cc0a560fb3d64f459a1b2accf7abe2", + "name": "conda-build", + "sha256": "bf44ec17aea71f5a8d09e228ba02e6d18bf58c65f2c7fe0b8266d80fa8fdce11", + "size": 428422, + "subdir": "linux-64", + "timestamp": 1520545350462, + "version": "3.7.1" + }, + "conda-build-3.7.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e9aa6584dee72cbfe476a651767036b4", + "name": "conda-build", + "sha256": "d08b30c725f0512a50df45e256cba2fb00d5537e6a989945b33bf32a67ac3321", + "size": 423379, + "subdir": "linux-64", + "timestamp": 1520545306318, + "version": "3.7.1" + }, + "conda-build-3.7.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cf9225990679814c674d0ba7ec8426a4", + "name": "conda-build", + "sha256": "7cb9d413c88845409c1ac984d7e26c74b0068d7b68cc4f8ee875c81896060047", + "size": 423420, + "subdir": "linux-64", + "timestamp": 1521746261220, + "version": "3.7.2" + }, + "conda-build-3.7.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "243478dc99cf751d2eedbda53c929ae4", + "name": "conda-build", + "sha256": "f8e573cd51c24ccb7fc3b518a3541791f2bad81571a83b8916d07a477cd0b3f5", + "size": 429310, + "subdir": "linux-64", + "timestamp": 1521746273744, + "version": "3.7.2" + }, + "conda-build-3.7.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1da61e1ab7c60d3207d7333d3e9c7a7a", + "name": "conda-build", + "sha256": "25ff7b3a4d46d75df5ee3bb3142ea12ec791596db5ce95704da33fca6cd6258f", + "size": 424108, + "subdir": "linux-64", + "timestamp": 1521746294883, + "version": "3.7.2" + }, + "conda-build-3.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c675bb20056af7f578b7895659cabaf5", + "name": "conda-build", + "sha256": "069ef8cd76edc7bf0247ad43d6fb5966476e2d57fdc91fef94005688f2329b7b", + "size": 427680, + "subdir": "linux-64", + "timestamp": 1522428282452, + "version": "3.8.0" + }, + "conda-build-3.8.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ceee35f21c07441a4c0d9b1bbb25b17a", + "name": "conda-build", + "sha256": "a57a22a72743a942a0707a4e6b07858741e1706f6651e3ff5b6d39a6898affb6", + "size": 430043, + "subdir": "linux-64", + "timestamp": 1522428334170, + "version": "3.8.0" + }, + "conda-build-3.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1ffae1cd0cead88739ced819507d086d", + "name": "conda-build", + "sha256": "36e384f91c1967c98054bc170045335f499270dee899abebadd566afbc70140b", + "size": 421134, + "subdir": "linux-64", + "timestamp": 1522428293746, + "version": "3.8.0" + }, + "conda-build-3.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6d6c2565f2591342a3dccf34741a8689", + "name": "conda-build", + "sha256": "6bc31525c5520816ea8b617708ce9e1457288a4e152ae74a1524800b184d474c", + "size": 427734, + "subdir": "linux-64", + "timestamp": 1523895532250, + "version": "3.8.1" + }, + "conda-build-3.8.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "08831752fd8ee59715a866ec1c11e1cf", + "name": "conda-build", + "sha256": "a888094deb698fb1d74a1ba8e07f3b159dc892c5e684c315c0f6d442523cc5bc", + "size": 426184, + "subdir": "linux-64", + "timestamp": 1523895582703, + "version": "3.8.1" + }, + "conda-build-3.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bbbf81106992d154ff0eec5d2b695e27", + "name": "conda-build", + "sha256": "1dc30328273381728daf0cfb48f6e46e5daea57cb2caed1dbeadc03133e8e60b", + "size": 425562, + "subdir": "linux-64", + "timestamp": 1523895568873, + "version": "3.8.1" + }, + "conda-build-3.9.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "be29882931af737d92604a54d1987da1", + "name": "conda-build", + "sha256": "76eaa0bb12a0582255d5e9cdc9820391f5162eb43f2c6e0bcdbd442de97add42", + "size": 431785, + "subdir": "linux-64", + "timestamp": 1524621216211, + "version": "3.9.1" + }, + "conda-build-3.9.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6e31d9e04cd30221a79c30c2290088a6", + "name": "conda-build", + "sha256": "924f093c5da8acbc32aa30c6beff0ca5b50acdb46a6f04d9ca7be5bac624ce8c", + "size": 433242, + "subdir": "linux-64", + "timestamp": 1524621254961, + "version": "3.9.1" + }, + "conda-build-3.9.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e2869bfa4ae00d840e8cae11e3df9e9a", + "name": "conda-build", + "sha256": "b914c8dac6a5f6a31a4db6049c96b5d148ec8c1fd939fac330733180fcdf50a0", + "size": 429028, + "subdir": "linux-64", + "timestamp": 1524621255611, + "version": "3.9.1" + }, + "conda-build-3.9.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "contextlib2", + "enum34", + "filelock", + "futures", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scandir", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3002fa86c48a365f8335366b8ce206b5", + "name": "conda-build", + "sha256": "bda0bdd5ac934815d03db5da174e237b8fd6644902b560bbd6ba7e6b3dac7170", + "size": 432184, + "subdir": "linux-64", + "timestamp": 1524862199707, + "version": "3.9.2" + }, + "conda-build-3.9.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "400e4cc5cd28ca0170cf58d6cd8abdb0", + "name": "conda-build", + "sha256": "0f0282a855b97a7d716ee21ed4c8cd8cc0ba38fbb833ebaa9ea76b92427a5dd2", + "size": 430503, + "subdir": "linux-64", + "timestamp": 1524862233179, + "version": "3.9.2" + }, + "conda-build-3.9.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "chardet", + "conda >=4.3,<4.13.0", + "conda-verify", + "filelock", + "glob2", + "jinja2 !=3.0.0", + "patchelf", + "pkginfo", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4f9da1b32d3cf3094b24b0a85ce1c5f3", + "name": "conda-build", + "sha256": "0cb95548f94ad164ebadc0a4be7369f8c094e2bda611aa177d73496b44315d25", + "size": 425380, + "subdir": "linux-64", + "timestamp": 1524862233103, + "version": "3.9.2" + }, + "conda-content-trust-0.1.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "69f1c06e7c9ce52d4a9b5787c74cac20", + "name": "conda-content-trust", + "sha256": "e45ee6f7d682f6765123dfb608e8a966d97dbe3cf525d3a6f045c6138df02e9f", + "size": 72203, + "subdir": "linux-64", + "timestamp": 1658126442462, + "version": "0.1.3" + }, + "conda-content-trust-0.1.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "597e7fc8644c26a4994de871bdee2f09", + "name": "conda-content-trust", + "sha256": "66acf3789700cb25224f31aa5eabfa0030b86d8109ee27ec7f4258eb26c46cba", + "size": 82068, + "subdir": "linux-64", + "timestamp": 1676851340382, + "version": "0.1.3" + }, + "conda-content-trust-0.1.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50c8d2765b6a8346b91735f81841e130", + "name": "conda-content-trust", + "sha256": "03eddc13536e7b08b5f2ff3648fe48976950174fd1adbabcfbf54ed6b88c9383", + "size": 71820, + "subdir": "linux-64", + "timestamp": 1658126496891, + "version": "0.1.3" + }, + "conda-content-trust-0.1.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6945bc2599e496ccd583b047aec8fe01", + "name": "conda-content-trust", + "sha256": "85c40a08e753ad4483bd2f05368c852b48066def69f9f140ee988fe386289f37", + "size": 72005, + "subdir": "linux-64", + "timestamp": 1658126404256, + "version": "0.1.3" + }, + "conda-content-trust-0.1.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f07cba1d364381901a5b1fb65ea7af09", + "name": "conda-content-trust", + "sha256": "8dbc1b2f0e96c571c176793e69dcf8bdefc204cfeb4c5c57d27884aecda481d0", + "size": 72058, + "subdir": "linux-64", + "timestamp": 1658126469377, + "version": "0.1.3" + }, + "conda-env-2.6.0-1.conda": { + "build": "1", + "build_number": 1, + "depends": [], + "license": "BSD 3-Clause", + "md5": "7e7b9e449c8e3ceffe23585d31be5f8a", + "name": "conda-env", + "namespace": "python", + "sha256": "701ae3f8a0bdc2459290943aca1690eeb95cf196cb927eb26526c82e8971818b", + "size": 3121, + "subdir": "linux-64", + "timestamp": 1530812938329, + "version": "2.6.0" + }, + "conda-env-2.6.0-h36134e3_1.conda": { + "build": "h36134e3_1", + "build_number": 1, + "depends": [], + "license": "BSD 3-Clause", + "md5": "23520f62c592d8ce54c3d8492e510814", + "name": "conda-env", + "namespace": "python", + "sha256": "649d6b95bbba66b2157b508bf8777e4ffa0217b3fb48e6f45945d2eef3959ed7", + "size": 2573, + "subdir": "linux-64", + "timestamp": 1505742067960, + "version": "2.6.0" + }, + "conda-index-0.2.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8", + "conda >=4.12.0", + "conda-package-streaming >=0.7.0", + "filelock", + "jinja2", + "more-itertools", + "python >=3.10,<3.11.0a0", + "pyyaml >=6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d009e64e5dd1f443a3692aad697ee3db", + "name": "conda-index", + "sha256": "ef793d18fa8f50de2d09729c6161404b22e55841865ceb4d667d655f39174f8e", + "size": 202426, + "subdir": "linux-64", + "timestamp": 1672127387623, + "version": "0.2.3" + }, + "conda-index-0.2.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8", + "conda >=4.12.0", + "conda-package-streaming >=0.7.0", + "filelock", + "jinja2", + "more-itertools", + "python >=3.11,<3.12.0a0", + "pyyaml >=6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c2274fad53af7de180c576f0c25373eb", + "name": "conda-index", + "sha256": "4553468736ed87e10b1b191966e38bce6ed63428739c4c12ee9d54bbf44c8191", + "size": 215478, + "subdir": "linux-64", + "timestamp": 1676851356499, + "version": "0.2.3" + }, + "conda-index-0.2.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8", + "conda >=4.12.0", + "conda-package-streaming >=0.7.0", + "filelock", + "jinja2", + "more-itertools", + "python >=3.7,<3.8.0a0", + "pyyaml >=6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "41249ed314bf96e1f0ddec854369fa5e", + "name": "conda-index", + "sha256": "80fe9eeb59196e9ef3a311bb51b693ebc477366555ac34d4272925e0633df39c", + "size": 201598, + "subdir": "linux-64", + "timestamp": 1672127423190, + "version": "0.2.3" + }, + "conda-index-0.2.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8", + "conda >=4.12.0", + "conda-package-streaming >=0.7.0", + "filelock", + "jinja2", + "more-itertools", + "python >=3.8,<3.9.0a0", + "pyyaml >=6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a594a5a29b725650e7dbcf82f3a19fb6", + "name": "conda-index", + "sha256": "00dae639d820876ada8216d76d2fb729bc5ac42ce71af7588b90235e9d690827", + "size": 201916, + "subdir": "linux-64", + "timestamp": 1672127470096, + "version": "0.2.3" + }, + "conda-index-0.2.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8", + "conda >=4.12.0", + "conda-package-streaming >=0.7.0", + "filelock", + "jinja2", + "more-itertools", + "python >=3.9,<3.10.0a0", + "pyyaml >=6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "be4d2d30ae001abd4563b9a30e5b743b", + "name": "conda-index", + "sha256": "77fe6c4d607d690d949092699eaccfb53e81c15182b4a1d235de976b6917a7f1", + "size": 201945, + "subdir": "linux-64", + "timestamp": 1672127352596, + "version": "0.2.3" + }, + "conda-libmamba-solver-22.12.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=22.11.0,<23.1.0a", + "importlib-metadata", + "libmambapy >=1.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "557acd480e9a703c759af1cba84f8f53", + "name": "conda-libmamba-solver", + "sha256": "d415bf46aaa95ad6c3f00a8bbfa4e28fe39729c0b72110f8e6354491665bd510", + "size": 65243, + "subdir": "linux-64", + "timestamp": 1669915150570, + "version": "22.12.0" + }, + "conda-libmamba-solver-22.12.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=22.11.0,<23.1.0a", + "importlib-metadata", + "libmambapy >=1.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e36794b5a6f8453a6bd612e6e042132f", + "name": "conda-libmamba-solver", + "sha256": "1d9cfcee01fe0a8f5360262131df48d9b15b5c1ed36f6b4864ae6b91d38ff4bf", + "size": 64687, + "subdir": "linux-64", + "timestamp": 1669915117324, + "version": "22.12.0" + }, + "conda-libmamba-solver-22.12.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=22.11.0,<23.1.0a", + "importlib-metadata", + "libmambapy >=1.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "003e4e125d45af37410322dbe54ad187", + "name": "conda-libmamba-solver", + "sha256": "eb7c927d30997313710765f010a37929fac8a9c33b4e83ef3049a95ce18306d2", + "size": 64832, + "subdir": "linux-64", + "timestamp": 1669915083949, + "version": "22.12.0" + }, + "conda-libmamba-solver-22.12.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=22.11.0,<23.1.0a", + "importlib-metadata", + "libmambapy >=1.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5a3f8ae1e2aa75125c30a9edc2a06c50", + "name": "conda-libmamba-solver", + "sha256": "5e0d33e4cf3e70e48b37436acd5256bbf16fe7e0a5bed9977d444494d6a353e6", + "size": 64757, + "subdir": "linux-64", + "timestamp": 1669915183463, + "version": "22.12.0" + }, + "conda-libmamba-solver-22.8.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=4.13,<22.11.0a", + "importlib_metadata", + "libmambapy >=0.23", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ac6766d0f450659aaea765f325204bd9", + "name": "conda-libmamba-solver", + "sha256": "fd9505ec0f8a2b119cf76b1512ddfed419233a42dcece54f60502c3f4f6605c0", + "size": 63672, + "subdir": "linux-64", + "timestamp": 1661888244054, + "version": "22.8.1" + }, + "conda-libmamba-solver-22.8.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=4.13,<22.11.0a", + "importlib_metadata", + "libmambapy >=0.23", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b3e0d7a06fc8538982ee26a9e02f7f15", + "name": "conda-libmamba-solver", + "sha256": "26ce04f675ad99cc2d6bc06544b9fce62661133d41458a3924310f772e50b8db", + "size": 63037, + "subdir": "linux-64", + "timestamp": 1661888196150, + "version": "22.8.1" + }, + "conda-libmamba-solver-22.8.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=4.13,<22.11.0a", + "importlib_metadata", + "libmambapy >=0.23", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b5a96ec8bca425fcc99b387a9f359e92", + "name": "conda-libmamba-solver", + "sha256": "0a0f32ac6c5f2614eec79cc81f8022c05ec0868183dba6d4d5d1000b53743999", + "size": 63255, + "subdir": "linux-64", + "timestamp": 1661888274607, + "version": "22.8.1" + }, + "conda-libmamba-solver-22.8.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=4.13,<22.11.0a", + "importlib_metadata", + "libmambapy >=0.23", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a61de1db7a8251d2c86ad24b99e9ee39", + "name": "conda-libmamba-solver", + "sha256": "439ce96954bea2cca2eda20ef0143c09430c3723d8f4cb873fe76393f84550f3", + "size": 63250, + "subdir": "linux-64", + "timestamp": 1661888309953, + "version": "22.8.1" + }, + "conda-libmamba-solver-23.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=22.11.0,<23.2.0a", + "importlib-metadata", + "libmambapy >=1.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "434de0cf81335a8ede4d95c3e7996627", + "name": "conda-libmamba-solver", + "sha256": "ebe4e0eb2ed04bd375f85373245db5aa31b92fa7e0ce457cdf642af86849fde5", + "size": 65616, + "subdir": "linux-64", + "timestamp": 1676391150802, + "version": "23.1.0" + }, + "conda-libmamba-solver-23.1.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=22.11.0,<23.2.0a", + "importlib-metadata", + "libmambapy >=1.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9de87b30541d938fc59009b98de045f4", + "name": "conda-libmamba-solver", + "sha256": "d74e68ff3c82baeacc03957d00b4645c143c00e52a3f57571f3c5808e0792c1c", + "size": 83459, + "subdir": "linux-64", + "timestamp": 1676851372601, + "version": "23.1.0" + }, + "conda-libmamba-solver-23.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=22.11.0,<23.2.0a", + "importlib-metadata", + "libmambapy >=1.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "de7440faabe7aa3b0cfceae605abc8a7", + "name": "conda-libmamba-solver", + "sha256": "f37916202f349d6a986dbb2b29c04500e2250bcfd9aed19bee1d4ae3cb7fb324", + "size": 65064, + "subdir": "linux-64", + "timestamp": 1676391251173, + "version": "23.1.0" + }, + "conda-libmamba-solver-23.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=22.11.0,<23.2.0a", + "importlib-metadata", + "libmambapy >=1.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88fa08ee9f513419151e6713672aab4c", + "name": "conda-libmamba-solver", + "sha256": "d9b909486363d7461fbb7bb7fee6c84db8452e4e66cf05ca8ab8818fb920af8b", + "size": 65118, + "subdir": "linux-64", + "timestamp": 1676391184564, + "version": "23.1.0" + }, + "conda-libmamba-solver-23.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "conda >=22.11.0,<23.2.0a", + "importlib-metadata", + "libmambapy >=1.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5d0e7a7c5ed02dc32d52d7c3ea3f6d30", + "name": "conda-libmamba-solver", + "sha256": "dd4b0b677d2858c050eaefeb4bd57c214d35105f508299631ffee73f995cd1ac", + "size": 65161, + "subdir": "linux-64", + "timestamp": 1676391217852, + "version": "23.1.0" + }, + "conda-libmamba-solver-23.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "boltons >=23.0.0", + "conda >=23.3.1", + "libmambapy >=1.4.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "796e8938830360f93a2332738ee64918", + "name": "conda-libmamba-solver", + "sha256": "fe998065943a3b3eb4b1f018970f15afda07888d69ad51d92630b9b6c65da851", + "size": 67459, + "subdir": "linux-64", + "timestamp": 1680589509902, + "version": "23.3.0" + }, + "conda-libmamba-solver-23.3.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "boltons >=23.0.0", + "conda >=23.3.1", + "libmambapy >=1.4.1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4ae6e91dfa175fd2b653e637c02cac42", + "name": "conda-libmamba-solver", + "sha256": "1c54a159b96538adf8ea4ab580ee2a96b02353f8127bc83b2469d8f421ae1e78", + "size": 86626, + "subdir": "linux-64", + "timestamp": 1680589594402, + "version": "23.3.0" + }, + "conda-libmamba-solver-23.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "boltons >=23.0.0", + "conda >=23.3.1", + "libmambapy >=1.4.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f051c88a001a0731f78c10b74e4a9350", + "name": "conda-libmamba-solver", + "sha256": "e85579aa376ed8032c8f5056358a9cf75cc2e716d2d73ac572c60784616b01d4", + "size": 66992, + "subdir": "linux-64", + "timestamp": 1680589552470, + "version": "23.3.0" + }, + "conda-libmamba-solver-23.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "boltons >=23.0.0", + "conda >=23.3.1", + "libmambapy >=1.4.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "948d398a35998467da2c0524ae1f3762", + "name": "conda-libmamba-solver", + "sha256": "836160994e91b42f2126a92781af7d5202591c630e0d6f24924f0c49160ae3e7", + "size": 66999, + "subdir": "linux-64", + "timestamp": 1680589468014, + "version": "23.3.0" + }, + "conda-lock-1.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol-with-filecache >=0.12.9", + "cachy >=0.3.0", + "click >=8.0", + "click-default-group", + "clikit >=0.6.2", + "crashtest >=0.3.0", + "ensureconda >=1.3", + "filelock >=3.8.0", + "html5lib >=1.0", + "jinja2", + "keyring >=21.2.0", + "packaging >=20.4", + "pkginfo >=1.4", + "pydantic >=1.8.1", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.1", + "requests >=2.18", + "ruamel.yaml", + "tomli", + "tomlkit >=0.7.0", + "toolz >=0.12.0,<1.0.0", + "typing_extensions", + "virtualenv >=20.0.26" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "287f83c9645e60a5671f6d0a3748424b", + "name": "conda-lock", + "sha256": "7f2b31cec6e7b0ef6cf93b1890700f3d62a0147ac1317ddc26a95a9781ce1b98", + "size": 1917014, + "subdir": "linux-64", + "timestamp": 1676368399126, + "version": "1.4.0" + }, + "conda-lock-1.4.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol-with-filecache >=0.12.9", + "cachy >=0.3.0", + "click >=8.0", + "click-default-group", + "clikit >=0.6.2", + "crashtest >=0.3.0", + "ensureconda >=1.3", + "filelock >=3.8.0", + "html5lib >=1.0", + "jinja2", + "keyring >=21.2.0", + "packaging >=20.4", + "pkginfo >=1.4", + "pydantic >=1.8.1", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.1", + "requests >=2.18", + "ruamel.yaml", + "tomlkit >=0.7.0", + "toolz >=0.12.0,<1.0.0", + "typing_extensions", + "virtualenv >=20.0.26" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d08ef7646ee358f775edb28753f204f", + "name": "conda-lock", + "sha256": "00d0c3a9154482e3e4fb10d639b511616de3ff783e487c2856c0f457f8036aeb", + "size": 2325214, + "subdir": "linux-64", + "timestamp": 1679517262114, + "version": "1.4.0" + }, + "conda-lock-1.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol-with-filecache >=0.12.9", + "cachy >=0.3.0", + "click >=8.0", + "click-default-group", + "clikit >=0.6.2", + "crashtest >=0.3.0", + "ensureconda >=1.3", + "filelock >=3.8.0", + "html5lib >=1.0", + "importlib-metadata >=1.7.0", + "jinja2", + "keyring >=21.2.0", + "packaging >=20.4", + "pkginfo >=1.4", + "pydantic >=1.8.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "requests >=2.18", + "ruamel.yaml", + "tomli", + "tomlkit >=0.7.0", + "toolz >=0.12.0,<1.0.0", + "typing_extensions", + "virtualenv >=20.0.26" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8fd8f049a1e96e496f013c6e804b61fa", + "name": "conda-lock", + "sha256": "e07b52f05514a47d58b0b0cabdf490609c5c34f88a582141267eb55cbb58504d", + "size": 1880539, + "subdir": "linux-64", + "timestamp": 1676368489269, + "version": "1.4.0" + }, + "conda-lock-1.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol-with-filecache >=0.12.9", + "cachy >=0.3.0", + "click >=8.0", + "click-default-group", + "clikit >=0.6.2", + "crashtest >=0.3.0", + "ensureconda >=1.3", + "filelock >=3.8.0", + "html5lib >=1.0", + "jinja2", + "keyring >=21.2.0", + "packaging >=20.4", + "pkginfo >=1.4", + "pydantic >=1.8.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "requests >=2.18", + "ruamel.yaml", + "tomli", + "tomlkit >=0.7.0", + "toolz >=0.12.0,<1.0.0", + "typing_extensions", + "virtualenv >=20.0.26" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d6d5ef7b3fb163dfbefc5fa71d842697", + "name": "conda-lock", + "sha256": "aa43a4ccc739e6968d7562e2357d73a1584c71c82246b71fc3df2ab7292366e7", + "size": 1899328, + "subdir": "linux-64", + "timestamp": 1676368354154, + "version": "1.4.0" + }, + "conda-lock-1.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol-with-filecache >=0.12.9", + "cachy >=0.3.0", + "click >=8.0", + "click-default-group", + "clikit >=0.6.2", + "crashtest >=0.3.0", + "ensureconda >=1.3", + "filelock >=3.8.0", + "html5lib >=1.0", + "jinja2", + "keyring >=21.2.0", + "packaging >=20.4", + "pkginfo >=1.4", + "pydantic >=1.8.1", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "requests >=2.18", + "ruamel.yaml", + "tomli", + "tomlkit >=0.7.0", + "toolz >=0.12.0,<1.0.0", + "typing_extensions", + "virtualenv >=20.0.26" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f0118ddf9736e1fd9be1e2be224e6dcb", + "name": "conda-lock", + "sha256": "ef58fde136aeb021c3ae3139a4061053d7e3c78c7c1dbcd69c55f7987ea41acb", + "size": 1897352, + "subdir": "linux-64", + "timestamp": 1676368443612, + "version": "1.4.0" + }, + "conda-package-handling-1.0.4-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aa39bf8f57933870f0855e8c12065d21", + "name": "conda-package-handling", + "sha256": "a10e58d9c8f9cdded5af8d5a9b4f77086d4d5f93f1cdec643a11d06161c6586c", + "size": 250895, + "subdir": "linux-64", + "timestamp": 1555080220688, + "version": "1.0.4" + }, + "conda-package-handling-1.0.4-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "11ef1c6c5f0c762351cf0672833b3dac", + "name": "conda-package-handling", + "sha256": "a7b75691c19cc53ac9e275ba2ab1aae4646ff91b76a2ad373c4dbf38488899eb", + "size": 251067, + "subdir": "linux-64", + "timestamp": 1555080380152, + "version": "1.0.4" + }, + "conda-package-handling-1.0.4-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7617026e15e5e29337afd26d0c94e989", + "name": "conda-package-handling", + "sha256": "4540344057770fc7ad9a5353d79d1962e40db013e3f9a32d1cdc114beab96d4f", + "size": 251019, + "subdir": "linux-64", + "timestamp": 1555080218325, + "version": "1.0.4" + }, + "conda-package-handling-1.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7b6865a01e842cfc137a1809f5bacd76", + "name": "conda-package-handling", + "sha256": "a0ee2f96687936dbe4578adb92c682ec1981430edb19df5395d047dede6e9234", + "size": 249920, + "subdir": "linux-64", + "timestamp": 1557514388864, + "version": "1.1.0" + }, + "conda-package-handling-1.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "06d38a19336353ac12f6b475b5ed6d09", + "name": "conda-package-handling", + "sha256": "852338906d427de09587b202bc42ae1c693662f64966aa5d4a6188d016c0e415", + "size": 250695, + "subdir": "linux-64", + "timestamp": 1557514410810, + "version": "1.1.0" + }, + "conda-package-handling-1.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1964eda40d9c9f05012b4080104ddebe", + "name": "conda-package-handling", + "sha256": "72db5975d6709822d3ce0357947f4bd20a64c240ada2444bf160e467016c0ab3", + "size": 250641, + "subdir": "linux-64", + "timestamp": 1557514372669, + "version": "1.1.0" + }, + "conda-package-handling-1.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8b204270c26c58ef89d6796c86de0f93", + "name": "conda-package-handling", + "sha256": "52651fd6061dec7ba32c4295fcf0153d53bca129be740d6dfd0655e3af7123be", + "size": 250575, + "subdir": "linux-64", + "timestamp": 1558113604884, + "version": "1.1.1" + }, + "conda-package-handling-1.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3551ca59ff9f55d02530e25babdf5922", + "name": "conda-package-handling", + "sha256": "8aa48fe5f3e4b49930149483d7d120f7fa941806df0a46f9ef32e8220cce2b26", + "size": 250741, + "subdir": "linux-64", + "timestamp": 1558113606980, + "version": "1.1.1" + }, + "conda-package-handling-1.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e2266a3cc5bf444e716ab4809a12c548", + "name": "conda-package-handling", + "sha256": "b2aca35198f75eb4053bb75057eb72513eff792dcc662565d9edb0040d08672b", + "size": 250116, + "subdir": "linux-64", + "timestamp": 1558113471112, + "version": "1.1.1" + }, + "conda-package-handling-1.1.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "efe27578e1d365504bf6f9d0fb96919f", + "name": "conda-package-handling", + "sha256": "ded5c33ec7114e1ea899844990fc5bc88b1fed29d1daf0feaf0ee14ba4be87a6", + "size": 252267, + "subdir": "linux-64", + "timestamp": 1558467517628, + "version": "1.1.5" + }, + "conda-package-handling-1.1.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "650b9a4d34a3f65b9d5da62d786b40dc", + "name": "conda-package-handling", + "sha256": "78be123173246948d3fc97c49d06d314b191c6567257ca26c8970258b2dab965", + "size": 252549, + "subdir": "linux-64", + "timestamp": 1558467540372, + "version": "1.1.5" + }, + "conda-package-handling-1.1.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c2e4c12d06c2a9ee9c927e64ba60be6c", + "name": "conda-package-handling", + "sha256": "90966d4ed2c53e8b5a05537686ecbebca85385369306df2648bf441cc0ef3bb6", + "size": 253506, + "subdir": "linux-64", + "timestamp": 1558467503260, + "version": "1.1.5" + }, + "conda-package-handling-1.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "36cdc12b2525e5a4c1ec0fe07001144f", + "name": "conda-package-handling", + "sha256": "e2f73c3a2acdf8a6b22fe6c23e1deb411059c858ea7e460c9cbd584733476601", + "size": 254284, + "subdir": "linux-64", + "timestamp": 1560193104523, + "version": "1.3.0" + }, + "conda-package-handling-1.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "151a5ef593f9fff9a2d0ea91a439ef69", + "name": "conda-package-handling", + "sha256": "c7e86adc42c167d494ac9c3a046b21e398fbf6d6128873dd12d3c96de2798277", + "size": 254612, + "subdir": "linux-64", + "timestamp": 1560193118048, + "version": "1.3.0" + }, + "conda-package-handling-1.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c3aaee54fa8a0620c2cbcab1aeecb18d", + "name": "conda-package-handling", + "sha256": "3a63fbfca9283d7a2e3e15f6377aabc2e2e4d0e5e0311c9e883c4daaa6f1027d", + "size": 254535, + "subdir": "linux-64", + "timestamp": 1560193090492, + "version": "1.3.0" + }, + "conda-package-handling-1.3.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a824a98080ee337024095160cad5a602", + "name": "conda-package-handling", + "sha256": "21353a79829d007034fd0ed4d3c8f367ff36cc5dc07e62cd1cdd77c8f0235922", + "size": 260995, + "subdir": "linux-64", + "timestamp": 1561405898197, + "version": "1.3.10" + }, + "conda-package-handling-1.3.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fda3d3dac50e771513245f6f5139a089", + "name": "conda-package-handling", + "sha256": "ac05dc98981676d74157eccc8b846a03210d0a7390acde8a98e3f5cad3290261", + "size": 261241, + "subdir": "linux-64", + "timestamp": 1561405919974, + "version": "1.3.10" + }, + "conda-package-handling-1.3.10-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c0ef1b03b4f5fce6a7920817466587fe", + "name": "conda-package-handling", + "sha256": "a15a23edf648404543864b484419816635a5f7896d8dd8abd882a4ca0ac54eef", + "size": 261155, + "subdir": "linux-64", + "timestamp": 1561405880363, + "version": "1.3.10" + }, + "conda-package-handling-1.3.11-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b8dbb12d06302e0bc14b7452d0a5d38b", + "name": "conda-package-handling", + "sha256": "7a6f0edb6aa896f71eaa3c2916608c61ff9359097a7b13459e54072774f5e6a2", + "size": 261343, + "subdir": "linux-64", + "timestamp": 1562853199859, + "version": "1.3.11" + }, + "conda-package-handling-1.3.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6f3ef146b739cdfc17c4fa4fcc2b4f68", + "name": "conda-package-handling", + "sha256": "e736bbfc00da5d5d99457bdc46b2bb15c0de0a623e03e2bb9d69dbb92e4441cb", + "size": 262551, + "subdir": "linux-64", + "timestamp": 1562853286073, + "version": "1.3.11" + }, + "conda-package-handling-1.3.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8b55be948c55479021f2521f9407aaea", + "name": "conda-package-handling", + "sha256": "72a605eae3a2dec60e8168748f8291a2a758b17a964e55ed79c1a6bfaebcb93d", + "size": 262443, + "subdir": "linux-64", + "timestamp": 1562853266422, + "version": "1.3.11" + }, + "conda-package-handling-1.3.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "baadc12408f66934bb1e65cfbc0e633b", + "name": "conda-package-handling", + "sha256": "abd4cd19afee9071c10c3440d09ff1586fd042db55ccae4c81da36eed7972e0b", + "size": 260576, + "subdir": "linux-64", + "timestamp": 1560362661478, + "version": "1.3.6" + }, + "conda-package-handling-1.3.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7d0caec1c743559cf575aebce2fb6840", + "name": "conda-package-handling", + "sha256": "d753375ee3f9b8d6c9bc07047ca6764de8bbbbd0ba0f7097053d0bd11d8699da", + "size": 260877, + "subdir": "linux-64", + "timestamp": 1560362684905, + "version": "1.3.6" + }, + "conda-package-handling-1.3.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85d21c32f63302b4b67ee4044c268294", + "name": "conda-package-handling", + "sha256": "08d81ff97615d88d5fc47af1ce607c6034d8fa8b263e71e7af67d75a848b14a7", + "size": 260607, + "subdir": "linux-64", + "timestamp": 1560362628844, + "version": "1.3.6" + }, + "conda-package-handling-1.3.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "831a181e12219970a268519ce583b3ca", + "name": "conda-package-handling", + "sha256": "e03453859a81c684d1af20a969f9df8e8f7b6a150f54e65b2d277cb81d9b99ca", + "size": 261125, + "subdir": "linux-64", + "timestamp": 1560377356826, + "version": "1.3.7" + }, + "conda-package-handling-1.3.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff6d60d92a62d274e2eb191ce018897b", + "name": "conda-package-handling", + "sha256": "966bbe25b52bb7a09c5997629f154c149c34cc31e375c1c68987fc8a655d4be1", + "size": 261221, + "subdir": "linux-64", + "timestamp": 1560377372426, + "version": "1.3.7" + }, + "conda-package-handling-1.3.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d98232b1acd00f246e588aac1ba82179", + "name": "conda-package-handling", + "sha256": "7c346f31b70bc09be1574f9a72c1eb321cf1e051ba7d1e16e2ab748d71e76d04", + "size": 261234, + "subdir": "linux-64", + "timestamp": 1560377341115, + "version": "1.3.7" + }, + "conda-package-handling-1.3.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "libarchive >=3.3.3", + "python >=2.7,<2.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cbfa470fa029daf6a48ef0f5009b0957", + "name": "conda-package-handling", + "sha256": "edb00f3f685ea928e9ecf8b96f8e0979c532f243c56fb85d19d25f4ddd9999c1", + "size": 260968, + "subdir": "linux-64", + "timestamp": 1560550856734, + "version": "1.3.9" + }, + "conda-package-handling-1.3.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.6,<3.7.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9d63389cf16042c66c7b7621019177ae", + "name": "conda-package-handling", + "sha256": "e3c913ef061d88ee24a18d3c490855c390eb0353185ed9d823a55bec3cb158fc", + "size": 261138, + "subdir": "linux-64", + "timestamp": 1560550867849, + "version": "1.3.9" + }, + "conda-package-handling-1.3.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libarchive >=3.3.3", + "python >=3.7,<3.8.0a0", + "python-libarchive-c", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2e4b227d944ae61b2f2c367a1b9f6dbf", + "name": "conda-package-handling", + "sha256": "397d615ca7dd4b3e13cc804f17d0240a9fdb2c0aa69db5366aa5d69f7d050aba", + "size": 261068, + "subdir": "linux-64", + "timestamp": 1560550824583, + "version": "1.3.9" + }, + "conda-package-handling-1.6.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "futures", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "441227c8b9c54dce634296b36d667c88", + "name": "conda-package-handling", + "sha256": "74fc12e922fe69177776be9c978f96f31b6dadafc4d2be43a3b534bf43024893", + "size": 816219, + "subdir": "linux-64", + "timestamp": 1569013516602, + "version": "1.6.0" + }, + "conda-package-handling-1.6.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "daa491af616faef8cb4bd014c1d854c1", + "name": "conda-package-handling", + "sha256": "70c212e1f0ba436b25311174942107766a63082170993f059e81693729f683ac", + "size": 813695, + "subdir": "linux-64", + "timestamp": 1569013524221, + "version": "1.6.0" + }, + "conda-package-handling-1.6.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d409005b22f5f007f3595a1cca8cbe37", + "name": "conda-package-handling", + "sha256": "3a08332c9201b59cc189cc900421d95cb99f06f1271281c0e5a555f7945b0523", + "size": 815702, + "subdir": "linux-64", + "timestamp": 1569013549041, + "version": "1.6.0" + }, + "conda-package-handling-1.6.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e709df06b774ce0368c2e96de9e5db96", + "name": "conda-package-handling", + "sha256": "38f1dac21e48d85168ecdb78e383cc9d00448a7f2833b707303bcf0c3e7fafd3", + "size": 812997, + "subdir": "linux-64", + "timestamp": 1573738178544, + "version": "1.6.0" + }, + "conda-package-handling-1.6.1-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "78e87ad2435d604c997333de333fd28b", + "name": "conda-package-handling", + "sha256": "6c646769122311a5d12bfa98012facfdf11e19356d0c007d2b6c727f7ded1fec", + "size": 839989, + "subdir": "linux-64", + "timestamp": 1641560745375, + "version": "1.6.1" + }, + "conda-package-handling-1.6.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "12eccdbf409ec3df53c0285f966e58e9", + "name": "conda-package-handling", + "sha256": "c802c53e05d2f5d458b770f84a8a222e2ea8831f4f3539b98e45b4ede0470417", + "size": 815841, + "subdir": "linux-64", + "timestamp": 1588797872636, + "version": "1.6.1" + }, + "conda-package-handling-1.6.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0d2c30e803dd2eda27fca35ea4f7ef43", + "name": "conda-package-handling", + "sha256": "1987aeb9ad29c70a11427e006499ca2139363319664d4e46224d27fe51115df8", + "size": 817037, + "subdir": "linux-64", + "timestamp": 1588797879755, + "version": "1.6.1" + }, + "conda-package-handling-1.6.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4f0201091509cf223466e74755745fb2", + "name": "conda-package-handling", + "sha256": "1c51bb4f759a653e5a8a60475b45c8df85861d3835748dec3ccb5fa7cff2a947", + "size": 818681, + "subdir": "linux-64", + "timestamp": 1588797905445, + "version": "1.6.1" + }, + "conda-package-handling-1.7.2-py36h03888b9_0.conda": { + "build": "py36h03888b9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8bdbc5e0c104356fcb42cb90cb29c5a8", + "name": "conda-package-handling", + "sha256": "3027705abc47148c7916adc7cc2b5551c326f6aea6d49145351b6723b9a272b8", + "size": 907034, + "subdir": "linux-64", + "timestamp": 1603018179849, + "version": "1.7.2" + }, + "conda-package-handling-1.7.2-py37h03888b9_0.conda": { + "build": "py37h03888b9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b40017a82a7a2280534e9f8d161d6727", + "name": "conda-package-handling", + "sha256": "4d1b157b6c39daf89ddc933a415e31973f275b3fd5814bfcda25f504d86ffc38", + "size": 905957, + "subdir": "linux-64", + "timestamp": 1603018174342, + "version": "1.7.2" + }, + "conda-package-handling-1.7.2-py38h03888b9_0.conda": { + "build": "py38h03888b9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "df032e2352df3401843d7eb432dda704", + "name": "conda-package-handling", + "sha256": "6c961631a89ed8e1bebfca49ff944f7e235311f1ae8c3076598b8e58663380eb", + "size": 907291, + "subdir": "linux-64", + "timestamp": 1603018175363, + "version": "1.7.2" + }, + "conda-package-handling-1.7.2-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f1bf657d58268dac1cffd37bca12cd01", + "name": "conda-package-handling", + "sha256": "2196c245bbab996d591435916135a83229676ddeeb20f14a2f2903b6f09ac1df", + "size": 907747, + "subdir": "linux-64", + "timestamp": 1605484883832, + "version": "1.7.2" + }, + "conda-package-handling-1.7.3-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fbdddc9db7c248b5c18777c7e8e459f7", + "name": "conda-package-handling", + "sha256": "c401aebedf2378f16da0d9c13928b3c2f5c85f91d293f0f63f6807d60b298091", + "size": 929529, + "subdir": "linux-64", + "timestamp": 1641551805944, + "version": "1.7.3" + }, + "conda-package-handling-1.7.3-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5cb085c4a7157ac102cd5997fe16a58b", + "name": "conda-package-handling", + "sha256": "88b75faf8a42d4a52b8fc590af565f87935d7e6f5477857c34a52fdf1e12221f", + "size": 903150, + "subdir": "linux-64", + "timestamp": 1618262209227, + "version": "1.7.3" + }, + "conda-package-handling-1.7.3-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2bdff5ba4d6bfb1acd2b9b253d2046d9", + "name": "conda-package-handling", + "sha256": "57d6cc4cba4c9103af11f91b0e4c5b4c7609c8a5afa707f682c6b16164403ad5", + "size": 901858, + "subdir": "linux-64", + "timestamp": 1618262198695, + "version": "1.7.3" + }, + "conda-package-handling-1.7.3-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "58e44cbd56afd4bba804dac10c62eeb1", + "name": "conda-package-handling", + "sha256": "8f30aa8aa0306ff5ef871754ae7f7913516512f35126a213f426dac4401b9f75", + "size": 905081, + "subdir": "linux-64", + "timestamp": 1618262197070, + "version": "1.7.3" + }, + "conda-package-handling-1.7.3-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "six", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20631b5b77d257cecd8375cdcc1f30bf", + "name": "conda-package-handling", + "sha256": "8e3e4668f0418286a47da12510b4af2b57e9af25dc3f6c4bfd87b14ea03ced63", + "size": 904754, + "subdir": "linux-64", + "timestamp": 1618262196863, + "version": "1.7.3" + }, + "conda-package-handling-1.8.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "091ba62d38745e1e79c071097eb67034", + "name": "conda-package-handling", + "sha256": "51843f2a6938ba9e0da95b0dec75fc80ced4c36556a71195ebd84eefa7942fe0", + "size": 933272, + "subdir": "linux-64", + "timestamp": 1647948763841, + "version": "1.8.0" + }, + "conda-package-handling-1.8.0-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "581713aefec3967d6a569252c3529a9c", + "name": "conda-package-handling", + "sha256": "9a2ae2a4fe677faa09df90af2ee75ede034ae72e4426f8ece3ced5e4fb7fc91e", + "size": 905644, + "subdir": "linux-64", + "timestamp": 1647948828506, + "version": "1.8.0" + }, + "conda-package-handling-1.8.0-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9d6d4c0f99027f9c71e21958ba1a0339", + "name": "conda-package-handling", + "sha256": "1b505b4343652b4276647b71aa3ad2874e4d5dee1e1efec96d4274f51c4acdd3", + "size": 905905, + "subdir": "linux-64", + "timestamp": 1647948795799, + "version": "1.8.0" + }, + "conda-package-handling-1.8.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6312878ef1066d2cbea5fea1d04259a2", + "name": "conda-package-handling", + "sha256": "e382bce54c6ed496c8a3f9eedca655c4f23370c84e4f047cc36d81d6857ae58a", + "size": 906208, + "subdir": "linux-64", + "timestamp": 1647948869367, + "version": "1.8.0" + }, + "conda-package-handling-1.8.1-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cbb591ef98a2dcbb8d5ace51cb0523ac", + "name": "conda-package-handling", + "sha256": "28dbd1d345bc243cc71aa234cddb719a0a81ddd630f1ed71831b44826204b206", + "size": 940218, + "subdir": "linux-64", + "timestamp": 1649087714922, + "version": "1.8.1" + }, + "conda-package-handling-1.8.1-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a44468ba2c7b8307afc932cb2cb50da4", + "name": "conda-package-handling", + "sha256": "3247fef2d15a4aa6b9c49850326f45c03ac824a431d916323207b339faa8ff47", + "size": 909833, + "subdir": "linux-64", + "timestamp": 1649105836092, + "version": "1.8.1" + }, + "conda-package-handling-1.8.1-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8eb9801368ace2e9f2c3fac90f349c36", + "name": "conda-package-handling", + "sha256": "fa067068e64df788c86ff0a183dfd9db15b7c464c74a494a4a86f4dab2859bfe", + "size": 906244, + "subdir": "linux-64", + "timestamp": 1649087967826, + "version": "1.8.1" + }, + "conda-package-handling-1.8.1-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9803e6734c340cdca615f01176efbdaa", + "name": "conda-package-handling", + "sha256": "6f4c3dd019849f469865071b5655d49a2664d3244de951b7fccb6a4b1118b7e0", + "size": 910216, + "subdir": "linux-64", + "timestamp": 1649105826585, + "version": "1.8.1" + }, + "conda-package-handling-1.9.0-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3b2b606ba8c96daf0ed0dd9a3ef9f4cd", + "name": "conda-package-handling", + "sha256": "f56e4c4d3ed1f41e8a83d371fec3cc0336d082cd41be7612d2d8c316926d54ea", + "size": 939446, + "subdir": "linux-64", + "timestamp": 1663598536095, + "version": "1.9.0" + }, + "conda-package-handling-1.9.0-py310h5eee18b_1.conda": { + "build": "py310h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8d6001e179ffa7981a49a6747356d66d", + "name": "conda-package-handling", + "sha256": "6f33b432b1ac53a6e87bf336acaa4873ae16b02664fee0b7672d75267f750e4c", + "size": 968526, + "subdir": "linux-64", + "timestamp": 1666940480817, + "version": "1.9.0" + }, + "conda-package-handling-1.9.0-py311h5eee18b_1.conda": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a35743ff273319885c41049eec34be33", + "name": "conda-package-handling", + "sha256": "42eaa9dfdce48fd0a713116e5786045f396b1aa0fd0aa398db40b7b32391c00d", + "size": 975323, + "subdir": "linux-64", + "timestamp": 1676830322959, + "version": "1.9.0" + }, + "conda-package-handling-1.9.0-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ec26099b1797e8723d0ecb2b5a13698", + "name": "conda-package-handling", + "sha256": "e8ac4928f9fb356299a8832a804380fe7b6010ac8395bec829cfcc1f24ef7f1d", + "size": 908098, + "subdir": "linux-64", + "timestamp": 1663598570791, + "version": "1.9.0" + }, + "conda-package-handling-1.9.0-py37h5eee18b_1.conda": { + "build": "py37h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f55bbc0ed4cf205c598685ee6a1ffdba", + "name": "conda-package-handling", + "sha256": "d803e47cb3125c4be3876a9d3045d0c27158ef18d343534e37f493d89e798ff2", + "size": 968010, + "subdir": "linux-64", + "timestamp": 1666940515292, + "version": "1.9.0" + }, + "conda-package-handling-1.9.0-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4e726637b7a193ed15b51a82dd18b3c1", + "name": "conda-package-handling", + "sha256": "714b4286d634b21a07cde1fb0a7fc7be72bd2719749b0dcaaf5523acb026a540", + "size": 907820, + "subdir": "linux-64", + "timestamp": 1663598640269, + "version": "1.9.0" + }, + "conda-package-handling-1.9.0-py38h5eee18b_1.conda": { + "build": "py38h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "62bb7abdf7256d7265ac34ba27b2d443", + "name": "conda-package-handling", + "sha256": "1e58dd0fafb38e5b107ab20eab30d88bcbfc1aa9dc5d2c69be0acf2508d87490", + "size": 968276, + "subdir": "linux-64", + "timestamp": 1666940446492, + "version": "1.9.0" + }, + "conda-package-handling-1.9.0-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "09d82c246f6e451aa90a7ba135e14679", + "name": "conda-package-handling", + "sha256": "a05ad13bc2527852916b589148d10e5a505477e7a996bd5df0b91ffa8027571f", + "size": 908636, + "subdir": "linux-64", + "timestamp": 1663598606324, + "version": "1.9.0" + }, + "conda-package-handling-1.9.0-py39h5eee18b_1.conda": { + "build": "py39h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8c0e42471873c4bdd08cf726f95f4cf8", + "name": "conda-package-handling", + "sha256": "0497094402cdcb09bd2c1b81baa1664725281bbe9625b4759b67d1842fbb9900", + "size": 968391, + "subdir": "linux-64", + "timestamp": 1666940411960, + "version": "1.9.0" + }, + "conda-package-handling-2.0.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "conda-package-streaming >=0.7.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "64566e4e128101c78fb70c70c750b504", + "name": "conda-package-handling", + "sha256": "c85b6437d2ee3562bfca72a94e2ebfe93d23e540ba36b7ae8dc1568c7bf74a31", + "size": 273679, + "subdir": "linux-64", + "timestamp": 1672865052883, + "version": "2.0.2" + }, + "conda-package-handling-2.0.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "conda-package-streaming >=0.7.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dcba74ec32fb4ca7accea772190303eb", + "name": "conda-package-handling", + "sha256": "5b6b43d42f9fbe643213c481f36ca3668539b3a3d302385f119d6f34d13c2be3", + "size": 279019, + "subdir": "linux-64", + "timestamp": 1679335570289, + "version": "2.0.2" + }, + "conda-package-handling-2.0.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "conda-package-streaming >=0.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "62c5508c096ece114695b5c9c66fb4a7", + "name": "conda-package-handling", + "sha256": "998df84aafd4f34139ed0024a004f44b30584007cd8939d4b9c109ca6c117a57", + "size": 273221, + "subdir": "linux-64", + "timestamp": 1672865090336, + "version": "2.0.2" + }, + "conda-package-handling-2.0.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "conda-package-streaming >=0.7.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "53061f0d5bcd0d2e6d3f9aca96593a94", + "name": "conda-package-handling", + "sha256": "35335b95110fc0fabcb29d39af77b1926e1b424b2156af9fc2506e522560b247", + "size": 273308, + "subdir": "linux-64", + "timestamp": 1672865164367, + "version": "2.0.2" + }, + "conda-package-handling-2.0.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "conda-package-streaming >=0.7.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fc08454e3055d6cff2b458740e3eafc5", + "name": "conda-package-handling", + "sha256": "fa37f3c25609e39bcd888bd962fbca32645910c5fa646044a104f5d7ca1cf7eb", + "size": 273346, + "subdir": "linux-64", + "timestamp": 1672865127636, + "version": "2.0.2" + }, + "conda-package-streaming-0.7.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "zstandard >=0.15" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "323eb92af9fe159497108382a2aa3c7d", + "name": "conda-package-streaming", + "sha256": "4470d0094a7ddc7aa7986277b66e17936db23c743c6c294e3af615c35779b0fe", + "size": 27205, + "subdir": "linux-64", + "timestamp": 1670508260420, + "version": "0.7.0" + }, + "conda-package-streaming-0.7.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "zstandard >=0.15" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "80b9719168640ed8daf55a68aab1cd5f", + "name": "conda-package-streaming", + "sha256": "d3051417df0e18d84d6b330ca656e523206929371b7bf3ccb29892cae7513d60", + "size": 31651, + "subdir": "linux-64", + "timestamp": 1676843659332, + "version": "0.7.0" + }, + "conda-package-streaming-0.7.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zstandard >=0.15" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d4ae44cf768fdd98ad6a01746d816b85", + "name": "conda-package-streaming", + "sha256": "f20019aacb8d822448a48e59237728af57ab77246ba93b4d8e8fa29eef651eac", + "size": 26835, + "subdir": "linux-64", + "timestamp": 1670508207799, + "version": "0.7.0" + }, + "conda-package-streaming-0.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zstandard >=0.15" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a6ec7742a8702490bb2a5accc0acb69", + "name": "conda-package-streaming", + "sha256": "e5e4846d770b71cf44a585cd53a37316fb5ef66f4ad53a7dc900d0944a33e62d", + "size": 26889, + "subdir": "linux-64", + "timestamp": 1670508234071, + "version": "0.7.0" + }, + "conda-package-streaming-0.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "zstandard >=0.15" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0f532adc40113a3a4ef0f321a91b58ea", + "name": "conda-package-streaming", + "sha256": "796665e12c365d82bec395ee23d750f5bcc39190a0b31d2cfea9262e20dcd152", + "size": 26963, + "subdir": "linux-64", + "timestamp": 1670508181398, + "version": "0.7.0" + }, + "conda-repo-cli-1.0.20-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07561d0301fb6ed4f5565626640db5f6", + "name": "conda-repo-cli", + "sha256": "51b5f38055d178684fa1a7392ab40e8285ac7dd4c0803a2d17495463d436a153", + "size": 110224, + "subdir": "linux-64", + "timestamp": 1664263126042, + "version": "1.0.20" + }, + "conda-repo-cli-1.0.20-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "55d423a0f42bb219577cc248d9f57dd5", + "name": "conda-repo-cli", + "sha256": "26c184939cb5da34e0ddd018402317e289ffc5959fc98997f23c82be1a98c3d2", + "size": 108493, + "subdir": "linux-64", + "timestamp": 1664263161637, + "version": "1.0.20" + }, + "conda-repo-cli-1.0.20-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "159ea6c60b89f9858e84cec2d4c61bc0", + "name": "conda-repo-cli", + "sha256": "4f07b7386e03a6bebdf34750e2179f5d878f1942ee656cdc634d651b0c5307e2", + "size": 109338, + "subdir": "linux-64", + "timestamp": 1664263074171, + "version": "1.0.20" + }, + "conda-repo-cli-1.0.20-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "06ab14ca0eca5e82bb31669375d24eb3", + "name": "conda-repo-cli", + "sha256": "4d5a309695c37a6f7edf093e968024ce4894668406a156f2f23995a4227eb6b2", + "size": 109296, + "subdir": "linux-64", + "timestamp": 1664263201138, + "version": "1.0.20" + }, + "conda-repo-cli-1.0.24-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7278cc8587f0b0b1aecb726cc352b041", + "name": "conda-repo-cli", + "sha256": "e4aac5a60c5e47e674bbf4c7f099029fdede5a00a7ec208e876b24d435a19789", + "size": 118858, + "subdir": "linux-64", + "timestamp": 1667407605915, + "version": "1.0.24" + }, + "conda-repo-cli-1.0.24-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d6ecbab39f605ca22900d728a1b214d", + "name": "conda-repo-cli", + "sha256": "f51cb4b872ef2a087fff262919fa4bac190903923c13818b2a2a959881ba120e", + "size": 116657, + "subdir": "linux-64", + "timestamp": 1673359305549, + "version": "1.0.24" + }, + "conda-repo-cli-1.0.24-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "575b32c42d838d0874fb7244041f1b66", + "name": "conda-repo-cli", + "sha256": "597a1690adc6e62d9306ae52b73a89eaf341f72a16e22c9587a5da657a5fa1da", + "size": 116718, + "subdir": "linux-64", + "timestamp": 1667407533608, + "version": "1.0.24" + }, + "conda-repo-cli-1.0.24-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1114a095a4d6a480a1f3041cd19bcd5c", + "name": "conda-repo-cli", + "sha256": "4145316955fb1ac5de2ab0aaa4f659a28dc20a91374a9f1491ecb850a852b145", + "size": 114648, + "subdir": "linux-64", + "timestamp": 1673359340978, + "version": "1.0.24" + }, + "conda-repo-cli-1.0.24-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5ac0e88d118908e3c49612a88929adff", + "name": "conda-repo-cli", + "sha256": "557c5d6e6055945420ca19ecdc7159a18c606f9c94873755d1ab8b96782f03ed", + "size": 117883, + "subdir": "linux-64", + "timestamp": 1667407496712, + "version": "1.0.24" + }, + "conda-repo-cli-1.0.24-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0f32e0206177db5a9713f014d757e727", + "name": "conda-repo-cli", + "sha256": "419230591c08f78ed2bfe6c6218248c58d67baafdfba013ab1e4be9ac5bd0da2", + "size": 115733, + "subdir": "linux-64", + "timestamp": 1673359269024, + "version": "1.0.24" + }, + "conda-repo-cli-1.0.24-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "291c74c1e26c2212d2c6064d9418a158", + "name": "conda-repo-cli", + "sha256": "27e7651ed9eacf1bd104937941cf276d4884bc73ce840ea46f24895158d6e6d2", + "size": 117889, + "subdir": "linux-64", + "timestamp": 1667407570383, + "version": "1.0.24" + }, + "conda-repo-cli-1.0.24-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a9311304397a868028cc2121d8867f14", + "name": "conda-repo-cli", + "sha256": "3a949270e0a08b7b0fcc8f474ebb4330b2d44be9c3d55cf6cd0d900d031f226f", + "size": 115723, + "subdir": "linux-64", + "timestamp": 1673359376470, + "version": "1.0.24" + }, + "conda-repo-cli-1.0.27-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "994af1a38911227c6a781e0f9eada7fa", + "name": "conda-repo-cli", + "sha256": "fc66827e539afcdd1de3286bd5463130ac6622e9bee844143fbfcbec081cf393", + "size": 117816, + "subdir": "linux-64", + "timestamp": 1673448385579, + "version": "1.0.27" + }, + "conda-repo-cli-1.0.27-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d5b9b439af486e9621aeeabd77fa3969", + "name": "conda-repo-cli", + "sha256": "b69392a43853a98bf407b1bb67ce9ef99f4f8629cce33d8d88719ee2c0e358f6", + "size": 115877, + "subdir": "linux-64", + "timestamp": 1673448503840, + "version": "1.0.27" + }, + "conda-repo-cli-1.0.27-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "28a9de9ce9a0b7f9a58bf3949f5bde5f", + "name": "conda-repo-cli", + "sha256": "4a4800fd6c6b7a951af5c754782ff807fa30779380daa1738bf3d2b486ea7738", + "size": 116914, + "subdir": "linux-64", + "timestamp": 1673448463981, + "version": "1.0.27" + }, + "conda-repo-cli-1.0.27-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "61e24bfd277658e7373ff555aeb0898e", + "name": "conda-repo-cli", + "sha256": "5ff4fa793403521199db47a155265ab0c5ecdf2946e032281fb806a13a739706", + "size": 116880, + "subdir": "linux-64", + "timestamp": 1673448424989, + "version": "1.0.27" + }, + "conda-repo-cli-1.0.41-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e24663fbe4385efb0a6c6bdf71efe9e5", + "name": "conda-repo-cli", + "sha256": "235c385c045aa20bf39c831be5a50d2895bf94a9f52c651abd90ad53f9548d21", + "size": 127759, + "subdir": "linux-64", + "timestamp": 1680097362759, + "version": "1.0.41" + }, + "conda-repo-cli-1.0.41-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5c5f6c4710bdbd88b246180465b9f866", + "name": "conda-repo-cli", + "sha256": "eee3bd91b658cae5e613857c48688106f667df594c356bf401666bd0c3abefeb", + "size": 170072, + "subdir": "linux-64", + "timestamp": 1680097484072, + "version": "1.0.41" + }, + "conda-repo-cli-1.0.41-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d6013a5bb5e366d328b54e2d6722218b", + "name": "conda-repo-cli", + "sha256": "d6a075909a89d42202a519b3832aa00b1623cd6ee65a2d22ce3c691a60136b65", + "size": 126705, + "subdir": "linux-64", + "timestamp": 1680097443244, + "version": "1.0.41" + }, + "conda-repo-cli-1.0.41-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.1", + "nbformat >=5.4.0", + "pathlib", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pytz", + "pyyaml >=6.0", + "requests >=2.28.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8885ab9994f1c1ae966506e045325ff1", + "name": "conda-repo-cli", + "sha256": "87264734db9c1b85c917a0c558c6d136015d20b004698e688f4f78866cd6e925", + "size": 126678, + "subdir": "linux-64", + "timestamp": 1680097402589, + "version": "1.0.41" + }, + "conda-repo-cli-1.0.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.0", + "nbformat >=4.4.0", + "pathlib", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "24246347772e82bc1b8ed8ad1fc4f19c", + "name": "conda-repo-cli", + "sha256": "52942dcc4f61cd033c3316152d9ffc8c40c8cb624466175f676756ad1b2ca955", + "size": 108111, + "subdir": "linux-64", + "timestamp": 1658947733446, + "version": "1.0.5" + }, + "conda-repo-cli-1.0.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.0", + "nbformat >=4.4.0", + "pathlib", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4708c8322e038c21f9c62075c3a2b286", + "name": "conda-repo-cli", + "sha256": "e95b31c4bc546cf6d6615297e5622aa909698e99cbe746844db735a8dff597bb", + "size": 109102, + "subdir": "linux-64", + "timestamp": 1658947765034, + "version": "1.0.5" + }, + "conda-repo-cli-1.0.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client >=1.7.2", + "clyent >=1.2.0", + "nbformat >=4.4.0", + "pathlib", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.6.1", + "pytz", + "pyyaml >=3.12", + "requests >=2.9.1", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e57a0013370af0bae550356f32365219", + "name": "conda-repo-cli", + "sha256": "539e4383b7d06ce796d0366cf8b6080d5154480cd808b8618e6dc5c5f58fea4c", + "size": 109065, + "subdir": "linux-64", + "timestamp": 1658947796374, + "version": "1.0.5" + }, + "conda-souschef-2.2.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "ruamel.yaml >=0.15.3", + "ruamel.yaml.jinja2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "484d8a0e0fb569b621fbbaeb82d50093", + "name": "conda-souschef", + "sha256": "649fdd19e53f0dfe1d129278495a5d37b564652f7b9c36afd0182d55ffb7ea68", + "size": 30743, + "subdir": "linux-64", + "timestamp": 1676968370202, + "version": "2.2.3" + }, + "conda-souschef-2.2.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "ruamel.yaml >=0.15.3", + "ruamel.yaml.jinja2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7f0e24ad7332cc61e05bd2a195fde20d", + "name": "conda-souschef", + "sha256": "3cf6c2925e070e2137e9101db4298ab8322fe2a3b567a9db2d33774d418bec93", + "size": 30514, + "subdir": "linux-64", + "timestamp": 1676968395373, + "version": "2.2.3" + }, + "conda-souschef-2.2.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "ruamel.yaml >=0.15.3", + "ruamel.yaml.jinja2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "41607305d72da18df63699da59b5331e", + "name": "conda-souschef", + "sha256": "e4929e084e4cf6aafc669bc0f61ca314be8ba9948a1a8fc4d54433ecfb490ade", + "size": 30466, + "subdir": "linux-64", + "timestamp": 1676968420834, + "version": "2.2.3" + }, + "conda-standalone-22.11.1-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "constrains": [ + "constructor >=3.3.1" + ], + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c1216f77aea650c9b3c99623d3c2feeb", + "name": "conda-standalone", + "sha256": "c02847544ec1acec4cad91407a96f980e7b995b043873174f4014051b0eeb33e", + "size": 12017270, + "subdir": "linux-64", + "timestamp": 1670890353460, + "version": "22.11.1" + }, + "conda-standalone-22.11.1-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "constrains": [ + "constructor >=3.3.1" + ], + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "19d73a2e672cb1315b843bf082015511", + "name": "conda-standalone", + "sha256": "97ce7536de77759c8fdd3b70dfaa5318690d53562b014427b25b19b61cfeef73", + "size": 11931994, + "subdir": "linux-64", + "timestamp": 1674500941975, + "version": "22.11.1" + }, + "conda-standalone-4.10.3-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "49c3d99f6051dfb2d0d1f286d9f76bb8", + "name": "conda-standalone", + "sha256": "06b248c76eedc306e8cf7c7e2be5a502029479226ab3cd2f9691fa7bd48ae933", + "size": 15303579, + "subdir": "linux-64", + "timestamp": 1633109786877, + "version": "4.10.3" + }, + "conda-standalone-4.10.3-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4a3b5b0ee56f214efe867253be917e45", + "name": "conda-standalone", + "sha256": "bd25d63558fc0b57b55ae279199dfe518d820cda3bed6293c7dc8a436d61022c", + "size": 15837421, + "subdir": "linux-64", + "timestamp": 1636413551481, + "version": "4.10.3" + }, + "conda-standalone-4.7.12-hf0df95a_0.conda": { + "build": "hf0df95a_0", + "build_number": 0, + "depends": [], + "md5": "9c134ea45c3c7a67c41f77c08e964f16", + "name": "conda-standalone", + "sha256": "0259c2264034a38b762387a67673bb733ece2a572415352bc76852aefe9159f6", + "size": 9329335, + "subdir": "linux-64", + "timestamp": 1568651214263, + "version": "4.7.12" + }, + "conda-standalone-4.7.12-hf0df95a_1.conda": { + "build": "hf0df95a_1", + "build_number": 1, + "depends": [], + "md5": "6fecdf7f5c1d64e09e32850c78634bac", + "name": "conda-standalone", + "sha256": "e69f27886b761ef8dcf9f7a49208d3a5fecc30bbfe3db46cbee4625c60fea0ab", + "size": 9623693, + "subdir": "linux-64", + "timestamp": 1568729338995, + "version": "4.7.12" + }, + "conda-standalone-4.7.12-hf0df95a_2.conda": { + "build": "hf0df95a_2", + "build_number": 2, + "depends": [], + "md5": "85c0d203333b88296411c6396034f6c4", + "name": "conda-standalone", + "sha256": "6e5003ea35129b117b7f8450efa5bbc0a7d1edbd3e9702ab193a31a466743fa8", + "size": 9622144, + "subdir": "linux-64", + "timestamp": 1568769789325, + "version": "4.7.12" + }, + "conda-standalone-4.8.2-h2f914fc_0.conda": { + "build": "h2f914fc_0", + "build_number": 0, + "depends": [], + "md5": "4b92c65e8bf0a0020736c5c00cacf972", + "name": "conda-standalone", + "sha256": "d27c36b168a870a6df08720f6853b5b428cd1046efd0b67ebefaa291bc9fee46", + "size": 9315491, + "subdir": "linux-64", + "timestamp": 1580834950453, + "version": "4.8.2" + }, + "conda-standalone-4.8.2-h2f914fc_1.conda": { + "build": "h2f914fc_1", + "build_number": 1, + "depends": [], + "md5": "828321af1a509217e3352f6ddfca8ef6", + "name": "conda-standalone", + "sha256": "088bbe85555ff53cba6be157c7ac3533d183e058412beb8935ddd6436d920a0b", + "size": 10998143, + "subdir": "linux-64", + "timestamp": 1580839585446, + "version": "4.8.2" + }, + "conda-standalone-4.8.2-h2f914fc_2.conda": { + "build": "h2f914fc_2", + "build_number": 2, + "depends": [], + "md5": "925a8198aca34af151cc4f20e78d85c7", + "name": "conda-standalone", + "sha256": "2bec6b6c304708f0802c5448acfacfbbb3b17bf096900f1473353c7ae54a4435", + "size": 11001345, + "subdir": "linux-64", + "timestamp": 1580848493373, + "version": "4.8.2" + }, + "conda-standalone-4.8.3-h18fab7e_0.conda": { + "build": "h18fab7e_0", + "build_number": 0, + "depends": [], + "md5": "1d494c1cd8f7e2b734b5e8703798b15d", + "name": "conda-standalone", + "sha256": "261fb755d31a82caf3d4f9b9ee5f1275aeafefc167fb5c6337600d0b1a09aabe", + "size": 14689393, + "subdir": "linux-64", + "timestamp": 1588803227554, + "version": "4.8.3" + }, + "conda-standalone-4.8.3-h18fab7e_10.conda": { + "build": "h18fab7e_10", + "build_number": 10, + "depends": [], + "md5": "1753fdce7d7854c73612b18160ca13fa", + "name": "conda-standalone", + "sha256": "0a6f54a95713556ed5ee9c1ff566dc0de8091f80b99863899cc866886f9abeba", + "size": 14636966, + "subdir": "linux-64", + "timestamp": 1589825456550, + "version": "4.8.3" + }, + "conda-standalone-4.8.3-h18fab7e_11.conda": { + "build": "h18fab7e_11", + "build_number": 11, + "depends": [], + "md5": "a11f48ba0fe1c4c28f07cec7bb259f91", + "name": "conda-standalone", + "sha256": "4719714b45cd17cd741512ffe83e90979329f63961a7d6032b7b03019fa8a857", + "size": 14650736, + "subdir": "linux-64", + "timestamp": 1589923075650, + "version": "4.8.3" + }, + "conda-standalone-4.8.3-h18fab7e_3.conda": { + "build": "h18fab7e_3", + "build_number": 3, + "depends": [], + "md5": "7470f48a6ecdd2e3e95cca0791a62c25", + "name": "conda-standalone", + "sha256": "9735971bdf9939683b7aeb42ef30101dba5442ad535fc4e886bf5350627ceb76", + "size": 14650379, + "subdir": "linux-64", + "timestamp": 1589918334762, + "version": "4.8.3" + }, + "conda-standalone-4.8.3-h18fab7e_4.conda": { + "build": "h18fab7e_4", + "build_number": 4, + "depends": [], + "md5": "743698dd46678fae4d4f74a6d5d2efc5", + "name": "conda-standalone", + "sha256": "c8e22388c42308bcef303fd6a45b7979c9142bfeb0ddb12b26e0f7faf2889d93", + "size": 14637091, + "subdir": "linux-64", + "timestamp": 1589384848878, + "version": "4.8.3" + }, + "conda-standalone-4.9.0-h718eed5_1.conda": { + "build": "h718eed5_1", + "build_number": 1, + "depends": [], + "md5": "4464866d5d29d40279554a15e8854c2d", + "name": "conda-standalone", + "sha256": "4c22c1f0b166c58dee4e8fb52ac41281b89a9394d00617cdb5a82380b78661d0", + "size": 15059056, + "subdir": "linux-64", + "timestamp": 1603137739878, + "version": "4.9.0" + }, + "conda-standalone-4.9.0-h7965325_0.conda": { + "build": "h7965325_0", + "build_number": 0, + "depends": [], + "md5": "faab6f1d32fe18ebc9daa8a4741b2a54", + "name": "conda-standalone", + "sha256": "4437fca2419d98570908af573125793c17c85961d9162445a8b3a494295ece21", + "size": 15059382, + "subdir": "linux-64", + "timestamp": 1603060614871, + "version": "4.9.0" + }, + "conda-verify-2.0.0-py27hf052a9d_0.conda": { + "build": "py27hf052a9d_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "33a0d43baf67a93840842a225ce0c628", + "name": "conda-verify", + "sha256": "1f560f654178a1b451efd592ccada0d4a6d8122815448f75c8d0299ab24b2258", + "size": 21793, + "subdir": "linux-64", + "timestamp": 1505742312436, + "version": "2.0.0" + }, + "conda-verify-2.0.0-py35he912c7b_0.conda": { + "build": "py35he912c7b_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "f82301d0fcfc447ff6c5977080e30eab", + "name": "conda-verify", + "sha256": "48a120854d00d4c5aa5d4853c3a5858649d2ee4d39d0d0970c324280feae4e2b", + "size": 22303, + "subdir": "linux-64", + "timestamp": 1505742324402, + "version": "2.0.0" + }, + "conda-verify-2.0.0-py36h98955d8_0.conda": { + "build": "py36h98955d8_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "4cb20778bb554a3aa5567ce894f62e47", + "name": "conda-verify", + "sha256": "16ffb2adbd18ed0323626b8d90c316bba15bfc870769a1c233a6470b7590c0df", + "size": 21836, + "subdir": "linux-64", + "timestamp": 1505742336674, + "version": "2.0.0" + }, + "conda-verify-3.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "click", + "jinja2", + "python >=2.7,<2.8.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "a4b59307a1e65497a0a2014115f30b7f", + "name": "conda-verify", + "sha256": "c10cbc1c94efcc330b13329a731abcec508c022b32dabfff899c8a77169318dc", + "size": 34495, + "subdir": "linux-64", + "timestamp": 1530813512607, + "version": "3.0.0" + }, + "conda-verify-3.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click", + "jinja2", + "python >=3.6,<3.7.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "ad96ec6d53f699059fb03f4e8444e60b", + "name": "conda-verify", + "sha256": "1ac61633a0beb94e5d79035a8c13b8508cd57fc1f3eccf9bc49da758a0ad2066", + "size": 34623, + "subdir": "linux-64", + "timestamp": 1530813538779, + "version": "3.0.0" + }, + "conda-verify-3.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click", + "jinja2", + "python >=3.7,<3.8.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "444c91a421f7f368a7581ed6bf78b2f2", + "name": "conda-verify", + "sha256": "159534cc47f6db817a035ef7fe0398541cffe7946256c880bb44c9aeb76ccb06", + "size": 34296, + "subdir": "linux-64", + "timestamp": 1530813486216, + "version": "3.0.0" + }, + "conda-verify-3.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "click", + "future", + "jinja2", + "python >=2.7,<2.8.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "1bcaf8c6a36438bd553affe520c6abc1", + "name": "conda-verify", + "sha256": "386f9cee92e72e3cc85146b345e79029a9ca0f3d89503c1296aac1ef02dd9fc7", + "size": 32874, + "subdir": "linux-64", + "timestamp": 1532368520141, + "version": "3.0.2" + }, + "conda-verify-3.0.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click", + "future", + "jinja2", + "python >=3.5,<3.6.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "90806a892399d4da4741e58b0b05b572", + "name": "conda-verify", + "sha256": "400573026f5930903a6c1448b53829a10fff7908b977660d31bd226d69deee3a", + "size": 33558, + "subdir": "linux-64", + "timestamp": 1532368526048, + "version": "3.0.2" + }, + "conda-verify-3.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click", + "future", + "jinja2", + "python >=3.6,<3.7.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "f62afae94f46761a2302fd4334049c28", + "name": "conda-verify", + "sha256": "301815d3f8215350e8cefec43cc6c4a842b912ddba7be0fdabd2a8774047c261", + "size": 32864, + "subdir": "linux-64", + "timestamp": 1532369331028, + "version": "3.0.2" + }, + "conda-verify-3.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click", + "future", + "jinja2", + "python >=3.7,<3.8.0a0", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "6d584713b0d5ebb5fe705a87319c4fab", + "name": "conda-verify", + "sha256": "60853eb51f65a578703b5614a4b2e702240ea54d4b7fdc6955058bbbc8932853", + "size": 32779, + "subdir": "linux-64", + "timestamp": 1532368529921, + "version": "3.0.2" + }, + "conda-verify-3.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "conda-build >=3.12.0" + ], + "depends": [ + "backports.functools_lru_cache", + "click", + "future", + "jinja2", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "md5": "d37d0bbfb99e9dd6e08199ac470c7df1", + "name": "conda-verify", + "sha256": "96779ba4db50aa0981a7df08cd840c5e8c644a6473c7140339188cfae2fc7a48", + "size": 33632, + "subdir": "linux-64", + "timestamp": 1532477176019, + "version": "3.1.0" + }, + "conda-verify-3.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "conda-build >=3.12.0" + ], + "depends": [ + "click", + "future", + "jinja2", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "md5": "181565b7762b8175e23882bfb04ea853", + "name": "conda-verify", + "sha256": "87e52464f050b4843c60fd5df5f391cf4157716959002c169c0c2c737dc5deef", + "size": 34224, + "subdir": "linux-64", + "timestamp": 1532477341463, + "version": "3.1.0" + }, + "conda-verify-3.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "conda-build >=3.12.0" + ], + "depends": [ + "click", + "future", + "jinja2", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "md5": "07026a381ab72f3921347d4663732fda", + "name": "conda-verify", + "sha256": "64fd0a4ca122b608c45c85e4f23f423b63afb748ede80e14b6b31b1a9c281c31", + "size": 33592, + "subdir": "linux-64", + "timestamp": 1532477103451, + "version": "3.1.0" + }, + "conda-verify-3.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "conda-build >=3.12.0" + ], + "depends": [ + "click", + "future", + "jinja2", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "md5": "ea80c913efba022fa4976cefd833878c", + "name": "conda-verify", + "sha256": "2246bbf0b4125352450a837f2b21eb982e85ff92fed7c10990d128159e40356c", + "size": 33554, + "subdir": "linux-64", + "timestamp": 1532477336284, + "version": "3.1.0" + }, + "conda-verify-3.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "click", + "future", + "jinja2", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "md5": "5ea53e333a3ed7d766fa695d89ff45bc", + "name": "conda-verify", + "sha256": "2333bb895d02e2a0b35d11cfbe4d9ffcaec994e090566dce4a0ab9a0834f303c", + "size": 34937, + "subdir": "linux-64", + "timestamp": 1538577299333, + "version": "3.1.1" + }, + "conda-verify-3.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click", + "future", + "jinja2", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "md5": "6af5c82ededbbfa442eecaa3f6e4787e", + "name": "conda-verify", + "sha256": "562c82a44cbbc9ea4507a2d87243ec675c4e8da83952e62d5f13c8f731cbb8f8", + "size": 35293, + "subdir": "linux-64", + "timestamp": 1538577323205, + "version": "3.1.1" + }, + "conda-verify-3.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click", + "future", + "jinja2", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six" + ], + "license": "BSD 3-Clause", + "md5": "0977ae6926befe6ee4af17ad5114f063", + "name": "conda-verify", + "sha256": "5c71c23846512cba14a276246d845fd91fb84d4eec5c3e06d173d7d887fb2b48", + "size": 34757, + "subdir": "linux-64", + "timestamp": 1538577289685, + "version": "3.1.1" + }, + "conda-verify-3.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click", + "conda-package-handling >=1.1", + "future", + "jinja2", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "md5": "e616d1d385f13ddcf315ce940c486133", + "name": "conda-verify", + "sha256": "a22c6285f7c342c3f32f148ca840a0e36523faba9816ca8307bce23e55bb9699", + "size": 44162, + "subdir": "linux-64", + "timestamp": 1558494699381, + "version": "3.3.0" + }, + "conda-verify-3.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click", + "conda-package-handling >=1.1", + "future", + "jinja2", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "tqdm" + ], + "license": "BSD 3-Clause", + "md5": "59fa49e3b659327a28e64b43a17e4b66", + "name": "conda-verify", + "sha256": "b5ffb23cea3b8418a0630d53aafdb23c022332f12d584190d4247e5669db5f36", + "size": 43811, + "subdir": "linux-64", + "timestamp": 1558494663395, + "version": "3.3.0" + }, + "configargparse-0.13.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e397bc8bbc2941ab3bf734747977588", + "name": "configargparse", + "sha256": "b4d102fd39540a86cc26dc6f8ce34bfa9a236685d5619ca1911aeb00973ebb4e", + "size": 27778, + "subdir": "linux-64", + "timestamp": 1519234653753, + "version": "0.13.0" + }, + "configargparse-0.13.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7fdaaaa096af47e350adb69e0711434a", + "name": "configargparse", + "sha256": "14c089d2de703a5373ccfbfa860bcc66557619771799045d8e03e6136387e032", + "size": 28400, + "subdir": "linux-64", + "timestamp": 1519234677274, + "version": "0.13.0" + }, + "configargparse-0.13.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5efcd96a2c901603663a1922752be11", + "name": "configargparse", + "sha256": "42319ee948935e793aa545a2aa32942a2770aa4153ec86719817bd1460981916", + "size": 27973, + "subdir": "linux-64", + "timestamp": 1519234639828, + "version": "0.13.0" + }, + "configargparse-0.13.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bee1b683d969db9ee63e0ae0c94940d4", + "name": "configargparse", + "sha256": "6acdcba93c73d46ef7cf4eac2f14e7f4d9ecf2f017dfb428cb7ba5d2dfd5f644", + "size": 28141, + "subdir": "linux-64", + "timestamp": 1530813884739, + "version": "0.13.0" + }, + "configargparse-0.14.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c08573bab26d719acefb8d1f6ec1887", + "name": "configargparse", + "sha256": "fb2afd9108fd9bb0a49f1a9c4f5e73f9ba8ebf3e905effe2a709f297d42f9448", + "size": 28659, + "subdir": "linux-64", + "timestamp": 1547748480072, + "version": "0.14.0" + }, + "configargparse-0.14.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7d1610ed0dc83f8b7b6d67314373e4e9", + "name": "configargparse", + "sha256": "996f68c78f76e8bee5d0c001270a8e21909f0c73113ac2b673a1970f417d3aea", + "size": 29065, + "subdir": "linux-64", + "timestamp": 1547748596009, + "version": "0.14.0" + }, + "configargparse-0.14.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e406a426cd4f491fdf0c27dbd31d1427", + "name": "configargparse", + "sha256": "c745872295497d3fbbc7793819996ba9f274fe2f62bc698890bc15f2cd1cca7e", + "size": 28945, + "subdir": "linux-64", + "timestamp": 1547748530722, + "version": "0.14.0" + }, + "configargparse-0.14.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33966ee0a1f4480eb9ffb005042c55a5", + "name": "configargparse", + "sha256": "50a905deb27cfdd67c2e33a4d71c00713b4ac7e2a0724006b4f063ddd9c5a648", + "size": 28465, + "subdir": "linux-64", + "timestamp": 1573033889842, + "version": "0.14.0" + }, + "configobj-5.0.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "37ad2f0fb8b2f0920e32f646155aa36c", + "name": "configobj", + "sha256": "f722c9f08cb2e84825337edb7fa7f3e996030178af2691efa777566f0f181e57", + "size": 54455, + "subdir": "linux-64", + "timestamp": 1530873786650, + "version": "5.0.6" + }, + "configobj-5.0.6-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "1c4d4d7482e5b38b1bf49c13e6719ff8", + "name": "configobj", + "sha256": "58b0a0143e6f3c0a29d2a05b00401fdfaf297a360ff4298c2d691cb06cc0aa50", + "size": 55441, + "subdir": "linux-64", + "timestamp": 1536253505757, + "version": "5.0.6" + }, + "configobj-5.0.6-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "85a073435265e0335992f1b8293d343b", + "name": "configobj", + "sha256": "d0efdae4a400e183d2ff93db03263e6d82ba0adb84c63240d0ea2317732c82b6", + "size": 56281, + "subdir": "linux-64", + "timestamp": 1640789131410, + "version": "5.0.6" + }, + "configobj-5.0.6-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "731c9c2b7d8463fa522e36d50c9d5cbb", + "name": "configobj", + "sha256": "ee2b0994e95a52b1f73cfec007a8944ae7b725c215e080de6bbf533927c89d11", + "size": 72256, + "subdir": "linux-64", + "timestamp": 1676907020713, + "version": "5.0.6" + }, + "configobj-5.0.6-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "dc3944f20fbb4b4ebee8d2a8129b9ad6", + "name": "configobj", + "sha256": "98c0e848d335941504d47be796893edb5fecf1e609857e165b834779011aec7b", + "size": 56291, + "subdir": "linux-64", + "timestamp": 1536253608349, + "version": "5.0.6" + }, + "configobj-5.0.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "6acab3a09f9c880176ec3692083089e6", + "name": "configobj", + "sha256": "033bb23b5fe3a8328cfb20fcd0581dc6723eb6cdf4d399c5fd82712e740e322f", + "size": 54543, + "subdir": "linux-64", + "timestamp": 1530873826694, + "version": "5.0.6" + }, + "configobj-5.0.6-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "28baba0c250aa08b67429f0e43bbe376", + "name": "configobj", + "sha256": "0cab4785f555d04e8457ee042a78de6e18e4aea15aa57c20ff3fe51381aa708f", + "size": 54613, + "subdir": "linux-64", + "timestamp": 1536253465708, + "version": "5.0.6" + }, + "configobj-5.0.6-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "e7c44870d77d73e1947616877777e9e8", + "name": "configobj", + "sha256": "51e3a4a50b90a4476fc82b48cc3cd576b96c3bbecc87d391ac96bda062d652f7", + "size": 294114, + "subdir": "linux-64", + "timestamp": 1613569037550, + "version": "5.0.6" + }, + "configobj-5.0.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "a420ac6984b2646dd010f9b902b37461", + "name": "configobj", + "sha256": "279679d595707c027dce73ad4d7d2915204b898d84aa712b77a3895404c2a837", + "size": 55526, + "subdir": "linux-64", + "timestamp": 1530873806285, + "version": "5.0.6" + }, + "configobj-5.0.6-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "61499fb92d9d1d2ef043e7a25a3d9d20", + "name": "configobj", + "sha256": "9fda0a6494d0e9ebbaf675c4d04a90c4c6bf5ae14d881822a521431e95571003", + "size": 55600, + "subdir": "linux-64", + "timestamp": 1536253561220, + "version": "5.0.6" + }, + "configobj-5.0.6-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "fa2d19e251d3f07cd3823bae514c2033", + "name": "configobj", + "sha256": "b1b11333a851034d0d549f7bd397a869b280e35259f70d78da02c611771b8930", + "size": 295932, + "subdir": "linux-64", + "timestamp": 1613569045423, + "version": "5.0.6" + }, + "configobj-5.0.6-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "05014ab24a6dfb698634e75754aa2213", + "name": "configobj", + "sha256": "a0e119aaf827d331ac94e3948e56aa964a4e9bfc18121b0368b8e312bbfdcab8", + "size": 56215, + "subdir": "linux-64", + "timestamp": 1573741588157, + "version": "5.0.6" + }, + "configobj-5.0.6-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "752a8ab17553d4a28bb2ba704aa410bc", + "name": "configobj", + "sha256": "fce9bc18b45af4a4e415c3abcb7264ae85288257cf4871d47b5f40086064aec6", + "size": 297113, + "subdir": "linux-64", + "timestamp": 1613569044972, + "version": "5.0.6" + }, + "configobj-5.0.6-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "7f6fef7cb3cefc84b32f779a59d90666", + "name": "configobj", + "sha256": "7344ab3e47c2ed676e5790caf696c914b2e308425e9be40b199cfc03e1c3b188", + "size": 295449, + "subdir": "linux-64", + "timestamp": 1613569380078, + "version": "5.0.6" + }, + "configparser-3.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "4699263203a1615270381dd77b01b243", + "name": "configparser", + "sha256": "5a5ad731f636f54049c6b8050d1c76f3da856fdb4dff367c1517dd356548ab25", + "size": 36628, + "subdir": "linux-64", + "timestamp": 1530735395257, + "version": "3.5.0" + }, + "configparser-3.5.0-py27h5117587_0.conda": { + "build": "py27h5117587_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f3f46304e1ed65783ae412f87bd573f0", + "name": "configparser", + "sha256": "9990fb4de89a8a17e7511beb3acea93e5c929a5c4860b1e5dc870ece2c9c4bc0", + "size": 36022, + "subdir": "linux-64", + "timestamp": 1505689796307, + "version": "3.5.0" + }, + "configparser-3.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "aaccffabb011cf83117b626065937649", + "name": "configparser", + "sha256": "77fd01d15d3bf131b375f6bcd5f095abe1b8ce2cb41e27aa441748aef3f7c693", + "size": 40371, + "subdir": "linux-64", + "timestamp": 1579721071171, + "version": "3.5.0" + }, + "configparser-3.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3c30cbefd4c8ddcac5fac9786cd0e498", + "name": "configparser", + "sha256": "4cb25c1dc13779955d75e45e15be94a06b926af30be9b651bd9019b13339f326", + "size": 40437, + "subdir": "linux-64", + "timestamp": 1579721036418, + "version": "3.5.0" + }, + "configparser-3.7.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "dd96a5b4647d1f9c17d39e87ed263343", + "name": "configparser", + "sha256": "7720c9b5712b43c69bb29d4acd1a2bea231f05731670b96840d60221b349d726", + "size": 39622, + "subdir": "linux-64", + "timestamp": 1549648425089, + "version": "3.7.1" + }, + "configparser-3.7.3-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "00e96b2affcbf9b908d18c025e48ac4d", + "name": "configparser", + "sha256": "466b26d444cb5b51876068ecb863f42b52f857f3f4ffc2ee975aa6e414bfeee7", + "size": 43163, + "subdir": "linux-64", + "timestamp": 1552338780932, + "version": "3.7.3" + }, + "configparser-3.7.3-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2e2d231eb030562b3938edfb85b835db", + "name": "configparser", + "sha256": "46881aff852fd118c2c276dfcc42038b3995994cc0c71a1e96f958cb1bc3d0a4", + "size": 43067, + "subdir": "linux-64", + "timestamp": 1552338801017, + "version": "3.7.3" + }, + "configparser-3.7.3-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "15b8eb9c40e94de52a5820056c42eaaa", + "name": "configparser", + "sha256": "a1cbc9b8c215a37907e352c8c67db27fb10062783ca80990d9d4b34ade5698d1", + "size": 43279, + "subdir": "linux-64", + "timestamp": 1552338761870, + "version": "3.7.3" + }, + "configparser-3.7.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f4786b350a369875d43d79cbc03aa60f", + "name": "configparser", + "sha256": "cc80ce921232d78535cc1691400930a5da4403f071c65facd6e89f6843064716", + "size": 43166, + "subdir": "linux-64", + "timestamp": 1556052027827, + "version": "3.7.4" + }, + "configparser-3.7.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6639b40ad03d4cdc4d19109edf196aa1", + "name": "configparser", + "sha256": "486a084b8cca2b7cf647e4a1591d03a2c26705771e2cbc44dfdefb451f027b1d", + "size": 43812, + "subdir": "linux-64", + "timestamp": 1556051918897, + "version": "3.7.4" + }, + "configparser-3.7.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b2d81c741207e2a4f7dcaa3aec23ac53", + "name": "configparser", + "sha256": "49376011ecac26468b524694f53ba0976c6a78f54d703cd5529029f5e3fb53ef", + "size": 43713, + "subdir": "linux-64", + "timestamp": 1556052012234, + "version": "3.7.4" + }, + "configparser-3.7.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "backports", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "a92b43f1ba544b5535bca3c799c22642", + "name": "configparser", + "sha256": "bd2ebd3b67afa3c1c6b70da1870850cf146b88dd6cbf4b280b56087cdece0bad", + "size": 39761, + "subdir": "linux-64", + "timestamp": 1574092505714, + "version": "3.7.4" + }, + "configparser-4.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b0b21d698582181d2468943920568f12", + "name": "configparser", + "sha256": "e2f6a8d72cce60051b674880478dd5ae92ef04a8cf8b5a5041d60b810851dbe1", + "size": 43862, + "subdir": "linux-64", + "timestamp": 1569428663733, + "version": "4.0.2" + }, + "configspace-0.4.19-py310h9102076_0.conda": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "pyparsing", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d8a36b0b9e460145b388f21f1adae084", + "name": "configspace", + "sha256": "6c416511b21b31ba71cbfd0f0b1f6aec6299ca855d6a9b98df595ac0ae218bf3", + "size": 2677728, + "subdir": "linux-64", + "timestamp": 1640789200266, + "version": "0.4.19" + }, + "configspace-0.4.19-py311hbed6279_0.conda": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "pyparsing", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "35cccfcddd03ff7d3d0ffcaaf3c3fa19", + "name": "configspace", + "sha256": "b9b8824a5cab6cd5a8f6b885efdcb44a0c71fd0d5b105fce3cce4f8892c383dc", + "size": 689000, + "subdir": "linux-64", + "timestamp": 1676851436182, + "version": "0.4.19" + }, + "configspace-0.4.19-py37hce1f21e_0.conda": { + "build": "py37hce1f21e_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "pyparsing", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "77c5abbe176748f65205942cc8924da8", + "name": "configspace", + "sha256": "0706cfff793d4d92269fbf5a261d99e4e3fce7f363f725e28593793ff08979aa", + "size": 658625, + "subdir": "linux-64", + "timestamp": 1633556300043, + "version": "0.4.19" + }, + "configspace-0.4.19-py38hce1f21e_0.conda": { + "build": "py38hce1f21e_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "pyparsing", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "26e19d8ae7f96834a53c067c820122bb", + "name": "configspace", + "sha256": "649269efd0f7b5e5d2b93f6fa4318c47d0a2a6208cd3d279471ce4a061138fcc", + "size": 709542, + "subdir": "linux-64", + "timestamp": 1633556308775, + "version": "0.4.19" + }, + "configspace-0.4.19-py39hce1f21e_0.conda": { + "build": "py39hce1f21e_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "pyparsing", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c83d597478087dc6bbd240ec2c469e57", + "name": "configspace", + "sha256": "52bff90e45b03b7c35b430a33387d64cd6c22b936bebd31d93385133c5ed91b5", + "size": 712521, + "subdir": "linux-64", + "timestamp": 1633556303512, + "version": "0.4.19" + }, + "configupdater-3.1.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "237c9397a19ab92cc70f7fd1a2745b60", + "name": "configupdater", + "sha256": "a7ec451211616a8d7124df4fce20c55a6fbd040868297326463f74b191b6862d", + "size": 63458, + "subdir": "linux-64", + "timestamp": 1668698060423, + "version": "3.1.1" + }, + "configupdater-3.1.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "658a330f598d3361b9bbb7af28ca80bd", + "name": "configupdater", + "sha256": "7bc39f7273e2264ea5b9f8dbe44f4aadfd20d08de8b5c78c616fabe0bf33ee8a", + "size": 73241, + "subdir": "linux-64", + "timestamp": 1676830339876, + "version": "3.1.1" + }, + "configupdater-3.1.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ccd4303fea0b25a61bf1b74f534b1f51", + "name": "configupdater", + "sha256": "f26204b6a129d5507a0810f45521b80fff888402c890fe5ce15a90290a9b8131", + "size": 62938, + "subdir": "linux-64", + "timestamp": 1668698157539, + "version": "3.1.1" + }, + "configupdater-3.1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f2e4a84a3c7a0137a9ae71370cca496", + "name": "configupdater", + "sha256": "007a65d48acbc58e3a9cf697096c7c8212cec4a3b015a0246da0b874ebd5b273", + "size": 63147, + "subdir": "linux-64", + "timestamp": 1668698092450, + "version": "3.1.1" + }, + "configupdater-3.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb9091a9a4d37c062d9e6932c9c2733c", + "name": "configupdater", + "sha256": "834e927518798f4007ffbd349d2bb502a4c1b3960cf20f940f6f7d4b3a9ad432", + "size": 63099, + "subdir": "linux-64", + "timestamp": 1668698124697, + "version": "3.1.1" + }, + "configurable-http-proxy-4.0.1-node14_0.conda": { + "build": "node14_0", + "build_number": 0, + "depends": [ + "nodejs 14.*" + ], + "license": "BSD 3-Clause", + "md5": "2ae86ab0620e3eaa34906c3ce43837da", + "name": "configurable-http-proxy", + "sha256": "790a182b60330d1c2ef8ddf4bc948760d47c4de6bf851052a56b4bc817244fbc", + "size": 714328, + "subdir": "linux-64", + "timestamp": 1615897252510, + "version": "4.0.1" + }, + "configurable-http-proxy-4.0.1-node6_0.conda": { + "build": "node6_0", + "build_number": 0, + "depends": [ + "nodejs 6.*" + ], + "license": "BSD 3-Clause", + "md5": "d21bd65c02f8a2a735de6fc03a7dbd73", + "name": "configurable-http-proxy", + "sha256": "d6708106f4993a4d8e87bed7c7bef04585866e948bce32688be9b0d472ffcfbc", + "size": 742187, + "subdir": "linux-64", + "timestamp": 1540825003021, + "version": "4.0.1" + }, + "connexion-2.14.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "clickclick >=1.2,<21", + "flask >=1.0.4,<3", + "importlib-metadata >=1", + "inflection >=0.3.1,<0.6", + "itsdangerous >=0.24", + "jsonschema >=2.5.1,<5", + "packaging >=20", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.1,<7", + "requests >=2.9.1,<3", + "werkzeug >=1.0,<3.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "728010a24a502c6bdecb48141f1422e2", + "name": "connexion", + "sha256": "3b1f7cb505b65e6238768164aa37105272564d432316b998c40258e27555c377", + "size": 131345, + "subdir": "linux-64", + "timestamp": 1659800904054, + "version": "2.14.0" + }, + "connexion-2.14.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "clickclick >=1.2,<21", + "flask >=1.0.4,<3", + "importlib-metadata >=1", + "inflection >=0.3.1,<0.6", + "itsdangerous >=0.24", + "jsonschema >=2.5.1,<5", + "packaging >=20", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.1,<7", + "requests >=2.9.1,<3", + "werkzeug >=1.0,<3.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "06f78fa243ba4ddc00d9f26315a2835e", + "name": "connexion", + "sha256": "01075fb006f1902dda2d5b3e3bd265ba6e016ecdd96156303b9388cec3627849", + "size": 168376, + "subdir": "linux-64", + "timestamp": 1676830354651, + "version": "2.14.0" + }, + "connexion-2.14.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "clickclick >=1.2,<21", + "flask >=1.0.4,<3", + "importlib-metadata >=1", + "inflection >=0.3.1,<0.6", + "itsdangerous >=0.24", + "jsonschema >=2.5.1,<5", + "packaging >=20", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1,<7", + "requests >=2.9.1,<3", + "werkzeug >=1.0,<3.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "88931e849b421ca764bdf5a04666ba69", + "name": "connexion", + "sha256": "fa91a474b8f674577efa634cc65e92df3cfc3b1d6d463ba0d3cdf196b4173412", + "size": 129593, + "subdir": "linux-64", + "timestamp": 1659800783936, + "version": "2.14.0" + }, + "connexion-2.14.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "clickclick >=1.2,<21", + "flask >=1.0.4,<3", + "importlib-metadata >=1", + "inflection >=0.3.1,<0.6", + "itsdangerous >=0.24", + "jsonschema >=2.5.1,<5", + "packaging >=20", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1,<7", + "requests >=2.9.1,<3", + "werkzeug >=1.0,<3.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a3382d567ad328fb3aae49a5c3ec04f1", + "name": "connexion", + "sha256": "8c6f67ef54d44dd2f3cb47261cba1d53586940e7a8b2ddd939d0e4986ad5c6fe", + "size": 130296, + "subdir": "linux-64", + "timestamp": 1659800857090, + "version": "2.14.0" + }, + "connexion-2.14.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "clickclick >=1.2,<21", + "flask >=1.0.4,<3", + "importlib-metadata >=1", + "inflection >=0.3.1,<0.6", + "itsdangerous >=0.24", + "jsonschema >=2.5.1,<5", + "packaging >=20", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1,<7", + "requests >=2.9.1,<3", + "werkzeug >=1.0,<3.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5e1d9c78d458b140903696258f7f103e", + "name": "connexion", + "sha256": "3b7c0addb01d3e456e49d163f4e84be8229f0b7a9a8398d08e90c0111a487a86", + "size": 130371, + "subdir": "linux-64", + "timestamp": 1659800822802, + "version": "2.14.0" + }, + "console_shortcut-0.1.1-3.conda": { + "build": "3", + "build_number": 3, + "depends": [ + "python" + ], + "license": "BSD", + "md5": "a72f6cdd894c4dcc5ece20bd9a0a1f65", + "name": "console_shortcut", + "sha256": "497e9a5e08db085b6b0ff3f77bfd1f1a5bf8d1b7da1746c0a3a56511c70606e7", + "size": 56641, + "subdir": "linux-64", + "timestamp": 1530813902156, + "version": "0.1.1" + }, + "constantly-15.1.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85d24561d9b47b00f7c71355967289d8", + "name": "constantly", + "sha256": "2a69d88576579917079071c0f743fe9880484a125c4d6e04e12b8a01eb8465c8", + "size": 13734, + "subdir": "linux-64", + "timestamp": 1530919567946, + "version": "15.1.0" + }, + "constantly-15.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f0679e5aae27a4bbd609e6eda4b091e", + "name": "constantly", + "sha256": "b00a788f3236ae7462247952e29822d37a6b5bf3ef9d60682cd47e6a1897fbde", + "size": 17034, + "subdir": "linux-64", + "timestamp": 1642674446154, + "version": "15.1.0" + }, + "constantly-15.1.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18dda8c24299b9953b3098711ecb9d13", + "name": "constantly", + "sha256": "fdc3853536fc562c36c084b78298f427ac9fe07ee43e51270209544ef69d4783", + "size": 16056, + "subdir": "linux-64", + "timestamp": 1676839224336, + "version": "15.1.0" + }, + "constantly-15.1.0-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4883fcd2ac13387082d02d54882eecd8", + "name": "constantly", + "sha256": "a611ed51aae453672d72aa97733884e727d523174942ce8648e5d38319b4596f", + "size": 13894, + "subdir": "linux-64", + "timestamp": 1534351178434, + "version": "15.1.0" + }, + "constantly-15.1.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d2c47e2c7c2b157ff279047b76c2553", + "name": "constantly", + "sha256": "f0486cbe035690cf0bee0ccda7450cc5bacfd9cf6e19ca21282b04c65888b34b", + "size": 13736, + "subdir": "linux-64", + "timestamp": 1530919512568, + "version": "15.1.0" + }, + "constantly-15.1.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c42b5e168060b3338c3ac4e4113fa95e", + "name": "constantly", + "sha256": "f09cc8e637718805f049b65b966043367fa884f913d79c3e6cfc46299fd78cc9", + "size": 13914, + "subdir": "linux-64", + "timestamp": 1530919540343, + "version": "15.1.0" + }, + "constructor-2.0.0-py27haf0e89a_0.conda": { + "build": "py27haf0e89a_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=2.7,<2.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b9ae895b9722f6d68946342e50192ff7", + "name": "constructor", + "sha256": "27a6f8f38422b95dbc1416744885e896b293b8df61301aede82e430c70ad18fd", + "size": 65708, + "subdir": "linux-64", + "timestamp": 1509559416724, + "version": "2.0.0" + }, + "constructor-2.0.0-py35ha65c8be_0.conda": { + "build": "py35ha65c8be_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.5,<3.6.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7adda9a17a40bff4f93709afb14532f8", + "name": "constructor", + "sha256": "cca5e279eae050c8783934d113a1e3ac94724fd7e67daa63a02b9d9df395673a", + "size": 65514, + "subdir": "linux-64", + "timestamp": 1509559394310, + "version": "2.0.0" + }, + "constructor-2.0.0-py36ha402fbe_0.conda": { + "build": "py36ha402fbe_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.6,<3.7.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "17fbebd1350d41559779331330c21730", + "name": "constructor", + "sha256": "486bf2d7879384f3c8805f03ffc4fba67703145b6305845cf211c5047059734d", + "size": 64805, + "subdir": "linux-64", + "timestamp": 1509559422628, + "version": "2.0.0" + }, + "constructor-2.0.1-py27h4bcccf3_0.conda": { + "build": "py27h4bcccf3_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=2.7,<2.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "73f90417bdd41ce1e79007dab8b36ac2", + "name": "constructor", + "sha256": "273dff4b89a352bf10b3a6c389a3ac4111cef8328a04fad5d07d60de07af98c3", + "size": 66973, + "subdir": "linux-64", + "timestamp": 1510776132861, + "version": "2.0.1" + }, + "constructor-2.0.1-py35h64a88dd_0.conda": { + "build": "py35h64a88dd_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.5,<3.6.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c8ffd999c149c0b573dae7f1bee5337f", + "name": "constructor", + "sha256": "b64c9f2a657a531f821f8c929176d364694f87c3f2797d74005faab0a4e61dfd", + "size": 67849, + "subdir": "linux-64", + "timestamp": 1510776142709, + "version": "2.0.1" + }, + "constructor-2.0.1-py36hb4fd3a0_0.conda": { + "build": "py36hb4fd3a0_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.6,<3.7.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "10f389b4f3f71c247bae78bccf1f0b7d", + "name": "constructor", + "sha256": "3a300aa59f0ac8a68f38aee5b6788a025e8e81e1c6382b5b2a92800103f6e0b0", + "size": 67089, + "subdir": "linux-64", + "timestamp": 1510776138613, + "version": "2.0.1" + }, + "constructor-2.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=2.7,<2.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7b1f0131c4a2b981ec23ff838a03e564", + "name": "constructor", + "sha256": "25d7d6e65785d1fca70d29bd669af9cb5a0f2984acadb2ccddb0f07905ca0d73", + "size": 67758, + "subdir": "linux-64", + "timestamp": 1517439331140, + "version": "2.0.2" + }, + "constructor-2.0.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.5,<3.6.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8ef6f60c3b4f497097b0c89e79ac5946", + "name": "constructor", + "sha256": "6cb295694f2bae90398afbdb8a7b549737103587a0fef67341d78d021e9d9216", + "size": 68173, + "subdir": "linux-64", + "timestamp": 1517439349720, + "version": "2.0.2" + }, + "constructor-2.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.6,<3.7.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ed4b0032fe98e2d901f2e8a74bbb1c3c", + "name": "constructor", + "sha256": "5e656d038f6186d02ec0677066f9f05ee7ab37a91e8784453da7eb1b8418a8e2", + "size": 67312, + "subdir": "linux-64", + "timestamp": 1517439349871, + "version": "2.0.2" + }, + "constructor-2.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=2.7,<2.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1893511abd3d2139c7d56bd6bd0dddc5", + "name": "constructor", + "sha256": "22d196a9eb23672e13c5e532ac1daa398284559db6082d12108058cfdf669128", + "size": 67418, + "subdir": "linux-64", + "timestamp": 1522809945821, + "version": "2.0.3" + }, + "constructor-2.0.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.5,<3.6.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "29e7a8744ac558e7e5d481759fa71c15", + "name": "constructor", + "sha256": "6dcb71e57734974ee2ea066f2dbe5a73bd094aa6e95ea93ee88d8f052032933d", + "size": 67806, + "subdir": "linux-64", + "timestamp": 1522810050745, + "version": "2.0.3" + }, + "constructor-2.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.6,<3.7.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fe1ca3b15413f627364a430923e95ba2", + "name": "constructor", + "sha256": "73e9549a0eb57c32465f7b16253c6d3437e70ac96ad78fd5b85a8eeb78f505ae", + "size": 66372, + "subdir": "linux-64", + "timestamp": 1522810070010, + "version": "2.0.3" + }, + "constructor-2.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=2.7,<2.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e6c19b298abf674b4027095c854246ab", + "name": "constructor", + "sha256": "08417bcc3510c142af15e8086fe125785abf9c9b7b823a4ac087e3cea40d904f", + "size": 68671, + "subdir": "linux-64", + "timestamp": 1528315605194, + "version": "2.1.0" + }, + "constructor-2.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.5,<3.6.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c90514886a2161f2278f1fd9f27d76b7", + "name": "constructor", + "sha256": "b5640a5efde547e56245a9805398c97a379f4cc12fba1103466658b1ad718581", + "size": 69112, + "subdir": "linux-64", + "timestamp": 1528315645744, + "version": "2.1.0" + }, + "constructor-2.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.6,<3.7.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f5df651e7cc01ac683e647e34497050a", + "name": "constructor", + "sha256": "8618f7740ecacf6aa3758ed4ca779799ce270dfed65eb5c837de880c0a33fcc1", + "size": 68254, + "subdir": "linux-64", + "timestamp": 1528315599463, + "version": "2.1.0" + }, + "constructor-2.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.7,<3.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "94608752275c23b0968aff2a03c4ad59", + "name": "constructor", + "sha256": "97ea9fc249c3800a92485e80ec195d011af1a7b80799eabb686d540e4e2f7a57", + "size": 68129, + "subdir": "linux-64", + "timestamp": 1530813925250, + "version": "2.1.0" + }, + "constructor-2.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=2.7,<2.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4761f08f39c0712a2a17e78a76caac03", + "name": "constructor", + "sha256": "d34ed78bb1e39af70ea644ef0f725c5a5b20c9226b408a8b0c8c999bd758aed5", + "size": 68799, + "subdir": "linux-64", + "timestamp": 1531548857486, + "version": "2.1.1" + }, + "constructor-2.1.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.5,<3.6.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "153896341e06745e2402be608885c033", + "name": "constructor", + "sha256": "efd6d150efac072146ad9a29243d3fcab44c96ffeab14094bacde2f01c193366", + "size": 68368, + "subdir": "linux-64", + "timestamp": 1531548914172, + "version": "2.1.1" + }, + "constructor-2.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.6,<3.7.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2d567d644290d6ebf656bcf1d4082afd", + "name": "constructor", + "sha256": "3a3c8026e92b1640f29b3019cb31869a7cb0dd38c8c69a1a7a3b155c1e705e50", + "size": 68291, + "subdir": "linux-64", + "timestamp": 1531548914962, + "version": "2.1.1" + }, + "constructor-2.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "conda <4.6.0a0", + "python >=3.7,<3.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0d944d3e37945a31f53109b571b0e992", + "name": "constructor", + "sha256": "b732e948e1a605f78edbf023fb557a5f36dde39a7202bc9a24cb871a10b11f6c", + "size": 68208, + "subdir": "linux-64", + "timestamp": 1531548885182, + "version": "2.1.1" + }, + "constructor-2.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda >=4.5", + "python >=2.7,<2.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "51380cbe0d7b32dc79907374065aee57", + "name": "constructor", + "sha256": "60523cb51c80552d15f7301a8ad689f406569f4a88cdd2ba6a2bf98e912aaacb", + "size": 68421, + "subdir": "linux-64", + "timestamp": 1538579959870, + "version": "2.2.0" + }, + "constructor-2.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda >=4.5", + "python >=3.6,<3.7.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c2e2fd988feab850d528dc4842d1ee6b", + "name": "constructor", + "sha256": "2180a0f87a461d934198fe3a3e0931dc253c90b958d0792445c8ac7d837ec48d", + "size": 67908, + "subdir": "linux-64", + "timestamp": 1538579984058, + "version": "2.2.0" + }, + "constructor-2.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "conda >=4.5", + "python >=3.7,<3.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d584fd2bf99da68685e3d1a3bff004c6", + "name": "constructor", + "sha256": "4c78a35346932c2723ae0bc54855512b609822324ea0405fec7040790ea1b175", + "size": 67145, + "subdir": "linux-64", + "timestamp": 1538579945128, + "version": "2.2.0" + }, + "constructor-2.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda >=4.5", + "python >=2.7,<2.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d8f62ed1461f1d4b582729b7d6587bad", + "name": "constructor", + "sha256": "86fb44fb5d1a4c66adc930b3945887fdc4f7d78f24689f9bbb21e7cd4460bdaa", + "size": 70843, + "subdir": "linux-64", + "timestamp": 1541804751464, + "version": "2.3.0" + }, + "constructor-2.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda >=4.5", + "python >=3.6,<3.7.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "af6b6351462933d7e19d649d0e93ad88", + "name": "constructor", + "sha256": "1756e045e7b827dd2a1921752cf2802976118934979e2f3c95cb3e42df0ef0e5", + "size": 70294, + "subdir": "linux-64", + "timestamp": 1541804810464, + "version": "2.3.0" + }, + "constructor-2.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "conda >=4.5", + "python >=3.7,<3.8.0a0", + "ruamel_yaml", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "51caa267b5428eb4e0cbc89b1957d639", + "name": "constructor", + "sha256": "7df2c7d5f6777c85492966909294d2d9af9b99d19b3e5b144d5d70cac2970dda", + "size": 70928, + "subdir": "linux-64", + "timestamp": 1541804766232, + "version": "2.3.0" + }, + "constructor-3.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "conda >=4.6,<23.1.0a0", + "python >=2.7,<2.8.0a0", + "ruamel_yaml" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d007c1f4b5dbe6d1699264c65042d81b", + "name": "constructor", + "sha256": "311837de7c31c3155da1d988857642d284c4076d3be5755fb7f33f2f2ecb40b1", + "size": 9050030, + "subdir": "linux-64", + "timestamp": 1565473506003, + "version": "3.0.0" + }, + "constructor-3.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda >=4.6,<23.1.0a0", + "python >=3.6,<3.7.0a0", + "ruamel_yaml" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "38ba984075196963d337e9c3f329b8f6", + "name": "constructor", + "sha256": "6c0bbcdeaf455d5614b1f51a3cfb3b6d325ddb7d324efc0b6d7ea01f876f7be2", + "size": 9049201, + "subdir": "linux-64", + "timestamp": 1565473531433, + "version": "3.0.0" + }, + "constructor-3.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "conda >=4.6,<23.1.0a0", + "python >=3.7,<3.8.0a0", + "ruamel_yaml" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dfcfb82fc4c4a8aa27018d4e0be1761d", + "name": "constructor", + "sha256": "b36ba136cc477656b95668e6db93ba4d78b6e192a5ba219369ac8021b5a847ed", + "size": 9051708, + "subdir": "linux-64", + "timestamp": 1565473281401, + "version": "3.0.0" + }, + "constructor-3.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.6,<3.7.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8ac335a9ade1548a514a27fc702a9317", + "name": "constructor", + "sha256": "e4ef5e03207f931d52a155fcc4e611d5cf6bbcbe9226047b48de53a128aaee16", + "size": 75174, + "subdir": "linux-64", + "timestamp": 1598031184213, + "version": "3.0.1" + }, + "constructor-3.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.7,<3.8.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ed95144c65257cbc01f9a64e045cb6ce", + "name": "constructor", + "sha256": "fb9870c02a3004abb3065a26c28975a1c3d3250975cbf58c7e9c2eaf9337b3c3", + "size": 76175, + "subdir": "linux-64", + "timestamp": 1598031187103, + "version": "3.0.1" + }, + "constructor-3.0.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.8,<3.9.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8774f771a8c49d17960281f7d3d4b9e9", + "name": "constructor", + "sha256": "f2f353bd027ef46364808c74d3df3d107917e12bdc51c4b43aced29110b0b799", + "size": 76360, + "subdir": "linux-64", + "timestamp": 1598031127131, + "version": "3.0.1" + }, + "constructor-3.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.6,<3.7.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "926e1edbd97670bf77e41308ba82f835", + "name": "constructor", + "sha256": "a7169b2a518390f1267be7e72bb40aef472471394ad5f363ae80fb2e24a1e68c", + "size": 78646, + "subdir": "linux-64", + "timestamp": 1598032241975, + "version": "3.0.2" + }, + "constructor-3.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.7,<3.8.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8662ec0e65319680cf40969cb23105bc", + "name": "constructor", + "sha256": "9240770f4812bced30ae357e159fadd1ba454d6238a938441634b95f5dcff661", + "size": 79388, + "subdir": "linux-64", + "timestamp": 1598032281713, + "version": "3.0.2" + }, + "constructor-3.0.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.8,<3.9.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e8a8baaa9f818410a9a97e7c4b5c43ce", + "name": "constructor", + "sha256": "de7dc11759c46fc558a3f0f8b37a9865031589e274d1308a22b622108595fe4e", + "size": 79585, + "subdir": "linux-64", + "timestamp": 1598032323293, + "version": "3.0.2" + }, + "constructor-3.2.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.6,<3.7.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e9dda21d0d821ad76873a5b0aa35bab2", + "name": "constructor", + "sha256": "e4895c75d613849a510d4fd32d60ae4fdf2e09156defec4fbaf6363a1677af65", + "size": 159352, + "subdir": "linux-64", + "timestamp": 1616147706516, + "version": "3.2.0" + }, + "constructor-3.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.7,<3.8.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bfa3cac12fede9eef37a4fc020f4922a", + "name": "constructor", + "sha256": "5b097491f98df9220970822f8f4ebc39a8aea8e7abad707574c90dd6f77edb9a", + "size": 160407, + "subdir": "linux-64", + "timestamp": 1616147694928, + "version": "3.2.0" + }, + "constructor-3.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.8,<3.9.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "67670aa5326770e81cb775aa306b0300", + "name": "constructor", + "sha256": "e0e20d793e899727f1fc47139f1b534a8ae36a6f1e78ebe21d3eaf36ad1e79a6", + "size": 159717, + "subdir": "linux-64", + "timestamp": 1616145745373, + "version": "3.2.0" + }, + "constructor-3.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.9,<3.10.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "57d1c483e8cbe30043574c3b3677bfb5", + "name": "constructor", + "sha256": "cd018ce94c7b7c305e823fe9ed375e0e531c3118b81fc3ff2dcec05b8e50baba", + "size": 159551, + "subdir": "linux-64", + "timestamp": 1616147698724, + "version": "3.2.0" + }, + "constructor-3.2.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.10,<3.11.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "02eb3e84727ca40537d4dffbe540eaf2", + "name": "constructor", + "sha256": "de98533b36e14f392b8f3cd1a2947756fc557aff26cd43f9b129656de1972a5c", + "size": 160107, + "subdir": "linux-64", + "timestamp": 1643041031940, + "version": "3.2.1" + }, + "constructor-3.2.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.6,<3.7.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b9c16f3e3a032a89cd023c531ac20835", + "name": "constructor", + "sha256": "9ac77526c0da3eff5b4467888393ce8960dbd651f04b01504d3b92f49dee3fa6", + "size": 156715, + "subdir": "linux-64", + "timestamp": 1617222111595, + "version": "3.2.1" + }, + "constructor-3.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.7,<3.8.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f90a45d67e59190afd43354a6463c5a4", + "name": "constructor", + "sha256": "0a712413609b846a6a08b6b674365cf69abdbebfb732e63369a0d5d4982156cb", + "size": 156831, + "subdir": "linux-64", + "timestamp": 1617222097516, + "version": "3.2.1" + }, + "constructor-3.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.8,<3.9.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dd4fea6a46246d80ccdf2e91ee44e8ef", + "name": "constructor", + "sha256": "68dad715dc1227ddc4cf941e93e6816b363085cbce955131c483bd2b3e3d4aab", + "size": 156321, + "subdir": "linux-64", + "timestamp": 1617222101001, + "version": "3.2.1" + }, + "constructor-3.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.9,<3.10.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d0ed4894e8980daf9c8e48a9a11f2aa", + "name": "constructor", + "sha256": "248b58695d29cce76d3f64499cc10dcd2c60af1b497d8bbcb4e45a2a00fe6899", + "size": 156250, + "subdir": "linux-64", + "timestamp": 1617222101078, + "version": "3.2.1" + }, + "constructor-3.3.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.10,<3.11.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c241297da21ee8c55d4e1c90ff63d766", + "name": "constructor", + "sha256": "e64f5d6778d9845ee0f317bda2004e0fb97f1c54298f0ffa84e3a68e7b5c1918", + "size": 159346, + "subdir": "linux-64", + "timestamp": 1647963606490, + "version": "3.3.1" + }, + "constructor-3.3.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.7,<3.8.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a9562a19d4b7640bac06c16080dae9de", + "name": "constructor", + "sha256": "ac5078ee14d22a1cb4cf3aa4abcb0ba834e0644cdc371754b6939172810e7ade", + "size": 158444, + "subdir": "linux-64", + "timestamp": 1647963480064, + "version": "3.3.1" + }, + "constructor-3.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.8,<3.9.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ba30ddd5caed4fadbd76751127f4ea5e", + "name": "constructor", + "sha256": "050fec66f51c59d322c496535564cae01640251357284e463c46ddf76ab2936c", + "size": 158608, + "subdir": "linux-64", + "timestamp": 1647963807970, + "version": "3.3.1" + }, + "constructor-3.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "chardet", + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "pip", + "python >=3.9,<3.10.0a0", + "ruamel_yaml >=0.11.14,<0.16", + "setuptools", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f62e3673f25f7143e1003b0bcc6f043e", + "name": "constructor", + "sha256": "79b51d0b498c94ced4d9ff7ea2019db856730cd237c5c7b11d24cb76b8e25e6a", + "size": 158736, + "subdir": "linux-64", + "timestamp": 1647963709546, + "version": "3.3.1" + }, + "constructor-3.4.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.10,<3.11.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee2ded42101be16e02af32ca493f6072", + "name": "constructor", + "sha256": "1de1859254c0b5e7e01098928e8250b26315c7b7704af9ec7357ed1295fbcf4d", + "size": 209156, + "subdir": "linux-64", + "timestamp": 1674234013351, + "version": "3.4.1" + }, + "constructor-3.4.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.7,<3.8.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1ade7f7cee831260d37f6ee1290bbe60", + "name": "constructor", + "sha256": "1c6fe4f615fcd7eee428a5b3db2ede687a197ed8ea74c326c7187cdc327b210b", + "size": 208263, + "subdir": "linux-64", + "timestamp": 1674234106041, + "version": "3.4.1" + }, + "constructor-3.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.8,<3.9.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ffcc4a8678efbb0274ebffa63572bdf", + "name": "constructor", + "sha256": "76038c0f4162f8fad61f2a4cdaf48dab2b1d8291f6a501c7f1ce5241453ce62f", + "size": 208600, + "subdir": "linux-64", + "timestamp": 1674234296336, + "version": "3.4.1" + }, + "constructor-3.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0a0", + "conda-standalone", + "python >=3.9,<3.10.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "09e2957f64a7d66e9d653d41ed812921", + "name": "constructor", + "sha256": "f23cccefded422411ff985de6e21828945704472c725c2613913b60197d5a6b3", + "size": 208567, + "subdir": "linux-64", + "timestamp": 1674234202536, + "version": "3.4.1" + }, + "constructor-3.4.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0", + "conda-standalone", + "python >=3.10,<3.11.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2d52f01b7249def344249414f457aa16", + "name": "constructor", + "sha256": "91e11d42b2df85bccf7507e62b13b6406a21e932dcef2c90b986a1ee9dfe6ba6", + "size": 206740, + "subdir": "linux-64", + "timestamp": 1674747611243, + "version": "3.4.2" + }, + "constructor-3.4.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0", + "conda-standalone", + "python >=3.7,<3.8.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f70ca8ec54892b2aad98c5de461334c8", + "name": "constructor", + "sha256": "9272a4336fd2aa569143a9f65b79b27c1ce0ceb7345574e53bcda479938a48cd", + "size": 205782, + "subdir": "linux-64", + "timestamp": 1674747663093, + "version": "3.4.2" + }, + "constructor-3.4.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0", + "conda-standalone", + "python >=3.8,<3.9.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3cfc881334baa29fee087b274ee7c908", + "name": "constructor", + "sha256": "ff3fd73d9b431aa8a72f9c835cb5285ca540e46d6141b61fec26a6da1f9417b0", + "size": 205980, + "subdir": "linux-64", + "timestamp": 1674747559677, + "version": "3.4.2" + }, + "constructor-3.4.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0", + "conda-standalone", + "python >=3.9,<3.10.0a0", + "ruamel_yaml >=0.11.14,<0.16" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1b31df270e12c74bf50ce7bf8cc09257", + "name": "constructor", + "sha256": "e01d3b85608fe712daa6e89420e837f16bb1bcf37beee2697901eb0d01ee3a36", + "size": 205936, + "subdir": "linux-64", + "timestamp": 1674747509811, + "version": "3.4.2" + }, + "constructor-3.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0", + "conda-standalone", + "pillow >=3.1", + "python >=3.10,<3.11.0a0", + "ruamel_yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "865cd001a467a24da2a9ff3caaebed16", + "name": "constructor", + "sha256": "e89cc75f109dd3d7f994d6541146eb71b23e6036952704ba31de90bc871a9008", + "size": 212104, + "subdir": "linux-64", + "timestamp": 1680792475331, + "version": "3.4.3" + }, + "constructor-3.4.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0", + "conda-standalone", + "pillow >=3.1", + "python >=3.11,<3.12.0a0", + "ruamel_yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c68503355b76e1c2cc3f9bea07703332", + "name": "constructor", + "sha256": "e37ba1b3ddada4c8117a7c7b2d8a31c5401c38144cbfd857e1ee2b91286611cb", + "size": 245743, + "subdir": "linux-64", + "timestamp": 1680792529931, + "version": "3.4.3" + }, + "constructor-3.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0", + "conda-standalone", + "pillow >=3.1", + "python >=3.8,<3.9.0a0", + "ruamel_yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6d27d76836b9f79fa371410cc97a6ccc", + "name": "constructor", + "sha256": "fdc0c3775357d206e1fafe518d6dd75d013a2b5275a1a5a81a5477c41b55c0f4", + "size": 210765, + "subdir": "linux-64", + "timestamp": 1680792638384, + "version": "3.4.3" + }, + "constructor-3.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "nsis >=3.08" + ], + "depends": [ + "conda >=4.6,<23.1.0", + "conda-standalone", + "pillow >=3.1", + "python >=3.9,<3.10.0a0", + "ruamel_yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "12a3bd687991f01c1a7ec36444938776", + "name": "constructor", + "sha256": "d1ae7a9a5f5319441e972884ba89e799ef00c4e9b16630bcea14e69ac64daa94", + "size": 210826, + "subdir": "linux-64", + "timestamp": 1680792583044, + "version": "3.4.3" + }, + "contextlib2-0.5.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "1fdabd17a463686e4f13553f98c74951", + "name": "contextlib2", + "sha256": "ef2dbb5a3da9fd19f1ba9101a402f343c9efd11b59da534f5608c3a726afaa21", + "size": 15673, + "subdir": "linux-64", + "timestamp": 1530781086406, + "version": "0.5.5" + }, + "contextlib2-0.5.5-py27hbf4c468_0.conda": { + "build": "py27hbf4c468_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "1a3ab4d43481fc90c1f1f67b9907f2b0", + "name": "contextlib2", + "sha256": "249753d7466f4f7b2c3ca2c9880f71d85b0704fce2a1e76a5a3b96be7daa4269", + "size": 15538, + "subdir": "linux-64", + "timestamp": 1505740282282, + "version": "0.5.5" + }, + "contextlib2-0.5.5-py35h6690dba_0.conda": { + "build": "py35h6690dba_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "b56ebd3a103c06b08c097041842793b3", + "name": "contextlib2", + "sha256": "99f7276970cbe544b16edcdf7fb1383c97850196dbc21121d6b5810f329bb52a", + "size": 15691, + "subdir": "linux-64", + "timestamp": 1505740294636, + "version": "0.5.5" + }, + "contextlib2-0.5.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "da67f3e9170d5598877302f744f8b923", + "name": "contextlib2", + "sha256": "c820d5521242d4bfc26f1a66aa01c1f8be70734e740d4a5afc10e9c7d789ff59", + "size": 15812, + "subdir": "linux-64", + "timestamp": 1530781108216, + "version": "0.5.5" + }, + "contextlib2-0.5.5-py36h6c84a62_0.conda": { + "build": "py36h6c84a62_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "c05d821f5b9005c1741b4fbc45318936", + "name": "contextlib2", + "sha256": "b582d865986fbe2aed4db7f58387f7239035b02002213b2147ea345dbe04d114", + "size": 15677, + "subdir": "linux-64", + "timestamp": 1505740306924, + "version": "0.5.5" + }, + "contextlib2-0.5.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "8ddb9bc3b24ae25e24bd0ebd7e3df185", + "name": "contextlib2", + "sha256": "a5410ddf0c80181573e681794efc6b73a9d60758fb6d78f40ce98cc4d3a84198", + "size": 15968, + "subdir": "linux-64", + "timestamp": 1530781130349, + "version": "0.5.5" + }, + "contextlib2-21.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "PSF-2.0 AND Apache-2.0", + "license_family": "PSF", + "md5": "ff05650b16f9fc2c097870b8e06fb0ac", + "name": "contextlib2", + "sha256": "8b4b850e48420173ac6cff2f337aa23d2a5f435aeaf3d4415f190e6da9e4bd25", + "size": 22467, + "subdir": "linux-64", + "timestamp": 1663665236889, + "version": "21.6.0" + }, + "contextlib2-21.6.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "PSF-2.0 AND Apache-2.0", + "license_family": "PSF", + "md5": "642772ec62b2195a9078ba16ff739677", + "name": "contextlib2", + "sha256": "53ca0339817e461a116b95d5bccafb1185b7f3c1052403236ed5b4ced2572483", + "size": 26331, + "subdir": "linux-64", + "timestamp": 1679340389734, + "version": "21.6.0" + }, + "contextlib2-21.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0 AND Apache-2.0", + "license_family": "PSF", + "md5": "54db19a10fc7d584e919eeae89e75b88", + "name": "contextlib2", + "sha256": "c66d551c93765d9b39b25f074191afcb2c7fd7f1da4153e21343a27690e4572e", + "size": 22037, + "subdir": "linux-64", + "timestamp": 1663665261215, + "version": "21.6.0" + }, + "contextlib2-21.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0 AND Apache-2.0", + "license_family": "PSF", + "md5": "5ef85dd4024eca0e24b208d9e34e101a", + "name": "contextlib2", + "sha256": "83c51ca2f9992f8015eb0025b98dbb082689792ddcd74cad3edd7b129ae0939f", + "size": 22186, + "subdir": "linux-64", + "timestamp": 1663665310844, + "version": "21.6.0" + }, + "contextlib2-21.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0 AND Apache-2.0", + "license_family": "PSF", + "md5": "d12e0e71093d6f2cb9699e491e36608c", + "name": "contextlib2", + "sha256": "6d862270f431d39a480645bad028db09cd89fa3211c90354974c75cd1a4f5306", + "size": 22185, + "subdir": "linux-64", + "timestamp": 1663665286687, + "version": "21.6.0" + }, + "continuum-docs-2.0.17-h215ba9a_0.conda": { + "build": "h215ba9a_0", + "build_number": 0, + "depends": [], + "md5": "b161be0807207f158496bb664420fa34", + "name": "continuum-docs", + "sha256": "eb3b44c54c54d75c1d59896fc2e16aea7448f28845f7f55396eadcb540ee6e25", + "size": 42673072, + "subdir": "linux-64", + "timestamp": 1509658360426, + "version": "2.0.17" + }, + "contourpy-1.0.5-py310hdb19cb5_0.conda": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9b1e392241c60302f830fe4446f6c722", + "name": "contourpy", + "sha256": "a3015c66bc6fbd3c4ca337c38cfc89a2955b4e531a1b5734f06f031d63dfb3b6", + "size": 209248, + "subdir": "linux-64", + "timestamp": 1663827593323, + "version": "1.0.5" + }, + "contourpy-1.0.5-py311hdb19cb5_0.conda": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "abaf0d710a8c93b80ac8bbc1534eca5e", + "name": "contourpy", + "sha256": "a9cd4afc1a154689667339a48dbf92518cd506725db0698aecfcb8ccbe7d0f22", + "size": 217576, + "subdir": "linux-64", + "timestamp": 1676827104466, + "version": "1.0.5" + }, + "contourpy-1.0.5-py37hdb19cb5_0.conda": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "25d183f5e32d5e955cf0b51a8d557be2", + "name": "contourpy", + "sha256": "01746bfc7f9792f2adceabe7aac28b0e9541fb2a497637e5325e7ce56d0798d5", + "size": 208472, + "subdir": "linux-64", + "timestamp": 1663827529541, + "version": "1.0.5" + }, + "contourpy-1.0.5-py38hdb19cb5_0.conda": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "95ad17ee0a802fc2cf4bfacfb47f2267", + "name": "contourpy", + "sha256": "98185b5992d4f84c5251631d2e627bfa81f1ba6a52844f357ef9b8defac40e84", + "size": 208201, + "subdir": "linux-64", + "timestamp": 1663827474400, + "version": "1.0.5" + }, + "contourpy-1.0.5-py39hdb19cb5_0.conda": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "35555506f0ba52e1324c024d28259e6b", + "name": "contourpy", + "sha256": "ba02d801fcacc6a1953bd9e9150445bf8bb193aca41ba7714fd1911060f59852", + "size": 209206, + "subdir": "linux-64", + "timestamp": 1663827645102, + "version": "1.0.5" + }, + "cookies-2.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "93bce46dd8a7caab869e7682f3903ac2", + "name": "cookies", + "sha256": "84d2604a9d307e3f2590ae019dcef303675837d56ab445d983e2d80c5374c106", + "size": 68661, + "subdir": "linux-64", + "timestamp": 1530812845216, + "version": "2.2.1" + }, + "cookies-2.2.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "1d98196ef39c158a45e489363dd5c7e8", + "name": "cookies", + "sha256": "c6054d3251cfc7b6fc46ce21fc1feb1eefeb593bf0a845df8b283df907cd6719", + "size": 69834, + "subdir": "linux-64", + "timestamp": 1539183660688, + "version": "2.2.1" + }, + "cookies-2.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "cffcaf1861e1030c9b1fe8214ee7598f", + "name": "cookies", + "sha256": "88c9731d0cbf7b1b6f9e989a51544e69250c4a5fd997e6cd5b926d0dc31067b2", + "size": 70294, + "subdir": "linux-64", + "timestamp": 1535130192661, + "version": "2.2.1" + }, + "cookies-2.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7d8d316351bc16830a76b76e33070d6e", + "name": "cookies", + "sha256": "322ce8762ac1441826b743e19e0b9851ab4fa01d9672975191fbcf6f9274683a", + "size": 68477, + "subdir": "linux-64", + "timestamp": 1530812893916, + "version": "2.2.1" + }, + "cookies-2.2.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "cabc30d731563574610ddc82e1f4647f", + "name": "cookies", + "sha256": "368ed3156aefb2adfb992fc60104da7ed7d4c0eb772e40bb40bc02b2c2f83bb3", + "size": 68799, + "subdir": "linux-64", + "timestamp": 1539183691408, + "version": "2.2.1" + }, + "cookies-2.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b3a73b8b165a654f93eae5e73e80be32", + "name": "cookies", + "sha256": "2dfbf6612f8d5a2038136e997a956ed96c43b88f03a9626cc67b8d9001b74bce", + "size": 69012, + "subdir": "linux-64", + "timestamp": 1530812869155, + "version": "2.2.1" + }, + "cookies-2.2.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6a59d0a65f0db524bb648e48de60629c", + "name": "cookies", + "sha256": "559aa02276595164bdbd31b6d89db616a6969ce8df37402e6968221766d63ae8", + "size": 68326, + "subdir": "linux-64", + "timestamp": 1539183677957, + "version": "2.2.1" + }, + "cookies-2.2.1-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "27bed615732656442e05de285bb02cf9", + "name": "cookies", + "sha256": "7eba08d51fc14a475b7888d15fc35c3b36a5e84fa86b8d2f4c1f401ef5385f66", + "size": 69858, + "subdir": "linux-64", + "timestamp": 1572357198550, + "version": "2.2.1" + }, + "coremltools-4.1-py310h00e6091_1.conda": { + "build": "py310h00e6091_1", + "build_number": 1, + "constrains": [ + "pytorch >=1.4,<1.7" + ], + "depends": [ + "attrs", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging", + "protobuf >=3.1.0", + "python >=3.10,<3.11.0a0", + "scipy", + "six >=1.1.0", + "sympy", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6d61021b0138d2a25b80f41db906f26a", + "name": "coremltools", + "sha256": "a20faf2e8dcbf3bf9152455b4db5ceacb883f0f24fe3a3cd084f2a9b2a4c4609", + "size": 3261928, + "subdir": "linux-64", + "timestamp": 1640811834063, + "version": "4.1" + }, + "coremltools-4.1-py36h5f574fb_0.conda": { + "build": "py36h5f574fb_0", + "build_number": 0, + "constrains": [ + "pytorch >=1.4,<1.7" + ], + "depends": [ + "attrs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf >=3.1.0", + "python >=3.6,<3.7.0a0", + "scipy", + "six >=1.1.0", + "sympy", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c848f4054cdc251d487a65a55c95e263", + "name": "coremltools", + "sha256": "c55b622aa726cc6721b43449d7c04c1646bc67658223e2193f84cbb958cfa7dd", + "size": 3241129, + "subdir": "linux-64", + "timestamp": 1612969001749, + "version": "4.1" + }, + "coremltools-4.1-py36h5f574fb_1.conda": { + "build": "py36h5f574fb_1", + "build_number": 1, + "constrains": [ + "pytorch >=1.4,<1.7" + ], + "depends": [ + "attrs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf >=3.1.0", + "python >=3.6,<3.7.0a0", + "scipy", + "six >=1.1.0", + "sympy", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1f22c03bc985f07cc1b1ab353839c89d", + "name": "coremltools", + "sha256": "0d6f46de57987ecd63ed13566b17c5786853e76c5f27ae96c54b0e5f690fe685", + "size": 3253737, + "subdir": "linux-64", + "timestamp": 1615414113482, + "version": "4.1" + }, + "coremltools-4.1-py37h5f574fb_0.conda": { + "build": "py37h5f574fb_0", + "build_number": 0, + "constrains": [ + "pytorch >=1.4,<1.7" + ], + "depends": [ + "attrs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf >=3.1.0", + "python >=3.7,<3.8.0a0", + "scipy", + "six >=1.1.0", + "sympy", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c22518567d98302cd550e895c2546a38", + "name": "coremltools", + "sha256": "a38536f9eed985243ab7f4d5644f418b856f9afe527e230fbe0dd25582b38251", + "size": 3234014, + "subdir": "linux-64", + "timestamp": 1612968946413, + "version": "4.1" + }, + "coremltools-4.1-py37h5f574fb_1.conda": { + "build": "py37h5f574fb_1", + "build_number": 1, + "constrains": [ + "pytorch >=1.4,<1.7" + ], + "depends": [ + "attrs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf >=3.1.0", + "python >=3.7,<3.8.0a0", + "scipy", + "six >=1.1.0", + "sympy", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a49ba29815aa91237331d3b5206c6a03", + "name": "coremltools", + "sha256": "b6f06c55d53afd86a370955109cb3145459c7e29e769196238736a6176d6d756", + "size": 3242148, + "subdir": "linux-64", + "timestamp": 1615414100368, + "version": "4.1" + }, + "coremltools-4.1-py38h5f574fb_0.conda": { + "build": "py38h5f574fb_0", + "build_number": 0, + "constrains": [ + "pytorch >=1.4,<1.7" + ], + "depends": [ + "attrs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf >=3.1.0", + "python >=3.8,<3.9.0a0", + "scipy", + "six >=1.1.0", + "sympy", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e35f375f341dd1808863f1675f27bc88", + "name": "coremltools", + "sha256": "1c540b81a0d2aea79722e4ad72cc8355c4174da8cc5f8b66515fecfa095a9866", + "size": 3242355, + "subdir": "linux-64", + "timestamp": 1612969374231, + "version": "4.1" + }, + "coremltools-4.1-py38h5f574fb_1.conda": { + "build": "py38h5f574fb_1", + "build_number": 1, + "constrains": [ + "pytorch >=1.4,<1.7" + ], + "depends": [ + "attrs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf >=3.1.0", + "python >=3.8,<3.9.0a0", + "scipy", + "six >=1.1.0", + "sympy", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4babbd58ebc8a1ed7f128687ed018dba", + "name": "coremltools", + "sha256": "7161492cd9be4bf079b059eed669beca4fd08dc0ef571a7c487ae4260ffe0bb2", + "size": 3260151, + "subdir": "linux-64", + "timestamp": 1615414110827, + "version": "4.1" + }, + "coremltools-4.1-py39h5f574fb_0.conda": { + "build": "py39h5f574fb_0", + "build_number": 0, + "constrains": [ + "pytorch >=1.4,<1.7" + ], + "depends": [ + "attrs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf >=3.1.0", + "python >=3.9,<3.10.0a0", + "scipy", + "six >=1.1.0", + "sympy", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5b3622484e24f5887977a50b701e7d35", + "name": "coremltools", + "sha256": "a2d3cdb51399f18ffc4af666f036770fbac5aaaf8d510ae9722d4aaf80280e5a", + "size": 3249501, + "subdir": "linux-64", + "timestamp": 1612969360580, + "version": "4.1" + }, + "coremltools-4.1-py39h5f574fb_1.conda": { + "build": "py39h5f574fb_1", + "build_number": 1, + "constrains": [ + "pytorch >=1.4,<1.7" + ], + "depends": [ + "attrs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf >=3.1.0", + "python >=3.9,<3.10.0a0", + "scipy", + "six >=1.1.0", + "sympy", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bbe0b9268a0b5b944378bfec7d63ad94", + "name": "coremltools", + "sha256": "5b7020642f8b695460e7e849b036de0d5d13b46c3c52d2334681eb7a7f318b82", + "size": 3253130, + "subdir": "linux-64", + "timestamp": 1615413291093, + "version": "4.1" + }, + "coreutils-8.31-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "ecce026920f65d18017c658e215f2709", + "name": "coreutils", + "sha256": "baa12b94ef80868b83a0d8063824ad0be34c5215253c5153b5a5ea7e4829c9fc", + "size": 2678663, + "subdir": "linux-64", + "timestamp": 1588104532312, + "version": "8.31" + }, + "coreutils-8.32-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "ae208c4c459c5919985211debccbf69e", + "name": "coreutils", + "sha256": "0cda371783e8b20c32a2e3cefc29f87c8e79c72c8a013b5e455aad3c686aefea", + "size": 2756815, + "subdir": "linux-64", + "timestamp": 1598644085483, + "version": "8.32" + }, + "cornice-2.4.0-py27h70b9346_0.conda": { + "build": "py27h70b9346_0", + "build_number": 0, + "depends": [ + "colander", + "pyramid", + "python >=2.7,<2.8.0a0", + "simplejson", + "venusian", + "webob" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "64e4e1573fe2760fe051c4d75f2507e2", + "name": "cornice", + "sha256": "f1f4528ccbe84d5974162248367a49ff0e6106b44422c88ab16b03b34c2d091f", + "size": 39387, + "subdir": "linux-64", + "timestamp": 1508743569820, + "version": "2.4.0" + }, + "cornice-2.4.0-py35hf69054b_0.conda": { + "build": "py35hf69054b_0", + "build_number": 0, + "depends": [ + "colander", + "pyramid", + "python >=3.5,<3.6.0a0", + "simplejson", + "venusian", + "webob" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "f13d5590f066b1a6863ae29946f2a297", + "name": "cornice", + "sha256": "5c3f6c635b47cf440105d7f62f197ed4ae15d377374e200e826a373b2f93b68f", + "size": 39861, + "subdir": "linux-64", + "timestamp": 1508743526825, + "version": "2.4.0" + }, + "cornice-2.4.0-py36had50d1d_0.conda": { + "build": "py36had50d1d_0", + "build_number": 0, + "depends": [ + "colander", + "pyramid", + "python >=3.6,<3.7.0a0", + "simplejson", + "venusian", + "webob" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "e4e40d630b66b1c5bb118d2612953eb8", + "name": "cornice", + "sha256": "b704cf067045225e3c25ca4e0ef3b1a507182bb1a62d0aedce2c80f1a78b210f", + "size": 39537, + "subdir": "linux-64", + "timestamp": 1508743577195, + "version": "2.4.0" + }, + "cornice-3.0.0-py27h318091b_0.conda": { + "build": "py27h318091b_0", + "build_number": 0, + "depends": [ + "colander", + "pyramid", + "python >=2.7,<2.8.0a0", + "simplejson", + "venusian", + "webob" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "cdc16999198257462f9ffa973e119608", + "name": "cornice", + "sha256": "7ee246a85f9380e41504b541513fffcf31458b52d3710bae9a5e33c3acde1bcd", + "size": 39076, + "subdir": "linux-64", + "timestamp": 1511700367658, + "version": "3.0.0" + }, + "cornice-3.0.0-py35hbebb21b_0.conda": { + "build": "py35hbebb21b_0", + "build_number": 0, + "depends": [ + "colander", + "pyramid", + "python >=3.5,<3.6.0a0", + "simplejson", + "venusian", + "webob" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "7f40393afa1031f2d7136dbdb67f6cbb", + "name": "cornice", + "sha256": "45e56388ec5da2a7d1bc9df85a63d4d33c85705c4de03931452a6735cc0bb6ca", + "size": 39886, + "subdir": "linux-64", + "timestamp": 1511700376262, + "version": "3.0.0" + }, + "cornice-3.0.0-py36h4eba0d1_0.conda": { + "build": "py36h4eba0d1_0", + "build_number": 0, + "depends": [ + "colander", + "pyramid", + "python >=3.6,<3.7.0a0", + "simplejson", + "venusian", + "webob" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "be94b07407a1313d131bf9ba581b365e", + "name": "cornice", + "sha256": "c0853a7f8fcb9a309c7fb4eab95d84536ef67b8b73fe9a25644885729b43bb1a", + "size": 39306, + "subdir": "linux-64", + "timestamp": 1511700379695, + "version": "3.0.0" + }, + "cornice-3.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "colander", + "pyramid", + "python >=2.7,<2.8.0a0", + "simplejson", + "six", + "venusian", + "webob" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "29f98be2fba5421a0087e4943dc5f9b9", + "name": "cornice", + "sha256": "163e3d5b00edc8b5546775810eec8131b80fb7c93d83c0cb87cd5019003bfe45", + "size": 39626, + "subdir": "linux-64", + "timestamp": 1519252774392, + "version": "3.1.0" + }, + "cornice-3.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "colander", + "pyramid", + "python >=3.5,<3.6.0a0", + "simplejson", + "six", + "venusian", + "webob" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "e63c9ef4df16e14de654fd3ce2823db5", + "name": "cornice", + "sha256": "b86338f99bcc5b040f4dbeafe3b166fe42d7f82df97c0e7ba84c01a8cbb9a9cd", + "size": 40158, + "subdir": "linux-64", + "timestamp": 1519252786019, + "version": "3.1.0" + }, + "cornice-3.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "colander", + "pyramid", + "python >=3.6,<3.7.0a0", + "simplejson", + "six", + "venusian", + "webob" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "13f27b1220539c8996d75d22396ae2da", + "name": "cornice", + "sha256": "9a7815cf544c4c0615180724d6d6f222dd443fab0fbbe26ddd6d08bd24d1dd25", + "size": 40189, + "subdir": "linux-64", + "timestamp": 1519252747761, + "version": "3.1.0" + }, + "cornice-3.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=2.7,<2.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "66fa89b889a5a79ed2d32467e53d7412", + "name": "cornice", + "sha256": "9e6a9c0f1ad4dd271c97e4e41560a3547a376ea15a9b0ebd911313663e3a955d", + "size": 41991, + "subdir": "linux-64", + "timestamp": 1530036373033, + "version": "3.4.0" + }, + "cornice-3.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.5,<3.6.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "af4e33ad7a73d10b8f0deffb82934d4d", + "name": "cornice", + "sha256": "45edb34be423b627fbb4ada787820fae3a42b87a4ac669eceec9841a648b7147", + "size": 43016, + "subdir": "linux-64", + "timestamp": 1530036409942, + "version": "3.4.0" + }, + "cornice-3.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.6,<3.7.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "d578dccc917274d4befb2396d8199e78", + "name": "cornice", + "sha256": "8961d4d7b730d38a35c27e3784fd383169d17893151af2979332592b21c415cd", + "size": 42232, + "subdir": "linux-64", + "timestamp": 1530036372259, + "version": "3.4.0" + }, + "cornice-3.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.7,<3.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "8c38e712f843ff547f25036532260dd4", + "name": "cornice", + "sha256": "bc667b6f6c5ac3354f671535ebcc3a2f8600897d6dc8c6ce00c441700705a6a8", + "size": 42673, + "subdir": "linux-64", + "timestamp": 1530875912077, + "version": "3.4.0" + }, + "cornice-3.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=2.7,<2.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "0c266fb9272c44547aab02e874ec331a", + "name": "cornice", + "sha256": "86bc7c4688a68fae8aafa7741fd9b373cf1fef7e6d8224c4ba3a513f8ff82173", + "size": 43155, + "subdir": "linux-64", + "timestamp": 1539473214246, + "version": "3.4.1" + }, + "cornice-3.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.6,<3.7.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "33113e431216d8d08ce1004357a8a34a", + "name": "cornice", + "sha256": "82bb2877b7cbb42d16fb96ab3f39939e73e435c509544c54dd33d5b55e3717a0", + "size": 43422, + "subdir": "linux-64", + "timestamp": 1539473235549, + "version": "3.4.1" + }, + "cornice-3.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.7,<3.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "28d03de3009e3cc9c80fb54899858a36", + "name": "cornice", + "sha256": "872c35ae3ef239caffe069184c12c188efda186a1f9489d2520e3ff87d42b1ca", + "size": 43423, + "subdir": "linux-64", + "timestamp": 1539473235497, + "version": "3.4.1" + }, + "cornice-3.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=2.7,<2.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "8c6c37961aa2c8efc9d8391415549b86", + "name": "cornice", + "sha256": "1ef1f158ab07b8816ac02604b7cc4960357992b4bfe413b95119b016a28374bc", + "size": 42611, + "subdir": "linux-64", + "timestamp": 1540962758099, + "version": "3.4.2" + }, + "cornice-3.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.6,<3.7.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "96caa87e05bbf8d9c317ba436acccb01", + "name": "cornice", + "sha256": "ecead1ea27c2f1946f711c50ab4b41f5116618b988d9b4ab2dd391b1caa79ea5", + "size": 43393, + "subdir": "linux-64", + "timestamp": 1540962773300, + "version": "3.4.2" + }, + "cornice-3.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.7,<3.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "27689f90a644751cefd1f6116088f336", + "name": "cornice", + "sha256": "1102123abbe233170a78581f13e061ec8030e6e2b0078b4546a827ac9081bb52", + "size": 43378, + "subdir": "linux-64", + "timestamp": 1540962776694, + "version": "3.4.2" + }, + "cornice-3.4.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=2.7,<2.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "717f4c573de477ef39b65732a0cb82a9", + "name": "cornice", + "sha256": "6dfc8cf8d31ecdc8cebd73920a78c3b02b40118f7643cd2e62982a6b68f5186f", + "size": 43262, + "subdir": "linux-64", + "timestamp": 1545114155822, + "version": "3.4.4" + }, + "cornice-3.4.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.6,<3.7.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "114a5ccc829b1a331325e90a0db6e7af", + "name": "cornice", + "sha256": "feb9fe64202a7b16d6f5e31df50d0df214cb635f954482460252afa90176bf36", + "size": 43529, + "subdir": "linux-64", + "timestamp": 1545114162004, + "version": "3.4.4" + }, + "cornice-3.4.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.7,<3.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "f6327607284608fa46db19bdcef87c33", + "name": "cornice", + "sha256": "4b44748322a026a14c8fd551c4fd46f7f0a8f8aaa3546a1e677d55b09b6a7bcc", + "size": 43503, + "subdir": "linux-64", + "timestamp": 1545114196962, + "version": "3.4.4" + }, + "cornice-3.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=2.7,<2.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "459b68611a921caf0023ab39e122baed", + "name": "cornice", + "sha256": "17d8efac9b30fa76100e6f71f1cb6725c8b665418937a9c76a34a87ba7fa05f3", + "size": 186440, + "subdir": "linux-64", + "timestamp": 1547789187785, + "version": "3.5.0" + }, + "cornice-3.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.6,<3.7.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "988a8804ff67277ffb4d1a049f01f677", + "name": "cornice", + "sha256": "277bd48286582e54e7064350d842da5105325e620ba90206fe3c8347c288e398", + "size": 186973, + "subdir": "linux-64", + "timestamp": 1547789321473, + "version": "3.5.0" + }, + "cornice-3.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.7,<3.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "913d15344ce33bf671ea43cbcd7d9964", + "name": "cornice", + "sha256": "e804136875577ed89be19e9d8c1cebfa16cb6ebf2feb53d929dcb3ce91824798", + "size": 186818, + "subdir": "linux-64", + "timestamp": 1547789319717, + "version": "3.5.0" + }, + "cornice-3.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=2.7,<2.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "b0c037038a1cf1c26df34f2d36d51e64", + "name": "cornice", + "sha256": "f3b6fcb6c46bdd7859c99995e5e3f61fe9470f3e13a34c6c38afb6181a8a6fcd", + "size": 191529, + "subdir": "linux-64", + "timestamp": 1550267627630, + "version": "3.5.1" + }, + "cornice-3.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.6,<3.7.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "661462e2eb62ab77aec31610d752fcb3", + "name": "cornice", + "sha256": "7c161aec4c99107459f0cf06d7e0778b70facd13b94d83fe2595822600011b4a", + "size": 191136, + "subdir": "linux-64", + "timestamp": 1550267623154, + "version": "3.5.1" + }, + "cornice-3.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyramid >=1.7", + "python >=3.7,<3.8.0a0", + "simplejson", + "six", + "venusian" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "8e017bada635ebdb5613899bdf806dcf", + "name": "cornice", + "sha256": "b2b7751d00a9a5dfc1f7a199e83ce5c65b813887e19999437f796ca83e19cd55", + "size": 192294, + "subdir": "linux-64", + "timestamp": 1550267555941, + "version": "3.5.1" + }, + "coverage-4.4.2-py27h86fff8b_0.conda": { + "build": "py27h86fff8b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8fddd90e396af810f2e741aa06cc5f0c", + "name": "coverage", + "sha256": "028a02ed866f466512c229f57ca36a04610e91fe68e09c51bc160e474f1cb550", + "size": 215269, + "subdir": "linux-64", + "timestamp": 1511294533705, + "version": "4.4.2" + }, + "coverage-4.4.2-py35h8fc71f1_0.conda": { + "build": "py35h8fc71f1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "931350072392b2071cd6a7b4909b50ce", + "name": "coverage", + "sha256": "02c3f6b907deb151c9cf7ce7b7204e089d714c5b5f172be994f4d2652014c7f8", + "size": 217421, + "subdir": "linux-64", + "timestamp": 1511294548177, + "version": "4.4.2" + }, + "coverage-4.4.2-py36hca7c4c5_0.conda": { + "build": "py36hca7c4c5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3673fd3abf20b95dc73334c16938a51a", + "name": "coverage", + "sha256": "5465be05ffabb1ebd5c8affc143d54e279e431ce3c8398fd968b737de572942d", + "size": 216013, + "subdir": "linux-64", + "timestamp": 1511294511924, + "version": "4.4.2" + }, + "coverage-4.5.1-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e343010153294d3ec4e003406baeb531", + "name": "coverage", + "sha256": "414b5287cfb00d1f3c153650d86f43935ffdf7d9c74de23e46c3b1bdc475fb3b", + "size": 216839, + "subdir": "linux-64", + "timestamp": 1519228346818, + "version": "4.5.1" + }, + "coverage-4.5.1-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ab90028bc79e43bb708a213885127f17", + "name": "coverage", + "sha256": "d22087a7c3b6da93b53a62cde91663442e7d13c7b1a2629f79d5112d1de88085", + "size": 220641, + "subdir": "linux-64", + "timestamp": 1519228362150, + "version": "4.5.1" + }, + "coverage-4.5.1-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "60578d469c37f1b2e8ad7ad6780c1c44", + "name": "coverage", + "sha256": "e53c234509a3a02a2f80d987c095a600285b9d35ea6fe879a5400d23e653693f", + "size": 218930, + "subdir": "linux-64", + "timestamp": 1519228334909, + "version": "4.5.1" + }, + "coverage-4.5.1-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a0c2d0fd5a1bb13c1f4f69178b26f0d8", + "name": "coverage", + "sha256": "2a56b8bf27cdb8b6953dfd0286eb2dad75c3e74028bc9086cc17717d2aa95a24", + "size": 218918, + "subdir": "linux-64", + "timestamp": 1530694019690, + "version": "4.5.1" + }, + "coverage-4.5.2-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "638e86559406317afc386783a7069179", + "name": "coverage", + "sha256": "4108108dc225c4c0243ba91defc4bd2232a6a9e7c4912b81f012d3d6aa6e1626", + "size": 221221, + "subdir": "linux-64", + "timestamp": 1542385760431, + "version": "4.5.2" + }, + "coverage-4.5.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ff27b0ce28e03ad6a7769641186e347c", + "name": "coverage", + "sha256": "52a463b741590dd2bd970221c4d1e3a34b5fdc049cdee8e289aeefe77913a771", + "size": 221533, + "subdir": "linux-64", + "timestamp": 1542385762289, + "version": "4.5.2" + }, + "coverage-4.5.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "df82ffc7ba70aad4545577f2a9fc33dd", + "name": "coverage", + "sha256": "9e264fd6aefe84cdbac2c9c2db58bd8d686b52c3964863c0710f67290b4cd9a1", + "size": 219848, + "subdir": "linux-64", + "timestamp": 1542385751158, + "version": "4.5.2" + }, + "coverage-4.5.3-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7d4e98e1d37f5159f46f0b4b750bfc46", + "name": "coverage", + "sha256": "434b21e527a85ffc63a9d2043d4456eafaf1dcee00fe5070e9450630decb78fb", + "size": 222730, + "subdir": "linux-64", + "timestamp": 1552344310108, + "version": "4.5.3" + }, + "coverage-4.5.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "092c11eb6d9d7bebfd169181f62455e0", + "name": "coverage", + "sha256": "5df0eec583f2f337d735402c0e46551413ed6c1bedc33e008fb0dd29ca7b59ea", + "size": 222973, + "subdir": "linux-64", + "timestamp": 1552344332561, + "version": "4.5.3" + }, + "coverage-4.5.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "09f74a0f6cd66c499dd5524d7b69d385", + "name": "coverage", + "sha256": "d4cf6aaf0801acfe3d212d88691436970936d6cb9b06957df127285dd2bd7a22", + "size": 224714, + "subdir": "linux-64", + "timestamp": 1552344328861, + "version": "4.5.3" + }, + "coverage-4.5.3-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b857f9031a2ee734f3fed232fbc7442c", + "name": "coverage", + "sha256": "73daa7d2a83367c439246eb2edcd5ad202ff86d2ab82a20af680b84ffb523f6d", + "size": 229658, + "subdir": "linux-64", + "timestamp": 1573033974013, + "version": "4.5.3" + }, + "coverage-4.5.4-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7fd2598adfb00968f12f03c9220f40a8", + "name": "coverage", + "sha256": "983a1464e275ae5ba6204f71dcf82f748dda13f4e79d73c516a19ff486eb2c4c", + "size": 229530, + "subdir": "linux-64", + "timestamp": 1569349916963, + "version": "4.5.4" + }, + "coverage-4.5.4-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5abef48bc18307f59bdcf6a27a4efdff", + "name": "coverage", + "sha256": "a48191df672f190a3a9bcbadc141ba0a916014b271794f0dd0c568b416e22793", + "size": 229035, + "subdir": "linux-64", + "timestamp": 1569349918105, + "version": "4.5.4" + }, + "coverage-4.5.4-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "68fde5662e6acc48b242855412abf2ed", + "name": "coverage", + "sha256": "b9ef81e4f294de8ce1d10bc62a8b7c9222b128ecae9cff1aa144217d23c5417e", + "size": 229257, + "subdir": "linux-64", + "timestamp": 1569349896713, + "version": "4.5.4" + }, + "coverage-5.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e0e56e8402907f86f7760387b4fa0f50", + "name": "coverage", + "sha256": "c416b9b41de2538c5eafe83f2c207c724fb38e929fbdbd2262546eceadf52648", + "size": 252948, + "subdir": "linux-64", + "timestamp": 1576871510409, + "version": "5.0" + }, + "coverage-5.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1075578ce23cfd2b08f6e9ed5e15af4e", + "name": "coverage", + "sha256": "f2982bbcb553796527eda6b568f2753e58872c8feb171d7b18676fe0954d9029", + "size": 255836, + "subdir": "linux-64", + "timestamp": 1576871552777, + "version": "5.0" + }, + "coverage-5.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "13e16aa5b4c9ff050129382ddb5a13ba", + "name": "coverage", + "sha256": "1807b05d10de6d21c149d6d5945badfbb58d624db9d470b464c435644c55f789", + "size": 255789, + "subdir": "linux-64", + "timestamp": 1576871539310, + "version": "5.0" + }, + "coverage-5.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6fc331b03a6070b4731d1954b8e36218", + "name": "coverage", + "sha256": "a18a35c38d2ecf507cc11651b70be557c402a64aa1667a58082a737a602fc667", + "size": 260260, + "subdir": "linux-64", + "timestamp": 1576871522564, + "version": "5.0" + }, + "coverage-5.0.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f1e2c9e49b2bcd0d5aefc161ae1ca9c7", + "name": "coverage", + "sha256": "ec0468211497c6c922491105af154d40acdb68c6479d9b02315a81a1f292060c", + "size": 256434, + "subdir": "linux-64", + "timestamp": 1597708366939, + "version": "5.0.1" + }, + "coverage-5.0.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9bf22cb6000e1593041bc3f4aeadb561", + "name": "coverage", + "sha256": "fd2d4941140612b4e38a0d06c8673ea4167bd5e1ca68ebdf79a9913daae523a2", + "size": 252645, + "subdir": "linux-64", + "timestamp": 1597708352414, + "version": "5.0.1" + }, + "coverage-5.0.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "474bcf43820f715360c17944e5862b2e", + "name": "coverage", + "sha256": "40de54fa631f63a47c84d699e312066edb5f51d320621d420618c30fe3521e73", + "size": 256826, + "subdir": "linux-64", + "timestamp": 1597708367045, + "version": "5.0.1" + }, + "coverage-5.0.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0c768e914f48483be0a527d1e641edec", + "name": "coverage", + "sha256": "0b46ad416f4a9ce55fd198d56831e4e90e1cc0f14015bc9f1210cdbe9f98c292", + "size": 252866, + "subdir": "linux-64", + "timestamp": 1597708900252, + "version": "5.0.2" + }, + "coverage-5.0.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f14511698b695bbd555f11f5637a888b", + "name": "coverage", + "sha256": "347c249dc975961bce6df360e61a9563faf266e8ce91d2b119c52884c1c23eee", + "size": 253209, + "subdir": "linux-64", + "timestamp": 1597708872307, + "version": "5.0.2" + }, + "coverage-5.0.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1155c88597390d08bd4e114e2bc77fcd", + "name": "coverage", + "sha256": "c4ea9aeacabda0ba441cd96f00a726b17413fa806cd6d28cfa89e04d36a4c46f", + "size": 253628, + "subdir": "linux-64", + "timestamp": 1597708876212, + "version": "5.0.2" + }, + "coverage-5.0.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8c4e8570efb16ffde7b875aee631c20f", + "name": "coverage", + "sha256": "d0f69c5390309ad41cebfb214c61e717ec65d05c1105edbd9592c89440a83c64", + "size": 253359, + "subdir": "linux-64", + "timestamp": 1597709373631, + "version": "5.0.3" + }, + "coverage-5.0.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "487611560fd3e8477d5221911866b1af", + "name": "coverage", + "sha256": "e51e89111958639977e3b79abf5f4c6e8161d8a19a698eca621ac1b086d125c1", + "size": 257106, + "subdir": "linux-64", + "timestamp": 1597709355466, + "version": "5.0.3" + }, + "coverage-5.0.3-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b057ff31125a1d213fa0e8c1ea7de1fe", + "name": "coverage", + "sha256": "5ab8743b049a8bf400617a2e0e9388a8d4b25c4255c142804edf087bfb3a9c16", + "size": 257790, + "subdir": "linux-64", + "timestamp": 1597709355506, + "version": "5.0.3" + }, + "coverage-5.0.4-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d2aca9c4b38715b89d84437bbe60e577", + "name": "coverage", + "sha256": "f4a6457c2352e951b47537d826018e14b900d8f2f20fa80a3f0370984b4ece2a", + "size": 257114, + "subdir": "linux-64", + "timestamp": 1597709693850, + "version": "5.0.4" + }, + "coverage-5.0.4-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "de32c54c05bdb6a940f22996f9ac72a0", + "name": "coverage", + "sha256": "ec612372f3f11adf4c37c1456d868e923fa64fd5374be9aab75c4f8aa6c31151", + "size": 257349, + "subdir": "linux-64", + "timestamp": 1597711912863, + "version": "5.0.4" + }, + "coverage-5.0.4-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b1ba2956a13d28b02aff7f1e6ad22448", + "name": "coverage", + "sha256": "15e8f5c46002125a1f558ad7f2308f07bfbbf6f6a12017d883763e0fff85b718", + "size": 254308, + "subdir": "linux-64", + "timestamp": 1597709713027, + "version": "5.0.4" + }, + "coverage-5.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "29a041b46323bb7fbcd925c3710d92bf", + "name": "coverage", + "sha256": "ac7ccbfb0edce8af3c3c86b39433428b17087961bd4fed5067c1f9046fb1d6ee", + "size": 257555, + "subdir": "linux-64", + "timestamp": 1597709922277, + "version": "5.1" + }, + "coverage-5.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "deb2c67b6b215138c9c9d00061644771", + "name": "coverage", + "sha256": "589958066c96646149394d12c300ecfdd89dfe9ea2d2e88f896792c3ec32efb2", + "size": 255082, + "subdir": "linux-64", + "timestamp": 1597709932222, + "version": "5.1" + }, + "coverage-5.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b0a35712d91664c78ea6c03000da69a0", + "name": "coverage", + "sha256": "2e4bdd4ae23061e48343d1f4caa320058e1173a5459f66ca29cd056656290e7e", + "size": 258793, + "subdir": "linux-64", + "timestamp": 1597709945150, + "version": "5.1" + }, + "coverage-5.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b9cb6fcf72488912de1aa78a0923a6b4", + "name": "coverage", + "sha256": "cf76f4a5d6fd15a7c414e48307e1853de252f0c35c0036adb03d059146628d43", + "size": 256117, + "subdir": "linux-64", + "timestamp": 1597710103726, + "version": "5.2" + }, + "coverage-5.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c84bf43fe0b0d6959d5f4d7407595f0b", + "name": "coverage", + "sha256": "a8d870415bd0de4fedd8e732467754c8751c88c24249641cc8406cef9a0fa349", + "size": 255962, + "subdir": "linux-64", + "timestamp": 1597710066639, + "version": "5.2" + }, + "coverage-5.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "470d80c7eab4231210ea5b6403542282", + "name": "coverage", + "sha256": "741b673f961c1020b7e74d34be14c252e97270d2c16cfea79e179bdb4cbb5d62", + "size": 256929, + "subdir": "linux-64", + "timestamp": 1597710071788, + "version": "5.2" + }, + "coverage-5.2.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1e8eff13bdb7cd8a7469347017cd3f77", + "name": "coverage", + "sha256": "7baf5b9b1d7c45cedd89427c8c73e56fe31d224981d698c46a5fb8cd3300b423", + "size": 259864, + "subdir": "linux-64", + "timestamp": 1597711755077, + "version": "5.2.1" + }, + "coverage-5.2.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "244b10d87d9efeb1eac16e645e2ae1bd", + "name": "coverage", + "sha256": "ef7467732dd51af05dd35a4feda8263823659edbb358e796af89de39732c4fc5", + "size": 260177, + "subdir": "linux-64", + "timestamp": 1597711783385, + "version": "5.2.1" + }, + "coverage-5.2.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bdd5f049cfaed707b239a186cb323762", + "name": "coverage", + "sha256": "0bf7a6d838ddd830ccef27c16d011fc1a94fee86c845040ebe4baa59d1607b6c", + "size": 261218, + "subdir": "linux-64", + "timestamp": 1597711761523, + "version": "5.2.1" + }, + "coverage-5.3-py36h27cfd23_2.conda": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "b7cc831b46fbf97e3b5a27fc2c6204e5", + "name": "coverage", + "sha256": "f7d79bf4025e9af5f664892ffae5fd60bad9dab70d7acb0f9de0002874b03ea5", + "size": 268633, + "subdir": "linux-64", + "timestamp": 1605479797101, + "version": "5.3" + }, + "coverage-5.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ea34eba15acd4a419ff7d82d3ef5db62", + "name": "coverage", + "sha256": "b72b7268f07a0da56a68eaf8c1d64b219116540d71f5868b1401d7f50cbfcc2a", + "size": 253702, + "subdir": "linux-64", + "timestamp": 1600293243800, + "version": "5.3" + }, + "coverage-5.3-py37h27cfd23_2.conda": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "881e1fb6f5edc7fb7a0ade0e2085e17a", + "name": "coverage", + "sha256": "95c68987712ae55b9c0c5e86248280409ca13b5307250b3ae560e1c0e625b99c", + "size": 268677, + "subdir": "linux-64", + "timestamp": 1605479767534, + "version": "5.3" + }, + "coverage-5.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "73b5a91146351494ace16e4c87be1af0", + "name": "coverage", + "sha256": "a556863293fa1ac74194d2f1b9b42edb27abd7de01088a171c59ef18add7ab0f", + "size": 253711, + "subdir": "linux-64", + "timestamp": 1600293252126, + "version": "5.3" + }, + "coverage-5.3-py38h27cfd23_2.conda": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "361b579bfacf9c61783ad0e86fb1df53", + "name": "coverage", + "sha256": "558505d0a52a97dcc9a532da166dbfbfc0927aadbf7a419dfab8459d6c2d47b0", + "size": 265625, + "subdir": "linux-64", + "timestamp": 1605479808767, + "version": "5.3" + }, + "coverage-5.3-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9b35032d9ba60f429447f1f6248ff9c8", + "name": "coverage", + "sha256": "313b24932f74c65910095996040f916e4c4790f1d1755e2e9db0f8974a2febd6", + "size": 258001, + "subdir": "linux-64", + "timestamp": 1600293241538, + "version": "5.3" + }, + "coverage-5.3-py39h27cfd23_2.conda": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "e2ae647a751739320ba113f4e0fd2645", + "name": "coverage", + "sha256": "ecf15ae53c5e58821f8e293914b50ed1d709e9957e6441c466daaf7a6bb0f8a3", + "size": 269775, + "subdir": "linux-64", + "timestamp": 1605479770319, + "version": "5.3" + }, + "coverage-5.3.1-py36h27cfd23_2.conda": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "9e1d0a3fa8d9ff09bc6992144f0031af", + "name": "coverage", + "sha256": "f0298d7bb796c8f864ce7beea8480635f77cabd7095b6f808a803604a431581f", + "size": 260870, + "subdir": "linux-64", + "timestamp": 1608575815738, + "version": "5.3.1" + }, + "coverage-5.3.1-py37h27cfd23_2.conda": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "43b98c238ff6ec8ee0ad60aadc4b2345", + "name": "coverage", + "sha256": "64c00feab455ca587299314a1761802d4597670c5e496dd671c16b62c0d3924a", + "size": 261695, + "subdir": "linux-64", + "timestamp": 1608575847822, + "version": "5.3.1" + }, + "coverage-5.3.1-py38h27cfd23_2.conda": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "103acef444f3a67f6e7be4410fdcbf81", + "name": "coverage", + "sha256": "352baa9ed0f66cf15cd64f37a5b0b5d5fb62e12c317979e27421fb9953701132", + "size": 262682, + "subdir": "linux-64", + "timestamp": 1608575848931, + "version": "5.3.1" + }, + "coverage-5.3.1-py39h27cfd23_2.conda": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "cb48ebd900c2df9774c8eed09ba0ffe7", + "name": "coverage", + "sha256": "fcba4a81989625187c833da1026c81f40c67376a53dbff2875aacc3531c5113e", + "size": 266491, + "subdir": "linux-64", + "timestamp": 1608575855332, + "version": "5.3.1" + }, + "coverage-5.4-py36h27cfd23_2.conda": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "c61a263b497d3f8461de2cf35e91247c", + "name": "coverage", + "sha256": "b6924e9b847f3d582aaf7bea2d5c5b5084775f9b33ae8559890599abf12d13e7", + "size": 261700, + "subdir": "linux-64", + "timestamp": 1611690835782, + "version": "5.4" + }, + "coverage-5.4-py37h27cfd23_2.conda": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "b6e2fc5c16d4dcbfd8b475e2935da26d", + "name": "coverage", + "sha256": "e2058cdaf26d658879fe8d2ae785628f5f305b8ac00aea0468e33f4ce2333849", + "size": 264833, + "subdir": "linux-64", + "timestamp": 1611690859014, + "version": "5.4" + }, + "coverage-5.4-py38h27cfd23_2.conda": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "c2eacc51b94fc0ba2ac4d964372eb295", + "name": "coverage", + "sha256": "1987e66ef72331508c34cfaa7cb85479e035eb225d51f2c9026ee2f3266c029c", + "size": 261870, + "subdir": "linux-64", + "timestamp": 1611690863238, + "version": "5.4" + }, + "coverage-5.4-py39h27cfd23_2.conda": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "e89bf206caf6f1757c261c78f314d735", + "name": "coverage", + "sha256": "32ed5fa672eb2a5b313d4f2c9b5bb87180b888f8c6967e19b01b1a664d64f839", + "size": 262006, + "subdir": "linux-64", + "timestamp": 1611690396124, + "version": "5.4" + }, + "coverage-5.5-py310h7f8727e_2.conda": { + "build": "py310h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "md5": "e78558a26ac3f7780e46710199ff7acf", + "name": "coverage", + "sha256": "81e2f2ecb448a94fc66d46e4fd00bf38829b492419236ee3392fdeb8bef5ce99", + "size": 288081, + "subdir": "linux-64", + "timestamp": 1640789227122, + "version": "5.5" + }, + "coverage-5.5-py36h27cfd23_2.conda": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "d73cb279571b1654972b4b6cf313e917", + "name": "coverage", + "sha256": "56503306ddbdfd67a996ee9b10fe99a7dbfc803319822b24c1e10338f3b76ea9", + "size": 264574, + "subdir": "linux-64", + "timestamp": 1614614249083, + "version": "5.5" + }, + "coverage-5.5-py37h27cfd23_2.conda": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "56d68cd4270407d7991ee09c18230df4", + "name": "coverage", + "sha256": "f6ea49ed691300ba362ef1cf20196559d0f9f2e9cbda9bfadb3f26419caf8cf4", + "size": 260517, + "subdir": "linux-64", + "timestamp": 1614614912831, + "version": "5.5" + }, + "coverage-5.5-py38h27cfd23_2.conda": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "42741b84cb7f6cfd80c5093f26d75659", + "name": "coverage", + "sha256": "7f671e792020ae90eb382ffb9fa85d6f6b42bc5b6b62e917f4d5bf8a460e96b8", + "size": 265561, + "subdir": "linux-64", + "timestamp": 1614613716436, + "version": "5.5" + }, + "coverage-5.5-py39h27cfd23_2.conda": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "04013683d7f74d4df67e0f14ada4d18e", + "name": "coverage", + "sha256": "2397c9cf14252e06dd2a987c299b7a3d7158df253f1296f1275797f01d5629a1", + "size": 265314, + "subdir": "linux-64", + "timestamp": 1614614909419, + "version": "5.5" + }, + "coverage-6.2-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9d7f407955834ff888befcb9e31ae44c", + "name": "coverage", + "sha256": "f726acbe3827f573c60018a751f8ab640e763d2d045187bfc646a6372b711dc7", + "size": 235484, + "subdir": "linux-64", + "timestamp": 1642021586349, + "version": "6.2" + }, + "coverage-6.2-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "34a3006ca7d8d286b63593b31b845ace", + "name": "coverage", + "sha256": "30c38f8ab24467e5f510e98a5a0748cf80d711b1e9112b7a080a92211e5b5125", + "size": 236255, + "subdir": "linux-64", + "timestamp": 1642021641889, + "version": "6.2" + }, + "coverage-6.2-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "40e175d55fafa76158091a0e7014a06f", + "name": "coverage", + "sha256": "0f06fcf427cd00514f88dd3d106d4bdc8c328a313470a4c3c6ff166f7eed9d67", + "size": 236364, + "subdir": "linux-64", + "timestamp": 1642021615856, + "version": "6.2" + }, + "coverage-6.3.2-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c8b6d8745475116e7a32da8eb3b19684", + "name": "coverage", + "sha256": "192fe5b57079a4701026872e4339ed380395bf55ca05b1297161c31543604ab2", + "size": 275994, + "subdir": "linux-64", + "timestamp": 1645522335286, + "version": "6.3.2" + }, + "coverage-6.3.2-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b74662f010f61cfd1ef9ee59e45cbdf3", + "name": "coverage", + "sha256": "8e4146cca7c1abfd67c2b4713165b7fc96652b7dbdb623d5d9ae805504130465", + "size": 302113, + "subdir": "linux-64", + "timestamp": 1676827710421, + "version": "6.3.2" + }, + "coverage-6.3.2-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "73a355808fa2b05cebbf41fbcfe90737", + "name": "coverage", + "sha256": "6d642dd316f472395a0b30583bd0513516e6dd2e070b95180bb56272c308d854", + "size": 250818, + "subdir": "linux-64", + "timestamp": 1645521024803, + "version": "6.3.2" + }, + "coverage-6.3.2-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "60da2430dbbf729bccb8623ff6c27d6f", + "name": "coverage", + "sha256": "6b1cea9c38f12906af63c943946f0ea7ab11a1d6751a8ac98aa61c75a0fff51b", + "size": 251932, + "subdir": "linux-64", + "timestamp": 1645539149102, + "version": "6.3.2" + }, + "coverage-6.3.2-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d1db18d77a3ce36ecdb1a8f14882253c", + "name": "coverage", + "sha256": "471874d4a68c14adfa25253caa5f12d2f4bdf81a6ee60be2e6f1001abd92d115", + "size": 252248, + "subdir": "linux-64", + "timestamp": 1645539150555, + "version": "6.3.2" + }, + "coverage-7.2.2-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "tomli" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "972548695b05ed28d4e51f22f74116d3", + "name": "coverage", + "sha256": "9eed6d94ee5248097c0b4629c9e2dbca4972d167ee5445722c521f1f75cde115", + "size": 287105, + "subdir": "linux-64", + "timestamp": 1680092846648, + "version": "7.2.2" + }, + "coverage-7.2.2-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b5ca40e7e105d846d822b7a7638fd561", + "name": "coverage", + "sha256": "6ae23e923b82b2da603e22dd724bd144e24643a83808f14e19b8a47253c190c6", + "size": 363249, + "subdir": "linux-64", + "timestamp": 1680092752358, + "version": "7.2.2" + }, + "coverage-7.2.2-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "tomli" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a05c1732d4e67102d2aa8d7e56de778b", + "name": "coverage", + "sha256": "74b6687cfd5cdce68f78ab4c576ff3eeab17c518c9d3991212293f020582180f", + "size": 282767, + "subdir": "linux-64", + "timestamp": 1680092783146, + "version": "7.2.2" + }, + "coverage-7.2.2-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "tomli" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e9da151b7e1f56be2cb569c65949a1d2", + "name": "coverage", + "sha256": "cac0af9dbddc843533d1d83130c18f41c01d481919ada2433a67d1183a29b066", + "size": 282913, + "subdir": "linux-64", + "timestamp": 1680092814360, + "version": "7.2.2" + }, + "coveralls-1.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=2.7,<2.8.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f8b17d87b6abdaf69172af7431af266", + "name": "coveralls", + "sha256": "edb5bf29bac026a75f1a9c5c14f306ac2f4c9494b740bd09e2ce33ecd98e2b80", + "size": 20592, + "subdir": "linux-64", + "timestamp": 1525269619727, + "version": "1.3.0" + }, + "coveralls-1.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.5,<3.6.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb421907e7f8dc194e22144da53c4f9f", + "name": "coveralls", + "sha256": "6e7467ef1c70ecd70e0df412b21b70379ecc257cc5d1495ef27bcfbdfba5613a", + "size": 20961, + "subdir": "linux-64", + "timestamp": 1525269652503, + "version": "1.3.0" + }, + "coveralls-1.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc535f555011c02960a9f2a95d50373d", + "name": "coveralls", + "sha256": "4f178b159e2c26f4d006f20f81c2a3404caf434d454608495057b31d50368b0c", + "size": 20756, + "subdir": "linux-64", + "timestamp": 1525269652165, + "version": "1.3.0" + }, + "coveralls-1.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=2.7,<2.8.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e2c2799046135c76ca4c36bc194ceef0", + "name": "coveralls", + "sha256": "f79dba9d74c77f2839fa518272885b8f08e3760747deceaca00000b5d069bf02", + "size": 21547, + "subdir": "linux-64", + "timestamp": 1535510803306, + "version": "1.4.0" + }, + "coveralls-1.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.5,<3.6.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d699a8baa1a0ad4f885ad366792ded9", + "name": "coveralls", + "sha256": "5f8101114008ef7a43fd1f1315ce0a45003041733c804f4509102cdeb93498a2", + "size": 22082, + "subdir": "linux-64", + "timestamp": 1535510448951, + "version": "1.4.0" + }, + "coveralls-1.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9a05f674316c51a4ac53a5b1dc49fec", + "name": "coveralls", + "sha256": "dce2f9a80cd9e07c950808daaac2d240006f00bbb3ae6f4ff291167c9616d819", + "size": 21818, + "subdir": "linux-64", + "timestamp": 1535510419312, + "version": "1.4.0" + }, + "coveralls-1.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "072e0d6c2459035cc4cbc08ea91938d7", + "name": "coveralls", + "sha256": "4e97283edcf5d3357a4a1748ffe0e2399e7c8350965b4a11dae05aac3451335c", + "size": 21695, + "subdir": "linux-64", + "timestamp": 1535510489646, + "version": "1.4.0" + }, + "coveralls-1.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=2.7,<2.8.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dfb637ee0a1c81b6d6c1575abe749260", + "name": "coveralls", + "sha256": "69d5e8d22eca3a869df8ed527613e70f16926832bdf4aa187944d61fb590a5fd", + "size": 21683, + "subdir": "linux-64", + "timestamp": 1536263542769, + "version": "1.5.0" + }, + "coveralls-1.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.5,<3.6.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a51cac73c9412347d7456a620e551a78", + "name": "coveralls", + "sha256": "0dcfc14f0ed909eefa50e9e50db776615eaa04f36fad9791252ab66df94ff7d3", + "size": 22009, + "subdir": "linux-64", + "timestamp": 1536263595629, + "version": "1.5.0" + }, + "coveralls-1.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3dac03d7c0f5cedf7d88ddd91abd1638", + "name": "coveralls", + "sha256": "b5bd0daf6ad25be73068ab0ddf48abc4f3f209fa7e6f46bb95d615d04cbd06ff", + "size": 21545, + "subdir": "linux-64", + "timestamp": 1536263488387, + "version": "1.5.0" + }, + "coveralls-1.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8330761b87fc9320a8f6a88a7e478ac", + "name": "coveralls", + "sha256": "715f3d507c14e18775c7c1af5795955f2a82c0cb74fde0de8be1d703a894bcc9", + "size": 21796, + "subdir": "linux-64", + "timestamp": 1536263609510, + "version": "1.5.0" + }, + "coveralls-1.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=2.7,<2.8.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48249ae032e72ef7df75a53c87315c8f", + "name": "coveralls", + "sha256": "604953e0c6525a623c2eab48d94219e5e2bd7c880e1a6193fe2b91d4b71cf0a8", + "size": 21647, + "subdir": "linux-64", + "timestamp": 1538367567151, + "version": "1.5.1" + }, + "coveralls-1.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "853032a6b952ef5fc7e1ecb4b7944171", + "name": "coveralls", + "sha256": "3d74285449d86af865b2bfc16ab869626a22d904b455228a56a0ba36c058be70", + "size": 21571, + "subdir": "linux-64", + "timestamp": 1538367600005, + "version": "1.5.1" + }, + "coveralls-1.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "coverage >=3.6", + "docopt >=0.6.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10", + "requests >=1.0.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87b0ccba13845a8e3434c1a76f107542", + "name": "coveralls", + "sha256": "03611ada27cd2f8d4cc31d89e2b771331ee6b1e6c710bee2361546439c272d96", + "size": 21609, + "subdir": "linux-64", + "timestamp": 1538367574651, + "version": "1.5.1" + }, + "cpp-expected-1.0.0-hd09550d_0.conda": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "e5caa87bc9242acbcdc5655461cf61fb", + "name": "cpp-expected", + "sha256": "759108b83b827625a035c5ba0ca16c42094408025ec43a60309c182bc8a267ec", + "size": 126059, + "subdir": "linux-64", + "timestamp": 1651255703555, + "version": "1.0.0" + }, + "cpp-filesystem-1.5.10-hd09550d_0.conda": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe0a0d2b6286a2e0442644fd0a44619e", + "name": "cpp-filesystem", + "sha256": "edd5790e89447c0ed9a5a9230fd63d055d2269be8bcebbcae5f5b6ac28fb44b2", + "size": 38337, + "subdir": "linux-64", + "timestamp": 1645571464140, + "version": "1.5.10" + }, + "cppy-1.2.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b4f73d2c3f340d210bedfe062e75acad", + "name": "cppy", + "sha256": "f8747fb175b419cbc1385682ecbed49d79f1d767f8bf12cbdd57c31a5e63caf3", + "size": 11932, + "subdir": "linux-64", + "timestamp": 1652450068463, + "version": "1.2.1" + }, + "cppy-1.2.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1c7c0225267859baf2afda6a18432d6f", + "name": "cppy", + "sha256": "49000c9b8090f6c5c24b31a71d5642be92a4583b62af6e8b7ad5eb4846b15b0d", + "size": 13009, + "subdir": "linux-64", + "timestamp": 1676825189406, + "version": "1.2.1" + }, + "cppy-1.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d450532048ac57529fd40fd4461afd63", + "name": "cppy", + "sha256": "65dc017eb94a9fe27a027cb6329143f298e130bfe7b250d7d04544a15570a6ba", + "size": 11919, + "subdir": "linux-64", + "timestamp": 1652450006384, + "version": "1.2.1" + }, + "cppy-1.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "114a83d8181691001815018a50dce744", + "name": "cppy", + "sha256": "4619bf2225653b3f269bb1b04d168b9ccbb78c6002631c0bc843b2fad5c05ca6", + "size": 11915, + "subdir": "linux-64", + "timestamp": 1652450031540, + "version": "1.2.1" + }, + "cppy-1.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "40bda654f8a845faa0da3fc7e79b53f6", + "name": "cppy", + "sha256": "23ec51ff79498fbe08b7036be2ddc13815f70240818d4ee78754db538c614f45", + "size": 11915, + "subdir": "linux-64", + "timestamp": 1652449980876, + "version": "1.2.1" + }, + "cram-0.7-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "b1f1a6cbad50fa52a05c708746b56e90", + "name": "cram", + "sha256": "73d2692cac8d2687c2f82bcea7ed24278e30c9a827d13a04228700bfb5d9f9bc", + "size": 44999, + "subdir": "linux-64", + "timestamp": 1539182904468, + "version": "0.7" + }, + "cram-0.7-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "910320f5e993a5711506a1457717e94a", + "name": "cram", + "sha256": "844d0adc994bf1495dd1505141c22257368edcdacb6096f12518b9efd995b8aa", + "size": 45070, + "subdir": "linux-64", + "timestamp": 1539182927005, + "version": "0.7" + }, + "cram-0.7-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "6713630de2e8d168782b582e31e93c19", + "name": "cram", + "sha256": "e283235014115401b72a7b3fc8aa466882137421c3acd5089e1c8466e1fe9f8e", + "size": 45202, + "subdir": "linux-64", + "timestamp": 1539182908399, + "version": "0.7" + }, + "crashtest-0.4.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d7d5cb306b89fa72964c9ccde1062f9f", + "name": "crashtest", + "sha256": "d1459b8f106527f4bcf5aaa3b49eebcd88bc03293d4eb2cfd889d85c449d35cf", + "size": 15768, + "subdir": "linux-64", + "timestamp": 1679422478049, + "version": "0.4.1" + }, + "crashtest-0.4.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c11599b40f6daa4a9d318f7e90fd6d8f", + "name": "crashtest", + "sha256": "1168e283ed5bd9fab80c3e866bc3b17290a96d61a40ba3c30298d58c56505068", + "size": 18062, + "subdir": "linux-64", + "timestamp": 1679422403237, + "version": "0.4.1" + }, + "crashtest-0.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c1406e4f7a682dab9f461ffc0ea6732", + "name": "crashtest", + "sha256": "4e93affd3cbd419a5d260cc1fd4eed26263d228d4c3b3e7b88f6eb00322732a9", + "size": 15541, + "subdir": "linux-64", + "timestamp": 1679422428423, + "version": "0.4.1" + }, + "crashtest-0.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9edb4fc27e2f6213b1507e582488d20", + "name": "crashtest", + "sha256": "1bab4e17e775e9901c919fe80f2a2343554ada030bbcba466aae5051af59ff95", + "size": 15611, + "subdir": "linux-64", + "timestamp": 1679422452487, + "version": "0.4.1" + }, + "crender-0.3-ha290191_1.conda": { + "build": "ha290191_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0" + ], + "license": "MIT", + "md5": "df7307795d80efd6ef1fd3b5de4db160", + "name": "crender", + "sha256": "b7051dd4c01b37b23762bc7b782494218058d7dd06f0e50b8ef5e8c6db2840d8", + "size": 1043940, + "subdir": "linux-64", + "timestamp": 1644229016381, + "version": "0.3" + }, + "crender-0.4-ha290191_0.conda": { + "build": "ha290191_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b20829f8cf1839a225112154007b45ee", + "name": "crender", + "sha256": "1e0f4d1169adb9ddd3924ae80caab75a1c1358e1d36d97e6fb56286ae5a5d938", + "size": 1040916, + "subdir": "linux-64", + "timestamp": 1654289728027, + "version": "0.4" + }, + "crender-0.5-ha290191_0.conda": { + "build": "ha290191_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "252e92418993672c8cc6963ee7ad9ba4", + "name": "crender", + "sha256": "3650e16334ef20d857331aeb9a07d9263f71775284849eb1d1972242cb2b3445", + "size": 1134075, + "subdir": "linux-64", + "timestamp": 1667935072086, + "version": "0.5" + }, + "cron-descriptor-1.2.24-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "c4acdb876dae81c79615fe661563da99", + "name": "cron-descriptor", + "sha256": "4412f6a0f02590f728f93d5b9beeba624c835613454df6b785a0f48bf2e7d8ca", + "size": 32985, + "subdir": "linux-64", + "timestamp": 1659858463731, + "version": "1.2.24" + }, + "cron-descriptor-1.2.24-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "614633701791f581caf4e0f0424d5e74", + "name": "cron-descriptor", + "sha256": "73dec942316ae5b079adc814457d57af25c7b9792fd2b260a7f051bd08978a1c", + "size": 39397, + "subdir": "linux-64", + "timestamp": 1676830370154, + "version": "1.2.24" + }, + "cron-descriptor-1.2.24-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "37b3f3386c2f20f9d8313aca5cb30968", + "name": "cron-descriptor", + "sha256": "bbb53cc87a6d6441b262e5beb65de171988d5ad628d41b23a145666ccf2e7a6d", + "size": 32674, + "subdir": "linux-64", + "timestamp": 1659858547877, + "version": "1.2.24" + }, + "cron-descriptor-1.2.24-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "fed95dfb3993670b2858b7f19285bba6", + "name": "cron-descriptor", + "sha256": "f867c4f769ce3dc46f5c73a05fd02c7fd1a82b0850a808d54f316cd484621f3d", + "size": 32575, + "subdir": "linux-64", + "timestamp": 1659858520811, + "version": "1.2.24" + }, + "cron-descriptor-1.2.24-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "7533d53ca60edb6373b5a7396cfffd3f", + "name": "cron-descriptor", + "sha256": "5b78c29bf3554bd6d593dedb5d64da25ebbe226670d843c0737283bf54f41176", + "size": 32782, + "subdir": "linux-64", + "timestamp": 1659858494211, + "version": "1.2.24" + }, + "croniter-1.3.7-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f7d117a1fcea2edce79c547d3a587691", + "name": "croniter", + "sha256": "42b5968348ba390894e0d6be9fa42415b0f6e32f34ba2ef6983c64a76ddff537", + "size": 31433, + "subdir": "linux-64", + "timestamp": 1666888102909, + "version": "1.3.7" + }, + "croniter-1.3.7-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b761f32ecc47294d4885a1d100fe54f5", + "name": "croniter", + "sha256": "ea5dff7b513fec73c36dfec78772d46b57c4b88d335af1c308803314d33dbcad", + "size": 38995, + "subdir": "linux-64", + "timestamp": 1676830384053, + "version": "1.3.7" + }, + "croniter-1.3.7-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc624af877c1c93c43adc25e83808743", + "name": "croniter", + "sha256": "c832c60627cc667b527f0d4d480891de30b440b0ec9efb889c55a4849509ac2d", + "size": 31067, + "subdir": "linux-64", + "timestamp": 1666888178639, + "version": "1.3.7" + }, + "croniter-1.3.7-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49721ea762453e396327380aaf90ee57", + "name": "croniter", + "sha256": "cfbe02b80d64da544f34dc2d1ab944355727839f5dc8efafb3b22d96c979b064", + "size": 31296, + "subdir": "linux-64", + "timestamp": 1666888128106, + "version": "1.3.7" + }, + "croniter-1.3.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e097ee8268b51ab6ff7348319b32804d", + "name": "croniter", + "sha256": "644ac1b60c0c8e44ba0078df14a063091aaa19deab3cda1a9142f202637723e7", + "size": 31229, + "subdir": "linux-64", + "timestamp": 1666888153084, + "version": "1.3.7" + }, + "crosstool-ng-1.23.0.rc2.diorcety.linux_target_2-h1bed415_4.conda": { + "build": "h1bed415_4", + "build_number": 4, + "depends": [], + "md5": "64c448cfdc4bff7e1521e26d822bea17", + "name": "crosstool-ng", + "sha256": "654c4ae60400f609b0ddf823aeee492c1e0a99d60c49856916814bdc89dc181f", + "size": 18248000, + "subdir": "linux-64", + "timestamp": 1520532738497, + "version": "1.23.0.rc2.diorcety.linux_target_2" + }, + "crosstool-ng-1.23.0.rc2.diorcety.linux_target_2-h307460b_3.conda": { + "build": "h307460b_3", + "build_number": 3, + "depends": [ + "libtool", + "ncurses" + ], + "md5": "96ba7c86321babca33cadcae73acdbe5", + "name": "crosstool-ng", + "sha256": "b2cc3ae80b2335091ad18becb0e08dab45051145d591c7cd049589da26265089", + "size": 16726905, + "subdir": "linux-64", + "timestamp": 1505664156306, + "version": "1.23.0.rc2.diorcety.linux_target_2" + }, + "crosstool-ng-1.23.0.rc2.diorcety.linux_target_2-h99d4681_3.conda": { + "build": "h99d4681_3", + "build_number": 3, + "depends": [ + "libtool", + "ncurses" + ], + "md5": "ac9e347af2c3ff35491b72adca40ea69", + "name": "crosstool-ng", + "sha256": "788093e9a2c69d9213e7efa9005bd6b88a7f9220327450b59a7062ae9c1eb11a", + "size": 16729207, + "subdir": "linux-64", + "timestamp": 1507259455014, + "version": "1.23.0.rc2.diorcety.linux_target_2" + }, + "cryptacular-1.4.1-py27h7b6447c_1.conda": { + "build": "py27h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "pbkdf2", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "53ec827531f7cef8219f094564a10ca0", + "name": "cryptacular", + "sha256": "40f193d7d85d26fd3975349a2b1e322b3923e7ae586af75371de66be122a2ae2", + "size": 35950, + "subdir": "linux-64", + "timestamp": 1540442606790, + "version": "1.4.1" + }, + "cryptacular-1.4.1-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "pbkdf2", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "8db58e0dd3976e51f7ae04350953b853", + "name": "cryptacular", + "sha256": "6723117b96f086eed4c1467d8b2bf3141fc1659a051fcea173825f4c874643bf", + "size": 59042, + "subdir": "linux-64", + "timestamp": 1640808718287, + "version": "1.4.1" + }, + "cryptacular-1.4.1-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "pbkdf2", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "3737a8082874e0ba136e7086c4c89220", + "name": "cryptacular", + "sha256": "d38b2b90092ec1f0f41724f2103e09ec16956ed265765d72f85899fb5eaa2fa8", + "size": 278011, + "subdir": "linux-64", + "timestamp": 1614007052275, + "version": "1.4.1" + }, + "cryptacular-1.4.1-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "pbkdf2", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "df52bbf05ef047a162102b9111183a30", + "name": "cryptacular", + "sha256": "b7c14a4556d5eee3d999339a34e9ce6b516c2e9dc9cce6dfdda79a95bd521ea5", + "size": 36070, + "subdir": "linux-64", + "timestamp": 1540442649746, + "version": "1.4.1" + }, + "cryptacular-1.4.1-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "pbkdf2", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "dd4389d85dd4466555641a09a48924f1", + "name": "cryptacular", + "sha256": "ecf12a855331c2e5d777571b912148a50fd19821a9296ff69d59533b59f6b0ea", + "size": 277455, + "subdir": "linux-64", + "timestamp": 1614007058459, + "version": "1.4.1" + }, + "cryptacular-1.4.1-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "pbkdf2", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "a18db7c45430e1836030f7a7e7c17351", + "name": "cryptacular", + "sha256": "286e039226e8b09a4f8db44d6c89f84c781ed88b5ccb0e360f56c8863463909a", + "size": 36214, + "subdir": "linux-64", + "timestamp": 1540442625042, + "version": "1.4.1" + }, + "cryptacular-1.4.1-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "pbkdf2", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "8edc1dafe0c6974805e8e4f52ae63131", + "name": "cryptacular", + "sha256": "f8f15a21455bfd3fc1be0aea2d6e87a0c4d3ea4e3373201fed646c6e90d54362", + "size": 278552, + "subdir": "linux-64", + "timestamp": 1614007063035, + "version": "1.4.1" + }, + "cryptacular-1.4.1-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "pbkdf2", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "c3662c353c9244b5b945c09f42d7a699", + "name": "cryptacular", + "sha256": "66f2235eddf53a05d5e898927eaf5835e0a354db69ae1b20898e8b62ad9cb692", + "size": 43143, + "subdir": "linux-64", + "timestamp": 1574097982401, + "version": "1.4.1" + }, + "cryptacular-1.4.1-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "pbkdf2", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "16db96537384ed276c0e7cdd800dd4f5", + "name": "cryptacular", + "sha256": "332e9f19cc08874b1be042e7df26281777816e041a47989ee81670af8e11be8e", + "size": 277130, + "subdir": "linux-64", + "timestamp": 1614007049082, + "version": "1.4.1" + }, + "cryptacular-1.6.2-py36h7f8727e_1.conda": { + "build": "py36h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "pbkdf2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c1ee0fb8a26cb73d99e28b3338fe5252", + "name": "cryptacular", + "sha256": "c2e6849e9856e2a818ce5b12968d407ebdcdf8f8fa43ca044765a54c6b0f482b", + "size": 34587, + "subdir": "linux-64", + "timestamp": 1629813218557, + "version": "1.6.2" + }, + "cryptacular-1.6.2-py37h7f8727e_1.conda": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "pbkdf2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f36b08c1c6c99e5d00b52280c5f7ae01", + "name": "cryptacular", + "sha256": "be5a68448758151dfc2fa5d829c1c566ca2d1e1fd518b6014254d160e68eb7ba", + "size": 34831, + "subdir": "linux-64", + "timestamp": 1629813194991, + "version": "1.6.2" + }, + "cryptacular-1.6.2-py38h7f8727e_1.conda": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "pbkdf2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "0635b5368f3f4cf17d925a693dd7f0e2", + "name": "cryptacular", + "sha256": "6bdee2f4bc717836122bf85dd4cedf4d8461dc21ba12e8be311bfea075115c55", + "size": 34914, + "subdir": "linux-64", + "timestamp": 1629813109188, + "version": "1.6.2" + }, + "cryptacular-1.6.2-py39h7f8727e_1.conda": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "pbkdf2", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "aa0d45fad80a323689ed23b7efee48af", + "name": "cryptacular", + "sha256": "55cf0d59913cf20de87fb4dd20f47fe746c1d6e4f227e59e61ae516f561da61e", + "size": 34676, + "subdir": "linux-64", + "timestamp": 1629804322276, + "version": "1.6.2" + }, + "cryptography-2.0.3-py27hea39389_1.conda": { + "build": "py27hea39389_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "3cc6e1fd95f2a32fa1e311330cc18e9f", + "name": "cryptography", + "sha256": "9cbf9b4050fa462f5cd00857e3e4106da9e5116f4f3ad25968a9552a0cf61125", + "size": 528190, + "subdir": "linux-64", + "timestamp": 1505692156287, + "version": "2.0.3" + }, + "cryptography-2.0.3-py35hef72dfd_1.conda": { + "build": "py35hef72dfd_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "c1ec5a3b3a4dff57003db346fd43e3b3", + "name": "cryptography", + "sha256": "e0c16ab685d30e2eba864a57c25df0be4a8941877874cfe7938e1766242fb54a", + "size": 534672, + "subdir": "linux-64", + "timestamp": 1505692423670, + "version": "2.0.3" + }, + "cryptography-2.0.3-py36ha225213_1.conda": { + "build": "py36ha225213_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "ad50ae5173ae98959684d74a64d193f7", + "name": "cryptography", + "sha256": "bf3a5251bbb45cad5616d73b5cf7e1a199aa39bd0ac5fbcd1508b4ec6a88a84a", + "size": 532356, + "subdir": "linux-64", + "timestamp": 1505692706043, + "version": "2.0.3" + }, + "cryptography-2.1.3-py27hb02c096_0.conda": { + "build": "py27hb02c096_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "2c5db6e4ae5d435495f57901243b93e7", + "name": "cryptography", + "sha256": "2abbacf77ae892cb147eb70c68a5848a3de51b7a39c400ceb65facf5b2869ad6", + "size": 540796, + "subdir": "linux-64", + "timestamp": 1511927139218, + "version": "2.1.3" + }, + "cryptography-2.1.3-py35hf0ae51d_0.conda": { + "build": "py35hf0ae51d_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "63ef6e202b707f62484b6f5cb4694736", + "name": "cryptography", + "sha256": "7357875d9fbebaa36800d97ec1ea60c30e772018a189a9c500352a5d3e5bbcb9", + "size": 545919, + "subdir": "linux-64", + "timestamp": 1511927151113, + "version": "2.1.3" + }, + "cryptography-2.1.3-py36h6e66a57_0.conda": { + "build": "py36h6e66a57_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "420b097301e8905872e0d5e0eb9f855a", + "name": "cryptography", + "sha256": "0984df54202394225523904e2f32d692bc7d5ba86bf68c16a7b2c8b3824ac5f7", + "size": 539887, + "subdir": "linux-64", + "timestamp": 1511927270089, + "version": "2.1.3" + }, + "cryptography-2.1.4-py27h6697b16_0.conda": { + "build": "py27h6697b16_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "aedef9c7048fd1dd82ea7ba865d0b0aa", + "name": "cryptography", + "sha256": "75fc0362e249178f54bbd63fb3af675fecc088985571fd77bc13be80b80e92f0", + "size": 538601, + "subdir": "linux-64", + "timestamp": 1512206182299, + "version": "2.1.4" + }, + "cryptography-2.1.4-py35hbeb2da1_0.conda": { + "build": "py35hbeb2da1_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "c9f30725d7efe04b611eab717a47ed05", + "name": "cryptography", + "sha256": "93e8f0993a478099fdff5ed3f945cbd2382e9d599b809baf2b8b7ae7bc81dc44", + "size": 543758, + "subdir": "linux-64", + "timestamp": 1512206186404, + "version": "2.1.4" + }, + "cryptography-2.1.4-py36hd09be54_0.conda": { + "build": "py36hd09be54_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "ecb72ff58a961fbbe371ddb20cc6c033", + "name": "cryptography", + "sha256": "48b3d3fac8873247f57ab815d9c38b6b694850086a048e78811cd7fa5572f9ac", + "size": 541839, + "subdir": "linux-64", + "timestamp": 1512206187827, + "version": "2.1.4" + }, + "cryptography-2.2.1-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2n,<1.0.3a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "486ff2184a4ac152521ca17314a8dbba", + "name": "cryptography", + "sha256": "5b10842aad622e6b305dfebe780d58b19a041e3172b12e29faafd49a3a6d0f91", + "size": 533193, + "subdir": "linux-64", + "timestamp": 1521784801205, + "version": "2.2.1" + }, + "cryptography-2.2.1-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2n,<1.0.3a", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "67535b7dd7db78689a2354ec4c2b81ab", + "name": "cryptography", + "sha256": "3c4a811c1f48d2198a340a4604ad0e23ced3a2334f826f3cfaf7901b5d38730b", + "size": 538499, + "subdir": "linux-64", + "timestamp": 1521784907036, + "version": "2.2.1" + }, + "cryptography-2.2.1-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2n,<1.0.3a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "53087f6494f519d3e8a51d9ad01c91f4", + "name": "cryptography", + "sha256": "16f3aedb7851bbbd8d3ddd9f0ec85ac4d8731307c7f10e4d7d473d1dcbf42b42", + "size": 538442, + "subdir": "linux-64", + "timestamp": 1521784620488, + "version": "2.2.1" + }, + "cryptography-2.2.2-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2o,<1.0.3a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "94f2dcff88dc4978d56e8ba270eee749", + "name": "cryptography", + "sha256": "3bda3b3f13278f14a7f26e7da2ab29d89ba4e9eaeff4a3cca2a04de3b12e902d", + "size": 532887, + "subdir": "linux-64", + "timestamp": 1522685523370, + "version": "2.2.2" + }, + "cryptography-2.2.2-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "cf91ede62dfa60008bbd8e0501ecde0c", + "name": "cryptography", + "sha256": "972d59dbee3446d55c8a4c9ce07050a914ad2b21e28c9678028a73820ca65794", + "size": 537557, + "subdir": "linux-64", + "timestamp": 1522686225010, + "version": "2.2.2" + }, + "cryptography-2.2.2-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "28427471814b1ee06d93ca00e12312f3", + "name": "cryptography", + "sha256": "13c71653ede69c7974e4b73b8c06994980eb4dd77890f9ffd55ddcf39c8dbf2c", + "size": 538362, + "subdir": "linux-64", + "timestamp": 1522685313430, + "version": "2.2.2" + }, + "cryptography-2.2.2-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "f0dd2aee4b6f49b812db649a814d1e40", + "name": "cryptography", + "sha256": "4a26367eaf739991365bfa37b250f3affd705c6745876fa10a227a810f708e0a", + "size": 538289, + "subdir": "linux-64", + "timestamp": 1530733149138, + "version": "2.2.2" + }, + "cryptography-2.3-py27hb7f436b_0.conda": { + "build": "py27hb7f436b_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "cryptography-vectors 2.3.*", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "1032fb93ebe682eddb28ce595b3374e8", + "name": "cryptography", + "sha256": "8fb1b6b48af63e47e33f989e4e836f0d010ede92a9e809a76101631b5d49dd37", + "size": 520618, + "subdir": "linux-64", + "timestamp": 1532993453599, + "version": "2.3" + }, + "cryptography-2.3-py27hb7f436b_1.conda": { + "build": "py27hb7f436b_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "cryptography-vectors 2.3.*", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "51f0affc7e732d849078b953eabcf243", + "name": "cryptography", + "sha256": "7676424f2fb0d48cb5fd18a6cbbbd3870b83ddd6717341948aa23a7419daf487", + "size": 521288, + "subdir": "linux-64", + "timestamp": 1534349625743, + "version": "2.3" + }, + "cryptography-2.3-py35hb7f436b_0.conda": { + "build": "py35hb7f436b_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "cryptography-vectors 2.3.*", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "087f5fada97929d885d6daef126c18a9", + "name": "cryptography", + "sha256": "3040c7d35015edddc4b3299c73b21530f86b2d6015e3e0fcaef21f20b5c3a233", + "size": 526662, + "subdir": "linux-64", + "timestamp": 1532991004241, + "version": "2.3" + }, + "cryptography-2.3-py35hb7f436b_1.conda": { + "build": "py35hb7f436b_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "cryptography-vectors 2.3.*", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "8a06e2d0459e91ede8e76366d31907f4", + "name": "cryptography", + "sha256": "a8ca600eb2a52a19e3f7adf43c1fdcb28c3792f9b124c1a0ea9b973bf01c8a98", + "size": 530458, + "subdir": "linux-64", + "timestamp": 1534349998681, + "version": "2.3" + }, + "cryptography-2.3-py36hb7f436b_0.conda": { + "build": "py36hb7f436b_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "cryptography-vectors 2.3.*", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "9df81ab6ec670ac00e777d2e65172582", + "name": "cryptography", + "sha256": "e26cde7b6da47213e6407b14206c4b6f2b14704608e3e24f87474077f0028a29", + "size": 526737, + "subdir": "linux-64", + "timestamp": 1532990527437, + "version": "2.3" + }, + "cryptography-2.3-py36hb7f436b_1.conda": { + "build": "py36hb7f436b_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "cryptography-vectors 2.3.*", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "7ea80f47483edc61525ec70f80bcde8f", + "name": "cryptography", + "sha256": "bafd754ffa92b06a02fdeb73e7605f55e3e2697fc5e2b14db48df48b572eefe2", + "size": 526586, + "subdir": "linux-64", + "timestamp": 1534350351218, + "version": "2.3" + }, + "cryptography-2.3-py37hb7f436b_0.conda": { + "build": "py37hb7f436b_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "cryptography-vectors 2.3.*", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "56cfc6d06a896c47a6c9df5919af3756", + "name": "cryptography", + "sha256": "839b61f11c0978133b6d1576825a54aec5d7043e28acdcfca722b4c52f9712ff", + "size": 524977, + "subdir": "linux-64", + "timestamp": 1532990627280, + "version": "2.3" + }, + "cryptography-2.3-py37hb7f436b_1.conda": { + "build": "py37hb7f436b_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "cryptography-vectors 2.3.*", + "idna >=2.1", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "05eae66a11ed75ea38babafa2253198a", + "name": "cryptography", + "sha256": "97d2433ac385dc6aa022736994196e9ec9e1d75c2132598a876eeb21decf7a58", + "size": 524374, + "subdir": "linux-64", + "timestamp": 1534349286938, + "version": "2.3" + }, + "cryptography-2.3.1-py27h1ba5d50_2.conda": { + "build": "py27h1ba5d50_2", + "build_number": 2, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "ee87d4c373752dac65aeb532cec027cf", + "name": "cryptography", + "sha256": "778ac6820254775a1980fa14c948caae99a763486b792b18407543ef3b2ab70b", + "size": 530014, + "subdir": "linux-64", + "timestamp": 1540943752934, + "version": "2.3.1" + }, + "cryptography-2.3.1-py27hc365091_0.conda": { + "build": "py27hc365091_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "454112b882d221ce9e0a0638894e2e01", + "name": "cryptography", + "sha256": "0c896f8e9eb78d45bc45444ddffff4cb8cb6ee9122c23f3e8f0d86c97c084de3", + "size": 524746, + "subdir": "linux-64", + "timestamp": 1535130005605, + "version": "2.3.1" + }, + "cryptography-2.3.1-py35hc365091_0.conda": { + "build": "py35hc365091_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "b23aa5c032524a75fda9edbc4ebbbb68", + "name": "cryptography", + "sha256": "35e273ef7c365a91c1599b636187a4afb872ae612eaf4f644700e9cdf216bfc7", + "size": 527348, + "subdir": "linux-64", + "timestamp": 1535126712495, + "version": "2.3.1" + }, + "cryptography-2.3.1-py36h1ba5d50_2.conda": { + "build": "py36h1ba5d50_2", + "build_number": 2, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "96aa365d194e81a491b095859f9ea837", + "name": "cryptography", + "sha256": "5c11191fe03345f767bf41cfe48157c0e2b83ab92d7e9ac09aabc32eabbd33b8", + "size": 535094, + "subdir": "linux-64", + "timestamp": 1540943770160, + "version": "2.3.1" + }, + "cryptography-2.3.1-py36hc365091_0.conda": { + "build": "py36hc365091_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "74fbaa09aa3016debc5cfa2eee6fa76a", + "name": "cryptography", + "sha256": "776655f42af26e952a65095e0e174eae3c650b2f6facd1ac7eafe843b0848f5a", + "size": 525852, + "subdir": "linux-64", + "timestamp": 1535129032419, + "version": "2.3.1" + }, + "cryptography-2.3.1-py37h1ba5d50_2.conda": { + "build": "py37h1ba5d50_2", + "build_number": 2, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "93753fa7840cf6c4766088321832062f", + "name": "cryptography", + "sha256": "59470b442b916805de117642706ddb1f82f1ab1b1d8c9ca8018627e2084525a8", + "size": 535321, + "subdir": "linux-64", + "timestamp": 1540943787408, + "version": "2.3.1" + }, + "cryptography-2.3.1-py37hc365091_0.conda": { + "build": "py37hc365091_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "47d0054e04be74ecd116fc9e5a749289", + "name": "cryptography", + "sha256": "37917d50512f619f5c27fb13eb2ad676cf6e51ab6d5213376aae2c30d61171f4", + "size": 526839, + "subdir": "linux-64", + "timestamp": 1535126718521, + "version": "2.3.1" + }, + "cryptography-2.4.1-py27h1ba5d50_0.conda": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "3d61ab9ab0dde385ec5ace2b057dc012", + "name": "cryptography", + "sha256": "3bab6137caf645cf74938fa844f975d3158e4e086cf6553b42f965bcd92f7bcc", + "size": 547747, + "subdir": "linux-64", + "timestamp": 1542313386506, + "version": "2.4.1" + }, + "cryptography-2.4.1-py27h1ba5d50_1.conda": { + "build": "py27h1ba5d50_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "edb5e5fcf392a7907dd61a7657ae313d", + "name": "cryptography", + "sha256": "df4a6c598845bf0a6873172187cfdf2f709ffead686c5c1449459c518eb99f84", + "size": 546311, + "subdir": "linux-64", + "timestamp": 1544809946456, + "version": "2.4.1" + }, + "cryptography-2.4.1-py36h1ba5d50_0.conda": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "396230bddb4e64335a08dafa3848f1b7", + "name": "cryptography", + "sha256": "cdb1a6577b7cacdb253b8c647ac9ae7064f59d3db3283fb93bc660b3c3d3304f", + "size": 549613, + "subdir": "linux-64", + "timestamp": 1542380950028, + "version": "2.4.1" + }, + "cryptography-2.4.1-py36h1ba5d50_1.conda": { + "build": "py36h1ba5d50_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "33f96419492959fc5efce0c90dc12e00", + "name": "cryptography", + "sha256": "cc5f62d997dba5410ec03f9f9e07932aa3bfa3cc2030e7e7fff80bed03051a8b", + "size": 549889, + "subdir": "linux-64", + "timestamp": 1544809971014, + "version": "2.4.1" + }, + "cryptography-2.4.1-py37h1ba5d50_0.conda": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "7b09179c5351858742cc495d2fd83e95", + "name": "cryptography", + "sha256": "55040e35e573fef974cbcc5dfa0925e312a498e128c05c61024723962e520701", + "size": 552210, + "subdir": "linux-64", + "timestamp": 1542313358511, + "version": "2.4.1" + }, + "cryptography-2.4.1-py37h1ba5d50_1.conda": { + "build": "py37h1ba5d50_1", + "build_number": 1, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "b03d06b92a0260f8e0a6f36eb07b4631", + "name": "cryptography", + "sha256": "0f17434bc76818613399dcc3bbaf33a77d1a17fe37e7dc37793a7b76eeef7dad", + "size": 549833, + "subdir": "linux-64", + "timestamp": 1544809883636, + "version": "2.4.1" + }, + "cryptography-2.4.2-py27h1ba5d50_0.conda": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "bdc5db142af35470effee2c012066126", + "name": "cryptography", + "sha256": "aeb3a909a1edb30a2f9b749afdf8d2741299116c8c9be59bdf6edb92f3e9f32d", + "size": 546068, + "subdir": "linux-64", + "timestamp": 1545070801909, + "version": "2.4.2" + }, + "cryptography-2.4.2-py36h1ba5d50_0.conda": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "e1d1059fd288a97e2b252567b3e2f54e", + "name": "cryptography", + "sha256": "b28a94d8a4e2620362caf590bbe58b786aa0e2c40297c457b4a2358d57754d03", + "size": 550874, + "subdir": "linux-64", + "timestamp": 1545070871266, + "version": "2.4.2" + }, + "cryptography-2.4.2-py37h1ba5d50_0.conda": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "ec94a6f157bbb3a94b76f15980bc1c1c", + "name": "cryptography", + "sha256": "2996c0c999c1dbfcaf60baf3e2266d5a29b166c3ffc8d160e465f3a591057a5e", + "size": 551334, + "subdir": "linux-64", + "timestamp": 1545070849520, + "version": "2.4.2" + }, + "cryptography-2.5-py27h1ba5d50_0.conda": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "f2c3b453439d2d69b90303af90d6d72e", + "name": "cryptography", + "sha256": "95fcb00fc20af61a112aebabe6831482427ba57063d53fa17f6455290a51854b", + "size": 564565, + "subdir": "linux-64", + "timestamp": 1549646478549, + "version": "2.5" + }, + "cryptography-2.5-py36h1ba5d50_0.conda": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "33760fa55f3d6c0a245edbc300c9c187", + "name": "cryptography", + "sha256": "26756c9b0de0760da432a22274d9f2f8db13d40054b89953933826bbae8309bf", + "size": 572533, + "subdir": "linux-64", + "timestamp": 1549646495097, + "version": "2.5" + }, + "cryptography-2.5-py37h1ba5d50_0.conda": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "8b0f21abbddc0a8625fff2bfb1798d93", + "name": "cryptography", + "sha256": "fb444e01d9a5a558a41c2dae915712df37b92cb710a594f83d4a161d12ee3215", + "size": 569681, + "subdir": "linux-64", + "timestamp": 1549646481606, + "version": "2.5" + }, + "cryptography-2.6.1-py27h1ba5d50_0.conda": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1b,<1.1.2a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "ea0e79db424fc7da5f4e58af4873f897", + "name": "cryptography", + "sha256": "40e17835875455ffe3fa3cb402c88ce375f02ecd0f2c517cf2d134f704d92599", + "size": 546769, + "subdir": "linux-64", + "timestamp": 1552319461370, + "version": "2.6.1" + }, + "cryptography-2.6.1-py36h1ba5d50_0.conda": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1b,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "e449497e6511d595822352afa8509f38", + "name": "cryptography", + "sha256": "0e86980b3615f71e78aa5694845afec29ccb23fb3e67204642db87190e41d32e", + "size": 553682, + "subdir": "linux-64", + "timestamp": 1552319483183, + "version": "2.6.1" + }, + "cryptography-2.6.1-py37h1ba5d50_0.conda": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1b,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "561ce424b4b5974d8e3ae7e96c173297", + "name": "cryptography", + "sha256": "5377e42c4307a3ad53be9c32ce64b4ca5b82dac249abe4c964d6c2c75186c213", + "size": 553858, + "subdir": "linux-64", + "timestamp": 1552319401372, + "version": "2.6.1" + }, + "cryptography-2.7-py27h1ba5d50_0.conda": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1c,<1.1.2a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "e1f06e935105f6e648f10ae47f381e6d", + "name": "cryptography", + "sha256": "c4d837123913403f6ceac88986e42b3878c3fd97357f844a314f5fec7f5f0056", + "size": 552818, + "subdir": "linux-64", + "timestamp": 1559575608878, + "version": "2.7" + }, + "cryptography-2.7-py36h1ba5d50_0.conda": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1c,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "6058c14639ea062ab396e8fbe0892ece", + "name": "cryptography", + "sha256": "f479d81ddfaae8cb0fd42ebe9529db1da64a06a9a46293f05f5233a76cf95a58", + "size": 556789, + "subdir": "linux-64", + "timestamp": 1559575641293, + "version": "2.7" + }, + "cryptography-2.7-py37h1ba5d50_0.conda": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.7", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1c,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "9ad5715d4ba2a14fdcf51bc93c9bcb7a", + "name": "cryptography", + "sha256": "e0e6f266775ad8256c95155f4fe12b57d92adf138ec48df4a1b2d49e9f0739fd", + "size": 557498, + "subdir": "linux-64", + "timestamp": 1559575588648, + "version": "2.7" + }, + "cryptography-2.8-py27h1ba5d50_0.conda": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.8", + "enum34", + "idna >=2.1", + "ipaddress", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "3a001d5dd438d525324ebcb820fc86ba", + "name": "cryptography", + "sha256": "1210c60c0007537134f79d025b97631eca700b2cd1bf7f2f588f9e23bc344707", + "size": 560561, + "subdir": "linux-64", + "timestamp": 1571690224415, + "version": "2.8" + }, + "cryptography-2.8-py36h1ba5d50_0.conda": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.8", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "0ce6f156a0d93cd5687ef5a431730ec5", + "name": "cryptography", + "sha256": "3282756041bc5e78cd466808260f3b82aaf8f42f1964a6aee19e9a8be888ef7f", + "size": 565670, + "subdir": "linux-64", + "timestamp": 1571690325240, + "version": "2.8" + }, + "cryptography-2.8-py37h1ba5d50_0.conda": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.8", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "cc350d10fee44f6e4e86afa859cde472", + "name": "cryptography", + "sha256": "3f2aaf6f4922d468886975e66ea61fc7e46f3e77b205b8073f72be7d3a3ff1d4", + "size": 566593, + "subdir": "linux-64", + "timestamp": 1571690208325, + "version": "2.8" + }, + "cryptography-2.8-py38h1ba5d50_0.conda": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "asn1crypto >=0.21.0", + "cffi >=1.8", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache 2.0 or BSD 3-Clause, PSF 2", + "license_family": "BSD", + "md5": "9f2bd734002f683417f0057578b18414", + "name": "cryptography", + "sha256": "0d1c24e7379e10d8a0bf987358a345eaf38d2b447dc9ee462def99ecff6c77d7", + "size": 567866, + "subdir": "linux-64", + "timestamp": 1574098022173, + "version": "2.8" + }, + "cryptography-2.9.2-py36h1ba5d50_0.conda": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "95f94178609a168bf779c32af788166c", + "name": "cryptography", + "sha256": "c66f72a757d032fffe10961cbc955c4e0ea126304dc2035878ca3e37c1849142", + "size": 569496, + "subdir": "linux-64", + "timestamp": 1588861130915, + "version": "2.9.2" + }, + "cryptography-2.9.2-py37h1ba5d50_0.conda": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "53b69412247600aadd20f1a1d2e98dcb", + "name": "cryptography", + "sha256": "c7f8640045ce6226539a61580d1651d92c471824b19ae2d925b454b13eeeab40", + "size": 565330, + "subdir": "linux-64", + "timestamp": 1588861083920, + "version": "2.9.2" + }, + "cryptography-2.9.2-py38h1ba5d50_0.conda": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "1acfedd1b4deee71bc673324553f8118", + "name": "cryptography", + "sha256": "9e895e055bffb26a110f2db17086781169b3cf92134fa31c69e1536360906be9", + "size": 569694, + "subdir": "linux-64", + "timestamp": 1588861116459, + "version": "2.9.2" + }, + "cryptography-2.9.2-py39h3c74f83_0.conda": { + "build": "py39h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "624716bfa4f978aa7e2cc9809c5b2d3b", + "name": "cryptography", + "sha256": "a20aa07b28b456bbb0375bc11265a0be9c5bcbaee0d4357ebbd8442121ff5495", + "size": 569192, + "subdir": "linux-64", + "timestamp": 1608674166951, + "version": "2.9.2" + }, + "cryptography-3.0-py36h1ba5d50_0.conda": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "bf336588d7d356387e35ad897c01b825", + "name": "cryptography", + "sha256": "4c70a4a2da6b65776de08aa130d3d7a01e495b7e3a03a7130dbaceb515240f60", + "size": 586573, + "subdir": "linux-64", + "timestamp": 1598371499892, + "version": "3.0" + }, + "cryptography-3.0-py37h1ba5d50_0.conda": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "62373189bb14088344ab1d9cae034631", + "name": "cryptography", + "sha256": "0f05a9601e8055f61317fd2093365f571f6f78a4a0dee4c4fdb316d39a27130e", + "size": 580636, + "subdir": "linux-64", + "timestamp": 1598371489791, + "version": "3.0" + }, + "cryptography-3.0-py38h1ba5d50_0.conda": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "4b7ab5fecdbc5f7aa265b25df95ed9d5", + "name": "cryptography", + "sha256": "212ab8bc48330c35ec60e0f4ea87c2bdcbbad738b70b49e58a91024c4a2aa798", + "size": 586625, + "subdir": "linux-64", + "timestamp": 1598371459348, + "version": "3.0" + }, + "cryptography-3.1-py36h1ba5d50_0.conda": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "d90bd54c7a1ff2796afc2b78c2c471d6", + "name": "cryptography", + "sha256": "26353f3f7882e578fdc3414312436cda5862dcea0f136a0b9f518b26b7ee45a2", + "size": 575314, + "subdir": "linux-64", + "timestamp": 1598892109325, + "version": "3.1" + }, + "cryptography-3.1-py37h1ba5d50_0.conda": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "edb3f3a8d9ce474aadf4b0fd650ddb97", + "name": "cryptography", + "sha256": "8ba0f8e3b4f10af03e99994cae0b3178a9ec55e3b96e2bf582dc52f9da164bb5", + "size": 572355, + "subdir": "linux-64", + "timestamp": 1598892092822, + "version": "3.1" + }, + "cryptography-3.1-py38h1ba5d50_0.conda": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi", + "idna", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "3d2c0ee3870267cbd4632a2cc727f583", + "name": "cryptography", + "sha256": "9ac5d0f86e43e264df805e2c8c82a4cff811c2ea2db876feba88dc076c89be1d", + "size": 577680, + "subdir": "linux-64", + "timestamp": 1598892096360, + "version": "3.1" + }, + "cryptography-3.1.1-py36h1ba5d50_0.conda": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "491892077f9ffcc01d390a7516ae3218", + "name": "cryptography", + "sha256": "def68932b20c188585ceaea18a77da2d936c08d3cda2e46bab614b0f03c59873", + "size": 568336, + "subdir": "linux-64", + "timestamp": 1601047511597, + "version": "3.1.1" + }, + "cryptography-3.1.1-py37h1ba5d50_0.conda": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "acfe2bd032e55333347c1207579042ae", + "name": "cryptography", + "sha256": "a4a82f71bd9df37ee5197619fc41e254212b47c4a8ec79fc9e4087b7867ef98d", + "size": 566830, + "subdir": "linux-64", + "timestamp": 1601046870414, + "version": "3.1.1" + }, + "cryptography-3.1.1-py38h1ba5d50_0.conda": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "9ba6d5f7f7ae3c5383e83dbc3dbbe4a0", + "name": "cryptography", + "sha256": "f458c4ffa2ae248c458721b029978697afa10468126733aac7f6c7b618f41c1d", + "size": 570753, + "subdir": "linux-64", + "timestamp": 1601046867723, + "version": "3.1.1" + }, + "cryptography-3.2.1-py36h3c74f83_1.conda": { + "build": "py36h3c74f83_1", + "build_number": 1, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "e7df5b57a493e4de1accbce9bf44f748", + "name": "cryptography", + "sha256": "1434706e96b1c2251ecaae2584ad7fe9aa5104d61807cb4d3714615a5cfcee64", + "size": 584012, + "subdir": "linux-64", + "timestamp": 1605544536097, + "version": "3.2.1" + }, + "cryptography-3.2.1-py37h3c74f83_1.conda": { + "build": "py37h3c74f83_1", + "build_number": 1, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "376fb62f90464729c182bc093ad751db", + "name": "cryptography", + "sha256": "b778a23ff2a06b74310774487e5d608edfe2044329684a39ca1e09bd1f1b86f7", + "size": 585928, + "subdir": "linux-64", + "timestamp": 1605544506648, + "version": "3.2.1" + }, + "cryptography-3.2.1-py38h3c74f83_1.conda": { + "build": "py38h3c74f83_1", + "build_number": 1, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "2592d88e9b486bb6e4a3212114cef144", + "name": "cryptography", + "sha256": "517ae1f269188735d14cfc8ce89d2301a54c6d51b00061631d04d910085263d6", + "size": 588034, + "subdir": "linux-64", + "timestamp": 1605544552873, + "version": "3.2.1" + }, + "cryptography-3.2.1-py39h3c74f83_1.conda": { + "build": "py39h3c74f83_1", + "build_number": 1, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.9,<3.10.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "b8d7a5dc758248f057ac60905b9135af", + "name": "cryptography", + "sha256": "b11195e0f1a97c0a359f15e48486360ed3a7729d56b5187816a539defa2e87be", + "size": 584267, + "subdir": "linux-64", + "timestamp": 1605544544832, + "version": "3.2.1" + }, + "cryptography-3.3-py36h3c74f83_0.conda": { + "build": "py36h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "dbaac53092df6f8319e2d6986fa42766", + "name": "cryptography", + "sha256": "abe57d8f0f8362f603340466bb15aeb387643cca8bb105a459481fd6d4609102", + "size": 574870, + "subdir": "linux-64", + "timestamp": 1607540738699, + "version": "3.3" + }, + "cryptography-3.3-py37h3c74f83_0.conda": { + "build": "py37h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "c20db0f0419212bd427eb46548172e6d", + "name": "cryptography", + "sha256": "d617a93cfb6d1992e3f1a1f9ea50d60764f391ca595f88d582ed49cf610ce8c8", + "size": 578572, + "subdir": "linux-64", + "timestamp": 1607540746536, + "version": "3.3" + }, + "cryptography-3.3-py38h3c74f83_0.conda": { + "build": "py38h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "4b84813437c1cf478aaf797a60830582", + "name": "cryptography", + "sha256": "56a0785957a44b410a95e1aaf510783986fbe5fa407aa3f62cafee9a07e60c85", + "size": 574665, + "subdir": "linux-64", + "timestamp": 1607540772240, + "version": "3.3" + }, + "cryptography-3.3-py39h3c74f83_0.conda": { + "build": "py39h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.9,<3.10.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "7d1e37c3332bc1a175c95e871d2c3031", + "name": "cryptography", + "sha256": "79e8c9e77057719362cc5db220cff9a84dff49f190cccf60f0f5edcb585aabf5", + "size": 576079, + "subdir": "linux-64", + "timestamp": 1607540754998, + "version": "3.3" + }, + "cryptography-3.3.1-py36h3c74f83_0.conda": { + "build": "py36h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "13dbc103efd7aed5879bddaf0e34724f", + "name": "cryptography", + "sha256": "bbcd71c20e079c496ff78f6235aec0f888d1c16b874a23cbc8b94003dac62305", + "size": 570848, + "subdir": "linux-64", + "timestamp": 1607635361733, + "version": "3.3.1" + }, + "cryptography-3.3.1-py36h3c74f83_1.conda": { + "build": "py36h3c74f83_1", + "build_number": 1, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "8db583e41f6de4d17b16d2d203f74cf8", + "name": "cryptography", + "sha256": "8b1068ed1c44ffc84c6bcd5dc1382369bb44b1d6b4a79bac761ef825766ae680", + "size": 581016, + "subdir": "linux-64", + "timestamp": 1613401458050, + "version": "3.3.1" + }, + "cryptography-3.3.1-py37h3c74f83_0.conda": { + "build": "py37h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "6882b1abe1d5d995bd73c11dc8d93619", + "name": "cryptography", + "sha256": "8d236098b3c7fa37c3f9458b91ae2ef82e1a8dbb6b7aab858339881e3f3167e0", + "size": 578184, + "subdir": "linux-64", + "timestamp": 1607635405608, + "version": "3.3.1" + }, + "cryptography-3.3.1-py37h3c74f83_1.conda": { + "build": "py37h3c74f83_1", + "build_number": 1, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "5754f254d4963766f612ca3289699a23", + "name": "cryptography", + "sha256": "9e8c79e0f6c3e96ba795fe640d6b678612adcc9483d1aee7dd7d7f3853077458", + "size": 585493, + "subdir": "linux-64", + "timestamp": 1613401505861, + "version": "3.3.1" + }, + "cryptography-3.3.1-py38h3c74f83_0.conda": { + "build": "py38h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "0fa9b82c4b16b1d0af7c750233e84a41", + "name": "cryptography", + "sha256": "9177c4e60cb30be76acfa181940cba11453a7eae615bc899fed48d6df962dd32", + "size": 579276, + "subdir": "linux-64", + "timestamp": 1607635408007, + "version": "3.3.1" + }, + "cryptography-3.3.1-py38h3c74f83_1.conda": { + "build": "py38h3c74f83_1", + "build_number": 1, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "6c4f4727dbd9933fb7a4fffda7dd1b9e", + "name": "cryptography", + "sha256": "8de2a1f7ccae15160d6a698213af9e5ee9c63fd39325878861bfd3e80658b88b", + "size": 580540, + "subdir": "linux-64", + "timestamp": 1613400933356, + "version": "3.3.1" + }, + "cryptography-3.3.1-py39h3c74f83_0.conda": { + "build": "py39h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.9,<3.10.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "465b1be14adf2880246308e067df4a46", + "name": "cryptography", + "sha256": "36cbb0095e26161df1075e06f4e45fb7b1dc41570f2b37c145d5fe5f3258bdb3", + "size": 574268, + "subdir": "linux-64", + "timestamp": 1607635380932, + "version": "3.3.1" + }, + "cryptography-3.3.1-py39h3c74f83_1.conda": { + "build": "py39h3c74f83_1", + "build_number": 1, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.9,<3.10.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "1d8361f79226b43b98fe71ca7430e003", + "name": "cryptography", + "sha256": "547f2eee88119ddff8eb77b9abe2f1871ed48da75ed099d71a49a56a5d3d2913", + "size": 583341, + "subdir": "linux-64", + "timestamp": 1613401516558, + "version": "3.3.1" + }, + "cryptography-3.3.2-py36h3c74f83_0.conda": { + "build": "py36h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "122781dc4162f921631c70848aa85f0f", + "name": "cryptography", + "sha256": "084c7d84c0d39c18bcbf3c714a882bb3d92860c5022268bda6d6c9525efe98cd", + "size": 578784, + "subdir": "linux-64", + "timestamp": 1615505313058, + "version": "3.3.2" + }, + "cryptography-3.3.2-py37h3c74f83_0.conda": { + "build": "py37h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "659e0eb3cbdaf17e3d286dbecb052bc4", + "name": "cryptography", + "sha256": "30f03630ea89ae8104746e46a5a0e7cf9690fb6a207169d22d07acc6b3067f99", + "size": 579646, + "subdir": "linux-64", + "timestamp": 1615505316217, + "version": "3.3.2" + }, + "cryptography-3.3.2-py38h3c74f83_0.conda": { + "build": "py38h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "5df3c77cb750c276b88a875c1f64a6bd", + "name": "cryptography", + "sha256": "618df186fa1cf0eb158db561cf6540209da3e4b089d893a61c002f31cca4287f", + "size": 581213, + "subdir": "linux-64", + "timestamp": 1615503676542, + "version": "3.3.2" + }, + "cryptography-3.3.2-py39h3c74f83_0.conda": { + "build": "py39h3c74f83_0", + "build_number": 0, + "depends": [ + "cffi !=1.11.3,>=1.8", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.9,<3.10.0a0", + "six >=1.4.1" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "d8cfe03f89ebee1036feba8cd87233ef", + "name": "cryptography", + "sha256": "2c2cecdbf4bc9d35c453d15de16be42668c363a1596f424a8fb56eeeecb333d9", + "size": 586828, + "subdir": "linux-64", + "timestamp": 1615505306566, + "version": "3.3.2" + }, + "cryptography-3.4.6-py36hd23ed53_0.conda": { + "build": "py36hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "24ce44eef2d0ec086a874b6eb2336dee", + "name": "cryptography", + "sha256": "cd2ffd81369109a6812cb141ffc7c5bda1a849b23bdca98f70dea4e1b1ab17ab", + "size": 929575, + "subdir": "linux-64", + "timestamp": 1615532272933, + "version": "3.4.6" + }, + "cryptography-3.4.6-py37hd23ed53_0.conda": { + "build": "py37hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "3f5913a98b6caf47a60fe6d9f793f576", + "name": "cryptography", + "sha256": "0b91e0a069a8e44df6f653690ac383db017fb01f01350f76bf1579f8f5782f2f", + "size": 929707, + "subdir": "linux-64", + "timestamp": 1615530943978, + "version": "3.4.6" + }, + "cryptography-3.4.6-py38hd23ed53_0.conda": { + "build": "py38hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "aa66de8f40aa441f39dca9b585af1317", + "name": "cryptography", + "sha256": "35f431a7c87dc61bcb0a2c538409e86863090600bfc833bbc98ebf7149f7c39b", + "size": 928363, + "subdir": "linux-64", + "timestamp": 1615532597178, + "version": "3.4.6" + }, + "cryptography-3.4.6-py39hd23ed53_0.conda": { + "build": "py39hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "4132f9ffa34d2b2ef5777a7fd81be664", + "name": "cryptography", + "sha256": "c633532af7e816c41c125b263a7a7fcf3e1e2e5caa65523115c6a0bc14e67d69", + "size": 926558, + "subdir": "linux-64", + "timestamp": 1615532601770, + "version": "3.4.6" + }, + "cryptography-3.4.7-py36hd23ed53_0.conda": { + "build": "py36hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1k,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "3f6125d0c193acbf59538a328518e58b", + "name": "cryptography", + "sha256": "cfe0368598fe34d66e99d4d490b1f2717d7be4ac304e8d4e4ef6062e763be0a6", + "size": 924306, + "subdir": "linux-64", + "timestamp": 1616769445889, + "version": "3.4.7" + }, + "cryptography-3.4.7-py37hd23ed53_0.conda": { + "build": "py37hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1k,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "633ee4362064b20bf7acd3da2cb6c82a", + "name": "cryptography", + "sha256": "b99770ae0d37070207397fbf65f1ac826ad9feb6d78dc720f8c26c7c75ff1fa7", + "size": 925703, + "subdir": "linux-64", + "timestamp": 1616769355987, + "version": "3.4.7" + }, + "cryptography-3.4.7-py38hd23ed53_0.conda": { + "build": "py38hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1k,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "2a1dbcc79beff36a06ca7a53f8316efc", + "name": "cryptography", + "sha256": "0fde7a632e74740ce705628dceba950b2b8a94478897ba3a77d7e506c9951652", + "size": 934557, + "subdir": "linux-64", + "timestamp": 1616769470690, + "version": "3.4.7" + }, + "cryptography-3.4.7-py39hd23ed53_0.conda": { + "build": "py39hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1k,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "8c4ba6d660cfb76a231129f9e81c1c0d", + "name": "cryptography", + "sha256": "667eb1750127cb57f548eb346f7fd5d991befedb0ff0a6462b6bd41abd1b6c54", + "size": 928034, + "subdir": "linux-64", + "timestamp": 1616767201071, + "version": "3.4.7" + }, + "cryptography-3.4.8-py37hd23ed53_0.conda": { + "build": "py37hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "e85ad35faf17419efed958b115f66956", + "name": "cryptography", + "sha256": "fd764f56d15877177f9d3c0706ee365fc67fd62e4966f075bf13c360bf9cd0b5", + "size": 963364, + "subdir": "linux-64", + "timestamp": 1633521716954, + "version": "3.4.8" + }, + "cryptography-3.4.8-py38hd23ed53_0.conda": { + "build": "py38hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "39aabc7130ee9e28741b2893ab4bd9ba", + "name": "cryptography", + "sha256": "e269808c81c8470bc3bf15f855105ec3ced0b4deac4b8f69bd4ba63c1c4ba104", + "size": 964679, + "subdir": "linux-64", + "timestamp": 1633520558217, + "version": "3.4.8" + }, + "cryptography-3.4.8-py39hd23ed53_0.conda": { + "build": "py39hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "a7e7d5b57710eef52bf56c8168f114c7", + "name": "cryptography", + "sha256": "0797ec841e3814a216f3f5003cd806ad6046b864865dd410ac806def82ed5752", + "size": 969119, + "subdir": "linux-64", + "timestamp": 1633520529458, + "version": "3.4.8" + }, + "cryptography-35.0.0-py36hd23ed53_0.conda": { + "build": "py36hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "e4ceb15e60d1cbc3ddb345f224656cbb", + "name": "cryptography", + "sha256": "dcf07070ebe8134deab7a4d067fefaeb07dc167495c1931df79f9acfc36b0aa7", + "size": 1330628, + "subdir": "linux-64", + "timestamp": 1635366316115, + "version": "35.0.0" + }, + "cryptography-35.0.0-py37hd23ed53_0.conda": { + "build": "py37hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "c95ebdbb0b21eeb831c1e69b354b9bab", + "name": "cryptography", + "sha256": "4383006f52645aa8266858bdb3059768f40ba5997f163ffef0ded816c74988b4", + "size": 1336155, + "subdir": "linux-64", + "timestamp": 1635355084621, + "version": "35.0.0" + }, + "cryptography-35.0.0-py38hd23ed53_0.conda": { + "build": "py38hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "f6830665b2192d04173ce77582e4cf4e", + "name": "cryptography", + "sha256": "927c0d90e5880428f7ddbf4a7117a037ac84efda4323e1738f2bb0c576323b32", + "size": 1338478, + "subdir": "linux-64", + "timestamp": 1635366770742, + "version": "35.0.0" + }, + "cryptography-35.0.0-py39hd23ed53_0.conda": { + "build": "py39hd23ed53_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "29df7c6b3304b63244eac2cbb81e3302", + "name": "cryptography", + "sha256": "ce613ad15013f472287371b1343c0c94da037ed4c41a15dde2f3d956aadc4593", + "size": 1336469, + "subdir": "linux-64", + "timestamp": 1635366308162, + "version": "35.0.0" + }, + "cryptography-36.0.0-py310h9ce1e76_0.conda": { + "build": "py310h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "1e1cdbf17495d835e68a231648a151d5", + "name": "cryptography", + "sha256": "14a45c8c1cf5a5a551804677f938d39b62acf94db25d6ed838a1db4bb0a02e35", + "size": 1650107, + "subdir": "linux-64", + "timestamp": 1640808838438, + "version": "36.0.0" + }, + "cryptography-36.0.0-py37h9ce1e76_0.conda": { + "build": "py37h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "58c4d950ab49773c116bc1a4148c4453", + "name": "cryptography", + "sha256": "a04a8b1a83507c4152fd6abac20e64d3b205706fb92b404e637ca43efe2b412d", + "size": 1398622, + "subdir": "linux-64", + "timestamp": 1639414779465, + "version": "36.0.0" + }, + "cryptography-36.0.0-py38h9ce1e76_0.conda": { + "build": "py38h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "c09592544c145d9a803cf1cdb2b43b42", + "name": "cryptography", + "sha256": "1896e178a8fec33132f12dd9d0043dfab5e5d8fb49b3b9dfb181f20a35559a8e", + "size": 1399301, + "subdir": "linux-64", + "timestamp": 1639401036933, + "version": "36.0.0" + }, + "cryptography-36.0.0-py39h9ce1e76_0.conda": { + "build": "py39h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 AND BSD-3-Clause AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "80423034596f7bf5c42bd2e65e6f75b8", + "name": "cryptography", + "sha256": "a1bcb544ce0fc5ada32d3c7cfe814973ebb21a3c0618a46ce0409e0fe0a46b1f", + "size": 1404475, + "subdir": "linux-64", + "timestamp": 1639414790730, + "version": "36.0.0" + }, + "cryptography-37.0.1-py310h9ce1e76_0.conda": { + "build": "py310h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.10,<3.11.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "d79b4926a9e7c333e99f352261e9ecca", + "name": "cryptography", + "sha256": "14ecbe0728c0d7e7a77a07816dae64f1e385e8da265cc7121b7cd581653aba4c", + "size": 1615371, + "subdir": "linux-64", + "timestamp": 1652101799179, + "version": "37.0.1" + }, + "cryptography-37.0.1-py37h9ce1e76_0.conda": { + "build": "py37h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.7,<3.8.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "d26d1619162d58af7c9ad8744f24cfb8", + "name": "cryptography", + "sha256": "c30a46a9b61c05b57b261188cd9f1d7f03b4ec5976e34079d3a53de959a1c384", + "size": 1346769, + "subdir": "linux-64", + "timestamp": 1652083665624, + "version": "37.0.1" + }, + "cryptography-37.0.1-py38h9ce1e76_0.conda": { + "build": "py38h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.8,<3.9.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "16d301ed789096eb9881a25ed7a1155e", + "name": "cryptography", + "sha256": "c14b17e8e4bebbdffa04be42db74e89fb1e21f7d52c0b91cd6add0488b337133", + "size": 1351050, + "subdir": "linux-64", + "timestamp": 1652083948459, + "version": "37.0.1" + }, + "cryptography-37.0.1-py39h9ce1e76_0.conda": { + "build": "py39h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.9,<3.10.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "47356ee727fc4f30592513464309b871", + "name": "cryptography", + "sha256": "44c23a23eeb8ea67e56e4c1b105db311e97bee47d9a2f3d3de5db0746c1b4391", + "size": 1352238, + "subdir": "linux-64", + "timestamp": 1652101795822, + "version": "37.0.1" + }, + "cryptography-38.0.1-py310h9ce1e76_0.conda": { + "build": "py310h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.10,<3.11.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "f9aba54a3e93124c31846c700f502f9d", + "name": "cryptography", + "sha256": "09cd6fd76253f3121d8224b2390e0678a9c8594f081857c1cf96de052639e3af", + "size": 1353088, + "subdir": "linux-64", + "timestamp": 1665613295924, + "version": "38.0.1" + }, + "cryptography-38.0.1-py37h9ce1e76_0.conda": { + "build": "py37h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.7,<3.8.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "5eaae755bc8e7a49ec5b17567d251fa0", + "name": "cryptography", + "sha256": "d6a7f7db47e3b9fc4cd02e8b412506b9eff8cd8a63d319a8f25ae433411bfadc", + "size": 1344318, + "subdir": "linux-64", + "timestamp": 1665612808358, + "version": "38.0.1" + }, + "cryptography-38.0.1-py38h9ce1e76_0.conda": { + "build": "py38h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.8,<3.9.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "1f179fad71e46b148b6f471770fa64f3", + "name": "cryptography", + "sha256": "b0de8ca16d54ce92d77d8e1536931e80bd7358889b51cdd95c351482cd0d0608", + "size": 1347236, + "subdir": "linux-64", + "timestamp": 1665613054282, + "version": "38.0.1" + }, + "cryptography-38.0.1-py39h9ce1e76_0.conda": { + "build": "py39h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.9,<3.10.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "0fb33632c7dc0813d181c58230488cfc", + "name": "cryptography", + "sha256": "67c4e23bd979b7c689e8f31752d027c7d4b7401c96b4f8fc879f05e1e984290c", + "size": 1346171, + "subdir": "linux-64", + "timestamp": 1665613528373, + "version": "38.0.1" + }, + "cryptography-38.0.4-py310h9ce1e76_0.conda": { + "build": "py310h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.10,<3.11.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "f75cc72c0e3460f6959f68171721c74f", + "name": "cryptography", + "sha256": "99bd896072c1abf46b2fc982889a5be6b3497dd96324ada6fce13b1ffcf6df11", + "size": 1474711, + "subdir": "linux-64", + "timestamp": 1673299122438, + "version": "38.0.4" + }, + "cryptography-38.0.4-py311hbdeaff8_0.conda": { + "build": "py311hbdeaff8_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.11,<3.12.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "b6f1d8d13930d292b38dbb0f00e64f27", + "name": "cryptography", + "sha256": "45fa0fa4c38a06d2e9bdd299351def9c30a59b134a5889d15fccfdd8d407dbfc", + "size": 1420727, + "subdir": "linux-64", + "timestamp": 1676824509583, + "version": "38.0.4" + }, + "cryptography-38.0.4-py37h9ce1e76_0.conda": { + "build": "py37h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.7,<3.8.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "a5d4715cb23d4f3493817349f7eca864", + "name": "cryptography", + "sha256": "8eddfce45aad42e5f781547560a1596c1112643d821ba03870fef4d7bd1b561d", + "size": 1466312, + "subdir": "linux-64", + "timestamp": 1673299343515, + "version": "38.0.4" + }, + "cryptography-38.0.4-py38h9ce1e76_0.conda": { + "build": "py38h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.8,<3.9.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "069a127658760920e9d53c31325fb8ce", + "name": "cryptography", + "sha256": "53b952909374d3e4c0252073dda6a9e302359725ba7c1182ca8655a180f37ca4", + "size": 1470162, + "subdir": "linux-64", + "timestamp": 1673298903332, + "version": "38.0.4" + }, + "cryptography-38.0.4-py39h9ce1e76_0.conda": { + "build": "py39h9ce1e76_0", + "build_number": 0, + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.9,<3.10.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "52136f55ebc78ad10354df15ddaa581a", + "name": "cryptography", + "sha256": "5b9e8a738436302fd283c23377b21e03587705885e41acb7492f3c9c7bdcfaa0", + "size": 1469124, + "subdir": "linux-64", + "timestamp": 1673299566607, + "version": "38.0.4" + }, + "cryptography-39.0.1-py310h9ce1e76_0.conda": { + "build": "py310h9ce1e76_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=23.0.0" + ], + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.10,<3.11.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "71f493886ed29220fb1b6e60ae511e68", + "name": "cryptography", + "sha256": "a0723351d96d0e227bb4ab2239b35d3db443997afa7bf113be8bb4132b093897", + "size": 1485343, + "subdir": "linux-64", + "timestamp": 1677533240358, + "version": "39.0.1" + }, + "cryptography-39.0.1-py311h9ce1e76_0.conda": { + "build": "py311h9ce1e76_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=23.0.0" + ], + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.11,<3.12.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "16bea2216f03f039e182fd62fd53d51c", + "name": "cryptography", + "sha256": "0cdea3a185823876e2721025b0064b36b561e1b1efc9987300b10f2714645e02", + "size": 1427919, + "subdir": "linux-64", + "timestamp": 1679335768469, + "version": "39.0.1" + }, + "cryptography-39.0.1-py37h9ce1e76_0.conda": { + "build": "py37h9ce1e76_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=23.0.0" + ], + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.7,<3.8.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "509328daac8377d28aea28eb51b60b0f", + "name": "cryptography", + "sha256": "0bc4a9db0e56de7d867b2aa2f9777bab976a5e9f95c4521a2089649cae707e1f", + "size": 1478253, + "subdir": "linux-64", + "timestamp": 1677533732417, + "version": "39.0.1" + }, + "cryptography-39.0.1-py38h9ce1e76_0.conda": { + "build": "py38h9ce1e76_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=23.0.0" + ], + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.8,<3.9.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "ad365e5ba98df04384bb85fe322bc1a4", + "name": "cryptography", + "sha256": "cde87ffd3ca9a53a48ceac1443396fddb1edba741f3ccf6066ec7f94b0f3884f", + "size": 1481665, + "subdir": "linux-64", + "timestamp": 1677533986384, + "version": "39.0.1" + }, + "cryptography-39.0.1-py39h9ce1e76_0.conda": { + "build": "py39h9ce1e76_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=23.0.0" + ], + "depends": [ + "cffi >=1.12", + "libgcc-ng", + "openssl", + "python >=3.9,<3.10.0a0" + ], + "license": "(BSD-3-Clause OR Apache-2.0) AND PSF-2.0 AND MIT", + "license_family": "BSD", + "md5": "38eea02c5f2ff123ddfa0b706482d0d3", + "name": "cryptography", + "sha256": "cf174b6091e45be3923cc4f32fb8512208e12056d14b3aed354f50c1db86a9fd", + "size": 1481247, + "subdir": "linux-64", + "timestamp": 1677533487931, + "version": "39.0.1" + }, + "cryptography-vectors-2.0.3-py27h509bbd6_0.conda": { + "build": "py27h509bbd6_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "65f895765d56e8527404766b50158570", + "name": "cryptography-vectors", + "sha256": "20100d07423a29b15fc8fd1a34fb56eb4dc51830eca3554eb21759ee5fc46a28", + "size": 22230982, + "subdir": "linux-64", + "timestamp": 1505691979504, + "version": "2.0.3" + }, + "cryptography-vectors-2.0.3-py35h4e3a8f9_0.conda": { + "build": "py35h4e3a8f9_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "14c1b1554e8d8d54f3bb1f9f7d588102", + "name": "cryptography-vectors", + "sha256": "c1dd555fdf20ff40cffa9601352033398c4c556c93b907683498f4d4cfd79eff", + "size": 22906338, + "subdir": "linux-64", + "timestamp": 1505692032452, + "version": "2.0.3" + }, + "cryptography-vectors-2.0.3-py36h2661aa0_0.conda": { + "build": "py36h2661aa0_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "7b55290d0c153d87ea47d146c06ca14c", + "name": "cryptography-vectors", + "sha256": "0eeb848e19b38d5041ed3bea40f5de6ca0fe7d4b953c92a9056a457407a3367c", + "size": 22972361, + "subdir": "linux-64", + "timestamp": 1505692084973, + "version": "2.0.3" + }, + "cryptography-vectors-2.1.3-py27hb4fb482_0.conda": { + "build": "py27hb4fb482_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "ea5ec3190c70d2cef7d8306747478d79", + "name": "cryptography-vectors", + "sha256": "a6fa44ef3a0f44fc3719102f64fe68dba49d44b442590b8133edf785ac579fbd", + "size": 22215305, + "subdir": "linux-64", + "timestamp": 1511926795394, + "version": "2.1.3" + }, + "cryptography-vectors-2.1.3-py35heb52bce_0.conda": { + "build": "py35heb52bce_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "a97bb26d7093bec8891a5aac6ea7d7f9", + "name": "cryptography-vectors", + "sha256": "fd12c2e795d25b05747b937b5e8749bc94aa4384a66e09f8e63f1798a601d282", + "size": 22962885, + "subdir": "linux-64", + "timestamp": 1511926837042, + "version": "2.1.3" + }, + "cryptography-vectors-2.1.3-py36h90764bc_0.conda": { + "build": "py36h90764bc_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "8b58791af9479263b9dd720663c0865b", + "name": "cryptography-vectors", + "sha256": "d8720803a12eeb2ef1a8985ae80bc107f358f2967a690d53aa0539dcedeee323", + "size": 22216418, + "subdir": "linux-64", + "timestamp": 1511926844448, + "version": "2.1.3" + }, + "cryptography-vectors-2.1.4-py27hae77291_0.conda": { + "build": "py27hae77291_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "6d7178b7c1df9de4eb5114f0d3202cce", + "name": "cryptography-vectors", + "sha256": "924c062136d690930a565b3cdd4523750cd9faa11fea68ab3703eefedac6eb2d", + "size": 23009832, + "subdir": "linux-64", + "timestamp": 1512200509100, + "version": "2.1.4" + }, + "cryptography-vectors-2.1.4-py35h7749f18_0.conda": { + "build": "py35h7749f18_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "cd27870b2159bc49c7a225fb83756fba", + "name": "cryptography-vectors", + "sha256": "bdde3b5dd4fb5427029e3ade79ccbb3c904952be3205f02fa4b1db876853c048", + "size": 22185966, + "subdir": "linux-64", + "timestamp": 1512200517947, + "version": "2.1.4" + }, + "cryptography-vectors-2.1.4-py36h02259fb_0.conda": { + "build": "py36h02259fb_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "20f59d734a0e91df6bf46d6e25022315", + "name": "cryptography-vectors", + "sha256": "28efec98471e7c4a577805b2300210fb3e990fdb9ef6f4f833f13db2bf914c8b", + "size": 22177802, + "subdir": "linux-64", + "timestamp": 1512200528807, + "version": "2.1.4" + }, + "cryptography-vectors-2.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "dce97a33ee5c87d47858795683e4a20b", + "name": "cryptography-vectors", + "sha256": "09982abd0fa1d54dab7ffbcb29fe5f35fea321bda66bbba2e400b5376f5db4d2", + "size": 22242911, + "subdir": "linux-64", + "timestamp": 1521784367161, + "version": "2.2.1" + }, + "cryptography-vectors-2.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "f632eefd317b01cb36524bf12b693eb7", + "name": "cryptography-vectors", + "sha256": "ea2f16de3be85197cf92dad9cf2422369cddfc006466a0bf9ed4a2a6350aeb71", + "size": 22294523, + "subdir": "linux-64", + "timestamp": 1521784417554, + "version": "2.2.1" + }, + "cryptography-vectors-2.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "3c15a333ad70bd4c8cc171836d1d84b3", + "name": "cryptography-vectors", + "sha256": "bd0cb98bacfe7a79925700250e4af50772358915289b37c95dc450d725d0c795", + "size": 22254027, + "subdir": "linux-64", + "timestamp": 1521784297188, + "version": "2.2.1" + }, + "cryptography-vectors-2.2.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "07af916b9e855093dc5dea782dc355ff", + "name": "cryptography-vectors", + "sha256": "a6a709379da3f89cd7d0fdcaad5aa79044b72473e81a0806588130490c48368d", + "size": 22156258, + "subdir": "linux-64", + "timestamp": 1522684624377, + "version": "2.2.2" + }, + "cryptography-vectors-2.2.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "4a99b284af0f9a63ecbd59fce0340a69", + "name": "cryptography-vectors", + "sha256": "db2eed7adf77204c70a47fc7ce70edc9067edbab8ef8655a801ec0e0fffcec9d", + "size": 22882840, + "subdir": "linux-64", + "timestamp": 1522684778794, + "version": "2.2.2" + }, + "cryptography-vectors-2.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "3edb6cdacfe30ed72494f36e6aad2a74", + "name": "cryptography-vectors", + "sha256": "303534b7f98d4780fc812cc70a0092cf929a1ae9dbca888932f5ee3f34853826", + "size": 22236876, + "subdir": "linux-64", + "timestamp": 1522684778776, + "version": "2.2.2" + }, + "cryptography-vectors-2.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "351757469c3dba76b8ccf3b958f00522", + "name": "cryptography-vectors", + "sha256": "61c9f8aaae9285f774c2b3936002ee08c98f953140acc1719392420cbf98b88b", + "size": 22271163, + "subdir": "linux-64", + "timestamp": 1530733002357, + "version": "2.2.2" + }, + "cryptography-vectors-2.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "0ff2a2475da818dd47b73cea0ddf8344", + "name": "cryptography-vectors", + "sha256": "9ddfb0ac61bcca7f8f87369ea9138d9017aaae30629e4691d8bcec82a7e255d3", + "size": 27445863, + "subdir": "linux-64", + "timestamp": 1532876137143, + "version": "2.3" + }, + "cryptography-vectors-2.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "f961861897071c3e8b97d9e8d3a25be8", + "name": "cryptography-vectors", + "sha256": "a4e93c5b94fe1726c0e951f91a388b0215e4587ec37e3663cbe3c848d4db976d", + "size": 27607868, + "subdir": "linux-64", + "timestamp": 1532876205372, + "version": "2.3" + }, + "cryptography-vectors-2.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "1551ec313414210019ca67d79b52c07f", + "name": "cryptography-vectors", + "sha256": "6f289070e5dfe07581099bc6942bbb902f9a7c10ab7dcbb969fbae0687257dfc", + "size": 27467658, + "subdir": "linux-64", + "timestamp": 1532876135965, + "version": "2.3" + }, + "cryptography-vectors-2.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "0394287e83834e58aadfd71d321fcd34", + "name": "cryptography-vectors", + "sha256": "199d705271e3027fae07d9f95e9f8ad56af5e056ac6df2b50084a56fdfe7c0ea", + "size": 27540053, + "subdir": "linux-64", + "timestamp": 1532876233642, + "version": "2.3" + }, + "cryptography-vectors-2.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "9288af25d8b7a92b3581163d2ed960aa", + "name": "cryptography-vectors", + "sha256": "eecda6606c8e5518310a4ab48c2706a751d04d67f32fa4e8fd8740d2507da79b", + "size": 27447922, + "subdir": "linux-64", + "timestamp": 1535126039546, + "version": "2.3.1" + }, + "cryptography-vectors-2.3.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "ceab8d68ab430573467c7115b45d3845", + "name": "cryptography-vectors", + "sha256": "36df8da0aef5f16327e156adab41848a8f3a1df5dec159af59ba1772f5ee8df2", + "size": 27512071, + "subdir": "linux-64", + "timestamp": 1535126096199, + "version": "2.3.1" + }, + "cryptography-vectors-2.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "90fffb3495a8576093b9b581461a0531", + "name": "cryptography-vectors", + "sha256": "b033b8e49f8d82c0c3751dbe879508ee40437ea80d21c038f10f1fce102cb02b", + "size": 27452488, + "subdir": "linux-64", + "timestamp": 1535126198010, + "version": "2.3.1" + }, + "cryptography-vectors-2.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "de0dbca0ea5e49633a7fdfb4bd36f693", + "name": "cryptography-vectors", + "sha256": "b9f03e3ab5668a6a2de812f4047f8b3dc6da5722a6ac6ddf1260e7dd7771a77c", + "size": 27455736, + "subdir": "linux-64", + "timestamp": 1535126146652, + "version": "2.3.1" + }, + "cryptography-vectors-2.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "0e2f7b0648c6bf0af49f1d7812f3b45c", + "name": "cryptography-vectors", + "sha256": "363893666e0ffc89599d69e71161272ebce5b6eb2b4a1a42674f3748018b7aac", + "size": 27773940, + "subdir": "linux-64", + "timestamp": 1542312981280, + "version": "2.4.1" + }, + "cryptography-vectors-2.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "a783e6f4c3e9d58be1bb7c152e24a10f", + "name": "cryptography-vectors", + "sha256": "475adc5534695197f18061364b23a9d53d2f03fea3f351e20aefe4c4ca5254d1", + "size": 27767440, + "subdir": "linux-64", + "timestamp": 1542312959442, + "version": "2.4.1" + }, + "cryptography-vectors-2.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "1cecdd7baeb1ddea73a2b8a96ced756b", + "name": "cryptography-vectors", + "sha256": "4bac5baade2e11880e76db9550dae379c7f0e618458eec4e6c073596aeace877", + "size": 27589116, + "subdir": "linux-64", + "timestamp": 1542312972430, + "version": "2.4.1" + }, + "cryptography-vectors-2.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "7ba9706fb3e6b0d1fe76a66c354ceb5c", + "name": "cryptography-vectors", + "sha256": "750072bd03a4cef8dea292871c3e84183cb2c7e3eabea3421b94d313cfab96f7", + "size": 27408259, + "subdir": "linux-64", + "timestamp": 1543519401820, + "version": "2.4.2" + }, + "cryptography-vectors-2.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "76abe54d291596c1c1eedd9fe1a8e07d", + "name": "cryptography-vectors", + "sha256": "13158114e38d7deda74a50dba37494065d73feba5b6f6f2f9d055c8ec3e281ec", + "size": 27404046, + "subdir": "linux-64", + "timestamp": 1543519374937, + "version": "2.4.2" + }, + "cryptography-vectors-2.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0 or BSD 3-Clause", + "md5": "ade52321f1a62311f9cb12e0dc22a3ed", + "name": "cryptography-vectors", + "sha256": "3d71eac3fc1a6a112ffa8c33c7dce6bdf65b4b1a2c11280ddcba00fb5685897e", + "size": 27579930, + "subdir": "linux-64", + "timestamp": 1543519389147, + "version": "2.4.2" + }, + "cryptography-vectors-38.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "69702fe00c4b9ad1cbdeab9f11bc4a31", + "name": "cryptography-vectors", + "sha256": "ab20ca2dd2f53aa8cf22575f0c839bf7f9a93dc7675e7a654be33653ba950df5", + "size": 27822264, + "subdir": "linux-64", + "timestamp": 1665455073629, + "version": "38.0.1" + }, + "cryptography-vectors-38.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "e57ad65a91f8c8aeefe60bb41c1ac2e7", + "name": "cryptography-vectors", + "sha256": "d717109c349a67fc06d7c1054a912b54237887d5d27b0ac2b80c665d6c87430a", + "size": 27926908, + "subdir": "linux-64", + "timestamp": 1665455260597, + "version": "38.0.1" + }, + "cryptography-vectors-38.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "b9be11b4f2a24201e55ff7cc700b5fe5", + "name": "cryptography-vectors", + "sha256": "ca0d9bd1f095ae1a2460a045d45564e913f56db86223edbe879a3dac87b33e69", + "size": 27848381, + "subdir": "linux-64", + "timestamp": 1665455135536, + "version": "38.0.1" + }, + "cryptography-vectors-38.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "5978b290ce4106ef12e8c2d6ed7255d0", + "name": "cryptography-vectors", + "sha256": "39ea518186d067c8e72da45f57c1b89bfa1869340c97911b8716edbc2c96f3f2", + "size": 27786732, + "subdir": "linux-64", + "timestamp": 1665455197529, + "version": "38.0.1" + }, + "cryptography-vectors-38.0.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "235c652f0af19dd849b2f5ddd66f305d", + "name": "cryptography-vectors", + "sha256": "3ba74340b6e2b304d2598ad43d6c0a9134f9595e0fd64b0240ad7fb825eb7291", + "size": 32481972, + "subdir": "linux-64", + "timestamp": 1673034311741, + "version": "38.0.4" + }, + "cryptography-vectors-38.0.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "aefc5e9edb8d3e1d46b95ed81603295b", + "name": "cryptography-vectors", + "sha256": "c19ba62d569bf22a9ed56e8e2d91ea654901044a2411bad4f81ff81a03deb906", + "size": 29384785, + "subdir": "linux-64", + "timestamp": 1676851499791, + "version": "38.0.4" + }, + "cryptography-vectors-38.0.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "a967155ec7a88f28b1a78f34c5cd3f8b", + "name": "cryptography-vectors", + "sha256": "7f8104ea58263096c481accd31bd21c9ebfe94d1fc4764bd6f8e0db254552e96", + "size": 32479991, + "subdir": "linux-64", + "timestamp": 1673034438240, + "version": "38.0.4" + }, + "cryptography-vectors-38.0.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "fc0fb5b167c6f30783cc33a027a98b78", + "name": "cryptography-vectors", + "sha256": "238d70bac9caff39898f57fa0ab00fda58f9755b1b572a3b52b2b800a23ecb5e", + "size": 32481256, + "subdir": "linux-64", + "timestamp": 1673034501482, + "version": "38.0.4" + }, + "cryptography-vectors-38.0.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "a5bdb8ca194c6119cbd60e59eb6fd8fe", + "name": "cryptography-vectors", + "sha256": "9c539eb94826acda45c3b099f35cbda11540ea10cbe9652cae003e1ba3a0800e", + "size": 32475698, + "subdir": "linux-64", + "timestamp": 1673034374940, + "version": "38.0.4" + }, + "cryptography-vectors-39.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "4ff12287dd4a1d433e9a317c15412191", + "name": "cryptography-vectors", + "sha256": "deeddc04043b234f013f3a639d95aee14b77fe38b27e8a5204006b56110a2565", + "size": 32714139, + "subdir": "linux-64", + "timestamp": 1677168664467, + "version": "39.0.1" + }, + "cryptography-vectors-39.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "d713c57b6b9ab9491357fa7672556a96", + "name": "cryptography-vectors", + "sha256": "572cef61a3875fc076a918d02cf099d198446aacea87566b6052a0a9f4eca0a2", + "size": 29491114, + "subdir": "linux-64", + "timestamp": 1679335807290, + "version": "39.0.1" + }, + "cryptography-vectors-39.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "f5430c031382e1f7d608035255edf619", + "name": "cryptography-vectors", + "sha256": "ed15fe2816b43e4ab63be54aec150fafe4b0d69e1213e60ce989277f588d3671", + "size": 32716988, + "subdir": "linux-64", + "timestamp": 1677168726489, + "version": "39.0.1" + }, + "cryptography-vectors-39.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "a84855d381c241314b86a9c8d5445530", + "name": "cryptography-vectors", + "sha256": "dbde4d5a3ceddcecadea312b4601bf1cb5bdbabc6c8d5b5db78daea0641eafba", + "size": 32709578, + "subdir": "linux-64", + "timestamp": 1677168539814, + "version": "39.0.1" + }, + "cryptography-vectors-39.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause OR Apache-2.0", + "license_family": "BSD", + "md5": "b2640591907ce066ef4eb015626d9a90", + "name": "cryptography-vectors", + "sha256": "e94fb3e9cde96c41de3b34727c91789ac440ba20d3a4bda56ed2873dacc9d51a", + "size": 32738604, + "subdir": "linux-64", + "timestamp": 1677168602037, + "version": "39.0.1" + }, + "cryptominisat-5.6.6-h5d072ba_0.conda": { + "build": "h5d072ba_0", + "build_number": 0, + "depends": [ + "libboost >=1.67.0,<1.67.1.0a0", + "libcryptominisat 5.6.6 h0e08187_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ddc24f10a36bb8a0851ab0e2d9554374", + "name": "cryptominisat", + "sha256": "c75ac082f9a7f3b6968b13948f10e19de7d92507ce57517e9c4de510e0f90101", + "size": 728629, + "subdir": "linux-64", + "timestamp": 1548447108484, + "version": "5.6.6" + }, + "cryptominisat-5.6.6-hc2b5a8e_0.conda": { + "build": "hc2b5a8e_0", + "build_number": 0, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0", + "libcryptominisat 5.6.6 hc0fe6c6_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "583daec186453cf1f769637e03483121", + "name": "cryptominisat", + "sha256": "6b3f88af31911309fe9b8b2ee769ef41781435aa20d9943cb685a968e01f5c9d", + "size": 719009, + "subdir": "linux-64", + "timestamp": 1611760375913, + "version": "5.6.6" + }, + "cryptominisat-5.6.6-hfbc36fb_1.conda": { + "build": "hfbc36fb_1", + "build_number": 1, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0", + "libcryptominisat 5.6.6 h9e868ea_1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "10caa2c8fb14b9292fb285f1a0082c9c", + "name": "cryptominisat", + "sha256": "6c4fadab43caa07c5af19fdac4ff2ceebe1cf9650f44d51faff65a440f16ec85", + "size": 1053096, + "subdir": "linux-64", + "timestamp": 1676725986964, + "version": "5.6.6" + }, + "cryptominisat-5.6.6-hfbc36fb_2.conda": { + "build": "hfbc36fb_2", + "build_number": 2, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0", + "libcryptominisat 5.6.6 h9e868ea_2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d550497af88454c917230f89d4e439e0", + "name": "cryptominisat", + "sha256": "97d011952fd2805e54b172e2fff776792b6021005e441e4398994bd58ed380d1", + "size": 1053247, + "subdir": "linux-64", + "timestamp": 1679313472422, + "version": "5.6.6" + }, + "cssselect-1.0.1-py27h1220d86_0.conda": { + "build": "py27h1220d86_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e42ef52646874dbecd73f93880234d35", + "name": "cssselect", + "sha256": "adeef3c6708bc0ec7b763a507f19f1d9cce281f741e32982aca2786414c34790", + "size": 29136, + "subdir": "linux-64", + "timestamp": 1508997790455, + "version": "1.0.1" + }, + "cssselect-1.0.1-py35hfccbc36_0.conda": { + "build": "py35hfccbc36_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "44f623f3257090069f6f0186a5a4d6cf", + "name": "cssselect", + "sha256": "ae61679f266aea627c1f23dd550f10957e58132cd4388acbf2a76b93bba71c8b", + "size": 29753, + "subdir": "linux-64", + "timestamp": 1508997802443, + "version": "1.0.1" + }, + "cssselect-1.0.1-py36he645adf_0.conda": { + "build": "py36he645adf_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4c449c142941090d89a2c0db6eb4cbe3", + "name": "cssselect", + "sha256": "63fb6c215f291bdf0a6e32eaedce04dd73965bd48b8d1b92b85cd0fc3cc0a538", + "size": 29367, + "subdir": "linux-64", + "timestamp": 1508997797260, + "version": "1.0.1" + }, + "cssselect-1.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7d8b1f8644f630083a3b7cf2dd5a4e08", + "name": "cssselect", + "sha256": "fba34a281e6be224c5ea26cc5bf7c51014f2f1816f5f7792b0698f4c7677df46", + "size": 29155, + "subdir": "linux-64", + "timestamp": 1516983415275, + "version": "1.0.3" + }, + "cssselect-1.0.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bc0d451c7b6ec96f103ee04bd2107b6c", + "name": "cssselect", + "sha256": "a9258e211672a4e83607032f8ccde2b86abddfb66e0216afe42e3470b3773cd6", + "size": 29638, + "subdir": "linux-64", + "timestamp": 1516983428148, + "version": "1.0.3" + }, + "cssselect-1.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f30f23def70f6489307ce6f64211045c", + "name": "cssselect", + "sha256": "07e40a887d3aebb943d5417bf9ab3fb62495c86a3df63158f5a3641b0f2f25e1", + "size": 29062, + "subdir": "linux-64", + "timestamp": 1516983429352, + "version": "1.0.3" + }, + "cssselect-1.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "16aeff6d4285e9030b14bba85728fd26", + "name": "cssselect", + "sha256": "5c54ec63c0f7e64de30159bf51a3ad65d148af66c32abba876da7f5e5d2c4e0a", + "size": 28922, + "subdir": "linux-64", + "timestamp": 1530814319218, + "version": "1.0.3" + }, + "csvkit-1.0.2-py27hab083c5_0.conda": { + "build": "py27hab083c5_0", + "build_number": 0, + "depends": [ + "agate >=1.6.0", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.1", + "agate-sql >=0.5.2", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cf4b616c8b38dba10805d725fc2ca184", + "name": "csvkit", + "sha256": "471a3b12902821006387903b7fcabcd5c03222ae0d2f78deca05ebf775a3d152", + "size": 56390, + "subdir": "linux-64", + "timestamp": 1508626155096, + "version": "1.0.2" + }, + "csvkit-1.0.2-py35h40534ce_0.conda": { + "build": "py35h40534ce_0", + "build_number": 0, + "depends": [ + "agate >=1.6.0", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.1", + "agate-sql >=0.5.2", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e39e7d3d2ce05bf45ecf2ecdb3070cae", + "name": "csvkit", + "sha256": "c46dc868c7966030671416e469925fa4133e573874ed81cbb4ca82bec97f8cab", + "size": 57719, + "subdir": "linux-64", + "timestamp": 1508626157602, + "version": "1.0.2" + }, + "csvkit-1.0.2-py36h1b4c739_0.conda": { + "build": "py36h1b4c739_0", + "build_number": 0, + "depends": [ + "agate >=1.6.0", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.1", + "agate-sql >=0.5.2", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47b0c3ef825c425de791e47126249b2a", + "name": "csvkit", + "sha256": "1599a787bf7e38aa4eb147c7cd68ecf714ccb0a27ebaedc83df16943a14ba74a", + "size": 56481, + "subdir": "linux-64", + "timestamp": 1508626165308, + "version": "1.0.2" + }, + "csvkit-1.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "67fc2b021b38f51340e5aa62fbe0680e", + "name": "csvkit", + "sha256": "73ae0e4f2c31eb219710676689f35e388c13814030c2765b59310ea957f26d6c", + "size": 59594, + "subdir": "linux-64", + "timestamp": 1520969951817, + "version": "1.0.3" + }, + "csvkit-1.0.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab143d664846f21b75095db9897e011b", + "name": "csvkit", + "sha256": "82cd9f35c8f2c7f4a566ce47a69903b578ede5765dfb68230b6d840d4008a1a7", + "size": 60389, + "subdir": "linux-64", + "timestamp": 1520970099533, + "version": "1.0.3" + }, + "csvkit-1.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0e1f942c0762c54e14f12afa020986fe", + "name": "csvkit", + "sha256": "2ddf1714af7564549cceecd8f0fc3e6353ce808fe90b5144f78920f549ae94be", + "size": 59613, + "subdir": "linux-64", + "timestamp": 1520969853620, + "version": "1.0.3" + }, + "csvkit-1.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "00e3c6688059e18a4f0303ccb1131b4a", + "name": "csvkit", + "sha256": "eabda1e789a5ff2bb243b6da3ba6e366146fda13d3fcc210a74cacc1bbcfcad6", + "size": 58811, + "subdir": "linux-64", + "timestamp": 1530814347431, + "version": "1.0.3" + }, + "csvkit-1.0.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01f145ffd48c9ac50f9ff293c500fd4f", + "name": "csvkit", + "sha256": "4cd7e7da975c75669d388f97afc1cc5047152ae1a8aaf816086f4d8c8846ae83", + "size": 62882, + "subdir": "linux-64", + "timestamp": 1556064528129, + "version": "1.0.4" + }, + "csvkit-1.0.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.10,<3.11.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb954d99ca104e1b7eab97c0a29e427b", + "name": "csvkit", + "sha256": "e892bc644519bc67de6fb1777176b5878fa4954fda020cb92a8387be07374321", + "size": 61755, + "subdir": "linux-64", + "timestamp": 1640811857519, + "version": "1.0.4" + }, + "csvkit-1.0.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.11,<3.12.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f4f0cc605e0f14025575c8b43b1d253", + "name": "csvkit", + "sha256": "94fa83da49c860afce7dae8dd8170b01ed5a6c5a44eb337494abd1804ed56263", + "size": 83537, + "subdir": "linux-64", + "timestamp": 1676851781002, + "version": "1.0.4" + }, + "csvkit-1.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5fc0821c7dd4eb5a8bab79ba78f2f05", + "name": "csvkit", + "sha256": "47551ba3458960f46b0fa3f81d0c4e1cc85d3cc7da1c5607096c93b908dfde38", + "size": 62866, + "subdir": "linux-64", + "timestamp": 1556064537099, + "version": "1.0.4" + }, + "csvkit-1.0.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "84ef005780de9c139626332da8f726a8", + "name": "csvkit", + "sha256": "6e4e778edc9042cfeebe79ccb0d082429584befd7633e18a2c68243b08f87a2f", + "size": 62529, + "subdir": "linux-64", + "timestamp": 1614082952362, + "version": "1.0.4" + }, + "csvkit-1.0.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d328bc91bc5a576145812a586f6f27f9", + "name": "csvkit", + "sha256": "fb0e392ff6ccd697f6ec90d29f1f26a7470bb079be01f545ec82841bbd91566c", + "size": 62739, + "subdir": "linux-64", + "timestamp": 1556064509839, + "version": "1.0.4" + }, + "csvkit-1.0.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f10dd2d8396c14c4211843adfeabe436", + "name": "csvkit", + "sha256": "99414c0a45c6b87506c6b778c9632a5618173e8f01b7a06caaf6737e23d62801", + "size": 63683, + "subdir": "linux-64", + "timestamp": 1614082366632, + "version": "1.0.4" + }, + "csvkit-1.0.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8977ce70e3751570eef2c6a1ab7c2026", + "name": "csvkit", + "sha256": "813493b8829441edef89664f7e8c9aa5eb22f09491ead0a6e5ac80951e10a621", + "size": 62253, + "subdir": "linux-64", + "timestamp": 1574177681731, + "version": "1.0.4" + }, + "csvkit-1.0.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5283d2f22e0f4efe0ce46662b1ae7579", + "name": "csvkit", + "sha256": "f7330d855a8f4cd74a3e5cb5116f719469cdefa9857177b00c144048e9b16479", + "size": 63210, + "subdir": "linux-64", + "timestamp": 1614082953112, + "version": "1.0.4" + }, + "csvkit-1.0.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "30dae71097d65ceeef8c88f28f8a9be7", + "name": "csvkit", + "sha256": "6de94ad6e3d4f2a67c50e0cc6aca62879e20a077eebcf91586d3ffe9e105ba4b", + "size": 62926, + "subdir": "linux-64", + "timestamp": 1614082030997, + "version": "1.0.4" + }, + "csvkit-1.0.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43df9f35d7aca5b3f6aff61222a6aa9d", + "name": "csvkit", + "sha256": "6288b3ac1c440e294964a90b6fe4081d520b596744a4fad33cb92599f2d866f3", + "size": 61735, + "subdir": "linux-64", + "timestamp": 1600354101162, + "version": "1.0.5" + }, + "csvkit-1.0.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "174a3e329f2e1364d105cfbc0d99c6ee", + "name": "csvkit", + "sha256": "b1175c2dc70d6faad825f79f4a794ccf48649ae40d3b1cab6d5fc8b3fb9998c6", + "size": 62135, + "subdir": "linux-64", + "timestamp": 1600354092555, + "version": "1.0.5" + }, + "csvkit-1.0.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "agate >=1.6.1", + "agate-dbf >=0.2.0", + "agate-excel >=0.2.2", + "agate-sql >=0.5.3", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af3e5ce056bd95ddccf9c346b61660bb", + "name": "csvkit", + "sha256": "c15ecd6511bef040655f773c22075e47948950187d0c6d23d1b709e363aad59d", + "size": 61741, + "subdir": "linux-64", + "timestamp": 1600354130517, + "version": "1.0.5" + }, + "cubes-1.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=2.7,<2.8.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "0c8960e5245f45f718313f68196f610a", + "name": "cubes", + "sha256": "4451cf3bb39488aee31033173399a1e848de9c8dba94f06a81446abbcd073e14", + "size": 222355, + "subdir": "linux-64", + "timestamp": 1537215890730, + "version": "1.1" + }, + "cubes-1.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=3.10,<3.11.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "6734876a8cb2210184668b478725ab65", + "name": "cubes", + "sha256": "4432325500889729932204050d20df5398cb97fb92c3b4ef7cb5fe476213f6a7", + "size": 227246, + "subdir": "linux-64", + "timestamp": 1640811876618, + "version": "1.1" + }, + "cubes-1.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=3.5,<3.6.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "fcf591684d636a8f856ec861b170652f", + "name": "cubes", + "sha256": "4332d908b562e538c04e02e52e207e14afb1e611c9c7deeed6f2031f65e71e41", + "size": 229046, + "subdir": "linux-64", + "timestamp": 1537215912795, + "version": "1.1" + }, + "cubes-1.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "4785cd1268e99cd1bfb2f2cc3a526478", + "name": "cubes", + "sha256": "cb49a8d036b0c80a0f401593eaf4ff484a5fdfe4d357dc31260ceb7d32644a25", + "size": 226753, + "subdir": "linux-64", + "timestamp": 1537215914459, + "version": "1.1" + }, + "cubes-1.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "985474301a8da41a95fde4e77108fe6b", + "name": "cubes", + "sha256": "f3c493d008356ec6d3a2df9e231da5f88fa28f120dee12983095aa3ef9975ef2", + "size": 469464, + "subdir": "linux-64", + "timestamp": 1614080124050, + "version": "1.1" + }, + "cubes-1.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "1c194953ff82617d91d3753be54d91ba", + "name": "cubes", + "sha256": "95dc85c1ddb9211ecca6afcb036ec8d40c7c7dd617a9384cfab4e6463ca327f8", + "size": 227206, + "subdir": "linux-64", + "timestamp": 1537215854760, + "version": "1.1" + }, + "cubes-1.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "06affc96550bc07b580d684e3b4dca92", + "name": "cubes", + "sha256": "291a885790992ee9a401e84eb64b6074d158a3d7a2892a946d647db9c30db9ce", + "size": 469720, + "subdir": "linux-64", + "timestamp": 1614080105291, + "version": "1.1" + }, + "cubes-1.1-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "48de35594d9c928c38122c1fa925a809", + "name": "cubes", + "sha256": "672adf9fb0c4d929738b60fff388b91f616b7ad72aa585104cf84a15a6888e73", + "size": 228618, + "subdir": "linux-64", + "timestamp": 1574177698291, + "version": "1.1" + }, + "cubes-1.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "cb74cf339c59c0470c0885e97c509272", + "name": "cubes", + "sha256": "5c17d6329fa01c183effae079027ea15a0d80f03eb0a68cef1568fa83a71477b", + "size": 468629, + "subdir": "linux-64", + "timestamp": 1614080111324, + "version": "1.1" + }, + "cubes-1.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "click", + "expressions >=0.2.3", + "flask", + "jsonschema", + "python >=3.9,<3.10.0a0", + "python-dateutil" + ], + "license": "MIT", + "md5": "46dcb60d1ea2a0f1be250a06072b5532", + "name": "cubes", + "sha256": "bdb07ae9fedf7e45e8d70dff9a9c121218eea5561ef7912e0a7ca35e3e030343", + "size": 470639, + "subdir": "linux-64", + "timestamp": 1614079796338, + "version": "1.1" + }, + "cudatoolkit-10.0.130-0.conda": { + "build": "0", + "build_number": 0, + "constrains": [ + "__cuda >=10.0" + ], + "depends": [], + "md5": "0f92a5d76b137998dfcae2b2fc723b61", + "name": "cudatoolkit", + "sha256": "208b656bd70ebebde57b7633a812582ee0f14559089255d927c35f38949cac97", + "size": 273930673, + "subdir": "linux-64", + "timestamp": 1548259562909, + "version": "10.0.130" + }, + "cudatoolkit-10.1.168-0.conda": { + "build": "0", + "build_number": 0, + "constrains": [ + "__cuda >=10.1" + ], + "depends": [], + "md5": "08e10de59e068bfb65adc9d4c5f5215b", + "name": "cudatoolkit", + "sha256": "dff10e3e719da549084be93601dc520bae86dcf60f144a2ed61467e7f28d29cf", + "size": 371264729, + "subdir": "linux-64", + "timestamp": 1559573884225, + "version": "10.1.168" + }, + "cudatoolkit-10.1.243-h6bb024c_0.conda": { + "build": "h6bb024c_0", + "build_number": 0, + "constrains": [ + "__cuda >=10.1" + ], + "depends": [], + "md5": "86c2168ceb0c5e8707efce50699ed001", + "name": "cudatoolkit", + "sha256": "17aee803ff8207df6de98058a88badc9a3f840894251b9ea67701b6b23ee0395", + "size": 364312915, + "subdir": "linux-64", + "timestamp": 1572634034749, + "version": "10.1.243" + }, + "cudatoolkit-10.2.89-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "constrains": [ + "__cuda >=10.2" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "md5": "94222190dddd3999a0384b169cf41889", + "name": "cudatoolkit", + "sha256": "6c50666ee8470c9d064aa06831c6791c81ec048a25ac84b08514117353509cbd", + "size": 382205856, + "subdir": "linux-64", + "timestamp": 1576620513184, + "version": "10.2.89" + }, + "cudatoolkit-10.2.89-hfd86e86_1.conda": { + "build": "hfd86e86_1", + "build_number": 1, + "constrains": [ + "__cuda >=10.2" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "md5": "16b6d0b7f60d39e571d0d030585068fe", + "name": "cudatoolkit", + "sha256": "23606619a251b16d54229b3ed28213b67e06cc80dd394d0cea4e955d7df8d23e", + "size": 382791771, + "subdir": "linux-64", + "timestamp": 1588169992158, + "version": "10.2.89" + }, + "cudatoolkit-11.0.221-h6bb024c_0.conda": { + "build": "h6bb024c_0", + "build_number": 0, + "constrains": [ + "__cuda >=11.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "NVIDIA End User License Agreement", + "md5": "d2f5dc40196d4e2c1f05130d4e5ac318", + "name": "cudatoolkit", + "sha256": "8deac6e2ffdbe7ab8bf7b3496b9e56fffeca2db0286f021a0e5420cd88dc4e29", + "size": 653169762, + "subdir": "linux-64", + "timestamp": 1598395571777, + "version": "11.0.221" + }, + "cudatoolkit-11.3.1-h2bc3f7f_2.conda": { + "build": "h2bc3f7f_2", + "build_number": 2, + "constrains": [ + "__cuda >=11.0" + ], + "depends": [ + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0" + ], + "license": "NVIDIA End User License Agreement", + "md5": "ec7241a3939c49e0f071ff0409bb438f", + "name": "cudatoolkit", + "sha256": "b7231afd3a61a9160542b22915a2bcef9dfb8f74739dc40447ac979cf80442cb", + "size": 575957943, + "subdir": "linux-64", + "timestamp": 1624974048871, + "version": "11.3.1" + }, + "cudatoolkit-9.0-h13b8566_0.conda": { + "build": "h13b8566_0", + "build_number": 0, + "constrains": [ + "__cuda >=9.0" + ], + "depends": [], + "md5": "7f0814ed96324dd029a85e087779ca04", + "name": "cudatoolkit", + "sha256": "3748b179671f1b4e5d14eae8b94b039be1a580b0a79436dc3852d077356a1088", + "size": 248552389, + "subdir": "linux-64", + "timestamp": 1515427750026, + "version": "9.0" + }, + "cudatoolkit-9.2-0.conda": { + "build": "0", + "build_number": 0, + "constrains": [ + "__cuda >=9.2" + ], + "depends": [], + "md5": "e288453c34c03904a6f683ac4bcde35b", + "name": "cudatoolkit", + "sha256": "edc7d4a546f0b1dde588f0593768f57e5127f0f26eeca74d3284c1c71e1e87e3", + "size": 245249198, + "subdir": "linux-64", + "timestamp": 1534891706146, + "version": "9.2" + }, + "cudnn-7.0.5-cuda8.0_0.conda": { + "build": "cuda8.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0*" + ], + "license": "Proprietary", + "md5": "3a550203131b15e30afe65022bbf4626", + "name": "cudnn", + "sha256": "affb54cad9460628461a903df4d2fbc18617362e723c281f7416d5894008c9d1", + "size": 181365372, + "subdir": "linux-64", + "timestamp": 1513362701597, + "version": "7.0.5" + }, + "cudnn-7.1.2-cuda9.0_0.conda": { + "build": "cuda9.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "libgcc-ng", + "libstdcxx-ng" + ], + "license": "Proprietary", + "md5": "57ed93f37796b572683cbee79d9bfc51", + "name": "cudnn", + "sha256": "f83518dfd81146ea4121f3d1cc0f0f48f26ebaebcb566375ca3d99329d5049d1", + "size": 254794777, + "subdir": "linux-64", + "timestamp": 1523281397595, + "version": "7.1.2" + }, + "cudnn-7.1.3-cuda8.0_0.conda": { + "build": "cuda8.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*" + ], + "license": "Proprietary", + "md5": "8389d2a287e6405fa736699771ca61ed", + "name": "cudnn", + "sha256": "4c6fcd6a57738b501a072fc75f9d2e1c315e3975fbdb37e2f9daa9ae11166813", + "size": 174341555, + "subdir": "linux-64", + "timestamp": 1533763199150, + "version": "7.1.3" + }, + "cudnn-7.2.1-cuda9.2_0.conda": { + "build": "cuda9.2_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.2.*" + ], + "license": "Proprietary", + "md5": "3b96b2c6a4cd07ffaecb9e95ad580cc5", + "name": "cudnn", + "sha256": "31f86b948b4ccde9b35974320b47e2ebe7fdb648175e1dcdc3a038055a5de626", + "size": 253301852, + "subdir": "linux-64", + "timestamp": 1534891952969, + "version": "7.2.1" + }, + "cudnn-7.3.1-cuda10.0_0.conda": { + "build": "cuda10.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.0.*" + ], + "license": "Proprietary", + "md5": "5fddf83caa37570c529a5dd031778af2", + "name": "cudnn", + "sha256": "a4b893e3d32805d618026f13d79053526318ea70d2d3e52e61f6a3a0b6d41de7", + "size": 299954418, + "subdir": "linux-64", + "timestamp": 1548261121945, + "version": "7.3.1" + }, + "cudnn-7.3.1-cuda9.0_0.conda": { + "build": "cuda9.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*" + ], + "license": "Proprietary", + "md5": "871d63d9fa413f7cf689b8b5f4fed462", + "name": "cudnn", + "sha256": "597734e1eb824353e014c58f7358a58a6f35c4113913a048d673ad34458d36b6", + "size": 260284821, + "subdir": "linux-64", + "timestamp": 1548264434745, + "version": "7.3.1" + }, + "cudnn-7.3.1-cuda9.2_0.conda": { + "build": "cuda9.2_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.2.*" + ], + "license": "Proprietary", + "md5": "1ed2cb2311d161b1eb20c66f5c1eac90", + "name": "cudnn", + "sha256": "c5100b93fc7d847cca60d6d09554574af09afb2bb93b4e7ac9821339009e4569", + "size": 261871678, + "subdir": "linux-64", + "timestamp": 1548262939538, + "version": "7.3.1" + }, + "cudnn-7.6.0-cuda10.0_0.conda": { + "build": "cuda10.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0,<10.1" + ], + "license": "Proprietary", + "md5": "7c0dbf6849af5966a73b03813f83aa6c", + "name": "cudnn", + "sha256": "6ea816729a08f1c0d11a6ef2ec3451b47f3754baa7c116703e5c7fcd7be33360", + "size": 165536847, + "subdir": "linux-64", + "timestamp": 1559577113681, + "version": "7.6.0" + }, + "cudnn-7.6.0-cuda10.1_0.conda": { + "build": "cuda10.1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.1,<10.2" + ], + "license": "Proprietary", + "md5": "6ac671ce01192eeb18026a9717ab2690", + "name": "cudnn", + "sha256": "6425c67aa55e3ca5af57aa33d7893b4c26ffd57b181ba6aa8a245f79b301579c", + "size": 182641495, + "subdir": "linux-64", + "timestamp": 1559576071032, + "version": "7.6.0" + }, + "cudnn-7.6.0-cuda9.0_0.conda": { + "build": "cuda9.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1" + ], + "license": "Proprietary", + "md5": "2a4919c94646083b40d6da424898b95f", + "name": "cudnn", + "sha256": "5c8020b4b5d35ee6241546b41b041942b13a5f640f79dad380a1e029066eeac5", + "size": 143215500, + "subdir": "linux-64", + "timestamp": 1559576388391, + "version": "7.6.0" + }, + "cudnn-7.6.0-cuda9.2_0.conda": { + "build": "cuda9.2_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3" + ], + "license": "Proprietary", + "md5": "ed9149e14f6c0ec45607bcd20284031f", + "name": "cudnn", + "sha256": "2d448f81d9ae8bfa38a384e0d4e7ab13884655a7a9981249734d7f224eb88362", + "size": 142954436, + "subdir": "linux-64", + "timestamp": 1559576744678, + "version": "7.6.0" + }, + "cudnn-7.6.4-cuda10.0_0.conda": { + "build": "cuda10.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0,<10.1" + ], + "license": "Proprietary", + "md5": "caddc0833c1e9eaf7447a26d61ae4088", + "name": "cudnn", + "sha256": "1830fe58c92599de03d60e5bf532b4e4228dee4bdca5c165a6be25a20c005157", + "size": 172940546, + "subdir": "linux-64", + "timestamp": 1572994963804, + "version": "7.6.4" + }, + "cudnn-7.6.4-cuda10.1_0.conda": { + "build": "cuda10.1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.1,<10.2" + ], + "license": "Proprietary", + "md5": "0d5b46253a4784c34a2c3d6e0aa4342e", + "name": "cudnn", + "sha256": "9e6a054720f2faebc61fa9de312e3195fe45bebd21fd4ccb0f5cd4cc21919c1e", + "size": 188830434, + "subdir": "linux-64", + "timestamp": 1572994968109, + "version": "7.6.4" + }, + "cudnn-7.6.4-cuda9.0_0.conda": { + "build": "cuda9.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1" + ], + "license": "Proprietary", + "md5": "d66b4a925141073ca55fed5066c5be19", + "name": "cudnn", + "sha256": "461dc4a1ee9a04dc1a16978cf2be2c18a7b49e904983f798c475a3b816af2593", + "size": 150419765, + "subdir": "linux-64", + "timestamp": 1572994948276, + "version": "7.6.4" + }, + "cudnn-7.6.4-cuda9.2_0.conda": { + "build": "cuda9.2_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3" + ], + "license": "Proprietary", + "md5": "30a30572f32bbd94a3c10497450f03c0", + "name": "cudnn", + "sha256": "00eb357e1ef0ac0199cdf3234cdff368560c5c9a48b8584fd8f237daed734f18", + "size": 149627990, + "subdir": "linux-64", + "timestamp": 1572994954968, + "version": "7.6.4" + }, + "cudnn-7.6.5-cuda10.0_0.conda": { + "build": "cuda10.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0,<10.1" + ], + "license": "Proprietary", + "md5": "99461bf253ebb2c14e5b574754e213cd", + "name": "cudnn", + "sha256": "770a0a802b642b380971d4d3d21309a45f84965f644011173dd4cc262d10accb", + "size": 172967513, + "subdir": "linux-64", + "timestamp": 1576790197647, + "version": "7.6.5" + }, + "cudnn-7.6.5-cuda10.1_0.conda": { + "build": "cuda10.1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.1,<10.2" + ], + "license": "Proprietary", + "md5": "48850e851b910b694192f417e860fba3", + "name": "cudnn", + "sha256": "e79168efab6501d63c55275b642954dc5268d24a4e48ad37ecef8f7aff1f20d6", + "size": 188683093, + "subdir": "linux-64", + "timestamp": 1576790463878, + "version": "7.6.5" + }, + "cudnn-7.6.5-cuda10.2_0.conda": { + "build": "cuda10.2_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.2,<10.3" + ], + "license": "Proprietary", + "md5": "a0990d592fe7b33055ffdd32bca0cc71", + "name": "cudnn", + "sha256": "78db2a50a60d954a9f37b326a8793aa1e4b04f13db3860981630075406b846e1", + "size": 193294478, + "subdir": "linux-64", + "timestamp": 1576790194333, + "version": "7.6.5" + }, + "cudnn-7.6.5-cuda9.0_0.conda": { + "build": "cuda9.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1" + ], + "license": "Proprietary", + "md5": "be86d7ce324baafffc384bb9ca25fa96", + "name": "cudnn", + "sha256": "1964e8ba5b8b9f15e89eb4b666c9c0a0f71da4dd924250124d172b3d4f7a59a0", + "size": 150280218, + "subdir": "linux-64", + "timestamp": 1576790399970, + "version": "7.6.5" + }, + "cudnn-7.6.5-cuda9.2_0.conda": { + "build": "cuda9.2_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3" + ], + "license": "Proprietary", + "md5": "6192da6c1cf651dbd292c8cdaa6ddf29", + "name": "cudnn", + "sha256": "daec5742440e672f8ee13d81c808b433d47caa591034988ee6c7ae683678d1c9", + "size": 149598116, + "subdir": "linux-64", + "timestamp": 1576790368096, + "version": "7.6.5" + }, + "cudnn-8.2.1-cuda11.3_0.conda": { + "build": "cuda11.3_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=11.3,<11.4" + ], + "license": "Proprietary", + "md5": "8eee1b8d399b27e82d10286037394e6f", + "name": "cudnn", + "sha256": "db10fa82975d4d3861cbf28e725f623b46db484e2ad15120305201fc5014e9c2", + "size": 907179703, + "subdir": "linux-64", + "timestamp": 1625057502116, + "version": "8.2.1" + }, + "cunit-2.1.3-h295c915_1002.conda": { + "build": "h295c915_1002", + "build_number": 1002, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "LGPL-2.0-only", + "md5": "a43a99316a30cf98003f53c86f1bd51c", + "name": "cunit", + "sha256": "b1bd9fb523034bf92ba2bcc3dc2d5dfaa9710ef780fcef502784209828060c9f", + "size": 503087, + "subdir": "linux-64", + "timestamp": 1655476904224, + "version": "2.1.3" + }, + "cupti-10.0.130-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.0.*" + ], + "license": "proprietary - Nvidia", + "license_family": "Proprietary", + "md5": "f743eb9c384c6ebe3c6bde0b391eae9c", + "name": "cupti", + "sha256": "7bedf8315df7775ada1be44fd07bfb8daf9733567aa4c293523fabf2af876c8b", + "size": 1593927, + "subdir": "linux-64", + "timestamp": 1548266521078, + "version": "10.0.130" + }, + "cupti-10.1.168-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.1,<10.2" + ], + "license": "proprietary - Nvidia", + "license_family": "Proprietary", + "md5": "073e0478e7092ddf4945947d2ce2e633", + "name": "cupti", + "sha256": "7cc8ff4e60a4e0e73c9f6ff48d35e4c2bb5dfd8f32a739735fe7418976ccb348", + "size": 1433741, + "subdir": "linux-64", + "timestamp": 1559575616138, + "version": "10.1.168" + }, + "cupti-11.3.1-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "cudatoolkit >=11.3,<11.4" + ], + "license": "proprietary - Nvidia", + "license_family": "Proprietary", + "md5": "b6149f041ee54b0e9cd83ede4553240a", + "name": "cupti", + "sha256": "861e2726f4d8159309b93d27b5b775713edcf32a79ca9b6e6effd4ce6fa29b48", + "size": 8345803, + "subdir": "linux-64", + "timestamp": 1626364160946, + "version": "11.3.1" + }, + "cupti-8.0.61-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.*" + ], + "license": "proprietary - Nvidia", + "license_family": "Proprietary", + "md5": "2fdb05b41885060c5902dff35e98728f", + "name": "cupti", + "sha256": "3393a6606db84eb515c60cdb8873908653b300167ff7d0393086db33b8012db6", + "size": 1283987, + "subdir": "linux-64", + "timestamp": 1524240019951, + "version": "8.0.61" + }, + "cupti-9.0.176-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*" + ], + "license": "proprietary - Nvidia", + "license_family": "Proprietary", + "md5": "20c0d570796a65360f371083f66113c1", + "name": "cupti", + "sha256": "78bede50a7dcc9d30a68b6054ee66eec3c5dab31f3fc7dc9f391a9301612be6a", + "size": 1431650, + "subdir": "linux-64", + "timestamp": 1524334373749, + "version": "9.0.176" + }, + "cupti-9.2.148-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.2.*" + ], + "license": "proprietary - Nvidia", + "license_family": "Proprietary", + "md5": "9762feec573a9b17ea260b46034f4803", + "name": "cupti", + "sha256": "d77ccdcbf99981bd5ccf789afadeff4a2e46cd6a7a1ca5e0fcd6537db4a9f21d", + "size": 1549288, + "subdir": "linux-64", + "timestamp": 1534892452681, + "version": "9.2.148" + }, + "cupy-4.0.0-py27he3f55b6_0.conda": { + "build": "py27he3f55b6_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9876d09423af32bf307268ee80a4a63", + "name": "cupy", + "sha256": "e94dfe2ba3a6d200ebc25bba649d7c49d4b69a349017f1d85f351f56c967e025", + "size": 7648573, + "subdir": "linux-64", + "timestamp": 1524333449391, + "version": "4.0.0" + }, + "cupy-4.0.0-py27hef69808_0.conda": { + "build": "py27hef69808_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6fe4333bdd5aa55ad7ed6b1e365eac6f", + "name": "cupy", + "sha256": "15ec664c26cc00ee966c5e5dba1f86a0f678e02ede552f5547b99c8e8c3a5302", + "size": 5932806, + "subdir": "linux-64", + "timestamp": 1524330066388, + "version": "4.0.0" + }, + "cupy-4.0.0-py35he3f55b6_0.conda": { + "build": "py35he3f55b6_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "05fd468ac15dda61351af6fbc7d5bf44", + "name": "cupy", + "sha256": "e62b9f5b5bbb0e7e2b74bd9be92c5f150786bf33ab49188a1e52085410a76554", + "size": 7659933, + "subdir": "linux-64", + "timestamp": 1524333975724, + "version": "4.0.0" + }, + "cupy-4.0.0-py35hef69808_0.conda": { + "build": "py35hef69808_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14fade1fc24112a787355372a1efd9ff", + "name": "cupy", + "sha256": "6764e018d42490dbefb31c006ab7e9d24b0f4e5a4414d7d74dd645924d44b5b8", + "size": 5946686, + "subdir": "linux-64", + "timestamp": 1524330692531, + "version": "4.0.0" + }, + "cupy-4.0.0-py36he3f55b6_0.conda": { + "build": "py36he3f55b6_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb37a57776ce28e2623d353daaa405e8", + "name": "cupy", + "sha256": "8983d000eb299bd4945cccc5f5a0df82c6c8e92ca7fce6612bf94610614f378e", + "size": 7687811, + "subdir": "linux-64", + "timestamp": 1524334470441, + "version": "4.0.0" + }, + "cupy-4.0.0-py36hef69808_0.conda": { + "build": "py36hef69808_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9115bf1fbf1d286d332032efcf86f66", + "name": "cupy", + "sha256": "1af9e41d5781132e42ea02a318239006b7d4abc365c9c41a1d53a0a75710f821", + "size": 5974516, + "subdir": "linux-64", + "timestamp": 1524331225376, + "version": "4.0.0" + }, + "cupy-4.1.0-py27h0ee51e5_0.conda": { + "build": "py27h0ee51e5_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c84d84904d9b9c342d2fab901b646ce", + "name": "cupy", + "sha256": "6c6f314543e2a3ab0796900cfe08b30e10610ced2b667911047f6714e19a5e96", + "size": 7650511, + "subdir": "linux-64", + "timestamp": 1529344342225, + "version": "4.1.0" + }, + "cupy-4.1.0-py27had95abb_0.conda": { + "build": "py27had95abb_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c2bae00f4df48d0701ec8d9a54225f2", + "name": "cupy", + "sha256": "9e46267c799675b80bd5a9046529047043584ec2f8cda5e875fda6af232d3810", + "size": 5937558, + "subdir": "linux-64", + "timestamp": 1529350485275, + "version": "4.1.0" + }, + "cupy-4.1.0-py35h0ee51e5_0.conda": { + "build": "py35h0ee51e5_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "228989ac368d21a700d95a36e5725f60", + "name": "cupy", + "sha256": "067c5d767ec46a19ea2e851fbe4f24e60e502f78a47b3cd42a4de42d56ea5f80", + "size": 7664118, + "subdir": "linux-64", + "timestamp": 1529343754967, + "version": "4.1.0" + }, + "cupy-4.1.0-py35had95abb_0.conda": { + "build": "py35had95abb_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1bad30f96cfa5e67535b79ab08815487", + "name": "cupy", + "sha256": "a1df081e7546a7c7afcd8eeb6d532d3bcd09b57889af69ccc871977fb49999bb", + "size": 5947470, + "subdir": "linux-64", + "timestamp": 1529349907735, + "version": "4.1.0" + }, + "cupy-4.1.0-py36h0ee51e5_0.conda": { + "build": "py36h0ee51e5_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13af3c278d4217a31d4987b7260f47a6", + "name": "cupy", + "sha256": "6000429c2cbb8427e0fab4a05a7794302c5f0c2dff2512a2d8775d83c167fea7", + "size": 7689475, + "subdir": "linux-64", + "timestamp": 1529344849257, + "version": "4.1.0" + }, + "cupy-4.1.0-py36had95abb_0.conda": { + "build": "py36had95abb_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7c513b4488255a64f14899052ab15ab", + "name": "cupy", + "sha256": "a50724b4203e971e776347458c0b851f84d8af490bcf765eabf5d07d985c1f55", + "size": 5975952, + "subdir": "linux-64", + "timestamp": 1529349228160, + "version": "4.1.0" + }, + "cupy-5.1.0-py27h062aff8_0.conda": { + "build": "py27h062aff8_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=8.0,<9.0a0", + "cudnn >=7.1.3,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.4,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f785a0f301cb6938e7a912de59cd9b6", + "name": "cupy", + "sha256": "5a92d3f4b3a6b1e9324d650994b271421e40b062dcd67cf1224b3b5e7c117d6f", + "size": 6246300, + "subdir": "linux-64", + "timestamp": 1548269838134, + "version": "5.1.0" + }, + "cupy-5.1.0-py27h686fdb1_0.conda": { + "build": "py27h686fdb1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5feb80c774903f02535f09ab5441c007", + "name": "cupy", + "sha256": "1f6d66c39f9271f1819debd58acc43a7ff505a61c5de4a02a8b0d7a57869e33c", + "size": 7918410, + "subdir": "linux-64", + "timestamp": 1548267152672, + "version": "5.1.0" + }, + "cupy-5.1.0-py27hc0ce245_0.conda": { + "build": "py27hc0ce245_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2a43f2b0292039a0a5833f68d700e04", + "name": "cupy", + "sha256": "ce1e600f754c1386826f197c87ccd67d40ee1568b61221e541e70b849ea858e5", + "size": 9690659, + "subdir": "linux-64", + "timestamp": 1548263254994, + "version": "5.1.0" + }, + "cupy-5.1.0-py27hc15394e_0.conda": { + "build": "py27hc15394e_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f5a9e987d47caf0d6be70e58fb0b674", + "name": "cupy", + "sha256": "a61a7d6c633861b1f932b8c42f9bea6dd0eca8d83257f1424988f1495536c18f", + "size": 9652016, + "subdir": "linux-64", + "timestamp": 1548265848133, + "version": "5.1.0" + }, + "cupy-5.1.0-py36h062aff8_0.conda": { + "build": "py36h062aff8_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=8.0,<9.0a0", + "cudnn >=7.1.3,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.4,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4eca13e5387b4df0d6e2db91465475bc", + "name": "cupy", + "sha256": "aab807473f63ffdd9943afc4215125ba4f5f20c5ead645442489c3536e940a52", + "size": 6327224, + "subdir": "linux-64", + "timestamp": 1548269394435, + "version": "5.1.0" + }, + "cupy-5.1.0-py36h686fdb1_0.conda": { + "build": "py36h686fdb1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "874d6aeba45d1f57bad8a220998254c4", + "name": "cupy", + "sha256": "7d96b95e56efde3a031d83091946e538f610e81a6e842ae8cb0cf06941d20abc", + "size": 8000961, + "subdir": "linux-64", + "timestamp": 1548268007029, + "version": "5.1.0" + }, + "cupy-5.1.0-py36hc0ce245_0.conda": { + "build": "py36hc0ce245_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "671b8cb4325186918742b54710027f4a", + "name": "cupy", + "sha256": "19e2b9cf4513603fcfb4816dc9c3f895c554dcfa212fc4e920a7d6fa3a6fa590", + "size": 9759112, + "subdir": "linux-64", + "timestamp": 1548263763381, + "version": "5.1.0" + }, + "cupy-5.1.0-py36hc15394e_0.conda": { + "build": "py36hc15394e_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11be955d4577f2d57465774c1ef34e92", + "name": "cupy", + "sha256": "a8974681f13c269e3da6f35704b183185823f5b5db61e0563514f2a8b0c78597", + "size": 9716563, + "subdir": "linux-64", + "timestamp": 1548266351530, + "version": "5.1.0" + }, + "cupy-5.1.0-py37h062aff8_0.conda": { + "build": "py37h062aff8_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=8.0,<9.0a0", + "cudnn >=7.1.3,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.4,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8db901093fd3aba017b2dc8f0d26679", + "name": "cupy", + "sha256": "65e833e7116f07d1a22f2305f2804e1c0a091f369711edb1ac2976af643fc9b1", + "size": 6326290, + "subdir": "linux-64", + "timestamp": 1548268944292, + "version": "5.1.0" + }, + "cupy-5.1.0-py37h686fdb1_0.conda": { + "build": "py37h686fdb1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "19be1a34b68885fc899cc39490076d91", + "name": "cupy", + "sha256": "7c6568a6406b75beb4ae52580f2af6ff2bcb987477443801a2d84a021d4e266a", + "size": 8002312, + "subdir": "linux-64", + "timestamp": 1548267567424, + "version": "5.1.0" + }, + "cupy-5.1.0-py37hc0ce245_0.conda": { + "build": "py37hc0ce245_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e5dbe9c9d9fc737fedb6bd6302ff4a51", + "name": "cupy", + "sha256": "ec0b8ec8e13412b39acbc47d8c0314b5ba9dbd74c645bbae9742120777149515", + "size": 9761500, + "subdir": "linux-64", + "timestamp": 1548262748665, + "version": "5.1.0" + }, + "cupy-5.1.0-py37hc15394e_0.conda": { + "build": "py37hc15394e_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da64b3cd45b8a2e2162feb0c9e621c0f", + "name": "cupy", + "sha256": "3b55b6314eefb230aad9e4c097951991f38d8ae5cf1fd0ee5882df0462eb0836", + "size": 9714163, + "subdir": "linux-64", + "timestamp": 1548265341166, + "version": "5.1.0" + }, + "cupy-6.0.0-py27h062aff8_0.conda": { + "build": "py27h062aff8_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=8.0,<9.0a0", + "cudnn >=7.1.3,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.4,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "67e0b67635aed60721ecfae404021f5a", + "name": "cupy", + "sha256": "df2c2a68336a6fb44bdfcaed582c94dabfc0eae4695e549ae755e7745eb69e2d", + "size": 6664153, + "subdir": "linux-64", + "timestamp": 1559146646483, + "version": "6.0.0" + }, + "cupy-6.0.0-py27h686fdb1_0.conda": { + "build": "py27h686fdb1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d65f07b598602759e10c89ffa4de7726", + "name": "cupy", + "sha256": "2b750285743017bda00ea8fab27d14d0b73bc353c9c038f96a3f1545566599f3", + "size": 8340016, + "subdir": "linux-64", + "timestamp": 1559151386662, + "version": "6.0.0" + }, + "cupy-6.0.0-py27hc0ce245_0.conda": { + "build": "py27hc0ce245_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71cdd3f76053c0438b48facbad786acb", + "name": "cupy", + "sha256": "e43aa76ca87b6fcd64e2ba871125ed950c42f8aac7beeb21c1c5a84bcf96a1db", + "size": 10651656, + "subdir": "linux-64", + "timestamp": 1559169047774, + "version": "6.0.0" + }, + "cupy-6.0.0-py27hc15394e_0.conda": { + "build": "py27hc15394e_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "86c6c637d307e2e7edcaa71a26f97cba", + "name": "cupy", + "sha256": "3931458e31825c211007a161f8aa29708c4a0c951438f1c9516888860fb64681", + "size": 10052766, + "subdir": "linux-64", + "timestamp": 1559154647818, + "version": "6.0.0" + }, + "cupy-6.0.0-py36h062aff8_0.conda": { + "build": "py36h062aff8_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=8.0,<9.0a0", + "cudnn >=7.1.3,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.4,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea3bb454f1badd8c513438218d015dbd", + "name": "cupy", + "sha256": "05be1a16d444398a2b1ba2e7f77cacef001e181862e2e4e86b081725c1b2dc94", + "size": 6761327, + "subdir": "linux-64", + "timestamp": 1559147225984, + "version": "6.0.0" + }, + "cupy-6.0.0-py36h686fdb1_0.conda": { + "build": "py36h686fdb1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12d8b26a2dc54c1c63869a7545e41559", + "name": "cupy", + "sha256": "9b8654d418bbed29b547dbb01df70b96bfcbf63738dcac1374f2af7c7c5bfe56", + "size": 8435062, + "subdir": "linux-64", + "timestamp": 1559150789800, + "version": "6.0.0" + }, + "cupy-6.0.0-py36hc0ce245_0.conda": { + "build": "py36hc0ce245_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b364c2b02e235bfaa780016e7040de35", + "name": "cupy", + "sha256": "890f051db1bdd107ccf577ccff31ed865c105b15fef2227b9ce68992b717d87c", + "size": 10750559, + "subdir": "linux-64", + "timestamp": 1559169844650, + "version": "6.0.0" + }, + "cupy-6.0.0-py36hc15394e_0.conda": { + "build": "py36hc15394e_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee42ecbd80b37014ec84ec11505a2801", + "name": "cupy", + "sha256": "7092c7ec89e920f2be4e10574d42b1dbeacf4ade6184060f0ceced84e955554c", + "size": 10137127, + "subdir": "linux-64", + "timestamp": 1559153138654, + "version": "6.0.0" + }, + "cupy-6.0.0-py37h062aff8_0.conda": { + "build": "py37h062aff8_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=8.0,<9.0a0", + "cudnn >=7.1.3,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.4,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c8fdf610199de61eb38fc62bdd94e9c6", + "name": "cupy", + "sha256": "0f65cd11e5dfa8c48cdcdf335138f6773692b6e63a87f1bca70d5615fb829d47", + "size": 6756373, + "subdir": "linux-64", + "timestamp": 1559147802889, + "version": "6.0.0" + }, + "cupy-6.0.0-py37h686fdb1_0.conda": { + "build": "py37h686fdb1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90880d24a7d49d08cf02db4fe4a18b24", + "name": "cupy", + "sha256": "5c428fedf033797189a507155cdd5df1fff62574cd608971b43ce584f7b281a9", + "size": 8432328, + "subdir": "linux-64", + "timestamp": 1559149912534, + "version": "6.0.0" + }, + "cupy-6.0.0-py37hc0ce245_0.conda": { + "build": "py37hc0ce245_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c7ab35e3609c8efdb1f41d46dde4304", + "name": "cupy", + "sha256": "e4cf2acf26b53b85e633fa4cc540447cac527394a0e299c3155bfc21e58f7371", + "size": 10743803, + "subdir": "linux-64", + "timestamp": 1559168228540, + "version": "6.0.0" + }, + "cupy-6.0.0-py37hc15394e_0.conda": { + "build": "py37hc15394e_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=1.3.5,<2.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ace62ccdf03386a9e99bb9bf4ce4a8f7", + "name": "cupy", + "sha256": "666f53e565830850ded47d84a543c34006df6b8fd0e896cfefd3945b00158c93", + "size": 10134345, + "subdir": "linux-64", + "timestamp": 1559153898766, + "version": "6.0.0" + }, + "cupy-8.3.0-py36h91b26fc_0.conda": { + "build": "py36h91b26fc_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.0|10.0.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4028dc7487b42ac885d94a33794ffe5", + "name": "cupy", + "sha256": "2fb8a77e15d3d1e8b402b065c4a2f49f5e6ab6da9dbd61048dccbba811acc678", + "size": 23921739, + "subdir": "linux-64", + "timestamp": 1610055481005, + "version": "8.3.0" + }, + "cupy-8.3.0-py36hcaf9a05_0.conda": { + "build": "py36hcaf9a05_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.1|10.1.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a4069b6a9a5a68df0f05abf16c3aa2be", + "name": "cupy", + "sha256": "1fb32a90ea4d13b590b85aef91a1b7ab3722d2a3c5235f4f030ffa9030084d57", + "size": 23635470, + "subdir": "linux-64", + "timestamp": 1610062666925, + "version": "8.3.0" + }, + "cupy-8.3.0-py36heaad284_0.conda": { + "build": "py36heaad284_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.2|9.2.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4c9b09e6ab96fdc3235977a161fc20ef", + "name": "cupy", + "sha256": "772c4be4eb740eb1b5fdc3fe6c48f8a655062dfd18c321a5fd8339ede6acc9a4", + "size": 21861360, + "subdir": "linux-64", + "timestamp": 1610043330245, + "version": "8.3.0" + }, + "cupy-8.3.0-py37h91b26fc_0.conda": { + "build": "py37h91b26fc_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.0|10.0.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3399d74c63e8e5d66be8c3f5de02dc16", + "name": "cupy", + "sha256": "a3daf14bb6fd6d4dea69ef2133cfd35a8f71a3b83ec938080eb4515a75ed48cc", + "size": 23911006, + "subdir": "linux-64", + "timestamp": 1610057076676, + "version": "8.3.0" + }, + "cupy-8.3.0-py37hcaf9a05_0.conda": { + "build": "py37hcaf9a05_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.1|10.1.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "84301326b041786dd2427954534a4aa0", + "name": "cupy", + "sha256": "cb07a58f9e42c2daaf0c513209222ef8191ddbdce1298a32dd771686d2bfa1fd", + "size": 23628955, + "subdir": "linux-64", + "timestamp": 1610064233504, + "version": "8.3.0" + }, + "cupy-8.3.0-py37heaad284_0.conda": { + "build": "py37heaad284_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.2|9.2.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d6718ed0bbd93b5a661ef17bb948ddea", + "name": "cupy", + "sha256": "797ae1dac3e716a7013aa88b2ed17144db61fda9be623ce26b73ad65786b4e53", + "size": 21843378, + "subdir": "linux-64", + "timestamp": 1610044661910, + "version": "8.3.0" + }, + "cupy-8.3.0-py38h91b26fc_0.conda": { + "build": "py38h91b26fc_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.0|10.0.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f660034f8eff7aa133cf749d9fb779c1", + "name": "cupy", + "sha256": "ea44d9bdf794c97e30afb6be694373389be8533f883e58d576d2d32db7458311", + "size": 24101941, + "subdir": "linux-64", + "timestamp": 1610058430477, + "version": "8.3.0" + }, + "cupy-8.3.0-py38hcaf9a05_0.conda": { + "build": "py38hcaf9a05_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.1|10.1.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a2e6481e6ddc474f180f5e082446dae5", + "name": "cupy", + "sha256": "09c4d68f39e6c2f25a11897e4e2c346407770b1bc96f40e6a7321987ae572c80", + "size": 23830148, + "subdir": "linux-64", + "timestamp": 1610065881815, + "version": "8.3.0" + }, + "cupy-8.3.0-py38heaad284_0.conda": { + "build": "py38heaad284_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.2|9.2.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b977cffdecc594b98fac5ae02a1fcfa", + "name": "cupy", + "sha256": "5b7457525a9cfbcebd592514b12fd321049f7e27b2598e0f5c608726b2edac86", + "size": 22041001, + "subdir": "linux-64", + "timestamp": 1610045959852, + "version": "8.3.0" + }, + "cupy-8.3.0-py39h91b26fc_0.conda": { + "build": "py39h91b26fc_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.0|10.0.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9eba9f4cfddf8829fe3703a3e61f1bec", + "name": "cupy", + "sha256": "345b5c857eac94f1c8c40231bcdbad4ef86fdd484c36c13a136511f0d036ec57", + "size": 24106987, + "subdir": "linux-64", + "timestamp": 1610059758394, + "version": "8.3.0" + }, + "cupy-8.3.0-py39hcaf9a05_0.conda": { + "build": "py39hcaf9a05_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.1|10.1.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8dab9aa571ed297d9012dfd5e07e7214", + "name": "cupy", + "sha256": "7e53fc2c373b3609d5c9860aa80b252035eb429068046c19211eddf40d9e9023", + "size": 23831065, + "subdir": "linux-64", + "timestamp": 1610067224656, + "version": "8.3.0" + }, + "cupy-8.3.0-py39heaad284_0.conda": { + "build": "py39heaad284_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.2|9.2.*", + "cudnn >=7.6,<8.0a0", + "fastrlock >=0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nccl >=2.8.3.1,<3.0a0", + "numpy >=1.16", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8188f62aa476cb539dbb4fd25099c1b", + "name": "cupy", + "sha256": "27b1afe5e827657bd0b67e98a2fa18280c895891bb3ed29a75b7fd08bf8a5b64", + "size": 22042090, + "subdir": "linux-64", + "timestamp": 1610051324612, + "version": "8.3.0" + }, + "curl-7.55.1-h78862de_4.conda": { + "build": "h78862de_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libssh2 1.*", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "5e19df1ce06c906177dccf95a4f6d6d0", + "name": "curl", + "sha256": "f14f704bb1b7f69c6f0645ddf2732d240f33b9c30f0558e26aa9093bd3f5cbe5", + "size": 468395, + "subdir": "linux-64", + "timestamp": 1510603346884, + "version": "7.55.1" + }, + "curl-7.55.1-hcb0b314_2.conda": { + "build": "hcb0b314_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libssh2 1.*", + "openssl 1.0.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "f1ece9f99d6d39c5feca2eb90949b720", + "name": "curl", + "sha256": "c4ba637f157abf6a2d0de5a63d93321880e1d844b5beb75bafb3002cee4f11f5", + "size": 467832, + "subdir": "linux-64", + "timestamp": 1505687736238, + "version": "7.55.1" + }, + "curl-7.57.0-h84994c4_0.conda": { + "build": "h84994c4_0", + "build_number": 0, + "depends": [ + "libcurl 7.57.0 h1ad7b7a_0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "f71eae616b9d65cbd99efb9da41b3fef", + "name": "curl", + "sha256": "ff1d02628fda53321b3398acf66873ee743001cdea7b6f9a5c45297431ea5c5d", + "size": 129442, + "subdir": "linux-64", + "timestamp": 1516812887930, + "version": "7.57.0" + }, + "curl-7.58.0-h84994c4_0.conda": { + "build": "h84994c4_0", + "build_number": 0, + "depends": [ + "libcurl 7.58.0 h1ad7b7a_0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "c0132af5dc80984ebee5149fd6dd8880", + "name": "curl", + "sha256": "d316906499d6feb20798b1c4bae8873fc7bcbc21de60da2e319e07c30eecb291", + "size": 130794, + "subdir": "linux-64", + "timestamp": 1517284621373, + "version": "7.58.0" + }, + "curl-7.59.0-h84994c4_0.conda": { + "build": "h84994c4_0", + "build_number": 0, + "depends": [ + "libcurl 7.59.0 h1ad7b7a_0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "a82c43720e8a4b7ea97cce3e9036f9b0", + "name": "curl", + "sha256": "91fbbcc2434580da08f8495f1b3ebc50ce69c7cc9e526de81117f0fca80e8254", + "size": 132946, + "subdir": "linux-64", + "timestamp": 1522272211662, + "version": "7.59.0" + }, + "curl-7.60.0-h84994c4_0.conda": { + "build": "h84994c4_0", + "build_number": 0, + "depends": [ + "libcurl 7.60.0 h1ad7b7a_0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "24af7d360af5f87c565998ab53d15c02", + "name": "curl", + "sha256": "57485bd1bd956be2715a483e319c6f60f4c8d18424530932a2fec87584e4e791", + "size": 133374, + "subdir": "linux-64", + "timestamp": 1527109707199, + "version": "7.60.0" + }, + "curl-7.61.0-h84994c4_0.conda": { + "build": "h84994c4_0", + "build_number": 0, + "depends": [ + "libcurl 7.61.0 h1ad7b7a_0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "32fb51eda43fe2e0e27e56444b97dd53", + "name": "curl", + "sha256": "c3c2676ef57daea8bee1d68ea350b2abfd744cd144347150700b3bd598573e07", + "size": 134570, + "subdir": "linux-64", + "timestamp": 1532525690875, + "version": "7.61.0" + }, + "curl-7.61.1-hbc83047_0.conda": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "libcurl 7.61.1 h20c2e04_0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "269280db8ebcc3893dfececfc1a9cc8a", + "name": "curl", + "sha256": "67791e9b4ab2b75168cc69c13008569434234538fba4866d1b3dae12ef47dfb6", + "size": 138412, + "subdir": "linux-64", + "timestamp": 1539968321625, + "version": "7.61.1" + }, + "curl-7.62.0-hbc83047_0.conda": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "libcurl 7.62.0 h20c2e04_0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "68cebec6264f6c72176694c08fbc0a1e", + "name": "curl", + "sha256": "6dfe14841f180cfbb6a968d3d3fedaf87577ba8b8287a74525638ef6a5d6d7fc", + "size": 135632, + "subdir": "linux-64", + "timestamp": 1541435356254, + "version": "7.62.0" + }, + "curl-7.63.0-hbc83047_0.conda": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libcurl 7.63.0 h20c2e04_0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.0,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "cfb9e249a9b41f69d254fd009592c6a3", + "name": "curl", + "sha256": "4d648d74c07c7aabb79de8166e8c8fdef60d46c079d80fa83f91646cb4b71272", + "size": 143102, + "subdir": "linux-64", + "timestamp": 1547225810222, + "version": "7.63.0" + }, + "curl-7.63.0-hbc83047_1000.conda": { + "build": "hbc83047_1000", + "build_number": 1000, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libcurl 7.63.0 h20c2e04_1000", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.0,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "5ce9d691dec1f26acae45737e66ab701", + "name": "curl", + "sha256": "b6d6fbc6d0525e8a167ab04964eac87a7ca2f2c6d846c17400e6ae4ba60847e1", + "size": 137902, + "subdir": "linux-64", + "timestamp": 1545106038460, + "version": "7.63.0" + }, + "curl-7.64.0-hbc83047_2.conda": { + "build": "hbc83047_2", + "build_number": 2, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libcurl 7.64.0 h20c2e04_2", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.0,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "bcc4d698f78a675b504319ac434a2f10", + "name": "curl", + "sha256": "907736b87994aef433e4c66c964e143fec70da23f514453aa7d6df9935afe6d5", + "size": 144044, + "subdir": "linux-64", + "timestamp": 1552411764756, + "version": "7.64.0" + }, + "curl-7.64.1-hbc83047_0.conda": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libcurl 7.64.1 h20c2e04_0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "a75549c428e1ab0fa366f8a9516da95e", + "name": "curl", + "sha256": "4570c0937602bbcf6a1cd7457594a51069c9452ada2640103117f650dc2dc7da", + "size": 131007, + "subdir": "linux-64", + "timestamp": 1556031965527, + "version": "7.64.1" + }, + "curl-7.65.2-hbc83047_0.conda": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libcurl 7.65.2 h20c2e04_0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "9f9ccab87337ae0f9038549db28e0d7a", + "name": "curl", + "sha256": "3a4428f0f28bf23921b8b5f322218e15c21699e875ed8dcfc1f5acd449989eb1", + "size": 133201, + "subdir": "linux-64", + "timestamp": 1563398725979, + "version": "7.65.2" + }, + "curl-7.65.3-hbc83047_0.conda": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libcurl 7.65.3 h20c2e04_0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "1eae52447904aa376d6bea1f5abe8405", + "name": "curl", + "sha256": "74fe42a658ec82d2e17e095b494b34f8b34b06f5081a0accbd496531dcb2ab22", + "size": 132777, + "subdir": "linux-64", + "timestamp": 1566828859652, + "version": "7.65.3" + }, + "curl-7.67.0-hbc83047_0.conda": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libcurl 7.67.0 h20c2e04_0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "fc199d11c2b47a3f03b5f80e867ebe83", + "name": "curl", + "sha256": "1837beddaf668d0d6a76886d37b07d8a5589f5f7264a5174ddde3b3f1d1f3d1f", + "size": 136810, + "subdir": "linux-64", + "timestamp": 1574273454929, + "version": "7.67.0" + }, + "curl-7.68.0-hbc83047_0.conda": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "krb5 >=1.17.1,<1.18.0a0", + "libcurl 7.68.0 h20c2e04_0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "60c1f171c8a6f83b9034e179a7539e63", + "name": "curl", + "sha256": "0717f78d1e5b558b733ba6e47f97e756143ce969e010f21d3a63b18e085989f2", + "size": 138499, + "subdir": "linux-64", + "timestamp": 1580837350356, + "version": "7.68.0" + }, + "curl-7.69.1-hbc83047_0.conda": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "krb5 >=1.17.1,<1.18.0a0", + "libcurl 7.69.1 h20c2e04_0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.9.0,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "0478de4737cfe1095fc6a4fe4a58d824", + "name": "curl", + "sha256": "4b1e0a474a41e505596f5cf41d8d7f8b57cba112d321f48f2eb26fd09e45865b", + "size": 140052, + "subdir": "linux-64", + "timestamp": 1584460908322, + "version": "7.69.1" + }, + "curl-7.71.0-hbc83047_0.conda": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libcurl 7.71.0 h20c2e04_0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.9.0,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "8f3544c834c3188b66fe0bf55b48cd35", + "name": "curl", + "sha256": "59cedd507d766912a1d98760414f396b1cb4763f7d760336d786eb0523259b02", + "size": 143006, + "subdir": "linux-64", + "timestamp": 1593438205057, + "version": "7.71.0" + }, + "curl-7.71.1-h8f29fe8_2.conda": { + "build": "h8f29fe8_2", + "build_number": 2, + "depends": [ + "libcurl 7.71.1 h303737a_2", + "libgcc-ng >=7.3.0", + "libssh2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "e258b6a1e57aba769eb8defd26cf18f2", + "name": "curl", + "sha256": "20d7b4ed2c685b49261c0ebef9cf18d37ffc2773c651749ba1ddaea21d41afc4", + "size": 142720, + "subdir": "linux-64", + "timestamp": 1621648770299, + "version": "7.71.1" + }, + "curl-7.71.1-hbc83047_1.conda": { + "build": "hbc83047_1", + "build_number": 1, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libcurl 7.71.1 h20c2e04_1", + "libgcc-ng >=7.3.0", + "libssh2 >=1.9.0,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "4cfd3878496b511a0da4541cd6fffa6b", + "name": "curl", + "sha256": "863908e4d34f618a608f597945f4dd215355990cf23805da1d3e4254afbedfb4", + "size": 143778, + "subdir": "linux-64", + "timestamp": 1594834910415, + "version": "7.71.1" + }, + "curl-7.78.0-h1ccaba5_0.conda": { + "build": "h1ccaba5_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libcurl 7.78.0 h0b77cf5_0", + "libgcc-ng >=7.5.0", + "libssh2 >=1.9.0,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "2aa115252b10389012c3a4d9337131cc", + "name": "curl", + "sha256": "d6c7589cddc0d64b6f22ae9cf5a3fc37fea782a57c45f8c9a501d846ed2f6d8b", + "size": 95911, + "subdir": "linux-64", + "timestamp": 1628797021055, + "version": "7.78.0" + }, + "curl-7.80.0-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libcurl 7.80.0 h0b77cf5_0", + "libgcc-ng >=7.5.0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "aac2502064f3db6a7a1cd9648aa605ef", + "name": "curl", + "sha256": "f5a437a1c74e776988cc0aa2ecd0b1efcaddd66df0359a1449768656eefd2dfe", + "size": 97756, + "subdir": "linux-64", + "timestamp": 1639143833802, + "version": "7.80.0" + }, + "curl-7.82.0-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libcurl 7.82.0 h0b77cf5_0", + "libgcc-ng >=7.5.0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "151ad900396dbd644727fb53d677d4fb", + "name": "curl", + "sha256": "b107e440b54111e5221b658722faf1b14b1014405a4df1d6249692d538ecb5d3", + "size": 97652, + "subdir": "linux-64", + "timestamp": 1649731358187, + "version": "7.82.0" + }, + "curl-7.83.0-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libcurl 7.83.0 h0b77cf5_0", + "libgcc-ng >=7.5.0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "1b1c76627023c09f19b719050ff21aec", + "name": "curl", + "sha256": "8360cabc1406139fba7802486b44f4b1c2b510704a203255287d33655ca447b8", + "size": 86897, + "subdir": "linux-64", + "timestamp": 1652189680921, + "version": "7.83.0" + }, + "curl-7.84.0-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libcurl 7.84.0 h91b91d3_0", + "libgcc-ng >=11.2.0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "6d4927f8634699ca751689341fc6bbdc", + "name": "curl", + "sha256": "71db9374504410ca72bcfb5bf8a34552b84eb802ce136cd742926b2e312d59bf", + "size": 81363, + "subdir": "linux-64", + "timestamp": 1659041696676, + "version": "7.84.0" + }, + "curl-7.85.0-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libcurl 7.85.0 h91b91d3_0", + "libgcc-ng >=11.2.0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "160b50d10c04f5f463c92a5abba8c563", + "name": "curl", + "sha256": "fa49c7213a2832794ee3699597692629e34f4a085b49f0e1da407fabb835d80e", + "size": 80884, + "subdir": "linux-64", + "timestamp": 1666683424268, + "version": "7.85.0" + }, + "curl-7.86.0-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libcurl 7.86.0 h91b91d3_0", + "libgcc-ng >=11.2.0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "71a9ae4b4ccca0c7dc3f4aaf2d77a356", + "name": "curl", + "sha256": "dff6f53fde2326e7f0f29fdfae80321d6dba579a16d6ffe38e58c0176a420ae2", + "size": 89384, + "subdir": "linux-64", + "timestamp": 1669738519087, + "version": "7.86.0" + }, + "curl-7.87.0-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libcurl 7.87.0 h91b91d3_0", + "libgcc-ng >=11.2.0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "e29317006df3f948862a93aeab9e4e39", + "name": "curl", + "sha256": "20aa5911521166aacd443436eea581e132b6d267b3185cf8a60232965b495457", + "size": 89840, + "subdir": "linux-64", + "timestamp": 1674234310318, + "version": "7.87.0" + }, + "curl-7.88.1-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libcurl 7.88.1 h91b91d3_0", + "libgcc-ng >=11.2.0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "a2b4c46475a202c4d980c706f1a06c5d", + "name": "curl", + "sha256": "660795f6b676108a650bb4a3a1b7cbccb0282155b2108798e91cc314c99d8cb7", + "size": 90467, + "subdir": "linux-64", + "timestamp": 1678377847425, + "version": "7.88.1" + }, + "curtsies-0.3.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "blessings >=1.5", + "python >=3.10,<3.11.0a0", + "wcwidth >=0.1.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f5393f404200e0cb03b1b3ab2ab17ea", + "name": "curtsies", + "sha256": "27fb5ca6332a65140474f0db8ea4b4aad6ce1198bd4c41d0745a14a7e5f1cb16", + "size": 62406, + "subdir": "linux-64", + "timestamp": 1640808892361, + "version": "0.3.4" + }, + "curtsies-0.3.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "blessings >=1.5", + "python >=3.11,<3.12.0a0", + "wcwidth >=0.1.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc750af485d75dee46434592003420d7", + "name": "curtsies", + "sha256": "aa042e0b90df414e554c5d8b1b4865943f8602117a9aa2c720645e3f47801ac4", + "size": 83132, + "subdir": "linux-64", + "timestamp": 1676843687740, + "version": "0.3.4" + }, + "curtsies-0.3.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "blessings >=1.5", + "python >=3.6,<3.7.0a0", + "wcwidth >=0.1.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c2ce5a526a7d5c794ea73b6a22981f5", + "name": "curtsies", + "sha256": "97d3d05221c081db2a841cbcc21f2974458d43a7522720ea539e99c3a8cc3277", + "size": 62349, + "subdir": "linux-64", + "timestamp": 1598664644537, + "version": "0.3.4" + }, + "curtsies-0.3.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "blessings >=1.5", + "python >=3.6,<3.7.0a0", + "wcwidth >=0.1.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64675bcc6081758a0fbc295d99b3b83b", + "name": "curtsies", + "sha256": "0e14bd2af4e3f8db3be2aed353a9b96780b9eed15350d79597d13913ddb492ce", + "size": 63616, + "subdir": "linux-64", + "timestamp": 1614257628123, + "version": "0.3.4" + }, + "curtsies-0.3.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "blessings >=1.5", + "python >=3.7,<3.8.0a0", + "wcwidth >=0.1.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9b2f06a6d9072c95110c4149724cc3c", + "name": "curtsies", + "sha256": "ba5a9dcd52a90d4c965b0aa8f4f779ee3e41650c5f3dca4c59f5719c84962c31", + "size": 62188, + "subdir": "linux-64", + "timestamp": 1598664641802, + "version": "0.3.4" + }, + "curtsies-0.3.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "blessings >=1.5", + "python >=3.7,<3.8.0a0", + "wcwidth >=0.1.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a5f1a9b881ede6589d4036570bf4221", + "name": "curtsies", + "sha256": "5b68a025049d29a0b03f719ecf84bfab9c9d12c028beb2622be6de1909931a1a", + "size": 63233, + "subdir": "linux-64", + "timestamp": 1614257625390, + "version": "0.3.4" + }, + "curtsies-0.3.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "blessings >=1.5", + "python >=3.8,<3.9.0a0", + "wcwidth >=0.1.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "46aabce7d349aef467b18e903d111c4d", + "name": "curtsies", + "sha256": "bcc53acadfcc73b3c91125e199b21621104d3915761052a4d7a4f6fb30034068", + "size": 63556, + "subdir": "linux-64", + "timestamp": 1598664685187, + "version": "0.3.4" + }, + "curtsies-0.3.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "blessings >=1.5", + "python >=3.8,<3.9.0a0", + "wcwidth >=0.1.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "acf91626bda347e0ed6a3d42a457977b", + "name": "curtsies", + "sha256": "07fbbd96a255aa391ce28a3220b17e2251ee80568e883abee02c4d0e316a87ae", + "size": 63548, + "subdir": "linux-64", + "timestamp": 1614256625377, + "version": "0.3.4" + }, + "curtsies-0.3.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "blessings >=1.5", + "python >=3.9,<3.10.0a0", + "wcwidth >=0.1.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d3c1477adb4c0d6024ac1a2d96d8f8e2", + "name": "curtsies", + "sha256": "6760898fb362f971f3e2a7095cab975f502e1a4cf7891484bc7aa2eb8ee773a7", + "size": 62254, + "subdir": "linux-64", + "timestamp": 1614257640156, + "version": "0.3.4" + }, + "cvxcanon-0.1.1-py27h04863e7_0.conda": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "af0dffd8b3927617e9a1eede05050a50", + "name": "cvxcanon", + "sha256": "b47bf8cfa384abff03f2439f82031935b5c06dda32afc28fe58a5f60587787fd", + "size": 191324, + "subdir": "linux-64", + "timestamp": 1530814434842, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py27h91e6341_0.conda": { + "build": "py27h91e6341_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "5d4765b2ec72c5ea582f9adce0376317", + "name": "cvxcanon", + "sha256": "5fd279bc71e3ed1eb9c5f199d951b0c3344f148500c11b2a4284a11ae219de47", + "size": 191430, + "subdir": "linux-64", + "timestamp": 1507617127900, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py310h00e6091_0.conda": { + "build": "py310h00e6091_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy", + "python >=3.10,<3.11.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "db2280af6bb040f61c650090316945d6", + "name": "cvxcanon", + "sha256": "77554d1cb707e92eac8316ec38ccd48eb2f51fa4938a6cc468d581e720f1a4fd", + "size": 1272079, + "subdir": "linux-64", + "timestamp": 1640808933873, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py311hba01205_0.conda": { + "build": "py311hba01205_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.11,<3.12.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "1be587595b0cefc1ffc54b1517090dcd", + "name": "cvxcanon", + "sha256": "d9bc503afb19cdac34595f28307cf43f26f3b62ce7285b61f14d2cca894472a4", + "size": 194124, + "subdir": "linux-64", + "timestamp": 1676907089019, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py35h04863e7_0.conda": { + "build": "py35h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "9dd87d92830e57da49fb2d1740642b92", + "name": "cvxcanon", + "sha256": "c0c8431a594769c72aea9f56004c5633457b299517b3c7e90e9633ccd4b3717c", + "size": 196752, + "subdir": "linux-64", + "timestamp": 1535130324236, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py35h9a30ffc_0.conda": { + "build": "py35h9a30ffc_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "1046ffcfd05120c3fd066fc340730974", + "name": "cvxcanon", + "sha256": "d4164e86e4560c915d6596b0a2b1e84d2f0c7513a85f674ed04e841403fbb16f", + "size": 191704, + "subdir": "linux-64", + "timestamp": 1507617409597, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py36h04863e7_0.conda": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "6a44c6761f574bd7f947883a4afe9126", + "name": "cvxcanon", + "sha256": "b021b54323b95d43173c94f772605dce6676ace2310bdfdf91be9e1542aa4764", + "size": 191791, + "subdir": "linux-64", + "timestamp": 1530814535713, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "30fafaf373aebc39d8a684c61917ac17", + "name": "cvxcanon", + "sha256": "6a49296a04e6c9b8ce25bce5db5ccd7a0dbdcbf57b68cc1a669c0c7c75c9ff26", + "size": 387107, + "subdir": "linux-64", + "timestamp": 1592214891729, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py36h7353a8a_0.conda": { + "build": "py36h7353a8a_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "dbcddde192b91c2797db36d3f75107d7", + "name": "cvxcanon", + "sha256": "c3143d4d3d894d0f27d8889d536759de312ad9792f3f2df9e6a04cbd7898fa35", + "size": 191118, + "subdir": "linux-64", + "timestamp": 1507617482779, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py36ha9443f7_0.conda": { + "build": "py36ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "ec447e8e493908ed0303f78619398cd9", + "name": "cvxcanon", + "sha256": "e2bedf154f9cc8bae2a6e9fa02682a4458ffb16c4c1a8676f4cfdadc718d1e28", + "size": 439386, + "subdir": "linux-64", + "timestamp": 1614265298725, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py37h04863e7_0.conda": { + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "ff199abc4c16a5fb2cb9412e728a767e", + "name": "cvxcanon", + "sha256": "8a2325840f3ff42a35a69c84a2acde39e28a54f2f60bc9c6cb068dabb450cf23", + "size": 191585, + "subdir": "linux-64", + "timestamp": 1530814484783, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "025a6f9da4aa8eab23aceba3eab3e431", + "name": "cvxcanon", + "sha256": "6d5b89ee7ae0a3997fe90ec382167cd1cec8f50b3b353fce49af41e472a088d0", + "size": 386306, + "subdir": "linux-64", + "timestamp": 1592214867939, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py37ha9443f7_0.conda": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "975bc9f166b00f14bc611479bee184e5", + "name": "cvxcanon", + "sha256": "4a9183c64719b93493717845593187afc3a72292fb044349ec915c7932eb6b07", + "size": 438645, + "subdir": "linux-64", + "timestamp": 1614265270454, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "da8bcfb7e13bd66e3babb231276f38f9", + "name": "cvxcanon", + "sha256": "88674b6e109b2b453ae977c648e1c7c71966594fb85b047ad3d2197dda9890f7", + "size": 387156, + "subdir": "linux-64", + "timestamp": 1592214691530, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py38ha9443f7_0.conda": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "c2332e0fda15da3aca28c7969fdc5bb6", + "name": "cvxcanon", + "sha256": "188a3b0c44f1fb2a30f8de05f605122106e87d9a6d33236f960f55f5c14ed496", + "size": 439652, + "subdir": "linux-64", + "timestamp": 1614265027423, + "version": "0.1.1" + }, + "cvxcanon-0.1.1-py39ha9443f7_0.conda": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.9,<3.10.0a0", + "scipy" + ], + "license": "GPL3", + "md5": "48f16c9b0893dee8230b586369e1e884", + "name": "cvxcanon", + "sha256": "bf1977b07f850f7c9907b15d2c5d154828fd150b89c4b90df09006b7f37d8799", + "size": 439973, + "subdir": "linux-64", + "timestamp": 1614265278475, + "version": "0.1.1" + }, + "cvxopt-1.2.0-py27h2c4e229_0.conda": { + "build": "py27h2c4e229_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "fftw >=3.3.8,<4.0a0", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "5ba2fcf229603449b4f225493f6487a3", + "name": "cvxopt", + "sha256": "afa03bacc6d5c91287f9108ee1fb99a05c8ef6d861f3521258bf473e497e05c7", + "size": 490386, + "subdir": "linux-64", + "timestamp": 1528997805128, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py27h75fe3a5_0.conda": { + "build": "py27h75fe3a5_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.8,<3.4.0a0", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "2dcde506c4439f0d96031c18b2c66ffa", + "name": "cvxopt", + "sha256": "c6223bf49d9d75625a948b2ce2da2644b5bdd2024453724495696e024543cb14", + "size": 490089, + "subdir": "linux-64", + "timestamp": 1550695564878, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py27h9e0dedd_0.conda": { + "build": "py27h9e0dedd_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "9c180d70263e266816b7124937bbde67", + "name": "cvxopt", + "sha256": "3909476291873d369fdc99d0b1acb463e4a94ae5f92499bb464ee064bd61d79a", + "size": 486720, + "subdir": "linux-64", + "timestamp": 1528997861621, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py27hfa32c7d_0.conda": { + "build": "py27hfa32c7d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "c58b35e4a5331d799539036fffdabecd", + "name": "cvxopt", + "sha256": "f7d69820023187178526b8362c8fe3d80e7377ad9f07193885c674d979b0a8be", + "size": 490738, + "subdir": "linux-64", + "timestamp": 1550695674832, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py35h2c4e229_0.conda": { + "build": "py35h2c4e229_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "fftw >=3.3.8,<4.0a0", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "320f5fdcd948cb2f3fb526c07e08e64b", + "name": "cvxopt", + "sha256": "bb946f58a4b76f12ee0812ad4cbe7eaad147fbdd86a8c4b035e1a6ea487a05ea", + "size": 494572, + "subdir": "linux-64", + "timestamp": 1528997796153, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py35h9e0dedd_0.conda": { + "build": "py35h9e0dedd_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "6024308816a7b6f69732a192c576a3bd", + "name": "cvxopt", + "sha256": "45768786205f3b94293557c3fbed399663b7bb60c4ac1c8c2a01b5963bf88f44", + "size": 494757, + "subdir": "linux-64", + "timestamp": 1528997794733, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py36h2c4e229_0.conda": { + "build": "py36h2c4e229_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "fftw >=3.3.8,<4.0a0", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "aa3bb9dfa18e5924308254cfd6e53fb7", + "name": "cvxopt", + "sha256": "f15623dbf9e529906292b72979d6fe467a4e28877476ad0ddceeaf0447042ad7", + "size": 489505, + "subdir": "linux-64", + "timestamp": 1528997706614, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py36h75fe3a5_0.conda": { + "build": "py36h75fe3a5_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.8,<3.4.0a0", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "9ccde89d42e3699fb000cfa321eadb37", + "name": "cvxopt", + "sha256": "d4cfc817aade91e17ec756974940ff5b0da7322df6e0dc0371ade02bc4e551a9", + "size": 492592, + "subdir": "linux-64", + "timestamp": 1550695610377, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py36h9e0dedd_0.conda": { + "build": "py36h9e0dedd_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "a015595962f3e157c6e5211ecae86446", + "name": "cvxopt", + "sha256": "84844c6f1f4c8cab5690fe6dab7f79bd2d847a78de36ef149ced69e8a8391a71", + "size": 493412, + "subdir": "linux-64", + "timestamp": 1528997415906, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py36ha87f1a5_0.conda": { + "build": "py36ha87f1a5_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "306b96c7af92c0585bf092d6b33309cb", + "name": "cvxopt", + "sha256": "d6eececea7a730bbe2d3af6f93bb2dc71a3217155d64f68e432b914f2520bdae", + "size": 496501, + "subdir": "linux-64", + "timestamp": 1614267875686, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py36hfa32c7d_0.conda": { + "build": "py36hfa32c7d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "9ff86dcecb3803d36357f5a0775731fd", + "name": "cvxopt", + "sha256": "8eefe46d02cf07e931509c0d128966ed04965f8958c4deaf9077ba72a8fec410", + "size": 497571, + "subdir": "linux-64", + "timestamp": 1550695714448, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py37h75fe3a5_0.conda": { + "build": "py37h75fe3a5_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.8,<3.4.0a0", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "8c1c374a529d7036798c6a7b14f2367d", + "name": "cvxopt", + "sha256": "2eadb7b6930c6ebd008b7b35c5d5e05fef377114340f8b70cf568ddcd1291404", + "size": 496183, + "subdir": "linux-64", + "timestamp": 1550699270665, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py37ha87f1a5_0.conda": { + "build": "py37ha87f1a5_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "79e5f7b7b53376b1a20ad154382d2edd", + "name": "cvxopt", + "sha256": "9bdf7545854c4a61eebf0a4ea885ad5b26a32f89e28e7e41771967b5caeaaebf", + "size": 490084, + "subdir": "linux-64", + "timestamp": 1614266845022, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py37hfa32c7d_0.conda": { + "build": "py37hfa32c7d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "654017bfd7c4774242d1f8969c3f5ffb", + "name": "cvxopt", + "sha256": "92b747bf1a09bd8a9692a58ca950ba9d4ea55aeb4d3ad6722b3fa7b18e43f07f", + "size": 493085, + "subdir": "linux-64", + "timestamp": 1550695709172, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py38h75fe3a5_0.conda": { + "build": "py38h75fe3a5_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.8,<3.4.0a0", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "c89e42c31011274ad92a01068e0b28fd", + "name": "cvxopt", + "sha256": "3c4fa9f5147cac67abb9cce48cfd3969b8d30e106dfb251d3eaae7765ecf5d2c", + "size": 500642, + "subdir": "linux-64", + "timestamp": 1573730140632, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py38ha87f1a5_0.conda": { + "build": "py38ha87f1a5_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "5e2c3c389db005c4951a2337953e7383", + "name": "cvxopt", + "sha256": "58d2a983319805bbca50dc1197665adac2fa48060515db08c241a8d736f304cd", + "size": 494331, + "subdir": "linux-64", + "timestamp": 1614267877834, + "version": "1.2.0" + }, + "cvxopt-1.2.0-py38hfa32c7d_0.conda": { + "build": "py38hfa32c7d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0", + "suitesparse >=5.2.0,<6.0a0" + ], + "license": "GPL 3", + "md5": "79918f609e3c8719b3382295fc5e2427", + "name": "cvxopt", + "sha256": "1cc542882d09cffb2a3992e76f862e9b7eb04971816d5297db9be646eca51e12", + "size": 501063, + "subdir": "linux-64", + "timestamp": 1573730215363, + "version": "1.2.0" + }, + "cvxopt-1.2.6-py310h4077e5c_1.conda": { + "build": "py310h4077e5c_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "2822ae76c70acc01a1f620fb50caab45", + "name": "cvxopt", + "sha256": "63bafa4b00c895ff6685e999ba97328cab6d9e71525c8c8b801673eee2f660b3", + "size": 819059, + "subdir": "linux-64", + "timestamp": 1656076931100, + "version": "1.2.6" + }, + "cvxopt-1.2.6-py310h7aab8bc_1.conda": { + "build": "py310h7aab8bc_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.10,<3.11.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "1251c8493b38da61a825371dbcc57279", + "name": "cvxopt", + "sha256": "1375ce3318be77dfd8c181bf530f590e01e051e462b615b6195fb872d5afb625", + "size": 818708, + "subdir": "linux-64", + "timestamp": 1656077129942, + "version": "1.2.6" + }, + "cvxopt-1.2.6-py310he715372_0.conda": { + "build": "py310he715372_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.4,<2.5.0a0", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.10,<3.11.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "27663858937e0dcb6cc4a778beb47df9", + "name": "cvxopt", + "sha256": "ec98eae4f5e1d4dda68db99d1b476fc9d034c070551d688def7bba6521b078a1", + "size": 753767, + "subdir": "linux-64", + "timestamp": 1641894686585, + "version": "1.2.6" + }, + "cvxopt-1.2.6-py311h7aab8bc_0.conda": { + "build": "py311h7aab8bc_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.11,<3.12.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "09ef2b052ab1a2b2f750b94acfbcb797", + "name": "cvxopt", + "sha256": "fccc25db6a3a55dd214f0a887587e9770a77dfed178c715d93e515373fd9512c", + "size": 548061, + "subdir": "linux-64", + "timestamp": 1677034706748, + "version": "1.2.6" + }, + "cvxopt-1.2.6-py37h4077e5c_1.conda": { + "build": "py37h4077e5c_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "ec902033ce173bbfcadb5e78330e443a", + "name": "cvxopt", + "sha256": "f3435ded191cb27c5b7e8db3408c3f547399b1b30fa47004ff5ed6a38de8703f", + "size": 489761, + "subdir": "linux-64", + "timestamp": 1656076873547, + "version": "1.2.6" + }, + "cvxopt-1.2.6-py37h7aab8bc_1.conda": { + "build": "py37h7aab8bc_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.7,<3.8.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "b923ec63cc28fea6a6ef288012753ebd", + "name": "cvxopt", + "sha256": "81c603fe1d7b6ab66978a0bdab1dbcb6a622be6d3abea50137ebb58c0b9fa9b2", + "size": 489407, + "subdir": "linux-64", + "timestamp": 1656077076763, + "version": "1.2.6" + }, + "cvxopt-1.2.6-py38h4077e5c_1.conda": { + "build": "py38h4077e5c_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "13f5129bcf2d17aada44a8f35db0e761", + "name": "cvxopt", + "sha256": "540f281c70129818788fd34196aebc3a33a5e45678df16c13d46cec4b335e5f5", + "size": 491728, + "subdir": "linux-64", + "timestamp": 1656076976380, + "version": "1.2.6" + }, + "cvxopt-1.2.6-py38h7aab8bc_1.conda": { + "build": "py38h7aab8bc_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.8,<3.9.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "b5cdaec9894c71bc293a52e4137ba93d", + "name": "cvxopt", + "sha256": "0166c3bc026e7e9e1e3caa648aec695f5ed729d997b3d4273f46fcd1cb5dd03d", + "size": 491409, + "subdir": "linux-64", + "timestamp": 1656077184392, + "version": "1.2.6" + }, + "cvxopt-1.2.6-py39h4077e5c_1.conda": { + "build": "py39h4077e5c_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "9464327b8e177fec0d252a8750ad68b1", + "name": "cvxopt", + "sha256": "9617df41324fe1fa9fe01938a6f0601d6595e36a8631408fc5e0379fb64590af", + "size": 490846, + "subdir": "linux-64", + "timestamp": 1656077031143, + "version": "1.2.6" + }, + "cvxopt-1.2.6-py39h7aab8bc_1.conda": { + "build": "py39h7aab8bc_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.9,<3.10.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL 3", + "md5": "83383fce10b882ccade43625fc28230b", + "name": "cvxopt", + "sha256": "ed72bc377e9420f96b68b3a6fa2f6d7685bea796fe602f9bc900c7dd673602a8", + "size": 490469, + "subdir": "linux-64", + "timestamp": 1656077229397, + "version": "1.2.6" + }, + "cvxopt-1.3.0-py310h7aab8bc_0.conda": { + "build": "py310h7aab8bc_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.10,<3.11.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "d825827e65c021f18799c8481c3533a1", + "name": "cvxopt", + "sha256": "44fa046691cda0442e334364dbd43b71a1913620c2a3f4aa603f5bc3c98f54e4", + "size": 536968, + "subdir": "linux-64", + "timestamp": 1677700998831, + "version": "1.3.0" + }, + "cvxopt-1.3.0-py311h7aab8bc_0.conda": { + "build": "py311h7aab8bc_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.11,<3.12.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "85a3cd1b95cbde8d4af149e1b63377dc", + "name": "cvxopt", + "sha256": "05f47ec5946f270577a31eea6dc4b994727ddc8b0fdbb5836567dc981f9477bd", + "size": 548099, + "subdir": "linux-64", + "timestamp": 1677271547787, + "version": "1.3.0" + }, + "cvxopt-1.3.0-py38h7aab8bc_0.conda": { + "build": "py38h7aab8bc_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.8,<3.9.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "4e95a22eef913fcd135ecb11359ebd63", + "name": "cvxopt", + "sha256": "a53f9854ec9a4de76ccc2d85c033d778d80907efceec0982a96720b6dbe2f868", + "size": 535497, + "subdir": "linux-64", + "timestamp": 1677701050385, + "version": "1.3.0" + }, + "cvxopt-1.3.0-py39h7aab8bc_0.conda": { + "build": "py39h7aab8bc_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "dsdp", + "fftw", + "glpk >=4.65,<4.66.0a0", + "gsl >=2.7.1,<2.8.0a0", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.9,<3.10.0a0", + "suitesparse >=5.10.1,<6.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "efef3b041f3c730831a36f87c357a5c0", + "name": "cvxopt", + "sha256": "5f057605e04b0eb4d9b753ffd1cce839684053c8143a3f0173cd1af3a36ab0c4", + "size": 534840, + "subdir": "linux-64", + "timestamp": 1677700947275, + "version": "1.3.0" + }, + "cx_oracle-6.0.3-py27hc82e58e_0.conda": { + "build": "py27hc82e58e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "e413d2ee72f4522edb74944c485bfe1a", + "name": "cx_oracle", + "sha256": "d637cedcf55e4946dc46bd384da8dd087db4095204b5ef78ce7b9c2c7cffabfd", + "size": 131928, + "subdir": "linux-64", + "timestamp": 1511813842245, + "version": "6.0.3" + }, + "cx_oracle-6.0.3-py35h7bef0a5_0.conda": { + "build": "py35h7bef0a5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "7604459500c5d4df3bfd7c7ed5ccd273", + "name": "cx_oracle", + "sha256": "73c5ea2683fe7a287ac0fbe5a3d50c2c7c1c634b49964265689fab25b5e69072", + "size": 132003, + "subdir": "linux-64", + "timestamp": 1511813920437, + "version": "6.0.3" + }, + "cx_oracle-6.0.3-py36h16aab10_0.conda": { + "build": "py36h16aab10_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "19ec7399cba6fe7234f089b56d915e20", + "name": "cx_oracle", + "sha256": "7603eeabfbfd885a311dd6ae460c90a4327136de3e6310771a9b3f2ec469975a", + "size": 133396, + "subdir": "linux-64", + "timestamp": 1511813927226, + "version": "6.0.3" + }, + "cx_oracle-6.1-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "64868ccf00de9ab3be18abee3d83cd8a", + "name": "cx_oracle", + "sha256": "4724adf0fa31e4a2f667987d7e5775dd51a2e06804fc4bb708bf5508abd1e768", + "size": 136319, + "subdir": "linux-64", + "timestamp": 1519148355667, + "version": "6.1" + }, + "cx_oracle-6.1-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "98d85e44fbcb9c268f6150ddbeacad42", + "name": "cx_oracle", + "sha256": "697b2825f98997da5413706126d4c3dddf126174ddaf671137ad547f9f4ec240", + "size": 136404, + "subdir": "linux-64", + "timestamp": 1519148369455, + "version": "6.1" + }, + "cx_oracle-6.1-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "1acee6fc5a38061db91a1fe375484d4a", + "name": "cx_oracle", + "sha256": "0c8312bf4bae75007321f1f26ad1caa7c31d3a9745014d162919e855245e5403", + "size": 137925, + "subdir": "linux-64", + "timestamp": 1519148371061, + "version": "6.1" + }, + "cx_oracle-6.2.1-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "d324bc4e1b8094663aa2420178e56a35", + "name": "cx_oracle", + "sha256": "fc8c7110ae888ed637b6573430ce20cb41c5f853218ad4ac9a7239154f53711c", + "size": 136876, + "subdir": "linux-64", + "timestamp": 1524495337478, + "version": "6.2.1" + }, + "cx_oracle-6.2.1-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "2014afc8aab591d7c09520419f3396b9", + "name": "cx_oracle", + "sha256": "2d3c4876be04add45cca1d7e78ec7f45cc0234074093313fd9d1635dde662c61", + "size": 137082, + "subdir": "linux-64", + "timestamp": 1524495453461, + "version": "6.2.1" + }, + "cx_oracle-6.2.1-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "533b4c4404ffbc8652b461cdf2744781", + "name": "cx_oracle", + "sha256": "aeb45de98f91edeb1cd12c396d86541640462d5f8f6a9b0cb4ed5a1cdedeb92c", + "size": 138798, + "subdir": "linux-64", + "timestamp": 1524495340159, + "version": "6.2.1" + }, + "cx_oracle-6.3.1-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "a8d58c42eee02c3a2b55c741cb03c879", + "name": "cx_oracle", + "sha256": "51110c0e408312be8521204583e01ff149ab161b6d8c99c690bb8cbb86734e0e", + "size": 138248, + "subdir": "linux-64", + "timestamp": 1529240780393, + "version": "6.3.1" + }, + "cx_oracle-6.3.1-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "aaf23a16abf0cc7ba4926b48c8db8874", + "name": "cx_oracle", + "sha256": "e2be268639aa2614af5c697df1eda418aa10ec3bc39f8d0681d5649585fcfa06", + "size": 140970, + "subdir": "linux-64", + "timestamp": 1529240789099, + "version": "6.3.1" + }, + "cx_oracle-6.3.1-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "8ccf8a91b4ea0dd1361c1178c78a5dd3", + "name": "cx_oracle", + "sha256": "cec1eaafd72a78f40d7454b16a90b7a05ed99d3739af49f2533c6b892d96c0a0", + "size": 138360, + "subdir": "linux-64", + "timestamp": 1529240762984, + "version": "6.3.1" + }, + "cx_oracle-6.3.1-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "68c1cbcbd65294ecd9d654bd430ae6dc", + "name": "cx_oracle", + "sha256": "1a50a5cd4b9a19338845ae29eae0158271c86d807f6fdcbe07fcb1093d9da413", + "size": 139642, + "subdir": "linux-64", + "timestamp": 1530814576724, + "version": "6.3.1" + }, + "cx_oracle-6.4.1-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "fba7973ee922079365ea1e957c0fe2c6", + "name": "cx_oracle", + "sha256": "51dd570336499f578cc98bcfd5c49d66b00b2faaadc842ae44638b87ae2903e4", + "size": 140884, + "subdir": "linux-64", + "timestamp": 1532799502659, + "version": "6.4.1" + }, + "cx_oracle-6.4.1-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "2b204d16a46bb56a66b8c34205842df4", + "name": "cx_oracle", + "sha256": "0c230fca81235406001b0a57a92ac8ae3f174442ddb5460f5dc83481deb991d1", + "size": 141827, + "subdir": "linux-64", + "timestamp": 1532799612934, + "version": "6.4.1" + }, + "cx_oracle-6.4.1-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "c66fdb0651cb9423c4677a33a84455b2", + "name": "cx_oracle", + "sha256": "eb32ab503dda31ca538b08637769dc67274748ed633534a32814d653baae479b", + "size": 140780, + "subdir": "linux-64", + "timestamp": 1532799474330, + "version": "6.4.1" + }, + "cx_oracle-6.4.1-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "c43b33f5a27d72d6492e239596046e5e", + "name": "cx_oracle", + "sha256": "048da0ab76d365ae7662f1e4a0ef3a038b77801a910f1b3135102b338c163899", + "size": 140769, + "subdir": "linux-64", + "timestamp": 1532799613011, + "version": "6.4.1" + }, + "cx_oracle-7.0.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "c8cc863cda0c4ca790aab3fb41447fd0", + "name": "cx_oracle", + "sha256": "91aaf0b231ca93f7962b79776853e9043dfde70b8ad29c4361b2bcf221bef111", + "size": 163898, + "subdir": "linux-64", + "timestamp": 1540060183587, + "version": "7.0.0" + }, + "cx_oracle-7.0.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "2cb08fa918e5b04e28cbad1d34cf5b76", + "name": "cx_oracle", + "sha256": "d84b529196c836624e2f64f7df9dab81a0de0dd9a462e2b3d9bf7ad3c8352968", + "size": 163852, + "subdir": "linux-64", + "timestamp": 1540060236427, + "version": "7.0.0" + }, + "cx_oracle-7.0.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "acaa7e05fc837855e84b8fd31a1c5eb2", + "name": "cx_oracle", + "sha256": "ee6796a1b7e6553c516c9872baa1f91b595b1bcda8c4c5948897e2c1907b1f88", + "size": 163855, + "subdir": "linux-64", + "timestamp": 1540060203929, + "version": "7.0.0" + }, + "cx_oracle-7.2.2-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e2ef527d3d1bb920f4f5723ea0f582bc", + "name": "cx_oracle", + "sha256": "6dcb02280794115f56f7e2fb928a4d9ef99a464dadc7baf2e4d581fb0023c315", + "size": 176371, + "subdir": "linux-64", + "timestamp": 1569432348301, + "version": "7.2.2" + }, + "cx_oracle-7.2.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ff874cdd1086745123b9444e58f35ac", + "name": "cx_oracle", + "sha256": "10c863cc33dce877a1fda761f255dfd8069b601533a11d971cadca10ebdf35a7", + "size": 175977, + "subdir": "linux-64", + "timestamp": 1569432365537, + "version": "7.2.2" + }, + "cx_oracle-7.2.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6b0644b1ca98e7c62aaf7d0df618704d", + "name": "cx_oracle", + "sha256": "ac986705db3501e938a912e71eb0bce7c26ca9c951b8c00a233192d27c5fc2df", + "size": 176854, + "subdir": "linux-64", + "timestamp": 1569432355937, + "version": "7.2.2" + }, + "cx_oracle-7.2.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "427ad380d3d23214e591bda13aaba6be", + "name": "cx_oracle", + "sha256": "787fb09dd3dfe1014edfcfe80c98b010eb718ee5ec68afad43aa7c2fc07a5707", + "size": 182155, + "subdir": "linux-64", + "timestamp": 1573034067429, + "version": "7.2.2" + }, + "cx_oracle-7.2.3-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "80d40590e47f0be6cc5b735cbf1c1c37", + "name": "cx_oracle", + "sha256": "dffe0a689add8963cc32d083ec6105b4b1b2bfdca3f22dab1b44df2754575054", + "size": 176754, + "subdir": "linux-64", + "timestamp": 1574367654503, + "version": "7.2.3" + }, + "cx_oracle-7.2.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "60e243fbcf09f923d97e66c255a4c162", + "name": "cx_oracle", + "sha256": "52eaa262fbfa9f4c4c4cdc628d1c0328fe509fe1fa5ad662be91e0674a04b8fa", + "size": 176330, + "subdir": "linux-64", + "timestamp": 1574367662634, + "version": "7.2.3" + }, + "cx_oracle-7.2.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "01720c1baa3c842713ab79d9c3060468", + "name": "cx_oracle", + "sha256": "fc963e1843e2a753e3ca22f7452b8da8911ec60a9181a8650be3fa313757ddff", + "size": 176542, + "subdir": "linux-64", + "timestamp": 1574367699368, + "version": "7.2.3" + }, + "cx_oracle-7.2.3-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "332c712afe13d72b5aa26674390c4421", + "name": "cx_oracle", + "sha256": "03c22e6864c618fba6d2bad2b9fdf9bb836b7e322da77d3faad60efefd4ec99c", + "size": 184811, + "subdir": "linux-64", + "timestamp": 1574367703668, + "version": "7.2.3" + }, + "cx_oracle-8.0.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5249772481ecbdde7abb01408d6512ee", + "name": "cx_oracle", + "sha256": "83eeac03a7b83c9e2d4ef0e55d605e7e5afc2c3915a6e3e55ee627e8ca8e1575", + "size": 181856, + "subdir": "linux-64", + "timestamp": 1600355102499, + "version": "8.0.1" + }, + "cx_oracle-8.0.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9e6625fb03482220f903acd08b828ca0", + "name": "cx_oracle", + "sha256": "c8c5f006a6130ba95ad392070a6ad2782de65554058f785176592a408677f190", + "size": 183843, + "subdir": "linux-64", + "timestamp": 1600355141837, + "version": "8.0.1" + }, + "cx_oracle-8.0.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7fc030d760fcf72034d71e74e4b1277c", + "name": "cx_oracle", + "sha256": "a61b4066d5e812d5876f9d18a64bed8246323c3dcab8ce43c7959f447b764397", + "size": 183002, + "subdir": "linux-64", + "timestamp": 1600355122846, + "version": "8.0.1" + }, + "cx_oracle-8.1.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "64f6b00b7799b17b7bbb2ab9b7e367f8", + "name": "cx_oracle", + "sha256": "30fa4fc68196a67017c4eb559397bf5f8c67873c7ba84bd6ff3fa09eba004244", + "size": 190978, + "subdir": "linux-64", + "timestamp": 1607534427939, + "version": "8.1.0" + }, + "cx_oracle-8.1.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a0df4b804e42c56d3f07a7c42403f9a", + "name": "cx_oracle", + "sha256": "beb39c42577e2d586a0f01cd6326d33ee018be4da2c33bff31ff2eb32b7db746", + "size": 190975, + "subdir": "linux-64", + "timestamp": 1607534459777, + "version": "8.1.0" + }, + "cx_oracle-8.1.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "60c6e439b9740080601b9981e0ea6677", + "name": "cx_oracle", + "sha256": "fdf1279aefac5d4fae68505cd7f5d29b0921742812d2d0b0c165b8c415d22fe0", + "size": 190682, + "subdir": "linux-64", + "timestamp": 1607534456848, + "version": "8.1.0" + }, + "cx_oracle-8.1.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6e772fe0063bc470ff4ed396360b6cfc", + "name": "cx_oracle", + "sha256": "3fa4e9cb4c4b9baaa7814a41e487ba7cedc14f3b4be7d8aae355465efa881e17", + "size": 192987, + "subdir": "linux-64", + "timestamp": 1607534472409, + "version": "8.1.0" + }, + "cx_oracle-8.2.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e99620a1d8b3075e984f526a5be694da", + "name": "cx_oracle", + "sha256": "14892c9677dc67f93153382986dc9020f2181191fd91659f78bb780451221d72", + "size": 193720, + "subdir": "linux-64", + "timestamp": 1621431799230, + "version": "8.2.0" + }, + "cx_oracle-8.2.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aac47c0783786bdc17a13d39fa19ba3e", + "name": "cx_oracle", + "sha256": "47ef63220fe63ca35d984d7d416468759d8bf2a97024619f0dba3ffb7a227f43", + "size": 193062, + "subdir": "linux-64", + "timestamp": 1621431804459, + "version": "8.2.0" + }, + "cx_oracle-8.2.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dc89a868f28e817556a86afbacefd593", + "name": "cx_oracle", + "sha256": "44fcc266875727baeb66bb3c7ba14a27858cbd8b5bf28cf5eafe96a6dd5308fd", + "size": 197750, + "subdir": "linux-64", + "timestamp": 1621431817532, + "version": "8.2.0" + }, + "cx_oracle-8.2.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "51bbd2f465ffb2038fe8b316f75cf582", + "name": "cx_oracle", + "sha256": "475d08bff5c0c5317933b8df26b3122db1f24cb38b961afcc4f1d2af2f0a49c8", + "size": 197027, + "subdir": "linux-64", + "timestamp": 1621431803087, + "version": "8.2.0" + }, + "cx_oracle-8.2.1-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cd9c1bfa717205894f5ae69bccf9250a", + "name": "cx_oracle", + "sha256": "9db90f4aa75773230957f5361aec673f704070a1c5020a6e129a4148e9b63b7c", + "size": 195867, + "subdir": "linux-64", + "timestamp": 1622745366851, + "version": "8.2.1" + }, + "cx_oracle-8.2.1-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6aefae744ce502ee79df7bd82af0763f", + "name": "cx_oracle", + "sha256": "04c18a47125c2a6a3f1b62d19a98b7153f98951f40e7ed7d1231447d89758a42", + "size": 194099, + "subdir": "linux-64", + "timestamp": 1622750649587, + "version": "8.2.1" + }, + "cx_oracle-8.2.1-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a601d3ff2d911b6853b819ac0544d87", + "name": "cx_oracle", + "sha256": "1ca25ef425c18e10b12539db3ec425dc92919111ecda673a4c4fc42719499280", + "size": 197862, + "subdir": "linux-64", + "timestamp": 1622750209571, + "version": "8.2.1" + }, + "cx_oracle-8.2.1-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "55e773aba2ff958eca475bc5d821ada7", + "name": "cx_oracle", + "sha256": "4158186ec9d79e985f509e41e8d71a9f966d9213a96d6f9d3a0e3a5dbd15a240", + "size": 196375, + "subdir": "linux-64", + "timestamp": 1622750668056, + "version": "8.2.1" + }, + "cx_oracle-8.3.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2e2415f0a9143fdf31737304e1cee90b", + "name": "cx_oracle", + "sha256": "dda0b431e5f69a67e0858dc758ecf131174eb548d95c980e930bf30837c11231", + "size": 587891, + "subdir": "linux-64", + "timestamp": 1640789293673, + "version": "8.3.0" + }, + "cx_oracle-8.3.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "443269e8742b9049df58c6c6b46e8dd1", + "name": "cx_oracle", + "sha256": "b06a9fe13fee3955cfc9f4242629428f03408a32581acf717bd2e2aa87448c1a", + "size": 193976, + "subdir": "linux-64", + "timestamp": 1676851825734, + "version": "8.3.0" + }, + "cx_oracle-8.3.0-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "42d9780e5865d14e83e1f5c0915a3442", + "name": "cx_oracle", + "sha256": "12ba9f4ce1fc6f2f7c90dc9a639980c80a92c4e6c832abe2bef460b6722d6f11", + "size": 194940, + "subdir": "linux-64", + "timestamp": 1638439859780, + "version": "8.3.0" + }, + "cx_oracle-8.3.0-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "642932ed0e6c6a0956fb6a9d55802dc2", + "name": "cx_oracle", + "sha256": "505651eb8f443ebbb2570ad1d72dfba316b0338ccc39e1f6480cf5346bf13529", + "size": 196234, + "subdir": "linux-64", + "timestamp": 1638453097779, + "version": "8.3.0" + }, + "cx_oracle-8.3.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b7c1c2821444690b1f9f0583f1f5b9af", + "name": "cx_oracle", + "sha256": "7c93f70f8332c3407544371d253fc65c1c455759b8a7c5f54217c04e81138f2a", + "size": 197761, + "subdir": "linux-64", + "timestamp": 1638452974512, + "version": "8.3.0" + }, + "cycler-0.10.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "8f5ddaff1d567aa535bc1ec683ca80a4", + "name": "cycler", + "sha256": "556f0124b9413ffdc4c533db5bca0442194a2a3fe96a61aa8b6bb11f6245eb34", + "size": 13535, + "subdir": "linux-64", + "timestamp": 1530793306166, + "version": "0.10.0" + }, + "cycler-0.10.0-py27hc7354d3_0.conda": { + "build": "py27hc7354d3_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "cc574ff67c01091c7a97c043c13449ea", + "name": "cycler", + "sha256": "79b65feb171ca436af55409de661fe7354cb7e7819524db1ace9c9238598b3a6", + "size": 13354, + "subdir": "linux-64", + "timestamp": 1505733625213, + "version": "0.10.0" + }, + "cycler-0.10.0-py35hc4d5149_0.conda": { + "build": "py35hc4d5149_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "330171b135d2cf7400ea975d3645d69c", + "name": "cycler", + "sha256": "d5f221439e57b233a7d6aa4b87bb60e0311a8dd46c7911dda9f201b486e3bdb1", + "size": 13658, + "subdir": "linux-64", + "timestamp": 1505733636578, + "version": "0.10.0" + }, + "cycler-0.10.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "94eaa67911c2814b479d5062a5ee3bda", + "name": "cycler", + "sha256": "b1fa9ca9c41f1d0d30a885c5a86bfda387c1e70d0771bd1f74be723239270f5f", + "size": 13621, + "subdir": "linux-64", + "timestamp": 1530793330550, + "version": "0.10.0" + }, + "cycler-0.10.0-py36h93f1223_0.conda": { + "build": "py36h93f1223_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "f70968f5256a9d0084c5e677dad0826c", + "name": "cycler", + "sha256": "4f5f2edb4e645782fc0b9eaf5ce4b94570ee7080bbc52d5b0effee798622229e", + "size": 13395, + "subdir": "linux-64", + "timestamp": 1505733648132, + "version": "0.10.0" + }, + "cycler-0.10.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "48d1b09390e40b3554c5c714a33dd1b5", + "name": "cycler", + "sha256": "a91599dcd9dc2178f91a7e6737a329ea8eb422df9c6ad3cee1463dbd2a6ba621", + "size": 13661, + "subdir": "linux-64", + "timestamp": 1530793355515, + "version": "0.10.0" + }, + "cycler-0.10.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "59bc042b0900f52a43a2a1ca50dfb60a", + "name": "cycler", + "sha256": "064394dc9e0ea308067263f3e7e3a0e51eafc801f6a69b70407fe89943cbcb36", + "size": 14177, + "subdir": "linux-64", + "timestamp": 1573741605355, + "version": "0.10.0" + }, + "cycler-0.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "247ee8cf1fb177b2dde9122ff35a9493", + "name": "cycler", + "sha256": "bdb39791080d482d79e0da8574b5ffa99ecb37cbb6b8c36c9f982f87471930ad", + "size": 16165, + "subdir": "linux-64", + "timestamp": 1607025525121, + "version": "0.10.0" + }, + "cymem-1.31.2-py27h6bb024c_0.conda": { + "build": "py27h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e8ab04e55bfb7f815c44294ac001de7d", + "name": "cymem", + "sha256": "6eeb775913ab1f5962e8a3542d692ab40b604df1ec9f16db319ee2bf28d61bd3", + "size": 26410, + "subdir": "linux-64", + "timestamp": 1530814606969, + "version": "1.31.2" + }, + "cymem-1.31.2-py35h6bb024c_0.conda": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "7e0a9f43e46497103b841a6da1f377be", + "name": "cymem", + "sha256": "1cfac1c9b2b2b1b3de0aa85db50af56ce9d056c6a0072723116a03f6aaaf4375", + "size": 26463, + "subdir": "linux-64", + "timestamp": 1535130360011, + "version": "1.31.2" + }, + "cymem-1.31.2-py36h6bb024c_0.conda": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "897789adb4f7191ea5e90ef319be8f1a", + "name": "cymem", + "sha256": "9baa241a63fd6c12a4c50bb469f47d786d5911bf997ee315a9235551e0ff9d2a", + "size": 26361, + "subdir": "linux-64", + "timestamp": 1530814662317, + "version": "1.31.2" + }, + "cymem-1.31.2-py37h6bb024c_0.conda": { + "build": "py37h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b18908ca040ad374bad1e5e4e4606f50", + "name": "cymem", + "sha256": "e5279416e5f7cc5929c13f4a8359c766526dcbc0ebceffc4edb4e663ef9e9775", + "size": 26375, + "subdir": "linux-64", + "timestamp": 1530814634441, + "version": "1.31.2" + }, + "cymem-2.0.2-py27hfd86e86_0.conda": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "0bedcea105a423da4c8b281ef16abfe6", + "name": "cymem", + "sha256": "418ae1aee9ef1312488bdda016fb0c75eaea4358016bb322e866aa9d89ae9cbd", + "size": 36284, + "subdir": "linux-64", + "timestamp": 1539715086687, + "version": "2.0.2" + }, + "cymem-2.0.2-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "37267d97a134caf264971c2aca904864", + "name": "cymem", + "sha256": "740eb5dfeaab5bfc3b0827af0b2ba9732995bacb743ce498ac84d34c87810483", + "size": 37935, + "subdir": "linux-64", + "timestamp": 1539715088321, + "version": "2.0.2" + }, + "cymem-2.0.2-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b0d1718f90ec00034a423e501d0f3469", + "name": "cymem", + "sha256": "0a2684d56efb71a17a807e870bf4512b5a63f2b211459265bc6b841d928bbf2a", + "size": 38093, + "subdir": "linux-64", + "timestamp": 1539715073686, + "version": "2.0.2" + }, + "cymem-2.0.2-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "e85f0623ea09969df90b70052b375b01", + "name": "cymem", + "sha256": "28b4915cd4202b59d73456c6e5b9f66b6180e5eefe35a94fbb987399de7bb2af", + "size": 45825, + "subdir": "linux-64", + "timestamp": 1573658085965, + "version": "2.0.2" + }, + "cymem-2.0.3-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b897d687711c053939bf54ac3cd1c2c8", + "name": "cymem", + "sha256": "49d5ee3f8bbc6b25710ef74c4583deb1df60f9547ce35ef0f723e0603d6ab1c8", + "size": 40905, + "subdir": "linux-64", + "timestamp": 1592215213715, + "version": "2.0.3" + }, + "cymem-2.0.3-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1e98fe47531fc820f61159ad56290834", + "name": "cymem", + "sha256": "e0a5072a0127d5448a5a077abb2189452f7d68a71751073bcae0d189e14aae26", + "size": 40897, + "subdir": "linux-64", + "timestamp": 1592215219099, + "version": "2.0.3" + }, + "cymem-2.0.3-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "14678bc6f4c130bc8fb2be6c30a6e25d", + "name": "cymem", + "sha256": "dd964439b849cd6c4cb7e10ea30e14405819cefc06bd26af2bead8c432463b49", + "size": 41841, + "subdir": "linux-64", + "timestamp": 1592215218391, + "version": "2.0.3" + }, + "cymem-2.0.4-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ea081e614a8b544be6cc00014637b75d", + "name": "cymem", + "sha256": "9459587702754feed02c168d6c3afbd149dbdbd6563e5457c66f2de14685224b", + "size": 40833, + "subdir": "linux-64", + "timestamp": 1605062316221, + "version": "2.0.4" + }, + "cymem-2.0.4-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "891a44404b5386578876ffe489bfdaac", + "name": "cymem", + "sha256": "ecc19683cdbecb1eab7feae481f7cb8c2d0c00c6b598a261509140b50b584e8c", + "size": 41049, + "subdir": "linux-64", + "timestamp": 1605062306210, + "version": "2.0.4" + }, + "cymem-2.0.4-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "064ae14618fe5fcc6163777fe752f8bf", + "name": "cymem", + "sha256": "5b560772b7ae8df27220d683ac3389a33ba1b1cafe2f710e7fc3425e43d8d2d5", + "size": 41681, + "subdir": "linux-64", + "timestamp": 1605062322984, + "version": "2.0.4" + }, + "cymem-2.0.4-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "2eb7bff7ce671af22bd2ff3ee274e42a", + "name": "cymem", + "sha256": "d477fac906c459eca15e1245ab8d9fe2fa98b8fe3121f835863b2c9b0aa5e08e", + "size": 41477, + "subdir": "linux-64", + "timestamp": 1608232731200, + "version": "2.0.4" + }, + "cymem-2.0.5-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "89315c1ea4d759e85dc26ec34f895f33", + "name": "cymem", + "sha256": "9eacf4e4c9aa087b743de4783d649303b8e2b5b5391df230be7d8e5e10aa0903", + "size": 115584, + "subdir": "linux-64", + "timestamp": 1640789321641, + "version": "2.0.5" + }, + "cymem-2.0.5-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "29e9d1f46dc5473dd57fce0f35293daa", + "name": "cymem", + "sha256": "cac060a81e9963c713517509db64e3c349c0e28d1906b5f1398ffc10edff4198", + "size": 40732, + "subdir": "linux-64", + "timestamp": 1613319308402, + "version": "2.0.5" + }, + "cymem-2.0.5-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ce714ef4447274f79dd31aeb9927d0b3", + "name": "cymem", + "sha256": "343e580f92fdf790867a050257fffcb88014805be6f291f4b223d42e4c7bd98b", + "size": 41305, + "subdir": "linux-64", + "timestamp": 1613319304424, + "version": "2.0.5" + }, + "cymem-2.0.5-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "0d04b0c6140fe5e988e7233754909990", + "name": "cymem", + "sha256": "020a8d7c07ca136f4fb79bc299eab5860bb7a4f3adbbc4974cdc3eb65ca0dc2b", + "size": 41362, + "subdir": "linux-64", + "timestamp": 1613319309884, + "version": "2.0.5" + }, + "cymem-2.0.5-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "cc42ef2052f0867d34b2d8f613cc5ffd", + "name": "cymem", + "sha256": "6fb12e77699410bf95a7e01359714a93c4cb72e287c418d73f94bfcf76a609d4", + "size": 40519, + "subdir": "linux-64", + "timestamp": 1613318777669, + "version": "2.0.5" + }, + "cymem-2.0.6-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e22eb3e64efa5b6bee9b6553e8ea0c7f", + "name": "cymem", + "sha256": "d4cbd5973dd8f761041a2d62a26f3c82241ceea12628fe3201bb4e672a578e2c", + "size": 116280, + "subdir": "linux-64", + "timestamp": 1651237323534, + "version": "2.0.6" + }, + "cymem-2.0.6-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc26e2ec8548e8b2d8bd4b3477396917", + "name": "cymem", + "sha256": "c7a6807bb6afa92dbed036afae25c5e618cd3aeba7b134acadc8c7ab22fc6326", + "size": 39604, + "subdir": "linux-64", + "timestamp": 1676830403508, + "version": "2.0.6" + }, + "cymem-2.0.6-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74349773648730a7af8ac03e70296da8", + "name": "cymem", + "sha256": "118de1978c5a78b59afd440a0d452be640b06fc83f9729fcb42256b81bc19cca", + "size": 41172, + "subdir": "linux-64", + "timestamp": 1651237385544, + "version": "2.0.6" + }, + "cymem-2.0.6-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9819287fab19eb10684dd1a0ac7091c9", + "name": "cymem", + "sha256": "015f0ba7fffc533053f483fe9cc5dd7a65c6a3c8adaa39822c32bd0dfb2d75c8", + "size": 41746, + "subdir": "linux-64", + "timestamp": 1651237354398, + "version": "2.0.6" + }, + "cymem-2.0.6-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7d1564e8f553a0a2919765ff2aa0ea32", + "name": "cymem", + "sha256": "122e8430ddb60c3f50c88c29af78290434d1ff88182c790e517ea6023fbf7e19", + "size": 41000, + "subdir": "linux-64", + "timestamp": 1651237417638, + "version": "2.0.6" + }, + "cyrus-sasl-2.1.26-h1dd3434_1.conda": { + "build": "h1dd3434_1", + "build_number": 1, + "depends": [ + "krb5 1.14.*", + "libgcc-ng >=7.2.0", + "libntlm", + "openssl 1.0.*", + "openssl >=1.0.2l,<1.0.3a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "61eb8d33be7858256d31b766e0421b35", + "name": "cyrus-sasl", + "sha256": "b62de86e186908640312be8179b1e2ff46df6b7bb135aed5a847a4bb6bb60669", + "size": 223944, + "subdir": "linux-64", + "timestamp": 1508757791220, + "version": "2.1.26" + }, + "cyrus-sasl-2.1.26-h20670df_2.conda": { + "build": "h20670df_2", + "build_number": 2, + "depends": [ + "krb5 >=1.16,<1.17.0a0", + "libgcc-ng >=7.2.0", + "libntlm >=1.4,<2.0a0", + "openssl >=1.0.2o,<1.0.3a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "d98d8f95d52b92b67a85266aeae63cbf", + "name": "cyrus-sasl", + "sha256": "4a0e3f8551f5a9b42cb8e4ad53bc344852c8a8453a02473ede9037fb8bee80d4", + "size": 224699, + "subdir": "linux-64", + "timestamp": 1527024230133, + "version": "2.1.26" + }, + "cyrus-sasl-2.1.26-h20670df_3.conda": { + "build": "h20670df_3", + "build_number": 3, + "depends": [ + "krb5 >=1.16,<1.17.0a0", + "libgcc-ng >=7.2.0", + "libntlm >=1.4,<2.0a0", + "openssl >=1.0.2o,<1.0.3a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "1bce277df20966cb2d075ea97e63a1ac", + "name": "cyrus-sasl", + "sha256": "05b48bcbfc291cffe8d90b35a200dc08a8ddb20ef8b3c50968d6203a2b0f073a", + "size": 231425, + "subdir": "linux-64", + "timestamp": 1527080498731, + "version": "2.1.26" + }, + "cyrus-sasl-2.1.26-h82bf5a1_4.conda": { + "build": "h82bf5a1_4", + "build_number": 4, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libdb >=6.1.26,<6.2.0a0", + "libgcc-ng >=7.3.0", + "libntlm >=1.4,<2.0a0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "bf2f1957317867892d54be32010d86a1", + "name": "cyrus-sasl", + "sha256": "e3df96f7e4990468cbe73c80c491e6218a9123c419bb414834cb5f62a4585d5c", + "size": 259556, + "subdir": "linux-64", + "timestamp": 1540928130125, + "version": "2.1.26" + }, + "cyrus-sasl-2.1.26-hf938e8d_3.conda": { + "build": "hf938e8d_3", + "build_number": 3, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libdb >=6.1.26,<6.2.0a0", + "libgcc-ng >=7.3.0", + "libntlm >=1.4,<2.0a0", + "openssl >=1.0.2p,<1.0.3a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "7a5ba0847f7173bcc055aa4767c5d0d9", + "name": "cyrus-sasl", + "sha256": "892343c8f64b683efaa0ec9499ee761985efa942678d33c7b0301118372a8ea5", + "size": 257645, + "subdir": "linux-64", + "timestamp": 1537820851034, + "version": "2.1.26" + }, + "cyrus-sasl-2.1.27-h27ad19a_7.conda": { + "build": "h27ad19a_7", + "build_number": 7, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libdb >=6.1.26,<6.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "1331ac4fd1f9381ceb051611550f4b95", + "name": "cyrus-sasl", + "sha256": "79befe6284808c8c803267771629b2bc60abd991a1456102aef314a4cb08bdb1", + "size": 284501, + "subdir": "linux-64", + "timestamp": 1600980700459, + "version": "2.1.27" + }, + "cyrus-sasl-2.1.27-h758a394_8.conda": { + "build": "h758a394_8", + "build_number": 8, + "depends": [ + "krb5 >=1.19.1,<1.20.0a0", + "libdb >=6.2.32,<6.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "25963bd05c436364a7032c3ab503be60", + "name": "cyrus-sasl", + "sha256": "c3264c0fa1c597ef7a8060ef72fb3d49ef77eac2f361d3dd50523609e198d540", + "size": 281312, + "subdir": "linux-64", + "timestamp": 1622292960748, + "version": "2.1.27" + }, + "cyrus-sasl-2.1.27-h9c0eb46_0.conda": { + "build": "h9c0eb46_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libntlm", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1o,<1.1.2a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "d60f0d38f60ee9fe5d85822dbe432f04", + "name": "cyrus-sasl", + "sha256": "e093240eb56470dce1e58436123b0a9ce0299e44d71b3575db0382378fcfbb0f", + "size": 221726, + "subdir": "linux-64", + "timestamp": 1656338245549, + "version": "2.1.27" + }, + "cyrus-sasl-2.1.27-h9c0eb46_10.conda": { + "build": "h9c0eb46_10", + "build_number": 10, + "depends": [ + "krb5 >=1.19.4,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libntlm >=1.5,<2.0a0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "680e6e6c0eb85782632d9bd8a78f68f0", + "name": "cyrus-sasl", + "sha256": "f9649b248f5cc901e9f5b2a77709065abb7a69f904e175ba48531fb9d6b4f09f", + "size": 238711, + "subdir": "linux-64", + "timestamp": 1678959656304, + "version": "2.1.27" + }, + "cyrus-sasl-2.1.27-h9c0eb46_9.conda": { + "build": "h9c0eb46_9", + "build_number": 9, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libntlm", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1o,<1.1.2a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "1b70ba8f94864dbd0d7318db6de61c1d", + "name": "cyrus-sasl", + "sha256": "d9c9305d01d409b29e3bc657b5ae7436a93d6824f882a07a4ad2af7ad62316ea", + "size": 220528, + "subdir": "linux-64", + "timestamp": 1656338742293, + "version": "2.1.27" + }, + "cyrus-sasl-2.1.27-hf484d3e_7.conda": { + "build": "hf484d3e_7", + "build_number": 7, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libdb >=6.1.26,<6.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a" + ], + "license": "BSD-3-Clause-Attribution", + "license_family": "BSD", + "md5": "df702648f7ab786b7e8fa6ffa9de69c8", + "name": "cyrus-sasl", + "sha256": "3778a145462fa83f8edf64849228bad86f85480f27b721da46723db89fcbc90e", + "size": 283115, + "subdir": "linux-64", + "timestamp": 1600980811007, + "version": "2.1.27" + }, + "cython-0.26.1-py27hdbcff32_0.conda": { + "build": "py27hdbcff32_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "70f7e4ffd8f9ada7dba61b9d2a01bd6f", + "name": "cython", + "sha256": "a20796367bab27232783b11af65bd17ab54e3a371037755cf80e0adfe65075c8", + "size": 2573929, + "subdir": "linux-64", + "timestamp": 1505693241957, + "version": "0.26.1" + }, + "cython-0.26.1-py35h636ebcb_0.conda": { + "build": "py35h636ebcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "9f2c794546c6188654aae138ef4564a3", + "name": "cython", + "sha256": "7fb5c7372cf20e5df90cb96fdf7b39ebbba54cecfc952c6bcbf04733dfd7d19a", + "size": 2723790, + "subdir": "linux-64", + "timestamp": 1505693395206, + "version": "0.26.1" + }, + "cython-0.26.1-py36h21c49d0_0.conda": { + "build": "py36h21c49d0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "d60991a58ae38afe04bff439d45dd674", + "name": "cython", + "sha256": "232dfcaf813d510bad79f156236bb36c070daefadaad1999be035417bb16333f", + "size": 2759144, + "subdir": "linux-64", + "timestamp": 1505693555932, + "version": "0.26.1" + }, + "cython-0.27.3-py27hc56b35e_0.conda": { + "build": "py27hc56b35e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "e5e87b863778398a6dc7a7884d11b606", + "name": "cython", + "sha256": "4e9374310f7a0ce2d44938432c835ffbda764c42bab869d20c218ad8d99d68dc", + "size": 2630337, + "subdir": "linux-64", + "timestamp": 1512030431483, + "version": "0.27.3" + }, + "cython-0.27.3-py35h6cdc64b_0.conda": { + "build": "py35h6cdc64b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "26e079c5fbab2ba825cc4a105342d931", + "name": "cython", + "sha256": "1a9e9b0b57c16a203e2a94f409f4fbd79818cbe137c957393ba56c75fb591420", + "size": 2794699, + "subdir": "linux-64", + "timestamp": 1512030439103, + "version": "0.27.3" + }, + "cython-0.27.3-py36h1860423_0.conda": { + "build": "py36h1860423_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "1fc9bcaec2f4de07092786b916607937", + "name": "cython", + "sha256": "88936fc298e21db09807c09772fae68c3a569bec77cb45312424d69badb7f916", + "size": 2837753, + "subdir": "linux-64", + "timestamp": 1512030347046, + "version": "0.27.3" + }, + "cython-0.28.1-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "59102f66413c0de06452e9c449b295f4", + "name": "cython", + "sha256": "cf62c534978252ec003fc301a676561e780b8a9bcad04bc0b1fa9badfc039545", + "size": 2955593, + "subdir": "linux-64", + "timestamp": 1522180809321, + "version": "0.28.1" + }, + "cython-0.28.1-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "120cff5981b92fa06183860f0f40cb26", + "name": "cython", + "sha256": "6b15600bc9c85741d2a45a16717bdd377eab1e3b7660f1db1f0947e9ceb07725", + "size": 2997918, + "subdir": "linux-64", + "timestamp": 1522180812803, + "version": "0.28.1" + }, + "cython-0.28.1-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "6b58a4d3b382d09f8c242e9facef9a13", + "name": "cython", + "sha256": "40340c06e00b9bee0ca19b4eb0634e907705c13e6d610baabc8c3a95824f75e6", + "size": 3031575, + "subdir": "linux-64", + "timestamp": 1522180389408, + "version": "0.28.1" + }, + "cython-0.28.2-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "26aa1437eecc255caa52c6a215579e8b", + "name": "cython", + "sha256": "2df83fabcae9bff9af266b82a89ab79197f6ec33ba7db84eb308a755e0ec59f8", + "size": 2961602, + "subdir": "linux-64", + "timestamp": 1523905135177, + "version": "0.28.2" + }, + "cython-0.28.2-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "770ca865dcdea89ef9b704cee74bd3a2", + "name": "cython", + "sha256": "648dab1552406b224c50ab8616bc0347b9e41913702faabc57b6de972d2fe26c", + "size": 2994456, + "subdir": "linux-64", + "timestamp": 1523905075381, + "version": "0.28.2" + }, + "cython-0.28.2-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "676c119f9971706a92238dca9d5b2891", + "name": "cython", + "sha256": "446761fc7286919780eef9702a1d374fc01eec4ffd8a65ecdcc9fbdde96929a1", + "size": 3032769, + "subdir": "linux-64", + "timestamp": 1523905143096, + "version": "0.28.2" + }, + "cython-0.28.3-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "515f6ee1cc4d93ed7290c7fa7e940fcb", + "name": "cython", + "sha256": "268addec60728aef782e684453dcee817ff5e2038f3940529f1a28d8781becf0", + "size": 2958055, + "subdir": "linux-64", + "timestamp": 1527796675856, + "version": "0.28.3" + }, + "cython-0.28.3-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "ca8badd60a1d8cee1d37944b02ef1d55", + "name": "cython", + "sha256": "b8828fea1b777a9b3e85b48e36e197ef08e3d6cdc0625f6501975d28d8aea4a5", + "size": 2996342, + "subdir": "linux-64", + "timestamp": 1527796935917, + "version": "0.28.3" + }, + "cython-0.28.3-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "10b5c0295b5b713539bc1b56e20f44d2", + "name": "cython", + "sha256": "f5847a13bdd79f4c0261d8bdd991866d4ee981b0d76bf3eebe982d1004fca947", + "size": 3040539, + "subdir": "linux-64", + "timestamp": 1527796656827, + "version": "0.28.3" + }, + "cython-0.28.3-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "3fcb6f7681387ed656ceae5a672f0e31", + "name": "cython", + "sha256": "cb1e248ab63b3effae21cf398ea121e695cbbecdddcfbf22f3c41fbe4d84de95", + "size": 3033295, + "subdir": "linux-64", + "timestamp": 1530695822561, + "version": "0.28.3" + }, + "cython-0.28.4-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "8fda5b7906a0c0fd92f81895fd7e64ac", + "name": "cython", + "sha256": "8d198334803ca5669456be6b365c4b08170a7a44e487181fc9ec765d50214846", + "size": 2962328, + "subdir": "linux-64", + "timestamp": 1532449675881, + "version": "0.28.4" + }, + "cython-0.28.4-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "ad68cb8ae64524a5b283a5e813fdf69e", + "name": "cython", + "sha256": "2d7b42e1b23f4da6c058899fc502cbb5b523662a07c6f22f136907a237ba183c", + "size": 3002019, + "subdir": "linux-64", + "timestamp": 1532449052512, + "version": "0.28.4" + }, + "cython-0.28.4-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "85f6f00dca62813a701ebcbea5b4c4aa", + "name": "cython", + "sha256": "e7fb9858c7a480153959d3597a05b81d1235ca85602630c1a04b9d57694fb1a9", + "size": 3041790, + "subdir": "linux-64", + "timestamp": 1532449666421, + "version": "0.28.4" + }, + "cython-0.28.4-py37hf484d3e_0.conda": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "0538967d2be1da4ca4176261f6c25605", + "name": "cython", + "sha256": "4cdc511cd585b97f2b40b9cd6f675c8afc1a03b0909c5ae4a62a4ad825c55a19", + "size": 3035596, + "subdir": "linux-64", + "timestamp": 1532449719161, + "version": "0.28.4" + }, + "cython-0.28.4-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "1dede049608774471bcf261a57014deb", + "name": "cython", + "sha256": "b5f63d335b34b231d7b43b183d2766155e51aacb56c4072446940544ec6b210f", + "size": 3177787, + "subdir": "linux-64", + "timestamp": 1572860692437, + "version": "0.28.4" + }, + "cython-0.28.5-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "e04dd0fb09306d76675d0ea564398f48", + "name": "cython", + "sha256": "692f3239d39094aa74ed8deda7586698dc5305caa90aeb7f74aaba2b2bbbb883", + "size": 2948218, + "subdir": "linux-64", + "timestamp": 1533739421124, + "version": "0.28.5" + }, + "cython-0.28.5-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "f0e49edae684ca7cc6cce12e04b27ac1", + "name": "cython", + "sha256": "99be62c80f0febf68a21bdd007f06aa67c9440a16190fc59d35820e477116513", + "size": 2986954, + "subdir": "linux-64", + "timestamp": 1533739693481, + "version": "0.28.5" + }, + "cython-0.28.5-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "21a7da1958b7ea0f1eca9a64fe7ff63a", + "name": "cython", + "sha256": "6f2dba796c5dc9622e463a67671c6aa35e1572db00fdffe2548cf020b162bfa9", + "size": 3028413, + "subdir": "linux-64", + "timestamp": 1533739634381, + "version": "0.28.5" + }, + "cython-0.28.5-py37hf484d3e_0.conda": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "9c4128512959220eb450a0bc49976f0e", + "name": "cython", + "sha256": "143b33ddc179cc5e0bb53c15f7ea9fec0a1128c46b3a0d8fddaf3e6b24ef27cb", + "size": 3018926, + "subdir": "linux-64", + "timestamp": 1533739697742, + "version": "0.28.5" + }, + "cython-0.29-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "531cc3a1024dc97785ca53623d2e21a6", + "name": "cython", + "sha256": "2b479118348d38a59bb740ca05e757240b679c3fe711d6a6e013037bf5cd5260", + "size": 2063809, + "subdir": "linux-64", + "timestamp": 1539636488894, + "version": "0.29" + }, + "cython-0.29-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "c9c4d8929c2640eccd6dc9ffb432a5e3", + "name": "cython", + "sha256": "1540a2c305c29e8edacdb2bed0b3c9a555c3c47af20a4231c40d51017a28b81c", + "size": 2113990, + "subdir": "linux-64", + "timestamp": 1539636482516, + "version": "0.29" + }, + "cython-0.29-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "14c5ab58dfec986bf8dad4f1c89ff152", + "name": "cython", + "sha256": "9c91f913cf2ae84498bc4c620f49912ca8e0ea2e537d297c134a597361990004", + "size": 2107522, + "subdir": "linux-64", + "timestamp": 1539636510341, + "version": "0.29" + }, + "cython-0.29.10-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "00ef82c7bfeccdbf1da21afe1f8d2d9c", + "name": "cython", + "sha256": "354816db7e701e5bfe08f7b43e8ab5d3296d23924a8c55623a9e9708c7dc31f3", + "size": 2075302, + "subdir": "linux-64", + "timestamp": 1559769854847, + "version": "0.29.10" + }, + "cython-0.29.10-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "613718d31da9bc8cfdf8a6e2b13a4643", + "name": "cython", + "sha256": "c5c0795dfeddbc711d890c4c1f0cf80fe8cc92da3afc98a30bbf223142cebd89", + "size": 2107161, + "subdir": "linux-64", + "timestamp": 1559769838362, + "version": "0.29.10" + }, + "cython-0.29.10-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "7a25ffa680c6d7d3a369f5f022cfbdaf", + "name": "cython", + "sha256": "356718a93f403d26dc44a75d2615af814c564111784d2d79d2dd31379694f36c", + "size": 2114325, + "subdir": "linux-64", + "timestamp": 1559770164793, + "version": "0.29.10" + }, + "cython-0.29.11-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "40914161f4c01a26a9eb0c29468d89ec", + "name": "cython", + "sha256": "2f6f2d2f239b4457e96c0a8e1377606a1837ee14d2542264136926f453c7ef29", + "size": 2070247, + "subdir": "linux-64", + "timestamp": 1562081886543, + "version": "0.29.11" + }, + "cython-0.29.11-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "43602ae66a3118db9ad89fa7f23c067d", + "name": "cython", + "sha256": "dd8fa2ef9648fe7043b19fccf4b1cf93741b23bebf4007daefadb168cce76233", + "size": 2111581, + "subdir": "linux-64", + "timestamp": 1562081888649, + "version": "0.29.11" + }, + "cython-0.29.11-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "a908fd030b2def2fa382f45687115bb1", + "name": "cython", + "sha256": "c1fbd38423679a05ed23d6a51c9053e795a64dcf861a4c68d9273c8905435f0e", + "size": 2107598, + "subdir": "linux-64", + "timestamp": 1562081960676, + "version": "0.29.11" + }, + "cython-0.29.12-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "3f7f74a9c10c0b5fc7fd4f3e283f1568", + "name": "cython", + "sha256": "5aca7a6bb86c7481e7492530422232b45ffd21ea27e38ed9bcfcdd452e0a4b27", + "size": 2081590, + "subdir": "linux-64", + "timestamp": 1563207240847, + "version": "0.29.12" + }, + "cython-0.29.12-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "1e06bd5b7877a82dbfa92f4564916978", + "name": "cython", + "sha256": "f2572db0ca80929a530509e4aa17654ea9c2599c54bd571e1936f7c17dbdafb1", + "size": 2133226, + "subdir": "linux-64", + "timestamp": 1563207263781, + "version": "0.29.12" + }, + "cython-0.29.12-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "ffa77d87d2bb3b18fd718f40a5897414", + "name": "cython", + "sha256": "e0322689a09e6dae2e92bd17ad4ebd76aa493215034d7f32238d4af6cd854de7", + "size": 2126618, + "subdir": "linux-64", + "timestamp": 1563207245706, + "version": "0.29.12" + }, + "cython-0.29.13-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "6645e54327a0389523cfd285d73222d0", + "name": "cython", + "sha256": "da4ffb5a052c1042876dbd46626328e28945b634cd4535d1545fcd77e8bcd25a", + "size": 2085430, + "subdir": "linux-64", + "timestamp": 1565959775345, + "version": "0.29.13" + }, + "cython-0.29.13-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "9bee92e22cb5df67d6a3062b1a7de719", + "name": "cython", + "sha256": "3f92d6dd8293ab8a2df903611a85ab49a27763cfe8a08a4d4a4bc9a449692f10", + "size": 2130063, + "subdir": "linux-64", + "timestamp": 1565959656768, + "version": "0.29.13" + }, + "cython-0.29.13-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "b1636b6a94d346517272c9223371ae8f", + "name": "cython", + "sha256": "9c23df6c61a5c5e57654ba5315446b5a92486a5ac40a30c20a2cdf1492a81056", + "size": 2124668, + "subdir": "linux-64", + "timestamp": 1565959875992, + "version": "0.29.13" + }, + "cython-0.29.13-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "e513847cd9af73ac6415695ad56fbf1c", + "name": "cython", + "sha256": "358a4281e74d5df5f1a288b5d92d50bad39595dac132dd1eb2290d9bd0ceb9db", + "size": 2186677, + "subdir": "linux-64", + "timestamp": 1572437128292, + "version": "0.29.13" + }, + "cython-0.29.14-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "436a099152664ffaa3366cc85632e9ca", + "name": "cython", + "sha256": "72cf3063919f18a14393ac1f6c8987764da6f56554528ba744eff7929e71cbae", + "size": 2085747, + "subdir": "linux-64", + "timestamp": 1574271369331, + "version": "0.29.14" + }, + "cython-0.29.14-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "345e2da95d0f610296c08715b7bf7d56", + "name": "cython", + "sha256": "f80b765b0aac409de437255be03a9ed0ba9d9edd9b1da4148a42b75fd7c63c41", + "size": 2127796, + "subdir": "linux-64", + "timestamp": 1574271377336, + "version": "0.29.14" + }, + "cython-0.29.14-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "ee5228869a8a308e159c0cbe6bd7a92e", + "name": "cython", + "sha256": "7cc2b5d1b51f8e12f4d9d46a7f53d2b709006367718a930dfaa7f9ff8ee7b474", + "size": 2123661, + "subdir": "linux-64", + "timestamp": 1574271241757, + "version": "0.29.14" + }, + "cython-0.29.14-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "f03b5492fe4eb7e08ff01d8a3dff71cd", + "name": "cython", + "sha256": "206ff28636252b37bb8d2f4e7b7ace66cb3acefc3a566ab4620a778ef37dd2f5", + "size": 2195500, + "subdir": "linux-64", + "timestamp": 1574271357426, + "version": "0.29.14" + }, + "cython-0.29.15-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "2877e2cb3f4967ff50c8e689599ca3d6", + "name": "cython", + "sha256": "096d92c423b22c4fdaecd0a2939cd0ab48b3d2433ecd8a2cf5f05bbd1612841b", + "size": 2118347, + "subdir": "linux-64", + "timestamp": 1581353624198, + "version": "0.29.15" + }, + "cython-0.29.15-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "eae6b8989537fe99df397526328afa6c", + "name": "cython", + "sha256": "75e1fc06efd5c67f1ec00f6b8dc6ee67a63585350be1b14b4dea3179bfe56d41", + "size": 2116655, + "subdir": "linux-64", + "timestamp": 1581353554962, + "version": "0.29.15" + }, + "cython-0.29.15-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "efee43036f5d749b6d0d22fc6402e218", + "name": "cython", + "sha256": "03bcc511fe8e12b8f781636576d4a844664ed7ae4ffc8568d15fa118ddaf468c", + "size": 2183278, + "subdir": "linux-64", + "timestamp": 1581353520151, + "version": "0.29.15" + }, + "cython-0.29.17-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "877d3bca3d82fefcbf7d7bc0ce7dabc6", + "name": "cython", + "sha256": "ca11cf4c0d9cfdfca3b274f995d944b0bde3b0dd31bccfdb77f706de3447a197", + "size": 2118559, + "subdir": "linux-64", + "timestamp": 1588172834210, + "version": "0.29.17" + }, + "cython-0.29.17-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "a8763b4fa260a7efa12846d2c36bd70d", + "name": "cython", + "sha256": "e7d9fbd635fb5b0197ed52477967f357370b0fa6c9b8cef806e4dbeda2f485e7", + "size": 2111410, + "subdir": "linux-64", + "timestamp": 1588172822397, + "version": "0.29.17" + }, + "cython-0.29.17-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "98f26cd4504c7cf558fd08e4727ce1a7", + "name": "cython", + "sha256": "c33eccb169af3c9f065030e0435c98f1e19ff7f367b6eb37b0e94d67e0aab17c", + "size": 2188541, + "subdir": "linux-64", + "timestamp": 1588172811523, + "version": "0.29.17" + }, + "cython-0.29.2-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "5e6ea27bc5f0f0afd09f252309837e50", + "name": "cython", + "sha256": "e2b56717b67fad620f4264448711f5d33a5f9c27f03d466d9ba6ede72c239131", + "size": 2070689, + "subdir": "linux-64", + "timestamp": 1545074265535, + "version": "0.29.2" + }, + "cython-0.29.2-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "ca8c223150d71cfd5cdb666a633af9b6", + "name": "cython", + "sha256": "1d66c60d2bde1c4b2eb84f0d0442b15617d6d7a81c34c9285c7fe7c2e255e7df", + "size": 2113062, + "subdir": "linux-64", + "timestamp": 1545074326716, + "version": "0.29.2" + }, + "cython-0.29.2-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "ab888ef041211ec560dfddcd02501648", + "name": "cython", + "sha256": "fc4dcc55ddf75bcbaed7c587f3deb9590c0a03f58e81e4ad45f954b0d4c20d2e", + "size": 2110688, + "subdir": "linux-64", + "timestamp": 1545074322215, + "version": "0.29.2" + }, + "cython-0.29.20-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "9438d94b8c5b687db6d2c3438d736e3d", + "name": "cython", + "sha256": "07249b84458e835ea07ae3bf11cd81ba1d13c95580d49df42a151866db640375", + "size": 2011757, + "subdir": "linux-64", + "timestamp": 1592330450476, + "version": "0.29.20" + }, + "cython-0.29.20-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "4ddce7d8c384d1397ccf0e995fbdff18", + "name": "cython", + "sha256": "d62b1c0d87b6c638f15a4958cd944e834769f0027a6c2f9a0299d611354928c5", + "size": 2004244, + "subdir": "linux-64", + "timestamp": 1592330439562, + "version": "0.29.20" + }, + "cython-0.29.20-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "5f3ce6411836fb7e3c1476f4e88700eb", + "name": "cython", + "sha256": "9bc7b512d3d8953bed198843009ec9f861d6dfe1134f63a8939384fc825d2304", + "size": 2070454, + "subdir": "linux-64", + "timestamp": 1592330446320, + "version": "0.29.20" + }, + "cython-0.29.21-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "c1cb48a2ab25a296120efb47dd05f332", + "name": "cython", + "sha256": "35de592cda52fc3c1171ca9a38cc825f89f0edda8ce886b00cb0fc5a113c24c0", + "size": 2021853, + "subdir": "linux-64", + "timestamp": 1605457745540, + "version": "0.29.21" + }, + "cython-0.29.21-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "ee7d8fd2d0691a89d5309a9d3e39b4c8", + "name": "cython", + "sha256": "6855d8d97d946701b6bf79bba7f077d652a922fdb47f88294fc064d2c97f7d33", + "size": 2015354, + "subdir": "linux-64", + "timestamp": 1594831673199, + "version": "0.29.21" + }, + "cython-0.29.21-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "7f9cc6ca7e606302eda8d41c7e31132b", + "name": "cython", + "sha256": "a58d77460615fde5a81d32fb6e9eefa6d7f624148543caaef54c1c68b385efd9", + "size": 2006022, + "subdir": "linux-64", + "timestamp": 1605457709717, + "version": "0.29.21" + }, + "cython-0.29.21-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "1547ab42ee874889ca67453bc36b50fa", + "name": "cython", + "sha256": "e671a7838f301a7ba7afa57f38f227205a690a1cc3b173ce69dd9a5e87cfcb1e", + "size": 2006435, + "subdir": "linux-64", + "timestamp": 1594831669266, + "version": "0.29.21" + }, + "cython-0.29.21-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "e4d8e48e58661ff54122725bba625527", + "name": "cython", + "sha256": "9e9aff1fd020659b2a36f059f0a124d2bfbe54df2d6ec4b44d8638caa7c10d0a", + "size": 2078690, + "subdir": "linux-64", + "timestamp": 1605457745356, + "version": "0.29.21" + }, + "cython-0.29.21-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "99e101789f4567d9cc484638dca1151d", + "name": "cython", + "sha256": "6b85740405ecaa312318f51f5ca9b0025c6d87cee6ec14c619f26170b3317fe9", + "size": 2081009, + "subdir": "linux-64", + "timestamp": 1594831669553, + "version": "0.29.21" + }, + "cython-0.29.21-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "0f27a1703a8e8253ddc16dfabccfe213", + "name": "cython", + "sha256": "bd91e1f14db3bd9e2f8126475edd86919bc8f2cd5ae8aab45dec479ec9cb9792", + "size": 2075354, + "subdir": "linux-64", + "timestamp": 1605457745033, + "version": "0.29.21" + }, + "cython-0.29.22-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "533cb42213d25e61cc6cfa8a3069cb9e", + "name": "cython", + "sha256": "80e49aba90dc161f01a6983a83ccd5b6e66ae5c662a214fff068f4c9fb265fd3", + "size": 2017976, + "subdir": "linux-64", + "timestamp": 1614014950713, + "version": "0.29.22" + }, + "cython-0.29.22-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "d90e3dbbcaca891f1431506f17e1a2ad", + "name": "cython", + "sha256": "60ec2ca3f9828d6f6bc26b08cecf4cbb5702cbce0205362a5a943f118999e474", + "size": 2018462, + "subdir": "linux-64", + "timestamp": 1614014950618, + "version": "0.29.22" + }, + "cython-0.29.22-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "121e559596f58885fd39d5aefa28f596", + "name": "cython", + "sha256": "6d245eaea218df7834cd17dcd904ac3b4ce6112529189dba675db82a397ffca6", + "size": 2073962, + "subdir": "linux-64", + "timestamp": 1614014948272, + "version": "0.29.22" + }, + "cython-0.29.22-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "0f3c143d50dabf118e1d625f32f9eb72", + "name": "cython", + "sha256": "be00e48573031e0c1df2487f41bdefbea4dcfed01c9ca292b65a010c679fe8e4", + "size": 2067324, + "subdir": "linux-64", + "timestamp": 1614014431627, + "version": "0.29.22" + }, + "cython-0.29.23-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "ab8c443e9e99cf2b481326e65f3e86f7", + "name": "cython", + "sha256": "c6526d9381fd728a703b57f704a3c57061c880c4a107212f4e15e6758df89d0c", + "size": 2011355, + "subdir": "linux-64", + "timestamp": 1618435280709, + "version": "0.29.23" + }, + "cython-0.29.23-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "051a98ec90439f35b4d6d3adbedb0938", + "name": "cython", + "sha256": "e5cb5a74a9bedbd84fcc4049336d4bc2fa3ef2dbd505c0f731ced2c1f2e39e44", + "size": 2013158, + "subdir": "linux-64", + "timestamp": 1618432151539, + "version": "0.29.23" + }, + "cython-0.29.23-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "29e14be4ac238b882e1b29fe75e406dc", + "name": "cython", + "sha256": "bba6ff59dc115fd200cd932f62a86055f822ad9a9360f4b93c74ebbbfdccebf0", + "size": 2068432, + "subdir": "linux-64", + "timestamp": 1618435275487, + "version": "0.29.23" + }, + "cython-0.29.23-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "50edf31b2c1c3f1087fe3046708ae466", + "name": "cython", + "sha256": "879f50774f699ccd117f90c744f0b7e8a8eeac60da9de5e78b62e98293911bab", + "size": 2075194, + "subdir": "linux-64", + "timestamp": 1618435265950, + "version": "0.29.23" + }, + "cython-0.29.24-py36h295c915_0.conda": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "400271a0ceeb375a58e25d4752e5f4a8", + "name": "cython", + "sha256": "b46144e2f7e461dfaf501555e3a2f48367447c5ff3b86d5ce1dccb9860d4abb7", + "size": 2009167, + "subdir": "linux-64", + "timestamp": 1626256722260, + "version": "0.29.24" + }, + "cython-0.29.24-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "69eb28c0342ccb4f2e92d5be35d06a5b", + "name": "cython", + "sha256": "c51bbc4c82f761aa2cbe9e9ad503c9fc387d74125fd89ac3d2cd2b7fbaaa3791", + "size": 2006585, + "subdir": "linux-64", + "timestamp": 1626250003391, + "version": "0.29.24" + }, + "cython-0.29.24-py37hdbfa776_0.conda": { + "build": "py37hdbfa776_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5d4a34291b36a03b9bfb0876c1b96ec9", + "name": "cython", + "sha256": "c6ba54f3bab798c96de64080bdf8faa9789ad4d2da2de309100a49cc1e9196c0", + "size": 2011867, + "subdir": "linux-64", + "timestamp": 1636023897717, + "version": "0.29.24" + }, + "cython-0.29.24-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "31e5a77c18e00a77a627da78c4ee6bf1", + "name": "cython", + "sha256": "e31d56c5395af001945ca5624cd2a5d7cc69aad58405f7da92b11051cac8dc6c", + "size": 2068613, + "subdir": "linux-64", + "timestamp": 1626257062703, + "version": "0.29.24" + }, + "cython-0.29.24-py38hdbfa776_0.conda": { + "build": "py38hdbfa776_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "392466afc0714547177a89a800a7045f", + "name": "cython", + "sha256": "472ca6ab718fce5c23f0ed889f9eff54e58ce3662b4f9b3d7be271211729fdb5", + "size": 2085951, + "subdir": "linux-64", + "timestamp": 1636035886270, + "version": "0.29.24" + }, + "cython-0.29.24-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e8356f29eea09f4b8568a6876cfed720", + "name": "cython", + "sha256": "786a90ffdb8e8c6b4311a7f5778a80e0a8c2a87bfa96803845974accd5cd50e8", + "size": 2077567, + "subdir": "linux-64", + "timestamp": 1626257080163, + "version": "0.29.24" + }, + "cython-0.29.24-py39hdbfa776_0.conda": { + "build": "py39hdbfa776_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8802b35c59a5d2a783648dfc347068b4", + "name": "cython", + "sha256": "8d436cc1bb1fe62280d17a48e7c79aab89da58a16d0677901e0d34ea91a60b34", + "size": 2086881, + "subdir": "linux-64", + "timestamp": 1636035258270, + "version": "0.29.24" + }, + "cython-0.29.25-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "47764993920642d8858a3aa8b0f259c1", + "name": "cython", + "sha256": "5558f2e41898156408e516f00441827b88efc2e3c221200fd9631ec57aabd04b", + "size": 4160229, + "subdir": "linux-64", + "timestamp": 1640004554193, + "version": "0.29.25" + }, + "cython-0.29.25-py310hdbfa776_0.conda": { + "build": "py310hdbfa776_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "7e0cd8f56601052e748397c8456bba76", + "name": "cython", + "sha256": "e84fefb6b2bf87638c3d7a33606b22e787bc319bf5fb483d86af9ee60acd963a", + "size": 4159096, + "subdir": "linux-64", + "timestamp": 1639474695333, + "version": "0.29.25" + }, + "cython-0.29.25-py37hdbfa776_0.conda": { + "build": "py37hdbfa776_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "aeaa93a2640ffb60172ac426187d873e", + "name": "cython", + "sha256": "b6b0bfec8a9e6e01f45927ed8d7e051c403ffd5e7a92a1268b637e29f9f94a85", + "size": 2020079, + "subdir": "linux-64", + "timestamp": 1639474670346, + "version": "0.29.25" + }, + "cython-0.29.25-py38hdbfa776_0.conda": { + "build": "py38hdbfa776_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "7f02bce110a03fe1f5c82cefd0b4c716", + "name": "cython", + "sha256": "ac20a3342f7c08303573b3f266fc532d20ce03846f477e99d209092136578fa5", + "size": 2075929, + "subdir": "linux-64", + "timestamp": 1639474670220, + "version": "0.29.25" + }, + "cython-0.29.25-py39hdbfa776_0.conda": { + "build": "py39hdbfa776_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "38b5eacef0182dce6e455e41134b2d63", + "name": "cython", + "sha256": "c11953984590441e04a70bc2d8ff6dc15a01d08a936778dd952208974c0d59e4", + "size": 2086293, + "subdir": "linux-64", + "timestamp": 1639456553547, + "version": "0.29.25" + }, + "cython-0.29.28-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3b1b8834ef78e60bac6bce26e404aa86", + "name": "cython", + "sha256": "fa866f9922c37dabe21898e490ce2278e3e4b96220fe94d0e44e9dfe070e593e", + "size": 4168602, + "subdir": "linux-64", + "timestamp": 1647832335641, + "version": "0.29.28" + }, + "cython-0.29.28-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "305c8d12e543a778ee1808f04ad1cf14", + "name": "cython", + "sha256": "52b2dfc53ac09525a279f01cd19cb9a01c660746df162d6a8b59e3315869118c", + "size": 2028357, + "subdir": "linux-64", + "timestamp": 1647850444065, + "version": "0.29.28" + }, + "cython-0.29.28-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5c546bcf04d20b8291d5794227de04fa", + "name": "cython", + "sha256": "d924ccd78833800e617bf474c4da9d7d3f9b455160269daa6ffa5e908d033091", + "size": 2086713, + "subdir": "linux-64", + "timestamp": 1647832571349, + "version": "0.29.28" + }, + "cython-0.29.28-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aad335458a7478211a4fda4590cfdb5f", + "name": "cython", + "sha256": "4212a72bfab0564afc1262ab6c3a916a98641cc0b0adde511a4649850570c0e4", + "size": 2077246, + "subdir": "linux-64", + "timestamp": 1647850444141, + "version": "0.29.28" + }, + "cython-0.29.30-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bb3460bbf426b544d1e4390a284472a4", + "name": "cython", + "sha256": "7c90879eb549bd062895a2b3f817ad61ee59b4780756f2096e9fa3ce18ccf3f6", + "size": 4487960, + "subdir": "linux-64", + "timestamp": 1656942152977, + "version": "0.29.30" + }, + "cython-0.29.30-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eabeecc4bf95685139a7b2ed9b52fe1e", + "name": "cython", + "sha256": "58ca3d758ef175063992b47453ca4fc787491174dbc9524c1a5dccbdf709b022", + "size": 2018732, + "subdir": "linux-64", + "timestamp": 1656942326989, + "version": "0.29.30" + }, + "cython-0.29.30-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "46c524f271afb80dfa5ef984e72c6ff4", + "name": "cython", + "sha256": "e132d9fe0275d08f9bab6a8ed7acad9db355bd44b472830b30497cf3fd455285", + "size": 2078941, + "subdir": "linux-64", + "timestamp": 1656942238380, + "version": "0.29.30" + }, + "cython-0.29.30-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f9d8082e2518d1b5870d275e68a9025c", + "name": "cython", + "sha256": "4068e9302f298b9288a4705819971aec063c4b48cb9cbd8bb5657de234a280cd", + "size": 2047224, + "subdir": "linux-64", + "timestamp": 1656942050866, + "version": "0.29.30" + }, + "cython-0.29.32-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "317574a4ade021d7d01701ba81ba27a6", + "name": "cython", + "sha256": "59291dc15f87cccacc5bb42ef3e30b2e5b2c63e34d04e238a796620b8c1e9bc7", + "size": 4487656, + "subdir": "linux-64", + "timestamp": 1663693020183, + "version": "0.29.32" + }, + "cython-0.29.32-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "01336e6822034ba73bcd0edd7b447e24", + "name": "cython", + "sha256": "66d7fceadf4431e3497845bbba2b8bf18797a9c4e63f62217b161c76e706772b", + "size": 2471979, + "subdir": "linux-64", + "timestamp": 1676904355646, + "version": "0.29.32" + }, + "cython-0.29.32-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "86d95102408316767641a58df25cfeee", + "name": "cython", + "sha256": "aa9ceb0e55431d0c7eaf9e6e4173ba0d68e158d79e8ffefa02748b82b6833041", + "size": 2019396, + "subdir": "linux-64", + "timestamp": 1663693096269, + "version": "0.29.32" + }, + "cython-0.29.32-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "81e586e2923e84782265d5e34b2c7189", + "name": "cython", + "sha256": "53dcb72e9b9f572f8a19e9eac80bb1ed0c19a672d123f9aa642691d758622351", + "size": 2077665, + "subdir": "linux-64", + "timestamp": 1663692929100, + "version": "0.29.32" + }, + "cython-0.29.32-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f7a9c5717a0233c34891a0e3265cbb19", + "name": "cython", + "sha256": "385806042545c5b3d6ef90e207c4f7279337cba5dc5c031116826ec0a8c1b135", + "size": 2047014, + "subdir": "linux-64", + "timestamp": 1663692857742, + "version": "0.29.32" + }, + "cython-0.29.33-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "585f7898beffd0631ef4b277163111d9", + "name": "cython", + "sha256": "cf8db54f10339235b12ed7bc9de36756836f72a12c494004ddc15b6b45c0b281", + "size": 2244911, + "subdir": "linux-64", + "timestamp": 1676568322193, + "version": "0.29.33" + }, + "cython-0.29.33-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b53919798c7dde817d084a5c236811c6", + "name": "cython", + "sha256": "fb5574ad50c5b7d7728e30624eeec240c8f77af6cee470ac7955f92a754c758f", + "size": 2472865, + "subdir": "linux-64", + "timestamp": 1676822959420, + "version": "0.29.33" + }, + "cython-0.29.33-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6eaecaad108acddfa88b9406ed96ad8a", + "name": "cython", + "sha256": "4dedb6c4f5d73d0797281bd02803a14144032b5d0460a9352b5466848d87bf55", + "size": 2215348, + "subdir": "linux-64", + "timestamp": 1676568110775, + "version": "0.29.33" + }, + "cython-0.29.33-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eb105388ba8bcf5ce82cf4cd5deeb5f9", + "name": "cython", + "sha256": "28ca987afca5f7d56ded901778659e1b4476ae3d5d6e82244a9ec98a50033305", + "size": 2286266, + "subdir": "linux-64", + "timestamp": 1676568253077, + "version": "0.29.33" + }, + "cython-0.29.33-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "95eb1c0bbb563cf6238978ffc1c01d90", + "name": "cython", + "sha256": "d36f748a0cd765c65ca0e76232f7da713e5b5cef138146d6b443d60dc4b705fb", + "size": 2248779, + "subdir": "linux-64", + "timestamp": 1676568180444, + "version": "0.29.33" + }, + "cython-0.29.4-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "2b91415565fff9d9e1a229070e319b8c", + "name": "cython", + "sha256": "21df036f462c3545c0e3af24186c35c2e7582398d33f5c0f94e02a8bc8193316", + "size": 2070881, + "subdir": "linux-64", + "timestamp": 1549325636863, + "version": "0.29.4" + }, + "cython-0.29.4-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "bcf7c84bf01b5e4e98499450306a6213", + "name": "cython", + "sha256": "8960f59f81d8d5f4e19e196b1cf55c3b1d4448296d493dab662816707d1af283", + "size": 2105520, + "subdir": "linux-64", + "timestamp": 1549325608965, + "version": "0.29.4" + }, + "cython-0.29.4-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "b27b6f8de72568d6520faa57a7ac0cd3", + "name": "cython", + "sha256": "8e99df62bfa6478204354d77f57e08313bce54c0f3c7e9a5623ce17b14d5c4ae", + "size": 2109516, + "subdir": "linux-64", + "timestamp": 1549325564532, + "version": "0.29.4" + }, + "cython-0.29.5-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "15f9929e9b7deff8abf669a6a9772f97", + "name": "cython", + "sha256": "c3615122e2e86cafaa7adcb7a96b548853a99d7c47fa829895274adf5cc52c98", + "size": 2076010, + "subdir": "linux-64", + "timestamp": 1550268010041, + "version": "0.29.5" + }, + "cython-0.29.5-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "05f4f954aeb2c97f934ff8710f17bd2f", + "name": "cython", + "sha256": "0a9e1c333903445b916398522ae84c9b7b6bc61fd960dd5324f4ecb050a38e8a", + "size": 2119365, + "subdir": "linux-64", + "timestamp": 1550268079570, + "version": "0.29.5" + }, + "cython-0.29.5-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "a52fa708ecd476b5313e22d48c8f2c84", + "name": "cython", + "sha256": "6d41eb1053820d1cd823304c4befde18bf4212e55afe0dd560fbeb6ee4965cb6", + "size": 2116351, + "subdir": "linux-64", + "timestamp": 1550268026025, + "version": "0.29.5" + }, + "cython-0.29.6-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "795867b57aa9c52d696047856652f702", + "name": "cython", + "sha256": "1f6b4e0e7d0e2f9ba28f4a3b3dbd41568f17b51c41f63e35fe606e1d5fd2de5e", + "size": 2077447, + "subdir": "linux-64", + "timestamp": 1552326333502, + "version": "0.29.6" + }, + "cython-0.29.6-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "6210cc389a7053c1f171e0aa6ea06408", + "name": "cython", + "sha256": "36ef376baba639285c67e2d0a8c4be0f3b5e03f832e6c2122e17663a3668e0b9", + "size": 2118460, + "subdir": "linux-64", + "timestamp": 1552326201435, + "version": "0.29.6" + }, + "cython-0.29.6-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "ac14bad208d15cca4a85f80a33aa86a5", + "name": "cython", + "sha256": "29173bfca30adc19c493ec3cff3b29da3cd64de216f334a7136adffaecba71bd", + "size": 2108826, + "subdir": "linux-64", + "timestamp": 1552326161333, + "version": "0.29.6" + }, + "cython-0.29.7-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "679bd70ec086a5da0dca1216450a573a", + "name": "cython", + "sha256": "d5388bfe9732c4ff414bcc5b4feba296040d7a29351c0cb5044057fd2c065fdc", + "size": 2076080, + "subdir": "linux-64", + "timestamp": 1555427804492, + "version": "0.29.7" + }, + "cython-0.29.7-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "22cf07207e6751af8b7a26d32b6d8528", + "name": "cython", + "sha256": "f13e9e80aa6b872f91408110bdf97ebc7588cd62a517610585a1201e2e22d9dc", + "size": 2118314, + "subdir": "linux-64", + "timestamp": 1555427828787, + "version": "0.29.7" + }, + "cython-0.29.7-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "535f86395262100d71368261f8ffdb4c", + "name": "cython", + "sha256": "28fa9ac1002287e145c8e37029f976ab4bc3d9c930dafd9338285c4d8e3b96fd", + "size": 2115218, + "subdir": "linux-64", + "timestamp": 1555427714543, + "version": "0.29.7" + }, + "cython-0.29.8-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "ebb1a7ffab1edc42bda3c91b19fc48e3", + "name": "cython", + "sha256": "b96f39ef15d43397330a48dfa898d1c8407988c4d0a806b1fe2f350f44ba98ae", + "size": 2074717, + "subdir": "linux-64", + "timestamp": 1559140804587, + "version": "0.29.8" + }, + "cython-0.29.8-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "6d15c69762b412481d6aa9b8aeffbd73", + "name": "cython", + "sha256": "a4f2b2a9c9d8658b8c917134eaf11949dd71c354f563e68e362d40a1f13fc833", + "size": 2119326, + "subdir": "linux-64", + "timestamp": 1559140741435, + "version": "0.29.8" + }, + "cython-0.29.8-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "573468633dc7e37df5fd2406e674f9f2", + "name": "cython", + "sha256": "34a2bf354b16bf76f00f2b3a079ea40accdf54dad171c1190e62be6200dcd916", + "size": 2115976, + "subdir": "linux-64", + "timestamp": 1559140576647, + "version": "0.29.8" + }, + "cython-blis-0.4.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "830b8787260dc9e2adf7a7f461ee59a5", + "name": "cython-blis", + "sha256": "7407d41952fd3c68760e80c679fcb4f4edf8e28a776867a3880b086948610419", + "size": 1950707, + "subdir": "linux-64", + "timestamp": 1590154876002, + "version": "0.4.1" + }, + "cython-blis-0.4.1-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c9a4fd7c39e22335dee8cab2f0dfd07d", + "name": "cython-blis", + "sha256": "03900045f3241822c9c9b95eca7bfa44a9d5b39cc57585e38d1acc286d08bf1f", + "size": 1953010, + "subdir": "linux-64", + "timestamp": 1594247180446, + "version": "0.4.1" + }, + "cython-blis-0.4.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1bb1c17fe7ffd55fbe5138f6e465c36b", + "name": "cython-blis", + "sha256": "0d826b6b2d9e3765e366c100c07b7ce77186cb51dc5d0eb2274a756400b9ff4c", + "size": 1958327, + "subdir": "linux-64", + "timestamp": 1590154867378, + "version": "0.4.1" + }, + "cython-blis-0.4.1-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b85b00930b8be4cabea5788b8989e482", + "name": "cython-blis", + "sha256": "cbefa13e74ae242b32597ad8803d8dee019881a6699e93fdaa79000bb434e717", + "size": 1959561, + "subdir": "linux-64", + "timestamp": 1594247204608, + "version": "0.4.1" + }, + "cython-blis-0.4.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "42cc21d901ce138ea45f401274081a2b", + "name": "cython-blis", + "sha256": "b53bb19340c0ea0e9f799eeba550d30560180ca4652b4bed4d7853cfa82d1a22", + "size": 1959730, + "subdir": "linux-64", + "timestamp": 1590154880633, + "version": "0.4.1" + }, + "cython-blis-0.4.1-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7d423fee9564cdfd5746240cf8fc1520", + "name": "cython-blis", + "sha256": "e649e1a4df31baeb2eb11887756a21feb6e4b9e9a86117666fbd28329eb9b0fc", + "size": 1960700, + "subdir": "linux-64", + "timestamp": 1594247283343, + "version": "0.4.1" + }, + "cython-blis-0.4.1-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b00dac49c92fc00442b67db29e501c52", + "name": "cython-blis", + "sha256": "49c1c84be4ffc21a4170b6a3fcb2263b80e23a0f2136b50e4c4ea6b10e2ec34c", + "size": 1965855, + "subdir": "linux-64", + "timestamp": 1608234067304, + "version": "0.4.1" + }, + "cython-blis-0.7.4-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e0ca1662ac204801825b531354ccf48d", + "name": "cython-blis", + "sha256": "94b01f9ce03ed5bb04b486bc71be802f1ccc962525f36f4de1c8c97df26ab002", + "size": 2130271, + "subdir": "linux-64", + "timestamp": 1613319993403, + "version": "0.7.4" + }, + "cython-blis-0.7.4-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3953d360b9d94b44bcd79c611bebbd7b", + "name": "cython-blis", + "sha256": "252317c270144a676b72beaa267ca443674f5c2067c2fc3eb4bdb0400ad90c84", + "size": 2129783, + "subdir": "linux-64", + "timestamp": 1613319974658, + "version": "0.7.4" + }, + "cython-blis-0.7.4-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "533cbdfb40d4d632f961f1a5ebeacb75", + "name": "cython-blis", + "sha256": "b3544c133a65ac693a2074f0fd1f024c99cc742c26d76da64d65e927d63017c7", + "size": 2137478, + "subdir": "linux-64", + "timestamp": 1613320009819, + "version": "0.7.4" + }, + "cython-blis-0.7.4-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e1714511b028ee58588b570acf817c5", + "name": "cython-blis", + "sha256": "c82637aebdd6cf49ed5f3d450ca1577b75d40d94fc73bcc250462947cc56002e", + "size": 2136268, + "subdir": "linux-64", + "timestamp": 1613319170304, + "version": "0.7.4" + }, + "cython-blis-0.7.7-py310h9102076_0.conda": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "679c3b1bad40bc71dcb77f548d865065", + "name": "cython-blis", + "sha256": "fd4ed1e448537a41ddbd86c669763cac39bf1fd43cd90f2e91e1783d96ac91ff", + "size": 2586343, + "subdir": "linux-64", + "timestamp": 1651220784169, + "version": "0.7.7" + }, + "cython-blis-0.7.7-py311hbed6279_0.conda": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b21439b5fca4c81bcaaf0f1a1f06bd5f", + "name": "cython-blis", + "sha256": "425f814d2d4432463a8518795ebe30ce29f68fdfadbadb40bfa6554627b11acf", + "size": 3031226, + "subdir": "linux-64", + "timestamp": 1676839688748, + "version": "0.7.7" + }, + "cython-blis-0.7.7-py37hce1f21e_0.conda": { + "build": "py37hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0087ee869c20c25240fcea64c0562935", + "name": "cython-blis", + "sha256": "ef4ce748bca5c4f4f541fa5af7becc7c20da9e0c4c2c835b888882a25ff8ad83", + "size": 2084994, + "subdir": "linux-64", + "timestamp": 1651220288651, + "version": "0.7.7" + }, + "cython-blis-0.7.7-py38hce1f21e_0.conda": { + "build": "py38hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff769b4ebd3047db264b258b5512f6a4", + "name": "cython-blis", + "sha256": "b8750aa6d0dab5a7690f895503011aa5e1dd0d815d9f841a4961a265d2d3d446", + "size": 2095103, + "subdir": "linux-64", + "timestamp": 1651221265740, + "version": "0.7.7" + }, + "cython-blis-0.7.7-py39hce1f21e_0.conda": { + "build": "py39hce1f21e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "02a74d825803e43e74ffdc8edbaf34fc", + "name": "cython-blis", + "sha256": "076a1161eaf4dae53fde95c1c52d4e7b21204e8207bcbec4c0c16a55c590121f", + "size": 2095170, + "subdir": "linux-64", + "timestamp": 1651221749591, + "version": "0.7.7" + }, + "cytoolz-0.10.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "6aeb3ad66ef6caf92bcfadc298a243a9", + "name": "cytoolz", + "sha256": "9b2a46b25c78cd1b0bbb4823844ca51d0563dec9370bef34403de1eef4b0b712", + "size": 375620, + "subdir": "linux-64", + "timestamp": 1563285785610, + "version": "0.10.0" + }, + "cytoolz-0.10.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "f981cf0d62fc16446923aa92c2c054f3", + "name": "cytoolz", + "sha256": "4d3841479d7bbaa586f43993ed460087e2e34ae0099faa58800758cdc7b3c19f", + "size": 382700, + "subdir": "linux-64", + "timestamp": 1563285784033, + "version": "0.10.0" + }, + "cytoolz-0.10.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "71a9f96bbec5eb9d42fcc7264c64eb74", + "name": "cytoolz", + "sha256": "bd2f9a55b0108b4faf4ce618f1e1b859767461adac11cec8bcaa154fd72d7c6e", + "size": 382713, + "subdir": "linux-64", + "timestamp": 1563285780647, + "version": "0.10.0" + }, + "cytoolz-0.10.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "858fccce004860e84e578332f7ac3a05", + "name": "cytoolz", + "sha256": "3f1006af366c4b704003975d46b4e871adef433961213c7e5044deae5d74b429", + "size": 375652, + "subdir": "linux-64", + "timestamp": 1573938366714, + "version": "0.10.1" + }, + "cytoolz-0.10.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "47dbaab7772ec467a8107fd2f4dded4b", + "name": "cytoolz", + "sha256": "c69fd1d199590e16b67576cd81011587cf64e86e7562a1f982f0bbd611d653aa", + "size": 386360, + "subdir": "linux-64", + "timestamp": 1573938360278, + "version": "0.10.1" + }, + "cytoolz-0.10.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "f38e382c34eed0d6a712ed872c4deb85", + "name": "cytoolz", + "sha256": "de00364cb15526fd8684eed5c1d1d926c6203ab097a26521c7935805689d1bf0", + "size": 385155, + "subdir": "linux-64", + "timestamp": 1573938360323, + "version": "0.10.1" + }, + "cytoolz-0.10.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "d6197c1812e49af9313d7a49de8c54bc", + "name": "cytoolz", + "sha256": "851feacf85cf104758927b6230cc9adabb442e397b563a9de199127780787fac", + "size": 401778, + "subdir": "linux-64", + "timestamp": 1573938384226, + "version": "0.10.1" + }, + "cytoolz-0.10.1-py39he8ac12f_0.conda": { + "build": "py39he8ac12f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "4afa802ba90e3c875cf70930cfd6c13e", + "name": "cytoolz", + "sha256": "737e1b2c7da0fb9db7edbda00184eea12e15e78f961ec32160f1799b82a15144", + "size": 360116, + "subdir": "linux-64", + "timestamp": 1607025606657, + "version": "0.10.1" + }, + "cytoolz-0.11.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "2e69242dd82565b6c846108144858b56", + "name": "cytoolz", + "sha256": "636b74d13b4ce5da52f16497167b1e5ba61010bf89a2e0a8108d1daa67ec3190", + "size": 1112592, + "subdir": "linux-64", + "timestamp": 1640789408417, + "version": "0.11.0" + }, + "cytoolz-0.11.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "e2ef5d94db4e39f1e58b5607023c3243", + "name": "cytoolz", + "sha256": "dee1fdc3465e5add0e8207843392be1f7b9479343929e839a3d49143a108e48e", + "size": 336955, + "subdir": "linux-64", + "timestamp": 1600959022284, + "version": "0.11.0" + }, + "cytoolz-0.11.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "271a278e474c95a9c2fca268e39de652", + "name": "cytoolz", + "sha256": "7f8be2d544f84a86e4f7606c40940a4f676d7e3b9ff50952d61600ea09c90d8b", + "size": 335664, + "subdir": "linux-64", + "timestamp": 1600959048771, + "version": "0.11.0" + }, + "cytoolz-0.11.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "674167bf0c35566f9fb70653cfc196c0", + "name": "cytoolz", + "sha256": "a5fe8c238714603e65c665e49719d767a408365d7e54f49898201d752d9416dd", + "size": 352813, + "subdir": "linux-64", + "timestamp": 1600959049930, + "version": "0.11.0" + }, + "cytoolz-0.11.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "md5": "521c9179d2952ca26e0f5f2dc6226c7d", + "name": "cytoolz", + "sha256": "479e78de00a4ca80e393726d425668fb23f198493df4594c4107ab2993c1924a", + "size": 358312, + "subdir": "linux-64", + "timestamp": 1608061872700, + "version": "0.11.0" + }, + "cytoolz-0.12.0-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "236015e40c130ef56785f779eda1cfaa", + "name": "cytoolz", + "sha256": "39358f98d3e50ff9de5bae6a806d6b4d69c991e1919f7809ec8d4cf9624a4edc", + "size": 379163, + "subdir": "linux-64", + "timestamp": 1667465990428, + "version": "0.12.0" + }, + "cytoolz-0.12.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c86e82b4e6a3d8b909cb63243f6f4a20", + "name": "cytoolz", + "sha256": "30fdc0e92f94ce48b63377c4b25f8bf3886d78b4d1f960d6d4692009a1982464", + "size": 367783, + "subdir": "linux-64", + "timestamp": 1676830435501, + "version": "0.12.0" + }, + "cytoolz-0.12.0-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "db8cb57faad8ef31be3daa059b782067", + "name": "cytoolz", + "sha256": "a4e88fbcae38dada5790c5312cf8335d6e3e6595850e2be83d1ea94881caa4d9", + "size": 379579, + "subdir": "linux-64", + "timestamp": 1667466137592, + "version": "0.12.0" + }, + "cytoolz-0.12.0-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "10e641a469191921ef8f504ce5d5a542", + "name": "cytoolz", + "sha256": "e442b13e5ad2685676aec87222a90200aaf0b09c91670c32713b954f1ca81b2c", + "size": 388206, + "subdir": "linux-64", + "timestamp": 1667466087220, + "version": "0.12.0" + }, + "cytoolz-0.12.0-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "toolz >=0.10.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c0229d589b5802f42edca29a9fc34832", + "name": "cytoolz", + "sha256": "760b532b539b934fbea6285378bbfb48d30f074b2c0bb8e46127f264ad786d3a", + "size": 381695, + "subdir": "linux-64", + "timestamp": 1667466037849, + "version": "0.12.0" + }, + "cytoolz-0.8.2-py27hf14aec9_0.conda": { + "build": "py27hf14aec9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "f17fe0867b67952cda3019ba53242c8e", + "name": "cytoolz", + "sha256": "71bc46ab695cd014ea88fe792775b23d9ef0d816ca5d9d103624ecef6283c35b", + "size": 319348, + "subdir": "linux-64", + "timestamp": 1505740196014, + "version": "0.8.2" + }, + "cytoolz-0.8.2-py35ha53021f_0.conda": { + "build": "py35ha53021f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "8ed1f3b617d03dfbd6ae2091ddb9524d", + "name": "cytoolz", + "sha256": "5923b35920683d3f1e432d010ddd2d433cf5bfb88e7966b01fc353a6d3dc7347", + "size": 323428, + "subdir": "linux-64", + "timestamp": 1505740231317, + "version": "0.8.2" + }, + "cytoolz-0.8.2-py36h708bfd4_0.conda": { + "build": "py36h708bfd4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "8646b1577efa0914b1ff3174d011c370", + "name": "cytoolz", + "sha256": "ef543de049d4a080d533eda99fd7047402935f8d564c3222c05b8e529c96bd67", + "size": 327074, + "subdir": "linux-64", + "timestamp": 1505740267776, + "version": "0.8.2" + }, + "cytoolz-0.9.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "8f531710fd665cb25057cb0cc31f4b4b", + "name": "cytoolz", + "sha256": "cbeff0dafba5907e003eb0d8fdae155beafa4115c339c493d94b99769d6624e0", + "size": 361603, + "subdir": "linux-64", + "timestamp": 1515794222549, + "version": "0.9.0" + }, + "cytoolz-0.9.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "3a98c146733b0aa75d7e72e9df746040", + "name": "cytoolz", + "sha256": "d5fc78d83f46d94eb0219748875f005308a99e4a4d1742d87debcf950c20c857", + "size": 364530, + "subdir": "linux-64", + "timestamp": 1515794234739, + "version": "0.9.0" + }, + "cytoolz-0.9.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "377dbfe45a96f128f10132e004eaa025", + "name": "cytoolz", + "sha256": "3d0f78c7df8ebd90ef4904b611e8b5eb3fbc389a6cd39466f4428df5e8a9176c", + "size": 369086, + "subdir": "linux-64", + "timestamp": 1515794401867, + "version": "0.9.0" + }, + "cytoolz-0.9.0.1-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "326e456419da4443792726fdf94182cd", + "name": "cytoolz", + "sha256": "70d6264d9f3c0d94a0a683386a7c63592b90fcdd2f56bc553f519aca1346f60d", + "size": 361350, + "subdir": "linux-64", + "timestamp": 1520374050863, + "version": "0.9.0.1" + }, + "cytoolz-0.9.0.1-py27h14c3975_1.conda": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "1d9ca88ecf1f9f1ebe324253161eb552", + "name": "cytoolz", + "sha256": "f4780004c42e336d00903d64c56e08dc07552adb1cf5e6722433768bb3e3fb7d", + "size": 361457, + "subdir": "linux-64", + "timestamp": 1530741613002, + "version": "0.9.0.1" + }, + "cytoolz-0.9.0.1-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "cf1f276cc31d708f625828c0aaa0cd6a", + "name": "cytoolz", + "sha256": "35591d7abaa2802a01a568adc866ee7f0c07d5dfbc4182267c0bb7e75aec6b23", + "size": 365579, + "subdir": "linux-64", + "timestamp": 1520374373870, + "version": "0.9.0.1" + }, + "cytoolz-0.9.0.1-py35h14c3975_1.conda": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "4aeae719440bf0f72d093d7ca83c0fd0", + "name": "cytoolz", + "sha256": "da3077b45c00e64d531444b6258503092ac49b45512cfc3809fab78c2a285299", + "size": 363995, + "subdir": "linux-64", + "timestamp": 1534356589107, + "version": "0.9.0.1" + }, + "cytoolz-0.9.0.1-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "3f99b322c09c29c845951585dde98785", + "name": "cytoolz", + "sha256": "f3c092bb09dbc0b8abf854aeab896811730fb9f4826bf694d350abd873f882d7", + "size": 368463, + "subdir": "linux-64", + "timestamp": 1520374393487, + "version": "0.9.0.1" + }, + "cytoolz-0.9.0.1-py36h14c3975_1.conda": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "c5b9e760da503932dbf61a92d5174b76", + "name": "cytoolz", + "sha256": "ccd2baa72ea980bef7ef31deb27cd307254b3429e46c2ee1cdf62882926e705e", + "size": 367942, + "subdir": "linux-64", + "timestamp": 1530741564377, + "version": "0.9.0.1" + }, + "cytoolz-0.9.0.1-py37h14c3975_1.conda": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "toolz >=0.8.0" + ], + "license": "BSD 3-Clause", + "md5": "bfdd4b2c268b98628df40ed7b5b193e7", + "name": "cytoolz", + "sha256": "07324d9be6a880352778edec9d6eb707825d2e09980d06a55f7f6c44c48827aa", + "size": 367198, + "subdir": "linux-64", + "timestamp": 1530741663494, + "version": "0.9.0.1" + }, + "d2to1-0.2.12-py27ha563d29_0.conda": { + "build": "py27ha563d29_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2b546ce5746abc1e5fe8d122c0a3e6e8", + "name": "d2to1", + "sha256": "15b8589751bb5827367ffec75bf47bd2e656b90ec5e886fc9378b25d6f31fad3", + "size": 44176, + "subdir": "linux-64", + "timestamp": 1507376117241, + "version": "0.2.12" + }, + "d2to1-0.2.12-py35h68503a4_0.conda": { + "build": "py35h68503a4_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a6160cfd7cbe260646b4e8dcdf7b7eef", + "name": "d2to1", + "sha256": "171700f00aa2402d73bd7eb7014e72e1c006a44bcbc90da372b0da559e7574f1", + "size": 44359, + "subdir": "linux-64", + "timestamp": 1507376118675, + "version": "0.2.12" + }, + "d2to1-0.2.12-py36h2e3980f_0.conda": { + "build": "py36h2e3980f_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c312f6fc2a19d6e76100729ec7bfffe5", + "name": "d2to1", + "sha256": "c15f3128839bc405b94053e78e60eb14b69d3107b2c60d059b34ab95e039eda3", + "size": 44142, + "subdir": "linux-64", + "timestamp": 1507376126151, + "version": "0.2.12" + }, + "d2to1-0.2.12.post1-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "624793efbffdd7bd3fc06a85ff3bf867", + "name": "d2to1", + "sha256": "1b4b96e8797682c2f1506ac0013266b2b48afae660797dabaf5ab5e685a97367", + "size": 43908, + "subdir": "linux-64", + "timestamp": 1530812347919, + "version": "0.2.12.post1" + }, + "d2to1-0.2.12.post1-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fbff2f09f90457e5720cbbdc1ed66ac7", + "name": "d2to1", + "sha256": "9c172ac78b8d7415cf6a4b4a181ef6c2b34ade023f7a1be055f3151b9fafdebd", + "size": 44080, + "subdir": "linux-64", + "timestamp": 1535130055326, + "version": "0.2.12.post1" + }, + "d2to1-0.2.12.post1-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "356b0b805041da98e2671050b759b109", + "name": "d2to1", + "sha256": "41b12f61cffef056a357435d86d9dcf87725edcdaeabb7e89686c8f667c14b24", + "size": 43639, + "subdir": "linux-64", + "timestamp": 1530812397648, + "version": "0.2.12.post1" + }, + "d2to1-0.2.12.post1-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1856958fe2c399a7e4d5be3dd568d044", + "name": "d2to1", + "sha256": "0227c2aa824ab0123c2b66c83a8e1820ab2811abb77633875cecf0188ddb4ef1", + "size": 43805, + "subdir": "linux-64", + "timestamp": 1530812372303, + "version": "0.2.12.post1" + }, + "daal-2019.3-199.conda": { + "build": "199", + "build_number": 199, + "depends": [ + "tbb 2019.*" + ], + "md5": "f749c3f9155e484961c749aa340ab840", + "name": "daal", + "sha256": "8f8932576ee7492c32513ed27425ebbba82b13ee8b69d0b7ac050ef56d110b25", + "size": 33055544, + "subdir": "linux-64", + "timestamp": 1557261142178, + "version": "2019.3" + }, + "daal-2019.4-243.conda": { + "build": "243", + "build_number": 243, + "depends": [ + "tbb 2019.*" + ], + "md5": "aa4d5a4458b1e7ae1e7c90d266ea9f5a", + "name": "daal", + "sha256": "3448a04022c0e4ea113e5db0a59eea0441e3a3cb39de9e9490fe62657056836c", + "size": 33690181, + "subdir": "linux-64", + "timestamp": 1559526392080, + "version": "2019.4" + }, + "daal-2020.0-166.conda": { + "build": "166", + "build_number": 166, + "depends": [ + "tbb 2020.*" + ], + "md5": "9e5a56cb5a4766905fc9472985a30d86", + "name": "daal", + "sha256": "a41e879c2e4bdd7a7656949029268437fb69ec38f3ae9e56b8d340bf318d9ba7", + "size": 38622354, + "subdir": "linux-64", + "timestamp": 1580943817372, + "version": "2020.0" + }, + "daal-2020.1-217.conda": { + "build": "217", + "build_number": 217, + "depends": [ + "tbb 2020.*" + ], + "md5": "552381ff64c789152296db6bbac70740", + "name": "daal", + "sha256": "bd08cb1c2df16a1946f803b1f898978b87813a312f86e0963d96550a3bb79b61", + "size": 37935157, + "subdir": "linux-64", + "timestamp": 1589162126410, + "version": "2020.1" + }, + "daal-2020.2-256.conda": { + "build": "256", + "build_number": 256, + "depends": [ + "tbb 2020.*" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "8f84cc03cca285d8e124df93f65e9762", + "name": "daal", + "sha256": "dae6ea339c249d7414f140e28e453245732d22f7b770610a1b2f2e552000a26e", + "size": 38644404, + "subdir": "linux-64", + "timestamp": 1598384110431, + "version": "2020.2" + }, + "daal-2021.2.2-h06a4308_389.conda": { + "build": "h06a4308_389", + "build_number": 389, + "depends": [ + "dal >=2021.2.2,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "75f26a0f1baf45a730ef573617a011e3", + "name": "daal", + "sha256": "f32e7e89bcf6d23e09cf99555f2aef98f7efba0ffdbbfa4361bbb52937e677eb", + "size": 15904, + "subdir": "linux-64", + "timestamp": 1619450726499, + "version": "2021.2.2" + }, + "daal-2021.3.0-h06a4308_557.conda": { + "build": "h06a4308_557", + "build_number": 557, + "depends": [ + "dal >=2021.3.0,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "3190402724c2daf12c13d9a2a21cf243", + "name": "daal", + "sha256": "4ad677e18d68cb421b2386862a912b47ee0082bee16bc794de2beb9db05c64ec", + "size": 15904, + "subdir": "linux-64", + "timestamp": 1626182304223, + "version": "2021.3.0" + }, + "daal-2021.4.0-h06a4308_729.conda": { + "build": "h06a4308_729", + "build_number": 729, + "depends": [ + "dal >=2021.4.0,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "c3e9ac8ace69306b60ae2cb8a951e02e", + "name": "daal", + "sha256": "f41a635c6c65ff8869b5b25baa9dcd264a31aaf736736459fd72fbbf9b8baa6e", + "size": 19628, + "subdir": "linux-64", + "timestamp": 1634546773301, + "version": "2021.4.0" + }, + "daal-2021.5.1-h06a4308_803.conda": { + "build": "h06a4308_803", + "build_number": 803, + "depends": [ + "dal >=2021.5.1,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "fb44f6e45cd7496a19c9f13d3d9a449e", + "name": "daal", + "sha256": "ebe15f8b10c656a8f758cee4244438c56e7251110987bf2b019d1e71891389f7", + "size": 20302, + "subdir": "linux-64", + "timestamp": 1642705453107, + "version": "2021.5.1" + }, + "daal-2021.5.3-h06a4308_833.conda": { + "build": "h06a4308_833", + "build_number": 833, + "depends": [ + "dal >=2021.6.0,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "003644e26256c9223c1f92af728098cc", + "name": "daal", + "sha256": "0de7332354f0300f3b98b48e8e73a550198c5f5e6df8a90de86cc211306ce87e", + "size": 18552, + "subdir": "linux-64", + "timestamp": 1662497675506, + "version": "2021.5.3" + }, + "daal-devel-2019.3-199.conda": { + "build": "199", + "build_number": 199, + "depends": [ + "daal 2019.3 199", + "daal-include 2019.3 199" + ], + "md5": "e0aa0d2ac51f0e4ea94bd9fe871e9a6e", + "name": "daal-devel", + "sha256": "6a0914f5a7213828d998a1f61f76cf30a6fd10d0f584207e066f3034a6147e87", + "size": 1686987, + "subdir": "linux-64", + "timestamp": 1557261294897, + "version": "2019.3" + }, + "daal-devel-2019.4-243.conda": { + "build": "243", + "build_number": 243, + "depends": [ + "daal 2019.4 243", + "daal-include 2019.4 243" + ], + "md5": "c33b172246a7d07fd4bb003678f9222a", + "name": "daal-devel", + "sha256": "14ffa50e4940a5c69ac94919e0c5bf168a2b3b69f474fb3dd93770da2f7a7acf", + "size": 1689837, + "subdir": "linux-64", + "timestamp": 1559526517475, + "version": "2019.4" + }, + "daal-devel-2020.0-166.conda": { + "build": "166", + "build_number": 166, + "depends": [ + "daal 2020.0 166", + "daal-include 2020.0 166" + ], + "md5": "f95a02d0e58a6fbeef9e378951b5a19b", + "name": "daal-devel", + "sha256": "9850e032b8849043485d3c83444121b13a1b41e4c23e87c1dadc94fb9296c25c", + "size": 1744511, + "subdir": "linux-64", + "timestamp": 1580943982397, + "version": "2020.0" + }, + "daal-devel-2020.1-217.conda": { + "build": "217", + "build_number": 217, + "depends": [ + "daal 2020.1 217", + "daal-include 2020.1 217" + ], + "md5": "86d451db6dfe1297372996cc93942dc2", + "name": "daal-devel", + "sha256": "632babb1d91f7384176522a12ba29a71b8cfdec74b5a687fd235c851b257fc26", + "size": 1748245, + "subdir": "linux-64", + "timestamp": 1589162252866, + "version": "2020.1" + }, + "daal-devel-2020.2-256.conda": { + "build": "256", + "build_number": 256, + "depends": [ + "daal 2020.2 256", + "daal-include 2020.2 256" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "71a493d56d17398798bb4ca5dd71f745", + "name": "daal-devel", + "sha256": "2d8e50300e0cccdc061047a540866fc6a2cc999fcdf8528eaf4147433d4be37b", + "size": 1753364, + "subdir": "linux-64", + "timestamp": 1598384201847, + "version": "2020.2" + }, + "daal-devel-2021.2.2-h06a4308_389.conda": { + "build": "h06a4308_389", + "build_number": 389, + "depends": [ + "dal-devel >=2021.2.2,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "ea1e286717b4adc6a53795e4c0438622", + "name": "daal-devel", + "sha256": "da371d89d42cf15857d5dbb5e76ef52170594d51aa03c9d47cb85ef8d6fb929e", + "size": 15962, + "subdir": "linux-64", + "timestamp": 1619451486495, + "version": "2021.2.2" + }, + "daal-devel-2021.3.0-h06a4308_557.conda": { + "build": "h06a4308_557", + "build_number": 557, + "depends": [ + "dal-devel >=2021.3.0,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "c8c2807145e8249d9aec6721a6430f90", + "name": "daal-devel", + "sha256": "4f977bb2bc7cc589cc23853322c5e35018399f9998ed3f2cca946d5d1cba1cfc", + "size": 15977, + "subdir": "linux-64", + "timestamp": 1626182866757, + "version": "2021.3.0" + }, + "daal-devel-2021.4.0-h06a4308_729.conda": { + "build": "h06a4308_729", + "build_number": 729, + "depends": [ + "dal-devel >=2021.4.0,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "b33c54eb625c002fdb3f20be03364bdb", + "name": "daal-devel", + "sha256": "59fbced8fa680812de572d89013634e04d3e9f0aa6bf0f84358fe0820a637a44", + "size": 19678, + "subdir": "linux-64", + "timestamp": 1634547335430, + "version": "2021.4.0" + }, + "daal-devel-2021.5.1-h06a4308_803.conda": { + "build": "h06a4308_803", + "build_number": 803, + "depends": [ + "dal-devel >=2021.5.1,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "bba00fdd25efb076c107a9d9e4480d42", + "name": "daal-devel", + "sha256": "8fd39c1797d755dd6dc9fbd5d0a02e6638ebae70b4d0a1c604c3d6c3264b3711", + "size": 20371, + "subdir": "linux-64", + "timestamp": 1642705972152, + "version": "2021.5.1" + }, + "daal-devel-2021.5.3-h06a4308_833.conda": { + "build": "h06a4308_833", + "build_number": 833, + "depends": [ + "dal-devel >=2021.6.0,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "e02b9eb08b1a80aad7ba3b2f604777e2", + "name": "daal-devel", + "sha256": "201f84f8cf783f341152b0656cd3c5896319d80ca28ea39e693d9f226cf95f20", + "size": 18642, + "subdir": "linux-64", + "timestamp": 1662498032811, + "version": "2021.5.3" + }, + "daal-include-2019.3-199.conda": { + "build": "199", + "build_number": 199, + "depends": [], + "md5": "7d27ba59ef3a9c2c5078894ebf296d6e", + "name": "daal-include", + "sha256": "97a43cf9d0c8de96223cdaea8ceb521cf4982a319692e7fae9027f6048af582a", + "size": 293649, + "subdir": "linux-64", + "timestamp": 1557261289722, + "version": "2019.3" + }, + "daal-include-2019.4-243.conda": { + "build": "243", + "build_number": 243, + "depends": [], + "md5": "571a6ae443f00f153a0f1f2199ba8048", + "name": "daal-include", + "sha256": "0436b4a649a147a57e83baef60f4aa727b6b7409b86acfbcef9e8d5f8ea0382a", + "size": 294492, + "subdir": "linux-64", + "timestamp": 1559526503951, + "version": "2019.4" + }, + "daal-include-2020.0-166.conda": { + "build": "166", + "build_number": 166, + "depends": [], + "md5": "a5d460ab7f936152f4145f2f468d637f", + "name": "daal-include", + "sha256": "915ffc9b08071fc8c6a0693dd0325fc0ecfc15a06e53ddc28823db40a68b0f48", + "size": 318956, + "subdir": "linux-64", + "timestamp": 1580943967224, + "version": "2020.0" + }, + "daal-include-2020.1-217.conda": { + "build": "217", + "build_number": 217, + "depends": [], + "md5": "75149df3175277109cc03ab546ef7f66", + "name": "daal-include", + "sha256": "b957bc9ada22ab2c0b1ff45540d4df8d0d892942d4736fc32ccc6d9e30060158", + "size": 322129, + "subdir": "linux-64", + "timestamp": 1589162236314, + "version": "2020.1" + }, + "daal-include-2020.2-256.conda": { + "build": "256", + "build_number": 256, + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "63f3dc44a74cede95409622c9e1a7c11", + "name": "daal-include", + "sha256": "c8763b5e7dcc739fb5ea4ba3d6eeec35130abbc1a37604f8988b8733210ffc49", + "size": 326368, + "subdir": "linux-64", + "timestamp": 1598384188504, + "version": "2020.2" + }, + "daal-include-2021.2.2-h06a4308_389.conda": { + "build": "h06a4308_389", + "build_number": 389, + "depends": [ + "dal-include >=2021.2.2,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "c3b4652d5ecfa3a58b653a693337e318", + "name": "daal-include", + "sha256": "c0f69c55f534a91b76fc0b9a44b6411d66efd5b4a02ddad04b8c29a51f2e75e3", + "size": 15947, + "subdir": "linux-64", + "timestamp": 1619450727630, + "version": "2021.2.2" + }, + "daal-include-2021.3.0-h06a4308_557.conda": { + "build": "h06a4308_557", + "build_number": 557, + "depends": [ + "dal-include >=2021.3.0,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "8708f7c86131ff317bed69e1f2496945", + "name": "daal-include", + "sha256": "847c2dcd6cfda8cba33b0e14f39bf620410c02fbb0d06f6714e1cd1fbc3e1472", + "size": 15950, + "subdir": "linux-64", + "timestamp": 1626182305140, + "version": "2021.3.0" + }, + "daal-include-2021.4.0-h06a4308_729.conda": { + "build": "h06a4308_729", + "build_number": 729, + "depends": [ + "dal-include >=2021.4.0,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "4c5f7590e34cc48cb36668109f6bb846", + "name": "daal-include", + "sha256": "84b2db7bfdf48f5f717063f14dfe9a578d6902089af08089a9222c594a3b6089", + "size": 19676, + "subdir": "linux-64", + "timestamp": 1634546774158, + "version": "2021.4.0" + }, + "daal-include-2021.5.1-h06a4308_803.conda": { + "build": "h06a4308_803", + "build_number": 803, + "depends": [ + "dal-include >=2021.5.1,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "8cc7963d4ac500a56963f73b659bf46e", + "name": "daal-include", + "sha256": "98c260413627e50f19eaf443c18dbc07d4b75493a45a8ba97eeb76e655b6fcd6", + "size": 20347, + "subdir": "linux-64", + "timestamp": 1642705454026, + "version": "2021.5.1" + }, + "daal-include-2021.5.3-h06a4308_833.conda": { + "build": "h06a4308_833", + "build_number": 833, + "depends": [ + "dal-include >=2021.6.0,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "42df70e73101c5b2786306e737143023", + "name": "daal-include", + "sha256": "892af7acb52be16dbd1d57b1d548e6e7ead27cf7262735816a502a1137587fe1", + "size": 18640, + "subdir": "linux-64", + "timestamp": 1662497676411, + "version": "2021.5.3" + }, + "daal-static-2019.3-199.conda": { + "build": "199", + "build_number": 199, + "depends": [ + "daal-include 2019.3 199", + "tbb 2019.*" + ], + "md5": "170ae8c7661389b26b698a5cf99e84d3", + "name": "daal-static", + "sha256": "2378470d3ef0747dc5047399a8c9e447683335530d126dbbd3c3c32d1622168d", + "size": 34322012, + "subdir": "linux-64", + "timestamp": 1557261392744, + "version": "2019.3" + }, + "daal-static-2019.4-243.conda": { + "build": "243", + "build_number": 243, + "depends": [ + "daal-include 2019.4 243", + "tbb 2019.*" + ], + "md5": "473fceb00b69bbba4f95b25447857bf3", + "name": "daal-static", + "sha256": "8261e1a77f6c012624a9a86b748c036aeb622eda6f75e221460ff814838618cb", + "size": 34736796, + "subdir": "linux-64", + "timestamp": 1559526587932, + "version": "2019.4" + }, + "daal-static-2020.0-166.conda": { + "build": "166", + "build_number": 166, + "depends": [ + "daal-include 2020.0 166", + "tbb 2020.*" + ], + "md5": "49e1f1c0384d816315de4698e24d1884", + "name": "daal-static", + "sha256": "c6996ae18ab13a09aa284821a0c35f3f14388454aa6d47bfb7ff00e0ff886507", + "size": 36158060, + "subdir": "linux-64", + "timestamp": 1580944071083, + "version": "2020.0" + }, + "daal-static-2020.1-217.conda": { + "build": "217", + "build_number": 217, + "depends": [ + "daal-include 2020.1 217", + "tbb 2020.*" + ], + "md5": "695fcf11eb8d644a53aab47e0b18c4bc", + "name": "daal-static", + "sha256": "fb10d0fde97066b1ba666c73e88555fde5acd846ec1c4d8d8a1c3420b82de74a", + "size": 36136813, + "subdir": "linux-64", + "timestamp": 1589162346112, + "version": "2020.1" + }, + "daal-static-2020.2-256.conda": { + "build": "256", + "build_number": 256, + "depends": [ + "daal-include 2020.2 256", + "tbb 2020.*" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "f9c8586fd25b3f16d90fbec4721c5710", + "name": "daal-static", + "sha256": "ff2227ac0659f2b326df51826f37dca16bc34162771661e4284ca22f0a9cb469", + "size": 36967836, + "subdir": "linux-64", + "timestamp": 1598384307842, + "version": "2020.2" + }, + "daal-static-2021.2.2-h06a4308_389.conda": { + "build": "h06a4308_389", + "build_number": 389, + "depends": [ + "dal-static >=2021.2.2,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "fbd1e2e3809e063c233343096851f455", + "name": "daal-static", + "sha256": "5af1f4a568f2142b4813c98357a267e4ad50b978f514b591f92950030e0a3128", + "size": 15951, + "subdir": "linux-64", + "timestamp": 1619451487731, + "version": "2021.2.2" + }, + "daal-static-2021.3.0-h06a4308_557.conda": { + "build": "h06a4308_557", + "build_number": 557, + "depends": [ + "dal-static >=2021.3.0,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "95069d7b58f97e8d5dc085e1a259eb58", + "name": "daal-static", + "sha256": "b8391d3aff0e69b64b6b93c66118ba63433369750ff48cf177f88e51f22e9c07", + "size": 15944, + "subdir": "linux-64", + "timestamp": 1626182867666, + "version": "2021.3.0" + }, + "daal-static-2021.4.0-h06a4308_729.conda": { + "build": "h06a4308_729", + "build_number": 729, + "depends": [ + "dal-static >=2021.4.0,<2022.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "92bb9b5ab1c5bbdd0056caba011010a9", + "name": "daal-static", + "sha256": "99c901351aa051dd2c4a3351689e10b56a0591d465340ae8dc85c3a0a0cc4845", + "size": 19674, + "subdir": "linux-64", + "timestamp": 1634547336292, + "version": "2021.4.0" + }, + "daal-static-2021.5.1-h06a4308_803.conda": { + "build": "h06a4308_803", + "build_number": 803, + "depends": [ + "dal-static >=2021.5.1,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "a628edcbf751250c8e64483921a6e1c6", + "name": "daal-static", + "sha256": "3ca7f2e710fe46704d96345b7e256beb9dd0c87dcbcdf62356a53b3d7940f93f", + "size": 20348, + "subdir": "linux-64", + "timestamp": 1642705973048, + "version": "2021.5.1" + }, + "daal-static-2021.5.3-h06a4308_833.conda": { + "build": "h06a4308_833", + "build_number": 833, + "depends": [ + "dal-static >=2021.6.0,<2022.0a0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "43dd0dc4bcbe6b6b10c78675fb937a89", + "name": "daal-static", + "sha256": "4822f48ca87904c858afe8c08ea84bc83ee32afdd05b472575527672fa1f09c8", + "size": 18613, + "subdir": "linux-64", + "timestamp": 1662498033717, + "version": "2021.5.3" + }, + "daal4py-2021.2.2-py36ha9443f7_0.conda": { + "build": "py36ha9443f7_0", + "build_number": 0, + "depends": [ + "dal >=2021.2.2,<2021.2.3.0a0", + "dal >=2021.2.2,<2022.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "0355d46f0bf2eba9348aedf7672554b1", + "name": "daal4py", + "sha256": "2e900fd0b87f994ff835ee18393ca5c07a88b74d9f5cb21ff1f34ff7d5930027", + "size": 8817833, + "subdir": "linux-64", + "timestamp": 1619794968395, + "version": "2021.2.2" + }, + "daal4py-2021.2.2-py37ha9443f7_0.conda": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "dal >=2021.2.2,<2021.2.3.0a0", + "dal >=2021.2.2,<2022.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "18586196c2601068c7cd49222696fae3", + "name": "daal4py", + "sha256": "03917deaa3e314967a1ff9282a238902a1672ccee45171e8cc384d4ac76ef1cc", + "size": 8833863, + "subdir": "linux-64", + "timestamp": 1619794950600, + "version": "2021.2.2" + }, + "daal4py-2021.2.2-py38ha9443f7_0.conda": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "dal >=2021.2.2,<2021.2.3.0a0", + "dal >=2021.2.2,<2022.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "af5253abf4b712ee59eb417c75eb0230", + "name": "daal4py", + "sha256": "256f352dd8364af628ad7e2e232ad238ef71fecb9030d7a14cd0501c69a02823", + "size": 8865917, + "subdir": "linux-64", + "timestamp": 1619794977069, + "version": "2021.2.2" + }, + "daal4py-2021.2.2-py39ha9443f7_0.conda": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "dal >=2021.2.2,<2021.2.3.0a0", + "dal >=2021.2.2,<2022.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "f805dbbe963b2e6f58ee1b146ed87c04", + "name": "daal4py", + "sha256": "6781107b74fb919052b49c8bbb57f357db49b5cef2514e31b7dc3a5c87257947", + "size": 8865138, + "subdir": "linux-64", + "timestamp": 1619791204527, + "version": "2021.2.2" + }, + "daal4py-2021.3.0-py36hae6d005_0.conda": { + "build": "py36hae6d005_0", + "build_number": 0, + "depends": [ + "dal >=2021.3.0,<2021.3.1.0a0", + "dal >=2021.3.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "6bd11340b181776c33d8adf3f058e1bc", + "name": "daal4py", + "sha256": "e3d935e509772c4ebb5eece0d7146397edf4c6cb77983d23a446ba3cd00c2ccb", + "size": 8997918, + "subdir": "linux-64", + "timestamp": 1626272868402, + "version": "2021.3.0" + }, + "daal4py-2021.3.0-py37hae6d005_0.conda": { + "build": "py37hae6d005_0", + "build_number": 0, + "depends": [ + "dal >=2021.3.0,<2021.3.1.0a0", + "dal >=2021.3.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "efbc333e061b504d8061e3681c0c096a", + "name": "daal4py", + "sha256": "7dc5978ad44217c7c51e4f1c53e51c5e2b9521f846bb139cc357bf50503f1a09", + "size": 8988758, + "subdir": "linux-64", + "timestamp": 1626272844358, + "version": "2021.3.0" + }, + "daal4py-2021.3.0-py38hae6d005_0.conda": { + "build": "py38hae6d005_0", + "build_number": 0, + "depends": [ + "dal >=2021.3.0,<2021.3.1.0a0", + "dal >=2021.3.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "d34182e692ac10a6458f76e16f29001a", + "name": "daal4py", + "sha256": "ec8cd39e9c73b875c77f0bd4ac9e0a846ade457042e6d4c914a498d5cc67bd81", + "size": 8996503, + "subdir": "linux-64", + "timestamp": 1626272457850, + "version": "2021.3.0" + }, + "daal4py-2021.3.0-py39hae6d005_0.conda": { + "build": "py39hae6d005_0", + "build_number": 0, + "depends": [ + "dal >=2021.3.0,<2021.3.1.0a0", + "dal >=2021.3.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "d51fed539f1b40d8a403e884d2775969", + "name": "daal4py", + "sha256": "d7fb3850b2c11399c742d2883fad928681461cff1d2f5775b7aa083953fd9276", + "size": 9011124, + "subdir": "linux-64", + "timestamp": 1626272853486, + "version": "2021.3.0" + }, + "daal4py-2021.4.0-py310h00b725a_0.conda": { + "build": "py310h00b725a_0", + "build_number": 0, + "depends": [ + "dal 2021.4.0.*", + "dal >=2021.4.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "51f5137dbbf5a0be75bd40c2c5752b0b", + "name": "daal4py", + "sha256": "dee618818808ddac3dab7fc16df6660bc964478c21ad75ca9dac1e898eddbcc2", + "size": 16862289, + "subdir": "linux-64", + "timestamp": 1640805351352, + "version": "2021.4.0" + }, + "daal4py-2021.4.0-py37h78b71dc_0.conda": { + "build": "py37h78b71dc_0", + "build_number": 0, + "depends": [ + "dal 2021.4.0.*", + "dal >=2021.4.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "1b8e3990a35e032f29fe1f50a60738df", + "name": "daal4py", + "sha256": "6e06fa7b15348180969f470bc03a8ebe336af3135d7ea25006e5b0fd4bc40e2b", + "size": 9163166, + "subdir": "linux-64", + "timestamp": 1638306307426, + "version": "2021.4.0" + }, + "daal4py-2021.4.0-py38h78b71dc_0.conda": { + "build": "py38h78b71dc_0", + "build_number": 0, + "depends": [ + "dal 2021.4.0.*", + "dal >=2021.4.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "66845e46604562ecb67db572d1dd7c35", + "name": "daal4py", + "sha256": "5cde1f48b1d3dbdf117bfc7480573d07bf5fa2ecbbab6b43080fad03f69dff95", + "size": 9204266, + "subdir": "linux-64", + "timestamp": 1638306197776, + "version": "2021.4.0" + }, + "daal4py-2021.4.0-py39h78b71dc_0.conda": { + "build": "py39h78b71dc_0", + "build_number": 0, + "depends": [ + "dal 2021.4.0.*", + "dal >=2021.4.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "4ca6610717f032db9102cebbbd4ac4c1", + "name": "daal4py", + "sha256": "f9f7584abd3c5262772f243b87806e6e0a5d54cbafa2b95b3572b342f767e309", + "size": 9203358, + "subdir": "linux-64", + "timestamp": 1638306274736, + "version": "2021.4.0" + }, + "daal4py-2021.5.0-py37h78b71dc_0.conda": { + "build": "py37h78b71dc_0", + "build_number": 0, + "depends": [ + "dal 2021.5.1.*", + "dal >=2021.5.1,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "ecfec74f76a9f0a232ccafdc920928c2", + "name": "daal4py", + "sha256": "4a3954f637ad3633a5dea24343ec4c7c43cdb661981ef4a9621d8ba3e643ffef", + "size": 9237964, + "subdir": "linux-64", + "timestamp": 1644854009330, + "version": "2021.5.0" + }, + "daal4py-2021.5.0-py38h78b71dc_0.conda": { + "build": "py38h78b71dc_0", + "build_number": 0, + "depends": [ + "dal 2021.5.1.*", + "dal >=2021.5.1,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "70122cc4b54a120c0e979bc793567d96", + "name": "daal4py", + "sha256": "ae1d3e94d4d3e45dda5ccbcc13f87d21b05c74b86f25761c7c810bb69bca9f9b", + "size": 9272272, + "subdir": "linux-64", + "timestamp": 1644835864053, + "version": "2021.5.0" + }, + "daal4py-2021.5.0-py39h78b71dc_0.conda": { + "build": "py39h78b71dc_0", + "build_number": 0, + "depends": [ + "dal 2021.5.1.*", + "dal >=2021.5.1,<2022.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "c1d3a84caf48d10942b3085b35eaa561", + "name": "daal4py", + "sha256": "16fc7841868f79472ec116b6f0cca4a8af90b2d2744eaf746ec2486c6cb9b203", + "size": 9273255, + "subdir": "linux-64", + "timestamp": 1644853994003, + "version": "2021.5.0" + }, + "daal4py-2021.6.0-py310h3c18c91_0.conda": { + "build": "py310h3c18c91_0", + "build_number": 0, + "depends": [ + "dal ==2021.6.0 hdb19cb5_916", + "dal >=2021.6.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "47427880c32ba9cc47ab3b41b50c3ece", + "name": "daal4py", + "sha256": "9f7984ba9fda50ef4df2c3a9e5a21d41f4cc11a121291e19f2baa7a296f4bd7a", + "size": 18951622, + "subdir": "linux-64", + "timestamp": 1664228496522, + "version": "2021.6.0" + }, + "daal4py-2021.6.0-py310h3c18c91_1.conda": { + "build": "py310h3c18c91_1", + "build_number": 1, + "depends": [ + "dal ==2021.6.0 hdb19cb5_916", + "dal >=2021.6.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "faaf205868594788ea589f0852089216", + "name": "daal4py", + "sha256": "1ae65f48a0d64de3cfecb79033903ab1fc6a71518094f444cfb0d8d15b5673d0", + "size": 18922146, + "subdir": "linux-64", + "timestamp": 1664830724086, + "version": "2021.6.0" + }, + "daal4py-2021.6.0-py37h79cecc1_0.conda": { + "build": "py37h79cecc1_0", + "build_number": 0, + "depends": [ + "dal ==2021.6.0 hdb19cb5_916", + "dal >=2021.6.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b5bcc433266462fff0ac2cbef1822e15", + "name": "daal4py", + "sha256": "573048be55841b07d75df602354f5dcf7856329457acbe124b1e5880d474039d", + "size": 9310168, + "subdir": "linux-64", + "timestamp": 1664227899693, + "version": "2021.6.0" + }, + "daal4py-2021.6.0-py37h79cecc1_1.conda": { + "build": "py37h79cecc1_1", + "build_number": 1, + "depends": [ + "dal ==2021.6.0 hdb19cb5_916", + "dal >=2021.6.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d2ca90914e445dea431f7273ad119417", + "name": "daal4py", + "sha256": "02a211b213606f96b9466ebe19c16604b20ceaf688ee2f3ad68f861d1c09c810", + "size": 9558689, + "subdir": "linux-64", + "timestamp": 1664830131169, + "version": "2021.6.0" + }, + "daal4py-2021.6.0-py38h79cecc1_0.conda": { + "build": "py38h79cecc1_0", + "build_number": 0, + "depends": [ + "dal ==2021.6.0 hdb19cb5_916", + "dal >=2021.6.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ed935472d86cc35287b3a90304f15ec4", + "name": "daal4py", + "sha256": "e7329cca5da26b43d0153aa4e453dc2ca4bc8a5fdfcb0865eae849be19391a56", + "size": 9344723, + "subdir": "linux-64", + "timestamp": 1664228187239, + "version": "2021.6.0" + }, + "daal4py-2021.6.0-py38h79cecc1_1.conda": { + "build": "py38h79cecc1_1", + "build_number": 1, + "depends": [ + "dal ==2021.6.0 hdb19cb5_916", + "dal >=2021.6.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "38d4170a1a47431c02cf8c8a11f930ab", + "name": "daal4py", + "sha256": "0b8af95b10f52a0c59e858de93cafb52ce59fb6c3b5c4782a104d7acd1b4eb8e", + "size": 9586635, + "subdir": "linux-64", + "timestamp": 1664829825882, + "version": "2021.6.0" + }, + "daal4py-2021.6.0-py39h79cecc1_0.conda": { + "build": "py39h79cecc1_0", + "build_number": 0, + "depends": [ + "dal ==2021.6.0 hdb19cb5_916", + "dal >=2021.6.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f2e92ca25564cbf435e3c721ac3da32d", + "name": "daal4py", + "sha256": "401909b15f77f57bc566cd132de56b4263194a2e312ed607dd0f1884a11dd135", + "size": 9595259, + "subdir": "linux-64", + "timestamp": 1664227579133, + "version": "2021.6.0" + }, + "daal4py-2021.6.0-py39h79cecc1_1.conda": { + "build": "py39h79cecc1_1", + "build_number": 1, + "depends": [ + "dal ==2021.6.0 hdb19cb5_916", + "dal >=2021.6.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c869edf0b690323214f2d0eeee6e55b8", + "name": "daal4py", + "sha256": "59e7045fa01db9895e34dc0d31d57590e11db88d8b492ec98bfafbeecc92f2f9", + "size": 9589403, + "subdir": "linux-64", + "timestamp": 1664830402894, + "version": "2021.6.0" + }, + "daal4py-2023.0.2-py310h3c18c91_0.conda": { + "build": "py310h3c18c91_0", + "build_number": 0, + "depends": [ + "dal 2023.0.1.*", + "dal >=2023.0.1,<2024.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "86494487b009fce5973a016c5f2a7c73", + "name": "daal4py", + "sha256": "89977347b5c5a862a2fe5ab575825b1c93e9ee214164e5bcf670be711863fb07", + "size": 12243351, + "subdir": "linux-64", + "timestamp": 1677604431121, + "version": "2023.0.2" + }, + "daal4py-2023.0.2-py311heed92f4_0.conda": { + "build": "py311heed92f4_0", + "build_number": 0, + "depends": [ + "dal 2023.0.1.*", + "dal >=2023.0.1,<2024.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1e51eb352c4169093c5c9f23ae99ed33", + "name": "daal4py", + "sha256": "81babb4f587320dd964c772c72a89ca11f1b3fc706d148270389eaa601fad91b", + "size": 10671448, + "subdir": "linux-64", + "timestamp": 1678300835045, + "version": "2023.0.2" + }, + "daal4py-2023.0.2-py38h79cecc1_0.conda": { + "build": "py38h79cecc1_0", + "build_number": 0, + "depends": [ + "dal 2023.0.1.*", + "dal >=2023.0.1,<2024.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "94d39351df6c85d73d6069b18753aa7e", + "name": "daal4py", + "sha256": "b069dee62cc44258c8a240f442b83c1cd045fa5f939487e60f78df8bc1f1207f", + "size": 12270615, + "subdir": "linux-64", + "timestamp": 1677604916664, + "version": "2023.0.2" + }, + "daal4py-2023.0.2-py39h79cecc1_0.conda": { + "build": "py39h79cecc1_0", + "build_number": 0, + "depends": [ + "dal 2023.0.1.*", + "dal >=2023.0.1,<2024.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mpich >=3.3.2,<3.4.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6d62a4a6fd2e0ef232c5232b57eded16", + "name": "daal4py", + "sha256": "1d0d63a58f9919ab13ba85f3c49b58dacb015dab823f2013f4486b4a03207017", + "size": 12251892, + "subdir": "linux-64", + "timestamp": 1677605429450, + "version": "2023.0.2" + }, + "dal-2021.2.2-h06a4308_389.conda": { + "build": "h06a4308_389", + "build_number": 389, + "depends": [ + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "856f182609b3c650995fd98d43d0c468", + "name": "dal", + "sha256": "c4e940965176efbeb64df5b3aae82b3315db48edf72c7f2a425ed59266e9058e", + "size": 42636527, + "subdir": "linux-64", + "timestamp": 1619450593041, + "version": "2021.2.2" + }, + "dal-2021.3.0-h06a4308_557.conda": { + "build": "h06a4308_557", + "build_number": 557, + "depends": [ + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "d2124416eac3ac9dbdf0d04e2a5afacc", + "name": "dal", + "sha256": "a13d8c13aa29afaaeb1d2ddfb959b09ec118c1d5b397c6cd02e6cadc694d93c8", + "size": 41093955, + "subdir": "linux-64", + "timestamp": 1626182192769, + "version": "2021.3.0" + }, + "dal-2021.4.0-h06a4308_729.conda": { + "build": "h06a4308_729", + "build_number": 729, + "depends": [ + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "ce04fde8836b430b91e37fbdf6afee50", + "name": "dal", + "sha256": "c0340179c4dcacae86cb414275a1d0594c04a86aa6f1f092368e1bc59a0d83fd", + "size": 40847618, + "subdir": "linux-64", + "timestamp": 1634546657748, + "version": "2021.4.0" + }, + "dal-2021.5.1-h06a4308_803.conda": { + "build": "h06a4308_803", + "build_number": 803, + "depends": [ + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "166a9a72b76a2121f8c9299b2fc235c0", + "name": "dal", + "sha256": "97441072e33062126b5a57fc14bce71b5a25176d987e9347ad9bb45b020f1d8b", + "size": 37026404, + "subdir": "linux-64", + "timestamp": 1642705328174, + "version": "2021.5.1" + }, + "dal-2021.6.0-hdb19cb5_916.conda": { + "build": "hdb19cb5_916", + "build_number": 916, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "749997318b72dc7f783d24de2bd4f250", + "name": "dal", + "sha256": "1e602c06dd97e411b5b55a55b0af3eb468f85fe4cb2990f3117179206a726e3e", + "size": 37268541, + "subdir": "linux-64", + "timestamp": 1662497571830, + "version": "2021.6.0" + }, + "dal-2023.0.1-hdb19cb5_26647.conda": { + "build": "hdb19cb5_26647", + "build_number": 26647, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "02c73c028bfc44063c7405d1e3b6b051", + "name": "dal", + "sha256": "80b500b1b60eb1efba320bc5fbd1251b8d68691445b9f0ba0ac66cd0a49cf11f", + "size": 49486464, + "subdir": "linux-64", + "timestamp": 1677516427897, + "version": "2023.0.1" + }, + "dal-devel-2021.2.2-h06a4308_389.conda": { + "build": "h06a4308_389", + "build_number": 389, + "depends": [ + "dal 2021.2.2 h06a4308_389", + "dal-include 2021.2.2 h06a4308_389" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "0943fcb86268412a422722fe2c027fd4", + "name": "dal-devel", + "sha256": "304bc5817c8045a4e9ba867e3c487836b4f38fdd195fbfa8dc0dc6a9ba128aa4", + "size": 18347, + "subdir": "linux-64", + "timestamp": 1619450730892, + "version": "2021.2.2" + }, + "dal-devel-2021.3.0-h06a4308_557.conda": { + "build": "h06a4308_557", + "build_number": 557, + "depends": [ + "dal 2021.3.0 h06a4308_557", + "dal-include 2021.3.0 h06a4308_557" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "109e6b10a2db51721f3e659d0fb428c2", + "name": "dal-devel", + "sha256": "549a391eb5cee716b31ac8c70fbf335b3de8ebc5dd6865d7d76a8643d25b9ecd", + "size": 4001782, + "subdir": "linux-64", + "timestamp": 1626182308121, + "version": "2021.3.0" + }, + "dal-devel-2021.4.0-h06a4308_729.conda": { + "build": "h06a4308_729", + "build_number": 729, + "depends": [ + "dal 2021.4.0 h06a4308_729", + "dal-include 2021.4.0 h06a4308_729" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "24d5dd943ba2a193510d72c0fc9ce05c", + "name": "dal-devel", + "sha256": "e282e4f893237874886bb217422455c5260b86ac12c0970dc72553948784ec95", + "size": 4197153, + "subdir": "linux-64", + "timestamp": 1634546777134, + "version": "2021.4.0" + }, + "dal-devel-2021.5.1-h06a4308_803.conda": { + "build": "h06a4308_803", + "build_number": 803, + "depends": [ + "dal 2021.5.1 h06a4308_803", + "dal-include 2021.5.1 h06a4308_803" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "f09ef87f8f9a2466885ed24308167c65", + "name": "dal-devel", + "sha256": "bd5fcef2b6b7515019aeb197235215860707b4c9f92ebb78190d75d00a02c373", + "size": 4130790, + "subdir": "linux-64", + "timestamp": 1642705457040, + "version": "2021.5.1" + }, + "dal-devel-2021.6.0-hdb19cb5_916.conda": { + "build": "hdb19cb5_916", + "build_number": 916, + "depends": [ + "dal 2021.6.0 hdb19cb5_916", + "dal-include 2021.6.0 h06a4308_916", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "505a306038cba5e544490a6eb019f222", + "name": "dal-devel", + "sha256": "a4762271fef500b4b0b2d06ce5eeb71aca24ea5952bc345944d6345402aa2b3b", + "size": 9365942, + "subdir": "linux-64", + "timestamp": 1662497683321, + "version": "2021.6.0" + }, + "dal-devel-2023.0.1-hdb19cb5_26647.conda": { + "build": "hdb19cb5_26647", + "build_number": 26647, + "depends": [ + "dal 2023.0.1 hdb19cb5_26647", + "dal-include 2023.0.1 h06a4308_26647", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "b0afe60076ac168fc4cacbc80c226671", + "name": "dal-devel", + "sha256": "bf89a118c9f8202ff4f9c99af2b3737276b81ecba941c3d722b62ba930c6b1fc", + "size": 5166813, + "subdir": "linux-64", + "timestamp": 1677516529341, + "version": "2023.0.1" + }, + "dal-include-2021.2.2-h06a4308_389.conda": { + "build": "h06a4308_389", + "build_number": 389, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "fc671cf90d3e20c3afb6cb94cbea60ae", + "name": "dal-include", + "sha256": "d470b590807f60fe35c4cf5107c13cd570efb17d5d09ad261fb7d9538f5e5509", + "size": 363759, + "subdir": "linux-64", + "timestamp": 1619450713265, + "version": "2021.2.2" + }, + "dal-include-2021.3.0-h06a4308_557.conda": { + "build": "h06a4308_557", + "build_number": 557, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "ad45f6eb5124af6934000a663f8cfeba", + "name": "dal-include", + "sha256": "f585aaf7e350618de3d5756c8f855ec863a6a89eea3a0dfd8e33df5ccdc2db3f", + "size": 383483, + "subdir": "linux-64", + "timestamp": 1626182291438, + "version": "2021.3.0" + }, + "dal-include-2021.4.0-h06a4308_729.conda": { + "build": "h06a4308_729", + "build_number": 729, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "6e2fc11610b0b5865de63ffad1b40e68", + "name": "dal-include", + "sha256": "a9bdf8e540f06b6a6cbd4dfdcb4e124510aeecccbaa48380c2ed2ff721e65acd", + "size": 389114, + "subdir": "linux-64", + "timestamp": 1634546755565, + "version": "2021.4.0" + }, + "dal-include-2021.5.1-h06a4308_803.conda": { + "build": "h06a4308_803", + "build_number": 803, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "aa297e09e0d4f977767923866f6878fe", + "name": "dal-include", + "sha256": "6006aa88a6aab4c21f4a317f2aa55bd520b6e5fa416d148b87691a7e448a3dbd", + "size": 397807, + "subdir": "linux-64", + "timestamp": 1642705434991, + "version": "2021.5.1" + }, + "dal-include-2021.6.0-h06a4308_916.conda": { + "build": "h06a4308_916", + "build_number": 916, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "796baaf8dfa234a1df91cf8d70bab98e", + "name": "dal-include", + "sha256": "ae1b536784c46c876a1aa3c5d0c060e6e78a05e521687e914f2ae2549a396f3e", + "size": 398008, + "subdir": "linux-64", + "timestamp": 1662497655070, + "version": "2021.6.0" + }, + "dal-include-2023.0.1-h06a4308_26647.conda": { + "build": "h06a4308_26647", + "build_number": 26647, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "5dbd818e84e155882f6e947421a542c0", + "name": "dal-include", + "sha256": "7308dc1c05c203d4456f12f67dbbe76166d59b69eb1c8f85eca6a51073670476", + "size": 430189, + "subdir": "linux-64", + "timestamp": 1677516497343, + "version": "2023.0.1" + }, + "dal-static-2021.2.2-h06a4308_389.conda": { + "build": "h06a4308_389", + "build_number": 389, + "depends": [ + "dal-include 2021.2.2 h06a4308_389", + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "87af17b4ce98cb3070cbc29a458431b1", + "name": "dal-static", + "sha256": "d88149e5846f56bae82ac432ea0d28441bf19c4d6a6f4cebc7133c4a93435606", + "size": 82995109, + "subdir": "linux-64", + "timestamp": 1619450736494, + "version": "2021.2.2" + }, + "dal-static-2021.3.0-h06a4308_557.conda": { + "build": "h06a4308_557", + "build_number": 557, + "depends": [ + "dal-include 2021.3.0 h06a4308_557", + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "98f5816fd8cba8f98d8eac73ebec930a", + "name": "dal-static", + "sha256": "aa67ccb9bf7c111903c504a0fde64e88906049e0f5dd0ccc67b038df113b13f7", + "size": 85224667, + "subdir": "linux-64", + "timestamp": 1626182332261, + "version": "2021.3.0" + }, + "dal-static-2021.4.0-h06a4308_729.conda": { + "build": "h06a4308_729", + "build_number": 729, + "depends": [ + "dal-include 2021.4.0 h06a4308_729", + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "598f1d4a0a40355dd6f886dd77b5c5ad", + "name": "dal-static", + "sha256": "eb35ac5ba37fbfd0743e620f009ecf8284607a458f88b9402da7ebeeadb916cd", + "size": 77625468, + "subdir": "linux-64", + "timestamp": 1634546801991, + "version": "2021.4.0" + }, + "dal-static-2021.5.1-h06a4308_803.conda": { + "build": "h06a4308_803", + "build_number": 803, + "depends": [ + "dal-include 2021.5.1 h06a4308_803", + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "3a27f937e852b0b504a37b76e78830e3", + "name": "dal-static", + "sha256": "96719bfc50716f6212dce67968450a6cc2d020ff4f46c1a39085b43be04df195", + "size": 73696899, + "subdir": "linux-64", + "timestamp": 1642705490332, + "version": "2021.5.1" + }, + "dal-static-2021.6.0-hdb19cb5_916.conda": { + "build": "hdb19cb5_916", + "build_number": 916, + "depends": [ + "dal-include 2021.6.0 h06a4308_916", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "9e832705d1c274df460dcf4341c92838", + "name": "dal-static", + "sha256": "3a5d8b5ba2998280483d278acc4d3c7db587cc467c133b91063dc94c2a12cfcd", + "size": 74117422, + "subdir": "linux-64", + "timestamp": 1662497717343, + "version": "2021.6.0" + }, + "dal-static-2023.0.1-hdb19cb5_26647.conda": { + "build": "hdb19cb5_26647", + "build_number": 26647, + "depends": [ + "dal-include 2023.0.1 h06a4308_26647", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.*" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "8ad300150e1275cb2106389ac30617e8", + "name": "dal-static", + "sha256": "260bfab0c72609c6bf47f8fd9d14c7b3f533ccf6dcd75501e8cdc69f8ecc2eaf", + "size": 96862819, + "subdir": "linux-64", + "timestamp": 1677516545106, + "version": "2023.0.1" + }, + "dash-2.7.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "dash-table ==5.0.0", + "dash-core-components ==2.0.0", + "dash-html-components ==2.0.0" + ], + "depends": [ + "flask >=1.0.4", + "flask-compress", + "plotly >=5.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b125d1d5f82cada764fdfafc3d44596", + "name": "dash", + "sha256": "176bd5ac61e199013694dc546dfc8a563433f96fcf455a702614774036cebdf9", + "size": 6758073, + "subdir": "linux-64", + "timestamp": 1669048547333, + "version": "2.7.0" + }, + "dash-2.7.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "dash-html-components ==2.0.0", + "dash-table ==5.0.0", + "dash-core-components ==2.0.0" + ], + "depends": [ + "flask >=1.0.4", + "flask-compress", + "plotly >=5.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4713af887aa410cb8e9f143aec147428", + "name": "dash", + "sha256": "91f91aed63d436381d21e61a97906c4607abc618e108f36f5615b7e2ac95bf01", + "size": 6151332, + "subdir": "linux-64", + "timestamp": 1676843923383, + "version": "2.7.0" + }, + "dash-2.7.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "dash-table ==5.0.0", + "dash-core-components ==2.0.0", + "dash-html-components ==2.0.0" + ], + "depends": [ + "flask >=1.0.4", + "flask-compress", + "plotly >=5.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f627f061b24b7019131069a2be36373", + "name": "dash", + "sha256": "859869d9dfcc693023c8af4cb73b23964de0968ad874c5646ea0ec194ecfc8ba", + "size": 6756808, + "subdir": "linux-64", + "timestamp": 1669048481676, + "version": "2.7.0" + }, + "dash-2.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "dash-table ==5.0.0", + "dash-core-components ==2.0.0", + "dash-html-components ==2.0.0" + ], + "depends": [ + "flask >=1.0.4", + "flask-compress", + "plotly >=5.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5824533cc817bac9ac4d0e122693fd65", + "name": "dash", + "sha256": "f933c304f3c500bdb86a3bfdaad427647dc94278e9498b36d7fb65a909388fb0", + "size": 6758601, + "subdir": "linux-64", + "timestamp": 1669048611665, + "version": "2.7.0" + }, + "dash-2.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "dash-table ==5.0.0", + "dash-core-components ==2.0.0", + "dash-html-components ==2.0.0" + ], + "depends": [ + "flask >=1.0.4", + "flask-compress", + "plotly >=5.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5225cc83b10a41f31549f8d942af0a6b", + "name": "dash", + "sha256": "b01c3804e1586aaebf0134999b89c857509a77632c6eb931855ae45cceb4bf5c", + "size": 6753885, + "subdir": "linux-64", + "timestamp": 1669048418711, + "version": "2.7.0" + }, + "dash-bio-0.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "dash >=1.0.0", + "pandas", + "plotly", + "python >=2.7,<2.8.0a0", + "scikit-learn >=0.20.1", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "599d2c18e46fc593d2bf8d043fcf230e", + "name": "dash-bio", + "sha256": "cec1272976adfd1386ce87a65a40f4b0e8649cc7bc66eb19a57c971842694b4d", + "size": 1153973, + "subdir": "linux-64", + "timestamp": 1576596552557, + "version": "0.2.0" + }, + "dash-bio-0.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dash >=1.0.0", + "pandas", + "plotly", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.20.1", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "93d88dc2e2265af71a39b67431960a53", + "name": "dash-bio", + "sha256": "493af94ea59906383da9b1b27afecedeb3a88d7689b33a22cc2bcc3766fcb5f3", + "size": 1153603, + "subdir": "linux-64", + "timestamp": 1640811896406, + "version": "0.2.0" + }, + "dash-bio-0.2.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "dash >=1.0.0", + "pandas", + "plotly", + "python >=3.11,<3.12.0a0", + "scikit-learn >=0.20.1", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c2254a778a58cf7ed7e4937e2c090bd", + "name": "dash-bio", + "sha256": "46648b1d6a08f882c936665a8a4c1cd071ef56d460f4a75811b1f019c31b448d", + "size": 1162913, + "subdir": "linux-64", + "timestamp": 1676851840888, + "version": "0.2.0" + }, + "dash-bio-0.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "dash >=1.0.0", + "pandas", + "plotly", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.20.1", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b59ca0ba3844612720c65ee6d0016e62", + "name": "dash-bio", + "sha256": "ff07db31761c07fea8c62281ef2cfbb08c01e7229b296917baa93450949beb93", + "size": 1154005, + "subdir": "linux-64", + "timestamp": 1576597017900, + "version": "0.2.0" + }, + "dash-bio-0.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dash >=1.0.0", + "pandas", + "plotly", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.20.1", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cac02b51c857ff490b7878a0d8787a07", + "name": "dash-bio", + "sha256": "40783b155f5ac5e656e739fdeab439e0ce6d01fac639f0a90b524de14546bf95", + "size": 1154686, + "subdir": "linux-64", + "timestamp": 1576596884936, + "version": "0.2.0" + }, + "dash-bio-0.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "dash >=1.0.0", + "pandas", + "plotly", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.20.1", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df73d01d6250d7e354ef456f45455afe", + "name": "dash-bio", + "sha256": "b0ff586a4c29398a62ab42d498d2c4dfc993533272d9eadcd0e2f084596258aa", + "size": 1154567, + "subdir": "linux-64", + "timestamp": 1576597139470, + "version": "0.2.0" + }, + "dask-0.15.2-py27h7693082_0.conda": { + "build": "py27h7693082_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.15.2.*", + "distributed >=1.16.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "6def0e9703da0c45f6499a79c59cfc1d", + "name": "dask", + "sha256": "14f6e75773928afb828ee16d5cda9cf2388659133ed29463d97e9a46f2c98e79", + "size": 3343, + "subdir": "linux-64", + "timestamp": 1505739872390, + "version": "0.15.2" + }, + "dask-0.15.2-py35h08b2748_0.conda": { + "build": "py35h08b2748_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.15.2.*", + "distributed >=1.16.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "747860d40d4df8f0ab6b79a26a5e8dd7", + "name": "dask", + "sha256": "ba4b764112cd7df1ed0b793d5b746fbbe856a997f868e8819e30adc7a5611fe4", + "size": 3357, + "subdir": "linux-64", + "timestamp": 1505739883742, + "version": "0.15.2" + }, + "dask-0.15.2-py36h9b48dc4_0.conda": { + "build": "py36h9b48dc4_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.15.2.*", + "distributed >=1.16.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "a24e5a3b4ab6c444fc4883bbe9b6b910", + "name": "dask", + "sha256": "cf8ee70d915f64e64b7d1b82ef1b6e75e9225531a4fda102c8e045ee0fad54bd", + "size": 3354, + "subdir": "linux-64", + "timestamp": 1505739895239, + "version": "0.15.2" + }, + "dask-0.15.3-py27hb94b45f_0.conda": { + "build": "py27hb94b45f_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.15.3.*", + "distributed >=1.19.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "2b098a643ba96710f5349ee23f745837", + "name": "dask", + "sha256": "64f08f3bffa4c32cca0f86bdc5d1c4f47c7a52df82fe4d85b40faa7445681379", + "size": 3803, + "subdir": "linux-64", + "timestamp": 1506624173873, + "version": "0.15.3" + }, + "dask-0.15.3-py35h52d6c43_0.conda": { + "build": "py35h52d6c43_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.15.3.*", + "distributed >=1.19.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "c662649e381e81589c6a097ed50b98b2", + "name": "dask", + "sha256": "9e1de70f249e7410f1f65e21c4d845a2f7f6be63cdb93ec468e3499410ddc752", + "size": 3839, + "subdir": "linux-64", + "timestamp": 1506624241516, + "version": "0.15.3" + }, + "dask-0.15.3-py36hdc2c8aa_0.conda": { + "build": "py36hdc2c8aa_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.15.3.*", + "distributed >=1.19.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "107ce5a2613edcbbb63dbe545adba23b", + "name": "dask", + "sha256": "bcd34841dbd5fb9472088cec221b86f8afdec762f1bddf677867c43de03ac81b", + "size": 3826, + "subdir": "linux-64", + "timestamp": 1506624227053, + "version": "0.15.3" + }, + "dask-0.15.4-py27hd41a479_0.conda": { + "build": "py27hd41a479_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.15.4.*", + "distributed >=1.19.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "12c0c12cbbe91b9a11650d870ea3e76e", + "name": "dask", + "sha256": "86c003bce742ba873e78a5a0776b0bfd1dc64b35c9039edf154c204150843e36", + "size": 3903, + "subdir": "linux-64", + "timestamp": 1510006299615, + "version": "0.15.4" + }, + "dask-0.15.4-py35h401027e_0.conda": { + "build": "py35h401027e_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.15.4.*", + "distributed >=1.19.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "effbd794aa5ff06def8e66eebd3c3bc7", + "name": "dask", + "sha256": "4bf90dd37601412da9eea0a67363e43e63b449597e5354c63ef7dcac2615e778", + "size": 3929, + "subdir": "linux-64", + "timestamp": 1510006310379, + "version": "0.15.4" + }, + "dask-0.15.4-py36h31fc154_0.conda": { + "build": "py36h31fc154_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.15.4.*", + "distributed >=1.19.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "72e635b559bb5d434395dfdc6c837910", + "name": "dask", + "sha256": "bbb498597c4284fff79a3d72da6c79a37254d0d7773043f8db34765e41f74c3b", + "size": 3891, + "subdir": "linux-64", + "timestamp": 1510006308934, + "version": "0.15.4" + }, + "dask-0.16.0-py27h8aa6184_0.conda": { + "build": "py27h8aa6184_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.16.0.*", + "distributed >=1.20.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "a2ae3b7b0e2166d2d74ce9d236fc48c3", + "name": "dask", + "sha256": "81cc58c84b7774afa5beffe92e1c76584beeadb744f75fa5d72a8846b2a7496e", + "size": 3966, + "subdir": "linux-64", + "timestamp": 1511196088249, + "version": "0.16.0" + }, + "dask-0.16.0-py35hcb8ecc8_0.conda": { + "build": "py35hcb8ecc8_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.16.0.*", + "distributed >=1.20.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "05003e028e93e5cdcbe0b1e24d364519", + "name": "dask", + "sha256": "4eb68cd3891cd787742d2691ca7833f249345de8859352803c8c36d9fc92110d", + "size": 3971, + "subdir": "linux-64", + "timestamp": 1511196156049, + "version": "0.16.0" + }, + "dask-0.16.0-py36h73d177f_0.conda": { + "build": "py36h73d177f_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.16.0.*", + "distributed >=1.20.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "17277b903614e85a50552722f8a07138", + "name": "dask", + "sha256": "b464d83983e3d1d1e72829aafde4e2427b6b55528e465f483dcf78330b87e1f0", + "size": 3969, + "subdir": "linux-64", + "timestamp": 1511196168252, + "version": "0.16.0" + }, + "dask-0.16.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.16.1.*", + "distributed >=1.20.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "1ca76ccbacf13c6fe00664359772a44e", + "name": "dask", + "sha256": "0fe8676b9b1aa4a3417d5625e09aecfe67909a1bf7946fa8e54909385b25810f", + "size": 3787, + "subdir": "linux-64", + "timestamp": 1515704584020, + "version": "0.16.1" + }, + "dask-0.16.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.16.1.*", + "distributed >=1.20.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "ca9b925bbfdf2d6dd749d8669961a81d", + "name": "dask", + "sha256": "a7c857d50bfa6700b61424ccd61635a01ee6805f7b4d7e64e7a461e6ba0a71c9", + "size": 3817, + "subdir": "linux-64", + "timestamp": 1515704922831, + "version": "0.16.1" + }, + "dask-0.16.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.16.1.*", + "distributed >=1.20.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "21d25282c7911058c52211a9f7dc7e80", + "name": "dask", + "sha256": "5010c10f5d69fae8da3c60e5c7ae7922f75cf7dc325e3ea5058e16190e871b31", + "size": 3776, + "subdir": "linux-64", + "timestamp": 1515704657685, + "version": "0.16.1" + }, + "dask-0.17.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.17.0.*", + "distributed >=1.21.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "8f39946b05c983d8c770071be7a7f6c4", + "name": "dask", + "sha256": "ab4e940465fd1d92b973bd5b88f66ca57af2c8bc4f0d9dd7a5c1ac95cb05a1ae", + "size": 3833, + "subdir": "linux-64", + "timestamp": 1518524603759, + "version": "0.17.0" + }, + "dask-0.17.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.17.0.*", + "distributed >=1.21.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "99b991f1ab74ee4ea1aa5e2cd8db571e", + "name": "dask", + "sha256": "55e570abb879d1f01d6e0f0277c2828eecbdc90efb7a06d31e9f79d2d9e7913c", + "size": 3844, + "subdir": "linux-64", + "timestamp": 1518524704909, + "version": "0.17.0" + }, + "dask-0.17.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.17.0.*", + "distributed >=1.21.0", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "baa78cfc3cae6d4e990741e047cd2c84", + "name": "dask", + "sha256": "68d990c153d63a951b9002259e44b099053513dff7ad6c5f4b6cb7defb16e107", + "size": 3831, + "subdir": "linux-64", + "timestamp": 1518524646862, + "version": "0.17.0" + }, + "dask-0.17.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.17.1.*", + "distributed >=1.21.1", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "f861175c944003c28ee116959cfea007", + "name": "dask", + "sha256": "b986f90482ebf8c4bc47c66a687d74c4b0fd46f3744d209fbc957523b7ec93ad", + "size": 3779, + "subdir": "linux-64", + "timestamp": 1519397947180, + "version": "0.17.1" + }, + "dask-0.17.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.17.1.*", + "distributed >=1.21.1", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "4777e7309d1f8c20264f7d2c9023b467", + "name": "dask", + "sha256": "46f11e38b30c3fba6849b0676aa37c4fe12e3dbde9c6675ec4b5ce0120cda170", + "size": 3770, + "subdir": "linux-64", + "timestamp": 1519397998413, + "version": "0.17.1" + }, + "dask-0.17.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "dask-core 0.17.1.*", + "distributed >=1.21.1", + "numpy >=1.10", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "b677850c7ac3c50111a3d24f15932d60", + "name": "dask", + "sha256": "269d479fd59e80710573d71c41137bcd5abfefb997d57e2bf9842f88a3234960", + "size": 3795, + "subdir": "linux-64", + "timestamp": 1519397912385, + "version": "0.17.1" + }, + "dask-0.17.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.2.*", + "distributed >=1.21.0", + "numpy >=1.10.4", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "b8af2e5179677405808cab2274d79db0", + "name": "dask", + "sha256": "f89897433f32a24271208afc3a45b42f270c7acffe1356082356e89a4dfbf36d", + "size": 3888, + "subdir": "linux-64", + "timestamp": 1521650426715, + "version": "0.17.2" + }, + "dask-0.17.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.2.*", + "distributed >=1.21.0", + "numpy >=1.10.4", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "753ce288448469935ddd150e0ff95dd9", + "name": "dask", + "sha256": "7fc414a5d91f5fd0391b32369b19e785b59d16675cb578dede45eb77d03710da", + "size": 3887, + "subdir": "linux-64", + "timestamp": 1521650514370, + "version": "0.17.2" + }, + "dask-0.17.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.2.*", + "distributed >=1.21.0", + "numpy >=1.10.4", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "317b4924f5986d8ddbb62ef1dd00c130", + "name": "dask", + "sha256": "adc00505381ebd0f28285b26a5fce987112a4f3155d928be027662acbe1531d1", + "size": 3853, + "subdir": "linux-64", + "timestamp": 1521650430536, + "version": "0.17.2" + }, + "dask-0.17.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.3.*", + "distributed >=1.21.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "4f60f783c0facf3a6711827ad1333606", + "name": "dask", + "sha256": "43dffbc3c6206209bc74b6f619df1dfb389cc58841289c895c310dff85486df6", + "size": 3855, + "subdir": "linux-64", + "timestamp": 1525292512747, + "version": "0.17.3" + }, + "dask-0.17.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.3.*", + "distributed >=1.21.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "59d4ae47d130ffc616a0d7f52db01e3f", + "name": "dask", + "sha256": "650d339230d063b07ae016a48b87b0391f5399a8e41fb031a927893437ba0680", + "size": 3827, + "subdir": "linux-64", + "timestamp": 1525292793163, + "version": "0.17.3" + }, + "dask-0.17.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.3.*", + "distributed >=1.21.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "77ab52cf1f33482cadeb0a5121edeb5b", + "name": "dask", + "sha256": "e945a500ca8043cc7f8dc5ec1615a177eaca117f99bca317e34efd3963be926e", + "size": 3853, + "subdir": "linux-64", + "timestamp": 1525292518713, + "version": "0.17.3" + }, + "dask-0.17.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.4.*", + "distributed >=1.21.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "fe7a667d50b09ed0c3fd32241dd57328", + "name": "dask", + "sha256": "c042015874ce97e685e68ca4be2cd8e688f81ef053a515ef6dce77f083e95cd4", + "size": 3869, + "subdir": "linux-64", + "timestamp": 1525471117824, + "version": "0.17.4" + }, + "dask-0.17.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.4.*", + "distributed >=1.21.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "d3d0cf16b32f77b1e6f8afb04a301b74", + "name": "dask", + "sha256": "7c964811f436cabff7cafbe8d371b7851979517a185f4f89fbfa7637a6b14a7b", + "size": 3874, + "subdir": "linux-64", + "timestamp": 1525471122323, + "version": "0.17.4" + }, + "dask-0.17.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.4.*", + "distributed >=1.21.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "ad1f385b554b37fd01742235bc532f87", + "name": "dask", + "sha256": "b521aeecd275a65f3dd1b9fdc83b6445edd683636c55c2b839e089e693047f57", + "size": 3870, + "subdir": "linux-64", + "timestamp": 1525471084452, + "version": "0.17.4" + }, + "dask-0.17.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.5.*", + "distributed >=1.21.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "4b21a623d7d23a9719200080a00d878c", + "name": "dask", + "sha256": "59cba2dd1f5446fb24cd6592dbd070558afd68d266a17539e739506bc4283143", + "size": 3818, + "subdir": "linux-64", + "timestamp": 1526527459308, + "version": "0.17.5" + }, + "dask-0.17.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.5.*", + "distributed >=1.21.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "a169dcecf19996ca3c199f3701050579", + "name": "dask", + "sha256": "56535b75e506a73921e175994af9cdf7589d2546b96cb6be09598ca7abd2026b", + "size": 3813, + "subdir": "linux-64", + "timestamp": 1526527408027, + "version": "0.17.5" + }, + "dask-0.17.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.17.5.*", + "distributed >=1.21.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "bdbea8e503ae812040049cde56dc0427", + "name": "dask", + "sha256": "581a39d4006c015cbef5b850cf153be1dfb450a7d08c5db75d4c183fec316bc1", + "size": 3855, + "subdir": "linux-64", + "timestamp": 1526527397946, + "version": "0.17.5" + }, + "dask-0.18.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.0.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "663651c8e2c870e3575286110b37d58a", + "name": "dask", + "sha256": "b69e6ff40885aea88a5d20876b8398ea4bb0a841aecb327017368fdacd4da95b", + "size": 3703, + "subdir": "linux-64", + "timestamp": 1529078269341, + "version": "0.18.0" + }, + "dask-0.18.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.0.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "b5339c9f1eb493c14a78a89b50dd8ed4", + "name": "dask", + "sha256": "5b7bcf37d6168196b1880b6cc9a6fe60258eac15e9b5cd023aada8727773618c", + "size": 3736, + "subdir": "linux-64", + "timestamp": 1529077757476, + "version": "0.18.0" + }, + "dask-0.18.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.0.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "1465ba8295dfdc11fa948156066a4071", + "name": "dask", + "sha256": "0ad6801a2081f5c2c74026cee65ca751e95a6419d362cf1021ceca0e351c325f", + "size": 3731, + "subdir": "linux-64", + "timestamp": 1529077964493, + "version": "0.18.0" + }, + "dask-0.18.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.1.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "ebb548c7e93a4420e962a06cc6e21585", + "name": "dask", + "sha256": "c2e43d52de1b8324ce51c16df9f45840fb855954e5d23d94a2c9aa95411fe4b4", + "size": 3746, + "subdir": "linux-64", + "timestamp": 1529768255877, + "version": "0.18.1" + }, + "dask-0.18.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.1.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "291a36ace9e007336c120a8bb8f4db0a", + "name": "dask", + "sha256": "9035c9655f94d5a12e0317bf48ef2ac9860166eeccb9ab5975a6d54579259586", + "size": 3741, + "subdir": "linux-64", + "timestamp": 1529768328172, + "version": "0.18.1" + }, + "dask-0.18.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.1.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "61a76980d8372b2c9084e7d495b35379", + "name": "dask", + "sha256": "63d8d1b32501d87e058363f2d2feb357564a1df2466bb44ab6bf6a7faaba98e7", + "size": 3776, + "subdir": "linux-64", + "timestamp": 1529934488671, + "version": "0.18.1" + }, + "dask-0.18.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.1.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "f736ea48dc46417423ff1fbb99455b02", + "name": "dask", + "sha256": "eddf631902522ca4039f050ec4b1e586f52e47a2464bcd245f79d6b503e6a001", + "size": 3660, + "subdir": "linux-64", + "timestamp": 1530741942844, + "version": "0.18.1" + }, + "dask-0.18.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.2.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "141012d2992c7110cabd296baad87945", + "name": "dask", + "sha256": "85c2a76a52b1ad5963324729e1191a743c53a35671f228356f1c587d47e1e347", + "size": 3611, + "subdir": "linux-64", + "timestamp": 1532441661706, + "version": "0.18.2" + }, + "dask-0.18.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.2.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "779fa20f864e3093ba8b6d60104ee2cf", + "name": "dask", + "sha256": "69c2ecd1dd82fe89b7ef34c7a23f037c5b2ed9895124a81a7d20e192dedc13bc", + "size": 3620, + "subdir": "linux-64", + "timestamp": 1532441803693, + "version": "0.18.2" + }, + "dask-0.18.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.2.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "d4480a9395c5433d649bb7db00f9aaae", + "name": "dask", + "sha256": "1a860171bd212b8c58fe2f5dee1ccd2dc5b96536d5c31521525a8036b69fda18", + "size": 3604, + "subdir": "linux-64", + "timestamp": 1532441476643, + "version": "0.18.2" + }, + "dask-0.18.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.18.2.*", + "distributed >=1.22.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "5e474c5f141caba5e7f93a1df659534b", + "name": "dask", + "sha256": "0701147d36c86891101ebdd3c7dd048561c5f185130d3bc61a3962c1f2e9cb1f", + "size": 3646, + "subdir": "linux-64", + "timestamp": 1532441537380, + "version": "0.18.2" + }, + "dask-0.19.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.0.*", + "distributed >=1.23.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "c4bc0e1b0cdd8acea3f192e3148e03df", + "name": "dask", + "sha256": "f82512f368c5f59da43a6296ea6f0e32eb81bf4bc8863e1df7e5e8075b4fe335", + "size": 3858, + "subdir": "linux-64", + "timestamp": 1535659109589, + "version": "0.19.0" + }, + "dask-0.19.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.0.*", + "distributed >=1.23.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "e89603a24800868b027c9b5446a2441e", + "name": "dask", + "sha256": "6acb526eb4422df4e23401ea5f0d0c8c2d3d055b7789e488f2233249b2be1f11", + "size": 3830, + "subdir": "linux-64", + "timestamp": 1535659197140, + "version": "0.19.0" + }, + "dask-0.19.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.0.*", + "distributed >=1.23.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "bbf4911e71c404ff44927eba9066adda", + "name": "dask", + "sha256": "1ea7a6975cfca851dbcbce74deebb8f3ba9453914738a9174e96d3faef299501", + "size": 3823, + "subdir": "linux-64", + "timestamp": 1535659104152, + "version": "0.19.0" + }, + "dask-0.19.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.0.*", + "distributed >=1.23.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "257169055e0c555b2cd32840d7de2dd9", + "name": "dask", + "sha256": "8c440d5e46086d2c549696e314091f6bd9f5d9da7ab90cc46d66d5a18bbaec9a", + "size": 3831, + "subdir": "linux-64", + "timestamp": 1535659192256, + "version": "0.19.0" + }, + "dask-0.19.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.1.*", + "distributed >=1.23.1", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "3cb0260b0f44c8774d8f10242381755c", + "name": "dask", + "sha256": "fd2c4134c71b9dd8db9807fc5b7ab69b4d14c5aa12ebe8c41d50a77c36ea02f8", + "size": 3839, + "subdir": "linux-64", + "timestamp": 1536250329401, + "version": "0.19.1" + }, + "dask-0.19.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.1.*", + "distributed >=1.23.1", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "8ae88a4ea9261be7d962198e09ae653b", + "name": "dask", + "sha256": "2587dec78676ad6d68e2e37b12b5726849e1fe06152b45345b200b14ef4aa32c", + "size": 3811, + "subdir": "linux-64", + "timestamp": 1536248991100, + "version": "0.19.1" + }, + "dask-0.19.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.1.*", + "distributed >=1.23.1", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "7dc3b661b9de3fc473f6817776fe512f", + "name": "dask", + "sha256": "19ff67733fdc91240d0ddbcbdc0010d540a10893d10505615322da789f1f43ca", + "size": 3806, + "subdir": "linux-64", + "timestamp": 1536248953295, + "version": "0.19.1" + }, + "dask-0.19.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.1.*", + "distributed >=1.23.1", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "a53d44334fdf8da63716061e67dc5276", + "name": "dask", + "sha256": "494edb9810476ec5880b44e437cf497e14ee44f069f1723f99631f788432c587", + "size": 3807, + "subdir": "linux-64", + "timestamp": 1536249003353, + "version": "0.19.1" + }, + "dask-0.19.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.2.*", + "distributed >=1.23.2", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "22d9f3fa537a72fd3a14a27db8ba8648", + "name": "dask", + "sha256": "bf2f0b0292af7e3a1bfc3e5df4a419dc845ff8219a65cc3aacb86ef91ac5527b", + "size": 3930, + "subdir": "linux-64", + "timestamp": 1538069293767, + "version": "0.19.2" + }, + "dask-0.19.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.2.*", + "distributed >=1.23.2", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "33d9b1832950cfb43ae448ef2cee3954", + "name": "dask", + "sha256": "9730b7ba4c9248bac25734b44c72e0d4185553af3df576818a03cfa44b8cef1b", + "size": 3896, + "subdir": "linux-64", + "timestamp": 1538069380126, + "version": "0.19.2" + }, + "dask-0.19.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.2.*", + "distributed >=1.23.2", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "7968d43d763663251cbaf4523ae651a3", + "name": "dask", + "sha256": "bc1b972f8b8ec1554509cc06cc61cf39d082ab6d6e88bad984fbbed94c0d376c", + "size": 3939, + "subdir": "linux-64", + "timestamp": 1538069350989, + "version": "0.19.2" + }, + "dask-0.19.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.2.*", + "distributed >=1.23.2", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "1e9b7a39b7af9eeff7962309bccd4e5a", + "name": "dask", + "sha256": "d8efb9b400085452486e0bd7eca6ccf823ffa1716b62a27983ea390276ff5f37", + "size": 3927, + "subdir": "linux-64", + "timestamp": 1538069243620, + "version": "0.19.2" + }, + "dask-0.19.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.3.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "592ca6b93e765c4d459fce251380137e", + "name": "dask", + "sha256": "5242fb950115cc7adba1f9a5d998ceab55c70bca17ddd956f03b2ce28adee9fb", + "size": 3984, + "subdir": "linux-64", + "timestamp": 1539017136512, + "version": "0.19.3" + }, + "dask-0.19.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.3.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "ff4ee77e7a614afb5f90efeff9919dbc", + "name": "dask", + "sha256": "3a207d93a7c5340123431c9cebf83de83fbcb3c2e7e9cecc61026865ad94c84d", + "size": 3979, + "subdir": "linux-64", + "timestamp": 1539017213285, + "version": "0.19.3" + }, + "dask-0.19.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.3.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "668e840b03eb7d83908ae780808ff913", + "name": "dask", + "sha256": "6f93f504877bb605db6ef0dd1a10b968784a85f9484e81bd0690fc754721b92f", + "size": 4002, + "subdir": "linux-64", + "timestamp": 1539017112614, + "version": "0.19.3" + }, + "dask-0.19.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.4.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "4b5f0315dfee51c70071f1f1e5333243", + "name": "dask", + "sha256": "2c42c2c254af0acc19556252ed4e53634ac432d271fdd142d42bc93cf16dbcb7", + "size": 3960, + "subdir": "linux-64", + "timestamp": 1539632869828, + "version": "0.19.4" + }, + "dask-0.19.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.4.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "8d7df0b9650e3d185128abe8e76ea2cf", + "name": "dask", + "sha256": "3e7cc11f79a1af17bc15af76d4eb1c0b8bc0cbec5742e1675f1a2322607e48a1", + "size": 3986, + "subdir": "linux-64", + "timestamp": 1539632883834, + "version": "0.19.4" + }, + "dask-0.19.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.19.4.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "86d0694d5a3b3b8613afa127a6ca4f0f", + "name": "dask", + "sha256": "539990ac2b7469b59396acaf56406ddb88a263475c5dcd9745e1134254d94d37", + "size": 3961, + "subdir": "linux-64", + "timestamp": 1539632882282, + "version": "0.19.4" + }, + "dask-0.20.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.20.0.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "a6d9be1cef65922bf9d4938cfcd630f6", + "name": "dask", + "sha256": "0f493422ed76a1ec93c4c461fe3a3a3cd2f737e276fdccda3e70ccb66b8ad3c9", + "size": 3981, + "subdir": "linux-64", + "timestamp": 1540830896518, + "version": "0.20.0" + }, + "dask-0.20.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.20.0.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "10504596e7a13dea0162e4d843d9b965", + "name": "dask", + "sha256": "497d5ede330da650ea36fef5b644369833a584995b20d43bd832f10b7c31f541", + "size": 3977, + "subdir": "linux-64", + "timestamp": 1540830925057, + "version": "0.20.0" + }, + "dask-0.20.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.20.0.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "751d09a2a43f51b5bf8a0d5ce70e5cd1", + "name": "dask", + "sha256": "cada132958b907bef7a908be4bdf9cd1d7373daefd2a3f4a055038bc6b14dc8b", + "size": 3980, + "subdir": "linux-64", + "timestamp": 1540830955581, + "version": "0.20.0" + }, + "dask-0.20.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.20.1.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "b587260560611b237fb66e5d571af603", + "name": "dask", + "sha256": "39677c33d82fba1b1df8e635357be300c4eb644dee56539cf44b4d38642dd3a4", + "size": 3971, + "subdir": "linux-64", + "timestamp": 1542077695070, + "version": "0.20.1" + }, + "dask-0.20.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.20.1.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "f2739619a7dd7266221d815feb6ab815", + "name": "dask", + "sha256": "000a7701da962f4f39300fe882fdae60b09ea190229c1e9103718fb461977549", + "size": 3971, + "subdir": "linux-64", + "timestamp": 1542077820054, + "version": "0.20.1" + }, + "dask-0.20.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.20.1.*", + "distributed >=1.23.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "dcc59672194318c6e93a130845f4695d", + "name": "dask", + "sha256": "aa7d79d6e634d2e638d3b18b1e5323c064fbb59b47a87b8f5895fbdcdebfb42e", + "size": 3999, + "subdir": "linux-64", + "timestamp": 1542077759712, + "version": "0.20.1" + }, + "dask-0.20.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.20.2.*", + "distributed >=1.24.2", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "5b9dc1e65c00c4c4fba5cc9241a9d78d", + "name": "dask", + "sha256": "dc88306b6214e8a9ee484cb5c13a190d89e7b1e553e0db627da7276b040212e9", + "size": 3974, + "subdir": "linux-64", + "timestamp": 1542386627620, + "version": "0.20.2" + }, + "dask-0.20.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.20.2.*", + "distributed >=1.24.2", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "3964f12d5c519d6dc4a670af11db02c8", + "name": "dask", + "sha256": "85f76ce417bdcc95a0dbb23bc8e0a447fc6738302e8c96180ca137826edae2ae", + "size": 3978, + "subdir": "linux-64", + "timestamp": 1542386681982, + "version": "0.20.2" + }, + "dask-0.20.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 0.20.2.*", + "distributed >=1.24.2", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "6c0144da546c72703fc7fd9feba9baaf", + "name": "dask", + "sha256": "600b97f4911858d228ec03e002aff97861a16117015133dffe29b3d32b328adc", + "size": 3982, + "subdir": "linux-64", + "timestamp": 1542386623203, + "version": "0.20.2" + }, + "dask-1.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 1.0.0.*", + "distributed >=1.25.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "84f53e0295632467c2a4225731d58d9f", + "name": "dask", + "sha256": "32e968fa90e971f4786251fd1b6873f42607b69d69935c9f86913b57c32d6d9f", + "size": 4020, + "subdir": "linux-64", + "timestamp": 1543504200478, + "version": "1.0.0" + }, + "dask-1.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 1.0.0.*", + "distributed >=1.25.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "e57d72a5e4a7ca18ce5f45d5f453c4f6", + "name": "dask", + "sha256": "8dd47c6dcace7bb4d4482a1dda0b0d3f5f15b165cf94278da814ed7fb8d8ba1c", + "size": 3976, + "subdir": "linux-64", + "timestamp": 1543504325126, + "version": "1.0.0" + }, + "dask-1.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 1.0.0.*", + "distributed >=1.25.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "1bfcff81d01b0e26f4014f3e60bf135a", + "name": "dask", + "sha256": "e725dec2b897d64594041c3c79607b0b73ad46b377278f233a492826e815e166", + "size": 3978, + "subdir": "linux-64", + "timestamp": 1543504219943, + "version": "1.0.0" + }, + "dask-1.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 1.1.2.*", + "distributed >=1.25.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "2a5b656c04dcd68efe32a7769d820b11", + "name": "dask", + "sha256": "47fe80126f0aa3e2b96ea5972db795fdc7d5899772c28315329a835f54fe601c", + "size": 11155, + "subdir": "linux-64", + "timestamp": 1551138544223, + "version": "1.1.2" + }, + "dask-1.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 1.1.2.*", + "distributed >=1.25.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "b4f1e278d72311133f4b59c8d4e2d1da", + "name": "dask", + "sha256": "4749f2a1a24d7cf1ee2539a1884e503a267dbc93b750db218d986aecd4db186a", + "size": 11126, + "subdir": "linux-64", + "timestamp": 1551138595105, + "version": "1.1.2" + }, + "dask-1.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 1.1.2.*", + "distributed >=1.25.3", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "d4bd1fdbc88a52d00125e922a12d60b1", + "name": "dask", + "sha256": "afaa5c30559194a0334faf271f7695f69702cea7d4575c4739f76eccea6ce218", + "size": 11146, + "subdir": "linux-64", + "timestamp": 1551195931863, + "version": "1.1.2" + }, + "dask-1.1.4-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 1.1.4.*", + "distributed >=1.26.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "76dd24c3afdc1494a8e409604a41f36b", + "name": "dask", + "sha256": "ee29c54c3d64d03d7d0750576ac10d7bf7f0aef0250eaad09b70088df6d18e50", + "size": 11431, + "subdir": "linux-64", + "timestamp": 1553289470806, + "version": "1.1.4" + }, + "dask-1.1.4-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 1.1.4.*", + "distributed >=1.26.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "1fd5482e8b7b90955bbc297cf8322674", + "name": "dask", + "sha256": "aaf7bb795ac24ae141c80cf58f08b03315372edccf5c0831ae01136848be14af", + "size": 11434, + "subdir": "linux-64", + "timestamp": 1553289520710, + "version": "1.1.4" + }, + "dask-1.1.4-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "bokeh >=0.13.0", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core 1.1.4.*", + "distributed >=1.26.0", + "numpy >=1.11.0", + "pandas >=0.19.0", + "partd >=0.3.8", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "17e0900c1f2783e713025db263435322", + "name": "dask", + "sha256": "135c2dcf48d2b4df1c622efdbbe70654cc8987974a2d60ccc8c17957e45dedb1", + "size": 11454, + "subdir": "linux-64", + "timestamp": 1553290686219, + "version": "1.1.4" + }, + "dask-2022.5.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "cytoolz >=0.8.2", + "dask-core 2022.5.0.*", + "distributed 2022.5.0.*", + "jinja2", + "lz4", + "numpy >=1.18", + "pandas >=1.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "920762661d0ae6888ef288aa4a3ce053", + "name": "dask", + "sha256": "147961c98c443b471834a66562d1a75b9669fd63dd1af84d425bb80ca6a47ba9", + "size": 5117, + "subdir": "linux-64", + "timestamp": 1653409189481, + "version": "2022.5.0" + }, + "dask-2022.5.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "cytoolz >=0.8.2", + "dask-core 2022.5.0.*", + "distributed 2022.5.0.*", + "jinja2", + "lz4", + "numpy >=1.18", + "pandas >=1.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6957a69e98ae00f21cafcf1562427340", + "name": "dask", + "sha256": "644bd78d2850a02d2eb15e746671c196179b52034e8627ef2f248ed27176ea2e", + "size": 5459, + "subdir": "linux-64", + "timestamp": 1676843943309, + "version": "2022.5.0" + }, + "dask-2022.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "cytoolz >=0.8.2", + "dask-core 2022.5.0.*", + "distributed 2022.5.0.*", + "jinja2", + "lz4", + "numpy >=1.18", + "pandas >=1.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f62e4d553654ed5de803264af9fb8541", + "name": "dask", + "sha256": "37284143958b6bd3cbbd765d00608d9c4df148917cb224bf55d1e0c2d4aaf287", + "size": 5091, + "subdir": "linux-64", + "timestamp": 1653409259494, + "version": "2022.5.0" + }, + "dask-2022.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "cytoolz >=0.8.2", + "dask-core 2022.5.0.*", + "distributed 2022.5.0.*", + "jinja2", + "lz4", + "numpy >=1.18", + "pandas >=1.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "44d5b193b5481e25ce83986d14783cce", + "name": "dask", + "sha256": "eee1949aa20e9cca19f05e43e1c1e18a6d47a6e87617d8039cbf4a4262b0c517", + "size": 5099, + "subdir": "linux-64", + "timestamp": 1653409226556, + "version": "2022.5.0" + }, + "dask-2022.7.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "cytoolz >=0.8.2", + "dask-core 2022.7.0.*", + "distributed 2022.7.0.*", + "jinja2", + "lz4", + "numpy >=1.18", + "pandas >=1.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff2b9f9c8186b50d838e4e80900c6edd", + "name": "dask", + "sha256": "000d2fa1a50174eb1a84cd4b233b5ec0bd96ce6eb66ac210e1ee1cdeece3dd3f", + "size": 5912, + "subdir": "linux-64", + "timestamp": 1658527043409, + "version": "2022.7.0" + }, + "dask-2022.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "cytoolz >=0.8.2", + "dask-core 2022.7.0.*", + "distributed 2022.7.0.*", + "jinja2", + "lz4", + "numpy >=1.18", + "pandas >=1.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3c613b96552add8d2f7bcfdfbdc99167", + "name": "dask", + "sha256": "9ff65006eecc319847e0f88c3ff299e1fca4ed46da017557117428319c31a7e2", + "size": 5883, + "subdir": "linux-64", + "timestamp": 1658527002815, + "version": "2022.7.0" + }, + "dask-2022.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "cytoolz >=0.8.2", + "dask-core 2022.7.0.*", + "distributed 2022.7.0.*", + "jinja2", + "lz4", + "numpy >=1.18", + "pandas >=1.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "664896c054a7901aa42edca7ea543fa7", + "name": "dask", + "sha256": "965f19bd8120b099dd3b51490a1359c69ddf7b97c8cd3e32b04f17006e3f356e", + "size": 5882, + "subdir": "linux-64", + "timestamp": 1658526967823, + "version": "2022.7.0" + }, + "dask-2023.3.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "click >=7.0", + "cloudpickle >=1.1.1", + "cytoolz >=0.8.2", + "dask-core 2023.3.2.*", + "distributed 2023.3.2.*", + "fsspec >=0.6.0", + "importlib-metadata >=4.13.0", + "jinja2 >=2.10.3", + "lz4", + "numpy >=1.21", + "packaging >=20.0", + "pandas >=1.3", + "partd >=1.2.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.3.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7da8506a429ae4d40389ddd581c2994c", + "name": "dask", + "sha256": "3fb7cd721f8467762c7ae6878a86c8fd85d902708b4ecbc290553c8d9af74301", + "size": 5620, + "subdir": "linux-64", + "timestamp": 1680108500827, + "version": "2023.3.2" + }, + "dask-2023.3.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "click >=7.0", + "cloudpickle >=1.1.1", + "cytoolz >=0.8.2", + "dask-core 2023.3.2.*", + "distributed 2023.3.2.*", + "fsspec >=0.6.0", + "importlib-metadata >=4.13.0", + "jinja2 >=2.10.3", + "lz4", + "numpy >=1.21", + "packaging >=20.0", + "pandas >=1.3", + "partd >=1.2.0", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.3.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "636d83dbb0f3f96a4f1614b22005e751", + "name": "dask", + "sha256": "6b74ee836ad38784410bb698c896b94a0644d0093350b4057ea7bcc8f8eee891", + "size": 5614, + "subdir": "linux-64", + "timestamp": 1680108537420, + "version": "2023.3.2" + }, + "dask-2023.3.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "click >=7.0", + "cloudpickle >=1.1.1", + "cytoolz >=0.8.2", + "dask-core 2023.3.2.*", + "distributed 2023.3.2.*", + "fsspec >=0.6.0", + "importlib-metadata >=4.13.0", + "jinja2 >=2.10.3", + "lz4", + "numpy >=1.21", + "packaging >=20.0", + "pandas >=1.3", + "partd >=1.2.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.3.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "118f9d8745e6ce42156e3048c8d81682", + "name": "dask", + "sha256": "c9a1c9ccdc4183a18a25dc4cc3b8ad76e482280693cf5319a52b97a06b732738", + "size": 5587, + "subdir": "linux-64", + "timestamp": 1680108462140, + "version": "2023.3.2" + }, + "dask-2023.3.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "bokeh >=2.4.2,<3.0", + "click >=7.0", + "cloudpickle >=1.1.1", + "cytoolz >=0.8.2", + "dask-core 2023.3.2.*", + "distributed 2023.3.2.*", + "fsspec >=0.6.0", + "importlib-metadata >=4.13.0", + "jinja2 >=2.10.3", + "lz4", + "numpy >=1.21", + "packaging >=20.0", + "pandas >=1.3", + "partd >=1.2.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.3.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2578464227434f6b6305d03ca023b85d", + "name": "dask", + "sha256": "bedaccc91440c58a56cbb42613186a8d58188e80f4f88e843f369eb4b158a736", + "size": 5582, + "subdir": "linux-64", + "timestamp": 1680108420325, + "version": "2023.3.2" + }, + "dask-core-0.15.2-py27heedc4a4_0.conda": { + "build": "py27heedc4a4_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b928795970fea52dc24908c56be84755", + "name": "dask-core", + "sha256": "8944456a0b2b676c7dd168f1841c4060403280c77ece691a0c13bd05e539b6d4", + "size": 843207, + "subdir": "linux-64", + "timestamp": 1505733002745, + "version": "0.15.2" + }, + "dask-core-0.15.2-py35h79caba8_0.conda": { + "build": "py35h79caba8_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "077bc598ff772708ed6085a717453673", + "name": "dask-core", + "sha256": "76a1a1c931348f387b9838bb598b386b38687267b45d43ccdde0ebc58172bf08", + "size": 861151, + "subdir": "linux-64", + "timestamp": 1505733025395, + "version": "0.15.2" + }, + "dask-core-0.15.2-py36h0f988a8_0.conda": { + "build": "py36h0f988a8_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9f0d84535dff8dc34f5a0e65f7b7345e", + "name": "dask-core", + "sha256": "378ae896f44682104bd929225e1e81008e359381ba447d46ec3a26a383615ce7", + "size": 852309, + "subdir": "linux-64", + "timestamp": 1505733048226, + "version": "0.15.2" + }, + "dask-core-0.15.3-py27h53a7ee6_0.conda": { + "build": "py27h53a7ee6_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "063c8c625c32dabc36c0a34162f1cd83", + "name": "dask-core", + "sha256": "ee8275f368d64859432f4a7133090365ebc98a808253870bed6371c8e80ffead", + "size": 866324, + "subdir": "linux-64", + "timestamp": 1506623913203, + "version": "0.15.3" + }, + "dask-core-0.15.3-py35hdf4792c_0.conda": { + "build": "py35hdf4792c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "02c291ff3ec0b805cef09c53de831bb2", + "name": "dask-core", + "sha256": "2e3a47765d33d6681f6573058103a15e2ceb9eccd8241101b9fc50d97e5bca9e", + "size": 885363, + "subdir": "linux-64", + "timestamp": 1506623946353, + "version": "0.15.3" + }, + "dask-core-0.15.3-py36h10e6167_0.conda": { + "build": "py36h10e6167_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a532c9d96c157fbff83a7ed2683b16c0", + "name": "dask-core", + "sha256": "10fcffe9dd6ecbac124bea851bf15ae3b98f02f07ff46b439ed3098fdb761358", + "size": 883575, + "subdir": "linux-64", + "timestamp": 1506623961580, + "version": "0.15.3" + }, + "dask-core-0.15.4-py27h539238a_0.conda": { + "build": "py27h539238a_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e2290f16cf3079c7381e3875c03698a2", + "name": "dask-core", + "sha256": "69177cff31b73eb121c526c0861278b95332a0b5f26b173ef9591c675fee8ebd", + "size": 878538, + "subdir": "linux-64", + "timestamp": 1510006209683, + "version": "0.15.4" + }, + "dask-core-0.15.4-py35hb07b8c3_0.conda": { + "build": "py35hb07b8c3_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "26e8d78b6111a548013be72acd609606", + "name": "dask-core", + "sha256": "6be019dd2636d1a7a8b7330edfdd5c5ad34525ae95a1b3c6f7b93bdeadc4b391", + "size": 888700, + "subdir": "linux-64", + "timestamp": 1510006221838, + "version": "0.15.4" + }, + "dask-core-0.15.4-py36h7045e13_0.conda": { + "build": "py36h7045e13_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a032817ac60011194f9ec8a438a4b72f", + "name": "dask-core", + "sha256": "b6e4300fd1e13a74622b860b2390e77fa570c8d3f42d8f335aa6be29425a7d9f", + "size": 887019, + "subdir": "linux-64", + "timestamp": 1510006216295, + "version": "0.15.4" + }, + "dask-core-0.16.0-py27he98c51e_0.conda": { + "build": "py27he98c51e_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d4a0d19ecff84fab833f8239871c8221", + "name": "dask-core", + "sha256": "def0cec9e0c537506d75679c43433a81e3cb21c483e44fa599183cf65b48447b", + "size": 888400, + "subdir": "linux-64", + "timestamp": 1511195884663, + "version": "0.16.0" + }, + "dask-core-0.16.0-py35hfc66869_0.conda": { + "build": "py35hfc66869_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0904c3459a33e349318c864736bc87fe", + "name": "dask-core", + "sha256": "70f14cff12bd00aabfb294666374dccb4143d00ce3d8a1ea02c7968084e6430a", + "size": 907633, + "subdir": "linux-64", + "timestamp": 1511195895537, + "version": "0.16.0" + }, + "dask-core-0.16.0-py36ha827fd6_0.conda": { + "build": "py36ha827fd6_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a3bb62173219c7dc6fde908756c5743f", + "name": "dask-core", + "sha256": "0963a2b46415bcb93a979c0a6ad29b1e5d385988471ae0a477744e48add41146", + "size": 906921, + "subdir": "linux-64", + "timestamp": 1511195926338, + "version": "0.16.0" + }, + "dask-core-0.16.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0459fa432353025d8a35adc1dbae402e", + "name": "dask-core", + "sha256": "4aefae6addc1b6d0a711ba5000863307669473fc1c523a34bb0ec274214faefe", + "size": 920443, + "subdir": "linux-64", + "timestamp": 1515704356145, + "version": "0.16.1" + }, + "dask-core-0.16.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5977d0b394eef0fe20177766064fed63", + "name": "dask-core", + "sha256": "789f46ce41f727fbbf1f1e543137b3045efdf78c72c2520429d102cf81e2cb39", + "size": 940067, + "subdir": "linux-64", + "timestamp": 1515704455676, + "version": "0.16.1" + }, + "dask-core-0.16.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b6daec16ab0505d647128e4b02ec5a1c", + "name": "dask-core", + "sha256": "fb64235e8fa59772aaaee9b04bc95303eac9b1f13cce7b126147a70755fb664f", + "size": 938434, + "subdir": "linux-64", + "timestamp": 1515704170446, + "version": "0.16.1" + }, + "dask-core-0.17.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "916be11d4789b7027b96ba621ebab975", + "name": "dask-core", + "sha256": "3769a6f683cb9d0ee63c2ce2028fb3c6d6935a2d0b96c29d8f8ec3f0d988a6ed", + "size": 938826, + "subdir": "linux-64", + "timestamp": 1518524262612, + "version": "0.17.0" + }, + "dask-core-0.17.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "633af41236ec55e4ab11d33f4f79689b", + "name": "dask-core", + "sha256": "d6086ab7f5f95521672292bc938e20dd78467bc031de74a0bbfd6b2bf7305b48", + "size": 958509, + "subdir": "linux-64", + "timestamp": 1518524311696, + "version": "0.17.0" + }, + "dask-core-0.17.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0de60aee92961957cad08fdadf6fe6b9", + "name": "dask-core", + "sha256": "14ea7585afc5ad6ed9e4596507767c43a6fd50907553b7ed73c5cd48d2781179", + "size": 958465, + "subdir": "linux-64", + "timestamp": 1518524311953, + "version": "0.17.0" + }, + "dask-core-0.17.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9c3391ea3af99643509686b60e4e56fb", + "name": "dask-core", + "sha256": "b2367c2e16be577fe21b8d5843b701ff5d9ea3a6d05faa92babbbe0b79ad337e", + "size": 948613, + "subdir": "linux-64", + "timestamp": 1519397632435, + "version": "0.17.1" + }, + "dask-core-0.17.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dbf0e687f09f4569d1d374af02838c89", + "name": "dask-core", + "sha256": "b1c6589889b314e8591f02f7d8ab3062fbec4d8d0b12f12b2727bc00478a6080", + "size": 968265, + "subdir": "linux-64", + "timestamp": 1519397647505, + "version": "0.17.1" + }, + "dask-core-0.17.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "94103f01c45286049c57c3e888849a53", + "name": "dask-core", + "sha256": "1a00f92d310b7d3e8f4d455213c8afdec52689fba04a40770d4d48b98b3ac6da", + "size": 958179, + "subdir": "linux-64", + "timestamp": 1519397610092, + "version": "0.17.1" + }, + "dask-core-0.17.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "35281139178438fe6ead8febd8ebd0e3", + "name": "dask-core", + "sha256": "32de4eb3da3e32e86250d9e031ccf356c33b2fd669e1fc537739a5ac1a58e115", + "size": 956740, + "subdir": "linux-64", + "timestamp": 1521650088111, + "version": "0.17.2" + }, + "dask-core-0.17.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "08a0e0b70651249bfbe7c853b3be83ff", + "name": "dask-core", + "sha256": "2dbf417b3eb9fc5f22fe0a57c8f5111cf72f5a2b816baf6e5d3ed950c5875890", + "size": 987318, + "subdir": "linux-64", + "timestamp": 1521650127658, + "version": "0.17.2" + }, + "dask-core-0.17.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ce61fa65356b2260cce8711aad8be4c3", + "name": "dask-core", + "sha256": "4d0a3d9bae76a74d472e983bdece4b20fc6145b66dfa223b335ebff2e6c1ed50", + "size": 976319, + "subdir": "linux-64", + "timestamp": 1521650089321, + "version": "0.17.2" + }, + "dask-core-0.17.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "37d37c391fc27884158ad34d64dce409", + "name": "dask-core", + "sha256": "46ee0f77ba1345a7150d78852a0d1111c2f028ff52a9c337bcb96d281915b647", + "size": 987707, + "subdir": "linux-64", + "timestamp": 1525289042483, + "version": "0.17.3" + }, + "dask-core-0.17.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e796642169fa00cd0e3e862277e81c60", + "name": "dask-core", + "sha256": "9ad2b0b451e65d4bf06c73cff935698b775684464d8901495bb4cb06717198cf", + "size": 1009947, + "subdir": "linux-64", + "timestamp": 1525289186011, + "version": "0.17.3" + }, + "dask-core-0.17.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "903f0281074bd1df6e03ea6c79bcaaad", + "name": "dask-core", + "sha256": "b69a6e2ca2028d486542b0198fec535924ec51639e1a877a6ea835eaa61a1df1", + "size": 998404, + "subdir": "linux-64", + "timestamp": 1525289186904, + "version": "0.17.3" + }, + "dask-core-0.17.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "39c77dfe6659e1e924c075bb99feb576", + "name": "dask-core", + "sha256": "90331917c4ee8482774c3aa5e6b6dfa1e64adfcd36109f341a5af46473eea8f2", + "size": 988222, + "subdir": "linux-64", + "timestamp": 1525470734188, + "version": "0.17.4" + }, + "dask-core-0.17.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ec8b60e4bbe8db1ebf74236558126b34", + "name": "dask-core", + "sha256": "1b1554de8ee82973b644604fa1a260ba8e44de7fe18eeb65437c92da7953f7d3", + "size": 1010058, + "subdir": "linux-64", + "timestamp": 1525470766780, + "version": "0.17.4" + }, + "dask-core-0.17.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "602ee24bc5fc3448f947454eb2b294ef", + "name": "dask-core", + "sha256": "571018146b9e6eb1ad0c003340f5d13f86ade11d4d9c5fbd13c4d0dbc294b209", + "size": 1008440, + "subdir": "linux-64", + "timestamp": 1525470682552, + "version": "0.17.4" + }, + "dask-core-0.17.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b4212f29d306cad53d208d4063fa677b", + "name": "dask-core", + "sha256": "ca0b53884d703a00137555d482bd29689992a63a0197722cf7f5b6c98b3fd720", + "size": 990348, + "subdir": "linux-64", + "timestamp": 1526527295232, + "version": "0.17.5" + }, + "dask-core-0.17.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fed8f6b9e526bc5333587f01f3ee1a92", + "name": "dask-core", + "sha256": "6e01e09cd0c58954b6fd4f81b9f2ce8604aa85a256c8aeb1160154a1cc0b0771", + "size": 1021719, + "subdir": "linux-64", + "timestamp": 1526527275068, + "version": "0.17.5" + }, + "dask-core-0.17.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "704b21119ccece836822091cb76dc5f3", + "name": "dask-core", + "sha256": "7a0e362368725aa40125ed47aab7f1f3476f32ce0fe6e27bb870fcb0871227f2", + "size": 999873, + "subdir": "linux-64", + "timestamp": 1526527279625, + "version": "0.17.5" + }, + "dask-core-0.18.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3e97550533a86a7c127b65b653a3f4fb", + "name": "dask-core", + "sha256": "ff133a42cbbf6ba38ac169cb1662b6dce399a8d43abdcffcdaa50d127169f6e0", + "size": 1042928, + "subdir": "linux-64", + "timestamp": 1529076322740, + "version": "0.18.0" + }, + "dask-core-0.18.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7ae72373fae57499e4f5ffbec6f56667", + "name": "dask-core", + "sha256": "3febd4e5e3f0aed81664f7a46969794fc875b374496f63f0bafdf3e640f7679c", + "size": 1063891, + "subdir": "linux-64", + "timestamp": 1529076389406, + "version": "0.18.0" + }, + "dask-core-0.18.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5bc6737453eeff772d97a2738477827d", + "name": "dask-core", + "sha256": "2ec013634c19aa8364d3f51935da998f534a8f5b38a3ca77a537f27575a0743c", + "size": 1052721, + "subdir": "linux-64", + "timestamp": 1529076283730, + "version": "0.18.0" + }, + "dask-core-0.18.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fa3a304ac017321d2357806d7b00100b", + "name": "dask-core", + "sha256": "788a81593bbede4b535ce6d710def413ea41c4491702dffffceb8628e600a47a", + "size": 1042020, + "subdir": "linux-64", + "timestamp": 1529768094770, + "version": "0.18.1" + }, + "dask-core-0.18.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e6fe54ff7fb1b9358fb170c9fa1f8703", + "name": "dask-core", + "sha256": "c7002351844e1c804768c30a66506b8b0c1a5b05c302f3a452b071768a89dddd", + "size": 1063357, + "subdir": "linux-64", + "timestamp": 1529768114344, + "version": "0.18.1" + }, + "dask-core-0.18.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bcaf13efa06c7bfca5aa125c7e4890dc", + "name": "dask-core", + "sha256": "0fbeb1394f58cce4d1bc47001cdff609565ca0ed28d3f696d73e50109ce4700b", + "size": 1063432, + "subdir": "linux-64", + "timestamp": 1529768238843, + "version": "0.18.1" + }, + "dask-core-0.18.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "632925f9ccbff6a6cc0db1bb04501e77", + "name": "dask-core", + "sha256": "4df9ed4331520b83265366fef14c46151d6835ab5a3196e95f9cd7a1c0e1c68c", + "size": 1057653, + "subdir": "linux-64", + "timestamp": 1530741212854, + "version": "0.18.1" + }, + "dask-core-0.18.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "90fd1a2c4dae783768c74253ec7c5fb5", + "name": "dask-core", + "sha256": "0bf51f41d0e8e1edf3a77ad40f658804dc9157e7bcfcb917ef1b64b87e3a80b1", + "size": 1064029, + "subdir": "linux-64", + "timestamp": 1532441219062, + "version": "0.18.2" + }, + "dask-core-0.18.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e4e8c40309b5200fe3dea5abe2038d63", + "name": "dask-core", + "sha256": "43a9349f685e33fb8d8e1b97a4dc882821bb0d6a4744caa1fdf4b011195eabdd", + "size": 1096892, + "subdir": "linux-64", + "timestamp": 1532441260108, + "version": "0.18.2" + }, + "dask-core-0.18.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ad91814ef7d988b21365eec98e5d4d92", + "name": "dask-core", + "sha256": "784177505a1da4bab75e5d0b860865f31c78c5db54f91c2ccc87c2601bbe979c", + "size": 1085560, + "subdir": "linux-64", + "timestamp": 1532441205887, + "version": "0.18.2" + }, + "dask-core-0.18.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bb16fda9a482f2dc72d49e704bbe16a4", + "name": "dask-core", + "sha256": "74e93f21422cddc7d5e4560a655b54bef1b9728acd284ffd815a1060c4cdfedc", + "size": 1068606, + "subdir": "linux-64", + "timestamp": 1532441228915, + "version": "0.18.2" + }, + "dask-core-0.19.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "457f41ec890725ba36302360caf0331f", + "name": "dask-core", + "sha256": "4475bfc81d6104beba28febbfe7cf2f96356652774efc22c301f512ef2f20bb3", + "size": 1079254, + "subdir": "linux-64", + "timestamp": 1535658877256, + "version": "0.19.0" + }, + "dask-core-0.19.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cf5b71d7725c343db82c88d2e6b74c09", + "name": "dask-core", + "sha256": "7bd062d6f39deb73789d06287a70fb7550cce3ed2e4ad11925aff5b977a4bed1", + "size": 1090195, + "subdir": "linux-64", + "timestamp": 1535658891039, + "version": "0.19.0" + }, + "dask-core-0.19.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e21b8f275cd2d157440d187a26724c46", + "name": "dask-core", + "sha256": "3a93d7a47cbcc819be84a03a42fa3b39572c2003c5e54daa41ce4901d97410d6", + "size": 1079712, + "subdir": "linux-64", + "timestamp": 1535658867426, + "version": "0.19.0" + }, + "dask-core-0.19.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1f6bedb880b27f66482c7d03da2420f3", + "name": "dask-core", + "sha256": "1eaf6b4ce6a0a12593acc999f18595891f75cc4a06e2f627aac73cf4226933b5", + "size": 1083855, + "subdir": "linux-64", + "timestamp": 1535658875766, + "version": "0.19.0" + }, + "dask-core-0.19.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bfde72a8bb9842b948d0955f07c5491b", + "name": "dask-core", + "sha256": "3ca220f064c4acb76a90dbfcfc2903d3f9ce3275ad9587c7f21e72e35e28cb25", + "size": 1088090, + "subdir": "linux-64", + "timestamp": 1536247992260, + "version": "0.19.1" + }, + "dask-core-0.19.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "443910ee987cfc49e0dcb6f997615828", + "name": "dask-core", + "sha256": "c82855ae45dc5e4068593de9086c00584656bbc5a8b48313c0891c4c3c5c1950", + "size": 1110303, + "subdir": "linux-64", + "timestamp": 1536248050360, + "version": "0.19.1" + }, + "dask-core-0.19.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f8a2eb0eb41fccd0acd2271e0aedfb6a", + "name": "dask-core", + "sha256": "53824e8be7ffe1ce67668041a20ed96d5da94a858d319f812ed5abd00c68219e", + "size": 1098973, + "subdir": "linux-64", + "timestamp": 1536247978010, + "version": "0.19.1" + }, + "dask-core-0.19.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "862734b0eae5f320e0f4dd778131c359", + "name": "dask-core", + "sha256": "123c26f7967e9809a34144182bed46597e8f479537d553899b31228981465503", + "size": 1091650, + "subdir": "linux-64", + "timestamp": 1536248085221, + "version": "0.19.1" + }, + "dask-core-0.19.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "253c78d35be9e8b1fb5b0e4237169038", + "name": "dask-core", + "sha256": "f300d588002069014eb6c95c792c81b42a6b0e7776ab3cf4167ce9878872719a", + "size": 1089474, + "subdir": "linux-64", + "timestamp": 1538069037064, + "version": "0.19.2" + }, + "dask-core-0.19.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c2bf5a7e7fd15435759d3051aee21023", + "name": "dask-core", + "sha256": "6f586b4d15431019096d8b4df2efd49e20b4295601b2c5d4bb15acfd09632735", + "size": 1112567, + "subdir": "linux-64", + "timestamp": 1538069035812, + "version": "0.19.2" + }, + "dask-core-0.19.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "96295184383b91d0e13eb09d1ffe721e", + "name": "dask-core", + "sha256": "bd8ed7be22100be0167fe8d30302e195b108bfd1a42620412d2ff87cf182596e", + "size": 1100665, + "subdir": "linux-64", + "timestamp": 1538069044631, + "version": "0.19.2" + }, + "dask-core-0.19.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "36113493465dad808c271300ce435dd2", + "name": "dask-core", + "sha256": "ee900d7eb26c9128669d6f10db9edc4142bfbf0c6f5bf76e1bc33a20b06a22ea", + "size": 1094338, + "subdir": "linux-64", + "timestamp": 1538069005665, + "version": "0.19.2" + }, + "dask-core-0.19.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6a2e8dafb8615d750921940391394885", + "name": "dask-core", + "sha256": "1e1746d21c7ed13a81a1b204df9746d80c8edb78323db40d633678cb92cb8a09", + "size": 1114769, + "subdir": "linux-64", + "timestamp": 1539016952415, + "version": "0.19.3" + }, + "dask-core-0.19.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "04807333eec444238fac371ab9bc72f4", + "name": "dask-core", + "sha256": "d882c1022c8c57c94a8f4528fc9c4abf9930cb75d72b11a908df63e82dde20c9", + "size": 1114088, + "subdir": "linux-64", + "timestamp": 1539016975625, + "version": "0.19.3" + }, + "dask-core-0.19.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c4318d9460d992210c506126a03ad3f5", + "name": "dask-core", + "sha256": "5ceb4f5ed8e21357e06a488979d80cf329ed7384ba7c23cff44c6b926c6798e2", + "size": 1118191, + "subdir": "linux-64", + "timestamp": 1539016953211, + "version": "0.19.3" + }, + "dask-core-0.19.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6e102c6de87a229babfe5eb311ca1f9c", + "name": "dask-core", + "sha256": "14d6487d19aaad405dd507d97a1d20becdd102a9d0490cc9c45d115abb203201", + "size": 1121902, + "subdir": "linux-64", + "timestamp": 1539473878214, + "version": "0.19.4" + }, + "dask-core-0.19.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "62ea2f987911943180c333c750056f1c", + "name": "dask-core", + "sha256": "05bde4fa7074a644f5a1d8531523b695f92a1b247a46d280585bd350ba87f1e8", + "size": 1131810, + "subdir": "linux-64", + "timestamp": 1539473895115, + "version": "0.19.4" + }, + "dask-core-0.19.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a97eae1d7108c3a6803e613389fd4c4c", + "name": "dask-core", + "sha256": "31769c3e4b69061109f0ade05483c910de1caa748a2a168c279af53da586cec6", + "size": 1125719, + "subdir": "linux-64", + "timestamp": 1539473901642, + "version": "0.19.4" + }, + "dask-core-0.20.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a88a4ceee0864e9f8d77a5bd07ae8207", + "name": "dask-core", + "sha256": "afdd075f6c91ae7264654ca4a2347f32239b530dd302ec56931a66aa63e4a297", + "size": 1137718, + "subdir": "linux-64", + "timestamp": 1540830594298, + "version": "0.20.0" + }, + "dask-core-0.20.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "55c891c108c73a692eb5cdf4e86d3c1c", + "name": "dask-core", + "sha256": "4061343c05c96e57dae2f4ee088ec37e66ad679ad0f2185ac1c45ae88d66570e", + "size": 1149885, + "subdir": "linux-64", + "timestamp": 1540830666301, + "version": "0.20.0" + }, + "dask-core-0.20.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "57a472eb6ce7ff27104e0b040e86b05a", + "name": "dask-core", + "sha256": "e1cb325ec8e5c07fd1cfe18b38d3cd6bd902dead4c93e8e0532cdb43b7e03bc6", + "size": 1132482, + "subdir": "linux-64", + "timestamp": 1540830662585, + "version": "0.20.0" + }, + "dask-core-0.20.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8edad23b3dfe543523e7afb700a2922d", + "name": "dask-core", + "sha256": "f7de7a2976b1bd8a950e82b84a76b923ceea2eb534418d4740943e827848210d", + "size": 1130964, + "subdir": "linux-64", + "timestamp": 1542077389304, + "version": "0.20.1" + }, + "dask-core-0.20.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f6af4092a6df5ebb35e1019c757f0a38", + "name": "dask-core", + "sha256": "14c2f7092f400cd54559685a07d2fa23bcc69fd21febbadb6408ce106e7c2f6e", + "size": 1141902, + "subdir": "linux-64", + "timestamp": 1542077488028, + "version": "0.20.1" + }, + "dask-core-0.20.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ad3dca9a40ea84269179bd5a6c8b9403", + "name": "dask-core", + "sha256": "ebdae81c97c16f73312e2305203a5b5008609c77c41757c7b1bb1a15a0930e53", + "size": 1135757, + "subdir": "linux-64", + "timestamp": 1542077390435, + "version": "0.20.1" + }, + "dask-core-0.20.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e856c9870f2b67894c59f7e099f9a6bf", + "name": "dask-core", + "sha256": "85160be1ba4d69a3625b80332b0acc08348f3213c96a5801bc48837057d3ec34", + "size": 1131369, + "subdir": "linux-64", + "timestamp": 1542386428139, + "version": "0.20.2" + }, + "dask-core-0.20.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e4f82bafebee99b19d4e49a4153ecede", + "name": "dask-core", + "sha256": "6c4b610a2a98f0e0dcd56f80ed1f0e6c5e3dfb29af023f791dc09c1e6aba0b90", + "size": 1143181, + "subdir": "linux-64", + "timestamp": 1542386438645, + "version": "0.20.2" + }, + "dask-core-0.20.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8d03d07f63f5e6202b5132d21225cddc", + "name": "dask-core", + "sha256": "3b68565ab2238e14fa82d37d15f370b7c2c1cbb7f6eac33146011020aaf64209", + "size": 1136904, + "subdir": "linux-64", + "timestamp": 1542386427430, + "version": "0.20.2" + }, + "dask-core-1.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6e6a747510df2a8d67974c457805f7e7", + "name": "dask-core", + "sha256": "6c66b71ed307a8e81dceda6c7b1c5ca5df8bb5de43a82b1e9611543c3fc2f7d0", + "size": 1130160, + "subdir": "linux-64", + "timestamp": 1543503953579, + "version": "1.0.0" + }, + "dask-core-1.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4fe04e06e53fd84695ce3d47a5b69a06", + "name": "dask-core", + "sha256": "c62d2b33ebfc2ba2f63ae4dd0ab821825eeccc4f86c358dbada50405446849bc", + "size": 1151952, + "subdir": "linux-64", + "timestamp": 1543503958205, + "version": "1.0.0" + }, + "dask-core-1.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4dd85f6f6bf2738275bdf3b5c0043092", + "name": "dask-core", + "sha256": "d48e62b2e4553f6fd245397f9bc1297d8363e1ddee5c4e63414efb2475d4b5a9", + "size": 1146239, + "subdir": "linux-64", + "timestamp": 1543503946475, + "version": "1.0.0" + }, + "dask-core-1.1.4-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e10b9354eca409b0de424d45372b1188", + "name": "dask-core", + "sha256": "6561a0e7a02547fefb1f613637e79cc0f181aab7411fbb22c464db08e14a334b", + "size": 1169870, + "subdir": "linux-64", + "timestamp": 1553289261066, + "version": "1.1.4" + }, + "dask-core-1.1.4-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "66f78612dc145b0f6a49a8766f40ff4c", + "name": "dask-core", + "sha256": "fcfb1927b5bfc31ed6984db6a6daa98ad3e443b71116d20b66ba2b4dd9ba0d10", + "size": 1181458, + "subdir": "linux-64", + "timestamp": 1553289398919, + "version": "1.1.4" + }, + "dask-core-1.1.4-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0a4c60c41afd70fd9745405918f6f887", + "name": "dask-core", + "sha256": "d3a646e6b66780be44d9569586aed31edf3aeb55c385adedd744b61f6e49584d", + "size": 1174767, + "subdir": "linux-64", + "timestamp": 1553290469269, + "version": "1.1.4" + }, + "dask-core-2022.5.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "packaging >=20.0", + "partd >=0.3.10", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6933465f9f2195db19c4763adf872f87", + "name": "dask-core", + "sha256": "bce34410b56df66b517b84b7b150ffa450be39725aabec5f87ec397ac02676f2", + "size": 1735534, + "subdir": "linux-64", + "timestamp": 1653082150114, + "version": "2022.5.0" + }, + "dask-core-2022.5.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "packaging >=20.0", + "partd >=0.3.10", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0c71c94a4e507343aa4ea50e18a575b6", + "name": "dask-core", + "sha256": "b428589b25777a1b0bb8a97085b3dec25fc08446651de8344c37aee8a1ad7178", + "size": 2407471, + "subdir": "linux-64", + "timestamp": 1676830456388, + "version": "2022.5.0" + }, + "dask-core-2022.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "packaging >=20.0", + "partd >=0.3.10", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d9e2917bed5f51aeb2ea2ea70f8e552", + "name": "dask-core", + "sha256": "11570dd8675aadd67bf80ecd9bb66388907f0677ea2b9eba90915924d0f52ec8", + "size": 1720154, + "subdir": "linux-64", + "timestamp": 1653082182985, + "version": "2022.5.0" + }, + "dask-core-2022.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "packaging >=20.0", + "partd >=0.3.10", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a971faddd8461daa895f37aaf6b5b7b3", + "name": "dask-core", + "sha256": "49621eca3c55bcbac5e1fcc9de49d6ec09ec930e79a89ca18ecea0938a12f363", + "size": 1717089, + "subdir": "linux-64", + "timestamp": 1653082218001, + "version": "2022.5.0" + }, + "dask-core-2022.7.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "packaging >=20.0", + "partd >=0.3.10", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5c48fe359572f2ebab9a44363af510ec", + "name": "dask-core", + "sha256": "d176c64188e4a542a95850b2a31c5d2543807089c7c4ca3bdb4e44ec71441de8", + "size": 1796123, + "subdir": "linux-64", + "timestamp": 1658513320718, + "version": "2022.7.0" + }, + "dask-core-2022.7.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "packaging >=20.0", + "partd >=0.3.10", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a2443f57888a63cd1a8909530b1ea2a7", + "name": "dask-core", + "sha256": "a1510b84fda185611d467d3a2c402f6af598f4e26114f19be60b2c990ecb08ca", + "size": 2462443, + "subdir": "linux-64", + "timestamp": 1679335874349, + "version": "2022.7.0" + }, + "dask-core-2022.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "packaging >=20.0", + "partd >=0.3.10", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "83cad3b4b1c306654e8c895c75386ec0", + "name": "dask-core", + "sha256": "a5cbff6990a237c871a6560a47e903372d3e79873b3700ace1cca7593cfe23db", + "size": 1780370, + "subdir": "linux-64", + "timestamp": 1658513277567, + "version": "2022.7.0" + }, + "dask-core-2022.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "packaging >=20.0", + "partd >=0.3.10", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "06872c8a11825fda3841cdcda23bf635", + "name": "dask-core", + "sha256": "f13a55918244ffe46e0692480803c654c64e78a781bf6843ea85552ec0c8ce70", + "size": 1776655, + "subdir": "linux-64", + "timestamp": 1658513245185, + "version": "2022.7.0" + }, + "dask-core-2023.3.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.0", + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "importlib-metadata >=4.13.0", + "packaging >=20.0", + "partd >=1.2.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5eba2ae36b20fa7b7b2d6869fc373d7e", + "name": "dask-core", + "sha256": "c89dd1cebc0dcc154275dd57b194b478a949f74a7a22290107ca99829a035cf0", + "size": 2189840, + "subdir": "linux-64", + "timestamp": 1680090611186, + "version": "2023.3.2" + }, + "dask-core-2023.3.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.0", + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "importlib-metadata >=4.13.0", + "packaging >=20.0", + "partd >=1.2.0", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ba95a75f6d4933c228fa95a1efd0cce6", + "name": "dask-core", + "sha256": "5afe8bc699ea5e0dc3576a780dc80ea8c6b2f6a88b40d977960b5df073817070", + "size": 2968693, + "subdir": "linux-64", + "timestamp": 1680090540232, + "version": "2023.3.2" + }, + "dask-core-2023.3.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.0", + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "importlib-metadata >=4.13.0", + "packaging >=20.0", + "partd >=1.2.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "33eae3c2a255dec15b7e2c8c1cf58670", + "name": "dask-core", + "sha256": "d5e55d57938ba908350562342ab236777af48f551f748700d111334bf373ecd9", + "size": 2172524, + "subdir": "linux-64", + "timestamp": 1680090645829, + "version": "2023.3.2" + }, + "dask-core-2023.3.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.0", + "cloudpickle >=1.1.1", + "fsspec >=0.6.0", + "importlib-metadata >=4.13.0", + "packaging >=20.0", + "partd >=1.2.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.3.1", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff8fdaa1f0f7d408e4dff547c94af7e1", + "name": "dask-core", + "sha256": "1459da915bf2af179323164dadd44a9bd926093a7736618b826a4017642f776a", + "size": 2170245, + "subdir": "linux-64", + "timestamp": 1680090574965, + "version": "2023.3.2" + }, + "dask-glm-0.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=2.7,<2.8.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3e9e8337aa0b6f56fbfb057e64c10d84", + "name": "dask-glm", + "sha256": "85986815d7e4617ffc4b77ffb53094308ede6ed3b0fa4cdb260b4f65412fdf4b", + "size": 23854, + "subdir": "linux-64", + "timestamp": 1530842711639, + "version": "0.1.0" + }, + "dask-glm-0.1.0-py27h0d5619a_0.conda": { + "build": "py27h0d5619a_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=2.7,<2.8.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9e9f7ab5da38bc2efa6f23dfe318d762", + "name": "dask-glm", + "sha256": "7c4970c005f4b03fa62b77360912ca387672cc4f4206b2f62dd6b67a8975dad9", + "size": 24346, + "subdir": "linux-64", + "timestamp": 1511217833354, + "version": "0.1.0" + }, + "dask-glm-0.1.0-py35h984da01_0.conda": { + "build": "py35h984da01_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=3.5,<3.6.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6c0e29b7b09f048ff7258f2005567038", + "name": "dask-glm", + "sha256": "a34873f4eacacd2bab0cb7fc1aaf241f872070ebd8d8dd3a210e9ccc19400dc3", + "size": 24819, + "subdir": "linux-64", + "timestamp": 1511217906248, + "version": "0.1.0" + }, + "dask-glm-0.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "18428c25fa54f995de4f314c6660e39d", + "name": "dask-glm", + "sha256": "ba8f1ca3c303d32930c90a50d35a68303851e9726cdf56ba2cf85740b461eccf", + "size": 24239, + "subdir": "linux-64", + "timestamp": 1530842742257, + "version": "0.1.0" + }, + "dask-glm-0.1.0-py36h1ff08bd_0.conda": { + "build": "py36h1ff08bd_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8d46260bce6b0535d455d2da674378d5", + "name": "dask-glm", + "sha256": "2b8b98656d49662d68878a6bc1acadb78c1e7f151ce9f1275ed1ed56dea9476e", + "size": 24581, + "subdir": "linux-64", + "timestamp": 1511217841338, + "version": "0.1.0" + }, + "dask-glm-0.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e292036c9542f191a36a4b43d112cb36", + "name": "dask-glm", + "sha256": "4c478d0d3239d60b92d7f4aa04cbef1c06143bf8ec483c044e27548d623f690b", + "size": 24414, + "subdir": "linux-64", + "timestamp": 1530842681903, + "version": "0.1.0" + }, + "dask-glm-0.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=2.7,<2.8.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f66a24b9a7655139c88e92ffaa4da511", + "name": "dask-glm", + "sha256": "dc8310f573fca9765da298f244f9812d827a1a816a77d937f82d571d4410d94a", + "size": 24219, + "subdir": "linux-64", + "timestamp": 1540963173751, + "version": "0.2.0" + }, + "dask-glm-0.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1c0e7628fef66a6447dfe3636178a23e", + "name": "dask-glm", + "sha256": "f58527966ab1eaddb9460e2f814d8d45cac31a41dc13a1b4d175e76c07c74345", + "size": 25130, + "subdir": "linux-64", + "timestamp": 1642517256876, + "version": "0.2.0" + }, + "dask-glm-0.2.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=3.11,<3.12.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9576a9c3ac924e843e1edcdd60476ff0", + "name": "dask-glm", + "sha256": "5e955a979f51994b7fa4efbb822a9cb2ac8c62364d19e682b850eabd8000bdb6", + "size": 32449, + "subdir": "linux-64", + "timestamp": 1676851856499, + "version": "0.2.0" + }, + "dask-glm-0.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a47d3fd9a1772729d0bd2da08bff3c3d", + "name": "dask-glm", + "sha256": "1d1a8478cef89def8c3f9b6bff3173bcd876ea972e764a8e58729c219d3a227d", + "size": 24603, + "subdir": "linux-64", + "timestamp": 1540963196507, + "version": "0.2.0" + }, + "dask-glm-0.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7a80685f762d6a6cc5177d0203a3d920", + "name": "dask-glm", + "sha256": "5d078510711342b45851d9b17290b56a91bcadb8b4f5c04f03e4d2ac049335c2", + "size": 24752, + "subdir": "linux-64", + "timestamp": 1540963181258, + "version": "0.2.0" + }, + "dask-glm-0.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "dask", + "multipledispatch >=0.4.9", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.18", + "scipy >=0.18.1", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20807f7c552cf7e03cf22b384158d573", + "name": "dask-glm", + "sha256": "594d8dccb066bdb9a345919e06d6501e575a72dd32a7e39701cd6310d95407ea", + "size": 25085, + "subdir": "linux-64", + "timestamp": 1574235675962, + "version": "0.2.0" + }, + "dask-ml-0.10.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d3df177e525dde4cf35e2b561d253ff2", + "name": "dask-ml", + "sha256": "b132253c068e86e9f54448aa24c4db47d3e9d3c9af123a35fc64049fc0eb3e16", + "size": 139623, + "subdir": "linux-64", + "timestamp": 1538172041983, + "version": "0.10.0" + }, + "dask-ml-0.10.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0920e97fb35917ee1489cfe62605b041", + "name": "dask-ml", + "sha256": "1905e9d7a65486a371f1513f53506fb3e6fddaf9251211e2008183d553d296a9", + "size": 140711, + "subdir": "linux-64", + "timestamp": 1538172071259, + "version": "0.10.0" + }, + "dask-ml-0.10.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "abc60a991c59a05659cf9fe7afe89461", + "name": "dask-ml", + "sha256": "b5942222ea463a8bb600ec36d42636d41858ff40bd6b897bc788e8f4e6df9c41", + "size": 138705, + "subdir": "linux-64", + "timestamp": 1538172047625, + "version": "0.10.0" + }, + "dask-ml-0.11.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=2.7,<2.8.0a0", + "scikit-learn >=0.20.0", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "837780ff5357d938aaf39a35ebbf59b7", + "name": "dask-ml", + "sha256": "022b571a924c0eebe58f65f0072bcb09a86516603b9c5a760692109b6bac7028", + "size": 146965, + "subdir": "linux-64", + "timestamp": 1540963772729, + "version": "0.11.0" + }, + "dask-ml-0.11.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.20.0", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "21e5220c7c037ebd3779a9a9cb1003e5", + "name": "dask-ml", + "sha256": "b1206e7cc5c02a9ec65d72a7638cd8800f381c6393163a8a4da83af9df9ee468", + "size": 150372, + "subdir": "linux-64", + "timestamp": 1540963836429, + "version": "0.11.0" + }, + "dask-ml-0.11.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.20.0", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f17efa1835918e41c9d0efbe9a31de13", + "name": "dask-ml", + "sha256": "34f2a296f6bfd7282eb441fcf1b5ff1a80268434d20d10736923a638f768f8e2", + "size": 147905, + "subdir": "linux-64", + "timestamp": 1540963783242, + "version": "0.11.0" + }, + "dask-ml-0.3.2-py27h2dd1506_0.conda": { + "build": "py27h2dd1506_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a0a7a9b5da3012feb61728b72cf7379c", + "name": "dask-ml", + "sha256": "6de386e0f57cb823735bc32ab8b8399f383a2571cbc901a43496445d340affd6", + "size": 137905, + "subdir": "linux-64", + "timestamp": 1511218792413, + "version": "0.3.2" + }, + "dask-ml-0.3.2-py35hf347010_0.conda": { + "build": "py35hf347010_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a0ce7e5483ead9741aa70246813f70ed", + "name": "dask-ml", + "sha256": "e80a8263546582098cbfc3d89aaff89632d174cefe64afe988f92e16640a8878", + "size": 133520, + "subdir": "linux-64", + "timestamp": 1511218910374, + "version": "0.3.2" + }, + "dask-ml-0.3.2-py36h51e09e3_0.conda": { + "build": "py36h51e09e3_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6cd9299eeb8dcd70d40805481517ebe4", + "name": "dask-ml", + "sha256": "7bfa17f47a85a60c564a21174888c57e4603c8bc0d8da707ccd292e828560ab2", + "size": 133759, + "subdir": "linux-64", + "timestamp": 1511218911865, + "version": "0.3.2" + }, + "dask-ml-0.4.1-py27h3010b51_0.conda": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4b88c6157134f5f5058d7f45485e6f6f", + "name": "dask-ml", + "sha256": "55bca75df6596c0b22499331729fd79eea7003ef951508ef17bd2c5df60afbb3", + "size": 152105, + "subdir": "linux-64", + "timestamp": 1519495484756, + "version": "0.4.1" + }, + "dask-ml-0.4.1-py35h3010b51_0.conda": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4a6fb4c64b144b07ace5ea74eaf215f0", + "name": "dask-ml", + "sha256": "0eb0622b565535d516fe4d22286f6893603aca70209953bc4b44ef1272089bdd", + "size": 148465, + "subdir": "linux-64", + "timestamp": 1519496624631, + "version": "0.4.1" + }, + "dask-ml-0.4.1-py36h3010b51_0.conda": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "168ae58726105c971e1ee934fbe4b822", + "name": "dask-ml", + "sha256": "e8c4a00533d088452cda774cdf7ee9a009add7e7b25364b334d87e13d27ea1ad", + "size": 148472, + "subdir": "linux-64", + "timestamp": 1519494998311, + "version": "0.4.1" + }, + "dask-ml-0.6.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ed7ddfe2dc25d3ff31a69c6046aaa8ae", + "name": "dask-ml", + "sha256": "364a6be9191a3914b234ae46c6f0118e113257a755a72e45529937d4a1b64c04", + "size": 167618, + "subdir": "linux-64", + "timestamp": 1529443076307, + "version": "0.6.0" + }, + "dask-ml-0.6.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8637ee8bfaad7a9d4810fd7eb3277056", + "name": "dask-ml", + "sha256": "a462a7218400edbc9860c8518c6f4aabe994b38c3165ff88932f9fb28d606cba", + "size": 164399, + "subdir": "linux-64", + "timestamp": 1529443103569, + "version": "0.6.0" + }, + "dask-ml-0.6.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "045a641f027523045ef2dd14d8fb5811", + "name": "dask-ml", + "sha256": "0210479b95b8aa68f4ad13ee5af1b92bfaaaae930f3d71906a346a5f6433e521", + "size": 164520, + "subdir": "linux-64", + "timestamp": 1529443320632, + "version": "0.6.0" + }, + "dask-ml-0.6.0-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "dask-searchcv", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5549c1214fde4eaee197c1ae9bb8df1f", + "name": "dask-ml", + "sha256": "020c94caf7d5c18d5153c04de3615942063a69a998a7f1287dc06a8c978eb337", + "size": 164697, + "subdir": "linux-64", + "timestamp": 1530842889224, + "version": "0.6.0" + }, + "dask-ml-0.7.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "81eee7c0bca7a7555330f91cf1a80f13", + "name": "dask-ml", + "sha256": "4b2ca6586fce00ecd22c30eedc838a753660737fc67af029a37a3aa9f9ab0119", + "size": 203112, + "subdir": "linux-64", + "timestamp": 1532555180999, + "version": "0.7.0" + }, + "dask-ml-0.7.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a2bf7abf7273af4eb3c7c8b03c039d73", + "name": "dask-ml", + "sha256": "dce357e55968ada807e0da846ddef1484d82ad8cc41e3b52275f91556810100d", + "size": 199984, + "subdir": "linux-64", + "timestamp": 1532555182227, + "version": "0.7.0" + }, + "dask-ml-0.7.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3708dd417406f6cdb08857e445c7b934", + "name": "dask-ml", + "sha256": "ed4f0adc74ab8cbcba60b98b4a0ca11f68a4d5735ed4e648be221faad769d699", + "size": 198369, + "subdir": "linux-64", + "timestamp": 1532555083258, + "version": "0.7.0" + }, + "dask-ml-0.7.0-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1f1af3a71a9c08d5e833e2cfc49d44f6", + "name": "dask-ml", + "sha256": "88572b73db15349d74256b9eddee13434b753a9c99320adf25d6a340b1f0e502", + "size": 198233, + "subdir": "linux-64", + "timestamp": 1532555158952, + "version": "0.7.0" + }, + "dask-ml-0.8.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "packaging", + "pandas", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "14e9073842a015d815540efb381079de", + "name": "dask-ml", + "sha256": "008ba99603b03e37132a078b1c16a5fbbabd694ca4a4c2f246d16b6e695a8d33", + "size": 213496, + "subdir": "linux-64", + "timestamp": 1534426732820, + "version": "0.8.0" + }, + "dask-ml-0.8.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "packaging", + "pandas", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1753ac193629ac283c784c5a9e2bf779", + "name": "dask-ml", + "sha256": "3a654f9656c8054cdb7b81a1a9b38264b76676e0099f5084184741ca72b4828e", + "size": 212298, + "subdir": "linux-64", + "timestamp": 1534426900644, + "version": "0.8.0" + }, + "dask-ml-0.8.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "packaging", + "pandas", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "98855a0cfbabc4832a5e962ca2f2acff", + "name": "dask-ml", + "sha256": "4ca0ece4a0ffdc71aaade7564369fa86aca53b5430906f415031ff9425ce7c18", + "size": 209064, + "subdir": "linux-64", + "timestamp": 1534426677426, + "version": "0.8.0" + }, + "dask-ml-0.8.0-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "dask", + "dask-glm", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "packaging", + "pandas", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "45ae900a3d91fdd98364c87a5756f29d", + "name": "dask-ml", + "sha256": "f5bed419668137b3986a6bf05d9d2c03e2930b882d194d88d9a58c77b7236a1c", + "size": 209087, + "subdir": "linux-64", + "timestamp": 1534426807012, + "version": "0.8.0" + }, + "dask-ml-0.9.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e95e52044bc5d95c9ba2bfbdf318e804", + "name": "dask-ml", + "sha256": "da3f241076be785e3acce0650474e53e13d2b6bdb7c4a9c00d4f3442f9b22506", + "size": 127053, + "subdir": "linux-64", + "timestamp": 1535636912531, + "version": "0.9.0" + }, + "dask-ml-0.9.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d74065178870ab07f06a64986851b5c", + "name": "dask-ml", + "sha256": "47d62bea89e4bea86aca47fbb0b335277b668e0d183d08d00dfe0f553610b334", + "size": 130994, + "subdir": "linux-64", + "timestamp": 1535636909000, + "version": "0.9.0" + }, + "dask-ml-0.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a23c62ab040dc782aa16285238c65368", + "name": "dask-ml", + "sha256": "8125fd5f336efafd3046aa2e368160d50ef1ad620d9edc6fbb9d3d21adb30395", + "size": 128098, + "subdir": "linux-64", + "timestamp": 1535636880197, + "version": "0.9.0" + }, + "dask-ml-0.9.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dask >=0.18.2", + "dask-glm", + "multipledispatch >=0.4.9", + "numba", + "numpy", + "packaging", + "pandas >=0.21.0", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9479885363df5d735c8ed7e0fa8595bf", + "name": "dask-ml", + "sha256": "44839bb8bf6e0dc72e286a94a9bdc31ff46f3f797d8e748a726d10467118c4d6", + "size": 128213, + "subdir": "linux-64", + "timestamp": 1535636951756, + "version": "0.9.0" + }, + "dask-ml-2022.5.27-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.4.0", + "dask-glm >=0.2.0", + "distributed >=2.4.0", + "multipledispatch >=0.4.9", + "numba >=0.51.0", + "numpy >=1.20.0", + "packaging", + "pandas >=0.24.2", + "python >=3.10,<3.11.0a0", + "scikit-learn >=1.0.0", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5bb198448c90d3ac6fe0547bdbd2f413", + "name": "dask-ml", + "sha256": "08e20c22e4d5a7a70dc6b10198115b0862375a185c06f671e35b343a15067668", + "size": 217510, + "subdir": "linux-64", + "timestamp": 1672127756481, + "version": "2022.5.27" + }, + "dask-ml-2022.5.27-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.4.0", + "dask-glm >=0.2.0", + "distributed >=2.4.0", + "multipledispatch >=0.4.9", + "numba >=0.51.0", + "numpy >=1.20.0", + "packaging", + "pandas >=0.24.2", + "python >=3.7,<3.8.0a0", + "scikit-learn >=1.0.0", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5b23c5bc96e4fcf8bda36a8b17ea07e4", + "name": "dask-ml", + "sha256": "ebc38e12f97434a7e0ed4d0cc582bc36dcf20bb20a9ee5d0b2138b6f206a1b01", + "size": 214252, + "subdir": "linux-64", + "timestamp": 1672127655515, + "version": "2022.5.27" + }, + "dask-ml-2022.5.27-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.4.0", + "dask-glm >=0.2.0", + "distributed >=2.4.0", + "multipledispatch >=0.4.9", + "numba >=0.51.0", + "numpy >=1.20.0", + "packaging", + "pandas >=0.24.2", + "python >=3.8,<3.9.0a0", + "scikit-learn >=1.0.0", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fbe156f86010e48f70d6a5d77411f988", + "name": "dask-ml", + "sha256": "18f61437e92ada0a48a30cc09bc2fbcedf94d67de39cce827c96fc18fd2a5bd6", + "size": 215736, + "subdir": "linux-64", + "timestamp": 1672127707877, + "version": "2022.5.27" + }, + "dask-ml-2022.5.27-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.4.0", + "dask-glm >=0.2.0", + "distributed >=2.4.0", + "multipledispatch >=0.4.9", + "numba >=0.51.0", + "numpy >=1.20.0", + "packaging", + "pandas >=0.24.2", + "python >=3.9,<3.10.0a0", + "scikit-learn >=1.0.0", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "485a44f99a018d844511324abbbba3a3", + "name": "dask-ml", + "sha256": "72a81c234df29a1be710587d7ebaeaa0fc39d6b8b55eb6493aa268d4fc1dcc13", + "size": 215508, + "subdir": "linux-64", + "timestamp": 1672127806612, + "version": "2022.5.27" + }, + "dask-searchcv-0.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "dask >=0.14.0", + "numpy >=1.8.0", + "python >=2.7,<2.8.0a0", + "scikit-learn >=0.18.0", + "scipy >=0.13.0", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8861500b064ea85acd989dd2b11df587", + "name": "dask-searchcv", + "sha256": "9ffbf56c57c5164b3c31ed661564bf0768116e992cc43b7e8b7b769db70a01d7", + "size": 71062, + "subdir": "linux-64", + "timestamp": 1530842807485, + "version": "0.2.0" + }, + "dask-searchcv-0.2.0-py27h5e106ca_0.conda": { + "build": "py27h5e106ca_0", + "build_number": 0, + "depends": [ + "dask >=0.14.0", + "numpy >=1.8.0", + "python >=2.7,<2.8.0a0", + "scikit-learn >=0.18.0", + "scipy >=0.13.0", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "db5900c03b08e8ab7d2c2cc2454ee7f1", + "name": "dask-searchcv", + "sha256": "c73519af0c3d3fb6aaa95c68502e2400f8ed04f64c6004372b94316687b1aa63", + "size": 71381, + "subdir": "linux-64", + "timestamp": 1511217841659, + "version": "0.2.0" + }, + "dask-searchcv-0.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=0.14.0", + "numpy >=1.8.0", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.18.0", + "scipy >=0.13.0", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "14b032c746760819514053a607df0356", + "name": "dask-searchcv", + "sha256": "cdfd9b7476f6e8bd4b5be22dd278c368dbba2b3b58faf8b174478fb1b6dc92e3", + "size": 72450, + "subdir": "linux-64", + "timestamp": 1640811916097, + "version": "0.2.0" + }, + "dask-searchcv-0.2.0-py35h2cd24c2_0.conda": { + "build": "py35h2cd24c2_0", + "build_number": 0, + "depends": [ + "dask >=0.14.0", + "numpy >=1.8.0", + "python >=3.5,<3.6.0a0", + "scikit-learn >=0.18.0", + "scipy >=0.13.0", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2871638a358de1dcd5b40526c5565527", + "name": "dask-searchcv", + "sha256": "520c1e133ee11fcb26a1e79a7209cf3580d7de312a2bccb8b8860952fab154f6", + "size": 73037, + "subdir": "linux-64", + "timestamp": 1511217869648, + "version": "0.2.0" + }, + "dask-searchcv-0.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "dask >=0.14.0", + "numpy >=1.8.0", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.18.0", + "scipy >=0.13.0", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "98d1ada3d9ebf9ab33c8467b44bf89fb", + "name": "dask-searchcv", + "sha256": "19383ca2a6caf011ea176f8bb2220e81c7f026aed51930616960dda11ac42f39", + "size": 71171, + "subdir": "linux-64", + "timestamp": 1530842838700, + "version": "0.2.0" + }, + "dask-searchcv-0.2.0-py36hae2c3c3_0.conda": { + "build": "py36hae2c3c3_0", + "build_number": 0, + "depends": [ + "dask >=0.14.0", + "numpy >=1.8.0", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.18.0", + "scipy >=0.13.0", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a7726b2ab31d221b520d229eab63131a", + "name": "dask-searchcv", + "sha256": "305dd606fbff44f7e1c5b7ae5f45685fb632185cca0261e1811ef5517531033a", + "size": 71499, + "subdir": "linux-64", + "timestamp": 1511217906306, + "version": "0.2.0" + }, + "dask-searchcv-0.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dask >=0.14.0", + "numpy >=1.8.0", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.18.0", + "scipy >=0.13.0", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "73b2fa450b785238394a8887a18feeab", + "name": "dask-searchcv", + "sha256": "91b1a5110a5285de1441eb383fd2085ae389873458f8cf03c261755b4b1878af", + "size": 71256, + "subdir": "linux-64", + "timestamp": 1530842778271, + "version": "0.2.0" + }, + "dask-searchcv-0.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "dask >=0.14.0", + "numpy >=1.8.0", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.18.0", + "scipy >=0.13.0", + "toolz >=0.8.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2507af2cdee1c4fa9fb6879c97839e50", + "name": "dask-searchcv", + "sha256": "0a8b5e3ee9f97e7527196ea86f7c4f3bd9dbc9820dbd9c3336571102bc338415", + "size": 72779, + "subdir": "linux-64", + "timestamp": 1574235694589, + "version": "0.2.0" + }, + "dataclasses-0.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "3d2d58be2ea26a26efefb621a4dca623", + "name": "dataclasses", + "sha256": "f9fe8f9bbbaff27a87d6e96f97c79f402a60e560a0fa50ff165d6c885c931998", + "size": 30782, + "subdir": "linux-64", + "timestamp": 1582149830248, + "version": "0.7" + }, + "dataclasses-0.7-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "1f5d45e5c132dc25e38318caa840fb0b", + "name": "dataclasses", + "sha256": "72e97b431fcacc45d067205ee967d0a18be2f0978a2882cf67e49603e541e6cf", + "size": 30855, + "subdir": "linux-64", + "timestamp": 1614076478266, + "version": "0.7" + }, + "dataclasses-0.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "ae452172f94aec8bee79f8968cd8f272", + "name": "dataclasses", + "sha256": "1c7652968a36dc167ed022fcff9fa1ae87b549f6e9f0244b1eb0df4cafbd7295", + "size": 8952, + "subdir": "linux-64", + "timestamp": 1582149612209, + "version": "0.7" + }, + "dataclasses-0.7-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "0d765e38e84ee62f7335a917a3b91ac5", + "name": "dataclasses", + "sha256": "6f9c13b2a2f6e964c870b3bef8ff49c751911fe81c39da594ef344661d27b005", + "size": 8981, + "subdir": "linux-64", + "timestamp": 1614076480587, + "version": "0.7" + }, + "dataclasses-0.7-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "7654cf33b281b40369670725b729ef83", + "name": "dataclasses", + "sha256": "7bd5af3892bb2fabfb6f726dec4589adcb760b1686552b2ca39ae16369150212", + "size": 8994, + "subdir": "linux-64", + "timestamp": 1582149808479, + "version": "0.7" + }, + "dataclasses-0.7-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "c60ada31778c15737940ad5a87bf79b4", + "name": "dataclasses", + "sha256": "967822ce386f4543206055fce5d1a9fc3ec2c59300ee07d52bfd88c0f7644256", + "size": 8975, + "subdir": "linux-64", + "timestamp": 1614076476338, + "version": "0.7" + }, + "dataclasses-0.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "acecb82e45c61c608ab229352c5c57fe", + "name": "dataclasses", + "sha256": "a972e332f2f2b09bea3ea0480b7ebb07ce31841f717f30d880b41e25976880e6", + "size": 8996, + "subdir": "linux-64", + "timestamp": 1614076040175, + "version": "0.7" + }, + "datasets-2.10.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "dill <0.3.7", + "fsspec >=2021.11.1", + "huggingface_hub >=0.2.0,<1.0.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "pyarrow >=6.0.0", + "python >=3.10,<3.11.0a0", + "python-xxhash", + "pyyaml >=5.1", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fe99d40d25afa26b2acd229a9d6b11d1", + "name": "datasets", + "sha256": "c1877574f828f9284fabd99987ac831ac6683cd8b49c8560aea22fa9756116f7", + "size": 658742, + "subdir": "linux-64", + "timestamp": 1679487100841, + "version": "2.10.1" + }, + "datasets-2.10.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "dill <0.3.7", + "fsspec >=2021.11.1", + "huggingface_hub >=0.2.0,<1.0.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "pyarrow >=6.0.0", + "python >=3.11,<3.12.0a0", + "python-xxhash", + "pyyaml >=5.1", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cc34070e44673a895444800cf1a4bb92", + "name": "datasets", + "sha256": "00be73f6a86148402a4fa0d4b5c588d00a31d3df17801a3e8c19d473f4bea089", + "size": 886230, + "subdir": "linux-64", + "timestamp": 1679487052874, + "version": "2.10.1" + }, + "datasets-2.10.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "dill <0.3.7", + "fsspec >=2021.11.1", + "huggingface_hub >=0.2.0,<1.0.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "pyarrow >=6.0.0", + "python >=3.8,<3.9.0a0", + "python-xxhash", + "pyyaml >=5.1", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7629d7d22a45d6fb77ea9ea37cc9f66c", + "name": "datasets", + "sha256": "0760539adc67b791493b213bcd8f6a3aa1a7479c78b80247ab23d5ec74a0c8e4", + "size": 651837, + "subdir": "linux-64", + "timestamp": 1679487004344, + "version": "2.10.1" + }, + "datasets-2.10.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "dill <0.3.7", + "fsspec >=2021.11.1", + "huggingface_hub >=0.2.0,<1.0.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "pyarrow >=6.0.0", + "python >=3.9,<3.10.0a0", + "python-xxhash", + "pyyaml >=5.1", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f4d323b3db9b77523a7fdf5ac390de6f", + "name": "datasets", + "sha256": "39b50866ae3e7aab0c034656a78eb948fcdb93460bc28a229c0fe5808654cc9b", + "size": 651744, + "subdir": "linux-64", + "timestamp": 1679486948054, + "version": "2.10.1" + }, + "datasets-2.6.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "dill <0.3.7", + "fsspec >=2021.11.1", + "huggingface_hub >=0.2.0,<1.0.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "pyarrow >=6.0.0", + "python >=3.10,<3.11.0a0", + "python-xxhash", + "pyyaml >=5.1", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cc41ea5ff835398969d15f9dac1662dc", + "name": "datasets", + "sha256": "e2bb2e2a2247efde2d1ee034f9deed523d218168676e5fd5f2f418a1b415043e", + "size": 607041, + "subdir": "linux-64", + "timestamp": 1668181601248, + "version": "2.6.1" + }, + "datasets-2.6.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "dill <0.3.7", + "fsspec >=2021.11.1", + "huggingface_hub >=0.2.0,<1.0.0", + "importlib-metadata", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "pyarrow >=6.0.0", + "python >=3.7,<3.8.0a0", + "python-xxhash", + "pyyaml >=5.1", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9da54373528f258702e4a27ee8eb6b93", + "name": "datasets", + "sha256": "d5e0d7a427ce51e3f30ceb000f3a19ed1e5b660503498bcfb0106dec357b6d77", + "size": 594604, + "subdir": "linux-64", + "timestamp": 1668181548087, + "version": "2.6.1" + }, + "datasets-2.6.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "dill <0.3.7", + "fsspec >=2021.11.1", + "huggingface_hub >=0.2.0,<1.0.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "pyarrow >=6.0.0", + "python >=3.8,<3.9.0a0", + "python-xxhash", + "pyyaml >=5.1", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a726ab3d2db789d17371fb87210c23e0", + "name": "datasets", + "sha256": "eab919c0679919c9984896b09790a6ee96d4f89fbe266b44824ac787836f4429", + "size": 599271, + "subdir": "linux-64", + "timestamp": 1668181693424, + "version": "2.6.1" + }, + "datasets-2.6.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "dill <0.3.7", + "fsspec >=2021.11.1", + "huggingface_hub >=0.2.0,<1.0.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "pyarrow >=6.0.0", + "python >=3.9,<3.10.0a0", + "python-xxhash", + "pyyaml >=5.1", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b5b070a834a8e7594ac5cc7621a10713", + "name": "datasets", + "sha256": "ca5c15e963b8da7d2e3f73dee6bd7ec3f570c7b64a12b5a4c0c36c178fa1377f", + "size": 600418, + "subdir": "linux-64", + "timestamp": 1668181647403, + "version": "2.6.1" + }, + "datashader-0.14.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "numpy >=1.18,<1.22" + ], + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.18.0", + "datashape >=0.5.1", + "numba >=0.51", + "numpy >=1.7", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.10,<3.11.0a0", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5abb6d405a8f358463f9f76376aede3d", + "name": "datashader", + "sha256": "02d37e782a82259b77e9bb331eacf839e95934e054f7331b33f605cf99e3f5e1", + "size": 17316874, + "subdir": "linux-64", + "timestamp": 1659349172234, + "version": "0.14.1" + }, + "datashader-0.14.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "bokeh <3.0.0", + "colorcet >=0.9.0", + "dask >=0.18.0", + "datashape >=0.5.1", + "numba >=0.51", + "numpy >=1.18,!=1.22.0,!=1.22.1,!=1.22.2,<1.23", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.10,<3.11.0a0", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "973ca164a7352ffa9714c4f436763491", + "name": "datashader", + "sha256": "cf232832bcabcaa3b013b0dedfd0d750e45ac7e0bfaf776786400770bf228f7b", + "size": 17556917, + "subdir": "linux-64", + "timestamp": 1668502678594, + "version": "0.14.1" + }, + "datashader-0.14.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "numpy >=1.18,<1.22" + ], + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.18.0", + "datashape >=0.5.1", + "numba >=0.51", + "numpy >=1.7", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.7,<3.8.0a0", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7a528c1f3537a66d863a1a6503119083", + "name": "datashader", + "sha256": "9c9081591844af24e49df70fd01e05a88b427f1e57d97d4594fd9246c44fe26c", + "size": 17303354, + "subdir": "linux-64", + "timestamp": 1659349348419, + "version": "0.14.1" + }, + "datashader-0.14.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "bokeh <3.0.0", + "colorcet >=0.9.0", + "dask >=0.18.0", + "datashape >=0.5.1", + "numba >=0.51", + "numpy >=1.18,!=1.22.0,!=1.22.1,!=1.22.2,<1.23", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.7,<3.8.0a0", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "973af340c9f8e728c390836f0b9cc2b3", + "name": "datashader", + "sha256": "99709bd4cae9ac0321d958f9843c5653658852fa83f9cef9e56812d420efb8ef", + "size": 17552979, + "subdir": "linux-64", + "timestamp": 1668502460158, + "version": "0.14.1" + }, + "datashader-0.14.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "numpy >=1.18,<1.22" + ], + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.18.0", + "datashape >=0.5.1", + "numba >=0.51", + "numpy >=1.7", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.8,<3.9.0a0", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "867f3c353b0541d3bc7c2e51a13c219c", + "name": "datashader", + "sha256": "1758192516dbbbd421d7cfd3c708a231d6fbf7ed55cedb3956b275b2954d4db7", + "size": 17314695, + "subdir": "linux-64", + "timestamp": 1659349257883, + "version": "0.14.1" + }, + "datashader-0.14.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "bokeh <3.0.0", + "colorcet >=0.9.0", + "dask >=0.18.0", + "datashape >=0.5.1", + "numba >=0.51", + "numpy >=1.18,!=1.22.0,!=1.22.1,!=1.22.2,<1.23", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.8,<3.9.0a0", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e5c0fc2ae4705a95a92e7aa8b8d1ef82", + "name": "datashader", + "sha256": "343d428392c1d5844c874bd99cfa09f2ad98baa589e2e0346c41e34ca92da6c6", + "size": 17557941, + "subdir": "linux-64", + "timestamp": 1668502341945, + "version": "0.14.1" + }, + "datashader-0.14.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "numpy >=1.18,<1.22" + ], + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.18.0", + "datashape >=0.5.1", + "numba >=0.51", + "numpy >=1.7", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.9,<3.10.0a0", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "40712e8809ec768e7479cd114e8c742f", + "name": "datashader", + "sha256": "e4e533634bfdb9d621581e1ce2854ade47989f809d65e1f0c2a6ef9227e53059", + "size": 17315885, + "subdir": "linux-64", + "timestamp": 1659349073339, + "version": "0.14.1" + }, + "datashader-0.14.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "bokeh <3.0.0", + "colorcet >=0.9.0", + "dask >=0.18.0", + "datashape >=0.5.1", + "numba >=0.51", + "numpy >=1.18,!=1.22.0,!=1.22.1,!=1.22.2,<1.23", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.9,<3.10.0a0", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "26a32451f9c5b846069101aada129b84", + "name": "datashader", + "sha256": "f324f065826d5a19e6d150d1a713c47db6a39503e221d7b0a6b0b59f16810e41", + "size": 17553765, + "subdir": "linux-64", + "timestamp": 1668502571280, + "version": "0.14.1" + }, + "datashader-0.14.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask-core", + "datashape >=0.5.1", + "numba >=0.51", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.10,<3.11.0a0", + "requests", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "306e4d618bb9d186c53fe3b7cf96be53", + "name": "datashader", + "sha256": "88324da298655f91fe9b9242a81ced78904c5149b5a0e0fe6902ce0a2b5f96c8", + "size": 17547652, + "subdir": "linux-64", + "timestamp": 1668506653180, + "version": "0.14.2" + }, + "datashader-0.14.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask-core", + "datashape >=0.5.1", + "numba >=0.51", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.7,<3.8.0a0", + "requests", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "37f583951bccb5ecdb45fa8a2c534ee4", + "name": "datashader", + "sha256": "5e9fe6260fceb5198a3d5b0041fdaff482ce7b5de77edd816cd19397bc3d1489", + "size": 17549951, + "subdir": "linux-64", + "timestamp": 1668506425569, + "version": "0.14.2" + }, + "datashader-0.14.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask-core", + "datashape >=0.5.1", + "numba >=0.51", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.8,<3.9.0a0", + "requests", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e4666a5c9079bdf66eb384c44164fa49", + "name": "datashader", + "sha256": "af67efdda57e0f11d7c9c1fdf56f29148f35d92320a5e30efcf57d14610333c9", + "size": 17553474, + "subdir": "linux-64", + "timestamp": 1668506546400, + "version": "0.14.2" + }, + "datashader-0.14.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask-core", + "datashape >=0.5.1", + "numba >=0.51", + "pandas >=0.24.1", + "param >=1.6.1", + "pillow >=3.1.1", + "pyct >=0.4.5", + "python >=3.9,<3.10.0a0", + "requests", + "scipy", + "xarray >=0.9.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f41790b2a394d9583dbc861ffbc68528", + "name": "datashader", + "sha256": "92b2af8db2d1b66cfdd4ee824de164bac2e807a416707cc1a8694ee316c59648", + "size": 17543801, + "subdir": "linux-64", + "timestamp": 1668506758641, + "version": "0.14.2" + }, + "datashader-0.14.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet", + "dask-core", + "datashape", + "numba >=0.51", + "numpy >=1.19,<2.0a", + "pandas", + "param", + "pillow", + "pyct", + "python >=3.10,<3.11.0a0", + "requests", + "scipy", + "toolz", + "xarray" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "956900dc222933b613d142b40e0bcfbe", + "name": "datashader", + "sha256": "d5ab14dbd70861699f6203d5e35a6a1bea6529e77bb3dec46b8dd51c95c276f4", + "size": 17570452, + "subdir": "linux-64", + "timestamp": 1670842171370, + "version": "0.14.3" + }, + "datashader-0.14.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet", + "dask-core", + "datashape", + "numba >=0.51", + "numpy >=1.19,<2.0a", + "pandas", + "param", + "pillow", + "pyct", + "python >=3.7,<3.8.0a0", + "requests", + "scipy", + "toolz", + "xarray" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "08ab802a7624b535b97267109bcffbe3", + "name": "datashader", + "sha256": "5c913975280adb85491945d53d0e96d09d12ca3217277a944ec91958b0711060", + "size": 17570170, + "subdir": "linux-64", + "timestamp": 1670841943015, + "version": "0.14.3" + }, + "datashader-0.14.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet", + "dask-core", + "datashape", + "numba >=0.51", + "numpy >=1.19,<2.0a", + "pandas", + "param", + "pillow", + "pyct", + "python >=3.8,<3.9.0a0", + "requests", + "scipy", + "toolz", + "xarray" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5bbe5ede64f510da62787511f3f5d2e4", + "name": "datashader", + "sha256": "f9d5af7e14d0fc9c3064f1a2c2b2ca85118d4cb403ef6d8706cb9a19fe1a7235", + "size": 17573705, + "subdir": "linux-64", + "timestamp": 1670842061652, + "version": "0.14.3" + }, + "datashader-0.14.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet", + "dask-core", + "datashape", + "numba >=0.51", + "numpy >=1.19,<2.0a", + "pandas", + "param", + "pillow", + "pyct", + "python >=3.9,<3.10.0a0", + "requests", + "scipy", + "toolz", + "xarray" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d93a0152c7301bcf70f652e6ce0a13c0", + "name": "datashader", + "sha256": "e2daa67e6e59db3c3232c18d6d37f6f78283945a3c6eafdf42bca7cd1478c598", + "size": 17570654, + "subdir": "linux-64", + "timestamp": 1670842278491, + "version": "0.14.3" + }, + "datashader-0.14.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet", + "dask-core", + "datashape", + "numba >=0.51", + "numpy >=1.19,<2.0a", + "pandas", + "param", + "pillow", + "pyct", + "python >=3.10,<3.11.0a0", + "requests", + "scipy", + "toolz", + "xarray" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "80a6039cc880153e708ae5327e3995c8", + "name": "datashader", + "sha256": "5533a1ce0a8c05c9430e6e34f5764998538b4870a682cb769ee712e2eb8cd96e", + "size": 17572094, + "subdir": "linux-64", + "timestamp": 1676023044233, + "version": "0.14.4" + }, + "datashader-0.14.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet", + "dask-core", + "datashape", + "numba >=0.51", + "numpy >=1.19,<2.0a", + "pandas", + "param", + "pillow", + "pyct", + "python >=3.7,<3.8.0a0", + "requests", + "scipy", + "toolz", + "xarray" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "62d4bd55776c35ee8332ebd77ed56b74", + "name": "datashader", + "sha256": "f51db559b61e4e7ddefd0f91b406d02bd1c7349ce5d12fd6e13a545f55ea0464", + "size": 17571031, + "subdir": "linux-64", + "timestamp": 1676022930963, + "version": "0.14.4" + }, + "datashader-0.14.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet", + "dask-core", + "datashape", + "numba >=0.51", + "numpy >=1.19,<2.0a", + "pandas", + "param", + "pillow", + "pyct", + "python >=3.8,<3.9.0a0", + "requests", + "scipy", + "toolz", + "xarray" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "17c741df3ab01648ac6c96ee03e77883", + "name": "datashader", + "sha256": "54bfbdb398e6c80be69366e95758fe0227b2be3577008d1322956e2f9d935a69", + "size": 17569498, + "subdir": "linux-64", + "timestamp": 1676023148951, + "version": "0.14.4" + }, + "datashader-0.14.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "colorcet", + "dask-core", + "datashape", + "numba >=0.51", + "numpy >=1.19,<2.0a", + "pandas", + "param", + "pillow", + "pyct", + "python >=3.9,<3.10.0a0", + "requests", + "scipy", + "toolz", + "xarray" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c82e08f67468a5417c8e8fe3b647011b", + "name": "datashader", + "sha256": "bf89ebfd778455b7006031b77d08b9a53bc746da6ac2e74b86e5bf376efec7b4", + "size": 17568360, + "subdir": "linux-64", + "timestamp": 1676023255777, + "version": "0.14.4" + }, + "datashader-0.6.2-py27h2029064_0.conda": { + "build": "py27h2029064_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask >=0.7.6", + "datashape >=0.5.1", + "numba >=0.35.0", + "numpy >=1.7", + "pandas >=0.15.0,<0.21", + "param >=1.5.0,<2.0", + "pillow >=3.1.1", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "595c540fba10b2af9f80f1ed8f755912", + "name": "datashader", + "sha256": "0caac96abbb001da3a9e69f2445f0db30955ec31640b03f6405a886631e3faf9", + "size": 644841, + "subdir": "linux-64", + "timestamp": 1510005029674, + "version": "0.6.2" + }, + "datashader-0.6.2-py35h03bc0cf_0.conda": { + "build": "py35h03bc0cf_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask >=0.7.6", + "datashape >=0.5.1", + "numba >=0.35.0", + "numpy >=1.7", + "pandas >=0.15.0,<0.21", + "param >=1.5.0,<2.0", + "pillow >=3.1.1", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "f121fad6befe2df1aae1f68b33f62434", + "name": "datashader", + "sha256": "f445efc8110521a6ced0d9c5ffd7cd103ab8c551fadf672f01a47b85a89dd34f", + "size": 647760, + "subdir": "linux-64", + "timestamp": 1510005035878, + "version": "0.6.2" + }, + "datashader-0.6.2-py36h21a1380_0.conda": { + "build": "py36h21a1380_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask >=0.7.6", + "datashape >=0.5.1", + "numba >=0.35.0", + "numpy >=1.7", + "pandas >=0.15.0,<0.21", + "param >=1.5.0,<2.0", + "pillow >=3.1.1", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "09f29ef4d3550173b1393dcdb883dcca", + "name": "datashader", + "sha256": "be7daeb5f682363050ef833fbbcf0d2a4c8b1648c0f989efcad193614be0bd65", + "size": 644148, + "subdir": "linux-64", + "timestamp": 1510005038260, + "version": "0.6.2" + }, + "datashader-0.6.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask >=0.15.4", + "datashape >=0.5.1", + "numba >=0.35.0", + "numpy >=1.7", + "pandas >=0.20.3", + "param >=1.5.0,<2.0", + "pillow >=3.1.1", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "cc99652bde0f775d7bb36fa6fe7ad61e", + "name": "datashader", + "sha256": "7f74eea5194ec4e90674e25675f3af56b3171d47d887d9053db68491cfe0d86e", + "size": 675320, + "subdir": "linux-64", + "timestamp": 1520379302349, + "version": "0.6.5" + }, + "datashader-0.6.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask >=0.15.4", + "datashape >=0.5.1", + "numba >=0.35.0", + "numpy >=1.7", + "pandas >=0.20.3", + "param >=1.5.0,<2.0", + "pillow >=3.1.1", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "b1d7396a2e076c1480a588b7b4d260ff", + "name": "datashader", + "sha256": "e115e00fe79f1e85b5537e089716c659d648429fb387e0540a7e0ebacc74e24b", + "size": 673085, + "subdir": "linux-64", + "timestamp": 1520964850499, + "version": "0.6.5" + }, + "datashader-0.6.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "colorcet >=0.9.0", + "dask >=0.15.4", + "datashape >=0.5.1", + "numba >=0.35.0", + "numpy >=1.7", + "pandas >=0.20.3", + "param >=1.5.0,<2.0", + "pillow >=3.1.1", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "2eb9d3dff2ad4ae7608868222fc8213f", + "name": "datashader", + "sha256": "a0bd14dc19a09524c7c5916c8c837bd72a66cedbcb28553be709bfcef8dac010", + "size": 673035, + "subdir": "linux-64", + "timestamp": 1520964730468, + "version": "0.6.5" + }, + "datashader-0.6.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.15.4", + "datashape >=0.5.1", + "numba >=0.37.0", + "numpy >=1.7", + "pandas >=0.20.3", + "param >=1.6.0", + "pillow >=3.1.1", + "pyct", + "python >=2.7,<2.8.0a0", + "scikit-image", + "scipy", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "a7f317679d3c6d15e6d85e5c75566bf6", + "name": "datashader", + "sha256": "14e88fb84a50152399035929b9baa393c9c5cb4fcdfc40d6b9d8f7202c615187", + "size": 9833082, + "subdir": "linux-64", + "timestamp": 1527636467514, + "version": "0.6.6" + }, + "datashader-0.6.6-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.15.4", + "datashape >=0.5.1", + "numba >=0.37.0", + "numpy >=1.7", + "pandas >=0.20.3", + "param >=1.6.0", + "pillow >=3.1.1", + "pyct", + "python >=2.7,<2.8.0a0", + "scikit-image", + "scipy", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "8fe9e1ed0b3bfa8d45c12c94ce151473", + "name": "datashader", + "sha256": "169dca119773867b59c9a27d829ea1cec60581b47f8fa497b256f36a79580e6c", + "size": 9837971, + "subdir": "linux-64", + "timestamp": 1527882713420, + "version": "0.6.6" + }, + "datashader-0.6.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.15.4", + "datashape >=0.5.1", + "numba >=0.37.0", + "numpy >=1.7", + "pandas >=0.20.3", + "param >=1.6.0", + "pillow >=3.1.1", + "pyct", + "python >=3.5,<3.6.0a0", + "scikit-image", + "scipy", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "769b68065e4f151a90972121b46aa058", + "name": "datashader", + "sha256": "3afb6b077310d8e176fcaf04b94bba78d9a024db8d04aa1b4a77dcd5fb02290e", + "size": 9837175, + "subdir": "linux-64", + "timestamp": 1527636407612, + "version": "0.6.6" + }, + "datashader-0.6.6-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.15.4", + "datashape >=0.5.1", + "numba >=0.37.0", + "numpy >=1.7", + "pandas >=0.20.3", + "param >=1.6.0", + "pillow >=3.1.1", + "pyct", + "python >=3.5,<3.6.0a0", + "scikit-image", + "scipy", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "4494cccf3f371978abe0cc3f1a963ac7", + "name": "datashader", + "sha256": "3481a05d2a645b7117a3c4714932010d2171e3a3072ed0c99df86da9f2bbb157", + "size": 9840329, + "subdir": "linux-64", + "timestamp": 1527882766242, + "version": "0.6.6" + }, + "datashader-0.6.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.15.4", + "datashape >=0.5.1", + "numba >=0.37.0", + "numpy >=1.7", + "pandas >=0.20.3", + "param >=1.6.0", + "pillow >=3.1.1", + "pyct", + "python >=3.6,<3.7.0a0", + "scikit-image", + "scipy", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "bc653bd51734fa2859cc726cfeade908", + "name": "datashader", + "sha256": "99d7e341efc0eab3826884cbf3ac70e0d81e384383834a06dfabfcb3bd845c57", + "size": 9832278, + "subdir": "linux-64", + "timestamp": 1527636353981, + "version": "0.6.6" + }, + "datashader-0.6.6-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "bokeh", + "colorcet >=0.9.0", + "dask >=0.15.4", + "datashape >=0.5.1", + "numba >=0.37.0", + "numpy >=1.7", + "pandas >=0.20.3", + "param >=1.6.0", + "pillow >=3.1.1", + "pyct", + "python >=3.6,<3.7.0a0", + "scikit-image", + "scipy", + "toolz >=0.7.4", + "xarray >=0.9.6" + ], + "license": "New BSD", + "md5": "5ad510b0f2ef52c583a4d25effa714cd", + "name": "datashader", + "sha256": "6cbf1d01a96aea4412fc0680c8c445183fdad445eaaf50324c66032eb7e28293", + "size": 9836862, + "subdir": "linux-64", + "timestamp": 1527882660610, + "version": "0.6.6" + }, + "datashape-0.5.4-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=2.7,<2.8.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "356c7dd7cdb08b2b23de66ba7aacb05c", + "name": "datashape", + "sha256": "01a7a7a73b2a23b9d4eea87eb602e4b0de854891533dac462dfbd40254383439", + "size": 102383, + "subdir": "linux-64", + "timestamp": 1530771877780, + "version": "0.5.4" + }, + "datashape-0.5.4-py27hf507385_0.conda": { + "build": "py27hf507385_0", + "build_number": 0, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=2.7,<2.8.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "85d30ce2c9a994aacd23354657bba86d", + "name": "datashape", + "sha256": "09945f28526f9dff8998bc9194f5236568c7371acbb518bd782d41c0dd724228", + "size": 101313, + "subdir": "linux-64", + "timestamp": 1505739949333, + "version": "0.5.4" + }, + "datashape-0.5.4-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.10,<3.11.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4875fe3baff73552b290fc3fe61d29bf", + "name": "datashape", + "sha256": "9e36681fbd32772cb8abb210b927e8ba493d5f90b2f86a098b95304b64322235", + "size": 105427, + "subdir": "linux-64", + "timestamp": 1640808953510, + "version": "0.5.4" + }, + "datashape-0.5.4-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.11,<3.12.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3235c08631b398b0816164a211b326bc", + "name": "datashape", + "sha256": "eedd81f5aceed43f6e8c23d5ac14cd7a3af10536dfe5bdff247dc1aa7923d158", + "size": 146490, + "subdir": "linux-64", + "timestamp": 1676843976720, + "version": "0.5.4" + }, + "datashape-0.5.4-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.5,<3.6.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f96a4f4f2922184b638a0a5aa2d8aae9", + "name": "datashape", + "sha256": "6570d029d2e8cfc75f2a3b69ea9dbe9b171ac3cba1ca52ea6974bca01f597bf7", + "size": 104924, + "subdir": "linux-64", + "timestamp": 1534804411607, + "version": "0.5.4" + }, + "datashape-0.5.4-py35h5b068ae_0.conda": { + "build": "py35h5b068ae_0", + "build_number": 0, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.5,<3.6.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3d61b404ce590d53a5b8b7e641befe74", + "name": "datashape", + "sha256": "dfe7783e298b415c0b6d1d0b410d813e678e48246e6fcc37e552e662f0654840", + "size": 103786, + "subdir": "linux-64", + "timestamp": 1505739965907, + "version": "0.5.4" + }, + "datashape-0.5.4-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d810eca4933e7cfda2aa8e5c2d963946", + "name": "datashape", + "sha256": "ccc9f776a3fbdd38d73e5f5ca92b4a4f93619164cb1c936e2555f4290e9c2683", + "size": 105451, + "subdir": "linux-64", + "timestamp": 1530771905449, + "version": "0.5.4" + }, + "datashape-0.5.4-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5450f57780b77562356521bdbed925b5", + "name": "datashape", + "sha256": "8f0e8700f922a7998d2b03737cbeeb3bf6d8690547380bc650472e3360318114", + "size": 106358, + "subdir": "linux-64", + "timestamp": 1613389671273, + "version": "0.5.4" + }, + "datashape-0.5.4-py36h3ad6b5c_0.conda": { + "build": "py36h3ad6b5c_0", + "build_number": 0, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.6,<3.7.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4a51024ad3750d165548f0e4e10501b4", + "name": "datashape", + "sha256": "3064e21a02eddc70b09fa1a3297a0facc74223c78fd55a7762761fc8b32de927", + "size": 104226, + "subdir": "linux-64", + "timestamp": 1505739982334, + "version": "0.5.4" + }, + "datashape-0.5.4-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "696b8d7bde99602424fe3af28e7009a1", + "name": "datashape", + "sha256": "b9afe040629a6158dd415553107312372ddc80e51334b994effa43df288207f6", + "size": 105043, + "subdir": "linux-64", + "timestamp": 1530771851361, + "version": "0.5.4" + }, + "datashape-0.5.4-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9936908015eceab593131d2e3645d01b", + "name": "datashape", + "sha256": "05a52282bf061c331aa8e645f15219b370a3b2385b20a514a5aa2ed52f37a994", + "size": 104480, + "subdir": "linux-64", + "timestamp": 1613389650903, + "version": "0.5.4" + }, + "datashape-0.5.4-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "75a03e80fbb002eb54f3f7431db881bf", + "name": "datashape", + "sha256": "5baeb90102cd39e66edbb6317fc57bb9f00cb43519a468f28006257b01a3fd3a", + "size": 106212, + "subdir": "linux-64", + "timestamp": 1574251109949, + "version": "0.5.4" + }, + "datashape-0.5.4-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f73825b45cf0833d720c09a47eb3706a", + "name": "datashape", + "sha256": "a57f39b112e54e0ea564bb87ac7327c62b1f4bea08dc85ad010e3091a3af7268", + "size": 105581, + "subdir": "linux-64", + "timestamp": 1613390257727, + "version": "0.5.4" + }, + "datashape-0.5.4-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "multipledispatch >=0.4.7", + "numpy >=1.7", + "python >=3.9,<3.10.0a0", + "python-dateutil" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3817b84b8f5fc50865c55ca0116af235", + "name": "datashape", + "sha256": "709685f821c3b6d9ec2ce8a9933ae93b87b8fdc5cb44b00657081f1ec18338e1", + "size": 106660, + "subdir": "linux-64", + "timestamp": 1613390248313, + "version": "0.5.4" + }, + "dateparser-1.1.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27,<2022.3.15", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "03dfe3333510d800daa27d83199a3266", + "name": "dateparser", + "sha256": "a8efe98fe0b8550ead5abce38a0c5f2db51e22b31395856c9e32e64a5f2c5c22", + "size": 362701, + "subdir": "linux-64", + "timestamp": 1671074962799, + "version": "1.1.3" + }, + "dateparser-1.1.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27,<2022.3.15", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6c7ed08c90a824b296947cf5d95a842a", + "name": "dateparser", + "sha256": "d5646927416b6d5860bd6a3e788c4e5d855fb45b07fb2d4b572eaea062422f47", + "size": 345048, + "subdir": "linux-64", + "timestamp": 1671075012572, + "version": "1.1.3" + }, + "dateparser-1.1.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27,<2022.3.15", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bdd10a6903731244327e4758e25eec45", + "name": "dateparser", + "sha256": "c899b7390794adb4a1320db432cb63c585c90eb1d67b68a0e3d2e5911b35ab87", + "size": 347811, + "subdir": "linux-64", + "timestamp": 1671074987533, + "version": "1.1.3" + }, + "dateparser-1.1.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27,<2022.3.15", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "525edaf14583ad850aa13ee8736c0b9f", + "name": "dateparser", + "sha256": "d0d9f9fbc79f5109732c23f48bd45f4a263d73d155a379b9133c8bc23c57e04e", + "size": 344371, + "subdir": "linux-64", + "timestamp": 1671075037741, + "version": "1.1.3" + }, + "dateparser-1.1.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27,<2022.3.15", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c2aafc1742e1071445a2bdfd796173b9", + "name": "dateparser", + "sha256": "5a4d25f59edc1590a2737a7e469356509e0eb78442bc231ab6773e0d49bec447", + "size": 365232, + "subdir": "linux-64", + "timestamp": 1671081600448, + "version": "1.1.4" + }, + "dateparser-1.1.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27,<2022.3.15", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a67480d46ff4f5f019a18a11d123e039", + "name": "dateparser", + "sha256": "af609329f62494f6b445c485a70fc35d3062f7a7c07af6b6404500a730430aaa", + "size": 345435, + "subdir": "linux-64", + "timestamp": 1671081625190, + "version": "1.1.4" + }, + "dateparser-1.1.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27,<2022.3.15", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d0306a56372f27dd41235795e0a2340d", + "name": "dateparser", + "sha256": "1ecab0a398e502c4a8a14798c1da72c92c4c438bd132259f15f7075c396c5361", + "size": 348182, + "subdir": "linux-64", + "timestamp": 1671081649573, + "version": "1.1.4" + }, + "dateparser-1.1.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27,<2022.3.15", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b50c8421a8a2335427d8a4238058f755", + "name": "dateparser", + "sha256": "fb7a99a45f0785303ae1e35a58a31a6d7e36975545723f8c0d074bd13dfbc49e", + "size": 344550, + "subdir": "linux-64", + "timestamp": 1671081674426, + "version": "1.1.4" + }, + "dateparser-1.1.8-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d42365b00693b7402d994aa8d1efdf39", + "name": "dateparser", + "sha256": "67af1d9891968c57f1bafb093a82bc01bb20baa717900c28aad2f2b3a071abd8", + "size": 368746, + "subdir": "linux-64", + "timestamp": 1679666229924, + "version": "1.1.8" + }, + "dateparser-1.1.8-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a430c9ef3811f4342ebd5be84df5ad1", + "name": "dateparser", + "sha256": "fb20b1827ea3b6b3219db92332ed7ebe56ce2b6d64c1d097fde6517810a87561", + "size": 445322, + "subdir": "linux-64", + "timestamp": 1679666144348, + "version": "1.1.8" + }, + "dateparser-1.1.8-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7d734f1e8d4c085828fbe5aa5ea74dd9", + "name": "dateparser", + "sha256": "4e49a2577fa42604e1f51df77e85835ae1d373e4c6bde4f9b552daede1e96c13", + "size": 351370, + "subdir": "linux-64", + "timestamp": 1679666200817, + "version": "1.1.8" + }, + "dateparser-1.1.8-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil", + "pytz", + "regex !=2019.02.19,!=2021.8.27", + "tzlocal" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c1b9c3ad6a85cc7aea414886d142cf49", + "name": "dateparser", + "sha256": "7724fd8f43df1ba5b36011fa4dc6c95ae30b28783cc0d60999244003885feeb4", + "size": 348046, + "subdir": "linux-64", + "timestamp": 1679666172166, + "version": "1.1.8" + }, + "datrie-0.7.1-py27h7b6447c_1.conda": { + "build": "py27h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "94a3a9c3a74e0a198cdfc9492e148d0d", + "name": "datrie", + "sha256": "3698e8b88a9e43933d53b9b1abb966c4e8b73e556ee21df6c0a5228039689ca1", + "size": 142340, + "subdir": "linux-64", + "timestamp": 1537292011984, + "version": "0.7.1" + }, + "datrie-0.7.1-py35h7b6447c_1.conda": { + "build": "py35h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "a04c061436314efbe415f565c44c0bcf", + "name": "datrie", + "sha256": "de0140a315325dd24f305824fc92b9be8e65addccafa21ec04d0f5041cbd4c7f", + "size": 145838, + "subdir": "linux-64", + "timestamp": 1537292051707, + "version": "0.7.1" + }, + "datrie-0.7.1-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "7419a2802fcacc76eb5567ece79a696b", + "name": "datrie", + "sha256": "4c84a27c828675c59472cd2769e628a685adb7ce30fdd8cda6ee1598a31305c9", + "size": 146682, + "subdir": "linux-64", + "timestamp": 1537292048628, + "version": "0.7.1" + }, + "datrie-0.7.1-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "d93381f14a85b65f2470cd242a409104", + "name": "datrie", + "sha256": "f3563019aafb1c5ffd8c417bf3c480ec9bb5145e8ba4e77280767b493ed78fdc", + "size": 145784, + "subdir": "linux-64", + "timestamp": 1537291987069, + "version": "0.7.1" + }, + "datrie-0.8-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "2d4f9641a2c98b584f86a37bef16fdfb", + "name": "datrie", + "sha256": "91ca87ca6a499f19f10972297070ccd86659871ff0f0ff5da6b7146a8e79b42b", + "size": 142960, + "subdir": "linux-64", + "timestamp": 1569433465876, + "version": "0.8" + }, + "datrie-0.8-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "063a7c9985b4c31309f21f926c0afe72", + "name": "datrie", + "sha256": "23c6d9aac73a58e521f76cb81a21a222111298fe3833ebfd5e112e8685ea6ffc", + "size": 150164, + "subdir": "linux-64", + "timestamp": 1569433468549, + "version": "0.8" + }, + "datrie-0.8-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "2aa82d8aeec0f0bac0f25b27c36b3d7b", + "name": "datrie", + "sha256": "cbe33d130efcad79e3bc5f2f75a746d5b4a31e1ced7f5067f76f888a7d36f041", + "size": 150846, + "subdir": "linux-64", + "timestamp": 1569433482841, + "version": "0.8" + }, + "datrie-0.8.2-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "2d18d853c6ec9cf4db5244906c506cdd", + "name": "datrie", + "sha256": "af9645f47f7388a1501277dbeb38ecbb6a050f72ea00bcc9f9c0b87c56417b7b", + "size": 462102, + "subdir": "linux-64", + "timestamp": 1640816681038, + "version": "0.8.2" + }, + "datrie-0.8.2-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "98183a8cb14b18fdcd30542be9033902", + "name": "datrie", + "sha256": "811e60a3b9e7d85e921d759c373fe6e354f4bdf56e787c5ca99f5bbe87df0247", + "size": 134829, + "subdir": "linux-64", + "timestamp": 1676851909935, + "version": "0.8.2" + }, + "datrie-0.8.2-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "079fcaa4e696f200c9432beed921461d", + "name": "datrie", + "sha256": "38c6b768fc66928c06b98c1c0e1d6ee182e7deb6b6149a2d305858c6848c8044", + "size": 135741, + "subdir": "linux-64", + "timestamp": 1611677550293, + "version": "0.8.2" + }, + "datrie-0.8.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "12b55c3d5f94a1f03fb7eb1266696a6c", + "name": "datrie", + "sha256": "771fb930b432d40bb8b1f22268d981e879673e2c0ad7e0700fe70afc19caa9ce", + "size": 148456, + "subdir": "linux-64", + "timestamp": 1588475717472, + "version": "0.8.2" + }, + "datrie-0.8.2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "89324ba40835534b317c946653d6cad5", + "name": "datrie", + "sha256": "208e0899837bf61a3d5323b6c6b5103bf308e183bf2f5af75699b13bef9d7702", + "size": 135897, + "subdir": "linux-64", + "timestamp": 1611677578962, + "version": "0.8.2" + }, + "datrie-0.8.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "5a5b10e0198e090f651bc005823f74ab", + "name": "datrie", + "sha256": "3a5bc4d43ca16004226bcde322611f1d6d74975e189e1f9254ae236c239dc75d", + "size": 148227, + "subdir": "linux-64", + "timestamp": 1588475736617, + "version": "0.8.2" + }, + "datrie-0.8.2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "65b226a887e4de9c876fe19bfa4130a2", + "name": "datrie", + "sha256": "015705e563c6d41cc6d09de8dc4d0165aa7db5953a303fbd5b68f23cefc5acbb", + "size": 140467, + "subdir": "linux-64", + "timestamp": 1611677594656, + "version": "0.8.2" + }, + "datrie-0.8.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "82f973a67fd54492787d00c22ecb124b", + "name": "datrie", + "sha256": "5c7799c907c07d05515973f37511bd9c0df1d591bccbc02f69344c90e6f456a3", + "size": 154100, + "subdir": "linux-64", + "timestamp": 1588475742767, + "version": "0.8.2" + }, + "datrie-0.8.2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPLv2", + "license_family": "LGPL", + "md5": "1c42c11418a12a11abf43e14b1e6f8f7", + "name": "datrie", + "sha256": "826dba8552d16fe530d6acc8b2341689f8caa21652976c64b5814166e1fa5c88", + "size": 141295, + "subdir": "linux-64", + "timestamp": 1611677571829, + "version": "0.8.2" + }, + "db-6.1.26-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libdb 6.1.26 he6710b0_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "AGPL-3.0", + "md5": "c49c5109a3c37939d76a7dcf5c72f3e8", + "name": "db", + "sha256": "dd16004c941c3050ab4f270e764839ab7ecf848289751c3e2abad79b1c7060f5", + "size": 20613, + "subdir": "linux-64", + "timestamp": 1537818034748, + "version": "6.1.26" + }, + "db-6.2.32-h6a678d5_1.conda": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "libdb 6.2.32 h6a678d5_1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "AGPL-3.0-only", + "md5": "3fee8444aa69f4ec10e1e4da7114a69b", + "name": "db", + "sha256": "aa353b30e39a6e952165dd7c6cb97ee3c72af9edfd231d953d7b86d6e2ef5e5d", + "size": 19093, + "subdir": "linux-64", + "timestamp": 1656332159344, + "version": "6.2.32" + }, + "db-6.2.32-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libdb 6.2.32 he6710b0_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "AGPL-3.0-only", + "md5": "db6f8a2037665e8f80eccb5f7f191e07", + "name": "db", + "sha256": "be87368d3d54f09fea2df94c8a17f37647a100a770c9fa91e9734e5b4d764edc", + "size": 24448, + "subdir": "linux-64", + "timestamp": 1601249400928, + "version": "6.2.32" + }, + "db-6.2.32-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libdb 6.2.32 hf484d3e_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "AGPL-3.0-only", + "md5": "de962f63a904921db621707693f238be", + "name": "db", + "sha256": "cf40a6459e0211d023d48bf0ca9c316bbb800d0cce1dab6aa71d96ef53930c69", + "size": 23147, + "subdir": "linux-64", + "timestamp": 1601249492835, + "version": "6.2.32" + }, + "dbf-0.96.8-py27h6f65a25_0.conda": { + "build": "py27h6f65a25_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4d6916091eb2cc67a431dd7cf8af40e6", + "name": "dbf", + "sha256": "7f5b1fa3bacbcb25ad86b0fcf72ca17ec3335ade858c6b4f7890c871a0231183", + "size": 195369, + "subdir": "linux-64", + "timestamp": 1509053667558, + "version": "0.96.8" + }, + "dbf-0.96.8-py35h1fafa07_0.conda": { + "build": "py35h1fafa07_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "fdfaf0ab57f481fa03f1870d0c908bf7", + "name": "dbf", + "sha256": "a3d456d018a1b5ed88178567f9572e560e9724b6883e3f03315024600a2ad8c9", + "size": 173077, + "subdir": "linux-64", + "timestamp": 1509053675867, + "version": "0.96.8" + }, + "dbf-0.96.8-py36hcbe1359_0.conda": { + "build": "py36hcbe1359_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d3da561ea92fe39e026fd98d834cfb53", + "name": "dbf", + "sha256": "25c155cfb250faa0c41c8f9419f51ddb98c6565d2a28ba28990f78b88e8c93ed", + "size": 168717, + "subdir": "linux-64", + "timestamp": 1509053703931, + "version": "0.96.8" + }, + "dbf-0.97.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "116701c7a9054251c94cf3ca8df18427", + "name": "dbf", + "sha256": "16d4295735cfe326212c764d8790800bc50d28f90b001c6f10e6221d6efddea2", + "size": 180807, + "subdir": "linux-64", + "timestamp": 1528218458344, + "version": "0.97.10" + }, + "dbf-0.97.10-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e924982de1621866c807750bfc31967f", + "name": "dbf", + "sha256": "cd1adb919e71839c9b596d00bc5d39fd0f0c75de204fd91d54e9c2cc677eb04f", + "size": 182407, + "subdir": "linux-64", + "timestamp": 1528218486931, + "version": "0.97.10" + }, + "dbf-0.97.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a0fc2082aab02bcad2c04b3ec2083642", + "name": "dbf", + "sha256": "78ebe36825c67f622507e6729c2e0bcfca478561bf852e4904a02aa478a47fe7", + "size": 179672, + "subdir": "linux-64", + "timestamp": 1528218443153, + "version": "0.97.10" + }, + "dbf-0.97.11-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f93d6a1f836466a0dedba3a879f4eb08", + "name": "dbf", + "sha256": "b651e0c65239e6362a24415e32d4946629f67ffbd732784733d716b17e83c8c5", + "size": 180854, + "subdir": "linux-64", + "timestamp": 1529424033380, + "version": "0.97.11" + }, + "dbf-0.97.11-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "54d02c6bf77cb9220ce6bb55ab3de13c", + "name": "dbf", + "sha256": "ab3e3bd6beae46446b696b5949959b1faaa6e05b9df623ace9c9ce4306ab7e42", + "size": 182171, + "subdir": "linux-64", + "timestamp": 1529423986258, + "version": "0.97.11" + }, + "dbf-0.97.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0bbfee9d16f4a0d81d243f28718b5f1b", + "name": "dbf", + "sha256": "7e55a9398ba63cb694d4e75d6b6ab40b540d3e69d8e728d9c31cb5e8eab5aeb6", + "size": 182123, + "subdir": "linux-64", + "timestamp": 1529423959090, + "version": "0.97.11" + }, + "dbf-0.97.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "31c1d3533d87ce8ac63c5303d2eca1a6", + "name": "dbf", + "sha256": "ade38917fcc0604272be54064fa5ca1cc1dd36740f4b9866613bcdf78f068c47", + "size": 179048, + "subdir": "linux-64", + "timestamp": 1530873024757, + "version": "0.97.11" + }, + "dbf-0.97.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ce7cc86344f24a971a565a518f706f2c", + "name": "dbf", + "sha256": "a377c53a0a94c7a486b3d51c13b3ecf16280e06f300c8dafe315426777128770", + "size": 172370, + "subdir": "linux-64", + "timestamp": 1521779872596, + "version": "0.97.2" + }, + "dbf-0.97.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cd5574089293eb297ca20d4656f17490", + "name": "dbf", + "sha256": "cc249ece0184aec28098a519e9416dc9982dad4273b51fe355b50a353f776b2e", + "size": 176169, + "subdir": "linux-64", + "timestamp": 1521779919538, + "version": "0.97.2" + }, + "dbf-0.97.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "500547dc4dd3f1ca48f21a8df9cb386d", + "name": "dbf", + "sha256": "1e5982984bf65e68bb7bd06a1f2f4f7c06ecdef64100e8400f8980a81c087fe5", + "size": 173603, + "subdir": "linux-64", + "timestamp": 1521779924379, + "version": "0.97.2" + }, + "dbf-0.97.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f5e9c00e60a2a81c5ffabf7b5ace1256", + "name": "dbf", + "sha256": "8cf96b8a45ac323a69f7624cac1b821982846bc90b6e8013188d352b0d255852", + "size": 172753, + "subdir": "linux-64", + "timestamp": 1526928658855, + "version": "0.97.4" + }, + "dbf-0.97.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "292e87cd524a2f0a9d32ce3fd97765f3", + "name": "dbf", + "sha256": "9342f639f1ed49ee87ff80c3da002c9421fd4aa18370175a5c673955492e2961", + "size": 176562, + "subdir": "linux-64", + "timestamp": 1526928680779, + "version": "0.97.4" + }, + "dbf-0.97.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "04ba2aab7818ad02356face421688f0e", + "name": "dbf", + "sha256": "48194b6ba8de72a37f361acb0d73d09f1eee360c1144dd93872477ab2252cd79", + "size": 173982, + "subdir": "linux-64", + "timestamp": 1526928641079, + "version": "0.97.4" + }, + "dbf-0.97.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e69784b1b37b9fe5f74234ffdf0ec0eb", + "name": "dbf", + "sha256": "8318e526f49f972b6337ffa1187cb01cd909675f5ec12c23d04241daf0b9c407", + "size": 179325, + "subdir": "linux-64", + "timestamp": 1527642801582, + "version": "0.97.8" + }, + "dbf-0.97.8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e0aae37f6410777a0e2eb5bece1dcc99", + "name": "dbf", + "sha256": "be184605448e400a72c1fd87c93b7ec62bf1a080f9bfe4b10fb71d04f9b9a8d2", + "size": 181125, + "subdir": "linux-64", + "timestamp": 1527642822558, + "version": "0.97.8" + }, + "dbf-0.97.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aenum", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "15de77c457061be905baa39aca001d57", + "name": "dbf", + "sha256": "11a327118d8d943d11e5b536862d880b276fa5f735e5b65eba8fe838b24bc62f", + "size": 178583, + "subdir": "linux-64", + "timestamp": 1527642788097, + "version": "0.97.8" + }, + "dbfread-2.0.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "236ad0c563d17f6c7716df37f38449a6", + "name": "dbfread", + "sha256": "63c03f53fc9f6838a31634539d188be3b239ab33404645b09b944ba8c8e7da64", + "size": 32170, + "subdir": "linux-64", + "timestamp": 1530735814923, + "version": "2.0.7" + }, + "dbfread-2.0.7-py27h8f214bf_0.conda": { + "build": "py27h8f214bf_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d791e2ae6392600cfa262f80d62908c", + "name": "dbfread", + "sha256": "948a708167c5ebe80dca450a389a140e38c833a1352688d7083b04db1b3f8b21", + "size": 32717, + "subdir": "linux-64", + "timestamp": 1508625329549, + "version": "2.0.7" + }, + "dbfread-2.0.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f6f86b73d5051ca75562d8a42557b87", + "name": "dbfread", + "sha256": "e0ed582d1d7553bf6ece1c34fd68035af49bdf40f5129805785b67b37957b87a", + "size": 32621, + "subdir": "linux-64", + "timestamp": 1534352068817, + "version": "2.0.7" + }, + "dbfread-2.0.7-py35he5e2644_0.conda": { + "build": "py35he5e2644_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6198c6b489da6a00917149b3012fac2f", + "name": "dbfread", + "sha256": "a109cbb2b4e7b66105ecfd2222a1df750bd25938f4b10edcc18f87cf70bfeb73", + "size": 32961, + "subdir": "linux-64", + "timestamp": 1508625335987, + "version": "2.0.7" + }, + "dbfread-2.0.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b619c9051d03acb5053e864134916ee9", + "name": "dbfread", + "sha256": "743c8a92eb33a228a4b9ac51ac3f8e737f3719c0802bd6059c61b4e07c3e8be9", + "size": 32169, + "subdir": "linux-64", + "timestamp": 1530735794561, + "version": "2.0.7" + }, + "dbfread-2.0.7-py36ha5008bc_0.conda": { + "build": "py36ha5008bc_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c2b4772542e2f03ed616b9c24d5a487", + "name": "dbfread", + "sha256": "944998ff7b430f9fdf3567f1555d335823e567edbf41f428f38e4cf96f366010", + "size": 32622, + "subdir": "linux-64", + "timestamp": 1508625333419, + "version": "2.0.7" + }, + "dbfread-2.0.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c7346d5a5be1191301d8dbd7bc5adac5", + "name": "dbfread", + "sha256": "a719bc99e2ce3bfa30f35474574c8cfebfb14cda4cf998e2f352f08de30ff4ea", + "size": 31960, + "subdir": "linux-64", + "timestamp": 1530735835962, + "version": "2.0.7" + }, + "dbfread-2.0.7-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "360af61316aea428d61d3df267c61fa5", + "name": "dbfread", + "sha256": "383917ce47ece223e4b644d2864658e7c7059c380f12be190d2364bcdeb68833", + "size": 32595, + "subdir": "linux-64", + "timestamp": 1572434918739, + "version": "2.0.7" + }, + "dbus-1.10.22-h3b5a359_0.conda": { + "build": "h3b5a359_0", + "build_number": 0, + "depends": [ + "expat", + "glib >=2.53.6,<3.0a0", + "libgcc-ng >=7.2.0" + ], + "license": "GPL2", + "md5": "da01ebb1759675106b50cce703c1f48d", + "name": "dbus", + "sha256": "1b0ec5231b93132905b85ba85736441c66a830f47abb75c8116efec26e4de711", + "size": 476098, + "subdir": "linux-64", + "timestamp": 1505735510995, + "version": "1.10.22" + }, + "dbus-1.12.12-h746ee38_0.conda": { + "build": "h746ee38_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "glib >=2.56.2,<3.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "GPL2", + "md5": "5fbd5df29bc2d1ea980e2f51b91342ab", + "name": "dbus", + "sha256": "8b2391efeda4b28b5e0b1682cd0468e70f39c0363db11652c0efd986dd695044", + "size": 506996, + "subdir": "linux-64", + "timestamp": 1547226354431, + "version": "1.12.12" + }, + "dbus-1.12.2-hc3f9b76_1.conda": { + "build": "hc3f9b76_1", + "build_number": 1, + "depends": [ + "expat", + "expat >=2.2.5,<3.0a0", + "glib >=2.53.6,<3.0a0", + "libgcc-ng >=7.2.0" + ], + "license": "GPL2", + "md5": "be48b671822c288b0b45c4f1148f9109", + "name": "dbus", + "sha256": "bf8d70b81af4fe6920ff0d8de1b40ce982bd9c85a6fd21d95c0c3d7a3a863e8c", + "size": 485707, + "subdir": "linux-64", + "timestamp": 1518199455973, + "version": "1.12.2" + }, + "dbus-1.12.2-hd3e2b69_0.conda": { + "build": "hd3e2b69_0", + "build_number": 0, + "depends": [ + "expat", + "expat >=2.2.5,<3.0a0", + "glib >=2.53.6,<3.0a0", + "libgcc-ng >=7.2.0" + ], + "license": "GPL2", + "md5": "6aee163b68f9278ef25d6c1ebabfc86a", + "name": "dbus", + "sha256": "6661b060ac214d99d7c62eac274ffcdba294c6ac7027a04f37c3d7f7aa635b8f", + "size": 486642, + "subdir": "linux-64", + "timestamp": 1516812561051, + "version": "1.12.2" + }, + "dbus-1.13.12-h746ee38_0.conda": { + "build": "h746ee38_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "glib >=2.56.2,<3.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "GPL2", + "md5": "bd1b587b027d305af743bf73cfba82fb", + "name": "dbus", + "sha256": "ce6187ae14028897c81da91a0bbfbdf002b99cae295d9807d0f5550d34aae489", + "size": 513441, + "subdir": "linux-64", + "timestamp": 1571950327744, + "version": "1.13.12" + }, + "dbus-1.13.14-hb2f20db_0.conda": { + "build": "hb2f20db_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "glib >=2.63.1,<3.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "GPL2", + "md5": "b04f1411c0eee168c15d0a5d4fc24f9e", + "name": "dbus", + "sha256": "a435f43d73c5c5ab9857628afda11c57cedf5b2e00a3f9fc838297ac76624fb7", + "size": 516374, + "subdir": "linux-64", + "timestamp": 1588560187466, + "version": "1.13.14" + }, + "dbus-1.13.16-hb2f20db_0.conda": { + "build": "hb2f20db_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "glib >=2.63.1,<3.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "GPL2", + "md5": "8abe4daf6a5d089ea4babe628d0e97dd", + "name": "dbus", + "sha256": "ac33f765593056ebede0a5e751b6f74bb4daae69b8fc5d77d79c563f0a3bd7d3", + "size": 512542, + "subdir": "linux-64", + "timestamp": 1593111218352, + "version": "1.13.16" + }, + "dbus-1.13.18-hb2f20db_0.conda": { + "build": "hb2f20db_0", + "build_number": 0, + "depends": [ + "expat >=2.2.10,<3.0a0", + "glib", + "libgcc-ng >=7.3.0" + ], + "license": "GPL2", + "md5": "6a6a6f1391f807847404344489ef6cf4", + "name": "dbus", + "sha256": "33cffa33d77d6bfa4e157322e188d82deb904efe1bc867d1ee08fcee9275b8ab", + "size": 515959, + "subdir": "linux-64", + "timestamp": 1602701107852, + "version": "1.13.18" + }, + "dbus-1.13.2-h714fa37_1.conda": { + "build": "h714fa37_1", + "build_number": 1, + "depends": [ + "expat", + "expat >=2.2.5,<3.0a0", + "glib >=2.56.1,<3.0a0", + "libgcc-ng >=7.2.0" + ], + "license": "GPL2", + "md5": "c3af41a22b013fedde92ba08714aaa82", + "name": "dbus", + "sha256": "8d24be2f7086ef5239360d7086f4556781ad5fdf864f098bd88a11e133e54d18", + "size": 488925, + "subdir": "linux-64", + "timestamp": 1523700685718, + "version": "1.13.2" + }, + "dbus-1.13.2-hc3f9b76_0.conda": { + "build": "hc3f9b76_0", + "build_number": 0, + "depends": [ + "expat", + "expat >=2.2.5,<3.0a0", + "glib >=2.53.6,<3.0a0", + "libgcc-ng >=7.2.0" + ], + "license": "GPL2", + "md5": "5675f2099599f7230380a5369c4f5adc", + "name": "dbus", + "sha256": "3569978e2708fbca8c322747c186e5d48d6e4d63f0f6d89bce681d4b837e0a16", + "size": 488826, + "subdir": "linux-64", + "timestamp": 1522686405896, + "version": "1.13.2" + }, + "dbus-1.13.6-h746ee38_0.conda": { + "build": "h746ee38_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "glib >=2.56.2,<3.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "GPL2", + "md5": "c2e40284a95127d6594cbffdfe0f49a8", + "name": "dbus", + "sha256": "b7377f998d036d20f24622796127683100555061708de715871bb88d23f88b2f", + "size": 510725, + "subdir": "linux-64", + "timestamp": 1547912302374, + "version": "1.13.6" + }, + "dbus-1.13.6-hb2f20db_0.conda": { + "build": "hb2f20db_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "glib >=2.63.1,<3.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "GPL2", + "md5": "59dcfc218105f301f81cd0c994c7db51", + "name": "dbus", + "sha256": "378d881c47b4807e89b2e92893b706a079282038d434a0558a4ffef6ab68f559", + "size": 511428, + "subdir": "linux-64", + "timestamp": 1588550285006, + "version": "1.13.6" + }, + "dbus-python-1.2.18-py310hfc3c560_0.conda": { + "build": "py310hfc3c560_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.18,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "676b70009e5f94e0d607b255e139f7ec", + "name": "dbus-python", + "sha256": "7d2430535bdb51e443776e2c82c52ea8756b25ad243fa7269f6fe60bd48c2953", + "size": 120038, + "subdir": "linux-64", + "timestamp": 1659032266936, + "version": "1.2.18" + }, + "dbus-python-1.2.18-py311hfc3c560_0.conda": { + "build": "py311hfc3c560_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.18,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5f193507a67f365ae4c6ca5000c91c5", + "name": "dbus-python", + "sha256": "f2181d5ff2451a635d260f851fac0d935f1a2a9560458b941ef4a2ceb331486c", + "size": 133950, + "subdir": "linux-64", + "timestamp": 1676825218385, + "version": "1.2.18" + }, + "dbus-python-1.2.18-py37hfc3c560_0.conda": { + "build": "py37hfc3c560_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.18,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12f465850a21580ab95445891c1edad3", + "name": "dbus-python", + "sha256": "31cbfa9baaa9ead8b3fdce92ce0237b1935df8e890a876c1229cba72faef7b08", + "size": 118060, + "subdir": "linux-64", + "timestamp": 1659032090614, + "version": "1.2.18" + }, + "dbus-python-1.2.18-py38hfc3c560_0.conda": { + "build": "py38hfc3c560_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.18,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "59da4599c34ca4213b64e6a29d53a538", + "name": "dbus-python", + "sha256": "b80fedb8ecb7f71af1cc737cd617c92fd616a1c78d5bbcec4e37951fd0164785", + "size": 119627, + "subdir": "linux-64", + "timestamp": 1659032144124, + "version": "1.2.18" + }, + "dbus-python-1.2.18-py39hfc3c560_0.conda": { + "build": "py39hfc3c560_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.18,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1cc8d7eeaba326b051ea48558b46eb6e", + "name": "dbus-python", + "sha256": "ed8ccfa947611ddda92bbe762d89f966552abb21fe536e7457433e46c94976f0", + "size": 119481, + "subdir": "linux-64", + "timestamp": 1659032197240, + "version": "1.2.18" + }, + "debugpy-1.4.1-py36h295c915_0.conda": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7af5f637ccf9ddf03aa741890c3d5e3f", + "name": "debugpy", + "sha256": "4ee688cb2c859b1fdd327982bd23d0e100c2b37d0ee76ebc8266a89376f36f15", + "size": 1805209, + "subdir": "linux-64", + "timestamp": 1629222796668, + "version": "1.4.1" + }, + "debugpy-1.4.1-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cf45ee4301fd30f529adcd50ffe69379", + "name": "debugpy", + "sha256": "9423e4680c2520fde80a852f9d2b48bac9768ac4e68f147b8144469aa9471dc5", + "size": 1779054, + "subdir": "linux-64", + "timestamp": 1629222507853, + "version": "1.4.1" + }, + "debugpy-1.4.1-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "42cba8f6a4111d4d4c941f0443d80694", + "name": "debugpy", + "sha256": "500742292e7018759fbb9a9da49f22f54f00d2b006e30f4d05d9ae1f4b5cc9b0", + "size": 1800492, + "subdir": "linux-64", + "timestamp": 1629222774574, + "version": "1.4.1" + }, + "debugpy-1.4.1-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9e2c99bc0c268ee16aa1794d1ed4567", + "name": "debugpy", + "sha256": "101a3ec821b2de7b7427a10cc89a1bc2ceccfe5d2623e4878cb361a60ba5d07a", + "size": 1825198, + "subdir": "linux-64", + "timestamp": 1629214203781, + "version": "1.4.1" + }, + "debugpy-1.5.1-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "20d40a51b7f332bdb009267fea9c8064", + "name": "debugpy", + "sha256": "4e8bae125f0b0a217d20ed21dd46e319365c8b5c5db605609796b0633f04399b", + "size": 1826288, + "subdir": "linux-64", + "timestamp": 1640789547774, + "version": "1.5.1" + }, + "debugpy-1.5.1-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34462be94197bc07a2593a228987e7b6", + "name": "debugpy", + "sha256": "fe1776426a9cf19d7dedcff239d07b7b441e8a79cd0c5d7fe68b321338667fa5", + "size": 2075503, + "subdir": "linux-64", + "timestamp": 1676824922722, + "version": "1.5.1" + }, + "debugpy-1.5.1-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6dc87e2f0e7dd65173c0fb2f8750c4d", + "name": "debugpy", + "sha256": "e7702fe46b4c78bfdbf66bdeff8fd46ee3229039a71cf732e42a4d8a6758b3d8", + "size": 1786326, + "subdir": "linux-64", + "timestamp": 1637091495391, + "version": "1.5.1" + }, + "debugpy-1.5.1-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15761a758f4788b5e068c0b2288afab5", + "name": "debugpy", + "sha256": "06b2eae48400bff98062ded7708e53310e0d4ef56763ee78e59f089e3bfeace6", + "size": 1809950, + "subdir": "linux-64", + "timestamp": 1637091855055, + "version": "1.5.1" + }, + "debugpy-1.5.1-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a52eb9732c535aabc81326e572ff4e8d", + "name": "debugpy", + "sha256": "73e74c454964224d737ba654a8ca09d5ab0673570f2520b243ed774b162c15d0", + "size": 1811065, + "subdir": "linux-64", + "timestamp": 1637091869922, + "version": "1.5.1" + }, + "decorator-4.1.2-py27h1544723_0.conda": { + "build": "py27h1544723_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "87ea945a0ef380eadfab071c31f72b89", + "name": "decorator", + "sha256": "35dbe17f6b18fae9ed807587cbdb97ee979ebdc742af2b0e94ff2147c7de9032", + "size": 16364, + "subdir": "linux-64", + "timestamp": 1505671998830, + "version": "4.1.2" + }, + "decorator-4.1.2-py35h3a268aa_0.conda": { + "build": "py35h3a268aa_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1fc6195f0dd10721874c0fe99f46d257", + "name": "decorator", + "sha256": "fdaf228348ea1e969656ecdbd2f4e36cfcef5f416412af73022c533e6402090c", + "size": 16444, + "subdir": "linux-64", + "timestamp": 1505672010649, + "version": "4.1.2" + }, + "decorator-4.1.2-py36hd076ac8_0.conda": { + "build": "py36hd076ac8_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dc39de8f854c7e93463732f571dc7a96", + "name": "decorator", + "sha256": "ead85c7c9daf440eba7991cca5ced64ea3485435cd3c00ffd9d8f94e4f792eb1", + "size": 16278, + "subdir": "linux-64", + "timestamp": 1505672022605, + "version": "4.1.2" + }, + "decorator-4.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cb35e084a3ac47ee47b22b66219e9ca3", + "name": "decorator", + "sha256": "ca77b18b368d762444b540aaa872939d8c058683829a0350642d7acb35b0e4d8", + "size": 17117, + "subdir": "linux-64", + "timestamp": 1516376429792, + "version": "4.2.1" + }, + "decorator-4.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6c9391c6405fdab5b658fcc03406d5c6", + "name": "decorator", + "sha256": "d0995d3d0bd1f762e3c0d942955194f6cd15e81e6aab69aa2783481b8a4e8d37", + "size": 17298, + "subdir": "linux-64", + "timestamp": 1516376670489, + "version": "4.2.1" + }, + "decorator-4.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a6862689b24e72564da330d2a476ff44", + "name": "decorator", + "sha256": "7df1527d7332d37c87424800b4e412bc32f0d2d79136a0352725934b2cf0b578", + "size": 16970, + "subdir": "linux-64", + "timestamp": 1516376671963, + "version": "4.2.1" + }, + "decorator-4.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c44053d7a7ef20fffd08120577b225cb", + "name": "decorator", + "sha256": "a893a2f15080e90f81de3bfd66f5fe7ccdddf37e9de3ecf1e23af3e4c2c2540d", + "size": 17007, + "subdir": "linux-64", + "timestamp": 1523903612790, + "version": "4.3.0" + }, + "decorator-4.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f6a80033dbc2424406e9e0178e1080a1", + "name": "decorator", + "sha256": "c372662b235c42eafe12a8a973d102014e9ce55361faef46149e34dffb35b2c9", + "size": 17130, + "subdir": "linux-64", + "timestamp": 1523903623007, + "version": "4.3.0" + }, + "decorator-4.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a3ba1f4bdc18086c291960f3a9216f07", + "name": "decorator", + "sha256": "42ae2a66b5b67eb4138073064dbb8d289e6f677dadb3b8e42bf578e2878e7e91", + "size": 16862, + "subdir": "linux-64", + "timestamp": 1523903566479, + "version": "4.3.0" + }, + "decorator-4.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "93aa86c37ca910be8ce11ed48dd64c92", + "name": "decorator", + "sha256": "665fecd1ee005391eb38779a80806c834101d5b7862060a9f112700313070440", + "size": 16833, + "subdir": "linux-64", + "timestamp": 1530694332680, + "version": "4.3.0" + }, + "decorator-4.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4a6a7776d9e73d3d61bbe87c4ef87e5b", + "name": "decorator", + "sha256": "d639c31bbacc000d0cea0d7e276976799a083f8954ca652c1d8c8159c4c0ccdf", + "size": 18247, + "subdir": "linux-64", + "timestamp": 1549321235404, + "version": "4.3.2" + }, + "decorator-4.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6f1759d8173f119095999bf22a95c254", + "name": "decorator", + "sha256": "156e9625344594f49decac70c34d9dbc855535822b6678a639a2d5f44604ba38", + "size": 18326, + "subdir": "linux-64", + "timestamp": 1549321244926, + "version": "4.3.2" + }, + "decorator-4.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "13918898f307403b9ce399dd14e2a877", + "name": "decorator", + "sha256": "80ef866de108ebd52caf6aa0184d45cdac0c1bc3ab68fbf8c31d4ebed4431cee", + "size": 18329, + "subdir": "linux-64", + "timestamp": 1549321208912, + "version": "4.3.2" + }, + "decorator-4.4.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cd1cec7407022324a6586a0a4102f64d", + "name": "decorator", + "sha256": "556a8376b429872ae99a119af339542143f0971ca241aaa7c7275ad420e93031", + "size": 19610, + "subdir": "linux-64", + "timestamp": 1553289502403, + "version": "4.4.0" + }, + "decorator-4.4.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4675a24f414c72682d5eef8f4f34008c", + "name": "decorator", + "sha256": "7314bd1eba59329dd61ba503f0766ccbe92b72b9934387143e4ea060bb540720", + "size": 19680, + "subdir": "linux-64", + "timestamp": 1553289438478, + "version": "4.4.0" + }, + "decorator-4.4.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "56b7924455565586c77641e4913e7db4", + "name": "decorator", + "sha256": "c152583a2b128a679f171be1823e7b1c3dd9a40ae3883cc158a34a819aea379d", + "size": 19576, + "subdir": "linux-64", + "timestamp": 1553289538176, + "version": "4.4.0" + }, + "defusedxml-0.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "1018508af321fb979a5f6ea5b4355026", + "name": "defusedxml", + "sha256": "b439d76065b6b40149b441b159633b2e914fb6b31d02e7787c5518789226cbdd", + "size": 40914, + "subdir": "linux-64", + "timestamp": 1530919284140, + "version": "0.5.0" + }, + "defusedxml-0.5.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "1e2ef1a6082e57aff118e2ac244c5e05", + "name": "defusedxml", + "sha256": "f44d708df449750808e29fe70500f7049ff71d54f9734d760a8e7c8ca91bf287", + "size": 30897, + "subdir": "linux-64", + "timestamp": 1536782398039, + "version": "0.5.0" + }, + "defusedxml-0.5.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "2b4ac0d391b8870f439a5459f9beae71", + "name": "defusedxml", + "sha256": "ac645c082ea0561108ae6c7082a6f9e908eb83b586794f8b13f8c69533ddba22", + "size": 31231, + "subdir": "linux-64", + "timestamp": 1536782427823, + "version": "0.5.0" + }, + "defusedxml-0.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "a169081d09ae5416f20d4b790b472b47", + "name": "defusedxml", + "sha256": "9f82ed2a8751b784b1ba85f65c24143d8520fc8bf22b71ea19d133a5b3976401", + "size": 40532, + "subdir": "linux-64", + "timestamp": 1530919229009, + "version": "0.5.0" + }, + "defusedxml-0.5.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "5b5cf71eb5ce687b88fe636dbdb53e13", + "name": "defusedxml", + "sha256": "eb1d39f1a79f2cc1e60d08fd72a366ccee324bc47f87cf130cf265a5e985be57", + "size": 31129, + "subdir": "linux-64", + "timestamp": 1536782434374, + "version": "0.5.0" + }, + "defusedxml-0.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "c01af056f177067c6670985ad70a7dd8", + "name": "defusedxml", + "sha256": "4f0240cc9d2dbc38abacdbe04b9d2dc39af461a32c92cad4b0b785cb94554ede", + "size": 40564, + "subdir": "linux-64", + "timestamp": 1530919256967, + "version": "0.5.0" + }, + "defusedxml-0.5.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "e626f524717afbb4a4a828941069f92c", + "name": "defusedxml", + "sha256": "7dc180ad6322627808ba67b656acaef123d8d6f0f201c694a84f595218bd0440", + "size": 31101, + "subdir": "linux-64", + "timestamp": 1536782373215, + "version": "0.5.0" + }, + "deprecated-1.2.13-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "wrapt >=1.10,<2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "35c7e776a8a7abf0a26ff4bd38ca71b8", + "name": "deprecated", + "sha256": "aa469d8fd59c8384cf0cf7db5c071fdcaaeb64a2da781e45837025e49c801de9", + "size": 15480, + "subdir": "linux-64", + "timestamp": 1659726507026, + "version": "1.2.13" + }, + "deprecated-1.2.13-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "wrapt >=1.10,<2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ca0e83072e1c9a68cae047c6e757d4b", + "name": "deprecated", + "sha256": "91bc77754bae831e2739acfaa893969c0de3700a8fca880b1cf63c195e4b1ae3", + "size": 18221, + "subdir": "linux-64", + "timestamp": 1676830473529, + "version": "1.2.13" + }, + "deprecated-1.2.13-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "wrapt >=1.10,<2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "006c522dda2ad8bc8aaf0e30416ffcb0", + "name": "deprecated", + "sha256": "beface3fd015039f54af4bde625ed0fb0db2e8b36640fc8c7af68fafddbec66b", + "size": 15398, + "subdir": "linux-64", + "timestamp": 1659726561168, + "version": "1.2.13" + }, + "deprecated-1.2.13-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "wrapt >=1.10,<2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "25458f8bf1c3b4d176481baebd854330", + "name": "deprecated", + "sha256": "d28ed601a2fed164b091b599269f671c3c59d30b8df9ff148a1532e0a65dbde4", + "size": 15388, + "subdir": "linux-64", + "timestamp": 1659726532850, + "version": "1.2.13" + }, + "deprecated-1.2.13-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "wrapt >=1.10,<2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "adfb0afbb4084d5ccdfb73ad4ccfe765", + "name": "deprecated", + "sha256": "32adbeddaddf072c1015d0cf8fc7c1c95f46be4e7eff3ad5ac17c6e7deddb16b", + "size": 15399, + "subdir": "linux-64", + "timestamp": 1659726467857, + "version": "1.2.13" + }, + "descartes-1.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "matplotlib", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "9b131ebd22b2b32adce1aea09c8c7dbd", + "name": "descartes", + "sha256": "871b9c029339d53779d1888a89bf287aeaa1f81070dde5dd4ef91ab49bf8d6b3", + "size": 8980, + "subdir": "linux-64", + "timestamp": 1530873052345, + "version": "1.1.0" + }, + "descartes-1.1.0-py27h5233db4_0.conda": { + "build": "py27h5233db4_0", + "build_number": 0, + "depends": [ + "matplotlib", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "2808958dee95f2e175bf18e9e94f323e", + "name": "descartes", + "sha256": "45b53343f506dee242c712613e8e8ea4a14b5af5c45515304b8172e2186ae3c8", + "size": 9193, + "subdir": "linux-64", + "timestamp": 1513268607706, + "version": "1.1.0" + }, + "descartes-1.1.0-py35h2f9c1c0_0.conda": { + "build": "py35h2f9c1c0_0", + "build_number": 0, + "depends": [ + "matplotlib", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "357314d103ba9644b36aafe17e1e6dd5", + "name": "descartes", + "sha256": "cebd4dae52a9dc32c9b43e8af0cd6fa5565b4295d399a6d06238374caa45122a", + "size": 9587, + "subdir": "linux-64", + "timestamp": 1513268662693, + "version": "1.1.0" + }, + "descartes-1.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "matplotlib", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "797a8daf34b91b9134bdbb34f5df94e2", + "name": "descartes", + "sha256": "da18deb943e531f59cba2ec7a9e661067981c079edf058e2a0bfbf46829d1f25", + "size": 9280, + "subdir": "linux-64", + "timestamp": 1530873114196, + "version": "1.1.0" + }, + "descartes-1.1.0-py36h2f9c1c0_0.conda": { + "build": "py36h2f9c1c0_0", + "build_number": 0, + "depends": [ + "matplotlib", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "93a4dd18e7c958b7829dfc4e5933aedb", + "name": "descartes", + "sha256": "1930a7199499e33d13330f81b1b19003d20d6bcdf15c05206efbd028ef6d0be7", + "size": 9476, + "subdir": "linux-64", + "timestamp": 1513268674408, + "version": "1.1.0" + }, + "descartes-1.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "matplotlib", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "2da47b3f0007f6b86483ff049bbd4a98", + "name": "descartes", + "sha256": "cea6f431bf60f16bca3111a4bdf57d7d34a2fabb7cbedcb664fde67284632be8", + "size": 9263, + "subdir": "linux-64", + "timestamp": 1530873083247, + "version": "1.1.0" + }, + "descartes-1.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "matplotlib", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "d0ae46c9810a110db4f45366fbac0ca8", + "name": "descartes", + "sha256": "03d1d8419a3a191363f1903e45ca8c46abbd52a0eb874be912b05ae680237187", + "size": 9805, + "subdir": "linux-64", + "timestamp": 1574448306954, + "version": "1.1.0" + }, + "devil-1.8.0-hfdbbce5_0.conda": { + "build": "hfdbbce5_0", + "build_number": 0, + "depends": [ + "jasper >=2.0.14,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "zlib" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "76a09281e47aaaee26169e58e796a16a", + "name": "devil", + "sha256": "bf2a3792d106d9e3aafe27db5028a02223e96e8a933939c2373f914543e0f6f8", + "size": 287320, + "subdir": "linux-64", + "timestamp": 1651749256008, + "version": "1.8.0" + }, + "dicttoxml-1.7.4-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "fad96df76d8d853c15a9b88296f9a093", + "name": "dicttoxml", + "sha256": "54574db84fad8a59d34c03c711ebd598bfd95b12a8b81acc387ca3f97975f370", + "size": 29285, + "subdir": "linux-64", + "timestamp": 1543382318301, + "version": "1.7.4" + }, + "dicttoxml-1.7.4-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "b3dff0664e329be0e2cb98574b91ec06", + "name": "dicttoxml", + "sha256": "6bb252ed7931aa087d780b232e51bd77432a2de1b14eb5137fc4f29b6fd94bab", + "size": 23611, + "subdir": "linux-64", + "timestamp": 1640789567413, + "version": "1.7.4" + }, + "dicttoxml-1.7.4-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "ea7b90a6b327e9e1a9c8a1e81bc126df", + "name": "dicttoxml", + "sha256": "c05f2febf6cacbe0ac99b6f0aa26edd54482ce0f2ca2b38b049a09785b7d16c7", + "size": 27106, + "subdir": "linux-64", + "timestamp": 1676851924791, + "version": "1.7.4" + }, + "dicttoxml-1.7.4-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "30f633151f388ddcc0236e3c476b11f0", + "name": "dicttoxml", + "sha256": "831daa82d60f77bb750ab23bcab7c7f1286b0290cec97844f6a927858a10bff4", + "size": 29375, + "subdir": "linux-64", + "timestamp": 1543382337085, + "version": "1.7.4" + }, + "dicttoxml-1.7.4-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "3abc86f630cea7ce403cb5b09c0e6b07", + "name": "dicttoxml", + "sha256": "207e6d15f46604322c4f48dbf7b441ad7e44c1b3bcb7e2b8366f9699402c9318", + "size": 24558, + "subdir": "linux-64", + "timestamp": 1611677538584, + "version": "1.7.4" + }, + "dicttoxml-1.7.4-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "b1e83783c34420b7f0c83c39fa0c0365", + "name": "dicttoxml", + "sha256": "30855741a991d8fc2b9dd45c9022e912aa98e309e0dfdca8728bcc52317aedeb", + "size": 29343, + "subdir": "linux-64", + "timestamp": 1543382277194, + "version": "1.7.4" + }, + "dicttoxml-1.7.4-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "e7fb1562b79bd09204367ed598dd3907", + "name": "dicttoxml", + "sha256": "a2d0bdbf5164bbe1cb7f4a48d5552048c0a20057772b30b14d44155c14029ad5", + "size": 24596, + "subdir": "linux-64", + "timestamp": 1611677561069, + "version": "1.7.4" + }, + "dicttoxml-1.7.4-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "ced19bc29049897e38fffa2796d270a5", + "name": "dicttoxml", + "sha256": "28c9c04558a6f4e81b724631bbc627ded8c9ba1b2f5d8db1c4a3653f1a4c6835", + "size": 23579, + "subdir": "linux-64", + "timestamp": 1572434950434, + "version": "1.7.4" + }, + "dicttoxml-1.7.4-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "c001a3b80bff063a06b015fef35bf1cd", + "name": "dicttoxml", + "sha256": "8b1511871787c3e54f222724d4ebdd2bc17722704ee758726013f2607bb17e10", + "size": 24502, + "subdir": "linux-64", + "timestamp": 1611677577856, + "version": "1.7.4" + }, + "dicttoxml-1.7.4-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "ed89b1184bb25674c37f4afa86b0e4ed", + "name": "dicttoxml", + "sha256": "d47fa4b018e8963fe23e2c43258f183b06039f8bc0d18763cbebbc2421ddc1db", + "size": 24566, + "subdir": "linux-64", + "timestamp": 1611677563416, + "version": "1.7.4" + }, + "diffusers-0.11.0-py310h2f386ee_0.conda": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "diffusers-torch 0.11.0 py310h2f386ee_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "182edb8bded51363f8cfe619d7b9dab5", + "name": "diffusers", + "sha256": "d9a30bb6b121b1f94c941d0175c978960206cbb5d3119672453098335c551118", + "size": 2949621, + "subdir": "linux-64", + "timestamp": 1671578845016, + "version": "0.11.0" + }, + "diffusers-0.11.0-py37hb070fc8_0.conda": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "diffusers-torch 0.11.0 py37hb070fc8_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2d2298a8caefe7f207bb46a53debaac9", + "name": "diffusers", + "sha256": "37d000927b9998059d4ab590ae9d84b4a13b86308b8a7a2339721660b11a784f", + "size": 2829114, + "subdir": "linux-64", + "timestamp": 1671578869411, + "version": "0.11.0" + }, + "diffusers-0.11.0-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "diffusers-torch 0.11.0 py38hb070fc8_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "009b07e3e883f3d7a3b9130a49ffabf4", + "name": "diffusers", + "sha256": "f668f51d90358fe93b7e494dc04e4d700416ba5039a12c483599dd022d841291", + "size": 2926164, + "subdir": "linux-64", + "timestamp": 1671578893889, + "version": "0.11.0" + }, + "diffusers-0.11.0-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "diffusers-torch 0.11.0 py39hb070fc8_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "89ff6c0953fd18bbc0d6c9666274eea8", + "name": "diffusers", + "sha256": "ba33035093ba02277f14ec1a314089694df17a32b6af078e2e9cfe314b006f16", + "size": 2890530, + "subdir": "linux-64", + "timestamp": 1671578918739, + "version": "0.11.0" + }, + "diffusers-base-0.11.0-py310h2f386ee_0.conda": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.10.0", + "importlib-metadata", + "numpy", + "pillow", + "python >=3.10,<3.11.0a0", + "regex !=2019.12.17", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5842870f94110fcabbde06a24ccc6146", + "name": "diffusers-base", + "sha256": "748fd058ddc11c02a3c357234a2e8a229533438b9721d3962eb2cc95f779a6bc", + "size": 2949565, + "subdir": "linux-64", + "timestamp": 1671578666611, + "version": "0.11.0" + }, + "diffusers-base-0.11.0-py37hb070fc8_0.conda": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.10.0", + "importlib-metadata", + "numpy", + "pillow", + "python >=3.7,<3.8.0a0", + "regex !=2019.12.17", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "489864d66170340e7ec4111ed7457859", + "name": "diffusers-base", + "sha256": "d0c1e5f408e6e97132d2cf17c16a9e62735fd3de9187eb00b93e44a3096d76a4", + "size": 2829115, + "subdir": "linux-64", + "timestamp": 1671578688319, + "version": "0.11.0" + }, + "diffusers-base-0.11.0-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.10.0", + "importlib-metadata", + "numpy", + "pillow", + "python >=3.8,<3.9.0a0", + "regex !=2019.12.17", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "af810bdb67380ed78dd033450be01518", + "name": "diffusers-base", + "sha256": "9fa820da0cb3391c141abf73cf58c8b682cda575bc92581bee4d9867b56b5348", + "size": 2926187, + "subdir": "linux-64", + "timestamp": 1671578710063, + "version": "0.11.0" + }, + "diffusers-base-0.11.0-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.10.0", + "importlib-metadata", + "numpy", + "pillow", + "python >=3.9,<3.10.0a0", + "regex !=2019.12.17", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b06cf884258577d4c29ded0077e00d1e", + "name": "diffusers-base", + "sha256": "107f426336dd30a7a1472f63f952d17629f3d5d346c17fd6f527f86319d5f116", + "size": 2890588, + "subdir": "linux-64", + "timestamp": 1671578732056, + "version": "0.11.0" + }, + "diffusers-torch-0.11.0-py310h2f386ee_0.conda": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "diffusers-base 0.11.0 py310h2f386ee_0", + "huggingface_accelerate >=0.11.0", + "python >=3.10,<3.11.0a0", + "pytorch >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "90b290cc33b5d71501d2dcda6004d42e", + "name": "diffusers-torch", + "sha256": "fb5bb731eab226b74afd24356f1dd0261013c9b24a559ce1f44f77a2ad4afcf3", + "size": 2949526, + "subdir": "linux-64", + "timestamp": 1671578753643, + "version": "0.11.0" + }, + "diffusers-torch-0.11.0-py37hb070fc8_0.conda": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "diffusers-base 0.11.0 py37hb070fc8_0", + "huggingface_accelerate >=0.11.0", + "python >=3.7,<3.8.0a0", + "pytorch >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "72f537205e107817ccda6426f3619fba", + "name": "diffusers-torch", + "sha256": "d47db8770b34aeec36f801749bd21c135053c25b3b3b4e7fe88ef032486da87d", + "size": 2829130, + "subdir": "linux-64", + "timestamp": 1671578776239, + "version": "0.11.0" + }, + "diffusers-torch-0.11.0-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "diffusers-base 0.11.0 py38hb070fc8_0", + "huggingface_accelerate >=0.11.0", + "python >=3.8,<3.9.0a0", + "pytorch >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c7b69415399ef5346549a67347f4ef4d", + "name": "diffusers-torch", + "sha256": "92c3847cd58bfb143f7c2f2c9af30bee89e72ddee0bef07aff30e7a8e6fa1991", + "size": 2926102, + "subdir": "linux-64", + "timestamp": 1671578799021, + "version": "0.11.0" + }, + "diffusers-torch-0.11.0-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "diffusers-base 0.11.0 py39hb070fc8_0", + "huggingface_accelerate >=0.11.0", + "python >=3.9,<3.10.0a0", + "pytorch >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "290f2c703057526266e7274823a7e3e5", + "name": "diffusers-torch", + "sha256": "451b05ac8ccda0d58c855fd11bcbf2165caeb4413a279f1539ce505fdf3ff0a8", + "size": 2890520, + "subdir": "linux-64", + "timestamp": 1671578821920, + "version": "0.11.0" + }, + "dill-0.2.7.1-py27h28bf823_0.conda": { + "build": "py27h28bf823_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b27481983d81d82f84b971948ba4bb3f", + "name": "dill", + "sha256": "6633d4ffdcbb5a6c1be29e98225f93f565f6e03dcbde328c339334666a3302f0", + "size": 85616, + "subdir": "linux-64", + "timestamp": 1507667955478, + "version": "0.2.7.1" + }, + "dill-0.2.7.1-py35h51ed871_0.conda": { + "build": "py35h51ed871_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "db59c399bff9c097a202896b90854a46", + "name": "dill", + "sha256": "3d380d300d5dfd884c16e4edd21453c75fd788f95cbe6a61b6213eb51525d5c9", + "size": 85130, + "subdir": "linux-64", + "timestamp": 1507667984668, + "version": "0.2.7.1" + }, + "dill-0.2.7.1-py36h644ae93_0.conda": { + "build": "py36h644ae93_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c07349335b8b334d390127ff27f9963f", + "name": "dill", + "sha256": "b2489eb59c70444184ed13d0eb40421a9851cb5f2154e965d2b0557bc3aeb64f", + "size": 84073, + "subdir": "linux-64", + "timestamp": 1507667987192, + "version": "0.2.7.1" + }, + "dill-0.2.8.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "58df4ff44acf102fb2f51e30f2d99aa0", + "name": "dill", + "sha256": "1315cd70da1f8420e3f52826811776588bc03198e11eaead9db40c7991d64c32", + "size": 114621, + "subdir": "linux-64", + "timestamp": 1529948446908, + "version": "0.2.8.2" + }, + "dill-0.2.8.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cb928956ed2c9cbbdfd56add70191ffa", + "name": "dill", + "sha256": "88de594c373edc81ebe2b9c22376f5d8ee942341a9f982bf013b4848a0f49297", + "size": 116105, + "subdir": "linux-64", + "timestamp": 1529948469911, + "version": "0.2.8.2" + }, + "dill-0.2.8.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3a88a8295665cbe8aabd89d79a636369", + "name": "dill", + "sha256": "42fd0bc1ce4d507c6a1dda601a55228e909290529ba24ef8c38f1f790ef1b41b", + "size": 114812, + "subdir": "linux-64", + "timestamp": 1529948379203, + "version": "0.2.8.2" + }, + "dill-0.2.8.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1f9204899936192121f46b4b654406fa", + "name": "dill", + "sha256": "d7d8b3b43ee273224e39d46bbc2b3d786a0ef2e0656affe916241f24c2fe8969", + "size": 112775, + "subdir": "linux-64", + "timestamp": 1531055475071, + "version": "0.2.8.2" + }, + "dill-0.2.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9462c13e86e6e69e5b9ab81330f32604", + "name": "dill", + "sha256": "319506752d62f4cffc3371ffc66955bcb72e5774d00614c2cee50c039ffae7aa", + "size": 118485, + "subdir": "linux-64", + "timestamp": 1552344487798, + "version": "0.2.9" + }, + "dill-0.2.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "47f5bed04baae217c64641c91720153f", + "name": "dill", + "sha256": "6dc1c2bdbe5e3094dcf34b03d059ff6f150adad1bebf7d8ac17dd6271a801b67", + "size": 116858, + "subdir": "linux-64", + "timestamp": 1552344483098, + "version": "0.2.9" + }, + "dill-0.2.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ed0c5b239a798ad8bc950f2400dd6543", + "name": "dill", + "sha256": "864088856d003e4e7b5284193697b1ade66aca4308c4dc3a2c4fabc687b54c34", + "size": 118784, + "subdir": "linux-64", + "timestamp": 1552344457252, + "version": "0.2.9" + }, + "dill-0.2.9-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "146b0f8fc795301cbf16a9b98ff6d45d", + "name": "dill", + "sha256": "29890d305f4fe42deaf84901349e4f205a5d04500eba15a22000dfbad2b6ea8a", + "size": 115783, + "subdir": "linux-64", + "timestamp": 1572435016852, + "version": "0.2.9" + }, + "dill-0.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6e8e97755ca2084392cca6d67b994235", + "name": "dill", + "sha256": "e09577fffcbad4133fc4867c704969d9abb9f767d82b7afcb253e0ffc59dcd97", + "size": 116828, + "subdir": "linux-64", + "timestamp": 1564161844133, + "version": "0.3.0" + }, + "dill-0.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "07803ff7d5403e51ba60b201ed5530c6", + "name": "dill", + "sha256": "241eb2eaff1bca4391c2036a6c8d3aeb87e21d1bd0cf8c26171379b1ebd1385b", + "size": 117948, + "subdir": "linux-64", + "timestamp": 1564161833605, + "version": "0.3.0" + }, + "dill-0.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8a4241159310f732f89738cc0ce58c85", + "name": "dill", + "sha256": "56b76614c391f5440e6de2be95026020e242675f3fb7396835d01579bcda19d9", + "size": 118165, + "subdir": "linux-64", + "timestamp": 1564161830621, + "version": "0.3.0" + }, + "dill-0.3.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3afb83303213457f3cf9ee311c9c601e", + "name": "dill", + "sha256": "152cc9b53e3ecf8e38a889eb046b49fc79e9264c43b4384f389d4870b8f28ef5", + "size": 120526, + "subdir": "linux-64", + "timestamp": 1573225287802, + "version": "0.3.1.1" + }, + "dill-0.3.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "566b0327820fc3716a991d83dd97101a", + "name": "dill", + "sha256": "09079b3325e71fb40d748fca433b21b4548883486e3e1efaf13c70e0932f1ae6", + "size": 120778, + "subdir": "linux-64", + "timestamp": 1573225289895, + "version": "0.3.1.1" + }, + "dill-0.3.1.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e37b3966cb0ac14654366e9460e9bb00", + "name": "dill", + "sha256": "5d6b8a55e687ae941b395ee0492007da996c7fc2863b9fa613274cefaf3f138c", + "size": 121180, + "subdir": "linux-64", + "timestamp": 1591795853205, + "version": "0.3.1.1" + }, + "dill-0.3.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "97140d90597614b46cbd4ac8e8e5dbc5", + "name": "dill", + "sha256": "9181c38f87db82f4bcee866afc20281883a04916025d3acd51f2c7484b97cf02", + "size": 120866, + "subdir": "linux-64", + "timestamp": 1573225271141, + "version": "0.3.1.1" + }, + "dill-0.3.1.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "333b6568148d180abc6b5ca02e1ffc7d", + "name": "dill", + "sha256": "b7aac2a54d750bdefc3e8e90770524d6dcb53df3b3216b3cd40f311a8f8bba04", + "size": 121333, + "subdir": "linux-64", + "timestamp": 1591789185087, + "version": "0.3.1.1" + }, + "dill-0.3.1.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f8d600f5132dccc19e16f94d5735e156", + "name": "dill", + "sha256": "173d32a9d04acb3be2578fd378e5651f7b36b559367e23711133320e8750524f", + "size": 121499, + "subdir": "linux-64", + "timestamp": 1573225302229, + "version": "0.3.1.1" + }, + "dill-0.3.1.1-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d9513120017eb388d08dcb2b180a3858", + "name": "dill", + "sha256": "61a46ea3280e2428d00978937266f98cbd2ea1b8c41809f428619eaf3f53b6ad", + "size": 121701, + "subdir": "linux-64", + "timestamp": 1591789206731, + "version": "0.3.1.1" + }, + "dill-0.3.6-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d291e8fde00c2cb7b6eef8bdc62789f8", + "name": "dill", + "sha256": "6dcdc99408e2c19b494ec54ada24618ad1ea480a4c589a97e0a99898b2337f82", + "size": 171425, + "subdir": "linux-64", + "timestamp": 1667919622818, + "version": "0.3.6" + }, + "dill-0.3.6-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2862c9d8c55725c172856026a20e7239", + "name": "dill", + "sha256": "b24028545a69f36e9bda04ffbd6ff7999904b8ba2b6edfb7ec4f0e3fb5ab79ea", + "size": 218855, + "subdir": "linux-64", + "timestamp": 1676827725133, + "version": "0.3.6" + }, + "dill-0.3.6-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "13f3a6a11eac7248acf9d8a09fc7dbc4", + "name": "dill", + "sha256": "66975cd3659242f6eb5ac5fe5dab1622d0dda2ff16f5c7c5bfe7a05943b5ef2b", + "size": 169966, + "subdir": "linux-64", + "timestamp": 1667919673864, + "version": "0.3.6" + }, + "dill-0.3.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2dd586d490260fe46079595e4a6f6fd5", + "name": "dill", + "sha256": "bba100f700c66ccd64072800bf49464b3bf94f47762e5a373bfcb6cad769d177", + "size": 170638, + "subdir": "linux-64", + "timestamp": 1667919648125, + "version": "0.3.6" + }, + "dill-0.3.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "14b37021e67815129d42721daa6035b0", + "name": "dill", + "sha256": "74e55700301e8247f64e1d3bd34eb9bc1311240099b51d330d49e0d6b205817e", + "size": 170109, + "subdir": "linux-64", + "timestamp": 1667919699601, + "version": "0.3.6" + }, + "dis3-0.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4473610cf264d19025b90a4562fcd11a", + "name": "dis3", + "sha256": "666332f996f9f3e5e4645ba4d1c4f0f18526610e226c4b11d831e7e9852089bc", + "size": 15943, + "subdir": "linux-64", + "timestamp": 1561613167935, + "version": "0.1.2" + }, + "dis3-0.1.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f0d03513a088a9e46db33c7bb2be9053", + "name": "dis3", + "sha256": "96ceea5f15cbf1cae873914fe78f88f9fd8b74dcf79ba83e03862b24fb8e082c", + "size": 20059, + "subdir": "linux-64", + "timestamp": 1569435647222, + "version": "0.1.3" + }, + "distconfig3-1.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "390d5714e466d7da15b4873dc1847f00", + "name": "distconfig3", + "sha256": "e1f983a9abf13131adbda670c49618067b42853bf935f3a9fb77508a513a69af", + "size": 33258, + "subdir": "linux-64", + "timestamp": 1668611891293, + "version": "1.0.1" + }, + "distconfig3-1.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8410922872d23fea503f602ccbd610b1", + "name": "distconfig3", + "sha256": "4899b3e1ac0b134f49da575ed5c18fb3d52a96ae2a776a9a06eef0260b40fa46", + "size": 38215, + "subdir": "linux-64", + "timestamp": 1676843991242, + "version": "1.0.1" + }, + "distconfig3-1.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5757807a3c575c271d101160b2a9fb4c", + "name": "distconfig3", + "sha256": "587e623671a1a3c41f76df86a1e3e60557db30248a367d787c28fd4208276a6b", + "size": 32599, + "subdir": "linux-64", + "timestamp": 1668611945160, + "version": "1.0.1" + }, + "distconfig3-1.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "84b6d0a0ad78097ff84cb130f039cf58", + "name": "distconfig3", + "sha256": "80d152de492e2abc5c87370330e4952cc8e31174df5c8a9831a6de5565cdf278", + "size": 32854, + "subdir": "linux-64", + "timestamp": 1668611864504, + "version": "1.0.1" + }, + "distconfig3-1.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6e5febbfaa22937ece1ef94079234b9e", + "name": "distconfig3", + "sha256": "983935ea949c912be204025cec3044ad245b5da9490d8b3e40113fedb5c2a6cd", + "size": 32763, + "subdir": "linux-64", + "timestamp": 1668611917928, + "version": "1.0.1" + }, + "distlib-0.2.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "bd88ee839d5107181d7f584adb271ec0", + "name": "distlib", + "sha256": "dc08700a3fc8ffdd098862ac404582396c7a969a6d8453045cd808cc4980fc25", + "size": 327871, + "subdir": "linux-64", + "timestamp": 1519832811537, + "version": "0.2.6" + }, + "distlib-0.2.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "83330e143631745e37a5439bec977998", + "name": "distlib", + "sha256": "999c82a05ae568f29426d4d35ff53781cc85572f3516bf78f3ee6b00dcd745c0", + "size": 334183, + "subdir": "linux-64", + "timestamp": 1519832836940, + "version": "0.2.6" + }, + "distlib-0.2.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "674116bb8f4d48480176b8ad9c1825a6", + "name": "distlib", + "sha256": "e0cae2fc832eafbdb1a650dddb93366fc9a34371def57f9345d068110c234285", + "size": 329961, + "subdir": "linux-64", + "timestamp": 1519832796613, + "version": "0.2.6" + }, + "distlib-0.2.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "515c783c0619876bb5e7487d072abb9c", + "name": "distlib", + "sha256": "0a71e21c85ddef2848999a210bec59e18b6a8cf4520a66e2b09d5d5ed3d63d54", + "size": 328660, + "subdir": "linux-64", + "timestamp": 1524497712517, + "version": "0.2.7" + }, + "distlib-0.2.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "aa3e114f7987b773c44f5d4906268620", + "name": "distlib", + "sha256": "43abeba92e8ffa94cc962ee00261df420343246847d693e3346b152ff65f6e2a", + "size": 334870, + "subdir": "linux-64", + "timestamp": 1524497645775, + "version": "0.2.7" + }, + "distlib-0.2.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "5310862fc8d481a9b48f650bdb742d38", + "name": "distlib", + "sha256": "1ac0c9b8ed24f8bbdd1deeba6213e5720672254de71271a9a7d5451dda6c736f", + "size": 327600, + "subdir": "linux-64", + "timestamp": 1524497719519, + "version": "0.2.7" + }, + "distlib-0.2.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "c6af7de5b6881211cdc587db88d1ff8e", + "name": "distlib", + "sha256": "1c4cdd29c014149b6c93f7004912f88f43fb3283d2555a06dce2929140db49dc", + "size": 330434, + "subdir": "linux-64", + "timestamp": 1530873175503, + "version": "0.2.7" + }, + "distlib-0.2.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "f23b0dba5dc9c8af05cb18a5d6a69d71", + "name": "distlib", + "sha256": "efc90082cd65220954659fc4ab3dfd1f774b5eec3da58773a75783c790cd813e", + "size": 329280, + "subdir": "linux-64", + "timestamp": 1539474355370, + "version": "0.2.8" + }, + "distlib-0.2.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "66d501d5a34298fbeaa63f2e9fd6b690", + "name": "distlib", + "sha256": "2ed44a91ea6acfeb90af2c898882afe8c600f8b306057805e340fa25ba27a547", + "size": 328100, + "subdir": "linux-64", + "timestamp": 1539474363724, + "version": "0.2.8" + }, + "distlib-0.2.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "e9d519b46148019c962ad9a647b6d1b7", + "name": "distlib", + "sha256": "d54943bf78cceaf6355d962462625a723048fcbb20459a2d7620c532e958843f", + "size": 331176, + "subdir": "linux-64", + "timestamp": 1539474365860, + "version": "0.2.8" + }, + "distlib-0.2.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "b5588b79ab3ba63d1e0771164512f06f", + "name": "distlib", + "sha256": "3f7ec4e046965118fb4a6728fcb0a07c09153e3f00be08cedd9178ad97449c58", + "size": 504487, + "subdir": "linux-64", + "timestamp": 1569508525799, + "version": "0.2.9" + }, + "distlib-0.2.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "79bd2dc9568d24b1157361c66306661d", + "name": "distlib", + "sha256": "76a41edbe9c15ae16bbd0aa04e752b1a63b50716ae246117bbdd0b31482b9f28", + "size": 504769, + "subdir": "linux-64", + "timestamp": 1569508532527, + "version": "0.2.9" + }, + "distlib-0.2.9-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "7de3741f48033d872ff9b2ca843e76cd", + "name": "distlib", + "sha256": "efb873a27b1d8cdae4d3f1f4df3ebb92821d70a770f22d745c045dce248d0541", + "size": 566518, + "subdir": "linux-64", + "timestamp": 1611674069017, + "version": "0.2.9" + }, + "distlib-0.2.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "cee341287f5a43b38607c47a2dfaf10e", + "name": "distlib", + "sha256": "6bacbed250d3b21a653fccb9d135f93ed7c0d94a12ea9f430b675a89aedac798", + "size": 504543, + "subdir": "linux-64", + "timestamp": 1569508525250, + "version": "0.2.9" + }, + "distlib-0.2.9-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "ffab8f19d7d440888066cbcfd86b0e41", + "name": "distlib", + "sha256": "ca18f63e870a5f430723f49dabbba7f05ed61f446cf61b67fa56dcc41d03facb", + "size": 570487, + "subdir": "linux-64", + "timestamp": 1611674423203, + "version": "0.2.9" + }, + "distlib-0.2.9-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "1ee113117df98e34f44cafba3e8309b8", + "name": "distlib", + "sha256": "86f652508b99b73ed001dac4cd6a28d965f539f7d225b0838af956d74e9379a2", + "size": 339122, + "subdir": "linux-64", + "timestamp": 1572357197603, + "version": "0.2.9" + }, + "distlib-0.2.9-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "c9700a5dec99e2863d3b0b6aa2eb5981", + "name": "distlib", + "sha256": "e45228538d0199573b49bf6c47e09f78104cfa0bc19f5b285eec9e1def040818", + "size": 571345, + "subdir": "linux-64", + "timestamp": 1611674437463, + "version": "0.2.9" + }, + "distlib-0.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "934336beadc639a20387288805d3fc7d", + "name": "distlib", + "sha256": "0a5b6c8ab2f78c2e4d8bfb66503144bbef2ccc0d58911e591a4ae95b526e719c", + "size": 539758, + "subdir": "linux-64", + "timestamp": 1600715973822, + "version": "0.3.1" + }, + "distlib-0.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "44c85fb017ed1a665d734b101b08b7ff", + "name": "distlib", + "sha256": "de26089f13890aaf61d6d8a07656de84d13ff8aa9daf22c646abdada9ba41704", + "size": 540458, + "subdir": "linux-64", + "timestamp": 1600715938708, + "version": "0.3.1" + }, + "distlib-0.3.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Python Software Foundation License", + "license_family": "OTHER", + "md5": "567937c0e6156526cd0b725d6431120a", + "name": "distlib", + "sha256": "46f05484e5216f17c4b2548c3ff21be3235998fd837d797166d305954e4b2789", + "size": 543348, + "subdir": "linux-64", + "timestamp": 1600715984847, + "version": "0.3.1" + }, + "distlib-0.3.6-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "a25cd220171292af94fe74b0a6cfe650", + "name": "distlib", + "sha256": "5802641427b0010ff498c7126729283a414a3cbb717c79d49062b5aa28116f4f", + "size": 393049, + "subdir": "linux-64", + "timestamp": 1673477588738, + "version": "0.3.6" + }, + "distlib-0.3.6-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "9653afe6c84cf633fdce953a601a8ea9", + "name": "distlib", + "sha256": "15fb2a701209c1b4822d33be3be25a2a308d14913a8c6cac69c03a392efc54a5", + "size": 466445, + "subdir": "linux-64", + "timestamp": 1678983694630, + "version": "0.3.6" + }, + "distlib-0.3.6-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "d8432d46cd4a0434298fc133fd938246", + "name": "distlib", + "sha256": "173181629a22f842fa7e6ebdb2c78e7bfc4bcad11ba20eedfc9c69a45cdd99b0", + "size": 390867, + "subdir": "linux-64", + "timestamp": 1673477615672, + "version": "0.3.6" + }, + "distlib-0.3.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "f71d3fbab78c82fcaa87bc85457b7c6f", + "name": "distlib", + "sha256": "558d86e7df11779094b31dc4d8c000d0e17763d07081888f6119e3ed5e267378", + "size": 390898, + "subdir": "linux-64", + "timestamp": 1673477641906, + "version": "0.3.6" + }, + "distlib-0.3.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "f8537e899af8d15b488c4a4dba23cfc9", + "name": "distlib", + "sha256": "ba899faee7cbb506f0b129fb9a2657d46f36def39181c9e6cc04aeb5ddb31e90", + "size": 391169, + "subdir": "linux-64", + "timestamp": 1673477561804, + "version": "0.3.6" + }, + "distributed-1.18.3-py27h5e7c565_0.conda": { + "build": "py27h5e7c565_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.15.2", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dc53912a2a546a92b8c6cdb1ab256098", + "name": "distributed", + "sha256": "0e370f4e46294980614fe0a6bbc7eaa0af76b64204568a25db6238688ab7f719", + "size": 632315, + "subdir": "linux-64", + "timestamp": 1505733266067, + "version": "1.18.3" + }, + "distributed-1.18.3-py35h076cbad_0.conda": { + "build": "py35h076cbad_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.15.2", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6ff6946b87a3664b1ac7e0416ab9f0e1", + "name": "distributed", + "sha256": "1bbd944054b3f35fde5d02f68dce5afa4c1cb62cbb76860790ce297f5eda4e84", + "size": 650008, + "subdir": "linux-64", + "timestamp": 1505733290512, + "version": "1.18.3" + }, + "distributed-1.18.3-py36h73cd4ae_0.conda": { + "build": "py36h73cd4ae_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.15.2", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bde5bba400b860a8236e69a411fd63e3", + "name": "distributed", + "sha256": "971d592a1a00e35395895bb57f820887f0e5269bcc13a7b94539e2f2a10f73a5", + "size": 641681, + "subdir": "linux-64", + "timestamp": 1505733315334, + "version": "1.18.3" + }, + "distributed-1.19.1-py27h38c4a05_0.conda": { + "build": "py27h38c4a05_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.15.2", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1378fe23e3fdeafea74e7a655447c209", + "name": "distributed", + "sha256": "433a6a4effae2dfd8621e06e2681a5c362c8d62d1ef26fd334f502b518fdc128", + "size": 652577, + "subdir": "linux-64", + "timestamp": 1506624063608, + "version": "1.19.1" + }, + "distributed-1.19.1-py35h399b246_0.conda": { + "build": "py35h399b246_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.15.2", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "61cc0bac5a19a1998fe06bdf76ea6ecd", + "name": "distributed", + "sha256": "b17befa1c913244d6515942bf364f7732cae96b31f119de25317da5b44ce193a", + "size": 671011, + "subdir": "linux-64", + "timestamp": 1506624102722, + "version": "1.19.1" + }, + "distributed-1.19.1-py36h25f3894_0.conda": { + "build": "py36h25f3894_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.15.2", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ef91ddfbcea0b29cafa8ad7c8a103d4b", + "name": "distributed", + "sha256": "68d8e21376646f51267f4653f720ebb3ad30d75c693ac1f0c1e6a262b9154e7e", + "size": 662204, + "subdir": "linux-64", + "timestamp": 1506624079800, + "version": "1.19.1" + }, + "distributed-1.20.0-py27hfe4ef5f_0.conda": { + "build": "py27hfe4ef5f_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.16.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "abde3b45fadf58802635a9ed56a3a81b", + "name": "distributed", + "sha256": "bb66ac35e2f588e4d771994fb9f678af4b71d61100880e389350ddefbd70b592", + "size": 664043, + "subdir": "linux-64", + "timestamp": 1511195990161, + "version": "1.20.0" + }, + "distributed-1.20.0-py35h5ba6bfe_0.conda": { + "build": "py35h5ba6bfe_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.16.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "183d5836e73a4b4d9e538087d7f3c442", + "name": "distributed", + "sha256": "6dd4d9caedd1c79b0a2d5982c7a392969f3f143a3d1b59b5d1495eea6c219b8c", + "size": 689066, + "subdir": "linux-64", + "timestamp": 1511196007800, + "version": "1.20.0" + }, + "distributed-1.20.0-py36h1c9f478_0.conda": { + "build": "py36h1c9f478_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.16.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "15fce11879cbf9a310f1bf7f4a5f7698", + "name": "distributed", + "sha256": "a325d63928cfe801685bde8601ff026cd73b7e00ba56a9b6577cf0006ffd6dc5", + "size": 679026, + "subdir": "linux-64", + "timestamp": 1511196026645, + "version": "1.20.0" + }, + "distributed-1.20.1-py27h41405a2_0.conda": { + "build": "py27h41405a2_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.16.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8460a2500d8a99c40e99cd778d16aa0a", + "name": "distributed", + "sha256": "16adc379d35dbfda837722756ab1278c652500422f8b91b89d91fe63a556d4c7", + "size": 682771, + "subdir": "linux-64", + "timestamp": 1511885260441, + "version": "1.20.1" + }, + "distributed-1.20.1-py35h8354bac_0.conda": { + "build": "py35h8354bac_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.16.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "62a328e06c42b91c4482156b81fb5c55", + "name": "distributed", + "sha256": "0fd651523fd842d7ee9b30ffc5cfba66e3eda250df0870748cce263f9e825bc1", + "size": 695628, + "subdir": "linux-64", + "timestamp": 1511885282869, + "version": "1.20.1" + }, + "distributed-1.20.1-py36h5b7e16d_0.conda": { + "build": "py36h5b7e16d_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.16.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cdb9d883fa999cec99950896881e304a", + "name": "distributed", + "sha256": "88204345e03c755e4c5dd15669d004750636e9c27c5f9fc88847cbec19491c42", + "size": 686482, + "subdir": "linux-64", + "timestamp": 1511885292006, + "version": "1.20.1" + }, + "distributed-1.20.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.16.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e0a150d959d3bdb067dc80528d7690d4", + "name": "distributed", + "sha256": "4eea22a62cda2b4f5cdc1d9d519f4119b50fd36c74e8eb28d738649b34af5754", + "size": 677869, + "subdir": "linux-64", + "timestamp": 1512751311780, + "version": "1.20.2" + }, + "distributed-1.20.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.16.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e567746856963c2b70bf1b3100edb989", + "name": "distributed", + "sha256": "0a8bced71b16680467cb2de9a1dc0d99ec2272f1c474bc44a4662aab253d9309", + "size": 696999, + "subdir": "linux-64", + "timestamp": 1512751322289, + "version": "1.20.2" + }, + "distributed-1.20.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.16.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0845a47c6760de0c050a7c3569fcb370", + "name": "distributed", + "sha256": "7e2f465f8231d628d20f41dcfd19feb9763c280784b59ba839bdc8930213f197", + "size": 693705, + "subdir": "linux-64", + "timestamp": 1512751325256, + "version": "1.20.2" + }, + "distributed-1.21.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.17.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ba48ec74f6104dfe8c98bc2f68182571", + "name": "distributed", + "sha256": "e81dc910a63653e4e79b99920c96078a06061b1f836055a539ccbca0ff386b0c", + "size": 701505, + "subdir": "linux-64", + "timestamp": 1518524447911, + "version": "1.21.0" + }, + "distributed-1.21.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0aa6c91f57ea8b9f344742008d74e061", + "name": "distributed", + "sha256": "5cafd222d5685730370283e24b57910c224bd0ae62b6a643e3cd58a3a8f2ef2c", + "size": 727922, + "subdir": "linux-64", + "timestamp": 1518524500983, + "version": "1.21.0" + }, + "distributed-1.21.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2e74531bd707a8c124dd6b48c1083578", + "name": "distributed", + "sha256": "8d434a405df53cba5a2678bf909d18bdad84c3b5af8d8e7e6a2953004ac531ae", + "size": 717766, + "subdir": "linux-64", + "timestamp": 1518524484876, + "version": "1.21.0" + }, + "distributed-1.21.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.17.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d2a99c0039f5f9a51c7b5d7a7b396fdb", + "name": "distributed", + "sha256": "85bb9c56a433a62ef8559c43ba6f413350284ce54a66cc7a94a823fb708c4d9d", + "size": 718130, + "subdir": "linux-64", + "timestamp": 1519397801363, + "version": "1.21.1" + }, + "distributed-1.21.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "714abdd571ec7f03293d782b4451b3fa", + "name": "distributed", + "sha256": "2e6faa39bd28dad481d901cfeb9c21dd904a5f9d492f258e180fdf0d76e5401b", + "size": 732811, + "subdir": "linux-64", + "timestamp": 1519397840655, + "version": "1.21.1" + }, + "distributed-1.21.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "68befe4bfa8f6818dbb50580f2887956", + "name": "distributed", + "sha256": "eb9cb418e1c7656f10a933b839de5565ebd479372cec69c3a1c480e1e9db4ed1", + "size": 723190, + "subdir": "linux-64", + "timestamp": 1519397767584, + "version": "1.21.1" + }, + "distributed-1.21.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.17.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9b8cf20079238eb14ee0445d3c7ada93", + "name": "distributed", + "sha256": "1925c00663e91514daa827af55d5b07d7b9028668105b778c3dc9b2cddbe9ddc", + "size": 724714, + "subdir": "linux-64", + "timestamp": 1520367506444, + "version": "1.21.2" + }, + "distributed-1.21.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5f5ae09249d4d7871736eacf7f9947f2", + "name": "distributed", + "sha256": "10306eb86621386353d4cca6c0fbad5ad9bc58c98b72a187afb1ceae106fab2e", + "size": 746100, + "subdir": "linux-64", + "timestamp": 1520367521794, + "version": "1.21.2" + }, + "distributed-1.21.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c60eea335cad7106df984d5faa39b50c", + "name": "distributed", + "sha256": "f8acb4107a2fa6c4ff42527e0ab57d0b6799fb03731bcf333585b6e7af6989d5", + "size": 729931, + "subdir": "linux-64", + "timestamp": 1520367547034, + "version": "1.21.2" + }, + "distributed-1.21.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4149dbc7b36d5899c3bedf0b775dd5d4", + "name": "distributed", + "sha256": "e9f4d47a8a844bc4f128201d6b923873d9ccf2b436954b7408a04939dbca58b3", + "size": 726018, + "subdir": "linux-64", + "timestamp": 1520972212793, + "version": "1.21.3" + }, + "distributed-1.21.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "db5ccfbdda14320861fea59dd7724a0b", + "name": "distributed", + "sha256": "5bbeaeacb6a2ad193920e5e8c5e81f062f8b78d8774b12511961266f39191d61", + "size": 745963, + "subdir": "linux-64", + "timestamp": 1520972218689, + "version": "1.21.3" + }, + "distributed-1.21.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "77ecb345b6b097b5c4027428dcc4ce74", + "name": "distributed", + "sha256": "78d0c15b3a62858dea43d2f464da5eaf78416aad6fb42335d17d597291dbcc86", + "size": 736445, + "subdir": "linux-64", + "timestamp": 1520972239105, + "version": "1.21.3" + }, + "distributed-1.21.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "60157996d0c8607850aaf2f230cc80f3", + "name": "distributed", + "sha256": "80361b6553f91b24988a9245dcc17547a3cb16bf899e0ce90221f3ade6027dad", + "size": 727168, + "subdir": "linux-64", + "timestamp": 1521650233567, + "version": "1.21.4" + }, + "distributed-1.21.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b2c61b712bc69a1ddbfc21f459a9bbf2", + "name": "distributed", + "sha256": "cd221f9723cf2a4032c849eb102ed8b4eff9b9ba12c31018d241f22814e359f8", + "size": 754177, + "subdir": "linux-64", + "timestamp": 1521650291364, + "version": "1.21.4" + }, + "distributed-1.21.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "41e4877cd263e8ad4fd7129dd4806066", + "name": "distributed", + "sha256": "14dd330ddd4e8dec6d43169c9349cedb7fd90fcb2fc4eea57e98a3cf46f4ddae", + "size": 743757, + "subdir": "linux-64", + "timestamp": 1521650243033, + "version": "1.21.4" + }, + "distributed-1.21.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aea189ae5ae87d88b3c371a1420249cb", + "name": "distributed", + "sha256": "c580d7e53be7ad55da2181c91b661001d0c9757468fd642e90f42b3b920c3e5d", + "size": 729366, + "subdir": "linux-64", + "timestamp": 1522683658825, + "version": "1.21.5" + }, + "distributed-1.21.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dff150ce56efdaa674d3d757c2342e28", + "name": "distributed", + "sha256": "7cb9da620ededfb5c5555ef33b6d644866ed0edc03aa1376c1eeb079c0d7e7a9", + "size": 749297, + "subdir": "linux-64", + "timestamp": 1522683754951, + "version": "1.21.5" + }, + "distributed-1.21.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "571945166e35697d50a3bf3d4685f103", + "name": "distributed", + "sha256": "c3005fa0c8b6670d5853f7af2d2a8ea3ac37aa2010c1c0cd94c5980715fac199", + "size": 746287, + "subdir": "linux-64", + "timestamp": 1522683682727, + "version": "1.21.5" + }, + "distributed-1.21.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "24b25955f2f862115526c83d454fef9d", + "name": "distributed", + "sha256": "5bfd26e111cbdacedac89069784c4aa84eacc1cef9272b463eed8d0f629e0200", + "size": 730615, + "subdir": "linux-64", + "timestamp": 1523051695940, + "version": "1.21.6" + }, + "distributed-1.21.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a17b47784614680ddc335ee7a8b6edc4", + "name": "distributed", + "sha256": "23e9dd351ca858db11f75026ef3d59834ea094b9a312e6d6af5b263f7779240f", + "size": 758047, + "subdir": "linux-64", + "timestamp": 1523051789469, + "version": "1.21.6" + }, + "distributed-1.21.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "586fd2a78a0173c247dc6ff6cc34032d", + "name": "distributed", + "sha256": "73c2c2c9c764b45c46783da16f8927612b1937a27845731b892bc91f0668d0d4", + "size": 741109, + "subdir": "linux-64", + "timestamp": 1523051788432, + "version": "1.21.6" + }, + "distributed-1.21.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "73dcca9f169274fca8d17dd07bd472db", + "name": "distributed", + "sha256": "a317f065e6f74923b2257ee19275330985467a468461c350dd5003416ecb6084", + "size": 747457, + "subdir": "linux-64", + "timestamp": 1525470945554, + "version": "1.21.8" + }, + "distributed-1.21.8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "39d23419a4e94b0073f97cad7802dd76", + "name": "distributed", + "sha256": "92496cd7afe177e6b4fc36400b07de34a571ce74f8da555983a75db95037715d", + "size": 768461, + "subdir": "linux-64", + "timestamp": 1525470962842, + "version": "1.21.8" + }, + "distributed-1.21.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.17.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7ec11b8aa83340992b1b2c304e567ac2", + "name": "distributed", + "sha256": "d7eaf78d13eed9c1ab660c6c04c20195519e6faacf967116825448323561533e", + "size": 757570, + "subdir": "linux-64", + "timestamp": 1525470872510, + "version": "1.21.8" + }, + "distributed-1.22.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "91b9360534841dabd42b03d3d68be754", + "name": "distributed", + "sha256": "1c6d1b7ad13b08e5c7a603243c4c80794c62a2d6db67364389265915aed52fc0", + "size": 758594, + "subdir": "linux-64", + "timestamp": 1529077046370, + "version": "1.22.0" + }, + "distributed-1.22.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "229537e13707d499da0196d917477be6", + "name": "distributed", + "sha256": "9fa130de6918f8eb21532066c49c9e1bb3b8582f5328942dbcbf93cfeb46aa6e", + "size": 778924, + "subdir": "linux-64", + "timestamp": 1529077060991, + "version": "1.22.0" + }, + "distributed-1.22.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "78eb097cca57df3e92f3a6de70c5143c", + "name": "distributed", + "sha256": "3184fb80d8dd6f10dc6a4e76ecd48f616e7622e97b689796281f3a8b0cbf06c1", + "size": 768927, + "subdir": "linux-64", + "timestamp": 1529076976736, + "version": "1.22.0" + }, + "distributed-1.22.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "88ac58f6a795bc99dba840b0efaf536b", + "name": "distributed", + "sha256": "52ca7b651765d1a2416fd277f41c57fe0515a5ca0d5fba4f8cf133413e89e0c7", + "size": 774861, + "subdir": "linux-64", + "timestamp": 1530741704736, + "version": "1.22.0" + }, + "distributed-1.22.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3505cebdd9b0fb428b9f9b9ff162d180", + "name": "distributed", + "sha256": "87523393b2442cb4c5275ecd83815babef5a91e5becd2abd78e98d3edb12e41d", + "size": 765257, + "subdir": "linux-64", + "timestamp": 1533655834125, + "version": "1.22.1" + }, + "distributed-1.22.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f08b1ae1a4e56a2e4f13720b886b7709", + "name": "distributed", + "sha256": "5a50741d0f10cc47083e4bacbaab414e661a00bdcff1311b2de7ee4620096b1b", + "size": 793966, + "subdir": "linux-64", + "timestamp": 1533655865113, + "version": "1.22.1" + }, + "distributed-1.22.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4cf3ac741d3a15764457df799c9c91c9", + "name": "distributed", + "sha256": "2797ba54fa4c016c28e94cb85a1f416b37a8b70f4494582eb0ac8c3cfa43efb2", + "size": 776165, + "subdir": "linux-64", + "timestamp": 1533655762096, + "version": "1.22.1" + }, + "distributed-1.22.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aeb6347926178ef2b636b41bf718a80c", + "name": "distributed", + "sha256": "76703d18b64d44778e927d7fb44986fa84757aae83de4af5d91fc37c75f91854", + "size": 775909, + "subdir": "linux-64", + "timestamp": 1533655860891, + "version": "1.22.1" + }, + "distributed-1.23.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2ddfeda3103d945d975f6a215f7efe16", + "name": "distributed", + "sha256": "91ce483852f8931144aed69b47a1021de5d5e280b073fe4afe879725b8b40cd3", + "size": 793676, + "subdir": "linux-64", + "timestamp": 1535658991718, + "version": "1.23.0" + }, + "distributed-1.23.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bf21ec2f91c7d658348361bfa3694391", + "name": "distributed", + "sha256": "0c158ecd274850754b5fe62cb43bd4a0694d3adf373235860c95b701bb9cbf4f", + "size": 823222, + "subdir": "linux-64", + "timestamp": 1535659061094, + "version": "1.23.0" + }, + "distributed-1.23.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c5d44ad337375e9a6f5776df6d55bfd3", + "name": "distributed", + "sha256": "99be10b4ac9e86aeaaa348ef61580dbcf1c0788d9f0e3e3f43b075dfd7c824a5", + "size": 811738, + "subdir": "linux-64", + "timestamp": 1535659007381, + "version": "1.23.0" + }, + "distributed-1.23.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "760e1417dcc5fdb347bccc1bd0d0c577", + "name": "distributed", + "sha256": "fe1792284bae59a0fc111f6c463110d4837e7bb7b915f8746280e36ac5ab4094", + "size": 804754, + "subdir": "linux-64", + "timestamp": 1535659027958, + "version": "1.23.0" + }, + "distributed-1.23.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "24037f5e7938fa2180eb584623dee2b8", + "name": "distributed", + "sha256": "b859070818f32f657183787bf6c8a39869a36c2b1595500283a0873097af691b", + "size": 803096, + "subdir": "linux-64", + "timestamp": 1536248112246, + "version": "1.23.1" + }, + "distributed-1.23.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "04806e431890c45999103bf93cd5ae08", + "name": "distributed", + "sha256": "dae305f97ab6cccd2089a62a58fd09dd84062fd019a0d518d4352a766100cb50", + "size": 825194, + "subdir": "linux-64", + "timestamp": 1536248309025, + "version": "1.23.1" + }, + "distributed-1.23.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d501041045c47598ab30e0841808fda0", + "name": "distributed", + "sha256": "d7d735b42d73aa540e908d27b6d4addda1c7eec476903725a4063a9db5bd41a7", + "size": 820713, + "subdir": "linux-64", + "timestamp": 1536248080138, + "version": "1.23.1" + }, + "distributed-1.23.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3c3e565557b21506c0cbc9f6bb728ca7", + "name": "distributed", + "sha256": "edd1ba8669f47a59265fd0c6b3fa560e128c00c20ed697b42a8484e93c2db36b", + "size": 819673, + "subdir": "linux-64", + "timestamp": 1536248276244, + "version": "1.23.1" + }, + "distributed-1.23.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "554d262b8b8bd16ca642fc9db0ac4aaf", + "name": "distributed", + "sha256": "9fbcf947463e87e811402390b53eec07107f8269ef74d75fc4ddfa0162710fe7", + "size": 810466, + "subdir": "linux-64", + "timestamp": 1538069147402, + "version": "1.23.2" + }, + "distributed-1.23.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.5,<3.6.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "15a0dd02aa20cf71611b1654a3278bb1", + "name": "distributed", + "sha256": "c003034e439709ee07e69e9b35fdb55ec1af63c9e64f786775cebea926e1f6a0", + "size": 833495, + "subdir": "linux-64", + "timestamp": 1538069221053, + "version": "1.23.2" + }, + "distributed-1.23.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "728dded87cdd56b1e780d4a54ce6cc16", + "name": "distributed", + "sha256": "03f16fc54674e75aa2c08d44d49e500d535b08d55248c5b721d7c3e21ab27a19", + "size": 822917, + "subdir": "linux-64", + "timestamp": 1538069173967, + "version": "1.23.2" + }, + "distributed-1.23.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d5f9bf37a001bba98f60ac0105417f5c", + "name": "distributed", + "sha256": "e83d312ed2956cadc01b078e75762b7a0de1259730f8dbbb09c98f9748e681e4", + "size": 821452, + "subdir": "linux-64", + "timestamp": 1538069149226, + "version": "1.23.2" + }, + "distributed-1.23.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bcc14e34bf9ca7319b4c6cd8ea261a82", + "name": "distributed", + "sha256": "90e23611906a0db4934598029744f952d3c94a019641010e8efbf8bff1325965", + "size": 794962, + "subdir": "linux-64", + "timestamp": 1539017046402, + "version": "1.23.3" + }, + "distributed-1.23.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "85328860f061a63ef50de2b15c823908", + "name": "distributed", + "sha256": "6348462bc8552cf86f3c0ea69315c158d0f07ed9eaeb79f2ea2993064b8328f0", + "size": 813473, + "subdir": "linux-64", + "timestamp": 1539017103206, + "version": "1.23.3" + }, + "distributed-1.23.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7324853ea32050d9d851aec79c809dc5", + "name": "distributed", + "sha256": "9b98ba99ab4f1019cadec541bc8f968eac300e964b22e77cc85735263de19161", + "size": 813592, + "subdir": "linux-64", + "timestamp": 1539017039280, + "version": "1.23.3" + }, + "distributed-1.24.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "deefe2dc17216a5325d61b5923b579b3", + "name": "distributed", + "sha256": "1be2d7b873b44db449a28da1bcc1934392268ad514d824838929227f78ae24c0", + "size": 789440, + "subdir": "linux-64", + "timestamp": 1540830739969, + "version": "1.24.0" + }, + "distributed-1.24.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3172da94625dbb0738e11336ac77f9a9", + "name": "distributed", + "sha256": "eab37cafc49c66ecf830ddbb9859c9bcd4b9b32da6f09a24c8c1e8ab405af28a", + "size": 801778, + "subdir": "linux-64", + "timestamp": 1540830801685, + "version": "1.24.0" + }, + "distributed-1.24.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dbf715bdd047f638171d59543de61b62", + "name": "distributed", + "sha256": "72c814203f3f18b69d207ee8e329b82dc06115295fca7c5efdfde5ad824dbada", + "size": 807792, + "subdir": "linux-64", + "timestamp": 1540830810745, + "version": "1.24.0" + }, + "distributed-1.24.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7403786cfccb444473e018dca4f29521", + "name": "distributed", + "sha256": "6fb659d44512e37298fe45dd3424def32126e1f4d3479f1c10661326f7845c2b", + "size": 791299, + "subdir": "linux-64", + "timestamp": 1542077555327, + "version": "1.24.1" + }, + "distributed-1.24.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7dbcf80677960fbaf35db73743110e81", + "name": "distributed", + "sha256": "342f21ccc4f2627f2653b200bba6c454669fad02377f380ff9386d2514ff132b", + "size": 802749, + "subdir": "linux-64", + "timestamp": 1542077665894, + "version": "1.24.1" + }, + "distributed-1.24.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "164cdf64c56f572c262e74101a04bf51", + "name": "distributed", + "sha256": "dbedac56e760645a493f07f2edc736eba6d024dbc6ba4fd03ce387965b137d22", + "size": 809530, + "subdir": "linux-64", + "timestamp": 1542077601180, + "version": "1.24.1" + }, + "distributed-1.24.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e395d8b523b79fc8591934a09b438377", + "name": "distributed", + "sha256": "edcb7a2bc9db45681cfc485c3c10d39e4559e3b98303c0e072a8bc765e0a29d4", + "size": 791222, + "subdir": "linux-64", + "timestamp": 1542386532035, + "version": "1.24.2" + }, + "distributed-1.24.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "36f523d89c48ca2edbbcfb9738e60e0e", + "name": "distributed", + "sha256": "b09c589ef7a66bb8b4ad5f3deec67d1c869a698f88478cda4a57137ff28fa3e2", + "size": 809930, + "subdir": "linux-64", + "timestamp": 1542386567339, + "version": "1.24.2" + }, + "distributed-1.24.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "05d465fe06f446852c30bda129c8897a", + "name": "distributed", + "sha256": "bd2c6a42aa3de760ceae376baa6af011cb7aace4b47af8e6c6e5b9312af518dc", + "size": 802628, + "subdir": "linux-64", + "timestamp": 1542386525823, + "version": "1.24.2" + }, + "distributed-1.25.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6d20d5b01d72c4cad887ec9d64fd4649", + "name": "distributed", + "sha256": "0b4efb85dc87650a14407c736579f84e9db90425c8e9b33cc762754cde1c9d46", + "size": 792110, + "subdir": "linux-64", + "timestamp": 1543504087292, + "version": "1.25.0" + }, + "distributed-1.25.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "680e29b07db42df3e4d01b587e619ace", + "name": "distributed", + "sha256": "459b2868562ac93948391e1b6dca177d54e5e1b2f9283048ca5b1e3935c66e82", + "size": 803840, + "subdir": "linux-64", + "timestamp": 1543504155168, + "version": "1.25.0" + }, + "distributed-1.25.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5def5c5fd7b386e3532b76511ee052c9", + "name": "distributed", + "sha256": "d99a87969d06d9f7a192f35b2cf5b129cef8e0157b117635390a46bf8ce69280", + "size": 803193, + "subdir": "linux-64", + "timestamp": 1543504083553, + "version": "1.25.0" + }, + "distributed-1.25.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "988d55ed10433d3729644269b12f4213", + "name": "distributed", + "sha256": "b40e16076fdf2220f12ff26c452183a60bd8d819d099aedefc696b3f508fde6f", + "size": 795844, + "subdir": "linux-64", + "timestamp": 1545074805453, + "version": "1.25.1" + }, + "distributed-1.25.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f12e9200bbd9227b30c544363e615107", + "name": "distributed", + "sha256": "11ea193ced1fbde866283c59af2ff230722d461eb139043456cb0a0e98c0bfa4", + "size": 807976, + "subdir": "linux-64", + "timestamp": 1545074835603, + "version": "1.25.1" + }, + "distributed-1.25.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f4e6bdf715315caaa0617aa323aa1d78", + "name": "distributed", + "sha256": "c52dc289875d478bcba0e20e81ce14abe064c3f1ed0f779f8364ce6ab7f7bf6c", + "size": 814525, + "subdir": "linux-64", + "timestamp": 1545074827283, + "version": "1.25.1" + }, + "distributed-1.25.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ad0c22561ec03daf2e2cc465c3ce884d", + "name": "distributed", + "sha256": "b49d0f865edbe35139005d9dfedc56d02318018082b2ae17c2b919acd42d8df3", + "size": 802740, + "subdir": "linux-64", + "timestamp": 1547226528510, + "version": "1.25.2" + }, + "distributed-1.25.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a037dfb4c15bec2b1793c9f72ed39334", + "name": "distributed", + "sha256": "7dcc6d6a2f4ee06cadb49a3a75bd937db0ac6d83d4f7d8495f3f53a4129d41af", + "size": 822725, + "subdir": "linux-64", + "timestamp": 1547226547340, + "version": "1.25.2" + }, + "distributed-1.25.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4cabd36b7f8f5a1a9efb7364221b1d61", + "name": "distributed", + "sha256": "de44256240a65c84d5a38217c5e86af54a8534680c9ab2b216a17aee8a69237e", + "size": 814535, + "subdir": "linux-64", + "timestamp": 1547226521695, + "version": "1.25.2" + }, + "distributed-1.25.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "846b95e0b2adf35debfaec028ccfdad3", + "name": "distributed", + "sha256": "ef0e359ed6bad8168d9cf102f1d09c59d7a171ad9d4ccc6cdff398e8c3f21dec", + "size": 806531, + "subdir": "linux-64", + "timestamp": 1549338021050, + "version": "1.25.3" + }, + "distributed-1.25.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7413938a3b9b7a557150f7e50f1a4356", + "name": "distributed", + "sha256": "06f2d073ac21d4a0a138bd21a67837f312b8217afa5450f8b1804b26757e4f1d", + "size": 819155, + "subdir": "linux-64", + "timestamp": 1549327059101, + "version": "1.25.3" + }, + "distributed-1.25.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c23cbc4fb7751898dfee64e112bb9789", + "name": "distributed", + "sha256": "fccd6b2fc5f7ef807cce65adec896f54929b4ba26dc68c9ca5d3f0d1937ef3cd", + "size": 811764, + "subdir": "linux-64", + "timestamp": 1549327009240, + "version": "1.25.3" + }, + "distributed-1.26.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "229b2a36c8a6d28db725ad66e425f265", + "name": "distributed", + "sha256": "ad0944976d43f12fbeed63012c40c1c6c52e5c80de95627576437160012d8c8e", + "size": 809006, + "subdir": "linux-64", + "timestamp": 1551127373319, + "version": "1.26.0" + }, + "distributed-1.26.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e518187ea0a09892f4ecdbd24509728a", + "name": "distributed", + "sha256": "898c1ef011fc5c6e020800f830558ebde3534c59612c0ccdb71f0d08bdf4db05", + "size": 816254, + "subdir": "linux-64", + "timestamp": 1551971088530, + "version": "1.26.0" + }, + "distributed-1.26.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7f49cfa4330592f243cd4e22aaa32753", + "name": "distributed", + "sha256": "4b2afd58030ed6cc5a4bf791cf44f4dcdd73dbc6060a4b1a2d52487fd0c476c8", + "size": 821225, + "subdir": "linux-64", + "timestamp": 1551127387176, + "version": "1.26.0" + }, + "distributed-1.26.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4f5125b05478ae663f9f7bdec4f25ba6", + "name": "distributed", + "sha256": "0465eea17f16890f49c7ffc92241cf5c9751d7558b40530dc77a4ba859928e2f", + "size": 821364, + "subdir": "linux-64", + "timestamp": 1551971119429, + "version": "1.26.0" + }, + "distributed-1.26.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=4.5.1", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d74daa523c32252842d348d0cb2dc98d", + "name": "distributed", + "sha256": "48bfc6c52b48a6a8ebcb1bb0c7f8d7d5be60350a9ffa707787ab3dd750e73338", + "size": 820778, + "subdir": "linux-64", + "timestamp": 1551127330219, + "version": "1.26.0" + }, + "distributed-1.26.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4467647d1079eed501e55e5655949f60", + "name": "distributed", + "sha256": "2e7a03177f6d82c914f8ad8729259b95b1f8ea2fcc72e09e6c463e516bc6eee6", + "size": 828473, + "subdir": "linux-64", + "timestamp": 1551971074571, + "version": "1.26.0" + }, + "distributed-1.26.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2a36fe02646b4fcaafd28fe772636089", + "name": "distributed", + "sha256": "2a303be3a78ec3dd3c08636e2a0b07d5de4a2749d13e63e5f04fe70fc71b9a46", + "size": 819543, + "subdir": "linux-64", + "timestamp": 1554925546144, + "version": "1.26.1" + }, + "distributed-1.26.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d093b7d5f6dce252112d40b2ad91271f", + "name": "distributed", + "sha256": "88041365714c6404318537ffec38b2149f36772a64af032cec0936945c7662f9", + "size": 824531, + "subdir": "linux-64", + "timestamp": 1554925573350, + "version": "1.26.1" + }, + "distributed-1.26.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cb915c7b602b0395df2b421768cd62b9", + "name": "distributed", + "sha256": "d6db1edd7b0a4aead985ae0bb8825cced0333a16b3e97082469bee21f88659d3", + "size": 831139, + "subdir": "linux-64", + "timestamp": 1554925595852, + "version": "1.26.1" + }, + "distributed-1.27.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ac6569b66af1e444312a2e6c1307e75f", + "name": "distributed", + "sha256": "cc1fd11f46c2db9e73b5242fc0a1ca5d97684a1e39dbab20a8f4073250f7e998", + "size": 815898, + "subdir": "linux-64", + "timestamp": 1555424758686, + "version": "1.27.0" + }, + "distributed-1.27.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d861340707cf2c386420060e8313477c", + "name": "distributed", + "sha256": "2b18fa2435b04dcc321917b3e5eaebe33a9626786678678e2ce5afce28769789", + "size": 827637, + "subdir": "linux-64", + "timestamp": 1555424655708, + "version": "1.27.0" + }, + "distributed-1.27.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5a9ab48b631cd0a2db3e301834c98fa7", + "name": "distributed", + "sha256": "c8f4656649d353fdd4adfb217539cad379b758b05ea46e97e19c3990eed26e43", + "size": 834507, + "subdir": "linux-64", + "timestamp": 1555424749461, + "version": "1.27.0" + }, + "distributed-1.27.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3415fcfa3c104e76894e87752f2d6a9c", + "name": "distributed", + "sha256": "0f62a79f8ba131de033e52916f1b8c37b7bc4887072921c0865307e7fa1dffa2", + "size": 834809, + "subdir": "linux-64", + "timestamp": 1556558475053, + "version": "1.27.1" + }, + "distributed-1.27.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0902f5e99a4348e86b5f8b34c7ad4ea4", + "name": "distributed", + "sha256": "2113d6a5466293723edb524d7e5820d42122fe9feaf4ba4bda066e0fc9b0b95b", + "size": 847914, + "subdir": "linux-64", + "timestamp": 1556558517227, + "version": "1.27.1" + }, + "distributed-1.27.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c73e947fc0e6936839568a3c391e196b", + "name": "distributed", + "sha256": "b2e773172faf60329ec224b48d896e6784d27900d4da5521c7fd75694a4d3c4a", + "size": 847239, + "subdir": "linux-64", + "timestamp": 1556558474914, + "version": "1.27.1" + }, + "distributed-1.28.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2c857423e8d2de1f8e78a3d9afae2bc0", + "name": "distributed", + "sha256": "19e5973a6ca0e63fafbe7fdfc2a8ddda132aafe0aa047772a8fce5624eb51f9d", + "size": 832772, + "subdir": "linux-64", + "timestamp": 1557501828309, + "version": "1.28.0" + }, + "distributed-1.28.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dbf74a6a6f9d63ab7828a2b89834d18f", + "name": "distributed", + "sha256": "a731494d751218f147cbdef6936e5e61a7fb29efd90f95da2a4399578a3e136c", + "size": 851458, + "subdir": "linux-64", + "timestamp": 1557501819268, + "version": "1.28.0" + }, + "distributed-1.28.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5aaac324bc2293bc7b0c837310d9812f", + "name": "distributed", + "sha256": "4bab851028a12dc025bf9537dcfa5b3ab0ba9f64fd68d3a1e283626b0eca0d06", + "size": 851731, + "subdir": "linux-64", + "timestamp": 1557501775651, + "version": "1.28.0" + }, + "distributed-1.28.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "futures", + "msgpack-python", + "psutil >=5.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "singledispatch", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "29146dc47201731b1d4faab2961d713f", + "name": "distributed", + "sha256": "0100b3a1a3748d0632587feeccb082b2d3bd804c08fed892f85690fe8acee630", + "size": 832987, + "subdir": "linux-64", + "timestamp": 1557855466742, + "version": "1.28.1" + }, + "distributed-1.28.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "34a1e468fa9377de507d3336a17ab706", + "name": "distributed", + "sha256": "fe11dedd664fc9b9616fe7bdc93afdbeeaf06345dfea4006ecaa0bd8211bb63b", + "size": 845497, + "subdir": "linux-64", + "timestamp": 1557855526755, + "version": "1.28.1" + }, + "distributed-1.28.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=0.18.0", + "msgpack-python", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "six", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "34a49ec40b925adcf06e43bd75417e6c", + "name": "distributed", + "sha256": "6951de865981e01353f1a834895d25a08e149919ebdd93853c62a77bf7f833cf", + "size": 851657, + "subdir": "linux-64", + "timestamp": 1557855419574, + "version": "1.28.1" + }, + "distributed-2.11.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f3ea762b330fc7ff5fb4b2892a9e20ba", + "name": "distributed", + "sha256": "22d992d16375304b86fb19caff772755a3c06d22e0f6c420ba32b1387173be28", + "size": 965576, + "subdir": "linux-64", + "timestamp": 1582558602274, + "version": "2.11.0" + }, + "distributed-2.11.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c3266917b473ffcb5fcd9a4ca974d89e", + "name": "distributed", + "sha256": "a28b095064b5109c155cc2744d70342e8a01949ec7187ea4f0f036d38393e754", + "size": 959102, + "subdir": "linux-64", + "timestamp": 1582558364368, + "version": "2.11.0" + }, + "distributed-2.11.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.7.4", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dd17248f5e670dcc6c83deaf37ca7e58", + "name": "distributed", + "sha256": "5c5a0bc32dd1cd4a2f1f5f374f086e7940be3f3401fb1f1d870315b04114210a", + "size": 965779, + "subdir": "linux-64", + "timestamp": 1582558546094, + "version": "2.11.0" + }, + "distributed-2.12.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "38e8bf87c44420484ec7aade3ad1fef3", + "name": "distributed", + "sha256": "5237c74ddb37d23456a1991ced8dda2ba48821f94dd23c276c9fbd424000569b", + "size": 974337, + "subdir": "linux-64", + "timestamp": 1584021686984, + "version": "2.12.0" + }, + "distributed-2.12.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.7.4", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "38d79e9fc8ef6e2e1086d740de44c67a", + "name": "distributed", + "sha256": "1e3b76a1cecd5ff50b233389c45dc2e5c122fc4021ea58d7e802c993d07500ba", + "size": 974191, + "subdir": "linux-64", + "timestamp": 1584021685053, + "version": "2.12.0" + }, + "distributed-2.12.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.7.4", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.7.4", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "873ec591995266a8cac51094a4611b3f", + "name": "distributed", + "sha256": "29595d8cd20bbfb6a8536d3258529767ec90245d926a6ba038fa8194ff648fe9", + "size": 973645, + "subdir": "linux-64", + "timestamp": 1584021773172, + "version": "2.12.0" + }, + "distributed-2.13.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "openssl !=1.1.1e", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fb63843f0b94e6250ae8293cf0373983", + "name": "distributed", + "sha256": "d41f55175264b30f128a04cf88d92b0efc2ebfa99d84050d745db789a6476357", + "size": 978601, + "subdir": "linux-64", + "timestamp": 1585232624778, + "version": "2.13.0" + }, + "distributed-2.13.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "openssl !=1.1.1e", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "286e047f7fdb98b3522f6442bcd33163", + "name": "distributed", + "sha256": "acc9ca276bd2410b0f21cad6e01b01ea64c79762de5ddfb0752600c8365a72b7", + "size": 977226, + "subdir": "linux-64", + "timestamp": 1585232643952, + "version": "2.13.0" + }, + "distributed-2.13.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "openssl !=1.1.1e", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b7216d4622fa53629c13e06e8ae41590", + "name": "distributed", + "sha256": "8753ff49da496ba5bf5145ad5a948af36251356eeec3ab03698713d043f02572", + "size": 977979, + "subdir": "linux-64", + "timestamp": 1585232670254, + "version": "2.13.0" + }, + "distributed-2.14.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cf000763e58cd9fb60891a82a8821e09", + "name": "distributed", + "sha256": "0cfe1eba18a301810a79e8a341aa71bef35fc6aa3819558bef2ed48786872e0e", + "size": 986859, + "subdir": "linux-64", + "timestamp": 1586199035531, + "version": "2.14.0" + }, + "distributed-2.14.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e49becc532025f898960a4079cff9a22", + "name": "distributed", + "sha256": "e6dc533fb76c0fb38464f6e86f62748c6581d353a390964161c385635a333ea1", + "size": 986730, + "subdir": "linux-64", + "timestamp": 1586198939479, + "version": "2.14.0" + }, + "distributed-2.14.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f2554b18eef1e7b1b00ff4b0ab01df2", + "name": "distributed", + "sha256": "101998abef1380d72a374cf57489abd9b457edf70dc369afc32e8e5c4c963f37", + "size": 986337, + "subdir": "linux-64", + "timestamp": 1586199018765, + "version": "2.14.0" + }, + "distributed-2.15.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9da56b570f2cdbc0f87e968b56b1e0db", + "name": "distributed", + "sha256": "024336843bc64fcf370627ad57c91dcdeb275bde4fd6693486fa07abf69b0a56", + "size": 996331, + "subdir": "linux-64", + "timestamp": 1588006856573, + "version": "2.15.0" + }, + "distributed-2.15.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b3aeddce36f9dc5bde20ef3cd030c7e9", + "name": "distributed", + "sha256": "728c45ccc4b11f7ae3121c6a4d41bc22c3a318d35eff6b8be98ba044cbf13f1e", + "size": 1002698, + "subdir": "linux-64", + "timestamp": 1588006837448, + "version": "2.15.0" + }, + "distributed-2.15.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5fd3822f0ffea3b60ee1d15ec955fe66", + "name": "distributed", + "sha256": "e45ca0965bd637a46d5348c948f509ae4cf7bd7b9b85164e2665807fbccc4d6f", + "size": 1003283, + "subdir": "linux-64", + "timestamp": 1588006856500, + "version": "2.15.0" + }, + "distributed-2.15.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1556e889ceea8e77f64e2cc0401adf27", + "name": "distributed", + "sha256": "44612613ad00a7125412badf1b8938c1a0251d1200151e5b84fb35bf365d36ba", + "size": 1004572, + "subdir": "linux-64", + "timestamp": 1588604865348, + "version": "2.15.2" + }, + "distributed-2.15.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b32a54a7e1c5ae2d7433c51b18d2f4ec", + "name": "distributed", + "sha256": "cdb83be2f36ddcaf2c2cfaf9c7bb77981d278c24f4171e5b1e3e5136f7f7ce92", + "size": 1003877, + "subdir": "linux-64", + "timestamp": 1588604861294, + "version": "2.15.2" + }, + "distributed-2.15.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "712ce6902c4acd59dcab52fbf114d3d5", + "name": "distributed", + "sha256": "1ec77d208176991aa5d51ee0ebdb6f2278a870bd8f760715ee368ad08eee6df8", + "size": 1012048, + "subdir": "linux-64", + "timestamp": 1588604863921, + "version": "2.15.2" + }, + "distributed-2.16.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "af7e2e6d382e62195d803c1e83395c5f", + "name": "distributed", + "sha256": "0de6550c125668fd741e7632c8d921492c02727bf2227aca55b64a5087923aaa", + "size": 1004231, + "subdir": "linux-64", + "timestamp": 1589207147770, + "version": "2.16.0" + }, + "distributed-2.16.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a3ae70b8099864cbbf9c1952930316f9", + "name": "distributed", + "sha256": "379d26dc25433fa791d01850f0a105e756ae2a2d90c59c56c87521d4683aaf06", + "size": 1011536, + "subdir": "linux-64", + "timestamp": 1589207139381, + "version": "2.16.0" + }, + "distributed-2.16.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=0.2.2", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ecc37319b728b45906dcc90fbbac6dc3", + "name": "distributed", + "sha256": "bda24ea30a3a5e040dfb6bed4a00d95d8cc5ba6606cbf6fd700db87aeff6cdd3", + "size": 1011435, + "subdir": "linux-64", + "timestamp": 1589207164345, + "version": "2.16.0" + }, + "distributed-2.17.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "db4a842c70bbb82687ab7860b28d759f", + "name": "distributed", + "sha256": "ffca65cf63f8f7c03ff2a652ef009037cb2b529c729879ffdc86aef7d00ae8c8", + "size": 1015528, + "subdir": "linux-64", + "timestamp": 1590590939248, + "version": "2.17.0" + }, + "distributed-2.17.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "11d0b0d8b3e10e4449a2558c8e768798", + "name": "distributed", + "sha256": "a83e9f2337623e803b37483f888c892275f7f1d1b404eb931d2d48cd4587799a", + "size": 1023769, + "subdir": "linux-64", + "timestamp": 1590590938549, + "version": "2.17.0" + }, + "distributed-2.17.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d781657c86a026a6ddff69e5662f4efc", + "name": "distributed", + "sha256": "7e556ad4f7496cf5782c31f196c33023d0a07ed27b479864fd4b0cf829b84d73", + "size": 1022453, + "subdir": "linux-64", + "timestamp": 1590590941270, + "version": "2.17.0" + }, + "distributed-2.18.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f74c7ab2602d075f96d8f1047271099f", + "name": "distributed", + "sha256": "7b9c151ee82c59c859d339f76b1819b20ea240363da0af4d97500efc5c1f3fc8", + "size": 1029109, + "subdir": "linux-64", + "timestamp": 1592250873110, + "version": "2.18.0" + }, + "distributed-2.18.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a131de08d56b92d22ea2024aeb8bfad3", + "name": "distributed", + "sha256": "5196a74a1faa1f332e3ab93c0adc17299da0916aa8fa7bfd449cbba3c9973cce", + "size": 1026897, + "subdir": "linux-64", + "timestamp": 1592250880539, + "version": "2.18.0" + }, + "distributed-2.18.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9bcd7e9553452c402701cca22e01acbb", + "name": "distributed", + "sha256": "cfe4efdea232ae4f697fa5e04b5d94b44971991b26bfb13cc9b1381d9bfa8bbf", + "size": 1035397, + "subdir": "linux-64", + "timestamp": 1592250871622, + "version": "2.18.0" + }, + "distributed-2.19.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "815fc491ef3a497ad3677aecc8052c32", + "name": "distributed", + "sha256": "f4b2631c0b06c593dfa57c68d2f9f38c7b1c1fefd067baac17a5f1f38e50987d", + "size": 1034277, + "subdir": "linux-64", + "timestamp": 1592842516328, + "version": "2.19.0" + }, + "distributed-2.19.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1f5dbb7857a4c71cb5a8eb3a3dc8f1a4", + "name": "distributed", + "sha256": "4adf760dd7841de122ce4eb43078ec1c4fd8b5565b483b48b8ae3df3f04b7344", + "size": 1032997, + "subdir": "linux-64", + "timestamp": 1592842499787, + "version": "2.19.0" + }, + "distributed-2.19.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a212eb41d9228924c9a0fb7737483d78", + "name": "distributed", + "sha256": "d5930af517e0c51440b56924569ba7b9216ed8be0ca735d3ce902ca8547c665e", + "size": 1033465, + "subdir": "linux-64", + "timestamp": 1592842497627, + "version": "2.19.0" + }, + "distributed-2.20.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0580619d3fba50611b64d06d50033ab0", + "name": "distributed", + "sha256": "3007d42b6ba69cfd36e0ee837a1e1ca21b41af77ad82b01866edbee61de0b48d", + "size": 1035390, + "subdir": "linux-64", + "timestamp": 1594750325613, + "version": "2.20.0" + }, + "distributed-2.20.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "635a1ce7f6e0ae7e5136ac508036d66e", + "name": "distributed", + "sha256": "4a7dc7a02c2eeb8efdebf2bf4dc52f37aff9ccd54948360fa6df0c4bd7193381", + "size": 1015827, + "subdir": "linux-64", + "timestamp": 1594350139179, + "version": "2.20.0" + }, + "distributed-2.20.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.3.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cbba8887105b37dd2313b015a2b42199", + "name": "distributed", + "sha256": "65d558a490da130c59c0e4a4f54bd8da304f2b14d5027fe7d034a06313b19ef3", + "size": 1041535, + "subdir": "linux-64", + "timestamp": 1594750325716, + "version": "2.20.0" + }, + "distributed-2.22.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7d873340e4134079d9847c1a8721f31b", + "name": "distributed", + "sha256": "e3f6be8532891bb978f4465f75892c4765a38af4ce1e8f9082589e7414cc1dcf", + "size": 1040648, + "subdir": "linux-64", + "timestamp": 1598652694324, + "version": "2.22.0" + }, + "distributed-2.22.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "93a8973592cdd44ebc8022ad9453dba9", + "name": "distributed", + "sha256": "5ed42d0e1866fad5fa48b52102b3547e6284dd56af26680649322fa049a855a7", + "size": 1028008, + "subdir": "linux-64", + "timestamp": 1596832096867, + "version": "2.22.0" + }, + "distributed-2.22.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7c24de326711c942b00c72d66e43c16a", + "name": "distributed", + "sha256": "5941b62b8497539e07592364b07703c6ff335437b89243dbf255b5a4ec8f8131", + "size": 1046711, + "subdir": "linux-64", + "timestamp": 1598652642895, + "version": "2.22.0" + }, + "distributed-2.23.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d80706848f9ece6901335a0d0fd45e5", + "name": "distributed", + "sha256": "458d110081d5fb8aa027b836b114cb002fafe94581aba06bb77912c1a6239500", + "size": 1045317, + "subdir": "linux-64", + "timestamp": 1598651237489, + "version": "2.23.0" + }, + "distributed-2.23.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4b79f705f7ad7094bbaa0a9179b75856", + "name": "distributed", + "sha256": "39f1012255baa2952fe38805a39468edc29cf89c7251798d944e864c236d9465", + "size": 1032921, + "subdir": "linux-64", + "timestamp": 1597595945458, + "version": "2.23.0" + }, + "distributed-2.23.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4ae13f8d813b1f40c5ab99f789faecec", + "name": "distributed", + "sha256": "17c3f0ee92d60dc0712e41ed4b1496b6f753e9151abb7ef83f5790252f9d4fbc", + "size": 1051566, + "subdir": "linux-64", + "timestamp": 1598651217501, + "version": "2.23.0" + }, + "distributed-2.24.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c223c38eee113e50a244719c0532eb48", + "name": "distributed", + "sha256": "e91c621c6b7a0a5fc19b148a0351d61436b52bb4a1e1f87fbc3a3814e88328cd", + "size": 1047668, + "subdir": "linux-64", + "timestamp": 1598623846582, + "version": "2.24.0" + }, + "distributed-2.24.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4f6ffae5f0bfdf51abc03cbded516890", + "name": "distributed", + "sha256": "9ace72e69efbe64961d390a7d66302a2201734ad6fca6e64afff9566f6554df3", + "size": 1025678, + "subdir": "linux-64", + "timestamp": 1598198406438, + "version": "2.24.0" + }, + "distributed-2.24.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20f8abfce1401ada7ad0bacbecbaef3d", + "name": "distributed", + "sha256": "9daf0b26f8ac94e1528e31459b1b6736b0c1ca5751a36e1bb3ba9a96b8f6059e", + "size": 1053793, + "subdir": "linux-64", + "timestamp": 1598623841590, + "version": "2.24.0" + }, + "distributed-2.25.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4e05f70764676c77e9905355548d6e64", + "name": "distributed", + "sha256": "ea9882418ac9c5ea01eb1fc8da98d4fbbcdab92ab8d39887ac4fd42593b3c6d9", + "size": 1047503, + "subdir": "linux-64", + "timestamp": 1598883562539, + "version": "2.25.0" + }, + "distributed-2.25.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5cdfff18f8a59b6baa32348a81328f81", + "name": "distributed", + "sha256": "2ca39c2a724989299e3569ac34d498c68ab12abdbd743032d2f5a231ab203889", + "size": 1046393, + "subdir": "linux-64", + "timestamp": 1598883559995, + "version": "2.25.0" + }, + "distributed-2.25.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "055e0dab93110ef65ec98ffdd5f610d8", + "name": "distributed", + "sha256": "7454321425c2aa8e68c8da23de875d6a05cff926e39a751477de7499ded767d5", + "size": 1055533, + "subdir": "linux-64", + "timestamp": 1598883566531, + "version": "2.25.0" + }, + "distributed-2.26.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b7f0ed346368824ea0c69342784d06b0", + "name": "distributed", + "sha256": "64da1987abd0b9ba0765fd892478f5c387506378992a1528d5fcd94142cad86b", + "size": 1030437, + "subdir": "linux-64", + "timestamp": 1600136919687, + "version": "2.26.0" + }, + "distributed-2.26.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aaf402d46ded8dbb5c0864fa761fea62", + "name": "distributed", + "sha256": "6a90643903e662a2739699d40fc53f33da4dee23095ca4e5a7a04fa5d188ff5f", + "size": 1028046, + "subdir": "linux-64", + "timestamp": 1600136906521, + "version": "2.26.0" + }, + "distributed-2.26.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1f8012599e902a332c1d71e309238d42", + "name": "distributed", + "sha256": "a7c6eb93b5a3946b4f8ba9b98c940c8ed8b89d351d71728ec865a7c1dffceb98", + "size": 1045434, + "subdir": "linux-64", + "timestamp": 1600136897660, + "version": "2.26.0" + }, + "distributed-2.27.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4f60d49d4d64c94044eebec064a602a7", + "name": "distributed", + "sha256": "1296b1e27401b94f2676eb6edfa36f6125dbaa47fbd19a8223de84e574fcf276", + "size": 1029554, + "subdir": "linux-64", + "timestamp": 1600699890595, + "version": "2.27.0" + }, + "distributed-2.27.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "01c98a281f3971634471d0be1e23902b", + "name": "distributed", + "sha256": "53ceb5b88d5ccb09e8044113e2280783b276724533c38e37bc15da3303705372", + "size": 1036536, + "subdir": "linux-64", + "timestamp": 1600699884840, + "version": "2.27.0" + }, + "distributed-2.27.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a42d13e97b1c35a952483dd263170a00", + "name": "distributed", + "sha256": "48b6637965c921b9f142dfb986233a48cf81dedb26df4b7cb2481b72fa1b5c49", + "size": 1035286, + "subdir": "linux-64", + "timestamp": 1600699881759, + "version": "2.27.0" + }, + "distributed-2.28.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d05f6bd1dc50faaa9443c2c40e598875", + "name": "distributed", + "sha256": "4b172f002bd24f84410ab387c46e653fb9086830fb4768f21849b7f273e93b7e", + "size": 1037536, + "subdir": "linux-64", + "timestamp": 1601309259342, + "version": "2.28.0" + }, + "distributed-2.28.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "42cac54d3fa8f726adbecd41686d1ece", + "name": "distributed", + "sha256": "14946c8f89585d9e1cb4681ad921822a9461136258278f90bcb9a32bad954111", + "size": 1029225, + "subdir": "linux-64", + "timestamp": 1601309267008, + "version": "2.28.0" + }, + "distributed-2.28.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "acd5e196e60b145ad293b1c2e1beac21", + "name": "distributed", + "sha256": "db81b30366c9b510715c9f4f12a460d77d6edf41c4a4b2c861c93c2ec6aa91a1", + "size": 1044935, + "subdir": "linux-64", + "timestamp": 1601309273300, + "version": "2.28.0" + }, + "distributed-2.29.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "273be8da9887e412bda4e14c4717676a", + "name": "distributed", + "sha256": "e378852a391466a02b572253302fddaaa9f09fe1f26d22990c6f7fff17a9f4ae", + "size": 1029881, + "subdir": "linux-64", + "timestamp": 1601910817541, + "version": "2.29.0" + }, + "distributed-2.29.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c5bbb667bac57edbc6dbd6daf76d849c", + "name": "distributed", + "sha256": "29bc02624880da1d9c481ee3066dc9b165809ab4ffc06fdf34d9a3ac6733a68e", + "size": 1037350, + "subdir": "linux-64", + "timestamp": 1601910822015, + "version": "2.29.0" + }, + "distributed-2.29.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c7ebff6b90a081f9bd8d972b57c197d3", + "name": "distributed", + "sha256": "29fd0f76f95925f493aee5ec6b28786df2312571a3eaa01c2ec9eb70f6db2874", + "size": 1045660, + "subdir": "linux-64", + "timestamp": 1601910819078, + "version": "2.29.0" + }, + "distributed-2.30.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ebcb3e22cc856c30390207d32b45c54", + "name": "distributed", + "sha256": "bee67c3f9d10252aa0a00f49d65a453feb5065029d0cf79f3f564a0b94cf81e3", + "size": 1042076, + "subdir": "linux-64", + "timestamp": 1602083954608, + "version": "2.30.0" + }, + "distributed-2.30.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a93422c6abf2e7abde68cc5fb633ad1", + "name": "distributed", + "sha256": "98de9c6ff7ffd87c74d71ad20ddd809032ac28464bf2f2b52f82cb97b97baaff", + "size": 1033346, + "subdir": "linux-64", + "timestamp": 1602083938612, + "version": "2.30.0" + }, + "distributed-2.30.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b7b9e4b214c9c8941af789a73aa8d969", + "name": "distributed", + "sha256": "8ea7c6d2f8c0a8b63cc2006044d6542918c08e4b153547c12a7eec27f9d5753f", + "size": 1041367, + "subdir": "linux-64", + "timestamp": 1602083918686, + "version": "2.30.0" + }, + "distributed-2.30.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "628634e23a61f6bdb8e753888460d024", + "name": "distributed", + "sha256": "4479f89b825e955170215edfc6dfdb77b3ddf70901f909219b7b7eeac87f09e7", + "size": 1034923, + "subdir": "linux-64", + "timestamp": 1605066540496, + "version": "2.30.1" + }, + "distributed-2.30.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b438ab5f037c6254b50bcfd863ca378d", + "name": "distributed", + "sha256": "e5a04d86f5c62b321e64c575972778daa3ffc87d8774aa30f5cadddeb67a0d7d", + "size": 1043181, + "subdir": "linux-64", + "timestamp": 1605066554840, + "version": "2.30.1" + }, + "distributed-2.30.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2.9.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38d17cda9943d3bd0933578240662f57", + "name": "distributed", + "sha256": "d95c1ab1a5d9e675eea7dd28efacf9bdcc35e7858b39a0faf2b35973716d387e", + "size": 1042126, + "subdir": "linux-64", + "timestamp": 1605066559613, + "version": "2.30.1" + }, + "distributed-2020.12.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8103be50f9fee002e4049d597429716d", + "name": "distributed", + "sha256": "46f6a58c99ab5c26567c07f8a6328284c32860bedb527727430ddded9a3484a1", + "size": 1065118, + "subdir": "linux-64", + "timestamp": 1607714086742, + "version": "2020.12.0" + }, + "distributed-2020.12.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3a74ef87f849e5e2530826187ce4925b", + "name": "distributed", + "sha256": "232242060aff2c618dc867f28acf42fde8cc4e3ea3d4810ae1eaad16d84acf18", + "size": 1064270, + "subdir": "linux-64", + "timestamp": 1607714052090, + "version": "2020.12.0" + }, + "distributed-2020.12.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "41498195a7cf844e17eff5a618d3a3c6", + "name": "distributed", + "sha256": "2605e3bde02477340368c191e2c969b1015612f2ce1d4438ca0f31ac9130fcc8", + "size": 1062926, + "subdir": "linux-64", + "timestamp": 1607714091687, + "version": "2020.12.0" + }, + "distributed-2020.12.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8383f60f018357d26a9a5a8b1fc45d4b", + "name": "distributed", + "sha256": "bf216733db721cdb3b4a8fe0a9c24c0e8ac2dd7a25cec46b82c839d76e1f9f44", + "size": 1064494, + "subdir": "linux-64", + "timestamp": 1607714074903, + "version": "2020.12.0" + }, + "distributed-2021.1.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "299353efbb32f82920349f802f165b4c", + "name": "distributed", + "sha256": "64b2849263f03453d7e9fae941ab8adf32437f97502cf962c168c8575ca07fd1", + "size": 1068044, + "subdir": "linux-64", + "timestamp": 1610822595600, + "version": "2021.1.0" + }, + "distributed-2021.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "41a2abcde99e90b855758769250c80b8", + "name": "distributed", + "sha256": "3f098f5d8e65722961c5953a07670d5bfef9952b392079385ad316d483dc6d82", + "size": 1058698, + "subdir": "linux-64", + "timestamp": 1610822584358, + "version": "2021.1.0" + }, + "distributed-2021.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6eaa4160ed792a0a6e7d4414d378b69a", + "name": "distributed", + "sha256": "89a3136aa8fdefcd606e07d748da07cab4678ae531e56506d9a883cabc1e0d27", + "size": 1067962, + "subdir": "linux-64", + "timestamp": 1610822597566, + "version": "2021.1.0" + }, + "distributed-2021.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "877a4bb66785ca84040891fbb0a8c8b5", + "name": "distributed", + "sha256": "d9d28ec1274f2795f9f4641d0f2bb12cbfa893fba6c973583a77f0a53cb5bd95", + "size": 1076418, + "subdir": "linux-64", + "timestamp": 1610821930725, + "version": "2021.1.0" + }, + "distributed-2021.1.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "15f1780bde3a1d3a30da02e222db93a7", + "name": "distributed", + "sha256": "ce4c8fe51b6c24cb1aea728a782ed158e8e81b062a27af060804dae865e854c7", + "size": 1069811, + "subdir": "linux-64", + "timestamp": 1611587309927, + "version": "2021.1.1" + }, + "distributed-2021.1.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "02feff2f4b1d3f6c83c4940c2c557e8f", + "name": "distributed", + "sha256": "f2afb21b9a4ec92234c2582f98cd579097ab3c9b8b9fa2e430f174eccdb88fe4", + "size": 1069389, + "subdir": "linux-64", + "timestamp": 1611341472088, + "version": "2021.1.1" + }, + "distributed-2021.1.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "18ba3f7cd8c9f58cb608dc5e0ec23cbb", + "name": "distributed", + "sha256": "a46cec6f8d8c611863b7666ac3e1c68d33f5fab9e36d9652f7594be21a631f6a", + "size": 1061456, + "subdir": "linux-64", + "timestamp": 1611587022949, + "version": "2021.1.1" + }, + "distributed-2021.1.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4ec16cea0bf19e687d881956e708ee34", + "name": "distributed", + "sha256": "62bed1be4091136f086c03872c46793f0ed96b025fdd33a8b124403f2635a082", + "size": 1061831, + "subdir": "linux-64", + "timestamp": 1611341517545, + "version": "2021.1.1" + }, + "distributed-2021.1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "70cd368f34c8595d5c7986c210831a7d", + "name": "distributed", + "sha256": "0d67d8e49738281dd90508d6680d4f38dccbddf534834252c5e46b2324bbe696", + "size": 1077351, + "subdir": "linux-64", + "timestamp": 1611587329266, + "version": "2021.1.1" + }, + "distributed-2021.1.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d82ab42dfe38cbb8eeaa8eab6bf5bbfa", + "name": "distributed", + "sha256": "f65fbe00837af1701766c70e96795328445f4ecdc098738368af60f504b8c6d8", + "size": 1077073, + "subdir": "linux-64", + "timestamp": 1611341497107, + "version": "2021.1.1" + }, + "distributed-2021.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "434cab89f953311c6df5010316389733", + "name": "distributed", + "sha256": "42b5bbb0fa9bf641b18053b94dce1f388c8f47e39d13ed1bb6bc61734ce923ac", + "size": 1068327, + "subdir": "linux-64", + "timestamp": 1611587333278, + "version": "2021.1.1" + }, + "distributed-2021.1.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "06afb44cab51817cfd7ca446225765eb", + "name": "distributed", + "sha256": "8a01ec7093b12a29eeb2aa766f6a25fae8ed6e1ce6e7dcac10d103c67aea6b64", + "size": 1070340, + "subdir": "linux-64", + "timestamp": 1611341515538, + "version": "2021.1.1" + }, + "distributed-2021.10.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.10.0.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.10,<3.11.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2fce15a611ce69a22f3e834abe50e0f4", + "name": "distributed", + "sha256": "b2e57f6c257be179a89f17f146502ddfd6de8fe59056d7ae3c07555e72fe81f7", + "size": 1011208, + "subdir": "linux-64", + "timestamp": 1642512829673, + "version": "2021.10.0" + }, + "distributed-2021.10.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.10.0.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0af5d518902f9c84608efbf5773c9a78", + "name": "distributed", + "sha256": "db27437459276c1d838dbd5abd25e9c61f021c147ac550b99f649aad0b02de07", + "size": 1011055, + "subdir": "linux-64", + "timestamp": 1635968235028, + "version": "2021.10.0" + }, + "distributed-2021.10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.10.0.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c487a9a201b9fe50865a06464a2a430a", + "name": "distributed", + "sha256": "6c829efe2e57330ddcdb75192a29ab44f463cf579ba1a7d4ff996134f805bfac", + "size": 1015448, + "subdir": "linux-64", + "timestamp": 1635968239447, + "version": "2021.10.0" + }, + "distributed-2021.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.10.0.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4304b1fb8d4ad88f73be4e5ac2c71d6e", + "name": "distributed", + "sha256": "ee2eb01a5709d5b94433fc5721ea404fce99fb5d381cc418e8c7d460a4d1e90a", + "size": 1017895, + "subdir": "linux-64", + "timestamp": 1635956256132, + "version": "2021.10.0" + }, + "distributed-2021.2.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "780ec8e748b05595e091de7bc0605e26", + "name": "distributed", + "sha256": "612a98c016e89c3fe7ce8be5cf7265f212302813f44fe19cb1c1d05b8bd27a31", + "size": 1065586, + "subdir": "linux-64", + "timestamp": 1613253514854, + "version": "2021.2.0" + }, + "distributed-2021.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "482f4f91c77e574f1b1f3469bd857ebc", + "name": "distributed", + "sha256": "06d664bfced915d56984949528a5d419b25750222600020c37d31508722fed5a", + "size": 1073734, + "subdir": "linux-64", + "timestamp": 1613253515853, + "version": "2021.2.0" + }, + "distributed-2021.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3ac4c0f7effdf624691f51c30839ed00", + "name": "distributed", + "sha256": "76e01cbbba343979d6f9e9d19860a62f2eb488bf5bee44dca34071497ea6c388", + "size": 1081737, + "subdir": "linux-64", + "timestamp": 1613253520408, + "version": "2021.2.0" + }, + "distributed-2021.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d21a88733864ad4fb0a7e1a5c0d333df", + "name": "distributed", + "sha256": "1870ed4193c2fc72fdfeefc31a92728107c2de7f2030dbebdd84a440ea46a293", + "size": 1072846, + "subdir": "linux-64", + "timestamp": 1613253522120, + "version": "2021.2.0" + }, + "distributed-2021.3.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "contextvars", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7f27ad8dfe92feddec4c9533a34f02ee", + "name": "distributed", + "sha256": "65f2e21671c1810a3f7ab99b19306ae079dfc43102f46aac203872452bd1c27a", + "size": 1073180, + "subdir": "linux-64", + "timestamp": 1615054637026, + "version": "2021.3.0" + }, + "distributed-2021.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9f2b68b9a68990ce7181c13d3269dad7", + "name": "distributed", + "sha256": "e2b6364bc5f3225646b0b4f210ff2c9c0231efde08f371d0694c911a6efa4865", + "size": 1065895, + "subdir": "linux-64", + "timestamp": 1615055324628, + "version": "2021.3.0" + }, + "distributed-2021.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "64abce7fa5c418f8b0e927709d77d2e9", + "name": "distributed", + "sha256": "2698f26df1304697036beb87b44e43f4d0e2ca849e0d78a0fb52ce99891fafdb", + "size": 1080317, + "subdir": "linux-64", + "timestamp": 1615055334373, + "version": "2021.3.0" + }, + "distributed-2021.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9fed58f67ea0cd055b95b9a4aa4a927c", + "name": "distributed", + "sha256": "eed35566dd1e5350b87b48fe21314b7c73c2524a6464d9c03f3e92fd235fad4b", + "size": 1072973, + "subdir": "linux-64", + "timestamp": 1615055338438, + "version": "2021.3.0" + }, + "distributed-2021.3.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "30a9539fb89cbcd2616bd0c8f87417dc", + "name": "distributed", + "sha256": "e7a94495aec63a871b11f1d03746ded1da0043c6fbd9d3faf3dcae8e4ca137ab", + "size": 1077005, + "subdir": "linux-64", + "timestamp": 1617220292322, + "version": "2021.3.1" + }, + "distributed-2021.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b5c88c7e277f1c5512a30304fc2b2ce5", + "name": "distributed", + "sha256": "2d9cf120eb751609c5880460b9f066a8c31691318512cb5ec79d464119d500ed", + "size": 1084021, + "subdir": "linux-64", + "timestamp": 1617220286548, + "version": "2021.3.1" + }, + "distributed-2021.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8e85d09df3124195ee34cf5de46647bb", + "name": "distributed", + "sha256": "25a0ea1d84531123a472c607289001f6ee755ab99296b13fa673f4ffcf00ead1", + "size": 1085939, + "subdir": "linux-64", + "timestamp": 1617220109840, + "version": "2021.3.1" + }, + "distributed-2021.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1207e9e4131a5d4913e6a14b7787c439", + "name": "distributed", + "sha256": "071643d796d0d17229e2577e3f8ce5a6dc2e8b4f516fb71d34ee14a3d6381339", + "size": 1076536, + "subdir": "linux-64", + "timestamp": 1617383733549, + "version": "2021.4.0" + }, + "distributed-2021.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee6eff232860d5fcef181ea36b46abf2", + "name": "distributed", + "sha256": "8476ae61924a8c965234f91f1b133e115f9e16b89f0ab57ff58c9a6afdc56530", + "size": 1090973, + "subdir": "linux-64", + "timestamp": 1617381543839, + "version": "2021.4.0" + }, + "distributed-2021.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2020.12.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9fde3ff07a790301d3297a9a5125edd2", + "name": "distributed", + "sha256": "7dbc7765ded80057d96c8aef032cc02d99903cde1a0222a005e3af6eecd4b4ae", + "size": 1083210, + "subdir": "linux-64", + "timestamp": 1617384123905, + "version": "2021.4.0" + }, + "distributed-2021.4.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2021.3.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "34edbe7ef99a60b147ea1f8db18d660d", + "name": "distributed", + "sha256": "c3a69c847e220e86405469e7ab999965366a9befdedbe1c68423cc9796f2543e", + "size": 1092343, + "subdir": "linux-64", + "timestamp": 1620906724179, + "version": "2021.4.1" + }, + "distributed-2021.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2021.3.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ab7bafb3976e4685833bd348542a82e1", + "name": "distributed", + "sha256": "ddcc5395fc44661ed1ab2bcfec86e633bd1c7ec58e094f8d2408873a4becafd1", + "size": 1109195, + "subdir": "linux-64", + "timestamp": 1620902880236, + "version": "2021.4.1" + }, + "distributed-2021.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core >=2021.3.0", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eb839b82c43f1b583182ff0cc651fb13", + "name": "distributed", + "sha256": "f0fbab2dd2d0b6e9688ff1e5d0aee1fdad9eb30c06cbd00be4ff4429a171488d", + "size": 1099503, + "subdir": "linux-64", + "timestamp": 1620907237140, + "version": "2021.4.1" + }, + "distributed-2021.5.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.5.0.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "709e8a90030dfcd883055371cc7250f2", + "name": "distributed", + "sha256": "678212647c1ddb551a8094253d26eea4e1277263cbece93b1d80fae9e25d9063", + "size": 1105565, + "subdir": "linux-64", + "timestamp": 1621290234256, + "version": "2021.5.0" + }, + "distributed-2021.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.5.0.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "96b199d5ede291a13e387f60276734cb", + "name": "distributed", + "sha256": "e50c9e7ab301ff50571bf55b059698ebb657b0c2bc81b27bd96d5f3d08e1bf17", + "size": 1104533, + "subdir": "linux-64", + "timestamp": 1621290228328, + "version": "2021.5.0" + }, + "distributed-2021.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.5.0.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cfc701678f33db637707746bd016369f", + "name": "distributed", + "sha256": "f46736f2eacbf1a2dc8c359b53f498de35b5b5bd4fa06838323b0edd7a360d9c", + "size": 1104453, + "subdir": "linux-64", + "timestamp": 1621290228848, + "version": "2021.5.0" + }, + "distributed-2021.5.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.5.1.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6355ddf3da9c3fba358d6eb1ffbf8916", + "name": "distributed", + "sha256": "ef720b565baa12dc5ac61944cd49a587d2e29079ff02a31d43b9cbb7ceb8b175", + "size": 1106541, + "subdir": "linux-64", + "timestamp": 1622643061589, + "version": "2021.5.1" + }, + "distributed-2021.5.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.5.1.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4022affdb78a1234df8533f6e10a8bbf", + "name": "distributed", + "sha256": "6ab1315fa45bf5711d5389878192a7e628ea90790b77fd3590d41edbd23e2df9", + "size": 1112534, + "subdir": "linux-64", + "timestamp": 1622643766398, + "version": "2021.5.1" + }, + "distributed-2021.5.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.5.1.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f0784185702d26293d53c4b9a7739b6c", + "name": "distributed", + "sha256": "09932a1d18abdd94706fcff16f02e3546256905eb5ea86ca90939425e782e5fc", + "size": 1122244, + "subdir": "linux-64", + "timestamp": 1622643769768, + "version": "2021.5.1" + }, + "distributed-2021.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.6.0.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7a4c71f7e655a393f76ef318565bac54", + "name": "distributed", + "sha256": "664a150a67b17914721f7d1aadf103613fde2c14de27ce8e4871080bb4296379", + "size": 1115313, + "subdir": "linux-64", + "timestamp": 1623168940195, + "version": "2021.6.0" + }, + "distributed-2021.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.6.0.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a1961f064ed456cf79b9fb3ecd18125", + "name": "distributed", + "sha256": "37307e494292dd00bef2faf0bf9df927d370b3df2e879e728963010e0829a8d5", + "size": 1134226, + "subdir": "linux-64", + "timestamp": 1623174445285, + "version": "2021.6.0" + }, + "distributed-2021.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.6.0.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5d0b3b995ca02429e70cb2c9b92e252f", + "name": "distributed", + "sha256": "c4c3dd7dbb005f2aa0d069d1780d3431391fd483f4d393cdecd1eec0baa2b5a9", + "size": 1134757, + "subdir": "linux-64", + "timestamp": 1623174444800, + "version": "2021.6.0" + }, + "distributed-2021.6.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.6.1.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3421591cc0af49897c9e8d16a5b70254", + "name": "distributed", + "sha256": "0bb931feaa4a9987f1c532439425c018b014f2c416d33ba17d28aeef4a217eee", + "size": 1127144, + "subdir": "linux-64", + "timestamp": 1624558438391, + "version": "2021.6.1" + }, + "distributed-2021.6.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.6.1.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6d7e9ad3352b4c836239dc832a846e44", + "name": "distributed", + "sha256": "a367c19beb91a2c25e2b8c369f2da76f7efb01eedb90362ee4c264871a31221e", + "size": 1145137, + "subdir": "linux-64", + "timestamp": 1624557709620, + "version": "2021.6.1" + }, + "distributed-2021.6.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.6.1.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1b957c7ea2a9b1e10e2e849d4e2ba472", + "name": "distributed", + "sha256": "6315c984f6669ddc8dc282c56e33d7a29248f0ec82fc177d8622ae336491b043", + "size": 1144575, + "subdir": "linux-64", + "timestamp": 1624558436159, + "version": "2021.6.1" + }, + "distributed-2021.6.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.6.2.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1382f7b825744540c655a39cb9f52408", + "name": "distributed", + "sha256": "06c1a4fe014a583fc5c0951a07302d2be7884d435731668cf055d2c8f687116e", + "size": 1126370, + "subdir": "linux-64", + "timestamp": 1624589165337, + "version": "2021.6.2" + }, + "distributed-2021.6.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.6.2.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1da84ad62b846a03cec11deb401709f2", + "name": "distributed", + "sha256": "a0d490f9fec2aeb60b1417dca88ecaf87b9ac13d1d0ddccd307c083c0d8ba0cb", + "size": 1136016, + "subdir": "linux-64", + "timestamp": 1624589295317, + "version": "2021.6.2" + }, + "distributed-2021.6.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.6.2.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3053d1c07fd9d2af308b47671a4ff03e", + "name": "distributed", + "sha256": "e18b98c0c82639052bb7c222ed1ce4d29fa1615a69f8294c41e143aea30807df", + "size": 1144580, + "subdir": "linux-64", + "timestamp": 1624583038800, + "version": "2021.6.2" + }, + "distributed-2021.7.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.7.0.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "40b7a2ae34347c1c73c01c964954af78", + "name": "distributed", + "sha256": "446263a802452c48b7daae9b95b221958209fe0e6e2c738944851a0293a2f9dd", + "size": 1450627, + "subdir": "linux-64", + "timestamp": 1626113028846, + "version": "2021.7.0" + }, + "distributed-2021.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.7.0.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "09f49d701ea07fd68e499e198e83aeb3", + "name": "distributed", + "sha256": "6502353120ad757b58506cac37ed85970c186d856844d37a46093b3fb68136dd", + "size": 1451949, + "subdir": "linux-64", + "timestamp": 1626113027982, + "version": "2021.7.0" + }, + "distributed-2021.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.7.0.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a954280a310c6d5e371e595b84a3cbf8", + "name": "distributed", + "sha256": "b23ef69fb1f4258a24619e1c1dfa6b80138e8880fa6ed8135dbb8552a7d483ea", + "size": 1450901, + "subdir": "linux-64", + "timestamp": 1626112664278, + "version": "2021.7.0" + }, + "distributed-2021.7.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.7.2.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a5e8c905216f1386171e3a5c8c83f193", + "name": "distributed", + "sha256": "fcf2751b9c5649376e4444023fb412345ca349dec68a20c748f72aab9bfe0fd1", + "size": 975798, + "subdir": "linux-64", + "timestamp": 1628001522135, + "version": "2021.7.2" + }, + "distributed-2021.7.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.7.2.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e2c8e619767427e8630424a005634f1", + "name": "distributed", + "sha256": "db08fe7a5f35e3219b2c5dfce2201d57fc9030e1af0a156ba3415e76a460eb09", + "size": 972466, + "subdir": "linux-64", + "timestamp": 1628001552572, + "version": "2021.7.2" + }, + "distributed-2021.7.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.7.2.*", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a5a1e75184b826100dc015f86c39a0e7", + "name": "distributed", + "sha256": "af8be30e3ba1d44a687ff2a3284153d283a0363051ce6ef6cf0f5902369b96c2", + "size": 979073, + "subdir": "linux-64", + "timestamp": 1628001122817, + "version": "2021.7.2" + }, + "distributed-2021.8.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.8.0.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e016d5ca27137bc2ecc0889e20bead04", + "name": "distributed", + "sha256": "d7d69ac76d479b1569c2e8fe6470d9565d45c12dd8ef763af2a0f922535adf06", + "size": 975185, + "subdir": "linux-64", + "timestamp": 1629141747422, + "version": "2021.8.0" + }, + "distributed-2021.8.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.8.0.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "02ffeadd66a540a6d060e2cc0aa0ad11", + "name": "distributed", + "sha256": "d12618a9dbfe134ec02704f93551986a6a39f823a2b83bc0b2b004bb2b61c6b4", + "size": 977434, + "subdir": "linux-64", + "timestamp": 1629141746441, + "version": "2021.8.0" + }, + "distributed-2021.8.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.8.0.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "988d4467e921e68ee01e55ba2716d05a", + "name": "distributed", + "sha256": "405f4b0912f2f0122008613435fd34b3281114d9214bd303b74cb0f912fbca9d", + "size": 976292, + "subdir": "linux-64", + "timestamp": 1629141750261, + "version": "2021.8.0" + }, + "distributed-2021.8.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.8.1.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2d782c305279b9ddd1d692a53ba2a206", + "name": "distributed", + "sha256": "cc284ba563b10ffb35b6d85a1d74cdbcdf7433a2ec8679e3dc68aeaf871037f7", + "size": 988147, + "subdir": "linux-64", + "timestamp": 1630620021670, + "version": "2021.8.1" + }, + "distributed-2021.8.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.8.1.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e882e1fcee47c1743af18222753c51d0", + "name": "distributed", + "sha256": "2c5a38640c73f878d9634d3a7fcc5afcd9a4d907bab40049875086d43c5a1318", + "size": 993145, + "subdir": "linux-64", + "timestamp": 1630629301789, + "version": "2021.8.1" + }, + "distributed-2021.8.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.8.1.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ef31f31e9efbf0e9924dfa38a8d93256", + "name": "distributed", + "sha256": "7e8e48ebbee028440fef3cc7ccf787a12800e20f57ccbc191bdcfda9b0645cfc", + "size": 995383, + "subdir": "linux-64", + "timestamp": 1630629004353, + "version": "2021.8.1" + }, + "distributed-2021.9.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.9.1.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=5", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1f616947cac1f2ea44abc03fddfac39d", + "name": "distributed", + "sha256": "f48d0f21fa1dd969d508f78b606f44ce1f9b0c66aca6d0e250b5174c1a5333cb", + "size": 999412, + "subdir": "linux-64", + "timestamp": 1634741471435, + "version": "2021.9.1" + }, + "distributed-2021.9.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.9.1.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f1ba6eb793e398dc735a58483fcd645d", + "name": "distributed", + "sha256": "6c5551750f574fa68eb0fb21ee1f9060f231ae2cecfa142d6e89d764a9aa892c", + "size": 1005819, + "subdir": "linux-64", + "timestamp": 1634730106507, + "version": "2021.9.1" + }, + "distributed-2021.9.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "cytoolz >=0.8.2", + "dask-core 2021.9.1.*", + "jinja2", + "msgpack-python >=0.6.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e27ce7b9e2ffd635184d301e2647bc3e", + "name": "distributed", + "sha256": "0115d36cfec9975101d46bbc1dc7bd107d64043e8a00ea3b1edcbb31fe2991b5", + "size": 1006893, + "subdir": "linux-64", + "timestamp": 1634741468527, + "version": "2021.9.1" + }, + "distributed-2022.5.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "dask-core 2022.5.0.*", + "jinja2", + "locket >=1.0.0", + "msgpack-python >=0.6.0", + "packaging >=20.0", + "psutil >=5.0", + "python >=3.10,<3.11.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "urllib3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "04a0fd2966e04d2b1ede522f69ee090e", + "name": "distributed", + "sha256": "b7b3c81ae4ce37ee62b6d84ab5efdc107585bc546165ce40650e90b735d46260", + "size": 1088886, + "subdir": "linux-64", + "timestamp": 1653401806837, + "version": "2022.5.0" + }, + "distributed-2022.5.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "dask-core 2022.5.0.*", + "jinja2", + "locket >=1.0.0", + "msgpack-python >=0.6.0", + "packaging >=20.0", + "psutil >=5.0", + "python >=3.11,<3.12.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "urllib3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e84a35b58926cf7f17bd263317e0a627", + "name": "distributed", + "sha256": "99bcde42b077a4f8a897083d10cbbd1629f77caf3ef4d57f13343ca73b04bda5", + "size": 1355309, + "subdir": "linux-64", + "timestamp": 1676839711274, + "version": "2022.5.0" + }, + "distributed-2022.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "dask-core 2022.5.0.*", + "jinja2", + "locket >=1.0.0", + "msgpack-python >=0.6.0", + "packaging >=20.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "urllib3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "62c6283ea25e03ec1bd03a2219911fb8", + "name": "distributed", + "sha256": "1df7bd9b548c739ce36eb4f7692131eac4197cb36cd2ba4c0040bebd201b27d3", + "size": 1077722, + "subdir": "linux-64", + "timestamp": 1653401843242, + "version": "2022.5.0" + }, + "distributed-2022.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "dask-core 2022.5.0.*", + "jinja2", + "locket >=1.0.0", + "msgpack-python >=0.6.0", + "packaging >=20.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3", + "urllib3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "15cd319e92b182f413d45916b352fe5c", + "name": "distributed", + "sha256": "f7524d05cd9de0127d6d691244a8d78baaf8929788d28415f654e1c94bb3268f", + "size": 1078607, + "subdir": "linux-64", + "timestamp": 1653401880449, + "version": "2022.5.0" + }, + "distributed-2022.7.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "dask-core 2022.7.0.*", + "jinja2", + "locket >=1.0.0", + "msgpack-python >=0.6.0", + "packaging >=20.0", + "psutil >=5.0", + "python >=3.10,<3.11.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3,<6.2", + "urllib3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6d46e73e5f013534d93dbcc96900225f", + "name": "distributed", + "sha256": "aeaeb36ede4672d1d95d199c6471c366f6f565fe53f83c48841bd4767c9ee575", + "size": 1127132, + "subdir": "linux-64", + "timestamp": 1658520862470, + "version": "2022.7.0" + }, + "distributed-2022.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "dask-core 2022.7.0.*", + "jinja2", + "locket >=1.0.0", + "msgpack-python >=0.6.0", + "packaging >=20.0", + "psutil >=5.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3,<6.2", + "urllib3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "63190dcd6bf8c830b1a820a688b80dc8", + "name": "distributed", + "sha256": "8b547b4b10925beece2940ece0bdfac8f9f78e51bb63ef9915d298bed624396d", + "size": 1114935, + "subdir": "linux-64", + "timestamp": 1658520781694, + "version": "2022.7.0" + }, + "distributed-2022.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=6.6", + "cloudpickle >=1.5.0", + "dask-core 2022.7.0.*", + "jinja2", + "locket >=1.0.0", + "msgpack-python >=0.6.0", + "packaging >=20.0", + "psutil >=5.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "setuptools", + "sortedcontainers !=2.0.0,!=2.0.1", + "tblib >=1.6.0", + "toolz >=0.8.2", + "tornado >=6.0.3,<6.2", + "urllib3", + "zict >=0.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "740cf81dfa6c748713a7f242c64f09f3", + "name": "distributed", + "sha256": "14e54e40ecc9d5ef2a533a68c6f6e518007ca7d3ddd029aa15d3735b11befe74", + "size": 1115651, + "subdir": "linux-64", + "timestamp": 1658520817278, + "version": "2022.7.0" + }, + "distributed-2023.3.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=8.0", + "cloudpickle >=1.5.0", + "dask-core 2023.3.2.*", + "jinja2 >=2.10.3", + "locket >=1.0.0", + "msgpack-python >=1.0.0", + "packaging >=20.0", + "psutil >=5.7.0", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.3.1", + "sortedcontainers >=2.0.5", + "tblib >=1.6.0", + "toolz >=0.10.0", + "tornado >=6.0.3", + "urllib3 >=1.24.3", + "zict >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "43dd4b759a810440cef61d69de57bd7e", + "name": "distributed", + "sha256": "f084e9f24072c7d89fdfc8f437a174a124d2dcbfc441f8316c2b190b40fbfa96", + "size": 1302299, + "subdir": "linux-64", + "timestamp": 1680104491233, + "version": "2023.3.2" + }, + "distributed-2023.3.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=8.0", + "cloudpickle >=1.5.0", + "dask-core 2023.3.2.*", + "jinja2 >=2.10.3", + "locket >=1.0.0", + "msgpack-python >=1.0.0", + "packaging >=20.0", + "psutil >=5.7.0", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.3.1", + "sortedcontainers >=2.0.5", + "tblib >=1.6.0", + "toolz >=0.10.0", + "tornado >=6.0.3", + "urllib3 >=1.24.3", + "zict >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "76f22399ef34c9d52215e2885c6d1d2c", + "name": "distributed", + "sha256": "c9f172fdabdb8ed91f36d5871b38c3504e27be31315726a376fa8fc3ca25e402", + "size": 1616275, + "subdir": "linux-64", + "timestamp": 1680104413719, + "version": "2023.3.2" + }, + "distributed-2023.3.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=8.0", + "cloudpickle >=1.5.0", + "dask-core 2023.3.2.*", + "jinja2 >=2.10.3", + "locket >=1.0.0", + "msgpack-python >=1.0.0", + "packaging >=20.0", + "psutil >=5.7.0", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.3.1", + "sortedcontainers >=2.0.5", + "tblib >=1.6.0", + "toolz >=0.10.0", + "tornado >=6.0.3", + "urllib3 >=1.24.3", + "zict >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6d578c8ab099f28ef8a4bb77e5910a35", + "name": "distributed", + "sha256": "07d7be299e8f6971d5e7766ec4d9a1fca4e78f8ecf619c8d828769ac8323ac5f", + "size": 1288743, + "subdir": "linux-64", + "timestamp": 1680104530237, + "version": "2023.3.2" + }, + "distributed-2023.3.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "openssl !=1.1.1e" + ], + "depends": [ + "click >=8.0", + "cloudpickle >=1.5.0", + "dask-core 2023.3.2.*", + "jinja2 >=2.10.3", + "locket >=1.0.0", + "msgpack-python >=1.0.0", + "packaging >=20.0", + "psutil >=5.7.0", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.3.1", + "sortedcontainers >=2.0.5", + "tblib >=1.6.0", + "toolz >=0.10.0", + "tornado >=6.0.3", + "urllib3 >=1.24.3", + "zict >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "68e9d97d7d6a54ebf1548800530a34d0", + "name": "distributed", + "sha256": "bf211bc7c7d5a063f1a69dbdf035297bccd4526a88033f6ddcb34b7699f65698", + "size": 1288506, + "subdir": "linux-64", + "timestamp": 1680104451788, + "version": "2023.3.2" + }, + "django-1.11.10-py27hd476221_0.conda": { + "build": "py27hd476221_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "4e29a45b01859c1a7ed4f5439c0e436f", + "name": "django", + "sha256": "10ee765b89895d28c63030d355841655b8be70dd033f19dcd9d02bfffaec9c3b", + "size": 3587676, + "subdir": "linux-64", + "timestamp": 1519060827525, + "version": "1.11.10" + }, + "django-1.11.10-py35hd476221_0.conda": { + "build": "py35hd476221_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "7f2facb5554a926889ce30656dffdfe0", + "name": "django", + "sha256": "71d7e3d902525a6f2ff8dcb4f66674586fb48a420c7b9c65c3aa9b4722f8272b", + "size": 3633680, + "subdir": "linux-64", + "timestamp": 1519060864484, + "version": "1.11.10" + }, + "django-1.11.10-py36hd476221_0.conda": { + "build": "py36hd476221_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "a54e933ce02b31ae250f05ec4535a5b2", + "name": "django", + "sha256": "7dda20d76efda82f5a9685a4e3d73cbdcf12731ac96bf87e35b89fc458e30202", + "size": 3621170, + "subdir": "linux-64", + "timestamp": 1519060880465, + "version": "1.11.10" + }, + "django-1.11.8-py27hd476221_0.conda": { + "build": "py27hd476221_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "3b3b7835d2a10f7ac95e87a3ec4ac61b", + "name": "django", + "sha256": "680bfac86096f1bddcaf2e3e8fdaadad687acd5da69ba7f830e18c25a431a412", + "size": 3602005, + "subdir": "linux-64", + "timestamp": 1512622372331, + "version": "1.11.8" + }, + "django-1.11.8-py35hd476221_0.conda": { + "build": "py35hd476221_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "13630df5a862ba3a26f52595436d8dd8", + "name": "django", + "sha256": "163a21e4f7f347277bd48a8d5a701a4edee38a4eb3421e161617863318c219f7", + "size": 3636820, + "subdir": "linux-64", + "timestamp": 1512622421913, + "version": "1.11.8" + }, + "django-1.11.8-py36hd476221_0.conda": { + "build": "py36hd476221_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "dd66df3a083691d7350522bcbff1bd1e", + "name": "django", + "sha256": "3d0e08b03a0b235e1cbe17bd55ec2a63b0321d55c366a1c5c91834619bdcf070", + "size": 3599005, + "subdir": "linux-64", + "timestamp": 1512622430154, + "version": "1.11.8" + }, + "django-2.0.2-py35hd476221_0.conda": { + "build": "py35hd476221_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "b14f1fd309a76fe2f26a6c56e948bedd", + "name": "django", + "sha256": "38185f06043d556c5fcd6459d1c547ab630d25b3cf79e032fb32180fef5f9b7b", + "size": 3682636, + "subdir": "linux-64", + "timestamp": 1519065539898, + "version": "2.0.2" + }, + "django-2.0.2-py36hd476221_0.conda": { + "build": "py36hd476221_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "d453a983ce917cf910909876dc79d967", + "name": "django", + "sha256": "b31ad4a8083a91d4400694b705c171614a045d310318b08aefae6fdf6b94dd4f", + "size": 3647608, + "subdir": "linux-64", + "timestamp": 1519065537135, + "version": "2.0.2" + }, + "django-2.0.5-py35hd476221_0.conda": { + "build": "py35hd476221_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "56b827b4a8ec7ac27ba9206c2ddec062", + "name": "django", + "sha256": "1b8ea3b768da92bb9b42c8923c3c9622209cf413e9a59bc0095b2b556a8ac941", + "size": 3672173, + "subdir": "linux-64", + "timestamp": 1526134119445, + "version": "2.0.5" + }, + "django-2.0.5-py36hd476221_0.conda": { + "build": "py36hd476221_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "1830d2df61f8c0e1e41460c356a4073d", + "name": "django", + "sha256": "7ec5026d3cf022b02ff7a85ef60ca0ee7151e163ecc5ddf71840363bbfd4dcdb", + "size": 3668605, + "subdir": "linux-64", + "timestamp": 1526134042776, + "version": "2.0.5" + }, + "django-2.0.5-py37hd476221_0.conda": { + "build": "py37hd476221_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "155b9aca7191442bc2433ae3e45815d1", + "name": "django", + "sha256": "d51e2aef41e5af0c7ea6fadb741cc27cb9081fc5e8400092f458ac8bc51e0124", + "size": 3655978, + "subdir": "linux-64", + "timestamp": 1530873331375, + "version": "2.0.5" + }, + "django-2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "d09f55b88f74510573f9d0fae3818819", + "name": "django", + "sha256": "160e7be8e08608efdd79e66864a8ce80551541dc288971e8d805e90a82a504f3", + "size": 3790723, + "subdir": "linux-64", + "timestamp": 1534392770985, + "version": "2.1" + }, + "django-2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "af52356f54b7a00a6a3d3d614598075e", + "name": "django", + "sha256": "29e62ee21e7449ccd104d4d44562102b0740f76776d0f9433a9ac0c3c47031a1", + "size": 3787073, + "subdir": "linux-64", + "timestamp": 1534392493185, + "version": "2.1" + }, + "django-2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "66435d69da1f58035870a93e948e2888", + "name": "django", + "sha256": "bd9ae5c064b5172d83e5b89cbb78ff38b05ed887c3d74b74b6cda08e233e538a", + "size": 3787707, + "subdir": "linux-64", + "timestamp": 1534392512940, + "version": "2.1" + }, + "django-2.1.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "e445d21831de44542f25d5e57e5d377c", + "name": "django", + "sha256": "7da04210264396023c3ace77f999006658ea6ee3ca7e3fca548245aa9d532a4b", + "size": 3789808, + "subdir": "linux-64", + "timestamp": 1536528853747, + "version": "2.1.1" + }, + "django-2.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "eb9282ad7810a22faa9958f9ed250e7b", + "name": "django", + "sha256": "8cf95a5d9e99ba2b2650edc4d1a106419f3eabf028a22d135da1bb07b33eb11e", + "size": 3774092, + "subdir": "linux-64", + "timestamp": 1536528896296, + "version": "2.1.1" + }, + "django-2.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "c0d50ce6d1306b171ad88299dfd4dcad", + "name": "django", + "sha256": "aeab424362da2d68f4076b09b3af6a17f711da4488242509241802fe09c4b525", + "size": 3789466, + "subdir": "linux-64", + "timestamp": 1536528805364, + "version": "2.1.1" + }, + "django-2.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "0918e9169a4b6d5132b55d04aa3bfaea", + "name": "django", + "sha256": "7fb1057dd05531d3dab61e1a26fe94b72a710a93b371b8a07bfbb9e74a0b0871", + "size": 3791328, + "subdir": "linux-64", + "timestamp": 1539474674331, + "version": "2.1.2" + }, + "django-2.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "c48f848bcbb517ead3d79b05b8d15ac9", + "name": "django", + "sha256": "01e95cf8b34f5cc980e0956d88709c54859223321ef499ae5a9f856ca4ca7dc8", + "size": 3794714, + "subdir": "linux-64", + "timestamp": 1539474702840, + "version": "2.1.2" + }, + "django-2.1.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "36bbc8ea4633c780af86590446d4873d", + "name": "django", + "sha256": "d947e269cb1a299d0d5797533c4904c3d3f0096e84df9024205141647f30d4f0", + "size": 3778629, + "subdir": "linux-64", + "timestamp": 1545092380357, + "version": "2.1.4" + }, + "django-2.1.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "31a62f32a8b7f7827e7e05d1c37e666d", + "name": "django", + "sha256": "ad4e5188569d84b7caee342e32d87b2065fb320567f1c5fdc9f4155e958dc399", + "size": 3801508, + "subdir": "linux-64", + "timestamp": 1545092402480, + "version": "2.1.4" + }, + "django-2.1.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "9c9c18825e34deada7bb31cd4bacb435", + "name": "django", + "sha256": "4dbdaff9cbdc3548a47fdd10ed093a9e8898ed66d585636cfad5952e8d4c79d2", + "size": 3801058, + "subdir": "linux-64", + "timestamp": 1547227052732, + "version": "2.1.5" + }, + "django-2.1.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "995eb663fa0640f897ce1ae3e135c751", + "name": "django", + "sha256": "482e596524e84c18a6a07b7a09273b55694a880074274503bfbc67b9039c61da", + "size": 3783976, + "subdir": "linux-64", + "timestamp": 1547227053379, + "version": "2.1.5" + }, + "django-2.1.7-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "ee13479dc97d9b1e8483b7be5f6ab4d1", + "name": "django", + "sha256": "374ed9ee17e6e552942945b813191ffed1ac704b5fa310e1e0311ac2358d854b", + "size": 3814854, + "subdir": "linux-64", + "timestamp": 1643016715330, + "version": "2.1.7" + }, + "django-2.1.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "9717f5ad170b5f3b9818c05aaa4cb5f8", + "name": "django", + "sha256": "1acaaf30b024d497b92c03c02831c6e168de7749bf33b13413fda417ee4b4565", + "size": 3795768, + "subdir": "linux-64", + "timestamp": 1550269207413, + "version": "2.1.7" + }, + "django-2.1.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "a4474e44d6ebd95fd712cf455dc41e8d", + "name": "django", + "sha256": "8b8c8d8ac36072a2203b5b2fb300ec36030649b1b3683336c57e6299acf561d7", + "size": 3799519, + "subdir": "linux-64", + "timestamp": 1550269208239, + "version": "2.1.7" + }, + "django-2.1.7-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "b5c25fd619bfe41a2a7a8c623946f310", + "name": "django", + "sha256": "f4bc2b9f12160490a517484357989e0e6544c3cb77c981d13120f32d6bfc0e17", + "size": 3774707, + "subdir": "linux-64", + "timestamp": 1636038994499, + "version": "2.1.7" + }, + "django-2.1.7-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "69ef4fc5f05fd4613c1552fbf7ec8db7", + "name": "django", + "sha256": "171a5e85b0490228ba5aa949115ba89539cd67611010806cb60657fa03510957", + "size": 3804748, + "subdir": "linux-64", + "timestamp": 1636039111532, + "version": "2.1.7" + }, + "django-2.1.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "0145d88862bc6f9109f4b97ee2753a4e", + "name": "django", + "sha256": "1873056707055cd3cacb4dd4dc1d4b785840c66a9a4ea9b2b5812476415e735e", + "size": 3799110, + "subdir": "linux-64", + "timestamp": 1636039111694, + "version": "2.1.7" + }, + "django-2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "8101674b587b71d336e9a3e53ac20c67", + "name": "django", + "sha256": "c04a2e43543f7bafdf6cf35e74cd28a9f6ff61cd685aa7d4c77729c0e171814c", + "size": 4005776, + "subdir": "linux-64", + "timestamp": 1556065071716, + "version": "2.2" + }, + "django-2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "f39b4be5c74944d0c1e83fe3881f8844", + "name": "django", + "sha256": "1e94c7ceac7e60d97441d93c9141d082dd5132e51a111aec46117504c6a526a1", + "size": 4020087, + "subdir": "linux-64", + "timestamp": 1556064909334, + "version": "2.2" + }, + "django-2.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "a466d3e323641551c0a0e745bff217ec", + "name": "django", + "sha256": "b78b008557639c6f1bef773506bdc29ded46fa5886f65aa0e81a177fabf1ef4d", + "size": 4030017, + "subdir": "linux-64", + "timestamp": 1559141050239, + "version": "2.2.1" + }, + "django-2.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "1bf3ba5712213cbd74c824b7ceded0e1", + "name": "django", + "sha256": "1a914ccba77c3b11737fc532504cd418b0a25ae9cc8fde27383651f511c6ddd1", + "size": 4036151, + "subdir": "linux-64", + "timestamp": 1559140863009, + "version": "2.2.1" + }, + "django-2.2.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "e24f1c18ab3156a349bf018195ad1ffe", + "name": "django", + "sha256": "8b4b6f49e7ca3d048e6c8d0f97230f31552296d0499b404366c91b8f186d6f61", + "size": 4034213, + "subdir": "linux-64", + "timestamp": 1569343485048, + "version": "2.2.5" + }, + "django-2.2.5-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "sqlparse" + ], + "license": "BSD 3-Clause", + "md5": "4a435acee0e4cf22aa8b84c36755c19f", + "name": "django", + "sha256": "2f5d686f4bb007808c7bd1c5c323e86e1f63f07fe0a5a80c8878022026b8bdce", + "size": 4034306, + "subdir": "linux-64", + "timestamp": 1569445764636, + "version": "2.2.5" + }, + "django-2.2.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "BSD 3-Clause", + "md5": "83296ab918f4fe983a91caa88ccf7ea5", + "name": "django", + "sha256": "9d8b25346e87cb462100565b42a4f6ed0eda322fb0766dcbd574dd4a31bdf4f9", + "size": 4034996, + "subdir": "linux-64", + "timestamp": 1569343469508, + "version": "2.2.5" + }, + "django-2.2.5-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz", + "sqlparse" + ], + "license": "BSD 3-Clause", + "md5": "7b9bd4bd27d9c5581fe2b2c3a8d94e0f", + "name": "django", + "sha256": "0a7593a87360cbd39803e2966a4bf551078ef7095232ed87cd9b40bcff8cff20", + "size": 4035911, + "subdir": "linux-64", + "timestamp": 1569445790216, + "version": "2.2.5" + }, + "django-2.2.5-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz", + "sqlparse" + ], + "license": "BSD 3-Clause", + "md5": "f117693503e8344a151c94914c53f332", + "name": "django", + "sha256": "f3c04439f7d0ac6e4fb704cf6d348c32d3a6dcba50a663deca9f12f9cd7b377e", + "size": 4041399, + "subdir": "linux-64", + "timestamp": 1573741654987, + "version": "2.2.5" + }, + "django-3.2.15-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.3.2,<4", + "psycopg2", + "python >=3.10,<3.11.0a0", + "pytz", + "sqlparse >=0.2.2" + ], + "license": "BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "5e6a8216103a679cd22e487c55b1427b", + "name": "django", + "sha256": "c0e2eac853cc1d055189b001e7b31f7de88a94f56e7ab5fa23683963fc018b47", + "size": 4275473, + "subdir": "linux-64", + "timestamp": 1661284412514, + "version": "3.2.15" + }, + "django-3.2.15-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.3.2,<4", + "psycopg2", + "python >=3.7,<3.8.0a0", + "pytz", + "sqlparse >=0.2.2" + ], + "license": "BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "24c9609ee9127bb8ef52cdc6be1943a0", + "name": "django", + "sha256": "63e5471f0c321577bae07a77b18e96b72de8ae0b55fe82888edf5fac7a570ca0", + "size": 4239541, + "subdir": "linux-64", + "timestamp": 1661284339889, + "version": "3.2.15" + }, + "django-3.2.15-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.3.2,<4", + "psycopg2", + "python >=3.8,<3.9.0a0", + "pytz", + "sqlparse >=0.2.2" + ], + "license": "BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "aa37f156cdf3aead660306bd3266df7b", + "name": "django", + "sha256": "2b80a6ce07b989624c64028d8068b700668fc1d4baec66140806abf3a7e77cfc", + "size": 4251621, + "subdir": "linux-64", + "timestamp": 1661284282561, + "version": "3.2.15" + }, + "django-3.2.15-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.3.2,<4", + "psycopg2", + "python >=3.9,<3.10.0a0", + "pytz", + "sqlparse >=0.2.2" + ], + "license": "BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "337ea61efe2ce8a9088a568f3734a227", + "name": "django", + "sha256": "4f0752ef7b911d7449536e4c73aeb0cfdc293af1fa12fbc943dca9416efdf343", + "size": 4255022, + "subdir": "linux-64", + "timestamp": 1661284473426, + "version": "3.2.15" + }, + "django-4.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.5.2,<4", + "python >=3.10,<3.11.0a0", + "sqlparse >=0.2.2" + ], + "license": "BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "738222720154d86823b5cca8e9d37735", + "name": "django", + "sha256": "0dc0a0455411e9fbfa4f33136f1db33ccf8bd22ab019449c8dc5488a4860e8d2", + "size": 4435943, + "subdir": "linux-64", + "timestamp": 1661296507042, + "version": "4.1" + }, + "django-4.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.5.2,<4", + "python >=3.11,<3.12.0a0", + "sqlparse >=0.2.2" + ], + "license": "BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "2a286757cd634d41f4b42005193a7700", + "name": "django", + "sha256": "408c78a4272abd2c442cad6b774bc193220c5ab7e476e924a42e76be7642ad6e", + "size": 5479965, + "subdir": "linux-64", + "timestamp": 1676851960213, + "version": "4.1" + }, + "django-4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.5.2,<4", + "backports.zoneinfo", + "python >=3.8,<3.9.0a0", + "sqlparse >=0.2.2" + ], + "license": "BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "b2c9ece3d762eff6522d5ca4d6f7f2f8", + "name": "django", + "sha256": "149cf46d8641541292e2faa82bf0aab2fa2b73bcc4450f79848227db4933c715", + "size": 4412010, + "subdir": "linux-64", + "timestamp": 1661296433754, + "version": "4.1" + }, + "django-4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.5.2,<4", + "python >=3.9,<3.10.0a0", + "sqlparse >=0.2.2" + ], + "license": "BSD-3-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "1e62b225890ce70caefdd87c29e568f9", + "name": "django", + "sha256": "e058bbcbcb832f74293fa5db76f01d0d73a331bb23ad9016778e342f105ff5c6", + "size": 4419924, + "subdir": "linux-64", + "timestamp": 1661296566572, + "version": "4.1" + }, + "dlpack-0.3-he6710b0_1.conda": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63be4032a3150fbf540b3fdfb2195cf2", + "name": "dlpack", + "sha256": "7c017734360bfcd2c0a65f9c3446f3372c7b9b51ec4f7a8d7dfe18cbadd0c29f", + "size": 1237244, + "subdir": "linux-64", + "timestamp": 1600691800051, + "version": "0.3" + }, + "dm-tree-0.1.5-py310h00e6091_2.conda": { + "build": "py310h00e6091_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "six >=1.12.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "df5f9ef78f63e1807a4158bc4c7bc5df", + "name": "dm-tree", + "sha256": "94cbfc3edab532f5032dc896cf10dba82535cfdf73504b6e5146695188fdbde4", + "size": 104124, + "subdir": "linux-64", + "timestamp": 1640789606166, + "version": "0.1.5" + }, + "dm-tree-0.1.5-py36h51133e4_0.conda": { + "build": "py36h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "six >=1.12.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "96ae620b467350a65fb23b9c86008da0", + "name": "dm-tree", + "sha256": "37af1180aae5a6c2c97955af12c335c7fb10bd9e8ed9c9e001ce4a0685a8a9ba", + "size": 105479, + "subdir": "linux-64", + "timestamp": 1633012179579, + "version": "0.1.5" + }, + "dm-tree-0.1.5-py37h51133e4_0.conda": { + "build": "py37h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "six >=1.12.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "080cf03d17bb91277a514a5512c82e53", + "name": "dm-tree", + "sha256": "e966e352356351513044dfe9c7fbec1811a51f6cc94211e9d034c2ada8f25acc", + "size": 105210, + "subdir": "linux-64", + "timestamp": 1633001684175, + "version": "0.1.5" + }, + "dm-tree-0.1.5-py38h51133e4_0.conda": { + "build": "py38h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "six >=1.12.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3133ded5b24c136ece4c4086b639ce8c", + "name": "dm-tree", + "sha256": "559300161267f81e57fec3619730a953f1664647bb6695521be4f45b6341cf0f", + "size": 105533, + "subdir": "linux-64", + "timestamp": 1633012155009, + "version": "0.1.5" + }, + "dm-tree-0.1.5-py39h51133e4_0.conda": { + "build": "py39h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "six >=1.12.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "193e5ecac75b3fb850b22ee1629838ae", + "name": "dm-tree", + "sha256": "04a8b20c3d2ccb6ff8179e8dbc2eea69655154816554327613f830838dd2a024", + "size": 105117, + "subdir": "linux-64", + "timestamp": 1633012155467, + "version": "0.1.5" + }, + "dm-tree-0.1.7-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "033a0da01cbbf48638ddb64154e362f6", + "name": "dm-tree", + "sha256": "7bbd3e06df3dc8aea4cb3cc42574c609cbd2eb039e14544929737047e160ba94", + "size": 155375, + "subdir": "linux-64", + "timestamp": 1669819840455, + "version": "0.1.7" + }, + "dm-tree-0.1.7-py310h6a678d5_1.conda": { + "build": "py310h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "84393c6d3c1546a66c339d59113a4598", + "name": "dm-tree", + "sha256": "bafa5057712b440fa19c3d3ff90b2b359903c596625a5771ca3b0b55e360c508", + "size": 161245, + "subdir": "linux-64", + "timestamp": 1671027591718, + "version": "0.1.7" + }, + "dm-tree-0.1.7-py311h6a678d5_1.conda": { + "build": "py311h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b59b32abc83690496e98105a63341fab", + "name": "dm-tree", + "sha256": "f5fa710ac16e75059d15fc9eb8c9dffb4233377d7ee499cc926a1002a9530821", + "size": 160272, + "subdir": "linux-64", + "timestamp": 1676839767491, + "version": "0.1.7" + }, + "dm-tree-0.1.7-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2e7133528457d521a37163e9f2f496be", + "name": "dm-tree", + "sha256": "1aab8e9896fa9041fbc66b5dcb00f7f910458c355e6ab1ed2ba8dbb7c90c7046", + "size": 154358, + "subdir": "linux-64", + "timestamp": 1669819762699, + "version": "0.1.7" + }, + "dm-tree-0.1.7-py37h6a678d5_1.conda": { + "build": "py37h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d413d92fd3ce2a5141e11cc3190bb24e", + "name": "dm-tree", + "sha256": "ffb85b2e46d44270d10e479896f6e609b26ca013886642aaa644c3fd5ece5d13", + "size": 162011, + "subdir": "linux-64", + "timestamp": 1671027515947, + "version": "0.1.7" + }, + "dm-tree-0.1.7-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c2a58fcd5e47758ba866169c0e4ffade", + "name": "dm-tree", + "sha256": "88e15da31dc6125b2e14f5a62c2bdabe267a605f924003fc167403986241b087", + "size": 155071, + "subdir": "linux-64", + "timestamp": 1669819986023, + "version": "0.1.7" + }, + "dm-tree-0.1.7-py38h6a678d5_1.conda": { + "build": "py38h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8baf7e6510f88eb9fc526729e0301fc0", + "name": "dm-tree", + "sha256": "a89cd899dc2eca6b276738ecbc4f28901d4d43e0a6cded1fce496b646e765ad5", + "size": 160816, + "subdir": "linux-64", + "timestamp": 1671027665000, + "version": "0.1.7" + }, + "dm-tree-0.1.7-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4ad6e5ce661f6585f557e1508d49d2cb", + "name": "dm-tree", + "sha256": "5d0099eeb26afddc8c97213b6e3b7670652b8ef185f217f79b7f52f165ea4e8c", + "size": 154378, + "subdir": "linux-64", + "timestamp": 1669819913001, + "version": "0.1.7" + }, + "dm-tree-0.1.7-py39h6a678d5_1.conda": { + "build": "py39h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4349ce35724bae72e637dca42478fbab", + "name": "dm-tree", + "sha256": "32920e7596a810a22225bf51ba789370d79ce0996af020c70e3952712a0da25b", + "size": 161226, + "subdir": "linux-64", + "timestamp": 1671027736286, + "version": "0.1.7" + }, + "dnspython-1.15.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "b10f184e08e7136b399ecdcfb2f9d8df", + "name": "dnspython", + "sha256": "27d340d7a4713e6cea8f88966631bdc4d9aaffb5f32a5eb522f10bffc4ec0683", + "size": 175378, + "subdir": "linux-64", + "timestamp": 1530873383534, + "version": "1.15.0" + }, + "dnspython-1.15.0-py27h8b108a9_0.conda": { + "build": "py27h8b108a9_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "9c5d71e00869fa5b3827cf99ef9f667d", + "name": "dnspython", + "sha256": "474c4ef73c0d025afba8e5177ecb8e8ea6731393ba39eb54ac56c0c65213731f", + "size": 175487, + "subdir": "linux-64", + "timestamp": 1507930516067, + "version": "1.15.0" + }, + "dnspython-1.15.0-py35h312e5ef_0.conda": { + "build": "py35h312e5ef_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "7874859593f9ccc273bbe25c0177a706", + "name": "dnspython", + "sha256": "780a8178040cf6cbecbeb7e22960b62fbac75e9c7906f843c151794a7dfa60c8", + "size": 179723, + "subdir": "linux-64", + "timestamp": 1507930526818, + "version": "1.15.0" + }, + "dnspython-1.15.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "1c09484a7b1710f0cfec2dac8686cbcc", + "name": "dnspython", + "sha256": "9648d7a2090e70d6ec5571a6a797b807d30d64daa6bb20ac435d77bf9872d786", + "size": 175340, + "subdir": "linux-64", + "timestamp": 1530873446943, + "version": "1.15.0" + }, + "dnspython-1.15.0-py36h3d718be_0.conda": { + "build": "py36h3d718be_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "a8840e7a4f063faee8eca84fe24408e5", + "name": "dnspython", + "sha256": "522b58c610d80a591d471d3bf87abae0d24408bc435b3046968f9dfebc44164d", + "size": 177660, + "subdir": "linux-64", + "timestamp": 1507930522450, + "version": "1.15.0" + }, + "dnspython-1.15.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "b66d21fafd0972fac5825e8296f24be6", + "name": "dnspython", + "sha256": "d145192c54c6f21528053174de5a257af3c181e1dcb60382a81b6b4757dd7ca7", + "size": 177906, + "subdir": "linux-64", + "timestamp": 1530873414487, + "version": "1.15.0" + }, + "dnspython-1.16.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "452f861381fb012103e8cb5e74302486", + "name": "dnspython", + "sha256": "73c23b4250b38a04fdacd605e68412b2ca5784501fa20366e3dd784ec1f12c91", + "size": 185301, + "subdir": "linux-64", + "timestamp": 1545108849100, + "version": "1.16.0" + }, + "dnspython-1.16.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "e068a9e8ef575974744df69357faf9c7", + "name": "dnspython", + "sha256": "b6ff72b7f0d21ef6c6fc11f12b50052306b289af08082e48a85a656b25fb8e5d", + "size": 185295, + "subdir": "linux-64", + "timestamp": 1640789625020, + "version": "1.16.0" + }, + "dnspython-1.16.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "507dd7e37a016dd4c3adb42ccd10e099", + "name": "dnspython", + "sha256": "9fe4c1b1d422415055b4e55506f5b1ff4e7e7f13564cc4555ad93541ebb9b5a3", + "size": 183184, + "subdir": "linux-64", + "timestamp": 1545108880429, + "version": "1.16.0" + }, + "dnspython-1.16.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "f586442a6c5be1d91cd00ff6dfdbf355", + "name": "dnspython", + "sha256": "a04e796136ba706533c9f3e2f56802855c6add9b092c671fdbf94682d2a17d70", + "size": 183328, + "subdir": "linux-64", + "timestamp": 1545108882971, + "version": "1.16.0" + }, + "dnspython-1.16.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-like", + "license_family": "BSD", + "md5": "763191ac746cfe332f1330fccbcb652b", + "name": "dnspython", + "sha256": "9810f439156469ee9e0504fb574020fcc3d6bc1c2a639e7c3c523527946d49e3", + "size": 186403, + "subdir": "linux-64", + "timestamp": 1572357222416, + "version": "1.16.0" + }, + "dnspython-2.2.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6", + "idna >=2.1", + "python >=3.10,<3.11.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "17d1ae9d7ea4a8ff23c45dad86be665b", + "name": "dnspython", + "sha256": "eace4ce8cbbb61aad913aa1e0cb94f75abb3d44435b458de024b76c4f403752d", + "size": 289877, + "subdir": "linux-64", + "timestamp": 1659712703431, + "version": "2.2.1" + }, + "dnspython-2.2.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6", + "idna >=2.1", + "python >=3.11,<3.12.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "22b181427f8403c240c4389c5c75a093", + "name": "dnspython", + "sha256": "104e91853bac4d112560febf5dfc64a3dc6e5a5df351fd31306b5ce0363b4c8c", + "size": 384327, + "subdir": "linux-64", + "timestamp": 1676903920576, + "version": "2.2.1" + }, + "dnspython-2.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6", + "idna >=2.1", + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "e05f03b7c110b66fcb3299c059dae09d", + "name": "dnspython", + "sha256": "4e8c972f43844ad671c716c68055d542fc0e2db814e0843a956849c61c75be75", + "size": 285211, + "subdir": "linux-64", + "timestamp": 1659712760311, + "version": "2.2.1" + }, + "dnspython-2.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6", + "idna >=2.1", + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "78a99553cce9192c71ec37fe7912aacc", + "name": "dnspython", + "sha256": "7983f084745cf6dc01fb4437711b703c286092341e11f4a119e9b61e3d7cdacd", + "size": 287356, + "subdir": "linux-64", + "timestamp": 1659712665340, + "version": "2.2.1" + }, + "dnspython-2.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6", + "idna >=2.1", + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "b51bdb4da2bd23d6688c94bec2070404", + "name": "dnspython", + "sha256": "4f319714c768b2b05477702ab6017945ef2dc36688fd2980499158e652abd1f9", + "size": 287692, + "subdir": "linux-64", + "timestamp": 1659712731261, + "version": "2.2.1" + }, + "docker-py-3.5.1-py27_1001.conda": { + "build": "py27_1001", + "build_number": 1001, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "enum34 >=1.1.6", + "idna >=2.5", + "ipaddress >=1.0.18", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "ssl_match_hostname >=3.5", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "f5c69773a673e236688d5c3c36cf9cd3", + "name": "docker-py", + "sha256": "4f4d1ea38598fb08168714dd7547e2c9f8f11ab39f4cb394a59dbf3224e68d85", + "size": 165713, + "subdir": "linux-64", + "timestamp": 1545410038433, + "version": "3.5.1" + }, + "docker-py-3.5.1-py36_1001.conda": { + "build": "py36_1001", + "build_number": 1001, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "7105c595bddaf709319eabf1ca9c405a", + "name": "docker-py", + "sha256": "8d09d797c0f918e656954b40968cc68f2e0633765fe3e5249837a9f0df06daa5", + "size": 164080, + "subdir": "linux-64", + "timestamp": 1545410089858, + "version": "3.5.1" + }, + "docker-py-3.5.1-py37_1001.conda": { + "build": "py37_1001", + "build_number": 1001, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "1d3e44c17d121659be530a9f7a7b9ef8", + "name": "docker-py", + "sha256": "705a1b90037a6325dae08a146e22431cf2bb89f65dbf6216e26ec74969bb8a3d", + "size": 164507, + "subdir": "linux-64", + "timestamp": 1545410492704, + "version": "3.5.1" + }, + "docker-py-4.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "enum34 >=1.1.6", + "idna >=2.5", + "ipaddress >=1.0.18", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "ssl_match_hostname >=3.5", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "10a356b04951f7071b17266831a0a2e8", + "name": "docker-py", + "sha256": "4cc81ba362eae0bc1798f49268687dabe0c1a0e2920d4435be4e41b6402b715b", + "size": 180289, + "subdir": "linux-64", + "timestamp": 1558586739340, + "version": "4.0.1" + }, + "docker-py-4.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "c43d81191c0ef7a3287214905398089c", + "name": "docker-py", + "sha256": "4ce4680fa416c26c9b2a81c33c7a0f95fb0f5bba51b3461a4a91c58691a6a1ab", + "size": 181486, + "subdir": "linux-64", + "timestamp": 1558586766913, + "version": "4.0.1" + }, + "docker-py-4.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "1dd21b03801926a1757d9f445d0684d1", + "name": "docker-py", + "sha256": "799b466a85275b8502eee51001028e2fae7024a310a983c99ce37e04e3c251ba", + "size": 181749, + "subdir": "linux-64", + "timestamp": 1558586716513, + "version": "4.0.1" + }, + "docker-py-4.0.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "592be74e671dc5a36e9bc202c13feb31", + "name": "docker-py", + "sha256": "b4393a25b3b7b2c38bea2f7060559faa847524c816f913a62ef015ac3adc89f2", + "size": 175141, + "subdir": "linux-64", + "timestamp": 1574238527586, + "version": "4.0.1" + }, + "docker-py-4.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "enum34 >=1.1.6", + "idna >=2.5", + "ipaddress >=1.0.18", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "ssl_match_hostname >=3.5", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "8d753a556aeafda89398895993a30694", + "name": "docker-py", + "sha256": "152d9acc9f8588e9a776cdf8cd6762bac34192268c3825c4bc6c38e279bd143e", + "size": 176414, + "subdir": "linux-64", + "timestamp": 1564162208438, + "version": "4.0.2" + }, + "docker-py-4.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "91def3a3b7482f72a26fa9c76cc172c7", + "name": "docker-py", + "sha256": "e55126bcf8b30bd871673aabba4753aceae2bb5b648a202c5add62b5063b1005", + "size": 174931, + "subdir": "linux-64", + "timestamp": 1564162214690, + "version": "4.0.2" + }, + "docker-py-4.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache 2.0", + "md5": "e185b510c5c1b1c0cd1d23540d13246e", + "name": "docker-py", + "sha256": "2a33c9e73ac6f97819029fbe4b8a1a58340ee6fcbe26a75110b6683177c960aa", + "size": 177720, + "subdir": "linux-64", + "timestamp": 1564162205989, + "version": "4.0.2" + }, + "docker-py-4.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "edbd09cba642f79914b1ad223e3c43db", + "name": "docker-py", + "sha256": "4dbc1b4bf3c23555932f456e061fb0f559d2548c4767fa9a75f0c19578e02e4d", + "size": 186911, + "subdir": "linux-64", + "timestamp": 1585132641633, + "version": "4.2.0" + }, + "docker-py-4.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "63c1ef0f10eaffe95b6372a31bc08e6d", + "name": "docker-py", + "sha256": "dd789682e997c73201da0f569a41211033fc15c9a2b1f4f7335a9531e12443ac", + "size": 187122, + "subdir": "linux-64", + "timestamp": 1585132634165, + "version": "4.2.0" + }, + "docker-py-4.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "b407abd2fd88376107f4d171090f34d9", + "name": "docker-py", + "sha256": "bd6474b8ea97fd2499c1c6d0215b883b4e9e6c60d9694335d3cd34da9737d06a", + "size": 188272, + "subdir": "linux-64", + "timestamp": 1585132635864, + "version": "4.2.0" + }, + "docker-py-4.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "81ba67bb9ccac0a4aa4eb89608b40aaa", + "name": "docker-py", + "sha256": "ca8ab20a8d73c220b6cb12fdb3bbd62c21d77451a74f6d328d5a89fe3521c6fc", + "size": 184226, + "subdir": "linux-64", + "timestamp": 1591789200110, + "version": "4.2.1" + }, + "docker-py-4.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "dce290c5c299a5697eb34c3611332dd2", + "name": "docker-py", + "sha256": "0a196d22a3279bcbcf4a68ab7c75ae67c8dfbbd1220b710ffc2c538c95aa7534", + "size": 184467, + "subdir": "linux-64", + "timestamp": 1591789195055, + "version": "4.2.1" + }, + "docker-py-4.2.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "b8f272018ee5881971575b1a1d681961", + "name": "docker-py", + "sha256": "fe46c68bdefed9866da493cae6829f949ee8e55b6f3656a9d22a4510665c3b4e", + "size": 185486, + "subdir": "linux-64", + "timestamp": 1591795855621, + "version": "4.2.1" + }, + "docker-py-4.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "176bd34c93de565a0eaadcebe61c59f9", + "name": "docker-py", + "sha256": "7d4a9b7bbf4c154f365992daf172c6e8f697d5a131ea2596f20af0ec6426caf2", + "size": 182540, + "subdir": "linux-64", + "timestamp": 1594350560469, + "version": "4.2.2" + }, + "docker-py-4.3.1-py36_4.conda": { + "build": "py36_4", + "build_number": 4, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "175ebbf98a628201ee420099df48070e", + "name": "docker-py", + "sha256": "5e6466271fbc036ea76c3951211e995c91d77771b6031f441c6adee046e4507e", + "size": 190295, + "subdir": "linux-64", + "timestamp": 1599337685614, + "version": "4.3.1" + }, + "docker-py-4.3.1-py37_4.conda": { + "build": "py37_4", + "build_number": 4, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "fcd336375ce2274ff9f52ed6d04e7f4a", + "name": "docker-py", + "sha256": "46cc3ce1a9bdb8f38786154939f5b16a007f758f57c1c5e71100dd656873bfe9", + "size": 190825, + "subdir": "linux-64", + "timestamp": 1599337700897, + "version": "4.3.1" + }, + "docker-py-4.3.1-py38_4.conda": { + "build": "py38_4", + "build_number": 4, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "7c1d351b3bf604e1d330dc933724fc7c", + "name": "docker-py", + "sha256": "833122788efd53582fde702399986b8768e5c0bebe5289b9b5feeaf0b3aa5c79", + "size": 188820, + "subdir": "linux-64", + "timestamp": 1599337688523, + "version": "4.3.1" + }, + "docker-py-4.4.0-py36h06a4308_4.conda": { + "build": "py36h06a4308_4", + "build_number": 4, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "bc7f6c06d45999a27d1c5a42de189832", + "name": "docker-py", + "sha256": "b729bc63cbfc6f66bc8c351aa3f2411042cb00849ec9817157196985f587efdc", + "size": 184158, + "subdir": "linux-64", + "timestamp": 1606144620655, + "version": "4.4.0" + }, + "docker-py-4.4.0-py37h06a4308_4.conda": { + "build": "py37h06a4308_4", + "build_number": 4, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "c48561ed4ded1efe0d95050235db9c3e", + "name": "docker-py", + "sha256": "e21194fef2047093c9358348f3a02d39874d4009a87628043a4da20552143116", + "size": 186962, + "subdir": "linux-64", + "timestamp": 1606144634157, + "version": "4.4.0" + }, + "docker-py-4.4.0-py38h06a4308_4.conda": { + "build": "py38h06a4308_4", + "build_number": 4, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "71cd8bc4201f0071ad9129a5cd30ac3b", + "name": "docker-py", + "sha256": "b1fdb5dca62b6eb0df44a3626d6c2cce4bbdb01beee827ad6493e6a3ad8551f9", + "size": 187631, + "subdir": "linux-64", + "timestamp": 1606144637723, + "version": "4.4.0" + }, + "docker-py-4.4.1-py310h06a4308_5.conda": { + "build": "py310h06a4308_5", + "build_number": 5, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.10,<3.11.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "236b483c4f67be2967a685593f12f9b9", + "name": "docker-py", + "sha256": "20f44183b904356bea4c5a26138926ad9f6e01c517a5dacfb4567b0a99ebbe87", + "size": 189189, + "subdir": "linux-64", + "timestamp": 1640811935219, + "version": "4.4.1" + }, + "docker-py-4.4.1-py311h06a4308_5.conda": { + "build": "py311h06a4308_5", + "build_number": 5, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.11,<3.12.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "3464669f5f555dc60420bb28266149df", + "name": "docker-py", + "sha256": "5f73e993e5879e136dc09105e16707a4e7ca116fc0fb27a1a5c33777d0f9eb7f", + "size": 242026, + "subdir": "linux-64", + "timestamp": 1676844006193, + "version": "4.4.1" + }, + "docker-py-4.4.1-py36h06a4308_4.conda": { + "build": "py36h06a4308_4", + "build_number": 4, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "b0309eb006909e8c504ef6245ff31f74", + "name": "docker-py", + "sha256": "fcc1d6fe2916cb7d78c110c934eeb12c45a2a699c4cef1f7248bd7afab600be4", + "size": 186769, + "subdir": "linux-64", + "timestamp": 1608758669823, + "version": "4.4.1" + }, + "docker-py-4.4.1-py36h06a4308_5.conda": { + "build": "py36h06a4308_5", + "build_number": 5, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "537293d05006fee49397a06a3eaace8f", + "name": "docker-py", + "sha256": "cacf790bb4fe95fc6edbd69fe7e901a1616a5b284e784ec761f820e9feb28eb0", + "size": 193814, + "subdir": "linux-64", + "timestamp": 1610480127783, + "version": "4.4.1" + }, + "docker-py-4.4.1-py37h06a4308_4.conda": { + "build": "py37h06a4308_4", + "build_number": 4, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "2a05e4fda446700a1ceeba62cd391621", + "name": "docker-py", + "sha256": "befe3b54259196544153a4c43b36dbd08c353881f57148b368f05159bdb2fda5", + "size": 184387, + "subdir": "linux-64", + "timestamp": 1608758671791, + "version": "4.4.1" + }, + "docker-py-4.4.1-py37h06a4308_5.conda": { + "build": "py37h06a4308_5", + "build_number": 5, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "ca8890a842989800daf60ef17efd3520", + "name": "docker-py", + "sha256": "634f70d1eb235b38e08f280bb73cb02b0b1ca1843ca80f744853625739286217", + "size": 191426, + "subdir": "linux-64", + "timestamp": 1610480127473, + "version": "4.4.1" + }, + "docker-py-4.4.1-py38h06a4308_4.conda": { + "build": "py38h06a4308_4", + "build_number": 4, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "2cc81ae1d0e77fb8de51cd052779b5ad", + "name": "docker-py", + "sha256": "d88b14528f28403d7a8d36176bf5d8ebf335862513d6c015cd9301a30819101a", + "size": 188518, + "subdir": "linux-64", + "timestamp": 1608758649951, + "version": "4.4.1" + }, + "docker-py-4.4.1-py38h06a4308_5.conda": { + "build": "py38h06a4308_5", + "build_number": 5, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "c34b065e3f50ba96ed2eade5d5273376", + "name": "docker-py", + "sha256": "2415e9b67105ce1e18fc0a0b109c6a83b59fe2c2769b68f63368d16767ef0460", + "size": 192572, + "subdir": "linux-64", + "timestamp": 1610480106484, + "version": "4.4.1" + }, + "docker-py-4.4.1-py39h06a4308_5.conda": { + "build": "py39h06a4308_5", + "build_number": 5, + "depends": [ + "appdirs >=1.4.3", + "asn1crypto >=0.22.0", + "cffi >=1.10.0", + "cryptography >=1.9", + "docker-pycreds >=0.2.1", + "docker-pycreds >=0.3.0", + "idna >=2.5", + "packaging >=16.8", + "pycparser >=2.17", + "pyopenssl >=17.0.0", + "pyparsing >=2.2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.14.2", + "six >=1.10.0", + "websocket-client >=0.32.0", + "websocket-client >=0.40.0" + ], + "license": "Apache-2.0", + "md5": "01751612e4aad2e5a0165514d7eefaae", + "name": "docker-py", + "sha256": "68a889cf387abc4c325d2c7b3449898041ad59efbe60c917ce02b417cc61e44c", + "size": 195173, + "subdir": "linux-64", + "timestamp": 1614172017794, + "version": "4.4.1" + }, + "docopt-0.6.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "1ee7bb79998f180fcd924562313b9386", + "name": "docopt", + "sha256": "cd04e0f8737407117381167330e4cd864f215b28fecd3caa9c194d6c4bc62c6b", + "size": 22318, + "subdir": "linux-64", + "timestamp": 1525269585638, + "version": "0.6.2" + }, + "docopt-0.6.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "f4dc8abcff226ed6397a99590f1bdcf0", + "name": "docopt", + "sha256": "634a73714daa3f297105b8db65f0f349c58e5dc2a5d4a5c5fd3f18059ffe9b20", + "size": 22970, + "subdir": "linux-64", + "timestamp": 1640789642686, + "version": "0.6.2" + }, + "docopt-0.6.2-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "40bad787eed006adf3c3fdfeab73b4db", + "name": "docopt", + "sha256": "76630910298ed22bbce8b35eb35004f852d52bf4d9e4b74999f00af231ef2432", + "size": 24564, + "subdir": "linux-64", + "timestamp": 1663662506455, + "version": "0.6.2" + }, + "docopt-0.6.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "d3ef030424e73289ed3a1bb772121954", + "name": "docopt", + "sha256": "03c86f0dd6e1231d7ebfedd4d11ec8573a9fa9b8478e88c3cc8e5036dc412f42", + "size": 29001, + "subdir": "linux-64", + "timestamp": 1676839782278, + "version": "0.6.2" + }, + "docopt-0.6.2-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7356ce6caa33fadccd449f1a023dc8d7", + "name": "docopt", + "sha256": "9c07d34d6a4241d34add6f198f4a8391e052ab1019d2d3c521090f9b132876c1", + "size": 30870, + "subdir": "linux-64", + "timestamp": 1679335926250, + "version": "0.6.2" + }, + "docopt-0.6.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "97763734616175d6b65a1f2c00779b12", + "name": "docopt", + "sha256": "d8a95e20d1823c5aed7fe50459ac50c3c0c5366fa5f342ac7330fadd65c7b574", + "size": 22740, + "subdir": "linux-64", + "timestamp": 1525269636381, + "version": "0.6.2" + }, + "docopt-0.6.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ddd1fb31bf5c40b41d32b3b2ac166d6a", + "name": "docopt", + "sha256": "a55ab7a333ddf3cfacf644a6134ecbc1c22665e8d91207ed4fcfb78eb836790b", + "size": 22608, + "subdir": "linux-64", + "timestamp": 1525269638315, + "version": "0.6.2" + }, + "docopt-0.6.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0acf95d5fc1f7dedcb19b3e0becbcb3e", + "name": "docopt", + "sha256": "17ce30fc7da84ddfa76221e91c96bb7a9e2940036332862c6ec3593bc1046848", + "size": 23964, + "subdir": "linux-64", + "timestamp": 1611678708521, + "version": "0.6.2" + }, + "docopt-0.6.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "26e12d9552c1fc7508e3f84d42827423", + "name": "docopt", + "sha256": "893996a5d762f2bde1f33db7a58a7c4d7ccee57dd42eb525aec08501dc8e45dc", + "size": 22433, + "subdir": "linux-64", + "timestamp": 1530922690073, + "version": "0.6.2" + }, + "docopt-0.6.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "621bd21d641c6c27d2bb1170d1af5b99", + "name": "docopt", + "sha256": "d6adbe4823312e4eb4e49b20fd357860f0be5f45eda13e9d52091d252c5284bb", + "size": 24187, + "subdir": "linux-64", + "timestamp": 1611677549613, + "version": "0.6.2" + }, + "docopt-0.6.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ccdb9a9c7f14604181ba64b7584b178", + "name": "docopt", + "sha256": "6d5a0a7d06006e006ae6cfcaf7cebbb18e315c10ec39f8301ae0080597e2fb6c", + "size": 24297, + "subdir": "linux-64", + "timestamp": 1663662469525, + "version": "0.6.2" + }, + "docopt-0.6.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "3dd4248b191fc4a0f2aad6bd7f6b5de2", + "name": "docopt", + "sha256": "1a503b32818615b65968a9d912680326185e065f8ce7540dfd790c8a21646c94", + "size": 23102, + "subdir": "linux-64", + "timestamp": 1572435037754, + "version": "0.6.2" + }, + "docopt-0.6.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "578d82b3d97d028fba2a80baa08c8ffa", + "name": "docopt", + "sha256": "d9b25c98daea92ff8525864ff97971802cc07eba8ced7517389fde76a9f75c38", + "size": 24132, + "subdir": "linux-64", + "timestamp": 1611677526240, + "version": "0.6.2" + }, + "docopt-0.6.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "984e3d3dc3baf8b8bdb85a4a4e5fbcd4", + "name": "docopt", + "sha256": "5888d2f5a064f0edfd86bf997abf522014ba29f9499a0e3c3edfc0a64d25e8a6", + "size": 24372, + "subdir": "linux-64", + "timestamp": 1663662530475, + "version": "0.6.2" + }, + "docopt-0.6.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "f71b799f915202ebcbe95d950c4afaf4", + "name": "docopt", + "sha256": "4b800e28cc5d6152b1e0bad1b899905e59d992a5fecc6de8ed34e469156fa98b", + "size": 24355, + "subdir": "linux-64", + "timestamp": 1611677526883, + "version": "0.6.2" + }, + "docopt-0.6.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e76d8b944697e835daca452c114ee22", + "name": "docopt", + "sha256": "738606785130db729711c9e1152a2fa45d83501865f8791bbebe6a49fe2d260d", + "size": 24292, + "subdir": "linux-64", + "timestamp": 1663662445070, + "version": "0.6.2" + }, + "docstring-to-markdown-0.11-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "ec5029ed85b0dc2db93b8a541d503882", + "name": "docstring-to-markdown", + "sha256": "3c387c9aa29a32144f24d058307f05758ea2c2d12c10904533056e7f32b1f066", + "size": 31688, + "subdir": "linux-64", + "timestamp": 1673447722014, + "version": "0.11" + }, + "docstring-to-markdown-0.11-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "54e318c57015dc24d1af2043668ef63b", + "name": "docstring-to-markdown", + "sha256": "74d8e9f12106bcb5adcee057321aa216981c291233a67274c6fb01b9ca643418", + "size": 35367, + "subdir": "linux-64", + "timestamp": 1676851986949, + "version": "0.11" + }, + "docstring-to-markdown-0.11-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "a6c7c84ba86edd0b05e5dae7e17a820c", + "name": "docstring-to-markdown", + "sha256": "a618a626ad198f66da4c8fe78f55017bcf99e84ac730c84afb09cc81a8da4d0e", + "size": 31371, + "subdir": "linux-64", + "timestamp": 1673447747889, + "version": "0.11" + }, + "docstring-to-markdown-0.11-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "688c05b218dd4091e5ea0ec048635856", + "name": "docstring-to-markdown", + "sha256": "df3966a9b0c6aa8cfd4c6a2a8f437619d7734c473d182746bcea26f5eccf772a", + "size": 31529, + "subdir": "linux-64", + "timestamp": 1673447669554, + "version": "0.11" + }, + "docstring-to-markdown-0.11-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "b9adc0b068e7ec26ca917ff9f6ba389f", + "name": "docstring-to-markdown", + "sha256": "f48bfa75dba7c19b67b39f4b0be163fbce2bb4f9023dd6e71f9745bd6384efcf", + "size": 31530, + "subdir": "linux-64", + "timestamp": 1673447695587, + "version": "0.11" + }, + "docutils-0.14-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "4d4dc0a2d9a54460541b84366c195a4f", + "name": "docutils", + "sha256": "dc4c97408257c938117eab5787089b6fc89d5cc4893c6bbdf4e3fbc654abd8af", + "size": 669029, + "subdir": "linux-64", + "timestamp": 1530695222343, + "version": "0.14" + }, + "docutils-0.14-py27hae222c1_0.conda": { + "build": "py27hae222c1_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "596996cdc81c271dd32f1f6799ff9c30", + "name": "docutils", + "sha256": "9c2752abc300e4595319a050c165882a513ccbd66bdac3e09ada5d09432d8950", + "size": 674913, + "subdir": "linux-64", + "timestamp": 1505741024841, + "version": "0.14" + }, + "docutils-0.14-py35hd11081d_0.conda": { + "build": "py35hd11081d_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "962d837a51d7776841cda63e8fdb270d", + "name": "docutils", + "sha256": "501d67357d90889f37f5738de6750aae99bddcd413bd6931316b6fa04022c0de", + "size": 672770, + "subdir": "linux-64", + "timestamp": 1505741103169, + "version": "0.14" + }, + "docutils-0.14-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "8c02a1fe17e8fe70885637f96a48b539", + "name": "docutils", + "sha256": "fe5455b8400c0926c56bf1d607c8d835b6e3fc151c0da38bf2a767976b9d2395", + "size": 668308, + "subdir": "linux-64", + "timestamp": 1530695120404, + "version": "0.14" + }, + "docutils-0.14-py36hb0f60f5_0.conda": { + "build": "py36hb0f60f5_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "70d0dfb742ec14b5dc93e27f1edb57c6", + "name": "docutils", + "sha256": "8d19019280fe23fbf1b0dee4afa089ea172804783ecdad265d1356544e2298a8", + "size": 661175, + "subdir": "linux-64", + "timestamp": 1505741175245, + "version": "0.14" + }, + "docutils-0.14-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "51be123c4ca4f434750be9dfcea78a6d", + "name": "docutils", + "sha256": "9ed90d9739e3de096df4880232209b5c034bf5606529bfcb1e33bfea154cc668", + "size": 661182, + "subdir": "linux-64", + "timestamp": 1530695197140, + "version": "0.14" + }, + "docutils-0.15.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "69170c3972f09999231e050629993d0a", + "name": "docutils", + "sha256": "c04108886385db9d3cbc7803c766df9805ef8661b34a5f3ebf46787929c800fd", + "size": 689400, + "subdir": "linux-64", + "timestamp": 1564162601364, + "version": "0.15.1" + }, + "docutils-0.15.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "e4e065530894cb55dfd91ea9acb6f2cb", + "name": "docutils", + "sha256": "5d7fb2938d53753a841fa353c857054b363390ddb2f11898f46ea1e158fca02d", + "size": 682504, + "subdir": "linux-64", + "timestamp": 1564162683057, + "version": "0.15.1" + }, + "docutils-0.15.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "a3df785943c9e4a4c8c2ccb65a2918d0", + "name": "docutils", + "sha256": "145bafcfe6068cd9fd558eb5e1a0a022faf80b483dbe2d79e54a87facaae9737", + "size": 688543, + "subdir": "linux-64", + "timestamp": 1565958413254, + "version": "0.15.2" + }, + "docutils-0.15.2-py310h06a4308_4.conda": { + "build": "py310h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "b30f1037217b52a628a5ce9dc02102dc", + "name": "docutils", + "sha256": "0062c44ba8d42601e2b9c987efdfc70549c41a09768e715149c3f403bdb98122", + "size": 722865, + "subdir": "linux-64", + "timestamp": 1659506382491, + "version": "0.15.2" + }, + "docutils-0.15.2-py310h06a4308_5.conda": { + "build": "py310h06a4308_5", + "build_number": 5, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "ddb1a7f553fb0bfa3a1cb5d5f5d1bc2f", + "name": "docutils", + "sha256": "dabcf6ca0789fb0f9ea1a1cbcd14ac972888aab6f1ddecaa5b3be90806ba149e", + "size": 695145, + "subdir": "linux-64", + "timestamp": 1660852624235, + "version": "0.15.2" + }, + "docutils-0.15.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "92081ab1d5ca967aad246e6d1233c2d3", + "name": "docutils", + "sha256": "aa01c7dec424e84da7de461da3f580dd2648b2306abd7daa82cd2ed8828e9906", + "size": 676090, + "subdir": "linux-64", + "timestamp": 1565959668887, + "version": "0.15.2" + }, + "docutils-0.15.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "6c3ca2e6d079e03fdce52fe5d6e311a0", + "name": "docutils", + "sha256": "18ff25da08865699af355fc10e62776dd10651468f06fbcb78aaf995fb355b15", + "size": 683269, + "subdir": "linux-64", + "timestamp": 1613157743625, + "version": "0.15.2" + }, + "docutils-0.15.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "bb26b4b997387ec4aa50e9895026046a", + "name": "docutils", + "sha256": "f87f2546ca872c71c5afed3f8427a174b37712330250c5807907c965d2b42a46", + "size": 675616, + "subdir": "linux-64", + "timestamp": 1565958736602, + "version": "0.15.2" + }, + "docutils-0.15.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "4ab1df558840961fba78643c56af8273", + "name": "docutils", + "sha256": "c9c09eb56a0f1fbe67e722b496ae46c96a9d3a54fc39c00eb4e31b22095d21d7", + "size": 683234, + "subdir": "linux-64", + "timestamp": 1613157742131, + "version": "0.15.2" + }, + "docutils-0.15.2-py37h06a4308_4.conda": { + "build": "py37h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "9cff7c64986dfdcaf1b5f009b58e7794", + "name": "docutils", + "sha256": "d3429cc7435930f6d7f1b711c45b6f2a474745f143f590c7c7568724afea1bc4", + "size": 698136, + "subdir": "linux-64", + "timestamp": 1659506613691, + "version": "0.15.2" + }, + "docutils-0.15.2-py37h06a4308_5.conda": { + "build": "py37h06a4308_5", + "build_number": 5, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "2d43fba6c59ef70e574c1527398e5a74", + "name": "docutils", + "sha256": "4573de4344329b6d8e7bd980ba0219379cebdfa220e6cbad8328f00dd3a0b741", + "size": 671843, + "subdir": "linux-64", + "timestamp": 1660852553745, + "version": "0.15.2" + }, + "docutils-0.15.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "8d8efa625fbce1a508c1c2773e1ab18e", + "name": "docutils", + "sha256": "ff6b60ad1198f72c89ab421b996cdbe2af7f8b72576ac5a4ca9cc08fa5392fb4", + "size": 684852, + "subdir": "linux-64", + "timestamp": 1572435113893, + "version": "0.15.2" + }, + "docutils-0.15.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "4e48d71556f70b6bbff647743ca7495c", + "name": "docutils", + "sha256": "e509e7510d9a5ae4eff468d8b5655b2388ad8da35d95e78274ef855c82ef03fb", + "size": 680355, + "subdir": "linux-64", + "timestamp": 1613157750048, + "version": "0.15.2" + }, + "docutils-0.15.2-py38h06a4308_4.conda": { + "build": "py38h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "39a7288106c6e903a1713a9ae308e1cd", + "name": "docutils", + "sha256": "d3d003c3c91591e2817f8000da3fad6fa132901dd5a4842167165e3e069da1e0", + "size": 701698, + "subdir": "linux-64", + "timestamp": 1659506459224, + "version": "0.15.2" + }, + "docutils-0.15.2-py38h06a4308_5.conda": { + "build": "py38h06a4308_5", + "build_number": 5, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "3921526effb569127d33825d2ceb7ffc", + "name": "docutils", + "sha256": "85d42fe922b89eed0c0d7d4b0ad2c0fcda13932be98ce6e31e5359e1b9c69c80", + "size": 677560, + "subdir": "linux-64", + "timestamp": 1660852684443, + "version": "0.15.2" + }, + "docutils-0.15.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "b47aa6f25988255527244290be7f88db", + "name": "docutils", + "sha256": "2aed77951923bf560e6088b06cf9f57cb1748cdfb51f7c5ff7ca079aba46d0b4", + "size": 679800, + "subdir": "linux-64", + "timestamp": 1613157744629, + "version": "0.15.2" + }, + "docutils-0.15.2-py39h06a4308_4.conda": { + "build": "py39h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "dbb972a2f5ced52012cf36a1c66e364f", + "name": "docutils", + "sha256": "47b8a4c407bd985695f077f3ecf21c597b19b657cef54467cc7a681519540e06", + "size": 702102, + "subdir": "linux-64", + "timestamp": 1659506534632, + "version": "0.15.2" + }, + "docutils-0.15.2-py39h06a4308_5.conda": { + "build": "py39h06a4308_5", + "build_number": 5, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "7d9cd16c82c7c141218ca5460123980a", + "name": "docutils", + "sha256": "2ce8b8ec174097a42ba8b48956e9fbf873bdf9af59cded3d700b9fd8ab29d776", + "size": 676733, + "subdir": "linux-64", + "timestamp": 1660852743778, + "version": "0.15.2" + }, + "docutils-0.16-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "71dba90951b3a0fe11f7ba4234d3a058", + "name": "docutils", + "sha256": "3e345054b6bcce6ca48a6a9341bf44874862ac2b280b10c36a0279321e3f8de9", + "size": 683810, + "subdir": "linux-64", + "timestamp": 1580151448049, + "version": "0.16" + }, + "docutils-0.16-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "77cbd4a5a509c9ab4094968664090994", + "name": "docutils", + "sha256": "b7843dee968a1d46da44744acfba9888303f99bef0d658f01cb2efe381b0f36f", + "size": 684944, + "subdir": "linux-64", + "timestamp": 1591789170785, + "version": "0.16" + }, + "docutils-0.16-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "fb718b88e169523da25180b89b00fe1a", + "name": "docutils", + "sha256": "9477012298157cdcf19429e4bf00efb589015eaaf4be8df37d44d2bbcac484ea", + "size": 684135, + "subdir": "linux-64", + "timestamp": 1580151526093, + "version": "0.16" + }, + "docutils-0.16-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "4b6913fcc7ca96a38026063ac7e695f5", + "name": "docutils", + "sha256": "7afcb35d763aa461cf788ae737f1dd2b5bb682594a524de49de6175529d707ba", + "size": 675737, + "subdir": "linux-64", + "timestamp": 1591789194977, + "version": "0.16" + }, + "docutils-0.16-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "14385db1caa3f189ff50dc78f180166d", + "name": "docutils", + "sha256": "43fed2b29e2252dfaa5589a748c5d094a0b0d9361003a79d92a9aab38e8cbe79", + "size": 681199, + "subdir": "linux-64", + "timestamp": 1580151453742, + "version": "0.16" + }, + "docutils-0.16-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "96a521620695d0a92701741ad12e051a", + "name": "docutils", + "sha256": "ea502f11f7981141287b4000fb1427711e718edbd5d96552152e4e22cd6cdf9c", + "size": 688124, + "subdir": "linux-64", + "timestamp": 1591789164516, + "version": "0.16" + }, + "docutils-0.16-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "a33d1bb7408dea760a263917afd9f132", + "name": "docutils", + "sha256": "5ded56262d69aa7fb668cbe14d7b11bca26cd3a52f4aed6cf93abdd251cd7785", + "size": 688133, + "subdir": "linux-64", + "timestamp": 1607039218774, + "version": "0.16" + }, + "docutils-0.17-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "232b180a82d54c0a16245426a6aa724d", + "name": "docutils", + "sha256": "27a8760fa60cbf68426e310297e6a0876f55d65c6f7c02d9800d0bfbedbf50f0", + "size": 703818, + "subdir": "linux-64", + "timestamp": 1617481486010, + "version": "0.17" + }, + "docutils-0.17-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "39c5802ecf64d0173df3bbe0ae78b058", + "name": "docutils", + "sha256": "a86df4bdcea13c9301211f413969ad3fe289698c5eb6a4d5ef34c904559af9db", + "size": 702736, + "subdir": "linux-64", + "timestamp": 1617624699118, + "version": "0.17" + }, + "docutils-0.17-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "398900432eb8bf168375113d07594f41", + "name": "docutils", + "sha256": "3213e086387ca94f9f30773c8f8de4d7026360df34c30ad48eb0c44733f35a81", + "size": 707764, + "subdir": "linux-64", + "timestamp": 1617624696296, + "version": "0.17" + }, + "docutils-0.17-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "31109e7251f09c944819824b275b1798", + "name": "docutils", + "sha256": "b3659367011762c9b9b8d36cb87109086e76b01e9c65e9108485f81258e1b748", + "size": 706038, + "subdir": "linux-64", + "timestamp": 1617481463926, + "version": "0.17" + }, + "docutils-0.17.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "0c51bba11081257b17bbc2bb618a95ab", + "name": "docutils", + "sha256": "5af3e87770140965bb911e89fe63125720ba346243a6c5ab68ac36161ad7104f", + "size": 703325, + "subdir": "linux-64", + "timestamp": 1620828019498, + "version": "0.17.1" + }, + "docutils-0.17.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "dc70e0399af894483d2e0e9fa807864f", + "name": "docutils", + "sha256": "f4b6f03fa4dbd767c1bc731e2c08eb87614e87a3f6e0477c89ec0cea465c5afb", + "size": 696284, + "subdir": "linux-64", + "timestamp": 1620828018248, + "version": "0.17.1" + }, + "docutils-0.17.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "d90ea0ab17a922c881d967ef5b239752", + "name": "docutils", + "sha256": "6c7f5675341c0ffdffd73801c7b4a1c01dd1d421768a7411823120460b221769", + "size": 702232, + "subdir": "linux-64", + "timestamp": 1620828023842, + "version": "0.17.1" + }, + "docutils-0.17.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "7641f2ca29a2b64fa3e04e294042fbdc", + "name": "docutils", + "sha256": "441efbcacbcc245371d783905aa45098ee732aba4cb0337893897677c520cb46", + "size": 708303, + "subdir": "linux-64", + "timestamp": 1620828017440, + "version": "0.17.1" + }, + "docutils-0.18.1-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "md5": "1265d6c7b634ff2c9c5911624901db04", + "name": "docutils", + "sha256": "591bfb4eef336ead935eed947537c450446c5fd8a33a8d259c18332e9872b447", + "size": 700431, + "subdir": "linux-64", + "timestamp": 1640789663378, + "version": "0.18.1" + }, + "docutils-0.18.1-py310h06a4308_3.conda": { + "build": "py310h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "license_family": "Other", + "md5": "5613973eae6fa1c63272b3aee8999580", + "name": "docutils", + "sha256": "a42ac7c89fc9e7771b939b3e43929d78e7d37aaaf52af8693ab573fe95af842f", + "size": 700756, + "subdir": "linux-64", + "timestamp": 1657175571617, + "version": "0.18.1" + }, + "docutils-0.18.1-py311h06a4308_3.conda": { + "build": "py311h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "license_family": "Other", + "md5": "4e54aecf990cdca05853247a80f0db47", + "name": "docutils", + "sha256": "d7fb3c79e2782f263cf22d0803ab88f429da22b07051a6454c5f2ae3c8b1760d", + "size": 899835, + "subdir": "linux-64", + "timestamp": 1676822788314, + "version": "0.18.1" + }, + "docutils-0.18.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "md5": "13c43d810b82138397de4c67caceaa19", + "name": "docutils", + "sha256": "491170afe0dab85a599dae50f34ea9fa4ade4bd2a66e5ee9c05acbf15eccc753", + "size": 677778, + "subdir": "linux-64", + "timestamp": 1638364318636, + "version": "0.18.1" + }, + "docutils-0.18.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "a62843c6dddc97f1c27fc58d85280247", + "name": "docutils", + "sha256": "9cdb4b78cc9a20005d9436c533086e405633566ae3fbe16bf5fa2465d8e1b1d9", + "size": 671419, + "subdir": "linux-64", + "timestamp": 1638363579636, + "version": "0.18.1" + }, + "docutils-0.18.1-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "md5": "5d2d0fa5e0f2742274e6a88e408aec15", + "name": "docutils", + "sha256": "67e0d44612764fe1605845e239c17bb5f0b8f6732312ac58d71ef37f3b8cea46", + "size": 675661, + "subdir": "linux-64", + "timestamp": 1638527881989, + "version": "0.18.1" + }, + "docutils-0.18.1-py37h06a4308_3.conda": { + "build": "py37h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "license_family": "Other", + "md5": "34bfbab5a536b95dcb729ea6b0cdefda", + "name": "docutils", + "sha256": "13726fcdbf7f58898178640bf0018c527754a7195d5a0929cb438fe3d4b68a74", + "size": 678667, + "subdir": "linux-64", + "timestamp": 1657175527107, + "version": "0.18.1" + }, + "docutils-0.18.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "md5": "b7a834c16bc1ec92e6bf81b36c89ab0e", + "name": "docutils", + "sha256": "33881dd1acdbed29fa872e34cd83fee8ca402f53072a607d894cd45eb0d6dd68", + "size": 676456, + "subdir": "linux-64", + "timestamp": 1638364317043, + "version": "0.18.1" + }, + "docutils-0.18.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "8409e906d60c41dafde0ede69b366bf5", + "name": "docutils", + "sha256": "271317cc0b0d34d1fafc988aa24205e8c3ddc40ab31348197f858b0f4d1ef91f", + "size": 676704, + "subdir": "linux-64", + "timestamp": 1638357019773, + "version": "0.18.1" + }, + "docutils-0.18.1-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "md5": "445febc63675ee77d82a3f0f74b870a5", + "name": "docutils", + "sha256": "4448707a705b130f49e7722c5d2732dbb91f7adf2b1f7ed2db7aa9cf3cb7f7ea", + "size": 686046, + "subdir": "linux-64", + "timestamp": 1638528514737, + "version": "0.18.1" + }, + "docutils-0.18.1-py38h06a4308_3.conda": { + "build": "py38h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "license_family": "Other", + "md5": "8abab11190f04760fb8d29d71dcfa032", + "name": "docutils", + "sha256": "24dc71f5ad983fa6262a048c571f6b64589d9ed53267f70d31a2935e2f21cca8", + "size": 682558, + "subdir": "linux-64", + "timestamp": 1657175462743, + "version": "0.18.1" + }, + "docutils-0.18.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "md5": "3f1d37dff7f741acc894b4e8b7847d97", + "name": "docutils", + "sha256": "df68a9e4bd1a4279963e28fe2bd7007278fb983421a156af851f983ba2ac0ae2", + "size": 682188, + "subdir": "linux-64", + "timestamp": 1638363871233, + "version": "0.18.1" + }, + "docutils-0.18.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Public Domain Dedictation and BSD 2-Clause and PSF 2.1.1 and GPL 3.0", + "md5": "d3ac75b8305fc3b6bbd61407553068c3", + "name": "docutils", + "sha256": "d7968833c4f7502373bc23e961d5fb01d552c65a962f6469255da274b385186d", + "size": 681893, + "subdir": "linux-64", + "timestamp": 1638344299876, + "version": "0.18.1" + }, + "docutils-0.18.1-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "md5": "22b6bf604db79892371ca0728836a611", + "name": "docutils", + "sha256": "c70e98ef51146abe92634cb818a1a842edd985133ff34f2aec1f919725ad5d0f", + "size": 679172, + "subdir": "linux-64", + "timestamp": 1638528514172, + "version": "0.18.1" + }, + "docutils-0.18.1-py39h06a4308_3.conda": { + "build": "py39h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later", + "license_family": "Other", + "md5": "89b9d5302135916200139e107981baab", + "name": "docutils", + "sha256": "9c6675e547546db0d4cde91d665d7ff6bf38105cfe3c1faea89f0b9f0218d31f", + "size": 682391, + "subdir": "linux-64", + "timestamp": 1657175495392, + "version": "0.18.1" + }, + "doit-0.29.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "configparser", + "pyinotify", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f05f1a301a0abb04fc596d4db88f4400", + "name": "doit", + "sha256": "3b217970efa9acffe14d66b49fc0c39f5cc99525c1c25172fddf8362cb9cd61e", + "size": 119054, + "subdir": "linux-64", + "timestamp": 1523046083229, + "version": "0.29.0" + }, + "doit-0.29.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a489f6619a07c830b6a080fcd4cf2426", + "name": "doit", + "sha256": "5ecb3462a1e45b3376a9bfb54767c3834798b428994d7e50a919d32df8fa3fd4", + "size": 120916, + "subdir": "linux-64", + "timestamp": 1523046108921, + "version": "0.29.0" + }, + "doit-0.29.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e13030748edc381c1906e12b5138945", + "name": "doit", + "sha256": "03fb6bd614705d43355154014e927266d33be580fbf977659cc90af178dbb60a", + "size": 119724, + "subdir": "linux-64", + "timestamp": 1523046106375, + "version": "0.29.0" + }, + "doit-0.31.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2adbddf4e56003ebd533fe268cc48b06", + "name": "doit", + "sha256": "03085e7a00f2cd7f08e05d87881dd047ac141e495f2eb16e78eca635eda72907", + "size": 123927, + "subdir": "linux-64", + "timestamp": 1523040481312, + "version": "0.31.1" + }, + "doit-0.31.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1601fd48f22ee9b2249472bf241358fe", + "name": "doit", + "sha256": "b49358ec977c924ab6f0983d86f8a29a7df73bb2086e9133ab1a146e35f0069a", + "size": 122745, + "subdir": "linux-64", + "timestamp": 1523040553907, + "version": "0.31.1" + }, + "doit-0.31.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc5480c5d4d20fea3b2baa0a16ad7d04", + "name": "doit", + "sha256": "f59d85c298e6629eb910461bd4f444e62e43d903bb24e9bf72874066584cd787", + "size": 120672, + "subdir": "linux-64", + "timestamp": 1530873502470, + "version": "0.31.1" + }, + "doit-0.31.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cea4647d6f426f75c39668a97a698ada", + "name": "doit", + "sha256": "5a926c55cbd9a3e3e95d2c23b1d456ae6e19e982c54798c32cffe0f57c75871a", + "size": 122557, + "subdir": "linux-64", + "timestamp": 1573741675915, + "version": "0.31.1" + }, + "doit-0.32.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60ae320b39c6172dc5ce89b10bdf5463", + "name": "doit", + "sha256": "e1a5ff9159280505549c89ae2440511793552c884357984475f4ca23359de212", + "size": 127523, + "subdir": "linux-64", + "timestamp": 1588595359684, + "version": "0.32.0" + }, + "doit-0.32.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12dc3e2e3da70440dd4099a2ffcccdf7", + "name": "doit", + "sha256": "eb58f586be84cee7a98268c354d47fa4d7949d16d748a21a3f9f82c63442ddca", + "size": 125964, + "subdir": "linux-64", + "timestamp": 1588595322334, + "version": "0.32.0" + }, + "doit-0.32.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98495f78002469867745a2bb07045591", + "name": "doit", + "sha256": "7202feb0821d7d3835dd6e9cd84fc4c2f88386a6e79d9ea6456361d8ff85fa3b", + "size": 126220, + "subdir": "linux-64", + "timestamp": 1588595401532, + "version": "0.32.0" + }, + "doit-0.33.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6454cebab92b29e775ba050ffb81dd8", + "name": "doit", + "sha256": "0a18a2b2f1e80adc6f08c4262ab9c2a12f7010f95cd2505b32c723aefd8c7a57", + "size": 127860, + "subdir": "linux-64", + "timestamp": 1640808972454, + "version": "0.33.1" + }, + "doit-0.33.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16afbd43cd90ed124b5371b12eb04e1a", + "name": "doit", + "sha256": "7e9e5cb171a90ab2544f328f2cd705ae273251db4431ede9a1b2281599fb43c7", + "size": 169437, + "subdir": "linux-64", + "timestamp": 1676852001024, + "version": "0.33.1" + }, + "doit-0.33.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "874a209650abb90759003bb9dedb0c68", + "name": "doit", + "sha256": "d43e4355552892a4d9ecac0dbed330c2a696da25bdc75fe6f25afac75d7fd3ed", + "size": 126913, + "subdir": "linux-64", + "timestamp": 1603926337092, + "version": "0.33.1" + }, + "doit-0.33.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f18634eb760cf73b4e10c5799a22c833", + "name": "doit", + "sha256": "0a92d4fe986063bca69f013589f2643c75d0a9283a22a2b654c73e6a13130900", + "size": 126857, + "subdir": "linux-64", + "timestamp": 1603926313804, + "version": "0.33.1" + }, + "doit-0.33.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2521098e3c81d77590a3a67c8a6515d", + "name": "doit", + "sha256": "f744673367df84316aafabfa7b6fd686224a63bcb39805e505b0395b2822e146", + "size": 125585, + "subdir": "linux-64", + "timestamp": 1603926335591, + "version": "0.33.1" + }, + "doit-0.33.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "pyinotify", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1277ab27c74932e8657973f28b3ee30e", + "name": "doit", + "sha256": "797d497ed98f9c058cfd95abc3b9c75768ad5bceb3da7955261fc07908f492c8", + "size": 126161, + "subdir": "linux-64", + "timestamp": 1614246298319, + "version": "0.33.1" + }, + "dos2unix-7.4.2-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ca4fe3ca03ee340c7d27e55fd7d9209d", + "name": "dos2unix", + "sha256": "1cb983438681375d2f4e56d6b1d49fa7fd3aa91207949f311fae9dd1c2fc686f", + "size": 270540, + "subdir": "linux-64", + "timestamp": 1642592499322, + "version": "7.4.2" + }, + "double-conversion-3.1.5-he6710b0_1.conda": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7997b27a33f772d5a6aac26f7ccf849f", + "name": "double-conversion", + "sha256": "a70c18d23f1ce9f4de75133e3ac321b94fed51a2b0a6e1ddc005bd049ca3ae60", + "size": 240569, + "subdir": "linux-64", + "timestamp": 1567108307419, + "version": "3.1.5" + }, + "dpcpp-cpp-rt-2021.3.0-h06a4308_3350.conda": { + "build": "h06a4308_3350", + "build_number": 3350, + "depends": [ + "intel-cmplr-lib-rt 2021.3.0 h06a4308_3350", + "intel-cmplr-lic-rt 2021.3.0 h06a4308_3350", + "intel-opencl-rt 2021.3.0 h06a4308_3350", + "intel-openmp 2021.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "56d01e1c532bb87b50d279b7ee0dc16a", + "name": "dpcpp-cpp-rt", + "sha256": "988505efb8350d917e863825a6fdf7d97483205dfa375d50a9ec2fd95e10500b", + "size": 1138142, + "subdir": "linux-64", + "timestamp": 1626976237193, + "version": "2021.3.0" + }, + "dpcpp-cpp-rt-2021.4.0-h06a4308_3561.conda": { + "build": "h06a4308_3561", + "build_number": 3561, + "depends": [ + "intel-cmplr-lib-rt 2021.4.0 h06a4308_3561", + "intel-cmplr-lic-rt 2021.4.0 h06a4308_3561", + "intel-opencl-rt 2021.4.0 h06a4308_3561", + "intel-openmp 2021.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "63ba703478d55f85da1d50310fd8856f", + "name": "dpcpp-cpp-rt", + "sha256": "256a94248efb2875ae7af13ba0a22d2ec9d7b834cf13d88c640542cbd156d3ae", + "size": 1132212, + "subdir": "linux-64", + "timestamp": 1641816140942, + "version": "2021.4.0" + }, + "dpcpp-cpp-rt-2022.0.1-h06a4308_3633.conda": { + "build": "h06a4308_3633", + "build_number": 3633, + "depends": [ + "intel-cmplr-lib-rt 2022.0.1 h06a4308_3633", + "intel-cmplr-lic-rt 2022.0.1 h06a4308_3633", + "intel-opencl-rt 2022.0.1 h06a4308_3633", + "intel-openmp 2022.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "0465292ebb7feafa684cfe23bc068105", + "name": "dpcpp-cpp-rt", + "sha256": "3985b8b66f4f105f723e16a1d65c8858a5cfc2a5cc99d6911e5873a11968c87b", + "size": 1145103, + "subdir": "linux-64", + "timestamp": 1642778772238, + "version": "2022.0.1" + }, + "dpcpp-cpp-rt-2022.1.0-h06a4308_3768.conda": { + "build": "h06a4308_3768", + "build_number": 3768, + "depends": [ + "intel-cmplr-lib-rt 2022.1.0 h06a4308_3768", + "intel-cmplr-lic-rt 2022.1.0 h06a4308_3768", + "intel-opencl-rt 2022.1.0 h06a4308_3768", + "intel-openmp 2022.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "76ddcce681873c4191f24edc829c2918", + "name": "dpcpp-cpp-rt", + "sha256": "26b18b0db1d817b23f249a4be5d348e411a5d3a217c0b1ed635d91515a27efd3", + "size": 1429303, + "subdir": "linux-64", + "timestamp": 1667585162588, + "version": "2022.1.0" + }, + "dpcpp-cpp-rt-2023.0.0-h06a4308_25370.conda": { + "build": "h06a4308_25370", + "build_number": 25370, + "depends": [ + "intel-cmplr-lib-rt 2023.0.0 h06a4308_25370", + "intel-cmplr-lic-rt 2023.0.0 h06a4308_25370", + "intel-opencl-rt 2023.0.0 h06a4308_25370", + "intel-openmp 2023.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "799aa963527102f901bd1c16f3966222", + "name": "dpcpp-cpp-rt", + "sha256": "9f0c10391e2fcb6e39c79c212873d100d074538844d974f62477dd3342dc5cf6", + "size": 1380604, + "subdir": "linux-64", + "timestamp": 1679615106681, + "version": "2023.0.0" + }, + "dpcpp_impl_linux-64-2021.3.0-h06a4308_3350.conda": { + "build": "h06a4308_3350", + "build_number": 3350, + "depends": [ + "dpcpp-cpp-rt 2021.3.0 h06a4308_3350" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "80b0d5e10242e6b7ecd7a3b92085477d", + "name": "dpcpp_impl_linux-64", + "sha256": "275d438c83e6b5363998b68746bbe8b62eafa45d65941efa49d7f7f7ce473473", + "size": 107496508, + "subdir": "linux-64", + "timestamp": 1626976374632, + "version": "2021.3.0" + }, + "dpcpp_impl_linux-64-2021.4.0-h06a4308_3561.conda": { + "build": "h06a4308_3561", + "build_number": 3561, + "depends": [ + "dpcpp-cpp-rt 2021.4.0 h06a4308_3561", + "dpl-include" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "3e977dc8fc7eecdeec8f5a230bbffce7", + "name": "dpcpp_impl_linux-64", + "sha256": "c27832140b31234b67a6ca76d0df4980172085b0a721ab10aef563797b7ff13b", + "size": 120882885, + "subdir": "linux-64", + "timestamp": 1641816197129, + "version": "2021.4.0" + }, + "dpcpp_impl_linux-64-2022.0.1-h06a4308_3633.conda": { + "build": "h06a4308_3633", + "build_number": 3633, + "depends": [ + "dpcpp-cpp-rt 2022.0.1 h06a4308_3633" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "cab13cd5cd925b39ae5d52c80e23f11a", + "name": "dpcpp_impl_linux-64", + "sha256": "dc0eb118bae953f6c2dbeb9500a4e46ebd4b023cb43ec27b34fd382c77dc41e6", + "size": 176221702, + "subdir": "linux-64", + "timestamp": 1642779040672, + "version": "2022.0.1" + }, + "dpcpp_impl_linux-64-2022.1.0-h6a678d5_3768.conda": { + "build": "h6a678d5_3768", + "build_number": 3768, + "depends": [ + "dpcpp-cpp-rt 2022.1.0 h06a4308_3768", + "gcc_impl_linux-64", + "gxx_impl_linux-64", + "sysroot_linux-64" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "fe6b9f0d37145a4ad01f255d914b1b8e", + "name": "dpcpp_impl_linux-64", + "sha256": "07b5f5c1ccacf0f6d4fa32049db5cd4de94be9729ad188745dd0eebceef59a00", + "size": 304724363, + "subdir": "linux-64", + "timestamp": 1667585195855, + "version": "2022.1.0" + }, + "dpcpp_impl_linux-64-2023.0.0-h6a678d5_25370.conda": { + "build": "h6a678d5_25370", + "build_number": 25370, + "depends": [ + "dpcpp-cpp-rt 2023.0.0 h06a4308_25370", + "gcc_impl_linux-64", + "gxx_impl_linux-64", + "sysroot_linux-64" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "45726a013276bfe8d0334df9775fd5fa", + "name": "dpcpp_impl_linux-64", + "sha256": "9d8b0ac52df81b3491edc900a21bafdb7823a273c5c7b6c03f2891fc99504abb", + "size": 382351727, + "subdir": "linux-64", + "timestamp": 1679615139912, + "version": "2023.0.0" + }, + "dpcpp_linux-64-2021.3.0-h06a4308_3350.conda": { + "build": "h06a4308_3350", + "build_number": 3350, + "depends": [ + "dpcpp_impl_linux-64 2021.3.0 h06a4308_3350" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "22954462abb5e64b2cc7cf5c23f7c447", + "name": "dpcpp_linux-64", + "sha256": "42db36cab6bd6fc43b6307ba4c01f75226e791cec5eef8d8be3d9aaa078d61a9", + "size": 28708, + "subdir": "linux-64", + "timestamp": 1626976548351, + "version": "2021.3.0" + }, + "dpcpp_linux-64-2021.4.0-h06a4308_3561.conda": { + "build": "h06a4308_3561", + "build_number": 3561, + "depends": [ + "dpcpp_impl_linux-64 2021.4.0 h06a4308_3561" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "1c5226028e0949bc74555df1dc6d578e", + "name": "dpcpp_linux-64", + "sha256": "5234dbaac0e2d640b9d98b19ce868936c418a59d6924bc8778d1f2774174ffd4", + "size": 29062, + "subdir": "linux-64", + "timestamp": 1641816357605, + "version": "2021.4.0" + }, + "dpcpp_linux-64-2022.0.1-h06a4308_3633.conda": { + "build": "h06a4308_3633", + "build_number": 3633, + "depends": [ + "dpcpp_impl_linux-64 2022.0.1 h06a4308_3633" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "29716b85280e3694f69b351721113b24", + "name": "dpcpp_linux-64", + "sha256": "5f56314b518623e24fd6b2a3c4c8685745eba0effef7fbcf6eb9ba121fb24991", + "size": 26988, + "subdir": "linux-64", + "timestamp": 1642779284378, + "version": "2022.0.1" + }, + "dpcpp_linux-64-2022.1.0-h3a05717_3768.conda": { + "build": "h3a05717_3768", + "build_number": 3768, + "depends": [ + "dpcpp_impl_linux-64 2022.1.0 h6a678d5_3768" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "9cb37c1e44f5edb9fdb47589215695a3", + "name": "dpcpp_linux-64", + "sha256": "9520aced79c93d185758e69b719dc3ad3da5e2bd5f0f2944ba707865470d8076", + "size": 32790, + "subdir": "linux-64", + "timestamp": 1667585634408, + "version": "2022.1.0" + }, + "dpcpp_linux-64-2023.0.0-h3a05717_25370.conda": { + "build": "h3a05717_25370", + "build_number": 25370, + "depends": [ + "dpcpp_impl_linux-64 2023.0.0 h6a678d5_25370" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "71eb4c665238cb9e120ca68534f3460f", + "name": "dpcpp_linux-64", + "sha256": "1c0ab32b3dd797a9c001967521d3b5c36876e437c34bb19d7b8a1ddea22344fb", + "size": 33238, + "subdir": "linux-64", + "timestamp": 1679615666052, + "version": "2023.0.0" + }, + "dpctl-0.11.4-py37h93b75d6_0.conda": { + "build": "py37h93b75d6_0", + "build_number": 0, + "depends": [ + "dpcpp-cpp-rt >=2021.3", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "411d9a21e9065e6f0acc7b37ee37d533", + "name": "dpctl", + "sha256": "d2c3eebc731879c6f5b11089903bf9c85a27ea696507ce1605521bfab0782fde", + "size": 775923, + "subdir": "linux-64", + "timestamp": 1646239175074, + "version": "0.11.4" + }, + "dpctl-0.11.4-py38h93b75d6_0.conda": { + "build": "py38h93b75d6_0", + "build_number": 0, + "depends": [ + "dpcpp-cpp-rt >=2021.3", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bcaa9a9b61e5ec974df6ef18c5595761", + "name": "dpctl", + "sha256": "ea5f5f71056ba33c70628d402db4714f62c1c6fb35992edfeff66973ba767b60", + "size": 809778, + "subdir": "linux-64", + "timestamp": 1646239350619, + "version": "0.11.4" + }, + "dpctl-0.11.4-py39h93b75d6_0.conda": { + "build": "py39h93b75d6_0", + "build_number": 0, + "depends": [ + "dpcpp-cpp-rt >=2021.3", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "866d65fd7a1512832ba06d391e16f0af", + "name": "dpctl", + "sha256": "6022f474ee9709f17b89c670127cfea708cec32d67855e4ec46362252ebb5f44", + "size": 811263, + "subdir": "linux-64", + "timestamp": 1646239261715, + "version": "0.11.4" + }, + "dpctl-0.13.0-py310h6244886_0.conda": { + "build": "py310h6244886_0", + "build_number": 0, + "depends": [ + "dpcpp-cpp-rt >=2022.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6c041c568455fd1202ba369aad14b418", + "name": "dpctl", + "sha256": "640e9edfc3773efa62b49b1e2bed756542eb77c941eb22f3154d57f9b7da2a45", + "size": 1803122, + "subdir": "linux-64", + "timestamp": 1667591849313, + "version": "0.13.0" + }, + "dpctl-0.13.0-py38h6244886_0.conda": { + "build": "py38h6244886_0", + "build_number": 0, + "depends": [ + "dpcpp-cpp-rt >=2022.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a13e3e6738aa8baa5c788f557a6da4d4", + "name": "dpctl", + "sha256": "4c11e2d649d1c04693056fed3bcc9435f1447d1058c91742f9f1f5c3395a2be9", + "size": 1823216, + "subdir": "linux-64", + "timestamp": 1667592313127, + "version": "0.13.0" + }, + "dpctl-0.13.0-py39h6244886_0.conda": { + "build": "py39h6244886_0", + "build_number": 0, + "depends": [ + "dpcpp-cpp-rt >=2022.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f312db05c915491099cb80383a3f170c", + "name": "dpctl", + "sha256": "c39d7622e1611b9236d7a7f690040b2dc0209a3e20a940dcd66e71decfd163cb", + "size": 1835939, + "subdir": "linux-64", + "timestamp": 1667592781330, + "version": "0.13.0" + }, + "dpl-include-2021.4.0-h06a4308_3561.conda": { + "build": "h06a4308_3561", + "build_number": 3561, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "f8937db265c1121f25ba85753b3a1d9e", + "name": "dpl-include", + "sha256": "2c4d5b0116cd61d5c44647cbed69b0dc6a5320a0d1a3c8195bacc7f7759e7acd", + "size": 205625, + "subdir": "linux-64", + "timestamp": 1641815988237, + "version": "2021.4.0" + }, + "dpnp-0.9.0-py37hfe064f0_0.conda": { + "build": "py37hfe064f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "dpcpp-cpp-rt >=2021.3", + "dpctl >=0.10", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.3", + "mkl-dpcpp >=2021.3", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.20.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d02586cad035b829e080416724550c90", + "name": "dpnp", + "sha256": "2023a6fc5839197b7fe4622c601f77bc1a1567ca32942239e3a430039003a8d1", + "size": 1657186, + "subdir": "linux-64", + "timestamp": 1646240247364, + "version": "0.9.0" + }, + "dpnp-0.9.0-py38hfe064f0_0.conda": { + "build": "py38hfe064f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "dpcpp-cpp-rt >=2021.3", + "dpctl >=0.10", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.3", + "mkl-dpcpp >=2021.3", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.20.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "eb2a7cafbd716bfc531bcf9a1dca2ae8", + "name": "dpnp", + "sha256": "981434075a971645efc57e5d06bf530a94b80e62595a8206e37a608755c3e30f", + "size": 1685857, + "subdir": "linux-64", + "timestamp": 1646239912211, + "version": "0.9.0" + }, + "dpnp-0.9.0-py39hfe064f0_0.conda": { + "build": "py39hfe064f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "dpcpp-cpp-rt >=2021.3", + "dpctl >=0.10", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.3", + "mkl-dpcpp >=2021.3", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.20.3,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ec4de204eed6ba9750ef771273de968b", + "name": "dpnp", + "sha256": "c605c4a2d18f093a7a884b4b3b2fe8530043defd08ce324b7662ab2db4f426b4", + "size": 1689206, + "subdir": "linux-64", + "timestamp": 1646240573381, + "version": "0.9.0" + }, + "drmaa-0.7.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "86319fb6aa72b1c6bb0ee5aca9e88b9d", + "name": "drmaa", + "sha256": "284291db708696b48172a66db5e661bbf7b64431407668b2d6dab7af5ff29c55", + "size": 29670, + "subdir": "linux-64", + "timestamp": 1522880564339, + "version": "0.7.8" + }, + "drmaa-0.7.8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "628ebed4c7093bc2fadb1c386d21e7e6", + "name": "drmaa", + "sha256": "a726ae216ed1951b241d85c2d94839cb4afe02e6d0d05f19a3d77adda8816a94", + "size": 30075, + "subdir": "linux-64", + "timestamp": 1522880575881, + "version": "0.7.8" + }, + "drmaa-0.7.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "0034af5cbee193faf2a35728ce152991", + "name": "drmaa", + "sha256": "bc7f1d4341aa974591907a8ddeabe9ce0b66a2d3daa647c9cbfa07e1d78f3262", + "size": 29789, + "subdir": "linux-64", + "timestamp": 1522880538273, + "version": "0.7.8" + }, + "drmaa-0.7.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "e8dc90c8456844a102feb975465c7728", + "name": "drmaa", + "sha256": "04ef27ef91267ff4bd87fed501dae41c1f0f9cac3c458fd4b0b17e0ca4f93025", + "size": 29810, + "subdir": "linux-64", + "timestamp": 1530873530594, + "version": "0.7.8" + }, + "drmaa-0.7.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "1df403708576eedfc14d65951e39402a", + "name": "drmaa", + "sha256": "b1169640db33bbf58af48f4ac7b409af9531d629e5435c527daa70a06a4377f5", + "size": 30769, + "subdir": "linux-64", + "timestamp": 1542077531566, + "version": "0.7.9" + }, + "drmaa-0.7.9-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "94bb5d2e3ea8a7d9f75981e6135694d9", + "name": "drmaa", + "sha256": "3679618130d18703da8c7d92f5037a41a2fdd30ce1d0e404d6efafbcb4dbed82", + "size": 30606, + "subdir": "linux-64", + "timestamp": 1640789681371, + "version": "0.7.9" + }, + "drmaa-0.7.9-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "md5": "f35a761ce52337f79a0e68cfd9a4ab74", + "name": "drmaa", + "sha256": "9d6c10c14826e1733616dc35d23f7dfaa32891c55b8bd1752458294687532293", + "size": 36394, + "subdir": "linux-64", + "timestamp": 1676852017387, + "version": "0.7.9" + }, + "drmaa-0.7.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "c84a4d120db38940952a9364cdd3c14a", + "name": "drmaa", + "sha256": "196994fb3c015d1e85ec621dbaee74ec6e45ac388d08ab4729807fac68c79b64", + "size": 30727, + "subdir": "linux-64", + "timestamp": 1542077525877, + "version": "0.7.9" + }, + "drmaa-0.7.9-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "11882ae886de331545426c370a1c30f7", + "name": "drmaa", + "sha256": "cd6070c120cf914f922368a2c421764123d8e062df271d84a9501790266b6574", + "size": 32745, + "subdir": "linux-64", + "timestamp": 1611677526406, + "version": "0.7.9" + }, + "drmaa-0.7.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "ff4060d55984da7d0365b7ea311e7585", + "name": "drmaa", + "sha256": "9ea11932f5b90bd92d1eb54942991d12d833a0a1365a05de73e1e36806a0be84", + "size": 30723, + "subdir": "linux-64", + "timestamp": 1542077464619, + "version": "0.7.9" + }, + "drmaa-0.7.9-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "67ae62ad671c7b9786015e84e32d7ed1", + "name": "drmaa", + "sha256": "e00d92f87035911236db461b9094261c5aa021fbc22c05b2d16836b66aad9340", + "size": 32750, + "subdir": "linux-64", + "timestamp": 1611678829789, + "version": "0.7.9" + }, + "drmaa-0.7.9-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "81f0784189d4d0b8bb7a4449d7d05add", + "name": "drmaa", + "sha256": "0fba1252c759c9229dca82945074cb9467b2834c648c7bffb0ff48fc4f491ffb", + "size": 30427, + "subdir": "linux-64", + "timestamp": 1572435136146, + "version": "0.7.9" + }, + "drmaa-0.7.9-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "4d1bde3d988108d685eff8b386fd8382", + "name": "drmaa", + "sha256": "8470d2c82c786b9d39f6b9f801c5911a53281492cc0a8f3cb15ed7e54567fd13", + "size": 32902, + "subdir": "linux-64", + "timestamp": 1611677542179, + "version": "0.7.9" + }, + "drmaa-0.7.9-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "445a40cdf631fe75c344aae1dbdaf852", + "name": "drmaa", + "sha256": "f755e004a5c4c9cf076597c00459a36978b1d7980a8e4851ab1a154919126208", + "size": 32928, + "subdir": "linux-64", + "timestamp": 1611677548427, + "version": "0.7.9" + }, + "dropbox-10.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f32eb8aa05ba0f1a08558193188a41a", + "name": "dropbox", + "sha256": "173544b25d68257ea7964e88a3ea71aba66d8a5589d148552e6fc8fc0a6bcd5f", + "size": 903556, + "subdir": "linux-64", + "timestamp": 1590086487899, + "version": "10.1.2" + }, + "dropbox-10.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "174ed362f40ea2a0f5cbc4712108ea59", + "name": "dropbox", + "sha256": "06db05a5592c273613b222939a58ff3bb3fdabee326281daf3161a7212a3b686", + "size": 903207, + "subdir": "linux-64", + "timestamp": 1590086475257, + "version": "10.1.2" + }, + "dropbox-10.1.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01d5853b665ed7f86aa1bf76b2b67de2", + "name": "dropbox", + "sha256": "d54db663aa9947b8e2c91e062e7ed37cc2161390a23373a443781f378c87b443", + "size": 908933, + "subdir": "linux-64", + "timestamp": 1590086478670, + "version": "10.1.2" + }, + "dropbox-10.10.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8df3128c65de1b44a12fd175d77e67c", + "name": "dropbox", + "sha256": "6e18032b7ef5f5a064266d6fcad9c069e9ccf1457b39a1811b3247e85d0a74f1", + "size": 941789, + "subdir": "linux-64", + "timestamp": 1606082683059, + "version": "10.10.0" + }, + "dropbox-10.10.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "231ad2f86d33b76c8cb7f547717c5dc8", + "name": "dropbox", + "sha256": "5c1df1e623b748a262eba95fd36ccb6ab022bb0e6da0d95b2425a7eb3c293ad9", + "size": 941027, + "subdir": "linux-64", + "timestamp": 1606082717410, + "version": "10.10.0" + }, + "dropbox-10.10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2bdbebde2fe9fa5943a21765fb590f1a", + "name": "dropbox", + "sha256": "4dd4716b14ea912913d8343dfc6de82f01f4042eacc3330540d0b110d072ab7a", + "size": 958401, + "subdir": "linux-64", + "timestamp": 1606082728447, + "version": "10.10.0" + }, + "dropbox-10.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "431449350625e4c334af7346a0e66e55", + "name": "dropbox", + "sha256": "4a7f43a47b6566ccee938a7c533d5ea87cb690794cac38f1879e579641c4f70c", + "size": 955853, + "subdir": "linux-64", + "timestamp": 1606082695930, + "version": "10.10.0" + }, + "dropbox-10.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8013b0fbe03beb279c7e9a7b2d12537f", + "name": "dropbox", + "sha256": "164f08c7f60d8f3f68650332ac503164f4518476d616559ed26da35039c34b83", + "size": 936225, + "subdir": "linux-64", + "timestamp": 1593439535340, + "version": "10.2.0" + }, + "dropbox-10.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b39ac93071a9f22c7c7fb2bd05bd321a", + "name": "dropbox", + "sha256": "a9cdf690547412c6456fe2a8a40b6ac1cdf72b13ee600e0c71c9a78da4a68e9f", + "size": 926377, + "subdir": "linux-64", + "timestamp": 1593439522334, + "version": "10.2.0" + }, + "dropbox-10.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a52ad3187dd4254c5f2a834cfa56d2b0", + "name": "dropbox", + "sha256": "7a2ad5dfe7da8af64a7997c554342bcd9cbcd8b62ec7c7d874bba13bf147ad56", + "size": 941996, + "subdir": "linux-64", + "timestamp": 1593439522326, + "version": "10.2.0" + }, + "dropbox-10.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1154b9b2b7e45f931f430bc8b851625a", + "name": "dropbox", + "sha256": "6431eeaeabe4f930035339b5911db1406d2d23cba5348cf430092f0ad121634a", + "size": 929455, + "subdir": "linux-64", + "timestamp": 1600355265497, + "version": "10.4.1" + }, + "dropbox-10.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a51a4534f55c4070bf94db25c53815dd", + "name": "dropbox", + "sha256": "7824fb07ef95a8a85aa96ef4c98883058c030abaad7ed44a1e4c1f022d5e5aad", + "size": 940006, + "subdir": "linux-64", + "timestamp": 1600355257650, + "version": "10.4.1" + }, + "dropbox-10.4.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "53c97a32b920af9c488269283319e5fb", + "name": "dropbox", + "sha256": "056cd1c4704e15924c6677846f143185ee15f8bb95cf32cab77e1dff67bbe5a6", + "size": 945653, + "subdir": "linux-64", + "timestamp": 1600355278101, + "version": "10.4.1" + }, + "dropbox-10.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "732f102482cdb28e99c2bca23383488d", + "name": "dropbox", + "sha256": "363fb1a5a0cc5acfe8e2ed1791e0325ab001904b749ca1b365d7901d339dced3", + "size": 926818, + "subdir": "linux-64", + "timestamp": 1601994666430, + "version": "10.5.0" + }, + "dropbox-10.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d328b9b0bb7afaa343da3f55aab1d854", + "name": "dropbox", + "sha256": "744f7155e0251bf13e0814cffdeb4de4b1d246d78974c505e1d6ab7673baa921", + "size": 927979, + "subdir": "linux-64", + "timestamp": 1601994627925, + "version": "10.5.0" + }, + "dropbox-10.5.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8b43ed4fb6bb09ec12ceb9af1da48529", + "name": "dropbox", + "sha256": "cbb1c0cdb66895f0944d1766fb248ad3b431f759c5f1c0050cee339e0f131cac", + "size": 941580, + "subdir": "linux-64", + "timestamp": 1601994630565, + "version": "10.5.0" + }, + "dropbox-10.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56eaa285386e1bc7d83fd5b19a4b9401", + "name": "dropbox", + "sha256": "149a518c384f7475d6e26e5922a124876335255091e2316651321ce2e12b86b6", + "size": 929271, + "subdir": "linux-64", + "timestamp": 1602613308040, + "version": "10.6.0" + }, + "dropbox-10.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e3ed8890ab61a8776755c9fe58b6504d", + "name": "dropbox", + "sha256": "5fe6e7b4f6b58f8c60a671a1d7b04e44f683bbb8672d71e8f944bbb945c85b5a", + "size": 928871, + "subdir": "linux-64", + "timestamp": 1602613276461, + "version": "10.6.0" + }, + "dropbox-10.6.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2321719b2461edd6c47a6639dfdb356c", + "name": "dropbox", + "sha256": "e154ae939d564ce701b0d1a2af14f85dff513ba0b777aaea9751c913e14e45d6", + "size": 942644, + "subdir": "linux-64", + "timestamp": 1602613301927, + "version": "10.6.0" + }, + "dropbox-10.7.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc93dbb49e1d8845e5a3ea180594ed54", + "name": "dropbox", + "sha256": "58cbaa2b0f9f26b8080ba7cfc23ab1edc44002b93d58a2d32831d346efd93731", + "size": 932444, + "subdir": "linux-64", + "timestamp": 1603926407482, + "version": "10.7.0" + }, + "dropbox-10.7.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "07bfcf2eb31c9fd0e4b442a63ba36ce5", + "name": "dropbox", + "sha256": "76962d46489b1913da1e4aa364a5ba59ae367c5853f8fc1e9a28f457e813b636", + "size": 931751, + "subdir": "linux-64", + "timestamp": 1603926378531, + "version": "10.7.0" + }, + "dropbox-10.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "828f5e218ad257694544af268ff69983", + "name": "dropbox", + "sha256": "ab38d1af89d2af26eb7daae4ddda66e7d32f56922549cdc3d1f318aea1ba77aa", + "size": 938008, + "subdir": "linux-64", + "timestamp": 1603926417338, + "version": "10.7.0" + }, + "dropbox-10.8.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2aa32c092f3e6c80e370f1aed779a09", + "name": "dropbox", + "sha256": "7b8429adc2d6e71970bdf3a916716762a2d889cdee1ab9423b528270176c29b5", + "size": 933278, + "subdir": "linux-64", + "timestamp": 1604099179895, + "version": "10.8.0" + }, + "dropbox-10.8.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bbccecbeed456ec9690ec9dc8eef32f6", + "name": "dropbox", + "sha256": "fb7273bd4298a915f2da55d8b5a0b8a5898d6170b0bcac78ef7031e13673c653", + "size": 932320, + "subdir": "linux-64", + "timestamp": 1604099155753, + "version": "10.8.0" + }, + "dropbox-10.8.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "520dc5d9d13db82962f4afc56f8eeb34", + "name": "dropbox", + "sha256": "afddbd695609340d27d131980d0eac77b2d1795710e8f72df801841b988cf8a4", + "size": 941458, + "subdir": "linux-64", + "timestamp": 1604099163041, + "version": "10.8.0" + }, + "dropbox-10.9.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e62a10938cf8669ee352c76847583fe8", + "name": "dropbox", + "sha256": "9503da657c3ea7c02b64dfbe14ef1d02b27c3b78ba934ef0fa58621809b2049c", + "size": 939775, + "subdir": "linux-64", + "timestamp": 1605066666399, + "version": "10.9.0" + }, + "dropbox-10.9.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "41f55c2ec9f0f43b27b72c36ce0a1faa", + "name": "dropbox", + "sha256": "7b2a28862a487ba6dfa0321732e3c24bea1e13bc5942924c78605c8265bd1c27", + "size": 950135, + "subdir": "linux-64", + "timestamp": 1605066628650, + "version": "10.9.0" + }, + "dropbox-10.9.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87f1aad660f23d8aa71fe092bf781a04", + "name": "dropbox", + "sha256": "edca2e966f51393952201f1556ad3b4aae2af99de46277d71be127dbf75e5540", + "size": 946658, + "subdir": "linux-64", + "timestamp": 1605066661916, + "version": "10.9.0" + }, + "dropbox-11.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5071743178c72945386f61d1df0ff5a8", + "name": "dropbox", + "sha256": "3f1a978546e91b95a17a92c301a59916b1ccd167567b99966bbce98afa048923", + "size": 1336438, + "subdir": "linux-64", + "timestamp": 1622151293496, + "version": "11.10.0" + }, + "dropbox-11.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ac794e090283139ed81272397fbd527", + "name": "dropbox", + "sha256": "8de27f6f45edf4f5e9eb1f887f98335378fbe93942d127515dfd9a400d912b7f", + "size": 1349958, + "subdir": "linux-64", + "timestamp": 1624291604944, + "version": "11.11.0" + }, + "dropbox-11.12.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b27c6c72e085bfbc360a2999401b105", + "name": "dropbox", + "sha256": "13f36b9d26c69c0b5c98d8b8b37a9130cfffc0ac6f1c6313422cee1ed511ec39", + "size": 1341352, + "subdir": "linux-64", + "timestamp": 1624616881706, + "version": "11.12.0" + }, + "dropbox-11.13.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "100d4a9fc2c1c993b3843eaa07aa403a", + "name": "dropbox", + "sha256": "983dac97b210f204819247c865a34e05f9e9dbf2373aefc31c8a9ff7b4b3b470", + "size": 1340798, + "subdir": "linux-64", + "timestamp": 1625729138273, + "version": "11.13.1" + }, + "dropbox-11.14.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7a18d6bd2a1304da52d4a709ca6ff817", + "name": "dropbox", + "sha256": "29f8c1b7ca57706979db7ce93fd8310090b67fb7746180e1fcbc82add2714c1e", + "size": 1351163, + "subdir": "linux-64", + "timestamp": 1640805498089, + "version": "11.14.0" + }, + "dropbox-11.14.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "069db108aeb7e3d6b3e93a8adb2210c9", + "name": "dropbox", + "sha256": "7a1e8d2085beaff0109443f82d70864a1d76cde3882b5c8f3a9bb79ce5b3d232", + "size": 1358604, + "subdir": "linux-64", + "timestamp": 1632880820806, + "version": "11.14.0" + }, + "dropbox-11.14.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7bf9a4a07700d44834cafcf4af4b3766", + "name": "dropbox", + "sha256": "b2619647bc788bac3b2972225c618fa5a4861a71a488416fcaa764add60b43fe", + "size": 1349233, + "subdir": "linux-64", + "timestamp": 1632890789054, + "version": "11.14.0" + }, + "dropbox-11.14.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6241ca43ec92d5a87fbbf2de9455ccaf", + "name": "dropbox", + "sha256": "9e8def39adb44d121c72d0b65bc01a302200df67304e82b0734283b7e972fa97", + "size": 1362083, + "subdir": "linux-64", + "timestamp": 1632890789569, + "version": "11.14.0" + }, + "dropbox-11.14.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "53e963c34d100880cd83e583208e4a9b", + "name": "dropbox", + "sha256": "b61713bb1d0d64d0d021f97790bc6846670e20a67cc0cff57d1753af96f25ba8", + "size": 1354806, + "subdir": "linux-64", + "timestamp": 1627019520878, + "version": "11.14.0" + }, + "dropbox-11.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56004ab52ccc7b2e26cbbc0d61df898d", + "name": "dropbox", + "sha256": "220996f357370aa07a2a10018c4a626a57f9b81db9141dbffb7d80a49526109f", + "size": 1340605, + "subdir": "linux-64", + "timestamp": 1618565109021, + "version": "11.7.0" + }, + "dropbox-11.8.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9725d9b9bb63e490c89f4368594797d", + "name": "dropbox", + "sha256": "0b2b93058b592b9cbd818fb90b53a0461942accfb7e34714549d3110ca9165e0", + "size": 1334590, + "subdir": "linux-64", + "timestamp": 1620619723022, + "version": "11.8.0" + }, + "dropbox-11.9.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.16.2", + "six >=1.12.0", + "stone >=2.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "846055b4d4ed606f3b45763a5bbf0615", + "name": "dropbox", + "sha256": "e9a78083ae667766d1753e7c1da0ed879383e34e84b7a3edadebbb5b106bc723", + "size": 1334756, + "subdir": "linux-64", + "timestamp": 1620823759212, + "version": "11.9.0" + }, + "dropbox-8.4.0-py27hdd59973_0.conda": { + "build": "py27hdd59973_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "94589466550c43eaf5304e2aa469e1a2", + "name": "dropbox", + "sha256": "7ca1ff382bf27adb95564e187cce4317c0223ad928ea74fd79ce3020bd263c54", + "size": 562782, + "subdir": "linux-64", + "timestamp": 1508628750587, + "version": "8.4.0" + }, + "dropbox-8.4.0-py35hd086d9a_0.conda": { + "build": "py35hd086d9a_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6820f868c00350f82901f7d4fc06fc3f", + "name": "dropbox", + "sha256": "41aa1905b03530a3b7482e3d6cfeed70514b80878b4924c4c40c83b37938150e", + "size": 595107, + "subdir": "linux-64", + "timestamp": 1508628751141, + "version": "8.4.0" + }, + "dropbox-8.4.0-py36ha3455e0_0.conda": { + "build": "py36ha3455e0_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "32b0ff59f9602ca3ead3752bcfa1ec13", + "name": "dropbox", + "sha256": "297a6365d3345ed95add9446718b1e44796dc8012b1570ad06d8109f159d58a8", + "size": 586301, + "subdir": "linux-64", + "timestamp": 1508628765880, + "version": "8.4.0" + }, + "dropbox-8.5.0-py27h2b0e868_0.conda": { + "build": "py27h2b0e868_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "61b608b894b95d9ee84669b29f52dd56", + "name": "dropbox", + "sha256": "6a712ddad1e99ec5981142ce412e26404393dcb68b299fcee603adc1ac6f2405", + "size": 573110, + "subdir": "linux-64", + "timestamp": 1511840659135, + "version": "8.5.0" + }, + "dropbox-8.5.0-py35h4c242c8_0.conda": { + "build": "py35h4c242c8_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d7d0fdcf8d5ab61c09e331d3b18aab0", + "name": "dropbox", + "sha256": "cabb8e12832659d5c671519640e02284e201f498b962b82408849ee21ee08147", + "size": 601624, + "subdir": "linux-64", + "timestamp": 1511840658791, + "version": "8.5.0" + }, + "dropbox-8.5.0-py36h9ff2726_0.conda": { + "build": "py36h9ff2726_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c78ff05c45096eae09cef4643f254fbf", + "name": "dropbox", + "sha256": "3b0572658ac1ac7969789aaf14930804ea9f0010a06ed4fea9d7cb67685a4b33", + "size": 597774, + "subdir": "linux-64", + "timestamp": 1511840659868, + "version": "8.5.0" + }, + "dropbox-8.7.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "865475a23c0b7655381cc9bced085c2a", + "name": "dropbox", + "sha256": "d6aa98ddf7ae46ec777b6fdd5e2fc7c9c1f834885f544663a8b48e955bd5fce5", + "size": 628303, + "subdir": "linux-64", + "timestamp": 1520916171549, + "version": "8.7.1" + }, + "dropbox-8.7.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dcb1ffe37f83e3f64b41e3bb6492bc0b", + "name": "dropbox", + "sha256": "724d6ab9307646c521b0290693d874023349e112b309475d1aad8ddf974e9078", + "size": 661442, + "subdir": "linux-64", + "timestamp": 1520916190932, + "version": "8.7.1" + }, + "dropbox-8.7.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f6ae21dd385a20884f6a9cb92622e4a", + "name": "dropbox", + "sha256": "12837a6160638a39d2a55abc31ca5dd7c9e899ae6742a236c054db6a3033b66b", + "size": 649538, + "subdir": "linux-64", + "timestamp": 1520916152629, + "version": "8.7.1" + }, + "dropbox-8.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b0b53c70721e367c79deb59ef35495e5", + "name": "dropbox", + "sha256": "3d5e494713abbc2a444eb038567fcef5793f30ba03aaba7ce320fd7a7d0699e7", + "size": 648929, + "subdir": "linux-64", + "timestamp": 1524508581577, + "version": "8.8.1" + }, + "dropbox-8.8.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "812867a5af6a1c4d2c29e0951c3ef22a", + "name": "dropbox", + "sha256": "af57bb2f13bf4aed4f0b7bba3d1bde964d76d7a7b28c7b07f690769e6dbddbf3", + "size": 683971, + "subdir": "linux-64", + "timestamp": 1524508589869, + "version": "8.8.1" + }, + "dropbox-8.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6ee7630b356278909c5de7ab67a0704", + "name": "dropbox", + "sha256": "24daae3f3838a4ddbce60e725ba09db0b02edcdafde28adf34d54662796d1edb", + "size": 679051, + "subdir": "linux-64", + "timestamp": 1524508592237, + "version": "8.8.1" + }, + "dropbox-8.9.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f5ef7a4c039f7fca6f34db72cee4e5df", + "name": "dropbox", + "sha256": "f426c48c7061a55fcc6230a693a3af0ea89ebfe4dc76b19ed9a5cc0dbafa9803", + "size": 655574, + "subdir": "linux-64", + "timestamp": 1526929448043, + "version": "8.9.0" + }, + "dropbox-8.9.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d3dab1bd6326da5b150a66a8d9d02ff", + "name": "dropbox", + "sha256": "6185f0597e6ab728ae68ca9aa205bdc973c6633b81140188f65ef6062cd91863", + "size": 691334, + "subdir": "linux-64", + "timestamp": 1526929468322, + "version": "8.9.0" + }, + "dropbox-8.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "795dd3e2257d424dc50b2b4b32f4ce8e", + "name": "dropbox", + "sha256": "ef0a97eb6e6ae0ecbf1c8e67509c1d69aa24b21afafbc0086b533579880febf9", + "size": 680419, + "subdir": "linux-64", + "timestamp": 1526929416425, + "version": "8.9.0" + }, + "dropbox-9.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f16fcae19736652978b47fa11fcf82b4", + "name": "dropbox", + "sha256": "33c56f8bc5f3d7d206d1740711a8bf08209127a7c7ff0d6fe6309f721c874dd1", + "size": 654676, + "subdir": "linux-64", + "timestamp": 1534438441169, + "version": "9.0.0" + }, + "dropbox-9.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fbcc0a49ffdcaa6277938d2ea3866e07", + "name": "dropbox", + "sha256": "c3b85356ccebc4f61e7733001776db9419383a59e97d07c1a4b0d292ff3ddebf", + "size": 691481, + "subdir": "linux-64", + "timestamp": 1534437094755, + "version": "9.0.0" + }, + "dropbox-9.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "61f017b7c84cbdfd9d16ad1e3071b826", + "name": "dropbox", + "sha256": "5a6376e5b823f0f4793121382b905f1ae2b8472c5927b7da80fed8ac959e3ed8", + "size": 683480, + "subdir": "linux-64", + "timestamp": 1534437115387, + "version": "9.0.0" + }, + "dropbox-9.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "84c36505cb8793a074a50e5e0c69133c", + "name": "dropbox", + "sha256": "d4275f94e85371f1c1d16126c72634563c3ef982b121a19478ecb31c8db3560b", + "size": 684346, + "subdir": "linux-64", + "timestamp": 1534437196488, + "version": "9.0.0" + }, + "dropbox-9.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dca8e5c66308ff4662ff6181db83c133", + "name": "dropbox", + "sha256": "0577b1fd3550bd1b99b44fb47b9587d56fabf5c36224a5f462b314b9082a666f", + "size": 674896, + "subdir": "linux-64", + "timestamp": 1539474978419, + "version": "9.1.0" + }, + "dropbox-9.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13a14acb283a1d70ee586371565f3cef", + "name": "dropbox", + "sha256": "b0935e0bf468f12cd40e87c8b9df499f85b450345652f6e703d750b3bf8fc00c", + "size": 719063, + "subdir": "linux-64", + "timestamp": 1539475001759, + "version": "9.1.0" + }, + "dropbox-9.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2aead85ce606873e6ca4631b7115b63", + "name": "dropbox", + "sha256": "8f55ef133ac81bfc9666ff51da0a3d9daf5ae5f0d3fa955e943fef00dab17c33", + "size": 712538, + "subdir": "linux-64", + "timestamp": 1539474990229, + "version": "9.1.0" + }, + "dropbox-9.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71d3ac5b997b8c557760f43f45ffff22", + "name": "dropbox", + "sha256": "f60a80e71e5e5369029aefa5de0955398b6fc3f1d53e1e0557a4c174919e5db2", + "size": 689579, + "subdir": "linux-64", + "timestamp": 1543521150943, + "version": "9.2.0" + }, + "dropbox-9.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da6e4ca0e4fe4e1512e4ebe5f3789653", + "name": "dropbox", + "sha256": "48524bf6a5517e0d16a37592befc6bf117b90e331d5d46c925d993d3fa13b76c", + "size": 720097, + "subdir": "linux-64", + "timestamp": 1543521186982, + "version": "9.2.0" + }, + "dropbox-9.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ad0b39c2bf11cd7a792f4be3f252dbd", + "name": "dropbox", + "sha256": "648aad961fce16a3efb0b9105af204f4d67606781eb6dfe711d31652115fb6f7", + "size": 725194, + "subdir": "linux-64", + "timestamp": 1543521137381, + "version": "9.2.0" + }, + "dropbox-9.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d88dbce2ad654a9f26930cd9e82763c3", + "name": "dropbox", + "sha256": "ca7493e9e9f0986b7b396a3290f97bf269d82558d277810408d09a3243a66e01", + "size": 681891, + "subdir": "linux-64", + "timestamp": 1545112084720, + "version": "9.3.0" + }, + "dropbox-9.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9b75e34a9655dd0c2a8d3eccc8f02c0", + "name": "dropbox", + "sha256": "49b0d4aa7b275a0fc9b13d4549ac271b2a915a4544f2807b384fe12f36b14887", + "size": 725932, + "subdir": "linux-64", + "timestamp": 1545112125028, + "version": "9.3.0" + }, + "dropbox-9.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d14a5cf6cd3456f166b0ddd1a316f7f", + "name": "dropbox", + "sha256": "8ed05dd8a9adb3cb41d92b6768894e39f0e53c18ed613731ad0e1102964b3a15", + "size": 726013, + "subdir": "linux-64", + "timestamp": 1545112121215, + "version": "9.3.0" + }, + "dropbox-9.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "089e3986b1e3b7320106652c3ab9dedc", + "name": "dropbox", + "sha256": "184eae86ee491b4c82fe5d95312aeb0763bd567d7bca130f9e811809528bbf5b", + "size": 731909, + "subdir": "linux-64", + "timestamp": 1564673307789, + "version": "9.4.0" + }, + "dropbox-9.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8471674aebb229e3fc19ebc0a3fdb59", + "name": "dropbox", + "sha256": "618d43cb9313cc34e6649258f0103d9aa7f1ea8c7a1b25aafc04c68e1cb56399", + "size": 773884, + "subdir": "linux-64", + "timestamp": 1564674410772, + "version": "9.4.0" + }, + "dropbox-9.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "65dd400af591da6d918654cd226aff8c", + "name": "dropbox", + "sha256": "ecb1bb8f8336acbee0182407442757998d20bdcb465931372374e8be73e876d6", + "size": 779437, + "subdir": "linux-64", + "timestamp": 1564673281371, + "version": "9.4.0" + }, + "dropbox-9.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.16.2", + "setuptools", + "six >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12b7ce3dfd344e04dc871cc26518581e", + "name": "dropbox", + "sha256": "ecba4db37cf08a9ed8a3ac38a5e143503b2f76465e8ff7b4b165d5314ddd557d", + "size": 782665, + "subdir": "linux-64", + "timestamp": 1574238556621, + "version": "9.4.0" + }, + "dsdp-5.8-h2c4e229_0.conda": { + "build": "h2c4e229_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0" + ], + "license": "DSDP", + "md5": "a39b7168481403739a11cb444d04dc4c", + "name": "dsdp", + "sha256": "d17b8250e7131a2ac9a8718b9a6ab6704b1ab494c12e1f12727bd91d3f9264ad", + "size": 223244, + "subdir": "linux-64", + "timestamp": 1528986722167, + "version": "5.8" + }, + "dsdp-5.8-h4077e5c_1.conda": { + "build": "h4077e5c_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0" + ], + "license": "DSDP", + "md5": "9bff32649bcc1407e23c46975bc0c315", + "name": "dsdp", + "sha256": "38c693870d0e50167491774a801b14b3e0dc758835cef996f10127cd1731af0d", + "size": 230222, + "subdir": "linux-64", + "timestamp": 1656067884060, + "version": "5.8" + }, + "dsdp-5.8-h75fe3a5_0.conda": { + "build": "h75fe3a5_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0" + ], + "license": "DSDP", + "md5": "9dd2e12f8bb3ffd377a9691e7d22e6fa", + "name": "dsdp", + "sha256": "e54ea5aefd009f3aadf633deff718be386fec6121cbe361f9c19377045a6a84a", + "size": 230383, + "subdir": "linux-64", + "timestamp": 1550693665184, + "version": "5.8" + }, + "dsdp-5.8-h7aab8bc_1.conda": { + "build": "h7aab8bc_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0" + ], + "license": "DSDP", + "md5": "06cf9d721943ed741832b6792d187ffa", + "name": "dsdp", + "sha256": "f0d8b5fa761ee41f8b1f67dd9058e307b41d670bd19d2a47c1cd9d496866ba02", + "size": 230246, + "subdir": "linux-64", + "timestamp": 1656067824413, + "version": "5.8" + }, + "dsdp-5.8-h9e0dedd_0.conda": { + "build": "h9e0dedd_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0" + ], + "license": "DSDP", + "md5": "53724d0327e3ba7cfde0247d681b8229", + "name": "dsdp", + "sha256": "4f390bab4c0bffe9e2f5556c081b48668870725a2d6467a3e7f090660ca024d8", + "size": 223642, + "subdir": "linux-64", + "timestamp": 1528986753791, + "version": "5.8" + }, + "dsdp-5.8-hfa32c7d_0.conda": { + "build": "hfa32c7d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0" + ], + "license": "DSDP", + "md5": "aff4321ea3fe1325fad1d9a860b1274b", + "name": "dsdp", + "sha256": "73c16be019dec5c07cd6949b33f5b178ff540f82e465b1cf791c1f569fb5f31f", + "size": 230881, + "subdir": "linux-64", + "timestamp": 1550693724288, + "version": "5.8" + }, + "dulwich-0.21.3-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "constrains": [ + "paramiko" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "urllib3 >=1.25" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "43ceab9011dae89b14cee64340ca321f", + "name": "dulwich", + "sha256": "ca97ff11a6f0c68c59c61b3906f79937ca84833f351099e9111aa1bfbbd40558", + "size": 740582, + "subdir": "linux-64", + "timestamp": 1679420145441, + "version": "0.21.3" + }, + "dulwich-0.21.3-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "constrains": [ + "paramiko" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "urllib3 >=1.25" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "738b9583f856eb2ebf0424fdd7ca3920", + "name": "dulwich", + "sha256": "10de6b516f1b19588d0d7b8a902eaf7cc38c60574662f76e6afd1053be867212", + "size": 998371, + "subdir": "linux-64", + "timestamp": 1679420178779, + "version": "0.21.3" + }, + "dulwich-0.21.3-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "constrains": [ + "paramiko" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "urllib3 >=1.25" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c4708bff3b93b103858bbc8749188d50", + "name": "dulwich", + "sha256": "3823bfdc0a03a646388a2ef2554f1b1dd0ba6788e58abddf25fd34a961e9f2cf", + "size": 731428, + "subdir": "linux-64", + "timestamp": 1679420111993, + "version": "0.21.3" + }, + "dulwich-0.21.3-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "constrains": [ + "paramiko" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "urllib3 >=1.25" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "df7cb6a2d064b7ddb442303123d9ef11", + "name": "dulwich", + "sha256": "dddfdadd521fb159dc41c7ca92b42be8a216b4e4ab682f9932d60577b494f13c", + "size": 731930, + "subdir": "linux-64", + "timestamp": 1679420079311, + "version": "0.21.3" + }, + "duma_linux-64-2.5.15-h1234567_0.conda": { + "build": "h1234567_0", + "build_number": 0, + "depends": [], + "license": "GPL", + "md5": "f853ad9c56ed5ab5470d090aba358781", + "name": "duma_linux-64", + "sha256": "436c99883fcd5a3e66e885cb9d51c97d3ed7b60a8a2fb08890887dc577781470", + "size": 102010, + "subdir": "linux-64", + "timestamp": 1652859649182, + "version": "2.5.15" + }, + "duma_linux-64-2.5.15-h1234567_1.conda": { + "build": "h1234567_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "344addb04a719af796f55fb41873dd62", + "name": "duma_linux-64", + "sha256": "a80b5d35eb5ff787a7af1673288fdfa699a0e2ad61d7300f699df5c82befcce8", + "size": 103199, + "subdir": "linux-64", + "timestamp": 1654090732360, + "version": "2.5.15" + }, + "duma_linux-64-2.5.15-h28ad9a3_3.conda": { + "build": "h28ad9a3_3", + "build_number": 3, + "depends": [], + "license": "GPL", + "md5": "615467b716370bd4d901268064a5db50", + "name": "duma_linux-64", + "sha256": "8adbb6c4519f38e2fe1a73c9f4f3f999e3f2b08e36ea3957b2c40289a58da894", + "size": 96510, + "subdir": "linux-64", + "timestamp": 1520534492887, + "version": "2.5.15" + }, + "duma_linux-64-2.5.15-h49555fe_2.conda": { + "build": "h49555fe_2", + "build_number": 2, + "depends": [], + "license": "GPL", + "md5": "f07bca37073949fb1ed4d876d87eb092", + "name": "duma_linux-64", + "sha256": "b1608fa54bd2c660e5fa2e4e779619e75725f00817c45b70d4cb95be1956d933", + "size": 83721, + "subdir": "linux-64", + "timestamp": 1507262704045, + "version": "2.5.15" + }, + "duma_linux-64-2.5.15-hec2b5b5_1.conda": { + "build": "hec2b5b5_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "a3cc3594cbd77e3c7db17f6b88dd8b22", + "name": "duma_linux-64", + "sha256": "d368d32ea1bac53dfae189e13a9859b82e77098f22930c871f8662d7050e8e8f", + "size": 83488, + "subdir": "linux-64", + "timestamp": 1505665553992, + "version": "2.5.15" + }, + "easyocr-1.6.2-py310hdb19cb5_0.conda": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ninja", + "numpy", + "pillow", + "py-opencv >=4.6.0", + "pyclipper", + "python >=3.10,<3.11.0a0", + "python-bidi", + "pytorch", + "pyyaml", + "scikit-image", + "scipy", + "shapely", + "torchvision >=0.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1e108b3f5986e06753feea556adcd621", + "name": "easyocr", + "sha256": "413b22705064e04b4f39b481fbd087b912a64f1bf5b7c3407aef4a6543c945ec", + "size": 65297773, + "subdir": "linux-64", + "timestamp": 1676627205933, + "version": "1.6.2" + }, + "easyocr-1.6.2-py37hdb19cb5_0.conda": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ninja", + "numpy", + "pillow", + "py-opencv >=4.6.0", + "pyclipper", + "python >=3.7,<3.8.0a0", + "python-bidi", + "pytorch", + "pyyaml", + "scikit-image", + "scipy", + "shapely", + "torchvision >=0.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "91e95b9db0a8d74818ee23251fc73cc8", + "name": "easyocr", + "sha256": "ffc6c4f124260ade211d133743eff3d733f737960180853bf6f2e25f159a24f2", + "size": 65307559, + "subdir": "linux-64", + "timestamp": 1676627041026, + "version": "1.6.2" + }, + "easyocr-1.6.2-py38hdb19cb5_0.conda": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ninja", + "numpy", + "pillow", + "py-opencv >=4.6.0", + "pyclipper", + "python >=3.8,<3.9.0a0", + "python-bidi", + "pytorch", + "pyyaml", + "scikit-image", + "scipy", + "shapely", + "torchvision >=0.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "afcb5297d2d24f3006ae7de86f5e4b36", + "name": "easyocr", + "sha256": "4eb77b4833b0be8c8159773f3ef58036b5eec3fec8c8a73e3794d08224de76e7", + "size": 65295920, + "subdir": "linux-64", + "timestamp": 1676627360996, + "version": "1.6.2" + }, + "easyocr-1.6.2-py39hdb19cb5_0.conda": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ninja", + "numpy", + "pillow", + "py-opencv >=4.6.0", + "pyclipper", + "python >=3.9,<3.10.0a0", + "python-bidi", + "pytorch", + "pyyaml", + "scikit-image", + "scipy", + "shapely", + "torchvision >=0.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e8843ba2170701a8290756ef4484fc6a", + "name": "easyocr", + "sha256": "da84cbc552b472eec112d5d6838f11aa61de59540fb0078558d6b2c4525a748b", + "size": 65307031, + "subdir": "linux-64", + "timestamp": 1676627515522, + "version": "1.6.2" + }, + "ecdsa-0.13-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ee1665b4edca8c00ff39c6637461381e", + "name": "ecdsa", + "sha256": "7444f01ab92ec29a264d99b03d6ffebf5358bf5ebefc537e39bc334debaefa5b", + "size": 77775, + "subdir": "linux-64", + "timestamp": 1530876140514, + "version": "0.13" + }, + "ecdsa-0.13-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "398dbfd5e362b1a26d7ecdf89d4a8de9", + "name": "ecdsa", + "sha256": "361a0038e21c726ef569da8c7b7f82b4bed62269f8115d18954fcacc48bbd064", + "size": 77904, + "subdir": "linux-64", + "timestamp": 1537807921091, + "version": "0.13" + }, + "ecdsa-0.13-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "61d96d90e23387ae721fc084694291c4", + "name": "ecdsa", + "sha256": "ee38b069994a9eab2510e05ab03fc8687e892d3e8c423dd8108124e011e74e3f", + "size": 77607, + "subdir": "linux-64", + "timestamp": 1642499233038, + "version": "0.13" + }, + "ecdsa-0.13-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "c35541145c7dc8a32e2ea9d17b08aec3", + "name": "ecdsa", + "sha256": "3fcac06d01d48696b0ba269d5c400afc753cc994d2e84e216cab9ae26bcf7540", + "size": 101443, + "subdir": "linux-64", + "timestamp": 1676905934641, + "version": "0.13" + }, + "ecdsa-0.13-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "9b37c77453d5856e8ee3ebcc42e88f7e", + "name": "ecdsa", + "sha256": "621feb6f880ccb95d104f71f194795edb0c8850530548adbcf00e6ac51d9d5d9", + "size": 78885, + "subdir": "linux-64", + "timestamp": 1537807935811, + "version": "0.13" + }, + "ecdsa-0.13-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "04461cfd958029d79e9d616b7f319b7d", + "name": "ecdsa", + "sha256": "67727db6aac00cc4a5a11a324b4dcbac44197ce0a70e70fbd4db5b37d5cba9da", + "size": 77993, + "subdir": "linux-64", + "timestamp": 1530876089205, + "version": "0.13" + }, + "ecdsa-0.13-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c5fcfbd0cb6065f35fc60fef7d71ee52", + "name": "ecdsa", + "sha256": "9abae7872c6c2d71a3a7f0e2add480aed34b26a859678c0b220451bf523f4737", + "size": 79258, + "subdir": "linux-64", + "timestamp": 1537807945494, + "version": "0.13" + }, + "ecdsa-0.13-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9bd22b5c8dd58fefcbc6b14a1726521a", + "name": "ecdsa", + "sha256": "1f35314da5c1eda0e48efdf905600872e023e77e28ffce7667bf6c0b55c8e641", + "size": 370166, + "subdir": "linux-64", + "timestamp": 1632891031686, + "version": "0.13" + }, + "ecdsa-0.13-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "dba1ba8b0de0109bc502a0f3e04bb1ff", + "name": "ecdsa", + "sha256": "3d4b78faebdc102c4f16d22630b3f6998c53c6f4db0def8a4d5a77f1e889a315", + "size": 77864, + "subdir": "linux-64", + "timestamp": 1530876115348, + "version": "0.13" + }, + "ecdsa-0.13-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6a6af401dd730af3a5a38b8e5f4bcd32", + "name": "ecdsa", + "sha256": "08c5958960f83500b9505358c506168113a42c19b3a8d66cfe864bf60cde6906", + "size": 77979, + "subdir": "linux-64", + "timestamp": 1537807884441, + "version": "0.13" + }, + "ecdsa-0.13-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "fe00b1566225550fc950509ca354726c", + "name": "ecdsa", + "sha256": "94ca2505e8dec5f8507a69858eecb13de5edfeb5db6f7b15e7b425b06febb81b", + "size": 369916, + "subdir": "linux-64", + "timestamp": 1632881020834, + "version": "0.13" + }, + "ecdsa-0.13-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "83db96f686cc8e692c70011a23b40790", + "name": "ecdsa", + "sha256": "abc55d6dc141c43101054c72e95f3ffb659126a8f0757680810f63cb4d198348", + "size": 78829, + "subdir": "linux-64", + "timestamp": 1572357143205, + "version": "0.13" + }, + "ecdsa-0.13-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "227bc9ed101c68ee2bd3580f8244bccc", + "name": "ecdsa", + "sha256": "6e02b1c7ff14f4ac4ef8abf7fd7bcdeae8126f0f675c3c27ab151eb993359498", + "size": 371168, + "subdir": "linux-64", + "timestamp": 1632891447592, + "version": "0.13" + }, + "ecdsa-0.13-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "c3f8a0fddb2d37fab71365568fa1b52d", + "name": "ecdsa", + "sha256": "df904c2861b729a7c0456751deb431058b5152185abed577fc08524d726256c4", + "size": 369640, + "subdir": "linux-64", + "timestamp": 1632891004925, + "version": "0.13" + }, + "ecos-2.0.12-py310ha9d4c09_0.conda": { + "build": "py310ha9d4c09_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "d6c13f78dd68d5ee8aa3eb46285c8a65", + "name": "ecos", + "sha256": "8c4a3d0eb6224bc7547a5a648b5f58eb72a75ea3cdf0e3fc4a55eea800352123", + "size": 102481, + "subdir": "linux-64", + "timestamp": 1677702303322, + "version": "2.0.12" + }, + "ecos-2.0.12-py311hbed6279_0.conda": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "ee6e4e92c028d65810ee4217fea3519d", + "name": "ecos", + "sha256": "ceef3379fd3e4315747619c90f23ccd0c9065bd9afb03718328da1bec347b027", + "size": 92294, + "subdir": "linux-64", + "timestamp": 1677770141369, + "version": "2.0.12" + }, + "ecos-2.0.12-py38h7deecbd_0.conda": { + "build": "py38h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "db737f0a29a2af6fec0cebf6b2e31f19", + "name": "ecos", + "sha256": "51f55fb235bd1ed46b670fc38699283fb112746c2b8df36144dc614744208dd1", + "size": 102667, + "subdir": "linux-64", + "timestamp": 1677702215206, + "version": "2.0.12" + }, + "ecos-2.0.12-py39h7deecbd_0.conda": { + "build": "py39h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "bcee3536d7e98ff610843b23e5f65efe", + "name": "ecos", + "sha256": "76fa4edd113f938aca05bb42d1b4c48a4548fd2a89c10affd6c3f8294b1d6334", + "size": 102275, + "subdir": "linux-64", + "timestamp": 1677702260169, + "version": "2.0.12" + }, + "ecos-2.0.5-py27h3010b51_0.conda": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.9" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "1f9658f3413b2612f51bcfec4fba4fe0", + "name": "ecos", + "sha256": "1975c2b28a6247a7d5de0c982cb01e0d7071292b5a24dfe706c3ede4dbda8934", + "size": 58340, + "subdir": "linux-64", + "timestamp": 1527023563598, + "version": "2.0.5" + }, + "ecos-2.0.5-py35h3010b51_0.conda": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.9" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "f874f955a9cb098f68ab8886e91730e9", + "name": "ecos", + "sha256": "de60acb8d59ee48bd37fe07dd3f9c2f10f4f768fe0cd33258bbce85ff62e4de3", + "size": 58307, + "subdir": "linux-64", + "timestamp": 1527023567757, + "version": "2.0.5" + }, + "ecos-2.0.5-py36h3010b51_0.conda": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.9" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "d92844a03ccf5714cb137f593d96670e", + "name": "ecos", + "sha256": "be0bc3641bb66cb90f8b19a06afb1d35fba969a2c22dd7e09daa62bf096f9333", + "size": 59098, + "subdir": "linux-64", + "timestamp": 1527023649855, + "version": "2.0.5" + }, + "ecos-2.0.7-py27hdd07704_0.conda": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "1c5910acf98ac7dd5ea809a715fa301a", + "name": "ecos", + "sha256": "788cf5693d3e8cf36f44911c4a88dcab960402fffe67e7673f567132a21d8625", + "size": 83572, + "subdir": "linux-64", + "timestamp": 1569433227262, + "version": "2.0.7" + }, + "ecos-2.0.7-py36hdd07704_0.conda": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "77ce1217b961bcc7e3c479b3f32db662", + "name": "ecos", + "sha256": "bd2bb46eb2fd845e893569633ac05c10cb9b970dcbbda43dd5f31672caddfc43", + "size": 83747, + "subdir": "linux-64", + "timestamp": 1569433233067, + "version": "2.0.7" + }, + "ecos-2.0.7-py37hdd07704_0.conda": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "8d0b3163558d5a2116556cd0867a2262", + "name": "ecos", + "sha256": "1051542bbd115d7a79cdeb7097d5870de059f3a60884817bc22ec243ba1eb656", + "size": 83553, + "subdir": "linux-64", + "timestamp": 1569433267435, + "version": "2.0.7" + }, + "ecos-2.0.7.post1-py310h9102076_0.conda": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "2b459ad26ea0bd6da2ea6b45f6d5f931", + "name": "ecos", + "sha256": "2bdc1de9a6f667f59fc81688fd38f8db9a2433e4792d296aedcb90432416f92b", + "size": 172363, + "subdir": "linux-64", + "timestamp": 1640809004825, + "version": "2.0.7.post1" + }, + "ecos-2.0.7.post1-py36h6323ea4_0.conda": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "7b3f4e6e06cb55cfa571a104d912fe19", + "name": "ecos", + "sha256": "257454c58d9b39f07f5117d0e734f4da87b04c02470bae43a02c35713f4cb450", + "size": 84219, + "subdir": "linux-64", + "timestamp": 1614178303851, + "version": "2.0.7.post1" + }, + "ecos-2.0.7.post1-py36heb32a55_0.conda": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "4f869831d3e28041996d877347b1e89b", + "name": "ecos", + "sha256": "661af298f1f48ee5ab22c024ca18b78b66d4adfc26285d4d279eea6a97b49e77", + "size": 84385, + "subdir": "linux-64", + "timestamp": 1592217405007, + "version": "2.0.7.post1" + }, + "ecos-2.0.7.post1-py37h6323ea4_0.conda": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "f0447a5607b136fdc196e43bb7da7aed", + "name": "ecos", + "sha256": "fa48508655437e7859f574661d091c71fdd800a05899e0ce3b5cdabfdc2919eb", + "size": 84597, + "subdir": "linux-64", + "timestamp": 1614177951831, + "version": "2.0.7.post1" + }, + "ecos-2.0.7.post1-py37heb32a55_0.conda": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "a2274048ee8a61783e17e457f8bd3317", + "name": "ecos", + "sha256": "11c45b76825f2cc08ddc09a76d1b0c2ca0558f4aec381803daf6cf97f66b8d2d", + "size": 84234, + "subdir": "linux-64", + "timestamp": 1592217405618, + "version": "2.0.7.post1" + }, + "ecos-2.0.7.post1-py38h6323ea4_0.conda": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "42a2e3806fb5374989a50bb02e1068b4", + "name": "ecos", + "sha256": "5b5bca0a6f7433598df07c3bca0cc52f8c24f736b270c159f310ef8cd4a32511", + "size": 85127, + "subdir": "linux-64", + "timestamp": 1614177364946, + "version": "2.0.7.post1" + }, + "ecos-2.0.7.post1-py38heb32a55_0.conda": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "abfa813c558e44f75d2fde46b5b38361", + "name": "ecos", + "sha256": "63a7259812b2146f9233e900aa42686d5c95aec0cdb8da79af514a960a6ff2bc", + "size": 84246, + "subdir": "linux-64", + "timestamp": 1592217385963, + "version": "2.0.7.post1" + }, + "ecos-2.0.7.post1-py39h6323ea4_0.conda": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.9" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "acb1327ff18426e0725a06e0e837745b", + "name": "ecos", + "sha256": "6741fab8a7789502fa0ca08bd9a126141ca99c0e29bb0cd3015020a5870f5fbc", + "size": 84911, + "subdir": "linux-64", + "timestamp": 1614178291267, + "version": "2.0.7.post1" + }, + "editables-0.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f97d697148a91c19b816f2910cba318", + "name": "editables", + "sha256": "b121e80a4c86387fc7914ba638aa4ce5a917146abb76e84bf7d30620c3dda4ca", + "size": 10259, + "subdir": "linux-64", + "timestamp": 1661189187722, + "version": "0.3" + }, + "editables-0.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f54481ad3d92cf0b7aace019a960563", + "name": "editables", + "sha256": "17292d439b8c2dec6d3ae37d16abf150dd0d5d9d50c82c772849d808c88b332c", + "size": 11993, + "subdir": "linux-64", + "timestamp": 1676822802816, + "version": "0.3" + }, + "editables-0.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63f0b71190f93a6e8edb529008e49309", + "name": "editables", + "sha256": "ff4a923af24ef94ed9077c2e5d74ffcf866da51d5b67df8dda15bf075d14737c", + "size": 10210, + "subdir": "linux-64", + "timestamp": 1661189231151, + "version": "0.3" + }, + "editables-0.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d7733753605fa4f1f4d39dcb67f0069f", + "name": "editables", + "sha256": "42273e49e6135c792f70fa667ea4ed98f3283476b7de4e5c7438cf26917f0839", + "size": 10217, + "subdir": "linux-64", + "timestamp": 1661189250044, + "version": "0.3" + }, + "editables-0.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b78427074f51b2a27a5c4d0a4a4e6aee", + "name": "editables", + "sha256": "9cc2f0aceecc220f438db3a9cb1c827d603483990320b48c25bfc32c1ef9ac19", + "size": 10203, + "subdir": "linux-64", + "timestamp": 1661189211780, + "version": "0.3" + }, + "editdistance-0.5.3-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f1c95f90cd836fd6a3cf6c9711313c0", + "name": "editdistance", + "sha256": "19891b7096af196544ca7eb743ad0d27bdf7ffa6431043962632bd3373fc8719", + "size": 169801, + "subdir": "linux-64", + "timestamp": 1640789751420, + "version": "0.5.3" + }, + "editdistance-0.5.3-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f40b1c47cea9ec97caab6035ac507f8a", + "name": "editdistance", + "sha256": "28f26dd64a25d644fce4ec28ce7d6bcd0fb10e9c2acd67a884976a3d59c1ce0c", + "size": 27933, + "subdir": "linux-64", + "timestamp": 1605215855278, + "version": "0.5.3" + }, + "editdistance-0.5.3-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6cf8d27eb189db2da54b091dddcdd9bc", + "name": "editdistance", + "sha256": "85fb844ce632b07e7361953c3dcbdbaff49756b1f3d972946db11c3c8c3e7eb7", + "size": 28071, + "subdir": "linux-64", + "timestamp": 1605215862920, + "version": "0.5.3" + }, + "editdistance-0.5.3-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2949046064863fc1456cffcfcde202f9", + "name": "editdistance", + "sha256": "fa8d156d3194ed8f474c5ea0fc3b6015e2825a03b87ec5b8f01eb2c24380ac3e", + "size": 28477, + "subdir": "linux-64", + "timestamp": 1605215860816, + "version": "0.5.3" + }, + "editdistance-0.5.3-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01432624d030b48bcb03cf67275a95ba", + "name": "editdistance", + "sha256": "362761bb39d92f0c87e46911979f20bc4685ccaf813c995c98e64e599a16484c", + "size": 27993, + "subdir": "linux-64", + "timestamp": 1605215844145, + "version": "0.5.3" + }, + "editdistance-0.6.1-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad13fcf357c62c704380b1c9b0df93ba", + "name": "editdistance", + "sha256": "83a33b45bbb894afd16fa91b0bb6a319f778eb21feb624cd5453353706f5578e", + "size": 50976, + "subdir": "linux-64", + "timestamp": 1670956874151, + "version": "0.6.1" + }, + "editdistance-0.6.1-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "578e1cbe48e8f68f4c9a8b15157e7e1b", + "name": "editdistance", + "sha256": "8ca6354040d1c08e1f4e09ded72f8ce481b56f3481479841de7437a0be54bdaa", + "size": 48101, + "subdir": "linux-64", + "timestamp": 1676852080355, + "version": "0.6.1" + }, + "editdistance-0.6.1-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "67ce7b8bc6f5fc484ee3b044e759d9a6", + "name": "editdistance", + "sha256": "243add7f3838c1695d740a561c3a514c1983a620026096c3eea2fa4c35df555a", + "size": 50916, + "subdir": "linux-64", + "timestamp": 1670956843590, + "version": "0.6.1" + }, + "editdistance-0.6.1-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd1c6e6dbe4ee0bb2a26841b7f301c54", + "name": "editdistance", + "sha256": "01467ad3d35779c20b047c319fefd4a9ef2e8e9a9e2555a0b4c107b45addd68e", + "size": 50948, + "subdir": "linux-64", + "timestamp": 1670956811013, + "version": "0.6.1" + }, + "editdistance-0.6.1-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0beb58e924a5dfef8b4c0b376b4caa0", + "name": "editdistance", + "sha256": "c7f1e5dbf6e47e9fc3b7895f4d9d831e981ef4cb284c220f188cf83add2657fe", + "size": 51160, + "subdir": "linux-64", + "timestamp": 1670956778531, + "version": "0.6.1" + }, + "efficientnet-1.0.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "keras >=2.2.0", + "keras-applications >=1.0.7", + "python >=3.10,<3.11.0a0", + "scikit-image" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7f09161477405aecba0b41b0073aa477", + "name": "efficientnet", + "sha256": "3c3740a190f3bf00bce94d7d12cc4903b7365ac8932ef2cd3435df105f044e9b", + "size": 29666, + "subdir": "linux-64", + "timestamp": 1640815203846, + "version": "1.0.0" + }, + "efficientnet-1.0.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "keras >=2.2.0", + "keras-applications >=1.0.7", + "python >=3.11,<3.12.0a0", + "scikit-image" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "536485a20ea93efc2daa3ced6e54cc5c", + "name": "efficientnet", + "sha256": "6dfad48f9b8ab889cfd8957ef23483d2f9bb8f271667f80d99c9938da49ca7ff", + "size": 33865, + "subdir": "linux-64", + "timestamp": 1676906026451, + "version": "1.0.0" + }, + "efficientnet-1.0.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "keras >=2.2.0", + "keras-applications >=1.0.7", + "python >=3.6,<3.7.0a0", + "scikit-image" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b5d1941e772e378ae266c442754b1bdd", + "name": "efficientnet", + "sha256": "f5ff5fe3b61e1be385b049cd1eb4db1cf17921744e23c94ecfd02a55b11f5d8f", + "size": 239610, + "subdir": "linux-64", + "timestamp": 1605286709366, + "version": "1.0.0" + }, + "efficientnet-1.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "keras >=2.2.0", + "keras-applications >=1.0.7", + "python >=3.7,<3.8.0a0", + "scikit-image" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4783407a2ea4d12ae6c9603c37481cb3", + "name": "efficientnet", + "sha256": "4cab88316fbe5e2849395abee2f3edca69473a7162db2eef6daaa40b1f9910d8", + "size": 239837, + "subdir": "linux-64", + "timestamp": 1605286719049, + "version": "1.0.0" + }, + "efficientnet-1.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "keras >=2.2.0", + "keras-applications >=1.0.7", + "python >=3.8,<3.9.0a0", + "scikit-image" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1b8c5debf5e234a389abae45e18fc062", + "name": "efficientnet", + "sha256": "ac7585746b596c3463ec4b79ed72e9e95dd6f5bb6844c4723b0491612028eded", + "size": 239823, + "subdir": "linux-64", + "timestamp": 1605286736226, + "version": "1.0.0" + }, + "eigen-3.3.3-h5721d7b_0.conda": { + "build": "h5721d7b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MPL2", + "license_family": "Other", + "md5": "07f50b2951583778b6cd601113fea653", + "name": "eigen", + "sha256": "75d179728d40e4adc474eb8263b34c58a8d8ece2660ae5d2c18e510269b99e97", + "size": 842560, + "subdir": "linux-64", + "timestamp": 1512427311853, + "version": "3.3.3" + }, + "eigen-3.3.5-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MPL2", + "license_family": "Other", + "md5": "9a7bd52039abb7a55bacf49aaefd71cf", + "name": "eigen", + "sha256": "470f6daaf612e317731f1db5284b28dd67f818095ff0838d7df9e46db984f715", + "size": 847998, + "subdir": "linux-64", + "timestamp": 1539475331266, + "version": "3.3.5" + }, + "eigen-3.3.7-hd09550d_1.conda": { + "build": "hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MPL2", + "license_family": "Other", + "md5": "535ad3181bd9b75808983d3585a3ea5a", + "name": "eigen", + "sha256": "4926eb83cdfeaf5c3ad2ff3aaefe0844a12dce94eb3e728bc6e722270b10a196", + "size": 850261, + "subdir": "linux-64", + "timestamp": 1646805514357, + "version": "3.3.7" + }, + "eigen-3.3.7-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MPL2", + "license_family": "Other", + "md5": "89b5e14765b43a28ab6e2b5336c37eb0", + "name": "eigen", + "sha256": "4bbfa915cdd7f25b4736c89fdc5ddde71d4d0924f19212e943a3d20f0b73ca73", + "size": 850493, + "subdir": "linux-64", + "timestamp": 1547227671774, + "version": "3.3.7" + }, + "elasticsearch-5.4.0-py27h91d0d75_0.conda": { + "build": "py27h91d0d75_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "urllib3 >=1.8,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "49e95eb992ec077c0d3478719330a51c", + "name": "elasticsearch", + "sha256": "00a3179fe4a137b187154792869fd543b9312f825c81813f2c76579076655234", + "size": 74190, + "subdir": "linux-64", + "timestamp": 1505742663035, + "version": "5.4.0" + }, + "elasticsearch-5.4.0-py35h40732ba_0.conda": { + "build": "py35h40732ba_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "urllib3 >=1.8,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dcc80552185b38b771bf5bc86a586841", + "name": "elasticsearch", + "sha256": "f7bababb4948f5698db63b68f5f4b0330dd7fc17b9214156708d515a1f17a528", + "size": 73922, + "subdir": "linux-64", + "timestamp": 1505742676872, + "version": "5.4.0" + }, + "elasticsearch-5.4.0-py36hd132294_0.conda": { + "build": "py36hd132294_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "urllib3 >=1.8,<2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "faa2c9637cee8e52d302a37dadf0a106", + "name": "elasticsearch", + "sha256": "2563e9e924a8255a673cf50751ce769c2b05b5e7ec63257a8ec5e9ce9529ff87", + "size": 74810, + "subdir": "linux-64", + "timestamp": 1505742690839, + "version": "5.4.0" + }, + "elasticsearch-6.0.0-py27hb682f61_0.conda": { + "build": "py27hb682f61_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "urllib3 >=1.21.1,<1.23" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6e61d1decacbd7233acf3d6c5c66488c", + "name": "elasticsearch", + "sha256": "56dc5826cd691d8a89fa0b82d18ae9f0e7d23602c2aa28503a0dbaa714569bde", + "size": 74755, + "subdir": "linux-64", + "timestamp": 1511925803760, + "version": "6.0.0" + }, + "elasticsearch-6.0.0-py35he8fa8db_0.conda": { + "build": "py35he8fa8db_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "urllib3 >=1.21.1,<1.23" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "182cc0d7623d97893918b8047fca0dd5", + "name": "elasticsearch", + "sha256": "4a834a696afb9a1602ae4f849ba05986315a57a552962c4d335eb860070eae68", + "size": 77124, + "subdir": "linux-64", + "timestamp": 1511925915481, + "version": "6.0.0" + }, + "elasticsearch-6.0.0-py36h03877a2_0.conda": { + "build": "py36h03877a2_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.23" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "867d37a64531f8a3597544ff881b2702", + "name": "elasticsearch", + "sha256": "0aaabfef8dc18686b0e0545420e37256596b832271ca871ce4bdc1b27e98f8fe", + "size": 75217, + "subdir": "linux-64", + "timestamp": 1511925918172, + "version": "6.0.0" + }, + "elasticsearch-6.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "urllib3 >=1.21.1,<1.23" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "63368c712572c81a4b6e5d722af3f567", + "name": "elasticsearch", + "sha256": "45ac1a7a6abd1b6ea1981c616ec08aca2106af8be370c29975947dea8761e8a5", + "size": 86341, + "subdir": "linux-64", + "timestamp": 1522714919654, + "version": "6.2.0" + }, + "elasticsearch-6.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "urllib3 >=1.21.1,<1.23" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "29e81c1ea9a1cedabee49576377e601e", + "name": "elasticsearch", + "sha256": "1a0a5ceb04d09c96906e67f724fdac682a66e2a64b631d848c75be774200ca80", + "size": 88103, + "subdir": "linux-64", + "timestamp": 1522714650904, + "version": "6.2.0" + }, + "elasticsearch-6.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.23" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "702aca63b386225991d4891b82985d49", + "name": "elasticsearch", + "sha256": "10832fd9bafa058c9e1f86b3bab742d611ae941904d8fbd9544097cbf11dd727", + "size": 86062, + "subdir": "linux-64", + "timestamp": 1522714649716, + "version": "6.2.0" + }, + "elasticsearch-6.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.4.0,<3.0.0", + "urllib3 >=1.21.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "06cc1db1349be54cfcb0c47a0397d89a", + "name": "elasticsearch", + "sha256": "268de57af365a785c8801acae095bae3f29396bc8fbda76e9e5fa05d91bf3e3a", + "size": 88256, + "subdir": "linux-64", + "timestamp": 1529954367978, + "version": "6.3.0" + }, + "elasticsearch-6.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.4.0,<3.0.0", + "urllib3 >=1.21.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e0edcb1d3e774b34d221b88f152b23c5", + "name": "elasticsearch", + "sha256": "951df0c2c7f9dca48fc1ce5d6849765684b8277fc1cae45c90af73fa172f92f5", + "size": 89800, + "subdir": "linux-64", + "timestamp": 1529954444381, + "version": "6.3.0" + }, + "elasticsearch-6.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.4.0,<3.0.0", + "urllib3 >=1.21.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d8f73bb03257d2d3ca563071db9377b1", + "name": "elasticsearch", + "sha256": "bc361ceadbd27f891c517383110439c273bf05f9e7f28bc9edd5e9fc425903d1", + "size": 87898, + "subdir": "linux-64", + "timestamp": 1529954355900, + "version": "6.3.0" + }, + "elasticsearch-6.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.4.0,<3.0.0", + "urllib3 >=1.21.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a9d8514ca0b179071a41e5f382c1a85e", + "name": "elasticsearch", + "sha256": "d580a40ec876158d9b1c7f44212820eb5019b53cf4bceeaf9dc3a4ff0fd7c42f", + "size": 89425, + "subdir": "linux-64", + "timestamp": 1530873560094, + "version": "6.3.0" + }, + "elasticsearch-6.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.4.0,<3.0.0", + "urllib3 >=1.21.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7a329367e106a31874f124395e819b23", + "name": "elasticsearch", + "sha256": "aed9b3c3e9183a9c1c6953b49deff5a12a9be81aba0b0402d28d05e00ca69834", + "size": 86989, + "subdir": "linux-64", + "timestamp": 1535423673672, + "version": "6.3.1" + }, + "elasticsearch-6.3.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.4.0,<3.0.0", + "urllib3 >=1.21.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9d3134d4d349b86fedfe670356e85f17", + "name": "elasticsearch", + "sha256": "29f982d068bf85f32bc1a203ab86d3d8ed9c89bcad19c5dc9073f4adefd97f39", + "size": 87013, + "subdir": "linux-64", + "timestamp": 1535423682885, + "version": "6.3.1" + }, + "elasticsearch-6.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.4.0,<3.0.0", + "urllib3 >=1.21.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "67aef92bb170f14b5247fcca9369dd61", + "name": "elasticsearch", + "sha256": "6fe57cf63f4b209763557e512e6a24ff6c304a2161cfdae0a8618e505f4a9844", + "size": 86724, + "subdir": "linux-64", + "timestamp": 1535423621257, + "version": "6.3.1" + }, + "elasticsearch-6.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.4.0,<3.0.0", + "urllib3 >=1.21.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5f4c624d6c7364b0f141f4df851d93be", + "name": "elasticsearch", + "sha256": "19eda98361c500d35c26f730142376346f1b3e807c5bb7d632529879001e3258", + "size": 86755, + "subdir": "linux-64", + "timestamp": 1535423745322, + "version": "6.3.1" + }, + "elasticsearch-async-5.2.0-py35hb077873_0.conda": { + "build": "py35hb077873_0", + "build_number": 0, + "depends": [ + "aiohttp", + "elasticsearch >=5.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e416f06d6a18032e35f6ddfc04da135e", + "name": "elasticsearch-async", + "sha256": "c9584cdfe699b3cebde5e3ca567fd8fd3089657a32eb346616ec7bc5dcc44200", + "size": 17366, + "subdir": "linux-64", + "timestamp": 1506937337079, + "version": "5.2.0" + }, + "elasticsearch-async-5.2.0-py36h6fd203e_0.conda": { + "build": "py36h6fd203e_0", + "build_number": 0, + "depends": [ + "aiohttp", + "elasticsearch >=5.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a267af2598d581ac774ca517f28b09d8", + "name": "elasticsearch-async", + "sha256": "9bb8cf9153152d34b7a512889c49e39304c402a39353aa61e26c10896ae4df12", + "size": 17239, + "subdir": "linux-64", + "timestamp": 1506937339392, + "version": "5.2.0" + }, + "elasticsearch-async-6.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aiohttp", + "elasticsearch >=6.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6a211a520ec86e7d1860cc06029a23e8", + "name": "elasticsearch-async", + "sha256": "e0b6cc0c050f4d0c27252b05838c61cf84460e9184d54b369ada27804310bd31", + "size": 18424, + "subdir": "linux-64", + "timestamp": 1524107738617, + "version": "6.0.0" + }, + "elasticsearch-async-6.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp", + "elasticsearch >=6.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4c28d26533d669711fa850ed759a2a33", + "name": "elasticsearch-async", + "sha256": "2ba63989d5ea8473e9c7b4762ae64818ea6f8b9f9e139f6068368d13e8421259", + "size": 18329, + "subdir": "linux-64", + "timestamp": 1524107734047, + "version": "6.0.0" + }, + "elasticsearch-async-6.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ac7e3129433237bc70b893bf6c63d6fe", + "name": "elasticsearch-async", + "sha256": "cc9b0f5bded3f0e635e083f5faec88cfc2ae2257d72a473b23e0911bf864b5a4", + "size": 20439, + "subdir": "linux-64", + "timestamp": 1529954952406, + "version": "6.1.0" + }, + "elasticsearch-async-6.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4652712e48bf9267971f080936f7c220", + "name": "elasticsearch-async", + "sha256": "b34b4b4accd455d1e6dbcff7975d99bc01f2df106a64354bb40618458d630e9d", + "size": 20402, + "subdir": "linux-64", + "timestamp": 1529954760209, + "version": "6.1.0" + }, + "elasticsearch-async-6.2.0-py310h06a4308_1000.conda": { + "build": "py310h06a4308_1000", + "build_number": 1000, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "82cb27149943a2482fd032548c6bdfe7", + "name": "elasticsearch-async", + "sha256": "19e2161494db78709a37ee2a167a32fee116847bc67d65781e74224822eac7c6", + "size": 20574, + "subdir": "linux-64", + "timestamp": 1640813493304, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4ceafa4b06d9817da95f6d5480350d07", + "name": "elasticsearch-async", + "sha256": "07bfd6efa98c4a3ed879f274fa3f526711b77939809b67070486930d81047263", + "size": 20539, + "subdir": "linux-64", + "timestamp": 1535801297600, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6983fcf8db4ec9ed0768108a11f2a6ac", + "name": "elasticsearch-async", + "sha256": "f7885b264e556b1f2cf187fa87ac8eb36afb32532d21ce2596a9cd4eb47d6640", + "size": 20501, + "subdir": "linux-64", + "timestamp": 1535801280173, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py36_1000.conda": { + "build": "py36_1000", + "build_number": 1000, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0e7d65b43ff81318b59b17ae94bd5444", + "name": "elasticsearch-async", + "sha256": "6e1c19e9a8f7b5d02f6b484994b4420aa37a71a51ce8f34d48a33b74e65d9969", + "size": 21960, + "subdir": "linux-64", + "timestamp": 1564163149924, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py36h06a4308_1000.conda": { + "build": "py36h06a4308_1000", + "build_number": 1000, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a19bbff222362cb074a0d15d8e520107", + "name": "elasticsearch-async", + "sha256": "ba13fb3ecf8207e54eac5928af7a2a66f5aaccb702f8c9b78422d62c4b6e7bc1", + "size": 22206, + "subdir": "linux-64", + "timestamp": 1614006176532, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4f35a1c8ecf62b5ba6a13b69db376e67", + "name": "elasticsearch-async", + "sha256": "2b396f371833506b252e52b6efc7e10a5f398391f7d556a9c97c91cd115b1082", + "size": 20543, + "subdir": "linux-64", + "timestamp": 1535801297781, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py37_1000.conda": { + "build": "py37_1000", + "build_number": 1000, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2911d87957230a119f2cfb99a13f00ff", + "name": "elasticsearch-async", + "sha256": "dc691860c18b8afca14eb6cd8f65f8874543f42e2d4322380386aec0d106d832", + "size": 21989, + "subdir": "linux-64", + "timestamp": 1564163138400, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py37h06a4308_1000.conda": { + "build": "py37h06a4308_1000", + "build_number": 1000, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0e4567c9ae0ada18c2144e6d9971cdb2", + "name": "elasticsearch-async", + "sha256": "5c77c245119c5d5656cc59f949087c59b7381d52937372ba0b3dcae8f43bbedb", + "size": 22213, + "subdir": "linux-64", + "timestamp": 1614007047565, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py38_1000.conda": { + "build": "py38_1000", + "build_number": 1000, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e1cd601e20ee49b9ad36ed2c857f7de4", + "name": "elasticsearch-async", + "sha256": "fbda5986b94f583190376e7024a03d05cbae21f7de730abeb1322fe81de0cc8b", + "size": 22392, + "subdir": "linux-64", + "timestamp": 1591789201537, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py38h06a4308_1000.conda": { + "build": "py38h06a4308_1000", + "build_number": 1000, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4d18168210936b12bb15665b478b9fa3", + "name": "elasticsearch-async", + "sha256": "060086a74c199b160c7e8d5a866d8126459edd713ff9e5ef413ac92e3734d9ea", + "size": 22364, + "subdir": "linux-64", + "timestamp": 1614006170305, + "version": "6.2.0" + }, + "elasticsearch-async-6.2.0-py39h06a4308_1000.conda": { + "build": "py39h06a4308_1000", + "build_number": 1000, + "depends": [ + "aiohttp", + "async-timeout", + "elasticsearch >=6.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6a6b6d863c21d406d89b345ff14318ca", + "name": "elasticsearch-async", + "sha256": "aa7c257dd25db5c37ce937738fddac5b783cbb6911480d3b3c8c1c8140dfe03b", + "size": 22383, + "subdir": "linux-64", + "timestamp": 1614007043041, + "version": "6.2.0" + }, + "elasticsearch-dsl-5.3.0-py27h02dbe23_0.conda": { + "build": "py27h02dbe23_0", + "build_number": 0, + "depends": [ + "elasticsearch >=5.0.0,<6.0.0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d0787718150566366471c6e697f65a8f", + "name": "elasticsearch-dsl", + "sha256": "4d3caaccbc4c4d5b45ee055e4ddc31beba8fabf0c996161346af7397a34c328e", + "size": 72084, + "subdir": "linux-64", + "timestamp": 1505742705131, + "version": "5.3.0" + }, + "elasticsearch-dsl-5.3.0-py35h5271a11_0.conda": { + "build": "py35h5271a11_0", + "build_number": 0, + "depends": [ + "elasticsearch >=5.0.0,<6.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7f8fac90e5c395b8e39471b2393235e2", + "name": "elasticsearch-dsl", + "sha256": "8a003e672bcb28bef2f3d71f0bcf8181ba9a13e9a3b31afa5854f1cf4b81d794", + "size": 72839, + "subdir": "linux-64", + "timestamp": 1505742718719, + "version": "5.3.0" + }, + "elasticsearch-dsl-5.3.0-py36h024d9ff_0.conda": { + "build": "py36h024d9ff_0", + "build_number": 0, + "depends": [ + "elasticsearch >=5.0.0,<6.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3ade53f5d69f2286f73609a0d7add835", + "name": "elasticsearch-dsl", + "sha256": "d7baad87f96dd551e898a8416bdacdc661b40564473a48199e6e533e38d6a52f", + "size": 72123, + "subdir": "linux-64", + "timestamp": 1505742732352, + "version": "5.3.0" + }, + "elasticsearch-dsl-6.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9701d1460236b88b0f8db6b9b76641f3", + "name": "elasticsearch-dsl", + "sha256": "896ffb0b4c554cbc93be0eaa28c62d85422c804896b680c16bccfafd6476d49c", + "size": 76276, + "subdir": "linux-64", + "timestamp": 1517132973106, + "version": "6.1.0" + }, + "elasticsearch-dsl-6.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "39f156e84ff6c71dbfcce4eb1b495222", + "name": "elasticsearch-dsl", + "sha256": "938301ae2cd60f8b7872f31ea728abcf74bcea3b8688cf10c39f31f9ce1ec653", + "size": 77125, + "subdir": "linux-64", + "timestamp": 1517132983409, + "version": "6.1.0" + }, + "elasticsearch-dsl-6.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "35ad69025e82f53bb4e5d4826967391b", + "name": "elasticsearch-dsl", + "sha256": "85f5a14d8d77e7fab5b31655306d0888204cb9270dddfd4a56befd77c95c18f0", + "size": 76552, + "subdir": "linux-64", + "timestamp": 1517132980724, + "version": "6.1.0" + }, + "elasticsearch-dsl-6.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1b90b76fb8dc9afdd44059179cec7e39", + "name": "elasticsearch-dsl", + "sha256": "ef54892cd7c92f02c442c46d101d2d35b48e6871860e36d708176e6318e8cbad", + "size": 76601, + "subdir": "linux-64", + "timestamp": 1530873591111, + "version": "6.1.0" + }, + "elasticsearch-dsl-6.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a202ced65b1bcc6faf6160b423fef26d", + "name": "elasticsearch-dsl", + "sha256": "8192aea971ff925e1897a4feab40a4acc2f47996f25400d35c2fb52baad6aa00", + "size": 76799, + "subdir": "linux-64", + "timestamp": 1535499615566, + "version": "6.2.1" + }, + "elasticsearch-dsl-6.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f90d4dddf72190a8f219b9cbce066c02", + "name": "elasticsearch-dsl", + "sha256": "840e93e682d8dcdbb4b265bfeb29a3412bce1159e38dc88b23f542dd09a6ccff", + "size": 80273, + "subdir": "linux-64", + "timestamp": 1535499618318, + "version": "6.2.1" + }, + "elasticsearch-dsl-6.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "55dd737745610cc9357b5534ed3712d0", + "name": "elasticsearch-dsl", + "sha256": "e4ed98f0d4923cddeb0f9e787deb92ddd4704f260f87cf51d679a4334f3947fb", + "size": 78306, + "subdir": "linux-64", + "timestamp": 1535499589552, + "version": "6.2.1" + }, + "elasticsearch-dsl-6.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3748549d345894ead2b3da139d223355", + "name": "elasticsearch-dsl", + "sha256": "6f118e00f2ad8832793d3d2d2c2cf5fd355ba84bb6bfe8a2a5b5f9cf62ca3413", + "size": 78500, + "subdir": "linux-64", + "timestamp": 1535499629312, + "version": "6.2.1" + }, + "elasticsearch-dsl-6.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "59e0ff45b70ca7a4c7e17a212f3d53c8", + "name": "elasticsearch-dsl", + "sha256": "df8e0d15a6480263a06fc5e3758f345a9eba4a11914099fb337e3875cd4f36f0", + "size": 85740, + "subdir": "linux-64", + "timestamp": 1543521723446, + "version": "6.3.0" + }, + "elasticsearch-dsl-6.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a0823fe6f8665ce28864db3f29c89494", + "name": "elasticsearch-dsl", + "sha256": "5cae81f3dc5b86d66b4d9ed89970203967bceeb6dbd1bfba54c7352b280d074b", + "size": 88737, + "subdir": "linux-64", + "timestamp": 1543521765786, + "version": "6.3.0" + }, + "elasticsearch-dsl-6.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1e22b91b45e6f6c6aba5f0e96d81b742", + "name": "elasticsearch-dsl", + "sha256": "736c556e17ec3ce23c14e8667460d0c38ef6b2668ee4354047856df5d27c805a", + "size": 87740, + "subdir": "linux-64", + "timestamp": 1543521724676, + "version": "6.3.0" + }, + "elasticsearch-dsl-6.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "99b529a3af295d3c9f3aea0d23b36ee6", + "name": "elasticsearch-dsl", + "sha256": "0d904be71bb9a54195eab3293ef73a49e0f7070f4a5ccee48c5023b6ce5fa709", + "size": 84984, + "subdir": "linux-64", + "timestamp": 1545116968299, + "version": "6.3.1" + }, + "elasticsearch-dsl-6.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2ecf17a8d32bdb9f6cc80f82bd7be490", + "name": "elasticsearch-dsl", + "sha256": "3105990748e3e85f5bbcff9874f2367c297dfb9bc75ae14eca3b472cf30e79b2", + "size": 86645, + "subdir": "linux-64", + "timestamp": 1545116997745, + "version": "6.3.1" + }, + "elasticsearch-dsl-6.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "046a4e1e4959a96a9af99ac1ec07b7d6", + "name": "elasticsearch-dsl", + "sha256": "c0c2a5d9638bfebf6049a5e264c1d89586b9a59583ce3e8ad7f0996699432e66", + "size": 85627, + "subdir": "linux-64", + "timestamp": 1545117016721, + "version": "6.3.1" + }, + "elasticsearch-dsl-7.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a1e9dc33d9d6d92966149b982ac13165", + "name": "elasticsearch-dsl", + "sha256": "6312003c933ed45055ed9b9b9fea3a496c73be1e51fb6b9f85258f4b5f074b6d", + "size": 91481, + "subdir": "linux-64", + "timestamp": 1558559646033, + "version": "7.0.0" + }, + "elasticsearch-dsl-7.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c9cfce945dcc22f1df5cc74b11819166", + "name": "elasticsearch-dsl", + "sha256": "e6b1fb722b0de6599f3a33bb792899d17b2814e77857a2b59d328bef52a253d0", + "size": 92969, + "subdir": "linux-64", + "timestamp": 1558559671862, + "version": "7.0.0" + }, + "elasticsearch-dsl-7.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c3bc8078d9232f337fce515107e0df99", + "name": "elasticsearch-dsl", + "sha256": "914485d7ba2de7561689c77ac622a640f18abca519eefe17e79874b168bb25bc", + "size": 93148, + "subdir": "linux-64", + "timestamp": 1558559585935, + "version": "7.0.0" + }, + "elasticsearch-dsl-7.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2574fe6f8192c8fa7435eed8d5b86c19", + "name": "elasticsearch-dsl", + "sha256": "2e4de078435a15ed3eff82006697b8ec0e96595d2bbb6287e165eb76adb94e35", + "size": 89928, + "subdir": "linux-64", + "timestamp": 1592217438395, + "version": "7.2.1" + }, + "elasticsearch-dsl-7.2.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "514fa955c8441f0253b069f6254548d2", + "name": "elasticsearch-dsl", + "sha256": "6454c7c2e59c9174005a78f345f5ffba6617e362c571812ba0f11bcd449593f0", + "size": 91271, + "subdir": "linux-64", + "timestamp": 1614249818877, + "version": "7.2.1" + }, + "elasticsearch-dsl-7.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8ee88a6db38430737023b41a580e356f", + "name": "elasticsearch-dsl", + "sha256": "2a258c1d2e7c158e176573f943f013a1f78623e792c735ee1d276761efee91b6", + "size": 90868, + "subdir": "linux-64", + "timestamp": 1592217627572, + "version": "7.2.1" + }, + "elasticsearch-dsl-7.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "83b7a952f4fcd8493c5c46cad7dc299a", + "name": "elasticsearch-dsl", + "sha256": "3e435c16da6c8be8b49d1e7e21a4b2840352c18b11c4aa141ddac01bdc5c711b", + "size": 90250, + "subdir": "linux-64", + "timestamp": 1614249819397, + "version": "7.2.1" + }, + "elasticsearch-dsl-7.2.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "032109ca6a940ac74e780becd2a0078e", + "name": "elasticsearch-dsl", + "sha256": "8c2e7dbf5e54a146b96b16761b0567220a162dfbbe4c213efe43641bce3f0b47", + "size": 90173, + "subdir": "linux-64", + "timestamp": 1592217615277, + "version": "7.2.1" + }, + "elasticsearch-dsl-7.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5321f6b0a5c06eebd8972ce2510babcb", + "name": "elasticsearch-dsl", + "sha256": "e125a9d1591eccff349a47bc645379e38d1360e2a84cd2e55164aab36bce3bf5", + "size": 91934, + "subdir": "linux-64", + "timestamp": 1614249828088, + "version": "7.2.1" + }, + "elasticsearch-dsl-7.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cf0fedd01cd614d706f5acb156ce9a2f", + "name": "elasticsearch-dsl", + "sha256": "71ea9a177c23bd2181336ef3a37d3bf87a551d8e19e10e934f9bb6e66d2cf15f", + "size": 90684, + "subdir": "linux-64", + "timestamp": 1614249821572, + "version": "7.2.1" + }, + "elasticsearch-dsl-7.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "78152fd0eafe5ee6579cb37e40c466d4", + "name": "elasticsearch-dsl", + "sha256": "e484dd90f46559cfd7b7be4fa25b11c5c609b63236bd905ba5b8dd8489fef7b6", + "size": 90739, + "subdir": "linux-64", + "timestamp": 1600373959055, + "version": "7.3.0" + }, + "elasticsearch-dsl-7.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c1c74a044c88604e49fa22c0539bb0f9", + "name": "elasticsearch-dsl", + "sha256": "99725af6c5cd8c937bc1386e0cd04b2525bbd2eafaeecdf5c81222e4d30ad479", + "size": 90839, + "subdir": "linux-64", + "timestamp": 1600373976308, + "version": "7.3.0" + }, + "elasticsearch-dsl-7.3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "elasticsearch >=6.0.0,<7.0.0", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1a64f114beec790cd4f92e5fd1d04009", + "name": "elasticsearch-dsl", + "sha256": "5d4f2719da03ed577fc679d8228954d1e39c835d5490d48f2902d503b8a0dabe", + "size": 91412, + "subdir": "linux-64", + "timestamp": 1600373990905, + "version": "7.3.0" + }, + "elasticsearch-dsl-7.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=7.0.0,<8.0.0", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ea0f67ea49094484fddcc0a0f88b5798", + "name": "elasticsearch-dsl", + "sha256": "c572776208cea2e85d96e3aee1a0c4b93c22d6f817078b3101ed21bb15fb58d7", + "size": 92338, + "subdir": "linux-64", + "timestamp": 1640789769520, + "version": "7.4.0" + }, + "elasticsearch-dsl-7.4.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=7.0.0,<8.0.0", + "python >=3.11,<3.12.0a0", + "python-dateutil", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2aafa3ab58ea5eb15c6e39638fbbc1a1", + "name": "elasticsearch-dsl", + "sha256": "bf53be499fa3718150ebfab5a9f50e8e587463b199d2f0c4cd49155db56b41ce", + "size": 120597, + "subdir": "linux-64", + "timestamp": 1676852109148, + "version": "7.4.0" + }, + "elasticsearch-dsl-7.4.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=7.0.0,<8.0.0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "28c03e6e8a9fa72290bfe230880520e2", + "name": "elasticsearch-dsl", + "sha256": "a3bee8101359d98d47ea707191b6af2ac746009e048a870f552f183bbd5bdcd6", + "size": 90792, + "subdir": "linux-64", + "timestamp": 1626441080839, + "version": "7.4.0" + }, + "elasticsearch-dsl-7.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=7.0.0,<8.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3d4bdf5aac75c0f32019e49740e3dfdb", + "name": "elasticsearch-dsl", + "sha256": "d23c5bab31421558154cded29c22e541e5a6d4cef46c09abc345dcf84e5b580e", + "size": 90832, + "subdir": "linux-64", + "timestamp": 1626441077427, + "version": "7.4.0" + }, + "elasticsearch-dsl-7.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=7.0.0,<8.0.0", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1a58b50fa0b2b64d2a87068b29cb9647", + "name": "elasticsearch-dsl", + "sha256": "e7a4dc39f15f45ae3972455eded34e97eb9badb5e6db1b58e95814f4628b5bdd", + "size": 91111, + "subdir": "linux-64", + "timestamp": 1626441027006, + "version": "7.4.0" + }, + "elasticsearch-dsl-7.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "elasticsearch >=7.0.0,<8.0.0", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "49bbd5891137fd1b410af24338803d3b", + "name": "elasticsearch-dsl", + "sha256": "8059009da32d3d6841ee9f3a9cf236b9365ae55f26b918235cc29abb9816ab4a", + "size": 92183, + "subdir": "linux-64", + "timestamp": 1626433917421, + "version": "7.4.0" + }, + "email-validator-1.2.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "idna >=2.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "079f1d3f0fd916b42d8eac1f0e20e1fd", + "name": "email-validator", + "sha256": "6faee91da6debd707b0cdc339501d04397d17a788070a631c046dff89e3e03c1", + "size": 33484, + "subdir": "linux-64", + "timestamp": 1659798212586, + "version": "1.2.1" + }, + "email-validator-1.2.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "idna >=2.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "ed76816f0ed0966bcba370be949ac6cb", + "name": "email-validator", + "sha256": "4f6edb3919cbb8e80b048bd4e0134276f68a6e834827fadabb1b58864396b1f1", + "size": 37886, + "subdir": "linux-64", + "timestamp": 1676827123876, + "version": "1.2.1" + }, + "email-validator-1.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "idna >=2.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "1157062cf36fef87daf333c9c2832591", + "name": "email-validator", + "sha256": "eacfb5adc19e1d32c089290a6b0097eff81c41e9b9e029d9eb419101857cda82", + "size": 33312, + "subdir": "linux-64", + "timestamp": 1659798336634, + "version": "1.2.1" + }, + "email-validator-1.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "idna >=2.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "fe776e001b73702dfde5001bd0e7ff94", + "name": "email-validator", + "sha256": "fa53adcacb2cb7b3b16d315efe0e482e0090bc6177ff24c67145551d86e775c0", + "size": 33507, + "subdir": "linux-64", + "timestamp": 1659798254382, + "version": "1.2.1" + }, + "email-validator-1.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "idna >=2.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "36f28415ed4d308301938dc01eef14d0", + "name": "email-validator", + "sha256": "c8e02b56397aa4949d51e182dc41243689dd940eaaa74931d9ceb38488c461b9", + "size": 33460, + "subdir": "linux-64", + "timestamp": 1659798297040, + "version": "1.2.1" + }, + "emfile-0.3.0-py310h2f386ee_0.conda": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b766aa3ab21cf6a82c6b23fe4325c9f0", + "name": "emfile", + "sha256": "042aa79e16fd4ed7f0ff0cd31190b18759eb8f9c8f394f917d48341d05f023b1", + "size": 12009, + "subdir": "linux-64", + "timestamp": 1679385336872, + "version": "0.3.0" + }, + "emfile-0.3.0-py311h92b7b1e_0.conda": { + "build": "py311h92b7b1e_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c572d06372a04c80844e7157df6e4e8b", + "name": "emfile", + "sha256": "a88d8fb576582fbf576d2f1c660ea44d6c9a469ceb0dc6e0c53ebd2309e5c5f4", + "size": 13167, + "subdir": "linux-64", + "timestamp": 1679385302171, + "version": "0.3.0" + }, + "emfile-0.3.0-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "23342ee1f5ee744b731fd04bbdb12c53", + "name": "emfile", + "sha256": "6e6deb936301b1b6ce37e693830dae5e892e3d4d318dcfa3025ff82fff487663", + "size": 11604, + "subdir": "linux-64", + "timestamp": 1679385405750, + "version": "0.3.0" + }, + "emfile-0.3.0-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3db87ef0caffcea738ffa2cb6dacbf06", + "name": "emfile", + "sha256": "a8ab9fa7619eb0b2b758d52ecdeeaaacd25f5137945d16ad73b55d40ee5df62f", + "size": 11620, + "subdir": "linux-64", + "timestamp": 1679385370804, + "version": "0.3.0" + }, + "enaml-0.10.2-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "atom >=0.4.1", + "future", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ply >=3.4", + "pyqt", + "python >=2.7,<2.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "bdd7eaa2c290a1cae63df42527c3b4bf", + "name": "enaml", + "sha256": "de3f45e502ad1cdac94854ccc3432091562aa9d8908e179143bea140a87c37ae", + "size": 870261, + "subdir": "linux-64", + "timestamp": 1519763912645, + "version": "0.10.2" + }, + "enaml-0.10.2-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "atom >=0.4.1", + "future", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ply >=3.4", + "pyqt", + "python >=3.5,<3.6.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "325430ed4318ad90f65f40db869fe07d", + "name": "enaml", + "sha256": "c8a6627ebce720a5390d07a9cfb533c7db28d2ab305514cf2b8098364cd440c3", + "size": 878174, + "subdir": "linux-64", + "timestamp": 1519764012253, + "version": "0.10.2" + }, + "enaml-0.10.2-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "atom >=0.4.1", + "future", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ply >=3.4", + "pyqt", + "python >=3.6,<3.7.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b87cb8b4a4a927d50b62a35a09dd4bc3", + "name": "enaml", + "sha256": "09ff056b34b4ad892c91b52a63ad73fd387cc1875c86f98980a0c73fcbaf8a19", + "size": 886145, + "subdir": "linux-64", + "timestamp": 1519764006329, + "version": "0.10.2" + }, + "enaml-0.10.2-py37hf484d3e_0.conda": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "atom >=0.4.1", + "future", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ply >=3.4", + "pyqt", + "python >=3.7,<3.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "419a1d478474a8c09bce57b232e7d91f", + "name": "enaml", + "sha256": "ba28224c32798402e8f11a6b72513926c84b9cf59fadc2a8db2750fe5c1ee333", + "size": 865004, + "subdir": "linux-64", + "timestamp": 1530873751740, + "version": "0.10.2" + }, + "enaml-0.10.3-py27hfd86e86_0.conda": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=2.7,<2.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d15e932428fbb0b159854d1712be9f2d", + "name": "enaml", + "sha256": "cb3346b788921584fdbbb12e7d86d4391fa0c1e16eaba52ca7978312f51bfdd5", + "size": 789781, + "subdir": "linux-64", + "timestamp": 1552414279515, + "version": "0.10.3" + }, + "enaml-0.10.3-py27hfd86e86_1.conda": { + "build": "py27hfd86e86_1", + "build_number": 1, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=2.7,<2.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6c8e3700028739ef8a2af1492260fb00", + "name": "enaml", + "sha256": "5f58016b0dcf03e4f6b1147225fd9782bf15a1dc7ab8f77bc39e1be2203afbad", + "size": 765982, + "subdir": "linux-64", + "timestamp": 1564163640977, + "version": "0.10.3" + }, + "enaml-0.10.3-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.6,<3.7.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b3332ca06d7157963f90c7679c4e91bf", + "name": "enaml", + "sha256": "76dcda4152f66ceb64d154ccee26e81fe4e3345f03dec4f26093e8a4dde0dffb", + "size": 769817, + "subdir": "linux-64", + "timestamp": 1552414190430, + "version": "0.10.3" + }, + "enaml-0.10.3-py36hfd86e86_1.conda": { + "build": "py36hfd86e86_1", + "build_number": 1, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.6,<3.7.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c8eed90313c6743e86500f86cd9d287d", + "name": "enaml", + "sha256": "c709763c21217d0737804a3eede96b2e16bf7c39b8427840766b0e33bb21da82", + "size": 781857, + "subdir": "linux-64", + "timestamp": 1564163636300, + "version": "0.10.3" + }, + "enaml-0.10.3-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.7,<3.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "90dbc47d323c94c29b9e4a09b2cdd9ab", + "name": "enaml", + "sha256": "0e0ed9a760d2c4e1fc5b882c1e4faa947733abd361eb49832c5ad1f15846154c", + "size": 757588, + "subdir": "linux-64", + "timestamp": 1552412083425, + "version": "0.10.3" + }, + "enaml-0.10.3-py37hfd86e86_1.conda": { + "build": "py37hfd86e86_1", + "build_number": 1, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.7,<3.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ab2a39f8bb40e358a71052a25e6a4db2", + "name": "enaml", + "sha256": "72cbf6aa93520c9709a6160ec3766003073006a40ec4fad5eb1ff8c9f1fce00f", + "size": 769046, + "subdir": "linux-64", + "timestamp": 1564163640802, + "version": "0.10.3" + }, + "enaml-0.10.4-py27hfd86e86_0.conda": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=2.7,<2.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "900a2afbeef1c3e53e1bb665305bce0e", + "name": "enaml", + "sha256": "42796308a36045d2449bd5e6cea2d20b79bb1c31d96ccec96cef765bb94eebe9", + "size": 768472, + "subdir": "linux-64", + "timestamp": 1569368677989, + "version": "0.10.4" + }, + "enaml-0.10.4-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.6,<3.7.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6e75ca3051b85a71c4b17cc62f8e4c5e", + "name": "enaml", + "sha256": "50d1b8d5afea5f747e1f5e531f8d09d0678f62445b431fe9de50d980c0e78a16", + "size": 784035, + "subdir": "linux-64", + "timestamp": 1569368678938, + "version": "0.10.4" + }, + "enaml-0.10.4-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.7,<3.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e6fb575f3d21ed0c157a93e944fe3505", + "name": "enaml", + "sha256": "b05b4f5d02b376eba17c870a4967a7393d0b74325bbe0b638361db1501a649f4", + "size": 783382, + "subdir": "linux-64", + "timestamp": 1569368665669, + "version": "0.10.4" + }, + "enaml-0.10.4-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.4.2", + "kiwisolver >=1.0.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.8,<3.9.0a0", + "qtpy >=1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b878546c530e17d1f0eba521124da1cf", + "name": "enaml", + "sha256": "0293a762f1425bf55e2a1e033b46554c62e3f6435df80a768349f4a511b13f81", + "size": 786506, + "subdir": "linux-64", + "timestamp": 1574251227828, + "version": "0.10.4" + }, + "enaml-0.11.1-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.5.0", + "bytecode", + "kiwisolver >=1.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.6,<3.7.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f44efb58f1a2cfc99331792e19093aec", + "name": "enaml", + "sha256": "b2dcb9f7d392e0a1b35ce4400d29097494561d15b6a764a6e49c912c6c311ef1", + "size": 748605, + "subdir": "linux-64", + "timestamp": 1591183494714, + "version": "0.11.1" + }, + "enaml-0.11.1-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.5.0", + "bytecode", + "kiwisolver >=1.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.7,<3.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5210e666c026b6a3439b3235c8ff8b5a", + "name": "enaml", + "sha256": "5190579f59b682da814e1ebe6f0b5131416e043b649ec288645c29943a9fb75f", + "size": 738208, + "subdir": "linux-64", + "timestamp": 1591183492872, + "version": "0.11.1" + }, + "enaml-0.11.1-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.5.0", + "bytecode", + "kiwisolver >=1.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.8,<3.9.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88d858acebe41d7727789dcdbac4ba05", + "name": "enaml", + "sha256": "bd810905b6a9afeaf173b0a718792653d0a744ffbf14547592c10ec146c6fcf5", + "size": 750556, + "subdir": "linux-64", + "timestamp": 1591183495192, + "version": "0.11.1" + }, + "enaml-0.11.2-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.5.0", + "bytecode", + "kiwisolver >=1.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.6,<3.7.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bbcd707e28d08daadb98a421414f1e93", + "name": "enaml", + "sha256": "1f5607c923195e51941df7f3e2ea52f7347268c899714485490cf5f55c936c70", + "size": 739099, + "subdir": "linux-64", + "timestamp": 1592217650761, + "version": "0.11.2" + }, + "enaml-0.11.2-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.5.0", + "bytecode", + "kiwisolver >=1.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.7,<3.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "80b6e46c53bb64e3b09efae200b0ce3f", + "name": "enaml", + "sha256": "0f0a97446097f09d2e53037da003e29dc48482f19cf004911c1a01f46e0db2a4", + "size": 747208, + "subdir": "linux-64", + "timestamp": 1592217867908, + "version": "0.11.2" + }, + "enaml-0.11.2-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "atom >=0.5.0", + "bytecode", + "kiwisolver >=1.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.8,<3.9.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "600d3f999b6293358759a4db3509a1d0", + "name": "enaml", + "sha256": "e321c1788bebdc7831664b91ecf93c48e5e76c97b580a119160fc771737bc2ae", + "size": 752690, + "subdir": "linux-64", + "timestamp": 1592217826004, + "version": "0.11.2" + }, + "enaml-0.12.0-py36hff7bd54_0.conda": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "atom >=0.6.0", + "bytecode", + "kiwisolver >=1.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.6,<3.7.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "59783b55c20415103f4d35eb4715e8c2", + "name": "enaml", + "sha256": "32912fcfd30bbb63b7c80c287a0d341f344306d6a5132c561a39ae8c823ee046", + "size": 695080, + "subdir": "linux-64", + "timestamp": 1617707984313, + "version": "0.12.0" + }, + "enaml-0.12.0-py37hff7bd54_0.conda": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "atom >=0.6.0", + "bytecode", + "kiwisolver >=1.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.7,<3.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6d7dae7743ae47a9241169966d74f4c4", + "name": "enaml", + "sha256": "83ef7828bf208e5d6e2efe3270bb86a170c08f25f6e4b17105839b41184214a0", + "size": 687525, + "subdir": "linux-64", + "timestamp": 1617708000761, + "version": "0.12.0" + }, + "enaml-0.12.0-py38hff7bd54_0.conda": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "atom >=0.6.0", + "bytecode", + "kiwisolver >=1.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.8,<3.9.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e58ef87d691548452ad3e65e15bf2df4", + "name": "enaml", + "sha256": "782971be0502c18b518d4cfcc475b05c23073c3b540474b31a8956ac4d2fc6fc", + "size": 691390, + "subdir": "linux-64", + "timestamp": 1617707328960, + "version": "0.12.0" + }, + "enaml-0.12.0-py39hff7bd54_0.conda": { + "build": "py39hff7bd54_0", + "build_number": 0, + "depends": [ + "atom >=0.6.0", + "bytecode", + "kiwisolver >=1.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.9,<3.10.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a7b8521740f14b355accedcf200d1ba8", + "name": "enaml", + "sha256": "4bf5c227f2065955f2eadc69dce11dd84adb1495dfec9216dcb21b6395df7048", + "size": 699025, + "subdir": "linux-64", + "timestamp": 1617705233980, + "version": "0.12.0" + }, + "enaml-0.13.0-py310hd09550d_0.conda": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "atom >=0.6.0", + "bytecode >=0.11.0", + "kiwisolver >=1.2.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ply >=3.4", + "pyqt", + "python >=3.10,<3.11.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e45bf75f1e0da9efe772fbc5320901b4", + "name": "enaml", + "sha256": "1bb58abddbcb9f755b0456e6d60b0de6965a4a1ce7badc450eea805c234aa550", + "size": 997919, + "subdir": "linux-64", + "timestamp": 1640811975279, + "version": "0.13.0" + }, + "enaml-0.13.0-py36hff7bd54_0.conda": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "atom >=0.6.0", + "bytecode", + "kiwisolver >=1.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.6,<3.7.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "42487a18deba6de1200b0e44161b9b74", + "name": "enaml", + "sha256": "00bf81dcb33bfbfaab13374da66ac09b6e76e293ce2f0b589ceacf7afacff244", + "size": 687701, + "subdir": "linux-64", + "timestamp": 1618867314439, + "version": "0.13.0" + }, + "enaml-0.13.0-py37hff7bd54_0.conda": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "atom >=0.6.0", + "bytecode", + "kiwisolver >=1.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.7,<3.8.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "041fbd064accc7df040b78f074635daf", + "name": "enaml", + "sha256": "7cf2a649d649c7cd553e739296c35b1d7bafde0aa5ded1236afac06b3fc96caf", + "size": 697013, + "subdir": "linux-64", + "timestamp": 1618867207406, + "version": "0.13.0" + }, + "enaml-0.13.0-py38hff7bd54_0.conda": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "atom >=0.6.0", + "bytecode", + "kiwisolver >=1.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.8,<3.9.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cb8000e8c0599cd5c08acc344810bb83", + "name": "enaml", + "sha256": "0d5a2d64d44117a4a84a7197079cebbe795c83874646d01b61b9733c4532ff1f", + "size": 691273, + "subdir": "linux-64", + "timestamp": 1618863980479, + "version": "0.13.0" + }, + "enaml-0.13.0-py39hff7bd54_0.conda": { + "build": "py39hff7bd54_0", + "build_number": 0, + "depends": [ + "atom >=0.6.0", + "bytecode >=0.11.0", + "kiwisolver >=1.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ply >=3.4", + "pyqt", + "python >=3.9,<3.10.0a0", + "qtpy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2f9b68914ef38af8c348a3a25c13fcfd", + "name": "enaml", + "sha256": "b0e836a940cfb9d904376c22bc484073f4c70a87b9036bc76b060c25ebc9ad5c", + "size": 701607, + "subdir": "linux-64", + "timestamp": 1618947143277, + "version": "0.13.0" + }, + "enaml-0.16.0-py310hdb19cb5_0.conda": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "atom >=0.9.0", + "bytecode >=0.13.0", + "kiwisolver >=1.2.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pegen >=0.1.0", + "ply", + "pyqt", + "python >=3.10,<3.11.0a0", + "qtpy >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e44411fe634b4e366f95cd4471214db6", + "name": "enaml", + "sha256": "1d1f1e6b12daa35ebfe046eb61ee42d4e1fcf7209837e47a1ee72f42bdb13303", + "size": 777012, + "subdir": "linux-64", + "timestamp": 1678397236296, + "version": "0.16.0" + }, + "enaml-0.16.0-py310hdb19cb5_1.conda": { + "build": "py310hdb19cb5_1", + "build_number": 1, + "depends": [ + "atom >=0.9.0", + "bytecode >=0.13.0", + "kiwisolver >=1.2.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pegen >=0.1.0", + "ply", + "pyqt", + "python >=3.10,<3.11.0a0", + "qtpy >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f45fe62169afeafbc866628a63970503", + "name": "enaml", + "sha256": "083af4eb6829fa6810156d00dc172a7c8037dac2952b597c6db1feb712c1d45f", + "size": 774638, + "subdir": "linux-64", + "timestamp": 1680271586780, + "version": "0.16.0" + }, + "enaml-0.16.0-py311hdb19cb5_1.conda": { + "build": "py311hdb19cb5_1", + "build_number": 1, + "depends": [ + "atom >=0.9.0", + "bytecode >=0.13.0", + "kiwisolver >=1.2.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pegen >=0.1.0", + "ply", + "pyqt", + "python >=3.11,<3.12.0a0", + "qtpy >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "008c39cdcdf2210a810e339a4d78636e", + "name": "enaml", + "sha256": "1282cba99e0b0d8c36980f4cb3789cad06218efe44b9fdf7133c4b6fe62c10d2", + "size": 943977, + "subdir": "linux-64", + "timestamp": 1680271540686, + "version": "0.16.0" + }, + "enaml-0.16.0-py38hdb19cb5_0.conda": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "atom >=0.9.0", + "bytecode >=0.13.0", + "kiwisolver >=1.2.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pegen >=0.1.0", + "ply", + "pyqt", + "python >=3.8,<3.9.0a0", + "qtpy >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d3b62c296478571a841d26146ae16cdc", + "name": "enaml", + "sha256": "47fd305cebbdf8851e1ea8d861b74748c0224f168cf769decd3ad13c67cf6e79", + "size": 768368, + "subdir": "linux-64", + "timestamp": 1678397183209, + "version": "0.16.0" + }, + "enaml-0.16.0-py38hdb19cb5_1.conda": { + "build": "py38hdb19cb5_1", + "build_number": 1, + "depends": [ + "atom >=0.9.0", + "bytecode >=0.13.0", + "kiwisolver >=1.2.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pegen >=0.1.0", + "ply", + "pyqt", + "python >=3.8,<3.9.0a0", + "qtpy >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "14e26419c698484fcd890d21c499239e", + "name": "enaml", + "sha256": "b99b602728a82106126bd942f474a2934d90b57f79de1ea3168e628e4750b6b5", + "size": 763314, + "subdir": "linux-64", + "timestamp": 1680271490160, + "version": "0.16.0" + }, + "enaml-0.16.0-py39hdb19cb5_0.conda": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "atom >=0.9.0", + "bytecode >=0.13.0", + "kiwisolver >=1.2.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pegen >=0.1.0", + "ply", + "pyqt", + "python >=3.9,<3.10.0a0", + "qtpy >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2e8de86c0f1403012b0f724713da08ce", + "name": "enaml", + "sha256": "516505a00baf72b0a6cc59ed5fc317e698d4aa613606cf1355e4845bec6c24ca", + "size": 767189, + "subdir": "linux-64", + "timestamp": 1678397283701, + "version": "0.16.0" + }, + "enaml-0.16.0-py39hdb19cb5_1.conda": { + "build": "py39hdb19cb5_1", + "build_number": 1, + "depends": [ + "atom >=0.9.0", + "bytecode >=0.13.0", + "kiwisolver >=1.2.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pegen >=0.1.0", + "ply", + "pyqt", + "python >=3.9,<3.10.0a0", + "qtpy >=2.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f361491cb2a7b8f45d27f08652e6d4a", + "name": "enaml", + "sha256": "bd7b84841d5add46a43506996895d368203e5e30804ab8592a0e385bb0852681", + "size": 763671, + "subdir": "linux-64", + "timestamp": 1680271631104, + "version": "0.16.0" + }, + "ensureconda-1.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "click >=5.1", + "filelock", + "python >=3.10,<3.11.0a0", + "requests >=2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f54d0147eba15980c8fbf9d694fb5aa", + "name": "ensureconda", + "sha256": "76cdf3edc120d3ccbb1b889789cc8f91675bbdc3e396c3632e6f40da9851d9d7", + "size": 19612, + "subdir": "linux-64", + "timestamp": 1676366477098, + "version": "1.4.3" + }, + "ensureconda-1.4.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "click >=5.1", + "filelock", + "python >=3.11,<3.12.0a0", + "requests >=2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2857f498b7ed0188cca694d05fc95a5e", + "name": "ensureconda", + "sha256": "e074988ad3a5c0742b7bb268467e9bfc69712f35b1711307da9c550c97e7ecc1", + "size": 22470, + "subdir": "linux-64", + "timestamp": 1679340458675, + "version": "1.4.3" + }, + "ensureconda-1.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "click >=5.1", + "filelock", + "python >=3.7,<3.8.0a0", + "requests >=2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "27543760eed62bdf2762be10457cf7f5", + "name": "ensureconda", + "sha256": "0aaa0d3f642a85ecd4fe1645feb6d9196334913812dfe7c3af797fbf5e5547a3", + "size": 19372, + "subdir": "linux-64", + "timestamp": 1676366389464, + "version": "1.4.3" + }, + "ensureconda-1.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "click >=5.1", + "filelock", + "python >=3.8,<3.9.0a0", + "requests >=2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5a49a1ae192eb4fe79dc3a6ad88349b0", + "name": "ensureconda", + "sha256": "2dfbbb25f0fc18e0033bc64f6877d6657ee8682d0bb5f38223d63e4080194eb6", + "size": 19436, + "subdir": "linux-64", + "timestamp": 1676366418604, + "version": "1.4.3" + }, + "ensureconda-1.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "click >=5.1", + "filelock", + "python >=3.9,<3.10.0a0", + "requests >=2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f6e6df1316a56d4439ab4ecb4634107", + "name": "ensureconda", + "sha256": "979682fb12032ff4f56fc5bf4f401c27c3800f70bf47bf3ad4a84496fde22b1c", + "size": 19458, + "subdir": "linux-64", + "timestamp": 1676366448337, + "version": "1.4.3" + }, + "entrypoints-0.2.3-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "configparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "a6bef93dc5c5d29c44f93888bc2706fe", + "name": "entrypoints", + "sha256": "b8e3dbba57d754c6bf425b4727ca10228d0b81f2cbfa554bfb272e95f4367792", + "size": 9652, + "subdir": "linux-64", + "timestamp": 1530734317642, + "version": "0.2.3" + }, + "entrypoints-0.2.3-py27h502b47d_2.conda": { + "build": "py27h502b47d_2", + "build_number": 2, + "depends": [ + "configparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "8836977271a65654d8a2c9c5f8690110", + "name": "entrypoints", + "sha256": "20b944868c7aecd1b890022b47561868425d7933a96ae2afb5788d8d65568d5c", + "size": 9374, + "subdir": "linux-64", + "timestamp": 1505957183808, + "version": "0.2.3" + }, + "entrypoints-0.2.3-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "64b54e9e9d8e994fbe1787e55681dd14", + "name": "entrypoints", + "sha256": "f8bb7052ddb189dc3d392ce0da37bb3df605eba468b4dcdfb3ddd5da600c9c45", + "size": 9602, + "subdir": "linux-64", + "timestamp": 1534350908850, + "version": "0.2.3" + }, + "entrypoints-0.2.3-py35h48174a2_2.conda": { + "build": "py35h48174a2_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "d1e1fc5ca5c9fc245ada531ad5118bdb", + "name": "entrypoints", + "sha256": "10c44815f72d1748def95030d37b6e2278cb927fd44857f83854c9db9da69761", + "size": 9483, + "subdir": "linux-64", + "timestamp": 1505957193149, + "version": "0.2.3" + }, + "entrypoints-0.2.3-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "7ff9040ac5f405ca76630dd962d87ad1", + "name": "entrypoints", + "sha256": "ecb3e74c896cac8d162cfc04058a8af777ccbd29c2b2c7913455c8845edf4202", + "size": 9645, + "subdir": "linux-64", + "timestamp": 1530734303576, + "version": "0.2.3" + }, + "entrypoints-0.2.3-py36h1aec115_2.conda": { + "build": "py36h1aec115_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "13a7ce7b0ff6f65e2b1d7ce1f8b05a8d", + "name": "entrypoints", + "sha256": "6c524e8fb675e75045f0425927172163cb59c535d43b01c7289c263e35ace69c", + "size": 9443, + "subdir": "linux-64", + "timestamp": 1505957202310, + "version": "0.2.3" + }, + "entrypoints-0.2.3-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "7bc52ff7f1d5b0111227c160bf0e6986", + "name": "entrypoints", + "sha256": "5caa63636d1d8ee9c46adb52369d4f7c3c4af9a5cac1600e8f03655b89135d6b", + "size": 9621, + "subdir": "linux-64", + "timestamp": 1530734332395, + "version": "0.2.3" + }, + "entrypoints-0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "865a1d903dd88d7afd9db2fd37de1db6", + "name": "entrypoints", + "sha256": "645e2e57f3b327f94276e36767b38a3d371e08a84af33850e1bd0449a400dbcf", + "size": 12175, + "subdir": "linux-64", + "timestamp": 1547904707913, + "version": "0.3" + }, + "entrypoints-0.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "aede19658ef469fe4870414464b9f12b", + "name": "entrypoints", + "sha256": "bcd8ff41f1611beb93ee8866cdec31b8400632b8060bc929cc01386e426d5767", + "size": 10313, + "subdir": "linux-64", + "timestamp": 1641916225764, + "version": "0.3" + }, + "entrypoints-0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "90f37d47f1d192fb171796337d50e0fc", + "name": "entrypoints", + "sha256": "9fa660d301201b407634001028d0472fcf990bf7cf651bd5fe9c1a3310df7e91", + "size": 12180, + "subdir": "linux-64", + "timestamp": 1547904768453, + "version": "0.3" + }, + "entrypoints-0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "08cfc83df40ff022d64e2bc1ac9aecac", + "name": "entrypoints", + "sha256": "af05eb4b85989d4d826a726f1b948b2e1e87e4a1f5b1a1a125e3f582b7d1d939", + "size": 12217, + "subdir": "linux-64", + "timestamp": 1547904690205, + "version": "0.3" + }, + "entrypoints-0.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "f21a05dd7fbcb93d709e629afc215745", + "name": "entrypoints", + "sha256": "6f5eefe16fee02b809d034217e0425380101a45c01a7c9a776a02b52a0c32d49", + "size": 10426, + "subdir": "linux-64", + "timestamp": 1572514983215, + "version": "0.3" + }, + "entrypoints-0.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "1cf0447ada1ff74c908f74b73238fa3d", + "name": "entrypoints", + "sha256": "bcbc49902e1b14a948679781d14ffbb5f6b8bff8d96f79af720a875e6b7df324", + "size": 12417, + "subdir": "linux-64", + "timestamp": 1607365042348, + "version": "0.3" + }, + "entrypoints-0.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "a7abf942ce9d11822b1ab146f949291b", + "name": "entrypoints", + "sha256": "04240db33a19536fbe79db29c976d9e172c28183225c6218c23860a43381e391", + "size": 16759, + "subdir": "linux-64", + "timestamp": 1649908359372, + "version": "0.4" + }, + "entrypoints-0.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "476078025205b930f39418fae598d318", + "name": "entrypoints", + "sha256": "86a29c39673e540da59c8df6be6c688188355daf3d14461806f43ddde41a4c2a", + "size": 17822, + "subdir": "linux-64", + "timestamp": 1676823330845, + "version": "0.4" + }, + "entrypoints-0.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "a0163283ce6370330310ac3ada054b1c", + "name": "entrypoints", + "sha256": "5eb3f3e8dcf39a48695360b5929b9a1df057808285d4e5c16e354091078feacc", + "size": 16590, + "subdir": "linux-64", + "timestamp": 1649908625568, + "version": "0.4" + }, + "entrypoints-0.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "3cdf167326744187efd003c24ab77c99", + "name": "entrypoints", + "sha256": "5fa28fb8902784fd0382a7fcb7743dced5d6055a12420447b0741b69b89e23dd", + "size": 16669, + "subdir": "linux-64", + "timestamp": 1649926480666, + "version": "0.4" + }, + "entrypoints-0.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "02c4aebf664427bb692dd90c62293539", + "name": "entrypoints", + "sha256": "46ebc6248a9f0ac222b52a431b0ef9768eb9f8d8db14e67502b1f0236308f5fd", + "size": 16666, + "subdir": "linux-64", + "timestamp": 1649926472708, + "version": "0.4" + }, + "enum34-1.1.10-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c9e754ec885f4c8c81272990146a55f4", + "name": "enum34", + "sha256": "35040a8de57ccefb24a82e16c857960aa0c5d865504bb34e670dea1ee2acf950", + "size": 4680, + "subdir": "linux-64", + "timestamp": 1640789804646, + "version": "1.1.10" + }, + "enum34-1.1.10-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7f6cc14737ef5412889f0403dcd20dc4", + "name": "enum34", + "sha256": "b26a01a3523b91622a0c8fea3104ddbe315d6b1e42f5776b193ce87c310f10f1", + "size": 5055, + "subdir": "linux-64", + "timestamp": 1676852155800, + "version": "1.1.10" + }, + "enum34-1.1.10-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "dd7605a442223fb400071552ae970c4e", + "name": "enum34", + "sha256": "540b62e57d76b04dc3eeef6610d5629f8217e4ce9b8653336a88bd0ba36b5725", + "size": 5840, + "subdir": "linux-64", + "timestamp": 1617954039209, + "version": "1.1.10" + }, + "enum34-1.1.10-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d88d9ee4458be6cbfcc5c7e4e6b774e8", + "name": "enum34", + "sha256": "825a005d47f49dd4cdccba9ecf8e368a827bf75edb647e4170b2fcb1b23ca7b9", + "size": 5844, + "subdir": "linux-64", + "timestamp": 1617954039535, + "version": "1.1.10" + }, + "enum34-1.1.10-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "562458da7199090c1dd1aa660746cb37", + "name": "enum34", + "sha256": "1eaeed5c3ca9eaa8157a99a3a765070a836b807fe9b79e45287898e4a414737c", + "size": 5855, + "subdir": "linux-64", + "timestamp": 1617951147712, + "version": "1.1.10" + }, + "enum34-1.1.10-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "90261dade181f9b3688aac9ef58ccbbb", + "name": "enum34", + "sha256": "4064b0cccee855d0f6079f9b46161533a14d4e4da593da347717b536bf77f954", + "size": 5869, + "subdir": "linux-64", + "timestamp": 1617954031322, + "version": "1.1.10" + }, + "enum34-1.1.6-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ed964f9927d3d8a8096031b4836b277b", + "name": "enum34", + "sha256": "125690e14b4580cda0d812a28c8aab829535d2bb913bbfa5d28109550084251e", + "size": 59263, + "subdir": "linux-64", + "timestamp": 1530735352907, + "version": "1.1.6" + }, + "enum34-1.1.6-py27h99a27e9_1.conda": { + "build": "py27h99a27e9_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "05a3f5e27d600389fc75553c15072c6b", + "name": "enum34", + "sha256": "feefe8a7032f881bf945dfb06dbf21cdc430ca7dd1618380a653fa22cc40043e", + "size": 59033, + "subdir": "linux-64", + "timestamp": 1505672101856, + "version": "1.1.6" + }, + "envisage-4.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=2.7,<2.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cfc1fbc9bd44ffa8006ae859141023e4", + "name": "envisage", + "sha256": "0df70964b470261df9b15254b9ddb30c26b44230a00b185399db40c02e357b77", + "size": 345945, + "subdir": "linux-64", + "timestamp": 1530874981923, + "version": "4.6.0" + }, + "envisage-4.6.0-py27hf3b32b8_0.conda": { + "build": "py27hf3b32b8_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=2.7,<2.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a9a2c359fa3d0279aec5f924ca846aca", + "name": "envisage", + "sha256": "04d8600e9e3cfa5f99a7599da534c0d47845dd9d99bd3f4597ef4a6209a000a1", + "size": 346090, + "subdir": "linux-64", + "timestamp": 1507932278907, + "version": "4.6.0" + }, + "envisage-4.6.0-py35hcb524f0_0.conda": { + "build": "py35hcb524f0_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=3.5,<3.6.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c9b27e940ea8cecd7342faea58ff82db", + "name": "envisage", + "sha256": "6a068a9d86a8c4600e6e1d026ad18519e8375ce2ddb63ddec512f2a9f1de4780", + "size": 354415, + "subdir": "linux-64", + "timestamp": 1507932304774, + "version": "4.6.0" + }, + "envisage-4.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b138c68c11671e76b7b4c54e1975438b", + "name": "envisage", + "sha256": "6253cc5f823a9dbe9969cd8f2969b30b5a5d6b0a5855c6eaac1bb0ee8bce2a1e", + "size": 356107, + "subdir": "linux-64", + "timestamp": 1530874898541, + "version": "4.6.0" + }, + "envisage-4.6.0-py36h49a624e_0.conda": { + "build": "py36h49a624e_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3eb83d2f2ff9ece5a4487ac3b6fd7836", + "name": "envisage", + "sha256": "b35a6c9aff8036bb3ab92c885daa1959b10f8a4781d8c9cd227d06b49763a6a7", + "size": 356301, + "subdir": "linux-64", + "timestamp": 1507932296399, + "version": "4.6.0" + }, + "envisage-4.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e2b02429e9eb64872b78ab6cdf93999f", + "name": "envisage", + "sha256": "06aae977764c5cdec247a1bd1fb4d5360784ebeb2495cf0b2136d17cd75dcdbb", + "size": 356458, + "subdir": "linux-64", + "timestamp": 1530874943283, + "version": "4.6.0" + }, + "envisage-4.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=2.7,<2.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cbd38df831eeb7f118d245e23506ccc9", + "name": "envisage", + "sha256": "d6697f36a01da33f43ca032ec287d5c235d7430f739c63bb697e15488f049be6", + "size": 362397, + "subdir": "linux-64", + "timestamp": 1536251641471, + "version": "4.7.0" + }, + "envisage-4.7.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=3.5,<3.6.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "411894665acf80c13470ef227b36f4ff", + "name": "envisage", + "sha256": "e709f26048c7ca55d66b7c6c393109f644da58112a52a7b67af7caa047294ce7", + "size": 370674, + "subdir": "linux-64", + "timestamp": 1536257290860, + "version": "4.7.0" + }, + "envisage-4.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2b8f161b5dfa11c3016a38548bbb92bf", + "name": "envisage", + "sha256": "f78b4c38266d4201e8e241f350da60c0dc93074ac482b44b15827079bc9a9e26", + "size": 374261, + "subdir": "linux-64", + "timestamp": 1536251623107, + "version": "4.7.0" + }, + "envisage-4.7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "apptools", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8d1fce956046dde89a6d03739aab4756", + "name": "envisage", + "sha256": "43737de85c05df5430fa475f14156db0b40b780b1ca16d0936805980d504cd1f", + "size": 374110, + "subdir": "linux-64", + "timestamp": 1536251723736, + "version": "4.7.0" + }, + "ephem-3.7.6.0-py27h14c3975_1.conda": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL", + "md5": "e2148b49b6e8b34777cf1674885d2a7b", + "name": "ephem", + "sha256": "fbee938e3e9487806bd77eb51dc1dc189c6bf6c89b33ac590d1ae0b20c598892", + "size": 712332, + "subdir": "linux-64", + "timestamp": 1522776099578, + "version": "3.7.6.0" + }, + "ephem-3.7.6.0-py35h14c3975_1.conda": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL", + "md5": "1651668678a6b0fb068c1f949db4b0c4", + "name": "ephem", + "sha256": "d69b4dcba0b0507ee3b94be3aa8c9429c8d9ed1eb0f61168b33e6a0f6a8eaf94", + "size": 713830, + "subdir": "linux-64", + "timestamp": 1522776222481, + "version": "3.7.6.0" + }, + "ephem-3.7.6.0-py36h14c3975_1.conda": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL", + "md5": "cd628b0cbbb8d241b0216f4b6cad8d91", + "name": "ephem", + "sha256": "91109ce3d4a0a785382fe6d1dd0c557e00f3f2c48a3986ed0f0f0794c94a19bc", + "size": 714268, + "subdir": "linux-64", + "timestamp": 1522776122925, + "version": "3.7.6.0" + }, + "ephem-3.7.6.0-py37h14c3975_1.conda": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL", + "md5": "eb9dea2ed417336ca37150b5d5cd8fab", + "name": "ephem", + "sha256": "ded9a290f0c1e41d3096c97956da6b5f0b398f39893dd35f77ad3c56efd0cfb4", + "size": 712369, + "subdir": "linux-64", + "timestamp": 1530875953162, + "version": "3.7.6.0" + }, + "ephem-3.7.7.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL", + "md5": "35234f68115be3d9b0ba943a7fc3f1c3", + "name": "ephem", + "sha256": "46595f59f0f8aa1b11f7f8f6771371967a435c7ed271857a886da2722acf265b", + "size": 741384, + "subdir": "linux-64", + "timestamp": 1569367363723, + "version": "3.7.7.0" + }, + "ephem-3.7.7.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL", + "md5": "42238bbfba59521ced1e1bb6d81c1e48", + "name": "ephem", + "sha256": "3c095759345cb10874399ec970243fd5f879fa7cbb8b3eb1b6006838d1903606", + "size": 743045, + "subdir": "linux-64", + "timestamp": 1614254425450, + "version": "3.7.7.0" + }, + "ephem-3.7.7.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL", + "md5": "d744dc4dd37a143a5d8de408c1908a60", + "name": "ephem", + "sha256": "d369f92c0873103d67c365c8f4e1642896fe3ee0ec61f1cfb96aa48ba31569a2", + "size": 741165, + "subdir": "linux-64", + "timestamp": 1569367318161, + "version": "3.7.7.0" + }, + "ephem-3.7.7.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL", + "md5": "089b0e6babcb4b4fd2535a6095c8fd71", + "name": "ephem", + "sha256": "32de7a9a20c08e4829b1ef153e6dfe1208dd7af7c1eb8bb4fb625e3f3845d2c4", + "size": 740358, + "subdir": "linux-64", + "timestamp": 1614254419633, + "version": "3.7.7.0" + }, + "ephem-3.7.7.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL", + "md5": "04a1626c8ec797799560ef61f711bfa5", + "name": "ephem", + "sha256": "057579e093f9701586a8dffe24b036cc00e48f401173047c97ab078c9ae84411", + "size": 740040, + "subdir": "linux-64", + "timestamp": 1569367341724, + "version": "3.7.7.0" + }, + "ephem-3.7.7.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL", + "md5": "ada141407994d2ece66c76d5b2997f31", + "name": "ephem", + "sha256": "bbd2b3451167bab5837b8c5718bdb802dca64bf9cf400de5bb730998a691f914", + "size": 741512, + "subdir": "linux-64", + "timestamp": 1614254436553, + "version": "3.7.7.0" + }, + "ephem-3.7.7.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL", + "md5": "7c47d348686b1c4905f21eaf659c763c", + "name": "ephem", + "sha256": "9fb47e27675158b9f59198c98ecc120637381ffa4f7b9de14c8a8be7d0c52e2a", + "size": 746305, + "subdir": "linux-64", + "timestamp": 1572515083286, + "version": "3.7.7.0" + }, + "ephem-3.7.7.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL", + "md5": "c0b19f2c55a46b84705bf53c7b8d0f31", + "name": "ephem", + "sha256": "e74d44d623773e2afd22fad6571438b06e85f593ea2e3725ea5f8734f0fa84a5", + "size": 740123, + "subdir": "linux-64", + "timestamp": 1614253910211, + "version": "3.7.7.0" + }, + "ephem-3.7.7.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL", + "md5": "d24976dccbbe475f7010c802488e2d5c", + "name": "ephem", + "sha256": "6da5b0e714ccce2cd1afc3b1619f28baca813b2b0036552fac8f2813af97f3f2", + "size": 741050, + "subdir": "linux-64", + "timestamp": 1600355436270, + "version": "3.7.7.1" + }, + "ephem-3.7.7.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL", + "md5": "33e94def71843df3480b322526e27234", + "name": "ephem", + "sha256": "5ddf0987e64039c42e7f444c24b39a28f261a7a0600ca55e6118086adddf2257", + "size": 740079, + "subdir": "linux-64", + "timestamp": 1600355443111, + "version": "3.7.7.1" + }, + "ephem-3.7.7.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL", + "md5": "fcd6922236b680ebf81d9958d05f3ca1", + "name": "ephem", + "sha256": "131b924ec859afd043208e2ebfac2f52fbfd6d7302f5bbf6be8663ca523f8393", + "size": 739828, + "subdir": "linux-64", + "timestamp": 1600355448368, + "version": "3.7.7.1" + }, + "ephem-4.0.0.2-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "a248652542b32ca92f90262cc748eaf2", + "name": "ephem", + "sha256": "1bc8cbfb2767ad535be443325041031e5d68571def69bd6e0fc9e028bab64410", + "size": 756172, + "subdir": "linux-64", + "timestamp": 1623914259875, + "version": "4.0.0.2" + }, + "ephem-4.0.0.2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "247e8f93f105625623d0cd56a84f8d80", + "name": "ephem", + "sha256": "1e1fb6b7b36303dc63ad9ae60957622da3e2ce376d691c9709919feff3931f87", + "size": 751820, + "subdir": "linux-64", + "timestamp": 1623920149976, + "version": "4.0.0.2" + }, + "ephem-4.0.0.2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "a7345d486c4724f9eb347e58e9c2433f", + "name": "ephem", + "sha256": "f7f91838c70a68baa8d2d8b0d25a7ceddb701a83c2709742ae62c1916806befd", + "size": 751340, + "subdir": "linux-64", + "timestamp": 1623919653923, + "version": "4.0.0.2" + }, + "ephem-4.0.0.2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "ef242fa7c8d324cc982707485226a272", + "name": "ephem", + "sha256": "bb6b67ac14c8d2e61cfa2a514ac2f01eea3d3c3639736b302fd9dd68718b7829", + "size": 753666, + "subdir": "linux-64", + "timestamp": 1623920142352, + "version": "4.0.0.2" + }, + "ephem-4.1.2-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96be67aa8db5ab91513a160a2da85d39", + "name": "ephem", + "sha256": "f81cbd10de7225450e6d8df9d0189c62fdf86409ef9d88591807d58a540b34eb", + "size": 1551468, + "subdir": "linux-64", + "timestamp": 1640789838002, + "version": "4.1.2" + }, + "ephem-4.1.2-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16801110aa4e76248b2b869ff6e0c918", + "name": "ephem", + "sha256": "67412ed9249caf8bb578e86b27c5f5c16a0ecc1e46569d16a24e13a4520e222d", + "size": 1382704, + "subdir": "linux-64", + "timestamp": 1676852179216, + "version": "4.1.2" + }, + "ephem-4.1.2-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "07dd0d64a548192a703e711b699fa949", + "name": "ephem", + "sha256": "2a5dce54d37af53d6f21fb1d84daa1269c77af6355d46a5c0c6c6a0ae7f976a3", + "size": 1367654, + "subdir": "linux-64", + "timestamp": 1638960359365, + "version": "4.1.2" + }, + "ephem-4.1.2-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "351e2d7af9a5bc1c72395084800bf288", + "name": "ephem", + "sha256": "bebf031731c9b6e6cc0668bfe52c2a557747397063ca98f80ab375fd13f97606", + "size": 1368253, + "subdir": "linux-64", + "timestamp": 1638942240609, + "version": "4.1.2" + }, + "ephem-4.1.2-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "caba5d9b2e7af423ba544c937957dbcb", + "name": "ephem", + "sha256": "cbd84d8a5308db13ff9f83d67e25451afd2e9ad69bc462c0a2d82c028c54f5a7", + "size": 1369815, + "subdir": "linux-64", + "timestamp": 1638960361596, + "version": "4.1.2" + }, + "epoxy-1.5.4-h7f8727e_2.conda": { + "build": "h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc5c7364c37f340374729502180655f4", + "name": "epoxy", + "sha256": "e2dcb63aa7ff1245a4597b70a764949c1ed13ea7dc94a276c1d41f574d942a46", + "size": 1161921, + "subdir": "linux-64", + "timestamp": 1632392751126, + "version": "1.5.4" + }, + "et_xmlfile-1.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb77662ce5d1e6fbe8d003f476693905", + "name": "et_xmlfile", + "sha256": "46e3c0a5b877a3cb58663e51278f2a46571f76255defafef6b75d821d1025329", + "size": 20944, + "subdir": "linux-64", + "timestamp": 1530736038853, + "version": "1.0.1" + }, + "et_xmlfile-1.0.1-py27h75840f5_0.conda": { + "build": "py27h75840f5_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b5df22d3a00205288ec01ede606c476", + "name": "et_xmlfile", + "sha256": "5f714261ea0e6b276eb462eb13bca2731ed1b699ca53ea16664f57f887630d0c", + "size": 20737, + "subdir": "linux-64", + "timestamp": 1505742745961, + "version": "1.0.1" + }, + "et_xmlfile-1.0.1-py35hde8d43e_0.conda": { + "build": "py35hde8d43e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c9e6e53049a5f9da7360716bada6af3", + "name": "et_xmlfile", + "sha256": "40d28c1d40c4e482e0d66c92576bca8d16533a95097b6c56d7fa3d1bdba7b074", + "size": 21222, + "subdir": "linux-64", + "timestamp": 1505742758336, + "version": "1.0.1" + }, + "et_xmlfile-1.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1416a0c27f4b430261bed052605984f1", + "name": "et_xmlfile", + "sha256": "39a276dab9ef8991d57bc810832f2c397742968071076dacb21daa7d4bf73cff", + "size": 21358, + "subdir": "linux-64", + "timestamp": 1530736018654, + "version": "1.0.1" + }, + "et_xmlfile-1.0.1-py36hd6bccc3_0.conda": { + "build": "py36hd6bccc3_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "520e3bd3d4482b5cebd17aff5c3adab9", + "name": "et_xmlfile", + "sha256": "d428200c0a6adc22e3fcf1d27a83f7ce042d02b71eeb9e7362ddb65b41ca2288", + "size": 21129, + "subdir": "linux-64", + "timestamp": 1505742770931, + "version": "1.0.1" + }, + "et_xmlfile-1.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e3908fd9010f1e3aa82c7c08af7f784e", + "name": "et_xmlfile", + "sha256": "73efcdb947cffde2ffa0078ba0016f66d83b18e65e8c3f9b4920c4207133b65e", + "size": 21248, + "subdir": "linux-64", + "timestamp": 1530736059295, + "version": "1.0.1" + }, + "et_xmlfile-1.0.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "945e471053d7c56188041e172fa0b165", + "name": "et_xmlfile", + "sha256": "3a2d4653614b02700050f4ac591a13863e31e388a2262e69f37e6bc553b8073f", + "size": 22653, + "subdir": "linux-64", + "timestamp": 1572515104873, + "version": "1.0.1" + }, + "et_xmlfile-1.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT AND PSF-2.0", + "license_family": "MIT", + "md5": "393287c24fffb60e25b6dd4c290b437f", + "name": "et_xmlfile", + "sha256": "a4e896adeb87fe91c7ef0eb2dd5ebaf49ecf1c15f4e04664da4a0feab08be839", + "size": 10081, + "subdir": "linux-64", + "timestamp": 1642499265483, + "version": "1.1.0" + }, + "et_xmlfile-1.1.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT AND PSF-2.0", + "license_family": "MIT", + "md5": "eac287d1ee34bdaf7e8c9a1ee26356cb", + "name": "et_xmlfile", + "sha256": "69f6fcd0738e66af1a1cffc2f49e70b70175f67f7e5f88ad604d998e0f7ee8a6", + "size": 11355, + "subdir": "linux-64", + "timestamp": 1676830488113, + "version": "1.1.0" + }, + "et_xmlfile-1.1.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4bb2f6e613fb3637437ee6a4f6ef143a", + "name": "et_xmlfile", + "sha256": "f69f17837fae787c27177178d9d42f1d0f05b3d9a5e3038d768261ce35a5d4eb", + "size": 10111, + "subdir": "linux-64", + "timestamp": 1621828471711, + "version": "1.1.0" + }, + "et_xmlfile-1.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2140b24ca3c4c243f43de1de7f134159", + "name": "et_xmlfile", + "sha256": "a458cb46868d61170bb505bf34d06a1d4817ebfc050821be8b895a2a74135248", + "size": 10188, + "subdir": "linux-64", + "timestamp": 1621828463872, + "version": "1.1.0" + }, + "et_xmlfile-1.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a619b65dd09785195d28045bbabc929b", + "name": "et_xmlfile", + "sha256": "9e1fa6da18bbeb7ef230f6a31a6f38db1355c1bf2a125048420df01fb2da776e", + "size": 10127, + "subdir": "linux-64", + "timestamp": 1621828464340, + "version": "1.1.0" + }, + "et_xmlfile-1.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT AND PSF-2.0", + "license_family": "MIT", + "md5": "6e5f8a1b375fb5715d89e0b51d878646", + "name": "et_xmlfile", + "sha256": "aa1d995b4cb7fa2b36eb3a4112561014640f080fdcc5601c1fcb530df4505b07", + "size": 10172, + "subdir": "linux-64", + "timestamp": 1621866114609, + "version": "1.1.0" + }, + "evaluate-0.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cookiecutter", + "datasets >=2.0.0", + "dill", + "fsspec >=2021.05.0", + "huggingface_hub >=0.7.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "python >=3.10,<3.11.0a0", + "python-xxhash", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a3b5e7179fbf7a8de5f258a781da5639", + "name": "evaluate", + "sha256": "b236686f561584baca94ce7143f4ac8bb2dbb6506aab4e0134c11a85e10a4138", + "size": 105142, + "subdir": "linux-64", + "timestamp": 1668622833770, + "version": "0.3.0" + }, + "evaluate-0.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cookiecutter", + "datasets >=2.0.0", + "dill", + "fsspec >=2021.05.0", + "huggingface_hub >=0.7.0", + "importlib-metadata", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "python >=3.7,<3.8.0a0", + "python-xxhash", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "56c1a4bcc9e3099c344875d13a7f271b", + "name": "evaluate", + "sha256": "2dcd4e672de7ea9dcd9cbfb483321b22bd03fd3bf01ffa54a98e30664e99195b", + "size": 103116, + "subdir": "linux-64", + "timestamp": 1668622777591, + "version": "0.3.0" + }, + "evaluate-0.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cookiecutter", + "datasets >=2.0.0", + "dill", + "fsspec >=2021.05.0", + "huggingface_hub >=0.7.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "python >=3.8,<3.9.0a0", + "python-xxhash", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d98f67c17f600217a420bfac377916da", + "name": "evaluate", + "sha256": "a98b492cc059ef9d7b8ae1fbe50357a983dca24009ab169f202dd9d82f45b551", + "size": 103704, + "subdir": "linux-64", + "timestamp": 1668622931661, + "version": "0.3.0" + }, + "evaluate-0.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cookiecutter", + "datasets >=2.0.0", + "dill", + "fsspec >=2021.05.0", + "huggingface_hub >=0.7.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "python >=3.9,<3.10.0a0", + "python-xxhash", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3d1a89c92d45c19489c298472846688f", + "name": "evaluate", + "sha256": "80c9adf3f98d655bec9da252b72a3e571578b7f7796d927cccf00e51d225eb56", + "size": 103727, + "subdir": "linux-64", + "timestamp": 1668622883126, + "version": "0.3.0" + }, + "evaluate-0.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cookiecutter", + "datasets >=2.0.0", + "dill", + "fsspec >=2021.05.0", + "huggingface_hub >=0.7.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "python >=3.10,<3.11.0a0", + "python-xxhash", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "15e27994c437b314ad0d5783b85c169d", + "name": "evaluate", + "sha256": "868bef174ef82bd856354573a8c8952289bb72743a6acc5d632e2a73a41be490", + "size": 119181, + "subdir": "linux-64", + "timestamp": 1679573642350, + "version": "0.4.0" + }, + "evaluate-0.4.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cookiecutter", + "datasets >=2.0.0", + "dill", + "fsspec >=2021.05.0", + "huggingface_hub >=0.7.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "python >=3.11,<3.12.0a0", + "python-xxhash", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c1ace84a2b0f3d599e6ad039abd91e5e", + "name": "evaluate", + "sha256": "72b7e46e2d9da3f89b3279608b7475bd3f9b34be0a1950a7ddb227e7b9923ad9", + "size": 156264, + "subdir": "linux-64", + "timestamp": 1679573745132, + "version": "0.4.0" + }, + "evaluate-0.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cookiecutter", + "datasets >=2.0.0", + "dill", + "fsspec >=2021.05.0", + "huggingface_hub >=0.7.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "python >=3.8,<3.9.0a0", + "python-xxhash", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "38a8511d9a7134bb4bdfb52d3916926c", + "name": "evaluate", + "sha256": "f1c0e893bb2b202cfc318dcb6ff94faa47c23b2e173eec95f7033d6f15d4c064", + "size": 117829, + "subdir": "linux-64", + "timestamp": 1679573697778, + "version": "0.4.0" + }, + "evaluate-0.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cookiecutter", + "datasets >=2.0.0", + "dill", + "fsspec >=2021.05.0", + "huggingface_hub >=0.7.0", + "multiprocess", + "numpy >=1.17", + "packaging", + "pandas", + "python >=3.9,<3.10.0a0", + "python-xxhash", + "requests >=2.19.0", + "responses <0.19", + "tqdm >=4.62.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "03e11d4977e3554189429236648e729d", + "name": "evaluate", + "sha256": "cc3fba88399b4650656fdb1a463cf8db8d2fdc237ecee145e14feda7baa5a7b3", + "size": 117635, + "subdir": "linux-64", + "timestamp": 1679573791010, + "version": "0.4.0" + }, + "eventlet-0.26.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "greenlet >=0.3", + "monotonic >=1.4", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "six >=1.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1517fe64d0b0b6dccffe925d86f6e2ec", + "name": "eventlet", + "sha256": "ee05c14545d0da4a24420ada27880975da92c405ff2827d678c001643b4d19fd", + "size": 306286, + "subdir": "linux-64", + "timestamp": 1596834704090, + "version": "0.26.1" + }, + "eventlet-0.27.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0,<2.0.0", + "greenlet >=0.3", + "monotonic >=1.4", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "six >=1.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "588c02079d4e2aa8885a459ec920e287", + "name": "eventlet", + "sha256": "38ab467886e9798f6f6d51c6173879f0693896275487109c5b3a78c6330d3d58", + "size": 311917, + "subdir": "linux-64", + "timestamp": 1600355442520, + "version": "0.27.0" + }, + "eventlet-0.27.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0,<2.0.0", + "greenlet >=0.3", + "monotonic >=1.4", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "six >=1.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a428d9c3f37208d926e9809cb161647", + "name": "eventlet", + "sha256": "b65de3666c9a35e050490aa6f2522b0def17e37f5e86b98e1c9147fe8199511a", + "size": 311605, + "subdir": "linux-64", + "timestamp": 1600355432175, + "version": "0.27.0" + }, + "eventlet-0.27.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0,<2.0.0", + "greenlet >=0.3", + "monotonic >=1.4", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "six >=1.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6903f4ea8ec663bfb02edf8fc7a1c75", + "name": "eventlet", + "sha256": "a442419c92bca9d2b7b28fae9a1144e1dc14fb3c1ecfb30c04c3e580cfae2d5b", + "size": 307760, + "subdir": "linux-64", + "timestamp": 1600355427983, + "version": "0.27.0" + }, + "eventlet-0.33.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "greenlet >=0.3", + "pyopenssl", + "python >=3.10,<3.11.0a0", + "six >=1.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8172aab59b8336371370db3afcd137f1", + "name": "eventlet", + "sha256": "56eb9b1ceb0d3632d6cd1463e11852fb25fe905a9dc7186fe55e0df05f4662ab", + "size": 314170, + "subdir": "linux-64", + "timestamp": 1659714656321, + "version": "0.33.1" + }, + "eventlet-0.33.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "greenlet >=0.3", + "pyopenssl", + "python >=3.11,<3.12.0a0", + "six >=1.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c80591cb2753b3c82fe63cf22b29b765", + "name": "eventlet", + "sha256": "9ea01a2a4dea987f24534aff3398cfda8b5b864a634facdebc38586e54d252d5", + "size": 422273, + "subdir": "linux-64", + "timestamp": 1676852212804, + "version": "0.33.1" + }, + "eventlet-0.33.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "greenlet >=0.3", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "six >=1.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c8258394a7f1dfdedcd21fee66e6ba3", + "name": "eventlet", + "sha256": "ad50a19e7d41a521aa3a85cb5e7949c9970dfe0390c831498f69d1f72958208f", + "size": 309956, + "subdir": "linux-64", + "timestamp": 1659714711796, + "version": "0.33.1" + }, + "eventlet-0.33.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "greenlet >=0.3", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "six >=1.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "00b33a7acc4a2df46e9ba1241dfac026", + "name": "eventlet", + "sha256": "f75d05a96bec35d84e707ee1195ddfac1e14ee13a086246653bc4dd2034c977d", + "size": 311382, + "subdir": "linux-64", + "timestamp": 1659714683866, + "version": "0.33.1" + }, + "eventlet-0.33.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dnspython >=1.15.0", + "greenlet >=0.3", + "pyopenssl", + "python >=3.9,<3.10.0a0", + "six >=1.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "503dcb8a6cf5246f52b25bfff0ee40c7", + "name": "eventlet", + "sha256": "de54718db221ca50477c3c1c135d76507cd186d432dfd38b298be72cb093ca63", + "size": 311386, + "subdir": "linux-64", + "timestamp": 1659714615473, + "version": "0.33.1" + }, + "exceptiongroup-1.0.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "21881c0c45838e0263245c3470d9b163", + "name": "exceptiongroup", + "sha256": "81a3cbe8408d73bd40c7d6bcb3ad0254e3b42b39d11d3bf8c87700cf0ffb99f0", + "size": 29037, + "subdir": "linux-64", + "timestamp": 1668714404585, + "version": "1.0.4" + }, + "exceptiongroup-1.0.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1574b9fc50395cee161f505703aeab05", + "name": "exceptiongroup", + "sha256": "ae595e1c89c40a0d41321af268749a7c7d2b8a71e6c2bf98143c758187d3dff2", + "size": 34405, + "subdir": "linux-64", + "timestamp": 1676827740583, + "version": "1.0.4" + }, + "exceptiongroup-1.0.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0c4d754086d3524db1ba8aef45b59886", + "name": "exceptiongroup", + "sha256": "77393a71e2e0c9bb1409519dd8c72c6ba2a646af3a3a74d001b5d0eed852efb5", + "size": 28776, + "subdir": "linux-64", + "timestamp": 1668714433596, + "version": "1.0.4" + }, + "exceptiongroup-1.0.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "db954e73dca6076c64a1004d71b45784", + "name": "exceptiongroup", + "sha256": "5d1526e800efe7dda41c1308e9e6a3314126ab8816b7fb579f5592b95b12c6f4", + "size": 28853, + "subdir": "linux-64", + "timestamp": 1668714375773, + "version": "1.0.4" + }, + "exceptiongroup-1.0.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "24efdd890b4d7e3e5b99784a87077709", + "name": "exceptiongroup", + "sha256": "cac7e557fc3dc2e745da75d5be7ec302b2692c64828c7a46f0362a3d56b5ae7a", + "size": 28772, + "subdir": "linux-64", + "timestamp": 1668714462023, + "version": "1.0.4" + }, + "execnet-1.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "apipkg >=1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "097e68e3ce1b6bc9ec2f942842353ff6", + "name": "execnet", + "sha256": "0ed15159ed5e3a5f8820948908ed77f30988df16d1b3dec97e928c49954bdd8b", + "size": 67357, + "subdir": "linux-64", + "timestamp": 1530727897484, + "version": "1.5.0" + }, + "execnet-1.5.0-py27hb11c14a_0.conda": { + "build": "py27hb11c14a_0", + "build_number": 0, + "depends": [ + "apipkg >=1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5b2ceb023d185796aedaec2a2856e820", + "name": "execnet", + "sha256": "e6e1a530accdaff954258887e74eb7b27d29e2bb3e88479882897c06d515869a", + "size": 69048, + "subdir": "linux-64", + "timestamp": 1510987279438, + "version": "1.5.0" + }, + "execnet-1.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "apipkg >=1.4", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "6684e1c53d16cea0a9d6d0dfc58650fc", + "name": "execnet", + "sha256": "e527e343867b4e2d2e1475e4e08aa2c4a5213b67a9a2c23da01abea7185eecb4", + "size": 69541, + "subdir": "linux-64", + "timestamp": 1534347564435, + "version": "1.5.0" + }, + "execnet-1.5.0-py35h6c6e770_0.conda": { + "build": "py35h6c6e770_0", + "build_number": 0, + "depends": [ + "apipkg >=1.4", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "24937dfd26d466f52068e6d0371cbe27", + "name": "execnet", + "sha256": "609b3932d5ba92e7694b37f226c2959f524b8ceee6bfab48cb3ef8acdad525fb", + "size": 69884, + "subdir": "linux-64", + "timestamp": 1510987291117, + "version": "1.5.0" + }, + "execnet-1.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "apipkg >=1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1a75533d5763c4cad273c75ec4f5f04b", + "name": "execnet", + "sha256": "fc8394f31edeff0d5e67eb8ef519517cb6c7e5990813ae3515be827f8a368cff", + "size": 67456, + "subdir": "linux-64", + "timestamp": 1530727939072, + "version": "1.5.0" + }, + "execnet-1.5.0-py36hcd6bdcb_0.conda": { + "build": "py36hcd6bdcb_0", + "build_number": 0, + "depends": [ + "apipkg >=1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "933da7015c2e50d8885440728b154f77", + "name": "execnet", + "sha256": "94786176cac6c69c610efbe4d6254d14f17d117d6ae0590c315d816428afaaeb", + "size": 68910, + "subdir": "linux-64", + "timestamp": 1510987288583, + "version": "1.5.0" + }, + "execnet-1.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "apipkg >=1.4", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "005f24878d890c67a78ae3ad764cc11f", + "name": "execnet", + "sha256": "b8b4c0c97ef22f6bc1c428ecf638af31882baf39a2d0363ee19042701fc575a8", + "size": 68973, + "subdir": "linux-64", + "timestamp": 1530727917769, + "version": "1.5.0" + }, + "expat-2.2.10-he6710b0_2.conda": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8b086ca590c1bd0d2a709d3affbda48", + "name": "expat", + "sha256": "b8e6f0fa7e0586149d833c38cbf46a548fd2ac33219ede74a61b1e2b178906b3", + "size": 156487, + "subdir": "linux-64", + "timestamp": 1602279285212, + "version": "2.2.10" + }, + "expat-2.2.4-h6ea4f2b_2.conda": { + "build": "h6ea4f2b_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "59f84c3f5c11d2eae127b82f30a63277", + "name": "expat", + "sha256": "a250db093aad06aa12fd8cc5a83438693365bef4f81a03be77ded373c64255f4", + "size": 148811, + "subdir": "linux-64", + "timestamp": 1509378905711, + "version": "2.2.4" + }, + "expat-2.2.4-h8e22279_3.conda": { + "build": "h8e22279_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "d45e5a78ee67a4fa5049dac55ae1b892", + "name": "expat", + "sha256": "1d3612ce0aa4f87e4380c3b110a58fe27ef0b9cc65cb6b611003f94dc36f6b8a", + "size": 148835, + "subdir": "linux-64", + "timestamp": 1510603170862, + "version": "2.2.4" + }, + "expat-2.2.4-hc00ebd1_1.conda": { + "build": "hc00ebd1_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "43f9e60963f0bf5e88146d68c7e340ce", + "name": "expat", + "sha256": "0895f86c63ee110d98bd36bcccc4d331d7a2c706289a50dcd9c1785c0e212a8c", + "size": 148036, + "subdir": "linux-64", + "timestamp": 1505687765027, + "version": "2.2.4" + }, + "expat-2.2.5-he0dffb1_0.conda": { + "build": "he0dffb1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "b4ccd5283b7708b3b6ec1d869b8f2fb8", + "name": "expat", + "sha256": "eaa2d830b7eef0495fc8184108afe1254338fec19f4164d04b23cfbc4b7e79fe", + "size": 150091, + "subdir": "linux-64", + "timestamp": 1510608289734, + "version": "2.2.5" + }, + "expat-2.2.6-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "e562997adcc35a8eb9d3cca2ff95054c", + "name": "expat", + "sha256": "55983f90f2a9884e06a62de58297c34d05860dba24d9570bff27827d2dfe7a69", + "size": 149770, + "subdir": "linux-64", + "timestamp": 1535396538938, + "version": "2.2.6" + }, + "expat-2.2.9-he6710b0_2.conda": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c51386e3931ddd81a5f3473c5879fff2", + "name": "expat", + "sha256": "5249c8ef59d3886f2ab7b7468e596fc0f2476c888e44860ac2f3d956cd728da2", + "size": 159301, + "subdir": "linux-64", + "timestamp": 1593113372530, + "version": "2.2.9" + }, + "expat-2.3.0-h2531618_2.conda": { + "build": "h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba5b1fda80a3db1f2e3dd3afbc579fab", + "name": "expat", + "sha256": "90955141f83f7bde0538374082eb9a4bd8fc6fcc10dabfd52814079137614823", + "size": 162017, + "subdir": "linux-64", + "timestamp": 1616699166604, + "version": "2.3.0" + }, + "expat-2.4.1-h2531618_2.conda": { + "build": "h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ae7edbb4278ee49e17a38d98444c6612", + "name": "expat", + "sha256": "dd2a76afaaa65f727cf7d6c7a2fc44db5ac98f2481215b7e6960e2186d79e1a5", + "size": 171768, + "subdir": "linux-64", + "timestamp": 1621849457989, + "version": "2.4.1" + }, + "expat-2.4.4-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9930c60940181cf06d0bd0b8095063c", + "name": "expat", + "sha256": "e5ee99a475f5bebbdc3fe5773cec890cbcdf8c28c08ccab088ed0d8c1d8bff54", + "size": 173404, + "subdir": "linux-64", + "timestamp": 1644418571578, + "version": "2.4.4" + }, + "expat-2.4.9-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a6139fbcd96384855f0e6037502bf28", + "name": "expat", + "sha256": "2ded55ac4db5d830457c88217aabe89cebce5bbeb3a8f8d420126abc13c0926c", + "size": 160087, + "subdir": "linux-64", + "timestamp": 1664286744782, + "version": "2.4.9" + }, + "expressions-0.2.3-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d49622de9a5909cc2413a275e6de458e", + "name": "expressions", + "sha256": "a628cdead6e047f68fe47b84f7c389153cf9efe65426e3ea62dec41b2eca473b", + "size": 15324, + "subdir": "linux-64", + "timestamp": 1537212814479, + "version": "0.2.3" + }, + "expressions-0.2.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "53491d76a66365f61a51f8814f908b98", + "name": "expressions", + "sha256": "6f8f9d1cc72f1adcab0326dd898efa444d22c09137723f3fe83f586215c5932c", + "size": 16939, + "subdir": "linux-64", + "timestamp": 1640809023581, + "version": "0.2.3" + }, + "expressions-0.2.3-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83ffa2dbc83f088eaa16ca435fc2d356", + "name": "expressions", + "sha256": "1be7bc40ae0e888ecf88faa0237046162f8acbacffe68e26e54fe62b77640637", + "size": 15946, + "subdir": "linux-64", + "timestamp": 1537212836938, + "version": "0.2.3" + }, + "expressions-0.2.3-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "179990d33356370a66aab26f0a6e72ea", + "name": "expressions", + "sha256": "aa50fa158c20a2013af0c2b9cac914dcc5739650fd2ef0ef95f85d50a25566e6", + "size": 15886, + "subdir": "linux-64", + "timestamp": 1537212848215, + "version": "0.2.3" + }, + "expressions-0.2.3-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83fda4995491a550644206d14e9142f4", + "name": "expressions", + "sha256": "9588ff14db26b88e33fe72a041f54c8c7786e0a26d7348db82dbfd5e40a03c06", + "size": 256515, + "subdir": "linux-64", + "timestamp": 1613556520176, + "version": "0.2.3" + }, + "expressions-0.2.3-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18350e2dfd30a3d4950455760455a367", + "name": "expressions", + "sha256": "21b0fd849297bf15a98b1acba72c5d038139cd28c86ff2fa619beae2a28d2828", + "size": 15896, + "subdir": "linux-64", + "timestamp": 1537212783991, + "version": "0.2.3" + }, + "expressions-0.2.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a95dc3dbf55a38a52b2ba0f01f07bebf", + "name": "expressions", + "sha256": "32873f06e8468273e41297a55c4bab11abe0f6ed4e0ca7f84ff1e0552f0bb92e", + "size": 255802, + "subdir": "linux-64", + "timestamp": 1613556524899, + "version": "0.2.3" + }, + "expressions-0.2.3-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fef0a4f8e9884d7927034a40afdd9de3", + "name": "expressions", + "sha256": "113ab165432364ce4be5161041bc571882796cde4d0ce8c95f606df76677c6c2", + "size": 16478, + "subdir": "linux-64", + "timestamp": 1573738050196, + "version": "0.2.3" + }, + "expressions-0.2.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0ba22c9b041bdc2863a1d19b990a96a2", + "name": "expressions", + "sha256": "b8f5a84a7f9727f58f45a73a6bff2e0fea606075e97e3f29a884ba4b9b21bd3c", + "size": 258049, + "subdir": "linux-64", + "timestamp": 1613557182978, + "version": "0.2.3" + }, + "expressions-0.2.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "grako >=3.9.3", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58c1a1ae08f7d0c773cb9420f8a68c33", + "name": "expressions", + "sha256": "176db3c663572df117536eb0c1a3959e60a79ad5cda19d8709924a0bf8f0c16f", + "size": 257878, + "subdir": "linux-64", + "timestamp": 1613557182339, + "version": "0.2.3" + }, + "fabric-1.14.0-py27hbb4c3a6_0.conda": { + "build": "py27hbb4c3a6_0", + "build_number": 0, + "depends": [ + "paramiko >=1.10,<3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "78e50a1791d2a114f80cc495f372e696", + "name": "fabric", + "sha256": "7de8c1b68e7848b07fad0362f7dab3916ef7a72e427c192b078d000cee8a2850", + "size": 121701, + "subdir": "linux-64", + "timestamp": 1507933774339, + "version": "1.14.0" + }, + "fabric-2.1.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=1.0", + "invoke >=1.0,<2.0", + "paramiko >=1.10,<3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "318ca23bc800b9c4fe42719f3b2c567a", + "name": "fabric", + "sha256": "e68ad9161f59c46eb1316ea152e0dc3ae848db7fb21c2c32b48f45cb059652f3", + "size": 56180, + "subdir": "linux-64", + "timestamp": 1527696281169, + "version": "2.1.3" + }, + "fabric-2.1.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography >=1.0", + "invoke >=1.0,<2.0", + "paramiko >=1.10,<3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "0df4f25bad7363fb655a87edcaeefcf8", + "name": "fabric", + "sha256": "1033d1d890e2e7776b0f90bbda58999c53b2627e59265638cd8b6dd73f7cfd3a", + "size": 56792, + "subdir": "linux-64", + "timestamp": 1527696320280, + "version": "2.1.3" + }, + "fabric-2.1.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.0", + "invoke >=1.0,<2.0", + "paramiko >=1.10,<3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "09f9326ef8085f7dca2fa94e693756d7", + "name": "fabric", + "sha256": "4e04b9711e94f151f1fc774ce323114276e1047390a7ed9e954687304b9f5166", + "size": 56376, + "subdir": "linux-64", + "timestamp": 1527696259355, + "version": "2.1.3" + }, + "fabric-2.1.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=1.0", + "invoke >=1.0,<2.0", + "paramiko >=1.10,<3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "127a9c04ea0d11993507ed1333ef735d", + "name": "fabric", + "sha256": "6b91ca0559184789aaefd2f749708e9ec3f34972185ce240ddcec2c225e6f88b", + "size": 55050, + "subdir": "linux-64", + "timestamp": 1530876230418, + "version": "2.1.3" + }, + "fabric-2.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=1.1", + "invoke >=1.1,<2.0", + "paramiko >=2.4", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "fb82055a9c6fb55afcad2d499815d29c", + "name": "fabric", + "sha256": "4a82aa0f876e4a96a8369287e924e37d52f4655f0a5a7931d6a9ddb378111e8b", + "size": 59072, + "subdir": "linux-64", + "timestamp": 1535497831904, + "version": "2.3.1" + }, + "fabric-2.3.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography >=1.1", + "invoke >=1.1,<2.0", + "paramiko >=2.4", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "668b89071f05e2835b75b21ac404ffd1", + "name": "fabric", + "sha256": "f686a4bf1013eb1611d37a7165fa75c3285ed22eee601e891fc3da043963df99", + "size": 61063, + "subdir": "linux-64", + "timestamp": 1535497850196, + "version": "2.3.1" + }, + "fabric-2.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.1", + "invoke >=1.1,<2.0", + "paramiko >=2.4", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "bd9b66e4230b14b25f683ff11da8119f", + "name": "fabric", + "sha256": "1f3cfa7881ed7940ac7ff31d7db05dcb500febf7fecbc97f17c0b8ac1debfe8d", + "size": 59358, + "subdir": "linux-64", + "timestamp": 1535497767085, + "version": "2.3.1" + }, + "fabric-2.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=1.1", + "invoke >=1.1,<2.0", + "paramiko >=2.4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "29a810bb80fbc2f0402aec4562193817", + "name": "fabric", + "sha256": "663becc7ec78b3cb91e05420d85087898dff5a712ccff917b00c62119499c6a8", + "size": 60686, + "subdir": "linux-64", + "timestamp": 1535497919455, + "version": "2.3.1" + }, + "fabric-2.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=1.1", + "invoke >=1.1,<2.0", + "paramiko >=2.4", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "0d0e557e80fb0952acfe849a11cb9bf1", + "name": "fabric", + "sha256": "ba74e4a4b1426f306c47483b0ff0a7e15ed9f6ec480f0a4312bc7aed5b31d134", + "size": 63173, + "subdir": "linux-64", + "timestamp": 1539475570762, + "version": "2.4.0" + }, + "fabric-2.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.1", + "invoke >=1.1,<2.0", + "paramiko >=2.4", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "81ee0c6d1949b1d2cb5b9f6d905fb2ae", + "name": "fabric", + "sha256": "25457bcefa374c5d97896d11d55532404b40966ad326d8b0c538e2951f6e4bfc", + "size": 63620, + "subdir": "linux-64", + "timestamp": 1539475614173, + "version": "2.4.0" + }, + "fabric-2.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=1.1", + "invoke >=1.1,<2.0", + "paramiko >=2.4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5baab280253b2aabb1d426155f308452", + "name": "fabric", + "sha256": "a51143b2c4b83000047e64b8e5f18842bc9dc02de010a93f858d2c7e6848a792", + "size": 62457, + "subdir": "linux-64", + "timestamp": 1539475612961, + "version": "2.4.0" + }, + "fabric-2.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b3699dbfc912f1fe092e52534a5621cf", + "name": "fabric", + "sha256": "4323344e5f7cb7094831e4c21e97e24880a09fc08ab9d6029864f28407c47e1e", + "size": 66043, + "subdir": "linux-64", + "timestamp": 1569361112841, + "version": "2.5.0" + }, + "fabric-2.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c6c7ad2a2fc1c603e66e3b48e774dcbd", + "name": "fabric", + "sha256": "a61be4caac1e61bb3b387617551ca719dd879c12131590c60bb8ff40d2f2dbc9", + "size": 66669, + "subdir": "linux-64", + "timestamp": 1569361132801, + "version": "2.5.0" + }, + "fabric-2.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "819a7385ef83d3e777fd24828f090ea5", + "name": "fabric", + "sha256": "b13610bda9c0b4b3d08cb40291df0b7b88cf53b9aa0996c157adccd1a743d89b", + "size": 66667, + "subdir": "linux-64", + "timestamp": 1569361249341, + "version": "2.5.0" + }, + "fabric-2.5.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "90fe413c4451ee8fdc8572d935be33e6", + "name": "fabric", + "sha256": "3f01b0db21fcdddb58b8925798a1abf042ba3459f43fe5f142210e600fdb1d30", + "size": 65012, + "subdir": "linux-64", + "timestamp": 1574177714500, + "version": "2.5.0" + }, + "fabric-2.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b3c739d1bab16bf72aa79a629a46c8bd", + "name": "fabric", + "sha256": "07e92be1c171bce46e57012a6c22b1d6b0006036bf34ebf0b178381da01f94f0", + "size": 65537, + "subdir": "linux-64", + "timestamp": 1640811995074, + "version": "2.6.0" + }, + "fabric-2.6.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c84f3d094052b6281a3a7266048a9e55", + "name": "fabric", + "sha256": "3f90bbfeda9bfe1111f05ff82807ee78453b808c4a6a0ef9e416b327389bac4b", + "size": 78327, + "subdir": "linux-64", + "timestamp": 1676852229434, + "version": "2.6.0" + }, + "fabric-2.6.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a2880bfd26296b31e1094d7a24134c2d", + "name": "fabric", + "sha256": "2cf92db552ad7be47ef7e53db5fbbff5d68dcb2df70d37ce9f88c10f8f9aea10", + "size": 66490, + "subdir": "linux-64", + "timestamp": 1611082275585, + "version": "2.6.0" + }, + "fabric-2.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "587241c06099abf2e4b2d8ed6d6677d4", + "name": "fabric", + "sha256": "7bb4d8d27c98617eac04d7e2adb4fa85485f43d4a60bdd294da20d7662c6dcee", + "size": 66596, + "subdir": "linux-64", + "timestamp": 1611081499825, + "version": "2.6.0" + }, + "fabric-2.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "581e63fdd905ccfb37941814a8b94472", + "name": "fabric", + "sha256": "435f72e8f2e643e9dcf6e586702486701c50b48e1beb605d041bf2d0ad0b2c5e", + "size": 66555, + "subdir": "linux-64", + "timestamp": 1611082266940, + "version": "2.6.0" + }, + "fabric-2.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "invoke >=1.3,<2.0", + "paramiko >=2.4", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ec280275647b703c08fc9bb7ce065ab3", + "name": "fabric", + "sha256": "4cf4a9f043764524e0b27bab86d9d34727e60855e0c11cf308dc66172d39370b", + "size": 67677, + "subdir": "linux-64", + "timestamp": 1614254413728, + "version": "2.6.0" + }, + "fabric3-1.13.1.post1-py27hc4c2163_0.conda": { + "build": "py27hc4c2163_0", + "build_number": 0, + "depends": [ + "paramiko >=1.17.2,<2.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b3c704c1ac3be34c81622f2060087286", + "name": "fabric3", + "sha256": "20c91306e5a52ab9544776c404a997e1e03f47bcd9b5a491c5d9a5d1ae3be953", + "size": 123216, + "subdir": "linux-64", + "timestamp": 1511041304482, + "version": "1.13.1.post1" + }, + "fabric3-1.13.1.post1-py35h70d5be3_0.conda": { + "build": "py35h70d5be3_0", + "build_number": 0, + "depends": [ + "paramiko >=1.17.2,<2.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "0a70e67c55ea280d66007dd8ad77abf1", + "name": "fabric3", + "sha256": "bccc70e39352d1b73c0ccaa43a0abfa0acc804880524b6f5dfbd31557d76fb1b", + "size": 121769, + "subdir": "linux-64", + "timestamp": 1511041310608, + "version": "1.13.1.post1" + }, + "fabric3-1.13.1.post1-py36hde4fd86_0.conda": { + "build": "py36hde4fd86_0", + "build_number": 0, + "depends": [ + "paramiko >=1.17.2,<2.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "136c75520714b3435d87d650e4fb660b", + "name": "fabric3", + "sha256": "35e81d11116593f3fc3966a75a5276fc4fcecce1560f85c33894ef3d8fc09b9f", + "size": 120447, + "subdir": "linux-64", + "timestamp": 1511041308980, + "version": "1.13.1.post1" + }, + "fabric3-1.14.post1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "paramiko >=1.17.2,<2.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4eb845fab7cc894a270b3ddd83ef2b2d", + "name": "fabric3", + "sha256": "2e6c1792790a0624ed98a48035440a8b4a1b876142c6a04511001fa69e93f536", + "size": 123866, + "subdir": "linux-64", + "timestamp": 1522787079036, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "paramiko >=2.0,<3.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3c3394a8899304d3fe592777c3b498b1", + "name": "fabric3", + "sha256": "7d2d2a8759d58f8ec2feb73d05904452851f6baefa7abdf8699aaa6e3fca5a8b", + "size": 121608, + "subdir": "linux-64", + "timestamp": 1530876317107, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "paramiko >=2.0,<3.0", + "python >=3.10,<3.11.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "82633d566cc0e435d7e03223ca00c37a", + "name": "fabric3", + "sha256": "07b1464839dbd45b2bd6afb0d83e876de7a70ba84d4ec6fa29204b324da3c5e1", + "size": 124678, + "subdir": "linux-64", + "timestamp": 1640789856968, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "paramiko >=1.17.2,<2.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ec9f1443bfeedeabd07a120568aa0b3d", + "name": "fabric3", + "sha256": "9f0d8b93ae08ecf019bfc0b1792372975d9081f5cf32ce3936e668059c7c65eb", + "size": 122171, + "subdir": "linux-64", + "timestamp": 1522787074989, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "paramiko >=1.17.2,<2.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "dbb200b7f57e1acbd4c468890b69ef3e", + "name": "fabric3", + "sha256": "41be408878c23a64f12747aedd45ddb02631d974a1440b5e828c874eb93c842f", + "size": 123320, + "subdir": "linux-64", + "timestamp": 1522787083891, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "paramiko >=2.0,<3.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5a487c12bb20c798c6e9fc8a3625f088", + "name": "fabric3", + "sha256": "e1770e442d35de2890e196f6ac2144e18f0766a301828b71ec27cf6a9cbd3c8f", + "size": 120773, + "subdir": "linux-64", + "timestamp": 1530876260481, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "paramiko >=2.0,<3.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "626da080aa6e446c7364d951621a0c46", + "name": "fabric3", + "sha256": "705e057574f842674dbb4f903079988423f834fb5284010f245c59fcd1d9e19b", + "size": 121989, + "subdir": "linux-64", + "timestamp": 1614254405656, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "paramiko >=2.0,<3.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "6d77b318be9940a3c8df80c5fc850d55", + "name": "fabric3", + "sha256": "504a61a3fb08b313de4e56e650a89a7e1828aeed18486dd53dc47374efdce9bd", + "size": 120909, + "subdir": "linux-64", + "timestamp": 1530876289599, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "paramiko >=2.0,<3.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "0ab80b03170aa9a9f6b2d50b5537cf48", + "name": "fabric3", + "sha256": "74e8505654d9e070ce02e42c22bf01f74d709a7d2545daf248f16ee1994ecef3", + "size": 122138, + "subdir": "linux-64", + "timestamp": 1614254395773, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "paramiko >=2.0,<3.0", + "python >=3.8,<3.9.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9abdc1e0ddee4b4dccc00101cdfa2774", + "name": "fabric3", + "sha256": "3d7e7bd8068afbc25823590d6eb1e1aef1ea2da0dd9801840159261dd2847db8", + "size": 123778, + "subdir": "linux-64", + "timestamp": 1574177733705, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "paramiko >=2.0,<3.0", + "python >=3.8,<3.9.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "0b5a08a216fd82d2b4057bb1c6e19655", + "name": "fabric3", + "sha256": "11e48b8385c1e0ad277cd0272d6638fd5c8f9290f2fbca1beb6791cf77da047d", + "size": 122270, + "subdir": "linux-64", + "timestamp": 1614254402071, + "version": "1.14.post1" + }, + "fabric3-1.14.post1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "paramiko >=2.0,<3.0", + "python >=3.9,<3.10.0a0", + "six >=1.10.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "dc442a9f28e0bbbd830c80c98a1c0336", + "name": "fabric3", + "sha256": "2be356816d4ec2a8bc78d5e07de270144a1ecd5341fa6ed9df61cdd0c29296ad", + "size": 124906, + "subdir": "linux-64", + "timestamp": 1614254399507, + "version": "1.14.post1" + }, + "factory_boy-2.10.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d72917e4b3c94d1382019940b7138061", + "name": "factory_boy", + "sha256": "11103e7c9b3575d89d30859391e7345d6835675b0f804c74ed5266dad584b514", + "size": 58690, + "subdir": "linux-64", + "timestamp": 1520882460120, + "version": "2.10.0" + }, + "factory_boy-2.10.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2703975a082c941b88be1cbfde29408f", + "name": "factory_boy", + "sha256": "82e00227ea13f6a5f07a3225545f633a23db91f39150d345d7fb5a9814fe7fc3", + "size": 60018, + "subdir": "linux-64", + "timestamp": 1520882510960, + "version": "2.10.0" + }, + "factory_boy-2.10.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "afe07ea7df2456439269e44d49bb0e50", + "name": "factory_boy", + "sha256": "a79b76a08aeaac9a31fa7028b7285965b473a97fa827a02c06857b7c2f11500d", + "size": 59463, + "subdir": "linux-64", + "timestamp": 1520882442744, + "version": "2.10.0" + }, + "factory_boy-2.11.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba4a404892a450563eedefacb2816549", + "name": "factory_boy", + "sha256": "1d6adb91f8311642faff8d4b3b4e35abfd38d5b88e2cdb809276d4bc261e76fb", + "size": 59622, + "subdir": "linux-64", + "timestamp": 1526940384857, + "version": "2.11.1" + }, + "factory_boy-2.11.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc38479b2e12ca7543e319d005da7e89", + "name": "factory_boy", + "sha256": "e46e98928b22c7bcdd949d5415eb2a9bbf15d126496e9bca1f4c0559c9fef502", + "size": 61842, + "subdir": "linux-64", + "timestamp": 1526940400136, + "version": "2.11.1" + }, + "factory_boy-2.11.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17676f0efbb5aeea3e71710c8700d354", + "name": "factory_boy", + "sha256": "6c2830949c0f562316457f55963d404c181c0bf0f9e340de973b8424196718f5", + "size": 61448, + "subdir": "linux-64", + "timestamp": 1526940366757, + "version": "2.11.1" + }, + "factory_boy-2.11.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8652760059e16dc4b586b9008dbf812e", + "name": "factory_boy", + "sha256": "2e6b2ddb46a9af31b236d912f2dd95d2e0f4a3ba552c0edec07dc05539f421ed", + "size": 60402, + "subdir": "linux-64", + "timestamp": 1530876348285, + "version": "2.11.1" + }, + "factory_boy-2.12.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d43e77fb80c37fba0b8f8fd972d57d3", + "name": "factory_boy", + "sha256": "9a0a034545ae9260f3abab8d6f01f31c7d95cbf185775eab4b9f1cc0f8cc960c", + "size": 63230, + "subdir": "linux-64", + "timestamp": 1559065488486, + "version": "2.12.0" + }, + "factory_boy-2.12.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4b847e0c2bf781ce87ab65de2a40062", + "name": "factory_boy", + "sha256": "2d556671d123900ee3e05f9f9196b2b6ef6935edd81749fd647c4249ad9eaa67", + "size": 64252, + "subdir": "linux-64", + "timestamp": 1559065505854, + "version": "2.12.0" + }, + "factory_boy-2.12.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "faker >=0.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f681c0066dd997cde7b08a747991e6c6", + "name": "factory_boy", + "sha256": "e2a19ffccae75b9de13b7177ffb4df3284d96dceb5d0ab42703315d59991301c", + "size": 63539, + "subdir": "linux-64", + "timestamp": 1588560267918, + "version": "2.12.0" + }, + "factory_boy-2.12.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c7b5ca2498ee3c408f66568a1c9d65de", + "name": "factory_boy", + "sha256": "1b8e459398c98d4d6debd475742217a2305e1fc879a47ca9e81d27d7b8ee704f", + "size": 64515, + "subdir": "linux-64", + "timestamp": 1559065468966, + "version": "2.12.0" + }, + "factory_boy-2.12.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "faker >=0.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7a1805905ffe0792e6da4eb1c33e18e1", + "name": "factory_boy", + "sha256": "00f64762549387f672658781de2d67cb61eed0cdc7671c156c1a2d36bdaa2822", + "size": 62386, + "subdir": "linux-64", + "timestamp": 1588560268890, + "version": "2.12.0" + }, + "factory_boy-2.12.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "faker >=0.7.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "773ea481d1f62203f03f0719065ac790", + "name": "factory_boy", + "sha256": "69b41d31528439f5f5e24d980de0c95b6b2744ef839f53da46763fe0b89df904", + "size": 62773, + "subdir": "linux-64", + "timestamp": 1588560262624, + "version": "2.12.0" + }, + "factory_boy-2.9.2-py27h5e84f35_0.conda": { + "build": "py27h5e84f35_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "24f5038bb70d2584f5730713472ef6a6", + "name": "factory_boy", + "sha256": "cb44421bd40f107a012bf388396105eb2a2fe1f2e108f89bd7ee1640143900f2", + "size": 57740, + "subdir": "linux-64", + "timestamp": 1508957382752, + "version": "2.9.2" + }, + "factory_boy-2.9.2-py35hf635695_0.conda": { + "build": "py35hf635695_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "788cfccd5ee5851813c86079c9f7a68f", + "name": "factory_boy", + "sha256": "781e27ce1205cb6216054517e377939f1d0e8c9409271363d84ee2a1e869dbf7", + "size": 59013, + "subdir": "linux-64", + "timestamp": 1508957381351, + "version": "2.9.2" + }, + "factory_boy-2.9.2-py36h7ef2604_0.conda": { + "build": "py36h7ef2604_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8815ec7deed991cff93cd75c530cc51b", + "name": "factory_boy", + "sha256": "87bd3bae2209fb832b6895e12bbdd3f463323fda1490e5bbf4d170328339e399", + "size": 58612, + "subdir": "linux-64", + "timestamp": 1508957385950, + "version": "2.9.2" + }, + "factory_boy-3.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb6b911f3025929e850aad763c102e8d", + "name": "factory_boy", + "sha256": "0fbe691cb645b92a420897f2d0059655696420a2a56f36ab070387afc835a63a", + "size": 62723, + "subdir": "linux-64", + "timestamp": 1598412480310, + "version": "3.0.1" + }, + "factory_boy-3.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c8c9115da26458867073d604d9a2038", + "name": "factory_boy", + "sha256": "d9ef02416b062aec07bf38e8228f66886f2b65c25b5e9695d9b82447ad619972", + "size": 62380, + "subdir": "linux-64", + "timestamp": 1598412523613, + "version": "3.0.1" + }, + "factory_boy-3.0.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f991025dec8e6c7ed338fc733cf6ef16", + "name": "factory_boy", + "sha256": "c9f05d84a934a6013a5b7b3316bfb4f2e8e5ab02719b06ec5b196e88eb8d89f4", + "size": 63355, + "subdir": "linux-64", + "timestamp": 1598412492549, + "version": "3.0.1" + }, + "factory_boy-3.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc7c19e6b70fff4cdadbb8e71cfe38e3", + "name": "factory_boy", + "sha256": "20765a94a36be6eebfa40e6b163f1fa79e03a9c8e9358008fdaa12ccb3bafc7a", + "size": 60344, + "subdir": "linux-64", + "timestamp": 1601911062308, + "version": "3.1.0" + }, + "factory_boy-3.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e24c10e36556884218b6c982d66d31f", + "name": "factory_boy", + "sha256": "1a52c2674bf71dba0850457d9a314ceb2a42dde8aaca3f93815b457b03a90ea2", + "size": 59279, + "subdir": "linux-64", + "timestamp": 1601911059102, + "version": "3.1.0" + }, + "factory_boy-3.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd9e97d8d8e79db1977990408c42ab21", + "name": "factory_boy", + "sha256": "b100faa3f85931c5553df26489423610bbc10f8ed44e1cc1e6295b7730fd206b", + "size": 60869, + "subdir": "linux-64", + "timestamp": 1601911091952, + "version": "3.1.0" + }, + "factory_boy-3.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b17d689d2bc387a42a8de20bc06abe08", + "name": "factory_boy", + "sha256": "6840b1c6338446d4d6233d85ded87d478547de3a778d124dd2a9ec888a60778d", + "size": 61033, + "subdir": "linux-64", + "timestamp": 1640789874713, + "version": "3.2.0" + }, + "factory_boy-3.2.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8861b05573458243223a93e1926b184e", + "name": "factory_boy", + "sha256": "874750c9d4de9cbbb2a2b2ae6a32ff0ad07be141717d906ee4d86b931ee8ff5d", + "size": 78878, + "subdir": "linux-64", + "timestamp": 1676852259394, + "version": "3.2.0" + }, + "factory_boy-3.2.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af5b56c10e87c26c3706b5f2f1a2f41c", + "name": "factory_boy", + "sha256": "124e412b5c07106f0e3658dbc593b3ce7afc0e948326aa217bb2d0d3f087b30b", + "size": 59825, + "subdir": "linux-64", + "timestamp": 1609265824664, + "version": "3.2.0" + }, + "factory_boy-3.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "54266b7371a1ad67d06e1f8376af3bc2", + "name": "factory_boy", + "sha256": "ead441d2af015e51d813ccce1a469a922ab940e5dc3f95e97a2c94156d585570", + "size": 59723, + "subdir": "linux-64", + "timestamp": 1609265822070, + "version": "3.2.0" + }, + "factory_boy-3.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f94684c4e66a5902c203f3db2b65c35", + "name": "factory_boy", + "sha256": "9f7964fdc285dd9dba426b0f58ee1a9bea35d7b949df1894faae801178f197c5", + "size": 59321, + "subdir": "linux-64", + "timestamp": 1609265839074, + "version": "3.2.0" + }, + "factory_boy-3.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "faker >=0.7.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5319a5ffef5993fa89a5c19b29b62867", + "name": "factory_boy", + "sha256": "d15cad52e7f1a51e390b359f7e473eede93306067f05c553d7e0c9060fd19623", + "size": 60428, + "subdir": "linux-64", + "timestamp": 1609265837458, + "version": "3.2.0" + }, + "faker-0.8.13-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode ==1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a890ccb25d47d55c5d98ce2a956ac48", + "name": "faker", + "sha256": "8fbabe37f2b26c6cfd4bd2e03a2c025e460c5c76617fa45e52c82e4fecbcbebf", + "size": 1185918, + "subdir": "linux-64", + "timestamp": 1524092830613, + "version": "0.8.13" + }, + "faker-0.8.13-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode ==1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02c8a0442a1bd28102e5a16f6a50c239", + "name": "faker", + "sha256": "01d5972bce4da1ea6cbe979cf468101beef5e90092685bbcfc8d35325c3754eb", + "size": 1193745, + "subdir": "linux-64", + "timestamp": 1524092889403, + "version": "0.8.13" + }, + "faker-0.8.13-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode ==1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4580014adb76aa2ed6676cbdfcefb52", + "name": "faker", + "sha256": "af8c7377221617f538286b41c5774a5bfa2d5a2379d1117add5d53cc0fd69121", + "size": 1189168, + "subdir": "linux-64", + "timestamp": 1524092858491, + "version": "0.8.13" + }, + "faker-0.8.15-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a50d2e17ff69a06ffae344e1e722927", + "name": "faker", + "sha256": "eff0b4ac5e09799346ed815914ce5d00023135ef999499c33918027e45f91551", + "size": 1199272, + "subdir": "linux-64", + "timestamp": 1526939821912, + "version": "0.8.15" + }, + "faker-0.8.15-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "81532a60edd483a8115b6d0b119bf23f", + "name": "faker", + "sha256": "6a0c242c5f87f240f152e0a160c94ee87c7fa9b569b5ba7f41cacc2f93ca886a", + "size": 1209228, + "subdir": "linux-64", + "timestamp": 1526939925128, + "version": "0.8.15" + }, + "faker-0.8.15-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "652e4815dbe71dd4874683a7b8cfae5e", + "name": "faker", + "sha256": "fa73d694e0d4449b75d68eddc401a3b0ebb5a991c4f22c56c419322fb76b798a", + "size": 1205056, + "subdir": "linux-64", + "timestamp": 1526939784279, + "version": "0.8.15" + }, + "faker-0.8.16-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "20df18947c100ec28fc86603c613c42b", + "name": "faker", + "sha256": "fb89e4210ef951147c18da7fdac485ba853cac7d16668feb7a398619b37a1177", + "size": 1205870, + "subdir": "linux-64", + "timestamp": 1529443803730, + "version": "0.8.16" + }, + "faker-0.8.16-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "153fe3834c6a730c0f0310cf7a379f99", + "name": "faker", + "sha256": "a11f6360a5ddc3304952377f2267198d45beb23944c4b5fa1f790e68000f6697", + "size": 1210123, + "subdir": "linux-64", + "timestamp": 1529443850334, + "version": "0.8.16" + }, + "faker-0.8.16-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d89a1eeea7b5cafefcf41da91249326b", + "name": "faker", + "sha256": "242d232ddf331a1bc55262dd740dfb510c8e0e4485c22d57ac3ee79929587cb9", + "size": 1204057, + "subdir": "linux-64", + "timestamp": 1529443663560, + "version": "0.8.16" + }, + "faker-0.8.16-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3b6213edae0ae3dd19b5fc926084d2b", + "name": "faker", + "sha256": "6287024805b56373312b6cef77fbf5b06a7ee81cd4076ee4bec0f5a530ac19cb", + "size": 1163999, + "subdir": "linux-64", + "timestamp": 1530727749702, + "version": "0.8.16" + }, + "faker-0.8.6-py27hd0256cd_0.conda": { + "build": "py27hd0256cd_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six", + "text-unidecode" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56a2d0151ae2b7c46dde56c6747f8dd2", + "name": "faker", + "sha256": "6bf7d0f84737e61b70f5a70c49950506d2e91151d7462057d758be45564d11ac", + "size": 1063855, + "subdir": "linux-64", + "timestamp": 1508956457239, + "version": "0.8.6" + }, + "faker-0.8.6-py35h59ce941_0.conda": { + "build": "py35h59ce941_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.4", + "six", + "text-unidecode" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7ce0aedc41fabc03c87256f188ff322", + "name": "faker", + "sha256": "fb94d12c68a4c98493b3e299238262256305f05dcf11b219dcdb41afdad35127", + "size": 1067823, + "subdir": "linux-64", + "timestamp": 1508956507666, + "version": "0.8.6" + }, + "faker-0.8.6-py36h14e001f_0.conda": { + "build": "py36h14e001f_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six", + "text-unidecode" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2254d3bb5ea3f472f921336258061833", + "name": "faker", + "sha256": "6b5bf65ee98fe5f3f4b88da1a2baa4719790cdbcc4ec458985c0e369ea9bf78e", + "size": 1069183, + "subdir": "linux-64", + "timestamp": 1508956528542, + "version": "0.8.6" + }, + "faker-0.9.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1acddf4f91c118015436745a43da4318", + "name": "faker", + "sha256": "c81ab8638d1b37833680ae2e9ed0f06c2db5daa73f997baf19794ba6cc89d03c", + "size": 1205653, + "subdir": "linux-64", + "timestamp": 1535510061588, + "version": "0.9.0" + }, + "faker-0.9.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cfbafa300a8c70c87dd2d551315e2049", + "name": "faker", + "sha256": "ed9935049a89440066d9226857521f9d3791baac7820a00606457bc5be7156c1", + "size": 1212470, + "subdir": "linux-64", + "timestamp": 1535510092897, + "version": "0.9.0" + }, + "faker-0.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "abb3c7e3168c48d98996661fbedb4f32", + "name": "faker", + "sha256": "357496c781ecf51c5df308bc2fd185e6e56dc9c03db61e5989cf885e6f63c892", + "size": 1207743, + "subdir": "linux-64", + "timestamp": 1535510037267, + "version": "0.9.0" + }, + "faker-0.9.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "24a552857edcec032ffe744caff1766c", + "name": "faker", + "sha256": "b5fbf9f44743090a058b6f215a5c95ced020f0709a2d26c6822653cf4ae9ed77", + "size": 1166791, + "subdir": "linux-64", + "timestamp": 1535510069022, + "version": "0.9.0" + }, + "faker-0.9.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "069a794294b0d0a7143f30560ad9a286", + "name": "faker", + "sha256": "085d50e26ee833a74f914c008e5f2db3cd56efe8240c0286bcdc3fc77c61c85f", + "size": 1237934, + "subdir": "linux-64", + "timestamp": 1538360131027, + "version": "0.9.1" + }, + "faker-0.9.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37bf9be043a18bc686c4bb89e300f1b2", + "name": "faker", + "sha256": "26ffd7cbd4144378a68f574b1d1afe42a738b938fff0ba14e30c63e045981827", + "size": 1230426, + "subdir": "linux-64", + "timestamp": 1538360171507, + "version": "0.9.1" + }, + "faker-0.9.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a44ab28d2a69ad767b4d27ab812f8f22", + "name": "faker", + "sha256": "96acbec9988ff399c7b4e572962477a12a4aeceda44a11f8256053985a24a0fa", + "size": 1189080, + "subdir": "linux-64", + "timestamp": 1538360151068, + "version": "0.9.1" + }, + "faker-0.9.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bdbf430f8bae3ce73b2ca38251768e21", + "name": "faker", + "sha256": "b29e21cdd10089b618162801b231b504a16f6601d304e5f0f63ce1d5587ec77e", + "size": 1242042, + "subdir": "linux-64", + "timestamp": 1539721341517, + "version": "0.9.2" + }, + "faker-0.9.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b5b2787013112fea9427e02325d8039", + "name": "faker", + "sha256": "a3f539953ae0b35439b6dd4f9ec28cf8d873e82b7a561b398d9ef6d8850ca520", + "size": 1244037, + "subdir": "linux-64", + "timestamp": 1539721382148, + "version": "0.9.2" + }, + "faker-0.9.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cbf278f436798fdee1f1483f2ce48fbf", + "name": "faker", + "sha256": "cd1a27a82321801cf37dd07d8e0fbd67f8df8bfaa0e49d73887c51d485ce0599", + "size": 1199451, + "subdir": "linux-64", + "timestamp": 1539721356887, + "version": "0.9.2" + }, + "faker-1.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9b55adf5eefbaf415576bb3f4c2145a", + "name": "faker", + "sha256": "39316beba6d03ce76fa2ec8fa455041a9aa755b1dcbaa45bae0a3e72e3741af1", + "size": 1367803, + "subdir": "linux-64", + "timestamp": 1542387769634, + "version": "1.0.0" + }, + "faker-1.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "706786836064d67ac61ca073c0de3392", + "name": "faker", + "sha256": "3440abd31b7caff1402c2620d51804855671d0c873bec966cf25e8ae7a305feb", + "size": 1364356, + "subdir": "linux-64", + "timestamp": 1542387779888, + "version": "1.0.0" + }, + "faker-1.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "252f7d1ebe11591874fa5a2cd5690524", + "name": "faker", + "sha256": "d246c9068c8d9980c16468ff01af374922260699777f1a0aaabce59617cacbce", + "size": 1318073, + "subdir": "linux-64", + "timestamp": 1542387758300, + "version": "1.0.0" + }, + "faker-1.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6013669f1f6d8d4ebbaaa34e9b37a151", + "name": "faker", + "sha256": "6ddc516637d593412a420c7f89ae7bc14ccb6f908d9089abd3fb4d5fbdcc9648", + "size": 1376190, + "subdir": "linux-64", + "timestamp": 1545127578624, + "version": "1.0.1" + }, + "faker-1.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "04237d8362622952d110668baa6ee1b1", + "name": "faker", + "sha256": "caeb5eb63fb194558607b3c46882dfddca0daaa916785f08e050d1863789773d", + "size": 1361615, + "subdir": "linux-64", + "timestamp": 1545127555797, + "version": "1.0.1" + }, + "faker-1.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b816c1ac4f35f5614dca5b580f5c1bbd", + "name": "faker", + "sha256": "7a0df1a125789d8e718156a8950e8cf3d3cb504bac7d7c29ab5736fcfe975a1b", + "size": 1314778, + "subdir": "linux-64", + "timestamp": 1545147399051, + "version": "1.0.1" + }, + "faker-1.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1235bb3d96419c3cea25148c1c6e268e", + "name": "faker", + "sha256": "6ceca0ea781282119542fdfcaf1b6034b40948bb5d0d1c2751c70fbc2933f5a9", + "size": 1384700, + "subdir": "linux-64", + "timestamp": 1550269338340, + "version": "1.0.2" + }, + "faker-1.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "248d06f45d1a0aae974e9cd5c7d44ce6", + "name": "faker", + "sha256": "5a74188ccce58673d8df47e12169e4899432da2da91673bcb9ecabe6a80196be", + "size": 1373474, + "subdir": "linux-64", + "timestamp": 1550269350303, + "version": "1.0.2" + }, + "faker-1.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1dd40de2007defed09366a7beece0350", + "name": "faker", + "sha256": "3e90a6d0aeaea53a348c0540df21c3c8a73f5eac820209bf0392871d63a562b3", + "size": 1325636, + "subdir": "linux-64", + "timestamp": 1550269290281, + "version": "1.0.2" + }, + "faker-1.0.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7aac889461b4ff21766687b0d63e7118", + "name": "faker", + "sha256": "d5ca020bf2733e01012c76d3974a42585efa05e33d1271669304f0ec13550ef6", + "size": 1421949, + "subdir": "linux-64", + "timestamp": 1556081075233, + "version": "1.0.5" + }, + "faker-1.0.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58a8c1ed5058689829db8ea2b6108842", + "name": "faker", + "sha256": "a234e0cc331f4acaec43a2b88e3f1fa7778dcebbfde54ef25a46fc78e4d460ce", + "size": 1409650, + "subdir": "linux-64", + "timestamp": 1556081095526, + "version": "1.0.5" + }, + "faker-1.0.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "477c9845fe1538a464e6604569c86c47", + "name": "faker", + "sha256": "5c1d222f582d7d69ea18137bdd67e956f97513d1ce1a779b5e3953927b11a631", + "size": 1359100, + "subdir": "linux-64", + "timestamp": 1556080924866, + "version": "1.0.5" + }, + "faker-1.0.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f85d25d3a5d99a3d893712c2dcee5804", + "name": "faker", + "sha256": "002711bebc61b6665e77793682a7999920f00a6186ab7ccd488e1fad5279e64f", + "size": 1440536, + "subdir": "linux-64", + "timestamp": 1559064414833, + "version": "1.0.7" + }, + "faker-1.0.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2b005d378ccd13dab4b36c8944994e4", + "name": "faker", + "sha256": "72a28b0f77105306b1a71877f9fa0114137480b1939cffe484766e7fd77b5bc8", + "size": 1427280, + "subdir": "linux-64", + "timestamp": 1559064528812, + "version": "1.0.7" + }, + "faker-1.0.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "237acf624214287c859e6fbe06397415", + "name": "faker", + "sha256": "bc10394b75dcd30acbcb7453a0e3fe5c5d1770c7830b6fef6eaa557d2bb556e6", + "size": 1378955, + "subdir": "linux-64", + "timestamp": 1559064408900, + "version": "1.0.7" + }, + "faker-2.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "975089f3438a86518a194f3a9632bc87", + "name": "faker", + "sha256": "52afc7b878368a3e3ea7cebdb76444c7cdf032e58c229460ad5694c8da238c2e", + "size": 1444558, + "subdir": "linux-64", + "timestamp": 1564674574823, + "version": "2.0.0" + }, + "faker-2.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd89749ae7501550b495000c4b40c8f4", + "name": "faker", + "sha256": "44de5c0763bff9698f1591dadac5ac04c3c50789450b78ab8c6093758d40d0c9", + "size": 1429951, + "subdir": "linux-64", + "timestamp": 1564674598697, + "version": "2.0.0" + }, + "faker-2.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5564f86442980840df031bbaa2e91a76", + "name": "faker", + "sha256": "0447a41188eb5e42c009f6aa4dc99ec9223559949706b92856399450273dfcb5", + "size": 1378636, + "subdir": "linux-64", + "timestamp": 1564674575092, + "version": "2.0.0" + }, + "faker-2.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "291034994e4e91dc3f3e5b6d2e2c6739", + "name": "faker", + "sha256": "c537c34d5510a34e50b918aaa06af3a7c30dda01f8b9a3dcdd364ced9c88fa7a", + "size": 1447317, + "subdir": "linux-64", + "timestamp": 1569419129747, + "version": "2.0.2" + }, + "faker-2.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e5bc2253cf5f6e9551fca76bc426723", + "name": "faker", + "sha256": "ca52ebdaeae8c380a6756effc126bf9e44b7f3ce54db73abe6bf7e7029b0f39b", + "size": 1434190, + "subdir": "linux-64", + "timestamp": 1569419122208, + "version": "2.0.2" + }, + "faker-2.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0ade01ab03eaf30c6f9d3c55dd990547", + "name": "faker", + "sha256": "1735f6d8fcf8b097e012be6b63acc6f3a6ed2d26dbd1aa8410079b9eca80ca60", + "size": 1387080, + "subdir": "linux-64", + "timestamp": 1569419120779, + "version": "2.0.2" + }, + "faker-2.0.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bac8be29c135174b654e0101155f6931", + "name": "faker", + "sha256": "855a43a8b17b297edb56cf6945e5f788c650d4604356bb34e5b878469918a35d", + "size": 1569686, + "subdir": "linux-64", + "timestamp": 1573963518900, + "version": "2.0.4" + }, + "faker-2.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2a428504bab379a1dc8e0108fdc66983", + "name": "faker", + "sha256": "24776f3c8b3c2bf0af6e9cc616de627f6b6e51a7fe3f0188cf2938ae9989bfe8", + "size": 1555450, + "subdir": "linux-64", + "timestamp": 1573963454799, + "version": "2.0.4" + }, + "faker-2.0.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5cca0a60f0a5f6270c7deac8ebf2ad12", + "name": "faker", + "sha256": "dbf3efa5adcb5f8d8bd4f0d3c7820995485f66fb61ba7be1fb2ed965cdf28f84", + "size": 1507750, + "subdir": "linux-64", + "timestamp": 1573963509837, + "version": "2.0.4" + }, + "faker-2.0.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "365a1f9e9c74d7ae8995efc24c60698f", + "name": "faker", + "sha256": "d34de82250f6e5f535821887926b3d7617b056057825bf096b102a3fdbfd11f6", + "size": 1511114, + "subdir": "linux-64", + "timestamp": 1574251298577, + "version": "2.0.4" + }, + "faker-3.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18c3ce31546e56557b4ab46feac93202", + "name": "faker", + "sha256": "dec2be4296b25845910e48a725ab0461c7527788ed2ebf5671a1bc89e2a1c727", + "size": 1581399, + "subdir": "linux-64", + "timestamp": 1576689279588, + "version": "3.0.0" + }, + "faker-3.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31473097226a759d18a2f628addcd492", + "name": "faker", + "sha256": "c8f23782d37020d3737634ece19e22a6fdf3ab605c45fa9cf8647676557645aa", + "size": 1564698, + "subdir": "linux-64", + "timestamp": 1576689276661, + "version": "3.0.0" + }, + "faker-3.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cdab5ff21d4463cdbee918717cbcc145", + "name": "faker", + "sha256": "2504589ff3d6e9937c75ea658523a9c8943b11b54d77087ceaa3f78c770ea664", + "size": 1515074, + "subdir": "linux-64", + "timestamp": 1576689275402, + "version": "3.0.0" + }, + "faker-4.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3715ac77b12d2c8a5915e1eba44f04a0", + "name": "faker", + "sha256": "2bf5ba357904c2c8f580af7f22793862f40a0d690554de7f09967c5ed684c284", + "size": 1640011, + "subdir": "linux-64", + "timestamp": 1588474968267, + "version": "4.0.3" + }, + "faker-4.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bdfd16f58e8fc2999109b203ffe78e76", + "name": "faker", + "sha256": "c2e858c36408c3402338ea6b30f18316dbeb0127cd48df675d66171f08594ff0", + "size": 1585622, + "subdir": "linux-64", + "timestamp": 1588474968948, + "version": "4.0.3" + }, + "faker-4.0.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.4", + "six >=1.10", + "text-unidecode 1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a302e281a4182d8f87cebe5bdb5fae3a", + "name": "faker", + "sha256": "dd3e31097e229e74db3455e71505d3c496c195eedafb4ef0a28c276e3e6915b3", + "size": 1599810, + "subdir": "linux-64", + "timestamp": 1588474978782, + "version": "4.0.3" + }, + "fast-histogram-0.3-py27h3010b51_0.conda": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "97082ce41b529640c95a086288bbb50f", + "name": "fast-histogram", + "sha256": "9ffcf170427ae7d887be3b4ecaa6fb32a54bfa799c2bb8932f4386f71bc77768", + "size": 17269, + "subdir": "linux-64", + "timestamp": 1525294123069, + "version": "0.3" + }, + "fast-histogram-0.3-py35h3010b51_0.conda": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "a22bfee1c4ca434a2e23294c0e8497a6", + "name": "fast-histogram", + "sha256": "9b3e43d73648ec06f541d1d730e95bce6ff29dbd7a534582c5be4c6772b5f880", + "size": 17236, + "subdir": "linux-64", + "timestamp": 1525294122551, + "version": "0.3" + }, + "fast-histogram-0.3-py36h3010b51_0.conda": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "298093392a73b8caf3212416ee734a10", + "name": "fast-histogram", + "sha256": "15e84852836bce07fae43493430fbfab9aa44c2d1c55fb1eafcbca1fa74bcf10", + "size": 17213, + "subdir": "linux-64", + "timestamp": 1525293360430, + "version": "0.3" + }, + "fast-histogram-0.4-py27h035aef0_0.conda": { + "build": "py27h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "35677227274804570f537888ce41da31", + "name": "fast-histogram", + "sha256": "4b5dab07f6aa5207868c94e48f0949534791c9f199aa216c393e0ab4d251d889", + "size": 17201, + "subdir": "linux-64", + "timestamp": 1530890962389, + "version": "0.4" + }, + "fast-histogram-0.4-py27h3010b51_0.conda": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "9eb9eb043b2fcae6fba44e90ff55de90", + "name": "fast-histogram", + "sha256": "3190aaca9dc928a6f50f14ab68585e5ce94427d3c4e1c68a8bf8445f1077c1a3", + "size": 17141, + "subdir": "linux-64", + "timestamp": 1526943674066, + "version": "0.4" + }, + "fast-histogram-0.4-py35h3010b51_0.conda": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "711e1549957b8546b270de768e1d8411", + "name": "fast-histogram", + "sha256": "8b05d14e61f54b6d424d6193d247673564504380f8e89d25015cc630ed589181", + "size": 17088, + "subdir": "linux-64", + "timestamp": 1526943624843, + "version": "0.4" + }, + "fast-histogram-0.4-py36h035aef0_0.conda": { + "build": "py36h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "68d4fb1df5dad2889e3194dd143225e7", + "name": "fast-histogram", + "sha256": "c003a231b0ec3e0d21015a6996f254f176f89c54c1f007d068d062cb93ac4c2f", + "size": 17118, + "subdir": "linux-64", + "timestamp": 1530890933923, + "version": "0.4" + }, + "fast-histogram-0.4-py36h3010b51_0.conda": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "1ca9ebc5bd77527ddefa598edc9a477d", + "name": "fast-histogram", + "sha256": "12a8c13508d3d7181da9a30a0357c027d50a1f8f6886a0a12f331608ce0090fd", + "size": 17046, + "subdir": "linux-64", + "timestamp": 1526943993536, + "version": "0.4" + }, + "fast-histogram-0.4-py37h035aef0_0.conda": { + "build": "py37h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "8ef9ae3c702daca44642e481361ea25a", + "name": "fast-histogram", + "sha256": "0a67f163ca5b03191cea898b6dffebca6a940928c5bfbfe1a481004692af52d4", + "size": 17053, + "subdir": "linux-64", + "timestamp": 1530890904045, + "version": "0.4" + }, + "fast-histogram-0.5-py27hdd07704_1.conda": { + "build": "py27hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "d302fd32a4d240d566e8b079e7a4b331", + "name": "fast-histogram", + "sha256": "c7082e0bf1b143630226921e7d6202ea6374be8f71e2db34e7635724433e5c16", + "size": 19938, + "subdir": "linux-64", + "timestamp": 1535424228546, + "version": "0.5" + }, + "fast-histogram-0.5-py35hdd07704_1.conda": { + "build": "py35hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "4a242bd8610802780596a758fae3b88e", + "name": "fast-histogram", + "sha256": "3f1c890648db399d4c1f9cd376cf17658bb8db994db38fb65eae4178b09a6d0a", + "size": 20078, + "subdir": "linux-64", + "timestamp": 1535424650350, + "version": "0.5" + }, + "fast-histogram-0.5-py36hdd07704_1.conda": { + "build": "py36hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "9a27137bbefa552d3f6d440050d3fcfc", + "name": "fast-histogram", + "sha256": "651be6c711b8617a60a4b4c0896f5d4d7dab4c8ccbcacf407c61cd6593f62028", + "size": 20032, + "subdir": "linux-64", + "timestamp": 1535424631908, + "version": "0.5" + }, + "fast-histogram-0.5-py37hdd07704_1.conda": { + "build": "py37hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "09463208b70ae98142d76084e164c803", + "name": "fast-histogram", + "sha256": "6a0b6cac213eb74eaf06f206066a7a384ba4e06e6ae4c3116f445f5dd278e40b", + "size": 19781, + "subdir": "linux-64", + "timestamp": 1535424775835, + "version": "0.5" + }, + "fast-histogram-0.7-py27hdd07704_1000.conda": { + "build": "py27hdd07704_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "54087ad44f6d8ccff59e498d77e7cbb0", + "name": "fast-histogram", + "sha256": "f59e389705322bd035ea46e8aec982b61beab23c0ae1b0982ae39c540c6c9962", + "size": 23310, + "subdir": "linux-64", + "timestamp": 1552376168634, + "version": "0.7" + }, + "fast-histogram-0.7-py36hdd07704_1000.conda": { + "build": "py36hdd07704_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "98468cf6e5d7f94917c1bb14c40f0eb9", + "name": "fast-histogram", + "sha256": "4035a174d45996e0ac0c36ac2e2a6cf59bf4ba84c70d1d7e5f9e5ce9c4a54f05", + "size": 23328, + "subdir": "linux-64", + "timestamp": 1552376191866, + "version": "0.7" + }, + "fast-histogram-0.7-py37hdd07704_1000.conda": { + "build": "py37hdd07704_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "0e0b1969855525c687457bbf2f90b57c", + "name": "fast-histogram", + "sha256": "75a4c5d6dd40e0f34ca16a374a3c067170620a1e0b81fcd345ffaedbc7f32780", + "size": 23113, + "subdir": "linux-64", + "timestamp": 1552376142575, + "version": "0.7" + }, + "fast-histogram-0.7-py38hdd07704_1000.conda": { + "build": "py38hdd07704_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "720425f5faace91620ee1ae7881046d5", + "name": "fast-histogram", + "sha256": "ab632ecbda4f270c182261bb95253e72b2e0c4cc00f071f2c3ebcf77f388ae78", + "size": 27585, + "subdir": "linux-64", + "timestamp": 1573738175112, + "version": "0.7" + }, + "fast-histogram-0.8-py36heb32a55_1000.conda": { + "build": "py36heb32a55_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "8986f7db7d0f8f1f8c7ceaf7d264f961", + "name": "fast-histogram", + "sha256": "3f8180b55c046d6cd183c19b7cc9e6574bc7a4c34f6ffaeb4e22234a1b6f676f", + "size": 22964, + "subdir": "linux-64", + "timestamp": 1583249450589, + "version": "0.8" + }, + "fast-histogram-0.8-py37heb32a55_1000.conda": { + "build": "py37heb32a55_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "7f8d976c564dcddde872492c97ce7cf7", + "name": "fast-histogram", + "sha256": "d2049407c8d33a20366250b80fb4feb1690f43e2811a412526e9554df8163786", + "size": 22902, + "subdir": "linux-64", + "timestamp": 1583249387141, + "version": "0.8" + }, + "fast-histogram-0.8-py38heb32a55_1000.conda": { + "build": "py38heb32a55_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "69118fe57d4d5d84020a885aa6b6d288", + "name": "fast-histogram", + "sha256": "768585a2d334f7c4c55905d66f8964426a9432a0d9bb7db505a3a15a08b53cda", + "size": 23480, + "subdir": "linux-64", + "timestamp": 1583249403171, + "version": "0.8" + }, + "fast-histogram-0.9-py310h9102076_0.conda": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "2c4009ecfc75adc4a948693b90eb4bcc", + "name": "fast-histogram", + "sha256": "7b7a572b4b1e436623b5c70a96595281b374db5de05bbee65c6c0ca1322c11e3", + "size": 40971, + "subdir": "linux-64", + "timestamp": 1640789902988, + "version": "0.9" + }, + "fast-histogram-0.9-py311hbed6279_0.conda": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "1f7cff46c581a3376588f2b1e894ef9e", + "name": "fast-histogram", + "sha256": "0df66d96612dec8087945ff0e1a21b4e825af55224fcc0b0281dfe8741cd9c0f", + "size": 25051, + "subdir": "linux-64", + "timestamp": 1676830508531, + "version": "0.9" + }, + "fast-histogram-0.9-py36h6323ea4_0.conda": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "bb19fb2fc67b4a5deab2de02132b34aa", + "name": "fast-histogram", + "sha256": "3879eda4eb126aaa9505dca6c463f5693829f6496ea9fe9476ba183f1f9515e0", + "size": 24221, + "subdir": "linux-64", + "timestamp": 1614080141062, + "version": "0.9" + }, + "fast-histogram-0.9-py36heb32a55_0.conda": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "b027570fe4521f6e6fbd40f8ae87e098", + "name": "fast-histogram", + "sha256": "1fd894de2867cebf7ce09295fd28cf3b141dae694d44343bfa76be93adca4a9b", + "size": 24023, + "subdir": "linux-64", + "timestamp": 1591836792107, + "version": "0.9" + }, + "fast-histogram-0.9-py37h6323ea4_0.conda": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "63b3dd1a18e9e014867e601577334d72", + "name": "fast-histogram", + "sha256": "496c3c951b0361d78a6a7ab8331ff4ebb5e4de7032fd55b4a857f592d9f418ff", + "size": 24027, + "subdir": "linux-64", + "timestamp": 1614079232710, + "version": "0.9" + }, + "fast-histogram-0.9-py37heb32a55_0.conda": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "b63f7bbc2626c94ec6c7412d38a68d74", + "name": "fast-histogram", + "sha256": "c9c4c08187eb87b1d1859553b829bee4ae6b8480463a8c529053644967235c05", + "size": 23747, + "subdir": "linux-64", + "timestamp": 1591836771482, + "version": "0.9" + }, + "fast-histogram-0.9-py38h6323ea4_0.conda": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "038385ed26f12c699e4b781374be8e14", + "name": "fast-histogram", + "sha256": "7e475b95b72f813ff6d95fe67836b3be5b0fcd938a4d4cd82a7c7ab8b0d5103a", + "size": 24327, + "subdir": "linux-64", + "timestamp": 1614079228110, + "version": "0.9" + }, + "fast-histogram-0.9-py38heb32a55_0.conda": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "da0ae21b60e47dc93a29107ec7d82e07", + "name": "fast-histogram", + "sha256": "9a8460e8e52af0ecfd3a8b993ffef79e8c183589d8285fdd7ab752fc52987ac0", + "size": 24321, + "subdir": "linux-64", + "timestamp": 1591836755275, + "version": "0.9" + }, + "fast-histogram-0.9-py39h6323ea4_0.conda": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "a0ca869a1a41d8e6cc7e61775dc240a1", + "name": "fast-histogram", + "sha256": "a25cc738b23404d5854a312b4e2c450ca180586f3c20f597d23a31bc1dec63ce", + "size": 24636, + "subdir": "linux-64", + "timestamp": 1614080128413, + "version": "0.9" + }, + "fastavro-0.17.10-py27h14c3975_1.conda": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "19f5719924613de62649804a9ee7eef8", + "name": "fastavro", + "sha256": "7b703d1dcdff55b037121d1564a51f3a272e06bd15a2b9ca7d26341733353f5e", + "size": 301029, + "subdir": "linux-64", + "timestamp": 1522790188086, + "version": "0.17.10" + }, + "fastavro-0.17.10-py35h14c3975_1.conda": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "d1eae8dcb46821c23f6dce9a2b8bbfa3", + "name": "fastavro", + "sha256": "314c6c3f56b4d3100b2c756b3a86884c43ca8bb2a42479372259d8ac4b025dc3", + "size": 302418, + "subdir": "linux-64", + "timestamp": 1522790337248, + "version": "0.17.10" + }, + "fastavro-0.17.10-py36h14c3975_1.conda": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "11d2534776b694fb75c77a75f75db9ff", + "name": "fastavro", + "sha256": "9a6dd393c142dc161c7dd28a4818c43c69da047d994a8e93cd97b02b3a925481", + "size": 311022, + "subdir": "linux-64", + "timestamp": 1522790468195, + "version": "0.17.10" + }, + "fastavro-0.17.5-py27h14c3975_1.conda": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "440e584f1fa63acd71aded0cb64df3cf", + "name": "fastavro", + "sha256": "9c15e49ea671a5376fe69199109f16e77a50a0c4d80f8b0717e6eb0442a8aa5d", + "size": 306979, + "subdir": "linux-64", + "timestamp": 1516906015047, + "version": "0.17.5" + }, + "fastavro-0.17.5-py35h14c3975_1.conda": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "3c98ac5175970532b224fed5cf327015", + "name": "fastavro", + "sha256": "9f00f47c8b1a18b7f157fe7635da5ac1ba7d1e0e220ca24b505cd0f84498cc9d", + "size": 308451, + "subdir": "linux-64", + "timestamp": 1516906051626, + "version": "0.17.5" + }, + "fastavro-0.17.5-py36h14c3975_1.conda": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "efffe3758b0bae8ecafb16ec62fc5f26", + "name": "fastavro", + "sha256": "2159bbefc36d78d7eab65e0b0e14d5d0a55cf56a14024c54df67dc39f8e21d9e", + "size": 317567, + "subdir": "linux-64", + "timestamp": 1516906053340, + "version": "0.17.5" + }, + "fastavro-0.19.3-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "2a574fd95b0c3a7d0c368440ccd6916f", + "name": "fastavro", + "sha256": "aa6ae638e15aaa3958c6953bb2947b8b6c34360cc331a5d56b4f405a26daabb9", + "size": 301999, + "subdir": "linux-64", + "timestamp": 1526943496142, + "version": "0.19.3" + }, + "fastavro-0.19.3-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "54edb3ed887e70f89e01d89ad203a9a1", + "name": "fastavro", + "sha256": "30fde64951f53381a9adca9d9f9403fafd1c383f466a71d08b704beb79a3356a", + "size": 305010, + "subdir": "linux-64", + "timestamp": 1526942949930, + "version": "0.19.3" + }, + "fastavro-0.19.3-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6e630b8df689ec0a36de950cc0acdfdd", + "name": "fastavro", + "sha256": "566456d1bfc58a23c84d72a9840d4ca252be56cb1f433be4b5c55578706fec5d", + "size": 312911, + "subdir": "linux-64", + "timestamp": 1526942897511, + "version": "0.19.3" + }, + "fastavro-0.19.5-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "1c0fe55ff1a5123bfb172677b8823985", + "name": "fastavro", + "sha256": "079ae8f7d6bffc23a8ea604fe8346df7ffe8405a13b45e5a708c9ef40a1061bc", + "size": 324194, + "subdir": "linux-64", + "timestamp": 1527854019353, + "version": "0.19.5" + }, + "fastavro-0.19.5-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "89edc365cfff31c5659f0c14a6848f3c", + "name": "fastavro", + "sha256": "665681273ac85a8a70732377f617fd99a2d7c1deb612e6f41c24c529657b1865", + "size": 326772, + "subdir": "linux-64", + "timestamp": 1527854041721, + "version": "0.19.5" + }, + "fastavro-0.19.5-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f1fe5660af3467dbb6cdf2c79e4489ad", + "name": "fastavro", + "sha256": "c2a7659a9bae1c57c04af2be265a71205bfd3aaaee18541d5a7d4ec47b5eb2c5", + "size": 337091, + "subdir": "linux-64", + "timestamp": 1527854022351, + "version": "0.19.5" + }, + "fastavro-0.19.6-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c77be1eee1fd1062d00911125ebca0b2", + "name": "fastavro", + "sha256": "83d3436013f0db318d29320fe2ad328b2ec2b4679432a52ab5aa271199cd171d", + "size": 324610, + "subdir": "linux-64", + "timestamp": 1528221254164, + "version": "0.19.6" + }, + "fastavro-0.19.6-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "aca24d7bbfafeb4d98a923ed3355f8ad", + "name": "fastavro", + "sha256": "6cd7bcc6477fc91b4b09fd679409f0fcde8cb38364b5bd04242f344fef0b2af5", + "size": 326636, + "subdir": "linux-64", + "timestamp": 1528221175044, + "version": "0.19.6" + }, + "fastavro-0.19.6-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "40c32d6382b01ca89edfcbca9b00f5dd", + "name": "fastavro", + "sha256": "dd9571c29045dea72755237635184a8e46433639d9de1bfacfb89463a382d065", + "size": 336269, + "subdir": "linux-64", + "timestamp": 1528221245099, + "version": "0.19.6" + }, + "fastavro-0.19.7-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d2366ae4bdc339cf53a50601385d3ec9", + "name": "fastavro", + "sha256": "ddaef1fc209c9a20f08d0bfca8c810120d430a05133f5a66f101908d8b838a33", + "size": 322732, + "subdir": "linux-64", + "timestamp": 1529443765019, + "version": "0.19.7" + }, + "fastavro-0.19.7-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "d10f560d68e381ba75c7904855fd1118", + "name": "fastavro", + "sha256": "0d2cb7053de06d515ce587d7cd416c74f3a7d6e6a20093253a5edd9b0ec15551", + "size": 325634, + "subdir": "linux-64", + "timestamp": 1529443769217, + "version": "0.19.7" + }, + "fastavro-0.19.7-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3d2912af84eead7bd2245e4dbcdb03ed", + "name": "fastavro", + "sha256": "3fa13a521ab9f1c828bbcda1a1a0f4fb0cb21cc5c9d9bc7f9a73b2ae5b6573b4", + "size": 336120, + "subdir": "linux-64", + "timestamp": 1529443385115, + "version": "0.19.7" + }, + "fastavro-0.19.7-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "96a5d185b64ebcb432d20c8bf5cb6695", + "name": "fastavro", + "sha256": "112973c79f4e3c75b33f518ae56cd2eb2fc9bb959795e228d2cef639a480c19b", + "size": 334518, + "subdir": "linux-64", + "timestamp": 1530876405406, + "version": "0.19.7" + }, + "fastavro-0.21.11-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "6f1c5b3a5ae83138f4101854b4ffc0c0", + "name": "fastavro", + "sha256": "8b7d7afc2b48e58009704f98984b494dd5cdd1d3816609dff62516176ab58334", + "size": 295208, + "subdir": "linux-64", + "timestamp": 1540964903902, + "version": "0.21.11" + }, + "fastavro-0.21.11-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4a484dbe41fdddca8358ae1ff19bad1a", + "name": "fastavro", + "sha256": "ee1fde204bdbc4226e86b70c5e3920d9d3c2b19f65053b1e682b8b151497d926", + "size": 313372, + "subdir": "linux-64", + "timestamp": 1540964952723, + "version": "0.21.11" + }, + "fastavro-0.21.11-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3811dd97af59b3870c1b8899b8273183", + "name": "fastavro", + "sha256": "9ee62808ad56ab5662b83a1665d556f36fddfc3df5bbdfbd2319c13fe14f075f", + "size": 312285, + "subdir": "linux-64", + "timestamp": 1540964951665, + "version": "0.21.11" + }, + "fastavro-0.21.12-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "25b5d19fc3375d815cf9981073691a1c", + "name": "fastavro", + "sha256": "88bada22d21532376919748959968eedf8fe2ac64d06dec0ce15068eaf57c2a3", + "size": 293883, + "subdir": "linux-64", + "timestamp": 1541105875934, + "version": "0.21.12" + }, + "fastavro-0.21.12-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "87c777e8f155dd9f1cab5ed9936f0700", + "name": "fastavro", + "sha256": "582915099004279aa132279f6f5b54f76b8867b8f8ed2aedcf293c9ae15e1be2", + "size": 313334, + "subdir": "linux-64", + "timestamp": 1541105897170, + "version": "0.21.12" + }, + "fastavro-0.21.12-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2cb4451cb1f2cb41c032c99a8f8b23c6", + "name": "fastavro", + "sha256": "53bbc9c657d6e7065c3c986b22efc66cc943923eb393139f02c984cfb8e3e0d5", + "size": 312121, + "subdir": "linux-64", + "timestamp": 1541105814618, + "version": "0.21.12" + }, + "fastavro-0.21.13-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d79c4120810dbf95be5bcc4b9479036b", + "name": "fastavro", + "sha256": "44853746380ec2d9fcdf865ecee349b73326f54a70735c2674631427c4b9b4ff", + "size": 295851, + "subdir": "linux-64", + "timestamp": 1542078613692, + "version": "0.21.13" + }, + "fastavro-0.21.13-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "24341b74560f7651f9a4a10c789ca904", + "name": "fastavro", + "sha256": "b20e0ecd37ecedddc43d10a66e8f43e701e356913173077f1bb79d6b68df7742", + "size": 314469, + "subdir": "linux-64", + "timestamp": 1542078644587, + "version": "0.21.13" + }, + "fastavro-0.21.13-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "393cab24e1da900f06eb8cd293eacab8", + "name": "fastavro", + "sha256": "e46c8b897be285d4f96f90367237f842e23dfe6df0efd59eec305b55a4d7ae81", + "size": 313046, + "subdir": "linux-64", + "timestamp": 1542078615736, + "version": "0.21.13" + }, + "fastavro-0.21.14-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5363176d23eaa05bc9dd36067cbd6df5", + "name": "fastavro", + "sha256": "6bbbf51dbec9bb76c89df4fa702bd83c49f768cb2104922932047915578cc0a3", + "size": 296828, + "subdir": "linux-64", + "timestamp": 1542639112966, + "version": "0.21.14" + }, + "fastavro-0.21.14-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b24acb11b542792a34dd456b5c41c7d1", + "name": "fastavro", + "sha256": "67deb48941b776477ae9ba8ae15a89ff806a5c963b6f110c945568056e283032", + "size": 315380, + "subdir": "linux-64", + "timestamp": 1542639145129, + "version": "0.21.14" + }, + "fastavro-0.21.14-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "95037938e0b0079c03fda9f4e918d1ae", + "name": "fastavro", + "sha256": "f9949a989a76831796792788145087440c549b8d7fff89e5065fd7863f10d782", + "size": 313017, + "subdir": "linux-64", + "timestamp": 1542639103685, + "version": "0.21.14" + }, + "fastavro-0.21.15-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9ca7de519115436a73192953d6a9792c", + "name": "fastavro", + "sha256": "c2a72235f77ffcf2692b2776daa255ed9463fe61d3eddad27f1a02f465ba4500", + "size": 297642, + "subdir": "linux-64", + "timestamp": 1545147112964, + "version": "0.21.15" + }, + "fastavro-0.21.15-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ed5f2428b22782c42e6a598a25b27561", + "name": "fastavro", + "sha256": "53b4ace437b3cd7d631d07f6c0ca8e389fa6c0aa21c7fbeb8527263fca6b70b9", + "size": 316717, + "subdir": "linux-64", + "timestamp": 1545129557379, + "version": "0.21.15" + }, + "fastavro-0.21.15-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "aab78f6117ad4cc93f140f50cd2dc1bc", + "name": "fastavro", + "sha256": "7794d2498399ef000c8aac39e64f51ff6b33f0301464558e02faa5d3c10254e4", + "size": 315411, + "subdir": "linux-64", + "timestamp": 1545129562691, + "version": "0.21.15" + }, + "fastavro-0.21.16-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b9db1f8f26004c51fe258c6c94820172", + "name": "fastavro", + "sha256": "c3b044accacc500ca98645d2baa699170772c8d8fb609a849e30bb3e1489d59a", + "size": 304510, + "subdir": "linux-64", + "timestamp": 1547228153268, + "version": "0.21.16" + }, + "fastavro-0.21.16-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "87eca651f80492051831638258bc26d9", + "name": "fastavro", + "sha256": "6462152d61a0760524daffd241cc937a306c6bfa33cf2d5a0a582b9eb2a4458d", + "size": 324206, + "subdir": "linux-64", + "timestamp": 1547228278530, + "version": "0.21.16" + }, + "fastavro-0.21.16-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "0428f319986be10ca124f2dd2b4c6df6", + "name": "fastavro", + "sha256": "215f5f0f02460d73540e8bb530a9ef6bdc6d61c08383bda97317fd70ae4c02d1", + "size": 322787, + "subdir": "linux-64", + "timestamp": 1547228278372, + "version": "0.21.16" + }, + "fastavro-0.21.18-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ad6c5a1deb660d78813eb93abc909d43", + "name": "fastavro", + "sha256": "ab8944b5d75477011111ecbd4b97e2269e797314d0844af256dd0d3741cae0be", + "size": 305045, + "subdir": "linux-64", + "timestamp": 1550269505928, + "version": "0.21.18" + }, + "fastavro-0.21.18-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "16b7983c704383de9f3443af8c7d47dc", + "name": "fastavro", + "sha256": "292122252b1623685193123852c3f3fc905f99f5b75af65760620f83d961db0f", + "size": 326464, + "subdir": "linux-64", + "timestamp": 1550269513327, + "version": "0.21.18" + }, + "fastavro-0.21.18-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d6561338fb68f8736fdb19990e461a7d", + "name": "fastavro", + "sha256": "e7056ea2e8f7ecb5dd245041b3978962873c1746ace9b077e8fab21aac96612f", + "size": 324800, + "subdir": "linux-64", + "timestamp": 1550269481274, + "version": "0.21.18" + }, + "fastavro-0.21.19-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "48ed3aeac492e7369a5a9eb47d66b839", + "name": "fastavro", + "sha256": "bfbb3834818e13c7647ad205a2526b2caa2dd405b7ad6ac183715f9531dc4aef", + "size": 306975, + "subdir": "linux-64", + "timestamp": 1552376670083, + "version": "0.21.19" + }, + "fastavro-0.21.19-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f0b8cbbf30d845ba7f0a4e2b4604f425", + "name": "fastavro", + "sha256": "cccf564c0d073e508d38841fe204461e8d2b0e7c039b58e3675eedadbd869f6c", + "size": 327626, + "subdir": "linux-64", + "timestamp": 1552376713638, + "version": "0.21.19" + }, + "fastavro-0.21.19-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "944d73537a3f210e081f84a695e81114", + "name": "fastavro", + "sha256": "fa68dbad146473865ed7c15c14fd2a926ba5bcdfa27796a32c7c667547842e59", + "size": 323873, + "subdir": "linux-64", + "timestamp": 1552376643879, + "version": "0.21.19" + }, + "fastavro-0.21.21-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "8073b81576536c93c799efefda89c75b", + "name": "fastavro", + "sha256": "e4c0046f1e0edffdae16529bacf09710e5a288309d6fd0d5764703df28ccf2de", + "size": 308275, + "subdir": "linux-64", + "timestamp": 1556081464914, + "version": "0.21.21" + }, + "fastavro-0.21.21-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d8ab8b62c557e4ff28f5b7ad0cd9b8e0", + "name": "fastavro", + "sha256": "c236a122e0437b294e820c24d9d7ae38cd96e3e9888153aa3f19ff02c1232400", + "size": 328195, + "subdir": "linux-64", + "timestamp": 1556112708224, + "version": "0.21.21" + }, + "fastavro-0.21.21-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e8df304a3d60e27eaf8e568f9db489a9", + "name": "fastavro", + "sha256": "a160a6943c160fcda2f5076f710c166b3e71ee6815b88d5f79eaa6fb948d86c5", + "size": 327518, + "subdir": "linux-64", + "timestamp": 1556112564470, + "version": "0.21.21" + }, + "fastavro-0.21.23-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "31d9eb4d5b5f730c1a309da46d16d7ff", + "name": "fastavro", + "sha256": "3cad92f0a75a39015613f8d5cc42a6506e06b11188c529e0f6338394dd538f44", + "size": 318032, + "subdir": "linux-64", + "timestamp": 1558587743409, + "version": "0.21.23" + }, + "fastavro-0.21.23-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "aabc83d371e36e6fb818fc70de977f83", + "name": "fastavro", + "sha256": "61adefbdf8782f23ae6cbd1d5e39334b305caae934053ca1d8ac8439662cd546", + "size": 339218, + "subdir": "linux-64", + "timestamp": 1558588078536, + "version": "0.21.23" + }, + "fastavro-0.21.23-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2d93dd991a6c1ebf7bd37be0d8f74cdf", + "name": "fastavro", + "sha256": "5bb66c94154e2ac87cbf3f32a8ffa0493dbd5431f59deb17bf4c2f43265bb8e9", + "size": 338324, + "subdir": "linux-64", + "timestamp": 1558587886692, + "version": "0.21.23" + }, + "fastavro-0.21.4-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ac3e7ceb08546075664c230a197eaffd", + "name": "fastavro", + "sha256": "4abe5fe96222b45210e006d07c096fc32a7035f0fffb63a374f713f76b5bd489", + "size": 296401, + "subdir": "linux-64", + "timestamp": 1535424990046, + "version": "0.21.4" + }, + "fastavro-0.21.4-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "48c8570f874e1e229c9f9351b770c461", + "name": "fastavro", + "sha256": "7ef5daf2a72c8168f78cffd48906cc04b198d849fc3d30daf3460971f4165224", + "size": 297799, + "subdir": "linux-64", + "timestamp": 1535424749383, + "version": "0.21.4" + }, + "fastavro-0.21.4-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a2cf3d6117078df58520b4a2e316e0b2", + "name": "fastavro", + "sha256": "480d0bf2900e9401b7be938b87738dbf6a4a763dc7afbd0724a3adbed11c7f61", + "size": 306055, + "subdir": "linux-64", + "timestamp": 1535424882506, + "version": "0.21.4" + }, + "fastavro-0.21.4-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3bd855e8439c5c196aecc11c5351190f", + "name": "fastavro", + "sha256": "3211e9dd4d32e2b198679d627d928ce415d43bca508e7fe867ee8efd28d7f899", + "size": 304075, + "subdir": "linux-64", + "timestamp": 1535425060280, + "version": "0.21.4" + }, + "fastavro-0.21.8-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "08fc81d50cd129fd61cf64f192ccd40a", + "name": "fastavro", + "sha256": "32139b7814f1c955df81b7a4232e4bc2fc5ed1071094b41cce6d3d9ef866e264", + "size": 306387, + "subdir": "linux-64", + "timestamp": 1538361881004, + "version": "0.21.8" + }, + "fastavro-0.21.8-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ee1ad92d25f65f3596947b0899b2765e", + "name": "fastavro", + "sha256": "df17d634f3bab5e2e47b2b5972743ee18d11d5601d43a59717fee4d5b3e26dc7", + "size": 317642, + "subdir": "linux-64", + "timestamp": 1538361911879, + "version": "0.21.8" + }, + "fastavro-0.21.8-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c20ace1619579f539edb9ad3b12b065f", + "name": "fastavro", + "sha256": "36ee50bf5e711d0723c90d441087c7a6671d7d13f2792d75635b45c7f7e1a0c4", + "size": 314998, + "subdir": "linux-64", + "timestamp": 1538361872794, + "version": "0.21.8" + }, + "fastavro-0.21.9-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "1efe42c7bac524d1bb5d6eefef47e7f6", + "name": "fastavro", + "sha256": "3a2c0d6237c3a9af0d567d83f94758b8fd8eac1684aa2903bba33db94c80b45b", + "size": 306587, + "subdir": "linux-64", + "timestamp": 1539476228933, + "version": "0.21.9" + }, + "fastavro-0.21.9-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8d52e2baaf51c128700e96871c995472", + "name": "fastavro", + "sha256": "fb7d19536ad82e2211760410f0b92a6a4bf2219718d5ae3f3cc66f1a3b5b6198", + "size": 317006, + "subdir": "linux-64", + "timestamp": 1539476263226, + "version": "0.21.9" + }, + "fastavro-0.21.9-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "13780d4094527be4dce835f29c320328", + "name": "fastavro", + "sha256": "161a7036666a4e31f1d383b4e1393dcf3c0d737215b90dd57dbddaed463404a9", + "size": 315177, + "subdir": "linux-64", + "timestamp": 1539476266823, + "version": "0.21.9" + }, + "fastavro-0.22.13-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "bb28f1bce7793836d93eee49c95f8687", + "name": "fastavro", + "sha256": "82497660ed36da0a02969ae82de81668888d866065f59a0f01290495c1bbcf4a", + "size": 386986, + "subdir": "linux-64", + "timestamp": 1584961130829, + "version": "0.22.13" + }, + "fastavro-0.22.13-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "a345a6adfaeec68db7dfb44872177101", + "name": "fastavro", + "sha256": "2b2d858c602bf4de54ec1a20ff8bde69bdfb5a30b8a1fa19132cc1d6c6f1e020", + "size": 385230, + "subdir": "linux-64", + "timestamp": 1584961137161, + "version": "0.22.13" + }, + "fastavro-0.22.13-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "ba58819925c0db2fd27790377376fcb1", + "name": "fastavro", + "sha256": "8dbbd7b18c04c1b3c7a36eb4b03600922356383fd9064a247cfdaebbc7c62f15", + "size": 405145, + "subdir": "linux-64", + "timestamp": 1584961139197, + "version": "0.22.13" + }, + "fastavro-0.22.5-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9c070da12e540edb9c4bb2b1f099d735", + "name": "fastavro", + "sha256": "bef25cb298848436f8a2ef921c4cba473c571251be45313e9289474059ae3d9b", + "size": 351094, + "subdir": "linux-64", + "timestamp": 1569420049308, + "version": "0.22.5" + }, + "fastavro-0.22.5-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6acc698434a508e0f703c94b9cbd0cd5", + "name": "fastavro", + "sha256": "8aa867f2abd4cd3c6cffc68528dbe00a0376ab182a4b8a29cefcf6b51076f17d", + "size": 374288, + "subdir": "linux-64", + "timestamp": 1569420023058, + "version": "0.22.5" + }, + "fastavro-0.22.5-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3811cdfa4676f67b644b1dc2a9ebfa42", + "name": "fastavro", + "sha256": "df9c23f32b3f4010c395e6955466fa880acb04573b6c6855685a30f87359e007", + "size": 371824, + "subdir": "linux-64", + "timestamp": 1569420006165, + "version": "0.22.5" + }, + "fastavro-0.22.5-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "9417501213eda765e4b7b08cc58137b8", + "name": "fastavro", + "sha256": "689514d2315c749213d12d48e59814110473ee9b787c7ea1e954f88d36099caa", + "size": 388013, + "subdir": "linux-64", + "timestamp": 1572880577707, + "version": "0.22.5" + }, + "fastavro-0.22.7-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7847633b75d52242749d9a28fab79296", + "name": "fastavro", + "sha256": "a350651af974da81b83ef921e6c0b1cf0bc1bd7dbf8e1d5658a40d0caa315d33", + "size": 352130, + "subdir": "linux-64", + "timestamp": 1573964049091, + "version": "0.22.7" + }, + "fastavro-0.22.7-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "dcc22d97b44a9fac37668e1e4a77aa97", + "name": "fastavro", + "sha256": "a1e6750c8ad2507dc585eae969344a473f6b61e7d0b398f8b90fe6de3274b88e", + "size": 376181, + "subdir": "linux-64", + "timestamp": 1573964053278, + "version": "0.22.7" + }, + "fastavro-0.22.7-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "628b5678e8b902596e02183e32e93dbc", + "name": "fastavro", + "sha256": "e1ea4a5e717f364b5a3542cebe4ded29e62452df846a205c7eae7fe5ca64d013", + "size": 374108, + "subdir": "linux-64", + "timestamp": 1573964004156, + "version": "0.22.7" + }, + "fastavro-0.23.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "9508c3483798debaa8af6c97acec139c", + "name": "fastavro", + "sha256": "51332b46c9374892403bcb7aa3f3ff8b42299a15739a0a7b322de2e7d7654fd6", + "size": 394355, + "subdir": "linux-64", + "timestamp": 1589230057950, + "version": "0.23.3" + }, + "fastavro-0.23.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "304a1156196a49baa12bcd1cb2215ec4", + "name": "fastavro", + "sha256": "ccd8e5518908297de0323e55178b5e4945893ae7b8d1d4a3ea88b7ad9518ee64", + "size": 389387, + "subdir": "linux-64", + "timestamp": 1589230043681, + "version": "0.23.3" + }, + "fastavro-0.23.3-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "462a71c1aa6a66b4e30a83c45549bb9f", + "name": "fastavro", + "sha256": "d4931e9dd9f6d8dbef6a439025bfc9e41d7f95db08d2f34ca80e602d0f9bf056", + "size": 412035, + "subdir": "linux-64", + "timestamp": 1589230058979, + "version": "0.23.3" + }, + "fastavro-0.23.4-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "c84bd76ad6a628c9b59ab00ac6d15c42", + "name": "fastavro", + "sha256": "9d925e3514cc5a41955ca38713e8dee5003dbf7f6071e724d03d360b3ece1cc4", + "size": 393832, + "subdir": "linux-64", + "timestamp": 1591183471592, + "version": "0.23.4" + }, + "fastavro-0.23.4-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "80a34af58a4e6efc5e8b78dacd7a24d8", + "name": "fastavro", + "sha256": "3126e4358305a7eafcd7eac5658fbec345a7fcb6d9d47d21a34856948c873520", + "size": 392520, + "subdir": "linux-64", + "timestamp": 1591183478421, + "version": "0.23.4" + }, + "fastavro-0.23.4-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "51528011e44fadcb55e1ce74724e141a", + "name": "fastavro", + "sha256": "e36486c1976bb6b2fbe96c84211b8d190e76b96daa8c0e980651649c58f0c877", + "size": 414475, + "subdir": "linux-64", + "timestamp": 1591183471801, + "version": "0.23.4" + }, + "fastavro-0.23.5-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "c06766b0d2a5c873d49cfd7ddc4ab499", + "name": "fastavro", + "sha256": "ea8ce3712f637a9efc661f803b7f07fc7447675974e985da158cf0dc389d7181", + "size": 357937, + "subdir": "linux-64", + "timestamp": 1593483787649, + "version": "0.23.5" + }, + "fastavro-0.23.5-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "2c735c9a4e5b713ad504eadc9c75b5b3", + "name": "fastavro", + "sha256": "dcaf6b2865536dec03350ce3dfe05e52c2a898e19c61ca24cf49e5f32503b517", + "size": 353131, + "subdir": "linux-64", + "timestamp": 1593483748725, + "version": "0.23.5" + }, + "fastavro-0.23.5-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "df61a3f7714d76c47801610a756b3c3b", + "name": "fastavro", + "sha256": "0b9cc96a01b9e431c3044690d147e3718815fbd68c0f30dce034dd14e129c7f5", + "size": 378869, + "subdir": "linux-64", + "timestamp": 1593483750888, + "version": "0.23.5" + }, + "fastavro-1.0.0.post1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "750bda877207d11fd5e9228620d9fe13", + "name": "fastavro", + "sha256": "b1c6c6a7449e5e35b4f8612598dfec8eb7e306289e748db2269ad6e00a5b9701", + "size": 363928, + "subdir": "linux-64", + "timestamp": 1600356316566, + "version": "1.0.0.post1" + }, + "fastavro-1.0.0.post1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "b4edb41c0a8edc614d8b4a5898f886fa", + "name": "fastavro", + "sha256": "461511e03f0604d6184ba099bd08e2f43170f36fe2a416bb40553c6973370840", + "size": 363192, + "subdir": "linux-64", + "timestamp": 1600356316048, + "version": "1.0.0.post1" + }, + "fastavro-1.0.0.post1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "3354b0c2332e4c8285289f0d52243f40", + "name": "fastavro", + "sha256": "989d9ac64b765b6f617fdf61b52e9acb9d3cc21d4482fff0398daef9197a486a", + "size": 384415, + "subdir": "linux-64", + "timestamp": 1600356336933, + "version": "1.0.0.post1" + }, + "fastavro-1.1.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "da52221658e59174359f7f37f773b174", + "name": "fastavro", + "sha256": "f5ac56bc2c4f6aa23eb25bfe03b18725458e691b283b8c1d58d74b81f9f93035", + "size": 362798, + "subdir": "linux-64", + "timestamp": 1604099523215, + "version": "1.1.0" + }, + "fastavro-1.1.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "867703995c026e1fe7305df25a5749bf", + "name": "fastavro", + "sha256": "ae9626cee74e91db82c110d3781a5e380a9c00f967993b6d16cbb2436cac1a96", + "size": 362322, + "subdir": "linux-64", + "timestamp": 1604099505364, + "version": "1.1.0" + }, + "fastavro-1.1.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "7479f3fedd00993df29828f99495fcb2", + "name": "fastavro", + "sha256": "1ee873715e99b3b464d1e82eb3a339a30e49548b461e822d787535358a24652d", + "size": 385418, + "subdir": "linux-64", + "timestamp": 1604099493442, + "version": "1.1.0" + }, + "fastavro-1.2.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "f57591ba2c66b29d5f8aa41fe7707463", + "name": "fastavro", + "sha256": "e48c51e86b46b5b5cc1eb3be029bbb7603cc3520974672aeb3868af6831f69dd", + "size": 367337, + "subdir": "linux-64", + "timestamp": 1606083231361, + "version": "1.2.0" + }, + "fastavro-1.2.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "46bc44b1ddd01b2313d1cb8ba75e5f5b", + "name": "fastavro", + "sha256": "fda072c835f7bac1dc039bd6afbc96bfa3a28da5944cb580b03833354ba28b9f", + "size": 365954, + "subdir": "linux-64", + "timestamp": 1606083219994, + "version": "1.2.0" + }, + "fastavro-1.2.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "9e217c7fce25f979299ecc659410c390", + "name": "fastavro", + "sha256": "d0f7ef8971ff099967226248068bc012a4fcf0e60b061057a35f9cf45d59d892", + "size": 391740, + "subdir": "linux-64", + "timestamp": 1606083220342, + "version": "1.2.0" + }, + "fastavro-1.2.1-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "c913f5a054fd8503da7cdc2392dda80b", + "name": "fastavro", + "sha256": "810f2d534e0f8df7e197c5c2952dd398d0bcad51f9033357a73536542f09029a", + "size": 368742, + "subdir": "linux-64", + "timestamp": 1606946705406, + "version": "1.2.1" + }, + "fastavro-1.2.1-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "bf56f0139d2243d9f802582670e344f5", + "name": "fastavro", + "sha256": "d680c32d540fae3326f00bb0ba1debd7e0c1595f2979b4da632a532f79f40b19", + "size": 366153, + "subdir": "linux-64", + "timestamp": 1606946673364, + "version": "1.2.1" + }, + "fastavro-1.2.1-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "4303e32d8a2657d0b0bf12fcad9e6e5c", + "name": "fastavro", + "sha256": "0808ceb70ea690646b559d178d3df5ca7fe6c2f9393633d546d43602ae12851c", + "size": 390848, + "subdir": "linux-64", + "timestamp": 1606946707530, + "version": "1.2.1" + }, + "fastavro-1.2.2-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "722b270fa50e4edc1129c587d4a11149", + "name": "fastavro", + "sha256": "caaeb7ac122bfe32ffef43af377c416a6c74cb63f7bf37a941e73fe70d91b508", + "size": 370250, + "subdir": "linux-64", + "timestamp": 1608755123228, + "version": "1.2.2" + }, + "fastavro-1.2.2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "c44fe9c2712e8aaeb91d719e149cae71", + "name": "fastavro", + "sha256": "7188e9976b85763f1b04d55280495f4cba299e2293b6cbec46128926f6e71184", + "size": 367761, + "subdir": "linux-64", + "timestamp": 1608755077297, + "version": "1.2.2" + }, + "fastavro-1.2.2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "f5249f85409a5255704399fbca86cbc2", + "name": "fastavro", + "sha256": "237f2179826b4692f0fdf23cb0e09d62b2acb7ba0563cbe5423c298dc412025b", + "size": 392976, + "subdir": "linux-64", + "timestamp": 1608755125652, + "version": "1.2.2" + }, + "fastavro-1.2.2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "55347b525bf04d36d9204a646b20b57f", + "name": "fastavro", + "sha256": "ad765dbf4abae34d9c48148fa71c575488f53c8511c6d7efcb2ddeb3d0d6eb1f", + "size": 390104, + "subdir": "linux-64", + "timestamp": 1608755034014, + "version": "1.2.2" + }, + "fastavro-1.2.3-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "11392042dbb6ab025f99454f222120cd", + "name": "fastavro", + "sha256": "b0b8ff53d953a1d15517617729e88fdf90593ae4fdaf23c36b7912824cf8f886", + "size": 370349, + "subdir": "linux-64", + "timestamp": 1608833667969, + "version": "1.2.3" + }, + "fastavro-1.2.3-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "1580025e1533dc4f7c2596cbb0711962", + "name": "fastavro", + "sha256": "db00fb977c4a61f81c906a6faa1efe42b97cb80f46ce6aada50defa4737ef8b5", + "size": 365999, + "subdir": "linux-64", + "timestamp": 1608833674291, + "version": "1.2.3" + }, + "fastavro-1.2.3-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "f46623591c631899ab344cf8e1070ff6", + "name": "fastavro", + "sha256": "d5333678b108d5f6d9f5ad88682120223c0b7aefa316a9ccca22858b644844dc", + "size": 394212, + "subdir": "linux-64", + "timestamp": 1608833681644, + "version": "1.2.3" + }, + "fastavro-1.2.3-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "0aea74f1ce4111cf9dc07f5ab7c2b336", + "name": "fastavro", + "sha256": "008d0e2bb6cdcc35af0e3175c23d9dd03e0a2eb51615c5f37491e8eb56e99941", + "size": 387507, + "subdir": "linux-64", + "timestamp": 1608833672483, + "version": "1.2.3" + }, + "fastavro-1.2.4-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "8b2ebe2ec37ed5068f6df655bbb7c589", + "name": "fastavro", + "sha256": "7ba5315a4492276caa909e227a4a8c0e3207ddef110b8008864ee411745d45e8", + "size": 370422, + "subdir": "linux-64", + "timestamp": 1610908894834, + "version": "1.2.4" + }, + "fastavro-1.2.4-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "014dad289fa1f5db4de5081e9c6634ad", + "name": "fastavro", + "sha256": "535c5fe5819207ca66ee6c10048fc683da7bf759e12252a1e698775fdd33fe18", + "size": 368295, + "subdir": "linux-64", + "timestamp": 1610908909129, + "version": "1.2.4" + }, + "fastavro-1.2.4-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "38f9522aadf6de8e3b42a7641ff7a456", + "name": "fastavro", + "sha256": "53c6ab748514fd1eb81eb1dad62622135022104ec9589ed9873cc7e8b51ae59c", + "size": 394930, + "subdir": "linux-64", + "timestamp": 1610908210884, + "version": "1.2.4" + }, + "fastavro-1.2.4-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "49f79f759c08f2dd114a79c18e78f040", + "name": "fastavro", + "sha256": "77680bc9aebc5bdc5b51a6559940aad026507fe88375ef156c1069538e7e44a6", + "size": 390505, + "subdir": "linux-64", + "timestamp": 1610908893402, + "version": "1.2.4" + }, + "fastavro-1.3.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "6a7c4794f16d1924330f2eb21f98093f", + "name": "fastavro", + "sha256": "14432a9d304966ed93d05bf4bfea1463281c2b15622b3e1b4c4a8067dea4adfa", + "size": 373949, + "subdir": "linux-64", + "timestamp": 1611341703422, + "version": "1.3.0" + }, + "fastavro-1.3.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "57bc15d1131600b95f0814f9a6b666fc", + "name": "fastavro", + "sha256": "dcc74dc724fd013026a04e833e547b53b42f698538e928df1c60149f2ad71f3d", + "size": 369396, + "subdir": "linux-64", + "timestamp": 1611341711051, + "version": "1.3.0" + }, + "fastavro-1.3.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "5ea3a6f12199c44940dfb86d3d101509", + "name": "fastavro", + "sha256": "ddde561cd563f861d8e728e572f71b53b91de6edd49de0f45939ed0579f5d1cb", + "size": 396101, + "subdir": "linux-64", + "timestamp": 1611341219974, + "version": "1.3.0" + }, + "fastavro-1.3.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "20c720a292b5d9b0fe24b06c4dbf145f", + "name": "fastavro", + "sha256": "9518503bd7f30ad5cce77403eb0b7b246869f78bbeb1f5c47363d0477722b6bb", + "size": 393408, + "subdir": "linux-64", + "timestamp": 1611341707993, + "version": "1.3.0" + }, + "fastavro-1.3.1-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "92170544b4e87c069dd3f8158bee2bfb", + "name": "fastavro", + "sha256": "f9d6fa3dee3c9c5e8d131a8e540cb18e63f9b8c0f67581f6a492f790fa3041e1", + "size": 398851, + "subdir": "linux-64", + "timestamp": 1613328447643, + "version": "1.3.1" + }, + "fastavro-1.3.1-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "97f01d8fd12828b1b1d213c5c8cc1769", + "name": "fastavro", + "sha256": "a766bb2296263a2dec489a9ca4d8015053029044d315b664da57e0372de6dbd2", + "size": 397719, + "subdir": "linux-64", + "timestamp": 1613327826592, + "version": "1.3.1" + }, + "fastavro-1.3.1-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "cbb788bf72c1dd5ab4e8bfc8d2003f36", + "name": "fastavro", + "sha256": "f2569df5d35cfd6ec8607cf6a8d89fa80e56826e5b1acd60072382328bc867aa", + "size": 422601, + "subdir": "linux-64", + "timestamp": 1613328445659, + "version": "1.3.1" + }, + "fastavro-1.3.1-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "5e2867088cb7156bb8f41e968e096413", + "name": "fastavro", + "sha256": "b0905fccaa2c88016d7102421451532022899aaffd97f4773eb62e7e042afc0e", + "size": 423536, + "subdir": "linux-64", + "timestamp": 1613328442447, + "version": "1.3.1" + }, + "fastavro-1.3.2-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "7b37a9cae40e109084352e5643b3dcb8", + "name": "fastavro", + "sha256": "3ad321459b5738be49f1ee265f5fb55ed5dcf9810d5b4b5b2078603d39f25d2b", + "size": 398776, + "subdir": "linux-64", + "timestamp": 1613414970546, + "version": "1.3.2" + }, + "fastavro-1.3.2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "e1b0f196545b190d938012e8ef3ccbf1", + "name": "fastavro", + "sha256": "d844cba3b561dbd91447787d8866e299b2f35143ec49572df97334c8e2f259f9", + "size": 398140, + "subdir": "linux-64", + "timestamp": 1613414856954, + "version": "1.3.2" + }, + "fastavro-1.3.2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "5fdf68fc46c414c9f99f9d5b5e5265b1", + "name": "fastavro", + "sha256": "183a8b5bc55ec919f47630fcd33cb0ceba3117fe3fd6f26fd9133bcb2a5e2388", + "size": 423253, + "subdir": "linux-64", + "timestamp": 1613414977867, + "version": "1.3.2" + }, + "fastavro-1.3.2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "bcf1d37edd8e8ff888d4df026ca1c50a", + "name": "fastavro", + "sha256": "36ea8f50981875a757a1925ead3e08b135165b1c5a459c6f93fbe7c975091aeb", + "size": 424288, + "subdir": "linux-64", + "timestamp": 1613414969506, + "version": "1.3.2" + }, + "fastavro-1.3.3-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "3462625eb64e52ea1cfe7991f1dd64fa", + "name": "fastavro", + "sha256": "38e923a72c70ac4967287e1706e5e518d1b7775d1d4bc27f291d8001bc4ec497", + "size": 404253, + "subdir": "linux-64", + "timestamp": 1615661545658, + "version": "1.3.3" + }, + "fastavro-1.3.3-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "42b62620c48b26f896fb560c1af14087", + "name": "fastavro", + "sha256": "279b82bd214629625b143f263f3a06934b76f9f8b4cd2c578e791fb161f70a81", + "size": 402929, + "subdir": "linux-64", + "timestamp": 1615661536510, + "version": "1.3.3" + }, + "fastavro-1.3.3-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "64bb3fd5d89c9e98956afa6daf11764d", + "name": "fastavro", + "sha256": "ffdf5168a3d8dbcf1032dd6a824a68efa4509730afb3f0583ea51749377c4008", + "size": 426905, + "subdir": "linux-64", + "timestamp": 1615661546293, + "version": "1.3.3" + }, + "fastavro-1.3.3-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "6b8d8ff45dbf44b7a26a7c641d2a87ab", + "name": "fastavro", + "sha256": "1c0ca6802ae8445be99eab2886b4aee5dcb274f11b5041c7c84829c71de585ce", + "size": 427355, + "subdir": "linux-64", + "timestamp": 1615661549634, + "version": "1.3.3" + }, + "fastavro-1.3.4-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "ff6d560c25a2cc220a6a85f5ad7e597d", + "name": "fastavro", + "sha256": "d71474578c5764401187a370a7466a362ee7c85df4a78eb214b7e3b261250165", + "size": 406761, + "subdir": "linux-64", + "timestamp": 1616268959089, + "version": "1.3.4" + }, + "fastavro-1.3.4-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "ff0190755fad508724e6fb8a3cdfbbd6", + "name": "fastavro", + "sha256": "fdb2886e0e10d2856964d732dfa5de9f54275531d1c94c737272cd5f5de9b905", + "size": 404543, + "subdir": "linux-64", + "timestamp": 1616268963787, + "version": "1.3.4" + }, + "fastavro-1.3.4-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "10a8a8613a6d29f91f7944215a24147d", + "name": "fastavro", + "sha256": "454cdc902f88434629795332215212f618e3ccef79b69411fe7c7857cf115f59", + "size": 430511, + "subdir": "linux-64", + "timestamp": 1616266938857, + "version": "1.3.4" + }, + "fastavro-1.3.4-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "2b75eafbcd497d525396b771e8c3a3bd", + "name": "fastavro", + "sha256": "28b34c4e1300054dbd3907e3373eeccc07292f2692ebe2780b1ecc704511befc", + "size": 429978, + "subdir": "linux-64", + "timestamp": 1616268269274, + "version": "1.3.4" + }, + "fastavro-1.3.5-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "01a6267896564bdbf588648c8cc9485b", + "name": "fastavro", + "sha256": "dc1a090aff3efbb1461de746bbf229863c9d0c584035b5ee94652809c76583c4", + "size": 410189, + "subdir": "linux-64", + "timestamp": 1617219860649, + "version": "1.3.5" + }, + "fastavro-1.3.5-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "399210602311c7de58950f58fb7e8d71", + "name": "fastavro", + "sha256": "8043a63a1f3a096c5fe233843e7e84cd5c2f4cf89e94b26e38495609484e73cd", + "size": 408517, + "subdir": "linux-64", + "timestamp": 1617222343993, + "version": "1.3.5" + }, + "fastavro-1.3.5-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "c440eaa5122f6067884af56796fe71fa", + "name": "fastavro", + "sha256": "02b749aa70200fafd0d3386a2756b2328cf45091354d945592e583aaa4df254a", + "size": 431422, + "subdir": "linux-64", + "timestamp": 1617222320395, + "version": "1.3.5" + }, + "fastavro-1.3.5-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "697280a8afd40ad7388247ce3d9e5439", + "name": "fastavro", + "sha256": "a7986fe3a4f7b75aeb205433567443a0d43aa0031823b3ca71868932fee055d7", + "size": 435671, + "subdir": "linux-64", + "timestamp": 1617222360624, + "version": "1.3.5" + }, + "fastavro-1.4.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "7466d14fb6b4edf1377c713935c48b03", + "name": "fastavro", + "sha256": "2cbf4b70108cd8e2bec176883487f8f599f728a6d6b3f264fa08f10b284d8fb6", + "size": 411083, + "subdir": "linux-64", + "timestamp": 1618690802749, + "version": "1.4.0" + }, + "fastavro-1.4.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "9c960cb2db03bb3a7f70d04acbc98d4f", + "name": "fastavro", + "sha256": "cecd5f780a7f017c0ec1ceb5c6adcf01eb6fdf5fcb1130ba29f205e3514db5ef", + "size": 409371, + "subdir": "linux-64", + "timestamp": 1618694048698, + "version": "1.4.0" + }, + "fastavro-1.4.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "8181de7e671f8d1cc1e4ff87b668b9e9", + "name": "fastavro", + "sha256": "dfc752cdb55841795786e6151b9f7bf29f0ab746095b8ee915f288fafd534d85", + "size": 435759, + "subdir": "linux-64", + "timestamp": 1618694059093, + "version": "1.4.0" + }, + "fastavro-1.4.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "6c1d3744709a78324200f4a7590cdab0", + "name": "fastavro", + "sha256": "6c87361719c648140525d47204e953ffc476eac11e33e780871f2c2cfb4562f3", + "size": 436980, + "subdir": "linux-64", + "timestamp": 1618789080530, + "version": "1.4.0" + }, + "fastavro-1.4.1-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "1d1249b8beedb9c8f21305478df101c1", + "name": "fastavro", + "sha256": "679b4e6df4d84ffa576aadd302d76b02363703586056796c2d62cf9d5eba1350", + "size": 436427, + "subdir": "linux-64", + "timestamp": 1621431970457, + "version": "1.4.1" + }, + "fastavro-1.4.2-py36h7f8727e_0.conda": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "7f7c9a0026b854d1bdc65cc8cb711133", + "name": "fastavro", + "sha256": "7701526fcc6516f545a5ded43567aa951008c70ca77ac9aa60c87ae41531d146", + "size": 414265, + "subdir": "linux-64", + "timestamp": 1625077490914, + "version": "1.4.2" + }, + "fastavro-1.4.2-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "2faf15f97b91f166d7ff678abbba478c", + "name": "fastavro", + "sha256": "65857840ed84a5b722448a819a9b52946cb79b48f8c3ea6c15a7d8fbd6312456", + "size": 412662, + "subdir": "linux-64", + "timestamp": 1625077471945, + "version": "1.4.2" + }, + "fastavro-1.4.2-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "da45eb1afd5a1919bfa26cd4c347960e", + "name": "fastavro", + "sha256": "05d83f71ef638a4e808a3e5871f2ae88c2ff6f174963ddb0683b33e5ff4c0344", + "size": 438031, + "subdir": "linux-64", + "timestamp": 1625071002066, + "version": "1.4.2" + }, + "fastavro-1.4.2-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d3daf0dd209d79e9b5149c2d2e3e549e", + "name": "fastavro", + "sha256": "742b936429582a1766118749b7611c2425590cd7412ccd100af1945218a4a7e0", + "size": 453248, + "subdir": "linux-64", + "timestamp": 1625127143866, + "version": "1.4.2" + }, + "fastavro-1.4.3-py36h7f8727e_0.conda": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37d3245762992485701c216db5321b9f", + "name": "fastavro", + "sha256": "20ac295cb4c4fde6ab5899ad47d86f92e05fafaf12cffed4d65d22bf5fd893fa", + "size": 425323, + "subdir": "linux-64", + "timestamp": 1632841022712, + "version": "1.4.3" + }, + "fastavro-1.4.3-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bed593cb5499db57f66d7fa868de45f5", + "name": "fastavro", + "sha256": "dbbe714f116a76ce89ee655293bf36d655596b2411b05b2e76c6d75fc193fcb4", + "size": 423561, + "subdir": "linux-64", + "timestamp": 1632841086129, + "version": "1.4.3" + }, + "fastavro-1.4.3-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83a6dec2feda4841d8e50115d6499e3c", + "name": "fastavro", + "sha256": "8803ea4398868fd2dc743f3e4f29420869007b6d166db1e1c9f1af8f905169ce", + "size": 450211, + "subdir": "linux-64", + "timestamp": 1632841006787, + "version": "1.4.3" + }, + "fastavro-1.4.3-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ecaf978327a27e6d77c3ae5beadd2d62", + "name": "fastavro", + "sha256": "e61ddc623d8d5a21b2fe5139a1256fb9d61b906e9064dbe3f2db10779bfbd28d", + "size": 454634, + "subdir": "linux-64", + "timestamp": 1626492995036, + "version": "1.4.3" + }, + "fastavro-1.4.7-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a71166a0347df5d442a7785da74e5b6a", + "name": "fastavro", + "sha256": "c1908ac15d44ba9f16d3cb1a06fa982035b39393890c212919b792ea4813d71c", + "size": 1465634, + "subdir": "linux-64", + "timestamp": 1640789946347, + "version": "1.4.7" + }, + "fastavro-1.4.7-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d942fbe18a2b5470c668a664a85ad6a6", + "name": "fastavro", + "sha256": "d9eed23edda5f9bc1ccd610daefd5ca3058c4306bf21bb20fbd03ca459662e54", + "size": 413786, + "subdir": "linux-64", + "timestamp": 1638961800596, + "version": "1.4.7" + }, + "fastavro-1.4.7-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3edfc08b15f456ab06807fa4132bb345", + "name": "fastavro", + "sha256": "c56aae909e644263f6527da05047459dc43b877bfdea1f5848a3cb954c353bf4", + "size": 438428, + "subdir": "linux-64", + "timestamp": 1638975306103, + "version": "1.4.7" + }, + "fastavro-1.4.7-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3621850438bfca54ae0489a9fa9fd29", + "name": "fastavro", + "sha256": "54cf71d25cf360e88f34539e93d0a7c5006938ac174996ff232deacf272f6040", + "size": 442340, + "subdir": "linux-64", + "timestamp": 1638975315401, + "version": "1.4.7" + }, + "fastavro-1.7.0-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2fc6d1b83e72237efbd74654baccea0a", + "name": "fastavro", + "sha256": "96da51e0b07cbec82f022663a55dafd4b53acfe5cbde3fcca291b7bc94c892ea", + "size": 500799, + "subdir": "linux-64", + "timestamp": 1670513337336, + "version": "1.7.0" + }, + "fastavro-1.7.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b89a728087afd034fc08e4ecc35c1a6f", + "name": "fastavro", + "sha256": "e6b00bc35a73c87e2284e77750bdf3900c8a8566b8abdb7d26dec0afe2b9bf19", + "size": 475084, + "subdir": "linux-64", + "timestamp": 1676839815476, + "version": "1.7.0" + }, + "fastavro-1.7.0-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "41dfcbd90d6b3eca87a97fa5a57b7738", + "name": "fastavro", + "sha256": "7a2ea5d1a329becb9884235310350d36fac3bdba949c73817d33431ca40db3e9", + "size": 477475, + "subdir": "linux-64", + "timestamp": 1670513384106, + "version": "1.7.0" + }, + "fastavro-1.7.0-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b0faf6841c75dac915a0d686aa7a360a", + "name": "fastavro", + "sha256": "4e8410a8e43f4ccf64428960e62e86a92828a165e960800fff86cc1a94ce40c1", + "size": 505373, + "subdir": "linux-64", + "timestamp": 1670513429590, + "version": "1.7.0" + }, + "fastavro-1.7.0-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "edeeae1c7e3cf7a6518c959840685600", + "name": "fastavro", + "sha256": "478bf970af4999a706319c37492b990121bad552be0235450aaf8b3966919a2c", + "size": 499023, + "subdir": "linux-64", + "timestamp": 1670513292517, + "version": "1.7.0" + }, + "fastcache-1.0.2-py27h14c3975_2.conda": { + "build": "py27h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e8014669b65db3dc334790cab663849", + "name": "fastcache", + "sha256": "7f7b6f218ef36015a3b25ace03de744232ac758d9d6c54065262ba26caa89da7", + "size": 29485, + "subdir": "linux-64", + "timestamp": 1518031539912, + "version": "1.0.2" + }, + "fastcache-1.0.2-py27h4cb8e01_0.conda": { + "build": "py27h4cb8e01_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8beb0d10b2367222641d8e98a3ad136", + "name": "fastcache", + "sha256": "01a7f04dcacfbcb5e2b579fb86adf32cd924b9939836d1c5126f0f51d638d651", + "size": 29423, + "subdir": "linux-64", + "timestamp": 1505742787495, + "version": "1.0.2" + }, + "fastcache-1.0.2-py35h14c3975_2.conda": { + "build": "py35h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ff79654f8eda0bb452b08e1e428d3bf", + "name": "fastcache", + "sha256": "2c2968a3c8ad856b7f93ae747ed53dedbf757057b6c1245bb6c1bb3bead40634", + "size": 29434, + "subdir": "linux-64", + "timestamp": 1518031667907, + "version": "1.0.2" + }, + "fastcache-1.0.2-py35hec2bbaa_0.conda": { + "build": "py35hec2bbaa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e81f8aff5bf26afaaed86f4fdccdcea", + "name": "fastcache", + "sha256": "1c576a928cadde32e6daa7b432407997e023bd884f931fbd6de95b0ab14ae0bf", + "size": 29004, + "subdir": "linux-64", + "timestamp": 1505742839495, + "version": "1.0.2" + }, + "fastcache-1.0.2-py36h14c3975_2.conda": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c353b64548ad00e50c72732f0c82a2e", + "name": "fastcache", + "sha256": "e14dc53c57d51131b424e7696d57d219a7c7724630f7953e5277edae361766fd", + "size": 29371, + "subdir": "linux-64", + "timestamp": 1518031518610, + "version": "1.0.2" + }, + "fastcache-1.0.2-py36h5b0c431_0.conda": { + "build": "py36h5b0c431_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2a1908d8f3e45cbe5af5f1c0fd8ff106", + "name": "fastcache", + "sha256": "e000ddd68546426a3922a14350bfc082bfb67a8f92a5d036e1d88deec42650b9", + "size": 28984, + "subdir": "linux-64", + "timestamp": 1505742887049, + "version": "1.0.2" + }, + "fastcache-1.0.2-py37h14c3975_2.conda": { + "build": "py37h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a95b840aba014236a359237533eb614", + "name": "fastcache", + "sha256": "015319ed1f1441df298f37dcc40ae581909350af28240c6e390ccc1225f07cf5", + "size": 29355, + "subdir": "linux-64", + "timestamp": 1530876437717, + "version": "1.0.2" + }, + "fastcache-1.1.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1da759286d9ff219fbee604a94a4e9e2", + "name": "fastcache", + "sha256": "6c026dbbf96a462e96df2cd4e4d5ce11e9c820bfb8a30cac20cfd2792c12dc0e", + "size": 31213, + "subdir": "linux-64", + "timestamp": 1557506988688, + "version": "1.1.0" + }, + "fastcache-1.1.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6392b3eb22a9813041d752c46062caa0", + "name": "fastcache", + "sha256": "c3508ac8999337d3180a3082bc129ddab50ab720ab54bb5df925ba0aa81dc4b9", + "size": 49190, + "subdir": "linux-64", + "timestamp": 1640789971784, + "version": "1.1.0" + }, + "fastcache-1.1.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a19104382258a3a1e365bff2559598e", + "name": "fastcache", + "sha256": "f218d1f9f2a264cfd028067b1e64d00ffd1c68e9aa4d88eb2ad603db933fd015", + "size": 36749, + "subdir": "linux-64", + "timestamp": 1676852276755, + "version": "1.1.0" + }, + "fastcache-1.1.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c9383dfc1294b9db699866682020ac7", + "name": "fastcache", + "sha256": "3d5151ac3af4c97bcef498f4a85652f00c11201a6140d0ed5e119162c3baf208", + "size": 31260, + "subdir": "linux-64", + "timestamp": 1557507091745, + "version": "1.1.0" + }, + "fastcache-1.1.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bf2ac84ed0365944c170252caca99843", + "name": "fastcache", + "sha256": "1b4e938e1f2ef7d9c9b90180e2a438a504b1f7f8f973c4db50c725e7232a5747", + "size": 31135, + "subdir": "linux-64", + "timestamp": 1557506998178, + "version": "1.1.0" + }, + "fastcache-1.1.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b719e0a5dea7eeab7e9a472fe6edab72", + "name": "fastcache", + "sha256": "8ffa2c5e5714440addae1e4e94f976f06f65de4f9250e1036fe7b0388dfffc66", + "size": 36989, + "subdir": "linux-64", + "timestamp": 1572880642654, + "version": "1.1.0" + }, + "fastcache-1.1.0-py39he8ac12f_0.conda": { + "build": "py39he8ac12f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66497c3273c030bda2740dc9761fe982", + "name": "fastcache", + "sha256": "a17dd3356479874c0598602d008bef25ad97342582aa4046fb721dfa27e210f4", + "size": 31917, + "subdir": "linux-64", + "timestamp": 1607571313944, + "version": "1.1.0" + }, + "fastcluster-1.1.26-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "0b93840efed1ad2d0e1c0acf7a3f7ffc", + "name": "fastcluster", + "sha256": "2bc77662c62377140c88e0397da4a8be58f1ab3c84196df956f492d435122189", + "size": 145531, + "subdir": "linux-64", + "timestamp": 1640790001278, + "version": "1.1.26" + }, + "fastcluster-1.1.26-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "8fac854825fbcf8779607c4648a6332e", + "name": "fastcluster", + "sha256": "21830f155bc75f7d7013f52a231f85e7aa6198a3d34dbb781b6e02cfcf82bd91", + "size": 45800, + "subdir": "linux-64", + "timestamp": 1676852299528, + "version": "1.1.26" + }, + "fastcluster-1.1.26-py36h295c915_0.conda": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "a9646855afbaaa977b2fa9371c6767c7", + "name": "fastcluster", + "sha256": "8d469969e69a711b9734c78826cbca2d808bb2d1bf8e1c6e17b55a231fff38e5", + "size": 45922, + "subdir": "linux-64", + "timestamp": 1633433586324, + "version": "1.1.26" + }, + "fastcluster-1.1.26-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "4799c0e18422d05c6b1ffba7fb2e1b9c", + "name": "fastcluster", + "sha256": "a0a31f4072ee68995d79baf99f9d4842387f65e436ff24ec34dbcd4826309aaf", + "size": 46041, + "subdir": "linux-64", + "timestamp": 1633422872490, + "version": "1.1.26" + }, + "fastcluster-1.1.26-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "6fff8fcb509dfb555a89092f83b583e4", + "name": "fastcluster", + "sha256": "b9ab591789b3d9951f39f29d03192fef90655a61abcb3c018860191b7dfff48c", + "size": 45998, + "subdir": "linux-64", + "timestamp": 1633433554061, + "version": "1.1.26" + }, + "fastcluster-1.1.26-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20.3,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "1f42ffbbc93c0562a0d2c4eb05dd8a8d", + "name": "fastcluster", + "sha256": "1596de477a65db2bf687bafce6ee260a3bccccc7e5065bfbb638c650549afb49", + "size": 45899, + "subdir": "linux-64", + "timestamp": 1633432981629, + "version": "1.1.26" + }, + "fastcluster-1.2.4-py36h295c915_0.conda": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "0663f9e35d1bbd1b94251d69102b6dd9", + "name": "fastcluster", + "sha256": "07cd5934427808f439caa3026b48aa3f2f86412a7144a43d10f63222cce36dcd", + "size": 45996, + "subdir": "linux-64", + "timestamp": 1633429531428, + "version": "1.2.4" + }, + "fastcluster-1.2.4-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "38c897762ffcec7950d65d4c5703e884", + "name": "fastcluster", + "sha256": "c7915778b108fd5551597c3a286f885ef2337a6d47e9e1c908136c28d61e0825", + "size": 45925, + "subdir": "linux-64", + "timestamp": 1633429321191, + "version": "1.2.4" + }, + "fastcluster-1.2.4-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "2f2bec3307913b4ebbfb99d31c6cf5f0", + "name": "fastcluster", + "sha256": "f12d4f45ede76a00dac9732addd18908bbaa628fd9e6faed1c554ddf37a3e364", + "size": 45974, + "subdir": "linux-64", + "timestamp": 1633418815631, + "version": "1.2.4" + }, + "fastcluster-1.2.4-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20.3,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause AND GPL-2.0-or-later", + "md5": "42449a6c401ca95fc2d5dba3ec90a35b", + "name": "fastcluster", + "sha256": "2ab3406b75cb5bc24c089ae47144decf0b577cf296bdc6871326e2b3ae269a41", + "size": 45883, + "subdir": "linux-64", + "timestamp": 1633429502695, + "version": "1.2.4" + }, + "fastparquet-0.1.2-py27h934da83_0.conda": { + "build": "py27h934da83_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11", + "pandas", + "pytest", + "python >=2.7,<2.8.0a0", + "thrift >=0.10" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "ef5cfe18486f553130815dc1f8951f95", + "name": "fastparquet", + "sha256": "8997ad0e6aa71c864b0a22abbebfbeeb7e2129000033c2549dacc8098eec2bb5", + "size": 205645, + "subdir": "linux-64", + "timestamp": 1505742977675, + "version": "0.1.2" + }, + "fastparquet-0.1.2-py35hba653af_0.conda": { + "build": "py35hba653af_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11", + "pandas", + "pytest", + "python >=3.5,<3.6.0a0", + "thrift >=0.10" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "86e33b33378bddf9b54d7fddd81fff2b", + "name": "fastparquet", + "sha256": "de540e2a985c938fa07a1fa30351e78e4681b63929a62ce64313bd7bcb7a8c9a", + "size": 201161, + "subdir": "linux-64", + "timestamp": 1505742998726, + "version": "0.1.2" + }, + "fastparquet-0.1.2-py36hd59b1b2_0.conda": { + "build": "py36hd59b1b2_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11", + "pandas", + "pytest", + "python >=3.6,<3.7.0a0", + "thrift >=0.10" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "bf19e7fca57f87c9e08ece4245c9a434", + "name": "fastparquet", + "sha256": "db65f4d481ddafb1eb2654db6c836d923f5f47fb1e56af2a10d2a88bab29dafa", + "size": 199843, + "subdir": "linux-64", + "timestamp": 1505743019639, + "version": "0.1.2" + }, + "fastparquet-0.1.3-py27hc8d2e31_0.conda": { + "build": "py27hc8d2e31_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytest", + "python >=2.7,<2.8.0a0", + "thrift >=0.10" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "e2a6b6235a12fb182d16e58a7d9ba0b1", + "name": "fastparquet", + "sha256": "d015c5e774b99569a0c8530aa5fa8ca850f9b8e9de756c7eff9d797ceda712a3", + "size": 206636, + "subdir": "linux-64", + "timestamp": 1509052903909, + "version": "0.1.3" + }, + "fastparquet-0.1.3-py35hd8c2413_0.conda": { + "build": "py35hd8c2413_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytest", + "python >=3.5,<3.6.0a0", + "thrift >=0.10" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "cb0c5ba34b1160b29186e53fa909375c", + "name": "fastparquet", + "sha256": "5bae49a68e3bf64668f10827e1bb90b300aed9f63bad0d5ddf48055d4e534181", + "size": 202574, + "subdir": "linux-64", + "timestamp": 1509052720489, + "version": "0.1.3" + }, + "fastparquet-0.1.3-py36h49281c8_0.conda": { + "build": "py36h49281c8_0", + "build_number": 0, + "depends": [ + "cython", + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.9.3,<2.0a0", + "pandas", + "pytest", + "python >=3.6,<3.7.0a0", + "thrift >=0.10" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "712c675a780d3a0b12a5c4442a37abe8", + "name": "fastparquet", + "sha256": "f3341c0a6b30161480f85709e7bcfaf69bd65291f2c43631a01983deaadf0661", + "size": 200641, + "subdir": "linux-64", + "timestamp": 1509052916660, + "version": "0.1.3" + }, + "fastparquet-0.1.4-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=2.7,<2.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "ddd69f63bf0d58c28acb2797b40ed14f", + "name": "fastparquet", + "sha256": "317e8210f892e57f4fe58dffdd262c92d220daf231c36e55586972045e97dad4", + "size": 214434, + "subdir": "linux-64", + "timestamp": 1517417507159, + "version": "0.1.4" + }, + "fastparquet-0.1.4-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.5,<3.6.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "e9cec3c09dd4faeec89e825f57890b8d", + "name": "fastparquet", + "sha256": "1bf6c688106e7c45626f4f6691d29fbf35bd286d6c9d90df670024e9b4c16178", + "size": 209997, + "subdir": "linux-64", + "timestamp": 1517417661761, + "version": "0.1.4" + }, + "fastparquet-0.1.4-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "13cbc25e8e7c60bfee86a929c1cf2dda", + "name": "fastparquet", + "sha256": "36b47687944bd3c7851bc679d0ec962dd0dffe8e15f0b5dd0daa1ea4c3b42851", + "size": 208162, + "subdir": "linux-64", + "timestamp": 1517417656074, + "version": "0.1.4" + }, + "fastparquet-0.1.5-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=2.7,<2.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "896de7ad56472f013d67fadf9a7432da", + "name": "fastparquet", + "sha256": "bbc02d42499d4a2672e40edec4a5caf6db5812026bc4f7b7bba5f4710cc87420", + "size": 218475, + "subdir": "linux-64", + "timestamp": 1530876623114, + "version": "0.1.5" + }, + "fastparquet-0.1.5-py27h3010b51_0.conda": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=2.7,<2.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "6f388fdd0a6334fb7a1fb93a5339ae90", + "name": "fastparquet", + "sha256": "8ac33fd7afea1a97af59ec4f705f95ea82fe45410c2912e9b24fdc681d6b0304", + "size": 216204, + "subdir": "linux-64", + "timestamp": 1522709064587, + "version": "0.1.5" + }, + "fastparquet-0.1.5-py35h3010b51_0.conda": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.5,<3.6.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "933722090ccef447d1dc8e3f6daafb05", + "name": "fastparquet", + "sha256": "a9bae98ec519257f7fe1a807d7e9149a6c8b53ef3b161a973c0359a5441f3a23", + "size": 212487, + "subdir": "linux-64", + "timestamp": 1522709075209, + "version": "0.1.5" + }, + "fastparquet-0.1.5-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "6f18d25c18f026caa8e784f35ecc2c8f", + "name": "fastparquet", + "sha256": "1b07e74d6f2f1045c58db181bfbd084e358799344aedda482ad6fd2666e09283", + "size": 214728, + "subdir": "linux-64", + "timestamp": 1530876547053, + "version": "0.1.5" + }, + "fastparquet-0.1.5-py36h3010b51_0.conda": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "cab01f28ce69d2730057d2ef08faad0e", + "name": "fastparquet", + "sha256": "786bb0e173ad0ea16685109a5702a3c9a49fa8f9af47aae28b16b67260547a3f", + "size": 210121, + "subdir": "linux-64", + "timestamp": 1522708999469, + "version": "0.1.5" + }, + "fastparquet-0.1.5-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "22443799a280e2b93c2f16c05711fe26", + "name": "fastparquet", + "sha256": "9bc9bed29aa8deab2d66cf156305a4bcaf7acfe4459d037a7d97c7abf2c03ff8", + "size": 214652, + "subdir": "linux-64", + "timestamp": 1530876584960, + "version": "0.1.5" + }, + "fastparquet-0.1.6-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=2.7,<2.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "4ab213fe08acd4b860837dc51a2edf72", + "name": "fastparquet", + "sha256": "b8e8326846adc51a52b4b79ccf6ce5b77d538586207d59727f1a237edcea183d", + "size": 224941, + "subdir": "linux-64", + "timestamp": 1535425704470, + "version": "0.1.6" + }, + "fastparquet-0.1.6-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.5,<3.6.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "d91ca96664d3320d0a89b5e17b82755e", + "name": "fastparquet", + "sha256": "69be29f9bbba0b972dcce05f3fb93b64fb7dbd85653fca344b6a181bff631f18", + "size": 222495, + "subdir": "linux-64", + "timestamp": 1535425910096, + "version": "0.1.6" + }, + "fastparquet-0.1.6-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "2fcef2985f985e1464949b72920a511f", + "name": "fastparquet", + "sha256": "39122acede663274834b3d301a1bc6bed777a0e59e5e7d31e644146bfc5289a9", + "size": 219954, + "subdir": "linux-64", + "timestamp": 1535425652572, + "version": "0.1.6" + }, + "fastparquet-0.1.6-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "5b28cd2bd2b3a3c5d04ede978d4ab4b1", + "name": "fastparquet", + "sha256": "05907ccc1c5525b6e4d0cb3ca57c9b9fa1a67d7e2659efbed6c2fe198d039c37", + "size": 221277, + "subdir": "linux-64", + "timestamp": 1535425729621, + "version": "0.1.6" + }, + "fastparquet-0.2.1-py27hdd07704_1.conda": { + "build": "py27hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=2.7,<2.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "80382259852bcc144605427d24988008", + "name": "fastparquet", + "sha256": "5cb2213145dd7eb95be6ff92c4ee61fc4d2cea6b8471642a86047fbf83c82479", + "size": 231151, + "subdir": "linux-64", + "timestamp": 1549636253148, + "version": "0.2.1" + }, + "fastparquet-0.2.1-py36hdd07704_1.conda": { + "build": "py36hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "b0a92d9a783ec4843091b182f92a3d08", + "name": "fastparquet", + "sha256": "7a5499d6f5172a8ac05931210ddf657c9b6aa0cab5dba141a314d9dfd69744f1", + "size": 227776, + "subdir": "linux-64", + "timestamp": 1549636239954, + "version": "0.2.1" + }, + "fastparquet-0.2.1-py37hdd07704_1.conda": { + "build": "py37hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "pytest", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "0506baddd3f1a15748af78294d4e7e8d", + "name": "fastparquet", + "sha256": "02a615ad54b71bbdf8a01f2ae5aa3ecb192bab32ec15b0efdd2a75dcf5cf11ee", + "size": 228288, + "subdir": "linux-64", + "timestamp": 1549636226730, + "version": "0.2.1" + }, + "fastparquet-0.3.0-py27hdd07704_0.conda": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "python >=2.7,<2.8.0a0", + "six", + "thrift >=0.11.0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "2d2c4f5f005e4a04df9ba4a5b578c287", + "name": "fastparquet", + "sha256": "e3cd81a0d6d0ff06e9a5d0888ecd299f04ef6f33a563c1c7145d8162b3d1c92e", + "size": 235703, + "subdir": "linux-64", + "timestamp": 1556065745665, + "version": "0.3.0" + }, + "fastparquet-0.3.0-py36hdd07704_0.conda": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "six", + "thrift >=0.11.0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "7f0643c8cd4368ea86baf209c361b481", + "name": "fastparquet", + "sha256": "fb397256be06ada23e8558d43e488d0edfb39fd8b7440310f54164da5becf7ff", + "size": 232018, + "subdir": "linux-64", + "timestamp": 1556065748070, + "version": "0.3.0" + }, + "fastparquet-0.3.0-py37hdd07704_0.conda": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "six", + "thrift >=0.11.0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "038be0262cfa0785ef667fb5fe1ba36c", + "name": "fastparquet", + "sha256": "3e4eb785760d794f1431b9d8dc36de77b1f2672d761a846bd058fd794f4625ff", + "size": 231708, + "subdir": "linux-64", + "timestamp": 1556065567267, + "version": "0.3.0" + }, + "fastparquet-0.3.2-py27hdd07704_0.conda": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "python >=2.7,<2.8.0a0", + "six", + "thrift >=0.11.0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "05d1b5a4feb6b19e7aace3631ed5ad32", + "name": "fastparquet", + "sha256": "4fafd421c9b29f26ca05d9a91b5cca32e5d2eabe3ae3d6f509ba6577cf55039e", + "size": 241745, + "subdir": "linux-64", + "timestamp": 1569351473872, + "version": "0.3.2" + }, + "fastparquet-0.3.2-py36hdd07704_0.conda": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "six", + "thrift >=0.11.0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "be65746466800cf7bece4a019b93160e", + "name": "fastparquet", + "sha256": "ec0c02818ec3c70abce2c31c10d871262e9892873845723f5571c3c7bd41f4d1", + "size": 237344, + "subdir": "linux-64", + "timestamp": 1569351514594, + "version": "0.3.2" + }, + "fastparquet-0.3.2-py36heb32a55_0.conda": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.14.6,<2.0a0", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "six", + "thrift >=0.11.0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "c2e176fbc60bd64545a4806484e39676", + "name": "fastparquet", + "sha256": "30a8b41b0ae0922677fb5183aef06d48cd9f494aeb32511de4d6bb43e03dfe7c", + "size": 236010, + "subdir": "linux-64", + "timestamp": 1592380548107, + "version": "0.3.2" + }, + "fastparquet-0.3.2-py37hdd07704_0.conda": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "six", + "thrift >=0.11.0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "10669a9ba4a27d1fec4aae964dd6552a", + "name": "fastparquet", + "sha256": "d8ea8bbe2d941f8c49f1c8d81d09b266434b8eeb2019b17b7fc61a4dd706d9ab", + "size": 239000, + "subdir": "linux-64", + "timestamp": 1569351485759, + "version": "0.3.2" + }, + "fastparquet-0.3.2-py37heb32a55_0.conda": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.14.6,<2.0a0", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "six", + "thrift >=0.11.0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "f398ed57cf2cf834c759f6647a0bfbce", + "name": "fastparquet", + "sha256": "d3aaedc400e96fec64f758e705680e8319b7e3174cc2f5919a509c4822c5adce", + "size": 237528, + "subdir": "linux-64", + "timestamp": 1592380535427, + "version": "0.3.2" + }, + "fastparquet-0.3.2-py38heb32a55_0.conda": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy >=1.14.6,<2.0a0", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "six", + "thrift >=0.11.0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "0085effedd3280bf4ece6fdf05c7242a", + "name": "fastparquet", + "sha256": "2db8ce718825811a0c04c97ff88a57cfa9d361ecdd5d898159702535e05c5c24", + "size": 238755, + "subdir": "linux-64", + "timestamp": 1592380526741, + "version": "0.3.2" + }, + "fastparquet-0.3.3-py36heb32a55_0.conda": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "ee9e6c94669029925aec8138b05b577c", + "name": "fastparquet", + "sha256": "b1ae59a56081ebe849c891daeb25ac8e394a41881ceaef49c31adb35074b532e", + "size": 236333, + "subdir": "linux-64", + "timestamp": 1598036464021, + "version": "0.3.3" + }, + "fastparquet-0.3.3-py37heb32a55_0.conda": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "15182aca93c8071c3bec452c16daa0e4", + "name": "fastparquet", + "sha256": "98a2770c2ce7ea130e25aa81eb01f8c2e6a25d91a2a0c90001963c09e661cf67", + "size": 237923, + "subdir": "linux-64", + "timestamp": 1598036468063, + "version": "0.3.3" + }, + "fastparquet-0.3.3-py38heb32a55_0.conda": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "09730e82629819e911377f705da79190", + "name": "fastparquet", + "sha256": "69b575cec08dfa0393d02463c164c9b2442fbe9ec87ef3446f65e3fff9d2bf92", + "size": 240493, + "subdir": "linux-64", + "timestamp": 1598036452604, + "version": "0.3.3" + }, + "fastparquet-0.4.0-py36heb32a55_0.conda": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "f97fa0a62744518cfa5f1dfef9fd5b93", + "name": "fastparquet", + "sha256": "59814c8dcb699eea4cc38ceb94a0aabc7ce8676e2a9d002fddd8b7ff6689dc5f", + "size": 236235, + "subdir": "linux-64", + "timestamp": 1598037895407, + "version": "0.4.0" + }, + "fastparquet-0.4.0-py37heb32a55_0.conda": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "378e32f6754b42e52f83c0b7f86928db", + "name": "fastparquet", + "sha256": "5cdb7f4bae52e7bd2b6e07b9d3645dc360bea620229d69c720b4eab43600e698", + "size": 236681, + "subdir": "linux-64", + "timestamp": 1598037884834, + "version": "0.4.0" + }, + "fastparquet-0.4.0-py38heb32a55_0.conda": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "11577a02692ebdbf785862cf12cb729c", + "name": "fastparquet", + "sha256": "0a6db78e837b7922c983e67d15f7542525238527bddf6a30e21206b1c6262c81", + "size": 238537, + "subdir": "linux-64", + "timestamp": 1598037895517, + "version": "0.4.0" + }, + "fastparquet-0.4.1-py36heb32a55_0.conda": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "8a608025f85fbf4b02c035c9ac1bd374", + "name": "fastparquet", + "sha256": "7a6d8621fdba9d9f111f0d4c897cf844db250b6dbe286e3932db7d8daa100772", + "size": 3537054, + "subdir": "linux-64", + "timestamp": 1598038695758, + "version": "0.4.1" + }, + "fastparquet-0.4.1-py37heb32a55_0.conda": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "7bf2ba4ea037e2a4cef596515dd1cb9d", + "name": "fastparquet", + "sha256": "3d206a047ca2e79538553aa9457754248e72dba63c8285f2c0b1ebe5cfa9343b", + "size": 3539345, + "subdir": "linux-64", + "timestamp": 1598038723986, + "version": "0.4.1" + }, + "fastparquet-0.4.1-py38heb32a55_0.conda": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "10b89c637227813c942fe6ffb036aefb", + "name": "fastparquet", + "sha256": "9d14ce6b4f6ca3da31a9aba3bdaa36fb6792835073a5f9a3c4ba1e60290623bb", + "size": 3541577, + "subdir": "linux-64", + "timestamp": 1598038730770, + "version": "0.4.1" + }, + "fastparquet-0.4.2-py36h6323ea4_0.conda": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "8b1326e5ffc988944f48adb995ae5bc7", + "name": "fastparquet", + "sha256": "e59dbe8526f2cd65b2065eec1d8d2169abc5d8ef06d39ddceab206345464ceab", + "size": 179681, + "subdir": "linux-64", + "timestamp": 1607969564742, + "version": "0.4.2" + }, + "fastparquet-0.4.2-py37h6323ea4_0.conda": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "fc2fb57f10ab6a978f1634f8fc4b98cf", + "name": "fastparquet", + "sha256": "9504d1445c641a27a78edb0ba9203d1e4555c8b3811fb6cabcfe8e8f387f895a", + "size": 180894, + "subdir": "linux-64", + "timestamp": 1607969529575, + "version": "0.4.2" + }, + "fastparquet-0.4.2-py38h6323ea4_0.conda": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "e23ac731e4ae2e822685a6e03ad17880", + "name": "fastparquet", + "sha256": "5fd41196933537cebf9c4ac72d537ef7d12b63fb4fabc28a5727db31b6a36bbd", + "size": 180948, + "subdir": "linux-64", + "timestamp": 1607969565853, + "version": "0.4.2" + }, + "fastparquet-0.5.0-py310ha9d4c09_2.conda": { + "build": "py310ha9d4c09_2", + "build_number": 2, + "constrains": [ + "numpy >=1.18,<1.22" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "numba >=0.49", + "numpy >=1.21.5,<2.0a0", + "packaging", + "pandas >=1.1.0", + "python >=3.10,<3.11.0a0", + "thrift >=0.11" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "722da6ad4911b8f463f4ff0f638f10df", + "name": "fastparquet", + "sha256": "42afe0f05818a519b5ac76c26c0ddb8c9b70207f8db8af7ba6366bbc5c9408ba", + "size": 251655, + "subdir": "linux-64", + "timestamp": 1658500821948, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py36h6323ea4_0.conda": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "10339e707fad28ffaa69994e58e9117a", + "name": "fastparquet", + "sha256": "f6bb73bdf8297b8097cd3f6736712998dd36c263248a32b8806596d1a34d39cb", + "size": 179491, + "subdir": "linux-64", + "timestamp": 1609265989487, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py36h6323ea4_1.conda": { + "build": "py36h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "0f3fc4f3ced63e34bea0795cecd547e8", + "name": "fastparquet", + "sha256": "335bfb4983692051f71583a9aa9ef43c6dd2343e0f67cb324e229d29acf0692b", + "size": 179978, + "subdir": "linux-64", + "timestamp": 1610480463284, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py36hce1f21e_1.conda": { + "build": "py36hce1f21e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "3a400f9771d5dec9344bf4eb25133c16", + "name": "fastparquet", + "sha256": "7c7c80c8fa996782ddd39a315a517124b6c833679dc7b594084e8c62dc91d104", + "size": 180189, + "subdir": "linux-64", + "timestamp": 1632742586462, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py37h6323ea4_0.conda": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "dc7ee09544f87d69fb5e0ea62745ff75", + "name": "fastparquet", + "sha256": "811e61403e7cca969559039cd9adff86aaa49b10c51baefc6388f91824a85244", + "size": 178628, + "subdir": "linux-64", + "timestamp": 1609265959270, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py37h6323ea4_1.conda": { + "build": "py37h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "3774c6c7d260528d1965a11526d1cfc8", + "name": "fastparquet", + "sha256": "86d3301ab7cdba03fe0422bb7f03a93550323a550ae002dde1de2c17d2a7c55c", + "size": 181397, + "subdir": "linux-64", + "timestamp": 1610480435219, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py37h7deecbd_2.conda": { + "build": "py37h7deecbd_2", + "build_number": 2, + "constrains": [ + "numpy >=1.18,<1.22" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "numba >=0.49", + "numpy >=1.16.6,<2.0a0", + "packaging", + "pandas >=1.1.0", + "python >=3.7,<3.8.0a0", + "thrift >=0.11" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c8dbf98711e112c7e74f0ad42f44113d", + "name": "fastparquet", + "sha256": "40fcbc98d58e32f35e0d0cb381d749a582e68c434e7237a7ae137d9e1832c6a4", + "size": 180237, + "subdir": "linux-64", + "timestamp": 1658500665617, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py37hce1f21e_1.conda": { + "build": "py37hce1f21e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "b6f5b93a0c223ebc471d7b59c1e649c8", + "name": "fastparquet", + "sha256": "46cd37e6d50405888b73db3a0665bad206747ff68e0e93c9d5304a8cd8ba4d9a", + "size": 179582, + "subdir": "linux-64", + "timestamp": 1632742563495, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py38h6323ea4_0.conda": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "210db14d936a94398a8291bb2a4fb7ed", + "name": "fastparquet", + "sha256": "2e9ad0ac9240bda27da98cff028bdbb6ae5bd066159977a328c0be2642a9756a", + "size": 180848, + "subdir": "linux-64", + "timestamp": 1609265948058, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py38h6323ea4_1.conda": { + "build": "py38h6323ea4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "2a96ccba74d2dd961967cd35491a75d1", + "name": "fastparquet", + "sha256": "b12672a21c5c830c04d00fbb78868e52ddca761ed2cbada46b5ad8cbd1b34732", + "size": 183055, + "subdir": "linux-64", + "timestamp": 1610480426195, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py38h7deecbd_2.conda": { + "build": "py38h7deecbd_2", + "build_number": 2, + "constrains": [ + "numpy >=1.18,<1.22" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "numba >=0.49", + "numpy >=1.16.6,<2.0a0", + "packaging", + "pandas >=1.1.0", + "python >=3.8,<3.9.0a0", + "thrift >=0.11" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "84afa34c4788e3932c289a878883f90a", + "name": "fastparquet", + "sha256": "5912470eec9181bc2d7f89afe2f78ddb0e2248f8148c00ccfc1ef31cab76056f", + "size": 181508, + "subdir": "linux-64", + "timestamp": 1658500714903, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py38hce1f21e_1.conda": { + "build": "py38hce1f21e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "292463dcbcbcbece1962a3155c7d43ee", + "name": "fastparquet", + "sha256": "80708c6489387a2c9b455cebb8c89a4d42ab8295fe0db5ac7d03b8be4b3c1ff0", + "size": 182238, + "subdir": "linux-64", + "timestamp": 1632742568948, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py39h6323ea4_0.conda": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.9,<3.10.0a0", + "thrift >=0.11" + ], + "license": "BSD-3-Clause", + "md5": "38246de34ea154a719942f1602b877da", + "name": "fastparquet", + "sha256": "698d005e5a35e70d4d6819d56650bf990b03dc248db1429731de7581790856a0", + "size": 182440, + "subdir": "linux-64", + "timestamp": 1615918606368, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py39h7deecbd_2.conda": { + "build": "py39h7deecbd_2", + "build_number": 2, + "constrains": [ + "numpy >=1.18,<1.22" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "numba >=0.49", + "numpy >=1.16.6,<2.0a0", + "packaging", + "pandas >=1.1.0", + "python >=3.9,<3.10.0a0", + "thrift >=0.11" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3acd6ac63422946d454e5403b359e318", + "name": "fastparquet", + "sha256": "ae70b5de3c2e1aba7d976b1a4bd8fbfab471095706dcdf326efb8ce99fb90884", + "size": 181166, + "subdir": "linux-64", + "timestamp": 1658500763114, + "version": "0.5.0" + }, + "fastparquet-0.5.0-py39hce1f21e_1.conda": { + "build": "py39hce1f21e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "numba >=0.28", + "numpy", + "packaging", + "pandas >=0.19", + "python >=3.9,<3.10.0a0", + "thrift 0.11.*" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "a68dcc3c847fa99380240c34ae434832", + "name": "fastparquet", + "sha256": "addba4026b21c6a87cb1759c53abe186454c46464cb736c92441b0fd7e81bc48", + "size": 182349, + "subdir": "linux-64", + "timestamp": 1632742520549, + "version": "0.5.0" + }, + "fastrlock-0.3-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e7cf9ecc3020f5398448c86ab353fa69", + "name": "fastrlock", + "sha256": "a16c7be7efd9544f1df9a96de96b10bc972a333d44d319368e164f034fdabfc5", + "size": 27200, + "subdir": "linux-64", + "timestamp": 1524327943139, + "version": "0.3" + }, + "fastrlock-0.3-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48d83c1e86ea59aa708abd0af325a4d5", + "name": "fastrlock", + "sha256": "10e5639e5f64284f0e1df41e5de66a411d0350ebaa8fd9b6dfe1199977d48c8f", + "size": 27939, + "subdir": "linux-64", + "timestamp": 1524327943249, + "version": "0.3" + }, + "fastrlock-0.3-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be881d70266c86735006db1fc4da5e12", + "name": "fastrlock", + "sha256": "eed698a19078c914ba3fe606d81b146d3a35545bd526941f75b6f4831bec804e", + "size": 27927, + "subdir": "linux-64", + "timestamp": 1524327683104, + "version": "0.3" + }, + "fastrlock-0.3-py37hf484d3e_0.conda": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "46db969166a74511b897dab8d7f17a9c", + "name": "fastrlock", + "sha256": "125ae0d490df25efead131620b3b2a39ce779561b22ad84365cb1bff95ee50f3", + "size": 27816, + "subdir": "linux-64", + "timestamp": 1530814380458, + "version": "0.3" + }, + "fastrlock-0.4-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a474b30920f7462c92a6a3b000253307", + "name": "fastrlock", + "sha256": "8d762429e44a42d08c38cb031800dbcf2b9c067174cbcbd148a25de97a57e648", + "size": 29198, + "subdir": "linux-64", + "timestamp": 1535511229200, + "version": "0.4" + }, + "fastrlock-0.4-py35he6710b0_0.conda": { + "build": "py35he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1512a8238d7ec2ef507a51cb79fcaa68", + "name": "fastrlock", + "sha256": "ae1ef98502211a02e73cc88960dde08f111bfff38ffdeb09f6b080426f571f37", + "size": 29481, + "subdir": "linux-64", + "timestamp": 1535511239611, + "version": "0.4" + }, + "fastrlock-0.4-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "950e633e6f1ddea91279beaaeaec293d", + "name": "fastrlock", + "sha256": "19add89f4bf2a9107e5b26a2b4653fa793737556f462159ee811c31a781c4bf1", + "size": 29482, + "subdir": "linux-64", + "timestamp": 1535511197979, + "version": "0.4" + }, + "fastrlock-0.4-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "26514c0c89b338a4b346985a6987633f", + "name": "fastrlock", + "sha256": "34d4e7739af9626804a03bafb9883606badc796efecb3625bcb628611a58240b", + "size": 29246, + "subdir": "linux-64", + "timestamp": 1535511296251, + "version": "0.4" + }, + "fastrlock-0.4-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "edeb5dc44d9a48211cc047f1f267cb39", + "name": "fastrlock", + "sha256": "6f4c8abf8eb164086c1bd160ef321b5d892cfbeb9ce2c10635ed6115cfacc267", + "size": 30259, + "subdir": "linux-64", + "timestamp": 1572357520917, + "version": "0.4" + }, + "fastrlock-0.5-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c5b0a44fac20df6f8194c74900a9615", + "name": "fastrlock", + "sha256": "912f5fafab1105480b8736f242bc52ba1a6ca5c258e127e9f7a318d813081d24", + "size": 74676, + "subdir": "linux-64", + "timestamp": 1640790026258, + "version": "0.5" + }, + "fastrlock-0.5-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "271d61a0843dec9300b5d77653a2f07f", + "name": "fastrlock", + "sha256": "b3b1ac93cad719f065f39257d850d006d36f8a6ccca7941fcef8addbc7b476fd", + "size": 29892, + "subdir": "linux-64", + "timestamp": 1676852319513, + "version": "0.5" + }, + "fastrlock-0.5-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14314f2dbd2b78c0a4bce4198122e8d9", + "name": "fastrlock", + "sha256": "85d320ffb0c3a010b53ef8b60ec0f66f64aa49c5683894d0355d5cf172148b6e", + "size": 32223, + "subdir": "linux-64", + "timestamp": 1599766709419, + "version": "0.5" + }, + "fastrlock-0.5-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f3117dc6905c228e6a87bbc279da979", + "name": "fastrlock", + "sha256": "d51bc71c037096324a71c100ad570b5f3fd18af3bee098b7894c59b121c90566", + "size": 32215, + "subdir": "linux-64", + "timestamp": 1599766729813, + "version": "0.5" + }, + "fastrlock-0.5-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8d43b5001749d8b2c8d9a160e15ec3a", + "name": "fastrlock", + "sha256": "ec11562375ac2898a9e2abab9ed55fca5629e8c7e1eaff265bed90dbf4e77810", + "size": 32516, + "subdir": "linux-64", + "timestamp": 1599766705650, + "version": "0.5" + }, + "fastrlock-0.5-py39he6710b0_0.conda": { + "build": "py39he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd8bf793358ee821155c8c3d92f91ced", + "name": "fastrlock", + "sha256": "2a5cbcbe6e852c40dd408195990304afe4dd0920341575adaf381f4cf57dc8ef", + "size": 32729, + "subdir": "linux-64", + "timestamp": 1610048070026, + "version": "0.5" + }, + "fastrlock-0.6-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71875e0c436d7ef75e51c968f196db24", + "name": "fastrlock", + "sha256": "2f747a3ea830df74d213ff85519dd24417042bb5821ed44384b8097af0d2a20b", + "size": 30878, + "subdir": "linux-64", + "timestamp": 1616528362919, + "version": "0.6" + }, + "fastrlock-0.6-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56316866bfde4df72caa93ca31c92837", + "name": "fastrlock", + "sha256": "e2e38c82ca0253f58782a2d9a3faae917815e4bbaf31b743b4f683b8127d257d", + "size": 31063, + "subdir": "linux-64", + "timestamp": 1616527930744, + "version": "0.6" + }, + "fastrlock-0.6-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8cf780c5e922f1801ccbf52142beffc", + "name": "fastrlock", + "sha256": "59b2a19a0f3aa1aae80d0fab1b018e501734661a48f21eb340684242aa25f53e", + "size": 31162, + "subdir": "linux-64", + "timestamp": 1616528366658, + "version": "0.6" + }, + "fastrlock-0.6-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f236a74d1107dc4a29760cb987ace9f", + "name": "fastrlock", + "sha256": "2e7dd7cfd45567e2947466f41f661570710e7b707726314b6bbf7a6f1d9b0a83", + "size": 30776, + "subdir": "linux-64", + "timestamp": 1616528355701, + "version": "0.6" + }, + "fasttsne-0.2.13-py36hdd07704_1.conda": { + "build": "py36hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.38.1", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "67681cad8d5e50dd27eb44020ea485b4", + "name": "fasttsne", + "sha256": "707d062171b358928949fb660fc6bb1497655367d0a5d1a9c9a88d4b25b56fff", + "size": 345257, + "subdir": "linux-64", + "timestamp": 1547969572656, + "version": "0.2.13" + }, + "fasttsne-0.2.13-py37hdd07704_1.conda": { + "build": "py37hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.38.1", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f3586972fcbd43bacce0d5048bae9db", + "name": "fasttsne", + "sha256": "73b235d7429edc3ec667a0f1c60f1a643474f788905f4dd552ddec8c4977171b", + "size": 345562, + "subdir": "linux-64", + "timestamp": 1547969502556, + "version": "0.2.13" + }, + "faulthandler-3.1-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "fa637099f1b1387333857565e1a0c829", + "name": "faulthandler", + "sha256": "d8c4d06365d8e738e194f133aaea0f4d7094de288be1e82b0a78bba599edc984", + "size": 17533, + "subdir": "linux-64", + "timestamp": 1529346531868, + "version": "3.1" + }, + "feedparser-5.2.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "24f7761388ff9fcf17b567047a7e3c48", + "name": "feedparser", + "sha256": "2060832e32d0e6c304cffc5c892c5fafaf4035978a2ade2cbea0ee025a351d11", + "size": 85040, + "subdir": "linux-64", + "timestamp": 1537207058707, + "version": "5.2.1" + }, + "feedparser-5.2.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "94d2b41ecb63b2c46e209af5da1ff80f", + "name": "feedparser", + "sha256": "b0873f46080004126e918d5a49cafe0a063af2b1a0d739ed7416bbafb36de139", + "size": 84475, + "subdir": "linux-64", + "timestamp": 1537207084146, + "version": "5.2.1" + }, + "feedparser-5.2.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "936f86a24b3951fa82f2f933046d3224", + "name": "feedparser", + "sha256": "8182b00f3e3111ab0ce24c5d0e5725b2009c3ece8f393be9f97fbe63538be916", + "size": 83143, + "subdir": "linux-64", + "timestamp": 1537207101004, + "version": "5.2.1" + }, + "feedparser-5.2.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "063f95cacc72724d7d3fcac610742200", + "name": "feedparser", + "sha256": "7b2d0992fb0562d3d52122040d86b93f3bf2239d8e5ba2d7d21746cc78b0bec4", + "size": 85075, + "subdir": "linux-64", + "timestamp": 1537207025484, + "version": "5.2.1" + }, + "feedparser-5.2.1-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "a45a2cdc9c4819234f8a2bae5326db12", + "name": "feedparser", + "sha256": "4e0269946d1d0afebc3b5f9e0c04b1debf29f517d9b99a2b8ff599b9cbe8fc62", + "size": 84903, + "subdir": "linux-64", + "timestamp": 1572357556284, + "version": "5.2.1" + }, + "feedparser-6.0.8-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "sgmllib3k" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "60d7e3435f7c392cba653f4120a6c552", + "name": "feedparser", + "sha256": "fc200d93be01438b7940552bdb5025f3b12f6dc39cd14fc6728cd1936eb22b56", + "size": 93967, + "subdir": "linux-64", + "timestamp": 1640790045761, + "version": "6.0.8" + }, + "feedparser-6.0.8-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "sgmllib3k" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "684125a45801d777b53faadc09b29252", + "name": "feedparser", + "sha256": "9e814f000e3a03754253ab2ed1fe209baaf795799c61ceac2606be6414c83353", + "size": 122076, + "subdir": "linux-64", + "timestamp": 1676907122074, + "version": "6.0.8" + }, + "feedparser-6.0.8-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "sgmllib3k" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "f00d4cec9ecad401c0b19284e6bbcf56", + "name": "feedparser", + "sha256": "fb5b5fa158f5b8bd14fa979ed8a3aece72b91e395d534b84b94a340abbf483d3", + "size": 394572, + "subdir": "linux-64", + "timestamp": 1636039078858, + "version": "6.0.8" + }, + "feedparser-6.0.8-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "sgmllib3k" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "1f3f497f60e0a3e06f0e102283ed01a1", + "name": "feedparser", + "sha256": "e1631a0f7e14ee8f7aa8b8afe14b7c6f03cc53174a80fb0391c71230ecfdbf9b", + "size": 395088, + "subdir": "linux-64", + "timestamp": 1636038971948, + "version": "6.0.8" + }, + "feedparser-6.0.8-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "sgmllib3k" + ], + "license": "OSI Approved", + "license_family": "Other", + "md5": "2623a7918466aeef5aa9c3bd527ecdb4", + "name": "feedparser", + "sha256": "87a614e941cb7848bdb7e269a5807520c970dc9ea1028a31be1089bf46883193", + "size": 394228, + "subdir": "linux-64", + "timestamp": 1636027071653, + "version": "6.0.8" + }, + "ffmpeg-3.4-h7264315_0.conda": { + "build": "h7264315_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.2.0", + "libopus >=1.2.1,<2.0a0", + "libstdcxx-ng >=7.2.0", + "libvpx >=1.6.1,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "b52c9e07a9f66b5ae4a93be59533016c", + "name": "ffmpeg", + "sha256": "4435209b421f23c6deb649ae6876f4746c066dba7e999af733ad172032edb346", + "size": 7395901, + "subdir": "linux-64", + "timestamp": 1512489786386, + "version": "3.4" + }, + "ffmpeg-3.4-h7985aa0_0.conda": { + "build": "h7985aa0_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.2.0", + "libopus >=1.2.1,<2.0a0", + "libstdcxx-ng >=7.2.0", + "libvpx >=1.7.0,<1.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "b0432687479e0e649c8f98ccbe0cca85", + "name": "ffmpeg", + "sha256": "957ff8573ea4a3c45c6879b7086e475270564b19214b89e8b297410eb15064ad", + "size": 7395469, + "subdir": "linux-64", + "timestamp": 1530807868145, + "version": "3.4" + }, + "ffmpeg-4.0-h04d0a96_0.conda": { + "build": "h04d0a96_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "freetype >=2.8,<2.9.0a0", + "libgcc-ng >=7.2.0", + "libopus >=1.2.1,<2.0a0", + "libstdcxx-ng >=7.2.0", + "libvpx >=1.7.0,<1.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 3", + "md5": "b8b03113e4e5880d084b1e18b3c9ebf9", + "name": "ffmpeg", + "sha256": "c9f5a16856497b450406caa4465c1318581a0e684145361477b77aaaec35c664", + "size": 55886935, + "subdir": "linux-64", + "timestamp": 1526323943701, + "version": "4.0" + }, + "ffmpeg-4.0-hcdf2ecd_0.conda": { + "build": "hcdf2ecd_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.2.0", + "libopus >=1.2.1,<2.0a0", + "libstdcxx-ng >=7.2.0", + "libvpx >=1.7.0,<1.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 3", + "md5": "cb00411bab76b9d4fff05ca982bb3d2c", + "name": "ffmpeg", + "sha256": "841462b38d55adc5d0011760918b2781eb7a1a0e8d2de71ee456f86a3b8e79fb", + "size": 55912615, + "subdir": "linux-64", + "timestamp": 1531089119627, + "version": "4.0" + }, + "ffmpeg-4.2-h1a5d6f3_0.conda": { + "build": "h1a5d6f3_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "freetype >=2.9.1,<3.0a0", + "gmp >=6.1.2", + "lame >=3.100,<3.101.0a0", + "libgcc-ng >=7.3.0", + "libopus >=1.3,<2.0a0", + "libstdcxx-ng >=7.3.0", + "libvpx >=1.7.0,<1.8.0a0", + "openh264 >=1.8.0,<1.9.0a0", + "openssl >=1.1.1d,<1.1.2a", + "x264 >=1!152.20180806,<1!153", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 3", + "md5": "cab36ffb011f7ade0456950fc8e434b5", + "name": "ffmpeg", + "sha256": "0218470754eb87706453831b595fe31a771fa4c5a1b77f6c8fac896f8a6b01e1", + "size": 61568307, + "subdir": "linux-64", + "timestamp": 1576692476884, + "version": "4.2" + }, + "ffmpeg-4.2.2-h20bf706_0.conda": { + "build": "h20bf706_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "freetype >=2.9.1,<3.0a0", + "gmp >=6.1.2", + "gnutls >=3.6.5,<3.7.0a0", + "lame >=3.100,<3.101.0a0", + "libgcc-ng >=7.3.0", + "libopus >=1.3.1,<2.0a0", + "libvpx >=1.7.0,<1.8.0a0", + "openh264 >=2.1.0,<2.2.0a0", + "x264 >=1!157.20191217,<1!158", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 3", + "md5": "2b07a3d0aab8f55c77c737db64fe145b", + "name": "ffmpeg", + "sha256": "28bdbb468c6116d17523269a043848c1ddf1377c7dd4908aa4e959abab8c6169", + "size": 62503168, + "subdir": "linux-64", + "timestamp": 1587155035511, + "version": "4.2.2" + }, + "fftw-3.3.8-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 2", + "md5": "5caea4e8be6f67b7222202277a5c8152", + "name": "fftw", + "sha256": "d9e1dcac2e91fd7f5fb5dcd548ecf1a56472f6ab08fe226043258f5e8b01c569", + "size": 2389925, + "subdir": "linux-64", + "timestamp": 1528733567738, + "version": "3.3.8" + }, + "fftw-3.3.8-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2", + "md5": "07bbc80c36edeb478c7794e24a209c5b", + "name": "fftw", + "sha256": "41bc1d40abe413dfab65aca0ef9450012c2d01f02ec04537dc3a87390b272e13", + "size": 2415797, + "subdir": "linux-64", + "timestamp": 1541613129286, + "version": "3.3.8" + }, + "fftw-3.3.8-h7b6447c_1.conda": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2", + "md5": "af5cc11e0ddf4b2647f2552c8be48eeb", + "name": "fftw", + "sha256": "d79a663a2e4226e7d0ce70f6976f0b129654bfc5acad3754b1b3ded877b35afa", + "size": 2414510, + "subdir": "linux-64", + "timestamp": 1541619763511, + "version": "3.3.8" + }, + "fftw-3.3.8-h7b6447c_2.conda": { + "build": "h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2", + "md5": "a461c2672f5bcfe160158c279c08669b", + "name": "fftw", + "sha256": "eadc25434a14d8484623d7336f84e857f704a7a0cdc0f5e77f075073bdeef5af", + "size": 2414108, + "subdir": "linux-64", + "timestamp": 1541708102573, + "version": "3.3.8" + }, + "fftw-3.3.8-h7b6447c_3.conda": { + "build": "h7b6447c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2", + "md5": "d58c911c6824974a8bf9c2ec92387fe9", + "name": "fftw", + "sha256": "4346d91967a222c50d418ab50b1f1589164b4aed0e4c5fb74ad627f7dd6bd281", + "size": 2414606, + "subdir": "linux-64", + "timestamp": 1541922820942, + "version": "3.3.8" + }, + "fftw-3.3.9-h27cfd23_1.conda": { + "build": "h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2", + "md5": "d266674fbd3345d45a69896e1bdef8be", + "name": "fftw", + "sha256": "cd2b91933ab098dff121a4ea2a9d8e46f28aa6c3afb3f746b85a309eae14b0fe", + "size": 2443756, + "subdir": "linux-64", + "timestamp": 1607970357824, + "version": "3.3.9" + }, + "filelock-2.0.12-py27h38fa839_0.conda": { + "build": "py27h38fa839_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "md5": "853b7b6eb54ae4555110584882cf2bff", + "name": "filelock", + "sha256": "8eac48c5103bf8e3b77aa03be6586a542fcdbd07371b042034f87555a0dd4a62", + "size": 11093, + "subdir": "linux-64", + "timestamp": 1505957212074, + "version": "2.0.12" + }, + "filelock-2.0.12-py35h7855d60_0.conda": { + "build": "py35h7855d60_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain", + "md5": "6b70589ea633d4646a8e60de2bac69e1", + "name": "filelock", + "sha256": "9f37ac7b578bac3cdb35dfe7aa3eb91d019aff6a2371a4dc1751d3973d6971f4", + "size": 11258, + "subdir": "linux-64", + "timestamp": 1505957225059, + "version": "2.0.12" + }, + "filelock-2.0.12-py36hacfa1f5_0.conda": { + "build": "py36hacfa1f5_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "md5": "03107346f22b85efbf85f4d877a2a11e", + "name": "filelock", + "sha256": "47d97aa83c89041132d9f4c1ac02862b5ae6f20869114169444ee5b70a389764", + "size": 11166, + "subdir": "linux-64", + "timestamp": 1505957237843, + "version": "2.0.12" + }, + "filelock-2.0.13-py27h61a9c69_0.conda": { + "build": "py27h61a9c69_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "278350cb5c608521414124d4550f09e6", + "name": "filelock", + "sha256": "8161500113796b337b494bc40db35f110bfcf38cdcc1b3b583b1b0bd53c40198", + "size": 12480, + "subdir": "linux-64", + "timestamp": 1511286413278, + "version": "2.0.13" + }, + "filelock-2.0.13-py35h4160c53_0.conda": { + "build": "py35h4160c53_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "83e655b418daa91d0f7331580d366479", + "name": "filelock", + "sha256": "ec8a6e8db51724d72f68df8d0c8eae78bc2debf53dc3fd405131d32a4762220f", + "size": 12731, + "subdir": "linux-64", + "timestamp": 1511286417303, + "version": "2.0.13" + }, + "filelock-2.0.13-py36h646ffb5_0.conda": { + "build": "py36h646ffb5_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "7c5f1cb9b5b13cb6dc995d1b5464bfd1", + "name": "filelock", + "sha256": "1b72997fc787fc45b45721761cc5c32fd7ea1b96f5819693cec0472bd7030e03", + "size": 12545, + "subdir": "linux-64", + "timestamp": 1511286417175, + "version": "2.0.13" + }, + "filelock-3.0.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "193899c12ec67b6a1b99b8275e7ddc34", + "name": "filelock", + "sha256": "9017a6cad0f23afe41bbb9b18394b5ea7cf51c218ac879486aadb95fa805cc99", + "size": 14251, + "subdir": "linux-64", + "timestamp": 1541105314522, + "version": "3.0.10" + }, + "filelock-3.0.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "d3f4da1224e0426c315df13575642c23", + "name": "filelock", + "sha256": "35c0148bc3c3af7b60d032fa551159a559bd2446a7c2291b05bcb6a4d24b455d", + "size": 14299, + "subdir": "linux-64", + "timestamp": 1541105507859, + "version": "3.0.10" + }, + "filelock-3.0.10-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "84c4f525c5ac2250388ad027fc3b6ce9", + "name": "filelock", + "sha256": "c6b3d80bad434a440e36987351330462070be009b77bc05b98d2d094861eb710", + "size": 14134, + "subdir": "linux-64", + "timestamp": 1541105309293, + "version": "3.0.10" + }, + "filelock-3.0.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "8e4724b253d3ac396950935629f7b68b", + "name": "filelock", + "sha256": "a6d15f474639e3fe1117ab31ec23255c58d4f18d9083da74436eefb5a00cc64c", + "size": 12993, + "subdir": "linux-64", + "timestamp": 1519108209338, + "version": "3.0.4" + }, + "filelock-3.0.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "a4d5ec56de386df83445af0a77ed8194", + "name": "filelock", + "sha256": "135062af9507735685288723e8a7928fa5936049f3cae10a828a4f3b0725382e", + "size": 13254, + "subdir": "linux-64", + "timestamp": 1519108221511, + "version": "3.0.4" + }, + "filelock-3.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "3fbc0578312b2fadd2467e9f52cda152", + "name": "filelock", + "sha256": "41c782a6ec87e1dc2d290de8bf4506d300e731e8ffbc71a4f5222dabfeeb7103", + "size": 13189, + "subdir": "linux-64", + "timestamp": 1519108223962, + "version": "3.0.4" + }, + "filelock-3.0.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "6e9c09de139fdde3909e594db952d5d5", + "name": "filelock", + "sha256": "a9ccc3f16cf016bd83014ea81102992c48dbf44bf99ea24b845903e8e87c81d9", + "size": 12987, + "subdir": "linux-64", + "timestamp": 1530811893950, + "version": "3.0.4" + }, + "filelock-3.0.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "8a69993bb50962b6f2ac456dda2aad8d", + "name": "filelock", + "sha256": "18b49903789ca88c076ea5dbbee8464d563d9dc3211c5bc2a5065f0ed7da5fab", + "size": 13131, + "subdir": "linux-64", + "timestamp": 1535379497436, + "version": "3.0.6" + }, + "filelock-3.0.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "7980b54aa69a235e3ea84ebaaa6adcdf", + "name": "filelock", + "sha256": "37316c2f4f9a0065a6407f4b563e44c8f951333c52ec73dcc8be18d02635d4c0", + "size": 13248, + "subdir": "linux-64", + "timestamp": 1535379225369, + "version": "3.0.6" + }, + "filelock-3.0.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "bafe1c20e284851d7194bc77d90fc35d", + "name": "filelock", + "sha256": "5f67d973afc58606ee76806a924b4815b69175f19b7291e9f7508377ff6d7242", + "size": 13178, + "subdir": "linux-64", + "timestamp": 1535379488238, + "version": "3.0.6" + }, + "filelock-3.0.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "15b6667bcd48eb4f159e5ad9ade0bbf8", + "name": "filelock", + "sha256": "75ed7e9bd22ea4e8014d07e2bda6c31bdaa4393a6757887b9420dbfad6f9fe06", + "size": 13211, + "subdir": "linux-64", + "timestamp": 1535379517775, + "version": "3.0.6" + }, + "filelock-3.0.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "5e7cfeff34c109dc8d473b375badb080", + "name": "filelock", + "sha256": "9e039dbb6bc12b8c8b14762d3399c32901838b11588d4b85748dc13662bdb47e", + "size": 13894, + "subdir": "linux-64", + "timestamp": 1536777028397, + "version": "3.0.8" + }, + "filelock-3.0.8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "8a9d9090837b7a4247a003c2bdd332c1", + "name": "filelock", + "sha256": "8aa08ff1fe15818ca552465e9cbffea5741689501f7551b71ea7e65af9df2b90", + "size": 13956, + "subdir": "linux-64", + "timestamp": 1536777043586, + "version": "3.0.8" + }, + "filelock-3.0.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "6acca3b983c7f339db38ff3e7aff6f1e", + "name": "filelock", + "sha256": "5f6feeecbedc13b9552066f98608ad4d998f3ea1423ef75eedf2e82650aa8aec", + "size": 13878, + "subdir": "linux-64", + "timestamp": 1536777053619, + "version": "3.0.8" + }, + "filelock-3.0.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "4bb81751a4d80c360c609117ef80a3a3", + "name": "filelock", + "sha256": "09af7fa36ded277fa71c95dde2a0f12daadae885a6ee315d7f7e8980630fdd0a", + "size": 13878, + "subdir": "linux-64", + "timestamp": 1536776994737, + "version": "3.0.8" + }, + "filelock-3.0.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "25d86a964e57cfd5f03d469c886d1d21", + "name": "filelock", + "sha256": "d9cf87997b14827a39882c8a2e3cd1c6fbe87b1c612e1fb2739fd0c64be49966", + "size": 14313, + "subdir": "linux-64", + "timestamp": 1539100208653, + "version": "3.0.9" + }, + "filelock-3.0.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "7a21dc222ca61f528a6424e0ef94748f", + "name": "filelock", + "sha256": "a7543c63c2178b13459380c8f9dc1c2664d350f06e0cc8f28a32f76358f4b66d", + "size": 14179, + "subdir": "linux-64", + "timestamp": 1539100215355, + "version": "3.0.9" + }, + "filelock-3.0.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain", + "license_family": "Public-Domain", + "md5": "fc07f8b7c0a9d7de99e02a83756ee73e", + "name": "filelock", + "sha256": "6ed93a14b642a4736f146cb698126ba4c70615a0316f164d120c9959194e1627", + "size": 14344, + "subdir": "linux-64", + "timestamp": 1539100177919, + "version": "3.0.9" + }, + "filelock-3.9.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Unlicense", + "license_family": "Public-Domain", + "md5": "ee117ef79a5cc24dd42067b41a171421", + "name": "filelock", + "sha256": "1075e6684c0c8546335ab40c23727c002f74b6a1f55be5ba0d647795c041de63", + "size": 18613, + "subdir": "linux-64", + "timestamp": 1672387160431, + "version": "3.9.0" + }, + "filelock-3.9.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Unlicense", + "license_family": "Public-Domain", + "md5": "a8fdf954594858b93a6555311fb34e68", + "name": "filelock", + "sha256": "5d0f878e38f1076189e45cbe4f3781e0bc9fce44af526f7a23be2efe30a71f01", + "size": 21009, + "subdir": "linux-64", + "timestamp": 1676823036011, + "version": "3.9.0" + }, + "filelock-3.9.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Unlicense", + "license_family": "Public-Domain", + "md5": "509cbd670f0ab545a5585e9fc4f2b8f3", + "name": "filelock", + "sha256": "ea28ddfbeef0d8e8d594f3c0a59031181f0b89b7cfa8986ad3faf955d22de2e9", + "size": 18423, + "subdir": "linux-64", + "timestamp": 1672387215084, + "version": "3.9.0" + }, + "filelock-3.9.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Unlicense", + "license_family": "Public-Domain", + "md5": "90cf00e8b50ede437ac0e69e8fd4dbf2", + "name": "filelock", + "sha256": "1856a9f921bb26390d66c9c42877837d02055daf34ad954ccdc06b01b19b49b3", + "size": 18443, + "subdir": "linux-64", + "timestamp": 1672387187242, + "version": "3.9.0" + }, + "filelock-3.9.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Unlicense", + "license_family": "Public-Domain", + "md5": "077473eb25b422637a6e4ee26a9c507d", + "name": "filelock", + "sha256": "f782a762fdd6d032735e968ca2099a5edbeb6a75f90e7678d7a2e5ab64da279d", + "size": 18468, + "subdir": "linux-64", + "timestamp": 1672387242626, + "version": "3.9.0" + }, + "findpython-0.2.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9e1e4403bdfea120238d8915d5e84cf", + "name": "findpython", + "sha256": "44779e2a179d9412e1334e8435df035c311e78772df23f71c1c0377ef9f959c6", + "size": 34902, + "subdir": "linux-64", + "timestamp": 1669937857846, + "version": "0.2.2" + }, + "findpython-0.2.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8bcff7c5bfd47c3963d765d8ae2262f6", + "name": "findpython", + "sha256": "7fa66433be435f031a23e12ea2a729855136661e66c377575a80425b18e37990", + "size": 41858, + "subdir": "linux-64", + "timestamp": 1676839832501, + "version": "0.2.2" + }, + "findpython-0.2.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "29f78c0f033f447c7fe2214574ce6c9b", + "name": "findpython", + "sha256": "5f5391ddb087062e296113c89c1045d24c06778bd1952ad8faf32891cea0404d", + "size": 34263, + "subdir": "linux-64", + "timestamp": 1669937831421, + "version": "0.2.2" + }, + "findpython-0.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "30e2acc8b70bc9310f947eb35469db83", + "name": "findpython", + "sha256": "677e06ca833617332622506c7c41af0eff658d85318b3f2d58ee5234a6d8a209", + "size": 34435, + "subdir": "linux-64", + "timestamp": 1669937778488, + "version": "0.2.2" + }, + "findpython-0.2.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d3aebf6305578c2864e62a06fda656f7", + "name": "findpython", + "sha256": "35495322e672b1108aed1a81cbf45ca7813ebbc4fef43a1c04d78c22fcaf09eb", + "size": 34330, + "subdir": "linux-64", + "timestamp": 1669937804770, + "version": "0.2.2" + }, + "fiona-1.7.10-py27hc43112a_0.conda": { + "build": "py27hc43112a_0", + "build_number": 0, + "depends": [ + "click-plugins", + "cligj", + "enum34", + "gdal 2.2.*", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "munch", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "shapely", + "six" + ], + "license": "BSD 3-Clause", + "md5": "f3ef71f4dd9321caeee8c3ec5611ed4b", + "name": "fiona", + "sha256": "875818d0eb39504ef686abd64ca279493d1154caac220bd352a9ecb6713ff8f2", + "size": 544238, + "subdir": "linux-64", + "timestamp": 1511983847259, + "version": "1.7.10" + }, + "fiona-1.7.10-py35h82be5b1_0.conda": { + "build": "py35h82be5b1_0", + "build_number": 0, + "depends": [ + "click-plugins", + "cligj", + "gdal 2.2.*", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "munch", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools", + "shapely", + "six" + ], + "license": "BSD 3-Clause", + "md5": "34686261cac41ca39cfe4ef06b1957d3", + "name": "fiona", + "sha256": "5aa2a12614dc9be970d23670d7b52ea41593d8b0d8715bd2f790224c94c70933", + "size": 544182, + "subdir": "linux-64", + "timestamp": 1511983969343, + "version": "1.7.10" + }, + "fiona-1.7.10-py36h48a52f0_0.conda": { + "build": "py36h48a52f0_0", + "build_number": 0, + "depends": [ + "click-plugins", + "cligj", + "gdal 2.2.*", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "munch", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "shapely", + "six" + ], + "license": "BSD 3-Clause", + "md5": "8a83f77b9dc04366e9c3fb5308234c04", + "name": "fiona", + "sha256": "3cfc94487808ebf65c8715726d4ac0f485504903a5698e2b8c5c397d8549668f", + "size": 551205, + "subdir": "linux-64", + "timestamp": 1511984077706, + "version": "1.7.10" + }, + "fiona-1.7.12-py27h3f37509_0.conda": { + "build": "py27h3f37509_0", + "build_number": 0, + "depends": [ + "click-plugins", + "cligj", + "enum34", + "gdal 2.2.*", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "shapely", + "six" + ], + "license": "BSD 3-Clause", + "md5": "ec4e165a10371fc68611d81b3493340c", + "name": "fiona", + "sha256": "fb62557d9abb75c8b1c70d8566ce487795485540e1711402e2705fab9ac95ad8", + "size": 559809, + "subdir": "linux-64", + "timestamp": 1530877096309, + "version": "1.7.12" + }, + "fiona-1.7.12-py36h3f37509_0.conda": { + "build": "py36h3f37509_0", + "build_number": 0, + "depends": [ + "click-plugins", + "cligj", + "gdal 2.2.*", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "shapely", + "six" + ], + "license": "BSD 3-Clause", + "md5": "0627dcd0221bdfb322e01e6f559ae2fe", + "name": "fiona", + "sha256": "378c6620010acc78836fd463e86e2e86d1855b110a17fb79e47b1749651032d7", + "size": 571591, + "subdir": "linux-64", + "timestamp": 1530876755800, + "version": "1.7.12" + }, + "fiona-1.7.12-py37h3f37509_0.conda": { + "build": "py37h3f37509_0", + "build_number": 0, + "depends": [ + "click-plugins", + "cligj", + "gdal 2.2.*", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "shapely", + "six" + ], + "license": "BSD 3-Clause", + "md5": "6d6560e76b638faee007cfde8fac2374", + "name": "fiona", + "sha256": "f516aaa129397f9c5b0787500c84325c6ee07db66555d4567ea8da33c1bae11b", + "size": 564169, + "subdir": "linux-64", + "timestamp": 1530877317964, + "version": "1.7.12" + }, + "fiona-1.8.11-py27h41e4f33_0.conda": { + "build": "py27h41e4f33_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "enum34", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "a7a5492a1b8eb42289859c8ad5a294ad", + "name": "fiona", + "sha256": "264b4d8cfe1b47527960d0ef325d51fe23e7672f22db0ee187d0c557f2376222", + "size": 711479, + "subdir": "linux-64", + "timestamp": 1573761086306, + "version": "1.8.11" + }, + "fiona-1.8.11-py36h41e4f33_0.conda": { + "build": "py36h41e4f33_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "29641071f1f9c8742fa6344b9a29bd30", + "name": "fiona", + "sha256": "12ea1eb3e7fe50df985845874de8b36083a2d0a6b5c03163db5a67aaf5e4bcba", + "size": 739541, + "subdir": "linux-64", + "timestamp": 1573761086333, + "version": "1.8.11" + }, + "fiona-1.8.11-py37h41e4f33_0.conda": { + "build": "py37h41e4f33_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "3607a7d179865fc91b29a50055a8aaee", + "name": "fiona", + "sha256": "8dacf8704777174118a3e6b4d797e317a0d520449cf8a4ed17844d6ec796d548", + "size": 739732, + "subdir": "linux-64", + "timestamp": 1573760987816, + "version": "1.8.11" + }, + "fiona-1.8.13.post1-py36hc820daa_0.conda": { + "build": "py36hc820daa_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "653bd9dd677dac8dd1d570432cc298b5", + "name": "fiona", + "sha256": "9a2e81986075586b3624c02da85deb122667821c375236f276dcd0ab5b17e218", + "size": 745466, + "subdir": "linux-64", + "timestamp": 1597154810002, + "version": "1.8.13.post1" + }, + "fiona-1.8.13.post1-py37hc820daa_0.conda": { + "build": "py37hc820daa_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "ac4594c867232d3b8a7b7085a283ad4b", + "name": "fiona", + "sha256": "2831fd0e0557c5b29ea0cb6299742f6b92c0343dbb426f0733a48f4889e4e227", + "size": 736981, + "subdir": "linux-64", + "timestamp": 1597154792721, + "version": "1.8.13.post1" + }, + "fiona-1.8.13.post1-py38hc820daa_0.conda": { + "build": "py38hc820daa_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "512e5f75cede1cb3f653bc3bc2bf7a8e", + "name": "fiona", + "sha256": "65278854b9c83bf071c6fd78be08b21f22e24e001b0745bbf9a18c7d942d660d", + "size": 769545, + "subdir": "linux-64", + "timestamp": 1597154790852, + "version": "1.8.13.post1" + }, + "fiona-1.8.22-py310h1128e8f_0.conda": { + "build": "py310h1128e8f_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=11.2.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=11.2.0", + "munch", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "18b631af77a724185987a722b104bdac", + "name": "fiona", + "sha256": "7578f341f2dff35984c360045da1e06dd301de55361ce0fb6fd1ae5062181432", + "size": 844465, + "subdir": "linux-64", + "timestamp": 1674252691083, + "version": "1.8.22" + }, + "fiona-1.8.22-py37h417a72b_0.conda": { + "build": "py37h417a72b_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "certifi", + "click >=4.0", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=11.2.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=11.2.0", + "munch", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "854cc82fc8d3bad83e3211ab4d4d03ec", + "name": "fiona", + "sha256": "46c82d91a465c3fafff24979e8c124948fd99c7837f245e0e7f5fcf0d18e304f", + "size": 822561, + "subdir": "linux-64", + "timestamp": 1674252911217, + "version": "1.8.22" + }, + "fiona-1.8.22-py38h417a72b_0.conda": { + "build": "py38h417a72b_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=11.2.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=11.2.0", + "munch", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c22dc0381e613580cadc42802cdb3b73", + "name": "fiona", + "sha256": "ebac06458eaeb14d5249df1fbb530ad388b4c3e99c94099ab847e04fdf48fda5", + "size": 867326, + "subdir": "linux-64", + "timestamp": 1674252581565, + "version": "1.8.22" + }, + "fiona-1.8.22-py39h417a72b_0.conda": { + "build": "py39h417a72b_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=11.2.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=11.2.0", + "munch", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "536936757720ca48eebc3f6b18bd6347", + "name": "fiona", + "sha256": "c8898c716c91ee11734446aa793801acfdb834121da032c1f279fe10f43ade34", + "size": 853858, + "subdir": "linux-64", + "timestamp": 1674252798488, + "version": "1.8.22" + }, + "fiona-1.8.4-py27hc38cc03_0.conda": { + "build": "py27hc38cc03_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "enum34", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "474ea26ef1041b58f592a3e8b0b11516", + "name": "fiona", + "sha256": "97e4fbcf107bfd120d297960a5e12a3110dfacd94fe39f9eb0a35f0050c3d7ea", + "size": 733493, + "subdir": "linux-64", + "timestamp": 1545417941359, + "version": "1.8.4" + }, + "fiona-1.8.4-py36hc38cc03_0.conda": { + "build": "py36hc38cc03_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "5cdc34de8b823a5868cdded1c22b5050", + "name": "fiona", + "sha256": "c691d139ecb435cc3cc1752489d7909ae9785b92858b79704825e553295a6ccd", + "size": 752249, + "subdir": "linux-64", + "timestamp": 1545417889425, + "version": "1.8.4" + }, + "fiona-1.8.4-py37hc38cc03_0.conda": { + "build": "py37hc38cc03_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "1efcc550864bfb6002ff99e51da75cff", + "name": "fiona", + "sha256": "940c6a4f9c80796c1dd6547e773d4bbc8769082b6b458e60a1dcdc1ceec19601", + "size": 746495, + "subdir": "linux-64", + "timestamp": 1545417913982, + "version": "1.8.4" + }, + "fiona-1.8.4-py38hc38cc03_0.conda": { + "build": "py38hc38cc03_0", + "build_number": 0, + "depends": [ + "attrs >=17", + "click >=4.0,<8", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "munch", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "shapely", + "six >=1.7" + ], + "license": "BSD-3-Clause", + "md5": "c92ddd47b7a1cd3ecc7d1d2ddbcbd92f", + "name": "fiona", + "sha256": "5383d3332ea358479fa64572429c19bcce566ead6f6fd1e72a80ebac7884aa35", + "size": 774302, + "subdir": "linux-64", + "timestamp": 1574413871152, + "version": "1.8.4" + }, + "fiona-1.9.1-py310h1128e8f_0.conda": { + "build": "py310h1128e8f_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "certifi", + "click >=8.0,<9.dev0", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=11.2.0", + "libgdal >=3.6.2,<3.7.0a0", + "libstdcxx-ng >=11.2.0", + "munch >=2.3.2", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools", + "shapely" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "228e3b181a68bef0af7af0160d50d291", + "name": "fiona", + "sha256": "ba92bca5866d3f7b6fd261ce65985e0fe32a724a84d142752e3190f818b1df77", + "size": 1150361, + "subdir": "linux-64", + "timestamp": 1678226138526, + "version": "1.9.1" + }, + "fiona-1.9.1-py311hba01205_0.conda": { + "build": "py311hba01205_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "certifi", + "click >=8.0,<9.dev0", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=11.2.0", + "libgdal >=3.6.2,<3.7.0a0", + "libstdcxx-ng >=11.2.0", + "munch >=2.3.2", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0", + "setuptools", + "shapely" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22ea96e0c7e83f9e30810720e7b52cf1", + "name": "fiona", + "sha256": "a3c957a6a2c8e6677ea96964c146a8f3af69c44e5234d7fe3f8098b5babb28dc", + "size": 1095198, + "subdir": "linux-64", + "timestamp": 1678243202198, + "version": "1.9.1" + }, + "fiona-1.9.1-py38h417a72b_0.conda": { + "build": "py38h417a72b_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "certifi", + "click >=8.0,<9.dev0", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=11.2.0", + "libgdal >=3.6.2,<3.7.0a0", + "libstdcxx-ng >=11.2.0", + "munch >=2.3.2", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "shapely" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f19662257bedebe245248cd85ddc6d81", + "name": "fiona", + "sha256": "2e56e27b0fbb00db37efa66de04ee781115f10e8f513c8623cefc3badb66a4df", + "size": 1175417, + "subdir": "linux-64", + "timestamp": 1678226422936, + "version": "1.9.1" + }, + "fiona-1.9.1-py39h417a72b_0.conda": { + "build": "py39h417a72b_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "certifi", + "click >=8.0,<9.dev0", + "click-plugins >=1.0", + "cligj >=0.5", + "gdal", + "libgcc-ng >=11.2.0", + "libgdal >=3.6.2,<3.7.0a0", + "libstdcxx-ng >=11.2.0", + "munch >=2.3.2", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "shapely" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "248a1e2898bde4294d2ffd4dcd2f5048", + "name": "fiona", + "sha256": "bb120d2db0f46767946346a7e3081a410384b422925504378aa18e3e6f1d0ee6", + "size": 1158335, + "subdir": "linux-64", + "timestamp": 1678226278439, + "version": "1.9.1" + }, + "flake8-3.4.1-py27hbe79fde_0.conda": { + "build": "py27hbe79fde_0", + "build_number": 0, + "depends": [ + "configparser", + "enum34", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.4.0", + "pyflakes >=1.5.0,<1.6.0", + "python >=2.7,<2.8.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e98332eb7fe958ca96b99e181595b13", + "name": "flake8", + "sha256": "ecf8ff286c87a22371a909192f0f1d29f4cec77c7d2096582aab7d0d9fe1b0a9", + "size": 157721, + "subdir": "linux-64", + "timestamp": 1505743148902, + "version": "3.4.1" + }, + "flake8-3.4.1-py35hbd4ebb8_0.conda": { + "build": "py35hbd4ebb8_0", + "build_number": 0, + "depends": [ + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.4.0", + "pyflakes >=1.5.0,<1.6.0", + "python >=3.5,<3.6.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "07e7bfb424c9dcecdd682d4d9cf9dc56", + "name": "flake8", + "sha256": "df29a4e84735d202b67ce0bbd94c7f32fa41cee9fc90b8afab0d0b6335088e21", + "size": 159244, + "subdir": "linux-64", + "timestamp": 1505743164170, + "version": "3.4.1" + }, + "flake8-3.4.1-py36h541458f_0.conda": { + "build": "py36h541458f_0", + "build_number": 0, + "depends": [ + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.4.0", + "pyflakes >=1.5.0,<1.6.0", + "python >=3.6,<3.7.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01c668917fd6148610a3586e4c7b7b26", + "name": "flake8", + "sha256": "dcee1673b8c076fe1055f2c162c205babb467103a3612cc515759b5723275115", + "size": 160097, + "subdir": "linux-64", + "timestamp": 1505743179645, + "version": "3.4.1" + }, + "flake8-3.5.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "configparser", + "enum34", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.4.0", + "pyflakes >=1.5.0,<1.7.0", + "python >=2.7,<2.8.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "274fcde9549b5acea56468ecb4f4bf93", + "name": "flake8", + "sha256": "99c3be2fb777c4f3288597d963c11e9774b533eb1cd9d78181f7df5f3a9dfd25", + "size": 162857, + "subdir": "linux-64", + "timestamp": 1516632822696, + "version": "3.5.0" + }, + "flake8-3.5.0-py27h544e95e_0.conda": { + "build": "py27h544e95e_0", + "build_number": 0, + "depends": [ + "configparser", + "enum34", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.4.0", + "pyflakes >=1.5.0,<1.6.0", + "python >=2.7,<2.8.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56a33b2533a575928981a3810a0ccaf3", + "name": "flake8", + "sha256": "41b358ada4f2b3962c3b5106cd0c0b4f3c7f0b608847759aeb985da92e10c829", + "size": 164018, + "subdir": "linux-64", + "timestamp": 1511296351780, + "version": "3.5.0" + }, + "flake8-3.5.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.4.0", + "pyflakes >=1.5.0,<1.7.0", + "python >=3.5,<3.6.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7cfd1cd565f262ca312e3e09d0a3b2ff", + "name": "flake8", + "sha256": "1060c2c62eeaef71cd1ae28a99e851bea0d5efa1b7581d82acab07fd01ecb4c1", + "size": 165799, + "subdir": "linux-64", + "timestamp": 1516632825627, + "version": "3.5.0" + }, + "flake8-3.5.0-py35h92eb085_0.conda": { + "build": "py35h92eb085_0", + "build_number": 0, + "depends": [ + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.4.0", + "pyflakes >=1.5.0,<1.6.0", + "python >=3.5,<3.6.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c915207dcdab9a09e399659692d9e37", + "name": "flake8", + "sha256": "4280f89966090369d7ed2f0d83839b5a801a8f5a3712aa243894eca87b30586b", + "size": 165839, + "subdir": "linux-64", + "timestamp": 1511296358882, + "version": "3.5.0" + }, + "flake8-3.5.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.4.0", + "pyflakes >=1.5.0,<1.7.0", + "python >=3.6,<3.7.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "750e25e37a396b814e1549e87f860f69", + "name": "flake8", + "sha256": "58f5749e017f1fc8a014b5c464bb8a22767235d8f36897beafd742bbf404c5f6", + "size": 164891, + "subdir": "linux-64", + "timestamp": 1516632833568, + "version": "3.5.0" + }, + "flake8-3.5.0-py36hda1b316_0.conda": { + "build": "py36hda1b316_0", + "build_number": 0, + "depends": [ + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.4.0", + "pyflakes >=1.5.0,<1.6.0", + "python >=3.6,<3.7.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85de95b8d154691c599527115c7d3c55", + "name": "flake8", + "sha256": "223156e275bf89bd668e3fd439350dcbecff83d3e887140e3106d68978608a7a", + "size": 163378, + "subdir": "linux-64", + "timestamp": 1511296362034, + "version": "3.5.0" + }, + "flake8-3.5.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.0.0,<2.5.0", + "pyflakes >=1.5.0,<1.7.0", + "python >=3.7,<3.8.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c74c51bc2dcd3ed9fb768429f674ca04", + "name": "flake8", + "sha256": "784f1430d812899cd35996a7b374fc16c46b223b6cbac22f29067064a1eff973", + "size": 163610, + "subdir": "linux-64", + "timestamp": 1530812701418, + "version": "3.5.0" + }, + "flake8-3.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser", + "enum34", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.4.0,<2.5.0", + "pyflakes >=2.0.0,<2.1.0", + "python >=2.7,<2.8.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cece50c8f9b6330401be4ccc783f81f8", + "name": "flake8", + "sha256": "f5cf4c1cf4a76309c58728938262dd5b11ada062586ec11d7331f5ea90abef5d", + "size": 166810, + "subdir": "linux-64", + "timestamp": 1541178562579, + "version": "3.6.0" + }, + "flake8-3.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.4.0,<2.5.0", + "pyflakes >=2.0.0,<2.1.0", + "python >=3.6,<3.7.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "538bb78f472dcc2b08cc6294f2a1cf83", + "name": "flake8", + "sha256": "e47504f2a310cbeab318fb88f0082527c76bd2810583e77fbe02f6f1a1c833c1", + "size": 165956, + "subdir": "linux-64", + "timestamp": 1541178592171, + "version": "3.6.0" + }, + "flake8-3.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.4.0,<2.5.0", + "pyflakes >=2.0.0,<2.1.0", + "python >=3.7,<3.8.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8552cb1ba99bd6720e81a53f916ee374", + "name": "flake8", + "sha256": "96b7943d1acea568cc6228511ceca88c67becb1b5a44cf00499d84586f7f3f14", + "size": 167899, + "subdir": "linux-64", + "timestamp": 1541178554748, + "version": "3.6.0" + }, + "flake8-3.7.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser", + "entrypoints >=0.3.0,<0.4.0", + "enum34", + "functools32", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=2.7,<2.8.0a0", + "setuptools >=30.0.0", + "typing" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c15c95baf1da7fed52db67a8969d34c6", + "name": "flake8", + "sha256": "4c0953354e08c1be888afe17e64a90ef70934ae2e5a07efdc63ec9dbc6dff982", + "size": 171914, + "subdir": "linux-64", + "timestamp": 1552360706852, + "version": "3.7.7" + }, + "flake8-3.7.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints >=0.3.0,<0.4.0", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=3.6,<3.7.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bf33febfb1ee9beac0ca221c80003470", + "name": "flake8", + "sha256": "eb3ff1c42e90e2400f34a363136bf723b8ae5bac484a0d21f666cd150c5d08e3", + "size": 173852, + "subdir": "linux-64", + "timestamp": 1552360737575, + "version": "3.7.7" + }, + "flake8-3.7.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints >=0.3.0,<0.4.0", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=3.7,<3.8.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1c3dc24397e4f599d721fa4cd7dc5fc", + "name": "flake8", + "sha256": "c294bf94194aa0f68219edea7cbb75d5ad80d70b2fd850d4ebc913ac2206fb68", + "size": 174062, + "subdir": "linux-64", + "timestamp": 1552360683501, + "version": "3.7.7" + }, + "flake8-3.7.8-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "configparser", + "entrypoints >=0.3.0,<0.4.0", + "enum34", + "functools32", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=2.7,<2.8.0a0", + "setuptools >=30.0.0", + "typing" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "736d0efe6ae8c991286eee68fbf751a3", + "name": "flake8", + "sha256": "9f6750f41c49617f94bf51ec7af8eb6362341ef2eac61c5ff4404b624351adf6", + "size": 176029, + "subdir": "linux-64", + "timestamp": 1569334746687, + "version": "3.7.8" + }, + "flake8-3.7.8-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "entrypoints >=0.3.0,<0.4.0", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=3.6,<3.7.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "99674dc0dd2de25254c7c6c1f9050199", + "name": "flake8", + "sha256": "355891dc51627a3f941d73dd8343ea079b148be58484f923b354e3a9d68ed466", + "size": 176678, + "subdir": "linux-64", + "timestamp": 1569334770746, + "version": "3.7.8" + }, + "flake8-3.7.8-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "entrypoints >=0.3.0,<0.4.0", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=3.7,<3.8.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2fbc23cd2a37468eb577a867fdc36564", + "name": "flake8", + "sha256": "1378139f1f9720b06e7e9be28665115e168e59de7c100ccd7c0a940ef2f861ee", + "size": 176685, + "subdir": "linux-64", + "timestamp": 1569334748586, + "version": "3.7.8" + }, + "flake8-3.7.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser", + "entrypoints >=0.3.0,<0.4.0", + "enum34", + "functools32", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=2.7,<2.8.0a0", + "setuptools >=30.0.0", + "typing" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b32b0ca6ecb5dca14d82b7cf5da8a829", + "name": "flake8", + "sha256": "912eaa4a7842b5ed78845bcde62a53142b374227f90ff29bd327d3117924a1c2", + "size": 176245, + "subdir": "linux-64", + "timestamp": 1573233032570, + "version": "3.7.9" + }, + "flake8-3.7.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints >=0.3.0,<0.4.0", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=3.6,<3.7.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ffc2c527966c9c74f999cd49825c41d8", + "name": "flake8", + "sha256": "413a86bf745e2059c4c5c9e2cc8c67b0cc63e8ad58c76e9aaab7239a5b226044", + "size": 176512, + "subdir": "linux-64", + "timestamp": 1573233107653, + "version": "3.7.9" + }, + "flake8-3.7.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints >=0.3.0,<0.4.0", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=3.7,<3.8.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6415b63ea04bc48c622ba38d46b69624", + "name": "flake8", + "sha256": "2251607f3fce353663c372d41bfa4b102622ad086230c7d635645d9f3cc7e546", + "size": 176830, + "subdir": "linux-64", + "timestamp": 1573232994106, + "version": "3.7.9" + }, + "flake8-3.7.9-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints >=0.3.0,<0.4.0", + "mccabe >=0.6.0,<0.7.0", + "pycodestyle >=2.5.0,<2.6.0", + "pyflakes >=2.1.0,<2.2.0", + "python >=3.8,<3.9.0a0", + "setuptools >=30.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "190eae97e9e98c7308bcdf48ddfea9e5", + "name": "flake8", + "sha256": "69068aa71cdc1692398bf8bb06d4b57826d17e1c1791d5e158bacb77e060ab9b", + "size": 171981, + "subdir": "linux-64", + "timestamp": 1574251330548, + "version": "3.7.9" + }, + "flake8-6.0.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "mccabe >=0.7.0,<0.8.0", + "pycodestyle >=2.10.0,<2.11.0", + "pyflakes >=3.0.0,<3.1.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "830624147bf39901f0aba4a71a8ce4f3", + "name": "flake8", + "sha256": "2ba8afa9dcda5fe201572da108cf41b0e63551a4e42456358ac3000e343bc047", + "size": 159968, + "subdir": "linux-64", + "timestamp": 1674581847639, + "version": "6.0.0" + }, + "flake8-6.0.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "mccabe >=0.7.0,<0.8.0", + "pycodestyle >=2.10.0,<2.11.0", + "pyflakes >=3.0.0,<3.1.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9cb531128028e1787e4b15fb0db507bc", + "name": "flake8", + "sha256": "3eef09aed9b4f3b82fbae227ef091d20525539e509931339ab487ed5202b0bd1", + "size": 173399, + "subdir": "linux-64", + "timestamp": 1677709259514, + "version": "6.0.0" + }, + "flake8-6.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "mccabe >=0.7.0,<0.8.0", + "pycodestyle >=2.10.0,<2.11.0", + "pyflakes >=3.0.0,<3.1.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de8735b053645ac1c44adf6400743ef1", + "name": "flake8", + "sha256": "94a4b704a57c651aa24b7fdfadc588863f34c1db851ab14c4678f786e952809e", + "size": 158709, + "subdir": "linux-64", + "timestamp": 1674581873099, + "version": "6.0.0" + }, + "flake8-6.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "mccabe >=0.7.0,<0.8.0", + "pycodestyle >=2.10.0,<2.11.0", + "pyflakes >=3.0.0,<3.1.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1258503d49f2b8716254a8521304e33d", + "name": "flake8", + "sha256": "a8fa0bc758eb85312168b4d14be51422987387f38e49c4a8ba70865c7b62608b", + "size": 158720, + "subdir": "linux-64", + "timestamp": 1674581821922, + "version": "6.0.0" + }, + "flake8-import-order-0.12-py27h9b42c04_0.conda": { + "build": "py27h9b42c04_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "dfe907513037c21ea64ac263617c5bc3", + "name": "flake8-import-order", + "sha256": "3924d63f09cb4d0cef227f04fbf55e4764758136d0f4b87797c75e64a2df6f00", + "size": 23440, + "subdir": "linux-64", + "timestamp": 1505743193549, + "version": "0.12" + }, + "flake8-import-order-0.12-py35hfe8de38_0.conda": { + "build": "py35hfe8de38_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "b45683b9f9b1440395b5debfaf4a4a83", + "name": "flake8-import-order", + "sha256": "84ad672c11841c1df6e8882d9bdc5368c58c2d793bd66510a6e8f3ce745bf790", + "size": 23892, + "subdir": "linux-64", + "timestamp": 1505743205983, + "version": "0.12" + }, + "flake8-import-order-0.12-py36h03aae4d_0.conda": { + "build": "py36h03aae4d_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "160052a774b2c97cb264766f994c2fd2", + "name": "flake8-import-order", + "sha256": "81f857f647f6bc70ff489da1641bab837f7742fef0b140a198b08ccd4976b4f7", + "size": 23706, + "subdir": "linux-64", + "timestamp": 1505743218319, + "version": "0.12" + }, + "flake8-import-order-0.16-py27h9d8f0cb_0.conda": { + "build": "py27h9d8f0cb_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "d75419a31518c5f111a33997fc71d8e4", + "name": "flake8-import-order", + "sha256": "ba6734d9915677f836676d0f8cd9ce8eb6b379abd3eefbd03d0bd8098ceae87e", + "size": 26287, + "subdir": "linux-64", + "timestamp": 1512035327308, + "version": "0.16" + }, + "flake8-import-order-0.16-py35h68db374_0.conda": { + "build": "py35h68db374_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "b10d2fe3a9666dfad2a84792343d2eff", + "name": "flake8-import-order", + "sha256": "32924a0530824577f93e7579ef612711170e51737d83131bf1c753150bb76695", + "size": 26849, + "subdir": "linux-64", + "timestamp": 1512035292559, + "version": "0.16" + }, + "flake8-import-order-0.16-py36hb126a73_0.conda": { + "build": "py36hb126a73_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "5c78ea6543602fb1fc632844b01b8434", + "name": "flake8-import-order", + "sha256": "8dc13a4725804834bb472aea7721951becfa72b39c1de05a20e5c20ed2984da8", + "size": 26633, + "subdir": "linux-64", + "timestamp": 1512035337798, + "version": "0.16" + }, + "flake8-import-order-0.17-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "flake8", + "pycodestyle", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "f131286e31b7aa3503ea60178b83e826", + "name": "flake8-import-order", + "sha256": "046b9dbdbbea83e1789370775d911d360b2074bbac4c0930dbaae49046ecd9ce", + "size": 26883, + "subdir": "linux-64", + "timestamp": 1519241864595, + "version": "0.17" + }, + "flake8-import-order-0.17-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "e28bfb538d39d2e0f093f0350f4bcb76", + "name": "flake8-import-order", + "sha256": "f0422380dda99ca3b5f7b249cf545f1aeddabeeefc8a94cd2af439b440abd475", + "size": 27136, + "subdir": "linux-64", + "timestamp": 1519241919854, + "version": "0.17" + }, + "flake8-import-order-0.17-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "791794edb2ee5fb0ce6b6ee8e1e41e3c", + "name": "flake8-import-order", + "sha256": "a6e2762abd4f3c1937626af95b903ee62a9c6ac3ef05e31e3e98662db5509d65", + "size": 27053, + "subdir": "linux-64", + "timestamp": 1519241787985, + "version": "0.17" + }, + "flake8-import-order-0.17.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "flake8", + "pycodestyle", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "0757c64310be0e04d7ba4fd6c81c646d", + "name": "flake8-import-order", + "sha256": "83af6d4061e485c2e9e82527aa4f8a9ce8e4a7caae56fe9be411dff1e3a07fe6", + "size": 27005, + "subdir": "linux-64", + "timestamp": 1522786496420, + "version": "0.17.1" + }, + "flake8-import-order-0.17.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "7a788b6ca3bb69e82db09fd96b4073eb", + "name": "flake8-import-order", + "sha256": "b136a14bdea2a5b4c3c4f9108398391c9a15b9236ade3895f66074af4f26d166", + "size": 27330, + "subdir": "linux-64", + "timestamp": 1522786507492, + "version": "0.17.1" + }, + "flake8-import-order-0.17.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "ecdb1fce38a3a353b272f49c3a61f4e6", + "name": "flake8-import-order", + "sha256": "6208059b0823a0914a8e3a5639bad16cf4bbe0c5806003fec6d26a69ff3b3842", + "size": 27121, + "subdir": "linux-64", + "timestamp": 1522786309136, + "version": "0.17.1" + }, + "flake8-import-order-0.17.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "5d87de6e275feb5205fe777365462a10", + "name": "flake8-import-order", + "sha256": "e5c34aa0de2c3f558c90a835639108d0d31560367363298903fccbdee336b6da", + "size": 26908, + "subdir": "linux-64", + "timestamp": 1530877422615, + "version": "0.17.1" + }, + "flake8-import-order-0.18-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "flake8", + "pycodestyle", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "d9df6256c713b429e8678b462cc3fc6e", + "name": "flake8-import-order", + "sha256": "a30f2eaeb054b335049ad46c5cc9d41b40442156c1dfce26af3d19b77a5fa26f", + "size": 26975, + "subdir": "linux-64", + "timestamp": 1535425792413, + "version": "0.18" + }, + "flake8-import-order-0.18-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "ff07a502ca966b454d4fc6e15b34f446", + "name": "flake8-import-order", + "sha256": "b4da8ee05a236e81caf2f901041584526f5bdbe435b21c96cc021ca24f3a2442", + "size": 27560, + "subdir": "linux-64", + "timestamp": 1535425816656, + "version": "0.18" + }, + "flake8-import-order-0.18-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "810a66b4cec071e87ae31c1065cacd8d", + "name": "flake8-import-order", + "sha256": "83a1064839aee61131ef25791505f9f390d085d4294f474fdacdfeaebc4f1e9b", + "size": 27218, + "subdir": "linux-64", + "timestamp": 1535425568107, + "version": "0.18" + }, + "flake8-import-order-0.18-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "867f6c8dd3ac0c068e29fe37760120df", + "name": "flake8-import-order", + "sha256": "65670f021f7748b622888d03955929758d521380f0365d18eb80b26b91b8935b", + "size": 27161, + "subdir": "linux-64", + "timestamp": 1535425816585, + "version": "0.18" + }, + "flake8-import-order-0.18.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "flake8", + "pycodestyle", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "db3b80194f93d2130ddd28d816977239", + "name": "flake8-import-order", + "sha256": "a3aa4f007655cb0575a7ef0722d4ac10348274b13c637d4dfc69c498cac032ca", + "size": 31875, + "subdir": "linux-64", + "timestamp": 1552377063631, + "version": "0.18.1" + }, + "flake8-import-order-0.18.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "397b9e3e88d065e27db8daee0170985b", + "name": "flake8-import-order", + "sha256": "26f2ed30d64890cd5137b03f56ef3fa4863a12cd5d3b0e86247c0e86dd326818", + "size": 27419, + "subdir": "linux-64", + "timestamp": 1640790063356, + "version": "0.18.1" + }, + "flake8-import-order-0.18.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "910d90baaf91ae85839ad2c14b83ff55", + "name": "flake8-import-order", + "sha256": "97043fd9e2b438041e413403ff537830bf1265088e720ff69fd1f3c33d3e4da4", + "size": 32370, + "subdir": "linux-64", + "timestamp": 1676852341629, + "version": "0.18.1" + }, + "flake8-import-order-0.18.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "1a986580f4f8ed7646f63aaf783412b5", + "name": "flake8-import-order", + "sha256": "8eaa4f947c13dfbd6f65cd895bf3bd9e6161ddc17af4eae5877c0d2abf21c1b7", + "size": 32105, + "subdir": "linux-64", + "timestamp": 1552377099091, + "version": "0.18.1" + }, + "flake8-import-order-0.18.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "dad9ba29005663c4a1a6600984307cee", + "name": "flake8-import-order", + "sha256": "b818f717f3fcf5eccdc0ec4ed59eef39ecf287472508cbffc73550ab232dea24", + "size": 30086, + "subdir": "linux-64", + "timestamp": 1614172018542, + "version": "0.18.1" + }, + "flake8-import-order-0.18.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "218b283ea56621958a0400c4cd4ab9c0", + "name": "flake8-import-order", + "sha256": "4d2b9f300a03b9db7302eca57a6f6357a87d9280fb68f3bb65ba2501fa6b40cc", + "size": 32139, + "subdir": "linux-64", + "timestamp": 1552377060800, + "version": "0.18.1" + }, + "flake8-import-order-0.18.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "8aebaf4ac1695c71695455b2da6f3c39", + "name": "flake8-import-order", + "sha256": "38316745cdacaa6e0ebf261038804a2f75da53d6fbc398c125153b25f2116cda", + "size": 30180, + "subdir": "linux-64", + "timestamp": 1614172012116, + "version": "0.18.1" + }, + "flake8-import-order-0.18.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "6ba66664c16764514b8c03eecba2b90b", + "name": "flake8-import-order", + "sha256": "6a47ad93c5ab7f91a79c7f3d8ed0c79a9dc1f361ede26551b3cd750483598880", + "size": 27955, + "subdir": "linux-64", + "timestamp": 1574413897779, + "version": "0.18.1" + }, + "flake8-import-order-0.18.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "56611e582b05b915ee5bde6035e91ed7", + "name": "flake8-import-order", + "sha256": "44cc8e269338b84aa92a0b9f1ea14a4fcebf74397b92c6cb0e59caf69d2680cc", + "size": 30323, + "subdir": "linux-64", + "timestamp": 1614171045708, + "version": "0.18.1" + }, + "flake8-import-order-0.18.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "252f380fd21b2a88a9a74c99a4d464fd", + "name": "flake8-import-order", + "sha256": "0376f7b68fae4e9b20cab5013d97339235beeaccda8f0b50275abd4d4385d19c", + "size": 29590, + "subdir": "linux-64", + "timestamp": 1614172016193, + "version": "0.18.1" + }, + "flake8-import-order-0.18.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "bb1b5139fe26a248cfa1fd323fdc5a4b", + "name": "flake8-import-order", + "sha256": "3bac2f2b7e120cf183cefe5bdd96d35660bd9ebd8c6596838e7c41e9f85bac59", + "size": 28892, + "subdir": "linux-64", + "timestamp": 1678214206977, + "version": "0.18.2" + }, + "flake8-import-order-0.18.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "1951bff03208a8f08377d238801682a5", + "name": "flake8-import-order", + "sha256": "215213dbae945959b6a8f19170df5393c88ee3f98eb7ebf203be872ff73091fc", + "size": 32460, + "subdir": "linux-64", + "timestamp": 1678243021410, + "version": "0.18.2" + }, + "flake8-import-order-0.18.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "f9db8d444a7dcaf2ac7f58b0a7fb5704", + "name": "flake8-import-order", + "sha256": "96de9ee85cf70062ce76f58c957d07625de5db140d83f64f9a6ecd472af6a81e", + "size": 29389, + "subdir": "linux-64", + "timestamp": 1678214258556, + "version": "0.18.2" + }, + "flake8-import-order-0.18.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "pycodestyle", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "dbd4d03d4426bd666a51d839caf79ff3", + "name": "flake8-import-order", + "sha256": "8bfc64d8091f33838a5a691f1ce7265997ead2cd9eac2fb2a5c88626718ebb45", + "size": 28645, + "subdir": "linux-64", + "timestamp": 1678214232792, + "version": "0.18.2" + }, + "flake8-polyfill-1.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d538d8e97b089de968bd779d45cf5bf5", + "name": "flake8-polyfill", + "sha256": "39831943b440d08427206b734ee8ec13e0737530a4b1c4f218e7d14c47cb37c3", + "size": 10715, + "subdir": "linux-64", + "timestamp": 1524096410206, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "54f7b905ee4f237034f2384cbf46fac4", + "name": "flake8-polyfill", + "sha256": "71a01a2a76c33259e986d92de6a838c1aaece2a6dc5b8fc1bd7791f2c6466967", + "size": 10862, + "subdir": "linux-64", + "timestamp": 1642515378291, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0ddc21d73c44f3ac71450a12d8c6df63", + "name": "flake8-polyfill", + "sha256": "3812cb1c0ff656ec7f964a29f08e78a798062b79ee65f0e94fcfad8e6df89f28", + "size": 12596, + "subdir": "linux-64", + "timestamp": 1676844036142, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4bd383f07139122d9689091452881969", + "name": "flake8-polyfill", + "sha256": "8bb28a24ec42e0587fe8bfe402ddd87b8ba52153877ba19710ad047e2ea25bc7", + "size": 10892, + "subdir": "linux-64", + "timestamp": 1524096417943, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11ff61933fbf2e35e5dc0af7a57b3adc", + "name": "flake8-polyfill", + "sha256": "9e67fe3f7beb0f4f5cbe6e6c979938e6d1609b5440eb96694bcab85326618a9e", + "size": 10780, + "subdir": "linux-64", + "timestamp": 1524096607968, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b34dcc312cee7ca29d1d12f92f41f279", + "name": "flake8-polyfill", + "sha256": "685bca9b99822ab942ea90eeabfa48544253cd353f77a3841b4f1ac1904e3f1e", + "size": 11833, + "subdir": "linux-64", + "timestamp": 1632891244200, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "edc1c6b6d41d680c69bdfb75e1e20af4", + "name": "flake8-polyfill", + "sha256": "a518eceb17016fed2a39b6dc048e196ed03bf65cd44cbe034dedd16a58f5cfb1", + "size": 10610, + "subdir": "linux-64", + "timestamp": 1530877451641, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "431e3d8d8f110b9cc1392df7718c5984", + "name": "flake8-polyfill", + "sha256": "686b406166290c95c5a4d54b710ea62e25390d50a52017307e6cac6c4f909b5c", + "size": 11857, + "subdir": "linux-64", + "timestamp": 1632890779792, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b5a9774b3f7ddf474d5f0ba02c403cc", + "name": "flake8-polyfill", + "sha256": "33ee27b7cd5b6517cae2542d06bc594e0e641315ef0132905d235cbf852193b9", + "size": 11044, + "subdir": "linux-64", + "timestamp": 1574413918703, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbb8dc81ed30fa5693c5af3046081330", + "name": "flake8-polyfill", + "sha256": "4fbe9fe6cb24ac4395cbe90a3b6dcb11a7842232c246e5dc0471128ab49068c6", + "size": 11838, + "subdir": "linux-64", + "timestamp": 1632890786003, + "version": "1.0.2" + }, + "flake8-polyfill-1.0.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a70303ffe2bf5af7a912b8a630fbfb4c", + "name": "flake8-polyfill", + "sha256": "c9f76630aad0613a8be7742a3c2877c440ccfac17a5fee65b401613e1854be6a", + "size": 11825, + "subdir": "linux-64", + "timestamp": 1632891210598, + "version": "1.0.2" + }, + "flaky-3.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bffec91fca69ae511cd6c2a85dbc8e95", + "name": "flaky", + "sha256": "e652156000ff222dfb2d48e4c4fcc3aadd94c93174106a6fdd77343fb28f68a0", + "size": 32974, + "subdir": "linux-64", + "timestamp": 1530727646665, + "version": "3.4.0" + }, + "flaky-3.4.0-py27h8a62d16_0.conda": { + "build": "py27h8a62d16_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "aba340ccdcf40fc6eb54620a5c709b30", + "name": "flaky", + "sha256": "2f7772d700e344325cfbf78f8cf4f6c9e9b7b7a34229c582ad3cf4d107e7fc80", + "size": 33559, + "subdir": "linux-64", + "timestamp": 1510981411135, + "version": "3.4.0" + }, + "flaky-3.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b5ec79bad26a60e00c7894c7414da665", + "name": "flaky", + "sha256": "baadd9f4faab396c3dc81ddec89534326512ea0c9a0e6bfd383404436f17e018", + "size": 33507, + "subdir": "linux-64", + "timestamp": 1534347475433, + "version": "3.4.0" + }, + "flaky-3.4.0-py35hdbc305c_0.conda": { + "build": "py35hdbc305c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "741a6127af93d09e348a2b0e833fd629", + "name": "flaky", + "sha256": "1a6762d85c4d821ad063d142a060359cca22bc12e3accef3d8681a06b02c1f21", + "size": 33667, + "subdir": "linux-64", + "timestamp": 1510981423604, + "version": "3.4.0" + }, + "flaky-3.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "945538491894b016e2b53bdbf13d485a", + "name": "flaky", + "sha256": "bee6f953232bb2f5fd98618f6ac08bdfbd1f0c7613b3fb2d25b7a64ff1f09554", + "size": 33233, + "subdir": "linux-64", + "timestamp": 1530727686767, + "version": "3.4.0" + }, + "flaky-3.4.0-py36h0c56b27_0.conda": { + "build": "py36h0c56b27_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "343d83de1ea5e9dce245e2d649ba8c46", + "name": "flaky", + "sha256": "4450a5391edda35b3a60673d6f6e720faa4154da2fceaf6bb1b9e0e8aff8eaa6", + "size": 33784, + "subdir": "linux-64", + "timestamp": 1510981419327, + "version": "3.4.0" + }, + "flaky-3.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3194d9bce0a89ea4181ce7a4a54c13ba", + "name": "flaky", + "sha256": "85900e5892f389b50b62d922a452d1e5d663603575cc8a4b7c73e6e5ef9d6e5b", + "size": 33235, + "subdir": "linux-64", + "timestamp": 1530727666342, + "version": "3.4.0" + }, + "flaky-3.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bfe89ee68a7fc2c16abe7d9c3fa21615", + "name": "flaky", + "sha256": "6419dd6a4619de046c255d8a89d4ddda711fb6e77dee5e3a55deb5c93220a7e4", + "size": 34932, + "subdir": "linux-64", + "timestamp": 1547228814219, + "version": "3.5.0" + }, + "flaky-3.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "32b019060290b3defc5fa090ff91a1a4", + "name": "flaky", + "sha256": "c709eede56cc28a6058496e6da8e0b6922f7c36a7b1672cea5121f3d34f53fcd", + "size": 34872, + "subdir": "linux-64", + "timestamp": 1547228862778, + "version": "3.5.0" + }, + "flaky-3.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0fb4229bf20f4b49529c07ce384d36ea", + "name": "flaky", + "sha256": "a5625d34c0d604a6e117b5360bd18c76d3022c913f8f004014771bd86d19142f", + "size": 35102, + "subdir": "linux-64", + "timestamp": 1547228841022, + "version": "3.5.0" + }, + "flaky-3.5.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3a11f77a9f66b1caa53da71e9108a773", + "name": "flaky", + "sha256": "5f44003dd30b4cc5424579129d5aeff22098de149f701e1ce3f9d4ff62535cf6", + "size": 33066, + "subdir": "linux-64", + "timestamp": 1547749293148, + "version": "3.5.3" + }, + "flaky-3.5.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0e48cbb79c263fdf3a439a3eb1c21632", + "name": "flaky", + "sha256": "30ef978863c5e56855f716419253c138f7eeb6b4f19b0b0974314c90b9ab611e", + "size": 33293, + "subdir": "linux-64", + "timestamp": 1547749339180, + "version": "3.5.3" + }, + "flaky-3.5.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a38bf7d173223e852abf98c39428005c", + "name": "flaky", + "sha256": "88c78a2fffb7a8d63e9b8a1e89bd2e83dcaa306b3c1cbc977be706b959fe7a10", + "size": 33328, + "subdir": "linux-64", + "timestamp": 1547749326097, + "version": "3.5.3" + }, + "flask-0.12.2-py27h6d5c1cd_0.conda": { + "build": "py27h6d5c1cd_0", + "build_number": 0, + "depends": [ + "click >=2.0", + "itsdangerous >=0.21", + "jinja2 >=2.4", + "python >=2.7,<2.8.0a0", + "werkzeug >=0.7,<1.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f5d0d7df028a99146062a6c7d4b9e0a9", + "name": "flask", + "sha256": "8bf52227dafb2be2cfdd26e90efe544f3c6b803be817fbd4f8bc2d72f829a7a9", + "size": 108950, + "subdir": "linux-64", + "timestamp": 1505740403221, + "version": "0.12.2" + }, + "flask-0.12.2-py35h679e90e_0.conda": { + "build": "py35h679e90e_0", + "build_number": 0, + "depends": [ + "click >=2.0", + "itsdangerous >=0.21", + "jinja2 >=2.4", + "python >=3.5,<3.6.0a0", + "werkzeug >=0.7,<1.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9465509cf5b7b6262323edef7e845b7d", + "name": "flask", + "sha256": "94b81f0fcba6029733db7a0c1f1e0186bd5330580e001a27d45a6e9bdc3fae63", + "size": 110492, + "subdir": "linux-64", + "timestamp": 1505740417217, + "version": "0.12.2" + }, + "flask-0.12.2-py36hb24657c_0.conda": { + "build": "py36hb24657c_0", + "build_number": 0, + "depends": [ + "click >=2.0", + "itsdangerous >=0.21", + "jinja2 >=2.4", + "python >=3.6,<3.7.0a0", + "werkzeug >=0.7,<1.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "da80359c6a9f41ccb3f7ae66232f89c6", + "name": "flask", + "sha256": "5ff1174074cf81cfed390f4dcda5ca55b5495f13f18faad9a0475e33bfbf05f5", + "size": 109639, + "subdir": "linux-64", + "timestamp": 1505740431814, + "version": "0.12.2" + }, + "flask-1.0.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "click >=5.1", + "itsdangerous >=0.24", + "jinja2 >=2.10,<3.0", + "python >=2.7,<2.8.0a0", + "werkzeug >=0.15,<2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2af21c49d696e5d9bee32576b2f8e2d1", + "name": "flask", + "sha256": "65e34befbc1e7274c8b7ca173c6c374e720adfe213d0ea47a20ac42103559d42", + "size": 123686, + "subdir": "linux-64", + "timestamp": 1525817220724, + "version": "1.0.2" + }, + "flask-1.0.2-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "click >=5.1", + "itsdangerous >=0.24", + "jinja2 >=2.10,<3.0", + "python >=3.5,<3.6.0a0", + "werkzeug >=0.15,<2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c396b33f84ef375bb8e31899e1997c84", + "name": "flask", + "sha256": "6113188a3abe03a9216d11fae54ca5ccbcf646cade0245af2f27fcb14c9e5c48", + "size": 123344, + "subdir": "linux-64", + "timestamp": 1525817046568, + "version": "1.0.2" + }, + "flask-1.0.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "click >=5.1", + "itsdangerous >=0.24", + "jinja2 >=2.10,<3.0", + "python >=3.6,<3.7.0a0", + "werkzeug >=0.15,<2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "29b291a9fe796b34c6f61fcf6fba4323", + "name": "flask", + "sha256": "b5a03d16d08ad5ab7b374e782cb1aded87f56958b39a491b69f0608dc6c01977", + "size": 124510, + "subdir": "linux-64", + "timestamp": 1525817058589, + "version": "1.0.2" + }, + "flask-1.0.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "click >=5.1", + "itsdangerous >=0.24", + "jinja2 >=2.10,<3.0", + "python >=3.7,<3.8.0a0", + "werkzeug >=0.15,<2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5ba422039395527e39e35855535301e4", + "name": "flask", + "sha256": "343ab68b08e191ef823c8898710f6e2e9557262f4e38b83f05b1370036395456", + "size": 122443, + "subdir": "linux-64", + "timestamp": 1530771776393, + "version": "1.0.2" + }, + "flask-1.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click >=5.1", + "itsdangerous >=0.24", + "jinja2 >=2.10,<3.0", + "python >=2.7,<2.8.0a0", + "werkzeug >=0.15,<2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "01858d0bbb99bdbc530aa33e3ecd810f", + "name": "flask", + "sha256": "a0d6357aa865ed355dc9a3ea62255a5bcbb49058868467b5120677460f9aa0fb", + "size": 126898, + "subdir": "linux-64", + "timestamp": 1559064650640, + "version": "1.0.3" + }, + "flask-1.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click >=5.1", + "itsdangerous >=0.24", + "jinja2 >=2.10,<3.0", + "python >=3.6,<3.7.0a0", + "werkzeug >=0.15,<2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cff1063eed44bf2796704f0fb6cab03d", + "name": "flask", + "sha256": "7c8f0c57e3114c4797422f078b8a1f8ce2d812e1f322f88fc5701a1dcc9602f7", + "size": 127776, + "subdir": "linux-64", + "timestamp": 1559064680497, + "version": "1.0.3" + }, + "flask-1.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click >=5.1", + "itsdangerous >=0.24", + "jinja2 >=2.10,<3.0", + "python >=3.7,<3.8.0a0", + "werkzeug >=0.15,<2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "977f0ffeb3305209187883eab7636154", + "name": "flask", + "sha256": "ddeb14b9c937fd4118aae55715963dce9752216eecfa6f9ff4493ceefbc86a89", + "size": 127838, + "subdir": "linux-64", + "timestamp": 1559064558591, + "version": "1.0.3" + }, + "flask-2.1.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8.0", + "itsdangerous >=2.0", + "jinja2 >=3.0", + "python >=3.10,<3.11.0a0", + "werkzeug >=2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "df134e4086e4438aa2f6c387603eaad4", + "name": "flask", + "sha256": "0d97ed8077b634b3546916a48170e63d2b33d7d316819a81172a48f570b4475e", + "size": 133846, + "subdir": "linux-64", + "timestamp": 1658870830934, + "version": "2.1.3" + }, + "flask-2.1.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8.0", + "importlib-metadata >=3.6.0", + "itsdangerous >=2.0", + "jinja2 >=3.0", + "python >=3.7,<3.8.0a0", + "werkzeug >=2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c6e09c99e30b4cc51ca59d1191f795b6", + "name": "flask", + "sha256": "fbe7c573c715c3b5eb1c84b00ec7929b85e326d3bdfe08de1ab2496746698f67", + "size": 131815, + "subdir": "linux-64", + "timestamp": 1658870881818, + "version": "2.1.3" + }, + "flask-2.1.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8.0", + "importlib-metadata >=3.6.0", + "itsdangerous >=2.0", + "jinja2 >=3.0", + "python >=3.8,<3.9.0a0", + "werkzeug >=2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a1fe86b2098d20531c90d2eb1c423713", + "name": "flask", + "sha256": "dccebc490a5b1f8c67a5ef06570564b9e91a449e1ea8123ca38d83eaee8fcb3a", + "size": 132527, + "subdir": "linux-64", + "timestamp": 1658870856122, + "version": "2.1.3" + }, + "flask-2.1.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8.0", + "importlib-metadata >=3.6.0", + "itsdangerous >=2.0", + "jinja2 >=3.0", + "python >=3.9,<3.10.0a0", + "werkzeug >=2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "69bc2a360d5fdc6d907fc654e682c2b7", + "name": "flask", + "sha256": "8ae5102c6cce34dc778a4859b1fa1905ca62bf95917aaa37e6ef5e3588d28562", + "size": 132686, + "subdir": "linux-64", + "timestamp": 1658870794542, + "version": "2.1.3" + }, + "flask-2.2.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8.0", + "itsdangerous >=2.0", + "jinja2 >=3.0", + "python >=3.10,<3.11.0a0", + "werkzeug >=2.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "26d3dd03d340b61578cf02ebaf988f8a", + "name": "flask", + "sha256": "ced690f05ad8eb79a51332c13665d47332956e691b67947eb326c5067e1b0db0", + "size": 151447, + "subdir": "linux-64", + "timestamp": 1671217451831, + "version": "2.2.2" + }, + "flask-2.2.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8.0", + "itsdangerous >=2.0", + "jinja2 >=3.0", + "python >=3.11,<3.12.0a0", + "werkzeug >=2.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c55371101d49bfbb693892bc057fdc8a", + "name": "flask", + "sha256": "45cb46e7cb1056d890e1138d85186c80153f28fe7a126e30fffd971ba0ee60d2", + "size": 181641, + "subdir": "linux-64", + "timestamp": 1676827153822, + "version": "2.2.2" + }, + "flask-2.2.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8.0", + "importlib-metadata >=3.6.0", + "itsdangerous >=2.0", + "jinja2 >=3.0", + "python >=3.7,<3.8.0a0", + "werkzeug >=2.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "32ab458215f6cb6f5c234068e6af8fd6", + "name": "flask", + "sha256": "8bd1528bb5c51c93eb0837fc661509f3e9c61a219bab0dec16067caf6439cb09", + "size": 149153, + "subdir": "linux-64", + "timestamp": 1671217425180, + "version": "2.2.2" + }, + "flask-2.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8.0", + "importlib-metadata >=3.6.0", + "itsdangerous >=2.0", + "jinja2 >=3.0", + "python >=3.8,<3.9.0a0", + "werkzeug >=2.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "311ee856c38b712cd48faf66c070ad0a", + "name": "flask", + "sha256": "94b46e6f142eba9fdb2f802c855202f457ade23f8253aa120f5f2d076e08ceed", + "size": 150034, + "subdir": "linux-64", + "timestamp": 1671217398740, + "version": "2.2.2" + }, + "flask-2.2.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=8.0", + "importlib-metadata >=3.6.0", + "itsdangerous >=2.0", + "jinja2 >=3.0", + "python >=3.9,<3.10.0a0", + "werkzeug >=2.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "54ad8cb021ce8932c59850eddefa83c9", + "name": "flask", + "sha256": "59b2543ae720d78d544cb40c71c5d77d366dabe0425ec0490c83208ed193fa90", + "size": 150238, + "subdir": "linux-64", + "timestamp": 1671217372741, + "version": "2.2.2" + }, + "flask-admin-1.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.7", + "python >=3.10,<3.11.0a0", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0fbc1c692a8b1d4fd73e274543d10997", + "name": "flask-admin", + "sha256": "191439767dd084813c2105e596ace9cd2217ff4387f09689f49fa3c6be985ee2", + "size": 4380548, + "subdir": "linux-64", + "timestamp": 1669054947277, + "version": "1.6.0" + }, + "flask-admin-1.6.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.7", + "python >=3.11,<3.12.0a0", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fade593fbbb2f6fe7e15ce6daf48dd5c", + "name": "flask-admin", + "sha256": "2af73a576aeaf3cb9e001800384a76926fd8be3e1e2e28dde0bc4370db9aa6a7", + "size": 3535652, + "subdir": "linux-64", + "timestamp": 1676852365602, + "version": "1.6.0" + }, + "flask-admin-1.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.7", + "python >=3.7,<3.8.0a0", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e230b32b9ebff75404819648e24a0105", + "name": "flask-admin", + "sha256": "aa6838d4e59d9383fe8cc52b6caf8e45a84a017c7abf5ec162bc5d21c5c29ed1", + "size": 4377767, + "subdir": "linux-64", + "timestamp": 1669055035903, + "version": "1.6.0" + }, + "flask-admin-1.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.7", + "python >=3.8,<3.9.0a0", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "05c32dbc1ab69da1d3081b09258c6c9b", + "name": "flask-admin", + "sha256": "85226c4cf3b7800ac1639ece9886ab2057422af54477374ad6554a0da0e23100", + "size": 4389320, + "subdir": "linux-64", + "timestamp": 1669055079097, + "version": "1.6.0" + }, + "flask-admin-1.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.7", + "python >=3.9,<3.10.0a0", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5eacf492af0577ab0df17d1473c272d2", + "name": "flask-admin", + "sha256": "ab68e2f04f1b782a7f1cb684f47489b16b53bd5e52b7f008df102a5b0632bea2", + "size": 4378122, + "subdir": "linux-64", + "timestamp": 1669054991697, + "version": "1.6.0" + }, + "flask-appbuilder-4.1.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "apispec >=3.3,<4", + "click >=8,<9", + "colorama >=0.3.9,<1", + "email_validator >=1.0.5,<2", + "flask >=2,<3", + "flask-babel >=1,<3", + "flask-jwt-extended >=4.0.0,<5.0.0", + "flask-login >=0.3,<0.7", + "flask-sqlalchemy >=2.4,<3", + "flask-wtf >=0.14.2,<1.0.0", + "jsonschema >=3,<5", + "marshmallow >=3,<4", + "marshmallow-enum >=1.5.1,<2", + "marshmallow-sqlalchemy >=0.22.0,<0.27.0", + "prison >=0.2.1,<1.0.0", + "pyjwt >=2.0.0,<3.0.0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.3,<3", + "sqlalchemy <1.5.0", + "sqlalchemy-utils >=0.32.21,<1", + "wtforms <3.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cb07064b8ddfd3e10a443d7eaaf364ae", + "name": "flask-appbuilder", + "sha256": "acb568b4fbdeccabc29a08f8fbd8fd08650910c644d5f09bad33548c9ee0e924", + "size": 1307324, + "subdir": "linux-64", + "timestamp": 1659862429185, + "version": "4.1.2" + }, + "flask-appbuilder-4.1.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "apispec >=3.3,<4", + "click >=8,<9", + "colorama >=0.3.9,<1", + "email_validator >=1.0.5,<2", + "flask >=2,<3", + "flask-babel >=1,<3", + "flask-jwt-extended >=4.0.0,<5.0.0", + "flask-login >=0.3,<0.7", + "flask-sqlalchemy >=2.4,<3", + "flask-wtf >=0.14.2,<1.0.0", + "jsonschema >=3,<5", + "marshmallow >=3,<4", + "marshmallow-enum >=1.5.1,<2", + "marshmallow-sqlalchemy >=0.22.0,<0.27.0", + "prison >=0.2.1,<1.0.0", + "pyjwt >=2.0.0,<3.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.3,<3", + "sqlalchemy <1.5.0", + "sqlalchemy-utils >=0.32.21,<1", + "wtforms <3.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "585665c9ab5bec396dae1289c59ab03c", + "name": "flask-appbuilder", + "sha256": "d1ee128d19e903a69410f2207f95010a2de485296ec38ce3825d11385a01c1e4", + "size": 1300432, + "subdir": "linux-64", + "timestamp": 1659862372553, + "version": "4.1.2" + }, + "flask-appbuilder-4.1.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "apispec >=3.3,<4", + "click >=8,<9", + "colorama >=0.3.9,<1", + "email_validator >=1.0.5,<2", + "flask >=2,<3", + "flask-babel >=1,<3", + "flask-jwt-extended >=4.0.0,<5.0.0", + "flask-login >=0.3,<0.7", + "flask-sqlalchemy >=2.4,<3", + "flask-wtf >=0.14.2,<1.0.0", + "jsonschema >=3,<5", + "marshmallow >=3,<4", + "marshmallow-enum >=1.5.1,<2", + "marshmallow-sqlalchemy >=0.22.0,<0.27.0", + "prison >=0.2.1,<1.0.0", + "pyjwt >=2.0.0,<3.0.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.3,<3", + "sqlalchemy <1.5.0", + "sqlalchemy-utils >=0.32.21,<1", + "wtforms <3.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d308ece46de514f4c8f273906fde2833", + "name": "flask-appbuilder", + "sha256": "b14fb0075b6566a1efee718b337cc66ce5943bc67008bc27aa6f28c41e1a8cc8", + "size": 1302004, + "subdir": "linux-64", + "timestamp": 1659862327581, + "version": "4.1.2" + }, + "flask-appbuilder-4.1.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "apispec >=3.3,<4", + "click >=8,<9", + "colorama >=0.3.9,<1", + "email_validator >=1.0.5,<2", + "flask >=2,<3", + "flask-babel >=1,<3", + "flask-jwt-extended >=4.0.0,<5.0.0", + "flask-login >=0.3,<0.7", + "flask-sqlalchemy >=2.4,<3", + "flask-wtf >=0.14.2,<1.0.0", + "jsonschema >=3,<5", + "marshmallow >=3,<4", + "marshmallow-enum >=1.5.1,<2", + "marshmallow-sqlalchemy >=0.22.0,<0.27.0", + "prison >=0.2.1,<1.0.0", + "pyjwt >=2.0.0,<3.0.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.3,<3", + "sqlalchemy <1.5.0", + "sqlalchemy-utils >=0.32.21,<1", + "wtforms <3.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "64dd79a885effac1413ad9ad53d86e7b", + "name": "flask-appbuilder", + "sha256": "9352f02fcc76fec8ecf2febcf7f621096fff75c8582ccfdaac02e2ea79dd4519", + "size": 1302564, + "subdir": "linux-64", + "timestamp": 1659862476136, + "version": "4.1.2" + }, + "flask-appbuilder-4.1.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "apispec >=3.3,<4", + "click >=8,<9", + "colorama >=0.3.9,<1", + "email_validator >=1.0.5,<2", + "flask >=2,<3", + "flask-babel >=1,<3", + "flask-jwt-extended >=4.0.0,<5.0.0", + "flask-login >=0.3,<0.7", + "flask-sqlalchemy >=2.4,<3", + "flask-wtf >=0.14.2,<2", + "jsonschema >=3,<5", + "marshmallow >=3,<4", + "marshmallow-enum >=1.5.1,<2", + "marshmallow-sqlalchemy >=0.22.0,<0.27.0", + "prison >=0.2.1,<1.0.0", + "pyjwt >=2.0.0,<3.0.0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.3,<3", + "sqlalchemy <1.5.0", + "sqlalchemy-utils >=0.32.21,<1", + "wtforms <4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6928221d6246696940753a770e8a5abe", + "name": "flask-appbuilder", + "sha256": "9372af309e84f2c3b79785d86402b2114fc4002e03e4ec31849fd27a29fb54c6", + "size": 1489319, + "subdir": "linux-64", + "timestamp": 1668714811782, + "version": "4.1.4" + }, + "flask-appbuilder-4.1.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "apispec >=3.3,<4", + "click >=8,<9", + "colorama >=0.3.9,<1", + "email_validator >=1.0.5,<2", + "flask >=2,<3", + "flask-babel >=1,<3", + "flask-jwt-extended >=4.0.0,<5.0.0", + "flask-login >=0.3,<0.7", + "flask-sqlalchemy >=2.4,<3", + "flask-wtf >=0.14.2,<2", + "jsonschema >=3,<5", + "marshmallow >=3,<4", + "marshmallow-enum >=1.5.1,<2", + "marshmallow-sqlalchemy >=0.22.0,<0.27.0", + "prison >=0.2.1,<1.0.0", + "pyjwt >=2.0.0,<3.0.0", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.3,<3", + "sqlalchemy <1.5.0", + "sqlalchemy-utils >=0.32.21,<1", + "wtforms <4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6b2815364c2cb052eb1528687555f573", + "name": "flask-appbuilder", + "sha256": "bc558e9469e1a365105eaf1f30527aad3a30e3b52343fbb82ec81ecb8bf72a20", + "size": 1427000, + "subdir": "linux-64", + "timestamp": 1676830527785, + "version": "4.1.4" + }, + "flask-appbuilder-4.1.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "apispec >=3.3,<4", + "click >=8,<9", + "colorama >=0.3.9,<1", + "email_validator >=1.0.5,<2", + "flask >=2,<3", + "flask-babel >=1,<3", + "flask-jwt-extended >=4.0.0,<5.0.0", + "flask-login >=0.3,<0.7", + "flask-sqlalchemy >=2.4,<3", + "flask-wtf >=0.14.2,<2", + "jsonschema >=3,<5", + "marshmallow >=3,<4", + "marshmallow-enum >=1.5.1,<2", + "marshmallow-sqlalchemy >=0.22.0,<0.27.0", + "prison >=0.2.1,<1.0.0", + "pyjwt >=2.0.0,<3.0.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.3,<3", + "sqlalchemy <1.5.0", + "sqlalchemy-utils >=0.32.21,<1", + "wtforms <4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0b2141302e672f31696b8740165566db", + "name": "flask-appbuilder", + "sha256": "c8597d7a5b552df3f246d753cdc3ae6582c9ccff441353d5bc67989e1b1cf14b", + "size": 1481505, + "subdir": "linux-64", + "timestamp": 1668714719259, + "version": "4.1.4" + }, + "flask-appbuilder-4.1.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "apispec >=3.3,<4", + "click >=8,<9", + "colorama >=0.3.9,<1", + "email_validator >=1.0.5,<2", + "flask >=2,<3", + "flask-babel >=1,<3", + "flask-jwt-extended >=4.0.0,<5.0.0", + "flask-login >=0.3,<0.7", + "flask-sqlalchemy >=2.4,<3", + "flask-wtf >=0.14.2,<2", + "jsonschema >=3,<5", + "marshmallow >=3,<4", + "marshmallow-enum >=1.5.1,<2", + "marshmallow-sqlalchemy >=0.22.0,<0.27.0", + "prison >=0.2.1,<1.0.0", + "pyjwt >=2.0.0,<3.0.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.3,<3", + "sqlalchemy <1.5.0", + "sqlalchemy-utils >=0.32.21,<1", + "wtforms <4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d582f39ef6bc3415414c32587ec9e882", + "name": "flask-appbuilder", + "sha256": "75e229460102b284fcafa8c7cc42eaf24c7c585eb3ebdee900beaf3841a9f8e2", + "size": 1477759, + "subdir": "linux-64", + "timestamp": 1668714670338, + "version": "4.1.4" + }, + "flask-appbuilder-4.1.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "apispec >=3.3,<4", + "click >=8,<9", + "colorama >=0.3.9,<1", + "email_validator >=1.0.5,<2", + "flask >=2,<3", + "flask-babel >=1,<3", + "flask-jwt-extended >=4.0.0,<5.0.0", + "flask-login >=0.3,<0.7", + "flask-sqlalchemy >=2.4,<3", + "flask-wtf >=0.14.2,<2", + "jsonschema >=3,<5", + "marshmallow >=3,<4", + "marshmallow-enum >=1.5.1,<2", + "marshmallow-sqlalchemy >=0.22.0,<0.27.0", + "prison >=0.2.1,<1.0.0", + "pyjwt >=2.0.0,<3.0.0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.3,<3", + "sqlalchemy <1.5.0", + "sqlalchemy-utils >=0.32.21,<1", + "wtforms <4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "105ce07bd0fd4c2f85f676dc6e385c26", + "name": "flask-appbuilder", + "sha256": "cc3534fa4e754dcf569864e79f941402f25b3e52648d7063c0bc0e43082226c5", + "size": 1473474, + "subdir": "linux-64", + "timestamp": 1668714765801, + "version": "4.1.4" + }, + "flask-apscheduler-1.12.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "apscheduler >=3.2.0,<4.0.0", + "flask >=0.10.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dee0cd230cf3fe00b80773d1acc3509e", + "name": "flask-apscheduler", + "sha256": "76c8dee97d39130f4a1925fd2ad996bcde4e6cddba928f68fff769edb54e34d9", + "size": 26518, + "subdir": "linux-64", + "timestamp": 1668715299193, + "version": "1.12.4" + }, + "flask-apscheduler-1.12.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "apscheduler >=3.2.0,<4.0.0", + "flask >=0.10.1", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "384291672bfd4f32d98be789ac4062f5", + "name": "flask-apscheduler", + "sha256": "8e270c78dad432a906eabb901f566fa78780e0c612c5a564545c14f3ec1186a7", + "size": 30501, + "subdir": "linux-64", + "timestamp": 1676852389438, + "version": "1.12.4" + }, + "flask-apscheduler-1.12.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "apscheduler >=3.2.0,<4.0.0", + "flask >=0.10.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e16a5ebe113f0fa5e5dfea96c26d9ab2", + "name": "flask-apscheduler", + "sha256": "d56e5471aead0fb7c8978686b7fbf8aa1a5e58d2d0a667a6746742630a9c79d3", + "size": 26411, + "subdir": "linux-64", + "timestamp": 1668715355228, + "version": "1.12.4" + }, + "flask-apscheduler-1.12.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "apscheduler >=3.2.0,<4.0.0", + "flask >=0.10.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1ff35fb6c08edc0587de441c4cba9a89", + "name": "flask-apscheduler", + "sha256": "9f0ee80c6d54e8e4b3c579006f6b4ef1c70c66dab421cb2faf4d9ea57efc287a", + "size": 26392, + "subdir": "linux-64", + "timestamp": 1668715327031, + "version": "1.12.4" + }, + "flask-apscheduler-1.12.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "apscheduler >=3.2.0,<4.0.0", + "flask >=0.10.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.4.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f262a948afa838a3f4a0d5e762343686", + "name": "flask-apscheduler", + "sha256": "2126baf457959fdb4fca55c7b08032079a0b9480dd4c3e71750f1cef93fe4daa", + "size": 26443, + "subdir": "linux-64", + "timestamp": 1668715270717, + "version": "1.12.4" + }, + "flask-bcrypt-1.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.1", + "flask", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6a9a0bb519d351eee1d97dbe6cde6bbc", + "name": "flask-bcrypt", + "sha256": "945bf16b59a07d15a83f3b09092c372a5d166c79bceaa2957eddb0a5d9d6dc9f", + "size": 11950, + "subdir": "linux-64", + "timestamp": 1669799384320, + "version": "1.0.1" + }, + "flask-bcrypt-1.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.1", + "flask", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6e4d5971c3c21ad063d08b84b067691c", + "name": "flask-bcrypt", + "sha256": "7134239b90e30b7bd71f12869499f3bf797281f0383f43553e2cf4bf0fed277d", + "size": 12748, + "subdir": "linux-64", + "timestamp": 1676852404035, + "version": "1.0.1" + }, + "flask-bcrypt-1.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.1", + "flask", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a729e3d1734573f4ca662fa235b2e102", + "name": "flask-bcrypt", + "sha256": "2d848c3da3cb2e6190209b6758d23917ebc1e697963204e912095d95d40af951", + "size": 11898, + "subdir": "linux-64", + "timestamp": 1669799309097, + "version": "1.0.1" + }, + "flask-bcrypt-1.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.1", + "flask", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cdd412ee916f04c99faef15432bcac2f", + "name": "flask-bcrypt", + "sha256": "5f8a0ca465997c9b958e5660e2308d5e9896439ef6a07a610b88593f80cafd6d", + "size": 11873, + "subdir": "linux-64", + "timestamp": 1669799359191, + "version": "1.0.1" + }, + "flask-bcrypt-1.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.1", + "flask", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aa18611450b043d365371537688a8602", + "name": "flask-bcrypt", + "sha256": "d6d6894ff262dc4e2514a703791c97c399e106557e4e8262fffe053f4f737896", + "size": 11906, + "subdir": "linux-64", + "timestamp": 1669799334260, + "version": "1.0.1" + }, + "flask-caching-2.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib >=0.9.0", + "flask <3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "42b08caa02cf7eb5ad076f261c2bc862", + "name": "flask-caching", + "sha256": "8aa90d663a3eb5b215e3b53c5d7e79c74d52af4c1fb250cfafc59c8c7bffa400", + "size": 45455, + "subdir": "linux-64", + "timestamp": 1668715163949, + "version": "2.0.1" + }, + "flask-caching-2.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib >=0.9.0", + "flask <3", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f249835cc2c3031d52b65f80972a75cf", + "name": "flask-caching", + "sha256": "1cf166437ba3ea8187e64ff60880a7bce9465a20202d9a49b24aea02359b6e9d", + "size": 55717, + "subdir": "linux-64", + "timestamp": 1676830543678, + "version": "2.0.1" + }, + "flask-caching-2.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib >=0.9.0", + "flask <3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "71c548dd7ca461a2b5dbd5877e677961", + "name": "flask-caching", + "sha256": "e6e8ec6a96a95487c754d39ad604aeb246bda61a71af0d68e40ddc5e46c5f41d", + "size": 44824, + "subdir": "linux-64", + "timestamp": 1668715107936, + "version": "2.0.1" + }, + "flask-caching-2.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib >=0.9.0", + "flask <3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "61b860547c3228a6dcc0678c480e4d7a", + "name": "flask-caching", + "sha256": "7766d84840fafab2594d63021380a553021c88485a18052c3b3a675d7a599dac", + "size": 45043, + "subdir": "linux-64", + "timestamp": 1668715135845, + "version": "2.0.1" + }, + "flask-caching-2.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib >=0.9.0", + "flask <3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2b64ca5ab6195dd73e4893e81e5eaf91", + "name": "flask-caching", + "sha256": "99aadcbe67e6a24bb91044fb283514d0a7050e9e2ae01c8123d62b64132eb6cf", + "size": 45065, + "subdir": "linux-64", + "timestamp": 1668715191514, + "version": "2.0.1" + }, + "flask-compress-1.13-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "brotli-python", + "flask", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c8b9cd5da812650d8db365c7d2f138c", + "name": "flask-compress", + "sha256": "118762edba668a1f818554a4d2b28be2bd4868b9c197ffcd62af4462ae844705", + "size": 19113, + "subdir": "linux-64", + "timestamp": 1668715006122, + "version": "1.13" + }, + "flask-compress-1.13-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "brotli-python", + "flask", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d3fb07e04bbc62d5d4c119a6604b68b", + "name": "flask-compress", + "sha256": "6c6290c79e323906e14a446ff2404fad59e4371e029bec1d221604e5f9c67a1c", + "size": 20936, + "subdir": "linux-64", + "timestamp": 1676839847005, + "version": "1.13" + }, + "flask-compress-1.13-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "brotli-python", + "flask", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17cb61f9c980f5d1af460681a8089fd2", + "name": "flask-compress", + "sha256": "ee39c497408d7b3a7b27ac3913f261eb83dfa90b4f2c408f15429ed6fdc0ddda", + "size": 19047, + "subdir": "linux-64", + "timestamp": 1668715036630, + "version": "1.13" + }, + "flask-compress-1.13-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "brotli-python", + "flask", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60765219055b36a0a30f2bb13e9057bd", + "name": "flask-compress", + "sha256": "3548c3413cbb34128740635bc0a8898ff7c77c054f8b18c52af08f1828cdf20d", + "size": 19073, + "subdir": "linux-64", + "timestamp": 1668714975815, + "version": "1.13" + }, + "flask-compress-1.13-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "brotli-python", + "flask", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33825d825f503d06e55c447731df8aff", + "name": "flask-compress", + "sha256": "69984d46cf54802c4021d01b86db01256bbb6957b20a413d6b33c4a2b99bd4f5", + "size": 19072, + "subdir": "linux-64", + "timestamp": 1668715066506, + "version": "1.13" + }, + "flask-cors-3.0.3-py27h1a8a27f_0.conda": { + "build": "py27h1a8a27f_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2d97de3f665387e07e89ba74f0944d7", + "name": "flask-cors", + "sha256": "d18fa7a995c5a331045ba62a5e5bc610794fe3c4d58f47983a0a71fd9d340075", + "size": 20630, + "subdir": "linux-64", + "timestamp": 1505740446272, + "version": "3.0.3" + }, + "flask-cors-3.0.3-py35h9b2065d_0.conda": { + "build": "py35h9b2065d_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c078d2029734615b6da763103a239aca", + "name": "flask-cors", + "sha256": "466a9a308ba844df7f08fa9a098345295d134930e3804655d1761e75a5204ead", + "size": 20793, + "subdir": "linux-64", + "timestamp": 1505740459106, + "version": "3.0.3" + }, + "flask-cors-3.0.3-py36h2d857d3_0.conda": { + "build": "py36h2d857d3_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "84f2fc935df17da55a9fcbf3b2a71be6", + "name": "flask-cors", + "sha256": "d9cd721144f32552578fe1be10f42729ccf2bda84a146cf26031db24326abd34", + "size": 20571, + "subdir": "linux-64", + "timestamp": 1505740472201, + "version": "3.0.3" + }, + "flask-cors-3.0.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "32c188214ddce6bc337ebce7e9ea78c2", + "name": "flask-cors", + "sha256": "aacb57f1450859c2b5b56179e48aaa138b8305733cd60b1891ef3005ed7a2752", + "size": 21064, + "subdir": "linux-64", + "timestamp": 1525812647683, + "version": "3.0.4" + }, + "flask-cors-3.0.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "858f0845ffb54e6641ded6cdef9f8ed6", + "name": "flask-cors", + "sha256": "a4dccc5a75156e95a9526f132cc4ae7bd98c386acf9cd0bed664f030fe387661", + "size": 21381, + "subdir": "linux-64", + "timestamp": 1525812691182, + "version": "3.0.4" + }, + "flask-cors-3.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4a458b7bfa0ac33dbc42cc42796dd910", + "name": "flask-cors", + "sha256": "7eaddfd0c2f87044006549783d54f9851c582dd71e08fc0760a8c125b11d2074", + "size": 21276, + "subdir": "linux-64", + "timestamp": 1525812746295, + "version": "3.0.4" + }, + "flask-cors-3.0.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a00493b85f68dd9c74a484c0720c03f7", + "name": "flask-cors", + "sha256": "45fd91eb8aafa517e05c39c5be1543555730b9b19c63b0dfa38cda70bc54903f", + "size": 20888, + "subdir": "linux-64", + "timestamp": 1529347022400, + "version": "3.0.6" + }, + "flask-cors-3.0.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d16525d36360c1c78d414377581d8f8", + "name": "flask-cors", + "sha256": "7b4e2a6578808a54b9929864579abe2a2c4064e84739f6018811ff98b1316178", + "size": 21240, + "subdir": "linux-64", + "timestamp": 1529347037592, + "version": "3.0.6" + }, + "flask-cors-3.0.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4a0d77e0ecdc2d347d7d265a26b8844", + "name": "flask-cors", + "sha256": "1904b3e8fc1b4c3c439c97067379c56e5e49eacca0325a191da7ed399f47781a", + "size": 21098, + "subdir": "linux-64", + "timestamp": 1529347006906, + "version": "3.0.6" + }, + "flask-cors-3.0.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "26f3fa4d65693df65393e7bba06cd3f8", + "name": "flask-cors", + "sha256": "5dd381f5bd6d8a7ce0c72bcbc9d766031da0a908cb0f64f3cef11523052f3b3c", + "size": 21011, + "subdir": "linux-64", + "timestamp": 1530771801305, + "version": "3.0.6" + }, + "flask-cors-3.0.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8552b53a973e4e6f7b4d0dc1292b8ea9", + "name": "flask-cors", + "sha256": "2290a0113b3fb796fb9e9a184c27ec2d1220bd93c57e61c3ce30e60ed66344eb", + "size": 21727, + "subdir": "linux-64", + "timestamp": 1542079353810, + "version": "3.0.7" + }, + "flask-cors-3.0.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c7080c9d3fda68cf701c5478e2e0d73", + "name": "flask-cors", + "sha256": "136f1bd0db000703fd818b31f0206695ad11e8fe6b49e23a88c0931e67126f4c", + "size": 22058, + "subdir": "linux-64", + "timestamp": 1542079403453, + "version": "3.0.7" + }, + "flask-cors-3.0.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15d4e16278ae6af6fc1ef0edb7db3d14", + "name": "flask-cors", + "sha256": "912fe7484de42c69fd8f6d1780382a019abf24251730a6f8263f8738efae6cdc", + "size": 21866, + "subdir": "linux-64", + "timestamp": 1542079340072, + "version": "3.0.7" + }, + "flask-jwt-extended-4.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.3.1", + "flask >=2.0,<3.0", + "pyjwt >=2.0,<3.0", + "python >=3.10,<3.11.0a0", + "werkzeug >=0.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2a735b6de058dfff66f6d0c84afbc73", + "name": "flask-jwt-extended", + "sha256": "d6859605f69983dd298f3b940884d9df2ba5401ebd8dd6916fb620fb012dacb3", + "size": 37736, + "subdir": "linux-64", + "timestamp": 1659620747921, + "version": "4.4.3" + }, + "flask-jwt-extended-4.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.3.1", + "flask >=2.0,<3.0", + "pyjwt >=2.0,<3.0", + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.7.4", + "werkzeug >=0.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e61da7dcac25f646a27ea2d23b97c845", + "name": "flask-jwt-extended", + "sha256": "372d141f315895262b59ec77c6de847f94e2cb7bb56d5a4aefe2d46873f99418", + "size": 37196, + "subdir": "linux-64", + "timestamp": 1659620769909, + "version": "4.4.3" + }, + "flask-jwt-extended-4.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.3.1", + "flask >=2.0,<3.0", + "pyjwt >=2.0,<3.0", + "python >=3.8,<3.9.0a0", + "werkzeug >=0.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7860beb9b75adca6617e0cfd39c65215", + "name": "flask-jwt-extended", + "sha256": "2f0662e7825202865aee60b6e5935bad0f4a192f2e35f8a8d5a87b3d018c4f71", + "size": 37276, + "subdir": "linux-64", + "timestamp": 1659620693293, + "version": "4.4.3" + }, + "flask-jwt-extended-4.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.3.1", + "flask >=2.0,<3.0", + "pyjwt >=2.0,<3.0", + "python >=3.9,<3.10.0a0", + "werkzeug >=0.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "132ede82526fbbc92b03127b4fa15244", + "name": "flask-jwt-extended", + "sha256": "3cbfb5e171da7f6121d3f1309cd8ff1566674aea0054f1efdfd1a2688560f275", + "size": 37280, + "subdir": "linux-64", + "timestamp": 1659620715616, + "version": "4.4.3" + }, + "flask-jwt-extended-4.4.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.3.1", + "flask >=2.0,<3.0", + "pyjwt >=2.0,<3.0", + "python >=3.10,<3.11.0a0", + "werkzeug >=0.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "97739d52aa0dfba2ba4ed3701fa4b413", + "name": "flask-jwt-extended", + "sha256": "e214a243171aaa79e27c9815bc661464b6dd0c1db18db2d2380eea730cffa157", + "size": 39656, + "subdir": "linux-64", + "timestamp": 1668814750559, + "version": "4.4.4" + }, + "flask-jwt-extended-4.4.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.3.1", + "flask >=2.0,<3.0", + "pyjwt >=2.0,<3.0", + "python >=3.11,<3.12.0a0", + "werkzeug >=0.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d7cab7d6766ac87bd21ad1eb73bac96", + "name": "flask-jwt-extended", + "sha256": "e80ab2aca765ccb7ac914acc4411548b008f22479d44de24b90cac6cfbdb78b0", + "size": 45435, + "subdir": "linux-64", + "timestamp": 1676827768723, + "version": "4.4.4" + }, + "flask-jwt-extended-4.4.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.3.1", + "flask >=2.0,<3.0", + "pyjwt >=2.0,<3.0", + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.7.4", + "werkzeug >=0.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e2387debd70cada9e376c3062a24066", + "name": "flask-jwt-extended", + "sha256": "45245dc3a5a2e30e141175ebba21f586e957e84c8850d2d3a0930f5c1feedee2", + "size": 39070, + "subdir": "linux-64", + "timestamp": 1668814803649, + "version": "4.4.4" + }, + "flask-jwt-extended-4.4.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.3.1", + "flask >=2.0,<3.0", + "pyjwt >=2.0,<3.0", + "python >=3.8,<3.9.0a0", + "werkzeug >=0.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7d53430258ec35ad302668942b7f89e3", + "name": "flask-jwt-extended", + "sha256": "d35ab876f661b301b0edda3754bd9734580630a41d18f015cfa15c74445e0c4d", + "size": 39450, + "subdir": "linux-64", + "timestamp": 1668814830227, + "version": "4.4.4" + }, + "flask-jwt-extended-4.4.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.3.1", + "flask >=2.0,<3.0", + "pyjwt >=2.0,<3.0", + "python >=3.9,<3.10.0a0", + "werkzeug >=0.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58f79fb8e33d393ddb27b0567d79307a", + "name": "flask-jwt-extended", + "sha256": "794a124b3873675074fac0ebbd4dcb0905b73d27632276b62b3a203e78f8cee0", + "size": 39246, + "subdir": "linux-64", + "timestamp": 1668814776920, + "version": "4.4.4" + }, + "flask-login-0.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9eda5d90dbd25db197ce732c90b250b7", + "name": "flask-login", + "sha256": "c6009785c5f3b55e17033b596ebc39a850d5fb8d8d91fcc9fa3aa6369f087456", + "size": 25192, + "subdir": "linux-64", + "timestamp": 1522774405699, + "version": "0.4.1" + }, + "flask-login-0.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flask", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "330732b0a036e323e276c55b82a6a6a1", + "name": "flask-login", + "sha256": "037da09b5a406d8d31a5a0ad4f107592d0b03ebc629cc190d0581ab23ae943c7", + "size": 25385, + "subdir": "linux-64", + "timestamp": 1522774439302, + "version": "0.4.1" + }, + "flask-login-0.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "fbfe8daa56db73e058d7add545d5a7f6", + "name": "flask-login", + "sha256": "40848a0b7dd42cea4f980b32301d39cabafeda0c7c1d7ff2a12d1b92ba860761", + "size": 25132, + "subdir": "linux-64", + "timestamp": 1522774422150, + "version": "0.4.1" + }, + "flask-login-0.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flask", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8781c6fe66f2919c2f551d9a1a8da832", + "name": "flask-login", + "sha256": "0ad21504d534323f81b02352f5cf8792140bcb1c16b8c5f6f3e8724cb1649298", + "size": 25019, + "subdir": "linux-64", + "timestamp": 1530877481765, + "version": "0.4.1" + }, + "flask-login-0.4.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "flask", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "d71200a3dd5e2426627ba4e4884dbce1", + "name": "flask-login", + "sha256": "7c96910949109277541d7ec3a5fa76922f29c376ad0f1ace2b7b1aa7b9552bb5", + "size": 25476, + "subdir": "linux-64", + "timestamp": 1574177518225, + "version": "0.4.1" + }, + "flask-login-0.6.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=1.0.4", + "python >=3.10,<3.11.0a0", + "werkzeug >=1.0.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "61fbb8f3ae00818e1881e124808b5961", + "name": "flask-login", + "sha256": "f3eb08b5ab150494d7eb0819f37a4a21b8b21a1ff6567439b2f80311487751bf", + "size": 30245, + "subdir": "linux-64", + "timestamp": 1669057640640, + "version": "0.6.2" + }, + "flask-login-0.6.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=1.0.4", + "python >=3.11,<3.12.0a0", + "werkzeug >=1.0.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f92247e86ba1d85ce76c42b1d37199a2", + "name": "flask-login", + "sha256": "106c7b716303b2d27802650304442f4ce21bc3fee9551fd400335e804821805f", + "size": 34779, + "subdir": "linux-64", + "timestamp": 1676827783031, + "version": "0.6.2" + }, + "flask-login-0.6.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=1.0.4", + "python >=3.7,<3.8.0a0", + "werkzeug >=1.0.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e698bcd3a0f37f40247b06f2b9bd35d", + "name": "flask-login", + "sha256": "b4128280a5fc5b244790ba4353adda5507438530eaa3ed9e5f754956fbf0a1dc", + "size": 30091, + "subdir": "linux-64", + "timestamp": 1669057702910, + "version": "0.6.2" + }, + "flask-login-0.6.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=1.0.4", + "python >=3.8,<3.9.0a0", + "werkzeug >=1.0.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c210375e1579f1f6d51401c54e63183", + "name": "flask-login", + "sha256": "278719c29dbb003785abeeed0c7f3f1d86b520c34139aca236875dd8443cf909", + "size": 30186, + "subdir": "linux-64", + "timestamp": 1669057670819, + "version": "0.6.2" + }, + "flask-login-0.6.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=1.0.4", + "python >=3.9,<3.10.0a0", + "werkzeug >=1.0.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e24d8fed0f56cd47dde89935c7d5406d", + "name": "flask-login", + "sha256": "89346ee2d6926e630f2de50d218ba3d4645990444a34c46089ae6da2c2b58297", + "size": 30108, + "subdir": "linux-64", + "timestamp": 1669057611684, + "version": "0.6.2" + }, + "flask-openid-1.2.5-py27_1003.conda": { + "build": "py27_1003", + "build_number": 1003, + "depends": [ + "flask >=0.3", + "python >=2.7,<2.8.0a0", + "python-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ceda9d156456a5432d167dda5d00c52a", + "name": "flask-openid", + "sha256": "fd96462ce8a1f41bb4375606cadfb80a63ea3b3a214f890116221744908815f0", + "size": 20379, + "subdir": "linux-64", + "timestamp": 1579615662425, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py310h06a4308_1004.conda": { + "build": "py310h06a4308_1004", + "build_number": 1004, + "depends": [ + "flask >=0.10.1", + "python >=3.10,<3.11.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1bb5077a74f1a63af519eb950c734d85", + "name": "flask-openid", + "sha256": "15e16a5840373be4f4e0f6733d96f1a1a3f9ed2260f36a2b821f0dec1378094f", + "size": 21677, + "subdir": "linux-64", + "timestamp": 1659705525396, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py36_1003.conda": { + "build": "py36_1003", + "build_number": 1003, + "depends": [ + "flask >=0.10.1", + "python >=3.6,<3.7.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "256d3ba88faefd7dcbdb41875e28a8ce", + "name": "flask-openid", + "sha256": "4db7cc968280f4382d406f0d4ac60af9e4dc7db920d8ab7d7f76198a117e94c2", + "size": 20144, + "subdir": "linux-64", + "timestamp": 1579615602010, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py36h06a4308_1003.conda": { + "build": "py36h06a4308_1003", + "build_number": 1003, + "depends": [ + "flask >=0.10.1", + "python >=3.6,<3.7.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9fd21ac072e7ed1df5c0eacd292f7bc4", + "name": "flask-openid", + "sha256": "5bf08256f083db6a7b1d58366f712e211b9eb17822d9535237ee9d0d4586ceb2", + "size": 20515, + "subdir": "linux-64", + "timestamp": 1614089141014, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py37_1003.conda": { + "build": "py37_1003", + "build_number": 1003, + "depends": [ + "flask >=0.10.1", + "python >=3.7,<3.8.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2065292841706ff530634f40559f6cd4", + "name": "flask-openid", + "sha256": "60ba0aa46a410af390c7889f96410e2e4eb2a7a042ea15fd111b375a7d897310", + "size": 20218, + "subdir": "linux-64", + "timestamp": 1579615484229, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py37h06a4308_1003.conda": { + "build": "py37h06a4308_1003", + "build_number": 1003, + "depends": [ + "flask >=0.10.1", + "python >=3.7,<3.8.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "650662a9ca7369c85a0af9233e7dc235", + "name": "flask-openid", + "sha256": "7fab890213fa1ee0869a378ddc4e85ac18b4090d5f3b3de54b6c8de90f3c6c95", + "size": 20460, + "subdir": "linux-64", + "timestamp": 1614088203115, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py37h06a4308_1004.conda": { + "build": "py37h06a4308_1004", + "build_number": 1004, + "depends": [ + "flask >=0.10.1", + "python >=3.7,<3.8.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "514f2c89a78f43a7f6ceb0ec3d51040a", + "name": "flask-openid", + "sha256": "84bb0dbe5a1da5a32f5de92c2d7715c6343b937fe2ec6032ca40d76f8e454c58", + "size": 21427, + "subdir": "linux-64", + "timestamp": 1659705547694, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py38_1003.conda": { + "build": "py38_1003", + "build_number": 1003, + "depends": [ + "flask >=0.10.1", + "python >=3.8,<3.9.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a0437561a08fe179c841c1069a6a8ad6", + "name": "flask-openid", + "sha256": "ad3a4df2b30a578e897c0831307fac2df58c6cc6bf4111248927cdf56de29b82", + "size": 20340, + "subdir": "linux-64", + "timestamp": 1579615760879, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py38h06a4308_1003.conda": { + "build": "py38h06a4308_1003", + "build_number": 1003, + "depends": [ + "flask >=0.10.1", + "python >=3.8,<3.9.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c5db076236cd0435fe15de29fb6ad53c", + "name": "flask-openid", + "sha256": "17d1e28d94a00b12f33dbd979035fb38f13e30b987b4d178774687dbc98de143", + "size": 20613, + "subdir": "linux-64", + "timestamp": 1614089137698, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py38h06a4308_1004.conda": { + "build": "py38h06a4308_1004", + "build_number": 1004, + "depends": [ + "flask >=0.10.1", + "python >=3.8,<3.9.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a3ed6cb1cd1554a3f5882c69ecbb0b9e", + "name": "flask-openid", + "sha256": "d6ba4e5de786a2416f01f41617f28d5ab2b503840b8065973b223af06da840eb", + "size": 21508, + "subdir": "linux-64", + "timestamp": 1659705493387, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py39h06a4308_1003.conda": { + "build": "py39h06a4308_1003", + "build_number": 1003, + "depends": [ + "flask >=0.10.1", + "python >=3.9,<3.10.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "380b575ae11b4ec4fcda9090be8527da", + "name": "flask-openid", + "sha256": "d21cf2b6543ed7556886a9ed87889d8bcd02be1d3baf554d7d593a23a1962312", + "size": 20697, + "subdir": "linux-64", + "timestamp": 1614089014804, + "version": "1.2.5" + }, + "flask-openid-1.2.5-py39h06a4308_1004.conda": { + "build": "py39h06a4308_1004", + "build_number": 1004, + "depends": [ + "flask >=0.10.1", + "python >=3.9,<3.10.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2d59d745276c56c1ab082360262d329c", + "name": "flask-openid", + "sha256": "b3456ffb2f734025fc7725b3c5d1242c78d7fef6bd63c328c8c903ca128c3e4c", + "size": 21488, + "subdir": "linux-64", + "timestamp": 1659705471317, + "version": "1.2.5" + }, + "flask-openid-1.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.10.1", + "python >=3.10,<3.11.0a0", + "python3-openid >=2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "19dfc96e0069caea435a399150e3db7e", + "name": "flask-openid", + "sha256": "faf4ff8b9315dffcbb0a4de0c20c24eb62d683bf6f754a7328cd430db15e2a9a", + "size": 18778, + "subdir": "linux-64", + "timestamp": 1640855875858, + "version": "1.3.0" + }, + "flask-openid-1.3.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "flask >=0.10.1", + "python >=3.10,<3.11.0a0", + "python3-openid >=2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "378fdab77229ccd6886747b0e22dec79", + "name": "flask-openid", + "sha256": "1b2d16178fed40d4c248443fa55a6760901ac6feb5b672641f70853d7561bd4c", + "size": 20156, + "subdir": "linux-64", + "timestamp": 1669237466920, + "version": "1.3.0" + }, + "flask-openid-1.3.0-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "flask >=0.10.1", + "python >=3.11,<3.12.0a0", + "python3-openid >=2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2e0b07a9873a9abf703b5ed760574d7c", + "name": "flask-openid", + "sha256": "1b52e7dc7b6d78521030ae1da25a6aff7969c2e27353fdbfa99f66d45b3f6fed", + "size": 23353, + "subdir": "linux-64", + "timestamp": 1676852419943, + "version": "1.3.0" + }, + "flask-openid-1.3.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "flask >=0.10.1", + "python >=3.7,<3.8.0a0", + "python3-openid >=2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b6d739bc8a8064073196c3c7952d2601", + "name": "flask-openid", + "sha256": "e2e44c6cc3d176b28bb7485121d685363b09765ca508c39687ad101d220e618d", + "size": 19889, + "subdir": "linux-64", + "timestamp": 1669237416631, + "version": "1.3.0" + }, + "flask-openid-1.3.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "flask >=0.10.1", + "python >=3.8,<3.9.0a0", + "python3-openid >=2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "387051a26030067c3d0701195f134884", + "name": "flask-openid", + "sha256": "d522a447193fcb04976da0d5cea2a46e61c2032b69edc93d957a4af12b193151", + "size": 20009, + "subdir": "linux-64", + "timestamp": 1669237441926, + "version": "1.3.0" + }, + "flask-openid-1.3.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "flask >=0.10.1", + "python >=3.9,<3.10.0a0", + "python3-openid >=2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b73ba1312c5cd3509435ea7faf529850", + "name": "flask-openid", + "sha256": "3bb5e207e82b5d1b55741c89e44195e6f254b103a2b37f7f958d20ada1d5dce9", + "size": 19973, + "subdir": "linux-64", + "timestamp": 1669237390959, + "version": "1.3.0" + }, + "flask-restful-0.3.9-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8", + "python >=3.10,<3.11.0a0", + "pytz", + "six >=1.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50229301383a44536d4fde2cb29d6a07", + "name": "flask-restful", + "sha256": "7eae2fd2c3dc2500eef7f485c9e914df7713e0d0d763477cdebe5f249dba5595", + "size": 47339, + "subdir": "linux-64", + "timestamp": 1669054959628, + "version": "0.3.9" + }, + "flask-restful-0.3.9-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8", + "python >=3.11,<3.12.0a0", + "pytz", + "six >=1.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "abb9cbe937eb4da512e39c62c19c2464", + "name": "flask-restful", + "sha256": "60e429f62e94041909cac5c2f10b7ad60fd75f950f60a25db0dd5f4d6163d0df", + "size": 55881, + "subdir": "linux-64", + "timestamp": 1676852434755, + "version": "0.3.9" + }, + "flask-restful-0.3.9-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8", + "python >=3.7,<3.8.0a0", + "pytz", + "six >=1.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e15636d10b07ba2bbc90368022b1e9e", + "name": "flask-restful", + "sha256": "9b3a6e9fa4d1776628853b34093b074f48977ce80e659221f1a7297bd45927f4", + "size": 46987, + "subdir": "linux-64", + "timestamp": 1669054906396, + "version": "0.3.9" + }, + "flask-restful-0.3.9-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8", + "python >=3.8,<3.9.0a0", + "pytz", + "six >=1.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c871f8045061444e366f53ded69b1b1f", + "name": "flask-restful", + "sha256": "e672889cd3c7104c0a32b1d58985b41b89a7dfb2551bd9f898e4e8cfc33fc8b3", + "size": 47146, + "subdir": "linux-64", + "timestamp": 1669054932982, + "version": "0.3.9" + }, + "flask-restful-0.3.9-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8", + "python >=3.9,<3.10.0a0", + "pytz", + "six >=1.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7c3cba4774b99ebc3828c3de7ab015a6", + "name": "flask-restful", + "sha256": "6a50c336f41bca2a4d5ecad0aecc32ea4e8417691c2b0b41134133ff30b3dc49", + "size": 47053, + "subdir": "linux-64", + "timestamp": 1669054985844, + "version": "0.3.9" + }, + "flask-restx-1.0.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8,!=2.0.0", + "jsonschema", + "python >=3.10,<3.11.0a0", + "pytz", + "werkzeug !=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "79724b662fba10d03b14648dbbb290a1", + "name": "flask-restx", + "sha256": "a64890ff6919f2a4d3f7791bd15684927e2e480608ef57d6059faf3dc15a06bd", + "size": 3505014, + "subdir": "linux-64", + "timestamp": 1669057147147, + "version": "1.0.3" + }, + "flask-restx-1.0.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8,!=2.0.0", + "jsonschema", + "python >=3.11,<3.12.0a0", + "pytz", + "werkzeug !=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d892ef45dbd9ade8e42e2122c27bd920", + "name": "flask-restx", + "sha256": "9777c1c11e97116a63988848bcde635fbfc95122e26c97227014ac4d3c9ed0cb", + "size": 2044359, + "subdir": "linux-64", + "timestamp": 1676852453377, + "version": "1.0.3" + }, + "flask-restx-1.0.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8,!=2.0.0", + "jsonschema", + "python >=3.7,<3.8.0a0", + "pytz", + "werkzeug !=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a74fe131dfff78687dcdb1c9c7b44271", + "name": "flask-restx", + "sha256": "01bd24a2148a788628c0bb4644acdca42a28861368c6b77f2ebca05a39d47dd1", + "size": 3490938, + "subdir": "linux-64", + "timestamp": 1669057182040, + "version": "1.0.3" + }, + "flask-restx-1.0.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8,!=2.0.0", + "jsonschema", + "python >=3.8,<3.9.0a0", + "pytz", + "werkzeug !=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a4c907545a618f24544a670c0958c82a", + "name": "flask-restx", + "sha256": "b30af16f8c334ca78451ca702fd6a63a68bcfa0b4196d35453d39910b3664484", + "size": 3490812, + "subdir": "linux-64", + "timestamp": 1669057109292, + "version": "1.0.3" + }, + "flask-restx-1.0.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aniso8601 >=0.82", + "flask >=0.8,!=2.0.0", + "jsonschema", + "python >=3.9,<3.10.0a0", + "pytz", + "werkzeug !=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "84b41e7e90803675557afb41390db72a", + "name": "flask-restx", + "sha256": "c640e31eaf2156b85ed6b39e92ee0940f86f956202c9d46c317b89f116aa0728", + "size": 3490794, + "subdir": "linux-64", + "timestamp": 1669057219721, + "version": "1.0.3" + }, + "flask-session-0.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib", + "flask >=0.8", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "efa314abdd528966ba7cabb4b167d7eb", + "name": "flask-session", + "sha256": "770664362fc4b90ea19d71d7516e3a2dec00639838e79c7f0e798a2ecea1c04f", + "size": 16521, + "subdir": "linux-64", + "timestamp": 1659857606374, + "version": "0.4.0" + }, + "flask-session-0.4.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib", + "flask >=0.8", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9b42f7cf41a2e09fc775197a807a5319", + "name": "flask-session", + "sha256": "b68e4a0b44374c67da3eb620c757d6f2292653e932f0c12bf48c61657474951b", + "size": 20104, + "subdir": "linux-64", + "timestamp": 1676830558905, + "version": "0.4.0" + }, + "flask-session-0.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib", + "flask >=0.8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "aca283941991abe3c2579e62c5aaaafa", + "name": "flask-session", + "sha256": "6842674c8829e2ec1753d9203a82965d0f5955ce5e7f02b35f5ead6f7dc602cb", + "size": 16347, + "subdir": "linux-64", + "timestamp": 1659857534518, + "version": "0.4.0" + }, + "flask-session-0.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib", + "flask >=0.8", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "82d0c72445b965c1d75f4c5d690d728f", + "name": "flask-session", + "sha256": "98479aae2f30a3f2091f567733019168a6e33b558448c49312042bbfc7193bb4", + "size": 16436, + "subdir": "linux-64", + "timestamp": 1659857507173, + "version": "0.4.0" + }, + "flask-session-0.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cachelib", + "flask >=0.8", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7e0777f7446c3b2590fc83d4751a0227", + "name": "flask-session", + "sha256": "1c9ae96a5e640299a5248b3d69bab9183507fcfd462fa86f8a3b782addb24576", + "size": 16353, + "subdir": "linux-64", + "timestamp": 1659857566057, + "version": "0.4.0" + }, + "flask-socketio-2.9.2-py27hbb26ec0_0.conda": { + "build": "py27hbb26ec0_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "python-engineio >=1.0.0", + "python-socketio >=1.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e55dcb98fec1d85e1cee78418ad6161b", + "name": "flask-socketio", + "sha256": "11c145c55b804ddb74a3e393ade3ce91ed4040b1b7958c60d492ea842d25987f", + "size": 26042, + "subdir": "linux-64", + "timestamp": 1512043280984, + "version": "2.9.2" + }, + "flask-socketio-2.9.2-py35ha1def9a_0.conda": { + "build": "py35ha1def9a_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.5,<3.6.0a0", + "python-engineio >=1.0.0", + "python-socketio >=1.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff24f235c6ca2480940e5986ded20e01", + "name": "flask-socketio", + "sha256": "8498c4515c6e186c8304226a968c182e0d0bdb32689b6a6b1f806fa5c806948b", + "size": 26201, + "subdir": "linux-64", + "timestamp": 1512043285249, + "version": "2.9.2" + }, + "flask-socketio-2.9.2-py36hec8e26b_0.conda": { + "build": "py36hec8e26b_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "python-engineio >=1.0.0", + "python-socketio >=1.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2f1c42d912570cd2781de688e55e8a1", + "name": "flask-socketio", + "sha256": "fdf50e65a8102bdd407bff7a64f2476f4df4eb1bf5b6bf24708e40735c00edf8", + "size": 26111, + "subdir": "linux-64", + "timestamp": 1512043284131, + "version": "2.9.2" + }, + "flask-socketio-2.9.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c5d336754c43a76b2d5d599dfd2f0ed", + "name": "flask-socketio", + "sha256": "35486a155f95afb368d4337ca81502e01642609ee0113f0b7ece7d17c8403103", + "size": 26074, + "subdir": "linux-64", + "timestamp": 1522193682046, + "version": "2.9.3" + }, + "flask-socketio-2.9.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.5,<3.6.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b87ebf909106a917f3defc7614e42d0", + "name": "flask-socketio", + "sha256": "15d71ba7554901b3637d0b0b46c4b8eb67cb74f76935a0e1b5dfc2a5836cd251", + "size": 26372, + "subdir": "linux-64", + "timestamp": 1522193698117, + "version": "2.9.3" + }, + "flask-socketio-2.9.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bce1ba7a31f942c39f606ca3d3503743", + "name": "flask-socketio", + "sha256": "ebc07ed744ca7cbb81ba1cedbe87289b8ef9c8a7be94dc8944ca5d2d526729de", + "size": 26181, + "subdir": "linux-64", + "timestamp": 1522193699559, + "version": "2.9.3" + }, + "flask-socketio-2.9.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb5522e271bf41cc1ec5d3f10b74a290", + "name": "flask-socketio", + "sha256": "51a939e4d3a66a85ea51d07bbaec2cc259a6169bb1e826e61fe7ee373ff06c99", + "size": 26310, + "subdir": "linux-64", + "timestamp": 1522096773375, + "version": "2.9.6" + }, + "flask-socketio-2.9.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.5,<3.6.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "472b50e6a756d73e78b7c926bf154a79", + "name": "flask-socketio", + "sha256": "425d616331ae4a7ce6770fc6cd2dd8ef8b218c8431556d683b44946bec42dc54", + "size": 26464, + "subdir": "linux-64", + "timestamp": 1522096823780, + "version": "2.9.6" + }, + "flask-socketio-2.9.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c985fd4aac1604884ff31438facfa69", + "name": "flask-socketio", + "sha256": "1bea712c53ba3bce65b945ff869544848ce208aeb085d9a1957a843d88bb7d75", + "size": 26441, + "subdir": "linux-64", + "timestamp": 1522096825021, + "version": "2.9.6" + }, + "flask-socketio-3.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4ea8ebad9f70aae398b5ca18988f9b0", + "name": "flask-socketio", + "sha256": "b104012beb9a6d032ec21662a4fb78620dc042a3634d3036c7984c0aefa7aea7", + "size": 26426, + "subdir": "linux-64", + "timestamp": 1526939404685, + "version": "3.0.0" + }, + "flask-socketio-3.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.5,<3.6.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e3a35c9dd5d7f019ed4e81873042eaa3", + "name": "flask-socketio", + "sha256": "c90bed212e2d300f070d45cbf863537bd6a62858566f5ee26151795b0c9d31dc", + "size": 26574, + "subdir": "linux-64", + "timestamp": 1526939419261, + "version": "3.0.0" + }, + "flask-socketio-3.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de545ce2e9fe057fe09fc472688d8a4f", + "name": "flask-socketio", + "sha256": "5fcbc532ed8875935da46240ddc58062ba9153c3a6977dc59702328af9381100", + "size": 26588, + "subdir": "linux-64", + "timestamp": 1526939383857, + "version": "3.0.0" + }, + "flask-socketio-3.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83e3095ab578c427fe76b3a038d34a60", + "name": "flask-socketio", + "sha256": "9a0553e08e53929f6eaafa9cc8902437f9061d5216c1b514bfb5202c8c11cee8", + "size": 26625, + "subdir": "linux-64", + "timestamp": 1528221809127, + "version": "3.0.1" + }, + "flask-socketio-3.0.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.5,<3.6.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "961a39033bdb6d19cce8619098d06855", + "name": "flask-socketio", + "sha256": "00f3524c9b9bc24506b5f119e2900eeeabc96d132145639726860e65fef1b0e0", + "size": 26845, + "subdir": "linux-64", + "timestamp": 1528221822694, + "version": "3.0.1" + }, + "flask-socketio-3.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "94d673f78e7ea42a8d7fa3b2839ff2b1", + "name": "flask-socketio", + "sha256": "61633361147e433c6cdc38a940311c71f79acf72c00d7158f92ae1792ca2a05a", + "size": 26558, + "subdir": "linux-64", + "timestamp": 1528221796599, + "version": "3.0.1" + }, + "flask-socketio-3.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.7,<3.8.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f8c4745b4bcca1793552ee07fa81ce1", + "name": "flask-socketio", + "sha256": "b5a0baf42cdbc987d87ced036e977042fb1dc8f47aee956b1a40649e55e8af39", + "size": 26542, + "subdir": "linux-64", + "timestamp": 1530877568507, + "version": "3.0.1" + }, + "flask-socketio-3.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a1a7998aff1494684a0e930d11323c8", + "name": "flask-socketio", + "sha256": "acc659767f15c09c03532847a186eab19dc4e8bd37f8562e3eb3583603d295e9", + "size": 27356, + "subdir": "linux-64", + "timestamp": 1539656511789, + "version": "3.0.2" + }, + "flask-socketio-3.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a4b78b4ad64aaf8a5b89fa7cbabf80f", + "name": "flask-socketio", + "sha256": "8b28d9e191e23e9375408160d761857f83834682343e27b60b035e0718fdea7b", + "size": 27685, + "subdir": "linux-64", + "timestamp": 1539656530287, + "version": "3.0.2" + }, + "flask-socketio-3.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.7,<3.8.0a0", + "python-socketio >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6448f15e55d4c6f493f2a94bb713fcdb", + "name": "flask-socketio", + "sha256": "b0f8f7602a4ca6f4061dd74fe410bb4747856a27d3a502b07ff84bb8003aaa7b", + "size": 27688, + "subdir": "linux-64", + "timestamp": 1539656533110, + "version": "3.0.2" + }, + "flask-socketio-3.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "python-socketio >=2.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2c9f3db4bea040a7cc844ce078ec6b3", + "name": "flask-socketio", + "sha256": "87d25fd81fad31d6f1bf942b18b2c44b59f622eb41f9ac8cfb931fdcb99567a0", + "size": 27489, + "subdir": "linux-64", + "timestamp": 1545166972153, + "version": "3.1.1" + }, + "flask-socketio-3.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "python-socketio >=2.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0e92f97a1be40a96680f9a441bee3ea", + "name": "flask-socketio", + "sha256": "628a0012bb809e31582789f6e7834f95d6d43647075b9c52ee8d01eff567e5b0", + "size": 27586, + "subdir": "linux-64", + "timestamp": 1545167026157, + "version": "3.1.1" + }, + "flask-socketio-3.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.7,<3.8.0a0", + "python-socketio >=2.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8419bd1c656bcc2d92241e11f27cf27", + "name": "flask-socketio", + "sha256": "c9158a7d9fdf9784021c60c1f0cec4526b1f412812fba59989b339d9d8ecbecc", + "size": 27612, + "subdir": "linux-64", + "timestamp": 1545167027548, + "version": "3.1.1" + }, + "flask-socketio-3.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=2.7,<2.8.0a0", + "python-socketio >=2.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3beb95ee6ded0d7c8f0106997943ff2c", + "name": "flask-socketio", + "sha256": "581416218b4fb238253907f7eef6d90e7ca91120f90e09520a41857e906c0b6e", + "size": 30079, + "subdir": "linux-64", + "timestamp": 1547229204605, + "version": "3.1.2" + }, + "flask-socketio-3.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.6,<3.7.0a0", + "python-socketio >=2.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d5f67994769110a69b3ea04bcc306da", + "name": "flask-socketio", + "sha256": "59ea0016c19b9cf48a331c9f81a474b895beb5d76e8a6a305653d2d78baac828", + "size": 30213, + "subdir": "linux-64", + "timestamp": 1547229207623, + "version": "3.1.2" + }, + "flask-socketio-3.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.7,<3.8.0a0", + "python-socketio >=2.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ced4a5b2915a939b3b9b5b0c7a87e31d", + "name": "flask-socketio", + "sha256": "13a4d9ecdfa39013195c680e0cbeb45d22337c63c8f4f8bc25ad6dd0b67e0108", + "size": 30105, + "subdir": "linux-64", + "timestamp": 1547229233734, + "version": "3.1.2" + }, + "flask-socketio-5.3.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.10,<3.11.0a0", + "python-socketio >=5.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2fcb2dab36ffad503bdc6371b9a97207", + "name": "flask-socketio", + "sha256": "25eae596fbf81455507b781df876162f398c36a4a37c448766b2f33c47125716", + "size": 32035, + "subdir": "linux-64", + "timestamp": 1669060278710, + "version": "5.3.1" + }, + "flask-socketio-5.3.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.11,<3.12.0a0", + "python-socketio >=5.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0ab0aa474e545f8cde47ccddd594858", + "name": "flask-socketio", + "sha256": "d4067c2724f555faea8d9fe794e66165da47ed31716728edcadf7345e203ad88", + "size": 36773, + "subdir": "linux-64", + "timestamp": 1676852472081, + "version": "5.3.1" + }, + "flask-socketio-5.3.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.7,<3.8.0a0", + "python-socketio >=5.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39ae6b6c9e4dc7cb34379a895b80f25c", + "name": "flask-socketio", + "sha256": "9b457cac002110ba98485c3d3bfc08d2b454c66fc61e401cc9f1a20b48a0cfd9", + "size": 31801, + "subdir": "linux-64", + "timestamp": 1669060307821, + "version": "5.3.1" + }, + "flask-socketio-5.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.8,<3.9.0a0", + "python-socketio >=5.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d927a59180ce49de168bcc2fc43f7049", + "name": "flask-socketio", + "sha256": "42fc10d384da238d5e2c94af8166f33b544f874dfdedc144f3afcebba353a805", + "size": 31914, + "subdir": "linux-64", + "timestamp": 1669060249099, + "version": "5.3.1" + }, + "flask-socketio-5.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=0.9", + "python >=3.9,<3.10.0a0", + "python-socketio >=5.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ec8badbbbcf20a86c4ab570555e4639", + "name": "flask-socketio", + "sha256": "36ce0321d0b6fdb5b5f239ac77ffe7d1c39f4c2c540c3768a5a991ca03e50555", + "size": 31976, + "subdir": "linux-64", + "timestamp": 1669060336743, + "version": "5.3.1" + }, + "flask-sqlalchemy-2.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flask >=0.10", + "python >=2.7,<2.8.0a0", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bfbea675f543918e5ac00a9651569fc0", + "name": "flask-sqlalchemy", + "sha256": "adca1e245cc1d09af5f1682fd014def71d7b295f2ab4a10c3374a331799ed9f2", + "size": 28828, + "subdir": "linux-64", + "timestamp": 1536858960389, + "version": "2.3.2" + }, + "flask-sqlalchemy-2.3.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flask >=0.10", + "python >=3.5,<3.6.0a0", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "910f9eeca1f6321c4f71e63850776b10", + "name": "flask-sqlalchemy", + "sha256": "5f15aa9b78b856964ae1edfcdbe87aca28a63c7016990ecb30c35839d7ce07ac", + "size": 29144, + "subdir": "linux-64", + "timestamp": 1536858754356, + "version": "2.3.2" + }, + "flask-sqlalchemy-2.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flask >=0.10", + "python >=3.6,<3.7.0a0", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9b192ec0e2b7b5ea5846729c7040bfee", + "name": "flask-sqlalchemy", + "sha256": "fe3626b1410178988bc5e5ef0528d1bcec5b528f35b942e12acd81339e552f6e", + "size": 28655, + "subdir": "linux-64", + "timestamp": 1536858974213, + "version": "2.3.2" + }, + "flask-sqlalchemy-2.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flask >=0.10", + "python >=3.7,<3.8.0a0", + "sqlalchemy >=0.8.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "be42ae2d627dca4a525a20375cc2dd70", + "name": "flask-sqlalchemy", + "sha256": "ba404efff19069804030c8074acfa38d2afc4346cc54e007667f9a35a7cbc062", + "size": 28995, + "subdir": "linux-64", + "timestamp": 1536858675607, + "version": "2.3.2" + }, + "flask-sqlalchemy-3.0.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=2.2", + "python >=3.10,<3.11.0a0", + "sqlalchemy >=1.4.18" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ab70eefc74a98989c9384d276b5c8cb1", + "name": "flask-sqlalchemy", + "sha256": "863d5252e1b40ace5ab524e83c418f6480dd918de8080e4af458738c5de0ed49", + "size": 40377, + "subdir": "linux-64", + "timestamp": 1671219175110, + "version": "3.0.2" + }, + "flask-sqlalchemy-3.0.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=2.2", + "python >=3.11,<3.12.0a0", + "sqlalchemy >=1.4.18" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aa46a4353e4475b5a13fee6c1c1c4108", + "name": "flask-sqlalchemy", + "sha256": "5cafe4646e546e35fe70527bac7880996379926032687d0ed63072d198c4de88", + "size": 45759, + "subdir": "linux-64", + "timestamp": 1676827797884, + "version": "3.0.2" + }, + "flask-sqlalchemy-3.0.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=2.2", + "python >=3.7,<3.8.0a0", + "sqlalchemy >=1.4.18" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "839a58cfd3e7350367e352bf4d34e37e", + "name": "flask-sqlalchemy", + "sha256": "224cb5f2ab623a491930c510917d5e24ca3b1806be959753850e7c60a86f9506", + "size": 39744, + "subdir": "linux-64", + "timestamp": 1671219228473, + "version": "3.0.2" + }, + "flask-sqlalchemy-3.0.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=2.2", + "python >=3.8,<3.9.0a0", + "sqlalchemy >=1.4.18" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d260f7dd7af21c2466e22ca9d3a518c", + "name": "flask-sqlalchemy", + "sha256": "8da3bb488e78b3c4fa8e97a05ea5009798cea7a07c97a1811d2baa7776403842", + "size": 39802, + "subdir": "linux-64", + "timestamp": 1671219201525, + "version": "3.0.2" + }, + "flask-sqlalchemy-3.0.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flask >=2.2", + "python >=3.9,<3.10.0a0", + "sqlalchemy >=1.4.18" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e437a72f68ea718e0551d4b3349fb45f", + "name": "flask-sqlalchemy", + "sha256": "bbfa801420f4f500332434f03c007aaebdcfd9e659f9f63c9f92c7edfcaf1b0c", + "size": 39920, + "subdir": "linux-64", + "timestamp": 1671219148094, + "version": "3.0.2" + }, + "flask-wtf-0.14.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "flask", + "python >=2.7,<2.8.0a0", + "werkzeug", + "wtforms" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f83d155a866717be2dfcdeb83d1d0c2a", + "name": "flask-wtf", + "sha256": "ce29625e952f77902e8bbbe8a318c83a6912fbbfd529e8e4093f56f000f9acbc", + "size": 25328, + "subdir": "linux-64", + "timestamp": 1537198180595, + "version": "0.14.2" + }, + "flask-wtf-0.14.2-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "flask", + "python >=3.5,<3.6.0a0", + "werkzeug", + "wtforms" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6b6da99555de725c24b26e6f72fba99b", + "name": "flask-wtf", + "sha256": "50112315aa69aa8175a2dc7407c95037dd6d5d29cac7a1cf0e874b553216d377", + "size": 25680, + "subdir": "linux-64", + "timestamp": 1537198197999, + "version": "0.14.2" + }, + "flask-wtf-0.14.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "flask", + "python >=3.6,<3.7.0a0", + "werkzeug", + "wtforms" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f6795441912b70cde29c0bb3b467c36b", + "name": "flask-wtf", + "sha256": "7306f4800f342b77c73accd2c80ac50c74f730597fb8f0d59256d7c3737a3c2e", + "size": 25316, + "subdir": "linux-64", + "timestamp": 1537198210598, + "version": "0.14.2" + }, + "flask-wtf-0.14.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "flask", + "python >=3.7,<3.8.0a0", + "werkzeug", + "wtforms" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "604bf1b74f40ce4e2147891df13a0241", + "name": "flask-wtf", + "sha256": "3de68ee2a15f7d3db263fd689a8af1911e1138d0a196ce59cbfaad6047bc595a", + "size": 25355, + "subdir": "linux-64", + "timestamp": 1537203907549, + "version": "0.14.2" + }, + "flask-wtf-1.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "email-validator", + "flask", + "itsdangerous", + "python >=3.10,<3.11.0a0", + "werkzeug", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e2c9c1b23ac4d2cb1ab06328c4fd25b5", + "name": "flask-wtf", + "sha256": "86ef505bd80cdb4d2f0362d27fdbf8f32288d22c4698396eeb2821a5d6ef105f", + "size": 24419, + "subdir": "linux-64", + "timestamp": 1668812635933, + "version": "1.0.1" + }, + "flask-wtf-1.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "email-validator", + "flask", + "itsdangerous", + "python >=3.11,<3.12.0a0", + "werkzeug", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e8f9443fbd482bcee5a6fa38d2c5ec8b", + "name": "flask-wtf", + "sha256": "284b8255a0ff1417f6e4592a1c16e243b957605594a0ba840c7c386b19af7cda", + "size": 28225, + "subdir": "linux-64", + "timestamp": 1676827882149, + "version": "1.0.1" + }, + "flask-wtf-1.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "email-validator", + "flask", + "itsdangerous", + "python >=3.7,<3.8.0a0", + "werkzeug", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "74e4e1386bbb83023dc48830ef833e21", + "name": "flask-wtf", + "sha256": "a29c9195a4abe45bc27e331a774e8a003ee64ab9cd7471c2bdc4680fa8f87f57", + "size": 24208, + "subdir": "linux-64", + "timestamp": 1668812606714, + "version": "1.0.1" + }, + "flask-wtf-1.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "email-validator", + "flask", + "itsdangerous", + "python >=3.8,<3.9.0a0", + "werkzeug", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d4aa5c0fce1fccc738718b8dacb755df", + "name": "flask-wtf", + "sha256": "65e89dbdf0cfb69086a8058728d05c3f72a76928edfe55bedda3da54acf4eeb9", + "size": 24309, + "subdir": "linux-64", + "timestamp": 1668812577936, + "version": "1.0.1" + }, + "flask-wtf-1.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "email-validator", + "flask", + "itsdangerous", + "python >=3.9,<3.10.0a0", + "werkzeug", + "wtforms" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85717604a8ece3952454f05559a5750b", + "name": "flask-wtf", + "sha256": "5424ab9866b7c861a9de6afdf9fe691067fa093e439f6a3f275abccf6db342de", + "size": 24287, + "subdir": "linux-64", + "timestamp": 1668812549179, + "version": "1.0.1" + }, + "flatbuffers-1.10.0-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "md5": "68cd5147f20a401c0e165873be49d883", + "name": "flatbuffers", + "sha256": "fea4f8fafb9595d555ff95657c584a1b6756b563e789378667e52182ae742dfa", + "size": 678363, + "subdir": "linux-64", + "timestamp": 1553104261966, + "version": "1.10.0" + }, + "flatbuffers-1.11.0-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "md5": "cbbe456d5adc4aa622b896d80700aa94", + "name": "flatbuffers", + "sha256": "95dc65c6da8109e3da0ead919248ae2a06480b79dfb089a7144acc0cd1a7aedb", + "size": 724521, + "subdir": "linux-64", + "timestamp": 1559064706994, + "version": "1.11.0" + }, + "flatbuffers-1.12.0-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "md5": "29c830a6264575942f3518dcf7f8e115", + "name": "flatbuffers", + "sha256": "cec2674a41e1943af170f888bd5b8ec1e788db1235ab5c85c705652c652855b7", + "size": 916755, + "subdir": "linux-64", + "timestamp": 1607037188008, + "version": "1.12.0" + }, + "flatbuffers-1.7.1-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "md5": "f839a2c9e5bffb7d67c0420987cc368b", + "name": "flatbuffers", + "sha256": "3f25da2ccf0245fd678882bf328637e094bf10710b283884ae252bb664d4fb46", + "size": 451138, + "subdir": "linux-64", + "timestamp": 1529361984513, + "version": "1.7.1" + }, + "flatbuffers-2.0.0-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "md5": "11016db84e6bea7597a8e90ee8a22e20", + "name": "flatbuffers", + "sha256": "983acc959371599d1b64e16e17c13b323deb359abdcf92ecae9a490bbc6e0777", + "size": 998240, + "subdir": "linux-64", + "timestamp": 1620825878215, + "version": "2.0.0" + }, + "flex-2.6.4-ha10e3a4_1.conda": { + "build": "ha10e3a4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "m4" + ], + "license": "BSD 2-Clause", + "md5": "8a9eaf084a1ab5f678ca6d602c65e348", + "name": "flex", + "sha256": "6412c08324f4459fa8706b40f812341831cf61fcff8428268a7f74bfa18d7b22", + "size": 315377, + "subdir": "linux-64", + "timestamp": 1505728637175, + "version": "2.6.4" + }, + "flit-1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils", + "pip", + "python >=3.5,<3.6.0a0", + "pytoml", + "requests", + "requests_download", + "zipfile36" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "99f76c6f7e86c5f0740a9b5558754cd8", + "name": "flit", + "sha256": "ba14eeccea194586b8b06e731e0acfad5d1d217020c73a37cbe458524574ab0e", + "size": 84944, + "subdir": "linux-64", + "timestamp": 1529953172115, + "version": "1.0" + }, + "flit-1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils", + "pip", + "python >=3.6,<3.7.0a0", + "pytoml", + "requests", + "requests_download" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "99302124cea9b0dcc3abf89d2537df6a", + "name": "flit", + "sha256": "ef50400350e84c2f032e6fbbb957cc7950b18f28ff71a0f4d4e26cbdd1823334", + "size": 83702, + "subdir": "linux-64", + "timestamp": 1529952774915, + "version": "1.0" + }, + "flit-1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils", + "pip", + "python >=3.7,<3.8.0a0", + "pytoml", + "requests", + "requests_download" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "49dc87bfffed58435abdb97d23dfcf5a", + "name": "flit", + "sha256": "96a1efd0ab0169980c31806ff964c9abd24c99559d73c171f1bc66d6bcc1b236", + "size": 84150, + "subdir": "linux-64", + "timestamp": 1530898115696, + "version": "1.0" + }, + "flit-1.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "docutils", + "pip", + "python >=3.5,<3.6.0a0", + "pytoml", + "requests", + "requests_download", + "zipfile36" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e2dbaaffada93c045ae880137e0480d0", + "name": "flit", + "sha256": "9436300c0ecd07d54e2406996c31656404ca33a5cc3163575ea20e84378d7ba4", + "size": 87864, + "subdir": "linux-64", + "timestamp": 1535511849349, + "version": "1.1" + }, + "flit-1.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "docutils", + "pip", + "python >=3.6,<3.7.0a0", + "pytoml", + "requests", + "requests_download" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "786ce641193630a1212c8ed528d13721", + "name": "flit", + "sha256": "4c73683f033266c0e10412c1a071151857292c40c978a9f7a02fd3649e4ac2a8", + "size": 86876, + "subdir": "linux-64", + "timestamp": 1535511828059, + "version": "1.1" + }, + "flit-1.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "docutils", + "pip", + "python >=3.7,<3.8.0a0", + "pytoml", + "requests", + "requests_download" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "25456548f235bb8ec8d60cea3c4e876b", + "name": "flit", + "sha256": "db5ce09035cbc44d0d24992ec635644531e2e75bf4f373e9ff931c15b624c653", + "size": 86127, + "subdir": "linux-64", + "timestamp": 1535511841879, + "version": "1.1" + }, + "flit-1.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils", + "pip", + "python >=3.6,<3.7.0a0", + "pytoml", + "requests", + "requests_download" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e4538f09b49ed38ddcb0446823a4344", + "name": "flit", + "sha256": "b961b66dca026e96441ad5fc2c9d4afd833b812252308ba1a7b4e24f5fe3719f", + "size": 87078, + "subdir": "linux-64", + "timestamp": 1538861582139, + "version": "1.2.1" + }, + "flit-1.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils", + "pip", + "python >=3.7,<3.8.0a0", + "pytoml", + "requests", + "requests_download" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "502d33fa20618da3992284ac2c3e76a6", + "name": "flit", + "sha256": "15b5b74ae32109fff7b51d750119a3d76d4dd79faae634c76ee1a51149c766e2", + "size": 87838, + "subdir": "linux-64", + "timestamp": 1538861561713, + "version": "1.2.1" + }, + "flit-1.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils", + "pip", + "python >=3.6,<3.7.0a0", + "pytoml", + "requests", + "requests_download" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cc1d558c4dff77feaa2b96202fa35ed9", + "name": "flit", + "sha256": "817122ff70f57426437dba5afb24effd646a7cb197c1ce2e0b61c6bd9bbc4720", + "size": 89470, + "subdir": "linux-64", + "timestamp": 1552377724665, + "version": "1.3" + }, + "flit-1.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils", + "pip", + "python >=3.7,<3.8.0a0", + "pytoml", + "requests", + "requests_download" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e0f4e39a39c9f4b6d3c9afc480f5ffe6", + "name": "flit", + "sha256": "44f739101a8f232a2c3b46c7c80b357a9d20c9fb0a695f0129af75ad9221d71d", + "size": 88866, + "subdir": "linux-64", + "timestamp": 1552377662968, + "version": "1.3" + }, + "flit-3.8.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "flit-core 3.8.0 py310h06a4308_0", + "pip", + "python >=3.10,<3.11.0a0", + "requests", + "tomli-w" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "64306b55a285e857021148265148b9f1", + "name": "flit", + "sha256": "384788e10c88cc158ed35735a9732595710e3a3fe4dca7edc6b007e820d819dd", + "size": 75276, + "subdir": "linux-64", + "timestamp": 1679397202550, + "version": "3.8.0" + }, + "flit-3.8.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "flit-core 3.8.0 py311h06a4308_0", + "pip", + "python >=3.11,<3.12.0a0", + "requests", + "tomli-w" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5caddac24f456926aaccfb6be219b08d", + "name": "flit", + "sha256": "c94ce7f5f08cac9f5ff8f7eb1f7f8196769ae92243bf2ac674e79935d7e187b8", + "size": 95551, + "subdir": "linux-64", + "timestamp": 1679397299181, + "version": "3.8.0" + }, + "flit-3.8.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "flit-core 3.8.0 py38h06a4308_0", + "pip", + "python >=3.8,<3.9.0a0", + "requests", + "tomli-w" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c5d93592abe3c8bdab15cb56611046be", + "name": "flit", + "sha256": "58bd5919707584c8a8637b2d77729b464113d1c1d3d86bc7c56295cc8c7d4159", + "size": 74478, + "subdir": "linux-64", + "timestamp": 1679397250372, + "version": "3.8.0" + }, + "flit-3.8.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "flit-core 3.8.0 py39h06a4308_0", + "pip", + "python >=3.9,<3.10.0a0", + "requests", + "tomli-w" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "43dfcdc047bfef1e04846f1753ab174b", + "name": "flit", + "sha256": "bcfedc7db1316f24d83f167b5f50a6ed05d48e1550d693cd195035a5ddec6f2e", + "size": 73931, + "subdir": "linux-64", + "timestamp": 1679397153552, + "version": "3.8.0" + }, + "flit-core-3.8.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "09000e804811d7cc51a2bfd597555f7e", + "name": "flit-core", + "sha256": "a2ada6bb5aea54b3ac8eded9f18475c791730e098f6498721b6a1f268e6abd02", + "size": 85707, + "subdir": "linux-64", + "timestamp": 1679397188810, + "version": "3.8.0" + }, + "flit-core-3.8.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5c9f331463fe859ee5c864ffa61ba0c5", + "name": "flit-core", + "sha256": "61125c1122419818c7eb486113044257c245a29b8e27e97e641ee0d77e6147f5", + "size": 113914, + "subdir": "linux-64", + "timestamp": 1679397285296, + "version": "3.8.0" + }, + "flit-core-3.8.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3142f4cf7655ed5e2ae24bcc301a62f5", + "name": "flit-core", + "sha256": "e75c436161c4a9b134a1dfc4ed6e4dace9a2ad6751c1ae1eb876af620202d625", + "size": 85631, + "subdir": "linux-64", + "timestamp": 1679397237065, + "version": "3.8.0" + }, + "flit-core-3.8.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7639e1dab812ee52e0752c0de7ec0974", + "name": "flit-core", + "sha256": "bb43d51c34abaa6b57bd963e407ddc3544e6fd1902d241b8af4734d98eac33ea", + "size": 85864, + "subdir": "linux-64", + "timestamp": 1679397140311, + "version": "3.8.0" + }, + "flit-scm-1.7.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.5.0,<4", + "python >=3.10,<3.11.0a0", + "setuptools_scm >=6.4", + "tomli" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c67a6a5d037d1f038cbe79f033f55ee7", + "name": "flit-scm", + "sha256": "a1c3925afaa43080471471a1e33f7f71da588904ca2d286ca6691de81525d7de", + "size": 8230, + "subdir": "linux-64", + "timestamp": 1668696594888, + "version": "1.7.0" + }, + "flit-scm-1.7.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.5.0,<4", + "python >=3.11,<3.12.0a0", + "setuptools_scm >=6.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb767e46b120136d7a23e6b13aa14084", + "name": "flit-scm", + "sha256": "07df157bffb4e8979cfb0e0e7d636b3585110ca671638038b5e600a3df996e77", + "size": 8777, + "subdir": "linux-64", + "timestamp": 1676827167888, + "version": "1.7.0" + }, + "flit-scm-1.7.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.5.0,<4", + "python >=3.7,<3.8.0a0", + "setuptools_scm >=6.4", + "tomli" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2e039ed64feeb56660e3f1c342fe876", + "name": "flit-scm", + "sha256": "13a40fecc9a342db3a05ccfee40f9c89a005b0f573c68083516e1372214a61ce", + "size": 8216, + "subdir": "linux-64", + "timestamp": 1668696566220, + "version": "1.7.0" + }, + "flit-scm-1.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.5.0,<4", + "python >=3.8,<3.9.0a0", + "setuptools_scm >=6.4", + "tomli" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "531a39521b3cf7e7818f46d9fbacd3bd", + "name": "flit-scm", + "sha256": "06eb754b781136a7eeaf03d936db18f7fd94af15a7f746b708ddb32cf3c53e33", + "size": 8203, + "subdir": "linux-64", + "timestamp": 1668696623276, + "version": "1.7.0" + }, + "flit-scm-1.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.5.0,<4", + "python >=3.9,<3.10.0a0", + "setuptools_scm >=6.4", + "tomli" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "81c48b76ab1010a975d85472692499a4", + "name": "flit-scm", + "sha256": "1e6d386adce9e550757714608eaca8cb83aedd3d6e14ba6e85c97ba27166b660", + "size": 8183, + "subdir": "linux-64", + "timestamp": 1668696651688, + "version": "1.7.0" + }, + "flite-2.2-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "md5": "6569d19dea515ad5e104e1666d5405ee", + "name": "flite", + "sha256": "97cc2a61748be8335d9922177259928200d9ce2ebde1912710f53e333e30360e", + "size": 18496146, + "subdir": "linux-64", + "timestamp": 1600349410028, + "version": "2.2" + }, + "fmt-7.1.3-hff7bd54_0.conda": { + "build": "hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9941d74cd6fe25febc41b969981cf84c", + "name": "fmt", + "sha256": "88e5f043bdca76803eb47032699bfcd001b3abb86db8fbc378b51edd68a69f36", + "size": 180382, + "subdir": "linux-64", + "timestamp": 1608223474733, + "version": "7.1.3" + }, + "fmt-8.1.1-hd09550d_1.conda": { + "build": "hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b8b22c0e94da603f04f390a74d4953e", + "name": "fmt", + "sha256": "976435d5c6327a9c25228c65c861aea26faf22727849e6691567b6de90e48aa0", + "size": 178124, + "subdir": "linux-64", + "timestamp": 1646411305067, + "version": "8.1.1" + }, + "fmt-9.1.0-hdb19cb5_0.conda": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1dd1acc970d91f52034e0e9afd0190a4", + "name": "fmt", + "sha256": "68f03e132f5199c55554884063c5d7b661a70fed35646cca32ca1413cf3fe224", + "size": 198981, + "subdir": "linux-64", + "timestamp": 1676360280858, + "version": "9.1.0" + }, + "folium-0.14.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "branca >=0.6.0", + "jinja2 >=2.9", + "numpy", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e5c014a8f16935ae9db0d708edbf8dc3", + "name": "folium", + "sha256": "bf6dc2e194c4a697dd937b5f09471ea59ccf11932b30f185e810b9b60bb5ed4f", + "size": 115715, + "subdir": "linux-64", + "timestamp": 1675353541104, + "version": "0.14.0" + }, + "folium-0.14.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "branca >=0.6.0", + "jinja2 >=2.9", + "numpy", + "python >=3.11,<3.12.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ccb8ca695c6450a757a7c0221f02ff10", + "name": "folium", + "sha256": "d8b33dd85fae3518bf99379d6116b6b74ff8389f10bd05dd5349a1e03618193f", + "size": 130823, + "subdir": "linux-64", + "timestamp": 1676852488567, + "version": "0.14.0" + }, + "folium-0.14.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "branca >=0.6.0", + "jinja2 >=2.9", + "numpy", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "455a06bd2eec7c6dd9202c2139708ee4", + "name": "folium", + "sha256": "7e60f273c699e941f182fd7b091ec552dc753916c9dd918be6c5a9172beb037c", + "size": 113937, + "subdir": "linux-64", + "timestamp": 1675353434617, + "version": "0.14.0" + }, + "folium-0.14.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "branca >=0.6.0", + "jinja2 >=2.9", + "numpy", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "251d00a3e761fd9e76b8218914e09e6c", + "name": "folium", + "sha256": "518fa5766dadf5d06cdf938c4b6b32850de6278fb8364b200bb5615046a285ff", + "size": 114437, + "subdir": "linux-64", + "timestamp": 1675353472060, + "version": "0.14.0" + }, + "folium-0.14.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "branca >=0.6.0", + "jinja2 >=2.9", + "numpy", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f05b46d5ff801825b79f057d626cd5d8", + "name": "folium", + "sha256": "f199e0df0e0027c7ead48a485fa0f3a9ada3d06c2645fd4d2962423cd0ea3c23", + "size": 114753, + "subdir": "linux-64", + "timestamp": 1675353507823, + "version": "0.14.0" + }, + "fontconfig-2.12.4-h88586e7_1.conda": { + "build": "h88586e7_1", + "build_number": 1, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libxml2 >=2.9.4,<2.10.0a0" + ], + "license": "MIT", + "md5": "2b732c574883c433f37621387285e103", + "name": "fontconfig", + "sha256": "f04b96cfce41be414c72bd3b68ef3ac85759cb29b5ceb484235558a2f782562a", + "size": 224850, + "subdir": "linux-64", + "timestamp": 1505734186823, + "version": "2.12.4" + }, + "fontconfig-2.12.6-h49f89f6_0.conda": { + "build": "h49f89f6_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libxml2 >=2.9.7,<2.10.0a0" + ], + "license": "MIT", + "md5": "6ad85ecf112bfaf060274426f9dbb8a0", + "name": "fontconfig", + "sha256": "00b84998325c39cbc583d710f9f760d30e6d61549502d1a2039db47ea9a446a9", + "size": 226220, + "subdir": "linux-64", + "timestamp": 1520614595614, + "version": "2.12.6" + }, + "fontconfig-2.13.0-h23c43c1_0.conda": { + "build": "h23c43c1_0", + "build_number": 0, + "depends": [ + "freetype >=2.9,<3.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.7,<2.10.0a0" + ], + "license": "MIT", + "md5": "0e451f9870acc0b3c65f8ac59401cf04", + "name": "fontconfig", + "sha256": "bae3efebca9b49ce1af3ed83c0ff7d62ef42e244d3025cee487956a901cedd05", + "size": 234226, + "subdir": "linux-64", + "timestamp": 1522464465668, + "version": "2.13.0" + }, + "fontconfig-2.13.0-h9420a91_0.conda": { + "build": "h9420a91_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0" + ], + "license": "MIT", + "md5": "e7f4d02e3204e867b6642753b6986b99", + "name": "fontconfig", + "sha256": "ffe86ebaaefc301ebb5c79cbd278bbcdd0df0b895a909650c9e234cd32c44117", + "size": 232720, + "subdir": "linux-64", + "timestamp": 1527253867511, + "version": "2.13.0" + }, + "fontconfig-2.13.1-h6c09931_0.conda": { + "build": "h6c09931_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.10,<2.10.0a0" + ], + "license": "MIT", + "md5": "fa04e89166d4b44326c6d76e2f708715", + "name": "fontconfig", + "sha256": "fa9d98e9653b68717f4cf09f3abfd364c84ac89e2190b976a8f1bb8771b80115", + "size": 255817, + "subdir": "linux-64", + "timestamp": 1612452969808, + "version": "2.13.1" + }, + "fontconfig-2.13.1-hef1e5e3_1.conda": { + "build": "hef1e5e3_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.14,<2.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "104cd6f83a6edd3e1fd662887f4bc215", + "name": "fontconfig", + "sha256": "7396e23788b7c171f9ec0ae8967fc09aad60b03a95d6805729b1f7163c5da679", + "size": 265906, + "subdir": "linux-64", + "timestamp": 1667568393817, + "version": "2.13.1" + }, + "fontconfig-2.14.1-h4c34cd2_2.conda": { + "build": "h4c34cd2_2", + "build_number": 2, + "depends": [ + "expat >=2.4.9,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "libxml2 >=2.10.3,<2.11.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f0b472f5b544f8d57beb09ed4a2932e1", + "name": "fontconfig", + "sha256": "25ebd0146f136dcbb923d45f184366bae0ffc06c3d55dd6ade2cb6ba9c3af000", + "size": 288248, + "subdir": "linux-64", + "timestamp": 1679578197653, + "version": "2.14.1" + }, + "fontconfig-2.14.1-h52c9d5c_1.conda": { + "build": "h52c9d5c_1", + "build_number": 1, + "depends": [ + "expat >=2.4.9,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd3f711abef17203045b7bcfc83fac2f", + "name": "fontconfig", + "sha256": "30902d9e2575e212b14c798465ba8eea5cbd4024bc88e933893c9e29a2bf616d", + "size": 288035, + "subdir": "linux-64", + "timestamp": 1671001523785, + "version": "2.14.1" + }, + "fontconfig-2.14.1-hef1e5e3_0.conda": { + "build": "hef1e5e3_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ade72b21d7ef60f012c3ca269a3e267e", + "name": "fontconfig", + "sha256": "aea3873d3c2426cf79c6d69c9035067a8e6916b6797a0b408fb121c31cf23403", + "size": 290997, + "subdir": "linux-64", + "timestamp": 1670019602470, + "version": "2.14.1" + }, + "freeglut-3.0.0-hf484d3e_5.conda": { + "build": "hf484d3e_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b036f88ede337fcb45e94f15a72eb017", + "name": "freeglut", + "sha256": "6556d96614bdddb1f95613946902f0480c853d4b71bcf0f079df34d45d9d71ee", + "size": 179717, + "subdir": "linux-64", + "timestamp": 1520767673427, + "version": "3.0.0" + }, + "freetds-1.00.83-hb7f436b_0.conda": { + "build": "hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2n,<1.0.3a", + "readline >=7.0,<8.0a0", + "unixodbc >=2.3.5,<2.4.0a0" + ], + "license": "GPL-2", + "license_family": "GPL2", + "md5": "9c1b91291c0dae65147f38ad3c41546e", + "name": "freetds", + "sha256": "40d8f63c4d6ddec83547db2e596066136d690872e381449bb7871a3ee31b106d", + "size": 1433715, + "subdir": "linux-64", + "timestamp": 1522004329353, + "version": "1.00.83" + }, + "freetds-1.00.86-hb7f436b_0.conda": { + "build": "hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "GPL-2", + "license_family": "GPL2", + "md5": "987094e75be8cbb77f15197535ccbe03", + "name": "freetds", + "sha256": "0e3b3d6aee84d6a35494591615c5d717b23375dfb8bb19e1a27f99b53ef8d5b2", + "size": 1434431, + "subdir": "linux-64", + "timestamp": 1524158884662, + "version": "1.00.86" + }, + "freetds-1.00.91-hb7f436b_0.conda": { + "build": "hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "GPL-2", + "license_family": "GPL2", + "md5": "74581df998c2ba27e18b771fb2db4c53", + "name": "freetds", + "sha256": "b88e597e4d5a4fabc23e71ead6dd9edf7786dd6a70f9d785e14baf08fdb66529", + "size": 1434845, + "subdir": "linux-64", + "timestamp": 1529962956850, + "version": "1.00.91" + }, + "freetds-1.00.97-h1ba5d50_0.conda": { + "build": "h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "GPL-2", + "license_family": "GPL2", + "md5": "38db8c780e1d4c05d879881778e69fbb", + "name": "freetds", + "sha256": "cbb40a7067095dba2b8685df46c762350bfc0e5d58c72f477bb8f9a86343fe6f", + "size": 1438002, + "subdir": "linux-64", + "timestamp": 1540226527571, + "version": "1.00.97" + }, + "freetds-1.00.97-h52ef933_0.conda": { + "build": "h52ef933_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1e,<1.1.2a", + "readline >=8.0,<9.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "GPL-2", + "license_family": "GPL2", + "md5": "d00b4f757765a48df2e737775fbf4b4e", + "name": "freetds", + "sha256": "c0dcc0fb91d5cd3c320ff9a314bba4a52e62940191a7c4953223fc6a4b4ba674", + "size": 1456338, + "subdir": "linux-64", + "timestamp": 1585178811031, + "version": "1.00.97" + }, + "freetds-1.00.97-hc365091_0.conda": { + "build": "hc365091_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a", + "readline >=7.0,<8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "GPL-2", + "license_family": "GPL2", + "md5": "2f6cbfe7f37ca037ac6fc0fb2b7de3ba", + "name": "freetds", + "sha256": "dc3edccadcabe053ab7fff6cb318d77ac579d5b4cb2e820a147ec15de6c2de3e", + "size": 1438935, + "subdir": "linux-64", + "timestamp": 1536076695281, + "version": "1.00.97" + }, + "freetds-1.1.15-hdedb384_0.conda": { + "build": "hdedb384_0", + "build_number": 0, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "readline >=8.0,<9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "GPL-2", + "license_family": "GPL2", + "md5": "01d3381589d29d14c0b856ec21ead52c", + "name": "freetds", + "sha256": "b6650e577188fbd6708a2b35a80b4b98e19c015e3a4b6f3dacde68a828d307bc", + "size": 1495232, + "subdir": "linux-64", + "timestamp": 1611074767837, + "version": "1.1.15" + }, + "freetds-1.2.19-hdedb384_0.conda": { + "build": "hdedb384_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.1,<1.20.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "ebce6eb71b81b483de21dc812a61d6bf", + "name": "freetds", + "sha256": "5a101843493dc787f60c6305318a06c7f344eda7988274d0b1dad2ee68551123", + "size": 1357456, + "subdir": "linux-64", + "timestamp": 1618326621306, + "version": "1.2.19" + }, + "freetds-1.2.20-hdedb384_0.conda": { + "build": "hdedb384_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.1,<1.20.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "2331e990083f36ff31d84f13b7fa3105", + "name": "freetds", + "sha256": "59ca2d16ea477804c52bfb2757b60d38da237fc1389b40c86b94dba37583c923", + "size": 1355519, + "subdir": "linux-64", + "timestamp": 1618381964612, + "version": "1.2.20" + }, + "freetds-1.2.21-hdedb384_0.conda": { + "build": "hdedb384_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.1,<1.20.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "31e9da99e09fe497b95781afcddf97aa", + "name": "freetds", + "sha256": "c5c08c8edc9ab38ca621b86e84bfb0681819ddf42c9315bfc47f9e93ddfe4a05", + "size": 1351895, + "subdir": "linux-64", + "timestamp": 1619476887860, + "version": "1.2.21" + }, + "freetds-1.3-ha584ca3_0.conda": { + "build": "ha584ca3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.1,<1.20.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "LGPL-2.0 AND GPL-2.0", + "license_family": "LGPL", + "md5": "5e487e7a682eae6a1f244928738955d1", + "name": "freetds", + "sha256": "3280a84ecdd52ae2ab81a128f928d94bafc0868ecc64267a5c3dd3cabfcb987c", + "size": 1354459, + "subdir": "linux-64", + "timestamp": 1626258071143, + "version": "1.3" + }, + "freetds-1.3.3-ha584ca3_0.conda": { + "build": "ha584ca3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "readline >=8.0,<9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "LGPL-2.0 AND GPL-2.0", + "license_family": "LGPL", + "md5": "c887dd3ed193c768c6ce807a2604f552", + "name": "freetds", + "sha256": "b5060d572f0c39794a349ad2c15f7082db0d38740b66780ae6d71c9df849d8f7", + "size": 1357153, + "subdir": "linux-64", + "timestamp": 1638441044819, + "version": "1.3.3" + }, + "freetype-2.10.2-h5ab3b9f_0.conda": { + "build": "h5ab3b9f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-only and LicenseRef-FreeType", + "md5": "6418b7c65407f7cac1ba2f18892aff8a", + "name": "freetype", + "sha256": "5092594b0a8cba789a04ba4b5bc64530db0fbb28382a0a12b377da516c84d59f", + "size": 622444, + "subdir": "linux-64", + "timestamp": 1592507538188, + "version": "2.10.2" + }, + "freetype-2.10.3-h5ab3b9f_0.conda": { + "build": "h5ab3b9f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-only and LicenseRef-FreeType", + "md5": "8fd8186305d11544452d99283b1a2cb5", + "name": "freetype", + "sha256": "43104e424980f0552899fb3910a3649cdadf0e1b02e1b33bec6571b4ad292264", + "size": 609775, + "subdir": "linux-64", + "timestamp": 1602517554418, + "version": "2.10.3" + }, + "freetype-2.10.4-h5ab3b9f_0.conda": { + "build": "h5ab3b9f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-only and LicenseRef-FreeType", + "md5": "bef0ea8b3abc9d84674733a3ca426865", + "name": "freetype", + "sha256": "ce30bd1542b38e7dc83180c54202b36597ef26a14fa4678f5a74ae540cdb2143", + "size": 610645, + "subdir": "linux-64", + "timestamp": 1603212964927, + "version": "2.10.4" + }, + "freetype-2.11.0-h70c0345_0.conda": { + "build": "h70c0345_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-only and LicenseRef-FreeType", + "md5": "b767874a6273e1058027cb2e300d00ac", + "name": "freetype", + "sha256": "cb29bcdeabea6bb96f2b6339f2ecdbeeb6d4683ff3ddb1b05a490138511419a2", + "size": 633048, + "subdir": "linux-64", + "timestamp": 1635422707211, + "version": "2.11.0" + }, + "freetype-2.12.1-h4a9f257_0.conda": { + "build": "h4a9f257_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2-only and LicenseRef-FreeType", + "license_family": "Other", + "md5": "bdc7b5952e9c5dca01bc2f4ccef2f974", + "name": "freetype", + "sha256": "d40c0f2889023791b4b9115cba9549fe97768bb2fa13d1721d8d095ff4f17a6f", + "size": 640793, + "subdir": "linux-64", + "timestamp": 1666798278693, + "version": "2.12.1" + }, + "freetype-2.8-h52ed37b_0.conda": { + "build": "h52ed37b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0 and FreeType", + "md5": "0e65b16b27ce8970cc307fa42ce054e0", + "name": "freetype", + "sha256": "17419234577eea46d240e2e6f79e82afbd628d150ea48455720d99e9edfdc3b5", + "size": 554547, + "subdir": "linux-64", + "timestamp": 1505733467465, + "version": "2.8" + }, + "freetype-2.8-hab7d2ae_1.conda": { + "build": "hab7d2ae_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0 and FreeType", + "md5": "f45ebc559699aa1730d3119b76b1f336", + "name": "freetype", + "sha256": "fb683c97a086f3a5c4ed646e31e9ed25f93b780857e2f39e607f5999eb279db5", + "size": 555101, + "subdir": "linux-64", + "timestamp": 1510603249537, + "version": "2.8" + }, + "freetype-2.9-hadd163a_0.conda": { + "build": "hadd163a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0 and FreeType", + "md5": "20da87b9aa68d1441b2d7599327bb900", + "name": "freetype", + "sha256": "53a6b6a5dbc39d7198f3696cdc1697c5803af5af7d8df18fef212f76701f3789", + "size": 557781, + "subdir": "linux-64", + "timestamp": 1522459361480, + "version": "2.9" + }, + "freetype-2.9.1-h8a8886c_0.conda": { + "build": "h8a8886c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0 and FreeType", + "md5": "1d33557789eea300748a82d635d1c1c1", + "name": "freetype", + "sha256": "0bc77bece77c62c6c7384bcfc11a6d6860bc25658dbe200ee91771165bf7541d", + "size": 557963, + "subdir": "linux-64", + "timestamp": 1527164842029, + "version": "2.9.1" + }, + "freetype-2.9.1-h8a8886c_1.conda": { + "build": "h8a8886c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libpng >=1.6.34,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0 and FreeType", + "md5": "e66a5cb02dd44ac02234402196861768", + "name": "freetype", + "sha256": "9feb53479977842df3ce61056d7e5736d1743d42c5d8a03cff3183489969759a", + "size": 563270, + "subdir": "linux-64", + "timestamp": 1535129426985, + "version": "2.9.1" + }, + "freexl-1.0.4-h2367b09_4.conda": { + "build": "h2367b09_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "md5": "30387db390c1996ce5a3ba86d676aa91", + "name": "freexl", + "sha256": "af5fb90217c0c61bdf4a9a9c00798168d2b2c2f6385de247424feb4d21b3a86f", + "size": 41513, + "subdir": "linux-64", + "timestamp": 1509502667050, + "version": "1.0.4" + }, + "freexl-1.0.4-hf32cdb2_5.conda": { + "build": "hf32cdb2_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "md5": "05350b2c6ac6c34554ee68a391cdc617", + "name": "freexl", + "sha256": "8ed5d2667595cffcd7d4d217a31514f12181f074fafc7f93ed784f03cd8a4723", + "size": 41490, + "subdir": "linux-64", + "timestamp": 1510603248058, + "version": "1.0.4" + }, + "freexl-1.0.5-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "md5": "2e7c72f3f62cd726524813d98574296d", + "name": "freexl", + "sha256": "67fe733fa0874cb3a6320fc64fd9266376c7e43d624b066fdc5ebbe313f3d0cf", + "size": 41294, + "subdir": "linux-64", + "timestamp": 1520963065745, + "version": "1.0.5" + }, + "freexl-1.0.6-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MPL-1.1", + "md5": "0f3d6c0873b7923fe08e16904937c832", + "name": "freexl", + "sha256": "930f3e997b3fd73c765f841484fdeb428a7c783965aa24a5c8ecb70e0a45772b", + "size": 43210, + "subdir": "linux-64", + "timestamp": 1607116152702, + "version": "1.0.6" + }, + "fribidi-1.0.10-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "md5": "1b4851703971b3d43acdcc9c72777575", + "name": "fribidi", + "sha256": "64c55b1e235fc5d56e4e0b5b1cec9c2500c404e71253a90e6df59f0a5a669bdb", + "size": 105625, + "subdir": "linux-64", + "timestamp": 1597684734171, + "version": "1.0.10" + }, + "fribidi-1.0.2-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "md5": "67cfe8ed62ea8cf3f8f69090ba0d64b7", + "name": "fribidi", + "sha256": "9ad7767c0be78cf46c4505c07e685b6b0925622305ce12da7ad5bbbe237f435d", + "size": 103023, + "subdir": "linux-64", + "timestamp": 1522873067928, + "version": "1.0.2" + }, + "fribidi-1.0.4-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "md5": "2c1b5712887a6c7b0e17e8159c0f9fd4", + "name": "fribidi", + "sha256": "22479cf51ac100b0c2f466ff1d0880ec8acb47bbb62b37a16d07163edf23f518", + "size": 102623, + "subdir": "linux-64", + "timestamp": 1529962411408, + "version": "1.0.4" + }, + "fribidi-1.0.5-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "md5": "57aebb9640eda34542b6b27a39f181a7", + "name": "fribidi", + "sha256": "63f561cc756f91da878621a2a6937f3e09f3694d7c348f085b9072d6796ee8dd", + "size": 103759, + "subdir": "linux-64", + "timestamp": 1536086961039, + "version": "1.0.5" + }, + "fribidi-1.0.9-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "md5": "b37de66f742ec304de114e77aefc146b", + "name": "fribidi", + "sha256": "f13e1f5a20858d1860ff5409c8c3bbea1fedd4bff0f08a73caa8871307058297", + "size": 106949, + "subdir": "linux-64", + "timestamp": 1593119676634, + "version": "1.0.9" + }, + "frozenlist-1.2.0-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "d35dad737968f210fd10671bcbf80a86", + "name": "frozenlist", + "sha256": "1166dce3a4b10b30d1d42b09f660df24c0ea52e33e1658e9b35878b26abacd0f", + "size": 152695, + "subdir": "linux-64", + "timestamp": 1640790103552, + "version": "1.2.0" + }, + "frozenlist-1.2.0-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "838da5efe4d4c46bb2d0ac8ffd4006e2", + "name": "frozenlist", + "sha256": "740aa8f4a5f1ac895c0d4f29c54d825617108e03d2b9a3b6aed869b2a9e7790f", + "size": 79788, + "subdir": "linux-64", + "timestamp": 1637767158189, + "version": "1.2.0" + }, + "frozenlist-1.2.0-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ce8258b85b912cf78964a621d58d0286", + "name": "frozenlist", + "sha256": "8e37b08061a0690223c9be96149f59cdc153f1d0488a54bd37f2d0b379852872", + "size": 80838, + "subdir": "linux-64", + "timestamp": 1637767147948, + "version": "1.2.0" + }, + "frozenlist-1.2.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2d0d1f8591a388c14e5b0eeb29799416", + "name": "frozenlist", + "sha256": "c2635f9eee00e206768dbf76e998bf2a5420eb6929f64fcd433c6116fb8f3a55", + "size": 80530, + "subdir": "linux-64", + "timestamp": 1637767150249, + "version": "1.2.0" + }, + "frozenlist-1.3.3-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3bbce235c9c098efcc47aadb11053b1b", + "name": "frozenlist", + "sha256": "51b86ac7ae8204a97bf7cb0f9035ed3905c2841672cee077ffaabade3461095b", + "size": 45576, + "subdir": "linux-64", + "timestamp": 1670004544636, + "version": "1.3.3" + }, + "frozenlist-1.3.3-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "456706b1525facdc26244fe30b7106b6", + "name": "frozenlist", + "sha256": "d0feb875f10980f9ffb480c9ad3a05d8eba9d488d279236c83fd2a2e8ca85e3d", + "size": 41914, + "subdir": "linux-64", + "timestamp": 1676825245209, + "version": "1.3.3" + }, + "frozenlist-1.3.3-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "14132a66cb14566784ff6172c5e0e215", + "name": "frozenlist", + "sha256": "133399b10633f53c2a34fae7a8f168be1d6b84e32c180c47c1e6906f36c2e5d1", + "size": 45229, + "subdir": "linux-64", + "timestamp": 1670004631894, + "version": "1.3.3" + }, + "frozenlist-1.3.3-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f6741f49b63a56fd20d58e39e6a252bd", + "name": "frozenlist", + "sha256": "8b7d9a0ac78b595390436e2237ef756b96b1d5ec8075d5eb507e9bad474f6b17", + "size": 45830, + "subdir": "linux-64", + "timestamp": 1670004602514, + "version": "1.3.3" + }, + "frozenlist-1.3.3-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0aa12aee4edc19023737037b17c5d424", + "name": "frozenlist", + "sha256": "62c9d021472009ea667bf65eed529b913aa8557a8e7f0a936b934c07a61070c2", + "size": 45661, + "subdir": "linux-64", + "timestamp": 1670004573921, + "version": "1.3.3" + }, + "fsspec-2022.10.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8dcfadbd08dcf54f2bb7a2b5e3d33646", + "name": "fsspec", + "sha256": "bbda9ebc11d7243b4bc1daf60baa36a85eb613983ebca09df01366a8fc8e7156", + "size": 225307, + "subdir": "linux-64", + "timestamp": 1667497055163, + "version": "2022.10.0" + }, + "fsspec-2022.10.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "578dd09ff60c072deb684ba40132f73b", + "name": "fsspec", + "sha256": "7a4cd57b7d4938fefc4e541a94693fcd13ca64483fb24799e3a7b764be7e0beb", + "size": 221215, + "subdir": "linux-64", + "timestamp": 1667497081379, + "version": "2022.10.0" + }, + "fsspec-2022.10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b290a35d87cbf9e9d2bb5c0964af8f8e", + "name": "fsspec", + "sha256": "13e40f0422085bdd87a4b246b21e2b70a854350bd03647929554cfc7098269ac", + "size": 222557, + "subdir": "linux-64", + "timestamp": 1667497106927, + "version": "2022.10.0" + }, + "fsspec-2022.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bdc02fd0564d308e09b5c2c32f1d99d8", + "name": "fsspec", + "sha256": "401a8edfacd57fb2a2f0de253ddfe6fb4e0a4e98d3efdbdcd21b4f0c86962c4f", + "size": 222740, + "subdir": "linux-64", + "timestamp": 1667497028895, + "version": "2022.10.0" + }, + "fsspec-2022.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4924e061a73336eddafea10e333cc5c2", + "name": "fsspec", + "sha256": "8b857feece3b14d21d88cf5ac1cc55115bbec638490789546ac36a2a0e2ca845", + "size": 231067, + "subdir": "linux-64", + "timestamp": 1670336700344, + "version": "2022.11.0" + }, + "fsspec-2022.11.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eb22809007cdf6bc431029565736242b", + "name": "fsspec", + "sha256": "9c1432c277b2ea81b6c5661e3773cdd0cdfe403e85965dfe1eb796837893eb70", + "size": 293643, + "subdir": "linux-64", + "timestamp": 1676827754606, + "version": "2022.11.0" + }, + "fsspec-2022.11.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c8977f659fae5b506d9a1fc60a9900bf", + "name": "fsspec", + "sha256": "acb8a9323be31e03822b172e827436e1fbdd01950e7d24f4263a58f31bc2f2ba", + "size": 226394, + "subdir": "linux-64", + "timestamp": 1670336648454, + "version": "2022.11.0" + }, + "fsspec-2022.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a243e5b4e6a939ce6b38aa1a73129695", + "name": "fsspec", + "sha256": "0414dd2dde88518018357da2f5c5c03d47299ee25c24b781a36e5723cdc1d5ec", + "size": 228122, + "subdir": "linux-64", + "timestamp": 1670336622478, + "version": "2022.11.0" + }, + "fsspec-2022.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0d0f175bbcf28965914aa0b82c9d5c8e", + "name": "fsspec", + "sha256": "7ff3f4dd09aa55314d8abe28f9700f646c9254b6cc7a158bd8e1e36fdb7e6876", + "size": 227814, + "subdir": "linux-64", + "timestamp": 1670336674291, + "version": "2022.11.0" + }, + "fsspec-2022.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ef4c995ac5bc0be31c4a0ce90b152d8a", + "name": "fsspec", + "sha256": "4c4acb03690793afcc3ae5b5516717f96767cea8e93f95ec0f5798e3448089f1", + "size": 209868, + "subdir": "linux-64", + "timestamp": 1652802179339, + "version": "2022.3.0" + }, + "fsspec-2022.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aaced739d0368a5acdf20ad637bc5eb8", + "name": "fsspec", + "sha256": "65fcdac5e329320d4112bbd776a978919b769e6d433678b17d387f9aa079f033", + "size": 205794, + "subdir": "linux-64", + "timestamp": 1652802207569, + "version": "2022.3.0" + }, + "fsspec-2022.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "45df02eb7d28e318d96e44caa6294626", + "name": "fsspec", + "sha256": "5d2f6b43566fce7db18ce34a300ff0ec2722fefe74203967d364de3b03932ddb", + "size": 207164, + "subdir": "linux-64", + "timestamp": 1652802235832, + "version": "2022.3.0" + }, + "fsspec-2022.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "602e4f1afdcbf916669b5ef54aed160d", + "name": "fsspec", + "sha256": "f45c8d2075e3dac1cd9c27314ac325651a1bb968cf6dde16f061e60cc8fd33bf", + "size": 207386, + "subdir": "linux-64", + "timestamp": 1652802140522, + "version": "2022.3.0" + }, + "fsspec-2022.7.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "681fd54cf498e974db6c3fb25f9a499d", + "name": "fsspec", + "sha256": "252108d88d480109d09271dc851600bbe871df09783d4c9546b1930890684551", + "size": 215145, + "subdir": "linux-64", + "timestamp": 1659972306331, + "version": "2022.7.1" + }, + "fsspec-2022.7.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d07cf70caf46c6ec71d673af37797557", + "name": "fsspec", + "sha256": "65778e3317ee364170b46226b19b127bc7f2a00d7f6368d6ef9074599775843d", + "size": 210781, + "subdir": "linux-64", + "timestamp": 1659972263070, + "version": "2022.7.1" + }, + "fsspec-2022.7.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aa5ac33675b4beb64d418ee248dcfd28", + "name": "fsspec", + "sha256": "d45dcf06e44117d07a0bbc3fffefa204cfee8554e50150ff615feb1d71cde01f", + "size": 212111, + "subdir": "linux-64", + "timestamp": 1659972234013, + "version": "2022.7.1" + }, + "fsspec-2022.7.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0f7af74424566db274d87c805e466ee1", + "name": "fsspec", + "sha256": "f5df9d656006af38916d29536dca42a055b0bc904c35c976161f40a745b30889", + "size": 212267, + "subdir": "linux-64", + "timestamp": 1659972337708, + "version": "2022.7.1" + }, + "fsspec-2023.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4cc7f02d06fa8dc495858431e08ba0e7", + "name": "fsspec", + "sha256": "5094f56511e71842289ce5e8ec6463143faffa75774e24b0fa4cb67840e37131", + "size": 238990, + "subdir": "linux-64", + "timestamp": 1679418818027, + "version": "2023.3.0" + }, + "fsspec-2023.3.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0d53e8e3f9fff4d94b838271eeba2237", + "name": "fsspec", + "sha256": "85d4586b40375a1a490c3ff74e765937843902ad9b5076ac55cbad4f5df36cf3", + "size": 321564, + "subdir": "linux-64", + "timestamp": 1679418895424, + "version": "2023.3.0" + }, + "fsspec-2023.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "847706f0d5ee5c2921d01fb7b42268be", + "name": "fsspec", + "sha256": "0506ab038257b52cfa2b41b3154788930067ab2a360fb46ee6d831a6cee0b8d5", + "size": 235614, + "subdir": "linux-64", + "timestamp": 1679418843983, + "version": "2023.3.0" + }, + "fsspec-2023.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "96de79bcb483a0a25c512f895d9f3389", + "name": "fsspec", + "sha256": "ed1769f16926edf12b14c065226b0c049109e5e5c708a944e97af8f175fa18a5", + "size": 235678, + "subdir": "linux-64", + "timestamp": 1679418868935, + "version": "2023.3.0" + }, + "ftfy-5.1.1-py35h1b93f42_0.conda": { + "build": "py35h1b93f42_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "e6557c79586c23db6287968104351275", + "name": "ftfy", + "sha256": "489436149d6a861cd0f4c1e680883d157cdfd12f524e0f32d704d1409efef3cd", + "size": 58123, + "subdir": "linux-64", + "timestamp": 1508600979995, + "version": "5.1.1" + }, + "ftfy-5.1.1-py36hfde7620_0.conda": { + "build": "py36hfde7620_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "54ff0064754770c894332ff3d2948294", + "name": "ftfy", + "sha256": "49e51a9f2d88e1553926615de7fc31573f63067168e8c95cd3293bee5e7a53bd", + "size": 57806, + "subdir": "linux-64", + "timestamp": 1508600975837, + "version": "5.1.1" + }, + "ftfy-5.2.0-py35h5167a2d_0.conda": { + "build": "py35h5167a2d_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "ebeda1613b61152d6d4f33519355eae3", + "name": "ftfy", + "sha256": "b1f6be924ae1649012a3e11057458b96fefab094a59f871a7e56e48fbb9d7994", + "size": 59223, + "subdir": "linux-64", + "timestamp": 1512059501629, + "version": "5.2.0" + }, + "ftfy-5.2.0-py36h43dc9bd_0.conda": { + "build": "py36h43dc9bd_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "b6e85cd15083f9b91b179dfd448608e2", + "name": "ftfy", + "sha256": "3f42ddba31ead599fa29434648c63ee083f46c165a276a24260397852b7a2701", + "size": 58885, + "subdir": "linux-64", + "timestamp": 1512059495692, + "version": "5.2.0" + }, + "ftfy-5.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "06964985398ad58ca703903341457559", + "name": "ftfy", + "sha256": "fcce3dedc4a016c131f4ce9f67fcd9ae7bebb1d7c48cc9d3593f0fb6ad158d22", + "size": 59552, + "subdir": "linux-64", + "timestamp": 1519484581869, + "version": "5.3.0" + }, + "ftfy-5.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "fb900db421b698a36e0b17d8bcc346eb", + "name": "ftfy", + "sha256": "c0401e8e187e901dcd869d1bceb7547f6cc5d488b08b1b6a4695474c32ada0fc", + "size": 59431, + "subdir": "linux-64", + "timestamp": 1519484535324, + "version": "5.3.0" + }, + "ftfy-5.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "d11858d57abd19f5a416ceceb451b4cd", + "name": "ftfy", + "sha256": "14bc007a03e420717ea169c7fafdaa303d428e6ce288c222f9ad79d4cfed4f27", + "size": 62882, + "subdir": "linux-64", + "timestamp": 1529561424070, + "version": "5.4.1" + }, + "ftfy-5.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "68a44efc78670183c490873776cd7967", + "name": "ftfy", + "sha256": "ead5ca4963126825fff79d0466f51f4eeea76357d06c7a7decb32642abf250d3", + "size": 62913, + "subdir": "linux-64", + "timestamp": 1529561399113, + "version": "5.4.1" + }, + "ftfy-5.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "7331e3d330ef46a8a178bdcab8a885ca", + "name": "ftfy", + "sha256": "99afedd6ea19941516b70028a89c3bc77fc8a0d004866e1eabe8314701693683", + "size": 62317, + "subdir": "linux-64", + "timestamp": 1530877599468, + "version": "5.4.1" + }, + "ftfy-5.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wcwidth" + ], + "license": "MIT", + "md5": "4bfcb5ba025504059e1e46970fe6f187", + "name": "ftfy", + "sha256": "f897e2e9a82c318d40425925d968ef566b279244c39843a196818748a1e0f38d", + "size": 63910, + "subdir": "linux-64", + "timestamp": 1540062826997, + "version": "5.5.0" + }, + "fuel-0.2.0-py27h7b6447c_1.conda": { + "build": "py27h7b6447c_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.3.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=2.7,<2.8.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "74259d5f4cbeb63744247534a7d51da2", + "name": "fuel", + "sha256": "58e3edcdd522a0f05963cef4a3a2445dd0719f61acf72679da152b0fc4f54fde", + "size": 239221, + "subdir": "linux-64", + "timestamp": 1537294484317, + "version": "0.2.0" + }, + "fuel-0.2.0-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.5.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=3.10,<3.11.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "7e0e54e7d9627f3373d3d512cf896bf6", + "name": "fuel", + "sha256": "def1929b40d45daa616e1faecb83e6ee91083a0286770e48916c1b51d65af96a", + "size": 431603, + "subdir": "linux-64", + "timestamp": 1642520087653, + "version": "0.2.0" + }, + "fuel-0.2.0-py35h7b6447c_1.conda": { + "build": "py35h7b6447c_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.3.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=3.5,<3.6.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "178dc1fa2a4e708884ceb8ffd716a6d5", + "name": "fuel", + "sha256": "48adb8061f4f47598b659f2ce4276b9cbf8f39bfa09714e8f28d8dd155411979", + "size": 244810, + "subdir": "linux-64", + "timestamp": 1537294535106, + "version": "0.2.0" + }, + "fuel-0.2.0-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.3.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=3.6,<3.7.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "ddd2e4a1dbe5b4b12fe1f644935c68b9", + "name": "fuel", + "sha256": "50d49c185b4e8afc40d18146b99924bbaff7f2dbbff7bba69d6507723f29ec99", + "size": 480552, + "subdir": "linux-64", + "timestamp": 1614326569833, + "version": "0.2.0" + }, + "fuel-0.2.0-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.3.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=3.6,<3.7.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "5351fe731b80c9cd4ad3b2a90849158d", + "name": "fuel", + "sha256": "c39ddaf7d1b7ca908cc623b2011430ec1ce4990eeef792d8001e2c48e6b5b019", + "size": 242622, + "subdir": "linux-64", + "timestamp": 1537294535707, + "version": "0.2.0" + }, + "fuel-0.2.0-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.3.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=3.7,<3.8.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "385799219ce76fe6a4a727356ecf37cb", + "name": "fuel", + "sha256": "beddacfc00569aa4282de674f3327bd56c9154f85b48d232cbd733c99ebea7cf", + "size": 476836, + "subdir": "linux-64", + "timestamp": 1614325508136, + "version": "0.2.0" + }, + "fuel-0.2.0-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.3.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=3.7,<3.8.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "f4150099b825578926650738bca7d5be", + "name": "fuel", + "sha256": "fc821815a20f8ecb99f53e5351f324e63b454ea5cf2b568d227140254af50bb3", + "size": 242287, + "subdir": "linux-64", + "timestamp": 1537294460505, + "version": "0.2.0" + }, + "fuel-0.2.0-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.3.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=3.8,<3.9.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "e3df371f3242b560717186cda88892d0", + "name": "fuel", + "sha256": "7e240d000d55503d3f50fd424a393e5c872f3e4f054084667a30e57f93e5b50d", + "size": 482153, + "subdir": "linux-64", + "timestamp": 1614326551170, + "version": "0.2.0" + }, + "fuel-0.2.0-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.3.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=3.8,<3.9.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "6eb94df3921ffdcd1b3d1634fa0f390a", + "name": "fuel", + "sha256": "340001761e6b6ac8bf00b800863c406ba09a8c413d6c569c4f55221d42741895", + "size": 249284, + "subdir": "linux-64", + "timestamp": 1574238607577, + "version": "0.2.0" + }, + "fuel-0.2.0-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "h5py", + "libgcc-ng >=7.3.0", + "numpy", + "picklable-itertools", + "pillow", + "progressbar2", + "pytables", + "python >=3.9,<3.10.0a0", + "pyyaml", + "pyzmq", + "requests", + "scipy", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "37f21427287f16fd15483a7c070bc278", + "name": "fuel", + "sha256": "a999fdd57b08f0aae3dd6a896bd29679c7c16d1c69c4ce1d5f1be3cade10b358", + "size": 481607, + "subdir": "linux-64", + "timestamp": 1614326551248, + "version": "0.2.0" + }, + "funcsigs-1.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "ce1bd96bdae8d3bb16ea9de2522cfdd3", + "name": "funcsigs", + "sha256": "b1fe25ead3156d6b65080acd437446c291b8192a44dfe740a101a7228d902c04", + "size": 22017, + "subdir": "linux-64", + "timestamp": 1530735147541, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py27h83f16ab_0.conda": { + "build": "py27h83f16ab_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "9640a2cff9a0a24e8c43ad690dbb474d", + "name": "funcsigs", + "sha256": "1bf876b55e811a941c84212ffaed8ea7a1a483f7b854fe1f5f481aa7ada2c251", + "size": 21766, + "subdir": "linux-64", + "timestamp": 1505691231315, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "md5": "82d3d3b82158203af82209b597c0f946", + "name": "funcsigs", + "sha256": "cd68002742f86156422e007ca8506e8c86e60189130255f3971dae455f5de4d8", + "size": 22325, + "subdir": "linux-64", + "timestamp": 1640790121231, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache 2.0", + "md5": "9594c56e23d96118b12fbffd66cfa322", + "name": "funcsigs", + "sha256": "a59c3c711129352899ab656fbc97e406b232ef27191142657831d216bdab377f", + "size": 28034, + "subdir": "linux-64", + "timestamp": 1676852502873, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "45556b6a9549fcadfd777e67e1ed15de", + "name": "funcsigs", + "sha256": "a858ff8fc07ca2cae4571c5dbcc13cc0287f01f7acae5ff7d08be653db518099", + "size": 22305, + "subdir": "linux-64", + "timestamp": 1534351830914, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "d052fad185a88e919504399f759e086c", + "name": "funcsigs", + "sha256": "f72fc161c806d33c2018480c580c6cbb598b8e9aa0fc4f73a3bf4ca49d2dafbf", + "size": 22059, + "subdir": "linux-64", + "timestamp": 1530735127840, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "b3e9f05bd486e0a97b687ed2ccbdc76c", + "name": "funcsigs", + "sha256": "9c45e716e97699d700bbedd6bf8b413a8afd26c2c6c2106073b2318dc6336958", + "size": 23112, + "subdir": "linux-64", + "timestamp": 1613164608111, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "d30d618c7adcebef2f4a8f0e009191c1", + "name": "funcsigs", + "sha256": "b62a9fadb0a00e25863eadd446aca00067dae4389f7ebb5018617cd0e9b8cec8", + "size": 22130, + "subdir": "linux-64", + "timestamp": 1530735167799, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "2894423c31644a69f854a925d8b59a25", + "name": "funcsigs", + "sha256": "425e1ce057fe1fd2d628e36ae51af98cf9b89925d16297f70c65ef779d867c55", + "size": 23185, + "subdir": "linux-64", + "timestamp": 1613165857178, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "0887bd9d8b3be384a68b043a0e25997c", + "name": "funcsigs", + "sha256": "3511a6062138f321c375409420b7c2eac7814bd7027343e4167115c750df25dc", + "size": 22626, + "subdir": "linux-64", + "timestamp": 1572880763116, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "ffa529b3dc764641191e5ecb409e5dce", + "name": "funcsigs", + "sha256": "d9e49c4b3c65e23944c42b8ec26e9259c8513904a99d41c27b30d58f34d68e81", + "size": 23307, + "subdir": "linux-64", + "timestamp": 1613165868000, + "version": "1.0.2" + }, + "funcsigs-1.0.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "b776ec955ba59b1c118c73d4baa28453", + "name": "funcsigs", + "sha256": "19ec3e86306d6e1d673b754421e7a24004dda5a087adf947c4c378f1ac491e47", + "size": 23313, + "subdir": "linux-64", + "timestamp": 1613165417467, + "version": "1.0.2" + }, + "functools32-3.2.3.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF license", + "md5": "847d5b23eda4d551711d946a6628ad46", + "name": "functools32", + "sha256": "08919eed1b7a44bca5cf3ceda8405614931ed54eab2c91d87af1650b88b37bca", + "size": 23653, + "subdir": "linux-64", + "timestamp": 1530735188460, + "version": "3.2.3.2" + }, + "functools32-3.2.3.2-py27h4ead58f_1.conda": { + "build": "py27h4ead58f_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF license", + "md5": "f6d7a7c12d5cd8bc485db64c146869f0", + "name": "functools32", + "sha256": "f4812adcfa3749d193bc56e288fb800101f12a5cb98a6d3effe081e46776f7c5", + "size": 23433, + "subdir": "linux-64", + "timestamp": 1505957251004, + "version": "3.2.3.2" + }, + "functools32-3.2.3.2-py36hc1f28f5_1.conda": { + "build": "py36hc1f28f5_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF license", + "md5": "671bc3b8304b2ed1e80d4c72a5fb883c", + "name": "functools32", + "sha256": "25514e2bf1f28c17d6bfcdbb2c3d79e3ac045f309ccf07e060840511c667e4d7", + "size": 23082, + "subdir": "linux-64", + "timestamp": 1505722662729, + "version": "3.2.3.2" + }, + "functools_lru_cache-1.4-hf48f6e4_0.conda": { + "build": "hf48f6e4_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache 1.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31032609eea1112aedd42300c83f642a", + "name": "functools_lru_cache", + "sha256": "4aa12b548003e6a06af1bf09027bbda36337a7daaa48b1585a3d20f8fc0c4daa", + "size": 3142, + "subdir": "linux-64", + "timestamp": 1507051196329, + "version": "1.4" + }, + "functools_lru_cache-1.5-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache 1.5.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa9c773c2d0cd9c515942fbb1dc0ddbb", + "name": "functools_lru_cache", + "sha256": "9848c89090dfb13bf99024b1ac52fe8f12c491df09c33cca98ea1beee4c510af", + "size": 3471, + "subdir": "linux-64", + "timestamp": 1519170657572, + "version": "1.5" + }, + "furl-1.0.1-py27hb01be32_0.conda": { + "build": "py27hb01be32_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "e80389175ab2dde4e60ef37cddd96c62", + "name": "furl", + "sha256": "49ec77482d307050978f15708659a31d8ec79081d17151a0239e0893ca8b2801", + "size": 31864, + "subdir": "linux-64", + "timestamp": 1505743270687, + "version": "1.0.1" + }, + "furl-1.0.1-py35h1507926_0.conda": { + "build": "py35h1507926_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=3.5,<3.6.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "4d8d54add571d983b36d7e2201579524", + "name": "furl", + "sha256": "633b7ad5ada67dd0299735e4bee2f5df8d9eb306113a322c55e155208b50f9b8", + "size": 32466, + "subdir": "linux-64", + "timestamp": 1505743282492, + "version": "1.0.1" + }, + "furl-1.0.1-py36h1286c47_0.conda": { + "build": "py36h1286c47_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "2607f6827488373b285542ebd9c51d34", + "name": "furl", + "sha256": "6698fbcb2aa9223965b1b77ac86e22f632e054b3e74311019eca6d066ecf0fd2", + "size": 32102, + "subdir": "linux-64", + "timestamp": 1505743294433, + "version": "1.0.1" + }, + "furl-1.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "62a43f82a644f59c08f76cd5a8f60788", + "name": "furl", + "sha256": "1a8dcc2bdd164aef9d7981058b17a8efa0486f5daf6d1aeb45e9e5871b61fe25", + "size": 32799, + "subdir": "linux-64", + "timestamp": 1527630958081, + "version": "1.0.2" + }, + "furl-1.0.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=3.5,<3.6.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "b3e363362b724e81b0e02516910a9f29", + "name": "furl", + "sha256": "251f09a0b4837335160222fed9b126c502432afa39c8314cdcc23c6edaa23c9a", + "size": 33455, + "subdir": "linux-64", + "timestamp": 1527630981128, + "version": "1.0.2" + }, + "furl-1.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "262d539ec9a1a20b662f24bb6ab83b8d", + "name": "furl", + "sha256": "0f27a6497c5c0de50226520b5a5d232efc3ff39a7867be4ac377ca25057b4508", + "size": 33101, + "subdir": "linux-64", + "timestamp": 1527630947100, + "version": "1.0.2" + }, + "furl-1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "acd4130de51d37e35ddf1ea550af74d7", + "name": "furl", + "sha256": "95d2b9c74e4a81923a69277306171bd840e31283237627920f805caeb1c7b91b", + "size": 32902, + "subdir": "linux-64", + "timestamp": 1528218681128, + "version": "1.1" + }, + "furl-1.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=3.5,<3.6.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "6d70d7b69a42da4e8de28e2fe914ff93", + "name": "furl", + "sha256": "943765691fbfc60e88705c35af95678f925b9e954731db60357714ac8d939031", + "size": 33833, + "subdir": "linux-64", + "timestamp": 1528218672519, + "version": "1.1" + }, + "furl-1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "c191f8136d9bb0279c165f2e593215ce", + "name": "furl", + "sha256": "fce8fc9c6ed6ef60fe223e839567aad8d53db68e3d3817d5efc2486c3ee78038", + "size": 33209, + "subdir": "linux-64", + "timestamp": 1528218653895, + "version": "1.1" + }, + "furl-1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=0.7.8", + "python >=3.7,<3.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "da168a953bfac2b2dd4463b6adb93b83", + "name": "furl", + "sha256": "6fe9d63048719217566b552b58a49578a18c0c2c666a2dfa47c1c333bac4a4f3", + "size": 33280, + "subdir": "linux-64", + "timestamp": 1530879379608, + "version": "1.1" + }, + "furl-1.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=1.0", + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "eae4c3cb7d391a480549b05b922c6111", + "name": "furl", + "sha256": "616ea410e011c35a5d498c926aeff4ed6edc85b7d966869028b4c1e503b35cd8", + "size": 32958, + "subdir": "linux-64", + "timestamp": 1535500127933, + "version": "1.2.1" + }, + "furl-1.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=1.0", + "python >=3.5,<3.6.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "97a0b01700156083d77dce0e769322f7", + "name": "furl", + "sha256": "0c53f5cfd62ad15b0511cdedc2f81332e24b821e856ea78a0f3e9e5b65bc829a", + "size": 33681, + "subdir": "linux-64", + "timestamp": 1535500136083, + "version": "1.2.1" + }, + "furl-1.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "1fa3f6529099bd9a7bf9e888b11cac27", + "name": "furl", + "sha256": "099b7234dc1a6b9c32e6a3fbe22bc8a526ce3434bd64fe5c4bd5ddc3b8a79c46", + "size": 33611, + "subdir": "linux-64", + "timestamp": 1535500131670, + "version": "1.2.1" + }, + "furl-1.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=1.0", + "python >=3.7,<3.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "818fd34aba8edfb6c71514ad924477a9", + "name": "furl", + "sha256": "61f320500ee32f08f62a7ffb34774b1a83154c97b0ce2e01247acab02549e2e2", + "size": 33637, + "subdir": "linux-64", + "timestamp": 1535500143308, + "version": "1.2.1" + }, + "furl-2.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=1.0", + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "b0ef055977471a12a4b834b39b1da919", + "name": "furl", + "sha256": "17cc8e4f6d781d30f8c99c4b5135f0cdb89efbe19ea464418007f7e8a2564472", + "size": 34348, + "subdir": "linux-64", + "timestamp": 1539623214269, + "version": "2.0.0" + }, + "furl-2.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "d2e9520f8e871ccb74ea596acb1d6ad5", + "name": "furl", + "sha256": "74485ceb805fd15885d902b3f2c9709025a3a872bfc9e05e99860b3e40b9ad45", + "size": 34586, + "subdir": "linux-64", + "timestamp": 1539478162128, + "version": "2.0.0" + }, + "furl-2.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "orderedmultidict >=1.0", + "python >=3.7,<3.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "86757089b35fce29e11f080a162e6638", + "name": "furl", + "sha256": "d9a97c406f1f13042d4b48307f162ffca27b6ba13481f3d0ceb02ec2f06bc50c", + "size": 34637, + "subdir": "linux-64", + "timestamp": 1539478166086, + "version": "2.0.0" + }, + "future-0.16.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4cb7e3ad932670cee9a3b64317245650", + "name": "future", + "sha256": "85cb08430d6ee21f218f77fcd18f3818747c720f06bbbb4e350ceca6b8fafd37", + "size": 649707, + "subdir": "linux-64", + "timestamp": 1530693597407, + "version": "0.16.0" + }, + "future-0.16.0-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d4a10781ec344b1f3439c1d4c721bce8", + "name": "future", + "sha256": "e7877859e22df1e83c89393de865df3b8381d4996fce12251faef7d205a25a7b", + "size": 641623, + "subdir": "linux-64", + "timestamp": 1535545061672, + "version": "0.16.0" + }, + "future-0.16.0-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cccb0e5242b555569452c6e8fa49271b", + "name": "future", + "sha256": "850a01efd476b39ba5703d855997a73fd14dc38197ca7c6976f69334abbbb564", + "size": 652021, + "subdir": "linux-64", + "timestamp": 1535788261805, + "version": "0.16.0" + }, + "future-0.16.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b165c543dfe86cbfa7decad25e00638a", + "name": "future", + "sha256": "d4f069f03898112a513a0a73e484f51d8cf979ffe40761764562222f4752a1fe", + "size": 639001, + "subdir": "linux-64", + "timestamp": 1530693534939, + "version": "0.16.0" + }, + "future-0.16.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18c99bacc77012825b9809dadc4f9c30", + "name": "future", + "sha256": "5e1dd70a81677987c74f70da85cab618890688264b1275bfc426bc08f579ae24", + "size": 629554, + "subdir": "linux-64", + "timestamp": 1530693567126, + "version": "0.16.0" + }, + "future-0.17.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1812831216c11d0f37de3b3513121d82", + "name": "future", + "sha256": "595e71e5f9910da73f6830b767d41a9a5f830c719719f89251cf19d87e0b9d9c", + "size": 651130, + "subdir": "linux-64", + "timestamp": 1540967282409, + "version": "0.17.0" + }, + "future-0.17.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d3bcfede327775a487ba23e6c54c355", + "name": "future", + "sha256": "a5dd1ee4403b280f416fbe1f575c5f2f21ee0573d333d76344f416181300b379", + "size": 631373, + "subdir": "linux-64", + "timestamp": 1540967294250, + "version": "0.17.0" + }, + "future-0.17.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f898551ce3dc6a78ac93f79c0ba9221", + "name": "future", + "sha256": "7886991981b2e75123cf4f8896e698078ab272393199668b9d4f38cd21713b13", + "size": 631185, + "subdir": "linux-64", + "timestamp": 1540967313150, + "version": "0.17.0" + }, + "future-0.17.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de90122932e194a4db932af2d31ef8bc", + "name": "future", + "sha256": "a7582d87dfdb6010181e8155ca7c989bf4defa908675ccbaab5878844b00effe", + "size": 642590, + "subdir": "linux-64", + "timestamp": 1541134222813, + "version": "0.17.1" + }, + "future-0.17.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ff7ee8a3fba460cb30d8b8bb53aef9f", + "name": "future", + "sha256": "e4545e4695876a6e909f0819cb3abb001eb53c27bf295102784800d10f74fcf5", + "size": 640503, + "subdir": "linux-64", + "timestamp": 1541134282677, + "version": "0.17.1" + }, + "future-0.17.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5fc7a5d4a28e034296264f949a48fc64", + "name": "future", + "sha256": "72301e90ef5218d0c3a35463999f944eacfb552fac45b02a94a4c515b0e21463", + "size": 630932, + "subdir": "linux-64", + "timestamp": 1541134197047, + "version": "0.17.1" + }, + "future-0.17.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5714e1872adb90acb5670fc805328850", + "name": "future", + "sha256": "4097ade0cf99f5b9f8c63279fb3ee22e4e4a83b8121b4f7d19c66f19d63ed6ce", + "size": 643325, + "subdir": "linux-64", + "timestamp": 1572880778966, + "version": "0.17.1" + }, + "future-0.18.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d2b8db9cbfa2d6aee74d1ee43bd9163", + "name": "future", + "sha256": "caf5405707fb51d1de4fc3553185903fdb558471e0fc3b1c76ba83a8355711f9", + "size": 665585, + "subdir": "linux-64", + "timestamp": 1573232739928, + "version": "0.18.2" + }, + "future-0.18.2-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dcc5d53d6bda33862b1934ec35341261", + "name": "future", + "sha256": "525607addcbb6266de090d44ed1d81c4ebe591860c344c37032bab7a60650ed6", + "size": 662409, + "subdir": "linux-64", + "timestamp": 1640790142392, + "version": "0.18.2" + }, + "future-0.18.2-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bad275fd1c46023b057a6a6d2b10a43d", + "name": "future", + "sha256": "34250660b68bea34124c00faf0ed66a0ee370ec7406d048b55239ccb78362c72", + "size": 841133, + "subdir": "linux-64", + "timestamp": 1676827184954, + "version": "0.18.2" + }, + "future-0.18.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "beace6ee65ed06817e91e68651f6ade8", + "name": "future", + "sha256": "2ee75c3d5443c2aa237b49a2c839cd4cc38e460b88cb016e412232e59936dc8a", + "size": 654811, + "subdir": "linux-64", + "timestamp": 1573232675434, + "version": "0.18.2" + }, + "future-0.18.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc559d65e16eac7065da52d95e5a50f7", + "name": "future", + "sha256": "74e7f54dfa105d1981a24eab2d3e16c13e666b5a17d07c465aba0f50b7bde36a", + "size": 654170, + "subdir": "linux-64", + "timestamp": 1591811034362, + "version": "0.18.2" + }, + "future-0.18.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8564f40667d43bfbf382975a89e901ff", + "name": "future", + "sha256": "0147706db75a1cf39c9d4636dec92d3cbad0aae4677e8cd93bf48bf1b8ecdbb0", + "size": 654141, + "subdir": "linux-64", + "timestamp": 1573232624165, + "version": "0.18.2" + }, + "future-0.18.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d3ee93b6047db58908e5e3b802a1a31", + "name": "future", + "sha256": "06e39cd49a9dee05e6c7d9ebd246c0a0b98d54bdb938bb08497490c575f9d930", + "size": 645922, + "subdir": "linux-64", + "timestamp": 1591809972903, + "version": "0.18.2" + }, + "future-0.18.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c72237a348059325e48c0a28a580c67", + "name": "future", + "sha256": "3516e3d67e2d1f9793e87c1be7ae7ddd067ab5de19b1ead28851718e417f7adb", + "size": 657398, + "subdir": "linux-64", + "timestamp": 1573232654126, + "version": "0.18.2" + }, + "future-0.18.2-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34aea374ae97858b1ea75421be6a38ef", + "name": "future", + "sha256": "dcd8c46a7bed167bc348695404221012752c75ad758c48bc953a5ec01fb55776", + "size": 647506, + "subdir": "linux-64", + "timestamp": 1591810642409, + "version": "0.18.2" + }, + "future-0.18.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "789620902cfd2e0b60633cbd63887f83", + "name": "future", + "sha256": "f84faae1b4ce0e1b4285c1bdd0f2e9aa5925e35edf289f5785752ddc25608cef", + "size": 647629, + "subdir": "linux-64", + "timestamp": 1607571374156, + "version": "0.18.2" + }, + "future-0.18.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f29c1ae56e18021da379520436f005a", + "name": "future", + "sha256": "e3cd618952823abb9903cbd45800b71dc6590087bdfb14122ae4ef38db0d4b33", + "size": 707843, + "subdir": "linux-64", + "timestamp": 1677599962721, + "version": "0.18.3" + }, + "future-0.18.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cefad90eb98b6fcb78eaad6420e4fd34", + "name": "future", + "sha256": "a9444997d4f2821d2674182d9df428f647bf4366fe479ec2b1ca0b5874c7347b", + "size": 843521, + "subdir": "linux-64", + "timestamp": 1679335951872, + "version": "0.18.3" + }, + "future-0.18.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca61a1c5f7c3a2acd16a2467ddb03b81", + "name": "future", + "sha256": "4e204c86eb5375ac069d38a822e85388dec9a0113af79671ec610e8c33f61b59", + "size": 685436, + "subdir": "linux-64", + "timestamp": 1677599903548, + "version": "0.18.3" + }, + "future-0.18.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90d891c80a489337f59c7b841bcc59dd", + "name": "future", + "sha256": "ba4489cee31c5b64b351b0de333f1ba54373ffb9c218a13a66fdc88ac4d522c7", + "size": 687889, + "subdir": "linux-64", + "timestamp": 1677599990780, + "version": "0.18.3" + }, + "future-0.18.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea4ecba8f223fff9fadcf120fb41d8c0", + "name": "future", + "sha256": "76ee12dc5703be99cc8dd6617f9b3f7589d51f710560e4f158ce02d76b3b41d9", + "size": 687051, + "subdir": "linux-64", + "timestamp": 1677599933597, + "version": "0.18.3" + }, + "futures-3.1.1-py27hdbc8cbb_0.conda": { + "build": "py27hdbc8cbb_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "203769ae908f1b5d5f73d3ac850ec392", + "name": "futures", + "sha256": "d49e4f50f1a73249aa3494679dbfecb591240bb84f27bc86933f74c19c56ea23", + "size": 23992, + "subdir": "linux-64", + "timestamp": 1505733247585, + "version": "3.1.1" + }, + "futures-3.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "e9ad9bd960d3dc35052dfa4438496a9f", + "name": "futures", + "sha256": "514d44ef168745cda27270acf3084594dd39c21f262574bf6ba3ba58442bd4a3", + "size": 25512, + "subdir": "linux-64", + "timestamp": 1530735271877, + "version": "3.2.0" + }, + "futures-3.2.0-py27_1000.conda": { + "build": "py27_1000", + "build_number": 1000, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "af86b91d2260819be81cac309600d6c3", + "name": "futures", + "sha256": "befc8f6e87df19d2dbee9dcd6cb7a925a6f7ca9201dbc93aec3e1d131e653bb3", + "size": 29179, + "subdir": "linux-64", + "timestamp": 1558589210132, + "version": "3.2.0" + }, + "futures-3.2.0-py27h7b459c0_0.conda": { + "build": "py27h7b459c0_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "6ab2fa5e830308e670b0a235384f6b74", + "name": "futures", + "sha256": "5959083949d30e1556b0329dc8b0cc985569bb6c00fd22293000ade60188ffa5", + "size": 25853, + "subdir": "linux-64", + "timestamp": 1512192950121, + "version": "3.2.0" + }, + "futures-3.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "5546c0be44976e7593b69b0c48febfb7", + "name": "futures", + "sha256": "0f46cbc8d2a2f0f9dbdc9d53a2b765a3ef51058e046bf2b0b1c10c257b711641", + "size": 29336, + "subdir": "linux-64", + "timestamp": 1563286742065, + "version": "3.3.0" + }, + "fuzzywuzzy-0.18.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "76920ded59e9cb8949306e9fc94cb2db", + "name": "fuzzywuzzy", + "sha256": "40e5393420e4cfc82968e35ed6781f168978b3dd891798f249abb069d166423a", + "size": 27302, + "subdir": "linux-64", + "timestamp": 1650548292461, + "version": "0.18.0" + }, + "fuzzywuzzy-0.18.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "6078a882b917ec75f2ebc26469cd7e57", + "name": "fuzzywuzzy", + "sha256": "2e6e7e726b7d05d473847eb5093eea63aecb4c81f4a096f180c0a2cebbf7c292", + "size": 31327, + "subdir": "linux-64", + "timestamp": 1676852518908, + "version": "0.18.0" + }, + "fuzzywuzzy-0.18.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "fb69d4b85fe0740bafadac364d6fa28b", + "name": "fuzzywuzzy", + "sha256": "15e6fd028f905945a72fd4930ea3fa67f9fe3b80cb2031a105fe3ecd9fff888d", + "size": 27101, + "subdir": "linux-64", + "timestamp": 1650548256396, + "version": "0.18.0" + }, + "fuzzywuzzy-0.18.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "386cfbacc5c3ce57bb6f022781377aea", + "name": "fuzzywuzzy", + "sha256": "31cc4c887243a8b81e24ac7dd91813e3113aeabeff639247c9e04cce7a731716", + "size": 27196, + "subdir": "linux-64", + "timestamp": 1650548316884, + "version": "0.18.0" + }, + "fuzzywuzzy-0.18.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "b14ad989c3d238a31bad13c442d48c7a", + "name": "fuzzywuzzy", + "sha256": "d5d9b3a49532666d3f0c828176b288b57e4e2e6806d5ac26374d11e87d2fa779", + "size": 27160, + "subdir": "linux-64", + "timestamp": 1650548231543, + "version": "0.18.0" + }, + "g2clib-1.6.0-h838ce51_4.conda": { + "build": "h838ce51_4", + "build_number": 4, + "depends": [ + "jasper >=1.900.1,<2.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public Domain", + "md5": "4852c559df53f00c918b7ac7c9a1cf23", + "name": "g2clib", + "sha256": "6cf9b0667bf653cd191216f4e6816c5654a04e8250f62af83cfdae1cdffe8fb9", + "size": 57715, + "subdir": "linux-64", + "timestamp": 1512065852712, + "version": "1.6.0" + }, + "g2clib-1.6.0-h8a8886c_5.conda": { + "build": "h8a8886c_5", + "build_number": 5, + "depends": [ + "jasper >=2.0.14,<3.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public Domain", + "md5": "5b464877b2d9fc443474a6a634f67191", + "name": "g2clib", + "sha256": "9e503aa800bb8a096b29eeffc435c12d84c09ad0fb35cfb23e1f50185da4928b", + "size": 57749, + "subdir": "linux-64", + "timestamp": 1531092606455, + "version": "1.6.0" + }, + "g2clib-1.6.2-ha7d24e7_0.conda": { + "build": "ha7d24e7_0", + "build_number": 0, + "depends": [ + "jasper >=2.0.14,<3.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public Domain", + "md5": "e72260736795be742bd30e8f91307c03", + "name": "g2clib", + "sha256": "dbb8244af6ecc59c5ead6cc50d28da7267ee05e3797bda587b30967605ad44b3", + "size": 58617, + "subdir": "linux-64", + "timestamp": 1608329007862, + "version": "1.6.2" + }, + "g2clib-1.6.3-ha7d24e7_0.conda": { + "build": "ha7d24e7_0", + "build_number": 0, + "depends": [ + "jasper >=2.0.14,<3.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public Domain", + "md5": "edf4e143174da5b7abd3ad35a92f81d6", + "name": "g2clib", + "sha256": "43fcb39e61b1123ce19063d1cedfd7406fbc925d468ab803ac54381eae49bf5f", + "size": 55561, + "subdir": "linux-64", + "timestamp": 1615381036664, + "version": "1.6.3" + }, + "gast-0.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "45e8175c7a5ba6b86b117a2408f24ecc", + "name": "gast", + "sha256": "75e1c98ae0579e991c28371c26efdf5b70345c1cb8b87addbbd71edc2c644e0e", + "size": 15779, + "subdir": "linux-64", + "timestamp": 1519945760708, + "version": "0.2.0" + }, + "gast-0.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "38a9016d0ce08ca69dd5d6de5d4c147c", + "name": "gast", + "sha256": "d9a34a58dddf21e5170aebcd0049f4961e50d234521b2917b5df3f4d3907ae2b", + "size": 15993, + "subdir": "linux-64", + "timestamp": 1519945768224, + "version": "0.2.0" + }, + "gast-0.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "ef4f6dbc444030bfa998aade55aaabf3", + "name": "gast", + "sha256": "cdb2d8005f9caf6492a75a1224ba36e833f84e061363eae8e942bf40f1cfdf8d", + "size": 15481, + "subdir": "linux-64", + "timestamp": 1519945787974, + "version": "0.2.0" + }, + "gast-0.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "b3db29dc667547c5259f13348953b570", + "name": "gast", + "sha256": "4749aa4a92af6bd1a9e9af1e1cb54048e3420b061ce055299a1807ffb205b7b5", + "size": 15044, + "subdir": "linux-64", + "timestamp": 1530879408932, + "version": "0.2.0" + }, + "gast-0.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "8f89eab83f62885e27b890c73bcf696e", + "name": "gast", + "sha256": "427f88f89dde7f63ef008c3ae48516739f4347b36491a8d2db6921e2fc229a42", + "size": 158203, + "subdir": "linux-64", + "timestamp": 1547229621936, + "version": "0.2.1" + }, + "gast-0.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "e1f9a0aeabc989d3b68d9022fe1a1bd7", + "name": "gast", + "sha256": "a4f3f1dedadd08781d69717ebd2fdd75653cb146327933b6c98dc7604c6fe14f", + "size": 157893, + "subdir": "linux-64", + "timestamp": 1547229640591, + "version": "0.2.1" + }, + "gast-0.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "7ee22c2b2d28878585e4391fbd342f51", + "name": "gast", + "sha256": "c7cb2879a49a2feb41c4a6c87ef4690b911b2fdc048f5173ece0bb0bf26becce", + "size": 157227, + "subdir": "linux-64", + "timestamp": 1547229606088, + "version": "0.2.1" + }, + "gast-0.2.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "1fe0f42df8c3d4012cf0f13b5a6dcd4f", + "name": "gast", + "sha256": "8295eb2ffb8fbe596998bb1e4f3bf5e0962a6b0ab8658e83e5db1da36e509559", + "size": 158359, + "subdir": "linux-64", + "timestamp": 1547749522913, + "version": "0.2.2" + }, + "gast-0.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "06c736bca7b89d76d960c6298f357d43", + "name": "gast", + "sha256": "0ada5e5eb6b2720a08b59989872ef03c8704d954fd2d416c08faa685ce824ca3", + "size": 158642, + "subdir": "linux-64", + "timestamp": 1547749527299, + "version": "0.2.2" + }, + "gast-0.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD License", + "license_family": "BSD", + "md5": "20622ada1efb2a83ef9f53aaf2c4f452", + "name": "gast", + "sha256": "3b9be3d0b94bd9ef4485ed09c0be4f58bc218cf1555f88058c2ca6ab04800498", + "size": 158389, + "subdir": "linux-64", + "timestamp": 1547749463316, + "version": "0.2.2" + }, + "gawk-4.2.1-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "7eac0a5ac1c1f733e5b7e02097bb5034", + "name": "gawk", + "sha256": "6d920cadf96260d09f1dff8e1a49a5702ee936ea80bde58f408d863cd0335551", + "size": 998680, + "subdir": "linux-64", + "timestamp": 1527332422904, + "version": "4.2.1" + }, + "gawk-5.0.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "bfec398b2022160fd1c9c4ae1ef9d25d", + "name": "gawk", + "sha256": "55e74ccb0834c185fbf27fac9e2a449b2385c60020b94c5b21291351685e0734", + "size": 1038455, + "subdir": "linux-64", + "timestamp": 1558589486887, + "version": "5.0.0" + }, + "gawk-5.0.1-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "b8a9298b17789a059e09d3a66e959329", + "name": "gawk", + "sha256": "ad1a664f11fa1643e8fede920099c50e6c944ff23c4f90f8e75115172f2dbcb2", + "size": 1040799, + "subdir": "linux-64", + "timestamp": 1565191723331, + "version": "5.0.1" + }, + "gawk-5.1.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "6ca63b7f8a106833de8e4c07d60d0aa6", + "name": "gawk", + "sha256": "d7ffde582cfb137110080a140d93859c1b7f86d165f70d6ca5ca5a57b430dd0f", + "size": 1031206, + "subdir": "linux-64", + "timestamp": 1587132617252, + "version": "5.1.0" + }, + "gcab-1.4-h8b4e3a7_0.conda": { + "build": "h8b4e3a7_0", + "build_number": 0, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "8a6ebca2d2666ac7b0b6bf8e41749f51", + "name": "gcab", + "sha256": "4f228ac929e3594a94392110783912583d4b030b628788706ae92df13c16f8cd", + "size": 62990, + "subdir": "linux-64", + "timestamp": 1667484696429, + "version": "1.4" + }, + "gcc-dbg_linux-64-7.2.0-19.conda": { + "build": "19", + "build_number": 19, + "depends": [ + "binutils_linux-64 7.2.0 19", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "cf2eb846d5287235139b95a9208b05e4", + "name": "gcc-dbg_linux-64", + "sha256": "c587fdf9e4c7f74a868e50ac23648539425ff33842243f8235a36a48aebd7ac6", + "size": 6694, + "subdir": "linux-64", + "timestamp": 1513886592858, + "version": "7.2.0" + }, + "gcc-dbg_linux-64-7.2.0-24.conda": { + "build": "24", + "build_number": 24, + "depends": [ + "binutils_linux-64 7.2.0 24", + "gcc_impl_linux-64 7.2.0.*", + "package_has_been_revoked" + ], + "license": "GPL", + "md5": "62554052f2dfa198f548787212193b3e", + "name": "gcc-dbg_linux-64", + "revoked": true, + "sha256": "de3773b38a9b5740c1764f8518dff44e1138fb0c4f1e4e501dc88c7401f7a05c", + "size": 6112, + "subdir": "linux-64", + "timestamp": 1514480887329, + "version": "7.2.0" + }, + "gcc-dbg_linux-64-7.2.0-25.conda": { + "build": "25", + "build_number": 25, + "depends": [ + "binutils_linux-64 7.2.0 25", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "bb58bb3c916fb7f7c5425859791f5e96", + "name": "gcc-dbg_linux-64", + "sha256": "3426156c5133abc9c624b50153cbaae17acc9d0b2e9ad05ddd8b4d29b50add20", + "size": 6121, + "subdir": "linux-64", + "timestamp": 1515156400620, + "version": "7.2.0" + }, + "gcc-dbg_linux-64-7.3.0-h553295d_1.conda": { + "build": "h553295d_1", + "build_number": 1, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_1", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "db6301673358e7805b1877eb72af0a03", + "name": "gcc-dbg_linux-64", + "sha256": "43f82db4a8584926ddf0e29c70a3b9c1f22594b62430e88dd51c5fb15e4227fb", + "size": 10863, + "subdir": "linux-64", + "timestamp": 1534694155758, + "version": "7.3.0" + }, + "gcc-dbg_linux-64-7.3.0-h553295d_2.conda": { + "build": "h553295d_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_2", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "e06eff34edcf39b21dce325c0f489612", + "name": "gcc-dbg_linux-64", + "sha256": "7f5fa90968669ff576735e2dc1911ec1862c2256190ccc63e2d540f001534389", + "size": 10869, + "subdir": "linux-64", + "timestamp": 1534794490768, + "version": "7.3.0" + }, + "gcc-dbg_linux-64-7.3.0-h553295d_26.conda": { + "build": "h553295d_26", + "build_number": 26, + "depends": [ + "binutils_linux-64 7.3.0 h6176602_26", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "ff989027bc2bf8523947c972babdd693", + "name": "gcc-dbg_linux-64", + "sha256": "e6fcc78102f4d185f57167bd94f061b18540c23d16c205436db059353a2a4adb", + "size": 10333, + "subdir": "linux-64", + "timestamp": 1534693901075, + "version": "7.3.0" + }, + "gcc-dbg_linux-64-8.2.0-h218040c_1.conda": { + "build": "h218040c_1", + "build_number": 1, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_1", + "gcc_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "ff27cf9ea5199dad38c96cac559b4d5d", + "name": "gcc-dbg_linux-64", + "sha256": "28ef236c65f679c808e99b9cb9b182c9460f1913a8d21d38c2d3f4dd27bde390", + "size": 10851, + "subdir": "linux-64", + "timestamp": 1534694048676, + "version": "8.2.0" + }, + "gcc-dbg_linux-64-8.2.0-h218040c_26.conda": { + "build": "h218040c_26", + "build_number": 26, + "depends": [ + "binutils_linux-64 8.2.0 h6176602_26", + "gcc_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "e6ea368057fc20abda81e520cddea088", + "name": "gcc-dbg_linux-64", + "sha256": "27137b64391af5a3a27eaa3af26c4a8eae11f31d6f16ce79545d91e71559284e", + "size": 10337, + "subdir": "linux-64", + "timestamp": 1534693817310, + "version": "8.2.0" + }, + "gcc_bootstrap_linux-64-11.2.0-h99d4493_0.conda": { + "build": "h99d4493_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=4.9", + "libstdcxx-ng >=4.9" + ], + "license": "GPL", + "md5": "d370dba3d148a51d515064b65e4bf6fd", + "name": "gcc_bootstrap_linux-64", + "sha256": "d56857d6476517fc2b4827de0a30c690fcce1c1e22370e7f41bf904f3b7e593e", + "size": 73051199, + "subdir": "linux-64", + "timestamp": 1652867324153, + "version": "11.2.0" + }, + "gcc_bootstrap_linux-64-7.3.0-h64e4fec_15.conda": { + "build": "h64e4fec_15", + "build_number": 15, + "depends": [], + "license": "GPL", + "md5": "8472137618b47985d92ad390f2e5d288", + "name": "gcc_bootstrap_linux-64", + "sha256": "099f78508c6e5dedd59f89ac2e2cb0446017cd2ef51da9aa38628bfdb10b3943", + "size": 68290845, + "subdir": "linux-64", + "timestamp": 1576707947593, + "version": "7.3.0" + }, + "gcc_bootstrap_linux-64-7.3.0-h64e4fec_9.conda": { + "build": "h64e4fec_9", + "build_number": 9, + "depends": [], + "license": "GPL", + "md5": "333aa961802bfb01cad10497169414f2", + "name": "gcc_bootstrap_linux-64", + "sha256": "a4870b378e98f749a26f07de4d92b03390aed55e938afd389b1bc59279e1e399", + "size": 69180841, + "subdir": "linux-64", + "timestamp": 1576689821203, + "version": "7.3.0" + }, + "gcc_bootstrap_linux-64-9.3.0-hb95220a_30.conda": { + "build": "hb95220a_30", + "build_number": 30, + "depends": [], + "license": "GPL", + "md5": "eee5cbffc5a0d34be78d8c04c27d3955", + "name": "gcc_bootstrap_linux-64", + "sha256": "3afda1ea96412cd7187ff3ef5a42565ab32401d89b28269ad8d87da54e3659d2", + "size": 64041366, + "subdir": "linux-64", + "timestamp": 1623136540355, + "version": "9.3.0" + }, + "gcc_impl_linux-64-11.2.0-h1234567_0.conda": { + "build": "h1234567_0", + "build_number": 0, + "depends": [ + "binutils_impl_linux-64 >=2.38", + "libgcc-devel_linux-64 11.2.0 h1234567_0", + "libgcc-ng >=11.2.0", + "libgcc-ng >=4.9", + "libgomp >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libstdcxx-ng >=4.9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "af6a5255cd42524619e9d43c5e8ac654", + "name": "gcc_impl_linux-64", + "sha256": "b5f8ad5af3a03e70b0994364f872b78783aa981f3a7cd5c760dab4e9a68923f8", + "size": 23372396, + "subdir": "linux-64", + "timestamp": 1652859794417, + "version": "11.2.0" + }, + "gcc_impl_linux-64-11.2.0-h1234567_1.conda": { + "build": "h1234567_1", + "build_number": 1, + "depends": [ + "binutils_impl_linux-64 >=2.38", + "libgcc-devel_linux-64 11.2.0 h1234567_1", + "libgcc-ng >=11.2.0", + "libgcc-ng >=4.9", + "libgomp >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libstdcxx-ng >=4.9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "d3fa9d40b5dcc3f227b78bf2fdc2bf2c", + "name": "gcc_impl_linux-64", + "sha256": "84035d4168f91d282b4a5c724b53e20cb2a07f5ad0da325633f3047ef064366f", + "size": 23277954, + "subdir": "linux-64", + "timestamp": 1654090883178, + "version": "11.2.0" + }, + "gcc_impl_linux-64-5.4.0-habb00fd_3.conda": { + "build": "habb00fd_3", + "build_number": 3, + "depends": [ + "binutils_impl_linux-64 >=2.28.1,<3", + "libstdcxx-ng >=5.4.0" + ], + "license": "GPL", + "md5": "14a4257c698129216c9e9bd593d84aa8", + "name": "gcc_impl_linux-64", + "sha256": "e459531f6a0b74e2e0b0b647aac74935c1e3009368052bed1a917b02a9755501", + "size": 37159540, + "subdir": "linux-64", + "timestamp": 1520969643017, + "version": "5.4.0" + }, + "gcc_impl_linux-64-7.2.0-habb00fd_3.conda": { + "build": "habb00fd_3", + "build_number": 3, + "depends": [ + "binutils_impl_linux-64 >=2.28.1,<3", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL", + "md5": "9bb470917c8bddb1d2f67885e7e7a9ec", + "name": "gcc_impl_linux-64", + "sha256": "c7b5b8ac9b7043e4d0b52aa5382346d4b43946d6a7867ee87ee7151009336b3c", + "size": 43786216, + "subdir": "linux-64", + "timestamp": 1520534652729, + "version": "7.2.0" + }, + "gcc_impl_linux-64-7.2.0-hc5ce805_2.conda": { + "build": "hc5ce805_2", + "build_number": 2, + "depends": [ + "binutils_impl_linux-64 >=2.28.1,<3", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL", + "md5": "42f9df4fed369ee2442c6ce502378403", + "name": "gcc_impl_linux-64", + "sha256": "1cd561d04ebf5c997c3d3600572db8dadfd661f2a1a4ad824cd7f53fe8f5b3ef", + "size": 43163165, + "subdir": "linux-64", + "timestamp": 1507262906442, + "version": "7.2.0" + }, + "gcc_impl_linux-64-7.3.0-habb00fd_0.conda": { + "build": "habb00fd_0", + "build_number": 0, + "depends": [ + "binutils_impl_linux-64 >=2.31.1,<3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL", + "md5": "ebebbcf15fadbdbf750534bab6240ce7", + "name": "gcc_impl_linux-64", + "sha256": "8cc7185b50171608d8153681bc0750ab6dde028237df54c15ffd25aa8963cea7", + "size": 43887005, + "subdir": "linux-64", + "timestamp": 1534628568186, + "version": "7.3.0" + }, + "gcc_impl_linux-64-7.3.0-habb00fd_1.conda": { + "build": "habb00fd_1", + "build_number": 1, + "depends": [ + "binutils_impl_linux-64 >=2.31.1,<3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL", + "md5": "e24fbc909241689b3343957585eb92cb", + "name": "gcc_impl_linux-64", + "sha256": "c1f707c081f04a5d8318a25538cf60e75d881132ab8cf8e22050ea8f2b0ca8d3", + "size": 43907951, + "subdir": "linux-64", + "timestamp": 1534866771998, + "version": "7.3.0" + }, + "gcc_linux-64-11.2.0-h5c386dc_0.conda": { + "build": "h5c386dc_0", + "build_number": 0, + "depends": [ + "binutils_linux-64 2.38.0 hc2dff05_0", + "gcc_impl_linux-64 11.2.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "7bae27e21eb72075de5ab141c041372c", + "name": "gcc_linux-64", + "sha256": "f0a83477336d5094afeccb3095ca61fad53966a40eecec33f1205d45732b1dcb", + "size": 26109, + "subdir": "linux-64", + "timestamp": 1652867211979, + "version": "11.2.0" + }, + "gcc_linux-64-5.4.0-h98af8de_24.conda": { + "build": "h98af8de_24", + "build_number": 24, + "depends": [ + "binutils_linux-64 5.4.0 had2808c_24", + "gcc_impl_linux-64 5.4.0.*" + ], + "license": "GPL", + "md5": "3417bf7640a4dece461d055b80bcba9c", + "name": "gcc_linux-64", + "sha256": "a400ee850b6ac1aaedb9b03a5726246ce42e68f245cc20aff13cc6a509cdbb41", + "size": 9908, + "subdir": "linux-64", + "timestamp": 1520970082066, + "version": "5.4.0" + }, + "gcc_linux-64-7.2.0-19.conda": { + "build": "19", + "build_number": 19, + "depends": [ + "binutils_linux-64 7.2.0 19", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "14e434bc52ca846f00ae5e5be629b3b9", + "name": "gcc_linux-64", + "sha256": "96f05dcc36d934c452beb2e37d1880db3f28543f78280af9596db0b30abe3660", + "size": 6578, + "subdir": "linux-64", + "timestamp": 1513886714900, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-24.conda": { + "build": "24", + "build_number": 24, + "depends": [ + "package_has_been_revoked" + ], + "license": "GPL", + "md5": "c121043af6bb01c27b60cb6c9059a1cf", + "name": "gcc_linux-64", + "revoked": true, + "sha256": "0162b181a4de0fcfba8789521a1ce1156960f2488512891a0ee75e102989955b", + "size": 6044, + "subdir": "linux-64", + "timestamp": 1514474638847, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-25.conda": { + "build": "25", + "build_number": 25, + "depends": [ + "binutils_linux-64 7.2.0 25", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "21fd1034e6e5bcea69f83fcb0524a57a", + "name": "gcc_linux-64", + "sha256": "5510d726d1c7991045d12b60b951695be584cc9e03739fe2a44ddf18f0d9dbb4", + "size": 6088, + "subdir": "linux-64", + "timestamp": 1514480906213, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-26.conda": { + "build": "26", + "build_number": 26, + "depends": [ + "binutils_linux-64 7.2.0 26", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "e1a6ffdf8823ea887bf260bced6cfce7", + "name": "gcc_linux-64", + "sha256": "39a221589098c1440d9185214d480ee32e54350f0497321da1328ab7a4eae167", + "size": 10035, + "subdir": "linux-64", + "timestamp": 1521829426235, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-h196ecd4_10.conda": { + "build": "h196ecd4_10", + "build_number": 10, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_10", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "afb0afbb6d7f3d53cc5dd0016794db64", + "name": "gcc_linux-64", + "sha256": "d228407e26da0dd6ac76bac0cd523fbecef6228d0865824b655f5b9698241a12", + "size": 5331, + "subdir": "linux-64", + "timestamp": 1510244819367, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-h217957b_13.conda": { + "build": "h217957b_13", + "build_number": 13, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_13", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "f254f0194756a8711e309d459c6d3a12", + "name": "gcc_linux-64", + "sha256": "fb969a97bc673e0ed78f836c1ee672bc3767b3f1c51e98ccbb8ca007aa6ed98b", + "size": 5640, + "subdir": "linux-64", + "timestamp": 1510925048019, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-h22f992b_7.conda": { + "build": "h22f992b_7", + "build_number": 7, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_7", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "0c141fee5889b745ec1cbabb817653ca", + "name": "gcc_linux-64", + "sha256": "7b92441f0cf39747be99298168cacb846883ed2f3ca2f94fb9bebf2c69623028", + "size": 5233, + "subdir": "linux-64", + "timestamp": 1507845399722, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-h29fd5c9_3.conda": { + "build": "h29fd5c9_3", + "build_number": 3, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_3", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "35bf42899e1e3bc38adb2bdebaca8867", + "name": "gcc_linux-64", + "sha256": "5372b4aabe150f4d6e150bce5ef54ae8811a406521eec2058d0f2c32167663cf", + "size": 5452, + "subdir": "linux-64", + "timestamp": 1507320234616, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-h4118e58_11.conda": { + "build": "h4118e58_11", + "build_number": 11, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_11", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "e8b639fda743712e9617514a2b16f67e", + "name": "gcc_linux-64", + "sha256": "54e2f7be41d04dbb7863983f34b5e43c6615922e2568799a4f387c067c631839", + "size": 5432, + "subdir": "linux-64", + "timestamp": 1510566119502, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-h550dcbe_27.conda": { + "build": "h550dcbe_27", + "build_number": 27, + "depends": [ + "binutils_linux-64 7.2.0 had2808c_27", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "76203afe2f3217a49e544d1af85ace87", + "name": "gcc_linux-64", + "sha256": "4e30c568e47066dc6920457ff6f8d2bca6f801eb081738347d57e538298edb18", + "size": 9983, + "subdir": "linux-64", + "timestamp": 1526461254217, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-h60973fd_9.conda": { + "build": "h60973fd_9", + "build_number": 9, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_9", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "90aa8f64b30d5b21862a9d323301422b", + "name": "gcc_linux-64", + "sha256": "d41e0b95a72bbd358512b73744f805b0710e119473a9a8a9fcc709373e3472d3", + "size": 5443, + "subdir": "linux-64", + "timestamp": 1509836579789, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-h6f34251_8.conda": { + "build": "h6f34251_8", + "build_number": 8, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_8", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "84c3439768893beec15071d64c58fbd2", + "name": "gcc_linux-64", + "sha256": "ec33f8a48d74b8481dbf4ec80cb5ea2b842ff2d5d81065c8bd7109451c173aa6", + "size": 5177, + "subdir": "linux-64", + "timestamp": 1509635178401, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-haf1f6fa_15.conda": { + "build": "haf1f6fa_15", + "build_number": 15, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_15", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "4c76c0257090487094694426d0dddcde", + "name": "gcc_linux-64", + "sha256": "b836d2660c6f289b2c88abf6dc12332bbd797c5f72c9c9e799879558abcf3f23", + "size": 5634, + "subdir": "linux-64", + "timestamp": 1511640858292, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-hc7b1ceb_1.conda": { + "build": "hc7b1ceb_1", + "build_number": 1, + "depends": [ + "binutils_linux-64 2.28.1 he4fe6c7_1" + ], + "license": "GPL", + "md5": "75953b42dfebe99f3ba0206106ff9745", + "name": "gcc_linux-64", + "sha256": "7c8695bd984c2127491630c518e0ce130e5fb734376ce8c04a9f189787af7c75", + "size": 43644208, + "subdir": "linux-64", + "timestamp": 1505665670247, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-hd763dfe_12.conda": { + "build": "hd763dfe_12", + "build_number": 12, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_12", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "739b620a181d454fd4bff3efcfc7d672", + "name": "gcc_linux-64", + "sha256": "10aba4fc1167b0633031688211e24bf70ef9619ac4fe06903c4fbf91c6e41c5c", + "size": 6087, + "subdir": "linux-64", + "timestamp": 1510792709510, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-hecb3f9c_2.conda": { + "build": "hecb3f9c_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_2", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "a48df58c3307827c6fff80db0ed1ddb7", + "name": "gcc_linux-64", + "sha256": "b5d75f222c251fd4e143eb3caf28662c3afe5b4d8d9c61ecbb68aea87f92c6d0", + "size": 5455, + "subdir": "linux-64", + "timestamp": 1507320098487, + "version": "7.2.0" + }, + "gcc_linux-64-7.2.0-hf1c97a4_14.conda": { + "build": "hf1c97a4_14", + "build_number": 14, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_14", + "gcc_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "48eb07be61db5b77781047d98fbe650f", + "name": "gcc_linux-64", + "sha256": "9f2714b303ddbcb68a3132436e459869885063ad1ea418460b06fb2dfcfecfda", + "size": 5639, + "subdir": "linux-64", + "timestamp": 1510930963879, + "version": "7.2.0" + }, + "gcc_linux-64-7.3.0-h553295d_1.conda": { + "build": "h553295d_1", + "build_number": 1, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_1", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "d39ead98fb776a8e99bc3398988dc9ec", + "name": "gcc_linux-64", + "sha256": "b282c261436b0d8636ca4a9dbebed6affc4f09055d517153f44f89a9b80c3e31", + "size": 11051, + "subdir": "linux-64", + "timestamp": 1534628901966, + "version": "7.3.0" + }, + "gcc_linux-64-7.3.0-h553295d_15.conda": { + "build": "h553295d_15", + "build_number": 15, + "depends": [ + "binutils_linux-64 2.33.1 h9595d00_15", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "BSD-3-Clause", + "md5": "26697dc38e05d06a3a2da1670c527811", + "name": "gcc_linux-64", + "sha256": "55f0a6b947bb6c8d47d5c87a897e33fc895d44af0e2348fee734e89cd0ea4279", + "size": 27770, + "subdir": "linux-64", + "timestamp": 1576707749392, + "version": "7.3.0" + }, + "gcc_linux-64-7.3.0-h553295d_2.conda": { + "build": "h553295d_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_2", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "08cc3c4d2059617ca0b3c632922e0604", + "name": "gcc_linux-64", + "sha256": "b437331a700cde1201d3026ce315357602eeb33ed8face870982f148a272e59a", + "size": 10895, + "subdir": "linux-64", + "timestamp": 1534793051330, + "version": "7.3.0" + }, + "gcc_linux-64-7.3.0-h553295d_3.conda": { + "build": "h553295d_3", + "build_number": 3, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_3", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "b2d7cef2b571e3665d0464f608c877c2", + "name": "gcc_linux-64", + "sha256": "6c854d92a617ba996201edd446ee68b183a66edce44525ea27dc005258a27634", + "size": 10887, + "subdir": "linux-64", + "timestamp": 1534948640654, + "version": "7.3.0" + }, + "gcc_linux-64-7.3.0-h553295d_6.conda": { + "build": "h553295d_6", + "build_number": 6, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_6", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "2126a89100f8ad9ae63e80739d880d16", + "name": "gcc_linux-64", + "sha256": "b974553df064564bda8b99c13b9e88c7b3c527c89e42b18c83963197fa722d85", + "size": 11991, + "subdir": "linux-64", + "timestamp": 1546883610036, + "version": "7.3.0" + }, + "gcc_linux-64-7.3.0-h553295d_7.conda": { + "build": "h553295d_7", + "build_number": 7, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_7", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "908b5cc043ff6c5d288525459677c187", + "name": "gcc_linux-64", + "sha256": "d33204b592135d69858f9b3eab6f62f6b1a58092392a73d1568c383d3cbfef71", + "size": 11114, + "subdir": "linux-64", + "timestamp": 1556137064827, + "version": "7.3.0" + }, + "gcc_linux-64-7.3.0-h553295d_8.conda": { + "build": "h553295d_8", + "build_number": 8, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_8", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "eee9951e27ba6e72b28965bd3ceac1c7", + "name": "gcc_linux-64", + "sha256": "73c3a8deb1f436c4621ed29c7b2b1aab4cd4fbd22177509d73efdaad157c7e54", + "size": 173106, + "subdir": "linux-64", + "timestamp": 1565123442020, + "version": "7.3.0" + }, + "gcc_linux-64-7.3.0-h553295d_9.conda": { + "build": "h553295d_9", + "build_number": 9, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_9", + "gcc_impl_linux-64 7.3.0.*" + ], + "license": "BSD-3-Clause", + "md5": "7d9271738b3ab47276c89f0ad7247fb4", + "name": "gcc_linux-64", + "sha256": "7d0ab1ac8318bd9445b1115d49abaa76a3fcd8c09dd30bbd86837d325d3ac55b", + "size": 27774, + "subdir": "linux-64", + "timestamp": 1576689709738, + "version": "7.3.0" + }, + "gcc_linux-64-7.5.0-h8f34230_30.conda": { + "build": "h8f34230_30", + "build_number": 30, + "depends": [ + "binutils_linux-64 2.35.1 h454624a_30", + "gcc_impl_linux-64 7.5.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "59e47aafaa1ed79bbf5fba738c990f1b", + "name": "gcc_linux-64", + "sha256": "c6c239658ccc8a25880cbd353ac4a6f43339136bb8ae966c397e97311150065f", + "size": 25733, + "subdir": "linux-64", + "timestamp": 1623135025610, + "version": "7.5.0" + }, + "gcc_linux-64-8.2.0-h218040c_2.conda": { + "build": "h218040c_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_2", + "gcc_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "2b1c8bf7a124dd3e1cd514f36a48f57d", + "name": "gcc_linux-64", + "sha256": "ef14005658989a339f2e7333e5eb2b709721f9692fc3137cb0d9272473562ccf", + "size": 10904, + "subdir": "linux-64", + "timestamp": 1534792655651, + "version": "8.2.0" + }, + "gcc_linux-64-8.2.0-h218040c_3.conda": { + "build": "h218040c_3", + "build_number": 3, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_3", + "gcc_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "65f4c0792fda515f4841c6c042b44c16", + "name": "gcc_linux-64", + "sha256": "488cd1cbd489d8e8c123bb8f9ee6268368e5fb41c0e1868e617357dde9e28d6e", + "size": 11995, + "subdir": "linux-64", + "timestamp": 1546883587488, + "version": "8.2.0" + }, + "gcc_linux-64-8.4.0-he201b7d_30.conda": { + "build": "he201b7d_30", + "build_number": 30, + "depends": [ + "binutils_linux-64 2.35.1 h454624a_30", + "gcc_impl_linux-64 8.4.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "438721d2f56c2c62e8ddd43576ad2635", + "name": "gcc_linux-64", + "sha256": "91198bb773b7c2d1503defdca5f312ade68bc64492693be9a34a713fdc02de81", + "size": 25785, + "subdir": "linux-64", + "timestamp": 1623135558243, + "version": "8.4.0" + }, + "gcc_linux-64-9.3.0-h1ee779e_30.conda": { + "build": "h1ee779e_30", + "build_number": 30, + "depends": [ + "binutils_linux-64 2.35.1 h454624a_30", + "gcc_impl_linux-64 9.3.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "d6d8cd60265be3603ab2188170cf5942", + "name": "gcc_linux-64", + "sha256": "7d84e461a6d41ee2013aca4c47beed144e7be0c2eb8eb591db93dd8fac4c8ef8", + "size": 25733, + "subdir": "linux-64", + "timestamp": 1623136132366, + "version": "9.3.0" + }, + "gdal-2.2.2-py27hae9aa10_1.conda": { + "build": "py27hae9aa10_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "2759b707d0e7b3dd80a6c7035338292a", + "name": "gdal", + "sha256": "c3eab928c029d1c27c1daf4f9b6cb2edf4cd64d7a1f5bca870868c4827a5c75c", + "size": 633616, + "subdir": "linux-64", + "timestamp": 1511391229901, + "version": "2.2.2" + }, + "gdal-2.2.2-py35h40af447_1.conda": { + "build": "py35h40af447_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "ea61d808eaeaf345e9fc246a587d99b9", + "name": "gdal", + "sha256": "6ac09c464675c25cb8e7627654ed1ccaffef4e9b7a2f6c7c278680dec07a34d0", + "size": 634978, + "subdir": "linux-64", + "timestamp": 1511391230101, + "version": "2.2.2" + }, + "gdal-2.2.2-py36hc209d97_1.conda": { + "build": "py36hc209d97_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a6a54b9b7c416afb3fdad470271d67ac", + "name": "gdal", + "sha256": "2ed5c78791884c7e74dd4d1ad5da54fe02604afa198a1bb5ca0224f6c6cecf52", + "size": 637065, + "subdir": "linux-64", + "timestamp": 1511391229950, + "version": "2.2.2" + }, + "gdal-2.2.4-py27h04863e7_1.conda": { + "build": "py27h04863e7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal 2.2.4 heea9cce_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "fd2ca7dc6fabe014cce481cc5ec6d073", + "name": "gdal", + "sha256": "75c01abbfeb7bf246ed2365baca0ae948f6c0ee346ae162b0d7c7d9b3210ff28", + "size": 995553, + "subdir": "linux-64", + "timestamp": 1530871220701, + "version": "2.2.4" + }, + "gdal-2.2.4-py27h637b7d7_1.conda": { + "build": "py27h637b7d7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal 2.2.4 hc8d23f9_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f3a60c3e60c75be045d6fd2a6da10e75", + "name": "gdal", + "sha256": "ed7423f564bcd11d45e40bddedc479532b2ed4b81ad0eeb6cfc5016d88b70adb", + "size": 995957, + "subdir": "linux-64", + "timestamp": 1527912911342, + "version": "2.2.4" + }, + "gdal-2.2.4-py35h637b7d7_1.conda": { + "build": "py35h637b7d7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal 2.2.4 hc8d23f9_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "4570d67e4a8c28e1a5223e23209fd9c1", + "name": "gdal", + "sha256": "d70a14a499196608ae63beced8ff73b8f9f9a65de69c8bc4a4140f905a9b53be", + "size": 997774, + "subdir": "linux-64", + "timestamp": 1527912720081, + "version": "2.2.4" + }, + "gdal-2.2.4-py36h04863e7_1.conda": { + "build": "py36h04863e7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal 2.2.4 heea9cce_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a4f1d6d1103fb0cd7428941cd74134e7", + "name": "gdal", + "sha256": "a77bae237edd1706efbb523fd6ad54c611a24f9413d8a1959de2016c375dec0c", + "size": 994236, + "subdir": "linux-64", + "timestamp": 1530871366684, + "version": "2.2.4" + }, + "gdal-2.2.4-py36h637b7d7_1.conda": { + "build": "py36h637b7d7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal 2.2.4 hc8d23f9_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f80f612036ae3f7c9b01f0d643ad5509", + "name": "gdal", + "sha256": "06b9782f5ae198239b2a8bc1eb118fea0001cb9ed0b7fca352d1d2e2b65429c5", + "size": 996028, + "subdir": "linux-64", + "timestamp": 1527913103357, + "version": "2.2.4" + }, + "gdal-2.2.4-py37h04863e7_1.conda": { + "build": "py37h04863e7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal 2.2.4 heea9cce_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "51dd96f517efc3359bc130b21b10c3f5", + "name": "gdal", + "sha256": "37aebf940c13b696d57a68ef0db11c3a6a03160cdb705fc2d21d92f87aa0053e", + "size": 992953, + "subdir": "linux-64", + "timestamp": 1530871294536, + "version": "2.2.4" + }, + "gdal-2.3.0-py27h04863e7_1.conda": { + "build": "py27h04863e7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal 2.3.0 heea9cce_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5dad80be1f3d81202277c47282bda77f", + "name": "gdal", + "sha256": "e33f8d4f6f3b6e3f86b92b3b2a141edc3dc77dfbd5409d30115c601dbf5b7a46", + "size": 1013698, + "subdir": "linux-64", + "timestamp": 1530869627399, + "version": "2.3.0" + }, + "gdal-2.3.0-py36h04863e7_1.conda": { + "build": "py36h04863e7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal 2.3.0 heea9cce_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c04f398b9b882593705c8579425e8820", + "name": "gdal", + "sha256": "b84bf8aa0bbc20e96c5074194cb0279020791b25752d2666a00eec3042885b60", + "size": 1012172, + "subdir": "linux-64", + "timestamp": 1530869777171, + "version": "2.3.0" + }, + "gdal-2.3.0-py37h04863e7_1.conda": { + "build": "py37h04863e7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgdal 2.3.0 heea9cce_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7dcdc69f6396c07c9a97831d6abb7c26", + "name": "gdal", + "sha256": "a82207127591dab242b254a893d808689d4fa6e37e4ef5c5c8d125b8eb14bd56", + "size": 1012998, + "subdir": "linux-64", + "timestamp": 1530869702090, + "version": "2.3.0" + }, + "gdal-2.3.2-py27h2924dbc_0.conda": { + "build": "py27h2924dbc_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.2 h9d4a965_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "6c7de640a3190d0330115a3ced40e3c5", + "name": "gdal", + "sha256": "a1dde0a0c2e90f95f2a538afc5174d7d6bbf4484f0ffa92b31c5ec0bfce9d91b", + "size": 1017292, + "subdir": "linux-64", + "timestamp": 1544656089046, + "version": "2.3.2" + }, + "gdal-2.3.2-py27hfcb4a02_0.conda": { + "build": "py27hfcb4a02_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.2 hda2fc8e_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "a3615dac674080ff8943882bc9801c5f", + "name": "gdal", + "sha256": "1655487134c427bd16e14ca73ce4154242e3283c65bd1ac1d614de72fde2a50b", + "size": 1017281, + "subdir": "linux-64", + "timestamp": 1544661955845, + "version": "2.3.2" + }, + "gdal-2.3.2-py36h2924dbc_0.conda": { + "build": "py36h2924dbc_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.2 h9d4a965_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "863c275595a2c1eeec8b7793afddec2e", + "name": "gdal", + "sha256": "8c5581c1e215836742e367dd2e0067a2e43109311eff90dd456bc6d2039c2083", + "size": 1017267, + "subdir": "linux-64", + "timestamp": 1544655998650, + "version": "2.3.2" + }, + "gdal-2.3.2-py36hfcb4a02_0.conda": { + "build": "py36hfcb4a02_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.2 hda2fc8e_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "edfadb3fc32a79f26b5a3f4e58660496", + "name": "gdal", + "sha256": "e0bfcac42db1c03af8e90d632c97dba57c6de65c921d38a97e40ca719f6f0711", + "size": 1015532, + "subdir": "linux-64", + "timestamp": 1544661868557, + "version": "2.3.2" + }, + "gdal-2.3.2-py37h2924dbc_0.conda": { + "build": "py37h2924dbc_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.2 h9d4a965_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "0b5cc2bae84696df5547ec511dc2562d", + "name": "gdal", + "sha256": "a4faa26700e9907a08724ecedeedae12549336fe198e027acf95cef2a0fe964d", + "size": 1015125, + "subdir": "linux-64", + "timestamp": 1544656185654, + "version": "2.3.2" + }, + "gdal-2.3.2-py37hfcb4a02_0.conda": { + "build": "py37hfcb4a02_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.2 hda2fc8e_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "72962b97c91c06c5bdd151ec3d3501b5", + "name": "gdal", + "sha256": "eba9b256da50f878f87768e46852af731ca2e633fba0f75049f10c91e1d2e413", + "size": 1015121, + "subdir": "linux-64", + "timestamp": 1544661776846, + "version": "2.3.2" + }, + "gdal-2.3.3-py27hbb2a789_0.conda": { + "build": "py27hbb2a789_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.3 h2e7e64b_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "fc3097cfaeea6942f3479f01df2e5c67", + "name": "gdal", + "sha256": "fb425f9df5281f785203a490800ade3c4adafad8a78836697493ae5ae52ac4d6", + "size": 1017532, + "subdir": "linux-64", + "timestamp": 1545408767024, + "version": "2.3.3" + }, + "gdal-2.3.3-py36hbb2a789_0.conda": { + "build": "py36hbb2a789_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.3 h2e7e64b_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "65b7d3f9eff17c4c24541ccdb8395d4d", + "name": "gdal", + "sha256": "84895629591b87c1666fbc5bcdc38e362629d960b136788b3344f5dcbd8f2668", + "size": 1015728, + "subdir": "linux-64", + "timestamp": 1545408875430, + "version": "2.3.3" + }, + "gdal-2.3.3-py37hbb2a789_0.conda": { + "build": "py37hbb2a789_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.3 h2e7e64b_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d8b97b16f6fd7a653363723ef2dbc557", + "name": "gdal", + "sha256": "de209b71c5b11c09d5a71a11c9419f5866ab28740d02d8fa5d086a767bde3a66", + "size": 1015658, + "subdir": "linux-64", + "timestamp": 1545408652901, + "version": "2.3.3" + }, + "gdal-2.3.3-py38hbb2a789_0.conda": { + "build": "py38hbb2a789_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 2.3.3 h2e7e64b_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "a4600c8b36bd20174f871dc1b3cf77fc", + "name": "gdal", + "sha256": "e896f43b5ac31c39074fba187a833fa476e291e9e578bf47ce69e33be8b33e8f", + "size": 1029094, + "subdir": "linux-64", + "timestamp": 1573739716408, + "version": "2.3.3" + }, + "gdal-3.0.2-py27hbb2a789_0.conda": { + "build": "py27hbb2a789_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 3.0.2 h27ab9cc_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ae76516bb2ad01de6209569fd4e01d4a", + "name": "gdal", + "sha256": "452b1e30e3985496c4dc2927c5522090bc0478a01a1c816158fb1b89ff21574e", + "size": 1063961, + "subdir": "linux-64", + "timestamp": 1573574897764, + "version": "3.0.2" + }, + "gdal-3.0.2-py310h3fbc5c2_3.conda": { + "build": "py310h3fbc5c2_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 h1d2d1f6_3", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "345213a0b1215aae96eb03dbb6ba069e", + "name": "gdal", + "sha256": "ec5177628f5b24fa963cb2808c34e26a62f679139b1fe77b2a4fd83a3b4a1faa", + "size": 2389661, + "subdir": "linux-64", + "timestamp": 1657806816850, + "version": "3.0.2" + }, + "gdal-3.0.2-py310h3fbc5c2_5.conda": { + "build": "py310h3fbc5c2_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 hf71aff0_5", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a1a79eb4389b2ebb14405e20b7bdc37b", + "name": "gdal", + "sha256": "ec29cda3ee3c5a0ce0e72946b7de68e087109ddc63149477c3699befa3b7ae99", + "size": 1144247, + "subdir": "linux-64", + "timestamp": 1673971922288, + "version": "3.0.2" + }, + "gdal-3.0.2-py310h3fbc5c2_6.conda": { + "build": "py310h3fbc5c2_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 hf71aff0_6", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63deb7ce46651ff22a158f30e1983e6b", + "name": "gdal", + "sha256": "bc8d36f267be8a9fdd8c7a18cd44d4f22f651c34d13a6f46c5cd36e76d5b0ab5", + "size": 1144507, + "subdir": "linux-64", + "timestamp": 1673992532364, + "version": "3.0.2" + }, + "gdal-3.0.2-py310h8f0303e_0.conda": { + "build": "py310h8f0303e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libgdal 3.0.2 h20ab51d_0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "aeca15b51ab68ef716e6673ae1bbdbe1", + "name": "gdal", + "sha256": "f62d2b3909ec909f8d750767a0727341061fd4b05993bdd6715796cb80ab616a", + "size": 2144263, + "subdir": "linux-64", + "timestamp": 1641553338209, + "version": "3.0.2" + }, + "gdal-3.0.2-py36h4694593_1.conda": { + "build": "py36h4694593_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 3.0.2 h7c14f60_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2b24b3debc70a7fb0b59cfc113fa54ee", + "name": "gdal", + "sha256": "95f5c4fa642409094fa0dd4e3688703e067be1fca544b1eccfb55a7aab411c30", + "size": 1071276, + "subdir": "linux-64", + "timestamp": 1622392924465, + "version": "3.0.2" + }, + "gdal-3.0.2-py36hbb2a789_0.conda": { + "build": "py36hbb2a789_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 3.0.2 h27ab9cc_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2d06d0fd07ac376fbb75b55716aa8919", + "name": "gdal", + "sha256": "796177b82a5f9b1242a2aa4c22a06ca6251bae9a86f9421bd443fcfb185fa7ea", + "size": 1064634, + "subdir": "linux-64", + "timestamp": 1573574560931, + "version": "3.0.2" + }, + "gdal-3.0.2-py37h2c27f0e_2.conda": { + "build": "py37h2c27f0e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libgdal 3.0.2 he6cead7_2", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "442eff9d084e6a4bf74f1f38e4e69f3e", + "name": "gdal", + "sha256": "84d2ada9cec1a53ee7ccbdd8e75d24253fe5411db5977b0317e56d15419a36ee", + "size": 1042777, + "subdir": "linux-64", + "timestamp": 1643382774337, + "version": "3.0.2" + }, + "gdal-3.0.2-py37h40f10ac_3.conda": { + "build": "py37h40f10ac_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 h1d2d1f6_3", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d6a15aef682c96b79df5b526ca9e868", + "name": "gdal", + "sha256": "35486e86850ca836ef1d48ce220d5f844d021321e8a78981034f919cca5410cc", + "size": 1074293, + "subdir": "linux-64", + "timestamp": 1657806692732, + "version": "3.0.2" + }, + "gdal-3.0.2-py37h40f10ac_5.conda": { + "build": "py37h40f10ac_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 hf71aff0_5", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bac21cdccf0d89435a39c2b213f79158", + "name": "gdal", + "sha256": "a0bf3be09729a649f4d94e104a177d8ce87d9e950ae8b9564203e3d1811500c8", + "size": 1132577, + "subdir": "linux-64", + "timestamp": 1673972073435, + "version": "3.0.2" + }, + "gdal-3.0.2-py37h40f10ac_6.conda": { + "build": "py37h40f10ac_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 hf71aff0_6", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cabd627985cbe9e18fdd436261511916", + "name": "gdal", + "sha256": "75122b51d51b013ef49eba4b07d1e588041b1427f1662d55fb058126410f17bd", + "size": 1133103, + "subdir": "linux-64", + "timestamp": 1673992632747, + "version": "3.0.2" + }, + "gdal-3.0.2-py37h4694593_1.conda": { + "build": "py37h4694593_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 3.0.2 h7c14f60_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "24093324b1330bb20eec2c00eb93ce95", + "name": "gdal", + "sha256": "27d34c97738474e586af1794a5a63d375d3ea4ff303d34bd03d21de58c2cdf36", + "size": 1071444, + "subdir": "linux-64", + "timestamp": 1622393146434, + "version": "3.0.2" + }, + "gdal-3.0.2-py37hbb2a789_0.conda": { + "build": "py37hbb2a789_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 3.0.2 h27ab9cc_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6e0b5d3c29660cb1101961baa5b9fc99", + "name": "gdal", + "sha256": "ee6b7799ef2bc440147ea43a6855795f80edfe18a971d9a49639f870e9dbba12", + "size": 1064792, + "subdir": "linux-64", + "timestamp": 1573574803369, + "version": "3.0.2" + }, + "gdal-3.0.2-py38h2c27f0e_2.conda": { + "build": "py38h2c27f0e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libgdal 3.0.2 he6cead7_2", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "20b37666f2073f1bbdb1b3e716273fc7", + "name": "gdal", + "sha256": "4a8d363da15e6a806c47d85726d34c61bb906ad9d4dd8083d2e0fd7a6304903f", + "size": 1051001, + "subdir": "linux-64", + "timestamp": 1643382663578, + "version": "3.0.2" + }, + "gdal-3.0.2-py38h40f10ac_3.conda": { + "build": "py38h40f10ac_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 h1d2d1f6_3", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc19b2672542e00a5bdf0e0f7a772176", + "name": "gdal", + "sha256": "10244c366abb1ed32708e1ec57ffdf4561f27e43bbb90585e1ae6b606af5a680", + "size": 1083640, + "subdir": "linux-64", + "timestamp": 1657806876333, + "version": "3.0.2" + }, + "gdal-3.0.2-py38h40f10ac_5.conda": { + "build": "py38h40f10ac_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 hf71aff0_5", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14b46e4f42aa3563638f869bfe683f48", + "name": "gdal", + "sha256": "6d8f12b0e9e011c669dad88efbf56dbbb3145ad9246fc26e549bf85fa34384d9", + "size": 1142571, + "subdir": "linux-64", + "timestamp": 1673971972406, + "version": "3.0.2" + }, + "gdal-3.0.2-py38h40f10ac_6.conda": { + "build": "py38h40f10ac_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 hf71aff0_6", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "27d118103398795a43889d92da0aaa7e", + "name": "gdal", + "sha256": "a0c523495fb1c9615523d983fb816054c27ac5d813136a12a280c2b725a0b4a5", + "size": 1143539, + "subdir": "linux-64", + "timestamp": 1673992682520, + "version": "3.0.2" + }, + "gdal-3.0.2-py38h4694593_1.conda": { + "build": "py38h4694593_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 3.0.2 h7c14f60_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "692537504612202315d9e9db80ae5695", + "name": "gdal", + "sha256": "f8215699be653e9de32dcfceb997d4c2130c0282120a941dfb26d719b9488db8", + "size": 1079760, + "subdir": "linux-64", + "timestamp": 1622392998045, + "version": "3.0.2" + }, + "gdal-3.0.2-py38hbb2a789_0.conda": { + "build": "py38hbb2a789_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 3.0.2 h27ab9cc_0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "3b7df24feb4951279077a207a4680e8c", + "name": "gdal", + "sha256": "7e3819928d699bc090a0b70fd74571f0afbce28c4105e29ff812cf66427dc4ea", + "size": 1079838, + "subdir": "linux-64", + "timestamp": 1573574659895, + "version": "3.0.2" + }, + "gdal-3.0.2-py39h2c27f0e_2.conda": { + "build": "py39h2c27f0e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libgdal 3.0.2 he6cead7_2", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "614f3335a696a3d4271f3f2e642f6df0", + "name": "gdal", + "sha256": "5e9d532d47cfcbffe9c7fa2c259714bf6361ff14ba7f63267f88332d209d85fe", + "size": 1050628, + "subdir": "linux-64", + "timestamp": 1643382722488, + "version": "3.0.2" + }, + "gdal-3.0.2-py39h40f10ac_3.conda": { + "build": "py39h40f10ac_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 h1d2d1f6_3", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1dc1db11034a9d7aab68e2cb7a39206e", + "name": "gdal", + "sha256": "697a922c26a3deb85004fb894aff6ac6d68b9d3b2bb47809ac484bbfb53c1f82", + "size": 1083714, + "subdir": "linux-64", + "timestamp": 1657806751401, + "version": "3.0.2" + }, + "gdal-3.0.2-py39h40f10ac_5.conda": { + "build": "py39h40f10ac_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 hf71aff0_5", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "187db154e188a4c3f4ee76574ed87a7d", + "name": "gdal", + "sha256": "98ed79d3a358a2e868c38b3297f353e2c6e7b23f09163ddc582596664a1305bf", + "size": 1142619, + "subdir": "linux-64", + "timestamp": 1673972023589, + "version": "3.0.2" + }, + "gdal-3.0.2-py39h40f10ac_6.conda": { + "build": "py39h40f10ac_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.0.2 hf71aff0_6", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc4b0aecc8ab024afbf184d784243b15", + "name": "gdal", + "sha256": "20f8cee3f4f0c62d37f2990618fc7d60ca2da62c41b6b1341dae23b548d30262", + "size": 1143372, + "subdir": "linux-64", + "timestamp": 1673992582452, + "version": "3.0.2" + }, + "gdal-3.0.2-py39h4694593_1.conda": { + "build": "py39h4694593_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libgdal 3.0.2 h7c14f60_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "8ee50c111cab4374c4363b8dbf66c733", + "name": "gdal", + "sha256": "7029221dc2ab36cf85e6787ffee3bc7275ca7f4119820dad2e17edb3e485c41e", + "size": 1078860, + "subdir": "linux-64", + "timestamp": 1622393072557, + "version": "3.0.2" + }, + "gdal-3.4.1-py310h8f0303e_0.conda": { + "build": "py310h8f0303e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libgdal 3.4.1.*", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "d5c9475c94c35216c8176b395cb0f248", + "name": "gdal", + "sha256": "9c6326a99abb696d79518ef136b1c7fc80aba73ef805a7aa83fa23136117ddbc", + "size": 2572405, + "subdir": "linux-64", + "timestamp": 1647030727174, + "version": "3.4.1" + }, + "gdal-3.4.1-py311hcb128cc_0.conda": { + "build": "py311hcb128cc_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal 3.4.1.*", + "libgdal >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "97fea4512bdd25a6dbd0312f44307cd6", + "name": "gdal", + "sha256": "d79a04ed310b761189a407ed2f78c6b64facd0b4507aacb8196b261fffeec3d9", + "size": 1546728, + "subdir": "linux-64", + "timestamp": 1676844084923, + "version": "3.4.1" + }, + "gdal-3.4.1-py37h2c27f0e_0.conda": { + "build": "py37h2c27f0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libgdal 3.4.1.*", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3122a637366a65f153f63d566d095880", + "name": "gdal", + "sha256": "ff43f14839dc9184974a59d57d65a477dbeb2c5696045753cef4349f68050b90", + "size": 1328473, + "subdir": "linux-64", + "timestamp": 1643825184861, + "version": "3.4.1" + }, + "gdal-3.4.1-py38h2c27f0e_0.conda": { + "build": "py38h2c27f0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libgdal 3.4.1.*", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "67fcf2aebeced23753b5a361574cedcf", + "name": "gdal", + "sha256": "e85fa240b6467637110403ae61c4441c369a0857b2e9d1f1facaa3e80af89f0d", + "size": 1337277, + "subdir": "linux-64", + "timestamp": 1643825115278, + "version": "3.4.1" + }, + "gdal-3.4.1-py39h2c27f0e_0.conda": { + "build": "py39h2c27f0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libgdal 3.4.1.*", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "8ace6247682f36b2d72e7206f7cd2d43", + "name": "gdal", + "sha256": "d293cb2709506d4d72fdfa3ca2b2ba44534c6c05cd506cfe576656e7a8b32d67", + "size": 1336593, + "subdir": "linux-64", + "timestamp": 1643825259668, + "version": "3.4.1" + }, + "gdal-3.6.0-py310h708d02d_0.conda": { + "build": "py310h708d02d_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.0 hc0e11bb_0", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.21.5,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f395a122bdd8832381ab60b3bfd509a0", + "name": "gdal", + "sha256": "660179aa507a2f7decf7145132249603a90dfcbd8532ccc588d603d0e3abd8e1", + "size": 1505084, + "subdir": "linux-64", + "timestamp": 1676727194678, + "version": "3.6.0" + }, + "gdal-3.6.0-py310h708d02d_1.conda": { + "build": "py310h708d02d_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.0 hc0e11bb_1", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.21.5,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "73b0690c11e6eefdee62571444daf980", + "name": "gdal", + "sha256": "003679e168b9fd468bb7e73981f4fe66b6272568e593e79e351d4cbbffaad1b1", + "size": 1510449, + "subdir": "linux-64", + "timestamp": 1677574455706, + "version": "3.6.0" + }, + "gdal-3.6.0-py311h89ef87f_0.conda": { + "build": "py311h89ef87f_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.0 hc0e11bb_0", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.22.3,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "efb7b663c72f5d0d21e6f293747bc9bf", + "name": "gdal", + "sha256": "ff69859082295fc7d37237d15ff3300870240d713159ba350a2f877a9679ff74", + "size": 1584649, + "subdir": "linux-64", + "timestamp": 1676920028162, + "version": "3.6.0" + }, + "gdal-3.6.0-py37hf9a8271_0.conda": { + "build": "py37hf9a8271_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.0 hc0e11bb_0", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b4f04a70eaa1b271e85550aef92d628", + "name": "gdal", + "sha256": "111665d8429982aee2b78502dbb4a73931652c57a733a2185ad4c1a856f1bf7c", + "size": 1484575, + "subdir": "linux-64", + "timestamp": 1676727291992, + "version": "3.6.0" + }, + "gdal-3.6.0-py37hf9a8271_1.conda": { + "build": "py37hf9a8271_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.0 hc0e11bb_1", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5c8f82a799f0894724bdcf46ec0051c", + "name": "gdal", + "sha256": "640fccc914714e90461b98011a72640c464c987abbf9936660140b159fcb3829", + "size": 1488841, + "subdir": "linux-64", + "timestamp": 1677574500832, + "version": "3.6.0" + }, + "gdal-3.6.0-py38hf9a8271_0.conda": { + "build": "py38hf9a8271_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.0 hc0e11bb_0", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d27bab34eda68c7ef6846b0e1f137f1c", + "name": "gdal", + "sha256": "b9ff0de556a3c13eb317b6cc3faa670dd795b31e586a325b59d6d61685d6e3e2", + "size": 1496422, + "subdir": "linux-64", + "timestamp": 1676727341107, + "version": "3.6.0" + }, + "gdal-3.6.0-py38hf9a8271_1.conda": { + "build": "py38hf9a8271_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.0 hc0e11bb_1", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0dccb95c734a84a9f4a49c68cae3a612", + "name": "gdal", + "sha256": "5c670ac5abe62a4d6058339a80da867a2e8e194f8c8981145b8e940a0dbb1be5", + "size": 1500596, + "subdir": "linux-64", + "timestamp": 1677574547808, + "version": "3.6.0" + }, + "gdal-3.6.0-py39hf9a8271_0.conda": { + "build": "py39hf9a8271_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.0 hc0e11bb_0", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9665e622b22b3d690e51a8eea6f901a8", + "name": "gdal", + "sha256": "8b9104f021da948dc8c99de75124204e2ba8f5944781a6ba2408aa3f1762acf5", + "size": 1499586, + "subdir": "linux-64", + "timestamp": 1676727242468, + "version": "3.6.0" + }, + "gdal-3.6.0-py39hf9a8271_1.conda": { + "build": "py39hf9a8271_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.0 hc0e11bb_1", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab7762c54b9c6f3e2501f8c1e365f262", + "name": "gdal", + "sha256": "0962cd7b895ea3ea7bfe83c1ba49e26b15bcac831d14e914b72ce7f2c50e0f0f", + "size": 1504210, + "subdir": "linux-64", + "timestamp": 1677574408039, + "version": "3.6.0" + }, + "gdal-3.6.2-py310h65ec567_1.conda": { + "build": "py310h65ec567_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.2 hc0e11bb_1", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "numpy >=1.21.5,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d3667b613d7cab3e70ce1379121337e", + "name": "gdal", + "sha256": "d331adc35d204883cd6f1a6e01b6dd2f03ce2e0a3fc96e9dcd150000263e59cc", + "size": 1506271, + "subdir": "linux-64", + "timestamp": 1680121180989, + "version": "3.6.2" + }, + "gdal-3.6.2-py310h708d02d_0.conda": { + "build": "py310h708d02d_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.2 hc0e11bb_0", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.21.5,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f8638ff878b2193c6c939f4fd00e3e6", + "name": "gdal", + "sha256": "34d3721aafdb0baeedf8ae66f0386d40c11bc6ed03d3ffb4fb2a3f005cdaba8c", + "size": 1509072, + "subdir": "linux-64", + "timestamp": 1678138704653, + "version": "3.6.2" + }, + "gdal-3.6.2-py311h4618797_1.conda": { + "build": "py311h4618797_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.2 hc0e11bb_1", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "numpy >=1.23.5,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c8251bce223a79cbd8335e54cdc751f", + "name": "gdal", + "sha256": "a4a5408bb7f29a7f64731c30989add27ab59375d5b9ad599047ed508800ed2b8", + "size": 1681356, + "subdir": "linux-64", + "timestamp": 1680121090296, + "version": "3.6.2" + }, + "gdal-3.6.2-py311h89ef87f_0.conda": { + "build": "py311h89ef87f_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.2 hc0e11bb_0", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.22.3,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cfcdc4358c8613231b9ca2a7fe58df73", + "name": "gdal", + "sha256": "51fd710f5eadd9c70f2b0278e01556ead0fb1311d7f95f5d312b45edbd25f728", + "size": 1583333, + "subdir": "linux-64", + "timestamp": 1678242957630, + "version": "3.6.2" + }, + "gdal-3.6.2-py38h2fd6ed0_1.conda": { + "build": "py38h2fd6ed0_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.2 hc0e11bb_1", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d88a28a4964eedf053649295c268364", + "name": "gdal", + "sha256": "21fda2677fdeae531ee646163e8db1708b3355c09c5b4def5df25a7ae2894b34", + "size": 1497202, + "subdir": "linux-64", + "timestamp": 1680121135682, + "version": "3.6.2" + }, + "gdal-3.6.2-py38hf9a8271_0.conda": { + "build": "py38hf9a8271_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.2 hc0e11bb_0", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa9f09361397aadc7ae8bed8696af97d", + "name": "gdal", + "sha256": "52f88da9919e15aee608074f54c17981174d83702b298de253504031995631c7", + "size": 1499769, + "subdir": "linux-64", + "timestamp": 1678138750891, + "version": "3.6.2" + }, + "gdal-3.6.2-py39h2fd6ed0_1.conda": { + "build": "py39h2fd6ed0_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.2 hc0e11bb_1", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f62a6f5ee05626f478ef5ea0e738d0f", + "name": "gdal", + "sha256": "469605afc8d98acb31ba8a4fc5b284d14653a4232808e81b55021e236a98267f", + "size": 1500506, + "subdir": "linux-64", + "timestamp": 1680121226484, + "version": "3.6.2" + }, + "gdal-3.6.2-py39hf9a8271_0.conda": { + "build": "py39hf9a8271_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libgdal 3.6.2 hc0e11bb_0", + "libiconv >=1.16,<2.0a0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e2b13f2f8deaea21e9f9cf180938f47", + "name": "gdal", + "sha256": "c4152887874acd600cd30fdc88dbaae878bcea6ab573bf4c129c367ece76d0d5", + "size": 1502537, + "subdir": "linux-64", + "timestamp": 1678138795746, + "version": "3.6.2" + }, + "gdata-2.0.18-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "834a9c656e4fe44a8a9fb6e7e7aeed9e", + "name": "gdata", + "sha256": "eae863e17b2d38ed080c901f216b9d61e85252cf295ef56a66d0da7f6fa0e0ed", + "size": 737359, + "subdir": "linux-64", + "timestamp": 1541010065333, + "version": "2.0.18" + }, + "gdb-11.2-py310he3c4487_2.conda": { + "build": "py310he3c4487_2", + "build_number": 2, + "depends": [ + "libgcc-ng", + "libstdcxx-ng", + "ncurses", + "pygments", + "python >=3.10,<3.11.0a0", + "six", + "xz" + ], + "license": "GPL", + "md5": "426695c4717ec81c5a7aff32d43d488d", + "name": "gdb", + "sha256": "bb90614db178fb9e65824eb2497dd9c79d43677a088674b0f870eb288706ab84", + "size": 5767855, + "subdir": "linux-64", + "timestamp": 1654065060940, + "version": "11.2" + }, + "gdb-11.2-py311he3c4487_2.conda": { + "build": "py311he3c4487_2", + "build_number": 2, + "depends": [ + "libgcc-ng", + "libstdcxx-ng", + "ncurses", + "pygments", + "python >=3.11,<3.12.0a0", + "six", + "xz" + ], + "license": "GPL", + "md5": "77a55fb4d1fd8d9f5d160a5c4faea51b", + "name": "gdb", + "sha256": "05561ab15706511b167f8c591a323960cecacc8ddec2b31a90c92d8a3e14be74", + "size": 6011713, + "subdir": "linux-64", + "timestamp": 1676921908353, + "version": "11.2" + }, + "gdb-11.2-py37he3c4487_2.conda": { + "build": "py37he3c4487_2", + "build_number": 2, + "depends": [ + "libgcc-ng", + "libstdcxx-ng", + "ncurses", + "pygments", + "python >=3.7,<3.8.0a0", + "six", + "xz" + ], + "license": "GPL", + "md5": "28a2e4e6154e4f5bd342770c91e628b4", + "name": "gdb", + "sha256": "ac15339584fac9e05c6fadced9f99a2e0d4e1fa873077daaf88f8147273b1123", + "size": 5816820, + "subdir": "linux-64", + "timestamp": 1654066414973, + "version": "11.2" + }, + "gdb-11.2-py38he3c4487_2.conda": { + "build": "py38he3c4487_2", + "build_number": 2, + "depends": [ + "libgcc-ng", + "libstdcxx-ng", + "ncurses", + "pygments", + "python >=3.8,<3.9.0a0", + "six", + "xz" + ], + "license": "GPL", + "md5": "327a0d00f6d34a0c31cd4df94a79e73b", + "name": "gdb", + "sha256": "4fa5d0b0a8c69700d8c958aefeaa5350a381fb83e5028cb41cee06cbe1d648dd", + "size": 5814630, + "subdir": "linux-64", + "timestamp": 1654063656583, + "version": "11.2" + }, + "gdb-11.2-py39he3c4487_2.conda": { + "build": "py39he3c4487_2", + "build_number": 2, + "depends": [ + "libgcc-ng", + "libstdcxx-ng", + "ncurses", + "pygments", + "python >=3.9,<3.10.0a0", + "six", + "xz" + ], + "license": "GPL", + "md5": "2a183daccd94cff9fbdd7026090c0df1", + "name": "gdb", + "sha256": "374c06dcb86dc1a71440c5205f0ace57a618f05cceab5e93195fea8dff0eb5e4", + "size": 5815855, + "subdir": "linux-64", + "timestamp": 1654067818897, + "version": "11.2" + }, + "gdb-pretty-printer-11.2.0-py310hcff718f_2.conda": { + "build": "py310hcff718f_2", + "build_number": 2, + "depends": [ + "gdb >=11.2", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "84049ddf1cfcbd421af24be01c7929cc", + "name": "gdb-pretty-printer", + "sha256": "c3ba16fc8d8fd37246edee041c917869489ec24d99f48a77b46e03b45002a262", + "size": 65786, + "subdir": "linux-64", + "timestamp": 1654065074087, + "version": "11.2.0" + }, + "gdb-pretty-printer-11.2.0-py311hcff718f_2.conda": { + "build": "py311hcff718f_2", + "build_number": 2, + "depends": [ + "gdb >=11.2", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "6762069cea1ea75aacb81938b04ff3e7", + "name": "gdb-pretty-printer", + "sha256": "b3939915731287457b717343da92658259f3ee7575acd27775ad43bf8ebe5efd", + "size": 87602, + "subdir": "linux-64", + "timestamp": 1676921920641, + "version": "11.2.0" + }, + "gdb-pretty-printer-11.2.0-py37hcff718f_2.conda": { + "build": "py37hcff718f_2", + "build_number": 2, + "depends": [ + "gdb >=11.2", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "79d31152b91470564b7b1fb208d818ab", + "name": "gdb-pretty-printer", + "sha256": "afa8b05639cbb38418db53b40dd6a75ff9bae427c0db0291ec63ddb141582077", + "size": 64381, + "subdir": "linux-64", + "timestamp": 1654066428076, + "version": "11.2.0" + }, + "gdb-pretty-printer-11.2.0-py38hcff718f_2.conda": { + "build": "py38hcff718f_2", + "build_number": 2, + "depends": [ + "gdb >=11.2", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "4351a22ef9138748e3713ad75639e279", + "name": "gdb-pretty-printer", + "sha256": "0ec8db4a25e674d2310ffbd81feb1ac0fabc1d18dca5b9051dff26db9cbcd7f8", + "size": 64899, + "subdir": "linux-64", + "timestamp": 1654063669693, + "version": "11.2.0" + }, + "gdb-pretty-printer-11.2.0-py39hcff718f_2.conda": { + "build": "py39hcff718f_2", + "build_number": 2, + "depends": [ + "gdb >=11.2", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "12aa9b11aba6c63efde5da8120e8e69b", + "name": "gdb-pretty-printer", + "sha256": "483c4f0239951c88a987a25baf54fecfa2bc9f7b8d7eda70d9c5efa6c1a5855a", + "size": 64876, + "subdir": "linux-64", + "timestamp": 1654067832410, + "version": "11.2.0" + }, + "gdb_linux-64-11.2-h1234567_0.conda": { + "build": "h1234567_0", + "build_number": 0, + "depends": [], + "license": "GPL", + "md5": "f1f5f63602f951effd9aad60179a0e3c", + "name": "gdb_linux-64", + "sha256": "e38e1f916fcf45c3d9dd60909518a78b0e73a2a77883ae236dc91c0afdbd3ed4", + "size": 4240517, + "subdir": "linux-64", + "timestamp": 1652859654120, + "version": "11.2" + }, + "gdb_linux-64-11.2-h1234567_1.conda": { + "build": "h1234567_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "e8970776ac992da2df7c6bb0d559dddd", + "name": "gdb_linux-64", + "sha256": "f552e7ba8b3b9c6e46aa85a095e5a641018de434eb731e6fd5c8bf97c1c3051f", + "size": 4241907, + "subdir": "linux-64", + "timestamp": 1654090737336, + "version": "11.2" + }, + "gdb_linux-64-7.12.1-h0d70bb3_3.conda": { + "build": "h0d70bb3_3", + "build_number": 3, + "depends": [], + "license": "GPL", + "md5": "f84319d1082bec3d2c1a16e6b6866c68", + "name": "gdb_linux-64", + "sha256": "a93ccfd7181a34fa91e3baea984ce907bc6a3142e434457d62f24b4f7d9f84c9", + "size": 2682338, + "subdir": "linux-64", + "timestamp": 1520534499595, + "version": "7.12.1" + }, + "gdb_linux-64-7.12.1-hd7315ee_1.conda": { + "build": "hd7315ee_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "1465dc9145ad5bad06cfba5e51eac1bd", + "name": "gdb_linux-64", + "sha256": "91773f290583d6330082013ca8f29905cb54d5315e366529eafa20b3234795b9", + "size": 2670126, + "subdir": "linux-64", + "timestamp": 1505665557371, + "version": "7.12.1" + }, + "gdb_linux-64-7.12.1-hf9d566d_2.conda": { + "build": "hf9d566d_2", + "build_number": 2, + "depends": [], + "license": "GPL", + "md5": "abca036781ccfdb7912bc0ec68d90931", + "name": "gdb_linux-64", + "sha256": "1e97f88088184b1677987de27ea29618a4101844e4b53a98aa4bf452051d1abd", + "size": 2670418, + "subdir": "linux-64", + "timestamp": 1507262711202, + "version": "7.12.1" + }, + "gdb_server_linux-64-11.2-h1234567_0.conda": { + "build": "h1234567_0", + "build_number": 0, + "depends": [], + "license": "GPL", + "md5": "2653a6fb9e9c1fe694d57de4db5ff54c", + "name": "gdb_server_linux-64", + "sha256": "7e9218479976290d41eb85c121491becade1d5feb8bad2d17aaa582436845679", + "size": 792926, + "subdir": "linux-64", + "timestamp": 1652859661753, + "version": "11.2" + }, + "gdb_server_linux-64-11.2-h1234567_1.conda": { + "build": "h1234567_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "2eee911bc3c9a5f0e2bf13d0bd3f446f", + "name": "gdb_server_linux-64", + "sha256": "a9865f7225451dc8926c525788a0afbed635f7a9656bdbd6662098794307249d", + "size": 793367, + "subdir": "linux-64", + "timestamp": 1654090744991, + "version": "11.2" + }, + "gdbm-1.18-hd4cb3f1_0.conda": { + "build": "hd4cb3f1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "readline >=8.0,<9.0a0" + ], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "b35cb70019aabe79b2758463031ef4cc", + "name": "gdbm", + "sha256": "645005e542c0d82af5e146d23fbb4d0fde19a22723b253f88133313814afc107", + "size": 181721, + "subdir": "linux-64", + "timestamp": 1658933501580, + "version": "1.18" + }, + "gdbm-1.18-hd4cb3f1_4.conda": { + "build": "hd4cb3f1_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=11.2.0", + "readline >=8.0,<9.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "1c82981848be10bfc91000a0afcefee3", + "name": "gdbm", + "sha256": "9c68559361c265daefea228e2886b39535f97bffe4ccb186d71df4c42a6e37dd", + "size": 198650, + "subdir": "linux-64", + "timestamp": 1667379356099, + "version": "1.18" + }, + "gdk-pixbuf-2.42.10-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "glib >=2.56.0,<3.0a0", + "glib >=2.69.1,<3.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.39,<1.7.0a0", + "libtiff >=4.2.0,<5.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "35c9e04145c5f90a9e4f342cc0d5af83", + "name": "gdk-pixbuf", + "sha256": "ab3284c8488e1d4c202eb8042d98ab7b25dc505e9c4e533dd0c952f4fb61f28e", + "size": 614165, + "subdir": "linux-64", + "timestamp": 1678446474565, + "version": "2.42.10" + }, + "gdk-pixbuf-2.42.6-h8cc273a_4.conda": { + "build": "h8cc273a_4", + "build_number": 4, + "depends": [ + "glib >=2.69.1,<3.0a0", + "gobject-introspection", + "jpeg >=9b,<10a", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "zlib" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "45458b9da56c52cabfecbc37bf2a943b", + "name": "gdk-pixbuf", + "sha256": "0b97f9e0b1cbe5797675c963869e22977bfd29bbccb23caac426f55d1a2e246f", + "size": 575416, + "subdir": "linux-64", + "timestamp": 1631785294033, + "version": "2.42.6" + }, + "gdk-pixbuf-2.42.6-h8cc273a_5.conda": { + "build": "h8cc273a_5", + "build_number": 5, + "depends": [ + "glib >=2.69.1,<3.0a0", + "gobject-introspection", + "jpeg", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "zlib" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "b61e0c70f5c6c81b0d42722f31c41f47", + "name": "gdk-pixbuf", + "sha256": "2ea2d0baeed870f0dc1b1cf0dbdb45325aa893a5933066ff3b9a5675a70f1784", + "size": 576164, + "subdir": "linux-64", + "timestamp": 1632493367697, + "version": "2.42.6" + }, + "gdk-pixbuf-2.42.8-h433bba3_0.conda": { + "build": "h433bba3_0", + "build_number": 0, + "depends": [ + "glib >=2.56.0,<3.0a0", + "glib >=2.69.1,<3.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "zlib" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "ed0898818026d1c3c5dd36469ac4098c", + "name": "gdk-pixbuf", + "sha256": "e6f0c597625e6e2427de1fab93b987bfd8fe8da9c88689a14b6b5b377a0d06ea", + "size": 223170, + "subdir": "linux-64", + "timestamp": 1656524732030, + "version": "2.42.8" + }, + "gdk-pixbuf-2.42.8-h433bba3_1.conda": { + "build": "h433bba3_1", + "build_number": 1, + "depends": [ + "glib >=2.56.0,<3.0a0", + "glib >=2.69.1,<3.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "zlib" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "bfefa3a07466a72ff05f963a5f966846", + "name": "gdk-pixbuf", + "sha256": "e747d4038dbd235dfe1c5f51ce101d1abf366b086433be44fb4087d55edd12c7", + "size": 241436, + "subdir": "linux-64", + "timestamp": 1669625880112, + "version": "2.42.8" + }, + "gdk-pixbuf-2.42.8-h5eee18b_2.conda": { + "build": "h5eee18b_2", + "build_number": 2, + "depends": [ + "glib >=2.56.0,<3.0a0", + "glib >=2.69.1,<3.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.2.0,<5.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "71204542c3227afc693b1f6ec06fd9cd", + "name": "gdk-pixbuf", + "sha256": "3092750fb6d5a138e6090d21faba2f93cfda23630e6a54a84d0e9e0556dcdb4c", + "size": 241208, + "subdir": "linux-64", + "timestamp": 1677573443403, + "version": "2.42.8" + }, + "gensim-3.0.1-py27h297c816_0.conda": { + "build": "py27h297c816_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "c82e4d2aa75319ec2b7c2e4e0c54ae97", + "name": "gensim", + "sha256": "29e675c8ef2ea6818f9d3716dd911e79e71b02bcb59220d62a37c0248e864179", + "size": 12439334, + "subdir": "linux-64", + "timestamp": 1508797441593, + "version": "3.0.1" + }, + "gensim-3.0.1-py35h6653ba0_0.conda": { + "build": "py35h6653ba0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "b6001c3c5e9634856c9221a7ae82c3e3", + "name": "gensim", + "sha256": "87ddfe2c1459ac5663792613a8a93f0e3bb35d50a38ce256398bf9763418381b", + "size": 12449229, + "subdir": "linux-64", + "timestamp": 1508797306817, + "version": "3.0.1" + }, + "gensim-3.0.1-py36h4ebfbf4_0.conda": { + "build": "py36h4ebfbf4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "69f79636337556997c4eac8f113873b0", + "name": "gensim", + "sha256": "9b87addf76b9194177971ba6a1efd012521bb1b311e411f1e05a5f6f610325e6", + "size": 12445399, + "subdir": "linux-64", + "timestamp": 1508797509978, + "version": "3.0.1" + }, + "gensim-3.1.0-py27h4d79aa8_0.conda": { + "build": "py27h4d79aa8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "2c11e1d9b67fed8622a00da1e9e3b949", + "name": "gensim", + "sha256": "761facebcd3841c6463a13942ac96f1bd70bb9597780a96155173946de808dd6", + "size": 13621690, + "subdir": "linux-64", + "timestamp": 1512065876696, + "version": "3.1.0" + }, + "gensim-3.1.0-py35h7300b16_0.conda": { + "build": "py35h7300b16_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "ddc729b8f0e4b99282681934b2c47130", + "name": "gensim", + "sha256": "169d4d4af42542353eee64974b2b68e13990c1a2cc2e3ec73d8997e7f481c283", + "size": 13623903, + "subdir": "linux-64", + "timestamp": 1512065888806, + "version": "3.1.0" + }, + "gensim-3.1.0-py36hc2fc318_0.conda": { + "build": "py36hc2fc318_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "e140a888e87ff46b5200a23a5a508a45", + "name": "gensim", + "sha256": "452a81f85f62176a5b756622ea2d333cd5bb61c2cc4c0ca0d2435b15ead48b32", + "size": 13633324, + "subdir": "linux-64", + "timestamp": 1512065733044, + "version": "3.1.0" + }, + "gensim-3.3.0-py27h3010b51_0.conda": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "c049827714797483f26440fc7bb97e0e", + "name": "gensim", + "sha256": "c248770ebc7c3d3b25af60e81f5acdf059ec6e1b728de37f0403369e4aeb60a6", + "size": 18054892, + "subdir": "linux-64", + "timestamp": 1519149939566, + "version": "3.3.0" + }, + "gensim-3.3.0-py35h3010b51_0.conda": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "fe9b5fa40204fd0a4ea89d5e2f91682f", + "name": "gensim", + "sha256": "0e5e5baad17b226c788192f4a993a94176395722a15e3d94396a6ad95aaa07de", + "size": 18081740, + "subdir": "linux-64", + "timestamp": 1519150000374, + "version": "3.3.0" + }, + "gensim-3.3.0-py36h3010b51_0.conda": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "d910cf11491cba1500b0a05c2972335e", + "name": "gensim", + "sha256": "bb161a642c39a4182c8d660dd86b43090cbb0d60d66d2d845f2ca52c0dcfb374", + "size": 18070531, + "subdir": "linux-64", + "timestamp": 1519149994716, + "version": "3.3.0" + }, + "gensim-3.4.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "b69046b595d894db8e412588119213f9", + "name": "gensim", + "sha256": "1cd048645a7766549709a598261010cbc1ee4af4736d016e03544e6d7d485bb5", + "size": 18319909, + "subdir": "linux-64", + "timestamp": 1530889413279, + "version": "3.4.0" + }, + "gensim-3.4.0-py27h3010b51_0.conda": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "74df81c68e90335df3a234b3322e9331", + "name": "gensim", + "sha256": "b7049b3f7e9cea74daec5b48dbd5e8923cf4a0a9cf89f4dffe6e5213ffd58c1a", + "size": 18310383, + "subdir": "linux-64", + "timestamp": 1520782139295, + "version": "3.4.0" + }, + "gensim-3.4.0-py35h3010b51_0.conda": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "7dc5761cb04768f960ac5e61549fd139", + "name": "gensim", + "sha256": "ad44fcd55073b45d80143b5cab22a40b26f9124482183cf271b4cb80114fb6d8", + "size": 18325876, + "subdir": "linux-64", + "timestamp": 1520782275819, + "version": "3.4.0" + }, + "gensim-3.4.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "b2c063399a0533864b8fe92cb5dd0e3e", + "name": "gensim", + "sha256": "0418123c98285dc82d2bdbf6ad0135bcd7085dc94b8af88fe5658c3c9ecbd7af", + "size": 18321782, + "subdir": "linux-64", + "timestamp": 1530880415964, + "version": "3.4.0" + }, + "gensim-3.4.0-py36h3010b51_0.conda": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "aa5c1fc7a2583092a35a4b891b8f75d8", + "name": "gensim", + "sha256": "32798dbec4aacd2ad1af1428b9a743676e67163bdbf5b7a334bea09af8eec41b", + "size": 18320926, + "subdir": "linux-64", + "timestamp": 1520782263833, + "version": "3.4.0" + }, + "gensim-3.4.0-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "908e574f9a66051c71963a80bfcd3ebc", + "name": "gensim", + "sha256": "b4aa3dd1b64e0921f86c4bc66170754de8e5e6b997988483c51cd419f077cb0c", + "size": 18320246, + "subdir": "linux-64", + "timestamp": 1530879696124, + "version": "3.4.0" + }, + "gensim-3.7.3-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.5,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "706b29bc5ebc5fc70917344188d41193", + "name": "gensim", + "sha256": "430d7ee2e1cd2bf151be8a86e268fb5bcf8402107fa2306afe559e96170ece0b", + "size": 19312422, + "subdir": "linux-64", + "timestamp": 1569336660183, + "version": "3.7.3" + }, + "gensim-3.7.3-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.5,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "f01eaaa8168835d42756b07cb4a54007", + "name": "gensim", + "sha256": "a84add46a46983256bc4be73ccfc7db90b60cbf29a9791c8b4594a5622f88b0d", + "size": 19339353, + "subdir": "linux-64", + "timestamp": 1569336679810, + "version": "3.7.3" + }, + "gensim-3.7.3-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.5,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "fc8c963d6523462b94faabe634f7b006", + "name": "gensim", + "sha256": "0b4f563f7a893b858ecc21686c0adb46b99c31b798865b0b319ec43cd8bfca95", + "size": 19355574, + "subdir": "linux-64", + "timestamp": 1569336662990, + "version": "3.7.3" + }, + "gensim-3.8.0-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "b7995352049db5a0e9e97f238a1795b9", + "name": "gensim", + "sha256": "55353ac926f96ff1092cd2dd8e2c213bb7507031a8d25f60182290becdf41fab", + "size": 19324846, + "subdir": "linux-64", + "timestamp": 1569354064548, + "version": "3.8.0" + }, + "gensim-3.8.0-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "921904e8f27f9f1cfe40bcac00db6e1b", + "name": "gensim", + "sha256": "05e15d0c16dc90c62cc395f6b297a7bf442e570120e6b4a5684bd70cc28a8d41", + "size": 19360085, + "subdir": "linux-64", + "timestamp": 1569354077761, + "version": "3.8.0" + }, + "gensim-3.8.0-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.2.1" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "e5a326e56818504280776a3cd6bd8012", + "name": "gensim", + "sha256": "0e813cc16358f49e9f052bbb572c22e338d22e3ce9adfe4266aeca995d1d88ce", + "size": 19322467, + "subdir": "linux-64", + "timestamp": 1569354077282, + "version": "3.8.0" + }, + "gensim-3.8.3-py36h2531618_2.conda": { + "build": "py36h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "md5": "d989a7f4fab4b9df780f306c98de2753", + "name": "gensim", + "sha256": "121a1d2a1a2f001cf407d8ce0328cf7bb0132589bb29733345df07b675e5db15", + "size": 19353684, + "subdir": "linux-64", + "timestamp": 1613993712786, + "version": "3.8.3" + }, + "gensim-3.8.3-py37h2531618_2.conda": { + "build": "py37h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "md5": "62cf9fd0d4b3936cb7f91ee4c45ae5fa", + "name": "gensim", + "sha256": "e5af8772174f3c912bf1f3fffcbf3b25fa3c7e051ecfac9029fbbb5e078be3ab", + "size": 19355519, + "subdir": "linux-64", + "timestamp": 1613994598843, + "version": "3.8.3" + }, + "gensim-3.8.3-py38h2531618_2.conda": { + "build": "py38h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "md5": "072da6bf0670a0389982826fde10bc3c", + "name": "gensim", + "sha256": "a2a83cb3d91c2aaa2403cdd2ddedaa54476afaa489e58bdef98114052cca5751", + "size": 19358820, + "subdir": "linux-64", + "timestamp": 1613994569427, + "version": "3.8.3" + }, + "gensim-3.8.3-py39h2531618_2.conda": { + "build": "py39h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.18.1", + "six >=1.5.0", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "md5": "db07fc4622ff66517c6796a0b8b42693", + "name": "gensim", + "sha256": "36e239c9d49fd8bf7174da67196e8e5531c83c754d5f0ed5aec9433276ec80c2", + "size": 19365575, + "subdir": "linux-64", + "timestamp": 1613994590150, + "version": "3.8.3" + }, + "gensim-4.0.1-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "cython 0.29.23", + "dataclasses", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3", + "python >=3.6,<3.7.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "md5": "84b44b23373806ea79adc4a9256433b6", + "name": "gensim", + "sha256": "f9a04e7d53d1a5dc87bb4f76e731c550813bf9286969f9b0a994082a326124ad", + "size": 19094010, + "subdir": "linux-64", + "timestamp": 1621559079230, + "version": "4.0.1" + }, + "gensim-4.0.1-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "cython 0.29.23", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3", + "python >=3.7,<3.8.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "md5": "ab13a58be4b6753d2226f005e3a34765", + "name": "gensim", + "sha256": "32dedf3469ac03c225bff4e1d1f580c774c8b347904b4bec5e88bc9ac93f25d9", + "size": 19091958, + "subdir": "linux-64", + "timestamp": 1621559071992, + "version": "4.0.1" + }, + "gensim-4.0.1-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "cython 0.29.23", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3", + "python >=3.8,<3.9.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "md5": "108b8384ceb0f05bb9dbe214b00fc40b", + "name": "gensim", + "sha256": "7fe3ab536e7855c82d609be65c7f20df79470c43409748376c5ee0b53ed282ab", + "size": 19124525, + "subdir": "linux-64", + "timestamp": 1621559068349, + "version": "4.0.1" + }, + "gensim-4.0.1-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "cython 0.29.23", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3", + "python >=3.9,<3.10.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "md5": "40b2d5e3246489340f09662c7520c5cf", + "name": "gensim", + "sha256": "3ab82320f929f38cf8ba73e9e42bb37f7a113ac9a0486513633c62ce026bb636", + "size": 19120696, + "subdir": "linux-64", + "timestamp": 1621558618835, + "version": "4.0.1" + }, + "gensim-4.1.2-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "cython >=0.29.23", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "16bd857a74e0a4e9ee13caa3b1fa1a68", + "name": "gensim", + "sha256": "38fb531076ea6a2aad862716a317af07d38c1dfd8105288643e157ce76c92093", + "size": 20496142, + "subdir": "linux-64", + "timestamp": 1646825045675, + "version": "4.1.2" + }, + "gensim-4.1.2-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "cython >=0.29.23", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "8d9521b8fc79ec084d4c99846ba0a9c9", + "name": "gensim", + "sha256": "2dd39f0ce828e7089320a0906094a65084d4c51bf49b74835936dbf5ee50c769", + "size": 19195462, + "subdir": "linux-64", + "timestamp": 1646807555025, + "version": "4.1.2" + }, + "gensim-4.1.2-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "cython >=0.29.23", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "3e7de7618c17a8d3bda5633006a4e713", + "name": "gensim", + "sha256": "8c40d7097fea49c0ae0f52bc5a75d2fb65a7537ac96569b6f50bbca240480a4b", + "size": 19223279, + "subdir": "linux-64", + "timestamp": 1646825032012, + "version": "4.1.2" + }, + "gensim-4.1.2-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "cython >=0.29.23", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "7ca5771fa113c437669a4e6994d9080d", + "name": "gensim", + "sha256": "ef31022b9079bac167a7d66e0c10a6989105ef251beb3b223027a862ed77e5b3", + "size": 19229832, + "subdir": "linux-64", + "timestamp": 1646806891493, + "version": "4.1.2" + }, + "gensim-4.2.0-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "cython 0.29.28", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "5c6a592fb923519e1659b0e4d21cb171", + "name": "gensim", + "sha256": "eebd1927de54469027fc5948c5efe48d1a3c0c09b2a9bfc70176e2d7404893c9", + "size": 20711995, + "subdir": "linux-64", + "timestamp": 1657909473209, + "version": "4.2.0" + }, + "gensim-4.2.0-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "cython 0.29.28", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "4385cca2083fe30e98a388d4944d1536", + "name": "gensim", + "sha256": "02d47893ec8ddc4f55021b3815256a5863926f674efe116243634fd6776920fc", + "size": 19179899, + "subdir": "linux-64", + "timestamp": 1657909378832, + "version": "4.2.0" + }, + "gensim-4.2.0-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "cython 0.29.28", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "61c55721bac82b6f4bcda48937062790", + "name": "gensim", + "sha256": "3ed208237f24bfd49a084e6ba6c0f070d9022d8fe3dab291e7e5490769ba6741", + "size": 19204860, + "subdir": "linux-64", + "timestamp": 1657909627285, + "version": "4.2.0" + }, + "gensim-4.2.0-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "cython 0.29.28", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.18.1", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "dcee824f4f0c28a8d8ee8cb14d47958d", + "name": "gensim", + "sha256": "fb51f4b2fd0398321606e672537fa72ad9a12b899d2dec6a2de8b03b355ce056", + "size": 19193204, + "subdir": "linux-64", + "timestamp": 1657909550490, + "version": "4.2.0" + }, + "gensim-4.3.0-py310h1128e8f_0.conda": { + "build": "py310h1128e8f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=1.7.0", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "2982c90ee2a8411be08ba6102c389dc8", + "name": "gensim", + "sha256": "68dca0ab319dc60de4bfba7c5e11f8faae8e3f1907aa65547f1dc9c1940e036b", + "size": 22838222, + "subdir": "linux-64", + "timestamp": 1674852699002, + "version": "4.3.0" + }, + "gensim-4.3.0-py311hba01205_1.conda": { + "build": "py311hba01205_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0", + "scipy >=1.7.0", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "ae2a079d908c726a0bd760b67db9756a", + "name": "gensim", + "sha256": "819e29003df97e0c9579339e8ca4f19a8db24e78490d5f19d1d40454e4b56799", + "size": 21211595, + "subdir": "linux-64", + "timestamp": 1677033437187, + "version": "4.3.0" + }, + "gensim-4.3.0-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.7.0", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "d90587d19591ea22e144dd115665f989", + "name": "gensim", + "sha256": "132566d22f380253633413e5588b35641194d10418395d699f7e5fd444537b25", + "size": 22844445, + "subdir": "linux-64", + "timestamp": 1674852610534, + "version": "4.3.0" + }, + "gensim-4.3.0-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.7.0", + "smart_open >=1.8.1" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "9fb148dff0bc3ca9ee3d6d3f2655a6b8", + "name": "gensim", + "sha256": "640dbfddc88cc0ded2277ab1d0c749991c022179451e4e37dc740501457a5ede", + "size": 22837682, + "subdir": "linux-64", + "timestamp": 1674852521396, + "version": "4.3.0" + }, + "genson-1.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f08eee76e7fc634417b31cccb46a367", + "name": "genson", + "sha256": "72c17306cc4780ac1e0354377441c8db8bc27b0d68d1663e36706e552f8f5c58", + "size": 24348, + "subdir": "linux-64", + "timestamp": 1519234621585, + "version": "1.0.1" + }, + "genson-1.0.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8cf5ae892b2e566827c5d87b9494cf86", + "name": "genson", + "sha256": "1dd97ba975358eb5ba9c92b274cc327d740bd6bd203ae816fb36cd140c999b07", + "size": 24941, + "subdir": "linux-64", + "timestamp": 1519234612038, + "version": "1.0.1" + }, + "genson-1.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c39353a568cf1dd42691e524c2ff2b39", + "name": "genson", + "sha256": "fc18d6bf931bae03a0dcd1ab32bd488655463c3723fe3bc5bb93b77f8e5b61d4", + "size": 25010, + "subdir": "linux-64", + "timestamp": 1519234561279, + "version": "1.0.1" + }, + "genson-1.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1246640524c976a653df59251b00f43", + "name": "genson", + "sha256": "af0a62e1275b68cd6f8195b56e1ef84b4fed2718906326428599b2a425061778", + "size": 24681, + "subdir": "linux-64", + "timestamp": 1530890140838, + "version": "1.0.1" + }, + "genson-1.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e78cbec4c10ddd815b388aea8bbc701c", + "name": "genson", + "sha256": "3403bcf8e6bcb23951562ec6c920833dc7baab8d4bfb7bf044ef7d04cff20668", + "size": 24745, + "subdir": "linux-64", + "timestamp": 1545151337943, + "version": "1.0.2" + }, + "genson-1.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad699880d88bb1e50cc893e41e817410", + "name": "genson", + "sha256": "f25a61561664160d0994e02a4b102526f72bfbb50de71a0e1545e26af9555b00", + "size": 25201, + "subdir": "linux-64", + "timestamp": 1545130114122, + "version": "1.0.2" + }, + "genson-1.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "449cf4eba605786284f2ab0204723fd6", + "name": "genson", + "sha256": "14fa2474d23d4b778e69bce8acccb6fe8c5a72811730b9d205fadd9889043985", + "size": 25311, + "subdir": "linux-64", + "timestamp": 1545130119070, + "version": "1.0.2" + }, + "geopandas-0.12.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "folium", + "geopandas-base 0.12.2 py38h06a4308_0", + "mapclassify >=2.4.0", + "matplotlib-base >=3.2.0", + "python >=3.8,<3.9.0a0", + "rtree", + "xyzservices" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "873acee9410a0da4eb37195d20a37b1c", + "name": "geopandas", + "sha256": "0378ed1e5e2a718f333c11c607488ea5fdb1b106243158ec303c19cde52743a7", + "size": 6672, + "subdir": "linux-64", + "timestamp": 1675672124803, + "version": "0.12.2" + }, + "geopandas-0.12.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "folium", + "geopandas-base 0.12.2 py39h06a4308_0", + "mapclassify >=2.4.0", + "matplotlib-base >=3.2.0", + "python >=3.9,<3.10.0a0", + "rtree", + "xyzservices" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f00dc6248909d417b14240ec94511921", + "name": "geopandas", + "sha256": "632daaf584190cbbe32af1f61a19b5f5d389f46a33b6342aa277b1f4c299c298", + "size": 6667, + "subdir": "linux-64", + "timestamp": 1675672048767, + "version": "0.12.2" + }, + "geopandas-0.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "descartes", + "fiona", + "matplotlib", + "pandas", + "psycopg2", + "pyproj", + "pysal", + "python >=2.7,<2.8.0a0", + "rtree", + "shapely", + "six", + "sqlalchemy" + ], + "license": "BSD 3-clause", + "md5": "470e54520822f695a8afa1936295ab40", + "name": "geopandas", + "sha256": "36276bc239f81a5766d3de1c0f073b0cd4287acf2be907dca76c128f0c5224be", + "size": 902675, + "subdir": "linux-64", + "timestamp": 1530890422320, + "version": "0.3.0" + }, + "geopandas-0.3.0-py27h5233db4_0.conda": { + "build": "py27h5233db4_0", + "build_number": 0, + "depends": [ + "descartes", + "fiona", + "matplotlib", + "pandas", + "psycopg2", + "pyproj", + "pysal", + "python >=2.7,<2.8.0a0", + "rtree", + "shapely", + "six", + "sqlalchemy" + ], + "license": "BSD 3-clause", + "md5": "c133799d0380da8bc842873449ab20c2", + "name": "geopandas", + "sha256": "2d1e6316c43ed89a33ec76612798383cb77ae85c98bc9da9dd8ed9a3a105e46c", + "size": 902893, + "subdir": "linux-64", + "timestamp": 1513269372160, + "version": "0.3.0" + }, + "geopandas-0.3.0-py35h2f9c1c0_0.conda": { + "build": "py35h2f9c1c0_0", + "build_number": 0, + "depends": [ + "descartes", + "fiona", + "matplotlib", + "pandas", + "psycopg2", + "pyproj", + "pysal", + "python >=3.5,<3.6.0a0", + "rtree", + "shapely", + "six", + "sqlalchemy" + ], + "license": "BSD 3-clause", + "md5": "2febfa5137c8ceef436b50af971610e2", + "name": "geopandas", + "sha256": "1a370eeaa2b72b25fe683c19174ff635cdf7ce4e51ca6665f31ec358b9e6a8c8", + "size": 905766, + "subdir": "linux-64", + "timestamp": 1513269562762, + "version": "0.3.0" + }, + "geopandas-0.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "descartes", + "fiona", + "matplotlib", + "pandas", + "psycopg2", + "pyproj", + "pysal", + "python >=3.6,<3.7.0a0", + "rtree", + "shapely", + "six", + "sqlalchemy" + ], + "license": "BSD 3-clause", + "md5": "37df557c362e670433cae96d8d03a1b9", + "name": "geopandas", + "sha256": "8ee6ab4132974ad76ed3b9be9d350c6c22b1dbaf5383bbc64afb52bd5c852fef", + "size": 909114, + "subdir": "linux-64", + "timestamp": 1530890375512, + "version": "0.3.0" + }, + "geopandas-0.3.0-py36h2f9c1c0_0.conda": { + "build": "py36h2f9c1c0_0", + "build_number": 0, + "depends": [ + "descartes", + "fiona", + "matplotlib", + "pandas", + "psycopg2", + "pyproj", + "pysal", + "python >=3.6,<3.7.0a0", + "rtree", + "shapely", + "six", + "sqlalchemy" + ], + "license": "BSD 3-clause", + "md5": "01e0fc2a828252962e3bae41805fef99", + "name": "geopandas", + "sha256": "bb9af4d7aa16fe455de3a2c6060e3c9e1cb529fe945abef6266231cff34c5e67", + "size": 909302, + "subdir": "linux-64", + "timestamp": 1513269580516, + "version": "0.3.0" + }, + "geopandas-0.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "descartes", + "fiona", + "matplotlib", + "pandas", + "psycopg2", + "pyproj", + "pysal", + "python >=3.7,<3.8.0a0", + "rtree", + "shapely", + "six", + "sqlalchemy" + ], + "license": "BSD 3-clause", + "md5": "4c9b22362459857279f05d385a9036c0", + "name": "geopandas", + "sha256": "9b9867998dd1d32181e3ce79b89fed6c482fd0c3b9cd29241c9fad1eaa64e0c0", + "size": 904468, + "subdir": "linux-64", + "timestamp": 1530890334061, + "version": "0.3.0" + }, + "geopandas-0.4.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "descartes", + "fiona", + "matplotlib", + "pandas", + "psycopg2", + "pyproj", + "pysal", + "python >=2.7,<2.8.0a0", + "rtree", + "shapely", + "six", + "sqlalchemy" + ], + "license": "BSD 3-clause", + "md5": "f183e68240ee3ce2664b34c2ca3429de", + "name": "geopandas", + "sha256": "f49e6adc30a20c5a444cdc42daea564ba06b2cdc8a967f0bf2775659a2a70add", + "size": 923455, + "subdir": "linux-64", + "timestamp": 1545418163994, + "version": "0.4.0" + }, + "geopandas-0.4.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "descartes", + "fiona", + "matplotlib", + "pandas", + "psycopg2", + "pyproj", + "pysal", + "python >=3.6,<3.7.0a0", + "rtree", + "shapely", + "six", + "sqlalchemy" + ], + "license": "BSD 3-clause", + "md5": "38ffe07fda394663d6d164a1509ae9bc", + "name": "geopandas", + "sha256": "ae665fa779535eca938016031772534f7c5fb57111daebb4884c816ea12d5955", + "size": 925378, + "subdir": "linux-64", + "timestamp": 1545418174408, + "version": "0.4.0" + }, + "geopandas-0.4.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "descartes", + "fiona", + "matplotlib", + "pandas", + "psycopg2", + "pyproj", + "pysal", + "python >=3.7,<3.8.0a0", + "rtree", + "shapely", + "six", + "sqlalchemy" + ], + "license": "BSD 3-clause", + "md5": "547c8e53fd759562b21bc1e2413ae62d", + "name": "geopandas", + "sha256": "98295ad29071e183feb5dccb81368ae038ece00dbca8f7dc2e8b710ec037f395", + "size": 925286, + "subdir": "linux-64", + "timestamp": 1545418185137, + "version": "0.4.0" + }, + "geopandas-base-0.12.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "fiona >=1.8", + "packaging", + "pandas >=1.0.0", + "pyproj >=2.6.1.post1", + "python >=3.8,<3.9.0a0", + "shapely >=1.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d375b65adb944223c0a42bc6f6c719c6", + "name": "geopandas-base", + "sha256": "5b4da1b034553f4292dd4ea8b7802bb303d1663dcc1f9a662ffc158b99a0bb4b", + "size": 1196498, + "subdir": "linux-64", + "timestamp": 1675672123162, + "version": "0.12.2" + }, + "geopandas-base-0.12.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "fiona >=1.8", + "packaging", + "pandas >=1.0.0", + "pyproj >=2.6.1.post1", + "python >=3.9,<3.10.0a0", + "shapely >=1.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "67fe198dfc302249df95dca2d2ce675c", + "name": "geopandas-base", + "sha256": "5bea400f950fcf254c96d547a8a3acdc45bbe22d58399d190373664b2893c718", + "size": 1196404, + "subdir": "linux-64", + "timestamp": 1675672047136, + "version": "0.12.2" + }, + "geos-3.6.0-h03ef862_2.conda": { + "build": "h03ef862_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPLv2.1", + "md5": "e6f9c182641be5d6d964971c4ebe7d2b", + "name": "geos", + "sha256": "7d0731229f56f3bddd575008aa32589807b66766b7132acaedb3f112c62b0d4c", + "size": 1255595, + "subdir": "linux-64", + "timestamp": 1510864387320, + "version": "3.6.0" + }, + "geos-3.6.0-h62fd342_1.conda": { + "build": "h62fd342_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPLv2.1", + "md5": "1219e49df71978586039712bc3435262", + "name": "geos", + "sha256": "29d69d7405bf7bb972339f201ead7bd70de3dd530cbe472edf7954bdb236d314", + "size": 1255722, + "subdir": "linux-64", + "timestamp": 1509380099632, + "version": "3.6.0" + }, + "geos-3.6.2-heeff764_2.conda": { + "build": "heeff764_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPLv2.1", + "md5": "2ad183acc9a18879aac111b3aab42805", + "name": "geos", + "sha256": "9aeb0b0ff719416556c069d3376a09f6f3a0f765b7eaf37cc6cb4efcd8cc93b5", + "size": 1250500, + "subdir": "linux-64", + "timestamp": 1511288943183, + "version": "3.6.2" + }, + "geos-3.7.1-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPLv2.1", + "md5": "730c5f8df12da33b3294335fe40ea16c", + "name": "geos", + "sha256": "9372de9966ba95986949aa7cc07abb123de9a35004dfa2bb690c50e2e6ce5a32", + "size": 1228485, + "subdir": "linux-64", + "timestamp": 1545278503715, + "version": "3.7.1" + }, + "geos-3.8.0-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "md5": "0a93810ba2437b4bca7b17e30c49f669", + "name": "geos", + "sha256": "1481d198037b9877abc927f9a78edc1f193b528ae0894bc89243ffde892ca9fb", + "size": 984506, + "subdir": "linux-64", + "timestamp": 1573215838521, + "version": "3.8.0" + }, + "geos-3.8.1-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "md5": "187e60349437d1f905d044203aadc8ae", + "name": "geos", + "sha256": "6e6f0adf0624c6a4cc6bfca9d69647cde2b839efd90f325bc8ae0fa487441c51", + "size": 983619, + "subdir": "linux-64", + "timestamp": 1588540645544, + "version": "3.8.1" + }, + "geos-3.9.0-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "md5": "b612b93a306cf0fb67911b6876256195", + "name": "geos", + "sha256": "9e6ff2eb12a4a34fd03af7fe7108df54d4ac558bcaf728de4a10b5be96d0d48c", + "size": 1002508, + "subdir": "linux-64", + "timestamp": 1613161685682, + "version": "3.9.0" + }, + "geos-3.9.1-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "md5": "2dddb00a3add032029cb5ad6e59acec4", + "name": "geos", + "sha256": "31fdcd2dfab6e63d7e74bebfaaf6d3d62d12dd9ffc758c93af47726e57a4730b", + "size": 996533, + "subdir": "linux-64", + "timestamp": 1613329302907, + "version": "3.9.1" + }, + "geos-3.9.1-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "LGPL-2.1", + "md5": "909a024d65ea8ef00ce351610af2058c", + "name": "geos", + "sha256": "d547b7c4a6d4a1641c9fb170e2615eec3cfe27d7e03d5c1bc5b5349741a8c3bc", + "size": 1001385, + "subdir": "linux-64", + "timestamp": 1643015949041, + "version": "3.9.1" + }, + "geotiff-1.4.2-h8e81d37_0.conda": { + "build": "h8e81d37_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "proj4 >=4.9.3,<4.9.4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "e172111fefe1efaf3b8e93b63a215566", + "name": "geotiff", + "sha256": "bc2c7ecfb49440e0f16fb34b917606fc67ccddb13c0a7d269cef1bd05ba62027", + "size": 1111616, + "subdir": "linux-64", + "timestamp": 1524095706648, + "version": "1.4.2" + }, + "geotiff-1.4.2-h9c7010b_0.conda": { + "build": "h9c7010b_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "proj4 >=5.2.0,<5.2.1.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "2541a7bad8dc809051d26805139158d3", + "name": "geotiff", + "sha256": "4e1b3b50a710e33e7916cf1e9c53a5420cc10c5e0c5fdd816ef28adc257b5273", + "size": 1114350, + "subdir": "linux-64", + "timestamp": 1545265212234, + "version": "1.4.2" + }, + "geotiff-1.5.1-h21e8280_0.conda": { + "build": "h21e8280_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "fd6976e80915ebf5bc177e47a2fd23e1", + "name": "geotiff", + "sha256": "fb7b74ffc212d343b2d74183bb89f78ced7a4242286a6a25d478944906c60e75", + "size": 243778, + "subdir": "linux-64", + "timestamp": 1573241782337, + "version": "1.5.1" + }, + "geotiff-1.5.1-h21e8280_1.conda": { + "build": "h21e8280_1", + "build_number": 1, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "45d29d7555cc37c5d1d8fe362094e807", + "name": "geotiff", + "sha256": "65a617999e0c260989fb29a3fffecc119cd22b4318b7b8c2ef9cec5e13ea84ab", + "size": 244301, + "subdir": "linux-64", + "timestamp": 1590596163321, + "version": "1.5.1" + }, + "geotiff-1.5.1-hda54ad2_1.conda": { + "build": "hda54ad2_1", + "build_number": 1, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "proj >=7.0.1,<7.0.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "30fc39517df8414a326e89b574e4c4fe", + "name": "geotiff", + "sha256": "3b93f1ed4abcf1f20a0a361c7830a0b6ff9225f44e67bd0dea5d9386f96306f6", + "size": 245089, + "subdir": "linux-64", + "timestamp": 1590596211313, + "version": "1.5.1" + }, + "geotiff-1.6.0-h21e8280_0.conda": { + "build": "h21e8280_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "5eb71703770e44c58e9c4025f1481dd4", + "name": "geotiff", + "sha256": "f9a0bf81c68e46812720ac2b8946e0086c556f302026d8319736b3a4f0957378", + "size": 245197, + "subdir": "linux-64", + "timestamp": 1596829845039, + "version": "1.6.0" + }, + "geotiff-1.7.0-h2a26cda_1.conda": { + "build": "h2a26cda_1", + "build_number": 1, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2aaa087044ce676be9675fc09c6d662a", + "name": "geotiff", + "sha256": "b9d6f3317f30a4ed9f52763dd3079a793b4af8da3072900a4dfde4012d67d38d", + "size": 279529, + "subdir": "linux-64", + "timestamp": 1679997074086, + "version": "1.7.0" + }, + "geotiff-1.7.0-hd69d5b1_0.conda": { + "build": "hd69d5b1_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "zlib" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb19c0eb740a737869ccd1f2f02b7a0e", + "name": "geotiff", + "sha256": "a544607e1e510a27f7272cafc328635a95d37233817d79805003cd2718b76fcd", + "size": 241206, + "subdir": "linux-64", + "timestamp": 1625555192147, + "version": "1.7.0" + }, + "geoviews-1.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "netcdf4 <1.4.0" + ], + "depends": [ + "bokeh >=0.12.13", + "cartopy >=0.14.2", + "holoviews >=1.10.1", + "jupyter", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b3a2e08e183f2ffe1079a3d94a9447ac", + "name": "geoviews", + "sha256": "0280ba321ba5b2e9d91b1144a6c47f9b504b52be883f5ab8fabff273f417fe58", + "size": 344331, + "subdir": "linux-64", + "timestamp": 1528137058073, + "version": "1.5.0" + }, + "geoviews-1.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "netcdf4 <1.4.0" + ], + "depends": [ + "bokeh >=0.12.13", + "cartopy >=0.14.2", + "holoviews >=1.10.1", + "jupyter", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "df81674266ce1b6dcdf28ededbdda56d", + "name": "geoviews", + "sha256": "5c6e9bdc59a329103112b626a27587004f4b5daba706f475e797a9996ef9ea1d", + "size": 341486, + "subdir": "linux-64", + "timestamp": 1528137107740, + "version": "1.5.0" + }, + "geoviews-1.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "netcdf4 <1.4.0" + ], + "depends": [ + "bokeh >=0.12.13", + "cartopy >=0.14.2", + "holoviews >=1.10.1", + "jupyter", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f2f99f27687a3177e36ce60e5e0bd6bc", + "name": "geoviews", + "sha256": "89f355d657dcab845eb8ed481a5948e0bdc9739d079b9d5f5c51b7c4069240c4", + "size": 343206, + "subdir": "linux-64", + "timestamp": 1528137045031, + "version": "1.5.0" + }, + "geoviews-1.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "datashader", + "gdal", + "geopandas", + "geoviews-core 1.5.1.*", + "jupyter", + "libgdal", + "matplotlib", + "netcdf4 <1.4.0", + "pandas", + "pyct", + "python >=2.7,<2.8.0a0", + "scipy", + "shapely", + "xarray" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9795643421db90b3923a345fc60d8fed", + "name": "geoviews", + "sha256": "17554d80b60ed8ff72b12752da530a67f2f63b29fa95d9cb56e8690e5799853b", + "size": 4949, + "subdir": "linux-64", + "timestamp": 1529435490028, + "version": "1.5.1" + }, + "geoviews-1.5.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "datashader", + "gdal", + "geopandas", + "geoviews-core 1.5.1.*", + "jupyter", + "libgdal", + "matplotlib", + "netcdf4 <1.4.0", + "pandas", + "pyct", + "python >=3.5,<3.6.0a0", + "scipy", + "shapely", + "xarray" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ae0f07c5baae5b65946a3607a56c8cf6", + "name": "geoviews", + "sha256": "a6434fb089e08e469829154a8f69fb85ac8efebb93d8d30b97ccac13ee9cbee0", + "size": 4942, + "subdir": "linux-64", + "timestamp": 1529435414481, + "version": "1.5.1" + }, + "geoviews-1.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "datashader", + "gdal", + "geopandas", + "geoviews-core 1.5.1.*", + "jupyter", + "libgdal", + "matplotlib", + "netcdf4 <1.4.0", + "pandas", + "pyct", + "python >=3.6,<3.7.0a0", + "scipy", + "shapely", + "xarray" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "93db1a9ab5156eac73d34f22813a5782", + "name": "geoviews", + "sha256": "fce7aede8980c1ffe67f823f32b7f66f21315e407ee70acfec291b1c8b62bf98", + "size": 4942, + "subdir": "linux-64", + "timestamp": 1529435207959, + "version": "1.5.1" + }, + "geoviews-core-1.5.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "constrains": [ + "geoviews 1.5.1" + ], + "depends": [ + "bokeh >=0.12.15", + "cartopy >=0.14.2", + "holoviews >=1.10.1", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c9a62e4fc7c43e0a0fd489545a567353", + "name": "geoviews-core", + "sha256": "0589b0d88e5ffdd0c826603233818f00919e1bd61b1be93261e4194b0b404a05", + "size": 337759, + "subdir": "linux-64", + "timestamp": 1529433878078, + "version": "1.5.1" + }, + "geoviews-core-1.5.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "constrains": [ + "geoviews 1.5.1" + ], + "depends": [ + "bokeh >=0.12.15", + "cartopy >=0.14.2", + "holoviews >=1.10.1", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0a7d2ffcbf9debf4a300919c8eb51895", + "name": "geoviews-core", + "sha256": "f50be5e04ba70c43aabe75c6c5ac8d4f84778c8bedc5cb06a7bd56efd76f6b2e", + "size": 343047, + "subdir": "linux-64", + "timestamp": 1642522440553, + "version": "1.5.1" + }, + "geoviews-core-1.5.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "constrains": [ + "geoviews 1.5.1" + ], + "depends": [ + "bokeh >=0.12.15", + "cartopy >=0.14.2", + "holoviews >=1.10.1", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "28ceef127356d2dc000e70d65a6ce777", + "name": "geoviews-core", + "sha256": "008152fa674e3c5f8c34d1688ac46e8bb10f3941d3e3ee31835582af595675e5", + "size": 339568, + "subdir": "linux-64", + "timestamp": 1529433921219, + "version": "1.5.1" + }, + "geoviews-core-1.5.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "constrains": [ + "geoviews 1.5.1" + ], + "depends": [ + "bokeh >=0.12.15", + "cartopy >=0.14.2", + "holoviews >=1.10.1", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1d7c434b29cff6d515d077788f6d6b6a", + "name": "geoviews-core", + "sha256": "3de9d46203b16519041e31552f2e4ca6758b9214d524a731d5bc6fabafa77c80", + "size": 338141, + "subdir": "linux-64", + "timestamp": 1529433816686, + "version": "1.5.1" + }, + "get_terminal_size-1.0.0-haa9412d_0.conda": { + "build": "haa9412d_0", + "build_number": 0, + "depends": [ + "backports.shutil_get_terminal_size" + ], + "license": "MIT", + "md5": "8e50035510680f5e0d2a4a968e3db4b3", + "name": "get_terminal_size", + "sha256": "f8f843e02a9a7305df8f12521e12225bb2ffd4ba97a75e802052a9f1b7c6672b", + "size": 3010, + "subdir": "linux-64", + "timestamp": 1505743304546, + "version": "1.0.0" + }, + "gettext-0.19.8.1-h9b4dc7a_1.conda": { + "build": "h9b4dc7a_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPLv2", + "md5": "299b6e981d401faa85ee33c2b305aa4f", + "name": "gettext", + "sha256": "bf11980687542a9eb06fe4c2103867fc2153b6832d547525af9dc1765e70093f", + "size": 3027223, + "subdir": "linux-64", + "timestamp": 1505743479908, + "version": "0.19.8.1" + }, + "gettext-0.19.8.1-hd7bead4_3.conda": { + "build": "hd7bead4_3", + "build_number": 3, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0" + ], + "license": "GPLv2", + "md5": "fe53ce328dece85be4210a03e68e2278", + "name": "gettext", + "sha256": "6710e88b316a69df8e32402198143a6f0afe49f567b1d945f8acd65fc4b728b4", + "size": 3019154, + "subdir": "linux-64", + "timestamp": 1510610506539, + "version": "0.19.8.1" + }, + "gettext-0.20.2-hf68c758_0.conda": { + "build": "hf68c758_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0" + ], + "license": "GPL-2.0", + "md5": "ebe271ec89971da8254e311700e8a981", + "name": "gettext", + "sha256": "0e9af1f92d3059390881e31142b4c9217fe6a679cb62798567113ed3dbb51130", + "size": 2707318, + "subdir": "linux-64", + "timestamp": 1617203743233, + "version": "0.20.2" + }, + "gettext-0.21.0-h39681ba_1.conda": { + "build": "h39681ba_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "ncurses >=6.4,<7.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "f1a124d6d1ba71feb53e83ad7568916d", + "name": "gettext", + "sha256": "4f359b13bc88663cb56cf30c11ac633dce6d4c2db5d45a8eaad521af9fb88a84", + "size": 3197061, + "subdir": "linux-64", + "timestamp": 1679578452756, + "version": "0.21.0" + }, + "gettext-0.21.0-hf68c758_0.conda": { + "build": "hf68c758_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0" + ], + "license": "GPL-2.0", + "md5": "8865b063e818a042678865d8cdd6562a", + "name": "gettext", + "sha256": "48b48e3242a6e7b7ff57be02455aaa7569daa55540071221e63d606e6879194d", + "size": 2769333, + "subdir": "linux-64", + "timestamp": 1617290893597, + "version": "0.21.0" + }, + "gevent-1.2.2-py27h475ea6a_0.conda": { + "build": "py27h475ea6a_0", + "build_number": 0, + "depends": [ + "cffi >=1.3.0", + "greenlet >=0.4.10", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f32c3ff308e009ca4a822a1d48519c5a", + "name": "gevent", + "sha256": "162f306f9bb66fd7c9f89670bca1eb3dd9ef947198a920d8960f3561260b3be7", + "size": 671704, + "subdir": "linux-64", + "timestamp": 1505743619086, + "version": "1.2.2" + }, + "gevent-1.2.2-py35he064abf_0.conda": { + "build": "py35he064abf_0", + "build_number": 0, + "depends": [ + "cffi >=1.3.0", + "greenlet >=0.4.10", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c5fdf573f8e10ea5fa9fd4546f314fe", + "name": "gevent", + "sha256": "e33dacd302aab857c0292b776f70f3ccc13c42cbe94984c84b5898cdc1c8d4a3", + "size": 685806, + "subdir": "linux-64", + "timestamp": 1505743706509, + "version": "1.2.2" + }, + "gevent-1.2.2-py36h2fe25dc_0.conda": { + "build": "py36h2fe25dc_0", + "build_number": 0, + "depends": [ + "cffi >=1.3.0", + "greenlet >=0.4.10", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "65f99947f96022e81ae3f8eda42d631b", + "name": "gevent", + "sha256": "51dc27c17f700313d5c538a2b55aea56258d18300ccec717bbd731126b55c470", + "size": 686823, + "subdir": "linux-64", + "timestamp": 1505743794067, + "version": "1.2.2" + }, + "gevent-1.3.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.10", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2340f3de205d6acb0202559540fc3f3", + "name": "gevent", + "sha256": "6d1f86d4f4493a22f7e35c87a4fd3cba7b796bd59a04bf0a1206745a34970a4d", + "size": 1446050, + "subdir": "linux-64", + "timestamp": 1526406170564, + "version": "1.3.0" + }, + "gevent-1.3.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.10", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b6357cbac2d686902c0c87e11565562", + "name": "gevent", + "sha256": "ba61ed5d4a23622afe5c13a0968fb5f577cf18db090a8b6fcd913042a272748b", + "size": 1455150, + "subdir": "linux-64", + "timestamp": 1526406142626, + "version": "1.3.0" + }, + "gevent-1.3.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.10", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cac092e54a02e06550e60f877c43bf14", + "name": "gevent", + "sha256": "44919ea2455891abeafa3066a317e4db2a412ce12772e0c2ec79e411dbc9f495", + "size": 1464491, + "subdir": "linux-64", + "timestamp": 1526406104590, + "version": "1.3.0" + }, + "gevent-1.3.2.post0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a2cab88950ef73bcc41327313525a55", + "name": "gevent", + "sha256": "b32ec6c5236b5645f2714a522999c6d962a28721b9d7effaad4385ba8142873a", + "size": 1447413, + "subdir": "linux-64", + "timestamp": 1527855212552, + "version": "1.3.2.post0" + }, + "gevent-1.3.2.post0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd3849a605afeea544373a6b4a51b575", + "name": "gevent", + "sha256": "672770e0beba6915b8f81c201b6a3ef74dbaea703bf86c1e156106c5196f3bb8", + "size": 1458738, + "subdir": "linux-64", + "timestamp": 1527855184769, + "version": "1.3.2.post0" + }, + "gevent-1.3.2.post0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ebc05ae7de1fcdae33f6d3fe6ee0ba1", + "name": "gevent", + "sha256": "836e41101c6b75505017ad7fa79f67efbacfb7db1360f9b23bd1e3bb918b7a05", + "size": 1476117, + "subdir": "linux-64", + "timestamp": 1527855144156, + "version": "1.3.2.post0" + }, + "gevent-1.3.3-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b79954a1326a471af270d59f4b39d504", + "name": "gevent", + "sha256": "ce88d68c2fee9dc4c2da80523bc0b9e99f93560deed8b17f139c8dc78becb114", + "size": 1455289, + "subdir": "linux-64", + "timestamp": 1529355276316, + "version": "1.3.3" + }, + "gevent-1.3.3-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebd91191fb6952a34fd857c7b09edcd3", + "name": "gevent", + "sha256": "7519ba81e10e610dd4d9b7d34ce536eb57e986a983142da099f3a0210b56ad0d", + "size": 1468531, + "subdir": "linux-64", + "timestamp": 1529355431696, + "version": "1.3.3" + }, + "gevent-1.3.3-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3eb963a8ac2a8a6781474cd24700d4fa", + "name": "gevent", + "sha256": "64ea20aa29fe223db58de62dcd85846a2d43f301e7b64cbc4fb8c17661169f72", + "size": 1469632, + "subdir": "linux-64", + "timestamp": 1529355425004, + "version": "1.3.3" + }, + "gevent-1.3.4-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f83cec518c902236e9f06b09ce06d6b", + "name": "gevent", + "sha256": "d40d8186c7e2c6c14c94b959b096f2cf517696cf0e2f668ab2bd409db0276a44", + "size": 1449964, + "subdir": "linux-64", + "timestamp": 1529941283252, + "version": "1.3.4" + }, + "gevent-1.3.4-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e3b7ec08bffcfe7e2c904334cdb72c9", + "name": "gevent", + "sha256": "36504758eaa43ffa95456ba330a691b2d7c25fd719cecd77d0fd36bff5cfac58", + "size": 1469533, + "subdir": "linux-64", + "timestamp": 1529941293431, + "version": "1.3.4" + }, + "gevent-1.3.4-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c72da4f573c38f88b3e8121ed8bf4c19", + "name": "gevent", + "sha256": "bc5eb46a5e0100adb3e6ffed6160d03f5e20fe7c5e4d2d3c9029885ecccc5c7c", + "size": 1470914, + "subdir": "linux-64", + "timestamp": 1529941282776, + "version": "1.3.4" + }, + "gevent-1.3.4-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f37a8a447c8601da1699c6cec3ae8d27", + "name": "gevent", + "sha256": "3e795f43f972451ba58391f8d7d24cd95cf7c2610ab65a6a3aeec570e3d50243", + "size": 1465119, + "subdir": "linux-64", + "timestamp": 1530890621572, + "version": "1.3.4" + }, + "gevent-1.3.5-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc7c97b86b7986866d8c51402409cee2", + "name": "gevent", + "sha256": "c54239cefa390ce02da1c734767fd87a10e5dc96fd497bc0fa579355c6f745ec", + "size": 1451625, + "subdir": "linux-64", + "timestamp": 1532523064998, + "version": "1.3.5" + }, + "gevent-1.3.5-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f047c67acfb03e443a97fcdb40d9119", + "name": "gevent", + "sha256": "0d7476eb2648a320573f74575644e130fc30b9efc796c9fdb4c2a44a37a3f5f6", + "size": 1474893, + "subdir": "linux-64", + "timestamp": 1532523012360, + "version": "1.3.5" + }, + "gevent-1.3.5-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c0a10e3baab60ee42af8353e441efe0", + "name": "gevent", + "sha256": "e77cd28480a8ded639afb68c3a78eb119c72ad68c79636dd6c2d74de4e347229", + "size": 1476424, + "subdir": "linux-64", + "timestamp": 1532523059083, + "version": "1.3.5" + }, + "gevent-1.3.5-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbcddb763c23ca5fa8de6df13b8877e3", + "name": "gevent", + "sha256": "d82f255121fa05c13cb377b5f81c2cfe53f7aba0bc6f51f6775d563627bb364f", + "size": 1470526, + "subdir": "linux-64", + "timestamp": 1532523105175, + "version": "1.3.5" + }, + "gevent-1.3.6-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62a40ab483232e8124f4cbcf3e8d68bf", + "name": "gevent", + "sha256": "afb5bba8288dd407947173713f24804f24f1ec8f9f7651889ac410ab72e8e4b0", + "size": 1452167, + "subdir": "linux-64", + "timestamp": 1534951777163, + "version": "1.3.6" + }, + "gevent-1.3.6-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e7e9a5711bf20618e148db40ede9c86", + "name": "gevent", + "sha256": "07658110cfe1f23f53821b9abd07cbbb2746f8bef89a42fd3f845a1a3f10c1ad", + "size": 1473970, + "subdir": "linux-64", + "timestamp": 1534951783744, + "version": "1.3.6" + }, + "gevent-1.3.6-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "627e14222e9d3a54025ac3edfc287d73", + "name": "gevent", + "sha256": "9010d89da3f4dce6c8a71c133eb80baedcc53903dfb9d8464533bbc858987a7f", + "size": 1483669, + "subdir": "linux-64", + "timestamp": 1534951782210, + "version": "1.3.6" + }, + "gevent-1.3.6-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f6c42cbb136af48753ee7227c4e20ef", + "name": "gevent", + "sha256": "975a0f6f50ba9c24f6d85a890c0549c856bcba54b36800d94fe17b04614a72e3", + "size": 1480035, + "subdir": "linux-64", + "timestamp": 1534951786423, + "version": "1.3.6" + }, + "gevent-1.3.7-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "622f42d3ec5ac51c3da42c9ecadaf466", + "name": "gevent", + "sha256": "159e76501f438ebd0f411514a5ccae7c5aed297a4fe2592dba945771c5d6290c", + "size": 1451954, + "subdir": "linux-64", + "timestamp": 1539635707799, + "version": "1.3.7" + }, + "gevent-1.3.7-py27h7b6447c_1.conda": { + "build": "py27h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15c6e5794955e518ab1f3248eae1b8f0", + "name": "gevent", + "sha256": "39ab4e61484fdff22bb2faabd51122b8a8932f0f456cac0d5a93d16a2b0e70b0", + "size": 1451867, + "subdir": "linux-64", + "timestamp": 1540307935570, + "version": "1.3.7" + }, + "gevent-1.3.7-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "86d0e708bc07c3bf7647321e2fc0e468", + "name": "gevent", + "sha256": "ee3a217daea6e7625d7e57c4a5d94929b825227345c6a7b09e97898a0c81497f", + "size": 1474609, + "subdir": "linux-64", + "timestamp": 1539635727846, + "version": "1.3.7" + }, + "gevent-1.3.7-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9bd6d5c051b7315b3d1d4e0e2308980c", + "name": "gevent", + "sha256": "47b9c2ce37e7a68f57652cff22596ab087f5aa4cc7e0ffa2952f799ecd4b4a15", + "size": 1483550, + "subdir": "linux-64", + "timestamp": 1540307995611, + "version": "1.3.7" + }, + "gevent-1.3.7-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.13", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d824115e8c0e8f9af4d52e2aca4fe5c", + "name": "gevent", + "sha256": "4019b79a00a46d37a9bc09c85ec12554c121855fe1a6eeb3c76383ff033b7602", + "size": 1480479, + "subdir": "linux-64", + "timestamp": 1539635675590, + "version": "1.3.7" + }, + "gevent-1.3.7-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "79dc010f27fd840a668529e98d1fa4f8", + "name": "gevent", + "sha256": "87d7f7ff720022dc4265398104c2f7c81233759b459766e48c0a9a54350a14fe", + "size": 1480488, + "subdir": "linux-64", + "timestamp": 1540307941561, + "version": "1.3.7" + }, + "gevent-1.3.7-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e4acf7556090ca987622496fb5ec008", + "name": "gevent", + "sha256": "726b0f7ee6c5259fc5d89860053afb6fccac13acc55eb4c4e63d776fba8911fa", + "size": 1519961, + "subdir": "linux-64", + "timestamp": 1574251613699, + "version": "1.3.7" + }, + "gevent-1.4.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16ab603d08d7bd145971d75fefeb3862", + "name": "gevent", + "sha256": "d5acf0bb4196ab5750941783a38e6ad57b15f91a523f6f7185ff16cabc67fe68", + "size": 2022828, + "subdir": "linux-64", + "timestamp": 1547230529337, + "version": "1.4.0" + }, + "gevent-1.4.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "247dbe94b66b972e74656a54d3af2a28", + "name": "gevent", + "sha256": "2eba26dada1148940065f8ba62a256778c00ebc6b73ab90b1b004b74cf55d69d", + "size": 2062992, + "subdir": "linux-64", + "timestamp": 1547230577792, + "version": "1.4.0" + }, + "gevent-1.4.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b75550f168cebdf28e18e2bd5d9f27f", + "name": "gevent", + "sha256": "3fc81f6225cab0c67236ec57980fb102618a18bb54e12877d3bd7a9027178540", + "size": 2061818, + "subdir": "linux-64", + "timestamp": 1547230549840, + "version": "1.4.0" + }, + "gevent-20.12.0-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ff38bd8c341650fb1f0446d6d1c2c9d", + "name": "gevent", + "sha256": "ef55b75606a87838b3ad790df37c3cc399f39f8e89d3173b27bb6f2228488677", + "size": 1670341, + "subdir": "linux-64", + "timestamp": 1608661211551, + "version": "20.12.0" + }, + "gevent-20.12.0-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01ce29adeffde842a5a72d6c53f808b6", + "name": "gevent", + "sha256": "00bad2a242147b56e0a52180d07129d605865295e11bfdb0c9c284101e0b4eda", + "size": 1685058, + "subdir": "linux-64", + "timestamp": 1608661214889, + "version": "20.12.0" + }, + "gevent-20.12.0-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "86b8a4efdb00b042f16bb1812f48d280", + "name": "gevent", + "sha256": "dd36c9b5ee7101eac420f4d8a72dea7d33131813053d0151e854a124c8ef0543", + "size": 1722166, + "subdir": "linux-64", + "timestamp": 1608661221297, + "version": "20.12.0" + }, + "gevent-20.12.0-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2eda9d9be0635029f07eee7e4b0b112b", + "name": "gevent", + "sha256": "42dd12ed713b9c9ccc7d49da158d66b2fa6cc6b204f77c3fad19efa13fd8a698", + "size": 1732277, + "subdir": "linux-64", + "timestamp": 1608661218373, + "version": "20.12.0" + }, + "gevent-20.12.1-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "100dedf46f717626a7068df4dbc8055c", + "name": "gevent", + "sha256": "fcc14fad0261ead2fe45788ed0b1fb1e1a6300ad7d7601a21c01a690313417af", + "size": 1673921, + "subdir": "linux-64", + "timestamp": 1609093283457, + "version": "20.12.1" + }, + "gevent-20.12.1-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4acda96dfc5d999fb1dfc8e43250e3e", + "name": "gevent", + "sha256": "dc374bd5cefc789f2bd0143fa1e0bc950ed6ec3e94b9ea63274fd00bbdb0e90b", + "size": 1697863, + "subdir": "linux-64", + "timestamp": 1609093269600, + "version": "20.12.1" + }, + "gevent-20.12.1-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc0c15f4603c4bc03b37eca51e3a45ad", + "name": "gevent", + "sha256": "49ab5eece9830d584feb614fc83014b6e3d1834f214ecd562bff6151440f5ffd", + "size": 1739625, + "subdir": "linux-64", + "timestamp": 1609093283675, + "version": "20.12.1" + }, + "gevent-20.12.1-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d0319532c2081746bd555651f244e8c", + "name": "gevent", + "sha256": "ff88da9471fc57cf6dc4916e2103d4384adf7229f93da0c2091392a139aab181", + "size": 1724820, + "subdir": "linux-64", + "timestamp": 1609093315890, + "version": "20.12.1" + }, + "gevent-20.6.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43334c57bf5bbcf6160c50a6c4db8879", + "name": "gevent", + "sha256": "6e428505960c57eb6da8ad07e00e84708580dbd57a5a5c27b553432b7958b344", + "size": 1631734, + "subdir": "linux-64", + "timestamp": 1593009704377, + "version": "20.6.2" + }, + "gevent-20.6.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c305d20bebcc4a24b6f096eac6d3af7", + "name": "gevent", + "sha256": "0c07ca96d2ccc1399f5ec59edeea598843990dcf502cdcf16bc31fbe583cb431", + "size": 1639587, + "subdir": "linux-64", + "timestamp": 1593010102114, + "version": "20.6.2" + }, + "gevent-20.6.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c585067b90c2e6dde3a44412a75ba2d4", + "name": "gevent", + "sha256": "3405a5ff1a83aa4824b692b38884d922a344fcdb604599a74c4910638d9b35e4", + "size": 1681432, + "subdir": "linux-64", + "timestamp": 1593009695671, + "version": "20.6.2" + }, + "gevent-20.9.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "88ef7ce123d0141ab04dc43e20a028c2", + "name": "gevent", + "sha256": "06f888d65a7f665c958d946d30306111a6a1ca238ec98e3e8be6593014c02bf2", + "size": 1627311, + "subdir": "linux-64", + "timestamp": 1601397716384, + "version": "20.9.0" + }, + "gevent-20.9.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e8849c3ad16b308aa242d18d6f1f993", + "name": "gevent", + "sha256": "485fd5259534b07c3a4b8b441a04fd60e79582fd19f394224bfcca67f851a89c", + "size": 1647369, + "subdir": "linux-64", + "timestamp": 1601397718157, + "version": "20.9.0" + }, + "gevent-20.9.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.14", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d4a6144907cccdc45694fdf7e127b5c1", + "name": "gevent", + "sha256": "ac70c095962aef61fb5326ec4dc75124c205d169868377458d584a00ad5524f2", + "size": 1690122, + "subdir": "linux-64", + "timestamp": 1601397678878, + "version": "20.9.0" + }, + "gevent-20.9.0-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0efb0ca3ed5c0180fd4c010d11ca1289", + "name": "gevent", + "sha256": "c645e3875fe14debe1091453539c8f5278f1b6469fd18bf931a38b60fc7e8660", + "size": 1700674, + "subdir": "linux-64", + "timestamp": 1608154882021, + "version": "20.9.0" + }, + "gevent-21.1.0-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "955c94f1bd46a9137e74e59edd57c549", + "name": "gevent", + "sha256": "142e753bf335a2041583f39f17a64102cd7a21f42ec82f17c2997d5bda89aa04", + "size": 1692877, + "subdir": "linux-64", + "timestamp": 1610823139106, + "version": "21.1.0" + }, + "gevent-21.1.0-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "135a15e279c6df28baab0a81c3788412", + "name": "gevent", + "sha256": "02e0b3c1f207160c1ea9c29b1450b7e29ec94684656dc782e07bcdd11d7ed392", + "size": 1712063, + "subdir": "linux-64", + "timestamp": 1610823157323, + "version": "21.1.0" + }, + "gevent-21.1.0-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0516d71040b568df2a7e4f626a107bcd", + "name": "gevent", + "sha256": "0f93e3555376b25c5dd0714d4fe7fd53f477f555ca4f7cf203ef580ba29891b9", + "size": 1747417, + "subdir": "linux-64", + "timestamp": 1610822512901, + "version": "21.1.0" + }, + "gevent-21.1.0-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "41d5ae0704dabd84cea8b1599e3803c5", + "name": "gevent", + "sha256": "21e012afc6e8a5547ff8eee3b0f993f5afb5dd4572c35fa95ba87f69931e8bef", + "size": 1739422, + "subdir": "linux-64", + "timestamp": 1610823147679, + "version": "21.1.0" + }, + "gevent-21.1.1-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a9c7849115aab7f6f32d66430246141", + "name": "gevent", + "sha256": "6c916b38064bd9e9ed5aeb97cfe7463704955e212ab462129ec741634df3819a", + "size": 1689734, + "subdir": "linux-64", + "timestamp": 1610995914836, + "version": "21.1.1" + }, + "gevent-21.1.1-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b3b2c9e2f303833385112ba48780194e", + "name": "gevent", + "sha256": "e37c6401b6236a337f75480243004c64b7dcac1356fba493a16514c8138554c6", + "size": 1705102, + "subdir": "linux-64", + "timestamp": 1610995949439, + "version": "21.1.1" + }, + "gevent-21.1.1-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ec90b2c40b06d2b33ef99429f4c2cd9", + "name": "gevent", + "sha256": "f1ab39359f5bb0c0240897e037bc941040b373d5fcebea9903eea01003fdc2bc", + "size": 1743304, + "subdir": "linux-64", + "timestamp": 1610995170970, + "version": "21.1.1" + }, + "gevent-21.1.1-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.11.5", + "greenlet >=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "68c16deacaa7118a9734b968c6fb9fd5", + "name": "gevent", + "sha256": "be99fe4529944a666d8ce84a07efe25283421eec1e0e09c9820b775c5a0402af", + "size": 1740081, + "subdir": "linux-64", + "timestamp": 1610995891765, + "version": "21.1.1" + }, + "gevent-21.1.2-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.11.5", + "greenlet >=0.4.17,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2daf5782196064ec7c3c924fdcd2c63d", + "name": "gevent", + "sha256": "ecf033d1c4ad2d50ef32d28b6ec359ed885ebed90c808f645592ee18009f2a0e", + "size": 1541719, + "subdir": "linux-64", + "timestamp": 1616408845827, + "version": "21.1.2" + }, + "gevent-21.1.2-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.11.5", + "greenlet >=0.4.17,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9d2b5cc328c266747ec33c53333ed56", + "name": "gevent", + "sha256": "c0bdf871bfa03c88e8028d02b29770580e4c4094c69e21762e244b1f9d4a730d", + "size": 1551127, + "subdir": "linux-64", + "timestamp": 1616773050134, + "version": "21.1.2" + }, + "gevent-21.1.2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.11.5", + "greenlet >=0.4.17,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5de7599d595962c740abb77e8ddf9b7a", + "name": "gevent", + "sha256": "655fbdafa031aaa04e8e4e47dfac7c3767c072d794df357b3c43b829b2c970ec", + "size": 1558194, + "subdir": "linux-64", + "timestamp": 1616408840824, + "version": "21.1.2" + }, + "gevent-21.1.2-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.11.5", + "greenlet >=0.4.17,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df6f45e8db99ea05007db1129013902b", + "name": "gevent", + "sha256": "6de214196b84dc9e4e77269e45385a60a073170f0b792118b39e9c9fe1af6f31", + "size": 1565719, + "subdir": "linux-64", + "timestamp": 1616773046117, + "version": "21.1.2" + }, + "gevent-21.1.2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.11.5", + "greenlet >=0.4.17,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0d0a854b68014563376da6d78960b47", + "name": "gevent", + "sha256": "2f26d668934ade57658bbc48904478ae43b57e6122a21568927d04d37a8abc44", + "size": 1607235, + "subdir": "linux-64", + "timestamp": 1616408790711, + "version": "21.1.2" + }, + "gevent-21.1.2-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.11.5", + "greenlet >=0.4.17,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd738f16654125318da5f994861aa868", + "name": "gevent", + "sha256": "b23e08febddf2fcb88c9d201361eb13407a535550c14455699b81381e25a91da", + "size": 1600118, + "subdir": "linux-64", + "timestamp": 1616770791479, + "version": "21.1.2" + }, + "gevent-21.1.2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.11.5", + "greenlet >=0.4.17,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "40623f58601a7dc549502fbe40867a43", + "name": "gevent", + "sha256": "c903a59553b2578bc20f893fee94dd0262485d4dec5067d058721225faf743a6", + "size": 1595170, + "subdir": "linux-64", + "timestamp": 1616408845353, + "version": "21.1.2" + }, + "gevent-21.1.2-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.11.5", + "greenlet >=0.4.17,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "160bc89447190131dfd68ad172952ff8", + "name": "gevent", + "sha256": "d25fb71737bc6287dc759e1263b20191184b16b871dd3d730a344f4b4bb71d54", + "size": 1606095, + "subdir": "linux-64", + "timestamp": 1616772977051, + "version": "21.1.2" + }, + "gevent-21.8.0-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=1.1.0,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "41a1705c309369b5f2b00ace3d4bb73f", + "name": "gevent", + "sha256": "3755e47589dc5d83f0185e828a390c7c1106a8fc1c51a92d9e3e075d14f64d89", + "size": 3657945, + "subdir": "linux-64", + "timestamp": 1640809197070, + "version": "21.8.0" + }, + "gevent-21.8.0-py36h7f8727e_1.conda": { + "build": "py36h7f8727e_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=1.1.0,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc145eac3ce4618b1836d4cc2249fc57", + "name": "gevent", + "sha256": "55705224330915d01253dfef14fc85a5b610646488e6972ddd7b11dcb2718146", + "size": 1569617, + "subdir": "linux-64", + "timestamp": 1628273801591, + "version": "21.8.0" + }, + "gevent-21.8.0-py37h7f8727e_1.conda": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=1.1.0,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f335b6fe8d909c339756a44864bb9f3", + "name": "gevent", + "sha256": "0e17d5bd6ae0bb4dff5ed1c65d8fc18473241a90dc8ae6b4559d5bc8e5d4e001", + "size": 1590325, + "subdir": "linux-64", + "timestamp": 1628265701491, + "version": "21.8.0" + }, + "gevent-21.8.0-py38h7f8727e_1.conda": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=1.1.0,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f70426030512a1ef14f8a9872e07e29e", + "name": "gevent", + "sha256": "390fe5476a3d1c4e7c9e4631e33fc852b02020dfc4b411e76e1e769cb010e4c9", + "size": 1621823, + "subdir": "linux-64", + "timestamp": 1628273784436, + "version": "21.8.0" + }, + "gevent-21.8.0-py39h7f8727e_1.conda": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=1.1.0,<2.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c357268aadd4e09745bf8b8e48c1f87d", + "name": "gevent", + "sha256": "bd192ee19d71f55a81b3a653a395d987926c2cbe4b3af0015c0c4eaa687201ee", + "size": 1622096, + "subdir": "linux-64", + "timestamp": 1628273362982, + "version": "21.8.0" + }, + "gevent-22.10.2-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "c-ares >=1.18.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=2.0.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=11.2.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1afdbbf8242d0ade34c81a185975be90", + "name": "gevent", + "sha256": "3dbe4786723d56fdad3b41b539d78521c7a4193293ee198d0c53c9db09a46ef1", + "size": 1742993, + "subdir": "linux-64", + "timestamp": 1670621524042, + "version": "22.10.2" + }, + "gevent-22.10.2-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "c-ares >=1.18.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=2.0.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=11.2.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.11,<3.12.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0ee86ba0643090ce18ab5ddd4eb70b2", + "name": "gevent", + "sha256": "ec83cd66e75367edddfd682c216fcc80f43ee7ab200ebb292df7bfafd658f3b8", + "size": 1882412, + "subdir": "linux-64", + "timestamp": 1676844142426, + "version": "22.10.2" + }, + "gevent-22.10.2-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "c-ares >=1.18.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=2.0.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=11.2.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d94731a8d91fd91bc3727e232b00a67d", + "name": "gevent", + "sha256": "201d582bc6f5ebac3cf6b624b5ff72081a1ff236e93aea60eab06748695aace8", + "size": 1699639, + "subdir": "linux-64", + "timestamp": 1670621368949, + "version": "22.10.2" + }, + "gevent-22.10.2-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "c-ares >=1.18.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=2.0.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=11.2.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c8fb1be01d6f9df12cabc38ed13be4f", + "name": "gevent", + "sha256": "bf1e893706be3208e34bc8a25df00dd8506d6104d945007a0b2962c9b35d2766", + "size": 1743235, + "subdir": "linux-64", + "timestamp": 1670621446346, + "version": "22.10.2" + }, + "gevent-22.10.2-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "c-ares >=1.18.1,<2.0a0", + "cffi >=1.12.2", + "greenlet >=2.0.0", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=11.2.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ca9a90c326bbc4a62f126fdc9cc85ce", + "name": "gevent", + "sha256": "28aa860f5d1652f4aba70f6b5c88c4013077c8b7250bda6b656954b22b22cd4b", + "size": 1735846, + "subdir": "linux-64", + "timestamp": 1670621282648, + "version": "22.10.2" + }, + "gevent-websocket-0.10.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "b1f49bf677b044e81130d15d45de9576", + "name": "gevent-websocket", + "sha256": "9b7a494f41dca55c157a791913a8e2a4828f972832d0108b1c6b3ea0d8519221", + "size": 35716, + "subdir": "linux-64", + "timestamp": 1537207584620, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "17710b0bde776912deaf8ca2510c163e", + "name": "gevent-websocket", + "sha256": "af460f4220582cd5fb663f56d4d1cc0403882df918ea2086f6e2078b9d1cb42e", + "size": 36781, + "subdir": "linux-64", + "timestamp": 1640812144314, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "18f74c93c0f3111d72db14ae3f0d95bc", + "name": "gevent-websocket", + "sha256": "4c6f00e81d2bfe35b4369779b99f65509dace8a6d49cf7ca5e056a47046f53db", + "size": 46837, + "subdir": "linux-64", + "timestamp": 1676907240781, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "6fd9742b060cd07b26e00666814df95a", + "name": "gevent-websocket", + "sha256": "6712fae9f33bcb1858ab23f8b8631df88af2055662f20d57cbd246b2283da7d4", + "size": 36290, + "subdir": "linux-64", + "timestamp": 1537207631764, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "818ce46d94a46df72f5a71ba9685eb14", + "name": "gevent-websocket", + "sha256": "3f2f74b1898d1c3a05bbddd28f1519df8da124632353fb74b16c37584811350c", + "size": 36012, + "subdir": "linux-64", + "timestamp": 1537207644912, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "dcc82d25eab4a24fa1236e3eb829fd82", + "name": "gevent-websocket", + "sha256": "c3430b0caa33a6ec9f2c2820abecc8a8ec96ba05d2594ee69b94da24c2dcedd0", + "size": 279058, + "subdir": "linux-64", + "timestamp": 1614094094044, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "57831e576b4acecbcacadd31811fe27a", + "name": "gevent-websocket", + "sha256": "6288c8f20bb19bb4defd6c9a9ba96274a9f8f658808ce726efcbac2c801e2993", + "size": 35973, + "subdir": "linux-64", + "timestamp": 1537207568212, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "06613c8b5b4c4a4c6ce2df45dc697e7b", + "name": "gevent-websocket", + "sha256": "88e8cdc3b84b49c25c6b9711c89931addab1cb178f64cc0db47d2d37a93bc2f1", + "size": 278853, + "subdir": "linux-64", + "timestamp": 1614093964108, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "70d841cd65f157f94c3e288e3472144a", + "name": "gevent-websocket", + "sha256": "1d5b04ece11b169097a22d68d8420aea5c1bcff64b31337d92182ac67150ba1d", + "size": 36686, + "subdir": "linux-64", + "timestamp": 1574413933779, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "70e0c4d4701f82efc56116b0d3d7ef2b", + "name": "gevent-websocket", + "sha256": "b383e6c7feeabca1894651addf8f4e56271da3ea4d71f72dd970fa08c4b8738e", + "size": 278820, + "subdir": "linux-64", + "timestamp": 1614094090600, + "version": "0.10.1" + }, + "gevent-websocket-0.10.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "gevent", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache", + "license_family": "APACHE", + "md5": "27de0c5239e905a7c9cddf7c7dec308b", + "name": "gevent-websocket", + "sha256": "04f8b84ae011a3013b84dd85cf3ee9264f3752c0d452b8dcf3392d286a05c58c", + "size": 279186, + "subdir": "linux-64", + "timestamp": 1614094091461, + "version": "0.10.1" + }, + "geventhttpclient-1.3.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5465f1848eda45d70dc6e6d655a08c78", + "name": "geventhttpclient", + "sha256": "02c3ea21e54d2ec11a8016ec289bfb2bfc9035f749ad35e5aa1d97e396f55833", + "size": 104023, + "subdir": "linux-64", + "timestamp": 1585079509097, + "version": "1.3.1" + }, + "geventhttpclient-1.3.1-py37hdbfa776_0.conda": { + "build": "py37hdbfa776_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e3496c363cc92529bc9d1cde7bcb33a9", + "name": "geventhttpclient", + "sha256": "017e337f5b4bfbcc241c4a2746ebcc9861cc8c43ed56e50f3398e000580a0073", + "size": 103344, + "subdir": "linux-64", + "timestamp": 1636035831444, + "version": "1.3.1" + }, + "geventhttpclient-1.3.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b640fbb98f292814e0ed3b1523eafdf6", + "name": "geventhttpclient", + "sha256": "2c84e4af329e96e395aa168c8e0278f0cbe275ae50e64616d618a364a8391f0f", + "size": 103426, + "subdir": "linux-64", + "timestamp": 1585079507899, + "version": "1.3.1" + }, + "geventhttpclient-1.3.1-py38hdbfa776_0.conda": { + "build": "py38hdbfa776_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2c2a0124b9034fcd0cfeaff92f50e9f", + "name": "geventhttpclient", + "sha256": "a273cd22e40e537b83b424f463665f9e8aaf4eb977b2b74714ea3a89cc3ab8a1", + "size": 106120, + "subdir": "linux-64", + "timestamp": 1636035204194, + "version": "1.3.1" + }, + "geventhttpclient-1.3.1-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "414a3645e6f60e89409587da1d4842a2", + "name": "geventhttpclient", + "sha256": "b7063759fcd400de23b4ce19dfa457efa7d1a09ea33631d0cd77e56f7b7fba6c", + "size": 104826, + "subdir": "linux-64", + "timestamp": 1585079511958, + "version": "1.3.1" + }, + "geventhttpclient-1.3.1-py39hdbfa776_0.conda": { + "build": "py39hdbfa776_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c69c1cc8b06bb87414c3d84707a4fbb", + "name": "geventhttpclient", + "sha256": "432ea9049a2ffd2caa45e9a3350e2be26cb8d99d42879b880dab74fb01825ac8", + "size": 105945, + "subdir": "linux-64", + "timestamp": 1636023823754, + "version": "1.3.1" + }, + "geventhttpclient-1.4.2-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b3a459749d79653c4f3816cf30d01149", + "name": "geventhttpclient", + "sha256": "705c62e4a9af8fe2ac51d7b7b3cb4cfb2240df11ab8d6d72e74406e5c07b52cf", + "size": 58896, + "subdir": "linux-64", + "timestamp": 1591811179108, + "version": "1.4.2" + }, + "geventhttpclient-1.4.2-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f28fd2fcf4cfe81840d6c679420fbc5", + "name": "geventhttpclient", + "sha256": "5a1b7c31b6ced81de4f5e0441b6146b57d91107788e972fef96c0cd32a7b6b56", + "size": 58870, + "subdir": "linux-64", + "timestamp": 1591810866551, + "version": "1.4.2" + }, + "geventhttpclient-1.4.2-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f46f2317d4b3413ea701462d7d3c04f", + "name": "geventhttpclient", + "sha256": "8d46acd23590a442b2035135dbbba862d605ff0e37d315299064df72df6362fd", + "size": 59654, + "subdir": "linux-64", + "timestamp": 1591811045959, + "version": "1.4.2" + }, + "geventhttpclient-1.4.4-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "53b06f748d8ec82f2988c481ec2e9cfa", + "name": "geventhttpclient", + "sha256": "492f226c3f0ed30180b538b5de63e5e175552aac17c9ee71bea5dfbd1c4e120a", + "size": 59762, + "subdir": "linux-64", + "timestamp": 1599271884848, + "version": "1.4.4" + }, + "geventhttpclient-1.4.4-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "717c7fc0a3f0871c47306279b9473d89", + "name": "geventhttpclient", + "sha256": "b18727daa2b36a85ecb2056911b52a68825f13381b74db26255022f566a8116b", + "size": 60618, + "subdir": "linux-64", + "timestamp": 1599271885144, + "version": "1.4.4" + }, + "geventhttpclient-1.4.4-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b2473eb75e682291367345d0930571c", + "name": "geventhttpclient", + "sha256": "7971fc0e694fbdd06a61cd738214d7f90eb95aaa32d8c9edf8f8e7c5eb2e310a", + "size": 60640, + "subdir": "linux-64", + "timestamp": 1599271877507, + "version": "1.4.4" + }, + "geventhttpclient-1.4.5-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7a370766a13514a112644f752fe705f3", + "name": "geventhttpclient", + "sha256": "9adad11ea75f020a88118ccaef962a5965a51c98f1243b40457f8d4aa0c349a0", + "size": 88438, + "subdir": "linux-64", + "timestamp": 1640812170028, + "version": "1.4.5" + }, + "geventhttpclient-1.4.5-py311h6a678d5_1.conda": { + "build": "py311h6a678d5_1", + "build_number": 1, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc1a9a052722b700d05f95a8e164c920", + "name": "geventhttpclient", + "sha256": "5cafc95514c5653ea48b8e4577888783988075b85b2ebbd9c69f400cfca3aba7", + "size": 74593, + "subdir": "linux-64", + "timestamp": 1676852578775, + "version": "1.4.5" + }, + "geventhttpclient-1.4.5-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "44c09bb9f34b711c8ee787f2bdf47315", + "name": "geventhttpclient", + "sha256": "79b41bb3b42ee259d75eee6f20223270ce4854b1f1d98b2a0d117ce27a429b50", + "size": 59416, + "subdir": "linux-64", + "timestamp": 1607366522680, + "version": "1.4.5" + }, + "geventhttpclient-1.4.5-py36h295c915_0.conda": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e7c41ae583e7ec692d5cafafd5fd7c7a", + "name": "geventhttpclient", + "sha256": "19d277f1ed52c5e3fd5a01377cfe859f5ef46ae970cae63e5d2650184b946546", + "size": 60818, + "subdir": "linux-64", + "timestamp": 1632890830354, + "version": "1.4.5" + }, + "geventhttpclient-1.4.5-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f82b3b5c70c8fb6a0ee57367846a661f", + "name": "geventhttpclient", + "sha256": "ba9edc132a8e2b3b113f57bbe17a3182212bc40ab807c7ce3e216f34d2656563", + "size": 59325, + "subdir": "linux-64", + "timestamp": 1607366545317, + "version": "1.4.5" + }, + "geventhttpclient-1.4.5-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63b314bafb8171351a8b0af9511a7559", + "name": "geventhttpclient", + "sha256": "231fecbdb8eba8b861f7f8d1ab817836d13d7205779d778ac769ae7832028076", + "size": 60702, + "subdir": "linux-64", + "timestamp": 1632891251272, + "version": "1.4.5" + }, + "geventhttpclient-1.4.5-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d056e6b0401dea8ab09858ca7dad4fe", + "name": "geventhttpclient", + "sha256": "6ab56fac300ce6637e57e935235f894ed41d69e7ed836d048bc2a860b6cd30fc", + "size": 60053, + "subdir": "linux-64", + "timestamp": 1607366543008, + "version": "1.4.5" + }, + "geventhttpclient-1.4.5-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22ef239b8ae1801bd1cb2064d0030e03", + "name": "geventhttpclient", + "sha256": "3adc946a56212c5bf12dbe70388c5dbb35bc8562769999a6e0f56cac3d4fb914", + "size": 60984, + "subdir": "linux-64", + "timestamp": 1632891249758, + "version": "1.4.5" + }, + "geventhttpclient-1.4.5-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "certifi", + "gevent >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47b708577b215a917835347e3c264010", + "name": "geventhttpclient", + "sha256": "dad710c3819b45661bc31ec9b018706ef1cbf34845a6bf7847e62cbb4f66e9a8", + "size": 61298, + "subdir": "linux-64", + "timestamp": 1632891266018, + "version": "1.4.5" + }, + "gflags-2.2.1-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "888397f005fdf1968a8cf0884ba124d8", + "name": "gflags", + "sha256": "d170b529ce87d4654041793936efca15581786f60ec1a462afabf80049ee5729", + "size": 134217, + "subdir": "linux-64", + "timestamp": 1512755419155, + "version": "2.2.1" + }, + "gflags-2.2.2-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2466b20a8801c41450ee622c1ad103f4", + "name": "gflags", + "sha256": "db6b325cc8b37b1e90b3170490630061f5007efee1ed39601912a204bc56dcb5", + "size": 129375, + "subdir": "linux-64", + "timestamp": 1542388351673, + "version": "2.2.2" + }, + "gfortran-dbg_linux-64-7.2.0-19.conda": { + "build": "19", + "build_number": 19, + "depends": [ + "binutils_linux-64 7.2.0 19", + "gcc-dbg_linux-64 7.2.0 19", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "f84800303f6248b9855551dc2544c23e", + "name": "gfortran-dbg_linux-64", + "sha256": "a939a8a47f8f310c6971de971e2ecc7db310bc2da832745993de9c4c48e648f6", + "size": 6050, + "subdir": "linux-64", + "timestamp": 1513886593018, + "version": "7.2.0" + }, + "gfortran-dbg_linux-64-7.2.0-24.conda": { + "build": "24", + "build_number": 24, + "depends": [ + "binutils_linux-64 7.2.0 24", + "gcc-dbg_linux-64 7.2.0 24", + "gfortran_impl_linux-64 7.2.0.*", + "package_has_been_revoked" + ], + "license": "GPL", + "md5": "8e05f8d3524bd156145a7d87c06d90da", + "name": "gfortran-dbg_linux-64", + "revoked": true, + "sha256": "1f165a0a782b9e44863b92511069b8dfcfb21af3546bfffcab889932937292cc", + "size": 5464, + "subdir": "linux-64", + "timestamp": 1514480887498, + "version": "7.2.0" + }, + "gfortran-dbg_linux-64-7.2.0-25.conda": { + "build": "25", + "build_number": 25, + "depends": [ + "binutils_linux-64 7.2.0 25", + "gcc-dbg_linux-64 7.2.0 25", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "443e9b136f71ee9de99885236d651a08", + "name": "gfortran-dbg_linux-64", + "sha256": "b04f076386ef2796cb84fc8ab1bd80f76a489e6be7c7347fabb5ddac4be9c65a", + "size": 5469, + "subdir": "linux-64", + "timestamp": 1515156401641, + "version": "7.2.0" + }, + "gfortran-dbg_linux-64-7.3.0-h553295d_1.conda": { + "build": "h553295d_1", + "build_number": 1, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_1", + "gcc-dbg_linux-64 7.3.0 h553295d_1", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "1bab830936d69a74383257fec2b00d9e", + "name": "gfortran-dbg_linux-64", + "sha256": "26f1aeda988be4a84bf5d87e32acd85d2ccea0b08b6a99de16d60ecb050dc97a", + "size": 10226, + "subdir": "linux-64", + "timestamp": 1534694160118, + "version": "7.3.0" + }, + "gfortran-dbg_linux-64-7.3.0-h553295d_2.conda": { + "build": "h553295d_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_2", + "gcc-dbg_linux-64 7.3.0 h553295d_2", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "91e1e7368a30310e0e198c3a681f6527", + "name": "gfortran-dbg_linux-64", + "sha256": "488ff24856bc05c2437a83b48c0df421ca459beb12b11960cd78a2a6a4a30130", + "size": 10259, + "subdir": "linux-64", + "timestamp": 1534794495493, + "version": "7.3.0" + }, + "gfortran-dbg_linux-64-7.3.0-h553295d_26.conda": { + "build": "h553295d_26", + "build_number": 26, + "depends": [ + "binutils_linux-64 7.3.0 h6176602_26", + "gcc-dbg_linux-64 7.3.0 h553295d_26", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "7ef602cdff651aa4175d79f79d099460", + "name": "gfortran-dbg_linux-64", + "sha256": "770cda8d81231426ad79687b4afe99dbe4c225e75b12174d5a16eeb5904c3e1a", + "size": 9707, + "subdir": "linux-64", + "timestamp": 1534693905902, + "version": "7.3.0" + }, + "gfortran-dbg_linux-64-8.2.0-h218040c_1.conda": { + "build": "h218040c_1", + "build_number": 1, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_1", + "gcc-dbg_linux-64 8.2.0 h218040c_1", + "gfortran_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "ec0df1245f767d85995360b5c7069f38", + "name": "gfortran-dbg_linux-64", + "sha256": "e14816e271bf8ab71ba710105395a7a0aee29d0433881b47cd1996a7c5583cd7", + "size": 10221, + "subdir": "linux-64", + "timestamp": 1534694053005, + "version": "8.2.0" + }, + "gfortran-dbg_linux-64-8.2.0-h218040c_26.conda": { + "build": "h218040c_26", + "build_number": 26, + "depends": [ + "binutils_linux-64 8.2.0 h6176602_26", + "gcc-dbg_linux-64 8.2.0 h218040c_26", + "gfortran_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "f44d905b39d37aa2fa8252d5ed503844", + "name": "gfortran-dbg_linux-64", + "sha256": "b838e53e72aaab4fc2365eb314ea061d9dc1887a212928031716541f6dfeaf01", + "size": 9709, + "subdir": "linux-64", + "timestamp": 1534693821605, + "version": "8.2.0" + }, + "gfortran_impl_linux-64-11.2.0-h1234567_0.conda": { + "build": "h1234567_0", + "build_number": 0, + "depends": [ + "gcc_impl_linux-64 >=11.2.0", + "libgcc-ng >=11.2.0", + "libgcc-ng >=4.9", + "libgfortran5 >=11.2.0,<12.0a0", + "libstdcxx-ng >=4.9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "272f30b21c953c446c6faed87162b342", + "name": "gfortran_impl_linux-64", + "sha256": "0f4cc53d106c1c0fe6f9d2fd7384f9c8c3ae7137bb7c1bd905e7e70debc1057d", + "size": 10683365, + "subdir": "linux-64", + "timestamp": 1652859869476, + "version": "11.2.0" + }, + "gfortran_impl_linux-64-11.2.0-h1234567_1.conda": { + "build": "h1234567_1", + "build_number": 1, + "depends": [ + "gcc_impl_linux-64 >=11.2.0", + "libgcc-ng >=11.2.0", + "libgcc-ng >=4.9", + "libgfortran5 >=11.2.0,<12.0a0", + "libstdcxx-ng >=4.9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "bbd6f731b4d86cbcec63d152b31a5211", + "name": "gfortran_impl_linux-64", + "sha256": "afac7ecd94d1a7c85e1fa843756f4bd3641434634ab3a779dc18e3e70e719254", + "size": 10727549, + "subdir": "linux-64", + "timestamp": 1654090965677, + "version": "11.2.0" + }, + "gfortran_impl_linux-64-5.4.0-hdf63c60_3.conda": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [ + "gcc_impl_linux-64 5.4.0 habb00fd_3", + "libgfortran-ng >=5.4.0,<8.0a0" + ], + "license": "GPL", + "md5": "565036978a8c3bec9cb94dac760ef2c5", + "name": "gfortran_impl_linux-64", + "sha256": "2c4430132ef973342ea92dad1f90d1bf6629e1ce8cd5cc778f8194376d9f9356", + "size": 7102305, + "subdir": "linux-64", + "timestamp": 1520969729994, + "version": "5.4.0" + }, + "gfortran_impl_linux-64-7.2.0-hb3c8cce_2.conda": { + "build": "hb3c8cce_2", + "build_number": 2, + "depends": [ + "gcc_impl_linux-64 7.2.0 hc5ce805_2", + "libgfortran-ng >=7.2.0,<8.0a0" + ], + "license": "GPL", + "md5": "305e2bd24570369005b5dae235a9bc53", + "name": "gfortran_impl_linux-64", + "sha256": "dcf034cd5686b696501ef32444fe2b2929fdcb4a0cfb33faea11a49a28f46a30", + "size": 8130908, + "subdir": "linux-64", + "timestamp": 1507263022031, + "version": "7.2.0" + }, + "gfortran_impl_linux-64-7.2.0-hdf63c60_3.conda": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [ + "gcc_impl_linux-64 7.2.0 habb00fd_3", + "libgfortran-ng >=7.2.0,<8.0a0" + ], + "license": "GPL", + "md5": "3fd50081ce709872e6ac6abceeb1c04b", + "name": "gfortran_impl_linux-64", + "sha256": "73ad348c146de37dcb90ad2d6dcf9bfef1108a74261dfe69ea94facea3970f47", + "size": 8144266, + "subdir": "linux-64", + "timestamp": 1520534747402, + "version": "7.2.0" + }, + "gfortran_impl_linux-64-7.3.0-hdf63c60_0.conda": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [ + "gcc_impl_linux-64 7.3.0 habb00fd_0", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7.3.0,<8.0a0" + ], + "license": "GPL", + "md5": "02dde267f3e5719c314495967054e4a2", + "name": "gfortran_impl_linux-64", + "sha256": "a194eed961fd27a9bcbbdc90e4abd38602494ca6990082eaba3c46346cd65950", + "size": 8231561, + "subdir": "linux-64", + "timestamp": 1534628635931, + "version": "7.3.0" + }, + "gfortran_impl_linux-64-7.3.0-hdf63c60_1.conda": { + "build": "hdf63c60_1", + "build_number": 1, + "depends": [ + "gcc_impl_linux-64 7.3.0 habb00fd_1", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7.3.0,<8.0a0" + ], + "license": "GPL", + "md5": "09331930b68efb3b64e841fe4e797911", + "name": "gfortran_impl_linux-64", + "sha256": "dc6e2eaac15f43adf74f74a2ebfe4bb850db2c551402adec2fa522b4e956c767", + "size": 8220284, + "subdir": "linux-64", + "timestamp": 1534866846414, + "version": "7.3.0" + }, + "gfortran_impl_linux-64-7.5.0-ha8c8e06_17.conda": { + "build": "ha8c8e06_17", + "build_number": 17, + "depends": [ + "gcc_impl_linux-64 >=7.5.0", + "libgcc-ng >=4.9", + "libgcc-ng >=7.5.0", + "libgfortran4 >=7.5.0,<8.0a0", + "libstdcxx-ng >=4.9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "bd1e4681ec9dd2de3e33f3007f78ffc3", + "name": "gfortran_impl_linux-64", + "sha256": "951798dfaa9a997c3f07487689ac7bc4726bc01122c4a939eac1372677f1a78d", + "size": 8704560, + "subdir": "linux-64", + "timestamp": 1622660259535, + "version": "7.5.0" + }, + "gfortran_impl_linux-64-8.4.0-h5ed45b9_17.conda": { + "build": "h5ed45b9_17", + "build_number": 17, + "depends": [ + "gcc_impl_linux-64 >=8.4.0", + "libgcc-ng >=4.9", + "libgcc-ng >=8.4.0", + "libgfortran5 >=8.4.0,<9.0a0", + "libstdcxx-ng >=4.9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "dbc0d6254db72d303f7bfac01e058c25", + "name": "gfortran_impl_linux-64", + "sha256": "a349848633af932d0be2d455a679d23da52f2de0945268ec1330a797a157ebb8", + "size": 9215547, + "subdir": "linux-64", + "timestamp": 1622661872136, + "version": "8.4.0" + }, + "gfortran_impl_linux-64-9.3.0-h5abd6ed_17.conda": { + "build": "h5abd6ed_17", + "build_number": 17, + "depends": [ + "gcc_impl_linux-64 >=9.3.0", + "libgcc-ng >=4.9", + "libgcc-ng >=9.3.0", + "libgfortran5 >=9.3.0,<10.0a0", + "libstdcxx-ng >=4.9", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "87fe22da37fef4b98851b340428c69c1", + "name": "gfortran_impl_linux-64", + "sha256": "99abfc7d5bdc17c13252a7fc680aa958e03a4133692698b60822543df21ecde1", + "size": 9251426, + "subdir": "linux-64", + "timestamp": 1622663523249, + "version": "9.3.0" + }, + "gfortran_linux-64-11.2.0-hc2dff05_0.conda": { + "build": "hc2dff05_0", + "build_number": 0, + "depends": [ + "binutils_linux-64 2.38.0 hc2dff05_0", + "gcc_linux-64 11.2.0 h5c386dc_0", + "gfortran_impl_linux-64 11.2.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "eda5ff2d675b0925a8c5b90ac5b71bcb", + "name": "gfortran_linux-64", + "sha256": "f2473ffbebad300b3fcc96c9ab386a029277ab86aedb7829a122df0276520e5b", + "size": 25049, + "subdir": "linux-64", + "timestamp": 1652867216237, + "version": "11.2.0" + }, + "gfortran_linux-64-5.4.0-h98af8de_24.conda": { + "build": "h98af8de_24", + "build_number": 24, + "depends": [ + "binutils_linux-64 5.4.0 had2808c_24", + "gcc_linux-64 5.4.0 h98af8de_24", + "gfortran_impl_linux-64 5.4.0.*" + ], + "license": "GPL", + "md5": "4a59e1ecc0bf66261bd3a0617cbfea29", + "name": "gfortran_linux-64", + "sha256": "05c9ccc20dfc066d01c49407a6f0b539b09bea696335c59324ca45435a42ecfb", + "size": 9292, + "subdir": "linux-64", + "timestamp": 1520970085933, + "version": "5.4.0" + }, + "gfortran_linux-64-7.2.0-19.conda": { + "build": "19", + "build_number": 19, + "depends": [ + "binutils_linux-64 7.2.0 19", + "gcc_linux-64 7.2.0 19", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "cc54b61275f1c8df63fda04fc934e349", + "name": "gfortran_linux-64", + "sha256": "12ed70655ec317e51d1002ec50b2fd5576bb412eb56eebd6c92245bfe65bcb3f", + "size": 5927, + "subdir": "linux-64", + "timestamp": 1513886715098, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-24.conda": { + "build": "24", + "build_number": 24, + "depends": [ + "package_has_been_revoked" + ], + "license": "GPL", + "md5": "1d8e7f85c295c653e3d1fcc31d493096", + "name": "gfortran_linux-64", + "revoked": true, + "sha256": "2de1deed9d7d0e824d80e9350e44c8b946fb0b40c0780f78a6ca60a7d5c28276", + "size": 5390, + "subdir": "linux-64", + "timestamp": 1514474639015, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-25.conda": { + "build": "25", + "build_number": 25, + "depends": [ + "binutils_linux-64 7.2.0 25", + "gcc_linux-64 7.2.0 25", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "29c638d474561f790486409cf9381b4d", + "name": "gfortran_linux-64", + "sha256": "56fd1d1849b215e6ad7268c5481661bd55b41a395bd8f381468c745fbb77f296", + "size": 5437, + "subdir": "linux-64", + "timestamp": 1514480906390, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-26.conda": { + "build": "26", + "build_number": 26, + "depends": [ + "binutils_linux-64 7.2.0 26", + "gcc_linux-64 7.2.0 26", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "332a1122e930d674e54d9dc8c9069e0b", + "name": "gfortran_linux-64", + "sha256": "a0e6e4271263e93afd1f4f7052c3ea4aa99314b2acea49014e78ded78c87958d", + "size": 9398, + "subdir": "linux-64", + "timestamp": 1521829429734, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-h0d86fa5_2.conda": { + "build": "h0d86fa5_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_2", + "gcc_linux-64 7.2.0 hecb3f9c_2", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "1fb706577b6df86d3b9a711e579c5b9a", + "name": "gfortran_linux-64", + "sha256": "c026a490565abcdeb27230554aa75f657c77d8e3456e87d9b676daf86b2bb61f", + "size": 5458, + "subdir": "linux-64", + "timestamp": 1507320099894, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-h36698f7_3.conda": { + "build": "h36698f7_3", + "build_number": 3, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_3", + "gcc_linux-64 7.2.0 h29fd5c9_3", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "99f0d658ade9516b2ca91f6c662d1d04", + "name": "gfortran_linux-64", + "sha256": "4d4b58a35237c2e8b194dba5d03462a669df6fbbc5ec767a620c0696d0e69fdd", + "size": 5463, + "subdir": "linux-64", + "timestamp": 1507320236046, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-h3a66261_14.conda": { + "build": "h3a66261_14", + "build_number": 14, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_14", + "gcc_linux-64 7.2.0 hf1c97a4_14", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "0b4b02f342f18236788d39f43fc31083", + "name": "gfortran_linux-64", + "sha256": "fe8292f6f57e1deb12cfd8bf72923ea7c80a3d2bfe17cddb958700aabb28ed34", + "size": 5633, + "subdir": "linux-64", + "timestamp": 1510930964630, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-h550dcbe_27.conda": { + "build": "h550dcbe_27", + "build_number": 27, + "depends": [ + "binutils_linux-64 7.2.0 had2808c_27", + "gcc_linux-64 7.2.0 h550dcbe_27", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "c238750072cd47ac940a75ed8939369e", + "name": "gfortran_linux-64", + "sha256": "cab4024cf8753d0ba4bd7416419437034bacf02bf7873148fa4c889678fe4326", + "size": 9373, + "subdir": "linux-64", + "timestamp": 1526461257915, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-h6c08c0b_8.conda": { + "build": "h6c08c0b_8", + "build_number": 8, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_8", + "gcc_linux-64 7.2.0 h6f34251_8", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "34ead23d20bd19819fe3ba9ab9d7e9b8", + "name": "gfortran_linux-64", + "sha256": "7d06b14c517901511a66c26d38c3b0073591bfee901844e0b8d623422b4ec404", + "size": 5201, + "subdir": "linux-64", + "timestamp": 1509635179005, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-h6fbc3aa_9.conda": { + "build": "h6fbc3aa_9", + "build_number": 9, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_9", + "gcc_linux-64 7.2.0 h60973fd_9", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "519b3009d8dbe4b6c90cc222d3f980b1", + "name": "gfortran_linux-64", + "sha256": "1fd1298501b92d0f48707f6818937953356744078a923c224752710011df1412", + "size": 5466, + "subdir": "linux-64", + "timestamp": 1509836579938, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-h939f3e1_1.conda": { + "build": "h939f3e1_1", + "build_number": 1, + "depends": [ + "gcc_linux-64 7.2.0 hc7b1ceb_1", + "libgfortran-ng 7.2.0 h6fcbd8e_1" + ], + "license": "GPL", + "md5": "75034326a18d8e6ecd8793ae901eecdf", + "name": "gfortran_linux-64", + "sha256": "0f0a52c723016d366fb7e8e0837e4d9cb8f280df653b30ca92d3aa541ef0b846", + "size": 8133794, + "subdir": "linux-64", + "timestamp": 1505665756299, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-h9b3fb79_10.conda": { + "build": "h9b3fb79_10", + "build_number": 10, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_10", + "gcc_linux-64 7.2.0 h196ecd4_10", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "e96c1aba7545c28d05086d969a5605c1", + "name": "gfortran_linux-64", + "sha256": "afbb823ba4c0367d31551ba0f63e7fbcc620f7e298227c91a6393e3a3c25a5ec", + "size": 5427, + "subdir": "linux-64", + "timestamp": 1510244819941, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-ha0c5ce7_12.conda": { + "build": "ha0c5ce7_12", + "build_number": 12, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_12", + "gcc_linux-64 7.2.0 hd763dfe_12", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "4661854da5972e1ab9f36fc64c44e509", + "name": "gfortran_linux-64", + "sha256": "d8d74ba99e1c3f92f69aa304b7ea60161287700204725ea5bc53f4efc6d80442", + "size": 5934, + "subdir": "linux-64", + "timestamp": 1510792710104, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-hbff877f_13.conda": { + "build": "hbff877f_13", + "build_number": 13, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_13", + "gcc_linux-64 7.2.0 h217957b_13", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "b3f2da27abe6f6fa28e1e2a637c9b4cc", + "name": "gfortran_linux-64", + "sha256": "7a519554e5e3fede828ecbf1f1d98bac9847878d2c29542de652b50acf5730a7", + "size": 5630, + "subdir": "linux-64", + "timestamp": 1510925048763, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-hc3a7fdf_7.conda": { + "build": "hc3a7fdf_7", + "build_number": 7, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_7", + "gcc_linux-64 7.2.0 h22f992b_7", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "9bac6888c76553cf0649915c9d086292", + "name": "gfortran_linux-64", + "sha256": "9f7aaaf95fc521f11531e4f1a7ccbe08f5a6dd7254787f19ff24e23ae87487d4", + "size": 5239, + "subdir": "linux-64", + "timestamp": 1507845399821, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-hc6796cf_11.conda": { + "build": "hc6796cf_11", + "build_number": 11, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_11", + "gcc_linux-64 7.2.0 h4118e58_11", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "6dd5dee18d6c85c5bca44f5838cfd8a2", + "name": "gfortran_linux-64", + "sha256": "b1fcc8c485cd76218e2297ace88ad9548b1b9c2b6276082433259166f271072c", + "size": 5458, + "subdir": "linux-64", + "timestamp": 1510566119764, + "version": "7.2.0" + }, + "gfortran_linux-64-7.2.0-hd729bf5_15.conda": { + "build": "hd729bf5_15", + "build_number": 15, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_15", + "gcc_linux-64 7.2.0 haf1f6fa_15", + "gfortran_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "1e1cb370158e86914ab5f094799c4700", + "name": "gfortran_linux-64", + "sha256": "68c11199655a6f5bfd6ba00942ff663ea0575fc0d08b2acf678cdf2c459050a7", + "size": 5645, + "subdir": "linux-64", + "timestamp": 1511640859457, + "version": "7.2.0" + }, + "gfortran_linux-64-7.3.0-h553295d_15.conda": { + "build": "h553295d_15", + "build_number": 15, + "depends": [ + "binutils_linux-64 2.33.1 h9595d00_15", + "gcc_linux-64 7.3.0 h553295d_15", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "BSD-3-Clause", + "md5": "f669abe9a3730773b9125c9ad2b99ac8", + "name": "gfortran_linux-64", + "sha256": "dee34c0fd391a1020708134b254e785f6564c2dd8b6f534718067693561938e8", + "size": 27188, + "subdir": "linux-64", + "timestamp": 1576707756158, + "version": "7.3.0" + }, + "gfortran_linux-64-7.3.0-h553295d_2.conda": { + "build": "h553295d_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_2", + "gcc_linux-64 7.3.0 h553295d_2", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "ee39afe1be695c77902dbb58404f281f", + "name": "gfortran_linux-64", + "sha256": "1e7428b5e72ed2fd591aea164901a5cb0e6be7c34e06d04928ce404daa5755cc", + "size": 10299, + "subdir": "linux-64", + "timestamp": 1534793056069, + "version": "7.3.0" + }, + "gfortran_linux-64-7.3.0-h553295d_3.conda": { + "build": "h553295d_3", + "build_number": 3, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_3", + "gcc_linux-64 7.3.0 h553295d_3", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "521aefe16751556ab132a3e675bedadd", + "name": "gfortran_linux-64", + "sha256": "ff6111d007c88589dc4493f6657553b63abfc8c091fdc7aa8c955a7342d57ea0", + "size": 10280, + "subdir": "linux-64", + "timestamp": 1534948645368, + "version": "7.3.0" + }, + "gfortran_linux-64-7.3.0-h553295d_6.conda": { + "build": "h553295d_6", + "build_number": 6, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_6", + "gcc_linux-64 7.3.0 h553295d_6", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "a98b276bf860bcdcd3897ffe8ff5f111", + "name": "gfortran_linux-64", + "sha256": "7d24535ff8c0c1c1ec0b468aa98f2dbf3481e061734923526540651af6b0ba2d", + "size": 11352, + "subdir": "linux-64", + "timestamp": 1546883613464, + "version": "7.3.0" + }, + "gfortran_linux-64-7.3.0-h553295d_7.conda": { + "build": "h553295d_7", + "build_number": 7, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_7", + "gcc_linux-64 7.3.0 h553295d_7", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "7b5628e3922e133c0db5b7453151c103", + "name": "gfortran_linux-64", + "sha256": "7a8f7baf9b294c639e1cf7eecf697785d4743a9fddbe005ed945ded0674b9245", + "size": 10443, + "subdir": "linux-64", + "timestamp": 1556137067538, + "version": "7.3.0" + }, + "gfortran_linux-64-7.3.0-h553295d_8.conda": { + "build": "h553295d_8", + "build_number": 8, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_8", + "gcc_linux-64 7.3.0 h553295d_8", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "c940aecb3f921a3a9dbbd8fc0cea679b", + "name": "gfortran_linux-64", + "sha256": "a22cc407c47d62f83d35c54c88f3ceff0c6123373da09b5d28bbb58c3b730f79", + "size": 172819, + "subdir": "linux-64", + "timestamp": 1565123587560, + "version": "7.3.0" + }, + "gfortran_linux-64-7.3.0-h553295d_9.conda": { + "build": "h553295d_9", + "build_number": 9, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_9", + "gcc_linux-64 7.3.0 h553295d_9", + "gfortran_impl_linux-64 7.3.0.*" + ], + "license": "BSD-3-Clause", + "md5": "ed3ef28852b5ffa9c192ad4330037b02", + "name": "gfortran_linux-64", + "sha256": "5e01d176b0eefb348842118906b7cd3bbefd6a9c00995717e80bfc8a0b73d8d5", + "size": 27179, + "subdir": "linux-64", + "timestamp": 1576689715188, + "version": "7.3.0" + }, + "gfortran_linux-64-7.5.0-h96bb648_30.conda": { + "build": "h96bb648_30", + "build_number": 30, + "depends": [ + "binutils_linux-64 2.35.1 h454624a_30", + "gcc_linux-64 7.5.0 h8f34230_30", + "gfortran_impl_linux-64 7.5.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "86332afa0d7d1a0d5029f42b96474076", + "name": "gfortran_linux-64", + "sha256": "54d18aea772ff1fced8c732a81913117c9b14fa5a7a0f74dd74eae4b3d567b08", + "size": 24729, + "subdir": "linux-64", + "timestamp": 1623135029770, + "version": "7.5.0" + }, + "gfortran_linux-64-8.2.0-h218040c_2.conda": { + "build": "h218040c_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_2", + "gcc_linux-64 8.2.0 h218040c_2", + "gfortran_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "56bdcded1f70cb120b66dd91d906da59", + "name": "gfortran_linux-64", + "sha256": "f9d295a0b7507ae7619c001c558ad3aaca40ad2a19eafc0317b2aaf75723d87a", + "size": 10274, + "subdir": "linux-64", + "timestamp": 1534792662978, + "version": "8.2.0" + }, + "gfortran_linux-64-8.2.0-h218040c_3.conda": { + "build": "h218040c_3", + "build_number": 3, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_3", + "gcc_linux-64 8.2.0 h218040c_3", + "gfortran_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "1b610debb62a1c9554f026442245f95a", + "name": "gfortran_linux-64", + "sha256": "3d8327fcd0106e2c0f5b46579a3e7ce01a062e28b6832fa674ac8615505786cb", + "size": 11370, + "subdir": "linux-64", + "timestamp": 1546883590891, + "version": "8.2.0" + }, + "gfortran_linux-64-8.4.0-h65c0feb_30.conda": { + "build": "h65c0feb_30", + "build_number": 30, + "depends": [ + "binutils_linux-64 2.35.1 h454624a_30", + "gcc_linux-64 8.4.0 he201b7d_30", + "gfortran_impl_linux-64 8.4.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "b32ff2813c764342d689a6c857e5bce0", + "name": "gfortran_linux-64", + "sha256": "7a69ae49b4af9a23e3f501f9cfff94273a761ea1976c99c64a58998f4bb2a751", + "size": 24813, + "subdir": "linux-64", + "timestamp": 1623135564464, + "version": "8.4.0" + }, + "gfortran_linux-64-9.3.0-hf47db2c_30.conda": { + "build": "hf47db2c_30", + "build_number": 30, + "depends": [ + "binutils_linux-64 2.35.1 h454624a_30", + "gcc_linux-64 9.3.0 h1ee779e_30", + "gfortran_impl_linux-64 9.3.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "4c0984896704c548ccdc0b4c98a98434", + "name": "gfortran_linux-64", + "sha256": "24a3d361d3e33bb3bca9fe8e57a20a7332b6f1c17280172cd93ae7e8f02cc213", + "size": 24721, + "subdir": "linux-64", + "timestamp": 1623136139292, + "version": "9.3.0" + }, + "ghc-8.2.2-h4c737dc_1003.conda": { + "build": "h4c737dc_1003", + "build_number": 1003, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "70ee49e8c30b1884d8aae011ba937f3d", + "name": "ghc", + "sha256": "be250c0c08380cbca3d4f89668e707eeb0df3a0ee3744d245a917eb65b0f396b", + "size": 132929670, + "subdir": "linux-64", + "timestamp": 1620299799676, + "version": "8.2.2" + }, + "gi-docgen-2022.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "markdown", + "markupsafe", + "pygments", + "python >=3.10,<3.11.0a0", + "toml", + "typogrify" + ], + "license": "GPL-3.0-or-later AND Apache-2.0 AND CC0-1.0", + "license_family": "GPL", + "md5": "d2a139e0673f4938b0ccdebad6cac469", + "name": "gi-docgen", + "sha256": "a0515ec5757ade545db360c39a80e70c08ecb3712dcac4caa63050e086c474eb", + "size": 1235213, + "subdir": "linux-64", + "timestamp": 1677600369373, + "version": "2022.1" + }, + "gi-docgen-2022.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "markdown", + "markupsafe", + "pygments", + "python >=3.11,<3.12.0a0", + "toml", + "typogrify" + ], + "license": "Apache Software License or GNU General Public v3 or later (GPLv3+)", + "license_family": "GPL3", + "md5": "5b29ce0502e2e553f79481873bf6cbf4", + "name": "gi-docgen", + "sha256": "278437e349206c5d9e9e28907072928fcd715ee7654486b9d49edfef87710a93", + "size": 1255359, + "subdir": "linux-64", + "timestamp": 1677686983474, + "version": "2022.1" + }, + "gi-docgen-2022.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "markdown", + "markupsafe", + "pygments", + "python >=3.7,<3.8.0a0", + "toml", + "typogrify" + ], + "license": "GPL-3.0-or-later AND Apache-2.0 AND CC0-1.0", + "license_family": "GPL", + "md5": "5e91e68c21d8ebf52206e28606d0c948", + "name": "gi-docgen", + "sha256": "a2a96ccfce6249ec9bf2cd29a93fcf7541fc5714665ac062549cb3202e2da645", + "size": 1234132, + "subdir": "linux-64", + "timestamp": 1677600339621, + "version": "2022.1" + }, + "gi-docgen-2022.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "markdown", + "markupsafe", + "pygments", + "python >=3.8,<3.9.0a0", + "toml", + "typogrify" + ], + "license": "GPL-3.0-or-later AND Apache-2.0 AND CC0-1.0", + "license_family": "GPL", + "md5": "510e8a51875fcb9f9c803a497d561633", + "name": "gi-docgen", + "sha256": "59a66e6aef2404799cde5154830dc0cc813ea9d16380f5c46774daa2c975c326", + "size": 1234599, + "subdir": "linux-64", + "timestamp": 1677600277597, + "version": "2022.1" + }, + "gi-docgen-2022.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "markdown", + "markupsafe", + "pygments", + "python >=3.9,<3.10.0a0", + "toml", + "typogrify" + ], + "license": "GPL-3.0-or-later AND Apache-2.0 AND CC0-1.0", + "license_family": "GPL", + "md5": "14da6fd6dc08a7b3cac901ddf6a617b5", + "name": "gi-docgen", + "sha256": "5c7c23e20120840e78440f90ef2ec5153e39d0c80bcc89901d450c48afbec945", + "size": 1234075, + "subdir": "linux-64", + "timestamp": 1677600307612, + "version": "2022.1" + }, + "giflib-5.1.4-h14c3975_1.conda": { + "build": "h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "877b1358f7dcf1193e717adc543b2aff", + "name": "giflib", + "sha256": "f68f4dbdeea134d2df86b9f429b064ac613feb5ee1e92dd911041b15cc0c3b52", + "size": 69289, + "subdir": "linux-64", + "timestamp": 1530868405704, + "version": "5.1.4" + }, + "giflib-5.1.4-h26a3ec6_1.conda": { + "build": "h26a3ec6_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "7ef677ff5a8dacddf9af71b5be89c61c", + "name": "giflib", + "sha256": "a217645e24be853b80a03a6cfada854454d7872575a842b9662c1437d8c12ad5", + "size": 69444, + "subdir": "linux-64", + "timestamp": 1511371539652, + "version": "5.1.4" + }, + "giflib-5.1.4-ha764e47_1.conda": { + "build": "ha764e47_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "f4d22187a7c67aaed769a19dc479b865", + "name": "giflib", + "sha256": "003af8422dee46018b35249c7cfa4122c5f5351f06fd9d03d208d64d82734a84", + "size": 69435, + "subdir": "linux-64", + "timestamp": 1509378873674, + "version": "5.1.4" + }, + "giflib-5.2.1-h5eee18b_1.conda": { + "build": "h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "md5": "a010493f3c2e80e21858079d584004aa", + "name": "giflib", + "sha256": "102245ec4739363f5719404a4aa9da819863972da93c662355f638058024df2a", + "size": 76630, + "subdir": "linux-64", + "timestamp": 1674666766879, + "version": "5.2.1" + }, + "giflib-5.2.1-h5eee18b_2.conda": { + "build": "h5eee18b_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "795740d11ea4c4ce53dd586fe13241cb", + "name": "giflib", + "sha256": "01511f5877260c53fc0a640be7552438afd509a4de761e6ca5579287c68cf9bc", + "size": 81329, + "subdir": "linux-64", + "timestamp": 1676976716663, + "version": "5.2.1" + }, + "giflib-5.2.1-h5eee18b_3.conda": { + "build": "h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa7d64adb3cd8a75d398167f8c29afc3", + "name": "giflib", + "sha256": "733084f0c4c2c5ef1723fab13f38b389d279c197f408fd724d399ef9c4ecfcc9", + "size": 81965, + "subdir": "linux-64", + "timestamp": 1676983203797, + "version": "5.2.1" + }, + "giflib-5.2.1-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "md5": "c2583ad8de5051f19479580c58336f15", + "name": "giflib", + "sha256": "6026e9f1bd54bbff846d938a7e060121bf941a3d82ebddc88de01d7f0af7b6dd", + "size": 79428, + "subdir": "linux-64", + "timestamp": 1603192039050, + "version": "5.2.1" + }, + "git-2.14.1-pl526h58e4575_2.conda": { + "build": "pl526h58e4575_2", + "build_number": 2, + "depends": [ + "curl", + "expat", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "perl 5.*", + "tk 8.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "21087441f9c8d27d553dc418fe53d719", + "name": "git", + "namespace": "global", + "sha256": "10f2caba309e325fde0d4e9602f5387239d75681967bcad248433183bd115c62", + "size": 3178730, + "subdir": "linux-64", + "timestamp": 1505742602911, + "version": "2.14.1" + }, + "git-2.15.0-pl526h838b92b_0.conda": { + "build": "pl526h838b92b_0", + "build_number": 0, + "depends": [ + "curl", + "expat", + "expat >=2.2.5,<3.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "perl 5.*", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "3cef5e4e70c119d7695cbb3d2c44ae39", + "name": "git", + "namespace": "global", + "sha256": "4bf3bbfb9f87764d2b672ca96c09cfcc5cc0dc54490c5931e037a2371ebc0f61", + "size": 3294945, + "subdir": "linux-64", + "timestamp": 1510699319939, + "version": "2.15.0" + }, + "git-2.16.1-hb75a9fb_0.conda": { + "build": "hb75a9fb_0", + "build_number": 0, + "depends": [ + "expat >=2.2.5,<3.0a0", + "libcurl >=7.57.0,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2n,<1.0.3a", + "perl 5.*", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "14c529debf3a7a29817532b07a685c21", + "name": "git", + "namespace": "global", + "sha256": "42f399e6a6749d41ee8cfd5cb8834036d36b1b92de8cdb3d1f72d3b87f9f3131", + "size": 3351726, + "subdir": "linux-64", + "timestamp": 1516814671815, + "version": "2.16.1" + }, + "git-2.16.1-pl526hb75a9fb_1.conda": { + "build": "pl526hb75a9fb_1", + "build_number": 1, + "depends": [ + "expat >=2.2.5,<3.0a0", + "libcurl >=7.58.0,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2n,<1.0.3a", + "perl 5.*", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "7a5c12d68daa921492c48e21cdbb681c", + "name": "git", + "namespace": "global", + "sha256": "02c210f77968d41aeed113ed85adb02bec72c35b52471e18a62046efa87d2332", + "size": 3354829, + "subdir": "linux-64", + "timestamp": 1519073519659, + "version": "2.16.1" + }, + "git-2.17.0-pl526hb75a9fb_0.conda": { + "build": "pl526hb75a9fb_0", + "build_number": 0, + "depends": [ + "expat >=2.2.5,<3.0a0", + "libcurl >=7.59.0,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "perl 5.*", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "b01fa9ba0a3538fb82dd7af8c98b487b", + "name": "git", + "namespace": "global", + "sha256": "68649ee0574158a172ef0b436ed236321e543352ff051038c1d9ab78e571a5b9", + "size": 3383103, + "subdir": "linux-64", + "timestamp": 1523306827090, + "version": "2.17.0" + }, + "git-2.17.1-pl526hb37396a_0.conda": { + "build": "pl526hb37396a_0", + "build_number": 0, + "depends": [ + "expat >=2.2.5,<3.0a0", + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "perl 5.*", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "6370fb80d05fa807ef4b333991c86527", + "name": "git", + "namespace": "global", + "sha256": "be66c3c10898d4638a27d5069e57d432601d5ff77e34577c55f587f69f81eafa", + "size": 3460848, + "subdir": "linux-64", + "timestamp": 1529247849731, + "version": "2.17.1" + }, + "git-2.18.0-pl526hb37396a_0.conda": { + "build": "pl526hb37396a_0", + "build_number": 0, + "depends": [ + "expat >=2.2.5,<3.0a0", + "libcurl >=7.61.0,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "perl 5.*", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "9aacea803a1c259388a223fde8161106", + "name": "git", + "namespace": "global", + "sha256": "533ff7e2c1cab57e5e52786ae960e29a6a76eb7fede094f136224c9d4299781a", + "size": 3399677, + "subdir": "linux-64", + "timestamp": 1533675527769, + "version": "2.18.0" + }, + "git-2.19.1-pl526h7fee0ce_0.conda": { + "build": "pl526h7fee0ce_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "libcurl >=7.61.1,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a", + "perl 5.*", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "f09e79f0506a35604bfeea76fc54ffed", + "name": "git", + "namespace": "global", + "sha256": "37e8dc8ccf84dfecf67c05a0ad741ca135a487ff04dec51c1a2d4b7cb79d54a1", + "size": 3455329, + "subdir": "linux-64", + "timestamp": 1539147443148, + "version": "2.19.1" + }, + "git-2.19.1-pl526hacde149_0.conda": { + "build": "pl526hacde149_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "libcurl >=7.61.1,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "perl 5.*", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "cc9c361adf82e355eff0c52b6bc717d7", + "name": "git", + "namespace": "global", + "sha256": "986861567774f60a5d1a9291587a71b24ae48c95300241fab0146a2cfb32d1ed", + "size": 3453216, + "subdir": "linux-64", + "timestamp": 1539969882324, + "version": "2.19.1" + }, + "git-2.20.1-pl526hacde149_0.conda": { + "build": "pl526hacde149_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "libcurl >=7.63.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "perl 5.*", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "9836e12b85a73d077951b09115b2fbbd", + "name": "git", + "namespace": "global", + "sha256": "fb5ff9ca0a1cb43b508ef1b94a82832109d521c6e400f8cc483bef2fa49303b7", + "size": 2964985, + "subdir": "linux-64", + "timestamp": 1548311457032, + "version": "2.20.1" + }, + "git-2.23.0-pl526hacde149_0.conda": { + "build": "pl526hacde149_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "libcurl >=7.65.3,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "pcre >=8.43,<9.0a0", + "perl 5.*", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2 and LGPL 2.1", + "md5": "ad163ffa437e6dec5c6241f0a02129c9", + "name": "git", + "namespace": "global", + "sha256": "3e878323823f0d4698b59c49bd17e619e4c8037e0818a412a98126aad9309188", + "size": 3387148, + "subdir": "linux-64", + "timestamp": 1572030249779, + "version": "2.23.0" + }, + "git-2.32.0-pl5262hc120c5b_1.conda": { + "build": "pl5262hc120c5b_1", + "build_number": 1, + "depends": [ + "curl", + "expat >=2.2.10,<3.0a0", + "gettext", + "libgcc-ng >=7.5.0", + "libiconv", + "openssl >=1.1.1k,<1.1.2a", + "pcre2 >=10.35,<10.36.0a0", + "perl 5.*", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later and LGPL-2.1-or-later", + "md5": "9f100f445a328618dbac017f47b67499", + "name": "git", + "namespace": "global", + "sha256": "3a89eb31fe9dca06a0bbc31d5b3cc311d39a42175f70a58ebaf0e9b05df784b9", + "size": 6193887, + "subdir": "linux-64", + "timestamp": 1628849197344, + "version": "2.32.0" + }, + "git-2.34.1-pl5262hc120c5b_0.conda": { + "build": "pl5262hc120c5b_0", + "build_number": 0, + "depends": [ + "curl", + "expat >=2.2.10,<3.0a0", + "gettext", + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1m,<1.1.2a", + "pcre2 >=10.37,<10.38.0a0", + "perl 5.*", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later and LGPL-2.1-or-later", + "md5": "c9df2cff7a9a6ef0945e01cb02c1261d", + "name": "git", + "namespace": "global", + "sha256": "13101c9c12773948bde3e42f7007b49d4e7a4e7734ff7a915d8a3da11994d6db", + "size": 6318968, + "subdir": "linux-64", + "timestamp": 1641997303674, + "version": "2.34.1" + }, + "git-lfs-2.13.2-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MIT", + "md5": "ad8aee564265fc4f1f41842796438c69", + "name": "git-lfs", + "sha256": "85d7c51d7a314efbb8a012859f92d6312751afa4220f88ea7199b9369a4d971b", + "size": 3805604, + "subdir": "linux-64", + "timestamp": 1610639278970, + "version": "2.13.2" + }, + "git-lfs-2.13.2-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a172acd6b8befbf64fdafb706fbd8fb2", + "name": "git-lfs", + "sha256": "676c16893bc60455acaec6453efd0ba8a11ba5819cbec36d70c1051c3e5cc296", + "size": 6403784, + "subdir": "linux-64", + "timestamp": 1610563424033, + "version": "2.13.2" + }, + "git-lfs-2.13.3-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MIT", + "license_family": "MIT", + "md5": "bac0974c2520a7660997ef2ed36061a9", + "name": "git-lfs", + "sha256": "a9b8b2a4b0aa49d8752725f5537883cc248dd51d45bcfb8e377c9d77c78907a9", + "size": 3257377, + "subdir": "linux-64", + "timestamp": 1622195800346, + "version": "2.13.3" + }, + "git-lfs-2.5.2-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e143b02846fe3cb0022a705801a5ff95", + "name": "git-lfs", + "sha256": "3537bf3177badd92a65d59ce2bdb1494c8e2726d4312b0fb8f6ced01f228ff86", + "size": 3514367, + "subdir": "linux-64", + "timestamp": 1537382432430, + "version": "2.5.2" + }, + "git-lfs-2.6.1-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea553b61f2613c3e1b2f9170a74a1e14", + "name": "git-lfs", + "sha256": "5543cbc9ffd236fe87c7cda946dd27ec1ec658a3bd24946f7a2a9b126df5d780", + "size": 5205704, + "subdir": "linux-64", + "timestamp": 1547231035591, + "version": "2.6.1" + }, + "gitdb2-2.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cca5a1918a79d2eec587e5531458dd91", + "name": "gitdb2", + "sha256": "e190c102d37e8fcf99a7c911d2b9cea96a40168ee968c1efbbed19bb070540e3", + "size": 89624, + "subdir": "linux-64", + "timestamp": 1522881964888, + "version": "2.0.3" + }, + "gitdb2-2.0.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "acfdd7216f6357aaedf2828e6df802c0", + "name": "gitdb2", + "sha256": "cd2e1567cd2cee94be09ab968897c2f59c4161a30b3b1d2d136662879f2db9b1", + "size": 91531, + "subdir": "linux-64", + "timestamp": 1522881966312, + "version": "2.0.3" + }, + "gitdb2-2.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "073ad1be84619b0afd5ba4d8a765e8d0", + "name": "gitdb2", + "sha256": "72946d0185c23196e8beeeffd80c0611733a0fc6edd610ab77d7fe1bf670b29d", + "size": 90909, + "subdir": "linux-64", + "timestamp": 1522881976331, + "version": "2.0.3" + }, + "gitdb2-2.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4ad931c990e016998173926279fb18da", + "name": "gitdb2", + "sha256": "f86b1c2eef2756398e2c84eda67f1aa47f4e67c5ab0a1f52ad3fdd83121900db", + "size": 90628, + "subdir": "linux-64", + "timestamp": 1530890683881, + "version": "2.0.3" + }, + "gitdb2-2.0.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7f6e5a3cb282e9ca5e2183d7d5887130", + "name": "gitdb2", + "sha256": "69df0789ce02e4b3e2353d311b8133bf4df088881e7cc97b753dd2e2600eb02c", + "size": 89544, + "subdir": "linux-64", + "timestamp": 1535426214104, + "version": "2.0.4" + }, + "gitdb2-2.0.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f91feb41eb985fa3bcb1d50e62d91101", + "name": "gitdb2", + "sha256": "bf6d94aa84f4b924f85f810a3dfe7a767bf8f67203e5ec98533373d0d3823c0e", + "size": 91462, + "subdir": "linux-64", + "timestamp": 1535426223816, + "version": "2.0.4" + }, + "gitdb2-2.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a740f4dcfe0d9d79a18b721701159a38", + "name": "gitdb2", + "sha256": "1a5b85bc738c440335bd34acdebcb1d1e27e72a53e8bf65e386f44bbb6fc5d65", + "size": 90849, + "subdir": "linux-64", + "timestamp": 1535426182740, + "version": "2.0.4" + }, + "gitdb2-2.0.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8a2c1002b7ed76ebcd7e5f79056cf19a", + "name": "gitdb2", + "sha256": "2836fed1b432239b5111dcfe4a9301258e047d2271baba193931e5aa9cddb639", + "size": 89625, + "subdir": "linux-64", + "timestamp": 1535426253499, + "version": "2.0.4" + }, + "gitdb2-2.0.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c7e3484dec0b93472da9b4244e3db784", + "name": "gitdb2", + "sha256": "2ccdb824417943651bc62dcb981511d629c904ecbbbc47050b8797de122d5d95", + "size": 90590, + "subdir": "linux-64", + "timestamp": 1539661246044, + "version": "2.0.5" + }, + "gitdb2-2.0.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a7c6a6dd91322094fb1160071c71102a", + "name": "gitdb2", + "sha256": "641b00da37269f7c1d7f9c0bdea8ca15cf74fc5fb8f6f6590f46b8216df08214", + "size": 91986, + "subdir": "linux-64", + "timestamp": 1539661245617, + "version": "2.0.5" + }, + "gitdb2-2.0.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "smmap2 >=2.0.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fc3241248619b5abd7fc9307d9da41f0", + "name": "gitdb2", + "sha256": "c8fe8f85a5140601797904a6453e3a522ae3ecc110c71027af51e07bb8170665", + "size": 91906, + "subdir": "linux-64", + "timestamp": 1539661254827, + "version": "2.0.5" + }, + "gitpython-2.1.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "259d2388896dce6ed657a13c8cf988b2", + "name": "gitpython", + "sha256": "7f2d25c6b9ed9dfca35364c1c4e682960691bf53fe6c73c5105de735a3738555", + "size": 485171, + "subdir": "linux-64", + "timestamp": 1527642576086, + "version": "2.1.10" + }, + "gitpython-2.1.10-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b2a17be53a15b77e89039692408ec3d4", + "name": "gitpython", + "sha256": "a34dee6b3f945b9348dce2fb33e96e39105808b813760efecf8014f885c4af4b", + "size": 493386, + "subdir": "linux-64", + "timestamp": 1527642601566, + "version": "2.1.10" + }, + "gitpython-2.1.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "94b6a69773617a78760b1e66f253fa6e", + "name": "gitpython", + "sha256": "74c7650d7fcc960ca3e02d2a85d1d7248a2303fc46699297ed66e0329b928127", + "size": 489456, + "subdir": "linux-64", + "timestamp": 1527642546425, + "version": "2.1.10" + }, + "gitpython-2.1.10-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9bef55b297ff4955c39b473d4f360f2f", + "name": "gitpython", + "sha256": "e3e3441fc39ca0d55ad669a2e03224cb557b4481dd99cda1ee1bc2a20ab20676", + "size": 492141, + "subdir": "linux-64", + "timestamp": 1530890717348, + "version": "2.1.10" + }, + "gitpython-2.1.11-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "59c2df3861be961ef2ff0a3ff8c4d86a", + "name": "gitpython", + "sha256": "1da3da11f84f804bc12d3d4702fafcbd3bc1579978e7a38b8f2be067792b85b1", + "size": 488814, + "subdir": "linux-64", + "timestamp": 1532629753823, + "version": "2.1.11" + }, + "gitpython-2.1.11-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "04da07f4c56b1b6d04aca986c4e0aa26", + "name": "gitpython", + "sha256": "78e683ad45bb268ccc21eb4ceb403d3cd44cbab3af014e9f5c177a956a0f2259", + "size": 493664, + "subdir": "linux-64", + "timestamp": 1532629801287, + "version": "2.1.11" + }, + "gitpython-2.1.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6527f0b36fc17370906101633ee42fbc", + "name": "gitpython", + "sha256": "673d09741e0adff0211994119c3915571885910080ea5764cc06a4b43174e232", + "size": 489217, + "subdir": "linux-64", + "timestamp": 1532629710625, + "version": "2.1.11" + }, + "gitpython-2.1.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4c987654117f7d575ec08a7c52523c2c", + "name": "gitpython", + "sha256": "23ca89018ae46d4e806d36df6a13e2d29548f530605ae9d82fe0c63b57f6ba9a", + "size": 490271, + "subdir": "linux-64", + "timestamp": 1532629798513, + "version": "2.1.11" + }, + "gitpython-2.1.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2897867b22dde902197260e816cb2862", + "name": "gitpython", + "sha256": "ccafb13fbe249afa32a3506080ce7a4091347f63ffefa345389a7f58eae0eae2", + "size": 473119, + "subdir": "linux-64", + "timestamp": 1522778050709, + "version": "2.1.5" + }, + "gitpython-2.1.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d5c51d0688c916da3d0c24ee2efce1b1", + "name": "gitpython", + "sha256": "be184c9151ef143dfa8cf1ee00598db32d1928cbe43079abdb06181676f8a289", + "size": 476444, + "subdir": "linux-64", + "timestamp": 1522778083279, + "version": "2.1.5" + }, + "gitpython-2.1.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6a40af486c9c60c6f7ecea2a8644d570", + "name": "gitpython", + "sha256": "b95480c7451076cbc055264dd210ae8f1d2dab50817b2821bac8320589e0ad45", + "size": 476697, + "subdir": "linux-64", + "timestamp": 1522778002208, + "version": "2.1.5" + }, + "gitpython-2.1.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "82a7e7a5b1a2130356f1626c9a84d476", + "name": "gitpython", + "sha256": "e3c9abd83e009bdb7dffbc64edc7a00971270163a2d14a497397f3ed55dd9def", + "size": 479072, + "subdir": "linux-64", + "timestamp": 1522782218281, + "version": "2.1.8" + }, + "gitpython-2.1.8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "acabc7a3c11f7d5aedc82a9ff7dd68f5", + "name": "gitpython", + "sha256": "8e02efec3b46132ca85c6b32bcb493ca085051e3465a4eddceb7c2328cdc7cc1", + "size": 483609, + "subdir": "linux-64", + "timestamp": 1522782242186, + "version": "2.1.8" + }, + "gitpython-2.1.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3c1c0fc3060444e8d5dc91dd20a80adb", + "name": "gitpython", + "sha256": "0e7ff776dd24a048e25c766bbb6502b92fd89927f1a482f28c16dab0ac327348", + "size": 482471, + "subdir": "linux-64", + "timestamp": 1522782215232, + "version": "2.1.8" + }, + "gitpython-2.1.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "11c0169050965f79d9d73592d817a71d", + "name": "gitpython", + "sha256": "0ecc0f45bb3990ebcc567c474859aa80743a2255c791cee08776f6dbff0b7601", + "size": 481490, + "subdir": "linux-64", + "timestamp": 1522783953595, + "version": "2.1.9" + }, + "gitpython-2.1.9-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a25643a3525fb6b844123f938fc2e025", + "name": "gitpython", + "sha256": "936d21a2d38db2a299207214fe9fe83a6b6a12b6027b70c3942d57adffabef16", + "size": 488070, + "subdir": "linux-64", + "timestamp": 1522783428511, + "version": "2.1.9" + }, + "gitpython-2.1.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gitdb2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bbda99a0d2dea2a271546cfa231a5444", + "name": "gitpython", + "sha256": "ca8fb3d048b57b7fbad5d0680c140268910fe2cd963bf25525ab5d9177c43b94", + "size": 481744, + "subdir": "linux-64", + "timestamp": 1522783430790, + "version": "2.1.9" + }, + "gitpython-3.1.30-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "gitdb >=4.0.1,<5", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "83cf681ac6cdacb5f95570d29533280a", + "name": "gitpython", + "sha256": "41bcac51cc8cfbae5c9744a36c39f25edbac22d511f676f3bed59c6aab88c175", + "size": 276019, + "subdir": "linux-64", + "timestamp": 1674662848129, + "version": "3.1.30" + }, + "gitpython-3.1.30-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "gitdb >=4.0.1,<5", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "867d67ba63d182ce90949a42bb009856", + "name": "gitpython", + "sha256": "aa060644a0427ef0717b2eaee9696f538cf244b349a139cabbef9978c9080018", + "size": 345539, + "subdir": "linux-64", + "timestamp": 1676830573119, + "version": "3.1.30" + }, + "gitpython-3.1.30-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "gitdb >=4.0.1,<5", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d0e5fac506d0a22acd0dbe211f4cba39", + "name": "gitpython", + "sha256": "b3d1ed148e71bed71beb7214b94ad94591a21d895f333f71afaa401aced7a413", + "size": 272602, + "subdir": "linux-64", + "timestamp": 1674662819097, + "version": "3.1.30" + }, + "gitpython-3.1.30-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "gitdb >=4.0.1,<5", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a2559c61daf2cd9811a67d4f6d46c871", + "name": "gitpython", + "sha256": "fff2377699e3f3d653b246764ae1a24a36f831a9545a41a54dc90eb6ceb40516", + "size": 273347, + "subdir": "linux-64", + "timestamp": 1674662874859, + "version": "3.1.30" + }, + "gitpython-3.1.30-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "gitdb >=4.0.1,<5", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c4bfe3ab36ddb38a646728014a6c6682", + "name": "gitpython", + "sha256": "4b9ccb85c040a0631fa54c522ce5c535d040e13e234814d9024e0a8179303dc7", + "size": 273660, + "subdir": "linux-64", + "timestamp": 1674662901951, + "version": "3.1.30" + }, + "gl2ps-1.4.2-h70c0345_0.conda": { + "build": "h70c0345_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "f13579c8c3010ed3ea5bf9c48c7ac38f", + "name": "gl2ps", + "sha256": "abfa3f39855c04253a9d95879aad3bdd18cf4b6ffe4cd164941ba0f01babc4c4", + "size": 120536, + "subdir": "linux-64", + "timestamp": 1642094816398, + "version": "1.4.2" + }, + "gl2ps-1.4.2-h70c0345_1.conda": { + "build": "h70c0345_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "0b0b594e1b3c9217efcf73c8fcb08108", + "name": "gl2ps", + "sha256": "5107c27e5982831d99bc74e969f226e7ac4505ba3c1b019eefd7dd73b498fafd", + "size": 121020, + "subdir": "linux-64", + "timestamp": 1644215894265, + "version": "1.4.2" + }, + "glew-2.1.0-h295c915_2.conda": { + "build": "h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libglu", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "md5": "1c0b79a238de59329b5252517ff197d2", + "name": "glew", + "sha256": "a11d64dd2fc7e1d1a6c6c7240d129f4fddf46ffa9d9800bb7b87778b09ec92be", + "size": 544960, + "subdir": "linux-64", + "timestamp": 1642106226883, + "version": "2.1.0" + }, + "glew-2.1.0-h295c915_3.conda": { + "build": "h295c915_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libglu", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "md5": "84d8f5e18d6f991782ed0bbc9548a7f4", + "name": "glew", + "sha256": "cfeeb1ebb6b2b042a06d165fcab09c164d31f5263666bff63370f0aabe70a631", + "size": 543905, + "subdir": "linux-64", + "timestamp": 1643883747315, + "version": "2.1.0" + }, + "glew-2.2.0-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libglu", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c61a6c448c4ad7448cfe833b77191597", + "name": "glew", + "sha256": "9baf210fa68a7909d544baf21766455241dd9083afd573ac316577b2e1286247", + "size": 645081, + "subdir": "linux-64", + "timestamp": 1679057475203, + "version": "2.2.0" + }, + "glib-2.53.6-h0d2cc06_1.conda": { + "build": "h0d2cc06_1", + "build_number": 1, + "depends": [ + "libffi >=3.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "pcre", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "77beac5e98eb31f2d9a3d6c6a24b1b95", + "name": "glib", + "sha256": "353a29a63255c034638c7a2823e95522b214a46653a8a998662cfb7282cc1bd2", + "size": 6947454, + "subdir": "linux-64", + "timestamp": 1509735425274, + "version": "2.53.6" + }, + "glib-2.53.6-h56f7bfe_1.conda": { + "build": "h56f7bfe_1", + "build_number": 1, + "depends": [ + "libffi >=3.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "pcre", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "6f06a41ceba5707f4537589b5fff4eaa", + "name": "glib", + "sha256": "af79df53927a9293e43ba134438c04b7847b6317258c35ebdb2f2c17d054a8bb", + "size": 6947719, + "subdir": "linux-64", + "timestamp": 1509735426706, + "version": "2.53.6" + }, + "glib-2.53.6-h5d9569c_2.conda": { + "build": "h5d9569c_2", + "build_number": 2, + "depends": [ + "libffi >=3.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "pcre", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "cf36166bd11330f77d3949b3438a5aaf", + "name": "glib", + "sha256": "087d2e3c6c68022f051160ce59a81a52e1854ade79278ef8cb4404e3b1e8333f", + "size": 6945559, + "subdir": "linux-64", + "timestamp": 1509994845830, + "version": "2.53.6" + }, + "glib-2.53.6-h7684f33_1.conda": { + "build": "h7684f33_1", + "build_number": 1, + "depends": [ + "libffi >=3.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "pcre", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "96fdafb85e944caf5943911990a2037d", + "name": "glib", + "sha256": "0f1cfb8f52d66517b38e67de4d8cef8db8dcdea46cb0ae60d659b4cd62f15f44", + "size": 6947334, + "subdir": "linux-64", + "timestamp": 1509735226137, + "version": "2.53.6" + }, + "glib-2.53.6-hc861d11_1.conda": { + "build": "hc861d11_1", + "build_number": 1, + "depends": [ + "libffi >=3.0.0", + "libgcc-ng >=7.2.0", + "pcre", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "fc709904fc8bba0aad5b43d4f56c9a1c", + "name": "glib", + "sha256": "f45487b74e5abf9fe9f1a6dc70946789b7877e8ecfe7337e599bf4bada95773d", + "size": 6926049, + "subdir": "linux-64", + "timestamp": 1505735456263, + "version": "2.53.6" + }, + "glib-2.56.0-h000015b_0.conda": { + "build": "h000015b_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "pcre", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "901c2ac56b66386167748b4fec09ca19", + "name": "glib", + "sha256": "8ee2db17d8620ddc241c43470325326ab13fa177ef16ceea636f362f3c96e35f", + "size": 4097092, + "subdir": "linux-64", + "timestamp": 1522691446165, + "version": "2.56.0" + }, + "glib-2.56.1-h000015b_0.conda": { + "build": "h000015b_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "pcre", + "pcre >=8.42,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "de5da5241bbe9979b41baf92917db42d", + "name": "glib", + "sha256": "d469ad23f6a08e62b0c20feb4e02f45ce540bab6cc356ff1cc0d70ecffbe24d7", + "size": 4105252, + "subdir": "linux-64", + "timestamp": 1523664837756, + "version": "2.56.1" + }, + "glib-2.56.2-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.42,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "75b3b8b4aad0571868d8122e89f5dfdc", + "name": "glib", + "sha256": "6a1e7272fbdcad167109c201d932e12d6c7911ba9140223f628aa5c7a7f1aba9", + "size": 4141875, + "subdir": "linux-64", + "timestamp": 1535475913016, + "version": "2.56.2" + }, + "glib-2.63.1-h3eb4bd4_1.conda": { + "build": "h3eb4bd4_1", + "build_number": 1, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.43,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "7f2c4a372d5750de9750ae75ae5830c0", + "name": "glib", + "sha256": "f36323f1c1964bd4be21f64450ae8500af08e1343036b52a6f547fd9db22081a", + "size": 2997780, + "subdir": "linux-64", + "timestamp": 1589813870891, + "version": "2.63.1" + }, + "glib-2.63.1-h5a9c865_0.conda": { + "build": "h5a9c865_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.43,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "c05e1fa89ebacdd19c8ec896cfff59ed", + "name": "glib", + "sha256": "77085a918ff0dfee3d8486bddd55c7b1a4c925f90bd8f1e716dd25d916ebb753", + "size": 3001417, + "subdir": "linux-64", + "timestamp": 1573052323452, + "version": "2.63.1" + }, + "glib-2.65.0-h3eb4bd4_0.conda": { + "build": "h3eb4bd4_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "68c4dc0bbd9cbba500507a5d304b8d63", + "name": "glib", + "sha256": "52ed7713091cbb3c8ec8d05d76572b79d4090d5bba5528702c35b0d7b3fb4c16", + "size": 3047413, + "subdir": "linux-64", + "timestamp": 1593199609035, + "version": "2.65.0" + }, + "glib-2.66.1-h92f7085_0.conda": { + "build": "h92f7085_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "9430d6ac60c7c4429e99ae0b1878a39b", + "name": "glib", + "sha256": "8926874da0fb6f1d1a0e9a26e8115fdad52de762d5fddcf690beabf0f6fb38dd", + "size": 3069852, + "subdir": "linux-64", + "timestamp": 1602709775969, + "version": "2.66.1" + }, + "glib-2.67.3-h36276a3_1.conda": { + "build": "h36276a3_1", + "build_number": 1, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "51b690c57c40b52524d94dfe07b1d54b", + "name": "glib", + "sha256": "efca72102470ea54b125cc84c773ce23ef592165ceeec5846f05ba8770f43602", + "size": 3093098, + "subdir": "linux-64", + "timestamp": 1613329495364, + "version": "2.67.3" + }, + "glib-2.67.4-h36276a3_1.conda": { + "build": "h36276a3_1", + "build_number": 1, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "14ebd49e913becbc1cc70b19e83d8491", + "name": "glib", + "sha256": "1840e5e9532b301c9d434b1aa9acb5d115e278a32381bf83eeee8b337e70d485", + "size": 3100217, + "subdir": "linux-64", + "timestamp": 1613587777854, + "version": "2.67.4" + }, + "glib-2.68.0-h36276a3_0.conda": { + "build": "h36276a3_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "c7a12531475328cd01a5aa82ce0125c9", + "name": "glib", + "sha256": "81f59feb67a14ceb0c0b1480316060f1584df02628fef492038482e1dfe52bf1", + "size": 3103934, + "subdir": "linux-64", + "timestamp": 1616685061597, + "version": "2.68.0" + }, + "glib-2.68.1-h36276a3_0.conda": { + "build": "h36276a3_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "ef1fb6ff69666bab3280c8b4846e11a4", + "name": "glib", + "sha256": "7a3d4f964cb0254b5f729a22d9493f92711a0dd6a079143f439a8766f7879447", + "size": 3098189, + "subdir": "linux-64", + "timestamp": 1617998734166, + "version": "2.68.1" + }, + "glib-2.68.2-h36276a3_0.conda": { + "build": "h36276a3_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "f82eca8148fb4e023355893db57863de", + "name": "glib", + "sha256": "0e88408be1ff0796f5fbba14d32bb122d540d99de709aeb2ee3a198bba6ed7c4", + "size": 3104054, + "subdir": "linux-64", + "timestamp": 1621259668015, + "version": "2.68.2" + }, + "glib-2.69.0-h5202010_0.conda": { + "build": "h5202010_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "pcre >=8.45,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "37690f16da9661093d10e6191329a990", + "name": "glib", + "sha256": "64ff859d8cfecd4b91f30e52c66e88c98f606e1f3c1f6e91bc0ec4ee6a2fbb97", + "size": 1812148, + "subdir": "linux-64", + "timestamp": 1625681449233, + "version": "2.69.0" + }, + "glib-2.69.1-h4ff587b_1.conda": { + "build": "h4ff587b_1", + "build_number": 1, + "depends": [ + "libffi >=3.3", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "pcre >=8.45,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "4c3eae7c0b8b1c8fb3046a0740313bbf", + "name": "glib", + "sha256": "ff780e0972134a6395d7e17cd74094a275c11d67538a99fc0cac31b8e09f266b", + "size": 1818671, + "subdir": "linux-64", + "timestamp": 1642701448286, + "version": "2.69.1" + }, + "glib-2.69.1-h5202010_0.conda": { + "build": "h5202010_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "pcre >=8.45,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "d7336b2523170ce22669972f4f8c3a20", + "name": "glib", + "sha256": "3f4e16e93629a1fc05e32bdd76806ed8ff1eda472b726deae2df9e0378086ce4", + "size": 1815133, + "subdir": "linux-64", + "timestamp": 1629381585657, + "version": "2.69.1" + }, + "glib-2.69.1-he621ea3_2.conda": { + "build": "he621ea3_2", + "build_number": 2, + "depends": [ + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pcre >=8.45,<9.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "51cf1899782b3f3744aedd143fbc07f3", + "name": "glib", + "sha256": "72c578259d3d01d68e1a348f4402c131f0b9a68ea42c0b0e334a3fb48c062375", + "size": 1991299, + "subdir": "linux-64", + "timestamp": 1669364519815, + "version": "2.69.1" + }, + "glob2-0.5-py27hd3b7d1f_1.conda": { + "build": "py27hd3b7d1f_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "6aa40f6aa6cad30edb1c895345d78ae1", + "name": "glob2", + "sha256": "7e86b3dcfb0158bc8844a63df39f83d27f3bec82284303bc3bfc44c8130499c1", + "size": 16092, + "subdir": "linux-64", + "timestamp": 1505742233538, + "version": "0.5" + }, + "glob2-0.5-py35h98a1f2a_1.conda": { + "build": "py35h98a1f2a_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-2-Clause", + "md5": "c9dd28f3c1a17963249b82e387e2bb4e", + "name": "glob2", + "sha256": "5181ae6561a6320434be67d2ee39502bfaded7cf83622ddb94dd982b5ba57418", + "size": 16260, + "subdir": "linux-64", + "timestamp": 1505742245766, + "version": "0.5" + }, + "glob2-0.5-py36h2c1b292_1.conda": { + "build": "py36h2c1b292_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "a32aa53da2d6f0b70eaa3f4a3bdd9e66", + "name": "glob2", + "sha256": "68026ed8801c4460e3d7c631c8c4dad2b09eb8dad6cf6a921c10bc2b9ee45648", + "size": 16190, + "subdir": "linux-64", + "timestamp": 1505742258045, + "version": "0.5" + }, + "glob2-0.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e82ec4abbf1b76999f83055314c015bc", + "name": "glob2", + "sha256": "d7feae456bac61f8153f35bf5e7da812780c4cde9dca42584a11f52eadbb44a6", + "size": 17233, + "subdir": "linux-64", + "timestamp": 1530813614048, + "version": "0.6" + }, + "glob2-0.6-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "4608ede21916323fc0ee904fed047ff7", + "name": "glob2", + "sha256": "4b25d8e23cc128bba218c243698b415db25284ea0451110497e3afc65fcd605e", + "size": 17950, + "subdir": "linux-64", + "timestamp": 1538518983444, + "version": "0.6" + }, + "glob2-0.6-py27hcea9cbd_0.conda": { + "build": "py27hcea9cbd_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "0c3d4f4527d62458d9168bda0b45dd4b", + "name": "glob2", + "sha256": "6e2d16e87fc4b0b6f9336a8f1581f67c3e79b1be881da92b44286aae0340d998", + "size": 17684, + "subdir": "linux-64", + "timestamp": 1511295062443, + "version": "0.6" + }, + "glob2-0.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d210be51f262efdf9be6eae3ea5cc2e2", + "name": "glob2", + "sha256": "ebf319cef161c4c077dd30c5e63acc5245df8a3b4ba0a231d23996714ee9463d", + "size": 17499, + "subdir": "linux-64", + "timestamp": 1535130222865, + "version": "0.6" + }, + "glob2-0.6-py35hff66265_0.conda": { + "build": "py35hff66265_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a2ab020fe1d743ce839917b364969882", + "name": "glob2", + "sha256": "6c2a4415b4ee054209deabd52974f4eceabdfeaecaa05cad4532ae9bdfc2aace", + "size": 17755, + "subdir": "linux-64", + "timestamp": 1511295064174, + "version": "0.6" + }, + "glob2-0.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e3261d2f9b3f4b1c58b9a14ea876151a", + "name": "glob2", + "sha256": "75f1189ec29cfb9f6b477034520a64111e92933e80a61d06131bc04196383b89", + "size": 17362, + "subdir": "linux-64", + "timestamp": 1530813637414, + "version": "0.6" + }, + "glob2-0.6-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "fc5c6a35fc05979d729191fb2f1366b2", + "name": "glob2", + "sha256": "1ff0a8fc0083c82f506f6ba081d035f2901db9040fb9482058a317b408fedc8f", + "size": 17971, + "subdir": "linux-64", + "timestamp": 1538518986058, + "version": "0.6" + }, + "glob2-0.6-py36he249c77_0.conda": { + "build": "py36he249c77_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ba1a15edf9232640e3f43eb82e779827", + "name": "glob2", + "sha256": "542b8514612febf289331ea887efb283f43f61d83c5d31ce5fec640eda12351e", + "size": 17677, + "subdir": "linux-64", + "timestamp": 1511295001725, + "version": "0.6" + }, + "glob2-0.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f20128e00d231c576e1ca377ac24978f", + "name": "glob2", + "sha256": "e1c1ae61fef70c614649acd75eb6a878abc0cae8aa6ca42406e6372f09b01762", + "size": 17355, + "subdir": "linux-64", + "timestamp": 1530813590386, + "version": "0.6" + }, + "glob2-0.6-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b2cf6d9e7530312934a2ac4d2969aed9", + "name": "glob2", + "sha256": "8bed527d0ee24fc8fe5c67122af2bb2d0b14e7056f82f92bc822da4b82ef90b1", + "size": 17951, + "subdir": "linux-64", + "timestamp": 1538518971046, + "version": "0.6" + }, + "glog-0.3.5-hf484d3e_1.conda": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "gflags >=2.2.1,<2.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD", + "md5": "dfd3100cdb2be7c5307b35776ab41ee5", + "name": "glog", + "sha256": "508090e30007dc796c157c938e29f51dc983ca91945f48189bec1d1343a1d758", + "size": 141782, + "subdir": "linux-64", + "timestamp": 1512765467074, + "version": "0.3.5" + }, + "glog-0.4.0-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "gflags >=2.2.2,<2.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "md5": "eb355e0640f0e3868b2470f5536834fd", + "name": "glog", + "sha256": "0260657bcd436dfa24cc582e572bff3a5e8dbc7b823e0fc80a55e289c7900866", + "size": 125582, + "subdir": "linux-64", + "timestamp": 1567108316306, + "version": "0.4.0" + }, + "glog-0.5.0-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "gflags >=2.2.2,<2.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "md5": "550f29b120f518aa7397cab05f55d416", + "name": "glog", + "sha256": "58984e4e178603984b2e5b5e3197b7a37d40d994fa8a76320dbcc7c5944e73d1", + "size": 102941, + "subdir": "linux-64", + "timestamp": 1620732909459, + "version": "0.5.0" + }, + "glpk-4.65-h276157c_3.conda": { + "build": "h276157c_3", + "build_number": 3, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=11.2.0" + ], + "license": "GPL3", + "md5": "b34dda7af54ce0a424dba44046b9d03f", + "name": "glpk", + "sha256": "8929d938887dd20db28ce0c75eef9472dd6c32cd7338febd53f0c4c33c615b1b", + "size": 759226, + "subdir": "linux-64", + "timestamp": 1656071603169, + "version": "4.65" + }, + "glpk-4.65-h3ceedfd_1.conda": { + "build": "h3ceedfd_1", + "build_number": 1, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0" + ], + "license": "GPL3", + "md5": "80d788a9e18d92a0b6f97c98aa935fb9", + "name": "glpk", + "sha256": "be8d87c262718ddc8b950ba682b4971fcadc48fb83bebd9ef578bf1f921d5e87", + "size": 762021, + "subdir": "linux-64", + "timestamp": 1528734837924, + "version": "4.65" + }, + "glpk-4.65-h3ceedfd_2.conda": { + "build": "h3ceedfd_2", + "build_number": 2, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0" + ], + "license": "GPL3", + "md5": "4bb99afd530896cba7d945b09351e8c5", + "name": "glpk", + "sha256": "3644b07fc5779b139af23673a12f1bd6fe027e46bde7d41cad8af798d039cfab", + "size": 762205, + "subdir": "linux-64", + "timestamp": 1528987054732, + "version": "4.65" + }, + "glue-core-0.12.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=2.7,<2.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "1ecb54b1903478d239750cddae7e575b", + "name": "glue-core", + "sha256": "f59aab780dae06cd114864ea180b91096cabb74f1cfdc03c6fed1f4ca2b2cc88", + "size": 1173779, + "subdir": "linux-64", + "timestamp": 1522703248244, + "version": "0.12.0" + }, + "glue-core-0.12.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=3.5,<3.6.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "876a7d9bf33ffe2ec2d0da1b13ca6f52", + "name": "glue-core", + "sha256": "887f5c510cf9292e21e7b026362816ba6882a38c7ec039b2015b15b6eb9cd593", + "size": 1198138, + "subdir": "linux-64", + "timestamp": 1522703274328, + "version": "0.12.0" + }, + "glue-core-0.12.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "f7d89bd98e8e5fb0923c22edfa3bbfd8", + "name": "glue-core", + "sha256": "ca9b28f3547d0b4842d3f5dcad0432aedac9312d97ff9f7938ecbec450c344b2", + "size": 1185162, + "subdir": "linux-64", + "timestamp": 1522703290976, + "version": "0.12.0" + }, + "glue-core-0.12.3-py27hb826bfd_0.conda": { + "build": "py27hb826bfd_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=2.7,<2.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "93b219373aac90db175b56c8d34b9b51", + "name": "glue-core", + "sha256": "0599be07a35b189d86ab7e32817def1ed0329724e835a1366e2c74f5f9d8b24d", + "size": 1175127, + "subdir": "linux-64", + "timestamp": 1511759474214, + "version": "0.12.3" + }, + "glue-core-0.12.3-py35h70c2699_0.conda": { + "build": "py35h70c2699_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=3.5,<3.6.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "1f555ae717fae39983c4cfff99cc9342", + "name": "glue-core", + "sha256": "0d1014570149fae28b784af53bbf4da6dbeb905b3c2de74822d2e609cdc3e0b6", + "size": 1199825, + "subdir": "linux-64", + "timestamp": 1511759515008, + "version": "0.12.3" + }, + "glue-core-0.12.3-py36h15cce50_0.conda": { + "build": "py36h15cce50_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "d356b1e437a5c4f64fc723dd15baad18", + "name": "glue-core", + "sha256": "26bf4cbac8274cd190198cbd2f9613946222844b4f6f94bc82d83bef8d5a070e", + "size": 1186301, + "subdir": "linux-64", + "timestamp": 1511759538905, + "version": "0.12.3" + }, + "glue-core-0.12.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=2.7,<2.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "6ceeba5c9f70e967a9d61b85c5af85c7", + "name": "glue-core", + "sha256": "86a61059c227a54c5ade284788a834da39c7c774407a89ceafa1c6788b375969", + "size": 1168660, + "subdir": "linux-64", + "timestamp": 1519756612327, + "version": "0.12.4" + }, + "glue-core-0.12.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=3.5,<3.6.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "5397a5b8facc76dc15ff35b464a10026", + "name": "glue-core", + "sha256": "66f34a678f594d773255c3f5c92a6b6f07461f6d5d372be00c10471b6a40fe24", + "size": 1200028, + "subdir": "linux-64", + "timestamp": 1519756731745, + "version": "0.12.4" + }, + "glue-core-0.12.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "60fd43d654c60383c40c8d0192074a43", + "name": "glue-core", + "sha256": "634df2305f84c97b290ccd9713fb1e78f4448207fa3e07c937eaa3d2b258e97b", + "size": 1185664, + "subdir": "linux-64", + "timestamp": 1519756716484, + "version": "0.12.4" + }, + "glue-core-0.12.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=2.7,<2.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "4e89aeecd10289f985129e7599d6bf17", + "name": "glue-core", + "sha256": "5b199ac7f93b6f166ac01382603b97d307c394aa70e5563aba70f4a0833c4cb2", + "size": 1174094, + "subdir": "linux-64", + "timestamp": 1525089841539, + "version": "0.12.5" + }, + "glue-core-0.12.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=3.5,<3.6.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "dce180d0e8f4b7308960768a51a5651a", + "name": "glue-core", + "sha256": "ce4c9c14fa1d7f3df04b0d1a12bc96e5523bdb4243a7052d59363c7d8316eb14", + "size": 1206162, + "subdir": "linux-64", + "timestamp": 1525089878044, + "version": "0.12.5" + }, + "glue-core-0.12.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=1.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt 4.11.*|5.6.*", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "024331dc5bf2581cf05438eeaaec3138", + "name": "glue-core", + "sha256": "d436dede0364647e85af82355450e99261fae4a93ec32f7545209b60f03b4650", + "size": 1191052, + "subdir": "linux-64", + "timestamp": 1525089854298, + "version": "0.12.5" + }, + "glue-core-0.13.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.3", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=2.7,<2.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "7f3297b520685924da361650104a23c9", + "name": "glue-core", + "sha256": "c7fe98c36115f01a946ecdac0b3973d373f1296232409e7ea38f4a652dbfa75c", + "size": 1302355, + "subdir": "linux-64", + "timestamp": 1526243307700, + "version": "0.13.3" + }, + "glue-core-0.13.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.3", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=3.5,<3.6.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "f40fde494daf1d0fa64d0d088d784a75", + "name": "glue-core", + "sha256": "fffbdb365b13ccf54e40dd0d4ceb9f28eb59947e078d68abbb647a4a5dd113a2", + "size": 1338051, + "subdir": "linux-64", + "timestamp": 1526243348548, + "version": "0.13.3" + }, + "glue-core-0.13.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.3", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "042dda73b69b94c1630c5e732784bbb7", + "name": "glue-core", + "sha256": "52ce4f9fbfed108c32767fb40d1b424c21b87604d34fc48d4011e53435be8df4", + "size": 1320493, + "subdir": "linux-64", + "timestamp": 1526243331796, + "version": "0.13.3" + }, + "glue-core-0.13.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astropy >=1.3", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.3", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "d113b61d24ef98d7329fa66c3cd6e7bc", + "name": "glue-core", + "sha256": "83586696142d7e504e19d806b4b3d956fbcf1083f62048b26e75ba0fe084d2eb", + "size": 1322796, + "subdir": "linux-64", + "timestamp": 1530891636845, + "version": "0.13.3" + }, + "glue-core-0.13.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.3", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=2.7,<2.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "fb4f9ee393c801aa02008765cd2f8e7b", + "name": "glue-core", + "sha256": "3691ac708d42f1b0ba3f15f06b60a314b8a63d9afff1d5e4b55f5bbc91862a0d", + "size": 1308509, + "subdir": "linux-64", + "timestamp": 1540971381756, + "version": "0.13.4" + }, + "glue-core-0.13.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.3", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "ac7175809db63c262049ba059d453ea0", + "name": "glue-core", + "sha256": "9bdcd0f84f7157b8f08d041247d1ca6597187d339b4cef17e774ef15929562f6", + "size": 1330001, + "subdir": "linux-64", + "timestamp": 1540971520669, + "version": "0.13.4" + }, + "glue-core-0.13.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.3", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "6c47a4ea1c0b42210ba0b5450b6c4b7c", + "name": "glue-core", + "sha256": "dd310aaae8a6cf2bfe35df5b5fde2d8612cf173b3b402e77ff852b8177fdbcc3", + "size": 1321981, + "subdir": "linux-64", + "timestamp": 1540971454680, + "version": "0.13.4" + }, + "glue-core-0.14.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=2.7,<2.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "db54bf49d9cd8114fd4d21155539c6a7", + "name": "glue-core", + "sha256": "82c0effcc49e97e5be3dd493adb3e3ac288ad0c5dff11a597b8d4bfab65a5b42", + "size": 1352165, + "subdir": "linux-64", + "timestamp": 1545093378889, + "version": "0.14.1" + }, + "glue-core-0.14.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "0c30affd938104700b7f94448ca06e7e", + "name": "glue-core", + "sha256": "95a811882909241c84f0b51b47ba7359ee01dc0b0e30215f793258e0723e7b2e", + "size": 1379267, + "subdir": "linux-64", + "timestamp": 1545093404118, + "version": "0.14.1" + }, + "glue-core-0.14.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.7,<3.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "880c2a669df889c7ebf3c25c2fdc7545", + "name": "glue-core", + "sha256": "1018df34d5bb24f78c0baeec5f722069fd7a8bace1e89e8e272a5cf20ecc6e1d", + "size": 1378097, + "subdir": "linux-64", + "timestamp": 1545093501627, + "version": "0.14.1" + }, + "glue-core-0.14.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=2.7,<2.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "66a93fd4f248f124a329ed03ad1d8807", + "name": "glue-core", + "sha256": "2af14bfe3bd71d766448cfbae55f6a8073c9aabb7955177af9cff0a32bd52a05", + "size": 1358722, + "subdir": "linux-64", + "timestamp": 1556066472588, + "version": "0.14.2" + }, + "glue-core-0.14.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "69b2b8cfa4e399f2d17eb0a9f30f30c9", + "name": "glue-core", + "sha256": "dc7fe2fd6fa032bf2a6e6b3e851f1eb7ea55c876b03972ebe9f97844d091fe0f", + "size": 1376980, + "subdir": "linux-64", + "timestamp": 1556066475993, + "version": "0.14.2" + }, + "glue-core-0.14.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.7,<3.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "b007c30ea7d97ce990b00faf504205a0", + "name": "glue-core", + "sha256": "b9938454694c104c84b1ae2abf0f0f29119c014f2c6b83e3822dd7d59126750b", + "size": 1383080, + "subdir": "linux-64", + "timestamp": 1556066430535, + "version": "0.14.2" + }, + "glue-core-0.15.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=2.7,<2.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "aff99ff227634a7de5862b0b5a41f035", + "name": "glue-core", + "sha256": "86a60aa67649c92e7d842d1a5a4355ce660cec27aa8efb549f9601774ae01048", + "size": 1605146, + "subdir": "linux-64", + "timestamp": 1568317227045, + "version": "0.15.6" + }, + "glue-core-0.15.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "1469aa8bb293f0898c6b22645600601f", + "name": "glue-core", + "sha256": "8563c0d0afcc052d43e3c0087944f156a254410f661416404e606d1add3a9a94", + "size": 1624617, + "subdir": "linux-64", + "timestamp": 1568317057276, + "version": "0.15.6" + }, + "glue-core-0.15.6-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=3.6,<3.7.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "f3c4448732d497d5f24274b3634af064", + "name": "glue-core", + "sha256": "b921f5c41c81ff022a67650613f2af6d24f32c8bcde79668f0b4325ffe0f1e1f", + "size": 1623554, + "subdir": "linux-64", + "timestamp": 1614166769404, + "version": "0.15.6" + }, + "glue-core-0.15.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.7,<3.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "d58e51cca6a290931be2ca577bf109e1", + "name": "glue-core", + "sha256": "2450c9006a722c025a4d776398940e3bfe7f0af88942aa45e33dd7395e251f43", + "size": 1622748, + "subdir": "linux-64", + "timestamp": 1568317125094, + "version": "0.15.6" + }, + "glue-core-0.15.6-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "4db78aea27de54746d7593f26ef5de39", + "name": "glue-core", + "sha256": "bcb6cbc64fc52b69e7de384a79b63442655090c9ca371994f0f870ceb46aa266", + "size": 1623797, + "subdir": "linux-64", + "timestamp": 1614166771042, + "version": "0.15.6" + }, + "glue-core-0.15.6-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.8,<3.9.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "690a49b53d4e57b927ae11e42be3e763", + "name": "glue-core", + "sha256": "739f3e4fc1347a866bf3228ac806d7dd5308f476d26df76656f54608e343d686", + "size": 1627595, + "subdir": "linux-64", + "timestamp": 1592221721999, + "version": "0.15.6" + }, + "glue-core-0.15.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=3.8,<3.9.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "e375723ce586acbea788514c6b5fb1ad", + "name": "glue-core", + "sha256": "0ef7aac6691efd3139d2a3aa8d98b067180b9005c73cce89ef550163c437878e", + "size": 1630832, + "subdir": "linux-64", + "timestamp": 1614166760683, + "version": "0.15.6" + }, + "glue-core-0.15.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=2.0", + "bottleneck >=1.2", + "dask", + "dill >=0.2", + "h5py >=2.4", + "ipykernel", + "ipython >=4.0", + "matplotlib >=2.0", + "mpl-scatter-density >=0.4", + "numpy >=1.9", + "pandas >=0.14", + "plotly", + "pyqt >=5.6,<6.0a0", + "python >=3.9,<3.10.0a0", + "qtconsole", + "qtpy >=1.2", + "scikit-image", + "scipy", + "setuptools >=1.0", + "xlrd >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "e3e8fc12ce174d1f1b7294fbae18340f", + "name": "glue-core", + "sha256": "48a82180eeaaf8900510a7490d720fa0816994ab8c4f4d6ce93e7836393b36f0", + "size": 1617689, + "subdir": "linux-64", + "timestamp": 1614166447511, + "version": "0.15.6" + }, + "glue-core-1.0.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "astropy >=4.0", + "bottleneck >=1.2", + "dill >=0.2", + "echo >=0.5", + "h5py >=2.10", + "ipykernel >=4.0,!=5.0.0,!=5.1.0", + "ipython >=4.0", + "jupyter_client <7", + "matplotlib >=3.2", + "mpl-scatter-density >=0.7", + "numpy >=1.16", + "pandas >=1.0", + "pillow !=7.1.0", + "plotly", + "python >=3.10,<3.11.0a0", + "qtconsole >=4.3", + "qtpy >=1.9", + "scikit-image", + "scipy >=1.0", + "setuptools >=30.3.0", + "xlrd >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3afe47674da556f5ca79eae99d3fc2e1", + "name": "glue-core", + "sha256": "5fd7bc812041a66a7c93cb89a9c5b9733a25bcd4de5432aaf7dfb6d365a221e9", + "size": 1663658, + "subdir": "linux-64", + "timestamp": 1643117372511, + "version": "1.0.1" + }, + "glue-core-1.0.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astropy >=4.0", + "bottleneck >=1.2", + "dill >=0.2", + "echo >=0.5", + "h5py >=2.10", + "ipykernel >=4.0,!=5.0.0,!=5.1.0", + "ipython >=4.0", + "jupyter_client <7", + "matplotlib >=3.2", + "mpl-scatter-density >=0.7", + "numpy >=1.16", + "pandas >=1.0", + "pillow !=7.1.0", + "plotly", + "python >=3.9,<3.10.0a0", + "qtconsole >=4.3", + "qtpy >=1.9", + "scikit-image", + "scipy >=1.0", + "setuptools >=30.3.0", + "xlrd >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "08867e17837815a6a3131788825b743f", + "name": "glue-core", + "sha256": "4b69b1af88a633c86d2565daf389eb529dca3af1128e5ce802fa7d4a6f6ac237", + "size": 1651765, + "subdir": "linux-64", + "timestamp": 1625832703270, + "version": "1.0.1" + }, + "glue-core-1.2.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "dill >=0.2", + "echo >=0.5", + "h5py >=2.10", + "ipykernel >=4.0,!=5.0.0,!=5.1.0", + "ipython >=4.0", + "matplotlib-base >=3.2", + "mpl-scatter-density >=0.7", + "numpy >=1.17", + "openpyxl >=3.0", + "pandas >=1.2", + "pillow !=7.1.0", + "plotly", + "python >=3.10,<3.11.0a0", + "qtconsole >=4.3", + "qtpy >=1.9", + "scikit-image", + "scipy >=1.1", + "setuptools >=30.3.0", + "xlrd >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c95923611bb2e3529ee8ed5bfa45ff44", + "name": "glue-core", + "sha256": "d319156ae9950e0f093ac77be817944ee7d8e05cdbc51feb9310ae7d3619946c", + "size": 1666512, + "subdir": "linux-64", + "timestamp": 1665682408431, + "version": "1.2.4" + }, + "glue-core-1.2.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "dill >=0.2", + "echo >=0.5", + "h5py >=2.10", + "ipykernel >=4.0,!=5.0.0,!=5.1.0", + "ipython >=4.0", + "matplotlib-base >=3.2", + "mpl-scatter-density >=0.7", + "numpy >=1.17", + "openpyxl >=3.0", + "pandas >=1.2", + "pillow !=7.1.0", + "plotly", + "python >=3.11,<3.12.0a0", + "qtconsole >=4.3", + "qtpy >=1.9", + "scikit-image", + "scipy >=1.1", + "setuptools >=30.3.0", + "xlrd >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1179eced096bd64c3a5dca162eed804a", + "name": "glue-core", + "sha256": "db35ed60f47c507cf2aa8d0a7056f23e3338fb09e3716db6b3069845ac6be765", + "size": 2015096, + "subdir": "linux-64", + "timestamp": 1676844178119, + "version": "1.2.4" + }, + "glue-core-1.2.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "dill >=0.2", + "echo >=0.5", + "h5py >=2.10", + "ipykernel >=4.0,!=5.0.0,!=5.1.0", + "ipython >=4.0", + "matplotlib-base >=3.2", + "mpl-scatter-density >=0.7", + "numpy >=1.17", + "openpyxl >=3.0", + "pandas >=1.2", + "pillow !=7.1.0", + "plotly", + "python >=3.7,<3.8.0a0", + "qtconsole >=4.3", + "qtpy >=1.9", + "scikit-image", + "scipy >=1.1", + "setuptools >=30.3.0", + "xlrd >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "051baa83ca512cf07c5f79c361774235", + "name": "glue-core", + "sha256": "ac8ebace5dba3e9a04b97682b078b647ecfdba91901c3166d7ebe124bf2f9714", + "size": 1647619, + "subdir": "linux-64", + "timestamp": 1665682317795, + "version": "1.2.4" + }, + "glue-core-1.2.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "dill >=0.2", + "echo >=0.5", + "h5py >=2.10", + "ipykernel >=4.0,!=5.0.0,!=5.1.0", + "ipython >=4.0", + "matplotlib-base >=3.2", + "mpl-scatter-density >=0.7", + "numpy >=1.17", + "openpyxl >=3.0", + "pandas >=1.2", + "pillow !=7.1.0", + "plotly", + "python >=3.8,<3.9.0a0", + "qtconsole >=4.3", + "qtpy >=1.9", + "scikit-image", + "scipy >=1.1", + "setuptools >=30.3.0", + "xlrd >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4a2415e406ff284a30ac0243db0d2383", + "name": "glue-core", + "sha256": "dd6de1acdaf85077c4d29ac805ba1a5a79a524c86586739258fa6be98bc585e1", + "size": 1653234, + "subdir": "linux-64", + "timestamp": 1665682127009, + "version": "1.2.4" + }, + "glue-core-1.2.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "dill >=0.2", + "echo >=0.5", + "h5py >=2.10", + "ipykernel >=4.0,!=5.0.0,!=5.1.0", + "ipython >=4.0", + "matplotlib-base >=3.2", + "mpl-scatter-density >=0.7", + "numpy >=1.17", + "openpyxl >=3.0", + "pandas >=1.2", + "pillow !=7.1.0", + "plotly", + "python >=3.9,<3.10.0a0", + "qtconsole >=4.3", + "qtpy >=1.9", + "scikit-image", + "scipy >=1.1", + "setuptools >=30.3.0", + "xlrd >=1.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3ccb6d1a129babb7a84809899da34c19", + "name": "glue-core", + "sha256": "07509673539e26b81ab99b3979dcbd74c7f93d18790354ad012bab3d69661963", + "size": 1655393, + "subdir": "linux-64", + "timestamp": 1665682224287, + "version": "1.2.4" + }, + "glue-vispy-viewers-0.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.13", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt >=5.6,<6.0a0", + "python >=2.7,<2.8.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "a63120328ad60a3faab75cfad99bfa9e", + "name": "glue-vispy-viewers", + "sha256": "63b8494f60385b26a821416e1e184a17800ace4304d030c962d0246b6116cf73", + "size": 1047431, + "subdir": "linux-64", + "timestamp": 1526244828860, + "version": "0.10" + }, + "glue-vispy-viewers-0.10-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.13", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt >=5.6,<6.0a0", + "python >=3.5,<3.6.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "28e5a57e3f56c5e72bb7f9823e5797d3", + "name": "glue-vispy-viewers", + "sha256": "334226ed1d1c63dc1f88fd5f7ca1fbd282567ed1818e31c087565ea32bb4f590", + "size": 1076083, + "subdir": "linux-64", + "timestamp": 1526244694070, + "version": "0.10" + }, + "glue-vispy-viewers-0.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.13", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt >=5.6,<6.0a0", + "python >=3.6,<3.7.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "6dcfee608239bbaa5233790942d4f87f", + "name": "glue-vispy-viewers", + "sha256": "b3b192c86605d1b6ff871558250f2dbfa72912b6278f2906755a3001f5e64e37", + "size": 1066084, + "subdir": "linux-64", + "timestamp": 1526244235294, + "version": "0.10" + }, + "glue-vispy-viewers-0.10-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.13", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "f80e11e45ff764485f3856c8361a00b3", + "name": "glue-vispy-viewers", + "sha256": "96100f80332f36703f32c346b394575a937b35ea34326a834391c822ec9e2836", + "size": 1053278, + "subdir": "linux-64", + "timestamp": 1530892199866, + "version": "0.10" + }, + "glue-vispy-viewers-0.9-py27ha2d5490_0.conda": { + "build": "py27ha2d5490_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.12", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt 4.11.*|5.6.*", + "python >=2.7,<2.8.0a0", + "qtpy" + ], + "license": "BSD 3-Clause", + "md5": "3ca04895f8f94e70217d79c2649bbb9e", + "name": "glue-vispy-viewers", + "sha256": "8b741a4f7654fb90ac9aca49c564e8fcb7865faf098882e6344a2b992ec71d94", + "size": 1050677, + "subdir": "linux-64", + "timestamp": 1511802346267, + "version": "0.9" + }, + "glue-vispy-viewers-0.9-py35h69f1dd5_0.conda": { + "build": "py35h69f1dd5_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.12", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt 4.11.*|5.6.*", + "python >=3.5,<3.6.0a0", + "qtpy" + ], + "license": "BSD 3-Clause", + "md5": "9362d305b65c87c828d904aa2bdd111b", + "name": "glue-vispy-viewers", + "sha256": "00d467a75bcf9070da6e637cda79a473a9ba999e7701670d40f04f73b0955610", + "size": 1066039, + "subdir": "linux-64", + "timestamp": 1511802363570, + "version": "0.9" + }, + "glue-vispy-viewers-0.9-py36h491feeb_0.conda": { + "build": "py36h491feeb_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.12", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt 4.11.*|5.6.*", + "python >=3.6,<3.7.0a0", + "qtpy" + ], + "license": "BSD 3-Clause", + "md5": "a45aea1143af710df1b98ec0604344fb", + "name": "glue-vispy-viewers", + "sha256": "bb010f72945cde204a360d308cdffd5c947460ca2234ccb2f49b322c80dda8bf", + "size": 1069049, + "subdir": "linux-64", + "timestamp": 1511802368274, + "version": "0.9" + }, + "glue-vispy-viewers-0.9.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.12", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt 4.11.*|5.6.*", + "python >=2.7,<2.8.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "70654615bcd420d25863070883ea64d0", + "name": "glue-vispy-viewers", + "sha256": "a87d233a14527cd99ebc17d401ff213d03c82d62c7a454e71c0c13c95821ac90", + "size": 1061638, + "subdir": "linux-64", + "timestamp": 1519757083637, + "version": "0.9.1" + }, + "glue-vispy-viewers-0.9.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.12", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt 4.11.*|5.6.*", + "python >=3.5,<3.6.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "ff2cc8136eeaebc8b3ff723bebccefd0", + "name": "glue-vispy-viewers", + "sha256": "6b4100fac41b3098b54192d17aa1229df57e919c83595df1f28eb81829f7ae07", + "size": 1066617, + "subdir": "linux-64", + "timestamp": 1519757455183, + "version": "0.9.1" + }, + "glue-vispy-viewers-0.9.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.12", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt 4.11.*|5.6.*", + "python >=3.6,<3.7.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "f7535774cc4ea4776eca6966a2254097", + "name": "glue-vispy-viewers", + "sha256": "f60c81ceadc7e67b57f5cba29da4908749b2932d347407fc325e8bcec3e7277d", + "size": 1068932, + "subdir": "linux-64", + "timestamp": 1519757420870, + "version": "0.9.1" + }, + "glue-vispy-viewers-0.9.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.12", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt 4.11.*|5.6.*", + "python >=2.7,<2.8.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "675c58d98c1f596a430e5235a3961369", + "name": "glue-vispy-viewers", + "sha256": "6d7ebaf54e2a3121173f0026f85919e3e4b8045c3043b04462d5a927a90e9483", + "size": 1061819, + "subdir": "linux-64", + "timestamp": 1522705765256, + "version": "0.9.2" + }, + "glue-vispy-viewers-0.9.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.12", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt 4.11.*|5.6.*", + "python >=3.5,<3.6.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "17244e70263334e05793fce91e8d6b74", + "name": "glue-vispy-viewers", + "sha256": "17e7e8913ca59cbd165982a53a94c98f23fb90f8deeaa9f9eaba202752752eb7", + "size": 1078349, + "subdir": "linux-64", + "timestamp": 1522706173760, + "version": "0.9.2" + }, + "glue-vispy-viewers-0.9.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astropy >=1.1", + "glue-core >=0.12", + "matplotlib", + "numpy >=1.9", + "pyopengl", + "pyqt 4.11.*|5.6.*", + "python >=3.6,<3.7.0a0", + "qtpy", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "ff1378617f2a48b38a1d4940841a0f9d", + "name": "glue-vispy-viewers", + "sha256": "6a94c5e2b905248bee410d1ec0d73aa584c17fc3a348400d86e116e5d965d2ea", + "size": 1068815, + "subdir": "linux-64", + "timestamp": 1522706131799, + "version": "0.9.2" + }, + "glue-vispy-viewers-1.0.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "glue-core >=1.0", + "matplotlib-base", + "numpy", + "pillow", + "pyopengl", + "pyqt >=5.9,<6.0a0", + "python >=3.10,<3.11.0a0", + "qtpy", + "scipy", + "vispy >=0.6" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b4a872bc2f6fb4ff932242f8cb551dec", + "name": "glue-vispy-viewers", + "sha256": "915c585d313afdc96bf87d57ddda93f5325e0c003fd8f879170004c527cdbd3d", + "size": 155477, + "subdir": "linux-64", + "timestamp": 1669917258365, + "version": "1.0.5" + }, + "glue-vispy-viewers-1.0.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "glue-core >=1.0", + "matplotlib-base", + "numpy", + "pillow", + "pyopengl", + "pyqt >=5.9,<6.0a0", + "python >=3.11,<3.12.0a0", + "qtpy", + "scipy", + "vispy >=0.6" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "0be639947e4e392b04f918306ff4ccf0", + "name": "glue-vispy-viewers", + "sha256": "90003930bf4a5a25e70143f0eabaf492e97d05dd76ebadb91aa70da8176725b9", + "size": 186597, + "subdir": "linux-64", + "timestamp": 1676852595198, + "version": "1.0.5" + }, + "glue-vispy-viewers-1.0.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "glue-core >=1.0", + "matplotlib-base", + "numpy", + "pillow", + "pyopengl", + "pyqt >=5.9,<6.0a0", + "python >=3.7,<3.8.0a0", + "qtpy", + "scipy", + "vispy >=0.6" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "306c6b83f23576309018ca0c890a0091", + "name": "glue-vispy-viewers", + "sha256": "0c5dee3011660fb1188c9ddb49d0d2c5d7c86356b959069b76e85c8abfd324df", + "size": 153591, + "subdir": "linux-64", + "timestamp": 1669917191427, + "version": "1.0.5" + }, + "glue-vispy-viewers-1.0.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "glue-core >=1.0", + "matplotlib-base", + "numpy", + "pillow", + "pyopengl", + "pyqt >=5.9,<6.0a0", + "python >=3.8,<3.9.0a0", + "qtpy", + "scipy", + "vispy >=0.6" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ea1a0052bbd55fa877710ce62d93d44e", + "name": "glue-vispy-viewers", + "sha256": "085cecd00ef75025108dfe3be40a0116911e5fb6cc826d23c0f70644f9c672bf", + "size": 154549, + "subdir": "linux-64", + "timestamp": 1669917326921, + "version": "1.0.5" + }, + "glue-vispy-viewers-1.0.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "astropy >=4.0", + "glue-core >=1.0", + "matplotlib-base", + "numpy", + "pillow", + "pyopengl", + "pyqt >=5.9,<6.0a0", + "python >=3.9,<3.10.0a0", + "qtpy", + "scipy", + "vispy >=0.6" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a941c6426932bf1f8ee892d7b3db21f9", + "name": "glue-vispy-viewers", + "sha256": "19b0cd28652796c93b268410af8145bbf64c0e799bc5e8234c2ef503b382b539", + "size": 154412, + "subdir": "linux-64", + "timestamp": 1669917112285, + "version": "1.0.5" + }, + "glueviz-0.12.0-ha37a3ef_0.conda": { + "app_entry": "glue", + "app_type": "desk", + "build": "ha37a3ef_0", + "build_number": 0, + "depends": [ + "glue-core >=0.12.0", + "glue-vispy-viewers >=0.9" + ], + "icon": "c124cb3a3bf9bb32f258a6e6f9b5c187.png", + "license": "BSD 3-Clause", + "md5": "7f51f4c4ef9502839fc967244cd64c8f", + "name": "glueviz", + "sha256": "1bcb7c0d728c14bc53d5d8573787a8b8ac32307ca0a5a740c8555d2fa7489dc4", + "size": 15390, + "subdir": "linux-64", + "summary": "Multi-dimensional linked data exploration", + "timestamp": 1511806296716, + "type": "app", + "version": "0.12.0" + }, + "glueviz-0.12.4-0.conda": { + "app_entry": "glue", + "app_type": "desk", + "build": "0", + "build_number": 0, + "depends": [ + "glue-core >=0.12.4", + "glue-vispy-viewers >=0.9.1" + ], + "icon": "c124cb3a3bf9bb32f258a6e6f9b5c187.png", + "license": "BSD 3-Clause", + "md5": "6bedc26db85e94af13b37b7e9206b55e", + "name": "glueviz", + "sha256": "09e665a904f8f10be0795e898e4c3e48b45535013243fed93e9b4d98509ee924", + "size": 15317, + "subdir": "linux-64", + "summary": "Multi-dimensional linked data exploration", + "timestamp": 1519757855077, + "type": "app", + "version": "0.12.4" + }, + "glueviz-0.13.3-0.conda": { + "app_entry": "glue", + "app_type": "desk", + "build": "0", + "build_number": 0, + "depends": [ + "glue-core >=0.13.3", + "glue-vispy-viewers >=0.10" + ], + "icon": "c124cb3a3bf9bb32f258a6e6f9b5c187.png", + "license": "BSD 3-Clause", + "md5": "7c077d833b0b7bc6d1e72e4eab61f0bd", + "name": "glueviz", + "sha256": "51b6077f55bcf52691a98d78ad5fa6968866167e10b1817ba309f6d96f956720", + "size": 15340, + "subdir": "linux-64", + "summary": "Multi-dimensional linked data exploration", + "timestamp": 1526246220910, + "type": "app", + "version": "0.13.3" + }, + "glueviz-0.15.2-0.conda": { + "app_entry": "glue", + "app_type": "desk", + "build": "0", + "build_number": 0, + "depends": [ + "glue-core >=0.15.3", + "glue-vispy-viewers >=0.12.2" + ], + "icon": "c124cb3a3bf9bb32f258a6e6f9b5c187.png", + "license": "BSD 3-Clause", + "md5": "2374a66495f2853f20f089edfdb74f77", + "name": "glueviz", + "sha256": "008672350f3313ec8ad3b2969df3da7711031d1312a23922e99abba4c2e2f59f", + "size": 23826, + "subdir": "linux-64", + "summary": "Multi-dimensional linked data exploration", + "timestamp": 1568318439164, + "type": "app", + "version": "0.15.2" + }, + "glueviz-0.15.2-h06a4308_0.conda": { + "app_entry": "glue", + "app_type": "desk", + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "glue-core >=0.15.3", + "glue-vispy-viewers >=0.12.2" + ], + "icon": "c124cb3a3bf9bb32f258a6e6f9b5c187.png", + "license": "BSD 3-Clause", + "md5": "0f05b2bc4e674faea4620c0fd89e565f", + "name": "glueviz", + "sha256": "d6debdd3d881b57899a84d04500da63e68e1e7e89db219388dde7d85fd61f6bf", + "size": 20849, + "subdir": "linux-64", + "summary": "Multi-dimensional linked data exploration", + "timestamp": 1643117856507, + "type": "app", + "version": "0.15.2" + }, + "glueviz-1.0.0-0.conda": { + "app_entry": "glue", + "app_type": "desk", + "build": "0", + "build_number": 0, + "depends": [ + "glue-core >=0.15.3", + "glue-vispy-viewers >=0.12.2" + ], + "icon": "c124cb3a3bf9bb32f258a6e6f9b5c187.png", + "license": "BSD 3-Clause", + "md5": "be0b78254df94a52a415072713cd6213", + "name": "glueviz", + "sha256": "db892d32f2ae1b0f7aa6536a9c947c717e7f374046ccee681d60f3e5cd12d27d", + "size": 17826, + "subdir": "linux-64", + "summary": "Multi-dimensional linked data exploration", + "timestamp": 1600379026461, + "type": "app", + "version": "1.0.0" + }, + "glueviz-1.2.4-h06a4308_0.conda": { + "app_entry": "glue", + "app_type": "desk", + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "glue-core 1.2.4", + "glue-vispy-viewers >=1.0.3" + ], + "icon": "c124cb3a3bf9bb32f258a6e6f9b5c187.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f17bae7ae5cf98c7a71c697462c0276e", + "name": "glueviz", + "sha256": "e2ece78d833268d91f6e3b7c1d20c6d83a81eb96aeeb6aef3077c62f150f22bf", + "size": 15191, + "subdir": "linux-64", + "summary": "Multi-dimensional linked data exploration", + "timestamp": 1670011307388, + "type": "app", + "version": "1.2.4" + }, + "gmock-1.11.0-hdb19cb5_0.conda": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "gtest 1.11.0 hdb19cb5_0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1fe28132b16c64a6687b8766ff933a24", + "name": "gmock", + "sha256": "96657f07b879a370ccf69cc2c58bf265a81d4eafd9a66d552a7b3d0c8d79e015", + "size": 137340, + "subdir": "linux-64", + "timestamp": 1658973578956, + "version": "1.11.0" + }, + "gmp-6.1.2-h6c8ec71_1.conda": { + "build": "h6c8ec71_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL 2 and LGPL 3", + "md5": "00620fd5552907fddda83ce4a11e5bac", + "name": "gmp", + "sha256": "c1f8ccf6ea60f02574c5f84b35f1f70b918c9bf828072f69b9ce4f6879b1fb8d", + "size": 526020, + "subdir": "linux-64", + "timestamp": 1510610105481, + "version": "6.1.2" + }, + "gmp-6.1.2-hb3b607b_0.conda": { + "build": "hb3b607b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL 2 and LGPL 3", + "md5": "fdc012ccf38d046934903fa433a5696b", + "name": "gmp", + "sha256": "ddec30e295e7c55db7728c13631f8311443f180f4b24bddc0cf4f14d970731c4", + "size": 520726, + "subdir": "linux-64", + "timestamp": 1505690005789, + "version": "6.1.2" + }, + "gmp-6.2.1-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-2.0-or-later AND LGPL-3.0-or-later", + "md5": "68b9fd1066fdb74b2f0601c045f3a0e9", + "name": "gmp", + "sha256": "0828476725bd679d6310a801996b968f98ea9daa77451bb18e9631638170e6a7", + "size": 554770, + "subdir": "linux-64", + "timestamp": 1612282186049, + "version": "6.2.1" + }, + "gmp-6.2.1-h2531618_2.conda": { + "build": "h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL 2 and LGPL 3", + "md5": "2e73d31066d9abc951ad4fe55e70cb98", + "name": "gmp", + "sha256": "8aff5ec4f1f6cade2b0663a261f58bd54672029c4a3651c89d34954bb2ea62f5", + "size": 552386, + "subdir": "linux-64", + "timestamp": 1612242995303, + "version": "6.2.1" + }, + "gmp-6.2.1-h295c915_3.conda": { + "build": "h295c915_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "GPL-2.0-or-later AND LGPL-3.0-or-later", + "md5": "045e9e85252d5efc8c09a136b4c2b3d4", + "name": "gmp", + "sha256": "e3797cbfa1cb235590989946e7a0535884aa14901810447e66da143cebc63c11", + "size": 556717, + "subdir": "linux-64", + "timestamp": 1653996358530, + "version": "6.2.1" + }, + "gmpy2-2.0.8-py27h10f8cd9_2.conda": { + "build": "py27h10f8cd9_2", + "build_number": 2, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "mpc", + "mpfr >=4.0.1,<5.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 3", + "md5": "61c10cde456541b93cc6499090d46695", + "name": "gmpy2", + "sha256": "ba6f6ba8031e01d324ba1f16e450e0fe65ad8c27f4a60b30e1c902a3c8d33a22", + "size": 155897, + "subdir": "linux-64", + "timestamp": 1530892340739, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py27h4cf3fa8_2.conda": { + "build": "py27h4cf3fa8_2", + "build_number": 2, + "depends": [ + "gmp", + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "mpc", + "mpfr 3.*", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 3", + "md5": "0147a261c07edeaba43960b00acef2a3", + "name": "gmpy2", + "sha256": "07dde75320deb275369a308c45c3722b6b5c2d4fc76ed270c7d47b9dbfe90e3e", + "size": 156045, + "subdir": "linux-64", + "timestamp": 1511294948101, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py27hc856308_1.conda": { + "build": "py27hc856308_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "mpc", + "mpfr 3.*", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 3", + "md5": "3a08a65f1ee0909d84b5bad3f8c61200", + "name": "gmpy2", + "sha256": "17d10b747aae4193faac0934e12673dfc7a6714144295bace2e14e44a6312520", + "size": 155394, + "subdir": "linux-64", + "timestamp": 1505743997451, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py310heeb90bb_3.conda": { + "build": "py310heeb90bb_3", + "build_number": 3, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.5.0", + "mpc", + "mpfr >=4.0.2,<5.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL 3", + "md5": "68c819240c5230cbd12af65dba7565c5", + "name": "gmpy2", + "sha256": "9054d36cc8788a8a311c5527d6779fb85ed46dcff069abc0266c0a5c6a568218", + "size": 420393, + "subdir": "linux-64", + "timestamp": 1643052589220, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py35h89a7545_1.conda": { + "build": "py35h89a7545_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "mpc", + "mpfr 3.*", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL 3", + "md5": "03eec11b298f6d203fbbb26dafc15659", + "name": "gmpy2", + "sha256": "da6b49658d2b34fcb7e7a481f2e75cd88d8875dfff95ee62a667a2ee75f74233", + "size": 152919, + "subdir": "linux-64", + "timestamp": 1505744025929, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py35hd0a1c9a_2.conda": { + "build": "py35hd0a1c9a_2", + "build_number": 2, + "depends": [ + "gmp", + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "mpc", + "mpfr 3.*", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL 3", + "md5": "cd251440385e2ee3f900d165a93e82a5", + "name": "gmpy2", + "sha256": "9bff526cdfffb59c2690d0e57d72a269868d1a55b874614bf66c044335204b32", + "size": 153576, + "subdir": "linux-64", + "timestamp": 1511294995399, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py36h10f8cd9_2.conda": { + "build": "py36h10f8cd9_2", + "build_number": 2, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "mpc", + "mpfr >=4.0.1,<5.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 3", + "md5": "a0780814750f513ca6d4cf2e73dd5741", + "name": "gmpy2", + "sha256": "c59577fb845bf8ec4e95d007551fc3c73476cb4839ba0f067baf3e59a0fcb6ec", + "size": 153313, + "subdir": "linux-64", + "timestamp": 1530892301647, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py36h55090d7_1.conda": { + "build": "py36h55090d7_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "mpc", + "mpfr 3.*", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 3", + "md5": "2ae8ed94da82b37b6da21b0cd55556c3", + "name": "gmpy2", + "sha256": "3353375617568d71dbf488a28409a830060b1104b9b02f15067065d190eefe96", + "size": 152806, + "subdir": "linux-64", + "timestamp": 1505744052326, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py36hc8893dd_2.conda": { + "build": "py36hc8893dd_2", + "build_number": 2, + "depends": [ + "gmp", + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "mpc", + "mpfr 3.*", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 3", + "md5": "409cb0b2b82bc13c47ac22ad1904ef5f", + "name": "gmpy2", + "sha256": "fa6f8f9d5dea0e918186ea026167e488595490bc1420b1fca440d419b07494fc", + "size": 153604, + "subdir": "linux-64", + "timestamp": 1511295011835, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py37h10f8cd9_2.conda": { + "build": "py37h10f8cd9_2", + "build_number": 2, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "mpc", + "mpfr >=4.0.1,<5.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 3", + "md5": "cc62b3fc5bf73f0f14ff68d6c730216f", + "name": "gmpy2", + "sha256": "b3c7622ed107f9ab287eb2d5e901f058217812ad7863a834d47d5284f51f2b17", + "size": 153253, + "subdir": "linux-64", + "timestamp": 1530892262558, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py38hd5f6e3b_3.conda": { + "build": "py38hd5f6e3b_3", + "build_number": 3, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "mpc", + "mpfr >=4.0.1,<5.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL 3", + "md5": "80aa1554d65abe39c01229f81626f3c9", + "name": "gmpy2", + "sha256": "b543b3bcc14ef2300f5e4c35633a4e4f276bb8ac404ca2653b0e89ad3ae389dd", + "size": 166035, + "subdir": "linux-64", + "timestamp": 1572880912253, + "version": "2.0.8" + }, + "gmpy2-2.0.8-py39h8083e48_3.conda": { + "build": "py39h8083e48_3", + "build_number": 3, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "mpc", + "mpfr >=4.0.2,<5.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL 3", + "md5": "ca272f98469f735694f860492f10412a", + "name": "gmpy2", + "sha256": "f8d0dcf5b8f2080ffee0437d92c4857d78964e95a5c85df7fd5872502205f7b1", + "size": 160931, + "subdir": "linux-64", + "timestamp": 1607571491123, + "version": "2.0.8" + }, + "gmpy2-2.1.2-py310heeb90bb_0.conda": { + "build": "py310heeb90bb_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.5.0", + "mpc", + "mpfr >=4.0.2,<5.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "669eccc196671c096319923ef299cd91", + "name": "gmpy2", + "sha256": "08e94122feaf6a78e201c94b69f729dda2b6fc53c720d22033bb2375da3fe841", + "size": 529902, + "subdir": "linux-64", + "timestamp": 1645455594626, + "version": "2.1.2" + }, + "gmpy2-2.1.2-py311hc9b5ff0_0.conda": { + "build": "py311hc9b5ff0_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=11.2.0", + "mpc", + "mpfr >=4.0.2,<5.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "82dd6df9c0c89d87d99cc40454d367e7", + "name": "gmpy2", + "sha256": "3e13101543cf1406799fff23b7b52ef821bfe87505fd0e7b871b3693863be5ba", + "size": 195547, + "subdir": "linux-64", + "timestamp": 1676839873370, + "version": "2.1.2" + }, + "gmpy2-2.1.2-py37heeb90bb_0.conda": { + "build": "py37heeb90bb_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.5.0", + "mpc", + "mpfr >=4.0.2,<5.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "2979d9fd55a702eeee8f9452b7298ad0", + "name": "gmpy2", + "sha256": "98dcb5a07b1b4c15b4033c37bad5fd1f005e608d86c222c6dc12112ae760056f", + "size": 192084, + "subdir": "linux-64", + "timestamp": 1645455579467, + "version": "2.1.2" + }, + "gmpy2-2.1.2-py38heeb90bb_0.conda": { + "build": "py38heeb90bb_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.5.0", + "mpc", + "mpfr >=4.0.2,<5.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "f62084e36c94b2f43de735b75e3d6ba1", + "name": "gmpy2", + "sha256": "93d8b267eaf0ced9b5f6ce68beddf502e0d99efb2252959a6b0cd7e812e15551", + "size": 195570, + "subdir": "linux-64", + "timestamp": 1645455581201, + "version": "2.1.2" + }, + "gmpy2-2.1.2-py39heeb90bb_0.conda": { + "build": "py39heeb90bb_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.5.0", + "mpc", + "mpfr >=4.0.2,<5.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "112b90ce5da4af34b7046f3057cc247e", + "name": "gmpy2", + "sha256": "b8f8ccd4c97481199c871226586f7b4280e0bff337f0ce892961d796d1259ce5", + "size": 196058, + "subdir": "linux-64", + "timestamp": 1645438799445, + "version": "2.1.2" + }, + "gn-0.0.20190712172645-he6710b0_2.conda": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7f9df91143a3daf9d0483a2a87e9e9dc", + "name": "gn", + "sha256": "2fd7a12eeb891e1297d6b2cd63284fa71fc2547f5e5fa9e7a05c676c5aff6afc", + "size": 752432, + "subdir": "linux-64", + "timestamp": 1591809863667, + "version": "0.0.20190712172645" + }, + "gn-0.0.20200720112859-hf484d3e_2.conda": { + "build": "hf484d3e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7b34cc8bffe65dbf8a2ce965e0226ea8", + "name": "gn", + "sha256": "7900cfeec7e31aaebe1a34f904fe8316e923342685b1cd4a568ed5f659bbda45", + "size": 958280, + "subdir": "linux-64", + "timestamp": 1596862074363, + "version": "0.0.20200720112859" + }, + "gn-0.0.20200909083119-h2531618_2.conda": { + "build": "h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2f4af9bde5ef625360044cf8905fbe48", + "name": "gn", + "sha256": "3ce9b4d8e3a3549485dfd71708d95a6fd523a7429deef95bdfceccb5779e2b8d", + "size": 982529, + "subdir": "linux-64", + "timestamp": 1605068825257, + "version": "0.0.20200909083119" + }, + "gnutls-3.6.15-he1e5248_0.conda": { + "build": "he1e5248_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "libidn2 >=2,<3.0a0", + "libstdcxx-ng >=7.3.0", + "libtasn1 >=4.16.0,<5.0a0", + "libunistring >=0,<1.0a0", + "nettle >=3.7.2,<3.8.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "de368b69defbce286b7cec43efbd4187", + "name": "gnutls", + "sha256": "b83d15a44abf3bb8bd4b9052b7287456975d0d650da99428fa4506675c98a28f", + "size": 1054747, + "subdir": "linux-64", + "timestamp": 1617814418590, + "version": "3.6.15" + }, + "gnutls-3.6.5-h71b1129_1002.conda": { + "build": "h71b1129_1002", + "build_number": 1002, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nettle >=3.4.1", + "nettle >=3.4.1,<3.5.0a0" + ], + "license": "LGPLv2.1", + "license_family": "LGPL", + "md5": "74ec746108824bb88dec27187b84108f", + "name": "gnutls", + "sha256": "46c3bcdde4fe6ec2781c1bcfa4cad0ac85aa347b5a6192a0f0b76adcab5870fe", + "size": 1712486, + "subdir": "linux-64", + "timestamp": 1587125136161, + "version": "3.6.5" + }, + "go-1.10.3-3.conda": { + "build": "3", + "build_number": 3, + "depends": [ + "go_linux-64 1.10.3 h0f5337a_3" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "c03a9b9a8d697c549b8da95321a3fa7c", + "name": "go", + "sha256": "6a014ba9011829fd8193e5de657e5bfedf841e0eb629ed29a404fc17ddef17d1", + "size": 7284, + "subdir": "linux-64", + "timestamp": 1537370191397, + "version": "1.10.3" + }, + "go-1.11.4-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "go_linux-64 1.11.4 h0f5337a_0" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "f9c3930694b7067ae95e71c1453ee6ad", + "name": "go", + "sha256": "3854746421f52e963d46803be56f44cebcf6a0e603670cff178ab0b7f7749757", + "size": 11454, + "subdir": "linux-64", + "timestamp": 1544962598792, + "version": "1.11.4" + }, + "go-1.16.5-h59941bc_0.conda": { + "build": "h59941bc_0", + "build_number": 0, + "constrains": [ + "gfortran_linux-64 9.3.*", + "gcc_linux-64 9.3.*", + "gxx_linux-64 9.3.*" + ], + "depends": [ + "_go_select ==2.3.0 cgo", + "libgcc-ng >=9.3.0", + "libgfortran-ng", + "libgfortran5 >=9.3.0", + "libstdcxx-ng >=9.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e413b131144245287e956496ed71074", + "name": "go", + "sha256": "4d3cd5adc72ff2ad3b517dc46b799cca3d6b22ab459c176b01f075fddbbf6402", + "size": 89891582, + "subdir": "linux-64", + "timestamp": 1623674097722, + "version": "1.16.5" + }, + "go-1.16.5-hb589e2e_0.conda": { + "build": "hb589e2e_0", + "build_number": 0, + "depends": [ + "_go_select ==2.2.0 nocgo" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "354468a4766494185af4a18003210df4", + "name": "go", + "sha256": "5c1c250049bc8f77edb6758d659bdd4c204a504ccf40a6efccb0ebaa3556ea76", + "size": 90134603, + "subdir": "linux-64", + "timestamp": 1623660026344, + "version": "1.16.5" + }, + "go-1.16.5-hfe6e22e_0.conda": { + "build": "hfe6e22e_0", + "build_number": 0, + "constrains": [ + "gxx_linux-64 8.4.*", + "gcc_linux-64 8.4.*", + "gfortran_linux-64 8.4.*" + ], + "depends": [ + "_go_select ==2.3.0 cgo", + "libgcc-ng >=8.4.0", + "libgfortran-ng", + "libgfortran5 >=8.4.0", + "libstdcxx-ng >=8.4.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a637542f3f82bf27532776856bbdc55e", + "name": "go", + "sha256": "17da21311d167293f9c7989ec97d2d7be1b3c2eb14274e0e5aec1da618ff28cf", + "size": 89317055, + "subdir": "linux-64", + "timestamp": 1623674057291, + "version": "1.16.5" + }, + "go-1.19.1-hb589e2e_0.conda": { + "build": "hb589e2e_0", + "build_number": 0, + "depends": [ + "_go_select ==2.2.0 nocgo" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5e0698959d383456e69c787671cf6e69", + "name": "go", + "sha256": "a9a1f029c3a9d2e60715e6351ec6bd450317238bdcc5ecaab2f7f5de08100bc2", + "size": 109935391, + "subdir": "linux-64", + "timestamp": 1665476726225, + "version": "1.19.1" + }, + "go-1.19.1-hcefc947_0.conda": { + "build": "hcefc947_0", + "build_number": 0, + "constrains": [ + "gxx_linux-64 11.2.0.*", + "gcc_linux-64 11.2.0.*", + "gfortran_linux-64 11.2.0.*" + ], + "depends": [ + "_go_select ==2.3.0 cgo", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4e74c388ae5649fddeb8f040f381e32b", + "name": "go", + "sha256": "76dd20f95acb380225d987d55b146779d835747a2c4e57ed0c9c668a7ea0e701", + "size": 110493223, + "subdir": "linux-64", + "timestamp": 1665477429097, + "version": "1.19.1" + }, + "go-1.19.3-hb589e2e_0.conda": { + "build": "hb589e2e_0", + "build_number": 0, + "depends": [ + "_go_select ==2.2.0 nocgo" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a97d812b20d2edcc29d8913c7365cc0d", + "name": "go", + "sha256": "b2e1614881409f9fc8e128fe30a848ab18623968bb22803f7d2e0dc2bd218be3", + "size": 137059995, + "subdir": "linux-64", + "timestamp": 1673315087267, + "version": "1.19.3" + }, + "go-1.19.3-hcefc947_0.conda": { + "build": "hcefc947_0", + "build_number": 0, + "constrains": [ + "gcc_linux-64 11.2.0.*", + "gfortran_linux-64 11.2.0.*", + "gxx_linux-64 11.2.0.*" + ], + "depends": [ + "_go_select ==2.3.0 cgo", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c986cf3a46efc377ad064af6d01443ed", + "name": "go", + "sha256": "82d22d7ebed5ac505728174c62e7ffb26000cebab4d4f97c0d5988a0e3bc7349", + "size": 137276399, + "subdir": "linux-64", + "timestamp": 1673315786898, + "version": "1.19.3" + }, + "go-cgo-1.16.5-h480a41b_0.conda": { + "build": "h480a41b_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 8.4.*", + "go 1.16.5 hfe6e22e_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "997c6bcbd05bb103686946b9ffaa3392", + "name": "go-cgo", + "sha256": "867f75935d61cb6e333ee60f0ee596b3bccfebd044ae8569a08bd0624ce56806", + "size": 32689, + "subdir": "linux-64", + "timestamp": 1623674158531, + "version": "1.16.5" + }, + "go-cgo-1.16.5-hd57fb8f_0.conda": { + "build": "hd57fb8f_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 9.3.*", + "go 1.16.5 h59941bc_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a99908b655c90cc719c036da5732325c", + "name": "go-cgo", + "sha256": "00d0d7cc75f1ce89699041db19fc941f68a6a41af4857bb33652d875e212d017", + "size": 32613, + "subdir": "linux-64", + "timestamp": 1623674203601, + "version": "1.16.5" + }, + "go-cgo-1.19.1-h043d29a_0.conda": { + "build": "h043d29a_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 11.2.0.*", + "go 1.19.1 hcefc947_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cbed00d0bb4840b45ff570c3003fde56", + "name": "go-cgo", + "sha256": "1d4c92ee6c602d86acbc75f691fbe71bc558e89865aa7fe426a326143941352d", + "size": 16697, + "subdir": "linux-64", + "timestamp": 1665477536085, + "version": "1.19.1" + }, + "go-cgo-1.19.3-h043d29a_0.conda": { + "build": "h043d29a_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 11.2.0.*", + "go 1.19.3 hcefc947_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e8cb2bc9467834df692392500f3fec4b", + "name": "go-cgo", + "sha256": "dec5ea7fc998983bea0830f1a37c8d3d5df9f3a0ce9103308cbceca1db2445be", + "size": 17420, + "subdir": "linux-64", + "timestamp": 1673315891152, + "version": "1.19.3" + }, + "go-cgo_linux-64-1.16.5-h833015d_0.conda": { + "build": "h833015d_0", + "build_number": 0, + "depends": [ + "_go_select ==2.3.0 cgo", + "go >=1.16.5,<1.16.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "06b7e0181370dc31e33bdbc9b77a15e3", + "name": "go-cgo_linux-64", + "sha256": "bf10269af3c50b3c26c352295f309b25ca318c2813de17b098257f4bc2cf373e", + "size": 33451, + "subdir": "linux-64", + "timestamp": 1623674206463, + "version": "1.16.5" + }, + "go-core-1.10.3-hf39692e_3.conda": { + "build": "hf39692e_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "3c72c11f9aae4f7e1ef8ced9387e35e5", + "name": "go-core", + "sha256": "8ca75ef25113bbf44b802fd483d2c237ee5106122583077aa91b11001932c5df", + "size": 53467548, + "subdir": "linux-64", + "timestamp": 1537370031018, + "version": "1.10.3" + }, + "go-core-1.11.4-hf39692e_0.conda": { + "build": "hf39692e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "1ef3b90909f7f91d18ed26b7f4205370", + "name": "go-core", + "sha256": "24db727dd9ba97dcd9506e30605efbddf890f86701f1e6c8f16e37a6a99b00e9", + "size": 86097575, + "subdir": "linux-64", + "timestamp": 1544962272460, + "version": "1.11.4" + }, + "go-nocgo-1.16.5-h94e987e_0.conda": { + "build": "h94e987e_0", + "build_number": 0, + "depends": [ + "go 1.16.5 hb589e2e_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "71fce11a5d466c8aad453beb5f895e3a", + "name": "go-nocgo", + "sha256": "c74d3c5720b48daff974d9fea102e348479794f085dd7b3b8442d30a89e39045", + "size": 32615, + "subdir": "linux-64", + "timestamp": 1623660122898, + "version": "1.16.5" + }, + "go-nocgo-1.19.1-hecb7f51_0.conda": { + "build": "hecb7f51_0", + "build_number": 0, + "depends": [ + "go 1.19.1 hb589e2e_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "604ab4e833a3c87baee609ebb9ecf1a0", + "name": "go-nocgo", + "sha256": "cf9d9e86419a2da5f3a2bc5bbf9034b732723114c4b81c7a80dbfb43a3210f39", + "size": 16682, + "subdir": "linux-64", + "timestamp": 1665476827893, + "version": "1.19.1" + }, + "go-nocgo-1.19.3-hecb7f51_0.conda": { + "build": "hecb7f51_0", + "build_number": 0, + "depends": [ + "go 1.19.3 hb589e2e_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "517e29b70c713cdf26cea15a8701d177", + "name": "go-nocgo", + "sha256": "e24a3433eec440b87df48cb051d5af731b72d033093a73c10a2432b28d274fdc", + "size": 17408, + "subdir": "linux-64", + "timestamp": 1673315189869, + "version": "1.19.3" + }, + "go-nocgo_linux-64-1.16.5-he21932f_0.conda": { + "build": "he21932f_0", + "build_number": 0, + "depends": [ + "_go_select ==2.2.0 nocgo", + "go >=1.16.5,<1.16.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8067127f81477ac663a9896eb4cd5661", + "name": "go-nocgo_linux-64", + "sha256": "c1b2b849264de030e68926ce9eb556682da0550c5bad801aa562009f45f66b7b", + "size": 33519, + "subdir": "linux-64", + "timestamp": 1623660125663, + "version": "1.16.5" + }, + "go_linux-32-1.11.4-hd1bdc26_0.conda": { + "build": "hd1bdc26_0", + "build_number": 0, + "depends": [ + "go-core 1.11.4 hf39692e_0" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "4f49bfe14c1a58edba90ae78dabe03d4", + "name": "go_linux-32", + "sha256": "197edc4053b32887cd61687bb0389e3edaeb70aa7b7b956bc0857d58a5dd43a5", + "size": 9864234, + "subdir": "linux-64", + "timestamp": 1544962452615, + "version": "1.11.4" + }, + "go_linux-64-1.10.3-h0f5337a_3.conda": { + "build": "h0f5337a_3", + "build_number": 3, + "depends": [ + "go-core 1.10.3 hf39692e_3" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "a38ad7333ad357b3bbc5979864d473e9", + "name": "go_linux-64", + "sha256": "9d7539c8a8e984e99fb67c04ae86ace79c8772479eced5c20c94d5659a3b2d36", + "size": 6925289, + "subdir": "linux-64", + "timestamp": 1537370141010, + "version": "1.10.3" + }, + "go_linux-64-1.11.4-h0f5337a_0.conda": { + "build": "h0f5337a_0", + "build_number": 0, + "depends": [ + "go-core 1.11.4 hf39692e_0" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "cd0563bdbb37e4a2e102792ba7326e72", + "name": "go_linux-64", + "sha256": "0904910f0f768f310d50ff94d1dc9cfa50313eb9378ac74baac836041063d915", + "size": 9985467, + "subdir": "linux-64", + "timestamp": 1544962477735, + "version": "1.11.4" + }, + "go_linux-ppc64le-1.11.4-hca29223_0.conda": { + "build": "hca29223_0", + "build_number": 0, + "depends": [ + "go-core 1.11.4 hf39692e_0" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "c91894c0bb2859834fdf6575bdd18326", + "name": "go_linux-ppc64le", + "sha256": "1017036d83471b7650fe4cc5b585a6ecff6e1a05ab5f13de886356bb48d2c680", + "size": 9441786, + "subdir": "linux-64", + "timestamp": 1544962503776, + "version": "1.11.4" + }, + "go_osx-64-1.10.3-h144c09f_3.conda": { + "build": "h144c09f_3", + "build_number": 3, + "depends": [ + "go-core 1.10.3 hf39692e_3" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "ffbf07fd0dd459406703af7bbe0a0c4b", + "name": "go_osx-64", + "sha256": "f591c78e3e0f24535fb44f9c30850526bab8df3c5cc1f32d90b4ea75172cd8e0", + "size": 6935777, + "subdir": "linux-64", + "timestamp": 1537370162401, + "version": "1.10.3" + }, + "go_osx-64-1.11.4-h144c09f_0.conda": { + "build": "h144c09f_0", + "build_number": 0, + "depends": [ + "go-core 1.11.4 hf39692e_0" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "598a0e47e703573220a10f41841335f4", + "name": "go_osx-64", + "sha256": "b58a733f93cf04d379c96376372675753b576bbfe12a0e4b9e02bfbec99e8ed8", + "size": 9998541, + "subdir": "linux-64", + "timestamp": 1544962530352, + "version": "1.11.4" + }, + "go_win-32-1.11.4-h03c23ce_0.conda": { + "build": "h03c23ce_0", + "build_number": 0, + "depends": [ + "go-core 1.11.4 hf39692e_0" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "67150437084d0deb200e2176ad31cbae", + "name": "go_win-32", + "sha256": "cabfd686fbd3f8ebae9d783aa03153209d0b4b518235c1586fc2ef3d135af2ae", + "size": 9846441, + "subdir": "linux-64", + "timestamp": 1544962557611, + "version": "1.11.4" + }, + "go_win-64-1.10.3-h2df250f_3.conda": { + "build": "h2df250f_3", + "build_number": 3, + "depends": [ + "go-core 1.10.3 hf39692e_3" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "26064e9e75e9fbc792edc280156152b7", + "name": "go_win-64", + "sha256": "4bf403792fab7d461d826299d91f23b28ea3f518f558b76eb73d6930fecb2500", + "size": 6945980, + "subdir": "linux-64", + "timestamp": 1537370184055, + "version": "1.10.3" + }, + "go_win-64-1.11.4-h2df250f_0.conda": { + "build": "h2df250f_0", + "build_number": 0, + "depends": [ + "go-core 1.11.4 hf39692e_0" + ], + "license": "BSD-Style", + "license_family": "BSD", + "md5": "6ce728e6865e8c4f66a958136e691b4d", + "name": "go_win-64", + "sha256": "73e4a38a8014d708d10d10be942f49afc7ebd0f716fe226cd3290b03d31985a7", + "size": 9976483, + "subdir": "linux-64", + "timestamp": 1544962583474, + "version": "1.11.4" + }, + "gobject-introspection-1.53.5-py27h02755b6_0.conda": { + "build": "py27h02755b6_0", + "build_number": 0, + "depends": [ + "glib >=2.53.6,<3.0a0", + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "58b98a3f93b99b286fcc01816f78755a", + "name": "gobject-introspection", + "sha256": "7b1f992886f858ce913b82de48c1a64116415fffbb20b2dcc59aaa8320c75411", + "size": 1174515, + "subdir": "linux-64", + "timestamp": 1505744109151, + "version": "1.53.5" + }, + "gobject-introspection-1.53.5-py27h26494a4_0.conda": { + "build": "py27h26494a4_0", + "build_number": 0, + "depends": [ + "glib >=2.53.6,<3.0a0", + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "0de64a6d4917913a12ed3f9285c2d640", + "name": "gobject-introspection", + "sha256": "85eae5e0aaf85d4fd4641c997c8ec6a035ec0e057d81ec0a15c1fc6823660650", + "size": 1174848, + "subdir": "linux-64", + "timestamp": 1507907868257, + "version": "1.53.5" + }, + "gobject-introspection-1.53.5-py35hcfa166f_0.conda": { + "build": "py35hcfa166f_0", + "build_number": 0, + "depends": [ + "glib >=2.53.6,<3.0a0", + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "689120482242650244711521fd5fb626", + "name": "gobject-introspection", + "sha256": "28efd2d5feb3866512adb079af26b355ee0d2cc545a295d7dcd6eb96a893afc4", + "size": 1177315, + "subdir": "linux-64", + "timestamp": 1507907932884, + "version": "1.53.5" + }, + "gobject-introspection-1.53.5-py36h0c36277_0.conda": { + "build": "py36h0c36277_0", + "build_number": 0, + "depends": [ + "glib >=2.53.6,<3.0a0", + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "39690684ec0299b53817554497f970e6", + "name": "gobject-introspection", + "sha256": "15f5b82146245d6b4378544399158415a1ee1ec76f5eed648cdc19c46a0d3eb7", + "size": 1174856, + "subdir": "linux-64", + "timestamp": 1507907991005, + "version": "1.53.5" + }, + "gobject-introspection-1.53.5-py36h92d389f_0.conda": { + "build": "py36h92d389f_0", + "build_number": 0, + "depends": [ + "glib >=2.53.6,<3.0a0", + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "a1ac0e2fb7e21172be42f97c69331419", + "name": "gobject-introspection", + "sha256": "649fc2566687c67f8ddad700e4249e2fb59481c35d10210ba052f119cd0a042f", + "size": 1174643, + "subdir": "linux-64", + "timestamp": 1505744228634, + "version": "1.53.5" + }, + "gobject-introspection-1.56.1-py27h085f2ab_0.conda": { + "build": "py27h085f2ab_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "693156ffbff366b6577efa4cae95faa3", + "name": "gobject-introspection", + "sha256": "3af91a1d617b8589fca43a576c84811e8d034bf0259951106bc8a7c941924b9d", + "size": 1177506, + "subdir": "linux-64", + "timestamp": 1523669888567, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py27hbc4ca2d_1.conda": { + "build": "py27hbc4ca2d_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "34ce9dbb54eb1cb5831a38c233a37ac0", + "name": "gobject-introspection", + "sha256": "51c8cbab0c76bdd53c44ecaec14c27b0691527c13159b2ad589bbe6637fa13d4", + "size": 1177101, + "subdir": "linux-64", + "timestamp": 1527187905744, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py27hbc4ca2d_2.conda": { + "build": "py27hbc4ca2d_2", + "build_number": 2, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "eebe8e5eebd4c8e8c9e5b7b9a4e72a30", + "name": "gobject-introspection", + "sha256": "1c960c86b16a65e5c3abfdef464b4358a936f6e012e2eef61a451dbf2cd67104", + "size": 1176773, + "subdir": "linux-64", + "timestamp": 1527894780765, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py35h085f2ab_0.conda": { + "build": "py35h085f2ab_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "78d2ef4144375d7a1ace2762d81181eb", + "name": "gobject-introspection", + "sha256": "ad6e7ba92f5325a94000720948de2a99a1162b92e18392e9d7731994c9809422", + "size": 1178389, + "subdir": "linux-64", + "timestamp": 1523670064585, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py35hbc4ca2d_1.conda": { + "build": "py35hbc4ca2d_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "ed0a9af131edddf4979431261720c1e9", + "name": "gobject-introspection", + "sha256": "f97d40fbdbcbf6cf57cbbf7d5e8b7f1ab3526d358644ee7e77056e02a38db0bd", + "size": 1178126, + "subdir": "linux-64", + "timestamp": 1527187932305, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py35hbc4ca2d_2.conda": { + "build": "py35hbc4ca2d_2", + "build_number": 2, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "4eadae7ee663f1464cbabbb6cf6d762d", + "name": "gobject-introspection", + "sha256": "9367a167289b05c214bb09028ac8b4e6062b8adbf29240b6ea3973d247e9dc72", + "size": 1177764, + "subdir": "linux-64", + "timestamp": 1527894780610, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py36h085f2ab_0.conda": { + "build": "py36h085f2ab_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "3c37e4c7a9c4bd50ac46608a0b5623a5", + "name": "gobject-introspection", + "sha256": "be8d1e29c21eccf1d72164a7fa8e3a8cc2fe12fd0ee581fb1e7f5caa2926b7a4", + "size": 1176881, + "subdir": "linux-64", + "timestamp": 1523670105791, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py36hbc4ca2d_1.conda": { + "build": "py36hbc4ca2d_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "64ad98d5f9bf845ad56de92cbe6b5663", + "name": "gobject-introspection", + "sha256": "6258262c1d7801b0575d98c877d60e4477e3ff7c1ea23976daf94c5f91abbe77", + "size": 1176873, + "subdir": "linux-64", + "timestamp": 1527187898494, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py36hbc4ca2d_2.conda": { + "build": "py36hbc4ca2d_2", + "build_number": 2, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "9a7d07e3af6e1703b2b6bef8e286e72a", + "name": "gobject-introspection", + "sha256": "2ab5c02e8cd65d6c006a21956e0ef8e26ae6f99c0788110a6aa701bdd490fc5e", + "size": 1175220, + "subdir": "linux-64", + "timestamp": 1527894778182, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py37hbc4ca2d_2.conda": { + "build": "py37hbc4ca2d_2", + "build_number": 2, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.42,<9.0a0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "2ed32921f60a8cec2b84b038dc6dd060", + "name": "gobject-introspection", + "sha256": "4e641f75ff3a65559b6e9dc9e1de5bde4edce8b79fe9644940672444a1283d85", + "size": 1175168, + "subdir": "linux-64", + "timestamp": 1530892415851, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py38h56ee657_3.conda": { + "build": "py38h56ee657_3", + "build_number": 3, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.63.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.43,<9.0a0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "cbd97bd50c6a320a05712515b92a5b12", + "name": "gobject-introspection", + "sha256": "646ef0cefec4c85ea4e383d6577d5b1473a0c450dbbcd966c59df00ff2c35a83", + "size": 1192018, + "subdir": "linux-64", + "timestamp": 1589891621683, + "version": "1.56.1" + }, + "gobject-introspection-1.56.1-py38h9a62fa1_2.conda": { + "build": "py38h9a62fa1_2", + "build_number": 2, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "glib >=2.63.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libxcb >=1.13,<2.0a0", + "pcre >=8.43,<9.0a0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPLv2+", + "license_family": "LGPL", + "md5": "dccb8e8a3d919656424da916476f2306", + "name": "gobject-introspection", + "sha256": "30dcef081b7baace49d355e94005a264844b02334fdb610662d15618af0e9ee8", + "size": 1197045, + "subdir": "linux-64", + "timestamp": 1573638896977, + "version": "1.56.1" + }, + "gobject-introspection-1.66.1-py36h94476cb_0.conda": { + "build": "py36h94476cb_0", + "build_number": 0, + "depends": [ + "glib >=2.63.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "e6480844f3afe5e2a51fb59f77b9dbde", + "name": "gobject-introspection", + "sha256": "1b63d4052b144cbbea77e56962fd5a3840b090d7d5008eebfbe9ec4528f81219", + "size": 1428142, + "subdir": "linux-64", + "timestamp": 1609185455029, + "version": "1.66.1" + }, + "gobject-introspection-1.66.1-py37h94476cb_0.conda": { + "build": "py37h94476cb_0", + "build_number": 0, + "depends": [ + "glib >=2.63.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "4a160ad81ced0e1f2789891f6cad4c6f", + "name": "gobject-introspection", + "sha256": "4908484e401202d9796070c43b143680b670911972f6fb96df73300be770023d", + "size": 1430316, + "subdir": "linux-64", + "timestamp": 1609185450282, + "version": "1.66.1" + }, + "gobject-introspection-1.66.1-py38h94476cb_0.conda": { + "build": "py38h94476cb_0", + "build_number": 0, + "depends": [ + "glib >=2.63.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "eaa9820a5333692308c4e14b43cd4985", + "name": "gobject-introspection", + "sha256": "04211898574c700bdc867e684113b5026c79c85deb2bfeb02e8cb4d735a9c414", + "size": 1431578, + "subdir": "linux-64", + "timestamp": 1609185434597, + "version": "1.66.1" + }, + "gobject-introspection-1.66.1-py39h94476cb_0.conda": { + "build": "py39h94476cb_0", + "build_number": 0, + "depends": [ + "glib >=2.63.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "bdc624cc1c8a56ce44feb04bf0d28a4e", + "name": "gobject-introspection", + "sha256": "32992a1f76e29da28a831a7edbf6587dbf81d581d7df9b3cc22e71dace3bc616", + "size": 1427980, + "subdir": "linux-64", + "timestamp": 1609185460135, + "version": "1.66.1" + }, + "gobject-introspection-1.67.1-py36h2109141_1.conda": { + "build": "py36h2109141_1", + "build_number": 1, + "depends": [ + "glib >=2.67.4,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "ed82f9e7a50c740b26e514c4c26e6d92", + "name": "gobject-introspection", + "sha256": "d7235d49d28d4c80e9f5c128e1afe898be687762160ac98a52d4973efe5d235e", + "size": 1447042, + "subdir": "linux-64", + "timestamp": 1615661986336, + "version": "1.67.1" + }, + "gobject-introspection-1.67.1-py37h2109141_1.conda": { + "build": "py37h2109141_1", + "build_number": 1, + "depends": [ + "glib >=2.67.4,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "86e6646c8212ff6fd479deeea8c512b6", + "name": "gobject-introspection", + "sha256": "3754e9a2933cb36ed77fec9fe365876d9826512dc9acb35a870b07d8f61ff5b3", + "size": 1447702, + "subdir": "linux-64", + "timestamp": 1615660299116, + "version": "1.67.1" + }, + "gobject-introspection-1.67.1-py38h2109141_1.conda": { + "build": "py38h2109141_1", + "build_number": 1, + "depends": [ + "glib >=2.67.4,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "1a9eaa0b9e6076efe68e7c37186cf2c6", + "name": "gobject-introspection", + "sha256": "573505b9cc14889a34f8c0e5a280a22bdb07c0f5dfb87ff468e5a8a6b6211df3", + "size": 1448660, + "subdir": "linux-64", + "timestamp": 1615662024201, + "version": "1.67.1" + }, + "gobject-introspection-1.67.1-py39h2109141_1.conda": { + "build": "py39h2109141_1", + "build_number": 1, + "depends": [ + "glib >=2.67.4,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "e957b8958e7abec5db3b23eb565de4e1", + "name": "gobject-introspection", + "sha256": "10cc269d52e2df81a5bca2bf9d2347e78b860d7f9bbf59cdc12d064ff4d319f7", + "size": 1449822, + "subdir": "linux-64", + "timestamp": 1615662021664, + "version": "1.67.1" + }, + "gobject-introspection-1.68.0-py310hc6cf493_2.conda": { + "build": "py310hc6cf493_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "cd2866d59a6dfbfa02d055e884782ba3", + "name": "gobject-introspection", + "sha256": "25d4e16ae9b7139ee52a9e0c36712318dc7f6cbb570f6f01b6e7b526a48dd315", + "size": 1454973, + "subdir": "linux-64", + "timestamp": 1640790560057, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py36h2109141_1.conda": { + "build": "py36h2109141_1", + "build_number": 1, + "depends": [ + "glib >=2.67.4,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "9b93d235678655e8a8c4b8896ad03bcb", + "name": "gobject-introspection", + "sha256": "524bd9cedbf1d2085d73bc2878f5a5b4f6b0ae341a4c57a1eb0ea709cd1e3eb7", + "size": 1445167, + "subdir": "linux-64", + "timestamp": 1616269317754, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py36hc6cf493_1.conda": { + "build": "py36hc6cf493_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "968174b813c8925cd8bbb3791ed61be7", + "name": "gobject-introspection", + "sha256": "d32f51c80c25961b8b5655b8903f679c0aaa4650a696a25915f0c7e68f29ac2c", + "size": 1456957, + "subdir": "linux-64", + "timestamp": 1631782815981, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py36hc6cf493_2.conda": { + "build": "py36hc6cf493_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "2c287bfa118e4e460e726ef039fc23bb", + "name": "gobject-introspection", + "sha256": "a0f61faa27866d7332c763bbec9a69bdd7bf4c0e2feaf227bd1b31af76fab7b7", + "size": 1458146, + "subdir": "linux-64", + "timestamp": 1632481180932, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py37h2109141_1.conda": { + "build": "py37h2109141_1", + "build_number": 1, + "depends": [ + "glib >=2.67.4,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "de71df9a7ed875b68530594daa43ebe3", + "name": "gobject-introspection", + "sha256": "a478f0ac44d1fb7e10ee0fdd7cf59fc974a43560ac4cf994510e56aafe00ac50", + "size": 1448443, + "subdir": "linux-64", + "timestamp": 1616269311443, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py37hc6cf493_1.conda": { + "build": "py37hc6cf493_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "8e37fcd3327b081edd671863c6f7107f", + "name": "gobject-introspection", + "sha256": "efc485d5217a1bcb22017f6a0bcb84afa6963512d752ddb254ebe6396f324997", + "size": 1458514, + "subdir": "linux-64", + "timestamp": 1631783221956, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py37hc6cf493_2.conda": { + "build": "py37hc6cf493_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "15f0a6c57dd214b83532a5b152176558", + "name": "gobject-introspection", + "sha256": "5bedd04e5909ca53d4028baee0698859ab630d91212664339df9f6d264d35001", + "size": 1460800, + "subdir": "linux-64", + "timestamp": 1632481018276, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py37he41a700_3.conda": { + "build": "py37he41a700_3", + "build_number": 3, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "b6f794065dd3ec7c57a5db7d9b45fa0f", + "name": "gobject-introspection", + "sha256": "411c386205b0d8431eb371c0b5415375650cad6df5edbef755d8bb3c0be53943", + "size": 1451094, + "subdir": "linux-64", + "timestamp": 1642702386246, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py38h2109141_1.conda": { + "build": "py38h2109141_1", + "build_number": 1, + "depends": [ + "glib >=2.67.4,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "ca86bada6aa1542a75c609ba880bea6b", + "name": "gobject-introspection", + "sha256": "d45f39dec19776fcf3fd1044dae30ad4ecbed94cc4ff46f0e0ebb5b4bb32f46a", + "size": 1448514, + "subdir": "linux-64", + "timestamp": 1616268593803, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py38hc6cf493_1.conda": { + "build": "py38hc6cf493_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "22bd33eafe9ff539c6cd6dc944e93311", + "name": "gobject-introspection", + "sha256": "dbc75b4a59ea9d7aba2a3e5b176b6421457a3785892f5e9090690716499b3d46", + "size": 1457112, + "subdir": "linux-64", + "timestamp": 1631783212703, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py38hc6cf493_2.conda": { + "build": "py38hc6cf493_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "470036f1081d0f2d24ff601928058d2f", + "name": "gobject-introspection", + "sha256": "f4a466454149865dc934304fa79e490cdfa0954b64a84c19f0159bb678b7a1f7", + "size": 1460272, + "subdir": "linux-64", + "timestamp": 1632481162622, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py38he41a700_3.conda": { + "build": "py38he41a700_3", + "build_number": 3, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "ba19d0b0c9daa6d934e6a51ea0074ace", + "name": "gobject-introspection", + "sha256": "2755844fff73509d2a06d51adfadb262fadbf3dbef94eae82d8a56f4055831d9", + "size": 1452636, + "subdir": "linux-64", + "timestamp": 1642702317938, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py39h2109141_1.conda": { + "build": "py39h2109141_1", + "build_number": 1, + "depends": [ + "glib >=2.67.4,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "c948075f7050b9f6bd08d62e6d1025aa", + "name": "gobject-introspection", + "sha256": "5a372334c555fc610742f21883f3358186b396c768b7f2a8306090979edf21a8", + "size": 1449955, + "subdir": "linux-64", + "timestamp": 1616267279765, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py39hc6cf493_1.conda": { + "build": "py39hc6cf493_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "7694d7d2263926631775042575e0cc0f", + "name": "gobject-introspection", + "sha256": "9d858687473b9c92b74c271b1d80fa5ac3a62f5f12ebc043cac9cc56353bc1c6", + "size": 1456703, + "subdir": "linux-64", + "timestamp": 1631783210170, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py39hc6cf493_2.conda": { + "build": "py39hc6cf493_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "40d4cef7bca54e38da442567bbd15d11", + "name": "gobject-introspection", + "sha256": "be789c7eff0337fa427be32c9d1f75869e8ecd1ef00cd5fc5833366cc3c2981e", + "size": 1461253, + "subdir": "linux-64", + "timestamp": 1632481151140, + "version": "1.68.0" + }, + "gobject-introspection-1.68.0-py39he41a700_3.conda": { + "build": "py39he41a700_3", + "build_number": 3, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "8fc0669e800fce9c0d53f945c791908d", + "name": "gobject-introspection", + "sha256": "275225af28ab7aa6cac0e8b08f054103304aa718939436687716bf9d7aec213a", + "size": 1452800, + "subdir": "linux-64", + "timestamp": 1642702246699, + "version": "1.68.0" + }, + "gobject-introspection-1.72.0-py310hbb6d50b_0.conda": { + "build": "py310hbb6d50b_0", + "build_number": 0, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "3f2ee6e9faaaa571e47b33f27417ebd3", + "name": "gobject-introspection", + "sha256": "8f5a1aa3e5a43fbeca10ea86b4208a6030c3a4b8f74afbd7234b1e009a420364", + "size": 1488310, + "subdir": "linux-64", + "timestamp": 1656517264696, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py310hbb6d50b_1.conda": { + "build": "py310hbb6d50b_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "e6784fa85898d69069b09d4184ce60d8", + "name": "gobject-introspection", + "sha256": "fd09caa98d024cdce6437ea6245619f2320ed9a545dcd7d660e7968c1079aa6a", + "size": 1494759, + "subdir": "linux-64", + "timestamp": 1669366989970, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py310hbb6d50b_2.conda": { + "build": "py310hbb6d50b_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "174de2e7d5c0e80bfbddb977f7141b3e", + "name": "gobject-introspection", + "sha256": "1e15805782e24345dbee6c09444c7ab274f4d9b12e771289ad2f4f40cebb81ae", + "size": 1660167, + "subdir": "linux-64", + "timestamp": 1678430377081, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py311hbb6d50b_1.conda": { + "build": "py311hbb6d50b_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "c8ce14091bbcdce04ab4bf3a81ab2930", + "name": "gobject-introspection", + "sha256": "cc3ab5ade96ac038ecb305e611379fe05a788de2da5a9b9c46eb017346ed98f6", + "size": 1584874, + "subdir": "linux-64", + "timestamp": 1676823485436, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py311hbb6d50b_2.conda": { + "build": "py311hbb6d50b_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "3d2742a8778aa8bcc8879f74aec288f3", + "name": "gobject-introspection", + "sha256": "27937ce04e5db748bd9dd571f6d83eb20ac2fff8b7ed1c4d357874daa84bff19", + "size": 1596217, + "subdir": "linux-64", + "timestamp": 1679336020517, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py37hbb6d50b_0.conda": { + "build": "py37hbb6d50b_0", + "build_number": 0, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "16c2b072793ccba3ebcee0535c289f72", + "name": "gobject-introspection", + "sha256": "51880d63f54ef120d43214c9f5343531d9c60c0c94c31dcdd26eba4598984ed7", + "size": 1485462, + "subdir": "linux-64", + "timestamp": 1656517182296, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py37hbb6d50b_1.conda": { + "build": "py37hbb6d50b_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "569a9ccee8fca12323a3acd165d13db5", + "name": "gobject-introspection", + "sha256": "abd794cc4a88527eee11edbeca7540c26cdcf05e6131815c83878dddc708623f", + "size": 1494212, + "subdir": "linux-64", + "timestamp": 1669367000146, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py38hbb6d50b_0.conda": { + "build": "py38hbb6d50b_0", + "build_number": 0, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "094cc2c6bd6dc5b91f5791a6f5df24a8", + "name": "gobject-introspection", + "sha256": "2e00c4f953ff39a82e75fa675369d513f673994cf5b61cf99ad941ebde852127", + "size": 1486475, + "subdir": "linux-64", + "timestamp": 1656517405236, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py38hbb6d50b_1.conda": { + "build": "py38hbb6d50b_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "0c417c9641752935b00e05a0ed45bd2b", + "name": "gobject-introspection", + "sha256": "5121fd8ac972f0856ef74e006f83c52af8c92757c2f312806faf48281dfa2eeb", + "size": 1494070, + "subdir": "linux-64", + "timestamp": 1669367018651, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py38hbb6d50b_2.conda": { + "build": "py38hbb6d50b_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "7f1ddb0137ae9b79b14657ccbb3ad59e", + "name": "gobject-introspection", + "sha256": "fbe4a69639e403e75dfba699b7e0df86b90c8b0018bb19cb176ceff59fad34f4", + "size": 1658837, + "subdir": "linux-64", + "timestamp": 1678430204759, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py39hbb6d50b_0.conda": { + "build": "py39hbb6d50b_0", + "build_number": 0, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.3", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "45acd6a7d9a7dcc17a0bf8746b01b8de", + "name": "gobject-introspection", + "sha256": "684a13c6ddd08b2eabc1f83c7806ccfc6a5c91427966d13cd53c192278182067", + "size": 1486357, + "subdir": "linux-64", + "timestamp": 1656517334776, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py39hbb6d50b_1.conda": { + "build": "py39hbb6d50b_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "f8b6d6d1832aadf9ab60f7279682a740", + "name": "gobject-introspection", + "sha256": "84ab26e954be9a81408d9bb8f63bf2acc6acd058386555ab69e3abc8a569b741", + "size": 1494609, + "subdir": "linux-64", + "timestamp": 1669367015091, + "version": "1.72.0" + }, + "gobject-introspection-1.72.0-py39hbb6d50b_2.conda": { + "build": "py39hbb6d50b_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "84aebcf62b98b5ce4893b880daeb0ede", + "name": "gobject-introspection", + "sha256": "dea4f7fea48fb87d37c22797be0da51050c3e594c8ebca9929e35f556be6a050", + "size": 1658689, + "subdir": "linux-64", + "timestamp": 1678430292045, + "version": "1.72.0" + }, + "google-api-core-1.16.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "google-auth >=0.4.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "944200978d9ef4b175e765eb6631e42c", + "name": "google-api-core", + "sha256": "8de0bc5aaafecade8563ee5f07145a1f85df9d3e5efeb693fd3c98b259869421", + "size": 88520, + "subdir": "linux-64", + "timestamp": 1586571786143, + "version": "1.16.0" + }, + "google-api-core-1.16.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "google-auth >=0.4.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "f8fe60eb18838b5138185342b2710bf1", + "name": "google-api-core", + "sha256": "b427543c71cc59ad5e2246d6720d45572b8855d4bef5c698a2b147dcdd5bb074", + "size": 88755, + "subdir": "linux-64", + "timestamp": 1586571788882, + "version": "1.16.0" + }, + "google-api-core-1.16.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "google-auth >=0.4.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "04517b034476643a15121c1380b874f8", + "name": "google-api-core", + "sha256": "c11eab7709defe2fe1b0f6ddbd1884599c69f4f234511b1c87229ac4802f56a0", + "size": 87981, + "subdir": "linux-64", + "timestamp": 1586571758910, + "version": "1.16.0" + }, + "google-api-core-1.17.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "90c900dfef15f6286eb59c1d9566e09e", + "name": "google-api-core", + "sha256": "97db8ce89fde140d10b7d434ca99856f90cd822ecfbbdd0af34f04edb995fb2a", + "size": 89002, + "subdir": "linux-64", + "timestamp": 1588594642046, + "version": "1.17.0" + }, + "google-api-core-1.17.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "531edf836adb5cec92a808e66e07e5c2", + "name": "google-api-core", + "sha256": "4148c8fd7e5f4a21373212b911baf6fb529f2faf0a550ae4ddf9eb8178909165", + "size": 89246, + "subdir": "linux-64", + "timestamp": 1588594618233, + "version": "1.17.0" + }, + "google-api-core-1.17.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "61f03f3ec1e4efdb010e0ed43431a353", + "name": "google-api-core", + "sha256": "08345150f262a092c52abc0b7189f6f1b594100f36bf16cdaf05f8338cbcf3d3", + "size": 87594, + "subdir": "linux-64", + "timestamp": 1588594639220, + "version": "1.17.0" + }, + "google-api-core-1.20.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5bc5dd5b2abae71216aaefc96e3308f0", + "name": "google-api-core", + "sha256": "0f1293d2424ddb31418e22742e70dbff5223ad2ba650323351ba431ed9a9db8e", + "size": 99967, + "subdir": "linux-64", + "timestamp": 1604438236344, + "version": "1.20.0" + }, + "google-api-core-1.20.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c71d65dd2682b39183d0642e1a43fccc", + "name": "google-api-core", + "sha256": "6a6475999e376906226b9c137f43ff59e8bb605973769758f8073807f9de86f2", + "size": 98749, + "subdir": "linux-64", + "timestamp": 1604438225060, + "version": "1.20.0" + }, + "google-api-core-1.20.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9708bff0e78596dd18e387e7d30139e6", + "name": "google-api-core", + "sha256": "5a5acd4598375b3c7f632a788615005945e6b596c26a0f07ad3c4f2bff329ded", + "size": 99115, + "subdir": "linux-64", + "timestamp": 1604438257657, + "version": "1.20.0" + }, + "google-api-core-1.20.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.9,<3.10.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c3a7a864bff82f47680b5709e9df9de5", + "name": "google-api-core", + "sha256": "a404481fce7138c252688a2cce8cc3c3f4461830ab16a6712bf4d7cd05fcf35c", + "size": 100431, + "subdir": "linux-64", + "timestamp": 1636035850990, + "version": "1.20.0" + }, + "google-api-core-1.22.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f0aaad9bce02287db4a8b6a18b9d9980", + "name": "google-api-core", + "sha256": "fc5429070d75f653764a7838ffaf9f15ff8b70dcb86f7f9a3de922b223eced6e", + "size": 98744, + "subdir": "linux-64", + "timestamp": 1601307118120, + "version": "1.22.2" + }, + "google-api-core-1.22.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7a98b299b176a886ce30966f127db5e9", + "name": "google-api-core", + "sha256": "e53c1b860954b311be56401ff205fed6171fea23a4c440df88603324eb18c2f0", + "size": 100684, + "subdir": "linux-64", + "timestamp": 1601307091464, + "version": "1.22.2" + }, + "google-api-core-1.22.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "google-auth >=1.14.0,<2.0.0dev", + "googleapis-common-protos >=1.6.0,<2.0dev", + "protobuf >=3.4.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests >=2.18.0,<3.0.0dev", + "setuptools >=34.0.0", + "six >=1.10.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ab9c0750c50b2471a48fb7bece9f7c61", + "name": "google-api-core", + "sha256": "198eda77a8ea9eca51215a7b09a0702abe5ce03f83b2777245b7acb8d4cd0dbd", + "size": 101153, + "subdir": "linux-64", + "timestamp": 1601307116386, + "version": "1.22.2" + }, + "google-api-core-2.10.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio-status >=1.33.2,<2.0dev", + "grpcio >=1.33.2,<2.0dev", + "grpcio-gcp >=0.2.2,<1.0dev" + ], + "depends": [ + "google-auth >=1.25.0,<3.0dev", + "googleapis-common-protos >=1.56.2,<2.0dev", + "protobuf >=3.20.1", + "python >=3.10,<3.11.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c16501b489f73f73cdc6f5cc9c2381c9", + "name": "google-api-core", + "sha256": "39b2cb5ccf2420b48aab55e696beb37d8503f7a88104c81335e4db80b4f1e342", + "size": 122125, + "subdir": "linux-64", + "timestamp": 1663638672043, + "version": "2.10.1" + }, + "google-api-core-2.10.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio >=1.33.2,<2.0dev", + "grpcio-status >=1.33.2,<2.0dev", + "grpcio-gcp >=0.2.2,<1.0dev" + ], + "depends": [ + "google-auth >=1.25.0,<3.0dev", + "googleapis-common-protos >=1.56.2,<2.0dev", + "protobuf >=3.20.1", + "python >=3.11,<3.12.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e9290097d2bd0a990ff460472126332e", + "name": "google-api-core", + "sha256": "deb0af136148bd02d08960e678fb9127f8caf9e53f1cb0d84ddb4e5a1abdb983", + "size": 148158, + "subdir": "linux-64", + "timestamp": 1676839889187, + "version": "2.10.1" + }, + "google-api-core-2.10.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio-status >=1.33.2,<2.0dev", + "grpcio >=1.33.2,<2.0dev", + "grpcio-gcp >=0.2.2,<1.0dev" + ], + "depends": [ + "google-auth >=1.25.0,<3.0dev", + "googleapis-common-protos >=1.56.2,<2.0dev", + "protobuf >=3.20.1", + "python >=3.7,<3.8.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "34488da909df4b81d3f02856802ec313", + "name": "google-api-core", + "sha256": "b22a4b30c557128bad513a9578641bc15bc04eae28f859111e6c650fa44abbb6", + "size": 120184, + "subdir": "linux-64", + "timestamp": 1663638871279, + "version": "2.10.1" + }, + "google-api-core-2.10.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio-status >=1.33.2,<2.0dev", + "grpcio >=1.33.2,<2.0dev", + "grpcio-gcp >=0.2.2,<1.0dev" + ], + "depends": [ + "google-auth >=1.25.0,<3.0dev", + "googleapis-common-protos >=1.56.2,<2.0dev", + "protobuf >=3.20.1", + "python >=3.8,<3.9.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "d7513849ba5c1206a1a2daf2bf2f6da1", + "name": "google-api-core", + "sha256": "4dc00e1cd900e9815b65115e9b6e5971577db368ab9790e136068b79f00ab245", + "size": 120874, + "subdir": "linux-64", + "timestamp": 1663638806063, + "version": "2.10.1" + }, + "google-api-core-2.10.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio-status >=1.33.2,<2.0dev", + "grpcio >=1.33.2,<2.0dev", + "grpcio-gcp >=0.2.2,<1.0dev" + ], + "depends": [ + "google-auth >=1.25.0,<3.0dev", + "googleapis-common-protos >=1.56.2,<2.0dev", + "protobuf >=3.20.1", + "python >=3.9,<3.10.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6b12af17189882c4dd64dce402bb9caa", + "name": "google-api-core", + "sha256": "c1dd167d061cc724af68828eb9105091b23eaa5d0cfa4ac82af66dabd098400d", + "size": 120876, + "subdir": "linux-64", + "timestamp": 1663638739929, + "version": "2.10.1" + }, + "google-api-core-grpc-1.16.0-1.conda": { + "build": "1", + "build_number": 1, + "depends": [ + "google-api-core >=1.16,<1.17.0a0", + "grpcio >=1.8.2" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "4d07a9406bb9c327ccbaeb7efb2e5764", + "name": "google-api-core-grpc", + "sha256": "28fa8fab8d9ffd19c1e0ce03f2064ce0d794baf7430b1cc60e5c16bbe6e36ece", + "size": 10200, + "subdir": "linux-64", + "timestamp": 1586571801386, + "version": "1.16.0" + }, + "google-api-core-grpc-1.17.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "google-api-core >=1.17,<1.18.0a0", + "grpcio >=1.8.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9a8bae8cd476ffd1cf97b341cd4bfc2d", + "name": "google-api-core-grpc", + "sha256": "1673d1a45aa123bcedd78217244b3c89b781d58ac1d871b622b8dc46e69e68b0", + "size": 10239, + "subdir": "linux-64", + "timestamp": 1588594651151, + "version": "1.17.0" + }, + "google-api-core-grpc-1.20.0-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.20,<1.21.0a0", + "grpcio >=1.8.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "33b06f1000d5bd310b959035d5652439", + "name": "google-api-core-grpc", + "sha256": "eca8a6139f9a80401d52b32b4cc23f7242f7ae8bb14a623b8c45b993ae5c51e1", + "size": 10260, + "subdir": "linux-64", + "timestamp": 1604438267854, + "version": "1.20.0" + }, + "google-api-core-grpc-1.22.2-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "google-api-core >=1.22,<1.23.0a0", + "grpcio >=1.8.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8bd6365a0680d3bff1381724e1f9f4bb", + "name": "google-api-core-grpc", + "sha256": "e71f7c6f1a9d629280bab27e7b0b421d016d75792677e03c780bd8aaee3db0f4", + "size": 10202, + "subdir": "linux-64", + "timestamp": 1601307099377, + "version": "1.22.2" + }, + "google-api-core-grpc-1.25.1-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.25,<1.26.0a0", + "grpcio >=1.29.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "0d500043a9f7433e96c7313786eedb55", + "name": "google-api-core-grpc", + "sha256": "38df96f4aab1ce070b9209836c480c4f4ee3ed453b2ef7f5333df656fcd060ec", + "size": 11886, + "subdir": "linux-64", + "timestamp": 1613979807101, + "version": "1.25.1" + }, + "google-api-core-grpc-2.10.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py310h06a4308_0", + "grpcio >=1.33.2,<2.0dev", + "grpcio-status >=1.33.2,<2.0dev", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "392bee3bc87be31b581ce33f878f8f4f", + "name": "google-api-core-grpc", + "sha256": "699e1a709280c8018458c99ab290865172804983929550ce228579b348f28bc4", + "size": 4326, + "subdir": "linux-64", + "timestamp": 1663638677868, + "version": "2.10.1" + }, + "google-api-core-grpc-2.10.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py311h06a4308_0", + "grpcio >=1.33.2,<2.0dev", + "grpcio-status >=1.33.2,<2.0dev", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "79db56ec9b8588f30e0660e5d7417394", + "name": "google-api-core-grpc", + "sha256": "0a05eae7d7446c5474c4d0f46fce00caada02882e4599515003a3ab84e5097b2", + "size": 4697, + "subdir": "linux-64", + "timestamp": 1676839893371, + "version": "2.10.1" + }, + "google-api-core-grpc-2.10.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py37h06a4308_0", + "grpcio >=1.33.2,<2.0dev", + "grpcio-status >=1.33.2,<2.0dev", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "653d793e165359a376376916f7562b96", + "name": "google-api-core-grpc", + "sha256": "3cce4014cb8322fa725e37bdbe55932173b6df49a709fd819a09837f9e5926eb", + "size": 4298, + "subdir": "linux-64", + "timestamp": 1663638876754, + "version": "2.10.1" + }, + "google-api-core-grpc-2.10.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py38h06a4308_0", + "grpcio >=1.33.2,<2.0dev", + "grpcio-status >=1.33.2,<2.0dev", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "627d4d714c8bd5bfcbe3d7afb8b3d1cd", + "name": "google-api-core-grpc", + "sha256": "fb7df67030876fec361b2d8746b288a882a3f89fe30f97d39c947074acf77fd6", + "size": 4298, + "subdir": "linux-64", + "timestamp": 1663638811603, + "version": "2.10.1" + }, + "google-api-core-grpc-2.10.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py39h06a4308_0", + "grpcio >=1.33.2,<2.0dev", + "grpcio-status >=1.33.2,<2.0dev", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6d24304828fe015cfad596da73db47c8", + "name": "google-api-core-grpc", + "sha256": "1d9e96d37500e2e4e045ac0171f0829d37bed6c0d63fc23fdec51d6ce76e8678", + "size": 4307, + "subdir": "linux-64", + "timestamp": 1663638745634, + "version": "2.10.1" + }, + "google-api-core-grpcgcp-1.16.0-1.conda": { + "build": "1", + "build_number": 1, + "depends": [ + "google-api-core-grpcio-gcp >=1.16,<1.17.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "e58d3b4a5ed0e519eb0570ae03d2d967", + "name": "google-api-core-grpcgcp", + "sha256": "e1e8d74ef8d59a8498449365c2e18449ca831b5446e09934501023a8087fc81c", + "size": 10208, + "subdir": "linux-64", + "timestamp": 1586571824931, + "version": "1.16.0" + }, + "google-api-core-grpcgcp-1.17.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "google-api-core-grpcio-gcp >=1.17,<1.18.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "44ba4b258a0bccf5cc4a95c5381aeb45", + "name": "google-api-core-grpcgcp", + "sha256": "68fd93e263469efc3627402a21394d5a749df340839a66a68805eff698fb0f0b", + "size": 10254, + "subdir": "linux-64", + "timestamp": 1588594675207, + "version": "1.17.0" + }, + "google-api-core-grpcgcp-1.20.0-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core-grpcio-gcp >=1.20,<1.21.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "03a807425acb1ebd56db2c1be11fd439", + "name": "google-api-core-grpcgcp", + "sha256": "0dcadfe582d613c7dc558ed5da2244550585ce5a8d85ac98bc69f17bf0b1e18a", + "size": 10262, + "subdir": "linux-64", + "timestamp": 1604438285519, + "version": "1.20.0" + }, + "google-api-core-grpcgcp-1.22.2-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "google-api-core-grpcio-gcp >=1.22,<1.23.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6f649525f76cfd0c6882eb0a1857ce23", + "name": "google-api-core-grpcgcp", + "sha256": "96d4d7b7f23b1ba703c7f030a24252f48af62dd91c96d5a35954cfe2adfd4303", + "size": 10236, + "subdir": "linux-64", + "timestamp": 1601307154324, + "version": "1.22.2" + }, + "google-api-core-grpcgcp-1.25.1-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core-grpcio-gcp >=1.25,<1.26.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "fe2344137a8cc827c6c82c771945258e", + "name": "google-api-core-grpcgcp", + "sha256": "c097b8f1d1f91f4e8665c5af58e07c255fd86d354770d12a73ae49919e8becb9", + "size": 11861, + "subdir": "linux-64", + "timestamp": 1613979824327, + "version": "1.25.1" + }, + "google-api-core-grpcgcp-2.10.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core-grpcio-gcp 2.10.1 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "cce627c0fe5bc956fcb8f86204e93633", + "name": "google-api-core-grpcgcp", + "sha256": "3e731dd105ac7810bb9bd55f7c95c7b1667ac16bbf3e982e47d01aae1055fc47", + "size": 4354, + "subdir": "linux-64", + "timestamp": 1663638688894, + "version": "2.10.1" + }, + "google-api-core-grpcgcp-2.10.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core-grpcio-gcp 2.10.1 py311h06a4308_0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c8be5a3edfb5b72d33c5d854432bac52", + "name": "google-api-core-grpcgcp", + "sha256": "3fc3f5e87eae4ad4756d9ed72fa1d09a22bd46dc042cd17d2cc2d60626b49e4c", + "size": 4724, + "subdir": "linux-64", + "timestamp": 1676839901173, + "version": "2.10.1" + }, + "google-api-core-grpcgcp-2.10.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core-grpcio-gcp 2.10.1 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8a16769c78b0d92de8814e405424f7b1", + "name": "google-api-core-grpcgcp", + "sha256": "17ce6ae37e7fbbdd93255d45da7a0ab56c66b50c97f35569fa9f72ee53d73eba", + "size": 4327, + "subdir": "linux-64", + "timestamp": 1663638887137, + "version": "2.10.1" + }, + "google-api-core-grpcgcp-2.10.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core-grpcio-gcp 2.10.1 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "4978fd2b4ec387b0911ec299cc3f418d", + "name": "google-api-core-grpcgcp", + "sha256": "bc6bc03f4054963a4d8c4f75fe7db6b91607e50ce56e52e77e0518689168ed86", + "size": 4328, + "subdir": "linux-64", + "timestamp": 1663638821996, + "version": "2.10.1" + }, + "google-api-core-grpcgcp-2.10.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core-grpcio-gcp 2.10.1 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "552a736823cb67d0c6b872537d0fefbf", + "name": "google-api-core-grpcgcp", + "sha256": "dd90565bbc76b4d33bd27e3d58c946b185fb8b6911f85b12ad8f8e0d10b87a9a", + "size": 4326, + "subdir": "linux-64", + "timestamp": 1663638756603, + "version": "2.10.1" + }, + "google-api-core-grpcio-gcp-1.16.0-1.conda": { + "build": "1", + "build_number": 1, + "depends": [ + "google-api-core >=1.16,<1.17.0a0", + "grpcio-gcp" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "c2f63e4cff4a826ab0f9a691b6214158", + "name": "google-api-core-grpcio-gcp", + "sha256": "8529f13dec69bdd158b2e6949da71b3fd2c03f0cbb6b1e49e4723d677912961a", + "size": 10274, + "subdir": "linux-64", + "timestamp": 1586571814274, + "version": "1.16.0" + }, + "google-api-core-grpcio-gcp-1.17.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "google-api-core >=1.17,<1.18.0a0", + "grpcio-gcp" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "ae812393de74e97a8cdc713f8724e00d", + "name": "google-api-core-grpcio-gcp", + "sha256": "518d6a70d1cf61b8f001b2a9e86fdc08ebdb84015af677a5dae0670be2a07727", + "size": 10337, + "subdir": "linux-64", + "timestamp": 1588594663660, + "version": "1.17.0" + }, + "google-api-core-grpcio-gcp-1.20.0-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.20,<1.21.0a0", + "grpcio-gcp" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "0edae9c7d4afed7a8e6cd303a6dabd73", + "name": "google-api-core-grpcio-gcp", + "sha256": "18c8ea5c18427c0753a287f84b5d62649abd04e07289d2ae01ee822bad738370", + "size": 10342, + "subdir": "linux-64", + "timestamp": 1604438278206, + "version": "1.20.0" + }, + "google-api-core-grpcio-gcp-1.22.2-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "google-api-core >=1.22,<1.23.0a0", + "grpcio-gcp" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "758f8a8bf256e91a07ca0c6353e25acb", + "name": "google-api-core-grpcio-gcp", + "sha256": "be0c06196a16edfb119c84b934f2519ddca8dd697983c3a305755e089733f220", + "size": 10306, + "subdir": "linux-64", + "timestamp": 1601307107546, + "version": "1.22.2" + }, + "google-api-core-grpcio-gcp-1.25.1-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.25,<1.26.0a0", + "grpcio-gcp" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c2b4de217e041b0389d5618245de2d15", + "name": "google-api-core-grpcio-gcp", + "sha256": "c7915e95a0b4dda8c252ee96990dc3d27358b96cea8b1c121cb7bde898b2ed49", + "size": 11961, + "subdir": "linux-64", + "timestamp": 1613979816578, + "version": "1.25.1" + }, + "google-api-core-grpcio-gcp-2.10.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py310h06a4308_0", + "grpcio-gcp >=0.2.2,<1.0dev", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "be71939b20c1ae00dde94451bd04efee", + "name": "google-api-core-grpcio-gcp", + "sha256": "938eb4e5cb8e21eaf414baabc694193759790e370fed136435e0a4f65f724468", + "size": 4365, + "subdir": "linux-64", + "timestamp": 1663638683445, + "version": "2.10.1" + }, + "google-api-core-grpcio-gcp-2.10.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py311h06a4308_0", + "grpcio-gcp >=0.2.2,<1.0dev", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9d7356c3b570465981f2bcf7ccbd6249", + "name": "google-api-core-grpcio-gcp", + "sha256": "a4b65e5915a596761d5b9956f10290eea760de4af815ab57cba24d408db5216e", + "size": 4728, + "subdir": "linux-64", + "timestamp": 1676839897181, + "version": "2.10.1" + }, + "google-api-core-grpcio-gcp-2.10.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py37h06a4308_0", + "grpcio-gcp >=0.2.2,<1.0dev", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "2260495c816fdbbafa9e49e6719e9c69", + "name": "google-api-core-grpcio-gcp", + "sha256": "d81164e8f0e974e5d561e2db8f6ca6665295247d6c954caf3dcdf2cd47e699bc", + "size": 4340, + "subdir": "linux-64", + "timestamp": 1663638881968, + "version": "2.10.1" + }, + "google-api-core-grpcio-gcp-2.10.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py38h06a4308_0", + "grpcio-gcp >=0.2.2,<1.0dev", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ea4689ebd5703144618a5eb8b80de189", + "name": "google-api-core-grpcio-gcp", + "sha256": "a83631bd9c811fc42b648beea40dc2f7115b5c31c03c51f51ad93116ab62b711", + "size": 4336, + "subdir": "linux-64", + "timestamp": 1663638816857, + "version": "2.10.1" + }, + "google-api-core-grpcio-gcp-2.10.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core 2.10.1 py39h06a4308_0", + "grpcio-gcp >=0.2.2,<1.0dev", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "981ee5c0d63d3de5490c6abd23625421", + "name": "google-api-core-grpcio-gcp", + "sha256": "b32255a8e9f678e6cfeabd17546f5a38fce94ee16ede16b5a4e413df048f0577", + "size": 4341, + "subdir": "linux-64", + "timestamp": 1663638751134, + "version": "2.10.1" + }, + "google-auth-oauthlib-0.5.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click >=6.0.0", + "google-auth >=1.0.0", + "python >=3.10,<3.11.0a0", + "requests-oauthlib >=0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0fc87b2a63236b7ed878a8fc45ef93d6", + "name": "google-auth-oauthlib", + "sha256": "ed16a225449c1a991776bdf28aa8551445c0abac50dca1de7e344f6991eee2b1", + "size": 25763, + "subdir": "linux-64", + "timestamp": 1660687833850, + "version": "0.5.2" + }, + "google-auth-oauthlib-0.5.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "click >=6.0.0", + "google-auth >=1.0.0", + "python >=3.11,<3.12.0a0", + "requests-oauthlib >=0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "97e7ddc4e06a301a313fa9a473de9946", + "name": "google-auth-oauthlib", + "sha256": "618478214b5f89ae8bc8977d31a884635ddd2425da126ac7f02ee59e4dcecd12", + "size": 28955, + "subdir": "linux-64", + "timestamp": 1679340700723, + "version": "0.5.2" + }, + "google-auth-oauthlib-0.5.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click >=6.0.0", + "google-auth >=1.0.0", + "python >=3.7,<3.8.0a0", + "requests-oauthlib >=0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fb3fdc3bddeb8dc02dcc0b2bfd01198b", + "name": "google-auth-oauthlib", + "sha256": "79ca8acd555a1ba82bb42f140bcc0ea13f1b531b23d0891766ca7700ee38a20e", + "size": 25559, + "subdir": "linux-64", + "timestamp": 1660687894514, + "version": "0.5.2" + }, + "google-auth-oauthlib-0.5.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=6.0.0", + "google-auth >=1.0.0", + "python >=3.8,<3.9.0a0", + "requests-oauthlib >=0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5d2f15d945777788b11f465a89fdfa73", + "name": "google-auth-oauthlib", + "sha256": "3fe69314d570fa2203d121f8b9596f9aa5c8dee9b1d1a0e8c851e3d2f8db285c", + "size": 25491, + "subdir": "linux-64", + "timestamp": 1660687864157, + "version": "0.5.2" + }, + "google-auth-oauthlib-0.5.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=6.0.0", + "google-auth >=1.0.0", + "python >=3.9,<3.10.0a0", + "requests-oauthlib >=0.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a7c709011014351d68c58f62473551fb", + "name": "google-auth-oauthlib", + "sha256": "07d7bb390af6c83240d61109f5ad0c1f9c546a62d540e1ce92d16c4fb44bf07e", + "size": 25614, + "subdir": "linux-64", + "timestamp": 1660687928336, + "version": "0.5.2" + }, + "google-cloud-core-2.3.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.6,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0.0dev", + "grpcio >=1.38.0,<2.0.0dev", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7f70750394ec438b0487f14091346462", + "name": "google-cloud-core", + "sha256": "7bc7dbc4eab077f83d9a383c59d5dee261c7e87a00c10e3b63e4737642bc3e6b", + "size": 38671, + "subdir": "linux-64", + "timestamp": 1666887837161, + "version": "2.3.2" + }, + "google-cloud-core-2.3.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.6,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0.0dev", + "grpcio >=1.38.0,<2.0.0dev", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "49073562834056abebc30d8b28127b37", + "name": "google-cloud-core", + "sha256": "ef582c0bbe35c183d017f93cd3e8ff4591613962406845e5fca01a552ae56810", + "size": 45876, + "subdir": "linux-64", + "timestamp": 1676844197302, + "version": "2.3.2" + }, + "google-cloud-core-2.3.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.6,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0.0dev", + "grpcio >=1.38.0,<2.0.0dev", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ce38ebbcce448f76f5569cf83599b754", + "name": "google-cloud-core", + "sha256": "e1a620ff4e52887bc11d486ad8d3438e4e8ecf18be4cd06d06cbc0e45f144409", + "size": 38303, + "subdir": "linux-64", + "timestamp": 1666887779483, + "version": "2.3.2" + }, + "google-cloud-core-2.3.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.6,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0.0dev", + "grpcio >=1.38.0,<2.0.0dev", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "09bf877a0f2673371d9b1814d81464cc", + "name": "google-cloud-core", + "sha256": "221c3380d44dff4f1c9333b269b55c4d084f74d5140eb83e6a1e9999359c57fa", + "size": 38472, + "subdir": "linux-64", + "timestamp": 1666887808369, + "version": "2.3.2" + }, + "google-cloud-core-2.3.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.6,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0.0dev", + "grpcio >=1.38.0,<2.0.0dev", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cb6b7fca889a60e592240acaef6da95f", + "name": "google-cloud-core", + "sha256": "a2a5a6f38ac082c29b5916254c25f26ff182e8549a90a04b97fbd53e6a716416", + "size": 38463, + "subdir": "linux-64", + "timestamp": 1666887750381, + "version": "2.3.2" + }, + "google-cloud-storage-1.43.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.29.0,<3.0dev", + "google-auth >=1.25.0,<3.0dev", + "google-cloud-core >=1.6.0,<3.0dev", + "google-resumable-media >=1.3.0,<3.0dev", + "protobuf", + "python >=3.10,<3.11.0a0", + "requests >=2.18.0,<3.0.0dev", + "six" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c63d143cb48673de700704700806f83b", + "name": "google-cloud-storage", + "sha256": "4f8e9d9f21c45221eb7806afa01ea390ce039c1400eb72c9f84515696c35df05", + "size": 123239, + "subdir": "linux-64", + "timestamp": 1654699272170, + "version": "1.43.0" + }, + "google-cloud-storage-1.43.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.29.0,<3.0dev", + "google-auth >=1.25.0,<3.0dev", + "google-cloud-core >=1.6.0,<3.0dev", + "google-resumable-media >=1.3.0,<3.0dev", + "protobuf", + "python >=3.7,<3.8.0a0", + "requests >=2.18.0,<3.0.0dev", + "six" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ca19ca1e045ac2026a13d0b7ee268515", + "name": "google-cloud-storage", + "sha256": "4802e37a050c51faa05690ba321d0b22c302319ac1e8567e907b0a5b0a3f992a", + "size": 121143, + "subdir": "linux-64", + "timestamp": 1654699305227, + "version": "1.43.0" + }, + "google-cloud-storage-1.43.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.29.0,<3.0dev", + "google-auth >=1.25.0,<3.0dev", + "google-cloud-core >=1.6.0,<3.0dev", + "google-resumable-media >=1.3.0,<3.0dev", + "protobuf", + "python >=3.8,<3.9.0a0", + "requests >=2.18.0,<3.0.0dev", + "six" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f99515479fb24021ebeab71ce72c3367", + "name": "google-cloud-storage", + "sha256": "10df6db3beeb14440a7a490b2c90e4b3c80ed8546c48f11e1ae5900dd923f51b", + "size": 121835, + "subdir": "linux-64", + "timestamp": 1654699337624, + "version": "1.43.0" + }, + "google-cloud-storage-1.43.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.29.0,<3.0dev", + "google-auth >=1.25.0,<3.0dev", + "google-cloud-core >=1.6.0,<3.0dev", + "google-resumable-media >=1.3.0,<3.0dev", + "protobuf", + "python >=3.9,<3.10.0a0", + "requests >=2.18.0,<3.0.0dev", + "six" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "19cb432e08343a8b3a987306270ba03e", + "name": "google-cloud-storage", + "sha256": "6713cf30fb689e050544c2da21fe08084a0a4cdb1f26fe5871fda4880f24a8b5", + "size": 121821, + "subdir": "linux-64", + "timestamp": 1654699227079, + "version": "1.43.0" + }, + "google-cloud-storage-2.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.5,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0dev", + "google-cloud-core >=2.3.0,<3.0dev", + "google-resumable-media >=2.3.2", + "protobuf <5.0.0dev", + "python >=3.10,<3.11.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a1441b8d9dc769fca6bb44c8bb6eee43", + "name": "google-cloud-storage", + "sha256": "e65df446456cb8f5229242321911a14c1bb66e4a5fb5a6d20d06f3bff75ea6a4", + "size": 130029, + "subdir": "linux-64", + "timestamp": 1668474027043, + "version": "2.6.0" + }, + "google-cloud-storage-2.6.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.5,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0dev", + "google-cloud-core >=2.3.0,<3.0dev", + "google-resumable-media >=2.3.2", + "protobuf <5.0.0dev", + "python >=3.11,<3.12.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ce60ef9e9e4af86a6b2c61e3d3de6c2d", + "name": "google-cloud-storage", + "sha256": "c2b05e8b072e9cc5250cafbd01725834f3deb03c697f272e41cd2fcf637b3d8c", + "size": 149814, + "subdir": "linux-64", + "timestamp": 1676852626027, + "version": "2.6.0" + }, + "google-cloud-storage-2.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.5,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0dev", + "google-cloud-core >=2.3.0,<3.0dev", + "google-resumable-media >=2.3.2", + "protobuf <5.0.0dev", + "python >=3.7,<3.8.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "39570a6aa1c1c9d60217671d127e3cd7", + "name": "google-cloud-storage", + "sha256": "6ebfa2f5c9c7edbb3bc99a8edf88d2c2f8519efcd4b114d1168858e7cc7b6c62", + "size": 128274, + "subdir": "linux-64", + "timestamp": 1668474056822, + "version": "2.6.0" + }, + "google-cloud-storage-2.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.5,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0dev", + "google-cloud-core >=2.3.0,<3.0dev", + "google-resumable-media >=2.3.2", + "protobuf <5.0.0dev", + "python >=3.8,<3.9.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b4d318c7bfb6b79cb5c9e2ba1d543fbb", + "name": "google-cloud-storage", + "sha256": "1eca1a9ce070fc86f53c646c86ac52212f734fbe1d069075966ac888ae389667", + "size": 129120, + "subdir": "linux-64", + "timestamp": 1668473997181, + "version": "2.6.0" + }, + "google-cloud-storage-2.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "google-api-core >=1.31.5,<3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", + "google-auth >=1.25.0,<3.0dev", + "google-cloud-core >=2.3.0,<3.0dev", + "google-resumable-media >=2.3.2", + "protobuf <5.0.0dev", + "python >=3.9,<3.10.0a0", + "requests >=2.18.0,<3.0.0dev" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9439ccfa1030e170dbf78b2191efcf38", + "name": "google-cloud-storage", + "sha256": "0d0c8d9b0c43de2d3f3aa4b05e0247d0782cfb5d35301a1459d67796e0d578ae", + "size": 128970, + "subdir": "linux-64", + "timestamp": 1668473967548, + "version": "2.6.0" + }, + "google-crc32c-1.0.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "354d699eefbdd0ac89ba2d09848af391", + "name": "google-crc32c", + "sha256": "8536a597d8e133ce307390adecdbd723bdd0d96d6842677f59d8234fd87294e3", + "size": 24974, + "subdir": "linux-64", + "timestamp": 1601305151291, + "version": "1.0.0" + }, + "google-crc32c-1.0.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "73d46ab2214cb9b33e35948d0c8374cc", + "name": "google-crc32c", + "sha256": "53d2dd6acb4a9ccd5d3e13a602905ba0a9ce8407de8d7aaafdd31af04afabfa9", + "size": 25065, + "subdir": "linux-64", + "timestamp": 1601305142179, + "version": "1.0.0" + }, + "google-crc32c-1.0.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7ec0de5e6072c5092c9d79eed58fc9c7", + "name": "google-crc32c", + "sha256": "a30b19e968afa7375e598dfcf6d2201f581710b5623302a2ff7bf0932f70401f", + "size": 25129, + "subdir": "linux-64", + "timestamp": 1601305146818, + "version": "1.0.0" + }, + "google-crc32c-1.1.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e8530f89a652ebddf410edb107ffd70c", + "name": "google-crc32c", + "sha256": "b0213996bf93da230fc66a7cfb8095efdf04b8e54a214dea907a6972c2095cda", + "size": 23985, + "subdir": "linux-64", + "timestamp": 1608071254553, + "version": "1.1.0" + }, + "google-crc32c-1.1.0-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "22befdbe3c4f1a2fece047e7ccd442c3", + "name": "google-crc32c", + "sha256": "d760e38081db0503135727d10bd0b8a48a3498770ac9c632d63d501e0d03ae9e", + "size": 23803, + "subdir": "linux-64", + "timestamp": 1608056225027, + "version": "1.1.0" + }, + "google-crc32c-1.1.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9e267f829e89ae55220e37dd5c1a2d6c", + "name": "google-crc32c", + "sha256": "badb017c9719855ee7758d0889766f305e85c604304da82403691c5130498a4d", + "size": 23888, + "subdir": "linux-64", + "timestamp": 1608071247207, + "version": "1.1.0" + }, + "google-crc32c-1.1.0-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7969153da4700336d9489a4f6a4bf9db", + "name": "google-crc32c", + "sha256": "95a540885af3597b0284dbcd409d3d5a3be873bda54f0167072e518bbbb63184", + "size": 23801, + "subdir": "linux-64", + "timestamp": 1608056274376, + "version": "1.1.0" + }, + "google-crc32c-1.1.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3e79d5a1f68351cab3563f0434e4778f", + "name": "google-crc32c", + "sha256": "bbc79e6cc6b46b50f82322836992d6d8919511cfe95394bfddda28f21c9bac32", + "size": 23970, + "subdir": "linux-64", + "timestamp": 1608071253573, + "version": "1.1.0" + }, + "google-crc32c-1.1.0-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e3907f6f0b095a630ca55c32407102f6", + "name": "google-crc32c", + "sha256": "9cab80b6f7e0141ff86eae7ba759cc1c0f48a27553524f39d0a5348e74ec1800", + "size": 23937, + "subdir": "linux-64", + "timestamp": 1608056268496, + "version": "1.1.0" + }, + "google-crc32c-1.1.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ef6dc991d4a8a461cbbb211a2249b319", + "name": "google-crc32c", + "sha256": "bbefe50ff1d19e4e8f9a2cf863154b4e90c35d3cb122571c2d0319a2baa4b05b", + "size": 23385, + "subdir": "linux-64", + "timestamp": 1608071208786, + "version": "1.1.0" + }, + "google-crc32c-1.1.0-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aef724f95a173a7a0d66a1b55d4567db", + "name": "google-crc32c", + "sha256": "d6a2d6f5c9bf1525100c720d32c142c69d0f23cb00c5df032511b09eb8f35214", + "size": 23489, + "subdir": "linux-64", + "timestamp": 1608056271836, + "version": "1.1.0" + }, + "google-crc32c-1.1.1-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2af0e63830235277619ca3a45f9de5e6", + "name": "google-crc32c", + "sha256": "82d4eb2889c45be87003bc25e533e2d8ef33929042b01df1a09b345f1734a6e5", + "size": 23068, + "subdir": "linux-64", + "timestamp": 1610650056180, + "version": "1.1.1" + }, + "google-crc32c-1.1.1-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7c1c6b2bc0dbbbc859f3b35212638d71", + "name": "google-crc32c", + "sha256": "aee3d3f2da16ae2020a81497853d19644fb8df4873a681d06a94436d589ff487", + "size": 22997, + "subdir": "linux-64", + "timestamp": 1610650048641, + "version": "1.1.1" + }, + "google-crc32c-1.1.1-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6d03b6ecb5a63c77f3be237ae1cd4be8", + "name": "google-crc32c", + "sha256": "fb10c2825e1c83bd88761eef26eba6b064fcd706e0e17a4dda87a5b0a19b60da", + "size": 22922, + "subdir": "linux-64", + "timestamp": 1610649479800, + "version": "1.1.1" + }, + "google-crc32c-1.1.1-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b69ec704133e9fbeadd2d44262b362c9", + "name": "google-crc32c", + "sha256": "64ca3393dd91995772b3bad3a8abc7df52da3caedeacc7847506167f911900d8", + "size": 22596, + "subdir": "linux-64", + "timestamp": 1610650039816, + "version": "1.1.1" + }, + "google-crc32c-1.1.2-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "41544ec3d04ceaf199953a7987f42a55", + "name": "google-crc32c", + "sha256": "0b28ed8beeed92ed1c53114b51f54c1bd2eb3eef936149005ce10da2fc808478", + "size": 29512, + "subdir": "linux-64", + "timestamp": 1640809226323, + "version": "1.1.2" + }, + "google-crc32c-1.1.2-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f361a3b4dc4a9cae14eb32bcf3449e05", + "name": "google-crc32c", + "sha256": "ef82c203c0c1459dc4ea404dca78d4f17c5a773414c11adb59cd5cf0cde1d805", + "size": 23169, + "subdir": "linux-64", + "timestamp": 1612242779739, + "version": "1.1.2" + }, + "google-crc32c-1.1.2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6fdf15b07b530cc9e27be5040568b838", + "name": "google-crc32c", + "sha256": "98cfbc708f33f561d8620cad9e9a1c27b83a909d7bd834f11f072589fccb0573", + "size": 22974, + "subdir": "linux-64", + "timestamp": 1612242973516, + "version": "1.1.2" + }, + "google-crc32c-1.1.2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a911894f53c5ce45c4979fc9198edfef", + "name": "google-crc32c", + "sha256": "85daa20cf33b878b2a30855c6d58c229821c31cabd42157f7b1dd756d430900b", + "size": 23124, + "subdir": "linux-64", + "timestamp": 1612242978327, + "version": "1.1.2" + }, + "google-crc32c-1.1.2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libcrc32c >=1.1.1,<1.2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b0dfbc337e876600be27e6eb4cc873b5", + "name": "google-crc32c", + "sha256": "67d5dcd2f4190c137e4021a6fffa3f2b0b9d8107d81f5abc79176fe95f8d4801", + "size": 22628, + "subdir": "linux-64", + "timestamp": 1612242979913, + "version": "1.1.2" + }, + "google-crc32c-1.5.0-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libcrc32c >=1.1.2,<1.2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "460480b8837d484a4a19ae67cd875a05", + "name": "google-crc32c", + "sha256": "6994f32a1d982a6fde5b8093d3d5a2993887a9e58a401d36c28f59e87b332ff9", + "size": 24314, + "subdir": "linux-64", + "timestamp": 1667946656002, + "version": "1.5.0" + }, + "google-crc32c-1.5.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libcrc32c >=1.1.2,<1.2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ff8f3df7b28f250f16220cedc17eaa61", + "name": "google-crc32c", + "sha256": "1e7aebf50ba59cf92269a702e4224caa1b81027bea51006d08c7989466d14dd2", + "size": 24501, + "subdir": "linux-64", + "timestamp": 1676839918213, + "version": "1.5.0" + }, + "google-crc32c-1.5.0-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libcrc32c >=1.1.2,<1.2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4b1ff9e29266df1c6c785dd599ae5f3e", + "name": "google-crc32c", + "sha256": "172661f940cbf4ed26b9ea0175e69df546dc51a2af3e5d6d5fa11d00fec0449a", + "size": 24695, + "subdir": "linux-64", + "timestamp": 1667946684560, + "version": "1.5.0" + }, + "google-crc32c-1.5.0-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libcrc32c >=1.1.2,<1.2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b10c2d1b9247f870e825fcf18b0e2e1f", + "name": "google-crc32c", + "sha256": "97cccc2588f4e6363a2648398a8ab7c36f1eecfa03e4094217673231a1e86ef5", + "size": 24630, + "subdir": "linux-64", + "timestamp": 1667946741380, + "version": "1.5.0" + }, + "google-crc32c-1.5.0-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libcrc32c >=1.1.2,<1.2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9dd1df957f167c82b34e4221764f8ca4", + "name": "google-crc32c", + "sha256": "08f25631f3d4f356927f1289699d58c2c8250244e8a980aaa2f110f2ee0af3a2", + "size": 24200, + "subdir": "linux-64", + "timestamp": 1667946713063, + "version": "1.5.0" + }, + "google-resumable-media-2.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "requests >=2.18.0,<3.0.0dev", + "aiohttp >=3.6.2,<4.0.0dev" + ], + "depends": [ + "google-crc32c >=1.0,<2.0dev", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a482849cf89ff21e3d74a86c4aef7f72", + "name": "google-resumable-media", + "sha256": "2f5a0ca73757d844975bd1387cb236f737ca65c6b5f0b56033b3d8c816af750d", + "size": 62983, + "subdir": "linux-64", + "timestamp": 1668208245495, + "version": "2.4.0" + }, + "google-resumable-media-2.4.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "aiohttp >=3.6.2,<4.0.0dev", + "requests >=2.18.0,<3.0.0dev" + ], + "depends": [ + "google-crc32c >=1.0,<2.0dev", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "becead5810eb4c263f2b280723b3e3fc", + "name": "google-resumable-media", + "sha256": "23a0deb547b7de1e5dfb6ab4b2b46bc9022f985cdd42e6c5c96fe79b1a15b263", + "size": 72458, + "subdir": "linux-64", + "timestamp": 1676844211888, + "version": "2.4.0" + }, + "google-resumable-media-2.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "requests >=2.18.0,<3.0.0dev", + "aiohttp >=3.6.2,<4.0.0dev" + ], + "depends": [ + "google-crc32c >=1.0,<2.0dev", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8fdaaf736d74e8a36c0f02c7410fe5ef", + "name": "google-resumable-media", + "sha256": "fa8093403472fffd193b8197b1efe4ab59e171cb639ff47f3470f55cfebe94ba", + "size": 62399, + "subdir": "linux-64", + "timestamp": 1668208219765, + "version": "2.4.0" + }, + "google-resumable-media-2.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "requests >=2.18.0,<3.0.0dev", + "aiohttp >=3.6.2,<4.0.0dev" + ], + "depends": [ + "google-crc32c >=1.0,<2.0dev", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "18e110e28199b03c464c2903e04e6e4c", + "name": "google-resumable-media", + "sha256": "e7e6c7f394653fe0cc3b9a2b9806d162d241cda5b119db106a408dc96d5c55a0", + "size": 62549, + "subdir": "linux-64", + "timestamp": 1668208295643, + "version": "2.4.0" + }, + "google-resumable-media-2.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "requests >=2.18.0,<3.0.0dev", + "aiohttp >=3.6.2,<4.0.0dev" + ], + "depends": [ + "google-crc32c >=1.0,<2.0dev", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9a3c86cda7c58d07615c7004ffd45f8c", + "name": "google-resumable-media", + "sha256": "5604071e39d678d5e35e5a323444b038605a9c110658d0561bfc34c7ebee5187", + "size": 62698, + "subdir": "linux-64", + "timestamp": 1668208270634, + "version": "2.4.0" + }, + "googleapis-common-protos-1.5.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "ab23e79609d039f98f58153d1e3eb9e8", + "name": "googleapis-common-protos", + "sha256": "9edcf0500f2bcd0a34c9d88ad0f5c3f335a1520b1f528153c3e13c601d681f8f", + "size": 76542, + "subdir": "linux-64", + "timestamp": 1558590757407, + "version": "1.5.10" + }, + "googleapis-common-protos-1.5.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "b64def4520e7e83a050c9e10a79b1cb9", + "name": "googleapis-common-protos", + "sha256": "7b3ac72c698290b631e898ead5c20bfc4038bedb758a8982ea78afb5b0e33c24", + "size": 75102, + "subdir": "linux-64", + "timestamp": 1558590445353, + "version": "1.5.10" + }, + "googleapis-common-protos-1.5.10-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "cd6accd7a002bc09a6689afbe67dbd80", + "name": "googleapis-common-protos", + "sha256": "8a52db06e7a4311d739902610d4a0f0c9839a4a1007640ad8277d5c5f2eaa3ef", + "size": 74870, + "subdir": "linux-64", + "timestamp": 1558590591360, + "version": "1.5.10" + }, + "googleapis-common-protos-1.51.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "protobuf", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "cb0ec030ea905033a416e3189577a377", + "name": "googleapis-common-protos", + "sha256": "fe271d0f3aa3df651e14f9193b63e699bbb40689398f7069287d8f8bbab2ebe0", + "size": 72798, + "subdir": "linux-64", + "timestamp": 1581952484222, + "version": "1.51.0" + }, + "googleapis-common-protos-1.51.0-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "protobuf", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "8df5b4ceefa9328b834ac52c8c2a880e", + "name": "googleapis-common-protos", + "sha256": "7247f30d30669888b242546fb0fa11b955f068b24047e7d851413656938afa5c", + "size": 73819, + "subdir": "linux-64", + "timestamp": 1586570305655, + "version": "1.51.0" + }, + "googleapis-common-protos-1.51.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "93f478ff8e5d184a1046de85189019eb", + "name": "googleapis-common-protos", + "sha256": "6305bcccad24aba369a96930ca3a979c0e043807a5a3d8332a40483af28ed201", + "size": 69398, + "subdir": "linux-64", + "timestamp": 1594357250343, + "version": "1.51.0" + }, + "googleapis-common-protos-1.51.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "protobuf", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "c579fed7efcb827759f9f991928388b5", + "name": "googleapis-common-protos", + "sha256": "c90a08757dd610528a4f38cb9c073ea1d87ad092102812d784c3d30b5860dac3", + "size": 73286, + "subdir": "linux-64", + "timestamp": 1581952473748, + "version": "1.51.0" + }, + "googleapis-common-protos-1.51.0-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "protobuf", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "f6ead32a1f89c8f78de6c080191ee08e", + "name": "googleapis-common-protos", + "sha256": "e7eaf461b29de2f90a9265226f3f03ec0d187284939244651aa3a20312bc9a19", + "size": 73854, + "subdir": "linux-64", + "timestamp": 1586570291236, + "version": "1.51.0" + }, + "googleapis-common-protos-1.51.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "protobuf", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "f7e918c38dc0dc0612eb02ded7cac91d", + "name": "googleapis-common-protos", + "sha256": "708929f05de505599294935888b86493782523723edfef749e49384ad37d244a", + "size": 73713, + "subdir": "linux-64", + "timestamp": 1581952492517, + "version": "1.51.0" + }, + "googleapis-common-protos-1.51.0-py38_2.conda": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "protobuf", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "02d2fdf3091d2438c0d06f5caf5f25c3", + "name": "googleapis-common-protos", + "sha256": "ca2ac00b8b11e02cccd2c31c8425db55090f7ac62bd9f00153eae83b01f6b81f", + "size": 74432, + "subdir": "linux-64", + "timestamp": 1586570294724, + "version": "1.51.0" + }, + "googleapis-common-protos-1.52.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e82bc3cd56f759310d0fc5389a9e314e", + "name": "googleapis-common-protos", + "sha256": "b13d3209fae778262fe8413350bc3d2a303b30383edee5db25018857293cb04e", + "size": 84077, + "subdir": "linux-64", + "timestamp": 1600455697070, + "version": "1.52.0" + }, + "googleapis-common-protos-1.52.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ac750c41972076fbe49d7269586e6855", + "name": "googleapis-common-protos", + "sha256": "67c9f6bce071fce5656d9eb684ccd0999029fe35829105e88485db65ca2f898e", + "size": 84535, + "subdir": "linux-64", + "timestamp": 1613732403584, + "version": "1.52.0" + }, + "googleapis-common-protos-1.52.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a307cf453847cf188ef1c8501bb87aae", + "name": "googleapis-common-protos", + "sha256": "e2221faee4476cb8509922d3107fa902e5f0062f708dc31308e7ba533e3ebe04", + "size": 84420, + "subdir": "linux-64", + "timestamp": 1600455653639, + "version": "1.52.0" + }, + "googleapis-common-protos-1.52.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b8afb7fab6062bb6890952d73b5a1cea", + "name": "googleapis-common-protos", + "sha256": "b991b2d456d50f5e73d06a35ea03f66e7e1c132f113871c437ccfeba952d16b0", + "size": 84293, + "subdir": "linux-64", + "timestamp": 1613732402313, + "version": "1.52.0" + }, + "googleapis-common-protos-1.52.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "cf4bfdc6d46f3635362c66bf0f065c23", + "name": "googleapis-common-protos", + "sha256": "022ab87be86915f30707bd80dbba58a28df560788c9a1abe8ff7c2ae0cc4425c", + "size": 84940, + "subdir": "linux-64", + "timestamp": 1600455687368, + "version": "1.52.0" + }, + "googleapis-common-protos-1.52.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f3b54b17ebab3c6d7f55d09486ad28f0", + "name": "googleapis-common-protos", + "sha256": "8fc92f270a4e01ed87aa4440d8f77fc2cb1a67d1d9217a213ad457196e909d5f", + "size": 85033, + "subdir": "linux-64", + "timestamp": 1613732409647, + "version": "1.52.0" + }, + "googleapis-common-protos-1.52.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "3e25082a9027bdd0815fe2194f761b25", + "name": "googleapis-common-protos", + "sha256": "b049c3c869d41e99d26ca49c044a2c91ebdd5e7f28a3e64a9070a951efc95f90", + "size": 85267, + "subdir": "linux-64", + "timestamp": 1613731664596, + "version": "1.52.0" + }, + "googleapis-common-protos-1.53.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.12.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "bbc4905a0beda840ad25087db213338e", + "name": "googleapis-common-protos", + "sha256": "0191f6545c9a31c8a658b8462a6f1fdf7b7324cb0132329a9b5357728ad0e014", + "size": 135912, + "subdir": "linux-64", + "timestamp": 1640809266383, + "version": "1.53.0" + }, + "googleapis-common-protos-1.53.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.12.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "acfa81198fe4666d73cab64f63bc51c8", + "name": "googleapis-common-protos", + "sha256": "27e089885cc766b8ce332b96919e901433e086a613f2b06665d619e693304adf", + "size": 137520, + "subdir": "linux-64", + "timestamp": 1617957353130, + "version": "1.53.0" + }, + "googleapis-common-protos-1.53.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.12.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ed961ea99ddf773a435c17553d36fd5c", + "name": "googleapis-common-protos", + "sha256": "bd2658f27c9a868e70bea87fa2b71c0c6ba4b63110d37e735b6259382ee5ef20", + "size": 137725, + "subdir": "linux-64", + "timestamp": 1617957697684, + "version": "1.53.0" + }, + "googleapis-common-protos-1.53.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.12.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "2ccd15aca4b8e21c02e050ebd7ba7976", + "name": "googleapis-common-protos", + "sha256": "44d8e3cd25f19ea6582e22522a069b7f870544c72237dc744b7879f243dc6f01", + "size": 137774, + "subdir": "linux-64", + "timestamp": 1617957704740, + "version": "1.53.0" + }, + "googleapis-common-protos-1.53.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.12.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "fc7cc35935d0977bfea68def6d8dedfe", + "name": "googleapis-common-protos", + "sha256": "af7794be29d8c252ebe65178630f132135625f2a1e4a4a830f8f0cfc7683b240", + "size": 138254, + "subdir": "linux-64", + "timestamp": 1617957709296, + "version": "1.53.0" + }, + "googleapis-common-protos-1.56.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio >=1.0.0,<2.0.0" + ], + "depends": [ + "libprotobuf", + "protobuf >=3.15.0,<5.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "4814bc445492e800407c07a6fd8b204d", + "name": "googleapis-common-protos", + "sha256": "fd51c83a05448bf15bcd92e7a39d0b3c91cb30eb98324d12a13e6f285cb91161", + "size": 132058, + "subdir": "linux-64", + "timestamp": 1660256275429, + "version": "1.56.4" + }, + "googleapis-common-protos-1.56.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio >=1.0.0,<2.0.0" + ], + "depends": [ + "libprotobuf", + "protobuf >=3.15.0,<5.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b52649db22ea28d826db68a9c3bffea2", + "name": "googleapis-common-protos", + "sha256": "3140f62958afead4a51cfca9f68633fc312a0fe605a297f2695c10bbe40a91ab", + "size": 140432, + "subdir": "linux-64", + "timestamp": 1676830589102, + "version": "1.56.4" + }, + "googleapis-common-protos-1.56.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio >=1.0.0,<2.0.0" + ], + "depends": [ + "libprotobuf", + "protobuf >=3.15.0,<5.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e97854b66532d049b1b45f492e0050b8", + "name": "googleapis-common-protos", + "sha256": "13081a5391ea0ed042b043b1ab67559ab36a2320d5cbd43b280a481f56053ad4", + "size": 131757, + "subdir": "linux-64", + "timestamp": 1660256288704, + "version": "1.56.4" + }, + "googleapis-common-protos-1.56.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio >=1.0.0,<2.0.0" + ], + "depends": [ + "libprotobuf", + "protobuf >=3.15.0,<5.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "de0526ae87d2cd12e698f5ef3ecdef38", + "name": "googleapis-common-protos", + "sha256": "72a4d3e47af7520e4c330244e8f5d3be4c5cbd083f4457b04ca627899d834aa5", + "size": 131853, + "subdir": "linux-64", + "timestamp": 1660256245839, + "version": "1.56.4" + }, + "googleapis-common-protos-1.56.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "grpcio >=1.0.0,<2.0.0" + ], + "depends": [ + "libprotobuf", + "protobuf >=3.15.0,<5.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e35c9e845ff4208c45e177f9692299fe", + "name": "googleapis-common-protos", + "sha256": "5338f16b76e671104dcb12659683fffbce81a4c56c68bd801638254452a559d7", + "size": 131823, + "subdir": "linux-64", + "timestamp": 1660256263647, + "version": "1.56.4" + }, + "googleapis-common-protos-1.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "f6589c9aac09739b070d529967538b6a", + "name": "googleapis-common-protos", + "sha256": "5ce41baddb9b0da62c6e4633d83f196c8cd796a4810f671bbd3e5ab9e96ed22c", + "size": 74546, + "subdir": "linux-64", + "timestamp": 1564754286136, + "version": "1.6.0" + }, + "googleapis-common-protos-1.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "2b8384d28b4cd7964ed027eb58e58082", + "name": "googleapis-common-protos", + "sha256": "d09a2b47c8791c4b6de074077e33e30b42ec29085679656f2de25232aabb05a8", + "size": 73086, + "subdir": "linux-64", + "timestamp": 1564753971037, + "version": "1.6.0" + }, + "googleapis-common-protos-1.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "dd83c88b7ffe404de0ffe36c3ba828e1", + "name": "googleapis-common-protos", + "sha256": "60af24cfe02ab9477231d70d37f273b43ca58b7993d2242499bb342b68db9cbc", + "size": 72899, + "subdir": "linux-64", + "timestamp": 1564753984318, + "version": "1.6.0" + }, + "googleapis-common-protos-1.6.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "protobuf", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "9f34db1e6add33a43be035df22040815", + "name": "googleapis-common-protos", + "sha256": "a81c15a749b2ba9b7cfa58e85b4b34a30946fcaae1a640a0696e2576519b5fa3", + "size": 70455, + "subdir": "linux-64", + "timestamp": 1574252034007, + "version": "1.6.0" + }, + "googleapis-common-protos-grpc-1.5.10-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.5,<1.6.0a0", + "grpcio" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "ef88a4830366725b2be65c0817dc19c8", + "name": "googleapis-common-protos-grpc", + "sha256": "3e13c69ba3f8ef041b299b4a84ad6b1d2583608cea3d8e342d784535f976346f", + "size": 9511, + "subdir": "linux-64", + "timestamp": 1558590805617, + "version": "1.5.10" + }, + "googleapis-common-protos-grpc-1.51.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.51,<1.52.0a0", + "grpcio" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "434ddb5226578649adcb7e38055db76c", + "name": "googleapis-common-protos-grpc", + "sha256": "dc87a408c0fb5fa0b8ac2a03e4b8cc6b231745dc083bf875a584166293a1798b", + "size": 9730, + "subdir": "linux-64", + "timestamp": 1594357258377, + "version": "1.51.0" + }, + "googleapis-common-protos-grpc-1.51.0-1.conda": { + "build": "1", + "build_number": 1, + "depends": [ + "googleapis-common-protos >=1.51,<1.52.0a0", + "grpcio" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "65935475d94b5a20a0bed95f3100e59e", + "name": "googleapis-common-protos-grpc", + "sha256": "1615bf959be12d41d2012c0dacf1bea60f9ce10906bda33197c16ee13eba5080", + "size": 14108, + "subdir": "linux-64", + "timestamp": 1581952503996, + "version": "1.51.0" + }, + "googleapis-common-protos-grpc-1.51.0-2.conda": { + "build": "2", + "build_number": 2, + "depends": [ + "googleapis-common-protos >=1.51,<1.52.0a0", + "grpcio" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "aaf1a2ca6a73b3c5f8a403935c7376e2", + "name": "googleapis-common-protos-grpc", + "sha256": "c83cc993109b03a8c9afdb7c51656dec161e706323841e3aa5d4ac9041e6201d", + "size": 14493, + "subdir": "linux-64", + "timestamp": 1586570318414, + "version": "1.51.0" + }, + "googleapis-common-protos-grpc-1.52.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.52,<1.53.0a0", + "grpcio" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "40c4b3a071e59b7fe92771e5a10ce555", + "name": "googleapis-common-protos-grpc", + "sha256": "579045218ed06871c29beedce0e74b13c5a5efe68393e68a937305361965387b", + "size": 18838, + "subdir": "linux-64", + "timestamp": 1600455704442, + "version": "1.52.0" + }, + "googleapis-common-protos-grpc-1.52.0-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "cython", + "googleapis-common-protos >=1.52,<1.53.0a0", + "grpcio" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ff5adf3ccc63d730e362f09615e36c34", + "name": "googleapis-common-protos-grpc", + "sha256": "68d6eb645aea7ad6f9d5846e772f68393ff91b5977604798ea9c89751b5ac487", + "size": 19067, + "subdir": "linux-64", + "timestamp": 1613731673860, + "version": "1.52.0" + }, + "googleapis-common-protos-grpc-1.53.0-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.53,<1.54.0a0", + "grpcio" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "61bf961f6cb8bdbf13b0b714e159e646", + "name": "googleapis-common-protos-grpc", + "sha256": "96034f9b222d481fde3988212bfa28c001a7984c59adda5165b11724069818c7", + "size": 18060, + "subdir": "linux-64", + "timestamp": 1617957719246, + "version": "1.53.0" + }, + "googleapis-common-protos-grpc-1.56.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.56,<1.57.0a0", + "grpcio >=1.0.0,<2.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "588bfb5d162ef854e259ab1fd3200120", + "name": "googleapis-common-protos-grpc", + "sha256": "db01e655f91f06a3172c8dfc057497699ae60158dd2b51531229b614cb95a227", + "size": 12909, + "subdir": "linux-64", + "timestamp": 1660256306009, + "version": "1.56.4" + }, + "googleapis-common-protos-grpc-1.56.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.56,<1.57.0a0", + "grpcio >=1.0.0,<2.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "eb0581bb036b208746b30215bf59ef9f", + "name": "googleapis-common-protos-grpc", + "sha256": "b01903f1cd7456c0c5a0221d9952478daece7ff8e42ef6b6807609dcfb17d4ef", + "size": 13357, + "subdir": "linux-64", + "timestamp": 1676830593344, + "version": "1.56.4" + }, + "googleapis-common-protos-grpc-1.56.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.56,<1.57.0a0", + "grpcio >=1.0.0,<2.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "21ac35f3d76536aebffdd5ec2949a394", + "name": "googleapis-common-protos-grpc", + "sha256": "b83c773b9a548b5d18375293510550b6e3495998e4c286a2a8a394065046d3f3", + "size": 12858, + "subdir": "linux-64", + "timestamp": 1660256311395, + "version": "1.56.4" + }, + "googleapis-common-protos-grpc-1.56.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.56,<1.57.0a0", + "grpcio >=1.0.0,<2.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "77004fef3692ea2c71bfd644c67a8d77", + "name": "googleapis-common-protos-grpc", + "sha256": "4350309ec3d13af58ab6f2d9011b881b35ee9d29631bbad0959bfcdd0adf6f56", + "size": 12862, + "subdir": "linux-64", + "timestamp": 1660256294586, + "version": "1.56.4" + }, + "googleapis-common-protos-grpc-1.56.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.56,<1.57.0a0", + "grpcio >=1.0.0,<2.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "0fc852c9764551950ce35a60af51e5e3", + "name": "googleapis-common-protos-grpc", + "sha256": "6196412d4712ec427e25a4f8092e0970b82272c689f8f207543aa0cdabea378b", + "size": 12873, + "subdir": "linux-64", + "timestamp": 1660256300202, + "version": "1.56.4" + }, + "googleapis-common-protos-grpc-1.6.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "googleapis-common-protos >=1.6,<1.7.0a0", + "grpcio" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "b6f0e97a4dbf36f1729fa3a364145302", + "name": "googleapis-common-protos-grpc", + "sha256": "1770ee188eada06bda99af2c9ad8356d27bba8cd50cabd400e015123352f9c5b", + "size": 9567, + "subdir": "linux-64", + "timestamp": 1564754010940, + "version": "1.6.0" + }, + "gperf-3.1-hb29a3a9_0.conda": { + "build": "hb29a3a9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL-3", + "md5": "fba95ed00c0b5687890e55232c606925", + "name": "gperf", + "sha256": "27a5288004f8fe6499d374b6537085fc05c0edebad43f9a6611052c29b982426", + "size": 89322, + "subdir": "linux-64", + "timestamp": 1505734080490, + "version": "3.1" + }, + "grako-3.99.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "16bc8091e7b04b33aab2541ea4a0aacd", + "name": "grako", + "sha256": "272efdfa5e6eb9764a8aec677ce34536c504a0b5af49f1c40d3a7d7046c0dc87", + "size": 129584, + "subdir": "linux-64", + "timestamp": 1537208008444, + "version": "3.99.9" + }, + "grako-3.99.9-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "92fc7538faccb7d47fb03da52c6e5f8e", + "name": "grako", + "sha256": "f3ed866ee5f4edd3c35d25dbea90fb68d3561f758685cd94fe1bd4d4afa3ea85", + "size": 135443, + "subdir": "linux-64", + "timestamp": 1537208030857, + "version": "3.99.9" + }, + "grako-3.99.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "f479f49ad416ca48aaf777925a7c2ac0", + "name": "grako", + "sha256": "45646cd7f0566aa7096665672bff725918b2af3cf126a9ca3f6170b71142f0ef", + "size": 133241, + "subdir": "linux-64", + "timestamp": 1537208024326, + "version": "3.99.9" + }, + "grako-3.99.9-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "aac97eb2336ecf9e06c558feb74f33b7", + "name": "grako", + "sha256": "41479493e67fd74d6eb78857ca5eeff46995d3d36f9cf33bd0fda5d38eeb755e", + "size": 371923, + "subdir": "linux-64", + "timestamp": 1613557866607, + "version": "3.99.9" + }, + "grako-3.99.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "08d28a6f02e1aa29f1c283e0f7138bbb", + "name": "grako", + "sha256": "c0f9e02b6728450726b9bfe9141773d5df716ee6ea35393e6877d7deb1af890a", + "size": 134905, + "subdir": "linux-64", + "timestamp": 1537207962584, + "version": "3.99.9" + }, + "grako-3.99.9-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "954996428dd761de6b8a4d26c5e4b816", + "name": "grako", + "sha256": "8f85d18e621ef7b42e27a9f4429262f0a769600fc98ad3c577155e4b3c66ed6a", + "size": 373028, + "subdir": "linux-64", + "timestamp": 1613557862060, + "version": "3.99.9" + }, + "grako-3.99.9-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "357d26af926e75ba340e08912e288dad", + "name": "grako", + "sha256": "4e6061ee1851d22586cd1ad5a125cc325bf13ed1a6c5e95d40dc498e06fff613", + "size": 135048, + "subdir": "linux-64", + "timestamp": 1572621481105, + "version": "3.99.9" + }, + "grako-3.99.9-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "f97c0d7ffc57a0c07cc7843485ee0824", + "name": "grako", + "sha256": "b047a8473e44f5cf5e43ee51a2c8ba8fbd25daca34d732a7d412c8410fbce0c1", + "size": 372904, + "subdir": "linux-64", + "timestamp": 1613557203469, + "version": "3.99.9" + }, + "graphite2-1.3.10-hc526e54_0.conda": { + "build": "hc526e54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPLv2", + "md5": "70e6bc2a9a35ced3611659f4544dc1cc", + "name": "graphite2", + "sha256": "af74917b155d85f679dc82bd4981fbf30296a8d33ef12d549721da8a7bc08be9", + "size": 122729, + "subdir": "linux-64", + "timestamp": 1505744265130, + "version": "1.3.10" + }, + "graphite2-1.3.10-hf63cedd_1.conda": { + "build": "hf63cedd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPLv2", + "md5": "1ff245b89e7b83cf9b3395e78497d0da", + "name": "graphite2", + "sha256": "a5238f81f743e9baaff3ee1c84797c0d5005a0e641d2aeb253d85b3b802a2a7e", + "size": 123327, + "subdir": "linux-64", + "timestamp": 1516742845589, + "version": "1.3.10" + }, + "graphite2-1.3.11-h16798f4_2.conda": { + "build": "h16798f4_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPLv2", + "md5": "7806c0a8d693b212c397748f429f41ec", + "name": "graphite2", + "sha256": "6a3186f725f6d505fe7a2852e2d1a12afd4b1a443d2f67a3f154df57a445d6e1", + "size": 126699, + "subdir": "linux-64", + "timestamp": 1527034769226, + "version": "1.3.11" + }, + "graphite2-1.3.11-hf63cedd_1.conda": { + "build": "hf63cedd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPLv2", + "md5": "e8a6617a0954c1ccc5b28805412feb60", + "name": "graphite2", + "sha256": "26171b66fd6f01f5e3033b886aa9b67560a0f4242bb659e572e3708e0489b734", + "size": 124064, + "subdir": "linux-64", + "timestamp": 1523977600380, + "version": "1.3.11" + }, + "graphite2-1.3.12-h23475e2_2.conda": { + "build": "h23475e2_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPLv2", + "md5": "4f9b7f8dbaffc586cd1993246d46bc79", + "name": "graphite2", + "sha256": "239745da275a4b8f168f98bbc3cb5bf8f13fc9d0a3a4d4467a41a696c9c6f0ea", + "size": 105852, + "subdir": "linux-64", + "timestamp": 1535464092597, + "version": "1.3.12" + }, + "graphite2-1.3.13-h23475e2_0.conda": { + "build": "h23475e2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPLv2", + "md5": "22f87c57164251076bd89dcdd2247627", + "name": "graphite2", + "sha256": "c01af9ac704de850b28fe6d65cd4ff955194120eb96b6d5809fb09e0375b9d15", + "size": 100520, + "subdir": "linux-64", + "timestamp": 1547231219268, + "version": "1.3.13" + }, + "graphite2-1.3.14-h23475e2_0.conda": { + "build": "h23475e2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPLv2", + "md5": "382df96314e71de30787a522893283f0", + "name": "graphite2", + "sha256": "fee071fb57d0d70bfc37e4bf4fccbd5157ccbdc64ff9ce48543483ed9b706f16", + "size": 101035, + "subdir": "linux-64", + "timestamp": 1593114287915, + "version": "1.3.14" + }, + "graphite2-1.3.14-h295c915_1.conda": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "1939e8b3c03da6de2c021bd41aead9f9", + "name": "graphite2", + "sha256": "342d6b127e0c2609df50cbe1f1047c8a943a89678101eec6b721437ed3e4c33d", + "size": 99773, + "subdir": "linux-64", + "timestamp": 1654175396761, + "version": "1.3.14" + }, + "graphql-core-3.2.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f54804d0263149c6caf55508468974a3", + "name": "graphql-core", + "sha256": "ff7bbeb2de164f5c0f65d71c0ce34a167cfcc0abdde08d2501921c9334daf2b7", + "size": 538965, + "subdir": "linux-64", + "timestamp": 1670009943242, + "version": "3.2.3" + }, + "graphql-core-3.2.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8315e5569528159a77dba21fa9dfd05d", + "name": "graphql-core", + "sha256": "c241fd387cdf86c0e66aa77224293084909acf24d6c71aa45f6ff794f1ce3912", + "size": 601959, + "subdir": "linux-64", + "timestamp": 1676906066686, + "version": "3.2.3" + }, + "graphql-core-3.2.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions >=4.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "daa3e9db761546a7a330d81c25f288a1", + "name": "graphql-core", + "sha256": "0b30168a1382e44065d147619d4bebf20578d75ca152de754d431320f6455465", + "size": 532031, + "subdir": "linux-64", + "timestamp": 1670010009256, + "version": "3.2.3" + }, + "graphql-core-3.2.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "typing_extensions >=4.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca20d6c803f3b8093591a5ef97b6ee42", + "name": "graphql-core", + "sha256": "e25745b49154fa1d70b5fee3768d772d851cf92ef9a830ae179674a4e767c64d", + "size": 534957, + "subdir": "linux-64", + "timestamp": 1670009812934, + "version": "3.2.3" + }, + "graphql-core-3.2.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "typing_extensions >=4.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "742077c1372dd6977a97ca9c8dfc9089", + "name": "graphql-core", + "sha256": "cfaaa2bb0f926e7a3d49cea273af32e24b4577f24bf0e4f88cf92364a1853bc3", + "size": 534406, + "subdir": "linux-64", + "timestamp": 1670009878360, + "version": "3.2.3" + }, + "graphviz-2.40.1-h21bd128_1.conda": { + "build": "h21bd128_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.4,<2.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.11,<2.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libtiff >=4.0.9,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.1,<2.0a0", + "pcre >=8.42,<9.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "EPL v1.0", + "license_family": "Other", + "md5": "6fd9e72ee61e8124bf2f1acc37e176f8", + "name": "graphviz", + "sha256": "55d497d9a5d198daf191b82d84a17fb4cc6c4c807d3c55407e9ced78678bdebe", + "size": 6807392, + "subdir": "linux-64", + "timestamp": 1530914504953, + "version": "2.40.1" + }, + "graphviz-2.40.1-h21bd128_2.conda": { + "build": "h21bd128_2", + "build_number": 2, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.4,<2.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.11,<2.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libtiff >=4.0.9,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.1,<2.0a0", + "pcre >=8.42,<9.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "EPL v1.0", + "license_family": "Other", + "md5": "54c61327f6e6f6e65ca20afc93ae35f5", + "name": "graphviz", + "sha256": "05caf1f9b1b95a948ef89f243177fc4ee2397ab413c269645e7345eb975a0e63", + "size": 6803669, + "subdir": "linux-64", + "timestamp": 1531089802644, + "version": "2.40.1" + }, + "graphviz-2.40.1-h25d223c_0.conda": { + "build": "h25d223c_0", + "build_number": 0, + "depends": [ + "cairo", + "cairo >=1.14.12,<2.0a0", + "expat", + "expat >=2.2.5,<3.0a0", + "freetype", + "freetype >=2.8,<2.9.0a0", + "jpeg", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff", + "libtiff >=4.0.9,<5.0a0", + "libtool", + "pango", + "pango >=1.41.0,<2.0a0", + "zlib", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "EPL v1.0", + "license_family": "Other", + "md5": "0a0bb3bc18981c46823eab30f1f82aa1", + "name": "graphviz", + "sha256": "6974a38c6671aacee5c4ccf17da165eb0a6c4ff78ea716cee1c98824d4f2d84c", + "size": 6804320, + "subdir": "linux-64", + "timestamp": 1516896801372, + "version": "2.40.1" + }, + "graphviz-2.50.0-h1b29801_1.conda": { + "build": "h1b29801_1", + "build_number": 1, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "expat >=2.4.9,<3.0a0", + "fontconfig >=2.14.1,<3.0a0", + "fonts-conda-ecosystem", + "freetype >=2.10.4,<3.0a0", + "gdk-pixbuf >=2.42.10,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gtk2", + "gts >=0.7.6,<0.8.0a0", + "libgcc-ng >=11.2.0", + "libgd >=2.3.3,<2.4.0a0", + "librsvg >=2.54.4,<3.0a0", + "libstdcxx-ng >=11.2.0", + "libtool", + "libwebp", + "libwebp-base >=1.2.4,<2.0a0", + "pango >=1.50.7,<2.0a0", + "poppler", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "EPL-1.0", + "license_family": "Other", + "md5": "41d8e35c61f56e59e30342afcb12dd5b", + "name": "graphviz", + "sha256": "8731dc80e5b58ceae6cbcc88a083e04044e433ba853c758bbcbdab1b150aceb4", + "size": 2704298, + "subdir": "linux-64", + "timestamp": 1678708498745, + "version": "2.50.0" + }, + "graphviz-2.50.0-h3cd0ef9_0.conda": { + "build": "h3cd0ef9_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "expat >=2.2.10,<3.0a0", + "fontconfig", + "fonts-conda-ecosystem", + "freetype", + "gdk-pixbuf", + "glib >=2.69.1,<3.0a0", + "gtk2", + "gts >=0.7.6,<0.8.0a0", + "libgcc-ng >=11.2.0", + "libgd >=2.3.3,<2.4.0a0", + "librsvg >=2.54.4,<3.0a0", + "libstdcxx-ng >=11.2.0", + "libtool", + "libwebp-base", + "pango >=1.50.7,<2.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "EPL-1.0", + "license_family": "Other", + "md5": "0142604f913b480901920e771d746761", + "name": "graphviz", + "sha256": "ece0416b279bb5842d51be989bde7c2474355911c26937085008ac733514a648", + "size": 2581743, + "subdir": "linux-64", + "timestamp": 1656619299645, + "version": "2.50.0" + }, + "grayskull-2.2.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "colorama", + "conda-souschef >=2.2.3", + "packaging >=21.3", + "pip", + "pkginfo", + "progressbar2 >=3.53.0", + "python >=3.10,<3.11.0a0", + "rapidfuzz >=1.7.1", + "requests", + "ruamel.yaml >=0.16.10", + "ruamel.yaml.jinja2", + "setuptools >=30.3.0", + "stdlib-list", + "tomli", + "tomli-w" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0c6fe7b5f05ebaee1029760257f45634", + "name": "grayskull", + "sha256": "386729efab1c11f663bd6f03d09b768884a494b75b971d545c37dab04c9ae991", + "size": 130096, + "subdir": "linux-64", + "timestamp": 1677054003200, + "version": "2.2.2" + }, + "grayskull-2.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "colorama", + "conda-souschef >=2.2.3", + "packaging >=21.3", + "pip", + "pkginfo", + "progressbar2 >=3.53.0", + "python >=3.8,<3.9.0a0", + "rapidfuzz >=1.7.1", + "requests", + "ruamel.yaml >=0.16.10", + "ruamel.yaml.jinja2", + "setuptools >=30.3.0", + "stdlib-list", + "tomli", + "tomli-w" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9d6be9d618174520d385ab50b9b8dec3", + "name": "grayskull", + "sha256": "aebfc07ff4638235e549f76e5cd5c2a7c19440a72f37bb45c2e519f69eb75a5d", + "size": 129575, + "subdir": "linux-64", + "timestamp": 1677053968475, + "version": "2.2.2" + }, + "grayskull-2.2.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "colorama", + "conda-souschef >=2.2.3", + "packaging >=21.3", + "pip", + "pkginfo", + "progressbar2 >=3.53.0", + "python >=3.9,<3.10.0a0", + "rapidfuzz >=1.7.1", + "requests", + "ruamel.yaml >=0.16.10", + "ruamel.yaml.jinja2", + "setuptools >=30.3.0", + "stdlib-list", + "tomli", + "tomli-w" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "00c1b6227322f2b6a27a53e8a1b052ca", + "name": "grayskull", + "sha256": "6ee335a6abd3842666fbff76dd8efb74f4a78d5d884aecb0309d3b377917986f", + "size": 129566, + "subdir": "linux-64", + "timestamp": 1677053930315, + "version": "2.2.2" + }, + "greenlet-0.4.12-py27hac09c53_0.conda": { + "build": "py27hac09c53_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "741ea2bb9fe16b02bb2888a71524fa28", + "name": "greenlet", + "sha256": "bf101a637af74e89333413c48ac1151f630c3c1ff39946d840ee62fdcf90d820", + "size": 18965, + "subdir": "linux-64", + "timestamp": 1505743502584, + "version": "0.4.12" + }, + "greenlet-0.4.12-py35h2547b41_0.conda": { + "build": "py35h2547b41_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b14909819b410d2d63669e5ea384ab64", + "name": "greenlet", + "sha256": "4b375de2eea6796b19d09ad246e408401e61bd4a4d2367992fe17d3f4cec17f1", + "size": 18940, + "subdir": "linux-64", + "timestamp": 1505743518057, + "version": "0.4.12" + }, + "greenlet-0.4.12-py36h2d503a6_0.conda": { + "build": "py36h2d503a6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48f2d115ba562f5db9ae8967026116e4", + "name": "greenlet", + "sha256": "5478d2180078b827b59c0144408c40e97f9e02d1d4b39e6322d6568e11afcea6", + "size": 18967, + "subdir": "linux-64", + "timestamp": 1505743533853, + "version": "0.4.12" + }, + "greenlet-0.4.13-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1f639fe98a2ebf8e5bc94202a4ed26e", + "name": "greenlet", + "sha256": "b58c3a9831fedc2b510ea1fc8c10ab0c972f896dc94c1b427443bef68af70fa0", + "size": 19936, + "subdir": "linux-64", + "timestamp": 1519170004934, + "version": "0.4.13" + }, + "greenlet-0.4.13-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3afe7fa37aac487100c32bf85f6b55e0", + "name": "greenlet", + "sha256": "c6ace2824a43230ce65bba7c07b8dfa72dd071cbbeac1b929a727c78994603db", + "size": 19837, + "subdir": "linux-64", + "timestamp": 1519170013384, + "version": "0.4.13" + }, + "greenlet-0.4.13-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f516058fff1979b18ca385d3e8a52af", + "name": "greenlet", + "sha256": "6e2ce5461e391108d2be882f1c43f730bb118726e543aeb87d5e53d638636a81", + "size": 19855, + "subdir": "linux-64", + "timestamp": 1519169903064, + "version": "0.4.13" + }, + "greenlet-0.4.13-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d455fc0e8b0e081bdc8e65670f1efe8f", + "name": "greenlet", + "sha256": "567d083e1c2ec22fe8fece45ac3e5a55bd18bde3b2723439092bfde084f086d5", + "size": 19799, + "subdir": "linux-64", + "timestamp": 1530890469520, + "version": "0.4.13" + }, + "greenlet-0.4.14-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12909653806ac5343f67b777892805a0", + "name": "greenlet", + "sha256": "9623ccd4b317a97c563c0f43c8f8487eb6eaa8156f5de726f56acec478843cce", + "size": 20085, + "subdir": "linux-64", + "timestamp": 1532524595079, + "version": "0.4.14" + }, + "greenlet-0.4.14-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6774219eda9e453eeb4d2edd745a99f6", + "name": "greenlet", + "sha256": "6be31c404129d856eb7937a3be88a9d56913cc1bb7a07990d8ad7936186edcb7", + "size": 19990, + "subdir": "linux-64", + "timestamp": 1532522084480, + "version": "0.4.14" + }, + "greenlet-0.4.14-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4ab5e5409b536f53a49de2abd948683", + "name": "greenlet", + "sha256": "36f1cf2f3804d91899aec977fd6cd6929ec6de2750577fffcf5f5c8e2c3798fe", + "size": 19987, + "subdir": "linux-64", + "timestamp": 1532521910440, + "version": "0.4.14" + }, + "greenlet-0.4.14-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3192f2f4dd5d633a4171c2f6bfce081d", + "name": "greenlet", + "sha256": "360d81f83cb6e7477f4711e57b92d99eedba6c211b33a43cd84b882c8ef275a9", + "size": 20109, + "subdir": "linux-64", + "timestamp": 1532521941259, + "version": "0.4.14" + }, + "greenlet-0.4.15-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1349413e709a15252fc8a2580059412", + "name": "greenlet", + "sha256": "5be4445107d1183bf005a60441debdb701d7981f320b72d0490f8163b08de22f", + "size": 20396, + "subdir": "linux-64", + "timestamp": 1536767955430, + "version": "0.4.15" + }, + "greenlet-0.4.15-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a32b545a5431e8a2bce300a97cbb1af6", + "name": "greenlet", + "sha256": "76cd6c1bfdd2976ba246842c862e9c54aac2237a684f94dac964cfaa38f7b6ad", + "size": 20195, + "subdir": "linux-64", + "timestamp": 1536767982369, + "version": "0.4.15" + }, + "greenlet-0.4.15-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "748b7c035b46080a99b98daae3ccadc7", + "name": "greenlet", + "sha256": "b4a259d0d9a168397536c4aff0bc7639efcb9d9ecd877b9ddcb06ee6e533cd23", + "size": 20286, + "subdir": "linux-64", + "timestamp": 1536767991184, + "version": "0.4.15" + }, + "greenlet-0.4.15-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a36c48c9957cab70f819d28c97f4b28a", + "name": "greenlet", + "sha256": "2f1cf2267f419c1ed96008a134963728f19c746a64dbba62fe2800d4486870e3", + "size": 20250, + "subdir": "linux-64", + "timestamp": 1536700046535, + "version": "0.4.15" + }, + "greenlet-0.4.15-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80418ba25b28fea924c37ca804e19380", + "name": "greenlet", + "sha256": "eca7344dd32901ef62a354ea09423b98703cc402a76fccf9e469f3b91fe93e80", + "size": 29610, + "subdir": "linux-64", + "timestamp": 1572621589725, + "version": "0.4.15" + }, + "greenlet-0.4.16-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3cc3f1db5f5de030ae1a8c07ea53aed8", + "name": "greenlet", + "sha256": "569e4b2fa1991bfffe35211a3e925f8cbeb30f5ee55956fb7cf31dc62843388a", + "size": 24886, + "subdir": "linux-64", + "timestamp": 1592330986140, + "version": "0.4.16" + }, + "greenlet-0.4.16-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd91c43d3fc0c0a25e89d99dedb14410", + "name": "greenlet", + "sha256": "c316df8b614763155606966dc4fe38d82e97901868ae11ce0dd4dc0a46d45d2f", + "size": 24845, + "subdir": "linux-64", + "timestamp": 1592330982320, + "version": "0.4.16" + }, + "greenlet-0.4.16-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff9f331353fbc4ee478f178b010aade9", + "name": "greenlet", + "sha256": "7f83462f1c20f91cd58fe7772c066aac509ebae555a2c23ecace9bc526964efd", + "size": 25425, + "subdir": "linux-64", + "timestamp": 1592330980066, + "version": "0.4.16" + }, + "greenlet-0.4.16-py39he8ac12f_0.conda": { + "build": "py39he8ac12f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8951efd92821b1717b2cab5d871ad826", + "name": "greenlet", + "sha256": "3d734c314e6cb127986ac1d4ddf72066673a8a9f456cf02637e591229f4d7db7", + "size": 25822, + "subdir": "linux-64", + "timestamp": 1607025773216, + "version": "0.4.16" + }, + "greenlet-0.4.17-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "788fc2f1e7e1c3578c501b0f2175c8fc", + "name": "greenlet", + "sha256": "8bd478c9e86da412133f91b858168c11274c42d959c50d3635bc3f11961ea8ea", + "size": 22687, + "subdir": "linux-64", + "timestamp": 1600874033501, + "version": "0.4.17" + }, + "greenlet-0.4.17-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "68e2223eda4d7ae3baba1111fde0acd2", + "name": "greenlet", + "sha256": "e555e8e614fdcfc2a9299792ed2ae93ca085c4cd9fb134ed8421a0a86e5c3262", + "size": 22887, + "subdir": "linux-64", + "timestamp": 1600874030289, + "version": "0.4.17" + }, + "greenlet-0.4.17-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0cc3fe79a7c85d203e94b7e5b5e3234e", + "name": "greenlet", + "sha256": "e81a6a9ab5443b82420ba40034eefb3cabe4db4341ffa8c384d3888727438fc6", + "size": 23829, + "subdir": "linux-64", + "timestamp": 1600874051223, + "version": "0.4.17" + }, + "greenlet-0.4.17-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15454ee2cc0a7a084d239395ce0e9d45", + "name": "greenlet", + "sha256": "d6abf4eaa9d0368d925887cc32ef4cbf98549c94a54206e75d5deef2984d1570", + "size": 26030, + "subdir": "linux-64", + "timestamp": 1608154615997, + "version": "0.4.17" + }, + "greenlet-1.0.0-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2adfbe16c6734d3c6821dce383ebf35", + "name": "greenlet", + "sha256": "f8b3b541446fe3806bfb8a109576e3037cebf14463cd74292060bffa332cddf3", + "size": 81807, + "subdir": "linux-64", + "timestamp": 1611961651218, + "version": "1.0.0" + }, + "greenlet-1.0.0-py36h2531618_2.conda": { + "build": "py36h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5bb2ff0a9485d18a1fea3eec6c1f883", + "name": "greenlet", + "sha256": "981f1bb1240f63b70d5e29e64daecc4b046b4d6ace64184aa0377293c800b420", + "size": 83051, + "subdir": "linux-64", + "timestamp": 1611958421257, + "version": "1.0.0" + }, + "greenlet-1.0.0-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f68124a6a6035d06bc0de1c50eb4fa3a", + "name": "greenlet", + "sha256": "5deff0e7831134323b272d68ada957b33b2c564f980cb63ef012e5b7b440723b", + "size": 83622, + "subdir": "linux-64", + "timestamp": 1611961617835, + "version": "1.0.0" + }, + "greenlet-1.0.0-py37h2531618_2.conda": { + "build": "py37h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "82b3d471ff0eaa22d2a8a10a8b60242e", + "name": "greenlet", + "sha256": "b971431829e26c192eaeff285894c2c34c9ccc52eadc995baa302f6a5c9a86ae", + "size": 82932, + "subdir": "linux-64", + "timestamp": 1611958402464, + "version": "1.0.0" + }, + "greenlet-1.0.0-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "114a10addd1a7402a68730bccde3fe45", + "name": "greenlet", + "sha256": "e9ba75b229672b549051237fe2a52035515da45c538a41c53645a6990552fbc6", + "size": 84431, + "subdir": "linux-64", + "timestamp": 1611961624772, + "version": "1.0.0" + }, + "greenlet-1.0.0-py38h2531618_2.conda": { + "build": "py38h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4278157696e17a6e83986a6aaae21748", + "name": "greenlet", + "sha256": "dd3b0a97f816592ad2368d35deaa0f10b69d1b035c5513d7bc7720306097bc47", + "size": 84222, + "subdir": "linux-64", + "timestamp": 1611957748048, + "version": "1.0.0" + }, + "greenlet-1.0.0-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a44fdd135a61e739b3ac48d7b798b7fa", + "name": "greenlet", + "sha256": "c493b487268a660e83bd9764206081b1fdbc06fea7ea01f3e9d7a1e439f230b9", + "size": 83344, + "subdir": "linux-64", + "timestamp": 1611961667222, + "version": "1.0.0" + }, + "greenlet-1.0.0-py39h2531618_2.conda": { + "build": "py39h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b0d2ca777334ae971cc9cbcff353db4", + "name": "greenlet", + "sha256": "5349b0197471ca8372e534d08c229c95324b0a20be297441e51feb1bac7323f3", + "size": 83216, + "subdir": "linux-64", + "timestamp": 1611958419735, + "version": "1.0.0" + }, + "greenlet-1.1.0-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4724fe2ce1f1b8ef64c1dc7231b0f3b4", + "name": "greenlet", + "sha256": "06dacf0c3c1819e433d46717eaba55264e864df773576db125ab735b85771512", + "size": 83061, + "subdir": "linux-64", + "timestamp": 1620913685100, + "version": "1.1.0" + }, + "greenlet-1.1.0-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fab3ae0a2ee57b65b0eda78d621635c2", + "name": "greenlet", + "sha256": "d96be583daee612b7f0b6dea2f47bca0625376e702f70279f9677ec90ba649af", + "size": 83540, + "subdir": "linux-64", + "timestamp": 1620913696443, + "version": "1.1.0" + }, + "greenlet-1.1.0-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a3a03de34de60f8d4df1696e57ea1fd", + "name": "greenlet", + "sha256": "b0da8c01f6885d7898e88217d423df7f89d07570f870331709f7b2d0ccd8fc9c", + "size": 84143, + "subdir": "linux-64", + "timestamp": 1620913375268, + "version": "1.1.0" + }, + "greenlet-1.1.0-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8fe3818a5fe67607c1498757ceaab0df", + "name": "greenlet", + "sha256": "34334f4b51eaf7204c42126a12269fc36b05135da9cdf9471c6b93d2155d059d", + "size": 83370, + "subdir": "linux-64", + "timestamp": 1620913698526, + "version": "1.1.0" + }, + "greenlet-1.1.1-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a7c0077a876e7b1c8e1347c382825ed", + "name": "greenlet", + "sha256": "800774571482b5f9d95207fb62d7bfcd9aeee1f854982ed0dc0e4f0acb30857a", + "size": 129859, + "subdir": "linux-64", + "timestamp": 1640790632904, + "version": "1.1.1" + }, + "greenlet-1.1.1-py36h295c915_0.conda": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8bd8bb22de7584050d6db4d0e1c2cca1", + "name": "greenlet", + "sha256": "48022481f2f468f216cd9884cb1b400de5d6d97eca3552828ba4e2a4087c92da", + "size": 82550, + "subdir": "linux-64", + "timestamp": 1628879803161, + "version": "1.1.1" + }, + "greenlet-1.1.1-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3cd4ece9b428096a24668021c8d17318", + "name": "greenlet", + "sha256": "7faabb1ee1c2e8554ebf5b6d8adb893364e31d0f0076edf702dc980448ad9214", + "size": 83019, + "subdir": "linux-64", + "timestamp": 1628888185299, + "version": "1.1.1" + }, + "greenlet-1.1.1-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ccad2e0ea07f181e0be09c09cbb2c53", + "name": "greenlet", + "sha256": "54ff8c761fe439a331cc4dc223de98f1d62f265c03ce8bc4a5428374bd2a8355", + "size": 83694, + "subdir": "linux-64", + "timestamp": 1628887771107, + "version": "1.1.1" + }, + "greenlet-1.1.1-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4efadfb7220f4f8ec2d6bdbbdff25ee", + "name": "greenlet", + "sha256": "f4175859b153a483a4e10e3119464cf0997ef52010bb83c378cd055543b64b5c", + "size": 83907, + "subdir": "linux-64", + "timestamp": 1628888187452, + "version": "1.1.1" + }, + "greenlet-1.1.3-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d1b482bf930d79d9cac7c8554765dd03", + "name": "greenlet", + "sha256": "0da5ced1151a55602fcb56c1fe05c496d288654721a8a263eff6641c4cc05284", + "size": 99635, + "subdir": "linux-64", + "timestamp": 1670013276464, + "version": "1.1.3" + }, + "greenlet-1.1.3-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "294947b67120d25e6754fe1b2d1a5bcb", + "name": "greenlet", + "sha256": "c1220248f98e264237c60efa2bcc400dd59f633a61032e92e68a52de4b87c213", + "size": 98122, + "subdir": "linux-64", + "timestamp": 1670013306552, + "version": "1.1.3" + }, + "greenlet-1.1.3-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cea5268c1ce1d31bf198da43dc4877ea", + "name": "greenlet", + "sha256": "3ca89b095b5b459e6c7f3bb92440051a3ff3c90a68ebf201fb94b65d43a13e58", + "size": 99067, + "subdir": "linux-64", + "timestamp": 1670013365891, + "version": "1.1.3" + }, + "greenlet-1.1.3-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e45f0c7d4e4f6c0a5e380e7e87ffe33", + "name": "greenlet", + "sha256": "01ba696c0677bbf51b1281467de4197fd23db465708fcf5632597e048af5e64d", + "size": 98854, + "subdir": "linux-64", + "timestamp": 1670013336395, + "version": "1.1.3" + }, + "greenlet-2.0.1-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2fcfea30b71a5c0252ca70d05dd4ea12", + "name": "greenlet", + "sha256": "af3e57b2dc21b76b162712c63bfa54083d184b212227c7c4062b3d8dfceaf3a6", + "size": 197946, + "subdir": "linux-64", + "timestamp": 1670513354121, + "version": "2.0.1" + }, + "greenlet-2.0.1-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f215674a197f15c6d6539f05f0b9be5", + "name": "greenlet", + "sha256": "7d63146f51a2076462afb14f233bf91e01953ae004754ae283595010ff533c93", + "size": 209445, + "subdir": "linux-64", + "timestamp": 1676825264503, + "version": "2.0.1" + }, + "greenlet-2.0.1-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ed108a7bcb0bcd70975f40b7d9b07de", + "name": "greenlet", + "sha256": "63c4a8390088955d91a41308b4b4486fbfddb81970e5837f7e36858b893ab51a", + "size": 196224, + "subdir": "linux-64", + "timestamp": 1670513324126, + "version": "2.0.1" + }, + "greenlet-2.0.1-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1869bf948d3f94b4f84934481189a8df", + "name": "greenlet", + "sha256": "c9b1f6314f2f96af0cf58db9d4b5ae50a02b0d86bb70b0c59a68fee932e1a220", + "size": 197560, + "subdir": "linux-64", + "timestamp": 1670513294315, + "version": "2.0.1" + }, + "greenlet-2.0.1-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f2067dd2861de82013650f7c9ef61e8", + "name": "greenlet", + "sha256": "ddb3e8f86b698e4efb5aeab961e8dd098c0846884c6e4dd4362be2ab4d6f299f", + "size": 196533, + "subdir": "linux-64", + "timestamp": 1670513264536, + "version": "2.0.1" + }, + "gridmap-0.14.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "drmaa", + "psutil >=2.0.0", + "python >=2.7,<2.8.0a0", + "pyzmq" + ], + "license": "GPL3", + "md5": "61c9c3d97d9140521337fb453f78b28b", + "name": "gridmap", + "sha256": "1d13893a02b180d1ca1d413d7f917d69657edcdfd181dbf7e54241930f544ce1", + "size": 46938, + "subdir": "linux-64", + "timestamp": 1529990039017, + "version": "0.14.0" + }, + "gridmap-0.14.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "drmaa", + "psutil >=2.0.0", + "python >=3.10,<3.11.0a0", + "pyzmq" + ], + "license": "GPL3", + "md5": "d1d9c08fb349eb8e9107f8c0ced83059", + "name": "gridmap", + "sha256": "dc033393d83cbf15cb87c575051bf45e2489b655e2e938bd3dd1399eb8d497b3", + "size": 46551, + "subdir": "linux-64", + "timestamp": 1640809285438, + "version": "0.14.0" + }, + "gridmap-0.14.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "drmaa", + "psutil >=2.0.0", + "python >=3.11,<3.12.0a0", + "pyzmq" + ], + "license": "GPL3", + "md5": "7bec68006ca1eecaf661508a5ef02f37", + "name": "gridmap", + "sha256": "21b24532b36d34a940ed9a906fa76336f61ed88b1544896d81593572ddabf9b1", + "size": 55705, + "subdir": "linux-64", + "timestamp": 1676907255812, + "version": "0.14.0" + }, + "gridmap-0.14.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "drmaa", + "psutil >=2.0.0", + "python >=3.5,<3.6.0a0", + "pyzmq" + ], + "license": "GPL3", + "md5": "8be9d4c07967b2f7e2818ab38fa1d5a0", + "name": "gridmap", + "sha256": "d862fe0d7ac726eed20b66ac625a11a529260480ed9a563d1f549cf7aadf3759", + "size": 47395, + "subdir": "linux-64", + "timestamp": 1529990059975, + "version": "0.14.0" + }, + "gridmap-0.14.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "drmaa", + "psutil >=2.0.0", + "python >=3.6,<3.7.0a0", + "pyzmq" + ], + "license": "GPL3", + "md5": "37b4d0752a8ee5e4ab041d957321262c", + "name": "gridmap", + "sha256": "d10fe6b2c267e87498360bd57b1d183ca204cf6778dac71c0133390610d153ff", + "size": 47021, + "subdir": "linux-64", + "timestamp": 1529990021141, + "version": "0.14.0" + }, + "gridmap-0.14.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "drmaa", + "psutil >=2.0.0", + "python >=3.6,<3.7.0a0", + "pyzmq" + ], + "license": "GPL3", + "md5": "fd132f3fb6f7e6b1ed2274461826bb6c", + "name": "gridmap", + "sha256": "d7ef869c2a4b539f464823bd883dc5fa5ff1b656274bb863de09ec52d55a7a56", + "size": 338849, + "subdir": "linux-64", + "timestamp": 1632891251129, + "version": "0.14.0" + }, + "gridmap-0.14.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "drmaa", + "psutil >=2.0.0", + "python >=3.7,<3.8.0a0", + "pyzmq" + ], + "license": "GPL3", + "md5": "8819a6ff9706645fb2f6a34f2cac6baf", + "name": "gridmap", + "sha256": "bac5fd72aba762eee0c1bff36faa912247b98682e02f3549ee2e1b8a461fa44f", + "size": 338659, + "subdir": "linux-64", + "timestamp": 1632891213271, + "version": "0.14.0" + }, + "gridmap-0.14.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "drmaa", + "psutil >=2.0.0", + "python >=3.8,<3.9.0a0", + "pyzmq" + ], + "license": "GPL3", + "md5": "f544cfb0c1c913f42c4f05d5b2cee5d3", + "name": "gridmap", + "sha256": "92abe23694fbffa658bbaebb8ad0124a3b9a979f3bda3b55df0d10ec0fa65fce", + "size": 338142, + "subdir": "linux-64", + "timestamp": 1632890774957, + "version": "0.14.0" + }, + "gridmap-0.14.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "drmaa", + "psutil >=2.0.0", + "python >=3.9,<3.10.0a0", + "pyzmq" + ], + "license": "GPL3", + "md5": "8ee89483a6eeae83967aeefb98bf60b0", + "name": "gridmap", + "sha256": "16e9a7ac08184035d63ef1c01bf0450ea5f64250f0010867b4c3721e2254e8c7", + "size": 338572, + "subdir": "linux-64", + "timestamp": 1632884002727, + "version": "0.14.0" + }, + "grin-1.2.1-py27_4.conda": { + "build": "py27_4", + "build_number": 4, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "27e27817acf97bbc9d0a37c7ccc01781", + "name": "grin", + "sha256": "0fc3c407911a03f91f1594ee9d98d90985b083c48b40390f6d74a28875d67f3e", + "size": 28631, + "subdir": "linux-64", + "timestamp": 1518030803541, + "version": "1.2.1" + }, + "grin-1.2.1-py27h54abee7_1.conda": { + "build": "py27h54abee7_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0c0d3e50e6c14c3077a7eab9bb46c986", + "name": "grin", + "sha256": "13819f53287e2a055de923d3e77ff906531c57522446845f3e60c226bd505a0f", + "size": 28469, + "subdir": "linux-64", + "timestamp": 1505744280494, + "version": "1.2.1" + }, + "groff-1.22.4-pl5262he6710b0_2.conda": { + "build": "pl5262he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "perl" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "8970af9dc8945aeab13720f43a9440fa", + "name": "groff", + "sha256": "dfa52ab21a60c217ae37424a31944efbbf220ca0048a70f61c830a595a9c0a35", + "size": 2860700, + "subdir": "linux-64", + "timestamp": 1600927491863, + "version": "1.22.4" + }, + "groff-1.22.4-pl5262hf484d3e_2.conda": { + "build": "pl5262hf484d3e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "perl" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "d0557e55a747f86eaf5fb6061b9461fc", + "name": "groff", + "sha256": "938e539bcb521e01d3f19285c7f19971382dec26e2ca9c9258e10ec4611b3d1d", + "size": 2859822, + "subdir": "linux-64", + "timestamp": 1600927577486, + "version": "1.22.4" + }, + "grpc-cpp-1.26.0-hf484d3e_1.conda": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "c-ares >=1.16.1,<2.0a0", + "gflags", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.13.0,<3.13.1.0a0", + "libprotobuf >=3.13.0,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "3bf547f3c345083ea6a107cd66f69ac8", + "name": "grpc-cpp", + "sha256": "f5b997172f77e363c3c6cd1373eabae5770a8f577182b10d1bf6f29c159f4acf", + "size": 2448610, + "subdir": "linux-64", + "timestamp": 1601514044015, + "version": "1.26.0" + }, + "grpc-cpp-1.26.0-hf8bcb03_0.conda": { + "build": "hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares", + "gflags >=2.2.2,<2.3.0a0", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.11.3.0a0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "702e32bb677c6d51ae3d3460af84035d", + "name": "grpc-cpp", + "sha256": "79197424168f1c4e4925a68af93f7bea49a76fef355d1849c71a1f965436f152", + "size": 2463096, + "subdir": "linux-64", + "timestamp": 1580397868189, + "version": "1.26.0" + }, + "grpc-cpp-1.26.0-hf8bcb03_1.conda": { + "build": "hf8bcb03_1", + "build_number": 1, + "depends": [ + "c-ares >=1.16.1,<2.0a0", + "gflags", + "libgcc-ng >=7.3.0", + "libprotobuf >=3.13.0,<3.13.1.0a0", + "libprotobuf >=3.13.0,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "df20a34cc4614bb0c5dd22f881e793c3", + "name": "grpc-cpp", + "sha256": "62aa81927d7e5d7f1d8a7d2e404824f38c7e316f52cf0e2d24a6ed7f6fd5f0ba", + "size": 2449729, + "subdir": "linux-64", + "timestamp": 1601513940169, + "version": "1.26.0" + }, + "grpc-cpp-1.33.2-h2157cd5_4.conda": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5629b0b07e05eca59c857a2b704c6838", + "name": "grpc-cpp", + "sha256": "e307014ca26ee768ae25105b764fac1c0c2be2e0c7db06f6e1ae048b66d96a95", + "size": 2474484, + "subdir": "linux-64", + "timestamp": 1607206484921, + "version": "1.33.2" + }, + "grpc-cpp-1.34.1-h2157cd5_4.conda": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "1bfd3fd7e41c1ecc3e727fccbbbcd7c6", + "name": "grpc-cpp", + "sha256": "89b029b8c16c44862d82c57ac4c78c72b15c18522215c93d29bd12a3add0156a", + "size": 2580953, + "subdir": "linux-64", + "timestamp": 1610563677342, + "version": "1.34.1" + }, + "grpc-cpp-1.35.0-h2157cd5_4.conda": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "95b5073b34a505001ae95b86c5796eee", + "name": "grpc-cpp", + "sha256": "90d3668326211e890616a8b1d3b48dc767cb310d30c826d3260b446afb5736ae", + "size": 2696959, + "subdir": "linux-64", + "timestamp": 1611255700755, + "version": "1.35.0" + }, + "grpc-cpp-1.36.0-h2157cd5_4.conda": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f457e944e668c85077e2ede5c297fc4b", + "name": "grpc-cpp", + "sha256": "76e1c42a40d5d807d849d9dbe6e97d3aac7c8a6388440c9ced660a50efddd52f", + "size": 2733204, + "subdir": "linux-64", + "timestamp": 1614363011831, + "version": "1.36.0" + }, + "grpc-cpp-1.36.1-h2157cd5_4.conda": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "701694619e738c444c769234fd351bb4", + "name": "grpc-cpp", + "sha256": "ef2304e6b159ff9add1c5fe20e67de1cb887cf4cda126c15bd8d78aca602677c", + "size": 2726128, + "subdir": "linux-64", + "timestamp": 1614882945334, + "version": "1.36.1" + }, + "grpc-cpp-1.36.2-h2157cd5_4.conda": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6a6c5f11972c2f18dd9cf43a8df166e0", + "name": "grpc-cpp", + "sha256": "cd957cb41ca4052b3a6926a785cf3509352a7191b7d90173c44ca636b037efec", + "size": 2729255, + "subdir": "linux-64", + "timestamp": 1615315917420, + "version": "1.36.2" + }, + "grpc-cpp-1.36.3-h2157cd5_4.conda": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "86e6d5d2fb2505b1d8b25655ed6a9ff1", + "name": "grpc-cpp", + "sha256": "a506fadaa07049fea93e928a8d4eaff6e7bf81f3da81c7301d82f7dd6e448e7e", + "size": 2728521, + "subdir": "linux-64", + "timestamp": 1615921849401, + "version": "1.36.3" + }, + "grpc-cpp-1.36.4-h2157cd5_4.conda": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "160129e246fee3b6b575491e159648f2", + "name": "grpc-cpp", + "sha256": "545227a639a5248fc640a06f4d431573614cea42d12067435ccd7c4c6206ee8b", + "size": 2731485, + "subdir": "linux-64", + "timestamp": 1616179890104, + "version": "1.36.4" + }, + "grpc-cpp-1.37.0-h2157cd5_4.conda": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e64aff8cb3f1544679449a5d80d3cd85", + "name": "grpc-cpp", + "sha256": "dd002b627310da2f3a6b28fe8005eb6a22f6c80bdebf4ecfa3d3135496dadc27", + "size": 2823554, + "subdir": "linux-64", + "timestamp": 1617828604546, + "version": "1.37.0" + }, + "grpc-cpp-1.37.1-h2157cd5_4.conda": { + "build": "h2157cd5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "bcbc85ac4a414cbd5d2f57245f786580", + "name": "grpc-cpp", + "sha256": "2737e2de9d7ebae831fb832bf801c8c566713126b105f9a28b35a5946c2e1650", + "size": 2821691, + "subdir": "linux-64", + "timestamp": 1619735993721, + "version": "1.37.1" + }, + "grpc-cpp-1.38.1-hce63b2e_4.conda": { + "build": "hce63b2e_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.5.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f96327aba9bc5a7efbc351617d9a4fc7", + "name": "grpc-cpp", + "sha256": "d4b3a24404a62ba975e5a93e30fa6282eca69b1af45e0bdd1aea4c1722ad1005", + "size": 2849890, + "subdir": "linux-64", + "timestamp": 1624485740659, + "version": "1.38.1" + }, + "grpc-cpp-1.39.0-hae934f6_5.conda": { + "build": "hae934f6_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf >=3.17.2,<3.17.3.0a0", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7821d5cb62955d4bb3488c030ac36104", + "name": "grpc-cpp", + "sha256": "74b8c74308596787f02196ae19dd0f4b05b02730299747de54cd7990cfbb16e1", + "size": 2890020, + "subdir": "linux-64", + "timestamp": 1631219715382, + "version": "1.39.0" + }, + "grpc-cpp-1.39.0-hce63b2e_4.conda": { + "build": "hce63b2e_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf >=3.14.0,<3.14.1.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.5.0", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "da599af81c2d9dfd6a3241b695f56f4f", + "name": "grpc-cpp", + "sha256": "59c10a938c87eb8cbce9c6ff4829a949870101dc3642774d1047b689c989e367", + "size": 2881841, + "subdir": "linux-64", + "timestamp": 1627018445192, + "version": "1.39.0" + }, + "grpc-cpp-1.43.0-h63824a7_0.conda": { + "build": "h63824a7_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "c-ares >=1.18.1,<2.0a0", + "libgcc-ng >=9.3.0", + "libprotobuf >=3.19.1,<3.19.2.0a0", + "libprotobuf >=3.19.1,<3.20.0a0", + "libstdcxx-ng >=9.3.0", + "openssl >=1.1.1m,<1.1.2a", + "re2 >=2020.11.1,<2020.11.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "d546936e6e103a71f3f20dc390e2d550", + "name": "grpc-cpp", + "sha256": "c0d981df9fc3b3ca089072bbad4cb68b8c96dd4b9e0857907f6ab26129cdd19c", + "size": 3105884, + "subdir": "linux-64", + "timestamp": 1642703924279, + "version": "1.43.0" + }, + "grpc-cpp-1.46.1-h33aed49_0.conda": { + "build": "h33aed49_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "c-ares >=1.18.1,<2.0a0", + "libgcc-ng >=8.4.0", + "libprotobuf >=3.20.1,<3.20.2.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=8.4.0", + "openssl >=1.1.1o,<1.1.2a", + "re2 >=2022.4.1,<2022.4.2.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f6474562f6c5e1afce61fa060d61059f", + "name": "grpc-cpp", + "sha256": "64b7ab99c35079237002f94eacb0bbca6845dc48f7adbf13338d81904166ce4b", + "size": 3392971, + "subdir": "linux-64", + "timestamp": 1652942891317, + "version": "1.46.1" + }, + "grpc-cpp-1.46.1-h33aed49_1.conda": { + "build": "h33aed49_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "c-ares >=1.18.1,<2.0a0", + "libgcc-ng >=8.4.0", + "libprotobuf >=3.20.3,<3.20.4.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=8.4.0", + "openssl >=1.1.1s,<1.1.2a", + "re2 >=2022.4.1,<2022.4.2.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9e6c90e8e9d1cd1f8746e0b0930e6a72", + "name": "grpc-cpp", + "sha256": "6e7a33472af17fd7126cd7bc6673b76b33dc243ca27d1261f739f5b052b528b8", + "size": 4449734, + "subdir": "linux-64", + "timestamp": 1675356525107, + "version": "1.46.1" + }, + "grpcio-1.10.0-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "protobuf >=3.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "aff5329dd97859799c6fc08da5e8f6fb", + "name": "grpcio", + "sha256": "5313e08342c5e81b978c35bfb1d270fa1bd9e6618845e39f719778896c566dd8", + "size": 1487184, + "subdir": "linux-64", + "timestamp": 1520017144164, + "version": "1.10.0" + }, + "grpcio-1.10.0-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "protobuf >=3.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "e3d6e5d1af2a15d2839c6b0997a38c1a", + "name": "grpcio", + "sha256": "5ba89f8e53b3d3f0fefd7d5a090752515fc9153fe2d781963032efc7793f9c83", + "size": 1488855, + "subdir": "linux-64", + "timestamp": 1520017149139, + "version": "1.10.0" + }, + "grpcio-1.10.0-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "protobuf >=3.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "f2a7ba2f9583f2025b26301867bf3f7a", + "name": "grpcio", + "sha256": "33251b193881bd9b051c89884bacc55ed4f4a56e7c8e8367262152d53627c1b7", + "size": 1489923, + "subdir": "linux-64", + "timestamp": 1520016990428, + "version": "1.10.0" + }, + "grpcio-1.11.0-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "protobuf >=3.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "629ee2324cd9237b64e01dda3109db8a", + "name": "grpcio", + "sha256": "9333c5da12caecb54f9fc60098afcc48731f42826195e265a928c2a022bc3424", + "size": 1605939, + "subdir": "linux-64", + "timestamp": 1524088742683, + "version": "1.11.0" + }, + "grpcio-1.11.0-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "protobuf >=3.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "87f41f611973fb4ad03dae6a2d0270d2", + "name": "grpcio", + "sha256": "0774862ee093c36bd07cb07a80940842f0bacd0a274bb18a8a614d5a5d4eef4c", + "size": 1607297, + "subdir": "linux-64", + "timestamp": 1524088821197, + "version": "1.11.0" + }, + "grpcio-1.11.0-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "protobuf >=3.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "96407969726b3687c19f381daa9efb90", + "name": "grpcio", + "sha256": "91672820dde58a3f4ff90e432cd1f61b5888f5ef618d3347f4b05793e3021cd8", + "size": 1608075, + "subdir": "linux-64", + "timestamp": 1524088823238, + "version": "1.11.0" + }, + "grpcio-1.12.0-py27hdbcaa40_0.conda": { + "build": "py27hdbcaa40_0", + "build_number": 0, + "depends": [ + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "protobuf >=3.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "251eff9ce888447c945cea839a5ee393", + "name": "grpcio", + "sha256": "a59215c5d65faf13896741988ce9fb0cee4bea4efe14e8fe2b5df897bda442a2", + "size": 1644808, + "subdir": "linux-64", + "timestamp": 1527833752151, + "version": "1.12.0" + }, + "grpcio-1.12.0-py35hdbcaa40_0.conda": { + "build": "py35hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "protobuf >=3.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "ea71cd67252fe69b8afbf93119bec996", + "name": "grpcio", + "sha256": "31551e7946a1f210da30d57623a65cdd1b52f72bd6abf2f4d0ec89348ff43fe0", + "size": 1649594, + "subdir": "linux-64", + "timestamp": 1527833832731, + "version": "1.12.0" + }, + "grpcio-1.12.0-py36hdbcaa40_0.conda": { + "build": "py36hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "protobuf >=3.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "25185a2690d851b300330d53c3486c1b", + "name": "grpcio", + "sha256": "6867ea277ece60ff49bb1082960c56cdcccbdfb747182aff782a0e3d3b142350", + "size": 1650565, + "subdir": "linux-64", + "timestamp": 1527833908871, + "version": "1.12.0" + }, + "grpcio-1.12.1-py27hdbcaa40_0.conda": { + "build": "py27hdbcaa40_0", + "build_number": 0, + "depends": [ + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "ab41e00858f69c88ac4eaf1f594a3fc8", + "name": "grpcio", + "sha256": "f428871fa1586db75db7777b97ede68ece5e7adb5386558680e8db7786089958", + "size": 1648242, + "subdir": "linux-64", + "timestamp": 1529433346834, + "version": "1.12.1" + }, + "grpcio-1.12.1-py35hdbcaa40_0.conda": { + "build": "py35hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "ce6d8b8d6c359aa67aabc644608af576", + "name": "grpcio", + "sha256": "a27717edb7d23cc092fc86a85d528384d0fb20abbe096117e8e66a122c19e9d6", + "size": 1652356, + "subdir": "linux-64", + "timestamp": 1529433401942, + "version": "1.12.1" + }, + "grpcio-1.12.1-py36hdbcaa40_0.conda": { + "build": "py36hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "5cc03515c3ba89ac14496d7e86a54ea5", + "name": "grpcio", + "sha256": "7332fdb356682d62edf0035ac58757011802c25348c0eb24a6466aa4a459e318", + "size": 1653101, + "subdir": "linux-64", + "timestamp": 1529433350282, + "version": "1.12.1" + }, + "grpcio-1.12.1-py37hdbcaa40_0.conda": { + "build": "py37hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "aaf940b5878f60b66754a469b7bf3882", + "name": "grpcio", + "sha256": "c4c3651acaa39540d0119eb5c434838dfafca57cd859e3c4cac31317bead911d", + "size": 1653271, + "subdir": "linux-64", + "timestamp": 1530892643313, + "version": "1.12.1" + }, + "grpcio-1.14.1-py27h9ba97e2_0.conda": { + "build": "py27h9ba97e2_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "8d8731074384fca72d90bcd964e16e83", + "name": "grpcio", + "sha256": "cdb04ca5e80f17032fefd2a2c511118f4b73b913464e219d51a1638b2782a4be", + "size": 962833, + "subdir": "linux-64", + "timestamp": 1541542294982, + "version": "1.14.1" + }, + "grpcio-1.14.1-py27hf8bcb03_0.conda": { + "build": "py27hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "b442b713472558ff197e6dc793e26d14", + "name": "grpcio", + "sha256": "e2cbcdfac1582ff465b3930b2ad1cc66561a0242feacfbdbc8f5ab3624babd68", + "size": 963040, + "subdir": "linux-64", + "timestamp": 1541545051748, + "version": "1.14.1" + }, + "grpcio-1.14.1-py27hf8bcb03_1.conda": { + "build": "py27hf8bcb03_1", + "build_number": 1, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "88135c6f4f965074ff25b56651067023", + "name": "grpcio", + "sha256": "574c65bed215e58445efa8c504fd43245108c14ad6fc85a02a122133df164bd1", + "size": 964765, + "subdir": "linux-64", + "timestamp": 1542417806321, + "version": "1.14.1" + }, + "grpcio-1.14.1-py36h9ba97e2_0.conda": { + "build": "py36h9ba97e2_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "74ad636c425db8543bcefb8660d37860", + "name": "grpcio", + "sha256": "c76bcb5860dd1f866035781e1af159a1298446ea31c0244cb2b43e88c4dde5a6", + "size": 966870, + "subdir": "linux-64", + "timestamp": 1541542179041, + "version": "1.14.1" + }, + "grpcio-1.14.1-py36hf8bcb03_0.conda": { + "build": "py36hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "05b262f6472003c6a812d9c203400248", + "name": "grpcio", + "sha256": "c7c97f8cb2c56a699ca7db59249ea567d31bb2072659ba9779157f86a260e3dd", + "size": 965202, + "subdir": "linux-64", + "timestamp": 1541545056009, + "version": "1.14.1" + }, + "grpcio-1.14.1-py36hf8bcb03_1.conda": { + "build": "py36hf8bcb03_1", + "build_number": 1, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "d91ee37a1f25a43f043992b3dd0b91ab", + "name": "grpcio", + "sha256": "d20fb0117064570e839dcef36d65ff1761b6dbd71bed408fb44b0bb03ec875a6", + "size": 968080, + "subdir": "linux-64", + "timestamp": 1542417910047, + "version": "1.14.1" + }, + "grpcio-1.14.1-py37h9ba97e2_0.conda": { + "build": "py37h9ba97e2_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "565cab2bd3d9e20de9a36db2fb999587", + "name": "grpcio", + "sha256": "cedffa2d063bf17b75d81a73d7844334df7a14c53c5660521ad0f75be30fd95e", + "size": 964805, + "subdir": "linux-64", + "timestamp": 1541542297492, + "version": "1.14.1" + }, + "grpcio-1.14.1-py37hf8bcb03_0.conda": { + "build": "py37hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "fa0101ac256e4a1f52ea51a1ab8d008e", + "name": "grpcio", + "sha256": "66481e4d774db97bbf314a2db755d2f4d08d19206b7ff575edadebac2deae08b", + "size": 965128, + "subdir": "linux-64", + "timestamp": 1541545020349, + "version": "1.14.1" + }, + "grpcio-1.14.1-py37hf8bcb03_1.conda": { + "build": "py37hf8bcb03_1", + "build_number": 1, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "36346689fc127798931487ddad261ef7", + "name": "grpcio", + "sha256": "2297514ddc69378beb463dc6676de246a7745d945f139b41e72a795481ae77ed", + "size": 966118, + "subdir": "linux-64", + "timestamp": 1542417809905, + "version": "1.14.1" + }, + "grpcio-1.16.0-py27hf8bcb03_0.conda": { + "build": "py27hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "e446d8c605d5a8905e901d3e3cc953d1", + "name": "grpcio", + "sha256": "57096f106a9d8218b0e23a64d86b897e3ec41499050522dd98a854dfb61eee26", + "size": 1002971, + "subdir": "linux-64", + "timestamp": 1542136639437, + "version": "1.16.0" + }, + "grpcio-1.16.0-py36hf8bcb03_0.conda": { + "build": "py36hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "c436040fdb9e759b5739dc150573e7ed", + "name": "grpcio", + "sha256": "4e9d4ae0d525c5f8608a7458a03526c70401469362bfd3c20492884645818a2c", + "size": 1008689, + "subdir": "linux-64", + "timestamp": 1542136775682, + "version": "1.16.0" + }, + "grpcio-1.16.0-py37hf8bcb03_0.conda": { + "build": "py37hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "3ff5e1d680099a7e93d675abd14c9ca8", + "name": "grpcio", + "sha256": "5a0666a30b645522070f5d0979986d178d12daa82821795e27161016124896f7", + "size": 1006585, + "subdir": "linux-64", + "timestamp": 1542136738746, + "version": "1.16.0" + }, + "grpcio-1.16.1-py27hf8bcb03_0.conda": { + "build": "py27hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "20a498b3252ec4943bcd4bb96ef20f6b", + "name": "grpcio", + "sha256": "56dc554ae5be9addc5d5f5933f55b6323a14c09f10ec09ec42c67883aa91f0de", + "size": 1003048, + "subdir": "linux-64", + "timestamp": 1542389654273, + "version": "1.16.1" + }, + "grpcio-1.16.1-py27hf8bcb03_1.conda": { + "build": "py27hf8bcb03_1", + "build_number": 1, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "87b51f6b53516be05540e5dc3cacee2b", + "name": "grpcio", + "sha256": "1f8742a0fb39c420f3ff8ddda8f9b60bab17e7aaf6d17460830741b616ac6ed0", + "size": 997716, + "subdir": "linux-64", + "timestamp": 1542480068976, + "version": "1.16.1" + }, + "grpcio-1.16.1-py36hf8bcb03_0.conda": { + "build": "py36hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "bb8dbdef97fd60a125eeb1cbf824860d", + "name": "grpcio", + "sha256": "b035ee0672233da6963f1ef9c69803a4b092c0e7abc43dc57ddcad698d6c1a46", + "size": 1005327, + "subdir": "linux-64", + "timestamp": 1542389586218, + "version": "1.16.1" + }, + "grpcio-1.16.1-py36hf8bcb03_1.conda": { + "build": "py36hf8bcb03_1", + "build_number": 1, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "bbd88ce24fbf37d87f87e7f04c8bcb98", + "name": "grpcio", + "sha256": "c5d6b06fa4933be11d2275e9fe694a7408764ec2df6021953510a82a89b643cd", + "size": 1007942, + "subdir": "linux-64", + "timestamp": 1542480175632, + "version": "1.16.1" + }, + "grpcio-1.16.1-py37hf8bcb03_0.conda": { + "build": "py37hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "317f5fdebc53c3b6cc9a04d7b8250651", + "name": "grpcio", + "sha256": "024c164e592408fed2a036e9ab79d5b0b6e160e8675bb4538239a792ee66b722", + "size": 1004761, + "subdir": "linux-64", + "timestamp": 1542389421220, + "version": "1.16.1" + }, + "grpcio-1.16.1-py37hf8bcb03_1.conda": { + "build": "py37hf8bcb03_1", + "build_number": 1, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "d6a01dc599d9a84c46ff92acd48f9693", + "name": "grpcio", + "sha256": "e572505dcf0e4ff977b7f62262cee9f6a058aa6f7d7b4c577d53a964f33f0e8f", + "size": 1007622, + "subdir": "linux-64", + "timestamp": 1542480078679, + "version": "1.16.1" + }, + "grpcio-1.16.1-py38hf8bcb03_1.conda": { + "build": "py38hf8bcb03_1", + "build_number": 1, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "6871f566557c5c6903926fdf32c3cdc1", + "name": "grpcio", + "sha256": "4c0d6ba258edb2b632ddd75ee0334fab1c8601eab7dc49128c265c5a3bdcf78b", + "size": 931106, + "subdir": "linux-64", + "timestamp": 1574251845417, + "version": "1.16.1" + }, + "grpcio-1.27.2-py27hf8bcb03_0.conda": { + "build": "py27hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "enum34 >=1.0.4", + "futures >=2.2.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "5a746f21aa0f4d6a9ecc065a1341f43d", + "name": "grpcio", + "sha256": "527665524cbb24a7b967cb2612c8e2fa4966f1c208393f3465b11fe67a161948", + "size": 1301933, + "subdir": "linux-64", + "timestamp": 1582044959557, + "version": "1.27.2" + }, + "grpcio-1.27.2-py36hf8bcb03_0.conda": { + "build": "py36hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "81638dbab1f71db9777f9e78814d4b6a", + "name": "grpcio", + "sha256": "923d488b178aadecb63d53cc590a706b2184f75d211db679b8d01c03b5709f55", + "size": 1340919, + "subdir": "linux-64", + "timestamp": 1581978720544, + "version": "1.27.2" + }, + "grpcio-1.27.2-py37hf8bcb03_0.conda": { + "build": "py37hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "747acd49af970ac0585f163f95edccb0", + "name": "grpcio", + "sha256": "3f04c8cd7c237326ada6d99b694d096b645bb002945264d92bac1408980350c9", + "size": 1342946, + "subdir": "linux-64", + "timestamp": 1581978537409, + "version": "1.27.2" + }, + "grpcio-1.27.2-py38hf8bcb03_0.conda": { + "build": "py38hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "c4e57b4492ab3fd74d12e71cd05141a2", + "name": "grpcio", + "sha256": "7bb3bbed2165f56395b6d5a7e5ed7c6188485e5c9da7dbbca1ca7d73397a4c2a", + "size": 1371292, + "subdir": "linux-64", + "timestamp": 1581978730234, + "version": "1.27.2" + }, + "grpcio-1.31.0-py36hf8bcb03_0.conda": { + "build": "py36hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "4bc46eef32c48b5198d8b0951d217b10", + "name": "grpcio", + "sha256": "a4379e1e5d8fb49a2099a751ae572bebb2677565e90e1a2f4774c251e2f51d6e", + "size": 2100599, + "subdir": "linux-64", + "timestamp": 1597424580274, + "version": "1.31.0" + }, + "grpcio-1.31.0-py37hf8bcb03_0.conda": { + "build": "py37hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "2ed81ca871e720a585392fbb8c6e72d3", + "name": "grpcio", + "sha256": "08eb26905c6e9d75d2a918e19c0af0b101c675ccfc0119366ee1624aa8dcc751", + "size": 2089664, + "subdir": "linux-64", + "timestamp": 1597424582078, + "version": "1.31.0" + }, + "grpcio-1.31.0-py38hf8bcb03_0.conda": { + "build": "py38hf8bcb03_0", + "build_number": 0, + "depends": [ + "c-ares >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "dd9ae83d40da3e086567a36e50efb38d", + "name": "grpcio", + "sha256": "cea8316e90627758479342cd66fb0f0f85c112557e72de8823ed5562098a9eb9", + "size": 2132173, + "subdir": "linux-64", + "timestamp": 1597424617399, + "version": "1.31.0" + }, + "grpcio-1.35.0-py310hce63b2e_0.conda": { + "build": "py310hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.10,<3.11.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "0032434c3dd3560a58cf70de70dd7937", + "name": "grpcio", + "sha256": "bc31c2ac6925d0e992e3dbd42ed9fcfb0628f382a2d4ed08b27f5bd9beff990c", + "size": 19519802, + "subdir": "linux-64", + "timestamp": 1640790718584, + "version": "1.35.0" + }, + "grpcio-1.35.0-py36h2157cd5_1.conda": { + "build": "py36h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "065893d9e7efe9d4421f1173ab14cf4c", + "name": "grpcio", + "sha256": "69226227f4cff2727f215d92fc2f902c0f85b5696607fe7c46929d85464cea4a", + "size": 1923794, + "subdir": "linux-64", + "timestamp": 1613730259403, + "version": "1.35.0" + }, + "grpcio-1.35.0-py36hce63b2e_0.conda": { + "build": "py36hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e2ca6d18ada77108c02b3384a829bd2b", + "name": "grpcio", + "sha256": "e54f9adc0430db1fc67fc903e568d388c1772d9aad4bd39b43ac8e8a1f6f1083", + "size": 1911570, + "subdir": "linux-64", + "timestamp": 1613123348768, + "version": "1.35.0" + }, + "grpcio-1.35.0-py37h2157cd5_1.conda": { + "build": "py37h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b8440a3cb40f6c01fa405ed090b56aa7", + "name": "grpcio", + "sha256": "c49faafe73ba5f97c68f416753402d5c5a7c9a7f25bb5f3c26bbf6cd67f09746", + "size": 1917517, + "subdir": "linux-64", + "timestamp": 1613730258454, + "version": "1.35.0" + }, + "grpcio-1.35.0-py37hce63b2e_0.conda": { + "build": "py37hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5b520c9c4652679228bb7d551374e31d", + "name": "grpcio", + "sha256": "837d3c3e4f04864f1652247e4aada45264799b01982e1a77da5009d5d3990101", + "size": 1910553, + "subdir": "linux-64", + "timestamp": 1613123417932, + "version": "1.35.0" + }, + "grpcio-1.35.0-py38h2157cd5_1.conda": { + "build": "py38h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e76fbcde0b9648113c84dd520f87c442", + "name": "grpcio", + "sha256": "e35dcdf5b063b1f5ff2e828dc9ab8449158f27b65bca9ae79d3c8ae5fdf8685f", + "size": 1955961, + "subdir": "linux-64", + "timestamp": 1613730258855, + "version": "1.35.0" + }, + "grpcio-1.35.0-py38hce63b2e_0.conda": { + "build": "py38hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "612c179358cf372028e4d8aaeba13a08", + "name": "grpcio", + "sha256": "446dcaab957753782db820c721391e26ef2aab6498f95c1bc8bef6f25639c1f2", + "size": 1956621, + "subdir": "linux-64", + "timestamp": 1613123555260, + "version": "1.35.0" + }, + "grpcio-1.35.0-py39h2157cd5_1.conda": { + "build": "py39h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8b32c2be6a7570094ef4445e8b0af755", + "name": "grpcio", + "sha256": "76e49b48508ad183c4311c46fe26bff834017d76ecaddaba9f0319bac7f3c380", + "size": 1961441, + "subdir": "linux-64", + "timestamp": 1613729902975, + "version": "1.35.0" + }, + "grpcio-1.35.0-py39hce63b2e_0.conda": { + "build": "py39hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "005812cfc51b275184962fe95c1ecdbd", + "name": "grpcio", + "sha256": "b1c59c39c5250e719f02beb912038d32c2e8fbe2706c36c867d8dfa7cf862a8b", + "size": 1957360, + "subdir": "linux-64", + "timestamp": 1613123488152, + "version": "1.35.0" + }, + "grpcio-1.36.0-py36h2157cd5_1.conda": { + "build": "py36h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "63a8ffd64a24a948bcbfce20b98a30ca", + "name": "grpcio", + "sha256": "46d6c56ba6d997447cd469693a409af9da8e8cc4b09dc384a99f62b067f4352b", + "size": 1956813, + "subdir": "linux-64", + "timestamp": 1614614921359, + "version": "1.36.0" + }, + "grpcio-1.36.0-py37h2157cd5_1.conda": { + "build": "py37h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7ab70af4520176b2008c61e8563d3318", + "name": "grpcio", + "sha256": "53ebaa951beda7ea1d8a4167f86ad22843f7552480340f61d52e9ab6619ba835", + "size": 1949460, + "subdir": "linux-64", + "timestamp": 1614616088040, + "version": "1.36.0" + }, + "grpcio-1.36.0-py38h2157cd5_1.conda": { + "build": "py38h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c2e9e940a7394905311a70187d00085b", + "name": "grpcio", + "sha256": "cc1ee6397c4a21d5305dd599bb4dc05f607d17d22d046de8984c1f2ac59fc6bd", + "size": 1991671, + "subdir": "linux-64", + "timestamp": 1614616092937, + "version": "1.36.0" + }, + "grpcio-1.36.0-py39h2157cd5_1.conda": { + "build": "py39h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "0323ffd6ad92c39352441b26c8c12359", + "name": "grpcio", + "sha256": "094806ce9e9cfa42f31541e2c7f2a17eeafb84093203070049d15d21a57f8f8a", + "size": 1996996, + "subdir": "linux-64", + "timestamp": 1614616081813, + "version": "1.36.0" + }, + "grpcio-1.36.1-py36h2157cd5_1.conda": { + "build": "py36h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "0794ed3e1acf8d99b0fd70b30bee1b49", + "name": "grpcio", + "sha256": "30045d8c284fe00ad786ba0c48c0f30ea120ad8492878dbc3e44b248af456474", + "size": 1953292, + "subdir": "linux-64", + "timestamp": 1614884350411, + "version": "1.36.1" + }, + "grpcio-1.36.1-py37h2157cd5_1.conda": { + "build": "py37h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "387d1d395b7ca4c9edbe535badab6a80", + "name": "grpcio", + "sha256": "b3be498d8683f8a9a7cb09694d41fad9e5ca6c0d426c205333fff2764943a72f", + "size": 1954221, + "subdir": "linux-64", + "timestamp": 1614884088704, + "version": "1.36.1" + }, + "grpcio-1.36.1-py38h2157cd5_1.conda": { + "build": "py38h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6211194130d38bd58f54cc62bfb695fc", + "name": "grpcio", + "sha256": "2bc5f3cd80f91d4e59c21818cbec40de015ed1151eb6e1385659752aacbf9ab5", + "size": 1984438, + "subdir": "linux-64", + "timestamp": 1614884308168, + "version": "1.36.1" + }, + "grpcio-1.36.1-py39h2157cd5_1.conda": { + "build": "py39h2157cd5_1", + "build_number": 1, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "coverage", + "cython", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "dd8a0a948c5fe4ca8a987970387f44cc", + "name": "grpcio", + "sha256": "267e14e7bebde190b3486b65253d037b3cd4c04552a608f51f8d7d354c70d95a", + "size": 2000869, + "subdir": "linux-64", + "timestamp": 1614884327430, + "version": "1.36.1" + }, + "grpcio-1.42.0-py310hce63b2e_0.conda": { + "build": "py310hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.18.1,<2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1o,<1.1.2a", + "python >=3.10,<3.11.0a0", + "six >=1.5.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "4a41de9654d8bfe83ec66443a5e4b802", + "name": "grpcio", + "sha256": "466e22e129ae85d804a62a2c803699c79c99ab64d1bc32883d06aba237b83a7b", + "size": 25435681, + "subdir": "linux-64", + "timestamp": 1655801249151, + "version": "1.42.0" + }, + "grpcio-1.42.0-py311ha637b67_0.conda": { + "build": "py311ha637b67_0", + "build_number": 0, + "depends": [ + "c-ares >=1.18.1,<2.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.11,<3.12.0a0", + "six >=1.5.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c8d508a7c4a5125b71f28cae73e1205e", + "name": "grpcio", + "sha256": "e4654a6b41d9589ca1169869f021d3d3ecd03daa4456c8282305cca65214b8b1", + "size": 2193979, + "subdir": "linux-64", + "timestamp": 1676830777553, + "version": "1.42.0" + }, + "grpcio-1.42.0-py37hce63b2e_0.conda": { + "build": "py37hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.7,<3.8.0a0", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "0f9b834febbe68b4238cb0a3be1b8ce2", + "name": "grpcio", + "sha256": "6277f0c4853af435e4ffd6b17e2a2019efab459453542f441b9bb4aa50b16071", + "size": 2158721, + "subdir": "linux-64", + "timestamp": 1637578137686, + "version": "1.42.0" + }, + "grpcio-1.42.0-py38hce63b2e_0.conda": { + "build": "py38hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.8,<3.9.0a0", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e927a3e889ea61ca34f47d1652b9f89d", + "name": "grpcio", + "sha256": "3d35f96d29553878ee774270705ab2afd7102c1749703fe5fc5817f88b88df9d", + "size": 2194363, + "subdir": "linux-64", + "timestamp": 1637590943256, + "version": "1.42.0" + }, + "grpcio-1.42.0-py39hce63b2e_0.conda": { + "build": "py39hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.9,<3.10.0a0", + "six >=1.5.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "edf2cde3ef8d7ef910a845cf48e64606", + "name": "grpcio", + "sha256": "1874cbb8abcb04cfb4a7c0bad05a517ebbfb3fc2438253242e6396a98ff9c481", + "size": 2200224, + "subdir": "linux-64", + "timestamp": 1637590949116, + "version": "1.42.0" + }, + "grpcio-gcp-0.2.2-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "grpcio >=1.35.0,<2.0a0", + "protobuf >=3.17.2,<4.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "cdf1039c4baa3a0dfd0abfb5d6ae0b03", + "name": "grpcio-gcp", + "sha256": "da520bd34bfe3366447820c283fbd583e0687df2801a5fe6add8760fba7c8e29", + "size": 25014, + "subdir": "linux-64", + "timestamp": 1640809317521, + "version": "0.2.2" + }, + "grpcio-gcp-0.2.2-py311h06a4308_2.conda": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "grpcio >=1.42.0,<2.0a0", + "protobuf >=3.20.3,<4.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "2977eb9d8b9ad2e6a7c0ff1f459c464e", + "name": "grpcio-gcp", + "sha256": "08766a25fa06ff23165777860d23e04478f48459667d0dbd6bb6969d6c698275", + "size": 30731, + "subdir": "linux-64", + "timestamp": 1676839934572, + "version": "0.2.2" + }, + "grpcio-gcp-0.2.2-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "grpcio >=1.27.2,<2.0a0", + "protobuf >=3.11.4,<4.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "201bb916bdceebdabc295822e5e29a64", + "name": "grpcio-gcp", + "sha256": "6eed91d058bff53b9948dcd7349da3c61f17bc112d278d4aa254298f89a1ee42", + "size": 25343, + "subdir": "linux-64", + "timestamp": 1586542195785, + "version": "0.2.2" + }, + "grpcio-gcp-0.2.2-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "grpcio >=1.35.0,<2.0a0", + "protobuf >=3.14.0,<4.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "72b7aea162eb66188dd02a3f51252853", + "name": "grpcio-gcp", + "sha256": "9f1bcfee315c74251b4c25140617275adbd12180f310831e192fac0b63211a45", + "size": 25628, + "subdir": "linux-64", + "timestamp": 1613736034557, + "version": "0.2.2" + }, + "grpcio-gcp-0.2.2-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "grpcio >=1.27.2,<2.0a0", + "protobuf >=3.11.4,<4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "6f886f26e94adaf537987362005e25f1", + "name": "grpcio-gcp", + "sha256": "78488d72c3d11d55a80379ca436b02debd7a3a8f0db40bb889530de81eb90e98", + "size": 25418, + "subdir": "linux-64", + "timestamp": 1586542188662, + "version": "0.2.2" + }, + "grpcio-gcp-0.2.2-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "grpcio >=1.35.0,<2.0a0", + "protobuf >=3.14.0,<4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "6f1dd09197d44021000cd12f87e322e0", + "name": "grpcio-gcp", + "sha256": "3d51b85a0dc4ee1807ac1f2f103910700b55358ba945d244c106b0e8ef8b29a2", + "size": 25686, + "subdir": "linux-64", + "timestamp": 1613736783692, + "version": "0.2.2" + }, + "grpcio-gcp-0.2.2-py38_2.conda": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "grpcio >=1.27.2,<2.0a0", + "protobuf >=3.11.4,<4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "2cbcca10fde51b82e5e6eff3680434ab", + "name": "grpcio-gcp", + "sha256": "d135b8bd4763b011d7d04f8a74188772560fa8a15b488285a2cfef52bdf98560", + "size": 25579, + "subdir": "linux-64", + "timestamp": 1586542193855, + "version": "0.2.2" + }, + "grpcio-gcp-0.2.2-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "grpcio >=1.35.0,<2.0a0", + "protobuf >=3.14.0,<4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "9b298a2167aa02eab1c90f246559679b", + "name": "grpcio-gcp", + "sha256": "e352c9783a9396e7720a31501b0d03559e895460cb56d73fd3d9386b7ffe030f", + "size": 25944, + "subdir": "linux-64", + "timestamp": 1613736457618, + "version": "0.2.2" + }, + "grpcio-gcp-0.2.2-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "grpcio >=1.35.0,<2.0a0", + "protobuf >=3.14.0,<4.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "b71c672cc564d6626622f9781cd820e1", + "name": "grpcio-gcp", + "sha256": "bf4c667f6af56b2c163aeb262fc94c67add7b33953d4eef0a6f64f1476f47d2b", + "size": 25941, + "subdir": "linux-64", + "timestamp": 1613736791059, + "version": "0.2.2" + }, + "grpcio-tools-1.16.1-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "grpcio >=1.16.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "6b3b2fc6b3b1e0915f27fcb4f2cf557e", + "name": "grpcio-tools", + "sha256": "538766bfd566daf5ab5a144c8aa66f912dbd2db3a98303195d94173b31523233", + "size": 1676496, + "subdir": "linux-64", + "timestamp": 1542484630393, + "version": "1.16.1" + }, + "grpcio-tools-1.16.1-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "grpcio >=1.16.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "protobuf >=3.6.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "993bba0e270d97371e5b197d40e386e4", + "name": "grpcio-tools", + "sha256": "1d018190c4c2d84435ab32fa1d55bce5b0303002dc8fac8f88fbce46267fb503", + "size": 15083887, + "subdir": "linux-64", + "timestamp": 1641902617662, + "version": "1.16.1" + }, + "grpcio-tools-1.16.1-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "grpcio >=1.16.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "40408370bf7b5a707302abbadad66b1f", + "name": "grpcio-tools", + "sha256": "66b49b557d0b1abb191f121fc98c62de824d7c49cf601f066cfe2fca73f9c492", + "size": 1789886, + "subdir": "linux-64", + "timestamp": 1614094849788, + "version": "1.16.1" + }, + "grpcio-tools-1.16.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "grpcio >=1.16.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "a3f1bd96f609d0b0b92348741763810b", + "name": "grpcio-tools", + "sha256": "336090e68fed2896fd540a9e81ebb6ec235765db04db7330bbef2834bbddad07", + "size": 1676233, + "subdir": "linux-64", + "timestamp": 1542484668532, + "version": "1.16.1" + }, + "grpcio-tools-1.16.1-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "grpcio >=1.16.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "5eb36128db587339fe39e2a86aea0dc2", + "name": "grpcio-tools", + "sha256": "d9bc97ee66e2c6f1748d49c691b479f8b1f93c69421d035c715845bde5bf0116", + "size": 1781954, + "subdir": "linux-64", + "timestamp": 1614094820551, + "version": "1.16.1" + }, + "grpcio-tools-1.16.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "grpcio >=1.16.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "a41e22d53a8952f85fb46df0c207836c", + "name": "grpcio-tools", + "sha256": "6469aa649de09a5e21711ece76966e5875a5abd872ebda2056187ebb2fe5c645", + "size": 1672602, + "subdir": "linux-64", + "timestamp": 1542484648236, + "version": "1.16.1" + }, + "grpcio-tools-1.16.1-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "grpcio >=1.16.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "56bbc026a2c140bb21f2370dbf2affb6", + "name": "grpcio-tools", + "sha256": "a658df0757b80f805ae1224e44fac9edada8dedc8f92a9a9741841f315ff6676", + "size": 1783497, + "subdir": "linux-64", + "timestamp": 1614094782356, + "version": "1.16.1" + }, + "grpcio-tools-1.16.1-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "grpcio >=1.16.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "f7d2351eb079ec79694b32ce9f117d95", + "name": "grpcio-tools", + "sha256": "5777ccfb12a66d6740b94a59e4f5e932cfa6b462c9af4219a72dbf6fc298b0e1", + "size": 1725538, + "subdir": "linux-64", + "timestamp": 1592222363402, + "version": "1.16.1" + }, + "grpcio-tools-1.16.1-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "grpcio >=1.16.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "20bd6311e7d3d7b3e9c272d1ce19be8f", + "name": "grpcio-tools", + "sha256": "a8423f639eedc16fe60eb40e99595aee582b464765bebba1f37768a1b8cc5b08", + "size": 1778253, + "subdir": "linux-64", + "timestamp": 1614094850053, + "version": "1.16.1" + }, + "grpcio-tools-1.35.0-py36h2531618_1.conda": { + "build": "py36h2531618_1", + "build_number": 1, + "depends": [ + "grpcio 1.35.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "60dbe57cb5b22ff1bbd03efc832c09dd", + "name": "grpcio-tools", + "sha256": "a81c94bfa9cbbebbf4f29b0a48c9ebaa0fbab004327acf75fb207c9447d93072", + "size": 1798335, + "subdir": "linux-64", + "timestamp": 1614095581957, + "version": "1.35.0" + }, + "grpcio-tools-1.35.0-py37h2531618_1.conda": { + "build": "py37h2531618_1", + "build_number": 1, + "depends": [ + "grpcio 1.35.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "04fb7eb342f4c354fccc1d13da29fba0", + "name": "grpcio-tools", + "sha256": "33ae8ea066fbf03f7e6bb4ac25b1116c71f51ab35af1d6f74d21d31ae521c84c", + "size": 1808925, + "subdir": "linux-64", + "timestamp": 1614095562664, + "version": "1.35.0" + }, + "grpcio-tools-1.35.0-py38h2531618_1.conda": { + "build": "py38h2531618_1", + "build_number": 1, + "depends": [ + "grpcio 1.35.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "81884ed5d1991647e9e2d15ee40ea01f", + "name": "grpcio-tools", + "sha256": "c6598cfbc19f03a2ea9b08e128f191d346bbfb435882d538ffbb86e784f1420f", + "size": 1802570, + "subdir": "linux-64", + "timestamp": 1614095601451, + "version": "1.35.0" + }, + "grpcio-tools-1.35.0-py39h2531618_1.conda": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "grpcio 1.35.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "protobuf >=3.6.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7ca722e699d08f28a208d8919fc876f8", + "name": "grpcio-tools", + "sha256": "28cf67733fa07d901f556d0166603eb3dcbe593f614618051a8e7c41e07ec2a9", + "size": 1798011, + "subdir": "linux-64", + "timestamp": 1614094643681, + "version": "1.35.0" + }, + "grpcio-tools-1.42.0-py310h6a678d5_2.conda": { + "build": "py310h6a678d5_2", + "build_number": 2, + "depends": [ + "grpcio 1.42.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "protobuf >=3.6.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "aa450f06443fbbbfb710c9ac8992cd1a", + "name": "grpcio-tools", + "sha256": "9bfd5a94b27dbe6f76fd4a9ee2f32b7314a3c7c8874d98fdb593ed880f22da09", + "size": 2145990, + "subdir": "linux-64", + "timestamp": 1678832108599, + "version": "1.42.0" + }, + "grpcio-tools-1.42.0-py311h6a678d5_1.conda": { + "build": "py311h6a678d5_1", + "build_number": 1, + "depends": [ + "grpcio 1.42.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "protobuf >=3.6.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c5a5d6fcfa01698b023e527da4d022a0", + "name": "grpcio-tools", + "sha256": "cd995a1f27f8d464b19959434e72574f9332776206b3807cf451a7fcf3e2ad81", + "size": 1916202, + "subdir": "linux-64", + "timestamp": 1677033086776, + "version": "1.42.0" + }, + "grpcio-tools-1.42.0-py311h6a678d5_2.conda": { + "build": "py311h6a678d5_2", + "build_number": 2, + "depends": [ + "grpcio 1.42.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "protobuf >=3.6.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "43186396ef5576aab9e5814bf5e34356", + "name": "grpcio-tools", + "sha256": "dd7c3fb4bbccff8a68ffb85ef394fc23eb733438a6dd94ea2690f3bdc0ef6b06", + "size": 1933587, + "subdir": "linux-64", + "timestamp": 1679336156122, + "version": "1.42.0" + }, + "grpcio-tools-1.42.0-py38h6a678d5_2.conda": { + "build": "py38h6a678d5_2", + "build_number": 2, + "depends": [ + "grpcio 1.42.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "protobuf >=3.6.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "de5747c28f3b1d192e542f512ffed30f", + "name": "grpcio-tools", + "sha256": "983858dc5bf22de2bb6ce328e2458f67b3f37d56aaa70eeb74063cdd739a7a04", + "size": 2148154, + "subdir": "linux-64", + "timestamp": 1678831805023, + "version": "1.42.0" + }, + "grpcio-tools-1.42.0-py39h6a678d5_2.conda": { + "build": "py39h6a678d5_2", + "build_number": 2, + "depends": [ + "grpcio 1.42.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "protobuf >=3.6.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "cdb3610ef2904ed7f3ff48e3112b79fa", + "name": "grpcio-tools", + "sha256": "57ec98083350a495edbab680d4dc6caa8b0de104f54ebe6258a17ac947ac832f", + "size": 2145987, + "subdir": "linux-64", + "timestamp": 1678831955815, + "version": "1.42.0" + }, + "gsl-2.2.1-h0743c53_2.conda": { + "build": "h0743c53_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-3.0", + "md5": "40b2d055d15bdb6a6b96b64e7fb264f0", + "name": "gsl", + "sha256": "cbec512ea74428b6bbb9a96570004a3c1cefdf03fc26bbe710db3566d7d9278d", + "size": 1837034, + "subdir": "linux-64", + "timestamp": 1505853592676, + "version": "2.2.1" + }, + "gsl-2.2.1-h0c605f7_3.conda": { + "build": "h0c605f7_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-3.0", + "md5": "2add1c4ead836cc773ec832fbb45eaf0", + "name": "gsl", + "sha256": "ffc5c632df5978d0b391d6a906391e654e2eca54a3ffead932b3ab4beb2d7213", + "size": 1835677, + "subdir": "linux-64", + "timestamp": 1510863242362, + "version": "2.2.1" + }, + "gsl-2.2.1-h8267d9d_2.conda": { + "build": "h8267d9d_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-3.0", + "md5": "7e37484e385c7e95694da9bed0a091eb", + "name": "gsl", + "sha256": "19f1c7f9b7021deb5d08cac338b42ce3737314c74a08e9a11d83d50aecc18143", + "size": 1837111, + "subdir": "linux-64", + "timestamp": 1507908707654, + "version": "2.2.1" + }, + "gsl-2.4-h14c3975_4.conda": { + "build": "h14c3975_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-3.0", + "md5": "fd711a47897e00a526d2efb8c99dfaa7", + "name": "gsl", + "sha256": "49c80b59587fe446b9e6f8da65e7b8c0ad3167303e21649a6bc50175459fd2f6", + "size": 1883986, + "subdir": "linux-64", + "timestamp": 1528733108675, + "version": "2.4" + }, + "gsl-2.4-h1bed415_3.conda": { + "build": "h1bed415_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-3.0", + "md5": "ee8a4eab41a6115bf9c29a65b93a4428", + "name": "gsl", + "sha256": "d02cda564d65ddc2b984d02bf30255664cb4acf0b22cad65d64808c466cceb07", + "size": 1883625, + "subdir": "linux-64", + "timestamp": 1522454546595, + "version": "2.4" + }, + "gsl-2.6-ha341630_0.conda": { + "build": "ha341630_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "GPL-3.0", + "md5": "9edd57dedc06f92e29d0c75ccd26cf6c", + "name": "gsl", + "sha256": "de80e7ce3f9b29a6db0e73654a74d9948e12b18eda03a4c7941a28c640be64f2", + "size": 2180216, + "subdir": "linux-64", + "timestamp": 1646837162243, + "version": "2.6" + }, + "gsl-2.6-he715372_0.conda": { + "build": "he715372_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0" + ], + "license": "GPL-3.0", + "md5": "234633036fcdf5b9311dd29ff81da661", + "name": "gsl", + "sha256": "1a4aff91bb63a59f60bd365569fc210cc3b184a0492baee41bd9709bb8c46938", + "size": 2180188, + "subdir": "linux-64", + "timestamp": 1646836943961, + "version": "2.6" + }, + "gsl-2.7-ha341630_0.conda": { + "build": "ha341630_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "GPL-3.0", + "md5": "4201838067b922a3791b1c4ca0efb711", + "name": "gsl", + "sha256": "36455499653a632a43965f4931b5f8b08307fa683c76658eec7aee9340db3eaa", + "size": 2228599, + "subdir": "linux-64", + "timestamp": 1646932570996, + "version": "2.7" + }, + "gsl-2.7-he715372_0.conda": { + "build": "he715372_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0" + ], + "license": "GPL-3.0", + "md5": "3782d55a5f59fbd5c8b4d89c87892700", + "name": "gsl", + "sha256": "ec365b8acd7a5a5232e99626e821105ce2aef6deb183ba528b13b061122257fb", + "size": 2228774, + "subdir": "linux-64", + "timestamp": 1646932809871, + "version": "2.7" + }, + "gsl-2.7.1-h6e86dc7_1.conda": { + "build": "h6e86dc7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "4dede1b5092017fe06644622a05c3c70", + "name": "gsl", + "sha256": "0abe45823bbda708921ab97faa78916aa103d3d867d3cb07364c049a84c17021", + "size": 2293129, + "subdir": "linux-64", + "timestamp": 1656079436673, + "version": "2.7.1" + }, + "gsl-2.7.1-h917eeb2_1.conda": { + "build": "h917eeb2_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "c0c35a1953a9468372582acd1379a0d3", + "name": "gsl", + "sha256": "db1355bc0757c72dec35bc91c851ffe26fb384c410b771e75999babde3d4e7d3", + "size": 2293543, + "subdir": "linux-64", + "timestamp": 1656079188989, + "version": "2.7.1" + }, + "gsl-2.7.1-h9f31491_0.conda": { + "build": "h9f31491_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "1a423ad3476377c233f6cb88d76c9c2f", + "name": "gsl", + "sha256": "dd2f6b1584c2b1d3d912f8db1a02c8a48b407bdc3944c74e535fd1d1fdf86624", + "size": 2237424, + "subdir": "linux-64", + "timestamp": 1647851723326, + "version": "2.7.1" + }, + "gsl-2.7.1-hd82f3ee_0.conda": { + "build": "hd82f3ee_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "8765c98670411208f55d7afc41fcaf27", + "name": "gsl", + "sha256": "cd958183fa438df1a60abc46a235b1453aa674afa1a8621e624fef345685a164", + "size": 2232966, + "subdir": "linux-64", + "timestamp": 1647869597902, + "version": "2.7.1" + }, + "gst-plugins-base-1.12.2-he3457e5_0.conda": { + "build": "he3457e5_0", + "build_number": 0, + "depends": [ + "gstreamer >=1.12.2,<1.13.0a0", + "libgcc-ng >=7.2.0", + "xz >=5.2.3,<6.0a0" + ], + "license": "GPL2", + "md5": "76e441ef8115768b0a1e079335524ae8", + "name": "gst-plugins-base", + "sha256": "f3e6abeba177fd4899262b9a0147efc75c95a9a7ee397745d127011eeaa57c63", + "size": 4048110, + "subdir": "linux-64", + "timestamp": 1505735977489, + "version": "1.12.2" + }, + "gst-plugins-base-1.12.4-h33fb286_0.conda": { + "build": "h33fb286_0", + "build_number": 0, + "depends": [ + "gstreamer >=1.12.4,<1.13.0a0", + "libgcc-ng >=7.2.0", + "libxcb >=1.12,<2.0a0", + "xz >=5.2.3,<6.0a0" + ], + "license": "GPL2", + "md5": "4ba83515edcd38536cca3c9d089d74d6", + "name": "gst-plugins-base", + "sha256": "378e64f865fc46c4eab348bcb2e1399b839821d5166f83f548908d8cef447961", + "size": 3985719, + "subdir": "linux-64", + "timestamp": 1516817613741, + "version": "1.12.4" + }, + "gst-plugins-base-1.14.0-h8213a91_2.conda": { + "build": "h8213a91_2", + "build_number": 2, + "depends": [ + "glib >=2.66.1,<3.0a0", + "gstreamer >=1.14.0,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxcb >=1.14,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "838648422452405b86699e780e293c1d", + "name": "gst-plugins-base", + "sha256": "61394888b29e57742a477f2134f735fbd4c39ae867c111badd7d8d410046bc7a", + "size": 5128597, + "subdir": "linux-64", + "timestamp": 1609866747525, + "version": "1.14.0" + }, + "gst-plugins-base-1.14.0-hbbd80ab_1.conda": { + "build": "hbbd80ab_1", + "build_number": 1, + "depends": [ + "glib >=2.56.1,<3.0a0", + "gstreamer >=1.14.0,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "4461ffa28478fe3ca9d0bea4e3395ed8", + "name": "gst-plugins-base", + "sha256": "9f9841880835a667d9312eff26fb31d14d53b1d1db193651a087d48d9a90007d", + "size": 5047785, + "subdir": "linux-64", + "timestamp": 1523671420695, + "version": "1.14.0" + }, + "gst-plugins-base-1.14.0-he9c8b40_0.conda": { + "build": "he9c8b40_0", + "build_number": 0, + "depends": [ + "glib >=2.53.6,<3.0a0", + "gstreamer >=1.14.0,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "xz >=5.2.3,<6.0a0" + ], + "md5": "64dfa2424d507a9392d8acdc3c6e62cb", + "name": "gst-plugins-base", + "sha256": "249698dd86f115ddb7fc681836435afd210a5173dc6edbfa744d5a970e806600", + "size": 4112814, + "subdir": "linux-64", + "timestamp": 1522700978144, + "version": "1.14.0" + }, + "gst-plugins-base-1.14.1-h6a678d5_1.conda": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "gstreamer >=1.14.1,<2.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxcb >=1.14,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "afd9cbe949d670d24cc0a007aaec1fe1", + "name": "gst-plugins-base", + "sha256": "e81dae03d17db2d5dbf9eb822fb15efe8dc0c5d768b499668a499114073369d8", + "size": 2255815, + "subdir": "linux-64", + "timestamp": 1677171916164, + "version": "1.14.1" + }, + "gst-plugins-base-1.18.5-hc549b11_0.conda": { + "build": "hc549b11_0", + "build_number": 0, + "depends": [ + "gettext", + "glib >=2.69.1,<3.0a0", + "gstreamer >=1.18.5,<2.0a0", + "libgcc-ng >=7.5.0", + "libogg", + "libopus >=1.3.1,<2.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libvorbis", + "libxcb >=1.14,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "cbb9b0e858ca8367c23f122b41430d3e", + "name": "gst-plugins-base", + "sha256": "9ba5e75684784262be3d7bd28f4189548b18075a3f32932e7348f379c9774ef6", + "size": 2426784, + "subdir": "linux-64", + "timestamp": 1632218706352, + "version": "1.18.5" + }, + "gst-plugins-good-1.18.5-hb67d8dd_0.conda": { + "build": "hb67d8dd_0", + "build_number": 0, + "depends": [ + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.18.5,<2.0a0", + "gstreamer >=1.18.5,<2.0a0", + "lame >=3.100,<3.101.0a0", + "libgcc-ng >=7.5.0", + "libpng", + "libstdcxx-ng >=7.5.0", + "mpg123", + "zlib" + ], + "md5": "d8788123cebd3828e9d1b89826ae7eca", + "name": "gst-plugins-good", + "sha256": "854a4a482db41a69e83f009701d5939cbfafe105ab1bdfa6b6b4f1d6779c9ab2", + "size": 1820014, + "subdir": "linux-64", + "timestamp": 1632218761681, + "version": "1.18.5" + }, + "gstreamer-1.12.2-h4f93127_0.conda": { + "build": "h4f93127_0", + "build_number": 0, + "depends": [ + "glib >=2.53.6,<3.0a0", + "libgcc-ng >=7.2.0", + "xz >=5.2.3,<6.0a0" + ], + "license": "LGPL 2", + "md5": "f4b956e1c10713ef1271f4842032dc72", + "name": "gstreamer", + "sha256": "fe4ab48a8cb188fd31abbddc101042df6ab8bf7adf45a948d6b9ab03f3725a55", + "size": 3095466, + "subdir": "linux-64", + "timestamp": 1505735891617, + "version": "1.12.2" + }, + "gstreamer-1.12.4-hb53b477_0.conda": { + "build": "hb53b477_0", + "build_number": 0, + "depends": [ + "glib >=2.53.6,<3.0a0", + "libgcc-ng >=7.2.0", + "xz >=5.2.3,<6.0a0" + ], + "license": "LGPL 2", + "md5": "3830c93d335d626281dd13787e8bdae9", + "name": "gstreamer", + "sha256": "f03525386870431d743ef5a056320f5440bdd11b9cfe5953aec563466b0cbfc8", + "size": 3096647, + "subdir": "linux-64", + "timestamp": 1516817410492, + "version": "1.12.4" + }, + "gstreamer-1.14.0-h28cd5cc_2.conda": { + "build": "h28cd5cc_2", + "build_number": 2, + "depends": [ + "glib >=2.66.1,<3.0a0", + "libgcc-ng >=7.3.0" + ], + "md5": "6af5d0cbd7310e1cd8a6a5c1c99649b2", + "name": "gstreamer", + "sha256": "254b4fe8b685fc293c250ca239d0be03e95f3d909972827fc472129ca2590d85", + "size": 3364270, + "subdir": "linux-64", + "timestamp": 1609866593800, + "version": "1.14.0" + }, + "gstreamer-1.14.0-hb31296c_0.conda": { + "build": "hb31296c_0", + "build_number": 0, + "depends": [ + "glib >=2.53.6,<3.0a0", + "libgcc-ng >=7.2.0", + "xz >=5.2.3,<6.0a0" + ], + "md5": "db432c4ba913459d99ab4b7facdcae80", + "name": "gstreamer", + "sha256": "456656a51abe93c9e8c2ae2add1980cb43b0395374858c7e3c70ee0e01d92481", + "size": 3209290, + "subdir": "linux-64", + "timestamp": 1522700842442, + "version": "1.14.0" + }, + "gstreamer-1.14.0-hb453b48_1.conda": { + "build": "hb453b48_1", + "build_number": 1, + "depends": [ + "glib >=2.56.1,<3.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "pcre >=8.42,<9.0a0", + "xz >=5.2.3,<6.0a0" + ], + "md5": "e9b8ad6885e6a342de09c9168bf30e8a", + "name": "gstreamer", + "sha256": "6393230d167ee5d77cbd7cdd50b139be9683bd0e5d81c07d01cb7854c04c8e2a", + "size": 3276952, + "subdir": "linux-64", + "timestamp": 1523671228623, + "version": "1.14.0" + }, + "gstreamer-1.14.1-h5eee18b_1.conda": { + "build": "h5eee18b_1", + "build_number": 1, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0" + ], + "md5": "f2f26e6f869b5d87f41bd059fae47c3e", + "name": "gstreamer", + "sha256": "dfd5bd5d2dfdc796e42b1b79bde009eb4727da5a7aa2a027f20ba8b52daa60e0", + "size": 1742741, + "subdir": "linux-64", + "timestamp": 1677171850557, + "version": "1.14.1" + }, + "gstreamer-1.18.5-ha1a6a79_0.conda": { + "build": "ha1a6a79_0", + "build_number": 0, + "depends": [ + "gettext", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=7.5.0" + ], + "md5": "a92b05bd3d99d6f077b46fe29c28c66c", + "name": "gstreamer", + "sha256": "bc2bebdeab10b749af1b88cb6f9e3125e1af66202799ddf5048d7006b01e93e5", + "size": 1899512, + "subdir": "linux-64", + "timestamp": 1632218649858, + "version": "1.18.5" + }, + "gtest-1.11.0-hdb19cb5_0.conda": { + "build": "hdb19cb5_0", + "build_number": 0, + "constrains": [ + "gmock 1.11.0" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2381990bffbf49defd03b3f297ec38dc", + "name": "gtest", + "sha256": "d6d3842319bfddb8e2901d2a39317259a025686934dea8666004124bc6e8db11", + "size": 277906, + "subdir": "linux-64", + "timestamp": 1658973567464, + "version": "1.11.0" + }, + "gtest-1.8.0-hf484d3e_4.conda": { + "build": "hf484d3e_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "348f0cceefebd36736b1185474e3b1e3", + "name": "gtest", + "sha256": "c956ed7e8bd6953b3132886b815d0a78f338ecc9d2431455f32c615a2b048f93", + "size": 276043, + "subdir": "linux-64", + "timestamp": 1526680086130, + "version": "1.8.0" + }, + "gtk2-2.24.33-h73c1081_2.conda": { + "build": "h73c1081_2", + "build_number": 2, + "depends": [ + "atk-1.0 >=1.29.2", + "atk-1.0 >=2.36.0", + "cairo >=1.16.0,<2.0a0", + "cairo >=1.6", + "fontconfig", + "freetype", + "gdk-pixbuf >=2.21.0", + "gdk-pixbuf >=2.42.8,<3.0a0", + "glib >=2.28.0,<3.0a0", + "glib >=2.69.1,<3.0a0", + "harfbuzz", + "libgcc-ng >=11.2.0", + "pango >=1.20", + "pango >=1.50.7,<2.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "dfcad588bb0ce1c81608f4eedc11b3c3", + "name": "gtk2", + "sha256": "ec805bf2e8cab3fa3a53472edae17bb1866fbe717832c085b5cb95e7a7785afb", + "size": 3438045, + "subdir": "linux-64", + "timestamp": 1656608247070, + "version": "2.24.33" + }, + "gts-0.7.6-hb67d8dd_2.conda": { + "build": "hb67d8dd_2", + "build_number": 2, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "LGPL-2.0-or-later", + "md5": "937b1c8bf5bf7ba003cc1a22b9bc1a0e", + "name": "gts", + "sha256": "7fb292def5f1480ff953cc90db5ab292b3cafa1c58c37946196ec89ab83237af", + "size": 317301, + "subdir": "linux-64", + "timestamp": 1631785118368, + "version": "0.7.6" + }, + "gts-0.7.6-hb67d8dd_3.conda": { + "build": "hb67d8dd_3", + "build_number": 3, + "depends": [ + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "c1435d3380fbe5a7ce7b7a872cc14ce0", + "name": "gts", + "sha256": "566140722f660b28e7ea3c10e9139a58ec7165bb86134d99880ec4864c83afc5", + "size": 316946, + "subdir": "linux-64", + "timestamp": 1648045431763, + "version": "0.7.6" + }, + "gunicorn-19.7.1-py27h5cfa6e4_0.conda": { + "build": "py27h5cfa6e4_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "6adf7325e65fd0a38d7794ec8d6dd1eb", + "name": "gunicorn", + "sha256": "ebd9ad0505864b88426df645583f31d66740c32777f04a02053a56ed98c69736", + "size": 178409, + "subdir": "linux-64", + "timestamp": 1507873665059, + "version": "19.7.1" + }, + "gunicorn-19.7.1-py35h985f2da_0.conda": { + "build": "py35h985f2da_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "48b5f8cd5eb44b6adc839070c7ff04bf", + "name": "gunicorn", + "sha256": "bdb82bd778578fd2e420c6eb2a590e98aa3df0e898687362bbe94547285891fd", + "size": 181002, + "subdir": "linux-64", + "timestamp": 1507873687061, + "version": "19.7.1" + }, + "gunicorn-19.7.1-py36h38c4014_0.conda": { + "build": "py36h38c4014_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "48bd8cb88fdcbf0837f3f04fa530c837", + "name": "gunicorn", + "sha256": "05048fc94b416f5b3b686a48861652ffdc69349583225644488f834aa82c752b", + "size": 178991, + "subdir": "linux-64", + "timestamp": 1507873689802, + "version": "19.7.1" + }, + "gunicorn-19.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "a26b001b87589ff8b818ed4c32c7c219", + "name": "gunicorn", + "sha256": "cd47e54339673c96c52399d977620916c3aefec0711a8b2ccd5601446ff49abe", + "size": 184885, + "subdir": "linux-64", + "timestamp": 1573964789862, + "version": "19.8.0" + }, + "gunicorn-19.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "c2e89e4736b85bd985dd1af0865889ad", + "name": "gunicorn", + "sha256": "cfb732f685cbd2a0eca6b2ce47a393085804360eef116de0525d20e72085aa25", + "size": 187850, + "subdir": "linux-64", + "timestamp": 1573964789437, + "version": "19.8.0" + }, + "gunicorn-19.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "7c1f28f9a60f33a30de2176e19227373", + "name": "gunicorn", + "sha256": "925178c32112956f95503b853c116ebc3ea72e09148363fed2596b69f39e32c2", + "size": 183113, + "subdir": "linux-64", + "timestamp": 1573964781156, + "version": "19.8.0" + }, + "gunicorn-19.8.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "c2d62cf6ffc430cbf84b9eab29af97f6", + "name": "gunicorn", + "sha256": "588fe0d271d9a4af060fd5f7e3320ba8b527521710084c2259c26cda886ed963", + "size": 181302, + "subdir": "linux-64", + "timestamp": 1574157869577, + "version": "19.8.0" + }, + "gunicorn-19.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "56ef4777aacf5ea175b5d6945ca0ec84", + "name": "gunicorn", + "sha256": "a7519ce3e085f4ecbd6c17c9fd13d880e7ed1c49f50e9784ae91f8b9cc5c6e7b", + "size": 179610, + "subdir": "linux-64", + "timestamp": 1526125494980, + "version": "19.8.1" + }, + "gunicorn-19.8.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "45ab7a494ab2a25a1e83d86693e613fd", + "name": "gunicorn", + "sha256": "a0cc991e4d24e5e7ba4f6521a51dbd4c6deb1f93b50f17e10c27748c0938f80c", + "size": 184515, + "subdir": "linux-64", + "timestamp": 1526125523220, + "version": "19.8.1" + }, + "gunicorn-19.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "a55eae2bdcebc7da1250c0c36da2bf79", + "name": "gunicorn", + "sha256": "aaf8fad92a0487f11bcd339b02cb17dd3c3acf68b1e3b91b14806e8a80a81a5c", + "size": 184494, + "subdir": "linux-64", + "timestamp": 1526125485975, + "version": "19.8.1" + }, + "gunicorn-19.8.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "764e5b14ea98e4b2212bb31cdb4bbebf", + "name": "gunicorn", + "sha256": "cc52b110549085fbee2bc6dca8fac0a644ec06a6c895695fc0d7048dee9b9544", + "size": 179674, + "subdir": "linux-64", + "timestamp": 1530892778974, + "version": "19.8.1" + }, + "gunicorn-19.9.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "398da10fa54e2125697237b3832809b9", + "name": "gunicorn", + "sha256": "d2a7358870921bef3b89c32dd89a44e06b295e11fb6208141ec0de0f8f9b95e7", + "size": 181490, + "subdir": "linux-64", + "timestamp": 1532802173081, + "version": "19.9.0" + }, + "gunicorn-19.9.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "d4c449230630607afcf55cd1abcac7e9", + "name": "gunicorn", + "sha256": "eb93b11490f6d1c1824a09aa7e05334760061567d819306170fc6ac89337de12", + "size": 186457, + "subdir": "linux-64", + "timestamp": 1532802183156, + "version": "19.9.0" + }, + "gunicorn-19.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "4959f11f627f419fa89528dbdf1ef5ac", + "name": "gunicorn", + "sha256": "4938a4fc49b2bc012341470ee5bdfe973ffc168d388459d04fe29ef68b387146", + "size": 184348, + "subdir": "linux-64", + "timestamp": 1532802156392, + "version": "19.9.0" + }, + "gunicorn-19.9.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "1e42bb9728fbff62ea134e914d84381f", + "name": "gunicorn", + "sha256": "11381d9985e5220379e7ebf33168c8470bd708558dde7e40c7bc2140bca0112d", + "size": 184723, + "subdir": "linux-64", + "timestamp": 1532802234755, + "version": "19.9.0" + }, + "gunicorn-20.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "b195aa8e8899eb4f38a9ebfc53d6dcad", + "name": "gunicorn", + "sha256": "98fb06be8e1a0aafebb8c278d9f89b3c7227e3811db6996d2e85fc21b56aa8ab", + "size": 126990, + "subdir": "linux-64", + "timestamp": 1574367708823, + "version": "20.0.0" + }, + "gunicorn-20.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "2e08f10ef9a042373d86c838dca315ad", + "name": "gunicorn", + "sha256": "7776317a8e3ca9eed1dedf961b5aa488f20cb27d4a84d9367e1fad8fc6fa6bc8", + "size": 127131, + "subdir": "linux-64", + "timestamp": 1574367729201, + "version": "20.0.0" + }, + "gunicorn-20.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "b73e91de3c27b5d2f453beb2281010d1", + "name": "gunicorn", + "sha256": "74d085e358d194c5f8d380760b97c1fd34e13ace8a83dfe46a376f5fbc713cb4", + "size": 127437, + "subdir": "linux-64", + "timestamp": 1574367724054, + "version": "20.0.0" + }, + "gunicorn-20.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "d603de9c865f232b4c1c6bd10b873ff7", + "name": "gunicorn", + "sha256": "24b79d64726b86b8188499b5dda33293a2786b23971f3ae17c2eba78c10c58f9", + "size": 128002, + "subdir": "linux-64", + "timestamp": 1576539113150, + "version": "20.0.4" + }, + "gunicorn-20.0.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "6909d29fe79bc7ec00d3d22c0825332a", + "name": "gunicorn", + "sha256": "5f10ef917bbfa267fea45e992490de22033591df56d31288ff817024350e0d5a", + "size": 126577, + "subdir": "linux-64", + "timestamp": 1615980824610, + "version": "20.0.4" + }, + "gunicorn-20.0.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "1edb3d30788c07a77043c5dec234adce", + "name": "gunicorn", + "sha256": "2ba68334739a5c7ddbee5918118a3bcdd7bebc803f6ab238fcf097745a3984f3", + "size": 126370, + "subdir": "linux-64", + "timestamp": 1576539089525, + "version": "20.0.4" + }, + "gunicorn-20.0.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "b4191e2ab581fb4b44eed900e14cb3f8", + "name": "gunicorn", + "sha256": "875f661cd19e4b76fcb04c8b69221f9aaf87014668431e9bbacf42e8c285d6d3", + "size": 126782, + "subdir": "linux-64", + "timestamp": 1615981110413, + "version": "20.0.4" + }, + "gunicorn-20.0.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "623e0a257509b0fa83114680d3846889", + "name": "gunicorn", + "sha256": "cad2cbb1d52086a4fa9ce043a6c9ccfbd1ec7afe827d27bf102f765d15bfe653", + "size": 128318, + "subdir": "linux-64", + "timestamp": 1576539112556, + "version": "20.0.4" + }, + "gunicorn-20.0.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "b8d5a205ac5cb09f0be8f0231b1415b6", + "name": "gunicorn", + "sha256": "b5abdb872107f6fb600e526efc37da365d0221d051e7026b0f4a91966d71024c", + "size": 126837, + "subdir": "linux-64", + "timestamp": 1615979224269, + "version": "20.0.4" + }, + "gunicorn-20.0.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "7758420a85be4dbe301b5bc4a51f8896", + "name": "gunicorn", + "sha256": "b60d84f91f6de339b82b54ed5c7cfffec38e7840b130b6f936790136e77a3bfa", + "size": 128879, + "subdir": "linux-64", + "timestamp": 1615982984732, + "version": "20.0.4" + }, + "gunicorn-20.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "cf8ee2889d445e904f123d91b34da903", + "name": "gunicorn", + "sha256": "0c70774e7c56860742289e24fd1201d583f471465a4c5843ad69cea2e728dfea", + "size": 126674, + "subdir": "linux-64", + "timestamp": 1640790751007, + "version": "20.1.0" + }, + "gunicorn-20.1.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "72d951c2c72e587e91238c90c7f12e72", + "name": "gunicorn", + "sha256": "22fd543e98f41e7a3914b604c2449a69fcdffd51c0cfd2566f022ffd8376faa2", + "size": 171448, + "subdir": "linux-64", + "timestamp": 1676830795360, + "version": "20.1.0" + }, + "gunicorn-20.1.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "b80b1867f86041963ab608625076ef38", + "name": "gunicorn", + "sha256": "b32a8c2ac7ced93a6aa3fad0bdc91feaf63f7164adb01b1d68ac41cb72f131e6", + "size": 124211, + "subdir": "linux-64", + "timestamp": 1617118223053, + "version": "20.1.0" + }, + "gunicorn-20.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "316df9a67b3b56d89b521369bd0f98db", + "name": "gunicorn", + "sha256": "22ead8dd7729c50bec9151115b526a1287454f89cd543538bbe99e073aa4728f", + "size": 124557, + "subdir": "linux-64", + "timestamp": 1617120680866, + "version": "20.1.0" + }, + "gunicorn-20.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "f35a6591a01d0a9dd306621f1f7ca918", + "name": "gunicorn", + "sha256": "d7dc59526ea133fc4d1d48b0ab64913eb4c52790eb4db953aca3ff583a6c74d2", + "size": 124799, + "subdir": "linux-64", + "timestamp": 1617120686537, + "version": "20.1.0" + }, + "gunicorn-20.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "3b17c6474ff27dff92a8c533ab80c653", + "name": "gunicorn", + "sha256": "0e192a8623164c8cd364fb7d3341ecda9e83cd4455c8edcb18ca56d74e615e4a", + "size": 125413, + "subdir": "linux-64", + "timestamp": 1617118229902, + "version": "20.1.0" + }, + "gxx-dbg_linux-64-7.2.0-19.conda": { + "build": "19", + "build_number": 19, + "depends": [ + "binutils_linux-64 7.2.0 19", + "gcc-dbg_linux-64 7.2.0 19", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "50a9bb46884c0fb3d7fae6adde005399", + "name": "gxx-dbg_linux-64", + "sha256": "36df5c95f43f410be1825ace558254e74975e279836aac20962d51b105386490", + "size": 5965, + "subdir": "linux-64", + "timestamp": 1513886593194, + "version": "7.2.0" + }, + "gxx-dbg_linux-64-7.2.0-24.conda": { + "build": "24", + "build_number": 24, + "depends": [ + "binutils_linux-64 7.2.0 24", + "gcc-dbg_linux-64 7.2.0 24", + "gxx_impl_linux-64 7.2.0.*", + "package_has_been_revoked" + ], + "license": "GPL", + "md5": "7fd07adbf6ce51c06e3353aaf6e5edc4", + "name": "gxx-dbg_linux-64", + "revoked": true, + "sha256": "536377e4990c23c6dfa3bf8dd0cf5279a1fef8902a5f9f3d91279dd99e3dcbd1", + "size": 5379, + "subdir": "linux-64", + "timestamp": 1514480887691, + "version": "7.2.0" + }, + "gxx-dbg_linux-64-7.2.0-25.conda": { + "build": "25", + "build_number": 25, + "depends": [ + "binutils_linux-64 7.2.0 25", + "gcc-dbg_linux-64 7.2.0 25", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "5bc480d5f9f3310d080e1c198e68e377", + "name": "gxx-dbg_linux-64", + "sha256": "f36b9eed85eeed5724f03e2847451aaf2ce3d7c6f35a6961e8f6efe26ed6cec7", + "size": 5390, + "subdir": "linux-64", + "timestamp": 1515156402667, + "version": "7.2.0" + }, + "gxx-dbg_linux-64-7.3.0-h553295d_1.conda": { + "build": "h553295d_1", + "build_number": 1, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_1", + "gcc-dbg_linux-64 7.3.0 h553295d_1", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "4f0c3fa9f6d15aa5a1d074d30866917a", + "name": "gxx-dbg_linux-64", + "sha256": "2f65973938ef6bcc939b6a159a278587e9c3a7dfea1a4992cc93404d2ddc04de", + "size": 10116, + "subdir": "linux-64", + "timestamp": 1534694164189, + "version": "7.3.0" + }, + "gxx-dbg_linux-64-7.3.0-h553295d_2.conda": { + "build": "h553295d_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_2", + "gcc-dbg_linux-64 7.3.0 h553295d_2", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "6bb997065030dbfdc4cd086a47e30074", + "name": "gxx-dbg_linux-64", + "sha256": "5caa1427fb072e8c6a88eb04c2beb9d6d6168dacff3256bb6b5ad3997996321c", + "size": 10167, + "subdir": "linux-64", + "timestamp": 1534794499906, + "version": "7.3.0" + }, + "gxx-dbg_linux-64-7.3.0-h553295d_26.conda": { + "build": "h553295d_26", + "build_number": 26, + "depends": [ + "binutils_linux-64 7.3.0 h6176602_26", + "gcc-dbg_linux-64 7.3.0 h553295d_26", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "595bfad3b4deff8eb8545ac9474d7b12", + "name": "gxx-dbg_linux-64", + "sha256": "4292e16a85a349e12183fbdef31097358baf016a0dbf27b0a0a8c17c302f1362", + "size": 9615, + "subdir": "linux-64", + "timestamp": 1534693909906, + "version": "7.3.0" + }, + "gxx-dbg_linux-64-8.2.0-h218040c_1.conda": { + "build": "h218040c_1", + "build_number": 1, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_1", + "gcc-dbg_linux-64 8.2.0 h218040c_1", + "gxx_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "e4adf3a7c1eed1b8942a7e6f5a1f7be7", + "name": "gxx-dbg_linux-64", + "sha256": "5f8e0a4a5fe494b818fc261f36de5831d3146c745888831081408a1a5b4cecaf", + "size": 10114, + "subdir": "linux-64", + "timestamp": 1534694057047, + "version": "8.2.0" + }, + "gxx-dbg_linux-64-8.2.0-h218040c_26.conda": { + "build": "h218040c_26", + "build_number": 26, + "depends": [ + "binutils_linux-64 8.2.0 h6176602_26", + "gcc-dbg_linux-64 8.2.0 h218040c_26", + "gxx_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "31d6704b98a2284b2f991a897d50212a", + "name": "gxx-dbg_linux-64", + "sha256": "c2b66006d8a58ed20edb80273d058a2ba5272e1a5133ecc12b0fba843df4aa72", + "size": 9617, + "subdir": "linux-64", + "timestamp": 1534693825575, + "version": "8.2.0" + }, + "gxx_impl_linux-64-11.2.0-h1234567_0.conda": { + "build": "h1234567_0", + "build_number": 0, + "depends": [ + "gcc_impl_linux-64 11.2.0 h1234567_0", + "libstdcxx-devel_linux-64 11.2.0 h1234567_0", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "58ac39bd856c30b62f29582460f416e9", + "name": "gxx_impl_linux-64", + "sha256": "4002726b7be824f22ad56a645f8fc2603a2e9e30c3ae30f303554ac184941358", + "size": 11102097, + "subdir": "linux-64", + "timestamp": 1652859909107, + "version": "11.2.0" + }, + "gxx_impl_linux-64-11.2.0-h1234567_1.conda": { + "build": "h1234567_1", + "build_number": 1, + "depends": [ + "gcc_impl_linux-64 11.2.0 h1234567_1", + "libstdcxx-devel_linux-64 11.2.0 h1234567_1", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "ec50e36f61b272654fc17378c7b0b33d", + "name": "gxx_impl_linux-64", + "sha256": "304b012f0a67f19f812e9dc02ed8d601b048e608e82bbab98c589eb0595c1459", + "size": 11142713, + "subdir": "linux-64", + "timestamp": 1654091011628, + "version": "11.2.0" + }, + "gxx_impl_linux-64-5.4.0-hdf63c60_3.conda": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [ + "gcc_impl_linux-64 5.4.0 habb00fd_3" + ], + "license": "GPL", + "md5": "d029ea68ab134ef8fdfa893cc6349d21", + "name": "gxx_impl_linux-64", + "sha256": "16f5387a62cf3b02bd3181cef1a4c10a6c0b8540b71118e0e1194c304fbf4d3f", + "size": 13998449, + "subdir": "linux-64", + "timestamp": 1520969771600, + "version": "5.4.0" + }, + "gxx_impl_linux-64-7.2.0-hd3faf3d_2.conda": { + "build": "hd3faf3d_2", + "build_number": 2, + "depends": [ + "gcc_impl_linux-64 7.2.0 hc5ce805_2" + ], + "license": "GPL", + "md5": "ac70eed2965189e011b9e9e83b711819", + "name": "gxx_impl_linux-64", + "sha256": "bcaf6d40471c2bc8c49cf0efab609a5b875f67dd7b5a0f8add847f7f4cff35f0", + "size": 15653069, + "subdir": "linux-64", + "timestamp": 1507263089640, + "version": "7.2.0" + }, + "gxx_impl_linux-64-7.2.0-hdf63c60_3.conda": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [ + "gcc_impl_linux-64 7.2.0 habb00fd_3" + ], + "license": "GPL", + "md5": "b3736d134265aabca0e6653371944fec", + "name": "gxx_impl_linux-64", + "sha256": "a0e3fadbbd2fd44416ee027f352d578958c9c606eb8f5a6a733a76a62da7e761", + "size": 15656962, + "subdir": "linux-64", + "timestamp": 1520534791657, + "version": "7.2.0" + }, + "gxx_impl_linux-64-7.3.0-hdf63c60_0.conda": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [ + "gcc_impl_linux-64 7.3.0 habb00fd_0" + ], + "license": "GPL", + "md5": "b89ccde5e5b1c6dba3ed8b1b5fce9a9b", + "name": "gxx_impl_linux-64", + "sha256": "285476f9406cbcf7db22b090b2018daa92df24e2dbecf3b806c2fae9b8ea6246", + "size": 15727283, + "subdir": "linux-64", + "timestamp": 1534628679813, + "version": "7.3.0" + }, + "gxx_impl_linux-64-7.3.0-hdf63c60_1.conda": { + "build": "hdf63c60_1", + "build_number": 1, + "depends": [ + "gcc_impl_linux-64 7.3.0 habb00fd_1" + ], + "license": "GPL", + "md5": "45e233ce123935461a36f32d6f6852aa", + "name": "gxx_impl_linux-64", + "sha256": "5541f1eaf439c0d24841129c143cae4631e91870729d5c00ba57da88b7a149e6", + "size": 15724529, + "subdir": "linux-64", + "timestamp": 1534866887969, + "version": "7.3.0" + }, + "gxx_impl_linux-64-7.5.0-h0a5bf11_17.conda": { + "build": "h0a5bf11_17", + "build_number": 17, + "depends": [ + "gcc_impl_linux-64 7.5.0 h7105cf2_17", + "libstdcxx-devel_linux-64 7.5.0 hf0c5c8d_17", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "b1d16bc1fbeace05ef1cfc1d2bd0d94a", + "name": "gxx_impl_linux-64", + "sha256": "2d21f2821d1a029e14d02a29b83c1a86a33ee8e7ad6ae7f8ea5339189e4f15eb", + "size": 8891647, + "subdir": "linux-64", + "timestamp": 1622660315993, + "version": "7.5.0" + }, + "gxx_impl_linux-64-8.4.0-h9ce2e92_17.conda": { + "build": "h9ce2e92_17", + "build_number": 17, + "depends": [ + "gcc_impl_linux-64 8.4.0 he7ac559_17", + "libstdcxx-devel_linux-64 8.4.0 hf0c5c8d_17", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "0476c3fdd985680bfb445778ead0b98e", + "name": "gxx_impl_linux-64", + "sha256": "3c838652c7d573088442a27ffad6a4a4b759d76cc9f70e2194302892a625a28a", + "size": 9383170, + "subdir": "linux-64", + "timestamp": 1622661931975, + "version": "8.4.0" + }, + "gxx_impl_linux-64-9.3.0-hbdd7822_17.conda": { + "build": "hbdd7822_17", + "build_number": 17, + "depends": [ + "gcc_impl_linux-64 9.3.0 h6df7d76_17", + "libstdcxx-devel_linux-64 9.3.0 hf0c5c8d_17", + "sysroot_linux-64" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "fb4e3e41be4d9cbf3029eae8e39b3c0f", + "name": "gxx_impl_linux-64", + "sha256": "a20d66d9c465ff5ddd1a6ca4b9e7871b928766ee575d72b0a9d29488e1341da7", + "size": 9431612, + "subdir": "linux-64", + "timestamp": 1622663583351, + "version": "9.3.0" + }, + "gxx_linux-64-11.2.0-hc2dff05_0.conda": { + "build": "hc2dff05_0", + "build_number": 0, + "depends": [ + "binutils_linux-64 2.38.0 hc2dff05_0", + "gcc_linux-64 11.2.0 h5c386dc_0", + "gxx_impl_linux-64 11.2.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "53c889a1eb287643e5b1986643907ef1", + "name": "gxx_linux-64", + "sha256": "3a79b4e628e108f85461fc32dc3ae6498357dd6ffef72d4719de187e8fc48db3", + "size": 24975, + "subdir": "linux-64", + "timestamp": 1652867219256, + "version": "11.2.0" + }, + "gxx_linux-64-5.4.0-h98af8de_24.conda": { + "build": "h98af8de_24", + "build_number": 24, + "depends": [ + "binutils_linux-64 5.4.0 had2808c_24", + "gcc_linux-64 5.4.0 h98af8de_24", + "gxx_impl_linux-64 5.4.0.*" + ], + "license": "GPL", + "md5": "db863a54642b849eaa0439f390335a26", + "name": "gxx_linux-64", + "sha256": "71aa3c1c5aebc8190726fc198c46b407a3a6927b980c40ebba03a352be9084a6", + "size": 9173, + "subdir": "linux-64", + "timestamp": 1520970089793, + "version": "5.4.0" + }, + "gxx_linux-64-7.2.0-19.conda": { + "build": "19", + "build_number": 19, + "depends": [ + "binutils_linux-64 7.2.0 19", + "gcc_linux-64 7.2.0 19", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "f2854f96c304249c20dba30c8d89e24e", + "name": "gxx_linux-64", + "sha256": "06cf6ea85a364049559f43896007695621adec74c794fafe60660b71af770ecf", + "size": 5859, + "subdir": "linux-64", + "timestamp": 1513886715267, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-24.conda": { + "build": "24", + "build_number": 24, + "depends": [ + "package_has_been_revoked" + ], + "license": "GPL", + "md5": "319141c33e2665928e986d293b709f78", + "name": "gxx_linux-64", + "revoked": true, + "sha256": "3c71898e74447ac7e49e33875faae3a5c06cb2c1d5fafa94ab1034d2216f712d", + "size": 5298, + "subdir": "linux-64", + "timestamp": 1514474639180, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-25.conda": { + "build": "25", + "build_number": 25, + "depends": [ + "binutils_linux-64 7.2.0 25", + "gcc_linux-64 7.2.0 25", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "30664b3c1733e3248cdd2c502896ee0b", + "name": "gxx_linux-64", + "sha256": "66ce74d81f955c38d26f7edd64f150308631e8e804d19125e883e25f465f373a", + "size": 5353, + "subdir": "linux-64", + "timestamp": 1514480906560, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-26.conda": { + "build": "26", + "build_number": 26, + "depends": [ + "binutils_linux-64 7.2.0 26", + "gcc_linux-64 7.2.0 26", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "1f45325757772ce58897c3d97ebae0cc", + "name": "gxx_linux-64", + "sha256": "f0d67b2e4a86cc3d23b87c11579f7bbf127b02b1a4765e4bbc156f8e31afc8b1", + "size": 9283, + "subdir": "linux-64", + "timestamp": 1521829433260, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h2e50c1c_15.conda": { + "build": "h2e50c1c_15", + "build_number": 15, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_15", + "gcc_linux-64 7.2.0 haf1f6fa_15", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "6839ee6461f98dda743e5a42a1f9517d", + "name": "gxx_linux-64", + "sha256": "a60f311f253d3ea1495146f806220fdebfb431ab8b660813d995e806e2948aee", + "size": 5568, + "subdir": "linux-64", + "timestamp": 1511640860559, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h33f4dac_3.conda": { + "build": "h33f4dac_3", + "build_number": 3, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_3", + "gcc_linux-64 7.2.0 h29fd5c9_3", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "df6d66111893a852c6c94c7a8b781907", + "name": "gxx_linux-64", + "sha256": "bfd13a21e9c5415dc33d6c380c4ed77128962dd9a4aa42ff3d7db0a4bbc0ff52", + "size": 5393, + "subdir": "linux-64", + "timestamp": 1507320237462, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h3aab023_7.conda": { + "build": "h3aab023_7", + "build_number": 7, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_7", + "gcc_linux-64 7.2.0 h22f992b_7", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "0bdd359ea81f4c4700e9658d91bc0233", + "name": "gxx_linux-64", + "sha256": "fa98a71e78985c90e16b8b565130536e15e128ff51730609806946494a580406", + "size": 5167, + "subdir": "linux-64", + "timestamp": 1507845399923, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h41d9e3f_12.conda": { + "build": "h41d9e3f_12", + "build_number": 12, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_12", + "gcc_linux-64 7.2.0 hd763dfe_12", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "5568ea3965d9910ad4992cdc7d7b0954", + "name": "gxx_linux-64", + "sha256": "be8f5a812075376d0b2fc3e4cdc50f6d12c403e6e03c5b054d95d0bbbb842f0c", + "size": 5987, + "subdir": "linux-64", + "timestamp": 1510792710651, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h4bc98f9_14.conda": { + "build": "h4bc98f9_14", + "build_number": 14, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_14", + "gcc_linux-64 7.2.0 hf1c97a4_14", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "459dc5d707737a548cd3157fc209816a", + "name": "gxx_linux-64", + "sha256": "67d9561792764724036b682053e6f79dc50f09bc523e6da675c9c30ba5fdaed6", + "size": 5556, + "subdir": "linux-64", + "timestamp": 1510930965483, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h550dcbe_27.conda": { + "build": "h550dcbe_27", + "build_number": 27, + "depends": [ + "binutils_linux-64 7.2.0 had2808c_27", + "gcc_linux-64 7.2.0 h550dcbe_27", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "88af4146c146e6d2f834694adeaf78d9", + "name": "gxx_linux-64", + "sha256": "157fc378132af784d48498af9a610520f8780903af895521dba0f020edabf1c1", + "size": 9268, + "subdir": "linux-64", + "timestamp": 1526461261504, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h57110d4_9.conda": { + "build": "h57110d4_9", + "build_number": 9, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_9", + "gcc_linux-64 7.2.0 h60973fd_9", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "653d63e593fe0aa6d295ae6d9967cf68", + "name": "gxx_linux-64", + "sha256": "4211ab8c01785fda28da983f1b39d8cafbc647eeb8bef3017eed0d4b5bbb7d82", + "size": 5383, + "subdir": "linux-64", + "timestamp": 1509836580115, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h5e79354_11.conda": { + "build": "h5e79354_11", + "build_number": 11, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_11", + "gcc_linux-64 7.2.0 h4118e58_11", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "b3c775b8e9db9e3d2bfac679809ccbfe", + "name": "gxx_linux-64", + "sha256": "dea4675d91d9838690cfd914157b637d4a08925626ee224b37ea59ffcfbc997b", + "size": 5377, + "subdir": "linux-64", + "timestamp": 1510566120000, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h60a51f1_2.conda": { + "build": "h60a51f1_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_2", + "gcc_linux-64 7.2.0 hecb3f9c_2", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "4d7ee45fb9803fa83f4bcfdd0734e4b7", + "name": "gxx_linux-64", + "sha256": "97975762780c7d184aa9922546ffa0f1d05dec6be13907ea3d6717a3be24233a", + "size": 5395, + "subdir": "linux-64", + "timestamp": 1507320101324, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h7798672_13.conda": { + "build": "h7798672_13", + "build_number": 13, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_13", + "gcc_linux-64 7.2.0 h217957b_13", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "d6c71ec208870f661185e1d46ec34248", + "name": "gxx_linux-64", + "sha256": "f23190dcc23aabd7d0e4bc57098f8a7b8aa45c5d8f1df57cb60ce78cc690f59c", + "size": 5553, + "subdir": "linux-64", + "timestamp": 1510925049582, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-h8cc0f3c_1.conda": { + "build": "h8cc0f3c_1", + "build_number": 1, + "depends": [ + "gcc_linux-64 7.2.0 hc7b1ceb_1", + "libstdcxx-ng 7.2.0 h24385c6_1" + ], + "license": "GPL", + "md5": "af3e6445d0aaeaa5f47dc6bee596fc2a", + "name": "gxx_linux-64", + "sha256": "8f64fe33a93767759096e1004d68622c3a881a5d8d37bcf64a1056b0e45f2352", + "size": 15713292, + "subdir": "linux-64", + "timestamp": 1505665795414, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-hc01b44c_10.conda": { + "build": "hc01b44c_10", + "build_number": 10, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_10", + "gcc_linux-64 7.2.0 h196ecd4_10", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "720a108b4bbeb7ce3c5c3f79af58a8c2", + "name": "gxx_linux-64", + "sha256": "3382d783496bf8b3d8d16a05d9dc938240d9ce946f308bbd5d8bbe84f627a7ce", + "size": 5309, + "subdir": "linux-64", + "timestamp": 1510244820492, + "version": "7.2.0" + }, + "gxx_linux-64-7.2.0-he93fcd3_8.conda": { + "build": "he93fcd3_8", + "build_number": 8, + "depends": [ + "binutils_linux-64 7.2.0 hc67e822_8", + "gcc_linux-64 7.2.0 h6f34251_8", + "gxx_impl_linux-64 7.2.0.*" + ], + "license": "GPL", + "md5": "fab8111a4d95dd9d9863db0fa2494cba", + "name": "gxx_linux-64", + "sha256": "ae93aa428b8db156568ef5daee913b968bb39ea260c21b42e3aa2973a25bdbde", + "size": 5117, + "subdir": "linux-64", + "timestamp": 1509635179708, + "version": "7.2.0" + }, + "gxx_linux-64-7.3.0-h553295d_15.conda": { + "build": "h553295d_15", + "build_number": 15, + "depends": [ + "binutils_linux-64 2.33.1 h9595d00_15", + "gcc_linux-64 7.3.0 h553295d_15", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "BSD-3-Clause", + "md5": "4dde80b0f7aa6e16d289a9cb768f014e", + "name": "gxx_linux-64", + "sha256": "f0025a588bbf648693cfcff34acee291d76f31052363ab729e10aa12e9cf2625", + "size": 26982, + "subdir": "linux-64", + "timestamp": 1576707760857, + "version": "7.3.0" + }, + "gxx_linux-64-7.3.0-h553295d_2.conda": { + "build": "h553295d_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_2", + "gcc_linux-64 7.3.0 h553295d_2", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "994c858fd3378582bb967313252f1068", + "name": "gxx_linux-64", + "sha256": "c856dd246f479952d272aa268fbd6211f3086eb4d6c04a5d410cb4e29064a2cc", + "size": 10174, + "subdir": "linux-64", + "timestamp": 1534793060512, + "version": "7.3.0" + }, + "gxx_linux-64-7.3.0-h553295d_3.conda": { + "build": "h553295d_3", + "build_number": 3, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_3", + "gcc_linux-64 7.3.0 h553295d_3", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "90b0edb425a809b08b5a46861394d8e5", + "name": "gxx_linux-64", + "sha256": "4424708daf8798da04b5f5ecd6e83138536fd9c2dca9cb23923c94f5ab38cff2", + "size": 10160, + "subdir": "linux-64", + "timestamp": 1534948650088, + "version": "7.3.0" + }, + "gxx_linux-64-7.3.0-h553295d_6.conda": { + "build": "h553295d_6", + "build_number": 6, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_6", + "gcc_linux-64 7.3.0 h553295d_6", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "c87973ff87e7b1e7fae38fb272273acc", + "name": "gxx_linux-64", + "sha256": "976f4acea4f410de9b8e0cedd4e622f70ee89b97646e3e8b2c4ae01b11db963e", + "size": 11227, + "subdir": "linux-64", + "timestamp": 1546883616664, + "version": "7.3.0" + }, + "gxx_linux-64-7.3.0-h553295d_7.conda": { + "build": "h553295d_7", + "build_number": 7, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_7", + "gcc_linux-64 7.3.0 h553295d_7", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "167e54ef5d1669eccb3edf1bb2e29fbe", + "name": "gxx_linux-64", + "sha256": "1973ee9a075ec685fa3d1274c7e0b7dbe645c2b3544a38f45c73309ebffdc90e", + "size": 10295, + "subdir": "linux-64", + "timestamp": 1556137070192, + "version": "7.3.0" + }, + "gxx_linux-64-7.3.0-h553295d_8.conda": { + "build": "h553295d_8", + "build_number": 8, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_8", + "gcc_linux-64 7.3.0 h553295d_8", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "GPL", + "md5": "91c9927f933a2c8e7831340b38f54944", + "name": "gxx_linux-64", + "sha256": "19a3869372c5add3d8331d38807c77efd988c3d935c8209e80648b158bbc1b82", + "size": 173310, + "subdir": "linux-64", + "timestamp": 1565123741742, + "version": "7.3.0" + }, + "gxx_linux-64-7.3.0-h553295d_9.conda": { + "build": "h553295d_9", + "build_number": 9, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_9", + "gcc_linux-64 7.3.0 h553295d_9", + "gxx_impl_linux-64 7.3.0.*" + ], + "license": "BSD-3-Clause", + "md5": "a6b0bfbc0fa358986ece074db945c8dc", + "name": "gxx_linux-64", + "sha256": "098c8dfb7443c4da881357bc47eea02d9129fc247c5ca363aa821e98ea9091c9", + "size": 26990, + "subdir": "linux-64", + "timestamp": 1576689718754, + "version": "7.3.0" + }, + "gxx_linux-64-7.5.0-hffc177d_30.conda": { + "build": "hffc177d_30", + "build_number": 30, + "depends": [ + "binutils_linux-64 2.35.1 h454624a_30", + "gcc_linux-64 7.5.0 h8f34230_30", + "gxx_impl_linux-64 7.5.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "c9c5c71031196b05647a95b1fb9be65f", + "name": "gxx_linux-64", + "sha256": "8492bf90d37f87700a21c3695769b683e18ed703938d5bf3cc451ff1f9a7dcb7", + "size": 24694, + "subdir": "linux-64", + "timestamp": 1623135032961, + "version": "7.5.0" + }, + "gxx_linux-64-8.2.0-h218040c_2.conda": { + "build": "h218040c_2", + "build_number": 2, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_2", + "gcc_linux-64 8.2.0 h218040c_2", + "gxx_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "ea86d27845a93dc43ad87cf1121422ed", + "name": "gxx_linux-64", + "sha256": "3dca5fd5ec8f4639c066da1ba7896eecce12e1c93b27d4359d36379e1be24315", + "size": 10163, + "subdir": "linux-64", + "timestamp": 1534792667384, + "version": "8.2.0" + }, + "gxx_linux-64-8.2.0-h218040c_3.conda": { + "build": "h218040c_3", + "build_number": 3, + "depends": [ + "binutils_linux-64 2.31.1 h6176602_3", + "gcc_linux-64 8.2.0 h218040c_3", + "gxx_impl_linux-64 8.2.0.*" + ], + "license": "GPL", + "md5": "6e22705ac5cc9712f4eb956f9230ba1b", + "name": "gxx_linux-64", + "sha256": "f987ec7f2aba32d83aa8882db80fff7ee737d0ccf46acabb28bf443604907672", + "size": 11232, + "subdir": "linux-64", + "timestamp": 1546883594184, + "version": "8.2.0" + }, + "gxx_linux-64-8.4.0-h85ed34b_30.conda": { + "build": "h85ed34b_30", + "build_number": 30, + "depends": [ + "binutils_linux-64 2.35.1 h454624a_30", + "gcc_linux-64 8.4.0 he201b7d_30", + "gxx_impl_linux-64 8.4.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "2c6f3c3be9c204deba2d51fb59b1fde3", + "name": "gxx_linux-64", + "sha256": "d4dfc85a42047911c281e98882d23fef6394d2edc967f8357b4f678fe8557b84", + "size": 24618, + "subdir": "linux-64", + "timestamp": 1623135567676, + "version": "8.4.0" + }, + "gxx_linux-64-9.3.0-h7e70986_30.conda": { + "build": "h7e70986_30", + "build_number": 30, + "depends": [ + "binutils_linux-64 2.35.1 h454624a_30", + "gcc_linux-64 9.3.0 h1ee779e_30", + "gxx_impl_linux-64 9.3.0.*", + "sysroot_linux-64" + ], + "license": "BSD-3-Clause", + "md5": "99d331288cc3a73e68cc8fea2e17a861", + "name": "gxx_linux-64", + "sha256": "795cb10a747c8ee648947c4cb414ab4ff05074b923747049f2b98050d242b9b2", + "size": 24694, + "subdir": "linux-64", + "timestamp": 1623136142801, + "version": "9.3.0" + }, + "gymnasium-0.26.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.2.0", + "gymnasium-notices", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "903ea478b4186b0b4903f30be6e1ef7b", + "name": "gymnasium", + "sha256": "946838b846d4d8f45bff9bff78094f8dd51bbe2e237dca12019db9d55eb8528b", + "size": 865226, + "subdir": "linux-64", + "timestamp": 1678091784144, + "version": "0.26.3" + }, + "gymnasium-0.26.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.2.0", + "gymnasium-notices", + "importlib_metadata >=4.8.1", + "numpy >=1.19.5,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa84dc55ea47ffc460afad7b52c9c02e", + "name": "gymnasium", + "sha256": "22f488eea85717e70df028eca9770deacaac92cad177fa5b85142ed0f10cb322", + "size": 862455, + "subdir": "linux-64", + "timestamp": 1678091696810, + "version": "0.26.3" + }, + "gymnasium-0.26.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.2.0", + "gymnasium-notices", + "importlib_metadata >=4.8.1", + "numpy >=1.19.5,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49c9a99465ccd2a5ece0c0d2535bbd27", + "name": "gymnasium", + "sha256": "12b28619bb896978e471abbf480ce3aacd5fe0fca13ac4ec2e139a76ef8df726", + "size": 862332, + "subdir": "linux-64", + "timestamp": 1678091740601, + "version": "0.26.3" + }, + "gymnasium-notices-0.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "287f9a0b438146770ccd52d84a52e246", + "name": "gymnasium-notices", + "sha256": "20cbb8283fe6fb723064090725aec45508feade26f2afc10da41aa2b197342f3", + "size": 7284, + "subdir": "linux-64", + "timestamp": 1677830286713, + "version": "0.0.1" + }, + "gymnasium-notices-0.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4afe30628f57c125cffbad91f567c83a", + "name": "gymnasium-notices", + "sha256": "85ac62fbcc5398afd009e29235e141ee70d8293e0403b1844e2c30bc83d93d81", + "size": 7235, + "subdir": "linux-64", + "timestamp": 1677830262325, + "version": "0.0.1" + }, + "gymnasium-notices-0.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "edbb5557b8c361e0dad7bba7d516bab0", + "name": "gymnasium-notices", + "sha256": "d8f4fd1435c6695d1df31fcedc6ada60bfe95179034000d42ea4b3d3cbbbffeb", + "size": 7234, + "subdir": "linux-64", + "timestamp": 1677830238500, + "version": "0.0.1" + }, + "h2-3.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34 >=1.1.6,<2", + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77a0621f9bae239d0658ae4c38b0ab19", + "name": "h2", + "sha256": "ec1219abfd466b6acd6ebe80063103c217513b6327876826356d1348bfecb94a", + "size": 80840, + "subdir": "linux-64", + "timestamp": 1530919165874, + "version": "3.0.1" + }, + "h2-3.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb4361a5cb8d3cc20aa57bec88980f6b", + "name": "h2", + "sha256": "df82cb12a607ec9db4027d04d14162e36644eb558248ee6ac67fe9c557be0c39", + "size": 81243, + "subdir": "linux-64", + "timestamp": 1530919107631, + "version": "3.0.1" + }, + "h2-3.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b2ffb9a7762be9ac4e653741ce289d6", + "name": "h2", + "sha256": "f708621897e0af70bfc0f3195831baedf9e8f018706c59c295b6466dd0e21626", + "size": 81257, + "subdir": "linux-64", + "timestamp": 1530919136798, + "version": "3.0.1" + }, + "h2-3.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34 >=1.1.6,<2", + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d68b0ae1afa391456594e915d937a231", + "name": "h2", + "sha256": "069db5773ecfa5fbe293d66cb58c3958a3fe21f30e832f204b0a9ba09bec1373", + "size": 83516, + "subdir": "linux-64", + "timestamp": 1552378479679, + "version": "3.1.0" + }, + "h2-3.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ab5de2d8243bfb4c591fdbc685369ca", + "name": "h2", + "sha256": "3aab99db9e100d1b3731b68be2da4ed51a39e71d3b21f6a948ba3c4fd4f43970", + "size": 86175, + "subdir": "linux-64", + "timestamp": 1552378546254, + "version": "3.1.0" + }, + "h2-3.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "331f3066becbfe5f2cf2389f4f45c3a7", + "name": "h2", + "sha256": "3bb457ade3d103929befd0d4c4aab334af8b8f1edae5a3cd5ba1674b9e32f7e3", + "size": 86143, + "subdir": "linux-64", + "timestamp": 1552378459512, + "version": "3.1.0" + }, + "h2-3.1.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "enum34 >=1.1.6,<2", + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c05d702096700840249436c03999ac0b", + "name": "h2", + "sha256": "3aa9907b02c346ba0220aec9f6e93f4864413821b00d339bf5159a11e1fe9641", + "size": 85618, + "subdir": "linux-64", + "timestamp": 1569424037301, + "version": "3.1.1" + }, + "h2-3.1.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c682c6733fec472c7bf0384553b00e21", + "name": "h2", + "sha256": "f8c104fab9f9422cea4f14fa3104060001caa7325ed023db58fa333027406ab2", + "size": 86502, + "subdir": "linux-64", + "timestamp": 1569424080764, + "version": "3.1.1" + }, + "h2-3.1.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "61339bc06511c33eebda80b44a13e1fa", + "name": "h2", + "sha256": "49e0d6795a11ddcb5a11127bb59a205b6b59b98b3eb5f3b7f559357267657285", + "size": 86534, + "subdir": "linux-64", + "timestamp": 1569424075409, + "version": "3.1.1" + }, + "h2-3.1.1-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "209af731288487751ca5651ac9fc0f92", + "name": "h2", + "sha256": "0da4e77cfbf004162581bc56ff8d7906940bc72730144cd10a9e8fa9f85acc61", + "size": 85759, + "subdir": "linux-64", + "timestamp": 1573739755358, + "version": "3.1.1" + }, + "h2-3.2.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c471ceb8359568c8f6d87149211af5e", + "name": "h2", + "sha256": "8d7ae3757a806d78e775609621e8db86a276b62c82653fb004e881690b6201ea", + "size": 87797, + "subdir": "linux-64", + "timestamp": 1584958576925, + "version": "3.2.0" + }, + "h2-3.2.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9cbbff26bc129f66224a246b9efe732f", + "name": "h2", + "sha256": "624e566cf0a4f05dc274c85343b1e96fdfcd932fcb0c0cf7cf0e2f76457911e0", + "size": 87705, + "subdir": "linux-64", + "timestamp": 1584958518329, + "version": "3.2.0" + }, + "h2-3.2.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "255c5aa67299f76190cdae73f526ca7d", + "name": "h2", + "sha256": "d19d3528a9703f588b241d02e0ed9a80351bd1c15ac2438b4b2d831250fce2ce", + "size": 88155, + "subdir": "linux-64", + "timestamp": 1584958552513, + "version": "3.2.0" + }, + "h2-4.0.0-py310h06a4308_3.conda": { + "build": "py310h06a4308_3", + "build_number": 3, + "depends": [ + "hpack >=4.0,<5", + "hyperframe >=6.0,<7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8f51862b654d2462ee2520b90a67edd", + "name": "h2", + "sha256": "623d19820676582fca6a1a72907046a3e3ed61e2a03203309bc8da088cfc8a1c", + "size": 80914, + "subdir": "linux-64", + "timestamp": 1640790768629, + "version": "4.0.0" + }, + "h2-4.0.0-py311h06a4308_3.conda": { + "build": "py311h06a4308_3", + "build_number": 3, + "depends": [ + "hpack >=4.0,<5", + "hyperframe >=6.0,<7", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "611e79acdf7c18edfd29f7125f5d80c1", + "name": "h2", + "sha256": "2b4afb6c1628caf26058ed933b18df11f01e677620eb98d25c27731d294676f0", + "size": 97512, + "subdir": "linux-64", + "timestamp": 1676827200127, + "version": "4.0.0" + }, + "h2-4.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2fdcc0453b08c6333f40c9b85ef3378c", + "name": "h2", + "sha256": "8bbc047aa1597c51f54fbf6f1a170594cf82923641d4422e33878eba52cb20d9", + "size": 78194, + "subdir": "linux-64", + "timestamp": 1600701272196, + "version": "4.0.0" + }, + "h2-4.0.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be2f73445fabb158fb806d9cbcb9fc20", + "name": "h2", + "sha256": "f743da1012d1d32d76fcc5398a18daa50385596947c03ee1bdc42d0b9c37b2b7", + "size": 82174, + "subdir": "linux-64", + "timestamp": 1614083124500, + "version": "4.0.0" + }, + "h2-4.0.0-py36h06a4308_3.conda": { + "build": "py36h06a4308_3", + "build_number": 3, + "depends": [ + "hpack >=4.0,<5", + "hyperframe >=6.0,<7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e34893461c4e0955e6f220534abaa8d", + "name": "h2", + "sha256": "78f49550a51d67a9052ad01243a5d969f8feafd5540646f1d38b654e4200aaad", + "size": 81137, + "subdir": "linux-64", + "timestamp": 1615904362446, + "version": "4.0.0" + }, + "h2-4.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31b4b9d67972464047525ad2ea089824", + "name": "h2", + "sha256": "7624d7a408b3b4e5c4f8f0b6a0bed3a43b295a949d3a9ffa074ff72db893657c", + "size": 78299, + "subdir": "linux-64", + "timestamp": 1600701289652, + "version": "4.0.0" + }, + "h2-4.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2b10c97be889ab7aaf614f573846d1b", + "name": "h2", + "sha256": "82f80d94ee4193c0259c2dfd406361aab8d4cf99590da3fb52d76282872db4fa", + "size": 82223, + "subdir": "linux-64", + "timestamp": 1614082187813, + "version": "4.0.0" + }, + "h2-4.0.0-py37h06a4308_3.conda": { + "build": "py37h06a4308_3", + "build_number": 3, + "depends": [ + "hpack >=4.0,<5", + "hyperframe >=6.0,<7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "57be3a2ff4b6401d7ae142a00189f8c4", + "name": "h2", + "sha256": "7b4e21f0cef3f06615f7cdc0eea4d3612254e9354f26942a65098a3bd9af10ba", + "size": 82747, + "subdir": "linux-64", + "timestamp": 1615904357144, + "version": "4.0.0" + }, + "h2-4.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "50cf1b7c31f7d12b4fe278cf3658aca8", + "name": "h2", + "sha256": "c0c08148a9fa0ec19e5e44b3617913b32154cf068eb3326371d425a3ae297527", + "size": 80225, + "subdir": "linux-64", + "timestamp": 1600701294299, + "version": "4.0.0" + }, + "h2-4.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e2e60b8ad73c96e0c8459e7559a100e", + "name": "h2", + "sha256": "e4725738622841355ea09956e667bbaab2e1199a9d09f9e6b0cc6a0deac2c4e4", + "size": 82631, + "subdir": "linux-64", + "timestamp": 1614082524713, + "version": "4.0.0" + }, + "h2-4.0.0-py38h06a4308_3.conda": { + "build": "py38h06a4308_3", + "build_number": 3, + "depends": [ + "hpack >=4.0,<5", + "hyperframe >=6.0,<7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa72bdcb7c1a4aed6cf7cb5ce7ae9f2e", + "name": "h2", + "sha256": "b21e4be6768b2228f54a4ab18d626ff4fded55a166101e624bd3742d90a13a06", + "size": 83131, + "subdir": "linux-64", + "timestamp": 1615904362475, + "version": "4.0.0" + }, + "h2-4.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "hpack >=2.3,<4", + "hyperframe >=5.1.0,<6", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f97d66dc0aaa65096bee6411657aa11", + "name": "h2", + "sha256": "cc4b5aa790e4c58df197680d7c6d4cdbed67e5473c33ea9ed055f7b9240b36b2", + "size": 82499, + "subdir": "linux-64", + "timestamp": 1614083120606, + "version": "4.0.0" + }, + "h2-4.0.0-py39h06a4308_3.conda": { + "build": "py39h06a4308_3", + "build_number": 3, + "depends": [ + "hpack >=4.0,<5", + "hyperframe >=6.0,<7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e637be9821172400dafddfdd036cb4ae", + "name": "h2", + "sha256": "e911f163dcccd1ccba36674a3eef8ef9b5c26e814714f0c6c6208ac99ea2cbb5", + "size": 82977, + "subdir": "linux-64", + "timestamp": 1615904348776, + "version": "4.0.0" + }, + "h2o-3.18.0.2-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "openjdk" + ], + "md5": "a2a98e672fc6ede2ad4ee389c85914a8", + "name": "h2o", + "sha256": "e52a25c3074ca32f9640e6b9d6e6aa93b03942e42af6df681c0b695873f82f66", + "size": 123966126, + "subdir": "linux-64", + "timestamp": 1520278916714, + "version": "3.18.0.2" + }, + "h2o-py-3.18.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "colorama", + "future", + "patsy", + "python >=2.7,<2.8.0a0", + "requests", + "scikit-learn", + "tabulate" + ], + "md5": "bee0c67fcf2333cbae00d36d7844a65a", + "name": "h2o-py", + "sha256": "02a7d5abf585e83d56d60a6302b1cdbfe59a8f49ee35861e4fb9d1cfb3b5bd5a", + "size": 331419, + "subdir": "linux-64", + "timestamp": 1520279240772, + "version": "3.18.0.2" + }, + "h2o-py-3.18.0.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "colorama", + "future", + "patsy", + "python >=3.5,<3.6.0a0", + "requests", + "scikit-learn", + "tabulate" + ], + "md5": "78da4d0d29b0327b971b2aa719117b87", + "name": "h2o-py", + "sha256": "349173593a588d3556a361b6404954ea9fa99b12cda58befcd12621520c1158b", + "size": 332080, + "subdir": "linux-64", + "timestamp": 1520279562012, + "version": "3.18.0.2" + }, + "h2o-py-3.18.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "colorama", + "future", + "patsy", + "python >=3.6,<3.7.0a0", + "requests", + "scikit-learn", + "tabulate" + ], + "md5": "d3e487ed97a6ceb83552260a04402dd6", + "name": "h2o-py", + "sha256": "65eada37c0efca8140eb0476c1b0d261978a1186205abb04cd9565c740b98d65", + "size": 329450, + "subdir": "linux-64", + "timestamp": 1520279424827, + "version": "3.18.0.2" + }, + "h5py-2.10.0-py36h7918eee_0.conda": { + "build": "py36h7918eee_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "a6b764c1079763a29e678e4df1b6f039", + "name": "h5py", + "sha256": "d6eb1aa5256ea9910ac09ee5ee47f181d44ee8e78a5b3eb6f7d671663e654960", + "size": 1051416, + "subdir": "linux-64", + "timestamp": 1580260071832, + "version": "2.10.0" + }, + "h5py-2.10.0-py36hd6299e0_1.conda": { + "build": "py36hd6299e0_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "fd923cbb36ad7477df501b2549fc8e9e", + "name": "h5py", + "sha256": "ca1f6342f63a19367c9cc4ddc57063c208bbc51d6a4f44fc194939f6786142fe", + "size": 923026, + "subdir": "linux-64", + "timestamp": 1593454278638, + "version": "2.10.0" + }, + "h5py-2.10.0-py37h7918eee_0.conda": { + "build": "py37h7918eee_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "33137f439455af733fdc7f5187c2a03f", + "name": "h5py", + "sha256": "6781f5a4e3bea271416e23dbcf8cc330b42ba0146a9ecacdf3840e48a598bf77", + "size": 1050136, + "subdir": "linux-64", + "timestamp": 1580260008947, + "version": "2.10.0" + }, + "h5py-2.10.0-py37hd6299e0_1.conda": { + "build": "py37hd6299e0_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "e6bb3a210b7fd4fc9821b4533e1fb6f9", + "name": "h5py", + "sha256": "611e54a103d1bc532f5912a61661d30a22bee8729591f0e2ce9118cfcce824ac", + "size": 923307, + "subdir": "linux-64", + "timestamp": 1593454273894, + "version": "2.10.0" + }, + "h5py-2.10.0-py38h7918eee_0.conda": { + "build": "py38h7918eee_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "e04302c498df486884f10d92c999a4fb", + "name": "h5py", + "sha256": "2c32da57298f3a1e8acdf9fde90b1c2612270b75e137120722bd518ff66a55ea", + "size": 1102661, + "subdir": "linux-64", + "timestamp": 1580260036973, + "version": "2.10.0" + }, + "h5py-2.10.0-py38hd6299e0_1.conda": { + "build": "py38hd6299e0_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "5ffdea1e8fb09af8cbb72b0b080b2238", + "name": "h5py", + "sha256": "2a53c4f78901e480b5bcbd3669b3454ca1e6251c990c7135f8b82805dc79dec3", + "size": 970387, + "subdir": "linux-64", + "timestamp": 1593454278766, + "version": "2.10.0" + }, + "h5py-2.10.0-py39hec9cf62_0.conda": { + "build": "py39hec9cf62_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "965e000e0da69685309da30116649187", + "name": "h5py", + "sha256": "d491c3d65b2c308d7ae119a56a3f6115590ec51eb1b3bd681dbf6bf83d61670b", + "size": 968942, + "subdir": "linux-64", + "timestamp": 1608649145845, + "version": "2.10.0" + }, + "h5py-2.7.0-py27h71d1790_1.conda": { + "build": "py27h71d1790_1", + "build_number": 1, + "depends": [ + "hdf5", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "d04270fe5001864db14153a4d764e0c7", + "name": "h5py", + "sha256": "d6aa6ac410f341ed2fb0976ac4ef90f3ec577895164912fc11d066d7fa9286a5", + "size": 907184, + "subdir": "linux-64", + "timestamp": 1505732542922, + "version": "2.7.0" + }, + "h5py-2.7.0-py35h41d5d6e_1.conda": { + "build": "py35h41d5d6e_1", + "build_number": 1, + "depends": [ + "hdf5", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "e0d201c8b0af22da06434e6292af4ad6", + "name": "h5py", + "sha256": "8177a42e985ea778aa085485911bfb60ed3238ee61131d5df26d6f2ec2413b24", + "size": 909385, + "subdir": "linux-64", + "timestamp": 1505732633193, + "version": "2.7.0" + }, + "h5py-2.7.0-py36he81ebca_1.conda": { + "build": "py36he81ebca_1", + "build_number": 1, + "depends": [ + "hdf5", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "82488a079b48eb03219ea6fa5f44f8e3", + "name": "h5py", + "sha256": "84ec197e8417892fc0340f968db7dae490f1c4c26b52625930e741ca1704f023", + "size": 921609, + "subdir": "linux-64", + "timestamp": 1505732727459, + "version": "2.7.0" + }, + "h5py-2.7.1-py27h2697762_0.conda": { + "build": "py27h2697762_0", + "build_number": 0, + "depends": [ + "hdf5", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "6670a58efff540a53475277e8645957b", + "name": "h5py", + "sha256": "8197a35e1c4390750a8293d72ec8d82baf68904119284b0e4c2a9d2212400269", + "size": 907681, + "subdir": "linux-64", + "timestamp": 1511314445067, + "version": "2.7.1" + }, + "h5py-2.7.1-py27ha1f6525_2.conda": { + "build": "py27ha1f6525_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "f2e204545e35761a5961790f3eb3bd09", + "name": "h5py", + "sha256": "e74a9700cceb1ca4e51ad16f16272c7a31576a98b7d5302f9c64f3d3b413da2a", + "size": 889760, + "subdir": "linux-64", + "timestamp": 1527222120427, + "version": "2.7.1" + }, + "h5py-2.7.1-py27he2f5538_0.conda": { + "build": "py27he2f5538_0", + "build_number": 0, + "depends": [ + "hdf5", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "ca387ab183eedda64c4184708c5a0dac", + "name": "h5py", + "sha256": "acaffff89d112486d55c4bb970dc59a7fd654a05a3c5de2630a302b4e07a7cb2", + "size": 893290, + "subdir": "linux-64", + "timestamp": 1511314295975, + "version": "2.7.1" + }, + "h5py-2.7.1-py35h8d53cdc_0.conda": { + "build": "py35h8d53cdc_0", + "build_number": 0, + "depends": [ + "hdf5", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "e33be3fdc7d80a7b010e8f95b97b9d28", + "name": "h5py", + "sha256": "42920aa7c101487dbba0c45ce9db9e0e58f8c25aeaa0f87a334f8a5669c36a40", + "size": 907535, + "subdir": "linux-64", + "timestamp": 1511314302735, + "version": "2.7.1" + }, + "h5py-2.7.1-py35ha1a889d_0.conda": { + "build": "py35ha1a889d_0", + "build_number": 0, + "depends": [ + "hdf5", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "f8d601e9824670df2f5daa4d1be58649", + "name": "h5py", + "sha256": "8776b35a6e81176725a5acd1d64eef4ace23c5a11ad9db686f6a686cf945bf1a", + "size": 894717, + "subdir": "linux-64", + "timestamp": 1511314474461, + "version": "2.7.1" + }, + "h5py-2.7.1-py35ha1f6525_2.conda": { + "build": "py35ha1f6525_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "30753433f3ebf0bd9efa46beb3ddcdb1", + "name": "h5py", + "sha256": "1416e13745cab09297e2b909ea82a8be0a3ec0039f5757a4dfa138c94c23e38e", + "size": 895731, + "subdir": "linux-64", + "timestamp": 1527222166885, + "version": "2.7.1" + }, + "h5py-2.7.1-py36h3585f63_0.conda": { + "build": "py36h3585f63_0", + "build_number": 0, + "depends": [ + "hdf5", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "942a229cf50bcfc520ee8350a266c392", + "name": "h5py", + "sha256": "e13d33acd047925514b7d1b397a4fb2ef6b37d3c98238594b20ac9dab5062a05", + "size": 920395, + "subdir": "linux-64", + "timestamp": 1511314482473, + "version": "2.7.1" + }, + "h5py-2.7.1-py36h9b8c120_0.conda": { + "build": "py36h9b8c120_0", + "build_number": 0, + "depends": [ + "hdf5", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "b90a62d1c8f28777785b990f8e7a1137", + "name": "h5py", + "sha256": "4bb79a4082f9d9d9bbfa10b18f5559925896fe6346b9c07dcabe23b7fa4b8755", + "size": 906452, + "subdir": "linux-64", + "timestamp": 1511314482429, + "version": "2.7.1" + }, + "h5py-2.7.1-py36ha1f6525_2.conda": { + "build": "py36ha1f6525_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "de103de58d1481c463cc6cb47438fc78", + "name": "h5py", + "sha256": "47839fe517791055163453f1e24def55236a035bd5ee19bca87ab8d17c9f41d3", + "size": 904955, + "subdir": "linux-64", + "timestamp": 1527221961350, + "version": "2.7.1" + }, + "h5py-2.8.0-py27h39dcb92_0.conda": { + "build": "py27h39dcb92_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "six", + "unittest2" + ], + "license": "BSD 3-Clause", + "md5": "3fa6f98a88fbfc3e2b0bb32d2cb85233", + "name": "h5py", + "sha256": "dcb1b99d6ebe7d81342feb04da3d15c2c5dbc48b90f4f71e744b07f869fd59e1", + "size": 902537, + "subdir": "linux-64", + "timestamp": 1530771427172, + "version": "2.8.0" + }, + "h5py-2.8.0-py27h39dcb92_2.conda": { + "build": "py27h39dcb92_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "unittest2" + ], + "license": "BSD 3-Clause", + "md5": "5f70291621a01db50ca05ecca50b8fb9", + "name": "h5py", + "sha256": "abf492cecd9637b0478615efa08f78df44287a2df2a216e01f9fcd27a5854b18", + "size": 902684, + "subdir": "linux-64", + "timestamp": 1534803789056, + "version": "2.8.0" + }, + "h5py-2.8.0-py27h61e79e4_3.conda": { + "build": "py27h61e79e4_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "unittest2" + ], + "license": "BSD 3-Clause", + "md5": "32e1a9f859f3e964105959ab0e771109", + "name": "h5py", + "sha256": "a9dbf54a3f9e1f98573d3ee4065ecd403771674a9c16e6875d124674b8b215f5", + "size": 902692, + "subdir": "linux-64", + "timestamp": 1534896246279, + "version": "2.8.0" + }, + "h5py-2.8.0-py27h8d01980_0.conda": { + "build": "py27h8d01980_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "six", + "unittest2" + ], + "license": "BSD 3-Clause", + "md5": "bcebdac7f7e97f9bb704ccc606ccc770", + "name": "h5py", + "sha256": "164c054566019ae10c73a894c3cadaee561e6a972c52d75075884b96d40539cd", + "size": 915740, + "subdir": "linux-64", + "timestamp": 1530771314025, + "version": "2.8.0" + }, + "h5py-2.8.0-py27h8d01980_2.conda": { + "build": "py27h8d01980_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "unittest2" + ], + "license": "BSD 3-Clause", + "md5": "f9b2368c3b6c4d3d442c6fd5c115caa8", + "name": "h5py", + "sha256": "7dff33834ddc07badb817a78dd29f53c2d89c194fa0e095180ee331cc69b324d", + "size": 916449, + "subdir": "linux-64", + "timestamp": 1534803656249, + "version": "2.8.0" + }, + "h5py-2.8.0-py27h989c5e5_3.conda": { + "build": "py27h989c5e5_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "unittest2" + ], + "license": "BSD 3-Clause", + "md5": "3ec8bc025006e6055c127198ffe734fe", + "name": "h5py", + "sha256": "3d34e48a7f4d58386a7cbdce4b2eaacb0ab44d56e3169467eddb1b20451a750b", + "size": 917783, + "subdir": "linux-64", + "timestamp": 1534896129694, + "version": "2.8.0" + }, + "h5py-2.8.0-py27ha1f6525_0.conda": { + "build": "py27ha1f6525_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "six", + "unittest2" + ], + "license": "BSD 3-Clause", + "md5": "29a0e01e55a173413d75c3e9c2019710", + "name": "h5py", + "sha256": "068aceae708bf9eca34df6b097d6be3f58b2513c0758ddb13b26c52a0e71a7d7", + "size": 914594, + "subdir": "linux-64", + "timestamp": 1527801378586, + "version": "2.8.0" + }, + "h5py-2.8.0-py27hca9c191_0.conda": { + "build": "py27hca9c191_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "six", + "unittest2" + ], + "license": "BSD 3-Clause", + "md5": "8c0f9c960d2e5040ad2081fd9e409ae2", + "name": "h5py", + "sha256": "3186fdd08dbeb5f632ad4bc116d7d4e1424da7b9138d8c1b49d02481d101a8c2", + "size": 901722, + "subdir": "linux-64", + "timestamp": 1527801175706, + "version": "2.8.0" + }, + "h5py-2.8.0-py35h39dcb92_2.conda": { + "build": "py35h39dcb92_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "dcf38d3db4320fd660f9a96ecd0e7eff", + "name": "h5py", + "sha256": "818507cb2c54fb7bc90fc82f6c9be2c26ca7f95ff1cf3215c5bc55610e954eeb", + "size": 908730, + "subdir": "linux-64", + "timestamp": 1534803139371, + "version": "2.8.0" + }, + "h5py-2.8.0-py35h61e79e4_3.conda": { + "build": "py35h61e79e4_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "a70c305bbf40914eaf0d1b7090ea6abb", + "name": "h5py", + "sha256": "c1a097221f54f9a4b8b3b9053aff876cbc0d8417839e82fd31d6a0adf17f69b1", + "size": 909216, + "subdir": "linux-64", + "timestamp": 1534896717081, + "version": "2.8.0" + }, + "h5py-2.8.0-py35h8d01980_2.conda": { + "build": "py35h8d01980_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "a8c1026022012a73b044e59890ce7ad9", + "name": "h5py", + "sha256": "36d05eeeda2b42fc0ce66fff003de882986b1d0c6d1350037de8c499f1a8728a", + "size": 923560, + "subdir": "linux-64", + "timestamp": 1534803001064, + "version": "2.8.0" + }, + "h5py-2.8.0-py35h989c5e5_3.conda": { + "build": "py35h989c5e5_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "f800ca226326632b24605b76e8c7df6e", + "name": "h5py", + "sha256": "18bb50d8e8057575d01d428b22bb6a86d37d54784bdfd501de5cda152f5f1ff9", + "size": 923540, + "subdir": "linux-64", + "timestamp": 1534896601393, + "version": "2.8.0" + }, + "h5py-2.8.0-py35ha1f6525_0.conda": { + "build": "py35ha1f6525_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "aa51ba96ff7f36589603a8fd28c2730e", + "name": "h5py", + "sha256": "903cc4ef1ecf95a87f6acde47d0aed1316d457f898d0875d779aec7a86d4843b", + "size": 921898, + "subdir": "linux-64", + "timestamp": 1527801407110, + "version": "2.8.0" + }, + "h5py-2.8.0-py35hca9c191_0.conda": { + "build": "py35hca9c191_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "0530a1120cba455e3347d72a910548c8", + "name": "h5py", + "sha256": "bf3f6d5ec71823375c26861fcf7497c49a991a6cf5490179930fb05f7bf427cd", + "size": 910107, + "subdir": "linux-64", + "timestamp": 1527801409845, + "version": "2.8.0" + }, + "h5py-2.8.0-py36h39dcb92_0.conda": { + "build": "py36h39dcb92_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "4aea8b730c6b686d9f193c158d16237f", + "name": "h5py", + "sha256": "4f2e0ae7a906d1d6effd6dc634b887b078ef6ce8c176d62f0efb3ae54bbc0703", + "size": 919255, + "subdir": "linux-64", + "timestamp": 1530771658436, + "version": "2.8.0" + }, + "h5py-2.8.0-py36h39dcb92_2.conda": { + "build": "py36h39dcb92_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "2d3c5f8df599eb95f94d0d935d701f60", + "name": "h5py", + "sha256": "cfcfb5492b9dc3206b4cb61454e736d3d4203e9e8d667e45066cf3f9a076227c", + "size": 918792, + "subdir": "linux-64", + "timestamp": 1534804324221, + "version": "2.8.0" + }, + "h5py-2.8.0-py36h61e79e4_3.conda": { + "build": "py36h61e79e4_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "38e6abd2e723b97f0410f52d4f9ba5e2", + "name": "h5py", + "sha256": "d43d9148e11aa03c7b761338e4f7cb47166cfd3013cc51fa968f6abeaeb0982b", + "size": 918827, + "subdir": "linux-64", + "timestamp": 1534896010158, + "version": "2.8.0" + }, + "h5py-2.8.0-py36h8d01980_0.conda": { + "build": "py36h8d01980_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "65ec699fc7e383ec633db15a2f468e50", + "name": "h5py", + "sha256": "211c4a909e0f992e5393abce61e07f79f729c56ef6f37feae607b89163e4a76a", + "size": 933547, + "subdir": "linux-64", + "timestamp": 1530771543951, + "version": "2.8.0" + }, + "h5py-2.8.0-py36h8d01980_2.conda": { + "build": "py36h8d01980_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "6a33d63df95b22a32425d8b6195713fc", + "name": "h5py", + "sha256": "1f8da4feae60a0f63d349e69e092052d77092b224632761d6d459e65466c717b", + "size": 932623, + "subdir": "linux-64", + "timestamp": 1534804192410, + "version": "2.8.0" + }, + "h5py-2.8.0-py36h989c5e5_3.conda": { + "build": "py36h989c5e5_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "d9cbb7df8b7ae3d09b6a1e34dfe78b80", + "name": "h5py", + "sha256": "4dca9c6c761da8be93c78faa0d5f72aa8b7da3ec886288a32aab1a9542554fc5", + "size": 932694, + "subdir": "linux-64", + "timestamp": 1534895888187, + "version": "2.8.0" + }, + "h5py-2.8.0-py36ha1f6525_0.conda": { + "build": "py36ha1f6525_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "225fece0bf87ee52b16165ee8484317b", + "name": "h5py", + "sha256": "9b74bee1382b5ce411347300be7a0d0ca9d14a7f82eacd0be56e2810e35bbe7e", + "size": 933289, + "subdir": "linux-64", + "timestamp": 1527801386533, + "version": "2.8.0" + }, + "h5py-2.8.0-py36hca9c191_0.conda": { + "build": "py36hca9c191_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "1345d23a0a7b21f6dfb444a33080dc89", + "name": "h5py", + "sha256": "6d6b799c81004d74c5f8dca31a0d936b54236b0b8cfe5dc02e847dfb3e5b1c3e", + "size": 919745, + "subdir": "linux-64", + "timestamp": 1527801144883, + "version": "2.8.0" + }, + "h5py-2.8.0-py37h39dcb92_0.conda": { + "build": "py37h39dcb92_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "1caed4db2c167fe6c587c3e8d514b5ef", + "name": "h5py", + "sha256": "30018c4766b1db4f58dcf92793f541e0e47e83f4be0871b651a1e32fce5768a3", + "size": 919745, + "subdir": "linux-64", + "timestamp": 1530771198834, + "version": "2.8.0" + }, + "h5py-2.8.0-py37h39dcb92_2.conda": { + "build": "py37h39dcb92_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "d4fc6d67eb6dda90920db04a84357c33", + "name": "h5py", + "sha256": "809b5f2162f8c0e27671a65ad80e80f6fa4e4849f139dfa3ea2971022af1e180", + "size": 917144, + "subdir": "linux-64", + "timestamp": 1534804056947, + "version": "2.8.0" + }, + "h5py-2.8.0-py37h61e79e4_3.conda": { + "build": "py37h61e79e4_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "5b21afb8995171b10ed5c6477f6f8010", + "name": "h5py", + "sha256": "e87fe2cbd7598bf834322fed52bd277db0a7342e69dde767c6ee968966ce8f9f", + "size": 917214, + "subdir": "linux-64", + "timestamp": 1534896483336, + "version": "2.8.0" + }, + "h5py-2.8.0-py37h8d01980_0.conda": { + "build": "py37h8d01980_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "9a17f4c098bf26302bf6f5dc048d5e29", + "name": "h5py", + "sha256": "778a4899b76c97aa2fb6442c47c3dd1c5c0dd7657f04fb9576a8c7b31726eab7", + "size": 929580, + "subdir": "linux-64", + "timestamp": 1530771081330, + "version": "2.8.0" + }, + "h5py-2.8.0-py37h8d01980_2.conda": { + "build": "py37h8d01980_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "217b658a355b446fd40e849fd650d74b", + "name": "h5py", + "sha256": "9e1f30e4d6fffd2c3be47dd7176390723c9aaaac2eb19e8929ccfb3a86a809a4", + "size": 932217, + "subdir": "linux-64", + "timestamp": 1534803924076, + "version": "2.8.0" + }, + "h5py-2.8.0-py37h989c5e5_3.conda": { + "build": "py37h989c5e5_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "3faf2c3eb7b91cfaa46c456f17fe889a", + "name": "h5py", + "sha256": "fde8332ea1aebf8808803f153e818e5a1f42dbfc3b7bb229695d90dbbf54af4c", + "size": 932193, + "subdir": "linux-64", + "timestamp": 1534896366448, + "version": "2.8.0" + }, + "h5py-2.9.0-py27h7918eee_0.conda": { + "build": "py27h7918eee_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "unittest2" + ], + "license": "BSD-3-Clause", + "md5": "0134ee79b68f97460432146bf58ea442", + "name": "h5py", + "sha256": "0d84b8f2d357cb3ca25acb5625dedfa75a26c2bc1fea2d87d1ca35e54c6bcdb4", + "size": 983824, + "subdir": "linux-64", + "timestamp": 1545411872838, + "version": "2.9.0" + }, + "h5py-2.9.0-py36h7918eee_0.conda": { + "build": "py36h7918eee_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "51ae76f2ecb5264538fb036d84751228", + "name": "h5py", + "sha256": "13f0fd852c74e7fd8522e07d377161bd8145e6a2c8828dfe2d4d9559c1df4b55", + "size": 1016395, + "subdir": "linux-64", + "timestamp": 1545411898065, + "version": "2.9.0" + }, + "h5py-2.9.0-py37h7918eee_0.conda": { + "build": "py37h7918eee_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "aa1a9cfa263430d5ad371f3b6c2d0757", + "name": "h5py", + "sha256": "6d134ccc1be3c4fb37539cc477c8fbe08b68a9388f514674ef9e5e688c4b6183", + "size": 1014380, + "subdir": "linux-64", + "timestamp": 1545411834002, + "version": "2.9.0" + }, + "h5py-2.9.0-py38h7918eee_0.conda": { + "build": "py38h7918eee_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "1bc6b703ab3c808d88412eb9f65509c1", + "name": "h5py", + "sha256": "dc5f4b25c07328066ae3bd73ed041cf463e1d55b9a83d78952f799c1fc69223d", + "size": 1071128, + "subdir": "linux-64", + "timestamp": 1573739904095, + "version": "2.9.0" + }, + "h5py-3.2.1-py37h6c542dc_0.conda": { + "build": "py37h6c542dc_0", + "build_number": 0, + "depends": [ + "cached-property", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "18f3a4b42551066e36582bc7ccbaafe5", + "name": "h5py", + "sha256": "c69c86843316df386b6d07ceb595b011ca519310028c153afe97a5f03e05fd86", + "size": 1073348, + "subdir": "linux-64", + "timestamp": 1622088619911, + "version": "3.2.1" + }, + "h5py-3.2.1-py38h6c542dc_0.conda": { + "build": "py38h6c542dc_0", + "build_number": 0, + "depends": [ + "cached-property", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "efd34d37b0309f5f11bd555501a28bbc", + "name": "h5py", + "sha256": "c7dfbc6ba7d39fd3d8c3f8323d023fd3ed7644f96973731196a0f51079537d71", + "size": 1123483, + "subdir": "linux-64", + "timestamp": 1622088642011, + "version": "3.2.1" + }, + "h5py-3.2.1-py39h6c542dc_0.conda": { + "build": "py39h6c542dc_0", + "build_number": 0, + "depends": [ + "cached-property", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "80567ea50e64d8f2798e3930f7ea8b5c", + "name": "h5py", + "sha256": "82fce5740bd7f4489d66a8042f28f5dada2c879efc3564de9080328b6b9478c8", + "size": 1125201, + "subdir": "linux-64", + "timestamp": 1622088279593, + "version": "3.2.1" + }, + "h5py-3.3.0-py37h930cdd6_0.conda": { + "build": "py37h930cdd6_0", + "build_number": 0, + "depends": [ + "cached-property", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a4f4e7fbcf9441522366b48b8ef203df", + "name": "h5py", + "sha256": "e9d02aa36a1dc18f64d43991c237afa9ffb5e1b92c51730a9498a6a1bbf4cf6d", + "size": 1078027, + "subdir": "linux-64", + "timestamp": 1636040444012, + "version": "3.3.0" + }, + "h5py-3.3.0-py38h930cdd6_0.conda": { + "build": "py38h930cdd6_0", + "build_number": 0, + "depends": [ + "cached-property", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a64c8bd373697034e14763b36f86e178", + "name": "h5py", + "sha256": "16cf9aab0323ac8f279fee65fc18c85cc04518fd64ecf4d86b16db871d44c0f0", + "size": 1134306, + "subdir": "linux-64", + "timestamp": 1636040714141, + "version": "3.3.0" + }, + "h5py-3.3.0-py39h930cdd6_0.conda": { + "build": "py39h930cdd6_0", + "build_number": 0, + "depends": [ + "cached-property", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a9e215ecec13d862d1bbc4d9bd04a870", + "name": "h5py", + "sha256": "47f12d352f17052517a5ae88c6ddfbd3a1901d199218e1bc2bea00d0c364dc77", + "size": 1133195, + "subdir": "linux-64", + "timestamp": 1636040709943, + "version": "3.3.0" + }, + "h5py-3.5.0-py37ha0f2276_0.conda": { + "build": "py37ha0f2276_0", + "build_number": 0, + "depends": [ + "cached-property", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "039b290c7aa15302ef5b11a7a3540f0f", + "name": "h5py", + "sha256": "eeb6ced01eda8f3b58904e0c8cece109d14571c906b0a15a0c09335f3815b953", + "size": 1080910, + "subdir": "linux-64", + "timestamp": 1636991252271, + "version": "3.5.0" + }, + "h5py-3.5.0-py37hd430a98_100.conda": { + "build": "py37hd430a98_100", + "build_number": 100, + "depends": [ + "cached-property", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3b1d4c1a99992534b281bda6550a5f86", + "name": "h5py", + "sha256": "970dba3bddacbe07819988f194e993cceb21426215603931c4fd20207f85feeb", + "size": 1080133, + "subdir": "linux-64", + "timestamp": 1636636868803, + "version": "3.5.0" + }, + "h5py-3.5.0-py38ha0f2276_0.conda": { + "build": "py38ha0f2276_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a3baac6c65b9e32fb1958d9ec55b6ca", + "name": "h5py", + "sha256": "576341d92b2f549b01c2cdbc674848e1292a2af8a9c7d20733f8d9cd9b47b93a", + "size": 1139207, + "subdir": "linux-64", + "timestamp": 1636978741829, + "version": "3.5.0" + }, + "h5py-3.5.0-py38hd430a98_100.conda": { + "build": "py38hd430a98_100", + "build_number": 100, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3b771a15ee698f8bce994d4deeff0efa", + "name": "h5py", + "sha256": "3e7ec88c33a4df52ecb4b494dd0e35c3aadfa02d311f91a935346b607ac7e8cb", + "size": 1135596, + "subdir": "linux-64", + "timestamp": 1636636858374, + "version": "3.5.0" + }, + "h5py-3.5.0-py39ha0f2276_0.conda": { + "build": "py39ha0f2276_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "80f770bf1f466778fbe64d17bcfa8630", + "name": "h5py", + "sha256": "54e8792ed70cfbae04f431b7878cfc7871f4d88767b03324b791df4f61411076", + "size": 1136908, + "subdir": "linux-64", + "timestamp": 1636991247778, + "version": "3.5.0" + }, + "h5py-3.5.0-py39hd430a98_100.conda": { + "build": "py39hd430a98_100", + "build_number": 100, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "469c3a22a8929c02a763778409c6a7b4", + "name": "h5py", + "sha256": "9185032cdf51d2c663724933d13c11ff6722eba8f3e888f4b9ce5c0b48402144", + "size": 1137021, + "subdir": "linux-64", + "timestamp": 1636624527741, + "version": "3.5.0" + }, + "h5py-3.6.0-py310h18f346e_0.conda": { + "build": "py310h18f346e_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "75f0c0bec7cd07efa0e34ca6d4644c46", + "name": "h5py", + "sha256": "2bfe23daa7f23bd6f7ffbff037b284c3c0098345a2468a114ef84f3862e71a39", + "size": 3854536, + "subdir": "linux-64", + "timestamp": 1640887474099, + "version": "3.6.0" + }, + "h5py-3.6.0-py37ha0f2276_0.conda": { + "build": "py37ha0f2276_0", + "build_number": 0, + "depends": [ + "cached-property", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "177e74c47548c9070e7c0a565becd84c", + "name": "h5py", + "sha256": "c8fa2d6d32bc9ef7293f698b6a71547488fd35e6956ee31b51bf15388a794899", + "size": 1083184, + "subdir": "linux-64", + "timestamp": 1637139039745, + "version": "3.6.0" + }, + "h5py-3.6.0-py38ha0f2276_0.conda": { + "build": "py38ha0f2276_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "40a334ef018154199984923c74674835", + "name": "h5py", + "sha256": "2b224c116d5aee23204b594021d418415befff7dc485c1d3119980e5d6663f1d", + "size": 1135694, + "subdir": "linux-64", + "timestamp": 1637139021142, + "version": "3.6.0" + }, + "h5py-3.6.0-py39ha0f2276_0.conda": { + "build": "py39ha0f2276_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "292417414b47a364e15f38b30fee775c", + "name": "h5py", + "sha256": "2bdd75d79dff1221d0107b2769aaf06170e87b5ca91be62d5e775ff3f8f83da7", + "size": 1136808, + "subdir": "linux-64", + "timestamp": 1637138630244, + "version": "3.6.0" + }, + "h5py-3.7.0-py310he06866b_0.conda": { + "build": "py310he06866b_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b5b232701af6b272f773700d670ffe2c", + "name": "h5py", + "sha256": "9a5aecaaf1b824adbf3bd04459896213a89a9e17d8c61e4183e47f5002bd17fa", + "size": 4249009, + "subdir": "linux-64", + "timestamp": 1659092007638, + "version": "3.7.0" + }, + "h5py-3.7.0-py311h021c08c_0.conda": { + "build": "py311h021c08c_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ed4dfd1c95dc655e830d284ae9d64cac", + "name": "h5py", + "sha256": "5d2bab8556b23a5c33ca1d4436a04bd91bad365fad07f291946058e019fe4123", + "size": 1178385, + "subdir": "linux-64", + "timestamp": 1676904091959, + "version": "3.7.0" + }, + "h5py-3.7.0-py37h737f45e_0.conda": { + "build": "py37h737f45e_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38526a0655e76d7449fd95920d448ffc", + "name": "h5py", + "sha256": "bae748f753856ced3106f30ce7ab58169e6e456ca9f64d939450a46d2b2add12", + "size": 1102685, + "subdir": "linux-64", + "timestamp": 1659091536323, + "version": "3.7.0" + }, + "h5py-3.7.0-py38h737f45e_0.conda": { + "build": "py38h737f45e_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a836f1509fc0c8694f3b94fdab2953fa", + "name": "h5py", + "sha256": "0db9a6e00ece0acd8c8d4f166602b63de2d824685538545d608875b3b2d3f873", + "size": 1144793, + "subdir": "linux-64", + "timestamp": 1659091830828, + "version": "3.7.0" + }, + "h5py-3.7.0-py39h737f45e_0.conda": { + "build": "py39h737f45e_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "48ef2a4a0b0d6a72fefac7052929dcfc", + "name": "h5py", + "sha256": "730d822f799603bf8c7b1f7fe03c0a4116b1aaa5fbb0b70339dca98f9de11a9f", + "size": 1126848, + "subdir": "linux-64", + "timestamp": 1659091680893, + "version": "3.7.0" + }, + "harfbuzz-1.5.0-h2545bd6_0.conda": { + "build": "h2545bd6_0", + "build_number": 0, + "depends": [ + "cairo 1.14.*", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "graphite2 1.3.*", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxcb" + ], + "license": "MIT", + "md5": "284d96b4334f99ab34c599c4742c11a4", + "name": "harfbuzz", + "sha256": "880bc2d9c9a1f408d31b51aad0c56b2688837f544d404b62a487db7450b3fd9f", + "size": 437820, + "subdir": "linux-64", + "timestamp": 1505744340721, + "version": "1.5.0" + }, + "harfbuzz-1.7.4-hc5b324e_0.conda": { + "build": "hc5b324e_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.10,<2.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "graphite2 >=1.3.10,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.12,<2.0a0" + ], + "license": "MIT", + "md5": "c7bfaffdf069721e29b58a79f4f32d4d", + "name": "harfbuzz", + "sha256": "07c725e6743f93eeb0e8931935ecd109a1b20b5dfccb3b0b0f4ebb543676cc72", + "size": 450048, + "subdir": "linux-64", + "timestamp": 1516743038041, + "version": "1.7.4" + }, + "harfbuzz-1.7.6-h5f0a787_1.conda": { + "build": "h5f0a787_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.10,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.13,<2.0a0" + ], + "license": "MIT", + "md5": "c38572869dec264719ab06498ef5ce8d", + "name": "harfbuzz", + "sha256": "0139eb02f4f4524090f19742b7e82b77235ab89869f1ed2f9b450a6015093754", + "size": 485574, + "subdir": "linux-64", + "timestamp": 1523672404228, + "version": "1.7.6" + }, + "harfbuzz-1.7.6-hc5b324e_0.conda": { + "build": "hc5b324e_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "graphite2 >=1.3.10,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.12,<2.0a0" + ], + "license": "MIT", + "md5": "1cc26973c95a49458df36f0b9447b406", + "name": "harfbuzz", + "sha256": "906d4d4f6239e833bada3582abd3edba825bdbef2cc52452c2bda0a200b14ece", + "size": 524424, + "subdir": "linux-64", + "timestamp": 1522349021236, + "version": "1.7.6" + }, + "harfbuzz-1.7.6-hec2c2bc_3.conda": { + "build": "hec2c2bc_3", + "build_number": 3, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.11,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.13,<2.0a0" + ], + "license": "MIT", + "md5": "b8627a2ef3db6f5fc27a6db061b1b7e8", + "name": "harfbuzz", + "sha256": "57c1245e2b43d2f6fd931289c3d7abafbd793cb1ea98260f11afdaacee2ce8da", + "size": 486879, + "subdir": "linux-64", + "timestamp": 1527258939186, + "version": "1.7.6" + }, + "harfbuzz-1.8.4-hec2c2bc_0.conda": { + "build": "hec2c2bc_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.11,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.13,<2.0a0" + ], + "license": "MIT", + "md5": "85d377e21cdd932592e1cfc27572601a", + "name": "harfbuzz", + "sha256": "c6fd8fa98faee7d18fac0e9d13ec6194cd3e647597a15aa53a410d73cbf53e69", + "size": 491959, + "subdir": "linux-64", + "timestamp": 1532580168746, + "version": "1.8.4" + }, + "harfbuzz-1.8.8-hffaf4a1_0.conda": { + "build": "hffaf4a1_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.11,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxcb >=1.13,<2.0a0" + ], + "license": "MIT", + "md5": "ed3697c63497f052a0c7b66f9155ed60", + "name": "harfbuzz", + "sha256": "3c66913e15734fbd403e7370a517282dce4064b42add7a85c9fc72f0b837494b", + "size": 519136, + "subdir": "linux-64", + "timestamp": 1535414042498, + "version": "1.8.8" + }, + "harfbuzz-2.4.0-hca77d97_0.conda": { + "build": "hca77d97_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.63.1,<3.0a0", + "graphite2 >=1.3.13,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxcb >=1.13,<2.0a0" + ], + "license": "MIT", + "md5": "550b9fd2038eeed0ca690128f847dd61", + "name": "harfbuzz", + "sha256": "f496b459ebda817fe9179405ee729c34cea8510ff48299213bfc5aaa088356fe", + "size": 809989, + "subdir": "linux-64", + "timestamp": 1593115783327, + "version": "2.4.0" + }, + "harfbuzz-2.4.0-hca77d97_1.conda": { + "build": "hca77d97_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.65.0,<3.0a0", + "graphite2 >=1.3.14,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxcb >=1.13,<2.0a0" + ], + "license": "MIT", + "md5": "b278ddd607b6f9d304a4ffaf930cf644", + "name": "harfbuzz", + "sha256": "87384f23ef2a88d81694adc348705521e4f2d3b283512a00b94f78cc842487c4", + "size": 870525, + "subdir": "linux-64", + "timestamp": 1593435707459, + "version": "2.4.0" + }, + "harfbuzz-2.7.4-h6f93f22_0.conda": { + "build": "h6f93f22_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.67.4,<3.0a0", + "graphite2 >=1.3.14,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "05ce4f379a5ff16d8398e8490bea9514", + "name": "harfbuzz", + "sha256": "aa2a23f6aec570bbf6127624c44472456e43902a923375321e984706f65573a1", + "size": 1081217, + "subdir": "linux-64", + "timestamp": 1615344138620, + "version": "2.7.4" + }, + "harfbuzz-2.8.0-h6f93f22_0.conda": { + "build": "h6f93f22_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.67.4,<3.0a0", + "graphite2 >=1.3.14,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "84b4e91183fe2c8267da589c45617633", + "name": "harfbuzz", + "sha256": "6ecc2512e6e5c2d363a15dd837da223189fbdc43ac0de7603adf138d5e5696c3", + "size": 1098502, + "subdir": "linux-64", + "timestamp": 1615920026036, + "version": "2.8.0" + }, + "harfbuzz-2.8.1-h6f93f22_0.conda": { + "build": "h6f93f22_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.68.2,<3.0a0", + "graphite2 >=1.3.14,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d49d93676464378b20060c8251841ea9", + "name": "harfbuzz", + "sha256": "0322260178f7a4f8847a6cdb06029dde0fb1ad46d111a76ee3a92b3d9e104ba9", + "size": 1121451, + "subdir": "linux-64", + "timestamp": 1622035133941, + "version": "2.8.1" + }, + "harfbuzz-3.1.2-h6b1f951_0.conda": { + "build": "h6b1f951_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "graphite2 >=1.3.14,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85ceb2de919337fdd398d0fec54156da", + "name": "harfbuzz", + "sha256": "4ef8c8b83442ff1deb5f8b6b75f933db885a64e47162f1295aa430f1ee3fb58c", + "size": 1214021, + "subdir": "linux-64", + "timestamp": 1638357221518, + "version": "3.1.2" + }, + "harfbuzz-4.3.0-hd55b92a_0.conda": { + "build": "hd55b92a_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "graphite2 >=1.3.14,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e52b5858fa7dec3ee8791785e1ffeb44", + "name": "harfbuzz", + "sha256": "98c69ac1b95afdfb01a5c2befe39991be358b81ceb31692eac2ca2d3f6bef3e3", + "size": 1186475, + "subdir": "linux-64", + "timestamp": 1656510744872, + "version": "4.3.0" + }, + "harfbuzz-4.3.0-hf52aaf7_1.conda": { + "build": "hf52aaf7_1", + "build_number": 1, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "graphite2 >=1.3.14,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "38604403945aaebb6007460c88b4e102", + "name": "harfbuzz", + "sha256": "774e1d1e9b34eced81e390a0ae2a0e1f27fda2b17f600ae45b97428582bbccb8", + "size": 1394907, + "subdir": "linux-64", + "timestamp": 1678800467402, + "version": "4.3.0" + }, + "hatch-nodejs-version-0.3.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ae57ce3533275068285d4d9fcad2c0fe", + "name": "hatch-nodejs-version", + "sha256": "c18bdc77289e470284cfe1e2e8e195303d1bab6b44b0e985b1da43ad759d1b67", + "size": 18734, + "subdir": "linux-64", + "timestamp": 1670275341857, + "version": "0.3.1" + }, + "hatch-nodejs-version-0.3.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9eaa4b590944091cc08073d3594f3967", + "name": "hatch-nodejs-version", + "sha256": "604a8736e2528a674809f284eade2f7d5b2635bd4917f3565bc12a29b9aea804", + "size": 20671, + "subdir": "linux-64", + "timestamp": 1676823346085, + "version": "0.3.1" + }, + "hatch-nodejs-version-0.3.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ce969321dd22313fef4ae2d9f66aaa9", + "name": "hatch-nodejs-version", + "sha256": "e218ef13dcd4b8d7dba9381fadbbea3e0902f17433f0da4835a7fc77fe6d9edc", + "size": 18581, + "subdir": "linux-64", + "timestamp": 1670275312382, + "version": "0.3.1" + }, + "hatch-nodejs-version-0.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f52ba56e60b38dbf0948cffdad98ded", + "name": "hatch-nodejs-version", + "sha256": "6887cc65e6ca5b99b1191830a00bbf4dcfb3c73da1b367f0b1394601391f2125", + "size": 18582, + "subdir": "linux-64", + "timestamp": 1670275399819, + "version": "0.3.1" + }, + "hatch-nodejs-version-0.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "25d54f5429daf482c77a3f2a1668dffb", + "name": "hatch-nodejs-version", + "sha256": "ce6775e5e19108ac78cfd9cb815a666c340bb30e5455d772c74b6e4f0b390509", + "size": 18600, + "subdir": "linux-64", + "timestamp": 1670275370764, + "version": "0.3.1" + }, + "hatch-requirements-txt-0.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "packaging >=21.3", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9bd89bc78155b834457cba35621635ac", + "name": "hatch-requirements-txt", + "sha256": "51b10b86e155ad39504418b9569ccf1226cb0df172a05fc7f88e2e9c72004e40", + "size": 12258, + "subdir": "linux-64", + "timestamp": 1676362030300, + "version": "0.3.0" + }, + "hatch-requirements-txt-0.3.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "packaging >=21.3", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e67e8f419a352661a225ddf1ada34168", + "name": "hatch-requirements-txt", + "sha256": "ce96a82d8b34bc1fb5cef26b321ce53349001f8faf426de58a4be5df908b63fe", + "size": 13523, + "subdir": "linux-64", + "timestamp": 1676844234743, + "version": "0.3.0" + }, + "hatch-requirements-txt-0.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "packaging >=21.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62d5fecee1da8ed8b8347ae594041457", + "name": "hatch-requirements-txt", + "sha256": "4b5a193d66834749e287fa90422b2497a50f8163e1e831c134a057e4beb00b96", + "size": 12275, + "subdir": "linux-64", + "timestamp": 1676362057912, + "version": "0.3.0" + }, + "hatch-requirements-txt-0.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "packaging >=21.3", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1bfb46f7885f72b7a177cc976d32e0ea", + "name": "hatch-requirements-txt", + "sha256": "a2b932d5c084f523747d9e1a6c6f55be75f0f524a8992105f9e15e4082e50d7b", + "size": 12202, + "subdir": "linux-64", + "timestamp": 1676362003448, + "version": "0.3.0" + }, + "hatch-requirements-txt-0.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "packaging >=21.3", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0a60cf835a178e29328a13a7c5732b1", + "name": "hatch-requirements-txt", + "sha256": "d3c6850241300737f1ac1c25865e5f167fa8ab4536381699a69c2b9f786f9858", + "size": 12212, + "subdir": "linux-64", + "timestamp": 1676362084544, + "version": "0.3.0" + }, + "hatch-vcs-0.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.10,<3.11.0a0", + "setuptools-scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cfce4f862c7ecea49cafb73106b2e166", + "name": "hatch-vcs", + "sha256": "fdef0d4625c30cf91acd1ca2899db07548d9f59f646bdacd9db22e7518048a7d", + "size": 11308, + "subdir": "linux-64", + "timestamp": 1661381063870, + "version": "0.2.0" + }, + "hatch-vcs-0.2.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.11,<3.12.0a0", + "setuptools-scm" + ], + "license": "MIT", + "md5": "73739189eace08ca8ebbfded403547ab", + "name": "hatch-vcs", + "sha256": "117b11d2ab903c29dc4287e72fa8d35cde04b26517312f3d7d6240224ba22a56", + "size": 12584, + "subdir": "linux-64", + "timestamp": 1676822977375, + "version": "0.2.0" + }, + "hatch-vcs-0.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.7,<3.8.0a0", + "setuptools-scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66a8b843337081ecb6ea03cc900ad9dc", + "name": "hatch-vcs", + "sha256": "33e4283ebf028da324e288198c6789a70c3d9b2ed639663a3a04ac90cc64506c", + "size": 11315, + "subdir": "linux-64", + "timestamp": 1661381124999, + "version": "0.2.0" + }, + "hatch-vcs-0.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.8,<3.9.0a0", + "setuptools-scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1aaa28a5ea770415a8c0ac810e1fab1", + "name": "hatch-vcs", + "sha256": "6000352e26fc44c7c4fc7930f6433bb02b300862f05a6e75bc843442ae388ce0", + "size": 11273, + "subdir": "linux-64", + "timestamp": 1661381019253, + "version": "0.2.0" + }, + "hatch-vcs-0.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "hatchling >=0.21.0", + "python >=3.9,<3.10.0a0", + "setuptools-scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8fe893d88e9948bba6dd2869a06fef97", + "name": "hatch-vcs", + "sha256": "80aeb7614adb93e987e95f784671afb0ebf9787dd025dce640877065263c7ba6", + "size": 11248, + "subdir": "linux-64", + "timestamp": 1661381095239, + "version": "0.2.0" + }, + "hatchling-1.12.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "packaging >=21.3", + "pathspec >=0.10.1", + "pluggy >=1.0.0", + "python >=3.10,<3.11.0a0", + "tomli >=1.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad8d7be0f88c3c69ffa7fc46c1154476", + "name": "hatchling", + "sha256": "f8a2e5377893d6f9a67047452c8facf29ef87573ab5dbec39353c6476adc1275", + "size": 136413, + "subdir": "linux-64", + "timestamp": 1674690467906, + "version": "1.12.2" + }, + "hatchling-1.12.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "packaging >=21.3", + "pathspec >=0.10.1", + "pluggy >=1.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b836e245ff284ab89a48d57262a67d5e", + "name": "hatchling", + "sha256": "e1b45d8d9ed8a202938450460541229cf392a5d49dda772938bdc197008af21e", + "size": 165486, + "subdir": "linux-64", + "timestamp": 1679516954850, + "version": "1.12.2" + }, + "hatchling-1.12.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "importlib-metadata", + "packaging >=21.3", + "pathspec >=0.10.1", + "pluggy >=1.0.0", + "python >=3.7,<3.8.0a0", + "tomli >=1.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "411f988d95b51db07509a6a5dc63b42e", + "name": "hatchling", + "sha256": "6fa5e7cb3c41d5ab24e55e8d48687200326a795edff12379136c88207401f60e", + "size": 132839, + "subdir": "linux-64", + "timestamp": 1674690496283, + "version": "1.12.2" + }, + "hatchling-1.12.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "packaging >=21.3", + "pathspec >=0.10.1", + "pluggy >=1.0.0", + "python >=3.8,<3.9.0a0", + "tomli >=1.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "880f41700a57f1b63f244b6e4f928810", + "name": "hatchling", + "sha256": "cc78b4526aff56a31a03883ef04ef2153d10812334f702480a28fc58b3af4ae5", + "size": 132149, + "subdir": "linux-64", + "timestamp": 1674690523415, + "version": "1.12.2" + }, + "hatchling-1.12.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "packaging >=21.3", + "pathspec >=0.10.1", + "pluggy >=1.0.0", + "python >=3.9,<3.10.0a0", + "tomli >=1.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8258f2c9b27c7573f900828a4ad6aaca", + "name": "hatchling", + "sha256": "fa2a5de6595f8e55509587b9281e5a695270c84605c18b91fde24fbadcefaca7", + "size": 130825, + "subdir": "linux-64", + "timestamp": 1674690440549, + "version": "1.12.2" + }, + "hatchling-1.8.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "packaging >=21.3", + "pathspec >=0.9", + "pluggy >=1.0.0", + "python >=3.10,<3.11.0a0", + "tomli >=1.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "35f1b2024ed2c2d5c915995abfb39506", + "name": "hatchling", + "sha256": "e05b5214865a6b707fcb428db50af394df41b1715ba6ac666d32911d3ca95216", + "size": 114449, + "subdir": "linux-64", + "timestamp": 1661204335007, + "version": "1.8.0" + }, + "hatchling-1.8.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "packaging >=21.3", + "pathspec >=0.9", + "pluggy >=1.0.0", + "python >=3.11,<3.12.0a0", + "tomli >=1.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51ecb6e9fd4e38e695faeeea60d1b44f", + "name": "hatchling", + "sha256": "7909228843edd43c9989a316df90f2048d8922f086b72bd1a5c07852aefe4007", + "size": 151616, + "subdir": "linux-64", + "timestamp": 1676822861141, + "version": "1.8.0" + }, + "hatchling-1.8.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "importlib-metadata", + "packaging >=21.3", + "pathspec >=0.9", + "pluggy >=1.0.0", + "python >=3.7,<3.8.0a0", + "tomli >=1.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9fae1dd34648cc8d41090f8af907bc9", + "name": "hatchling", + "sha256": "e36b0d5554c96e64e92ebf9be115803c1d4cd220baf06389e69319d432df8550", + "size": 112309, + "subdir": "linux-64", + "timestamp": 1661204288811, + "version": "1.8.0" + }, + "hatchling-1.8.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "packaging >=21.3", + "pathspec >=0.9", + "pluggy >=1.0.0", + "python >=3.8,<3.9.0a0", + "tomli >=1.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "089e0c0e87bb172e387d743463fa31dc", + "name": "hatchling", + "sha256": "eeea395be5c76af1ee5610f0ce5a3033bf30b22071904aed9193c18df3ce85c6", + "size": 112382, + "subdir": "linux-64", + "timestamp": 1661204363698, + "version": "1.8.0" + }, + "hatchling-1.8.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "editables >=0.3", + "packaging >=21.3", + "pathspec >=0.9", + "pluggy >=1.0.0", + "python >=3.9,<3.10.0a0", + "tomli >=1.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63e9d29cb16334aa0b2185d7c9df4891", + "name": "hatchling", + "sha256": "87748f06c0324927dd807c4f6a6325690275d4adab03d789d3c7020267b4e63e", + "size": 111046, + "subdir": "linux-64", + "timestamp": 1661204258862, + "version": "1.8.0" + }, + "hdf4-4.2.13-h1976432_1.conda": { + "build": "h1976432_1", + "build_number": 1, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a958ce04e4b6274a1a22651f043e33f1", + "name": "hdf4", + "sha256": "141e3217593e87e6bf52f9984825e6c7f7a0ec3f3b9e7e07679e4b5502c08a71", + "size": 725859, + "subdir": "linux-64", + "timestamp": 1509502810225, + "version": "4.2.13" + }, + "hdf4-4.2.13-h3ca952b_2.conda": { + "build": "h3ca952b_2", + "build_number": 2, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "99f7b578c71893c6ffbe359499374048", + "name": "hdf4", + "sha256": "735945fbe5e5f7c2c0558b7621f58224a9ead5016bfdc4c66696adba2f72609d", + "size": 731182, + "subdir": "linux-64", + "timestamp": 1510862959026, + "version": "4.2.13" + }, + "hdf5-1.10.1-h9caa474_1.conda": { + "build": "h9caa474_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "7675679a249fd49a0c82346448e4bd01", + "name": "hdf5", + "sha256": "1dc9d349709b2aead92508c92245f71a1d9af1907140e2db707a28f97cd4f744", + "size": 4013816, + "subdir": "linux-64", + "timestamp": 1510864218176, + "version": "1.10.1" + }, + "hdf5-1.10.1-hb0523eb_0.conda": { + "build": "hb0523eb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "285362c5eca756f45bd1112e8633bd05", + "name": "hdf5", + "sha256": "01ce165c6581bc7b212e5b337bd9ec19e569315f04a76dde259520012ed230e7", + "size": 4073506, + "subdir": "linux-64", + "timestamp": 1505730098014, + "version": "1.10.1" + }, + "hdf5-1.10.2-hba1933b_1.conda": { + "build": "hba1933b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "43997abb971654fa0669ae8bbf7e29a3", + "name": "hdf5", + "sha256": "5a6a2465ebe4c933e1241689eb71feb791d643eed4b3be1ff9c615ec69d38171", + "size": 4000001, + "subdir": "linux-64", + "timestamp": 1525909482253, + "version": "1.10.2" + }, + "hdf5-1.10.4-hb1b8bf9_0.conda": { + "build": "hb1b8bf9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "30e7271e95b885756963da25773a9e2f", + "name": "hdf5", + "sha256": "7219ee632cee9b5ef314541b7f482161ba4f0ff7c17bc407523e2f54658e1742", + "size": 4095117, + "subdir": "linux-64", + "timestamp": 1545245222343, + "version": "1.10.4" + }, + "hdf5-1.10.6-h3ffc7dd_1.conda": { + "build": "h3ffc7dd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "be0c7398eb62d3748efe85fc26c4024f", + "name": "hdf5", + "sha256": "def0ec3704a38c4fbf231fd1ec935532bf0872d73d07de0355be6a8b6a51739c", + "size": 3813361, + "subdir": "linux-64", + "timestamp": 1655307962864, + "version": "1.10.6" + }, + "hdf5-1.10.6-hb1b8bf9_0.conda": { + "build": "hb1b8bf9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "a496f7ed2cbb6fb069b005f4df3c0cff", + "name": "hdf5", + "sha256": "a73f24776a4771092b909d1501fbcabf243a1c240ffeb6718e66a677e3d8cf5e", + "size": 3839844, + "subdir": "linux-64", + "timestamp": 1593121597858, + "version": "1.10.6" + }, + "hdf5-1.10.7-hb1b8bf9_0.conda": { + "build": "hb1b8bf9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "6456dd4919d239fd28bbe34c0d8ed353", + "name": "hdf5", + "sha256": "7f29dc6e614930ea1d8a840583c515535b0da6bb4175f6172509ec6e8eaf7978", + "size": 3933325, + "subdir": "linux-64", + "timestamp": 1600361203389, + "version": "1.10.7" + }, + "hdf5-1.12.0-hc3cf35f_0.conda": { + "build": "hc3cf35f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "c6a7ece1edb8b5a6cdc1fba5dc87d8cc", + "name": "hdf5", + "sha256": "968c3fd3c7d9f6f0a1b686e1723c366e47e42657d52f54fc5c105e3ba4d299eb", + "size": 4169917, + "subdir": "linux-64", + "timestamp": 1611516031048, + "version": "1.12.0" + }, + "hdf5-1.12.1-h69dfa17_1.conda": { + "build": "h69dfa17_1", + "build_number": 1, + "depends": [ + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "c77c8a167d3d1236bfc9e62f287750ed", + "name": "hdf5", + "sha256": "efcbfffad9d28c2fd369f764e42d500b7a90d4820ee60234584527cbea5fc1ed", + "size": 4327315, + "subdir": "linux-64", + "timestamp": 1636040445739, + "version": "1.12.1" + }, + "hdf5-1.12.1-h70be1eb_2.conda": { + "build": "h70be1eb_2", + "build_number": 2, + "depends": [ + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1o,<1.1.2a", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "691def1681fbcd60d39966d00b8cbeb6", + "name": "hdf5", + "sha256": "b91fd46b7135d4cbab3b68aad033cbad76a50a2a72d102ea0ea8e1511dfd7ec9", + "size": 4350895, + "subdir": "linux-64", + "timestamp": 1655307949265, + "version": "1.12.1" + }, + "hdf5-1.8.18-h525d4c3_0.conda": { + "build": "h525d4c3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "zlib 1.2.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "7b443f371b6782925578d9900f65ae9c", + "name": "hdf5", + "sha256": "fdb61d012e707d068bcb0da67a438204b447d3844e523dce4f5c01ec1d6f12c1", + "size": 3183291, + "subdir": "linux-64", + "timestamp": 1505729146643, + "version": "1.8.18" + }, + "hdf5-1.8.18-h6792536_1.conda": { + "build": "h6792536_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "14750099b19d3973afd8c8a5ebc48975", + "name": "hdf5", + "sha256": "ac2df05a7eb0aedf8d7bb10aaf48e2d540c26a602cb34378ddb36aff2aa94ba7", + "size": 3184269, + "subdir": "linux-64", + "timestamp": 1510863817753, + "version": "1.8.18" + }, + "hdf5-1.8.20-hba1933b_1.conda": { + "build": "hba1933b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HDF5", + "license_family": "BSD", + "md5": "a9e1bd992a79b9898a1601e18051574f", + "name": "hdf5", + "sha256": "17d84c4ffca11f645a822ddb401476b5890f67deee36529ed6f7f2f2f948228d", + "size": 3169336, + "subdir": "linux-64", + "timestamp": 1530868368461, + "version": "1.8.20" + }, + "hdfeos2-2.19.1-h25c61e6_9.conda": { + "build": "h25c61e6_9", + "build_number": 9, + "depends": [ + "hdf4 >=4.2.13,<4.2.14.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public Domain", + "md5": "43a746c13bc32325de1554f48b69a90a", + "name": "hdfeos2", + "sha256": "abc4770e8b37b2ecd47d8fcbf5b413620c7bae013edca572963e1aef1f2c8b69", + "size": 228344, + "subdir": "linux-64", + "timestamp": 1512104007886, + "version": "2.19.1" + }, + "hdfeos2-2.20-h64bfcee_0.conda": { + "build": "h64bfcee_0", + "build_number": 0, + "depends": [ + "hdf4 >=4.2.13,<4.2.14.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public Domain", + "md5": "585f53c7e467cacd45a2144db3e6d5a0", + "name": "hdfeos2", + "sha256": "e5b32138d2cb84b06b582e8e25c1bb17e9de842cb207afd4e860c17cd32f4b50", + "size": 231073, + "subdir": "linux-64", + "timestamp": 1531092706071, + "version": "2.20" + }, + "hdfs3-0.1.4-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "libhdfs3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0afbf3ad8b20298c74659c62dcfcb3f6", + "name": "hdfs3", + "sha256": "558c44077834df855e03191b42890acf35a8c3cb846a1169f7e3b785f4054b11", + "size": 31269, + "subdir": "linux-64", + "timestamp": 1515697222212, + "version": "0.1.4" + }, + "hdfs3-0.1.4-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "libhdfs3", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "09d2de917d2bd44a272e9e6fbdf21e38", + "name": "hdfs3", + "sha256": "d7084c8f8b98b62095b87627a7c2da62bd780762bc14842ea772fad0e059eff8", + "size": 31810, + "subdir": "linux-64", + "timestamp": 1515697246799, + "version": "0.1.4" + }, + "hdfs3-0.1.4-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "libhdfs3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ba99982caa9b03fdc080ee90ae688d89", + "name": "hdfs3", + "sha256": "4c8dc9b8a8b5f1225ab34a4c02009eb1afddd575a9c55e75227ef46e18638dde", + "size": 31561, + "subdir": "linux-64", + "timestamp": 1515697215173, + "version": "0.1.4" + }, + "hdfs3-0.3.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "libhdfs3 >=2.3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "297d461ed1ccd52cde3f1b9d337af1a2", + "name": "hdfs3", + "sha256": "d1f178458a2e5d25ee556d1dc4bcfa8193759f70e41a1d190bdd32904cb40ca7", + "size": 39743, + "subdir": "linux-64", + "timestamp": 1515710225106, + "version": "0.3.0" + }, + "hdfs3-0.3.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0216472d1b6798a3ee2f749cad610943", + "name": "hdfs3", + "sha256": "e40269638a7c93cadee00a479487aba434e03d8c9c094a329bf5f71918d3f5bb", + "size": 40219, + "subdir": "linux-64", + "timestamp": 1515710239218, + "version": "0.3.0" + }, + "hdfs3-0.3.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "34a68f0c160f97da226546b076189b58", + "name": "hdfs3", + "sha256": "f3bb36ea3cf9465d7774f18247910a8ad9a6019bb05df2e51d849147b9d61c55", + "size": 40190, + "subdir": "linux-64", + "timestamp": 1515710207534, + "version": "0.3.0" + }, + "hdfs3-0.3.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f973c7d957e632e21f64a42423531e8a", + "name": "hdfs3", + "sha256": "fc8f6432002ca2f78b95e99e6ebafce77feb90981852afd2e0c58896b690186a", + "size": 39793, + "subdir": "linux-64", + "timestamp": 1530892808972, + "version": "0.3.0" + }, + "hdfs3-0.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "libhdfs3 >=2.3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4f0693de160c80de56ff5b5ca262d1b7", + "name": "hdfs3", + "sha256": "71d79926f7e335f23bd2c02040296947bcaba729d8673d9a3062f577cf665e57", + "size": 42959, + "subdir": "linux-64", + "timestamp": 1569343261553, + "version": "0.3.1" + }, + "hdfs3-0.3.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8ee7ac4ae7b5c70e3aa7b4bc3e1d306f", + "name": "hdfs3", + "sha256": "9cc37baeba6053413e0f2f876fcbd0bb2c89e14d1d997da62f6d24560ec3340a", + "size": 41349, + "subdir": "linux-64", + "timestamp": 1640790832421, + "version": "0.3.1" + }, + "hdfs3-0.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bf672c58f3450a6dbad6d3c50bf2aaba", + "name": "hdfs3", + "sha256": "ae253a69d365679e814df8871f26e8670221de92744f29116ad9977e956c0044", + "size": 43224, + "subdir": "linux-64", + "timestamp": 1569343298181, + "version": "0.3.1" + }, + "hdfs3-0.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e57f2638d07db3b0ca999390360d100b", + "name": "hdfs3", + "sha256": "f74c080c104e4e955b019219517aadfa4d9d028a410282b3ae6e1822b3f7bbe2", + "size": 43261, + "subdir": "linux-64", + "timestamp": 1569343263785, + "version": "0.3.1" + }, + "hdfs3-0.3.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d12b9975d7b78f7695ec154a9de28a31", + "name": "hdfs3", + "sha256": "ac4794e86defce459205613466780abdc33e42fee00b59026fc4c468c2d64ff5", + "size": 41078, + "subdir": "linux-64", + "timestamp": 1641828211910, + "version": "0.3.1" + }, + "hdfs3-0.3.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1da58f4dbad4e5b8b483c8ac80e014c4", + "name": "hdfs3", + "sha256": "80e612de04f004333350ca0ad24c1022c3d7737290ba1bfa56c394aefd302066", + "size": 41164, + "subdir": "linux-64", + "timestamp": 1572621616875, + "version": "0.3.1" + }, + "hdfs3-0.3.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7b39f7b74d024474066d4304973dbda9", + "name": "hdfs3", + "sha256": "f19022656a0d1ace6aa8bf4c53dd2ae0b5121e2adbf68b2ad66b27ddaf7467fc", + "size": 41158, + "subdir": "linux-64", + "timestamp": 1641828270275, + "version": "0.3.1" + }, + "hdfs3-0.3.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "libhdfs3 >=2.3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ec6269fc66848a5dec5d5aa0184c9c2c", + "name": "hdfs3", + "sha256": "7c5525c15bcd872219f58762331a3ed5434d7368093a9899b519bb17ccc14c2e", + "size": 41151, + "subdir": "linux-64", + "timestamp": 1641828244747, + "version": "0.3.1" + }, + "hdijupyterutils-0.12.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5b4816faa3f035b1a8ece861cdddf559", + "name": "hdijupyterutils", + "sha256": "9ced0b347a4309f39f367c9ac83af1b8c3e36a10122fdec6c5f190ff59853863", + "size": 13254, + "subdir": "linux-64", + "timestamp": 1530738696020, + "version": "0.12.5" + }, + "hdijupyterutils-0.12.5-py27hcc60360_0.conda": { + "build": "py27hcc60360_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a9b713d5f92e59b2692df5df77fb8728", + "name": "hdijupyterutils", + "sha256": "24ec44fad9fb81fa4c833da290705633891ae9c9c2b7a4e4f3a59be8ea2aa2e2", + "size": 13538, + "subdir": "linux-64", + "timestamp": 1511835492832, + "version": "0.12.5" + }, + "hdijupyterutils-0.12.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c45f8f447391d42f47e3b7428d33e1b4", + "name": "hdijupyterutils", + "sha256": "4ba79af2b5370e41c06bc8a6ca76fe79db3bd123d0163df09e014a0aad53a431", + "size": 13521, + "subdir": "linux-64", + "timestamp": 1534355171942, + "version": "0.12.5" + }, + "hdijupyterutils-0.12.5-py35h8a67a8b_0.conda": { + "build": "py35h8a67a8b_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7b876e3f71baccf2c3396f0ea45cf340", + "name": "hdijupyterutils", + "sha256": "5018901b78c16eaf707a569008a125eebd956a1c11b01d7aab4578e6cce82f81", + "size": 13865, + "subdir": "linux-64", + "timestamp": 1511835504913, + "version": "0.12.5" + }, + "hdijupyterutils-0.12.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8021afdbd453daf8308a92cb90248351", + "name": "hdijupyterutils", + "sha256": "d15f551871862fe0aabc22c4b7b61d04464cb208fbf2a100d55104c738b98c7e", + "size": 13472, + "subdir": "linux-64", + "timestamp": 1530738667179, + "version": "0.12.5" + }, + "hdijupyterutils-0.12.5-py36hc0bb8fd_0.conda": { + "build": "py36hc0bb8fd_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1583f4309354d6cbbda7b19af39ff580", + "name": "hdijupyterutils", + "sha256": "905d0f68c7ece7fc61ed6f209e7f171d8ec601e534d6eac5ed3dc39ea928f852", + "size": 13731, + "subdir": "linux-64", + "timestamp": 1511835504913, + "version": "0.12.5" + }, + "hdijupyterutils-0.12.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b687e2dbd0d19737468429de838a1c21", + "name": "hdijupyterutils", + "sha256": "8e09516798cfdd683dccee1a7d28a8fd16fe2e51e80396e67caf42b10c5b75cd", + "size": 13443, + "subdir": "linux-64", + "timestamp": 1530738726665, + "version": "0.12.5" + }, + "hdijupyterutils-0.12.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "384038a3440c5579e6efc504d1f7f18b", + "name": "hdijupyterutils", + "sha256": "a4d9172c532b657d3865c7884c63e60b293e4542f743e246570c033ba143f622", + "size": 14983, + "subdir": "linux-64", + "timestamp": 1539725818145, + "version": "0.12.6" + }, + "hdijupyterutils-0.12.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "c4afa1e8c66a7bb8cbc6519c88991aa1", + "name": "hdijupyterutils", + "sha256": "4ca86bc76113bc53aac2069ff91cdd010d1f8d581df6d20d52e7183b74b84d73", + "size": 15264, + "subdir": "linux-64", + "timestamp": 1539725840122, + "version": "0.12.6" + }, + "hdijupyterutils-0.12.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "ba58f5f4a4b5dfa4f1c4d06b6ed0d96b", + "name": "hdijupyterutils", + "sha256": "ae3c0810cfdcf9a23dc425d49ad740f6642fbd1f7ec06f3ffb44704f713f66f1", + "size": 15165, + "subdir": "linux-64", + "timestamp": 1539725840081, + "version": "0.12.6" + }, + "hdijupyterutils-0.20.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "jupyter >=1", + "mock", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "84a0c97a475d6ab038c7010eaa20893a", + "name": "hdijupyterutils", + "sha256": "82ed53c85497ba8cc79d46325a6ea81db003635a5c7b968bad3fbffd1eea0d83", + "size": 16081, + "subdir": "linux-64", + "timestamp": 1663054046392, + "version": "0.20.0" + }, + "hdijupyterutils-0.20.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "jupyter >=1", + "mock", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fb40b880a7cb1987b51e74c38083bdbc", + "name": "hdijupyterutils", + "sha256": "6f6191af76a4fa17da5b4c55139410d355217cf8eddd644a046e759a480cfbb0", + "size": 19058, + "subdir": "linux-64", + "timestamp": 1676839957770, + "version": "0.20.0" + }, + "hdijupyterutils-0.20.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "jupyter >=1", + "mock", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4e7fff7b81ea32e90624f3919581cf4c", + "name": "hdijupyterutils", + "sha256": "29b332642102a93acd148e6f9a1f93fe4522381c8f9ddd9c41de80993d3c8469", + "size": 15814, + "subdir": "linux-64", + "timestamp": 1663053879113, + "version": "0.20.0" + }, + "hdijupyterutils-0.20.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "jupyter >=1", + "mock", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bcad9b5893dd3d43580c4dbee53363ef", + "name": "hdijupyterutils", + "sha256": "f2f87946ac0a49a859655ac914582b2e0ee2e896968cde386956a9d6b85446d2", + "size": 15897, + "subdir": "linux-64", + "timestamp": 1663053938574, + "version": "0.20.0" + }, + "hdijupyterutils-0.20.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "jupyter >=1", + "mock", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ba63c70f37612223cea946926c0f59be", + "name": "hdijupyterutils", + "sha256": "2fd8c9306154e60b92eb2945fb56f50c1c966e784cbd05e88e3dff6f67506db4", + "size": 15925, + "subdir": "linux-64", + "timestamp": 1663053986978, + "version": "0.20.0" + }, + "hdmedians-0.13-py27h035aef0_0.conda": { + "build": "py27h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "d02afd86a991a8a846ca48322ae9b4ba", + "name": "hdmedians", + "sha256": "4ca96d6011af3d1dd46a51e46ec2c0975a174b520c3906b4f8f77a74572b443b", + "size": 144280, + "subdir": "linux-64", + "timestamp": 1534604115351, + "version": "0.13" + }, + "hdmedians-0.13-py27hdd07704_1000.conda": { + "build": "py27hdd07704_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "5847172322520573e62526ee98c52b26", + "name": "hdmedians", + "sha256": "c9cf6c340e3d57eda35a90f5d7f3034c83ba2b030e09aa93c012feab1247fc90", + "size": 155986, + "subdir": "linux-64", + "timestamp": 1565188723674, + "version": "0.13" + }, + "hdmedians-0.13-py35h035aef0_0.conda": { + "build": "py35h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "43fc55ca2598f6e80b1c1f93c1329321", + "name": "hdmedians", + "sha256": "d6042be6040a4a7e1ada5d20913706ce9e0bbdd81eddb02672138211e6d66e68", + "size": 137495, + "subdir": "linux-64", + "timestamp": 1534604668581, + "version": "0.13" + }, + "hdmedians-0.13-py36h035aef0_0.conda": { + "build": "py36h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "57db28bec32d8f8cc0f3c4cf2a386a24", + "name": "hdmedians", + "sha256": "79c055c4291908a04e3dcf045f0294dd0bb47b91bbadb55454f858c801997d4c", + "size": 139900, + "subdir": "linux-64", + "timestamp": 1534604542100, + "version": "0.13" + }, + "hdmedians-0.13-py36hdd07704_1000.conda": { + "build": "py36hdd07704_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "3311d4ecfa4b7adf2fcc199c476e2c60", + "name": "hdmedians", + "sha256": "9c2bb4f8ee558868b6ecaaca7db8c79fa2e52b92dbbde2701406bdb945cb03c9", + "size": 154865, + "subdir": "linux-64", + "timestamp": 1565190174871, + "version": "0.13" + }, + "hdmedians-0.13-py36heb32a55_1001.conda": { + "build": "py36heb32a55_1001", + "build_number": 1001, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "e5615c95130d6efeb87dc8a81cd05b19", + "name": "hdmedians", + "sha256": "931130d1edf8bcf88df74d628991ae3218df0555104cd6df3eb54205aa13f04f", + "size": 155141, + "subdir": "linux-64", + "timestamp": 1584958700900, + "version": "0.13" + }, + "hdmedians-0.13-py37h035aef0_0.conda": { + "build": "py37h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "79aef27a17097e951c7c22fb54960e3a", + "name": "hdmedians", + "sha256": "e19c9ae7abf2d1ab2cb7c2b4a03b2f3392bde659c63a5a2d3a9588876535c26b", + "size": 140413, + "subdir": "linux-64", + "timestamp": 1534604666124, + "version": "0.13" + }, + "hdmedians-0.13-py37h035aef0_1002.conda": { + "build": "py37h035aef0_1002", + "build_number": 1002, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "f658d3d8f777b02201bb6099f27395e9", + "name": "hdmedians", + "sha256": "ea8b96c0a65da7a06a3f55ee18e72f327c1b897044753a6c60f09fc6fb3214da", + "size": 139540, + "subdir": "linux-64", + "timestamp": 1594358873687, + "version": "0.13" + }, + "hdmedians-0.13-py37hdd07704_1000.conda": { + "build": "py37hdd07704_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "350478e65fecb8972dd0fadf260d5e06", + "name": "hdmedians", + "sha256": "e631252f3ee395ba8b62de2b79c76b788fe83ac5a0f9ac0768e920840959a487", + "size": 154371, + "subdir": "linux-64", + "timestamp": 1565188704577, + "version": "0.13" + }, + "hdmedians-0.13-py37heb32a55_1001.conda": { + "build": "py37heb32a55_1001", + "build_number": 1001, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "5c2d79428d69ad0da464c07043fc1219", + "name": "hdmedians", + "sha256": "a1b148cf68c0ea8baad975f117d7a169ce6700627271601db583dc66b11a0dfc", + "size": 154730, + "subdir": "linux-64", + "timestamp": 1584958639182, + "version": "0.13" + }, + "hdmedians-0.13-py38hdd07704_1000.conda": { + "build": "py38hdd07704_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "2c37e33bffcbc377e2511b1ab787589a", + "name": "hdmedians", + "sha256": "6d70916be862726d7506f36b334544b486df63628273f574e520709c742da51c", + "size": 160149, + "subdir": "linux-64", + "timestamp": 1573469574547, + "version": "0.13" + }, + "hdmedians-0.13-py38heb32a55_1001.conda": { + "build": "py38heb32a55_1001", + "build_number": 1001, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL3", + "license_family": "GPL3", + "md5": "339aadbfbc179a5a0522b36b5532a7df", + "name": "hdmedians", + "sha256": "471590cd8ec6cea70fc50e00f3c609ad85596be21576f9584ca82d3fcd23efff", + "size": 161903, + "subdir": "linux-64", + "timestamp": 1584958722594, + "version": "0.13" + }, + "hdmedians-0.14.1-py36hdd07704_0.conda": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "28603cb68c8dee2955a573fdbcec5aa4", + "name": "hdmedians", + "sha256": "59ba21acb3d57b7e4f4c25ce189ea00459d3be3340f1017ef7a6d334de811e26", + "size": 130098, + "subdir": "linux-64", + "timestamp": 1601310916710, + "version": "0.14.1" + }, + "hdmedians-0.14.1-py37hdd07704_0.conda": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "69fe2bcab86aef397614f50c330ae319", + "name": "hdmedians", + "sha256": "819096f255b20fe918e500d86ea82592da290586413a23c6459a47dd6a423477", + "size": 129089, + "subdir": "linux-64", + "timestamp": 1601310925966, + "version": "0.14.1" + }, + "hdmedians-0.14.1-py38hdd07704_0.conda": { + "build": "py38hdd07704_0", + "build_number": 0, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "53ccd74e5ffa70a4615fd603d7c9dfc8", + "name": "hdmedians", + "sha256": "d00c2247dc21279891c3b1b67710c5d172a82dc2716485d8ec12f2334c138d76", + "size": 133272, + "subdir": "linux-64", + "timestamp": 1601310892725, + "version": "0.14.1" + }, + "hdmedians-0.14.1-py39h6323ea4_0.conda": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ff3cdae64c0c92eef3745c3cc8b94c6b", + "name": "hdmedians", + "sha256": "50b96c0dc3c77a1c3cfce8ef4a079b5a32601d2613291ac1bdbcc4324caf262b", + "size": 134792, + "subdir": "linux-64", + "timestamp": 1614414140355, + "version": "0.14.1" + }, + "hdmedians-0.14.2-py310h9102076_1.conda": { + "build": "py310h9102076_1", + "build_number": 1, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2365e7a1afabae2e5fc08f7a670611c6", + "name": "hdmedians", + "sha256": "bd9d93f86555351fd11d7eb05a3186393d821ca70e1c81f7a02865de2483f18f", + "size": 432413, + "subdir": "linux-64", + "timestamp": 1640790867004, + "version": "0.14.2" + }, + "hdmedians-0.14.2-py310ha9d4c09_2.conda": { + "build": "py310ha9d4c09_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ac8a27c397c3a6d366bc52d6a7206876", + "name": "hdmedians", + "sha256": "715d4c5ab50c033b16eab21a3699c35d7a8d8d99da77558c5a017dbf9effdd3d", + "size": 151996, + "subdir": "linux-64", + "timestamp": 1676301103162, + "version": "0.14.2" + }, + "hdmedians-0.14.2-py311hbed6279_2.conda": { + "build": "py311hbed6279_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7acfd06ce0695a54f90c30ec5dd4996c", + "name": "hdmedians", + "sha256": "5378127a0ce8b7fd62e533c4b30689375c43a80048b9f65c207681beedb0a1cf", + "size": 137475, + "subdir": "linux-64", + "timestamp": 1676844261477, + "version": "0.14.2" + }, + "hdmedians-0.14.2-py36h6323ea4_1.conda": { + "build": "py36h6323ea4_1", + "build_number": 1, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b6c7550bb3d60a55b504eb1499589486", + "name": "hdmedians", + "sha256": "bec37c8b174a3d818060817139ed7bb566be92e4b8639d555b61de53f6424c57", + "size": 130002, + "subdir": "linux-64", + "timestamp": 1614616181251, + "version": "0.14.2" + }, + "hdmedians-0.14.2-py37h6323ea4_1.conda": { + "build": "py37h6323ea4_1", + "build_number": 1, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2f8fafffa5bf7bc8bfd2098e751928e0", + "name": "hdmedians", + "sha256": "ed1598f4a8b1a67908e7e7afbd9a4b9b62ffd153d7a419b5ec761f2b2635ddf3", + "size": 128794, + "subdir": "linux-64", + "timestamp": 1614615401126, + "version": "0.14.2" + }, + "hdmedians-0.14.2-py37h7deecbd_2.conda": { + "build": "py37h7deecbd_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "af22808e9bae3cf8808f15b9f4252652", + "name": "hdmedians", + "sha256": "72bc4678903763707810678786c3581efca5dff61b469e5cbc7392caf229f7da", + "size": 153935, + "subdir": "linux-64", + "timestamp": 1676301243460, + "version": "0.14.2" + }, + "hdmedians-0.14.2-py38h6323ea4_1.conda": { + "build": "py38h6323ea4_1", + "build_number": 1, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b768279072f5aefc1953b8f6917e8c53", + "name": "hdmedians", + "sha256": "f303aec8eb74df1d132d52d796bcc70e8f0578b006be62013512340585053d43", + "size": 135556, + "subdir": "linux-64", + "timestamp": 1614616179847, + "version": "0.14.2" + }, + "hdmedians-0.14.2-py38h7deecbd_2.conda": { + "build": "py38h7deecbd_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "626b21aa6b86e1b0ca0ac253aea09692", + "name": "hdmedians", + "sha256": "3e9c0c423b8cc4ce7d7d7be162178b749c3f874b6454a8c3988a101c83420999", + "size": 157625, + "subdir": "linux-64", + "timestamp": 1676301195580, + "version": "0.14.2" + }, + "hdmedians-0.14.2-py39h6323ea4_1.conda": { + "build": "py39h6323ea4_1", + "build_number": 1, + "depends": [ + "cython >=0.23", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "322f731b33c4b7cfb0c839e746a2ad64", + "name": "hdmedians", + "sha256": "b425074d1c55052abe62c6c42d333926cf3023f26ad8f01267551eeaebe8f35b", + "size": 133873, + "subdir": "linux-64", + "timestamp": 1614616175611, + "version": "0.14.2" + }, + "hdmedians-0.14.2-py39h7deecbd_2.conda": { + "build": "py39h7deecbd_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e342b462c2390803161341971b5715c5", + "name": "hdmedians", + "sha256": "17c20de93d54afb4d17cd2b35483afa51ca509a9794224bfb6d9c317a272535c", + "size": 154125, + "subdir": "linux-64", + "timestamp": 1676301148908, + "version": "0.14.2" + }, + "heapdict-1.0.0-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6e54e87b5e396e287d08731ced47bb72", + "name": "heapdict", + "sha256": "9712168ebf0db94b6def4910cc4cd00d7ef4e80a55643673353bdc91534a2b9e", + "size": 8421, + "subdir": "linux-64", + "timestamp": 1518029695426, + "version": "1.0.0" + }, + "heapdict-1.0.0-py27h33770af_0.conda": { + "build": "py27h33770af_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "123222154b69e222bfd882444e09e195", + "name": "heapdict", + "sha256": "a7fc09be72782bce5772b94da5fd9c8bf3ca98f6722d54e6826159f149b57ba4", + "size": 8034, + "subdir": "linux-64", + "timestamp": 1505732926826, + "version": "1.0.0" + }, + "heapdict-1.0.0-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6ee2bb2f5ef1360be41885e40bac9af5", + "name": "heapdict", + "sha256": "7c4354e542288ab5ea1b85d4b2da6ba9bbcbc8bda16175fa2326ab365b429941", + "size": 8202, + "subdir": "linux-64", + "timestamp": 1518029712593, + "version": "1.0.0" + }, + "heapdict-1.0.0-py35h51e6c10_0.conda": { + "build": "py35h51e6c10_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e6e73d49e972ed9b48b3029205083e8f", + "name": "heapdict", + "sha256": "b4e48e5898d465452e764ec10c021b1adea3f7b2ad56f499c41dda045c7f2c1b", + "size": 7768, + "subdir": "linux-64", + "timestamp": 1505732937783, + "version": "1.0.0" + }, + "heapdict-1.0.0-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d78870851e8e23191faab106351447e5", + "name": "heapdict", + "sha256": "54fefc040102c8d14c0a794680216eea988c79bd9dd77f96f37dc1f00aa2caef", + "size": 8133, + "subdir": "linux-64", + "timestamp": 1518029728032, + "version": "1.0.0" + }, + "heapdict-1.0.0-py36h79797d7_0.conda": { + "build": "py36h79797d7_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a02ed192f2c30c00d2d66b15e15c19fa", + "name": "heapdict", + "sha256": "42e65dfbc99c249fb7b1e45a42d01c6585de58761b453918a6cc9ac020c6566b", + "size": 7735, + "subdir": "linux-64", + "timestamp": 1505732948871, + "version": "1.0.0" + }, + "heapdict-1.0.0-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "13976ebe56fc411098d7dfe3b0c564f9", + "name": "heapdict", + "sha256": "aa4dbdbba5c4e5b217ad327bf0511ae03d627bb8050b2ad943d168f9f59bbe44", + "size": 8027, + "subdir": "linux-64", + "timestamp": 1530741351719, + "version": "1.0.0" + }, + "heapdict-1.0.0-py38_2.conda": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "927bb752623386afde8f3a155fc21dfc", + "name": "heapdict", + "sha256": "a8c4272567d150704b4f85625a67f0337597fae09942c4b0b62efb0a5c277227", + "size": 8414, + "subdir": "linux-64", + "timestamp": 1572512127985, + "version": "1.0.0" + }, + "help2man-1.47.17-pl5262h27cfd23_0.conda": { + "build": "pl5262h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "perl" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "b51a76f33324ce0a176fa9ddee79523e", + "name": "help2man", + "sha256": "9e71f3da6ec1d9349e5d16f17eeab96cd13a9097639f49af86c4018d5d49298c", + "size": 29127, + "subdir": "linux-64", + "timestamp": 1611514780274, + "version": "1.47.17" + }, + "help2man-1.47.6-pl526h14c3975_0.conda": { + "build": "pl526h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "perl" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "7d9957414324cdf44f1fc9c467aedb41", + "name": "help2man", + "sha256": "bfb6037afab17b18712df15b59dcb3669260ebd33ffd1245d30f988b6d51b7cc", + "size": 29541, + "subdir": "linux-64", + "timestamp": 1527326658152, + "version": "1.47.6" + }, + "help2man-1.47.7-pl526h7b6447c_0.conda": { + "build": "pl526h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "perl" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "6887cf2bb3dde0c3b2104d194dc547cb", + "name": "help2man", + "sha256": "fffa3e34905b7a37e25812f10dbeb395a0ab67c8b62ac604229080e18c3abfee", + "size": 29782, + "subdir": "linux-64", + "timestamp": 1539663973702, + "version": "1.47.7" + }, + "help2man-1.47.8-pl526h7b6447c_0.conda": { + "build": "pl526h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "perl" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "db9f1412c49ff7375599b87eb312f9b6", + "name": "help2man", + "sha256": "280b2e225487396f3ae9714e7fd62d90cc1d9055d7b2ad72618f9e61fe6c046a", + "size": 30528, + "subdir": "linux-64", + "timestamp": 1547231987595, + "version": "1.47.8" + }, + "help2man-1.48.1-pl5262h27cfd23_0.conda": { + "build": "pl5262h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "perl" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "1987fed203acb0c1874d664cbdee3bd1", + "name": "help2man", + "sha256": "b5a636fc0f316920889bc7bdfd7be348cd873b6435b0e8afed6e2dfb6b78dfca", + "size": 29099, + "subdir": "linux-64", + "timestamp": 1613415235045, + "version": "1.48.1" + }, + "help2man-1.48.2-pl5262h27cfd23_0.conda": { + "build": "pl5262h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "perl" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "7b786531de4a2c7868d22b4a74422aa5", + "name": "help2man", + "sha256": "c493d66782993bdbcd676886bab3b3024755b832f9c61d2b49fdbf857f1505a8", + "size": 29126, + "subdir": "linux-64", + "timestamp": 1614797165362, + "version": "1.48.2" + }, + "help2man-1.48.3-pl5262h27cfd23_0.conda": { + "build": "pl5262h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "perl" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "fcada0921b546bb357ac2c4ffa3f0d16", + "name": "help2man", + "sha256": "4557cec4718b72008b02a70c9db9300bd4fdae0b91004e50290541de2d022ebe", + "size": 29094, + "subdir": "linux-64", + "timestamp": 1617222655891, + "version": "1.48.3" + }, + "help2man-1.48.4-pl5262h7f8727e_0.conda": { + "build": "pl5262h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "perl" + ], + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "2107fccd183750c7409152a99cd55f47", + "name": "help2man", + "sha256": "bf148cde483987de65ce43d84a0aec192b2e3ebe09fd35d3a93d703f13936b43", + "size": 28869, + "subdir": "linux-64", + "timestamp": 1629126812456, + "version": "1.48.4" + }, + "hicolor-icon-theme-0.17-h06a4308_2.conda": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "9896258d57ed1beecb0d6cdbefa3ad5a", + "name": "hicolor-icon-theme", + "sha256": "e02d10d013a58add0b21a56a61c9cec73f4c4e5121e295a730167281254867cc", + "size": 16938, + "subdir": "linux-64", + "timestamp": 1632405199912, + "version": "0.17" + }, + "hiredis-1.1.0-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f6fbcf47dd1203a05f3fae7bd3da8f15", + "name": "hiredis", + "sha256": "fe2c76af4a05f6fdba0929a1caa5881f7182be3899bc2868276b034cc5dffaf6", + "size": 56215, + "subdir": "linux-64", + "timestamp": 1640790891992, + "version": "1.1.0" + }, + "hiredis-1.1.0-py311h5eee18b_1.conda": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e96b060c6ea57414cb58ad06e5cfb2bf", + "name": "hiredis", + "sha256": "b6d9e545ed7353eb8666cf31ab531c68ff586a4131f10e80a9bd710b40fc4897", + "size": 23992, + "subdir": "linux-64", + "timestamp": 1676852669568, + "version": "1.1.0" + }, + "hiredis-1.1.0-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "4dc9614d737c112ae9b30e0c3435672e", + "name": "hiredis", + "sha256": "0155a728e9243cf4bc1664588e191e1586803689b2ffe75f9b78e531842d92df", + "size": 27770, + "subdir": "linux-64", + "timestamp": 1621433454445, + "version": "1.1.0" + }, + "hiredis-1.1.0-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f21ec763c1eec9aa2e48a09273ccd6bb", + "name": "hiredis", + "sha256": "52f668fb9d8de7cb9706bd0142697f51c7a46d21ab3d6580bd19576df7ecb306", + "size": 27067, + "subdir": "linux-64", + "timestamp": 1621433322215, + "version": "1.1.0" + }, + "hiredis-1.1.0-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d1a0cfac2c3929bc2410225f78a63485", + "name": "hiredis", + "sha256": "1717bc6e6e0f014a79af97a445fd97103b9c5af46132bef0d8b4144c60ebee41", + "size": 27557, + "subdir": "linux-64", + "timestamp": 1621428822822, + "version": "1.1.0" + }, + "hiredis-1.1.0-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7e5bce5df5a91e62adb899e28331e33d", + "name": "hiredis", + "sha256": "149af98ceb4740cb3f41c00be1596a851afeb0aabfcbbe967dcd3fe4505579d9", + "size": 27630, + "subdir": "linux-64", + "timestamp": 1621433461897, + "version": "1.1.0" + }, + "hiredis-2.0.0-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "41c0c4728f9edccd9428880da2d7aa00", + "name": "hiredis", + "sha256": "f9828d16889cd4c7ea304657617b4a9b77c595e4eb1d96f820ab59f480e376b2", + "size": 76979, + "subdir": "linux-64", + "timestamp": 1661475819874, + "version": "2.0.0" + }, + "hiredis-2.0.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2558452f35c77564f0f17e32dafef97f", + "name": "hiredis", + "sha256": "f4c3d8e01b7a113b132ed6b0642d1b13385272c924351ab49d8c49765d68879e", + "size": 29445, + "subdir": "linux-64", + "timestamp": 1679336253654, + "version": "2.0.0" + }, + "hiredis-2.0.0-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d3cdf9a479c562d1b67100d7bb88c821", + "name": "hiredis", + "sha256": "2d62c8345ff410277b3c761550c193e847425870b07ed312647ebe8c2b48e199", + "size": 29775, + "subdir": "linux-64", + "timestamp": 1661475850237, + "version": "2.0.0" + }, + "hiredis-2.0.0-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3c0dbd5f7c999819d9a2305e7f51e358", + "name": "hiredis", + "sha256": "57773391e3974a3babaa4aefd48327e7b116e6d42cdf0595596118f9b55aac85", + "size": 29803, + "subdir": "linux-64", + "timestamp": 1661475738627, + "version": "2.0.0" + }, + "hiredis-2.0.0-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5940c9479a32bcfbf3dd04ccac882f14", + "name": "hiredis", + "sha256": "4c40d51e23800522995a47825b3bc42f07bd64e1f4a9919ef8407e6923609e0c", + "size": 29755, + "subdir": "linux-64", + "timestamp": 1661475773357, + "version": "2.0.0" + }, + "holidays-0.18-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.3.0", + "hijri-converter", + "korean_lunar_calendar", + "pymeeus", + "python >=3.10,<3.11.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "645133239ff8be584ecd0489c79fbcaa", + "name": "holidays", + "sha256": "efd667f29d9419cee8155191699f900f10c003cd392e8c335f708a0bc50a3954", + "size": 205426, + "subdir": "linux-64", + "timestamp": 1673991951253, + "version": "0.18" + }, + "holidays-0.18-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.3.0", + "hijri-converter", + "korean_lunar_calendar", + "pymeeus", + "python >=3.11,<3.12.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5151eb5f57140f1946edd5281b5f064a", + "name": "holidays", + "sha256": "0bb31fc92b67a3226256e86c256532c350c0bbd2e1efed9c4dbe05bc2fe0d2a9", + "size": 235031, + "subdir": "linux-64", + "timestamp": 1676852685158, + "version": "0.18" + }, + "holidays-0.18-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.3.0", + "hijri-converter", + "korean_lunar_calendar", + "pymeeus", + "python >=3.7,<3.8.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9e0a008abc12bd141f933abda00fc76", + "name": "holidays", + "sha256": "2822d4bc72f20c28dfc70c962d1282e6448b3364535b425bd3f2fc78fce82332", + "size": 203542, + "subdir": "linux-64", + "timestamp": 1673991978404, + "version": "0.18" + }, + "holidays-0.18-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.3.0", + "hijri-converter", + "korean_lunar_calendar", + "pymeeus", + "python >=3.8,<3.9.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "46531cf3daad710f473e91f1ddc58e30", + "name": "holidays", + "sha256": "0f206c69c195dd75d8a67fec1d02a0b042a7472ba030c90f741443482cf6ff5f", + "size": 204794, + "subdir": "linux-64", + "timestamp": 1673991923805, + "version": "0.18" + }, + "holidays-0.18-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.3.0", + "hijri-converter", + "korean_lunar_calendar", + "pymeeus", + "python >=3.9,<3.10.0a0", + "python-dateutil" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "508275a788f3a389b498adc1b5f5ecce", + "name": "holidays", + "sha256": "07666986e588a2e3eea468f175756c278adfb7b628f55ddd5d562bdf27a4056c", + "size": 204356, + "subdir": "linux-64", + "timestamp": 1673992005411, + "version": "0.18" + }, + "holoviews-1.10.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "47d1395c74b2521127288478cf42b050", + "name": "holoviews", + "sha256": "394f3fe9a1ff7e3d8de5d124a4fd226c6b6a76235a43a6b5985e422df7f42fee", + "size": 3409315, + "subdir": "linux-64", + "timestamp": 1524000900626, + "version": "1.10.0" + }, + "holoviews-1.10.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b10e85a4a09870f4361db16eb678283c", + "name": "holoviews", + "sha256": "6746950c14ed149775f87a6229aa641a72fce30d75620efce2416586090d9d66", + "size": 3426141, + "subdir": "linux-64", + "timestamp": 1524000901459, + "version": "1.10.0" + }, + "holoviews-1.10.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "915312239f03a4851197749a95d94cb6", + "name": "holoviews", + "sha256": "23d796a2c1eef2fbf698147610b762d6dddabd8b8ee73c0c9120384ad537a139", + "size": 3431016, + "subdir": "linux-64", + "timestamp": 1524000907461, + "version": "1.10.0" + }, + "holoviews-1.10.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.14,<=0.12.16", + "ipython >=5.4.0", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param >=1.6.0,<2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7626f321b1a96b4bdc50f255db28ee49", + "name": "holoviews", + "sha256": "c96e831b3600de8857f95385d15075f2fcbecc6d80107594f655488b7978f140", + "size": 3421307, + "subdir": "linux-64", + "timestamp": 1524514123796, + "version": "1.10.1" + }, + "holoviews-1.10.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.14,<=0.12.16", + "ipython >=5.4.0", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param >=1.6.0,<2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0b7924e83fa640d4f2171b14e82c9e1b", + "name": "holoviews", + "sha256": "db8b1fa7a9aabc03fc77cdc931ec4d94105d68d7adb95e90bb3766280a609287", + "size": 3427618, + "subdir": "linux-64", + "timestamp": 1524514148087, + "version": "1.10.1" + }, + "holoviews-1.10.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.14,<=0.12.16", + "ipython >=5.4.0", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param >=1.6.0,<2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "aa28fce1a80bb36dfcaf36e260ae8f74", + "name": "holoviews", + "sha256": "4e1083e0383bf9ac87b8b158c60a1431ef068a145c07de69cdfd8c6c32a1da71", + "size": 3417537, + "subdir": "linux-64", + "timestamp": 1524514146371, + "version": "1.10.1" + }, + "holoviews-1.10.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cd4e04193713cc67e2ccf7daec0e1989", + "name": "holoviews", + "sha256": "9b8cef2ad91cf14f1e62eafceefb918bf4dee8c9110a1d2127b001cb6cc7dae4", + "size": 3424122, + "subdir": "linux-64", + "timestamp": 1525186194852, + "version": "1.10.2" + }, + "holoviews-1.10.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "21401898988683519d086fa51ad3f552", + "name": "holoviews", + "sha256": "7dd8b21fa825682fe5dbbea96d76cf85ce6335772a405b97fcb1aeb2eebb98a1", + "size": 3457543, + "subdir": "linux-64", + "timestamp": 1525186205025, + "version": "1.10.2" + }, + "holoviews-1.10.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e1a67cf5783c15a7358d3d5413487454", + "name": "holoviews", + "sha256": "d18111b5921947525fa3442f789d5830584592614d0d808f11337997302d1677", + "size": 3438159, + "subdir": "linux-64", + "timestamp": 1525186212529, + "version": "1.10.2" + }, + "holoviews-1.10.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7c4bb51281390ced2a837107b167626a", + "name": "holoviews", + "sha256": "cc0e6e6ede17a2ea3c2b9c658a81d005e38871fd50587762750e40f02ac348b8", + "size": 3435326, + "subdir": "linux-64", + "timestamp": 1525875540944, + "version": "1.10.3" + }, + "holoviews-1.10.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "438e42ecc029fd1a34fcc2d86367721e", + "name": "holoviews", + "sha256": "f8fb30eb56eaa05a4c5c704b78f8645d97688bd68665751e9c48ca39f0fef94a", + "size": 3441389, + "subdir": "linux-64", + "timestamp": 1525875853722, + "version": "1.10.3" + }, + "holoviews-1.10.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4f8d7ebaaf99bf42ca6ab66cc308e9f7", + "name": "holoviews", + "sha256": "078ced1f407379554edba40bfd35c96900e5281de50cf061b58ad27b9c709776", + "size": 3448412, + "subdir": "linux-64", + "timestamp": 1525875821486, + "version": "1.10.3" + }, + "holoviews-1.10.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "322d32e1a007ddd2ff6b256cdf682ba5", + "name": "holoviews", + "sha256": "8c4ab740e799b6df99ea19899c57489179c83d5b9249fd0d4a1f618a6b55f3d2", + "size": 3424638, + "subdir": "linux-64", + "timestamp": 1526567774916, + "version": "1.10.4" + }, + "holoviews-1.10.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9bf2dc0ea5f54b74de048984dcddcde9", + "name": "holoviews", + "sha256": "72f2e890fc5e4a7bfae4b0a270d446fc6d5bdea2ec201121bcaa29a9f1179c86", + "size": 3441896, + "subdir": "linux-64", + "timestamp": 1526567844000, + "version": "1.10.4" + }, + "holoviews-1.10.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "473be71def199418a43712328f31a655", + "name": "holoviews", + "sha256": "7f2cde525977cbf2df7d4416f6029c8bd3e1e325368a8ed52dee0df8dde8b3a4", + "size": 3434661, + "subdir": "linux-64", + "timestamp": 1526567777956, + "version": "1.10.4" + }, + "holoviews-1.10.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.12.16", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=2.7,<2.8.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "2271d9f67744c1f0daf44382f6c26348", + "name": "holoviews", + "sha256": "1eba8f3c5846266f3bd9d505622ab542fd5a5f61ffd81428fd27d0c6829e6571", + "size": 3425352, + "subdir": "linux-64", + "timestamp": 1529337042097, + "version": "1.10.5" + }, + "holoviews-1.10.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.12.16", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.5,<3.6.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "b24a41831240ea900736e14b7ef0b696", + "name": "holoviews", + "sha256": "de7de9d493d6773d87fbe31613fd85c2f82b0c35567ba07ded5fc1f6287c1ca9", + "size": 3443666, + "subdir": "linux-64", + "timestamp": 1529337073689, + "version": "1.10.5" + }, + "holoviews-1.10.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.12.16", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.6,<3.7.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "673614064b3c8db1348cf526a9cb645a", + "name": "holoviews", + "sha256": "261eb47ff2a760f9ca22315e958dfa78c91740d5204a0ec20fbcf63df362f6c4", + "size": 3435391, + "subdir": "linux-64", + "timestamp": 1529337038472, + "version": "1.10.5" + }, + "holoviews-1.10.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.13.0", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=2.7,<2.8.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "f65bb166fb15d6500636eb136ad70604", + "name": "holoviews", + "sha256": "c4369a4e14e0f3e54c2b576754dc9314bce75beee44fff9f34c77aab4bfda71d", + "size": 3446396, + "subdir": "linux-64", + "timestamp": 1530893129662, + "version": "1.10.6" + }, + "holoviews-1.10.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.13.0", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.6,<3.7.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "6fb4a7190318da126100882ca3fa493d", + "name": "holoviews", + "sha256": "33a6c0569feddd9163e0f7fd0d64f3466e8d70a6535822ddf211957c3b439af4", + "size": 3442394, + "subdir": "linux-64", + "timestamp": 1530893076288, + "version": "1.10.6" + }, + "holoviews-1.10.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.13.0", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.7,<3.8.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "58574cac244f8169f477560b99d6c133", + "name": "holoviews", + "sha256": "3f1f37e70d3367902a09f59b9ecbbac134cd1790097cccfb78dfedf3ccb0a709", + "size": 3456220, + "subdir": "linux-64", + "timestamp": 1530893021819, + "version": "1.10.6" + }, + "holoviews-1.10.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.13.0", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=2.7,<2.8.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "bb4484e1bddbf82108eb2199cf12f495", + "name": "holoviews", + "sha256": "48a7d10b88d3b22b7aac5164473d8bcbbfddf02902755de73798625bc7ebc972", + "size": 3432033, + "subdir": "linux-64", + "timestamp": 1532552538106, + "version": "1.10.7" + }, + "holoviews-1.10.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.13.0", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.5,<3.6.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "2af8b1e3ae86e27b2ab9ee98f00b146c", + "name": "holoviews", + "sha256": "16239b56867fc5aea2c4c1a4e527803bf0a038298ad03d2f6b0f457b735935aa", + "size": 3453876, + "subdir": "linux-64", + "timestamp": 1532552713752, + "version": "1.10.7" + }, + "holoviews-1.10.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.13.0", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.6,<3.7.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "44aa14a2f0250e17272b0b7ce2687cba", + "name": "holoviews", + "sha256": "d647b7bb9c7f70885a3b08df1f0c5ffbf8d89bee0e5ed3a63605b0760f1976c0", + "size": 3458606, + "subdir": "linux-64", + "timestamp": 1532552531235, + "version": "1.10.7" + }, + "holoviews-1.10.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bokeh >=0.12.15,<=0.13.0", + "ipython >=5.4.0", + "jupyter", + "matplotlib >=2.1", + "notebook", + "numpy >=1.0", + "param >=1.6.1,<2.0", + "python >=3.7,<3.8.0a0", + "pyviz_comms" + ], + "license": "BSD 3-Clause", + "md5": "420fe201002b168fee8eb48660718af4", + "name": "holoviews", + "sha256": "89c98086c40a8eac66e595f663bda62a1b7674026696b82d805a8cc8ad9717d4", + "size": 3455838, + "subdir": "linux-64", + "timestamp": 1532552571608, + "version": "1.10.7" + }, + "holoviews-1.15.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "68d5d23e1452590d0fbf6b6a25c82bb7", + "name": "holoviews", + "sha256": "c1907dce93f3fac440d07b0f4561847d357ee106d2b6bcc2ca81e355b3c30756", + "size": 4223788, + "subdir": "linux-64", + "timestamp": 1658171786808, + "version": "1.15.0" + }, + "holoviews-1.15.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "bokeh >=2.4.3,<2.5.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "21d2d3b92a7f0ec3b7938a63c3b9d5f9", + "name": "holoviews", + "sha256": "b3b184b52c43a4183ae1c65a48be5fc4929bb7ecf531bae1e3992f58ae575644", + "size": 4515287, + "subdir": "linux-64", + "timestamp": 1668502209372, + "version": "1.15.0" + }, + "holoviews-1.15.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ac8fd16ab94d897c9b18b20d36d7f5e3", + "name": "holoviews", + "sha256": "67eb143387a859458798e4baedac397c09a3b04b71cd66aec129c96e573d4636", + "size": 4199794, + "subdir": "linux-64", + "timestamp": 1658171635265, + "version": "1.15.0" + }, + "holoviews-1.15.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "bokeh >=2.4.3,<2.5.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cbd91f42f156f6eda3e6da25de1d631f", + "name": "holoviews", + "sha256": "6e3ab18251da405270d9028080809f2b0683e0ba25c857ed1c8daa5848569093", + "size": 4510423, + "subdir": "linux-64", + "timestamp": 1668501986794, + "version": "1.15.0" + }, + "holoviews-1.15.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "468c6c066effd1ffe805239ab63c7cc3", + "name": "holoviews", + "sha256": "4a62d7cce79c4b454bfdc39c7fa92b1272fad1e4483dd96bacbadca0f3ee7d67", + "size": 4211082, + "subdir": "linux-64", + "timestamp": 1658171557394, + "version": "1.15.0" + }, + "holoviews-1.15.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "bokeh >=2.4.3,<2.5.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a9fd14226c68b428d3a14d510a3a347", + "name": "holoviews", + "sha256": "9e096905e9539d55c6e2f6f0a88195574cd914ae2fe2cb85cc0e39cff71410cc", + "size": 4516605, + "subdir": "linux-64", + "timestamp": 1668502137628, + "version": "1.15.0" + }, + "holoviews-1.15.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "480bdbc69a6b68b8ed31b413a179e7fc", + "name": "holoviews", + "sha256": "03039461fd7fe6aa3e423f66a96e49ccfe6de1ff0f8e14ec88d5b5059bd1629d", + "size": 4207283, + "subdir": "linux-64", + "timestamp": 1658171704915, + "version": "1.15.0" + }, + "holoviews-1.15.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "bokeh >=2.4.3,<2.5.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3c6ce3bbf8cc64bae911c6883a4e4f59", + "name": "holoviews", + "sha256": "4c80877ebe8346a380ca2b0f0b32162296c3655a64a0210ec23d4fc624e7e477", + "size": 4514057, + "subdir": "linux-64", + "timestamp": 1668502065853, + "version": "1.15.0" + }, + "holoviews-1.15.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "038c148468b2c24c4c5a58025903afe9", + "name": "holoviews", + "sha256": "0bd1d7ebf9e77eccedb38608247ed8d94a70b7ba2faa37284b13e5584d2bbf8a", + "size": 4574706, + "subdir": "linux-64", + "timestamp": 1668507167161, + "version": "1.15.2" + }, + "holoviews-1.15.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "423cb71a6e1593ac216a4f60c3932fc3", + "name": "holoviews", + "sha256": "94ab06bee89966773ac775be5aec061096f5c6bc3d561e35bf48f1715341208d", + "size": 4553468, + "subdir": "linux-64", + "timestamp": 1668506944896, + "version": "1.15.2" + }, + "holoviews-1.15.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "984b9dab044d2491f315290bd2768b5d", + "name": "holoviews", + "sha256": "7a671351178e207f73c81ff8a54b54d8d09b279cf8463a76b77d00ed13c07850", + "size": 4574948, + "subdir": "linux-64", + "timestamp": 1668507095660, + "version": "1.15.2" + }, + "holoviews-1.15.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "372d3ebc8ffec1cd28afbb1295a09ae6", + "name": "holoviews", + "sha256": "e7164a7652f0c63d2e903713c286402ea35c62ebb10ea61c587b5bb226a533e2", + "size": 4563576, + "subdir": "linux-64", + "timestamp": 1668507023468, + "version": "1.15.2" + }, + "holoviews-1.15.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d03a6ac96be6593b681161fe08d80b85", + "name": "holoviews", + "sha256": "2c20218366e47ff1239a2d28f1c24d3be3c85cf10cc7b75c5d298bc7e333d6fd", + "size": 4578946, + "subdir": "linux-64", + "timestamp": 1671783124208, + "version": "1.15.3" + }, + "holoviews-1.15.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.11,<3.12.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "87016a3ad1d810e7e9d2310809f78bfa", + "name": "holoviews", + "sha256": "3bd8f7b817cdd91da381b33cc5a43bbd0cc4aa8aadc9a282f0d4b28363982a26", + "size": 4875866, + "subdir": "linux-64", + "timestamp": 1676844282740, + "version": "1.15.3" + }, + "holoviews-1.15.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "667d6b205ca756f54cd8b7526ddda27f", + "name": "holoviews", + "sha256": "ec4ac8e197184846a0ccaf45e423febeb4f9acadd0a8b34d4f87fe6726d5cf60", + "size": 4547811, + "subdir": "linux-64", + "timestamp": 1671783053444, + "version": "1.15.3" + }, + "holoviews-1.15.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3a2a1998513a219e5cc8cfe33dd9b4b5", + "name": "holoviews", + "sha256": "0a352e2b050eaeea7593e0f2f2a6939a9542c9a10d95d895bb8050082f526523", + "size": 4564271, + "subdir": "linux-64", + "timestamp": 1671783195954, + "version": "1.15.3" + }, + "holoviews-1.15.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0f232b91d42d5b359b13be866793a0df", + "name": "holoviews", + "sha256": "510c08ecbe5c67ae6ad9d64c6b22479da467040aa759ba9c90fed521ed443779", + "size": 4559282, + "subdir": "linux-64", + "timestamp": 1671782975232, + "version": "1.15.3" + }, + "holoviews-1.15.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2528aea848163c7540ef5fb75305f277", + "name": "holoviews", + "sha256": "9e2e959bc7911aa666f85194db680e786b6fdec1406b5a75ef0671755b517510", + "size": 4546511, + "subdir": "linux-64", + "timestamp": 1676372933494, + "version": "1.15.4" + }, + "holoviews-1.15.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.11,<3.12.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dfab93fad8a2c2b136ef2ae6849bff33", + "name": "holoviews", + "sha256": "c8f1711c2e432e1a442e89aefcf59d076670372ce17ec5410df7297a40566511", + "size": 4978263, + "subdir": "linux-64", + "timestamp": 1679336285609, + "version": "1.15.4" + }, + "holoviews-1.15.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "10c6647dcdc4b4f8f1e7244f8ee92fe3", + "name": "holoviews", + "sha256": "a76df1015531bb6a591b5902dd4d62dcad325e20c0418a67de244bec683eb550", + "size": 4537771, + "subdir": "linux-64", + "timestamp": 1676373081665, + "version": "1.15.4" + }, + "holoviews-1.15.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "31d7be0e12d99635b4314597ffd53d81", + "name": "holoviews", + "sha256": "a883a2b8d2b8c632835dc6ff75178a84654d503bb2a8e3021dcd9708ceb09e32", + "size": 4550136, + "subdir": "linux-64", + "timestamp": 1676373153977, + "version": "1.15.4" + }, + "holoviews-1.15.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.4.3,<3.0", + "colorcet", + "ipython >=5.4.0", + "matplotlib-base >=3", + "notebook", + "numpy >=1.0", + "packaging", + "pandas >=0.20.0", + "panel >=0.13.1", + "param >=1.9.3,<2.0", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5924ac4d523664d7c93f63ab16692dea", + "name": "holoviews", + "sha256": "aba7a31ec66b91881ab90fab2c2a9803fceee5b41aa56bfa82bd9a15b29e5e44", + "size": 4548389, + "subdir": "linux-64", + "timestamp": 1676373006514, + "version": "1.15.4" + }, + "holoviews-1.9.1-py27h8db4e1f_0.conda": { + "build": "py27h8db4e1f_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "lancet", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9b76976eb286e5580fd01748b563be9b", + "name": "holoviews", + "sha256": "be7ff677bda261cd8f1217b9481e780a17268e9fecbf2e2cb6c7302c5d72b7f6", + "size": 3196664, + "subdir": "linux-64", + "timestamp": 1511672937588, + "version": "1.9.1" + }, + "holoviews-1.9.1-py35hd7d2f6e_0.conda": { + "build": "py35hd7d2f6e_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "lancet", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f0e97f23ad93a770c05864591113121f", + "name": "holoviews", + "sha256": "d494ac120c31a2781fd3218c82df6b5234579da6a7fd67d82f17c56b72c12090", + "size": 3221920, + "subdir": "linux-64", + "timestamp": 1511672959495, + "version": "1.9.1" + }, + "holoviews-1.9.1-py36h76d18d8_0.conda": { + "build": "py36h76d18d8_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "lancet", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9583d0649f5c764f2b4581e475748e40", + "name": "holoviews", + "sha256": "892077c834f2293a9bb8cc63e563712253f52edb83c991277a5aabfbce490a90", + "size": 3207475, + "subdir": "linux-64", + "timestamp": 1511672942702, + "version": "1.9.1" + }, + "holoviews-1.9.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ef7b27dfc5f82cd4ed523a68824ade86", + "name": "holoviews", + "sha256": "1a042199431eb8ed0fc8e33f4c00f2a8e717caefbe5eb78bb417d85ca7d550a2", + "size": 3213320, + "subdir": "linux-64", + "timestamp": 1515177941849, + "version": "1.9.2" + }, + "holoviews-1.9.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "efa22adb309f9ae83b52b754323a1b90", + "name": "holoviews", + "sha256": "c425128e6dcde29761044a0578f95da7dc976d88e3784173ae2eb6088eb2b193", + "size": 3228394, + "subdir": "linux-64", + "timestamp": 1515178049434, + "version": "1.9.2" + }, + "holoviews-1.9.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a1aefac2c632c47ebec9457448bdfcb2", + "name": "holoviews", + "sha256": "4ac6d1be7fc06191c2045db4ce9f2b379b4697fa00f5e81e42dd3d7227a60051", + "size": 3213091, + "subdir": "linux-64", + "timestamp": 1515178049561, + "version": "1.9.2" + }, + "holoviews-1.9.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6a872f983e12f9cda210987456d604ea", + "name": "holoviews", + "sha256": "cfb6fa6a96dcd61747e732fcede6273a48925b7a4b952c2a69ab21f1cf017a6d", + "size": 3220550, + "subdir": "linux-64", + "timestamp": 1519237201753, + "version": "1.9.4" + }, + "holoviews-1.9.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c0cdf5df0bf83b637b21b652825a5cd6", + "name": "holoviews", + "sha256": "0c8cef0b5da7f2863b583ffb2ccf0226f2b8012e14b6e5ebe1ac74f7708f218e", + "size": 3224682, + "subdir": "linux-64", + "timestamp": 1519237180976, + "version": "1.9.4" + }, + "holoviews-1.9.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5d7601ac86fd600c952fa0f17133b4ef", + "name": "holoviews", + "sha256": "05b44ad60274a3c73081706fa3cc7d14cd649cb092d33e25abb044d343d30a8d", + "size": 3226606, + "subdir": "linux-64", + "timestamp": 1519237019722, + "version": "1.9.4" + }, + "holoviews-1.9.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "129f324ac68f0836ad253127d3894308", + "name": "holoviews", + "sha256": "f0709ed8c23c9aaa6f863b3660400aa5289d871d4538da9d77832ee50a26c9d8", + "size": 3212402, + "subdir": "linux-64", + "timestamp": 1522360445793, + "version": "1.9.5" + }, + "holoviews-1.9.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e1ea5e19664e9b78caca145293de04e5", + "name": "holoviews", + "sha256": "8f09c777f93726af257c97d854b1216fa7450383600b9f387f3e3f51220613a7", + "size": 3237955, + "subdir": "linux-64", + "timestamp": 1522360757526, + "version": "1.9.5" + }, + "holoviews-1.9.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bokeh", + "ipython", + "jupyter", + "matplotlib", + "notebook", + "numpy", + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8010f0894af682971833540c92a0b7ca", + "name": "holoviews", + "sha256": "decbaaccbc17df4483879c3462fd3110cc8ff06bc7a0269986068d78ff7b9b0f", + "size": 3230818, + "subdir": "linux-64", + "timestamp": 1522360747895, + "version": "1.9.5" + }, + "hpack-3.0.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66737f0e691371dd7b20dda83fd8621a", + "name": "hpack", + "sha256": "ffa119c85fc773ba524dcd47625c1ea6042839ff96909dd54d6cf008a8262c0c", + "size": 47123, + "subdir": "linux-64", + "timestamp": 1530918994794, + "version": "3.0.0" + }, + "hpack-3.0.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "99c035022ee763ff64e63fd691c8f8f0", + "name": "hpack", + "sha256": "2d4f8a4a826a10af4cdd7ed8f471d335d617a4736e0d529ff4d73f676279f2ce", + "size": 48173, + "subdir": "linux-64", + "timestamp": 1530918937189, + "version": "3.0.0" + }, + "hpack-3.0.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1e4ce619a486ff5a4bc64c5e72c31ad", + "name": "hpack", + "sha256": "f19f24458728c58c7a17375a3df092a3fb6b574d80f97bfb2554bed003e7239c", + "size": 48013, + "subdir": "linux-64", + "timestamp": 1530918966503, + "version": "3.0.0" + }, + "hsluv-5.0.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools >=38.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "32cfcb5ed4ff89fffc9bb77fe06b76bd", + "name": "hsluv", + "sha256": "2029ac1cddcf2571a4e496be53932e7c63970c66f6f5ac054f0a9e452aacf9ff", + "size": 14343, + "subdir": "linux-64", + "timestamp": 1670833721262, + "version": "5.0.3" + }, + "hsluv-5.0.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools >=38.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b96c100cb663c8bb05d4e152e83dfe4", + "name": "hsluv", + "sha256": "02f9bccb591d0bdd2bcaa887a6952601323864771311a3a73cd2b9d9d17208e9", + "size": 15641, + "subdir": "linux-64", + "timestamp": 1676839971908, + "version": "5.0.3" + }, + "hsluv-5.0.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools >=38.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "69b039c3ac31fba00c20c6f25a799920", + "name": "hsluv", + "sha256": "5d6d07903e79a1f646536f88a46a33c8bd9b9c001a04a09b1fc58fb2b0447ab6", + "size": 14151, + "subdir": "linux-64", + "timestamp": 1670833671060, + "version": "5.0.3" + }, + "hsluv-5.0.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools >=38.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "29346b91430b302db131bda828e60a73", + "name": "hsluv", + "sha256": "9aa028cf7cf7645226105323c403e53a49cdafbd2528b7e7d23c4414c2112928", + "size": 14239, + "subdir": "linux-64", + "timestamp": 1670833695707, + "version": "5.0.3" + }, + "hsluv-5.0.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools >=38.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4b7cfb61654db92971d24a99187b6072", + "name": "hsluv", + "sha256": "25c12e919609b68659aa007560ca3b9a9a6961fd25f514107042c90389e8181d", + "size": 14191, + "subdir": "linux-64", + "timestamp": 1670833646288, + "version": "5.0.3" + }, + "html5lib-0.999999999-py27hdf15f34_0.conda": { + "build": "py27hdf15f34_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "503617636597ac588a2a92310e63948a", + "name": "html5lib", + "sha256": "2ff1772e8c6a99f1da6697067b6a57aa315936eb143e119eaa9c99f3eafdfd6a", + "size": 190387, + "subdir": "linux-64", + "timestamp": 1505688715735, + "version": "0.999999999" + }, + "html5lib-0.999999999-py35h0543385_0.conda": { + "build": "py35h0543385_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "10a2f1a060ec4cf3c26a845250cf5084", + "name": "html5lib", + "sha256": "bdebee079a5eed3b475af0233a3e377f29b28241568e886394ccf7794e248670", + "size": 193397, + "subdir": "linux-64", + "timestamp": 1505688730339, + "version": "0.999999999" + }, + "html5lib-0.999999999-py36h2cfc398_0.conda": { + "build": "py36h2cfc398_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6fcda94e7b0017333e46e52c7b03a18", + "name": "html5lib", + "sha256": "948dbda7e9f14e1e2e659815ec8e878a8c0cc59738058724db7995028301e439", + "size": 186598, + "subdir": "linux-64", + "timestamp": 1505688745067, + "version": "0.999999999" + }, + "html5lib-1.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d472e4007036a028881ca77e5ca1aa51", + "name": "html5lib", + "sha256": "7ef22ff355c08c4042a3bd99b59d60ffb238b388cd9744ed1a56c888db067312", + "size": 196335, + "subdir": "linux-64", + "timestamp": 1530734173152, + "version": "1.0.1" + }, + "html5lib-1.0.1-py27h5233db4_0.conda": { + "build": "py27h5233db4_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d8e0d08b7efc5b467e1cd40888cea67", + "name": "html5lib", + "sha256": "a4acf3d445a73bf45a1d2cae4de2bcc3284be87ee7d5e30e203370af08eba679", + "size": 193616, + "subdir": "linux-64", + "timestamp": 1512923123581, + "version": "1.0.1" + }, + "html5lib-1.0.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12df9fb3bf45f79cb0bf6e3cc3fabc99", + "name": "html5lib", + "sha256": "b9593f8aae992cf504c0da3f062c7372970e2b0adeb8431e97fdd3ad903eb9c8", + "size": 197612, + "subdir": "linux-64", + "timestamp": 1534350881761, + "version": "1.0.1" + }, + "html5lib-1.0.1-py35h2f9c1c0_0.conda": { + "build": "py35h2f9c1c0_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11c6eb80cc075e52c045d0578e23d3c6", + "name": "html5lib", + "sha256": "2477a85d531cfe5186ece54547b3e5b07d4e8c4e799e405382913241464661be", + "size": 198546, + "subdir": "linux-64", + "timestamp": 1512923144145, + "version": "1.0.1" + }, + "html5lib-1.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "67faf9e699e454a4e43fca2a3414536c", + "name": "html5lib", + "sha256": "bd7080509a1dfe9aab90f15726acba4e5422fd3b573600841b518a1627f1dd67", + "size": 191257, + "subdir": "linux-64", + "timestamp": 1530734150784, + "version": "1.0.1" + }, + "html5lib-1.0.1-py36h2f9c1c0_0.conda": { + "build": "py36h2f9c1c0_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dea409c92c9cab919d07718cc13c9814", + "name": "html5lib", + "sha256": "c1b635fbb74ed1a0210cea07125b85100b3ac128748a376d3fc519ed40fb5bcb", + "size": 189825, + "subdir": "linux-64", + "timestamp": 1512923153402, + "version": "1.0.1" + }, + "html5lib-1.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9", + "webencodings" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b8916d9e43689ee94273fdd6a1328fc", + "name": "html5lib", + "sha256": "9df95ac787f6d4f0548e94a830cd5decdc9ea3ee390353cb21f1ff23cb366b07", + "size": 189926, + "subdir": "linux-64", + "timestamp": 1530734195767, + "version": "1.0.1" + }, + "htslib-1.6-h42e7767_0.conda": { + "build": "h42e7767_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "curl >=7.78.0,<8.0a0", + "libcurl", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "7efba13ecac9ce3eba026af8218f7323", + "name": "htslib", + "sha256": "1599fea6aeb786a9becf43e9008af8e4269e0f25eb4c95caf882d2823403e535", + "size": 962444, + "subdir": "linux-64", + "timestamp": 1636040051295, + "version": "1.6" + }, + "httpcore-0.15.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anyio 3.*", + "certifi", + "h11 >=0.11,<0.13", + "h2 >=3,<5", + "python >=3.10,<3.11.0a0", + "sniffio 1.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e39612f2367542f497aa77699dea191a", + "name": "httpcore", + "sha256": "eba71144dee6dcf2d2453e1a7b217519660bdf5e9f9a7a1bca254494bfdd4fd8", + "size": 76321, + "subdir": "linux-64", + "timestamp": 1659344330513, + "version": "0.15.0" + }, + "httpcore-0.15.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "anyio 3.*", + "certifi", + "h11 >=0.11,<0.13", + "h2 >=3,<5", + "python >=3.11,<3.12.0a0", + "sniffio 1.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2b8c8f1392f83e7daea5f8a992cffb1d", + "name": "httpcore", + "sha256": "97232fd433d61a3a7141045c2eb5a7ec458183a1b9e0b5fbd3ad5a014c8e385b", + "size": 100577, + "subdir": "linux-64", + "timestamp": 1676827896293, + "version": "0.15.0" + }, + "httpcore-0.15.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anyio 3.*", + "certifi", + "h11 >=0.11,<0.13", + "h2 >=3,<5", + "python >=3.7,<3.8.0a0", + "sniffio 1.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e0108c7e5b2e44e29af21afd64ec325", + "name": "httpcore", + "sha256": "99de413f5dca6d835e9b734456ae08f914c7e934911d712d9b8fc88a55eaf637", + "size": 73712, + "subdir": "linux-64", + "timestamp": 1659344217753, + "version": "0.15.0" + }, + "httpcore-0.15.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anyio 3.*", + "certifi", + "h11 >=0.11,<0.13", + "h2 >=3,<5", + "python >=3.8,<3.9.0a0", + "sniffio 1.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3b6dddb50991fff5f79b180c5a0b5223", + "name": "httpcore", + "sha256": "2e1aa4ac244c7b4f5e5ef38a927c67542107af5170a6d845f868a07f994179d7", + "size": 74063, + "subdir": "linux-64", + "timestamp": 1659344250620, + "version": "0.15.0" + }, + "httpcore-0.15.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anyio 3.*", + "certifi", + "h11 >=0.11,<0.13", + "h2 >=3,<5", + "python >=3.9,<3.10.0a0", + "sniffio 1.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "abf7e1442cf9a741a93b5d6b8b9b62f4", + "name": "httpcore", + "sha256": "d69f3819d76ebec62c86eaef59e0894b7000882b5ecb3564b21b1d9978f9acdc", + "size": 74378, + "subdir": "linux-64", + "timestamp": 1659344283013, + "version": "0.15.0" + }, + "httpretty-0.8.14-py27h160e1a8_1.conda": { + "build": "py27h160e1a8_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "cb100d1638e98a9d4ca78eca1a696654", + "name": "httpretty", + "sha256": "111c98e6edf26871f6fabb7bb4e58148c1a533f02b92c69ec94beca6f548b216", + "size": 36629, + "subdir": "linux-64", + "timestamp": 1509562627081, + "version": "0.8.14" + }, + "httpretty-0.8.14-py35h72974e7_1.conda": { + "build": "py35h72974e7_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "b570108229f7ea70d5e3729c7cfb468e", + "name": "httpretty", + "sha256": "dd503dcd0ed809cea48b3d22a58e395a12318f243aa9dd7c6be03a0beea0fe2f", + "size": 37211, + "subdir": "linux-64", + "timestamp": 1509562638096, + "version": "0.8.14" + }, + "httpretty-0.8.14-py36hb7a778b_1.conda": { + "build": "py36hb7a778b_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "814bd899e321339ebedb5431b384352d", + "name": "httpretty", + "sha256": "f36d53826aa1295c5262bd6c1af046ad70633e44e3236f2ce22eab6767bdcfdd", + "size": 36421, + "subdir": "linux-64", + "timestamp": 1509562614056, + "version": "0.8.14" + }, + "httpretty-0.9.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "d52d23ccba989c9e502fd6f78a65c5c8", + "name": "httpretty", + "sha256": "3021625f9af7bb472bfa58e369707676cab5603537acf46862877861b08ef1c0", + "size": 38081, + "subdir": "linux-64", + "timestamp": 1526409700432, + "version": "0.9.4" + }, + "httpretty-0.9.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "1632067ec70d5301d3b15c8c4733185d", + "name": "httpretty", + "sha256": "4b0e5eec8a89d1b3ead55d927c95ce9155035ffa773dcae938d0d947da74d5c0", + "size": 38593, + "subdir": "linux-64", + "timestamp": 1526409889020, + "version": "0.9.4" + }, + "httpretty-0.9.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "f443aa94bf79141f56caf569519541d9", + "name": "httpretty", + "sha256": "b5ad85dc916306e948121b305442b8b210f85031839c11cfcbceddaf138a27d2", + "size": 38315, + "subdir": "linux-64", + "timestamp": 1526409689237, + "version": "0.9.4" + }, + "httpretty-0.9.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "17f07d2665cc40740adb5afeb0b90d21", + "name": "httpretty", + "sha256": "d7966cb4e30b975aa781d51276771d58ac599a4a9807fcf94d0b8a2a80884bdb", + "size": 38191, + "subdir": "linux-64", + "timestamp": 1529444175654, + "version": "0.9.5" + }, + "httpretty-0.9.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "bd87ea5a1f179853c7fccf0078fe36bb", + "name": "httpretty", + "sha256": "8a40b90c93ff6f66f6ece5beb6179e8f34fd4d572e03b69fc1dad44a850d42d8", + "size": 38951, + "subdir": "linux-64", + "timestamp": 1529444190244, + "version": "0.9.5" + }, + "httpretty-0.9.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "2530690fb7d7bcb25798aa35191f1255", + "name": "httpretty", + "sha256": "4b2792de893bd657619bebe6be10835686e868d207468e27bb79e584db4d8817", + "size": 38110, + "subdir": "linux-64", + "timestamp": 1529444234638, + "version": "0.9.5" + }, + "httpretty-0.9.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "8f5c7409710c18ae23a7a08efbf27e62", + "name": "httpretty", + "sha256": "d74e24de3eaa77fe94cd609168dd07a3f44458371bfb3afaf5785cf96d0abe25", + "size": 38087, + "subdir": "linux-64", + "timestamp": 1530893175608, + "version": "0.9.5" + }, + "httpretty-0.9.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "f77022dd3fd632994e4f69f919ff237d", + "name": "httpretty", + "sha256": "96310ba8dfe52cb265daeb7528ee48c581809ab2f32e769bd737bab245f26959", + "size": 40037, + "subdir": "linux-64", + "timestamp": 1541435640584, + "version": "0.9.6" + }, + "httpretty-0.9.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "57e4a5900addffc1a583acdb8493a6a1", + "name": "httpretty", + "sha256": "aab46017fefc3a1942658d4ede090fc7da39d8485663f983a4fa830fed534f18", + "size": 40361, + "subdir": "linux-64", + "timestamp": 1541435640851, + "version": "0.9.6" + }, + "httpretty-0.9.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "f9bcdf13df5aa056c25b6095a619afcd", + "name": "httpretty", + "sha256": "ddc7db42a0f1c4face000a7f2061e99f60317cd96c6fc8e230b1f12078b8585f", + "size": 40328, + "subdir": "linux-64", + "timestamp": 1541435611067, + "version": "0.9.6" + }, + "httpretty-0.9.6-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "md5": "b1d0e7f74000fc3da1b553b871a4c96f", + "name": "httpretty", + "sha256": "fdc27109095e7be78300910b0e486dcd52f30b2d94129afc821a75ea629f8f2d", + "size": 40087, + "subdir": "linux-64", + "timestamp": 1573469597120, + "version": "0.9.6" + }, + "httpretty-0.9.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "23fc1cc4d65d96a695eefb839153d15c", + "name": "httpretty", + "sha256": "af2f3d675edded0c88642114407913ca69f4d22e4655d1dcb3a0d6fc3db2ad7a", + "size": 41926, + "subdir": "linux-64", + "timestamp": 1573965074851, + "version": "0.9.7" + }, + "httpretty-0.9.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "6e1cd4c29c308de7bec6a913f138ef57", + "name": "httpretty", + "sha256": "ca4c6391f9b3aeb2cce23943ed8444401099f4516e676d2edb1d9a03acf25575", + "size": 41833, + "subdir": "linux-64", + "timestamp": 1573965096679, + "version": "0.9.7" + }, + "httpretty-0.9.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "8cfa2600fe8df6660821ba677cb4fcd3", + "name": "httpretty", + "sha256": "134cb6132ed7bc22b9377998bb254215333f182f6b3d1302e9a6d37871d1e079", + "size": 41863, + "subdir": "linux-64", + "timestamp": 1573965079768, + "version": "0.9.7" + }, + "httpretty-0.9.7-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "md5": "6aed29f6d88c5758b94730161966539a", + "name": "httpretty", + "sha256": "48754ada67281d71875a30554231fa4756d5d8de198686271ea4346facc5dd2f", + "size": 42115, + "subdir": "linux-64", + "timestamp": 1573965115730, + "version": "0.9.7" + }, + "httptools-0.5.0-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "062a2164c7abd9fd32f0b8b514d2b157", + "name": "httptools", + "sha256": "3e065ac7aed2f94c01afa26981a79b0caf2cee22edb0cbf287c0940bbe270a2d", + "size": 129212, + "subdir": "linux-64", + "timestamp": 1677830227383, + "version": "0.5.0" + }, + "httptools-0.5.0-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a755ddd73789b5911c5a53bfe8bdef3", + "name": "httptools", + "sha256": "c14eecb4b0e863d119fd953aa32803ebb32e58a9aad3f8a3b29016b98c235dbf", + "size": 130529, + "subdir": "linux-64", + "timestamp": 1677830257645, + "version": "0.5.0" + }, + "httptools-0.5.0-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21d8a515d80f15315bfa717043b1cfc6", + "name": "httptools", + "sha256": "e61b141638164b68f204e86357975705941e4012485873e65491955961e6bb60", + "size": 129805, + "subdir": "linux-64", + "timestamp": 1677830287946, + "version": "0.5.0" + }, + "httpx-0.23.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "httpcore >=0.15.0,<0.16.0", + "idna", + "python >=3.10,<3.11.0a0", + "rfc3986 >=1.3,<2", + "sniffio" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "287341c3322e7c56000dd442160be0e4", + "name": "httpx", + "sha256": "dfebb3e31d5d6ec96a8e699f82dc0be41ff2525d94876eeb51ddb76610cdf5fe", + "size": 133078, + "subdir": "linux-64", + "timestamp": 1659460991688, + "version": "0.23.0" + }, + "httpx-0.23.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "httpcore >=0.15.0,<0.16.0", + "idna", + "python >=3.11,<3.12.0a0", + "rfc3986 >=1.3,<2", + "sniffio" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "abb359033a1ff9c7d59cc7f752ebb146", + "name": "httpx", + "sha256": "f45ff1918a99a90e05d0a5925c13e5890fddf637647dbb788209c717876b2235", + "size": 173780, + "subdir": "linux-64", + "timestamp": 1676830809742, + "version": "0.23.0" + }, + "httpx-0.23.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "httpcore >=0.15.0,<0.16.0", + "idna", + "python >=3.7,<3.8.0a0", + "rfc3986 >=1.3,<2", + "sniffio" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "09bf941703d8d7cbee8be1f0086221fa", + "name": "httpx", + "sha256": "b97548407081e980e1a8ffa8ec76a1d713f4956bfb2af1086aa91112890db961", + "size": 130417, + "subdir": "linux-64", + "timestamp": 1659460959466, + "version": "0.23.0" + }, + "httpx-0.23.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "httpcore >=0.15.0,<0.16.0", + "idna", + "python >=3.8,<3.9.0a0", + "rfc3986 >=1.3,<2", + "sniffio" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "69a107ae7d0ddae910c2ff326ae49845", + "name": "httpx", + "sha256": "9ef245568d74ed889ece557879852cc0dab96b839f557d42ef3f524bba08abf5", + "size": 130730, + "subdir": "linux-64", + "timestamp": 1659461013402, + "version": "0.23.0" + }, + "httpx-0.23.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "httpcore >=0.15.0,<0.16.0", + "idna", + "python >=3.9,<3.10.0a0", + "rfc3986 >=1.3,<2", + "sniffio" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88a2784b28fa8ca55ca31f49b6585b1f", + "name": "httpx", + "sha256": "f8255acac4872202c9836efaba3a9d277effc77293417122dd122f3742b9a36d", + "size": 131040, + "subdir": "linux-64", + "timestamp": 1659460937227, + "version": "0.23.0" + }, + "huggingface_accelerate-0.15.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.17", + "packaging >=20.0", + "psutil", + "python >=3.10,<3.11.0a0", + "pytorch >=1.4.0,<3", + "pyyaml" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "26d6406c2d331327ce8cd9f3df328ea8", + "name": "huggingface_accelerate", + "sha256": "8de6c7900002e4eb6f02dafe21018fd7592bbdcd3a2d66483a534176d9ba98e3", + "size": 259042, + "subdir": "linux-64", + "timestamp": 1670426367321, + "version": "0.15.0" + }, + "huggingface_accelerate-0.15.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "numpy >=1.17", + "packaging >=20.0", + "psutil", + "python >=3.7,<3.8.0a0", + "pytorch >=1.4.0,<3", + "pyyaml" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "80aef5eb8cd5df04c515a7b2f0351816", + "name": "huggingface_accelerate", + "sha256": "4e271a28d88f1238a8a46d105df44200d747810549ac4850dacff57f716289e1", + "size": 256039, + "subdir": "linux-64", + "timestamp": 1670426437730, + "version": "0.15.0" + }, + "huggingface_accelerate-0.15.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.17", + "packaging >=20.0", + "psutil", + "python >=3.8,<3.9.0a0", + "pytorch >=1.4.0,<3", + "pyyaml" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b1e096560712e6ca223a257efc3cba75", + "name": "huggingface_accelerate", + "sha256": "a84bbc0a0ada5a56f1455635f1be8db6f96c96b9b1e9da156442025dfde9e456", + "size": 256971, + "subdir": "linux-64", + "timestamp": 1670426401998, + "version": "0.15.0" + }, + "huggingface_accelerate-0.15.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.17", + "packaging >=20.0", + "psutil", + "python >=3.9,<3.10.0a0", + "pytorch >=1.4.0,<3", + "pyyaml" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3b9e1e997085e78ac85d6b48dc5d11cc", + "name": "huggingface_accelerate", + "sha256": "05d83cb983023da6cd869555340fd69a6fe631096ff528d7b424cf9401ac85e7", + "size": 256956, + "subdir": "linux-64", + "timestamp": 1670426329246, + "version": "0.15.0" + }, + "huggingface_hub-0.10.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "packaging >=20.9", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.1", + "requests", + "tqdm", + "typing-extensions >=3.7.4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9ef3ffed89c96934b7c51658a7c84b0a", + "name": "huggingface_hub", + "sha256": "628f3300571b39f710336ae78e8fcdb778f7a5fc65521df23b3dd0d63c8ebd7c", + "size": 220784, + "subdir": "linux-64", + "timestamp": 1667490303076, + "version": "0.10.1" + }, + "huggingface_hub-0.10.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "packaging >=20.9", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.1", + "requests", + "tqdm", + "typing-extensions >=3.7.4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "335a0f029b65b05e561617cf3356ce61", + "name": "huggingface_hub", + "sha256": "a7f75794bcded4e3a0eec1b5a5be14f8b7d2cec8c4a64c3d58c3a911a369a0dd", + "size": 268876, + "subdir": "linux-64", + "timestamp": 1676839986214, + "version": "0.10.1" + }, + "huggingface_hub-0.10.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "importlib-metadata", + "packaging >=20.9", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "requests", + "tqdm", + "typing-extensions >=3.7.4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0d8e9b5d27f05bc49f1cbc52e9f64479", + "name": "huggingface_hub", + "sha256": "c09c0a73bc4a4afc70061455e1f71ff569dd3b7f76ded57ee005a2d429b41e51", + "size": 216747, + "subdir": "linux-64", + "timestamp": 1667490359736, + "version": "0.10.1" + }, + "huggingface_hub-0.10.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "packaging >=20.9", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "requests", + "tqdm", + "typing-extensions >=3.7.4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0cb0c29aeffd1e80e3d253d97ede6c9e", + "name": "huggingface_hub", + "sha256": "2304abaea97d8fe14e854f2bf47b079b2ed214745c847cea2579dcf505cf9a23", + "size": 218627, + "subdir": "linux-64", + "timestamp": 1667490274356, + "version": "0.10.1" + }, + "huggingface_hub-0.10.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "packaging >=20.9", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "requests", + "tqdm", + "typing-extensions >=3.7.4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "81b1d15928ec161ca012ef4558751485", + "name": "huggingface_hub", + "sha256": "b4d795e3c18e194e9feea44c32310762873a1da88c82526a7c00696f1921d654", + "size": 218609, + "subdir": "linux-64", + "timestamp": 1667490331327, + "version": "0.10.1" + }, + "humanfriendly-10.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85b3166a8a99078e84da53f33f4ca69d", + "name": "humanfriendly", + "sha256": "b0dfcd10dabdcd9d3e9f660ccb503beaf047e7bd33a7833ca67599ffade52ab7", + "size": 120145, + "subdir": "linux-64", + "timestamp": 1640790909537, + "version": "10.0" + }, + "humanfriendly-10.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "282e19cbb5bd00171b3d4fdf64ce9aa1", + "name": "humanfriendly", + "sha256": "83f3683e069e9ec0d5375ded628da4e058f6728aef08fdb055400abfbadcb495", + "size": 127496, + "subdir": "linux-64", + "timestamp": 1668016418367, + "version": "10.0" + }, + "humanfriendly-10.0-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71a0507108f5df5dc054eb10bbe36449", + "name": "humanfriendly", + "sha256": "0f6ceb4d7b842172be612e61635e411cb795b2de3453c206c9b3e7092adcafd4", + "size": 151685, + "subdir": "linux-64", + "timestamp": 1676840001274, + "version": "10.0" + }, + "humanfriendly-10.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2e9b3c6e475d731fb43efae276c1260", + "name": "humanfriendly", + "sha256": "3617601d86c900aca35b0a9c972ea50fe7fd959f3c2b974e8c0380cfba0772ef", + "size": 116544, + "subdir": "linux-64", + "timestamp": 1639115593777, + "version": "10.0" + }, + "humanfriendly-10.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e60f327b4ec79a0fee7863886aebcef", + "name": "humanfriendly", + "sha256": "ec3778510e251a6479c2f0655723e7614ff2efe467263a5f1548666c27d9ec30", + "size": 125823, + "subdir": "linux-64", + "timestamp": 1668016444209, + "version": "10.0" + }, + "humanfriendly-10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "07c0416396c678aa2bae5377a592a8ef", + "name": "humanfriendly", + "sha256": "a7366cb803a0ab130f3ad767cc403db6147b17137db51fc491d3eaef003c9717", + "size": 116694, + "subdir": "linux-64", + "timestamp": 1639133712491, + "version": "10.0" + }, + "humanfriendly-10.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5889e1b3c138df45fc6aa82abc82b8e0", + "name": "humanfriendly", + "sha256": "691c9a2b6974c74f41cf600f3abec4905052c35246df826542bfa5bf0792dff0", + "size": 126014, + "subdir": "linux-64", + "timestamp": 1668016469555, + "version": "10.0" + }, + "humanfriendly-10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3bdf4e912e05b7df3988f519e183ebfe", + "name": "humanfriendly", + "sha256": "336b8ca2ef11256a8f03a885c38c6508a88c404cc7a8a8113669ff8c5e1a3c03", + "size": 116857, + "subdir": "linux-64", + "timestamp": 1639133710406, + "version": "10.0" + }, + "humanfriendly-10.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "65309cec8398cc4b1e8836ade3726ef8", + "name": "humanfriendly", + "sha256": "6e70ef6fd2d9b2033366bcc54043cafb65e6e867ca7d0261a2b5efff4a543245", + "size": 126654, + "subdir": "linux-64", + "timestamp": 1668016494682, + "version": "10.0" + }, + "humanfriendly-4.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "061a6f5b71a95555f6b440c35e5aea2f", + "name": "humanfriendly", + "sha256": "a8cf0696aebfe7ec26e69f03f41e9e0e8853731b342d269e0327d387db08fb40", + "size": 90652, + "subdir": "linux-64", + "timestamp": 1522786281171, + "version": "4.10" + }, + "humanfriendly-4.10-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "36b1f33e05a6c206eb5b27480dc212f1", + "name": "humanfriendly", + "sha256": "80bda93e89ab0c4069fc6e67d07fcfb2954c724433705d750a54cc4719f2b8b8", + "size": 90339, + "subdir": "linux-64", + "timestamp": 1522786283187, + "version": "4.10" + }, + "humanfriendly-4.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "06ab9c63589efe1cbf88b0ecdcf10713", + "name": "humanfriendly", + "sha256": "8bfbc8b826be9e4f67885c901bae0c9f6b50a40a04e3fa495100928222d74b79", + "size": 89768, + "subdir": "linux-64", + "timestamp": 1522786283715, + "version": "4.10" + }, + "humanfriendly-4.12.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "07cb511b7403ab8491f92767cc501aec", + "name": "humanfriendly", + "sha256": "607402c94974766af2e8e134c19caf58d089748d2af70de731e12b10ce27896a", + "size": 91839, + "subdir": "linux-64", + "timestamp": 1526938619897, + "version": "4.12.1" + }, + "humanfriendly-4.12.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "2e46453f3deb67500c21e3d65ae0b715", + "name": "humanfriendly", + "sha256": "e600d517e257d25924447459a35810eab52deab7a91c1a2e1ce5ca578853638c", + "size": 93401, + "subdir": "linux-64", + "timestamp": 1526938635504, + "version": "4.12.1" + }, + "humanfriendly-4.12.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "51192c6e9aa3682b700c104ce9ec1585", + "name": "humanfriendly", + "sha256": "550412355bf7aec8dafc342f8f7405cbd92792365da9c1bf03fb5314daee7b79", + "size": 90602, + "subdir": "linux-64", + "timestamp": 1526938595634, + "version": "4.12.1" + }, + "humanfriendly-4.12.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "049165f4419ed414d307cbe1911fd0e0", + "name": "humanfriendly", + "sha256": "0fd27fa4e1e69297f7d80cc0ae5156eeb4851126607ce126e6c8840ddeb329c7", + "size": 90299, + "subdir": "linux-64", + "timestamp": 1530811004931, + "version": "4.12.1" + }, + "humanfriendly-4.16.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "989256de2ba748db8404a128abcbf3ad", + "name": "humanfriendly", + "sha256": "c7b999aba7809a042e6ee725c310b64b43e7f38dbf30cf6294d2c19a8349194f", + "size": 97739, + "subdir": "linux-64", + "timestamp": 1535426943023, + "version": "4.16.1" + }, + "humanfriendly-4.16.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "bf1adc944b480211759a36bc2d484b58", + "name": "humanfriendly", + "sha256": "ce9eaab049d506f7ee19b9dce79c9e4f0605e0968e5743ca7613ec9ff74b070a", + "size": 101670, + "subdir": "linux-64", + "timestamp": 1535426843171, + "version": "4.16.1" + }, + "humanfriendly-4.16.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "5465e9288ae4f327b52aa64deb53947d", + "name": "humanfriendly", + "sha256": "cbb453734df72a867637d463fe497f704ad4f1cf451ed1a82c83aefd24cc62a2", + "size": 101051, + "subdir": "linux-64", + "timestamp": 1535426916759, + "version": "4.16.1" + }, + "humanfriendly-4.16.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "99a73b5b66fbe14fca5e6994e941dff4", + "name": "humanfriendly", + "sha256": "d879c407f4e8f707bab98b06529181c072b0a3d8cc9b071c815fb52f0b28cbb1", + "size": 100532, + "subdir": "linux-64", + "timestamp": 1535426957107, + "version": "4.16.1" + }, + "humanfriendly-4.17-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "51b6d9fddcad6a411733064302139008", + "name": "humanfriendly", + "sha256": "d3f8d1c5e28cf86e215e4b7d5b8a60c04a9aedb8421b39b5bfcb65e2b300aa9a", + "size": 102279, + "subdir": "linux-64", + "timestamp": 1540975880329, + "version": "4.17" + }, + "humanfriendly-4.17-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6348687e09cbefa4be76026d1cfebaba", + "name": "humanfriendly", + "sha256": "5ccc0c07e928f5e5221669edfa09b28913704df2be772c7714839e5ddc0d632d", + "size": 101130, + "subdir": "linux-64", + "timestamp": 1540975893907, + "version": "4.17" + }, + "humanfriendly-4.17-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b6970a3a777ae0b158103d22702878ac", + "name": "humanfriendly", + "sha256": "fe158cdd39878db7f0af8d908d65e8368df3627843b7a35cbda9061c5da579da", + "size": 103045, + "subdir": "linux-64", + "timestamp": 1540975904671, + "version": "4.17" + }, + "humanfriendly-4.18-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "a4c28575e4ef92e59e5fcee7e0acb833", + "name": "humanfriendly", + "sha256": "897e573a8758356da4ddf09149552988c5a4041c88bb4fb6042bc6acc129fc4c", + "size": 103887, + "subdir": "linux-64", + "timestamp": 1552378485425, + "version": "4.18" + }, + "humanfriendly-4.18-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7382d593621fedc7ef649df2e9a946ba", + "name": "humanfriendly", + "sha256": "c640e1f6a5cd2d11d70ec9a9a677ba60a44f9ddd3a11a86dbbe5b037067536b3", + "size": 106977, + "subdir": "linux-64", + "timestamp": 1552378551847, + "version": "4.18" + }, + "humanfriendly-4.18-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "31af532805c7852adc44e0454271ca13", + "name": "humanfriendly", + "sha256": "4959e0ec1d42559ecd8863e64507feb42e7df890026ca85873d5544f52088114", + "size": 106524, + "subdir": "linux-64", + "timestamp": 1552378495029, + "version": "4.18" + }, + "humanfriendly-4.18-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "d79082950f69289a1261473131033bdf", + "name": "humanfriendly", + "sha256": "423ee445caa4e4a5591d3e96c0da4c7c979813a5b39275b4bfea9a3dfc9e5460", + "size": 103879, + "subdir": "linux-64", + "timestamp": 1572512179816, + "version": "4.18" + }, + "humanfriendly-4.4-py27h983c27b_0.conda": { + "build": "py27h983c27b_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "8303c6ced709a6f5dd70fde9767e2cc8", + "name": "humanfriendly", + "sha256": "e775afe78a6ce7f361916fdb226d3bc91def09f98607283a68cb57940d4fdf97", + "size": 84024, + "subdir": "linux-64", + "timestamp": 1505741982496, + "version": "4.4" + }, + "humanfriendly-4.4-py35haa9438c_0.conda": { + "build": "py35haa9438c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "9c74227a92658939a07279c7a5be6f4d", + "name": "humanfriendly", + "sha256": "31a1bc1edfc54154e25862a2bfedb67ce30101fe0ba9c4978f0366154524f8ae", + "size": 83819, + "subdir": "linux-64", + "timestamp": 1505741994636, + "version": "4.4" + }, + "humanfriendly-4.4-py36h10ed9d1_0.conda": { + "build": "py36h10ed9d1_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "48e4b4c1a004c3fa175d8375c557b490", + "name": "humanfriendly", + "sha256": "26d9bc37a912b18c6476199f0280e74418c0e5b59430b4338c962b7c4f78b87e", + "size": 84818, + "subdir": "linux-64", + "timestamp": 1505742007077, + "version": "4.4" + }, + "humanfriendly-4.4.1-py27h1bea999_0.conda": { + "build": "py27h1bea999_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "70bee555d0cb84ce82c2cf018fd20b4a", + "name": "humanfriendly", + "sha256": "747159facf3471030153c2812fc1caf3cd00bf528578ffb52f1aa7fff316d5a6", + "size": 84731, + "subdir": "linux-64", + "timestamp": 1511968355291, + "version": "4.4.1" + }, + "humanfriendly-4.4.1-py35h457744f_0.conda": { + "build": "py35h457744f_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "4614509f26a4fd2d90353c9b4fe3897b", + "name": "humanfriendly", + "sha256": "01b3e5a8fff57278befee290849216578da55e6835f96acbbce0ac38d42d2d61", + "size": 86147, + "subdir": "linux-64", + "timestamp": 1511968363149, + "version": "4.4.1" + }, + "humanfriendly-4.4.1-py36h3cfbe1d_0.conda": { + "build": "py36h3cfbe1d_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1c0b288e8f509a62fc8fea6bf55a87b0", + "name": "humanfriendly", + "sha256": "a6383f3a91baa85e092fc4f7a774662aac2b95db4bea75428b426d338282b7aa", + "size": 85568, + "subdir": "linux-64", + "timestamp": 1511968331268, + "version": "4.4.1" + }, + "humanfriendly-4.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c01a653d0305f42f1e9bb9e60502f86d", + "name": "humanfriendly", + "sha256": "20c33b1f734356e91cd493983864d98dd852e2c11bab38de499c0f571ffe5c68", + "size": 87610, + "subdir": "linux-64", + "timestamp": 1519067753804, + "version": "4.8" + }, + "humanfriendly-4.8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "f65cc97ba630548988904600a9dac07c", + "name": "humanfriendly", + "sha256": "0d72e58e5d997c86ac8f3ee392be7d90bdeb62b6603c821aabff8a5439cf42ec", + "size": 89082, + "subdir": "linux-64", + "timestamp": 1519067792215, + "version": "4.8" + }, + "humanfriendly-4.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "5d7c95b940544f546c1cacc26509315f", + "name": "humanfriendly", + "sha256": "3e2bdc5903ee839baa9037103eab3d3d11339ede86535b2dd928bedc560c5161", + "size": 88446, + "subdir": "linux-64", + "timestamp": 1519067847073, + "version": "4.8" + }, + "humanfriendly-6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "04bc77aadbd8a28afb52deb3f94f6f54", + "name": "humanfriendly", + "sha256": "6229b3f86f539e6add76fd02a2f75b2a95443e42955120e0344d3f6638977cd9", + "size": 107468, + "subdir": "linux-64", + "timestamp": 1581539569493, + "version": "6.1" + }, + "humanfriendly-6.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "cd417419cd640be01b8a9f7ab8389ef4", + "name": "humanfriendly", + "sha256": "e746cc25c05183f9087d3620ee2d4a90221dd2e3b20e30424576e293a31dd3c5", + "size": 107145, + "subdir": "linux-64", + "timestamp": 1581539551763, + "version": "6.1" + }, + "humanfriendly-6.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "808635ebd7f1ff171e423eb53f5a89cb", + "name": "humanfriendly", + "sha256": "17c51c9a9ecdb29200df836343d384e6450a353a5727bf0b2234d4adb413bb0e", + "size": 109585, + "subdir": "linux-64", + "timestamp": 1581539535542, + "version": "6.1" + }, + "humanfriendly-8.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d66ec3eab28763586ce970b80967dc55", + "name": "humanfriendly", + "sha256": "6622e54e8f706a098518ef14553ae26e085f04d943b934b6fb533b7bab263d12", + "size": 121922, + "subdir": "linux-64", + "timestamp": 1592228480999, + "version": "8.2" + }, + "humanfriendly-8.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a0548fedb88f8a47f1ac42beaa40e00e", + "name": "humanfriendly", + "sha256": "3948ca4f5c7f6272c4fb3200613c506853de588a574fbc9c0595b70ea551d249", + "size": 117237, + "subdir": "linux-64", + "timestamp": 1588299943089, + "version": "8.2" + }, + "humanfriendly-8.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "cd39c06791523549dd39aaa1c286d99f", + "name": "humanfriendly", + "sha256": "48d88da78ba6bfd01229f6f2c761b601679472cf9c79b7594544ceb9727efa08", + "size": 122020, + "subdir": "linux-64", + "timestamp": 1592228463289, + "version": "8.2" + }, + "humanfriendly-9.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4b099a50eff025d13976cf5690e40a17", + "name": "humanfriendly", + "sha256": "364a81f3594c4c09407189f7884363de65fe262290c06f0d6f9564206830f11a", + "size": 119257, + "subdir": "linux-64", + "timestamp": 1607115555893, + "version": "9.0" + }, + "humanfriendly-9.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b5408b8ac49f5ff74b2d160c7be5dbea", + "name": "humanfriendly", + "sha256": "2a0c5eaffb579110dd7e5f5c46bc744a9ffb7c9e569c4e0f7c7e19ed0a4048ef", + "size": 118736, + "subdir": "linux-64", + "timestamp": 1607113876291, + "version": "9.0" + }, + "humanfriendly-9.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "c36c7beb8fd7d36fc66247ebe96c4e35", + "name": "humanfriendly", + "sha256": "467968d4638f65b3da5f2002e62d543e7d8c0b0d1d0ae325f027eebce8f6beff", + "size": 117034, + "subdir": "linux-64", + "timestamp": 1607115243981, + "version": "9.0" + }, + "humanfriendly-9.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "fa8b554ff0f2e52b89466692fc8b665f", + "name": "humanfriendly", + "sha256": "fd4b532bbad7dc38c39d33573eb2a3deb347455f4ab34db5175ce897ec6dd30f", + "size": 119165, + "subdir": "linux-64", + "timestamp": 1607113847032, + "version": "9.0" + }, + "humanfriendly-9.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e3b8e8d8ffb0eaa8f2d7554e442c8b0e", + "name": "humanfriendly", + "sha256": "714f10a8ea50d34deb8804d5bc8d2aaa9526fd0906a075ecf7c8933ddfe78d71", + "size": 117031, + "subdir": "linux-64", + "timestamp": 1607621766762, + "version": "9.1" + }, + "humanfriendly-9.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a5e306cf34158b403b28d0d28f889f09", + "name": "humanfriendly", + "sha256": "ec26ada1ed7479a0e6b674f39d572d33cde39a6b3060322c0fdcd7737e0eb32c", + "size": 116970, + "subdir": "linux-64", + "timestamp": 1607621804456, + "version": "9.1" + }, + "humanfriendly-9.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "cfee32f5752e97187eb2c1084bcf7e47", + "name": "humanfriendly", + "sha256": "4b9f8c923c2c96217d31ced53c6979127c1ae0364d754258ab336de52432330c", + "size": 117119, + "subdir": "linux-64", + "timestamp": 1607621748883, + "version": "9.1" + }, + "humanfriendly-9.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "396903e9bfbf08d9f61f40a26ed84cd1", + "name": "humanfriendly", + "sha256": "37e7f66928889443abc2f717d4e7e6974c6ddc599fa4eca65b7401892d592773", + "size": 117260, + "subdir": "linux-64", + "timestamp": 1607621786005, + "version": "9.1" + }, + "humanfriendly-9.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "226adbfda07a6c8a0ca1259632998f72", + "name": "humanfriendly", + "sha256": "51783753f1e576bc39ed336c8795146d6acef90daade31a296d9dfc152ed27f6", + "size": 119142, + "subdir": "linux-64", + "timestamp": 1623659455826, + "version": "9.2" + }, + "humanfriendly-9.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c34b2aaec8571c18fad0af2b46c4170", + "name": "humanfriendly", + "sha256": "52bd44b25221fa70d4db7d9ae2abcd969139224ca7b454cbbb2db4b248254cdd", + "size": 116369, + "subdir": "linux-64", + "timestamp": 1623653705270, + "version": "9.2" + }, + "humanfriendly-9.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d19fd615fa9b06d4cf2b6bd5c635806", + "name": "humanfriendly", + "sha256": "7e138aa8cfda0202f16a21ee29478d5bd6462aa1a78f3dbbcf17d5a173e8deb4", + "size": 118908, + "subdir": "linux-64", + "timestamp": 1623659088846, + "version": "9.2" + }, + "humanfriendly-9.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4123d045be2efe75fa52260f41939eba", + "name": "humanfriendly", + "sha256": "de3352354eba4c07ec9da28c21b2239d0c4c247759f84008f2256c326a5e519a", + "size": 118855, + "subdir": "linux-64", + "timestamp": 1623659453284, + "version": "9.2" + }, + "humanize-0.5.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "3aee8db740d080b8a9a69aba16a90097", + "name": "humanize", + "sha256": "4eb59c87bf949bfbe3e22ba1c42e7f0da09083b104e32453b7d82a5459937296", + "size": 21357, + "subdir": "linux-64", + "timestamp": 1537198295974, + "version": "0.5.1" + }, + "humanize-0.5.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "1dea7afa7d36b3baffeb20d2cc917469", + "name": "humanize", + "sha256": "75bcff31793afc1e0e21db5ed1531166304386255a6c1662747d503f6f0347f5", + "size": 21604, + "subdir": "linux-64", + "timestamp": 1537198319570, + "version": "0.5.1" + }, + "humanize-0.5.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "40baa42c089caa5b5f1207b468f00e55", + "name": "humanize", + "sha256": "88c5236b34920b904ee00577f29860f5bcdf12bb35cab454869982574beebeb9", + "size": 21341, + "subdir": "linux-64", + "timestamp": 1537198325242, + "version": "0.5.1" + }, + "humanize-0.5.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7583edcc9d12e761035f5cba10b59b6c", + "name": "humanize", + "sha256": "6d7ab57f47698343283a61b7b6e8c5f6fe2b73dcde51ea560dc7eb906983dbb5", + "size": 21218, + "subdir": "linux-64", + "timestamp": 1537198273544, + "version": "0.5.1" + }, + "hupper-1.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d01469db58dd771d179e5fb9c550832", + "name": "hupper", + "sha256": "25a9d66dd6f765ec7e7fac4da13fd434d0c71365d2b17ccd5a31154c4b9b00f1", + "size": 35501, + "subdir": "linux-64", + "timestamp": 1530025359547, + "version": "1.3" + }, + "hupper-1.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dade97e46aa0e1752e45a1fc40c4db60", + "name": "hupper", + "sha256": "0646cd71d362706d042656077b5b48029c2c0cfbda4f018d83e1713038380f90", + "size": 36352, + "subdir": "linux-64", + "timestamp": 1530025641209, + "version": "1.3" + }, + "hupper-1.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b520fdefa43e53f16d7ff9d0eb03a6a7", + "name": "hupper", + "sha256": "2ef92e9cc2ce039eade5c2057186e43b3b0bad1c95d363cb03b0be2c5b054f2b", + "size": 35687, + "subdir": "linux-64", + "timestamp": 1530025499493, + "version": "1.3" + }, + "hupper-1.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "975b5954e842f2d828045ed4413d46ef", + "name": "hupper", + "sha256": "7c45b54618e896a864eca7df8a9db3bbe31496dfb66e27e66f0c09fd69824f27", + "size": 35892, + "subdir": "linux-64", + "timestamp": 1530875173823, + "version": "1.3" + }, + "hupper-1.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0005d8f033e7561f47891bf9ae2fc48f", + "name": "hupper", + "sha256": "65cd220eda6ab55a4c6ed15a9ddf37f604c422d2a5a8c438679ed3be59fb6971", + "size": 36384, + "subdir": "linux-64", + "timestamp": 1539657522728, + "version": "1.3.1" + }, + "hupper-1.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f55348c88b8f8e4c7a5e13dd28ca97cb", + "name": "hupper", + "sha256": "c3dce856cfcf50848f5a84e81813edcdf1d4c1a8322f0311a3d7fc92a37737f8", + "size": 36543, + "subdir": "linux-64", + "timestamp": 1539657533648, + "version": "1.3.1" + }, + "hupper-1.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "575705f420a6ba73c7baa76bf7e3fa85", + "name": "hupper", + "sha256": "a1ac4028b849f7f6d2794ae21df24ed0c0c28b1877900f501238eed27ef62755", + "size": 36448, + "subdir": "linux-64", + "timestamp": 1539657545370, + "version": "1.3.1" + }, + "hupper-1.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0178e593588eb21a919db9693611912", + "name": "hupper", + "sha256": "5f39abf0bdcc884d267f48cc0ada7e0d01c704e6cda286c4b76c48328e69047e", + "size": 37275, + "subdir": "linux-64", + "timestamp": 1540977811524, + "version": "1.4" + }, + "hupper-1.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "06c2c3042e3a427c747e2cbed82c95b0", + "name": "hupper", + "sha256": "df083e6ded699e92f232735a98cdf68829d4ad7f41a710fecddc925ba5401b77", + "size": 37328, + "subdir": "linux-64", + "timestamp": 1540977846085, + "version": "1.4" + }, + "hupper-1.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d974c51c537964d6fe95f6103693c472", + "name": "hupper", + "sha256": "4bc56a0b908ddeb110f676976a436a8815576ec2ac20c051c81d55a6215bce20", + "size": 37645, + "subdir": "linux-64", + "timestamp": 1540977794160, + "version": "1.4" + }, + "hupper-1.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7645b9d13b021f36bbf0e6dc2d6e07e5", + "name": "hupper", + "sha256": "de153140aed9f4b6554a44389083705b9454211317e4b452e6de0c4b8f95bee6", + "size": 37363, + "subdir": "linux-64", + "timestamp": 1542079701270, + "version": "1.4.1" + }, + "hupper-1.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "75e4a28ffee2fffbab04702585099e89", + "name": "hupper", + "sha256": "86edd56636d239466450915b6af0ac051e4e0e148afe533d6086b6627eecfe52", + "size": 37589, + "subdir": "linux-64", + "timestamp": 1542079707290, + "version": "1.4.1" + }, + "hupper-1.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c551ab0863fe1b7b4d7cc2fd9f6bf626", + "name": "hupper", + "sha256": "4842c4ddd15b3ac1b68061b9c5faa5ed5f1846ad8c5e56842fa9e11c28f94bf1", + "size": 37485, + "subdir": "linux-64", + "timestamp": 1542079709116, + "version": "1.4.1" + }, + "hupper-1.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c6d7d93128669559384417079ab31741", + "name": "hupper", + "sha256": "b12d5bcc4a814130aee34fcc896172501a5c9ed25a3e49e2bbc3a7ada3a95cc3", + "size": 37527, + "subdir": "linux-64", + "timestamp": 1545131308305, + "version": "1.4.2" + }, + "hupper-1.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a2701399f8e165e28b16441724dc828", + "name": "hupper", + "sha256": "e34f0cdfc3079338848e7caadae7a42c94dcff9a749294c72fc30e985b1d5b15", + "size": 37577, + "subdir": "linux-64", + "timestamp": 1545131346048, + "version": "1.4.2" + }, + "hupper-1.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ea17bbe530f370f0113f25ef6353ab1", + "name": "hupper", + "sha256": "a4a186d69c35c9498cb2da9143614e26879dccbfbc84b1f6e0f15589b818b842", + "size": 37655, + "subdir": "linux-64", + "timestamp": 1545131383050, + "version": "1.4.2" + }, + "hupper-1.6.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a1f65f8a9653f0ef8bdc786937e7217", + "name": "hupper", + "sha256": "06e4266a90b5da3cbf78205a67576243c0192aa9116169496f0f0bb7e753cd28", + "size": 192759, + "subdir": "linux-64", + "timestamp": 1552435922979, + "version": "1.6.1" + }, + "hupper-1.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b2658064a4681af0e4c82fcfc10ae9b", + "name": "hupper", + "sha256": "24c6f1865273d489a148508dcf7b08f9d4ccca80a20be61d344d36e1cd9794c2", + "size": 192894, + "subdir": "linux-64", + "timestamp": 1552435937344, + "version": "1.6.1" + }, + "hupper-1.6.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6bf44bf16df06ecbbd5deab6a26b3003", + "name": "hupper", + "sha256": "0afec4ddc8191a2d5dbbec66e13fd081a0484cf188b1cc05d6a3ed05c8759d19", + "size": 193852, + "subdir": "linux-64", + "timestamp": 1552435944248, + "version": "1.6.1" + }, + "hupper-1.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4115686bdccdb9e9c71728dd8ae009e4", + "name": "hupper", + "sha256": "1539e50d130f9254bc93bd76078ecfe51e6de4e81a29fe4c0d1299f05267cb0b", + "size": 200992, + "subdir": "linux-64", + "timestamp": 1564680578077, + "version": "1.8.1" + }, + "hupper-1.8.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "539632bb660da3176333ffe890dfafc7", + "name": "hupper", + "sha256": "2c4af7ec9ce571ef3b915670605ccac74a9d358b6d751279cee8a90c47d4a5b4", + "size": 42235, + "subdir": "linux-64", + "timestamp": 1640790928246, + "version": "1.8.1" + }, + "hupper-1.8.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "102e95e2b91728dfb6b307a8be0f992d", + "name": "hupper", + "sha256": "a58a8d0f42723730d835e7be70bd84d7a0f8b1d8d1a8ab99c790781162254efc", + "size": 52867, + "subdir": "linux-64", + "timestamp": 1676904110273, + "version": "1.8.1" + }, + "hupper-1.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "278a4ce2df9a5a125aab449f7428f329", + "name": "hupper", + "sha256": "47757955ce6e2763ec27f358ad2beb21d724dda04ca07f6f4a3a589f503e7b3d", + "size": 202387, + "subdir": "linux-64", + "timestamp": 1564680865940, + "version": "1.8.1" + }, + "hupper-1.8.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "10a518eb7413ca4bb12aed8256a7b905", + "name": "hupper", + "sha256": "45d0fecf83a243353f0b206bfd8450ddee3a213a2a4bd08bacadce00c6bd00bd", + "size": 202249, + "subdir": "linux-64", + "timestamp": 1564680747045, + "version": "1.8.1" + }, + "hupper-1.8.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6096f0b3a53e4e868edb39759598f57", + "name": "hupper", + "sha256": "f744c5096ea0cb97d80e45b51aa1a4555f88d9c4797fec3cf84c7e75d3d46b8e", + "size": 41803, + "subdir": "linux-64", + "timestamp": 1572357239256, + "version": "1.8.1" + }, + "hvplot-0.8.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.0.0", + "colorcet >=2", + "holoviews >=1.12.0", + "numpy >=1.15", + "packaging", + "pandas", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e26c644b3576710252771ee573b233f4", + "name": "hvplot", + "sha256": "e3332ff5994d8faf0e76f14aa4b37840010f0a9bfd3157952c82f70e0bc32ddd", + "size": 3149412, + "subdir": "linux-64", + "timestamp": 1659026563609, + "version": "0.8.0" + }, + "hvplot-0.8.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.0.0", + "colorcet >=2", + "holoviews >=1.12.0", + "numpy >=1.15", + "packaging", + "pandas", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "36abed1f97717e4a2df1bbf8cb04f2ac", + "name": "hvplot", + "sha256": "8c34615c5ab354e6d14b27d6923263228f7873e75f65e34aead001f0f6054864", + "size": 3147140, + "subdir": "linux-64", + "timestamp": 1659026643259, + "version": "0.8.0" + }, + "hvplot-0.8.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.0.0", + "colorcet >=2", + "holoviews >=1.12.0", + "numpy >=1.15", + "packaging", + "pandas", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "68cb25ce876b44e8c1625cd7aae098f7", + "name": "hvplot", + "sha256": "3072810fd1b7b33f7407ac72fbccf8c4ae3561daf2dc9e05095cc513d532340d", + "size": 3148497, + "subdir": "linux-64", + "timestamp": 1659026784479, + "version": "0.8.0" + }, + "hvplot-0.8.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=2.0.0", + "colorcet >=2", + "holoviews >=1.12.0", + "numpy >=1.15", + "packaging", + "pandas", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c8c78d190873f727346b188cb1990d06", + "name": "hvplot", + "sha256": "63d05d06736082947bdf4dcc44c9557162a8734594bf326dbdaf711369f2495f", + "size": 3147400, + "subdir": "linux-64", + "timestamp": 1659026715322, + "version": "0.8.0" + }, + "hvplot-0.8.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=1.0.0", + "colorcet >=2", + "holoviews >=1.11.0", + "numpy >=1.15", + "packaging", + "pandas", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b94341bd4c302b061507b787f1e59913", + "name": "hvplot", + "sha256": "d6d4ae4ce1ae4566586b205168cdc5f9bae237a7a46e4422c1b15f0a59707b3b", + "size": 3227177, + "subdir": "linux-64", + "timestamp": 1668767226780, + "version": "0.8.1" + }, + "hvplot-0.8.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=1.0.0", + "colorcet >=2", + "holoviews >=1.11.0", + "numpy >=1.15", + "packaging", + "pandas", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c1a5df165d617b8f532951f9a945d945", + "name": "hvplot", + "sha256": "60f412daf8410aa5f5331bade21b92cc0ecfe98b38d79edc29c0bda31e51dfbb", + "size": 3225503, + "subdir": "linux-64", + "timestamp": 1668767162094, + "version": "0.8.1" + }, + "hvplot-0.8.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=1.0.0", + "colorcet >=2", + "holoviews >=1.11.0", + "numpy >=1.15", + "packaging", + "pandas", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "82d0baecccd21a41b3b2beca6a0215ae", + "name": "hvplot", + "sha256": "da6401a3841da72413ebeba32eca996d2905bc7fd4fe04edffcf8720348768ab", + "size": 3226930, + "subdir": "linux-64", + "timestamp": 1668767351132, + "version": "0.8.1" + }, + "hvplot-0.8.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=1.0.0", + "colorcet >=2", + "holoviews >=1.11.0", + "numpy >=1.15", + "packaging", + "pandas", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0370438230dd4abd1fc756453a80a9a7", + "name": "hvplot", + "sha256": "5cfca73f61d21c4b238a344d0cda63f3e99082a10daae45531383a9292ea79a2", + "size": 3225919, + "subdir": "linux-64", + "timestamp": 1668767287275, + "version": "0.8.1" + }, + "hvplot-0.8.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=1.0.0", + "colorcet >=2", + "holoviews >=1.11.0", + "numpy >=1.15", + "packaging", + "pandas", + "panel >=0.11.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b4b5996ffcadd914152c1562cbd30d9a", + "name": "hvplot", + "sha256": "3edd0a69c96ec3041de3ef45ca68bc72cf095c5c7b412830ecb4f86c2d7de468", + "size": 3227290, + "subdir": "linux-64", + "timestamp": 1670509148333, + "version": "0.8.2" + }, + "hvplot-0.8.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=1.0.0", + "colorcet >=2", + "holoviews >=1.11.0", + "numpy >=1.15", + "packaging", + "pandas", + "panel >=0.11.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1d8cb029dc28415df93e568156dc683b", + "name": "hvplot", + "sha256": "2c49bbc824d8d6e20559e609180506e6293ff3f52b8d695966d2128e030709db", + "size": 3257132, + "subdir": "linux-64", + "timestamp": 1676852704821, + "version": "0.8.2" + }, + "hvplot-0.8.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=1.0.0", + "colorcet >=2", + "holoviews >=1.11.0", + "numpy >=1.15", + "packaging", + "pandas", + "panel >=0.11.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "426c7cf4305909baffa198727ea0fad5", + "name": "hvplot", + "sha256": "5404233e7c457c8d6822cd837f34aad541840160de1ad94986a024cfbabdec57", + "size": 3224695, + "subdir": "linux-64", + "timestamp": 1670509087218, + "version": "0.8.2" + }, + "hvplot-0.8.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=1.0.0", + "colorcet >=2", + "holoviews >=1.11.0", + "numpy >=1.15", + "packaging", + "pandas", + "panel >=0.11.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6a918d22f35268bc0e5f18ad1fc1601a", + "name": "hvplot", + "sha256": "171152d8cbfdc4155f4cd3f5515954c9d44328929ccd4603a4bfea3c73ae3948", + "size": 3225353, + "subdir": "linux-64", + "timestamp": 1670509023118, + "version": "0.8.2" + }, + "hvplot-0.8.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bokeh >=1.0.0", + "colorcet >=2", + "holoviews >=1.11.0", + "numpy >=1.15", + "packaging", + "pandas", + "panel >=0.11.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f23a1da395ac5007d3075613929b230c", + "name": "hvplot", + "sha256": "170e3eacf4baa235f34c3ee2862ab3b5bf4711bb5f86cf144119c26220e08918", + "size": 3227205, + "subdir": "linux-64", + "timestamp": 1670508954130, + "version": "0.8.2" + }, + "hyperframe-5.1.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f60084adc0012f4fa3814f16ebd69bbb", + "name": "hyperframe", + "sha256": "0509cac5eada7a839cd1246bab54602c76d98c37df4de35915637f8adbf2f2a9", + "size": 21220, + "subdir": "linux-64", + "timestamp": 1530919078388, + "version": "5.1.0" + }, + "hyperframe-5.1.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d900bf19bd2e7e6f6f6fa289b572367", + "name": "hyperframe", + "sha256": "77f6995d418f9c2ec28a50678b5e896ef710aae86454348d9367440849e50786", + "size": 21604, + "subdir": "linux-64", + "timestamp": 1530919022683, + "version": "5.1.0" + }, + "hyperframe-5.1.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "27f1bdb72803446b808049a3907c1684", + "name": "hyperframe", + "sha256": "2d8bae595cfd7da35b000bbf9972885e20257c1a4a4a34137e092ffdca1293d7", + "size": 21688, + "subdir": "linux-64", + "timestamp": 1530919050918, + "version": "5.1.0" + }, + "hyperlink-18.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "idna >=2.5", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eea10c31bbd0bfc20280d90489fd8c44", + "name": "hyperlink", + "sha256": "fea5995d1a5a8c0c402534a7e8214e0bec4bb7917841c7cf83c8e0ea81708440", + "size": 61812, + "subdir": "linux-64", + "timestamp": 1519671840987, + "version": "18.0.0" + }, + "hyperlink-18.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "idna >=2.5", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c9e7a75edbc336338290721156944dca", + "name": "hyperlink", + "sha256": "676817f84746a8d028c1917fb907eae4d5b38afc232fd23a51f2c211646e3c9e", + "size": 64412, + "subdir": "linux-64", + "timestamp": 1519671861383, + "version": "18.0.0" + }, + "hyperlink-18.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "idna >=2.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3fa9dbf28ce753aaae6207cf82a270f0", + "name": "hyperlink", + "sha256": "9343570d3d9fa6bb00c16c9fc63bf79e41b3f23aa1fee57f561bbbe7d157167b", + "size": 63488, + "subdir": "linux-64", + "timestamp": 1519671858639, + "version": "18.0.0" + }, + "hyperlink-18.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "idna >=2.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8dc37b23d9e51ae466c17794d4d3c2fc", + "name": "hyperlink", + "sha256": "09b1b85fd94db9b480e47c8968fd563403ace3adbc2be40ec21acec0c2d379e8", + "size": 61840, + "subdir": "linux-64", + "timestamp": 1530893205250, + "version": "18.0.0" + }, + "hypothesis-3.23.0-py27hb9bf4c2_0.conda": { + "build": "py27hb9bf4c2_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "md5": "361f56d1ab987defba0896683e5e5e90", + "name": "hypothesis", + "sha256": "210dd6e8f096a6a37d41ee35922b9c917e7f7148305d3a89ce0a4d21fff0e966", + "size": 196800, + "subdir": "linux-64", + "timestamp": 1505691802242, + "version": "3.23.0" + }, + "hypothesis-3.23.0-py35h5ac4e47_0.conda": { + "build": "py35h5ac4e47_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "md5": "8812812e060696bc843c112580d1ce14", + "name": "hypothesis", + "sha256": "2bd6cb9051c5f68ec86ccd6bd458e8da0f92659d282c2c95198f318fd9260ee9", + "size": 200063, + "subdir": "linux-64", + "timestamp": 1505691817549, + "version": "3.23.0" + }, + "hypothesis-3.23.0-py36h6c998d5_0.conda": { + "build": "py36h6c998d5_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "md5": "ba7d6b4b2363c87f22690ca174bb058a", + "name": "hypothesis", + "sha256": "a67245c9adb06b0dcac3a383fb2e163afc5698c6d05b968f9ec5a8136330b6af", + "size": 197970, + "subdir": "linux-64", + "timestamp": 1505691832947, + "version": "3.23.0" + }, + "hypothesis-3.37.0-py27h1e90009_1.conda": { + "build": "py27h1e90009_1", + "build_number": 1, + "depends": [ + "attrs", + "coverage", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "md5": "c7158c7b34a00046d86f8d7c92c9e961", + "name": "hypothesis", + "sha256": "7cfeb0354b91a6606596e3eee96155f11ad0bbab4984aa996f25675f9b712e79", + "size": 229367, + "subdir": "linux-64", + "timestamp": 1510987883998, + "version": "3.37.0" + }, + "hypothesis-3.37.0-py35h38301bd_1.conda": { + "build": "py35h38301bd_1", + "build_number": 1, + "depends": [ + "attrs", + "coverage", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "md5": "83c1d1676064c5498c5b232018af41e3", + "name": "hypothesis", + "sha256": "bccb903847d6de2e77a4b0bf31a8b42ac418fae61e5f78f99f47d08c488ab8dd", + "size": 233438, + "subdir": "linux-64", + "timestamp": 1510987891417, + "version": "3.37.0" + }, + "hypothesis-3.37.0-py36hefa9d8b_1.conda": { + "build": "py36hefa9d8b_1", + "build_number": 1, + "depends": [ + "attrs", + "coverage", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "md5": "547ad542607b29c5695f497f186cf0ce", + "name": "hypothesis", + "sha256": "08cc1a180c6b716bb2feb0b29a85f4895ba4af829f1671079763e63228d564a0", + "size": 233364, + "subdir": "linux-64", + "timestamp": 1510987891706, + "version": "3.37.0" + }, + "hypothesis-3.38.5-py27h2236425_0.conda": { + "build": "py27h2236425_0", + "build_number": 0, + "depends": [ + "attrs", + "coverage", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "b8733ca32899a8c52c3a1092f2ce87d8", + "name": "hypothesis", + "sha256": "6f1bcec70281ae1e890cd49f8b42dcba443b3702189601152a65ee3639ab5e89", + "size": 232578, + "subdir": "linux-64", + "timestamp": 1511884077080, + "version": "3.38.5" + }, + "hypothesis-3.38.5-py35h785bf34_0.conda": { + "build": "py35h785bf34_0", + "build_number": 0, + "depends": [ + "attrs", + "coverage", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "8db4ed2d6c7894d0a108c1dc134c2f5d", + "name": "hypothesis", + "sha256": "f3c0dca741a4457a19c5005427c66c9d0d3c9447ac610ceccd557c3b7a591582", + "size": 236657, + "subdir": "linux-64", + "timestamp": 1511884082425, + "version": "3.38.5" + }, + "hypothesis-3.38.5-py36h196a6cc_0.conda": { + "build": "py36h196a6cc_0", + "build_number": 0, + "depends": [ + "attrs", + "coverage", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "0c4018d3b387f0e62cb492e534d9c897", + "name": "hypothesis", + "sha256": "8a6f90ee11f9a4d14f7b2506865f02e1b8e8c62a54a89da14dc9b01b7957be19", + "size": 231288, + "subdir": "linux-64", + "timestamp": 1511884082940, + "version": "3.38.5" + }, + "hypothesis-3.46.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "attrs", + "coverage", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "a077cfb20538ba5a230d1dbbcd7a47a8", + "name": "hypothesis", + "sha256": "d7b5b7571167e4b255107938f118a19ad3ecae2f656cde4e4c1d44e17c9c0f2a", + "size": 255616, + "subdir": "linux-64", + "timestamp": 1519762048955, + "version": "3.46.0" + }, + "hypothesis-3.46.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "attrs", + "coverage", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "d32fe23b855c8b846dadf05c08112eda", + "name": "hypothesis", + "sha256": "74eb451600f13c9c5c60d8fa2ac95f3ecd7b62cf17c4aa82353e3dca7bffa6de", + "size": 260405, + "subdir": "linux-64", + "timestamp": 1519762166207, + "version": "3.46.0" + }, + "hypothesis-3.46.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "attrs", + "coverage", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "3d3d4aac285f6e99321b0a141b94ccab", + "name": "hypothesis", + "sha256": "7421811ee6f89eee3cd4d7bd0024e3be7e7fb5adef1de493a1d6fed4c8d0f1e2", + "size": 257409, + "subdir": "linux-64", + "timestamp": 1519762067548, + "version": "3.46.0" + }, + "hypothesis-3.52.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "e7e719862a8a1f8d12ac5212a3a9079f", + "name": "hypothesis", + "sha256": "120bf8c3d93a6f3becc21ad2fff45c78b847a37204b2d8883362c9a0b3517cb2", + "size": 256866, + "subdir": "linux-64", + "timestamp": 1522004075530, + "version": "3.52.0" + }, + "hypothesis-3.52.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "9c53328bed5d119fe080f2ef39990ea0", + "name": "hypothesis", + "sha256": "2c75fe3669afed8635725788df2bf918cb09ffd039338abfe98c0628d831c47f", + "size": 261213, + "subdir": "linux-64", + "timestamp": 1522004154088, + "version": "3.52.0" + }, + "hypothesis-3.52.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "7744696476c3b3e973367415114ac0e1", + "name": "hypothesis", + "sha256": "f7207de63f39f8830206caae5c3cb23b48229589f453303a4c647f24595a4a8d", + "size": 262367, + "subdir": "linux-64", + "timestamp": 1522004156571, + "version": "3.52.0" + }, + "hypothesis-3.53.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "30590e716c7b72db9922090bc5097898", + "name": "hypothesis", + "sha256": "1c08eb2add1e7a6653286920fab463f63432f52bd718e999968c14855615b38f", + "size": 260182, + "subdir": "linux-64", + "timestamp": 1522785051437, + "version": "3.53.0" + }, + "hypothesis-3.53.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "6a1a8e4f12552bff59408c9e1f49ab18", + "name": "hypothesis", + "sha256": "4c059d867d6ffaa188b518b029dac4df613a0b3200a16daec354545dad9e3bd4", + "size": 265087, + "subdir": "linux-64", + "timestamp": 1522785064928, + "version": "3.53.0" + }, + "hypothesis-3.53.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "e12f1b93af53f47419e25e212aa2a7c5", + "name": "hypothesis", + "sha256": "b6bfe0ef06f53ea1c35ecadaa6773dbe29b13c3339ce0c000df9cbd3f878bc6c", + "size": 262259, + "subdir": "linux-64", + "timestamp": 1522785049307, + "version": "3.53.0" + }, + "hypothesis-3.56.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "e8988604b76f8dd7782da1307e836afb", + "name": "hypothesis", + "sha256": "0302b8e5d63e07dd684fd5b854d50093ffa566d9a4dfb811151c1dcd50d0be8b", + "size": 259832, + "subdir": "linux-64", + "timestamp": 1524083370341, + "version": "3.56.0" + }, + "hypothesis-3.56.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "cc755f7cf6ead2a48ac0aa885769ce7b", + "name": "hypothesis", + "sha256": "4079b320b03eed156bbe29458d5321fb3daa34bc3209f0ec9db33fcc20c9fddd", + "size": 267852, + "subdir": "linux-64", + "timestamp": 1524083395650, + "version": "3.56.0" + }, + "hypothesis-3.56.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "91a9e242f73b5e268e3f2a936cd91f1a", + "name": "hypothesis", + "sha256": "fa6693bd62fc7b2744d81f64ff077736eb2340c443757c63b787bf756e5f36a8", + "size": 264929, + "subdir": "linux-64", + "timestamp": 1524083315568, + "version": "3.56.0" + }, + "hypothesis-3.57.0-py27h24bf2e0_0.conda": { + "build": "py27h24bf2e0_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "cbe571df3f18f01b2cf7921a7d0946e3", + "name": "hypothesis", + "sha256": "6e6a21ab50e52c132692fb687ae5fc357b36b8928057b8aa2dcb7fa830ac7a0b", + "size": 263169, + "subdir": "linux-64", + "timestamp": 1527702543749, + "version": "3.57.0" + }, + "hypothesis-3.57.0-py35h24bf2e0_0.conda": { + "build": "py35h24bf2e0_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "67d0e234d79d32845d6b1f4dd696b0db", + "name": "hypothesis", + "sha256": "74d8be378e90e2b4a9fa4519d35857506028842706569aaa9cdfba96284b50a1", + "size": 266578, + "subdir": "linux-64", + "timestamp": 1527702573924, + "version": "3.57.0" + }, + "hypothesis-3.57.0-py36h24bf2e0_0.conda": { + "build": "py36h24bf2e0_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "deb26df0c4e75386ee8c5193fb5e1f1e", + "name": "hypothesis", + "sha256": "b9acc5330fe72649c47c60654f45ef275daab349f19b4bc6b0727e371a444cb4", + "size": 263894, + "subdir": "linux-64", + "timestamp": 1527702461706, + "version": "3.57.0" + }, + "hypothesis-3.59.1-py27h39e3cac_0.conda": { + "build": "py27h39e3cac_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "da2a1d2b1a14b9176592b916ce5ba6b8", + "name": "hypothesis", + "sha256": "cf0426ced7b4393236b361db7b51c022e9ce64aca2a8d33fc95e6b7eb18beb22", + "size": 368665, + "subdir": "linux-64", + "timestamp": 1530729834378, + "version": "3.59.1" + }, + "hypothesis-3.59.1-py35h39e3cac_0.conda": { + "build": "py35h39e3cac_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "cb895c922506906df5c9a9d7342a5624", + "name": "hypothesis", + "sha256": "fa5b00fceefd5f72cf7138ae42fa5119bd18d822d705739340de35bd1db165d5", + "size": 369267, + "subdir": "linux-64", + "timestamp": 1534347734583, + "version": "3.59.1" + }, + "hypothesis-3.59.1-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "1dec612223a5de7cc3f56b5f4d8bf475", + "name": "hypothesis", + "sha256": "a61a0497d88708dcbb6f29da4d59ca9dca140cead25e3fc1e8e8193b88e7dafa", + "size": 369751, + "subdir": "linux-64", + "timestamp": 1530732222565, + "version": "3.59.1" + }, + "hypothesis-3.59.1-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "ad106da4bba8d74738391adaca578cdf", + "name": "hypothesis", + "sha256": "c64f92416b1523e180c0af711223aa1f85ccae62307922253277377b68c67f7e", + "size": 369885, + "subdir": "linux-64", + "timestamp": 1530730530148, + "version": "3.59.1" + }, + "hypothesis-3.68.0-py27h39e3cac_0.conda": { + "build": "py27h39e3cac_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "062add2c88543cbb5501b60e7b0c73d0", + "name": "hypothesis", + "sha256": "47ddf651991f8ce3fe27d2f665255105ab9480ccef09eb94123f30434534c4cf", + "size": 396413, + "subdir": "linux-64", + "timestamp": 1534778398436, + "version": "3.68.0" + }, + "hypothesis-3.68.0-py35h39e3cac_0.conda": { + "build": "py35h39e3cac_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "0c6ad6eb9a03eb4538e2ad107734bbb3", + "name": "hypothesis", + "sha256": "a0caae17ed25688fae7d86606cc6f9cf80e47af16340eb05bd8a53fb3c661300", + "size": 400503, + "subdir": "linux-64", + "timestamp": 1534777898275, + "version": "3.68.0" + }, + "hypothesis-3.68.0-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "1485b858b95490bba698a38c91e08489", + "name": "hypothesis", + "sha256": "a1ca89c37bd01f1b64153058ce64cddb8f8f53aceca919e554c74666fd5f0488", + "size": 397532, + "subdir": "linux-64", + "timestamp": 1534778904612, + "version": "3.68.0" + }, + "hypothesis-3.68.0-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "coverage", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "2d3bc94e26eda7862a83ea06157b2767", + "name": "hypothesis", + "sha256": "9135a601de9425ab14669b2f9fe11bb937382b3c8f528cae9aba3b50780c65b5", + "size": 397833, + "subdir": "linux-64", + "timestamp": 1534779380655, + "version": "3.68.0" + }, + "hypothesis-4.10.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "5b3730729f29bf6494a355a7960be55b", + "name": "hypothesis", + "sha256": "e959cdcc759e81153de2045e834bcd4aa68f260972ab75dfed237ed8fde08ef7", + "size": 338811, + "subdir": "linux-64", + "timestamp": 1552436663716, + "version": "4.10.0" + }, + "hypothesis-4.10.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "956d24c7de4b1a24e7356b8d30ae8526", + "name": "hypothesis", + "sha256": "412e12d97fd91cd9b4dac6f54ab2efe887a279a73258f31f3054d32a286561d6", + "size": 340617, + "subdir": "linux-64", + "timestamp": 1552436778307, + "version": "4.10.0" + }, + "hypothesis-4.10.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "8f3198abdfdeed5ac195e1eabc0bfb2a", + "name": "hypothesis", + "sha256": "64708cac840e0899e55e8555c602f4cc282d2878188f2829ff655f32924e88d5", + "size": 344493, + "subdir": "linux-64", + "timestamp": 1552436725880, + "version": "4.10.0" + }, + "hypothesis-4.17.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "aa332fdb12090a65113cd2d85cd97c03", + "name": "hypothesis", + "sha256": "e192a4b98c87e4c48ba393f140198caf472ab4c8aa1edf4497ce3f6b7fb77761", + "size": 350078, + "subdir": "linux-64", + "timestamp": 1556082487091, + "version": "4.17.2" + }, + "hypothesis-4.17.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "21c479e3d9ca57416bf0f89967480bd2", + "name": "hypothesis", + "sha256": "25224dd920395719fcaeb1219ffa8c5a4f8b69fb8b5dccb5b45ee64aa104163f", + "size": 351813, + "subdir": "linux-64", + "timestamp": 1556112457288, + "version": "4.17.2" + }, + "hypothesis-4.17.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "e881e6dac5dd94209e33d11d6bfc7a9e", + "name": "hypothesis", + "sha256": "86215d434fe49eccf6be87c5c012f0468141757c65aef9449e47e4689ac963c2", + "size": 356012, + "subdir": "linux-64", + "timestamp": 1556112429839, + "version": "4.17.2" + }, + "hypothesis-4.23.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "85f1b9f6855d735554e4b6d59d3da9de", + "name": "hypothesis", + "sha256": "4d2d207c11aef2326ebc5e577f8914f8ecc57ff6c605c54741d202eb07e4ba33", + "size": 358136, + "subdir": "linux-64", + "timestamp": 1559063682385, + "version": "4.23.6" + }, + "hypothesis-4.23.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "3461b69311a9928d6583c97dc63db122", + "name": "hypothesis", + "sha256": "a10143d59f3f968cc49389f844ed003b5c51b7bc4774f8c965463bdcab96851a", + "size": 360191, + "subdir": "linux-64", + "timestamp": 1559063692093, + "version": "4.23.6" + }, + "hypothesis-4.23.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "d6c708aafcffc23120c85bbd2c2b0d70", + "name": "hypothesis", + "sha256": "4a6916779d8a89c3dbbaa3f959e1c89b2246fce672e79163863362ebbc6edcfd", + "size": 360040, + "subdir": "linux-64", + "timestamp": 1559063647202, + "version": "4.23.6" + }, + "hypothesis-4.32.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "98b0e3115d51cef2b2765e71e84cdc9b", + "name": "hypothesis", + "sha256": "58274d9f8941d1c45f7c8936da387e4b8da140dc8dc85c1779af43816fa5d3ee", + "size": 354008, + "subdir": "linux-64", + "timestamp": 1564685687824, + "version": "4.32.2" + }, + "hypothesis-4.32.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "451ae0edf1e96604a6e7082e82c8fdf8", + "name": "hypothesis", + "sha256": "3b91b86dce6557c24298cbb9ca9a78d815527cf6c94e831c242162946e87dd64", + "size": 355981, + "subdir": "linux-64", + "timestamp": 1564685679514, + "version": "4.32.2" + }, + "hypothesis-4.32.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "4309918adb26118480666dfb34fa0089", + "name": "hypothesis", + "sha256": "e5f34a6f4a7b7ec1099bb4ceeaf2d8d6b7270190571cf90d0941c5d9967d4bd8", + "size": 352016, + "subdir": "linux-64", + "timestamp": 1564685387128, + "version": "4.32.2" + }, + "hypothesis-4.36.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "9ef4465d9a1f17b3c6eaceeede4b1260", + "name": "hypothesis", + "sha256": "f69dce695f2cfe7fe18cc3417cc429735deb71ef2771d6361ba331ebd66c9a6d", + "size": 365515, + "subdir": "linux-64", + "timestamp": 1569375203269, + "version": "4.36.2" + }, + "hypothesis-4.36.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "4bd80407283a579ec0a5bf3877d0e04b", + "name": "hypothesis", + "sha256": "5688a1749e0589771fe1cd63f075e881aeff915e9412dbbc725a233b34cb6ea7", + "size": 367545, + "subdir": "linux-64", + "timestamp": 1569375186919, + "version": "4.36.2" + }, + "hypothesis-4.36.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "18eb409cb8f6d5f800ce1c1cc159655e", + "name": "hypothesis", + "sha256": "a2652734e4fbdb08e1443bb0cd1b37de352778a64b82a337441c93fb8ef50fbb", + "size": 367876, + "subdir": "linux-64", + "timestamp": 1569375208689, + "version": "4.36.2" + }, + "hypothesis-4.36.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "5fcd208f8747e4b8d292290358ecf937", + "name": "hypothesis", + "sha256": "7470a8f9990e0f6f3aef54530ac9e206cfadd7a51f1810f3e3064363023c4966", + "size": 344201, + "subdir": "linux-64", + "timestamp": 1573469614261, + "version": "4.36.2" + }, + "hypothesis-4.44.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "d27d65d029f4a1de33e7b83ec20890f7", + "name": "hypothesis", + "sha256": "0ab2a9937f65717c797ab4af69f4701cdf76092fd10c3d1c00db13036bb027e1", + "size": 383921, + "subdir": "linux-64", + "timestamp": 1573965442937, + "version": "4.44.2" + }, + "hypothesis-4.44.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "c16bf286145f68eb3df8c831671ad25d", + "name": "hypothesis", + "sha256": "8b0b67bca9e90a73e38526283a7a2d85cd67c2df8cdcdad8cdbc54dc31baffb5", + "size": 385793, + "subdir": "linux-64", + "timestamp": 1573965424136, + "version": "4.44.2" + }, + "hypothesis-4.44.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "200bee63cdc8549af9db525a5422358d", + "name": "hypothesis", + "sha256": "a83a1a03db5f03e1e8f241c380af23cd873891c2ae23842368ec372f44c3ed3e", + "size": 386047, + "subdir": "linux-64", + "timestamp": 1573965435552, + "version": "4.44.2" + }, + "hypothesis-4.44.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "ac672b5b80980d87c4394356a5019af2", + "name": "hypothesis", + "sha256": "3511ed2c8a5ae53a2a10474db144d20b1ac98b8ed00100bda28622015aac70db", + "size": 388135, + "subdir": "linux-64", + "timestamp": 1573965471265, + "version": "4.44.2" + }, + "hypothesis-4.54.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "enum34", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "2ff3ca92f3440f69006ae076c0a23827", + "name": "hypothesis", + "sha256": "d9e792758feeae613b3072bff7134cf655e36233191ace72e323d2b63ac9f567", + "size": 389156, + "subdir": "linux-64", + "timestamp": 1576539568622, + "version": "4.54.2" + }, + "hypothesis-4.54.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "0c62c2b7484a6d6ff33b07388a27a777", + "name": "hypothesis", + "sha256": "99f3cf49010a57ee4cf4c68b2a7ee14ef5fceb23829568caa610792fb3e18b94", + "size": 395392, + "subdir": "linux-64", + "timestamp": 1576539600334, + "version": "4.54.2" + }, + "hypothesis-4.54.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "c8ce535af630c275ce71cb7ecc32726c", + "name": "hypothesis", + "sha256": "10f0b8ec5aa68d3d1eee48728314e3cc0032924904752e6e006bc4c1d8a17f68", + "size": 391108, + "subdir": "linux-64", + "timestamp": 1576539503458, + "version": "4.54.2" + }, + "hypothesis-4.54.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MPL 2.0", + "license_family": "Other", + "md5": "936fe4b3400ae3d8070445f8608483aa", + "name": "hypothesis", + "sha256": "6108161a2f86ae520419fcb8a1fb32d723aca3c0a495735486ace07deafa8ee4", + "size": 398514, + "subdir": "linux-64", + "timestamp": 1576539606800, + "version": "4.54.2" + }, + "ibis-framework-0.12.0-py27h9175896_0.conda": { + "build": "py27h9175896_0", + "build_number": 0, + "depends": [ + "enum34", + "graphviz", + "impyla >=0.14.0", + "multipledispatch", + "numpy >=1.10.0", + "pandas >=0.18.1", + "psycopg2", + "python >=2.7,<2.8.0a0", + "python-graphviz", + "setuptools", + "six", + "sqlalchemy >=1.0.0", + "thrift <=0.9.3", + "thriftpy <=0.3.9", + "toolz" + ], + "license": "Apache 2.0", + "md5": "ce3100784d1034600f4c805471de015b", + "name": "ibis-framework", + "sha256": "50e3c1dd9b0d341878a20aceef548fec80531e25a31d17e2067be8c1e6262407", + "size": 599434, + "subdir": "linux-64", + "timestamp": 1510945275278, + "version": "0.12.0" + }, + "ibis-framework-0.12.0-py35hf90f30f_0.conda": { + "build": "py35hf90f30f_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "multipledispatch", + "numpy >=1.10.0", + "pandas >=0.18.1", + "psycopg2", + "python >=3.5,<3.6.0a0", + "python-graphviz", + "setuptools", + "six", + "sqlalchemy >=1.0.0", + "thrift <=0.9.3", + "thriftpy <=0.3.9", + "toolz" + ], + "license": "Apache 2.0", + "md5": "a9b69b198903b424cc463c7c31421ab0", + "name": "ibis-framework", + "sha256": "758db5e89d6ea053cdf4e7e8a427024e81d08d806c3514bd2d743d4e16193df3", + "size": 613622, + "subdir": "linux-64", + "timestamp": 1510945246210, + "version": "0.12.0" + }, + "ibis-framework-0.12.0-py36h5db9e08_0.conda": { + "build": "py36h5db9e08_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "multipledispatch", + "numpy >=1.10.0", + "pandas >=0.18.1", + "psycopg2", + "python >=3.6,<3.7.0a0", + "python-graphviz", + "setuptools", + "six", + "sqlalchemy >=1.0.0", + "thrift", + "thriftpy <=0.3.9", + "toolz" + ], + "license": "Apache 2.0", + "md5": "33c774c3cd4780ce7fb4a690935758f8", + "name": "ibis-framework", + "sha256": "d9be41aadf8d7bf8d8775bd506d4504506c9748d189729dc954a49a522f955c3", + "size": 607681, + "subdir": "linux-64", + "timestamp": 1510945250466, + "version": "0.12.0" + }, + "ibis-framework-0.13.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "functools32", + "graphviz", + "impyla >=0.14.0", + "multipledispatch", + "numpy >=1.10.0", + "pandas >=0.18.1", + "pathlib2", + "psycopg2", + "python >=2.7,<2.8.0a0", + "python-graphviz", + "setuptools", + "six", + "sqlalchemy >=1.0.0", + "thrift <=0.9.3", + "thriftpy <=0.3.9", + "toolz" + ], + "license": "Apache 2.0", + "md5": "1a57b2bd2b9a8eefd8904e0f39782023", + "name": "ibis-framework", + "sha256": "2a14aa7516112499abdd7f3e2d2423146dba95c327fdf39836dc972525c5b223", + "size": 695391, + "subdir": "linux-64", + "timestamp": 1530914713869, + "version": "0.13.0" + }, + "ibis-framework-0.13.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "multipledispatch", + "numpy >=1.10.0", + "pandas >=0.18.1", + "psycopg2", + "python >=3.6,<3.7.0a0", + "python-graphviz", + "setuptools", + "six", + "sqlalchemy >=1.0.0", + "thrift", + "thriftpy <=0.3.9", + "toolz" + ], + "license": "Apache 2.0", + "md5": "4493b469d5b6e632ed3aceb01d8feeda", + "name": "ibis-framework", + "sha256": "f13f83c6e111d8ed291c8b5a1342f3335a94cc788db3ff1440c6ca4f725646c9", + "size": 697310, + "subdir": "linux-64", + "timestamp": 1530914784017, + "version": "0.13.0" + }, + "ibis-framework-0.13.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "multipledispatch", + "numpy >=1.10.0", + "pandas >=0.18.1", + "psycopg2", + "python >=3.7,<3.8.0a0", + "python-graphviz", + "setuptools", + "six", + "sqlalchemy >=1.0.0", + "thrift", + "thriftpy <=0.3.9", + "toolz" + ], + "license": "Apache 2.0", + "md5": "1bdefd26b3de2f586ad2eb0c6d53bba2", + "name": "ibis-framework", + "sha256": "1b3aa949231cb3c880ada63f176236726ed39b4557d766fcd9ebff4ba294cdef", + "size": 693492, + "subdir": "linux-64", + "timestamp": 1530914846248, + "version": "0.13.0" + }, + "ibis-framework-0.13.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "multipledispatch", + "numpy >=1.10.0", + "pandas >=0.18.1", + "psycopg2", + "python >=3.8,<3.9.0a0", + "python-graphviz", + "setuptools", + "six", + "sqlalchemy >=1.0.0", + "thrift", + "thriftpy <=0.3.9", + "toolz" + ], + "license": "Apache 2.0", + "md5": "6cf478fddf54bbd07a17314733436a27", + "name": "ibis-framework", + "sha256": "926c1d78fea4d0d0c976305ee60ca2df083c45670c1d335110dbb4fda3506100", + "size": 709969, + "subdir": "linux-64", + "timestamp": 1574414004322, + "version": "0.13.0" + }, + "ibis-framework-0.14.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "funcsigs", + "functools32", + "graphviz", + "impyla >=0.14.0", + "lz4", + "multipledispatch", + "numpy >=1.11", + "pandas >=0.20", + "pathlib2", + "psycopg2", + "pyarrow >=0.6.0", + "pymysql", + "pytables >=3.0.0", + "python >=2.7,<2.8.0a0", + "python-graphviz", + "python-hdfs >=2.0.16", + "regex", + "setuptools", + "six", + "sqlalchemy", + "thrift <=0.9.3", + "thriftpy <=0.3.9", + "toolz" + ], + "license": "Apache 2.0", + "md5": "e3066e95e32c9b85f882cc613d0da350", + "name": "ibis-framework", + "sha256": "42170d2733f0d9fbfe3a7ab5780d8b77a33c8dee84ba3a3867730f319c916c00", + "size": 801125, + "subdir": "linux-64", + "timestamp": 1545242235398, + "version": "0.14.0" + }, + "ibis-framework-0.14.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "lz4", + "multipledispatch", + "numpy >=1.11", + "pandas >=0.20", + "psycopg2", + "pyarrow >=0.6.0", + "pymysql", + "pytables >=3.0.0", + "python >=3.10,<3.11.0a0", + "python-graphviz", + "python-hdfs >=2.0.16", + "regex", + "setuptools", + "six", + "sqlalchemy", + "toolz" + ], + "license": "Apache 2.0", + "md5": "3d2860f03708afb281575bf40003b4c7", + "name": "ibis-framework", + "sha256": "c85c63cea350d71a7cf8eb688b4a4dacbb111faaae19fff71b8940fb8b850eaf", + "size": 822023, + "subdir": "linux-64", + "timestamp": 1641558163172, + "version": "0.14.0" + }, + "ibis-framework-0.14.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "lz4", + "multipledispatch", + "numpy >=1.11", + "pandas >=0.20", + "psycopg2", + "pyarrow >=0.6.0", + "pymysql", + "pytables >=3.0.0", + "python >=3.6,<3.7.0a0", + "python-graphviz", + "python-hdfs >=2.0.16", + "regex", + "setuptools", + "six", + "sqlalchemy", + "toolz" + ], + "license": "Apache 2.0", + "md5": "cbbf9613eaccbb5a9b3aafea0355c12c", + "name": "ibis-framework", + "sha256": "6d0dfeea0b8f2bb0e731d5cb2fb735a62abb7f0a0f9060a778b112ca2fe1c7aa", + "size": 801229, + "subdir": "linux-64", + "timestamp": 1545242271255, + "version": "0.14.0" + }, + "ibis-framework-0.14.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "lz4", + "multipledispatch", + "numpy >=1.11", + "pandas >=0.20", + "psycopg2", + "pyarrow >=0.6.0", + "pymysql", + "pytables >=3.0.0", + "python >=3.7,<3.8.0a0", + "python-graphviz", + "python-hdfs >=2.0.16", + "regex", + "setuptools", + "six", + "sqlalchemy", + "toolz" + ], + "license": "Apache 2.0", + "md5": "6c535c42909fbd3fee3c3401aa8f531d", + "name": "ibis-framework", + "sha256": "c1d8db77cb01c817d0924598bc2af38462fb6e4334034fb731a477a371453e8c", + "size": 801620, + "subdir": "linux-64", + "timestamp": 1545242272599, + "version": "0.14.0" + }, + "ibis-framework-1.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "lz4", + "multipledispatch", + "numpy >=1.11", + "pandas >=0.20", + "psycopg2", + "pyarrow >=0.6.0", + "pymysql", + "pytables >=3.0.0", + "python >=3.6,<3.7.0a0", + "python-graphviz", + "python-hdfs >=2.0.16", + "regex", + "setuptools", + "six", + "sqlalchemy", + "toolz" + ], + "license": "Apache 2.0", + "md5": "3ebe68f93158ebed9bd325879840341d", + "name": "ibis-framework", + "sha256": "3d65026555de518c0981d608c0a1e21a6504035cc0e88e0050604fdb87da0814", + "size": 950820, + "subdir": "linux-64", + "timestamp": 1600361257841, + "version": "1.3.0" + }, + "ibis-framework-1.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "lz4", + "multipledispatch", + "numpy >=1.11", + "pandas >=0.20", + "psycopg2", + "pyarrow >=0.6.0", + "pymysql", + "pytables >=3.0.0", + "python >=3.7,<3.8.0a0", + "python-graphviz", + "python-hdfs >=2.0.16", + "regex", + "setuptools", + "six", + "sqlalchemy", + "toolz" + ], + "license": "Apache 2.0", + "md5": "43f9ae00bc3bbb363c9833db7c0cef51", + "name": "ibis-framework", + "sha256": "c855d03b478f9c83ca14bc4897a6c87bb7ffc6e85c1ff87f5248c9b88a04b13a", + "size": 958701, + "subdir": "linux-64", + "timestamp": 1600361217475, + "version": "1.3.0" + }, + "ibis-framework-1.3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "graphviz", + "impyla >=0.14.0", + "lz4", + "multipledispatch", + "numpy >=1.11", + "pandas >=0.20", + "psycopg2", + "pyarrow >=0.6.0", + "pymysql", + "pytables >=3.0.0", + "python >=3.8,<3.9.0a0", + "python-graphviz", + "python-hdfs >=2.0.16", + "regex", + "setuptools", + "six", + "sqlalchemy", + "toolz" + ], + "license": "Apache 2.0", + "md5": "3ad92fceece26a4f1af09f8d8bf5a023", + "name": "ibis-framework", + "sha256": "aeb34881740c42e62bacd8876d852c208b06cbb620b4792b08176c0077312b60", + "size": 963082, + "subdir": "linux-64", + "timestamp": 1600361214588, + "version": "1.3.0" + }, + "icalendar-4.0.2-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ca1564f5c4667a21dd76e83c71ad3b31", + "name": "icalendar", + "sha256": "cf0ea6be4f7e03e139d25e5ea8fd54452a9d460bf144bbcc94f244fc93e2fe30", + "size": 104099, + "subdir": "linux-64", + "timestamp": 1531494963767, + "version": "4.0.2" + }, + "icalendar-4.0.2-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8ae83c8c65b20be45dc62bbfe203431b", + "name": "icalendar", + "sha256": "9df02bb9da5d2845043848548dd264892049f333e2aa68dada658c842bc1ee8e", + "size": 105315, + "subdir": "linux-64", + "timestamp": 1531495110459, + "version": "4.0.2" + }, + "icalendar-4.0.2-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "2781305b3bc3faaabd7e4b4df3410e6b", + "name": "icalendar", + "sha256": "e161d6a7db6e315e10bab79666c1e5c02e6ee0500b5fc455561451ccee8ddeb1", + "size": 105553, + "subdir": "linux-64", + "timestamp": 1531495110822, + "version": "4.0.2" + }, + "icalendar-4.0.2-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "196666d0e24865fc9349acba2db19107", + "name": "icalendar", + "sha256": "1f4a2b17fa818ddda92ffd7e096176de0f9236017c68028f05fb2e0bbbe0cdd0", + "size": 103958, + "subdir": "linux-64", + "timestamp": 1531495107278, + "version": "4.0.2" + }, + "icalendar-4.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "adf90468b9d7b88045622dda73a29bdb", + "name": "icalendar", + "sha256": "d2c170da6a7d00107122763d9f31689b5800fd664e6b2e26c591449c98b95e5c", + "size": 104409, + "subdir": "linux-64", + "timestamp": 1539657757062, + "version": "4.0.3" + }, + "icalendar-4.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b8552de4a2510ccdd379f7e30b6a00f9", + "name": "icalendar", + "sha256": "67c6681d7da0512d052d3b85b98e50b3c67077511a4c5ed9a124d913f989db20", + "size": 105114, + "subdir": "linux-64", + "timestamp": 1539657773796, + "version": "4.0.3" + }, + "icalendar-4.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "51d67fed5d2f802adce94927f8b727b6", + "name": "icalendar", + "sha256": "4c5b1e08001a4d55c052574a19f4210250101f8b8b61b674e90f4b495545a224", + "size": 106840, + "subdir": "linux-64", + "timestamp": 1539657777559, + "version": "4.0.3" + }, + "icu-58.2-h211956c_0.conda": { + "build": "h211956c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "0732226ca96080f817deb6498c9597af", + "name": "icu", + "sha256": "0a8ce4c0e59c083ac6a16c84aa5a133aa7a9e6559c454bc4115eb27245bf4df0", + "size": 10731103, + "subdir": "linux-64", + "timestamp": 1505733580747, + "version": "58.2" + }, + "icu-58.2-h9c2bf20_1.conda": { + "build": "h9c2bf20_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "3dd4ee7f149320d74d356e309422edc6", + "name": "icu", + "sha256": "b5857d4dcdb6861251d11e1f35eac7befea9d7b17da0da9e1d7f3b01ff7392f4", + "size": 10761336, + "subdir": "linux-64", + "timestamp": 1510863235474, + "version": "58.2" + }, + "icu-58.2-he6710b0_3.conda": { + "build": "he6710b0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "48cc14d5ad1a9bcd8dac17211a8deb8b", + "name": "icu", + "sha256": "fdf7a480fcb598d164cbd28d3ce015d7de52db30f76faf7a15fbb8bbc7b8c5af", + "size": 11012106, + "subdir": "linux-64", + "timestamp": 1588026213084, + "version": "58.2" + }, + "icu-68.1-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "446da901624ad90d03fac6e5d467fa1e", + "name": "icu", + "sha256": "fb04db14ea02626dac4277248b87dd24e79389ed0fabf29c85f500079e090fb2", + "size": 12345500, + "subdir": "linux-64", + "timestamp": 1611658295025, + "version": "68.1" + }, + "identify-2.5.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "ukkonen" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c32ff6b93ebe5b0425f4f11197469792", + "name": "identify", + "sha256": "29dc159f9008140236ccd9fd0f44b6e133d6df8511e51301de3f47a5c2771711", + "size": 86735, + "subdir": "linux-64", + "timestamp": 1663193251802, + "version": "2.5.5" + }, + "identify-2.5.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "ukkonen" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5276c46194262bb622bc8d3019abfd3b", + "name": "identify", + "sha256": "2895892971756128991d0953ab7befcc70d08b1a68c12b991487e47e9419b29a", + "size": 91313, + "subdir": "linux-64", + "timestamp": 1676844305369, + "version": "2.5.5" + }, + "identify-2.5.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "ukkonen" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9c2467d7be4fbfa09f58fb0a43efa22", + "name": "identify", + "sha256": "9c8a1aead68ffd47196dfdef5087d6d4ec16bae72d6db0bf43ca277dda9006e7", + "size": 84780, + "subdir": "linux-64", + "timestamp": 1663193211289, + "version": "2.5.5" + }, + "identify-2.5.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "ukkonen" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17c5ca97df3efedbd6cee36bdd9fa64e", + "name": "identify", + "sha256": "1fed3bd777076703613129c9ce1aeea38a95d4ed4dd15fbb44a8e800c09542a8", + "size": 84841, + "subdir": "linux-64", + "timestamp": 1663193306595, + "version": "2.5.5" + }, + "identify-2.5.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "ukkonen" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5884f7d3d8a4cfd403b1c8c1ad81d697", + "name": "identify", + "sha256": "fd3c046ec5411520e8f1cc5b352c5b95fe0677409d5b2df3a17a338512ece64e", + "size": 84946, + "subdir": "linux-64", + "timestamp": 1663193279927, + "version": "2.5.5" + }, + "idna-2.6-py27h5722d68_1.conda": { + "build": "py27h5722d68_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD Like", + "md5": "84ed6801a0c774e282224b05888fb575", + "name": "idna", + "sha256": "d8e0fc6a4cdfc889c54b85aa52239320b2e19b3f2d8152f37bbf85e7fbfae86b", + "size": 107843, + "subdir": "linux-64", + "timestamp": 1505691711574, + "version": "2.6" + }, + "idna-2.6-py35h8605a33_1.conda": { + "build": "py35h8605a33_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD Like", + "md5": "33ba2b5c7debe5764539834862a673f2", + "name": "idna", + "sha256": "2aa6ae18ccacc2bfbcc587966f2866d2573a67b67ba0fa82a50dbf61152f5ec6", + "size": 110036, + "subdir": "linux-64", + "timestamp": 1505691723368, + "version": "2.6" + }, + "idna-2.6-py36h82fb2a8_1.conda": { + "build": "py36h82fb2a8_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD Like", + "md5": "29c92e4229e61ac109dfc20c4e061fe3", + "name": "idna", + "sha256": "46957d1ada279f5d720b5ed54fe0d9701a647adebc71907de42c7da73a85641b", + "size": 106648, + "subdir": "linux-64", + "timestamp": 1505691735281, + "version": "2.6" + }, + "idna-2.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD Like", + "md5": "0953c4b3184a73eabb1161d5ef3d7711", + "name": "idna", + "sha256": "2e28632492b4ec9a570cfd7c641f0de0ad4e55d24b93954b59ff3cb79b3de959", + "size": 114887, + "subdir": "linux-64", + "timestamp": 1528923514438, + "version": "2.7" + }, + "idna-2.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD Like", + "md5": "2fc1f984df5d32ffec73ff45d909e782", + "name": "idna", + "sha256": "17646bfdca9b4ddbdd3cfe61a08abf8d46ea8661a424938a9ff7cabd1e41571f", + "size": 115494, + "subdir": "linux-64", + "timestamp": 1528923507756, + "version": "2.7" + }, + "idna-2.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD Like", + "md5": "c9fb5e8f2f2328a9e9b4d411143bca1c", + "name": "idna", + "sha256": "6934a735475e6b670e11fef341f7db16ed39adc579a49518564ad0893deaf367", + "size": 114326, + "subdir": "linux-64", + "timestamp": 1528923498940, + "version": "2.7" + }, + "idna-2.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD Like", + "md5": "0a896a268c55a5817c1bd4d0c153d14e", + "name": "idna", + "sha256": "fe2383036182285032e607223a6cede4d0d2d14a7723fdf612d045b9cd74e186", + "size": 87499, + "subdir": "linux-64", + "timestamp": 1531342378046, + "version": "2.7" + }, + "idna-2.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD Like", + "md5": "fd757c82e291acd6b0db19d7ee8ee2b7", + "name": "idna", + "sha256": "a21ad00f865e71d720b679560d675b2333d10e3f815c9f48d83d2354d457931d", + "size": 116728, + "subdir": "linux-64", + "timestamp": 1545082875447, + "version": "2.8" + }, + "idna-2.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD Like", + "md5": "3164b878ed7259b13b0bf531c492d991", + "name": "idna", + "sha256": "02b118afa173e6f8d8dfd9e8daa793f719ba232a3c31b21855f86100f7f168eb", + "size": 114585, + "subdir": "linux-64", + "timestamp": 1545082944493, + "version": "2.8" + }, + "idna-2.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD Like", + "md5": "fd11c9476dfda060e4f3df6e023f76fe", + "name": "idna", + "sha256": "27237ef41103a7492b9baee5f33e0445a7ebc77865294396cbfe5b7c57bc6b8f", + "size": 87397, + "subdir": "linux-64", + "timestamp": 1545082953868, + "version": "2.8" + }, + "idna-2.8-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD Like", + "md5": "4e6fe9600e30115db4c0d6bab5dca3bd", + "name": "idna", + "sha256": "248dbf61ba1c8cb79b090186ca1e5f0fc58e1b33e4141725eedbc516ef8c0872", + "size": 93984, + "subdir": "linux-64", + "timestamp": 1575486166738, + "version": "2.8" + }, + "idna-2.8-py38_1000.conda": { + "build": "py38_1000", + "build_number": 1000, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD Like", + "md5": "ba3f82ff5b3402f43c13ab28b6094a2d", + "name": "idna", + "sha256": "640c5ab63adc3833c94bf8ac7f72e695a67ae388852482cd7af1ab14dea52d7d", + "size": 91876, + "subdir": "linux-64", + "timestamp": 1572512253707, + "version": "2.8" + }, + "idna-3.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7f4dba8f7c37983e0d56fad719c94ba3", + "name": "idna", + "sha256": "2f0a7c1c45943cbc02e987a9e682290b15a08a940ecdff9cd82e83e84919dcd3", + "size": 98832, + "subdir": "linux-64", + "timestamp": 1666125633476, + "version": "3.4" + }, + "idna-3.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ace9494db4d1927c447dc6f81bc95f0a", + "name": "idna", + "sha256": "9b03a645e8b6e53045d69b1c0b387f0710012c836991cb03e0f17a8041fd296b", + "size": 98558, + "subdir": "linux-64", + "timestamp": 1676822710633, + "version": "3.4" + }, + "idna-3.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1d74eed7438b961a6b611ac975ec63c5", + "name": "idna", + "sha256": "ce7674803ad5e8ee93a96e266f214b7a3cf3d538696d13ed547fe160ba402f53", + "size": 93471, + "subdir": "linux-64", + "timestamp": 1666125686415, + "version": "3.4" + }, + "idna-3.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1c05a7fa231e08f357d92702689cbdd", + "name": "idna", + "sha256": "89d9bdea712dcfc904d0b3c51b72bf142af04ff9a99c93bf58dfdcf0951ee32e", + "size": 95207, + "subdir": "linux-64", + "timestamp": 1666125659782, + "version": "3.4" + }, + "idna-3.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "92ee6ebc3f880fe03d98f90d122d4719", + "name": "idna", + "sha256": "e8d33aa2447ce717310855d9382bf9547841246ac883e0aa27981f8b6a5d6fea", + "size": 94742, + "subdir": "linux-64", + "timestamp": 1666125606878, + "version": "3.4" + }, + "idna_ssl-1.0.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cdc3740fbcfaeb474a3bc5b8795e0fc3", + "name": "idna_ssl", + "sha256": "a1489ddc722c06bd6dfd89fd81c96ab81851e97462d9c2bdf856636d2dacfa02", + "size": 7067, + "subdir": "linux-64", + "timestamp": 1520920996598, + "version": "1.0.1" + }, + "idna_ssl-1.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c7425215e8dea7f39f67c3d0a8ebd51", + "name": "idna_ssl", + "sha256": "5f51d9a19b91c9a513840d73ed1d1d37c6854ddebc9e374624d003ce245b0a49", + "size": 7052, + "subdir": "linux-64", + "timestamp": 1520920966171, + "version": "1.0.1" + }, + "idna_ssl-1.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "adab5a898ac08e35a2cb529bcad2ca04", + "name": "idna_ssl", + "sha256": "e640ce3134af8420be7cd5c6ec760bce94a7a8484202351f9b8ce3153a4132c3", + "size": 7745, + "subdir": "linux-64", + "timestamp": 1640790945882, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0ca5d3f33b4fb9d82588b281ceecaf9", + "name": "idna_ssl", + "sha256": "e82fac17a5b0d08852e0f5febb08d92e94b1b6006deefff6327f7e685725e059", + "size": 8487, + "subdir": "linux-64", + "timestamp": 1676852742992, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b78344b2605b46baf64bb86b2c8e515", + "name": "idna_ssl", + "sha256": "c6f073f0f321343f94b926d278b0680d086ce384bafc619061970d6d01008def", + "size": 7079, + "subdir": "linux-64", + "timestamp": 1535510959667, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "265105d7315e4a97fe4b1a455181b9a0", + "name": "idna_ssl", + "sha256": "0b94d38f4741b9030b0a843a719b35833250e3fbaabfc0fc1b01046a59cc3f3b", + "size": 7055, + "subdir": "linux-64", + "timestamp": 1535510962043, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea0bb4dcb7e14f330326a57fa08ca2a1", + "name": "idna_ssl", + "sha256": "a5c504ce1b726b0cea2192e0e920cd53021da750fe78fa8a840971b0cd5de47d", + "size": 8508, + "subdir": "linux-64", + "timestamp": 1611752521045, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a1cc2bb4b5b40683eb4a55055a810127", + "name": "idna_ssl", + "sha256": "1f333308728c8532446bc32f95732ab8581533ae0f49f9506a67efc7ac251451", + "size": 7061, + "subdir": "linux-64", + "timestamp": 1535543696935, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py37_1000.conda": { + "build": "py37_1000", + "build_number": 1000, + "depends": [ + "idna >=2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1bfed6685f7ecc940daab4e6d3185237", + "name": "idna_ssl", + "sha256": "d5869b02566ea8d155c03a6bc163f41ea506506de34b677c037209391dd139dd", + "size": 7020, + "subdir": "linux-64", + "timestamp": 1594359721583, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df3e210affd30a8f089f60b502678cf4", + "name": "idna_ssl", + "sha256": "944802454e62746509e2a1fd61351760793222efd957af80dec3030bb956eb6b", + "size": 8492, + "subdir": "linux-64", + "timestamp": 1611752521047, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d6854f65081985809f66b89e28b241f", + "name": "idna_ssl", + "sha256": "760ecd690197367840b68b8852165c4f3155092bf62af7a07b81d639240255ad", + "size": 7576, + "subdir": "linux-64", + "timestamp": 1573469630319, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e8d376bfe628cad725c35730ed3f7b3", + "name": "idna_ssl", + "sha256": "f45f3a68850fb954ab78453ae7fdfdc29dab32b5a56cf60fc676ffbda6e62378", + "size": 8464, + "subdir": "linux-64", + "timestamp": 1611752500343, + "version": "1.1.0" + }, + "idna_ssl-1.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "idna", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45d925860adad9ecc5adfe14f4b66b6c", + "name": "idna_ssl", + "sha256": "b50cd3d75ece3f7f50396af2d8c9db9df6bb6584da98a775c12bff8d82613872", + "size": 8492, + "subdir": "linux-64", + "timestamp": 1611752520139, + "version": "1.1.0" + }, + "ijson-3.1.4-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "yajl" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "01a185fa9616a760b660f046d23439e0", + "name": "ijson", + "sha256": "47815c0a737cf1c18ff9f0fce05503f1987fc77c1b53828831328e2e716a9940", + "size": 99440, + "subdir": "linux-64", + "timestamp": 1655384141822, + "version": "3.1.4" + }, + "ijson-3.1.4-py311h5eee18b_1.conda": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "yajl" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ea030bb97719e9048ea878ad2384b1c4", + "name": "ijson", + "sha256": "89fabe3a7ecdb1dade9fb3eacaedd313113e151c96aecf4080bc0f4bedf1a732", + "size": 63693, + "subdir": "linux-64", + "timestamp": 1679340176418, + "version": "3.1.4" + }, + "ijson-3.1.4-py37h7f8727e_1.conda": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "yajl" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "01dcece50b414bbfccffc36b38b6c893", + "name": "ijson", + "sha256": "c6df662addc4d4d75d72a9d8164daea2badac132682663e91b6e5120607a0cba", + "size": 53720, + "subdir": "linux-64", + "timestamp": 1655384170860, + "version": "3.1.4" + }, + "ijson-3.1.4-py38h7f8727e_1.conda": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "yajl" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "475199ffb4490fe2f27935f1761544d8", + "name": "ijson", + "sha256": "61f80a2ebad41f778ccc26016b7847485414afd3a29003730b523e49ea38e9e6", + "size": 54568, + "subdir": "linux-64", + "timestamp": 1655384199670, + "version": "3.1.4" + }, + "ijson-3.1.4-py39h7f8727e_1.conda": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "yajl" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "21ef4d7e1bf4156101a7bf487ba322d6", + "name": "ijson", + "sha256": "55059469104877c9c5c9491647283cdb9db400c0aabe92698d168626a96f283c", + "size": 54518, + "subdir": "linux-64", + "timestamp": 1655384101163, + "version": "3.1.4" + }, + "imagecodecs-2020.5.30-py36h567f118_1.conda": { + "build": "py36h567f118_1", + "build_number": 1, + "depends": [ + "blosc >=1.19.0,<2.0a0", + "brotli >=1.0.7,<1.1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.2,<1.10.0a0", + "numpy >=1.15.4,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.4,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6647caeef725fc54bf5f97aa94d79222", + "name": "imagecodecs", + "sha256": "56c65d4c9a7268548544da35b0d26d47baf685b22eb70d7564628bdb95f56d6a", + "size": 5710602, + "subdir": "linux-64", + "timestamp": 1593454003151, + "version": "2020.5.30" + }, + "imagecodecs-2020.5.30-py36hfa7d478_2.conda": { + "build": "py36hfa7d478_2", + "build_number": 2, + "depends": [ + "blosc >=1.20.1,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.2,<1.10.0a0", + "numpy >=1.15.4,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b9d0b9d6f4c0ba9b5bb01dbc71de6249", + "name": "imagecodecs", + "sha256": "419dc63312a45fac9255b0093d6d395b6239e980a035937aaf671b3c54ce708f", + "size": 5718156, + "subdir": "linux-64", + "timestamp": 1603270701716, + "version": "2020.5.30" + }, + "imagecodecs-2020.5.30-py37h567f118_1.conda": { + "build": "py37h567f118_1", + "build_number": 1, + "depends": [ + "blosc >=1.19.0,<2.0a0", + "brotli >=1.0.7,<1.1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.2,<1.10.0a0", + "numpy >=1.15.4,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.4,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "36991c0928a3d60fd159656966fb66b5", + "name": "imagecodecs", + "sha256": "17f57dc12f5ec23a79cd8f143171d01c6e169af230957872e16abbf59e35ce4d", + "size": 5710532, + "subdir": "linux-64", + "timestamp": 1593453966719, + "version": "2020.5.30" + }, + "imagecodecs-2020.5.30-py37hfa7d478_2.conda": { + "build": "py37hfa7d478_2", + "build_number": 2, + "depends": [ + "blosc >=1.20.1,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.2,<1.10.0a0", + "numpy >=1.15.4,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20461ff2f9333a3f33a90ca85c61c9d2", + "name": "imagecodecs", + "sha256": "3987daa5fc0f65a1a22a9576d31c0aaeb361ff6331da731675eb138d87278f70", + "size": 5711708, + "subdir": "linux-64", + "timestamp": 1603270678223, + "version": "2020.5.30" + }, + "imagecodecs-2020.5.30-py38h567f118_1.conda": { + "build": "py38h567f118_1", + "build_number": 1, + "depends": [ + "blosc >=1.19.0,<2.0a0", + "brotli >=1.0.7,<1.1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.2,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.4,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d2da98c14d339a3bc94f92e53ed7005b", + "name": "imagecodecs", + "sha256": "0473e6ab357fbc8bc4dc5735e82a4b6cbf66a48f7d223510d69eecba3e46de34", + "size": 5765305, + "subdir": "linux-64", + "timestamp": 1593453995153, + "version": "2020.5.30" + }, + "imagecodecs-2020.5.30-py38hfa7d478_2.conda": { + "build": "py38hfa7d478_2", + "build_number": 2, + "depends": [ + "blosc >=1.20.1,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.2,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8c35e74e17392ad3a0ce68d387b93463", + "name": "imagecodecs", + "sha256": "bb5a2e62a8e2a90a04ee122c6a9a21a8335e8404385dc66e3735d70f846016b6", + "size": 5764129, + "subdir": "linux-64", + "timestamp": 1603270690952, + "version": "2020.5.30" + }, + "imagecodecs-2020.5.30-py39h581e88b_2.conda": { + "build": "py39h581e88b_2", + "build_number": 2, + "depends": [ + "blosc >=1.20.1,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.2,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8d7c6506772e18fbdacb1612adf6ec95", + "name": "imagecodecs", + "sha256": "4822a2aa28b19b26d899fad7e72ff241ccde5fbd5b97a3346b0ba8070f6c1f13", + "size": 5772421, + "subdir": "linux-64", + "timestamp": 1608062001498, + "version": "2020.5.30" + }, + "imagecodecs-2021.1.11-py37h581e88b_1.conda": { + "build": "py37h581e88b_1", + "build_number": 1, + "depends": [ + "blosc >=1.20.1,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1bad1d6caf70e3cad57200440c98ae19", + "name": "imagecodecs", + "sha256": "cb0891dc7f719381182094abe50ca91540c65e3dbe7b11cd598583fab5b90299", + "size": 5938043, + "subdir": "linux-64", + "timestamp": 1611258496132, + "version": "2021.1.11" + }, + "imagecodecs-2021.1.11-py38h581e88b_1.conda": { + "build": "py38h581e88b_1", + "build_number": 1, + "depends": [ + "blosc >=1.20.1,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c3ca34e0c169901f7475acbfcceeb8b3", + "name": "imagecodecs", + "sha256": "832e75ff7695562af3d6d10a7a9fdea5ed6b236693ae73a2fc62642a9b41507c", + "size": 6005300, + "subdir": "linux-64", + "timestamp": 1611258357258, + "version": "2021.1.11" + }, + "imagecodecs-2021.1.11-py39h581e88b_1.conda": { + "build": "py39h581e88b_1", + "build_number": 1, + "depends": [ + "blosc >=1.20.1,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.1.0,<2.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.11,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "09dfa0f4c40c46b963895258faf05235", + "name": "imagecodecs", + "sha256": "5302192034f89ac2e92f2ea5f1575d45adf7156a8f416e42aa2e43dfe712227b", + "size": 6014321, + "subdir": "linux-64", + "timestamp": 1611258475326, + "version": "2021.1.11" + }, + "imagecodecs-2021.3.31-py37h581e88b_0.conda": { + "build": "py37h581e88b_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f9bc4f44e809eef9a56c7aea9842b41c", + "name": "imagecodecs", + "sha256": "45d2df865ad7b0422c872baaa801a6b43b03695cdc405e312b947324ac58f450", + "size": 6165242, + "subdir": "linux-64", + "timestamp": 1617993657920, + "version": "2021.3.31" + }, + "imagecodecs-2021.3.31-py38h581e88b_0.conda": { + "build": "py38h581e88b_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4550bbe961c799a0ad8980042c7b5437", + "name": "imagecodecs", + "sha256": "828eee0dc1c11ea0a9076b06642d9b3eb8956508ff3fed9fae45cf472f5c527a", + "size": 6232859, + "subdir": "linux-64", + "timestamp": 1617996579272, + "version": "2021.3.31" + }, + "imagecodecs-2021.3.31-py39h581e88b_0.conda": { + "build": "py39h581e88b_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8e22a90a91e6c4b73b414f85cf122fc9", + "name": "imagecodecs", + "sha256": "f9bbda40d33ffbc48ec6fbc474c5a57320878d7759f7ac89bfe9c1d6a13dca4e", + "size": 6238051, + "subdir": "linux-64", + "timestamp": 1617996588573, + "version": "2021.3.31" + }, + "imagecodecs-2021.4.28-py37h581e88b_0.conda": { + "build": "py37h581e88b_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ff2e9ad16cc49b659aedfce4497c651", + "name": "imagecodecs", + "sha256": "20e35a4c3de24340f1cabdf2fbc43cef1fb57241284ef25ef01549b465ea337a", + "size": 6187148, + "subdir": "linux-64", + "timestamp": 1621408170398, + "version": "2021.4.28" + }, + "imagecodecs-2021.4.28-py38h581e88b_0.conda": { + "build": "py38h581e88b_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3aab02d230b24c27575ef97617a18210", + "name": "imagecodecs", + "sha256": "bab7ac7ce47f64b97c76b8a01429bc078a0f532a13817f5ebb6073d16f37c5b6", + "size": 6259967, + "subdir": "linux-64", + "timestamp": 1621408155389, + "version": "2021.4.28" + }, + "imagecodecs-2021.4.28-py39h581e88b_0.conda": { + "build": "py39h581e88b_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "706f4418d93b9f27846972b155de1fa5", + "name": "imagecodecs", + "sha256": "40bf33eaf39bd0d2eb22fcbac914e9873256145813fc12c4a96d02aec88aa772", + "size": 6270595, + "subdir": "linux-64", + "timestamp": 1621408148552, + "version": "2021.4.28" + }, + "imagecodecs-2021.6.8-py37h20f8b18_1.conda": { + "build": "py37h20f8b18_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9d,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "26f2a0d474f400c401e40a863737a5c3", + "name": "imagecodecs", + "sha256": "223f26b9face5083c772a865435a60cda4aafd55269ee7309ff0bdaa4396088a", + "size": 6241543, + "subdir": "linux-64", + "timestamp": 1634837056342, + "version": "2021.6.8" + }, + "imagecodecs-2021.6.8-py37h581e88b_0.conda": { + "build": "py37h581e88b_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fd7d6fe12901e1feb740749a279a3752", + "name": "imagecodecs", + "sha256": "5f6e49cc9e2a01bd13ed6c0dd2ba3bf4b966c925b4974e1d94fdaa56b1b54ab9", + "size": 6240532, + "subdir": "linux-64", + "timestamp": 1623228585001, + "version": "2021.6.8" + }, + "imagecodecs-2021.6.8-py38h20f8b18_1.conda": { + "build": "py38h20f8b18_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9d,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c708723dbe60b1bbb63fb1b92175133b", + "name": "imagecodecs", + "sha256": "7fba25b34dda77a2a88a05b260c65e81bfb01552f4fb508ff61e7be76b036c51", + "size": 6312062, + "subdir": "linux-64", + "timestamp": 1634825654364, + "version": "2021.6.8" + }, + "imagecodecs-2021.6.8-py38h581e88b_0.conda": { + "build": "py38h581e88b_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1be7e016ba7892f83d00b315743820a1", + "name": "imagecodecs", + "sha256": "8807622b538e3706d2f2e1f5f8662dda1f645e703872ebec1f97cafad1479896", + "size": 6306869, + "subdir": "linux-64", + "timestamp": 1623223093131, + "version": "2021.6.8" + }, + "imagecodecs-2021.6.8-py39h20f8b18_1.conda": { + "build": "py39h20f8b18_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9d,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5d785ab87b6efc3a01b902892f2086d8", + "name": "imagecodecs", + "sha256": "06a3e30551953b1f573b1647fddae2c9af62fd4098a0c3f3bf7f128beb579275", + "size": 6322514, + "subdir": "linux-64", + "timestamp": 1634843997131, + "version": "2021.6.8" + }, + "imagecodecs-2021.6.8-py39h581e88b_0.conda": { + "build": "py39h581e88b_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=2.2.1,<3.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.7,<1.8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7a3259fb5814458806f53a4dbee40e97", + "name": "imagecodecs", + "sha256": "33f0cfa2e5206f8483370494f97885f1b2fab73a3ada38887ffd5db0d7900677", + "size": 6325906, + "subdir": "linux-64", + "timestamp": 1623227982821, + "version": "2021.6.8" + }, + "imagecodecs-2021.8.26-py310h2a2ad71_0.conda": { + "build": "py310h2a2ad71_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9d,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.21.2,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "919dbd1eea11bb51251ddcb8fad4e368", + "name": "imagecodecs", + "sha256": "127ab5c9af6317e9f8ee55b6007a83d1c6118c96804480de3bd543fe4e36d0ea", + "size": 11890495, + "subdir": "linux-64", + "timestamp": 1642084705147, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py310h46e8fbd_2.conda": { + "build": "py310h46e8fbd_2", + "build_number": 2, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.5.0,<5.0a0", + "libwebp-base >=1.2.4,<2.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.21.5,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.10,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a8e759c9e8e71d8c69beb2ad912ec1c2", + "name": "imagecodecs", + "sha256": "63b8476ce91035b9d84a386df6f9a5ffc31e6dff30e814e71314b1c27583a260", + "size": 6623414, + "subdir": "linux-64", + "timestamp": 1677576900926, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py310hecf7e94_1.conda": { + "build": "py310hecf7e94_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.21.5,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.6,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "da91de23ddda157a60ac84be11b336a1", + "name": "imagecodecs", + "sha256": "cb61e27eb6f360a1e7e6cd6302b97605bd910ac6a596b509eec6c92b6dedee7b", + "size": 11791362, + "subdir": "linux-64", + "timestamp": 1664563374130, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py311h1307a82_0.conda": { + "build": "py311h1307a82_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.22.3,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.11,<3.12.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.10,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "713c9eb0a89656fbce6b29f27e1e10d9", + "name": "imagecodecs", + "sha256": "f9633d78e539e0c50abca2e2e067f18f6a837d6c8bb82efd917e63f73edb77f7", + "size": 6242917, + "subdir": "linux-64", + "timestamp": 1676919123830, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py311hb63acbb_2.conda": { + "build": "py311hb63acbb_2", + "build_number": 2, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.39,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.5.0,<5.0a0", + "libwebp-base >=1.2.4,<2.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.22.3,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.11,<3.12.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.10,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cca0f6d8cfdd07058531b451c4b93d9e", + "name": "imagecodecs", + "sha256": "44302392a878f335af20af88d0df1398815f34863a6e30d70d6b0576bf1d79e0", + "size": 6242056, + "subdir": "linux-64", + "timestamp": 1679336463587, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py37h4cda21f_0.conda": { + "build": "py37h4cda21f_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9d,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "792e7bd07238d5a244fffd8b67917fc3", + "name": "imagecodecs", + "sha256": "74b5e3cca739070d1453796605025c8357bd5b93241dca42a2795dd58d4a788d", + "size": 6314510, + "subdir": "linux-64", + "timestamp": 1635529358467, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py37hf0132c2_1.conda": { + "build": "py37hf0132c2_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.6,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f92a83ed6f8cbd3308630a271cb9cc82", + "name": "imagecodecs", + "sha256": "477bf4e21f846f4651434ed1f8e549f01874e8cb46801d7ce7a4552662dee88c", + "size": 6245334, + "subdir": "linux-64", + "timestamp": 1664562965130, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py37hfcb8610_2.conda": { + "build": "py37hfcb8610_2", + "build_number": 2, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.5.0,<5.0a0", + "libwebp-base >=1.2.4,<2.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.10,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d9b48537214cb8aa1e93078c890e47fa", + "name": "imagecodecs", + "sha256": "396017b987f61d804fc1f13b0fbd0cf796a2fd9489df697bf2eee06a934ec5b3", + "size": 6559506, + "subdir": "linux-64", + "timestamp": 1677577508385, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py38h4cda21f_0.conda": { + "build": "py38h4cda21f_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9d,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4cfb229b623dd26c7cca3bfa18638a98", + "name": "imagecodecs", + "sha256": "b7a811184085bb6e39ba641a52778b71c4755e3fb25d6ef617756311d435181f", + "size": 6396035, + "subdir": "linux-64", + "timestamp": 1635529352441, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py38hf0132c2_1.conda": { + "build": "py38hf0132c2_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.6,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "08efcd807392e9d895bebdda574a8cfa", + "name": "imagecodecs", + "sha256": "b8e009d7abe6dcd61fd85a64ad177fc2bb6d1bfeb1204a6b0d5c5681e28bbe6c", + "size": 6345658, + "subdir": "linux-64", + "timestamp": 1664562581922, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py38hfcb8610_2.conda": { + "build": "py38hfcb8610_2", + "build_number": 2, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.5.0,<5.0a0", + "libwebp-base >=1.2.4,<2.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.10,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c513ec447f2383ac4235d8e8a90c4734", + "name": "imagecodecs", + "sha256": "4addf6d92f6a50a3214871f02c5ca741a73b7cbdae429ac6d4457ac71a4d4efc", + "size": 6666033, + "subdir": "linux-64", + "timestamp": 1677577200072, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py39h4cda21f_0.conda": { + "build": "py39h4cda21f_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brotli >=1.0.9,<2.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9d,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.8,<2.0a0", + "xz >=5.2.5,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e126c63e1b309fba4c9785d6bf54fcce", + "name": "imagecodecs", + "sha256": "6652a2f587a1a12800b42e3907955c1b787c59ec49b065f2126b18a31617d609", + "size": 6407051, + "subdir": "linux-64", + "timestamp": 1635529364456, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py39hf0132c2_1.conda": { + "build": "py39hf0132c2_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.6,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "239815de75ba996794ec7520d2521aac", + "name": "imagecodecs", + "sha256": "f3fefeacfa7ba52132689392b1e50a16477ea1d4f7b6dc148faff41766f64961", + "size": 6315345, + "subdir": "linux-64", + "timestamp": 1664562215324, + "version": "2021.8.26" + }, + "imagecodecs-2021.8.26-py39hfcb8610_2.conda": { + "build": "py39hfcb8610_2", + "build_number": 2, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "brotli >=1.0.9,<1.1.0a0", + "brunsli >=0.1,<1.0a0", + "bzip2 >=1.0.8,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "charls >=2.2.0,<2.3.0a0", + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "jxrlib >=1.1,<1.2.0a0", + "lcms2 >=2.12,<3.0a0", + "lerc >=3.0,<4.0a0", + "libaec >=1.0.4,<2.0a0", + "libbrotlicommon >=1.0.9,<1.1.0a0", + "libbrotlidec >=1.0.9,<1.1.0a0", + "libbrotlienc >=1.0.9,<1.1.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.5.0,<5.0a0", + "libwebp-base >=1.2.4,<2.0a0", + "libzopfli >=1.0.3,<1.1.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "numpy >=1.16.6,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.9,<2.0a0", + "xz >=5.2.10,<6.0a0", + "zfp >=0.5.5,<1.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "13cad206a3e129de16ea6e8e270c9eaa", + "name": "imagecodecs", + "sha256": "3681945d07197852d6821218b38763afa4a1eb16057234225cc923e39aaa124f", + "size": 6640495, + "subdir": "linux-64", + "timestamp": 1677577808062, + "version": "2021.8.26" + }, + "imagehash-4.3.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.10,<3.11.0a0", + "pywavelets", + "scipy" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e5f8f197c3fd889cdca8de964e8eb15e", + "name": "imagehash", + "sha256": "392e32772f979601b7101903250804fb672a7e3f50f22102d8aee216cee84899", + "size": 318366, + "subdir": "linux-64", + "timestamp": 1679418774806, + "version": "4.3.1" + }, + "imagehash-4.3.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.11,<3.12.0a0", + "pywavelets", + "scipy" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "2f0a7ede48861068c338f98b699148b8", + "name": "imagehash", + "sha256": "7d7e2835c73954514a50d4b08ff1c36c25c1b2e09bd5061f5e4baeece348de06", + "size": 324245, + "subdir": "linux-64", + "timestamp": 1679418704301, + "version": "4.3.1" + }, + "imagehash-4.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.8,<3.9.0a0", + "pywavelets", + "scipy" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "72c4d1fa12a767b57331c7443ddea672", + "name": "imagehash", + "sha256": "00f7610975049b9729c9170762b1437a1a4a035453378e662c80f6dd5e4161a4", + "size": 318536, + "subdir": "linux-64", + "timestamp": 1679418740480, + "version": "4.3.1" + }, + "imagehash-4.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.9,<3.10.0a0", + "pywavelets", + "scipy" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5edfb2d031b9051569cf570c12a2b2b4", + "name": "imagehash", + "sha256": "3e06ab9c1448628e36273cb43d0ca375f642764a5f5e5dd6df9063f76441ba7f", + "size": 318490, + "subdir": "linux-64", + "timestamp": 1679418808344, + "version": "4.3.1" + }, + "imageio-2.19.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=8.3.2", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "cd07c3e709ccbbea7adce45878f57bf7", + "name": "imageio", + "sha256": "1d072ffab100c6677ab03de6f9d2e3eb71321af45c89501d192b23cc755ff576", + "size": 3407920, + "subdir": "linux-64", + "timestamp": 1658785153453, + "version": "2.19.3" + }, + "imageio-2.19.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=8.3.2", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a9934a3053ef3e1ad0b9c47f8d1f0935", + "name": "imageio", + "sha256": "fee1d8311179a9d2c48a2741ffa586c8e2f7385384c42936f657e3d38272ad1a", + "size": 3537584, + "subdir": "linux-64", + "timestamp": 1677083672444, + "version": "2.19.3" + }, + "imageio-2.19.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=8.3.2", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "fcd2729cb054bd8d698e4204f0ec5888", + "name": "imageio", + "sha256": "910642b0b34cf7d495fcff9afc60d72d2bfebff98388d483243f5a0612f6b3ad", + "size": 3395169, + "subdir": "linux-64", + "timestamp": 1658785072600, + "version": "2.19.3" + }, + "imageio-2.19.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=8.3.2", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "393adce6ee29d61b68a72b21121c9226", + "name": "imageio", + "sha256": "7fff8868c968ddf174113ce47a388bf72a9317667e240246b479359255d0796b", + "size": 3396365, + "subdir": "linux-64", + "timestamp": 1658785109705, + "version": "2.19.3" + }, + "imageio-2.19.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=8.3.2", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "0b953cabab97ccb3963ca41c3c285c58", + "name": "imageio", + "sha256": "26ecd6429c5bf9f61aa2ae80afc5a47c607c0f9da26808781733e92e3a3e060d", + "size": 3396941, + "subdir": "linux-64", + "timestamp": 1658785185768, + "version": "2.19.3" + }, + "imageio-2.2.0-py27hf108a7f_0.conda": { + "build": "py27hf108a7f_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "1d78410b56db7ad177a9215ab79cbbf2", + "name": "imageio", + "sha256": "581417e1d52d0946a74d13f089c015aa3ff00ba3584ba0d0b54331acb7705136", + "size": 3255542, + "subdir": "linux-64", + "timestamp": 1505744538012, + "version": "2.2.0" + }, + "imageio-2.2.0-py35hd0a6de2_0.conda": { + "build": "py35hd0a6de2_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "594363667ed859f1fcfaf24b1fcc3e26", + "name": "imageio", + "sha256": "26950323c222bd74654fb6435e621841e48d2b924c27a81d201eae7107452003", + "size": 3260712, + "subdir": "linux-64", + "timestamp": 1505744554535, + "version": "2.2.0" + }, + "imageio-2.2.0-py36he555465_0.conda": { + "build": "py36he555465_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "dbcea51af7e0d1725feec40d25020051", + "name": "imageio", + "sha256": "13d4cb39df1abb9cc97cf77fd4325c27f9e2784277d4a4cff4f0ee77913c14da", + "size": 3255034, + "subdir": "linux-64", + "timestamp": 1505744571122, + "version": "2.2.0" + }, + "imageio-2.26.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=8.3.2", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f84c75bbc045903f2965afd55c333d32", + "name": "imageio", + "sha256": "5628b9629d5e796712b2caa6e6a69c12cf6c1cd80f2327e8c9ffd5736d033afc", + "size": 3465997, + "subdir": "linux-64", + "timestamp": 1677879669662, + "version": "2.26.0" + }, + "imageio-2.26.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=8.3.2", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "771dac37e2bcf5d3d2b9f39b6432308e", + "name": "imageio", + "sha256": "3c635a891296940eb2e72900a81a27a0d1975d6a2989a2fe73ae5ec3f67d82ed", + "size": 3559202, + "subdir": "linux-64", + "timestamp": 1677869340419, + "version": "2.26.0" + }, + "imageio-2.26.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=8.3.2", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c56defcc46c54fb4f8358d5bd5f1ff84", + "name": "imageio", + "sha256": "e65d2eac918ac160bdd8f3aa70e5ccf55145ad4d161e86748e84689706610cb2", + "size": 3452702, + "subdir": "linux-64", + "timestamp": 1677879594578, + "version": "2.26.0" + }, + "imageio-2.26.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=8.3.2", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "4929269dcb24e8227795f2b5de8c6c6e", + "name": "imageio", + "sha256": "ccc4b4597ca39f5df605e9e973ed0faccf60b1128ea51f24855d1af1f8d116b6", + "size": 3452909, + "subdir": "linux-64", + "timestamp": 1677879633168, + "version": "2.26.0" + }, + "imageio-2.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "ff3703709b824954ed0b370a2eb7f01d", + "name": "imageio", + "sha256": "ba99b36ae252273800640e3bec762e7f4a78f34bdd320042e9fb53b5fef8c2cb", + "size": 3326935, + "subdir": "linux-64", + "timestamp": 1522082081812, + "version": "2.3.0" + }, + "imageio-2.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "e4f05f2058b1b2a44edf31bc7f4ac46e", + "name": "imageio", + "sha256": "68e3676f343f122922ed5fc9ffadb9f869d22c0fb702be27cb5e77fa4ac99bd0", + "size": 3326723, + "subdir": "linux-64", + "timestamp": 1522082097340, + "version": "2.3.0" + }, + "imageio-2.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "b4def1d229f8ec0c898c4881ef77a191", + "name": "imageio", + "sha256": "5c375657e500b2d86383d481708982f9291caa4afbffd65bd4e88dbb854159c1", + "size": 3322217, + "subdir": "linux-64", + "timestamp": 1522082099186, + "version": "2.3.0" + }, + "imageio-2.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "b77013f61fca6507ddf7cd462516abad", + "name": "imageio", + "sha256": "b64cdfa93bfb760093e871fe9bc6e402936a2d4a51bc5ab81c7bc8383c111bbf", + "size": 3323039, + "subdir": "linux-64", + "timestamp": 1530793146155, + "version": "2.3.0" + }, + "imageio-2.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "9a4ca02c03ee9e713bd363223de74b90", + "name": "imageio", + "sha256": "9598b23a4896b4e654559c0d19fe302f08403797ae327a4bfcb194352dc56626", + "size": 3328735, + "subdir": "linux-64", + "timestamp": 1536699292992, + "version": "2.4.1" + }, + "imageio-2.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "540db838fc70c91a0a93e2926b17973a", + "name": "imageio", + "sha256": "baeb14f063a4d5545c2ab1744356014e1ff8297d0580c4c0895d01e306a9cf20", + "size": 3334637, + "subdir": "linux-64", + "timestamp": 1536699294688, + "version": "2.4.1" + }, + "imageio-2.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "0209064b807741dc59632469cc9a3ed8", + "name": "imageio", + "sha256": "b33d24c008465af460d088954310496282403eb893afab775c08c3b932c818db", + "size": 3326917, + "subdir": "linux-64", + "timestamp": 1536699298207, + "version": "2.4.1" + }, + "imageio-2.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "000b6c7892e2ebbb5472585114453d94", + "name": "imageio", + "sha256": "3246f47e4e203f9ddbd5a5939fc2131a27b6f1eec3f3e056c9811d86adabbeed", + "size": 3327761, + "subdir": "linux-64", + "timestamp": 1536699273402, + "version": "2.4.1" + }, + "imageio-2.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "067fd0f169b1150d5693c1a40083a907", + "name": "imageio", + "sha256": "1661f58c2da1e0c5ec5e067f417cdbb06280e2a394b7d6fa54841210843d4531", + "size": 3343355, + "subdir": "linux-64", + "timestamp": 1551139233003, + "version": "2.5.0" + }, + "imageio-2.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "746fa87f322e4418b50e94f195e88f61", + "name": "imageio", + "sha256": "fe6c7f7be5cda79dc14a6b8a18bb09f052bf7426bae238e66054ceefd471ee9c", + "size": 3344172, + "subdir": "linux-64", + "timestamp": 1551139326048, + "version": "2.5.0" + }, + "imageio-2.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "71f67feadaaf8f2e452e2e5e5f7d1449", + "name": "imageio", + "sha256": "a654826c597c81f14809dbc5adb13725c96210018df6e5df107aa7f7c0295b3a", + "size": 3338257, + "subdir": "linux-64", + "timestamp": 1551139235819, + "version": "2.5.0" + }, + "imageio-2.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "futures", + "numpy", + "pillow", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "5340c59b0772c8abb41a6f1b8e16cd7c", + "name": "imageio", + "sha256": "eec7f0d68b18e6f5eefe96c1f12181f1602f7f677a4542d34b925209ceaad54b", + "size": 3354125, + "subdir": "linux-64", + "timestamp": 1570464573473, + "version": "2.6.0" + }, + "imageio-2.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "426f9a9c6db568f0bdf23fe3e577e051", + "name": "imageio", + "sha256": "dade3f4904c45915784a295b15838b899b3105aec0c0c18d64b48498d249560e", + "size": 3352379, + "subdir": "linux-64", + "timestamp": 1570464585749, + "version": "2.6.0" + }, + "imageio-2.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "76c164d3f21ce6a2ac8dec9c1e252da7", + "name": "imageio", + "sha256": "8aeb2795319877dcbba37a7590d1914c6c4ff9748ca88614752c83e2d3657227", + "size": 3349206, + "subdir": "linux-64", + "timestamp": 1570464593756, + "version": "2.6.0" + }, + "imageio-2.6.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "futures", + "numpy", + "pillow", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "2a894e3205bf65ab380fa1083355c66d", + "name": "imageio", + "sha256": "c781a38f54550b10331fc9123b6004d71a752aa0dfbec557de77a027f3e2883a", + "size": 3354238, + "subdir": "linux-64", + "timestamp": 1571761258337, + "version": "2.6.1" + }, + "imageio-2.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "38d7fd0c1937a1f7ed8d1a1c63fc9ed9", + "name": "imageio", + "sha256": "0c0f046e61f5d7d88677a69c2d322f5d7a82cd9b637f0f68b778d74413c470b5", + "size": 3352494, + "subdir": "linux-64", + "timestamp": 1571761291154, + "version": "2.6.1" + }, + "imageio-2.6.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "c79e4b4e307df6dc8dbe99607ad05284", + "name": "imageio", + "sha256": "0a78b9a5de36710ea95e1998fb62f35e64cd54112df60dc49c03f71cfe7542c6", + "size": 3349847, + "subdir": "linux-64", + "timestamp": 1571761257266, + "version": "2.6.1" + }, + "imageio-2.6.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "8cc3c5badf41654c2cee07b6606e79dc", + "name": "imageio", + "sha256": "3d5c63902e16392adc498c131e2a8ae8b9fec34c085269bdd418761bc9625e91", + "size": 3349327, + "subdir": "linux-64", + "timestamp": 1574157898960, + "version": "2.6.1" + }, + "imagesize-0.7.1-py27hd17bf80_0.conda": { + "build": "py27hd17bf80_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "bb2f0fc504eba6df7cdf63646644d9ea", + "name": "imagesize", + "sha256": "34cebdf133d224cad8742814b0acb0276d66f869e163101140801e00569ccd8e", + "size": 6266, + "subdir": "linux-64", + "timestamp": 1505744587169, + "version": "0.7.1" + }, + "imagesize-0.7.1-py35hf008fae_0.conda": { + "build": "py35hf008fae_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "98846a4b7109cb9770a5ae8c92fa14db", + "name": "imagesize", + "sha256": "7d8d5237bb21c2eafb1b1cd4cb366be66c3c5744aafedb26126d75d4380e8502", + "size": 6357, + "subdir": "linux-64", + "timestamp": 1505744599862, + "version": "0.7.1" + }, + "imagesize-0.7.1-py36h52d8127_0.conda": { + "build": "py36h52d8127_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8ffd4fb0048370671ed7bb8058f973dc", + "name": "imagesize", + "sha256": "92ab458f1832a80d6acdc02f294dd8ee6682ab4007506eba1f5584c4d4a52348", + "size": 6333, + "subdir": "linux-64", + "timestamp": 1505744612732, + "version": "0.7.1" + }, + "imagesize-1.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "bd2207e32a387809732baf0ccc058790", + "name": "imagesize", + "sha256": "8b644d9273eebb8a7fac2db120be431de63f5a2b827011b818d2aa6f5106726c", + "size": 8548, + "subdir": "linux-64", + "timestamp": 1519153057710, + "version": "1.0.0" + }, + "imagesize-1.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "402ee802de0b30145e85d871b552224e", + "name": "imagesize", + "sha256": "94025802dab4a58e2099fcf7050c11868f1471061d69f209d222fc35fcfb1541", + "size": 8655, + "subdir": "linux-64", + "timestamp": 1519153054425, + "version": "1.0.0" + }, + "imagesize-1.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e796b4944979db17f708214d87affd0c", + "name": "imagesize", + "sha256": "c2d75a67c90268deb1f8f155165ca42593ad2aaa641a713e6232f937e2c49bbb", + "size": 8609, + "subdir": "linux-64", + "timestamp": 1519153009294, + "version": "1.0.0" + }, + "imagesize-1.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1671ad2e35e5def35806e1666bd18e74", + "name": "imagesize", + "sha256": "f600a431e380819bdbe49ec7331ff6f1f6e2d1b05ba8192b5e217824cec8ec26", + "size": 8457, + "subdir": "linux-64", + "timestamp": 1530695243157, + "version": "1.0.0" + }, + "imagesize-1.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "29c4641905eda1562fe335b241cbdf01", + "name": "imagesize", + "sha256": "7abd7e2b1ce3e4fdc846453fa362a11d58cf58fb4d63eb677b612df37ab30530", + "size": 9474, + "subdir": "linux-64", + "timestamp": 1536074331532, + "version": "1.1.0" + }, + "imagesize-1.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "75101b50d75bba9eba1255ddf15e3d31", + "name": "imagesize", + "sha256": "f64d65d51bf3d115fe5341f48fee289a7d53607b6fe8fd7eb1d8648a952d12d4", + "size": 9554, + "subdir": "linux-64", + "timestamp": 1536074353217, + "version": "1.1.0" + }, + "imagesize-1.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c2aa6d0e05509a0418a9618e17e506dd", + "name": "imagesize", + "sha256": "157f218f91cd98ae6ae5169f2ac6e5b6aa693682eba17f97881c825c16b47a09", + "size": 9536, + "subdir": "linux-64", + "timestamp": 1536074305437, + "version": "1.1.0" + }, + "imagesize-1.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4af54daea1db439b3095c6ee9f08ce5d", + "name": "imagesize", + "sha256": "9e7e96315a5e501acbd1ac20b0b57e4bd8966866e57412f008d59f871f320cb0", + "size": 9456, + "subdir": "linux-64", + "timestamp": 1536074354238, + "version": "1.1.0" + }, + "imagesize-1.4.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31935cd380a5bd6e42694f23b3775a0a", + "name": "imagesize", + "sha256": "511bcc21ab89d5d00bce7bcad49250b67abc3e8a4b038205a072eda07da3ad14", + "size": 13568, + "subdir": "linux-64", + "timestamp": 1657179640057, + "version": "1.4.1" + }, + "imagesize-1.4.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1336aeeee49deaee844b31324ce0a16", + "name": "imagesize", + "sha256": "6a6cd65e5e04645198d9e0a064161c03070f592c48a509422d4c8c8ae78c6463", + "size": 17357, + "subdir": "linux-64", + "timestamp": 1676830841315, + "version": "1.4.1" + }, + "imagesize-1.4.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ae5612ce187b2b4bedec85301675784", + "name": "imagesize", + "sha256": "cecef91667467cc2547a7fe21e5e105a1a45184b4461e09398810d277381d46b", + "size": 13390, + "subdir": "linux-64", + "timestamp": 1657179573348, + "version": "1.4.1" + }, + "imagesize-1.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7f5dec0d40bc523d3c8ae28a0b49d53", + "name": "imagesize", + "sha256": "7dc80ce3e02bdefd347c5a63dc331cd4ce5cab454627a6955e6197df62a32147", + "size": 13349, + "subdir": "linux-64", + "timestamp": 1657179542889, + "version": "1.4.1" + }, + "imagesize-1.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "daa11cdf95b501d5cd35edcaeaaa3fdc", + "name": "imagesize", + "sha256": "1fa7e67d3012af4993061fe3aa30243ab693ee2245d62c703dbf4a8b8e0c0e14", + "size": 13426, + "subdir": "linux-64", + "timestamp": 1657179601801, + "version": "1.4.1" + }, + "imbalanced-learn-0.10.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "joblib >=1.1.1", + "numpy", + "python >=3.10,<3.11.0a0", + "scikit-learn >=1.0.2", + "scipy >=1.3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "586e7db36b5022b041b91d33fccd2de6", + "name": "imbalanced-learn", + "sha256": "8470566416b5cf3206e1170872133e405fbfedbce5ea0e5e602937452380b738", + "size": 286452, + "subdir": "linux-64", + "timestamp": 1677191754591, + "version": "0.10.1" + }, + "imbalanced-learn-0.10.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "joblib >=1.1.1", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn >=1.0.2", + "scipy >=1.3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58712c9f149c75f6b984f2738ff1a8b9", + "name": "imbalanced-learn", + "sha256": "9acf09ff70ab6f0bd116990cbc618fb4527aa207769e4f7e3f61650e118ad9df", + "size": 283697, + "subdir": "linux-64", + "timestamp": 1677191597309, + "version": "0.10.1" + }, + "imbalanced-learn-0.10.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "joblib >=1.1.1", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn >=1.0.2", + "scipy >=1.3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8dcb9ae650c47a0c6563bfe4ec84ef96", + "name": "imbalanced-learn", + "sha256": "a0bfb295f8151db47005256b7749fd13a74b82a25f6888fc0b99c4986f46e537", + "size": 283466, + "subdir": "linux-64", + "timestamp": 1677191906932, + "version": "0.10.1" + }, + "iminuit-1.2-py27h30ba22a_0.conda": { + "build": "py27h30ba22a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "32fca35a8657ae38b05cb6b2dba4a20b", + "name": "iminuit", + "sha256": "eca569d7f2cce7d327e661af29d5d81cef581f9d695a976c2166aa020609f9d0", + "size": 401513, + "subdir": "linux-64", + "timestamp": 1508269264786, + "version": "1.2" + }, + "iminuit-1.2-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "d6c24850c4a565eb22ea9119340393e2", + "name": "iminuit", + "sha256": "e43d4e2817e3960ea59df3956d5e23d1a6d92b56fff87ee28431045f77bea590", + "size": 425597, + "subdir": "linux-64", + "timestamp": 1530897313188, + "version": "1.2" + }, + "iminuit-1.2-py35hd0651ea_0.conda": { + "build": "py35hd0651ea_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "fc288c4033178b6b531ba66f18a0f19d", + "name": "iminuit", + "sha256": "90003155e2513f3ef9d35f53fe06c39c05473bf4acf423bfaef987eb6f170222", + "size": 402459, + "subdir": "linux-64", + "timestamp": 1508269258504, + "version": "1.2" + }, + "iminuit-1.2-py36h393febe_0.conda": { + "build": "py36h393febe_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "6d817219aaab8e08143129425ec38b57", + "name": "iminuit", + "sha256": "18f98d21c480f61db24e92a677202c766f192fca67daa0dbf8dafd1046ff9e95", + "size": 401336, + "subdir": "linux-64", + "timestamp": 1508269278552, + "version": "1.2" + }, + "iminuit-1.2-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "3f1c6af9a1d20d57a8ed926c2aecf82e", + "name": "iminuit", + "sha256": "3dfd476a2422ff715a2f1206f0900bb9c3061946e29a40d9da19f0deb26ec9cf", + "size": 430770, + "subdir": "linux-64", + "timestamp": 1530897412991, + "version": "1.2" + }, + "iminuit-1.2-py37hf484d3e_0.conda": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "767f44b029ccb6cefdc079111977f8f9", + "name": "iminuit", + "sha256": "87d97e34907218cacd8116ed768f0002f5213a566584a8c8d3de12cfca153e68", + "size": 429722, + "subdir": "linux-64", + "timestamp": 1530897513102, + "version": "1.2" + }, + "iminuit-1.3.2-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "7409312d241f6090782e193c94e5d29d", + "name": "iminuit", + "sha256": "8a671445d0630f80e1418279bd9732be236ea5c9c3d46a200410a4770b26041c", + "size": 389572, + "subdir": "linux-64", + "timestamp": 1536113223982, + "version": "1.3.2" + }, + "iminuit-1.3.2-py35h962f231_0.conda": { + "build": "py35h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "b6dab840a0c0499753cf09fac44be53d", + "name": "iminuit", + "sha256": "b16bae0a7eca6cc8f41d5b46ab972428ef66bfec0467248c470ade313c6c914e", + "size": 391243, + "subdir": "linux-64", + "timestamp": 1536113108228, + "version": "1.3.2" + }, + "iminuit-1.3.2-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "47a09730cf890164c7c1bd76d16b3919", + "name": "iminuit", + "sha256": "25eb62ada45968286f0cb1f8f21256a3bd470d309222ec5ed8009f8e91776913", + "size": 396320, + "subdir": "linux-64", + "timestamp": 1536113024988, + "version": "1.3.2" + }, + "iminuit-1.3.2-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "46564b8586a3a88b1f71c5dabb2357d5", + "name": "iminuit", + "sha256": "ec6b561d85ccbfb96e4dc184551bdf58aae4315ee72717e45cb3d9d73c91434e", + "size": 393054, + "subdir": "linux-64", + "timestamp": 1536113255344, + "version": "1.3.2" + }, + "iminuit-1.3.3-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "f8b2a1d72f96992e6653ae2db19d5f1b", + "name": "iminuit", + "sha256": "6ff3228f3edd0ba8979717d5933c2357c9f7b7c12a7d5856e5c4ac13c531b475", + "size": 385424, + "subdir": "linux-64", + "timestamp": 1538180486411, + "version": "1.3.3" + }, + "iminuit-1.3.3-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "17b3d9916ea7472747b4e6d1dbe51ea0", + "name": "iminuit", + "sha256": "a73ee22b70b571ee4111f6fd0064e59faa1b7755b6a133f896217ad5eb2ebc0e", + "size": 388320, + "subdir": "linux-64", + "timestamp": 1538180465756, + "version": "1.3.3" + }, + "iminuit-1.3.3-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "1346cb7686f5a34239275bd321221bd8", + "name": "iminuit", + "sha256": "ee9f74628fd65f9cd2a875327a8746d119ab0cf2cc495ec5fcdb4773bb49d9d2", + "size": 387160, + "subdir": "linux-64", + "timestamp": 1538180538381, + "version": "1.3.3" + }, + "iminuit-1.3.7-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "390533215df0ae0b83b1bb67098be371", + "name": "iminuit", + "sha256": "ebb75b4a7f97a47c392c9d6b92aaf8eb047ad41730b4bc8e471b1676bde64ebf", + "size": 384478, + "subdir": "linux-64", + "timestamp": 1569369039644, + "version": "1.3.7" + }, + "iminuit-1.3.7-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "4a4e92d8699569b6853da6ba5a5657ea", + "name": "iminuit", + "sha256": "b3be0762c2097305e0d7aca78c5fbfb675e36f39d73cdd3762fc02ed4fd5a381", + "size": 391577, + "subdir": "linux-64", + "timestamp": 1569369091317, + "version": "1.3.7" + }, + "iminuit-1.3.7-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "e18477dc92cb90f09a23c492d6b42a6b", + "name": "iminuit", + "sha256": "8dec37a853048a10d74044c8a8561c7603ef73515055ff4d006b6a8f679c1a4b", + "size": 390925, + "subdir": "linux-64", + "timestamp": 1569369085911, + "version": "1.3.7" + }, + "iminuit-1.3.7-py38h962f231_0.conda": { + "build": "py38h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "9981ca08164c7deea6a29465a10ee146", + "name": "iminuit", + "sha256": "1aa625292982f334fc13a981c7c3e5109d67c1d6ce4dd66a0e36bd533bf378e0", + "size": 399129, + "subdir": "linux-64", + "timestamp": 1572621902709, + "version": "1.3.7" + }, + "iminuit-1.3.8-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "95ca6636bda20ceb9836c584e45a487e", + "name": "iminuit", + "sha256": "634bbf0d715870f20af81d57b455e4c0c1d1af35c7211a81d57f8c6cb491e4c7", + "size": 389163, + "subdir": "linux-64", + "timestamp": 1573966101570, + "version": "1.3.8" + }, + "iminuit-1.3.8-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "fe79547f8f793c67ecab1d5baf6d5eef", + "name": "iminuit", + "sha256": "73b25b91d53570c0ed9ba07fbcd121b408fe0b7dfb164d545ba323afc3f822d6", + "size": 396504, + "subdir": "linux-64", + "timestamp": 1573966080824, + "version": "1.3.8" + }, + "iminuit-1.3.8-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "96eabeca62ccb3e4991822ab7eeffc8a", + "name": "iminuit", + "sha256": "ef80675f5ae97ac91629cbcf93911728082465e50f74dd069d9f74df5f08b18b", + "size": 395523, + "subdir": "linux-64", + "timestamp": 1573966076600, + "version": "1.3.8" + }, + "iminuit-1.3.8-py38h962f231_0.conda": { + "build": "py38h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "1562cbff04aaa8672579f99b42108631", + "name": "iminuit", + "sha256": "a1bcff0b3b7fb45167e0abfacd33049de7558ed90af97bfa38e812cdbf990525", + "size": 405376, + "subdir": "linux-64", + "timestamp": 1573966109417, + "version": "1.3.8" + }, + "iminuit-1.4.2-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "a14a94cebab0d9d1baf8f2e9977dab66", + "name": "iminuit", + "sha256": "048c90d558ebf93102d6a59a5caac8db6dfdd855b46df42724753256dba3879c", + "size": 415708, + "subdir": "linux-64", + "timestamp": 1592228706118, + "version": "1.4.2" + }, + "iminuit-1.4.2-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "c3ab325371323b78101282ba31ec2a84", + "name": "iminuit", + "sha256": "e97e2ade6460fb1a98911291d4a24cd0aea6b8138bd8cb38f5667497616f806e", + "size": 414242, + "subdir": "linux-64", + "timestamp": 1592228685062, + "version": "1.4.2" + }, + "iminuit-1.4.2-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "bc6eab291a52c19f6a6e7b7e49f4fe9b", + "name": "iminuit", + "sha256": "35857bea3893ba7d47add9b3bd0014aa2f7361602310dcddca27bfd9a8cfa703", + "size": 425088, + "subdir": "linux-64", + "timestamp": 1592228681060, + "version": "1.4.2" + }, + "iminuit-1.4.9-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "c67b6d492526324e5c87deabbe18d53e", + "name": "iminuit", + "sha256": "5308f89540f6c675612e504d00f0714fc732ecd66f9be52ddfd2b10cf7dfd8a7", + "size": 420512, + "subdir": "linux-64", + "timestamp": 1600361325730, + "version": "1.4.9" + }, + "iminuit-1.4.9-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "5d12711b2a732aea8c9a6a2f96c2b9d2", + "name": "iminuit", + "sha256": "a0f4b4b2cfab7cd94bd17fdf762731ed7d453649ca8f10f0ac4f3019375ac902", + "size": 419913, + "subdir": "linux-64", + "timestamp": 1600361285150, + "version": "1.4.9" + }, + "iminuit-1.4.9-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "e3a6c66e6daa9a3432d2fc58e82b8aab", + "name": "iminuit", + "sha256": "999a3154b6180d7d62e08d16dcded34aae8db6ba4fb8bcac39b67e16ee774989", + "size": 432832, + "subdir": "linux-64", + "timestamp": 1600361303247, + "version": "1.4.9" + }, + "iminuit-1.5.0-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "fa63994695bdb413e54fbde0305485ee", + "name": "iminuit", + "sha256": "0bfd9a329dac9f0bc5c5f138dbc37bc4768fb50b917e195c8c9c0d6394e58523", + "size": 421523, + "subdir": "linux-64", + "timestamp": 1600379491703, + "version": "1.5.0" + }, + "iminuit-1.5.0-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "4fd09a89b60857e62be3cfef9c764387", + "name": "iminuit", + "sha256": "b7b97737cad0983958a228c6ca5e4be2a9f928514c6de284f398cd5c8a02a8ae", + "size": 420367, + "subdir": "linux-64", + "timestamp": 1600379491690, + "version": "1.5.0" + }, + "iminuit-1.5.0-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "e16eada5de9d2feb72c3b17fa0769761", + "name": "iminuit", + "sha256": "8b2efbfc89d3a596411b51174151a22ee2fa1aa34452086ca772bd2c64250abe", + "size": 432008, + "subdir": "linux-64", + "timestamp": 1600379477858, + "version": "1.5.0" + }, + "iminuit-1.5.1-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "ab4416f70eaa11f186a429b6de75a5cb", + "name": "iminuit", + "sha256": "0da38e3b6e93a0b6b185299153a21a956d39394a94c693c237f54e22bc0ae06e", + "size": 423413, + "subdir": "linux-64", + "timestamp": 1600701647933, + "version": "1.5.1" + }, + "iminuit-1.5.1-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "44fe5e5fe8d8d7ead41ae9f04861af4c", + "name": "iminuit", + "sha256": "e9f0bc3c4301279e82f3bae3a8505ca03c0f9b190d28c2592a34004b2431f24a", + "size": 419898, + "subdir": "linux-64", + "timestamp": 1600701621774, + "version": "1.5.1" + }, + "iminuit-1.5.1-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "1c05f13c24c23e8be3e9853e87f06cc0", + "name": "iminuit", + "sha256": "acb37651014026d42f38e4e5ddbd7b606dd843593030e3d345794c96f4967474", + "size": 433879, + "subdir": "linux-64", + "timestamp": 1600701622404, + "version": "1.5.1" + }, + "iminuit-1.5.2-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "073cd1892d56305b8eb0bfc7fbbe9cc0", + "name": "iminuit", + "sha256": "8136daa75a33f103ed6024d88fb6227137c1e6bc5e684e7fab3641a2e226ae12", + "size": 421143, + "subdir": "linux-64", + "timestamp": 1600967561535, + "version": "1.5.2" + }, + "iminuit-1.5.2-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "1e7e7f972a33ad3fbf5c584678f5ebdb", + "name": "iminuit", + "sha256": "73c4945673bc547dd68e07860139ffe6482c906f75328c53b7ad3b429221d464", + "size": 421913, + "subdir": "linux-64", + "timestamp": 1600962133833, + "version": "1.5.2" + }, + "iminuit-1.5.2-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "039620135c984d1d8e801f2545998904", + "name": "iminuit", + "sha256": "d0806de7ddd751ad66da5419338c9004027ab7e4e65c17819e671238272eb5f7", + "size": 432888, + "subdir": "linux-64", + "timestamp": 1600967550148, + "version": "1.5.2" + }, + "iminuit-1.5.4-py36ha9443f7_0.conda": { + "build": "py36ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "d512c571089a064db2db4f5e484bb9e1", + "name": "iminuit", + "sha256": "59fe4460bbe4e121c92752e6cb7e75a6a9ad6a858807b210ae44e50539be32a5", + "size": 419453, + "subdir": "linux-64", + "timestamp": 1606145751585, + "version": "1.5.4" + }, + "iminuit-1.5.4-py37ha9443f7_0.conda": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "0a60224a26048b5da05984fb2619dc80", + "name": "iminuit", + "sha256": "cb4161e1b4e931b61a4b68eeee1ea017849ba0b29f522a76dc9b40ca16f1fa6d", + "size": 418360, + "subdir": "linux-64", + "timestamp": 1606145753720, + "version": "1.5.4" + }, + "iminuit-1.5.4-py38ha9443f7_0.conda": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL v2", + "license_family": "LGPL", + "md5": "6eecd095d89b5fe1c6c752764b23c6e0", + "name": "iminuit", + "sha256": "18da88302df2d29b9e3cdcbf4187021593b0d97214541318f137e4ea2a70ae6b", + "size": 428953, + "subdir": "linux-64", + "timestamp": 1606145754467, + "version": "1.5.4" + }, + "iminuit-2.18.0-py310h1128e8f_0.conda": { + "build": "py310h1128e8f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "6c4b9a9cd211a13546c94ac776b06aac", + "name": "iminuit", + "sha256": "485c9bab1df1bf690a9705b004ce06c75d3fa1adcced7373d0f74225c86decb9", + "size": 420505, + "subdir": "linux-64", + "timestamp": 1674746701738, + "version": "2.18.0" + }, + "iminuit-2.18.0-py311hba01205_0.conda": { + "build": "py311hba01205_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "fef52bfe81346eb4c48d079d45479033", + "name": "iminuit", + "sha256": "1f2021ee73bed2bd8695496d92d6f64110d50d5dad9b2afb4482cba654c457e4", + "size": 420708, + "subdir": "linux-64", + "timestamp": 1676852821156, + "version": "2.18.0" + }, + "iminuit-2.18.0-py37h417a72b_0.conda": { + "build": "py37h417a72b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "7ee77a6944ec611001ff54117f8fc15b", + "name": "iminuit", + "sha256": "f2326b79c3d9bbdd22a386d316ad58b1b1999d22b2ec0db7571ba6df8dfa6adf", + "size": 432317, + "subdir": "linux-64", + "timestamp": 1674746622311, + "version": "2.18.0" + }, + "iminuit-2.18.0-py38h417a72b_0.conda": { + "build": "py38h417a72b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "5962c32c737a2727d325907820b622e6", + "name": "iminuit", + "sha256": "aea722944f7af8de8b65564bbb0f1dc2696c97801bfb498b7473b7d98a3cbe84", + "size": 419190, + "subdir": "linux-64", + "timestamp": 1674746780504, + "version": "2.18.0" + }, + "iminuit-2.18.0-py39h417a72b_0.conda": { + "build": "py39h417a72b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "0514257eb895eb9e308337657ceb66c6", + "name": "iminuit", + "sha256": "120c87538024738abdb0a8cf9a67b8d9179b4dbbb646260e095993485ec42a9f", + "size": 420319, + "subdir": "linux-64", + "timestamp": 1674746860422, + "version": "2.18.0" + }, + "iminuit-2.2.0-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "ddeb1dcdc6d87b991a1e619142458d6c", + "name": "iminuit", + "sha256": "47d451caa94f7b3315237a0b4ce95c2dc29e8cc5bd8733aa5d600becfbac4300", + "size": 298775, + "subdir": "linux-64", + "timestamp": 1608650636987, + "version": "2.2.0" + }, + "iminuit-2.2.0-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "889b28381d72d15fae6885e743229792", + "name": "iminuit", + "sha256": "5e8bb2be19812ee74f7f91675d433fc7144563f6380c5d0d1d121a0b10aeeb3f", + "size": 298169, + "subdir": "linux-64", + "timestamp": 1608650659260, + "version": "2.2.0" + }, + "iminuit-2.2.0-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "f4ecded0adae1d112c9a43caac156b20", + "name": "iminuit", + "sha256": "923e4993ac3e2361c225978ca493fe4ddb0ebbd5cbf736186c3c9d8d28324acb", + "size": 299559, + "subdir": "linux-64", + "timestamp": 1608650667481, + "version": "2.2.0" + }, + "iminuit-2.2.0-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "db58f80aa79447268c50ecd4e330b68f", + "name": "iminuit", + "sha256": "8d3b24ebb145eb1ab4aca5b114c8b16cd213559fc4e3e6567302ab1a59e8a168", + "size": 299156, + "subdir": "linux-64", + "timestamp": 1608650689736, + "version": "2.2.0" + }, + "iminuit-2.4.0-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "0e3ca23dc4f1d73ed426042f166e7c77", + "name": "iminuit", + "sha256": "293827b491847d733a857fd1f0aa77d49ecd1dda022c434f057d4249c4512d2a", + "size": 300863, + "subdir": "linux-64", + "timestamp": 1619185894667, + "version": "2.4.0" + }, + "iminuit-2.4.0-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "f4cb974e568dc57ef48c3c761a016eca", + "name": "iminuit", + "sha256": "b9cf88c379b98351b8fdf17be328747cb853041e0fbe5a58755bbb76117be444", + "size": 301448, + "subdir": "linux-64", + "timestamp": 1619189387973, + "version": "2.4.0" + }, + "iminuit-2.4.0-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "5a5dcee67ca8e0c1aa5a6c288568e515", + "name": "iminuit", + "sha256": "1e463bd1f4d58c0f556bf4126fa63f1cff8e656d48c5c9440d76b0d1dd431027", + "size": 301172, + "subdir": "linux-64", + "timestamp": 1619189386842, + "version": "2.4.0" + }, + "iminuit-2.4.0-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "da2f7190aefc7adb3797406be4358071", + "name": "iminuit", + "sha256": "aa89c798f60910135227fc4b8c6bc4f4ad3d88588d3943593e27aa1d0d2e4b42", + "size": 301047, + "subdir": "linux-64", + "timestamp": 1619188934070, + "version": "2.4.0" + }, + "iminuit-2.6.0-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "d2ce81985ae745954afd90934a6ebaa5", + "name": "iminuit", + "sha256": "0a06e98488df199ededf880cc851c0e1d91ff4dad5291bc9872340e47bc6baa3", + "size": 306861, + "subdir": "linux-64", + "timestamp": 1619997415121, + "version": "2.6.0" + }, + "iminuit-2.6.0-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "aa19302a729055cea764c68cd7e2c592", + "name": "iminuit", + "sha256": "b78698d2a15424d3a9ac65295f95b8dcc395bbe346503c35c04415c1f208f122", + "size": 306884, + "subdir": "linux-64", + "timestamp": 1619997420037, + "version": "2.6.0" + }, + "iminuit-2.6.0-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "fc73f8b5c9a9cd9b0631880bb8fd94c2", + "name": "iminuit", + "sha256": "b972ae1c550990aca1576b4924c4fb30818c50f2c8ddd9f83eb49ec8b877f1bc", + "size": 307399, + "subdir": "linux-64", + "timestamp": 1619997412382, + "version": "2.6.0" + }, + "iminuit-2.6.0-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "b8a5d0b34e78535cd89e5c409eb13e76", + "name": "iminuit", + "sha256": "c0a25b2a8e3a382fa06dcac6020e1da4c5f54614cc74aca27bf65d357023f226", + "size": 308132, + "subdir": "linux-64", + "timestamp": 1619997410514, + "version": "2.6.0" + }, + "iminuit-2.6.1-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "66dfd8d867af13abdae37ab698291c2c", + "name": "iminuit", + "sha256": "2667be3ea3139b7c66928ff2f99a98d97e9bcc834479f4535be7f89ddcd3e776", + "size": 309404, + "subdir": "linux-64", + "timestamp": 1620999511151, + "version": "2.6.1" + }, + "iminuit-2.6.1-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "5c3974965428e27f8ae0b43460f770de", + "name": "iminuit", + "sha256": "c4ddc42b925d201281947397c2dfdfbc0e634d23492411321476da4b5699039f", + "size": 309260, + "subdir": "linux-64", + "timestamp": 1621000095437, + "version": "2.6.1" + }, + "iminuit-2.6.1-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "3b89699144930d424960a4dc75810eac", + "name": "iminuit", + "sha256": "c7dcceea6397753d032ce6d1df3699d544190fbe1c3b0b8fd5aabb7cfd205a8e", + "size": 311756, + "subdir": "linux-64", + "timestamp": 1620999506674, + "version": "2.6.1" + }, + "iminuit-2.6.1-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "66ea021f6a400884bac1c9439855397e", + "name": "iminuit", + "sha256": "2d6502bdc661b8abfa2d78ae4fdc24349e66ea33364319bf608b0245b969e41e", + "size": 312039, + "subdir": "linux-64", + "timestamp": 1621244792845, + "version": "2.6.1" + }, + "iminuit-2.6.1-py39ha9443f7_0.conda": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "a917c60ff45f8360d54f9110bc3a8dec", + "name": "iminuit", + "sha256": "786c7e122a334f5c3295a13ba4a5377e6c1ccac8ec6bb886cc5e7cc933ab4021", + "size": 311149, + "subdir": "linux-64", + "timestamp": 1621248270916, + "version": "2.6.1" + }, + "iminuit-2.7.0-py36h295c915_0.conda": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "14ffcd424a0f860e254ca2697946cee5", + "name": "iminuit", + "sha256": "773686412ccef12f80069acd5233e1ea3d5024883b1efa6d7cf8459ac020ff4e", + "size": 322341, + "subdir": "linux-64", + "timestamp": 1625730141216, + "version": "2.7.0" + }, + "iminuit-2.7.0-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "e9e900138e7976d2a3abde6b3f0ccdbd", + "name": "iminuit", + "sha256": "d324eb379baf54103c11c68af7c80d8569ee82470922915c1cdb42350a61ec50", + "size": 324153, + "subdir": "linux-64", + "timestamp": 1625751163511, + "version": "2.7.0" + }, + "iminuit-2.7.0-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "cfc382889eb5e641074c329916992093", + "name": "iminuit", + "sha256": "8fc5329363a1a2a15bfcb93704379442356af1adadd2d2eb56939c4291d8cd03", + "size": 324387, + "subdir": "linux-64", + "timestamp": 1625730111345, + "version": "2.7.0" + }, + "iminuit-2.7.0-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "79b594d304e786b5861ed30daf98672e", + "name": "iminuit", + "sha256": "80934d910aac6077d52b0898ac4c843d04cd88cabc4c1044b872e2254eeb1298", + "size": 322636, + "subdir": "linux-64", + "timestamp": 1625730125595, + "version": "2.7.0" + }, + "iminuit-2.8.4-py310h00e6091_0.conda": { + "build": "py310h00e6091_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "c466694b45cfb2e06d90cabaa9822c87", + "name": "iminuit", + "sha256": "867895fe5ff8878763c84cfba0b350d1aef801e8fa9cc4a6a7f3f8e34ab9d568", + "size": 328125, + "subdir": "linux-64", + "timestamp": 1640790998430, + "version": "2.8.4" + }, + "iminuit-2.8.4-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "a2ed47d7a2d646d9ed2934f259719164", + "name": "iminuit", + "sha256": "4abbe4381d119753c8cd80c335e3d21f84c32b8ea4817cc875a649c45003534b", + "size": 328840, + "subdir": "linux-64", + "timestamp": 1638708998377, + "version": "2.8.4" + }, + "iminuit-2.8.4-py37h51133e4_0.conda": { + "build": "py37h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "e4cc4df005d6b34da8545e52ca93f1e8", + "name": "iminuit", + "sha256": "b93ad7cf4e4a1b70e23a7dbd909b694f4aa707475474e233e94e082d3f88f5c3", + "size": 328325, + "subdir": "linux-64", + "timestamp": 1638960151390, + "version": "2.8.4" + }, + "iminuit-2.8.4-py38h51133e4_0.conda": { + "build": "py38h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "a39731a9083bb286ce6d3682e8f0bece", + "name": "iminuit", + "sha256": "c1ec12a41397071bdc311b8c8431058366bdb1c0be118b7a00827f6b10b9d559", + "size": 329487, + "subdir": "linux-64", + "timestamp": 1638960073391, + "version": "2.8.4" + }, + "iminuit-2.8.4-py39h51133e4_0.conda": { + "build": "py39h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-or-later AND MIT", + "license_family": "LGPL", + "md5": "bcddb68d03e5fd4d8dc338c7dbd901fd", + "name": "iminuit", + "sha256": "05c2a333b4bc113285d659505826f8c4028272820408f703fc9f4b1749fbbce3", + "size": 329371, + "subdir": "linux-64", + "timestamp": 1638959999055, + "version": "2.8.4" + }, + "immutables-0.11-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e6ad777e4ed1c27578008f0e15e3424c", + "name": "immutables", + "sha256": "fc534acf3347d486fbb00151f954a725b92e0fbe8f8413dc1002c9cbc4734f78", + "size": 65490, + "subdir": "linux-64", + "timestamp": 1585075320037, + "version": "0.11" + }, + "immutables-0.11-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8063a3b1e4579e0189a532f5fb758dcb", + "name": "immutables", + "sha256": "fa7c9ba5d2c79ba326a5cd2c6fe2f34aef987e78e7509d15cfb1751327b35419", + "size": 65430, + "subdir": "linux-64", + "timestamp": 1585075322507, + "version": "0.11" + }, + "immutables-0.11-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "845296395e2f2c9a99ea9f32be751a7e", + "name": "immutables", + "sha256": "802430d0fdbf9c7f54ed3fb7bd805682fd8a8c86932481f871c235d3e502661c", + "size": 65667, + "subdir": "linux-64", + "timestamp": 1585075345952, + "version": "0.11" + }, + "immutables-0.14-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7f3d4bc7779b7785944fb197bb8443ba", + "name": "immutables", + "sha256": "c56dac395949c93c6da35cf6ecf7ff64b8d47eef8080ef4629095d121c3291e7", + "size": 71133, + "subdir": "linux-64", + "timestamp": 1613500317110, + "version": "0.14" + }, + "immutables-0.14-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "529e4f470993765d3b6f26c21ea9f154", + "name": "immutables", + "sha256": "2c5b63623ec1e085bd7560fd985f57af9b85a22b99f9c3055b633f8725f748fb", + "size": 71291, + "subdir": "linux-64", + "timestamp": 1592426033717, + "version": "0.14" + }, + "immutables-0.14-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "40b191d5423a1a0ce0b620dec0310ef4", + "name": "immutables", + "sha256": "7a11aa84a83972a79aa08f7c829beaae3b209d6901f2f7b2a5ba630901e8fa6f", + "size": 71341, + "subdir": "linux-64", + "timestamp": 1613500943714, + "version": "0.14" + }, + "immutables-0.14-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "856691c619037500be94a1e664649c99", + "name": "immutables", + "sha256": "005e7a554ac61a0503c1f092f247ff861e41492dcdc62b80daa606866200c4d7", + "size": 70776, + "subdir": "linux-64", + "timestamp": 1592426029434, + "version": "0.14" + }, + "immutables-0.14-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "35cbbc2520cd2cc9850ec367c1c5d10c", + "name": "immutables", + "sha256": "5a4cf3f185908f049fffabe74281d89f83d91434c0b0c55ab100709b2a69fca4", + "size": 72000, + "subdir": "linux-64", + "timestamp": 1613500950294, + "version": "0.14" + }, + "immutables-0.14-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5a2376f7ff5faabd21e7c194ef6ca1a2", + "name": "immutables", + "sha256": "625c740ea40e7ec552052ca199f6b0ed52da7d68de4b29f939a86887ca7e31d9", + "size": 71443, + "subdir": "linux-64", + "timestamp": 1592426008592, + "version": "0.14" + }, + "immutables-0.14-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "cf0a7046df75ac2ec4cfe313b23cae38", + "name": "immutables", + "sha256": "6d15631ea876bf0aeb1f847e50909c942ee1e5bfb0c12242cd4eb92d49ce1344", + "size": 72025, + "subdir": "linux-64", + "timestamp": 1613500952155, + "version": "0.14" + }, + "immutables-0.15-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "1b506b765bcdce5320530ea4b84abf0e", + "name": "immutables", + "sha256": "d1f2ad4432f639d54e21d771e69632d58456fdd6022c0fde0c84d2a3551ff97f", + "size": 69716, + "subdir": "linux-64", + "timestamp": 1615839353431, + "version": "0.15" + }, + "immutables-0.15-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "cf110b28e764e2ef579d3f13e5a51af6", + "name": "immutables", + "sha256": "b657ae8920a61093bb146c8db83e873bedbc3f56e64286c7d9937f4a9721c1b1", + "size": 70645, + "subdir": "linux-64", + "timestamp": 1615841159787, + "version": "0.15" + }, + "immutables-0.15-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c5f13df67ada20990953ba601179819e", + "name": "immutables", + "sha256": "41b09a68a5a466aa06367188357aad28f2520e72e25033116db6f9a8b86a85b3", + "size": 69996, + "subdir": "linux-64", + "timestamp": 1615840871095, + "version": "0.15" + }, + "immutables-0.15-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ec2ed20cf00a5b68f83f1ec3fec3a60c", + "name": "immutables", + "sha256": "ddab3b5568358ca895f8b0fa3eb624c45d3d0f775c5156a1d7d850e2513bef65", + "size": 70193, + "subdir": "linux-64", + "timestamp": 1615841168110, + "version": "0.15" + }, + "immutables-0.16-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "565104f4786b05975548f70bc91bee44", + "name": "immutables", + "sha256": "3ee58ae82e4d16a567bdf0e1ee292a742ce41a78fdbc381c9d7a4651b7cc83ec", + "size": 110523, + "subdir": "linux-64", + "timestamp": 1640791023448, + "version": "0.16" + }, + "immutables-0.16-py311h5eee18b_1.conda": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0 AND MIT", + "license_family": "Apache", + "md5": "31aba7a72f447a6c9c54b1cd240fbb4d", + "name": "immutables", + "sha256": "2da4e0c4e3f6fa633c3a19239fe1b8ebc425d52de2620c811d581a29b2ed6577", + "size": 73074, + "subdir": "linux-64", + "timestamp": 1676852842799, + "version": "0.16" + }, + "immutables-0.16-py36h7f8727e_0.conda": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e84ed74825151227baa8a163a7c6df3a", + "name": "immutables", + "sha256": "02a345915122fff9cfbde94a6517dd3bd5795a41ceb49c6753dfdf43d7348966", + "size": 65012, + "subdir": "linux-64", + "timestamp": 1628889054704, + "version": "0.16" + }, + "immutables-0.16-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "d325184d8719a7de6ae727af5371d2a7", + "name": "immutables", + "sha256": "acf26fa566d787808a979328b75272415ac9a5974d00cc66eadbd6e440cf8809", + "size": 65387, + "subdir": "linux-64", + "timestamp": 1628881178135, + "version": "0.16" + }, + "immutables-0.16-py37h7f8727e_1.conda": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "Apache-2.0 AND MIT", + "license_family": "Apache", + "md5": "d8517130c407123426f5cbfe1f120594", + "name": "immutables", + "sha256": "8c2d0e6e7cd7fef89297dcbdab949e5b6ae7dd59f722725f91edf94d6502c3c7", + "size": 69395, + "subdir": "linux-64", + "timestamp": 1640145868168, + "version": "0.16" + }, + "immutables-0.16-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "eb7e6b26fd36bcb2f59b65473ae1aa29", + "name": "immutables", + "sha256": "87fca0f928d0c3f227e6d1ab8bb9ee33a9c640d7573409b7c42d9df75f83b78c", + "size": 65991, + "subdir": "linux-64", + "timestamp": 1628889576722, + "version": "0.16" + }, + "immutables-0.16-py38h7f8727e_1.conda": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 AND MIT", + "license_family": "Apache", + "md5": "aa5758f386d78027d0cff2bebaef237a", + "name": "immutables", + "sha256": "0c7df76df7aa4b000b9948ee8b76a265b84e29e767f0ae7b57c7cd27ca3011f4", + "size": 69848, + "subdir": "linux-64", + "timestamp": 1640163987214, + "version": "0.16" + }, + "immutables-0.16-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "06fa65c96a5057512bac45047f59eb08", + "name": "immutables", + "sha256": "d3ec53b7a5506e23df9513796ceca7b08f2a8a47869212e894b343a77dae2e6f", + "size": 66195, + "subdir": "linux-64", + "timestamp": 1628889582131, + "version": "0.16" + }, + "immutables-0.16-py39h7f8727e_1.conda": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 AND MIT", + "license_family": "Apache", + "md5": "7a3321ea6740c6210c31e6ebc483f774", + "name": "immutables", + "sha256": "4fe4b274f3ee31dbc45b2073d3865a8f2b82508dad3d5583bd7553fbf1f8dcd0", + "size": 69833, + "subdir": "linux-64", + "timestamp": 1640163986689, + "version": "0.16" + }, + "importlib-metadata-1.1.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "acb424dbb19cedbaacc0ccdea707143f", + "name": "importlib-metadata", + "sha256": "3310f40fa2cb05d913172fd288473fee2865f49dba1450b6eaf5f447cb65a86b", + "size": 47914, + "subdir": "linux-64", + "timestamp": 1594838469052, + "version": "1.1.3" + }, + "importlib-metadata-1.1.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "8e84aeb69c11ac3d4dbcaceca7d18d4b", + "name": "importlib-metadata", + "sha256": "105b6442ecba67a73b67f3a3091c2b5ab800ec093d76ab50dc624dbbcf83f255", + "size": 48153, + "subdir": "linux-64", + "timestamp": 1594838467114, + "version": "1.1.3" + }, + "importlib-metadata-1.1.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "4743d0b427bf906e2a9cb282ea967247", + "name": "importlib-metadata", + "sha256": "01be56454bcef2acab82f9078dd5a3359e085af997fdaedd9bc033eca7421293", + "size": 48577, + "subdir": "linux-64", + "timestamp": 1594838467093, + "version": "1.1.3" + }, + "importlib-metadata-1.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "2d86e7f231a5fd473faf6b49994b9786", + "name": "importlib-metadata", + "sha256": "9be820bf053c9dc634e5609b48bb200b02134d6f8212a3646efa95bf0789a9da", + "size": 50773, + "subdir": "linux-64", + "timestamp": 1590516354242, + "version": "1.6.0" + }, + "importlib-metadata-1.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e7a28f7c24a6517cd8a9a877e0692597", + "name": "importlib-metadata", + "sha256": "596b0f7658394085d6120ecfc434a63f3a3565da4a9c0697f628f91b08999e57", + "size": 50310, + "subdir": "linux-64", + "timestamp": 1590516380777, + "version": "1.6.0" + }, + "importlib-metadata-1.6.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "bf24774a64a29a4a7dafdc79de03e543", + "name": "importlib-metadata", + "sha256": "856fda8556541d4c79525d1c59a70bdd3cd3fd16db8d340efcd3eda3dbb6a1df", + "size": 50679, + "subdir": "linux-64", + "timestamp": 1590516388056, + "version": "1.6.0" + }, + "importlib-metadata-1.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e2c4488613e5546cd33f35d4c40ad30e", + "name": "importlib-metadata", + "sha256": "3acb7248828be488ef1903662c87993c1ce22a11c53ce6ef6fbc8fbd2698d4c0", + "size": 52052, + "subdir": "linux-64", + "timestamp": 1592328454024, + "version": "1.6.1" + }, + "importlib-metadata-1.6.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "eb0013c6dbb1ce2bb83910c4dc496a67", + "name": "importlib-metadata", + "sha256": "7ca4c7092ee44cc2cc758620ed2c949d92e9a011fb19348cb20e60a5ca1a2189", + "size": 52065, + "subdir": "linux-64", + "timestamp": 1592328452018, + "version": "1.6.1" + }, + "importlib-metadata-1.6.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "acc702dc350a78afcc4468e926a4d634", + "name": "importlib-metadata", + "sha256": "cce681bae184740ee93d413652cf139d5d6edf3704548c726dc1ab5aec262dd1", + "size": 51923, + "subdir": "linux-64", + "timestamp": 1592328452098, + "version": "1.6.1" + }, + "importlib-metadata-1.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "557814cf53633d6393f35a595b4a97b8", + "name": "importlib-metadata", + "sha256": "07b2b9586bdbc02ff73b921d478095a617ea8dfc62d5f97aa797ad08432bdd20", + "size": 52546, + "subdir": "linux-64", + "timestamp": 1593446464880, + "version": "1.7.0" + }, + "importlib-metadata-1.7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "14585850b45263ea860d08f634f5f021", + "name": "importlib-metadata", + "sha256": "bdba2a78c77a404182ebf16fdf2440a131f6d167785be7c0166102e77796876c", + "size": 52622, + "subdir": "linux-64", + "timestamp": 1593446439336, + "version": "1.7.0" + }, + "importlib-metadata-1.7.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f09caad8b5d640f732db3b96d98457ff", + "name": "importlib-metadata", + "sha256": "391c62ccce91058b4c332ad7871e03048e7ea8ea6a7f52f1e5af0df40dc0819a", + "size": 53363, + "subdir": "linux-64", + "timestamp": 1593446439244, + "version": "1.7.0" + }, + "importlib-metadata-1.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e9cec75dfb81a58dbd7019c095a7d3fb", + "name": "importlib-metadata", + "sha256": "5339edd7ca8b1ae39de73602cc1bfc1b2212c7ba62581188a44129c400c7e1c0", + "size": 53109, + "subdir": "linux-64", + "timestamp": 1608273463536, + "version": "1.7.0" + }, + "importlib-metadata-3.10.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "d9c57c71f209cbfb64db6c0edfbc9123", + "name": "importlib-metadata", + "sha256": "1d3c8eae17a7e694cdab44e499e3cda502e6d6ed712f956e3d1e9985c580cb02", + "size": 33783, + "subdir": "linux-64", + "timestamp": 1617877348218, + "version": "3.10.0" + }, + "importlib-metadata-3.10.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f4e87590ef36a1662562d7a8748fa7b5", + "name": "importlib-metadata", + "sha256": "d3eb99134628608659e3e78c6beaf3ea450e6128e552db84dec1784b1d09979f", + "size": 34197, + "subdir": "linux-64", + "timestamp": 1617877353498, + "version": "3.10.0" + }, + "importlib-metadata-3.10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b064c19266a568270f06245b9d4dc4ec", + "name": "importlib-metadata", + "sha256": "0f9102dece65a255ac90fb370763da17c73ed52364969c2360790cb51b25c57b", + "size": 34024, + "subdir": "linux-64", + "timestamp": 1617874510790, + "version": "3.10.0" + }, + "importlib-metadata-3.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e007579a1019031c4c019e08026f9112", + "name": "importlib-metadata", + "sha256": "1f9d713628a422e7fa9d3043bc82319fb3316e08a2323acdfb96379f17eb82d8", + "size": 34070, + "subdir": "linux-64", + "timestamp": 1617877346541, + "version": "3.10.0" + }, + "importlib-metadata-3.7.3-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "bd4899102f8b9a55b46b9c098f3ed336", + "name": "importlib-metadata", + "sha256": "494e880a82c553201451bcef47bb1700987c1ec0dd4721c5775e7850e4ee0eab", + "size": 31598, + "subdir": "linux-64", + "timestamp": 1615900373215, + "version": "3.7.3" + }, + "importlib-metadata-3.7.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "601c8c376c156943ee77a3a787bad5d9", + "name": "importlib-metadata", + "sha256": "1d8ab6969c9a18590ea68ec4a7e67469eb573211ced3f2c604d0a107dfb71b9d", + "size": 31373, + "subdir": "linux-64", + "timestamp": 1615900494797, + "version": "3.7.3" + }, + "importlib-metadata-3.7.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a9a87aaee1bd956e9f1bff7714938607", + "name": "importlib-metadata", + "sha256": "feeb57143bd03398dddef5cd4de016084dee6771a1b6d007211d6be79e50bff8", + "size": 31754, + "subdir": "linux-64", + "timestamp": 1615900481322, + "version": "3.7.3" + }, + "importlib-metadata-3.7.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "cec4ea95047e6074034b168a9a52fde2", + "name": "importlib-metadata", + "sha256": "a0cc58e08b58ea947faf733174d64bf8da9bb51aeed6c49f0bdaf05174916bd0", + "size": 31765, + "subdir": "linux-64", + "timestamp": 1615900490143, + "version": "3.7.3" + }, + "importlib-metadata-4.11.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "402867e9fc6f8b2d4b4b9074db22b829", + "name": "importlib-metadata", + "sha256": "ffaffd0ab9ab814d8e6ca1ecd17282e87e431d18011c908824e3cb6cd42c19a0", + "size": 41534, + "subdir": "linux-64", + "timestamp": 1648562468048, + "version": "4.11.3" + }, + "importlib-metadata-4.11.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "2a5121d0636c0bf9613aaa277085ab02", + "name": "importlib-metadata", + "sha256": "4538dd986b48ffd5f96acb1eee4ff7045e89fe79e4f94ab73f13eb02e9c980cd", + "size": 42644, + "subdir": "linux-64", + "timestamp": 1676822992907, + "version": "4.11.3" + }, + "importlib-metadata-4.11.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "805ade2a4aa932fcf4b598a4de33c2d0", + "name": "importlib-metadata", + "sha256": "47264f1233386dde23505f94290cba5f09e56ffbb6484230ef9513e243cc6ef6", + "size": 40976, + "subdir": "linux-64", + "timestamp": 1648562455026, + "version": "4.11.3" + }, + "importlib-metadata-4.11.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "423bacee14c9d4174efc8cd379f6c2dc", + "name": "importlib-metadata", + "sha256": "eb1636fb499ffcd1d6bec45a676c40284bab9e957ed9813bc72e316fb7f44ad0", + "size": 41085, + "subdir": "linux-64", + "timestamp": 1648562454191, + "version": "4.11.3" + }, + "importlib-metadata-4.11.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "3049562ec071212e501225d07d0853db", + "name": "importlib-metadata", + "sha256": "248c5d4f612c71b28ae13dea85bc5b2787bc81e9b49719a9b4e856e6b90a2b94", + "size": 40813, + "subdir": "linux-64", + "timestamp": 1648544587647, + "version": "4.11.3" + }, + "importlib-metadata-4.6.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "46d7d49ef4847aab59d2c181a5a5a73f", + "name": "importlib-metadata", + "sha256": "47a5183cab37c9259a8e810c9ba05465b5219d166ffd8cda628251737625700c", + "size": 38506, + "subdir": "linux-64", + "timestamp": 1631053088668, + "version": "4.6.4" + }, + "importlib-metadata-4.6.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "11ba335f73f0a95593d98dfbf253dcb1", + "name": "importlib-metadata", + "sha256": "29b5ceff6a65db693ab2690592f6548142cfa08f5579236f6a48dfb5b37bf6ac", + "size": 38372, + "subdir": "linux-64", + "timestamp": 1631043574684, + "version": "4.6.4" + }, + "importlib-metadata-4.6.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "39ad78801c7b2179ee6cf11d774e7c29", + "name": "importlib-metadata", + "sha256": "73ea4127d43497cfdda023f3bbbe954c0992c834c3954a8bc970b1d7a7645d07", + "size": 38479, + "subdir": "linux-64", + "timestamp": 1631053072153, + "version": "4.6.4" + }, + "importlib-metadata-4.6.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "1e915f6ba4d02f43ab769ba50728a71f", + "name": "importlib-metadata", + "sha256": "69101090a238055400a6e1cf9d9c55b7675be0646fe89edf8c0221441d3abd95", + "size": 38587, + "subdir": "linux-64", + "timestamp": 1631053074829, + "version": "4.6.4" + }, + "importlib-metadata-4.8.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9178126e307ebb3f93a5e5964c4069e1", + "name": "importlib-metadata", + "sha256": "23394e89a4ec5ec6622596e47af4a9d7273ae8abec8bb490e8fcd2a7fcd9218f", + "size": 39151, + "subdir": "linux-64", + "timestamp": 1631916743742, + "version": "4.8.1" + }, + "importlib-metadata-4.8.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "76e54fdbc993e7cae51cba69e883561b", + "name": "importlib-metadata", + "sha256": "332e4a57e26299343944ab69d15ce92d380d5d9ffa8a4b9f030a3c5427656a29", + "size": 39353, + "subdir": "linux-64", + "timestamp": 1631906794031, + "version": "4.8.1" + }, + "importlib-metadata-4.8.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "685758301be215305d8ddd4a5634cb43", + "name": "importlib-metadata", + "sha256": "aff136230027b627102636a58d0a434980dc649f214432479649dfc201d24681", + "size": 39558, + "subdir": "linux-64", + "timestamp": 1631916728650, + "version": "4.8.1" + }, + "importlib-metadata-4.8.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f885b8a3dbd22b838d7cfbf270c5bf63", + "name": "importlib-metadata", + "sha256": "801f2e1983fd5dd3d6b44b9ff08206f895031851f336e2997cb522e3acda6eaf", + "size": 39878, + "subdir": "linux-64", + "timestamp": 1631916728376, + "version": "4.8.1" + }, + "importlib-metadata-4.8.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "db8ca479685bde1c58e997e5679b38ee", + "name": "importlib-metadata", + "sha256": "bfb7bb37f4068776e671437c5549c92f9751fd51cd0ea091aa15db1a0c8323db", + "size": 34279, + "subdir": "linux-64", + "timestamp": 1640886206486, + "version": "4.8.2" + }, + "importlib-metadata-4.8.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.6.4", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "84898f457b2a26e712fe484aea4a3da7", + "name": "importlib-metadata", + "sha256": "2bd41b7a72b639df68f9c57998819f258506610b22f54f6ce5a28248d9fbd497", + "size": 40348, + "subdir": "linux-64", + "timestamp": 1638529639804, + "version": "4.8.2" + }, + "importlib-metadata-4.8.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "07b69889f7bd5069502e5444ed476fd8", + "name": "importlib-metadata", + "sha256": "51b2a2935c8c4c229f2dd2f0bfbd2a77c1aa425042ffdc1dd8e93f9941eac724", + "size": 40473, + "subdir": "linux-64", + "timestamp": 1638542925707, + "version": "4.8.2" + }, + "importlib-metadata-4.8.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "23caa405dfb3a481e8aa28c01b97b227", + "name": "importlib-metadata", + "sha256": "7476e46b236339a382e58ac529b67883266daa5fb8800a0e998fae4eaf41497d", + "size": 40446, + "subdir": "linux-64", + "timestamp": 1638542805718, + "version": "4.8.2" + }, + "importlib-metadata-6.0.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "20d9c2f775654fc3ccab00311209de61", + "name": "importlib-metadata", + "sha256": "9da94bc6d2050e37311395674574e55bfeb54b99189a8040bc401f79bfe8df44", + "size": 39655, + "subdir": "linux-64", + "timestamp": 1678997157064, + "version": "6.0.0" + }, + "importlib-metadata-6.0.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9b19c842972a7754a1604166acf44c10", + "name": "importlib-metadata", + "sha256": "c9516f8633b05e3a63d407c8630a26ae464c0196cb963047a179b86195b93041", + "size": 47310, + "subdir": "linux-64", + "timestamp": 1678997105314, + "version": "6.0.0" + }, + "importlib-metadata-6.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "04271710dda9ec4a9d99937b1b8a5511", + "name": "importlib-metadata", + "sha256": "d6c91690e06832f1fad5599a3b0992f1581e225a43e0ff1ef0602de8df16c9bb", + "size": 39207, + "subdir": "linux-64", + "timestamp": 1678997179162, + "version": "6.0.0" + }, + "importlib-metadata-6.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "zipp >=0.5" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "cc268ce97197920bd7ee27aa7c404a77", + "name": "importlib-metadata", + "sha256": "e036908b0d886499a90695b2cc962aae380bbfa7b770f9c10fc2ca36c3b1fafc", + "size": 38597, + "subdir": "linux-64", + "timestamp": 1678997134023, + "version": "6.0.0" + }, + "importlib_metadata-0.17-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "configparser", + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "47ff35ff8944fd9ecb815fd6d03e5fe6", + "name": "importlib_metadata", + "sha256": "f961dbcc8f6ef0e52d0ccca9434a21d4f50b6b8fa194c1e5dc6036a71c2ed432", + "size": 40510, + "subdir": "linux-64", + "timestamp": 1559659706254, + "version": "0.17" + }, + "importlib_metadata-0.17-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "1b80c043f57b2584dcbe777e6b506d76", + "name": "importlib_metadata", + "sha256": "615012f2f3ee8b1b9ab18159f3f120710ccd8413894ed91feb6900504b45337c", + "size": 40763, + "subdir": "linux-64", + "timestamp": 1559659727045, + "version": "0.17" + }, + "importlib_metadata-0.17-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "f4f63615b1c98521a7bd110dfa1b9713", + "name": "importlib_metadata", + "sha256": "06cfba49dca54bc04fb147baaabd35e4536988847abae8e8d20ddfa37083dfc5", + "size": 41003, + "subdir": "linux-64", + "timestamp": 1559659699765, + "version": "0.17" + }, + "importlib_metadata-0.19-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser >=3.5", + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "a8b34774c731688cc7de12358dd7ddeb", + "name": "importlib_metadata", + "sha256": "012fb1e31a6741b1fcd48702be78fc6db494026d4e37bfcf226a737cb03f5730", + "size": 41286, + "subdir": "linux-64", + "timestamp": 1565189825791, + "version": "0.19" + }, + "importlib_metadata-0.19-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "0cd057bcf722be005ddc7027a7329344", + "name": "importlib_metadata", + "sha256": "c63f9fd17a9d326d2fd4f15c478654fc449328ed0e2d5080190c7d2dbcfcb226", + "size": 41792, + "subdir": "linux-64", + "timestamp": 1565189331177, + "version": "0.19" + }, + "importlib_metadata-0.19-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "4cfc82dd3a1a3beeee2eadfe6293673e", + "name": "importlib_metadata", + "sha256": "9233502cd067b89722d80ce03cd06c5f98643217c9b5e8268cbe11db8ab5747e", + "size": 41921, + "subdir": "linux-64", + "timestamp": 1565189079347, + "version": "0.19" + }, + "importlib_metadata-0.23-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser >=3.5", + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "81e65405a5d5cb2678bb208e35e1f94d", + "name": "importlib_metadata", + "sha256": "86df8580eef012859061a20da1911491897f71f7f9f6490ee2ecd58cd995ef2c", + "size": 44298, + "subdir": "linux-64", + "timestamp": 1569374940359, + "version": "0.23" + }, + "importlib_metadata-0.23-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "b62245bc9ae184f335a52020429b969b", + "name": "importlib_metadata", + "sha256": "4b70720178b3e8ea1e5b493b86e6b523bf9c93ea3a2c3de8fefbd7e022de1c10", + "size": 44825, + "subdir": "linux-64", + "timestamp": 1569374926672, + "version": "0.23" + }, + "importlib_metadata-0.23-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "9ec782a7975303d9cd24965794b505b8", + "name": "importlib_metadata", + "sha256": "f2b30acd14af604ec6313f9f3a261e510baa4f23d93bd41320d60895188559b5", + "size": 44896, + "subdir": "linux-64", + "timestamp": 1569374920397, + "version": "0.23" + }, + "importlib_metadata-0.23-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "2cd1cb994fe60b8296cd1bba1acc137e", + "name": "importlib_metadata", + "sha256": "6184936f6cf9e8a8690d45201207af93c9ed36412ee35a164a3c6ba545a4987c", + "size": 41538, + "subdir": "linux-64", + "timestamp": 1573469654223, + "version": "0.23" + }, + "importlib_metadata-0.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "5492f0ae75b0c29202c87e08dd4c8434", + "name": "importlib_metadata", + "sha256": "b17275a50f07d90317977ad5db7e0330bfb459eff678884f80ec565bed4107d5", + "size": 22889, + "subdir": "linux-64", + "timestamp": 1539703310780, + "version": "0.6" + }, + "importlib_metadata-0.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "bd6d035d2fb51ef98bbc688508a33157", + "name": "importlib_metadata", + "sha256": "3b5c6498e821451834f9e7296e3ef921ef63b4382a7e6806356ae779fd5dd4bd", + "size": 23089, + "subdir": "linux-64", + "timestamp": 1539703377551, + "version": "0.6" + }, + "importlib_metadata-0.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "782e5c7b8695f14a5d9bac7a0f4ef914", + "name": "importlib_metadata", + "sha256": "1796232d62e25f7ac96851a1e451b9e0bab822016e2b8918b59020b3f03cce51", + "size": 23047, + "subdir": "linux-64", + "timestamp": 1539703324459, + "version": "0.6" + }, + "importlib_metadata-0.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "b3492ef6570c9e5092f361ee20b7de87", + "name": "importlib_metadata", + "sha256": "d732874dfe7bd003671ecaeec2f1a1c88a73c65deaa2f4cae5034bee492cbd37", + "size": 25264, + "subdir": "linux-64", + "timestamp": 1548295254367, + "version": "0.7" + }, + "importlib_metadata-0.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "7cf376a96c0a9e8af2b20a051fc57053", + "name": "importlib_metadata", + "sha256": "57bfc4efc218fbef08835a5dbd5dd967bacff173b594a1a9a35993a8572ac3dd", + "size": 25594, + "subdir": "linux-64", + "timestamp": 1548295291914, + "version": "0.7" + }, + "importlib_metadata-0.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "bd3a2c0f0a2735eb844784899a72ced1", + "name": "importlib_metadata", + "sha256": "6550420e1c70ce560ec0aa240a1a861adfa7f0a536851e9139b4763facc363f7", + "size": 25494, + "subdir": "linux-64", + "timestamp": 1548291054129, + "version": "0.7" + }, + "importlib_metadata-0.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser", + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0", + "zipp >=0.3.2" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "824bb509215d2a30930aabc94d3159e7", + "name": "importlib_metadata", + "sha256": "62c7fd3bff6c5b3cdb0d0eee95a3ff16e71bf24af3c943b3a3ebbe2a1342299f", + "size": 34746, + "subdir": "linux-64", + "timestamp": 1552361522552, + "version": "0.8" + }, + "importlib_metadata-0.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.3.2" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "c241f64e90a87018d311a390c2b9b034", + "name": "importlib_metadata", + "sha256": "db58b1ac95335e1ce410ac8e69a9a39bafa50df8f4cf28ecc147079fb1916938", + "size": 34711, + "subdir": "linux-64", + "timestamp": 1552361554146, + "version": "0.8" + }, + "importlib_metadata-0.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.3.2" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "030527f3c20ad6c50b8114e7ba5cd317", + "name": "importlib_metadata", + "sha256": "7ced77800d3870c2dc242163c2f478fc470ebd9f21a0c74d5d46555556a8d18d", + "size": 34786, + "subdir": "linux-64", + "timestamp": 1552361481855, + "version": "0.8" + }, + "importlib_metadata-0.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser", + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0", + "zipp >=0.3.2" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "8a8bb5302acfcdc275d27cafabf90657", + "name": "importlib_metadata", + "sha256": "0265081435bfbf675a025cd9e3d76cfeac6f81bd4b3dd97b1a3aa6eff253379b", + "size": 37048, + "subdir": "linux-64", + "timestamp": 1556067217232, + "version": "0.9" + }, + "importlib_metadata-0.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.3.2" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "33ee273bb307ee6ab969c19d0edf2771", + "name": "importlib_metadata", + "sha256": "775462d412f0b8df7fa76782f6f141d77e98191998c76a2f727a8f480c880855", + "size": 37281, + "subdir": "linux-64", + "timestamp": 1556067102786, + "version": "0.9" + }, + "importlib_metadata-0.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.3.2" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "40359ed78186b59106109fc4bf9b9fa9", + "name": "importlib_metadata", + "sha256": "ab48afbaa4be9584e9857eb1bbc62714e1f44ceb68177b431a153d9e518080c4", + "size": 37790, + "subdir": "linux-64", + "timestamp": 1556067200544, + "version": "0.9" + }, + "importlib_metadata-1.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser >=3.5", + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "eca15b93ed1b6b7308d2c934b5a538ff", + "name": "importlib_metadata", + "sha256": "b01bff168bb021222e73b8918ec41170e4e4e92e6a775f37683fc2b62d9e3743", + "size": 46208, + "subdir": "linux-64", + "timestamp": 1575393468208, + "version": "1.1.0" + }, + "importlib_metadata-1.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "5d85c39b5d74c260d25503b35f365a0f", + "name": "importlib_metadata", + "sha256": "0046d39312da737c61ad5b4d48c0a4a848b99c7ca6c9aab4d14ddecce8f0630e", + "size": 46690, + "subdir": "linux-64", + "timestamp": 1575393521047, + "version": "1.1.0" + }, + "importlib_metadata-1.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "32eecaab779927ebddc18ecbc2eea2ef", + "name": "importlib_metadata", + "sha256": "2d0f2dd2ce34119059b615692774b0762a9be40424d2a59679f13c51e9eb267a", + "size": 46795, + "subdir": "linux-64", + "timestamp": 1575393392981, + "version": "1.1.0" + }, + "importlib_metadata-1.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "1a60124a945aa1034f9141ca163c7cfc", + "name": "importlib_metadata", + "sha256": "acbcceee4d3c8fdda0a92b55a0a99f3898bcb42c07ad3fc3b35a7671de5b4f76", + "size": 47049, + "subdir": "linux-64", + "timestamp": 1575393533407, + "version": "1.1.0" + }, + "importlib_metadata-1.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser >=3.5", + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "52b1f8fa241c57646d5d043330f514e6", + "name": "importlib_metadata", + "sha256": "e133e210eecd68e0df6200065551f1b81837ab1f3e89e6571cb1029cd048f0e8", + "size": 46382, + "subdir": "linux-64", + "timestamp": 1576004195238, + "version": "1.2.0" + }, + "importlib_metadata-1.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "ba08278113246f270c5d684c3b41894a", + "name": "importlib_metadata", + "sha256": "39611bf0695736a90ea0f103913b541f03c36e21f06b0401f1797bafc4246a16", + "size": 46665, + "subdir": "linux-64", + "timestamp": 1576004189902, + "version": "1.2.0" + }, + "importlib_metadata-1.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "fb3424e56ec19108603003a280430100", + "name": "importlib_metadata", + "sha256": "559c7b45cb8a5795e10cc39ba9c38e94200f1d38c77f3836a1289a1aded5db5a", + "size": 47106, + "subdir": "linux-64", + "timestamp": 1576004176228, + "version": "1.2.0" + }, + "importlib_metadata-1.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "546f36982c17f84537c52cd7385570bc", + "name": "importlib_metadata", + "sha256": "2765d4f2ede144b34a6f4ac89522ba55cfc49a45811da28c1fc88bbcca521aee", + "size": 47050, + "subdir": "linux-64", + "timestamp": 1576004219932, + "version": "1.2.0" + }, + "importlib_metadata-1.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser >=3.5", + "contextlib2", + "pathlib2", + "python >=2.7,<2.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "6b003a1273060a055d008c49ba3e0b80", + "name": "importlib_metadata", + "sha256": "855b26090b82bbfdaae760366a0be03d9f87694f51a6defcd73c4e6ac613190c", + "size": 46803, + "subdir": "linux-64", + "timestamp": 1576514618793, + "version": "1.3.0" + }, + "importlib_metadata-1.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "b786a7a20b5d732dba7c6af72d2db8ff", + "name": "importlib_metadata", + "sha256": "4e3c36e7f10f31532f5b246bbe9496ce7001776308c892a2e9f9433627c6802a", + "size": 47338, + "subdir": "linux-64", + "timestamp": 1576514713839, + "version": "1.3.0" + }, + "importlib_metadata-1.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "78a9c445dab430b092ad83b787d64158", + "name": "importlib_metadata", + "sha256": "ea929b9e3b91f19c9b12a5bb10018604d240dc8807f269b94caf3a068b9baf6a", + "size": 47431, + "subdir": "linux-64", + "timestamp": 1576514674055, + "version": "1.3.0" + }, + "importlib_metadata-1.3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "0726e774e3c7f58236f83ba18582a248", + "name": "importlib_metadata", + "sha256": "338aafaf367be5519c872cefd970a2b18746ea0256c440faf0fd634bd7ff3f38", + "size": 47794, + "subdir": "linux-64", + "timestamp": 1576514742081, + "version": "1.3.0" + }, + "importlib_metadata-1.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "c041ae23d3b3c8841409a6f66455182c", + "name": "importlib_metadata", + "sha256": "0d927ff1c9de807f8a7693853d6986a75ad078d1b8871e0f4f5fe463d9da75e6", + "size": 47761, + "subdir": "linux-64", + "timestamp": 1580153661482, + "version": "1.4.0" + }, + "importlib_metadata-1.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "5e539a03f2dfddd4e9ea8c4f4e58d715", + "name": "importlib_metadata", + "sha256": "6aa80338a16b118d85bc76a06a3008f75d4af7b00e9e5f1b3e0f4a94110f1902", + "size": 47368, + "subdir": "linux-64", + "timestamp": 1580153767506, + "version": "1.4.0" + }, + "importlib_metadata-1.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "2d8f0ea584c96613d294576961c0fbfb", + "name": "importlib_metadata", + "sha256": "b695c825e266d09e7e965ef8e18b917a54c2d4a1d3a4f5c49051e82a08703921", + "size": 47794, + "subdir": "linux-64", + "timestamp": 1580153698023, + "version": "1.4.0" + }, + "importlib_metadata-1.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "1705acee96d49cd3b941ad94170a2cf8", + "name": "importlib_metadata", + "sha256": "619a5117ce0f57839e1f44a3f85d8b143110d5a5d9e289ed3a1eb0dc8e5263e8", + "size": 48769, + "subdir": "linux-64", + "timestamp": 1580835911627, + "version": "1.5.0" + }, + "importlib_metadata-1.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "36d21b07fa6a5b36d9ca2dc26de09553", + "name": "importlib_metadata", + "sha256": "b1b8688f5081b942c2c82b2e3959e4981d210bd367e46faf5d5ee148312f9ae1", + "size": 48790, + "subdir": "linux-64", + "timestamp": 1580835921617, + "version": "1.5.0" + }, + "importlib_metadata-1.5.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zipp >=0.5" + ], + "license": "APACHE-2.0", + "license_family": "APACHE", + "md5": "4e1c94e748838f83d272456c2b0eacf0", + "name": "importlib_metadata", + "sha256": "420c7be663948cfc72b743674edd20a8b3567566c015f8360370f4e3e00c7fca", + "size": 49443, + "subdir": "linux-64", + "timestamp": 1580835949770, + "version": "1.5.0" + }, + "importlib_resources-1.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "607c54b36b2a0cd7bc29f0c209f32048", + "name": "importlib_resources", + "sha256": "32a510657c155ba64d6861635aa39cc5258955354849b39c65a821d9fbba2dac", + "size": 32599, + "subdir": "linux-64", + "timestamp": 1585051569102, + "version": "1.4.0" + }, + "importlib_resources-1.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "71987b8e2c0c3b44f1e43a475f595186", + "name": "importlib_resources", + "sha256": "cc1a31ba201d7c90eb35f622ce49a56bf4f3bf478f255671660c025f17c26138", + "size": 32648, + "subdir": "linux-64", + "timestamp": 1585051601550, + "version": "1.4.0" + }, + "importlib_resources-1.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "2126cf9738feff5ecc78af4b4a1fe01f", + "name": "importlib_resources", + "sha256": "3167c14474702b8a77dba587b29fdce06ccc4fc1b3aa22f21c6ae1af6cfb856d", + "size": 32819, + "subdir": "linux-64", + "timestamp": 1585051586312, + "version": "1.4.0" + }, + "importlib_resources-3.0.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "c890decffc896c349ad5b1c42b110bcc", + "name": "importlib_resources", + "sha256": "7476cd4ebb1376fa11c114979c7c9183aed296c6b97ac4320dbaa214b80ecd10", + "size": 36369, + "subdir": "linux-64", + "timestamp": 1605034136267, + "version": "3.0.0" + }, + "importlib_resources-3.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "9b1178cef394d49dc1f9a13652380277", + "name": "importlib_resources", + "sha256": "9306c78ce367525899fa0aab1b58320d32105f606da825c16c650c3c40abf049", + "size": 32975, + "subdir": "linux-64", + "timestamp": 1594360859153, + "version": "3.0.0" + }, + "importlib_resources-3.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "f1a122886ffa7474204b8ac91de73298", + "name": "importlib_resources", + "sha256": "a951ca7ce8713b26d6249c06ff32c595be68bf297fcfb7f49996fe184665f48d", + "size": 36433, + "subdir": "linux-64", + "timestamp": 1605034440631, + "version": "3.0.0" + }, + "importlib_resources-3.3.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "2e549e1305d30b246bc4591f7664a2d1", + "name": "importlib_resources", + "sha256": "383ff5a34f680e982b717cbdd405aac1a09e3f7b5eddf84aaa9e27827a97331e", + "size": 38737, + "subdir": "linux-64", + "timestamp": 1603999996610, + "version": "3.3.0" + }, + "importlib_resources-3.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "1a01841955410d56a9ee500598082a2b", + "name": "importlib_resources", + "sha256": "154354db16c6778e1cce01c50cc0d1503f06e9b1fd0e8ae9e740aeabfeeb1275", + "size": 38766, + "subdir": "linux-64", + "timestamp": 1603999988741, + "version": "3.3.0" + }, + "importlib_resources-3.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "bea610937296e846694389149c4d94ad", + "name": "importlib_resources", + "sha256": "49f10eae167c3177fc7223c1fbbe604512fca8da1084d22e03ebb92e7ef81782", + "size": 39675, + "subdir": "linux-64", + "timestamp": 1603999993709, + "version": "3.3.0" + }, + "importlib_resources-3.3.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "f84b52dd308687ec7c74e8af03a82c5a", + "name": "importlib_resources", + "sha256": "18ed002455f92716c7d89404a7e11473cc39212a1370e2bf4f6edf4765f652df", + "size": 39210, + "subdir": "linux-64", + "timestamp": 1608755762262, + "version": "3.3.1" + }, + "importlib_resources-3.3.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "80f0bb568bfce21d0e172dc1496069ac", + "name": "importlib_resources", + "sha256": "d5ecbedc6b972697ed36797627f318b3f7f1a94046173b4445318a776a573440", + "size": 39156, + "subdir": "linux-64", + "timestamp": 1608755761563, + "version": "3.3.1" + }, + "importlib_resources-3.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "c37adc2240b40acaf5e991c8c667045c", + "name": "importlib_resources", + "sha256": "35290ad17ac218d5661087612b685dc8bd0cfaa22c707ab4bfbdf699e0271b50", + "size": 39616, + "subdir": "linux-64", + "timestamp": 1608755761702, + "version": "3.3.1" + }, + "importlib_resources-3.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "6295b6c2ffcfebf5a97f6b92c52fb46c", + "name": "importlib_resources", + "sha256": "ed8a32671f9f93c88d65e004a50df8f0c576e56634519fa3b73cbf1a7dd002f1", + "size": 39621, + "subdir": "linux-64", + "timestamp": 1608755762214, + "version": "3.3.1" + }, + "importlib_resources-4.0.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "ebc594a680d03ee92d94e12269af6664", + "name": "importlib_resources", + "sha256": "ef2b9184b5f650ea5427acc22466383a879f78d1a82096919b8605b3c4cb2e87", + "size": 35752, + "subdir": "linux-64", + "timestamp": 1608834336975, + "version": "4.0.0" + }, + "importlib_resources-4.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "61763880a87b394542231c56cfb780f4", + "name": "importlib_resources", + "sha256": "1e2a1b67027a8023314d6edfd2079c4447be202e911a6acef50b11e51e54d575", + "size": 35684, + "subdir": "linux-64", + "timestamp": 1608834342861, + "version": "4.0.0" + }, + "importlib_resources-4.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "401fd66990887364d8aa4887eff8b2b2", + "name": "importlib_resources", + "sha256": "741ea879240be53448dbc457c35063f77041d35547d0718b7a100e32273904db", + "size": 36199, + "subdir": "linux-64", + "timestamp": 1608834326130, + "version": "4.0.0" + }, + "importlib_resources-4.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "8158b00e027090c0457d8990ddd60e21", + "name": "importlib_resources", + "sha256": "7020bae27706b9fd61cf5875bb9548e55608237521366f6910695e33f7da73ee", + "size": 36332, + "subdir": "linux-64", + "timestamp": 1608834345583, + "version": "4.0.0" + }, + "importlib_resources-4.1.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "f7403440c1c59bd1503be1771917c725", + "name": "importlib_resources", + "sha256": "b58a79ce52b1b3e854a4f7018dd9f36a71630bdaef1e3363a267384a643dae55", + "size": 35170, + "subdir": "linux-64", + "timestamp": 1608920536490, + "version": "4.1.0" + }, + "importlib_resources-4.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "ed429c6efa702d8ea0415898c472a310", + "name": "importlib_resources", + "sha256": "f4209a24f00b7dae450802a9452145e5da98a79d38471a6b840cac48863da3b2", + "size": 35297, + "subdir": "linux-64", + "timestamp": 1608920525862, + "version": "4.1.0" + }, + "importlib_resources-4.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "4b2bd1d5b3188ad728d68d48ddaf217f", + "name": "importlib_resources", + "sha256": "15c89883a71d00baff6a3f5413e7ccb0698e07d11b137cce3cf084ae70fff4c8", + "size": 35786, + "subdir": "linux-64", + "timestamp": 1608920521057, + "version": "4.1.0" + }, + "importlib_resources-4.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "723172c3aa36188f4d06c66ad879695d", + "name": "importlib_resources", + "sha256": "0c360e2f98b2f190f059c5d446330172dfe7ef3ae4d7fa00cfc910f426b0c509", + "size": 35527, + "subdir": "linux-64", + "timestamp": 1608920527850, + "version": "4.1.0" + }, + "importlib_resources-4.1.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "8ac6a7fce8b7f7cb00f176f011e5b6bf", + "name": "importlib_resources", + "sha256": "4cc0cdd4de7ecff85bd6e1591c95c2c82280b9cca91ea7152b3d4e1c5cf21d6f", + "size": 35383, + "subdir": "linux-64", + "timestamp": 1609860461401, + "version": "4.1.1" + }, + "importlib_resources-4.1.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "41cfcbcbc63149ec8b092b0f0bdc6f91", + "name": "importlib_resources", + "sha256": "316848b845cddb213900ca5dd1efbed3cc07e355c765c7b02b6f5a82c15c2968", + "size": 35468, + "subdir": "linux-64", + "timestamp": 1609860333624, + "version": "4.1.1" + }, + "importlib_resources-4.1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "57e016a5fccf5e9719f0413777065ca3", + "name": "importlib_resources", + "sha256": "f39bf3eb34d663f2be9948e5d0e870fc74f465bc2f85a46feb2fd42663b6956c", + "size": 35467, + "subdir": "linux-64", + "timestamp": 1609353277649, + "version": "4.1.1" + }, + "importlib_resources-4.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "b5b33bf564104c80b7d07d0b25efe5e8", + "name": "importlib_resources", + "sha256": "4eb6f75d45d73bfa48e1b4b03550ce992563fee3eba5d83fe749fa5fe87e71a4", + "size": 35794, + "subdir": "linux-64", + "timestamp": 1609860196526, + "version": "4.1.1" + }, + "importlib_resources-5.0.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "4aa2c4c82966357ff876cdeac6dd6891", + "name": "importlib_resources", + "sha256": "1e6b70d679b371fe49a9a47616903df5bff768e87d26e8089450d3d5ae2fd305", + "size": 34889, + "subdir": "linux-64", + "timestamp": 1610303935680, + "version": "5.0.0" + }, + "importlib_resources-5.0.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "b6d68d7de00d2089ed12067720e013b3", + "name": "importlib_resources", + "sha256": "cbd135133f3685fa89e8fc737a5bcc8171ce1bcc6426d4169370d0eb95f86351", + "size": 39111, + "subdir": "linux-64", + "timestamp": 1610481599840, + "version": "5.0.0" + }, + "importlib_resources-5.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "4d358a0e2d40b307962b94f91f0bea0f", + "name": "importlib_resources", + "sha256": "b02391e3933f039e79c2a46cd3993b7c9bb1a23669be75948b39c0bb4ee1e763", + "size": 35323, + "subdir": "linux-64", + "timestamp": 1610303928139, + "version": "5.0.0" + }, + "importlib_resources-5.0.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "4db2fe94d82ec2d79b7072b3403a8995", + "name": "importlib_resources", + "sha256": "1b7f3d7bc6c842189ad8b8f49ef1f56fc3f794f709d50eeb7d88ac0e4d1990b8", + "size": 39107, + "subdir": "linux-64", + "timestamp": 1610481523126, + "version": "5.0.0" + }, + "importlib_resources-5.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "ec1518a0c4c602cfee7d239e551c8953", + "name": "importlib_resources", + "sha256": "e85c169a47101efd3202e04a35ae1069980a5d04573d713bb10b2566b22c8d35", + "size": 35271, + "subdir": "linux-64", + "timestamp": 1610303967414, + "version": "5.0.0" + }, + "importlib_resources-5.0.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "510fdac8052052d5fb645342dedfd3a7", + "name": "importlib_resources", + "sha256": "3e0db238856e19747b55442b868d4a7661c3216030b62c8f5445a1dbc8c89a73", + "size": 39390, + "subdir": "linux-64", + "timestamp": 1610481119514, + "version": "5.0.0" + }, + "importlib_resources-5.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "9f4430af8c1e06009ab0ecbf188e431b", + "name": "importlib_resources", + "sha256": "ce498598a92570bb669d158caf79945b4aa3fbe29954aeb80c7238b582e78689", + "size": 35218, + "subdir": "linux-64", + "timestamp": 1610303929224, + "version": "5.0.0" + }, + "importlib_resources-5.0.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "b1077b83cb85b984446336039a22dd26", + "name": "importlib_resources", + "sha256": "2e9056a4563e02ebcf8bcfd7f2e6cd083335a6b246674cd5799c2dcfe110d3e6", + "size": 39478, + "subdir": "linux-64", + "timestamp": 1610481596107, + "version": "5.0.0" + }, + "importlib_resources-5.1.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "083f855775b5b12d1d581cb1bd21bc41", + "name": "importlib_resources", + "sha256": "8ee0f02cb9eebb2f0e9e17da7f290b3077be8b35666611bcb886df0a5184af48", + "size": 38429, + "subdir": "linux-64", + "timestamp": 1611082891907, + "version": "5.1.0" + }, + "importlib_resources-5.1.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "b121dbc9e2cdbc0e9743fc261308ba2b", + "name": "importlib_resources", + "sha256": "bcc15bfaa4f1c6c530d6ba8abb2d3305b905cca3c08f5b9aeff7058d23a034e3", + "size": 38436, + "subdir": "linux-64", + "timestamp": 1611082893936, + "version": "5.1.0" + }, + "importlib_resources-5.1.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "1e9cf5e20c5eb34064f6b9af16246314", + "name": "importlib_resources", + "sha256": "6e843ab977fd2de54668be0ff443b52b6fbcd69baf0fd6e4ad4cb751eab5cfee", + "size": 38677, + "subdir": "linux-64", + "timestamp": 1611082096345, + "version": "5.1.0" + }, + "importlib_resources-5.1.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "28371baba8c83105184b2ff727d26e72", + "name": "importlib_resources", + "sha256": "7c5ece0427fb962f4dbe71e6573894ee77d9779c478698af195d76e7532ef858", + "size": 38800, + "subdir": "linux-64", + "timestamp": 1611082868990, + "version": "5.1.0" + }, + "importlib_resources-5.1.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "17015215667a74822f5430ab7d9a7529", + "name": "importlib_resources", + "sha256": "a2a5b3565679109c5b7fa584d366f2635d8450950f96529e5705d5a61a1d9277", + "size": 39665, + "subdir": "linux-64", + "timestamp": 1614615181800, + "version": "5.1.1" + }, + "importlib_resources-5.1.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "bc1a3cc8c18a0cd846b86072ce1ae518", + "name": "importlib_resources", + "sha256": "994f2f6a85a4bf5a35e0cd803b82b9717da449610f648bb709a0fa36eb468d7c", + "size": 39643, + "subdir": "linux-64", + "timestamp": 1614616372780, + "version": "5.1.1" + }, + "importlib_resources-5.1.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "67e994f30fa52eb9cac4a0842579fa8f", + "name": "importlib_resources", + "sha256": "267ae80224ab52774b6d15a4e5e2ac8284d6c9f272ce328cbab056e0ef63235d", + "size": 40024, + "subdir": "linux-64", + "timestamp": 1614616365065, + "version": "5.1.1" + }, + "importlib_resources-5.1.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "7c7c60e0bf4338a689895ee1f8e6f6e2", + "name": "importlib_resources", + "sha256": "58997329a518407e578d3e8b53c43e271cf61de252f5ba072aaf8c08b46a1c2e", + "size": 40137, + "subdir": "linux-64", + "timestamp": 1614615572998, + "version": "5.1.1" + }, + "importlib_resources-5.1.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "2dcf426f1380b97ca05f15f914ef449a", + "name": "importlib_resources", + "sha256": "4a3ce0967ce58ecaad7ba5e6b35976b568cfa761277c2eda8f4e5130424fda00", + "size": 39360, + "subdir": "linux-64", + "timestamp": 1614969166535, + "version": "5.1.2" + }, + "importlib_resources-5.1.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "9395b1d5b358cbca41fec7366d69e055", + "name": "importlib_resources", + "sha256": "d41686d2399512124bc84c3d2121dad32fb06c9450fe0070df4dbe766951aaf1", + "size": 39786, + "subdir": "linux-64", + "timestamp": 1614969328489, + "version": "5.1.2" + }, + "importlib_resources-5.1.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "4085a317c972a091eebd8cfad84c7f3f", + "name": "importlib_resources", + "sha256": "42a24a0ea288629fb639040ea939b10c5bb08010a09cb17803b69e2fe809c023", + "size": 39836, + "subdir": "linux-64", + "timestamp": 1614969306177, + "version": "5.1.2" + }, + "importlib_resources-5.1.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "69c9c5650fff424c1ad8d3f14a44ea2d", + "name": "importlib_resources", + "sha256": "c282212ef5303cfad8121a5be1c07120e0edfd160446606dd67eb2372afdd65a", + "size": 40122, + "subdir": "linux-64", + "timestamp": 1614969310955, + "version": "5.1.2" + }, + "importlib_resources-5.1.3-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "11fd1fe1b60d609d890fc6ed71750526", + "name": "importlib_resources", + "sha256": "f75d0a9017882bb2a676ab2c094795ad2366693fc3578565bb69bfb4a6e5a272", + "size": 40805, + "subdir": "linux-64", + "timestamp": 1620913895816, + "version": "5.1.3" + }, + "importlib_resources-5.1.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "fc38ee6a1c2a10098de1da032f259160", + "name": "importlib_resources", + "sha256": "73b82aa0874896be888ba14d0bc3fbc283d2f0191bca2672d948809136255c9a", + "size": 40893, + "subdir": "linux-64", + "timestamp": 1620909527956, + "version": "5.1.3" + }, + "importlib_resources-5.1.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "7eeb32baf402dc627d226f14f81c6922", + "name": "importlib_resources", + "sha256": "cd1c3cacc42fd0001a4e0940093a0d3605e472e3a74432ac8ba1a40ec823f7cf", + "size": 41528, + "subdir": "linux-64", + "timestamp": 1620913887732, + "version": "5.1.3" + }, + "importlib_resources-5.1.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "fdfe40d433e2e08af875c5fd3f7093b9", + "name": "importlib_resources", + "sha256": "8150ab3115f5306849777b11df3b784edb94f68ae9ecb251c5851534e8d65217", + "size": 41598, + "subdir": "linux-64", + "timestamp": 1620913551064, + "version": "5.1.3" + }, + "importlib_resources-5.1.4-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "285a9b4d98671402087455fba6089481", + "name": "importlib_resources", + "sha256": "9f108510b91bc88d54a4a8eaa10c4c432e27453362e147f8f87514a1c609e477", + "size": 41157, + "subdir": "linux-64", + "timestamp": 1622567524906, + "version": "5.1.4" + }, + "importlib_resources-5.1.4-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "zipp >=0.4" + ], + "license": "Apache-2.0", + "md5": "af9069b88b0c20a76101b4ef54e08bfb", + "name": "importlib_resources", + "sha256": "3aa0b95fc77ac3f2adf58bac07a23b10a5c9812ba23862ab86a2b0ce44e7bbab", + "size": 41287, + "subdir": "linux-64", + "timestamp": 1622567525511, + "version": "5.1.4" + }, + "impyla-0.14.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "thrift", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3b5f9e4dcc6f5d9f793536a80e0d2f25", + "name": "impyla", + "sha256": "bd2ebe99fd27733f6bd34f0f7b372526fec7bcdcd8cff2f65da9940331f9986b", + "size": 219199, + "subdir": "linux-64", + "timestamp": 1522780092223, + "version": "0.14.0" + }, + "impyla-0.14.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "90ba71cf628abc4b3f58fd0a272a5c87", + "name": "impyla", + "sha256": "be70e0f2f7f1e050f84d23e4b06e0b80dbcd3e12578624f446667e0ecc00b377", + "size": 93242, + "subdir": "linux-64", + "timestamp": 1522780172113, + "version": "0.14.0" + }, + "impyla-0.14.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3554a220136dee04674a961091364e84", + "name": "impyla", + "sha256": "0b795216eaec0839c3d33ff5a98f88264223a6ff564cdd5f58b11b3271cae86d", + "size": 92056, + "subdir": "linux-64", + "timestamp": 1522779801524, + "version": "0.14.0" + }, + "impyla-0.14.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "thrift", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "30d49992cd63240bc222d82a0c80adae", + "name": "impyla", + "sha256": "63dbb17bcfe7face9f7d0034aa8398b111f2eaf48b10792ede555409a81556ea", + "size": 218243, + "subdir": "linux-64", + "timestamp": 1522787603146, + "version": "0.14.1" + }, + "impyla-0.14.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "thrift", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "67146216b1e16b9656ef1af2c083735f", + "name": "impyla", + "sha256": "4581e808f627e7d2dd55698914d7f390093384c834e7bea939bf314701bd605b", + "size": 219235, + "subdir": "linux-64", + "timestamp": 1530893431896, + "version": "0.14.1" + }, + "impyla-0.14.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "43b61c7303dd440a4b047477d7344f8c", + "name": "impyla", + "sha256": "033f73c438da8ff023ec4a82d6bb53a83a1efb8ae698ca04e693abf3153a89cf", + "size": 93088, + "subdir": "linux-64", + "timestamp": 1522787550613, + "version": "0.14.1" + }, + "impyla-0.14.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "722e9774404eec45d0d4631ad98771bc", + "name": "impyla", + "sha256": "d4b0c77418bd12b8efc51727b9dca865fed1720d374b847b9bee621aa69df22d", + "size": 92362, + "subdir": "linux-64", + "timestamp": 1522787613060, + "version": "0.14.1" + }, + "impyla-0.14.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2ef3ea6f523a30dce8a72c43e4e8a8b8", + "name": "impyla", + "sha256": "ec672120da219a3cb5ef7a66738a8ec9d827864c3d966c4e3bcdbb407235dc89", + "size": 92644, + "subdir": "linux-64", + "timestamp": 1530893399207, + "version": "0.14.1" + }, + "impyla-0.14.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ab0d2a8748324e23d01f34d7715def18", + "name": "impyla", + "sha256": "d7b51be0feb528c30c063c81ef7bef23c7d48216306045877a4626adce90830c", + "size": 92043, + "subdir": "linux-64", + "timestamp": 1530893367689, + "version": "0.14.1" + }, + "impyla-0.14.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "thrift", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e37703b8b001cdd935385dd8018b1dd6", + "name": "impyla", + "sha256": "f3b4a85e85ae4c0793aed1859363c75eb348f4c4e5b6b7a9f35feae486010cf8", + "size": 221885, + "subdir": "linux-64", + "timestamp": 1556067466261, + "version": "0.14.2" + }, + "impyla-0.14.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a83e2e4efd9e3606242b030841a6a8fa", + "name": "impyla", + "sha256": "32424777acc813d7ffd4811c9d41bba822b0318fb14279209e9d912b2837a28a", + "size": 192859, + "subdir": "linux-64", + "timestamp": 1556067645775, + "version": "0.14.2" + }, + "impyla-0.14.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "503eddeb17c89de6afef47c098a6a24a", + "name": "impyla", + "sha256": "04b92eb548d30811a9e2f7049b2c95a29ec9ab29af2b397634165830dbe5c16a", + "size": 191964, + "subdir": "linux-64", + "timestamp": 1556067455974, + "version": "0.14.2" + }, + "impyla-0.15.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "thrift", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e025290f2b6d6ff51d21bb638ce02dd8", + "name": "impyla", + "sha256": "70ead97dd0a783441216323b8d71e9d353dac1e9dcd52910d22baa5cbbb67a7d", + "size": 326423, + "subdir": "linux-64", + "timestamp": 1559063928497, + "version": "0.15.0" + }, + "impyla-0.15.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6834b5ce27d82f53aa99925fa63a371f", + "name": "impyla", + "sha256": "f1e5136efac5bbbda6f9b035dc556caaf95fb65b1ff06b63f0ba14bf38b6cd94", + "size": 360706, + "subdir": "linux-64", + "timestamp": 1559063951692, + "version": "0.15.0" + }, + "impyla-0.15.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0741513923490501212adeaf89477b77", + "name": "impyla", + "sha256": "e8314334202561ef2906774b4ff4ab216b85244f1b7f5fc29f65444d2a2942a1", + "size": 360425, + "subdir": "linux-64", + "timestamp": 1559063865075, + "version": "0.15.0" + }, + "impyla-0.15.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.8,<3.9.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "75bc71bee5a75062ec6e4f18ab1504ff", + "name": "impyla", + "sha256": "ddbf8141b08297674adf65add4010a633114b162a3ce79900f79788dd5ca6eba", + "size": 364753, + "subdir": "linux-64", + "timestamp": 1574157921472, + "version": "0.15.0" + }, + "impyla-0.16.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.10,<3.11.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "09f8a3fed2a6af8ddedefacc4cf7bb58", + "name": "impyla", + "sha256": "45e2aeae5c446fc79f259f25210721333b8833f535e01700111455efd1bfafe6", + "size": 368886, + "subdir": "linux-64", + "timestamp": 1640812191322, + "version": "0.16.2" + }, + "impyla-0.16.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "04e6e851bfa4a5389619ebb0cda57980", + "name": "impyla", + "sha256": "f3cce472140c6cfa752cff3dc02dd0b289277d84771fa6fc13521734f067e509", + "size": 363776, + "subdir": "linux-64", + "timestamp": 1592228759779, + "version": "0.16.2" + }, + "impyla-0.16.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6ff2ca88e54ff33d4f1e8e7ac55fd9bc", + "name": "impyla", + "sha256": "d52324cbf21377d0d997c4b8b513d37beb4e9a561cc35bad03ade666fed2045b", + "size": 363410, + "subdir": "linux-64", + "timestamp": 1592228570415, + "version": "0.16.2" + }, + "impyla-0.16.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ecf4ab3cf4a85a23d6b7ade515d9da8a", + "name": "impyla", + "sha256": "b51c32e7ac7d3cf73b6822496ff18dce171e872dab0180e599ed448c96095130", + "size": 364992, + "subdir": "linux-64", + "timestamp": 1636035816587, + "version": "0.16.2" + }, + "impyla-0.16.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.8,<3.9.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7d5610565e96863c1604d806eee4f55b", + "name": "impyla", + "sha256": "9069f875dfd4397de28cc33ac6eb12c94ff1bfe158d46e4cf410584e435dd312", + "size": 368830, + "subdir": "linux-64", + "timestamp": 1592228759938, + "version": "0.16.2" + }, + "impyla-0.16.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.8,<3.9.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d58bad1fc7005e515ee2af76ed6f96bf", + "name": "impyla", + "sha256": "1ce8c63cd1246d49ebb916ec9ebde9a238693da7c10622190b4260879aaf905c", + "size": 367325, + "subdir": "linux-64", + "timestamp": 1636035818301, + "version": "0.16.2" + }, + "impyla-0.16.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.9,<3.10.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "67e9f69820e1febc9098b3dbb9416e79", + "name": "impyla", + "sha256": "33bfa2ec9d64bebebee9d7ae1132fc19f6ad201f00bf0984ce4e1b07946b6f24", + "size": 367822, + "subdir": "linux-64", + "timestamp": 1636035820340, + "version": "0.16.2" + }, + "impyla-0.16.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=3.10,<3.11.0a0", + "six", + "thriftpy2 >=0.4.0,<0.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "35f8acd90bffcf0dc783bd4d77e4b48b", + "name": "impyla", + "sha256": "1dce87f8f228cef375e088f67233e79a47d0a09055d26d834cbd3981bd2efa27", + "size": 417123, + "subdir": "linux-64", + "timestamp": 1677160437855, + "version": "0.16.3" + }, + "impyla-0.16.3-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=3.11,<3.12.0a0", + "six", + "thriftpy2 >=0.4.0,<0.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "197291ca3a9fb2e1f5650c33c869cf95", + "name": "impyla", + "sha256": "9f048363a3b284ca602398765259cc52224e609dfe10fd207b0d6ebbe1ae8ed3", + "size": 475396, + "subdir": "linux-64", + "timestamp": 1677125418024, + "version": "0.16.3" + }, + "impyla-0.16.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "49dd7957a9c74d7315d735e89ec6bdd2", + "name": "impyla", + "sha256": "6c9d6a6f4b531a3362a3c0512bce0a3b5cc2145f53e7d2c3b5852d6fdaef0b65", + "size": 363640, + "subdir": "linux-64", + "timestamp": 1602258512962, + "version": "0.16.3" + }, + "impyla-0.16.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a3dbf0363c5c241e2c03c112413d9f0d", + "name": "impyla", + "sha256": "8e060674ba34ab7f399dddc8bb9b4fea34c3cae19816d3aa8815d8b7d4a195c0", + "size": 363734, + "subdir": "linux-64", + "timestamp": 1632732177321, + "version": "0.16.3" + }, + "impyla-0.16.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "57b310ffc10c8eb9acbf35a92f98c598", + "name": "impyla", + "sha256": "975da1f469e561fd8510a61fa54b827e38cc29ae290d19d32abf4da9a3028d73", + "size": 363558, + "subdir": "linux-64", + "timestamp": 1602258517684, + "version": "0.16.3" + }, + "impyla-0.16.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6631a223ebecaa83b782fd9319725b26", + "name": "impyla", + "sha256": "1edbd3f0eb9c8b01e89f8ab51ea8e51ac576ff3c3dc538af7aafa657b9281427", + "size": 363204, + "subdir": "linux-64", + "timestamp": 1632742513329, + "version": "0.16.3" + }, + "impyla-0.16.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=3.7,<3.8.0a0", + "six", + "thriftpy2 >=0.4.0,<0.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "adf6c494c4df19f1753a1cef5ea6de75", + "name": "impyla", + "sha256": "6ab5f6f6a0676c0dad0ddf14c78e966d5d3fcf920b8992aa89b8a30c6c5838ec", + "size": 408400, + "subdir": "linux-64", + "timestamp": 1677160495553, + "version": "0.16.3" + }, + "impyla-0.16.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.8,<3.9.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a8bb916d2d23867f9aa1d79f2fcfd13f", + "name": "impyla", + "sha256": "26f58da9ffb160aed0a7f8b11fa4d8043587be5b9b5c0e3c253c6f8b07962e06", + "size": 365890, + "subdir": "linux-64", + "timestamp": 1602258519631, + "version": "0.16.3" + }, + "impyla-0.16.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.8,<3.9.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "06cf8eacac7b9fa6e45616c95ad3de4e", + "name": "impyla", + "sha256": "6218a59e8925240b2be87bc0050639b35ba07e6f69c053dc4c0753ba0ccbb950", + "size": 368097, + "subdir": "linux-64", + "timestamp": 1632742509905, + "version": "0.16.3" + }, + "impyla-0.16.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=3.8,<3.9.0a0", + "six", + "thriftpy2 >=0.4.0,<0.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2ff5974b6bbc460e93d06682dd1250bd", + "name": "impyla", + "sha256": "96be91aafb2d4f3a442c6c23b0b153e685a0fd9f2563241496b8a3137316773b", + "size": 414274, + "subdir": "linux-64", + "timestamp": 1677160524272, + "version": "0.16.3" + }, + "impyla-0.16.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bitarray", + "python >=3.9,<3.10.0a0", + "setuptools", + "six", + "thriftpy >=0.3.5" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "59378d895359d4c1ad4b5e95f59f733b", + "name": "impyla", + "sha256": "fcee303370bd298d571f0e193eb8ee91e7b890aed24c701aa0ede9c45f0143b8", + "size": 369024, + "subdir": "linux-64", + "timestamp": 1632742469081, + "version": "0.16.3" + }, + "impyla-0.16.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "bitarray", + "python >=3.9,<3.10.0a0", + "six", + "thriftpy2 >=0.4.0,<0.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c1c3d0527365545aa4ed99725543ee6c", + "name": "impyla", + "sha256": "01c85c07d7b105337f42e0bb76e7a088d9e13cc30c02f9069e62bfdc84bd551c", + "size": 414072, + "subdir": "linux-64", + "timestamp": 1677160466542, + "version": "0.16.3" + }, + "incremental-17.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "9521ac41efd7a57975853f82aec41956", + "name": "incremental", + "sha256": "be7a06d4d7d382f4a9d0de9521fffc6d7df0382d6dfe446da5c70187c1e46ca6", + "size": 25268, + "subdir": "linux-64", + "timestamp": 1530919745465, + "version": "17.5.0" + }, + "incremental-17.5.0-py27h1923969_0.conda": { + "build": "py27h1923969_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "cdc1467e9c1bbb891ce9688c87e0c73f", + "name": "incremental", + "sha256": "e37388968226ab7fafd3e0c2dc69b4792819b8287d998d1cbce34c603071228c", + "size": 25508, + "subdir": "linux-64", + "timestamp": 1508608341130, + "version": "17.5.0" + }, + "incremental-17.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "7fb36d2fc4b79755bf36edf28a63047f", + "name": "incremental", + "sha256": "11add3089fa98773950a86d4f0745ab49e4bd7a770528ea8572e1e5ac8d5f61c", + "size": 25889, + "subdir": "linux-64", + "timestamp": 1534350999806, + "version": "17.5.0" + }, + "incremental-17.5.0-py35head57c3_0.conda": { + "build": "py35head57c3_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "511b028c2364396568dcc79b13fd0c9d", + "name": "incremental", + "sha256": "5173db170f5cd20121a95e5dabd249e71947d49d8b53109b1c5e3d0787dae088", + "size": 26008, + "subdir": "linux-64", + "timestamp": 1508608357898, + "version": "17.5.0" + }, + "incremental-17.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "fdb81aaa51d273e7a995904ccaeddfa1", + "name": "incremental", + "sha256": "fe7408230d9d4be7d4930dd050af6001f42da4c81b0ed230e958c90f01f0a5e1", + "size": 25320, + "subdir": "linux-64", + "timestamp": 1530919689032, + "version": "17.5.0" + }, + "incremental-17.5.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "3d24a36a625887d26966b0a06e12e56f", + "name": "incremental", + "sha256": "1193d7817b128b46185c3484507b5865215fb1930442aede95b81366aa2da26d", + "size": 268835, + "subdir": "linux-64", + "timestamp": 1614067516025, + "version": "17.5.0" + }, + "incremental-17.5.0-py36hff7e2ee_0.conda": { + "build": "py36hff7e2ee_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "2e0c35c3d38686817ea946ce629a8bf0", + "name": "incremental", + "sha256": "ee5a8161b86e70c15d2ad5e2cdfa51e2c48570e3a0ac71cf60e1a5e1367a1104", + "size": 25762, + "subdir": "linux-64", + "timestamp": 1508608357827, + "version": "17.5.0" + }, + "incremental-17.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "c89db232d595998d7f8459103c46c2a6", + "name": "incremental", + "sha256": "7d7c1a6ec636c33b155cce2b48f4cc5cea9cc52fc886a763e6a2716b965c98ca", + "size": 25352, + "subdir": "linux-64", + "timestamp": 1530919717388, + "version": "17.5.0" + }, + "incremental-17.5.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "f70287022053a51e7ff1ae0a6858d9c4", + "name": "incremental", + "sha256": "ab61ac06f52f0ff52282cef8ff828a6dcd592c6c1e1e8db589b0f4c29ac55433", + "size": 268770, + "subdir": "linux-64", + "timestamp": 1614067501575, + "version": "17.5.0" + }, + "incremental-17.5.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "cec45c985603695dd40690ce0e796dac", + "name": "incremental", + "sha256": "3ee0181a2df9db8fcc901975b5c21736cb2949de2da26784398d84228b3c791d", + "size": 26102, + "subdir": "linux-64", + "timestamp": 1572357265596, + "version": "17.5.0" + }, + "incremental-17.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "c7e3bbfb54126e84288036399130b30d", + "name": "incremental", + "sha256": "52939e06573abe6e68c032ad351ed1e6969c4825b84fe420d79013af4b691a44", + "size": 268264, + "subdir": "linux-64", + "timestamp": 1614067507701, + "version": "17.5.0" + }, + "infinity-1.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a0010a6fa162ffa1f1da4b27f4cd8631", + "name": "infinity", + "sha256": "bf8a0ae3a61825ddb874b20494e3f71b8b913901837b0bdfe8ffa38b68e8a197", + "size": 7640, + "subdir": "linux-64", + "timestamp": 1530897681937, + "version": "1.4" + }, + "infinity-1.4-py27h1eb3021_0.conda": { + "build": "py27h1eb3021_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f1c9de399653c20e4d24819d5318bb37", + "name": "infinity", + "sha256": "23e935e255003bdba3f5fb4a3768a910aab06f1259df841d31dad7df18c2f7a6", + "size": 7878, + "subdir": "linux-64", + "timestamp": 1507384407568, + "version": "1.4" + }, + "infinity-1.4-py35hb24af9e_0.conda": { + "build": "py35hb24af9e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "adf932791031a464ddf01aec0c9624bb", + "name": "infinity", + "sha256": "2446ed3c30ac7e7fca97b9f2259e100dd4bd1991ed16adf98ea2f83e7bd99b96", + "size": 8109, + "subdir": "linux-64", + "timestamp": 1507384413971, + "version": "1.4" + }, + "infinity-1.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "27d384f57f7fabdf2e814930437e9a37", + "name": "infinity", + "sha256": "569b756d1be46c07c02222804050cb4391117eb3d105afee4bd45ddb38fe7213", + "size": 7749, + "subdir": "linux-64", + "timestamp": 1530897735851, + "version": "1.4" + }, + "infinity-1.4-py36h8fa02c4_0.conda": { + "build": "py36h8fa02c4_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7d2ea20b82a9e8ef4c7079058c69b9c8", + "name": "infinity", + "sha256": "30b6fa482192a130f6bf80bd4c381ba204caa1982bb4c17445eab8860a08993f", + "size": 7981, + "subdir": "linux-64", + "timestamp": 1507384419631, + "version": "1.4" + }, + "infinity-1.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "74a67a41dabe1e06ae414dbdb0b78261", + "name": "infinity", + "sha256": "d48f9c64e54b5cf03a2aea4b0e8bf6a9e3fb01dd3e3a4400b59ac165d9897fd9", + "size": 7797, + "subdir": "linux-64", + "timestamp": 1530897708536, + "version": "1.4" + }, + "infinity-1.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1635db96d5b371b6be6b52aba69cf48e", + "name": "infinity", + "sha256": "cc7a0cc12c1793b6ba40ebd870ddf96ee6c97fc100f354fa4fe56ab73c99d4f0", + "size": 8195, + "subdir": "linux-64", + "timestamp": 1572437472829, + "version": "1.4" + }, + "infinity-1.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f20d39d65c32543c97f386675d4cc25b", + "name": "infinity", + "sha256": "7b0e422c4ccdaefc88cb539111d88edffeb51c6e3445307e37b74a00d53321a5", + "size": 8022, + "subdir": "linux-64", + "timestamp": 1640791066922, + "version": "1.5" + }, + "infinity-1.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a5f103e2ac99470f2ceb27b5937bf891", + "name": "infinity", + "sha256": "d56ef6de5e0426fccf8d4092904db7ef4ada5b5c0bb1743a9e6ae6b9b4d36a4a", + "size": 8998, + "subdir": "linux-64", + "timestamp": 1676825277450, + "version": "1.5" + }, + "infinity-1.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a26bce00b8a303f10a9697773a7c23b7", + "name": "infinity", + "sha256": "00c5972669b2ad134467e4a5ba34075276d6b61d053cd2ee401f1d13ce0db100", + "size": 8722, + "subdir": "linux-64", + "timestamp": 1598411740229, + "version": "1.5" + }, + "infinity-1.5-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "89503ee3d71c328a86f18e34702a300d", + "name": "infinity", + "sha256": "bcc8c9b355e0f58bcb4a61c4dcf803bdddfc572f6f9754efcfd617e119f0d3c1", + "size": 8848, + "subdir": "linux-64", + "timestamp": 1613236247085, + "version": "1.5" + }, + "infinity-1.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "61aaa0939bc48fd382980c0472255c7e", + "name": "infinity", + "sha256": "7afa41e8873b40062b6e8a9169f87462b3556c4fd46842a89f87c7b6c6a285ab", + "size": 8732, + "subdir": "linux-64", + "timestamp": 1598411741799, + "version": "1.5" + }, + "infinity-1.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "92e12332ea88784e9ffc14647056a9fb", + "name": "infinity", + "sha256": "1e743f7347ca76c80f744c50c95aef4b31f337acd8b792bd21a8bd570c381668", + "size": 8837, + "subdir": "linux-64", + "timestamp": 1613236746180, + "version": "1.5" + }, + "infinity-1.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a90f8cb3ad43dfcf74e7b7e27bd29726", + "name": "infinity", + "sha256": "c2c1d1a5f9ab30f40935be6b9ff487a63e1fb4b97757d84182cdab2723984642", + "size": 8816, + "subdir": "linux-64", + "timestamp": 1598411766619, + "version": "1.5" + }, + "infinity-1.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "75d53b59c6486a55d660b52070fd1e15", + "name": "infinity", + "sha256": "6d68c11072d169f2b9f63caa5b63ffe7e1817337e924dc3edadc579db770eb90", + "size": 8834, + "subdir": "linux-64", + "timestamp": 1613236758242, + "version": "1.5" + }, + "infinity-1.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0a7058c2c9af3b251d7e77ee993e6a98", + "name": "infinity", + "sha256": "28a5a92640b0f5a3ad68f2ec3bc220d89b84e8ed3db1f5936eef0be5273243d9", + "size": 8933, + "subdir": "linux-64", + "timestamp": 1613236745794, + "version": "1.5" + }, + "inflect-4.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "063cfa324638e1db393b8d6ae73e6887", + "name": "inflect", + "sha256": "2e67fb81490df759d7908af1f5f49d3881107c91d24c893969e332c05f7e82e5", + "size": 60635, + "subdir": "linux-64", + "timestamp": 1580836718702, + "version": "4.1.0" + }, + "inflect-4.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d3be7f4079f1c6deb0d3ccc55565d2ca", + "name": "inflect", + "sha256": "4c959beb68083564d3be6aad3017621865c0f0b4ce5bbd701a1a450fb6967eec", + "size": 60877, + "subdir": "linux-64", + "timestamp": 1580836718073, + "version": "4.1.0" + }, + "inflect-4.1.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d10f783e5b2f5726dba2284f0468f6cd", + "name": "inflect", + "sha256": "5b52b4fd7d5288df00f3da86a0d65439df76f5ba68e611515d2d4026105c53bd", + "size": 55057, + "subdir": "linux-64", + "timestamp": 1594361274391, + "version": "4.1.0" + }, + "inflect-4.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ab7e70018d10d6f56afd69fd7b832ba", + "name": "inflect", + "sha256": "55e923166d3f21f0d6e8e33c089ee5a97761aae261ce24d8be9afede0ff4598e", + "size": 60909, + "subdir": "linux-64", + "timestamp": 1580836709008, + "version": "4.1.0" + }, + "inflect-5.0.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08193118c760d54fccb17c5fcae582d0", + "name": "inflect", + "sha256": "51cf5220276ae264a51292c9cf7393c6951366529d65dfff8e18920a3a5741dc", + "size": 59078, + "subdir": "linux-64", + "timestamp": 1606148662523, + "version": "5.0.2" + }, + "inflect-5.0.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a033a222a0d13ea092316ad00fcfcc46", + "name": "inflect", + "sha256": "cd597a90d9fa1feb7cde8ccfc73281ab2957cdbc204b340a3abc85229ccae7f7", + "size": 57265, + "subdir": "linux-64", + "timestamp": 1606148655177, + "version": "5.0.2" + }, + "inflect-5.0.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2bdd18a73610985453ee0430c62ade9", + "name": "inflect", + "sha256": "d9b29038df6a267b3588b69301455d18a6dd7746e466fd20a31c0ff6c0018c9e", + "size": 56061, + "subdir": "linux-64", + "timestamp": 1606148648606, + "version": "5.0.2" + }, + "inflect-5.0.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11b84942fef4dbbffb3c0909b4e0f03b", + "name": "inflect", + "sha256": "e8952ba1a06dfb43ce70d235a7e7b36ea8d6366bbed17cabea6b9f9793d0b52f", + "size": 57018, + "subdir": "linux-64", + "timestamp": 1606148629502, + "version": "5.0.2" + }, + "inflect-5.2.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "importlib-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c53c160a722f163a266685695dfbc0c3", + "name": "inflect", + "sha256": "bc4fc89ba6187a709fa93fda2b046d74c07d3a6fe62bc81dcf0ca368ce5aa1e3", + "size": 60728, + "subdir": "linux-64", + "timestamp": 1614363006456, + "version": "5.2.0" + }, + "inflect-5.2.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01bc9351d9ff8fce769e846e83e21d5a", + "name": "inflect", + "sha256": "d2a8ecc3a566d76ff5295623295a64408531440630345edd60695f3e85e9b699", + "size": 57628, + "subdir": "linux-64", + "timestamp": 1614363007942, + "version": "5.2.0" + }, + "inflect-5.2.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "270e083b543e40011ec662dfa1fadbaf", + "name": "inflect", + "sha256": "8b6f1e4067fb89621422e52cb54feca0e7da86fca9253929c99d13aabbf0170f", + "size": 57939, + "subdir": "linux-64", + "timestamp": 1614363053311, + "version": "5.2.0" + }, + "inflect-5.2.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77579b39207523532ad8e17e4dafa24b", + "name": "inflect", + "sha256": "2a07d8385642878f927d1ca4597c0e685750a8a182a13bb8e42fa652a98c3897", + "size": 57001, + "subdir": "linux-64", + "timestamp": 1614361950139, + "version": "5.2.0" + }, + "inflect-5.3.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc3853ab4b28d70b2d3319879d91fb5f", + "name": "inflect", + "sha256": "270bbaf9a73e1939c9de326ba5f9062b41fd977438bf0d2941a445cab115b74d", + "size": 58056, + "subdir": "linux-64", + "timestamp": 1640809420882, + "version": "5.3.0" + }, + "inflect-5.3.0-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "adc48253c37174bf34d414964dd9f02b", + "name": "inflect", + "sha256": "38d0a3c0150d10f5622cedf3d565135ba7bbf95b0d0097f0a1c73bd4775b363a", + "size": 74730, + "subdir": "linux-64", + "timestamp": 1676852857740, + "version": "5.3.0" + }, + "inflect-5.3.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "importlib-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9f1c6f44b37698023b7b3d404509ec7", + "name": "inflect", + "sha256": "0c309790cd9db98ad6f391be5539226c34603fa90a8713533a23658d700dd48e", + "size": 60025, + "subdir": "linux-64", + "timestamp": 1614797335387, + "version": "5.3.0" + }, + "inflect-5.3.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62b82591a24913a53465c675ce6f4036", + "name": "inflect", + "sha256": "11fb51ec59bf6253006e1a40853b6d74505fc69549ad6a61c75f3e73979a79bc", + "size": 58039, + "subdir": "linux-64", + "timestamp": 1614796047577, + "version": "5.3.0" + }, + "inflect-5.3.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "97f0031de7f468afb137b7cb57a51e33", + "name": "inflect", + "sha256": "cdbdfed452c35463ec7b1266f2f9781d769ce2eed8345cf4afedd6dc230bc850", + "size": 59747, + "subdir": "linux-64", + "timestamp": 1614797338017, + "version": "5.3.0" + }, + "inflect-5.3.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c8430f78f19d1810af665630b25afcd1", + "name": "inflect", + "sha256": "317a5ea5d9d8bd9b981127615b800c80b90d3ce3e6b07d2dce636e001f39de46", + "size": 60039, + "subdir": "linux-64", + "timestamp": 1614797335438, + "version": "5.3.0" + }, + "inflection-0.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5c07fa37454bee0a9aa2f22407ae5d5d", + "name": "inflection", + "sha256": "e4615773d47e1b7c161aa86c1d227a52f7f408b9670e9cbb167e84649467d983", + "size": 11217, + "subdir": "linux-64", + "timestamp": 1530923300192, + "version": "0.3.1" + }, + "inflection-0.3.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ab6cb4592bcb72ca7a5d5132cb09a32c", + "name": "inflection", + "sha256": "68a475752673b24d5b1cdf176c35d824b0db5c75539ccf21f4f6c30ab7d0adf2", + "size": 11304, + "subdir": "linux-64", + "timestamp": 1536247755827, + "version": "0.3.1" + }, + "inflection-0.3.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "65d02e1e250870fc0dfd048e2007f7e0", + "name": "inflection", + "sha256": "68b6940ae617dd675aa4e44153cb64e511b20cbbe8a70d6599e90410eaebde53", + "size": 11349, + "subdir": "linux-64", + "timestamp": 1536247747479, + "version": "0.3.1" + }, + "inflection-0.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "03a8cb5dfec81492138e21093c1b1683", + "name": "inflection", + "sha256": "ef0fde7c926277a5bd8b310f7d8df9b7b63772ebf70abb54fdde85f231b51b97", + "size": 11068, + "subdir": "linux-64", + "timestamp": 1530923233883, + "version": "0.3.1" + }, + "inflection-0.3.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b2b4118503332a8f1bdbc4c73b3127e6", + "name": "inflection", + "sha256": "6c54cdf3aaa05eaebddbfaa6d5e9b5eb6d022733c1ed6fd4a443dc6a230e4b21", + "size": 11241, + "subdir": "linux-64", + "timestamp": 1536247680850, + "version": "0.3.1" + }, + "inflection-0.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a20db3f50cf5e17ee867aeacbd0049c7", + "name": "inflection", + "sha256": "7c4d29f56f6b214276ba9e2dcdc1af3c5e1f09df63e6d91211a5dc5f467cbdad", + "size": 10967, + "subdir": "linux-64", + "timestamp": 1530923266715, + "version": "0.3.1" + }, + "inflection-0.3.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "779caa39f826d69ee3abe46c4c71e2b6", + "name": "inflection", + "sha256": "fef293d2976bf9ae54a0d02da5ba78ada0b299ca8b2135bcecf0080166231c2c", + "size": 10974, + "subdir": "linux-64", + "timestamp": 1536247755949, + "version": "0.3.1" + }, + "inflection-0.3.1-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "cf8a3bbbbd38fe908f0c091c747c673e", + "name": "inflection", + "sha256": "d458755383ded51f9e8d3be8b0118ea689d956907299a28b53de10c9ccc62c6c", + "size": 11431, + "subdir": "linux-64", + "timestamp": 1572437492238, + "version": "0.3.1" + }, + "inflection-0.5.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "32f93a417dfdd434c6e26a2ba212b82d", + "name": "inflection", + "sha256": "53b63e3040bd44f194eb6d105274d5ae0ba44f4c42a098285ef720d4793c7fef", + "size": 11188, + "subdir": "linux-64", + "timestamp": 1640791083957, + "version": "0.5.1" + }, + "inflection-0.5.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "95556c01f688df51c3b4676617813410", + "name": "inflection", + "sha256": "ff5a415ec7136877b00b6530e3a899292fb31dbee63a8c89e28e9a9d0094a0f6", + "size": 13366, + "subdir": "linux-64", + "timestamp": 1676827910382, + "version": "0.5.1" + }, + "inflection-0.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a9be9dc4cb91c63941e0cf6c9f4c3f60", + "name": "inflection", + "sha256": "e68dc8ac02f4771a8395a4ecd889c2f6ca8ad1a9e9871e8431c266ac62524aa1", + "size": 12394, + "subdir": "linux-64", + "timestamp": 1598401857257, + "version": "0.5.1" + }, + "inflection-0.5.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d3fa451d315ad2c9a712149e6ecbe9d5", + "name": "inflection", + "sha256": "b497725c1f0fc25fc19d59854be208bd5e1aad25a2f1e9d5f8e06d2b23f0885d", + "size": 12469, + "subdir": "linux-64", + "timestamp": 1611675362382, + "version": "0.5.1" + }, + "inflection-0.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "37d1d920fb01f090ced34db0aff3625e", + "name": "inflection", + "sha256": "acc9e599ee65db46954b16864bd5393387f7454af6ae8607775122347514f502", + "size": 12062, + "subdir": "linux-64", + "timestamp": 1598401854111, + "version": "0.5.1" + }, + "inflection-0.5.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e127085e69ac672ed640f30c210ffa8c", + "name": "inflection", + "sha256": "adf844903ffeffbcacf853b8ef1641a1560783c38457d98f46b2b6673721571a", + "size": 12228, + "subdir": "linux-64", + "timestamp": 1611675309732, + "version": "0.5.1" + }, + "inflection-0.5.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "3e04c8d53b31872f8dba3b71072b8b6e", + "name": "inflection", + "sha256": "4df2c7522e1aafebd60dee0126e792a457248af1ed4b4c8bd9ae22b8f1b2e5f8", + "size": 12219, + "subdir": "linux-64", + "timestamp": 1598401883183, + "version": "0.5.1" + }, + "inflection-0.5.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "46699936514aac980bcc761fbcdc90e5", + "name": "inflection", + "sha256": "4661c007b4d290cde907fc1214e8f7becdad0dfbd6f8b983ab4764f7c6acbe6c", + "size": 12307, + "subdir": "linux-64", + "timestamp": 1611675361301, + "version": "0.5.1" + }, + "inflection-0.5.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "b29f9c8baa25ba348f0c553d2b02e423", + "name": "inflection", + "sha256": "548975a5cc85bb00f85c7840aaa43b7cba851c7778f84e63757f3b63c837a37a", + "size": 12231, + "subdir": "linux-64", + "timestamp": 1611675359323, + "version": "0.5.1" + }, + "intake-0.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs", + "dask >=0.17.0", + "holoviews", + "jinja2", + "msgpack-numpy", + "msgpack-python", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "python-snappy", + "requests", + "ruamel_yaml >=0.15.0", + "tornado >=4.5.1" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e923255af600ef1411d212354e02aa2e", + "name": "intake", + "sha256": "8acca15fe3a4be04990bfa51a743f2dfe5ab12dcb6935dad77ad2c3946da7fd3", + "size": 2709619, + "subdir": "linux-64", + "timestamp": 1547677151278, + "version": "0.3.0" + }, + "intake-0.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs", + "dask >=0.17.0", + "holoviews", + "jinja2", + "msgpack-numpy", + "msgpack-python", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "python-snappy", + "requests", + "ruamel_yaml >=0.15.0", + "tornado >=4.5.1" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "10988575de7b97ce052f0d2aa6bfd9ae", + "name": "intake", + "sha256": "b8e78fe0c02d2d931e5e9f2edad3146e3fb59339c139f02e6cd3d4b05a1a7ad9", + "size": 2734611, + "subdir": "linux-64", + "timestamp": 1548432632688, + "version": "0.4.1" + }, + "intake-0.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs", + "dask >=0.17.0", + "holoviews", + "jinja2", + "msgpack-numpy", + "msgpack-python", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "python-snappy", + "requests", + "ruamel_yaml >=0.15.0", + "tornado >=4.5.1" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "6678ccc7de3d040c4af75bf7cbbdc94b", + "name": "intake", + "sha256": "35905c3bb6b754974d71f1f491bbd224eec97add03444fb450699e77e1fc57e7", + "size": 2734602, + "subdir": "linux-64", + "timestamp": 1548432622531, + "version": "0.4.1" + }, + "intake-0.6.6-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "hvplot", + "bokeh", + "panel >=0.7.0" + ], + "depends": [ + "appdirs", + "dask-core", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.10,<3.11.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f3020aef650632910e9ae2f6c6664863", + "name": "intake", + "sha256": "dcf3a9a2fd69036012cdb008be60c483ae6ff88ee42b82c8aa7ecec1b7c3ec94", + "size": 207880, + "subdir": "linux-64", + "timestamp": 1668767499603, + "version": "0.6.6" + }, + "intake-0.6.6-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "panel >=0.7.0", + "bokeh", + "hvplot" + ], + "depends": [ + "appdirs", + "dask-core", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.11,<3.12.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "dd6612de3f2ec141691cd73731b2a0bb", + "name": "intake", + "sha256": "7aed835fe1fc5032fe0f6bf6147a1d0e61ed75d3bf416faf0efcd89165696a38", + "size": 264098, + "subdir": "linux-64", + "timestamp": 1676844327922, + "version": "0.6.6" + }, + "intake-0.6.6-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "hvplot", + "bokeh", + "panel >=0.7.0" + ], + "depends": [ + "appdirs", + "dask-core", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.7,<3.8.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "80179361adbb793415b1a9b3491504ac", + "name": "intake", + "sha256": "7e5c58eb9760c0c9bfa6755cb94c5f49c3e91ba50b35089a32ff76f8539c5348", + "size": 204549, + "subdir": "linux-64", + "timestamp": 1668767463678, + "version": "0.6.6" + }, + "intake-0.6.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "hvplot", + "bokeh", + "panel >=0.7.0" + ], + "depends": [ + "appdirs", + "dask-core", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.8,<3.9.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "116721ee7ac4dddb7a8f4a6b6cd0e7f3", + "name": "intake", + "sha256": "07ee370b81bd74a679806abd0a56427fa93cb1caa1fe61586e09c64489518de3", + "size": 205844, + "subdir": "linux-64", + "timestamp": 1668767566829, + "version": "0.6.6" + }, + "intake-0.6.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "hvplot", + "bokeh", + "panel >=0.7.0" + ], + "depends": [ + "appdirs", + "dask-core", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.9,<3.10.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "654c05fa6e69867393c58ffba73dde9a", + "name": "intake", + "sha256": "355f7dcb59fd28ef8e7f5f5109a646294c973a1639a4310fdf142cd1206480e6", + "size": 205915, + "subdir": "linux-64", + "timestamp": 1668767532901, + "version": "0.6.6" + }, + "intake-0.6.7-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "hvplot", + "panel >=0.7.0", + "bokeh" + ], + "depends": [ + "appdirs", + "dask >=1.0", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.10,<3.11.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e0d98dfefe4e5acdc97f943373083456", + "name": "intake", + "sha256": "075928ced4a73bfc74658b67ee5a2b0c63e4f3c8c24aa651a5b5d18fdef4ae75", + "size": 214919, + "subdir": "linux-64", + "timestamp": 1676619951562, + "version": "0.6.7" + }, + "intake-0.6.7-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "hvplot", + "panel >=0.7.0", + "bokeh" + ], + "depends": [ + "appdirs", + "dask >=1.0", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.8,<3.9.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "114b6d587b96563feb6014f95d6f43c6", + "name": "intake", + "sha256": "2fd7aa6f730482d1833b8f709b3ad2a4cf9f5d55e4f50d26870347ac94930e93", + "size": 212749, + "subdir": "linux-64", + "timestamp": 1676619898218, + "version": "0.6.7" + }, + "intake-0.6.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "hvplot", + "panel >=0.7.0", + "bokeh" + ], + "depends": [ + "appdirs", + "dask >=1.0", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.9,<3.10.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ca96ce16d9212224ccf0b79a49b20ee3", + "name": "intake", + "sha256": "55478fe8a496e1b0c5b525b91b8db243f82ab2d8a874b4828827f489a2f5d738", + "size": 212737, + "subdir": "linux-64", + "timestamp": 1676619999457, + "version": "0.6.7" + }, + "intake-0.6.8-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "panel >=0.7.0", + "hvplot", + "bokeh" + ], + "depends": [ + "appdirs", + "dask >=1.0", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.10,<3.11.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f0f4470f2e88ff357563ac39f0e2bf2d", + "name": "intake", + "sha256": "97c16c8250f2d505de38be8e3859a3b9e2c4ae0dfc2c6f5f6541c5adcc9e49c6", + "size": 214880, + "subdir": "linux-64", + "timestamp": 1678787739687, + "version": "0.6.8" + }, + "intake-0.6.8-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "hvplot", + "panel >=0.7.0", + "bokeh" + ], + "depends": [ + "appdirs", + "dask >=1.0", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.11,<3.12.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9d2c5d94e2541c4d69e12901721effd4", + "name": "intake", + "sha256": "eed0ab50a3716b774dcce0f17fe1182aacd343a555c4afcd4c03da45fd6b97da", + "size": 270816, + "subdir": "linux-64", + "timestamp": 1679336493260, + "version": "0.6.8" + }, + "intake-0.6.8-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "panel >=0.7.0", + "hvplot", + "bokeh" + ], + "depends": [ + "appdirs", + "dask >=1.0", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.8,<3.9.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "dba1cda75f4ba25cb5276c3fa8f1385b", + "name": "intake", + "sha256": "e6c759fc7a7aa4993fe94d1110e1a830634a2f996bbc07cbd1b50999fc6f5a8d", + "size": 212615, + "subdir": "linux-64", + "timestamp": 1678787690195, + "version": "0.6.8" + }, + "intake-0.6.8-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "panel >=0.7.0", + "hvplot", + "bokeh" + ], + "depends": [ + "appdirs", + "dask >=1.0", + "entrypoints", + "fsspec >=2021.7.0", + "jinja2", + "msgpack-python", + "python >=3.9,<3.10.0a0", + "python-snappy", + "pyyaml", + "requests", + "tornado" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "36367ac0a76be6ba9df04ffaed269c21", + "name": "intake", + "sha256": "163d1c3c490679584d4e7f13664118f0f53634ef7a908a2333d1dcb8c2adfcb7", + "size": 212735, + "subdir": "linux-64", + "timestamp": 1678787636365, + "version": "0.6.8" + }, + "intake-xarray-0.6.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dask-core >=2.2", + "fsspec >=2022", + "intake >=0.6.6", + "msgpack-python", + "netcdf4", + "python >=3.10,<3.11.0a0", + "requests", + "xarray >=2022", + "zarr" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d5f7db48d53130651f68a9afbceb6e10", + "name": "intake-xarray", + "sha256": "8da0b0c56ac678da02d4a049dc7287ce23eae78083d178414bd0a815469c9abd", + "size": 1639433, + "subdir": "linux-64", + "timestamp": 1669628930104, + "version": "0.6.1" + }, + "intake-xarray-0.6.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "dask-core >=2.2", + "fsspec >=2022", + "intake >=0.6.6", + "msgpack-python", + "netcdf4", + "python >=3.11,<3.12.0a0", + "requests", + "xarray >=2022", + "zarr" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "dc08720255311669e58f45e4e3fe6f62", + "name": "intake-xarray", + "sha256": "1cb56693e21fce91ee3c033506cc024713eac3d4974e8cf928afb655ea45319a", + "size": 1543622, + "subdir": "linux-64", + "timestamp": 1676852874065, + "version": "0.6.1" + }, + "intake-xarray-0.6.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dask-core >=2.2", + "fsspec >=2022", + "intake >=0.6.6", + "msgpack-python", + "netcdf4", + "python >=3.8,<3.9.0a0", + "requests", + "xarray >=2022", + "zarr" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b604c8791647bea5368402e55fb9226a", + "name": "intake-xarray", + "sha256": "8dbc91c80667f519ed2f0c51dd9292eb11f1c1b0732fad69798ddd88a21c79fe", + "size": 1638534, + "subdir": "linux-64", + "timestamp": 1669629023511, + "version": "0.6.1" + }, + "intake-xarray-0.6.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dask-core >=2.2", + "fsspec >=2022", + "intake >=0.6.6", + "msgpack-python", + "netcdf4", + "python >=3.9,<3.10.0a0", + "requests", + "xarray >=2022", + "zarr" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "323458dc96f3a135b5c5aaead79394f1", + "name": "intake-xarray", + "sha256": "4d108a28e1f4dcb4d522160d24493399c792c162541690fc1b37b4e84500dec7", + "size": 1638507, + "subdir": "linux-64", + "timestamp": 1669628977358, + "version": "0.6.1" + }, + "intel-cmplr-lib-rt-2021.3.0-h06a4308_3350.conda": { + "build": "h06a4308_3350", + "build_number": 3350, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "8bf593b63c1d56675aafc85d5f804260", + "name": "intel-cmplr-lib-rt", + "sha256": "29fe0f8506d35bda4d3ddcdf2cfc1b9936717a238ce35938f7c5a57f396886b9", + "size": 21781406, + "subdir": "linux-64", + "timestamp": 1626976023087, + "version": "2021.3.0" + }, + "intel-cmplr-lib-rt-2021.4.0-h06a4308_3561.conda": { + "build": "h06a4308_3561", + "build_number": 3561, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "5eef1507cdac73b290cee482147f432c", + "name": "intel-cmplr-lib-rt", + "sha256": "fbc5a9f5601b44940101e593062584d5c1e25ad03362a79dc6433b9f78bdd580", + "size": 22871904, + "subdir": "linux-64", + "timestamp": 1641816003446, + "version": "2021.4.0" + }, + "intel-cmplr-lib-rt-2022.0.1-h06a4308_3633.conda": { + "build": "h06a4308_3633", + "build_number": 3633, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "6af154078a8ad446e017721e95777de2", + "name": "intel-cmplr-lib-rt", + "sha256": "345f215ecdfc57acb277ba39d3b966c839ef72dd692113a4fe33c95042cfb875", + "size": 22473664, + "subdir": "linux-64", + "timestamp": 1642778486847, + "version": "2022.0.1" + }, + "intel-cmplr-lib-rt-2022.1.0-h06a4308_3768.conda": { + "build": "h06a4308_3768", + "build_number": 3768, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "e69f866e904ead27d8a1ed4ccf9c657f", + "name": "intel-cmplr-lib-rt", + "sha256": "990d4466f29c7f032c8d5de42b60f56171ccf373701f27dc07a9d134efa9e319", + "size": 28658087, + "subdir": "linux-64", + "timestamp": 1667585029156, + "version": "2022.1.0" + }, + "intel-cmplr-lib-rt-2023.0.0-h06a4308_25370.conda": { + "build": "h06a4308_25370", + "build_number": 25370, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "6183da47ffa17e109a2248a94320ef9a", + "name": "intel-cmplr-lib-rt", + "sha256": "e58c24c1ac330056af25b3ac2da15b3a3cb6751bc65aa8bac6b8d190aa1cf596", + "size": 32480310, + "subdir": "linux-64", + "timestamp": 1679614919821, + "version": "2023.0.0" + }, + "intel-cmplr-lic-rt-2021.3.0-h06a4308_3350.conda": { + "build": "h06a4308_3350", + "build_number": 3350, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "6e37a75ee206d79c38f9e3090f690887", + "name": "intel-cmplr-lic-rt", + "sha256": "5f88e98f6888ad107ddf341843c54eacfce4a78551903b62e7a87b708b73fb1a", + "size": 27314, + "subdir": "linux-64", + "timestamp": 1626976049328, + "version": "2021.3.0" + }, + "intel-cmplr-lic-rt-2021.4.0-h06a4308_3561.conda": { + "build": "h06a4308_3561", + "build_number": 3561, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "951fd19a95aaf5076f3320a4f30ed0f3", + "name": "intel-cmplr-lic-rt", + "sha256": "ba695b78a9dda13a98c1065af5614f352ef8bb4bfa29f6b988f69f913af165c0", + "size": 27581, + "subdir": "linux-64", + "timestamp": 1641816030306, + "version": "2021.4.0" + }, + "intel-cmplr-lic-rt-2022.0.1-h06a4308_3633.conda": { + "build": "h06a4308_3633", + "build_number": 3633, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "e957a68437b535aeb1bbfa00cbc01b39", + "name": "intel-cmplr-lic-rt", + "sha256": "f33486f2d506220ada3a48d5e4e376ff4fd8e04d73fd35b1d5f1e58c9a91582a", + "size": 25329, + "subdir": "linux-64", + "timestamp": 1642778514661, + "version": "2022.0.1" + }, + "intel-cmplr-lic-rt-2022.1.0-h06a4308_3768.conda": { + "build": "h06a4308_3768", + "build_number": 3768, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "d3018dd1734e823124ab14d035385430", + "name": "intel-cmplr-lic-rt", + "sha256": "7ad45cf4299452b0f3c53f09fcf407e8d1b8ecd737a00a4489cbb39b6d6a91a4", + "size": 29751, + "subdir": "linux-64", + "timestamp": 1667585053432, + "version": "2022.1.0" + }, + "intel-cmplr-lic-rt-2023.0.0-h06a4308_25370.conda": { + "build": "h06a4308_25370", + "build_number": 25370, + "depends": [], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "73cb77456dacf7045206afca7f26fba6", + "name": "intel-cmplr-lic-rt", + "sha256": "569dcd0f3cbac67d2cebc7f7e49d575b70518eb1b9a71cf0dc0410812f07ffec", + "size": 30147, + "subdir": "linux-64", + "timestamp": 1679614947442, + "version": "2023.0.0" + }, + "intel-fortran-rt-2021.3.0-h06a4308_3350.conda": { + "build": "h06a4308_3350", + "build_number": 3350, + "depends": [ + "intel-cmplr-lib-rt 2021.3.0 h06a4308_3350", + "intel-cmplr-lic-rt 2021.3.0 h06a4308_3350", + "intel-openmp 2021.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "71a8d2b9fa518e2d7326b31eed76870d", + "name": "intel-fortran-rt", + "sha256": "44bed6be28b0c7ebb9470ed9428db837da09bcf6aa649f1265a44b467809d83f", + "size": 674810, + "subdir": "linux-64", + "timestamp": 1626976072168, + "version": "2021.3.0" + }, + "intel-fortran-rt-2021.4.0-h06a4308_3561.conda": { + "build": "h06a4308_3561", + "build_number": 3561, + "depends": [ + "intel-cmplr-lib-rt 2021.4.0 h06a4308_3561", + "intel-cmplr-lic-rt 2021.4.0 h06a4308_3561", + "intel-openmp 2021.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "a1cc338aac646809570453b7a9607542", + "name": "intel-fortran-rt", + "sha256": "052bd6c22e80800804678eac5511e404b66327cdf2b81fe722c552f8eac107ca", + "size": 658839, + "subdir": "linux-64", + "timestamp": 1641816045790, + "version": "2021.4.0" + }, + "intel-fortran-rt-2022.0.1-h06a4308_3633.conda": { + "build": "h06a4308_3633", + "build_number": 3633, + "depends": [ + "intel-cmplr-lib-rt 2022.0.1 h06a4308_3633", + "intel-cmplr-lic-rt 2022.0.1 h06a4308_3633", + "intel-openmp 2022.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "1046fd9e5dc2745e31baca7c7141fb76", + "name": "intel-fortran-rt", + "sha256": "8860a5a1488fe448bf4f3aa122ce693eb4f618bc21c138a735df389079522ff5", + "size": 659521, + "subdir": "linux-64", + "timestamp": 1642778527588, + "version": "2022.0.1" + }, + "intel-fortran-rt-2022.1.0-h06a4308_3768.conda": { + "build": "h06a4308_3768", + "build_number": 3768, + "depends": [ + "intel-cmplr-lib-rt 2022.1.0 h06a4308_3768", + "intel-cmplr-lic-rt 2022.1.0 h06a4308_3768", + "intel-openmp 2022.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "e8906a61bbc30e3927d11b877cab26af", + "name": "intel-fortran-rt", + "sha256": "ff702d83601e1fae716ba8ed6f8eeb213e8bb43b771a9e58b7bfbc19cfcd57e6", + "size": 728943, + "subdir": "linux-64", + "timestamp": 1667585064645, + "version": "2022.1.0" + }, + "intel-fortran-rt-2023.0.0-h06a4308_25370.conda": { + "build": "h06a4308_25370", + "build_number": 25370, + "depends": [ + "intel-cmplr-lib-rt 2023.0.0 h06a4308_25370", + "intel-cmplr-lic-rt 2023.0.0 h06a4308_25370", + "intel-openmp 2023.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "454f5b041fb36c0360410a20ec2ed7d3", + "name": "intel-fortran-rt", + "sha256": "ebbbb3e966fcc5eaec3b53e9562794c2a05d24c206603b2f64e9c72f487bbd6e", + "size": 674266, + "subdir": "linux-64", + "timestamp": 1679614960176, + "version": "2023.0.0" + }, + "intel-opencl-rt-2021.3.0-h06a4308_3350.conda": { + "build": "h06a4308_3350", + "build_number": 3350, + "depends": [ + "intel-cmplr-lic-rt 2021.3.0 h06a4308_3350", + "intel-openmp 2021.*", + "tbb 2021.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "6767e224e473303dec3b73ec63c1cd77", + "name": "intel-opencl-rt", + "sha256": "38f0e876b26a4300ae2f14a4b6145d955b4f05f72986e8555b75621b1b4dbbda", + "size": 52626621, + "subdir": "linux-64", + "timestamp": 1626976158872, + "version": "2021.3.0" + }, + "intel-opencl-rt-2021.4.0-h06a4308_3561.conda": { + "build": "h06a4308_3561", + "build_number": 3561, + "depends": [ + "intel-cmplr-lic-rt 2021.4.0 h06a4308_3561", + "intel-openmp 2021.*", + "tbb 2021.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "d0aa62d779c82c85b7659536324534d3", + "name": "intel-opencl-rt", + "sha256": "4a35782f3c16560293295655e9a760278cdf90a635056c9cdee8085679c53f7c", + "size": 46391806, + "subdir": "linux-64", + "timestamp": 1641816073673, + "version": "2021.4.0" + }, + "intel-opencl-rt-2022.0.1-h06a4308_3633.conda": { + "build": "h06a4308_3633", + "build_number": 3633, + "depends": [ + "intel-cmplr-lic-rt 2022.0.1 h06a4308_3633", + "intel-openmp 2022.*", + "tbb 2021.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "cbafb6dcb4ef5975594a7179524d4364", + "name": "intel-opencl-rt", + "sha256": "f8eff92b92f278191c3e4d1969ab8ad11df16883973312fa48b6b2e1f7c3f8c1", + "size": 63786664, + "subdir": "linux-64", + "timestamp": 1642778672185, + "version": "2022.0.1" + }, + "intel-opencl-rt-2022.1.0-h06a4308_3768.conda": { + "build": "h06a4308_3768", + "build_number": 3768, + "depends": [ + "intel-cmplr-lic-rt 2022.1.0 h06a4308_3768", + "intel-openmp 2022.*", + "tbb 2021.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "a4d18089a58558f07860e2da1436bf1c", + "name": "intel-opencl-rt", + "sha256": "39e1d865a03f76dc8263c148ddf89127383a82ed51ef2c577fff84e5235f3f56", + "size": 114656609, + "subdir": "linux-64", + "timestamp": 1667585079825, + "version": "2022.1.0" + }, + "intel-opencl-rt-2023.0.0-h06a4308_25370.conda": { + "build": "h06a4308_25370", + "build_number": 25370, + "depends": [ + "intel-cmplr-lic-rt 2023.0.0 h06a4308_25370", + "intel-openmp 2023.*", + "tbb 2021.*" + ], + "license": "Intel End User License Agreement for Developer Tools", + "license_family": "Proprietary", + "md5": "0b114fe99a6e5d1a140d0bf499dfe491", + "name": "intel-opencl-rt", + "sha256": "6e332ed85a7cf568f6357a1f1b288fcb3ca822e95b8ad7f514d636c48e4b28d8", + "size": 150517460, + "subdir": "linux-64", + "timestamp": 1679614975597, + "version": "2023.0.0" + }, + "intel-openmp-2017.0.4-hf7c01fb_0.conda": { + "build": "hf7c01fb_0", + "build_number": 0, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "8681355c67c6a05ec656e10310bfebb2", + "name": "intel-openmp", + "sha256": "f45807b5d64e00e95ebbfc4049a4b5e1887fa193f281cb602620bac64c8966bb", + "size": 543151, + "subdir": "linux-64", + "timestamp": 1508962801421, + "version": "2017.0.4" + }, + "intel-openmp-2018.0.0-8.conda": { + "build": "8", + "build_number": 8, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "cb45f16508802330d7bf45263f8d6917", + "name": "intel-openmp", + "sha256": "eff2805f4c5684992b8355c1d55b21c14ec57faede1ee9b5ebdf6e6630390d21", + "size": 545495, + "subdir": "linux-64", + "timestamp": 1521735596719, + "version": "2018.0.0" + }, + "intel-openmp-2018.0.0-h15fc484_7.conda": { + "build": "h15fc484_7", + "build_number": 7, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "1d0074aeba6c7f7acbf274fd9b3b699e", + "name": "intel-openmp", + "sha256": "f7fd614a0cacb618000df33c834d1b853375883f59db1f1264a5d17ca03f247b", + "size": 542825, + "subdir": "linux-64", + "timestamp": 1505745611021, + "version": "2018.0.0" + }, + "intel-openmp-2018.0.0-hc7b2577_8.conda": { + "build": "hc7b2577_8", + "build_number": 8, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "daf43f0c33e1bcb7c2bf58fd8fe8439a", + "name": "intel-openmp", + "sha256": "1a283018dd5bfe2afa9056b68a081f139635f420e84a9d9712f8c7c264c6354c", + "size": 543475, + "subdir": "linux-64", + "timestamp": 1511376416187, + "version": "2018.0.0" + }, + "intel-openmp-2018.0.3-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "66d8d81da977264c8991c9148cf22c1c", + "name": "intel-openmp", + "sha256": "d7e1f7628fa1a6ceb0fe94408bbd5385141e7f8102d1227fdf7e558aae90bd51", + "size": 618860, + "subdir": "linux-64", + "timestamp": 1528122050163, + "version": "2018.0.3" + }, + "intel-openmp-2019.0-117.conda": { + "build": "117", + "build_number": 117, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "4eb84ade751c098edf44789b067d2371", + "name": "intel-openmp", + "sha256": "b06ff0202b88413c4c494eb19006d92b75c5a7cd53500f9622092628e1d1f01d", + "size": 633129, + "subdir": "linux-64", + "timestamp": 1536594375868, + "version": "2019.0" + }, + "intel-openmp-2019.0-118.conda": { + "build": "118", + "build_number": 118, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "045cd20811bf49c74e2300fa785eca0b", + "name": "intel-openmp", + "sha256": "f7588e64b5d57832ae9eb68db09856021a1b9883b35019b85863f3dfd18fe3b4", + "size": 632387, + "subdir": "linux-64", + "timestamp": 1537292389205, + "version": "2019.0" + }, + "intel-openmp-2019.1-144.conda": { + "build": "144", + "build_number": 144, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "d4a1b2f40f42f6038b6b1700a4a0eafa", + "name": "intel-openmp", + "sha256": "86c636ba559350eb4e5e983b271c662199f9ebd1485ff7edc899d383dedee16d", + "size": 751605, + "subdir": "linux-64", + "timestamp": 1542661340496, + "version": "2019.1" + }, + "intel-openmp-2019.3-199.conda": { + "build": "199", + "build_number": 199, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "48ca57bbef52ede1e8147908cd7fc7b4", + "name": "intel-openmp", + "sha256": "03bcabbe35235222bdb2663a8fb31ea0461c97d951e5b0d0054c56e39cc03cfe", + "size": 754908, + "subdir": "linux-64", + "timestamp": 1552593606793, + "version": "2019.3" + }, + "intel-openmp-2019.4-243.conda": { + "build": "243", + "build_number": 243, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "264d7675bc416bf7c1428ea2d48fa187", + "name": "intel-openmp", + "sha256": "75d5764bddfbd3c183919911842aa789af810a0b56a7e2cfc5c34faee55462cd", + "size": 746422, + "subdir": "linux-64", + "timestamp": 1559526508129, + "version": "2019.4" + }, + "intel-openmp-2020.0-166.conda": { + "build": "166", + "build_number": 166, + "constrains": [ + "mkl >=2020.0" + ], + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "4b483d8df9ffff30ae1c816a56adfd24", + "name": "intel-openmp", + "sha256": "43a7099262a8fcd872446053fe74e4e246431374311a79600ff966014826feaa", + "size": 774335, + "subdir": "linux-64", + "timestamp": 1580943972633, + "version": "2020.0" + }, + "intel-openmp-2020.1-217.conda": { + "build": "217", + "build_number": 217, + "constrains": [ + "mkl >=2020.1" + ], + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "d0f70b64caec4cccb497dc95be39ea08", + "name": "intel-openmp", + "sha256": "9f40bb3ffb161c3a3caa7a97250cb1a6543ce39c464a9c12ea6453da2cd0f3f1", + "size": 798898, + "subdir": "linux-64", + "timestamp": 1589162242087, + "version": "2020.1" + }, + "intel-openmp-2020.2-254.conda": { + "build": "254", + "build_number": 254, + "constrains": [ + "mkl >=2020.2" + ], + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "e5ebf34035f1012b68e2e1508c9c48a5", + "name": "intel-openmp", + "sha256": "d74e3c8068b6deb57474d863019b65ff1912ed4cf80cf36b1dcb509a9d1fbc60", + "size": 804535, + "subdir": "linux-64", + "timestamp": 1598384192885, + "version": "2020.2" + }, + "intel-openmp-2021.2.0-h06a4308_610.conda": { + "build": "h06a4308_610", + "build_number": 610, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "39673e59a1d6195fa3a7aff31ea0ab52", + "name": "intel-openmp", + "sha256": "a1c78a2d9d80bbd625e8199cd3b8c7ced6542cbe7ddfcf7a834caba69d07ac38", + "size": 1403466, + "subdir": "linux-64", + "timestamp": 1618534005074, + "version": "2021.2.0" + }, + "intel-openmp-2021.3.0-h06a4308_3350.conda": { + "build": "h06a4308_3350", + "build_number": 3350, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "f4abddc8a0203dd80c3a7d27add9a14f", + "name": "intel-openmp", + "sha256": "3db6da799031795ddb1420b64faa154afefc6dca01e4639594edc8ed9cbb95e8", + "size": 1440579, + "subdir": "linux-64", + "timestamp": 1626182296095, + "version": "2021.3.0" + }, + "intel-openmp-2021.4.0-h06a4308_3561.conda": { + "build": "h06a4308_3561", + "build_number": 3561, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "15d9e331499432d8e22935c1d3b5d2a1", + "name": "intel-openmp", + "sha256": "6a2d668a0a33fddbf047f8ef55c29ba5f803ef2c6fed923b7c753a836f4ce002", + "size": 4368467, + "subdir": "linux-64", + "timestamp": 1634546760713, + "version": "2021.4.0" + }, + "intel-openmp-2022.0.1-h06a4308_3633.conda": { + "build": "h06a4308_3633", + "build_number": 3633, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "c9bf9cea63382b0c0cf1cbdfcc64942f", + "name": "intel-openmp", + "sha256": "43cf01ba59e93fe929a9ecdaf376021aa5a497d87cd8dc1ab611641433aa677e", + "size": 4394834, + "subdir": "linux-64", + "timestamp": 1642705440370, + "version": "2022.0.1" + }, + "intel-openmp-2022.1.0-h9e868ea_3769.conda": { + "build": "h9e868ea_3769", + "build_number": 3769, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "ee98f23e5f7ec758c9f1979f7d050a3d", + "name": "intel-openmp", + "sha256": "b660d6a53819cb07f980d06f01d02603447569e07029250ab8e05aacaf148c1b", + "size": 4733351, + "subdir": "linux-64", + "timestamp": 1662497664244, + "version": "2022.1.0" + }, + "intel-openmp-2023.0.0-h9e868ea_25371.conda": { + "build": "h9e868ea_25371", + "build_number": 25371, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [ + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "6a6a971d4334e4b025871d11b0d8ff7b", + "name": "intel-openmp", + "sha256": "abcdcd30bb05cef930154356736d67d2ffbf1b6089a807d2e35fcd4376e9451c", + "size": 15833879, + "subdir": "linux-64", + "timestamp": 1677516507053, + "version": "2023.0.0" + }, + "intervals-0.8.0-py27h5a35102_0.conda": { + "build": "py27h5a35102_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fa77c07d862c2fa4b34d5e2e8f448375", + "name": "intervals", + "sha256": "ee2984ca14740e24587ce388fdcd6a98842eba20777fd014de13156b7e943620", + "size": 17734, + "subdir": "linux-64", + "timestamp": 1507384538825, + "version": "0.8.0" + }, + "intervals-0.8.0-py35h051fd7f_0.conda": { + "build": "py35h051fd7f_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c5f22988274fff9245f5f10b44477191", + "name": "intervals", + "sha256": "828dee8946c0c15e3f0b2a7647bc1ff49f69b9c9a3d97ccb00508aed306c8d4b", + "size": 18196, + "subdir": "linux-64", + "timestamp": 1507384540438, + "version": "0.8.0" + }, + "intervals-0.8.0-py36h1633872_0.conda": { + "build": "py36h1633872_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6103c415755a999c125fb542081e008c", + "name": "intervals", + "sha256": "f69908d7d851312755c43f1550dcf144ea2e6b58ea262c2940bb8209fcc75549", + "size": 17943, + "subdir": "linux-64", + "timestamp": 1507384550902, + "version": "0.8.0" + }, + "intervals-0.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a8c272591d0cbb4c1f3b2df0d75d3e36", + "name": "intervals", + "sha256": "aee2ccd052a7b3ec9594426b06bbf05b6e69e25d6ad76bc2f05bed5dff9588df", + "size": 17656, + "subdir": "linux-64", + "timestamp": 1520909886155, + "version": "0.8.1" + }, + "intervals-0.8.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "39e061d730eb40e87bbd3683ce0a1293", + "name": "intervals", + "sha256": "962f5af4e5813ba18190bb261136b3203c4152da5dfd049d11f0a161a2731462", + "size": 18292, + "subdir": "linux-64", + "timestamp": 1520909920744, + "version": "0.8.1" + }, + "intervals-0.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "90b8164785c53cda7a4675a468576948", + "name": "intervals", + "sha256": "a2d391c992dff3587a852e3d2890f0bec8a9e9e5e6aa6cad37169696f96a9866", + "size": 17963, + "subdir": "linux-64", + "timestamp": 1520909852635, + "version": "0.8.1" + }, + "intervals-0.8.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "643cefc238ed01f7248847588707c06c", + "name": "intervals", + "sha256": "43f45423fe4bd2a68b226ddca819ffeb1b60015e6d32a1f8d36ea9748523120e", + "size": 17868, + "subdir": "linux-64", + "timestamp": 1530897762998, + "version": "0.8.1" + }, + "intervals-0.8.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1464fecfb9ac43c1d4a984ba7ea58957", + "name": "intervals", + "sha256": "009458e5d30b49584f0d931e5920c9140332c5b7f3a3a79f07cce3abc73af8c5", + "size": 18517, + "subdir": "linux-64", + "timestamp": 1573469673080, + "version": "0.8.1" + }, + "intervals-0.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8ca355a7b323ed2ae845e25cdb374d59", + "name": "intervals", + "sha256": "bb405078fc64f7b5477f98b36f66d6177a364a4075a70e6bb65a4b4f3286759d", + "size": 19079, + "subdir": "linux-64", + "timestamp": 1598411867381, + "version": "0.9.0" + }, + "intervals-0.9.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cf3efdf454bb964a9f2f6441e8ed913c", + "name": "intervals", + "sha256": "f89b9fc2abfb93f84740f4f2b29a19ee15c98656660a0ddcec0c349aa3b2427d", + "size": 19113, + "subdir": "linux-64", + "timestamp": 1598411864056, + "version": "0.9.0" + }, + "intervals-0.9.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "28aaf8b1f6aea89cbaaf1ec7cbdf5519", + "name": "intervals", + "sha256": "46543c8c21e10956569f27c2a1c6c521fcfb2c53d5c4ea0e32e1324b6411da3b", + "size": 19396, + "subdir": "linux-64", + "timestamp": 1598411905393, + "version": "0.9.0" + }, + "intervals-0.9.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fe03b736a51cf6bc0f578d749ba7767d", + "name": "intervals", + "sha256": "49e817a15d6686b322cee0fdf6745503454be8c3a72df564afbe552a0fd3f767", + "size": 18384, + "subdir": "linux-64", + "timestamp": 1613237422813, + "version": "0.9.1" + }, + "intervals-0.9.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7212aeacdb61d17730c2e963dccadaae", + "name": "intervals", + "sha256": "215505125f8981e9f95821825125dbeb669f6f1ac85c49055da532c62c991246", + "size": 18229, + "subdir": "linux-64", + "timestamp": 1613237920777, + "version": "0.9.1" + }, + "intervals-0.9.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "37d17e1ce42820b0bccb10770b2688c7", + "name": "intervals", + "sha256": "b8da5fedafd9a4a02f0c624d3770301a389d6bd985c4fabac9224fa3ca134ad2", + "size": 18617, + "subdir": "linux-64", + "timestamp": 1613237931606, + "version": "0.9.1" + }, + "intervals-0.9.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c23f2a9329ea48a1cc581974beea280f", + "name": "intervals", + "sha256": "4e9e47845f4ac316594eb8ebc904536102c0a3d4a34c7d7f1aa557242f8d9219", + "size": 18429, + "subdir": "linux-64", + "timestamp": 1613237928516, + "version": "0.9.1" + }, + "intervals-0.9.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "921712579479d3696b93df62770c3c89", + "name": "intervals", + "sha256": "8f27563819e722f3996b84d53ae98babbb34d0eafed575f5980986c2dcf73e42", + "size": 18932, + "subdir": "linux-64", + "timestamp": 1640809439215, + "version": "0.9.2" + }, + "intervals-0.9.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9f371d15aba0d609f4a420307df65371", + "name": "intervals", + "sha256": "a36c143954ece87c5e43b214d467bacb8ac3623ff8f8dc97d09c82275b370dee", + "size": 23834, + "subdir": "linux-64", + "timestamp": 1676827214107, + "version": "0.9.2" + }, + "intervals-0.9.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f5e214906a41f377f184ef6489c12464", + "name": "intervals", + "sha256": "e8794fd31cd7617cb8e35c48e0a8482f5355dc5a95630e1e929ae45145c7735d", + "size": 18043, + "subdir": "linux-64", + "timestamp": 1625723310469, + "version": "0.9.2" + }, + "intervals-0.9.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fdf654505a45451536d5669bb5efc755", + "name": "intervals", + "sha256": "73dbeb7a9f1926a6f349547908fc2928de83729f691f6b0db170757b8bd0650e", + "size": 18079, + "subdir": "linux-64", + "timestamp": 1625730103837, + "version": "0.9.2" + }, + "intervals-0.9.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "75dc94d07586f5beff26740bdf0945ab", + "name": "intervals", + "sha256": "057755ee740577731eeed0bb7003c3db5af22d6cd625154e61b84ecab401df62", + "size": 18352, + "subdir": "linux-64", + "timestamp": 1625729522371, + "version": "0.9.2" + }, + "intervals-0.9.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "infinity >=0.1.3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "45bb3b9a639048904d976cf3840cd4e3", + "name": "intervals", + "sha256": "62a5f951a1412720a98e4284959d029d7c42a7f568efac4609587f28fbdbaf75", + "size": 18493, + "subdir": "linux-64", + "timestamp": 1625753542839, + "version": "0.9.2" + }, + "invoke-1.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "dc0f68b86735cefa4062be99f167ee0a", + "name": "invoke", + "sha256": "a0d7a0d8e8a6c865da6cf2b076856c12e28c2d989b840fc82fddecc8d3df2d41", + "size": 223795, + "subdir": "linux-64", + "timestamp": 1527696140397, + "version": "1.0.0" + }, + "invoke-1.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "7e7b03e4f4c434499f9313562280cf8e", + "name": "invoke", + "sha256": "49e4836ad6cdc94caa292d1bb682b538b37f383010d42d56db833eb6b6e5eb1f", + "size": 229553, + "subdir": "linux-64", + "timestamp": 1527696176212, + "version": "1.0.0" + }, + "invoke-1.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "771a9168df52fb34347eab5e3d880fd1", + "name": "invoke", + "sha256": "fafe9a346be252ca1bbfe0aeb1fd882da52324fda479233f41cdc851456adb97", + "size": 223635, + "subdir": "linux-64", + "timestamp": 1527696125083, + "version": "1.0.0" + }, + "invoke-1.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "fca2f36b6d8bf0ef13a82e4ead37aff1", + "name": "invoke", + "sha256": "c72014c5726a2c1599705553f86621c491c318e3d9e06a40bdd1e8cb1edb95de", + "size": 223959, + "subdir": "linux-64", + "timestamp": 1530876201469, + "version": "1.0.0" + }, + "invoke-1.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "830822d5b37fc4b37b08c2dd2e2dd0e3", + "name": "invoke", + "sha256": "f0b480e7459d28b05e2983e1489ded0a566a974bb9a616428cddfc4e288f095f", + "size": 223210, + "subdir": "linux-64", + "timestamp": 1535427184141, + "version": "1.1.1" + }, + "invoke-1.1.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "04c02de42896972014e671f1adc5aab9", + "name": "invoke", + "sha256": "7f1602ad931035b31716040aa29a507f60331af41e131c90749144e3ad32cbce", + "size": 228856, + "subdir": "linux-64", + "timestamp": 1535427406502, + "version": "1.1.1" + }, + "invoke-1.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "2a131524277ac19fcf98e5474bc1caca", + "name": "invoke", + "sha256": "4dd86f3fd282438dfec3f70c9c50159560bbe5d8df7f04accfd067973ee1977e", + "size": 226440, + "subdir": "linux-64", + "timestamp": 1535427335493, + "version": "1.1.1" + }, + "invoke-1.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f8d424d8d2297298e7f8662b38157b94", + "name": "invoke", + "sha256": "ada334a1e8283c52c3b6aac856f826180b8f9cf00c193e52c7da6ee4cdc854dd", + "size": 223349, + "subdir": "linux-64", + "timestamp": 1535427406767, + "version": "1.1.1" + }, + "invoke-1.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "7413012fe0a4e3a5e9a41b9582a362ae", + "name": "invoke", + "sha256": "b31d1a819201a4e05cdf18179398e967bf1cda07b0c79ba2b77d26361f2969c3", + "size": 249226, + "subdir": "linux-64", + "timestamp": 1538175566060, + "version": "1.2.0" + }, + "invoke-1.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "3636756ccee0f4ce44e88f08613aa4f1", + "name": "invoke", + "sha256": "8e4db914e9ae9ba8bccb167d087d2cb90c134c780474a017dfe93a4bcd1ea695", + "size": 238825, + "subdir": "linux-64", + "timestamp": 1538175575204, + "version": "1.2.0" + }, + "invoke-1.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "dddd1174558c183927530db034315b5e", + "name": "invoke", + "sha256": "4ab0e960eef2008a16044126ff1fd9706f8d44bce01def263c60db9d6a1e4291", + "size": 243603, + "subdir": "linux-64", + "timestamp": 1538175516365, + "version": "1.2.0" + }, + "invoke-1.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "3d75ac3adf89c246daba7a14575ef924", + "name": "invoke", + "sha256": "f6917c55aafb759be71f69c1e37359b12f7ca4ce8f6efdff0010335c1cdee613", + "size": 254729, + "subdir": "linux-64", + "timestamp": 1569360906640, + "version": "1.3.0" + }, + "invoke-1.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ab4124c0a378f5b0bf12464d4adb5354", + "name": "invoke", + "sha256": "7cd95f8f95f22b82e6c81fcc5655ce05934b36898529f66a689e7e750a5f5ceb", + "size": 250325, + "subdir": "linux-64", + "timestamp": 1569360951866, + "version": "1.3.0" + }, + "invoke-1.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "929fb5f426d905f0baeabe175a61e237", + "name": "invoke", + "sha256": "636b6234ce8dbbdb74308fa0423c6759ccb9615dd9f3e6ca51f29363783a5b65", + "size": 250634, + "subdir": "linux-64", + "timestamp": 1569360942018, + "version": "1.3.0" + }, + "invoke-1.3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "26e5d4dbdc84c9cf9725c56c88884014", + "name": "invoke", + "sha256": "a48fc671259b301a2e916a938931d97a9ccb44b36953626c08145665b1c45f5a", + "size": 248580, + "subdir": "linux-64", + "timestamp": 1572437524313, + "version": "1.3.0" + }, + "invoke-1.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e19fc778fe887d10a059a440537bacad", + "name": "invoke", + "sha256": "6b3b487e24311839f944ad1827c9e15f538764cf17c4384f58a274af36c61965", + "size": 247058, + "subdir": "linux-64", + "timestamp": 1600361249611, + "version": "1.4.1" + }, + "invoke-1.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "2184df214fdc02f968dcdb00b0194b0e", + "name": "invoke", + "sha256": "b059bb76a78841eb561cb1cd2b7925a20ee06ddb063a35f922a9333269c3db5c", + "size": 247429, + "subdir": "linux-64", + "timestamp": 1600361232070, + "version": "1.4.1" + }, + "invoke-1.4.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c9b3559ab3ecd4dc44b7c102d047828e", + "name": "invoke", + "sha256": "a6967f86672b29d62235db1d20963e1a1e4c974b1564a2b971862a0069690275", + "size": 251795, + "subdir": "linux-64", + "timestamp": 1600361228337, + "version": "1.4.1" + }, + "invoke-1.5.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "201dee2b33dbc7912d76bc42039bae03", + "name": "invoke", + "sha256": "461a3ee3612c7bd2c1bdc90aedb12d9f050dd77c3515f6de65fd1b123a9b1566", + "size": 252394, + "subdir": "linux-64", + "timestamp": 1612279037237, + "version": "1.5.0" + }, + "invoke-1.5.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "7200dccea2a17d5a7030d21cc8922f7c", + "name": "invoke", + "sha256": "5433a36f127fab87358b795e433d3de9c750fb1a8942cbcd1c856f511af4fe0e", + "size": 249060, + "subdir": "linux-64", + "timestamp": 1612278983156, + "version": "1.5.0" + }, + "invoke-1.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "2729c1a70909bbc08c0d4df17fd71d23", + "name": "invoke", + "sha256": "801f7c5a07b72b5bf4f2d151da49de3c5cc84aa012c69eb70d5f44003d0c58d1", + "size": 250207, + "subdir": "linux-64", + "timestamp": 1612278737805, + "version": "1.5.0" + }, + "invoke-1.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "931f27ac7de30bf493f33cee77be60f7", + "name": "invoke", + "sha256": "c3ca664cf8d8d5e07c792cccf57157eeac2d794b780810b90c1143b0fcdf2bf5", + "size": 253825, + "subdir": "linux-64", + "timestamp": 1612278986029, + "version": "1.5.0" + }, + "invoke-1.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "545b9631cdef0ec23c8b14d67064c5e7", + "name": "invoke", + "sha256": "abced0756ee8421adc7589f70de39ca3216e206bec4992f21f2b4caffd390024", + "size": 256626, + "subdir": "linux-64", + "timestamp": 1640791101835, + "version": "1.6.0" + }, + "invoke-1.6.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "4b107575b122f3e2ad9b76e238a63767", + "name": "invoke", + "sha256": "1224d457276ea8e7c2a4a5d4bc8a86446d9cf1218a0032238f7184d93e5b4ce9", + "size": 327381, + "subdir": "linux-64", + "timestamp": 1676844344407, + "version": "1.6.0" + }, + "invoke-1.6.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "95091ff550e295613c44b568c5c9259d", + "name": "invoke", + "sha256": "5acaecf9123ed03304a41ccbf9131d4bfe20dddd0e6e55ad7c9826ec3d75146e", + "size": 252097, + "subdir": "linux-64", + "timestamp": 1626067442194, + "version": "1.6.0" + }, + "invoke-1.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "172e1748e0c67da89eab9f5323662d8d", + "name": "invoke", + "sha256": "aa4b432ad0d4780b7492a76ddacb2a042187f1753314f8dba0636bfc2ce99e74", + "size": 252760, + "subdir": "linux-64", + "timestamp": 1626060455377, + "version": "1.6.0" + }, + "invoke-1.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a141d2b1c5ffaf93ed1b23b61924d378", + "name": "invoke", + "sha256": "7f48821e40aaa8da3664307fecc1e605361d8ae3912e3d8ce169fd92a4596bf5", + "size": 253526, + "subdir": "linux-64", + "timestamp": 1626067428560, + "version": "1.6.0" + }, + "invoke-1.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "bf59c95a44d510b8ccddff36a795c559", + "name": "invoke", + "sha256": "965d9b97ed2dfb5b880c3ad0ae7d68a944f2d2f4d040e47cd91a14e567654cb2", + "size": 253703, + "subdir": "linux-64", + "timestamp": 1626089899372, + "version": "1.6.0" + }, + "ipaddr-2.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "29109579a1fbd6a937dc24c58112d0a8", + "name": "ipaddr", + "sha256": "207d5e7eafd1db249f4dd3e3d1999428a6126ff1500758df7419a02ee2349f45", + "size": 29894, + "subdir": "linux-64", + "timestamp": 1530897789745, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py27h59904b5_0.conda": { + "build": "py27h59904b5_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d84957cc298d2160bd910099a304533f", + "name": "ipaddr", + "sha256": "d41736d5b2480172195c2bbd2f51b7ff07c5a47d4be493cb3a52f0565c258a78", + "size": 30095, + "subdir": "linux-64", + "timestamp": 1507401429255, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8f695916a364a090191f86bebd371c59", + "name": "ipaddr", + "sha256": "3fab3c1f989b5e20292c060578f89aa7f60c8279ed98288c7fff650f58d6345d", + "size": 30726, + "subdir": "linux-64", + "timestamp": 1640791119558, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7d739a86fe6edfe4f82f26318958dc49", + "name": "ipaddr", + "sha256": "b7928acde9874ddb10ceefc7b857b5f3093de1e0ec9fcd044e3a04dfa3f3f8ec", + "size": 38129, + "subdir": "linux-64", + "timestamp": 1676852888924, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py35h205650a_0.conda": { + "build": "py35h205650a_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a28294087a4f1ee145367b3244a01218", + "name": "ipaddr", + "sha256": "5e25b64bc2a29a261d3d139c633b831e3628c6d3583ab06b11a3ae62a967782d", + "size": 30692, + "subdir": "linux-64", + "timestamp": 1507401431662, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b96a25d9919cccd87820b4bb87a535d9", + "name": "ipaddr", + "sha256": "be112e0f275d67bd9505b3c51ce9c36ee22ec983b24c8a1aeee1ff87b98c56bf", + "size": 30460, + "subdir": "linux-64", + "timestamp": 1530897842059, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b930e1b02c1fad8cd153d41b127ebe61", + "name": "ipaddr", + "sha256": "8e04401687adb7a4066d2ffbb111614108e85bee68629f4afb7dda4d8ac65299", + "size": 30887, + "subdir": "linux-64", + "timestamp": 1632748096907, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py36h982ec33_0.conda": { + "build": "py36h982ec33_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5c99158b6b8c1af48c108d26309ffb2c", + "name": "ipaddr", + "sha256": "8b062b66c8a3ebcb86b3ecc61b9ca4f8c3219ac556211a4ae6d18f6366ec2add", + "size": 30405, + "subdir": "linux-64", + "timestamp": 1507401429067, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c4a00b3ea57d56e51978a46e78bbc819", + "name": "ipaddr", + "sha256": "cc444f0bc4010787bde54d01cf0d0079c564e6e37d4fe8be4648fac998d98e08", + "size": 30187, + "subdir": "linux-64", + "timestamp": 1530897815335, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "47ae06cf69306a8995b669aec52ce1d8", + "name": "ipaddr", + "sha256": "c7d9e59ed2da2db122c13d1ec440b68be3d6c6b9d2bc55b542d6948fa1d4e980", + "size": 31016, + "subdir": "linux-64", + "timestamp": 1632748437870, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "30f3f0822ddc491e4a23d8fd2028acaa", + "name": "ipaddr", + "sha256": "0170cc8dfbbf7ad7ef1666cacafc2ab9f774b29d68fe8dd147c341866d13995a", + "size": 30848, + "subdir": "linux-64", + "timestamp": 1572437552878, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3c3384c8599268838388eec7091a68f7", + "name": "ipaddr", + "sha256": "b80a414cddc988777dddc3c00a829fd725876f4a083eb57f29bf8c698e1c52b2", + "size": 30974, + "subdir": "linux-64", + "timestamp": 1632748441464, + "version": "2.2.0" + }, + "ipaddr-2.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b06b017d2aed2605afd8018e3306f89c", + "name": "ipaddr", + "sha256": "7ee54dcdff66473078582f2b2f0986f99c08fb28632c32a658efd9a8463747ca", + "size": 31204, + "subdir": "linux-64", + "timestamp": 1632748442398, + "version": "2.2.0" + }, + "ipaddress-1.0.18-py27h337fd85_0.conda": { + "build": "py27h337fd85_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "license_family": "PSF", + "md5": "355027d6e2ae57cb3384e137be24d375", + "name": "ipaddress", + "sha256": "6dfc0628994a76e3fde9b65d3308c38c6be9342674876dc67e3707b0678d4751", + "size": 32828, + "subdir": "linux-64", + "timestamp": 1505691786314, + "version": "1.0.18" + }, + "ipaddress-1.0.19-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "license_family": "PSF", + "md5": "cf5720df5c1fa879d042392c345af943", + "name": "ipaddress", + "sha256": "08a81288f7eb301bc54f02805bac4d5565650436fbd2a8b9f3dfe4e1f4692e8d", + "size": 32980, + "subdir": "linux-64", + "timestamp": 1515704334664, + "version": "1.0.19" + }, + "ipaddress-1.0.22-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "license_family": "PSF", + "md5": "6baa8701690278c67deee9e720fac44f", + "name": "ipaddress", + "sha256": "7679abed1b173943e524ccb40e2dd2e99d01eeee3000bb8d0a7822ad3e130346", + "size": 33042, + "subdir": "linux-64", + "timestamp": 1523974561353, + "version": "1.0.22" + }, + "ipykernel-4.10.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6f09b3b269ffffac072f223e3db7aab2", + "name": "ipykernel", + "sha256": "fc2939a751730f0e7316d4c55a60157fa11dfe0400a97e074c77f743a46319d8", + "size": 156170, + "subdir": "linux-64", + "timestamp": 1538040731267, + "version": "4.10.0" + }, + "ipykernel-4.10.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "85dac0d0bb6ec105c0f449cf2d23a3de", + "name": "ipykernel", + "sha256": "b87db0abc3e70ac032415ef4cfb929fb0fe1985885cd4bf4b733f3d03d2ddfa1", + "size": 157072, + "subdir": "linux-64", + "timestamp": 1538040792655, + "version": "4.10.0" + }, + "ipykernel-4.10.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b4405a982035f1960c07e64a0f0a61a3", + "name": "ipykernel", + "sha256": "837c358ac04567b72d3b4eb5125cc4dc42f597be2a5088c6416f51de6e3a7864", + "size": 155622, + "subdir": "linux-64", + "timestamp": 1538040761425, + "version": "4.10.0" + }, + "ipykernel-4.10.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "39d7e009cb5c704780cd7705f2f70ead", + "name": "ipykernel", + "sha256": "1c7fae8fe75ebf119d3f028eb721535d5d99b38ddc90878308cb9888c6bdf070", + "size": 157561, + "subdir": "linux-64", + "timestamp": 1538040700771, + "version": "4.10.0" + }, + "ipykernel-4.6.1-py27hc93e584_0.conda": { + "build": "py27hc93e584_0", + "build_number": 0, + "depends": [ + "ipython", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "6cc993fc027294d269dc65add1fc9aff", + "name": "ipykernel", + "sha256": "67d45889242e413f88749c675a47aba64d5c4b72e3a54cc1827a8cfb864cc11e", + "size": 148597, + "subdir": "linux-64", + "timestamp": 1505690571612, + "version": "4.6.1" + }, + "ipykernel-4.6.1-py35h29d130c_0.conda": { + "build": "py35h29d130c_0", + "build_number": 0, + "depends": [ + "ipython", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "993392e8f20efabcc16f2c6a3accfe4f", + "name": "ipykernel", + "sha256": "8f2df42d0836f8dcc7fe73c52aa3909deb0e1595c85ccb69093962138fc89cc1", + "size": 151089, + "subdir": "linux-64", + "timestamp": 1505690708184, + "version": "4.6.1" + }, + "ipykernel-4.6.1-py36hbf841aa_0.conda": { + "build": "py36hbf841aa_0", + "build_number": 0, + "depends": [ + "ipython", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "772c9374664dfa4a65acb68076903b8e", + "name": "ipykernel", + "sha256": "7426478866683dc55b92a8e401607afd5358b4669d726658b9f3a3f17d99a94a", + "size": 149508, + "subdir": "linux-64", + "timestamp": 1505690727501, + "version": "4.6.1" + }, + "ipykernel-4.7.0-py27h5233db4_0.conda": { + "build": "py27h5233db4_0", + "build_number": 0, + "depends": [ + "ipython", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b108c0e84f66ceb64a15d0e8a1fbf99c", + "name": "ipykernel", + "sha256": "e58ce86852ac8d0fc665c7273670d26a1348ba437464ef89cb31a1909366f9d7", + "size": 150626, + "subdir": "linux-64", + "timestamp": 1512586018518, + "version": "4.7.0" + }, + "ipykernel-4.7.0-py35h2f9c1c0_0.conda": { + "build": "py35h2f9c1c0_0", + "build_number": 0, + "depends": [ + "ipython", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c9a47c4271f6deb72a53afb4afa855a2", + "name": "ipykernel", + "sha256": "c00670360667798b066b662657b56b737a1bf3f8e555ba4d4b7f606528a8c0ac", + "size": 154498, + "subdir": "linux-64", + "timestamp": 1512586049343, + "version": "4.7.0" + }, + "ipykernel-4.7.0-py36h2f9c1c0_0.conda": { + "build": "py36h2f9c1c0_0", + "build_number": 0, + "depends": [ + "ipython", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f2885539f0cc6cdfa8feed8d4b171d93", + "name": "ipykernel", + "sha256": "3f3dba18fc79ae120f10c7a747cd5d8eaa6ea749e02d2714229b7d4a2bb83b44", + "size": 152804, + "subdir": "linux-64", + "timestamp": 1512586060687, + "version": "4.7.0" + }, + "ipykernel-4.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipython >=4.0.0", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "02a6fb2bc2203f3ab075d4e485a2f193", + "name": "ipykernel", + "sha256": "5b2cf8fb8e032eec27e2a8c46546a779a80a00cf3fa7b49ae4a954911a260219", + "size": 154355, + "subdir": "linux-64", + "timestamp": 1516652174979, + "version": "4.8.0" + }, + "ipykernel-4.8.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipython >=4.0.0", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "20dbcba316da7fae8178b6ab7d3acfad", + "name": "ipykernel", + "sha256": "6ee289912ee08b2720425dcc23d1816a871a6a7024ea92910b955f70e0bbcb30", + "size": 155202, + "subdir": "linux-64", + "timestamp": 1516652159456, + "version": "4.8.0" + }, + "ipykernel-4.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4.0.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dbe0ad7dfddd16744659ff9a2154a2db", + "name": "ipykernel", + "sha256": "9b7c9e7d0f3c4e127f6a0417143850681e36fccb4017f51c6d20f225fcb49e5a", + "size": 155381, + "subdir": "linux-64", + "timestamp": 1516652159262, + "version": "4.8.0" + }, + "ipykernel-4.8.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipython >=4.0.0", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "53bc5e55281cd0548d3de9e03749b297", + "name": "ipykernel", + "sha256": "e39cfee99ef05c9d953ca5f7fe9dea777cdc678a7a201b2021a1e607d1e57588", + "size": 153538, + "subdir": "linux-64", + "timestamp": 1519152937479, + "version": "4.8.2" + }, + "ipykernel-4.8.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipython >=4.0.0", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d868eab23c04b1faef17744fec880fb8", + "name": "ipykernel", + "sha256": "82643f28421b14705cd31d22b19539e21b7219dc416b12e3c466c1bff55aaf0e", + "size": 155642, + "subdir": "linux-64", + "timestamp": 1519152976611, + "version": "4.8.2" + }, + "ipykernel-4.8.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4.0.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2c168e83c14bccf8a998f31929911257", + "name": "ipykernel", + "sha256": "5fa88e99425baee5a31877fb8f2dc53fc8b4ed431633832adf32357f05995bdb", + "size": 154113, + "subdir": "linux-64", + "timestamp": 1519152923770, + "version": "4.8.2" + }, + "ipykernel-4.8.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4.0.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "455b0a7411af708d82ae94194bdb20bc", + "name": "ipykernel", + "sha256": "225246a52e98707788523acc7b33b3ceb08efe738a21907b133d82276f71162a", + "size": 158257, + "subdir": "linux-64", + "timestamp": 1530734063073, + "version": "4.8.2" + }, + "ipykernel-4.9.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7e56afd2f5bbb78f0742128b6810c658", + "name": "ipykernel", + "sha256": "678599f33358f831b8287744443b97a2725c58065947b708c2092b5e0654b66f", + "size": 154509, + "subdir": "linux-64", + "timestamp": 1536073577085, + "version": "4.9.0" + }, + "ipykernel-4.9.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cfc61e66e1fccb4f9b6fe44406b7605b", + "name": "ipykernel", + "sha256": "0547030ac6c337b16a06af6aa901ff17c3e68de9221183c0a5239d82e2b53ab7", + "size": 154632, + "subdir": "linux-64", + "timestamp": 1537386314387, + "version": "4.9.0" + }, + "ipykernel-4.9.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c88e057e9ae18e67fc485e2f96c6965c", + "name": "ipykernel", + "sha256": "f15cf1faa6f4078165d24a822a8cb0dc87bb549f112b00cd00b0063241f113a1", + "size": 156747, + "subdir": "linux-64", + "timestamp": 1536073616730, + "version": "4.9.0" + }, + "ipykernel-4.9.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "483c86ef13839d64e90e21166f663379", + "name": "ipykernel", + "sha256": "23ed34d5d783a3be56762911c5882bfb31eadd1de7107561c55df0c0fa917167", + "size": 158817, + "subdir": "linux-64", + "timestamp": 1537386369650, + "version": "4.9.0" + }, + "ipykernel-4.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cdb4d5e2c09d7769a11157ce414f1bbb", + "name": "ipykernel", + "sha256": "0b27dafb9ec8c11d3c7caeaf75f96d8719bed2f29ff9184f6dd66ec9355e9331", + "size": 157020, + "subdir": "linux-64", + "timestamp": 1536073582294, + "version": "4.9.0" + }, + "ipykernel-4.9.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "befd7774d607026cd9b1fc15b9ff373d", + "name": "ipykernel", + "sha256": "d16f250a9eed0df2f83cf97deb19a131e35fa2ddfbeb6741ffcc47f692439c76", + "size": 155362, + "subdir": "linux-64", + "timestamp": 1537386383438, + "version": "4.9.0" + }, + "ipykernel-4.9.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "fa35ff6b84c08c24ebfd299d503d9391", + "name": "ipykernel", + "sha256": "1789f7f15ebcc2b17c62f4d4b23021c9ad825fc5a4e21fa73f6b7dfd6e3c7c96", + "size": 155368, + "subdir": "linux-64", + "timestamp": 1536073622581, + "version": "4.9.0" + }, + "ipykernel-4.9.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "ipython >=4.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e48b609ad987d687a5e248ed41c88761", + "name": "ipykernel", + "sha256": "b18632f49cf89dfb175c86219786d347c8bccc2d07857a0c9a26d81d9f821678", + "size": 157416, + "subdir": "linux-64", + "timestamp": 1537386308958, + "version": "4.9.0" + }, + "ipykernel-5.0.0-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "31350723eced3b10a576984f05503813", + "name": "ipykernel", + "sha256": "985126ccd17326ac4226bd7bfb0e65b3470b2f632c08cf5bda1060f6264a4c73", + "size": 164390, + "subdir": "linux-64", + "timestamp": 1538603381927, + "version": "5.0.0" + }, + "ipykernel-5.0.0-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7556048d1338299aae43e2267f55c06c", + "name": "ipykernel", + "sha256": "8c3613adfbdf8df783ad1d507a824a5e1b08f1100d1a1dd7ae45f51d8d790231", + "size": 164757, + "subdir": "linux-64", + "timestamp": 1538606276960, + "version": "5.0.0" + }, + "ipykernel-5.1.0-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c0fbf50a6b083860547fd5e0417d1c22", + "name": "ipykernel", + "sha256": "99ce6d508a624773d8f91b03a4586c06ffc2cb04f407b6343cd198ba4e5ea626", + "size": 167238, + "subdir": "linux-64", + "timestamp": 1539879520077, + "version": "5.1.0" + }, + "ipykernel-5.1.0-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5de13e76ec587e01fcedd84d50123271", + "name": "ipykernel", + "sha256": "297ffcb8fd00c316aeadfbc8c3ea1465c670de836597c07ec5bdb71cbd87a57b", + "size": 165397, + "subdir": "linux-64", + "timestamp": 1539879520664, + "version": "5.1.0" + }, + "ipykernel-5.1.1-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0329e96d5067eeafa9b1aab75c922768", + "name": "ipykernel", + "sha256": "cda68cc8dddc841452d1d002317e344c28ab78e88226db287bd78229c60905c1", + "size": 172475, + "subdir": "linux-64", + "timestamp": 1559658946956, + "version": "5.1.1" + }, + "ipykernel-5.1.1-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6d59e91b4f61ac7a9ea0dcac059cf356", + "name": "ipykernel", + "sha256": "f0d45282c93ec91f9a942f039287aef12b16907cfc13f9d0a9540f8512afeb83", + "size": 170567, + "subdir": "linux-64", + "timestamp": 1559658916651, + "version": "5.1.1" + }, + "ipykernel-5.1.2-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2fc91580473ea8501975afe69bd00677", + "name": "ipykernel", + "sha256": "fc4ba9dc6085911661e79f60be00d5321af57da731b05e196010f854da03f022", + "size": 171534, + "subdir": "linux-64", + "timestamp": 1565955912025, + "version": "5.1.2" + }, + "ipykernel-5.1.2-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.0", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f7755b77e2712042b6f2d34f9c68ed5e", + "name": "ipykernel", + "sha256": "f99599fec71d745479ec94141911beb9fc18e0a2fa746afefa6f7948e1ed8e31", + "size": 174466, + "subdir": "linux-64", + "timestamp": 1565899836330, + "version": "5.1.2" + }, + "ipykernel-5.1.3-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "77d4b661ba2833c273b8111d96e89d08", + "name": "ipykernel", + "sha256": "1604a11add13897a2c9947efc887fd7590b09a3ff35945c926fd6e1fecc8c83c", + "size": 176535, + "subdir": "linux-64", + "timestamp": 1572456863865, + "version": "5.1.3" + }, + "ipykernel-5.1.3-py36h39e3cac_1.conda": { + "build": "py36h39e3cac_1", + "build_number": 1, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b1e9c69b5e2afda4c3826ae781a817ae", + "name": "ipykernel", + "sha256": "79bcedeb0906c1f02e61a3a9c760c1a3654499b39969636a4212e11c172e6bcf", + "size": 176669, + "subdir": "linux-64", + "timestamp": 1579118681344, + "version": "5.1.3" + }, + "ipykernel-5.1.3-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dcfb5bc660384584f4c82f93aebac6ec", + "name": "ipykernel", + "sha256": "dbd954ce0105ff0631046f0e1de625d5c994a661560206bf71331c1777b97d6e", + "size": 176813, + "subdir": "linux-64", + "timestamp": 1572456830675, + "version": "5.1.3" + }, + "ipykernel-5.1.3-py37h39e3cac_1.conda": { + "build": "py37h39e3cac_1", + "build_number": 1, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bd9079adb238076ad9113aed7fbdafee", + "name": "ipykernel", + "sha256": "1a45b8ba63155b465d5ce5404c73ab56eb768521d38dd5be28ec1cca0520e4ab", + "size": 177123, + "subdir": "linux-64", + "timestamp": 1579118684637, + "version": "5.1.3" + }, + "ipykernel-5.1.3-py38h39e3cac_0.conda": { + "build": "py38h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5d7d57fb6868a8000d692a5736377bbf", + "name": "ipykernel", + "sha256": "ea45a2fc16ac97a3cff2de9a18e2024cc17be382cbcbcb1ab3e5dae26cbe32d7", + "size": 170839, + "subdir": "linux-64", + "timestamp": 1574235734148, + "version": "5.1.3" + }, + "ipykernel-5.1.3-py38h39e3cac_1.conda": { + "build": "py38h39e3cac_1", + "build_number": 1, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "930da63f756e61f9294368a4159827c4", + "name": "ipykernel", + "sha256": "e29be3c02464a18eacd3978265d81e5ae47641b0857c3a86dcd3c14585e821b3", + "size": 175185, + "subdir": "linux-64", + "timestamp": 1579118667631, + "version": "5.1.3" + }, + "ipykernel-5.1.4-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2fafe932991eca0dd27dd316003dec57", + "name": "ipykernel", + "sha256": "3ab0c6d7e85ea50ba22aa37fba8321337d33224b6188c5e1c45341c5037f4b31", + "size": 174850, + "subdir": "linux-64", + "timestamp": 1580149653429, + "version": "5.1.4" + }, + "ipykernel-5.1.4-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff792f0216a7c71034158685004d4e9f", + "name": "ipykernel", + "sha256": "014d3f7589b2da11967b46df78db3410f392c8f3d123bc30ba055f10bea4f96e", + "size": 174606, + "subdir": "linux-64", + "timestamp": 1580149676813, + "version": "5.1.4" + }, + "ipykernel-5.1.4-py38h39e3cac_0.conda": { + "build": "py38h39e3cac_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "778ae57743d6af8a62931e2349d44a0e", + "name": "ipykernel", + "sha256": "eb13478ea0b29602435f68cf0a6121d1656fbd5d399873d1d4ff9c78228c23db", + "size": 176030, + "subdir": "linux-64", + "timestamp": 1580149667914, + "version": "5.1.4" + }, + "ipykernel-5.3.0-py36h5ca1d4c_0.conda": { + "build": "py36h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "be9c0da0f3926e34b8655be613845136", + "name": "ipykernel", + "sha256": "b674f8e0ed47a5b71172acce6cf4e72e60254a9dc0e84490d598706457efefce", + "size": 181320, + "subdir": "linux-64", + "timestamp": 1592339939667, + "version": "5.3.0" + }, + "ipykernel-5.3.0-py37h5ca1d4c_0.conda": { + "build": "py37h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c8301d24294c9dfa2452adc9fa106eb9", + "name": "ipykernel", + "sha256": "98e986df8b18a6c1405694a772db2b31781a783b09d924a747c1e93370b380c0", + "size": 180912, + "subdir": "linux-64", + "timestamp": 1592339944504, + "version": "5.3.0" + }, + "ipykernel-5.3.0-py38h5ca1d4c_0.conda": { + "build": "py38h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3ea50de58389f997d31da2ef9c18ec37", + "name": "ipykernel", + "sha256": "c32226a787099251fbac046098c215781d2f068a628374aa4cc950a76cb037bc", + "size": 182258, + "subdir": "linux-64", + "timestamp": 1592339891383, + "version": "5.3.0" + }, + "ipykernel-5.3.2-py36h5ca1d4c_0.conda": { + "build": "py36h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bab3bc3ea8cb604cf869924a5dc12c77", + "name": "ipykernel", + "sha256": "a5f82876e372243ec2993237765ff83fcc680505e91f00948384229add33f70b", + "size": 183327, + "subdir": "linux-64", + "timestamp": 1594755362658, + "version": "5.3.2" + }, + "ipykernel-5.3.2-py37h5ca1d4c_0.conda": { + "build": "py37h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8d348f3a8897b7435c69095e340dce1b", + "name": "ipykernel", + "sha256": "469741f61798c1b95024a718755146c4465721b9d8700a611245b201cbdb8ad4", + "size": 182841, + "subdir": "linux-64", + "timestamp": 1594753413943, + "version": "5.3.2" + }, + "ipykernel-5.3.2-py38h5ca1d4c_0.conda": { + "build": "py38h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6020cf6885f03c92b42415141958a695", + "name": "ipykernel", + "sha256": "f5bcd5e0119e0236f4d4c273f98d03f0be056ddc8588f7864241485e0fe5d84a", + "size": 186376, + "subdir": "linux-64", + "timestamp": 1594753414032, + "version": "5.3.2" + }, + "ipykernel-5.3.3-py36h5ca1d4c_0.conda": { + "build": "py36h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0bdd8834caa1600852f2868ec168f733", + "name": "ipykernel", + "sha256": "e9999a250193673a7c489ba3b828c17a922715d868ab092be55997ce4942bfd2", + "size": 183140, + "subdir": "linux-64", + "timestamp": 1595346605681, + "version": "5.3.3" + }, + "ipykernel-5.3.3-py37h5ca1d4c_0.conda": { + "build": "py37h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "33286dd86c6ed675f90e34a3c00b4ba4", + "name": "ipykernel", + "sha256": "4da98a95ffe5c31e25cc525dff2c4985aba1859fb27ea05466feb3acffdea4da", + "size": 183427, + "subdir": "linux-64", + "timestamp": 1595347189618, + "version": "5.3.3" + }, + "ipykernel-5.3.3-py38h5ca1d4c_0.conda": { + "build": "py38h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c1345d4583afaac8b3b1baad30dfa009", + "name": "ipykernel", + "sha256": "4d383827827708d64bc94c3c6dfba109d377abf0de2257800ed87ac1a7e91038", + "size": 184612, + "subdir": "linux-64", + "timestamp": 1595347191937, + "version": "5.3.3" + }, + "ipykernel-5.3.4-py36h5ca1d4c_0.conda": { + "build": "py36h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "853c1364be857de8acb0ae6a6e84a16c", + "name": "ipykernel", + "sha256": "b64f43796599c4255229ac980af69395c179f6f8605b1c78534973caee42f0c0", + "size": 185718, + "subdir": "linux-64", + "timestamp": 1596206647122, + "version": "5.3.4" + }, + "ipykernel-5.3.4-py37h5ca1d4c_0.conda": { + "build": "py37h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e8a12edd10c0ec82deecb6a2c29e39de", + "name": "ipykernel", + "sha256": "ad98fae168b9ac4f4c0cada25be882582d6ebe0473c7678a8afeef9c464de364", + "size": 183753, + "subdir": "linux-64", + "timestamp": 1596206637562, + "version": "5.3.4" + }, + "ipykernel-5.3.4-py38h5ca1d4c_0.conda": { + "build": "py38h5ca1d4c_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "75e7a6a523bff56edb6b719697e9660b", + "name": "ipykernel", + "sha256": "b4c017bc95df691187747db5166484cdc270a1883bc43223cd46a3e90ff88d94", + "size": 186946, + "subdir": "linux-64", + "timestamp": 1596207682698, + "version": "5.3.4" + }, + "ipykernel-5.3.4-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "ipython >=5.0", + "jupyter_client", + "python >=3.9,<3.10.0a0", + "tornado >=4.2", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "44d0c9c1aa5e9abb79f6cd90d15fc003", + "name": "ipykernel", + "sha256": "7d14c20400b7cd7d792b56f1acdf2a773657b0ce1083fdaa383d7707258f8318", + "size": 184445, + "subdir": "linux-64", + "timestamp": 1607452836012, + "version": "5.3.4" + }, + "ipykernel-6.15.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "debugpy >=1.0.0", + "ipython >=7.23.1", + "jupyter_client >=6.1.12", + "matplotlib-inline >=0.1.0", + "nest-asyncio", + "packaging", + "psutil", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "tornado >=6.1,<7.0", + "traitlets >=5.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "33fcd636594055839cfcf3a82aa68454", + "name": "ipykernel", + "sha256": "1d4501e40fe2d80ba807e602ef0479cab003e2597dc16db9688d744238aaf89b", + "size": 196096, + "subdir": "linux-64", + "timestamp": 1662362226787, + "version": "6.15.2" + }, + "ipykernel-6.15.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "debugpy >=1.0.0", + "ipython >=7.23.1", + "jupyter_client >=6.1.12", + "matplotlib-inline >=0.1.0", + "nest-asyncio", + "packaging", + "psutil", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "tornado >=6.1,<7.0", + "traitlets >=5.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "82c3c51c5273f7c209d61e1675dd5693", + "name": "ipykernel", + "sha256": "8cdd3aad390635b09e40017217d016d5af61c002d7c9fd90e63ad7fd0b5a5c5e", + "size": 193740, + "subdir": "linux-64", + "timestamp": 1662362093833, + "version": "6.15.2" + }, + "ipykernel-6.15.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "debugpy >=1.0.0", + "ipython >=7.23.1", + "jupyter_client >=6.1.12", + "matplotlib-inline >=0.1.0", + "nest-asyncio", + "packaging", + "psutil", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "tornado >=6.1,<7.0", + "traitlets >=5.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e817067e3c01f9b7ce5bf31bc20c387", + "name": "ipykernel", + "sha256": "062afb8df3477d43d7ef51dc5d8b84a65a25de099ec308ff6faf94f9045d58f7", + "size": 194648, + "subdir": "linux-64", + "timestamp": 1662361974763, + "version": "6.15.2" + }, + "ipykernel-6.15.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "debugpy >=1.0.0", + "ipython >=7.23.1", + "jupyter_client >=6.1.12", + "matplotlib-inline >=0.1.0", + "nest-asyncio", + "packaging", + "psutil", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "tornado >=6.1,<7.0", + "traitlets >=5.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aac69adfccf7fd610fd9212c99a51212", + "name": "ipykernel", + "sha256": "c4570dacb044ce8cb4932e280bd4e0b9ad9d12fab64a61953da51a390c163629", + "size": 194229, + "subdir": "linux-64", + "timestamp": 1662361852777, + "version": "6.15.2" + }, + "ipykernel-6.19.2-py310h2f386ee_0.conda": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "comm >=0.1.1", + "debugpy >=1.0", + "ipython >=7.23.1", + "jupyter_client >=6.1.12", + "matplotlib-inline >=0.1", + "nest-asyncio", + "packaging", + "psutil", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "tornado >=6.1", + "traitlets >=5.4.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4e3b198588181bc66c09cd4e908f8da3", + "name": "ipykernel", + "sha256": "463c9966382302b768fa14aa58d331144bce6be12f4e2db6f6a409968e12a4a2", + "size": 224946, + "subdir": "linux-64", + "timestamp": 1671488556575, + "version": "6.19.2" + }, + "ipykernel-6.19.2-py311h6410fe4_0.conda": { + "build": "py311h6410fe4_0", + "build_number": 0, + "depends": [ + "comm >=0.1.1", + "debugpy >=1.0", + "ipython >=7.23.1", + "jupyter_client >=6.1.12", + "matplotlib-inline >=0.1", + "nest-asyncio", + "packaging", + "psutil", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "tornado >=6.1", + "traitlets >=5.4.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "40b6d73dad3a72d777434f4fdc49339f", + "name": "ipykernel", + "sha256": "ef577244ffd7f7dcab218e45e57f8d37fb7b21a0f889e93a2bfd2b1ce725f492", + "size": 274414, + "subdir": "linux-64", + "timestamp": 1677867968670, + "version": "6.19.2" + }, + "ipykernel-6.19.2-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "comm >=0.1.1", + "debugpy >=1.0", + "ipython >=7.23.1", + "jupyter_client >=6.1.12", + "matplotlib-inline >=0.1", + "nest-asyncio", + "packaging", + "psutil", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "tornado >=6.1", + "traitlets >=5.4.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "16bd8c613dd822b1cb837c042ed5f210", + "name": "ipykernel", + "sha256": "5beea0c44f820d8d4e92eb643d8971ee38bed26c82f1439734db249bf8688534", + "size": 222981, + "subdir": "linux-64", + "timestamp": 1671488427499, + "version": "6.19.2" + }, + "ipykernel-6.19.2-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "comm >=0.1.1", + "debugpy >=1.0", + "ipython >=7.23.1", + "jupyter_client >=6.1.12", + "matplotlib-inline >=0.1", + "nest-asyncio", + "packaging", + "psutil", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "tornado >=6.1", + "traitlets >=5.4.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "81bb66e37fb0afaed483d0bc6c629ac9", + "name": "ipykernel", + "sha256": "bcc765f0d38ee5c8aeaf7bba9efa3611312d73a0652679eb3851bc9e751bd51e", + "size": 222796, + "subdir": "linux-64", + "timestamp": 1671488675347, + "version": "6.19.2" + }, + "ipykernel-6.2.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "argcomplete >=1.12.3", + "debugpy >=1,<2.0", + "importlib-metadata <5", + "ipython >=7.23.1,<8.0", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "python >=3.7,<3.8.0a0", + "tornado >=4.2,<7.0", + "traitlets >=4.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a3d61a8b19bf725afba0c33304ef9e77", + "name": "ipykernel", + "sha256": "7ab9ca5e5bf09dd14e8ec08b6c6f329cea7c3982147727e5e647240f809cb167", + "size": 195183, + "subdir": "linux-64", + "timestamp": 1629986184914, + "version": "6.2.0" + }, + "ipykernel-6.2.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "debugpy >=1,<2.0", + "ipython >=7.23.1,<8.0", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "python >=3.8,<3.9.0a0", + "tornado >=4.2,<7.0", + "traitlets >=4.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "500c741931363ee9e9f6c54401e95623", + "name": "ipykernel", + "sha256": "2d989610c4e6e29f58454bfc9c32e6353606eef2a2afdaadfac6cc1adc00e618", + "size": 196100, + "subdir": "linux-64", + "timestamp": 1629995147032, + "version": "6.2.0" + }, + "ipykernel-6.2.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "debugpy >=1,<2.0", + "ipython >=7.23.1,<8.0", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "python >=3.9,<3.10.0a0", + "tornado >=4.2,<7.0", + "traitlets >=4.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "af0cccf3db01ba854364e4ec3ee8fcbe", + "name": "ipykernel", + "sha256": "7da6df17d063824c1c6b7d18955547c1490c182c3f464e636d85755732ce9933", + "size": 195890, + "subdir": "linux-64", + "timestamp": 1629995148430, + "version": "6.2.0" + }, + "ipykernel-6.4.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "debugpy >=1,<2.0", + "ipython >=7.23.1,<8.0", + "ipython_genutils", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "python >=3.10,<3.11.0a0", + "tornado >=4.2,<7.0", + "traitlets >=4.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f5db85cfa7995f99d87ac3a77b1f787c", + "name": "ipykernel", + "sha256": "c4549a5af699c1a82e576354f5779925bae811b8650e241f12447e61842268e4", + "size": 184433, + "subdir": "linux-64", + "timestamp": 1640812222903, + "version": "6.4.1" + }, + "ipykernel-6.4.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "argcomplete >=1.12.3", + "debugpy >=1,<2.0", + "importlib-metadata <5", + "ipython >=7.23.1,<8.0", + "ipython_genutils", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "python >=3.7,<3.8.0a0", + "tornado >=4.2,<7.0", + "traitlets >=4.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "196b142688ac3d6049b9d99763454fb9", + "name": "ipykernel", + "sha256": "a8876d321e0a184b1ff17960b8507472885d4174bc1c55fe3335a5e2ec7f7dca", + "size": 197585, + "subdir": "linux-64", + "timestamp": 1633545462807, + "version": "6.4.1" + }, + "ipykernel-6.4.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "debugpy >=1,<2.0", + "ipython >=7.23.1,<8.0", + "ipython_genutils", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "python >=3.8,<3.9.0a0", + "tornado >=4.2,<7.0", + "traitlets >=4.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "665cc9e25b016586f68da2aa612e7720", + "name": "ipykernel", + "sha256": "b846758d72a87deac90312fbdf42c245d726ef9521cc4c05c5adf0606322decf", + "size": 198442, + "subdir": "linux-64", + "timestamp": 1633545454359, + "version": "6.4.1" + }, + "ipykernel-6.4.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "debugpy >=1,<2.0", + "ipython >=7.23.1,<8.0", + "ipython_genutils", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "python >=3.9,<3.10.0a0", + "tornado >=4.2,<7.0", + "traitlets >=4.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bfb323ce72a0787939d2412529a8063f", + "name": "ipykernel", + "sha256": "0ceb4ca7c572152310d9c3da88b75aee4a5668d9975ebc83a1961bb30532bc6d", + "size": 198412, + "subdir": "linux-64", + "timestamp": 1633534698061, + "version": "6.4.1" + }, + "ipykernel-6.9.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "debugpy >=1.0.0,<2.0", + "ipython >=7.23.1", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "nest-asyncio", + "python >=3.10,<3.11.0a0", + "tornado >=4.2,<7.0", + "traitlets >=5.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "99c8e70711b05a26293afab6eb8d30fd", + "name": "ipykernel", + "sha256": "f0d43a7f276d31ce1bad0ba0a5ca6e0fe68b2976f52dbf05eb657e6c7a8cd4ae", + "size": 208133, + "subdir": "linux-64", + "timestamp": 1647000831741, + "version": "6.9.1" + }, + "ipykernel-6.9.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "debugpy >=1.0.0,<2.0", + "ipython >=7.23.1", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "nest-asyncio", + "python >=3.7,<3.8.0a0", + "tornado >=4.2,<7.0", + "traitlets >=5.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "43e5f20773f33433bb6f3081b2f8d157", + "name": "ipykernel", + "sha256": "dd5f92b4e2c0f6580e44131138ae6db24071e0d0014ee0b056c893457d8b349e", + "size": 202963, + "subdir": "linux-64", + "timestamp": 1646983262624, + "version": "6.9.1" + }, + "ipykernel-6.9.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "debugpy >=1.0.0,<2.0", + "ipython >=7.23.1", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "nest-asyncio", + "python >=3.8,<3.9.0a0", + "tornado >=4.2,<7.0", + "traitlets >=5.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "64a5bfbc32f1e68b0eda430a1e3e2c11", + "name": "ipykernel", + "sha256": "a2e50454773714563d6384fa8b0651c30445b6d99ddd6520d36ac53aa90de6de", + "size": 204063, + "subdir": "linux-64", + "timestamp": 1646982691923, + "version": "6.9.1" + }, + "ipykernel-6.9.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "debugpy >=1.0.0,<2.0", + "ipython >=7.23.1", + "jupyter_client <8.0", + "matplotlib-inline >=0.1.0,<0.2.0", + "nest-asyncio", + "python >=3.9,<3.10.0a0", + "tornado >=4.2,<7.0", + "traitlets >=5.1.0,<6.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "59b681ef2ada970ae0d5ca32c4f9a921", + "name": "ipykernel", + "sha256": "66bcf46dc3fd91d5fd4b5b74bdf2ffded90987e402af4cc5fe5c75789c274208", + "size": 206024, + "subdir": "linux-64", + "timestamp": 1647000816111, + "version": "6.9.1" + }, + "ipyparallel-6.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator", + "futures", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f7f9965f892bceec37b5045257d81798", + "name": "ipyparallel", + "sha256": "5337baab6c34310b6af1c82af8f49f7c0180d4a22c7dee943caa0b654f61ba23", + "size": 303630, + "subdir": "linux-64", + "timestamp": 1518721747213, + "version": "6.1.1" + }, + "ipyparallel-6.1.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "02c22254f14f0f3a1edd805316aaf675", + "name": "ipyparallel", + "sha256": "c1b2fb25e9e44454f0c500becb79a5b7be714537fc0625b7e328dc37183ea75e", + "size": 310128, + "subdir": "linux-64", + "timestamp": 1518721757546, + "version": "6.1.1" + }, + "ipyparallel-6.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a7ac08a18226a7e38947af0f1a51238a", + "name": "ipyparallel", + "sha256": "ac70dd17dbd56e89132bdaba49f4215884e5266dac5b02d60bf1174c1f871c17", + "size": 302848, + "subdir": "linux-64", + "timestamp": 1518721824708, + "version": "6.1.1" + }, + "ipyparallel-6.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator", + "futures", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "02f9461f186e6186a05b0f04cc08f263", + "name": "ipyparallel", + "sha256": "56f398ae6ecab4613b73957ebf5c2897e998f736a963cfcec721ca8361292f4d", + "size": 302753, + "subdir": "linux-64", + "timestamp": 1528219407881, + "version": "6.2.1" + }, + "ipyparallel-6.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5ca9c6c8b5b8869fe0805ec53582066a", + "name": "ipyparallel", + "sha256": "32d56048ee69fc8ce15145cf5d16e8eecd7ddd6f50c66a9edf9b8cefeb648552", + "size": 312363, + "subdir": "linux-64", + "timestamp": 1528219433975, + "version": "6.2.1" + }, + "ipyparallel-6.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "156f496632dcd30de846da48ccddeabd", + "name": "ipyparallel", + "sha256": "325a8a2f7fd098d8e85ad3f9bcb8ab48660c62e4085abad452b47c7f89cdeab7", + "size": 304918, + "subdir": "linux-64", + "timestamp": 1528219387902, + "version": "6.2.1" + }, + "ipyparallel-6.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f9574d0b7b4c74d7e70976d30ce4d419", + "name": "ipyparallel", + "sha256": "c7b052d779846e1c9eb9040c7d6ec6eecf3cb45dbd12c3376a74f4e710fbd831", + "size": 308955, + "subdir": "linux-64", + "timestamp": 1530897876704, + "version": "6.2.1" + }, + "ipyparallel-6.2.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator", + "futures", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5c4c580a4cb39cc4131e9cf1386e4ad8", + "name": "ipyparallel", + "sha256": "11e7e4168e695c7d0cf52df95cbb5360390ef3f4e381376e48b7fe89075d4ac0", + "size": 307057, + "subdir": "linux-64", + "timestamp": 1532629328930, + "version": "6.2.2" + }, + "ipyparallel-6.2.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eadda9f233ad11b4d06a1c5514733af1", + "name": "ipyparallel", + "sha256": "b5f38ac0b6191414727355735da2d2e9cba8a52e71286c163daf901425e7f1ef", + "size": 309677, + "subdir": "linux-64", + "timestamp": 1532629463657, + "version": "6.2.2" + }, + "ipyparallel-6.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "89a713ec0e7abc910ec9fe8499eb9887", + "name": "ipyparallel", + "sha256": "8c43d6edbdca87b68227e1c66a67d9e32fd36843cda444bbfe7f050157a4aac3", + "size": 310051, + "subdir": "linux-64", + "timestamp": 1532629387504, + "version": "6.2.2" + }, + "ipyparallel-6.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "26e6d862e2fd26b2456cafda9bd9b328", + "name": "ipyparallel", + "sha256": "71156917e96700671ae7e55bcad374b3f0025dbd39c297b70a9b41e8a719560d", + "size": 310540, + "subdir": "linux-64", + "timestamp": 1532629449211, + "version": "6.2.2" + }, + "ipyparallel-6.2.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator", + "futures", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ce427d8ea702dcadc029ae8638dbea49", + "name": "ipyparallel", + "sha256": "68584c260799b0ca42f4ca2335cc818f28af6e5ec005bcee9e408d0091078337", + "size": 307005, + "subdir": "linux-64", + "timestamp": 1540979213173, + "version": "6.2.3" + }, + "ipyparallel-6.2.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5018d0bebaaa8c88189bfe14eac2c629", + "name": "ipyparallel", + "sha256": "fb2bc4383c2baaecf55535f722bfd3af2ab16e645cec7ac264dd8895575bc594", + "size": 309889, + "subdir": "linux-64", + "timestamp": 1540979291738, + "version": "6.2.3" + }, + "ipyparallel-6.2.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cd42c910ebde401243035072bf81aa3f", + "name": "ipyparallel", + "sha256": "9564a21def62a6edfa3bd1cecef12c4e60833c14d558dfd28e2dd2edd1bb235c", + "size": 309949, + "subdir": "linux-64", + "timestamp": 1540979295449, + "version": "6.2.3" + }, + "ipyparallel-6.2.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator", + "futures", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8125b1cb3a8c823760d467acc487b8c3", + "name": "ipyparallel", + "sha256": "0de6cb72b0a32a1f9da163c214d75f248be348a6e8c7e02e1050db961dcf184a", + "size": 313250, + "subdir": "linux-64", + "timestamp": 1559061922771, + "version": "6.2.4" + }, + "ipyparallel-6.2.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c4e1cfc70c86ad01895b250b18adf360", + "name": "ipyparallel", + "sha256": "1b903f054c3da41f8be6a111a52c61274f4a3f5d4dac1d5bbd2c1542c7a03416", + "size": 316576, + "subdir": "linux-64", + "timestamp": 1558606856336, + "version": "6.2.4" + }, + "ipyparallel-6.2.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "50afb0c0278f27b39954cffb339be84c", + "name": "ipyparallel", + "sha256": "3a3e6b34750f8964f9273063b820a595846c905dc8510471cd6bbbe7c410c21a", + "size": 316954, + "subdir": "linux-64", + "timestamp": 1559061878626, + "version": "6.2.4" + }, + "ipyparallel-6.2.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d979f1eeb3f57e32d9c620fcad3a3aa5", + "name": "ipyparallel", + "sha256": "5d656d3d9908baf11f9436bfab18c1b3c029cf2079f2f1cee9d49e7ad274964a", + "size": 312637, + "subdir": "linux-64", + "timestamp": 1574238629998, + "version": "6.2.4" + }, + "ipyparallel-6.2.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6ca52c501eb494a4aa353cdd47226e7b", + "name": "ipyparallel", + "sha256": "c9727deb77def2570c4e6f3d6061dddd7d6cdb61600d407ed49ae257217b5c57", + "size": 316953, + "subdir": "linux-64", + "timestamp": 1587604293282, + "version": "6.2.5" + }, + "ipyparallel-6.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6143da0f12acd98b26ebad035afdacff", + "name": "ipyparallel", + "sha256": "9b3d9c9eebc16b2745df1f3f9f61a90ccf6dbcb915fc5946337436e83e8e9cf3", + "size": 316803, + "subdir": "linux-64", + "timestamp": 1640813536590, + "version": "6.3.0" + }, + "ipyparallel-6.3.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a9dae83f2b9ad55c5c6d87dcdc843fac", + "name": "ipyparallel", + "sha256": "a5b19b0cab8453648f6830c1c88b63f50578580063a33eccf32250b7b440a9d9", + "size": 431074, + "subdir": "linux-64", + "timestamp": 1676852906083, + "version": "6.3.0" + }, + "ipyparallel-6.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ea43051aad83411d881459858ae56839", + "name": "ipyparallel", + "sha256": "77e1c1ff49e3b47047f27b79e35de6e91378a8f7c770f300338071669cfa132d", + "size": 314226, + "subdir": "linux-64", + "timestamp": 1593440631905, + "version": "6.3.0" + }, + "ipyparallel-6.3.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "26df3cb04fae3e946ce22d08d9338ef2", + "name": "ipyparallel", + "sha256": "bcf5b73e9826cefe0fe46ce1c7620e8a4971d0471f8aad627a73a3d619d9bca9", + "size": 318813, + "subdir": "linux-64", + "timestamp": 1613482868716, + "version": "6.3.0" + }, + "ipyparallel-6.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f3de8a39f28bb56fa30712a216b5333", + "name": "ipyparallel", + "sha256": "4dcf73c6988595ed6d2c7f8db965d187336e94c5d95f55f73a8207fdfb351520", + "size": 318785, + "subdir": "linux-64", + "timestamp": 1593440631932, + "version": "6.3.0" + }, + "ipyparallel-6.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a248999460cd2e03ed9450df5e5cc405", + "name": "ipyparallel", + "sha256": "70f9f047ba97fdb4ca2355203906849fe9126b2179b94788182d5e7d62df0583", + "size": 319079, + "subdir": "linux-64", + "timestamp": 1613482859694, + "version": "6.3.0" + }, + "ipyparallel-6.3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6b646d1d0f5c79cd2c5b0a7f84da6b55", + "name": "ipyparallel", + "sha256": "d348f77046ae5554383fc670ccbcb66810c29f314ddbd50d543b466e08a895b0", + "size": 315374, + "subdir": "linux-64", + "timestamp": 1593440631905, + "version": "6.3.0" + }, + "ipyparallel-6.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "09d17b6b3e50f560f50c39c0ff76a711", + "name": "ipyparallel", + "sha256": "bb0a44f1400e68f7e4c1945ab3dd1a4088c1cfb3fe1867a2e43c3e871131acbd", + "size": 320254, + "subdir": "linux-64", + "timestamp": 1613482863072, + "version": "6.3.0" + }, + "ipyparallel-6.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipykernel >=4.4", + "ipython >=4", + "ipython_genutils", + "jupyter_client", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dd44a5795691e8a34dd5398c1d4a228a", + "name": "ipyparallel", + "sha256": "51eac972cb02673f9404ee8f1336cc83c4f45167fd5fe2ab4fe4513947111759", + "size": 320410, + "subdir": "linux-64", + "timestamp": 1613482240946, + "version": "6.3.0" + }, + "ipyparallel-8.4.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "entrypoints", + "ipykernel >=4.4", + "ipython >=4", + "jupyter_client", + "psutil", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.1", + "pyzmq >=18", + "tornado >=5.1", + "tqdm", + "traitlets >=4.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eebf11c3daf53d9fb56459b5d7259ca7", + "name": "ipyparallel", + "sha256": "14e1ed420977b117b09533bc7b50f0736943a4bc76cdec783b0d4610e3079565", + "size": 458656, + "subdir": "linux-64", + "timestamp": 1677879768000, + "version": "8.4.1" + }, + "ipyparallel-8.4.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "entrypoints", + "ipykernel >=4.4", + "ipython >=4", + "jupyter_client", + "psutil", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.1", + "pyzmq >=18", + "tornado >=5.1", + "tqdm", + "traitlets >=4.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "af3e5e90fcffed03fdd9945ebf371c14", + "name": "ipyparallel", + "sha256": "07da08527f9f9982c2adc917c4c64da77d6667bc6955ca7a3ca4484da434bde7", + "size": 570842, + "subdir": "linux-64", + "timestamp": 1677867596417, + "version": "8.4.1" + }, + "ipyparallel-8.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "entrypoints", + "ipykernel >=4.4", + "ipython >=4", + "jupyter_client", + "psutil", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyzmq >=18", + "tornado >=5.1", + "tqdm", + "traitlets >=4.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "debb9c3933652575e86642209275ee27", + "name": "ipyparallel", + "sha256": "46859ba411b9e675723a43e7900c6f33a231476859518fe313175c0f907c6bb7", + "size": 454334, + "subdir": "linux-64", + "timestamp": 1677879697626, + "version": "8.4.1" + }, + "ipyparallel-8.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "entrypoints", + "ipykernel >=4.4", + "ipython >=4", + "jupyter_client", + "psutil", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "pyzmq >=18", + "tornado >=5.1", + "tqdm", + "traitlets >=4.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "712c474b88f2b386c0e02d9e98fcbc46", + "name": "ipyparallel", + "sha256": "cd38c8585e586e4b5106d1ed1e318fc99bc8122a4b1786d2321227ea4962928e", + "size": 453852, + "subdir": "linux-64", + "timestamp": 1677879624343, + "version": "8.4.1" + }, + "ipython-5.4.1-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "backports.shutil_get_terminal_size", + "decorator", + "pathlib2", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=2.7,<2.8.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "42c146de127feb01521d5683d643225e", + "name": "ipython", + "sha256": "94ac65243e31b32dee32cc4f39d5f409fa3c0cd0e9c835bfb12e79e941f9ba4e", + "size": 941413, + "subdir": "linux-64", + "timestamp": 1516650353919, + "version": "5.4.1" + }, + "ipython-5.4.1-py27h36c99b6_1.conda": { + "build": "py27h36c99b6_1", + "build_number": 1, + "depends": [ + "backports.shutil_get_terminal_size", + "decorator", + "pathlib2", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=2.7,<2.8.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "d9f0d2ef94efa2ce51d5e648539b2aab", + "name": "ipython", + "sha256": "e994962d466397ed132197649c080d2f00478f03d2ed8acba46801cc921d0a4e", + "size": 952893, + "subdir": "linux-64", + "timestamp": 1505690417052, + "version": "5.4.1" + }, + "ipython-5.4.1-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "decorator", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "ff3a38197944f3587ec0e11c9ec63f27", + "name": "ipython", + "sha256": "e649dea73f814b07e0e85f9364e7f66394432ba2fd3f37c7c229b7e507959e9a", + "size": 963035, + "subdir": "linux-64", + "timestamp": 1516650397213, + "version": "5.4.1" + }, + "ipython-5.4.1-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "decorator", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "648690642a9909badc2e3fccfdb7a46a", + "name": "ipython", + "sha256": "101df71b92923385a5ed7686d4fae4093a15b215784d5a86564d33a90c367d65", + "size": 951926, + "subdir": "linux-64", + "timestamp": 1516650399834, + "version": "5.4.1" + }, + "ipython-5.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.shutil_get_terminal_size", + "decorator", + "pathlib2", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=2.7,<2.8.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "cdc1e8d230f3a1514d1dab56f7194015", + "name": "ipython", + "sha256": "558a56a28da8ddd85b52bba68c7fa4dda82bbf665de18f41e3e01af1f95108e7", + "size": 955704, + "subdir": "linux-64", + "timestamp": 1522686124984, + "version": "5.5.0" + }, + "ipython-5.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "1a19d3ee84abe582a00ec59257c5edf8", + "name": "ipython", + "sha256": "e4174eacb7c05764ea9b8c9735b77804a4ea18fd859f96403f20899be47c3d34", + "size": 951797, + "subdir": "linux-64", + "timestamp": 1522686147501, + "version": "5.5.0" + }, + "ipython-5.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "96c9378fd4f8f5be54d640754283479b", + "name": "ipython", + "sha256": "540cb09aba68e4d6cde6d7d8776719b876e047b2d7d1fadf165066fc6b28916a", + "size": 954106, + "subdir": "linux-64", + "timestamp": 1522686050018, + "version": "5.5.0" + }, + "ipython-5.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.shutil_get_terminal_size", + "decorator", + "pathlib2", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=2.7,<2.8.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "cc86ac8bafcce7f8eab2e599a06fdc8a", + "name": "ipython", + "sha256": "95481d1626ccc80d0ce4a8cb4d299988919da4020cb9d9c0af266a477ae7e3c2", + "size": 944514, + "subdir": "linux-64", + "timestamp": 1522690259211, + "version": "5.6.0" + }, + "ipython-5.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "8d5e0f83674506eae78c801b6e5a1f28", + "name": "ipython", + "sha256": "2d8c98a9a9ad9ab0ec8f747aa52b8c799ed6ad2e280cfa4f858a6cfdb6f2a83a", + "size": 967155, + "subdir": "linux-64", + "timestamp": 1522690360749, + "version": "5.6.0" + }, + "ipython-5.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "c0eeb34ece4a825af76da90f86889f11", + "name": "ipython", + "sha256": "8907187741027db3dd44e6324ae01139b81082e95c15841240699b8edffaed14", + "size": 942276, + "subdir": "linux-64", + "timestamp": 1522690361398, + "version": "5.6.0" + }, + "ipython-5.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.shutil_get_terminal_size", + "decorator", + "pathlib2", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=2.7,<2.8.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "cdfa417249083ce56333ebf7e501581a", + "name": "ipython", + "sha256": "d0f8fc7f1261b3d6e7b2baa154d90047b6417a9f636c2cf665340d29da291e0c", + "size": 969404, + "subdir": "linux-64", + "timestamp": 1526050673300, + "version": "5.7.0" + }, + "ipython-5.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.shutil_get_terminal_size", + "decorator", + "pathlib2", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=2.7,<2.8.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "75210e55edcc8afed2035990b31bf401", + "name": "ipython", + "sha256": "cbfb67fa3b79c0fb4bb67ff1c7b4574704d4d2ba54e64395b93d138015704b48", + "size": 955900, + "subdir": "linux-64", + "timestamp": 1532967271125, + "version": "5.8.0" + }, + "ipython-5.8.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "89d96e6396e0ae1a4f5df4bc4d252c35", + "name": "ipython", + "sha256": "69b0e8c042d58f36d2b2d221e12725ad54417beaa3adf170d8fb9a2ffa4b0f80", + "size": 978667, + "subdir": "linux-64", + "timestamp": 1532967246834, + "version": "5.8.0" + }, + "ipython-5.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "214a6a738398476245608099a1ab882a", + "name": "ipython", + "sha256": "d20cc05503ef289eb3c9fbbc6e23e296265e3256557312f6bd824d2528296dd7", + "size": 953690, + "subdir": "linux-64", + "timestamp": 1532967193884, + "version": "5.8.0" + }, + "ipython-5.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "12854aeadffc616752165209eea23632", + "name": "ipython", + "sha256": "14d4b2a22a19746ef62e606c0af88368458a0d44e4272986ddac17fa99879cc3", + "size": 966605, + "subdir": "linux-64", + "timestamp": 1532967295886, + "version": "5.8.0" + }, + "ipython-6.1.0-py35h1b71439_1.conda": { + "build": "py35h1b71439_1", + "build_number": 1, + "depends": [ + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "2bc212851eaa3cee893cbff0b44cd179", + "name": "ipython", + "sha256": "ba438f53e26f632c10bc7419bae54b0946b539d9553f130aefb497ee2e7b2beb", + "size": 950843, + "subdir": "linux-64", + "timestamp": 1505690651442, + "version": "6.1.0" + }, + "ipython-6.1.0-py36hc72a948_1.conda": { + "build": "py36hc72a948_1", + "build_number": 1, + "depends": [ + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "bdd548f900ecdf9737a2ed8ebd01b4b5", + "name": "ipython", + "sha256": "cfbeb18c6a051945f68882e2ba85158ad6db243965a5a6c0616b213fd1731406", + "size": 939818, + "subdir": "linux-64", + "timestamp": 1505690685499, + "version": "6.1.0" + }, + "ipython-6.2.1-py35hd850d2a_1.conda": { + "build": "py35hd850d2a_1", + "build_number": 1, + "depends": [ + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5e746cbcd57b73be50f553f0f604f3ae", + "name": "ipython", + "sha256": "426c0bae578743e9dfb673eae70c7e930ccd4522c7b8a02068a1d25f245263a4", + "size": 958813, + "subdir": "linux-64", + "timestamp": 1511288261990, + "version": "6.2.1" + }, + "ipython-6.2.1-py36h88c514a_1.conda": { + "build": "py36h88c514a_1", + "build_number": 1, + "depends": [ + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a26b95987edb4a61cc86360ad0f7620c", + "name": "ipython", + "sha256": "434404f0ab5dd110439d6b1bac4966f46e3ada1a744ea679f9cb2a664dee4a35", + "size": 933861, + "subdir": "linux-64", + "timestamp": 1511288267019, + "version": "6.2.1" + }, + "ipython-6.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "66e3bca11e4396078805ea61e51d8a84", + "name": "ipython", + "sha256": "c084b852f5beb98c672330ee885e41900851840fc7e31ad81f54d25779dee115", + "size": 964198, + "subdir": "linux-64", + "timestamp": 1522693081451, + "version": "6.3.0" + }, + "ipython-6.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "02472ffc293a8d3dc4182a1c88c16e38", + "name": "ipython", + "sha256": "d0e39cb703621992ed32351f1760909b4b2b39943962e9340d874317f6bb9536", + "size": 940478, + "subdir": "linux-64", + "timestamp": 1522693112517, + "version": "6.3.0" + }, + "ipython-6.3.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b8492db9915c02d9d45a4073e7680f4c", + "name": "ipython", + "sha256": "5fa453c689eae89f92ad840e3f8938b01fabba9c157e9810f18abe73b43bac29", + "size": 964959, + "subdir": "linux-64", + "timestamp": 1523021923356, + "version": "6.3.1" + }, + "ipython-6.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "380b9628c258af89e5587a383c5903bd", + "name": "ipython", + "sha256": "a995a00962e41e9371e02bf4b30866467bd3dd0795a861e063106a4cf5a6e022", + "size": 953494, + "subdir": "linux-64", + "timestamp": 1523021917817, + "version": "6.3.1" + }, + "ipython-6.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d63d4ab68d8d1144065c1f54b2c5fb89", + "name": "ipython", + "sha256": "38b81cdd95e74c9e00b5d946be887cf13ade974e59f6905c1b98940333ed2fdb", + "size": 975348, + "subdir": "linux-64", + "timestamp": 1526048601663, + "version": "6.4.0" + }, + "ipython-6.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ba9aab73b74f7493ceeb56e9aca3344b", + "name": "ipython", + "sha256": "af3da2df443b693325e4a7c3a710df21a8b9a060f0c1bc40ebb11d06f28b0622", + "size": 964032, + "subdir": "linux-64", + "timestamp": 1526048575813, + "version": "6.4.0" + }, + "ipython-6.4.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3b704c77bc582ad12718284a958b6b86", + "name": "ipython", + "sha256": "4f9ec07cc308eccaa051e43f15ee87369ecd28363919260de9432df09abf5c68", + "size": 963768, + "subdir": "linux-64", + "timestamp": 1530733978622, + "version": "6.4.0" + }, + "ipython-6.4.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6d919110399cd80e9e276642c0d05bcc", + "name": "ipython", + "sha256": "495a6dcd79343e1ec02af3b79e1f8b484c690b2839d6d5927fa5b7fa87ce7b09", + "size": 951686, + "subdir": "linux-64", + "timestamp": 1530734022931, + "version": "6.4.0" + }, + "ipython-6.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.5,<3.6.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b4ce6266919dd4b91fe0ef7bec86ea55", + "name": "ipython", + "sha256": "f8ae168183545dc42f73f00bf16e65ea2f0bcb54cf7cafb000c1ed97c405c5ed", + "size": 963743, + "subdir": "linux-64", + "timestamp": 1532964115048, + "version": "6.5.0" + }, + "ipython-6.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "86699d3ff306d8813898a26e7253421a", + "name": "ipython", + "sha256": "107c0e5a9676487f57e8e8ca1ead8f2720453b9202053283f168e1a2772252be", + "size": 966310, + "subdir": "linux-64", + "timestamp": 1532964056811, + "version": "6.5.0" + }, + "ipython-6.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=1.0.4,<2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3901dd45f8c7b3e6c42fc27931208b84", + "name": "ipython", + "sha256": "3ef9d5f6b7982f1be6d25ab27deb7d75ced36e60e27458f38a742cfd0eca2a1e", + "size": 965787, + "subdir": "linux-64", + "timestamp": 1532964096121, + "version": "6.5.0" + }, + "ipython-7.0.1-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e5d6f86b63606cc7d9014c0bfcd81d7b", + "name": "ipython", + "sha256": "d081dc9961b2304a4550b17b638c9e3d1545eac3e19836c1d1f3f0b8c6c58b5e", + "size": 964187, + "subdir": "linux-64", + "timestamp": 1538670848971, + "version": "7.0.1" + }, + "ipython-7.0.1-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "simplegeneric >0.8", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1b9f9d57251ac9fdb9f7e00269be8a8f", + "name": "ipython", + "sha256": "30454f6733eec91d7cf6a4ecab3c4d541837c5e5cd66bbcdcb6489bcbff1f67f", + "size": 965881, + "subdir": "linux-64", + "timestamp": 1538670818476, + "version": "7.0.1" + }, + "ipython-7.1.1-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "25c9274e2da90073ae8d74bfa2f33d97", + "name": "ipython", + "sha256": "d5790980f8f0ca7e3b3ec47209ee82c14057938616b9f490286885f62977a19d", + "size": 983650, + "subdir": "linux-64", + "timestamp": 1541004636457, + "version": "7.1.1" + }, + "ipython-7.1.1-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "092d4d479370d5f5806130e2f2e34ee0", + "name": "ipython", + "sha256": "921813c57372b24fe318209e83bcdf43dc7557ba76ec2b3eeabc4365007e6351", + "size": 986176, + "subdir": "linux-64", + "timestamp": 1541004679359, + "version": "7.1.1" + }, + "ipython-7.10.1-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8c02e35c2087f666fb61fdd626357a54", + "name": "ipython", + "sha256": "2d8249b46d867f42be3ca22d1a2e489bba297fc005c5753379a7d4eacbff8953", + "size": 1012894, + "subdir": "linux-64", + "timestamp": 1575478621608, + "version": "7.10.1" + }, + "ipython-7.10.1-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "602577e68d63f39941518b99776cf3a3", + "name": "ipython", + "sha256": "f18bb9a64ef30ef6c3ac320622ac458b44a0759941ff018aa49f5879712e13a5", + "size": 1010848, + "subdir": "linux-64", + "timestamp": 1575478625028, + "version": "7.10.1" + }, + "ipython-7.10.1-py38h39e3cac_0.conda": { + "build": "py38h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.8,<3.9.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "06766cd19d5bdae8a4cb59f38d2340a0", + "name": "ipython", + "sha256": "73f0f0a09d2b7468e2a496462e4d2e40c4aa927a18b1b625827d2ce415426d6f", + "size": 1015831, + "subdir": "linux-64", + "timestamp": 1575484718359, + "version": "7.10.1" + }, + "ipython-7.10.2-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5a8fe36bf8e6835a1cdb59b92e554bfe", + "name": "ipython", + "sha256": "8eb698de3b4a349ef045a75a3a5e0f5d1a0f5d3cb2d8a3b0da8dc80a72d06fe4", + "size": 1013950, + "subdir": "linux-64", + "timestamp": 1576511992396, + "version": "7.10.2" + }, + "ipython-7.10.2-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c5c8dd739b1bfb6bee80678d649d42f1", + "name": "ipython", + "sha256": "0c6c3ef83d61aa77bb90ab3be1ad85a5fc5d5c47b9babac6d494ea720a264d18", + "size": 998199, + "subdir": "linux-64", + "timestamp": 1576511944100, + "version": "7.10.2" + }, + "ipython-7.10.2-py38h39e3cac_0.conda": { + "build": "py38h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.8,<3.9.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "49fef29e9f777e0b725f6c5bcfdd2867", + "name": "ipython", + "sha256": "060d326ec1b79825955edd32084cf03b0be902673691c4b50e9b3401e04f8c98", + "size": 1003506, + "subdir": "linux-64", + "timestamp": 1576511990405, + "version": "7.10.2" + }, + "ipython-7.11.1-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5c369c3922219cb82c46df4ac86d5bd3", + "name": "ipython", + "sha256": "ded0bc879ea91adbcea80e224298e9fde7611cb7f34d8e97d11e8d3ee2210754", + "size": 1011707, + "subdir": "linux-64", + "timestamp": 1578325685352, + "version": "7.11.1" + }, + "ipython-7.11.1-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "32b47996f01542c5dc5abf6eb8b62374", + "name": "ipython", + "sha256": "e79b5e2c5308b4b90608726d800ea87ffbb8ee5e6cc4874b85abfc6a10bdc316", + "size": 997531, + "subdir": "linux-64", + "timestamp": 1578325572628, + "version": "7.11.1" + }, + "ipython-7.11.1-py38h39e3cac_0.conda": { + "build": "py38h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.8,<3.9.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "30db59945788cad9a19864a741ad39bb", + "name": "ipython", + "sha256": "cd5eb83cfc6ea2c2c42e736900ddb3beea86022479b74f883d6745a350e48509", + "size": 1003171, + "subdir": "linux-64", + "timestamp": 1578325638547, + "version": "7.11.1" + }, + "ipython-7.12.0-py36h5ca1d4c_0.conda": { + "build": "py36h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.6,<3.7.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2364d006281e9d8a87993a316aab2412", + "name": "ipython", + "sha256": "5e9c39bbf75aea8d308d577bdc2bea29237ff8183197df3d5e9ffb6a34eec3fc", + "size": 1014239, + "subdir": "linux-64", + "timestamp": 1580837277994, + "version": "7.12.0" + }, + "ipython-7.12.0-py37h5ca1d4c_0.conda": { + "build": "py37h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b879b05e6beb377746d0391c3ec4e4cc", + "name": "ipython", + "sha256": "43f6803f2fc6a4cb7e4f3ec9e05af0652e098ec2ca1af1459c5507a81ad9e9f8", + "size": 1012209, + "subdir": "linux-64", + "timestamp": 1580837257262, + "version": "7.12.0" + }, + "ipython-7.12.0-py38h5ca1d4c_0.conda": { + "build": "py38h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9297a26155c1fa4c097dcf9d33a3c1b8", + "name": "ipython", + "sha256": "0c6796326b8b45e82f0a62fa37850a3ce9ae145802786ded35667662cb526165", + "size": 1002298, + "subdir": "linux-64", + "timestamp": 1580837278274, + "version": "7.12.0" + }, + "ipython-7.13.0-py36h5ca1d4c_0.conda": { + "build": "py36h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.6,<3.7.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d6280a509328474ae9a3bc17ffd515ea", + "name": "ipython", + "sha256": "d89592736ae2e8c0f782bd54c2d7655e0703da7682d7511f841f581054911e18", + "size": 1001053, + "subdir": "linux-64", + "timestamp": 1584021361904, + "version": "7.13.0" + }, + "ipython-7.13.0-py37h5ca1d4c_0.conda": { + "build": "py37h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6b8d4cfa9699d4b5d663d4985bd79dd1", + "name": "ipython", + "sha256": "ea603b85e910585101da2c80ad1769ca8001676b2df92cfb9bbe5ce6350985e1", + "size": 1015188, + "subdir": "linux-64", + "timestamp": 1584021296829, + "version": "7.13.0" + }, + "ipython-7.13.0-py38h5ca1d4c_0.conda": { + "build": "py38h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<4,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "57313de6df9eaa6bb44140265db6ae2e", + "name": "ipython", + "sha256": "7bcdcddce3e042d55356482fab004982db0e7bf8c2806c27507e90c2b32bfa10", + "size": 1002471, + "subdir": "linux-64", + "timestamp": 1584021348429, + "version": "7.13.0" + }, + "ipython-7.15.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "efaccc423b35f8cb1bc4ac7729dbb3c3", + "name": "ipython", + "sha256": "2bcdfb242ecdf0a5567ef914551088e95d5a1d213b16240118ad3b650d7b2ee4", + "size": 1008295, + "subdir": "linux-64", + "timestamp": 1592348421007, + "version": "7.15.0" + }, + "ipython-7.15.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4e1970e669db2e94dcc84aed3ca0113f", + "name": "ipython", + "sha256": "ad3e94a2183759da778a30647870355cfa22288ebb27d5572860f200f1a328ff", + "size": 1004583, + "subdir": "linux-64", + "timestamp": 1592348440742, + "version": "7.15.0" + }, + "ipython-7.15.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fcf064c020d46de9976c129bf59ad393", + "name": "ipython", + "sha256": "1b8e63c6048301b8a88578f0b10ca6da56e459413b571fd8db6278be3ae79dbd", + "size": 1023005, + "subdir": "linux-64", + "timestamp": 1592348420828, + "version": "7.15.0" + }, + "ipython-7.16.1-py36h5ca1d4c_0.conda": { + "build": "py36h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.6,<3.7.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a4deba4b3b4cc4d864518da5f2377de0", + "name": "ipython", + "sha256": "6adf32e9c73408f9749f6118f04c2d6f218def5f0df967eac753a0c91ff91c1d", + "size": 1022919, + "subdir": "linux-64", + "timestamp": 1593447403316, + "version": "7.16.1" + }, + "ipython-7.16.1-py37h5ca1d4c_0.conda": { + "build": "py37h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4755af3c1661a2c255d4c9fdb6d4db21", + "name": "ipython", + "sha256": "f04dffec42944577110d57254b7b003dc4e3902b73f927c3d2007d62e0af54f2", + "size": 1010510, + "subdir": "linux-64", + "timestamp": 1593447400040, + "version": "7.16.1" + }, + "ipython-7.16.1-py38h5ca1d4c_0.conda": { + "build": "py38h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cab9d1edef212a48e051c2225fee350e", + "name": "ipython", + "sha256": "6802017ef47670c7432fd986d7200f8b04093c5e764b4bbc9454bbc43978013f", + "size": 1025897, + "subdir": "linux-64", + "timestamp": 1593447407997, + "version": "7.16.1" + }, + "ipython-7.17.0-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "58b9a6fa3edf7e8e3923fb8e4e1aaf53", + "name": "ipython", + "sha256": "d96babde0e6437d622c743e791b853f67f67527810b45a3c329600fde6d416b4", + "size": 1000776, + "subdir": "linux-64", + "timestamp": 1596868550866, + "version": "7.17.0" + }, + "ipython-7.17.0-py37h5ca1d4c_0.conda": { + "build": "py37h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f386d36e21071f057dce84a34edb3169", + "name": "ipython", + "sha256": "88646c404b274149c93f0721962c3ba19c376dc43e9f85860871da23e84ac459", + "size": 1026564, + "subdir": "linux-64", + "timestamp": 1598371611907, + "version": "7.17.0" + }, + "ipython-7.17.0-py38h5ca1d4c_0.conda": { + "build": "py38h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4916115c99763aa7acf999174962cf6e", + "name": "ipython", + "sha256": "b45976ee647fe9ac7be5b2ece2c051ce51ffda5ef15476650ef6d1a4fb525804", + "size": 1030672, + "subdir": "linux-64", + "timestamp": 1598371614238, + "version": "7.17.0" + }, + "ipython-7.18.1-py37h5ca1d4c_0.conda": { + "build": "py37h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "edc07f7415477902f9e9e14bdeb8309e", + "name": "ipython", + "sha256": "11cdda8445fdc8f804f4f60aaf12c1838e380e81c0954ebbf0583a4190320bfd", + "size": 1012543, + "subdir": "linux-64", + "timestamp": 1598883876782, + "version": "7.18.1" + }, + "ipython-7.18.1-py38h5ca1d4c_0.conda": { + "build": "py38h5ca1d4c_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2139428be168ed55b60333576243ca14", + "name": "ipython", + "sha256": "504f003db49369624cd21d4dba9d6a2efb1a33ffee1ce5210dfdb7532bff82c0", + "size": 1032617, + "subdir": "linux-64", + "timestamp": 1598883859417, + "version": "7.18.1" + }, + "ipython-7.19.0-py37hb070fc8_0.conda": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "04584a493f6541c38432cb2f74c79de0", + "name": "ipython", + "sha256": "2eb1ac1dc104294b20048d737c60bfb1b838a9c68345e70ebc8bf47d96b2d8ac", + "size": 1001563, + "subdir": "linux-64", + "timestamp": 1604101276114, + "version": "7.19.0" + }, + "ipython-7.19.0-py37hb070fc8_1.conda": { + "build": "py37hb070fc8_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bc8c1c2ef608b998f2886e3469cbf8b1", + "name": "ipython", + "sha256": "c7b9edd3dece52e60070da04c4a3798820044e10fbfeffdac8ff5b1154eb750c", + "size": 1028115, + "subdir": "linux-64", + "timestamp": 1610725452752, + "version": "7.19.0" + }, + "ipython-7.19.0-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "19fe22579104ac3c2babb4888ff8e94d", + "name": "ipython", + "sha256": "c150b88cc18d6955ec56cb8c5832fddf91cca0b74c108d3c4608a7d16d951947", + "size": 1005533, + "subdir": "linux-64", + "timestamp": 1604101235603, + "version": "7.19.0" + }, + "ipython-7.19.0-py38hb070fc8_1.conda": { + "build": "py38hb070fc8_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "43b155a93e05ac86f0e64a9201123718", + "name": "ipython", + "sha256": "00234b1b63ed4767a4bcbfa0fa476035412203a262df2303853468410d80dcd0", + "size": 1032123, + "subdir": "linux-64", + "timestamp": 1610724841120, + "version": "7.19.0" + }, + "ipython-7.19.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "98d1e06007d734c66e8115c63b4cdf25", + "name": "ipython", + "sha256": "6f1208bb7405eb7d81141ced1e08fb074d54f139d268699d8c1b492cc70de23e", + "size": 1018020, + "subdir": "linux-64", + "timestamp": 1607355389749, + "version": "7.19.0" + }, + "ipython-7.19.0-py39hb070fc8_1.conda": { + "build": "py39hb070fc8_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f040f1401c12b2b590d757fed295b10c", + "name": "ipython", + "sha256": "b20f9c6021316700c1330a8bba7bcdd09f87d160e04805fec9503cced9900411", + "size": 1030124, + "subdir": "linux-64", + "timestamp": 1610725439229, + "version": "7.19.0" + }, + "ipython-7.2.0-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ac5ebddae4b9784c18cf0da82f805e1b", + "name": "ipython", + "sha256": "347b02e4bef3f08891a9a34891c6be895aef8ad4f1ab37bda5b9d1ef2eee5d77", + "size": 974324, + "subdir": "linux-64", + "timestamp": 1543586495209, + "version": "7.2.0" + }, + "ipython-7.2.0-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d7ab0d3356130d2c445ad197297a0cdc", + "name": "ipython", + "sha256": "a70511a01eacee8057c947178461e447a42461e2d448166fdc19a2da6a4aee36", + "size": 973410, + "subdir": "linux-64", + "timestamp": 1543586457880, + "version": "7.2.0" + }, + "ipython-7.20.0-py37hb070fc8_0.conda": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dc02b71943a152947f4a8e35c0770c45", + "name": "ipython", + "sha256": "6b4b057c9e5c05f7350b91d3bbe0d5be397a16f9310287341de767def5c717ec", + "size": 998768, + "subdir": "linux-64", + "timestamp": 1612218596736, + "version": "7.20.0" + }, + "ipython-7.20.0-py37hb070fc8_1.conda": { + "build": "py37hb070fc8_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "28dcbfcc55760132ebe3a94036974c83", + "name": "ipython", + "sha256": "142b27240461c2026d4086a0cba72a5c5d619333f682b580692d40c57d0fce46", + "size": 1014702, + "subdir": "linux-64", + "timestamp": 1612212964562, + "version": "7.20.0" + }, + "ipython-7.20.0-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "106cae3fc930fa644a31dd7ece990357", + "name": "ipython", + "sha256": "475d740bde3aa0fd98742e799656c5aeb11b4b2caccb582c294b934d1b147ac6", + "size": 1006140, + "subdir": "linux-64", + "timestamp": 1612218578644, + "version": "7.20.0" + }, + "ipython-7.20.0-py38hb070fc8_1.conda": { + "build": "py38hb070fc8_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "adbb6765f1a2fc9dbd4f3118b4d67529", + "name": "ipython", + "sha256": "e5a5c4b62a56fec2349b12aaff4035f5efed92e9d903f73057d99e401cde2285", + "size": 1018208, + "subdir": "linux-64", + "timestamp": 1612212966918, + "version": "7.20.0" + }, + "ipython-7.20.0-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0c09e46f4d6498b9150551359f28be12", + "name": "ipython", + "sha256": "ed0083eb97b1081fa6e2faa34fe720dc1cf8dce68b369680fa6f882eabe792db", + "size": 1004573, + "subdir": "linux-64", + "timestamp": 1612218614529, + "version": "7.20.0" + }, + "ipython-7.20.0-py39hb070fc8_1.conda": { + "build": "py39hb070fc8_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d98918e42837bd4f7c20e56d6d73539c", + "name": "ipython", + "sha256": "717b5758e71cbafd5db9e407cc750690dcd48c9085b78ef68877d5adf5e8132a", + "size": 1018717, + "subdir": "linux-64", + "timestamp": 1612212962797, + "version": "7.20.0" + }, + "ipython-7.21.0-py37hb070fc8_0.conda": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "553cda1255e18cf444754771b4baca7f", + "name": "ipython", + "sha256": "d00e31738c1f73919b59f8a42355766fb826d4a42ae47750792c28faecf8acf9", + "size": 1001881, + "subdir": "linux-64", + "timestamp": 1614615683465, + "version": "7.21.0" + }, + "ipython-7.21.0-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "76adf47f05bbf0a863f315dfb89e8d58", + "name": "ipython", + "sha256": "1b6bedb1342eb41a1a015e04905aebbd0daa98c4196d0979762b06f663b4036d", + "size": 1006321, + "subdir": "linux-64", + "timestamp": 1614615289105, + "version": "7.21.0" + }, + "ipython-7.21.0-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d570ce06b41be4426ac5431b71efd1a6", + "name": "ipython", + "sha256": "0011520cada8a06db49afb860448ccf525180cdcef34316be46b8b23dbd49600", + "size": 1004860, + "subdir": "linux-64", + "timestamp": 1614616498997, + "version": "7.21.0" + }, + "ipython-7.22.0-py37hb070fc8_0.conda": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c42224cd4026a65d7caaf0dff3f1b423", + "name": "ipython", + "sha256": "e8f1cfb615cccda410fd14076ae6d8aa2af6605a2f7be7293cc6ba73601d1e7a", + "size": 1015404, + "subdir": "linux-64", + "timestamp": 1617118475839, + "version": "7.22.0" + }, + "ipython-7.22.0-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ce092ee49c2ceaf6c4414504b7a55e2f", + "name": "ipython", + "sha256": "71a7721c7fcd885f122c6dc406c1d0278b759662a39c73da156ae30f96366bee", + "size": 1005171, + "subdir": "linux-64", + "timestamp": 1617120931612, + "version": "7.22.0" + }, + "ipython-7.22.0-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit !=3.0.0,!=3.0.1,<3.1.0,>=2.0.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5e155f2b513fac1afa72bfe709ed6cd3", + "name": "ipython", + "sha256": "64471b8ea41f22c7cbefbed6031bbfc4ba4970dbfc99c5b732a73ca562b86a90", + "size": 1006702, + "subdir": "linux-64", + "timestamp": 1617120932001, + "version": "7.22.0" + }, + "ipython-7.26.0-py37hb070fc8_0.conda": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4ad91c95463ed9bf0b62206d939f602c", + "name": "ipython", + "sha256": "c52b85fec248864ac5e376930e3224778cdb098aad6c42d08647f2eb02cbd76b", + "size": 1029057, + "subdir": "linux-64", + "timestamp": 1628235884911, + "version": "7.26.0" + }, + "ipython-7.26.0-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5394391179b96f0f3c216279ab865b07", + "name": "ipython", + "sha256": "651ce9e9ffe0fc0d51bffde416171e87e499f9d73eeaa395b50a8fc27a0aab5c", + "size": 1017912, + "subdir": "linux-64", + "timestamp": 1628243960674, + "version": "7.26.0" + }, + "ipython-7.26.0-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4c73c0f21074dcae8dd6990f017e0b74", + "name": "ipython", + "sha256": "f03ce60dd1c47c1738323f0086d78fadb4bd0ad5a587399f2f01ec5af489e557", + "size": 1020417, + "subdir": "linux-64", + "timestamp": 1628243954554, + "version": "7.26.0" + }, + "ipython-7.27.0-py37hb070fc8_0.conda": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "92d2830258f7f94221f94fa7b1de6aeb", + "name": "ipython", + "sha256": "813da9a6de63122eef647ccb6168c5931a49bf083ce79cce44a3efa4c8d97c42", + "size": 1030339, + "subdir": "linux-64", + "timestamp": 1632141092862, + "version": "7.27.0" + }, + "ipython-7.27.0-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9c1ed05e7069b0bfbb2e87620c1c01d1", + "name": "ipython", + "sha256": "38e4e71aecd6b8f28a88a6cf74e426622e44c53e0ab987f75c6736c6609d1ffd", + "size": 1019762, + "subdir": "linux-64", + "timestamp": 1632141430069, + "version": "7.27.0" + }, + "ipython-7.27.0-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b5f469f89e30bd6aa64acd45ccb740d5", + "name": "ipython", + "sha256": "df8e48b911b29e52fbb6aa1505f7d4825c5ef580aedc86bddb250b8b49cafd50", + "size": 1020575, + "subdir": "linux-64", + "timestamp": 1632131381979, + "version": "7.27.0" + }, + "ipython-7.29.0-py310h2f386ee_0.conda": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.10,<3.11.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "69c247bf75409ad5548ba9be5ba8e904", + "name": "ipython", + "sha256": "5351bd1e381900bce8656b2e5c32f15227dd87b10144cb078ca03168d0fd19c0", + "size": 1045212, + "subdir": "linux-64", + "timestamp": 1640809461659, + "version": "7.29.0" + }, + "ipython-7.29.0-py37hb070fc8_0.conda": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e64a0da4a07d8ad1b7ea71d13c670228", + "name": "ipython", + "sha256": "bc9da2be3ac533b84b4af36d6c9d5b3503bbbcaf6e33faec917978eba793184f", + "size": 1035857, + "subdir": "linux-64", + "timestamp": 1635944212908, + "version": "7.29.0" + }, + "ipython-7.29.0-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9f31c5ad59bebc1f0e2939c4906c6663", + "name": "ipython", + "sha256": "693bf98994cd711025868ab158df897f0e8b6df9bc428bcc82a242071658503c", + "size": 1026119, + "subdir": "linux-64", + "timestamp": 1635944038316, + "version": "7.29.0" + }, + "ipython-7.29.0-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16,<1.0", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1679d14f6ec6af05468309373b16c6f4", + "name": "ipython", + "sha256": "efa62e10cc1add232ef45bdbb5a406b49029bbe97043b7e267d4a8bbaff47c89", + "size": 1025741, + "subdir": "linux-64", + "timestamp": 1635944205923, + "version": "7.29.0" + }, + "ipython-7.3.0-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ec9a30c334164a16bdae33c9f882fbac", + "name": "ipython", + "sha256": "032eed9f86268fc067a6d0471958c5f524f81ab4a6293255d383adbc0a1ad681", + "size": 984265, + "subdir": "linux-64", + "timestamp": 1551128451092, + "version": "7.3.0" + }, + "ipython-7.3.0-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cfd554361d190e5167de12709ad9e927", + "name": "ipython", + "sha256": "427097852771e0d42a0a21f9c749fce58fc82e930fd3afe405aa0ca9bc5576ca", + "size": 983596, + "subdir": "linux-64", + "timestamp": 1551128448776, + "version": "7.3.0" + }, + "ipython-7.31.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.10,<3.11.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e2b948ba02c731e7b316d0f820e669a", + "name": "ipython", + "sha256": "3bb200fa8bf6f3cf6d761a2406ce058277c013f2cd0e4c92d4a426384c44a6e2", + "size": 1046564, + "subdir": "linux-64", + "timestamp": 1659530038998, + "version": "7.31.1" + }, + "ipython-7.31.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "115b35f60901351cd15631828f409d24", + "name": "ipython", + "sha256": "b9fd013e26f80c7588faba47922d9b926b609f308f18240ac08ff6c3b95cbef8", + "size": 1036977, + "subdir": "linux-64", + "timestamp": 1643818185716, + "version": "7.31.1" + }, + "ipython-7.31.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fe5d470d4694ce49fa0741090201703a", + "name": "ipython", + "sha256": "3db96a0057946406d0a6e20b7fc80841c99204cc82e19441a0e2ab54d8c49d21", + "size": 1026439, + "subdir": "linux-64", + "timestamp": 1659530195402, + "version": "7.31.1" + }, + "ipython-7.31.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e74ca0263ef60674ccb6abdb39559a27", + "name": "ipython", + "sha256": "91e4f3cb252ad7aae192739237626835d6236f495d477a5651c7af0ea6be2d35", + "size": 1043025, + "subdir": "linux-64", + "timestamp": 1643818185749, + "version": "7.31.1" + }, + "ipython-7.31.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "28fcca457264bbfa5db80f2c9164820f", + "name": "ipython", + "sha256": "285a534704dde920193968741678cca69ae157f827ec1fed1b12dfad18f50a16", + "size": 1030217, + "subdir": "linux-64", + "timestamp": 1659530314001, + "version": "7.31.1" + }, + "ipython-7.31.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f156bb7bccdaf5582c54f2c23ec93fc8", + "name": "ipython", + "sha256": "8253ee6ecb9c42b8a0ac30510a5bfd6e0ab269d99aa3c5c1838268e7c4e7de3a", + "size": 1029835, + "subdir": "linux-64", + "timestamp": 1643818181622, + "version": "7.31.1" + }, + "ipython-7.31.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,!=3.0.0,!=3.0.1,<3.1.0", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e62063f2360cb54b40286983069f664c", + "name": "ipython", + "sha256": "e04579dd1a7be81ffbed8ba303a853e6d704bf207cea2205d259a7ef25cefa37", + "size": 1033417, + "subdir": "linux-64", + "timestamp": 1659529902720, + "version": "7.31.1" + }, + "ipython-7.4.0-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6b9a54422a750e00b9f7d83089834011", + "name": "ipython", + "sha256": "906038c5583882fe83fcdeb0d02de050591f3b8b6b01f2326668cffe9bf69b72", + "size": 999871, + "subdir": "linux-64", + "timestamp": 1553524015818, + "version": "7.4.0" + }, + "ipython-7.4.0-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7b2f8014f8c14f97e1d1564e346eb8dd", + "name": "ipython", + "sha256": "05a32d3e2d43f12ae93f05a058b76631bf60ececeb4b8db000357abcf9c69051", + "size": 986066, + "subdir": "linux-64", + "timestamp": 1553523922027, + "version": "7.4.0" + }, + "ipython-7.5.0-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7833f520b7581833d68256199262750a", + "name": "ipython", + "sha256": "682e194514167ebad444768a5bdfb3a0a95f1e54e133131815737026eba41b69", + "size": 1000034, + "subdir": "linux-64", + "timestamp": 1556287378160, + "version": "7.5.0" + }, + "ipython-7.5.0-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "65c9e40809fa12add3ee898514d909e3", + "name": "ipython", + "sha256": "d90569ffe49832073ecf44594a4c42141c7adfa1621bc77ec67a8da44238579e", + "size": 986784, + "subdir": "linux-64", + "timestamp": 1556287301718, + "version": "7.5.0" + }, + "ipython-7.6.0-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "24b55862739e98798a29747bb95cb0a9", + "name": "ipython", + "sha256": "44502f5972224b9f0efae30e8a2deb58fbe32501b4662b671c0f39ae993f2259", + "size": 994590, + "subdir": "linux-64", + "timestamp": 1562004138392, + "version": "7.6.0" + }, + "ipython-7.6.0-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "21365aa1553517972b41b91e9d4a9845", + "name": "ipython", + "sha256": "2d9d5872cfbdb3f8a0bb034b50702cfa967a0c46395ff76507d9095a2a5b9e62", + "size": 993412, + "subdir": "linux-64", + "timestamp": 1562004415723, + "version": "7.6.0" + }, + "ipython-7.6.1-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0c1d1181afb4be2d99ff48234be1bab4", + "name": "ipython", + "sha256": "bbdd11c9f744b4eef3a9980685abfe48783f30ee07ca881944bb47a10cc358b8", + "size": 1008372, + "subdir": "linux-64", + "timestamp": 1562701456465, + "version": "7.6.1" + }, + "ipython-7.6.1-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2dfd512aa3edddf11c4d6a5ab308f18d", + "name": "ipython", + "sha256": "4ac8832f06385bc03bb1cecfed908702b42667bba97316cb02be1fea4f8609ee", + "size": 1007945, + "subdir": "linux-64", + "timestamp": 1562701469725, + "version": "7.6.1" + }, + "ipython-7.7.0-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "56f3ad586ecb4449dcef74a4523da234", + "name": "ipython", + "sha256": "76ca7c63f5c28994e08e5edf07c0633c97370bf8148a16dfd120b59c8ac26e42", + "size": 1008414, + "subdir": "linux-64", + "timestamp": 1564509261240, + "version": "7.7.0" + }, + "ipython-7.7.0-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "569f78dd04e0fdb8bfd093dbeae70e2a", + "name": "ipython", + "sha256": "ce614bb2e89b2073f4b80f81350a4c6df22cb5729a218c7c596b6bb0ebfa5f0a", + "size": 1007381, + "subdir": "linux-64", + "timestamp": 1564509520323, + "version": "7.7.0" + }, + "ipython-7.8.0-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b3ede8277f6dca8af1d406670f672fce", + "name": "ipython", + "sha256": "868fa4abe93a60ecb8f1dc290c3c44b146c72de4df196bab03da4b34086c07b5", + "size": 992314, + "subdir": "linux-64", + "timestamp": 1567191137752, + "version": "7.8.0" + }, + "ipython-7.8.0-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e5d41235a82aca63ebaf464e97183db", + "name": "ipython", + "sha256": "4fea60c3c22965ddff407124ee9a96ca6eeaba17423dbcd9b50a12ddcabfd373", + "size": 1008652, + "subdir": "linux-64", + "timestamp": 1567191119747, + "version": "7.8.0" + }, + "ipython-7.9.0-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.6,<3.7.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2b5909787013e51627698c17ef545f27", + "name": "ipython", + "sha256": "ff31172310f7a6499a7dc8096b6bf5b4052dce97aadde792f88f6ca0152544f3", + "size": 1007851, + "subdir": "linux-64", + "timestamp": 1572462615818, + "version": "7.9.0" + }, + "ipython-7.9.0-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.7,<3.8.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7b18a3c675fc0ba74f417090efcfb6b8", + "name": "ipython", + "sha256": "d429fa3de534bde7b7f07140acf36bbdcd3f2abb322a50b877b8d35200176b7a", + "size": 1007834, + "subdir": "linux-64", + "timestamp": 1572462603146, + "version": "7.9.0" + }, + "ipython-7.9.0-py38h39e3cac_0.conda": { + "build": "py38h39e3cac_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.10,<0.18", + "pexpect", + "pickleshare", + "prompt_toolkit >=2.0.0,<3", + "pygments", + "python >=3.8,<3.9.0a0", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "551572473fff296e2905c8a33f71e982", + "name": "ipython", + "sha256": "214f40383a82dd42336713e807ea39fc9cce9045bfdcb817c40d55a36783d847", + "size": 1003270, + "subdir": "linux-64", + "timestamp": 1574177550400, + "version": "7.9.0" + }, + "ipython-8.1.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d9e619942b4ba3de9e64b0519b54449d", + "name": "ipython", + "sha256": "0141332098e359ccd8b2d6a49cc99692432e347352b66cc848135392d09fc722", + "size": 997711, + "subdir": "linux-64", + "timestamp": 1646949833716, + "version": "8.1.1" + }, + "ipython-8.1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0dbb88fc5df82222b1ff765e27f0028b", + "name": "ipython", + "sha256": "c13a21157a2f563512fbfbdbfec5ad9838bdfced7b1ae288e96ff6572c99792e", + "size": 981614, + "subdir": "linux-64", + "timestamp": 1646949544519, + "version": "8.1.1" + }, + "ipython-8.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "21a6661c041a28cb3bb2566204b7fcb1", + "name": "ipython", + "sha256": "5adcb8f896b1376fa7ad53c870e9b49df378d3390b1bc24e11a5738779265ac7", + "size": 981431, + "subdir": "linux-64", + "timestamp": 1646949689716, + "version": "8.1.1" + }, + "ipython-8.10.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5b258e4a59044ca7bf8e3fbe68a074fd", + "name": "ipython", + "sha256": "455a95adda6aa6669bb8bb9ee3a0a9063daeee3474b9f40807e3caeeec5f5a66", + "size": 1119960, + "subdir": "linux-64", + "timestamp": 1676582497535, + "version": "8.10.0" + }, + "ipython-8.10.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0", + "pygments >=2.4.0", + "python >=3.11,<3.12.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2e12c7cf9ce35342af668d99da2eead7", + "name": "ipython", + "sha256": "fb94793e75d409a28be50d9effa129f6e5eedc91106999f5f9bfa077778905a5", + "size": 1354125, + "subdir": "linux-64", + "timestamp": 1676824943533, + "version": "8.10.0" + }, + "ipython-8.10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c3b869591079727cf47047010ab94071", + "name": "ipython", + "sha256": "694a6acfabfbb56a8dd5e532356b53d22e96a7eeeb0a7433380642417486e817", + "size": 1100834, + "subdir": "linux-64", + "timestamp": 1676582385859, + "version": "8.10.0" + }, + "ipython-8.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3aaad576cbeaba8085783f8904595f8b", + "name": "ipython", + "sha256": "61fba1f3e1cb7112be7d7b1b1df48778e6751abac6384d3b6a1b8e29d5bde44a", + "size": 1103521, + "subdir": "linux-64", + "timestamp": 1676582265069, + "version": "8.10.0" + }, + "ipython-8.12.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0,!=3.0.37", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0ffe1a9ac4a7e84f2d53b945bd974e89", + "name": "ipython", + "sha256": "48dc20b9023ea8d1ef3a6da434d7ca389df602a4637f5bb8f8d083224fbac31a", + "size": 1164410, + "subdir": "linux-64", + "timestamp": 1680701911266, + "version": "8.12.0" + }, + "ipython-8.12.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0,!=3.0.37", + "pygments >=2.4.0", + "python >=3.11,<3.12.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ca554990a0b5446c608f47b0836705ae", + "name": "ipython", + "sha256": "f601cb1ffeed2017d27ea46b31fa38d95a9d4ee61036044905078c0023d550ec", + "size": 1488544, + "subdir": "linux-64", + "timestamp": 1680702276698, + "version": "8.12.0" + }, + "ipython-8.12.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0,!=3.0.37", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "stack_data", + "traitlets >=5", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a836da0503a22507ab0174329589079", + "name": "ipython", + "sha256": "d8705b88ec6833f80068527719ace5dc79b657c4bb7c4961722f2f7fb381d5fc", + "size": 1146473, + "subdir": "linux-64", + "timestamp": 1680702037294, + "version": "8.12.0" + }, + "ipython-8.12.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0,!=3.0.37", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "stack_data", + "traitlets >=5", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4098f8fa895a639b69bfcfb37a2b5ae4", + "name": "ipython", + "sha256": "51dd74de59c54630212a7b42f24342a9a5d021bbe4ccaf7796dd1c0d8f061109", + "size": 1145107, + "subdir": "linux-64", + "timestamp": 1680702156755, + "version": "8.12.0" + }, + "ipython-8.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7bb8a3cf07b68ca242ee8bb83bcda06f", + "name": "ipython", + "sha256": "b76301a9131bf0fd6451e839bf0fefea8050bb4b9b51d633217b8721c59db2c0", + "size": 1014552, + "subdir": "linux-64", + "timestamp": 1649079009751, + "version": "8.2.0" + }, + "ipython-8.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4405f53f4bef8c0784d7e8cf69360f58", + "name": "ipython", + "sha256": "da5f819d25ca8d12d51c792bcbabadce49442e78bd9ac39fbdb4b6f7280cf548", + "size": 999285, + "subdir": "linux-64", + "timestamp": 1649079154888, + "version": "8.2.0" + }, + "ipython-8.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b0c3b87bd716237abde6e55aceb008e0", + "name": "ipython", + "sha256": "726e82340a4660961b205353a05f327893de0c37166b6a9110c3543ea77b1edd", + "size": 996457, + "subdir": "linux-64", + "timestamp": 1649079285722, + "version": "8.2.0" + }, + "ipython-8.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "508c905cac58e3f9c3071ef8ea1baf6f", + "name": "ipython", + "sha256": "50546a7976e652add85185fdb33fb28d7955f5551c88397bc6a8c49fbbadb84e", + "size": 1000851, + "subdir": "linux-64", + "timestamp": 1651600469933, + "version": "8.3.0" + }, + "ipython-8.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "770f26af389c5103c26addcae7fe755b", + "name": "ipython", + "sha256": "89e739f38d68fd8fce416e2d3cc1ea9cfd07a78d995e7674b3b027937f7658e4", + "size": 985787, + "subdir": "linux-64", + "timestamp": 1651600182146, + "version": "8.3.0" + }, + "ipython-8.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5bb38d20afb3c52f194b8f3a0954701c", + "name": "ipython", + "sha256": "0ff801f2ae16164575f9dfe0e27e9929dc7726611235bc9d2c05da6141292b5f", + "size": 986289, + "subdir": "linux-64", + "timestamp": 1651600322541, + "version": "8.3.0" + }, + "ipython-8.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b51a44f76a62d175995c346facec6e40", + "name": "ipython", + "sha256": "e60104e097ef8229af3cb4692299a9d89327b0dca824054c2123ee69720e27c2", + "size": 997913, + "subdir": "linux-64", + "timestamp": 1657652542580, + "version": "8.4.0" + }, + "ipython-8.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "453d75ac39ca6d0075d2c5051c139e5b", + "name": "ipython", + "sha256": "1acdec882b588e9f874fa39dbe1398845d4e92ecd24092c21200f98dd853c161", + "size": 983143, + "subdir": "linux-64", + "timestamp": 1657652396073, + "version": "8.4.0" + }, + "ipython-8.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "setuptools >=18.5", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2b007e18863e88fc793736c9899cf289", + "name": "ipython", + "sha256": "1fe05b7fbf05f6142c95116964fca078ae64652c3aace0f8bbddb8c10ecd6798", + "size": 985377, + "subdir": "linux-64", + "timestamp": 1657652249749, + "version": "8.4.0" + }, + "ipython-8.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.1,<3.1.0", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5676bd4a483cd32d3fc22b01e9d0c637", + "name": "ipython", + "sha256": "183e74a87535d5f4899c7f04bc15826220fb365255476a2ceeac65cccd7ba323", + "size": 1078858, + "subdir": "linux-64", + "timestamp": 1668088371980, + "version": "8.6.0" + }, + "ipython-8.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.1,<3.1.0", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "083c5ae6fb421c9fdd94f98001ee678c", + "name": "ipython", + "sha256": "f15aea0c58301b339ad19972221f5a5a03cc6b2d108a86e29134732291afb1d1", + "size": 1061985, + "subdir": "linux-64", + "timestamp": 1668088271001, + "version": "8.6.0" + }, + "ipython-8.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.1,<3.1.0", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "174fb2be7e10f80b69fe5c310df42f0d", + "name": "ipython", + "sha256": "1d127815bcae2ec5d3b800f6ec234e14a23904ba9156df1df07623f2604a8a59", + "size": 1060621, + "subdir": "linux-64", + "timestamp": 1668088159097, + "version": "8.6.0" + }, + "ipython-8.7.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.11,<3.1.0", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4a3243ffa7cc18acb26f8796d935fdf2", + "name": "ipython", + "sha256": "405f336e93eba9cbfe96449ec98aa6669de7d0cb6934aa6f7db0a479ffae29d1", + "size": 1079482, + "subdir": "linux-64", + "timestamp": 1670919474577, + "version": "8.7.0" + }, + "ipython-8.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.11,<3.1.0", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3086b6cb9dc3d8e1e9610f53c82b61b3", + "name": "ipython", + "sha256": "e26fcf8f76559f9312cf91a260d51a0afe7829dd7c0578bd2fc230483454f043", + "size": 1061956, + "subdir": "linux-64", + "timestamp": 1670919585793, + "version": "8.7.0" + }, + "ipython-8.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.11,<3.1.0", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eafc9037d81c102f9ee5e8b347129167", + "name": "ipython", + "sha256": "2f2d7c5dfae69bb17eb0c96e23ad645e20a09f59409ca247453e3519c41c40cc", + "size": 1062521, + "subdir": "linux-64", + "timestamp": 1670919359769, + "version": "8.7.0" + }, + "ipython-8.8.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.11,<3.1.0", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "87531331adad9950ee6d4e0d96bbd002", + "name": "ipython", + "sha256": "b50f109a3a30cca6134e73cd12f7f9452963873c51de4c82c71282ed96c7d3b2", + "size": 1107455, + "subdir": "linux-64", + "timestamp": 1674681578555, + "version": "8.8.0" + }, + "ipython-8.8.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.11,<3.1.0", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0f6eef35e2d7008ce5b6c588f66a9631", + "name": "ipython", + "sha256": "3bd6a306162d4388789d64dad597e430ffa16d02caca4125c4207b8bad22615c", + "size": 1090402, + "subdir": "linux-64", + "timestamp": 1674681691019, + "version": "8.8.0" + }, + "ipython-8.8.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline >=0.1.2", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.11,<3.1.0", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "73cc39cb9fca482e66108679d5d0ab43", + "name": "ipython", + "sha256": "23874ce25d1ed02b85bbd27f23bab2407fe14070e2dd750904240ce227d6913d", + "size": 1087977, + "subdir": "linux-64", + "timestamp": 1674681462183, + "version": "8.8.0" + }, + "ipython-8.9.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0", + "pygments >=2.4.0", + "python >=3.10,<3.11.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4ab9816e6c9308af729b534e5aee1032", + "name": "ipython", + "sha256": "676964fc4a6eda891ae035139f9bd5be07230c1336c63cb964c9b1b67ef03929", + "size": 1137754, + "subdir": "linux-64", + "timestamp": 1676331680829, + "version": "8.9.0" + }, + "ipython-8.9.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0", + "pygments >=2.4.0", + "python >=3.8,<3.9.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f11f40606cbdceda05483361dbbe5109", + "name": "ipython", + "sha256": "9581f498a643f9d61a6a2032400e3755df57ddfab45dd50e1171a6548fdc4c94", + "size": 1120830, + "subdir": "linux-64", + "timestamp": 1676331568643, + "version": "8.9.0" + }, + "ipython-8.9.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "backcall", + "decorator", + "jedi >=0.16", + "matplotlib-inline", + "pexpect >4.3", + "pickleshare", + "prompt-toolkit >3.0.30,<3.1.0", + "pygments >=2.4.0", + "python >=3.9,<3.10.0a0", + "stack_data", + "traitlets >=5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "037c8d44c3ada8cd5ecd9ecd7482b4e8", + "name": "ipython", + "sha256": "38dae2c4c04c0df04ca4cad36e333c102385011b1d93356a863e2d1c1b0a0545", + "size": 1119327, + "subdir": "linux-64", + "timestamp": 1676331794114, + "version": "8.9.0" + }, + "ipython-sql-0.3.9-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=1.0", + "ipython_genutils >=0.1.0", + "prettytable", + "python >=3.10,<3.11.0a0", + "six", + "sqlalchemy >=0.6.7", + "sqlparse" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6639c038f20b8d48b45b8a2bc937c1ce", + "name": "ipython-sql", + "sha256": "a8fd2061c29fc882bcd1b2841d0b9f5c1fd844e10589d611228d0ea295cab735", + "size": 30268, + "subdir": "linux-64", + "timestamp": 1672342838681, + "version": "0.3.9" + }, + "ipython-sql-0.3.9-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=1.0", + "ipython_genutils >=0.1.0", + "prettytable", + "python >=3.11,<3.12.0a0", + "six", + "sqlalchemy >=0.6.7", + "sqlparse" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1daa96a6d71cc24480f64c8d73a5ad19", + "name": "ipython-sql", + "sha256": "484048b7bbdc951a93ba10610204dc1b53bdecd7de6929b4a0ee6c0929b9fa30", + "size": 35802, + "subdir": "linux-64", + "timestamp": 1676852921259, + "version": "0.3.9" + }, + "ipython-sql-0.3.9-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=1.0", + "ipython_genutils >=0.1.0", + "prettytable", + "python >=3.7,<3.8.0a0", + "six", + "sqlalchemy >=0.6.7", + "sqlparse" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f476b3603c49e74afd3d281d0340cc9", + "name": "ipython-sql", + "sha256": "bfe1b09d236375a45a4fe7f0444f986662e5d5515349d943bd2315c619379e5c", + "size": 30109, + "subdir": "linux-64", + "timestamp": 1672342809384, + "version": "0.3.9" + }, + "ipython-sql-0.3.9-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=1.0", + "ipython_genutils >=0.1.0", + "prettytable", + "python >=3.8,<3.9.0a0", + "six", + "sqlalchemy >=0.6.7", + "sqlparse" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e2bea9099888ca1aab899640c6507f1b", + "name": "ipython-sql", + "sha256": "abeeffb3f7d72b3f60ee7e1731b3976c63cb1220724cfcbde7edaba53db66085", + "size": 30160, + "subdir": "linux-64", + "timestamp": 1672342895691, + "version": "0.3.9" + }, + "ipython-sql-0.3.9-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=1.0", + "ipython_genutils >=0.1.0", + "prettytable", + "python >=3.9,<3.10.0a0", + "six", + "sqlalchemy >=0.6.7", + "sqlparse" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "46f709241b591d83925a3bc795a60376", + "name": "ipython-sql", + "sha256": "82dc9130dff94659efe3481c151a709f318a888b35025ebb08a138d7360799c7", + "size": 30149, + "subdir": "linux-64", + "timestamp": 1672342867246, + "version": "0.3.9" + }, + "ipython_genutils-0.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "077c9eb5b60754d62c1e46f2435239ec", + "name": "ipython_genutils", + "sha256": "b14b283805973be650de2b5dbcd626e0f861d57299d04760c5aea216b9529152", + "size": 39744, + "subdir": "linux-64", + "timestamp": 1530694312457, + "version": "0.2.0" + }, + "ipython_genutils-0.2.0-py27h89fb69b_0.conda": { + "build": "py27h89fb69b_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "29ad50e471aa2d540ccba0b7208d5d3b", + "name": "ipython_genutils", + "sha256": "2db9ec0b83d6c523b8a1fc05a51a54d5dd27ed9bfd1d59ef8c18163f70d44572", + "size": 38995, + "subdir": "linux-64", + "timestamp": 1505672034041, + "version": "0.2.0" + }, + "ipython_genutils-0.2.0-py35hc9e07d0_0.conda": { + "build": "py35hc9e07d0_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2ff9f82fe6f6c40ded230a1dea93ecbb", + "name": "ipython_genutils", + "sha256": "8f20d3fe94796e26e4c01f1e212b5fc50c7d78cffe57598dfe785b2bbe5cf4b4", + "size": 39939, + "subdir": "linux-64", + "timestamp": 1505672045196, + "version": "0.2.0" + }, + "ipython_genutils-0.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "708f53ba553514e91474aac43958cfe4", + "name": "ipython_genutils", + "sha256": "47ce6d2008d1aba2ea0a5435fda158f79019d75833623a4d0aa084c98ac8068a", + "size": 40383, + "subdir": "linux-64", + "timestamp": 1530694274705, + "version": "0.2.0" + }, + "ipython_genutils-0.2.0-py36hb52b0d5_0.conda": { + "build": "py36hb52b0d5_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ebd04d058250f42171290aaf139d89df", + "name": "ipython_genutils", + "sha256": "14a14885cab4d13a7c38d3de98cc083e09bb1ede35b4eefa5d68550e36313537", + "size": 40133, + "subdir": "linux-64", + "timestamp": 1505672056487, + "version": "0.2.0" + }, + "ipython_genutils-0.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2ee762470440d89c1295952b4c598335", + "name": "ipython_genutils", + "sha256": "98dd3fb611348918718ec2e482491c1170fec1acbb69a9beb9796e896b4bd0ba", + "size": 40431, + "subdir": "linux-64", + "timestamp": 1530694294222, + "version": "0.2.0" + }, + "ipython_genutils-0.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "82996fcc5e928d5e50535d16c7eb7b08", + "name": "ipython_genutils", + "sha256": "975aef44bba6492a41948d754e5b9f0b463ed79f0637f8f3910645f02b120c87", + "size": 40585, + "subdir": "linux-64", + "timestamp": 1572437574248, + "version": "0.2.0" + }, + "ipywidgets-7.0.0-py27h4fda95d_0.conda": { + "build": "py27h4fda95d_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=3.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "abe1d339ee7412e9a2af06310566583d", + "name": "ipywidgets", + "sha256": "f7480d62fe9cf998d62d62a88c0708ad99c21889cecadbfc83f2077e79e228e8", + "size": 94407, + "subdir": "linux-64", + "timestamp": 1505690954179, + "version": "7.0.0" + }, + "ipywidgets-7.0.0-py35h8ebd919_0.conda": { + "build": "py35h8ebd919_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=3.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "400393065273a731e9de3c4b2c3713b1", + "name": "ipywidgets", + "sha256": "dd0c74643812589b60ba04f83bc8f25187697eb14d879d3de4b16511480c71fc", + "size": 94896, + "subdir": "linux-64", + "timestamp": 1505690970262, + "version": "7.0.0" + }, + "ipywidgets-7.0.0-py36h7b55c3a_0.conda": { + "build": "py36h7b55c3a_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=3.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2beefbf455fa26ec8b1f3fdbed85e88c", + "name": "ipywidgets", + "sha256": "4b94ccd0a9bf2d1c67f272fbd78ab887586a157bd73adcd42ef8aae1838cecf6", + "size": 94132, + "subdir": "linux-64", + "timestamp": 1505690986629, + "version": "7.0.0" + }, + "ipywidgets-7.0.5-py27hfb35cc2_0.conda": { + "build": "py27hfb35cc2_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=3.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6cccd28107f9f6edb47af1d3355283ff", + "name": "ipywidgets", + "sha256": "20cbd057e622a4a0d22c750bf2da1e05e4e926ff0c6c4dd57c25d5a15c6c1c29", + "size": 100279, + "subdir": "linux-64", + "timestamp": 1511288756637, + "version": "7.0.5" + }, + "ipywidgets-7.0.5-py35h8147dc1_0.conda": { + "build": "py35h8147dc1_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=3.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e870c6a31a663cbb96f34fc50a2a6dd4", + "name": "ipywidgets", + "sha256": "34c55a74a66bae6ff978d184e397739393e854a5636380ab93ef6a4b64478865", + "size": 100485, + "subdir": "linux-64", + "timestamp": 1511288768996, + "version": "7.0.5" + }, + "ipywidgets-7.0.5-py36h31d6531_0.conda": { + "build": "py36h31d6531_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=3.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "29ab47d8eddc64fe3d55dfdf58c3aad8", + "name": "ipywidgets", + "sha256": "927fbe10675c7e459ae6ec3514c91cbfb6dacfd8f7edb7f56386e9cc32f57539", + "size": 99524, + "subdir": "linux-64", + "timestamp": 1511288772204, + "version": "7.0.5" + }, + "ipywidgets-7.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=3.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2633fea23ebbd17ccc5d04da90c9a9bc", + "name": "ipywidgets", + "sha256": "4a40e7384a11605671d6c5cb70f9466179fb31b25df98053a7e184c62bfc4d9f", + "size": 100161, + "subdir": "linux-64", + "timestamp": 1515704174749, + "version": "7.1.0" + }, + "ipywidgets-7.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=3.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "78387f5578f1fc8eb9c8b3f80b101057", + "name": "ipywidgets", + "sha256": "3dcdf63dd2f1dcd41b79c7ba27749624e582107d6b467c884d28cf6904bd1ba6", + "size": 101975, + "subdir": "linux-64", + "timestamp": 1515704439260, + "version": "7.1.0" + }, + "ipywidgets-7.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=3.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c8e73907d9dc625d9fd20e476fa738a4", + "name": "ipywidgets", + "sha256": "964c2916240a05a1599c9137c7a3b06a996edec83debc63214088bf97ce97024", + "size": 99505, + "subdir": "linux-64", + "timestamp": 1515704144782, + "version": "7.1.0" + }, + "ipywidgets-7.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.1.0,<4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9e447d534d503efa9f51a6bc31af0e77", + "name": "ipywidgets", + "sha256": "a6a17009329b34fe7cae4d03b8d3095698ea3c159b6d390e9969934cb9829afa", + "size": 98531, + "subdir": "linux-64", + "timestamp": 1517329729968, + "version": "7.1.1" + }, + "ipywidgets-7.1.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.1.0,<4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8729920f061e8c27e26638cecb685c90", + "name": "ipywidgets", + "sha256": "12bce41d3cbd07b9e9ca6bc6bd2e84d3dca5c08a8524311aa2624bd244e13faf", + "size": 102075, + "subdir": "linux-64", + "timestamp": 1517329742141, + "version": "7.1.1" + }, + "ipywidgets-7.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.1.0,<4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "211cb3960326ea299b116ff144eb5bf4", + "name": "ipywidgets", + "sha256": "96f7ecac3ae376e8c292cf716e4d03d9b600c10acb9765804819eb836c69ec9a", + "size": 99478, + "subdir": "linux-64", + "timestamp": 1517329833205, + "version": "7.1.1" + }, + "ipywidgets-7.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.1.0,<4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cb75538901b4a2cd36c81e17b82ba17b", + "name": "ipywidgets", + "sha256": "594a42c764f8c89495efb56bf719aae886e50f45e8c89e53a1c27ce9ccbde10f", + "size": 98583, + "subdir": "linux-64", + "timestamp": 1519152784523, + "version": "7.1.2" + }, + "ipywidgets-7.1.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.1.0,<4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "eab911a650134bc3daa42755cec4891b", + "name": "ipywidgets", + "sha256": "2807eac56165b7be4fd7988d0e3053b18e963b83408f8abf7120ea91482d93b9", + "size": 100431, + "subdir": "linux-64", + "timestamp": 1519152800784, + "version": "7.1.2" + }, + "ipywidgets-7.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.1.0,<4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7da74b9becf333d43567df8ee54ae6b3", + "name": "ipywidgets", + "sha256": "e9e5254b2674fb4dc203472246e0a4778ec4667de3967f6edfc2ed1bec809401", + "size": 99486, + "subdir": "linux-64", + "timestamp": 1519152753893, + "version": "7.1.2" + }, + "ipywidgets-7.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.2.0,<4.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7afaebc0f75db7cc37bf5cda9264cd03", + "name": "ipywidgets", + "sha256": "e041a82a036fa7e418646a5c1fe125ffcabe9a9a8b540177cb7d3b620afa99fc", + "size": 143457, + "subdir": "linux-64", + "timestamp": 1522694865672, + "version": "7.2.0" + }, + "ipywidgets-7.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.2.0,<4.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4d24409a7ddb2e9641272dd554fe7592", + "name": "ipywidgets", + "sha256": "30f0d926336b293ae9457f4d31991c01a0b45c0ba4cd8bda8a7249883de4f142", + "size": 144032, + "subdir": "linux-64", + "timestamp": 1522695059882, + "version": "7.2.0" + }, + "ipywidgets-7.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.2.0,<4.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f96e6505017950e9ea4a978d07c78f3a", + "name": "ipywidgets", + "sha256": "8b19c366b25cdb038e8a846d4771e3a405eb9a3751fd62426bb32324523c6ec4", + "size": 144882, + "subdir": "linux-64", + "timestamp": 1522694922847, + "version": "7.2.0" + }, + "ipywidgets-7.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.2.0,<4.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "227db3348d74db322e057b72b8ac1bb1", + "name": "ipywidgets", + "sha256": "70a9c0ad8e4b926e6c24fc663a265ac1090343ccaaf824b1825caeb4fa8e403b", + "size": 143476, + "subdir": "linux-64", + "timestamp": 1523907722999, + "version": "7.2.1" + }, + "ipywidgets-7.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.2.0,<4.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f29174634af73e6df8dd4f60b1862fcb", + "name": "ipywidgets", + "sha256": "ab20030c0bdf29469c68ed1b6be3708b9b959d9c64744bdec05271cb1a0861fe", + "size": 145935, + "subdir": "linux-64", + "timestamp": 1523908337820, + "version": "7.2.1" + }, + "ipywidgets-7.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.2.0,<4.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b69f5ed55bbe3fe4d5f59bc8f9a09e5f", + "name": "ipywidgets", + "sha256": "2aea0d3e21ad8b03678085b9dc83059069d1b597c002210094e6d5f48c4ffe8a", + "size": 143058, + "subdir": "linux-64", + "timestamp": 1523907720523, + "version": "7.2.1" + }, + "ipywidgets-7.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.7,<3.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.2.0,<4.0.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "149c67da20703b6a780ecd85f5d04631", + "name": "ipywidgets", + "sha256": "7d419ee701567e542b2b3bf88e0d2d3b965abead5ce88862663f5e7a99ee84b1", + "size": 144747, + "subdir": "linux-64", + "timestamp": 1530734792962, + "version": "7.2.1" + }, + "ipywidgets-7.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.3.0,<3.4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8a0459c97218fdd995b553d73674dded", + "name": "ipywidgets", + "sha256": "d0983b9a0b0a37d72e998a123c45073fc7b7be0c771d0077e75e45e546907ffe", + "size": 145116, + "subdir": "linux-64", + "timestamp": 1532452146269, + "version": "7.3.0" + }, + "ipywidgets-7.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.3.0,<3.4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9728509a4f57734cc1d4732257a802f0", + "name": "ipywidgets", + "sha256": "0922d1fd1cedc6fdaf8c0544e6f1e1efbe980d08bb455da5e11399f36a5a5102", + "size": 149118, + "subdir": "linux-64", + "timestamp": 1532452494177, + "version": "7.3.0" + }, + "ipywidgets-7.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.3.0,<3.4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0899d1cce724bd109c0b5601fd9f8ca6", + "name": "ipywidgets", + "sha256": "00eb1c232fd242838a2754fde34900f19fa7638617da095c560b8ce98aebdbd8", + "size": 146324, + "subdir": "linux-64", + "timestamp": 1532452784490, + "version": "7.3.0" + }, + "ipywidgets-7.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.7,<3.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.3.0,<3.4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1bcd41809d7ad5d06d9d588f81a7be79", + "name": "ipywidgets", + "sha256": "02dd28b14feaacec8d84987efe948f1c0a2260c65e56c7ac0c95211430552afb", + "size": 146286, + "subdir": "linux-64", + "timestamp": 1532452864384, + "version": "7.3.0" + }, + "ipywidgets-7.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.3.0,<3.4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "91b23bd8de6151a168d375255a4457eb", + "name": "ipywidgets", + "sha256": "5a0f05fb68bf231ac8f827939e790f73d08462a2df5d313c7bbc1cbcd109a305", + "size": 145734, + "subdir": "linux-64", + "timestamp": 1532970553709, + "version": "7.3.1" + }, + "ipywidgets-7.3.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.3.0,<3.4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1ca61354d35403e5879c96b3702a406c", + "name": "ipywidgets", + "sha256": "45b6dfbbb30492f09aa30b55a70f424e348f8a5990ca3be81083835c328d153f", + "size": 147710, + "subdir": "linux-64", + "timestamp": 1532970615177, + "version": "7.3.1" + }, + "ipywidgets-7.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.3.0,<3.4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b3a22e7473628f2a575559f693ee6be1", + "name": "ipywidgets", + "sha256": "82040c330d160e2e4fd9b486bb5f8a323b0f069cace9d7b23373fb150d15d1e1", + "size": 148308, + "subdir": "linux-64", + "timestamp": 1532970469582, + "version": "7.3.1" + }, + "ipywidgets-7.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.7,<3.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.3.0,<3.4.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "be813fe4e37c82d57120b6ccf4b3b483", + "name": "ipywidgets", + "sha256": "fe887f2c3306cd46bbda8996a97a1fe2edbc0007e547e01d46d1f50d874ee553", + "size": 148578, + "subdir": "linux-64", + "timestamp": 1532970578281, + "version": "7.3.1" + }, + "ipywidgets-7.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cd8bbe8550e7ae8b837f650395917015", + "name": "ipywidgets", + "sha256": "7f9c9c8369f6598363d688ca5e451688ebe4f81dfad3f114c0ec7b63bfe47de3", + "size": 144958, + "subdir": "linux-64", + "timestamp": 1533743200121, + "version": "7.4.0" + }, + "ipywidgets-7.4.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "34cd61491d1f27377df80905a2d4a0c2", + "name": "ipywidgets", + "sha256": "02c701edb393c830d9c0935ac79035cdcccae67c97c797ef884a1b47595d3638", + "size": 149222, + "subdir": "linux-64", + "timestamp": 1534351422043, + "version": "7.4.0" + }, + "ipywidgets-7.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c71cd5835d00f0195d215015e755fdc3", + "name": "ipywidgets", + "sha256": "7444479840f79204a90e1099ccbd23e5ef031c47d5f87b7f04b769105b5760a9", + "size": 147121, + "subdir": "linux-64", + "timestamp": 1533743754904, + "version": "7.4.0" + }, + "ipywidgets-7.4.0-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f1837a3dc12317625c9140a41fafa1a1", + "name": "ipywidgets", + "sha256": "11c237578c013c8a4c99245ac2e7f733e111f1a1a0d09201f76001ac853740fe", + "size": 151907, + "subdir": "linux-64", + "timestamp": 1534351464492, + "version": "7.4.0" + }, + "ipywidgets-7.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "01be04181d234c688ce86493855f6a27", + "name": "ipywidgets", + "sha256": "22eb60a909cb2a7410e43e76afbecb049394076b20833267b9ec92763f73c132", + "size": 146154, + "subdir": "linux-64", + "timestamp": 1533743207071, + "version": "7.4.0" + }, + "ipywidgets-7.4.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c8b8f32d62a4a3bd5dd8a986544ced7b", + "name": "ipywidgets", + "sha256": "d65c3dcb6f6166ad115cddf81392ba01d9a356a54d12a18dfe97baa78c523df2", + "size": 149062, + "subdir": "linux-64", + "timestamp": 1534351509863, + "version": "7.4.0" + }, + "ipywidgets-7.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.7,<3.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6d7e37c1bedcffc21adce7576c3c9718", + "name": "ipywidgets", + "sha256": "f26dea552fdf13b02dba5853fea5afac17f1bf6676b487c0ef1f93de9ae7fd68", + "size": 146069, + "subdir": "linux-64", + "timestamp": 1533743303993, + "version": "7.4.0" + }, + "ipywidgets-7.4.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.7,<3.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e48b74a581a73b3244fe9493960a3859", + "name": "ipywidgets", + "sha256": "db00428a92a4bc6b7c6188924147b2e494d3ca3d33bf5ce13ff8e33407708c69", + "size": 149018, + "subdir": "linux-64", + "timestamp": 1534351383908, + "version": "7.4.0" + }, + "ipywidgets-7.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6ca6157387b4da6830a468c27d898c51", + "name": "ipywidgets", + "sha256": "3b0bb9103ae6eb2583abec4710423d7a0a50988bd33ba2ab16d1eee895633577", + "size": 145356, + "subdir": "linux-64", + "timestamp": 1536074929997, + "version": "7.4.1" + }, + "ipywidgets-7.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.5,<3.6.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "28c9f4b59784b600fbbbd4ec1ec44406", + "name": "ipywidgets", + "sha256": "220ee88a7f6f38f46d4a42187d31238d2d4cf55d123c939e7f76f185e8d764d1", + "size": 149539, + "subdir": "linux-64", + "timestamp": 1536074922151, + "version": "7.4.1" + }, + "ipywidgets-7.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "83cdc675d6d09cdd80816210607f6b53", + "name": "ipywidgets", + "sha256": "1a7f1217c2970f71bb6a2187a051e484c7a61a8f8db6fede792dc5083d53ccd9", + "size": 148491, + "subdir": "linux-64", + "timestamp": 1536074927237, + "version": "7.4.1" + }, + "ipywidgets-7.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.7,<3.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "60b215df24f1909e96f5cb145ff9f7e6", + "name": "ipywidgets", + "sha256": "44aa6ca4224665c350fbc10714ef46f1733f965004217f1b380033f363e5cd3d", + "size": 146596, + "subdir": "linux-64", + "timestamp": 1536074956515, + "version": "7.4.1" + }, + "ipywidgets-7.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=2.7,<2.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2e557be2704643f61cbf4d0d9f89d541", + "name": "ipywidgets", + "sha256": "b88da1d64b215f12f1f6c40c9f023a6d080b7b8bfca4a91707344e8681740f4c", + "size": 148706, + "subdir": "linux-64", + "timestamp": 1538158579676, + "version": "7.4.2" + }, + "ipywidgets-7.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.6,<3.7.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e1f1f80572f77286d8f1c539b64d47e8", + "name": "ipywidgets", + "sha256": "3f383792cff289b736bdeccb96c98b9ea1d0a29fbaa56f29edb6dfbc70d3e3d0", + "size": 151627, + "subdir": "linux-64", + "timestamp": 1538158648009, + "version": "7.4.2" + }, + "ipywidgets-7.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=4.0.0", + "nbformat >=4.2.0", + "python >=3.7,<3.8.0a0", + "traitlets >=4.3.1,<5.0.0", + "widgetsnbextension >=3.4.0,<3.5.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e7c9f3daa27c260ec367af7de0c72931", + "name": "ipywidgets", + "sha256": "4080c8ecab23b03f25bc5679847c60cf86b2ca7e947a66a428ca4abb9f482c24", + "size": 149922, + "subdir": "linux-64", + "timestamp": 1538158606399, + "version": "7.4.2" + }, + "ipywidgets-8.0.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=6.1.0", + "jupyterlab_widgets >=3.0.4,<4.0.0", + "python >=3.10,<3.11.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=4.0.4,<5.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b9c6707e32d0a3d9d2d146ea9c178ac3", + "name": "ipywidgets", + "sha256": "502073268209d33f41d84d41af44c02247324fc8922a4f7adf921f29934b8064", + "size": 201434, + "subdir": "linux-64", + "timestamp": 1679394901804, + "version": "8.0.4" + }, + "ipywidgets-8.0.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=6.1.0", + "jupyterlab_widgets >=3.0.4,<4.0.0", + "python >=3.11,<3.12.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=4.0.4,<5.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6047cd8364b070f9a5836c41e0336e04", + "name": "ipywidgets", + "sha256": "98b8294c40d64d6869203b8cd9ea86902c3586b2c817e9142d5aa3423e2de025", + "size": 254824, + "subdir": "linux-64", + "timestamp": 1679394936739, + "version": "8.0.4" + }, + "ipywidgets-8.0.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=6.1.0", + "jupyterlab_widgets >=3.0.4,<4.0.0", + "python >=3.8,<3.9.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=4.0.4,<5.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "237f73ed7b0e4fde514c025e13588905", + "name": "ipywidgets", + "sha256": "3a98c683186dd6f4ee56088187ad33db31f0762b2901dbbe9b3f69c120b289df", + "size": 199131, + "subdir": "linux-64", + "timestamp": 1679394865401, + "version": "8.0.4" + }, + "ipywidgets-8.0.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.5.1", + "ipython >=6.1.0", + "jupyterlab_widgets >=3.0.4,<4.0.0", + "python >=3.9,<3.10.0a0", + "traitlets >=4.3.1", + "widgetsnbextension >=4.0.4,<5.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e2442ff8ccad9ef983d3489f8acab493", + "name": "ipywidgets", + "sha256": "abe6953da3958fb1645bb657ecac7f378e81350258184f59cdfa8f8e1bcc4073", + "size": 199720, + "subdir": "linux-64", + "timestamp": 1679394829252, + "version": "8.0.4" + }, + "isl-0.12.2-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "gmp" + ], + "license": "MIT", + "md5": "f2cb627fd0bd8b996daa8133edba1903", + "name": "isl", + "sha256": "6e6b497b3a4a8c1e28a5bdfe2f88ee4754ff78f967d625f15eccd6b2487ec076", + "size": 939108, + "version": "0.12.2" + }, + "isl-0.22.1-h295c915_3.conda": { + "build": "h295c915_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5a12f75c44a53c72a4f6aa53b3f126a4", + "name": "isl", + "sha256": "005c0da4430d917f5df45d97f92b00214e31f6f2084d0316e015207511a8121e", + "size": 867083, + "subdir": "linux-64", + "timestamp": 1646827138055, + "version": "0.22.1" + }, + "iso8601-0.1.12-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ed20d8d69408838e8df9c99935b82e3a", + "name": "iso8601", + "sha256": "6a662b54160d3a8e0d8f5320cd82970512a2cbb7e7ba877be23aa1f3f2a08a1e", + "size": 14855, + "subdir": "linux-64", + "timestamp": 1530733069005, + "version": "0.1.12" + }, + "iso8601-0.1.12-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "cd9f482b489b99e09b16d14274f06c64", + "name": "iso8601", + "sha256": "89c9df30fe5ae7c3d83fe31109b187597e4f219df44a31fde399c5da8922b4a5", + "size": 14908, + "subdir": "linux-64", + "timestamp": 1535126122103, + "version": "0.1.12" + }, + "iso8601-0.1.12-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "727b32244e196fa9102be7c8e1558319", + "name": "iso8601", + "sha256": "206a117065b240ed02f7e2899fe2dda3536bb076e81e415d58e3159ed6997ae5", + "size": 15023, + "subdir": "linux-64", + "timestamp": 1535126129734, + "version": "0.1.12" + }, + "iso8601-0.1.12-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "07360df94df10144cc8ebf76843f49a5", + "name": "iso8601", + "sha256": "5093ab9a70c071cc12cf8cf91d3ff5b56f3daec694bdfffd75d5a859f306c55d", + "size": 14719, + "subdir": "linux-64", + "timestamp": 1530733049433, + "version": "0.1.12" + }, + "iso8601-0.1.12-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f05e0d90b0ca2d7013f94f29515b4e9e", + "name": "iso8601", + "sha256": "6c86f44dd96e61ade4c0fd13f8d96999d8fb45e078cf827de897b0791a2a0259", + "size": 14876, + "subdir": "linux-64", + "timestamp": 1535125912782, + "version": "0.1.12" + }, + "iso8601-0.1.12-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c5f2fb817d604f2db3be904c7ab116ee", + "name": "iso8601", + "sha256": "cc4113dd09b5c6b507cabc1231d6819a15b19b29e02394c13d63ce925c0c6ede", + "size": 16264, + "subdir": "linux-64", + "timestamp": 1605213729849, + "version": "0.1.12" + }, + "iso8601-0.1.12-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b1dc400d1ad8d4f83c067adeaab85029", + "name": "iso8601", + "sha256": "6c57cd8a425dc95fe63a2ed65b8d604ce2b052307f1755cbd65cf95d20dc37a5", + "size": 14703, + "subdir": "linux-64", + "timestamp": 1530733088629, + "version": "0.1.12" + }, + "iso8601-0.1.12-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b3f244e01dea1c896744a11d8ac49787", + "name": "iso8601", + "sha256": "23f5fdc4be33f786b5f3af542dd10885bc5e354142d3ff7704539ad3b807b91c", + "size": 14773, + "subdir": "linux-64", + "timestamp": 1535125999079, + "version": "0.1.12" + }, + "iso8601-0.1.12-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "81b35b194bbe539630ae4192833ff3d2", + "name": "iso8601", + "sha256": "a6b6b4ff39a570e09162beeccb47e0236bf13d4698530c18353efaa65868b8f5", + "size": 16142, + "subdir": "linux-64", + "timestamp": 1605213713753, + "version": "0.1.12" + }, + "iso8601-0.1.12-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "8109915671f9714109f8ec706cd6216e", + "name": "iso8601", + "sha256": "e0d81aa1d116e914b6ac897daa3f04a5dd20f4d34f0e1c1e5d008fea54cc6dfd", + "size": 15236, + "subdir": "linux-64", + "timestamp": 1572437621791, + "version": "0.1.12" + }, + "iso8601-0.1.12-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "133386a906d97612663cf17d7678682d", + "name": "iso8601", + "sha256": "424c1bcc74df8c5eaa4111f7b6bde125d555ec0bbd7992f75e91d5c487a684cd", + "size": 16240, + "subdir": "linux-64", + "timestamp": 1605213721250, + "version": "0.1.12" + }, + "iso8601-0.1.12-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "882cf87d09b2931fe0a5f433e920bb0d", + "name": "iso8601", + "sha256": "5b6b0501ce6837ffc4eeb5698fbb9519b434e2c609d34ccc8ee96b7e54af89a3", + "size": 16113, + "subdir": "linux-64", + "timestamp": 1605213695003, + "version": "0.1.12" + }, + "iso8601-0.1.13-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e3e092cddcd1bd27e5d77687915720ca", + "name": "iso8601", + "sha256": "5011e9d5af98744eb8e135d37fbb0ec28421541f77d0be22b6172ddf3685870c", + "size": 15279, + "subdir": "linux-64", + "timestamp": 1600379569044, + "version": "0.1.13" + }, + "iso8601-0.1.13-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "29a5a2086792a8a689c27413b0010585", + "name": "iso8601", + "sha256": "dbe6a380f6739d0b8767ed00b8bdf8f7f5c3c447f8a2bd0d74dd88564ba6276e", + "size": 15263, + "subdir": "linux-64", + "timestamp": 1600379566702, + "version": "0.1.13" + }, + "iso8601-0.1.13-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "6b600cc07e6bbdfeddc27dfbddf2bff3", + "name": "iso8601", + "sha256": "e4638576fe5fc1038472107c2d79ab98befb8c9ff77845b08540fd3da4f9dbe4", + "size": 15274, + "subdir": "linux-64", + "timestamp": 1600379586609, + "version": "0.1.13" + }, + "iso8601-0.1.14-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ae4614ccbf99761a8fb8b9c58985bd5b", + "name": "iso8601", + "sha256": "e5704c2163ed43b8657e5e5a9b859f6fe41704a69f65fbc35c17569484a719aa", + "size": 15559, + "subdir": "linux-64", + "timestamp": 1613502215658, + "version": "0.1.14" + }, + "iso8601-0.1.14-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b389646468c8931825c03716fb74434c", + "name": "iso8601", + "sha256": "ed07eaed31e678a6c7d01a100d9eb3fd3e6bff9c46a29c6b351a52ef334e6ae0", + "size": 15460, + "subdir": "linux-64", + "timestamp": 1613502217695, + "version": "0.1.14" + }, + "iso8601-0.1.14-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "51174b7291552a296b31bae2da028e21", + "name": "iso8601", + "sha256": "92f5da4d866716a1427d1f4e53b0ca75ba44453e445cd349815fa6e151057c05", + "size": 15575, + "subdir": "linux-64", + "timestamp": 1613502217258, + "version": "0.1.14" + }, + "iso8601-0.1.14-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "7c1abb4167298f08d121216a94757ed4", + "name": "iso8601", + "sha256": "094b523154a9c41a556ff654b2069a7394b508aeb5589f07f74644861cfe7465", + "size": 15405, + "subdir": "linux-64", + "timestamp": 1613501576700, + "version": "0.1.14" + }, + "iso8601-0.1.16-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4d3ecc7e6411bfc0e2a3a548dd52e87", + "name": "iso8601", + "sha256": "a1950b60bb592c396923602c154684fbafc34bf773824603b4ba746bc6c54ddb", + "size": 16436, + "subdir": "linux-64", + "timestamp": 1626702135050, + "version": "0.1.16" + }, + "iso8601-0.1.16-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01deb87ecd3d8f936978c69a2cf3025c", + "name": "iso8601", + "sha256": "238d018da32a0d704a88ca6fb75328f02558d570d160095f4644a15709fb2ea3", + "size": 16516, + "subdir": "linux-64", + "timestamp": 1626694819602, + "version": "0.1.16" + }, + "iso8601-0.1.16-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea34da956b03369c74fff0a552e6ea6a", + "name": "iso8601", + "sha256": "6accbea2254bb973aea858ec183b89e66b6c2f2a1ac0594b6bc79545928059b2", + "size": 16479, + "subdir": "linux-64", + "timestamp": 1626702055242, + "version": "0.1.16" + }, + "iso8601-0.1.16-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1292445419222694346238dd212cb8f8", + "name": "iso8601", + "sha256": "1e7cf5e1877321135eb37adae20f17e17fc241f15abf575c5b0ffd2093745201", + "size": 16492, + "subdir": "linux-64", + "timestamp": 1626702133908, + "version": "0.1.16" + }, + "isodate-0.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "593b9a8ab82bd4ddcfc44a18e90830e3", + "name": "isodate", + "sha256": "702ad89b95750e75635d754c4bdbc431ccac68384af790c15e43cfbc347a8a34", + "size": 45266, + "subdir": "linux-64", + "timestamp": 1530735719545, + "version": "0.6.0" + }, + "isodate-0.6.0-py27hf5b12f5_0.conda": { + "build": "py27hf5b12f5_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "8fcabf00a69d61703019d352095893c2", + "name": "isodate", + "sha256": "bcd07a1e984a841a23d3d3647db8c143e5e84ad80e426aa9714247d269489af5", + "size": 45562, + "subdir": "linux-64", + "timestamp": 1508620696791, + "version": "0.6.0" + }, + "isodate-0.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "e5dd26b00d92fad639a0f5f6767857fd", + "name": "isodate", + "sha256": "2ef52b52fe0db74e2b27f283e74a8683f53c7df8f74b4f966e833a8bca4d2b54", + "size": 46029, + "subdir": "linux-64", + "timestamp": 1534352042771, + "version": "0.6.0" + }, + "isodate-0.6.0-py35h6a86938_0.conda": { + "build": "py35h6a86938_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "0be5fe4c2a523ddbfe45c170eef95627", + "name": "isodate", + "sha256": "4f246c254f5c286d1bd3912a3d7c394c36d32e2ab76258eb3f2fdc13632255e0", + "size": 46342, + "subdir": "linux-64", + "timestamp": 1508620683489, + "version": "0.6.0" + }, + "isodate-0.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "2531f17829d0d050fe8d44e0ce865bf5", + "name": "isodate", + "sha256": "4c94de9efffd8f2d7040688a2a1dfa84e6511f8485c58602b0152c4a3ccc58eb", + "size": 44683, + "subdir": "linux-64", + "timestamp": 1530735698818, + "version": "0.6.0" + }, + "isodate-0.6.0-py36h3a1d279_0.conda": { + "build": "py36h3a1d279_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "4c103cc360b47593e0050b3db72bcd39", + "name": "isodate", + "sha256": "62d2c49c47e0e98096c8426d6b57084674160b6f9ef59b0753b4409290286bda", + "size": 44935, + "subdir": "linux-64", + "timestamp": 1508620730136, + "version": "0.6.0" + }, + "isodate-0.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "12a1470b27d007890b70947f0d95c7b2", + "name": "isodate", + "sha256": "1e7ce7cc27a2d08c104b1ed19b30a10cad4f1f6ac4e60c78b10ff6c7903f0c4f", + "size": 45504, + "subdir": "linux-64", + "timestamp": 1530735740946, + "version": "0.6.0" + }, + "isort-4.2.15-py27hcfa4749_0.conda": { + "build": "py27hcfa4749_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "9c89aadf6faafd75c3e009dd396e5083", + "name": "isort", + "sha256": "46cbe87c7a5d958c29190623a39fd0ee4460a16cf4b3d54de60d746d0d791cc2", + "size": 59775, + "subdir": "linux-64", + "timestamp": 1505744628252, + "version": "4.2.15" + }, + "isort-4.2.15-py35h44a00d2_0.conda": { + "build": "py35h44a00d2_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "bff1ef31b9b6fe6644a755f3914c012b", + "name": "isort", + "sha256": "984e3e51c4b447a473f06de9702f6f074e649ccb3f34a6af589887e1dcb54dc0", + "size": 60537, + "subdir": "linux-64", + "timestamp": 1505744641942, + "version": "4.2.15" + }, + "isort-4.2.15-py36had401c0_0.conda": { + "build": "py36had401c0_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "bbc57dba4191824121fb7af42f54ef41", + "name": "isort", + "sha256": "444f7fd041700a226099dda8c8a7b56897c6e4fb5a5d8793a0ecd64bd128dadb", + "size": 58828, + "subdir": "linux-64", + "timestamp": 1505744655582, + "version": "4.2.15" + }, + "isort-4.3.15-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "futures", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "9f14562f54b0594a4ffb1561fba50c77", + "name": "isort", + "sha256": "dfea0e715d89f9ce0205095fa229ba3720937159dbdc08f68989cc4909d21398", + "size": 69839, + "subdir": "linux-64", + "timestamp": 1552332165092, + "version": "4.3.15" + }, + "isort-4.3.15-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "c2a13bf2702661245f524975d010482e", + "name": "isort", + "sha256": "79e5ddb8ed78ddc18da551169bff1dfa66793a4ce824b707fe6f36ef05587fa5", + "size": 69626, + "subdir": "linux-64", + "timestamp": 1552332197001, + "version": "4.3.15" + }, + "isort-4.3.15-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "f44d8dabaa337b47dc66e66df264c2f0", + "name": "isort", + "sha256": "211f69a0312daf62c87dd87daf7b0c5e8a5abbd0797aad9352ca109af5bb3ed5", + "size": 68672, + "subdir": "linux-64", + "timestamp": 1552332091910, + "version": "4.3.15" + }, + "isort-4.3.16-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "futures", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "350de63570c716fa944562408fca1155", + "name": "isort", + "sha256": "ffa5788ffa61c8620699c963a99d76fe0c24c3b7abc8bbdc27c91d71b7db1fa0", + "size": 69533, + "subdir": "linux-64", + "timestamp": 1553525057080, + "version": "4.3.16" + }, + "isort-4.3.16-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "bb79111d2b402315d21c3dfbf272e1f8", + "name": "isort", + "sha256": "7b8adaa06bcc4674526083f62fbcbe05ad615f4679fb33226bd7e864c6ff3d35", + "size": 68954, + "subdir": "linux-64", + "timestamp": 1553525005490, + "version": "4.3.16" + }, + "isort-4.3.16-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "a7ee4fe4f1c070b2f8c205d1465270f2", + "name": "isort", + "sha256": "188e1a25007ffbda942a042c845931327652d3399e519ab62529f097554ad9a8", + "size": 69382, + "subdir": "linux-64", + "timestamp": 1553525028445, + "version": "4.3.16" + }, + "isort-4.3.17-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "futures", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "0ac4b7d6ff6f4766fd82b72208c458c3", + "name": "isort", + "sha256": "0fe1f0d0a662a3b1aaab501f80afac80a0a08decd67be61d51bc79d63b9e023b", + "size": 70161, + "subdir": "linux-64", + "timestamp": 1555430965266, + "version": "4.3.17" + }, + "isort-4.3.17-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "cf7a6955c8db22379f299fa5092057c3", + "name": "isort", + "sha256": "9907d7181cb33f5a14b40535e2cd01610808187b3d88bd9e96637a04fda7d32d", + "size": 69840, + "subdir": "linux-64", + "timestamp": 1555430976644, + "version": "4.3.17" + }, + "isort-4.3.17-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "6905cf9c2d4a550db697c5fea8e262e3", + "name": "isort", + "sha256": "2f1b01fba0e8f282e118dd59e3eaed2dd0fcaa8e4a5e4147758adb96ab1b7ef1", + "size": 69042, + "subdir": "linux-64", + "timestamp": 1555430951300, + "version": "4.3.17" + }, + "isort-4.3.18-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "futures", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "a8c4effdd3bd27b20d0bc3fd0346bccf", + "name": "isort", + "sha256": "49f0bd2a8ac5aca2957100c8a21d94ac9171098514b5d6fc687da03a17e8c44f", + "size": 70419, + "subdir": "linux-64", + "timestamp": 1557505719630, + "version": "4.3.18" + }, + "isort-4.3.18-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "1d6f71827aded5e363f9cfa8ff2c6b6a", + "name": "isort", + "sha256": "a7978a24c30bd5d502cf65c16879ccba2a2ec022efa56779799f99f64bac9abd", + "size": 69929, + "subdir": "linux-64", + "timestamp": 1557505747704, + "version": "4.3.18" + }, + "isort-4.3.18-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "3051b55e37d0cbe4f523885b012b9e57", + "name": "isort", + "sha256": "17291a3fbcbfda4f450fde544e90bd30b847bcb31e6b5bfe749f3092a86622c3", + "size": 69671, + "subdir": "linux-64", + "timestamp": 1557505709201, + "version": "4.3.18" + }, + "isort-4.3.19-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "futures", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "5df5626364dac24bbc5d3177d7c30dcb", + "name": "isort", + "sha256": "8557e3b9c8e128312a87021bf4825294d25672665cf5e0ca84a4781bd653500f", + "size": 70319, + "subdir": "linux-64", + "timestamp": 1557855800039, + "version": "4.3.19" + }, + "isort-4.3.19-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "4dba7ec6831f9310f3aea848d69f4501", + "name": "isort", + "sha256": "98b865453318f1ccdc52b4b6708031f313042eda8febee9140228aa48ba62940", + "size": 70459, + "subdir": "linux-64", + "timestamp": 1557855853291, + "version": "4.3.19" + }, + "isort-4.3.19-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "4294e0ba5413b1f5dbe8565a3621dade", + "name": "isort", + "sha256": "44339f59bd26d9d7ef9698e5f81cd2a5b37f7c7b31b304873b8a032cdc1e61ba", + "size": 70034, + "subdir": "linux-64", + "timestamp": 1557855792852, + "version": "4.3.19" + }, + "isort-4.3.20-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "futures", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "48ab9e2f74c0effea18e93d7aec33395", + "name": "isort", + "sha256": "1044b7ca4f4c640f31679cad877c3ca02a6542de73d9d3804e2dc9f613eac0bb", + "size": 70607, + "subdir": "linux-64", + "timestamp": 1559772926344, + "version": "4.3.20" + }, + "isort-4.3.20-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "4c51692219361a66c127bdd03a484785", + "name": "isort", + "sha256": "51ac8a41441ac47621045bcce5290952b2f4e0da3f0a42ab1f97cb36fd6c8016", + "size": 70507, + "subdir": "linux-64", + "timestamp": 1559773054508, + "version": "4.3.20" + }, + "isort-4.3.20-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "1e543688787c8150b5df0109cf3fba2d", + "name": "isort", + "sha256": "574a0390f7df59d0ef47fd8012829040288f85dfa1f69dcdc83a7d6747a315f5", + "size": 70087, + "subdir": "linux-64", + "timestamp": 1559772906478, + "version": "4.3.20" + }, + "isort-4.3.21-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "futures", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "578e099e35d83d346f823de01a9f8620", + "name": "isort", + "sha256": "d79c3afa542d38112c47bc15eddb6ef7c3c261e72b681b2fee6e653e6e625fbc", + "size": 70768, + "subdir": "linux-64", + "timestamp": 1562085504919, + "version": "4.3.21" + }, + "isort-4.3.21-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "075aea6a6d653068d8c426154a354cd7", + "name": "isort", + "sha256": "c1342ffa6d5c85419491c11019d64887fa2d95f7760b94bff4fc726fb8ea1cc7", + "size": 70460, + "subdir": "linux-64", + "timestamp": 1562085542403, + "version": "4.3.21" + }, + "isort-4.3.21-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "b38c85725d34f3843160166706c97962", + "name": "isort", + "sha256": "dfb23b39fa80e5e9b71f9b5f1805e07efe5b1f253698772f88e3cd2f464e61ad", + "size": 70350, + "subdir": "linux-64", + "timestamp": 1562085540235, + "version": "4.3.21" + }, + "isort-4.3.21-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "66cd54102b67e907fc74b7893e53950c", + "name": "isort", + "sha256": "46117bb157db077a2b66542cf3edede3ada47c610a17fec302e90d06dc393822", + "size": 66304, + "subdir": "linux-64", + "timestamp": 1574157987422, + "version": "4.3.21" + }, + "isort-4.3.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "0253ed65756e9ff85b0989fd05b64bbe", + "name": "isort", + "sha256": "a044ce8ae7c88b2335298ad26dc654cf0cf7c82f5876a6a68caa9ee031143833", + "size": 60729, + "subdir": "linux-64", + "timestamp": 1519152646289, + "version": "4.3.4" + }, + "isort-4.3.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "12e7a336f929da75f597d5d8c5c5541f", + "name": "isort", + "sha256": "90efd5b7b5990feeb8b69591e51f021aaeaf6239ad9553c313c80a9c42fe1c14", + "size": 61155, + "subdir": "linux-64", + "timestamp": 1519152646931, + "version": "4.3.4" + }, + "isort-4.3.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "5a415e4c4d49ade7c0fb0992d9709edc", + "name": "isort", + "sha256": "e6ca603c9381ccd9c526f661422a6c132af43fa2eac615b3e2a27e0c431516e5", + "size": 61270, + "subdir": "linux-64", + "timestamp": 1519152572471, + "version": "4.3.4" + }, + "isort-4.3.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "f6c0e5de2503dd609bb4ff3fdea481a7", + "name": "isort", + "sha256": "1793b30710ab661b32f7383d54ef85a413d73c2669cab6fce4b61ace4a7dca01", + "size": 60662, + "subdir": "linux-64", + "timestamp": 1530897913208, + "version": "4.3.4" + }, + "isort-4.3.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "f4d9156b8b0a4c04b6205758c15ceb14", + "name": "isort", + "sha256": "8ea5c87ff508517133dc9a35534e9af7cdd6d6a6a715998ec4ed5c2fee722614", + "size": 65029, + "subdir": "linux-64", + "timestamp": 1551139857556, + "version": "4.3.8" + }, + "isort-4.3.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "d1730c775ca67a484c4cb7eb5138ece2", + "name": "isort", + "sha256": "1468a1dbc35439ce2bd39605fd8fe4d5e73124307f6deb3da4d7bd683c9584ff", + "size": 64350, + "subdir": "linux-64", + "timestamp": 1551139877828, + "version": "4.3.8" + }, + "isort-4.3.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "9703c1bdce67104d4da03f83bdcf24c4", + "name": "isort", + "sha256": "3358992b6720328d61e62eb8540585fad147732826819e0fef9affdbcc3349e1", + "size": 64702, + "subdir": "linux-64", + "timestamp": 1551139836425, + "version": "4.3.8" + }, + "isort-5.0.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "f6a18493bcfca401f9b9185c0f785f0c", + "name": "isort", + "sha256": "d1444be580e5f485005ec45197477316302c81ee99c2a073acdefa927fe62664", + "size": 139432, + "subdir": "linux-64", + "timestamp": 1594747370756, + "version": "5.0.9" + }, + "isort-5.0.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "e8e544365fdf0e57a202ba19c6c2eaad", + "name": "isort", + "sha256": "38c98cc7cc341bf0b68b27304200dd889a174af6128d357417749d158c4c65c5", + "size": 138734, + "subdir": "linux-64", + "timestamp": 1594747347283, + "version": "5.0.9" + }, + "isort-5.0.9-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "3c1ff296737e6a3ec243e154f2010692", + "name": "isort", + "sha256": "47d5dc6141a91319f7c94f13ad2782929af44f1ddf0e7989ec03a11a3c36d4b2", + "size": 139879, + "subdir": "linux-64", + "timestamp": 1594851245432, + "version": "5.0.9" + }, + "isort-5.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "545551c2f20f06f53db685e7d067c056", + "name": "isort", + "sha256": "63b4d0fe739d4d89dbfcd8ec52e8bc0f03aa2b33244fea2e261201c0327d0b31", + "size": 145216, + "subdir": "linux-64", + "timestamp": 1596472834478, + "version": "5.2.2" + }, + "isort-5.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "3e144814d5df986cee1a90bbcdea6513", + "name": "isort", + "sha256": "d70a8f76b32cc62df6457dccbad3c84d1e0582b6f4576621dc17a626da2a7170", + "size": 145958, + "subdir": "linux-64", + "timestamp": 1596472854356, + "version": "5.2.2" + }, + "isort-5.2.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "6ffff632f8ae117f9b0ac198ac1d6357", + "name": "isort", + "sha256": "dcdbc4bde108e16c4d5c71a4fd42b5e5dcf4868e6e4c119baa82f87f4e51eb6e", + "size": 145646, + "subdir": "linux-64", + "timestamp": 1596472870493, + "version": "5.2.2" + }, + "isort-5.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "ea252ef8861ebd91900ec38d008b909a", + "name": "isort", + "sha256": "6e053f91cb327a558aabeffb56a9b690ecf7f75fd5d9d855ce6605a843abcf7f", + "size": 151349, + "subdir": "linux-64", + "timestamp": 1601750471788, + "version": "5.3.2" + }, + "isort-5.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "cdb57ab976455c092b95199cbbe31f76", + "name": "isort", + "sha256": "34bede6493a828eaaf3a628265f059a424c70e390c5bd0d348dc0fb6fb5feb05", + "size": 145346, + "subdir": "linux-64", + "timestamp": 1596868939877, + "version": "5.3.2" + }, + "isort-5.3.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "e54425311d52ffb53bb443f7d7b89f82", + "name": "isort", + "sha256": "2fc82afa214faf8e5c2e91c21989fbbe79e12d6702401deae61e56fcbb076b63", + "size": 151431, + "subdir": "linux-64", + "timestamp": 1601750516287, + "version": "5.3.2" + }, + "isort-5.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "2f79a49a4b59fe6612b20a53aefc5a57", + "name": "isort", + "sha256": "3ba51c157e80a67702d947658542b592d796262f78fa672c21e066272d8e27df", + "size": 151626, + "subdir": "linux-64", + "timestamp": 1601749738514, + "version": "5.4.1" + }, + "isort-5.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "790769497aa09a412160bf298db749ac", + "name": "isort", + "sha256": "fd75210040b4e8810f70e615ec2b4c3cd4aa037ffc5029e291d074b01470eb14", + "size": 144717, + "subdir": "linux-64", + "timestamp": 1597337619604, + "version": "5.4.1" + }, + "isort-5.4.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "cc99199999f590a5c9c9e53c63f33319", + "name": "isort", + "sha256": "c11db84979c55f4fe9d71cb6ff5c05d234d8e755c3c2026e819153aea313e5a4", + "size": 152133, + "subdir": "linux-64", + "timestamp": 1601749721984, + "version": "5.4.1" + }, + "isort-5.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "c4e2c650620aba82a8006ea033d3474f", + "name": "isort", + "sha256": "34c53beb07a14d2ed8d9c6a2188879351eccae3cde82fce56ea81cb192a26e68", + "size": 153023, + "subdir": "linux-64", + "timestamp": 1598376251679, + "version": "5.4.2" + }, + "isort-5.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "54b53d08b208863def7ca40af4f35a44", + "name": "isort", + "sha256": "4b8dcda363bebb95f9c13143310768ed93188589db50c103e797a386f5f4543f", + "size": 146048, + "subdir": "linux-64", + "timestamp": 1597597621739, + "version": "5.4.2" + }, + "isort-5.4.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "9fa30088e6c82df6e62e785a23f34178", + "name": "isort", + "sha256": "e56f9833bed67bb17591b0afc98cdb1e1215e5e3c66af056d82c59a45994d176", + "size": 154021, + "subdir": "linux-64", + "timestamp": 1598376233810, + "version": "5.4.2" + }, + "isort-5.5.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "05c9515e11ed134095fdfe4dda78fb6d", + "name": "isort", + "sha256": "4e7bc636c355a77fafaf66c67d761f959860ed0a8f16a2bffe0f332c4ac3a288", + "size": 155750, + "subdir": "linux-64", + "timestamp": 1600485493604, + "version": "5.5.2" + }, + "isort-5.5.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "49d881d91cf51418662c84170d02286c", + "name": "isort", + "sha256": "52dda66e7bccf54856c24df851d58ca87542a5cd915d577024d63d15e73b55f2", + "size": 155862, + "subdir": "linux-64", + "timestamp": 1600480687403, + "version": "5.5.2" + }, + "isort-5.5.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "82723d406787d9391ce0c5bfb8e3cb49", + "name": "isort", + "sha256": "0272ff298c52fc3ecfdfa0c7c89ba036f31e93568f9cd326d549771240dc2473", + "size": 156425, + "subdir": "linux-64", + "timestamp": 1600480672098, + "version": "5.5.2" + }, + "isort-5.5.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "004ae355f1d416cea6191cbd4ddf1344", + "name": "isort", + "sha256": "a458f70cd5b36bf28740b1fb7fe48fc5f4c6edcdb4fae91494c531b5c2ed00b1", + "size": 149606, + "subdir": "linux-64", + "timestamp": 1600701732730, + "version": "5.5.3" + }, + "isort-5.5.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "99785ce43ddc67ab7679079fc6e9c25a", + "name": "isort", + "sha256": "2f3d8ce9e9b6d5df6dd2556112ea37840e7373f6d5308116c27bc83e74ebabe9", + "size": 147976, + "subdir": "linux-64", + "timestamp": 1600701717448, + "version": "5.5.3" + }, + "isort-5.5.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "1be1e7ca685640be1ed48938299e4224", + "name": "isort", + "sha256": "76ce29c4c81d45587e70213bb15c7e2ad7150e01902ea558a20ef048ce686586", + "size": 150511, + "subdir": "linux-64", + "timestamp": 1600701683645, + "version": "5.5.3" + }, + "isort-5.5.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "0aff68433e3244855bad92ddf96d16df", + "name": "isort", + "sha256": "c12853e5bb2a03580a41821d069b8609917ca919f0c91c54f1cd887f6cc126ba", + "size": 149514, + "subdir": "linux-64", + "timestamp": 1601490247645, + "version": "5.5.4" + }, + "isort-5.5.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "fcd52f4f1490423bd0fb8a2375e535c1", + "name": "isort", + "sha256": "c4d9ec245ecdcf61185bfe2eda814411b753407e96add344b78a4028f5fe374a", + "size": 149350, + "subdir": "linux-64", + "timestamp": 1601490245902, + "version": "5.5.4" + }, + "isort-5.5.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "044c3b95c961500d8997b437023dd8bd", + "name": "isort", + "sha256": "11317b827e3b24480357a88336f6eb21d57783cde1a9a30b2458f5f48c8ff639", + "size": 148551, + "subdir": "linux-64", + "timestamp": 1601490259926, + "version": "5.5.4" + }, + "isort-5.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "3863fe7478036a28d94378385ca4a508", + "name": "isort", + "sha256": "de85bc13b30448040868d24a3ac912e653f95095728b59622788fa38b8c112ec", + "size": 153652, + "subdir": "linux-64", + "timestamp": 1602258739807, + "version": "5.6.1" + }, + "isort-5.6.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "b0b722bc4e4f7c2edc77ce0ab2f8151b", + "name": "isort", + "sha256": "38d2a37000a2ee7ca4611b11ac3ddd0376fbfa6b8444205abcad0bfec237df4f", + "size": 153540, + "subdir": "linux-64", + "timestamp": 1602258714384, + "version": "5.6.1" + }, + "isort-5.6.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "91c914df2ac144f96c35ce264c720b21", + "name": "isort", + "sha256": "6580a4c07bfabaf4bdaf88147329cee38b93f69fdbe025cbe2de643e71e0e325", + "size": 154025, + "subdir": "linux-64", + "timestamp": 1602258705919, + "version": "5.6.1" + }, + "itsdangerous-0.24-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d2f5864139546acbe052d22260b3e165", + "name": "itsdangerous", + "sha256": "7e45b575819c1313939d0d001c6393e63a64649df0bda63a494d352f3d91e763", + "size": 20980, + "subdir": "linux-64", + "timestamp": 1530771705041, + "version": "0.24" + }, + "itsdangerous-0.24-py27hb8295c1_1.conda": { + "build": "py27hb8295c1_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0d773d8ac7d08293c8d81c8ee651f40d", + "name": "itsdangerous", + "sha256": "5dcc324583e4481275fc6e5d37fadbc7bdde53907776ba5986704523925f87c1", + "size": 20756, + "subdir": "linux-64", + "timestamp": 1505740319564, + "version": "0.24" + }, + "itsdangerous-0.24-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c0ade7e9ea422cf939280aba9f40f6fc", + "name": "itsdangerous", + "sha256": "4fc155ff5b91c92d4aaa1e7c5e6eb7b81ecbce2975c0502b66400ddeee68b2e9", + "size": 21684, + "subdir": "linux-64", + "timestamp": 1534804365488, + "version": "0.24" + }, + "itsdangerous-0.24-py35h7c46880_1.conda": { + "build": "py35h7c46880_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4ac819163d4c026e8808a8416ad676a1", + "name": "itsdangerous", + "sha256": "728686908e6f3d6c2a213b27ed7eb6e1ab3f39d245d827886c195fcbca873cf2", + "size": 21200, + "subdir": "linux-64", + "timestamp": 1505740331441, + "version": "0.24" + }, + "itsdangerous-0.24-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1e6d8878866ed886102d03b8df4223e6", + "name": "itsdangerous", + "sha256": "1dc698b11d0d9c019fe156f21d59bd6c5baf3402eb45d26050f268cf923b1427", + "size": 21246, + "subdir": "linux-64", + "timestamp": 1530771726429, + "version": "0.24" + }, + "itsdangerous-0.24-py36h93cc618_1.conda": { + "build": "py36h93cc618_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "de93ec3deb19150674287cf89c316ca4", + "name": "itsdangerous", + "sha256": "d29fe1c7c82c82223c1305cff80594e6eda379f8319ab40979bbaefe0318528e", + "size": 21039, + "subdir": "linux-64", + "timestamp": 1505740343513, + "version": "0.24" + }, + "itsdangerous-0.24-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1d8bbfb1819be2fb58af1ff0d30d1649", + "name": "itsdangerous", + "sha256": "0d52281fb7543c77dc7a84791444ce0b3465aa1b5c01cb2b66ab5758b4a93ea1", + "size": 21298, + "subdir": "linux-64", + "timestamp": 1530771684001, + "version": "0.24" + }, + "itsdangerous-1.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "919ac0c03fac224f66b6f8c5fdad6e1e", + "name": "itsdangerous", + "sha256": "44cd47585af1f8930b833693afc9b5b29f9719d9c93309b69bfa4cf093d3b562", + "size": 25432, + "subdir": "linux-64", + "timestamp": 1540238063568, + "version": "1.0.0" + }, + "itsdangerous-1.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b646ac9e68ef8de338a9f91263980b62", + "name": "itsdangerous", + "sha256": "33e71b7d56897b5e7225d4123701f5365501f19521d78a68a3f1d647d2f1d7e8", + "size": 25720, + "subdir": "linux-64", + "timestamp": 1540238139090, + "version": "1.0.0" + }, + "itsdangerous-1.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ffb4ea7e426834850fc95c7cc9fc8e7e", + "name": "itsdangerous", + "sha256": "91fc6e58a30c807d6a72493a41e5b5a6e18ea13abc6528567047ebcf45e87c01", + "size": 25733, + "subdir": "linux-64", + "timestamp": 1540238127817, + "version": "1.0.0" + }, + "itsdangerous-1.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0fedac00a90c53b53a1df3a19e66deaa", + "name": "itsdangerous", + "sha256": "66032557ddbf6cf6ebd3ad0f33c6932092e8a512b6be8a7295e87d8aee3468fe", + "size": 28323, + "subdir": "linux-64", + "timestamp": 1541025216123, + "version": "1.1.0" + }, + "itsdangerous-1.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c03d27225236bafe74b021f1bd8c89aa", + "name": "itsdangerous", + "sha256": "e02257a94581eb49b14a3a5688e3cfb8ef7d17d4627531ef98c1dc9060ca16be", + "size": 28633, + "subdir": "linux-64", + "timestamp": 1541025205968, + "version": "1.1.0" + }, + "itsdangerous-1.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "825f0156e3d79837d56c85890ba9822b", + "name": "itsdangerous", + "sha256": "12ed2126f910e0622e4ca9852ce4fed4f68ea4d22fab0451b9174196a23a9e66", + "size": 28684, + "subdir": "linux-64", + "timestamp": 1541025206057, + "version": "1.1.0" + }, + "jaeger-client-3.13.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "opentracing", + "python >=2.7,<2.8.0a0", + "threadloop", + "thrift", + "tornado" + ], + "license": "MIT", + "md5": "13252e427bb4d4507bf0854115fb34c4", + "name": "jaeger-client", + "sha256": "d094157c7493c1844b0ac0ed25ea6a335addec6798e0d55b134bb79c75bad04f", + "size": 79954, + "subdir": "linux-64", + "timestamp": 1545418711428, + "version": "3.13.0" + }, + "jaeger-client-3.13.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "opentracing", + "python >=3.6,<3.7.0a0", + "threadloop", + "thrift", + "tornado" + ], + "license": "MIT", + "md5": "a2a2fe484182b0bd153cf62601fd6f4f", + "name": "jaeger-client", + "sha256": "e00dacb30ae5c016ca517823f9d97c394b46c6b7f2459b80f0a59f421948931a", + "size": 81410, + "subdir": "linux-64", + "timestamp": 1545418733982, + "version": "3.13.0" + }, + "jaeger-client-3.13.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "opentracing", + "python >=3.7,<3.8.0a0", + "threadloop", + "thrift", + "tornado" + ], + "license": "MIT", + "md5": "4c922068d8832a84c2c2481f440121f3", + "name": "jaeger-client", + "sha256": "ac8f2b8ede7667d6990b97dc3187849d28c5dbc9b4db888ff5a9063d65b1b79d", + "size": 81611, + "subdir": "linux-64", + "timestamp": 1545418744799, + "version": "3.13.0" + }, + "jaeger-client-4.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=2.7,<2.8.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "b95a35a96af99491239f0f398397de50", + "name": "jaeger-client", + "sha256": "0cd92edfaf33f44436dc00259122a678ba72e549cca036e6fa877b812d11646b", + "size": 82953, + "subdir": "linux-64", + "timestamp": 1569424453797, + "version": "4.1.0" + }, + "jaeger-client-4.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.6,<3.7.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "076ef93ff50d3715d9dc0ad21ec1b045", + "name": "jaeger-client", + "sha256": "ad8f45dec0a5784b7d6d7eaf3778ec362b552dd4460c84b3cf60ce6748badd3c", + "size": 84406, + "subdir": "linux-64", + "timestamp": 1569424449014, + "version": "4.1.0" + }, + "jaeger-client-4.1.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.6,<3.7.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "25fd682a740d1b964e99ba968381e323", + "name": "jaeger-client", + "sha256": "70aff95e0ae4a5da52ff15317bf03078966f7bbb9b693be193f901f39118468a", + "size": 83333, + "subdir": "linux-64", + "timestamp": 1613485555983, + "version": "4.1.0" + }, + "jaeger-client-4.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.7,<3.8.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "2eec7c91894031c11c9f4020ca16e52a", + "name": "jaeger-client", + "sha256": "52b731f6bee6aed1d52e95fd49cf33c2567373ae496715da05904a35ebcb450e", + "size": 84479, + "subdir": "linux-64", + "timestamp": 1569424453439, + "version": "4.1.0" + }, + "jaeger-client-4.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.7,<3.8.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "c93c2463ad854ca731ab730c08e63f06", + "name": "jaeger-client", + "sha256": "e397c04f7245c618745a3a79eb0a743ab97ccb196976cc1f78d020407b7b21d0", + "size": 84832, + "subdir": "linux-64", + "timestamp": 1613485539519, + "version": "4.1.0" + }, + "jaeger-client-4.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.8,<3.9.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "bf570f70ffc9912d3b01a770c2ef8278", + "name": "jaeger-client", + "sha256": "91f3c4f5e93ee11a586f2a3ba2462e0f66c8f3374add5a93699b146879c9853c", + "size": 84664, + "subdir": "linux-64", + "timestamp": 1574158004797, + "version": "4.1.0" + }, + "jaeger-client-4.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.8,<3.9.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "148aacb71b9325c2613612cb9a2161fd", + "name": "jaeger-client", + "sha256": "03091546a77594920582d3eb2be393699a1735739435ebdb1fdd65a5a73c46a3", + "size": 84497, + "subdir": "linux-64", + "timestamp": 1613485162175, + "version": "4.1.0" + }, + "jaeger-client-4.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.9,<3.10.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "0ae0b5252e3212708970bb91a3ac3e1d", + "name": "jaeger-client", + "sha256": "5f3758ceaad6de7af8fd2c17e140f160fee4282272329bde5df233fef184e57d", + "size": 84329, + "subdir": "linux-64", + "timestamp": 1613485538339, + "version": "4.1.0" + }, + "jaeger-client-4.4.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.6,<3.7.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "1d66e08e65eaf7d55124b2b6a6cdd9c2", + "name": "jaeger-client", + "sha256": "f6884f6a527e47c05ad9c638735314b00ffa4955e9185e3c29b688fe02932de5", + "size": 82984, + "subdir": "linux-64", + "timestamp": 1613502271842, + "version": "4.4.0" + }, + "jaeger-client-4.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.7,<3.8.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "432901d1980485da6e21719599d83e75", + "name": "jaeger-client", + "sha256": "15242d647d1f126a81e14145eb9cbd4e91bbdf902cc85e9041a8d5f0cce4ae54", + "size": 84165, + "subdir": "linux-64", + "timestamp": 1613502285386, + "version": "4.4.0" + }, + "jaeger-client-4.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.8,<3.9.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "a040b8c64d0d68df856daebacbfa594a", + "name": "jaeger-client", + "sha256": "837e215dd1a74ea181807f27b7108e14e1190fa26548cf5d78d9a3043fcc56fa", + "size": 83823, + "subdir": "linux-64", + "timestamp": 1613501645558, + "version": "4.4.0" + }, + "jaeger-client-4.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.9,<3.10.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3,<6" + ], + "license": "MIT", + "md5": "221cd77c6ff96eca5b2f386b3e9b8f15", + "name": "jaeger-client", + "sha256": "da93ffe4b697dda5ca2f965a0d83d065335608d0b8efde1fe44bcf6aa3a36c80", + "size": 83802, + "subdir": "linux-64", + "timestamp": 1613502014820, + "version": "4.4.0" + }, + "jaeger-client-4.5.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.6,<3.7.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "md5": "75de138628eed189c3a00d8d1afa1640", + "name": "jaeger-client", + "sha256": "668bd3523d7b44f75a6e0ac0f831b65c05d96a6f401df57f41ae0deb21a87763", + "size": 87790, + "subdir": "linux-64", + "timestamp": 1621330381064, + "version": "4.5.0" + }, + "jaeger-client-4.5.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.7,<3.8.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "md5": "6874942efc2bc2eb4b89bec7bf5569dc", + "name": "jaeger-client", + "sha256": "d929f3a7a034e605c2efc5f5ae8c194a26721d030b0d128cc39433109c0140cf", + "size": 87838, + "subdir": "linux-64", + "timestamp": 1621334977590, + "version": "4.5.0" + }, + "jaeger-client-4.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.8,<3.9.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "md5": "dd74a873434c062516b8d2bf8e012bf4", + "name": "jaeger-client", + "sha256": "6e78bd9e5a8da40461c6b5b3255b5b1ef0e36102400b017676ed62c1e387af71", + "size": 89324, + "subdir": "linux-64", + "timestamp": 1621334968640, + "version": "4.5.0" + }, + "jaeger-client-4.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.9,<3.10.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "md5": "3a5f6e5d27855b7db22a69cdfbfeb4cc", + "name": "jaeger-client", + "sha256": "a666687edba696197dac8cbb6a99e17b46f18bbebb8eb8ab166c499757d99cfa", + "size": 89284, + "subdir": "linux-64", + "timestamp": 1621334641952, + "version": "4.5.0" + }, + "jaeger-client-4.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.10,<3.11.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fc61400637b6942bdcf93969d1ed8a79", + "name": "jaeger-client", + "sha256": "5de01b783d08696143f9508adde1fdc2b2ca4d89f31668ce1859bfe184e215cd", + "size": 85149, + "subdir": "linux-64", + "timestamp": 1640809478751, + "version": "4.6.0" + }, + "jaeger-client-4.6.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.11,<3.12.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b6af8b334de6b9b943a0ee8a2e72bab6", + "name": "jaeger-client", + "sha256": "f9cf2a83dc503990c722ef1929d8fb01a6d2569cd0101cc1d421b9e77f8dd3ac", + "size": 115256, + "subdir": "linux-64", + "timestamp": 1676852937188, + "version": "4.6.0" + }, + "jaeger-client-4.6.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.6,<3.7.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "776d855113d2f7b79e002d31d4689f73", + "name": "jaeger-client", + "sha256": "723191e637571ea243f27353e69d1ca0a4e5a2f0d3b6489b72591095c67492f6", + "size": 84441, + "subdir": "linux-64", + "timestamp": 1627065877796, + "version": "4.6.0" + }, + "jaeger-client-4.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.7,<3.8.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "50550b2589cb22e5992f738ed35dab5a", + "name": "jaeger-client", + "sha256": "c8a13fe00c077a4839327e4f19caadf63bbff1e5bf5b7d0c60387ebd4d6633cf", + "size": 83070, + "subdir": "linux-64", + "timestamp": 1627065864628, + "version": "4.6.0" + }, + "jaeger-client-4.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.8,<3.9.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b798b4828e5a0ef7e287742b132a0b86", + "name": "jaeger-client", + "sha256": "56076fb53a51e590903e32fe0352176d1bbccf8e2e1f779b2ed5e64fdf4923b6", + "size": 85201, + "subdir": "linux-64", + "timestamp": 1627065856540, + "version": "4.6.0" + }, + "jaeger-client-4.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "opentracing >=2.1,<3", + "python >=3.9,<3.10.0a0", + "threadloop >=1,<2", + "thrift", + "tornado >=4.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d18d675ef9c8dade513b6b13b3cfcaf5", + "name": "jaeger-client", + "sha256": "c44eaeb42d53c6f932d40e20ad4162d205b01351a80aff72bfda36cab14f9433", + "size": 83673, + "subdir": "linux-64", + "timestamp": 1627058395580, + "version": "4.6.0" + }, + "jansson-2.14-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e2b226e5eb569b784135cb6d07e563c", + "name": "jansson", + "sha256": "7a0ef2b5715e09a5b44e2cb159086f56d4a4d03e664c1709647a478797e0f74a", + "size": 40786, + "subdir": "linux-64", + "timestamp": 1677685765389, + "version": "2.14" + }, + "jaraco.classes-1.4.3-py27h6fce145_0.conda": { + "build": "py27h6fce145_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "79287cb1942ce4bccdd274e4943f67d3", + "name": "jaraco.classes", + "sha256": "9fb532f71415b279eacb94b087b76f08219fe52012defdee023663acf0d40723", + "size": 9318, + "subdir": "linux-64", + "timestamp": 1511702977991, + "version": "1.4.3" + }, + "jaraco.classes-1.4.3-py35h46561aa_0.conda": { + "build": "py35h46561aa_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "79327e6d487aaeff7085f28b52b30db4", + "name": "jaraco.classes", + "sha256": "958cd12cecc251cb4ce376dc7910ad591a30ba54854905d1e00a80252178872c", + "size": 9416, + "subdir": "linux-64", + "timestamp": 1511702976581, + "version": "1.4.3" + }, + "jaraco.classes-1.4.3-py36h1d0d791_0.conda": { + "build": "py36h1d0d791_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "94fb0aabb0c8dd8f0fc8922c2273f3c2", + "name": "jaraco.classes", + "sha256": "609877e3acef7f3b19541d9a46e9c1c66c1d500cabdab7b3207b7023d03a4ac8", + "size": 9370, + "subdir": "linux-64", + "timestamp": 1511702980783, + "version": "1.4.3" + }, + "jaraco.classes-1.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "442673337dee26b76f2ba8f14df231b6", + "name": "jaraco.classes", + "sha256": "af27b83865fe3ff6c030f9365973faa8565e3205951af0a17f2f7c3a20a5d87e", + "size": 10281, + "subdir": "linux-64", + "timestamp": 1528172318869, + "version": "1.5" + }, + "jaraco.classes-1.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0668a09d7b61a3ead9e0b1ed67567591", + "name": "jaraco.classes", + "sha256": "5a7971b98d830a5760fef8453c8452cb8cdb86cdfe2c90e18210e6a49d349f5a", + "size": 10312, + "subdir": "linux-64", + "timestamp": 1528172341564, + "version": "1.5" + }, + "jaraco.classes-1.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fafd90383757b260abb062be459702af", + "name": "jaraco.classes", + "sha256": "130014640f86d1189cd1658e3e7b5b562a44114b7bc2456c42265862033f66e0", + "size": 10294, + "subdir": "linux-64", + "timestamp": 1528172299585, + "version": "1.5" + }, + "jaraco.classes-1.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c479826aa2a919cb35f35942d7e74a3b", + "name": "jaraco.classes", + "sha256": "21a6268bf046c5ce27593eba3e30bba32f0f3fc6281d1e32dfb1bc529490406e", + "size": 10361, + "subdir": "linux-64", + "timestamp": 1530897945231, + "version": "1.5" + }, + "jaraco.functools-1.20-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache >=1.0.3", + "more-itertools", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e11e0d1917160e65f9f451418508c0d6", + "name": "jaraco.functools", + "sha256": "e2cc59ea6afff8746812a3806660af8a30db8fed9306c457a8e14df377773c2b", + "size": 13475, + "subdir": "linux-64", + "timestamp": 1539721892536, + "version": "1.20" + }, + "jaraco.functools-1.20-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "more-itertools", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "03f178f1ce12f52e9f5845c17846c686", + "name": "jaraco.functools", + "sha256": "b4dfd2b0d45339d32141b17c33a0e1474f88d5cc6aaaadb3296265b704dc16ad", + "size": 13596, + "subdir": "linux-64", + "timestamp": 1539721927085, + "version": "1.20" + }, + "jaraco.functools-1.20-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "more-itertools", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ec8d0d7003183e775e64caf19e7b2c7", + "name": "jaraco.functools", + "sha256": "78db62b545319c55aa7e38fc95f7f0e4e284234747ee89effa53cd0d29690849", + "size": 13451, + "subdir": "linux-64", + "timestamp": 1539721907690, + "version": "1.20" + }, + "jaraco.functools-2.0-py27_1000.conda": { + "build": "py27_1000", + "build_number": 1000, + "depends": [ + "backports.functools_lru_cache >=1.0.3", + "more-itertools", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8bb4f14fa2b28f81282aece07733bfc", + "name": "jaraco.functools", + "sha256": "8da7dccc81959287aa6f293459f0c8918967efd5b00632489c6133092e5d92cc", + "size": 15106, + "subdir": "linux-64", + "timestamp": 1552437074285, + "version": "2.0" + }, + "jaraco.functools-2.0-py36_1000.conda": { + "build": "py36_1000", + "build_number": 1000, + "depends": [ + "more-itertools", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a928e61be849fe8a953fa3d7761f8a08", + "name": "jaraco.functools", + "sha256": "9f966387387affb6dc8646d230e98f548413789c81ba3ef36626556994f3ed40", + "size": 15075, + "subdir": "linux-64", + "timestamp": 1552437101985, + "version": "2.0" + }, + "jaraco.functools-2.0-py37_1000.conda": { + "build": "py37_1000", + "build_number": 1000, + "depends": [ + "more-itertools", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5fa79b9f523880e69109db24044cc2d2", + "name": "jaraco.functools", + "sha256": "f35c3d6e31246edb3ae326dbf072041224f8f04be6fcd410bdc85834a028625d", + "size": 15084, + "subdir": "linux-64", + "timestamp": 1552437059106, + "version": "2.0" + }, + "jaraco.functools-2.0-py38_1000.conda": { + "build": "py38_1000", + "build_number": 1000, + "depends": [ + "more-itertools", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d0f534e995128deb2f492f785c0e308", + "name": "jaraco.functools", + "sha256": "04cd2805fc1394566e4ec282f91dfa0ff4c3850d1c791bf47e36ce5a9eee8dbb", + "size": 14053, + "subdir": "linux-64", + "timestamp": 1574158025486, + "version": "2.0" + }, + "jaraco.text-3.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib_resources", + "jaraco.functools", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6740d1fa014d51c63084a11b8c88dbc4", + "name": "jaraco.text", + "sha256": "1b221a51ee2566784d1369fb95754e410c33f079e154390500fcb694f4febcb2", + "size": 15944, + "subdir": "linux-64", + "timestamp": 1585058393511, + "version": "3.2.0" + }, + "jaraco.text-3.2.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "importlib_resources", + "jaraco.functools", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62c592fc43a5036b107c7cd57df0e037", + "name": "jaraco.text", + "sha256": "8a3390e9e924535279c01a88385e8c01f66da5a6712f4397d4e41a15b3ee4d80", + "size": 15265, + "subdir": "linux-64", + "timestamp": 1601490335368, + "version": "3.2.0" + }, + "jaraco.text-3.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e5d4f854694bd78a8a62ce397cfb658b", + "name": "jaraco.text", + "sha256": "ce8ece6e5d9afba0bfbc97176f71e36cef0f0711bafaf854fb91843a05f85f76", + "size": 15957, + "subdir": "linux-64", + "timestamp": 1585053247704, + "version": "3.2.0" + }, + "jaraco.text-3.2.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e36dd6b98ebc5016f9554936cf13324e", + "name": "jaraco.text", + "sha256": "80e5b3943947dd575ccd0e39fc1400d85319f5c38207c370faed2031555a1877", + "size": 14543, + "subdir": "linux-64", + "timestamp": 1594363002191, + "version": "3.2.0" + }, + "jaraco.text-3.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jaraco.functools", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11c140805143657c620d78659fb7305b", + "name": "jaraco.text", + "sha256": "154670e3e3f622a2e6de6f8ad85479f592d448324875fa79b05706c9a40575f4", + "size": 16020, + "subdir": "linux-64", + "timestamp": 1585053273240, + "version": "3.2.0" + }, + "jaraco.text-3.2.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "jaraco.functools", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc9cf6065ba26db7ea9528d877840589", + "name": "jaraco.text", + "sha256": "6b084069dc9258dfa700ffd36b306ee345a8a401402f9bee24ff2fe06741eec2", + "size": 15317, + "subdir": "linux-64", + "timestamp": 1601490300815, + "version": "3.2.0" + }, + "jaraco.text-3.4.0-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "importlib_resources", + "jaraco.functools", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f8c95da3301abddb8cd8e13c5780fd0", + "name": "jaraco.text", + "sha256": "ce3e49fe321af4c39033e1ef2d610c775d2eeac7f4614623ad403798153a5749", + "size": 15653, + "subdir": "linux-64", + "timestamp": 1609093480849, + "version": "3.4.0" + }, + "jaraco.text-3.4.0-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b278eec2bffcfdf504edee9ed4729340", + "name": "jaraco.text", + "sha256": "403ad3f0463452f4f02c75690437dff10e9e8e77249ec7a10132f3c5f18137f1", + "size": 15643, + "subdir": "linux-64", + "timestamp": 1609093459039, + "version": "3.4.0" + }, + "jaraco.text-3.4.0-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "27ec32d9e04b875e1cd703bea4190aad", + "name": "jaraco.text", + "sha256": "0fc5ea9319cf13bc4298859b1fe291c26e41624c9602cb21cd3a4fc2642c474e", + "size": 15786, + "subdir": "linux-64", + "timestamp": 1609093482333, + "version": "3.4.0" + }, + "jaraco.text-3.4.0-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "70bef6854b8e3ee9766f64c008cab806", + "name": "jaraco.text", + "sha256": "029125a222906ef6ff979f0b8721f5a95f95fbd44548ebc0dcbee6e49890831b", + "size": 15782, + "subdir": "linux-64", + "timestamp": 1609093478999, + "version": "3.4.0" + }, + "jaraco.text-3.5.0-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "importlib_resources", + "jaraco.functools", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c65134d967767d144e6c4c4d630a0050", + "name": "jaraco.text", + "sha256": "3545ec841c06dc7c839b1eebf287f37823252eaae6adb2fed1b4094a3c636af0", + "size": 15286, + "subdir": "linux-64", + "timestamp": 1613502409045, + "version": "3.5.0" + }, + "jaraco.text-3.5.0-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbdff9be3097d59017222b22d3fb8b92", + "name": "jaraco.text", + "sha256": "fc4e23e69b3290bd339e32bfd739ef5f3665bf5be29780396a2745e100acc7dd", + "size": 15493, + "subdir": "linux-64", + "timestamp": 1613502400289, + "version": "3.5.0" + }, + "jaraco.text-3.5.0-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6aa9693076b10bf5984699dc5e507835", + "name": "jaraco.text", + "sha256": "5bb3bbb6646c71255cc0015ded514f2c01d5a0bcf1c9ac415d76a95c2bb16734", + "size": 15517, + "subdir": "linux-64", + "timestamp": 1613501768092, + "version": "3.5.0" + }, + "jaraco.text-3.5.0-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb346826e258d5ae07af93ac61f0332f", + "name": "jaraco.text", + "sha256": "d42a9f0d5b14affb582411b5100715b24ff5130dc8e0f4098d7a834603aadffa", + "size": 15505, + "subdir": "linux-64", + "timestamp": 1613502402539, + "version": "3.5.0" + }, + "jaraco.text-3.5.1-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "69a3286add11c58e30c1040512fcc097", + "name": "jaraco.text", + "sha256": "ac00c69f736b81e5365af891b011e0927e2a9dcda7cb0f8e8b50dd651b02b5c6", + "size": 15561, + "subdir": "linux-64", + "timestamp": 1640791137719, + "version": "3.5.1" + }, + "jaraco.text-3.5.1-py311h06a4308_2.conda": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef0daa9227d472f94296826ecc58bff7", + "name": "jaraco.text", + "sha256": "05f0f2bb3f0a923d2c58d28044974cabfb43b20eec40954166c6d41b6c2724b3", + "size": 17942, + "subdir": "linux-64", + "timestamp": 1676840015996, + "version": "3.5.1" + }, + "jaraco.text-3.5.1-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "importlib_resources", + "jaraco.functools", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "30b30f3f3e184b09f4eec50eb23a9b79", + "name": "jaraco.text", + "sha256": "4f71df607f1181b4aba71628c7dd80785f082233106edfbfa41b3c6ac4c10c02", + "size": 15245, + "subdir": "linux-64", + "timestamp": 1626445393969, + "version": "3.5.1" + }, + "jaraco.text-3.5.1-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b98f3f7150040cf0f1c186b8fcb7084", + "name": "jaraco.text", + "sha256": "ef117f851c10093254da9d1674f00d634baca234e5a46cd8a12f4b82a5272c4a", + "size": 15264, + "subdir": "linux-64", + "timestamp": 1626438312434, + "version": "3.5.1" + }, + "jaraco.text-3.5.1-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f266b6e325fb79312b4e9c3ccb09704", + "name": "jaraco.text", + "sha256": "41879c03e758853ceb68c59c91552f384db725d96e516e96205c939476a063be", + "size": 15304, + "subdir": "linux-64", + "timestamp": 1626445481180, + "version": "3.5.1" + }, + "jaraco.text-3.5.1-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "jaraco.functools", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "601a290f7ed656e07536398c28d0e4a1", + "name": "jaraco.text", + "sha256": "416f2d6d0c69f9ae6a05bb41df49532a5a014ac3fb6b678cb829581049bd4461", + "size": 15291, + "subdir": "linux-64", + "timestamp": 1626445493892, + "version": "3.5.1" + }, + "jasper-1.900.1-hd497a04_4.conda": { + "build": "hd497a04_4", + "build_number": 4, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0" + ], + "license": "JasPer 2.0", + "md5": "fdb696583837d4f0a0aeb411741827b0", + "name": "jasper", + "sha256": "13b3fc3ef630e211ffdb2b3a9177a8e43469add32dc2814b6139df6d1228184b", + "size": 202845, + "subdir": "linux-64", + "timestamp": 1512065615327, + "version": "1.900.1" + }, + "jasper-2.0.14-h07fcdf6_0.conda": { + "build": "h07fcdf6_0", + "build_number": 0, + "depends": [ + "freeglut >=2.8.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu >=9.0.0,<10.0a0" + ], + "license": "JasPer 2.0", + "md5": "001db4bd8629e1386d691de099ba389a", + "name": "jasper", + "sha256": "6fc7df6564d9215d26cc8309a8f6188b1c7bc138689572d6773c2ac34c30e33e", + "size": 724021, + "subdir": "linux-64", + "timestamp": 1520775456386, + "version": "2.0.14" + }, + "jasper-2.0.14-h07fcdf6_1.conda": { + "build": "h07fcdf6_1", + "build_number": 1, + "depends": [ + "freeglut >=3.0.0,<4.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu >=9.0.0,<10.0a0" + ], + "license": "JasPer 2.0", + "md5": "076f0b9762977e3aae069f99db43cd8b", + "name": "jasper", + "sha256": "87c8a4223efea603b086bd7bde0494bce6280e4099fa80d4c4e750cd0080b6d2", + "size": 724411, + "subdir": "linux-64", + "timestamp": 1527038694212, + "version": "2.0.14" + }, + "jasper-2.0.14-hd8c5072_2.conda": { + "build": "hd8c5072_2", + "build_number": 2, + "depends": [ + "freeglut >=3.0.0,<4.0a0", + "jpeg", + "libgcc-ng >=7.5.0", + "libglu >=9.0.0,<10.0a0" + ], + "license": "JasPer 2.0", + "md5": "49fe59cd1445d971a58295f6ce7dfaec", + "name": "jasper", + "sha256": "ef017893a4ecc9815efe6d006d6ac97f3827d9a7299ee4db50ed21cd7279f82c", + "size": 753543, + "subdir": "linux-64", + "timestamp": 1633701200112, + "version": "2.0.14" + }, + "jax-0.3.25-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jaxlib >=0.3.22", + "numpy >=1.21,<2", + "opt_einsum", + "python >=3.10,<3.11.0a0", + "scipy >=1.5", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6d6b7dc17472df072e86905a4e5f63a4", + "name": "jax", + "sha256": "e1fe10180de4550e3f81cd2898c02cbfd9377330617cd41f091daf83fb6f73ca", + "size": 2200447, + "subdir": "linux-64", + "timestamp": 1669936888469, + "version": "0.3.25" + }, + "jax-0.3.25-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jaxlib >=0.3.22", + "numpy >=1.21,<2", + "opt_einsum", + "python >=3.11,<3.12.0a0", + "scipy >=1.5", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a1d8f539e6793b9ef9a06e8ba95adb62", + "name": "jax", + "sha256": "996b75f6ca66fa2ab049cce95c53e3446696948ddbb6d75aa0638ae31a4b39ab", + "size": 2644851, + "subdir": "linux-64", + "timestamp": 1676840034730, + "version": "0.3.25" + }, + "jax-0.3.25-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jaxlib >=0.3.22", + "numpy >=1.20,<2", + "opt_einsum", + "python >=3.7,<3.8.0a0", + "scipy >=1.5", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "1647d587fd5e2dcedabd36449ca02872", + "name": "jax", + "sha256": "14e2ef1cebe4bb0f34e11e6ca0f565211fa8858a8b54579452ec04c5ff0e5ddc", + "size": 2158549, + "subdir": "linux-64", + "timestamp": 1669936928288, + "version": "0.3.25" + }, + "jax-0.3.25-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jaxlib >=0.3.22", + "numpy >=1.20,<2", + "opt_einsum", + "python >=3.8,<3.9.0a0", + "scipy >=1.5", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7eb28f5c7b02b8878718fa259eec128c", + "name": "jax", + "sha256": "1c07ab263716fc694faf7a991e0ae36668aaed79b578a42ecbea7421350d6489", + "size": 2182631, + "subdir": "linux-64", + "timestamp": 1669937003072, + "version": "0.3.25" + }, + "jax-0.3.25-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jaxlib >=0.3.22", + "numpy >=1.20,<2", + "opt_einsum", + "python >=3.9,<3.10.0a0", + "scipy >=1.5", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8939e52334c63b7007841bdafdbbb885", + "name": "jax", + "sha256": "af30b077c95c1ee43dfcd307b1c5434f4a1e7ea07fccd41642f86c10dacfde25", + "size": 2178443, + "subdir": "linux-64", + "timestamp": 1669936965684, + "version": "0.3.25" + }, + "jax-jumpy-0.2.0-py310h2f386ee_0.conda": { + "build": "py310h2f386ee_0", + "build_number": 0, + "constrains": [ + "jax >=0.3.24", + "jaxlib >=0.3.24" + ], + "depends": [ + "numpy >=1.18.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8560155376ac795408e982f02e285cf7", + "name": "jax-jumpy", + "sha256": "3916e9d4bc689b9873f2fa9ab5a43707a7b106e6d600c2a7523900c76c4e26f5", + "size": 23987, + "subdir": "linux-64", + "timestamp": 1677830303948, + "version": "0.2.0" + }, + "jax-jumpy-0.2.0-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "constrains": [ + "jax >=0.3.24", + "jaxlib >=0.3.24" + ], + "depends": [ + "numpy >=1.18.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "17203519c439a7669de150b5739d73ce", + "name": "jax-jumpy", + "sha256": "7ac007a88df629513e590df231a1bb6b8b2e96b06533724d80395c5e2bf92a77", + "size": 23711, + "subdir": "linux-64", + "timestamp": 1677830267392, + "version": "0.2.0" + }, + "jax-jumpy-0.2.0-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "constrains": [ + "jax >=0.3.24", + "jaxlib >=0.3.24" + ], + "depends": [ + "numpy >=1.18.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "461fb788b31ac45b555e415356b2ffb4", + "name": "jax-jumpy", + "sha256": "f0d2ce85c38a17b6059f9d25c3da2b7a2d2d6c7a14cc0a7e049589397d5b6caf", + "size": 23732, + "subdir": "linux-64", + "timestamp": 1677830232829, + "version": "0.2.0" + }, + "jaxlib-0.3.25-py310h6a678d5_1.conda": { + "build": "py310h6a678d5_1", + "build_number": 1, + "constrains": [ + "jax >=0.3.25" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<2", + "python >=3.10,<3.11.0a0", + "scipy >=1.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6c899b315f7183ee45c997f48d73f34d", + "name": "jaxlib", + "sha256": "5c88c86798491b0dc589e164ee2ba680f591c87628342222293f6ef943d29040", + "size": 40597101, + "subdir": "linux-64", + "timestamp": 1669917536637, + "version": "0.3.25" + }, + "jaxlib-0.3.25-py311h6a678d5_2.conda": { + "build": "py311h6a678d5_2", + "build_number": 2, + "constrains": [ + "jax >=0.3.25" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<2", + "python >=3.11,<3.12.0a0", + "scipy >=1.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e9852ccae6d8d0bec571d68f8f5de2cf", + "name": "jaxlib", + "sha256": "a192c0e3ff9a1754a6e31f924049801d96472e84acd497de38139475e9095a7a", + "size": 36461527, + "subdir": "linux-64", + "timestamp": 1676836981586, + "version": "0.3.25" + }, + "jaxlib-0.3.25-py37h6a678d5_1.conda": { + "build": "py37h6a678d5_1", + "build_number": 1, + "constrains": [ + "jax >=0.3.25" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<2", + "python >=3.7,<3.8.0a0", + "scipy >=1.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c83b851dd223b911d0477e3a0a7ad847", + "name": "jaxlib", + "sha256": "bd1899a94c590b8d9ba2aeddf93c13d78a42af64931b4adc0e6b72ac484fcbda", + "size": 40578442, + "subdir": "linux-64", + "timestamp": 1669909422909, + "version": "0.3.25" + }, + "jaxlib-0.3.25-py38h6a678d5_1.conda": { + "build": "py38h6a678d5_1", + "build_number": 1, + "constrains": [ + "jax >=0.3.25" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<2", + "python >=3.8,<3.9.0a0", + "scipy >=1.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "772c0017058f8690ca8a683f0cc95169", + "name": "jaxlib", + "sha256": "5a902b802b291353cbb039af7eaf513fad21d8174c6726182c6a1180cbd274a3", + "size": 40591775, + "subdir": "linux-64", + "timestamp": 1669925614935, + "version": "0.3.25" + }, + "jaxlib-0.3.25-py39h6a678d5_1.conda": { + "build": "py39h6a678d5_1", + "build_number": 1, + "constrains": [ + "jax >=0.3.25" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<2", + "python >=3.9,<3.10.0a0", + "scipy >=1.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4eec229bdb07bb12cd04dd8e941f50eb", + "name": "jaxlib", + "sha256": "7cbf669b4cccfb526f548cf45c67a2a139bcff23da616f3d312283c4e2391df6", + "size": 40598090, + "subdir": "linux-64", + "timestamp": 1669933680493, + "version": "0.3.25" + }, + "jbig-2.1-hdba287a_0.conda": { + "build": "hdba287a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "17d909449cd89da0324bf755aee5a9ef", + "name": "jbig", + "sha256": "924971b5e00ec6f599a7bb7af32548efdf8106182691a5306ca5405931d5970a", + "size": 40737, + "subdir": "linux-64", + "timestamp": 1505744775994, + "version": "2.1" + }, + "jdcal-1.3-py27h2cc5433_0.conda": { + "build": "py27h2cc5433_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "965413a4acb7a1a680667f301260532e", + "name": "jdcal", + "sha256": "9ab49772497bf88072661b6f43aa8296d84d9fd0fa4a7e17080e916129669eae", + "size": 10788, + "subdir": "linux-64", + "timestamp": 1505744787171, + "version": "1.3" + }, + "jdcal-1.3-py35hf1f7175_0.conda": { + "build": "py35hf1f7175_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "842332ef4b871e1b509f638e719304f2", + "name": "jdcal", + "sha256": "41817506791510de138e6ab7363668835cf2759c7de57a70c0774b7cbe9afb35", + "size": 10963, + "subdir": "linux-64", + "timestamp": 1505744799659, + "version": "1.3" + }, + "jdcal-1.3-py36h4c697fb_0.conda": { + "build": "py36h4c697fb_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "93935f971dd6dc4849242dd9d9954ebf", + "name": "jdcal", + "sha256": "c580a72537b52642680ac198a084e145a2123b6818c4632c5eb9182472f8b670", + "size": 10892, + "subdir": "linux-64", + "timestamp": 1505744812149, + "version": "1.3" + }, + "jdcal-1.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "6383ae623a632375f2d3f8bdfbd5421f", + "name": "jdcal", + "sha256": "7cbd2ec9151baeef0bb578fb945f39507ea8f0f521055974fa6bde71f0061fff", + "size": 11250, + "subdir": "linux-64", + "timestamp": 1523943908324, + "version": "1.4" + }, + "jdcal-1.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ef3500edd44856c3d702091f1c61ff6f", + "name": "jdcal", + "sha256": "4190c98d46d705f6f7d7882a57193abca61c264995d1c3667e32db3a0fba88dc", + "size": 11425, + "subdir": "linux-64", + "timestamp": 1523943843456, + "version": "1.4" + }, + "jdcal-1.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "00b85b0b8d7073435b7938807d8e575c", + "name": "jdcal", + "sha256": "ba51d709046c7c768c4e4db795d1bffe9c04a8e68c10b3c5ffe2e2231502320e", + "size": 11359, + "subdir": "linux-64", + "timestamp": 1523944002303, + "version": "1.4" + }, + "jdcal-1.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e8722a284f3bae24eb03a51c29c42755", + "name": "jdcal", + "sha256": "b3228f2f443358f57eeec24503674fa1512d1509cd6d7de8d0739eb369a7c189", + "size": 11185, + "subdir": "linux-64", + "timestamp": 1530735997064, + "version": "1.4" + }, + "jedi-0.10.2-py27h8af4e35_0.conda": { + "build": "py27h8af4e35_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da26d76d708ce595dd1d3a78d1a59119", + "name": "jedi", + "sha256": "0c20443d3797ad96abb75548277154a610ea1a4a3e66c587921d1e0b7ee8261f", + "size": 259179, + "subdir": "linux-64", + "timestamp": 1505690588395, + "version": "0.10.2" + }, + "jedi-0.10.2-py35hc33c70f_0.conda": { + "build": "py35hc33c70f_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "742772e6bcee6af3873b8e4581dda9eb", + "name": "jedi", + "sha256": "fa8a245f3eb7ad6da04ff286bc61c44711a6ea55bbb37d7371fabe0402ddc6e4", + "size": 268023, + "subdir": "linux-64", + "timestamp": 1505690603584, + "version": "0.10.2" + }, + "jedi-0.10.2-py36h552def0_0.conda": { + "build": "py36h552def0_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8509c0f5a0afac4d7cb9e9f18f81c55", + "name": "jedi", + "sha256": "3fc55d68c8c564172836b1ffe6b7d79b0e44878ce12955c648c18e5d809cb4e5", + "size": 262048, + "subdir": "linux-64", + "timestamp": 1505690618923, + "version": "0.10.2" + }, + "jedi-0.11.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "parso >=0.1.0,<0.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "293433b7b0643271405c5af72dc49a27", + "name": "jedi", + "sha256": "f439e8e042c36768d9314de47ad581de221128467967ed598057b7ecbedb4f91", + "size": 208668, + "subdir": "linux-64", + "timestamp": 1512675226636, + "version": "0.11.0" + }, + "jedi-0.11.0-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "parso >=0.1.0,<0.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "57fee8706b41a707af63730708e99d2f", + "name": "jedi", + "sha256": "72821d927da22a8c9a4646db6fcde29ad27d12d049bbc28eeab88463f4510bca", + "size": 209000, + "subdir": "linux-64", + "timestamp": 1512802210504, + "version": "0.11.0" + }, + "jedi-0.11.0-py27hb1d440e_0.conda": { + "build": "py27hb1d440e_0", + "build_number": 0, + "depends": [ + "parso ==0.1.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3fe5e484cdd99b0c377f0a7a28e980fe", + "name": "jedi", + "sha256": "3aeb7b416ce275077de9854cb4be1834adb152b76ebe68682a6a821f5ea465c8", + "size": 208853, + "subdir": "linux-64", + "timestamp": 1512058836974, + "version": "0.11.0" + }, + "jedi-0.11.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "parso >=0.1.0,<0.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ed03dac2f69a61de5a1a87cba692e682", + "name": "jedi", + "sha256": "b2b30451854bc6a11381419a427f292b103bcaaa4c1e68d25d9164210fc205f4", + "size": 210773, + "subdir": "linux-64", + "timestamp": 1512675237974, + "version": "0.11.0" + }, + "jedi-0.11.0-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "parso >=0.1.0,<0.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98add182719f602ab805a837449bbf0e", + "name": "jedi", + "sha256": "d3e69c6ddb357422354c3b5f2b630caa99a6ebafcfb6e44ad5f7b510b540f334", + "size": 213348, + "subdir": "linux-64", + "timestamp": 1512802247535, + "version": "0.11.0" + }, + "jedi-0.11.0-py35h48b7ba3_0.conda": { + "build": "py35h48b7ba3_0", + "build_number": 0, + "depends": [ + "parso ==0.1.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "266a995ad3488910e6f9138fdf407264", + "name": "jedi", + "sha256": "28aea24dc0820b21f0523080a05788d11d26f6f3afce5335a6f188911d04c6d3", + "size": 210934, + "subdir": "linux-64", + "timestamp": 1512058837639, + "version": "0.11.0" + }, + "jedi-0.11.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "parso >=0.1.0,<0.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f32c6ca342198d991a5ac38dd574352", + "name": "jedi", + "sha256": "17d128ada476e311cc4067bf7f480ccd20c2737361d783341d336c4869e92e9f", + "size": 210463, + "subdir": "linux-64", + "timestamp": 1512675253432, + "version": "0.11.0" + }, + "jedi-0.11.0-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "parso >=0.1.0,<0.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "567731d8f6ce6b3599eaa4f4bea9590c", + "name": "jedi", + "sha256": "14f195fd2543d8d387714fa26b8112480c861b94e867781abd9e84f85739ad18", + "size": 208717, + "subdir": "linux-64", + "timestamp": 1512802215982, + "version": "0.11.0" + }, + "jedi-0.11.0-py36hf290c5b_0.conda": { + "build": "py36hf290c5b_0", + "build_number": 0, + "depends": [ + "parso ==0.1.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d8ec990e30e4939009745adc1b67c2e", + "name": "jedi", + "sha256": "c81bf2048fab54c68d2c5b23bcfabcdcfcde2cb1960b54c89d18dfb17a7869df", + "size": 210572, + "subdir": "linux-64", + "timestamp": 1512058861563, + "version": "0.11.0" + }, + "jedi-0.11.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "parso >=0.1.0,<0.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85352b8a91ac434dbea970128381beab", + "name": "jedi", + "sha256": "88d895254b6c1830dc46fdeb6c2cd057e1cebf92309e9cd75e8e6f1689386c41", + "size": 310605, + "subdir": "linux-64", + "timestamp": 1515791358516, + "version": "0.11.1" + }, + "jedi-0.11.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "numpydoc", + "parso >=0.1.0,<0.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15fde35f92472b520d5b4016ce67c67d", + "name": "jedi", + "sha256": "2d522b18aae59b852d1e98d95dc03f300ac7a6c022045de96a738c860ccd9ead", + "size": 310561, + "subdir": "linux-64", + "timestamp": 1521633485650, + "version": "0.11.1" + }, + "jedi-0.11.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "parso >=0.1.0,<0.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a34c3318647fd07c17ef4c26fc61071f", + "name": "jedi", + "sha256": "b46f0e779a9fd7509336ff33a7669456255538f94c47b1ec3181ad8157578d45", + "size": 319800, + "subdir": "linux-64", + "timestamp": 1515791523666, + "version": "0.11.1" + }, + "jedi-0.11.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "numpydoc", + "parso >=0.1.0,<0.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6458c2c361b4b0cae957846829ac0b38", + "name": "jedi", + "sha256": "e1664bc142b952731247154e448c91f5e4b73e5e65456363ac49cb4dea3c03f1", + "size": 323237, + "subdir": "linux-64", + "timestamp": 1521633501130, + "version": "0.11.1" + }, + "jedi-0.11.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.1.0,<0.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8b8bb9d08a699e5fe3ee1541694f72a", + "name": "jedi", + "sha256": "f57010c37f12da3fb3a916a85f9d17f1f0c6acce80edb5cf349fe978a9a72928", + "size": 317624, + "subdir": "linux-64", + "timestamp": 1515791326040, + "version": "0.11.1" + }, + "jedi-0.11.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "numpydoc", + "parso >=0.1.0,<0.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a4374c38d686cf827dd876d451312ae", + "name": "jedi", + "sha256": "9b8a4196fc0d765e52beda4d36544fbfcd69bc5755cbf913dabaff1758581370", + "size": 320273, + "subdir": "linux-64", + "timestamp": 1521633499682, + "version": "0.11.1" + }, + "jedi-0.12.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpydoc", + "parso >=0.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34f06d341f136e0c061a62aae321192f", + "name": "jedi", + "sha256": "2a8ed97b70aa6670d06f3bfc827122879bd660f4a6c51f90c601480c9f830708", + "size": 238731, + "subdir": "linux-64", + "timestamp": 1523970976509, + "version": "0.12.0" + }, + "jedi-0.12.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "parso", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c4bf6551a7ac7d35d038f0adcc30e8c", + "name": "jedi", + "sha256": "4749641e9893cdc6c2eb7b44a0d4ca10449afcfd367e72b92451cf8781f321ac", + "size": 238728, + "subdir": "linux-64", + "timestamp": 1524675554736, + "version": "0.12.0" + }, + "jedi-0.12.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpydoc", + "parso >=0.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0cb51a445214f47338c7ebabc84ee34d", + "name": "jedi", + "sha256": "29f6c2ebb8122175412a33d3382a5227687db24feb081f53fea2751b72014ffb", + "size": 246163, + "subdir": "linux-64", + "timestamp": 1523971007545, + "version": "0.12.0" + }, + "jedi-0.12.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "parso", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5901f8ec2581fa7b127702907eb0d18", + "name": "jedi", + "sha256": "17664e228f97bef6b208df415775f514774007810b3328c1dbae4a3e547627e2", + "size": 243828, + "subdir": "linux-64", + "timestamp": 1524675569984, + "version": "0.12.0" + }, + "jedi-0.12.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpydoc", + "parso >=0.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "614b5f8c998d39763c2eb7462c9642ff", + "name": "jedi", + "sha256": "fb976b61a71dbbb5eff2581205e927f2ddc36ad882f5d7fded7d23ce75ff9e8c", + "size": 241236, + "subdir": "linux-64", + "timestamp": 1523971008186, + "version": "0.12.0" + }, + "jedi-0.12.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "parso", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "35c1abcefc0f1d24e7e8ceb5f7267200", + "name": "jedi", + "sha256": "2ff7e2e87a3e838fd1c4ac64e5bf5c9fad1aa39209b90ef51a9446b87c3cd1e2", + "size": 243283, + "subdir": "linux-64", + "timestamp": 1524675572686, + "version": "0.12.0" + }, + "jedi-0.12.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "parso >=0.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "03d4c298b03a0277b31ca191c5dacf71", + "name": "jedi", + "sha256": "0108dc864eb929268f461bed94adb73ef90c52aab767a99e2487e54e586451ac", + "size": 244010, + "subdir": "linux-64", + "timestamp": 1530733677896, + "version": "0.12.0" + }, + "jedi-0.12.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3c9d30c99a1802bd1b1ab1cce609a4e", + "name": "jedi", + "sha256": "54ef409af4475171afe410944ad84e7d9339c27ba3317e430956fe86b2253fc7", + "size": 240214, + "subdir": "linux-64", + "timestamp": 1532365272634, + "version": "0.12.1" + }, + "jedi-0.12.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c51102a1bdf0138acfa612ac29f423e1", + "name": "jedi", + "sha256": "3e39b9bb7e66c42ecb1b13be785e768b0c05591b0ef0b1e912394fb67a34924f", + "size": 245517, + "subdir": "linux-64", + "timestamp": 1532365309846, + "version": "0.12.1" + }, + "jedi-0.12.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "65aa196241197caca5f1694fd9ba339f", + "name": "jedi", + "sha256": "303480be32c3a02626c8793e23c5905b9414f9c7196deed7198f23a893e8bbdf", + "size": 245165, + "subdir": "linux-64", + "timestamp": 1532365129053, + "version": "0.12.1" + }, + "jedi-0.12.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e2e675c83fa6162f377def3fddf8dba5", + "name": "jedi", + "sha256": "a652fb14ceab99074ae4a88d246beaf809925497dce2d2cc750cf2473e88a31a", + "size": 243199, + "subdir": "linux-64", + "timestamp": 1532365324039, + "version": "0.12.1" + }, + "jedi-0.13.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd491acb4fbe188860a2bc1c59108079", + "name": "jedi", + "sha256": "96794f0b95f33f27339577e486baa11ff4df1edeecd04166df91a0595f024522", + "size": 244320, + "subdir": "linux-64", + "timestamp": 1539023217343, + "version": "0.13.1" + }, + "jedi-0.13.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63d9e1c951aedcafb308927e4dd1b86f", + "name": "jedi", + "sha256": "bb5b88038ebb5c1e30b949bf36b66261dfa75aaa7005259af593f4bfde6275c7", + "size": 246935, + "subdir": "linux-64", + "timestamp": 1539023226347, + "version": "0.13.1" + }, + "jedi-0.13.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51a18c052fd817e5d5a02068e125e0eb", + "name": "jedi", + "sha256": "b51bf5190bc5994954422ab1793a1ce453898779dcb179cce66efd158c5c9562", + "size": 248944, + "subdir": "linux-64", + "timestamp": 1539023205129, + "version": "0.13.1" + }, + "jedi-0.13.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "69dd532e65d12b9f211d0a5fe7715135", + "name": "jedi", + "sha256": "59cf6947c477a540f65c10362101a08df0a22669ed8264ca2c97da1cd4f57bb0", + "size": 246995, + "subdir": "linux-64", + "timestamp": 1545072609078, + "version": "0.13.2" + }, + "jedi-0.13.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8af6bbac5d07d1d76f1f78f222a12155", + "name": "jedi", + "sha256": "7b53c1b77af80ffcfff004bde266ae9859205888903334190ce8b3529b1c457b", + "size": 247149, + "subdir": "linux-64", + "timestamp": 1545072628071, + "version": "0.13.2" + }, + "jedi-0.13.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "304b45358d508a2ee00ec376a3198aa4", + "name": "jedi", + "sha256": "ef78d60a5d36f5baf98ae5345ce2dd7e8673b63f36f9836d8b4874a1d781b7b2", + "size": 247116, + "subdir": "linux-64", + "timestamp": 1545072602226, + "version": "0.13.2" + }, + "jedi-0.13.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee51b273c5d39cf14248efa746b5fb80", + "name": "jedi", + "sha256": "f56d32c0ebb2926602d39169bd9191a15b7e978952b908719ca22fdada9c6663", + "size": 248312, + "subdir": "linux-64", + "timestamp": 1551140327364, + "version": "0.13.3" + }, + "jedi-0.13.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0419f7cfe44dd68f47fb36ad636649b4", + "name": "jedi", + "sha256": "e1428de2d61e12befe53dcb80df532df835d12b6848cda77b63008dc88f86209", + "size": 253321, + "subdir": "linux-64", + "timestamp": 1551140353363, + "version": "0.13.3" + }, + "jedi-0.13.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ae4c4fd969fc5db01ef3166ae685ef36", + "name": "jedi", + "sha256": "c08dbfabd1a21ab9e0b9634e9dee88d94183f20d4da359da8a47a4681f56b60b", + "size": 250920, + "subdir": "linux-64", + "timestamp": 1551195541963, + "version": "0.13.3" + }, + "jedi-0.14.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90be8b5de5ba34a981d6ac13f7439db4", + "name": "jedi", + "sha256": "8758dc0c0bd37bf4c2d212dd1948b61188540afdaac5161271e9e824ed163902", + "size": 700348, + "subdir": "linux-64", + "timestamp": 1575415316457, + "version": "0.14.1" + }, + "jedi-0.14.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1591ff568cbc59e58f6ffbb6fac3d5db", + "name": "jedi", + "sha256": "e2fd738590349c4475fb541740947246e9024d960138dcd4ca4be8b697dc4c36", + "size": 703153, + "subdir": "linux-64", + "timestamp": 1575415346909, + "version": "0.14.1" + }, + "jedi-0.14.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b0e221230a19cf656ff9d95a6998ff48", + "name": "jedi", + "sha256": "6071ee4bdd286638b175e208829cb00b1c09ae1ca1aaa872826c59a090800ddb", + "size": 703098, + "subdir": "linux-64", + "timestamp": 1575415316672, + "version": "0.14.1" + }, + "jedi-0.14.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "988a09ad8253df7991840c29b56a4c4c", + "name": "jedi", + "sha256": "e74f1fe682364341dd5c33ae5f1bfcd4bfb15634860157c9f4843fe8efa8d475", + "size": 706618, + "subdir": "linux-64", + "timestamp": 1575415377015, + "version": "0.14.1" + }, + "jedi-0.15.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5f94de9eadd70abfd0ec54920505e2a", + "name": "jedi", + "sha256": "74b72a4f07fc20c5714eb16f09c681e49d9957e63586b315468462adb8d9fecb", + "size": 714152, + "subdir": "linux-64", + "timestamp": 1565957055936, + "version": "0.15.1" + }, + "jedi-0.15.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31ac9a2500f74cd5fb492879715060ea", + "name": "jedi", + "sha256": "22c37244776ea83c710badd6f34939a8e28700d5658abd7110ec71f2724427ce", + "size": 715452, + "subdir": "linux-64", + "timestamp": 1565957154975, + "version": "0.15.1" + }, + "jedi-0.15.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce86c34befb8ad0f80a4f36f15170b54", + "name": "jedi", + "sha256": "b1f844c0e957e78ce4b52cd49730ff5936ba4fe45460ef6943fa527e6226751c", + "size": 721012, + "subdir": "linux-64", + "timestamp": 1565957079630, + "version": "0.15.1" + }, + "jedi-0.15.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4a47f80291efd40da179ed9b07f59fb", + "name": "jedi", + "sha256": "875b20dd6d202e5e83156e62b5567db5c0b9cd63959f05da8245c63d9cf3800f", + "size": 718947, + "subdir": "linux-64", + "timestamp": 1573469701161, + "version": "0.15.1" + }, + "jedi-0.15.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0640731410e4311e633e905b981e8ae4", + "name": "jedi", + "sha256": "4cbed9efd7107869a14a79f6b183a528503710d1a3bbd8ba9dce2dc27cd5229b", + "size": 752102, + "subdir": "linux-64", + "timestamp": 1578412349295, + "version": "0.15.2" + }, + "jedi-0.15.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "78f9473590a31e01cc7b57724c99e6a5", + "name": "jedi", + "sha256": "ae74f9a4e3b03abdbe9be67225a30bb92fcb353a6893a64f89b163dbbd8d17e5", + "size": 755329, + "subdir": "linux-64", + "timestamp": 1578412357813, + "version": "0.15.2" + }, + "jedi-0.15.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ee87d6fb238432f4f0c3a109519e1a3", + "name": "jedi", + "sha256": "9662b309bc1319c15d0965eb7de4af25fe8ed0e6b562654aa517f225ba11ee3f", + "size": 760383, + "subdir": "linux-64", + "timestamp": 1578412340302, + "version": "0.15.2" + }, + "jedi-0.15.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3615fb1ce471c325946a444262787498", + "name": "jedi", + "sha256": "5b132cfc782a5b1ff2aa4a205fcd769058453db3476ad41fdf6d009eae501bc1", + "size": 761353, + "subdir": "linux-64", + "timestamp": 1578412340906, + "version": "0.15.2" + }, + "jedi-0.16.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7df8389422e83edf16c0cfe740c7c1e2", + "name": "jedi", + "sha256": "69a7aa993561221d385c975672d9a3d5cc9606de34a915254030598777d0adb1", + "size": 775381, + "subdir": "linux-64", + "timestamp": 1580150723998, + "version": "0.16.0" + }, + "jedi-0.16.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "parso >=0.5.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47f66c636259e0ebfcae5345d80b9c78", + "name": "jedi", + "sha256": "b46795e36720d2b56cc27912a22bb3559e2cfcdc325297b6b97706f023c7244b", + "size": 779179, + "subdir": "linux-64", + "timestamp": 1585135569560, + "version": "0.16.0" + }, + "jedi-0.16.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d2ffeee68872f3f8e12aa66bed25cfa", + "name": "jedi", + "sha256": "63539b6c283f4d1ed3aa1c19b557de045aa0ff3b8169b3f8c7492a79f2b566cc", + "size": 779251, + "subdir": "linux-64", + "timestamp": 1580150575183, + "version": "0.16.0" + }, + "jedi-0.16.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "parso >=0.5.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff8e08b97043ca804f4fbc9634ce30d7", + "name": "jedi", + "sha256": "802c8a42f9aa6fa3c7ced86537ddcbcebecf903bfa716bbb9b281d5464ff4299", + "size": 778876, + "subdir": "linux-64", + "timestamp": 1585135563743, + "version": "0.16.0" + }, + "jedi-0.16.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "parso >=0.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e1b7ddac08d03dc0f844091f44b954f", + "name": "jedi", + "sha256": "8c6bb72fea06de2594ad7488fb67287799b50af8f214090ca8530223523048e0", + "size": 775140, + "subdir": "linux-64", + "timestamp": 1580150697828, + "version": "0.16.0" + }, + "jedi-0.16.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "parso >=0.5.2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "215f6f72958b886240b6c05b39ddf766", + "name": "jedi", + "sha256": "5692f73c767d642a483bd6319b813bf89f581ba233b7e7318be0903741a563ad", + "size": 780298, + "subdir": "linux-64", + "timestamp": 1585135588633, + "version": "0.16.0" + }, + "jedi-0.17.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "03400149122ed9398a930a07cb69f5f8", + "name": "jedi", + "sha256": "a1d0b722a7ae14a1132ee3b858a3e7810fe96afa57f896a4132b15d677b97309", + "size": 798463, + "subdir": "linux-64", + "timestamp": 1588278615673, + "version": "0.17.0" + }, + "jedi-0.17.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "41546dc084b6b369d7512fac6793e9b8", + "name": "jedi", + "sha256": "7b0b320161130aa9ee8e27c2fe2d2189dbf071106968f643aff5e7a3a50fe86b", + "size": 793612, + "subdir": "linux-64", + "timestamp": 1588278584242, + "version": "0.17.0" + }, + "jedi-0.17.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8dbf0ef973c55615580ef586387dca1", + "name": "jedi", + "sha256": "16d83aaa1d6fae5b459ec1d659ddfabdad2d5d54c7f75ac39975d14748f4d332", + "size": 798867, + "subdir": "linux-64", + "timestamp": 1588278612377, + "version": "0.17.0" + }, + "jedi-0.17.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5848f0a416d3102c3d2b3f76461c504f", + "name": "jedi", + "sha256": "f333fb13cb96f04737bf41f6efad3c0d8c89ec7c1e73b25eff5c60103df8a1ce", + "size": 942988, + "subdir": "linux-64", + "timestamp": 1592841949873, + "version": "0.17.1" + }, + "jedi-0.17.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d08af912e28959e902b40fe1847250e", + "name": "jedi", + "sha256": "a8a26a27739cc4bd26318f9c0dfcd066b6fe97db4b62eaebc629d433c7f6b2d1", + "size": 942898, + "subdir": "linux-64", + "timestamp": 1592841924909, + "version": "0.17.1" + }, + "jedi-0.17.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3809ad12523258a8b9fdab096498da63", + "name": "jedi", + "sha256": "428c97e15f0c49c49c3d53ecef01eec8b96313adbbe44d21dfa7eec4a6d47859", + "size": 945671, + "subdir": "linux-64", + "timestamp": 1592841910536, + "version": "0.17.1" + }, + "jedi-0.17.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "20c62fe2c8934231ff656014a4ae32ec", + "name": "jedi", + "sha256": "3fd3d179cea08bcad580013581699916e5581c6d1c6f6828dae2cb4f55f26e8d", + "size": 938481, + "subdir": "linux-64", + "timestamp": 1598371660772, + "version": "0.17.2" + }, + "jedi-0.17.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dcd984c2f89df95ba96dff4a6ed51c64", + "name": "jedi", + "sha256": "3d5ecab4d5649455e2145dff3599cc31aa27f421a993d0319c60f0eb3095a4ae", + "size": 941292, + "subdir": "linux-64", + "timestamp": 1606932616049, + "version": "0.17.2" + }, + "jedi-0.17.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01af093d381a71881ba4b769577eab55", + "name": "jedi", + "sha256": "fe99741ccb9b411a5c7c142e40f42708c5a230a315b15a5a3a72c3c591f170b5", + "size": 933532, + "subdir": "linux-64", + "timestamp": 1596490780717, + "version": "0.17.2" + }, + "jedi-0.17.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b55d78ac3c8b517eaf64d38e89b30942", + "name": "jedi", + "sha256": "99c654ba57be46c485b829db033e8d9ca7a314e7d76b9a7524972743b74ade15", + "size": 939673, + "subdir": "linux-64", + "timestamp": 1606932595287, + "version": "0.17.2" + }, + "jedi-0.17.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bba03494e0d3b6cb39d76e4c758adba5", + "name": "jedi", + "sha256": "5f310daac964555807035fdade20f7c67600d08e045df466ffe07bdcf39cdd15", + "size": 941310, + "subdir": "linux-64", + "timestamp": 1598371708046, + "version": "0.17.2" + }, + "jedi-0.17.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a0db923daa3be552146008ec4c4951a", + "name": "jedi", + "sha256": "7a1d438f290939ac478c84f55274fcb4a29b70a551a8d77ff74936dd8138cf29", + "size": 945695, + "subdir": "linux-64", + "timestamp": 1606932606482, + "version": "0.17.2" + }, + "jedi-0.17.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1cbbd80a1d60b73da62ddf594928f35", + "name": "jedi", + "sha256": "9e8cf5f5cc16b0d2cd03131d0e015b4c36266b1e4862283aaf3a7cbde7ca7d5c", + "size": 947692, + "subdir": "linux-64", + "timestamp": 1606932608161, + "version": "0.17.2" + }, + "jedi-0.18.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "423c7cf5badaa527a00e3ab540c8859b", + "name": "jedi", + "sha256": "e7bdacbe34701f03cd2cb26a985583e3f502174d3b1a11feecfe7eb98c0f5d4c", + "size": 933359, + "subdir": "linux-64", + "timestamp": 1641919232989, + "version": "0.18.0" + }, + "jedi-0.18.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e99a47cc9f2c99cb00eb5f06c2e1f95", + "name": "jedi", + "sha256": "6bdc805e73a79687fe428cae31c161978a100125f16a85e6072af8c27b1479f9", + "size": 926252, + "subdir": "linux-64", + "timestamp": 1608920763380, + "version": "0.18.0" + }, + "jedi-0.18.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e04f8b8b0e0989243aca73b9172b07c1", + "name": "jedi", + "sha256": "a384c25e42871035d05bc6974f1f7bf5fe1e84a90fd67751aff2cef5366c899c", + "size": 930695, + "subdir": "linux-64", + "timestamp": 1611333791626, + "version": "0.18.0" + }, + "jedi-0.18.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c9851971e193eef2c0825287f8aae39a", + "name": "jedi", + "sha256": "55fdf4cdea4c3ec747e257f2ff48d7ae32079fba177f3425e16d5a941d58140b", + "size": 924828, + "subdir": "linux-64", + "timestamp": 1608920731822, + "version": "0.18.0" + }, + "jedi-0.18.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a4fff6f3ff8b8d9393c3ab7567b5d584", + "name": "jedi", + "sha256": "3cddaefd13f56851a25d99fae01f3a7c1ae589a0df4fc0dbdd12668ba58de504", + "size": 932591, + "subdir": "linux-64", + "timestamp": 1611333797020, + "version": "0.18.0" + }, + "jedi-0.18.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4b2cd27250e454798c214394f9aaacd", + "name": "jedi", + "sha256": "67f2c68752384759c545a87f99628a0e56ea0a9e204886f68919408baf699ea6", + "size": 925713, + "subdir": "linux-64", + "timestamp": 1608920752427, + "version": "0.18.0" + }, + "jedi-0.18.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f4e346aa60a82d8a3ae8548533129d21", + "name": "jedi", + "sha256": "644f702975ccfbf7e05d81501332661c5857a5999d3c27bb965f1edd7337bd63", + "size": 933287, + "subdir": "linux-64", + "timestamp": 1611333166324, + "version": "0.18.0" + }, + "jedi-0.18.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "parso >=0.7.0,<0.8.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b7b4978924dce8fdc552c74f31e02d2", + "name": "jedi", + "sha256": "3f777bf79a13b3f6a3fb24d2c060174181d7bfa042e06f9ab53ab2dcad3b0079", + "size": 929809, + "subdir": "linux-64", + "timestamp": 1608920764545, + "version": "0.18.0" + }, + "jedi-0.18.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a06adcf5a40fe50ec153cf547bf0e604", + "name": "jedi", + "sha256": "4ac1699a81f4d804e6882dc3237cfafef3e870d271cb198b15886250475d2f87", + "size": 933743, + "subdir": "linux-64", + "timestamp": 1611333804528, + "version": "0.18.0" + }, + "jedi-0.18.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c60111a48386f3741f711f97e8d293c4", + "name": "jedi", + "sha256": "ddbb1f24575eb8c7a4e3c6127ba29d7f17426aa4f18c41f21d3923120848899f", + "size": 1011885, + "subdir": "linux-64", + "timestamp": 1644315282525, + "version": "0.18.1" + }, + "jedi-0.18.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f09e3efb72d6fcd03fceed140f23bf7", + "name": "jedi", + "sha256": "61162e739961f288fb93d8085ef651badd2f1400077aea1e118fe73ee45b5b90", + "size": 1158434, + "subdir": "linux-64", + "timestamp": 1676823821205, + "version": "0.18.1" + }, + "jedi-0.18.1-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83b2d5fe74d8b0c3bcbcfe3d12bb239c", + "name": "jedi", + "sha256": "b0f76316e06f109b8a74f6511791f6b80cba9af820726fb441592f967859c3a1", + "size": 1160030, + "subdir": "linux-64", + "timestamp": 1679336523618, + "version": "0.18.1" + }, + "jedi-0.18.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "55447dba18046e11d31c1fc545e47592", + "name": "jedi", + "sha256": "1cbf83fe0294ef708a56db66cc7562f1995fa44d8ac7606cff3c1c9f11e71603", + "size": 993653, + "subdir": "linux-64", + "timestamp": 1642692294657, + "version": "0.18.1" + }, + "jedi-0.18.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa8df9c2969f8b6859d1bbb306a9f0a8", + "name": "jedi", + "sha256": "d4870462d605a762ea962753aa26442d7a882d30cfa7e431f0089ea2a0db9f2f", + "size": 1003017, + "subdir": "linux-64", + "timestamp": 1644299065124, + "version": "0.18.1" + }, + "jedi-0.18.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e80732d641469269bc94cd409e70bff6", + "name": "jedi", + "sha256": "3250d64941275f5b0dbd7099bd8e1518e276b0ca370cfd3a53577bce62a4e14e", + "size": 995984, + "subdir": "linux-64", + "timestamp": 1642692219238, + "version": "0.18.1" + }, + "jedi-0.18.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d3629035a1f2c61553814cc20fa2ec11", + "name": "jedi", + "sha256": "dbc80eefca61dbdebe1d1de77f51894d4f797531261e3d90d81e49feae21594f", + "size": 1005573, + "subdir": "linux-64", + "timestamp": 1644315273267, + "version": "0.18.1" + }, + "jedi-0.18.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17f7a9b2fc410fbdd90e142975c0af48", + "name": "jedi", + "sha256": "fdf6221c2f62ecdac5b29bb17aa4a28ef026203f06407d489613b520bf06c73d", + "size": 995453, + "subdir": "linux-64", + "timestamp": 1642692260138, + "version": "0.18.1" + }, + "jedi-0.18.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "parso >=0.8.0,<0.9.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4c1857649c14e8d5a3f6bb022cefda7e", + "name": "jedi", + "sha256": "8c2208e78b00f79559fd308815f73b0d550363dd4448f1d8429bbf235cc7fc6f", + "size": 1005264, + "subdir": "linux-64", + "timestamp": 1644297140650, + "version": "0.18.1" + }, + "jeepney-0.3.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bdf29916c1ccd6a5a51ef86c240903d1", + "name": "jeepney", + "sha256": "824ee6bdda747d1639ee55581f1c1b31568814eb8df92aac03e23c93e8143595", + "size": 38771, + "subdir": "linux-64", + "timestamp": 1529952896194, + "version": "0.3.1" + }, + "jeepney-0.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "705a6aeef079a488eea36257908f242f", + "name": "jeepney", + "sha256": "bc6739ae9c7fd5d79c88c42c92c7285410d347beb4ca7e5e677194cc9ac524ac", + "size": 38384, + "subdir": "linux-64", + "timestamp": 1529952854702, + "version": "0.3.1" + }, + "jeepney-0.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f180ab6b46fc22efc5e2321aeee6ec12", + "name": "jeepney", + "sha256": "2aea2047f4aece22ffbfb957992188957944fcb2a7466d609961bb732427c290", + "size": 38303, + "subdir": "linux-64", + "timestamp": 1530898151273, + "version": "0.3.1" + }, + "jeepney-0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c918998a161947ada4cb14c978299e04", + "name": "jeepney", + "sha256": "155439c7a55165dd0f4a283e1ba5fc6bf436a91c53fee79e58e012f106610006", + "size": 40202, + "subdir": "linux-64", + "timestamp": 1538366583168, + "version": "0.4" + }, + "jeepney-0.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "860d7cfed6b5619f18ff73bc7595bc07", + "name": "jeepney", + "sha256": "3711b526a42cf701b4a1fbc635d75d9bbc4b520911cd9478ab6ddb48ed0b7a3e", + "size": 40308, + "subdir": "linux-64", + "timestamp": 1538366552165, + "version": "0.4" + }, + "jellyfish-0.9.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "67e2430f4720e8954f57772661c688aa", + "name": "jellyfish", + "sha256": "eec5a1618eedfcd313473d40eaec4b82c78da82ab4659e751a87d62af9922d21", + "size": 79559, + "subdir": "linux-64", + "timestamp": 1647944479821, + "version": "0.9.0" + }, + "jellyfish-0.9.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b8b32055b136dee0451f358776a3ab5b", + "name": "jellyfish", + "sha256": "0cc2a42cd46782b31fa91e53d9048a6803894876f420770efcf380a2c0bebafa", + "size": 45807, + "subdir": "linux-64", + "timestamp": 1676844363764, + "version": "0.9.0" + }, + "jellyfish-0.9.0-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c6ca701f42a8ae319e1da62a8666f899", + "name": "jellyfish", + "sha256": "292fce3667eb17a5037cbfc7093f5763accf2cce4dceec6f75dcf0fc00eab2dc", + "size": 42632, + "subdir": "linux-64", + "timestamp": 1647944732093, + "version": "0.9.0" + }, + "jellyfish-0.9.0-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "197bd9aa17fc7e85068d214aefb08cb0", + "name": "jellyfish", + "sha256": "f79c3c34c87d964ac5d629c92e9771fe3d6283092288709533d055244ab0cd63", + "size": 42927, + "subdir": "linux-64", + "timestamp": 1647962586771, + "version": "0.9.0" + }, + "jellyfish-0.9.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "0ef51febd2eae3c1fcce654c4ecc11c6", + "name": "jellyfish", + "sha256": "aebe86df2c8c9f37db68bf9836f9d113fe291b9977cb12b63ad485ab9562846b", + "size": 43022, + "subdir": "linux-64", + "timestamp": 1647944464758, + "version": "0.9.0" + }, + "jemalloc-5.0.1-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 2-Clause", + "md5": "019ee51f6260ef8d1108e5df4b3df0da", + "name": "jemalloc", + "sha256": "ad84f5ad375ff28b1076cd870ff5aaf6d5247b5eb18e9e33a71ef46b3f1e670c", + "size": 5697305, + "subdir": "linux-64", + "timestamp": 1514580884546, + "version": "5.0.1" + }, + "jemalloc-5.0.1-hf484d3e_1.conda": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 2-Clause", + "md5": "636247971ec383c8ffeb5aebbfc72540", + "name": "jemalloc", + "sha256": "cea48f90bc1618cf79697f36a637b4ded613a85789ded76daf0c5b846e330ede", + "size": 5645329, + "subdir": "linux-64", + "timestamp": 1514725114781, + "version": "5.0.1" + }, + "jemalloc-5.2.1-h2531618_5.conda": { + "build": "h2531618_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "md5": "2be813309541b453a2d8f95de4495caf", + "name": "jemalloc", + "sha256": "d35bbc9e59bab62b6aed5ec145c05cf44ad965f72a216d86e4fcfc03a8b97ccf", + "size": 1065284, + "subdir": "linux-64", + "timestamp": 1619184855594, + "version": "5.2.1" + }, + "jemalloc-5.2.1-h6a678d5_6.conda": { + "build": "h6a678d5_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ade8d51389134dc8d000e69c512825f7", + "name": "jemalloc", + "sha256": "a1f29b3fcfa3244a10afd56e66350c87eb4ff4d534e9cd84d5bff9150ea2b57c", + "size": 1376805, + "subdir": "linux-64", + "timestamp": 1678115311319, + "version": "5.2.1" + }, + "jinja2-2.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "9f45d2fa1ef1ea1e2b6e75bfbd4d6b26", + "name": "jinja2", + "sha256": "d0ef38b00ab82f38082a5fa6af795b5d4125f06107a8c0ac60d5fea26e6d912e", + "size": 191618, + "subdir": "linux-64", + "timestamp": 1530695459930, + "version": "2.10" + }, + "jinja2-2.10-py27h4114e70_0.conda": { + "build": "py27h4114e70_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "988e363f3fa4ccbbb416375f5aae2d7f", + "name": "jinja2", + "sha256": "f3411960deec54fd9044d3c32ad34014f5e4c2b40d80ef1c1e16ceb0b901dd06", + "size": 189416, + "subdir": "linux-64", + "timestamp": 1512041847443, + "version": "2.10" + }, + "jinja2-2.10-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "ec14ab767229d09e9ab07e3515f06307", + "name": "jinja2", + "sha256": "c1c65cc72a96b76938f8ef7f25faaad233904a8d5a9ee48c1963c012b8395565", + "size": 194383, + "subdir": "linux-64", + "timestamp": 1534345527196, + "version": "2.10" + }, + "jinja2-2.10-py35h480ab6d_0.conda": { + "build": "py35h480ab6d_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "0fd899ebf07fe107c8d09ea69742447b", + "name": "jinja2", + "sha256": "b5b736259d3c20771888e656c88ff1c8777a33524041e2bcfd67d9b2a27d87db", + "size": 194792, + "subdir": "linux-64", + "timestamp": 1512041875277, + "version": "2.10" + }, + "jinja2-2.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "7e89aa34a1b86e69f30a648bd03c6622", + "name": "jinja2", + "sha256": "5ff6a9313d2cb547ac977518b11edd24db5e6def4630fcdf340ebd3da6f2dcb4", + "size": 193084, + "subdir": "linux-64", + "timestamp": 1530695417666, + "version": "2.10" + }, + "jinja2-2.10-py36ha16c418_0.conda": { + "build": "py36ha16c418_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "247acd0d3056251d924bcf24cfbb68ee", + "name": "jinja2", + "sha256": "f5c78198a43ba1fa296e5239ca32c8b96a0247588482141ff205e59aeadad64a", + "size": 196144, + "subdir": "linux-64", + "timestamp": 1512041876307, + "version": "2.10" + }, + "jinja2-2.10-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "ca365aa2e8e34f1e638f9908d1ffb1a7", + "name": "jinja2", + "sha256": "d75a5803aa7a2079ca18d4680ffb850fdaa742a256692791cdaebc4d79b54520", + "size": 192946, + "subdir": "linux-64", + "timestamp": 1530695439574, + "version": "2.10" + }, + "jinja2-2.10.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "83e0a99ab410a207ff2256abbff72bf7", + "name": "jinja2", + "sha256": "4c6f7b437577701acfe96cbcc25278d076837d749802ba2700c8a7a3c82f4779", + "size": 193234, + "subdir": "linux-64", + "timestamp": 1555082260029, + "version": "2.10.1" + }, + "jinja2-2.10.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "6207f988d0fd2ebd024d6e99fac4a9df", + "name": "jinja2", + "sha256": "61eef088ee7ccba857bae24073da3a6314a850fdb30437fce207c2191ba7321f", + "size": 200034, + "subdir": "linux-64", + "timestamp": 1555082266836, + "version": "2.10.1" + }, + "jinja2-2.10.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.23", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "1f25a9eb0b7db151e2bdb81090e8203c", + "name": "jinja2", + "sha256": "9135ff3c8154ac7547c27fb88b2079c83bfd50b91bb09a4bbdcd557d0c7759f9", + "size": 199839, + "subdir": "linux-64", + "timestamp": 1555082345132, + "version": "2.10.1" + }, + "jinja2-2.9.6-py27h82327ae_1.conda": { + "build": "py27h82327ae_1", + "build_number": 1, + "depends": [ + "markupsafe >=0.23", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "98def3de51778cb82010145b5c767d93", + "name": "jinja2", + "sha256": "5d3b8a75b7d77f4bc378694bd155c4504bbbe36e82ef322cce70df81b7eef861", + "size": 207445, + "subdir": "linux-64", + "timestamp": 1505672379234, + "version": "2.9.6" + }, + "jinja2-2.9.6-py35h90b8645_1.conda": { + "build": "py35h90b8645_1", + "build_number": 1, + "depends": [ + "markupsafe >=0.23", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "73ac03ac77f1df4214a1ea35a55c57d1", + "name": "jinja2", + "sha256": "ad87394efbb4978c7d56cd5025ddcde8d44c7de82d70215fcd9a1a3c0064c691", + "size": 312936, + "subdir": "linux-64", + "timestamp": 1505672392862, + "version": "2.9.6" + }, + "jinja2-2.9.6-py36h489bce4_1.conda": { + "build": "py36h489bce4_1", + "build_number": 1, + "depends": [ + "markupsafe >=0.23", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "3-Clause BSD", + "md5": "fa1afecb631050a85cd6dd250b307f4b", + "name": "jinja2", + "sha256": "3773662676a4b84e1ece238ed42c0d069a35ea3fb2456d50f56766d31459d1e0", + "size": 313693, + "subdir": "linux-64", + "timestamp": 1505672406680, + "version": "2.9.6" + }, + "jinja2-3.1.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f22cc11648fc31b2cebaafed2dd8d5ec", + "name": "jinja2", + "sha256": "1464e3a3cc3eb67f9951c1ef7e8225a1b25b4a5742c1f52a02930f3df2923e7e", + "size": 219690, + "subdir": "linux-64", + "timestamp": 1666908186956, + "version": "3.1.2" + }, + "jinja2-3.1.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1173c148bd36cfc89283992fb37ef859", + "name": "jinja2", + "sha256": "cfee934819348c23c5b61db964430ca971dc04f983c4af7d6870f096ddeac88b", + "size": 301741, + "subdir": "linux-64", + "timestamp": 1676823601235, + "version": "3.1.2" + }, + "jinja2-3.1.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5150b8d17bbee948836922251a8e6a55", + "name": "jinja2", + "sha256": "825b4a4c80f9e333668fc16101a0d01c43f93be6a3c2ae9e94047f872cb044d1", + "size": 214030, + "subdir": "linux-64", + "timestamp": 1666908161286, + "version": "3.1.2" + }, + "jinja2-3.1.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "08038a2028a799f695b6826c076e863f", + "name": "jinja2", + "sha256": "5daf8d2d930ad171275d31bd9dc5c4631c9e5d368c49279579c4b0bbc2015b8d", + "size": 215631, + "subdir": "linux-64", + "timestamp": 1666908237448, + "version": "3.1.2" + }, + "jinja2-3.1.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1ae40578c29a6ed9ca0cf23c89d48fa4", + "name": "jinja2", + "sha256": "c1ad1b431b6dcd013844299e301da8bd5faed9ca9bbbd0695d0fdfeb971b3a09", + "size": 216098, + "subdir": "linux-64", + "timestamp": 1666908212136, + "version": "3.1.2" + }, + "jmespath-0.9.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e3241feb976ff6a8131f4e410e061106", + "name": "jmespath", + "sha256": "59a3149a0c7259a98966faf3fc95091dde44e7e94608ea7cfb5b5a289592f92d", + "size": 37067, + "subdir": "linux-64", + "timestamp": 1530736686119, + "version": "0.9.3" + }, + "jmespath-0.9.3-py27h7df6b23_0.conda": { + "build": "py27h7df6b23_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4dfc2c93f4549efbb891210f88ec4568", + "name": "jmespath", + "sha256": "e1d081fd4d3316e3431fd0cd3a883a7a136b50afe555f3415a74fce03af77b9d", + "size": 37122, + "subdir": "linux-64", + "timestamp": 1505740978273, + "version": "0.9.3" + }, + "jmespath-0.9.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0e2f46d1890e9c1bf2a25d111a99ceff", + "name": "jmespath", + "sha256": "9d17496ee46e9dda8debba30f47aa24750e034b31f0ce0f5005e1428b4563b05", + "size": 38203, + "subdir": "linux-64", + "timestamp": 1534352333374, + "version": "0.9.3" + }, + "jmespath-0.9.3-py35h8a35363_0.conda": { + "build": "py35h8a35363_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "afa1e0316d1f244c52e1182a0e736b58", + "name": "jmespath", + "sha256": "8ad007a70820b57a5d4234f937912388cbe965a10c88e04cfb9bfc548bef1a3d", + "size": 38075, + "subdir": "linux-64", + "timestamp": 1505740990926, + "version": "0.9.3" + }, + "jmespath-0.9.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9d06e9cef498fb041b61eef6e429fd8", + "name": "jmespath", + "sha256": "3b3b59258a8651e3e85eebc98abef876bb4ac2210b85cd29e6a2b33a2953be82", + "size": 37663, + "subdir": "linux-64", + "timestamp": 1530736665109, + "version": "0.9.3" + }, + "jmespath-0.9.3-py36hd3948f9_0.conda": { + "build": "py36hd3948f9_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1834755e7ca01bedd3f083958345681c", + "name": "jmespath", + "sha256": "83888c76ce0ace3c8b397fd4bed8f34dd2d561c52ca6084bc157fbcdb6f90b88", + "size": 37426, + "subdir": "linux-64", + "timestamp": 1505741003574, + "version": "0.9.3" + }, + "jmespath-0.9.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ffb7936d2892afe392bdb9ac3b3ae0ef", + "name": "jmespath", + "sha256": "2f59b8fdf3da490df175e27d145f120db347d7ea3182f72d4c929f7ab91f8ef7", + "size": 37861, + "subdir": "linux-64", + "timestamp": 1530736707235, + "version": "0.9.3" + }, + "joblib-0.12-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6bb50252b84d5520ebf7579d7b165bcb", + "name": "joblib", + "sha256": "840c7027c074394171245ed7f2bf08cfc0ef826e6de2888a368d7133e825d518", + "size": 322914, + "subdir": "linux-64", + "timestamp": 1529943845096, + "version": "0.12" + }, + "joblib-0.12-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "74ac72b0b4f93b9a174133f6751c1844", + "name": "joblib", + "sha256": "39832dd54dd0de692e5d39d0a74141e18b37c6f48cc4db65f4dec9ab3f47670b", + "size": 327150, + "subdir": "linux-64", + "timestamp": 1529943876472, + "version": "0.12" + }, + "joblib-0.12-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ca3446c0fb0966ee30c25c572b9c1c9a", + "name": "joblib", + "sha256": "4ff213247be8b1e2d569c10c593813c369bf359305b917e1dc9ede7d18d84663", + "size": 320377, + "subdir": "linux-64", + "timestamp": 1529943818226, + "version": "0.12" + }, + "joblib-0.12-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "63117e1db6782c382904dee3fd2161a1", + "name": "joblib", + "sha256": "cca90638a0c90e8658dce6759408f2391518c5267e54bf7684aaf17e96fd5037", + "size": 324603, + "subdir": "linux-64", + "timestamp": 1530902811876, + "version": "0.12" + }, + "joblib-0.12.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "66a949f6462805e025a11cf6944dbecb", + "name": "joblib", + "sha256": "b623ab1d019479afa807fe1e511c8778d26a1936ecea566c33630cd13e45d595", + "size": 319169, + "subdir": "linux-64", + "timestamp": 1532534652266, + "version": "0.12.1" + }, + "joblib-0.12.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c98353e405d96757f4a5dc5f57b4895a", + "name": "joblib", + "sha256": "c5d715249d33b5b1c00851ddb408eecf6264fca6d7732fe3954fb55c3776f5f8", + "size": 327852, + "subdir": "linux-64", + "timestamp": 1532534643190, + "version": "0.12.1" + }, + "joblib-0.12.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7e7872a274e4617a942be6b9c3bb7889", + "name": "joblib", + "sha256": "5ad6c6bba295ffdb8beb0d01653c45397f06723ca1cb71b15e1113bbd0a6126c", + "size": 325059, + "subdir": "linux-64", + "timestamp": 1532534633711, + "version": "0.12.1" + }, + "joblib-0.12.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d5a33a731516d6aa77b561b95359937f", + "name": "joblib", + "sha256": "b7a75c7095066d858fd6fa303aaee6a82def13883502f013f01a767f8b5094cc", + "size": 324887, + "subdir": "linux-64", + "timestamp": 1532534672781, + "version": "0.12.1" + }, + "joblib-0.12.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "12d5e505b098b17d35ff2aca6b484654", + "name": "joblib", + "sha256": "9d7622c9c4f4abdc2347022b2eb31453a08a015f47db5793563b660531ce4878", + "size": 325894, + "subdir": "linux-64", + "timestamp": 1534173012149, + "version": "0.12.2" + }, + "joblib-0.12.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a76c09b8b08cbaac21cedce1ba22ee63", + "name": "joblib", + "sha256": "7caa9097e8a94ee5318bba52a79f0f328fdc7a7c00360bad75f43accf0f4c40a", + "size": 334678, + "subdir": "linux-64", + "timestamp": 1534173069792, + "version": "0.12.2" + }, + "joblib-0.12.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7614edd663cf0a45cf8f5f6a6d389331", + "name": "joblib", + "sha256": "2212f773f2608e7d26fe8af0d0dd9b9a2879cad23cb91d9ab361b50fc040002f", + "size": 327688, + "subdir": "linux-64", + "timestamp": 1534173021003, + "version": "0.12.2" + }, + "joblib-0.12.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "98dcb1e794a26d201b1adf7625658e31", + "name": "joblib", + "sha256": "74d72cd473cfd2de53bc7211203be28df50196b5be40641eeb84c886502cca19", + "size": 327764, + "subdir": "linux-64", + "timestamp": 1534173049988, + "version": "0.12.2" + }, + "joblib-0.12.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0c9271dc491513b44a216ab335f84cc3", + "name": "joblib", + "sha256": "a48e705c471d965e6ee448b7f339f9bf7fe0128064d5d7b76bc847f8ec166ae0", + "size": 335653, + "subdir": "linux-64", + "timestamp": 1536102440140, + "version": "0.12.3" + }, + "joblib-0.12.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5650307f7df59e876755e42dac07824d", + "name": "joblib", + "sha256": "728c2eef14145319e82904a218f2706a1263632b6ed655f92fb2f2d5cd280c49", + "size": 336915, + "subdir": "linux-64", + "timestamp": 1536102454857, + "version": "0.12.3" + }, + "joblib-0.12.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "eea9b952a364147023095ea46ea1e0b7", + "name": "joblib", + "sha256": "1c09e0fd137b866b1a8a8c7a1149dcc32786370a1ab83b41cf1a9397e9a8b7bc", + "size": 337983, + "subdir": "linux-64", + "timestamp": 1536102411723, + "version": "0.12.3" + }, + "joblib-0.12.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c5c84e8d012c357ac8bd312e42ca4f5f", + "name": "joblib", + "sha256": "0b9526a808b1447d39ce30ee490705d13674b5ce820ca86832be7e7271ba8ea2", + "size": 338028, + "subdir": "linux-64", + "timestamp": 1536102446763, + "version": "0.12.3" + }, + "joblib-0.12.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bc364ae133a9a6c1b80221409ac9a2fd", + "name": "joblib", + "sha256": "0feb69aef3c17acf65af541b61619c0da66811f5faf22265cad5b0ab21da3d73", + "size": 337251, + "subdir": "linux-64", + "timestamp": 1538176661770, + "version": "0.12.5" + }, + "joblib-0.12.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "aa5a9a870c3580155b4095f7de354e43", + "name": "joblib", + "sha256": "c037317daafab5543c53dd296ad6071d757b8a2584cac9e451c746192e787fea", + "size": 339927, + "subdir": "linux-64", + "timestamp": 1538176695132, + "version": "0.12.5" + }, + "joblib-0.12.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "77085e9a816423b0ab603757f719217e", + "name": "joblib", + "sha256": "cae851f2630478d99aae504edc6bd13513aeb8154d62b4f5980b82bf85fd0901", + "size": 339885, + "subdir": "linux-64", + "timestamp": 1538176659260, + "version": "0.12.5" + }, + "joblib-0.13.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "85d8b4751ff6dc2a2875bdf34c79d7d7", + "name": "joblib", + "sha256": "70dd4a8bccfa0e2939dd10acb8fd6d14a702fd2e68b9a73ee040ab5906524b9d", + "size": 342156, + "subdir": "linux-64", + "timestamp": 1542080129057, + "version": "0.13.0" + }, + "joblib-0.13.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "61b37114f6f446a37e36476d94f8a0f9", + "name": "joblib", + "sha256": "d84f4e660dbb5504753423eb3d420302b330af449e4a2f9a5631da8863e69048", + "size": 340642, + "subdir": "linux-64", + "timestamp": 1542080111898, + "version": "0.13.0" + }, + "joblib-0.13.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9455ec192edc985acaf999bfd5be081a", + "name": "joblib", + "sha256": "bc954ec236de8d7bad3d8c713276997883a3e3295e3aa5a74e285b8956f3935b", + "size": 344466, + "subdir": "linux-64", + "timestamp": 1542080110819, + "version": "0.13.0" + }, + "joblib-0.13.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7396a7ac8b0447c19742068770864c8c", + "name": "joblib", + "sha256": "f6abd9bf013f79e206bae535d658a41665b601d31f68bff5276aeb7896a5e160", + "size": 344466, + "subdir": "linux-64", + "timestamp": 1547750057946, + "version": "0.13.1" + }, + "joblib-0.13.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8618fbedb6cb4b8d25b52483278dbbdd", + "name": "joblib", + "sha256": "72bf3f3192c319e51e1d223efb6a9e843394d86148ae7b2d3df7e9245c8b1823", + "size": 346510, + "subdir": "linux-64", + "timestamp": 1547750127437, + "version": "0.13.1" + }, + "joblib-0.13.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0fa003f5361b0339dca6839542ad7592", + "name": "joblib", + "sha256": "3d15b86936885d101974e6a3f5cd6de5c7317a55f81b588ea7248f9b480a8da3", + "size": 346346, + "subdir": "linux-64", + "timestamp": 1547750086026, + "version": "0.13.1" + }, + "joblib-0.13.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "785ffb0e7be2477e3396e344c975f2c1", + "name": "joblib", + "sha256": "a9830011dfd98a4d0c17270ad1b0420773ef1c627234b578d1fb0d6cae267f72", + "size": 349050, + "subdir": "linux-64", + "timestamp": 1550348198201, + "version": "0.13.2" + }, + "joblib-0.13.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c71e58af0f0ef2b0c4819f5e7071040c", + "name": "joblib", + "sha256": "c170e1222636e549c15f18f959df52a30255a0b864e775df7df0684c56252199", + "size": 351267, + "subdir": "linux-64", + "timestamp": 1550348196395, + "version": "0.13.2" + }, + "joblib-0.13.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e75e02805829335c6cd2f409ce6b67b0", + "name": "joblib", + "sha256": "b3111c787f257491544aeefe018be9803f3b8fe7f8a316349c7eaecd5beaea45", + "size": 351099, + "subdir": "linux-64", + "timestamp": 1550348149568, + "version": "0.13.2" + }, + "joblib-1.1.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee38e6a977dac2d8d795bbcf69a6d875", + "name": "joblib", + "sha256": "6e93b9725d0d1b1816b668a3bcef92fb797a4beb42afeedafb4398111f98c9bc", + "size": 395151, + "subdir": "linux-64", + "timestamp": 1666298931868, + "version": "1.1.1" + }, + "joblib-1.1.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f434122fc75e7100c6520f7c77f853e4", + "name": "joblib", + "sha256": "7abb66109256b3a98b2ea5d9e7954d45fecb90fd19229686bbbe11bb1759e6e4", + "size": 524775, + "subdir": "linux-64", + "timestamp": 1676837036611, + "version": "1.1.1" + }, + "joblib-1.1.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c54f1f11e171665b9b126334fb49eab3", + "name": "joblib", + "sha256": "598d50fc7cd5b7318c2ff8b5c5eacba5c40d7ede8e1333750343fe0953484e46", + "size": 388493, + "subdir": "linux-64", + "timestamp": 1666298959625, + "version": "1.1.1" + }, + "joblib-1.1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e655dfc29e36336810c9f69dea37b2de", + "name": "joblib", + "sha256": "bb403897cb8e8ea5f42e98cab8652629b5750dc44e9edcac1bc5c8552c217d63", + "size": 391053, + "subdir": "linux-64", + "timestamp": 1666298876713, + "version": "1.1.1" + }, + "joblib-1.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d97e6009278dd78b1affe356455e984", + "name": "joblib", + "sha256": "abb19f73f9cb4cc43a0732a413df017c4a3ee3926ca24da266130ab10b69d246", + "size": 391364, + "subdir": "linux-64", + "timestamp": 1666298904238, + "version": "1.1.1" + }, + "jpeg-9b-h024ee3a_2.conda": { + "build": "h024ee3a_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "Custom free software license", + "md5": "d8f003a909108eaa4a6d898dacb740f8", + "name": "jpeg", + "sha256": "3771b5c80500813ee442f6360a1453fc32d30e84d9f6ea71ef0c67de1860a0a0", + "size": 219316, + "subdir": "linux-64", + "timestamp": 1510201951443, + "version": "9b" + }, + "jpeg-9b-h376031c_1.conda": { + "build": "h376031c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "Custom free software license", + "md5": "7262f5ee465f71af4e429995c549a391", + "name": "jpeg", + "sha256": "950bfbe07c9286d5748211fa7c1c48a3488b76166f33d61ca62fb2bdc8104f5f", + "size": 219383, + "subdir": "linux-64", + "timestamp": 1509502668308, + "version": "9b" + }, + "jpeg-9b-habf39ab_1.conda": { + "build": "habf39ab_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "Custom free software license", + "md5": "052ec424e232bd863b3908be17a43b8c", + "name": "jpeg", + "sha256": "dd1bda8282d8038a5231326af39031237a0f4c9b0787cf489e97ff1983d2faf0", + "size": 218530, + "subdir": "linux-64", + "timestamp": 1505735527625, + "version": "9b" + }, + "jpeg-9d-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "Custom free software license", + "md5": "28bb4c75a1ef6e3d7100a383a6437318", + "name": "jpeg", + "sha256": "12f0d1ccc91ef8620e095706c0ab5b9d139c19dfa0d506f39deec18a793d9f22", + "size": 238005, + "subdir": "linux-64", + "timestamp": 1631864296647, + "version": "9d" + }, + "jpeg-9e-h5eee18b_1.conda": { + "build": "h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "IJG", + "license_family": "Other", + "md5": "ac373800fda872108412d1ccfe3fa572", + "name": "jpeg", + "sha256": "93c52c384566cf975a928b79563ae6f6cfe369252c6cbeb933dc174429efaa69", + "size": 267801, + "subdir": "linux-64", + "timestamp": 1677849152168, + "version": "9e" + }, + "jpeg-9e-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "IJG", + "license_family": "Other", + "md5": "a0571bd2254b360aef526307a17f3526", + "name": "jpeg", + "sha256": "4a1bc1d3d77df3a4dfc9a6de450e304e7bb2bc7e5a37140352b7497474fbcfe6", + "size": 245748, + "subdir": "linux-64", + "timestamp": 1651065953960, + "version": "9e" + }, + "jpype1-1.0.2-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "md5": "c23ad06ed5aafac0c5e1af2dfb921cc5", + "name": "jpype1", + "sha256": "d5b846bd39b8211cac1083feaccd6d67870651a9ca38051d2cbd0f34af77e5de", + "size": 2039265, + "subdir": "linux-64", + "timestamp": 1601400922437, + "version": "1.0.2" + }, + "jpype1-1.0.2-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "md5": "f119bfe12967f9a564656d6b2971a5e1", + "name": "jpype1", + "sha256": "1752177d903485ecc79baba8888dbb40b272d565d97b160022bcaa16f7accd0c", + "size": 2050685, + "subdir": "linux-64", + "timestamp": 1601400871501, + "version": "1.0.2" + }, + "jpype1-1.0.2-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "fc22f3340e0f271c3025605c9908af99", + "name": "jpype1", + "sha256": "90bf9e2b503df1b42b2d1fe5fcda1d5ce7b0e44c4e24005fdf87ba6f481670f3", + "size": 2045845, + "subdir": "linux-64", + "timestamp": 1601400894345, + "version": "1.0.2" + }, + "jpype1-1.1.2-py36hff7bd54_0.conda": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "md5": "6b0d633ff54aae75b80d7dbc2d3fdc93", + "name": "jpype1", + "sha256": "6048228c57c18953db9346922b1583a46c78d6fef13263a38d5937315b03dd02", + "size": 415771, + "subdir": "linux-64", + "timestamp": 1604013964037, + "version": "1.1.2" + }, + "jpype1-1.1.2-py37hff7bd54_0.conda": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "md5": "74c67d6fe07650981a5521b7395d913a", + "name": "jpype1", + "sha256": "d88515ec69d29fdaa359a0ae7dee3e19b4ec73e8450f7baa2eb71db4ef0194ee", + "size": 413026, + "subdir": "linux-64", + "timestamp": 1604013959343, + "version": "1.1.2" + }, + "jpype1-1.1.2-py38hff7bd54_0.conda": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "3308ff130aded1751dfc5932ab2f1e2a", + "name": "jpype1", + "sha256": "2a4d4441545c06e098e295b6462a2904a34bc7bc21f668ee05d8c3bfa12efbc0", + "size": 418163, + "subdir": "linux-64", + "timestamp": 1604013989703, + "version": "1.1.2" + }, + "jpype1-1.2.1-py36hff7bd54_0.conda": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "md5": "7d5baf56e35d1bfec686007d43e177ba", + "name": "jpype1", + "sha256": "9bb3e30a9c514e9ff18add9a7ab9c13db4463a7ab4d9146df4efb64492e7f476", + "size": 422964, + "subdir": "linux-64", + "timestamp": 1609785231179, + "version": "1.2.1" + }, + "jpype1-1.2.1-py37hff7bd54_0.conda": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "md5": "cae27671daa6f54be614c427869af2fd", + "name": "jpype1", + "sha256": "1fb43dec290921148b0beb493c7b5bbe6f3d3d4ac670486e8cb256734c872a04", + "size": 420426, + "subdir": "linux-64", + "timestamp": 1609785346655, + "version": "1.2.1" + }, + "jpype1-1.2.1-py38hff7bd54_0.conda": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "251c2a2d9aa6d9b7f9fc1a566a660aad", + "name": "jpype1", + "sha256": "67a266f8e651bb71038a1180bbc0a79ecbbd166e77f259017ff91fb861d9e8fd", + "size": 420270, + "subdir": "linux-64", + "timestamp": 1609785317589, + "version": "1.2.1" + }, + "jpype1-1.2.1-py39hff7bd54_0.conda": { + "build": "py39hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "66a974b377334157188df101d179e9df", + "name": "jpype1", + "sha256": "8e79fc7d108a3dc8b039332d4b3fcd59f59e1712967ecd562935a527284fa8b0", + "size": 420730, + "subdir": "linux-64", + "timestamp": 1609785334036, + "version": "1.2.1" + }, + "jpype1-1.3.0-py310hd09550d_0.conda": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "1c9b187f595cc9dfabdc4ccd5afe5650", + "name": "jpype1", + "sha256": "1c32afbfbb0e5838a8e28af5fda7f43b24b46961efbab301f3264797e6a407f8", + "size": 428356, + "subdir": "linux-64", + "timestamp": 1643968732370, + "version": "1.3.0" + }, + "jpype1-1.3.0-py37hd09550d_0.conda": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "md5": "d3bd82b12921bb72175e2269cfeb021c", + "name": "jpype1", + "sha256": "6b114228c7ff29b551c70fb6de6627cc763ab87b19e4d139d917580f456f7901", + "size": 426649, + "subdir": "linux-64", + "timestamp": 1643968653546, + "version": "1.3.0" + }, + "jpype1-1.3.0-py38hd09550d_0.conda": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "124033aac0ff8bb2e72dd8487e31bb8b", + "name": "jpype1", + "sha256": "e48a3ba0146af3bdf9a5c3b6c7b2268b354da490a520230cc2bd7402f4d9d554", + "size": 427566, + "subdir": "linux-64", + "timestamp": 1643968797362, + "version": "1.3.0" + }, + "jpype1-1.3.0-py39hd09550d_0.conda": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "efb57a73776c7fbcb97d2f03acd3e5ea", + "name": "jpype1", + "sha256": "99be80e60d7edc3f871506c5a9263cecf8a661289cb40c1f1e76ca1b2c981080", + "size": 427352, + "subdir": "linux-64", + "timestamp": 1643968866804, + "version": "1.3.0" + }, + "jpype1-1.4.1-py310hdb19cb5_0.conda": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1721ae2f9e342c9847cb59161a54d4ab", + "name": "jpype1", + "sha256": "64d12c59035a9f72b0eaf61d3fd7572b4d47906f9978a62c3fbcf5c854746cb9", + "size": 470722, + "subdir": "linux-64", + "timestamp": 1674515356498, + "version": "1.4.1" + }, + "jpype1-1.4.1-py311hdb19cb5_0.conda": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ffab9c253b80d3bab6362cd04f7ae7cf", + "name": "jpype1", + "sha256": "43cd579c3ef3a39bb79509e099bcb0e11503916f4eba808c34add93d264e1a25", + "size": 461263, + "subdir": "linux-64", + "timestamp": 1676852985424, + "version": "1.4.1" + }, + "jpype1-1.4.1-py37hdb19cb5_0.conda": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ac4ab27e25c718762f474c0cb93bdf76", + "name": "jpype1", + "sha256": "7c84d8470f6b8a3fa2b772c4e798b2d49dc4b925449d5f7ef8800398eac789b9", + "size": 468967, + "subdir": "linux-64", + "timestamp": 1674515420627, + "version": "1.4.1" + }, + "jpype1-1.4.1-py38hdb19cb5_0.conda": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "801abee23a76c6c9cbda3d7cb474f9cb", + "name": "jpype1", + "sha256": "1ca5293f94d7983e67a23651bf85a238d395afe210c1d6bcfce59f6a3990acc3", + "size": 470174, + "subdir": "linux-64", + "timestamp": 1674515227594, + "version": "1.4.1" + }, + "jpype1-1.4.1-py39hdb19cb5_0.conda": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "600ddb8bb204f112f10dede4f9124461", + "name": "jpype1", + "sha256": "3045c7c3e90e082bd733d19f54084c934d7b44ae5a4266fc56ec4d54940c8a01", + "size": 469779, + "subdir": "linux-64", + "timestamp": 1674515291629, + "version": "1.4.1" + }, + "jq-1.6-h27cfd23_1.conda": { + "build": "h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "oniguruma 6.9.*", + "oniguruma >=6.9.3,<6.10.0a0" + ], + "license": "MIT", + "md5": "ca6e88c5049e0741b7868a2af36ed74f", + "name": "jq", + "sha256": "aabe9f73f82f77f3a21e1e2de27737bdfb77be87d4b749bf581fc628c52689ad", + "size": 266335, + "subdir": "linux-64", + "timestamp": 1604748492335, + "version": "1.6" + }, + "jq-1.6-h27cfd23_1000.conda": { + "build": "h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "oniguruma 6.9.*", + "oniguruma >=6.9.3,<6.10.0a0" + ], + "license": "MIT", + "md5": "e3959b747ad5c51cbb8e0c2b0374e9d1", + "name": "jq", + "sha256": "7a51e12510799010b959e88888f2f28b679e9c91960b29715b149dd926fd9af8", + "size": 263415, + "subdir": "linux-64", + "timestamp": 1604335045432, + "version": "1.6" + }, + "js2py-0.71-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pyjsparser >=2.5.1", + "python >=3.10,<3.11.0a0", + "six >=1.10", + "tzlocal >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "986621ba52f1b7aa86de254f009c8952", + "name": "js2py", + "sha256": "2346b95fa787f991659d253e39ae3f2fc4a117e4ba1e717512d51bd6ab0a48c5", + "size": 1510864, + "subdir": "linux-64", + "timestamp": 1663948596274, + "version": "0.71" + }, + "js2py-0.71-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pyjsparser >=2.5.1", + "python >=3.7,<3.8.0a0", + "six >=1.10", + "tzlocal >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ccdcf6adf7cd0ce4da6c135148a51eb5", + "name": "js2py", + "sha256": "0c56edb0c5c4bbda9fb94c05fb60f8eedd173da2ca65eee272b557ae55a5f7b7", + "size": 1461733, + "subdir": "linux-64", + "timestamp": 1663948476181, + "version": "0.71" + }, + "js2py-0.71-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pyjsparser >=2.5.1", + "python >=3.8,<3.9.0a0", + "six >=1.10", + "tzlocal >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b3ad12908846d455d83aad7b512c962", + "name": "js2py", + "sha256": "291831c277aeb19350f532a47e282b859e2a70a692dd552e5b5bf8041853dcf6", + "size": 1469227, + "subdir": "linux-64", + "timestamp": 1663948510716, + "version": "0.71" + }, + "js2py-0.71-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pyjsparser >=2.5.1", + "python >=3.9,<3.10.0a0", + "six >=1.10", + "tzlocal >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d0144b512c6325ef6d358fe821560c2d", + "name": "js2py", + "sha256": "a68074d2cee70e0e5bd280560c3497d3000068eb537c7cffe536040019978a6c", + "size": 1480471, + "subdir": "linux-64", + "timestamp": 1663948546861, + "version": "0.71" + }, + "js2py-0.74-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pyjsparser >=2.5.1", + "python >=3.10,<3.11.0a0", + "six >=1.10", + "tzlocal >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "93fa7c5ebf17b311b4eadebb9770b0a2", + "name": "js2py", + "sha256": "6baa87af387c6379a3eb19428c7a6af43da3be50b50b858aa9aa0f91986a50c2", + "size": 1707217, + "subdir": "linux-64", + "timestamp": 1679573781415, + "version": "0.74" + }, + "js2py-0.74-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pyjsparser >=2.5.1", + "python >=3.11,<3.12.0a0", + "six >=1.10", + "tzlocal >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47cd0776a8714a51e6d177b7261ba5f0", + "name": "js2py", + "sha256": "5a893042f188c9f344c3363eabd6a90558a6a916fc050508b490261e47942a5a", + "size": 2923472, + "subdir": "linux-64", + "timestamp": 1679573677178, + "version": "0.74" + }, + "js2py-0.74-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pyjsparser >=2.5.1", + "python >=3.8,<3.9.0a0", + "six >=1.10", + "tzlocal >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1fae09184eafb9cfce13e9c1803b17d7", + "name": "js2py", + "sha256": "98467d03612ebf0e6b5b6c7ef8a5bd63d27b67dcd6cc44a8746af3dc28995644", + "size": 1666155, + "subdir": "linux-64", + "timestamp": 1679573713578, + "version": "0.74" + }, + "js2py-0.74-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pyjsparser >=2.5.1", + "python >=3.9,<3.10.0a0", + "six >=1.10", + "tzlocal >=1.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16b6202f863d24ab5654c1fa9f737a77", + "name": "js2py", + "sha256": "e9b271c1c55dbb366d48d962c628ba09a932bf34df9c76589ccb75486136fc0d", + "size": 1674306, + "subdir": "linux-64", + "timestamp": 1679573746682, + "version": "0.74" + }, + "json-c-0.12.1-ha6a3662_2.conda": { + "build": "ha6a3662_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "d750c2259ac90faecc54d9bc6a5c381a", + "name": "json-c", + "sha256": "c3f1ba0df2ff4422ea929d84638eef39ded5f172aeb12b0e8249c7fe00c5b858", + "size": 46780, + "subdir": "linux-64", + "timestamp": 1511371612257, + "version": "0.12.1" + }, + "json-c-0.13.1-h1bed415_0.conda": { + "build": "h1bed415_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "0e0ce287e2f81d4d4d1efacd177d1229", + "name": "json-c", + "sha256": "40e53c6f9cf166f5d556eb8164684a176d4e991eb1b94f4b16038548261eb722", + "size": 65811, + "subdir": "linux-64", + "timestamp": 1520912298499, + "version": "0.13.1" + }, + "json-c-0.16-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "65bd539eb8eb5319d79e243829a58f0f", + "name": "json-c", + "sha256": "842aad528502c20a37559718eeac911415b2fd38edd62874cbed37da8f348d51", + "size": 78407, + "subdir": "linux-64", + "timestamp": 1659123696523, + "version": "0.16" + }, + "jsoncpp-1.8.3-h3a67955_0.conda": { + "build": "h3a67955_0", + "build_number": 0, + "depends": [ + "libstdcxx-ng >=7.2.0" + ], + "license": "Public Domain/MIT", + "md5": "b56baaf2b76928b8b68134fc8504a482", + "name": "jsoncpp", + "sha256": "4b5878ae6dea1b7a41deadd542e553b45854394a9a9994614656d854b75b7890", + "size": 133534, + "subdir": "linux-64", + "timestamp": 1508958342092, + "version": "1.8.3" + }, + "jsoncpp-1.8.4-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Public Domain/MIT", + "md5": "17da7d826336263eab3361f24c4206dc", + "name": "jsoncpp", + "sha256": "9037a812b0ecc1f4f402fc8f478fd79f2c4267c8702c5999d6600ccb63f6194b", + "size": 135505, + "subdir": "linux-64", + "timestamp": 1539527206948, + "version": "1.8.4" + }, + "jsoncpp-1.9.4-hff7bd54_0.conda": { + "build": "hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Public Domain/MIT", + "md5": "a90a0ded354dcf53ab36f87e627341b0", + "name": "jsoncpp", + "sha256": "5ed4b9aad4b5826a2b446db9a810bdf1bacf39903367c067bdbd549e8086af8e", + "size": 151949, + "subdir": "linux-64", + "timestamp": 1619131096802, + "version": "1.9.4" + }, + "jsoncpp-1.9.4-hff7bd54_2.conda": { + "build": "hff7bd54_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Public Domain/MIT", + "md5": "861d0859c0e3bdee74e28868c94184ab", + "name": "jsoncpp", + "sha256": "698057486e8340b0f033c3a7ee89c85e5d0b1be8844bb2ad7e5668b3100f05d7", + "size": 153230, + "subdir": "linux-64", + "timestamp": 1619620540210, + "version": "1.9.4" + }, + "jsondate-0.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "caa65ec8eeefff1ecf0845658c864de5", + "name": "jsondate", + "sha256": "33562c32b0989eee100d35116c480e963358a5f3cdb61ec0061394c6c9397e2f", + "size": 8528, + "subdir": "linux-64", + "timestamp": 1530897972899, + "version": "0.1.2" + }, + "jsondate-0.1.2-py27h2933415_0.conda": { + "build": "py27h2933415_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "25df0b77043a5ecb421124091352eea1", + "name": "jsondate", + "sha256": "b03e4204162397795432118049abe8bb132cf40a35f9a04c4cab491410bc13aa", + "size": 8771, + "subdir": "linux-64", + "timestamp": 1509139728161, + "version": "0.1.2" + }, + "jsondate-0.1.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "25f482254c2167efcbd5b395e0900912", + "name": "jsondate", + "sha256": "37f1dee2dec7ff563dd734e3ed4f5febd2570443e035560e6ae1256b0fc86173", + "size": 8915, + "subdir": "linux-64", + "timestamp": 1640791219969, + "version": "0.1.2" + }, + "jsondate-0.1.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85c2cc292d7cd4509cd23ab6b8ec45d1", + "name": "jsondate", + "sha256": "1e3e02455f03a12b83c35bcef35a611f31acd04abfdb7283158cc2aeea2cc692", + "size": 10502, + "subdir": "linux-64", + "timestamp": 1676853001325, + "version": "0.1.2" + }, + "jsondate-0.1.2-py35hde4c474_0.conda": { + "build": "py35hde4c474_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85e8284d1bf9b71cdeb59b77a9639013", + "name": "jsondate", + "sha256": "f871a51b8d052b5560ad9f961d652e1f3fa321fc62b79b65af0008475150a379", + "size": 8923, + "subdir": "linux-64", + "timestamp": 1509139802251, + "version": "0.1.2" + }, + "jsondate-0.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31e7600d3eb193e36e6638dc9eb0ab51", + "name": "jsondate", + "sha256": "c60566bb2d1e4878a0d76655cccc4614dbdf16545aa46e7f09e7aa1d3ebcb1be", + "size": 8608, + "subdir": "linux-64", + "timestamp": 1530898025972, + "version": "0.1.2" + }, + "jsondate-0.1.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "86a226cdcc09d2e6b96d68f2dff58734", + "name": "jsondate", + "sha256": "2a7dee1ebcaeba6788f2911ea09517d9f65d8e1cda0b8924bc882cdc205d9af5", + "size": 9318, + "subdir": "linux-64", + "timestamp": 1614070136078, + "version": "0.1.2" + }, + "jsondate-0.1.2-py36hd087d56_0.conda": { + "build": "py36hd087d56_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2104741f20636f774be895994be88068", + "name": "jsondate", + "sha256": "22d926fc53cfee9e36b1f2b5ed0ebadd14f7cde4b4f5571587fa3644236803ed", + "size": 8839, + "subdir": "linux-64", + "timestamp": 1509139814420, + "version": "0.1.2" + }, + "jsondate-0.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "028460b0df13ddcb276632782344ccaa", + "name": "jsondate", + "sha256": "fa076f71a234e04543281e4d03630a19f5d507aeedf03213c2c17b46b8337cbe", + "size": 8648, + "subdir": "linux-64", + "timestamp": 1530897999335, + "version": "0.1.2" + }, + "jsondate-0.1.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7cd51b83943dca5f7cc9f18ba640488f", + "name": "jsondate", + "sha256": "06fba8c106ba777ec729ac14a27e052d6d9fac81cfdd511ce766616cddd85535", + "size": 9329, + "subdir": "linux-64", + "timestamp": 1614070229965, + "version": "0.1.2" + }, + "jsondate-0.1.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02c23fc34b640811a53a33d454285def", + "name": "jsondate", + "sha256": "64cc29268512b0508b26d8654d75767b8437df5f3169408a8c60c03475ce3406", + "size": 9063, + "subdir": "linux-64", + "timestamp": 1573489732190, + "version": "0.1.2" + }, + "jsondate-0.1.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "654338ef7363025c2158ffae3b6af864", + "name": "jsondate", + "sha256": "680e95a786d021189d242b252f0151250f5e07a0c8bfd19e7be692d970795378", + "size": 9363, + "subdir": "linux-64", + "timestamp": 1614069315232, + "version": "0.1.2" + }, + "jsondate-0.1.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a6bbc26ce0bbed48d04f0065abfa9f9a", + "name": "jsondate", + "sha256": "1355f9dc7b0626ab4280e39d4aed199056d14a3222407c664a6f4b98e8d9f3b2", + "size": 9340, + "subdir": "linux-64", + "timestamp": 1614070246449, + "version": "0.1.2" + }, + "jsondiff-1.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b0b527fe6476a882acd20ca832526d31", + "name": "jsondiff", + "sha256": "6b2b5ee6d381ee1a41d76ab5f7234c725035e18d5ced866f39ae0a929f1a8532", + "size": 16122, + "subdir": "linux-64", + "timestamp": 1543383167096, + "version": "1.1.1" + }, + "jsondiff-1.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9bf9eca6b60d5d3090f885950c993832", + "name": "jsondiff", + "sha256": "327be726522956b9de8687842e3a1b436b14e3445afc4f6a8342eaca8d053ce2", + "size": 16371, + "subdir": "linux-64", + "timestamp": 1543383184061, + "version": "1.1.1" + }, + "jsondiff-1.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0183182087ce29ebbffd0169f87d0ba0", + "name": "jsondiff", + "sha256": "929745203c04efeeb58f26f16e76a904f029f0eef8adc636afcadf085a7558e6", + "size": 16393, + "subdir": "linux-64", + "timestamp": 1543383149370, + "version": "1.1.1" + }, + "jsondiff-1.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52fff989ab38b07b708a14475ca33898", + "name": "jsondiff", + "sha256": "449a1465778066ee4d43d20c4d454a411b093e4a933fe131199d1a24faa1c4a2", + "size": 16475, + "subdir": "linux-64", + "timestamp": 1552437708480, + "version": "1.1.2" + }, + "jsondiff-1.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8bfd061fbdaca6f8ce728f36ab656e1", + "name": "jsondiff", + "sha256": "47b4b0f16c012ba0dffa1bff7d45ce06c103c5552fd71057229b457fb60c3547", + "size": 16707, + "subdir": "linux-64", + "timestamp": 1552437685154, + "version": "1.1.2" + }, + "jsondiff-1.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1420d13456918fc36ef4542a42c96ab9", + "name": "jsondiff", + "sha256": "3a7ac2d3426af700b0227af6aae1634b2e6ea2a7a3855d298757bcf484055745", + "size": 16754, + "subdir": "linux-64", + "timestamp": 1552437776612, + "version": "1.1.2" + }, + "jsonpickle-2.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "94b65e6033576942e13812855aa670da", + "name": "jsonpickle", + "sha256": "97da21b83f90d9302619cf27929e8991ab725ea554fcc7ca349a376659f9afa5", + "size": 63860, + "subdir": "linux-64", + "timestamp": 1659021481631, + "version": "2.2.0" + }, + "jsonpickle-2.2.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8779cf366bdf098895a4d3a3fa6c7cfe", + "name": "jsonpickle", + "sha256": "aefa35009da8a948d63abccf4ee14c85b9d35caad1c37f53e2af3392aae2b36b", + "size": 84257, + "subdir": "linux-64", + "timestamp": 1676853016209, + "version": "2.2.0" + }, + "jsonpickle-2.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ab2aa9129693a53dc7c277431fb1da64", + "name": "jsonpickle", + "sha256": "4e425cae04df466eebfd901f5d2647b8b045e02010f078f6582047ea6bc8d52a", + "size": 63047, + "subdir": "linux-64", + "timestamp": 1659021400367, + "version": "2.2.0" + }, + "jsonpickle-2.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "30fdd902f4bfd9c06d858e7bd3f6fa4c", + "name": "jsonpickle", + "sha256": "3355b2d973d86d0fd392f860e471942c86a730fd99dba160aee7238a8c5b543d", + "size": 63301, + "subdir": "linux-64", + "timestamp": 1659021366097, + "version": "2.2.0" + }, + "jsonpickle-2.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c22578f900a303a245fff3970c020e9d", + "name": "jsonpickle", + "sha256": "d38e2579c9ca585382217a7767c2c1e354fb19ac754ff11e32cf79fdbfeeb944", + "size": 62984, + "subdir": "linux-64", + "timestamp": 1659021433559, + "version": "2.2.0" + }, + "jsonschema-2.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "functools32", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "7e4748cfede9f30e791c1d2f36e8eafc", + "name": "jsonschema", + "sha256": "ed572367f5462b6f64592a485846067dff3792e917c876d1c7874a3778b6d8fe", + "size": 66454, + "subdir": "linux-64", + "timestamp": 1530693972968, + "version": "2.6.0" + }, + "jsonschema-2.6.0-py27h7ed5aa4_0.conda": { + "build": "py27h7ed5aa4_0", + "build_number": 0, + "depends": [ + "functools32", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "3816b32fc23bdf8109b2296e7340b47f", + "name": "jsonschema", + "sha256": "9989fd850f00b1e5e31b0ac3d13fa6a1cdd03cfdbbe51f79c845550afa0d7e19", + "size": 65183, + "subdir": "linux-64", + "timestamp": 1505672201982, + "version": "2.6.0" + }, + "jsonschema-2.6.0-py35h4395190_0.conda": { + "build": "py35h4395190_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "8f650d9da546597bef38c63eb4de9a26", + "name": "jsonschema", + "sha256": "66dd16fa3f3767fd35e9205d39553f6c7f18d2a5a122426938a6543b25ccf97f", + "size": 66091, + "subdir": "linux-64", + "timestamp": 1505672214133, + "version": "2.6.0" + }, + "jsonschema-2.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "b774d9c875c6e5fb937a215e0d0a2b04", + "name": "jsonschema", + "sha256": "61b7059111aa1d5c0ff8da124357062d6ff82ba7f427b6e3c3d607b0fb508bd7", + "size": 66617, + "subdir": "linux-64", + "timestamp": 1530693932134, + "version": "2.6.0" + }, + "jsonschema-2.6.0-py36h006f8b5_0.conda": { + "build": "py36h006f8b5_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "d522f333cc6aca630ce4c54bf34520af", + "name": "jsonschema", + "sha256": "765018e0951fc126b0a393d27352c274d7a0ade803f5fff2c3b89353e325a35e", + "size": 65522, + "subdir": "linux-64", + "timestamp": 1505672226456, + "version": "2.6.0" + }, + "jsonschema-2.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "31156c1a8bb186ca07c38601a486539f", + "name": "jsonschema", + "sha256": "d6d715924a7d5b2b8c96732bde08e553b796ae32a1d90300a22cd60bf796724b", + "size": 65965, + "subdir": "linux-64", + "timestamp": 1530693952933, + "version": "2.6.0" + }, + "jsonschema-3.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "functools32", + "pyrsistent >=0.14.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "90358ffb5411efa698f47e7275ecfe3e", + "name": "jsonschema", + "sha256": "b86ff30fbac252c40ed3432c524b45fe8f4e25942b499855ec82462a64f591f8", + "size": 92045, + "subdir": "linux-64", + "timestamp": 1552335896413, + "version": "3.0.1" + }, + "jsonschema-3.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent >=0.14.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "c4fdbb84aa8e9e556c295a05a3479e67", + "name": "jsonschema", + "sha256": "8cb6db53b55bc72fb1a217297789361289f756aeddaee625609f467c33b3b436", + "size": 92027, + "subdir": "linux-64", + "timestamp": 1552335993372, + "version": "3.0.1" + }, + "jsonschema-3.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent >=0.14.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "4af72d42d79922c2b9acd2692df3cb41", + "name": "jsonschema", + "sha256": "10191761bdc540437152108ac8576802b180a2ea8256c6749077f0e9a9e24527", + "size": 92497, + "subdir": "linux-64", + "timestamp": 1552340741547, + "version": "3.0.1" + }, + "jsonschema-3.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "functools32", + "pyrsistent >=0.14.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "2f84afa6e376bd5b2bfbf43c12208963", + "name": "jsonschema", + "sha256": "396123a6c6c04259457a1dca65feb09a325a43dd327478828aefd86a76fc7c37", + "size": 93145, + "subdir": "linux-64", + "timestamp": 1565957026120, + "version": "3.0.2" + }, + "jsonschema-3.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent >=0.14.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "9576e7db33df39065fc462bd37f8cedf", + "name": "jsonschema", + "sha256": "f3c30ad5c82a0aef5c66eabb6b2a113b93ba696d2742bbb23520390d2567fc74", + "size": 94059, + "subdir": "linux-64", + "timestamp": 1565957034144, + "version": "3.0.2" + }, + "jsonschema-3.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent >=0.14.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "d987d6d9b901a8a22730383788554754", + "name": "jsonschema", + "sha256": "1243e67e77cef8e220857e135ba76e9641bb72634a3ed7910e5ca4687ec1e49d", + "size": 93944, + "subdir": "linux-64", + "timestamp": 1565957057091, + "version": "3.0.2" + }, + "jsonschema-3.0.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "284f15fe35ba067d0705a30aec5a06f2", + "name": "jsonschema", + "sha256": "7528e90c6ae4f85b951dce0d04bfb8167e7907b9e2a270878c23e4ae9116f17c", + "size": 95388, + "subdir": "linux-64", + "timestamp": 1594303840751, + "version": "3.0.2" + }, + "jsonschema-3.0.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent >=0.14.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "d2474c7fbb5a0a98720e260c9a5bab3c", + "name": "jsonschema", + "sha256": "fafd4c587820152a27f4e32adee2e3156aaf93d4988220b0a76b3922cad68f1c", + "size": 96331, + "subdir": "linux-64", + "timestamp": 1608322003951, + "version": "3.0.2" + }, + "jsonschema-3.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "functools32", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "f0b62d8945b133fefe065ef750e40408", + "name": "jsonschema", + "sha256": "5fc271edd3ce3e6fc13cd6def0ad5abd70bd2ffb35d81883a1db6c8171401154", + "size": 95555, + "subdir": "linux-64", + "timestamp": 1571757583344, + "version": "3.1.1" + }, + "jsonschema-3.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "db9ab67d4f9f4cb452104e996feb9650", + "name": "jsonschema", + "sha256": "562f973ff33e59dbfbd3ecff0f759dc84509c05ec3bc84d6ede085da24cf922d", + "size": 96479, + "subdir": "linux-64", + "timestamp": 1571757605489, + "version": "3.1.1" + }, + "jsonschema-3.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "2e49d9a5a0dad2e1de6bc370539c6655", + "name": "jsonschema", + "sha256": "b244071cb4c9753656a16c2b8b102c7772e3c65d87f76458b7ba6f3f088d8b84", + "size": 96764, + "subdir": "linux-64", + "timestamp": 1571757607039, + "version": "3.1.1" + }, + "jsonschema-3.1.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "70db17245289d5877a985005634b6577", + "name": "jsonschema", + "sha256": "cdaf1c1cc454647a6de9f6ea45e55c6f88b18fb2d23f468d61d98b8f341a56f7", + "size": 94802, + "subdir": "linux-64", + "timestamp": 1574158041698, + "version": "3.1.1" + }, + "jsonschema-3.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "functools32", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "c5f12216bbe6adc725bc3c0b9ed98b9e", + "name": "jsonschema", + "sha256": "eceb185a54b8f8cbca730189432f2d18f70c3847a1196809c86f9c3c8eec3fdf", + "size": 96045, + "subdir": "linux-64", + "timestamp": 1574266800104, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.10,<3.11.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "f3a94095396cc72cdc432aeed551ec53", + "name": "jsonschema", + "sha256": "9771c5c2a68bdb8f282feea98012422ab644fe92b22ba99476d2917d30d54c62", + "size": 95030, + "subdir": "linux-64", + "timestamp": 1640878114983, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "1a5967d1f51440fa8f0bca518d635a36", + "name": "jsonschema", + "sha256": "32a26e70c7fbc858f579a9fb978f9260c7783823fc18a559ddd70e278a34c47c", + "size": 97344, + "subdir": "linux-64", + "timestamp": 1574266890507, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "476b303fd5637e6b2154d078ad9dada1", + "name": "jsonschema", + "sha256": "0dc9ddc482d5e15a098e542b8969a3e1620d928b47fc61130b3b1d015cab2181", + "size": 93286, + "subdir": "linux-64", + "timestamp": 1601490641956, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "59c4abd9763e9294a787321b6b1f1775", + "name": "jsonschema", + "sha256": "3f7ae054436626a18b340f022183f56a3653821723613ab7db2e5f6ddfa6c247", + "size": 95726, + "subdir": "linux-64", + "timestamp": 1632891494325, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "6c5c6a539f509cd29c49258171cbfd1d", + "name": "jsonschema", + "sha256": "a71da3b2276128393f617e30264e2356b33c8d85f1e5d8cb3ffe4fddb8d505a8", + "size": 97538, + "subdir": "linux-64", + "timestamp": 1574266775784, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "3935df4e0001b7cff9a77f4bbbed8220", + "name": "jsonschema", + "sha256": "60f4dae1e74f2e323e8bca25ee2d92e48a795199d96c97ff96eda2fc25422382", + "size": 93683, + "subdir": "linux-64", + "timestamp": 1594363581181, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "8e2a0515f08b19354a22cae80a42ee8e", + "name": "jsonschema", + "sha256": "8d6df47575d64ae3e08210e954293c086d112fe53348129786a08a66287d96b4", + "size": 97418, + "subdir": "linux-64", + "timestamp": 1632881032917, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "8c491f8f33feae1aee5b17a4caa0a751", + "name": "jsonschema", + "sha256": "7b1aa27aa907ebe780507ca03e75cd1cdc3bcb6bf08e06aa0c0a65f8ac2b1b0e", + "size": 98451, + "subdir": "linux-64", + "timestamp": 1574266988780, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "8d8d3f60afe5d90a293e905037626a36", + "name": "jsonschema", + "sha256": "64f766c9672e12d1b4af33c9872e6832d8a14a3902c0a20440bab3482765dfc9", + "size": 95120, + "subdir": "linux-64", + "timestamp": 1601490606424, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "c5c9be3015942278ed0b8917e921003e", + "name": "jsonschema", + "sha256": "2f1840d1dc60b63bfad9f918fa67852f997e1f634eadd84beafe56d303bf3b3b", + "size": 98232, + "subdir": "linux-64", + "timestamp": 1632890996816, + "version": "3.2.0" + }, + "jsonschema-3.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "pyrsistent >=0.14.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.11.0" + ], + "license": "MIT", + "md5": "5f646a349a3a7c4fa668d67d318f16ee", + "name": "jsonschema", + "sha256": "74cd824e8f0f48cad296cdde0aa03e672a28c008cab25c551e83f7a12e45fc39", + "size": 98471, + "subdir": "linux-64", + "timestamp": 1632891473678, + "version": "3.2.0" + }, + "jsonschema-4.16.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent !=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "54a56c4925703a909ecd34da30cc1fdf", + "name": "jsonschema", + "sha256": "3e7ce6e35687349721e95bf4d9b30768af2c1033c79b655c2952f71ae5e71234", + "size": 133551, + "subdir": "linux-64", + "timestamp": 1663375614686, + "version": "4.16.0" + }, + "jsonschema-4.16.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "importlib_resources >=1.4.0", + "pkgutil-resolve-name >=1.3.10", + "pyrsistent !=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92224ea9d022402b9eed5aec314c84f3", + "name": "jsonschema", + "sha256": "c06b421c8915d595f70372f2061d5f0d60adea9c2c465c014c37b5de9cdbdf8c", + "size": 129956, + "subdir": "linux-64", + "timestamp": 1663375543814, + "version": "4.16.0" + }, + "jsonschema-4.16.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_resources >=1.4.0", + "pkgutil-resolve-name >=1.3.10", + "pyrsistent !=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f3e37d568511d8ef52f7776f55d5569", + "name": "jsonschema", + "sha256": "f545c678d6240382f09e398f5e260ea2a4d55910bedfe5b0c2658297eae7e406", + "size": 131151, + "subdir": "linux-64", + "timestamp": 1663375513879, + "version": "4.16.0" + }, + "jsonschema-4.16.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent !=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5797b54ed34f8de00269eeb5dd8a967a", + "name": "jsonschema", + "sha256": "47abede9c13d57eef915f3b6f3e37712f2879839f0a1a6c1904f87f7fdb60cc6", + "size": 131597, + "subdir": "linux-64", + "timestamp": 1663375573769, + "version": "4.16.0" + }, + "jsonschema-4.17.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent !=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8c006211bbcd6db1f8b85c6fd1b9c6a", + "name": "jsonschema", + "sha256": "e0f9cbfefe951f57df257ce31f2fdf9187c6e53eafbe8c20588f1e717093d348", + "size": 145414, + "subdir": "linux-64", + "timestamp": 1676558776772, + "version": "4.17.3" + }, + "jsonschema-4.17.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent !=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f4a628ee18419c7c95bd1219fabfac3", + "name": "jsonschema", + "sha256": "373746b7d2a404719e70cbcacd0af45e6fc4d0efe71426fda3ee0db56539bc6c", + "size": 191348, + "subdir": "linux-64", + "timestamp": 1678983467176, + "version": "4.17.3" + }, + "jsonschema-4.17.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "importlib_resources >=1.4.0", + "pkgutil-resolve-name >=1.3.10", + "pyrsistent !=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "219e2fab9233a34e5c6f05033274aae4", + "name": "jsonschema", + "sha256": "454ac5b324b6a221de402cec7e8da2d2bf6701e625a27658389b3e4a23ef6514", + "size": 141174, + "subdir": "linux-64", + "timestamp": 1676558747293, + "version": "4.17.3" + }, + "jsonschema-4.17.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_resources >=1.4.0", + "pkgutil-resolve-name >=1.3.10", + "pyrsistent !=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c46e7bb2eddf1b76530f8625f3e9d272", + "name": "jsonschema", + "sha256": "5c3d11a6000b289ede11dbd14316dcfe7ec689228738fc879118f415ea002c27", + "size": 142948, + "subdir": "linux-64", + "timestamp": 1676558687406, + "version": "4.17.3" + }, + "jsonschema-4.17.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent !=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d1d08296a687321da795a516e7973c72", + "name": "jsonschema", + "sha256": "312766b4eb7ba20f544052a97ddb483089297f9d0c65d72215c3d4c6221580ea", + "size": 143291, + "subdir": "linux-64", + "timestamp": 1676558716852, + "version": "4.17.3" + }, + "jsonschema-4.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent >=0.14.0,!=0.17.0,!=0.17.1,!=0.17.2", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c48d04476435803143fbe04224c9c898", + "name": "jsonschema", + "sha256": "0b56fc8b0a9f25b100c5cb1157fc7ea4dc37e0b36005aa55a6582cf5ac986e19", + "size": 127242, + "subdir": "linux-64", + "timestamp": 1650007885399, + "version": "4.4.0" + }, + "jsonschema-4.4.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent >=0.14.0,!=0.17.0,!=0.17.1,!=0.17.2", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0115552955ff22540c5d9569129467d", + "name": "jsonschema", + "sha256": "e0aea462c2bd4e177d52b97d56660160da377e7a6b5f671d874f327914bfa711", + "size": 163751, + "subdir": "linux-64", + "timestamp": 1676823160726, + "version": "4.4.0" + }, + "jsonschema-4.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_metadata", + "importlib_resources >=1.4.0", + "pyrsistent >=0.14.0,!=0.17.0,!=0.17.1,!=0.17.2", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e0a2d34b55b02b5e68c7b9acd20480d", + "name": "jsonschema", + "sha256": "0a3c50a0de6582813fee1e81dff4a818f38e2a4377816149a1ea567251eb44c5", + "size": 123622, + "subdir": "linux-64", + "timestamp": 1650008131057, + "version": "4.4.0" + }, + "jsonschema-4.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "importlib_resources >=1.4.0", + "pyrsistent >=0.14.0,!=0.17.0,!=0.17.1,!=0.17.2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "877ad2da45101c06e0e779df2abcaf30", + "name": "jsonschema", + "sha256": "720d6023090ae6a1d732f9e570906cd4be93b348a0463fccb76b1bc8a7f00f84", + "size": 123567, + "subdir": "linux-64", + "timestamp": 1650025986553, + "version": "4.4.0" + }, + "jsonschema-4.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "pyrsistent >=0.14.0,!=0.17.0,!=0.17.1,!=0.17.2", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f25c2f18ab8998fe2db4df1df5c27f83", + "name": "jsonschema", + "sha256": "3869fbf52f7f0369ed6f1d0b951224345cb0689ae1ada81e2cd8a566c5a3aec6", + "size": 123722, + "subdir": "linux-64", + "timestamp": 1650025990702, + "version": "4.4.0" + }, + "jupyter-1.0.0-py27_4.conda": { + "build": "py27_4", + "build_number": 4, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=2.7,<2.8.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "bceb51ce520bce796be0d55f4e474651", + "name": "jupyter", + "sha256": "c7ed7b727344500a0671421d8fdf5792fada3e5536ea27413dc773acab325640", + "size": 5979, + "subdir": "linux-64", + "timestamp": 1518035203304, + "version": "1.0.0" + }, + "jupyter-1.0.0-py27_6.conda": { + "build": "py27_6", + "build_number": 6, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=2.7,<2.8.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "502604be8806b846620cc1df78cd8094", + "name": "jupyter", + "sha256": "d70426380c49e97f0f2a619ebd30e7b7ca6088c3142a75ab8f66073673626cec", + "size": 6463, + "subdir": "linux-64", + "timestamp": 1537216810475, + "version": "1.0.0" + }, + "jupyter-1.0.0-py27_7.conda": { + "build": "py27_7", + "build_number": 7, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=2.7,<2.8.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "300b082d1e3301fceb4e80a51b6690e0", + "name": "jupyter", + "sha256": "36b1bbf707754425c2054eda4924fe3d80f8026fc46d919f3cb3aadb0d34b86b", + "size": 6165, + "subdir": "linux-64", + "timestamp": 1537454692904, + "version": "1.0.0" + }, + "jupyter-1.0.0-py27h505fd4b_0.conda": { + "build": "py27h505fd4b_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=2.7,<2.8.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "2273d807fb98ebfb0ebb405d1fb52926", + "name": "jupyter", + "sha256": "e5b948cadaf4a0721f9e3e5cb342fd7cb1c8f2c159f3c57d37a4c98618d02a78", + "size": 4210, + "subdir": "linux-64", + "timestamp": 1505744965582, + "version": "1.0.0" + }, + "jupyter-1.0.0-py310h06a4308_7.conda": { + "build": "py310h06a4308_7", + "build_number": 7, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.10,<3.11.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "c9605eec9a0084751525454f53d12a74", + "name": "jupyter", + "sha256": "0f227213f95eeab0f318d257161a06b8ce1de476f5266389faf41bf6f74f1af3", + "size": 6749, + "subdir": "linux-64", + "timestamp": 1641917241052, + "version": "1.0.0" + }, + "jupyter-1.0.0-py310h06a4308_8.conda": { + "build": "py310h06a4308_8", + "build_number": 8, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "jupyterlab", + "nbconvert", + "notebook", + "python >=3.10,<3.11.0a0", + "qtconsole" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4bc9a44581e5de62ec1533b95cf35fd1", + "name": "jupyter", + "sha256": "a81f3ea33d95936ed76132191ba76a503c8a7f16c9097dc1a6c993874023efe6", + "size": 7699, + "subdir": "linux-64", + "timestamp": 1659349161198, + "version": "1.0.0" + }, + "jupyter-1.0.0-py311h06a4308_8.conda": { + "build": "py311h06a4308_8", + "build_number": 8, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "jupyterlab", + "nbconvert", + "notebook", + "python >=3.11,<3.12.0a0", + "qtconsole" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "902d0e6d61d54303da241cf0e4817e03", + "name": "jupyter", + "sha256": "3bb63b55cfa0b9fbb0bc9374c84f18336f527c397752de5788fe5816bc72600b", + "size": 7412, + "subdir": "linux-64", + "timestamp": 1676837051219, + "version": "1.0.0" + }, + "jupyter-1.0.0-py35_4.conda": { + "build": "py35_4", + "build_number": 4, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.5,<3.6.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "edb9aca08abc2f5d8bf6870950549853", + "name": "jupyter", + "sha256": "fc8df5e2efd9095e582899a39b124b40e2bcd7b3f3e7c7cbecdd9c626520cc85", + "size": 6028, + "subdir": "linux-64", + "timestamp": 1518035258706, + "version": "1.0.0" + }, + "jupyter-1.0.0-py35_6.conda": { + "build": "py35_6", + "build_number": 6, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.5,<3.6.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "802dde8238457036ff0dca0f6502475f", + "name": "jupyter", + "sha256": "497331bb064ad723f9f198bddb505463bb6ab843934bd1e82558b33ed9e88146", + "size": 6171, + "subdir": "linux-64", + "timestamp": 1537216847715, + "version": "1.0.0" + }, + "jupyter-1.0.0-py35_7.conda": { + "build": "py35_7", + "build_number": 7, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.5,<3.6.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "1dc0b6d7c38535981ada96d2353f2025", + "name": "jupyter", + "sha256": "caac8ec8ee2c370e4bbf45383a4cc9879c17fba6ffcd17d7b8e9a4d26588b474", + "size": 6169, + "subdir": "linux-64", + "timestamp": 1537454718884, + "version": "1.0.0" + }, + "jupyter-1.0.0-py35hd38625c_0.conda": { + "build": "py35hd38625c_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.5,<3.6.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "41645756fe95c15dfabfa2fc4f9aa973", + "name": "jupyter", + "sha256": "2a542483b59f90121a7065e2b2913c91c624308725ec2c619a305785a5415520", + "size": 4243, + "subdir": "linux-64", + "timestamp": 1505744981873, + "version": "1.0.0" + }, + "jupyter-1.0.0-py36_4.conda": { + "build": "py36_4", + "build_number": 4, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.6,<3.7.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "eced5ba06ff09fb193e350022cbede8d", + "name": "jupyter", + "sha256": "27e6024e943487664542976450f4885da8ab3b2bcf76d60e7c8a66f3821ff97d", + "size": 5978, + "subdir": "linux-64", + "timestamp": 1518035258479, + "version": "1.0.0" + }, + "jupyter-1.0.0-py36_6.conda": { + "build": "py36_6", + "build_number": 6, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.6,<3.7.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "0cc9b3456341be43d985106f71863ead", + "name": "jupyter", + "sha256": "e0c167376009d354da23a179a33faaa990627dd1a0958bd5d6c6226a165b9f7f", + "size": 6167, + "subdir": "linux-64", + "timestamp": 1537216864188, + "version": "1.0.0" + }, + "jupyter-1.0.0-py36_7.conda": { + "build": "py36_7", + "build_number": 7, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.6,<3.7.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "c580ed32cf19c4b01364f29274dcdf24", + "name": "jupyter", + "sha256": "3d7e749698e65385d1701ca0727695a86db9b4f3350f7aba447699ee97f72e16", + "size": 6145, + "subdir": "linux-64", + "timestamp": 1537454708191, + "version": "1.0.0" + }, + "jupyter-1.0.0-py36h9896ce5_0.conda": { + "build": "py36h9896ce5_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.6,<3.7.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "389e8a20b6b88333e7b41377a83e9344", + "name": "jupyter", + "sha256": "66970719e2bb83b6edb82d36dab08cd21aae775fcb3bfdd31946b5eb89a4252f", + "size": 4238, + "subdir": "linux-64", + "timestamp": 1505744998703, + "version": "1.0.0" + }, + "jupyter-1.0.0-py37_4.conda": { + "build": "py37_4", + "build_number": 4, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.7,<3.8.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "1aef585755c8d80a710d509dbeee5d57", + "name": "jupyter", + "sha256": "cab7e259f5001b90eea3f928d45100d411f276a764dee7b7fac925bd9baab85f", + "size": 6340, + "subdir": "linux-64", + "timestamp": 1530892936616, + "version": "1.0.0" + }, + "jupyter-1.0.0-py37_5.conda": { + "build": "py37_5", + "build_number": 5, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.7,<3.8.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "c4a43627e3f48de028b278a2949c3f2c", + "name": "jupyter", + "sha256": "88257ea262d89e6fd3cefe4d88d63762c88cb5091fdf4c47e741442d3cce2a2d", + "size": 6036, + "subdir": "linux-64", + "timestamp": 1531500225458, + "version": "1.0.0" + }, + "jupyter-1.0.0-py37_6.conda": { + "build": "py37_6", + "build_number": 6, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.7,<3.8.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "a1d8612700e054d258a51301642518f2", + "name": "jupyter", + "sha256": "8e3421024bbe508f7a6cac1d96ef42db8586cc9fcc873549d256bb30d8b8d2ff", + "size": 6141, + "subdir": "linux-64", + "timestamp": 1537216787888, + "version": "1.0.0" + }, + "jupyter-1.0.0-py37_7.conda": { + "build": "py37_7", + "build_number": 7, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.7,<3.8.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "8b4d802247e48c541da50180c2412e01", + "name": "jupyter", + "sha256": "15c9856657b69580d49c58ab0c54ef23a4a5c773f4de36752651758d629c0109", + "size": 6131, + "subdir": "linux-64", + "timestamp": 1537454658837, + "version": "1.0.0" + }, + "jupyter-1.0.0-py37h06a4308_8.conda": { + "build": "py37h06a4308_8", + "build_number": 8, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "jupyterlab", + "nbconvert", + "notebook", + "python >=3.7,<3.8.0a0", + "qtconsole" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6bdb6b5b4b0f19e0bcf4f81943d24112", + "name": "jupyter", + "sha256": "00b6a2a44ad33c7a326647ada2395bc7b780743c65fcabe8707c93909e0cc26b", + "size": 7664, + "subdir": "linux-64", + "timestamp": 1659349213260, + "version": "1.0.0" + }, + "jupyter-1.0.0-py38_7.conda": { + "build": "py38_7", + "build_number": 7, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.8,<3.9.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "a0948f111fccb0f9fd5895eac209d6c0", + "name": "jupyter", + "sha256": "4bcef7e49c4b36074f05b935f9824c47d486473f805fab2e0a3b76dd172c1087", + "size": 7603, + "subdir": "linux-64", + "timestamp": 1580250115272, + "version": "1.0.0" + }, + "jupyter-1.0.0-py38h06a4308_8.conda": { + "build": "py38h06a4308_8", + "build_number": 8, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "jupyterlab", + "nbconvert", + "notebook", + "python >=3.8,<3.9.0a0", + "qtconsole" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f7470ca2743d837dc0bb58c8189b1437", + "name": "jupyter", + "sha256": "e9804471b02333d1290c8ea224581adceff297ebf72537fa2ef9aae6acc63df0", + "size": 7668, + "subdir": "linux-64", + "timestamp": 1659349266270, + "version": "1.0.0" + }, + "jupyter-1.0.0-py39h06a4308_7.conda": { + "build": "py39h06a4308_7", + "build_number": 7, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "nbconvert", + "notebook", + "python >=3.9,<3.10.0a0", + "qtconsole" + ], + "license": "BSD 3-Clause", + "md5": "fee8e9e87ebbbc1a68e0440ad0c2b7b1", + "name": "jupyter", + "sha256": "bba2c70c558bbffcdc48b3624abae18d4aab98aae49f13b707f8e057b7f14c27", + "size": 7964, + "subdir": "linux-64", + "timestamp": 1607700875873, + "version": "1.0.0" + }, + "jupyter-1.0.0-py39h06a4308_8.conda": { + "build": "py39h06a4308_8", + "build_number": 8, + "depends": [ + "ipykernel", + "ipywidgets", + "jupyter_console", + "jupyterlab", + "nbconvert", + "notebook", + "python >=3.9,<3.10.0a0", + "qtconsole" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9c1ec71e0a6d1fc3ce630dfd2926cc09", + "name": "jupyter", + "sha256": "0acafd437d7b2b3e3f2b8f4181acfbea29a22400d33b24b9c094ded8f279b89b", + "size": 7648, + "subdir": "linux-64", + "timestamp": 1659349087693, + "version": "1.0.0" + }, + "jupyter-dash-0.4.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ansi2html", + "dash", + "flask", + "ipykernel", + "ipython", + "nest-asyncio", + "python >=3.10,<3.11.0a0", + "requests", + "retrying" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f08efd18b147b56106e23147779ba758", + "name": "jupyter-dash", + "sha256": "0c5260edea62039ef10c16b2ff7ac4298bf85c532b1a4ac23fa6b4b2393f71b8", + "size": 27743, + "subdir": "linux-64", + "timestamp": 1679330902270, + "version": "0.4.2" + }, + "jupyter-dash-0.4.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ansi2html", + "dash", + "flask", + "ipykernel", + "ipython", + "nest-asyncio", + "python >=3.11,<3.12.0a0", + "requests", + "retrying" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "922fc813b43a1999920dfd8fbd72772c", + "name": "jupyter-dash", + "sha256": "274d53d6c949c960deb4e433a00863e1736bcabf70dcc1bae914f5b6803ae9c6", + "size": 32029, + "subdir": "linux-64", + "timestamp": 1679331050936, + "version": "0.4.2" + }, + "jupyter-dash-0.4.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ansi2html", + "dash", + "flask", + "ipykernel", + "ipython", + "nest-asyncio", + "python >=3.8,<3.9.0a0", + "requests", + "retrying" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ac4ee973f7c506feaccaf2fca4e0114", + "name": "jupyter-dash", + "sha256": "e441b8ac0ba2c2c6e18e1e219ed7e504bca97a6d95d9c1605c310f47f98151bf", + "size": 27668, + "subdir": "linux-64", + "timestamp": 1679330956089, + "version": "0.4.2" + }, + "jupyter-dash-0.4.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ansi2html", + "dash", + "flask", + "ipykernel", + "ipython", + "nest-asyncio", + "python >=3.9,<3.10.0a0", + "requests", + "retrying" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60fbe31c7d791135b89b3b83d3912ff6", + "name": "jupyter-dash", + "sha256": "8fe01f757dbdab5412649d6aef7cdcf7751f3dd468f331ba96170d951baf49ff", + "size": 27647, + "subdir": "linux-64", + "timestamp": 1679330999864, + "version": "0.4.2" + }, + "jupyter-packaging-0.12.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "deprecation", + "packaging", + "python >=3.10,<3.11.0a0", + "setuptools >=60.2.0", + "tomlkit", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "78e33d286956a5e32d00b5b8087a505e", + "name": "jupyter-packaging", + "sha256": "84e34e04cce8797ba939da1fe486f444c582462ecd9d44de213de30c1a61a8b0", + "size": 45427, + "subdir": "linux-64", + "timestamp": 1654695016159, + "version": "0.12.0" + }, + "jupyter-packaging-0.12.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "deprecation", + "packaging", + "python >=3.10,<3.11.0a0", + "setuptools >=60.2.0", + "tomlkit", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2638a3fe3edd4d7a6f86931803f5b8aa", + "name": "jupyter-packaging", + "sha256": "2678c400e2a8ef6ff3d47b8ba28765221a7321a8d12d4544c779dfd843a75914", + "size": 47262, + "subdir": "linux-64", + "timestamp": 1678960981148, + "version": "0.12.0" + }, + "jupyter-packaging-0.12.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "deprecation", + "packaging", + "python >=3.11,<3.12.0a0", + "setuptools >=60.2.0", + "tomlkit", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "940b247a9be2ee5b63203aa5d086b073", + "name": "jupyter-packaging", + "sha256": "bd2b360c63927fc72ccdb514fc65591f50ded97b90db9c30e46f2b3234d2cfd8", + "size": 59234, + "subdir": "linux-64", + "timestamp": 1676823839221, + "version": "0.12.0" + }, + "jupyter-packaging-0.12.0-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "deprecation", + "packaging", + "python >=3.11,<3.12.0a0", + "setuptools >=60.2.0", + "tomlkit", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5d18dff1fca37a5d2a618bc95044c0ea", + "name": "jupyter-packaging", + "sha256": "5be96e13ac509efa114a5bcac920186428073bd7e2abd8e47cbed893e7284c1e", + "size": 61759, + "subdir": "linux-64", + "timestamp": 1678961058849, + "version": "0.12.0" + }, + "jupyter-packaging-0.12.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "deprecation", + "packaging", + "python >=3.7,<3.8.0a0", + "setuptools >=60.2.0", + "tomlkit", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5cc45f00d00006d181643d56d2b0e445", + "name": "jupyter-packaging", + "sha256": "2d2df608cf1201f22174e8a306c08675acdae6911ba54cfde749e5de610806d0", + "size": 45157, + "subdir": "linux-64", + "timestamp": 1654694978616, + "version": "0.12.0" + }, + "jupyter-packaging-0.12.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "deprecation", + "packaging", + "python >=3.8,<3.9.0a0", + "setuptools >=60.2.0", + "tomlkit", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dce5aaa78c20147ac52e3a5aa22c532b", + "name": "jupyter-packaging", + "sha256": "634739835b95faa3d0ca4906f5ccd75bc13c4fef8d6003b55efdce8fa7a9db8e", + "size": 45096, + "subdir": "linux-64", + "timestamp": 1654695069876, + "version": "0.12.0" + }, + "jupyter-packaging-0.12.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "deprecation", + "packaging", + "python >=3.8,<3.9.0a0", + "setuptools >=60.2.0", + "tomlkit", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5a962d234b4684c991e43b132625a2d8", + "name": "jupyter-packaging", + "sha256": "99d9e16f79272fc8426a6486725a2c789553dee311edcc60f4a680d82ad40130", + "size": 46964, + "subdir": "linux-64", + "timestamp": 1678961006899, + "version": "0.12.0" + }, + "jupyter-packaging-0.12.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "deprecation", + "packaging", + "python >=3.9,<3.10.0a0", + "setuptools >=60.2.0", + "tomlkit", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bcfd54d5e23c7f93aa1c86b64174ec24", + "name": "jupyter-packaging", + "sha256": "9acb1892cd0626b68868b7abe4b999c5d75308939ead530a6a301edbfdbeb07a", + "size": 45019, + "subdir": "linux-64", + "timestamp": 1654695043414, + "version": "0.12.0" + }, + "jupyter-packaging-0.12.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "deprecation", + "packaging", + "python >=3.9,<3.10.0a0", + "setuptools >=60.2.0", + "tomlkit", + "wheel" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "58307c8241e876b4412b12fd1141e8c3", + "name": "jupyter-packaging", + "sha256": "d4079eb1c44bd5ca8edbffc8d0584e9748101192b544b811de7ff45430cf660d", + "size": 46809, + "subdir": "linux-64", + "timestamp": 1678961031723, + "version": "0.12.0" + }, + "jupyter-server-proxy-3.2.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "jupyter_server >=1", + "python >=3.10,<3.11.0a0", + "simpervisor >=0.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "027abebe75d9c3c10a41b981b8f62e8c", + "name": "jupyter-server-proxy", + "sha256": "db6855c3e537d03652f55229aa812ac38c484852e00357e9f2e65781e5338474", + "size": 44209, + "subdir": "linux-64", + "timestamp": 1679384838638, + "version": "3.2.2" + }, + "jupyter-server-proxy-3.2.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "jupyter_server >=1", + "python >=3.11,<3.12.0a0", + "simpervisor >=0.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "17c05d5291dd9f72061bfb143601c8d4", + "name": "jupyter-server-proxy", + "sha256": "e47943bba506f08ad28e657bad3cf2e793cac32e2817a16b55ab07dc0727da9e", + "size": 53378, + "subdir": "linux-64", + "timestamp": 1679384644435, + "version": "3.2.2" + }, + "jupyter-server-proxy-3.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "jupyter_server >=1", + "python >=3.8,<3.9.0a0", + "simpervisor >=0.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "72e8dd8cb2bcd708de28a70792af0d12", + "name": "jupyter-server-proxy", + "sha256": "7495d1cd9ae1a67efe48d725dcff31d19a6975f80bce87d5f12c1f1d92a28d91", + "size": 43965, + "subdir": "linux-64", + "timestamp": 1679384773558, + "version": "3.2.2" + }, + "jupyter-server-proxy-3.2.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp", + "jupyter_server >=1", + "python >=3.9,<3.10.0a0", + "simpervisor >=0.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f57e413671c6db07d2a151cbea025a9d", + "name": "jupyter-server-proxy", + "sha256": "d80a8551ce36941be23fbede55734f7e03f906e31a316810e32ee1323365b081", + "size": 43883, + "subdir": "linux-64", + "timestamp": 1679384707331, + "version": "3.2.2" + }, + "jupyter_bokeh-3.0.7-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "bokeh >=3,<4", + "ipywidgets >=8,<9", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "187133b3c3548183dd9bc33ae2f0a7c1", + "name": "jupyter_bokeh", + "sha256": "18a94c904b86214399dad9ee95ef623ccd1a70f54498572db5240fd7c278ee19", + "size": 582231, + "subdir": "linux-64", + "timestamp": 1679489253752, + "version": "3.0.7" + }, + "jupyter_bokeh-3.0.7-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "bokeh >=3,<4", + "ipywidgets >=8,<9", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e8431e4c630db0296573803b1f292252", + "name": "jupyter_bokeh", + "sha256": "c4072ac823d24372b128683782421b5c77fc35d79de4d5a085534542848e434e", + "size": 584110, + "subdir": "linux-64", + "timestamp": 1679489335323, + "version": "3.0.7" + }, + "jupyter_bokeh-3.0.7-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "bokeh >=3,<4", + "ipywidgets >=8,<9", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "807214849d9fb7253713ab6b14c2f804", + "name": "jupyter_bokeh", + "sha256": "9d6035b22a5e0ff83e0a13d3337696a4215fc143d2678ae4cfbb352a20049cc4", + "size": 582088, + "subdir": "linux-64", + "timestamp": 1679489495070, + "version": "3.0.7" + }, + "jupyter_bokeh-3.0.7-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "bokeh >=3,<4", + "ipywidgets >=8,<9", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f5e797c964de5fa0549eadab08e1ccb2", + "name": "jupyter_bokeh", + "sha256": "6fde4814e7876d9458786b64167293c404e7f72b91c6756f595c43fb78d0bd55", + "size": 581723, + "subdir": "linux-64", + "timestamp": 1679489411883, + "version": "3.0.7" + }, + "jupyter_client-5.1.0-py27hbee1118_0.conda": { + "build": "py27hbee1118_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "b86fe9f2761f1600571901c78c8524c0", + "name": "jupyter_client", + "sha256": "8170f6896a6f8ecf5d8910a730d49a18e634366eebad10a93895cd6f08000864", + "size": 125934, + "subdir": "linux-64", + "timestamp": 1505688479689, + "version": "5.1.0" + }, + "jupyter_client-5.1.0-py35h2bff583_0.conda": { + "build": "py35h2bff583_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "917de618b546714ac60ae53909a80a0e", + "name": "jupyter_client", + "sha256": "865ec7c8d3d65e684663545502f9901d647fd141ac91ddbff848c7cd9c744b9b", + "size": 128090, + "subdir": "linux-64", + "timestamp": 1505688494728, + "version": "5.1.0" + }, + "jupyter_client-5.1.0-py36h614e9ea_0.conda": { + "build": "py36h614e9ea_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "5d232080a48b1d1014b52fff03465bdd", + "name": "jupyter_client", + "sha256": "945e5aa377ab8c0c45739348618967b7dfe34892fa438e5675d989cdf7705778", + "size": 126715, + "subdir": "linux-64", + "timestamp": 1505688510089, + "version": "5.1.0" + }, + "jupyter_client-5.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "ceb589301df169118387cdc44f4dabe1", + "name": "jupyter_client", + "sha256": "0ea88bfa970444dcaed46a5ef2a596757ac518ff7ddcfaafe215c25a4e01b064", + "size": 132798, + "subdir": "linux-64", + "timestamp": 1515706426034, + "version": "5.2.1" + }, + "jupyter_client-5.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "55d2710ebe0355b6b3fe8680003c5d10", + "name": "jupyter_client", + "sha256": "d1a43aa34b43573fa2fa5045c712767ecdf90eeef0ab6639265e56109792c242", + "size": 135064, + "subdir": "linux-64", + "timestamp": 1515706417747, + "version": "5.2.1" + }, + "jupyter_client-5.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "84506a670a613066c85e7e56fe2a87de", + "name": "jupyter_client", + "sha256": "677cb7dd86b104e5e19f94d651777eafbfc6d4577f1af09fae225fe58102388b", + "size": 133629, + "subdir": "linux-64", + "timestamp": 1515706346643, + "version": "5.2.1" + }, + "jupyter_client-5.2.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "eca5d76c31ef45f17a1819d321c31340", + "name": "jupyter_client", + "sha256": "a333e1eade718917355d7bc0c465be6b4bba53739b2059fa85eb833515fc2d98", + "size": 132909, + "subdir": "linux-64", + "timestamp": 1516910116981, + "version": "5.2.2" + }, + "jupyter_client-5.2.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "6676ea0ef3e1f997787c7ed2670d750e", + "name": "jupyter_client", + "sha256": "3b57bda4c5010246fe64c044bbad3a89094ce0eb3b8e5b632288c8b2494382c5", + "size": 133245, + "subdir": "linux-64", + "timestamp": 1516910136639, + "version": "5.2.2" + }, + "jupyter_client-5.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "4fc8edc55953487409d3746cb5c2bab2", + "name": "jupyter_client", + "sha256": "dfb552e0069e8389934d63c624fdb02a350d2ad8438f64ac365a33cdb409b8ae", + "size": 132064, + "subdir": "linux-64", + "timestamp": 1516910135717, + "version": "5.2.2" + }, + "jupyter_client-5.2.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "16e8f6d79a76061a55c07bce1e74d053", + "name": "jupyter_client", + "sha256": "19b24ee02bc6d9a6aa87abf209d318dd607173bc6e07c5738d22a3dd9cefc430", + "size": 131990, + "subdir": "linux-64", + "timestamp": 1521484125000, + "version": "5.2.3" + }, + "jupyter_client-5.2.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "2aa60d9e7a524bdf8ade48e55f0c992c", + "name": "jupyter_client", + "sha256": "cb64aac92c61767633d8f03f9b0e0be8a0715a72d69ada5f712daff825dca038", + "size": 133910, + "subdir": "linux-64", + "timestamp": 1521484132858, + "version": "5.2.3" + }, + "jupyter_client-5.2.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "1f7fff3dd7e6a196fb82ed836c6ea171", + "name": "jupyter_client", + "sha256": "199ff6ef99dd0db7a95d33ecaa06d441923d202d1bfd0f29037edf5418e811bd", + "size": 132718, + "subdir": "linux-64", + "timestamp": 1521484134735, + "version": "5.2.3" + }, + "jupyter_client-5.2.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "1446e8e70a81041a955597f6df8d8626", + "name": "jupyter_client", + "sha256": "1997aec9544b4bbd9f0cc4c8a5909287cc25beb6700becc1ec83a25c9b3bb111", + "size": 134478, + "subdir": "linux-64", + "timestamp": 1530694716397, + "version": "5.2.3" + }, + "jupyter_client-5.2.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "2ee4a23398dfe60a85125e2477927277", + "name": "jupyter_client", + "sha256": "951137029981ace27e10c58905ce31b0040d28615990ac4f9e1fdef075bf8b87", + "size": 135205, + "subdir": "linux-64", + "timestamp": 1545071982225, + "version": "5.2.4" + }, + "jupyter_client-5.2.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "15b6197fcaa19be3e8c1aebcc8bae759", + "name": "jupyter_client", + "sha256": "784ff60b8920472e52cdbdf8f461976c9a59a65e65ae3339cb25ee4f76895d99", + "size": 135999, + "subdir": "linux-64", + "timestamp": 1545072025530, + "version": "5.2.4" + }, + "jupyter_client-5.2.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyter_core", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "359739a1daf97e6b12cfc2bc3435d02b", + "name": "jupyter_client", + "sha256": "38ebc8b98d10ad279d20b2a215a6efc1eb2ed2b9be970dc3c4485c1e295abfef", + "size": 137854, + "subdir": "linux-64", + "timestamp": 1545072007262, + "version": "5.2.4" + }, + "jupyter_client-5.3.3-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "jupyter_core", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4.1", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "61395422627a59c354b27b97e318af4b", + "name": "jupyter_client", + "sha256": "24251419e4bd28012d7744f3edace0fe8e0de39ee7e37a5dad617e4313fea3d3", + "size": 144667, + "subdir": "linux-64", + "timestamp": 1569448159366, + "version": "5.3.3" + }, + "jupyter_client-5.3.3-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "jupyter_core", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4.1", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "e2d479fcb9b0df91c7ce6dcf64652eb5", + "name": "jupyter_client", + "sha256": "f93299fe150d0aa723baef316274bb57ad70f84ff66c52f7fb64944ae89ab8a4", + "size": 145453, + "subdir": "linux-64", + "timestamp": 1569448157660, + "version": "5.3.3" + }, + "jupyter_client-5.3.3-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "jupyter_core", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4.1", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "0f85192616bfc13023947dfce5356451", + "name": "jupyter_client", + "sha256": "e7271ca47b1be32ae26355e794125151db2face6909a7e4bbc148078fe72174c", + "size": 145843, + "subdir": "linux-64", + "timestamp": 1569448156654, + "version": "5.3.3" + }, + "jupyter_client-5.3.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jupyter_core >=4.6.0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4.1", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "03d9aa359d393529fd8dbf94c0853871", + "name": "jupyter_client", + "sha256": "1c3ae9520705ceb908b7e96026bea41104c98a90d68b3d9a88dd388cd0b0c5cb", + "size": 143135, + "subdir": "linux-64", + "timestamp": 1571154013472, + "version": "5.3.4" + }, + "jupyter_client-5.3.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyter_core >=4.6.0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4.1", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "d1985fcd352953d7d79c719e75ee7869", + "name": "jupyter_client", + "sha256": "89f86369cc38fbabcdd580b31e6a824d1357863a1a1d6310ddd55912a7f9b45d", + "size": 144222, + "subdir": "linux-64", + "timestamp": 1571153981176, + "version": "5.3.4" + }, + "jupyter_client-5.3.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyter_core >=4.6.0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4.1", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "cbe1c78657e0d3e59b91db01843d83b0", + "name": "jupyter_client", + "sha256": "d335994b3dcd50007a0c087d26038e56937daf4c1324fae223a6bbbf1ff2cfbe", + "size": 144625, + "subdir": "linux-64", + "timestamp": 1571154026784, + "version": "5.3.4" + }, + "jupyter_client-5.3.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jupyter_core >=4.6.0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "pyzmq >=13", + "tornado >=4.1", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "c795bfbf3654533501b4ef5a32b312d3", + "name": "jupyter_client", + "sha256": "5c146e2fbff89553bfe7801220e406bea125af5deaa52bddb7bf01034745d9bf", + "size": 140736, + "subdir": "linux-64", + "timestamp": 1574448337627, + "version": "5.3.4" + }, + "jupyter_client-7.2.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=22.3", + "tornado >=6.0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "949a24c68cb918c43b06a0788fe8183f", + "name": "jupyter_client", + "sha256": "836113dfd71bdddec9cb88d2235725e4015bb60a77e0bf12e9dfe1a769597efe", + "size": 198062, + "subdir": "linux-64", + "timestamp": 1650623162029, + "version": "7.2.2" + }, + "jupyter_client-7.2.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=22.3", + "tornado >=6.0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5c621e4a858fcd7d57cd4b5009d43ba1", + "name": "jupyter_client", + "sha256": "9b7760799a5c1c409b8c6e9bc57f1b67151458429c3839907e3e0e9231ff4889", + "size": 195018, + "subdir": "linux-64", + "timestamp": 1650622242192, + "version": "7.2.2" + }, + "jupyter_client-7.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=22.3", + "tornado >=6.0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6252e586fe1056d82d0cdeac2f46fec1", + "name": "jupyter_client", + "sha256": "fd1e1a3080c343bb0269bb08919f86eb379131cbb9a3300d23fbb8fe5f8abd44", + "size": 195702, + "subdir": "linux-64", + "timestamp": 1650622858276, + "version": "7.2.2" + }, + "jupyter_client-7.2.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=22.3", + "tornado >=6.0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2877d81efbe9a2b695da2fef4afc7918", + "name": "jupyter_client", + "sha256": "7bff32251a96d510345d4395704ac2c56e5eb426e3c05c26cf7d729a6e4d96c0", + "size": 195591, + "subdir": "linux-64", + "timestamp": 1650622553813, + "version": "7.2.2" + }, + "jupyter_client-7.3.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0b0ebb9367a58a1f9c719f1bda70446a", + "name": "jupyter_client", + "sha256": "d23cabf6e87e807178d0c8becacd9054a9dc7f14fa626afaa3b8f0ed5bb27cad", + "size": 199426, + "subdir": "linux-64", + "timestamp": 1661849794892, + "version": "7.3.4" + }, + "jupyter_client-7.3.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c387b6cc45627db718c6fb47bf6ec475", + "name": "jupyter_client", + "sha256": "6ee48d41ad6d746377e1a834045be04b482f6517f4ba99877e17fdb411bb5258", + "size": 196022, + "subdir": "linux-64", + "timestamp": 1661848952899, + "version": "7.3.4" + }, + "jupyter_client-7.3.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c236131fc3b02acc89164051881a90c4", + "name": "jupyter_client", + "sha256": "3894c896cbb81beed4fe12bf31d10d2d1cc5f7224b3b702faed1ca505e3a5c1e", + "size": 196683, + "subdir": "linux-64", + "timestamp": 1661849504409, + "version": "7.3.4" + }, + "jupyter_client-7.3.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e619db361baed94f29dc4fb9ce6a8cd2", + "name": "jupyter_client", + "sha256": "02c85fb1bd1aaa7e5eb341d41f3b845f7aad24b93b290b322e489261ce6cea3e", + "size": 196796, + "subdir": "linux-64", + "timestamp": 1661849228699, + "version": "7.3.4" + }, + "jupyter_client-7.3.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1022bff401204e47e173cc6ae53e2081", + "name": "jupyter_client", + "sha256": "33cad75a34022daca08229a0d9c22eece6e3a513a0345d651057023eacddf7f3", + "size": 198858, + "subdir": "linux-64", + "timestamp": 1662504601486, + "version": "7.3.5" + }, + "jupyter_client-7.3.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9f868d938528401951686cae4eb7268c", + "name": "jupyter_client", + "sha256": "2f53447df6206535613730d4caa7f6eb6c9dec0a167c6fa8ef47981e97ad338f", + "size": 195789, + "subdir": "linux-64", + "timestamp": 1662504779143, + "version": "7.3.5" + }, + "jupyter_client-7.3.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "778309a12c4aedf8d741d3c17761f185", + "name": "jupyter_client", + "sha256": "405bf846cd84712b71bacaf4050cc1a0c90417dfed21ff3359d80f4058ae6925", + "size": 196466, + "subdir": "linux-64", + "timestamp": 1662504405200, + "version": "7.3.5" + }, + "jupyter_client-7.3.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "74efa184a391e406d6d1bc7fe1d93f9b", + "name": "jupyter_client", + "sha256": "4932fd142fc8a4b58b7b1d0e44bc8fa0eb5b42a48443bc62d507d502cdc9c6b1", + "size": 196338, + "subdir": "linux-64", + "timestamp": 1662504952424, + "version": "7.3.5" + }, + "jupyter_client-7.4.7-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e706fe51a68e40a306e7928ee3befbc8", + "name": "jupyter_client", + "sha256": "d66d8276eda75c7a62169b5c99543d30826b2276c87a74d33b9f929ce9126b34", + "size": 215825, + "subdir": "linux-64", + "timestamp": 1669040879808, + "version": "7.4.7" + }, + "jupyter_client-7.4.7-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b61abab192043fe94d1848706e8c1b22", + "name": "jupyter_client", + "sha256": "8f7ad50d2570c6b053a0b949c3a1df20541631b99dff3e01ad1630070334ba25", + "size": 212953, + "subdir": "linux-64", + "timestamp": 1669040597438, + "version": "7.4.7" + }, + "jupyter_client-7.4.7-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "52f682fc4fc59ac91ae9f4a0079fd870", + "name": "jupyter_client", + "sha256": "ad4052f49d0b089afb70a30394986ce257f17814a23199a33d4eff922c312c86", + "size": 213777, + "subdir": "linux-64", + "timestamp": 1669040311231, + "version": "7.4.7" + }, + "jupyter_client-7.4.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa412db71e97f250c221ff201753029b", + "name": "jupyter_client", + "sha256": "c68f72dcd2fbc81c2f742a4a5ebfa6547acfd3d51677e8698d51a1494d7dcc7a", + "size": 213581, + "subdir": "linux-64", + "timestamp": 1669041158256, + "version": "7.4.7" + }, + "jupyter_client-7.4.8-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20ac1b428d43ee026faae82b785c0559", + "name": "jupyter_client", + "sha256": "85e66ddf285596d62f8c91bc37da94c07ada7b42a1d2ff18d6bf727caf3bdd26", + "size": 211812, + "subdir": "linux-64", + "timestamp": 1671703086222, + "version": "7.4.8" + }, + "jupyter_client-7.4.8-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f5e3a47ab1ef1d75343776dd4068e1da", + "name": "jupyter_client", + "sha256": "25b85d0fc7d002b031a1123b7d49d6ba8df720e747b35cf6101dd1dc8d2e1b7d", + "size": 209598, + "subdir": "linux-64", + "timestamp": 1671703876053, + "version": "7.4.8" + }, + "jupyter_client-7.4.8-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5462316ed3345bbe80dce5aed3b71567", + "name": "jupyter_client", + "sha256": "6b9a35e65eb54e9a421a8ada26e040be876e0d96da4c92fda08cbe92d8db0880", + "size": 209493, + "subdir": "linux-64", + "timestamp": 1671703615861, + "version": "7.4.8" + }, + "jupyter_client-7.4.8-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ec94243f4ea4c62c64bd992a31771161", + "name": "jupyter_client", + "sha256": "5f90493b24ebae7f49d48eef5168c60eebb3520df7c501ef8712369f18b26164", + "size": 209480, + "subdir": "linux-64", + "timestamp": 1671703353352, + "version": "7.4.8" + }, + "jupyter_client-7.4.9-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07e14fb10a57b73a6fced76dc7a1f2df", + "name": "jupyter_client", + "sha256": "76e9a94610d90d853121f7b8fcb4a47aa27a4e9ddf13d3085025934288c481bd", + "size": 212515, + "subdir": "linux-64", + "timestamp": 1676329563637, + "version": "7.4.9" + }, + "jupyter_client-7.4.9-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "031419f48dd8519031342808d3901ca3", + "name": "jupyter_client", + "sha256": "6b143b2b7a0ff7d97f81fdd56338c60dbaaac0c2ee519f678205292e0b37bb96", + "size": 269341, + "subdir": "linux-64", + "timestamp": 1676823504812, + "version": "7.4.9" + }, + "jupyter_client-7.4.9-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f4e2ef93e8b80ba2f0b327a176c95ee6", + "name": "jupyter_client", + "sha256": "af25f0736eaef907d357c5c5d1b6719280de67f6e593b16781caac8929305785", + "size": 208846, + "subdir": "linux-64", + "timestamp": 1676329265802, + "version": "7.4.9" + }, + "jupyter_client-7.4.9-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "10722ad4c2bcc1faf9c1ec4d0b61dc0b", + "name": "jupyter_client", + "sha256": "ca470f1350097eb4992fbf4e5e1ab04e30c95673dfd82d139b7dc1e9b0346b89", + "size": 209632, + "subdir": "linux-64", + "timestamp": 1676329113709, + "version": "7.4.9" + }, + "jupyter_client-7.4.9-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jupyter_core >=4.9.2", + "nest-asyncio >=1.5.4", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "01844f4f7e51c2c870116b461a6de57e", + "name": "jupyter_client", + "sha256": "940dee24a22bb0e40172d36bd5ca9c537ab4ca7ca05b644c35235d6f21fe2e00", + "size": 209542, + "subdir": "linux-64", + "timestamp": 1676329415827, + "version": "7.4.9" + }, + "jupyter_client-8.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_core >=4.12,!=5.0.*", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d5431a6d5fe24b371f8b6b2173d10a52", + "name": "jupyter_client", + "sha256": "627dc8330abe26cb1a501c6336872a9fd28aa3e809a91f9fed35309d1a6f7038", + "size": 184225, + "subdir": "linux-64", + "timestamp": 1680172590767, + "version": "8.1.0" + }, + "jupyter_client-8.1.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_core >=4.12,!=5.0.*", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "26502dc9a49e3ca09a9cf5c3c82d8cb1", + "name": "jupyter_client", + "sha256": "a01f898e9e86d87cdf0595a558275cd2897724a504ec7a83257a0d7d8cc7596c", + "size": 232945, + "subdir": "linux-64", + "timestamp": 1680172241388, + "version": "8.1.0" + }, + "jupyter_client-8.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=4.8.3", + "jupyter_core >=4.12,!=5.0.*", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4b41ab4823d8bd272dc2ab4874c5ff68", + "name": "jupyter_client", + "sha256": "dbd1a8608d2d2e1d59706a9d76cf8777adb20176d74b4574e0594798507cce7b", + "size": 182712, + "subdir": "linux-64", + "timestamp": 1680172942337, + "version": "8.1.0" + }, + "jupyter_client-8.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=4.8.3", + "jupyter_core >=4.12,!=5.0.*", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.2", + "pyzmq >=23.0", + "tornado >=6.2", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "df633a7aa5f2208e6f556a3e07b72b2a", + "name": "jupyter_client", + "sha256": "d17f45e834433485d0f57d3e01a00258c663c75497084e012d90bf78b54b18f3", + "size": 182767, + "subdir": "linux-64", + "timestamp": 1680171895221, + "version": "8.1.0" + }, + "jupyter_console-5.2.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client", + "pexpect", + "prompt_toolkit >=1.0.0,<2", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3634e0822d9e88e9fddafa86c8571df2", + "name": "jupyter_console", + "sha256": "31029418389c88097df9dcf83cad0afd31c956b3deaad34c82ee6543b317aff2", + "size": 37453, + "subdir": "linux-64", + "timestamp": 1530892903069, + "version": "5.2.0" + }, + "jupyter_console-5.2.0-py27hc6bee7e_1.conda": { + "build": "py27hc6bee7e_1", + "build_number": 1, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client", + "pexpect", + "prompt_toolkit >=1.0.0,<2", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "50d461e0f6d6da7fc2563fb1c1e64c81", + "name": "jupyter_console", + "sha256": "2081e03a0c385f03ad0b59488c82080643f417790a8ac76db9ab200715ddde05", + "size": 36665, + "subdir": "linux-64", + "timestamp": 1505957266748, + "version": "5.2.0" + }, + "jupyter_console-5.2.0-py35h4044a63_1.conda": { + "build": "py35h4044a63_1", + "build_number": 1, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client", + "pexpect", + "prompt_toolkit >=1.0.0,<2", + "pygments", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e387c6f21046e71ab0d0b2819f258303", + "name": "jupyter_console", + "sha256": "0882b6142b72fb039a0b457b01a7c661bd468ad00242122076baf5b8dc96c9e2", + "size": 37209, + "subdir": "linux-64", + "timestamp": 1505957283283, + "version": "5.2.0" + }, + "jupyter_console-5.2.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client", + "pexpect", + "prompt_toolkit >=1.0.0,<2", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6161a285461717ec010cc3766a723ace", + "name": "jupyter_console", + "sha256": "e0d65c24b4c498323c4ee07121c022e2f5d2e41692db59fd8e032aa49d5c1c5a", + "size": 37558, + "subdir": "linux-64", + "timestamp": 1530892872961, + "version": "5.2.0" + }, + "jupyter_console-5.2.0-py36he59e554_1.conda": { + "build": "py36he59e554_1", + "build_number": 1, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client", + "pexpect", + "prompt_toolkit >=1.0.0,<2", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ef160da9e36aae33cc786e3277f815db", + "name": "jupyter_console", + "sha256": "5c3810a14085ce192796672001c0c3f43be93161aee56800eaef65f6c1fd2f94", + "size": 36601, + "subdir": "linux-64", + "timestamp": 1505957299707, + "version": "5.2.0" + }, + "jupyter_console-5.2.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client", + "pexpect", + "prompt_toolkit >=1.0.0,<2", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3ecdfee7832c3e7bd784dd1734c0198c", + "name": "jupyter_console", + "sha256": "eab4450702bd77aef794308cba23642a264909d6e6acbcffd65c5a4272fbca13", + "size": 37628, + "subdir": "linux-64", + "timestamp": 1530892841146, + "version": "5.2.0" + }, + "jupyter_console-6.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client", + "prompt_toolkit >=2.0.0,<2.1.0", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "98a55bf529709ca53d48604430a78ad6", + "name": "jupyter_console", + "sha256": "fde402e57cb66cf8d27fcd4821cf611c7777324180bec87d44555073d40b8fff", + "size": 37682, + "subdir": "linux-64", + "timestamp": 1539024695322, + "version": "6.0.0" + }, + "jupyter_console-6.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client", + "prompt_toolkit >=2.0.0,<2.1.0", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d57206c70ee4516e04e74d689255fbbf", + "name": "jupyter_console", + "sha256": "adfb6d57e1ca9acd39cb9aeb6c33bacd13f6cd7df77b091b44246574cd4658f5", + "size": 37746, + "subdir": "linux-64", + "timestamp": 1539024664638, + "version": "6.0.0" + }, + "jupyter_console-6.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client", + "prompt_toolkit >=2.0.0,<2.1.0", + "pygments", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "6b8751a40f85d939d16be0cb8a469a40", + "name": "jupyter_console", + "sha256": "bd1d820e1e03a81a150fdf73b260797f8f398bfac139ef2c71cd569ae87fa474", + "size": 38730, + "subdir": "linux-64", + "timestamp": 1574238645702, + "version": "6.0.0" + }, + "jupyter_console-6.4.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client >=7.0.0", + "prompt_toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d28b85cfd721ded85bf36f8ccccbeae6", + "name": "jupyter_console", + "sha256": "b2fa5ef67d2ce48611d20574967177a65f4e74204f887aebcb25d7885c78f85e", + "size": 43930, + "subdir": "linux-64", + "timestamp": 1671541939419, + "version": "6.4.4" + }, + "jupyter_console-6.4.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client >=7.0.0", + "prompt_toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5a0229d77b9e77c00f6d96ae79460cfe", + "name": "jupyter_console", + "sha256": "166b25bd72dad23dabe178927d00228af7823876e00c392b4dad1e5973bafca2", + "size": 53463, + "subdir": "linux-64", + "timestamp": 1676827924183, + "version": "6.4.4" + }, + "jupyter_console-6.4.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client >=7.0.0", + "prompt_toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3e31fafa7d1e8e2484a1841ce22f603e", + "name": "jupyter_console", + "sha256": "752c65216d57476c12b7a29c63be6d8db64459971eed247271df71af856bf2e9", + "size": 43405, + "subdir": "linux-64", + "timestamp": 1671541969961, + "version": "6.4.4" + }, + "jupyter_console-6.4.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client >=7.0.0", + "prompt_toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5bb83904b5e812bc1ffad1fdfcd325bf", + "name": "jupyter_console", + "sha256": "b670d8213b41f18b8a1484811a437bacb866232f44427d3bd5510fc0e731ca30", + "size": 43502, + "subdir": "linux-64", + "timestamp": 1671542029723, + "version": "6.4.4" + }, + "jupyter_console-6.4.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython", + "jupyter_client >=7.0.0", + "prompt_toolkit >=2.0.0,<3.1.0,!=3.0.0,!=3.0.1", + "pygments", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b9d44007da5db0d139b50681fad6b652", + "name": "jupyter_console", + "sha256": "14d853876649dbb7f8ac4608693f87c99a9b0f7f53bddd11dd8b513d8ed794ef", + "size": 43544, + "subdir": "linux-64", + "timestamp": 1671541999949, + "version": "6.4.4" + }, + "jupyter_console-6.6.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "ipython", + "jupyter_client >=7.0.0", + "jupyter_core >=4.12,!=5.0.*", + "prompt_toolkit >=3.0.30", + "pygments", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "traitlets >=5.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1a78f951134fa00974ac37122d97076d", + "name": "jupyter_console", + "sha256": "03f524ff14fadd84bb6bcd31b95674c6e49e39f7c7a6753d7dc998eea31b8d70", + "size": 45639, + "subdir": "linux-64", + "timestamp": 1677674741056, + "version": "6.6.2" + }, + "jupyter_console-6.6.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "ipython", + "jupyter_client >=7.0.0", + "jupyter_core >=4.12,!=5.0.*", + "prompt_toolkit >=3.0.30", + "pygments", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "traitlets >=5.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e7103251eee30df9e3e2e89ab8399abb", + "name": "jupyter_console", + "sha256": "89c491bd63f1faf49ae3d115326f7d26ee3184d1bc8b4480e8e3c2b7c0c4cbed", + "size": 54765, + "subdir": "linux-64", + "timestamp": 1679336550072, + "version": "6.6.2" + }, + "jupyter_console-6.6.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "ipython", + "jupyter_client >=7.0.0", + "jupyter_core >=4.12,!=5.0.*", + "prompt_toolkit >=3.0.30", + "pygments", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "traitlets >=5.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c9c73adaddd2577f662d27406b084ab9", + "name": "jupyter_console", + "sha256": "847afa2161d5bafdb8d35e1a2b1bee0631ec62e9101c46ee28e393c898c83107", + "size": 45230, + "subdir": "linux-64", + "timestamp": 1677674680500, + "version": "6.6.2" + }, + "jupyter_console-6.6.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "ipython", + "jupyter_client >=7.0.0", + "jupyter_core >=4.12,!=5.0.*", + "prompt_toolkit >=3.0.30", + "pygments", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "traitlets >=5.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6dc74dd0fe334ee97c29003d7de25637", + "name": "jupyter_console", + "sha256": "144f64dd1b1ea5d276b3465b9f7d49b7c0f1e2a1b2dde282c6d2047bdd0f725f", + "size": 45263, + "subdir": "linux-64", + "timestamp": 1677674711139, + "version": "6.6.2" + }, + "jupyter_console-6.6.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "ipython", + "jupyter_client >=7.0.0", + "jupyter_core >=4.12,!=5.0.*", + "prompt_toolkit >=3.0.30", + "pygments", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "traitlets >=5.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa6873ef4b33e75b594f174b47204b20", + "name": "jupyter_console", + "sha256": "91024de86ef20ed8f15541e743514845cb049f446acfe77d0d4255d69af4f3c2", + "size": 45905, + "subdir": "linux-64", + "timestamp": 1679999729802, + "version": "6.6.3" + }, + "jupyter_console-6.6.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "ipython", + "jupyter_client >=7.0.0", + "jupyter_core >=4.12,!=5.0.*", + "prompt_toolkit >=3.0.30", + "pygments", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "traitlets >=5.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "82b6c0ce1adec65e2f77ea364a275695", + "name": "jupyter_console", + "sha256": "8f988566fa324511833fd4f0602148894cb250710124a5785e39bc984211fd17", + "size": 58088, + "subdir": "linux-64", + "timestamp": 1679999662329, + "version": "6.6.3" + }, + "jupyter_console-6.6.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "ipython", + "jupyter_client >=7.0.0", + "jupyter_core >=4.12,!=5.0.*", + "prompt_toolkit >=3.0.30", + "pygments", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "traitlets >=5.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8b08e77d9d002be38ca2c3b12168679f", + "name": "jupyter_console", + "sha256": "65bf7fc99de84dede5e7b3dc6c4f4619dfad4fc5e613111a8daacf71603808bc", + "size": 45599, + "subdir": "linux-64", + "timestamp": 1679999763666, + "version": "6.6.3" + }, + "jupyter_console-6.6.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "ipython", + "jupyter_client >=7.0.0", + "jupyter_core >=4.12,!=5.0.*", + "prompt_toolkit >=3.0.30", + "pygments", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "traitlets >=5.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dee965810ba0caf07fdd465c2db07743", + "name": "jupyter_console", + "sha256": "80b6ef1665adee7cdc662e6a2668e27947f7c9ba14de258e104f93fc3b21757d", + "size": 45495, + "subdir": "linux-64", + "timestamp": 1679999694997, + "version": "6.6.3" + }, + "jupyter_core-4.10.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6bb93665a9dea7c206a000eb4d643b8d", + "name": "jupyter_core", + "sha256": "4dc4cd5d30a56a338ced01461ffaa8d83048c344bef441623f7d8a7891b48336", + "size": 78049, + "subdir": "linux-64", + "timestamp": 1651671331477, + "version": "4.10.0" + }, + "jupyter_core-4.10.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "64d78389dc0962edab04a9555b8d5871", + "name": "jupyter_core", + "sha256": "8a2c480ee691fc4534c1d8f4ef996b31af4369002f8e73a05ee9047011a7fbd0", + "size": 77290, + "subdir": "linux-64", + "timestamp": 1651671261820, + "version": "4.10.0" + }, + "jupyter_core-4.10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dbb24641c111c02f0620a3c339517d74", + "name": "jupyter_core", + "sha256": "26df8b8c84f46db06d365d905fd150811270f4a09f62361d89186996d50067f8", + "size": 77445, + "subdir": "linux-64", + "timestamp": 1651671359188, + "version": "4.10.0" + }, + "jupyter_core-4.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d2d4120816c9394669bbda3e6a0f5b04", + "name": "jupyter_core", + "sha256": "57073e3e5fef6415c2cc5f736a3f57fb48175ff8a0b2f4965d4cb4ea1f06087d", + "size": 77466, + "subdir": "linux-64", + "timestamp": 1651671292026, + "version": "4.10.0" + }, + "jupyter_core-4.11.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6ea91b518693cd4a677163bfb84721f2", + "name": "jupyter_core", + "sha256": "66bea21a486cba81d3a38ed1523981f0f902dd18be510c3843551c12fbdcc9d2", + "size": 78890, + "subdir": "linux-64", + "timestamp": 1664917412252, + "version": "4.11.1" + }, + "jupyter_core-4.11.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "62ab48b80f164f2e65f50ad530484b24", + "name": "jupyter_core", + "sha256": "5e3d147cce3c0dc9f790551a0a5fe6e2caeac6883caacda79ba903a95862585c", + "size": 78121, + "subdir": "linux-64", + "timestamp": 1664917442869, + "version": "4.11.1" + }, + "jupyter_core-4.11.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8ccedb5428734141daa8309167f23647", + "name": "jupyter_core", + "sha256": "74435737298445eac93426b6db14b78ef37f8d27921f05ea8b83bbb8d1514ed3", + "size": 78231, + "subdir": "linux-64", + "timestamp": 1664917336879, + "version": "4.11.1" + }, + "jupyter_core-4.11.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d3e86856de80b9872da2d456c596edf0", + "name": "jupyter_core", + "sha256": "a00deeb18a17943eec4436f64323d193cc7b0cb8fc191c0048bcb482a4fe14f5", + "size": 78430, + "subdir": "linux-64", + "timestamp": 1664917370029, + "version": "4.11.1" + }, + "jupyter_core-4.11.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d7014180dd6f542ed815bd9b0cad420", + "name": "jupyter_core", + "sha256": "464bd8ac0904af4e8c74abf0c4e1c197802f200e315965bd61680b2edecd8ed6", + "size": 82405, + "subdir": "linux-64", + "timestamp": 1668084533635, + "version": "4.11.2" + }, + "jupyter_core-4.11.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "487382d7892cddc5bef38ea9f7b1e2ec", + "name": "jupyter_core", + "sha256": "85fb355e192774939376c69867393a346a6291aa67d7938d1cef308cead43532", + "size": 81697, + "subdir": "linux-64", + "timestamp": 1668084564177, + "version": "4.11.2" + }, + "jupyter_core-4.11.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fffbfdd8b6b3cb719fbca3ef5f816634", + "name": "jupyter_core", + "sha256": "545b34f2f44d3de9493c3d6003dd4c9657e556569950a5c88884b54fc77b558e", + "size": 81785, + "subdir": "linux-64", + "timestamp": 1668084503651, + "version": "4.11.2" + }, + "jupyter_core-4.11.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a356d402d84b9f9ce4eb1bb0db937ea1", + "name": "jupyter_core", + "sha256": "204d2ded51344b65782aa6ae94d852118c1317c1816a208b748f25f59142ef4e", + "size": 81843, + "subdir": "linux-64", + "timestamp": 1668084473932, + "version": "4.11.2" + }, + "jupyter_core-4.3.0-py27hcd9ae3a_0.conda": { + "build": "py27hcd9ae3a_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "4a53d98c25c95eacf0c391e8f251809b", + "name": "jupyter_core", + "sha256": "406806ddd3c0dc9ea4c3feefcf1bed74510a36bab3d7bec2451d59656d2923ac", + "size": 58658, + "subdir": "linux-64", + "timestamp": 1505672242706, + "version": "4.3.0" + }, + "jupyter_core-4.3.0-py35he2f7985_0.conda": { + "build": "py35he2f7985_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "2f55f47c3100685fb8994280c71d6913", + "name": "jupyter_core", + "sha256": "a25aa01264a395c0339f00bb5fced66c2ffd410526d2f035d74872c8c531137c", + "size": 58383, + "subdir": "linux-64", + "timestamp": 1505672257166, + "version": "4.3.0" + }, + "jupyter_core-4.3.0-py36h357a921_0.conda": { + "build": "py36h357a921_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "md5": "d40cdeff4839a532ac7e2778d15e6e9e", + "name": "jupyter_core", + "sha256": "fbf79be9c314e3d0852b6422f8682996d5a3a14691fda2a683166ef659798816", + "size": 57947, + "subdir": "linux-64", + "timestamp": 1505672272011, + "version": "4.3.0" + }, + "jupyter_core-4.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "563bae981d11efa454019cf60851aa6f", + "name": "jupyter_core", + "sha256": "09a9cc21a46c1e82ca15e452a0403016dcb136b43ef1ead5c02b820671014050", + "size": 60338, + "subdir": "linux-64", + "timestamp": 1530694461495, + "version": "4.4.0" + }, + "jupyter_core-4.4.0-py27h345911c_0.conda": { + "build": "py27h345911c_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "31ee753b32454d4597d4b009453418d2", + "name": "jupyter_core", + "sha256": "6377dffeab25267bc14c108ebeb85632a8f9130e6186d06a455453b20da95e96", + "size": 60107, + "subdir": "linux-64", + "timestamp": 1511290813060, + "version": "4.4.0" + }, + "jupyter_core-4.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3a82648cbd806425650530ae1eb6db66", + "name": "jupyter_core", + "sha256": "44bb9dd1211cb58f6f3eecd6b9e3e44fc31caec3520a96bcf1ea5d609d197f3a", + "size": 60646, + "subdir": "linux-64", + "timestamp": 1534345287327, + "version": "4.4.0" + }, + "jupyter_core-4.4.0-py35ha89e94b_0.conda": { + "build": "py35ha89e94b_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ed08f96668b7b58e2a1a03741fa76c61", + "name": "jupyter_core", + "sha256": "56095d733e2536e41074bfe80d1c1c989528f24ab109b5bea930e794592fc7ed", + "size": 59895, + "subdir": "linux-64", + "timestamp": 1511290832830, + "version": "4.4.0" + }, + "jupyter_core-4.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6c56b6453ffca985a8637d2268746a22", + "name": "jupyter_core", + "sha256": "1538b3c494e9bd3fd10d2141cf6dacc5aecf84af3f4ad72487df173cf56afbc5", + "size": 60190, + "subdir": "linux-64", + "timestamp": 1530694419261, + "version": "4.4.0" + }, + "jupyter_core-4.4.0-py36h7c827e3_0.conda": { + "build": "py36h7c827e3_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "65780bbd76762357de3f55f1d738d12a", + "name": "jupyter_core", + "sha256": "b38f76f1ab0fb21bdc9d1b038b9ff760a8c543be17d5acf8217d130759036622", + "size": 60108, + "subdir": "linux-64", + "timestamp": 1511290842789, + "version": "4.4.0" + }, + "jupyter_core-4.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dae30b29a22a86ac0c6f8b2af58c3141", + "name": "jupyter_core", + "sha256": "527b317a9878b429f31de1da419ab972e7cfc51fc10a9e82dd315971439d7944", + "size": 61172, + "subdir": "linux-64", + "timestamp": 1530694440867, + "version": "4.4.0" + }, + "jupyter_core-4.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1eec72283ff53dbd80400a62b4c41643", + "name": "jupyter_core", + "sha256": "f05a1e78bfb0d7fb2868afbb0968545916041d1c70c7b61957731dd48eba795d", + "size": 65387, + "subdir": "linux-64", + "timestamp": 1572457594939, + "version": "4.5.0" + }, + "jupyter_core-4.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0d7d7eadd42ce3bd88e94929d2cdd6a3", + "name": "jupyter_core", + "sha256": "913e3f4a4cedbde771e5fa011fabf0e8e0b92391dae82341e9749fda81c3be8d", + "size": 65386, + "subdir": "linux-64", + "timestamp": 1572457593977, + "version": "4.5.0" + }, + "jupyter_core-4.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0204f9accf329cda6367eabc51038bb1", + "name": "jupyter_core", + "sha256": "a0eed0a70017589b61490ebdaaaf14bcbcdc85d22a6479d37684e2b29aa1a06d", + "size": 65475, + "subdir": "linux-64", + "timestamp": 1572457550358, + "version": "4.5.0" + }, + "jupyter_core-4.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8828fddc8dc77f1602c6d29c76563ed9", + "name": "jupyter_core", + "sha256": "e89bcd71044aa290f9d7c8e04307e2389ba622b44a4b8f5f3071c2b8b6d0d05f", + "size": 71060, + "subdir": "linux-64", + "timestamp": 1571153848777, + "version": "4.6.0" + }, + "jupyter_core-4.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "69d817e71d0ac00ca142793e5a733fba", + "name": "jupyter_core", + "sha256": "b46bad9be219b0accf1c4bc46b143823eda80d838d833bf2cf0433ca54da8c88", + "size": 71213, + "subdir": "linux-64", + "timestamp": 1571153862840, + "version": "4.6.0" + }, + "jupyter_core-4.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "156f7c6a076be2c6d79878b58842a474", + "name": "jupyter_core", + "sha256": "e893a4a67e6f16a00a60e9fabe7005cdb788d0adbfc9de862ea76e305c169bd4", + "size": 71109, + "subdir": "linux-64", + "timestamp": 1571153862604, + "version": "4.6.0" + }, + "jupyter_core-4.6.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "59d82ebb3ae1a8c22b54a35d7532c7f3", + "name": "jupyter_core", + "sha256": "e58172c85dfdf6fabc15728d16dfddfafb4280928a248f695a221c417cbe08a1", + "size": 71442, + "subdir": "linux-64", + "timestamp": 1573062510826, + "version": "4.6.1" + }, + "jupyter_core-4.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "010e11a30af35ca703a3f2befe9c7ea7", + "name": "jupyter_core", + "sha256": "69556464afc45d277af19edee7145cfc8edca8221cefabe117ac90528430f22c", + "size": 71707, + "subdir": "linux-64", + "timestamp": 1573062515899, + "version": "4.6.1" + }, + "jupyter_core-4.6.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4f3e48e6e2509c47268a958d4849eb22", + "name": "jupyter_core", + "sha256": "61a1ee452de6c9562baf611befac7320e8571839d21a85417bcda4ded8e475c1", + "size": 71629, + "subdir": "linux-64", + "timestamp": 1573062508223, + "version": "4.6.1" + }, + "jupyter_core-4.6.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4aa0cec9660ceb30b651fd12f6bf762a", + "name": "jupyter_core", + "sha256": "ef6713405acee950196af620b3ed5e8be858d19b7bf052655f755fb42c0bd10e", + "size": 68691, + "subdir": "linux-64", + "timestamp": 1574097555051, + "version": "4.6.1" + }, + "jupyter_core-4.6.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dd78390662717d61eac1bd5f3150a9d4", + "name": "jupyter_core", + "sha256": "9f172f4ae593f335f4567b66735c641dedbce88dc5fe28c2a990de7abdc5de2b", + "size": 72372, + "subdir": "linux-64", + "timestamp": 1585645262710, + "version": "4.6.3" + }, + "jupyter_core-4.6.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "982641464203d287da573aa7bbc70c17", + "name": "jupyter_core", + "sha256": "70751de26be3a942140b14e6773bca7fdd052c8600ee61ff87257455aeef9231", + "size": 72417, + "subdir": "linux-64", + "timestamp": 1585645218484, + "version": "4.6.3" + }, + "jupyter_core-4.6.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "369fa0f64f4f1ac29ecebf094be83989", + "name": "jupyter_core", + "sha256": "03a76ea94606756683cb71386cf78234f6df4a7e9c2ecea6c25341dc076c2a4d", + "size": 72598, + "subdir": "linux-64", + "timestamp": 1585645262149, + "version": "4.6.3" + }, + "jupyter_core-4.7.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a1c829c7b730559cffc36cc1e38df409", + "name": "jupyter_core", + "sha256": "fd819452337ecc258475fd6ba9e71a733876a4eda015c86aa221d6b032febb79", + "size": 69466, + "subdir": "linux-64", + "timestamp": 1606149006140, + "version": "4.7.0" + }, + "jupyter_core-4.7.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "61466d5cc3b5dd7467578ce307e084f6", + "name": "jupyter_core", + "sha256": "fb4e3eb824998c959d5f57dae6940340216ae26e4d15befcf21aa40cc9a3af82", + "size": 69134, + "subdir": "linux-64", + "timestamp": 1606148988928, + "version": "4.7.0" + }, + "jupyter_core-4.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5bbc6bd7ca6b10fd0129c34f1ec82c8b", + "name": "jupyter_core", + "sha256": "f6d327acc07d29ec1f675c04c01b7c5d39adaf101897737f31712217714d0114", + "size": 69381, + "subdir": "linux-64", + "timestamp": 1606149038092, + "version": "4.7.0" + }, + "jupyter_core-4.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e8e72c907b75fd73a6c06c7302a00593", + "name": "jupyter_core", + "sha256": "a8693709aa2049a299e8189311a78b5c411dabb769ec81aec2543b9e2d64c13f", + "size": 73224, + "subdir": "linux-64", + "timestamp": 1606834060003, + "version": "4.7.0" + }, + "jupyter_core-4.7.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d47df630ecd804bdb23027440bff6c75", + "name": "jupyter_core", + "sha256": "68f529fc106cc79f45cb313e627ed2e5dccaccfc8bd3625be755021f5126a82f", + "size": 70056, + "subdir": "linux-64", + "timestamp": 1612213346084, + "version": "4.7.1" + }, + "jupyter_core-4.7.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b37042b4eba110616d658174fee063ab", + "name": "jupyter_core", + "sha256": "658e8401882d50ceadcdd23f8d16c312c6d1c7af5a8289ec85769a8a842fbdf7", + "size": 69527, + "subdir": "linux-64", + "timestamp": 1612213343388, + "version": "4.7.1" + }, + "jupyter_core-4.7.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4dc89e90fe7b643db7a9f82e933de4d8", + "name": "jupyter_core", + "sha256": "b9818621952cddf01a8c05efd81a826232ca8b9babad35c14e1f21e29fd81495", + "size": 69179, + "subdir": "linux-64", + "timestamp": 1612213351745, + "version": "4.7.1" + }, + "jupyter_core-4.7.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "303aa7e2be46636a1fa800a1d474c6a3", + "name": "jupyter_core", + "sha256": "ef827c5c766b7a64bd65152b348f91c36c131e8888a186744d069e8b01d8f2cb", + "size": 69592, + "subdir": "linux-64", + "timestamp": 1612213349730, + "version": "4.7.1" + }, + "jupyter_core-4.8.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "492067f92925b8375ddb6fee8e4e4d66", + "name": "jupyter_core", + "sha256": "be378711c50fdbc5b2cde1bd0f11134185b9bc7060dd711bbe855e71e0071ba8", + "size": 75578, + "subdir": "linux-64", + "timestamp": 1633420155136, + "version": "4.8.1" + }, + "jupyter_core-4.8.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9152c59cb7d2c1e6c53f8feae5ed207f", + "name": "jupyter_core", + "sha256": "c0ba803870180615b4b1cb751cc7d0f6b4385a970d2d7a63c96c61be93bc12d0", + "size": 75572, + "subdir": "linux-64", + "timestamp": 1633420124599, + "version": "4.8.1" + }, + "jupyter_core-4.8.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e79a6720aabf120388017d3e57220491", + "name": "jupyter_core", + "sha256": "35cc549bbf3ea739e0cbdb435557494452b2a3dc3630ebfd972916f84fa222e9", + "size": 75681, + "subdir": "linux-64", + "timestamp": 1633409436315, + "version": "4.8.1" + }, + "jupyter_core-4.8.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "57032f1855c40c660aa18e8b3e79ea17", + "name": "jupyter_core", + "sha256": "9359baf3f1de50aa796d41cfe66dab421efe3d148084141f2fffcde935b4e224", + "size": 75270, + "subdir": "linux-64", + "timestamp": 1633420138922, + "version": "4.8.1" + }, + "jupyter_core-4.9.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4bf9c4048038ca6b99d0ab2283453ad3", + "name": "jupyter_core", + "sha256": "a8dc1106a38bd087d048f10475b49e48b553166ca069dce0c0de8ac27df5b321", + "size": 77735, + "subdir": "linux-64", + "timestamp": 1641916134081, + "version": "4.9.1" + }, + "jupyter_core-4.9.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "be5228a559492d8497a49d097b5409de", + "name": "jupyter_core", + "sha256": "f4a655d5ed909187086788b2cba4b30bc32be58a8810b91d46eaac0ff1343be5", + "size": 76203, + "subdir": "linux-64", + "timestamp": 1636537069547, + "version": "4.9.1" + }, + "jupyter_core-4.9.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b794fc617686b78c3b96cf63db063a0c", + "name": "jupyter_core", + "sha256": "be2fef789813f090e6a17afd8b60f5c701a3f67fc93dfb75ea0448596cdf1d2d", + "size": 76770, + "subdir": "linux-64", + "timestamp": 1636524790246, + "version": "4.9.1" + }, + "jupyter_core-4.9.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0b9f2d16bf946101366de34310aa98f3", + "name": "jupyter_core", + "sha256": "ecd098f2836fedc0ff0cdd3bb9639f1c772efa562308b73e4eef9d8852e076dd", + "size": 77197, + "subdir": "linux-64", + "timestamp": 1636537058844, + "version": "4.9.1" + }, + "jupyter_core-4.9.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "371116541a90b6b66d690af0937b14e1", + "name": "jupyter_core", + "sha256": "4f3c922499baa6bc119c723a52dd32a72d551a2a28c5149ef5af079ca457de55", + "size": 81723, + "subdir": "linux-64", + "timestamp": 1646994486831, + "version": "4.9.2" + }, + "jupyter_core-4.9.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "58c9cf26d381e6868f85dd2c89e84062", + "name": "jupyter_core", + "sha256": "1f86d9d7b230e7d81f4041d93703fad833b6d10562847eda439188f7f1d20461", + "size": 80976, + "subdir": "linux-64", + "timestamp": 1646994476826, + "version": "4.9.2" + }, + "jupyter_core-4.9.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d0d0cb3c0859bd1555c1cb07b9485012", + "name": "jupyter_core", + "sha256": "cd57d306b5fb9b1ccdbd5e3508640faadf1c18f7dbc4f45593362395e3eca25f", + "size": 80692, + "subdir": "linux-64", + "timestamp": 1646994473562, + "version": "4.9.2" + }, + "jupyter_core-4.9.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e5e1a77c78f10a280c146fd8ee48e995", + "name": "jupyter_core", + "sha256": "a7e10c349dc40abef60f6536d72eec9e7c8edb0ae63d9875305053720886945f", + "size": 80813, + "subdir": "linux-64", + "timestamp": 1646976345169, + "version": "4.9.2" + }, + "jupyter_core-5.1.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.10,<3.11.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2f75c341970380a6e71775e793462215", + "name": "jupyter_core", + "sha256": "9c36745d00aa39452701731f4a74e6d40fb033bbcb71787d5f3a5a307af58e9e", + "size": 92108, + "subdir": "linux-64", + "timestamp": 1672332284637, + "version": "5.1.1" + }, + "jupyter_core-5.1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.8,<3.9.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a0f132331123afb90fc27ce985f2dcbe", + "name": "jupyter_core", + "sha256": "41a43d28a7c8b822bb43aea627957de98f4044d902ccdc74ff3ca9d9d24ef122", + "size": 91349, + "subdir": "linux-64", + "timestamp": 1672332313759, + "version": "5.1.1" + }, + "jupyter_core-5.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.9,<3.10.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fcb3ccc35ce482e43d94fb0239b13249", + "name": "jupyter_core", + "sha256": "7a4fc07f3a049d6e384d25e7012832bfbd099844c159b3395563fece44b35058", + "size": 91448, + "subdir": "linux-64", + "timestamp": 1672332255325, + "version": "5.1.1" + }, + "jupyter_core-5.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.10,<3.11.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9b1de9d7dc975ff0e922acc8b619fc53", + "name": "jupyter_core", + "sha256": "ad0aabe7a1e53a4bfdec03a12d7f759f1f5ce8aad069ded05d084260ea0ab6d7", + "size": 92251, + "subdir": "linux-64", + "timestamp": 1676538658256, + "version": "5.2.0" + }, + "jupyter_core-5.2.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.11,<3.12.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d4f4c21793e49e275e6e605af108e739", + "name": "jupyter_core", + "sha256": "b5b2797dde66c9b5dbb5a80e25022011855ca9ea6ba1e674934901e745b1f3ec", + "size": 112395, + "subdir": "linux-64", + "timestamp": 1676823359810, + "version": "5.2.0" + }, + "jupyter_core-5.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.8,<3.9.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b18bf6faf9db1ae86f0fac80942281fb", + "name": "jupyter_core", + "sha256": "23a06746ff25e5b5e8eaacd68cdd7d4f050d6c17a7863eb06545721ed8e34af2", + "size": 91272, + "subdir": "linux-64", + "timestamp": 1676538598023, + "version": "5.2.0" + }, + "jupyter_core-5.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.9,<3.10.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1626df6429279f65a42c8ce561820a09", + "name": "jupyter_core", + "sha256": "6be548cdfe25591a0ab7fff0906ae1b0232996722eb21fb6e0043ae22aa5d6a3", + "size": 91262, + "subdir": "linux-64", + "timestamp": 1676538628009, + "version": "5.2.0" + }, + "jupyter_core-5.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.10,<3.11.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9ae8cdc1c461a41d192bcac8b9704013", + "name": "jupyter_core", + "sha256": "7c7bdbb012c4041e98f9af9c071b4c14e30c97ae78e9e6abf5349e97594f0e30", + "size": 91358, + "subdir": "linux-64", + "timestamp": 1679906681642, + "version": "5.3.0" + }, + "jupyter_core-5.3.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.11,<3.12.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "611b1c191fd5a26c0e7b788163c32502", + "name": "jupyter_core", + "sha256": "66e5791cf90199dd79ae1d066588209dc1f5aa0de2c3d7025af855a170abec26", + "size": 115870, + "subdir": "linux-64", + "timestamp": 1679906624249, + "version": "5.3.0" + }, + "jupyter_core-5.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.8,<3.9.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "95154c4b7a7d2e541acee66e38b6ef6a", + "name": "jupyter_core", + "sha256": "217ef604058a465fdc8931a9fb5e9db0241a89b06e363f6587bb089f0a0a3dd9", + "size": 90680, + "subdir": "linux-64", + "timestamp": 1679906595114, + "version": "5.3.0" + }, + "jupyter_core-5.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "platformdirs >=2.5", + "python >=3.9,<3.10.0a0", + "traitlets >=5.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "433236f9ecba86742948005c77ce2f57", + "name": "jupyter_core", + "sha256": "46cd808e333a55cf12acd0b0f692c14785d223f119422b4129839c5fa26b919a", + "size": 90752, + "subdir": "linux-64", + "timestamp": 1679906652183, + "version": "5.3.0" + }, + "jupyter_dashboards_bundlers-0.9.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "notebook >=5.0", + "python >=2.7,<2.8.0a0", + "requests >=2.7" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "abd1d998fbb04669d0fa07dcbbeaed5d", + "name": "jupyter_dashboards_bundlers", + "sha256": "2d493fb6a35c1b4af8de9df06bd6e32204a25c21abe6afc910098e9a4ca9553c", + "size": 15483, + "subdir": "linux-64", + "timestamp": 1539206257280, + "version": "0.9.1" + }, + "jupyter_dashboards_bundlers-0.9.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "notebook >=5.0", + "python >=3.10,<3.11.0a0", + "requests >=2.7" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "c7a2dfd7f53be086ff2c2ead3504308a", + "name": "jupyter_dashboards_bundlers", + "sha256": "49d35b350d7f890846b2323e9f3da30ee28062a5a8d3bb66f977c8d46dd28bf5", + "size": 14446, + "subdir": "linux-64", + "timestamp": 1640815241939, + "version": "0.9.1" + }, + "jupyter_dashboards_bundlers-0.9.1-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "notebook >=5.0", + "python >=3.11,<3.12.0a0", + "requests >=2.7" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "8a57085331b6665b945f6155497c2d13", + "name": "jupyter_dashboards_bundlers", + "sha256": "9951da751fca4a5610ce9e98fb2ff0a8276be92a3a128326d3a290d62e64468b", + "size": 16773, + "subdir": "linux-64", + "timestamp": 1676907278937, + "version": "0.9.1" + }, + "jupyter_dashboards_bundlers-0.9.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "notebook >=5.0", + "python >=3.6,<3.7.0a0", + "requests >=2.7" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "7f0572ee6ec5bf22e51878fdd6ef91c9", + "name": "jupyter_dashboards_bundlers", + "sha256": "8094e09ada5133c54fa34372c5ff87c7140c98040d63819834a855977959f985", + "size": 15471, + "subdir": "linux-64", + "timestamp": 1539206280719, + "version": "0.9.1" + }, + "jupyter_dashboards_bundlers-0.9.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "notebook >=5.0", + "python >=3.6,<3.7.0a0", + "requests >=2.7" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "8a6fe38e9f198c59872749f9533e89ca", + "name": "jupyter_dashboards_bundlers", + "sha256": "e8ae9e1380c12caba216422cd9d9f3a94a7c96a7eccf882f3ef559d43106cc1b", + "size": 260736, + "subdir": "linux-64", + "timestamp": 1615394836203, + "version": "0.9.1" + }, + "jupyter_dashboards_bundlers-0.9.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "notebook >=5.0", + "python >=3.7,<3.8.0a0", + "requests >=2.7" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "26b0e4daeecef0822d07b6a8fa9663c4", + "name": "jupyter_dashboards_bundlers", + "sha256": "17b6a9cb16129ef03d3f83b7af6734c04ce05eb156a9de8a3b84d8d35cf90bcc", + "size": 15446, + "subdir": "linux-64", + "timestamp": 1539206295458, + "version": "0.9.1" + }, + "jupyter_dashboards_bundlers-0.9.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "notebook >=5.0", + "python >=3.7,<3.8.0a0", + "requests >=2.7" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "9e247f0cbe0551ae5ef21969411ab6c1", + "name": "jupyter_dashboards_bundlers", + "sha256": "7e84378d368bb9b153dc2ae17c8a2ae6906207c4b98d0f6b3da1e3a60e55263d", + "size": 261250, + "subdir": "linux-64", + "timestamp": 1615394985475, + "version": "0.9.1" + }, + "jupyter_dashboards_bundlers-0.9.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "notebook >=5.0", + "python >=3.8,<3.9.0a0", + "requests >=2.7" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "45c3572f625f732c2bff5fb8552301e9", + "name": "jupyter_dashboards_bundlers", + "sha256": "b64deb0de62c84685cab2f26f36e758f28274812f77343cebc52bd62575faf73", + "size": 261422, + "subdir": "linux-64", + "timestamp": 1615394987932, + "version": "0.9.1" + }, + "jupyter_dashboards_bundlers-0.9.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "notebook >=5.0", + "python >=3.9,<3.10.0a0", + "requests >=2.7" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "3469fdb41110c8acb3aa5f9236053dfa", + "name": "jupyter_dashboards_bundlers", + "sha256": "8c2f4ddd8e3db25fd36442be91db02d2af3d7a073b5b533e0b1f7d37881c1c21", + "size": 261626, + "subdir": "linux-64", + "timestamp": 1615394992359, + "version": "0.9.1" + }, + "jupyter_kernel_gateway-2.1.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "notebook >=5.3.0,<6.0", + "python >=2.7,<2.8.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD 3-Clause", + "md5": "9476e69014c1189052f26c9d2c5d6d63", + "name": "jupyter_kernel_gateway", + "sha256": "3b5934d732c336590f090b46765933c5d32a1b965dc4d352288e8e6976bc700c", + "size": 56850, + "subdir": "linux-64", + "timestamp": 1536855145864, + "version": "2.1.0" + }, + "jupyter_kernel_gateway-2.1.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "notebook >=5.3.0,<6.0", + "python >=3.5,<3.6.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD 3-Clause", + "md5": "ee9f11edc8a0e3c48cdd4298e0b24e26", + "name": "jupyter_kernel_gateway", + "sha256": "aceaa112564be63f244ea520f58e92a924e6754a38884ccefb48819f96c45901", + "size": 59006, + "subdir": "linux-64", + "timestamp": 1536855193796, + "version": "2.1.0" + }, + "jupyter_kernel_gateway-2.1.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "notebook >=5.3.0,<6.0", + "python >=3.6,<3.7.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD 3-Clause", + "md5": "f535419d4bb2611f94acefff6c7862f5", + "name": "jupyter_kernel_gateway", + "sha256": "e08753f6905734933255b796f2f2ac16d05a1382db4bb8a1bda3d06883ff8dda", + "size": 58345, + "subdir": "linux-64", + "timestamp": 1536855181727, + "version": "2.1.0" + }, + "jupyter_kernel_gateway-2.1.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "notebook >=5.3.0,<6.0", + "python >=3.7,<3.8.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD 3-Clause", + "md5": "7c56cd2c062e3d420a8a7404ce9e6043", + "name": "jupyter_kernel_gateway", + "sha256": "700d3dd6b70cbf49ab057632fc13641977460a65c94e27922439c549cc64d153", + "size": 58471, + "subdir": "linux-64", + "timestamp": 1536855141121, + "version": "2.1.0" + }, + "jupyter_kernel_gateway-2.5.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "notebook >=5.7.6,<7.0", + "python >=3.10,<3.11.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "de7d8dbaf49778d3ee8a661b61d1b112", + "name": "jupyter_kernel_gateway", + "sha256": "eef41d890ced7a965511d040450b5fc11505c52922f48d9c3ed1bd32a93c9034", + "size": 61396, + "subdir": "linux-64", + "timestamp": 1670546582778, + "version": "2.5.1" + }, + "jupyter_kernel_gateway-2.5.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "notebook >=5.7.6,<7.0", + "python >=3.11,<3.12.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ac228b4126d1d539fb7aeedd393f008", + "name": "jupyter_kernel_gateway", + "sha256": "a1783acd4f18e8b625b9eb96bc87655a050f82df16a7094a03261cbb7aa768a5", + "size": 74597, + "subdir": "linux-64", + "timestamp": 1676853030777, + "version": "2.5.1" + }, + "jupyter_kernel_gateway-2.5.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "notebook >=5.7.6,<7.0", + "python >=3.7,<3.8.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4bfbfdd117182a2851c1c3669977c719", + "name": "jupyter_kernel_gateway", + "sha256": "b952d8e92f343144a4a3007b365196361fdaaf1df2b630f30df5d337608431be", + "size": 60678, + "subdir": "linux-64", + "timestamp": 1670546652652, + "version": "2.5.1" + }, + "jupyter_kernel_gateway-2.5.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "notebook >=5.7.6,<7.0", + "python >=3.8,<3.9.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bc2f3c9390c1c021e796d675a49811d3", + "name": "jupyter_kernel_gateway", + "sha256": "e2bea2585b19f29c6d91b1b0aef7e75d49a3d1d58e6e56891dd1df9c2a103222", + "size": 60820, + "subdir": "linux-64", + "timestamp": 1670546687842, + "version": "2.5.1" + }, + "jupyter_kernel_gateway-2.5.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "notebook >=5.7.6,<7.0", + "python >=3.9,<3.10.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7087595fc904cf6f44108e2799ac1025", + "name": "jupyter_kernel_gateway", + "sha256": "7c77781be5bfdc0e9c7328cb039c64d7d0111fb1b2e733146d7c6be8cf0e870f", + "size": 60854, + "subdir": "linux-64", + "timestamp": 1670546617998, + "version": "2.5.1" + }, + "jupyter_kernel_gateway-2.5.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=5.2.0,<8.0", + "jupyter_core >=4.4.0", + "notebook >=5.7.6,<7.0", + "python >=3.10,<3.11.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0370eb44fd5fdc2db01b29fe86477fd1", + "name": "jupyter_kernel_gateway", + "sha256": "39a9b2d477ba7b0150b4e48726f369f8cc3574a3e38df3e8c73e86ea729fe3a6", + "size": 64920, + "subdir": "linux-64", + "timestamp": 1679567467295, + "version": "2.5.2" + }, + "jupyter_kernel_gateway-2.5.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=5.2.0,<8.0", + "jupyter_core >=4.4.0", + "notebook >=5.7.6,<7.0", + "python >=3.11,<3.12.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fb7d5c7ea50f3c40cea61da057b4ae73", + "name": "jupyter_kernel_gateway", + "sha256": "5075f14e8df410db61ce28d07cae8cb28ec1ea6b5342b09e9d4271e58e0c48a0", + "size": 80123, + "subdir": "linux-64", + "timestamp": 1679567354950, + "version": "2.5.2" + }, + "jupyter_kernel_gateway-2.5.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=5.2.0,<8.0", + "jupyter_core >=4.4.0", + "notebook >=5.7.6,<7.0", + "python >=3.8,<3.9.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "90f7f873df6e3ea74909dfb53faf00e8", + "name": "jupyter_kernel_gateway", + "sha256": "0e840ac7de24704d2718be7a1424df65cffc0c43c50f0a6607f3a5143a8d6800", + "size": 63764, + "subdir": "linux-64", + "timestamp": 1679567392897, + "version": "2.5.2" + }, + "jupyter_kernel_gateway-2.5.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=5.2.0,<8.0", + "jupyter_core >=4.4.0", + "notebook >=5.7.6,<7.0", + "python >=3.9,<3.10.0a0", + "requests >=2.7,<3.0", + "tornado >=4.2.0", + "traitlets >=4.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "190ddb64991fe069d02e80d34a7bb40a", + "name": "jupyter_kernel_gateway", + "sha256": "588ad63df50699a324fb9898893182e5e05dbfd488e1038061d3847e11f53004", + "size": 64288, + "subdir": "linux-64", + "timestamp": 1679567429889, + "version": "2.5.2" + }, + "jupyter_server-1.1.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=2.0.2", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7c1b16b295e626a99f3e322f1b21b96e", + "name": "jupyter_server", + "sha256": "0b497311d6f4e5eef38767c9a3958e1becbaa722a864b9cc41f2615c63ef046d", + "size": 307938, + "subdir": "linux-64", + "timestamp": 1641917277595, + "version": "1.1.3" + }, + "jupyter_server-1.17.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "689dbf9236eb854f0ffe924735028d05", + "name": "jupyter_server", + "sha256": "652e9c5a25f201037d623c513f733a33d329c884bf5f58ba8fd40a8e8ad28389", + "size": 366231, + "subdir": "linux-64", + "timestamp": 1654784448888, + "version": "1.17.1" + }, + "jupyter_server-1.17.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "59fd9041eacb21acf54975a469dc50a0", + "name": "jupyter_server", + "sha256": "cb74f73d5341fa677a3f37b712850f8cdd2794c686a7f409a6df94cb7dd67db3", + "size": 362110, + "subdir": "linux-64", + "timestamp": 1654784047544, + "version": "1.17.1" + }, + "jupyter_server-1.17.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8af43922d8634c78f987bb99bd713a38", + "name": "jupyter_server", + "sha256": "9eb7bc6c6d734db771f1f6e1eddff2eaa1ead74c62e145ce00192bcb29d078f3", + "size": 362199, + "subdir": "linux-64", + "timestamp": 1654784199050, + "version": "1.17.1" + }, + "jupyter_server-1.17.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "616eb7e80b44f8ad8aa9ae57a8a799a9", + "name": "jupyter_server", + "sha256": "153901c401d558cf21771f91060e528128dda42a1739c1195292ff2626b6dded", + "size": 363297, + "subdir": "linux-64", + "timestamp": 1654784319629, + "version": "1.17.1" + }, + "jupyter_server-1.18.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9f5709c045561ba2710962ac21759465", + "name": "jupyter_server", + "sha256": "952f6653a96bf5db87f9d47a6535af0504c77e3f6a745bffdd62ab76b4d2779d", + "size": 367808, + "subdir": "linux-64", + "timestamp": 1658754619953, + "version": "1.18.1" + }, + "jupyter_server-1.18.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c502d678133b04f765bdb1fa37647ae6", + "name": "jupyter_server", + "sha256": "1a5799113a0bc490a18f63fc2a6a92d7dd581535df208b03496a2e3c11a677c9", + "size": 363629, + "subdir": "linux-64", + "timestamp": 1658754546998, + "version": "1.18.1" + }, + "jupyter_server-1.18.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a461fe5eadc87007233194c283c0cdfe", + "name": "jupyter_server", + "sha256": "6972dd2653a5b1dce40f35fb37265175570b6096efbe6d12d4950f1793ce1d88", + "size": 364647, + "subdir": "linux-64", + "timestamp": 1658754578796, + "version": "1.18.1" + }, + "jupyter_server-1.18.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "260872735d02dff8faeefa31eeceda26", + "name": "jupyter_server", + "sha256": "cdd45f934c49e7f69c66e4e059cdb56f5b4e538513c4b5645c566948fe394987", + "size": 364758, + "subdir": "linux-64", + "timestamp": 1658754514317, + "version": "1.18.1" + }, + "jupyter_server-1.23.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "749fae1920a080cb2ebf60be9966b5e9", + "name": "jupyter_server", + "sha256": "e53f26cf49722752dcfc0e9a8a8116fe157b1251043d886613f2354458880308", + "size": 394216, + "subdir": "linux-64", + "timestamp": 1671707770227, + "version": "1.23.4" + }, + "jupyter_server-1.23.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d9f74088f39214b96fa00eef077747c", + "name": "jupyter_server", + "sha256": "3c87e2d29fcee2ea0fcd530cc3f63ee6ecb3e094f969a4efe3dda4cd6bebd051", + "size": 454310, + "subdir": "linux-64", + "timestamp": 1676824961113, + "version": "1.23.4" + }, + "jupyter_server-1.23.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9b99513d3ac07a12fb44211ec2915cdc", + "name": "jupyter_server", + "sha256": "cae9567446036aac61c7c5f8170f0b7de31726a7b728c5473f8de4f1a8b12a19", + "size": 390973, + "subdir": "linux-64", + "timestamp": 1671707666926, + "version": "1.23.4" + }, + "jupyter_server-1.23.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f54677766157d1b70870d991f466c724", + "name": "jupyter_server", + "sha256": "a50130e09df410a890004df1a3eb46c9389162aaf24fc8cb9230de4f858a9109", + "size": 391030, + "subdir": "linux-64", + "timestamp": 1671707735470, + "version": "1.23.4" + }, + "jupyter_server-1.23.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=3.1.0,<4", + "argon2-cffi", + "jinja2", + "jupyter_client >=6.1.12", + "jupyter_core >=4.7.0", + "nbconvert >=6.4.4", + "nbformat >=5.2.0", + "packaging", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1.0", + "traitlets >=5.1", + "websocket-client" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b28bd3df58c5de74a80db5f2de35a81e", + "name": "jupyter_server", + "sha256": "6f8fd1bdf5049ca5d91a883d9fcfbcbfdcf22311ccabc68ec1f5d02e3c4e5aea", + "size": 391331, + "subdir": "linux-64", + "timestamp": 1671707702849, + "version": "1.23.4" + }, + "jupyter_server-1.4.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=2.0.2", + "dataclasses", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c4a0cec7296a8ea45ccdbf85e0ac306c", + "name": "jupyter_server", + "sha256": "968b160b3dfcd1770fb9f92f2f0299c30a411dcc82cee299301dbb653499fdbe", + "size": 321315, + "subdir": "linux-64", + "timestamp": 1616083679501, + "version": "1.4.1" + }, + "jupyter_server-1.4.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=2.0.2", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "247a91dbee73db13961aa92ea0ef51c1", + "name": "jupyter_server", + "sha256": "6148e14a9e8ec569442c5d0d3069c9a9d4cb857e742ee5e461badd750e759052", + "size": 318150, + "subdir": "linux-64", + "timestamp": 1616084101991, + "version": "1.4.1" + }, + "jupyter_server-1.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=2.0.2", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1df7fff658240ace0d5c023a80ff283f", + "name": "jupyter_server", + "sha256": "271d8d1900e35008d9e32eece115fbf063c8b6e57c6606542846b5a58036d5f1", + "size": 324113, + "subdir": "linux-64", + "timestamp": 1616083678327, + "version": "1.4.1" + }, + "jupyter_server-1.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anyio >=2.0.2", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "96044b502366d838feb0e5dc9c719ae6", + "name": "jupyter_server", + "sha256": "319dabe60e7e5bb9c31fbe793a45d7203d50ae9cbe261b328bac94f3d76310c8", + "size": 320671, + "subdir": "linux-64", + "timestamp": 1616084108246, + "version": "1.4.1" + }, + "jupyterhub-0.9.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alembic", + "async_generator >=1.8", + "configurable-http-proxy", + "jinja2", + "pamela", + "prometheus_client >=0.0.21", + "pycurl", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-oauth2 >=1.0", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.0", + "traitlets >=4.3.2" + ], + "license": "BSD 3-Clause", + "md5": "782666e6dfed2c4fbc7d1fa428edeab8", + "name": "jupyterhub", + "sha256": "c31e80db0a8efaf3cf60a729f1a45400bab8f6c8c968b66a57ac4852fb92cf75", + "size": 1482781, + "subdir": "linux-64", + "timestamp": 1541099793519, + "version": "0.9.4" + }, + "jupyterhub-0.9.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alembic", + "async_generator >=1.8", + "configurable-http-proxy", + "jinja2", + "pamela", + "prometheus_client >=0.0.21", + "pycurl", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-oauth2 >=1.0", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.0", + "traitlets >=4.3.2" + ], + "license": "BSD 3-Clause", + "md5": "6c95c5b44013af2eb5a5e68fd3c959ed", + "name": "jupyterhub", + "sha256": "7745c35b4422b9de2b8488fd1d5fd1fba3c0c6a2f37998d82c1bcaa671c836da", + "size": 1486046, + "subdir": "linux-64", + "timestamp": 1541099831863, + "version": "0.9.4" + }, + "jupyterhub-0.9.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alembic", + "async_generator >=1.8", + "configurable-http-proxy", + "jinja2", + "pamela", + "prometheus_client >=0.0.21", + "pycurl", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-oauth2 >=1.0", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.0", + "traitlets >=4.3.2" + ], + "license": "BSD 3-Clause", + "md5": "ad96d2d149e9a9832f8287aafb207a34", + "name": "jupyterhub", + "sha256": "cf01d945a293051c1396c6079a25b158e717a09e2181da62cf47f2c6438025be", + "size": 1483410, + "subdir": "linux-64", + "timestamp": 1553788360540, + "version": "0.9.5" + }, + "jupyterhub-0.9.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alembic", + "async_generator >=1.8", + "configurable-http-proxy", + "jinja2", + "pamela", + "prometheus_client >=0.0.21", + "pycurl", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-oauth2 >=1.0", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.0", + "traitlets >=4.3.2" + ], + "license": "BSD 3-Clause", + "md5": "97c6c12278f66f3fa53078726ac01785", + "name": "jupyterhub", + "sha256": "298c766dc1997020db4cfae397316ab634c0388d959adcf5ef2e6983a2689e58", + "size": 1476348, + "subdir": "linux-64", + "timestamp": 1553788331303, + "version": "0.9.5" + }, + "jupyterhub-0.9.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alembic", + "async_generator >=1.8", + "configurable-http-proxy", + "jinja2", + "pamela", + "prometheus_client >=0.0.21", + "pycurl", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "python-oauth2 >=1.0", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.0", + "traitlets >=4.3.2" + ], + "license": "BSD 3-Clause", + "md5": "e57d6a438a6d7c860b93c0f307c936e0", + "name": "jupyterhub", + "sha256": "bb6a75b23738e8eb1d955052c5f9428e62343b39b0ffe2be6648cb62128393ab", + "size": 1477117, + "subdir": "linux-64", + "timestamp": 1554133925983, + "version": "0.9.6" + }, + "jupyterhub-0.9.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alembic", + "async_generator >=1.8", + "configurable-http-proxy", + "jinja2", + "pamela", + "prometheus_client >=0.0.21", + "pycurl", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "python-oauth2 >=1.0", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.0", + "traitlets >=4.3.2" + ], + "license": "BSD 3-Clause", + "md5": "5aa8e4aa1114d1d193bcfe8bc2200ed7", + "name": "jupyterhub", + "sha256": "68a55d83e50bd0f34fad739d5f4797d2c349bf092915dc8e062d140893e3ad1c", + "size": 1482015, + "subdir": "linux-64", + "timestamp": 1554133925484, + "version": "0.9.6" + }, + "jupyterhub-1.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alembic", + "async_generator >=1.8", + "certipy >=0.1.2", + "configurable-http-proxy", + "entrypoints", + "jinja2", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.0.21", + "pycurl", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.0", + "traitlets >=4.3.2" + ], + "license": "BSD 3-Clause", + "md5": "b5105ab53e55060602631937f4455efa", + "name": "jupyterhub", + "sha256": "b044987490cdb4789b722f920751e81377c2a6258c29f7b310cb54e7bc784996", + "size": 1546687, + "subdir": "linux-64", + "timestamp": 1569510028748, + "version": "1.0.0" + }, + "jupyterhub-1.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alembic", + "async_generator >=1.8", + "certipy >=0.1.2", + "configurable-http-proxy", + "entrypoints", + "jinja2", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.0.21", + "pycurl", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.0", + "traitlets >=4.3.2" + ], + "license": "BSD 3-Clause", + "md5": "624b45529d66f5bdaae333e37e2f463c", + "name": "jupyterhub", + "sha256": "117edf0c7d6fc18d41813aba53e932bd0cdd02b095d1764f2ef4107271e1b798", + "size": 1547072, + "subdir": "linux-64", + "timestamp": 1569510034643, + "version": "1.0.0" + }, + "jupyterhub-1.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "alembic", + "async_generator >=1.8", + "certipy >=0.1.2", + "configurable-http-proxy", + "entrypoints", + "jinja2", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.0.21", + "pycurl", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.0", + "traitlets >=4.3.2" + ], + "license": "BSD 3-Clause", + "md5": "cb299d7debccd158ad6e549168fdd63e", + "name": "jupyterhub", + "sha256": "5f6e29a4d374df0f9091caa9a8412753b75084dc1a26e74d84b1236fd247c6ac", + "size": 1543186, + "subdir": "linux-64", + "timestamp": 1574238667121, + "version": "1.0.0" + }, + "jupyterhub-1.3.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "configurable-http-proxy >=4", + "jupyterhub-base 1.3.0 py36h06a4308_1", + "nodejs >=12", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "3a58e0516a523cfde94bbb7a9db67fda", + "name": "jupyterhub", + "sha256": "4f9bcc435d4f73077ae4a4d3b4c1e91d374c8d2b9c24fbfe14cbac45f0614cfc", + "size": 12815, + "subdir": "linux-64", + "timestamp": 1615900885200, + "version": "1.3.0" + }, + "jupyterhub-1.3.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "configurable-http-proxy >=4", + "jupyterhub-base 1.3.0 py37h06a4308_1", + "nodejs >=12", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "429829763f30ccf4740a06751ab8eb85", + "name": "jupyterhub", + "sha256": "0a7b1249ebdaf2c05f0ac8b4a69a07832980d97bc482d1111a7070eafa0f6a7b", + "size": 12806, + "subdir": "linux-64", + "timestamp": 1615899025551, + "version": "1.3.0" + }, + "jupyterhub-1.3.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "configurable-http-proxy >=4", + "jupyterhub-base 1.3.0 py38h06a4308_1", + "nodejs >=12", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e91cb438fc25be9ef2ae831ffbdc18e7", + "name": "jupyterhub", + "sha256": "f7192e8fb21d21113eec2ee49936b19f70777e774c64e03daf6a481a94106b36", + "size": 12818, + "subdir": "linux-64", + "timestamp": 1615900874023, + "version": "1.3.0" + }, + "jupyterhub-1.3.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "configurable-http-proxy >=4", + "jupyterhub-base 1.3.0 py39h06a4308_1", + "nodejs >=12", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f2c5f3433df7aeebd8b0b239d8554a24", + "name": "jupyterhub", + "sha256": "99a7cd2e3ba1920be55c22ebc2b9218dd1defe38fe855e30935c388b25cf0078", + "size": 12821, + "subdir": "linux-64", + "timestamp": 1615900875779, + "version": "1.3.0" + }, + "jupyterhub-1.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "entrypoints", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cecd555a217b778ccc8b86d8cdef2c6e", + "name": "jupyterhub", + "sha256": "a3405fd48ed37eedb1fff44155bffbe88062d80defd5bc72fffeaf79ab01870c", + "size": 1602032, + "subdir": "linux-64", + "timestamp": 1622645507544, + "version": "1.4.1" + }, + "jupyterhub-1.4.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "entrypoints", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bc6c2704e045e69854c9d7ba11c7349e", + "name": "jupyterhub", + "sha256": "78849ed33e17736a00c05ec501331ccfbdd8fba2b5616e069142397f0f64f51f", + "size": 1606867, + "subdir": "linux-64", + "timestamp": 1641903286783, + "version": "1.4.2" + }, + "jupyterhub-1.4.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "entrypoints", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "54d38061ca3b3b528852fed1cf34e232", + "name": "jupyterhub", + "sha256": "854bf84eed9f30f9b9da989dba3f141eb4506e86669f0ee5af460aa82e3fd434", + "size": 1601979, + "subdir": "linux-64", + "timestamp": 1626856531280, + "version": "1.4.2" + }, + "jupyterhub-1.4.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "entrypoints", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85efd67283a436ba6583260cd707ecdc", + "name": "jupyterhub", + "sha256": "08ea7c578eb1bf550e69f79ce0279cba862f75cba1bbe1c05ccaf385d3f78091", + "size": 1604990, + "subdir": "linux-64", + "timestamp": 1626856695303, + "version": "1.4.2" + }, + "jupyterhub-1.4.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "entrypoints", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2c8810a46ddd357c07b47ed6b762d092", + "name": "jupyterhub", + "sha256": "07c9ffcc9afdf96b0b269ecbd2f7debb676758d22c93f04c60918ead59440df5", + "size": 1605034, + "subdir": "linux-64", + "timestamp": 1626856646700, + "version": "1.4.2" + }, + "jupyterhub-1.4.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "entrypoints", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a0cc59df685d98c2702b6c6c0e3ad05f", + "name": "jupyterhub", + "sha256": "af5b7f68334f4c1f92173b8ab7f1c2b55ac957889456dcab889485eaf4ab40bb", + "size": 1604824, + "subdir": "linux-64", + "timestamp": 1626856601534, + "version": "1.4.2" + }, + "jupyterhub-3.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "packaging", + "pamela", + "prometheus_client >=0.4.0", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0eaaa2abad2d229166fff3f94995013d", + "name": "jupyterhub", + "sha256": "cc14590a1ffd7784dbf8333c110e2035d3b874287d03a1d9f900956ceca7ef86", + "size": 2083707, + "subdir": "linux-64", + "timestamp": 1671135622360, + "version": "3.1.0" + }, + "jupyterhub-3.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "importlib_metadata >=3.6", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "packaging", + "pamela", + "prometheus_client >=0.4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e68134a6a9841b6ed07fce7965b53e20", + "name": "jupyterhub", + "sha256": "482dd3eafb39ed9ae108bf2bc2761b8e589cb94590c33655c39f983d0031fdec", + "size": 2075302, + "subdir": "linux-64", + "timestamp": 1671135579182, + "version": "3.1.0" + }, + "jupyterhub-3.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "importlib_metadata >=3.6", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "packaging", + "pamela", + "prometheus_client >=0.4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a107ad77c77a4d35c61d87859b6189d", + "name": "jupyterhub", + "sha256": "36d297bc404c9f2c15fe53d512ca884f752b96bf41cd5dd013de83f6d8cc1804", + "size": 2079187, + "subdir": "linux-64", + "timestamp": 1671135533292, + "version": "3.1.0" + }, + "jupyterhub-3.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "importlib_metadata >=3.6", + "jinja2 >=2.11.0,<3.0.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "packaging", + "pamela", + "prometheus_client >=0.4.0", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d3f591051e2221b1c6c2cb0eb02004ad", + "name": "jupyterhub", + "sha256": "49094296f1f0797dd0c4d8eee47661640f6cc6f35fe66cd268931e647ab236a0", + "size": 2077988, + "subdir": "linux-64", + "timestamp": 1671135488126, + "version": "3.1.0" + }, + "jupyterhub-3.1.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "jinja2 >=2.11.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "packaging", + "pamela", + "prometheus_client >=0.4.0", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b0be9ee21bc393812f45612eeeef6caf", + "name": "jupyterhub", + "sha256": "05ee380c7b85ff1ae0e33870bd1c0a5ed66040e4086076e00afa589c311c44f1", + "size": 1920864, + "subdir": "linux-64", + "timestamp": 1675293528136, + "version": "3.1.1" + }, + "jupyterhub-3.1.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "jinja2 >=2.11.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "packaging", + "pamela", + "prometheus_client >=0.4.0", + "python >=3.11,<3.12.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6f7138281bb6f3373bd82624a0753ec3", + "name": "jupyterhub", + "sha256": "d84ad3ea0554ee13b472a92443578ade73e6186f68d55e5e5cb35b6959a9f121", + "size": 2078141, + "subdir": "linux-64", + "timestamp": 1676844403832, + "version": "3.1.1" + }, + "jupyterhub-3.1.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "importlib_metadata >=3.6", + "jinja2 >=2.11.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "packaging", + "pamela", + "prometheus_client >=0.4.0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bcc7ff1af4e340f51c4fe2f917fa58ae", + "name": "jupyterhub", + "sha256": "fc36e7c4e7934b5ac0495541bf4a19a9fc4a1fa44371ae031e666f25608f758e", + "size": 1916447, + "subdir": "linux-64", + "timestamp": 1675293481209, + "version": "3.1.1" + }, + "jupyterhub-3.1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "importlib_metadata >=3.6", + "jinja2 >=2.11.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "packaging", + "pamela", + "prometheus_client >=0.4.0", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6158710412b703b528c0c0f23d9df6dd", + "name": "jupyterhub", + "sha256": "a80e2c5f95ab67d96b7c3b77f0f1137cb7ce2776d2ead05d073b80c8548135f1", + "size": 1918599, + "subdir": "linux-64", + "timestamp": 1675293611477, + "version": "3.1.1" + }, + "jupyterhub-3.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "alembic >=1.4", + "async_generator >=1.9", + "certipy >=0.1.2", + "configurable-http-proxy", + "importlib_metadata >=3.6", + "jinja2 >=2.11.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "packaging", + "pamela", + "prometheus_client >=0.4.0", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2a0d0e4c2348da3d46a0c570d15a14dd", + "name": "jupyterhub", + "sha256": "c0ec552396e4f5384286aaaa03d07e327bab72808e4c5ee99c1015d4fdac72b6", + "size": 1919400, + "subdir": "linux-64", + "timestamp": 1675293569907, + "version": "3.1.1" + }, + "jupyterhub-base-1.3.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "alembic", + "async_generator >=1.9", + "certipy >=0.1.2", + "entrypoints", + "jinja2 >=2.11.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "md5": "4058409570ce4042e46a378270f7197a", + "name": "jupyterhub-base", + "sha256": "5ade90f796fc4dcb1d633029256b5876490b6338f3871414a3a8bf9e6fda9b2b", + "size": 1604567, + "subdir": "linux-64", + "timestamp": 1615900875567, + "version": "1.3.0" + }, + "jupyterhub-base-1.3.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "alembic", + "async_generator >=1.9", + "certipy >=0.1.2", + "entrypoints", + "jinja2 >=2.11.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "md5": "b22907198072ad148db0dda586e4ad74", + "name": "jupyterhub-base", + "sha256": "8b32b8c8b05e0ee4fd7cdcf1070ce8e35733f852e644bc76ee97005f9469f615", + "size": 1609798, + "subdir": "linux-64", + "timestamp": 1615899016369, + "version": "1.3.0" + }, + "jupyterhub-base-1.3.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "alembic", + "async_generator >=1.9", + "certipy >=0.1.2", + "entrypoints", + "jinja2 >=2.11.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "md5": "79dd5aad91cd11525deb4e9ccb491247", + "name": "jupyterhub-base", + "sha256": "bb0b80a19b186363111db0a42ed84c32f0a3d000f5b0940bf70a93ad0449d6d0", + "size": 1612098, + "subdir": "linux-64", + "timestamp": 1615900865293, + "version": "1.3.0" + }, + "jupyterhub-base-1.3.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "alembic", + "async_generator >=1.9", + "certipy >=0.1.2", + "entrypoints", + "jinja2 >=2.11.0", + "jupyter_telemetry >=0.1.0", + "oauthlib >=3.0", + "pamela", + "prometheus_client >=0.4.0", + "pycurl", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests", + "sqlalchemy >=1.1", + "tornado >=5.1", + "traitlets >=4.3.2" + ], + "license": "BSD-3-Clause", + "md5": "00293ecf66edf016beab6c4004edea7d", + "name": "jupyterhub-base", + "sha256": "fcdda2845fd6391aa207f35f7ea1aa571765c00101deff84cd13f9a0a625f59e", + "size": 1606191, + "subdir": "linux-64", + "timestamp": 1615900866032, + "version": "1.3.0" + }, + "jupyterhub-singleuser-1.3.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "jupyterhub-base 1.3.0 py36h06a4308_1", + "notebook >=4", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "83ea122e719abbf94e2bf3f8b927573d", + "name": "jupyterhub-singleuser", + "sha256": "ec7d7ac87ab776cb8c655e421de63b5f1cfa6f926d94ef6840384fea8fce72d8", + "size": 12844, + "subdir": "linux-64", + "timestamp": 1615900892038, + "version": "1.3.0" + }, + "jupyterhub-singleuser-1.3.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "jupyterhub-base 1.3.0 py37h06a4308_1", + "notebook >=4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "4aefedaf015abfc0627672f728da8d4a", + "name": "jupyterhub-singleuser", + "sha256": "d52e8c089c9954073a7d72de6aa775d525cc86d314b516bfae7111be78d631d3", + "size": 12837, + "subdir": "linux-64", + "timestamp": 1615899032777, + "version": "1.3.0" + }, + "jupyterhub-singleuser-1.3.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "jupyterhub-base 1.3.0 py38h06a4308_1", + "notebook >=4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "eb61720b72046646648341a34e300928", + "name": "jupyterhub-singleuser", + "sha256": "a897fa47079031ace11d1ad889a2006e49296725555e68950bb7137aa93629cd", + "size": 12840, + "subdir": "linux-64", + "timestamp": 1615900880611, + "version": "1.3.0" + }, + "jupyterhub-singleuser-1.3.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "jupyterhub-base 1.3.0 py39h06a4308_1", + "notebook >=4", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9096134ff32bff290fc8122a34e1e6b6", + "name": "jupyterhub-singleuser", + "sha256": "609da1aef0c423aac44adbcc245055cabdab04714d13c1b9633d0646ecf6f86a", + "size": 12846, + "subdir": "linux-64", + "timestamp": 1615900882805, + "version": "1.3.0" + }, + "jupyterlab-0.27.0-py27h42ebfef_2.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27h42ebfef_2", + "build_number": 2, + "depends": [ + "jupyterlab_launcher >=0.4.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "md5": "93e8f7c6b188a6baea9e6f1dad3847c7", + "name": "jupyterlab", + "sha256": "23715f53b65e32d485bb053cbb182549b8215c067f82912437160a0120b88ff9", + "size": 2434630, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1505691039765, + "type": "app", + "version": "0.27.0" + }, + "jupyterlab-0.27.0-py35h29561ed_2.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35h29561ed_2", + "build_number": 2, + "depends": [ + "jupyterlab_launcher >=0.4.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "md5": "3854707e9fc374766f217b52e60ebe78", + "name": "jupyterlab", + "sha256": "9c1cbd107116172e8bdae6d0e1bc633efab9fbe76c35dd5aef3c46d319e5139e", + "size": 2439924, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1505691060028, + "type": "app", + "version": "0.27.0" + }, + "jupyterlab-0.27.0-py36h86377d0_2.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36h86377d0_2", + "build_number": 2, + "depends": [ + "jupyterlab_launcher >=0.4.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "md5": "863ee1550d99662216ba2d84db99fe45", + "name": "jupyterlab", + "sha256": "58c34dfe1d35d1152142ce53a1ea624d2f0df109a01a8c707469a6e9e341a3b9", + "size": 2424218, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1505691080678, + "type": "app", + "version": "0.27.0" + }, + "jupyterlab-0.30.4-py27_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.6.0,<0.7.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c75016069c43d39c3c1338f72b9aaab0", + "name": "jupyterlab", + "sha256": "473dee14ccd759a3b41f3145e5dfd39ae19e7851f6e52205c29b09fe35333f5f", + "size": 3306023, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1512661433769, + "type": "app", + "version": "0.30.4" + }, + "jupyterlab-0.30.4-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.6.0,<0.7.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "809d91f180c5f2c353bd14b893fb5a35", + "name": "jupyterlab", + "sha256": "ce3b41221beb2da1e4d94ebce7f92e71f29399d3028045df67a5cdccbb41fa83", + "size": 3312538, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1512661427206, + "type": "app", + "version": "0.30.4" + }, + "jupyterlab-0.30.4-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.6.0,<0.7.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2f84c2c423e27c12225d368cacafc9af", + "name": "jupyterlab", + "sha256": "484389fca1676691e3b8839cd78eb4ace11802fff309b5f3fce9d24771d30bb0", + "size": 3324704, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1512661486641, + "type": "app", + "version": "0.30.4" + }, + "jupyterlab-0.30.5-py27_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.6.0,<0.7.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e96260a8758676c2dafc0802664f262f", + "name": "jupyterlab", + "sha256": "a1aa09356393ceb97039f6cd33954948a37bae8289640efc2e16891a320c172f", + "size": 3306107, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1512748510835, + "type": "app", + "version": "0.30.5" + }, + "jupyterlab-0.30.5-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.6.0,<0.7.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3b613c2bbb6a0724c03886b5fa8bb5cc", + "name": "jupyterlab", + "sha256": "a6a34fa41e7aa2af3a0bb9d62b5cfb37c0c45eedba1c29448ab67387ccf83991", + "size": 3342800, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1512748519990, + "type": "app", + "version": "0.30.5" + }, + "jupyterlab-0.30.5-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.6.0,<0.7.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "090191da0e7e249646050c1e9c779f0e", + "name": "jupyterlab", + "sha256": "e2f9af1efc2590399f1e48217aa24f7cc5120fe7aa61b9328e53f69742224ed6", + "size": 3325312, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1512748504472, + "type": "app", + "version": "0.30.5" + }, + "jupyterlab-0.30.6-py27h5233db4_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27h5233db4_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.6.0,<0.7.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "43a8847af275480055237409dce0124e", + "name": "jupyterlab", + "sha256": "2999153a8a79f1e5f6f3c4ceeb525c771a2afbf09461abacc797e9fb353a65f8", + "size": 3300765, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1513007702360, + "type": "app", + "version": "0.30.6" + }, + "jupyterlab-0.30.6-py35h2f9c1c0_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35h2f9c1c0_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.6.0,<0.7.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1e24fcc0e64695f5ed57d625cef2e1b4", + "name": "jupyterlab", + "sha256": "ff15668c81995f2e47dafe40a2f6072efaa7160958f7002163d31a91bb8391c0", + "size": 3341290, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1513007738216, + "type": "app", + "version": "0.30.6" + }, + "jupyterlab-0.30.6-py36h2f9c1c0_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36h2f9c1c0_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.6.0,<0.7.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0d67b4a4fcf1e4c341e643051c184090", + "name": "jupyterlab", + "sha256": "db7a2921317bed82013b10d4b03134663959feb00e1401b50dd322127e046909", + "size": 3324799, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1513007762094, + "type": "app", + "version": "0.30.6" + }, + "jupyterlab-0.31.0-py27_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8cdef7c3dbef22456d8da26c98be84ff", + "name": "jupyterlab", + "sha256": "357e358ba8cda30628f1f158530116c5b1f8158062644c4e56681dd97d18f482", + "size": 2214787, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1515950051675, + "type": "app", + "version": "0.31.0" + }, + "jupyterlab-0.31.0-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "90378139b11bc68a8a6fc739e4bb1d1e", + "name": "jupyterlab", + "sha256": "0b3b7ebb8562e1be93840a4293f4e5d3a014964a9da983c0e2c1c560ce6b34d1", + "size": 2216378, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1515950062650, + "type": "app", + "version": "0.31.0" + }, + "jupyterlab-0.31.0-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a1c4da13683633664ee72ac3cbfc768f", + "name": "jupyterlab", + "sha256": "19fb9abc131766a212f7f9c4cd12420144ee41ca8c85f01a49c879b0032ef4f8", + "size": 2214935, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1515950039360, + "type": "app", + "version": "0.31.0" + }, + "jupyterlab-0.31.1-py27_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "80c73736ace6ad647bc45b4f963620c1", + "name": "jupyterlab", + "sha256": "f50ab988cee53ac4720346bc56db51c45c5b1dfec40931970f0cedfefe4b4a0d", + "size": 4499388, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1515951260764, + "type": "app", + "version": "0.31.1" + }, + "jupyterlab-0.31.1-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3d272e1a18731c0f78ff8f05e1b3866a", + "name": "jupyterlab", + "sha256": "91b90357d579e5326c617bbe3ef2765f588a123e8e087809fe846efcb76d584e", + "size": 4499524, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1515951301584, + "type": "app", + "version": "0.31.1" + }, + "jupyterlab-0.31.1-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7328dbce048ede399dd2172564aff8f9", + "name": "jupyterlab", + "sha256": "5f5c6417fa202af6729589347c26cc2dc3dc99fdba6d0a2ac500f77ce91a9c41", + "size": 4498532, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1515951221467, + "type": "app", + "version": "0.31.1" + }, + "jupyterlab-0.31.10-py27_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "48bcb8dc95e8f047525d65d9c7c8e75f", + "name": "jupyterlab", + "sha256": "411ed046988a315870f98412a982bf423504e38dd2ab62683feacfdde66db958", + "size": 4507323, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1519920180924, + "type": "app", + "version": "0.31.10" + }, + "jupyterlab-0.31.10-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dd87c081a942200eea5dfcf9b9de53cb", + "name": "jupyterlab", + "sha256": "4175ee5b736a79a11cc18ea442a0d9b94396a9f1d6610deca178ad424331f345", + "size": 4510788, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1519920306726, + "type": "app", + "version": "0.31.10" + }, + "jupyterlab-0.31.10-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "579dc56639802958e36253a05506bc87", + "name": "jupyterlab", + "sha256": "9071d4b17708bf8437ba6cd2e3de86d580de949b91b90764c3f149c8c4351c6a", + "size": 4508957, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1519920322013, + "type": "app", + "version": "0.31.10" + }, + "jupyterlab-0.31.11-py27_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2242cdb528ab535276775575a45a2528", + "name": "jupyterlab", + "sha256": "826932a7e1170cb1cf015e873cc1fd353807f3a1e13a1ee62a755b77a488cb1b", + "size": 4508139, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1520521453016, + "type": "app", + "version": "0.31.11" + }, + "jupyterlab-0.31.11-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0bbf19f69be47dcefcc8c6f20f5445a5", + "name": "jupyterlab", + "sha256": "aa173ed1623f5da75ba229fa28f7a0f18afc251f3d18d618eff9f031d44967fb", + "size": 4510991, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1520521456795, + "type": "app", + "version": "0.31.11" + }, + "jupyterlab-0.31.11-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "55af4d9def1aa434ba09fbf81e453245", + "name": "jupyterlab", + "sha256": "f710a5567264c6ec84b662f8821cc22e613451fb6899e4a82a6d88c29dc58a06", + "size": 4508376, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1520521613183, + "type": "app", + "version": "0.31.11" + }, + "jupyterlab-0.31.12-py27_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6f2bdb7501580df084d55d830b9ca936", + "name": "jupyterlab", + "sha256": "8da4b396044f353d744d63ce1b0a1c585b62e897a8fc40ee57b2ee9f1d621e11", + "size": 4519677, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1520522807685, + "type": "app", + "version": "0.31.12" + }, + "jupyterlab-0.31.12-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2cc2e4904c07013b799e7009e6993df4", + "name": "jupyterlab", + "sha256": "5965ca4419e839df72afc3a7eaaf49eaa6c052a9721484a7c9e67df35d2fa5cd", + "size": 4520056, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1520522816532, + "type": "app", + "version": "0.31.12" + }, + "jupyterlab-0.31.12-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a67f491cf8bba8146ce7c9323c6a3ca5", + "name": "jupyterlab", + "sha256": "af63e040f3c4c7ac3b843197580d6fe86d2c668e85fe5a1e5081eb740c9fa0a8", + "size": 4517306, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1520522818492, + "type": "app", + "version": "0.31.12" + }, + "jupyterlab-0.31.2-py27_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "86ff6d6b14c7a29e434fe6572e316b1f", + "name": "jupyterlab", + "sha256": "c57f20089a0cda145d4125720665cd9b613f1ef5809626daa6c4c1def3b0422a", + "size": 4503912, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1517330752002, + "type": "app", + "version": "0.31.2" + }, + "jupyterlab-0.31.2-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d2c3b68b80495e41919b5a60b25ff027", + "name": "jupyterlab", + "sha256": "429a2888a9a52371c5a8ca74249280c8c7d46e2db3fec25e1955dc5d913f7342", + "size": 4505779, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1517330741099, + "type": "app", + "version": "0.31.2" + }, + "jupyterlab-0.31.2-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "64c92c75ba69da0d67f6315c6812ff87", + "name": "jupyterlab", + "sha256": "66bcdcf143bbc0819fa585a066fb22cfab6db13c66f0870f84634c120102c58f", + "size": 4500826, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1517330738162, + "type": "app", + "version": "0.31.2" + }, + "jupyterlab-0.31.3-py27_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "761cded5c04d95d7d1b7e2fbae2960c9", + "name": "jupyterlab", + "sha256": "b6f9a018fa47b25ca7e1c7efb0c5421ec9351a726b887847087109ee3d969287", + "size": 4505274, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1517937285085, + "type": "app", + "version": "0.31.3" + }, + "jupyterlab-0.31.3-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5754c4d54ef878a165544c7246d2f596", + "name": "jupyterlab", + "sha256": "6fd7a8c1d5a86ffff7acda80cc951fe2767e70e6ad828bfe6f6c65c55888fee8", + "size": 4507466, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1517937352628, + "type": "app", + "version": "0.31.3" + }, + "jupyterlab-0.31.3-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a118b9518eff17c7de68691318bc15a4", + "name": "jupyterlab", + "sha256": "8d0618a22785e372a8882470e6ad85b58b33cefed4b0965bd151fa9843e73a35", + "size": 4506659, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1517937351015, + "type": "app", + "version": "0.31.3" + }, + "jupyterlab-0.31.4-py27_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fb9099fa1acd5bd0191d27cca8b49344", + "name": "jupyterlab", + "sha256": "338f0209989178a2a74c234a2141cc2952a83cfe22976a3b24330a57075688b0", + "size": 4503672, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1517940187348, + "type": "app", + "version": "0.31.4" + }, + "jupyterlab-0.31.4-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fc72938f9f04bf6ff74a86ac312b6a11", + "name": "jupyterlab", + "sha256": "8fa865ade8902eaa66661a2160628da7b9369a8c45d02080cd7ab623e83314f8", + "size": 4505983, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1517940253876, + "type": "app", + "version": "0.31.4" + }, + "jupyterlab-0.31.4-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8d8c9a3df0fb5f0efc1cdbf44261915a", + "name": "jupyterlab", + "sha256": "877011e66a57a217b3d4d3cab020f52b4b4b425cffac5309e44efa33aca2b5fc", + "size": 4504668, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1517940203029, + "type": "app", + "version": "0.31.4" + }, + "jupyterlab-0.31.5-py27_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2c6d351aa9aeeee67f333b7d84a6aaa4", + "name": "jupyterlab", + "sha256": "eecaabea39faa97d82e1232462808a9d07705226057b80c596472caa69d83255", + "size": 4505025, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1518196757728, + "type": "app", + "version": "0.31.5" + }, + "jupyterlab-0.31.5-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dbccc07f8f54d8867da6477aa1eb4b27", + "name": "jupyterlab", + "sha256": "b576e283823c6e341df18cd9cd3a3cdacfc195cc2534dd301877dd1b5a30ea12", + "size": 4506759, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1518196834610, + "type": "app", + "version": "0.31.5" + }, + "jupyterlab-0.31.5-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9355532ef80199dde228431a6ba3895d", + "name": "jupyterlab", + "sha256": "7a70de2aa94104eaa0038c2bbd44063cdd728307457d66bfe2089044ca2eb53b", + "size": 4505118, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1518196831334, + "type": "app", + "version": "0.31.5" + }, + "jupyterlab-0.31.6-py27_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c653017e8dafa0076a14096a34103ab2", + "name": "jupyterlab", + "sha256": "686bdf5b0544463c936d713f4402ee453720e12f22af132c8222cfabccf6873a", + "size": 4504648, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1518800639943, + "type": "app", + "version": "0.31.6" + }, + "jupyterlab-0.31.6-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eb55959c5ac1ae6abfbaca2d398700ac", + "name": "jupyterlab", + "sha256": "80be516a1c62c7bed88ab8fddfaa5d1307a0efe180a7e9333fc2cfd100c9b93f", + "size": 4507374, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1518800665355, + "type": "app", + "version": "0.31.6" + }, + "jupyterlab-0.31.6-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ffdb911b450cacec889e178f19a6c544", + "name": "jupyterlab", + "sha256": "43cb166f2ec392236e54fb116725fe86e27a7a8fa2dbf4f4faee32267ab957f5", + "size": 4503952, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1518800667349, + "type": "app", + "version": "0.31.6" + }, + "jupyterlab-0.31.8-py27_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "57b9efb5d682b88e33a45bdc9c588372", + "name": "jupyterlab", + "sha256": "8c491f17fd710729bae8210f233f317bca5e66a0b2863d9e38a24e45eb4e1603", + "size": 4505089, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1518802021283, + "type": "app", + "version": "0.31.8" + }, + "jupyterlab-0.31.8-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d35a4f0e07ff112c1272d7410e7ee76e", + "name": "jupyterlab", + "sha256": "d0477af4456728963d8d112aab4c0bbb90fa1f62dd8e05b5679fc5875f5d999b", + "size": 4506595, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1518802065738, + "type": "app", + "version": "0.31.8" + }, + "jupyterlab-0.31.8-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "987f9755f1c2502886954bd9f014fdd9", + "name": "jupyterlab", + "sha256": "23336e105ca8e6003f4efe02fec74b2d8abde3c5623cb3639a58b52a56998cd0", + "size": 4506282, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1518802055805, + "type": "app", + "version": "0.31.8" + }, + "jupyterlab-0.31.9-py27_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "42dc60e9cca0f6c7cc8003516800c982", + "name": "jupyterlab", + "sha256": "9e6f158f0e5d59cc97c95521169744b1d39d83f648bd075a812bb1130a5a1c36", + "size": 4503815, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1519832193936, + "type": "app", + "version": "0.31.9" + }, + "jupyterlab-0.31.9-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "659f184e206311505f965563131404c0", + "name": "jupyterlab", + "sha256": "e0c6f4edc41a29016b636f02f9c9bc0ef395b6703b7b5f2baa1c27ecd8770a3f", + "size": 4507072, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1519832223468, + "type": "app", + "version": "0.31.9" + }, + "jupyterlab-0.31.9-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8b0fe1882c51fa0409741095c67f25b5", + "name": "jupyterlab", + "sha256": "c4758e71bc90467b0d720aa19985745b4e3a9dadbb0d4d58c3a6465264e84aab", + "size": 4505612, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1519832815809, + "type": "app", + "version": "0.31.9" + }, + "jupyterlab-0.32.0-py27_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "05d4c98d67c037f9f19fcfafee98f68f", + "name": "jupyterlab", + "sha256": "fa3ae5db52d67c83b008b52a33f4bdb06b74cdd87d1629b70f3851b90edb106e", + "size": 5055248, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1524231812960, + "type": "app", + "version": "0.32.0" + }, + "jupyterlab-0.32.0-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "39f82d188374bbda726bb18267ffa65d", + "name": "jupyterlab", + "sha256": "11b4254d9b8b86da91db575efd57772af8cae4226ca6aba9e61c2bf053a4e2d6", + "size": 5057518, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1524231938986, + "type": "app", + "version": "0.32.0" + }, + "jupyterlab-0.32.0-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "25d6446e7e6a8e6cf96dc9408d11b87a", + "name": "jupyterlab", + "sha256": "c415e61c0dba4d610396473a8f4dfc9d09add3f62e9a34692e5626700d6f0b74", + "size": 5056466, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1524231943681, + "type": "app", + "version": "0.32.0" + }, + "jupyterlab-0.32.1-py27_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ea2d4654cf308231ab6e2203b47f8ac8", + "name": "jupyterlab", + "sha256": "97342f05b9771249209ab487bab6d415d0cf0af7cadcfcaf02f34c41a2b1d5de", + "size": 5090838, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1525117196419, + "type": "app", + "version": "0.32.1" + }, + "jupyterlab-0.32.1-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "039e980b413a642b0a199c398c049480", + "name": "jupyterlab", + "sha256": "afbd73e7b8a41bd3100853759d95e487c3434097fe8462c2362cc18f4980e8e2", + "size": 5092468, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1525117222090, + "type": "app", + "version": "0.32.1" + }, + "jupyterlab-0.32.1-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.10.0,<0.11.0", + "notebook >=4.3", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "199608a1ab40bc8f7bcdd86e7dacf714", + "name": "jupyterlab", + "sha256": "99849a4143f391da5d7d4f6308bf2815775d5e94f3a651c12db801518a573aa2", + "size": 5089254, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1525117205771, + "type": "app", + "version": "0.32.1" + }, + "jupyterlab-0.32.1-py37_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.11.0,<0.12.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "971ea876f8bfa4e9c8a0f1af29a6b2cc", + "name": "jupyterlab", + "sha256": "4f41f671745e6b699052090ed27a841ffb29ee50ee3e553e0f622e77534ed2f0", + "size": 5095632, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1530734856746, + "type": "app", + "version": "0.32.1" + }, + "jupyterlab-0.33.11-py27_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "futures", + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a784f26532f07ec047e50d86d55a7b63", + "name": "jupyterlab", + "sha256": "3dac081ca09d4302f49122827cc9ae606bb1544723d7afb8ccacd70431ea29e1", + "size": 4884172, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1534268331242, + "type": "app", + "version": "0.33.11" + }, + "jupyterlab-0.33.11-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "deeea9f466bf773b0746819d32fb26fa", + "name": "jupyterlab", + "sha256": "0bcdbcfadbbe9216c18f71fde6d1221e5a4a1d206d86b4b4b37f09f924f1ee4e", + "size": 4886412, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1534268353242, + "type": "app", + "version": "0.33.11" + }, + "jupyterlab-0.33.11-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "11f3900992d95953a16f9091c807c8c5", + "name": "jupyterlab", + "sha256": "2cfb2f22c16ba20b6f3290ef882eca6a2726f4a637f9d5cdeb019c9f41074cde", + "size": 4884175, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1534266395710, + "type": "app", + "version": "0.33.11" + }, + "jupyterlab-0.33.11-py37_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "46f845095523202144f49c20c1eb0d6e", + "name": "jupyterlab", + "sha256": "2c1e5692ea7bb8196f5e9f80ddf9b1f0ff2e8a414fb078d2ee01a155c3e48047", + "size": 4883107, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1534266466194, + "type": "app", + "version": "0.33.11" + }, + "jupyterlab-0.33.4-py27_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "futures", + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6b4ec323ea89980fbf12407bc3a21739", + "name": "jupyterlab", + "sha256": "de88e2f6c2f2386ae4da82ade297e478df50d9dac7d70d3032245afba2dc677a", + "size": 4884564, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1532985946522, + "type": "app", + "version": "0.33.4" + }, + "jupyterlab-0.33.4-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2adf141bca2f6454352a908d4543cd20", + "name": "jupyterlab", + "sha256": "aefd355aed19cb3dd20e2bbab7142562ffd39c5b042e409c9b16458ce5d96e8a", + "size": 4886126, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1532986019727, + "type": "app", + "version": "0.33.4" + }, + "jupyterlab-0.33.4-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "28c3a9237f7f6b9f50113e0f6e710bf8", + "name": "jupyterlab", + "sha256": "ed803ef7e99c9442a89fc2c8a0be95708944c09272d59ab99a0e3026557d5e1e", + "size": 4884136, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1532985876120, + "type": "app", + "version": "0.33.4" + }, + "jupyterlab-0.33.4-py37_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "42ea9cab3979fadd500403c450df4a03", + "name": "jupyterlab", + "sha256": "3c9a03d03f318e35b38ac567ab8d97ba86d559e428b7f73817c4aa3578bc2579", + "size": 4884353, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1532986002212, + "type": "app", + "version": "0.33.4" + }, + "jupyterlab-0.33.8-py27_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "futures", + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=2.7,<2.8.0a0", + "subprocess32" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0e4f7d3fbe73e90ff7a0b1fb5618c546", + "name": "jupyterlab", + "sha256": "18ca98a1764cf5d05be0bddf2e80863e28f7fa1d7c5c01a6b2063c2c06b3222f", + "size": 4884170, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1533752021561, + "type": "app", + "version": "0.33.8" + }, + "jupyterlab-0.33.8-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85edaf905edad7816bd7bfe1ae8a20e6", + "name": "jupyterlab", + "sha256": "b7da4cf6d5625ada919dedb95a3f0f5159dd2530446d11c4cc0a2e83cb0cd899", + "size": 4885833, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1533752082681, + "type": "app", + "version": "0.33.8" + }, + "jupyterlab-0.33.8-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "89150ba0ab5ad9f54a931d6adef39711", + "name": "jupyterlab", + "sha256": "ecc6b84ce841be16b78be5aa67d82577c33d58130c07bfff32554912e0ef2507", + "size": 4885230, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1533752011446, + "type": "app", + "version": "0.33.8" + }, + "jupyterlab-0.33.8-py37_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "constrains": [ + "nodejs <10" + ], + "depends": [ + "jupyterlab_launcher >=0.11.2,<0.12.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e9accb23251d87234ec21b2cb19b917f", + "name": "jupyterlab", + "sha256": "0b684bac9a411b6e061c91553048d9b6ebc055339d240029183bb4f8d51eb794", + "size": 4884960, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1533752022968, + "type": "app", + "version": "0.33.8" + }, + "jupyterlab-0.34.1-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1062127e87ee822049ff3bb9676b0e8f", + "name": "jupyterlab", + "sha256": "31ace0e52358b8a36b94eb3f429f0d862d21904c32f0bcd76119492418396ea2", + "size": 4815980, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1534946826941, + "type": "app", + "version": "0.34.1" + }, + "jupyterlab-0.34.1-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b646c8af4838d7cfa4f03f3b41050ab3", + "name": "jupyterlab", + "sha256": "7291f3c27740f9eb04e48ca636918938097a0b7e60154ce1009c935fbb455c21", + "size": 4814910, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1534946799045, + "type": "app", + "version": "0.34.1" + }, + "jupyterlab-0.34.1-py37_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "747aa1638f547ac091bad987ee41b96b", + "name": "jupyterlab", + "sha256": "a7bf82c08743a22bdf66cf12a9224aa77695f72eb5b0f7807fcbf5ec7c4f29f3", + "size": 4815092, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1534946857011, + "type": "app", + "version": "0.34.1" + }, + "jupyterlab-0.34.12-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f7578192e81b890c6e2b2a962c9df322", + "name": "jupyterlab", + "sha256": "005e2c874738a8db98de2dbc30386346f2912a3259d6dc14a9ca8ffdeb1e33cc", + "size": 4859359, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1538599401293, + "type": "app", + "version": "0.34.12" + }, + "jupyterlab-0.34.12-py37_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c7209d2611e67e63458552351f6178db", + "name": "jupyterlab", + "sha256": "db377d6e603f13926bf282892e30337ad217f14242cdf504e2f5c32c02ab0b39", + "size": 4861493, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1538599389027, + "type": "app", + "version": "0.34.12" + }, + "jupyterlab-0.34.3-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7ba23af7a0be6b401da6e766052fd54b", + "name": "jupyterlab", + "sha256": "eef7601aa23af1bf9bf3200eddc25e8b418d86d5c5078f82d57686bc2ff978fe", + "size": 4836461, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1535385210313, + "type": "app", + "version": "0.34.3" + }, + "jupyterlab-0.34.3-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "749858c0b88c7bbccd694d2687f60453", + "name": "jupyterlab", + "sha256": "9429826bd4df9f6a47a284af28c68b21cfc610228e7fea1a4dfb68e434d77998", + "size": 4836718, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1535385052723, + "type": "app", + "version": "0.34.3" + }, + "jupyterlab-0.34.3-py37_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "afef91e1cd7990c2360ddeea944ff63c", + "name": "jupyterlab", + "sha256": "fd526c6d969f6d4a51ffb1e2d64c8ef30daa5e8dd2647a026a6163613c87048a", + "size": 4834624, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1535385093018, + "type": "app", + "version": "0.34.3" + }, + "jupyterlab-0.34.7-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6de05f659fefba65bbb39fc2da75ff22", + "name": "jupyterlab", + "sha256": "fdbb3b2f8598fe9039f0270fd42a8c0ded751163f5632cb78669929bbff24268", + "size": 4860930, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1536080200962, + "type": "app", + "version": "0.34.7" + }, + "jupyterlab-0.34.7-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5532c4bd55033fda3a2466002609161d", + "name": "jupyterlab", + "sha256": "96e58a00c37a6cb53a6d7f18fe91e1b745948c3103535cafd51b63835aef223d", + "size": 4857154, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1536080106751, + "type": "app", + "version": "0.34.7" + }, + "jupyterlab-0.34.7-py37_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9889cf2929d59258d3a4b2e71b62b389", + "name": "jupyterlab", + "sha256": "c2f86314b1a44261cab37df8f6bc16f18b575d8f581e6db2f23d0bdc0ff56b2a", + "size": 4859623, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1536083528352, + "type": "app", + "version": "0.34.7" + }, + "jupyterlab-0.34.9-py35_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.5,<3.6.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fb255c294763b24f370bfac00383bd5f", + "name": "jupyterlab", + "sha256": "a3cd369e408e2f939c79e9713de43d4048bbd853265e2209c187e7e4215e0fcb", + "size": 4861607, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1536767434211, + "type": "app", + "version": "0.34.9" + }, + "jupyterlab-0.34.9-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8ba7cdaa421d227378e320778e3eb304", + "name": "jupyterlab", + "sha256": "23e5514df766ac8066136fc7335535755b1e1ec8bcb21e688254e278afbf1677", + "size": 4858803, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1536700699953, + "type": "app", + "version": "0.34.9" + }, + "jupyterlab-0.34.9-py37_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_launcher >=0.13.1,<0.14.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cf3317f522f9976c7d1276a5be969798", + "name": "jupyterlab", + "sha256": "ff419f52241db5b5e131099050a3e4133e8122d407d70a080cfd0fa8acf55ee8", + "size": 4861014, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1536767403298, + "type": "app", + "version": "0.34.9" + }, + "jupyterlab-0.35.0-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "207f10c30052672bb815494726293cff", + "name": "jupyterlab", + "sha256": "497da338c5de902b48c3294e852651d4fcf0c9bb5d97f44a167013be5dd844e7", + "size": 5074840, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1539095156582, + "type": "app", + "version": "0.35.0" + }, + "jupyterlab-0.35.0-py37_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f81e812c430200f1e80b248ee747626", + "name": "jupyterlab", + "sha256": "5a5a238dcfb0c1dc67f6db1c3b9a860c5ea93bf32c0dee834241323d67128cc3", + "size": 5073314, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1539095107196, + "type": "app", + "version": "0.35.0" + }, + "jupyterlab-0.35.1-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20a95471bc2651ac5b638cbfbf19be82", + "name": "jupyterlab", + "sha256": "10de4c9cea8cff8f64a351919b901d6a53617a69ac27bf262ee7a38fa874464a", + "size": 5079924, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1539695627210, + "type": "app", + "version": "0.35.1" + }, + "jupyterlab-0.35.1-py37_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22faacc31490d04c03edb868a80683bb", + "name": "jupyterlab", + "sha256": "f40b26022e258b406d6351fcb0195b3f045c377a75ab7d983b2fafb14946efde", + "size": 5081879, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1539695632957, + "type": "app", + "version": "0.35.1" + }, + "jupyterlab-0.35.2-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "be3390fd66f5aa8c3f8eeb8df06638b9", + "name": "jupyterlab", + "sha256": "109c1dc874a902300d55f3668a8783a6e7e1447e618ccb3819d6d1bef53f8b4d", + "size": 5079611, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1540234891875, + "type": "app", + "version": "0.35.2" + }, + "jupyterlab-0.35.2-py37_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "36ca294db4cf58a5bef52130217eab45", + "name": "jupyterlab", + "sha256": "b8d59fcdca79974357a6f7728d43ae2e83ae8355bfe3f821146fdfbfc901b653", + "size": 5081986, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1540234889766, + "type": "app", + "version": "0.35.2" + }, + "jupyterlab-0.35.3-py36_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "947741f73d0c139693f3bc94068dfc61", + "name": "jupyterlab", + "sha256": "65eaafa0422cce9fb9dac4e7103c1e853a488d7271b3f7bae121e454301bfe8c", + "size": 5081813, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1540980644840, + "type": "app", + "version": "0.35.3" + }, + "jupyterlab-0.35.3-py37_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e14333d9fd9f221a4fc09f4c6a00e177", + "name": "jupyterlab", + "sha256": "48b65d00fd050fbb170cd4e46d9e98addaf8a7b8e8045344457a3d8f5c110a2e", + "size": 5082987, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1540980649755, + "type": "app", + "version": "0.35.3" + }, + "jupyterlab-0.35.4-py36hf63ae98_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36hf63ae98_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "02e501a40f72196296776c245c571d6e", + "name": "jupyterlab", + "sha256": "4f8541dda6180dbeb510f5bab918b45c1695d05d274bf2760ae150bcb9fa3cbc", + "size": 5094858, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1552338927961, + "type": "app", + "version": "0.35.4" + }, + "jupyterlab-0.35.4-py37hf63ae98_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37hf63ae98_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fde462e5695c86fa06173b61007219cd", + "name": "jupyterlab", + "sha256": "b9d227f57d35a92a57ec65e274168f8667aea7ca3e19f9301ee8b05e8234bddb", + "size": 5096072, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1552338905887, + "type": "app", + "version": "0.35.4" + }, + "jupyterlab-0.35.5-py36hf63ae98_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36hf63ae98_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "40177c4cf5269433334055bded8d4157", + "name": "jupyterlab", + "sha256": "c50dc5f69d59d57470854a96e6a6278e4e156655fad32c8b74d3bd34b8244e61", + "size": 5112778, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1556288301278, + "type": "app", + "version": "0.35.5" + }, + "jupyterlab-0.35.5-py37hf63ae98_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37hf63ae98_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=0.2.0,<0.3.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e262d34cce3612c75c61b23256aa0b0f", + "name": "jupyterlab", + "sha256": "28d88b8c10f46b4797ec66458e324b97f6d4ecc404146085ce3256259288f343", + "size": 5114836, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1556288282715, + "type": "app", + "version": "0.35.5" + }, + "jupyterlab-1.0.2-py36hf63ae98_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py36hf63ae98_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=1.0.0,<2.0.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0", + "tornado !=6.0.0,!=6.0.1,!=6.0.2" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "25cc7d36e25a9a5f35e302fe16c9610b", + "name": "jupyterlab", + "sha256": "9a11b40b4789bfcef5405cf30d95bb002d1bd6081e5b81d87386e1a8ffc2320f", + "size": 6546004, + "subdir": "linux-64", + "summary": "JupyterLab", + "timestamp": 1563286194193, + "type": "app", + "version": "1.0.2" + }, + "jupyterlab-1.0.2-py37hf63ae98_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37hf63ae98_0", + "build_number": 0, + "depends": [ + "jupyterlab_server >=1.0.0,<2.0.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0", + "tornado !=6.0.0,!=6.0.1,!=6.0.2" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a0c883c51971b02080f890d1b6ed575", + "name": "jupyterlab", + "sha256": "19b003609e080322e0e0ef0216dc45e0f78671369aeb4aa79959795f502e8e84", + "size": 6543647, + "subdir": "linux-64", + "summary": "JupyterLab", + "timestamp": 1563286126507, + "type": "app", + "version": "1.0.2" + }, + "jupyterlab-3.4.4-py310h06a4308_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<2", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.10,<3.11.0a0", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "30a294f714e65285046e14a50ebaf438", + "name": "jupyterlab", + "sha256": "19a7a4a33bffff3cfac67216e09a8d6b712971d1d7ddc118bd0d2e34a1bddcd0", + "size": 3926839, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1658907667387, + "type": "app", + "version": "3.4.4" + }, + "jupyterlab-3.4.4-py37h06a4308_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<2", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.7,<3.8.0a0", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ce0ae7c70655f79272251b9f251cf886", + "name": "jupyterlab", + "sha256": "26e6ca397bb69045e9056dd55fb69958177ad4be46c7818bad4d958aab8ef98a", + "size": 3927006, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1658907751102, + "type": "app", + "version": "3.4.4" + }, + "jupyterlab-3.4.4-py38h06a4308_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<2", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.8,<3.9.0a0", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d2ad281a90f730270a40370e1362aa77", + "name": "jupyterlab", + "sha256": "759b7f3493e73edf2e9547dae38e6c8a3b3b1ff44a48edaf1ad7311fbc1437ec", + "size": 3924078, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1658907573057, + "type": "app", + "version": "3.4.4" + }, + "jupyterlab-3.4.4-py39h06a4308_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<2", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.9,<3.10.0a0", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "21d853c3418f70aca85bb57c91f62f21", + "name": "jupyterlab", + "sha256": "caf6f8ce7f3ae4ceec2f0632c3bedc85ba1eb27b796b940dd03867b8757cadd0", + "size": 3926353, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1658907833263, + "type": "app", + "version": "3.4.4" + }, + "jupyterlab-3.5.0-py310h06a4308_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.10,<3.11.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2d4d3e4b96780d5e9c0e44be9a155418", + "name": "jupyterlab", + "sha256": "f391ad45bf2f948403d41d3e0e9983eef04ea46c98b063ad934750580a01bf39", + "size": 4397591, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1669368595313, + "type": "app", + "version": "3.5.0" + }, + "jupyterlab-3.5.0-py37h06a4308_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.7,<3.8.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "10aeb604a5b764af9193c33cee624bbb", + "name": "jupyterlab", + "sha256": "e5e51e384b6c795185a35b1b96fc3e6d6946247269e81175f08b5ce399a9ad50", + "size": 4395596, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1669368496128, + "type": "app", + "version": "3.5.0" + }, + "jupyterlab-3.5.0-py38h06a4308_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.8,<3.9.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "03327028f8a9d9d58cf69a8bc744559a", + "name": "jupyterlab", + "sha256": "f99ff13e886ea46e965c1169c565cf14fc4de9e2012b0d3b0de5c1d51eff50ef", + "size": 4396216, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1669368682316, + "type": "app", + "version": "3.5.0" + }, + "jupyterlab-3.5.0-py39h06a4308_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.9,<3.10.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "02096784263aab674ffd1a095daa869b", + "name": "jupyterlab", + "sha256": "9157b19c109d9d770322e4110f3b0c6b3fffb816ad0d83a120523394503e3325", + "size": 4399348, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1669368769612, + "type": "app", + "version": "3.5.0" + }, + "jupyterlab-3.5.2-py310h06a4308_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.10,<3.11.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "99d32d00797489d19077490b79bf599c", + "name": "jupyterlab", + "sha256": "f536e4c953beddb25679cc842477f8707f459b7ac81d4a0e3dbdea0f155e2f56", + "size": 4399437, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1672132901521, + "type": "app", + "version": "3.5.2" + }, + "jupyterlab-3.5.2-py37h06a4308_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.7,<3.8.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cac0bb0fe4a129540ca19e372a9974cd", + "name": "jupyterlab", + "sha256": "7591fe3b532428e03c8731e5ed4b05387ac2a176ddbf5c6aac16e5e19c09f5f7", + "size": 4402596, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1672132982831, + "type": "app", + "version": "3.5.2" + }, + "jupyterlab-3.5.2-py38h06a4308_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.8,<3.9.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "76c44f09f9e97dd6b78b5b37850b17f1", + "name": "jupyterlab", + "sha256": "ad3f635c490332f82681e38f4080672c977f88cf79436b2a9e87196b11112c8e", + "size": 4397854, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1672132726593, + "type": "app", + "version": "3.5.2" + }, + "jupyterlab-3.5.2-py39h06a4308_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.9,<3.10.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fcef8342a8e024048e0e1177607d3e55", + "name": "jupyterlab", + "sha256": "9634657986e69009c8567e206f916c72c4f86c6ce12238f5d044dfa9170fee9f", + "size": 4398265, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1672132821306, + "type": "app", + "version": "3.5.2" + }, + "jupyterlab-3.5.3-py310h06a4308_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.10,<3.11.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f44063a16b6ddc48d92f49f99ac2f4d8", + "name": "jupyterlab", + "sha256": "1c1f89aec7564aa01eb1245d90b135273aacd53e8d631ca710b697afc2de7013", + "size": 4606865, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1675354153054, + "type": "app", + "version": "3.5.3" + }, + "jupyterlab-3.5.3-py311h06a4308_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.11,<3.12.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "064b5480bb6e60f0710c9abc9f8498e5", + "name": "jupyterlab", + "sha256": "dd2b06a31d77f854d4e185b31b6b841710450763ef208eab460ab66f3ff006c4", + "size": 4195067, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1677874041337, + "type": "app", + "version": "3.5.3" + }, + "jupyterlab-3.5.3-py37h06a4308_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.7,<3.8.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aa5becd1a61937689e7ea60b46d95436", + "name": "jupyterlab", + "sha256": "c0c89c7fd9167e92e889ffab69ff4c4d9225d9a8bee7e82c16816ba9bb4ef883", + "size": 4603424, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1675354347491, + "type": "app", + "version": "3.5.3" + }, + "jupyterlab-3.5.3-py38h06a4308_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.8,<3.9.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5fa12ba70fa91b1a89dd1ad8506fee71", + "name": "jupyterlab", + "sha256": "3bf785574a7769d6a5861b578bedae26f9fe46e9c469d48c73114d3aee67f3e5", + "size": 4605792, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1675354257535, + "type": "app", + "version": "3.5.3" + }, + "jupyterlab-3.5.3-py39h06a4308_0.conda": { + "app_entry": "jupyter lab", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "jinja2 >=2.1", + "jupyter_core", + "jupyter_server >=1.16,<3", + "jupyterlab_server >=2.10,<3", + "nbclassic", + "notebook <7", + "packaging", + "python >=3.9,<3.10.0a0", + "tomli", + "tornado >=6.1.0" + ], + "icon": "717340b6962ac8f292a17e7fa60ab5e7.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2263c52edf30aea5ebf2b7f6d5e5b18e", + "name": "jupyterlab", + "sha256": "4c8590f53662cf8bb14551a574baa5105c05611a6d04602b732d98b70132ee94", + "size": 4605870, + "subdir": "linux-64", + "summary": "JupyterLab PRE-ALPHA", + "timestamp": 1675354436606, + "type": "app", + "version": "3.5.3" + }, + "jupyterlab-geojson-3.3.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6c23bac963ff529db0373ccaa62e63a3", + "name": "jupyterlab-geojson", + "sha256": "526b45544958ed72eba0d909ed4647b68d8feadd81ecf52862e9445a6ef4baac", + "size": 82920, + "subdir": "linux-64", + "timestamp": 1679915894232, + "version": "3.3.1" + }, + "jupyterlab-geojson-3.3.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7c6a82d1381112e9ac08506bfa98e0a7", + "name": "jupyterlab-geojson", + "sha256": "65a3aa722743fece98c89c9b3cdeaae193eb275d3c7db0e995bab6729a2b170e", + "size": 83527, + "subdir": "linux-64", + "timestamp": 1679916010600, + "version": "3.3.1" + }, + "jupyterlab-geojson-3.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aa282048ddec357b2cf8abe04a3d8e9d", + "name": "jupyterlab-geojson", + "sha256": "b918152c06727d63332b03ce37759688fe369db8787375a0457abf8665ed827c", + "size": 82943, + "subdir": "linux-64", + "timestamp": 1679915952791, + "version": "3.3.1" + }, + "jupyterlab-geojson-3.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "13d2c33c3b69ee3dbae680265951ad6f", + "name": "jupyterlab-geojson", + "sha256": "2efd562348074ce6e937d0373bea0fda8ea26c9445ccf3fee30563e823d34afd", + "size": 82856, + "subdir": "linux-64", + "timestamp": 1679915837752, + "version": "3.3.1" + }, + "jupyterlab_launcher-0.10.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dd8b682f74e0f879a94d60a4775f0e3b", + "name": "jupyterlab_launcher", + "sha256": "591518791beda251b6c6a73d3f9552cdf80089e7d8ceb199e98195935658c52a", + "size": 26557, + "subdir": "linux-64", + "timestamp": 1515949888848, + "version": "0.10.0" + }, + "jupyterlab_launcher-0.10.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "50079c7a3b3611741b1c98436fe00ec9", + "name": "jupyterlab_launcher", + "sha256": "f2fd273efd79f2fd1cfad81c6014b1381f712f9de6982c00a4d92c837729f8ff", + "size": 26975, + "subdir": "linux-64", + "timestamp": 1515949911245, + "version": "0.10.0" + }, + "jupyterlab_launcher-0.10.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eca66989191a5390eb92fa407db02249", + "name": "jupyterlab_launcher", + "sha256": "daea4e3f7793ae3d3caea435ad461175150025709d4f31548521af4b9146fae6", + "size": 26513, + "subdir": "linux-64", + "timestamp": 1515949880807, + "version": "0.10.0" + }, + "jupyterlab_launcher-0.10.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f369947311e74edfe1b3e75208dad5ab", + "name": "jupyterlab_launcher", + "sha256": "233c46247c85eb193d940ec8290a28822764630895e67ee38a9a9cef75781367", + "size": 26569, + "subdir": "linux-64", + "timestamp": 1515950581219, + "version": "0.10.1" + }, + "jupyterlab_launcher-0.10.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e3c20c3f934129349e960b62e6647e57", + "name": "jupyterlab_launcher", + "sha256": "5a96202234cf79ac4c9453ba4c119bbd7ab86cd5c731facd2f9e8222dcf569cc", + "size": 26829, + "subdir": "linux-64", + "timestamp": 1515950604939, + "version": "0.10.1" + }, + "jupyterlab_launcher-0.10.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "13bb37117ec4cddefa42601bfd068b24", + "name": "jupyterlab_launcher", + "sha256": "800f9d7512efb889a92133afad0d7ce36196f640b04252a8d2037ebd3888bcd4", + "size": 26515, + "subdir": "linux-64", + "timestamp": 1515950563276, + "version": "0.10.1" + }, + "jupyterlab_launcher-0.10.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0d84add63117c7aebda205efc4002627", + "name": "jupyterlab_launcher", + "sha256": "dd81cd479a249742e6ea3987054b45b131da244644e5598f1542d1a101af066e", + "size": 26575, + "subdir": "linux-64", + "timestamp": 1515951092342, + "version": "0.10.2" + }, + "jupyterlab_launcher-0.10.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "738f7f956ceb8275aca60004ce6665d1", + "name": "jupyterlab_launcher", + "sha256": "21dd2085d2558fd20742e8664b0dde049d5cce079079a7433fdbcf5b24410f06", + "size": 26836, + "subdir": "linux-64", + "timestamp": 1515951110824, + "version": "0.10.2" + }, + "jupyterlab_launcher-0.10.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e9b687ff3b33c2428d4e8f53412fc4ae", + "name": "jupyterlab_launcher", + "sha256": "26e52315ae6f13ef3411a427e4339621d946a36ebcdc10f344b634d4dcce0de0", + "size": 26520, + "subdir": "linux-64", + "timestamp": 1515951069301, + "version": "0.10.2" + }, + "jupyterlab_launcher-0.10.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "999d8839214d1433cbb273127c7c7bfb", + "name": "jupyterlab_launcher", + "sha256": "7eb36bdc2b4511945cbb039ce0860077031dd5f464def1a975762df6bb74d003", + "size": 26463, + "subdir": "linux-64", + "timestamp": 1519832051305, + "version": "0.10.5" + }, + "jupyterlab_launcher-0.10.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "098d6e05dd868887e00d9661a40e3ea3", + "name": "jupyterlab_launcher", + "sha256": "58620f3bf19902f50a38858054260f0b68b290a927f2621f062795167af48954", + "size": 26831, + "subdir": "linux-64", + "timestamp": 1519832061476, + "version": "0.10.5" + }, + "jupyterlab_launcher-0.10.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4bc710c6e84cc2f456bfd9af94cad692", + "name": "jupyterlab_launcher", + "sha256": "5030297519bdff3bf022dda2e64bcac1b5dfe50e268212d5551efd8d9dabb809", + "size": 26567, + "subdir": "linux-64", + "timestamp": 1519832629274, + "version": "0.10.5" + }, + "jupyterlab_launcher-0.11.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "58ffca348f22788204318ddabb503beb", + "name": "jupyterlab_launcher", + "sha256": "eaec39c7fac380745d14f2f1a9e037f6b0e1d14fec4f9c14c201749e13bda569", + "size": 32384, + "subdir": "linux-64", + "timestamp": 1529348389751, + "version": "0.11.0" + }, + "jupyterlab_launcher-0.11.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "04c9af56fe0d8b9781ab72e6ab540506", + "name": "jupyterlab_launcher", + "sha256": "a901e703d6738ae7b945de2203bd117f49a3f44312c4cd55b048e10ee5123218", + "size": 32664, + "subdir": "linux-64", + "timestamp": 1529348430489, + "version": "0.11.0" + }, + "jupyterlab_launcher-0.11.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ef2901eab5b66a503c4d693dea5bab4b", + "name": "jupyterlab_launcher", + "sha256": "d21e8f8f2a3885769aa636ee409248ddf04a65b72561700793e4e0c9004df6dd", + "size": 32297, + "subdir": "linux-64", + "timestamp": 1529348370280, + "version": "0.11.0" + }, + "jupyterlab_launcher-0.11.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "972abc5e09b98885defec0b33bc24bfe", + "name": "jupyterlab_launcher", + "sha256": "6e61d935911cd8cc874deb3872390ed2b2da364ad2a489fdef5bb8eb4dce4ba8", + "size": 32540, + "subdir": "linux-64", + "timestamp": 1530734823652, + "version": "0.11.0" + }, + "jupyterlab_launcher-0.11.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d84c6c355630ad0a3b3b879610688114", + "name": "jupyterlab_launcher", + "sha256": "54a37559a15625965fc1df3a4b497aa16aeddcd87a4042aa6bf96fa156e53801", + "size": 35319, + "subdir": "linux-64", + "timestamp": 1532522427982, + "version": "0.11.2" + }, + "jupyterlab_launcher-0.11.2-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7324ad913b368f02d357e8e81aed15bb", + "name": "jupyterlab_launcher", + "sha256": "14516b3266fbcefb4f0881cd2e8955d2afd0d2c39388a4f5e71833009929a4ec", + "size": 35340, + "subdir": "linux-64", + "timestamp": 1534351594663, + "version": "0.11.2" + }, + "jupyterlab_launcher-0.11.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "70690e50064f269668973a8679ae2ec2", + "name": "jupyterlab_launcher", + "sha256": "6c5900dc102211d60d645deb30f14f865f656d73584a08e44b424982bd5c5fc2", + "size": 35849, + "subdir": "linux-64", + "timestamp": 1532522516629, + "version": "0.11.2" + }, + "jupyterlab_launcher-0.11.2-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5435e831c3cdf13fa81835cda71a5711", + "name": "jupyterlab_launcher", + "sha256": "55de69917412664379fbc57aa833d5700d3f4d47c1d5b8de6d36d4778046e90e", + "size": 35824, + "subdir": "linux-64", + "timestamp": 1534351633153, + "version": "0.11.2" + }, + "jupyterlab_launcher-0.11.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "492d2c19c39fda37716a52d6653b406d", + "name": "jupyterlab_launcher", + "sha256": "9de178c40de1471bb6644edf78b766511a6265caab32ba649808a7d521237892", + "size": 35543, + "subdir": "linux-64", + "timestamp": 1532522309936, + "version": "0.11.2" + }, + "jupyterlab_launcher-0.11.2-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "14b3c304cce585bebfaa9eb2ffc6da4d", + "name": "jupyterlab_launcher", + "sha256": "19cfebd4982622f8769de1fb6f7d4e2cbefa86db81d4ffa853a8897f78042b74", + "size": 35537, + "subdir": "linux-64", + "timestamp": 1534351673312, + "version": "0.11.2" + }, + "jupyterlab_launcher-0.11.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "59f2085b328c1692a3f18e6a793e7e7d", + "name": "jupyterlab_launcher", + "sha256": "0170e628ec371c125fcc740dc1adda3fe291f91a666da4f1c3fe6be3b34405ba", + "size": 35841, + "subdir": "linux-64", + "timestamp": 1532522486958, + "version": "0.11.2" + }, + "jupyterlab_launcher-0.11.2-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a1daea68ad991ce3da8268fb500fcc8e", + "name": "jupyterlab_launcher", + "sha256": "d3d0462498df1cf1f9f8e0013632723c9b923c4fdca00fc18ab7c3f185dc7683", + "size": 35838, + "subdir": "linux-64", + "timestamp": 1534351561052, + "version": "0.11.2" + }, + "jupyterlab_launcher-0.13.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d4c02ebfe7e92be001515dfbc0c86d4a", + "name": "jupyterlab_launcher", + "sha256": "532b33327ac5d4629f16f74544c490142d0eb704027f7ded6bcef4dd507a3485", + "size": 40137, + "subdir": "linux-64", + "timestamp": 1642519562022, + "version": "0.13.1" + }, + "jupyterlab_launcher-0.13.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1bf1d4ec88c7fe66c7b397b40a0b0b50", + "name": "jupyterlab_launcher", + "sha256": "ca3e002f40c58be4677ef2a0f56cc3d73b40213b914d1aa1097bdb3d98b4163d", + "size": 51925, + "subdir": "linux-64", + "timestamp": 1676853045764, + "version": "0.13.1" + }, + "jupyterlab_launcher-0.13.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0fa038b69e26022f444ec551197af8d3", + "name": "jupyterlab_launcher", + "sha256": "e1178db095298895578de4d0860ef6283070901976c2cb17ae8f3f2491328820", + "size": 38909, + "subdir": "linux-64", + "timestamp": 1534266449732, + "version": "0.13.1" + }, + "jupyterlab_launcher-0.13.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e0afcbe3167296b46e5c3b7673c04f56", + "name": "jupyterlab_launcher", + "sha256": "da140cc6cbbf2b7c6b5ba9642fdef512966014519ae54f33de1ecbedf4e4dc94", + "size": 38587, + "subdir": "linux-64", + "timestamp": 1534266392565, + "version": "0.13.1" + }, + "jupyterlab_launcher-0.13.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8af8ed41e21d53965c25632b3e19bac0", + "name": "jupyterlab_launcher", + "sha256": "e73879b35fa86cd42506dd225c03735130cdcda05acac5f66fbc8cbd5c125aab", + "size": 39089, + "subdir": "linux-64", + "timestamp": 1534266428724, + "version": "0.13.1" + }, + "jupyterlab_launcher-0.4.0-py27h0e16d15_0.conda": { + "build": "py27h0e16d15_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0021ed2ce679049bcab4af8c7c8b1d30", + "name": "jupyterlab_launcher", + "sha256": "21afa1d851e48f4632866193307f6f39a1f66d48bb81fcd086517d2a63e9f564", + "size": 18270, + "subdir": "linux-64", + "timestamp": 1505690999927, + "version": "0.4.0" + }, + "jupyterlab_launcher-0.4.0-py35ha4e430f_0.conda": { + "build": "py35ha4e430f_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "98a0b34549d95c4243b45009f2898019", + "name": "jupyterlab_launcher", + "sha256": "65e4b642556693faa1796a8398157a386025293b15214abc8e3e6f222bcb0951", + "size": 18560, + "subdir": "linux-64", + "timestamp": 1505691012126, + "version": "0.4.0" + }, + "jupyterlab_launcher-0.4.0-py36h4d8058d_0.conda": { + "build": "py36h4d8058d_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fdf7bedee513496d0432a1c3aee8daaa", + "name": "jupyterlab_launcher", + "sha256": "439eb011f64a6860107b9009ed5e528180f480846acf48b71606986cee2fdb52", + "size": 18328, + "subdir": "linux-64", + "timestamp": 1505691024679, + "version": "0.4.0" + }, + "jupyterlab_launcher-0.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "24ca83f685157fd3526562954bea28e2", + "name": "jupyterlab_launcher", + "sha256": "4c834618d150f09729099a4158fb7c2d774dbc4fba542f31852ec8449635d763", + "size": 22019, + "subdir": "linux-64", + "timestamp": 1512661225068, + "version": "0.6.0" + }, + "jupyterlab_launcher-0.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "99fac12b76aac6a75fff40329fdf2b48", + "name": "jupyterlab_launcher", + "sha256": "4caa4eaac4ef9863242d62561f7b178126db902759ee8ccd238886d4c99dcdbf", + "size": 22375, + "subdir": "linux-64", + "timestamp": 1512661277914, + "version": "0.6.0" + }, + "jupyterlab_launcher-0.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c30d6e289c6af1a20f179fe451dc592e", + "name": "jupyterlab_launcher", + "sha256": "066a773073bac41144ecd4bffaaf16680b65399f08ba41536ebe4d7cd601d9fe", + "size": 22065, + "subdir": "linux-64", + "timestamp": 1512661294342, + "version": "0.6.0" + }, + "jupyterlab_server-0.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "454b8a890a8e57818fe03e718f16f5b7", + "name": "jupyterlab_server", + "sha256": "f131ddbd8fa408d093adda3e645554bb5d2a7a7eed9cbcb0f72b4593b9f6da2f", + "size": 43215, + "subdir": "linux-64", + "timestamp": 1539095022210, + "version": "0.2.0" + }, + "jupyterlab_server-0.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9647721fafa593c8b7b9679d78c5cfd8", + "name": "jupyterlab_server", + "sha256": "a772412fbbaa01c2eb50e2fe16506c512b8a6b9135282f471e6e742a684f6d42", + "size": 42728, + "subdir": "linux-64", + "timestamp": 1539095000160, + "version": "0.2.0" + }, + "jupyterlab_server-0.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7500713be2a863a45d7132f08a50aad2", + "name": "jupyterlab_server", + "sha256": "34c814a523256287c59ef392a32505c9bad023ffd972a99359ec422a52612b4b", + "size": 43369, + "subdir": "linux-64", + "timestamp": 1551141564654, + "version": "0.3.0" + }, + "jupyterlab_server-0.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "28dc63f71a5a72f5ee302d78e032713d", + "name": "jupyterlab_server", + "sha256": "f7a9731675c5d968d0c7b1e439212cae2b66e1d7fef04d9312b6bf31f383db9f", + "size": 44160, + "subdir": "linux-64", + "timestamp": 1551141544312, + "version": "0.3.0" + }, + "jupyterlab_server-0.3.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1f83629befba9dd602313453c0cfc9b3", + "name": "jupyterlab_server", + "sha256": "41c0f40efc6200dc6633fa623b615fe938a8d32df7671fe99a8adb69cce04cb5", + "size": 44203, + "subdir": "linux-64", + "timestamp": 1559849278712, + "version": "0.3.4" + }, + "jupyterlab_server-0.3.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f644858e6d2ec421effab159f588752a", + "name": "jupyterlab_server", + "sha256": "e51183f136930272deaf620289de8f62acd66e158d79a5de758fb5b24061ff76", + "size": 44904, + "subdir": "linux-64", + "timestamp": 1559849231775, + "version": "0.3.4" + }, + "jupyterlab_server-2.12.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "entrypoints >=0.2.2", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<2", + "packaging", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f54c8aaf831582f1a9cca4cfa9fa28d", + "name": "jupyterlab_server", + "sha256": "20122d0b0c8badbc14f75ae2173c1dfaf1ebd79ec3e816edaad238b8ee306d4f", + "size": 78573, + "subdir": "linux-64", + "timestamp": 1650462524608, + "version": "2.12.0" + }, + "jupyterlab_server-2.12.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "entrypoints >=0.2.2", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<2", + "packaging", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "11f3a5dea3f132afc99d3a3a3d8430e8", + "name": "jupyterlab_server", + "sha256": "2e8ab454f91ff144ef2b66df816e97d3401538cb9caf0b70900e0b8f021ec223", + "size": 78008, + "subdir": "linux-64", + "timestamp": 1650462650715, + "version": "2.12.0" + }, + "jupyterlab_server-2.12.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "entrypoints >=0.2.2", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<2", + "packaging", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ae60c37f4ef571584563c5cbd6ac9466", + "name": "jupyterlab_server", + "sha256": "91bcd81a9a4b7923285959ec09f567a3fb15f718c84f285aa4ef7f42f45b6f71", + "size": 78094, + "subdir": "linux-64", + "timestamp": 1650462385574, + "version": "2.12.0" + }, + "jupyterlab_server-2.12.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "entrypoints >=0.2.2", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<2", + "packaging", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b1148b4321b0b2cf45e8ccba01d77ebe", + "name": "jupyterlab_server", + "sha256": "3ac73dd4b6a54f459a5d63857efb481841142acd9d8f1536e9d2abb399035e0f", + "size": 78193, + "subdir": "linux-64", + "timestamp": 1650462228197, + "version": "2.12.0" + }, + "jupyterlab_server-2.15.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<2", + "packaging", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b643a0a85a634e6cad2e78ecb5d2f303", + "name": "jupyterlab_server", + "sha256": "df14d9ea2d58550ed9278a638ebe0dedb2e20c4eea5a708dfde50182e72d444d", + "size": 77633, + "subdir": "linux-64", + "timestamp": 1664908287526, + "version": "2.15.2" + }, + "jupyterlab_server-2.15.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "importlib-metadata >=3.6", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<2", + "packaging", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c98831f82da940d7300cb9010c0667d6", + "name": "jupyterlab_server", + "sha256": "23f13fbf55de908afbb65fde9a17b7a6aa24a7af041e27307dda3aeb9d93fda6", + "size": 76965, + "subdir": "linux-64", + "timestamp": 1664908410213, + "version": "2.15.2" + }, + "jupyterlab_server-2.15.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "importlib-metadata >=3.6", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<2", + "packaging", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a11debd7031fe075611f69c24f38a89f", + "name": "jupyterlab_server", + "sha256": "ac08cb18426e5ff180e3f5551c9581b75cac85cfb9d60f892d229b4def1e9781", + "size": 77052, + "subdir": "linux-64", + "timestamp": 1664908369980, + "version": "2.15.2" + }, + "jupyterlab_server-2.15.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "importlib-metadata >=3.6", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<2", + "packaging", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "be56c95153940be5f83f91fab23f9422", + "name": "jupyterlab_server", + "sha256": "eb07703494d1dfe21a35c9f4ee7f764eaaa1ea7f86bdae7bc2ba08b4362b0793", + "size": 77163, + "subdir": "linux-64", + "timestamp": 1664908329910, + "version": "2.15.2" + }, + "jupyterlab_server-2.16.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<3", + "packaging", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d66c008dd7b8dfe15b8c89e383e3809", + "name": "jupyterlab_server", + "sha256": "15aeb8673701e4cc158f075fd824ad2f844e5184f33a68e30bbd7a7261fe3f09", + "size": 82563, + "subdir": "linux-64", + "timestamp": 1669363810464, + "version": "2.16.3" + }, + "jupyterlab_server-2.16.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<3", + "packaging", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9fdbd331aa94953ca35df86dc16cc028", + "name": "jupyterlab_server", + "sha256": "0915cb92cd99e469b93cdcbccfd06bef263e9e0ba244006234c5bec36e52f8e8", + "size": 81998, + "subdir": "linux-64", + "timestamp": 1669363774742, + "version": "2.16.3" + }, + "jupyterlab_server-2.16.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<3", + "packaging", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1688ad9496ea8aba9630b2f7c1d27c6a", + "name": "jupyterlab_server", + "sha256": "b46f0cc3e3693b8193417aa4647c83fd2aa437ee1d011195758a9fc89cc8e1ab", + "size": 81997, + "subdir": "linux-64", + "timestamp": 1669363845111, + "version": "2.16.3" + }, + "jupyterlab_server-2.16.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "babel", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5", + "jsonschema >=3.0.1", + "jupyter_server >=1.8,<3", + "packaging", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "74ecec9de894c0794e30c09700726f64", + "name": "jupyterlab_server", + "sha256": "530c260824dbe5fddd73dfd49370cfa63bb42774c8e674757d475bbf150cf56e", + "size": 82128, + "subdir": "linux-64", + "timestamp": 1669363737316, + "version": "2.16.3" + }, + "jupyterlab_server-2.16.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=3.0.1", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.10,<3.11.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3270e2d74ecc85a8622f0fcb7eed6d8a", + "name": "jupyterlab_server", + "sha256": "177b0e28b33a8bea4ccc10e328487e9985adea05042c3229b0c2158329a48e91", + "size": 82971, + "subdir": "linux-64", + "timestamp": 1672127661882, + "version": "2.16.5" + }, + "jupyterlab_server-2.16.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=3.0.1", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.11,<3.12.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a46f821251def2135bcf915eecac06c2", + "name": "jupyterlab_server", + "sha256": "433204d1d5b55fff3e17a96084d4dc3df748450b1211b22d4098746c2d53c33a", + "size": 102894, + "subdir": "linux-64", + "timestamp": 1676827228114, + "version": "2.16.5" + }, + "jupyterlab_server-2.16.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=3.0.1", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.7,<3.8.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e81a843bd574bc7560baa205fa97d59b", + "name": "jupyterlab_server", + "sha256": "9159e398931e61273621f315a95cd9111daa77a803cfe2ba55f568be3b2b146d", + "size": 82368, + "subdir": "linux-64", + "timestamp": 1672127489938, + "version": "2.16.5" + }, + "jupyterlab_server-2.16.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=3.0.1", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.8,<3.9.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "540239c68dba0a827a306dc569b87141", + "name": "jupyterlab_server", + "sha256": "e084fa18463eadfb7bfc65c63a168b657c3bf5ff0b0a88d2e28c44152087c09f", + "size": 82226, + "subdir": "linux-64", + "timestamp": 1672127576652, + "version": "2.16.5" + }, + "jupyterlab_server-2.16.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=3.0.1", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.9,<3.10.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e9d46390c6f6ba5be68aface5287388d", + "name": "jupyterlab_server", + "sha256": "19b6556c32b9a43a6edf7613b265e9705eecef94868f93ad5e45a749c64e5be9", + "size": 82946, + "subdir": "linux-64", + "timestamp": 1672127389677, + "version": "2.16.5" + }, + "jupyterlab_server-2.19.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.10,<3.11.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9102579aa2b2a39a844fc1885e00082a", + "name": "jupyterlab_server", + "sha256": "80ce28bfa93dc08e14ec2d6afd283fe0fdbee68a69d95c73bc09c98600e37c44", + "size": 83324, + "subdir": "linux-64", + "timestamp": 1677143155986, + "version": "2.19.0" + }, + "jupyterlab_server-2.19.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.11,<3.12.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "39332459d0ff9e7c857f41a185828de7", + "name": "jupyterlab_server", + "sha256": "1e8d47abfda72daba362a29ca1c66a6cce8142d5aabf41d9de21f292f05200a5", + "size": 111901, + "subdir": "linux-64", + "timestamp": 1679046576246, + "version": "2.19.0" + }, + "jupyterlab_server-2.19.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.7,<3.8.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "944fd5cc3b98e3a6f9f29036539660d4", + "name": "jupyterlab_server", + "sha256": "4e938622d0f2ecce5e227743fad8c99f243ad331c9501c9eea129dbccd7c77c3", + "size": 82334, + "subdir": "linux-64", + "timestamp": 1677143088566, + "version": "2.19.0" + }, + "jupyterlab_server-2.19.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.8,<3.9.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3a4b651ca79c4e161d006609b6e0bf4a", + "name": "jupyterlab_server", + "sha256": "cae381fba66a303acf86aa3af05152ca5dc6e0a090809a84d3fa8bf448410b4c", + "size": 82391, + "subdir": "linux-64", + "timestamp": 1677143123430, + "version": "2.19.0" + }, + "jupyterlab_server-2.19.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.9,<3.10.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5196b850edee3f6a6c0e1055ce9064cc", + "name": "jupyterlab_server", + "sha256": "82c94d28be34cc84c49b06a68d844335d553a900aa5f3ce2c349957fe446c71e", + "size": 82491, + "subdir": "linux-64", + "timestamp": 1677143188283, + "version": "2.19.0" + }, + "jupyterlab_server-2.21.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.10,<3.11.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2def95865cd9404b18f9951bd38c997f", + "name": "jupyterlab_server", + "sha256": "59218af4695e545ab3a10ba19488ead3685948115e5b2cafd3ea18a37ded1610", + "size": 86089, + "subdir": "linux-64", + "timestamp": 1679906335081, + "version": "2.21.0" + }, + "jupyterlab_server-2.21.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.11,<3.12.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1790d5c87b3b53e4d71acf0f4fd42fc3", + "name": "jupyterlab_server", + "sha256": "31f064395b444d70d028434185761b4df873b30b63722c3177c771d24cb66fd5", + "size": 112884, + "subdir": "linux-64", + "timestamp": 1679906370711, + "version": "2.21.0" + }, + "jupyterlab_server-2.21.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.8,<3.9.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85d79d64b5c1f61df67f888cbe2e4418", + "name": "jupyterlab_server", + "sha256": "d2d9d47456cd9e53c9b7fa1d6dcb10e9080b1de4a40b004ce79dbcca9138d2db", + "size": 85169, + "subdir": "linux-64", + "timestamp": 1679906440834, + "version": "2.21.0" + }, + "jupyterlab_server-2.21.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.9,<3.10.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c8d95a0acbc14d3d46414a6d7454b05b", + "name": "jupyterlab_server", + "sha256": "2621e62b5bec4a61f3cffaf3b547a9ddf4201cfe832c20c5f040de000a05a0df", + "size": 85253, + "subdir": "linux-64", + "timestamp": 1679906405016, + "version": "2.21.0" + }, + "jupyterlab_server-2.22.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.10,<3.11.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "86ad7633cc004676e4653a07de7a557a", + "name": "jupyterlab_server", + "sha256": "9d546231862d8a8e03fc2bdac7b01402ddb734d9a52e4e9714ac932c66747aee", + "size": 84637, + "subdir": "linux-64", + "timestamp": 1680792640261, + "version": "2.22.0" + }, + "jupyterlab_server-2.22.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.11,<3.12.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a292f1a9927d61325d3cbd5bdf32e676", + "name": "jupyterlab_server", + "sha256": "35fa138127be3321b28e7783721521685e5ce55dd02967d4142b8c8bbdd470b4", + "size": 111019, + "subdir": "linux-64", + "timestamp": 1680792605044, + "version": "2.22.0" + }, + "jupyterlab_server-2.22.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.8,<3.9.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9adcb5678be41d96b9b9a86e25b94cce", + "name": "jupyterlab_server", + "sha256": "1e0c0eb43e397bdca99b5d2c05ec63c3cfeb4aea98421de04e149d8804290ae0", + "size": 84009, + "subdir": "linux-64", + "timestamp": 1680792570109, + "version": "2.22.0" + }, + "jupyterlab_server-2.22.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "babel >=2.10", + "importlib-metadata >=4.8.3", + "jinja2 >=3.0.3", + "json5 >=0.9.0", + "jsonschema >=4.17.3", + "jupyter_server >=1.21,<3", + "packaging >=21.3", + "python >=3.9,<3.10.0a0", + "requests >=2.28" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6e321f2d56cee380cb06ee509da3fc07", + "name": "jupyterlab_server", + "sha256": "9b7ceb3ed63b0b3f27339f2cff158a32968a36b6c950fc43faed3d626ffa4f15", + "size": 84148, + "subdir": "linux-64", + "timestamp": 1680792534677, + "version": "2.22.0" + }, + "jupyterlab_widgets-3.0.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyterlab >=3,<4" + ], + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b91464a64afb7d842cc31a09a9251fd3", + "name": "jupyterlab_widgets", + "sha256": "1f08b9c816e12faa6858b382d5d94bb53ca26d621a8e967f354e53c0c14509cf", + "size": 182550, + "subdir": "linux-64", + "timestamp": 1679055314433, + "version": "3.0.5" + }, + "jupyterlab_widgets-3.0.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyterlab >=3,<4" + ], + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a716a9b122bfa248a90f033fb1369a7f", + "name": "jupyterlab_widgets", + "sha256": "4da059bf72a42c6bb7e2ead3ecc96b54d11df07f9092d5d6a71bbfe0e159a29e", + "size": 182809, + "subdir": "linux-64", + "timestamp": 1679055342664, + "version": "3.0.5" + }, + "jupyterlab_widgets-3.0.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyterlab >=3,<4" + ], + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a16786a9d6f670770e6d5a48897e8169", + "name": "jupyterlab_widgets", + "sha256": "af8fb9fde6352459cc4df3943b7a423ddfa3b8ce7975b920c626c8506105a657", + "size": 182487, + "subdir": "linux-64", + "timestamp": 1679055371126, + "version": "3.0.5" + }, + "jupyterlab_widgets-3.0.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyterlab >=3,<4" + ], + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e388525551a2e5968546568feb088ba8", + "name": "jupyterlab_widgets", + "sha256": "f71166e67fd0322e95b61ed29eda2c9c1535849daccc348a85476386f24d6839", + "size": 182495, + "subdir": "linux-64", + "timestamp": 1679055398232, + "version": "3.0.5" + }, + "jxrlib-1.1-h7b6447c_2.conda": { + "build": "h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "3cc305f3788177c8ea28088590ab75a1", + "name": "jxrlib", + "sha256": "26d8bdd124ba25a45425c18b41d9765db810deba870d55082104e011a4c6d7be", + "size": 228075, + "subdir": "linux-64", + "timestamp": 1593197090424, + "version": "1.1" + }, + "kealib-1.4.12-hd0c454d_0.conda": { + "build": "hd0c454d_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "e07f039e060260aa36c8fe0a0f505deb", + "name": "kealib", + "sha256": "218e490ebe18ace046d8c91ea1a8d836ddb6776de89f0884e1901de90277307f", + "size": 158468, + "subdir": "linux-64", + "timestamp": 1582227404676, + "version": "1.4.12" + }, + "kealib-1.4.14-h54c064f_0.conda": { + "build": "h54c064f_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "705df498dccd94bce998449edfd41bcb", + "name": "kealib", + "sha256": "b00a2caa5fbc138d956c66b6544b4d27436635937402e119c3068978ac1ace7f", + "size": 163934, + "subdir": "linux-64", + "timestamp": 1621648701471, + "version": "1.4.14" + }, + "kealib-1.4.14-hb50703a_1.conda": { + "build": "hb50703a_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "54b163a467721e67c364c4ac733259b2", + "name": "kealib", + "sha256": "701c77cfc08cf4ec46634a3f165eda399e1737d9ccba93b135d2f76696a3a02d", + "size": 163631, + "subdir": "linux-64", + "timestamp": 1640000342243, + "version": "1.4.14" + }, + "kealib-1.4.7-h5472223_5.conda": { + "build": "h5472223_5", + "build_number": 5, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "9537f44723d153528f67c74b3da3ab51", + "name": "kealib", + "sha256": "0b6677169b7e8e529d96aceef20a6a91dc6dc45f0f352405c7dcc3fe2f7a23e8", + "size": 152118, + "subdir": "linux-64", + "timestamp": 1511297426193, + "version": "1.4.7" + }, + "kealib-1.4.7-h77bc034_6.conda": { + "build": "h77bc034_6", + "build_number": 6, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "0fb3c023156bc8bd1063c91d0f956dd3", + "name": "kealib", + "sha256": "91374a9f32ef0eff94f8d5084d3a4942594ea106c2a9bb1dd7f4373bfbfbaed5", + "size": 152064, + "subdir": "linux-64", + "timestamp": 1526039819783, + "version": "1.4.7" + }, + "kealib-1.4.7-h79811e5_5.conda": { + "build": "h79811e5_5", + "build_number": 5, + "depends": [ + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "8d4dc57ff6e3a2aa171ff8374ede9c59", + "name": "kealib", + "sha256": "cf1a73a5754f48eaf17e1ab58b19daa139a43a6eaedd7520a23c31e9eccde266", + "size": 152167, + "subdir": "linux-64", + "timestamp": 1511297631757, + "version": "1.4.7" + }, + "kealib-1.4.7-hbc776fa_4.conda": { + "build": "hbc776fa_4", + "build_number": 4, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "585fa46fd7bf86b542f56721bde83708", + "name": "kealib", + "sha256": "c94e5f65cca52dbc021994acecf28687bec3107b14b56e7e3874c46809296a94", + "size": 152072, + "subdir": "linux-64", + "timestamp": 1509379010164, + "version": "1.4.7" + }, + "kealib-1.4.7-hd0c454d_6.conda": { + "build": "hd0c454d_6", + "build_number": 6, + "depends": [ + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "4f89bfa8fdbbdecd4b751efb87043b22", + "name": "kealib", + "sha256": "751bf8e7bfbacdd4d5a50561f54f67e050a09e7da3b374f85eacff3af2aae3f5", + "size": 157302, + "subdir": "linux-64", + "timestamp": 1545404578691, + "version": "1.4.7" + }, + "kealib-1.4.7-hd1b091a_4.conda": { + "build": "hd1b091a_4", + "build_number": 4, + "depends": [ + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "dd15495821c85acf05e44b4209b5b0c1", + "name": "kealib", + "sha256": "944f6bdae49675cac3893b37b1b1bb5319811b2f4bf26f227ea12f6be5550293", + "size": 152056, + "subdir": "linux-64", + "timestamp": 1509379009228, + "version": "1.4.7" + }, + "kealib-1.5.0-hd940352_0.conda": { + "build": "hd940352_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f9b4d2e7e2c22c007de190033c96f42", + "name": "kealib", + "sha256": "905dc693f741c9b2e67fe5761648bd1fe0a85d7466c39d536deb1e6c6940ec16", + "size": 179674, + "subdir": "linux-64", + "timestamp": 1674215888200, + "version": "1.5.0" + }, + "keras-2.0.8-py27hd1b5a5b_0.conda": { + "build": "py27hd1b5a5b_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d54b89b01e69bf1931c2b8bdebb7b527", + "name": "keras", + "namespace": "python", + "sha256": "f228a077aa5ecfe1c681d276954585f1b168fb37f01fb87d89482e9564462e67", + "size": 381519, + "subdir": "linux-64", + "timestamp": 1508952999367, + "version": "2.0.8" + }, + "keras-2.0.8-py35h4bddecc_0.conda": { + "build": "py35h4bddecc_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a785efb0a6cb295da3d45ffb41bd7b57", + "name": "keras", + "namespace": "python", + "sha256": "a58a5ed41f69f3ed497bc8e882909e84924c8323a966bdad9258a84d1f03ab08", + "size": 383596, + "subdir": "linux-64", + "timestamp": 1508953001103, + "version": "2.0.8" + }, + "keras-2.0.8-py36hc0b6f7c_0.conda": { + "build": "py36hc0b6f7c_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b47e94cde35609584bced810f6b64d7", + "name": "keras", + "namespace": "python", + "sha256": "cd32365ef67d6eec2325043b224195525b820d16c756ddfb2c8e9e1f5ed9e184", + "size": 384797, + "subdir": "linux-64", + "timestamp": 1508953071686, + "version": "2.0.8" + }, + "keras-2.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d00a74927ec27995bef099ea918507e8", + "name": "keras", + "namespace": "python", + "sha256": "8ce086d758055566c14d3575c74e287cc91aacf89781c0ef5b061ff1879ba8c7", + "size": 406991, + "subdir": "linux-64", + "timestamp": 1515179977234, + "version": "2.1.2" + }, + "keras-2.1.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c54e09aad96a8f36b1e8ed28f409bc0", + "name": "keras", + "namespace": "python", + "sha256": "398a1c4f85eb502515441381a655337000f680134d98d2f2d32d64f1903cd41f", + "size": 419540, + "subdir": "linux-64", + "timestamp": 1515180000850, + "version": "2.1.2" + }, + "keras-2.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d4afd8ffc51013adb305e0eba51266ed", + "name": "keras", + "namespace": "python", + "sha256": "eef0e75b36c7f5596daefadecaa0ea344bac7f3c92efaad18ef1d3a101e0ca9f", + "size": 410439, + "subdir": "linux-64", + "timestamp": 1515179993965, + "version": "2.1.2" + }, + "keras-2.1.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "61766f87d60ff06a1e32e23346589f62", + "name": "keras", + "namespace": "python", + "sha256": "96b9095a85f65ff3a09774cc8d8a6e696c5355fabef5c220ebfb93bc86b5ae77", + "size": 427068, + "subdir": "linux-64", + "timestamp": 1516651576337, + "version": "2.1.3" + }, + "keras-2.1.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "82c5499b21f33a6d2c45d8f92a3475b3", + "name": "keras", + "namespace": "python", + "sha256": "174ae099606b48638212297ad82882cbf7fe4379fcc7dc91f3e091b591945cef", + "size": 435530, + "subdir": "linux-64", + "timestamp": 1516651595794, + "version": "2.1.3" + }, + "keras-2.1.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbbfcffd91b9cd5fea601fe367ca4ee6", + "name": "keras", + "namespace": "python", + "sha256": "517a6b6734b5a421e694d92df3983316674f4be592b6a4cd3a8fa042a4ea9ea5", + "size": 425784, + "subdir": "linux-64", + "timestamp": 1516651602800, + "version": "2.1.3" + }, + "keras-2.1.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f70f7564b8536c3f3e208a034f29b12a", + "name": "keras", + "namespace": "python", + "sha256": "8e379f325e9ff84b1cd121c97b6d73c334caebf12eee787ce519959f3f6bb328", + "size": 430749, + "subdir": "linux-64", + "timestamp": 1519752809947, + "version": "2.1.4" + }, + "keras-2.1.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95e7c1e8d2f97d3e281f5964c4e85b80", + "name": "keras", + "namespace": "python", + "sha256": "cb5c26a987eb1a71db75a2a18a19132386109c763734b7f2b9bfff1f11de4ac6", + "size": 434143, + "subdir": "linux-64", + "timestamp": 1519752834691, + "version": "2.1.4" + }, + "keras-2.1.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "374dd8a9c8afa26edc7eedab0e62f52d", + "name": "keras", + "namespace": "python", + "sha256": "a0aea55a791b8b49944dc09d123f5e743627a18268170778ea4221dcfe47e913", + "size": 430004, + "subdir": "linux-64", + "timestamp": 1519752802685, + "version": "2.1.4" + }, + "keras-2.1.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9bb882f7be5d3655d2feaa1ed690c19", + "name": "keras", + "namespace": "python", + "sha256": "e8865906a6026caee3b2479b239f97447fe2464755edc3049a215bf7047d76c2", + "size": 442102, + "subdir": "linux-64", + "timestamp": 1521484643022, + "version": "2.1.5" + }, + "keras-2.1.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc0dc2d212cb35857d6abb30a12e02fa", + "name": "keras", + "namespace": "python", + "sha256": "ca00437ad2dc9db18f7db712fa10e1a128c530f8b421d51caf3d2b6ee59c36dd", + "size": 444826, + "subdir": "linux-64", + "timestamp": 1521484732468, + "version": "2.1.5" + }, + "keras-2.1.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5bd0db93425f3de4e18c800de6350689", + "name": "keras", + "namespace": "python", + "sha256": "a086b9ddff88d82b8f2e4387117fc21e4c1323895c0e855af7e16fb327b2fb77", + "size": 440709, + "subdir": "linux-64", + "timestamp": 1521484738304, + "version": "2.1.5" + }, + "keras-2.1.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4b4cb3683c9cd4dc595def9412b846f", + "name": "keras", + "namespace": "python", + "sha256": "83e043db8ad946702ddb4aeb309af6f4eb77db353075659ae1aeff01bacacf90", + "size": 447387, + "subdir": "linux-64", + "timestamp": 1527628588238, + "version": "2.1.6" + }, + "keras-2.1.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb5a36215b86572ecf44ef4e1896e1db", + "name": "keras", + "namespace": "python", + "sha256": "f169b3cde3fcd3e5debb4d6dc93cc914338e41efcb8de98f2c3019cbdcd64997", + "size": 456008, + "subdir": "linux-64", + "timestamp": 1527628602976, + "version": "2.1.6" + }, + "keras-2.1.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "279a67cbacf8f6222314847de3c6b899", + "name": "keras", + "namespace": "python", + "sha256": "4eeb4d67b1ac5a7868cd82c8cc0fbe36ebcf40f26a994f053f29f163d3e24837", + "size": 451834, + "subdir": "linux-64", + "timestamp": 1527628614296, + "version": "2.1.6" + }, + "keras-2.10.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.10.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "153bf0c2f3f571017bfe9ac7d14a04b1", + "name": "keras", + "namespace": "python", + "sha256": "b8024642ff1d6f4cfe0584ddd6d0a2c7be6176bea8edc29f148afdb63c7adcb5", + "size": 1638609, + "subdir": "linux-64", + "timestamp": 1666889663660, + "version": "2.10.0" + }, + "keras-2.10.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.10.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "7ae55044b6d871e4e19a12112f23f0c9", + "name": "keras", + "namespace": "python", + "sha256": "14cfabf49ea357f29ce0b1b140b2fb31a36f808f9ef6407cc05bc6614752bcc6", + "size": 1630037, + "subdir": "linux-64", + "timestamp": 1666889754798, + "version": "2.10.0" + }, + "keras-2.10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.10.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "6353ca0bc2cc49d6a5611b9ec119f398", + "name": "keras", + "namespace": "python", + "sha256": "eba160601c48802b3fb124acc678607a4f03336a22f50c21846ebcf043296f5a", + "size": 1619598, + "subdir": "linux-64", + "timestamp": 1666889613052, + "version": "2.10.0" + }, + "keras-2.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.10.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "d359219bec1c8176d575b77d6167733e", + "name": "keras", + "namespace": "python", + "sha256": "dde5c30b0bd5f157961b20d68cdf5a405c6bdeccb8c4e882270fe30283427f9c", + "size": 1622579, + "subdir": "linux-64", + "timestamp": 1666889707655, + "version": "2.10.0" + }, + "keras-2.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.11.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "694d5b6552f6557f39741c563211acfc", + "name": "keras", + "namespace": "python", + "sha256": "69c6f976f226603c5af0309e14ce330a5d56b14aed7f2be6a4621274540e7c93", + "size": 1639316, + "subdir": "linux-64", + "timestamp": 1678126533487, + "version": "2.11.0" + }, + "keras-2.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.11.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "5ebaed3cceec5a1387d5471fd7e65248", + "name": "keras", + "namespace": "python", + "sha256": "f9cb33a3abc3d3170c4fe0c58212547a7b44cdd475a596822536e8e1b7c33525", + "size": 1644983, + "subdir": "linux-64", + "timestamp": 1678126568175, + "version": "2.11.0" + }, + "keras-2.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.11.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "88fddf68ebbfc1cc13b098207ffa5771", + "name": "keras", + "namespace": "python", + "sha256": "8d7556de4fb0bde17b7760ecc09a21e428cc1a09bcb09ade0650bc22bf340c86", + "size": 1645435, + "subdir": "linux-64", + "timestamp": 1678126499316, + "version": "2.11.0" + }, + "keras-2.2.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "keras-base 2.2.0.*", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58f361060f3fbc199316d02b3c0a1d48", + "name": "keras", + "namespace": "python", + "sha256": "481533133ccf4f527bccce6bc41612051567a712be45f5de4eb491805f163365", + "size": 5843, + "subdir": "linux-64", + "timestamp": 1529076397295, + "version": "2.2.0" + }, + "keras-2.2.2-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "keras-base 2.2.2.*", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "642dba36ddcb789a74e16e1d4d1fff73", + "name": "keras", + "namespace": "python", + "sha256": "11d0ce98dbaece6da8556d6f5fea03adab6d625a41e4e1264d4956b66bb31d82", + "size": 5737, + "subdir": "linux-64", + "timestamp": 1533138374255, + "version": "2.2.2" + }, + "keras-2.2.4-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "keras-base 2.2.4.*", + "tensorflow <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d4802195c14dc304d15b9146542c89d1", + "name": "keras", + "namespace": "python", + "sha256": "0a90cd340cfd787a8dcb65441cee9eec272c440670841f5964a29fbbfc69073a", + "size": 5540, + "subdir": "linux-64", + "timestamp": 1539019786931, + "version": "2.2.4" + }, + "keras-2.3.1-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "keras-base 2.3.1.*", + "tensorflow" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b7ebf64f4d57276fdd5ec1cee55600f", + "name": "keras", + "namespace": "python", + "sha256": "276e2a1f9ed2472196c99bdb919d36cbc7d64a203a152db4dbf34d50606907a2", + "size": 12163, + "subdir": "linux-64", + "timestamp": 1582144378752, + "version": "2.3.1" + }, + "keras-2.8.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.10,<3.11.0a0", + "pyyaml", + "tensorflow-base 2.8.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7380f025aa85dcf859b1cacc845badaf", + "name": "keras", + "namespace": "python", + "sha256": "45a17d220c781d92be9e671430ad796bdeac0c6b02c42b5fafd682548e3eb84d", + "size": 1491883, + "subdir": "linux-64", + "timestamp": 1659009025922, + "version": "2.8.0" + }, + "keras-2.8.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.7,<3.8.0a0", + "pyyaml", + "tensorflow-base 2.8.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23cca87c3994eea8d33cc68fde6e1fcc", + "name": "keras", + "namespace": "python", + "sha256": "84822be483fbc81468f5b8f530ca01f529f960d291ee7ed982c3d0d733eea022", + "size": 1463246, + "subdir": "linux-64", + "timestamp": 1659009046203, + "version": "2.8.0" + }, + "keras-2.8.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.8,<3.9.0a0", + "pyyaml", + "tensorflow-base 2.8.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd392a3b58a8b726dc13d44714d32e49", + "name": "keras", + "namespace": "python", + "sha256": "f305fcbca818b5f59f6e71ae2220e62cc6fd722253cc27034cf055b91dd44a03", + "size": 1477358, + "subdir": "linux-64", + "timestamp": 1659009004716, + "version": "2.8.0" + }, + "keras-2.8.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.9,<3.10.0a0", + "pyyaml", + "tensorflow-base 2.8.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c261bcd86ca77ba7acfc33ee7658ba4c", + "name": "keras", + "namespace": "python", + "sha256": "c3fe7ab5c616953c0eac955a88d72d3c840f428db8456ec0c9c92784a4d890d4", + "size": 1477679, + "subdir": "linux-64", + "timestamp": 1659009066974, + "version": "2.8.0" + }, + "keras-2.9.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.9.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.10,<3.11.0a0", + "pyyaml", + "scipy 1.7.3.*" + ], + "license": "Apache-2.0", + "md5": "bf5124b6e02936ace6dbd14340c4a59c", + "name": "keras", + "namespace": "python", + "sha256": "531491f258cb286675571386a2762e175fabbb93a21f83f258933669280b097e", + "size": 1590243, + "subdir": "linux-64", + "timestamp": 1661556291615, + "version": "2.9.0" + }, + "keras-2.9.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.9.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy 1.7.3.*" + ], + "license": "Apache-2.0", + "md5": "dd72c139a93b3aa90e1b700b3f71a460", + "name": "keras", + "namespace": "python", + "sha256": "61700220bc1bd2963a8a7b379417d925d38cb840e5150e83fe784cb0cea96c52", + "size": 1582189, + "subdir": "linux-64", + "timestamp": 1661556329112, + "version": "2.9.0" + }, + "keras-2.9.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.9.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.8,<3.9.0a0", + "pyyaml", + "scipy 1.7.3.*" + ], + "license": "Apache-2.0", + "md5": "692e7d63e1216bdc7560e4717ee66bb0", + "name": "keras", + "namespace": "python", + "sha256": "8d43fb158d07966f00f54bcebc163dae2af639abac392182c1e65ad3cecc43db", + "size": 1571669, + "subdir": "linux-64", + "timestamp": 1661556254881, + "version": "2.9.0" + }, + "keras-2.9.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.9.*" + ], + "depends": [ + "keras-preprocessing >=1.1.2", + "python >=3.9,<3.10.0a0", + "pyyaml", + "scipy 1.7.3.*" + ], + "license": "Apache-2.0", + "md5": "72d9c8329e1d38175e6c91fc9b0c3314", + "name": "keras", + "namespace": "python", + "sha256": "9d5c37619f130c749fbbe866f6e93645ce247c91e8ee3c818e8f229ea0e82c3a", + "size": 1573503, + "subdir": "linux-64", + "timestamp": 1661556367767, + "version": "2.9.0" + }, + "keras-applications-1.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "519b114726d875b68eaeaaf72bf41078", + "name": "keras-applications", + "sha256": "0e073f59bbcadaa1d6db69fd0e81fef54347590e50f47445bbfd7d36ac44ec6f", + "size": 45451, + "subdir": "linux-64", + "timestamp": 1529074359080, + "version": "1.0.2" + }, + "keras-applications-1.0.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7cb4342ab164b372c73c15f01deff046", + "name": "keras-applications", + "sha256": "9d9fe0a28469f727fb5d7c332ad6b95b5aa6cfc59724eea5a0261715cb9c985c", + "size": 45484, + "subdir": "linux-64", + "timestamp": 1529074482497, + "version": "1.0.2" + }, + "keras-applications-1.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f224a5e0b3e3dbc19c759537d189dcda", + "name": "keras-applications", + "sha256": "9eb96b161074d2eae5443267d6e961dbfbfde56c6b9ca463c16039fabe09f490", + "size": 45292, + "subdir": "linux-64", + "timestamp": 1529074342790, + "version": "1.0.2" + }, + "keras-applications-1.0.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0fac6267500895f8ac3b41b86a66eda1", + "name": "keras-applications", + "sha256": "faba761dd6f505cab1cce179e93979e9e3ab388cb41af1621cb5ec3fac99c197", + "size": 45786, + "subdir": "linux-64", + "timestamp": 1533108212107, + "version": "1.0.4" + }, + "keras-applications-1.0.4-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0363694c40e631f0b36246917d1c352f", + "name": "keras-applications", + "sha256": "8e16c0186ed064e9a1dbb55f8cec5975f166fe7982b3701ecf789d83f5d7b1c7", + "size": 46142, + "subdir": "linux-64", + "timestamp": 1534973224051, + "version": "1.0.4" + }, + "keras-applications-1.0.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2a87ac2075c8b1821eacf7931ee7996d", + "name": "keras-applications", + "sha256": "41ece79a6c207b0d42a9093389f7f614d39a8caccb1f1fe3aa2068f6cb35975a", + "size": 45807, + "subdir": "linux-64", + "timestamp": 1533108227375, + "version": "1.0.4" + }, + "keras-applications-1.0.4-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a01a65faacb088386afe7a52b5958839", + "name": "keras-applications", + "sha256": "2a325f574bc6374db0f1225a9e67be17203c2dc58fa3522ddb11541eade774e3", + "size": 45697, + "subdir": "linux-64", + "timestamp": 1534973211581, + "version": "1.0.4" + }, + "keras-applications-1.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "220d7dd8b4259b9286cba1c88f6953fa", + "name": "keras-applications", + "sha256": "c6e26b01fbf7eba1d895a867fb4c76661b639666a2fae2225a5617e059686599", + "size": 45963, + "subdir": "linux-64", + "timestamp": 1533108220694, + "version": "1.0.4" + }, + "keras-applications-1.0.4-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ea4c578e952e9f7ed975718f75ee6a5", + "name": "keras-applications", + "sha256": "67b6e5c15dc145d4d2c965f3d154fb1db50b66315b67d2f9e1b9348dcb925da9", + "size": 45779, + "subdir": "linux-64", + "timestamp": 1534973121293, + "version": "1.0.4" + }, + "keras-applications-1.0.4-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f7d73b8cc28dc3d3dec7b8bd250ba43", + "name": "keras-applications", + "sha256": "d4a05f3b67db35bf95d6b7e2c2a269c46ca359e91f78153eaed6ea0fc01b8137", + "size": 45067, + "subdir": "linux-64", + "timestamp": 1534973164791, + "version": "1.0.4" + }, + "keras-applications-1.0.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bdcf51db0f9a2121efcb0ad74bc2fe9a", + "name": "keras-applications", + "sha256": "36c28c905ec4579710aa6a2a467511bcac3c1ad24e956ada7cd4a5de34e2a0bb", + "size": 47416, + "subdir": "linux-64", + "timestamp": 1538424962758, + "version": "1.0.6" + }, + "keras-applications-1.0.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c47c40c42b8ddfb2bb8f493be1c28503", + "name": "keras-applications", + "sha256": "7b877cd6c3ce7f87ef6bb5adc9cb396a1eb60a4c6d43f0639aca7bdc37838205", + "size": 47181, + "subdir": "linux-64", + "timestamp": 1538425005197, + "version": "1.0.6" + }, + "keras-applications-1.0.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63ca2e92f59cd2562c91373edf78a242", + "name": "keras-applications", + "sha256": "74e1f829ba64d6ef110b7b1687ce95f6ba0093400bbef6a686469d09ab6462ac", + "size": 46725, + "subdir": "linux-64", + "timestamp": 1538424928230, + "version": "1.0.6" + }, + "keras-base-2.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "keras 2.2.0" + ], + "depends": [ + "h5py", + "keras-applications 1.0.2.*", + "keras-preprocessing 1.0.1.*", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "b82678b07e695d648bbba893eef2b31c", + "name": "keras-base", + "sha256": "910fd09ac09c8679ad75e728af9f8551ee4006ffffc39c11e8b1f53b5d884c99", + "size": 410777, + "subdir": "linux-64", + "timestamp": 1529076390809, + "version": "2.2.0" + }, + "keras-base-2.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "keras 2.2.0" + ], + "depends": [ + "h5py", + "keras-applications 1.0.2.*", + "keras-preprocessing 1.0.1.*", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "cca23b3330f0f7757572654b3c4e03ae", + "name": "keras-base", + "sha256": "ebf8b6db022d55c0ef70b21f7a10ed16c29baf1feffefb989fd5003848269741", + "size": 414042, + "subdir": "linux-64", + "timestamp": 1529076283729, + "version": "2.2.0" + }, + "keras-base-2.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras 2.2.0" + ], + "depends": [ + "h5py", + "keras-applications 1.0.2.*", + "keras-preprocessing 1.0.1.*", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "5b893285b121e4f9843a8f3851ff1992", + "name": "keras-base", + "sha256": "4a1868322a7de0efd65a5d9f41eed027cc6b17d860476d5566b96ba58371028b", + "size": 415201, + "subdir": "linux-64", + "timestamp": 1529076344151, + "version": "2.2.0" + }, + "keras-base-2.2.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "keras 2.2.2" + ], + "depends": [ + "h5py", + "keras-applications 1.0.4.*", + "keras-preprocessing 1.0.2.*", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "50ec39ab02eac33740fef579778f4b5a", + "name": "keras-base", + "sha256": "c41be27213b055a265644d21f927b4009dc1c0388aca11ead2687af355bcbdc7", + "size": 403300, + "subdir": "linux-64", + "timestamp": 1533138746296, + "version": "2.2.2" + }, + "keras-base-2.2.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "keras 2.2.2" + ], + "depends": [ + "h5py", + "keras-applications 1.0.4.*", + "keras-preprocessing 1.0.2.*", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "0e1e4036b851b79c1d876ad51868e70a", + "name": "keras-base", + "sha256": "21a68160b9718106026c1b88a3c227d50d2f58e77c42b8f1affdf091ee145450", + "size": 416867, + "subdir": "linux-64", + "timestamp": 1533138980666, + "version": "2.2.2" + }, + "keras-base-2.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras 2.2.2" + ], + "depends": [ + "h5py", + "keras-applications 1.0.4.*", + "keras-preprocessing 1.0.2.*", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "f1287d47906ba3758a6718258a3d8a67", + "name": "keras-base", + "sha256": "8968ef6e1341739aa780d6527bba8a5380fea903fc3c07492688ac3aa55ed7b2", + "size": 412381, + "subdir": "linux-64", + "timestamp": 1533138372434, + "version": "2.2.2" + }, + "keras-base-2.2.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "keras 2.2.4" + ], + "depends": [ + "h5py", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "9b71e7dd0f92d84d02e40000c5b9f719", + "name": "keras-base", + "sha256": "dc539912597b0207d1d7cc008c06d9e86c056033a56c9abb7382103eef542ddd", + "size": 418865, + "subdir": "linux-64", + "timestamp": 1539019773289, + "version": "2.2.4" + }, + "keras-base-2.2.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras 2.2.4" + ], + "depends": [ + "h5py", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "735822c7b1f09e46cf9896245e5d20ed", + "name": "keras-base", + "sha256": "89f701b42d52c624780f2f9a1826e3d40b518eec0c406079b831ccea5f7184ea", + "size": 428406, + "subdir": "linux-64", + "timestamp": 1539019785472, + "version": "2.2.4" + }, + "keras-base-2.2.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "keras 2.2.4" + ], + "depends": [ + "h5py", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "numpy >=1.9.1", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "3bc14f59f34cadd4ac5db1214c889f5f", + "name": "keras-base", + "sha256": "eb67d73504fd66f540bb7b34046d0e0da45b890077f05accf0af5506e555495f", + "size": 430595, + "subdir": "linux-64", + "timestamp": 1554743173443, + "version": "2.2.4" + }, + "keras-base-2.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras 2.3.1" + ], + "depends": [ + "h5py", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "dd973c405734b933fdeeee5116adcec8", + "name": "keras-base", + "sha256": "616155c1eecdcdf1d18ea8af89af4d820a0678db35e71bacfa38ba66bc4ca1ca", + "size": 506836, + "subdir": "linux-64", + "timestamp": 1582144353884, + "version": "2.3.1" + }, + "keras-base-2.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "keras 2.3.1" + ], + "depends": [ + "h5py", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "numpy >=1.9.1", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "dcb50b1f0c845b7e4d5d0b05cdc92a2a", + "name": "keras-base", + "sha256": "04a7df1f0ba2542874f1e85d910e6862e3c3f3f8e714e7174e2d102b3eb021a3", + "size": 506759, + "subdir": "linux-64", + "timestamp": 1582144375962, + "version": "2.3.1" + }, + "keras-base-2.3.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "keras 2.3.1" + ], + "depends": [ + "h5py", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "numpy >=1.9.1", + "python >=3.8,<3.9.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0" + ], + "md5": "97e3e3a7a8ba8ba83bcdf1c95e336eed", + "name": "keras-base", + "sha256": "44721046376e931404a9ccea988ee04295109e3bac93450561ac464d9869ecfa", + "size": 518421, + "subdir": "linux-64", + "timestamp": 1590699728675, + "version": "2.3.1" + }, + "keras-gpu-2.0.8-py27hde4dcf2_0.conda": { + "build": "py27hde4dcf2_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c09d1f7f538a40b0ddf40ed629c77503", + "name": "keras-gpu", + "namespace": "python", + "sha256": "ca68250a8e942b513965083848a8a9e5d0c6c318d3e6c12b3c761debca48d432", + "size": 380687, + "subdir": "linux-64", + "timestamp": 1508953006444, + "version": "2.0.8" + }, + "keras-gpu-2.0.8-py35ha2fb4ba_0.conda": { + "build": "py35ha2fb4ba_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6156107620b78401ef74cd5f4932181", + "name": "keras-gpu", + "namespace": "python", + "sha256": "131c7ebf555c82c2ffbcdc9055bfd1d4345c891a656d3529225c0ecc56f134a0", + "size": 382724, + "subdir": "linux-64", + "timestamp": 1508953022004, + "version": "2.0.8" + }, + "keras-gpu-2.0.8-py36h0585f72_0.conda": { + "build": "py36h0585f72_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bf15d560d6c814d32ace58431c40a072", + "name": "keras-gpu", + "namespace": "python", + "sha256": "9e239e10812a28fb6328a5854cd2c3f47b5b624a53f1fa5f1be477875e81a756", + "size": 379171, + "subdir": "linux-64", + "timestamp": 1508953072153, + "version": "2.0.8" + }, + "keras-gpu-2.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6bac1d890a4b7b3b06d3ca378e3d8ecd", + "name": "keras-gpu", + "namespace": "python", + "sha256": "f3e03e1f83ff7cfeb73bb6b2b26ec399e73c20d10c7b246c1c15d107f3cf3727", + "size": 412060, + "subdir": "linux-64", + "timestamp": 1516650822522, + "version": "2.1.2" + }, + "keras-gpu-2.1.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a55cb37f82e331b3d3c5d51761db61e2", + "name": "keras-gpu", + "namespace": "python", + "sha256": "e873301833a34780470c222149a4e58226a63aff88810952f23445498362a0df", + "size": 414277, + "subdir": "linux-64", + "timestamp": 1516650836662, + "version": "2.1.2" + }, + "keras-gpu-2.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b781ec89704d01c4c30855b47303179e", + "name": "keras-gpu", + "namespace": "python", + "sha256": "060ecd4eedf2593c5717412ca791e5c5ac8c702499123e6e7f7d03cb918d1da4", + "size": 410295, + "subdir": "linux-64", + "timestamp": 1516650839818, + "version": "2.1.2" + }, + "keras-gpu-2.1.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64708d6c6cf022bc2fb329a52de27d62", + "name": "keras-gpu", + "namespace": "python", + "sha256": "d94c565ad21d17430382b9c32b94e9c71a1809402eea75faabfb09460fa41ced", + "size": 422546, + "subdir": "linux-64", + "timestamp": 1516651962619, + "version": "2.1.3" + }, + "keras-gpu-2.1.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bfbdba1434c64993b6688beeb60b94c2", + "name": "keras-gpu", + "namespace": "python", + "sha256": "f617d79e43aaca56050394101dc194f4e37301ffe4bf007671b6517c1190adc2", + "size": 435415, + "subdir": "linux-64", + "timestamp": 1516651994826, + "version": "2.1.3" + }, + "keras-gpu-2.1.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9625c7d02bf1c50c4723d803f6d054e", + "name": "keras-gpu", + "namespace": "python", + "sha256": "51503ae2652b0a8f6e83304a2a17bec539c275fe424f3627119b3e8b0504d0e0", + "size": 425703, + "subdir": "linux-64", + "timestamp": 1516652135543, + "version": "2.1.3" + }, + "keras-gpu-2.1.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45cdda772cbbd5db532551fa551dcd99", + "name": "keras-gpu", + "namespace": "python", + "sha256": "7019c01d927016c14970e674a142694547bced19ee37aaf62c5df1cfa6997111", + "size": 426084, + "subdir": "linux-64", + "timestamp": 1519752874758, + "version": "2.1.4" + }, + "keras-gpu-2.1.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc50ecdd3bb5167294fe71005e848c80", + "name": "keras-gpu", + "namespace": "python", + "sha256": "964ada5d046c656670e495b2a26feeefdf804e3b8e6017f3e9f710b650a43eac", + "size": 439477, + "subdir": "linux-64", + "timestamp": 1519752875449, + "version": "2.1.4" + }, + "keras-gpu-2.1.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "69f052336d2b779a19edbd409fc00823", + "name": "keras-gpu", + "namespace": "python", + "sha256": "50522bd26f5778798199c5828b10c14a108ff2e54756e5ee959b288ab65f8ee7", + "size": 435006, + "subdir": "linux-64", + "timestamp": 1519752865485, + "version": "2.1.4" + }, + "keras-gpu-2.1.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e7b419a3b327a26f45a7f07042828cc", + "name": "keras-gpu", + "namespace": "python", + "sha256": "04db1c61f475d47b9e0938f8d816b33ea4aa2b9f25cd72114393b9d3dcabf212", + "size": 436721, + "subdir": "linux-64", + "timestamp": 1521485514807, + "version": "2.1.5" + }, + "keras-gpu-2.1.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cca85ccc70f1fb9fef5f90d3aa753ba8", + "name": "keras-gpu", + "namespace": "python", + "sha256": "851364caeb5ffe39c3da8d1195fb6c491840ec34717befa5a0e801d07522f818", + "size": 444709, + "subdir": "linux-64", + "timestamp": 1521485206438, + "version": "2.1.5" + }, + "keras-gpu-2.1.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f51aa72c1fcd0d7c3816a56929d9e1c", + "name": "keras-gpu", + "namespace": "python", + "sha256": "b1c1d0a9dda903d8c4859b5a726a89ca0f6a39d3ba57950c083fd69a3e28ebf1", + "size": 440488, + "subdir": "linux-64", + "timestamp": 1521485209262, + "version": "2.1.5" + }, + "keras-gpu-2.1.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8005b4a2160af5550e485c920133bf79", + "name": "keras-gpu", + "namespace": "python", + "sha256": "722007025374f277ad51e3ed788bf6c94b2e5bacf6f3c9112495678231033bdd", + "size": 441698, + "subdir": "linux-64", + "timestamp": 1527633627177, + "version": "2.1.6" + }, + "keras-gpu-2.1.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "841f155f09ff06f16a52ad2615380115", + "name": "keras-gpu", + "namespace": "python", + "sha256": "503e7769791b0fcecc2f87ba8d3e20756f9a83314de0610f1bdfe96ffc833e01", + "size": 449942, + "subdir": "linux-64", + "timestamp": 1527633658064, + "version": "2.1.6" + }, + "keras-gpu-2.1.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py", + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.14", + "six >=1.9.0", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a873faa88b489b5723f87f655fa0f02", + "name": "keras-gpu", + "namespace": "python", + "sha256": "11f5cd937969d623f298b4e0b0b84336e31bf3f26fb9fcc29d73d39eff7db46a", + "size": 451853, + "subdir": "linux-64", + "timestamp": 1527633631545, + "version": "2.1.6" + }, + "keras-gpu-2.2.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "keras-base 2.2.0.*", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e20aac964009e1c4f58e851ee42ce7f5", + "name": "keras-gpu", + "namespace": "python", + "sha256": "677def1fcd88d6d768304cf998eb8765096eddb3184f6d78b90c93e6aeaf4c79", + "size": 5873, + "subdir": "linux-64", + "timestamp": 1529076398075, + "version": "2.2.0" + }, + "keras-gpu-2.2.2-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "keras-base 2.2.2.*", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb51113c5744d67033187a9d77a1cda0", + "name": "keras-gpu", + "namespace": "python", + "sha256": "be7a26bdef3d955035d1e182f4eb5a260de2fa61ff5e48e75377bfbb625fe2cd", + "size": 5739, + "subdir": "linux-64", + "timestamp": 1533138374640, + "version": "2.2.2" + }, + "keras-gpu-2.2.4-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "keras-base 2.2.4.*", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a1112fc413a6b004db02253cd12c0401", + "name": "keras-gpu", + "namespace": "python", + "sha256": "7d38e286f6ee499ecce7a64917648d980994a5c45a69515fa0909af27f78202d", + "size": 5550, + "subdir": "linux-64", + "timestamp": 1539019787297, + "version": "2.2.4" + }, + "keras-gpu-2.3.1-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "keras-base 2.3.1.*", + "tensorflow-gpu" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "73eaf9e4ae147ce931f468fba103f175", + "name": "keras-gpu", + "namespace": "python", + "sha256": "85b8825186f9a38f2ee7dc0e115ab48d1f59f7ad61245f53d9b427630931163a", + "size": 12183, + "subdir": "linux-64", + "timestamp": 1582144379857, + "version": "2.3.1" + }, + "keras-ocr-0.8.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "editdistance", + "efficientnet 1.0.0", + "essential_generators", + "fonttools", + "imgaug", + "pyclipper", + "python >=3.10,<3.11.0a0", + "shapely", + "tensorflow >=2.0", + "tqdm", + "validators" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f69a11713bb717d80242883d151beea6", + "name": "keras-ocr", + "sha256": "93eefd7cadcd0fe20e3820bde8127be1468d935ad5ec03bb44f4ee3c8277467e", + "size": 73986, + "subdir": "linux-64", + "timestamp": 1640815728486, + "version": "0.8.5" + }, + "keras-ocr-0.8.5-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "editdistance", + "efficientnet 1.0.0", + "essential_generators", + "fonttools", + "imgaug", + "pyclipper", + "python >=3.6,<3.7.0a0", + "shapely", + "tensorflow >=2.0", + "tqdm", + "validators" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "688311e14e1671160c992f1511aeaca0", + "name": "keras-ocr", + "sha256": "3e2f9243f69170ce2d7ca7f7b0de981cf5d2e147db93f05acfddeedd0e34eb6b", + "size": 283869, + "subdir": "linux-64", + "timestamp": 1605289713743, + "version": "0.8.5" + }, + "keras-ocr-0.8.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "editdistance", + "efficientnet 1.0.0", + "essential_generators", + "fonttools", + "imgaug", + "pyclipper", + "python >=3.7,<3.8.0a0", + "shapely", + "tensorflow >=2.0", + "tqdm", + "validators" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd88eb9524c84bcaa12b6c7d7b56c607", + "name": "keras-ocr", + "sha256": "3c7dab8d92c301e0677c1c0e646c46ce283b136d550797deb0fe6e3643c7e3a3", + "size": 283808, + "subdir": "linux-64", + "timestamp": 1605289716575, + "version": "0.8.5" + }, + "keras-preprocessing-1.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da3b8a684a6ee3c4e739ac7327c34e16", + "name": "keras-preprocessing", + "sha256": "05de193e27cd238d0806288eb306cb5da0def71862200a6a34c8a4445163e738", + "size": 44060, + "subdir": "linux-64", + "timestamp": 1529074474117, + "version": "1.0.1" + }, + "keras-preprocessing-1.0.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15f896b04adce91c8f11bf3205bde088", + "name": "keras-preprocessing", + "sha256": "2774c7d956e3a56e9146aee2da9b07a13f39ff79f16fda56b0c7994444707534", + "size": 45290, + "subdir": "linux-64", + "timestamp": 1529074378967, + "version": "1.0.1" + }, + "keras-preprocessing-1.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c30f2b3e12221a0b016c018f9e6b5774", + "name": "keras-preprocessing", + "sha256": "45e6560fc38e18b46207915aed06a91f0c2b749d18d40154c56e6828893f4ad1", + "size": 44903, + "subdir": "linux-64", + "timestamp": 1529074504538, + "version": "1.0.1" + }, + "keras-preprocessing-1.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8e9bc33281ddb6c252ce70dc27a5eec", + "name": "keras-preprocessing", + "sha256": "9f6a8e51b85527767c523e5fdfd042e0ee1f2fbeede636949989e1e4442ffbeb", + "size": 45651, + "subdir": "linux-64", + "timestamp": 1533108188555, + "version": "1.0.2" + }, + "keras-preprocessing-1.0.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f14cc7d77726ece381ce94deb4d9011", + "name": "keras-preprocessing", + "sha256": "2759e26092f8143d449359d1d0f8568299cf659e260747dbbea87d2b631889df", + "size": 45191, + "subdir": "linux-64", + "timestamp": 1534973207466, + "version": "1.0.2" + }, + "keras-preprocessing-1.0.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08a380aeb597b96e30cd9265e137ff37", + "name": "keras-preprocessing", + "sha256": "19030dae24b994b3670aee801061d5ca4fc4039ec207048fbeac0d950d9d970d", + "size": 45875, + "subdir": "linux-64", + "timestamp": 1533108197212, + "version": "1.0.2" + }, + "keras-preprocessing-1.0.2-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=3.5,<3.6.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0577c1e2896983cd357c9f498d442a4e", + "name": "keras-preprocessing", + "sha256": "bbc308df617371815d9d0ea70aff170a595b1bed78597a452293c42ebe52bd35", + "size": 45935, + "subdir": "linux-64", + "timestamp": 1534973212635, + "version": "1.0.2" + }, + "keras-preprocessing-1.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f4911dc445c1086e59bddafe7df10fc", + "name": "keras-preprocessing", + "sha256": "b085b79ffd852b24f8879306ff16d7a394fa2bf7f7a90721b6d78968487eb3c6", + "size": 45046, + "subdir": "linux-64", + "timestamp": 1533108217816, + "version": "1.0.2" + }, + "keras-preprocessing-1.0.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af86c7cbd0a74a72f3c47a0cff9b7b59", + "name": "keras-preprocessing", + "sha256": "3601cc346c018ec22a4e632264d28fa2966f046a5d29c3983a029fe74490172a", + "size": 45294, + "subdir": "linux-64", + "timestamp": 1534973148997, + "version": "1.0.2" + }, + "keras-preprocessing-1.0.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=3.7,<3.8.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e79d69b9caf799e6ef60300b6de511a9", + "name": "keras-preprocessing", + "sha256": "fe82680c6728f9c32993deab1031c9bb6194bb8381478746a9b009318d59fb4c", + "size": 46049, + "subdir": "linux-64", + "timestamp": 1534973207447, + "version": "1.0.2" + }, + "keras-preprocessing-1.0.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=2.7,<2.8.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a1afa158681fa09b50dac0221cf18486", + "name": "keras-preprocessing", + "sha256": "5a44325a2ac7d18493507d7ddc90134ac18bad525ea5d10d56edaecd256be9f5", + "size": 51077, + "subdir": "linux-64", + "timestamp": 1538424982424, + "version": "1.0.5" + }, + "keras-preprocessing-1.0.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=3.6,<3.7.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0e3f8b225d69dce4f7f84a1e99d0c070", + "name": "keras-preprocessing", + "sha256": "9805b43297d409099db30edb93721a71c2906dd411e9a97cb90751b280c123e2", + "size": 51382, + "subdir": "linux-64", + "timestamp": 1538425360255, + "version": "1.0.5" + }, + "keras-preprocessing-1.0.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "keras >=2.1.6" + ], + "depends": [ + "numpy >=1.9.1", + "python >=3.7,<3.8.0a0", + "scipy >=0.14", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "762944df1572b4d5e187cef689d36b20", + "name": "keras-preprocessing", + "sha256": "9708ed5693684c3f374579218ff876e34471459c7f40c7af0bcf355915d3d542", + "size": 50263, + "subdir": "linux-64", + "timestamp": 1538424954137, + "version": "1.0.5" + }, + "keyring-10.4.0-py27h70e99c7_0.conda": { + "build": "py27h70e99c7_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "md5": "4bb3bf81830151c9b8bded4add49a910", + "name": "keyring", + "sha256": "d89d1de84cff6f46bfe5cc5409a3bef539b055fbd88606d0ddf81e53fd1542f5", + "size": 48137, + "subdir": "linux-64", + "timestamp": 1508689966965, + "version": "10.4.0" + }, + "keyring-10.4.0-py35h596fbf2_0.conda": { + "build": "py35h596fbf2_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Python Software Foundation or MIT", + "md5": "2d7b904dbc4e4650a7c76049d103678c", + "name": "keyring", + "sha256": "f5e499cf86dc95aabba32458748259c3ca2d4bbe1891a48bee967d7b3338911a", + "size": 49003, + "subdir": "linux-64", + "timestamp": 1508689968457, + "version": "10.4.0" + }, + "keyring-10.4.0-py36h4fce1c9_0.conda": { + "build": "py36h4fce1c9_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation or MIT", + "md5": "4a8bd281d7a8b13cd39179f258c0dee1", + "name": "keyring", + "sha256": "d21dc1d8ef627634c1efd548d0dc4113a6aa6427954c5183e4b32e588ef97033", + "size": 48045, + "subdir": "linux-64", + "timestamp": 1508689992612, + "version": "10.4.0" + }, + "keyring-10.5.0-py27h855395d_0.conda": { + "build": "py27h855395d_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "30513d7407db9cb24f877265270f0947", + "name": "keyring", + "sha256": "0d24150e66669350c544894f398625384d1eeb77db6b51f307307bb6c8e8c330", + "size": 48099, + "subdir": "linux-64", + "timestamp": 1511832203907, + "version": "10.5.0" + }, + "keyring-10.5.0-py35hbf6c1c3_0.conda": { + "build": "py35hbf6c1c3_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "d71e21baeabfcdc75c943190108eb2d2", + "name": "keyring", + "sha256": "d0f7360e00cfea33b874654f5f111e9b231f47800ce3fd6719015b9bb944bf4a", + "size": 49456, + "subdir": "linux-64", + "timestamp": 1511832213563, + "version": "10.5.0" + }, + "keyring-10.5.0-py36h0041fa8_0.conda": { + "build": "py36h0041fa8_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "f809e2db67e57ee9bf0192c882fab364", + "name": "keyring", + "sha256": "e874ddfdc65296a1e5ec3e3bc2b6295f6fea7bd54c418345b890f1fedde93dd7", + "size": 49072, + "subdir": "linux-64", + "timestamp": 1511832213254, + "version": "10.5.0" + }, + "keyring-11.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "87d150ed5882378b038ec2d6c6078e0a", + "name": "keyring", + "sha256": "03f00ff99011d3d52bba661a36ecba15a1080b184a810e5838fa1e7103ef9a2a", + "size": 47821, + "subdir": "linux-64", + "timestamp": 1519758157765, + "version": "11.0.0" + }, + "keyring-11.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "16b4265f17fb25bf484ba5131c3d004b", + "name": "keyring", + "sha256": "d8fc1cc715a846aed7a8ec00cd592b81255b34f658a986a9272f7f31ab668051", + "size": 49157, + "subdir": "linux-64", + "timestamp": 1519758239384, + "version": "11.0.0" + }, + "keyring-11.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "8754b4460d175201313453935fad9e52", + "name": "keyring", + "sha256": "2204e8d6a33744041d21462b37c09f525fda2d8f5c327d54c7d99792f886a36a", + "size": 48723, + "subdir": "linux-64", + "timestamp": 1519758120888, + "version": "11.0.0" + }, + "keyring-12.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "115b45c013e2a10ddd86783ed7864ed7", + "name": "keyring", + "sha256": "600342ee577dd0c5446d223e6876a3f463d88e592d25418e175e6a74c4fc6fba", + "size": 51226, + "subdir": "linux-64", + "timestamp": 1522855493404, + "version": "12.0.0" + }, + "keyring-12.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.5,<3.6.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "d880d9f5d036e19c99149b9942e2462e", + "name": "keyring", + "sha256": "5085fcfb639e1310187fa6269b9a3bbd2e4a991f4bd9f4bbe65c89af5e2cef70", + "size": 52197, + "subdir": "linux-64", + "timestamp": 1522855513959, + "version": "12.0.0" + }, + "keyring-12.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "5b81bb36fff358c2704e266b1c88746e", + "name": "keyring", + "sha256": "75bb7a134581eb237ab789f862a04a93c4c756501df7e9c3a827ca2955e82d6c", + "size": 51734, + "subdir": "linux-64", + "timestamp": 1522855526893, + "version": "12.0.0" + }, + "keyring-12.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "43f38205b727cbbde9fa1b6d2f3ad5dd", + "name": "keyring", + "sha256": "08e8a661108360f7cbe2041383cadd663092c6e3fa2ff4403c4cbc606aedc550", + "size": 51514, + "subdir": "linux-64", + "timestamp": 1523991349355, + "version": "12.0.1" + }, + "keyring-12.0.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.5,<3.6.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "56315d6a7233f4d7f068b775e68a77e3", + "name": "keyring", + "sha256": "4966868f76cd49516661386e2dd090e79e0591c458eb6d5a1956485fb9ffe940", + "size": 52229, + "subdir": "linux-64", + "timestamp": 1523991779698, + "version": "12.0.1" + }, + "keyring-12.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "45c6cf7519b47439b85e9d5bbedd2a7d", + "name": "keyring", + "sha256": "5997162f889226e0ac0e8152f5652fd240917258b93caa75fea82e40dc56729f", + "size": 51984, + "subdir": "linux-64", + "timestamp": 1523991778011, + "version": "12.0.1" + }, + "keyring-12.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "d046be92e0db028801cd0bed415076eb", + "name": "keyring", + "sha256": "048d3fb76a3e2c275f0382b85fce11f571f5b132ae9928178f9e95b018e1c81f", + "size": 51556, + "subdir": "linux-64", + "timestamp": 1527688222798, + "version": "12.2.1" + }, + "keyring-12.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.5,<3.6.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "69571895adf8aa6dd8a080041617654a", + "name": "keyring", + "sha256": "45e2f717e439b1ad7ac3ba072e7332e508871809f47cc1c981a91938153f539a", + "size": 52318, + "subdir": "linux-64", + "timestamp": 1527688239064, + "version": "12.2.1" + }, + "keyring-12.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "11a570ace34278d80c40048d576975a8", + "name": "keyring", + "sha256": "9f20f4d9a2980b30d1101fa4fa4b2205ff6358240cade9de1efbfefd2f9e3cdd", + "size": 52053, + "subdir": "linux-64", + "timestamp": 1527688209849, + "version": "12.2.1" + }, + "keyring-13.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "9852f2430e7555df60d520f4b1fbe17a", + "name": "keyring", + "sha256": "b8fcbbb9f33c0f9c1860fdb80693b4e8543d76989ec342a9d80612e7935c1fc7", + "size": 51851, + "subdir": "linux-64", + "timestamp": 1529952753705, + "version": "13.0.0" + }, + "keyring-13.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.5,<3.6.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "439bbbb44c2db76521c2e74f1a7eae70", + "name": "keyring", + "sha256": "2372baabe783505c970bc3762bc82d6a02c35bd1c3e2586fe784ba991f1a68e2", + "size": 52761, + "subdir": "linux-64", + "timestamp": 1529953525524, + "version": "13.0.0" + }, + "keyring-13.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "c9da685a236a84d599574eebfd5a4bb6", + "name": "keyring", + "sha256": "039abaa1e34a98afd45216e6e3d304b4095a5d4e3537393b0c2cc031e9af3d77", + "size": 52404, + "subdir": "linux-64", + "timestamp": 1529953407015, + "version": "13.0.0" + }, + "keyring-13.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "23b1771ea6fd5deab87ae0427d1b4433", + "name": "keyring", + "sha256": "4baa3be16f0851943ea8ff2d364cf601ff7c93442e65cef0588584233ba1c902", + "size": 52280, + "subdir": "linux-64", + "timestamp": 1530898213730, + "version": "13.0.0" + }, + "keyring-13.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "520ad7271e1cc0f78241bb34bb5d0a3d", + "name": "keyring", + "sha256": "2d843d5007a350841d9932c2dbcbd42fb64732190001bb7dd201da19c62169f4", + "size": 51577, + "subdir": "linux-64", + "timestamp": 1532540690912, + "version": "13.2.1" + }, + "keyring-13.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.5,<3.6.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "4c1c06bd7cf346da92a9a0091d3b9444", + "name": "keyring", + "sha256": "91ec11d599b7f64f4a86f27544c07afe35e385411c775270638780f225c90b9f", + "size": 53090, + "subdir": "linux-64", + "timestamp": 1532540823640, + "version": "13.2.1" + }, + "keyring-13.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "78ed0bb11d32ca2dbcd36d9a1564f354", + "name": "keyring", + "sha256": "48064b505dd4a01bce0d53bb526ace2940918e6aba392123613e299953d69b68", + "size": 52599, + "subdir": "linux-64", + "timestamp": 1532540661721, + "version": "13.2.1" + }, + "keyring-13.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "c24045c3cfe2babf212f4607442bc80d", + "name": "keyring", + "sha256": "0d0cedb71193b5c0cef967aa009476762d50b29066402b7fb4c20f7ac949fbae", + "size": 52076, + "subdir": "linux-64", + "timestamp": 1532540708238, + "version": "13.2.1" + }, + "keyring-15.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "84eef286a05daa7d3a3b084af4fbcdba", + "name": "keyring", + "sha256": "cc2b9b1dfccf7d065c2e6b8d60db1cf2899aa0b45ad1afd429acdbfdd30caf23", + "size": 52778, + "subdir": "linux-64", + "timestamp": 1539637773281, + "version": "15.1.0" + }, + "keyring-15.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "75a6280282907d6cabb123616d37a52a", + "name": "keyring", + "sha256": "6942a15f9c50637edf57bd4e4310f21f48e9c65a20ad0ddc1437e59a65aec3b4", + "size": 52680, + "subdir": "linux-64", + "timestamp": 1539637795056, + "version": "15.1.0" + }, + "keyring-15.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "0f0c5ab1e988b1780943f098467d87b6", + "name": "keyring", + "sha256": "aa5f989b851f283d06d912532b0210ca0fcc04cca35b21ea67c3e415a8f21710", + "size": 52757, + "subdir": "linux-64", + "timestamp": 1539637787710, + "version": "15.1.0" + }, + "keyring-16.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "ec20ef142aa1ccee9db15d1c4193f62a", + "name": "keyring", + "sha256": "931e8adf2cbf62c64bc65fb514285c8bb4c45371fc90d1b9b11363fc76095b5e", + "size": 54019, + "subdir": "linux-64", + "timestamp": 1540981129976, + "version": "16.0.0" + }, + "keyring-16.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "9f0aa7c2c1eeef887c25b9fab6741dae", + "name": "keyring", + "sha256": "0ecb4c077060de82adf8d777cf23b5beb712a7c969d9d54f41ac6822d52c6d21", + "size": 55221, + "subdir": "linux-64", + "timestamp": 1540981149966, + "version": "16.0.0" + }, + "keyring-16.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "cf7b7ac1f5e2986a1803824c728217f6", + "name": "keyring", + "sha256": "627b71fa0adab10969b5d8616dbfdcb58fc2d176357b0aa5635a49e54b81a5c0", + "size": 54373, + "subdir": "linux-64", + "timestamp": 1540981150962, + "version": "16.0.0" + }, + "keyring-16.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "b0a93e6d7101cf6016417b50f66cb10a", + "name": "keyring", + "sha256": "4d49fb407089ace584854a993547c4bd2188b0293bd3783cf655752bd74bbea9", + "size": 55231, + "subdir": "linux-64", + "timestamp": 1542313636873, + "version": "16.0.2" + }, + "keyring-16.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "141d4c687a760f78bc5567bf497bb34c", + "name": "keyring", + "sha256": "4f3befb69daf6fe764ef5d4f733faa984804fe2e1e0ef12c457d2f85da964e79", + "size": 54774, + "subdir": "linux-64", + "timestamp": 1542313657330, + "version": "16.0.2" + }, + "keyring-16.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "2c0b3da8e4785e7d5ec5fd161db2a3d9", + "name": "keyring", + "sha256": "7be0dae1fd5ca3c4b88fd5ac6ebf648994fc2729999522fea7ecbebe195b77ab", + "size": 54741, + "subdir": "linux-64", + "timestamp": 1542313592244, + "version": "16.0.2" + }, + "keyring-16.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "15a4e985c053e8dcdf4aa4994b718c6c", + "name": "keyring", + "sha256": "4c6bf6d089377930de641163e0ad34b1fc9cf538fa55cf34894dd2e5cb0482a1", + "size": 55757, + "subdir": "linux-64", + "timestamp": 1542639700278, + "version": "16.1.0" + }, + "keyring-16.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "87ee12f0a4267a15bfbb6f8a08c50897", + "name": "keyring", + "sha256": "6761fa0c4e298f68a6311fe3ac799ed31ce7e32ef7591db667e9d9944d9045b3", + "size": 56336, + "subdir": "linux-64", + "timestamp": 1542639722579, + "version": "16.1.0" + }, + "keyring-16.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "4f3788dd069aea1d7eaf9719370a9188", + "name": "keyring", + "sha256": "4dd30235dcfe76f0509c4d7906124d4be342ea8d090c278bf85b3ac6ff5ada60", + "size": 55549, + "subdir": "linux-64", + "timestamp": 1542639689237, + "version": "16.1.0" + }, + "keyring-16.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "65f1878e099904a7e40a9f68337d4814", + "name": "keyring", + "sha256": "b8e55b094356474a450c36332da6a8e8781e1ad8627aaa414bf565385f5e61ce", + "size": 57797, + "subdir": "linux-64", + "timestamp": 1543525883570, + "version": "16.1.1" + }, + "keyring-16.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "37a4eebcbf0692a3d9c8725bf9f795d5", + "name": "keyring", + "sha256": "eff866a4be825650f745193a26c65079be15b615cd43033bec4214db81056575", + "size": 59035, + "subdir": "linux-64", + "timestamp": 1543525904962, + "version": "16.1.1" + }, + "keyring-16.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "124ac609969cfc198c64797c4cf602a8", + "name": "keyring", + "sha256": "2550de71205fd7668992034966ffe112cea4c491a2c7df0d1b32db3de802529d", + "size": 58270, + "subdir": "linux-64", + "timestamp": 1543525860603, + "version": "16.1.1" + }, + "keyring-17.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "d3228b3436f7e1817e8b205adf05c6c3", + "name": "keyring", + "sha256": "27410829a2ce736bfbf628ea1f3540adc864010f012b1462d57ff33c4050ab54", + "size": 55254, + "subdir": "linux-64", + "timestamp": 1545091737710, + "version": "17.0.0" + }, + "keyring-17.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "1459166e8d160ca10467bb57ff37f815", + "name": "keyring", + "sha256": "4b858c9fefe79edc63df7184e0cc0a6aecbc2ecba8a5b6e9baec63cd14aae68a", + "size": 56452, + "subdir": "linux-64", + "timestamp": 1545091745092, + "version": "17.0.0" + }, + "keyring-17.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "957cea08741aee27ddc9c945071cec9e", + "name": "keyring", + "sha256": "a02d7a69572ecebbed322641ad578cfd8e367726eea8e27a05490855fa103a3e", + "size": 55588, + "subdir": "linux-64", + "timestamp": 1545091764210, + "version": "17.0.0" + }, + "keyring-17.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "b8e6b6c2b81c999470cded25e933f1e5", + "name": "keyring", + "sha256": "69389dd2850ddbd3960c935190ac7b8f5bc34402684d64a178d4fc79e9d1dd79", + "size": 58851, + "subdir": "linux-64", + "timestamp": 1547232997607, + "version": "17.1.1" + }, + "keyring-17.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "31617c97c6efae34b9f40a1d583f197a", + "name": "keyring", + "sha256": "565e57c0ea4b3dde71abd0447e8790f340dcb2c0d35308769f4b437a323644dd", + "size": 59255, + "subdir": "linux-64", + "timestamp": 1547233003068, + "version": "17.1.1" + }, + "keyring-17.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "0bbb4da93666f200e74981c4ec2c20ec", + "name": "keyring", + "sha256": "f0fed71b7f9ca9394b15bea980d93f0167aebd5350f2942b21158e9d079ce5ef", + "size": 58513, + "subdir": "linux-64", + "timestamp": 1547233009265, + "version": "17.1.1" + }, + "keyring-18.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=2.7,<2.8.0a0" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "c09ad20678793c5d7b0a80b798a25284", + "name": "keyring", + "sha256": "41693d2ca506f2dad4f1f22c0e1b9939198b2673019d2b4ac08fa14f8eb77045", + "size": 60680, + "subdir": "linux-64", + "timestamp": 1550348346763, + "version": "18.0.0" + }, + "keyring-18.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "40687fd6432518871e6e57e99e3c447b", + "name": "keyring", + "sha256": "6a1fae00c6df3b1398a425047cb72eb6a6b9142c16f1ca5fd7fea792c0bf4c7e", + "size": 60909, + "subdir": "linux-64", + "timestamp": 1550348348939, + "version": "18.0.0" + }, + "keyring-18.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "9fc2208a0a47501cb012859d65225c35", + "name": "keyring", + "sha256": "49b7d70fc4b9759042a800ad6f79eecdee51b298b3240b0a186159aa29a96963", + "size": 60918, + "subdir": "linux-64", + "timestamp": 1550348287541, + "version": "18.0.0" + }, + "keyring-18.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "3a7d259df7cc6fa7d840f846a2ecb5af", + "name": "keyring", + "sha256": "e7b21967ab0a4fe1b3879401cd17965d702fe591cc9ff70ea1554ccd86af5a84", + "size": 58893, + "subdir": "linux-64", + "timestamp": 1574177569500, + "version": "18.0.0" + }, + "keyring-18.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib-metadata", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "md5": "dbc84c6d7e4cbcaffc517308e3e05307", + "name": "keyring", + "sha256": "e5e1c06c41a42b4590d08870a89e603ddab9a200089730ef8287fe7858c6314a", + "size": 58671, + "subdir": "linux-64", + "timestamp": 1594840368567, + "version": "18.0.1" + }, + "keyring-18.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib-metadata", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "md5": "70b461f77dd57b3fe8c4dd56f9773299", + "name": "keyring", + "sha256": "0d23e6fc9f7aba3214eee12e9ca46a2e185ee734ec5df5b77bf861f6beda4c9f", + "size": 59641, + "subdir": "linux-64", + "timestamp": 1594844550640, + "version": "18.0.1" + }, + "keyring-18.0.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints", + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "md5": "e677e230c3056e5e14e5aeae156cb0b0", + "name": "keyring", + "sha256": "f267fe2e75255e859278eb882c37a8d765c81a6e0e885d7cdb911dd7c379f428", + "size": 59922, + "subdir": "linux-64", + "timestamp": 1594842854796, + "version": "18.0.1" + }, + "keyring-19.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "2842ddfdf9d186c09131339ad05014a2", + "name": "keyring", + "sha256": "3f97056b00a2ef1fd40918c991ce627a1b0afe3cc00e918d9067e6299fbaa326", + "size": 61832, + "subdir": "linux-64", + "timestamp": 1574272893974, + "version": "19.2.0" + }, + "keyring-19.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "4a312390203cda9256309e0a55487081", + "name": "keyring", + "sha256": "3883fbde5553bef1ca7f7ba70fe4c7f3547a178a934d20989f8616d60448c818", + "size": 61750, + "subdir": "linux-64", + "timestamp": 1574272884458, + "version": "19.2.0" + }, + "keyring-19.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "8b6fbd795289a942445d36e1d59d5673", + "name": "keyring", + "sha256": "4bb274d7082c7cb3f2ec5ecdc46ff59d117dafb071064c7c9444015d0535c6be", + "size": 61946, + "subdir": "linux-64", + "timestamp": 1574272932911, + "version": "19.2.0" + }, + "keyring-20.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "a73b0e336a7695256a1f9fa75ba0eaf7", + "name": "keyring", + "sha256": "f198b3501fa524b87c9efed9e82169e5eda4cdc2514242b0628c6e0f96367d5e", + "size": 56664, + "subdir": "linux-64", + "timestamp": 1576602572036, + "version": "20.0.0" + }, + "keyring-20.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "d997ce9ae4f32ab19bc1eab24f5a55e2", + "name": "keyring", + "sha256": "500f201364c50f7555dc6a36af3fcd10f25a6bac41abeb4e4fd5545fbfe02a85", + "size": 56907, + "subdir": "linux-64", + "timestamp": 1576602522043, + "version": "20.0.0" + }, + "keyring-20.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "62cbbc42c71cf77086dbb56af7186183", + "name": "keyring", + "sha256": "bf1dc64b7549eef1daf666d4cee395cccb0adfb32e9768afda1c9fae266f9518", + "size": 56933, + "subdir": "linux-64", + "timestamp": 1576602596353, + "version": "20.0.0" + }, + "keyring-21.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "059ad463c6208dda078f31aa4a30b9a2", + "name": "keyring", + "sha256": "5e7065105e46f5ebaaca9136cb1969aebb374f232f803f71a9b9971540a89ab6", + "size": 57322, + "subdir": "linux-64", + "timestamp": 1580400530486, + "version": "21.1.0" + }, + "keyring-21.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "df0decc8115a90b4d54e7f40215676ba", + "name": "keyring", + "sha256": "16a005c3138e022fb98616eda2756b72eac76c165d2c9342b188f8b30de6c78e", + "size": 57451, + "subdir": "linux-64", + "timestamp": 1580400528276, + "version": "21.1.0" + }, + "keyring-21.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "f94cdd914c4cbd7df3eb634c7b48a898", + "name": "keyring", + "sha256": "c875687ec32bda3ae51c6b034fac639857b29b8396b921edcfb0f72ae909c39a", + "size": 57343, + "subdir": "linux-64", + "timestamp": 1580400525851, + "version": "21.1.0" + }, + "keyring-21.1.1-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "e207dc9e8dfb663aa6f565a859ccc176", + "name": "keyring", + "sha256": "a34bf043715b73cd956c8c0daef0bcff53a492f2aae2f13653663e8f2ce7e038", + "size": 58577, + "subdir": "linux-64", + "timestamp": 1585850904212, + "version": "21.1.1" + }, + "keyring-21.1.1-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "54866856703160ce313b007b64802fde", + "name": "keyring", + "sha256": "1c0bf9a6e60775f89d2e53e2e9d1d60d1a258cdbcdc14978890b825280cd68b0", + "size": 58546, + "subdir": "linux-64", + "timestamp": 1585850900433, + "version": "21.1.1" + }, + "keyring-21.1.1-py38_2.conda": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "entrypoints", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "afbe61e5e03310ab326f8bf3a4221215", + "name": "keyring", + "sha256": "b46eefd3acd524a27acb9b9f1bd16f802736cffcd628fe8a78d869412c1d2931", + "size": 57969, + "subdir": "linux-64", + "timestamp": 1585850897188, + "version": "21.1.1" + }, + "keyring-21.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "1180569d21ecd53a2f5e6d2483b2de65", + "name": "keyring", + "sha256": "f715905bdff62ce38ef7006eb61b60e04d824c640f2d77a14b929bd9f688465f", + "size": 58571, + "subdir": "linux-64", + "timestamp": 1593109750955, + "version": "21.2.1" + }, + "keyring-21.2.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb78fea0342062a921c37251e0a1057f", + "name": "keyring", + "sha256": "509ed6ad07c126d0bc03d918f03f22196f1cc02f82c3b65153b754e907be6ae8", + "size": 60271, + "subdir": "linux-64", + "timestamp": 1615497932053, + "version": "21.2.1" + }, + "keyring-21.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "00fd4cd722d070ebe17f8a8e603440d1", + "name": "keyring", + "sha256": "24a4b41935f6773ecc32f9fb4ac835501fdaba79f5ff8f3e96f5e7cada33bb16", + "size": 59305, + "subdir": "linux-64", + "timestamp": 1593109729316, + "version": "21.2.1" + }, + "keyring-21.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "268c94b1f091a3b77d741f70586a5aff", + "name": "keyring", + "sha256": "8826d6acb32c2b93bc264136ccb06fc99d6762916b7089bfbecc5f45808c7317", + "size": 60421, + "subdir": "linux-64", + "timestamp": 1615498319103, + "version": "21.2.1" + }, + "keyring-21.2.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "3065c14e49a74bae3b9f9ec61f3f769a", + "name": "keyring", + "sha256": "4cd3b736447757b15c5df351af7eff7ffd601d2c2b55d26153da42b5de56d9be", + "size": 58901, + "subdir": "linux-64", + "timestamp": 1593109750628, + "version": "21.2.1" + }, + "keyring-21.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fddcf6fad3de99a14f08c6c586224880", + "name": "keyring", + "sha256": "5c88f5e3eeef33cbc374de8bf1e604a8a0a2d62a452001154b8c94d7f725b4c6", + "size": 60460, + "subdir": "linux-64", + "timestamp": 1615496691816, + "version": "21.2.1" + }, + "keyring-21.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9f8bc75a250a7b701180e02ec8ffbd6", + "name": "keyring", + "sha256": "a7691ec892d4e8b5453b52a4c232240d287a5be217d07c29c72f638a38dc8e8b", + "size": 60428, + "subdir": "linux-64", + "timestamp": 1615498327718, + "version": "21.2.1" + }, + "keyring-21.3.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "md5": "5dd5a66e3dbe76d6a0940714f05253b3", + "name": "keyring", + "sha256": "bbc028db4ef2464157edfc525393f64fe75b93433930295cdc6085c0dc6fcbab", + "size": 55351, + "subdir": "linux-64", + "timestamp": 1605040305638, + "version": "21.3.0" + }, + "keyring-21.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "3b0616f0a2fc50483968492ef4af9f9c", + "name": "keyring", + "sha256": "b9c9eced25569f76cc92a3326f7fb27288d49a39872a4684a0adac1bfc132de1", + "size": 51714, + "subdir": "linux-64", + "timestamp": 1596873535518, + "version": "21.3.0" + }, + "keyring-21.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "md5": "7d6ab02511a67c90984aa793cd495308", + "name": "keyring", + "sha256": "39d87b1a94738bc451184780df082688efc9032b9a0233434c2a5cc4ac76f993", + "size": 56285, + "subdir": "linux-64", + "timestamp": 1605040293440, + "version": "21.3.0" + }, + "keyring-21.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "2cd075749c0cdcc6d71c16524414c31f", + "name": "keyring", + "sha256": "2b192c8d3aa21898a1956c9ecb4c15e4922e93244ab24ef44b9d8a853bf3b263", + "size": 59366, + "subdir": "linux-64", + "timestamp": 1598375836132, + "version": "21.3.1" + }, + "keyring-21.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "b979419ce1feaa129105643c11d611a3", + "name": "keyring", + "sha256": "bf2d9bf9faee272b694299e46369f346b8cbd4ff9135fab676b37d62f1161e17", + "size": 59408, + "subdir": "linux-64", + "timestamp": 1598375837495, + "version": "21.3.1" + }, + "keyring-21.3.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "5553e02817a82f5be8d7d3e2eec21f8e", + "name": "keyring", + "sha256": "675693afcdc7c34384e933d9f00efd361f977605e908422202710c8fc43e41ae", + "size": 59462, + "subdir": "linux-64", + "timestamp": 1598375852204, + "version": "21.3.1" + }, + "keyring-21.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.9,<3.10.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "232d690d5ab6e72ca1636b7396aa0271", + "name": "keyring", + "sha256": "16551547b8136e634737ba2aa2121c3842e751e5a0d95b7dba9c8853d31b15ed", + "size": 59731, + "subdir": "linux-64", + "timestamp": 1607573567387, + "version": "21.3.1" + }, + "keyring-21.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "a936fe98f8984560028d9da342bd6a4c", + "name": "keyring", + "sha256": "ac02b5c088315e6a23c7770ac529ba4d38ec66ebfbefa692701dbfca3302eae2", + "size": 59742, + "subdir": "linux-64", + "timestamp": 1598884793506, + "version": "21.4.0" + }, + "keyring-21.4.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.6,<3.7.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "1a1ea9277b7265375bcbdc05c5801029", + "name": "keyring", + "sha256": "3a1c5fb4b753e0ce75a29745c05a93c5eeca4fb9aa39cacbcd09521bd7fa892d", + "size": 53525, + "subdir": "linux-64", + "timestamp": 1601490889875, + "version": "21.4.0" + }, + "keyring-21.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "entrypoints", + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "dcde839cb6de024c97d84efd90bb5777", + "name": "keyring", + "sha256": "c896af22eccb61e15099157dc6c065eb4a1cc7bab73571f5d4fa24ed574c618d", + "size": 60551, + "subdir": "linux-64", + "timestamp": 1598884806937, + "version": "21.4.0" + }, + "keyring-21.4.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "7552898813562f2b8f6f9d6af6a36bec", + "name": "keyring", + "sha256": "a37715499fa82ca5226c4e4832892f2048e6fbc5b1f8e6ff1ebdef5434357e5f", + "size": 53543, + "subdir": "linux-64", + "timestamp": 1601490870236, + "version": "21.4.0" + }, + "keyring-21.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "entrypoints", + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "013d3854b4620f233792e5641d0d2ba8", + "name": "keyring", + "sha256": "eed3d42d4fc643e49da2b1d53006424ceb07412e2d6cc140ea7280f9b729a202", + "size": 59880, + "subdir": "linux-64", + "timestamp": 1598884788122, + "version": "21.4.0" + }, + "keyring-21.4.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "c8641645ace8e0c866833dc024f33c42", + "name": "keyring", + "sha256": "c88db4165e117cdf81f0e7f3c93d976a7cf98757268b8e2606aab2d866de52e1", + "size": 53085, + "subdir": "linux-64", + "timestamp": 1601490866628, + "version": "21.4.0" + }, + "keyring-21.4.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "secretstorage" + ], + "license": "Python Software Foundation or MIT", + "license_family": "MIT", + "md5": "4f69acf517bfaea6590822ef0f693aed", + "name": "keyring", + "sha256": "94417ee440474efe11e826947ab3af0d24ec3522fb13ecee6056f9f826effc90", + "size": 61116, + "subdir": "linux-64", + "timestamp": 1607709224657, + "version": "21.4.0" + }, + "keyring-21.6.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c5cabf5d75216e1de528ffff28964f2", + "name": "keyring", + "sha256": "20ed0bac2528184c94ebe0d59dc471bbf0de72bb705a8b210eaab07c02d07056", + "size": 53624, + "subdir": "linux-64", + "timestamp": 1608667223912, + "version": "21.6.0" + }, + "keyring-21.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a64f594c2f3168711e377f3525ab9821", + "name": "keyring", + "sha256": "1e6c6720cc87ddd6e5ad34246ced879dfeb9d4bb57d2d67131c50c36d61bb407", + "size": 53646, + "subdir": "linux-64", + "timestamp": 1608667262867, + "version": "21.6.0" + }, + "keyring-21.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08b0f3cf1a3ec340965c5c59e8658823", + "name": "keyring", + "sha256": "30490fdc8fad43aafd38b24b36a3f2e3836ab35521c04aafa927ea201e615798", + "size": 53832, + "subdir": "linux-64", + "timestamp": 1608667261813, + "version": "21.6.0" + }, + "keyring-21.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b68ae443404e702b68fe432f24777324", + "name": "keyring", + "sha256": "646c27aab0f894ca456a4dd105de16a77b11b50f003aa7f9bf306335ed8d08a3", + "size": 54529, + "subdir": "linux-64", + "timestamp": 1608667247731, + "version": "21.6.0" + }, + "keyring-21.7.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7ea1b4cef99f3924545991f9cf97a1f", + "name": "keyring", + "sha256": "411275bf9b6316f695bedef48f87141a31c5523848cf234535f63e90a0017e16", + "size": 54439, + "subdir": "linux-64", + "timestamp": 1608756057308, + "version": "21.7.0" + }, + "keyring-21.7.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92a6ba39ddf5bf5b9f1d4634fafe8de6", + "name": "keyring", + "sha256": "380e8e015f1e89133ca2bacbc06c6617cf896e9abf67c9c80c100ce6901db9c8", + "size": 54485, + "subdir": "linux-64", + "timestamp": 1608756127608, + "version": "21.7.0" + }, + "keyring-21.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d532c6ba65ffe7911a408b32a070c4f", + "name": "keyring", + "sha256": "5147d7886673d419859a4ea7e251c210ed899f77ad2396d15077ba5bd0add7d9", + "size": 53716, + "subdir": "linux-64", + "timestamp": 1608756147645, + "version": "21.7.0" + }, + "keyring-21.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f07e486830217bbf6082f36ff96c17d", + "name": "keyring", + "sha256": "b9320af9907b17bfd0307129b7c8aa0cea2e0232a065f5bd3f6772417f97dbbf", + "size": 53646, + "subdir": "linux-64", + "timestamp": 1608756137553, + "version": "21.7.0" + }, + "keyring-21.8.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e1e90edbfee3dcba48f9574fc4a421e", + "name": "keyring", + "sha256": "3e7ef5a9b854242b489b66c1eb7e8fc36e9d9beaeca3379ad28fafcf1032019f", + "size": 55189, + "subdir": "linux-64", + "timestamp": 1609353679610, + "version": "21.8.0" + }, + "keyring-21.8.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "746ea59a87bc5d8624b6ab168cb227b9", + "name": "keyring", + "sha256": "ff4b7231b6932cdd394caf5538209c5d8924ca843c2834d26a26bee3b0f4c561", + "size": 55201, + "subdir": "linux-64", + "timestamp": 1609353658083, + "version": "21.8.0" + }, + "keyring-21.8.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a4e9c6dcca555bd30df3af3bd2fee55", + "name": "keyring", + "sha256": "3401641382bfc531ab8974e8316decc5d30ceeb40abcdd9d72b8c17640ef7989", + "size": 55346, + "subdir": "linux-64", + "timestamp": 1609353699125, + "version": "21.8.0" + }, + "keyring-21.8.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa2daded0f7bed1ad98f5c3b80df1a2d", + "name": "keyring", + "sha256": "e13bf9e8a534dbe7fdbb4b61317f9fa223fde123df674f07a926535c2dca72f9", + "size": 54393, + "subdir": "linux-64", + "timestamp": 1609353654697, + "version": "21.8.0" + }, + "keyring-22.0.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16890c132f146f5e2c18fb546150bfbc", + "name": "keyring", + "sha256": "b8d5c0cc4e28f2a9550db8d08e4eed7914c661303782cff0611b9da8bca7422d", + "size": 55065, + "subdir": "linux-64", + "timestamp": 1611601981541, + "version": "22.0.0" + }, + "keyring-22.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ae98df5892850dac743bc7e37ce4b1e", + "name": "keyring", + "sha256": "31bd981dc55aceb1f570dc61c3759be39b506a2449d36cbb9a1dae4d0f7f675e", + "size": 54136, + "subdir": "linux-64", + "timestamp": 1611601668373, + "version": "22.0.0" + }, + "keyring-22.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1855025c5ae2aa9d3f7602b87351c25", + "name": "keyring", + "sha256": "73d65c03311bedb64bb9eaf78537cb75a266277b299dfa2e210e6a4f7d841924", + "size": 55193, + "subdir": "linux-64", + "timestamp": 1611601990105, + "version": "22.0.0" + }, + "keyring-22.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bae0ad24218723e4c4a22f3d3823c996", + "name": "keyring", + "sha256": "7eed7a43d49bf1914b67c607f9513c4f41c29416ffda56a9cad669b2918bf078", + "size": 55348, + "subdir": "linux-64", + "timestamp": 1611601982765, + "version": "22.0.0" + }, + "keyring-22.0.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a9e6b25c47d9ffe80a82ca05fce5c21", + "name": "keyring", + "sha256": "3d0d59336b7be76b8bf230ae489f388a0b9790a909026f5ea04a62ba10527eec", + "size": 55244, + "subdir": "linux-64", + "timestamp": 1611778748393, + "version": "22.0.1" + }, + "keyring-22.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13383b3ea45a28367aa350ff0d694339", + "name": "keyring", + "sha256": "f2a14ea90a2dae12b8128c5079584e3c06286c79eb6508055a1d1c728b8de289", + "size": 54444, + "subdir": "linux-64", + "timestamp": 1611778551038, + "version": "22.0.1" + }, + "keyring-22.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e107fb0a589a25027e83d4bb472029a", + "name": "keyring", + "sha256": "1939867b9e10291e00c7eb6468c6e8eb648e0ab8b2683821fdbf1976587dfd89", + "size": 55283, + "subdir": "linux-64", + "timestamp": 1611778758423, + "version": "22.0.1" + }, + "keyring-22.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52128a0f37637543decb6f5adaf4e7c6", + "name": "keyring", + "sha256": "4fbfca8771e044d22d0f9b19a9deb769f81febfa732f60e7b039684bd8df79a3", + "size": 54494, + "subdir": "linux-64", + "timestamp": 1611778747109, + "version": "22.0.1" + }, + "keyring-22.2.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da8836b48112238a56e7e383a4f37c2b", + "name": "keyring", + "sha256": "5001ec0b1219a8cae832927bba3e6246b81a6cf9eb3ed7979d020e7c7c93cefd", + "size": 54469, + "subdir": "linux-64", + "timestamp": 1614363063443, + "version": "22.2.0" + }, + "keyring-22.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d67582d7751032872ce80bd907c5ce61", + "name": "keyring", + "sha256": "2678e0ded72f69888f9413ae5079482764c1fe7f8dc8dad5afedca29545893ac", + "size": 54350, + "subdir": "linux-64", + "timestamp": 1614363359476, + "version": "22.2.0" + }, + "keyring-22.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a74fc52c48d60cc7a2c6d947f342d92", + "name": "keyring", + "sha256": "4c45f26f5f0caf211ee1e02b534b3bff771d48061008d503da63e256c13e75f6", + "size": 55528, + "subdir": "linux-64", + "timestamp": 1614363312639, + "version": "22.2.0" + }, + "keyring-22.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fcb133faff65af9595e65639707834b7", + "name": "keyring", + "sha256": "91a70df6d6f3ef693db39d22fd1c0cc61a46acc707ee24d9ccfe79ab8d3b1fe0", + "size": 55651, + "subdir": "linux-64", + "timestamp": 1614363365136, + "version": "22.2.0" + }, + "keyring-22.3.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e51bad9e2fa7679f3406ee0eb0c1e964", + "name": "keyring", + "sha256": "b09e6b123e7a1de06bade821e3c0589e98a123051d10aa061687d60c523cb0c4", + "size": 55374, + "subdir": "linux-64", + "timestamp": 1614615585935, + "version": "22.3.0" + }, + "keyring-22.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=1", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "972db0f5c522d5c36c74a62984ff8513", + "name": "keyring", + "sha256": "efa0edc7e7fded81c33218ecbc8274e1b727c908e12fbb16881dae4c05938ff9", + "size": 54684, + "subdir": "linux-64", + "timestamp": 1614616787817, + "version": "22.3.0" + }, + "keyring-22.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "04001866e187d4db1dfa2c4c4500a695", + "name": "keyring", + "sha256": "f6d1ab31d3f1c308a50d0347d5e65c002e78592182730516bbea579e43b276c1", + "size": 54685, + "subdir": "linux-64", + "timestamp": 1614616779212, + "version": "22.3.0" + }, + "keyring-22.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eebc8e89a5143f845758a99a33ef6047", + "name": "keyring", + "sha256": "dd37e534758025084f363cb54172fb06fef1a6a0a63bc77ec607906ff1316af9", + "size": 55848, + "subdir": "linux-64", + "timestamp": 1614615940431, + "version": "22.3.0" + }, + "keyring-23.0.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "md5": "4b041cb6e711db43de1e31339dd1664b", + "name": "keyring", + "sha256": "60a4aa024d806274f8ef92825f99ccc451794fe288140a89be8eeb6db170573b", + "size": 54628, + "subdir": "linux-64", + "timestamp": 1621519938758, + "version": "23.0.1" + }, + "keyring-23.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "md5": "8f1c676b6d4e57e7200e5d7aa41ca53f", + "name": "keyring", + "sha256": "4e8a86a8b2c435c7f69436146e11394bad64511f134724bcdfa392a7bfcfa52b", + "size": 55783, + "subdir": "linux-64", + "timestamp": 1621524620349, + "version": "23.0.1" + }, + "keyring-23.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "md5": "908ebe9c6f497d82d36dc96d0c890340", + "name": "keyring", + "sha256": "fbc8a3cc67e1ba8421018b2d65a29b90e24d5985b2ff8ff3f1efb563f648ed4e", + "size": 55059, + "subdir": "linux-64", + "timestamp": 1621524444162, + "version": "23.0.1" + }, + "keyring-23.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "md5": "d8707345a982117c8c9d76570e8d88bd", + "name": "keyring", + "sha256": "792c49190b93d2b667f848816d88718344d4e0de0621ef5586c3d242d28e181f", + "size": 55050, + "subdir": "linux-64", + "timestamp": 1621524620745, + "version": "23.0.1" + }, + "keyring-23.1.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.6,<3.7.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "26f150eb3097da743e7361f8cfac57f5", + "name": "keyring", + "sha256": "428114b8ca8fd899614bb9f4220358004eecf8a42281b93f52f664f4958d341d", + "size": 62182, + "subdir": "linux-64", + "timestamp": 1629312985224, + "version": "23.1.0" + }, + "keyring-23.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9728c6f75cc7a594b77fbc398d0d2508", + "name": "keyring", + "sha256": "e3dfffebb08b43de06d0d948eb664292cb2910c2675e3a121778515cefcc2d6b", + "size": 61571, + "subdir": "linux-64", + "timestamp": 1629321372602, + "version": "23.1.0" + }, + "keyring-23.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58c2cad7616c2d8e1f6667a658e19a66", + "name": "keyring", + "sha256": "27fe0b99968ca3203319f084c752c8e4d92890163a0125f10ea65ea2b98e878a", + "size": 62208, + "subdir": "linux-64", + "timestamp": 1629321588236, + "version": "23.1.0" + }, + "keyring-23.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b47249f58e8c14e39e9480f42512e4cd", + "name": "keyring", + "sha256": "c0d8748b1c941b59258a0c27961a6560afb57501a23a08829f7cab72e68ac7b3", + "size": 61684, + "subdir": "linux-64", + "timestamp": 1629321584007, + "version": "23.1.0" + }, + "keyring-23.13.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=4.11.4", + "jaraco.classes", + "jeepney >=0.4.2", + "python >=3.10,<3.11.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1e68f8918371fbb74af7547af65719c", + "name": "keyring", + "sha256": "83ac7add1cb1bf186e6c443730453f680f7718fa456b3f2b5c9659a13a7ec2a3", + "size": 66482, + "subdir": "linux-64", + "timestamp": 1678999281695, + "version": "23.13.1" + }, + "keyring-23.13.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=4.11.4", + "jaraco.classes", + "jeepney >=0.4.2", + "python >=3.11,<3.12.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a57e31b1cbfccd073b52e6b161181c4", + "name": "keyring", + "sha256": "b903430393cecbf90d366d7f2eb60987a81fcb5c204719e92a91ffa03887439f", + "size": 82167, + "subdir": "linux-64", + "timestamp": 1678999344745, + "version": "23.13.1" + }, + "keyring-23.13.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=4.11.4", + "importlib_resources", + "jaraco.classes", + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e470cf012cff707fdcfb6f6e3b9a21a", + "name": "keyring", + "sha256": "de33a8e90dabb41e4eda42fc400316f9a0da128da6ef96ced8003224c17928c9", + "size": 66252, + "subdir": "linux-64", + "timestamp": 1678999313102, + "version": "23.13.1" + }, + "keyring-23.13.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=4.11.4", + "jaraco.classes", + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0eb90cc269d05afd3b8162d2d7d32e10", + "name": "keyring", + "sha256": "bd3d2f7545730d398399bd6c954efa44b2e5d37a841e5e01c61fc8fb1e79d14f", + "size": 65916, + "subdir": "linux-64", + "timestamp": 1678999249834, + "version": "23.13.1" + }, + "keyring-23.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.10,<3.11.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5af948061d76fa7f95ac402127f7016c", + "name": "keyring", + "sha256": "044e21913bf88812f9824ef30b81e4c241a76a5792c99ddd46fd6c45f19bdb5a", + "size": 56964, + "subdir": "linux-64", + "timestamp": 1640884852850, + "version": "23.4.0" + }, + "keyring-23.4.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.11,<3.12.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "312e481443cdec752516ff9f7731bc7c", + "name": "keyring", + "sha256": "aa022fb39c8962a894753fe3c21e00e5122ee9db1643ea8649c18d67732b2eec", + "size": 71225, + "subdir": "linux-64", + "timestamp": 1676823176179, + "version": "23.4.0" + }, + "keyring-23.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.7,<3.8.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37a2b8240a77cb07262f262f37122518", + "name": "keyring", + "sha256": "f49c257a125afd55cabc4cc90c4589ec3236126b32cc87fb076d784fb061b8f7", + "size": 55153, + "subdir": "linux-64", + "timestamp": 1638531289024, + "version": "23.4.0" + }, + "keyring-23.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.8,<3.9.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "574a3534443e047d446697de75340ef3", + "name": "keyring", + "sha256": "86df525ebd4bfe2473b6a5728b4b3a0064fe8f88ab6400c1ab98a3757ef20ca4", + "size": 55444, + "subdir": "linux-64", + "timestamp": 1638531389937, + "version": "23.4.0" + }, + "keyring-23.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jeepney >=0.4.2", + "python >=3.9,<3.10.0a0", + "secretstorage >=3.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b490525ffdb7a95ea7c8ccb631a06dc", + "name": "keyring", + "sha256": "f7c44cceda921e9afc5d1e5f3135c646805e0882bc0d41cf20a202cedc896712", + "size": 56245, + "subdir": "linux-64", + "timestamp": 1638531384627, + "version": "23.4.0" + }, + "keyrings.alt-2.3-py27he1d4c3b_0.conda": { + "build": "py27he1d4c3b_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0999e739c4ed778af145ca8ff97460c", + "name": "keyrings.alt", + "sha256": "29c5b5f5d61cd99c278b2566cbf4de5de4868fe2e52eefd7081cb18086f6be4f", + "size": 34395, + "subdir": "linux-64", + "timestamp": 1509228222928, + "version": "2.3" + }, + "keyrings.alt-2.3-py35h10e0aba_0.conda": { + "build": "py35h10e0aba_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9077a8e03dd3602e20017ce3881a8319", + "name": "keyrings.alt", + "sha256": "8b4ea2218519c2ff4066e6827fabfdcd601fe931df97700e74bb89dd07b63c17", + "size": 35278, + "subdir": "linux-64", + "timestamp": 1509228223904, + "version": "2.3" + }, + "keyrings.alt-2.3-py36h0f3a8d9_0.conda": { + "build": "py36h0f3a8d9_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "950853f6f27f4dcabd237b2e4cf73a6c", + "name": "keyrings.alt", + "sha256": "23234ec73f271cecc0fee90f136b9860bc5d9620cb2ede5ab7081244b2e65413", + "size": 34840, + "subdir": "linux-64", + "timestamp": 1509228217782, + "version": "2.3" + }, + "keyrings.alt-3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "efdf2ba156202b8e7f9f867045480126", + "name": "keyrings.alt", + "sha256": "4987b072a0e00112ee7df46544ad7ee88d2284e7dd0940f6dab87b8b6f42fc91", + "size": 34915, + "subdir": "linux-64", + "timestamp": 1522789592918, + "version": "3.0" + }, + "keyrings.alt-3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "27083ab486a0ffcf4678764c2b2e6c86", + "name": "keyrings.alt", + "sha256": "e9d2cc6b33a8f81966ea2ee45a97f6efafeaf044a9c24cbd2582f1d77a1f886e", + "size": 35490, + "subdir": "linux-64", + "timestamp": 1522789602128, + "version": "3.0" + }, + "keyrings.alt-3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "82f76bcba71c1df8c21a323673a0764d", + "name": "keyrings.alt", + "sha256": "5683abc448849ffc0fdd1cd0437c3e7ce75c3921d568085b5006fbc3cd57ea7d", + "size": 34806, + "subdir": "linux-64", + "timestamp": 1522789837662, + "version": "3.0" + }, + "keyrings.alt-3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1acce79d0bfcd1f012ea040809265fef", + "name": "keyrings.alt", + "sha256": "687b9caf2278f0763c7204639216fcb4d7cfdd791525929c85c5d9d4cccf2a1c", + "size": 35896, + "subdir": "linux-64", + "timestamp": 1527853790441, + "version": "3.1" + }, + "keyrings.alt-3.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b4a82d0a42d5f3bf7da034a6173825c", + "name": "keyrings.alt", + "sha256": "a9ee658cd465db3abb9c48bd7b740f9e78a7ec05c44fe93ed022c5134e475dd0", + "size": 36648, + "subdir": "linux-64", + "timestamp": 1527853788232, + "version": "3.1" + }, + "keyrings.alt-3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bf882e9dfc3791fdcda304253285a581", + "name": "keyrings.alt", + "sha256": "d16b465bf74d3dc4d04360e65066a3088b5dad4caba5b8b38f2a095fa7234af7", + "size": 36035, + "subdir": "linux-64", + "timestamp": 1527853779429, + "version": "3.1" + }, + "keyrings.alt-3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23b13c9e450198df98ffe1acb7a7ccca", + "name": "keyrings.alt", + "sha256": "e7db7acf38d2931b9d7ce3bd82c4ce8c8aae3746d5d6730d399add93c4da3267", + "size": 36430, + "subdir": "linux-64", + "timestamp": 1530898246487, + "version": "3.1" + }, + "keyrings.alt-3.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6628a5889ad0e7cebd2124154294c4a5", + "name": "keyrings.alt", + "sha256": "9d7cf165134df3f9a7df428fef269096de1069af1081bac29508b4fa5137cd42", + "size": 36028, + "subdir": "linux-64", + "timestamp": 1545123872974, + "version": "3.1.1" + }, + "keyrings.alt-3.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df04c1f484107d188b1f4a9db68fc7ed", + "name": "keyrings.alt", + "sha256": "856406ecf1a90d81401ed7c1d042083909947ef1bef1d0a85e7081ec5e557747", + "size": 36480, + "subdir": "linux-64", + "timestamp": 1545123917800, + "version": "3.1.1" + }, + "keyrings.alt-3.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8153214336ba124a31679029c7b38f20", + "name": "keyrings.alt", + "sha256": "0d16f965709bc22643ea1b86dc902be740458ea8954d054d467ec717f1bc4462", + "size": 36520, + "subdir": "linux-64", + "timestamp": 1545123923662, + "version": "3.1.1" + }, + "keyrings.alt-3.1.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d75155326eee9f33b368bdde1c4af654", + "name": "keyrings.alt", + "sha256": "d705c30330f48ccd6c917f1a6fe438d617e7971a8e3e7c979963402a0116ebb5", + "size": 36844, + "subdir": "linux-64", + "timestamp": 1574235751895, + "version": "3.1.1" + }, + "keyrings.alt-3.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "227ed82c5df2033e3cb45d873d5eef49", + "name": "keyrings.alt", + "sha256": "759c6e1e23d84e5d3bdd7f85dda91b36378d91b5582d3c24bfbd61d98f31aaea", + "size": 53912, + "subdir": "linux-64", + "timestamp": 1592250377450, + "version": "3.4.0" + }, + "keyrings.alt-3.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "36730db340bf637fbc93be52ad5b58ee", + "name": "keyrings.alt", + "sha256": "cefdc4fb6e84044135f78612277b9d51d84afb409ef21d2a3556802c6cff45c2", + "size": 54122, + "subdir": "linux-64", + "timestamp": 1592250376100, + "version": "3.4.0" + }, + "keyrings.alt-3.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "97479991b6132349b37a9d546a9250c0", + "name": "keyrings.alt", + "sha256": "2dd0c42ce782a0158661938ae34d9ada44b3d5769ee2f027af77d789fb295492", + "size": 55228, + "subdir": "linux-64", + "timestamp": 1592250387276, + "version": "3.4.0" + }, + "keyrings.alt-4.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db568b633122d5bfdd34cbbd0b97cd9d", + "name": "keyrings.alt", + "sha256": "d304c2fe36f5137e55e84a4358a17bbbaeba59d4d918107a11a3be73038d7145", + "size": 53364, + "subdir": "linux-64", + "timestamp": 1602262359170, + "version": "4.0.0" + }, + "keyrings.alt-4.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c38289dd29230ed46dbdb9b6d5180b39", + "name": "keyrings.alt", + "sha256": "8ab69c055e050a57a40be207d8caf3d8e05f5c4393312b0a88247a76237cbbbb", + "size": 53122, + "subdir": "linux-64", + "timestamp": 1602262629566, + "version": "4.0.0" + }, + "keyrings.alt-4.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7cba4564421d7a4c8680f73bcc181c2c", + "name": "keyrings.alt", + "sha256": "e1f88ffcf8899cbf5190441c45f2a015c59b61db2acb757db5c4d970f939d794", + "size": 53074, + "subdir": "linux-64", + "timestamp": 1602262619556, + "version": "4.0.0" + }, + "keyrings.alt-4.0.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8eb7b676774248c741fe21c0a7722bd6", + "name": "keyrings.alt", + "sha256": "9a39e995b4534ff751c9afeba62c6d7617f2634660631c2a25f807f582e18322", + "size": 52184, + "subdir": "linux-64", + "timestamp": 1605125191740, + "version": "4.0.1" + }, + "keyrings.alt-4.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "88fee3f25ea501c8295ed1c396a551a8", + "name": "keyrings.alt", + "sha256": "75007bdea88ca0072bb8adf7a88efa3bbbac472ccf2aa159de83668fc53c33e3", + "size": 52206, + "subdir": "linux-64", + "timestamp": 1605125184947, + "version": "4.0.1" + }, + "keyrings.alt-4.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c87f81d4a1b764f61002b3d05eda28d", + "name": "keyrings.alt", + "sha256": "ed439c881a5076900af1e153a5503585a828bf4a93fb564f4e5ca6d280bcd815", + "size": 52649, + "subdir": "linux-64", + "timestamp": 1605125151951, + "version": "4.0.1" + }, + "keyrings.alt-4.0.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3fa9ae868fb406d58f4c36431d5d0e0c", + "name": "keyrings.alt", + "sha256": "60213d080e1d5dc34662bf4b69ac2ff80974b26a12adfa86c3b85f203d008f24", + "size": 34972, + "subdir": "linux-64", + "timestamp": 1608143118150, + "version": "4.0.2" + }, + "keyrings.alt-4.0.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6805ddbc7de8a40c3a0746c356b250aa", + "name": "keyrings.alt", + "sha256": "40b7c45857c2120402a3bf959cae3698d7d10b8527562b06f37ad6e0567543f0", + "size": 35340, + "subdir": "linux-64", + "timestamp": 1608143091241, + "version": "4.0.2" + }, + "keyrings.alt-4.0.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8275bebfb3a2b43c7831bdd2d81da6f4", + "name": "keyrings.alt", + "sha256": "4365ea12c7d2d42cadc0d6113175b12a314048efcc96b2d9e29a383a5ffd3ef2", + "size": 35586, + "subdir": "linux-64", + "timestamp": 1608143133971, + "version": "4.0.2" + }, + "keyrings.alt-4.0.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "169e8b6219a6923e3f5e134ec17737e7", + "name": "keyrings.alt", + "sha256": "4707ad28c0f833fa0a2311967fc7b97900f578df993b68bce37bebcd961f73fc", + "size": 35591, + "subdir": "linux-64", + "timestamp": 1608143126058, + "version": "4.0.2" + }, + "keyrings.alt-4.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1911e0386869ad30d2a7049aa066c2c5", + "name": "keyrings.alt", + "sha256": "9eac98d6f7311c7bb517edbb2f42a83b06ba6492e90607952c86e5dc6681a70c", + "size": 35621, + "subdir": "linux-64", + "timestamp": 1640815261641, + "version": "4.1.0" + }, + "keyrings.alt-4.1.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa9b51160899504f1ba1bb8bce86b8f7", + "name": "keyrings.alt", + "sha256": "3cb4550bdd1af112e440eba6f53fff4e1ae4df9bc136e0fe14adfee640d684dc", + "size": 47244, + "subdir": "linux-64", + "timestamp": 1676853087777, + "version": "4.1.0" + }, + "keyrings.alt-4.1.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66e6f8bb117e9bf0ba998979c21cfe97", + "name": "keyrings.alt", + "sha256": "586345524d35d813f8dcd6bf122bfe3179d828f0fe54f7c3d84c300b1020a358", + "size": 35086, + "subdir": "linux-64", + "timestamp": 1626447616179, + "version": "4.1.0" + }, + "keyrings.alt-4.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1dc4131befe31c15c20867d2863340ac", + "name": "keyrings.alt", + "sha256": "12ee7621b2a3edf0658517ef3a022b0c0e76bf542f77240154bd84874d76a7bb", + "size": 35120, + "subdir": "linux-64", + "timestamp": 1626440755175, + "version": "4.1.0" + }, + "keyrings.alt-4.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "888c983efab5180663ff41a55e4d2d9a", + "name": "keyrings.alt", + "sha256": "662d718679fbfbf35c961f5a4276f2eeb769201f24f72901d4196efddcc421ba", + "size": 35121, + "subdir": "linux-64", + "timestamp": 1626447920493, + "version": "4.1.0" + }, + "keyrings.alt-4.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "keyring", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58911092711964d28ee6c549cf1505eb", + "name": "keyrings.alt", + "sha256": "dc0df7d5140d11c42cd857119552767d535c562eba84850f2700111b768f05df", + "size": 35281, + "subdir": "linux-64", + "timestamp": 1626447933564, + "version": "4.1.0" + }, + "kiwisolver-1.0.0-py27h5923d62_0.conda": { + "build": "py27h5923d62_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9044df8480296661437ef7495aee5d72", + "name": "kiwisolver", + "sha256": "6eb37ce563715a77af32e7417fbf599f08f032048e2618ba95b010cc44d3dacf", + "size": 80410, + "subdir": "linux-64", + "timestamp": 1508261302614, + "version": "1.0.0" + }, + "kiwisolver-1.0.0-py35h49e2766_0.conda": { + "build": "py35h49e2766_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bab23078a840abf5b059b6520fa52877", + "name": "kiwisolver", + "sha256": "f3dfaf6eb388234f639ff93b4acc38c11a17b340c4a4e8c5c31e4544c8b57b88", + "size": 79200, + "subdir": "linux-64", + "timestamp": 1508261290043, + "version": "1.0.0" + }, + "kiwisolver-1.0.0-py36h506f09e_0.conda": { + "build": "py36h506f09e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "75ef3a51ab1601cafbd4acf0c17444e0", + "name": "kiwisolver", + "sha256": "599d838e215687ecf13e6eb7bdc1c8fb1a04a0c89a24dd451d183824808c4b92", + "size": 79632, + "subdir": "linux-64", + "timestamp": 1508261305531, + "version": "1.0.0" + }, + "kiwisolver-1.0.1-py27hc15e7b5_0.conda": { + "build": "py27hc15e7b5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "855d7167f023da3b0b4d7cc4156243fe", + "name": "kiwisolver", + "sha256": "03a2eac5d0bf2ec060e08f46f63ea157997bca021c63a53a3749d2a0f94412a1", + "size": 81155, + "subdir": "linux-64", + "timestamp": 1511805540597, + "version": "1.0.1" + }, + "kiwisolver-1.0.1-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d25a889b9ba6ce1437da2b60914674e8", + "name": "kiwisolver", + "sha256": "b58761da4d24d86b262c4300c0aa99cb260604472c14ebaba83a50768e04cbdf", + "size": 81428, + "subdir": "linux-64", + "timestamp": 1530793196224, + "version": "1.0.1" + }, + "kiwisolver-1.0.1-py35hcb1117a_0.conda": { + "build": "py35hcb1117a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "efdb410c0f794ad4423118ab0cea2b3b", + "name": "kiwisolver", + "sha256": "4c9e30afcb1a85f46e2b6d5e7cddf57399ee1eef9381438fbed4f490db932f30", + "size": 79526, + "subdir": "linux-64", + "timestamp": 1511805509554, + "version": "1.0.1" + }, + "kiwisolver-1.0.1-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e1d37e87e98911fc51f8fa5279a731c4", + "name": "kiwisolver", + "sha256": "db0f09c8e3389da8c385b3f3e4cc94086dfb137a13d93194c44720e726d3a393", + "size": 81136, + "subdir": "linux-64", + "timestamp": 1534955365240, + "version": "1.0.1" + }, + "kiwisolver-1.0.1-py36h764f252_0.conda": { + "build": "py36h764f252_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ee012a618ea2277c667813bdda7b8a14", + "name": "kiwisolver", + "sha256": "74e2d7d858c3b1934542f7cc07aa42676b22992e406ec6d3cae00fb17fcdb2bf", + "size": 79725, + "subdir": "linux-64", + "timestamp": 1511805557717, + "version": "1.0.1" + }, + "kiwisolver-1.0.1-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b36592dd78c386b3c737babbefaf9003", + "name": "kiwisolver", + "sha256": "a311330e33b2c6c4237b416b1247371f84b247ffd50055faa89e51eff314d4de", + "size": 78889, + "subdir": "linux-64", + "timestamp": 1530793238722, + "version": "1.0.1" + }, + "kiwisolver-1.0.1-py37hf484d3e_0.conda": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7ea72a33c4ff78d29ebda022ba76d4a5", + "name": "kiwisolver", + "sha256": "89c32aecf0adb1edaf9d880f8d1984fd64951520aea2a7c9c43eda697806bd35", + "size": 79419, + "subdir": "linux-64", + "timestamp": 1530793280787, + "version": "1.0.1" + }, + "kiwisolver-1.0.1-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f1f1e8fee81f0f6e0d9ad94e66116648", + "name": "kiwisolver", + "sha256": "28ec01f3a9d5890697f356a522e436c1f423363c4a91ece003f324de5cccf2d3", + "size": 87801, + "subdir": "linux-64", + "timestamp": 1573489791599, + "version": "1.0.1" + }, + "kiwisolver-1.1.0-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f4b347cb35de67a3aaaf42ed9b25a85c", + "name": "kiwisolver", + "sha256": "6f86670fddb85af3d2e92ce70bea71ee44c6b7310966c9bb6d5cacf870539818", + "size": 86299, + "subdir": "linux-64", + "timestamp": 1556560918632, + "version": "1.1.0" + }, + "kiwisolver-1.1.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6eb0f6ca9122a166b1e6bdb46407216d", + "name": "kiwisolver", + "sha256": "bf77289aac5f0ae68e9eab1292d8acc9ecd83c02d9e0336f0f7e8dcf38abe922", + "size": 84415, + "subdir": "linux-64", + "timestamp": 1556560942778, + "version": "1.1.0" + }, + "kiwisolver-1.1.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b15fc057b97acb0a5c512a1724fc8a77", + "name": "kiwisolver", + "sha256": "47d1e6bd3e012209cdba5ed1c34eb3248aebbe55e73d1f7501200a5c76c1a9cd", + "size": 84476, + "subdir": "linux-64", + "timestamp": 1556560851628, + "version": "1.1.0" + }, + "kiwisolver-1.2.0-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f332ae5a47b0a8201b9ab2402511ea4e", + "name": "kiwisolver", + "sha256": "a47412e810b46700730e1301cc27227532d00a85fcd787412cde866c0730843e", + "size": 85899, + "subdir": "linux-64", + "timestamp": 1588545733797, + "version": "1.2.0" + }, + "kiwisolver-1.2.0-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c444416678c5999021b8a9a39a609bf6", + "name": "kiwisolver", + "sha256": "a3d166fcd824b386d64a2da155879901a414c877450623d9edb2f88301fd34b8", + "size": 85910, + "subdir": "linux-64", + "timestamp": 1588545730625, + "version": "1.2.0" + }, + "kiwisolver-1.2.0-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "571e4a4bb692f4375e3807f3606bb362", + "name": "kiwisolver", + "sha256": "33ea9139fc179cc8e5d85cc6e8bd8039072103488f9597e6b8b3fafbb45b1f2c", + "size": 85829, + "subdir": "linux-64", + "timestamp": 1588545740960, + "version": "1.2.0" + }, + "kiwisolver-1.3.0-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "503e96fb135e57e10197c57659ba254b", + "name": "kiwisolver", + "sha256": "b72ba68f3ce0e7511c34f2d29f050688c1b1613e76597a55d5774eb7bb5b4459", + "size": 81600, + "subdir": "linux-64", + "timestamp": 1604014622162, + "version": "1.3.0" + }, + "kiwisolver-1.3.0-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50a62f1096e6b1737bd6d6ad2b5920ee", + "name": "kiwisolver", + "sha256": "444827ce63df17dfd9ff2cfa4f0af9a768a4d7fbe81e91c4bb1332e34223d9c7", + "size": 81670, + "subdir": "linux-64", + "timestamp": 1604014595582, + "version": "1.3.0" + }, + "kiwisolver-1.3.0-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1ab1adba2027f09de02d1fbdc7b15ba", + "name": "kiwisolver", + "sha256": "051de2f96ba6bff572eea5b765259ff7bf5e40d5e7032ba2eb7247dc13114eaf", + "size": 81793, + "subdir": "linux-64", + "timestamp": 1604014600301, + "version": "1.3.0" + }, + "kiwisolver-1.3.0-py39h66f3464_0.conda": { + "build": "py39h66f3464_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c0c74cd872b4b57e352318c5195a9fe8", + "name": "kiwisolver", + "sha256": "8f2de5f488edf6e0ec01ae12e4e4d37d1e781e951dd5ebf2b90cdb2d32304575", + "size": 85221, + "subdir": "linux-64", + "timestamp": 1607570912735, + "version": "1.3.0" + }, + "kiwisolver-1.3.1-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d5cd7bf1990e07cd7a117bde668967aa", + "name": "kiwisolver", + "sha256": "95240a74bfa72442a4616a7bc7f766b5faf5a04895444a305b78f60107fa48fb", + "size": 768895, + "subdir": "linux-64", + "timestamp": 1643038906469, + "version": "1.3.1" + }, + "kiwisolver-1.3.1-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0295ac991a681fdb7b60edf03799339c", + "name": "kiwisolver", + "sha256": "61c39517a7c8217a8632c6f757ce7924167af2de2421af7b37dc5a4c8c33aece", + "size": 81674, + "subdir": "linux-64", + "timestamp": 1612282475046, + "version": "1.3.1" + }, + "kiwisolver-1.3.1-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c084270e4b56cfe39f5c3249ac1f9511", + "name": "kiwisolver", + "sha256": "33a15b35744ed4d5c0c2cf560e9d8c6d1e8b96dffc8d1df22093c5ffcd452db7", + "size": 81619, + "subdir": "linux-64", + "timestamp": 1612282488640, + "version": "1.3.1" + }, + "kiwisolver-1.3.1-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "edeba8798b0e099d3e80c1e054302990", + "name": "kiwisolver", + "sha256": "c9a599135c8d79a9fafa3716269e0ca62dda56b6034b1abfc346e2390e80b044", + "size": 82431, + "subdir": "linux-64", + "timestamp": 1612281900774, + "version": "1.3.1" + }, + "kiwisolver-1.3.2-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ebcf28e1dea7d2b0433aa48844746793", + "name": "kiwisolver", + "sha256": "603971c258e2956810da66083dfad4ef1162d18ff22fa9198a61a8ece2e53c47", + "size": 81719, + "subdir": "linux-64", + "timestamp": 1638569980628, + "version": "1.3.2" + }, + "kiwisolver-1.3.2-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "110dea482a589287f78324302f4b1c17", + "name": "kiwisolver", + "sha256": "846fb3e35c82fecab32c1bf0dbbbc00963ff2a55aea8f31f5205c44479cf7d38", + "size": 81598, + "subdir": "linux-64", + "timestamp": 1638570016144, + "version": "1.3.2" + }, + "kiwisolver-1.3.2-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "adf9b91f24ef7b3c4fdd29c6d5758c5d", + "name": "kiwisolver", + "sha256": "edbcee4afa7992190094a663a99afc805c9532745381ba928ed22a10678d571a", + "size": 81552, + "subdir": "linux-64", + "timestamp": 1638569943848, + "version": "1.3.2" + }, + "kiwisolver-1.4.2-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c9aaca83e350716eca3fb4ccb0f2aaf4", + "name": "kiwisolver", + "sha256": "aa41531b00cc2c18a66c3b4f9bdc8aef74e242073575b3ae4b359460527158c9", + "size": 770143, + "subdir": "linux-64", + "timestamp": 1653292125501, + "version": "1.4.2" + }, + "kiwisolver-1.4.2-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f41c4c5abb9e0b7c2d5a91432cf82ec", + "name": "kiwisolver", + "sha256": "11e162bc17f84795f3cc6ae8a497eed99299ec1ddd8f283e75aaf4332cc5c039", + "size": 84881, + "subdir": "linux-64", + "timestamp": 1653292169829, + "version": "1.4.2" + }, + "kiwisolver-1.4.2-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "00e5f5a50b547c8c31d1a559828f3251", + "name": "kiwisolver", + "sha256": "2d6a427df3ce57ddced40c49409354ee6cdb4f7e264b8fc1ff0a9076e5e6eef7", + "size": 84619, + "subdir": "linux-64", + "timestamp": 1653292259825, + "version": "1.4.2" + }, + "kiwisolver-1.4.2-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "92ac85e4525168d4c3ed4ea10d2f132c", + "name": "kiwisolver", + "sha256": "d83df7803b399506d9ff0e29a6c3da96722070f512b7120ab1f98dff18fdde47", + "size": 84597, + "subdir": "linux-64", + "timestamp": 1653292217019, + "version": "1.4.2" + }, + "kiwisolver-1.4.4-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fc0ad9cdbc3d973156fc0832a5e96433", + "name": "kiwisolver", + "sha256": "a2c753bfbde2d0e795220606166e740cb15ff293ec1401eeb86e0540bad1dced", + "size": 78087, + "subdir": "linux-64", + "timestamp": 1672387187154, + "version": "1.4.4" + }, + "kiwisolver-1.4.4-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3152f70874dcc84ba512ff5097e37ab4", + "name": "kiwisolver", + "sha256": "24b4db7a930701a73746f2804220d213c4f137d9df9a94e72ef94855ecd20a2d", + "size": 71564, + "subdir": "linux-64", + "timestamp": 1676827253282, + "version": "1.4.4" + }, + "kiwisolver-1.4.4-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "932b8e944691ebe2526744b84b985409", + "name": "kiwisolver", + "sha256": "b4d8339aef175fafcab1bdde316e14c662fd25856a5706e6f6fdc93ca8b1be98", + "size": 75468, + "subdir": "linux-64", + "timestamp": 1672387263318, + "version": "1.4.4" + }, + "kiwisolver-1.4.4-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7424aa335d22974192800ec19a68486e", + "name": "kiwisolver", + "sha256": "5d0ad8ab21545ffd65e17ca814c3459f0511ee0d8bbfbd28028d5be310666163", + "size": 78112, + "subdir": "linux-64", + "timestamp": 1672387224889, + "version": "1.4.4" + }, + "kiwisolver-1.4.4-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d57aedbfbd054ce57fb3c1e4448828c", + "name": "kiwisolver", + "sha256": "0410b546877514c30cbeaaa49a1e40e867d8a884fd53f6d94d0320351e0021ee", + "size": 78168, + "subdir": "linux-64", + "timestamp": 1672387301020, + "version": "1.4.4" + }, + "knit-0.2.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cb5005c1c6136e4c7cb561d1a96bb433", + "name": "knit", + "sha256": "5b03d13fcbb0ec5a5b00a7d1a3d0c2836caed42032e9ba2fbcf37cde275c2426", + "size": 22835213, + "subdir": "linux-64", + "timestamp": 1522783147701, + "version": "0.2.4" + }, + "knit-0.2.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f2f0f0bb1352d1546390d14a58d2869b", + "name": "knit", + "sha256": "de6ea41c96a0b408cbca1845774a1d953f649a36e0f389354b38d4f5f99ba768", + "size": 22834452, + "subdir": "linux-64", + "timestamp": 1640791279683, + "version": "0.2.4" + }, + "knit-0.2.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.11,<3.12.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6f5226efeefc986dbc7359725f72ac9c", + "name": "knit", + "sha256": "9779b7d443f48b27989f34367ab89512607c0b91fd1f6fcdd428e16d5990ab22", + "size": 22941505, + "subdir": "linux-64", + "timestamp": 1676853106637, + "version": "0.2.4" + }, + "knit-0.2.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2688ab5645b9cf2d95efe12a22a26e6b", + "name": "knit", + "sha256": "c3e458f517d0250dc10b743388ee45a8498bbae38b965e2f36295e1731042527", + "size": 22836077, + "subdir": "linux-64", + "timestamp": 1522783188984, + "version": "0.2.4" + }, + "knit-0.2.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b0eed303c7e1811d19c66fd2d44b3bef", + "name": "knit", + "sha256": "10ff609a6c20db31cf92400b9262299cd3590b933b55717627a10d8ec2c1fd94", + "size": 22835128, + "subdir": "linux-64", + "timestamp": 1522783199614, + "version": "0.2.4" + }, + "knit-0.2.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a1d50277433b2bf8a31a44deb84edb70", + "name": "knit", + "sha256": "79be987ed4422e70059fcae4718f839881d77f1c2a4f51ac825717eb038dc710", + "size": 22838368, + "subdir": "linux-64", + "timestamp": 1614178278500, + "version": "0.2.4" + }, + "knit-0.2.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ffaef8edba932e6aae8a930ef3ef19e5", + "name": "knit", + "sha256": "56cd716f79349e9033a124b3837c2a883e375e517454de81ae000bb157c1ff5f", + "size": 22835016, + "subdir": "linux-64", + "timestamp": 1530898309933, + "version": "0.2.4" + }, + "knit-0.2.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f3d0f49ccfc125cf5756da52a815b936", + "name": "knit", + "sha256": "6536c17489980ad26044d701f04aee4ade66df67d696096912b1197056d3d566", + "size": 22838391, + "subdir": "linux-64", + "timestamp": 1614177918952, + "version": "0.2.4" + }, + "knit-0.2.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f06694aa04791746eb6b007b6ce3320b", + "name": "knit", + "sha256": "2b1ed8eea4676a1fa41af7209d5e1af961b7cfeab3bbe51568109bf758d6943d", + "size": 22837796, + "subdir": "linux-64", + "timestamp": 1574238024798, + "version": "0.2.4" + }, + "knit-0.2.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "91a54506637d9eefa13e5e2da704b72c", + "name": "knit", + "sha256": "9d8f9aa964dbfc349295809ff9ec12ec559cbf0427bcc1270583b5a482b0798a", + "size": 22836256, + "subdir": "linux-64", + "timestamp": 1614178284825, + "version": "0.2.4" + }, + "knit-0.2.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py4j", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "38dcd7c90953d3605643fc93b539ead3", + "name": "knit", + "sha256": "bdc3504d884c4e8e8adc3599699a5f28ebc147642e34ea30ae1b56f84058672a", + "size": 22837796, + "subdir": "linux-64", + "timestamp": 1614178275589, + "version": "0.2.4" + }, + "kombu-4.6.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a6a9c11b30f5f6705083f933370f0f77", + "name": "kombu", + "sha256": "1e0e5d818f0c6cde45e73a9da7619bfdff90fd9a1bc837f7cff69d382fb637ab", + "size": 277208, + "subdir": "linux-64", + "timestamp": 1595344168085, + "version": "4.6.10" + }, + "kombu-4.6.10-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "feed4bae4f0d6fbb4c3ff2d0b2e6fd80", + "name": "kombu", + "sha256": "83a465ad13039a0f974c5002d3457a0ec0b5d1929fdb22211497ef839a72f9d8", + "size": 274092, + "subdir": "linux-64", + "timestamp": 1595349487271, + "version": "4.6.10" + }, + "kombu-4.6.10-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "801f49ca9d8d796193462297c763132c", + "name": "kombu", + "sha256": "d5a84496e4df673f7c1f13862981992bc958c802eb88081d09477a45ec62f4e8", + "size": 280253, + "subdir": "linux-64", + "timestamp": 1595349485445, + "version": "4.6.10" + }, + "kombu-4.6.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d6bfe79fe1494501cf59e2fb0d235631", + "name": "kombu", + "sha256": "413b393b16aedb2982fc789e54febe93487db45b767c5c4cd5e0305060c49863", + "size": 278154, + "subdir": "linux-64", + "timestamp": 1596111263573, + "version": "4.6.11" + }, + "kombu-4.6.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a6ff7969bacc1b79d3a6b6b07e5dd46a", + "name": "kombu", + "sha256": "1f2c8de3efd2e5a9879d05721f972bd246d29898935a1c676eb3898daa28c248", + "size": 274877, + "subdir": "linux-64", + "timestamp": 1596111250326, + "version": "4.6.11" + }, + "kombu-4.6.11-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9bdc14ba78df9cd1bdb7b2b539bc7357", + "name": "kombu", + "sha256": "05160c31112e7fabf31b64e0b3b8d4a106ddb428c7517e8f005f0ff490a69486", + "size": 281150, + "subdir": "linux-64", + "timestamp": 1596111279096, + "version": "4.6.11" + }, + "kombu-4.6.8-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "amqp >=2.5.2,<2.6", + "importlib_metadata >=0.18", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "1fc721b318720cbb1c3edf787ad26a14", + "name": "kombu", + "sha256": "e1de41bcf5c1ee3007042cd935924804bdccf152dff46427682c878f594ac0a5", + "size": 276555, + "subdir": "linux-64", + "timestamp": 1585237611939, + "version": "4.6.8" + }, + "kombu-4.6.8-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "amqp >=2.5.2,<2.6", + "importlib_metadata >=0.18", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7e28a4b659b0465389111001004d5b93", + "name": "kombu", + "sha256": "4d2a392c08abe87eafa0f6021d529c1b026f5454c92f29b40556b20ce58c0d4d", + "size": 276714, + "subdir": "linux-64", + "timestamp": 1585237573034, + "version": "4.6.8" + }, + "kombu-4.6.8-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "amqp >=2.5.2,<2.6", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f102411cd010fc38d73bce222dcb9c41", + "name": "kombu", + "sha256": "a7416e65e453426709ec4f4f7b852083ce5893c76e292e553a750ca85160ad91", + "size": 279081, + "subdir": "linux-64", + "timestamp": 1585237605606, + "version": "4.6.8" + }, + "kombu-5.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "0897cad7ec84dcd8bf262b497df20e05", + "name": "kombu", + "sha256": "5b6682165e522a4df73f1b00ded406bf05bd1bad2c977628efd4317ead12e3fe", + "size": 275428, + "subdir": "linux-64", + "timestamp": 1597347980238, + "version": "5.0.0" + }, + "kombu-5.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "93c80409b31dec0046ad85de7208e86a", + "name": "kombu", + "sha256": "4a53fe7f6192e6a45f3801a6ac8222a4ac9c3d5dfe9912a7fa215210da34498d", + "size": 275713, + "subdir": "linux-64", + "timestamp": 1597347975915, + "version": "5.0.0" + }, + "kombu-5.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ef85fa5abc09a3c1c17b9c5e76ad91a7", + "name": "kombu", + "sha256": "cecd3cd73643826909ae84a87038efca676090327644a444479530146c807692", + "size": 274477, + "subdir": "linux-64", + "timestamp": 1597347985231, + "version": "5.0.0" + }, + "kombu-5.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b8c8f5c1ea8e139903be158823b86154", + "name": "kombu", + "sha256": "51d044e27faec8196d080fd1ef6f365777f80177cc29b0f1b0aa1598df0b8feb", + "size": 272356, + "subdir": "linux-64", + "timestamp": 1598410748986, + "version": "5.0.1" + }, + "kombu-5.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "99af2e89b55d74fcbca488b50a5234f4", + "name": "kombu", + "sha256": "23f3ac083dc61a1d101fd6a1e075a182c8ea9fcadadd75bd77976dcdff703cf0", + "size": 275753, + "subdir": "linux-64", + "timestamp": 1598410746584, + "version": "5.0.1" + }, + "kombu-5.0.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "fe544225e636711206bdb5ba75690d7a", + "name": "kombu", + "sha256": "839e1cd62a84ef11ea74dba543395c6fbc27a3d6671a2b2b962410be1a36a4db", + "size": 274811, + "subdir": "linux-64", + "timestamp": 1598410771722, + "version": "5.0.1" + }, + "kombu-5.0.2-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "amqp >=5.0.0,<6.0.0", + "python >=3.10,<3.11.0a0", + "vine" + ], + "license": "BSD-3-Clause", + "md5": "5c46910151137c8a6495f8e317bc2eff", + "name": "kombu", + "sha256": "87b048a5e70429fa9cedfcdec17b6278451aba045d121132f99d5dde9a1c4aeb", + "size": 277362, + "subdir": "linux-64", + "timestamp": 1642513025526, + "version": "5.0.2" + }, + "kombu-5.0.2-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "amqp >=5.0.0,<6.0.0", + "python >=3.11,<3.12.0a0", + "vine" + ], + "license": "BSD-3-Clause", + "md5": "f13979ecdd2ac57c5cc06099e78cbb85", + "name": "kombu", + "sha256": "eead2c6a8ebfe6455287c7d8d042f444b37f2267d71a6534cef48bb3710a1d51", + "size": 361831, + "subdir": "linux-64", + "timestamp": 1676853132535, + "version": "5.0.2" + }, + "kombu-5.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.6,<3.7.0a0", + "vine <=1.3.0" + ], + "license": "BSD-3-Clause", + "md5": "3b2db7d410537c8934ac6eaed49a8fb1", + "name": "kombu", + "sha256": "7e3cc3a3e9106df75f27112fd19ca1a0baee7cf3ef83d00a1f185965d0db9c8d", + "size": 271102, + "subdir": "linux-64", + "timestamp": 1600557701147, + "version": "5.0.2" + }, + "kombu-5.0.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "amqp >=5.0.0,<6.0.0", + "importlib_metadata >=0.18", + "python >=3.6,<3.7.0a0", + "vine" + ], + "license": "BSD-3-Clause", + "md5": "b186075f05e513c934aebb7114bf5531", + "name": "kombu", + "sha256": "fa33c7e8bbd765ca7238e07e2b5cfaaf9cb45bf96bd583ed37f7ed0f5bb06a32", + "size": 276137, + "subdir": "linux-64", + "timestamp": 1607353541356, + "version": "5.0.2" + }, + "kombu-5.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "importlib_metadata >=0.18", + "python >=3.7,<3.8.0a0", + "vine <=1.3.0" + ], + "license": "BSD-3-Clause", + "md5": "3ee1be0aefd079e47d96cd3364b0c746", + "name": "kombu", + "sha256": "9ae7e3c1192115ccbb2f6a65823918a5530d25cc44175ec4d947cd30c6a8aad1", + "size": 267708, + "subdir": "linux-64", + "timestamp": 1600557697824, + "version": "5.0.2" + }, + "kombu-5.0.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "amqp >=5.0.0,<6.0.0", + "importlib_metadata >=0.18", + "python >=3.7,<3.8.0a0", + "vine" + ], + "license": "BSD-3-Clause", + "md5": "8fd3bc4817a28871b6c400300cc136a1", + "name": "kombu", + "sha256": "d1eb09c3dabc407d155421c2367ab393c9d30035c846c85f2df53bc83ccc7545", + "size": 276120, + "subdir": "linux-64", + "timestamp": 1607353522523, + "version": "5.0.2" + }, + "kombu-5.0.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "amqp >=2.6.0,<2.7", + "python >=3.8,<3.9.0a0", + "vine <=1.3.0" + ], + "license": "BSD-3-Clause", + "md5": "3e340a977347d0b6414713f24e7b2de9", + "name": "kombu", + "sha256": "7155c2d1546597786941bc2c5417cd68c0bb8dafc4b31e7759d66ba15d4bb28c", + "size": 273475, + "subdir": "linux-64", + "timestamp": 1600557698530, + "version": "5.0.2" + }, + "kombu-5.0.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "amqp >=5.0.0,<6.0.0", + "python >=3.8,<3.9.0a0", + "vine" + ], + "license": "BSD-3-Clause", + "md5": "201cfaf11637ae79f50a949f1201d4c9", + "name": "kombu", + "sha256": "e0f637aac05978c0e9c000aed6cb234cb07d95572f69d97cbe5eb55d75e0ef15", + "size": 275252, + "subdir": "linux-64", + "timestamp": 1607353501128, + "version": "5.0.2" + }, + "kombu-5.0.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "amqp >=5.0.0,<6.0.0", + "python >=3.9,<3.10.0a0", + "vine" + ], + "license": "BSD-3-Clause", + "md5": "c20eee397569a022240b2d725259c61b", + "name": "kombu", + "sha256": "2b006bafe02f21978ddba6caafdc828ce84a4314fee781796809519f7c6ace84", + "size": 279119, + "subdir": "linux-64", + "timestamp": 1607353531023, + "version": "5.0.2" + }, + "krb5-1.14.2-h56d4222_4.conda": { + "build": "h56d4222_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2l,<1.0.3a" + ], + "license": "MIT", + "md5": "c20fb4f11eb636d32ea93cc42d0b18f7", + "name": "krb5", + "sha256": "6d3c0fa3b11c00021316f30af83775cea2781cda826453b87de4a9b6e0660c58", + "size": 1271399, + "subdir": "linux-64", + "timestamp": 1509379141731, + "version": "1.14.2" + }, + "krb5-1.14.2-h668a083_3.conda": { + "build": "h668a083_3", + "build_number": 3, + "depends": [ + "libedit", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl 1.0.*", + "tk 8.6.*" + ], + "license": "MIT", + "md5": "eb98c2201453467ee3b0ed0667e2cb81", + "name": "krb5", + "sha256": "29d4d9792157a578fb2b9e450d6eff7d9360723953e99ac8baa39b98d15f8532", + "size": 1271457, + "subdir": "linux-64", + "timestamp": 1505851356735, + "version": "1.14.2" + }, + "krb5-1.14.2-hbabe799_5.conda": { + "build": "hbabe799_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "tk >=8.6.7,<8.7.0a0" + ], + "license": "MIT", + "md5": "ca51ae286c6fcdeed78b4238a1e4fa1b", + "name": "krb5", + "sha256": "ba39926bfd6f77996672fb023ed96599e939358ff5ab759dcb120cc8eb5ca710", + "size": 1271487, + "subdir": "linux-64", + "timestamp": 1510862694694, + "version": "1.14.2" + }, + "krb5-1.14.2-hcc13386_3.conda": { + "build": "hcc13386_3", + "build_number": 3, + "depends": [ + "libedit", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl 1.0.*", + "tk 8.6.*" + ], + "license": "MIT", + "md5": "1bb999edecc80e8a41f875add18279d5", + "name": "krb5", + "sha256": "1af149ab6c5e6457ee4ae6a682d8978c0797a9d9f0246f15147e0689a4d55172", + "size": 1271451, + "subdir": "linux-64", + "timestamp": 1505851248622, + "version": "1.14.2" + }, + "krb5-1.14.2-hcdc1b81_6.conda": { + "build": "hcdc1b81_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "tk >=8.6.7,<8.7.0a0" + ], + "license": "MIT", + "md5": "4e5edc6ee4053a4644ebe596cc3fc674", + "name": "krb5", + "sha256": "3f37a85701dc0e9b874a7f2b7b1bcb25bd43d041aa6de51143ab2b628e599d53", + "size": 1271939, + "subdir": "linux-64", + "timestamp": 1511386521866, + "version": "1.14.2" + }, + "krb5-1.14.2-hd3fe544_3.conda": { + "build": "hd3fe544_3", + "build_number": 3, + "depends": [ + "libedit", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl 1.0.*", + "tk 8.6.*" + ], + "license": "MIT", + "md5": "82e382b6422e1ce746b2227e19cdae4b", + "name": "krb5", + "sha256": "9ea6b79965ebb9c21d65d13c5f052af3bcdbe2e4b0ec3bd786256a81c450699b", + "size": 1271506, + "subdir": "linux-64", + "timestamp": 1505851463876, + "version": "1.14.2" + }, + "krb5-1.16-h3f6afd0_6.conda": { + "build": "h3f6afd0_6", + "build_number": 6, + "depends": [ + "libedit >=3.1,<4.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2n,<1.0.3a", + "tk >=8.6.7,<8.7.0a0" + ], + "license": "MIT", + "md5": "e076e4d8da8d0d24a3c6787398ca9cd2", + "name": "krb5", + "sha256": "a7495d61ae39be4367062f3d2b7f41c35db6b4615b2593dd56390d7d67c3115e", + "size": 1217911, + "subdir": "linux-64", + "timestamp": 1519755691640, + "version": "1.16" + }, + "krb5-1.16.1-h173b8e3_7.conda": { + "build": "h173b8e3_7", + "build_number": 7, + "depends": [ + "libedit >=3.1.20170329,<3.2.0a0", + "libedit >=3.1.20170329,<4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "tk >=8.6.8,<8.7.0a0" + ], + "license": "MIT", + "md5": "732e04dab7b43fc09c4ff84721669004", + "name": "krb5", + "sha256": "dda7feaecd5dd05d69a4ef36e908402ebff9b66c49707eb261e26b451eb223be", + "size": 1302252, + "subdir": "linux-64", + "timestamp": 1540589223793, + "version": "1.16.1" + }, + "krb5-1.16.1-hc83ff2d_6.conda": { + "build": "hc83ff2d_6", + "build_number": 6, + "depends": [ + "libedit >=3.1.20170329,<3.2.0a0", + "libedit >=3.1.20170329,<4.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "tk >=8.6.7,<8.7.0a0" + ], + "license": "MIT", + "md5": "052bde7e2e16d73e08dde2e386fbc2c1", + "name": "krb5", + "sha256": "f4dd51d415ea1e62b371133ca316f4a4242daeddcbe52e96fe7ed091c55e50d6", + "size": 1291794, + "subdir": "linux-64", + "timestamp": 1528259004760, + "version": "1.16.1" + }, + "krb5-1.16.4-h173b8e3_0.conda": { + "build": "h173b8e3_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libedit >=3.1.20181209,<4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "tk >=8.6.8,<8.7.0a0" + ], + "license": "MIT", + "md5": "1dfa16eb997ebe71167392898d2d299a", + "name": "krb5", + "sha256": "f782cfacb254d166a02c4ca12aab9d1e08c0cee16de969c0484f9622938145f6", + "size": 1294191, + "subdir": "linux-64", + "timestamp": 1576515758124, + "version": "1.16.4" + }, + "krb5-1.17.1-h173b8e3_0.conda": { + "build": "h173b8e3_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libedit >=3.1.20181209,<4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "tk >=8.6.8,<8.7.0a0" + ], + "license": "MIT", + "md5": "d1de8847d71a7549b0b1a0b3cc51f8eb", + "name": "krb5", + "sha256": "1c362a64e7b50bc15c4948668c1922c9d9dcda228e36ae33dd0cfca09e13a804", + "size": 1349203, + "subdir": "linux-64", + "timestamp": 1576540393941, + "version": "1.17.1" + }, + "krb5-1.18.2-h173b8e3_0.conda": { + "build": "h173b8e3_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20191231,<3.2.0a0", + "libedit >=3.1.20191231,<4.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a" + ], + "license": "MIT", + "md5": "bdc8a1097a9056bbf908c8d82b1c4d43", + "name": "krb5", + "sha256": "1d26238a48d401fd23657e56a979736dd487f938f20b273f2396bc03f7bd034b", + "size": 1339506, + "subdir": "linux-64", + "timestamp": 1593436520744, + "version": "1.18.2" + }, + "krb5-1.19.1-h3535a68_0.conda": { + "build": "h3535a68_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20191231,<3.2.0a0", + "libedit >=3.1.20191231,<4.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "MIT", + "md5": "4ac288c10656f8bea90843f93bfe1ecc", + "name": "krb5", + "sha256": "94ea78ac3867493548bffb7ce8fd9e1f19e5d2bdd1ebcac7ac040f9ac52c3f13", + "size": 1333589, + "subdir": "linux-64", + "timestamp": 1613679171439, + "version": "1.19.1" + }, + "krb5-1.19.2-hac12032_0.conda": { + "build": "hac12032_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20210216,<3.2.0a0", + "libedit >=3.1.20210216,<4.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "MIT", + "md5": "62a43976b48799377103390c340a3824", + "name": "krb5", + "sha256": "b8bddb4e3cb60400d5d43f020ff8c233f3fe963fe11876967de01f205d6a45e6", + "size": 1281396, + "subdir": "linux-64", + "timestamp": 1627388807149, + "version": "1.19.2" + }, + "krb5-1.19.4-h568e23c_0.conda": { + "build": "h568e23c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20221030,<3.2.0a0", + "libedit >=3.1.20221030,<4.0a0", + "libgcc-ng >=11.2.0", + "openssl >=1.1.1s,<1.1.2a" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "649816c5e24c76bd06e74a0eb671a82e", + "name": "krb5", + "sha256": "edaab210b6679d2874bad7cfda7edd164ddcc0346539cf4676f2457ff68898a9", + "size": 1400003, + "subdir": "linux-64", + "timestamp": 1674242843410, + "version": "1.19.4" + }, + "lame-3.100-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "LGPL", + "md5": "477799f2a31e72dd949fa5c043a409de", + "name": "lame", + "sha256": "50ea348e457eb20b603edc9fad836c5ba5cff58544aa9460349e313bdd5e79f7", + "size": 331108, + "subdir": "linux-64", + "timestamp": 1576633249203, + "version": "3.100" + }, + "lancet-0.9.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "param", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "97ba001e759dcff9d5191d8154d2e6f5", + "name": "lancet", + "sha256": "031f2a40d6c2b82eb102c1240af4f3f405ec6458530b75695f4273d1c9db50ef", + "size": 60766, + "subdir": "linux-64", + "timestamp": 1527884547169, + "version": "0.9.0" + }, + "lancet-0.9.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "param", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50e5aa4f7e5d6e3156259ddb155f6116", + "name": "lancet", + "sha256": "8e1445b8dda93a3e38f31e70c7adeb6e6d9d34f64ac4edd00cf5cc9fd65fbe11", + "size": 64821, + "subdir": "linux-64", + "timestamp": 1640791305113, + "version": "0.9.0" + }, + "lancet-0.9.0-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "param", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7ea69544dc9803527e90f08f68f70506", + "name": "lancet", + "sha256": "9542fa9cca13634403600c7759ded96df76795e6d0476f8a4bfe244bf8226f4f", + "size": 87164, + "subdir": "linux-64", + "timestamp": 1676853147162, + "version": "0.9.0" + }, + "lancet-0.9.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "param", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3f990ddf698c1b0717b3c40e12c9b9d2", + "name": "lancet", + "sha256": "04c8aa4e4ed2f89e07bc297f56e5d955bed51ceee31026014a6b725fba1b251a", + "size": 62946, + "subdir": "linux-64", + "timestamp": 1527884558254, + "version": "0.9.0" + }, + "lancet-0.9.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0010281385d91017b0bf77f95165e90f", + "name": "lancet", + "sha256": "f6480fd0178389fce31fb94cea9ec180eb15750e393e2a1a684ebabb2e485328", + "size": 62420, + "subdir": "linux-64", + "timestamp": 1527884653971, + "version": "0.9.0" + }, + "lancet-0.9.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5690c466ea7541443a2897ee6833076d", + "name": "lancet", + "sha256": "ae5841c53e14e5e82c1baab3d2ca27674754b3aa0dee47c79c0b00369cffe555", + "size": 63904, + "subdir": "linux-64", + "timestamp": 1632881051312, + "version": "0.9.0" + }, + "lancet-0.9.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "param", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4cdd5b57756ab1faa74e05febb745f79", + "name": "lancet", + "sha256": "53d011a0d786daaec820258f2f2618441b59e78e95e2626ce2b6bedc3657ea35", + "size": 64214, + "subdir": "linux-64", + "timestamp": 1632891463158, + "version": "0.9.0" + }, + "lancet-0.9.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "param", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1efdb68ebbb1432b1a91a0eec52714c0", + "name": "lancet", + "sha256": "598c9dff28160b3516a9b34331bd117e8b3a79d32241d32dd4d16ecbb84ef89f", + "size": 63907, + "subdir": "linux-64", + "timestamp": 1632891453725, + "version": "0.9.0" + }, + "lancet-0.9.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "param", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "79093f1e5537a72ead8ab8ebb1a544e1", + "name": "lancet", + "sha256": "893e3583b34b16bddeb4241ee2ddcc1aa3170d7dc5800d943ef562201938bdcd", + "size": 64549, + "subdir": "linux-64", + "timestamp": 1632891463960, + "version": "0.9.0" + }, + "lark-1.1.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "js2py", + "python >=3.10,<3.11.0a0", + "regex" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "905fb5ee290ecbe0879513ab286cde59", + "name": "lark", + "sha256": "42aaa969fea5cb45788976e454b4f6a295634671ede1414c12ca2a565ac7a9be", + "size": 176071, + "subdir": "linux-64", + "timestamp": 1663951822673, + "version": "1.1.2" + }, + "lark-1.1.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "js2py", + "python >=3.11,<3.12.0a0", + "regex" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df14f47e7f5582597cdaca92bc109f0d", + "name": "lark", + "sha256": "1789d83a5aa708cf4a5741bc3a66aabd9592f99d94538c92f7620d01a5516b16", + "size": 243737, + "subdir": "linux-64", + "timestamp": 1679340099904, + "version": "1.1.2" + }, + "lark-1.1.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "js2py", + "python >=3.7,<3.8.0a0", + "regex" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4d38d70a6c4c0a710874a575071ed5f", + "name": "lark", + "sha256": "bfacc5840d08d6a7a38afce2624f29018d98895e798bed64013aa0054e011738", + "size": 173622, + "subdir": "linux-64", + "timestamp": 1663951780421, + "version": "1.1.2" + }, + "lark-1.1.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "js2py", + "python >=3.8,<3.9.0a0", + "regex" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd3a8bee0533a15951dd4fd39015d6be", + "name": "lark", + "sha256": "bd532c13a39c35771dfec560916434aa9cb9ceca71d53d1a1d82144261912223", + "size": 174189, + "subdir": "linux-64", + "timestamp": 1663951752058, + "version": "1.1.2" + }, + "lark-1.1.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "js2py", + "python >=3.9,<3.10.0a0", + "regex" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4902422cf7f72745908c298db56b3a03", + "name": "lark", + "sha256": "3bb7563752685daa879def1fb2030f991f11fd21d97cf42c2a0d1e426e4744ec", + "size": 173714, + "subdir": "linux-64", + "timestamp": 1663951852208, + "version": "1.1.2" + }, + "lazy-object-proxy-1.3.1-py27h14c3975_2.conda": { + "build": "py27h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "2629b1dcb9c1475ef333346c2f35dc5d", + "name": "lazy-object-proxy", + "sha256": "0ff5656dd0e36ae7e27e5409703e9253bafed53ee248892f58aaf6325f907f8d", + "size": 29882, + "subdir": "linux-64", + "timestamp": 1530737934236, + "version": "1.3.1" + }, + "lazy-object-proxy-1.3.1-py27h682c727_0.conda": { + "build": "py27h682c727_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "bf7607b6da8023b8424c6942512680c0", + "name": "lazy-object-proxy", + "sha256": "00ee0dfe77cd0fb03b61a3b19d4c968f4e39777991451e804c171f870b3fbb8b", + "size": 29765, + "subdir": "linux-64", + "timestamp": 1505693814804, + "version": "1.3.1" + }, + "lazy-object-proxy-1.3.1-py35h14c3975_2.conda": { + "build": "py35h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "d9557ead0ce57edfeb3d4873389257a0", + "name": "lazy-object-proxy", + "sha256": "70df7bdec8bd02dc9e163f91eb52b12867ddba948b1bd99a92ba225939f6ea39", + "size": 30177, + "subdir": "linux-64", + "timestamp": 1534352853265, + "version": "1.3.1" + }, + "lazy-object-proxy-1.3.1-py35h4c720c6_0.conda": { + "build": "py35h4c720c6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "58cffdf6581ddeef3e734867feedb8f5", + "name": "lazy-object-proxy", + "sha256": "27dd7062dd1f9dc1673ae987bca2f488205a0607c58867114bfd3fdac857d5d7", + "size": 29611, + "subdir": "linux-64", + "timestamp": 1505693829994, + "version": "1.3.1" + }, + "lazy-object-proxy-1.3.1-py36h10fcdad_0.conda": { + "build": "py36h10fcdad_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "753a97b88d766b8fe1c28c23271d7833", + "name": "lazy-object-proxy", + "sha256": "5532adc10dd742ffe86d8a5614ab40451d5710dbad358afc2518898aa32b7d17", + "size": 29420, + "subdir": "linux-64", + "timestamp": 1505693845469, + "version": "1.3.1" + }, + "lazy-object-proxy-1.3.1-py36h14c3975_2.conda": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "6090ea9ee38223baf5e4a06470f716ae", + "name": "lazy-object-proxy", + "sha256": "bfcaefaa6d611f11050c7d6c2407e7e9d09f05277fd7fa05cdfb2bc6df11e99d", + "size": 29609, + "subdir": "linux-64", + "timestamp": 1530737911582, + "version": "1.3.1" + }, + "lazy-object-proxy-1.3.1-py37h14c3975_2.conda": { + "build": "py37h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "9f8a31db05a133fb179f6edc1cb7eac7", + "name": "lazy-object-proxy", + "sha256": "e08109c3017b7eea763562306b5a1b0aee9ce6f7b115df1dfeea9a98f401b18e", + "size": 29686, + "subdir": "linux-64", + "timestamp": 1530737956788, + "version": "1.3.1" + }, + "lazy-object-proxy-1.4.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "53d8f6f05a843aae964765dc088f70be", + "name": "lazy-object-proxy", + "sha256": "4770778e357f7e2df001dd11b9da57d816620ec8907b632826d7b4d97a55d93f", + "size": 33376, + "subdir": "linux-64", + "timestamp": 1557506321762, + "version": "1.4.0" + }, + "lazy-object-proxy-1.4.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "f16cb9364e06cad4ec3a27fd9c14cf41", + "name": "lazy-object-proxy", + "sha256": "3f49d230344523f8c8e802083fb42d65a8d63359a7d88e5588438e7d74579b71", + "size": 33680, + "subdir": "linux-64", + "timestamp": 1557506389660, + "version": "1.4.0" + }, + "lazy-object-proxy-1.4.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "1fc740ce1e0d0eeb0f000f7651817068", + "name": "lazy-object-proxy", + "sha256": "b2a72d78e86888025af8d2d1b72b5c50708d11e7bc819f79a524e29232c90920", + "size": 33647, + "subdir": "linux-64", + "timestamp": 1557506322044, + "version": "1.4.0" + }, + "lazy-object-proxy-1.4.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "4334015f8f01760e6029271c01bb06ad", + "name": "lazy-object-proxy", + "sha256": "d46191ed03b9df85b96adab148b79cf57238d25d6c0b42247120aab16ddbbb73", + "size": 30069, + "subdir": "linux-64", + "timestamp": 1558026953991, + "version": "1.4.1" + }, + "lazy-object-proxy-1.4.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "f497050dc1ceeada2d8afa07e268484a", + "name": "lazy-object-proxy", + "sha256": "4868005ea8fe1f5a7f135775a4618d637165785e52d5ebd7b2e8965898ea37f8", + "size": 29928, + "subdir": "linux-64", + "timestamp": 1558027042190, + "version": "1.4.1" + }, + "lazy-object-proxy-1.4.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "c4a658dcdd2b316d8e1dd9d67cfb6239", + "name": "lazy-object-proxy", + "sha256": "7af0a4bd16f1decf88c3f90709fba775d781b3c56e3272ff10e274badc70c8b3", + "size": 30557, + "subdir": "linux-64", + "timestamp": 1558027023549, + "version": "1.4.1" + }, + "lazy-object-proxy-1.4.2-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "4e673946eb986741d484025e4a7fa2e8", + "name": "lazy-object-proxy", + "sha256": "1e8343496343f50b6c39384cb6e40b614dc7d604064829d7332dcff1ad00fd52", + "size": 29166, + "subdir": "linux-64", + "timestamp": 1566571436953, + "version": "1.4.2" + }, + "lazy-object-proxy-1.4.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "65b55b8de29b7e789d646eda7ca31927", + "name": "lazy-object-proxy", + "sha256": "9c48ebe400ac2fa502ec902c197d668aa3d788453868e913d7edaa49bc2b934a", + "size": 29441, + "subdir": "linux-64", + "timestamp": 1566571428047, + "version": "1.4.2" + }, + "lazy-object-proxy-1.4.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "31144fb6349f4dccf5275bb1afeb8855", + "name": "lazy-object-proxy", + "sha256": "b30923369863ec6f7491071e1e5ea6ebc2da90f9baf1a7f1c85da799adfdc377", + "size": 29823, + "subdir": "linux-64", + "timestamp": 1566571398106, + "version": "1.4.2" + }, + "lazy-object-proxy-1.4.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "1e9b71c3dfa965426cd857d53ea7761c", + "name": "lazy-object-proxy", + "sha256": "60f95a66801f63f3c3977683762071f88154f5dd55e11fd06ce4d17847a11005", + "size": 34250, + "subdir": "linux-64", + "timestamp": 1573489820587, + "version": "1.4.2" + }, + "lazy-object-proxy-1.4.3-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "4868580e7bd1d465546ba2ae4e36ffc9", + "name": "lazy-object-proxy", + "sha256": "32a8a95d10d0ed33651931c7ccb624e36528dbb1200a7ef10d7dc10b8b69fabc", + "size": 29783, + "subdir": "linux-64", + "timestamp": 1573080326770, + "version": "1.4.3" + }, + "lazy-object-proxy-1.4.3-py36h27cfd23_2.conda": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "eb798e76888fc16cc74928389a0b554d", + "name": "lazy-object-proxy", + "sha256": "014f9910f1db1600cacb56ea4c0e22c630f8a52744ef457809182473d105ad34", + "size": 31037, + "subdir": "linux-64", + "timestamp": 1607707373307, + "version": "1.4.3" + }, + "lazy-object-proxy-1.4.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "ad0eeddcc55f592e6428de679a403854", + "name": "lazy-object-proxy", + "sha256": "017ebae36a903ba26c6cb11f3528053754d11737915c55882fc4b564b74074ee", + "size": 30096, + "subdir": "linux-64", + "timestamp": 1573080363921, + "version": "1.4.3" + }, + "lazy-object-proxy-1.4.3-py37h27cfd23_2.conda": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "b340da77d30526f75a2d3a919a589bea", + "name": "lazy-object-proxy", + "sha256": "49940b4692609ad230871494f718c1107321e1732964454f7fa1647f62876671", + "size": 31371, + "subdir": "linux-64", + "timestamp": 1607707358780, + "version": "1.4.3" + }, + "lazy-object-proxy-1.4.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "f8be753236582b7c2779a19c644b76f0", + "name": "lazy-object-proxy", + "sha256": "cdde3a92f5e0c8803329d75fba057254f47e5fa1a3e232d6b22f33e37968289e", + "size": 30122, + "subdir": "linux-64", + "timestamp": 1573080326793, + "version": "1.4.3" + }, + "lazy-object-proxy-1.4.3-py38h27cfd23_2.conda": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "b009271ab399979e696f9efc30945b54", + "name": "lazy-object-proxy", + "sha256": "290fe010fd47bde2aa4041e3fed76c81105e43472ea245c1e0bfc8f5b39827c8", + "size": 31103, + "subdir": "linux-64", + "timestamp": 1607707403067, + "version": "1.4.3" + }, + "lazy-object-proxy-1.4.3-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "063b67dedeaa80a928721015df235430", + "name": "lazy-object-proxy", + "sha256": "c337006613df10edc1f44ed296524b7805b5f9dd0a3e54dcb66b74df74c6e2dd", + "size": 37043, + "subdir": "linux-64", + "timestamp": 1573080360085, + "version": "1.4.3" + }, + "lazy-object-proxy-1.4.3-py39h27cfd23_2.conda": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "md5": "0a972753cabcf68e169d0e11f69d33c7", + "name": "lazy-object-proxy", + "sha256": "d1e9288424fabeec07f26efee892784a804c3a1e51b2fe1d6e7cd7bb47542264", + "size": 31385, + "subdir": "linux-64", + "timestamp": 1607707375743, + "version": "1.4.3" + }, + "lazy-object-proxy-1.5.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "f21fe8c7b90a9fe779e4d87a1f3909aa", + "name": "lazy-object-proxy", + "sha256": "3c7463c483b5008c9439abfd4080965f38348fc3541f678f3c700c50e55a883f", + "size": 31840, + "subdir": "linux-64", + "timestamp": 1592328146755, + "version": "1.5.0" + }, + "lazy-object-proxy-1.5.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "bd84bcb1639b63cbc57631a29263268b", + "name": "lazy-object-proxy", + "sha256": "e0a2c907f8db26d4250e1060e644ae51d457f7fc9d21213122187eeb5573e53d", + "size": 32001, + "subdir": "linux-64", + "timestamp": 1592328160498, + "version": "1.5.0" + }, + "lazy-object-proxy-1.5.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "084eed34c5d0186c19cb398faf50abb4", + "name": "lazy-object-proxy", + "sha256": "08debf33b29fdd7a628e16ccded9d6b44a37a938b1d709b3d0b6f6b0497f2392", + "size": 32345, + "subdir": "linux-64", + "timestamp": 1592328133378, + "version": "1.5.0" + }, + "lazy-object-proxy-1.5.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "6abfbd2aacd4dd87995a7a33e756933a", + "name": "lazy-object-proxy", + "sha256": "24f543418131f7bcc3bf31bf68c41804efc8b1aae147619454061738181a074d", + "size": 32029, + "subdir": "linux-64", + "timestamp": 1597442141426, + "version": "1.5.1" + }, + "lazy-object-proxy-1.5.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "b8327c2a6d4b1060aa52a6c65ee89394", + "name": "lazy-object-proxy", + "sha256": "9f00424d56b82d6d14172fa26c80050f2f2306fe5085b3914ec3d5b2da115377", + "size": 31992, + "subdir": "linux-64", + "timestamp": 1597442157229, + "version": "1.5.1" + }, + "lazy-object-proxy-1.5.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "ce5456eeac1e65348fc75be5a49b5b8f", + "name": "lazy-object-proxy", + "sha256": "1f4106bdf02495414d6b035c6d64dca6dd06fee977489c75c565ca27d0311ff2", + "size": 32289, + "subdir": "linux-64", + "timestamp": 1597442156985, + "version": "1.5.1" + }, + "lazy-object-proxy-1.5.2-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "8754d7c7268230a43b0f924133d04459", + "name": "lazy-object-proxy", + "sha256": "4c40422a47d622556afed3acd32e61faee55a139f9d2aeba2305798f921ef645", + "size": 28084, + "subdir": "linux-64", + "timestamp": 1606850116253, + "version": "1.5.2" + }, + "lazy-object-proxy-1.5.2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "df9c4ea77e7bac213f656c0e3a15fcdc", + "name": "lazy-object-proxy", + "sha256": "0e88df643298888422a6812ecca639ca0e49795252fd88577bd5605bb0fab298", + "size": 28186, + "subdir": "linux-64", + "timestamp": 1606850081152, + "version": "1.5.2" + }, + "lazy-object-proxy-1.5.2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "478e3bda7b8f7a5b17847c5bedc28bad", + "name": "lazy-object-proxy", + "sha256": "dd2c168ab1e0270bcf1278b0eb7998b3ed2d6088b0f0994f7a4fc03c71e6667e", + "size": 28592, + "subdir": "linux-64", + "timestamp": 1606850097090, + "version": "1.5.2" + }, + "lazy-object-proxy-1.5.2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "md5": "35fee6056a1a4a92b8c46547465e58a0", + "name": "lazy-object-proxy", + "sha256": "f2f3d4ad6f1e030409f954907f1d68d0d3fb2318dd314e57b91ec409f1baa425", + "size": 28482, + "subdir": "linux-64", + "timestamp": 1606850130322, + "version": "1.5.2" + }, + "lazy-object-proxy-1.6.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "md5": "fef18fe5f461fe3b6dd6e410082dea46", + "name": "lazy-object-proxy", + "sha256": "faf3afec34ada0c8fa32340b3de56b7d8d20a89d822f125f196875fe990b1622", + "size": 54399, + "subdir": "linux-64", + "timestamp": 1640791329792, + "version": "1.6.0" + }, + "lazy-object-proxy-1.6.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "md5": "122337ed4666a446dabe8acca6743261", + "name": "lazy-object-proxy", + "sha256": "9af9793be3c9e8001d8ad1db6a0668e20b55c3e6d3d2e8568b861047f86b8bcc", + "size": 35040, + "subdir": "linux-64", + "timestamp": 1676827272418, + "version": "1.6.0" + }, + "lazy-object-proxy-1.6.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "171c534c15e59b17dcb4cbc6cb781509", + "name": "lazy-object-proxy", + "sha256": "b51edb266154bcd42796930416da73370ad9db5875e92e62f4c22b77c78c0c0d", + "size": 30390, + "subdir": "linux-64", + "timestamp": 1616526969119, + "version": "1.6.0" + }, + "lazy-object-proxy-1.6.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "8f35e59e08f110ffb368c78fb8bb3ac7", + "name": "lazy-object-proxy", + "sha256": "e8e6a1555ef64c07c74199319e7c954ff170ceedfac38c795cc405c55d84f74d", + "size": 30577, + "subdir": "linux-64", + "timestamp": 1616529129646, + "version": "1.6.0" + }, + "lazy-object-proxy-1.6.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "2a442f76cc31c225873e27928cca5dd4", + "name": "lazy-object-proxy", + "sha256": "34fd8e6cb90fff4f6fdeb7ef4713856253e1bfe26e22097acc0741aba3a8c71b", + "size": 30777, + "subdir": "linux-64", + "timestamp": 1616526968966, + "version": "1.6.0" + }, + "lazy-object-proxy-1.6.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "md5": "6ec355252c7ccac69ef84165b4d1453e", + "name": "lazy-object-proxy", + "sha256": "4f8fb3bbcfc24d4790cef73f44ff073bafebc993faae4f6530a5ab41e20c9e3b", + "size": 31275, + "subdir": "linux-64", + "timestamp": 1616529071988, + "version": "1.6.0" + }, + "lazy_loader-0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "8dd28774aabc6b7370e29e9b9eabe80b", + "name": "lazy_loader", + "sha256": "468ca3d1e2b54ce793a23c1a9195db129247bd159bcb9e04dc30c1a55d40d8a9", + "size": 17334, + "subdir": "linux-64", + "timestamp": 1679411931777, + "version": "0.1" + }, + "lazy_loader-0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "fe9c8ea8bd071a11f3c79e094b3ada72", + "name": "lazy_loader", + "sha256": "ee48b22dd9d73944009006e6630ead52664420bf4a185021a2fe9d1772e5d49e", + "size": 20136, + "subdir": "linux-64", + "timestamp": 1679411907109, + "version": "0.1" + }, + "lazy_loader-0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "fde984313c02a2b90f231b6cdb905e01", + "name": "lazy_loader", + "sha256": "a60a3f43ae2914079f6803a5d17c72fe17d4eb70772d14c6ff589048a009964a", + "size": 17246, + "subdir": "linux-64", + "timestamp": 1679411979942, + "version": "0.1" + }, + "lazy_loader-0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b492f92ef89754de5853ba227ed3d276", + "name": "lazy_loader", + "sha256": "0158b08371504b1baf7df4aabb05cd98f4c8601f6ec55c0e361537bd219d45a2", + "size": 17245, + "subdir": "linux-64", + "timestamp": 1679411955197, + "version": "0.1" + }, + "lcms2-2.11-h396b838_0.conda": { + "build": "h396b838_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c4eab3aa7783b3c89ff1c2210b63df9", + "name": "lcms2", + "sha256": "184c1fb7fe015304786c5ba339aee187b5e34beb126e79c0f68ac35978f6190f", + "size": 314332, + "subdir": "linux-64", + "timestamp": 1593198336289, + "version": "2.11" + }, + "lcms2-2.12-h3be6417_0.conda": { + "build": "h3be6417_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "719db47afba9f6586eecb5eacac70bff", + "name": "lcms2", + "sha256": "c7fdebc0954fe6d272c2a477a1067dc96ebc36fb43109b33378e0e9c2732a847", + "size": 319025, + "subdir": "linux-64", + "timestamp": 1617648674152, + "version": "2.12" + }, + "ld64-530-h0c34534_25.conda": { + "build": "h0c34534_25", + "build_number": 25, + "constrains": [ + "cctools_linux-64 949.0.1.*", + "cctools 949.0.1.*" + ], + "depends": [ + "ld64_linux-64 530 h3868468_25" + ], + "license": "APSL-2.0", + "license_family": "Other", + "md5": "6d3544e824337a51bd2ff925ff20b73c", + "name": "ld64", + "sha256": "0aa4ebd23849cd4b1a78a78619bfd3f23320909a4b8a9320c02ea3469b458df7", + "size": 15218, + "subdir": "linux-64", + "timestamp": 1662554230436, + "version": "530" + }, + "ld64_linux-64-530-h3868468_25.conda": { + "build": "h3868468_25", + "build_number": 25, + "constrains": [ + "cctools_linux-64 949.0.1.*", + "clang >=14.0.6,<15.0a0", + "cctools 949.0.1.*", + "ld 530.*" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "libuuid >=1.0.3,<2.0a0", + "tapi >=1100.0.11,<1101.0a0" + ], + "license": "APSL-2.0", + "license_family": "Other", + "md5": "4d5a8cbc81c7748cc06b240843a3d315", + "name": "ld64_linux-64", + "sha256": "531e035749d6dce0cd72d4e813671ae21d613ce3baadb136d36fb3a054ad92d7", + "size": 5174518, + "subdir": "linux-64", + "timestamp": 1662554195053, + "version": "530" + }, + "ld_impl_linux-64-2.33.1-h53a641e_7.conda": { + "build": "h53a641e_7", + "build_number": 7, + "depends": [], + "license": "GPL 3", + "md5": "ae7fa9dd2ad15b81ab2ba25fe264bcb0", + "name": "ld_impl_linux-64", + "sha256": "a0c2beae9a4a2b66416dc2964db41cda61fa21dd630db756c183b4bea4e117ad", + "size": 581274, + "subdir": "linux-64", + "timestamp": 1576704246287, + "version": "2.33.1" + }, + "ld_impl_linux-64-2.35.1-h7274673_9.conda": { + "build": "h7274673_9", + "build_number": 9, + "constrains": [ + "binutils_impl_linux-64 2.35.1" + ], + "depends": [], + "license": "GPL-3.0-only", + "md5": "dec20f7c8f9d5f1b293abd97b0f518ed", + "name": "ld_impl_linux-64", + "sha256": "cc5b453d585754bb9d52bac9e2045f32eb0fc43d74ec3eee21e44604cf1a6485", + "size": 600155, + "subdir": "linux-64", + "timestamp": 1622698544714, + "version": "2.35.1" + }, + "ld_impl_linux-64-2.38-h1181459_0.conda": { + "build": "h1181459_0", + "build_number": 0, + "constrains": [ + "binutils_impl_linux-64 2.38" + ], + "depends": [], + "license": "GPL-3.0-only", + "md5": "7a8629f37d6fa713d93aab69e36637ad", + "name": "ld_impl_linux-64", + "sha256": "c2f402a076a23e1362dfa8988dd0e7e88bc6d3c4777b6a04e1a160da7afa3862", + "size": 669576, + "subdir": "linux-64", + "timestamp": 1652588230998, + "version": "2.38" + }, + "ld_impl_linux-64-2.38-h1181459_1.conda": { + "build": "h1181459_1", + "build_number": 1, + "constrains": [ + "binutils_impl_linux-64 2.38" + ], + "depends": [], + "license": "GPL-3.0-only", + "md5": "68eedfd9c06f2b0e6888d8db345b7f5b", + "name": "ld_impl_linux-64", + "sha256": "0c7a6f340f4a9e15cc99b3c7e11f07c7670a9b881161739edd77753e5530fe31", + "size": 669201, + "subdir": "linux-64", + "timestamp": 1652971360657, + "version": "2.38" + }, + "ldap3-2.3-py27hcb53f9d_0.conda": { + "build": "py27hcb53f9d_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "7eb191b27b153084d0f358d82557ab5d", + "name": "ldap3", + "sha256": "77afecf57bffa5114eff492fd1a5a6670ee91966cedbec5a19c8d630e7149348", + "size": 398310, + "subdir": "linux-64", + "timestamp": 1507979328562, + "version": "2.3" + }, + "ldap3-2.3-py35h8e63e30_0.conda": { + "build": "py35h8e63e30_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "81e064f325f0c61aa91882ffca28d848", + "name": "ldap3", + "sha256": "dd199cb8c9588c10694823cdf9014aa815f0acc51d137edb7be7536cedf16f7a", + "size": 420671, + "subdir": "linux-64", + "timestamp": 1507979341514, + "version": "2.3" + }, + "ldap3-2.3-py36h3a9aeb9_0.conda": { + "build": "py36h3a9aeb9_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "683473fbca685977e9b93f037f70be4f", + "name": "ldap3", + "sha256": "dc1dbb307d7b861a1abdf3c7260e70a4cf4fb8fc98eb8215de88c24526d2425c", + "size": 415292, + "subdir": "linux-64", + "timestamp": 1507979337932, + "version": "2.3" + }, + "ldap3-2.4-py27h4f5a97a_0.conda": { + "build": "py27h4f5a97a_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "0ab0651e7450926565632d0992944ba3", + "name": "ldap3", + "sha256": "a9a6ee8c45db988c835f3cd91d5476dab4461f5f41fef383d93033d14e3af951", + "size": 416053, + "subdir": "linux-64", + "timestamp": 1511808749761, + "version": "2.4" + }, + "ldap3-2.4-py35h5cb38fc_0.conda": { + "build": "py35h5cb38fc_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "278d0fe25d8d8ae5e05bdd34554312c3", + "name": "ldap3", + "sha256": "1200d10d4f5e6d4381c3f0540a4cf05ea956bd28a7fe8953dbcbf69314bd94cc", + "size": 403611, + "subdir": "linux-64", + "timestamp": 1511808759856, + "version": "2.4" + }, + "ldap3-2.4-py36hcd36b8f_0.conda": { + "build": "py36hcd36b8f_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "84dbb244d6b5fa43e891252fdf8f5222", + "name": "ldap3", + "sha256": "d0f376c0f23e2d6e8f5393106c9a23a75d05696682a77ad8b00c12a16f8596ab", + "size": 419722, + "subdir": "linux-64", + "timestamp": 1511808759111, + "version": "2.4" + }, + "ldap3-2.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "9bb621a65a1b71f4cfd7fc9c8ec85bdd", + "name": "ldap3", + "sha256": "024fc46b087bcb59fc4dccfe27ced4fb17d6fa8c716edac906ba97a9a90a4cd9", + "size": 417533, + "subdir": "linux-64", + "timestamp": 1520880232097, + "version": "2.4.1" + }, + "ldap3-2.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "38f7d47ac44bfc09d578840e6ed0455b", + "name": "ldap3", + "sha256": "ecc957e10db18da3cba72d3fcfb837c96a8e45aafd727661b8f29a9ad3547641", + "size": 404913, + "subdir": "linux-64", + "timestamp": 1520880264823, + "version": "2.4.1" + }, + "ldap3-2.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "39b4ec3f816c62a98f6f38003f8fbd7e", + "name": "ldap3", + "sha256": "16722d42f0164dc5dbde47dc24b13b7116a14dc46f40e6490e498b2e09ffe73b", + "size": 418034, + "subdir": "linux-64", + "timestamp": 1520880205168, + "version": "2.4.1" + }, + "ldap3-2.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "5e50d49e287fa27355fdd4a8ac8e7677", + "name": "ldap3", + "sha256": "732c53131717763428dbc9eea1402ebe776b6385cb1b32fa06fda67dc6f92314", + "size": 422929, + "subdir": "linux-64", + "timestamp": 1524070577726, + "version": "2.5" + }, + "ldap3-2.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "f26994d386f1655507caf7a1801c3cfd", + "name": "ldap3", + "sha256": "131f042af438c187eae9d6369e3cd352d25baefbfc03f60b84eaba0216c72460", + "size": 410656, + "subdir": "linux-64", + "timestamp": 1524070588227, + "version": "2.5" + }, + "ldap3-2.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "6e0d08a351a6571d3ffefa7006f5cd0c", + "name": "ldap3", + "sha256": "fee15ecd7578157285179866ffebee6eacf0fdf33e28d7ddc67c0151d5a10d5d", + "size": 407369, + "subdir": "linux-64", + "timestamp": 1524070586566, + "version": "2.5" + }, + "ldap3-2.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "7fabb0b4a9691a1e20165279746caf9a", + "name": "ldap3", + "sha256": "a83cc91cb72fbb3883581aacee2b6bcde3ba2b024131f7a86d7c85b39d1a89e9", + "size": 429775, + "subdir": "linux-64", + "timestamp": 1530898361521, + "version": "2.5" + }, + "ldap3-2.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "ce276071621ba25d7969b197f03d1d7d", + "name": "ldap3", + "sha256": "354bc4393c7c2cdac2cc2264ad3e730f32a2453ac34ae0661aec23a6198b89eb", + "size": 431956, + "subdir": "linux-64", + "timestamp": 1535498058044, + "version": "2.5.1" + }, + "ldap3-2.5.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "2ef8d626e8081d9155cd43630cf884e2", + "name": "ldap3", + "sha256": "da4a07dc3381143894927e063cd08631c242477eaa9a3f73eb8e39dbfcbf0b3b", + "size": 433131, + "subdir": "linux-64", + "timestamp": 1535498065371, + "version": "2.5.1" + }, + "ldap3-2.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "455a87e67adb0b7a39b8bd4544e1c271", + "name": "ldap3", + "sha256": "737ab76156ac182a22e921add94062d4213adf55c2c028875d3691b12b66c47f", + "size": 409448, + "subdir": "linux-64", + "timestamp": 1535498057390, + "version": "2.5.1" + }, + "ldap3-2.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.8", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "LGPL", + "md5": "2aa355c2a8c04f190aef4d68becd1a20", + "name": "ldap3", + "sha256": "49cc3622055f42cd66c359c1a0bfe430a2d05aeecbab0e98c3c48926bfb81eb6", + "size": 431043, + "subdir": "linux-64", + "timestamp": 1535498098078, + "version": "2.5.1" + }, + "leather-0.3.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7197c4d46bab678208b2cfca5612ffc7", + "name": "leather", + "sha256": "b65ed3de91a27edf2cac9ca2ca1f3a119d51042ff89cc274c81ec1d4a9b4ffa7", + "size": 42490, + "subdir": "linux-64", + "timestamp": 1530735530860, + "version": "0.3.3" + }, + "leather-0.3.3-py27hb189859_0.conda": { + "build": "py27hb189859_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9462a58a1d9d7f92d2139e2a582e3718", + "name": "leather", + "sha256": "dfce50f8fc1c9976485752cc1805ece8763d1fe31fc265372b13128a125ca5f6", + "size": 42754, + "subdir": "linux-64", + "timestamp": 1508618544519, + "version": "0.3.3" + }, + "leather-0.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5423a29718c89bcf640a789919ec6d1b", + "name": "leather", + "sha256": "b83f5df0e2c58b5952dc0ca26534e1986dba8c4177edea5c6fb375300cdccef2", + "size": 43501, + "subdir": "linux-64", + "timestamp": 1642510498924, + "version": "0.3.3" + }, + "leather-0.3.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "051912c57e2bb090fb25d483d209d2dd", + "name": "leather", + "sha256": "ccc9a0176dde882d8bb4044b23f957dbd081c97d17be86865d7d6e797f91f853", + "size": 42822, + "subdir": "linux-64", + "timestamp": 1534351989580, + "version": "0.3.3" + }, + "leather-0.3.3-py35h0484072_0.conda": { + "build": "py35h0484072_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4ed116b5daa0a1cfaf96d4fd7b48ab0", + "name": "leather", + "sha256": "538d69a36384639bd2f48f188ebb09bd824f58f712873147cde13f4c20224917", + "size": 43678, + "subdir": "linux-64", + "timestamp": 1508618588022, + "version": "0.3.3" + }, + "leather-0.3.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17b0d46ba9a5eff895b78fabf4718b77", + "name": "leather", + "sha256": "c75f680dfb0b5b96a3d75fcfbd930cc4dd0e8a2d962bca522f3b78c42f1cd377", + "size": 42540, + "subdir": "linux-64", + "timestamp": 1530735509476, + "version": "0.3.3" + }, + "leather-0.3.3-py36hdd9ea39_0.conda": { + "build": "py36hdd9ea39_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d208b2c0e5ce8eba4b89e3d35b325bf2", + "name": "leather", + "sha256": "34a6d23aa949629a10d3c04c7bb84606482633167fc34fc0cbd330301784cc73", + "size": 42787, + "subdir": "linux-64", + "timestamp": 1508618584920, + "version": "0.3.3" + }, + "leather-0.3.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0478275d8151c115e07d9775563e5234", + "name": "leather", + "sha256": "22516d7e8227e47cb498c90df54cd425fb5a18b4f39f52f6b890c5f2f1912c4e", + "size": 43040, + "subdir": "linux-64", + "timestamp": 1530735553205, + "version": "0.3.3" + }, + "leather-0.3.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b1d657259b6d2fee415a1ad72b3a57e", + "name": "leather", + "sha256": "5f93e2b89f1981b52d8ef362f54ff4c47f2ce2497e359ed761e7137c5f99bd50", + "size": 43538, + "subdir": "linux-64", + "timestamp": 1573469724170, + "version": "0.3.3" + }, + "leather-0.3.4-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "defee9a1dfb2d64c8e52d077d2927a7f", + "name": "leather", + "sha256": "fd14431543b2a4149e9b37ff94c685d84f1d164fa8a9e4dcc3c9965ba78dd66d", + "size": 49076, + "subdir": "linux-64", + "timestamp": 1674746011099, + "version": "0.3.4" + }, + "leather-0.3.4-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4559f24b1690c403832370ef8e30b7fa", + "name": "leather", + "sha256": "18bf9662711649c4e1eb8543374eac14a4fd6d1d9016fea93487bfd178f0815c", + "size": 58467, + "subdir": "linux-64", + "timestamp": 1676837066920, + "version": "0.3.4" + }, + "leather-0.3.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ba0ab50648eab450e29c5fbe0ac96b2", + "name": "leather", + "sha256": "c2c95109b1db0ed0dbbf775d455bade8756339db0c36e117fbef9096585cd254", + "size": 43698, + "subdir": "linux-64", + "timestamp": 1634292754744, + "version": "0.3.4" + }, + "leather-0.3.4-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fabf10baea01f13d1a62b86afdb1f132", + "name": "leather", + "sha256": "4cd8cd4291e31241a1fa1129b2883cffceeda12f644c8e80c231c5e7659d4774", + "size": 48808, + "subdir": "linux-64", + "timestamp": 1674746036614, + "version": "0.3.4" + }, + "leather-0.3.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87c478e69b14581f9e1d4ed612f658c2", + "name": "leather", + "sha256": "4c6d87cd0fdf816f8ee4db8486552642e8de246d020f5fd96201f0a05e876aa2", + "size": 43436, + "subdir": "linux-64", + "timestamp": 1634292753102, + "version": "0.3.4" + }, + "leather-0.3.4-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3769be05173144fb677439d97bdffff1", + "name": "leather", + "sha256": "f56a02aa77ed600dee8c691aa5db650adb8292609921584509e3f72d2d28d28b", + "size": 48830, + "subdir": "linux-64", + "timestamp": 1674745985446, + "version": "0.3.4" + }, + "leather-0.3.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4a3e9a1d5df91a994aa3299b52248ca2", + "name": "leather", + "sha256": "a67e452fe3f3940a4053c7c57bcb4550733df11d6cbc35ca2f6a14b0b0343d19", + "size": 43709, + "subdir": "linux-64", + "timestamp": 1634292760476, + "version": "0.3.4" + }, + "leather-0.3.4-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "six >=1.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f30182dc0f26f1e72b9d428fbe24d8f6", + "name": "leather", + "sha256": "4af82a80fa4f46eb18302b90537eabe3c45a62a18eefa4ef961d47401f7f70f3", + "size": 48780, + "subdir": "linux-64", + "timestamp": 1674745959938, + "version": "0.3.4" + }, + "leptonica-1.82.0-he027829_0.conda": { + "build": "he027829_0", + "build_number": 0, + "depends": [ + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "openjpeg >=2.3.0,<3.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a002931e406457dc9f0b6a07aa550d20", + "name": "leptonica", + "sha256": "61162ece65a9ed25a0a14e5159d8943e88ff35352b739bbc2dff137ede1072d1", + "size": 1901767, + "subdir": "linux-64", + "timestamp": 1665399843062, + "version": "1.82.0" + }, + "leptonica-1.82.0-he027829_1.conda": { + "build": "he027829_1", + "build_number": 1, + "depends": [ + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libwebp-base", + "openjpeg >=2.3.0,<3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "1af4a4c41eb9a4c5910b07591dcea185", + "name": "leptonica", + "sha256": "500bd38493eb1a69538252639e3062b81df0d98079d14455a8042de83a5f8539", + "size": 2686162, + "subdir": "linux-64", + "timestamp": 1676988421664, + "version": "1.82.0" + }, + "lerc-2.2-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b663a048d442956d1b9a6d90e7d8fd85", + "name": "lerc", + "sha256": "15256b35c34cf1ff7a6c4b5a680d69fbc95b922df508fb0cfc003ac508f6b4a0", + "size": 190489, + "subdir": "linux-64", + "timestamp": 1600373731109, + "version": "2.2" + }, + "lerc-2.2.1-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fbf654aa7b5daf66d80c78c7eb0c18a0", + "name": "lerc", + "sha256": "96f2324f6c00d7a8ee6af8e60a6b104d1b4e0add6f7f8be96e646557d7abaadd", + "size": 189833, + "subdir": "linux-64", + "timestamp": 1609353805386, + "version": "2.2.1" + }, + "lerc-3.0-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b97309770412f10bed8d9448f6f98f87", + "name": "lerc", + "sha256": "e9b84d986a46d22c6a1713b267f98ed3adbd486e423d2be74a3b42416e5b3e60", + "size": 200516, + "subdir": "linux-64", + "timestamp": 1635523146417, + "version": "3.0" + }, + "leveldb-1.20-hf484d3e_1.conda": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "snappy", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD", + "md5": "554f3605ee6c3a7754fa192402e93107", + "name": "leveldb", + "sha256": "88dc0641068948b14054850df2595bf7ad80567dd2a3eeb271ee7355245e4b83", + "size": 259116, + "subdir": "linux-64", + "timestamp": 1512801642355, + "version": "1.20" + }, + "leveldb-1.23-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "feaac156e20db96a81d208bf1dcc7d8d", + "name": "leveldb", + "sha256": "963bf267301b55c4b3c2c3fd7e157146a59e61a7a9582ba2f81612778d6f0310", + "size": 192462, + "subdir": "linux-64", + "timestamp": 1622722453206, + "version": "1.23" + }, + "leveldb-1.23-h6a678d5_2.conda": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "snappy >=1.1.9,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fb44a43f5fc0610e096eea4e050db859", + "name": "leveldb", + "sha256": "05969d554144f1bd91f85b72e87a8f25d73274b523dd1b97c5cb0ac42e5de3fc", + "size": 176764, + "subdir": "linux-64", + "timestamp": 1659773640052, + "version": "1.23" + }, + "libaec-1.0.4-he6710b0_1.conda": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "95e3b23fe7c0108bce3b6826749bb94d", + "name": "libaec", + "sha256": "f3c5042e35d675d1bec54e14d5f6c45fd4147446f8486dfc897daf603c81c8e2", + "size": 32947, + "subdir": "linux-64", + "timestamp": 1593197267510, + "version": "1.0.4" + }, + "libaio-0.3.110-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPLv2.1", + "license_family": "LGPL", + "md5": "2c19dea2ffb0042e74fd7b17cee0a91c", + "name": "libaio", + "sha256": "fc24e171170a1ff0b76baf82f4a2f480fdbc257e0aefe18cf3f3c97d56b39f83", + "size": 20081, + "subdir": "linux-64", + "timestamp": 1525298567034, + "version": "0.3.110" + }, + "libaio-0.3.111-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPLv2.1", + "license_family": "LGPL", + "md5": "0846d6cc6b78f226559553f51daf705a", + "name": "libaio", + "sha256": "6a574da8498899f7d4fdfa7f25099e2920388b9b754642141964f8bda48a31f6", + "size": 20570, + "subdir": "linux-64", + "timestamp": 1527852225975, + "version": "0.3.111" + }, + "libaio-0.3.113-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "bf2f0f0df915a30ef531e26ed2e9c1e5", + "name": "libaio", + "sha256": "98fae4f22671b94a4f6bccbc077b3008a354f9af29834d80ead7fca820fafed5", + "size": 18966, + "subdir": "linux-64", + "timestamp": 1656416114008, + "version": "0.3.113" + }, + "libapr-1.7.0-hf178f73_5.conda": { + "build": "hf178f73_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "58ba618ddb3580c906c48517787d54c4", + "name": "libapr", + "sha256": "c8861d01dd85a2d4150269206c2bfac57bde6f45638d715ac63f680ab889ce39", + "size": 665513, + "subdir": "linux-64", + "timestamp": 1631785188555, + "version": "1.7.0" + }, + "libapriconv-1.2.2-h7f8727e_5.conda": { + "build": "h7f8727e_5", + "build_number": 5, + "depends": [ + "libapr", + "libgcc-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f0d9ac6d38a302b9744bb87a79e790cd", + "name": "libapriconv", + "sha256": "d086d4fd460e3a13b8ae93fb036dd6908823a42d524e79bd9c198b7662baea99", + "size": 878458, + "subdir": "linux-64", + "timestamp": 1631785348398, + "version": "1.2.2" + }, + "libaprutil-1.6.1-hfefca11_5.conda": { + "build": "hfefca11_5", + "build_number": 5, + "depends": [ + "expat >=2.2.10,<3.0a0", + "libapr", + "libgcc-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "570ecc7bcbb958fe583261787de90117", + "name": "libaprutil", + "sha256": "4a585e1eedb70c96fe026cbc93e6a3caf14f154f66c8c0aa75b20ae5b36666f4", + "size": 505109, + "subdir": "linux-64", + "timestamp": 1631785382881, + "version": "1.6.1" + }, + "libarchive-3.3.2-h4a23435_4.conda": { + "build": "h4a23435_4", + "build_number": 4, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "lz4-c >=1.8.0,<1.9.0a0", + "lzo >=2.10,<3.0a0", + "openssl >=1.0.2o,<1.0.3a", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "_low_priority" + ], + "license": "BSD 2-Clause", + "md5": "22f823db475ddf93bcff2464a43fa2e3", + "name": "libarchive", + "sha256": "eb01aa8fd93bbf9dc32d6d208152952c49b8c89dd2024c41e4d3345e957989bc", + "size": 728718, + "subdir": "linux-64", + "timestamp": 1522166972224, + "version": "3.3.2" + }, + "libarchive-3.3.2-h4a23435_5.conda": { + "build": "h4a23435_5", + "build_number": 5, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "lzo >=2.10,<3.0a0", + "openssl >=1.0.2o,<1.0.3a", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "_low_priority" + ], + "license": "BSD 2-Clause", + "md5": "9cbda2b55737a11a674910bd8f20ef7c", + "name": "libarchive", + "sha256": "43b6ac7fd2815e54471dadef08fd8601c87331e0f9457bd53ba77670c0d808f9", + "size": 732072, + "subdir": "linux-64", + "timestamp": 1524615997334, + "version": "3.3.2" + }, + "libarchive-3.3.2-ha7923ee_0.conda": { + "build": "ha7923ee_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "expat", + "expat >=2.2.4,<3.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2l,<1.0.3a", + "_low_priority" + ], + "license": "BSD 2-Clause", + "md5": "4f55735f2c2a04f434d8e759ebb3b5d7", + "name": "libarchive", + "sha256": "c448fd377eb64a61d45d7cdd4dd35f9cc491fc1813b3c8034b720750f24d12ea", + "size": 639978, + "subdir": "linux-64", + "timestamp": 1509635328694, + "version": "3.3.2" + }, + "libarchive-3.3.2-hb43526a_6.conda": { + "build": "hb43526a_6", + "build_number": 6, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "lzo >=2.10,<3.0a0", + "openssl >=1.0.2o,<1.0.3a", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "_low_priority" + ], + "license": "BSD 2-Clause", + "md5": "5c9762b48319f15ef71d96b28ab27465", + "name": "libarchive", + "sha256": "521d5bfd08a6c1c0a2013d0840f10a760dac9dc6f53938ce34b3c51fe75a42e3", + "size": 729694, + "subdir": "linux-64", + "timestamp": 1527041461012, + "version": "3.3.2" + }, + "libarchive-3.3.2-hbf4e9fd_1.conda": { + "build": "hbf4e9fd_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "lz4-c >=1.8.0,<1.9.0a0", + "lzo >=2.10,<3.0a0", + "openssl >=1.0.2m,<1.0.3a", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "_low_priority" + ], + "license": "BSD 2-Clause", + "md5": "5c253525b1492eb582fa179c18a19609", + "name": "libarchive", + "sha256": "b69b5c52801a0827dbe74236e6427c79d6a7620aebb51899605dd2d6d9e17576", + "size": 729240, + "subdir": "linux-64", + "timestamp": 1510141959053, + "version": "3.3.2" + }, + "libarchive-3.3.3-h5d8350f_2.conda": { + "build": "h5d8350f_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "lzo >=2.10,<3.0a0", + "openssl >=1.1.1a,<1.1.2a", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "BSD 2-Clause", + "md5": "4cf3275c3c7701f2664194c6077f0742", + "name": "libarchive", + "sha256": "127f2248d1a0997b99534e69974e0fff012ed25e4d97945e0fa03e1b367da27f", + "size": 742011, + "subdir": "linux-64", + "timestamp": 1540778684214, + "version": "3.3.3" + }, + "libarchive-3.3.3-h5d8350f_4.conda": { + "build": "h5d8350f_4", + "build_number": 4, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "lzo >=2.10,<3.0a0", + "openssl >=1.1.1a,<1.1.2a", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "2d5d20b4abd54a2ea1b2e54349334fbf", + "name": "libarchive", + "sha256": "d36a30d78358aa8cf06dbff28d3b0fe6b6f9691a29fd409ddb0d0c37680a33c8", + "size": 742466, + "subdir": "linux-64", + "timestamp": 1541477533189, + "version": "3.3.3" + }, + "libarchive-3.3.3-h5d8350f_5.conda": { + "build": "h5d8350f_5", + "build_number": 5, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "lzo >=2.10,<3.0a0", + "openssl >=1.1.1a,<1.1.2a", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "0aeb406d903a11ac49a5974ebc0881a1", + "name": "libarchive", + "sha256": "d601bb92f99e946f51e8473c87cfc053d2ec0a20579cc32cf18e8d7763fa62ff", + "size": 742760, + "subdir": "linux-64", + "timestamp": 1544640956053, + "version": "3.3.3" + }, + "libarchive-3.3.3-h7d0bbab_1.conda": { + "build": "h7d0bbab_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "lzo >=2.10,<3.0a0", + "openssl >=1.0.2p,<1.0.3a", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.3,<1.3.4.0a0" + ], + "license": "BSD 2-Clause", + "md5": "0f44d9bb8f07a165dfa32d6cadb54fb1", + "name": "libarchive", + "sha256": "c491a35e69986001c6b0f1f14e40c3d37c3ec61ce2c3403c0792871d623d4ebc", + "size": 742246, + "subdir": "linux-64", + "timestamp": 1537557918416, + "version": "3.3.3" + }, + "libarchive-3.4.2-h5de8990_2.conda": { + "build": "h5de8990_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "openssl >=1.1.1o,<1.1.2a", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "0444df893dbe6df33f71e863f200e165", + "name": "libarchive", + "sha256": "0f7c96c7bfe201db06cff935350ba5e2f55f8a3ee55f8826b41d83e05166d844", + "size": 805572, + "subdir": "linux-64", + "timestamp": 1652979024081, + "version": "3.4.2" + }, + "libarchive-3.4.2-h62408e4_0.conda": { + "build": "h62408e4_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "lz4-c >=1.9.2,<1.10.0a0", + "openssl >=1.1.1f,<1.1.2a", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.4,<1.5.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "da258dddbbcd789bf79b6051cbc228ab", + "name": "libarchive", + "sha256": "d5242e84ed82f74fd5304c8130fdf4574029a753ada78989458edd89826b7aa9", + "size": 815451, + "subdir": "linux-64", + "timestamp": 1587215846741, + "version": "3.4.2" + }, + "libarchive-3.5.2-h5de8990_0.conda": { + "build": "h5de8990_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.14,<2.10.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "openssl >=1.1.1o,<1.1.2a", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "67df1bcd371b25d95a805b34d909db1b", + "name": "libarchive", + "sha256": "fe357b4e8b747b4a0cff2eddf1f47f5318e462607026116c9b81c8dd50f176bd", + "size": 847619, + "subdir": "linux-64", + "timestamp": 1654255326579, + "version": "3.5.2" + }, + "libarchive-3.6.1-hab531cd_0.conda": { + "build": "hab531cd_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "openssl >=1.1.1q,<1.1.2a", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ae2013162e22fe50c3f880290bc8b7ea", + "name": "libarchive", + "sha256": "29b896af81a61ec3609b8f3b692850397f1da1ef45df1dc8c724569130cd319f", + "size": 834418, + "subdir": "linux-64", + "timestamp": 1663062388221, + "version": "3.6.1" + }, + "libarchive-3.6.2-hab531cd_0.conda": { + "build": "hab531cd_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "openssl >=1.1.1s,<1.1.2a", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e9d9120736a96e82bf7a04ac914671e0", + "name": "libarchive", + "sha256": "cfa96cf7d5708393e2a1450ea4879fcae59b2ec2be75568eb7dd96fea97a7813", + "size": 913916, + "subdir": "linux-64", + "timestamp": 1674632192945, + "version": "3.6.2" + }, + "libarchive-3.6.2-hb4bd9a0_1.conda": { + "build": "hb4bd9a0_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "openssl >=1.1.1t,<1.1.2a", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "aa699838b47402b4b5ddc6f14edc047c", + "name": "libarchive", + "sha256": "5eac0beca5147db9df7ff79ba345a12a964382cb46123e32c57f5b4f577ddf08", + "size": 921867, + "subdir": "linux-64", + "timestamp": 1679578141147, + "version": "3.6.2" + }, + "libboost-1.65.1-h4055789_3.conda": { + "build": "h4055789_3", + "build_number": 3, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Boost-1.0", + "md5": "0ec65704cbe793fcb8cf97f6a6d35ed4", + "name": "libboost", + "sha256": "bf026947ed948c92329c4b003d3484f454147dfe64da70916fe7a74a76c4835c", + "size": 12486550, + "subdir": "linux-64", + "timestamp": 1508786567485, + "version": "1.65.1" + }, + "libboost-1.65.1-habcd387_4.conda": { + "build": "habcd387_4", + "build_number": 4, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Boost-1.0", + "md5": "83d9acae72089ae23820266958ba7e8a", + "name": "libboost", + "sha256": "738b7b6eb91f098fa0aba183f995978b6da62765e9b0c6c277f308893f4f0a7c", + "size": 12487946, + "subdir": "linux-64", + "timestamp": 1515095183212, + "version": "1.65.1" + }, + "libboost-1.67.0-h46d08c1_4.conda": { + "build": "h46d08c1_4", + "build_number": 4, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Boost-1.0", + "md5": "311a5e7567f5635050b31451ebdc26b2", + "name": "libboost", + "sha256": "de871692890c372b4be6b69a899a95fc250c7a6b9a2de1a7aae27693e2f4fbe2", + "size": 13628536, + "subdir": "linux-64", + "timestamp": 1530782048345, + "version": "1.67.0" + }, + "libboost-1.71.0-h97c9712_0.conda": { + "build": "h97c9712_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "84f42933afe522d10d569bcb746da7c0", + "name": "libboost", + "sha256": "bf592813828db78cea4eb6873b8543823ee4dd10515c91e1ff98f3a3d3a33639", + "size": 15927988, + "subdir": "linux-64", + "timestamp": 1572610543643, + "version": "1.71.0" + }, + "libboost-1.71.0-haf77d95_1.conda": { + "build": "haf77d95_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.5.0,<1.6.0a0" + ], + "license": "Boost-1.0", + "md5": "2bf9ecc21274f3902b4f8c3d255d4715", + "name": "libboost", + "sha256": "60a9d0ecae99e231009895fc79b21470534cc5bbfa6b4bf3fb675d320b058f2c", + "size": 15953877, + "subdir": "linux-64", + "timestamp": 1642425039425, + "version": "1.71.0" + }, + "libboost-1.73.0-h28710b8_12.conda": { + "build": "h28710b8_12", + "build_number": 12, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "3ef53f540eeaaec8a02fb943a535b3cc", + "name": "libboost", + "sha256": "a50ab136dc48182339fdd96887b9a8c1e4967a0377d4d4ed16bea2538ef63ec3", + "size": 14490914, + "subdir": "linux-64", + "timestamp": 1655879823139, + "version": "1.73.0" + }, + "libboost-1.73.0-h37e3b65_10.conda": { + "build": "h37e3b65_10", + "build_number": 10, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Boost-1.0", + "md5": "581cffd79ef0a113d7c647c8ae69650b", + "name": "libboost", + "sha256": "c0d006b3c16969993125bd6976ef7734f1d561737332266c830a244d3ef4a7e9", + "size": 15670729, + "subdir": "linux-64", + "timestamp": 1601386035154, + "version": "1.73.0" + }, + "libboost-1.73.0-h37e3b65_11.conda": { + "build": "h37e3b65_11", + "build_number": 11, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Boost-1.0", + "md5": "5968de3e2fad3fbf1644d7b711b21abe", + "name": "libboost", + "sha256": "d870dfb306647d12fe332a9d20ee3cea6e01cf5aa639d0fd358578860b9f40c0", + "size": 14586697, + "subdir": "linux-64", + "timestamp": 1601470540575, + "version": "1.73.0" + }, + "libboost-1.73.0-h3ff78a5_11.conda": { + "build": "h3ff78a5_11", + "build_number": 11, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Boost-1.0", + "md5": "ef14cd05b9531bb34097d59c391f8ef2", + "name": "libboost", + "sha256": "bcc4409c6ed27643f13d7246b352c97306e824af1ec27640bfa73015df8fb8c7", + "size": 14585830, + "subdir": "linux-64", + "timestamp": 1611677068430, + "version": "1.73.0" + }, + "libboost-1.73.0-hf484d3e_10.conda": { + "build": "hf484d3e_10", + "build_number": 10, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Boost-1.0", + "md5": "b610e75cd1d5bfe807f4651f42386114", + "name": "libboost", + "sha256": "2068261b9b2544712b09f9b5296cc65a122544d599ef2b57ca965553dace406f", + "size": 15668394, + "subdir": "linux-64", + "timestamp": 1601386770076, + "version": "1.73.0" + }, + "libboost-1.73.0-hf484d3e_11.conda": { + "build": "hf484d3e_11", + "build_number": 11, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Boost-1.0", + "md5": "b7a0c513abde05aff8e14eb2ada0e579", + "name": "libboost", + "sha256": "118954832207b559fbf762a77882e7f4e1a01fbd27498a7e9ea1ae966f755f20", + "size": 14584297, + "subdir": "linux-64", + "timestamp": 1601471289913, + "version": "1.73.0" + }, + "libbrotlicommon-1.0.9-h5eee18b_7.conda": { + "build": "h5eee18b_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "md5": "73357cb8fde4b92707ec575c8d8a7ebc", + "name": "libbrotlicommon", + "sha256": "3c819c1c8125c03f36f22bb766c18fff319f9f8916f441102d53d0eb8cebb03a", + "size": 71765, + "subdir": "linux-64", + "timestamp": 1659616145972, + "version": "1.0.9" + }, + "libbrotlidec-1.0.9-h5eee18b_7.conda": { + "build": "h5eee18b_7", + "build_number": 7, + "depends": [ + "libbrotlicommon 1.0.9 h5eee18b_7", + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "md5": "5c31f3bd570dc4d7d799117c98aad6e3", + "name": "libbrotlidec", + "sha256": "1251c6405edf786520b8c60ac9cbea50961098725f193b5010020a4faf94458d", + "size": 31998, + "subdir": "linux-64", + "timestamp": 1659616154057, + "version": "1.0.9" + }, + "libbrotlienc-1.0.9-h5eee18b_7.conda": { + "build": "h5eee18b_7", + "build_number": 7, + "depends": [ + "libbrotlicommon 1.0.9 h5eee18b_7", + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "md5": "289179174f1216582a949b528d8224af", + "name": "libbrotlienc", + "sha256": "fafc4cd52916e22ae3d7682f133cb0ea5491f78ee5c304cd049d0b81f708d3a5", + "size": 270249, + "subdir": "linux-64", + "timestamp": 1659616162282, + "version": "1.0.9" + }, + "libclang-10.0.1-default_h658b4fb_2.conda": { + "build": "default_h658b4fb_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "edcdfbd0f83a1143a965cccd4596ba84", + "name": "libclang", + "sha256": "51812240702daf969fcb11e036faf842f45d455399571b953e14305a0c2e7876", + "size": 11338947, + "subdir": "linux-64", + "timestamp": 1601486012482, + "version": "10.0.1" + }, + "libclang-10.0.1-default_hb85057a_2.conda": { + "build": "default_hb85057a_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "9e39ee5217327ba25e341c629b642247", + "name": "libclang", + "sha256": "7d54cd9fe799b4fea87052120b529ad1a97f0b10bf21b0b3ad2e7a34b4934c68", + "size": 11337168, + "subdir": "linux-64", + "timestamp": 1601487939823, + "version": "10.0.1" + }, + "libclang-14.0.6-default_hc1a23ef_0.conda": { + "build": "default_hc1a23ef_0", + "build_number": 0, + "depends": [ + "libclang13 14.0.6 default_h31cde19_0", + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "6ae2c8bd2da915707c4d5c1f0514c6d3", + "name": "libclang", + "sha256": "206da8eefe8b0b9a81f37cbeefbb2bd4fc1a812ec53bc4054ab65bd23fa63675", + "size": 131380, + "subdir": "linux-64", + "timestamp": 1661930404826, + "version": "14.0.6" + }, + "libclang-cpp-10.0.1-default_h658b4fb_2.conda": { + "build": "default_h658b4fb_2", + "build_number": 2, + "depends": [ + "libclang-cpp10 10.0.1 default_h658b4fb_2", + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "cbe614926a13013c5b0821940b678e53", + "name": "libclang-cpp", + "sha256": "f5874b7def03ab880d413d59cb5031aaa2ce6d1c0b5a4e4dc3d9f6f9505e26cc", + "size": 13342153, + "subdir": "linux-64", + "timestamp": 1601485964187, + "version": "10.0.1" + }, + "libclang-cpp-10.0.1-default_hb85057a_2.conda": { + "build": "default_hb85057a_2", + "build_number": 2, + "depends": [ + "libclang-cpp10 10.0.1 default_hb85057a_2", + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "88fcdf8f6cae3ce1282f33d4c27be997", + "name": "libclang-cpp", + "sha256": "ba3a966b74a47e3a5be99a5955a1ea1c8c22befc70ddd3983eb91c93bb54bcd9", + "size": 13355873, + "subdir": "linux-64", + "timestamp": 1601487893552, + "version": "10.0.1" + }, + "libclang-cpp-14.0.6-default_hc1a23ef_0.conda": { + "build": "default_hc1a23ef_0", + "build_number": 0, + "depends": [ + "libclang-cpp14 14.0.6 default_hc1a23ef_0", + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "790e71f8f7c01aa5af042c377eec80a8", + "name": "libclang-cpp", + "sha256": "2699d894ce7c7f2a712db32e16a178c3ae4ed0f198a7b52a8bc31f62a9151691", + "size": 131361, + "subdir": "linux-64", + "timestamp": 1661930346313, + "version": "14.0.6" + }, + "libclang-cpp10-10.0.1-default_h658b4fb_2.conda": { + "build": "default_h658b4fb_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "cd2e8d6b865743bc23c2a8cbf815278a", + "name": "libclang-cpp10", + "sha256": "de4d90e73b08b4dd53ed67b8ab43d6e3ddf3e363897cd02a168370d91bde8684", + "size": 13361268, + "subdir": "linux-64", + "timestamp": 1601485857815, + "version": "10.0.1" + }, + "libclang-cpp10-10.0.1-default_hb85057a_2.conda": { + "build": "default_hb85057a_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "b2c120920fc9d5349afe3d65e2c796f5", + "name": "libclang-cpp10", + "sha256": "ff9e2c3e722d3d16992d9bb1d4bb1da006aebe89cdc0077527891d0b85f9d15c", + "size": 13359578, + "subdir": "linux-64", + "timestamp": 1601487815912, + "version": "10.0.1" + }, + "libclang-cpp14-14.0.6-default_hc1a23ef_0.conda": { + "build": "default_hc1a23ef_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "327bb92a2c7f5f555612bfb657b2496c", + "name": "libclang-cpp14", + "sha256": "7540b45c20356b12ab498be747a523ba5f4cd24723a07b58ab54df9ba77905ac", + "size": 16133340, + "subdir": "linux-64", + "timestamp": 1661930294179, + "version": "14.0.6" + }, + "libclang13-14.0.6-default_h31cde19_0.conda": { + "build": "default_h31cde19_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "da914b77bb2dc7e29ae5b608e05411fe", + "name": "libclang13", + "sha256": "48faa2dee2b4c67c8ce76209095decb2e86d2ee43b4562dad221cf9403c6081a", + "size": 9212229, + "subdir": "linux-64", + "timestamp": 1661930380098, + "version": "14.0.6" + }, + "libcrc32c-1.1.1-he6710b0_2.conda": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0b31d3723aa324c856a3d4a835d0179f", + "name": "libcrc32c", + "sha256": "1d8759378802c05f15141f480c23c01746083e4704264103bd8e5e9c67778eb0", + "size": 20579, + "subdir": "linux-64", + "timestamp": 1601305006983, + "version": "1.1.1" + }, + "libcrc32c-1.1.2-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "daf778296b4ada0649ecad5e5e320cd0", + "name": "libcrc32c", + "sha256": "9c24483d1fe1e8f264500acadf593db65c543a956603cec681bfffa64e9729a3", + "size": 20199, + "subdir": "linux-64", + "timestamp": 1666883171505, + "version": "1.1.2" + }, + "libcryptominisat-5.6.6-h0e08187_0.conda": { + "build": "h0e08187_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dac4bd0fe270a9c1a06b924cf80ac4a2", + "name": "libcryptominisat", + "sha256": "b7cd693545a65804be6fb74da22d270d018aaef87d5ea272a3aad6361f773767", + "size": 3871659, + "subdir": "linux-64", + "timestamp": 1548446889535, + "version": "5.6.6" + }, + "libcryptominisat-5.6.6-h9e868ea_1.conda": { + "build": "h9e868ea_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f679c78cdbbf52152d026b865a036f3", + "name": "libcryptominisat", + "sha256": "59d91c34b13c918e70de740fd7a90a909361bfcb3cf3ea7f33e7ad3d74a6ba1e", + "size": 6015229, + "subdir": "linux-64", + "timestamp": 1676725901683, + "version": "5.6.6" + }, + "libcryptominisat-5.6.6-h9e868ea_2.conda": { + "build": "h9e868ea_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3819d64491a59c654913c67b183e1d92", + "name": "libcryptominisat", + "sha256": "3da5218431990635594eda5214f16a0a95764af71f48e6204ba9f0e609caf882", + "size": 6015969, + "subdir": "linux-64", + "timestamp": 1679313384931, + "version": "5.6.6" + }, + "libcryptominisat-5.6.6-hc0fe6c6_0.conda": { + "build": "hc0fe6c6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f35b083d606fd441b13db72fe17722a", + "name": "libcryptominisat", + "sha256": "59e03be95dc50e05478bc7c58d902317a51c59f55e6e71c64e806789184566f9", + "size": 3872470, + "subdir": "linux-64", + "timestamp": 1611760247956, + "version": "5.6.6" + }, + "libcst-0.3.14-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "dataclasses", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab164d8ad5899ab919e88b7e389f4fa9", + "name": "libcst", + "sha256": "5d41d0e4f25382b772a33fbea73d68c4a08834538f462aacf7863de9d5e4d27f", + "size": 662902, + "subdir": "linux-64", + "timestamp": 1606163965155, + "version": "0.3.14" + }, + "libcst-0.3.14-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "100e7a82e41d6edda61385694280f236", + "name": "libcst", + "sha256": "b79e6487e1f8a82d4edec23e5b5016f4a287047ef2ccaa6a88d37c90aebadbdf", + "size": 668186, + "subdir": "linux-64", + "timestamp": 1606163960318, + "version": "0.3.14" + }, + "libcst-0.3.14-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f08cfdf70933c0bbf4e6af5cb08d1bec", + "name": "libcst", + "sha256": "6e105a8565ef2f4c6bf4c92999ac35c5c76723dc590a1c06d60f26e00e9b4b11", + "size": 671801, + "subdir": "linux-64", + "timestamp": 1606163939152, + "version": "0.3.14" + }, + "libcst-0.3.15-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "dataclasses", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a8983ec5e4f8b288d9ec91901038732", + "name": "libcst", + "sha256": "019bd8f0f9798044740603f47042f9247b857391a075a5ccdcc7f22921ac3ce9", + "size": 667228, + "subdir": "linux-64", + "timestamp": 1606861658827, + "version": "0.3.15" + }, + "libcst-0.3.15-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "38ddca753b6e6cd7747c8cefa096f5de", + "name": "libcst", + "sha256": "fb86b7be5f41a08ad0d22c28084d13a6b1bae1cd709de39a33cbaed45cd0a113", + "size": 666803, + "subdir": "linux-64", + "timestamp": 1606861671673, + "version": "0.3.15" + }, + "libcst-0.3.15-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "634bc3bce78f5486919d2a57f7b208be", + "name": "libcst", + "sha256": "a6469512446031fb6cc5381c83d00b1c225d4eab5f9e20b1e6f7af465263b831", + "size": 675356, + "subdir": "linux-64", + "timestamp": 1606861681476, + "version": "0.3.15" + }, + "libcst-0.3.16-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "dataclasses", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd8c8d0ab61b3e68f3c833f8cdf95ee2", + "name": "libcst", + "sha256": "611672070a73664bc790cb23e8a01005c6ef66f5eacba3b87723dddbef51527c", + "size": 663742, + "subdir": "linux-64", + "timestamp": 1608230239373, + "version": "0.3.16" + }, + "libcst-0.3.16-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d7f3cfa2672e87c3875bed9c0656516", + "name": "libcst", + "sha256": "472d493b8a4060c32b51db026dd441dde322168229c55801916013dfbbd2a98a", + "size": 669284, + "subdir": "linux-64", + "timestamp": 1608230221894, + "version": "0.3.16" + }, + "libcst-0.3.16-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87c8f2d16c17d7d944318e7a1a0928fc", + "name": "libcst", + "sha256": "5f8daef90edeecc2fd4d75ac9f471970455679eeba8ba1757ae8d3736627e1ef", + "size": 671922, + "subdir": "linux-64", + "timestamp": 1608230215754, + "version": "0.3.16" + }, + "libcst-0.3.17-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3bb6274198ff3583b16f56a0663b2c8", + "name": "libcst", + "sha256": "97fbb3c61e32704f20e053a9975a8353e7999a58b5d78ec32a10a93032a47605", + "size": 690552, + "subdir": "linux-64", + "timestamp": 1640809502459, + "version": "0.3.17" + }, + "libcst-0.3.17-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8856ca2630f8cf78801ccb54cd28c750", + "name": "libcst", + "sha256": "83f1d388d533523abd32bcd2619cbc8f46ab02b0bf7ce7f05821c7b51da285d8", + "size": 898139, + "subdir": "linux-64", + "timestamp": 1676853181579, + "version": "0.3.17" + }, + "libcst-0.3.17-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "dataclasses", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11fc59cb9bb0ae1115820241fc4b8079", + "name": "libcst", + "sha256": "b778120c8bc9b28448ab98c3014fc6ac0e02b3be9a87da3792bb3744b9a040d6", + "size": 665232, + "subdir": "linux-64", + "timestamp": 1613588862065, + "version": "0.3.17" + }, + "libcst-0.3.17-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ffcef7d014d85afa418f123ef55a748", + "name": "libcst", + "sha256": "eb49b2f8d146857c10fef474bb6cd3dc6100de15c791debba7a51cee2d2a81eb", + "size": 670014, + "subdir": "linux-64", + "timestamp": 1613588869467, + "version": "0.3.17" + }, + "libcst-0.3.17-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "921eea0dab28dfa0ebae7c4900b5dd1d", + "name": "libcst", + "sha256": "a90e95a5f87d3755625e005a90e5358e7e532692a17736c1f9ce48e367596b85", + "size": 679467, + "subdir": "linux-64", + "timestamp": 1613588543593, + "version": "0.3.17" + }, + "libcst-0.3.17-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d7dae4b1cd9bab766233d7c8b8318e8", + "name": "libcst", + "sha256": "5a49e55a37de17fe65cdfe9355f2c7f08b4233a7bb80db3d3e0a6c21fa100bcb", + "size": 673154, + "subdir": "linux-64", + "timestamp": 1613588203703, + "version": "0.3.17" + }, + "libcst-0.3.18-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "dataclasses", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "991bc7085a84eec8da8cb8b6e3b53f19", + "name": "libcst", + "sha256": "0dafe67b726bd07ff72f6f75dc7d23af0ee10ac1b10b06312da99f5815987649", + "size": 671673, + "subdir": "linux-64", + "timestamp": 1617121307699, + "version": "0.3.18" + }, + "libcst-0.3.18-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c61ccba3b53d0c35c3fbf185eeb3c418", + "name": "libcst", + "sha256": "a1b97f167eae4ff2d26261e174f2f5ed45e6181b26174f38254314f65091725c", + "size": 678416, + "subdir": "linux-64", + "timestamp": 1617121309809, + "version": "0.3.18" + }, + "libcst-0.3.18-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2aa58ebe17628468d299a13e54572fb6", + "name": "libcst", + "sha256": "e1a41cae018a2470111a26b89273a2b6acf82529e2dc927c1e37abf34e0ab098", + "size": 681004, + "subdir": "linux-64", + "timestamp": 1617118853335, + "version": "0.3.18" + }, + "libcst-0.3.18-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d39ecb0d1f670ebdde664778f8500ac9", + "name": "libcst", + "sha256": "24161781d450bbddc843273c2ab0fb00e22f80cea59bcb45bf519250dd35c0c9", + "size": 679544, + "subdir": "linux-64", + "timestamp": 1617121313374, + "version": "0.3.18" + }, + "libcst-0.3.19-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "dataclasses", + "python >=3.6,<3.7.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af35dcab777827ba14f5ff061ad6dd5e", + "name": "libcst", + "sha256": "fad02ed1f8121a496f0d7d4058150ee1264d3fd03a8e22bb1df821d6c5a27970", + "size": 680784, + "subdir": "linux-64", + "timestamp": 1620999857101, + "version": "0.3.19" + }, + "libcst-0.3.19-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b25b6907ba723e3b099a77f4e9c91c0a", + "name": "libcst", + "sha256": "ccf619b53fa935eef7ac4ab71a7325cc8ceae970585fcb11b03d8b027edb0b65", + "size": 680470, + "subdir": "linux-64", + "timestamp": 1621000482533, + "version": "0.3.19" + }, + "libcst-0.3.19-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "89592cd17c2f8d320b4a22cd0b60b23b", + "name": "libcst", + "sha256": "e631ecdacba2e1b84f90afb4f30e46cedc6f8bc997d9da22115a937ad1f0fe9d", + "size": 689620, + "subdir": "linux-64", + "timestamp": 1621000490790, + "version": "0.3.19" + }, + "libcst-0.3.19-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pyyaml >=5.2", + "typing_extensions >=3.7.4.2", + "typing_inspect >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb415ef842f86c4991e1240f6d0b368e", + "name": "libcst", + "sha256": "c05174d8eb34b58d41502e34c30d9c55d0c2325fbc034908e0bcc99fec944eb6", + "size": 679614, + "subdir": "linux-64", + "timestamp": 1621000481107, + "version": "0.3.19" + }, + "libcups-2.2.12-h4ff587b_1.conda": { + "build": "h4ff587b_1", + "build_number": 1, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "05b8f3ccc0edfdc76c0f53fd0a2c11ff", + "name": "libcups", + "sha256": "34f88eca53f23407e76c040b6af657fc5702a60a5875b090f9933afa3e634a11", + "size": 6417321, + "subdir": "linux-64", + "timestamp": 1632414655779, + "version": "2.2.12" + }, + "libcups-2.4.2-ha637b67_0.conda": { + "build": "ha637b67_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1q,<1.1.2a", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "42b4ff0f3274958a7789de0fdd1a7550", + "name": "libcups", + "sha256": "f7abc8be37bb1e8c566253e74275ca7a9dae1bb59a1b7bb855a70bb5c9db2e06", + "size": 4615547, + "subdir": "linux-64", + "timestamp": 1665596528843, + "version": "2.4.2" + }, + "libcurl-7.57.0-h1ad7b7a_0.conda": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.0.2n,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "b20c8a8ee9c6e21a3608aaad68899d0f", + "name": "libcurl", + "sha256": "cd30c57e11150ad3b95595b94f6ec06d8bd569d1046a906a329d87eab2b4c37b", + "size": 372475, + "subdir": "linux-64", + "timestamp": 1516812880776, + "version": "7.57.0" + }, + "libcurl-7.58.0-h1ad7b7a_0.conda": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.0.2n,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "525b381ad4f6295f970ce759bf498154", + "name": "libcurl", + "sha256": "32462e58f6ad873c8c9d01d381b9dd3ad89617d0d1fb5eb8228345fa7a3a301a", + "size": 359074, + "subdir": "linux-64", + "timestamp": 1517284610702, + "version": "7.58.0" + }, + "libcurl-7.59.0-h1ad7b7a_0.conda": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.0.2o,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "e73e90f7047c81547ed955d3124b94b2", + "name": "libcurl", + "sha256": "ef84b66e58eedfced225a205044fbc0ace79b7b75ed4b8de462ceecb4ae5c602", + "size": 362024, + "subdir": "linux-64", + "timestamp": 1522272204460, + "version": "7.59.0" + }, + "libcurl-7.60.0-h1ad7b7a_0.conda": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.0.2o,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "3554e648d8cbdf364d1bc76515795248", + "name": "libcurl", + "sha256": "7f24cf01a87a1198b401a0c49c8c28eeaccddb403249bfe2233df1cd0a7a734b", + "size": 367716, + "subdir": "linux-64", + "timestamp": 1527109699454, + "version": "7.60.0" + }, + "libcurl-7.61.0-h1ad7b7a_0.conda": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.0.2o,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "dbf41fdfc3a69f29c726f31115f5cb15", + "name": "libcurl", + "sha256": "30627b1a9e0f703addcaf671ff03f294a36b21871a505329e7daaccc0818e7f2", + "size": 363143, + "subdir": "linux-64", + "timestamp": 1532525678731, + "version": "7.61.0" + }, + "libcurl-7.61.1-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "f316f61bd77115ff0a4502ea2913077c", + "name": "libcurl", + "sha256": "c6691827049af7dc0871bb453747b6b4ae5f39895bab0b9bdace48b7c9a60dfb", + "size": 370263, + "subdir": "linux-64", + "timestamp": 1539968313039, + "version": "7.61.1" + }, + "libcurl-7.61.1-heec0ca6_0.conda": { + "build": "heec0ca6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.0.2p,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "83e73bfea462e4f771d2cb466fb6ec7d", + "name": "libcurl", + "sha256": "8ac1c719945996f8da3b14b6fcd6b1110f202dc706277fbaa0affd25cb055f4d", + "size": 363649, + "subdir": "linux-64", + "timestamp": 1538232666465, + "version": "7.61.1" + }, + "libcurl-7.62.0-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.1.1a,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "0f0b2b6f9efb427a176303d06048ac9a", + "name": "libcurl", + "sha256": "4d9918d639088b7e956977ccdc8cc1a4755b2cc3a8d5b2020de2fbacc58f0091", + "size": 369865, + "subdir": "linux-64", + "timestamp": 1541435347443, + "version": "7.62.0" + }, + "libcurl-7.63.0-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.1.1a,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "82d014ea64eeb15087b18dd8932c0424", + "name": "libcurl", + "sha256": "acb9ba1501e83a8c1b240a9693fb5c0361c62e99c1a961af705aabc4c2e7626b", + "size": 441620, + "subdir": "linux-64", + "timestamp": 1547225793370, + "version": "7.63.0" + }, + "libcurl-7.63.0-h20c2e04_1000.conda": { + "build": "h20c2e04_1000", + "build_number": 1000, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.1.1a,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "47b627d6c8b2e9663782b94a9ea16699", + "name": "libcurl", + "sha256": "8662a6af333048ce7925e993f723aa0b65bdb61b549f4377dde35d46c69b4e9d", + "size": 411840, + "subdir": "linux-64", + "timestamp": 1545106026062, + "version": "7.63.0" + }, + "libcurl-7.64.0-h20c2e04_2.conda": { + "build": "h20c2e04_2", + "build_number": 2, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.0,<2.0a0", + "openssl >=1.1.1b,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "3ea8fb6d487b336a863a2411af272ea2", + "name": "libcurl", + "sha256": "ee802cc5ce603b816b62c9ff6355a575684773557d7efc8ad5017fa82abc6545", + "size": 440672, + "subdir": "linux-64", + "timestamp": 1552411755987, + "version": "7.64.0" + }, + "libcurl-7.64.1-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "openssl >=1.1.1b,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "1c9381471d22e6bf896f759d3e93fd9a", + "name": "libcurl", + "sha256": "7123f9d135e348a808471fedbd12ad08341ba2085d301af893817881386b573b", + "size": 443591, + "subdir": "linux-64", + "timestamp": 1556031956997, + "version": "7.64.1" + }, + "libcurl-7.65.2-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "openssl >=1.1.1c,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "5da2b667e649a067e4256c67e5fdb1d3", + "name": "libcurl", + "sha256": "d74642b585652b6bbc00a08c438ab7aa2ee1c5298fa3a681d722990eb5e69fcc", + "size": 436410, + "subdir": "linux-64", + "timestamp": 1563398718220, + "version": "7.65.2" + }, + "libcurl-7.65.3-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "openssl >=1.1.1c,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "4027c8c0de40be94149da0683b6eb885", + "name": "libcurl", + "sha256": "b293b138443d0a2afafc8543467aeeaa4d4798ba1f1d07b76984672a7a1feaa1", + "size": 440878, + "subdir": "linux-64", + "timestamp": 1566828842344, + "version": "7.65.3" + }, + "libcurl-7.67.0-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "openssl >=1.1.1d,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "1d5415340885d6db9f80c9a0ff10dbb2", + "name": "libcurl", + "sha256": "ff82ff88ab629dabb59ca5fd8e16531d0861d6a0a9ab2ce41a6d36726c656097", + "size": 435811, + "subdir": "linux-64", + "timestamp": 1574273435826, + "version": "7.67.0" + }, + "libcurl-7.68.0-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.17.1,<1.18.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.8.2,<2.0a0", + "openssl >=1.1.1d,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "6db585af4f46640a964d8681b51233dd", + "name": "libcurl", + "sha256": "8f979ee30da222c8f24b4254a4658520386a8741fea8d7b0f45a1b99bef21c63", + "size": 441131, + "subdir": "linux-64", + "timestamp": 1580837341017, + "version": "7.68.0" + }, + "libcurl-7.69.1-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.17.1,<1.18.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1d,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "ff0002442c81432f88280f8bd39731f4", + "name": "libcurl", + "sha256": "9a949414823e66f0bdaea5a9f279942a143c8e68bf0c0a47f22ec09cd0cd40e0", + "size": 441141, + "subdir": "linux-64", + "timestamp": 1584460896818, + "version": "7.69.1" + }, + "libcurl-7.71.0-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1g,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "2ab450eec598126ba05fb9e8efb9094d", + "name": "libcurl", + "sha256": "024ac54d2d2beb0bb3efa11bfe306f0d260da197d8daac383c0acd19ea86da94", + "size": 445656, + "subdir": "linux-64", + "timestamp": 1593438198583, + "version": "7.71.0" + }, + "libcurl-7.71.1-h20c2e04_1.conda": { + "build": "h20c2e04_1", + "build_number": 1, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1g,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "d93429a1f4045317512d7aa126015ea5", + "name": "libcurl", + "sha256": "57b17ce248d5297bef4171fbb5a7ffe87f17788a331632cacd6e37aa0ce476ce", + "size": 312193, + "subdir": "linux-64", + "timestamp": 1594834903124, + "version": "7.71.1" + }, + "libcurl-7.71.1-h303737a_2.conda": { + "build": "h303737a_2", + "build_number": 2, + "depends": [ + "krb5 >=1.19.1,<1.20.0a0", + "libgcc-ng >=7.3.0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1k,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT/X derivate (http://curl.haxx.se/docs/copyright.html)", + "license_family": "MIT", + "md5": "0d12d1341cd5fd6228974bc0881e2caf", + "name": "libcurl", + "sha256": "73aef5f3033bae8b5a5ab7d5c00db06413b9f35138bdad2542ab4960a95c38e8", + "size": 313933, + "subdir": "linux-64", + "timestamp": 1621648761512, + "version": "7.71.1" + }, + "libcurl-7.78.0-h0b77cf5_0.conda": { + "build": "h0b77cf5_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "libnghttp2 >=1.41.0,<2.0a0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1k,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "224da35c06d4c99b8d41876aa6f8130c", + "name": "libcurl", + "sha256": "a585caa90a9665c91241f9202f148eb28713348ff0ea1247f7335e3aa259abee", + "size": 345681, + "subdir": "linux-64", + "timestamp": 1628797013645, + "version": "7.78.0" + }, + "libcurl-7.80.0-h0b77cf5_0.conda": { + "build": "h0b77cf5_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "libnghttp2 >=1.46.0,<2.0a0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1l,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "91cea86ac0407414d3b55e7a38d60384", + "name": "libcurl", + "sha256": "19329033c24cf55c276e6f694e4bca6349d639a83f092448d3738f27f003f0fe", + "size": 347432, + "subdir": "linux-64", + "timestamp": 1639143826639, + "version": "7.80.0" + }, + "libcurl-7.82.0-h0b77cf5_0.conda": { + "build": "h0b77cf5_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "libnghttp2 >=1.46.0,<2.0a0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1n,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "1a3f73bece51854cd6afd18238a983c6", + "name": "libcurl", + "sha256": "57464474ae0515249d1d3fdd8a5c62b34e9478b6e67a71bbf26f4f335c2e653d", + "size": 350112, + "subdir": "linux-64", + "timestamp": 1649731351073, + "version": "7.82.0" + }, + "libcurl-7.84.0-h91b91d3_0.conda": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libnghttp2 >=1.46.0,<2.0a0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "41853e4ec985861aeec97a2dbd34e7ab", + "name": "libcurl", + "sha256": "34a62c0d73b35abcdc2b4d388e61b4279449865f628899404d1686f7332c0652", + "size": 345518, + "subdir": "linux-64", + "timestamp": 1659041689515, + "version": "7.84.0" + }, + "libcurl-7.85.0-h91b91d3_0.conda": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libnghttp2 >=1.46.0,<2.0a0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "52feb0997216bf5bd8fde82acf2c0be9", + "name": "libcurl", + "sha256": "7afa3ab43565343e8a7e6c8f6c3d7f02f32a079b2139dace464f5763aa0a307a", + "size": 346641, + "subdir": "linux-64", + "timestamp": 1666683418263, + "version": "7.85.0" + }, + "libcurl-7.86.0-h91b91d3_0.conda": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libnghttp2 >=1.46.0,<2.0a0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1s,<1.1.2a", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "19d8c5eca5941f0c4f898492dd5dd8db", + "name": "libcurl", + "sha256": "9b63ea7b9b9236eb3cf547eb516f8afffec455d4c0416074b85112d9fa7ec259", + "size": 376372, + "subdir": "linux-64", + "timestamp": 1669738513219, + "version": "7.86.0" + }, + "libcurl-7.87.0-h91b91d3_0.conda": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libnghttp2 >=1.46.0,<2.0a0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1s,<1.1.2a", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "d9dec814afccf758636fb96a1183c4ed", + "name": "libcurl", + "sha256": "c85c99391fcd57a0978121b8ac3d01613f581e4cd8575a1fff6405fc653f1ca6", + "size": 381556, + "subdir": "linux-64", + "timestamp": 1674234304307, + "version": "7.87.0" + }, + "libcurl-7.88.1-h91b91d3_0.conda": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.4,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libnghttp2 >=1.46.0", + "libnghttp2 >=1.46.0,<2.0a0", + "libssh2 >=1.10.0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1t,<1.1.2a", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "f5db91f4cacba5e3f00771f0015ec9e1", + "name": "libcurl", + "sha256": "dd4a34663513af1e440fb9d8acb8bb44c4229ecb329641f8654f3445e3fc6878", + "size": 391874, + "subdir": "linux-64", + "timestamp": 1678377841152, + "version": "7.88.1" + }, + "libcurl-static-7.78.0-h0b77cf5_0.conda": { + "build": "h0b77cf5_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libcurl 7.78.0 h0b77cf5_0", + "libgcc-ng >=7.5.0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1k,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "1b7ba180532e5fef5a384e1cfbdf447c", + "name": "libcurl-static", + "sha256": "f8a94b095f89c42b4d363976ed3da4c52ad954dbc6073b5b5217c5ba0edf34d9", + "size": 362859, + "subdir": "linux-64", + "timestamp": 1628797027827, + "version": "7.78.0" + }, + "libcurl-static-7.80.0-h8f2d780_0.conda": { + "build": "h8f2d780_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libcurl 7.80.0 h0b77cf5_0", + "libgcc-ng >=7.5.0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1l,<1.1.2a" + ], + "license": "curl", + "license_family": "MIT", + "md5": "604738f61da4aad42f860ceac4f5c036", + "name": "libcurl-static", + "sha256": "9cf5e49ed89b592c2586473b95a9298778f7034640d4d5b9d2975adabf169f28", + "size": 365701, + "subdir": "linux-64", + "timestamp": 1639143840502, + "version": "7.80.0" + }, + "libcurl-static-7.82.0-h8f2d780_0.conda": { + "build": "h8f2d780_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libcurl 7.82.0 h0b77cf5_0", + "libgcc-ng >=7.5.0", + "libssh2 >=1.9.0,<2.0a0", + "openssl >=1.1.1n,<1.1.2a" + ], + "license": "curl", + "license_family": "MIT", + "md5": "b89de9d7e2d29706d2e4a18a7f6272f4", + "name": "libcurl-static", + "sha256": "831cb76ffd9ac2dfd47c27823caed9a509a870600029a05493d3b29b86724c55", + "size": 366961, + "subdir": "linux-64", + "timestamp": 1649731365130, + "version": "7.82.0" + }, + "libcurl-static-7.84.0-h91b91d3_0.conda": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libcurl 7.84.0 h91b91d3_0", + "libgcc-ng >=11.2.0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "fc8bd6c13b30696e2e8cff2e757239f0", + "name": "libcurl-static", + "sha256": "175f01ffe98d1a47bbdd2e924bc65d3451d3512dd0296023560a8e6fbe55c685", + "size": 364072, + "subdir": "linux-64", + "timestamp": 1659041704179, + "version": "7.84.0" + }, + "libcurl-static-7.85.0-h91b91d3_0.conda": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libcurl 7.85.0 h91b91d3_0", + "libgcc-ng >=11.2.0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "a7486805f7a40890678e88066dcb1f7f", + "name": "libcurl-static", + "sha256": "fd004bfc44a59c1fecdd0a32df4ffcf70a5fd59a1f192ba4ae5a8b15dd6215a5", + "size": 365277, + "subdir": "linux-64", + "timestamp": 1666683430224, + "version": "7.85.0" + }, + "libcurl-static-7.86.0-h91b91d3_0.conda": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libcurl 7.86.0 h91b91d3_0", + "libgcc-ng >=11.2.0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1s,<1.1.2a", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "470b776f94ca1586392733a20eb6337d", + "name": "libcurl-static", + "sha256": "7ad67bdf74ac7d5924f10c7db2bdf6a3f60164e7630cb4ea1fe6a072a4f34afd", + "size": 396899, + "subdir": "linux-64", + "timestamp": 1669738524947, + "version": "7.86.0" + }, + "libcurl-static-7.87.0-h91b91d3_0.conda": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libcurl 7.87.0 h91b91d3_0", + "libgcc-ng >=11.2.0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1s,<1.1.2a", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "0f8308f7b3323b6ae27e02540528d47e", + "name": "libcurl-static", + "sha256": "0c9c173bca63b259a2a5da5e4a5b0db53aca7608912ca3bd5e0558c20aa63c62", + "size": 402176, + "subdir": "linux-64", + "timestamp": 1674234316189, + "version": "7.87.0" + }, + "libcurl-static-7.88.1-h91b91d3_0.conda": { + "build": "h91b91d3_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.4,<1.20.0a0", + "libcurl 7.88.1 h91b91d3_0", + "libgcc-ng >=11.2.0", + "libssh2 >=1.10.0,<2.0a0", + "openssl >=1.1.1t,<1.1.2a", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "curl", + "license_family": "MIT", + "md5": "a3b8101a42a780d8af419aae78f4db13", + "name": "libcurl-static", + "sha256": "656dd79ef21d0da87327ea560aac53a4186d687035215963bce30a17eec79ef6", + "size": 414662, + "subdir": "linux-64", + "timestamp": 1678377853606, + "version": "7.88.1" + }, + "libcxx-14.0.6-h83ecd13_0.conda": { + "build": "h83ecd13_0", + "build_number": 0, + "depends": [ + "libcxxabi 14.0.6 h06a4308_0", + "libgcc-ng >=11.2.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "7d872e47415a373b56a94b2a06efc450", + "name": "libcxx", + "sha256": "5175fa7cddd49be75a0ecf5eb667be52d3b7698a579556a6d377ebd8510c0787", + "size": 1094363, + "subdir": "linux-64", + "timestamp": 1662620535350, + "version": "14.0.6" + }, + "libcxxabi-14.0.6-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "constrains": [ + "libcxx 14.0.6.*" + ], + "depends": [], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "135974475a3280bd51f392f462f9e01c", + "name": "libcxxabi", + "sha256": "5a843055cdeec053fdee6771f3ecd69c74dd14756adff566949a7a9399f5251f", + "size": 150650, + "subdir": "linux-64", + "timestamp": 1662620526949, + "version": "14.0.6" + }, + "libdap4-3.19.0-h5bd89bb_2.conda": { + "build": "h5bd89bb_2", + "build_number": 2, + "depends": [ + "curl", + "libcurl >=7.58.0,<8.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.7,<2.10.0a0" + ], + "license": "GNU LGPL", + "md5": "79a7e2214f5fd6adc16fa0f861556c79", + "name": "libdap4", + "sha256": "a171eefa036658a1b7c278d87c44497d9c74963c775563c5b259790d31ce2424", + "size": 1084704, + "subdir": "linux-64", + "timestamp": 1518111422068, + "version": "3.19.0" + }, + "libdap4-3.19.0-h6ec2957_2.conda": { + "build": "h6ec2957_2", + "build_number": 2, + "depends": [ + "curl", + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0" + ], + "license": "GNU LGPL", + "md5": "5605a0c1366fdccbafb8f6b385be10d0", + "name": "libdap4", + "sha256": "1657f203d11791ea49b91d57b74041e5a245af1efcbaf84508e4f6b0ab13bdc5", + "size": 1097623, + "subdir": "linux-64", + "timestamp": 1530868852589, + "version": "3.19.0" + }, + "libdap4-3.19.0-h8c95237_1.conda": { + "build": "h8c95237_1", + "build_number": 1, + "depends": [ + "curl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "util-linux" + ], + "license": "GNU LGPL", + "md5": "adffae18bc2362359e2b9470dfe4ae9d", + "name": "libdap4", + "sha256": "e1e5c3d8539515ec661e292abfb1fd73da172e88b4b9ac1e523eadbd00407e32", + "size": 1109543, + "subdir": "linux-64", + "timestamp": 1511371852263, + "version": "3.19.0" + }, + "libdap4-3.19.0-haaf9fdb_1.conda": { + "build": "haaf9fdb_1", + "build_number": 1, + "depends": [ + "curl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "util-linux" + ], + "license": "GNU LGPL", + "md5": "c8fa2fdbb28cf11f4a8ccc7f48370548", + "name": "libdap4", + "sha256": "5b554632f0f8ac20af4298f5e8eec03d31b99a4216bd7a5db18723febddfc382", + "size": 1109298, + "subdir": "linux-64", + "timestamp": 1509503009528, + "version": "3.19.0" + }, + "libdap4-3.19.1-h6a678d5_1.conda": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "curl", + "libcurl >=7.88.1,<8.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "libxml2 >=2.10.3,<2.11.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "4e66b6c3b021bea20d736606e90d9297", + "name": "libdap4", + "sha256": "40268fc77a2d8b4ae760b2cc38ffb837bab075db63035cf59ddcee847a41b975", + "size": 1512038, + "subdir": "linux-64", + "timestamp": 1679578334916, + "version": "3.19.1" + }, + "libdap4-3.19.1-h6ec2957_0.conda": { + "build": "h6ec2957_0", + "build_number": 0, + "depends": [ + "curl", + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0" + ], + "license": "GNU LGPL", + "md5": "85b390844364dee784afbc2e18cc02e2", + "name": "libdap4", + "sha256": "8fddebd86413f57aa4ea927340b131cab1904b82d1d5d951318c3b97cf0d18b5", + "size": 1085609, + "subdir": "linux-64", + "timestamp": 1532084028670, + "version": "3.19.1" + }, + "libdate-3.0.1-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "57d49eac811482ec0cdd6bb53d97b163", + "name": "libdate", + "sha256": "69f0c26a609a11ec3af5c69919fcc2b96612cd20c13bfab550a23d5d3578a93a", + "size": 114279, + "subdir": "linux-64", + "timestamp": 1659102203728, + "version": "3.0.1" + }, + "libdb-6.1.26-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "AGPL-3.0", + "md5": "cca51d279623d5045f928972d5c9a6ef", + "name": "libdb", + "sha256": "7b64888a44832d84846ef524fea587976ae548deca85367746abd2989064f69f", + "size": 18537078, + "subdir": "linux-64", + "timestamp": 1537817966915, + "version": "6.1.26" + }, + "libdb-6.2.32-h6a678d5_1.conda": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "AGPL-3.0-only", + "md5": "3f0e8b19439efa7dad29eb8f6586f09e", + "name": "libdb", + "sha256": "7f8681b95ddbdb78a6bef70cd7c2e03bd8e3a04fbaa2709d46b38a600c001110", + "size": 19419739, + "subdir": "linux-64", + "timestamp": 1656332129152, + "version": "6.2.32" + }, + "libdb-6.2.32-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "AGPL-3.0-only", + "md5": "5e9bb87ff6fdead82e64656b7246c8b2", + "name": "libdb", + "sha256": "ff51e03e04004292cda16a619c2a43bf2d5d509a5b4eb6dd2f6237762f7a59e9", + "size": 19411984, + "subdir": "linux-64", + "timestamp": 1601249370375, + "version": "6.2.32" + }, + "libdb-6.2.32-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "AGPL-3.0-only", + "md5": "540a1974e97c6fa2506fc39453e00fee", + "name": "libdb", + "sha256": "83c5915aa9f05a29091b89c5a3a1e90ae93abd9303513d040299f1f75eb8678f", + "size": 19411485, + "subdir": "linux-64", + "timestamp": 1601249464834, + "version": "6.2.32" + }, + "libdeflate-1.17-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4891fa07ca4cad1c53a0d0e539482da", + "name": "libdeflate", + "sha256": "529ebc4555ef377b00ec07708b47fdcea1dcf4721f5a2fddfd0ca7cb652e9d0a", + "size": 70808, + "subdir": "linux-64", + "timestamp": 1677486576483, + "version": "1.17" + }, + "libdeflate-1.7-h27cfd23_5.conda": { + "build": "h27cfd23_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "md5": "475abffbeba5b2f96ae9694d0018dcc9", + "name": "libdeflate", + "sha256": "0466c0ce90965e6db9cb8281ef180a369fc3e879b2f6307204b415f10f59dfff", + "size": 56529, + "subdir": "linux-64", + "timestamp": 1611255495157, + "version": "1.7" + }, + "libdeflate-1.8-h7f8727e_5.conda": { + "build": "h7f8727e_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6942d65edab9a800900f43e750b3ad1f", + "name": "libdeflate", + "sha256": "f0a3d0a69ee162bba747e81b0770d3a14c0551600c41d607ac7b3e08e0a3bff4", + "size": 52410, + "subdir": "linux-64", + "timestamp": 1626439978555, + "version": "1.8" + }, + "libedit-3.1-heed3624_0.conda": { + "build": "heed3624_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "ncurses 6.0.*" + ], + "license": "3-Clause BSD", + "license_family": "BSD", + "md5": "bf83ea733fdf1d24eefcee2fb3e2ddf3", + "name": "libedit", + "sha256": "4913bc90e04906e911557886e811723fcf4de8ebb25d57c399dc7fa82cab1134", + "size": 155054, + "subdir": "linux-64", + "timestamp": 1505666480132, + "version": "3.1" + }, + "libedit-3.1.20170329-h6b74fdf_2.conda": { + "build": "h6b74fdf_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "ncurses >=6.1,<7.0a0" + ], + "license": "NetBSD", + "license_family": "BSD", + "md5": "cbd312822a2a6b59b02ea71c1a52c1d4", + "name": "libedit", + "sha256": "bf63771de780bb3d46e5e9625b1309a23e70f438c42d51fc8742e97ad77dc5dd", + "size": 154017, + "subdir": "linux-64", + "timestamp": 1525913899914, + "version": "3.1.20170329" + }, + "libedit-3.1.20181209-hc058e9b_0.conda": { + "build": "hc058e9b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ncurses >=6.1,<7.0a0" + ], + "license": "NetBSD", + "license_family": "BSD", + "md5": "594c05f769516b55c004eada4fc9ea74", + "name": "libedit", + "sha256": "47fded4c565175b5732320048bd5cdd0e8638523fe21207090665b8e6d0d753e", + "size": 166984, + "subdir": "linux-64", + "timestamp": 1547971047214, + "version": "3.1.20181209" + }, + "libedit-3.1.20191231-h14c3975_1.conda": { + "build": "h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a900fd130232e0189f071fabbc6025d9", + "name": "libedit", + "sha256": "5e2b1ccae715cca850c3246f996cf7f310babc609c6e7398869028135f9f8a7d", + "size": 118350, + "subdir": "linux-64", + "timestamp": 1594367571417, + "version": "3.1.20191231" + }, + "libedit-3.1.20191231-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c38bb867424ddef56e3df79402fb688b", + "name": "libedit", + "sha256": "4c85ab34fd889b3960f43f23ad4e22ead0e473b12b4c06d24d0953d613fec1d8", + "size": 170598, + "subdir": "linux-64", + "timestamp": 1592512294724, + "version": "3.1.20191231" + }, + "libedit-3.1.20210216-h27cfd23_1.conda": { + "build": "h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e04d04ddd875c3877eaad0d94b250166", + "name": "libedit", + "sha256": "8c096f0829735fc9c3549887a38c5201de3a83e325920d87fd9f8531501b27db", + "size": 170728, + "subdir": "linux-64", + "timestamp": 1615827969117, + "version": "3.1.20210216" + }, + "libedit-3.1.20210714-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "ncurses >=6.2,<7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a44c016447ec4fc366dc35ce5282a5a8", + "name": "libedit", + "sha256": "d29f6f11e12e93ae0222704e34e78aa0c3f104cf998eb5149ab1dc15bcdcfdae", + "size": 168667, + "subdir": "linux-64", + "timestamp": 1630071246101, + "version": "3.1.20210714" + }, + "libedit-3.1.20210910-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "ncurses >=6.3,<7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "cf16006f8f24e4224ddce196471d2509", + "name": "libedit", + "sha256": "6bfecab0a81cd806c353cfe60bc7528ed93f047e6355476d0db131b9d1e1ba31", + "size": 170118, + "subdir": "linux-64", + "timestamp": 1636026988621, + "version": "3.1.20210910" + }, + "libedit-3.1.20221030-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "7c724a17739aceaf9d1633ff06962137", + "name": "libedit", + "sha256": "a173782157a51369f2a6dbdaaad3dfbc78d1ad4b76a5648fe55bca9acc7f0205", + "size": 185564, + "subdir": "linux-64", + "timestamp": 1670840131081, + "version": "3.1.20221030" + }, + "libev-4.33-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a022f5d9c1737589a55c715cfaada508", + "name": "libev", + "sha256": "8ba6c67b5790b240c3a4fc7333453efd3604125d37c3dc0c51ebe5e20848a8be", + "size": 114190, + "subdir": "linux-64", + "timestamp": 1597168717341, + "version": "4.33" + }, + "libev-4.33-h7f8727e_1.conda": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5065620db4393fb549f30114a33897d1", + "name": "libev", + "sha256": "75f04cf201848d58df127caf9f316f71e1103b28e00b5add9b0c8025e52d7569", + "size": 114011, + "subdir": "linux-64", + "timestamp": 1632891483341, + "version": "4.33" + }, + "libev-libevent-4.33-h7f8727e_1.conda": { + "build": "h7f8727e_1", + "build_number": 1, + "constrains": [ + "libevent ==9999999999" + ], + "depends": [ + "libev 4.33 h7f8727e_1", + "libgcc-ng >=7.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "7fe441cd2ac69a9e08393fa07c33ab0f", + "name": "libev-libevent", + "sha256": "767ea82ea6f435eeae096cfcbe8d61527a2907b41cda3c1baab0e72f38812a51", + "size": 9807, + "subdir": "linux-64", + "timestamp": 1632891491283, + "version": "4.33" + }, + "libev-static-4.33-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libev 4.33 h7b6447c_0", + "libgcc-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ead7674750d05f74b6c72bfb4a72c07f", + "name": "libev-static", + "sha256": "6c18280dd93acb9b82c72a88d17f21cc3e6df5339860f13182ef3d4b58c47cbd", + "size": 30867, + "subdir": "linux-64", + "timestamp": 1597168723823, + "version": "4.33" + }, + "libev-static-4.33-h7f8727e_1.conda": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libev 4.33 h7f8727e_1", + "libgcc-ng >=7.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b4ce5b1a2066fe551010715fa6534e30", + "name": "libev-static", + "sha256": "6dc7d058b7cf028928f880dbae3e27a4612d5a3f0b8fe734119f2e52377c6055", + "size": 31488, + "subdir": "linux-64", + "timestamp": 1632891498542, + "version": "4.33" + }, + "libevent-2.1.12-h8f2d780_0.conda": { + "build": "h8f2d780_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openssl >=1.1.1m,<1.1.2a" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8de03cd4b6ee0ddeb0571a5199db5637", + "name": "libevent", + "sha256": "04d91a45746f1ec150aa9c7511593f63ab195cf45571320a312ee16ced0ff94b", + "size": 434879, + "subdir": "linux-64", + "timestamp": 1642102679055, + "version": "2.1.12" + }, + "libevent-2.1.8-h1ba5d50_0.conda": { + "build": "h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7d7b5e09cd896e30870d9cc6793402ee", + "name": "libevent", + "sha256": "cf2d76ce75db96c7787443bfb05421b7eb07dd15026cb9744aef62f083a385ab", + "size": 905647, + "subdir": "linux-64", + "timestamp": 1540396874706, + "version": "2.1.8" + }, + "libevent-2.1.8-h1ba5d50_1.conda": { + "build": "h1ba5d50_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1f3482ea86898a99d3425f3fef188ae0", + "name": "libevent", + "sha256": "66156a5a9a4c57b9b5f1d76c646be189b6c204c8c4c71664a45e72fee818dc75", + "size": 929654, + "subdir": "linux-64", + "timestamp": 1599251065437, + "version": "2.1.8" + }, + "libevent-2.1.8-h93c0eb6_0.conda": { + "build": "h93c0eb6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1b925a0f9f095677433a6ffe5deeca6b", + "name": "libevent", + "sha256": "13ea20c424d26c504a2651a0d117df4906a56ad8c01d82ae46e8a6be34829051", + "size": 933683, + "subdir": "linux-64", + "timestamp": 1511641734520, + "version": "2.1.8" + }, + "libffi-3.2.1-h4deb6c0_3.conda": { + "build": "h4deb6c0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Custom", + "md5": "72afb9bcc666cb819edc76496b469684", + "name": "libffi", + "sha256": "8116fbefdaef823fe58b29367a6b5a559f9504dac98dd410a590529c8692ef19", + "size": 40457, + "subdir": "linux-64", + "timestamp": 1505666561994, + "version": "3.2.1" + }, + "libffi-3.2.1-hd88cf55_4.conda": { + "build": "hd88cf55_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Custom", + "md5": "670083422f422f03dcd3e7e0d4de1e3a", + "name": "libffi", + "sha256": "806aeff0c3279e44cbed04d64ecb13527e27e7b34dd70b873287f1fbab5e8916", + "size": 41208, + "subdir": "linux-64", + "timestamp": 1510177337742, + "version": "3.2.1" + }, + "libffi-3.2.1-he6710b0_1007.conda": { + "build": "he6710b0_1007", + "build_number": 1007, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Custom", + "md5": "deacbc1d8ae5f25808c5a723c964f4fd", + "name": "libffi", + "sha256": "74dbe0ac37a79a2bcd0630165a4131a0ed6d880a7719f87723d74637e8148e32", + "size": 50264, + "subdir": "linux-64", + "timestamp": 1601368071003, + "version": "3.2.1" + }, + "libffi-3.2.1-hf484d3e_1007.conda": { + "build": "hf484d3e_1007", + "build_number": 1007, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Custom", + "md5": "ef4c7b437f50a1ab4920dc313d8ebc28", + "name": "libffi", + "sha256": "191f84206e321803695745e89b8e8c1ab24c2500cb82f2bf0378c65228b2ba89", + "size": 49436, + "subdir": "linux-64", + "timestamp": 1601368102100, + "version": "3.2.1" + }, + "libffi-3.3-he6710b0_1.conda": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Custom", + "md5": "d64f09bdde908ed6793d0f992041a0bf", + "name": "libffi", + "sha256": "56dbae0d2cc5d3a2b119f7f4c33d8076dee3e6b2ad9978bba6559f80a3eb3e56", + "size": 50906, + "subdir": "linux-64", + "timestamp": 1587588834166, + "version": "3.3" + }, + "libffi-3.3-he6710b0_2.conda": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Custom", + "md5": "88a54b8f50e351c650e16f4ee781440c", + "name": "libffi", + "sha256": "2cef7c80db19e83a38b6e02110f0e9828d3ef4045c38791d5b01006c44529093", + "size": 51543, + "subdir": "linux-64", + "timestamp": 1594054267890, + "version": "3.3" + }, + "libffi-3.4.2-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "md5": "0140465fa76dc6d5daa650f5e61be6f6", + "name": "libffi", + "sha256": "77e29463e5e4319e24d90963fc9b3b0dfd76fe9ac3a7e2420ae6e0311a2e2bbf", + "size": 63151, + "subdir": "linux-64", + "timestamp": 1632983431265, + "version": "3.4.2" + }, + "libffi-3.4.2-h295c915_1.conda": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "md5": "0f36c9e6e139f9b2ba25530cec971ac7", + "name": "libffi", + "sha256": "bfc003f9bf06e449f9970c48afe6908bc8fc0ee704f8967c427133516186ed9c", + "size": 62163, + "subdir": "linux-64", + "timestamp": 1636541731368, + "version": "3.4.2" + }, + "libffi-3.4.2-h295c915_2.conda": { + "build": "h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "md5": "8ef1202f4e0061602164d5ab310c5f0f", + "name": "libffi", + "sha256": "bd4b469098e1f074b1aef3e4982446dfaff254381c3bff72d78a5ae32ec83514", + "size": 61509, + "subdir": "linux-64", + "timestamp": 1636543695241, + "version": "3.4.2" + }, + "libffi-3.4.2-h295c915_4.conda": { + "build": "h295c915_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d5b83edde52035ce38c3ceee1bf09b63", + "name": "libffi", + "sha256": "5533ddc0c1711272498f202743185fd6e5da61fbd3afeadba9f687299b789b5c", + "size": 126566, + "subdir": "linux-64", + "timestamp": 1654878550541, + "version": "3.4.2" + }, + "libffi-3.4.2-h6a678d5_5.conda": { + "build": "h6a678d5_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "29b5cbea76b606d261afc64e49da3ad4", + "name": "libffi", + "sha256": "695004846c389b69dd7c0abd5b6d190014ad6bc2a421ebdabd3ff3fed8b4ca94", + "size": 137728, + "subdir": "linux-64", + "timestamp": 1669039999559, + "version": "3.4.2" + }, + "libffi-3.4.2-h6a678d5_6.conda": { + "build": "h6a678d5_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d65e299b535d3b3613b6d4bce901834", + "name": "libffi", + "sha256": "31ae5d8823804e741958a6e04704dd951d140bcf3032a07b7b5e940bc516b829", + "size": 139609, + "subdir": "linux-64", + "timestamp": 1669126632561, + "version": "3.4.2" + }, + "libgcc-7.2.0-h69d50b8_2.conda": { + "build": "h69d50b8_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GNU GPL 3+ with GCC Runtime Library", + "license_family": "GPL", + "md5": "e4722d42e4eb722876cf914e3fc011a2", + "name": "libgcc", + "sha256": "3027a54f8029803393573be05f98c46c141a5e0ba965b697a7c3faa2c62439d4", + "size": 275183, + "subdir": "linux-64", + "timestamp": 1505745053518, + "version": "7.2.0" + }, + "libgcc-devel_linux-64-11.2.0-h1234567_0.conda": { + "build": "h1234567_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "25b6c2a46b2067ac71fb041839b3f4fa", + "name": "libgcc-devel_linux-64", + "sha256": "a8fd241e4cd303c3e9639011eef5eaab95030ddcd09fad052b4c8eab67afdac7", + "size": 2633923, + "subdir": "linux-64", + "timestamp": 1652859669676, + "version": "11.2.0" + }, + "libgcc-devel_linux-64-11.2.0-h1234567_1.conda": { + "build": "h1234567_1", + "build_number": 1, + "depends": [ + "__glibc >=2.17,<3.0.a0" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "f667c768c8bfce044f2623c84321e2c5", + "name": "libgcc-devel_linux-64", + "sha256": "f2dfbd8ab721f9c414a1d5ec614c3f9170e6e13f93a8d1cbdbe677615f10db39", + "size": 2621635, + "subdir": "linux-64", + "timestamp": 1654090753647, + "version": "11.2.0" + }, + "libgcc-devel_linux-64-7.5.0-hbbeae57_17.conda": { + "build": "hbbeae57_17", + "build_number": 17, + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "b45600a2d661573423bffcf55539e1d9", + "name": "libgcc-devel_linux-64", + "sha256": "6e87f6dde39c8adcad3614553139f0caee7022dcc992562aee54322a1e8a67fa", + "size": 2696107, + "subdir": "linux-64", + "timestamp": 1622660030050, + "version": "7.5.0" + }, + "libgcc-devel_linux-64-8.4.0-hd257e2f_17.conda": { + "build": "hd257e2f_17", + "build_number": 17, + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "980d99281f3b89c12077fed4e07220e3", + "name": "libgcc-devel_linux-64", + "sha256": "391c27f68ea7796f0f385be5e2013353b60babf94846725375b7b8942d9dd1e2", + "size": 2921340, + "subdir": "linux-64", + "timestamp": 1622661638276, + "version": "8.4.0" + }, + "libgcc-devel_linux-64-9.3.0-hb95220a_17.conda": { + "build": "hb95220a_17", + "build_number": 17, + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "3faa77438680d3706329f7f2d1513575", + "name": "libgcc-devel_linux-64", + "sha256": "f5767894fbb36f154d653bbf9547c700e22d7401f13aff73697e7270fb675da4", + "size": 2921580, + "subdir": "linux-64", + "timestamp": 1622663285149, + "version": "9.3.0" + }, + "libgcc-ng-11.2.0-h1234567_0.conda": { + "build": "h1234567_0", + "build_number": 0, + "constrains": [ + "_openmp_mutex", + "libgomp 11.2.0 h1234567_0", + "_libgcc_mutex 0.1 main" + ], + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex", + "_libgcc_mutex * main", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "83c045906d7d785252a34846348d16c6", + "name": "libgcc-ng", + "sha256": "834dcb50b7574a072755541bc9c0264b214ae7a8ad6b63f3ce24a90bf079f004", + "size": 5590744, + "subdir": "linux-64", + "timestamp": 1652859742018, + "version": "11.2.0" + }, + "libgcc-ng-11.2.0-h1234567_1.conda": { + "build": "h1234567_1", + "build_number": 1, + "constrains": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex", + "libgomp 11.2.0 h1234567_1" + ], + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex", + "_libgcc_mutex * main", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "a87728dabf3151fb9cfa990bd2eb0464", + "name": "libgcc-ng", + "sha256": "cdcce11f1c6ca57ba686ab92f3a5c122efe1e0630e00c6ad275624ce79008aa7", + "size": 5602184, + "subdir": "linux-64", + "timestamp": 1654090827491, + "version": "11.2.0" + }, + "libgcc-ng-5.4.0-hdf63c60_3.conda": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [ + "_libgcc_mutex * main" + ], + "license": "GPL", + "md5": "81015325adda2e4e2bc6cda59e238d75", + "name": "libgcc-ng", + "sha256": "a155d9e4a5a6eaecec8fc524725703691b9edda7e426acea752d38ea5b1d4cd6", + "size": 2974151, + "subdir": "linux-64", + "timestamp": 1520969505500, + "version": "5.4.0" + }, + "libgcc-ng-7.2.0-h7cc24e2_2.conda": { + "build": "h7cc24e2_2", + "build_number": 2, + "depends": [ + "_libgcc_mutex * main" + ], + "license": "GPL", + "md5": "f98bd409ae8833f48af84d6991ddbee3", + "name": "libgcc-ng", + "sha256": "96112a4a880d77ca50404699aa971a2f350ad2ab30ed4e5455b76e31f3f1b7d0", + "size": 3987220, + "subdir": "linux-64", + "timestamp": 1507262720504, + "version": "7.2.0" + }, + "libgcc-ng-7.2.0-hcbc56d2_1.conda": { + "build": "hcbc56d2_1", + "build_number": 1, + "depends": [ + "_libgcc_mutex * main" + ], + "license": "GPL", + "md5": "ad08127b90950019456545fc18ae50ab", + "name": "libgcc-ng", + "sha256": "d98bf49f3e9664a5604c543e4abdd0a19306ebca803264a45f954d9240d11fe7", + "size": 3989645, + "subdir": "linux-64", + "timestamp": 1505665562970, + "version": "7.2.0" + }, + "libgcc-ng-7.2.0-hdf63c60_3.conda": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [ + "_libgcc_mutex * main" + ], + "license": "GPL", + "md5": "c3b5bdd1e342c4c60405a3c4c6c2faf8", + "name": "libgcc-ng", + "sha256": "5f71ab1122ef516bdfb017e4a3242abb5ff263ede730cb81909c50be9730b0f3", + "size": 4002524, + "subdir": "linux-64", + "timestamp": 1520534508914, + "version": "7.2.0" + }, + "libgcc-ng-7.3.0-hdf63c60_0.conda": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex * main" + ], + "license": "GPL", + "md5": "d488be2fcafc5603d1e4647d0450d680", + "name": "libgcc-ng", + "sha256": "3091921e1f8476735e7a2beaeaca7265cb6aab5970b2d12ed3a60cb5093c6507", + "size": 4050704, + "subdir": "linux-64", + "timestamp": 1534628447830, + "version": "7.3.0" + }, + "libgcc-ng-7.5.0-h5101ec6_17.conda": { + "build": "h5101ec6_17", + "build_number": 17, + "constrains": [ + "libgomp 7.5.0 h5101ec6_17" + ], + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex >=4.5", + "_libgcc_mutex * main", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "b387c3f062fd3f8c366258d56c89273f", + "name": "libgcc-ng", + "sha256": "154e431b52e6ed1de2abfb79d233fe58ea1a33223340767de5c8829fceb94ef3", + "size": 3837112, + "subdir": "linux-64", + "timestamp": 1622660095834, + "version": "7.5.0" + }, + "libgcc-ng-8.2.0-hdf63c60_0.conda": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex * main" + ], + "license": "GPL", + "md5": "ba3bff334315cec1d0e70c6e62038356", + "name": "libgcc-ng", + "sha256": "c6f8b9cc1ab7a4fa3e16d2d4e807523df8ad975e64668e0402a003916375929a", + "size": 4990418, + "subdir": "linux-64", + "timestamp": 1534277498668, + "version": "8.2.0" + }, + "libgcc-ng-8.2.0-hdf63c60_1.conda": { + "build": "hdf63c60_1", + "build_number": 1, + "depends": [ + "_libgcc_mutex * main" + ], + "license": "GPL", + "md5": "894083b9b5adbe5f661b10c29f6c621d", + "name": "libgcc-ng", + "sha256": "68c7f7ba0b7ccab1cf458c87d669a67e7e88fd6f6413fc04bc67fb8662137136", + "size": 4986241, + "subdir": "linux-64", + "timestamp": 1534516107109, + "version": "8.2.0" + }, + "libgcc-ng-8.4.0-h5101ec6_17.conda": { + "build": "h5101ec6_17", + "build_number": 17, + "constrains": [ + "libgomp 8.4.0 h5101ec6_17" + ], + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex >=4.5", + "_libgcc_mutex * main", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "669ef30dadfcc92d455367c32682a42e", + "name": "libgcc-ng", + "sha256": "2b93adf85134046d80a707fcbb3bd287c5c44a94501c2455200846a62aa3e5ad", + "size": 4756676, + "subdir": "linux-64", + "timestamp": 1622661701487, + "version": "8.4.0" + }, + "libgcc-ng-9.1.0-hdf63c60_0.conda": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex * main" + ], + "license": "GPL", + "md5": "80a23105874059534307086faae566c5", + "name": "libgcc-ng", + "sha256": "9f867b7bf107d4999f91b7f6a4f930c25e82a859013fba4ded608d78f7da5aa9", + "size": 5304005, + "subdir": "linux-64", + "timestamp": 1560112207081, + "version": "9.1.0" + }, + "libgcc-ng-9.3.0-h5101ec6_17.conda": { + "build": "h5101ec6_17", + "build_number": 17, + "constrains": [ + "libgomp 9.3.0 h5101ec6_17" + ], + "depends": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex >=4.5", + "_libgcc_mutex * main", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "e9cbabbfb9e8a430f6a7660fe8dd77a7", + "name": "libgcc-ng", + "sha256": "49a808720a51c107241a42ac3641cce3d8451ef7cfaf3d68b6e4a3fec2da0676", + "size": 5035441, + "subdir": "linux-64", + "timestamp": 1622663350853, + "version": "9.3.0" + }, + "libgcrypt-1.8.0-h14c3975_2.conda": { + "build": "h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpg-error >=1.27,<2.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "3d2a18d74ddba5d70e8a2b4e007beaab", + "name": "libgcrypt", + "sha256": "a1f5ddd1deb3d8aa07c21dbb85ef768e31befcde2192e676a7eb86e10c6f18ee", + "size": 555204, + "subdir": "linux-64", + "timestamp": 1515696811175, + "version": "1.8.0" + }, + "libgcrypt-1.8.2-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpg-error >=1.29,<2.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "8098ab3fa298608b16f24f26c869bb62", + "name": "libgcrypt", + "sha256": "dcb5abd937aea2f6d2f1beb099dae3fb1f21183dcee25f0a46366efb5f96ba27", + "size": 555290, + "subdir": "linux-64", + "timestamp": 1523954047529, + "version": "1.8.2" + }, + "libgcrypt-1.8.3-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpg-error >=1.31,<2.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "06f5f6aeac40ef31420ec9ed24f51669", + "name": "libgcrypt", + "sha256": "5090e530df5c9652dee26c4ee719cc92778ec8b3c880e445f302747716f242d2", + "size": 560038, + "subdir": "linux-64", + "timestamp": 1529961323434, + "version": "1.8.3" + }, + "libgcrypt-1.8.4-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpg-error >=1.32,<2.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "6a8f54308a5b373c30f813111d9bd45f", + "name": "libgcrypt", + "sha256": "e355bb39b3233ac970d96dcfbb7809c9504ab319c236d56331ea16be949cab42", + "size": 563035, + "subdir": "linux-64", + "timestamp": 1540981549661, + "version": "1.8.4" + }, + "libgcrypt-1.8.6-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpg-error >=1.32,<2.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "57452e5fcb4e454783bdc9df367e6715", + "name": "libgcrypt", + "sha256": "26f2cf448f82b118aa8d7152b17727edcfc8803ebd89a625527a64ffe08b7aa5", + "size": 561120, + "subdir": "linux-64", + "timestamp": 1600381734428, + "version": "1.8.6" + }, + "libgcrypt-1.8.7-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpg-error >=1.39,<2.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "aee89fd29075b88368ab2e9346a30ed2", + "name": "libgcrypt", + "sha256": "b86f5b82aeeb4247d51dd20987013fdfc2eaa21abad07ebc4782c202aba612a2", + "size": 562518, + "subdir": "linux-64", + "timestamp": 1603821168850, + "version": "1.8.7" + }, + "libgcrypt-1.9.0-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpg-error >=1.41,<2.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "909220604b7b856a6764acaa339534a0", + "name": "libgcrypt", + "sha256": "ef4d0dede62853f161ed51667186303938bc88d2fabdc5e52f50df21add322b0", + "size": 605886, + "subdir": "linux-64", + "timestamp": 1611082600169, + "version": "1.9.0" + }, + "libgcrypt-1.9.1-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpg-error >=1.41,<2.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "40aeae09018df7c6d99774001ba3f955", + "name": "libgcrypt", + "sha256": "3c5950f0d0b4478daedeadc6f1ed9d1427132eaa5cfbc6d79c27ecc861a9bcf8", + "size": 604042, + "subdir": "linux-64", + "timestamp": 1611951455942, + "version": "1.9.1" + }, + "libgcrypt-1.9.2-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpg-error >=1.41,<2.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "102fd3ac8a93f02763ca343d50185cb8", + "name": "libgcrypt", + "sha256": "465bb13de94c43bff0593aefe04168235bad70f5a8726f5f59a47b43974779a0", + "size": 604910, + "subdir": "linux-64", + "timestamp": 1613588719411, + "version": "1.9.2" + }, + "libgcrypt-1.9.3-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpg-error >=1.42,<2.0a0" + ], + "license": "LGPL-2.1-or-later AND GPL-2.0-or-later", + "license_family": "GPL", + "md5": "200958e0e7cc4bb0883732283ee307bd", + "name": "libgcrypt", + "sha256": "2fc8cca1f965d7bc54ba826db10788adf8c114d982445aff0b83bf88b378a2b2", + "size": 618052, + "subdir": "linux-64", + "timestamp": 1618922221586, + "version": "1.9.3" + }, + "libgd-2.2.5-h0db58fd_3.conda": { + "build": "h0db58fd_3", + "build_number": 3, + "depends": [ + "expat >=2.2.6,<3.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GD", + "license_family": "BSD", + "md5": "7bac75c87b46a4e4979eee41204562a9", + "name": "libgd", + "sha256": "47fcd3c16675c6691d782f122075a9ca4f13fbcbfeab70309f50dc895ed55684", + "size": 234901, + "subdir": "linux-64", + "timestamp": 1581434054141, + "version": "2.2.5" + }, + "libgd-2.2.5-h8e06009_4.conda": { + "build": "h8e06009_4", + "build_number": 4, + "depends": [ + "expat", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "icu", + "jpeg >=9b,<10a", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GD", + "license_family": "BSD", + "md5": "6a5d95a3a505c257d454f137f46e072b", + "name": "libgd", + "sha256": "ebdb6d9b9bf5564e4ee78e37d80292a76c2409f3da7fc4b92501d05ddd635c13", + "size": 234560, + "subdir": "linux-64", + "timestamp": 1631695646696, + "version": "2.2.5" + }, + "libgd-2.2.5-hceca4fd_3.conda": { + "build": "hceca4fd_3", + "build_number": 3, + "depends": [ + "expat >=2.2.5,<3.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libtiff >=4.0.9,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GD", + "license_family": "BSD", + "md5": "f84fb297b1ceb421c2bfedf9e8ed98ce", + "name": "libgd", + "sha256": "25dcb4c2dc9d1510391b46cacee2b0df2258387d0cb2356f7b294fe2da93493c", + "size": 220689, + "subdir": "linux-64", + "timestamp": 1534486421561, + "version": "2.2.5" + }, + "libgd-2.3.2-hdd3ff0f_3.conda": { + "build": "hdd3ff0f_3", + "build_number": 3, + "depends": [ + "expat", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "icu", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.0.0,<1.1.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GD", + "license_family": "BSD", + "md5": "790312ffa7f79a842ed399073a289aae", + "name": "libgd", + "sha256": "344b8cc9e1672a731b0c6b0d0f802328548e0e7663261eb86aae11619a342998", + "size": 235443, + "subdir": "linux-64", + "timestamp": 1621419196671, + "version": "2.3.2" + }, + "libgd-2.3.3-h695aa2c_0.conda": { + "build": "h695aa2c_0", + "build_number": 0, + "depends": [ + "expat", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "icu", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base" + ], + "license": "GD", + "license_family": "BSD", + "md5": "687c75fad983d86cc17f67a1b5f9687e", + "name": "libgd", + "sha256": "2595c73ba00854e685a29c009bf9f3b3243cecd367feed9c5e3428230b4ad8c9", + "size": 229084, + "subdir": "linux-64", + "timestamp": 1639139509275, + "version": "2.3.3" + }, + "libgd-2.3.3-h695aa2c_1.conda": { + "build": "h695aa2c_1", + "build_number": 1, + "depends": [ + "expat", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "icu", + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base" + ], + "license": "GD", + "license_family": "BSD", + "md5": "a83694f90f2668f9e94ff0c78a8c5209", + "name": "libgd", + "sha256": "b9fdc1f4c62e18e000c849ac17b5d16a501606445f28f9ced0a4c15b21a1c0aa", + "size": 227548, + "subdir": "linux-64", + "timestamp": 1655396452872, + "version": "2.3.3" + }, + "libgd-2.3.3-h6a678d5_2.conda": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "expat >=2.4.9,<3.0a0", + "fontconfig >=2.14.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "icu >=58.0,<59.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "libwebp-base >=1.2.4,<2.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GD", + "license_family": "BSD", + "md5": "990e0e4d5e6349de76ca9608f71134ac", + "name": "libgd", + "sha256": "de9c263bd5ffec305055376159e05f2109347cb4a46ec0ff3cbecbfb0ee41d9c", + "size": 246146, + "subdir": "linux-64", + "timestamp": 1677001623648, + "version": "2.3.3" + }, + "libgdal-2.2.2-h1c3dc7d_1.conda": { + "build": "h1c3dc7d_1", + "build_number": 1, + "depends": [ + "curl", + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.4,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jpeg >=9b,<10a", + "json-c >=0.12.1,<0.13.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "libpng >=1.6.32,<1.7.0a0", + "libpq >=9.6.6", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "openjpeg >=2.2.0,<3.0a0", + "poppler >=0.60.1,<1.0a0", + "proj4 >=4.9.3,<4.9.4.0a0", + "sqlite >=3.20.1,<4.0a0", + "xerces-c >=3.2.0,<3.3.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "4f4b976d749afa6cf510db8fd2f6f8df", + "name": "libgdal", + "sha256": "0cf008995645c907a34c8708efa5257323bcff9f763f2f1f255ff704a371f4ba", + "size": 10396782, + "subdir": "linux-64", + "timestamp": 1511373362469, + "version": "2.2.2" + }, + "libgdal-2.2.2-h2422bbf_1.conda": { + "build": "h2422bbf_1", + "build_number": 1, + "depends": [ + "curl", + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.4,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jpeg >=9b,<10a", + "json-c >=0.12.1,<0.13.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "libpng >=1.6.32,<1.7.0a0", + "libpq >=9.6.6", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "openjpeg >=2.2.0,<3.0a0", + "poppler >=0.60.1,<1.0a0", + "proj4 >=4.9.3,<4.9.4.0a0", + "sqlite >=3.20.1,<4.0a0", + "xerces-c >=3.2.0,<3.3.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "661da1086326a41f06f08688917cac90", + "name": "libgdal", + "sha256": "7cba734ed5144596c906d3dd3807855a68bc4247187df091aeff904c62081075", + "size": 10419075, + "subdir": "linux-64", + "timestamp": 1511373363420, + "version": "2.2.2" + }, + "libgdal-2.2.2-h6bd4d82_1.conda": { + "build": "h6bd4d82_1", + "build_number": 1, + "depends": [ + "curl", + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.4,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jpeg >=9b,<10a", + "json-c >=0.12.1,<0.13.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "libpng >=1.6.32,<1.7.0a0", + "libpq >=9.6.6", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "openjpeg >=2.2.0,<3.0a0", + "poppler >=0.60.1,<1.0a0", + "proj4 >=4.9.3,<4.9.4.0a0", + "sqlite >=3.20.1,<4.0a0", + "xerces-c >=3.2.0,<3.3.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "c3972ebc52da187b45a3c3203f64308b", + "name": "libgdal", + "sha256": "f3718355bf36236d7765a588c9b4e58c10ee8121a79e8fb2fff461b50134d036", + "size": 10522985, + "subdir": "linux-64", + "timestamp": 1511390349717, + "version": "2.2.2" + }, + "libgdal-2.2.2-h804cdde_1.conda": { + "build": "h804cdde_1", + "build_number": 1, + "depends": [ + "curl", + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.4,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jpeg >=9b,<10a", + "json-c >=0.12.1,<0.13.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "libpng >=1.6.32,<1.7.0a0", + "libpq >=9.6.6", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "openjpeg >=2.2.0,<3.0a0", + "poppler >=0.60.1,<1.0a0", + "proj4 >=4.9.3,<4.9.4.0a0", + "sqlite >=3.20.1,<4.0a0", + "xerces-c >=3.2.0,<3.3.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "54893405b7c40b5db0281cf770fa6968", + "name": "libgdal", + "sha256": "955eb7ccd43fbdd23b210712d54d92f3d603f57e875039bfc1c34132c1783e19", + "size": 10501413, + "subdir": "linux-64", + "timestamp": 1511390362915, + "version": "2.2.2" + }, + "libgdal-2.2.4-h6f639c0_1.conda": { + "build": "h6f639c0_1", + "build_number": 1, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.60.0,<8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libpq >=10.3,<11.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.0.2o,<1.0.3a", + "pcre >=8.42,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "sqlite >=3.24.0,<4.0a0", + "xerces-c >=3.2.1,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "bdd1f49bb2a13b2ce5f853d0e432ec03", + "name": "libgdal", + "sha256": "0213604c8c2240ff69820b1ab1552e85e5909361fbfcbb23b00f9dcd39251330", + "size": 10528177, + "subdir": "linux-64", + "timestamp": 1530872128937, + "version": "2.2.4" + }, + "libgdal-2.2.4-h864d619_1.conda": { + "build": "h864d619_1", + "build_number": 1, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.60.0,<8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libpq >=10.3,<11.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "pcre >=8.42,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "proj4 >=4.9.3,<4.9.4.0a0", + "sqlite >=3.23.1,<4.0a0", + "xerces-c >=3.2.1,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "525facf5375fff87d5a7cacb5c08668e", + "name": "libgdal", + "sha256": "86561ca2cdaf2b40379c7dd6764dd555fca61f3777bfc2e6f20e2eacf40bcbfc", + "size": 10516912, + "subdir": "linux-64", + "timestamp": 1527912262110, + "version": "2.2.4" + }, + "libgdal-2.2.4-hc8d23f9_1.conda": { + "build": "hc8d23f9_1", + "build_number": 1, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.60.0,<8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libpq >=10.3,<11.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "pcre >=8.42,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "proj4 >=4.9.3,<4.9.4.0a0", + "sqlite >=3.23.1,<4.0a0", + "xerces-c >=3.2.1,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "c0334a87ef2075b0239a7096adf6110d", + "name": "libgdal", + "sha256": "262889264e1a4e9fc52c3e439b684deeadaa1560214885c195a81fe7621455c3", + "size": 10493272, + "subdir": "linux-64", + "timestamp": 1527912267707, + "version": "2.2.4" + }, + "libgdal-2.2.4-heea9cce_1.conda": { + "build": "heea9cce_1", + "build_number": 1, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.60.0,<8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libpq >=10.3,<11.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.0.2o,<1.0.3a", + "pcre >=8.42,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "sqlite >=3.24.0,<4.0a0", + "xerces-c >=3.2.1,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "7fb55114580fbee9b245363967661484", + "name": "libgdal", + "sha256": "7f681130ae2135f5acc8d44f0323d2c678e67b0790ff5ddbfbd2a9badb94a2f4", + "size": 10486247, + "subdir": "linux-64", + "timestamp": 1530871137278, + "version": "2.2.4" + }, + "libgdal-2.3.0-h6f639c0_1.conda": { + "build": "h6f639c0_1", + "build_number": 1, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.60.0,<8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libpq >=10.3,<11.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.0.2o,<1.0.3a", + "pcre >=8.42,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "sqlite >=3.24.0,<4.0a0", + "xerces-c >=3.2.1,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "dc0cbe9365d40c391eb1d76530227ac9", + "name": "libgdal", + "sha256": "85f14d546371fd46a264f2cbbf9afa505e977f8ddf1d69ec3bba24696def8402", + "size": 11168371, + "subdir": "linux-64", + "timestamp": 1530870526950, + "version": "2.3.0" + }, + "libgdal-2.3.0-heea9cce_1.conda": { + "build": "heea9cce_1", + "build_number": 1, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.60.0,<8.0a0", + "libdap4 >=3.19.0,<3.20.0a0", + "libgcc-ng >=7.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libpq >=10.3,<11.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.0.2o,<1.0.3a", + "pcre >=8.42,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "sqlite >=3.24.0,<4.0a0", + "xerces-c >=3.2.1,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "f13b145accafcbcb7c9f38cf068b7720", + "name": "libgdal", + "sha256": "3d6d0432512c08d88c2a1b7db733a2ffadf08cf26b9e46e75ed81177ecb38574", + "size": 11168179, + "subdir": "linux-64", + "timestamp": 1530869539802, + "version": "2.3.0" + }, + "libgdal-2.3.2-h9d4a965_0.conda": { + "build": "h9d4a965_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.61.1,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=7.3.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.35,<1.7.0a0", + "libpq >=10.5,<11.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.0.2p,<1.0.3a", + "pcre >=8.42,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "sqlite >=3.25.3,<4.0a0", + "xerces-c >=3.2.2,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "339d4987b49b7e7d7f0050adac35764a", + "name": "libgdal", + "sha256": "d1fb8dc990b095d9148ba9e1c4dacec85f2018209f690559dfc7d4a5f7d1bcc9", + "size": 11629322, + "subdir": "linux-64", + "timestamp": 1544655823241, + "version": "2.3.2" + }, + "libgdal-2.3.2-hda2fc8e_0.conda": { + "build": "hda2fc8e_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.61.1,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=7.3.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.35,<1.7.0a0", + "libpq >=10.5,<11.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.0.2p,<1.0.3a", + "pcre >=8.42,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "sqlite >=3.25.3,<4.0a0", + "xerces-c >=3.2.2,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "320316e128fd1c27526f478d63dc2f67", + "name": "libgdal", + "sha256": "5ecdaab9d9c3d4457d60005078e3987976ed0872e245091b8e48151c93a84e82", + "size": 11630412, + "subdir": "linux-64", + "timestamp": 1544661591241, + "version": "2.3.2" + }, + "libgdal-2.3.3-h2e7e64b_0.conda": { + "build": "h2e7e64b_0", + "build_number": 0, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.7.1,<3.7.2.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.63.0,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=7.3.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.35,<1.7.0a0", + "libpq >=11.1,<12.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1a,<1.1.2a", + "pcre >=8.42,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "proj4 >=5.2.0,<5.2.1.0a0", + "sqlite >=3.26.0,<4.0a0", + "xerces-c >=3.2.2,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "287f5dcef7db97d72d453c948a31f294", + "name": "libgdal", + "sha256": "9f2b3211ee0c4ab4a2406bd9cb57bf37ffff1ad148d967a410a3e9a79deb8249", + "size": 11630605, + "subdir": "linux-64", + "timestamp": 1545408403571, + "version": "2.3.3" + }, + "libgdal-3.0.2-h1d2d1f6_3.conda": { + "build": "h1d2d1f6_3", + "build_number": 3, + "depends": [ + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.2.10,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.14,<1.5.0a0", + "libcurl >=7.82.0,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=11.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libwebp-base", + "libxml2 >=2.9.14,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1q,<1.1.2a", + "pcre >=8.45,<9.0a0", + "poppler >=0.81.0,<1.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.38.5,<4.0a0", + "tiledb >=2.3.3,<2.4.0a0", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "md5": "5e4ec55393073005134d1d24567a9e49", + "name": "libgdal", + "sha256": "e9d8c057e6ae4011a6de7ee0860ed9de1cd5024e25abd06443b63a18d36abfae", + "size": 13018020, + "subdir": "linux-64", + "timestamp": 1657806613512, + "version": "3.0.2" + }, + "libgdal-3.0.2-h20ab51d_0.conda": { + "build": "h20ab51d_0", + "build_number": 0, + "depends": [ + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.2.10,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9d,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.14,<1.5.0a0", + "libcurl >=7.80.0,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=7.5.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.12,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1m,<1.1.2a", + "pcre >=8.45,<9.0a0", + "poppler >=0.81.0,<1.0a0", + "postgresql", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.37.0,<4.0a0", + "tiledb >=2.2,<3.0a0", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "md5": "376fd061089ba91f6d56eb6bcefa5cbb", + "name": "libgdal", + "sha256": "e717cd8ad67a0891e3a773bda976095e5ad319eeb7dd2c163255fa968ed62263", + "size": 12285629, + "subdir": "linux-64", + "timestamp": 1642506825271, + "version": "3.0.2" + }, + "libgdal-3.0.2-h27ab9cc_0.conda": { + "build": "h27ab9cc_0", + "build_number": 0, + "depends": [ + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.2.6,<3.0a0", + "freexl >=1.0.5,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.5.1,<1.6.0a0", + "giflib >=5.1.4,<5.2.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.7,<1.4.8.0a0", + "libcurl >=7.65.3,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=7.3.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=11.2,<12.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.9,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1d,<1.1.2a", + "pcre >=8.43,<9.0a0", + "poppler >=0.65.0,<1.0a0", + "postgresql", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.30.1,<4.0a0", + "tiledb >=1.6.3,<2.0a0", + "xerces-c >=3.2.2,<3.3.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "md5": "623cbaae51fc894ca2acd529239a5845", + "name": "libgdal", + "sha256": "2bed9882e2d86396aa2af5b3fa11f66b422431f3c6758e044fa0d8126eaa1d61", + "size": 12271671, + "subdir": "linux-64", + "timestamp": 1573574427624, + "version": "3.0.2" + }, + "libgdal-3.0.2-h7c14f60_1.conda": { + "build": "h7c14f60_1", + "build_number": 1, + "depends": [ + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.2.10,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.6.0,<1.7.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.14,<1.5.0a0", + "libcurl >=7.71.1,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=7.3.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.2,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.10,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1k,<1.1.2a", + "pcre >=8.44,<9.0a0", + "poppler >=0.81.0,<1.0a0", + "postgresql", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.35.4,<4.0a0", + "tiledb >=2.2,<3.0a0", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "md5": "0e097a667222de143e5ec0fe708c85bc", + "name": "libgdal", + "sha256": "e94293ca9876a005f42bad76b9ed04aac2c837146ce0d61898baac35a97e9862", + "size": 12278038, + "subdir": "linux-64", + "timestamp": 1622392825455, + "version": "3.0.2" + }, + "libgdal-3.0.2-he6cead7_2.conda": { + "build": "he6cead7_2", + "build_number": 2, + "depends": [ + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.2.10,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9d,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.14,<1.5.0a0", + "libcurl >=7.80.0,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=7.5.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libwebp-base", + "libxml2 >=2.9.12,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1m,<1.1.2a", + "pcre >=8.45,<9.0a0", + "poppler >=0.81.0,<1.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.37.0,<4.0a0", + "tiledb >=2.2,<3.0a0", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "md5": "1a907299d2f72d9349bde9a2722d22ec", + "name": "libgdal", + "sha256": "b82b631baba9f7c1c33c68d603cc592d59e779d304158007c6651e8243e5b19d", + "size": 12284489, + "subdir": "linux-64", + "timestamp": 1643382592086, + "version": "3.0.2" + }, + "libgdal-3.0.2-hf71aff0_5.conda": { + "build": "hf71aff0_5", + "build_number": 5, + "depends": [ + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "json-c >=0.16,<0.17.0a0", + "kealib >=1.4.14,<1.5.0a0", + "libcurl >=7.86.0,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=11.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.41.5,<2.0a0", + "libwebp-base", + "libxml2 >=2.9.14,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1s,<1.1.2a", + "pcre >=8.45,<9.0a0", + "poppler >=0.81.0,<1.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tiledb >=2.3.3,<2.4.0a0", + "xerces-c >=3.2.4,<3.3.0a0", + "xz >=5.2.8,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "efba63b290d06b746e7fd1c7525876da", + "name": "libgdal", + "sha256": "ddc86b69a58525e3f25a724d33bbe3967bf17d992ea6d2a3c1603f99706f71e3", + "size": 19834253, + "subdir": "linux-64", + "timestamp": 1673971850418, + "version": "3.0.2" + }, + "libgdal-3.0.2-hf71aff0_6.conda": { + "build": "hf71aff0_6", + "build_number": 6, + "depends": [ + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "json-c >=0.16,<0.17.0a0", + "kealib >=1.4.14,<1.5.0a0", + "libcurl >=7.86.0,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=11.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.41.5,<2.0a0", + "libwebp-base", + "libxml2 >=2.9.14,<2.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1s,<1.1.2a", + "pcre >=8.45,<9.0a0", + "poppler >=0.81.0,<1.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tiledb >=2.3.3,<2.4.0a0", + "xerces-c >=3.2.4,<3.3.0a0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "310cca5bd2f40255ccca4d21a4c22b02", + "name": "libgdal", + "sha256": "8ad4ace386828ea83c9ba6d5d5985cbd6a0fc1e6dea23c5c6431d36ce9a0a42a", + "size": 19891847, + "subdir": "linux-64", + "timestamp": 1673992462294, + "version": "3.0.2" + }, + "libgdal-3.4.1-h05199a0_1.conda": { + "build": "h05199a0_1", + "build_number": 1, + "depends": [ + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.2.10,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.14,<1.5.0a0", + "libcurl >=7.82.0,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=11.2.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf 4.8.*", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libwebp-base", + "libxml2 >=2.9.14,<2.10.0a0", + "lz4-c", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1o,<1.1.2a", + "pcre >=8.45,<9.0a0", + "poppler >=0.81.0,<1.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.38.3,<4.0a0", + "tiledb >=2.3.3,<2.4.0a0", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "528e9245fa09cfbaf2b604eda1c3d92e", + "name": "libgdal", + "sha256": "08ae117dd302b6b4f8405b1b65dfceca3f541e87a3df1594297f2f920f29b358", + "size": 20468055, + "subdir": "linux-64", + "timestamp": 1656058258624, + "version": "3.4.1" + }, + "libgdal-3.4.1-hdd9df00_0.conda": { + "build": "hdd9df00_0", + "build_number": 0, + "depends": [ + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.2.10,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9d,<10a", + "json-c >=0.13.1,<0.14.0a0", + "kealib >=1.4.14,<1.5.0a0", + "libcurl >=7.80.0,<8.0a0", + "libdap4 >=3.19.1,<3.20.0a0", + "libgcc-ng >=7.5.0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf 4.8.*", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.0.3,<2.0a0", + "libwebp-base", + "libxml2 >=2.9.12,<2.10.0a0", + "lz4-c", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1m,<1.1.2a", + "pcre >=8.45,<9.0a0", + "poppler >=0.81.0,<1.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.37.0,<4.0a0", + "tiledb >=2.2,<3.0a0", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd" + ], + "license": "MIT", + "md5": "e3454698ad25de375806ab74d3c715df", + "name": "libgdal", + "sha256": "7ed1053be1e87ccccf1a9e939a7019bde7b49da63ea9c503d4de0903fbada4a5", + "size": 18055294, + "subdir": "linux-64", + "timestamp": 1643735898947, + "version": "3.4.1" + }, + "libgdal-3.6.0-hc0e11bb_0.conda": { + "build": "hc0e11bb_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "json-c >=0.16,<0.17.0a0", + "kealib >=1.5.0,<1.6.0a0", + "lerc >=3.0,<4.0a0", + "libcurl >=7.87.0,<8.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libiconv >=1.16,<2.0a0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.41.5,<2.0a0", + "libwebp-base", + "libxml2 >=2.9.14,<2.10.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre2 >=10.37,<10.38.0a0", + "poppler", + "postgresql", + "proj >=6.2.1,<6.2.2.0a0", + "qhull >=2020.2,<2020.3.0a0", + "sqlite >=3.40.1,<4.0a0", + "tiledb >=2.3.3,<2.4.0a0", + "xerces-c >=3.2.4,<3.3.0a0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa474502fa3155c6078db63f7bd13aad", + "name": "libgdal", + "sha256": "97e051d562ae39990406f95cbbe5e7fa1e62b5e0c72d85dfb5f8a139ca3b875d", + "size": 10942886, + "subdir": "linux-64", + "timestamp": 1676727131097, + "version": "3.6.0" + }, + "libgdal-3.6.0-hc0e11bb_1.conda": { + "build": "hc0e11bb_1", + "build_number": 1, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "json-c >=0.16,<0.17.0a0", + "kealib >=1.5.0,<1.6.0a0", + "lerc >=3.0,<4.0a0", + "libcurl >=7.87.0,<8.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libiconv >=1.16,<2.0a0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.41.5,<2.0a0", + "libwebp-base", + "libxml2 >=2.9.14,<2.10.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre2 >=10.37,<10.38.0a0", + "poppler", + "postgresql", + "proj >=6.2.1,<6.2.2.0a0", + "qhull >=2020.2,<2020.3.0a0", + "sqlite >=3.40.1,<4.0a0", + "tiledb >=2.3.3,<2.4.0a0", + "xerces-c >=3.2.4,<3.3.0a0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5849ada82061a8d8af08ba1c4745edc3", + "name": "libgdal", + "sha256": "85a0101bf726961abe843147b18b338df61eb5be1cbe5927c9c7353df90c14e0", + "size": 10942098, + "subdir": "linux-64", + "timestamp": 1677574346815, + "version": "3.6.0" + }, + "libgdal-3.6.2-hc0e11bb_0.conda": { + "build": "hc0e11bb_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "json-c >=0.16,<0.17.0a0", + "kealib >=1.5.0,<1.6.0a0", + "lerc >=3.0,<4.0a0", + "libcurl >=7.87.0,<8.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libiconv >=1.16,<2.0a0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.39,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.41.5,<2.0a0", + "libwebp-base", + "libxml2 >=2.9.14,<2.10.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre2 >=10.37,<10.38.0a0", + "poppler", + "postgresql", + "proj >=6.2.1,<6.2.2.0a0", + "qhull", + "sqlite >=3.40.1,<4.0a0", + "tiledb >=2.3.3,<2.4.0a0", + "xerces-c >=3.2.4,<3.3.0a0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1aa7a0c1ca383bf108a986ba7d6c9ea9", + "name": "libgdal", + "sha256": "4eeab2b34d0808d983f7e546e255111bc55db252e1d02eb39d3c0b0c6168c29f", + "size": 11147461, + "subdir": "linux-64", + "timestamp": 1678138645438, + "version": "3.6.2" + }, + "libgdal-3.6.2-hc0e11bb_1.conda": { + "build": "hc0e11bb_1", + "build_number": 1, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "blosc >=1.21.3,<2.0a0", + "cfitsio >=3.470,<3.471.0a0", + "expat >=2.4.9,<3.0a0", + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "geotiff >=1.7.0,<1.8.0a0", + "giflib >=5.2.1,<5.3.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "json-c >=0.16,<0.17.0a0", + "kealib >=1.5.0,<1.6.0a0", + "lerc >=3.0,<4.0a0", + "libcurl >=7.88.1,<8.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libiconv >=1.16,<2.0a0", + "libkml >=1.3.0,<1.4.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "libpng >=1.6.39,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libspatialite >=4.3.0a,<4.4.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libuuid >=1.41.5,<2.0a0", + "libwebp-base", + "libxml2 >=2.10.3,<2.11.0a0", + "lz4-c >=1.9.4,<1.10.0a0", + "openjpeg >=2.3.0,<3.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre2 >=10.37,<10.38.0a0", + "poppler", + "postgresql", + "proj >=6.2.1,<6.2.2.0a0", + "qhull", + "sqlite >=3.41.1,<4.0a0", + "tiledb >=2.3.3,<2.4.0a0", + "xerces-c >=3.2.4,<3.3.0a0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9774221344a279e154892563679726d2", + "name": "libgdal", + "sha256": "a8961f54dba6890d5d2b9ec29e727b73547a78f6757335166cf7444e05ab50a1", + "size": 11148784, + "subdir": "linux-64", + "timestamp": 1680121032785, + "version": "3.6.2" + }, + "libgfortran-ng-11.2.0-h00389a5_0.conda": { + "build": "h00389a5_0", + "build_number": 0, + "depends": [ + "libgfortran5 11.2.0.*", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "a6a0e722ca98bb19b72252872de15fb3", + "name": "libgfortran-ng", + "sha256": "cd7e1ae739aafdd40c765862f95ca46435479578e9729a00eea872382372de93", + "size": 20224, + "subdir": "linux-64", + "timestamp": 1652859734310, + "version": "11.2.0" + }, + "libgfortran-ng-11.2.0-h00389a5_1.conda": { + "build": "h00389a5_1", + "build_number": 1, + "depends": [ + "libgfortran5 11.2.0.*", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "7429b67ab7b1d7cb99b9d1f3ddaec6e3", + "name": "libgfortran-ng", + "sha256": "228ecd4c12468e9f5e2e1806e02309f83b9fdbc5860efd3b34afc8be52b86511", + "size": 20217, + "subdir": "linux-64", + "timestamp": 1654090819660, + "version": "11.2.0" + }, + "libgfortran-ng-5.4.0-hdf63c60_3.conda": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [], + "license": "GPL", + "md5": "58ed2a98c943cd3f357fe1d5a192b08d", + "name": "libgfortran-ng", + "sha256": "5d85747c025b7b3c60945a2dfeed1ee7258d84315f7f129ccfaaa3370a06b7ee", + "size": 759444, + "subdir": "linux-64", + "timestamp": 1520969513418, + "version": "5.4.0" + }, + "libgfortran-ng-7.2.0-h6fcbd8e_1.conda": { + "build": "h6fcbd8e_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "db07693604dc5e0b62b59b83bc3084b9", + "name": "libgfortran-ng", + "sha256": "699eeb6349505dd2552938c58fec10e9ce71c5f03202484a96e242f2aee2f36a", + "size": 300682, + "subdir": "linux-64", + "timestamp": 1505665568036, + "version": "7.2.0" + }, + "libgfortran-ng-7.2.0-h9f7466a_2.conda": { + "build": "h9f7466a_2", + "build_number": 2, + "depends": [], + "license": "GPL", + "md5": "ef2d2f571154b9e5dff29f7ded19a95a", + "name": "libgfortran-ng", + "sha256": "387255ce216c95a541f9c154c55c66416a788dcdd6fbce93f1bdae141110bf9d", + "size": 302358, + "subdir": "linux-64", + "timestamp": 1507262726991, + "version": "7.2.0" + }, + "libgfortran-ng-7.2.0-hdf63c60_3.conda": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [], + "license": "GPL", + "md5": "68117d137e8fbc14e083eef80b1c5218", + "name": "libgfortran-ng", + "sha256": "3318cad7615a8adef8c829320fed03040ec4a197e01bb630b4c7af5184dc00bb", + "size": 1000558, + "subdir": "linux-64", + "timestamp": 1520534517851, + "version": "7.2.0" + }, + "libgfortran-ng-7.3.0-hdf63c60_0.conda": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [], + "license": "GPL", + "md5": "e3e10877b7ee2bdd3f67f6d4d4e32e00", + "name": "libgfortran-ng", + "sha256": "5fc07f818aca5df283f804026f991a4e5db2b2e29959def155e36ce9b9b26def", + "size": 1030197, + "subdir": "linux-64", + "timestamp": 1534628456385, + "version": "7.3.0" + }, + "libgfortran-ng-7.5.0-ha8ba4b0_17.conda": { + "build": "ha8ba4b0_17", + "build_number": 17, + "depends": [ + "libgfortran4 7.5.0.*", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "ecb35c8952579d5c8dc56c6e076ba948", + "name": "libgfortran-ng", + "sha256": "f962258281d978f7b0e8207304531a60860c2e54cf2f2e59ae380d22fe10f1d2", + "size": 22460, + "subdir": "linux-64", + "timestamp": 1622660084422, + "version": "7.5.0" + }, + "libgfortran-ng-8.2.0-hdf63c60_0.conda": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [], + "license": "GPL", + "md5": "71943f47ec49cff5dd65f53197155a73", + "name": "libgfortran-ng", + "sha256": "c107b8df9d62cc3fae9e39112bd797612236ca8c5ba10ee7faf8a66695cbb5c9", + "size": 1367344, + "subdir": "linux-64", + "timestamp": 1534277508708, + "version": "8.2.0" + }, + "libgfortran-ng-8.2.0-hdf63c60_1.conda": { + "build": "hdf63c60_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "29c0ef7e284d741937c7c26ae3250bbd", + "name": "libgfortran-ng", + "sha256": "d3eb0564dcb9696089bfa66008001a9c5f01e369b3dfa64c35c6c438b58e7825", + "size": 1362964, + "subdir": "linux-64", + "timestamp": 1534516119090, + "version": "8.2.0" + }, + "libgfortran-ng-8.4.0-he6ba991_17.conda": { + "build": "he6ba991_17", + "build_number": 17, + "depends": [ + "libgfortran5 8.4.0.*", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "72dc32f8df8e8898f740a65a0aa1de6e", + "name": "libgfortran-ng", + "sha256": "fbae230e8356aafa82ac1f33d880395474e8275a93f29c140bfe18edb0591638", + "size": 22447, + "subdir": "linux-64", + "timestamp": 1622661689809, + "version": "8.4.0" + }, + "libgfortran-ng-9.3.0-ha5ec8a7_17.conda": { + "build": "ha5ec8a7_17", + "build_number": 17, + "depends": [ + "libgfortran5 9.3.0.*", + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "1e6b98f15e9ff3a0a54b8256500cc4e1", + "name": "libgfortran-ng", + "sha256": "d3f33865f55a3adbf61b74f2e8b38e37fd4e03752ef831ab8ed822992149aebe", + "size": 22431, + "subdir": "linux-64", + "timestamp": 1622663339018, + "version": "9.3.0" + }, + "libgfortran4-7.5.0-ha8ba4b0_17.conda": { + "build": "ha8ba4b0_17", + "build_number": 17, + "constrains": [ + "libgfortran-ng 7.5.0 *_17" + ], + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "e3883581cbf0a98672250c3e80d292bf", + "name": "libgfortran4", + "sha256": "66d9ef6bbf134d7d39b39d79b48b7abccc042405880ab9c2a1799dabc78cf590", + "size": 1019163, + "subdir": "linux-64", + "timestamp": 1622660038350, + "version": "7.5.0" + }, + "libgfortran5-11.2.0-h1234567_0.conda": { + "build": "h1234567_0", + "build_number": 0, + "constrains": [ + "libgfortran-ng 11.2.0 *_0" + ], + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "d560aa70d6402acbaaa57537ecc6fb56", + "name": "libgfortran5", + "sha256": "1f3c98a9489ea35fe0e6aaf34f36bc3216234770c90f0ab1670b6b2772ebccaa", + "size": 2134669, + "subdir": "linux-64", + "timestamp": 1652859678573, + "version": "11.2.0" + }, + "libgfortran5-11.2.0-h1234567_1.conda": { + "build": "h1234567_1", + "build_number": 1, + "constrains": [ + "libgfortran-ng 11.2.0 *_1" + ], + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "36a01a8c30e0cadf0d3e842c50b73f3b", + "name": "libgfortran5", + "sha256": "83df17eb4be4232b6616f4a713624fab63cd8c41ea9957941b85e302b8954268", + "size": 2134559, + "subdir": "linux-64", + "timestamp": 1654090762569, + "version": "11.2.0" + }, + "libgfortran5-8.4.0-he6ba991_17.conda": { + "build": "he6ba991_17", + "build_number": 17, + "constrains": [ + "libgfortran-ng 8.4.0 *_17" + ], + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "3e6cc3b4b0e67d7b8dd808036bfc7e30", + "name": "libgfortran5", + "sha256": "69b86929703d2d3b705a28095b1989f35fdced8b80ade505f313eb033a247ab5", + "size": 1375659, + "subdir": "linux-64", + "timestamp": 1622661646530, + "version": "8.4.0" + }, + "libgfortran5-9.3.0-ha5ec8a7_17.conda": { + "build": "ha5ec8a7_17", + "build_number": 17, + "constrains": [ + "libgfortran-ng 9.3.0 *_17" + ], + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "15c36fe92a9a3e329a07fcb45d07be89", + "name": "libgfortran5", + "sha256": "c213462ac5715b2cb160aad0790e0317654a52e35b28a18497c1d2e7d9d4ac98", + "size": 1533212, + "subdir": "linux-64", + "timestamp": 1622663293084, + "version": "9.3.0" + }, + "libgit2-1.5.0-ha637b67_0.conda": { + "build": "ha637b67_0", + "build_number": 0, + "depends": [ + "curl", + "libgcc-ng >=11.2.0", + "libssh2 >=1.10.0,<2.0a0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1q,<1.1.2a", + "pcre2 >=10.37,<10.38.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-only WITH GCC-exception-2.0", + "license_family": "GPL2", + "md5": "e475112f1a6cec92b702678ea78d6823", + "name": "libgit2", + "sha256": "2b34304e863a0c86b09dc220a224196aba89e320cea9a91d91b1ea88ae3862b1", + "size": 920946, + "subdir": "linux-64", + "timestamp": 1667503279109, + "version": "1.5.0" + }, + "libglu-9.0.0-h0c0bdc1_1.conda": { + "build": "h0c0bdc1_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "SGI-2", + "md5": "5b3cca2be580f38c512928dcc3fc49a9", + "name": "libglu", + "sha256": "120726b865ef3f3977b413271e5a30f69ef6b39d2b813c16dc9db0f172fe0f94", + "size": 319874, + "subdir": "linux-64", + "timestamp": 1507908736126, + "version": "9.0.0" + }, + "libglu-9.0.0-hf484d3e_1.conda": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "SGI-2", + "md5": "0a985c66d84d7bba59d31952eebb0e57", + "name": "libglu", + "sha256": "a8ce73f6cc1ff30ad8e41a034ed597a8253508e27b90eb927b831d50bfefb4b5", + "size": 277231, + "subdir": "linux-64", + "timestamp": 1530807703852, + "version": "9.0.0" + }, + "libgomp-11.2.0-h1234567_0.conda": { + "build": "h1234567_0", + "build_number": 0, + "depends": [ + "_libgcc_mutex 0.1 main" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "c8acb8d9aff1ead1b273ace299ca12d2", + "name": "libgomp", + "sha256": "af5e140f4545d54aaa12c263879b0f9c0d6a30b5d1e7735d85a1eb70bc64d50a", + "size": 484673, + "subdir": "linux-64", + "timestamp": 1652859691785, + "version": "11.2.0" + }, + "libgomp-11.2.0-h1234567_1.conda": { + "build": "h1234567_1", + "build_number": 1, + "depends": [ + "_libgcc_mutex 0.1 main" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "b372c0eea9b60732fdae4b817a63c8cd", + "name": "libgomp", + "sha256": "a1c6e599df45e116af81c36ec4c9efb1793fa3a0b854dd90dd6c8813cd476e90", + "size": 485145, + "subdir": "linux-64", + "timestamp": 1654090775721, + "version": "11.2.0" + }, + "libgomp-7.5.0-h5101ec6_17.conda": { + "build": "h5101ec6_17", + "build_number": 17, + "depends": [ + "_libgcc_mutex 0.1 main" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "08a2bb8ce6185714332bafdfd335ce2b", + "name": "libgomp", + "sha256": "45a8a10c8126fa3f2a5fb01813826f5a51b79be67b105c33626c2a00a2bdd6bc", + "size": 246376, + "subdir": "linux-64", + "timestamp": 1622660050908, + "version": "7.5.0" + }, + "libgomp-8.4.0-h5101ec6_17.conda": { + "build": "h5101ec6_17", + "build_number": 17, + "depends": [ + "_libgcc_mutex 0.1 main" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "fbd13189c2c1137c9fe0bc1af598a4fb", + "name": "libgomp", + "sha256": "aaf2d18200d8530fb4178962b8f417eb0cedfd8beb60bd68f3f548264bfe7838", + "size": 278153, + "subdir": "linux-64", + "timestamp": 1622661660057, + "version": "8.4.0" + }, + "libgomp-9.3.0-h5101ec6_17.conda": { + "build": "h5101ec6_17", + "build_number": 17, + "depends": [ + "_libgcc_mutex 0.1 main" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "fb19b69bac6d819c7f3d1126b05461e1", + "name": "libgomp", + "sha256": "b53f7b4d5a1a3a3d61ad86b043f91a0ca9ee16b77194021383185d34eb592e56", + "size": 318078, + "subdir": "linux-64", + "timestamp": 1622663306647, + "version": "9.3.0" + }, + "libgpg-error-1.27-h14c3975_2.conda": { + "build": "h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "4cc44ab385a48383ee854aee07b754b4", + "name": "libgpg-error", + "sha256": "757a477ee3f9f5294ec2044dfe33ee32fd611a59db731ba30f897716e4349a68", + "size": 176362, + "subdir": "linux-64", + "timestamp": 1515696704892, + "version": "1.27" + }, + "libgpg-error-1.29-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "86477e38d1fef18fabb6e4b1b1d513a7", + "name": "libgpg-error", + "sha256": "1e6530025ee3e1e3382ffe0881a8a24ba3a828d15974b6aedbb9ec8a39e8747e", + "size": 217068, + "subdir": "linux-64", + "timestamp": 1523953940896, + "version": "1.29" + }, + "libgpg-error-1.31-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "39307efb015203caa45ec92c88753377", + "name": "libgpg-error", + "sha256": "7f97820cf115e0ea4aededc2178a899cd925deab59759517a543e31ea23482c7", + "size": 222119, + "subdir": "linux-64", + "timestamp": 1527179944603, + "version": "1.31" + }, + "libgpg-error-1.32-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "b58f087c9cc5651c32bc4c6235e47566", + "name": "libgpg-error", + "sha256": "7ee9aae105fd171c466ee3b0bdaafa94599dfb1f52873384b867a081e899b534", + "size": 223832, + "subdir": "linux-64", + "timestamp": 1532875867442, + "version": "1.32" + }, + "libgpg-error-1.39-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "609c97622ae11991465baed8ee43bf0f", + "name": "libgpg-error", + "sha256": "99e9e86776a3b6c59d123d772720be910e9a56892f0790ab5510243a81b9e83a", + "size": 239660, + "subdir": "linux-64", + "timestamp": 1601491507911, + "version": "1.39" + }, + "libgpg-error-1.41-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "c416bbca5226dd9369cdb47d2e22c83d", + "name": "libgpg-error", + "sha256": "129415b6c3c1b72e57dd2ae4ef966434cfd713608b3662eda0193b9a0ff487db", + "size": 241061, + "subdir": "linux-64", + "timestamp": 1608576978124, + "version": "1.41" + }, + "libgpg-error-1.42-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-2.0", + "license_family": "GPL2", + "md5": "0cd7211a9f9c59cbceb1ce3313087020", + "name": "libgpg-error", + "sha256": "a2f21664b8941b88a81d56c891a92eea94f38eff57a01bef5c84db25c8a347a5", + "size": 245927, + "subdir": "linux-64", + "timestamp": 1616440454143, + "version": "1.42" + }, + "libgpuarray-0.7.5-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "ISC", + "md5": "c6083d1fe26f28dd4cd7c3efcc30dd4e", + "name": "libgpuarray", + "sha256": "4655a3ca37fc909921aa4e58c96449fa0fdcf5f2c13313f943815335ad052089", + "size": 217315, + "subdir": "linux-64", + "timestamp": 1515100476747, + "version": "0.7.5" + }, + "libgpuarray-0.7.6-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "ISC", + "md5": "3d5eaae0d05b246851b31b3d03f77c18", + "name": "libgpuarray", + "sha256": "de607361868cab24591f920af743689b35373f90000d7c519ebbd9616e07fac5", + "size": 217134, + "subdir": "linux-64", + "timestamp": 1526494991655, + "version": "0.7.6" + }, + "libgpuarray-0.7.6-h7f8727e_1.conda": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "ISC", + "md5": "207bc6eee8f894e8025e5b3dafc3baf4", + "name": "libgpuarray", + "sha256": "bff4f01f5677b4c97b59908fe2b4d6cf137add12a35c93078a31872dd656c81b", + "size": 223591, + "subdir": "linux-64", + "timestamp": 1642510472908, + "version": "0.7.6" + }, + "libgsasl-1.10.0-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "libgcrypt >=1.9.3,<2.0a0", + "libgpg-error >=1.42,<2.0a0", + "libntlm >=1.6,<2.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "d63e18e158b39d5f57b5ea8acd8a2b0f", + "name": "libgsasl", + "sha256": "e10ae0899fb587cc80567db393b7581c958287c423e1516683b54603952f1de2", + "size": 164137, + "subdir": "linux-64", + "timestamp": 1642672232315, + "version": "1.10.0" + }, + "libgsasl-1.8.0-h14c3975_3.conda": { + "build": "h14c3975_3", + "build_number": 3, + "depends": [ + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "libgcrypt >=1.8.0,<2.0a0", + "libntlm >=1.4,<2.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "0244d8ece237cb48c56f3285d7ae36aa", + "name": "libgsasl", + "sha256": "51c6bf61d6b56340d3dbfce7808e367269b5f71411c508895874d32221129982", + "size": 119687, + "subdir": "linux-64", + "timestamp": 1515696923573, + "version": "1.8.0" + }, + "libgsasl-1.8.0-h7b6447c_3.conda": { + "build": "h7b6447c_3", + "build_number": 3, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libgcrypt >=1.8.3,<2.0a0", + "libntlm >=1.4,<2.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "e98152d64ca7c7bba6a8fc69c744090e", + "name": "libgsasl", + "sha256": "ed54ed8313f618007b41ecab15f2ab2b612c99f1e08870378974934b38f9691a", + "size": 121830, + "subdir": "linux-64", + "timestamp": 1540967010187, + "version": "1.8.0" + }, + "libgsf-1.14.50-h622765d_1.conda": { + "build": "h622765d_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "pcre >=8.45,<9.0a0", + "zlib >=1.2.13,<1.2.14", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-only", + "license_family": "GPL", + "md5": "2d61e6838de5c44b6665bdc59e8920a6", + "name": "libgsf", + "sha256": "3b993a4ab99f95182aa187d308a4761d00958b804b79d8ae760cf788d763880f", + "size": 437743, + "subdir": "linux-64", + "timestamp": 1679988293565, + "version": "1.14.50" + }, + "libgsf-1.14.50-hc037cb4_0.conda": { + "build": "hc037cb4_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "pcre >=8.45,<9.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-only", + "license_family": "GPL", + "md5": "e27c1f5bb5334ee36e7cc68db34af99e", + "name": "libgsf", + "sha256": "c6410efffc090d372c8e1e7e268db4ca8d20e1fc2b615f2c18f0b67c247dddd1", + "size": 436344, + "subdir": "linux-64", + "timestamp": 1667992205668, + "version": "1.14.50" + }, + "libhdfs3-2.2.31-hfff6f95_2.conda": { + "build": "hfff6f95_2", + "build_number": 2, + "depends": [ + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "libgsasl >=1.8.0,<2.0a0", + "libntlm >=1.4,<2.0a0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.4,<2.10.0a0" + ], + "license": "Apache 2.0", + "md5": "ff5d96202c3bc8b210e63a4e4d457a00", + "name": "libhdfs3", + "sha256": "1e65dfe36e5d18cf1a14bb703401988e33fac071ae2ec6c399a2b04ccbfcfa94", + "size": 5631673, + "subdir": "linux-64", + "timestamp": 1515697141057, + "version": "2.2.31" + }, + "libhdfs3-2.3.0-h1a0844a_3.conda": { + "build": "h1a0844a_3", + "build_number": 3, + "depends": [ + "krb5 >=1.16.4,<1.17.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libcurl >=7.67.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libgsasl >=1.8.0,<2.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.12,<2.10.0a0", + "openssl >=1.1.1o,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a391d3df17872b53ac3a7add600f7220", + "name": "libhdfs3", + "sha256": "eee5edc40a09fe950245b53179cc59f7a3265485f910665bb609b7c5f1347d57", + "size": 7499265, + "subdir": "linux-64", + "timestamp": 1652943196633, + "version": "2.3.0" + }, + "libhdfs3-2.3.0-h2fca0e8_1.conda": { + "build": "h2fca0e8_1", + "build_number": 1, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libcurl >=7.61.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libgsasl >=1.8.0,<2.0a0", + "libntlm >=1.4,<2.0a0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "Apache 2.0", + "md5": "5939ba77981f21ea870fe1a040cf2871", + "name": "libhdfs3", + "sha256": "117bfb4b78cfb5fc10da64088995219bbc7d7185b265aa60bac7b1e240d5e58c", + "size": 7056042, + "subdir": "linux-64", + "timestamp": 1540968914523, + "version": "2.3.0" + }, + "libhdfs3-2.3.0-h6233a4a_4.conda": { + "build": "h6233a4a_4", + "build_number": 4, + "depends": [ + "krb5 >=1.16.4,<1.17.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libcurl >=7.67.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libgsasl >=1.8.0,<2.0a0", + "libntlm >=1.6,<2.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "libxml2 >=2.10.3,<2.11.0a0", + "openssl >=1.1.1t,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b298eca68a39215e169a813ef41851cb", + "name": "libhdfs3", + "sha256": "e6ac2d3a599e0acea7888907e14f69bb43cb9ec4807625dc7bc3a2c09f3d7680", + "size": 10025165, + "subdir": "linux-64", + "timestamp": 1679578395694, + "version": "2.3.0" + }, + "libhdfs3-2.3.0-h97226ba_1.conda": { + "build": "h97226ba_1", + "build_number": 1, + "depends": [ + "curl >=7.55.1,<8.0a0", + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "libgsasl >=1.8.0,<2.0a0", + "libntlm >=1.4,<2.0a0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.4,<2.10.0a0", + "openssl >=1.0.2n,<1.0.3a" + ], + "license": "Apache 2.0", + "md5": "20150f4993dc3ca17ee615b4c96c9a24", + "name": "libhdfs3", + "sha256": "0e7451f4e4a370f69353ae8fc7ba908738b6c124ec80ec463ef6664a38b64606", + "size": 6557671, + "subdir": "linux-64", + "timestamp": 1515710070367, + "version": "2.3.0" + }, + "libhdfs3-2.3.0-hcdb25c3_2.conda": { + "build": "hcdb25c3_2", + "build_number": 2, + "depends": [ + "krb5 >=1.16.4,<1.17.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libcurl >=7.67.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libgsasl >=1.8.0,<2.0a0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.5.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.12,<2.10.0a0", + "openssl >=1.1.1l,<1.1.2a" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "118a44d65db7bfc1a1b059c601c00a8e", + "name": "libhdfs3", + "sha256": "c7b6c7b34a6b70dd39ede47f5b3dce886f00d4a4ad3923543b1e966da7c52d19", + "size": 7633877, + "subdir": "linux-64", + "timestamp": 1641390579146, + "version": "2.3.0" + }, + "libhdfs3-2.3.0-hd191362_1.conda": { + "build": "hd191362_1", + "build_number": 1, + "depends": [ + "krb5 >=1.14.2,<1.15.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "libgsasl >=1.8.0,<2.0a0", + "libntlm >=1.4,<2.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openssl >=1.0.2o,<1.0.3a" + ], + "license": "Apache 2.0", + "md5": "99a1548a282768be47782c638353dc88", + "name": "libhdfs3", + "sha256": "48e61392f04c7aefb0e9cda5ff88b5b87d0f4732a1a7e12efaa6ea380db767b7", + "size": 6571721, + "subdir": "linux-64", + "timestamp": 1530914264111, + "version": "2.3.0" + }, + "libiconv-1.15-h63c8f33_5.conda": { + "build": "h63c8f33_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL and LGPL", + "md5": "55474411ba274f0c8385417a3e64e08f", + "name": "libiconv", + "sha256": "b434f3127de6c9b651285bf27b0b68071fe04682aadc07041fca7aed4a2c7264", + "size": 738037, + "subdir": "linux-64", + "timestamp": 1505745162898, + "version": "1.15" + }, + "libiconv-1.16-h7f8727e_2.conda": { + "build": "h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL3", + "md5": "80d4bc7d7e58b5f0be41d763f60994f5", + "name": "libiconv", + "sha256": "bcdab81d4856106e7876a40a7b476147861dafd5a8761885463b90796d0fd202", + "size": 753730, + "subdir": "linux-64", + "timestamp": 1650983457202, + "version": "1.16" + }, + "libidn11-1.33-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "LGPLv3", + "license_family": "GPL", + "md5": "75d5c232628eb6701d7a491716243a1f", + "name": "libidn11", + "sha256": "ac2c6287113c7f97c7588abc12608c5aaa07f93a2edf2abccbf362455704f5cb", + "size": 184684, + "subdir": "linux-64", + "timestamp": 1576614314267, + "version": "1.33" + }, + "libidn2-2.3.0-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libunistring >=0,<1.0a0" + ], + "license": "LGPLv2", + "md5": "82f8766953d016a6d076517aa3913291", + "name": "libidn2", + "sha256": "a419fa9d07364384edcac71f155eb0ffda0c0376ca67e2c5f86c919c16c6375a", + "size": 88257, + "subdir": "linux-64", + "timestamp": 1617768421518, + "version": "2.3.0" + }, + "libidn2-2.3.1-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libunistring >=0,<1.0a0" + ], + "license": "LGPLv2 AND LGPL-3.0-or-later AND GPL-3.0-or-later", + "md5": "d1e37d381c0fd10279c4957c0a41fdb0", + "name": "libidn2", + "sha256": "27dca6ab2eb6a81d31401799689c2240131e41d191257379bf48255e0ec22ef1", + "size": 86686, + "subdir": "linux-64", + "timestamp": 1621322982007, + "version": "2.3.1" + }, + "libidn2-2.3.2-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libunistring >=0,<1.0a0" + ], + "license": "LGPLv2 AND LGPL-3.0-or-later AND GPL-3.0-or-later", + "md5": "3ce9977fc2669601f79a2eb360b95fe6", + "name": "libidn2", + "sha256": "b01a53fbdc5881474ff796f9fc0e70bdff3dccf36dd4bf24b8c16054c61cc978", + "size": 83199, + "subdir": "linux-64", + "timestamp": 1626872281578, + "version": "2.3.2" + }, + "libkml-1.3.0-h096b73e_6.conda": { + "build": "h096b73e_6", + "build_number": 6, + "depends": [ + "expat >=2.4.9,<3.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b64ca9cf58d20389e1e0f6ff721ae577", + "name": "libkml", + "sha256": "6dee55339a5d9c7ccdc81111776a61666e1b78add1acdb55e4430e683327a084", + "size": 598271, + "subdir": "linux-64", + "timestamp": 1674197618983, + "version": "1.3.0" + }, + "libkml-1.3.0-h590aaf7_3.conda": { + "build": "h590aaf7_3", + "build_number": 3, + "depends": [ + "expat >=2.2.5,<3.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9b69b1df1f2fe0f069b18186367f5406", + "name": "libkml", + "sha256": "061d3aabbbbebf168c07c657e5c3e7f7596437a9f0db77efb1a48697653ebe0d", + "size": 576900, + "subdir": "linux-64", + "timestamp": 1530868696494, + "version": "1.3.0" + }, + "libkml-1.3.0-h590aaf7_4.conda": { + "build": "h590aaf7_4", + "build_number": 4, + "depends": [ + "expat >=2.2.5,<3.0a0", + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "292281bafceaf7d7112a0dc8fac8d399", + "name": "libkml", + "sha256": "c2517c27b2a9b64035cb41e1cb2d5b3f431f1e6276877fe5fe8bb9be94ad719d", + "size": 577301, + "subdir": "linux-64", + "timestamp": 1530874561085, + "version": "1.3.0" + }, + "libkml-1.3.0-h7ecb851_5.conda": { + "build": "h7ecb851_5", + "build_number": 5, + "depends": [ + "expat >=2.2.10,<3.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "80039bbedf153cc777d6b862e4f45452", + "name": "libkml", + "sha256": "e42a0516d71b461d4221b56861771cb008cf5444f0365e8047f76140b84bce0d", + "size": 586944, + "subdir": "linux-64", + "timestamp": 1622296726318, + "version": "1.3.0" + }, + "libkml-1.3.0-h8777076_2.conda": { + "build": "h8777076_2", + "build_number": 2, + "depends": [ + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dcf4b69299be0002b0d9939c4633244d", + "name": "libkml", + "sha256": "3a85e80686065f529f30b2a6c168f0d4d0958c8468410b69fb98f4597f94776f", + "size": 577755, + "subdir": "linux-64", + "timestamp": 1509502887176, + "version": "1.3.0" + }, + "libkml-1.3.0-h9d32c78_3.conda": { + "build": "h9d32c78_3", + "build_number": 3, + "depends": [ + "expat >=2.2.5,<3.0a0", + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "87caf626e0c7c119edbd7a8f7eef7553", + "name": "libkml", + "sha256": "1f77438bd1a1b84fdf3a95fe61eb7bd6fc1468d65251bec5d9f6399b76900c01", + "size": 577089, + "subdir": "linux-64", + "timestamp": 1510863086949, + "version": "1.3.0" + }, + "liblief-0.10.1-h2531618_1.conda": { + "build": "h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "55892a27327689460123ab176f4bf1a9", + "name": "liblief", + "sha256": "dace9c268a70c09bc37033bfa5107fdf6cc8718f6f431ae23c9dbdb2430e8062", + "size": 1736784, + "subdir": "linux-64", + "timestamp": 1607401876049, + "version": "0.10.1" + }, + "liblief-0.10.1-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e94229a88ed005d459840a76aebf1875", + "name": "liblief", + "sha256": "0e422036cc4a77cb1de0a8dbfa7bfb3e886e3856eaba4e3664864a3d9e5ecce4", + "size": 1732247, + "subdir": "linux-64", + "timestamp": 1588593780971, + "version": "0.10.1" + }, + "liblief-0.11.5-h295c915_1.conda": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c4f381cc194375e3cc5b8b226c34f55d", + "name": "liblief", + "sha256": "be3df8763e2940274a2a991bbf2854a0a7b77cc012c3592add73d16252c395f7", + "size": 1814049, + "subdir": "linux-64", + "timestamp": 1648523621267, + "version": "0.11.5" + }, + "liblief-0.12.3-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9996383fc2561614e4d54490aea33f8e", + "name": "liblief", + "sha256": "35873dd7c288d83b738fd4597cb0ee1466dab75b2e1d43710d540a804da3c42d", + "size": 2024451, + "subdir": "linux-64", + "timestamp": 1670876577307, + "version": "0.12.3" + }, + "liblief-0.8.3-h1532aa0_0.conda": { + "build": "h1532aa0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9d7ce8264744958bc11e07e776cec92e", + "name": "liblief", + "sha256": "fc7b51dcdc3bd06b96c0f7a4c9e99787ba3466fb2e02040fd4ffd2677f654e49", + "size": 2108152, + "subdir": "linux-64", + "timestamp": 1528206739722, + "version": "0.8.3" + }, + "liblief-0.9.0-h1532aa0_0.conda": { + "build": "h1532aa0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e9c66fab7795467e608e2b2b6167cd4b", + "name": "liblief", + "sha256": "7fb0f9d77f0070f0e12b4a85d28d8a1e832e7aa4b1d9a3eb21af2b2431f935b5", + "size": 2814904, + "subdir": "linux-64", + "timestamp": 1528675660467, + "version": "0.9.0" + }, + "liblief-0.9.0-h7725739_1.conda": { + "build": "h7725739_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8b866bcc5b8fdff9668f6c11ad527159", + "name": "liblief", + "sha256": "70070bd320229e92fce551d79a0da08111b3ef6641fb8663bfe9ab2a6c64babf", + "size": 2994068, + "subdir": "linux-64", + "timestamp": 1541028761721, + "version": "0.9.0" + }, + "liblief-0.9.0-h7725739_2.conda": { + "build": "h7725739_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0139e1ff06373bd10d13c3b9517cad27", + "name": "liblief", + "sha256": "ac2cd4bbce8be6e3283177994856a73745f9de0c87e0f42b413f5fbeecc5d87e", + "size": 3059887, + "subdir": "linux-64", + "timestamp": 1547591875929, + "version": "0.9.0" + }, + "libllvm10-10.0.0-h4a3c616_1.conda": { + "build": "h4a3c616_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "37fe925a320e8a22003fc71f08f78e3d", + "name": "libllvm10", + "sha256": "7732a1eb8597e43cde8d9475f2f9e8c9faaf569b6865717ed45463dc200551ce", + "size": 23136723, + "subdir": "linux-64", + "timestamp": 1594485727493, + "version": "10.0.0" + }, + "libllvm10-10.0.1-hbcb73fb_5.conda": { + "build": "hbcb73fb_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "198e840fc17a5bff7f1ee543ee1981b2", + "name": "libllvm10", + "sha256": "58e06c97453d1dd486d35274fa5c60eb2a666c9b99df4b3594f4758ac1eda984", + "size": 23133777, + "subdir": "linux-64", + "timestamp": 1599257442808, + "version": "10.0.1" + }, + "libllvm11-11.0.0-h3826bc1_0.conda": { + "build": "h3826bc1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "f9ae9516eb048791a07735e26c38dd88", + "name": "libllvm11", + "sha256": "c9c500356d5fbe99a06eab897e4f74bbe889ef81b987b264904ba7a7694c20a5", + "size": 24771583, + "subdir": "linux-64", + "timestamp": 1626720887434, + "version": "11.0.0" + }, + "libllvm11-11.0.0-h3826bc1_1.conda": { + "build": "h3826bc1_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "44c5950cfe7a87f93a9909f3027c4504", + "name": "libllvm11", + "sha256": "91a0d3f9c15b1fc071f99d702cc748839db7055ac6c5f52e81705f4b4c5493f2", + "size": 24774791, + "subdir": "linux-64", + "timestamp": 1646054256176, + "version": "11.0.0" + }, + "libllvm11-11.1.0-h3826bc1_0.conda": { + "build": "h3826bc1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "91cd0afaf88e576c7a619a732dd722e5", + "name": "libllvm11", + "sha256": "5727ba0309ae62dec4933cf858ce51f4c4eb94a83971ebbe27ee46689c60ba2f", + "size": 24752894, + "subdir": "linux-64", + "timestamp": 1624906818854, + "version": "11.1.0" + }, + "libllvm11-11.1.0-h3826bc1_1.conda": { + "build": "h3826bc1_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "fd64f5913323d529f516539d3752d472", + "name": "libllvm11", + "sha256": "38b2b4def7e200d074fd2ef528e07d4e6015f0f5bcf9705726d4a2a38088340f", + "size": 24730792, + "subdir": "linux-64", + "timestamp": 1647523885063, + "version": "11.1.0" + }, + "libllvm11-11.1.0-h9e868ea_5.conda": { + "build": "h9e868ea_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "bc1aa4ad77d6727ab96b46ae80ff3f76", + "name": "libllvm11", + "sha256": "f054996561a01d10fe76095b47eda588164f4deb6d132b25d218bb635aa33b63", + "size": 25304044, + "subdir": "linux-64", + "timestamp": 1662598008362, + "version": "11.1.0" + }, + "libllvm11-11.1.0-h9e868ea_6.conda": { + "build": "h9e868ea_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "813b2e7b6a660340977a6a3074c23703", + "name": "libllvm11", + "sha256": "2afb36e0df747bd655a4488fc152f7936764156bccf3b680317c7b8de0cc4585", + "size": 25310262, + "subdir": "linux-64", + "timestamp": 1665079289108, + "version": "11.1.0" + }, + "libllvm14-14.0.6-h9e868ea_1.conda": { + "build": "h9e868ea_1", + "build_number": 1, + "depends": [ + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "1b3525dfa6750e6fe34b2f211c8d00dd", + "name": "libllvm14", + "sha256": "eb9a79875f761b34c4c6dba17743f43a0a6eb537a34fdf7ad7560ef0d62a226b", + "size": 34855735, + "subdir": "linux-64", + "timestamp": 1669293197994, + "version": "14.0.6" + }, + "libllvm14-14.0.6-hef93074_0.conda": { + "build": "hef93074_0", + "build_number": 0, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "eab45b5bf36854d507b3cbf96285a0a7", + "name": "libllvm14", + "sha256": "0e04c96d36184ebec57ec24a5a8c63ecdadf26f6c1ccce054e86a6d63ebe53ff", + "size": 30492441, + "subdir": "linux-64", + "timestamp": 1661449591289, + "version": "14.0.6" + }, + "libllvm9-9.0.1-h4a3c616_0.conda": { + "build": "h4a3c616_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "7d37a6d76f1f3e43d5864ba95c166e53", + "name": "libllvm9", + "sha256": "b875ce1697cb4b88d0c23f7f65a8518b04dbe92fe58273bb7b67add6eadad831", + "size": 22004069, + "subdir": "linux-64", + "timestamp": 1592929433291, + "version": "9.0.1" + }, + "libllvm9-9.0.1-h4a3c616_1.conda": { + "build": "h4a3c616_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "b283b5087c2b8468a976c439b616a2fc", + "name": "libllvm9", + "sha256": "e53490b70422937b076a4a58e506abceb23b4c40969fbefc26d6353bb6f70d92", + "size": 22025773, + "subdir": "linux-64", + "timestamp": 1594477682199, + "version": "9.0.1" + }, + "libmagic-5.36-h27cfd23_2.conda": { + "build": "h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5e43a00547072f156f29c3bd3c7c344d", + "name": "libmagic", + "sha256": "aee198fb4cfd1acea0e0e5655f4acd82731e05821c68b33787bbff08e9b0077c", + "size": 556403, + "subdir": "linux-64", + "timestamp": 1616768333417, + "version": "5.36" + }, + "libmamba-0.22.1-h1566912_0.conda": { + "build": "h1566912_0", + "build_number": 0, + "depends": [ + "libarchive >=3.4.2,<3.5.0a0", + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1m,<1.1.2a", + "reproc >=14.2,<15.0a0", + "reproc-cpp >=14.2,<15.0a0", + "spdlog-fmt-embed >=1.9.2,<2.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6510668c2074425e0755acdd5eff26bc", + "name": "libmamba", + "sha256": "6f00f68e6be57a37353aefdb7abe0ccafa3a08a87a33897b0d166541a2faa6a7", + "size": 1161064, + "subdir": "linux-64", + "timestamp": 1647297012673, + "version": "0.22.1" + }, + "libmamba-0.24.0-h1566912_0.conda": { + "build": "h1566912_0", + "build_number": 0, + "depends": [ + "libarchive >=3.5.2,<3.6.0a0", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1o,<1.1.2a", + "reproc >=14.2,<15.0a0", + "reproc-cpp >=14.2,<15.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "95546a1b9e6951203fea80c613035dad", + "name": "libmamba", + "sha256": "0900d2bc324cb0aa45731406008679fc3fb144d2608abb7e73bfe4bee50c26f3", + "size": 1236672, + "subdir": "linux-64", + "timestamp": 1654274054610, + "version": "0.24.0" + }, + "libmamba-1.0.0-ha06983f_0.conda": { + "build": "ha06983f_0", + "build_number": 0, + "depends": [ + "fmt >=8.1.1,<9.0a0", + "libarchive >=3.6.1,<3.7.0a0", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libsolv >=0.7.22", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1s,<1.1.2a", + "reproc >=14.2", + "reproc-cpp >=14.2", + "reproc-cpp >=14.2,<15.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5525f7e252bddb78c8d94ba03fe50ca6", + "name": "libmamba", + "sha256": "0dfec059fe0d253d3ecddc7019a5ca076bd3cebeff14db25792e33c00b0c54f0", + "size": 1411924, + "subdir": "linux-64", + "timestamp": 1669229533825, + "version": "1.0.0" + }, + "libmamba-1.3.1-hdb19cb5_0.conda": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "fmt >=9.1.0,<10.0a0", + "libarchive >=3.6.2,<3.7.0a0", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libsolv >=0.7.22,<0.8.0a0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "reproc >=14.2,<15.0a0", + "reproc >=14.2.4,<15.0a0", + "reproc-cpp >=14.2,<15.0a0", + "reproc-cpp >=14.2.4,<15.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "de6a13f27920dada18df96b6be03b006", + "name": "libmamba", + "sha256": "12f81e6d2c5cee5c63c4ead3caa32ea2f2ca355f70cbd3244786dd85cb1e6117", + "size": 1770534, + "subdir": "linux-64", + "timestamp": 1676389107025, + "version": "1.3.1" + }, + "libmamba-1.3.1-hdb19cb5_1.conda": { + "build": "hdb19cb5_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "fmt >=9.1.0,<10.0a0", + "libarchive >=3.6.2,<3.7.0a0", + "libcurl >=7.88.1,<8.0a0", + "libgcc-ng >=11.2.0", + "libsolv >=0.7.22,<0.8.0a0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "reproc >=14.2,<15.0a0", + "reproc >=14.2.4,<15.0a0", + "reproc-cpp >=14.2,<15.0a0", + "reproc-cpp >=14.2.4,<15.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f0da8a7d292076bf9cab0aedc89ae96f", + "name": "libmamba", + "sha256": "2e590103586c600ca517fa9073821b3cee418f04a41db706e1bb7540c0787efc", + "size": 1752494, + "subdir": "linux-64", + "timestamp": 1678914319576, + "version": "1.3.1" + }, + "libmamba-1.4.1-hdb19cb5_0.conda": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "fmt >=9.1.0,<10.0a0", + "libarchive >=3.6.2,<3.7.0a0", + "libcurl >=7.88.1,<8.0a0", + "libgcc-ng >=11.2.0", + "libsolv >=0.7.22,<0.8.0a0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "reproc >=14.2,<15.0a0", + "reproc >=14.2.4,<15.0a0", + "reproc-cpp >=14.2,<15.0a0", + "reproc-cpp >=14.2.4,<15.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0", + "zstd >=1.5.4,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07f1115756f71fa8dbe3cd4f8aa421b3", + "name": "libmamba", + "sha256": "bac58856ee25fe61fec9e64a61d9024cb3cee842e7b4f586eeb1bb9a4e43915d", + "size": 1770052, + "subdir": "linux-64", + "timestamp": 1680093200323, + "version": "1.4.1" + }, + "libmambapy-0.22.1-py310hd09550d_0.conda": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.22.1 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d2e352627718399ae1e11ffd2c90e87b", + "name": "libmambapy", + "sha256": "c61718222f30c9b0b9c32d2d65705a13e3e58377d42cd78aa617109953ebb37e", + "size": 238493, + "subdir": "linux-64", + "timestamp": 1647294651758, + "version": "0.22.1" + }, + "libmambapy-0.22.1-py37hd09550d_0.conda": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.22.1 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "777c058958edffbfd471c509d4b70924", + "name": "libmambapy", + "sha256": "121d732112edbf0bbe036f63d086a7a5158650aa5cb535f30389ff19ce7f2629", + "size": 240693, + "subdir": "linux-64", + "timestamp": 1647294589665, + "version": "0.22.1" + }, + "libmambapy-0.22.1-py38hd09550d_0.conda": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.22.1 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e4f3ba45c8a230e4d0b48ad89c9ef28c", + "name": "libmambapy", + "sha256": "30cae5cc09fbb8c67e7d5a65bca543d5609cc436ebcbcd90bfbe26a14a704c31", + "size": 239759, + "subdir": "linux-64", + "timestamp": 1647294526210, + "version": "0.22.1" + }, + "libmambapy-0.22.1-py39hd09550d_0.conda": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.22.1 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1b2749c2cb9b46b8dc7f4d4106ee263", + "name": "libmambapy", + "sha256": "421d095fdcaea02ebacebb3810675410666019bedda36ceb0460216f13b2e8ec", + "size": 238753, + "subdir": "linux-64", + "timestamp": 1647294464629, + "version": "0.22.1" + }, + "libmambapy-0.23.1-py310hd09550d_0.conda": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.23.1 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "54dc46a95ea766d7007b4c94d402ae01", + "name": "libmambapy", + "sha256": "3a85d18386b0be13d2a56e25b131dbaef51ed77e8d9c0c70cca7232b80535f16", + "size": 198435, + "subdir": "linux-64", + "timestamp": 1652475517207, + "version": "0.23.1" + }, + "libmambapy-0.23.1-py37hd09550d_0.conda": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.23.1 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f3a5e40f9fe111bd53110a76650b4821", + "name": "libmambapy", + "sha256": "1bf928150eb12673e107e7e791a720ab554b0faa6e1dd56645cbb281e10b5aa0", + "size": 197078, + "subdir": "linux-64", + "timestamp": 1652475607196, + "version": "0.23.1" + }, + "libmambapy-0.23.1-py38hd09550d_0.conda": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.23.1 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b6fabc2fe909f4222ffb7f87036ea9d1", + "name": "libmambapy", + "sha256": "158b62aba0b62d8969b60fbac30c78aa829ba9b627ce84a61d2347f0ccfc3be8", + "size": 198226, + "subdir": "linux-64", + "timestamp": 1652475561214, + "version": "0.23.1" + }, + "libmambapy-0.23.1-py39hd09550d_0.conda": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.23.1 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "40a1770a13c3b0899f7e06356d0b42ec", + "name": "libmambapy", + "sha256": "18f5478cacb900e8bee620f2e7685f9c602e61524eee6928fd826ce44fdd8778", + "size": 198856, + "subdir": "linux-64", + "timestamp": 1652475653297, + "version": "0.23.1" + }, + "libmambapy-0.23.3-py310hd09550d_0.conda": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.23.3 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ed17b20a92607bac90f24b297a914b0", + "name": "libmambapy", + "sha256": "de2742aa22665b61b6e25cd8ff8989ded5b9ab73679d989fa052dc32d0657342", + "size": 196910, + "subdir": "linux-64", + "timestamp": 1653512397922, + "version": "0.23.3" + }, + "libmambapy-0.23.3-py37hd09550d_0.conda": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.23.3 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a86f279fca8653eaa34a9af8dce546c8", + "name": "libmambapy", + "sha256": "d813ec81070860b09487cdb16307fa4de7df104f2516063e2cf5b465819f253d", + "size": 196795, + "subdir": "linux-64", + "timestamp": 1653512488549, + "version": "0.23.3" + }, + "libmambapy-0.23.3-py38hd09550d_0.conda": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.23.3 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "15755a8afc8acb4d3ebf0208464c58a1", + "name": "libmambapy", + "sha256": "136b7b51a3bd6d0b676cfbb62881c7032b6664193c196e41ca875ddaa86c8211", + "size": 196753, + "subdir": "linux-64", + "timestamp": 1653512442317, + "version": "0.23.3" + }, + "libmambapy-0.23.3-py39hd09550d_0.conda": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.23.3 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3ccec664a29884047ae1b8eca9d98049", + "name": "libmambapy", + "sha256": "46bc1bb2e6c2b882f39171fb5fba30c085e7eda3f978fc32dc5b33bf19bac8ae", + "size": 197384, + "subdir": "linux-64", + "timestamp": 1653512353475, + "version": "0.23.3" + }, + "libmambapy-0.24.0-py310hd09550d_0.conda": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.24.0 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "68f877ecee192c07419c8deff882b144", + "name": "libmambapy", + "sha256": "caa847d4f844979d875adb35ae38c2b35f69fb366c8626e34310ad62dbfdc563", + "size": 197119, + "subdir": "linux-64", + "timestamp": 1654274236735, + "version": "0.24.0" + }, + "libmambapy-0.24.0-py37hd09550d_0.conda": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.24.0 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "feabb097715c1019022514a0f5d3292d", + "name": "libmambapy", + "sha256": "83cf0edcf88d4ff4d7dde09571c2435deb9c2d1bf73535552599fd7b44490e29", + "size": 197375, + "subdir": "linux-64", + "timestamp": 1654274192389, + "version": "0.24.0" + }, + "libmambapy-0.24.0-py38hd09550d_0.conda": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.24.0 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "110d08b793210379b3bf1870a34c433b", + "name": "libmambapy", + "sha256": "e645b3c0dc2dca2e443d14651627f8b431b7b3aebfca553fcd5d84f385539887", + "size": 197559, + "subdir": "linux-64", + "timestamp": 1654274099961, + "version": "0.24.0" + }, + "libmambapy-0.24.0-py39hd09550d_0.conda": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmamba 0.24.0 h1566912_0", + "libsolv >=0.7.20,<0.8.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b8d78bbad644778d7aa17c5075a02f74", + "name": "libmambapy", + "sha256": "2c5e34c58c91a428022370835cfd14d7886d3c18c2254a11541103d8985b079d", + "size": 198336, + "subdir": "linux-64", + "timestamp": 1654274146269, + "version": "0.24.0" + }, + "libmambapy-1.0.0-py310ha06983f_0.conda": { + "build": "py310ha06983f_0", + "build_number": 0, + "depends": [ + "fmt >=8.1.1,<9.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.0.0 ha06983f_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1s,<1.1.2a", + "pybind11-abi 4", + "python >=3.10,<3.11.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f671824667c2db9124f3377f6597599c", + "name": "libmambapy", + "sha256": "86f0a136b308aec78e3ccda5fc329361fc94bd0f7e4073f5c8dbdbec0644e9d8", + "size": 261578, + "subdir": "linux-64", + "timestamp": 1669229582419, + "version": "1.0.0" + }, + "libmambapy-1.0.0-py311ha06983f_0.conda": { + "build": "py311ha06983f_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.0.0 ha06983f_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.11,<3.12.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4ced27a3a9fd10b92fd2ce1810a3078d", + "name": "libmambapy", + "sha256": "a0efa36e5b9b7d4f74c64cbdabe36c41ee4957b0e717a1b1ef4eff44f8836f05", + "size": 256396, + "subdir": "linux-64", + "timestamp": 1676844677347, + "version": "1.0.0" + }, + "libmambapy-1.0.0-py37ha06983f_0.conda": { + "build": "py37ha06983f_0", + "build_number": 0, + "depends": [ + "fmt >=8.1.1,<9.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.0.0 ha06983f_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1s,<1.1.2a", + "pybind11-abi 4", + "python >=3.7,<3.8.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "05c1a5f289785abeec75b4d6519c6cbd", + "name": "libmambapy", + "sha256": "cb23b46075f96c9862c6776ace3e39383b5f20a104b2b6b0923c4a141ce16c7c", + "size": 256131, + "subdir": "linux-64", + "timestamp": 1669229675989, + "version": "1.0.0" + }, + "libmambapy-1.0.0-py38ha06983f_0.conda": { + "build": "py38ha06983f_0", + "build_number": 0, + "depends": [ + "fmt >=8.1.1,<9.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.0.0 ha06983f_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1s,<1.1.2a", + "pybind11-abi 4", + "python >=3.8,<3.9.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a966d39784bf52d2b40653d90a38c80f", + "name": "libmambapy", + "sha256": "41bf1b02f9a4abb85a54a68a6939e179ea3de4efa16cb4f8a735eff8bade5988", + "size": 258002, + "subdir": "linux-64", + "timestamp": 1669229723069, + "version": "1.0.0" + }, + "libmambapy-1.0.0-py39ha06983f_0.conda": { + "build": "py39ha06983f_0", + "build_number": 0, + "depends": [ + "fmt >=8.1.1,<9.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.0.0 ha06983f_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1s,<1.1.2a", + "pybind11-abi 4", + "python >=3.9,<3.10.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "499aa6e0a895ae3a9c20f0bf9dddde32", + "name": "libmambapy", + "sha256": "a471f98fb3dd4d5240c6f529068635af31fcd2bbc14277eadcf75a5f5635ff01", + "size": 261594, + "subdir": "linux-64", + "timestamp": 1669229629332, + "version": "1.0.0" + }, + "libmambapy-1.3.1-py310hdb19cb5_0.conda": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.3.1 hdb19cb5_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.10,<3.11.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50dd8e2411700997116f1813d2ce0bbc", + "name": "libmambapy", + "sha256": "540e23f5a709616107ee869957ebfb444edc362697ffcff66e502987bf31e04e", + "size": 294822, + "subdir": "linux-64", + "timestamp": 1676389159466, + "version": "1.3.1" + }, + "libmambapy-1.3.1-py310hdb19cb5_1.conda": { + "build": "py310hdb19cb5_1", + "build_number": 1, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.3.1 hdb19cb5_1", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.10,<3.11.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d89cb9b3959e706acc7fdb5ee189c5c6", + "name": "libmambapy", + "sha256": "b3aa652e83a2a49b74309b6c98566e9f01dd3ac61a84035f516dd6d6d99de792", + "size": 295188, + "subdir": "linux-64", + "timestamp": 1678914523749, + "version": "1.3.1" + }, + "libmambapy-1.3.1-py311hdb19cb5_1.conda": { + "build": "py311hdb19cb5_1", + "build_number": 1, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.3.1 hdb19cb5_1", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.11,<3.12.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9bc79d2d0982da6a25138989bbc1fdb7", + "name": "libmambapy", + "sha256": "e800091b31ccc3a8d9f5a3a8ecbe0ab8b01175cb41a66b7541ad6406b1a38218", + "size": 294913, + "subdir": "linux-64", + "timestamp": 1678914422539, + "version": "1.3.1" + }, + "libmambapy-1.3.1-py37hdb19cb5_0.conda": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.3.1 hdb19cb5_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.7,<3.8.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1ace2886dd3fe9be8a866fa86b4b64bb", + "name": "libmambapy", + "sha256": "44c29205beea56bef527b6732747bfd504eaf4be35153d0fa0fe951c12b777bb", + "size": 308329, + "subdir": "linux-64", + "timestamp": 1676389214197, + "version": "1.3.1" + }, + "libmambapy-1.3.1-py38hdb19cb5_0.conda": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.3.1 hdb19cb5_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.8,<3.9.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4e2732a6ec3af2e7750a195baeaed4dd", + "name": "libmambapy", + "sha256": "a5a7602f924f8e79da79ffdb49a162516782eb8d76a327cb4a41b7e477105754", + "size": 294753, + "subdir": "linux-64", + "timestamp": 1676389315732, + "version": "1.3.1" + }, + "libmambapy-1.3.1-py38hdb19cb5_1.conda": { + "build": "py38hdb19cb5_1", + "build_number": 1, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.3.1 hdb19cb5_1", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.8,<3.9.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "800499b4e0c061db4973c2eb4f93d7b5", + "name": "libmambapy", + "sha256": "f7ac80101104d1938a4bf5d73f9a3180b000a5aa1fc10730244a3535b9aee454", + "size": 295138, + "subdir": "linux-64", + "timestamp": 1678914371312, + "version": "1.3.1" + }, + "libmambapy-1.3.1-py39hdb19cb5_0.conda": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.3.1 hdb19cb5_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.9,<3.10.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "af4df2bc12fc07b6cc4d5cd8e45ce0e5", + "name": "libmambapy", + "sha256": "0d139223c68a8de81036c4a31834fe9084bbc7c901f480a2f3f79a5cd9ba44da", + "size": 294918, + "subdir": "linux-64", + "timestamp": 1676389265137, + "version": "1.3.1" + }, + "libmambapy-1.3.1-py39hdb19cb5_1.conda": { + "build": "py39hdb19cb5_1", + "build_number": 1, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.3.1 hdb19cb5_1", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.9,<3.10.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f1468b40d7b5cb791beb08547af26e39", + "name": "libmambapy", + "sha256": "ddcc9f7c8c79147976932de033550fd9da892eef415efeef5fdd8598bccc2a79", + "size": 295269, + "subdir": "linux-64", + "timestamp": 1678914472797, + "version": "1.3.1" + }, + "libmambapy-1.4.1-py310hdb19cb5_0.conda": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.4.1 hdb19cb5_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.10,<3.11.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "520225c16f0ca8e97148d344ba10751c", + "name": "libmambapy", + "sha256": "0b0b9c54a65d063d4c3663580367c8ec67c045ddbd66a67225684bd539618e20", + "size": 295956, + "subdir": "linux-64", + "timestamp": 1680093363322, + "version": "1.4.1" + }, + "libmambapy-1.4.1-py311hdb19cb5_0.conda": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.4.1 hdb19cb5_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.11,<3.12.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f58ebb37bcc6516f00bf940c5a796ea6", + "name": "libmambapy", + "sha256": "40668c5e52f9c6b937b9e7d7b264eb405acd616f7d5c8d9529f49a54d24187ba", + "size": 296189, + "subdir": "linux-64", + "timestamp": 1680093255621, + "version": "1.4.1" + }, + "libmambapy-1.4.1-py38hdb19cb5_0.conda": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.4.1 hdb19cb5_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.8,<3.9.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "40df25538e3e66378b8c2d1342ccf5cc", + "name": "libmambapy", + "sha256": "e133dd77429e7edbf1dbf7005d842affdd511f70715076a2b402cc984b5d4177", + "size": 296017, + "subdir": "linux-64", + "timestamp": 1680093308873, + "version": "1.4.1" + }, + "libmambapy-1.4.1-py39hdb19cb5_0.conda": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libmamba 1.4.1 hdb19cb5_0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "pybind11-abi 4", + "python >=3.9,<3.10.0a0", + "yaml-cpp >=0.7.0,<0.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a16e691b5482f09604e963eefc4ec452", + "name": "libmambapy", + "sha256": "cd156bcbba8cb9290588a43c803a11e163b56206038513555b5e8d407b9e3bd3", + "size": 295737, + "subdir": "linux-64", + "timestamp": 1680093416778, + "version": "1.4.1" + }, + "libmklml-2018.0.3-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "intel-openmp 2018.0.3.*", + "libgcc-ng" + ], + "md5": "260919a4f1bbe51d4731cf233ba4a4a7", + "name": "libmklml", + "sha256": "1a31ac29713abb913e98529c422c457c1c00a9dd9196b5a0d5c602ff8a292a3a", + "size": 44883754, + "subdir": "linux-64", + "timestamp": 1530345087172, + "version": "2018.0.3" + }, + "libmklml-2019.0.3-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "intel-openmp 2019.*", + "libgcc-ng" + ], + "md5": "4a476083f06c967a7b6e8bf62ad41c85", + "name": "libmklml", + "sha256": "7e2007f7c3951327428ea417a12bd2d9d727d9f84c3c534f2c71fc3ccbe10e4e", + "size": 23390342, + "subdir": "linux-64", + "timestamp": 1551761704067, + "version": "2019.0.3" + }, + "libmklml-2019.0.5-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "intel-openmp 2019.*", + "libgcc-ng" + ], + "md5": "6ce7db8d95aeee05c5674af53419bbf8", + "name": "libmklml", + "sha256": "d6abbcf30f5328501aaf094f337e1107a9baefef6981ad16c52c67dd77fcff31", + "size": 23409500, + "subdir": "linux-64", + "timestamp": 1564677966774, + "version": "2019.0.5" + }, + "libmklml-2019.0.5-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "intel-openmp 2019.*", + "libgcc-ng" + ], + "md5": "2923ef8714aff05c84ecd047933550f2", + "name": "libmklml", + "sha256": "4b1c678e2e982a749499d25a7ac5144bb022b730c071b9604cdc37d2fbc4eb67", + "size": 23212591, + "subdir": "linux-64", + "timestamp": 1641844474278, + "version": "2019.0.5" + }, + "libmlir-14.0.6-h9e868ea_0.conda": { + "build": "h9e868ea_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libmlir14 14.0.6 h9e868ea_0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "cada7b79611d0944642840a575ed879d", + "name": "libmlir", + "sha256": "e55772d528598c04f4bc0f6b8344701e6bf38af0bb8dcce3f1ca33243cf23a9f", + "size": 7506073, + "subdir": "linux-64", + "timestamp": 1662555382434, + "version": "14.0.6" + }, + "libmlir14-14.0.6-h9e868ea_0.conda": { + "build": "h9e868ea_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "1155389c202e7b35c71cd49bd6517810", + "name": "libmlir14", + "sha256": "aa6ab7a59b68031ac446dac013913c1ee5327ec5598e04da66dfae2cd094e006", + "size": 7506136, + "subdir": "linux-64", + "timestamp": 1662555355611, + "version": "14.0.6" + }, + "libmxnet-1.0.0-hb7fadbc_0.conda": { + "build": "hb7fadbc_0", + "build_number": 0, + "depends": [ + "jemalloc", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.1,<2019.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "blas * mkl" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "fb2d8bba6f2e56c033b3f8a82e57d7b5", + "name": "libmxnet", + "sha256": "6330a7393c272b00dea4d7aecd97d813e071dd94245032bc02d232eae815de40", + "size": 19189693, + "subdir": "linux-64", + "timestamp": 1514730526365, + "version": "1.0.0" + }, + "libmxnet-1.0.0-nomklh2cb3ce3_0.conda": { + "build": "nomklh2cb3ce3_0", + "build_number": 0, + "depends": [ + "jemalloc", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "opencv >=3.3.1,<3.3.2.0a0", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "cd6a3f2bfb5a0806299e5e7dfb8a4323", + "name": "libmxnet", + "sha256": "16f0e8f9ad799c38a5d4325ab3cfe0cf1e23cea96e7460a4e2d422855da05ffb", + "size": 18752637, + "subdir": "linux-64", + "timestamp": 1514731439768, + "version": "1.0.0" + }, + "libmxnet-1.1.0-h47cb24f_0.conda": { + "build": "h47cb24f_0", + "build_number": 0, + "depends": [ + "jemalloc", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "opencv >=3.3.1,<3.3.2.0a0", + "blas * mkl" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "cdb49788903fd45a592b26b51f5b633e", + "name": "libmxnet", + "sha256": "472b9e429a4b55ea57011eb87ad669ff59afd7aab4cf264f0c128cc1cd0e4b2b", + "size": 20110835, + "subdir": "linux-64", + "timestamp": 1522952735018, + "version": "1.1.0" + }, + "libmxnet-1.1.0-nomklh028b6bb_0.conda": { + "build": "nomklh028b6bb_0", + "build_number": 0, + "depends": [ + "jemalloc", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "opencv >=3.3.1,<3.3.2.0a0", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "be33c2a413392da62e388d36b5026a57", + "name": "libmxnet", + "sha256": "388924aeaf6c3877ab0333f0249059967f7285df776083dc10bc03509f6f23a2", + "size": 19583598, + "subdir": "linux-64", + "timestamp": 1522953489196, + "version": "1.1.0" + }, + "libmxnet-1.2.1-gpu_mkl_h3d71631_1.conda": { + "build": "gpu_mkl_h3d71631_1", + "build_number": 1, + "depends": [ + "_mutex_mxnet 0.0.20 gpu_mkl", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "intel-openmp >=2018.0.3,<2019.0a0", + "libgcc-ng >=5.4.0", + "libmklml >=2018.0.3", + "libopencv >=3.4.1,<3.4.2.0a0", + "libstdcxx-ng >=5.4.0", + "mkl-dnn >=0.14,<1.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "2bfe9f4d69e8ce0936d8105a1a53a47c", + "name": "libmxnet", + "sha256": "cd6a0de11cb40d2313e6a956a85938705bbbf82bfe7054dbaa8b8a1cc2eac906", + "size": 182461883, + "subdir": "linux-64", + "timestamp": 1533387308069, + "version": "1.2.1" + }, + "libmxnet-1.2.1-gpu_mkl_he87abd8_1.conda": { + "build": "gpu_mkl_he87abd8_1", + "build_number": 1, + "depends": [ + "_mutex_mxnet 0.0.20 gpu_mkl", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "intel-openmp >=2018.0.3,<2019.0a0", + "libgcc-ng >=5.4.0", + "libmklml >=2018.0.3", + "libopencv >=3.4.1,<3.4.2.0a0", + "libstdcxx-ng >=5.4.0", + "mkl-dnn >=0.14,<1.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "9adefacd5aec61996109e42a0da278e6", + "name": "libmxnet", + "sha256": "bc0ebb165446bd1411e13ec57c4319dcecf4b64ce158f4d02aad5ee1e3463702", + "size": 174105522, + "subdir": "linux-64", + "timestamp": 1533382716051, + "version": "1.2.1" + }, + "libmxnet-1.2.1-gpu_openblas_h1d4bbbf_1.conda": { + "build": "gpu_openblas_h1d4bbbf_1", + "build_number": 1, + "depends": [ + "_mutex_mxnet 0.0.10 gpu_openblas", + "blas 1.0 openblas", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libopencv >=3.4.1,<3.4.2.0a0", + "libstdcxx-ng >=5.4.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "bddba3f463635c7ed377d0fdb29d5d84", + "name": "libmxnet", + "sha256": "dc4c717c7ebfdc0e3da7d2f58ce71bc7819398be807d643df05061a2f7f14501", + "size": 182135845, + "subdir": "linux-64", + "timestamp": 1533388173538, + "version": "1.2.1" + }, + "libmxnet-1.2.1-gpu_openblas_hf1ee61d_1.conda": { + "build": "gpu_openblas_hf1ee61d_1", + "build_number": 1, + "depends": [ + "_mutex_mxnet 0.0.10 gpu_openblas", + "blas 1.0 openblas", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "libgcc-ng >=5.4.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libopencv >=3.4.1,<3.4.2.0a0", + "libstdcxx-ng >=5.4.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "d2d52549fd14b7d2ec00c0ac9012084d", + "name": "libmxnet", + "sha256": "af5d48133fdeae1dd20683c506a1fecdf398fd0e0324fe31dce04bdb82785f32", + "size": 173245913, + "subdir": "linux-64", + "timestamp": 1533383695098, + "version": "1.2.1" + }, + "libmxnet-1.2.1-mkl_hcbe7347_1.conda": { + "build": "mkl_hcbe7347_1", + "build_number": 1, + "depends": [ + "_mutex_mxnet 0.0.40 mkl", + "intel-openmp >=2018.0.3,<2019.0a0", + "libgcc-ng >=7.2.0", + "libmklml >=2018.0.3", + "libopencv >=3.4.1,<3.4.2.0a0", + "libstdcxx-ng >=7.2.0", + "mkl-dnn >=0.14,<1.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "86355c6679d7d37f03eb80dad565f397", + "name": "libmxnet", + "sha256": "020a69f5e0e5110c8f970784cc8a7af4b9795b04b2b5c83bcc38b81e6eb19bd8", + "size": 24368629, + "subdir": "linux-64", + "timestamp": 1533370399585, + "version": "1.2.1" + }, + "libmxnet-1.2.1-openblas_h42b7326_1.conda": { + "build": "openblas_h42b7326_1", + "build_number": 1, + "depends": [ + "_mutex_mxnet 0.0.30 openblas", + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libopencv >=3.4.1,<3.4.2.0a0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "777ce4e0a08e79c9fd8ae6627db38d18", + "name": "libmxnet", + "sha256": "e6d4b3a1e7cb2829de2632554e886486b2240eb73b81c944ee05b21018ce3523", + "size": 23346225, + "subdir": "linux-64", + "timestamp": 1533371129876, + "version": "1.2.1" + }, + "libmxnet-1.5.0-mkl_h902f91f_0.conda": { + "build": "mkl_h902f91f_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.30 mkl", + "blas 1.0 mkl", + "intel-openmp >=2019.4,<2020.0a0", + "libgcc-ng >=7.5.0", + "libmklml >=2019.0.5", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.5.0", + "mkl >=2019.4,<2021.0a0", + "mkl-dnn >=0.19,<1.0a0", + "mkl-service >=2,<3.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "476d4dd97bd29ef05c08569ac6da15eb", + "name": "libmxnet", + "sha256": "14ca4922c33331ee8b12df66d3d8338100918d0dc97e51591e64295d298c08c8", + "size": 13884903, + "subdir": "linux-64", + "timestamp": 1633948736619, + "version": "1.5.0" + }, + "libmxnet-1.5.0-mkl_hfe83b78_0.conda": { + "build": "mkl_hfe83b78_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.40 mkl", + "blas 1.0 mkl", + "intel-openmp >=2019.4,<2020.0a0", + "libgcc-ng >=7.3.0", + "libmklml >=2019.0.5", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-dnn >=0.19,<1.0a0", + "mkl-service >=2,<3.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "c736d25f0d1164b87b341344827ea694", + "name": "libmxnet", + "sha256": "5e2ee2167a918f1223976c4e8e75850638eccba6c659cdb3c82a9adcf7514ca5", + "size": 13954009, + "subdir": "linux-64", + "timestamp": 1564767316679, + "version": "1.5.0" + }, + "libmxnet-1.5.0-openblas_h7253574_0.conda": { + "build": "openblas_h7253574_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.40 openblas", + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.13,<1.0a0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "c246e6f10d48c6eb3a2efa5d85a134da", + "name": "libmxnet", + "sha256": "eafb63af6d784a58400f9cb7441f7e45ea20d6ff3b22974c7147e8390e6c068e", + "size": 13254654, + "subdir": "linux-64", + "timestamp": 1633949017027, + "version": "1.5.0" + }, + "libmxnet-1.5.0-openblas_ha1db078_0.conda": { + "build": "openblas_ha1db078_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.30 openblas", + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.6,<1.0a0", + "libopencv >=3.4.2,<3.4.3.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "12d5c13bfcfa60abdc65c69b0a26141e", + "name": "libmxnet", + "sha256": "3679a55ea19fe969e2693c31e4c7bc96965071e04757641703d9dbe2ed43aeac", + "size": 13213527, + "subdir": "linux-64", + "timestamp": 1564768892182, + "version": "1.5.0" + }, + "libmxnet-1.5.1-openblas_h8848447_0.conda": { + "build": "openblas_h8848447_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.50 openblas", + "_openmp_mutex", + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "opencv >=4.6" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "beba378b0ea9ca6c9a6b0053e71600fe", + "name": "libmxnet", + "sha256": "c43caefd026b680cb97c30e41c5671f27eef43c9286be2261ffc9d340b378e78", + "size": 15323749, + "subdir": "linux-64", + "timestamp": 1665586651378, + "version": "1.5.1" + }, + "libmxnet-1.9.1-openblas_h8848447_0.conda": { + "build": "openblas_h8848447_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.50 openblas", + "_openmp_mutex", + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "opencv >=4.6" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "484e5913de6c7fdec2dc264d70102f7d", + "name": "libmxnet", + "sha256": "36f015e07987d530bb3bb42c32b1651b52e35e9fa55aa751da5c56ab9f78febb", + "size": 19792189, + "subdir": "linux-64", + "timestamp": 1666596907579, + "version": "1.9.1" + }, + "libnetcdf-4.4.1.1-h816af47_8.conda": { + "build": "h816af47_8", + "build_number": 8, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "d157fe551fbe3867361329388be28a71", + "name": "libnetcdf", + "sha256": "465dbb1a2579beb8accbef499e98f2be5489c6bd32384320c8a94767477db741", + "size": 3042977, + "subdir": "linux-64", + "timestamp": 1511287888297, + "version": "4.4.1.1" + }, + "libnetcdf-4.4.1.1-h97d33d9_8.conda": { + "build": "h97d33d9_8", + "build_number": 8, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "064db5ac408c9627c62a1a81f5980612", + "name": "libnetcdf", + "sha256": "d038c1f57a369021cca486a88a094f259c972e89e1340e68b3bf973b93f44cff", + "size": 3037494, + "subdir": "linux-64", + "timestamp": 1511287907397, + "version": "4.4.1.1" + }, + "libnetcdf-4.5.0-h3d11b55_5.conda": { + "build": "h3d11b55_5", + "build_number": 5, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "7de4f4cd72008b4b78329ea832d0132c", + "name": "libnetcdf", + "sha256": "11d35391cce638f244d82a67e3801e2bf648ec37c632bb8a71088ac7f590e424", + "size": 3579116, + "subdir": "linux-64", + "timestamp": 1511988220225, + "version": "4.5.0" + }, + "libnetcdf-4.5.0-h569e9f1_7.conda": { + "build": "h569e9f1_7", + "build_number": 7, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "4454bbde16935d20245426e1b2ff3244", + "name": "libnetcdf", + "sha256": "0011726d788c065ec4eaf19b421a22569c91d771629a41056e757700b5b5019f", + "size": 813147, + "subdir": "linux-64", + "timestamp": 1515001499977, + "version": "4.5.0" + }, + "libnetcdf-4.5.0-h5cf2a1f_4.conda": { + "build": "h5cf2a1f_4", + "build_number": 4, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "20a51209d7e3246525279c932f274ef3", + "name": "libnetcdf", + "sha256": "ace32cd387f77902532a72a0e295f6fbf6d9d02ed710575ef8577e6fc37c28ca", + "size": 3584167, + "subdir": "linux-64", + "timestamp": 1511817560815, + "version": "4.5.0" + }, + "libnetcdf-4.5.0-h7338db0_5.conda": { + "build": "h7338db0_5", + "build_number": 5, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "f22292a722ab95bc876528fb68891835", + "name": "libnetcdf", + "sha256": "7fb5bdf8773495791e6dba6a38ca37251d40558da3a3a17f137ae0bafa7530b1", + "size": 3579539, + "subdir": "linux-64", + "timestamp": 1511988202884, + "version": "4.5.0" + }, + "libnetcdf-4.5.0-hc9a163a_7.conda": { + "build": "hc9a163a_7", + "build_number": 7, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "072cc58e9f294fb723ed238f3fe39a07", + "name": "libnetcdf", + "sha256": "757b9fb9ef3a30a65dffd5c59b998ffe9068abdd62932d12c02153f8d95251bb", + "size": 805032, + "subdir": "linux-64", + "timestamp": 1515001518688, + "version": "4.5.0" + }, + "libnetcdf-4.5.0-he97b2d4_4.conda": { + "build": "he97b2d4_4", + "build_number": 4, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "d51296f881947ca4c509bb781d26f4c5", + "name": "libnetcdf", + "sha256": "4ed85789ed2bf0319b17cb00dc630cc6ef0e259ddd401a93755cb2bcc04fc09a", + "size": 3580041, + "subdir": "linux-64", + "timestamp": 1511817562262, + "version": "4.5.0" + }, + "libnetcdf-4.6.1-h015f1c5_0.conda": { + "build": "h015f1c5_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.59.0,<8.0a0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "820f6446a565de13c67f85f5ba9a495e", + "name": "libnetcdf", + "sha256": "5479fd0f1a2614b7a11f730a5d0a2b5a858a5a0a28e0f45313d4e7cd40635bb9", + "size": 834295, + "subdir": "linux-64", + "timestamp": 1526211407364, + "version": "4.6.1" + }, + "libnetcdf-4.6.1-h10edf3e_1.conda": { + "build": "h10edf3e_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.61.0,<8.0a0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "d6bdd4a76b7f389228d090798b69abbc", + "name": "libnetcdf", + "sha256": "91c675e4010944c48c8418f1082a59133f838a6662ea2f66cbe66d4a2df05443", + "size": 852889, + "subdir": "linux-64", + "timestamp": 1536427419490, + "version": "4.6.1" + }, + "libnetcdf-4.6.1-h10edf3e_2.conda": { + "build": "h10edf3e_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.61.1,<8.0a0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "700a4fee93f371c20cbf1fa4f6bb7592", + "name": "libnetcdf", + "sha256": "498314a4d453dee2e9086d897eef854f4b6d3c07d6012296cc94b208049c6665", + "size": 852881, + "subdir": "linux-64", + "timestamp": 1539979652433, + "version": "4.6.1" + }, + "libnetcdf-4.6.1-h11d0813_2.conda": { + "build": "h11d0813_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.63.0,<8.0a0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "81ad970989dc5f95b51ea8f6d83a35a0", + "name": "libnetcdf", + "sha256": "8549506f3af88d26636966fdd5b4d2ac4376592710f9438969c259840a797495", + "size": 852706, + "subdir": "linux-64", + "timestamp": 1545349808889, + "version": "4.6.1" + }, + "libnetcdf-4.6.1-h13459d8_0.conda": { + "build": "h13459d8_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.59.0,<8.0a0", + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "a61fecb37b0186a676be1454c4535444", + "name": "libnetcdf", + "sha256": "f6bf05dc8230e31b13bba345296cdf5357e849deca986cc0c700c74d23a57090", + "size": 840867, + "subdir": "linux-64", + "timestamp": 1526211406831, + "version": "4.6.1" + }, + "libnetcdf-4.6.1-h2053bdc_3.conda": { + "build": "h2053bdc_3", + "build_number": 3, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "zlib" + ], + "license": "MIT", + "md5": "d62183220638a62ee7e807dfc5fdd363", + "name": "libnetcdf", + "sha256": "9da8730819e2163c9c2ddfe7d3ba9491542789263f2b2fc5bdbc2e2d0ab19128", + "size": 884591, + "subdir": "linux-64", + "timestamp": 1613574842822, + "version": "4.6.1" + }, + "libnetcdf-4.6.1-h2053bdc_4.conda": { + "build": "h2053bdc_4", + "build_number": 4, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "zlib" + ], + "license": "MIT", + "md5": "f2cb485dac7ca2c497850082de619768", + "name": "libnetcdf", + "sha256": "83c1b79bc64e73e1a91780bf58beed4f213c2e6ebb1153377ef033db61203836", + "size": 889986, + "subdir": "linux-64", + "timestamp": 1621644214403, + "version": "4.6.1" + }, + "libnetcdf-4.6.1-h6ee366c_1.conda": { + "build": "h6ee366c_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.20,<1.9.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.61.0,<8.0a0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "c2f097e27c9813aff7ed172acab08816", + "name": "libnetcdf", + "sha256": "a1d808781a25b866b503663336855d50afa18c21a29c562b58f8c97a418ccc24", + "size": 843558, + "subdir": "linux-64", + "timestamp": 1536427620237, + "version": "4.6.1" + }, + "libnetcdf-4.6.1-h6ee366c_2.conda": { + "build": "h6ee366c_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.20,<1.9.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.61.1,<8.0a0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "6e484609d2574cba061b68437dfc51ac", + "name": "libnetcdf", + "sha256": "d66bee1ce440173e56f959030f0057bcd1f5e48ddebe90e58a9a4d71c0631fe4", + "size": 853232, + "subdir": "linux-64", + "timestamp": 1539979651736, + "version": "4.6.1" + }, + "libnetcdf-4.7.3-hb80b6cc_0.conda": { + "build": "hb80b6cc_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.68.0,<8.0a0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "743f7cd9b0fa243b056f7e72a1de68e5", + "name": "libnetcdf", + "sha256": "478f1f16d9a702866c664d3166011977937e625499885ea6cac4d4c79d29fb44", + "size": 918137, + "subdir": "linux-64", + "timestamp": 1582140035959, + "version": "4.7.3" + }, + "libnetcdf-4.8.1-h42ceab0_0.conda": { + "build": "h42ceab0_0", + "build_number": 0, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libzip" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "559804f71fbad511dfb3eb598882f22b", + "name": "libnetcdf", + "sha256": "7303458dcfcfc764d9134018da9bf50bd8fe8b47eda46cba6b6d6390f0da500f", + "size": 1044326, + "subdir": "linux-64", + "timestamp": 1641396335597, + "version": "4.8.1" + }, + "libnetcdf-4.8.1-h42ceab0_1.conda": { + "build": "h42ceab0_1", + "build_number": 1, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libzip", + "zlib" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3deda7df7d528f6860589625f16e1b29", + "name": "libnetcdf", + "sha256": "fde5fbe58ad125f2e88198996c4cf1e225c5a3bcc2888acd948df03f6eff4fcf", + "size": 1049561, + "subdir": "linux-64", + "timestamp": 1642426008501, + "version": "4.8.1" + }, + "libnetcdf-4.8.1-h8322cc2_2.conda": { + "build": "h8322cc2_2", + "build_number": 2, + "depends": [ + "curl", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libzip", + "zlib" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ce14e57c2981f934fed6962bf9e3624", + "name": "libnetcdf", + "sha256": "1b97f8f15a7e8b211c03cd3ee10c902dac81375313643830cfb2147ed272a589", + "size": 1206010, + "subdir": "linux-64", + "timestamp": 1674628166020, + "version": "4.8.1" + }, + "libnghttp2-1.41.0-hf8bcb03_2.conda": { + "build": "hf8bcb03_2", + "build_number": 2, + "depends": [ + "c-ares >=1.16.1,<2.0a0", + "c-ares >=1.7.5", + "libev >=4.11", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0bb17a2bc621b9d35a0d4a579eecdf7d", + "name": "libnghttp2", + "sha256": "9acf29edd4d74a3e1561f3c2063fd71e9c3d7e275960468e78997ca1888e52f8", + "size": 683143, + "subdir": "linux-64", + "timestamp": 1602882997296, + "version": "1.41.0" + }, + "libnghttp2-1.46.0-hce63b2e_0.conda": { + "build": "hce63b2e_0", + "build_number": 0, + "depends": [ + "c-ares >=1.17.1,<2.0a0", + "c-ares >=1.7.5", + "libev >=4.11", + "libev >=4.33,<4.34.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bf09e3bce5afd6b281f6e3722c4b7f7b", + "name": "libnghttp2", + "sha256": "026a81c38532e2009b45343002303115c6af4d1ad830f66abdf392796a26f3d7", + "size": 695819, + "subdir": "linux-64", + "timestamp": 1637149827126, + "version": "1.46.0" + }, + "libnghttp2-static-1.41.0-he6710b0_2.conda": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "c-ares-static", + "libev-static", + "libgcc-ng >=7.3.0", + "libnghttp2 1.41.0 hf8bcb03_2", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f07b644b997ccc7050c833d7f07cf774", + "name": "libnghttp2-static", + "sha256": "a72696441cca43d964265fb7fb929ec7d5d37283efcef9ccc4be99efaacc1f5a", + "size": 83666, + "subdir": "linux-64", + "timestamp": 1602883007216, + "version": "1.41.0" + }, + "libnghttp2-static-1.46.0-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "c-ares-static", + "libev-static", + "libgcc-ng >=7.5.0", + "libnghttp2 1.46.0 hce63b2e_0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "695d15873f5dc53475e083fccebb8d86", + "name": "libnghttp2-static", + "sha256": "b553e431b025c1061c30ebdaef05464d501f943a4dc9fdc7721e0b92ab8c4ca0", + "size": 84102, + "subdir": "linux-64", + "timestamp": 1637149836847, + "version": "1.46.0" + }, + "libnsl-2.0.0-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "GPL-2.0-only", + "license_family": "GPL", + "md5": "55e3f1b0c2a70454cdf1a5d64fb44752", + "name": "libnsl", + "sha256": "34fbadc1e86ee37b19b98799b4f806d8be205e9c0220bdb76598f0295961812e", + "size": 31754, + "subdir": "linux-64", + "timestamp": 1666886617155, + "version": "2.0.0" + }, + "libntlm-1.4-h14c3975_2.conda": { + "build": "h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "md5": "93eecb080904d64e89a5f461ba1f8372", + "name": "libntlm", + "sha256": "28e697a70532e5523b26729464c571783611882542d42c0a20741bbc428949a7", + "size": 30895, + "subdir": "linux-64", + "timestamp": 1515696708073, + "version": "1.4" + }, + "libntlm-1.4-hbaadc6b_1.conda": { + "build": "hbaadc6b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "md5": "02e90bbf9c64a248cd1fba1d7a3272b2", + "name": "libntlm", + "sha256": "7f262fffb7c9af943f286444f83b90be8563105370ac96a510b926fd675af773", + "size": 30761, + "subdir": "linux-64", + "timestamp": 1508757755952, + "version": "1.4" + }, + "libntlm-1.5-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "md5": "c34a714d0a05550c80c2c9ab66e79593", + "name": "libntlm", + "sha256": "9b60d592265488221526f7da920714d8b1c255f8582304be541cd4a7fd051888", + "size": 33141, + "subdir": "linux-64", + "timestamp": 1552511223163, + "version": "1.5" + }, + "libntlm-1.6-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "LGPL-2.1", + "md5": "06ed69858d8207d23c2aa1c95fa753ee", + "name": "libntlm", + "sha256": "1546daa4d8511f6ecbf09f733a49ce8bf4e50cc92ca75a31af5064a21a6df82f", + "size": 33146, + "subdir": "linux-64", + "timestamp": 1631837639630, + "version": "1.6" + }, + "libogg-1.3.2-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD3", + "md5": "3adcec4fb0ade8a4103dd96a78e28205", + "name": "libogg", + "sha256": "a991b5f9fad12f6853a07cb96e29a03d3baa0545359ccfead8d8e9552e95a188", + "size": 198834, + "subdir": "linux-64", + "timestamp": 1539168795260, + "version": "1.3.2" + }, + "libogg-1.3.4-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD3", + "md5": "47210bc3513f8b99ca4289e0508f538f", + "name": "libogg", + "sha256": "08efdb272dad0a36ad700d151e377262d7222194a93d0f81ee424a68d78ebb89", + "size": 209499, + "subdir": "linux-64", + "timestamp": 1619217664147, + "version": "1.3.4" + }, + "libogg-1.3.4-h27cfd23_1.conda": { + "build": "h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "md5": "f091111095142906eba5c0fb67013ed4", + "name": "libogg", + "sha256": "f83caa2d930f166d64011acafb1287d17ee69680130eae0d878d50fd1a8281f3", + "size": 203385, + "subdir": "linux-64", + "timestamp": 1619530117892, + "version": "1.3.4" + }, + "libogg-1.3.5-h27cfd23_1.conda": { + "build": "h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "710ee7fdb0ddf7591a5af7ca7eb4d73d", + "name": "libogg", + "sha256": "152640cb85a760721ffdf419bbb33d838885a855c7deb89177c9a263bcdfff6a", + "size": 204185, + "subdir": "linux-64", + "timestamp": 1623063983024, + "version": "1.3.5" + }, + "libopenblas-0.2.20-h9ac9557_4.conda": { + "build": "h9ac9557_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "e6f60c56bc7773fa0bab229a9a836441", + "name": "libopenblas", + "sha256": "319c1676d07fb481232d05f99d2ff8c4352aa3017e2463dd743d6c5ba44ef423", + "size": 4188814, + "subdir": "linux-64", + "timestamp": 1515516215744, + "version": "0.2.20" + }, + "libopenblas-0.2.20-h9ac9557_7.conda": { + "build": "h9ac9557_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "743f6ed6e298b32bc8285c22ffcd3358", + "name": "libopenblas", + "sha256": "f1b495b1a40b82ce6aece89c42abc56454552d54f0a75eec3f03851f781fcb03", + "size": 4230044, + "subdir": "linux-64", + "timestamp": 1527877193514, + "version": "0.2.20" + }, + "libopenblas-0.2.20-hae245c1_3.conda": { + "build": "hae245c1_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0" + ], + "license": "BSD", + "md5": "76799d7a6e8915db598abff022294bb6", + "name": "libopenblas", + "sha256": "59ecee2e24cd2c4a442134d8cb364df440862e7e6adb56db778e76935e4b7701", + "size": 4191474, + "subdir": "linux-64", + "timestamp": 1509731009108, + "version": "0.2.20" + }, + "libopenblas-0.3.10-h5a2b251_0.conda": { + "build": "h5a2b251_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "fdcbc234f3566dc863de99a2d59eada3", + "name": "libopenblas", + "sha256": "82a338990c5b3b3d1569f6710ba29cd5409be9dd2174c0151c7160451ccc11b9", + "size": 4764435, + "subdir": "linux-64", + "timestamp": 1594191939436, + "version": "0.3.10" + }, + "libopenblas-0.3.13-h4367d64_0.conda": { + "build": "h4367d64_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "c8a328b6c15b20d33210bf1e8eae85ff", + "name": "libopenblas", + "sha256": "7e6f375f4afa9dbc47f4e559ef8896ac2b6f7f3650a3a9c64b0a842e397ca4aa", + "size": 5054338, + "subdir": "linux-64", + "timestamp": 1616438133183, + "version": "0.3.13" + }, + "libopenblas-0.3.17-hf726d26_1.conda": { + "build": "hf726d26_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-clause", + "md5": "41a01f4e002017062564d95c6240f0bd", + "name": "libopenblas", + "sha256": "dea8d2360484aa1dff6c406843802c82fec5c27a7db6c6d4dd0c9b27e8d6e460", + "size": 5022660, + "subdir": "linux-64", + "timestamp": 1643995245345, + "version": "0.3.17" + }, + "libopenblas-0.3.18-hf726d26_0.conda": { + "build": "hf726d26_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-clause", + "md5": "10422bb3b9b022e27798fc368cda69ba", + "name": "libopenblas", + "sha256": "a8a507fe2ee463d98a4a22424884303ef99bea00925eb5a3a0fd3550b1d2c469", + "size": 5148487, + "subdir": "linux-64", + "timestamp": 1649691280533, + "version": "0.3.18" + }, + "libopenblas-0.3.2-h5a2b251_1.conda": { + "build": "h5a2b251_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "b4463144cc7ca4a55f4daae3fba98be6", + "name": "libopenblas", + "sha256": "c7f8c8f0cc7d104131fdd22367c4594f3d404f7cdef4acccc993ab4b53427456", + "size": 4692951, + "subdir": "linux-64", + "timestamp": 1535382564840, + "version": "0.3.2" + }, + "libopenblas-0.3.2-h7aa55d7_0.conda": { + "build": "h7aa55d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=8.2.0", + "libgfortran-ng >=8,<9.0a0" + ], + "license": "BSD", + "md5": "bf14a3281693cdba284fd7af77796ba8", + "name": "libopenblas", + "sha256": "22bf37dc857f695019bcc8e9688fdd85441292bb7ee3f27afea0b43bcb26be02", + "size": 13861360, + "subdir": "linux-64", + "timestamp": 1534769988486, + "version": "0.3.2" + }, + "libopenblas-0.3.2-h9ac9557_0.conda": { + "build": "h9ac9557_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "54971c16c4d6ee7a6914841948b91822", + "name": "libopenblas", + "sha256": "2854ef7a3e3167ab2de001d0afd65300e0d4a247b6029b5be650bc36f544dfba", + "size": 4717993, + "subdir": "linux-64", + "timestamp": 1534770579276, + "version": "0.3.2" + }, + "libopenblas-0.3.2-h9ac9557_1.conda": { + "build": "h9ac9557_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=8.2.0", + "libgfortran-ng >=8,<9.0a0" + ], + "license": "BSD", + "md5": "2d179821df8a49c055cc183a2d934114", + "name": "libopenblas", + "sha256": "0e171587302daf174b1563171efd91ad680f7875616ccd42f4bd299b125d0c9b", + "size": 5027298, + "subdir": "linux-64", + "timestamp": 1534782531307, + "version": "0.3.2" + }, + "libopenblas-0.3.20-h043d6bf_0.conda": { + "build": "h043d6bf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-clause", + "md5": "b068662da61af6cfcd1173362fc2e566", + "name": "libopenblas", + "sha256": "ab9ab150d79994273048199011866d863e78f96a847cddeba1bd62edefd9e5f3", + "size": 5649889, + "subdir": "linux-64", + "timestamp": 1652995305837, + "version": "0.3.20" + }, + "libopenblas-0.3.20-h043d6bf_1.conda": { + "build": "h043d6bf_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-clause", + "md5": "1623a4cf00b7acf0291da61f20cb87c3", + "name": "libopenblas", + "sha256": "e031729b3e7f4e53bd449002fd8b776497faf8195d40c4c8f51fbd498ddd5edc", + "size": 5647468, + "subdir": "linux-64", + "timestamp": 1653477000378, + "version": "0.3.20" + }, + "libopenblas-0.3.21-h043d6bf_0.conda": { + "build": "h043d6bf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7f7324dcc3c4761a14f3e4ac443235a7", + "name": "libopenblas", + "sha256": "2be562fee8f310c93c5e9bbe6dda834b7b9408164b108a0b570c8587591f1dc2", + "size": 5669108, + "subdir": "linux-64", + "timestamp": 1664897187441, + "version": "0.3.21" + }, + "libopenblas-0.3.3-h5a2b251_1.conda": { + "build": "h5a2b251_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "ab9f39746364774861056cb5aeacf3cf", + "name": "libopenblas", + "sha256": "f0388ef808b6703823970b6dfe19fb47d524500723b704a7b0862b6446d8e355", + "size": 4666661, + "subdir": "linux-64", + "timestamp": 1536076208904, + "version": "0.3.3" + }, + "libopenblas-0.3.3-h5a2b251_2.conda": { + "build": "h5a2b251_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "a999617c6a23be218425042c17cd5c1b", + "name": "libopenblas", + "sha256": "abe78f928b7652ece88f3f0dcf0b127f6c481a4ded3c8273458d626debc211c7", + "size": 4631932, + "subdir": "linux-64", + "timestamp": 1536889145220, + "version": "0.3.3" + }, + "libopenblas-0.3.3-h5a2b251_3.conda": { + "build": "h5a2b251_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "9a13cfd03d29600ac617c7afd9f647a9", + "name": "libopenblas", + "sha256": "99d391309551a0e2c3d51dc47543a2685c8f575befb3241a88a776e79ae61914", + "size": 4627221, + "subdir": "linux-64", + "timestamp": 1537472768584, + "version": "0.3.3" + }, + "libopenblas-0.3.6-h5a2b251_0.conda": { + "build": "h5a2b251_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "0cb1173e64bf65a22b6ea3d41d2afa60", + "name": "libopenblas", + "sha256": "33c924e50847bf81bf3f24f4beb8ce08ef4da31d0c888b763fc1c056f6226d83", + "size": 4702840, + "subdir": "linux-64", + "timestamp": 1559239803591, + "version": "0.3.6" + }, + "libopenblas-0.3.6-h5a2b251_1.conda": { + "build": "h5a2b251_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "25960e9080cbb601598373e955159e9c", + "name": "libopenblas", + "sha256": "fb51334ef828a5d3d02e8e848c0e9f4d1e40ab2a94d12c15fd768678f84bb5ea", + "size": 4710037, + "subdir": "linux-64", + "timestamp": 1563464662571, + "version": "0.3.6" + }, + "libopenblas-0.3.6-h5a2b251_2.conda": { + "build": "h5a2b251_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0" + ], + "license": "BSD", + "md5": "8ddc1f6380e686ae449f91e4e4e26494", + "name": "libopenblas", + "sha256": "7a04ff55bb12392a6914a231b301494ee1498dbaadab238c929efcb6e8c1f5f6", + "size": 4706320, + "subdir": "linux-64", + "timestamp": 1573061073675, + "version": "0.3.6" + }, + "libopenblas-static-0.2.20-4.conda": { + "build": "4", + "build_number": 4, + "depends": [], + "md5": "afd4471e10f45715b4736d614bfe6eb3", + "name": "libopenblas-static", + "sha256": "fc0250aba55ac87b8b17cc0daeac2b846cf2d495f2d66abe5d5f3894868aef35", + "size": 4050445, + "subdir": "linux-64", + "timestamp": 1515516228087, + "version": "0.2.20" + }, + "libopenblas-static-0.2.20-7.conda": { + "build": "7", + "build_number": 7, + "depends": [], + "md5": "93aab0191bbb1faae8546e5fee7941eb", + "name": "libopenblas-static", + "sha256": "8cb2212aa303721dbc19877327439834cc46793b8fb8b3018f7cb3b05fc2fd18", + "size": 4090382, + "subdir": "linux-64", + "timestamp": 1527877204140, + "version": "0.2.20" + }, + "libopenblas-static-0.2.20-hb692580_3.conda": { + "build": "hb692580_3", + "build_number": 3, + "depends": [], + "md5": "5385e01a00884bbea311dc625b2da943", + "name": "libopenblas-static", + "sha256": "9e532c110223e36930b10dc692ce153c05c16526c46301f15b9fe1d8ceacff3c", + "size": 4043965, + "subdir": "linux-64", + "timestamp": 1509731020378, + "version": "0.2.20" + }, + "libopenblas-static-0.3.10-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "BSD", + "md5": "f7c32efe1d842595496fabd1965677f1", + "name": "libopenblas-static", + "sha256": "b8719b5df9818637614c62a526eb499bcbeddf33601579af84fab0c6ed89cb62", + "size": 4626720, + "subdir": "linux-64", + "timestamp": 1594191947553, + "version": "0.3.10" + }, + "libopenblas-static-0.3.13-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "BSD", + "md5": "40fa4fb0dd23a4ffcbb9802853cb5747", + "name": "libopenblas-static", + "sha256": "2b0283f31faf28b636ffa1a9214410afcf71a11460007d64103f2286ff5dc50d", + "size": 4930670, + "subdir": "linux-64", + "timestamp": 1616438141788, + "version": "0.3.13" + }, + "libopenblas-static-0.3.17-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "BSD-3-clause", + "md5": "a051f4943a6a42fe5e6432dbb00525d1", + "name": "libopenblas-static", + "sha256": "804b71efa231880a12dac57abd74bb428d5a3b3b62dd815408f20d0c2dc97e20", + "size": 4894326, + "subdir": "linux-64", + "timestamp": 1643995252475, + "version": "0.3.17" + }, + "libopenblas-static-0.3.18-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "BSD-3-clause", + "md5": "3e300b6a9dce252d15780b15c96dcd17", + "name": "libopenblas-static", + "sha256": "7c89181e55c5ae8957ef46b3d6aca2cae346904d78181ea7dde1e395475fe140", + "size": 5021118, + "subdir": "linux-64", + "timestamp": 1649691288073, + "version": "0.3.18" + }, + "libopenblas-static-0.3.2-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "BSD", + "md5": "6b0cf9c309d9ac807ad2a9f38bc6310d", + "name": "libopenblas-static", + "sha256": "e7813b36b9cfb3b9beadbfa76435c59c4b7d48d6c7d2a35df311c1c0c5d927d1", + "size": 4517152, + "subdir": "linux-64", + "timestamp": 1534770586513, + "version": "0.3.2" + }, + "libopenblas-static-0.3.2-1.conda": { + "build": "1", + "build_number": 1, + "depends": [], + "license": "BSD", + "md5": "4009f4c8d805ee57562f4a2fe82ec5c1", + "name": "libopenblas-static", + "sha256": "427ec82e4c6ba6b9ee6f1690347723eae7be64aabbc0053c2dd02c72681256f3", + "size": 4872266, + "subdir": "linux-64", + "timestamp": 1534782551674, + "version": "0.3.2" + }, + "libopenblas-static-0.3.20-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "BSD-3-clause", + "md5": "27cb580975de51228c273006dd04c776", + "name": "libopenblas-static", + "sha256": "df7a5318bc6947c7e05ff596750992217656f5446972592df1bfc8a1e04d2e7c", + "size": 5586263, + "subdir": "linux-64", + "timestamp": 1652995313839, + "version": "0.3.20" + }, + "libopenblas-static-0.3.20-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "BSD-3-clause", + "md5": "89cc4cc4239cef385456316421ab5b5b", + "name": "libopenblas-static", + "sha256": "fa785c31d9286902e35adc5456d563bbbd91a353210a4ec7b333e234908b25cb", + "size": 5585321, + "subdir": "linux-64", + "timestamp": 1653477008412, + "version": "0.3.20" + }, + "libopenblas-static-0.3.21-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "80e2f528cbc87cb1abbf53b06d907f75", + "name": "libopenblas-static", + "sha256": "0854a0514d8c59d4363f6e5d989cadbd73355a8af62048ea1ce2c73aa9c5a4c4", + "size": 5607272, + "subdir": "linux-64", + "timestamp": 1664897195360, + "version": "0.3.21" + }, + "libopenblas-static-0.3.3-1.conda": { + "build": "1", + "build_number": 1, + "depends": [], + "license": "BSD", + "md5": "c4e468684417ce6440eebe1628b21cd5", + "name": "libopenblas-static", + "sha256": "f81bc308eae20b5b96f68a703bf1db3bf9a5bee0d95dbf8b12fdc16e37f496e7", + "size": 4488363, + "subdir": "linux-64", + "timestamp": 1536076214950, + "version": "0.3.3" + }, + "libopenblas-static-0.3.3-2.conda": { + "build": "2", + "build_number": 2, + "depends": [], + "license": "BSD", + "md5": "4e61e1adf300967fd10a5abdc176d963", + "name": "libopenblas-static", + "sha256": "2c252df8c233759dc1a933fd5e5d27769459dbbadf47ab42807a8601db893351", + "size": 4480794, + "subdir": "linux-64", + "timestamp": 1536889154281, + "version": "0.3.3" + }, + "libopenblas-static-0.3.3-3.conda": { + "build": "3", + "build_number": 3, + "depends": [], + "license": "BSD", + "md5": "efbd6f11469119e8616746d10c89b5b0", + "name": "libopenblas-static", + "sha256": "eede2613baf6c5488af882337bbed122447958c2825717954228ad5be7ec61fd", + "size": 4477405, + "subdir": "linux-64", + "timestamp": 1537472782825, + "version": "0.3.3" + }, + "libopenblas-static-0.3.6-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "BSD", + "md5": "296e5c97f3b66aca447bfa5f2680733d", + "name": "libopenblas-static", + "sha256": "be9e9669059cce77a15a427413fba6fc9a2618781d161601a3e725f0a6bea951", + "size": 4571813, + "subdir": "linux-64", + "timestamp": 1559239819494, + "version": "0.3.6" + }, + "libopenblas-static-0.3.6-1.conda": { + "build": "1", + "build_number": 1, + "depends": [], + "license": "BSD", + "md5": "ad2b2dc8ffa78145a3cf63dcc4f62165", + "name": "libopenblas-static", + "sha256": "67761af84e26df24f64bf927d5184494234a7b902772ae75fb0753b00c48812d", + "size": 4574422, + "subdir": "linux-64", + "timestamp": 1563464680446, + "version": "0.3.6" + }, + "libopenblas-static-0.3.6-2.conda": { + "build": "2", + "build_number": 2, + "depends": [], + "license": "BSD", + "md5": "c48658528baa76db609f92861f5e4ba8", + "name": "libopenblas-static", + "sha256": "f61523f2f645408abd93e6e9d40ee6fcea543fb9b708cbcb537a0519187a2a04", + "size": 4572141, + "subdir": "linux-64", + "timestamp": 1573061082474, + "version": "0.3.6" + }, + "libopencv-3.4.1-h1a3b859_1.conda": { + "build": "h1a3b859_1", + "build_number": 1, + "depends": [ + "ffmpeg >=4.0,<4.1.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2f9e88db190dc30f33b31e714730074e", + "name": "libopencv", + "sha256": "70bc8566cde42e2dd8238f8cc0d6f259b5a05f70d5ad8ab2247d5b3c428b319c", + "size": 23069392, + "subdir": "linux-64", + "timestamp": 1527005695368, + "version": "3.4.1" + }, + "libopencv-3.4.1-h62359dd_1.conda": { + "build": "h62359dd_1", + "build_number": 1, + "depends": [ + "ffmpeg >=4.0,<4.1.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "fe8a8267ad6ea16467739382e6701798", + "name": "libopencv", + "sha256": "cbc80fcbbc58e610cd775826b608e0619a95a7020c3cf6491f7212847633b15e", + "size": 23041189, + "subdir": "linux-64", + "timestamp": 1527006615490, + "version": "3.4.1" + }, + "libopencv-3.4.1-h8fa1ad8_3.conda": { + "build": "h8fa1ad8_3", + "build_number": 3, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "freetype >=2.9.1,<3.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c254d3cf929b1b8bf18f960423d36654", + "name": "libopencv", + "sha256": "979ef245b7e37ed9ca8807603b70a373714108eabdb73d1e7d7a62693c711345", + "size": 23044339, + "subdir": "linux-64", + "timestamp": 1530790782681, + "version": "3.4.1" + }, + "libopencv-3.4.1-he6673a0_3.conda": { + "build": "he6673a0_3", + "build_number": 3, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "freetype >=2.9.1,<3.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c02e2453dc6351ae625499964b1b477b", + "name": "libopencv", + "sha256": "4012dca442d73725a3360087daaef5c948a930d95da1bcebe1295f1b4035261f", + "size": 23062115, + "subdir": "linux-64", + "timestamp": 1530792449948, + "version": "3.4.1" + }, + "libopencv-3.4.2-h765d7f9_1.conda": { + "build": "h765d7f9_1", + "build_number": 1, + "depends": [ + "ffmpeg >=4.0,<4.1.0a0", + "freetype >=2.9.1,<3.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "hdf5 >=1.8.20,<1.9.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "40ea33532c6379e71e4a8a325c68b208", + "name": "libopencv", + "sha256": "b10bb5b56b866d814081f498982cca2368d5ff33f642987dc0985053e72bba89", + "size": 22884901, + "subdir": "linux-64", + "timestamp": 1535561159743, + "version": "3.4.2" + }, + "libopencv-3.4.2-h8fa1ad8_0.conda": { + "build": "h8fa1ad8_0", + "build_number": 0, + "depends": [ + "ffmpeg >=4.0,<4.1.0a0", + "freetype >=2.9.1,<3.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ed97907e16378d631b404b5ed33a5793", + "name": "libopencv", + "sha256": "8087b2ac96bf840cd452d17addad9dc0f8472df3edb22da3c87d7b7ddcf489d2", + "size": 22705246, + "subdir": "linux-64", + "timestamp": 1533642139251, + "version": "3.4.2" + }, + "libopencv-3.4.2-hb342d67_1.conda": { + "build": "hb342d67_1", + "build_number": 1, + "depends": [ + "ffmpeg >=4.0,<4.1.0a0", + "freetype >=2.9.1,<3.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cc5de709e3a2678aed7b5f094bdf9034", + "name": "libopencv", + "sha256": "37784ec75e1bd5a1647ff32e9de0044ed426ef19f04a3bbbebd57ba1c816e97b", + "size": 22885338, + "subdir": "linux-64", + "timestamp": 1535561152670, + "version": "3.4.2" + }, + "libopencv-3.4.2-he6673a0_0.conda": { + "build": "he6673a0_0", + "build_number": 0, + "depends": [ + "ffmpeg >=4.0,<4.1.0a0", + "freetype >=2.9.1,<3.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "hdf5 >=1.8.20,<1.9.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "97fb6d3249b768fc2e6229f482e268ef", + "name": "libopencv", + "sha256": "489f5b5b59787949b1b74602bf40ca2d645ddaed6c244310289df757791fff75", + "size": 22672944, + "subdir": "linux-64", + "timestamp": 1533643718463, + "version": "3.4.2" + }, + "libopencv-4.5.4-h06a4308_2.conda": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [ + "opencv >=4.5.4,<4.5.5.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cb1138ce370c4a97c57b5c919ab42d67", + "name": "libopencv", + "sha256": "8ba5d218cda5564997e429947e4263a85ced3dad1d30bb9c1a9b9966e4c705f1", + "size": 29621, + "subdir": "linux-64", + "timestamp": 1648833842781, + "version": "4.5.4" + }, + "libopencv-4.5.4-h06a4308_3.conda": { + "build": "h06a4308_3", + "build_number": 3, + "depends": [ + "opencv 4.5.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cf36a2c04ee4609d382e2b97235968f6", + "name": "libopencv", + "sha256": "bf2213e1b87633c41a71a8430b20b71f6a0f53dd492cc238d2a26d9a4b121cc7", + "size": 29795, + "subdir": "linux-64", + "timestamp": 1648873491917, + "version": "4.5.4" + }, + "libopencv-4.5.5-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "41e1e45cbea0f22cc8b465f721b5de29", + "name": "libopencv", + "sha256": "abc87066f07dbab4484fd4cb2e29e9362b7eee8a20e5d2a35bff72101109f5d9", + "size": 10376, + "subdir": "linux-64", + "timestamp": 1652956698046, + "version": "4.5.5" + }, + "libopencv-4.5.5-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c1683f01608288c3c4e1b4c59d5945ac", + "name": "libopencv", + "sha256": "27610f7c7c90b711aea025d4b62d99d92cfdf919872977baac9ed9bfb96794f3", + "size": 10486, + "subdir": "linux-64", + "timestamp": 1655908326802, + "version": "4.5.5" + }, + "libopencv-4.5.5-h06a4308_2.conda": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "be8cd33877694389b878672436aa8f53", + "name": "libopencv", + "sha256": "d7479ebc56bc0ccce6d5824da0d8f8292e8d114053f447811d391583e3df3635", + "size": 10566, + "subdir": "linux-64", + "timestamp": 1656000399624, + "version": "4.5.5" + }, + "libopencv-4.5.5-h06a4308_3.conda": { + "build": "h06a4308_3", + "build_number": 3, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7ea10407e70b3f9b9b580d4421ad3bee", + "name": "libopencv", + "sha256": "6ccb080faca301458ce0283f1ef32952920bf37d5ddb9b6ab52ce8dceb8b8176", + "size": 14432, + "subdir": "linux-64", + "timestamp": 1656607334301, + "version": "4.5.5" + }, + "libopencv-4.5.5-h06a4308_4.conda": { + "build": "h06a4308_4", + "build_number": 4, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8e1d5b62fa5567c542a8bf6854ce8b6d", + "name": "libopencv", + "sha256": "e49e893415078e2111f860880d8f1526997c2768bbea1e8c334a5cd83dce42c5", + "size": 14503, + "subdir": "linux-64", + "timestamp": 1659975118525, + "version": "4.5.5" + }, + "libopencv-4.6.0-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "opencv 4.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "940443f0e5343a5658fa68bcdfadf99e", + "name": "libopencv", + "sha256": "e6d75cac599a379d57209cae22ed4d77ca2e8e04fb880423ae38621013133d40", + "size": 12965, + "subdir": "linux-64", + "timestamp": 1663874027904, + "version": "4.6.0" + }, + "libopencv-4.6.0-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [ + "opencv 4.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "780c0d1c404e37e1ea7a044e894c75fb", + "name": "libopencv", + "sha256": "6d591408e703b4cd5c549fae7f60816e231fcaab23cb5d710ad8f4b14cab7203", + "size": 13001, + "subdir": "linux-64", + "timestamp": 1664372684059, + "version": "4.6.0" + }, + "libopencv-4.6.0-h06a4308_2.conda": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [ + "opencv 4.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1e73a30a4c06f7541f8c648ca7bda625", + "name": "libopencv", + "sha256": "ed38f2c11a8e01379829df28d99ce52e3729500d73f37f9af783f65e9e5b05f7", + "size": 13003, + "subdir": "linux-64", + "timestamp": 1664550105546, + "version": "4.6.0" + }, + "libopencv-4.6.0-h06a4308_3.conda": { + "build": "h06a4308_3", + "build_number": 3, + "depends": [ + "opencv 4.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "53f3bdca099a172b3ff846b8cc73ba85", + "name": "libopencv", + "sha256": "0d3957a718857061e8287104552f4f63df5a90171d15fcce3814b617b16af17d", + "size": 13755, + "subdir": "linux-64", + "timestamp": 1676453511641, + "version": "4.6.0" + }, + "libopus-1.2.1-hb9ed12e_0.conda": { + "build": "hb9ed12e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "2f7906c40173ee70b2089d91a8515192", + "name": "libopus", + "sha256": "d03aba552c7ba91ea922152c13fbc492ec2749391d86d7cfa14722b4f4cd4973", + "size": 279017, + "subdir": "linux-64", + "timestamp": 1512490365561, + "version": "1.2.1" + }, + "libopus-1.3-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "fd084da03274ea82b38132239efdc05c", + "name": "libopus", + "sha256": "a8b331e62e097fe9bc3fff20468154b71e6db84ebb1326e2878a5501d6bd93e2", + "size": 446634, + "subdir": "linux-64", + "timestamp": 1540710911748, + "version": "1.3" + }, + "libopus-1.3.1-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "69dd2e1a52989aaf0971b001c60ea482", + "name": "libopus", + "sha256": "7fc96f443aaffa57ad0b6502b8f78a118a47b50c7c2f710e8d83f2b9cfd46b59", + "size": 503135, + "subdir": "linux-64", + "timestamp": 1587129391927, + "version": "1.3.1" + }, + "libpcap-1.10.1-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "17bdfc8dd3d902cf401a8562baea6ad5", + "name": "libpcap", + "sha256": "a9b444c0c2e9c35dea16cde277ae1ef389f8ca951d18d500090ac45901b27422", + "size": 254522, + "subdir": "linux-64", + "timestamp": 1632843431366, + "version": "1.10.1" + }, + "libpcap-1.9.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "608cf806c1c9587a18c04c6e273d1cf8", + "name": "libpcap", + "sha256": "8dddc7be1489149ff950da2e5555005d5e4643967cfa978da471f674c062743a", + "size": 229410, + "subdir": "linux-64", + "timestamp": 1544672066845, + "version": "1.9.0" + }, + "libpcap-1.9.1-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "851e79d98962b1298327506d8879568d", + "name": "libpcap", + "sha256": "d0a881e341fa072c1928395b40d8b094747144e9e279a2f68a9194c6cf9b526c", + "size": 248653, + "subdir": "linux-64", + "timestamp": 1573952811358, + "version": "1.9.1" + }, + "libpng-1.6.32-hbd3595f_4.conda": { + "build": "hbd3595f_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "zlib/libpng", + "md5": "3e943b228c66b9d1a5a9ebf80237f0d0", + "name": "libpng", + "sha256": "28762d23f1fd1c26ac51df573049093d8a683594a7c42c5bcd822cf7d50efa18", + "size": 271144, + "subdir": "linux-64", + "timestamp": 1511297717727, + "version": "1.6.32" + }, + "libpng-1.6.32-hda9c8bc_2.conda": { + "build": "hda9c8bc_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "zlib/libpng", + "md5": "f865b36c47b24b81a1b62e862d829ce3", + "name": "libpng", + "sha256": "70f21572a6b5c42d894208df72999e14da4e4dedd75a7cab01386af8fdb5fa49", + "size": 270475, + "subdir": "linux-64", + "timestamp": 1505733443215, + "version": "1.6.32" + }, + "libpng-1.6.34-hb9fc6fc_0.conda": { + "build": "hb9fc6fc_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "zlib/libpng", + "md5": "6656dc606166a806c322fbe4e5cd3918", + "name": "libpng", + "sha256": "1dd1e329b656f7a7a7e93f53def51d01e2ff327d81582daa18bd2e6e25b027ef", + "size": 270774, + "subdir": "linux-64", + "timestamp": 1516738379327, + "version": "1.6.34" + }, + "libpng-1.6.35-hbc83047_0.conda": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "zlib/libpng", + "md5": "23a6a1c64d11898f7a6348cd57c8bce5", + "name": "libpng", + "sha256": "9ad9f9e70aecdf8b63555a936154de178e9103edace41cd43df67c280e9c7f48", + "size": 271953, + "subdir": "linux-64", + "timestamp": 1539728120355, + "version": "1.6.35" + }, + "libpng-1.6.36-hbc83047_0.conda": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "zlib/libpng", + "md5": "6ba0ccfecb1e1e17b1a96f3454d8a6dd", + "name": "libpng", + "sha256": "c31ea9eb0b1286ad479c455909deab00df5da2787e854dd5a774d9da5537cafd", + "size": 282563, + "subdir": "linux-64", + "timestamp": 1547234458119, + "version": "1.6.36" + }, + "libpng-1.6.37-hbc83047_0.conda": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "zlib/libpng", + "md5": "689f903925dcf6c5ab7bc1de0f58b67b", + "name": "libpng", + "sha256": "4f99638c8da0abe841c2b4bc337839f2a01363d40cfc334c0084e79dc0fd0a0d", + "size": 284656, + "subdir": "linux-64", + "timestamp": 1556041895170, + "version": "1.6.37" + }, + "libpng-1.6.39-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Zlib", + "license_family": "Other", + "md5": "f6aee38184512eb05b06c2e94d39ab22", + "name": "libpng", + "sha256": "61f2daac38a2be6429f5119b6288914d25b5bbf6ca0cb2cfe117ef44141514b1", + "size": 311229, + "subdir": "linux-64", + "timestamp": 1677841789536, + "version": "1.6.39" + }, + "libpq-10.3-h1ad7b7a_0.conda": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16,<1.17.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "880796ef7fa4eb9820aa564b3257a968", + "name": "libpq", + "sha256": "e1fb6686a498ead534affed2fd0036c69229cc394e0272554ed3b4847b2a3702", + "size": 2074293, + "subdir": "linux-64", + "timestamp": 1522426547287, + "version": "10.3" + }, + "libpq-10.4-h1ad7b7a_0.conda": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "068a8e53244dc2e377d2db54929a4baa", + "name": "libpq", + "sha256": "eb63ddb0c8a47c76e5c2b827c05bcbdde172ea006ca5db31eb9941f9dc310e7e", + "size": 2075327, + "subdir": "linux-64", + "timestamp": 1532852628907, + "version": "10.4" + }, + "libpq-10.5-h1ad7b7a_0.conda": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2p,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "efe86de3fa9c42b090f5d4f583a67f46", + "name": "libpq", + "sha256": "708029d86ca051078b1a5eb442c465803a01bd7825804d4709ab0db001c83ec2", + "size": 2080318, + "subdir": "linux-64", + "timestamp": 1534394926184, + "version": "10.5" + }, + "libpq-11.1-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "809f8116a12d0db8bb5e6872d6557fa6", + "name": "libpq", + "sha256": "9ce891dedd93fe8dfb8279c1d5fbae2c1df9a2e657dd1dfd8e02c6985138ddea", + "size": 2078795, + "subdir": "linux-64", + "timestamp": 1545233706751, + "version": "11.1" + }, + "libpq-11.2-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1b,<1.1.2a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "deb8ddb60402f11859fcb0d7d8186ae4", + "name": "libpq", + "sha256": "73b314473316678bdca7a288292ea3ef61201a53d94c25a86bc3a56636ef9031", + "size": 2095671, + "subdir": "linux-64", + "timestamp": 1552511043783, + "version": "11.2" + }, + "libpq-12.2-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.17.1,<1.18.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "7f3a010c7becd75db333af062934e770", + "name": "libpq", + "sha256": "3df0546005ab0680feea70bbd592c0cf4d33becfdf71283385a5663f702c90ab", + "size": 2209493, + "subdir": "linux-64", + "timestamp": 1582128055574, + "version": "12.2" + }, + "libpq-12.2-h553bfba_1.conda": { + "build": "h553bfba_1", + "build_number": 1, + "depends": [ + "krb5 >=1.19.1,<1.20.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "md5": "f6c7d6ee56ecbba650f396d58499af43", + "name": "libpq", + "sha256": "f08cc94238f902e41e1910d4862f3d37f2db22690820dc6463efd13833f51f00", + "size": 2203227, + "subdir": "linux-64", + "timestamp": 1621644106995, + "version": "12.2" + }, + "libpq-12.9-h16c4e8d_3.conda": { + "build": "h16c4e8d_3", + "build_number": 3, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=11.2.0", + "openssl >=1.1.1o,<1.1.2a", + "readline >=8.0,<9.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "md5": "0f127be216a734916faf456bb21404e9", + "name": "libpq", + "sha256": "9e8428627ca532bc93dff919510b2972ba023a53ca4991d109b923e43e44c0ac", + "size": 2207712, + "subdir": "linux-64", + "timestamp": 1656062943598, + "version": "12.9" + }, + "libpq-12.9-hc2c5182_1.conda": { + "build": "hc2c5182_1", + "build_number": 1, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "2d1ab8c30a6fb565e2556d09b910a569", + "name": "libpq", + "sha256": "9f48bb1e047bd837528618f1c72b609798dcd5fb139cb8c8af3fc0bc43f1ab2f", + "size": 2214607, + "subdir": "linux-64", + "timestamp": 1638892697693, + "version": "12.9" + }, + "libpq-12.9-hc2c5182_2.conda": { + "build": "hc2c5182_2", + "build_number": 2, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1o,<1.1.2a", + "readline >=8.0,<9.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "md5": "8f7b7b48dd6cb145337e6d74db24986e", + "name": "libpq", + "sha256": "1a158d28008c089a153f4ea3f511b91cb4d405e998aca2fe287f827b80c39653", + "size": 2198042, + "subdir": "linux-64", + "timestamp": 1655472390761, + "version": "12.9" + }, + "libpq-9.5.10-h88a1faf_0.conda": { + "build": "h88a1faf_0", + "build_number": 0, + "depends": [ + "openssl >=1.0.2m,<1.0.3a" + ], + "license": "PostgreSQL", + "md5": "71abe44c4e6da2ee47b4f2b0075afb32", + "name": "libpq", + "sha256": "c8529d3d9843fd2cd1b02f3c4ce1202c32dea3a393f9b6933283fa4f324b87de", + "size": 97577, + "subdir": "linux-64", + "timestamp": 1510351488790, + "version": "9.5.10" + }, + "libpq-9.6.6-h1f21990_0.conda": { + "build": "h1f21990_0", + "build_number": 0, + "depends": [ + "openssl >=1.0.2m,<1.0.3a" + ], + "license": "PostgreSQL", + "md5": "b6df768139e15738c0e10febc99b53fb", + "name": "libpq", + "sha256": "16fb6dadd2bf35b187da3211852b53ccfcccbdaf89a2b09a1a6e565878525c54", + "size": 99500, + "subdir": "linux-64", + "timestamp": 1510610960868, + "version": "9.6.6" + }, + "libpq-9.6.6-h4e02ad2_0.conda": { + "build": "h4e02ad2_0", + "build_number": 0, + "depends": [ + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a" + ], + "license": "PostgreSQL", + "md5": "826c293bac5ddfb3adbafea0be6ac266", + "name": "libpq", + "sha256": "a74e6b10da8a3564e78bb58e2a13f03f7236c9addc949afca4f0b2b8b489d8dd", + "size": 99027, + "subdir": "linux-64", + "timestamp": 1511817098958, + "version": "9.6.6" + }, + "libpq-9.6.6-h60b3205_0.conda": { + "build": "h60b3205_0", + "build_number": 0, + "depends": [ + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a" + ], + "license": "PostgreSQL", + "md5": "159eb793cab3f150916d93708c47ec2a", + "name": "libpq", + "sha256": "31b8cc0fbc16e9aab30f750834e5f06c0c212e1479d790409e3b4465ceced389", + "size": 99022, + "subdir": "linux-64", + "timestamp": 1511386899875, + "version": "9.6.6" + }, + "libprotobuf-3.10.1-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "329adff3492bfd39374ce2100d9cd2a6", + "name": "libprotobuf", + "sha256": "85fe40ae022ebd3f2e8c77088edb5a92c1be180e2a9e563c1288a74ae8416046", + "size": 3081587, + "subdir": "linux-64", + "timestamp": 1573966987405, + "version": "3.10.1" + }, + "libprotobuf-3.11.2-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1c771222b3e76f834025cbca2ce6c13", + "name": "libprotobuf", + "sha256": "d190c2c7a752442aced9fab6164032cf2bebe9233f359edbdc307107faf5af96", + "size": 3066550, + "subdir": "linux-64", + "timestamp": 1576541584171, + "version": "3.11.2" + }, + "libprotobuf-3.11.3-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "66a907ea73b6c20b980284de64a0e35b", + "name": "libprotobuf", + "sha256": "d74cf98721fbd0d64d895d1295343fd57c478035129fa9ce68051e6b88a03e12", + "size": 3059808, + "subdir": "linux-64", + "timestamp": 1581538747478, + "version": "3.11.3" + }, + "libprotobuf-3.11.4-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bf7d47654ea531e801c29f3acf291971", + "name": "libprotobuf", + "sha256": "5e24914860d73def11fed8686f777cf2b9701fc35fa400537be6176ffb2f66ca", + "size": 3070699, + "subdir": "linux-64", + "timestamp": 1581952301358, + "version": "3.11.4" + }, + "libprotobuf-3.12.3-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9f7b01efbc0fda00e7a3d8bab399b695", + "name": "libprotobuf", + "sha256": "dc36faea93fc747dac4cf31903405b02c8afc16cf6de33eee17c85acd19d25d1", + "size": 3087733, + "subdir": "linux-64", + "timestamp": 1591836337062, + "version": "3.12.3" + }, + "libprotobuf-3.12.4-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d98aaf46ae6b7719fc74fe251892f273", + "name": "libprotobuf", + "sha256": "e22c8899a801d4c6c9889d4faf733039d07f830b398cbd08d44622213a28c73b", + "size": 2064955, + "subdir": "linux-64", + "timestamp": 1597429722973, + "version": "3.12.4" + }, + "libprotobuf-3.13.0-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a2226d53b58044498005afe3eadf4e5d", + "name": "libprotobuf", + "sha256": "5126e075872ab68f1fc2e242a9a0ab01337b1f5d6b1921ee62eb926daeeb302f", + "size": 2075752, + "subdir": "linux-64", + "timestamp": 1597784395651, + "version": "3.13.0" + }, + "libprotobuf-3.13.0.1-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a7099d27324f9d459ed48b347c2e7174", + "name": "libprotobuf", + "sha256": "6337ba72027477ed336cc8d66c3babe05c6b866e5f261f9145812611b18da00c", + "size": 2066974, + "subdir": "linux-64", + "timestamp": 1602519676737, + "version": "3.13.0.1" + }, + "libprotobuf-3.14.0-h8c45485_0.conda": { + "build": "h8c45485_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "56c25f416510b02036e872b6baec69bf", + "name": "libprotobuf", + "sha256": "43a6a29d5e0bb1deadc6ed034e5e703c98a628d20acee4e9729528291adb33f3", + "size": 2091907, + "subdir": "linux-64", + "timestamp": 1607036010369, + "version": "3.14.0" + }, + "libprotobuf-3.17.2-h4ff587b_1.conda": { + "build": "h4ff587b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9fa02c9a6e5945c90014702bf798bb3b", + "name": "libprotobuf", + "sha256": "18acd02f794c9e6e4c0b5f7db86acd91fdb0b5c175d8a3e94d307f1d158f4472", + "size": 2113965, + "subdir": "linux-64", + "timestamp": 1626458853901, + "version": "3.17.2" + }, + "libprotobuf-3.19.1-h4ff587b_0.conda": { + "build": "h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0ef10d940ae9ee98307ace9a5b5fe2b2", + "name": "libprotobuf", + "sha256": "2f93cd6f02586a8d86b2f601324bfb5106af087a12c9de741455ca9ce72abde3", + "size": 2191618, + "subdir": "linux-64", + "timestamp": 1640021836928, + "version": "3.19.1" + }, + "libprotobuf-3.19.6-he621ea3_0.conda": { + "build": "he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ad407423ef513c6b05768bb70e14578b", + "name": "libprotobuf", + "sha256": "e50a15c8151b2be7a4b7cdcf245e74b08f2bb1be36c3dc2c79806bc1397f9062", + "size": 2450105, + "subdir": "linux-64", + "timestamp": 1675278885796, + "version": "3.19.6" + }, + "libprotobuf-3.20.1-h4ff587b_0.conda": { + "build": "h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "952a297928737b6fea756c9104484027", + "name": "libprotobuf", + "sha256": "ec4e63014108ee03071b84c557f771719ec6f5734f67f8a2a3222682543c1d0c", + "size": 2180884, + "subdir": "linux-64", + "timestamp": 1652364394785, + "version": "3.20.1" + }, + "libprotobuf-3.20.3-he621ea3_0.conda": { + "build": "he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e4eca5d1a9226085c59d77d85e4d59cb", + "name": "libprotobuf", + "sha256": "24a61758075abc34f83c79b398a98776bcbbf9043e87e6d3b0169dd511aab127", + "size": 2470454, + "subdir": "linux-64", + "timestamp": 1675278653314, + "version": "3.20.3" + }, + "libprotobuf-3.4.1-h5b8497f_0.conda": { + "build": "h5b8497f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "license_family": "BSD", + "md5": "242dba4442f4b17ce8c51d0c97122486", + "name": "libprotobuf", + "sha256": "4422ef0788c68692f9c594d1441569cafb106bd21ba3d64f5158cc9d95ebe965", + "size": 2538372, + "subdir": "linux-64", + "timestamp": 1510782278543, + "version": "3.4.1" + }, + "libprotobuf-3.5.1-h6f1eeef_0.conda": { + "build": "h6f1eeef_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "license_family": "BSD", + "md5": "53b486638bed21677fe5a9fb7f029fca", + "name": "libprotobuf", + "sha256": "1fb1654771993e36a9fdd11bdcf04fa358cd693a98f0c9e3bed23ee3f0b8968f", + "size": 2685629, + "subdir": "linux-64", + "timestamp": 1519949265457, + "version": "3.5.1" + }, + "libprotobuf-3.5.2-h6f1eeef_0.conda": { + "build": "h6f1eeef_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8d7e6963cec0ab9445fc6ee4f402b6a6", + "name": "libprotobuf", + "sha256": "c57d86277b3b6114d901f18640607434ae1af94f2df0e884fd55245fc3e6f174", + "size": 2642240, + "subdir": "linux-64", + "timestamp": 1523041234939, + "version": "3.5.2" + }, + "libprotobuf-3.6.0-hdbcaa40_0.conda": { + "build": "hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9b4c07d3e7dba19a3810f56d9fd3782e", + "name": "libprotobuf", + "sha256": "5cc536d97fb74f32f595943f92c77ff46305470e9ff33ca9e6e673f833d97e41", + "size": 2574158, + "subdir": "linux-64", + "timestamp": 1534345787089, + "version": "3.6.0" + }, + "libprotobuf-3.6.1-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6bcfc8acfc00cb41fade5b49a5e024bd", + "name": "libprotobuf", + "sha256": "398d64ee69c8e5501308508f97ae98613eb3f9e641cdc8c302994019b888db6f", + "size": 2626572, + "subdir": "linux-64", + "timestamp": 1541097651174, + "version": "3.6.1" + }, + "libprotobuf-3.7.1-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d263c24cc1d05012f8dceb0e93ba1804", + "name": "libprotobuf", + "sha256": "c0bb154edb1ec9b84622da0324d975e072f3005115424870388a836a8101d267", + "size": 3046973, + "subdir": "linux-64", + "timestamp": 1556563621034, + "version": "3.7.1" + }, + "libprotobuf-3.8.0-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7efa114eb527ff3e25c8590129c5b8e0", + "name": "libprotobuf", + "sha256": "00054b0a76847a633496241cd2126a8677023639c32a074aedd5b01cdfbce49e", + "size": 3028762, + "subdir": "linux-64", + "timestamp": 1559918744508, + "version": "3.8.0" + }, + "libprotobuf-3.9.1-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2f1275fb5c7d99608d294183330cf521", + "name": "libprotobuf", + "sha256": "cc563cf4f4514b2b0bc1c999df235445175c433ba8fb08b2be79b16520b323b8", + "size": 3061706, + "subdir": "linux-64", + "timestamp": 1567109403157, + "version": "3.9.1" + }, + "libprotobuf-3.9.2-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "44e8fd41a5c195f35b3fca7ded8f654e", + "name": "libprotobuf", + "sha256": "6df7e221345ecfc5e6e1a525ab4ea51a3a93766001574e98e98e5b31749cf696", + "size": 3024973, + "subdir": "linux-64", + "timestamp": 1569267961253, + "version": "3.9.2" + }, + "libprotobuf-static-3.12.4-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "147c847ac0040f63e4d2a088be87c5be", + "name": "libprotobuf-static", + "sha256": "c97bc76aebef6e1f4c67acbbfeb366de0956682c70345d0f7bdbe542f6a30b4e", + "size": 1930076, + "subdir": "linux-64", + "timestamp": 1597429728661, + "version": "3.12.4" + }, + "libprotobuf-static-3.13.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c919b93f01bca3e0f7759c4dee5e552d", + "name": "libprotobuf-static", + "sha256": "3a9b74487f11bd22a5fd4966098b32717ce99aabf37428bfddca53488c5ef43e", + "size": 1946550, + "subdir": "linux-64", + "timestamp": 1597784401112, + "version": "3.13.0" + }, + "libprotobuf-static-3.13.0.1-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0f57bd44d108bf0b6a428eb368159a18", + "name": "libprotobuf-static", + "sha256": "8a78d069b0e3277a24b631d9bbf7c646db32d3bf8f640887b1fba8d6cd4da17b", + "size": 1938275, + "subdir": "linux-64", + "timestamp": 1602519682292, + "version": "3.13.0.1" + }, + "libprotobuf-static-3.14.0-h8c45485_0.conda": { + "build": "h8c45485_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a7b759d4c553311c7223fa26dbc4650", + "name": "libprotobuf-static", + "sha256": "a9f0800502de75d031d9fec903d0441a13b99311877160dbfaec086bb3e27cfa", + "size": 1953046, + "subdir": "linux-64", + "timestamp": 1607036023164, + "version": "3.14.0" + }, + "libprotobuf-static-3.17.2-h4ff587b_1.conda": { + "build": "h4ff587b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.17.2 h4ff587b_1", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "98ce001a1e64b6a8bfbf06c1d267ee9f", + "name": "libprotobuf-static", + "sha256": "099b222638d29ec716d9ebff381a652db521b25103b2b34ea67b2783fc82ecce", + "size": 1979028, + "subdir": "linux-64", + "timestamp": 1626458864563, + "version": "3.17.2" + }, + "libprotobuf-static-3.19.1-h4ff587b_0.conda": { + "build": "h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.19.1 h4ff587b_0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c61420d104c84bc8306821752a8941df", + "name": "libprotobuf-static", + "sha256": "c88def25876467c08c8359c4a0aeead423a2ada1d488396be67b5168a21ddbba", + "size": 2040113, + "subdir": "linux-64", + "timestamp": 1640021848894, + "version": "3.19.1" + }, + "libprotobuf-static-3.19.6-he621ea3_0.conda": { + "build": "he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.19.6 he621ea3_0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a74cadefb592791901e620692f803c58", + "name": "libprotobuf-static", + "sha256": "0bb0a546f602f0bc8ddc6c9a7a9163a576f2e5f46cfa9e49ec7f4a9e7dbb1b3c", + "size": 2393645, + "subdir": "linux-64", + "timestamp": 1675278897243, + "version": "3.19.6" + }, + "libprotobuf-static-3.20.1-h4ff587b_0.conda": { + "build": "h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.20.1 h4ff587b_0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9d5c93d9bad879d820c2608548f3b4cf", + "name": "libprotobuf-static", + "sha256": "64fd9d395205605eed44ba050a4cd02c111272833e629ef083645abc7db70494", + "size": 2039985, + "subdir": "linux-64", + "timestamp": 1652364404266, + "version": "3.20.1" + }, + "libprotobuf-static-3.20.3-he621ea3_0.conda": { + "build": "he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.20.3 he621ea3_0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "865b9111468ca6a89221eacd6cd5eec4", + "name": "libprotobuf-static", + "sha256": "05850106ad11e9223028b5f3a56cbb8abadb663c6abb73b8a91f8ec7532ff6a5", + "size": 2424814, + "subdir": "linux-64", + "timestamp": 1675278664195, + "version": "3.20.3" + }, + "libprotobuf-static-3.6.0-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2f58f94c29e6434584c7a21ae2f5120b", + "name": "libprotobuf-static", + "sha256": "b8ef5fe44b1425a4223204a45f6a96bf15186103a29a0f5c801303423d276390", + "size": 2327463, + "subdir": "linux-64", + "timestamp": 1537898286405, + "version": "3.6.0" + }, + "libprotobuf-static-3.7.1-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e61e0cf496a08a96057225ea7ca2e900", + "name": "libprotobuf-static", + "sha256": "424eb154fa2bc80c698fb3b819f4f3bca403e082a4b24a2aa1abecbb258ee0a5", + "size": 2821857, + "subdir": "linux-64", + "timestamp": 1556562968499, + "version": "3.7.1" + }, + "libpython-static-3.10.0-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0 h12debd9_0" + ], + "license": "Python-2.0", + "md5": "4e8bf30dcdab35c68e27947df3f3e75d", + "name": "libpython-static", + "sha256": "8e0aacbaecb35792ceb83f53abdbb9e21becbd0105066879a1a582f2f42e9ce4", + "size": 38340495, + "subdir": "linux-64", + "timestamp": 1633415507473, + "version": "3.10.0" + }, + "libpython-static-3.10.0-h295c915_1.conda": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0 h12debd9_1" + ], + "license": "Python-2.0", + "md5": "e3a041337321986155e5f72df1d27aeb", + "name": "libpython-static", + "sha256": "c4c9b7d3473ce7408ca736c9491a64b7677855862c64cce07f50e7e3c63a5ef4", + "size": 37979728, + "subdir": "linux-64", + "timestamp": 1633606556586, + "version": "3.10.0" + }, + "libpython-static-3.10.0-h295c915_2.conda": { + "build": "h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0 h12debd9_2" + ], + "license": "Python-2.0", + "md5": "edc7b7de725bdfd468a9e96105bb4f79", + "name": "libpython-static", + "sha256": "1f684f56f9ba95ec291ed27e1f9b9bf18559d3ad7415e2a21c1f5441402ab05c", + "size": 38575902, + "subdir": "linux-64", + "timestamp": 1636442381046, + "version": "3.10.0" + }, + "libpython-static-3.10.0-h295c915_4.conda": { + "build": "h295c915_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0 h12debd9_4" + ], + "license": "Python-2.0", + "md5": "acac374b94fd14b9e451b7b7773e2cab", + "name": "libpython-static", + "sha256": "ae0418d59c91d6d133bcc923a69730cdd28edc59e99ee8d2ad91126a2d6e7826", + "size": 38060090, + "subdir": "linux-64", + "timestamp": 1640094533106, + "version": "3.10.0" + }, + "libpython-static-3.10.0-h295c915_5.conda": { + "build": "h295c915_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0 h12debd9_5" + ], + "license": "Python-2.0", + "md5": "cb26e2e2195593338e57af84d0ccde82", + "name": "libpython-static", + "sha256": "7a000ce219e25a64ffd11d4b9b82d087e137c634f827e151b0b4afb6565ebab8", + "size": 38484280, + "subdir": "linux-64", + "timestamp": 1646302135485, + "version": "3.10.0" + }, + "libpython-static-3.10.0-hdbfa776_3.conda": { + "build": "hdbfa776_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0 h151d27f_3" + ], + "license": "Python-2.0", + "md5": "651bf513d1961e983cce9325dfe666c2", + "name": "libpython-static", + "sha256": "63bfb58c02bc0f98963672e3bd3460b7b2d43e6757e704481723b7471b2bf785", + "size": 38281131, + "subdir": "linux-64", + "timestamp": 1636572516532, + "version": "3.10.0" + }, + "libpython-static-3.10.10-h6a678d5_2.conda": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0 h7a1cb2a_2" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "ffc59e34a6a2a6d02171db3b83ecc9e8", + "name": "libpython-static", + "sha256": "2381496f49cafa6288ad206b94691bcede25e11105fdc6ed9247140a45370741", + "size": 57110538, + "subdir": "linux-64", + "timestamp": 1679425062401, + "version": "3.10.10" + }, + "libpython-static-3.10.6-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0 haa1d7c7_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "c3aace8025608ff1f3790ae302bd3a0c", + "name": "libpython-static", + "sha256": "0ac4fce48586106c6cc10888f6fe9a53251441bc12ffe20987d6d824eae16c7f", + "size": 43398838, + "subdir": "linux-64", + "timestamp": 1665174716129, + "version": "3.10.6" + }, + "libpython-static-3.10.6-h6a678d5_1.conda": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0 haa1d7c7_1" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "6a2af9f9c4dfff4abfb841b28c333c25", + "name": "libpython-static", + "sha256": "711885ab7b08df7b3ce3c723a878c1fe66b1f29a41ddf42d4c617965ebddebbc", + "size": 43579292, + "subdir": "linux-64", + "timestamp": 1666628402870, + "version": "3.10.6" + }, + "libpython-static-3.10.8-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0 haa1d7c7_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "3dde87faba7d3fd33659ef4eb80df04f", + "name": "libpython-static", + "sha256": "9650dbc031fafdb8b306fc32ff03bd0c4cc144185c9b6036a3d2bddb01f606ec", + "size": 57049998, + "subdir": "linux-64", + "timestamp": 1667570424472, + "version": "3.10.8" + }, + "libpython-static-3.10.8-h6a678d5_1.conda": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0 h7a1cb2a_1" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "d577ff1bb764734a3c671009eca2a26b", + "name": "libpython-static", + "sha256": "db2cbfaf6271798ad66f21de02d0094b50f2ee4ccc1f777ebd19eee3db309324", + "size": 57052355, + "subdir": "linux-64", + "timestamp": 1669299944919, + "version": "3.10.8" + }, + "libpython-static-3.10.9-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0 h7a1cb2a_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "6e6191dd45d0a8fdcc4f3a81fcf6e2cc", + "name": "libpython-static", + "sha256": "4f45893fcd41c85105aaf7732cedd6f0fcd91e8242bb63f9a7f787e9d8cedf4d", + "size": 57109043, + "subdir": "linux-64", + "timestamp": 1673451245342, + "version": "3.10.9" + }, + "libpython-static-3.10.9-h6a678d5_1.conda": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0 h7a1cb2a_1" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "bc8c8709c4a495ba0726d2c28c989238", + "name": "libpython-static", + "sha256": "bb412b4d0e09e3e70a156f6fc95751911fa643fbe253f6caedc311dbecfa608e", + "size": 57108673, + "subdir": "linux-64", + "timestamp": 1677695724289, + "version": "3.10.9" + }, + "libpython-static-3.10.9-h6a678d5_2.conda": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0 h7a1cb2a_2" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "4a5f63a714627bcf4f9d36c1d1ba0ce3", + "name": "libpython-static", + "sha256": "97420b03f97b5ea5713a7aa0a135306ee3187634ef289fd47e13e1af45adef0c", + "size": 57116898, + "subdir": "linux-64", + "timestamp": 1678273164882, + "version": "3.10.9" + }, + "libpython-static-3.11.0-h6a678d5_2.conda": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0 h7a1cb2a_2" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "1086b1e76268d30da30f91277dc267a5", + "name": "libpython-static", + "sha256": "0e55d8cb27efff740f218f86bf14167dcca41130f922b1f72e70139fe5e83b05", + "size": 77104124, + "subdir": "linux-64", + "timestamp": 1673879797077, + "version": "3.11.0" + }, + "libpython-static-3.11.0-h6a678d5_3.conda": { + "build": "h6a678d5_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0 h7a1cb2a_3" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "aef5d67ee0db51c05dcb82877780b556", + "name": "libpython-static", + "sha256": "128ead2a0d6618caa5471e32af30630232efa8df1f30c00a4afde55d8252464e", + "size": 77094121, + "subdir": "linux-64", + "timestamp": 1677696192007, + "version": "3.11.0" + }, + "libpython-static-3.11.2-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0 h7a1cb2a_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "2d723f774e1114c40ce18ec2c7040a33", + "name": "libpython-static", + "sha256": "b22620bfc82e28b697c1033048de3762e6d47d39d7b021d022c47486067d53b0", + "size": 77165101, + "subdir": "linux-64", + "timestamp": 1679961560002, + "version": "3.11.2" + }, + "libpython-static-3.8.11-h295c915_0_cpython.conda": { + "build": "h295c915_0_cpython", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0 h12debd9_0_cpython" + ], + "license": "Python-2.0", + "md5": "0135d76cd360f2378436a7884bc9d557", + "name": "libpython-static", + "sha256": "c0ce8072332cc9f322014c6218ebc99de36195f9d35a09583a6003fe6c1d6241", + "size": 45592029, + "subdir": "linux-64", + "timestamp": 1628004061150, + "version": "3.8.11" + }, + "libpython-static-3.8.12-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0 h12debd9_0" + ], + "license": "Python-2.0", + "md5": "34a062c6f702993868ebf8612c7e7d2b", + "name": "libpython-static", + "sha256": "b061171add5578b9335a43c26ebd8edf5615fd7a1911f99ffda888e0cac25690", + "size": 45565271, + "subdir": "linux-64", + "timestamp": 1634047274729, + "version": "3.8.12" + }, + "libpython-static-3.8.13-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0 h12debd9_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "15a0f14a851ada5389984c22c04652ef", + "name": "libpython-static", + "sha256": "93cde7b06e8e92bdfd13d57ca64ba7672cd47e0c137c5bb6df6ae49d14065164", + "size": 45471685, + "subdir": "linux-64", + "timestamp": 1648468116406, + "version": "3.8.13" + }, + "libpython-static-3.8.13-h6a678d5_1.conda": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0 haa1d7c7_1" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "d39368725dc2ad2949521187141f228b", + "name": "libpython-static", + "sha256": "f95aa7aeb2b17d978156f72ce0ce6df8fe9228730626131ccdd8dd162e728436", + "size": 42388516, + "subdir": "linux-64", + "timestamp": 1666397003349, + "version": "3.8.13" + }, + "libpython-static-3.8.15-h3fd9d12_0.conda": { + "build": "h3fd9d12_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0 h3fd9d12_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "f0020adadb139efd002c6910c528b7d5", + "name": "libpython-static", + "sha256": "a55f136466aa5366541c058836d17d5a49deb73f4250136567d7beb02d355793", + "size": 42396012, + "subdir": "linux-64", + "timestamp": 1667596323330, + "version": "3.8.15" + }, + "libpython-static-3.8.15-h6a678d5_2.conda": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0 h7a1cb2a_2" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "760adc3678efddb76a33cd4bdc73bc5d", + "name": "libpython-static", + "sha256": "d1e4eb5a9620188c3624de706b5634439ba8635eb8e6482605200bae38a44dc2", + "size": 42409406, + "subdir": "linux-64", + "timestamp": 1669303882150, + "version": "3.8.15" + }, + "libpython-static-3.8.16-h6a678d5_2.conda": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0 h7a1cb2a_2" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "a21299a24327db4d631d5957683c5896", + "name": "libpython-static", + "sha256": "f8f57e3f8a017bdc1af954e29c70a1ef7b23635a0f060373bc60d39abecfd6d7", + "size": 47002517, + "subdir": "linux-64", + "timestamp": 1673997802345, + "version": "3.8.16" + }, + "libpython-static-3.8.16-h6a678d5_3.conda": { + "build": "h6a678d5_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0 h7a1cb2a_3" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "51e86cdc95c97c6ae4e945e180ce637d", + "name": "libpython-static", + "sha256": "db828ab3bdd0f1ab6f34786d6581775110f63d564caaf447c485589655dbbf4c", + "size": 46817072, + "subdir": "linux-64", + "timestamp": 1677727933984, + "version": "3.8.16" + }, + "libpython-static-3.9.0-h2531618_2.conda": { + "build": "h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0 hdb3f193_2" + ], + "license": "Python-2.0", + "md5": "57c0dd1d1cc63f9a703c0d37159081ea", + "name": "libpython-static", + "sha256": "5bc9e560a5395f4f76ca7b9ba23cd0934407306b39725a1aa8fdcab99c251475", + "size": 35894175, + "subdir": "linux-64", + "timestamp": 1605451303688, + "version": "3.9.0" + }, + "libpython-static-3.9.0-he6710b0_1.conda": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0 hcff3b4d_1" + ], + "license": "Python-2.0", + "md5": "8e36c404ef6b9beeb69821f63fd0c603", + "name": "libpython-static", + "sha256": "c7ad74db15233a9996597bb0720df11ba16d3eb42fdcd177b401ddb519411ea6", + "size": 36050202, + "subdir": "linux-64", + "timestamp": 1603370153193, + "version": "3.9.0" + }, + "libpython-static-3.9.1-h2531618_2.conda": { + "build": "h2531618_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0 hdb3f193_2" + ], + "license": "Python-2.0", + "md5": "54bad301428511d037e9cf3387476b2a", + "name": "libpython-static", + "sha256": "3967ca79bb0bb5774fe0af007f86df97455dd81e6c664df1ad1eb27a95d8752d", + "size": 34685278, + "subdir": "linux-64", + "timestamp": 1607697753382, + "version": "3.9.1" + }, + "libpython-static-3.9.11-h295c915_1.conda": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0 h12debd9_1" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "a0abc155a4ba6afa6952209212a78868", + "name": "libpython-static", + "sha256": "2c1d0c817316b87b9075b4263caa9b691eb8271ff71aff8fae25657f7b4ddaca", + "size": 35356988, + "subdir": "linux-64", + "timestamp": 1648462888618, + "version": "3.9.11" + }, + "libpython-static-3.9.11-h295c915_2.conda": { + "build": "h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0 h12debd9_2" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "158a6ea1a4aba7d0687d0103f29e4eb3", + "name": "libpython-static", + "sha256": "e8b8181fb69deed47f6ad741444d6da983d7a93a467e2b6409fca816492f81e6", + "size": 35656195, + "subdir": "linux-64", + "timestamp": 1648581561448, + "version": "3.9.11" + }, + "libpython-static-3.9.12-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0 h12debd9_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "e06aa16e12808340e44ddccd5e06f95b", + "name": "libpython-static", + "sha256": "0344568f999517929af70fa0d7220fdd917d82647eb724a22da6847390d7127e", + "size": 35206117, + "subdir": "linux-64", + "timestamp": 1649142471890, + "version": "3.9.12" + }, + "libpython-static-3.9.12-h295c915_1.conda": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0 h12debd9_1" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "592d1413728b7de872d8c4bfa332bb5e", + "name": "libpython-static", + "sha256": "93a7f75e044410ff5e0284a26dc509f0b9e0307cf1836ec53e310eddc2904a14", + "size": 35244739, + "subdir": "linux-64", + "timestamp": 1654084193324, + "version": "3.9.12" + }, + "libpython-static-3.9.13-h6a678d5_1.conda": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0 haa1d7c7_1" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "a66555aa872efa4d8c9ee08d0f68fbd9", + "name": "libpython-static", + "sha256": "387969cdcaac2cfa3af25cc16729b5a204f840babd6c12896cb6aa9dcce372f2", + "size": 39511769, + "subdir": "linux-64", + "timestamp": 1661470694890, + "version": "3.9.13" + }, + "libpython-static-3.9.13-h6a678d5_2.conda": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0 haa1d7c7_2" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "18b8de5b9c7f384e09749d0c76292bb4", + "name": "libpython-static", + "sha256": "2778e23ff9fddfc808a1ddd9a5c85260a6855614b9700e7c144b8be6e5739122", + "size": 39736124, + "subdir": "linux-64", + "timestamp": 1665696384158, + "version": "3.9.13" + }, + "libpython-static-3.9.15-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0 haa1d7c7_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "763d1564c65d4b6aa3efc3eb3166c252", + "name": "libpython-static", + "sha256": "fd3513102b9c7cd8c3e2aab4ba2fbd3083d5828ef1427e193d091726c278f8cf", + "size": 51997293, + "subdir": "linux-64", + "timestamp": 1667579118299, + "version": "3.9.15" + }, + "libpython-static-3.9.15-h6a678d5_2.conda": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0 h7a1cb2a_2" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "1311340bbf3221fea97547aa19f49cf2", + "name": "libpython-static", + "sha256": "5aa15090d03a676da84b13d8b6f7afa8e673ae2f8aca051350a20e3d1e668e92", + "size": 52003641, + "subdir": "linux-64", + "timestamp": 1669300977755, + "version": "3.9.15" + }, + "libpython-static-3.9.16-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0 h7a1cb2a_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "8d18ffca823e30de374804f5eab7d7bd", + "name": "libpython-static", + "sha256": "08457c6dd0d77e23676d76b5bff78d81f74edf8a81e893fb7441ef93626d1550", + "size": 52017133, + "subdir": "linux-64", + "timestamp": 1673453851236, + "version": "3.9.16" + }, + "libpython-static-3.9.16-h6a678d5_1.conda": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0 h7a1cb2a_1" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "532b398bdd07b803139bdadf0d780a87", + "name": "libpython-static", + "sha256": "36bf9f4beb3d5e1d96a5e678e502ff90c84899d48bf4cee0d73f5f10d45e6aad", + "size": 52027327, + "subdir": "linux-64", + "timestamp": 1677695618930, + "version": "3.9.16" + }, + "libpython-static-3.9.16-h6a678d5_2.conda": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0 h7a1cb2a_2" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "53c10551e13d1536d01cb2542ac13bcc", + "name": "libpython-static", + "sha256": "ab0f565834fb046a72a57eaf3b8c19a28a733cb328e015921f9ab17f7220d063", + "size": 52011698, + "subdir": "linux-64", + "timestamp": 1678284669315, + "version": "3.9.16" + }, + "libpython-static-3.9.2-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0 hdb3f193_0" + ], + "license": "Python-2.0", + "md5": "927f7101cdb6aec842158f67add235d6", + "name": "libpython-static", + "sha256": "e82f30c0a6720f7e39a293478a4ed6207f4cb228c88ffab25349d718defe246e", + "size": 35492184, + "subdir": "linux-64", + "timestamp": 1614802511391, + "version": "3.9.2" + }, + "libpython-static-3.9.4-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0 hdb3f193_0" + ], + "license": "Python-2.0", + "md5": "46498ea38cbcee16cf8e10b5f328fc44", + "name": "libpython-static", + "sha256": "e2660bded3b05ab9b72331f5806f58e16cec8307856ddce8ca29c220100a160b", + "size": 35415886, + "subdir": "linux-64", + "timestamp": 1617986814028, + "version": "3.9.4" + }, + "libpython-static-3.9.5-h2531618_3.conda": { + "build": "h2531618_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0 hdb3f193_3" + ], + "license": "Python-2.0", + "md5": "803276feca54eccf47c1cfdfc255e44c", + "name": "libpython-static", + "sha256": "5e5086d0f66106f2f9fc221d48ac125cce61724e9a0200913b52d8e4e4bfb3a8", + "size": 35764811, + "subdir": "linux-64", + "timestamp": 1621367234679, + "version": "3.9.5" + }, + "libpython-static-3.9.5-h2531618_4.conda": { + "build": "h2531618_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0 hdb3f193_4" + ], + "license": "Python-2.0", + "md5": "9ef904c897f3597b4343a0e9a41328d8", + "name": "libpython-static", + "sha256": "87c0d4ae56518cb536b10972fe979f79ee80fd942315a45127bebb9e1f50a693", + "size": 35018690, + "subdir": "linux-64", + "timestamp": 1622818412578, + "version": "3.9.5" + }, + "libpython-static-3.9.5-h295c915_4.conda": { + "build": "h295c915_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0 h12debd9_4" + ], + "license": "Python-2.0", + "md5": "d78c317113624a0e5b43f85f1bc5e66c", + "name": "libpython-static", + "sha256": "26a11966cedc0ed316d6f1fade403af4b290c6ae886cb0fdf091a3ae7f4810c3", + "size": 34917309, + "subdir": "linux-64", + "timestamp": 1622828242067, + "version": "3.9.5" + }, + "libpython-static-3.9.6-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0 h12debd9_0" + ], + "license": "Python-2.0", + "md5": "ab8bc8ab3be7ec38147b39dbeee61fd5", + "name": "libpython-static", + "sha256": "be28c00ff2ecbb75b5330ff070207ebea32e5831993bfd9dd364713894b729c7", + "size": 34971257, + "subdir": "linux-64", + "timestamp": 1627663657786, + "version": "3.9.6" + }, + "libpython-static-3.9.6-h295c915_1.conda": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0 h12debd9_1" + ], + "license": "Python-2.0", + "md5": "dca13d34796421c6e43a484fcc639e8d", + "name": "libpython-static", + "sha256": "6d74afa66b381ff19c172ba3987dfb60d05945f28ef9efd5cd4533bdde67cbed", + "size": 35310075, + "subdir": "linux-64", + "timestamp": 1629316156023, + "version": "3.9.6" + }, + "libpython-static-3.9.7-h295c915_1.conda": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0 h12debd9_1" + ], + "license": "Python-2.0", + "md5": "831f72f94eacd932c1160306454d4371", + "name": "libpython-static", + "sha256": "2d4c685c01bb8bb88aff4437269e4c0f3df12a4e39a0225aa5dc5b2c4621cd76", + "size": 34773407, + "subdir": "linux-64", + "timestamp": 1631798551238, + "version": "3.9.7" + }, + "librdkafka-1.6.0-h2f57cc4_2.conda": { + "build": "h2f57cc4_2", + "build_number": 2, + "depends": [ + "cyrus-sasl >=2.1.27,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "lz4-c >=1.9.3,<1.10.0a0", + "openssl >=1.1.1o,<1.1.2a", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5bee81cae8d3251876d4cf2cf9827909", + "name": "librdkafka", + "sha256": "e043e46e2706a85643cbd18a5a495abf2ef94a7b08dd001d1725c9d3abd39fd7", + "size": 8435821, + "subdir": "linux-64", + "timestamp": 1656405317791, + "version": "1.6.0" + }, + "librdkafka-1.6.0-hc0fa4bf_1.conda": { + "build": "hc0fa4bf_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.27,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "openssl >=1.1.1k,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5d607b4d012bfd4d7cb6cb0b56f068b8", + "name": "librdkafka", + "sha256": "da389833951791b21a73e1953d673d918d6de949717267a3b94fac4c291aee96", + "size": 8157905, + "subdir": "linux-64", + "timestamp": 1621648716636, + "version": "1.6.0" + }, + "librsvg-2.54.4-h19fe530_0.conda": { + "build": "h19fe530_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "gdk-pixbuf >=2.42.8,<3.0a0", + "glib >=2.69.1,<3.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "pango >=1.50.7,<2.0a0", + "zlib" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "08350a4d4f11828832d529f6b0a50c1c", + "name": "librsvg", + "sha256": "aa6173ce030201d290669c203c5e5e2218f8e117542335c312ee504efa0ad94b", + "size": 3882257, + "subdir": "linux-64", + "timestamp": 1656615720019, + "version": "2.54.4" + }, + "librsvg-2.54.4-h36cc946_2.conda": { + "build": "h36cc946_2", + "build_number": 2, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "fontconfig >=2.14.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "gdk-pixbuf >=2.42.10,<3.0a0", + "glib >=2.69.1,<3.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.39,<1.7.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "pango >=1.50.7,<2.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "70ce5f08bbb6932a1499c5d86879be40", + "name": "librsvg", + "sha256": "da808f404a3be46a534c17a515adb69ffc5ec290e6497e36a637349ef6b3794a", + "size": 6298456, + "subdir": "linux-64", + "timestamp": 1678549834206, + "version": "2.54.4" + }, + "librsvg-2.54.4-h36cc946_3.conda": { + "build": "h36cc946_3", + "build_number": 3, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "fontconfig >=2.14.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "gdk-pixbuf >=2.42.10,<3.0a0", + "glib >=2.69.1,<3.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.39,<1.7.0a0", + "libxml2 >=2.10.3,<2.11.0a0", + "pango >=1.50.7,<2.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "8acab5154214e233bbcf21a1129cdfc3", + "name": "librsvg", + "sha256": "fa95f3d7fd96a4f8c6e800f686c99079bcc8f734a31b0f07c57b586646dedb1d", + "size": 6300881, + "subdir": "linux-64", + "timestamp": 1679663049125, + "version": "2.54.4" + }, + "libsodium-1.0.13-h31c71d8_2.conda": { + "build": "h31c71d8_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "ISC", + "md5": "00f01618e2f5b36bd6637b6a62b8ac9a", + "name": "libsodium", + "sha256": "6eb6921eee74d09592dc3a047054b74c29a12bca2f56ffc4de7cc1246cde2cf8", + "size": 262991, + "subdir": "linux-64", + "timestamp": 1505687591176, + "version": "1.0.13" + }, + "libsodium-1.0.15-hf101ebd_0.conda": { + "build": "hf101ebd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "ISC", + "md5": "fca8f29c901d04fd26218da6c36ea47f", + "name": "libsodium", + "sha256": "71a6363b7e0c268b2ed9157f3abecb3f106caf09c6f4aa77861eaae978cd26bb", + "size": 221398, + "subdir": "linux-64", + "timestamp": 1511036070905, + "version": "1.0.15" + }, + "libsodium-1.0.16-h1bed415_0.conda": { + "build": "h1bed415_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "ISC", + "md5": "523a3f30893e4a208d1ab426bd8c3495", + "name": "libsodium", + "sha256": "87e871fcfd53d66a4bca3c916c38580e48748d5639cc5019d569980ea557fa98", + "size": 219158, + "subdir": "linux-64", + "timestamp": 1522217356801, + "version": "1.0.16" + }, + "libsodium-1.0.18-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "ISC", + "md5": "c8783b20f0e14bc1d701352c26c264d5", + "name": "libsodium", + "sha256": "be446d634c6f366fce72b77c7a3b2709f2fd29dd8eedab05df253e99ce08650a", + "size": 250267, + "subdir": "linux-64", + "timestamp": 1581700759428, + "version": "1.0.18" + }, + "libsolv-0.7.20-h4ff587b_0.conda": { + "build": "h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4a8d8deaf18c95604541407c2b68ceee", + "name": "libsolv", + "sha256": "2f8281cca4d7caeea9510227f3dcf40a7bb5eadbd7aa4447d3a27eccb2f235d0", + "size": 466503, + "subdir": "linux-64", + "timestamp": 1645463043114, + "version": "0.7.20" + }, + "libsolv-0.7.22-he621ea3_0.conda": { + "build": "he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pcre2 >=10.37,<10.38.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "18b9ccdb2f2d037efc2c150a6a1832d5", + "name": "libsolv", + "sha256": "edcf163357cf709820d7d6aaf0da0af1ddfb2069d08b052a0904b757cbb81db9", + "size": 446734, + "subdir": "linux-64", + "timestamp": 1666304574357, + "version": "0.7.22" + }, + "libsolv-static-0.7.20-h4ff587b_0.conda": { + "build": "h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libsolv 0.7.20 h4ff587b_0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d5a9e9c1b01b09671746c6591144186c", + "name": "libsolv-static", + "sha256": "2dd0c1593da4db04e62b105362f013d51b4ed1f7af74b11253692fa10198b2d2", + "size": 397917, + "subdir": "linux-64", + "timestamp": 1645463059600, + "version": "0.7.20" + }, + "libsolv-static-0.7.22-he621ea3_0.conda": { + "build": "he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libsolv 0.7.22 he621ea3_0", + "libstdcxx-ng >=11.2.0", + "pcre2 >=10.37,<10.38.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1bff65e2712992d40c8e6ec21114379", + "name": "libsolv-static", + "sha256": "23c511db47fefc9f4a4e53ce473ee48f28b0bec30bbba5b1292d3f3599eb4271", + "size": 377973, + "subdir": "linux-64", + "timestamp": 1666304584555, + "version": "0.7.22" + }, + "libspatialindex-1.8.5-h20b78c2_2.conda": { + "build": "h20b78c2_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "1f3d06989645ed0c389bfa76a0159cc7", + "name": "libspatialindex", + "sha256": "d8fa99b862271477874fd671eb2f6ae7c854092e808c3371bb49f46f44cd7b9e", + "size": 446011, + "subdir": "linux-64", + "timestamp": 1513268848433, + "version": "1.8.5" + }, + "libspatialindex-1.9.3-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "2944eeda0125389c979af67e4460a510", + "name": "libspatialindex", + "sha256": "ace5622050c0bc5dde819d360b2c0de86487152b9fc7d9069ffc96d8509b913e", + "size": 2241930, + "subdir": "linux-64", + "timestamp": 1616086764247, + "version": "1.9.3" + }, + "libspatialindex-1.9.3-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "2e1b1f45b25d34881280fdef731d89a1", + "name": "libspatialindex", + "sha256": "6e4d58605ef0157ffff23269896d9dab81b33156402f78c6bf846d7ba61f1992", + "size": 2241432, + "subdir": "linux-64", + "timestamp": 1573154440181, + "version": "1.9.3" + }, + "libspatialite-4.3.0a-h21ec0d7_22.conda": { + "build": "h21ec0d7_22", + "build_number": 22, + "depends": [ + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.10,<2.11.0a0", + "libxml2 >=2.10.3,<2.11.0a0", + "proj >=7.2.0,<7.2.1.0a0", + "sqlite >=3.41.1,<4.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "80c2dbd5e3bd567446c9a96132584cdd", + "name": "libspatialite", + "sha256": "0252592f5577a5b9a70fe4113a84307503e51100e5e10e7677abc8d58566fbba", + "size": 3327384, + "subdir": "linux-64", + "timestamp": 1679578297974, + "version": "4.3.0a" + }, + "libspatialite-4.3.0a-h21ec0d7_23.conda": { + "build": "h21ec0d7_23", + "build_number": 23, + "depends": [ + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.10,<2.11.0a0", + "libxml2 >=2.10.3,<2.11.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.41.1,<4.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "aa460f801ac27e7fbd4a42be53e8a329", + "name": "libspatialite", + "sha256": "10ed37954a286ebbc3d79cb2bb15ac1049a88c80986aed47f2e9e5e792e85280", + "size": 3326748, + "subdir": "linux-64", + "timestamp": 1680110293351, + "version": "4.3.0a" + }, + "libspatialite-4.3.0a-h664321b_0.conda": { + "build": "h664321b_0", + "build_number": 0, + "depends": [ + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "proj <8.0.0", + "proj >=7.2.0,<7.2.1.0a0", + "sqlite >=3.37.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "017d13a1d8531a6eccd446fa4cd09e4e", + "name": "libspatialite", + "sha256": "f3ce2a423801e807cdf125be89341fb259f2c0aafb86ee84499f5d6e96a8c571", + "size": 2211652, + "subdir": "linux-64", + "timestamp": 1643015097685, + "version": "4.3.0a" + }, + "libspatialite-4.3.0a-h71b31bf_21.conda": { + "build": "h71b31bf_21", + "build_number": 21, + "depends": [ + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.40.1,<4.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "839bc4e2f4953c6b60055ade8b6cd4cb", + "name": "libspatialite", + "sha256": "9599fa829e898d3c6837bffc85ad3a56d76c83942325ffc2497d171b0907c4d4", + "size": 3327630, + "subdir": "linux-64", + "timestamp": 1674750914624, + "version": "4.3.0a" + }, + "libspatialite-4.3.0a-h72746d6_18.conda": { + "build": "h72746d6_18", + "build_number": 18, + "depends": [ + "freexl >=1.0.4,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "proj4 >=4.9.3,<4.9.4.0a0", + "sqlite >=3.20.1,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "ab2ec51f82b6c63ce78d6e31370e2e8a", + "name": "libspatialite", + "sha256": "104ede0290e9f2c5153ddd7e4886899d878d9c25d22d3fa53ba743ea73c87c38", + "size": 2171428, + "subdir": "linux-64", + "timestamp": 1511291186010, + "version": "4.3.0a" + }, + "libspatialite-4.3.0a-h793db0d_0.conda": { + "build": "h793db0d_0", + "build_number": 0, + "depends": [ + "freexl >=1.0.5,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.30.1,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "679a8503f00d125dc107231ed4becb4e", + "name": "libspatialite", + "sha256": "91bbe49d9bd698e5cfca8b058395a8c15e56909160948ee648e8bbdc879ff98c", + "size": 2206313, + "subdir": "linux-64", + "timestamp": 1573226969136, + "version": "4.3.0a" + }, + "libspatialite-4.3.0a-hb08deb6_19.conda": { + "build": "hb08deb6_19", + "build_number": 19, + "depends": [ + "freexl >=1.0.5,<2.0a0", + "geos >=3.7.1,<3.7.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "proj4 >=5.2.0,<5.2.1.0a0", + "sqlite >=3.26.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "7aba87281ef3d9789a6af7aa92dbaf9e", + "name": "libspatialite", + "sha256": "981c6c29219a1e542b46b607cf9eab64c187b757ae03efdf6eae2f73838f5263", + "size": 2184158, + "subdir": "linux-64", + "timestamp": 1545319414931, + "version": "4.3.0a" + }, + "libspatialite-4.3.0a-hbedb2dc_20.conda": { + "build": "hbedb2dc_20", + "build_number": 20, + "depends": [ + "freexl >=1.0.6,<2.0a0", + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "sqlite >=3.37.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "d809e84eb401bba4ef047d78e312203f", + "name": "libspatialite", + "sha256": "0311842baa4eec9195d0bca8ea7e682aba2640579b0fccacfeaeb54f73e7b317", + "size": 2206395, + "subdir": "linux-64", + "timestamp": 1642781088363, + "version": "4.3.0a" + }, + "libspatialite-4.3.0a-he475c7f_19.conda": { + "build": "he475c7f_19", + "build_number": 19, + "depends": [ + "freexl >=1.0.5,<2.0a0", + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "sqlite >=3.24.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "046c053bee4bff14993a234074d614bb", + "name": "libspatialite", + "sha256": "8f49ad1874c8b08240c31086a758b155deb00262b5133a1616b647483be165a9", + "size": 2041543, + "subdir": "linux-64", + "timestamp": 1530868615629, + "version": "4.3.0a" + }, + "libssh2-1.10.0-h8f2d780_0.conda": { + "build": "h8f2d780_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openssl >=1.1.1n,<1.1.2a" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dede0f0061d9891642f640c2c4ea442e", + "name": "libssh2", + "sha256": "d462b8a03cfa2599b8d8711c63109997ee555b6db63a411d7632c1b087229f40", + "size": 280643, + "subdir": "linux-64", + "timestamp": 1651087263509, + "version": "1.10.0" + }, + "libssh2-1.8.0-h1ba5d50_4.conda": { + "build": "h1ba5d50_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5e28ae6e2abacadc61bb71c5e450b01e", + "name": "libssh2", + "sha256": "f8b7565368f46018b2e57a09e81beb9c9d859120a9a622faf3e084ab2559d5b8", + "size": 221753, + "subdir": "linux-64", + "timestamp": 1540494448731, + "version": "1.8.0" + }, + "libssh2-1.8.0-h2d05a93_3.conda": { + "build": "h2d05a93_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dbf847fb935a312e822e3af54f5e45c4", + "name": "libssh2", + "sha256": "ea60d74d8b74c6504ec001c8c8a30d853e22edc5f95fec759394e0dd776ab1ac", + "size": 218291, + "subdir": "linux-64", + "timestamp": 1511297592364, + "version": "1.8.0" + }, + "libssh2-1.8.0-h8c220ad_2.conda": { + "build": "h8c220ad_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "97c9419e4a9212619de8471ae198cfbc", + "name": "libssh2", + "sha256": "0a1c908a268a20a984293d658bc095bf6044663aabe047581d491b446c962d28", + "size": 217623, + "subdir": "linux-64", + "timestamp": 1505687685660, + "version": "1.8.0" + }, + "libssh2-1.8.0-h9cfc8f7_4.conda": { + "build": "h9cfc8f7_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2n,<1.0.3a" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "167ce7824be1e72cf28d15e3e3647da2", + "name": "libssh2", + "sha256": "00ec740a9c388fd3bc06caea20fb5b2daf6fdfc1b34e1e039f7e0d080c80eac6", + "size": 217983, + "subdir": "linux-64", + "timestamp": 1516741046975, + "version": "1.8.0" + }, + "libssh2-1.8.2-h1ba5d50_0.conda": { + "build": "h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1b,<1.1.2a" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fe45c9209902cd1a02134c64ad4a77ab", + "name": "libssh2", + "sha256": "5f3c9774e077acca9520963906c519f1af6c2cd33b2d91160914da2d0d1df299", + "size": 231400, + "subdir": "linux-64", + "timestamp": 1555957533473, + "version": "1.8.2" + }, + "libssh2-1.9.0-h1ba5d50_1.conda": { + "build": "h1ba5d50_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f20d2c2f77ee95f800cf0e932af216ab", + "name": "libssh2", + "sha256": "44a292b8d2004962bf9babca42cbdd2e02d1b592dc8c4faed7675c5315b27920", + "size": 275387, + "subdir": "linux-64", + "timestamp": 1583777378437, + "version": "1.9.0" + }, + "libstdcxx-devel_linux-64-11.2.0-h1234567_0.conda": { + "build": "h1234567_0", + "build_number": 0, + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "f1e1673417b54b491b87407373fe5344", + "name": "libstdcxx-devel_linux-64", + "sha256": "c8a3773934582bb77e3669acdeedf4cf5dcf2cdc2aeefb77602f1273ca8581b2", + "size": 15356373, + "subdir": "linux-64", + "timestamp": 1652859697566, + "version": "11.2.0" + }, + "libstdcxx-devel_linux-64-11.2.0-h1234567_1.conda": { + "build": "h1234567_1", + "build_number": 1, + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "1b838d355c9c962e0e822d0eda7564fa", + "name": "libstdcxx-devel_linux-64", + "sha256": "84150fcf17d33d1f091379da7cb0d285baa5e996ca929066177b503eb31c9491", + "size": 15306004, + "subdir": "linux-64", + "timestamp": 1654090781633, + "version": "11.2.0" + }, + "libstdcxx-devel_linux-64-7.5.0-hf0c5c8d_17.conda": { + "build": "hf0c5c8d_17", + "build_number": 17, + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "505eca96d14cca2770a580054fead597", + "name": "libstdcxx-devel_linux-64", + "sha256": "29583eab437017162c084579355dfec8ab988476b08da2ce025fbc53ddf2fb5f", + "size": 7360654, + "subdir": "linux-64", + "timestamp": 1622660063579, + "version": "7.5.0" + }, + "libstdcxx-devel_linux-64-8.4.0-hf0c5c8d_17.conda": { + "build": "hf0c5c8d_17", + "build_number": 17, + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "c5724764a84a795932abddf5baaf9c8c", + "name": "libstdcxx-devel_linux-64", + "sha256": "0dd44361941c29027a62d02cb0f7237b79a64c221c025d567d7b98de7bd43460", + "size": 9855687, + "subdir": "linux-64", + "timestamp": 1622661672879, + "version": "8.4.0" + }, + "libstdcxx-devel_linux-64-9.3.0-hf0c5c8d_17.conda": { + "build": "hf0c5c8d_17", + "build_number": 17, + "depends": [], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "252abf75ff7bc46e126b0d1fea21a11a", + "name": "libstdcxx-devel_linux-64", + "sha256": "17993338ddd620a64723ce03339c17f4e9d8a7f24dd0e788cc6434c741ddd844", + "size": 11063412, + "subdir": "linux-64", + "timestamp": 1622663319968, + "version": "9.3.0" + }, + "libstdcxx-ng-11.2.0-h1234567_0.conda": { + "build": "h1234567_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "ce541c2473bd2d56da84ec8f241a8574", + "name": "libstdcxx-ng", + "sha256": "75b0814dd95da20035c99f2bf494e5f77135f0e2b01eacda3f7fa8ae80f2a36e", + "size": 4920920, + "subdir": "linux-64", + "timestamp": 1652859715934, + "version": "11.2.0" + }, + "libstdcxx-ng-11.2.0-h1234567_1.conda": { + "build": "h1234567_1", + "build_number": 1, + "depends": [ + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "57623d10a70e09e1d048c2b2b6f4e2dd", + "name": "libstdcxx-ng", + "sha256": "4da22842de544990e623ed38dfd9b468cc26cc592a102e41bcf45c91bcce9aa2", + "size": 4919942, + "subdir": "linux-64", + "timestamp": 1654090800863, + "version": "11.2.0" + }, + "libstdcxx-ng-5.4.0-hdf63c60_3.conda": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [], + "license": "GPL3 with runtime exception", + "md5": "0b318fc50352459a8c7611c684b0a9a2", + "name": "libstdcxx-ng", + "sha256": "55717f7b033b6dd0aec5eda4a5f8fc22eb11442e9246c1d1a3b7f6db6999f801", + "size": 1824110, + "subdir": "linux-64", + "timestamp": 1520969519257, + "version": "5.4.0" + }, + "libstdcxx-ng-7.2.0-h24385c6_1.conda": { + "build": "h24385c6_1", + "build_number": 1, + "depends": [], + "license": "GPL3 with runtime exception", + "md5": "14203152d4093c20c9da63c31569d64a", + "name": "libstdcxx-ng", + "sha256": "393334730fd1e3886781ee652034cf8592735229bb19a67bb42168e6fe8ae88f", + "size": 1998555, + "subdir": "linux-64", + "timestamp": 1505665569122, + "version": "7.2.0" + }, + "libstdcxx-ng-7.2.0-h7a57d05_2.conda": { + "build": "h7a57d05_2", + "build_number": 2, + "depends": [], + "license": "GPL3 with runtime exception", + "md5": "b9585f334f35ad56f11dee354ee9da04", + "name": "libstdcxx-ng", + "sha256": "83cecd9beda0d43bf93620a84f9a1972e1e049f879ab8dd98a647cf0ba02a21e", + "size": 1997640, + "subdir": "linux-64", + "timestamp": 1507262729393, + "version": "7.2.0" + }, + "libstdcxx-ng-7.2.0-hdf63c60_3.conda": { + "build": "hdf63c60_3", + "build_number": 3, + "depends": [], + "license": "GPL3 with runtime exception", + "md5": "2e748f88b9d27b4aa1e63b906829d20c", + "name": "libstdcxx-ng", + "sha256": "64a855b015021ed9a32a76e8d03ec3e42f92c310e2d60bf0d8a205c06bfaaa92", + "size": 1994201, + "subdir": "linux-64", + "timestamp": 1520534523570, + "version": "7.2.0" + }, + "libstdcxx-ng-7.3.0-hdf63c60_0.conda": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [], + "license": "GPL3 with runtime exception", + "md5": "f9f5ec2e0dc9a16eccc077cdf6fd0bf8", + "name": "libstdcxx-ng", + "sha256": "faad6d44ae609391572f32cb381e96f25cea79117d34efd0dbccb18b00b48481", + "size": 2072869, + "subdir": "linux-64", + "timestamp": 1534628462259, + "version": "7.3.0" + }, + "libstdcxx-ng-7.5.0-hd4cf53a_17.conda": { + "build": "hd4cf53a_17", + "build_number": 17, + "depends": [ + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "2f479f358916ea446bc54dbf49d08374", + "name": "libstdcxx-ng", + "sha256": "30704098949813551333da01dc66933b123e6f2d5b9fc9b01e14d97f990c5ad0", + "size": 2049419, + "subdir": "linux-64", + "timestamp": 1622660076260, + "version": "7.5.0" + }, + "libstdcxx-ng-8.2.0-hdf63c60_0.conda": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [], + "license": "GPL3 with runtime exception", + "md5": "25095401b9cd42e47a3cf1739c4d7ad9", + "name": "libstdcxx-ng", + "sha256": "42b2272d979f3b94bc43e26fea6c501e8c6dbd7a5ab37e3460c29f80954a7068", + "size": 2350875, + "subdir": "linux-64", + "timestamp": 1534277515972, + "version": "8.2.0" + }, + "libstdcxx-ng-8.2.0-hdf63c60_1.conda": { + "build": "hdf63c60_1", + "build_number": 1, + "depends": [], + "license": "GPL3 with runtime exception", + "md5": "f8b5131e7d56d09cd2b4626a18cd2d45", + "name": "libstdcxx-ng", + "sha256": "8ecbc7c5495479ccbb6d6741befe9effcda3f98748aeb1fa8c2a4f40ddf23992", + "size": 2350925, + "subdir": "linux-64", + "timestamp": 1534516131602, + "version": "8.2.0" + }, + "libstdcxx-ng-8.4.0-hd4cf53a_17.conda": { + "build": "hd4cf53a_17", + "build_number": 17, + "depends": [ + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "7741dea5b4846da471b1ab3d9cdfcb44", + "name": "libstdcxx-ng", + "sha256": "64388e7e5c028ce52ac2f6c936a7661ee5bf21c65032d9ba279afc08f73428cf", + "size": 2356019, + "subdir": "linux-64", + "timestamp": 1622661686810, + "version": "8.4.0" + }, + "libstdcxx-ng-9.1.0-hdf63c60_0.conda": { + "build": "hdf63c60_0", + "build_number": 0, + "depends": [], + "license": "GPL3 with runtime exception", + "md5": "c3efd14430bedbe0a036a899f50cec7f", + "name": "libstdcxx-ng", + "sha256": "4cd5e8e3ad70b0a611fd94931fd82d845ba602789fa9bbd9f202b9d0da434277", + "size": 3258838, + "subdir": "linux-64", + "timestamp": 1560112223556, + "version": "9.1.0" + }, + "libstdcxx-ng-9.3.0-hd4cf53a_17.conda": { + "build": "hd4cf53a_17", + "build_number": 17, + "depends": [ + "__glibc >=2.17" + ], + "license": "GPL-3.0-only WITH GCC-exception-3.1", + "md5": "47744aca0f5e63c4672d117c3596d937", + "name": "libstdcxx-ng", + "sha256": "0cdad3721336fe93f626289dd45e864eb4a0659ff2094670af01e7eacad28d9c", + "size": 3248965, + "subdir": "linux-64", + "timestamp": 1622663335295, + "version": "9.3.0" + }, + "libtasn1-4.16.0-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-3.0", + "md5": "bcd9553465d04c838be32ac46ccbef09", + "name": "libtasn1", + "sha256": "d8a4a2cdc217900543dd867d4547793d7432ac8e8e2281081567952c5c2ce925", + "size": 59388, + "subdir": "linux-64", + "timestamp": 1617770625491, + "version": "4.16.0" + }, + "libtheora-1.1.1-h5ab3b9f_1.conda": { + "build": "h5ab3b9f_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libogg >=1.3.2,<2.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libvorbis >=1.3.5,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d68deb65b66dce4242def733cd0ae252", + "name": "libtheora", + "sha256": "7fa304366e49f344cb43bd273d0d36c80a35d27b74ebb4a26d195b8292d11889", + "size": 337558, + "subdir": "linux-64", + "timestamp": 1539495957934, + "version": "1.1.1" + }, + "libtheora-1.1.1-h7f8727e_3.conda": { + "build": "h7f8727e_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libogg >=1.3.5,<1.4.0a0", + "libogg >=1.3.5,<2.0a0", + "libvorbis" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "40a96939e4cdf521643211464fa8e8aa", + "name": "libtheora", + "sha256": "fad8a26cc000c37cb6b41ee4443275da11e434d1d6c058594b6ae6ff0baa6baf", + "size": 346096, + "subdir": "linux-64", + "timestamp": 1644826597812, + "version": "1.1.1" + }, + "libthrift-0.13.0-hfb8234f_6.conda": { + "build": "hfb8234f_6", + "build_number": 6, + "depends": [ + "libevent", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl", + "zlib" + ], + "license": "Apache-2.0", + "md5": "4cc7f74be9c3b0e44a778d46d4e3f3fc", + "name": "libthrift", + "sha256": "2792fd0e532c49215940ff5f4547ffa21a4ae38a2c3dbf6d18c8316433db6e4e", + "size": 2622273, + "subdir": "linux-64", + "timestamp": 1612012797813, + "version": "0.13.0" + }, + "libthrift-0.14.2-hcc01f38_0.conda": { + "build": "hcc01f38_0", + "build_number": 0, + "depends": [ + "libevent >=2.1.8,<2.2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "md5": "a63062e8cb0c66c9318a6fb5a6788cc4", + "name": "libthrift", + "sha256": "5ff3fe6c26a69f56159ff2442348d7b3e0f0f1abcf0c1a4164b3e1559a69bf24", + "size": 2931218, + "subdir": "linux-64", + "timestamp": 1632847267327, + "version": "0.14.2" + }, + "libthrift-0.15.0-hcc01f38_0.conda": { + "build": "hcc01f38_0", + "build_number": 0, + "depends": [ + "libevent >=2.1.8,<2.2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl", + "zlib" + ], + "license": "Apache-2.0", + "md5": "626396934bdd78d7bb6d305b5b247fe5", + "name": "libthrift", + "sha256": "7fe3b2cc28bc9850608cd2bf792444d0f956e40a1953bd6f2269b9460f8492fc", + "size": 2938199, + "subdir": "linux-64", + "timestamp": 1631679350731, + "version": "0.15.0" + }, + "libtiff-4.0.10-h2733197_2.conda": { + "build": "h2733197_2", + "build_number": 2, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "HPND", + "md5": "165bf8a9f4767c97bcffc2e94ddfa96e", + "name": "libtiff", + "sha256": "c5f05b59320c88feda7ba7648c05fdc860b58567d3ffaf38608198a7644ba5e9", + "size": 445615, + "subdir": "linux-64", + "timestamp": 1548707350095, + "version": "4.0.10" + }, + "libtiff-4.0.8-h29d08b4_11.conda": { + "build": "h29d08b4_11", + "build_number": 11, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HPND", + "md5": "020e8ce3cf411f5a45825f5a713d7416", + "name": "libtiff", + "sha256": "26b50f4f23ec55e1aefa9e454b3be722f45691bed7671223e7c9b2f42a3806c3", + "size": 431935, + "subdir": "linux-64", + "timestamp": 1511297440769, + "version": "4.0.8" + }, + "libtiff-4.0.8-h90200ff_9.conda": { + "build": "h90200ff_9", + "build_number": 9, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HPND", + "md5": "7e209629fab632dd714ebba6618321a0", + "name": "libtiff", + "sha256": "70207c342ac9ae9049aefb695e2253d9054a87a8545a035c3907983002e84dec", + "size": 431677, + "subdir": "linux-64", + "timestamp": 1505744388925, + "version": "4.0.8" + }, + "libtiff-4.0.9-h28f6b97_0.conda": { + "build": "h28f6b97_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HPND", + "md5": "b9a56392648d406a7e56c6343e49128d", + "name": "libtiff", + "sha256": "0a6bbe0e9ef00836b108c9f8f8b4479cda83cab86b05e819bad8082639eb5599", + "size": 435585, + "subdir": "linux-64", + "timestamp": 1511371632213, + "version": "4.0.9" + }, + "libtiff-4.0.9-he85c1e1_1.conda": { + "build": "he85c1e1_1", + "build_number": 1, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HPND", + "md5": "eddf456361c0198ee6bda0d63eebf310", + "name": "libtiff", + "sha256": "ee7be4d6489b37e6e3c90fb7cf644e51a1ca8ab0314c2f9d9d625ef601d1d3de", + "size": 428966, + "subdir": "linux-64", + "timestamp": 1525875328091, + "version": "4.0.9" + }, + "libtiff-4.0.9-he85c1e1_2.conda": { + "build": "he85c1e1_2", + "build_number": 2, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "HPND", + "md5": "3d25d8b5ce60cea1024c2d9e98138dfc", + "name": "libtiff", + "sha256": "110af6d428678bd44265de6747198cf6278f9497ac581293473445a8cefdcf24", + "size": 432338, + "subdir": "linux-64", + "timestamp": 1535046023487, + "version": "4.0.9" + }, + "libtiff-4.1.0-h2733197_0.conda": { + "build": "h2733197_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "HPND", + "md5": "65d8d208ac6aa09fe90318e7ad3b5a8f", + "name": "libtiff", + "sha256": "8d612b497d509603ae676d971f7a6fc11ffc9f935bea88bd0045fb48f985960d", + "size": 457659, + "subdir": "linux-64", + "timestamp": 1573232994675, + "version": "4.1.0" + }, + "libtiff-4.1.0-h2733197_1.conda": { + "build": "h2733197_1", + "build_number": 1, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4", + "zstd >=1.4.4,<1.5.0a0" + ], + "license": "HPND", + "md5": "6c4806c1cf73eefa92deab14c98c6c15", + "name": "libtiff", + "sha256": "6c956a33ff7cd7c38bcbd749028cc599be1b454798efdb2a0fff57cd3d6674fe", + "size": 459326, + "subdir": "linux-64", + "timestamp": 1591038832602, + "version": "4.1.0" + }, + "libtiff-4.1.0-h2818925_1.conda": { + "build": "h2818925_1", + "build_number": 1, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "libtiff", + "license_family": "OTHER", + "md5": "6c0b7dc1a89f059c0505d587ba6d93a0", + "name": "libtiff", + "sha256": "8f19b3cef322930b4908d10a8b91e1f1ee705f55d4aec10b0cb0c764cb6d93ba", + "size": 447984, + "subdir": "linux-64", + "timestamp": 1655721058367, + "version": "4.1.0" + }, + "libtiff-4.1.0-hecacb30_2.conda": { + "build": "hecacb30_2", + "build_number": 2, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "libtiff", + "license_family": "BSD", + "md5": "362dea9923b540dd8a9211f91f086b8e", + "name": "libtiff", + "sha256": "e907dff36c9cf09f7dc977ee59d1ca164bc8eb49035eda8a182420379c48bbee", + "size": 463970, + "subdir": "linux-64", + "timestamp": 1663085286465, + "version": "4.1.0" + }, + "libtiff-4.2.0-h2818925_1.conda": { + "build": "h2818925_1", + "build_number": 1, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libwebp-base", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "HPND", + "md5": "4197d70794ffb5386cf9d4b59233c481", + "name": "libtiff", + "sha256": "838b1964114b1ec9603ff95a5cae13ced9820f66f7858caac11df79d8b01a283", + "size": 462645, + "subdir": "linux-64", + "timestamp": 1653047881023, + "version": "4.2.0" + }, + "libtiff-4.2.0-h3942068_0.conda": { + "build": "h3942068_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libwebp-base", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "HPND", + "md5": "35e692c43ccad81f56c904634a538ea8", + "name": "libtiff", + "sha256": "6c5829948f4219a828239ef58aae1243e3d77637eafad8d4cd082963e180412a", + "size": 473633, + "subdir": "linux-64", + "timestamp": 1615544136333, + "version": "4.2.0" + }, + "libtiff-4.2.0-h85742a9_0.conda": { + "build": "h85742a9_0", + "build_number": 0, + "depends": [ + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libwebp-base", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "HPND", + "md5": "a70887f6e46ea21d5e4e27685bd59ff9", + "name": "libtiff", + "sha256": "abef7c57f548dd2b9dac487db1a9ffaf949b9505e94af5566778ed8116babbe7", + "size": 513670, + "subdir": "linux-64", + "timestamp": 1616492392965, + "version": "4.2.0" + }, + "libtiff-4.2.0-hecacb30_2.conda": { + "build": "hecacb30_2", + "build_number": 2, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libwebp-base", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "libtiff", + "license_family": "BSD", + "md5": "075965745767d510e794b0d1188b90c9", + "name": "libtiff", + "sha256": "a7bd7f21affafc463ec9a85f5a8aed6ffee52ef3e6726cc1033e0a6f4c649663", + "size": 477583, + "subdir": "linux-64", + "timestamp": 1663278260224, + "version": "4.2.0" + }, + "libtiff-4.4.0-hecacb30_0.conda": { + "build": "hecacb30_0", + "build_number": 0, + "depends": [ + "jpeg >=9e,<10a", + "lerc >=3.0,<4.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libwebp-base", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "HPND", + "md5": "208ff08f39d63d049e97d88de84206a4", + "name": "libtiff", + "sha256": "d11a2bda0e2eeb10043a81588bcae0b4adbac8b095e4d47cd68d1585c449a6ae", + "size": 481839, + "subdir": "linux-64", + "timestamp": 1660660381009, + "version": "4.4.0" + }, + "libtiff-4.4.0-hecacb30_1.conda": { + "build": "hecacb30_1", + "build_number": 1, + "depends": [ + "jpeg >=9e,<10a", + "lerc >=3.0,<4.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libwebp-base", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "HPND", + "license_family": "Other", + "md5": "6b83bcbadf7137e2ac06299816b74d94", + "name": "libtiff", + "sha256": "c1b94a483910df7a735eedb948df102a3b2001b361d18bf91f67d68f4946dffa", + "size": 528146, + "subdir": "linux-64", + "timestamp": 1667343106207, + "version": "4.4.0" + }, + "libtiff-4.4.0-hecacb30_2.conda": { + "build": "hecacb30_2", + "build_number": 2, + "depends": [ + "jpeg >=9e,<10a", + "lerc >=3.0,<4.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libwebp-base", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "HPND", + "license_family": "Other", + "md5": "debd52cb518dce3d4f48833cdc1032e4", + "name": "libtiff", + "sha256": "ff5f5a8346208cabed6f2bf230a169125f7fd7ba7e67dc27636e9b0ccd57679a", + "size": 538484, + "subdir": "linux-64", + "timestamp": 1668535662291, + "version": "4.4.0" + }, + "libtiff-4.5.0-h6a678d5_1.conda": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "jpeg >=9e,<10a", + "lerc >=3.0,<4.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libwebp-base", + "xz >=5.2.10,<6.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "HPND", + "license_family": "Other", + "md5": "b71b31215b01e488547343aec82c9c3c", + "name": "libtiff", + "sha256": "398050bf1aa4e390b63f2a33cdffbf50495bb0e85ce9a6f314c5bdceb761f3b8", + "size": 536829, + "subdir": "linux-64", + "timestamp": 1675328844757, + "version": "4.5.0" + }, + "libtiff-4.5.0-h6a678d5_2.conda": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "jpeg >=9e,<10a", + "lerc >=3.0,<4.0a0", + "libdeflate >=1.17,<1.18.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libwebp-base", + "xz >=5.2.10,<6.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "HPND", + "license_family": "Other", + "md5": "b3391ee6956636eb8ef159c1c454e3da", + "name": "libtiff", + "sha256": "39ae48cb24be0806cae2ca3e3b5b300820f39da145c77b01996856690eecf9ba", + "size": 490840, + "subdir": "linux-64", + "timestamp": 1677493430198, + "version": "4.5.0" + }, + "libtiff-4.5.0-hecacb30_0.conda": { + "build": "hecacb30_0", + "build_number": 0, + "depends": [ + "jpeg >=9e,<10a", + "lerc >=3.0,<4.0a0", + "libdeflate >=1.8,<1.9.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libwebp-base", + "xz >=5.2.8,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "HPND", + "license_family": "Other", + "md5": "ee78c57621673ab656d341c5cd3de211", + "name": "libtiff", + "sha256": "11869ebff018151fe3025dc2b18cebddc9071095239e67155cbe13b220e5bf58", + "size": 540991, + "subdir": "linux-64", + "timestamp": 1673474698484, + "version": "4.5.0" + }, + "libtool-2.4.6-h295c915_1008.conda": { + "build": "h295c915_1008", + "build_number": 1008, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "32cbc73903c5f66ebe97400fb3ef922f", + "name": "libtool", + "sha256": "6c98305e31e647a7cf8500ca3d1f36a630a9bdd2e1daf6fd88a3b1e55f9f57f1", + "size": 403153, + "subdir": "linux-64", + "timestamp": 1644482588290, + "version": "2.4.6" + }, + "libtool-2.4.6-h544aabb_3.conda": { + "build": "h544aabb_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "b21a42f469659372a1eda857caa10433", + "name": "libtool", + "sha256": "8e65c62db5a5efd272d40caf6e37d8d6c745c6f9a2134eb13f1440da93c3740b", + "size": 399883, + "subdir": "linux-64", + "timestamp": 1509873791246, + "version": "2.4.6" + }, + "libtool-2.4.6-h6a678d5_1009.conda": { + "build": "h6a678d5_1009", + "build_number": 1009, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "0e2a600942eb66bbbdae8f1f5fec9693", + "name": "libtool", + "sha256": "60ef1e85059ff15d3f32267e112814194370e88bfb02a98f395d4dabb19c4e7e", + "size": 431384, + "subdir": "linux-64", + "timestamp": 1670318708338, + "version": "2.4.6" + }, + "libtool-2.4.6-h7b6447c_1005.conda": { + "build": "h7b6447c_1005", + "build_number": 1005, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-2.0-or-later", + "md5": "dbb1de63cff5299139e602cd0b147d43", + "name": "libtool", + "sha256": "ef438be9b10baf77517f07b670c76894dbf068067aaa2ab627823d5be75cddac", + "size": 403142, + "subdir": "linux-64", + "timestamp": 1601492198044, + "version": "2.4.6" + }, + "libtool-2.4.6-h7b6447c_5.conda": { + "build": "h7b6447c_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL 3", + "md5": "17c0807a71e8fb53673295ccfc9c0468", + "name": "libtool", + "sha256": "338188a1f9b297372d6dc0e14cff16b910cb897b22dde22471162bb254806ce8", + "size": 397981, + "subdir": "linux-64", + "timestamp": 1538243270871, + "version": "2.4.6" + }, + "libtool-2.4.6-hd50d1a6_0.conda": { + "build": "hd50d1a6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "27fd5cd6e5ac3c7bf6d3770f463ded83", + "name": "libtool", + "sha256": "73e004aaf33adeac2b3962ddd75e6ca572e611b3c9438a3e4913f32b4aa93f53", + "size": 398990, + "subdir": "linux-64", + "timestamp": 1505665992983, + "version": "2.4.6" + }, + "libunistring-0.9.10-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "LGPL", + "md5": "5b6ed6cd1b1ca3a383daef1d6464d02a", + "name": "libunistring", + "sha256": "e513b61d4b848d68a26ce89b00c90cd2958403026a6dea396af870f317199def", + "size": 548433, + "subdir": "linux-64", + "timestamp": 1617770969934, + "version": "0.9.10" + }, + "libunwind-1.5.0-h295c915_1.conda": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9025e1d32415d44319931cf9fd465f63", + "name": "libunwind", + "sha256": "34b021c455def0c5070d2e4679fb38b349458b36f87752a777242ce3066c23a8", + "size": 72022, + "subdir": "linux-64", + "timestamp": 1634151888996, + "version": "1.5.0" + }, + "libutf8proc-2.1.1-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb4958203713398596af1ead69e768f9", + "name": "libutf8proc", + "sha256": "55538f921b11d0650782c05265b925ae890ba63c5d75f97de54c46d7cf1c5097", + "size": 77420, + "subdir": "linux-64", + "timestamp": 1527939600770, + "version": "2.1.1" + }, + "libutf8proc-2.5.0-h14c3975_2.conda": { + "build": "h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c9dd551c747cd2ed4dc59daa23790c0b", + "name": "libutf8proc", + "sha256": "2dd5ed2f4530c14fb24c2990057967f820d1db0b78775da4ec7ab2d785df95c9", + "size": 78920, + "subdir": "linux-64", + "timestamp": 1601293244712, + "version": "2.5.0" + }, + "libutf8proc-2.5.0-h7b6447c_2.conda": { + "build": "h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fddda7759530089e0897895041783b43", + "name": "libutf8proc", + "sha256": "14f39dcb80b593232f9d6e4ab6f24739d728e0e7f37451ef67857aa7d78435a7", + "size": 79559, + "subdir": "linux-64", + "timestamp": 1601293227819, + "version": "2.5.0" + }, + "libutf8proc-2.6.1-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b69614fbde813bc01668a23bb129d28", + "name": "libutf8proc", + "sha256": "c0e226e39b7c4ec64e9dcb23c02ce7bd715e88bd66b8d711a544dfdc1aeee6c4", + "size": 82036, + "subdir": "linux-64", + "timestamp": 1612284952317, + "version": "2.6.1" + }, + "libutf8proc-2.6.1-h5eee18b_1.conda": { + "build": "h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "57528c54ffcacc4c9726cf919f0cb948", + "name": "libutf8proc", + "sha256": "c5a4e400a360160679d3776776cb7608a1d387e10e12f4386ea7b7b657c99e48", + "size": 94602, + "subdir": "linux-64", + "timestamp": 1672422880512, + "version": "2.6.1" + }, + "libuuid-1.0.3-h1bed415_2.conda": { + "build": "h1bed415_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "md5": "c7eb74a82210554559774327088c2582", + "name": "libuuid", + "sha256": "7c4bc14591f14cbe1c92bd0c658c21d1dbe7138a0067b0c9f0fe65bf5ceb8c53", + "size": 15085, + "subdir": "linux-64", + "timestamp": 1515696691334, + "version": "1.0.3" + }, + "libuuid-1.0.3-h5bb35a6_1.conda": { + "build": "h5bb35a6_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "md5": "dc6713dcde0c2365edf9fcb5bb3ecd6b", + "name": "libuuid", + "sha256": "d098bb2fa2c7efc12db7e3af565c43f4eafea229056b47a8fd874b10dc60ae15", + "size": 14515, + "subdir": "linux-64", + "timestamp": 1505745182024, + "version": "1.0.3" + }, + "libuuid-1.0.3-h7f8727e_2.conda": { + "build": "h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "BSD 3-Clause", + "md5": "6c4c9e96bfa4744d4839b9ed128e1114", + "name": "libuuid", + "sha256": "78e174d87231225fd813bd13b281cf249e59d21cc32fb7717473c4f65163af1b", + "size": 17366, + "subdir": "linux-64", + "timestamp": 1633507857274, + "version": "1.0.3" + }, + "libuuid-1.41.5-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4a6a2354414c9080327274aa514e5299", + "name": "libuuid", + "sha256": "2a401aafabac51b7736cfe12d2ab205d29052640ea8183253c9d0a8e7ed0d49a", + "size": 28110, + "subdir": "linux-64", + "timestamp": 1668082729834, + "version": "1.41.5" + }, + "libuv-1.14.0-h56b52c2_0.conda": { + "build": "h56b52c2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23523cfb71e6228e1550c3ea8fe6e891", + "name": "libuv", + "sha256": "43dee7eafb140b5e9df9d051f84e77c06759479e2f4cf5322f349137f110338e", + "size": 599057, + "subdir": "linux-64", + "timestamp": 1505687933785, + "version": "1.14.0" + }, + "libuv-1.19.2-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd19e2e1b369b55d37407a3a5e311a04", + "name": "libuv", + "sha256": "a1aa807490cdf3e40cd8e5b061f952b62dd95011042492383957654093e4a671", + "size": 598003, + "subdir": "linux-64", + "timestamp": 1519712477871, + "version": "1.19.2" + }, + "libuv-1.20.0-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0e211ebde96bd3fae630dccfd99cb687", + "name": "libuv", + "sha256": "bde250a654f5a19cac5a77014c44c3f0f45d4f921f0d1d30d14198b14dc11328", + "size": 603590, + "subdir": "linux-64", + "timestamp": 1523955739908, + "version": "1.20.0" + }, + "libuv-1.20.3-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c19bd114c8eee4aa611e472ab05591aa", + "name": "libuv", + "sha256": "d3caba8d9480d83557db87bd78d8c213b7d71709333bc88d7e1154dcd3980a88", + "size": 602452, + "subdir": "linux-64", + "timestamp": 1527275647125, + "version": "1.20.3" + }, + "libuv-1.22.0-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "35317fae73f6c0b21151f2fe2d81c4c5", + "name": "libuv", + "sha256": "6a176d49d44ef460c7909bcd4642d6594adb384eaa4313100175c59b3bcb2449", + "size": 641117, + "subdir": "linux-64", + "timestamp": 1532575712718, + "version": "1.22.0" + }, + "libuv-1.23.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc42f973d1945a3e2c2c53417f1939de", + "name": "libuv", + "sha256": "91b084cdd1d2805d9c11b3a7c13ccccc521d121e456db791816ff89c05895324", + "size": 638761, + "subdir": "linux-64", + "timestamp": 1536074413202, + "version": "1.23.0" + }, + "libuv-1.23.2-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7384c573142844b893631ad037a842af", + "name": "libuv", + "sha256": "bd5f688f97500589c9f8b8a25903ae50820ede3f2ddb7071781696f81ac85f49", + "size": 636745, + "subdir": "linux-64", + "timestamp": 1539661723002, + "version": "1.23.2" + }, + "libuv-1.24.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "166e276d545cc9e575ad5f6ffbfff000", + "name": "libuv", + "sha256": "c89eaa298bf1b8fe5436c1ce7659f9c3d0229ba79afb9baa5b642c72e9b37c83", + "size": 647447, + "subdir": "linux-64", + "timestamp": 1542390014703, + "version": "1.24.0" + }, + "libuv-1.24.1-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "41c28e04026ba2ccb0e06d20fb2c0b4d", + "name": "libuv", + "sha256": "220d934c310e98498e98c82f936f248754f979fac6fed5b7cae36eda2db06c5c", + "size": 691231, + "subdir": "linux-64", + "timestamp": 1547235277245, + "version": "1.24.1" + }, + "libuv-1.26.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "07cda69732c5e0d027f21e47a41b9889", + "name": "libuv", + "sha256": "e9de8cce5f3e13e700996ad2aa3ae8983d27c66df39e5feda9a317ae4420928b", + "size": 689574, + "subdir": "linux-64", + "timestamp": 1552511866328, + "version": "1.26.0" + }, + "libuv-1.38.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0bbb787ec3670af5e280e280b6b4ffc3", + "name": "libuv", + "sha256": "d338f24221517407eb4756f2a319a9345b4329cb80c99a55010cedb18670b643", + "size": 754527, + "subdir": "linux-64", + "timestamp": 1597416619979, + "version": "1.38.0" + }, + "libuv-1.39.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "28cc3d57d6cd0de91a4e1daa2f8431e2", + "name": "libuv", + "sha256": "f6c367eb1ecfb35a356d41a81539b363bdd0f21db7d9823547f7497372fc84a6", + "size": 766579, + "subdir": "linux-64", + "timestamp": 1600423255660, + "version": "1.39.0" + }, + "libuv-1.40.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb1eff3862d3729995c38fc1f5d71ca4", + "name": "libuv", + "sha256": "c6fc151ab1135a13ff6f1d93530c5d16ff0f333e1bcf01b9ed52c3cfc014f55a", + "size": 753230, + "subdir": "linux-64", + "timestamp": 1601049115502, + "version": "1.40.0" + }, + "libuv-1.44.2-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2c7c0ae511d2f6de249732f53e27b2e", + "name": "libuv", + "sha256": "b9e61e938010cd52f6474d8dbc1794e9880e1468ab2df8c9547555885c189a33", + "size": 885213, + "subdir": "linux-64", + "timestamp": 1677079467117, + "version": "1.44.2" + }, + "libvorbis-1.3.5-h7b6447c_1.conda": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libogg >=1.3.2,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f157ef8446549da87a5707e164a51075", + "name": "libvorbis", + "sha256": "2793dd346f4219671d2be9e9930d6da01bcd36199456c8cb7d8f9da851d25ce3", + "size": 405784, + "subdir": "linux-64", + "timestamp": 1539325110617, + "version": "1.3.5" + }, + "libvorbis-1.3.6-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libogg >=1.3.2,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "52dd294762db2b2a1097b9a6569cfe9d", + "name": "libvorbis", + "sha256": "30e312fbf939816cf4849b0f9881bee72dbc288cf546f2da611cd95432a2da64", + "size": 397954, + "subdir": "linux-64", + "timestamp": 1539664982557, + "version": "1.3.6" + }, + "libvorbis-1.3.7-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libogg >=1.3.2,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "66711b855c73a5ac42127ad8789b6cf3", + "name": "libvorbis", + "sha256": "990a36e750a1eeb85dc18f0958a6a144bbf8a9feb586d4fd16f942e4dcd73962", + "size": 407850, + "subdir": "linux-64", + "timestamp": 1600376062963, + "version": "1.3.7" + }, + "libvpx-1.10.0-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "cbd501325eb921d4ee35fd787e56d18c", + "name": "libvpx", + "sha256": "767b445b04b544d4bcf6370f8162a306b8a364a8646685357092414367fbc44c", + "size": 1558858, + "subdir": "linux-64", + "timestamp": 1632843298172, + "version": "1.10.0" + }, + "libvpx-1.11.0-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e83b182b831e27b7c1d3fcd311cd6020", + "name": "libvpx", + "sha256": "156fae3cee2d3f488c13a0cae09e9004454f174266e920877e132bf049080421", + "size": 1089524, + "subdir": "linux-64", + "timestamp": 1639406907879, + "version": "1.11.0" + }, + "libvpx-1.6.1-h888fd40_0.conda": { + "build": "h888fd40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "6ca8bfcf358f2fad6855dc10e745ef7b", + "name": "libvpx", + "sha256": "b53026415a4c9ec8c6cf98642947d6d485aa318a91f900215a06bd81ead69a51", + "size": 1288554, + "subdir": "linux-64", + "timestamp": 1512432093122, + "version": "1.6.1" + }, + "libvpx-1.7.0-h439df22_0.conda": { + "build": "h439df22_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "b540d4b817e11fb5b9350fea1faca263", + "name": "libvpx", + "sha256": "f76d3b1ba902eba217f2cf3fb326dd6cee47d54843117379fa762e76d0133426", + "size": 1306593, + "subdir": "linux-64", + "timestamp": 1519759593884, + "version": "1.7.0" + }, + "libwebp-1.0.0-h222930b_1.conda": { + "build": "h222930b_1", + "build_number": 1, + "depends": [ + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libtiff >=4.0.9,<5.0a0" + ], + "license": "Google", + "md5": "4937e5f7d89dc37d5eb9b3f1b0d83c0d", + "name": "libwebp", + "sha256": "e42046609513bbe0b30ff4b05100a57da579ed174f5e0c1cfaade8557b1260f6", + "size": 482036, + "subdir": "linux-64", + "timestamp": 1534481283875, + "version": "1.0.0" + }, + "libwebp-1.0.1-h8e7db2f_0.conda": { + "build": "h8e7db2f_0", + "build_number": 0, + "depends": [ + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.35,<1.7.0a0", + "libtiff >=4.0.9,<5.0a0" + ], + "license": "Google", + "md5": "786d06bc5b6374a27553aacab2e48202", + "name": "libwebp", + "sha256": "2a1013d40b03b5cb336f13a6b08b9ddc42c01d8b5183cc14c06f2b33fc2ddc6b", + "size": 482453, + "subdir": "linux-64", + "timestamp": 1542640363230, + "version": "1.0.1" + }, + "libwebp-1.1.0-hd31223b_0.conda": { + "build": "hd31223b_0", + "build_number": 0, + "depends": [ + "giflib >=5.1.4,<5.2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0" + ], + "license": "Google", + "md5": "542e85af8daa85cd5a2c6d16ed4184ed", + "name": "libwebp", + "sha256": "4ed30d50d307acc946dcfbb8a873b3a44fdff6d0b15406d62a02abfcaf2aed8c", + "size": 505396, + "subdir": "linux-64", + "timestamp": 1600443349083, + "version": "1.1.0" + }, + "libwebp-1.2.0-h89dd481_0.conda": { + "build": "h89dd481_0", + "build_number": 0, + "depends": [ + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0" + ], + "license": "Google", + "md5": "dce6cb0ba5fa0097683adacece85aba3", + "name": "libwebp", + "sha256": "b77476dff467d94a2c932d23cb51d0651bd48a0dd5a028724d7fc7701fd68436", + "size": 505036, + "subdir": "linux-64", + "timestamp": 1612214220336, + "version": "1.2.0" + }, + "libwebp-1.2.2-h55f646e_0.conda": { + "build": "h55f646e_0", + "build_number": 0, + "depends": [ + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c9ed6bddefc09dbfc246301c3ce3ca14", + "name": "libwebp", + "sha256": "7d5eb348332133225e5d39eaa143a964239bcd1c4044cf55fdf0dfcbdd8c5853", + "size": 82140, + "subdir": "linux-64", + "timestamp": 1645441199289, + "version": "1.2.2" + }, + "libwebp-1.2.4-h11a3e52_0.conda": { + "build": "h11a3e52_0", + "build_number": 0, + "depends": [ + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base 1.2.4.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "971acc20767cc834a6baffdeaae6a100", + "name": "libwebp", + "sha256": "2ff35590e12f8bbf3247860b333ca386adc566c14115b48a2faccc23f5a31c72", + "size": 81326, + "subdir": "linux-64", + "timestamp": 1665397142365, + "version": "1.2.4" + }, + "libwebp-1.2.4-h11a3e52_1.conda": { + "build": "h11a3e52_1", + "build_number": 1, + "depends": [ + "giflib >=5.2.1,<5.3.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base 1.2.4.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9f9153b30e58e9ce896f74634622cbf1", + "name": "libwebp", + "sha256": "e3329353356fbee47b5947773bd555526459f51ea31982667f3c9a9e9d365535", + "size": 88139, + "subdir": "linux-64", + "timestamp": 1677058936047, + "version": "1.2.4" + }, + "libwebp-base-1.1.0-h7b6447c_3.conda": { + "build": "h7b6447c_3", + "build_number": 3, + "constrains": [ + "libwebp 1.1.0" + ], + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "md5": "e4f4343a422ae7e79f9073e65eb5a178", + "name": "libwebp-base", + "sha256": "db0145b0513c6825d73d84be352b4f54bfd56d1a0c5cdb6d6ba2e49ad6501f46", + "size": 448649, + "subdir": "linux-64", + "timestamp": 1595950847030, + "version": "1.1.0" + }, + "libwebp-base-1.2.0-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "constrains": [ + "libwebp 1.2.0" + ], + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "md5": "4d1ba466be28f57eeba2c341ae1390f4", + "name": "libwebp-base", + "sha256": "a894ef4837385c2bb9ac9abcbb4527e0c5f5051979156179fbbfde21f10f49e1", + "size": 447750, + "subdir": "linux-64", + "timestamp": 1612214102400, + "version": "1.2.0" + }, + "libwebp-base-1.2.2-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "constrains": [ + "libwebp 1.2.2" + ], + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "162451b4884cfc7db8400580c711e83a", + "name": "libwebp-base", + "sha256": "200b4ae8d83efca7dda8a3855a380a602509a031678af5cf08b7aa3c62d56c08", + "size": 450799, + "subdir": "linux-64", + "timestamp": 1645089138421, + "version": "1.2.2" + }, + "libwebp-base-1.2.4-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "constrains": [ + "libwebp 1.2.4" + ], + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f5f56389136bcd9ca92ee1d64afcceb3", + "name": "libwebp-base", + "sha256": "89eb864ce737810f8354eb648ba6e461037faf9e313279193b1c61bc24660a9a", + "size": 355031, + "subdir": "linux-64", + "timestamp": 1665395933749, + "version": "1.2.4" + }, + "libwebp-base-1.2.4-h5eee18b_1.conda": { + "build": "h5eee18b_1", + "build_number": 1, + "constrains": [ + "libwebp 1.2.4" + ], + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a65a20c48061ecf2a6f4f02eae9f2366", + "name": "libwebp-base", + "sha256": "1749b5bf683234089fe8d7a405c6b1af5c4017febbeda572b77737224fb2625b", + "size": 385400, + "subdir": "linux-64", + "timestamp": 1677057926950, + "version": "1.2.4" + }, + "libxcb-1.12-h84ff03f_3.conda": { + "build": "h84ff03f_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e73cc9f3a0cc1c9dd0854331d854022b", + "name": "libxcb", + "sha256": "121291f2cdddf07d78e111b8a8230cddf6d637ca9a0c92582a30295b9daa7f6a", + "size": 384334, + "subdir": "linux-64", + "timestamp": 1507908036832, + "version": "1.12" + }, + "libxcb-1.12-hcd93eb1_4.conda": { + "build": "hcd93eb1_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc624b1cd57e6d03dd597b187ee9ae5a", + "name": "libxcb", + "sha256": "12ec835c63958f34c16deac9f2ff4e3b5d4c194a618a51587987f6e13c2d3d0e", + "size": 386141, + "subdir": "linux-64", + "timestamp": 1511297685381, + "version": "1.12" + }, + "libxcb-1.12-he6ee5dd_2.conda": { + "build": "he6ee5dd_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "820863818c7944298c4e8c3a7bf70400", + "name": "libxcb", + "sha256": "a0250054f7100df58e177962f4d66c5393e2162c564055d139f35be7da44b494", + "size": 385297, + "subdir": "linux-64", + "timestamp": 1505734062961, + "version": "1.12" + }, + "libxcb-1.13-h1bed415_0.conda": { + "build": "h1bed415_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "md5": "179c50026aba12cef669c1c6efc0ae74", + "name": "libxcb", + "sha256": "be101a724bd388928f6d9307794cf4e9ddd95271e61df5d56b3203431c3e1ca5", + "size": 431287, + "subdir": "linux-64", + "timestamp": 1522698448141, + "version": "1.13" + }, + "libxcb-1.13-h1bed415_1.conda": { + "build": "h1bed415_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "md5": "e04bd9ad2cc33b55eafd738f2c5d102c", + "name": "libxcb", + "sha256": "1c4e43f22b7977bb4fef1b22b140b7a882679d3f5263f9ad7d435c0a90bdbc95", + "size": 431577, + "subdir": "linux-64", + "timestamp": 1523637427898, + "version": "1.13" + }, + "libxcb-1.14-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "md5": "05811f2f9a9af28f3d7d665dca4d573e", + "name": "libxcb", + "sha256": "a715f9f5484de1cc39a4182e46a762cf574ff0b13ff6daeff74563f3791528a4", + "size": 517169, + "subdir": "linux-64", + "timestamp": 1593535452782, + "version": "1.14" + }, + "libxcb-1.15-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "md5": "ada518dcadd6aaee9aae47ba9a671553", + "name": "libxcb", + "sha256": "9feb197125e4803d702cfdf10116c856e381b59f845b3346f50cb10e9bb8c643", + "size": 517527, + "subdir": "linux-64", + "timestamp": 1652448233146, + "version": "1.15" + }, + "libxgboost-0.7-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "md5": "de2f312cebca2213b5a806015c4291aa", + "name": "libxgboost", + "sha256": "7f52287a15634251b5a2b65677aeb9745b09e30697f5f6c9f2acb84f35a104c6", + "size": 1611061, + "subdir": "linux-64", + "timestamp": 1521480984755, + "version": "0.7" + }, + "libxgboost-0.71-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "md5": "3b735b164a78850d554c4031f7fb77d6", + "name": "libxgboost", + "sha256": "7bbe89098d73918935572414617cb815e41cd02ceb2cdf0ab5c0fbb0e2ff552e", + "size": 1732190, + "subdir": "linux-64", + "timestamp": 1525821700805, + "version": "0.71" + }, + "libxgboost-0.72-h83be7fe_0.conda": { + "build": "h83be7fe_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "md5": "db4dcaf6fd8915438e777e8b493f8fc9", + "name": "libxgboost", + "sha256": "4a5e7be85c132787ecf682ff72c23a0a7727f6a9fcb03dbc536044fa1e5c05f3", + "size": 2991139, + "subdir": "linux-64", + "timestamp": 1530222934712, + "version": "0.72" + }, + "libxgboost-0.72-h87a4715_0.conda": { + "build": "h87a4715_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "md5": "7975df6c3e7d1370f77232397d69756e", + "name": "libxgboost", + "sha256": "5339f9e0d083611cd23a872a23ed281881fc948799e02557740c8083f064526d", + "size": 3208859, + "subdir": "linux-64", + "timestamp": 1530223606110, + "version": "0.72" + }, + "libxgboost-0.72-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "md5": "60e671a25d72c2e1ee4623abbae550db", + "name": "libxgboost", + "sha256": "fecb034c5049a3af80d1d9a472f8ad5404644c9980c466ab2407438e2b4f1982", + "size": 1754053, + "subdir": "linux-64", + "timestamp": 1530218256438, + "version": "0.72" + }, + "libxgboost-0.80-h51060c3_0.conda": { + "build": "h51060c3_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "md5": "85c11caa2d6629cccc9a066f229a71d3", + "name": "libxgboost", + "sha256": "5a18c90d4454146147ef68d0acb98bb058638a391cfa1d754fe87da2ad485afa", + "size": 3974836, + "subdir": "linux-64", + "timestamp": 1541468824993, + "version": "0.80" + }, + "libxgboost-0.80-h6cbba54_0.conda": { + "build": "h6cbba54_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.2.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "md5": "24048743cab9b9439b642b69ecea6b3f", + "name": "libxgboost", + "sha256": "63397b4e91671c74e5ab036f9f9b79e2b10a95d5bdf97514f849d446ddb5c7c7", + "size": 4355044, + "subdir": "linux-64", + "timestamp": 1541450084466, + "version": "0.80" + }, + "libxgboost-0.80-h6edc907_0.conda": { + "build": "h6edc907_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "md5": "41a575f61b0b5cadd5b7332e0818f5d0", + "name": "libxgboost", + "sha256": "84ba801c48a80a7ad8651d5b631b6f5c25f7445e4f2b938b26bff067df53bd56", + "size": 4297303, + "subdir": "linux-64", + "timestamp": 1541451058067, + "version": "0.80" + }, + "libxgboost-0.80-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "md5": "5ce19dc3155e280fcfde06a880c665fb", + "name": "libxgboost", + "sha256": "123514b5e82c5bd20ef07140ffcdd7d5695e4a8743677edd70f5a67c97032039", + "size": 1825751, + "subdir": "linux-64", + "timestamp": 1540835319640, + "version": "0.80" + }, + "libxgboost-0.90-h295c915_1.conda": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "md5": "f984be29e2551281082f3d8abee6ef88", + "name": "libxgboost", + "sha256": "f584886992fd3da2b188f3ed1253c61d5e517a3403e2c634f3567f610359272c", + "size": 1966552, + "subdir": "linux-64", + "timestamp": 1642675470075, + "version": "0.90" + }, + "libxgboost-0.90-h4d71fd4_0.conda": { + "build": "h4d71fd4_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "md5": "4169ad91bf611bffe80b4ecbbcbbd8b7", + "name": "libxgboost", + "sha256": "8d0dcb18b0ddde3686a2cd8fbcf5f589a0d6d4db6599746ec0682af9ea9165a6", + "size": 7019163, + "subdir": "linux-64", + "timestamp": 1560802228082, + "version": "0.90" + }, + "libxgboost-0.90-h688424c_0.conda": { + "build": "h688424c_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "md5": "04107587f94fc38e528f56528336fefc", + "name": "libxgboost", + "sha256": "1e347652db5b7c39a8758a772efe5bb079e112d50807b204414d627b0956b465", + "size": 7326077, + "subdir": "linux-64", + "timestamp": 1560801030555, + "version": "0.90" + }, + "libxgboost-0.90-h6edc907_0.conda": { + "build": "h6edc907_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "md5": "980405772eec73ec7a6dae3efa30dbb7", + "name": "libxgboost", + "sha256": "4ec7ef875b76372e7ec6c6cdd100601c44cc96f71eff99b3043677466f0447b2", + "size": 5772686, + "subdir": "linux-64", + "timestamp": 1560804818600, + "version": "0.90" + }, + "libxgboost-0.90-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "md5": "9c2252aed1441a12482f86c3433c5d55", + "name": "libxgboost", + "sha256": "4d1fb442fc1c1d94c53553b87293a57437f274b4fb721e4e5788b9242b200b2e", + "size": 1999542, + "subdir": "linux-64", + "timestamp": 1559931184751, + "version": "0.90" + }, + "libxgboost-0.90-he6710b0_1.conda": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "md5": "350e8dac0f9fcdd2151a833e68f97919", + "name": "libxgboost", + "sha256": "b3aa26660c68db3e9995cc56c23844ee8dc90dd350a24a683245ff2f753830dd", + "size": 1999374, + "subdir": "linux-64", + "timestamp": 1572481299536, + "version": "0.90" + }, + "libxgboost-0.90-hf484d3e_1.conda": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [], + "md5": "2190f7a02f4136a02b9db91588b4a94e", + "name": "libxgboost", + "sha256": "ba8f879d156d62210bdb5a83867e6e136d65d2e0fd0c7233a0795a9b7855f20f", + "size": 1995939, + "subdir": "linux-64", + "timestamp": 1572476412182, + "version": "0.90" + }, + "libxgboost-1.3.3-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "md5": "6fb281862eef2ec1da41fcc4bf1dd600", + "name": "libxgboost", + "sha256": "bdb921406fb8d37677900d9414b67ef4430324e4eaf8dab3e6512cbbfe685104", + "size": 1937637, + "subdir": "linux-64", + "timestamp": 1619724716187, + "version": "1.3.3" + }, + "libxgboost-1.5.0-h295c915_1.conda": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "md5": "b39c890553bf6a5a5fcb4a77b5cec461", + "name": "libxgboost", + "sha256": "b86a749ba53ceed5c4fccc32cdb78c9d464512c636d1a2e5ec9e91ced57aa0cb", + "size": 2046100, + "subdir": "linux-64", + "timestamp": 1638290161400, + "version": "1.5.0" + }, + "libxgboost-1.5.0-h6a678d5_2.conda": { + "build": "h6a678d5_2", + "build_number": 2, + "depends": [ + "_openmp_mutex", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0", + "md5": "ef7ae22c0e376be9e8acc563a2cf66d3", + "name": "libxgboost", + "sha256": "1458305dad0a3f41ae5bf6340f38371287d2f85104944504e75173c97db57580", + "size": 2135131, + "subdir": "linux-64", + "timestamp": 1659549271981, + "version": "1.5.0" + }, + "libxgboost-1.5.1-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9f7334503d5d8ac73db63ceac5839798", + "name": "libxgboost", + "sha256": "291832e6aefe57b797461ae8a17bb6cd9471970b9cb5acbfe57c0a72195d70e0", + "size": 3395005, + "subdir": "linux-64", + "timestamp": 1675119947017, + "version": "1.5.1" + }, + "libxgboost-1.7.3-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6e0e825a668992a0dde11c06c541f012", + "name": "libxgboost", + "sha256": "8f6f3062c776b482be10db0ac69850f799df715a697519c12a12da68d975c7c3", + "size": 4058916, + "subdir": "linux-64", + "timestamp": 1675458035048, + "version": "1.7.3" + }, + "libxkbcommon-1.0.1-h5eee18b_1.conda": { + "build": "h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libxcb >=1.15,<2.0a0", + "libxml2 >=2.10.3,<2.11.0a0" + ], + "license": "MIT/X11 Derivative", + "license_family": "MIT", + "md5": "888b2e8f1bbf21017c503826e2d24b50", + "name": "libxkbcommon", + "sha256": "d0ad34ddd1a6d391ec291ae7a126646b2f5794cdca4bd00cc6e2afc4233fb27e", + "size": 604308, + "subdir": "linux-64", + "timestamp": 1679578328295, + "version": "1.0.1" + }, + "libxkbcommon-1.0.1-hfa300c1_0.conda": { + "build": "hfa300c1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxcb >=1.14,<2.0a0", + "libxml2 >=2.9.12,<2.10.0a0" + ], + "license": "MIT/X11 Derivative", + "license_family": "MIT", + "md5": "913e6c7c04026ff341960a9700889498", + "name": "libxkbcommon", + "sha256": "03f4513acad39e52f579e8a38b776afb12c865e042e5d7d09a0c65417f6f5451", + "size": 494699, + "subdir": "linux-64", + "timestamp": 1642166105276, + "version": "1.0.1" + }, + "libxml2-2.10.3-hcbfbd50_0.conda": { + "build": "hcbfbd50_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=11.2.0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95357588631b66da8f97ddbfbdf2e4e1", + "name": "libxml2", + "sha256": "8a503b845992732166ac3251fb0399facd8e0f3d2d3cce43f15949e85ce9e6b0", + "size": 773086, + "subdir": "linux-64", + "timestamp": 1678468377187, + "version": "2.10.3" + }, + "libxml2-2.9.10-hb55368b_3.conda": { + "build": "hb55368b_3", + "build_number": 3, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5cc9d595a9d91c2f5c1d722252e27343", + "name": "libxml2", + "sha256": "2a9de88b92469a616b75f91fcc47a9d5e17b7d529d8984f7642295ef1051232e", + "size": 1240061, + "subdir": "linux-64", + "timestamp": 1603239296279, + "version": "2.9.10" + }, + "libxml2-2.9.10-he19cac6_1.conda": { + "build": "he19cac6_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12b40388ca82d5610b7abd96ca91c08f", + "name": "libxml2", + "sha256": "83c0da624871612c9109b66eae52858d368aab4778023b58199f27594f4e5ae5", + "size": 1232429, + "subdir": "linux-64", + "timestamp": 1591981384134, + "version": "2.9.10" + }, + "libxml2-2.9.12-h03d6c58_0.conda": { + "build": "h03d6c58_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=9.3.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "521d2ff23ffb87c5bf7e673ac780270b", + "name": "libxml2", + "sha256": "8cb4ba69be2ff7199905552a4eb82329425ff8125155ef6d74927b2818453c8b", + "size": 1242428, + "subdir": "linux-64", + "timestamp": 1624477975749, + "version": "2.9.12" + }, + "libxml2-2.9.12-h74e7548_1.conda": { + "build": "h74e7548_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ac7815a8b90fcc5f12b129f7c86af735", + "name": "libxml2", + "sha256": "f7c9bb7581f26df8fe6567cd168b2ae495e53babdb858396b24ec7de0ec93454", + "size": 1236417, + "subdir": "linux-64", + "timestamp": 1651841277535, + "version": "2.9.12" + }, + "libxml2-2.9.12-h74e7548_2.conda": { + "build": "h74e7548_2", + "build_number": 2, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eff5ba91c84a8329c2a1117bee13cd68", + "name": "libxml2", + "sha256": "f09c6452b6bd81cf0d7ea05325a7c5aaaa99a10ec12b8be7a68982e3e95dfd1b", + "size": 1238231, + "subdir": "linux-64", + "timestamp": 1652884304398, + "version": "2.9.12" + }, + "libxml2-2.9.14-h74e7548_0.conda": { + "build": "h74e7548_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2eafeb1cb5f00b034d150f3d70436e52", + "name": "libxml2", + "sha256": "9863bcc7b1ab7cc3dfeb8206eeae135953f3712892a8a7d5151358a0342772e6", + "size": 735354, + "subdir": "linux-64", + "timestamp": 1653546418059, + "version": "2.9.14" + }, + "libxml2-2.9.4-h2e8b1d7_6.conda": { + "build": "h2e8b1d7_6", + "build_number": 6, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "94c1efb5262a1d29a65ecbe9649eeb9e", + "name": "libxml2", + "sha256": "07f365f32f01ae67da387f2bf23b52c316f727a1577d356025e7e1d04a451908", + "size": 1557937, + "subdir": "linux-64", + "timestamp": 1511294538916, + "version": "2.9.4" + }, + "libxml2-2.9.4-h6b072ca_5.conda": { + "build": "h6b072ca_5", + "build_number": 5, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02c8d3ca1aedf3e1c304b4d7eb83d02b", + "name": "libxml2", + "sha256": "7a2967dd96b68b26de79f1fd80c1c51ca9a55c1f4464e2fa55b36627dd0ee74a", + "size": 1557227, + "subdir": "linux-64", + "timestamp": 1505734150613, + "version": "2.9.4" + }, + "libxml2-2.9.7-h26e45fe_0.conda": { + "build": "h26e45fe_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3332e2e7d5d545a03a16640f6ced8de1", + "name": "libxml2", + "sha256": "73db441985b04cfe7c2b32e2d98edbb4a03a8000ff3d22c3540ef675ec10661c", + "size": 1546960, + "subdir": "linux-64", + "timestamp": 1516985287556, + "version": "2.9.7" + }, + "libxml2-2.9.8-h26e45fe_1.conda": { + "build": "h26e45fe_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b781167bfbabec565c688c6e5c5e1e15", + "name": "libxml2", + "sha256": "8aeb43241c24d08bc0e7607af8220921b9c08c85e7230bc3cba55b718699f5d5", + "size": 1549342, + "subdir": "linux-64", + "timestamp": 1527065267245, + "version": "2.9.8" + }, + "libxml2-2.9.8-hf84eae3_0.conda": { + "build": "hf84eae3_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8e4e4f0d6030751c2e46d773c7f9d7f", + "name": "libxml2", + "sha256": "86374203f0b41df8bc9f52c1ffa59cb87e5ab8afe180aa6d598e90ded5825b2f", + "size": 1548876, + "subdir": "linux-64", + "timestamp": 1522941159616, + "version": "2.9.8" + }, + "libxml2-2.9.9-he19cac6_0.conda": { + "build": "he19cac6_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea02380e622eaeaa380418b3cde783b7", + "name": "libxml2", + "sha256": "5e2a47b8c78d84d28f5bcc8d65274b4ed5ebd5d179768adfa9c3a41c882f7c75", + "size": 1628681, + "subdir": "linux-64", + "timestamp": 1547910704655, + "version": "2.9.9" + }, + "libxml2-2.9.9-hea5a465_1.conda": { + "build": "hea5a465_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b559b699acc426292f2c618f09065017", + "name": "libxml2", + "sha256": "9a72d7b139c3cbf29f43787578660bda247f5521c8e3e0d495bae4c602e5c7e4", + "size": 1629703, + "subdir": "linux-64", + "timestamp": 1561393276600, + "version": "2.9.9" + }, + "libxmlsec1-1.2.29-h69ce41f_1.conda": { + "build": "h69ce41f_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libgcrypt >=1.9.1,<2.0a0", + "libgpg-error >=1.41,<2.0a0", + "libtool >=2.4.6,<3.0a0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "MIT and MPL-1.1", + "license_family": "MIT", + "md5": "0c65f86a0d116427ae7204f1b453bfd3", + "name": "libxmlsec1", + "sha256": "cf8317cedcfa6d9e899883ca58a31fa163ee07b19ed937212a5946c5a5d61dfe", + "size": 588228, + "subdir": "linux-64", + "timestamp": 1613393703376, + "version": "1.2.29" + }, + "libxmlsec1-1.2.29-h8fe84ac_0.conda": { + "build": "h8fe84ac_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libgcrypt >=1.8.4,<2.0a0", + "libgpg-error >=1.32,<2.0a0", + "libtool >=2.4.6,<3.0a0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "openssl >=1.1.1e,<1.1.2a" + ], + "license": "MIT and MPL-1.1", + "license_family": "MIT", + "md5": "9d8bc33d3b3f9c39a0903f8ff7e131f6", + "name": "libxmlsec1", + "sha256": "ed437d6e0dc077f058c623453d263cf30782f6c1c1a58e4261fecc12fb6f4004", + "size": 528405, + "subdir": "linux-64", + "timestamp": 1584995437454, + "version": "1.2.29" + }, + "libxmlsec1-1.2.32-hba55599_1.conda": { + "build": "hba55599_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=11.2.0", + "libgcrypt >=1.9.3,<2.0a0", + "libgpg-error >=1.42,<2.0a0", + "libtool >=2.4.6,<3.0a0", + "libxml2 >=2.10.3,<2.11.0a0", + "libxslt >=1.1.37,<2.0a0", + "openssl >=1.1.1t,<1.1.2a", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zlib >=1.2.13,<2.0a0" + ], + "license": "MIT and MPL-1.1", + "license_family": "MIT", + "md5": "151fec291e800666d68cf7fe632772a2", + "name": "libxmlsec1", + "sha256": "f85f75d504bfbf28c0e1937237955637d11e02aa5190a1bfa14de135c3bc37b5", + "size": 378688, + "subdir": "linux-64", + "timestamp": 1679901692026, + "version": "1.2.32" + }, + "libxmlsec1-1.2.32-hd42b715_0.conda": { + "build": "hd42b715_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "libgcrypt >=1.9.3,<2.0a0", + "libgpg-error >=1.42,<2.0a0", + "libtool >=2.4.6,<3.0a0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "openssl >=1.1.1l,<1.1.2a", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<2.0a0" + ], + "license": "MIT and MPL-1.1", + "license_family": "MIT", + "md5": "f5d10155e5b8acb8f4ccede8f69843dd", + "name": "libxmlsec1", + "sha256": "25007ebc5a5d099f1cfe787f36be99b0e4a96b9c63eb9bdb8aa2bc74a351c915", + "size": 648270, + "subdir": "linux-64", + "timestamp": 1636111200451, + "version": "1.2.32" + }, + "libxslt-1.1.29-h78d5cac_6.conda": { + "build": "h78d5cac_6", + "build_number": 6, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0" + ], + "license": "MIT", + "md5": "6ba3fc499b9e4bfcf76a3b8da35de41a", + "name": "libxslt", + "sha256": "c88fa7c8fa75b92990492620db5a9465d05c0a0620b6a7640b15b880a0e26f0b", + "size": 421529, + "subdir": "linux-64", + "timestamp": 1511294861873, + "version": "1.1.29" + }, + "libxslt-1.1.29-hcf9102b_5.conda": { + "build": "hcf9102b_5", + "build_number": 5, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0" + ], + "license": "MIT", + "md5": "eaaaef057b1ef0af95384e295a83344e", + "name": "libxslt", + "sha256": "5a2e2652cd7a905d90cc523927c40f21dc0fb4e0c43e9cefec5fa03c0a10caf0", + "size": 420937, + "subdir": "linux-64", + "timestamp": 1505745247786, + "version": "1.1.29" + }, + "libxslt-1.1.32-h1312cb7_0.conda": { + "build": "h1312cb7_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0" + ], + "license": "MIT", + "md5": "6ed89f191febd490c7dc7b7d27bbd293", + "name": "libxslt", + "sha256": "064f7c118ecda8edb1006393e10ae3aa11822ab5408753314d83195e8f72e22c", + "size": 424811, + "subdir": "linux-64", + "timestamp": 1516986820353, + "version": "1.1.32" + }, + "libxslt-1.1.33-h7d1a2b0_0.conda": { + "build": "h7d1a2b0_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0" + ], + "license": "MIT", + "md5": "56c05c1104eb8f0dd29230bc757241cc", + "name": "libxslt", + "sha256": "4b013ba71a910ddeb6ccd580fde5dc42367a1bee44aae3970cad42f3e1800325", + "size": 436699, + "subdir": "linux-64", + "timestamp": 1547922875391, + "version": "1.1.33" + }, + "libxslt-1.1.34-hc22bd24_0.conda": { + "build": "hc22bd24_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0" + ], + "license": "MIT", + "md5": "9bc13800c7779f0d6a12bed3048c6aee", + "name": "libxslt", + "sha256": "c7f40fbbb201b449581ca718b1d7333a2f9f330f39ae9d9d9e9c68f46aabd155", + "size": 442607, + "subdir": "linux-64", + "timestamp": 1591988409457, + "version": "1.1.34" + }, + "libxslt-1.1.35-h4e12654_0.conda": { + "build": "h4e12654_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.14,<2.10.0a0" + ], + "license": "MIT", + "md5": "328c111d87dccd5a3e471a691833f670", + "name": "libxslt", + "sha256": "34fea43799502927463bb7938721b7b62402b9be140726dcb1794747cab72c8b", + "size": 463477, + "subdir": "linux-64", + "timestamp": 1654075843119, + "version": "1.1.35" + }, + "libxslt-1.1.37-h2085143_0.conda": { + "build": "h2085143_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "680f9676bf55bdafd276eaa12fbb0f28", + "name": "libxslt", + "sha256": "13db4a414874d5eb1ccbbf685ca582932407cf69406116f63b715a78e94612bd", + "size": 272456, + "subdir": "linux-64", + "timestamp": 1679578063222, + "version": "1.1.37" + }, + "libzip-1.5.1-h8d318fa_1002.conda": { + "build": "h8d318fa_1002", + "build_number": 1002, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f5bdb6d5e8921e53a9f54803b0dc1f74", + "name": "libzip", + "sha256": "3554dfff1768213a0e7065a5df5557c5368be62385cfcdde3a2db3f8620db2ee", + "size": 114289, + "subdir": "linux-64", + "timestamp": 1640109303459, + "version": "1.5.1" + }, + "libzip-1.5.1-h8d318fa_1003.conda": { + "build": "h8d318fa_1003", + "build_number": 1003, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1m,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38c56ac4e3a1c0287d66441785b029b7", + "name": "libzip", + "sha256": "359a3b78740870b921033125634809f6feacf67052e3c5535c914021be2d994b", + "size": 114540, + "subdir": "linux-64", + "timestamp": 1646852435711, + "version": "1.5.1" + }, + "libzip-1.5.1-h8d318fa_1004.conda": { + "build": "h8d318fa_1004", + "build_number": 1004, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1n,<1.1.2a", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "53e2263cae447edce1b0a2853ffcd629", + "name": "libzip", + "sha256": "27adc1c54971c6b1a982faa975a3d43b28a3f92bde82be7a3120043a8e20f16b", + "size": 86985, + "subdir": "linux-64", + "timestamp": 1651789268252, + "version": "1.5.1" + }, + "libzip-1.8.0-h5cef20c_0.conda": { + "build": "h5cef20c_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1o,<1.1.2a", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2c05cec60531418cf88ebb3502e94d42", + "name": "libzip", + "sha256": "40a27e754dfef2e58505a2040cacf8d83d784b10b382c7a0045af32d9f34aa8b", + "size": 103973, + "subdir": "linux-64", + "timestamp": 1652978513482, + "version": "1.8.0" + }, + "libzopfli-1.0.3-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8671895f71c9046f38b814f8662226f5", + "name": "libzopfli", + "sha256": "b7d6dee99369d2e602bb0901e7d468db3d6567a4af3666b75213ef268c560d39", + "size": 174889, + "subdir": "linux-64", + "timestamp": 1593197391897, + "version": "1.0.3" + }, + "license-expression-30.0.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "boolean.py >=4.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "12ffacfefb63b23c70a5dd99f96bdf1c", + "name": "license-expression", + "sha256": "330f2f6d861c003d0e7644caed230866db328dd2b87bbc345bb58a206570b402", + "size": 92484, + "subdir": "linux-64", + "timestamp": 1663022085127, + "version": "30.0.0" + }, + "license-expression-30.0.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "boolean.py >=4.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "082f33c845c134ed8784c8b22d022513", + "name": "license-expression", + "sha256": "ad0ebdd9e68a167c5d3fab4b6cb8f50db08b592d8846c8980c68c74e320fc419", + "size": 106280, + "subdir": "linux-64", + "timestamp": 1676844694173, + "version": "30.0.0" + }, + "license-expression-30.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "boolean.py >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3775c3763e8bf689081b099498e7cd1b", + "name": "license-expression", + "sha256": "9b310873c4931bbe5a2d0c6f350b5e12fbb1e2eecb02437a10134734c40b2f64", + "size": 92366, + "subdir": "linux-64", + "timestamp": 1663022045248, + "version": "30.0.0" + }, + "license-expression-30.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "boolean.py >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "18144f758ba96ebff324bd8b918fb13d", + "name": "license-expression", + "sha256": "3d11ee628f07f1769e41f56e3b516a066a9adee8d53d2dfa2c56428dc408cd54", + "size": 92529, + "subdir": "linux-64", + "timestamp": 1663021989216, + "version": "30.0.0" + }, + "license-expression-30.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "boolean.py >=4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6bbf230c483fb632719dd0224647eb0d", + "name": "license-expression", + "sha256": "3bbb6f65df983faf52e18c61313a8a9adfea94fdcf62ee83af2d1f217f874ddc", + "size": 92371, + "subdir": "linux-64", + "timestamp": 1663022017832, + "version": "30.0.0" + }, + "lightgbm-2.2.1-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e8575eae6c811dcc6d476125aebda65", + "name": "lightgbm", + "sha256": "bc07afffa115eb20d8f2cb6ed48905b21e5c2e1de393c86c970908168afc9bc9", + "size": 856528, + "subdir": "linux-64", + "timestamp": 1543625057268, + "version": "2.2.1" + }, + "lightgbm-2.2.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d03a9b7eb990f6c424456ca602969b8a", + "name": "lightgbm", + "sha256": "be450ce122e4a067bd0eb73b1584ec504796a59a1f7b72889590c52a67495843", + "size": 856320, + "subdir": "linux-64", + "timestamp": 1543625069147, + "version": "2.2.1" + }, + "lightgbm-2.2.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff91cf5ea1b002d4fce92ac717c55080", + "name": "lightgbm", + "sha256": "fba4792cfbf65e8263b50e528d5ea2bbd60be628b7766285e69a93058f5f9e38", + "size": 855854, + "subdir": "linux-64", + "timestamp": 1543625044113, + "version": "2.2.1" + }, + "lightgbm-2.2.3-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6446de378a977080a7fd718a0493d03b", + "name": "lightgbm", + "sha256": "dce20a86a81ff7c71bf7839be11ce1211e1b29c5e56064836981835215b847b5", + "size": 902773, + "subdir": "linux-64", + "timestamp": 1569435358278, + "version": "2.2.3" + }, + "lightgbm-2.2.3-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e14d3a7217d6667ffd00b48bf114e834", + "name": "lightgbm", + "sha256": "d6a9357d735772987567f84a86440aec39d1cac9c67965249b2e5446aecdce17", + "size": 902590, + "subdir": "linux-64", + "timestamp": 1569435382322, + "version": "2.2.3" + }, + "lightgbm-2.2.3-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "519fbc5d9a60bd47fbcd82e88624fd61", + "name": "lightgbm", + "sha256": "249a7906807fe5f974ef603554bb51763a7b3c968f839b8246a931f1c0015142", + "size": 903559, + "subdir": "linux-64", + "timestamp": 1569435374229, + "version": "2.2.3" + }, + "lightgbm-2.3.0-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "50819b0b8bd907b6f3ed11d8d4974943", + "name": "lightgbm", + "sha256": "a0d73c2e9419ca41dcec873574b90179768e771cb653dfb068451ffa7f2cf811", + "size": 957952, + "subdir": "linux-64", + "timestamp": 1573966561878, + "version": "2.3.0" + }, + "lightgbm-2.3.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ef1549800b2807e0ce38f0a931c04cd", + "name": "lightgbm", + "sha256": "4b7dfe860c17692590ec8448e1aa1990ecacd607dbb55cc19315c0faf4de2573", + "size": 958288, + "subdir": "linux-64", + "timestamp": 1573966564271, + "version": "2.3.0" + }, + "lightgbm-2.3.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34a60c8ba1ce1657d5b17f733affb493", + "name": "lightgbm", + "sha256": "b0ae98adc78a79ee52fa33b313e78f812db08d3593262d7850d5ad1e346749f9", + "size": 958220, + "subdir": "linux-64", + "timestamp": 1573966611991, + "version": "2.3.0" + }, + "lightgbm-2.3.0-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "878059f1586a4d67fdc57c3a474a2227", + "name": "lightgbm", + "sha256": "eb374ef3b45fb3dad0e2d5d6c6e7d8b83ec48cdf154a438a3e9aaba388a056e9", + "size": 963367, + "subdir": "linux-64", + "timestamp": 1574412880732, + "version": "2.3.0" + }, + "lightgbm-3.1.1-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49f0d18f0b96cc1ad3058d597e2b3c47", + "name": "lightgbm", + "sha256": "dbf0e55fbe6ccd1e9ef83983b5d4f65d5e931f2196b0b564550b94c1455f32b7", + "size": 1341452, + "subdir": "linux-64", + "timestamp": 1607536112798, + "version": "3.1.1" + }, + "lightgbm-3.1.1-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "27a9c2aee30c254352ea2d0d45c23ab3", + "name": "lightgbm", + "sha256": "10352c58d358026dfd855160ca3f0872a82b96ff1f4128680c82c0b7cb7fae9b", + "size": 1342607, + "subdir": "linux-64", + "timestamp": 1607536084787, + "version": "3.1.1" + }, + "lightgbm-3.1.1-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d39b3d67d40c6b86612ce78813a1ad4", + "name": "lightgbm", + "sha256": "310be71c5fa77bcc638bf57547d8f7a23ad73b8f6c845aa69649a5511afee23f", + "size": 1342320, + "subdir": "linux-64", + "timestamp": 1607536069312, + "version": "3.1.1" + }, + "lightgbm-3.1.1-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45168e4e1f5c44048d46b95cbb6882bf", + "name": "lightgbm", + "sha256": "1e1ac08734d56e689c5fc8220214e799160a35349f056545d56d2fd88dbf233d", + "size": 1343694, + "subdir": "linux-64", + "timestamp": 1614247416843, + "version": "3.1.1" + }, + "lightgbm-3.2.1-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy", + "python >=3.10,<3.11.0a0", + "scikit-learn !=0.22.0", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "89dd6858a2b6302eaeb780f0dbd91f85", + "name": "lightgbm", + "sha256": "3810d59de7b3d5ca2d62141599a78224a12f604e2dbc6e7709ba8e970e55e909", + "size": 1515528, + "subdir": "linux-64", + "timestamp": 1640812315695, + "version": "3.2.1" + }, + "lightgbm-3.2.1-py36h295c915_0.conda": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn !=0.22.0", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8280b4b6da53b820ebea842b5ddab67", + "name": "lightgbm", + "sha256": "cc6dfc934ebaff24e6c5cb7b0483b57dd5cd2f88f5fba3b40f26c5ab724aa70a", + "size": 1510049, + "subdir": "linux-64", + "timestamp": 1633019330387, + "version": "3.2.1" + }, + "lightgbm-3.2.1-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn !=0.22.0", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a457c97fdf706bc7d741d0ec33ef8783", + "name": "lightgbm", + "sha256": "12d88e9bd1b289a4c191446666e4afcc42ba77094908f5d4a848d7184688b4d7", + "size": 1511579, + "subdir": "linux-64", + "timestamp": 1633019245678, + "version": "3.2.1" + }, + "lightgbm-3.2.1-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn !=0.22.0", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c8e2ff7527018b50bf051d7c5f763319", + "name": "lightgbm", + "sha256": "7278d1f5ddfdacb19bee8c83c4ddb211d26e13b74ae71d446412d955e72f60cd", + "size": 1512207, + "subdir": "linux-64", + "timestamp": 1633008815333, + "version": "3.2.1" + }, + "lightgbm-3.2.1-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn !=0.22.0", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45730bbde6c076f8af3c46bce01e7510", + "name": "lightgbm", + "sha256": "c9fb28b6c0d91673bcebf585ecaa2f654ed77473c7d1ff85e053e809aa62bb58", + "size": 1513971, + "subdir": "linux-64", + "timestamp": 1633019335543, + "version": "3.2.1" + }, + "lightgbm-3.3.5-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.10,<3.11.0a0", + "scikit-learn !=0.22.0", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c3a4b59f33c982bf7041c155113ac19", + "name": "lightgbm", + "sha256": "50423d05e9aa17a50ab32bd9430ecc72c181e4333304efa385ee3659879f07c7", + "size": 1823415, + "subdir": "linux-64", + "timestamp": 1677766611806, + "version": "3.3.5" + }, + "lightgbm-3.3.5-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.11,<3.12.0a0", + "scikit-learn !=0.22.0", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ec8d4564cabb5817c7ef3791ed816d1", + "name": "lightgbm", + "sha256": "5dadfa6cdede33278d41c09ab7616380194f526559ffc24f1b09c18d807a0467", + "size": 1691106, + "subdir": "linux-64", + "timestamp": 1677700446736, + "version": "3.3.5" + }, + "lightgbm-3.3.5-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn !=0.22.0", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dace14399995251bd21428d76df114bb", + "name": "lightgbm", + "sha256": "1ea151e266f6d07dc83642f706116ce63a29634c942583b0d63e5cd95a4d71da", + "size": 1822658, + "subdir": "linux-64", + "timestamp": 1677766847806, + "version": "3.3.5" + }, + "lightgbm-3.3.5-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn !=0.22.0", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4cef2c7ade39b3185162ac348ddf95ad", + "name": "lightgbm", + "sha256": "65b3aeb7eb33b841a05a4dc9dde0ca4aa10b10c16574b03ff07f85e7810d0fc0", + "size": 1821762, + "subdir": "linux-64", + "timestamp": 1677766730638, + "version": "3.3.5" + }, + "lightning-utilities-0.7.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=17.1", + "python >=3.10,<3.11.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c9ac9247f4f620342e86b8ccdf83608a", + "name": "lightning-utilities", + "sha256": "be23b7819c5d2fb4d983180943a5ade893479251c38d5e9f7eff7fc6341e3b5c", + "size": 30285, + "subdir": "linux-64", + "timestamp": 1677510363916, + "version": "0.7.1" + }, + "lightning-utilities-0.7.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata >=4.0.0", + "packaging >=17.1", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c318f3fb160718c8ce522b2e9d02ee0a", + "name": "lightning-utilities", + "sha256": "8732434721bd44fc1046023ee6c6a6db3912817717470bbbb05d7d802b07785f", + "size": 29970, + "subdir": "linux-64", + "timestamp": 1677510413507, + "version": "0.7.1" + }, + "lightning-utilities-0.7.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=17.1", + "python >=3.8,<3.9.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "193b26116c5da903a05d7e1af4ef1d51", + "name": "lightning-utilities", + "sha256": "96e3eac9a3c8ce43110659d4c4d56c62d5233a499f1974d9d682f6c7e92ea8d3", + "size": 30043, + "subdir": "linux-64", + "timestamp": 1677510388593, + "version": "0.7.1" + }, + "lightning-utilities-0.7.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=17.1", + "python >=3.9,<3.10.0a0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1ae56bb93df28bd8cec400fc83691517", + "name": "lightning-utilities", + "sha256": "878e43449fa9c0520597886047d0d4dfd0d2a8599ca7a5c9f1de5e8088fb0fa2", + "size": 30075, + "subdir": "linux-64", + "timestamp": 1677510338880, + "version": "0.7.1" + }, + "lighttpd-1.4.50-h334f0b8_0.conda": { + "build": "h334f0b8_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.2.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "openssl >=1.0.2p,<1.0.3a", + "pcre >=8.42,<9.0a0", + "sqlite >=3.24.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a4029e09b6cab11c69c7f3dff9776105", + "name": "lighttpd", + "sha256": "2bae9e152a90a2fa94bdeaaba2e543013aed1d3eddf72482a8bc8ea30b698709", + "size": 329739, + "subdir": "linux-64", + "timestamp": 1534674947922, + "version": "1.4.50" + }, + "lighttpd-1.4.51-h3fd3949_1.conda": { + "build": "h3fd3949_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "krb5 >=1.19.4,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "libxml2 >=2.10.3,<2.11.0a0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre >=8.45,<9.0a0", + "sqlite >=3.41.1,<4.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4dc5aba27bbd182326a6df5895430150", + "name": "lighttpd", + "sha256": "9258af766e8bc9c4d5d3732def8128c44afe81766e3fce0cd82b34421bb2af87", + "size": 359457, + "subdir": "linux-64", + "timestamp": 1679578399483, + "version": "1.4.51" + }, + "lighttpd-1.4.51-hccf73bf_0.conda": { + "build": "hccf73bf_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "openssl >=1.1.1a,<1.1.2a", + "pcre >=8.42,<9.0a0", + "sqlite >=3.25.2,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8b89d4a1d26e0e6b8bf948767197df83", + "name": "lighttpd", + "sha256": "cffde3ddacf67d8b9a49347797e847bf275cf04dcfc4806d799ae8815d14c50e", + "size": 330878, + "subdir": "linux-64", + "timestamp": 1541011665435, + "version": "1.4.51" + }, + "line_profiler-2.1.2-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "ipython >=0.13", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "c6989ecf979ae34f7539407403501592", + "name": "line_profiler", + "sha256": "72753d628a4bf75f2c40aef5c3c837f0bfbf3306c1b78c2a4cae75677feeb671", + "size": 60827, + "subdir": "linux-64", + "timestamp": 1522774147770, + "version": "2.1.2" + }, + "line_profiler-2.1.2-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "ipython >=0.13", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "2904d743d4cd3dee6b8e472ea5fc592f", + "name": "line_profiler", + "sha256": "c9c7ee96e5f9897f9c134d16037ae32698c8f6778685466f319d2383d0b070db", + "size": 60631, + "subdir": "linux-64", + "timestamp": 1522774155546, + "version": "2.1.2" + }, + "line_profiler-2.1.2-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "ipython >=0.13", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "d924354984700f4aae868cfb3cd92f46", + "name": "line_profiler", + "sha256": "c5e0a28f72f886853ee43052d27116d05d406c9e4d9d7f0b192ab195c13ddb08", + "size": 61224, + "subdir": "linux-64", + "timestamp": 1522773913002, + "version": "2.1.2" + }, + "line_profiler-2.1.2-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "ipython >=0.13", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "fe514bf6245866c72cdb44ee2820df56", + "name": "line_profiler", + "sha256": "eb35019b76a75104791cb44ac57082278332462024f1f7b956fd7025be052aaf", + "size": 64100, + "subdir": "linux-64", + "timestamp": 1530898397461, + "version": "2.1.2" + }, + "line_profiler-2.1.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "ipython >=0.13", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "4a4d815f4b530d8890f07bb71d47ca49", + "name": "line_profiler", + "sha256": "b90fb2944eaa94581c08c4ccf1c21c6c7ebbc5b2e0973cbd7970fce9cbc54a30", + "size": 66625, + "subdir": "linux-64", + "timestamp": 1574235796144, + "version": "2.1.2" + }, + "line_profiler-3.3.1-py310hd09550d_0.conda": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "ipython >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "55e91ac382c85c0aabd41df840e57f35", + "name": "line_profiler", + "sha256": "5bf22fd3463a8d82b3d8f1cc00c9d556604f68869f26d6369d8c71523c1d5f0e", + "size": 69371, + "subdir": "linux-64", + "timestamp": 1642674911590, + "version": "3.3.1" + }, + "line_profiler-3.3.1-py37hd09550d_0.conda": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "ipython >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "ce1e36050595f2bf93e95b0d4cc4d38f", + "name": "line_profiler", + "sha256": "62a0d11d4c3fb2db7af32bb32799015fe2ba634a318e6d6bdba13adf21077e9c", + "size": 62442, + "subdir": "linux-64", + "timestamp": 1642087268983, + "version": "3.3.1" + }, + "line_profiler-3.3.1-py38hd09550d_0.conda": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "ipython >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "891cccf64d8e5e25381248e661af1840", + "name": "line_profiler", + "sha256": "cd6cb8ffd58255d778503d5baea957d12eaae5a029b33a2b9366b640adfdf1f4", + "size": 66171, + "subdir": "linux-64", + "timestamp": 1642087304655, + "version": "3.3.1" + }, + "line_profiler-3.3.1-py39hd09550d_0.conda": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "ipython >=0.13", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "34d861ac626c93e1b738c058f68d3aee", + "name": "line_profiler", + "sha256": "ecba660ebb1f079f606b3ef24231eea0aa6ccf1851ee6870d367b0fc8b19eb69", + "size": 66075, + "subdir": "linux-64", + "timestamp": 1642087232099, + "version": "3.3.1" + }, + "linecache2-1.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 1.0", + "md5": "1b7d8fd15f7aff406dbbc4c98c3fa714", + "name": "linecache2", + "sha256": "9abf1e23628c3af30eaa6a9b2407101a246ac741c4ff8cea21ed1e89185b630f", + "size": 25204, + "subdir": "linux-64", + "timestamp": 1530898427744, + "version": "1.0.0" + }, + "linecache2-1.0.0-py27hc477507_0.conda": { + "build": "py27hc477507_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 1.0", + "md5": "c252e00da84847e21814835c22247664", + "name": "linecache2", + "sha256": "bbd26cee4770c3c39a35ad8edf9c8115034c661c4f5a4076d5d8fa7d14196f0f", + "size": 25499, + "subdir": "linux-64", + "timestamp": 1508303281657, + "version": "1.0.0" + }, + "linecache2-1.0.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "PSF 1.0", + "md5": "cc3689dc28dbd4a0140dfd63f70308c4", + "name": "linecache2", + "sha256": "6437a8c337b0efe2e204591c8e07b507cf8c8ba4da5c981fd9a7399ccf7eae5b", + "size": 27543, + "subdir": "linux-64", + "timestamp": 1642499453271, + "version": "1.0.0" + }, + "linecache2-1.0.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "PSF 1.0", + "md5": "2e0c928689ca21652f28a720369b898c", + "name": "linecache2", + "sha256": "dc1eb3bf29cd8e28926d5411bf11f7669dd74fd7612c142207caef74935b4035", + "size": 37443, + "subdir": "linux-64", + "timestamp": 1676844708741, + "version": "1.0.0" + }, + "linecache2-1.0.0-py35h4c29c73_0.conda": { + "build": "py35h4c29c73_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "PSF 1.0", + "md5": "78b34299dc132aef0cf29aadf0da0cd4", + "name": "linecache2", + "sha256": "6e2f42b01d5d94642c4222900dd754fe46599279dffb680873e53c5f6264b097", + "size": 27627, + "subdir": "linux-64", + "timestamp": 1508303284304, + "version": "1.0.0" + }, + "linecache2-1.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF 1.0", + "md5": "114e1b57d84dc80fb8baeea84d612c83", + "name": "linecache2", + "sha256": "e08c9fda7967e72999736908cfda3d883d03a1dfd5bfb9f0d1a2bc55afb38d61", + "size": 26797, + "subdir": "linux-64", + "timestamp": 1530898483874, + "version": "1.0.0" + }, + "linecache2-1.0.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF 1.0", + "md5": "2c93fc5a3fbac8780098057882ddc614", + "name": "linecache2", + "sha256": "3c9828190466308b740a4eb47b75b5b0c979d48c219b67c1b590d09674762c42", + "size": 27822, + "subdir": "linux-64", + "timestamp": 1632843428671, + "version": "1.0.0" + }, + "linecache2-1.0.0-py36h9981fe4_0.conda": { + "build": "py36h9981fe4_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF 1.0", + "md5": "b960020e3ea87b697a037bb0612ba0c9", + "name": "linecache2", + "sha256": "4d99a126b2b823d8ac20436e10e2e55da13d1408f94a799b6dcf804c02b09178", + "size": 27071, + "subdir": "linux-64", + "timestamp": 1508303293240, + "version": "1.0.0" + }, + "linecache2-1.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF 1.0", + "md5": "ecf60d30bd91691eb4b71b0735bf0d96", + "name": "linecache2", + "sha256": "0ee6f04edf8a588face4a1d5a7be4c9623a0451dff65cefbdaae54ad5aae1bd2", + "size": 26843, + "subdir": "linux-64", + "timestamp": 1530898455164, + "version": "1.0.0" + }, + "linecache2-1.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF 1.0", + "md5": "f223bc1030fb9781b16df1b0ab09903b", + "name": "linecache2", + "sha256": "51d1e1acf53f638601aa8e2ea27923b135c622aa0bfde652bf587296c8e6977f", + "size": 27855, + "subdir": "linux-64", + "timestamp": 1632843242996, + "version": "1.0.0" + }, + "linecache2-1.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF 1.0", + "md5": "33a4d6183414fc876695b52620830aac", + "name": "linecache2", + "sha256": "349131f6095817e2e5d7e888ff8146a2b6de73fab121ab228b210bba31363134", + "size": 27711, + "subdir": "linux-64", + "timestamp": 1573489840960, + "version": "1.0.0" + }, + "linecache2-1.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF 1.0", + "md5": "528af4bbee616a0b478bde7ce06975c0", + "name": "linecache2", + "sha256": "5127357eede98df27db9689df267b4064094aba295a42d2b10afe705f6ee8cb0", + "size": 28018, + "subdir": "linux-64", + "timestamp": 1632843426559, + "version": "1.0.0" + }, + "linecache2-1.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF 1.0", + "md5": "9885bcc18a93447fbb459f75e007d20a", + "name": "linecache2", + "sha256": "239543f4e895678339c5e186456979aea7168f46aae44677d825eec07dae24bc", + "size": 28110, + "subdir": "linux-64", + "timestamp": 1632833017245, + "version": "1.0.0" + }, + "linkify-it-py-2.0.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "uc-micro-py >=1.0.1,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b612530b9ad95eca4304313219acada", + "name": "linkify-it-py", + "sha256": "f86c1f819e44287b2af34d3506d3e7152b13605aa663fda01bf3a431a3a8a06b", + "size": 35099, + "subdir": "linux-64", + "timestamp": 1659783460274, + "version": "2.0.0" + }, + "linkify-it-py-2.0.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "uc-micro-py >=1.0.1,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e2a59d8198c6d0396095efc7cd74b81d", + "name": "linkify-it-py", + "sha256": "0217282ddbfe67fb6b52953a05c7b3863601135e6457311ba1414d7ce3ea2b3e", + "size": 39927, + "subdir": "linux-64", + "timestamp": 1676837080881, + "version": "2.0.0" + }, + "linkify-it-py-2.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "uc-micro-py >=1.0.1,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "72a47fb5738860196e0bce5e2080e028", + "name": "linkify-it-py", + "sha256": "0e5217f9d21ce07cc8267ccc9a0413727a65a2f91e907fd59f998598e3d4b8ad", + "size": 37131, + "subdir": "linux-64", + "timestamp": 1659783420814, + "version": "2.0.0" + }, + "linkify-it-py-2.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "uc-micro-py >=1.0.1,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63e2c9909f31692aa45d758b5a7fa57c", + "name": "linkify-it-py", + "sha256": "c292d3b6e308a4fe52d6617cd12331a16c0bf5a3c6f898f53552a7abbee36b87", + "size": 37486, + "subdir": "linux-64", + "timestamp": 1659783395053, + "version": "2.0.0" + }, + "linkify-it-py-2.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "uc-micro-py >=1.0.1,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c6c8ef9243f30ff92e9830b81ad3a33f", + "name": "linkify-it-py", + "sha256": "cfafb1c469e5625ec9b5505517b2a880fcf79bc3e445a17b1ffb3b07b6afe615", + "size": 34939, + "subdir": "linux-64", + "timestamp": 1659783489143, + "version": "2.0.0" + }, + "lit-11.1.0-py310h06a4308_5.conda": { + "build": "py310h06a4308_5", + "build_number": 5, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "791a5c31d137757eb099d78ed40bf5a6", + "name": "lit", + "sha256": "453a339c4d69a9f579f6d0153d8463deac6b25b323152739e3bf4ea40e4d7ffb", + "size": 176888, + "subdir": "linux-64", + "timestamp": 1662598064569, + "version": "11.1.0" + }, + "lit-11.1.0-py310h06a4308_6.conda": { + "build": "py310h06a4308_6", + "build_number": 6, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "e861e3c9c17af0f33a7e0230b839ca39", + "name": "lit", + "sha256": "96baad59ef52d4cb6bfb2e7fcc6bdb93a2fd7d4da8616f5e3857ff9aabe648da", + "size": 160542, + "subdir": "linux-64", + "timestamp": 1665079326433, + "version": "11.1.0" + }, + "lit-11.1.0-py37h06a4308_5.conda": { + "build": "py37h06a4308_5", + "build_number": 5, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "306f9f098ff3b281b871c156915f6716", + "name": "lit", + "sha256": "7df58321945e51cd5cebdfc9147260ce77c7363009ccf49febea6353fa8a1bcf", + "size": 175569, + "subdir": "linux-64", + "timestamp": 1662598074866, + "version": "11.1.0" + }, + "lit-11.1.0-py37h06a4308_6.conda": { + "build": "py37h06a4308_6", + "build_number": 6, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "3b680f7d58d12e9d0e7f7cd47a52d9c9", + "name": "lit", + "sha256": "f2cb991669e0587f9e1d7f433f99f228b287a81f8bbb3c0d937a850c9608fb4f", + "size": 159219, + "subdir": "linux-64", + "timestamp": 1665079316322, + "version": "11.1.0" + }, + "lit-11.1.0-py38h06a4308_5.conda": { + "build": "py38h06a4308_5", + "build_number": 5, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "d9c12cc53a3f0d1068129cd7bec2130d", + "name": "lit", + "sha256": "c4b4237bd682dc2c0790b1447b8da31e240ba8d8c73a09c62af42a2db22fbca8", + "size": 176046, + "subdir": "linux-64", + "timestamp": 1662598053870, + "version": "11.1.0" + }, + "lit-11.1.0-py38h06a4308_6.conda": { + "build": "py38h06a4308_6", + "build_number": 6, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "ec479532641559bbc230782a7a91e644", + "name": "lit", + "sha256": "c612dcc9dc4b7db1ea847a8eb17b81c21b870d8103c0cf9b97e8b4a7348068ad", + "size": 159514, + "subdir": "linux-64", + "timestamp": 1665079345892, + "version": "11.1.0" + }, + "lit-11.1.0-py39h06a4308_5.conda": { + "build": "py39h06a4308_5", + "build_number": 5, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "2b5d3b1298e6b0638363a45773b04a57", + "name": "lit", + "sha256": "50b536fcdf4b08cf3593c21783de51c24510eab4a6d70ca75b96e19681b60341", + "size": 175944, + "subdir": "linux-64", + "timestamp": 1662598043534, + "version": "11.1.0" + }, + "lit-11.1.0-py39h06a4308_6.conda": { + "build": "py39h06a4308_6", + "build_number": 6, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "f4b1894c9c54fadab3a6cba5b8acd4b2", + "name": "lit", + "sha256": "d53ff79338fe8184ce7247f2692db537bec8d1da64cbe0ac0e39872575a08fba", + "size": 159465, + "subdir": "linux-64", + "timestamp": 1665079336216, + "version": "11.1.0" + }, + "lit-14.0.6-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "c510c818d0467cca4851bc66a9ca565a", + "name": "lit", + "sha256": "47c6fcf8516a3c6ed9f1ee1db7bbf40f343355ba6f7b26f642326a126cc56561", + "size": 183567, + "subdir": "linux-64", + "timestamp": 1661449658029, + "version": "14.0.6" + }, + "lit-14.0.6-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "4d024c7f0fe5e818bb8bd4191a78e545", + "name": "lit", + "sha256": "4c67cf04a7e3304c68fcc7e45f1d5f70a0e076c514dd9df383763ace443d24c6", + "size": 195661, + "subdir": "linux-64", + "timestamp": 1669293249820, + "version": "14.0.6" + }, + "lit-14.0.6-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "8179ae424fc01d1733460d5d7ca72709", + "name": "lit", + "sha256": "ff6575a6da05cc0404edc7474d24af900da76b6b80a62bca8bfd0f34491a44d3", + "size": 234012, + "subdir": "linux-64", + "timestamp": 1676858397032, + "version": "14.0.6" + }, + "lit-14.0.6-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "624014ff56b29dd4aa77c7fa9ab5d435", + "name": "lit", + "sha256": "ecf597076c22e0a911c16245b92b9aa656aff0812a1735a9eb4fb41c01524134", + "size": 181993, + "subdir": "linux-64", + "timestamp": 1661449623622, + "version": "14.0.6" + }, + "lit-14.0.6-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "bdabd9ae61dd5a6177c6dfdb63852647", + "name": "lit", + "sha256": "f4dacbbf880d929c789196a5dff8e27d132cbe0834680d654ce72425b0493955", + "size": 194190, + "subdir": "linux-64", + "timestamp": 1669293259278, + "version": "14.0.6" + }, + "lit-14.0.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "54481430b2e221ac8d8b9a6f30d0b15c", + "name": "lit", + "sha256": "e21cb334afa6601d17fe0c47695a2d3404583ad0362fa4c57e745f6c38bc8eed", + "size": 182598, + "subdir": "linux-64", + "timestamp": 1661449647636, + "version": "14.0.6" + }, + "lit-14.0.6-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "11d78d39e49a0b6ea98ee09a6ff7436e", + "name": "lit", + "sha256": "0f333a3aaa3076b6d18b512b48225d29f0306c9100419ad4eb1e9c9cbd0c13ec", + "size": 194944, + "subdir": "linux-64", + "timestamp": 1669293239691, + "version": "14.0.6" + }, + "lit-14.0.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "9d4d8a4022cf95157d76a1b6620547b7", + "name": "lit", + "sha256": "593833f8b07f7b587dddc596c4ce70924841046bdb49cc001f892121e7a40382", + "size": 182528, + "subdir": "linux-64", + "timestamp": 1661449637629, + "version": "14.0.6" + }, + "lit-14.0.6-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "592cf4e83c1cefaa64d3c3a794face92", + "name": "lit", + "sha256": "fb7339872108e1961a543e6cad4453b770daa2f6e63050a229e174d9f7617f21", + "size": 194785, + "subdir": "linux-64", + "timestamp": 1669293230178, + "version": "14.0.6" + }, + "lld-14.0.6-hbe14939_0.conda": { + "build": "hbe14939_0", + "build_number": 0, + "constrains": [ + "llvm ==14.0.6" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "80f5f368266b48fd8c075c8ed2ec0ecb", + "name": "lld", + "sha256": "feaea961cdb2178e9099c238c9ba101dea73d0a7634c86d1056e8a530b9f50e2", + "size": 2558925, + "subdir": "linux-64", + "timestamp": 1662539715612, + "version": "14.0.6" + }, + "llvm-10.0.0-h21ff451_1.conda": { + "build": "h21ff451_1", + "build_number": 1, + "constrains": [ + "llvmdev 10.0.0" + ], + "depends": [ + "libllvm10 10.0.0 h4a3c616_1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "4a2a2c47f1ba78b0c0033f6d4f44ca8c", + "name": "llvm", + "sha256": "93acf75dc786024fe68580fb82daa1bc8184e58bbe1e668078be6911e4eb2b3b", + "size": 67355, + "subdir": "linux-64", + "timestamp": 1594485764666, + "version": "10.0.0" + }, + "llvm-10.0.1-h21ff451_5.conda": { + "build": "h21ff451_5", + "build_number": 5, + "constrains": [ + "llvmdev 10.0.1" + ], + "depends": [ + "libllvm10 10.0.1 hbcb73fb_5" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "c0ce4dab4ad2cbff9aa181a8cf705087", + "name": "llvm", + "sha256": "ddbc537e23ab5d6cc698dede5e1284379838cc17cd9da87543d75643a8954b6a", + "size": 67660, + "subdir": "linux-64", + "timestamp": 1599257532356, + "version": "10.0.1" + }, + "llvm-11.0.0-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "constrains": [ + "llvmdev 11.0.0" + ], + "depends": [ + "libllvm11 11.0.0 h3826bc1_0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "991609a0dccb67e5eed34b9d9078e4fe", + "name": "llvm", + "sha256": "7578e2ad6e86e0a2209bba439de086ac3d57115a980294836a5abd7ac3e65549", + "size": 69559, + "subdir": "linux-64", + "timestamp": 1626720923008, + "version": "11.0.0" + }, + "llvm-11.0.0-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "constrains": [ + "llvmdev 11.0.0" + ], + "depends": [ + "libllvm11 11.0.0 h3826bc1_1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "9955546de2ae952010ae02ac4755ab21", + "name": "llvm", + "sha256": "ab19c1c21bae342542926effc0b234af6a7b070509c6cec5a4a4c1c448ea47f0", + "size": 71901, + "subdir": "linux-64", + "timestamp": 1646054295328, + "version": "11.0.0" + }, + "llvm-11.1.0-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "constrains": [ + "llvmdev 11.1.0" + ], + "depends": [ + "libllvm11 11.1.0 h3826bc1_0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "b9679ac809b3aceb5a08ee9d5e05172a", + "name": "llvm", + "sha256": "a06c21cee1e5a80e1239c33afc59b92ab650b7b7fd3409395b496d6955dacfb1", + "size": 72346, + "subdir": "linux-64", + "timestamp": 1624906857917, + "version": "11.1.0" + }, + "llvm-11.1.0-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "constrains": [ + "llvmdev 11.1.0" + ], + "depends": [ + "libllvm11 11.1.0 h3826bc1_1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "c8970e42b25373b4617c7672dc0b40df", + "name": "llvm", + "sha256": "d177fd3b711aac137482480a58a31eafe7ff80570a47c68bcfb8c47600672e08", + "size": 53419, + "subdir": "linux-64", + "timestamp": 1647523930959, + "version": "11.1.0" + }, + "llvm-11.1.0-h06a4308_5.conda": { + "build": "h06a4308_5", + "build_number": 5, + "constrains": [ + "llvmdev 11.1.0" + ], + "depends": [ + "libllvm11 11.1.0 h9e868ea_5" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "2dda06a9fea23443fa733e4d043c935f", + "name": "llvm", + "sha256": "021fc609b12a95811a8395bfa49cd5331baf5ad4fa259bf459f395029e0a9da1", + "size": 54758, + "subdir": "linux-64", + "timestamp": 1662598084620, + "version": "11.1.0" + }, + "llvm-11.1.0-h06a4308_6.conda": { + "build": "h06a4308_6", + "build_number": 6, + "constrains": [ + "llvmdev 11.1.0" + ], + "depends": [ + "libllvm11 11.1.0 h9e868ea_6" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "071196e2fbceeccf22ea35dd1cced11b", + "name": "llvm", + "sha256": "0faa01035274a348f7ec15c3700e3c9fbafeca891bbbc7b951005d8227f8da2b", + "size": 38049, + "subdir": "linux-64", + "timestamp": 1665079353199, + "version": "11.1.0" + }, + "llvm-14.0.6-h5c3875c_0.conda": { + "build": "h5c3875c_0", + "build_number": 0, + "constrains": [ + "llvmdev 14.0.6" + ], + "depends": [ + "libllvm14 14.0.6 hef93074_0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "3b82fc0dd25cb9bd57b18d18ee5577a4", + "name": "llvm", + "sha256": "c5348e5056da277f9c826dc2be954facca0af61437ee20afaa48d233177469d0", + "size": 52271, + "subdir": "linux-64", + "timestamp": 1661449666688, + "version": "14.0.6" + }, + "llvm-14.0.6-h5c3875c_1.conda": { + "build": "h5c3875c_1", + "build_number": 1, + "constrains": [ + "llvmdev 14.0.6" + ], + "depends": [ + "libllvm14 14.0.6 h9e868ea_1", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "ff86c85c1b0c4cff1b13ebb6db47c1e2", + "name": "llvm", + "sha256": "495970466f8a5a1cf9a0f5d21f88e3839fbef7fddafe6437be2bb91221f17dfe", + "size": 55098, + "subdir": "linux-64", + "timestamp": 1669293267975, + "version": "14.0.6" + }, + "llvm-9.0.1-h21ff451_0.conda": { + "build": "h21ff451_0", + "build_number": 0, + "constrains": [ + "llvmdev 9.0.1" + ], + "depends": [ + "libllvm9 9.0.1 h4a3c616_0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "1499d45853820f54c98c3fbb7d4529c2", + "name": "llvm", + "sha256": "a1374cc9e673c0fd1e6bea657e6d53f060b80fb326cc020bb023eb4e0bf27f6f", + "size": 65033, + "subdir": "linux-64", + "timestamp": 1592929469333, + "version": "9.0.1" + }, + "llvm-9.0.1-h21ff451_1.conda": { + "build": "h21ff451_1", + "build_number": 1, + "constrains": [ + "llvmdev 9.0.1" + ], + "depends": [ + "libllvm9 9.0.1 h4a3c616_1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "341b5ccd07588e6f4451d1d8b609d022", + "name": "llvm", + "sha256": "5780f597bd603db6c1d4ca1b092cfa0f00600d4073eaf4ace01f4404e711e447", + "size": 66123, + "subdir": "linux-64", + "timestamp": 1594477718085, + "version": "9.0.1" + }, + "llvm-openmp-14.0.6-h9e868ea_0.conda": { + "build": "h9e868ea_0", + "build_number": 0, + "constrains": [ + "openmp 14.0.6|14.0.6.*" + ], + "depends": [ + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "ea4b8facb65d80d5520255fd331bae37", + "name": "llvm-openmp", + "sha256": "c7377016c8219e0090e82c79f9b01873d4a20804908a6b773f8250e40fb49255", + "size": 4586926, + "subdir": "linux-64", + "timestamp": 1662635605547, + "version": "14.0.6" + }, + "llvm-spirv-11.0.0-hd09550d_0.conda": { + "build": "hd09550d_0", + "build_number": 0, + "constrains": [ + "llvmdev 11.0.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.0.0,<11.1.0a0", + "libstdcxx-ng >=7.5.0" + ], + "license": "NCSA", + "license_family": "BSD", + "md5": "82b2071a680befa8839950088368f8a2", + "name": "llvm-spirv", + "sha256": "cfabacec7da91a3baa4675ed95e7bf3245253233d73a2bb1f469bf6f52998b83", + "size": 853050, + "subdir": "linux-64", + "timestamp": 1646149310654, + "version": "11.0.0" + }, + "llvm-tools-10.0.0-h4a3c616_1.conda": { + "build": "h4a3c616_1", + "build_number": 1, + "constrains": [ + "llvmdev 10.0.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 10.0.0 h4a3c616_1", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "0f25a8c455820e42e9614d3f83ef35d9", + "name": "llvm-tools", + "sha256": "a08ae458ebd99186ae8a63aa1c1b1ad4fc9571fd3e1196b4ee756818c54b9bc2", + "size": 4550603, + "subdir": "linux-64", + "timestamp": 1594485791785, + "version": "10.0.0" + }, + "llvm-tools-10.0.1-h4a3c616_5.conda": { + "build": "h4a3c616_5", + "build_number": 5, + "constrains": [ + "llvmdev 10.0.1" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 10.0.1 hbcb73fb_5", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "b9b7d110d863bdc7b07dccd59f1bf564", + "name": "llvm-tools", + "sha256": "89dc3a5c066236c29a75aae9f326742d30d1b136d11d05914fcd7d23e5ff60e7", + "size": 4558555, + "subdir": "linux-64", + "timestamp": 1599257608678, + "version": "10.0.1" + }, + "llvm-tools-11.0.0-h3826bc1_0.conda": { + "build": "h3826bc1_0", + "build_number": 0, + "constrains": [ + "llvmdev 11.0.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 11.0.0 h3826bc1_0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "9e56d20b324657c57ae04b1efd94681d", + "name": "llvm-tools", + "sha256": "36fbe839dfa45d0dc33ea2c46d98d8ee3fefb913fa902b72cf89351d839c443b", + "size": 12425615, + "subdir": "linux-64", + "timestamp": 1626721175665, + "version": "11.0.0" + }, + "llvm-tools-11.0.0-h3826bc1_1.conda": { + "build": "h3826bc1_1", + "build_number": 1, + "constrains": [ + "llvmdev 11.0.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 11.0.0 h3826bc1_1", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "ed8102047a940cf60091d0db99b5e19e", + "name": "llvm-tools", + "sha256": "b13e8abd7426a43d93dbab8cd47460671b1bedcb4164cb7f791812d8b87081d7", + "size": 12421282, + "subdir": "linux-64", + "timestamp": 1646054548533, + "version": "11.0.0" + }, + "llvm-tools-11.1.0-h3826bc1_0.conda": { + "build": "h3826bc1_0", + "build_number": 0, + "constrains": [ + "llvmdev 11.1.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 11.1.0 h3826bc1_0", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "382d78732474742950f07d1db00bcc40", + "name": "llvm-tools", + "sha256": "6fa2d79bd9f645dd49d5b561ab9d0c0f93a70d90451fe817dea70f6e03554567", + "size": 12431164, + "subdir": "linux-64", + "timestamp": 1624906919317, + "version": "11.1.0" + }, + "llvm-tools-11.1.0-h3826bc1_1.conda": { + "build": "h3826bc1_1", + "build_number": 1, + "constrains": [ + "llvmdev 11.1.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 11.1.0 h3826bc1_1", + "libstdcxx-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "2af82173eccb9aa95c45e0433b4b4b1a", + "name": "llvm-tools", + "sha256": "c88c197250298a30cb62b7dd27886d3f66ec9fdcce120a5ed18708b8e05aaa05", + "size": 12417424, + "subdir": "linux-64", + "timestamp": 1647523984573, + "version": "11.1.0" + }, + "llvm-tools-11.1.0-h9e868ea_5.conda": { + "build": "h9e868ea_5", + "build_number": 5, + "constrains": [ + "llvmdev 11.1.0" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm11 11.1.0 h9e868ea_5", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "a3c2e51c75a637b0309d43cc69b72f52", + "name": "llvm-tools", + "sha256": "5a0bdbd16fde26c8b5f084d2745cf63747adeb9299f61b51c1db0295230e0a12", + "size": 12689237, + "subdir": "linux-64", + "timestamp": 1662598155309, + "version": "11.1.0" + }, + "llvm-tools-11.1.0-h9e868ea_6.conda": { + "build": "h9e868ea_6", + "build_number": 6, + "constrains": [ + "llvmdev 11.1.0" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm11 11.1.0 h9e868ea_6", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "c392d0e45811082647b090a66addc6f6", + "name": "llvm-tools", + "sha256": "7550db529c9fdf223b2c66eec7019746a01055d35527feb806d6ae7918796edc", + "size": 12676685, + "subdir": "linux-64", + "timestamp": 1665079421330, + "version": "11.1.0" + }, + "llvm-tools-14.0.6-h9e868ea_0.conda": { + "build": "h9e868ea_0", + "build_number": 0, + "constrains": [ + "llvmdev 14.0.6" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 14.0.6 hef93074_0", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "7f47b57858ba811f305214f9bcbdbe26", + "name": "llvm-tools", + "sha256": "a9b1fb4995605bdef6b9ec7412d1346c300624c7d9802da4143f86dc88464f50", + "size": 14206238, + "subdir": "linux-64", + "timestamp": 1661449680796, + "version": "14.0.6" + }, + "llvm-tools-14.0.6-h9e868ea_1.conda": { + "build": "h9e868ea_1", + "build_number": 1, + "constrains": [ + "llvmdev 14.0.6" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 14.0.6 h9e868ea_1", + "libstdcxx-ng >=11.2.0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "8540fcca2d354e0ab62c202b30fba7c6", + "name": "llvm-tools", + "sha256": "0a21886be5c3ed0d1de8206a79c81dbfc1ab1dad3e8f3bca55c4b6d6ba308658", + "size": 15969180, + "subdir": "linux-64", + "timestamp": 1669293280981, + "version": "14.0.6" + }, + "llvm-tools-9.0.1-h4a3c616_0.conda": { + "build": "h4a3c616_0", + "build_number": 0, + "constrains": [ + "llvmdev 9.0.1" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9 9.0.1 h4a3c616_0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "c3b18ef1dcd6199eb8c36cfb19bb51c6", + "name": "llvm-tools", + "sha256": "0b4120f7cf5143910fda4d21afeb645c57ff4a03eb820fc42c8eeec34ab4f858", + "size": 4262482, + "subdir": "linux-64", + "timestamp": 1592929496217, + "version": "9.0.1" + }, + "llvm-tools-9.0.1-h4a3c616_1.conda": { + "build": "h4a3c616_1", + "build_number": 1, + "constrains": [ + "llvmdev 9.0.1" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9 9.0.1 h4a3c616_1", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "3dab4a8466a8d78b57ef00dd606040d6", + "name": "llvm-tools", + "sha256": "60df8e86871b89fe49368703cfb5417f6f1fff7f8a84583594df6358b557ecc5", + "size": 4263334, + "subdir": "linux-64", + "timestamp": 1594477744543, + "version": "9.0.1" + }, + "llvmdev-10.0.0-h4a3c616_1.conda": { + "build": "h4a3c616_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 10.0.0 h4a3c616_1", + "libstdcxx-ng >=7.3.0", + "llvm-tools 10.0.0 h4a3c616_1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "66e01c25b33b99828d1e46a7d73fb76a", + "name": "llvmdev", + "sha256": "6cbcfedb0d9e521026e304e3068f52b3d5c4a511733580a0ea576e0e5472f01d", + "size": 31186724, + "subdir": "linux-64", + "timestamp": 1594485860108, + "version": "10.0.0" + }, + "llvmdev-10.0.1-h4a3c616_5.conda": { + "build": "h4a3c616_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 10.0.1 hbcb73fb_5", + "libstdcxx-ng >=7.3.0", + "llvm-tools 10.0.1 h4a3c616_5" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "c71c723a11af78708e6f37a603e82e38", + "name": "llvmdev", + "sha256": "7af881d4045ca53b6a11760d47f3157eb7b1567f799b230304fd9c94de74e498", + "size": 31210684, + "subdir": "linux-64", + "timestamp": 1599257693375, + "version": "10.0.1" + }, + "llvmdev-11.0.0-hd09550d_0.conda": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 11.0.0 h3826bc1_0", + "libstdcxx-ng >=7.5.0", + "llvm-tools 11.0.0 h3826bc1_0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "8ccc7cf454dbb9bbd734b803c9c523a8", + "name": "llvmdev", + "sha256": "878e28ec6134f8b29e29d34e1cfd231ad163d25fc52f99a5cf2dee24a4ea2119", + "size": 33506357, + "subdir": "linux-64", + "timestamp": 1626721450232, + "version": "11.0.0" + }, + "llvmdev-11.0.0-hd09550d_1.conda": { + "build": "hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 11.0.0 h3826bc1_1", + "libstdcxx-ng >=7.5.0", + "llvm-tools 11.0.0 h3826bc1_1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "cf88c1e76b0f7163318ed3c60ab48ee7", + "name": "llvmdev", + "sha256": "17c9ff44249103a9bdc7467d4b272a1d76e88debfe930c2a35f3a569d55cd01f", + "size": 33494795, + "subdir": "linux-64", + "timestamp": 1646054818147, + "version": "11.0.0" + }, + "llvmdev-11.1.0-hd09550d_0.conda": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 11.1.0 h3826bc1_0", + "libstdcxx-ng >=7.5.0", + "llvm-tools 11.1.0 h3826bc1_0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "eda8d2e51d30f0e07d3a1ec1429eb9ca", + "name": "llvmdev", + "sha256": "d7fed18f8cafe5175c458aea724c92e76f6e789e7c7a73b9aa16b41ca45f1594", + "size": 33484452, + "subdir": "linux-64", + "timestamp": 1624906994003, + "version": "11.1.0" + }, + "llvmdev-11.1.0-hd09550d_1.conda": { + "build": "hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 11.1.0 h3826bc1_1", + "libstdcxx-ng >=7.5.0", + "llvm-tools 11.1.0 h3826bc1_1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "8266d428f08bd47c629148ed9322ca9c", + "name": "llvmdev", + "sha256": "2867da07f2168eabe177db4e1c27eaa6c4c8a1f46c2bb5acf98f6d952284f56a", + "size": 33484373, + "subdir": "linux-64", + "timestamp": 1647524046749, + "version": "11.1.0" + }, + "llvmdev-11.1.0-hdb19cb5_5.conda": { + "build": "hdb19cb5_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm11 11.1.0 h9e868ea_5", + "libstdcxx-ng >=11.2.0", + "llvm-tools 11.1.0 h9e868ea_5" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "6bbebc190b1ad25f67f98106271f6df0", + "name": "llvmdev", + "sha256": "96ab36fb4a1f9697d4113d22a7d86c4f81cd0bcd1e5930a496cb339819acf099", + "size": 33939937, + "subdir": "linux-64", + "timestamp": 1662598240724, + "version": "11.1.0" + }, + "llvmdev-11.1.0-hdb19cb5_6.conda": { + "build": "hdb19cb5_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm11 11.1.0 h9e868ea_6", + "libstdcxx-ng >=11.2.0", + "llvm-tools 11.1.0 h9e868ea_6" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "f77cd9c4c09b6316f06c176d29aba06a", + "name": "llvmdev", + "sha256": "c0696cbfcb4c5ac9bba7ce0c6ffea338ac2526927302947cef5866004f7e798e", + "size": 33909673, + "subdir": "linux-64", + "timestamp": 1665079495506, + "version": "11.1.0" + }, + "llvmdev-14.0.6-h9e868ea_0.conda": { + "build": "h9e868ea_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 14.0.6 hef93074_0", + "libstdcxx-ng >=11.2.0", + "llvm-tools 14.0.6 h9e868ea_0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "5706c63a9ae367e540fe5f27a528c0bc", + "name": "llvmdev", + "sha256": "9335f5f46c1d2c0ab3411e9e38256905f26e397e5db71e1764f43c1bd50208e7", + "size": 42567191, + "subdir": "linux-64", + "timestamp": 1661449705330, + "version": "14.0.6" + }, + "llvmdev-14.0.6-h9e868ea_1.conda": { + "build": "h9e868ea_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 14.0.6 h9e868ea_1", + "libstdcxx-ng >=11.2.0", + "llvm-tools 14.0.6 h9e868ea_1", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "06dc77fdbf99716c6fadb4f8e06199e3", + "name": "llvmdev", + "sha256": "416e5773807ba156306a9e1248e39033b30fa0e31dc09639b742910e625bba00", + "size": 53950230, + "subdir": "linux-64", + "timestamp": 1669293305625, + "version": "14.0.6" + }, + "llvmdev-6.0.0-h1a6f6a4_3.conda": { + "build": "h1a6f6a4_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "NCSA", + "md5": "e6323594a1ac8ff285086b80dc8d0ac2", + "name": "llvmdev", + "sha256": "3d446961b01631834a1a31c1f616e9d068644e06284b3248e4cb1e69bde75783", + "size": 70476883, + "subdir": "linux-64", + "timestamp": 1526580046000, + "version": "6.0.0" + }, + "llvmdev-6.0.0-h1a6f6a4_4.conda": { + "build": "h1a6f6a4_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "NCSA", + "md5": "7e9195af9242b2ef58c27feabe913872", + "name": "llvmdev", + "sha256": "a7270d761789efca0e33c2c5f2a1fb38238e46553208adedcd7b9bae36194ccb", + "size": 70624490, + "subdir": "linux-64", + "timestamp": 1531253789908, + "version": "6.0.0" + }, + "llvmdev-7.0.0-hc6ec683_1.conda": { + "build": "hc6ec683_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "NCSA", + "md5": "402412414fbf17c82a6f732d5139cb58", + "name": "llvmdev", + "sha256": "18128ec80c02f2bd0859b8ecbabc225c131510bc177386b57567ea808add6a10", + "size": 85492508, + "subdir": "linux-64", + "timestamp": 1546541412675, + "version": "7.0.0" + }, + "llvmdev-8.0.0-hc6ec683_0.conda": { + "build": "hc6ec683_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "NCSA", + "md5": "adf7c5361f2f824378dcbec0289175a7", + "name": "llvmdev", + "sha256": "859082fcaf2a5bdee4a7544ebbbb7dde89a043ea3f667e5e5ca52822dfcdf6fb", + "size": 108139956, + "subdir": "linux-64", + "timestamp": 1560808928476, + "version": "8.0.0" + }, + "llvmdev-9.0.1-h4a3c616_0.conda": { + "build": "h4a3c616_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9 9.0.1 h4a3c616_0", + "libstdcxx-ng >=7.3.0", + "llvm-tools 9.0.1 h4a3c616_0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "fcbcbb5aff2f32cc6ca3d6fd91746537", + "name": "llvmdev", + "sha256": "97bdf193ab2b34164b80c0aa761d8ebc6beb6bb5a0b2148937fca8f226cb5e8b", + "size": 29204920, + "subdir": "linux-64", + "timestamp": 1592929560509, + "version": "9.0.1" + }, + "llvmdev-9.0.1-h4a3c616_1.conda": { + "build": "h4a3c616_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9 9.0.1 h4a3c616_1", + "libstdcxx-ng >=7.3.0", + "llvm-tools 9.0.1 h4a3c616_1" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "d32aa5aa14f1d21cd4e6b7fd78479df8", + "name": "llvmdev", + "sha256": "c9f3b9cc9bf3b1d45d92cbe8f388b2bda6d22a65e8b5c80bcffd3497b98fd933", + "size": 29194377, + "subdir": "linux-64", + "timestamp": 1594477807275, + "version": "9.0.1" + }, + "llvmlite-0.20.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python 2.7*" + ], + "license": "New BSD License", + "md5": "7f0a2707b59cbf4393849513abb68379", + "name": "llvmlite", + "sha256": "760e41a584096512a782612dd8aab4ba0cb01cd94f6556e889849e35c737dcc7", + "size": 10165919, + "subdir": "linux-64", + "version": "0.20.0" + }, + "llvmlite-0.20.0-py34_0.conda": { + "build": "py34_0", + "build_number": 0, + "depends": [ + "python 3.4*" + ], + "license": "New BSD License", + "md5": "72b501a2ba5d383e362e51fb700eb8f1", + "name": "llvmlite", + "sha256": "99c6de8357b3370b97797702521b936a3e70ec9e30d41d51b4246a139dd783fb", + "size": 10167207, + "subdir": "linux-64", + "version": "0.20.0" + }, + "llvmlite-0.20.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python 3.5*" + ], + "license": "New BSD License", + "md5": "9c7c75448181e790c30b545424652aff", + "name": "llvmlite", + "sha256": "93b61cb64bd5823dae5be2e1cdd2248c1e34a8c56762d4b8d02281a9ce1739e3", + "size": 10169167, + "subdir": "linux-64", + "version": "0.20.0" + }, + "llvmlite-0.20.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python 3.6*" + ], + "license": "New BSD License", + "md5": "48dfeb816332789bc9be1ab4c8573fd4", + "name": "llvmlite", + "sha256": "be6a47478d1a63ebb0b1cdaa62e9d86662a71ae91ef19bd0585e515854d230fa", + "size": 10163783, + "subdir": "linux-64", + "version": "0.20.0" + }, + "llvmlite-0.21.0-py27h6dad3f9_0.conda": { + "build": "py27h6dad3f9_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "New BSD License", + "md5": "e6f3b808dd877b1d769310dd2598c15d", + "name": "llvmlite", + "sha256": "40ba8bfe72ffd02e3d0cac40483bfeb7496f3e27d39037795ee47e290fabfcb2", + "size": 12998678, + "subdir": "linux-64", + "timestamp": 1512594434391, + "version": "0.21.0" + }, + "llvmlite-0.21.0-py35hcfd7307_0.conda": { + "build": "py35hcfd7307_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "New BSD License", + "md5": "eea777b71ea7d8a6c70662e1c2d39b43", + "name": "llvmlite", + "sha256": "a420cdb0cb7d059485a809586262515f7b6d42a19f0ca3bbf6c2c2da0e23800d", + "size": 13026723, + "subdir": "linux-64", + "timestamp": 1512594320688, + "version": "0.21.0" + }, + "llvmlite-0.21.0-py36ha241eea_0.conda": { + "build": "py36ha241eea_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "New BSD License", + "md5": "8ac0753d7e650fcbab176e14fff52c4a", + "name": "llvmlite", + "sha256": "bc2ed52f3687adeccb2b1eb30b3d03b4599a723251d7f90d2ec824c09fca2803", + "size": 13020237, + "subdir": "linux-64", + "timestamp": 1512594213795, + "version": "0.21.0" + }, + "llvmlite-0.22.0-py27hdbca893_0.conda": { + "build": "py27hdbca893_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "New BSD License", + "md5": "1a1ccb45f6eedde03d588543275508a7", + "name": "llvmlite", + "sha256": "3399db7d4ea84569b231fff83476e001f7523029446ab27a87515e17f2c1d3a5", + "size": 13002832, + "subdir": "linux-64", + "timestamp": 1518736106894, + "version": "0.22.0" + }, + "llvmlite-0.22.0-py35h998887b_0.conda": { + "build": "py35h998887b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "New BSD License", + "md5": "f646dbb399ed8b8371058840ba8c5f5d", + "name": "llvmlite", + "sha256": "96f4b2b1719994dc271f56d6530369dc1182604f476cc55854bd4bf0fff73cd0", + "size": 13000445, + "subdir": "linux-64", + "timestamp": 1518736194471, + "version": "0.22.0" + }, + "llvmlite-0.22.0-py36ha27ea49_0.conda": { + "build": "py36ha27ea49_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "New BSD License", + "md5": "39763a7faf3edff84a8b4cb034921670", + "name": "llvmlite", + "sha256": "a967ce91af880b26ca48b9ba8b4cfe3436cf30f9b476f228d4cc5a65a667040b", + "size": 13011398, + "subdir": "linux-64", + "timestamp": 1518736018153, + "version": "0.22.0" + }, + "llvmlite-0.23.1-py27hdbcaa40_0.conda": { + "build": "py27hdbcaa40_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "40f61978bf02a496acee0d5d6e94221d", + "name": "llvmlite", + "sha256": "157a5897a5f548cd366c263f65af675866cb286566ee964fd2795f632f560dc9", + "size": 13468594, + "subdir": "linux-64", + "timestamp": 1526589142632, + "version": "0.23.1" + }, + "llvmlite-0.23.1-py35hdbcaa40_0.conda": { + "build": "py35hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "8344bcb25a2d176f13c71650376bc77f", + "name": "llvmlite", + "sha256": "b799f8ebde51c5d55032098e4203247ad2d3394e6b36de2b8b251f5f61296b2d", + "size": 13454797, + "subdir": "linux-64", + "timestamp": 1526588705392, + "version": "0.23.1" + }, + "llvmlite-0.23.1-py36hdbcaa40_0.conda": { + "build": "py36hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "ae1ea2f5de8056673869137339b466dc", + "name": "llvmlite", + "sha256": "e4c4ad89cf32d431570bb9040b06c2e842b77a4dee3f83b9ba882f5ab849fcdf", + "size": 13446115, + "subdir": "linux-64", + "timestamp": 1526589136294, + "version": "0.23.1" + }, + "llvmlite-0.23.2-py27hdbcaa40_0.conda": { + "build": "py27hdbcaa40_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "3ba9a8162059f0f2d2cef03ae6fddec6", + "name": "llvmlite", + "sha256": "f0bf0603aebe34caf3e0a70c4236734a9d925bab537219c114478c75a77143ea", + "size": 13467919, + "subdir": "linux-64", + "timestamp": 1529653658578, + "version": "0.23.2" + }, + "llvmlite-0.23.2-py35hdbcaa40_0.conda": { + "build": "py35hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "81970c92cb2d4b1d3ceff17911dd7a7b", + "name": "llvmlite", + "sha256": "0e2268d7a77b1dcb335bdcb3362e07b49873962da7a03f1fc85fcbbcb0a66333", + "size": 13457266, + "subdir": "linux-64", + "timestamp": 1529653683188, + "version": "0.23.2" + }, + "llvmlite-0.23.2-py36hdbcaa40_0.conda": { + "build": "py36hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "cefa6fdf2b8cb0a732cd9ab86e4dbcb8", + "name": "llvmlite", + "sha256": "2b2fdc6cebd48fcb8d4b670517d6c96706ae77a8a5a0a383dd44f394b7f594e7", + "size": 13447639, + "subdir": "linux-64", + "timestamp": 1529653636209, + "version": "0.23.2" + }, + "llvmlite-0.24.0-py27hdbcaa40_0.conda": { + "build": "py27hdbcaa40_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "cf9dfd0093580417414cc94dc927f1e6", + "name": "llvmlite", + "sha256": "fea8e79ac9c4b4ff08c8d2fafaa616838df94302e8eb2983550b46d0bd950775", + "size": 13458104, + "subdir": "linux-64", + "timestamp": 1531254529598, + "version": "0.24.0" + }, + "llvmlite-0.24.0-py35hdbcaa40_0.conda": { + "build": "py35hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "b228cbbb0a4a4962af977dba6c476000", + "name": "llvmlite", + "sha256": "d25c98d0bb5c8d5594ba0dcf0f037aacb52416c77168c2f6dc7cb93edf5e8d4e", + "size": 13470431, + "subdir": "linux-64", + "timestamp": 1534899269949, + "version": "0.24.0" + }, + "llvmlite-0.24.0-py36hdbcaa40_0.conda": { + "build": "py36hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "ad306b52546c4427c219e81082ba007b", + "name": "llvmlite", + "sha256": "5f699836de067b3bcf60d8afafd0d359f0128f26c6030456e7e8a1eefa3fa901", + "size": 13450827, + "subdir": "linux-64", + "timestamp": 1531254355022, + "version": "0.24.0" + }, + "llvmlite-0.24.0-py37hdbcaa40_0.conda": { + "build": "py37hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "e49b0aba22d1952c1408e46086a1a4ca", + "name": "llvmlite", + "sha256": "c66cb12de0cc526bf8ceb80dee2f3abe3bc98497fd074f44dfbb0295444332f0", + "size": 13446713, + "subdir": "linux-64", + "timestamp": 1531254181384, + "version": "0.24.0" + }, + "llvmlite-0.25.0-py27hd408876_0.conda": { + "build": "py27hd408876_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "daefd3fc788689fc78880b43fa85ff11", + "name": "llvmlite", + "sha256": "65240452e3a11a922054c35b94215a7d09f1f71af73f200b049ca76f2b5a2d0c", + "size": 13491735, + "subdir": "linux-64", + "timestamp": 1538584507200, + "version": "0.25.0" + }, + "llvmlite-0.25.0-py36hd408876_0.conda": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "16a2a6cf93436009b213388cd31c7195", + "name": "llvmlite", + "sha256": "0a2f90151612b3c6323cbd4f518ee9da667a0554f5d5b0f90af2fea5b3a52e80", + "size": 13495166, + "subdir": "linux-64", + "timestamp": 1538584526271, + "version": "0.25.0" + }, + "llvmlite-0.25.0-py37hd408876_0.conda": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "3948f3cf3474e29fcd89e0681751105c", + "name": "llvmlite", + "sha256": "f1d34605752389edbec9ae2649a917c51b96fdf81b5ff612b06d2f9a7426125e", + "size": 13492742, + "subdir": "linux-64", + "timestamp": 1538584499645, + "version": "0.25.0" + }, + "llvmlite-0.26.0-py27hd408876_0.conda": { + "build": "py27hd408876_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "64f196874c14e5c9447be88975c1f2ea", + "name": "llvmlite", + "sha256": "06078d17646caf3a7954a16db17179db0192e8fea7a7ec2c076bac32cb1ee89e", + "size": 13494932, + "subdir": "linux-64", + "timestamp": 1543472774125, + "version": "0.26.0" + }, + "llvmlite-0.26.0-py36hd408876_0.conda": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "eb6a043aaf8967d287dfd4728f8b0f72", + "name": "llvmlite", + "sha256": "18bcf4610d7840993afd1617bc071b03c9a38e5b5a42f67be6d0ebdcab9a7e6e", + "size": 13514493, + "subdir": "linux-64", + "timestamp": 1543472970536, + "version": "0.26.0" + }, + "llvmlite-0.26.0-py37hd408876_0.conda": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "9bb83ab03d8f2e69d75b08d06153ba28", + "name": "llvmlite", + "sha256": "3596433b7dac44e18679b94970612160a2ecd319cd61873db6d2527ac5a2b9d8", + "size": 13500596, + "subdir": "linux-64", + "timestamp": 1543472879621, + "version": "0.26.0" + }, + "llvmlite-0.27.0-py27hd408876_0.conda": { + "build": "py27hd408876_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "2b09b2e3be16b9b2ab42e59212ba4edb", + "name": "llvmlite", + "sha256": "97b4db791968c50ea43646e24cae1c19b6543f21ee0d376288426e1f7c7af44f", + "size": 14271951, + "subdir": "linux-64", + "timestamp": 1546578664408, + "version": "0.27.0" + }, + "llvmlite-0.27.0-py36hd408876_0.conda": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "45f1392e3a81cb4725b158fc77cc7afd", + "name": "llvmlite", + "sha256": "7c592ea661e4bb5b802a512dc71dedd6943dec60431e7cf4dadb15ddbf3cdba6", + "size": 14272377, + "subdir": "linux-64", + "timestamp": 1546578766824, + "version": "0.27.0" + }, + "llvmlite-0.27.0-py37hd408876_0.conda": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "57ddb3875d7d052d4b379f310c8486a6", + "name": "llvmlite", + "sha256": "41ae690c4842674b0d678e661c00b34d881f4b4b3bfaead2b54799330585c717", + "size": 14282822, + "subdir": "linux-64", + "timestamp": 1546578695513, + "version": "0.27.0" + }, + "llvmlite-0.28.0-py27hd408876_0.conda": { + "build": "py27hd408876_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "d7ec6c5c68aa94c6d4aba1c190274ea9", + "name": "llvmlite", + "sha256": "115fb9972c629f35275e889f09ac1bef163350bdf4d2d47a0692b740838f694e", + "size": 13146587, + "subdir": "linux-64", + "timestamp": 1552584680801, + "version": "0.28.0" + }, + "llvmlite-0.28.0-py36hd408876_0.conda": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "eace4962ae2d4931f9289ee0985940e9", + "name": "llvmlite", + "sha256": "01a58656bf59b375e2da80f9432fabc5b891cc5baf937b767a320bb1fc990593", + "size": 13139731, + "subdir": "linux-64", + "timestamp": 1552584740556, + "version": "0.28.0" + }, + "llvmlite-0.28.0-py37hd408876_0.conda": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "9dc41c122e5637d60643a02978aa7424", + "name": "llvmlite", + "sha256": "0267b8cc0e9e7c5f58bfa6b05e69f196187f4d206920eb63c42fe7a23b3233ff", + "size": 13141567, + "subdir": "linux-64", + "timestamp": 1552584717937, + "version": "0.28.0" + }, + "llvmlite-0.29.0-py27hd408876_0.conda": { + "build": "py27hd408876_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "80ac34d0eeb80883df6efe754db7a5da", + "name": "llvmlite", + "sha256": "ea012d8843866d118b8a90cd64ce7a11d5bf885b8a7677cb5ce8269087c3dbee", + "size": 15568774, + "subdir": "linux-64", + "timestamp": 1560810383844, + "version": "0.29.0" + }, + "llvmlite-0.29.0-py36hd408876_0.conda": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "7e0970bb084a630002bb1cb377ae5bfc", + "name": "llvmlite", + "sha256": "321e5f730a3171ff1d272c1d41fb45f2b8e9eff896ecc35f65eec04ceaf64049", + "size": 15573166, + "subdir": "linux-64", + "timestamp": 1560810177736, + "version": "0.29.0" + }, + "llvmlite-0.29.0-py37hd408876_0.conda": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "d609543cb58119db4dff8bcd0bc784d8", + "name": "llvmlite", + "sha256": "44127523da58a35a65ee27bc1996c6db2a191f13b5c64387c9a69310a7212060", + "size": 15573222, + "subdir": "linux-64", + "timestamp": 1560810370347, + "version": "0.29.0" + }, + "llvmlite-0.30.0-py27hd408876_0.conda": { + "build": "py27hd408876_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "1687118467a284e7952a0e97e2663a09", + "name": "llvmlite", + "sha256": "12cd17912037a9b46c26785a1845c6237c5c792f8d77b7759115460bc294abbf", + "size": 15559034, + "subdir": "linux-64", + "timestamp": 1572011372010, + "version": "0.30.0" + }, + "llvmlite-0.30.0-py36hd408876_0.conda": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "7a67c670094e5c900952cd970328bb4f", + "name": "llvmlite", + "sha256": "940e2718cab52dc4050acdea5cd9a2b89d02728763ce36bbdd22d24ad7bda75f", + "size": 15575898, + "subdir": "linux-64", + "timestamp": 1572011427938, + "version": "0.30.0" + }, + "llvmlite-0.30.0-py37hd408876_0.conda": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "1cd451314bba3b05e160a5888abe3d36", + "name": "llvmlite", + "sha256": "9ac4fa2fdb1929d300dffe1e8c684280288a40f8b73e353b20e38c88f274ff20", + "size": 15572404, + "subdir": "linux-64", + "timestamp": 1572011396710, + "version": "0.30.0" + }, + "llvmlite-0.30.0-py38hd408876_0.conda": { + "build": "py38hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "b2af0cf1d24a54bbfb32a478355b740e", + "name": "llvmlite", + "sha256": "eefaf8fdf582cad6c1b4d05e12d58cf6299daac1158b4fd6abd6061529343ba3", + "size": 15576279, + "subdir": "linux-64", + "timestamp": 1573638790354, + "version": "0.30.0" + }, + "llvmlite-0.31.0-py27hd408876_0.conda": { + "build": "py27hd408876_0", + "build_number": 0, + "depends": [ + "enum34", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "0e277398126ff96acff4285392b5e807", + "name": "llvmlite", + "sha256": "3d7cb648adfe6cc8ffb8aa5c1c2b4dc4bcdc606e75b1cfc19d96bcaffb9fd531", + "size": 15565909, + "subdir": "linux-64", + "timestamp": 1579016451759, + "version": "0.31.0" + }, + "llvmlite-0.31.0-py36hd408876_0.conda": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "0d6d4757d2707953fe2966cbdea9b8e3", + "name": "llvmlite", + "sha256": "e912ccb8818eca0f072a39ec61f996e68f35a300b316aaa5d9ad6f24412a0fa4", + "size": 15565216, + "subdir": "linux-64", + "timestamp": 1579016457991, + "version": "0.31.0" + }, + "llvmlite-0.31.0-py37hd408876_0.conda": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "86349cbeb1bcabd25fe8095c0e59d11b", + "name": "llvmlite", + "sha256": "16c14deacf0e1a93f0e2865bd0b1bd5e2cd1fae657e39330ae18425e5cfbcebc", + "size": 15561654, + "subdir": "linux-64", + "timestamp": 1579016355125, + "version": "0.31.0" + }, + "llvmlite-0.31.0-py38hd408876_0.conda": { + "build": "py38hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "483aacf3c7ec1a880ce66e64956ba12e", + "name": "llvmlite", + "sha256": "ea814a08d0adeeea0c7711521657d7ce797d3b4801d859053ed67b037d6b435c", + "size": 15566306, + "subdir": "linux-64", + "timestamp": 1579016442010, + "version": "0.31.0" + }, + "llvmlite-0.32.0-py36hd408876_0.conda": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "8948dd71fb4d65058e956b1ef8fd24b3", + "name": "llvmlite", + "sha256": "06ea655caf8c7d9cbfe5db07434505b2817979650f8b5dc3871f06e04e17a594", + "size": 15551658, + "subdir": "linux-64", + "timestamp": 1587142789645, + "version": "0.32.0" + }, + "llvmlite-0.32.0-py37hd408876_0.conda": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "0f59e809fa93d5d6a575b55fa22632d8", + "name": "llvmlite", + "sha256": "2a5ed90c3f8dd727e13e00b9e75911119bc4a92d31ac3e155a64c9415ef3e74a", + "size": 15554658, + "subdir": "linux-64", + "timestamp": 1587142756861, + "version": "0.32.0" + }, + "llvmlite-0.32.0-py38hd408876_0.conda": { + "build": "py38hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "15ec2a7294070e1c08ee3101305840fc", + "name": "llvmlite", + "sha256": "1e4c84e97f2a8fe21b9fa356f70fa8c9eef2a7f463c1cc9b9e285eec6194cf08", + "size": 15558292, + "subdir": "linux-64", + "timestamp": 1587142810611, + "version": "0.32.0" + }, + "llvmlite-0.32.1-py36hd408876_0.conda": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "40601ec7ea1ccc7a7e1be32439a30e83", + "name": "llvmlite", + "sha256": "367cf535b33bf1ef3d9f4d3ab86e9950064ab9792645968088c03c1500516a3e", + "size": 15551181, + "subdir": "linux-64", + "timestamp": 1589294284967, + "version": "0.32.1" + }, + "llvmlite-0.32.1-py37hd408876_0.conda": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "c675e904d7617814fb260ad4f083687d", + "name": "llvmlite", + "sha256": "3ad7b3074bbe8d2f9141593fec4a24cc02a63810f9c73216c4fc252b716c9589", + "size": 15545710, + "subdir": "linux-64", + "timestamp": 1589294221649, + "version": "0.32.1" + }, + "llvmlite-0.32.1-py38hd408876_0.conda": { + "build": "py38hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "be77c06fdc6407d1a079a81544b2d97e", + "name": "llvmlite", + "sha256": "7c207dee322bdd2722a982bacafceb6b2ad562aee7fabb8006a548fa2ea40186", + "size": 15548498, + "subdir": "linux-64", + "timestamp": 1589294233502, + "version": "0.32.1" + }, + "llvmlite-0.33.0-py36hc6ec683_1.conda": { + "build": "py36hc6ec683_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9 9.0.1 *_1", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "d8b4298b994531f3a921b96b12ff123f", + "name": "llvmlite", + "sha256": "200839fe42a0352b6e401f13d06665b9019d536207f2728fdfd3309fae3dae1e", + "size": 18166881, + "subdir": "linux-64", + "timestamp": 1594578335385, + "version": "0.33.0" + }, + "llvmlite-0.33.0-py36hd408876_0.conda": { + "build": "py36hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "590771a473f7722161d14f81ca3beb8d", + "name": "llvmlite", + "sha256": "14c960a937a40a3bdb8680f000646da35b2d10c86fc3062164133979d9fc0596", + "size": 18164582, + "subdir": "linux-64", + "timestamp": 1593094013350, + "version": "0.33.0" + }, + "llvmlite-0.33.0-py37hc6ec683_1.conda": { + "build": "py37hc6ec683_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9 9.0.1 *_1", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "115537d6638cb063b93846dcd6f95dea", + "name": "llvmlite", + "sha256": "1e2119ce2fd1462d8d8d760ffdb3f3ac548142c18d2f07d88a75d64a2db954d6", + "size": 18169647, + "subdir": "linux-64", + "timestamp": 1594577362497, + "version": "0.33.0" + }, + "llvmlite-0.33.0-py37hd408876_0.conda": { + "build": "py37hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "2f347f063384fbb97281038e0c812310", + "name": "llvmlite", + "sha256": "1fa37d289881fcbf70017265deab9f2bf35c345ab3018560a4d501d1d9476f68", + "size": 18177444, + "subdir": "linux-64", + "timestamp": 1593094037750, + "version": "0.33.0" + }, + "llvmlite-0.33.0-py38hc6ec683_1.conda": { + "build": "py38hc6ec683_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9 9.0.1 *_1", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "e5ec733ea1e7633feb21a0fb696f5af0", + "name": "llvmlite", + "sha256": "0f5c6eb9312f93d53162951310ccfe6fcf5ce5fbedc051d8978db1a9dae067fa", + "size": 18177339, + "subdir": "linux-64", + "timestamp": 1594578183183, + "version": "0.33.0" + }, + "llvmlite-0.33.0-py38hd408876_0.conda": { + "build": "py38hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm9", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "New BSD License", + "md5": "8ab9bc78216107b368b32d498dfd7517", + "name": "llvmlite", + "sha256": "d91a3137a913b042c1f21f6d8dcc7d69bd15fbe14a0386d45216a15fed1b6cd6", + "size": 18171387, + "subdir": "linux-64", + "timestamp": 1593094016966, + "version": "0.33.0" + }, + "llvmlite-0.34.0-py36h269e1b5_3.conda": { + "build": "py36h269e1b5_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "66470ec82f05af4356b0fb0d0460ef7b", + "name": "llvmlite", + "sha256": "4a92ad365abbc1ef951abc303044778797cea2e232ffd17611586acafecd3a3a", + "size": 304253, + "subdir": "linux-64", + "timestamp": 1599298452135, + "version": "0.34.0" + }, + "llvmlite-0.34.0-py36h269e1b5_4.conda": { + "build": "py36h269e1b5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "29471cdb7c53088256bd09c27d5463b0", + "name": "llvmlite", + "sha256": "6937550627a25fb360215cb320fc7f6c762ea4985310070cbeb6fb5167788f71", + "size": 300267, + "subdir": "linux-64", + "timestamp": 1599324295342, + "version": "0.34.0" + }, + "llvmlite-0.34.0-py37h269e1b5_3.conda": { + "build": "py37h269e1b5_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "65b65b92326c3ee0ba45bac1e8807c34", + "name": "llvmlite", + "sha256": "a25471ce6f7e5eb3fadbc3b227033240f7b654a26ef051aff0c3dbcd5d1c608b", + "size": 301974, + "subdir": "linux-64", + "timestamp": 1599298398991, + "version": "0.34.0" + }, + "llvmlite-0.34.0-py37h269e1b5_4.conda": { + "build": "py37h269e1b5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "cbac2f9385f35e1327005e70a072d9bf", + "name": "llvmlite", + "sha256": "9fbc1638eae0c0ae89c3c18c069406d9b8c6102f1f064a833069633decb262b5", + "size": 304221, + "subdir": "linux-64", + "timestamp": 1599324204238, + "version": "0.34.0" + }, + "llvmlite-0.34.0-py38h269e1b5_3.conda": { + "build": "py38h269e1b5_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "8a738717f0bd721a008cb3c9e9f8ed35", + "name": "llvmlite", + "sha256": "f73c7c3daf242987bd5ce002b2094906d253d71fa1a1241558f12ccb921ac5a9", + "size": 302895, + "subdir": "linux-64", + "timestamp": 1599298453264, + "version": "0.34.0" + }, + "llvmlite-0.34.0-py38h269e1b5_4.conda": { + "build": "py38h269e1b5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "1ddd92e30ea2adf7d359adb3b42767f7", + "name": "llvmlite", + "sha256": "172bf370b0201d5b0a33c95e0fcfca0c5ef2e71d9fe87f7023435826d648e410", + "size": 307020, + "subdir": "linux-64", + "timestamp": 1599324340952, + "version": "0.34.0" + }, + "llvmlite-0.35.0-py36h612dafd_4.conda": { + "build": "py36h612dafd_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "02410323a96394db3e2c786121c32eb3", + "name": "llvmlite", + "sha256": "69e7df45b2ccd76f8af88b9d283a1e8be36dba3fa2cb12eca531b718c0b28e5f", + "size": 397499, + "subdir": "linux-64", + "timestamp": 1606862159021, + "version": "0.35.0" + }, + "llvmlite-0.35.0-py37h612dafd_4.conda": { + "build": "py37h612dafd_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "395e671f94efece0104d1c5d8542b9f4", + "name": "llvmlite", + "sha256": "716e6a250cfe53e7adfeab81c7b64c9add6d3bad05f96fd88b5e7116ee28d84c", + "size": 396628, + "subdir": "linux-64", + "timestamp": 1606862185989, + "version": "0.35.0" + }, + "llvmlite-0.35.0-py38h612dafd_4.conda": { + "build": "py38h612dafd_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "bf26ed8562f94e80c672932d63870bc4", + "name": "llvmlite", + "sha256": "a97917a5bdd3a44f61b147a12437918a34e928ee99a65614612158aede9c94cd", + "size": 401894, + "subdir": "linux-64", + "timestamp": 1606862192126, + "version": "0.35.0" + }, + "llvmlite-0.35.0-py39h612dafd_4.conda": { + "build": "py39h612dafd_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "md5": "6c6048ca2237cb3c3b452a95fc71051b", + "name": "llvmlite", + "sha256": "b001541dabea6db7082410bdabde99a3bf3d93b82a584db654fc09a5dbc6bee7", + "size": 398827, + "subdir": "linux-64", + "timestamp": 1606862186085, + "version": "0.35.0" + }, + "llvmlite-0.36.0-py36h612dafd_4.conda": { + "build": "py36h612dafd_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "5fd1567d4154f8d23671fc3724dfa576", + "name": "llvmlite", + "sha256": "0bba071122ab3fb8f456791985ec8a1a97a5fde2d65184837c82e0aeffd4921d", + "size": 402623, + "subdir": "linux-64", + "timestamp": 1615662902850, + "version": "0.36.0" + }, + "llvmlite-0.36.0-py37h612dafd_4.conda": { + "build": "py37h612dafd_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "648d48e0a3ba2b4b63cd653f9f3234ed", + "name": "llvmlite", + "sha256": "87aeb3a8d1cd35d8d7853df9737e862f7b3f6e9943bd92ba09c8408d277ebd3d", + "size": 400752, + "subdir": "linux-64", + "timestamp": 1615662784289, + "version": "0.36.0" + }, + "llvmlite-0.36.0-py38h612dafd_4.conda": { + "build": "py38h612dafd_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "0272f086c1709b7b8be5accdc8c3c9e9", + "name": "llvmlite", + "sha256": "e90d13bbb2d72f079ad8b3d93b51206eb3a7c9d358f806f6582a50085b147e8c", + "size": 405004, + "subdir": "linux-64", + "timestamp": 1615662884426, + "version": "0.36.0" + }, + "llvmlite-0.36.0-py39h612dafd_4.conda": { + "build": "py39h612dafd_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "md5": "5d9c5631689d803709c9abb1f3f905ec", + "name": "llvmlite", + "sha256": "7658a7ebfd0ae9d4ffecfef8bea2d8a2261ea639407beb2dddbaafbd3f3da6a6", + "size": 402047, + "subdir": "linux-64", + "timestamp": 1615661177058, + "version": "0.36.0" + }, + "llvmlite-0.37.0-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "523a8fd94795ecca4ad6a833463ff85c", + "name": "llvmlite", + "sha256": "182aa4725b97e7d08e0f009d0553f2b144c2cf63e2b262c60b32b1a314a5e2ad", + "size": 439508, + "subdir": "linux-64", + "timestamp": 1630587796610, + "version": "0.37.0" + }, + "llvmlite-0.37.0-py37h295c915_1.conda": { + "build": "py37h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "74812dcbcf604970d732025f59748f85", + "name": "llvmlite", + "sha256": "935ee6ab66d76ad09833130a4be0e37a34dbce258cfa708eb94494fb28b843aa", + "size": 441649, + "subdir": "linux-64", + "timestamp": 1633428729925, + "version": "0.37.0" + }, + "llvmlite-0.37.0-py37h295c915_2.conda": { + "build": "py37h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.0.0,<11.1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "8889849fa382a96cf247e0326bb3b855", + "name": "llvmlite", + "sha256": "b3de8089b61ed69d2d9d3226cbee6f13e208d1f39131a07317866cb93792d266", + "size": 441278, + "subdir": "linux-64", + "timestamp": 1646168670904, + "version": "0.37.0" + }, + "llvmlite-0.37.0-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "9ee201930df54ddb3d873b854a112163", + "name": "llvmlite", + "sha256": "9fc9a2409b5c6f0c1f8962325024cdd0a7da8ef7e9b0bb8cb114d62609102c5f", + "size": 443195, + "subdir": "linux-64", + "timestamp": 1630597062867, + "version": "0.37.0" + }, + "llvmlite-0.37.0-py38h295c915_1.conda": { + "build": "py38h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "1de27a5a80fe3e5e2c882427c9c80a36", + "name": "llvmlite", + "sha256": "1a2fbe7eb2d277a61eca33a44439654b6f5eede5b98f92557bd58a74b4ebfa84", + "size": 441124, + "subdir": "linux-64", + "timestamp": 1633418036642, + "version": "0.37.0" + }, + "llvmlite-0.37.0-py38h295c915_2.conda": { + "build": "py38h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.0.0,<11.1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "md5": "1efaee84af29831a8069c86839a877f5", + "name": "llvmlite", + "sha256": "f8d87eaa95bc0bc2e23bdff832e142f2772ac2955bdb6d7fa6cf38df1db5d542", + "size": 441714, + "subdir": "linux-64", + "timestamp": 1646151524759, + "version": "0.37.0" + }, + "llvmlite-0.37.0-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "md5": "9a679ff035e1434543883d791cafce26", + "name": "llvmlite", + "sha256": "43765f58182adca9ee3bd43680df5cbf4e1583adf2a6c7edfff0e8d8286202f4", + "size": 443439, + "subdir": "linux-64", + "timestamp": 1630597067601, + "version": "0.37.0" + }, + "llvmlite-0.37.0-py39h295c915_1.conda": { + "build": "py39h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "md5": "b58082402668b2332f150223293b5e0b", + "name": "llvmlite", + "sha256": "c25a9132880eee54486847941c41015597c6a7cb5d1b925c8a7be15ff72b688c", + "size": 441155, + "subdir": "linux-64", + "timestamp": 1633428714988, + "version": "0.37.0" + }, + "llvmlite-0.37.0-py39h295c915_2.conda": { + "build": "py39h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.0.0,<11.1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "md5": "6768ac2d58725efeacb5ec0f314eb0ce", + "name": "llvmlite", + "sha256": "c978009518dfdfde413538c0c4c36f00b777f1210c747361b28d566c3629e6bd", + "size": 441106, + "subdir": "linux-64", + "timestamp": 1646150537930, + "version": "0.37.0" + }, + "llvmlite-0.38.0-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "md5": "f7a216a71b6943d005c57952a37111d2", + "name": "llvmlite", + "sha256": "7b15ba06d343ec7379cc595c11c7179858880c40423abe8c080dd8c2827d3003", + "size": 443193, + "subdir": "linux-64", + "timestamp": 1641837826880, + "version": "0.38.0" + }, + "llvmlite-0.38.0-py310h4ff587b_0.conda": { + "build": "py310h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "zlib" + ], + "license": "BSD-2-Clause", + "md5": "dcf55b5625e287667450877a51a586df", + "name": "llvmlite", + "sha256": "f5dbc459b10e4e6bdc049e686761595f40e2ab07a0174029d7250f42b8c57ef0", + "size": 2166493, + "subdir": "linux-64", + "timestamp": 1647870439669, + "version": "0.38.0" + }, + "llvmlite-0.38.0-py37h4ff587b_0.conda": { + "build": "py37h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "zlib" + ], + "license": "BSD-2-Clause", + "md5": "97d35f91d28832551b0850ec499635da", + "name": "llvmlite", + "sha256": "61c04ac2a37e243048c2970e687522d0f61ebd6e6de7cc291b6385c0375df999", + "size": 2161893, + "subdir": "linux-64", + "timestamp": 1647870360040, + "version": "0.38.0" + }, + "llvmlite-0.38.0-py38h4ff587b_0.conda": { + "build": "py38h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "zlib" + ], + "license": "BSD-2-Clause", + "md5": "2cb99f6d0a704913c2863f42b645c48b", + "name": "llvmlite", + "sha256": "09752ebc22a0f61f06663ceb942c6ea6ee7b392f58777030dbe349d2f3e53c17", + "size": 2163500, + "subdir": "linux-64", + "timestamp": 1647870575953, + "version": "0.38.0" + }, + "llvmlite-0.38.0-py39h4ff587b_0.conda": { + "build": "py39h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "zlib" + ], + "license": "BSD-2-Clause", + "md5": "00262a02af43a41bb53fe9d0f49a3cb8", + "name": "llvmlite", + "sha256": "59625f12231c5d56dc4ff7c4dbff5855f7f4179684a58e73e5a5a583840a461f", + "size": 2163520, + "subdir": "linux-64", + "timestamp": 1647870510956, + "version": "0.38.0" + }, + "llvmlite-0.39.1-py310he621ea3_0.conda": { + "build": "py310he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "zlib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "401b8fc1d354f6670e45aad3e320709b", + "name": "llvmlite", + "sha256": "d4a247f6858f11350c33402d09b6e9dbcea4f9fff7a126ab6c4f628733a353a9", + "size": 2082843, + "subdir": "linux-64", + "timestamp": 1665171795884, + "version": "0.39.1" + }, + "llvmlite-0.39.1-py37he621ea3_0.conda": { + "build": "py37he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "zlib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e304e7df05f2985dd2939e3ecbe43f1a", + "name": "llvmlite", + "sha256": "60719117b64a50f80cd6893029cabca4dc61763a64eeb7524f172190b50b5541", + "size": 2078220, + "subdir": "linux-64", + "timestamp": 1665171850030, + "version": "0.39.1" + }, + "llvmlite-0.39.1-py38he621ea3_0.conda": { + "build": "py38he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "zlib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "675cc5226f9d33b3ac2bcb3b7d8d7425", + "name": "llvmlite", + "sha256": "37ffbec2255d4590f29c6fc1c2f1db3eb2fd1d00e317c393025a1a4f2649e628", + "size": 2080018, + "subdir": "linux-64", + "timestamp": 1665171903628, + "version": "0.39.1" + }, + "llvmlite-0.39.1-py39he621ea3_0.conda": { + "build": "py39he621ea3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "zlib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "4497d75c4a7c85034744b372052de607", + "name": "llvmlite", + "sha256": "061067992114b2c7ce3623ed3e91c84477e27e4e6b53caf3415085cb34125866", + "size": 2079992, + "subdir": "linux-64", + "timestamp": 1665171728939, + "version": "0.39.1" + }, + "lmdb-0.9.21-hf484d3e_1.conda": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "OpenLDAP Public License and BSD 3-clause", + "license_family": "BSD", + "md5": "75fe68ef427b70e8f940b634b6cf7751", + "name": "lmdb", + "sha256": "4a366ec5f50111f5bec08da19bfa3befecab19a370d9c294f47b975f603e29e9", + "size": 443006, + "subdir": "linux-64", + "timestamp": 1512756896984, + "version": "0.9.21" + }, + "lmdb-0.9.22-hf484d3e_1.conda": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "OpenLDAP Public License and BSD 3-clause", + "license_family": "BSD", + "md5": "7a3ec303d1b719b6c650f0d7797d3f18", + "name": "lmdb", + "sha256": "be972a2e282d7b1155a5c3cbc1f9f25d05e3914f846f00fcc5d2df0c05fee5b9", + "size": 432163, + "subdir": "linux-64", + "timestamp": 1524181018724, + "version": "0.9.22" + }, + "lmdb-0.9.23-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "OpenLDAP Public License and BSD 3-clause", + "license_family": "BSD", + "md5": "0aa4144c662afc4374bc935c80832cec", + "name": "lmdb", + "sha256": "2958787a854acd0e8b07600d34659031cc148c8fcf30219bc54fdcba340bf58e", + "size": 428189, + "subdir": "linux-64", + "timestamp": 1547235506596, + "version": "0.9.23" + }, + "lmdb-0.9.24-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "OpenLDAP Public License and BSD 3-clause", + "license_family": "BSD", + "md5": "73880c454cb62c783b2a0d301da145fc", + "name": "lmdb", + "sha256": "384fcf957992f0dfa7698c52e46ab1a8f57db58106779b9d31829552c834b7a9", + "size": 428495, + "subdir": "linux-64", + "timestamp": 1600443503430, + "version": "0.9.24" + }, + "lmdb-0.9.28-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "OpenLDAP Public License and BSD 3-clause", + "license_family": "BSD", + "md5": "b21de656957854341a3956a1ef80059d", + "name": "lmdb", + "sha256": "364cb0ec9fb80e8e0aa60f623378c628d65875460e6429f8df870e94d6c76935", + "size": 439862, + "subdir": "linux-64", + "timestamp": 1613676227754, + "version": "0.9.28" + }, + "lmdb-0.9.29-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "OpenLDAP Public License and BSD 3-clause", + "license_family": "BSD", + "md5": "687cfd844457d9980b55f6d1abc712c2", + "name": "lmdb", + "sha256": "c4af46b6c1ba5d6c5f620fb306e5e696100f57acf559111ee2adc09d768bfc19", + "size": 434122, + "subdir": "linux-64", + "timestamp": 1620400717780, + "version": "0.9.29" + }, + "locket-0.2.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "315d9de3e6f81aff35ddcf9ff5d7ff51", + "name": "locket", + "sha256": "5a7ef0ffc2bf0ab988e7206eef50ced7ce0a63c2427de1ab3aafd34692874ecb", + "size": 8744, + "subdir": "linux-64", + "timestamp": 1530741752827, + "version": "0.2.0" + }, + "locket-0.2.0-py27h73929a2_1.conda": { + "build": "py27h73929a2_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "a6e540b2f5b2e3dc9d4802440feca484", + "name": "locket", + "sha256": "002fd71ea0d1b4a8870e51755faff22492cf3a2565bc949dd92db2b89a5bb9e8", + "size": 8491, + "subdir": "linux-64", + "timestamp": 1505732742217, + "version": "0.2.0" + }, + "locket-0.2.0-py35h170bc82_1.conda": { + "build": "py35h170bc82_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "e8fe27ce167968dfe468735b5d4d6834", + "name": "locket", + "sha256": "cc226952b140a461b6ca86e3a26ee09f22360f23b316975692417b4a34b32747", + "size": 8576, + "subdir": "linux-64", + "timestamp": 1505732753137, + "version": "0.2.0" + }, + "locket-0.2.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "99ed7786890366e237cf37c5c81ca02a", + "name": "locket", + "sha256": "b10bb74e79e251915de8b665818f87baf1330e0d0b14dbfe58e17fb0e8ec1dd2", + "size": 8760, + "subdir": "linux-64", + "timestamp": 1530741731902, + "version": "0.2.0" + }, + "locket-0.2.0-py36h787c0ad_1.conda": { + "build": "py36h787c0ad_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "6016a36bdb08744cbd00050cb65c22a2", + "name": "locket", + "sha256": "78594f34d1a2b37565e3d8b1f3200b06736b2ff414877adb8531159394b83f47", + "size": 8531, + "subdir": "linux-64", + "timestamp": 1505732764177, + "version": "0.2.0" + }, + "locket-0.2.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "f8bab10c5646b467c8cdc795fc132748", + "name": "locket", + "sha256": "50b0b79a30e3de6e39d2462c744c1ced498d5272bc8ba40c44aa8d5995bd3d3d", + "size": 8779, + "subdir": "linux-64", + "timestamp": 1530741774429, + "version": "0.2.0" + }, + "locket-0.2.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "md5": "deca2b57c7ea26889e5dab3fd9d8d26d", + "name": "locket", + "sha256": "0f25b34c37735389a2c6d0cd7b025a7e1121add50296d6e4677828b082e812bf", + "size": 9241, + "subdir": "linux-64", + "timestamp": 1573488766533, + "version": "0.2.0" + }, + "locket-0.2.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "md5": "9cf9907f366e10e71c8f2b69533c21ce", + "name": "locket", + "sha256": "d3b2b3b1fe0b7618322234cce6d74492dd68f6d00f3539fd9aeaece4b55e9666", + "size": 10247, + "subdir": "linux-64", + "timestamp": 1607570774449, + "version": "0.2.0" + }, + "locket-0.2.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 2-Clause", + "md5": "5fcb82a8727db922ce73e547b4aedfe7", + "name": "locket", + "sha256": "09fe9b8fcf49ffe4fadf85cc64254b93fc25edd4713690e93bbe510fc82809b2", + "size": 10002, + "subdir": "linux-64", + "timestamp": 1640791373772, + "version": "0.2.1" + }, + "locket-0.2.1-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c5f3558375724fe6a7136c3e215ac9d3", + "name": "locket", + "sha256": "ec2d1cd0327143803e8dfcfafc41231dd4e7295fdcba6bda4d7c5e0dd6ee8060", + "size": 11644, + "subdir": "linux-64", + "timestamp": 1646987929209, + "version": "0.2.1" + }, + "locket-0.2.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "a1bd632a051d1865f2e8c176eba3fe12", + "name": "locket", + "sha256": "7125e914207b8c31629f47b254e3f664bcac949091c911eb71413c8520249c7d", + "size": 10109, + "subdir": "linux-64", + "timestamp": 1611170835352, + "version": "0.2.1" + }, + "locket-0.2.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "cf72cb836da6f8da6a211b4d1515d615", + "name": "locket", + "sha256": "1d0298532e42bad938336148530684ad0993b06ae06ba731725e39983d7e9bd8", + "size": 10113, + "subdir": "linux-64", + "timestamp": 1611170851518, + "version": "0.2.1" + }, + "locket-0.2.1-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "17ca9215c4658a19779678afda35554b", + "name": "locket", + "sha256": "a2a6e1c9e822b315548bdf2bbb9c886030cba27b068324d2e8d50d1c9fe0b4d8", + "size": 11537, + "subdir": "linux-64", + "timestamp": 1646988470789, + "version": "0.2.1" + }, + "locket-0.2.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "md5": "8a9db0bd5e3c16c3a2287631da1fecd9", + "name": "locket", + "sha256": "98b37721112f84de7ddd0e54196f6f3a8338397ea48327ba34dd52768663d893", + "size": 10173, + "subdir": "linux-64", + "timestamp": 1611170807044, + "version": "0.2.1" + }, + "locket-0.2.1-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "6b3054dd89d675c810b986ae14f1e835", + "name": "locket", + "sha256": "f750bfd12efdd6d04e41b8adb4e8a5d124a9b401890b0d786809c3aa07041f79", + "size": 11564, + "subdir": "linux-64", + "timestamp": 1647006037112, + "version": "0.2.1" + }, + "locket-0.2.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "md5": "e6e3287cc8eb86c0cf5803c8b89d4ab6", + "name": "locket", + "sha256": "6f538cd8242d21b1d03d03fb42e47ee44a5563e443fceb3f48d3b18f36bb2c2a", + "size": 10180, + "subdir": "linux-64", + "timestamp": 1611170764206, + "version": "0.2.1" + }, + "locket-0.2.1-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ed3381e56e59f4b196f465a7da1265e3", + "name": "locket", + "sha256": "4d0df1552d999a2e92fdf8048e1b4035735a451dac9c302f620b61cc51c40a5a", + "size": 11545, + "subdir": "linux-64", + "timestamp": 1647006043407, + "version": "0.2.1" + }, + "locket-1.0.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "efa1eafd517606ce1384aede9c4eb1ad", + "name": "locket", + "sha256": "5c7877966aaa57d3e09fc188c907f236d143e5760d9f692210298a085e819a6d", + "size": 11310, + "subdir": "linux-64", + "timestamp": 1652903185157, + "version": "1.0.0" + }, + "locket-1.0.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "63a391d565a11ad6c76a197564450280", + "name": "locket", + "sha256": "08783fe1f650d967a09e2a581ae7c53c65deb4e54547070cc1f29883738c84c7", + "size": 13498, + "subdir": "linux-64", + "timestamp": 1676827287432, + "version": "1.0.0" + }, + "locket-1.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "6845fb13cb6db92a469dcf7d09881f97", + "name": "locket", + "sha256": "88764929e1c868ba1b2bbb2526894dc5980b731160b5c5b1fe1749f86ddf55a1", + "size": 11169, + "subdir": "linux-64", + "timestamp": 1652903235682, + "version": "1.0.0" + }, + "locket-1.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9075221bb581a3c2fc5a079efc183784", + "name": "locket", + "sha256": "28593c590ee13208124cbba08fe01c3d607a657b2e32881cb6df1575ecc7d138", + "size": 11203, + "subdir": "linux-64", + "timestamp": 1652903148662, + "version": "1.0.0" + }, + "locket-1.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "76f3059967599bd974ff21ecc376c7e0", + "name": "locket", + "sha256": "9ae502d6411317773514e53ce867431cf8aa5a76ceb3935a534a3e4f964e9b17", + "size": 11188, + "subdir": "linux-64", + "timestamp": 1652903210940, + "version": "1.0.0" + }, + "lockfile-0.12.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "11da0c03e89a233aae35b318040eebc7", + "name": "lockfile", + "sha256": "d946c075b6953ad287f960073f8dc459b09c12d110720e2b6de5aa65afbf9bd2", + "size": 19509, + "subdir": "linux-64", + "timestamp": 1530898511367, + "version": "0.12.2" + }, + "lockfile-0.12.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "6a022b3b03431a4a86ee02e89e724772", + "name": "lockfile", + "sha256": "c6ef61dc337b4ba7cf2de4b448ddb7565562c1b982993c8bfa5ef278da9350e9", + "size": 19768, + "subdir": "linux-64", + "timestamp": 1640791392442, + "version": "0.12.2" + }, + "lockfile-0.12.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "a14b1bb527c511679448113851309aae", + "name": "lockfile", + "sha256": "c49edeb21961db905eb1ae0e5c159b894ac6ace8558827348833385c6ac4ed11", + "size": 24652, + "subdir": "linux-64", + "timestamp": 1676903850269, + "version": "0.12.2" + }, + "lockfile-0.12.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "5e1bd5defd235f8bf723fdbca375fb8d", + "name": "lockfile", + "sha256": "f221fb6f1931f4695738c2d31491570b0eb3160d1069214a6eabc71f300a1435", + "size": 19829, + "subdir": "linux-64", + "timestamp": 1535480708241, + "version": "0.12.2" + }, + "lockfile-0.12.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ee91e772c2aadd874b83ed75658b8f96", + "name": "lockfile", + "sha256": "7c2dac350306407e692426a557eb14da7ae6fc9381c8e9bbcc59cd98e6ffbde9", + "size": 19456, + "subdir": "linux-64", + "timestamp": 1530898566621, + "version": "0.12.2" + }, + "lockfile-0.12.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b930522d28bc0873c311cea9601875ce", + "name": "lockfile", + "sha256": "548136e7d7ebcd33f6207acc87f179ba3cba7a7c8f43f2ffb2141d5cd9f52c41", + "size": 252138, + "subdir": "linux-64", + "timestamp": 1611760097634, + "version": "0.12.2" + }, + "lockfile-0.12.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d900df104040ee387d71d5efe23e9b9a", + "name": "lockfile", + "sha256": "2f787b48093b30b6121dcc9faebc3cbdceafc6768286e522dc7339b60ada5f43", + "size": 19499, + "subdir": "linux-64", + "timestamp": 1530898538255, + "version": "0.12.2" + }, + "lockfile-0.12.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "bdf101dd887b2035e40b6ab373cff387", + "name": "lockfile", + "sha256": "ade644aaa8bb73146cfc13d3c7d1681a47abade27151f89d58592ffe0ca5c1fa", + "size": 252316, + "subdir": "linux-64", + "timestamp": 1611760052878, + "version": "0.12.2" + }, + "lockfile-0.12.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "f38653e284829393a48378bc5c723812", + "name": "lockfile", + "sha256": "af6990c595ae7c9114dd3c0950b6b4cce690136b30e0cd5d03c385fa042245a2", + "size": 20107, + "subdir": "linux-64", + "timestamp": 1573488788663, + "version": "0.12.2" + }, + "lockfile-0.12.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "e4a1b96d1aa210cd63cb04ea5cf553d1", + "name": "lockfile", + "sha256": "d2a428f7cc88bea4a7b44c22f493abdc41744fc62effde8ef77fcb2192ff780f", + "size": 252077, + "subdir": "linux-64", + "timestamp": 1611760094940, + "version": "0.12.2" + }, + "logilab-common-1.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "cdf64425958256bcab001da1916727fc", + "name": "logilab-common", + "sha256": "821df7a6833c38278ebcd0c4ea34d1b70bf2107508f1e6c693c3e75cf4642c92", + "size": 203386, + "subdir": "linux-64", + "timestamp": 1519762037050, + "version": "1.4.1" + }, + "logilab-common-1.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "8b6e243c62f15f13b23740fe8c9222fb", + "name": "logilab-common", + "sha256": "6a7611b2b188b0d7cf50047a43efc4fc90b38b47fd7bc33c57712733251b81b6", + "size": 206734, + "subdir": "linux-64", + "timestamp": 1519762153368, + "version": "1.4.1" + }, + "logilab-common-1.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "0772011dcc478f95f6577038935928d0", + "name": "logilab-common", + "sha256": "afaf9e5cdb8960e7926bc08a0ffc6b84624b03de52aa8735e1534e8560d9e4a2", + "size": 204391, + "subdir": "linux-64", + "timestamp": 1519762183850, + "version": "1.4.1" + }, + "logilab-common-1.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "461647a93c74211849ae7d795a159751", + "name": "logilab-common", + "sha256": "b635cf4234230db415968d4e7fa43a7821190559857a4a76b4ca40222cc8ecce", + "size": 207379, + "subdir": "linux-64", + "timestamp": 1530898596605, + "version": "1.4.1" + }, + "logilab-common-1.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "97edd1c8c96fe30b4d584a91f685c96b", + "name": "logilab-common", + "sha256": "d890f958bc0f5929b8d03fd4a5dd562f6f89b0bedda47e123b1e3215bcc2bffe", + "size": 203559, + "subdir": "linux-64", + "timestamp": 1535509785325, + "version": "1.4.2" + }, + "logilab-common-1.4.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "1307faaace3de44a5fbe6c8548a39f97", + "name": "logilab-common", + "sha256": "758743a981df05046fed186d0f40df34eff1d8bc855bbd269595be4499142168", + "size": 210126, + "subdir": "linux-64", + "timestamp": 1535509828064, + "version": "1.4.2" + }, + "logilab-common-1.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "b89c41c318ecea0a7b9717876c187be5", + "name": "logilab-common", + "sha256": "3c67d176964b06eed7e8fc5e3cce0035872bcbee58e502f6f995b04480332c48", + "size": 207667, + "subdir": "linux-64", + "timestamp": 1535509773395, + "version": "1.4.2" + }, + "logilab-common-1.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "f8d77b9509958685dfe974f9ac258a28", + "name": "logilab-common", + "sha256": "c5a4015f62fde0934e52e571a736409b4a3ebf9edf0743e77130a7c970317825", + "size": 204392, + "subdir": "linux-64", + "timestamp": 1535509832665, + "version": "1.4.2" + }, + "logilab-common-1.4.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "4e7b43172b9c164d5f68e48080ec01be", + "name": "logilab-common", + "sha256": "eccaa95e91c173c5c8e0d39fa1a594d4f7786e75fcefb82d96e973c9c9fe16f3", + "size": 204396, + "subdir": "linux-64", + "timestamp": 1564686064945, + "version": "1.4.3" + }, + "logilab-common-1.4.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "2aa2f0b6db64a5d1a38b943e29fe0770", + "name": "logilab-common", + "sha256": "6a32eec66e734bd28b3cc2f359f7d37e2718ca2f9fcc21c4c5f8e881306e1a31", + "size": 208590, + "subdir": "linux-64", + "timestamp": 1564686035810, + "version": "1.4.3" + }, + "logilab-common-1.4.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "eac5b8c7b50dce9abd20663936efd28b", + "name": "logilab-common", + "sha256": "c8f3510f6eb3bf45676233eebf9e08abe02961bcc31d3b2d0f22706884797788", + "size": 208595, + "subdir": "linux-64", + "timestamp": 1564686073527, + "version": "1.4.3" + }, + "logilab-common-1.4.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "5b59c37e60975184bd5a7df47bf9e817", + "name": "logilab-common", + "sha256": "e087652b1e4af15bf0c625b56d62e829a6d2311f40348966ddfcb710e72a5d47", + "size": 207925, + "subdir": "linux-64", + "timestamp": 1574158060930, + "version": "1.4.3" + }, + "logilab-common-1.7.3-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "3974344cd6d8e237bb497f84c1e5b769", + "name": "logilab-common", + "sha256": "cb12e8575ff53f949c86df52fae7374174f438ec195f30bce52f3bf436e8b04c", + "size": 236144, + "subdir": "linux-64", + "timestamp": 1600443537600, + "version": "1.7.3" + }, + "logilab-common-1.7.3-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "6bc63f2b45241531638f28d6e0c4453d", + "name": "logilab-common", + "sha256": "e292b282a52e7193c685581df39b73c7a8c7fd7900895012afa1d8e0fffa8504", + "size": 236447, + "subdir": "linux-64", + "timestamp": 1600443537843, + "version": "1.7.3" + }, + "logilab-common-1.7.3-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "LGPL 2.1", + "md5": "3703805acaeffef5e2509b327727f049", + "name": "logilab-common", + "sha256": "50d7620f4c9f48af5b59e9d2e323f8897b5b8ac23f9b406318f4e6919c2028c4", + "size": 234530, + "subdir": "linux-64", + "timestamp": 1600443509380, + "version": "1.7.3" + }, + "logilab-common-1.8.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "f0b4288417f67c11e005f0130da00b65", + "name": "logilab-common", + "sha256": "5afc046781bd7f9259ecbbab226a307b9a2a3a50d6821f88f635c8c0abb05bb1", + "size": 239052, + "subdir": "linux-64", + "timestamp": 1640791410867, + "version": "1.8.0" + }, + "logilab-common-1.8.0-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "f28b1ac721a28dcf7c16ed4b3e1015c4", + "name": "logilab-common", + "sha256": "f91df128a21b54b052a8606b2b33f0c47a545d881ecbebcc28d5764a3fcd16ad", + "size": 321856, + "subdir": "linux-64", + "timestamp": 1676858523417, + "version": "1.8.0" + }, + "logilab-common-1.8.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "75fcaeea409295732b23421688dc044b", + "name": "logilab-common", + "sha256": "f7c415d7954a9f97ec79953eb482ac08bab520fd9678eac55e1fad1dca4faf2e", + "size": 236393, + "subdir": "linux-64", + "timestamp": 1603826705416, + "version": "1.8.0" + }, + "logilab-common-1.8.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "597438ecc6da5ba9aa55b7ea85fcc8fb", + "name": "logilab-common", + "sha256": "fe0bee71508e1ed8c66df2dabdd0e34e6b816d1b92915923f7664e39575ac391", + "size": 237039, + "subdir": "linux-64", + "timestamp": 1603826734709, + "version": "1.8.0" + }, + "logilab-common-1.8.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "7ca66e8a439a4cb46dfb1d7f7f2be8db", + "name": "logilab-common", + "sha256": "8dad0bbd7028dbd8bcf2c59e41aff63392f751cc7499a1d747f273d4cac536f1", + "size": 236893, + "subdir": "linux-64", + "timestamp": 1603826725424, + "version": "1.8.0" + }, + "logilab-common-1.8.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "6068888374bd6407a59057d7afb8e8fa", + "name": "logilab-common", + "sha256": "c5896e78140a063251772c3820a44e78c4a6f821fd3754fabaf6d195e354ef3d", + "size": 238819, + "subdir": "linux-64", + "timestamp": 1636035197928, + "version": "1.8.0" + }, + "logilab-common-1.8.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "9a811a3f8ee681b98596d3704358b34c", + "name": "logilab-common", + "sha256": "f1959f21574ab196782fe4bfdb0777f3a87951fca34da89b5e8cafce20776b79", + "size": 236861, + "subdir": "linux-64", + "timestamp": 1609872538743, + "version": "1.8.1" + }, + "logilab-common-1.8.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "a64a2d0cd6f647f9fe563e0c7da5eebb", + "name": "logilab-common", + "sha256": "e5ac56733045a71f490c4c4eb33c14bc35f0fae4f98fffff9779045341a21d8c", + "size": 235997, + "subdir": "linux-64", + "timestamp": 1609872551478, + "version": "1.8.1" + }, + "logilab-common-1.8.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "96d884c119548131e8c63edfb6aa0024", + "name": "logilab-common", + "sha256": "42f2eeb236424de24563d8f16cb59493b453ebb0085a515b4ddba67b12afec24", + "size": 237385, + "subdir": "linux-64", + "timestamp": 1609872380441, + "version": "1.8.1" + }, + "logilab-common-1.8.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.4.0", + "typing-extensions" + ], + "license": "LGPL 2.1", + "md5": "83e37eaf841f1dbcd34a403879da66bf", + "name": "logilab-common", + "sha256": "01be8a129bf2364a9e5c5009245c8f0644d819e869b58be95964ef7ec09c3a2a", + "size": 240510, + "subdir": "linux-64", + "timestamp": 1609872564264, + "version": "1.8.1" + }, + "loguru-0.5.3-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "debf40cd5f14ed0ff65c4bce7dbab858", + "name": "loguru", + "sha256": "824e7ed687165d7db4b27fa27eb7045c6d668b6207760c0d8ec02c0893b496c0", + "size": 87418, + "subdir": "linux-64", + "timestamp": 1641920760404, + "version": "0.5.3" + }, + "loguru-0.5.3-py310h06a4308_4.conda": { + "build": "py310h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f9eb60c2a9721b50b935dbe2fa834aa", + "name": "loguru", + "sha256": "1a9bba719af4c813fec06d9cd21ef4fa781cd9b7736c46185bb6b63d77d43e32", + "size": 93681, + "subdir": "linux-64", + "timestamp": 1675318562473, + "version": "0.5.3" + }, + "loguru-0.5.3-py311h06a4308_4.conda": { + "build": "py311h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8450c13051d2352002308faabb17daf", + "name": "loguru", + "sha256": "13e48585301ffcf5b94bc6f4d3153f5196928cec4d1243ef9986528eee1d0b5a", + "size": 113338, + "subdir": "linux-64", + "timestamp": 1676858538751, + "version": "0.5.3" + }, + "loguru-0.5.3-py37h06a4308_3.conda": { + "build": "py37h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c992d4ccffa8461fa3064525ebe9237e", + "name": "loguru", + "sha256": "e39cb5c6f85ed1c56cbc1c8f30b4e5d2d30b2284402ee5854618e66628fce3c6", + "size": 85470, + "subdir": "linux-64", + "timestamp": 1643635414519, + "version": "0.5.3" + }, + "loguru-0.5.3-py37h06a4308_4.conda": { + "build": "py37h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f26b33488a8728b6ef6588e5827e1971", + "name": "loguru", + "sha256": "93e958136ec9d25c2ad3590cfe6e5063d73d8f57cf63e64ce3700ad961778050", + "size": 92458, + "subdir": "linux-64", + "timestamp": 1675318589085, + "version": "0.5.3" + }, + "loguru-0.5.3-py38h06a4308_3.conda": { + "build": "py38h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "206efb4199b132b3c01002fd8cf8ad96", + "name": "loguru", + "sha256": "d544b2d24ef8e691e835e5c47a52e50b034f7b0fe22b6ac7d0d641d07b91f432", + "size": 85984, + "subdir": "linux-64", + "timestamp": 1643635364959, + "version": "0.5.3" + }, + "loguru-0.5.3-py38h06a4308_4.conda": { + "build": "py38h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0e4551e9da10ed2ec3a5f6015ceb6406", + "name": "loguru", + "sha256": "a82b8ed04bf650a58d54a82aeeb5baeef7aef1df38bef7633f42fa2c0096a147", + "size": 92330, + "subdir": "linux-64", + "timestamp": 1675318508999, + "version": "0.5.3" + }, + "loguru-0.5.3-py39h06a4308_3.conda": { + "build": "py39h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8b1d233aab179437050aad8f7882b2f", + "name": "loguru", + "sha256": "57865501a7079a8fe36210ab1458c610f11ac9c43a210fbad74732a1796b0f29", + "size": 85869, + "subdir": "linux-64", + "timestamp": 1643635392339, + "version": "0.5.3" + }, + "loguru-0.5.3-py39h06a4308_4.conda": { + "build": "py39h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d66447fe03e4a8c6cbced542fc54d60", + "name": "loguru", + "sha256": "777f1772fca00fd8e154e1a5a577af89b632f7177fab607252614e9a002350d5", + "size": 92792, + "subdir": "linux-64", + "timestamp": 1675318535694, + "version": "0.5.3" + }, + "ltrace_linux-64-0.7.3-h1234567_0.conda": { + "build": "h1234567_0", + "build_number": 0, + "depends": [], + "license": "GPL", + "md5": "d4fe60afd20e8bd80f3aeb5033b7005c", + "name": "ltrace_linux-64", + "sha256": "607dfc1463767fba725bbeb97bdc4c8747e516dec0015d292e0ddaa128206eea", + "size": 147683, + "subdir": "linux-64", + "timestamp": 1652859723868, + "version": "0.7.3" + }, + "ltrace_linux-64-0.7.3-h1234567_1.conda": { + "build": "h1234567_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "717181fb42686b8efe50170fd7bc2403", + "name": "ltrace_linux-64", + "sha256": "839486209b589dce21f0acea124522c15bc165754dae08841b6d586fb441acfc", + "size": 147266, + "subdir": "linux-64", + "timestamp": 1654090809095, + "version": "0.7.3" + }, + "lua-5.3.4-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "readline >=7.0,<8.0a0" + ], + "license": "MIT", + "md5": "8b4b93455af45bf295decd1bf0baf048", + "name": "lua", + "sha256": "116ccef74aa60080481539f8ad17c0472f3dd51cf96ac06bd680566be871537b", + "size": 197989, + "subdir": "linux-64", + "timestamp": 1545961178241, + "version": "5.3.4" + }, + "lua-resty-http-0.12.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "openresty" + ], + "license": "BSD", + "md5": "9812e1f81166c935ed621ed2a3ce553e", + "name": "lua-resty-http", + "sha256": "c360f02fbce3837314fc58817b82bf33869314d0c61bc8ef1e1e62233e20be90", + "size": 1332906, + "subdir": "linux-64", + "timestamp": 1545963405195, + "version": "0.12.0" + }, + "luajit-2.0.5-h7b6447c_1000.conda": { + "build": "h7b6447c_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d971d4936d31ecca3b61816de3b9ef2", + "name": "luajit", + "sha256": "9d7e455d81decab6c3aa8670eccf267370ed9e0b85409a0142c3c679682c171a", + "size": 381680, + "subdir": "linux-64", + "timestamp": 1545961180298, + "version": "2.0.5" + }, + "luarocks-3.0.0-lua53_0.conda": { + "build": "lua53_0", + "build_number": 0, + "depends": [ + "lua", + "unzip" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "97bab8b8531e67bf133c193b42f31b7f", + "name": "luarocks", + "sha256": "5d8dcfc684241453dd6e042073b47b8fbf99c53666c7d532530a91b7f618ac28", + "size": 132547, + "subdir": "linux-64", + "timestamp": 1545961186730, + "version": "3.0.0" + }, + "luarocks-3.3.1-lua53_0.conda": { + "build": "lua53_0", + "build_number": 0, + "depends": [ + "lua", + "unzip" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb48b1356ac6aafa937b896a88fdd467", + "name": "luarocks", + "sha256": "e99d1d79b0491b57ea2c2beef90de11eccbfc3f1cff123d4d542d9e41b869ca5", + "size": 150322, + "subdir": "linux-64", + "timestamp": 1599161265053, + "version": "3.3.1" + }, + "luarocks-3.4.0-lua53_0.conda": { + "build": "lua53_0", + "build_number": 0, + "depends": [ + "lua", + "unzip" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a99edbe7cba320d3f4cada628634b448", + "name": "luarocks", + "sha256": "1dcb947533a5e17c444649ff87cee2d7b246b6b5c7a53d60a01f396010e6ed2e", + "size": 150590, + "subdir": "linux-64", + "timestamp": 1601313366726, + "version": "3.4.0" + }, + "luarocks-3.5.0-lua53h06a4308_0.conda": { + "build": "lua53h06a4308_0", + "build_number": 0, + "depends": [ + "lua", + "unzip" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "38f29c70c3d6be715a777fb367e17c8c", + "name": "luarocks", + "sha256": "0611fbe0429c9439027615134cd2190afab28667a987d421c4f0c6476032f9dd", + "size": 151474, + "subdir": "linux-64", + "timestamp": 1607622605561, + "version": "3.5.0" + }, + "luarocks-3.6.0-lua53h06a4308_0.conda": { + "build": "lua53h06a4308_0", + "build_number": 0, + "depends": [ + "lua", + "unzip" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90c9b498f922a03a114b259ec5f120a4", + "name": "luarocks", + "sha256": "0710886b05c227567fd6b30f59dd5eec9edf8bad94676ca6d013f8f7021f8d97", + "size": 152370, + "subdir": "linux-64", + "timestamp": 1617378599650, + "version": "3.6.0" + }, + "luarocks-3.7.0-lua53h06a4308_0.conda": { + "build": "lua53h06a4308_0", + "build_number": 0, + "depends": [ + "lua", + "unzip" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6206ea07e5a10c7e4a65634005d2c54d", + "name": "luarocks", + "sha256": "750bcbfeb63991249898c2ce238b0aac9e119352b7c121be76b052eae37d209d", + "size": 152735, + "subdir": "linux-64", + "timestamp": 1618436602010, + "version": "3.7.0" + }, + "luigi-2.7.1-py27h6a3284f_0.conda": { + "build": "py27h6a3284f_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "512406b559967c8fae3d002a172c5aa4", + "name": "luigi", + "sha256": "d2dde0ad151a96e9a7007aeffc0c71339e16d230cdc16db4bde7af3a8b719558", + "size": 1069174, + "subdir": "linux-64", + "timestamp": 1507981695242, + "version": "2.7.1" + }, + "luigi-2.7.1-py35h7a986c5_0.conda": { + "build": "py35h7a986c5_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.5,<3.6.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "960c7971e9e84c47c6ac1a31a1c87630", + "name": "luigi", + "sha256": "9a1c9325cff002e9baece27d8c6aaf1e3b6c736be987d9b0873efcf94cb60bfc", + "size": 1069942, + "subdir": "linux-64", + "timestamp": 1507981737438, + "version": "2.7.1" + }, + "luigi-2.7.1-py36he7d448a_0.conda": { + "build": "py36he7d448a_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "212e03f249f2be447dbf2853b2542aa3", + "name": "luigi", + "sha256": "d52a16bc61f2fa0f63cb466f90d5b632812d437ce846312938547826d7f40a53", + "size": 1065953, + "subdir": "linux-64", + "timestamp": 1507981737704, + "version": "2.7.1" + }, + "luigi-2.7.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f9152942494478a474541bfaf4191a3b", + "name": "luigi", + "sha256": "a0ea743d2b49b4aff04144763d8d6b06adc4702fcadf903840f6913eb1c2d71c", + "size": 1064534, + "subdir": "linux-64", + "timestamp": 1520829210010, + "version": "2.7.2" + }, + "luigi-2.7.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.5,<3.6.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0f8bae4a4dfb128f588d6bb492d3fd17", + "name": "luigi", + "sha256": "029a94b8baf9d5d3a27423a95bd274c5abee71460c4e63075b80fe9c1504a90c", + "size": 1072867, + "subdir": "linux-64", + "timestamp": 1520829231051, + "version": "2.7.2" + }, + "luigi-2.7.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4a7532d83c411b801082dd8ec930d984", + "name": "luigi", + "sha256": "6a7daed27b7f531c5fb8c385dcf9f2fc580c4702b11dbef6a5b208560b88d8dc", + "size": 1070379, + "subdir": "linux-64", + "timestamp": 1520829202873, + "version": "2.7.2" + }, + "luigi-2.7.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7c393d1678fe788586ff65aa1a6e6231", + "name": "luigi", + "sha256": "3abe6b3abe91f981799b537d796698344072167e09eb6cc158ffaa09eeacfa89", + "size": 1072148, + "subdir": "linux-64", + "timestamp": 1522192028468, + "version": "2.7.3" + }, + "luigi-2.7.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.5,<3.6.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f0dd58486991e71f49630e4365a272ea", + "name": "luigi", + "sha256": "fd185bfbb6d74c1c3bd6690c700820989d9c1fdf55911d8aaf4a8b9f50f8c46d", + "size": 1081235, + "subdir": "linux-64", + "timestamp": 1522192124851, + "version": "2.7.3" + }, + "luigi-2.7.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b5ac1d097c9d09e2c47bbf6398ce38df", + "name": "luigi", + "sha256": "45cb748942141230db92d3707cfe6c86ed96be8551dfdd099836cb47a2947f04", + "size": 1076824, + "subdir": "linux-64", + "timestamp": 1522192095747, + "version": "2.7.3" + }, + "luigi-2.7.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2b4d68467f8c00c6a9cb929a624b712c", + "name": "luigi", + "sha256": "48dedc948444db833b4cb29c2ffed487e8d91982c0f906852b187d95c3358688", + "size": 1077462, + "subdir": "linux-64", + "timestamp": 1524002240780, + "version": "2.7.5" + }, + "luigi-2.7.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.5,<3.6.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3c7685c40fd1a97b97b4af77a69fdc66", + "name": "luigi", + "sha256": "f3995fe42953e1d49a62d8c307859c09f88da75b0937921e22c2767c10ae5c93", + "size": 1085073, + "subdir": "linux-64", + "timestamp": 1524002331352, + "version": "2.7.5" + }, + "luigi-2.7.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e44010c02f6de0a40680bfa6393e3a65", + "name": "luigi", + "sha256": "9aa3a282b54cc8cc3fd11069c4261c913cd8e03b2b12c9bb7ac71ef18bdc9faa", + "size": 1082933, + "subdir": "linux-64", + "timestamp": 1524002328897, + "version": "2.7.5" + }, + "luigi-2.7.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eb3a96661812cbbaa2b1a8f233722cea", + "name": "luigi", + "sha256": "aa83c1e2bc145703cff24a738179e5fbce1259b8b02ab714b50aa2b273b07244", + "size": 1089347, + "subdir": "linux-64", + "timestamp": 1530899067643, + "version": "2.7.5" + }, + "luigi-2.7.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5bd21946d10fc7bfff74893b801505e3", + "name": "luigi", + "sha256": "9ae0f970efcda57f6c012655bf24984a240acc0077a7b1715e1927c5ef522772", + "size": 1090106, + "subdir": "linux-64", + "timestamp": 1536104208659, + "version": "2.7.8" + }, + "luigi-2.7.8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7c2004a13503d3fc5a61d50af3b7d3c2", + "name": "luigi", + "sha256": "7185d29413a2200cca5a083e82b35a5c6580269bb3dc9001748914ddb8f8d036", + "size": 1095733, + "subdir": "linux-64", + "timestamp": 1536104226296, + "version": "2.7.8" + }, + "luigi-2.7.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f192b4c7688cade3210626cd9c38587b", + "name": "luigi", + "sha256": "be480ea3ebe8c0ad988806a3b377b66e7b8fe6d487344758b39823ccbd74c974", + "size": 1096527, + "subdir": "linux-64", + "timestamp": 1536104207811, + "version": "2.7.8" + }, + "luigi-2.7.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8e5347068449b3cc061da38f726ad558", + "name": "luigi", + "sha256": "9a05f3c6387fb979cd3eae691dbb0c3f5f55cf7c93e2b06a3534b19722727c5b", + "size": 1092045, + "subdir": "linux-64", + "timestamp": 1536104234500, + "version": "2.7.8" + }, + "luigi-2.7.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bacce3ede0a8e05d3e153185b472ec4d", + "name": "luigi", + "sha256": "51fa0ee34994b934962bf2fda2cd89e5c2cf7fae447c38e446d94f8951c89c86", + "size": 1091315, + "subdir": "linux-64", + "timestamp": 1538364465478, + "version": "2.7.9" + }, + "luigi-2.7.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9e751ac8d5f1680b05566571a5820d1d", + "name": "luigi", + "sha256": "a2b89dd63248ba4449bf8fd15493ffa20a0251c6939eb3bc002a88e5bcf79292", + "size": 1091927, + "subdir": "linux-64", + "timestamp": 1538364433683, + "version": "2.7.9" + }, + "luigi-2.7.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3d71dbb3c1677555c5732b760b16b9c1", + "name": "luigi", + "sha256": "fcb05ea7e661c9c3992f9e92c5dda4377633ccbcb6615909bb53834d1b60dabd", + "size": 1092385, + "subdir": "linux-64", + "timestamp": 1538364465927, + "version": "2.7.9" + }, + "luigi-2.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "191e3e6e2301aedf28066a14511dd704", + "name": "luigi", + "sha256": "1e0d0d57eed75f44a5281c6caa631b2b7d179a6f2f68bcb0a1f2cce4c9fda70b", + "size": 1091882, + "subdir": "linux-64", + "timestamp": 1541174693610, + "version": "2.8.0" + }, + "luigi-2.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4ae64621dbec5de629dee247878d42df", + "name": "luigi", + "sha256": "d5ec1b86164c49cb335c1182c938e570bb2beda1922b810f7ac70096c8dc5691", + "size": 1094426, + "subdir": "linux-64", + "timestamp": 1541174659338, + "version": "2.8.0" + }, + "luigi-2.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "401f37a04c5181191e99625be2201467", + "name": "luigi", + "sha256": "bfbd834007c3400e8fd7b3b7346059c8cad501f2de76b2e9be16474fd09b06bf", + "size": 1096127, + "subdir": "linux-64", + "timestamp": 1541174654975, + "version": "2.8.0" + }, + "luigi-2.8.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5efa9c95ecc1945a8eb86c5235b0141f", + "name": "luigi", + "sha256": "239d7548aeb2be245b829cf34140f421973dc2edbe338bd255555d071499e467", + "size": 1132096, + "subdir": "linux-64", + "timestamp": 1576540502718, + "version": "2.8.10" + }, + "luigi-2.8.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6e86b00cf476ba691b67da03fc65aa0f", + "name": "luigi", + "sha256": "b0d224aa96fcb9c45e108c123f6461d722502e155b972d9a895e5267262b854c", + "size": 1141565, + "subdir": "linux-64", + "timestamp": 1576540504169, + "version": "2.8.10" + }, + "luigi-2.8.10-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0bd970cd9b598dee555a4f614d392799", + "name": "luigi", + "sha256": "0387a3228ce9558866344e3c55493c33428f0126456a11cf4cc02ae67d714f6d", + "size": 1144500, + "subdir": "linux-64", + "timestamp": 1576540506074, + "version": "2.8.10" + }, + "luigi-2.8.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9ff51d39e02b192d4a688bac1724660a", + "name": "luigi", + "sha256": "3cedcd31805edf458251474c12a6cfc19bdc07ff21da09c7cf45c186d5fa8263", + "size": 1093858, + "subdir": "linux-64", + "timestamp": 1545108260738, + "version": "2.8.2" + }, + "luigi-2.8.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ff4b5ef4cbd1055963fa8dfdf533a583", + "name": "luigi", + "sha256": "8e77cc6fe1820edecf8ae6f5ce07c9eeaa8f9d596dc051d7cd81621b1ec196d3", + "size": 1098389, + "subdir": "linux-64", + "timestamp": 1545108290946, + "version": "2.8.2" + }, + "luigi-2.8.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "da82a519be50ad3a6612ac73f6466312", + "name": "luigi", + "sha256": "e1ae701484bde5d74d2ba0037fe4486d9dd5188a7091cb53fc2540ac220aef6c", + "size": 1094578, + "subdir": "linux-64", + "timestamp": 1545108293082, + "version": "2.8.2" + }, + "luigi-2.8.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ee1bad18961af92a238f96727d02b635", + "name": "luigi", + "sha256": "5d2a4ca99d9d54d880d853f797575001e0dc3610440164ba0fd73f0f2032b946", + "size": 1110780, + "subdir": "linux-64", + "timestamp": 1547791150256, + "version": "2.8.3" + }, + "luigi-2.8.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "92dd303cd69583aff1b26b2a8d6301d9", + "name": "luigi", + "sha256": "b3908de41bedfe43647b99320c98e4d8b5e3fdfaa83082a061eb77528f5c805b", + "size": 1109263, + "subdir": "linux-64", + "timestamp": 1547791199225, + "version": "2.8.3" + }, + "luigi-2.8.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "02635b8967d07e4fdf964fc64cb96395", + "name": "luigi", + "sha256": "fe93b5b4adaaab4c4d53a2c0770f9eee2d6987ca7a31a2f363d73009aabbe89c", + "size": 1110128, + "subdir": "linux-64", + "timestamp": 1547791196857, + "version": "2.8.3" + }, + "luigi-2.8.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e32f4866528f64110ebe37efd648533d", + "name": "luigi", + "sha256": "77876a7cd3bd971ed51f3911e571cb9ceee558b307cf5985840695bccfa5f747", + "size": 1134860, + "subdir": "linux-64", + "timestamp": 1559919737034, + "version": "2.8.6" + }, + "luigi-2.8.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c3f81e6c42e04a185c9c664cd581a62d", + "name": "luigi", + "sha256": "4c90a2552154ed6b48e48e86f80460596ca4b2c392bedf520dd6a88c14852d23", + "size": 1142844, + "subdir": "linux-64", + "timestamp": 1559919756461, + "version": "2.8.6" + }, + "luigi-2.8.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b044ae657122659c9d1caccae675bda5", + "name": "luigi", + "sha256": "a9d301ea1d52bbd9315c30b904f34d24ad34f25c3f309c0701821814e96b79a9", + "size": 1142715, + "subdir": "linux-64", + "timestamp": 1559919720650, + "version": "2.8.6" + }, + "luigi-2.8.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1039aedce7cd945090a86bbe185c6038", + "name": "luigi", + "sha256": "00a2da62965ce142beb6f4ed9fdf03c21c2a55f57875fec1dd5b99743459fa82", + "size": 1136370, + "subdir": "linux-64", + "timestamp": 1564686004974, + "version": "2.8.7" + }, + "luigi-2.8.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6b5285110ddf442e18c9b7027a6848f2", + "name": "luigi", + "sha256": "771ebdabf4148a60d2901f67c8556369fc04e0bd9f08c69740be48bc16ccecf0", + "size": 1142086, + "subdir": "linux-64", + "timestamp": 1564686007319, + "version": "2.8.7" + }, + "luigi-2.8.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ba60bbf85f08888fc4ba003c1e41bb18", + "name": "luigi", + "sha256": "f35be0b2790395ba74ae1aa4bb9ded23029ad6423ada80fb44c1bad19c8b1d6b", + "size": 1137025, + "subdir": "linux-64", + "timestamp": 1564685717196, + "version": "2.8.7" + }, + "luigi-2.8.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "enum34", + "python >=2.7,<2.8.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e2ebdebf33c64c31e6b6f9f90e9fd0f5", + "name": "luigi", + "sha256": "8a655137b5302ccc79acbd4c9f5de959d4428ebd570373d2a09048f885844542", + "size": 1138626, + "subdir": "linux-64", + "timestamp": 1569356334529, + "version": "2.8.9" + }, + "luigi-2.8.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4871a9f076a412fc9294b398cf50c6b9", + "name": "luigi", + "sha256": "3348ec1b95bee5b8ab20fad33eaa78d9f5044ce3c70ae2a0166214e7303f84d8", + "size": 1142178, + "subdir": "linux-64", + "timestamp": 1569356335793, + "version": "2.8.9" + }, + "luigi-2.8.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "55106a125184875981b80d017bf6b56f", + "name": "luigi", + "sha256": "9e041125edf466ff934cdbdedc18742d4f82854d87bc356576c0b167c351054e", + "size": 1143070, + "subdir": "linux-64", + "timestamp": 1569356330144, + "version": "2.8.9" + }, + "luigi-2.8.9-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.8,<3.9.0a0", + "python-daemon <3.0", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "03e5f6201a807afe07356661a2d411f2", + "name": "luigi", + "sha256": "59cf56c812da261eaf5441dcf5fe08e537e36640cba6277fd9bf0d90819fd265", + "size": 1138655, + "subdir": "linux-64", + "timestamp": 1574414024347, + "version": "2.8.9" + }, + "luigi-3.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "62bdd0609a01c822f90d148a0961943c", + "name": "luigi", + "sha256": "8c03013af33993965816ae9f21b8ad655edfabf8329dc047c083e31934e06846", + "size": 1129426, + "subdir": "linux-64", + "timestamp": 1595271767745, + "version": "3.0.0" + }, + "luigi-3.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1dabcb2d941aa1717262ccfe707fc97e", + "name": "luigi", + "sha256": "f55f99ac4fa206e958e9b60b6d9fe84f81d70271074405d22e96dce20839746c", + "size": 1125601, + "subdir": "linux-64", + "timestamp": 1595276645447, + "version": "3.0.0" + }, + "luigi-3.0.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "toml <2.0.0", + "prometheus_client ==0.5.0" + ], + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b9b0c3caefa8b4dff28cf139daf25339", + "name": "luigi", + "sha256": "a8fb823e17a09b0d5b52bc945926f58c5c79eed8b0a43c43d4f0ebc3f0bb7308", + "size": 1117677, + "subdir": "linux-64", + "timestamp": 1613676287421, + "version": "3.0.2" + }, + "luigi-3.0.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "toml <2.0.0", + "prometheus_client ==0.5.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f549a6a6dba8f87a20a850ad2b4290e0", + "name": "luigi", + "sha256": "675d34725abbef5adbb4536aba7c0b19e8a71f0aa75c58e41141506dbe28cd40", + "size": 1126311, + "subdir": "linux-64", + "timestamp": 1613676270974, + "version": "3.0.2" + }, + "luigi-3.0.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.8,<3.9.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cc72c4041e657ad40d6b83ddcdd82bed", + "name": "luigi", + "sha256": "29460cb7d81b2e2c2137707ac30ea3eff17cf2e9f5449431eb074f8a51f57789", + "size": 1123520, + "subdir": "linux-64", + "timestamp": 1613676162812, + "version": "3.0.2" + }, + "luigi-3.0.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.9,<3.10.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tornado >=4.0,<6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0e07fe169951636b91e611e0e79b1d97", + "name": "luigi", + "sha256": "20493e2beca982a83141efdfeeca2c810b3dc670548cd3edee521f8029129c84", + "size": 1122772, + "subdir": "linux-64", + "timestamp": 1613676287504, + "version": "3.0.2" + }, + "luigi-3.0.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "toml <2.0.0", + "prometheus_client ==0.5.0" + ], + "depends": [ + "python >=3.10,<3.11.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tenacity >=6.3.0,<7", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dd2c2843ebe9925bcfddf3285e168fa1", + "name": "luigi", + "sha256": "b07529e6ad28b8be63260d3b9a425c4c8a3ac8d0c0ae932a3b60b0473ec17a41", + "size": 1135198, + "subdir": "linux-64", + "timestamp": 1640812362734, + "version": "3.0.3" + }, + "luigi-3.0.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.6,<3.7.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tenacity >=6.3.0,<7", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4a037f66eca51a727dc468e8ed899671", + "name": "luigi", + "sha256": "920c41374db9021ff9ddbcddbe4744a5e761c357b00c1bdb97c2b4b0f258d1b8", + "size": 1126683, + "subdir": "linux-64", + "timestamp": 1618564379343, + "version": "3.0.3" + }, + "luigi-3.0.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "toml <2.0.0", + "prometheus_client ==0.5.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tenacity >=6.3.0,<7", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b8f1b63c80bb30cd9adab43f05787d98", + "name": "luigi", + "sha256": "e6ef18c1a4eb4200a15ac78cdb564734754f0d9e34a067cd9e265589af65ee32", + "size": 1119709, + "subdir": "linux-64", + "timestamp": 1618564378459, + "version": "3.0.3" + }, + "luigi-3.0.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.8,<3.9.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tenacity >=6.3.0,<7", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fd323e21bfd5a38b968a31bacf83ec3b", + "name": "luigi", + "sha256": "c773e668451ae7e727bf803913efa745e1f1a760ea3662164ff60f8958bbe25c", + "size": 1126851, + "subdir": "linux-64", + "timestamp": 1618564380541, + "version": "3.0.3" + }, + "luigi-3.0.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "prometheus_client ==0.5.0", + "toml <2.0.0" + ], + "depends": [ + "python >=3.9,<3.10.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "setuptools", + "tenacity >=6.3.0,<7", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cfaa5996fc438ee3e67f84ccc23f5c29", + "name": "luigi", + "sha256": "b54c1605c8e50eb216fe4398d439bd04f33dfb909f4a89865c37f843fb547bb5", + "size": 1124063, + "subdir": "linux-64", + "timestamp": 1618564378157, + "version": "3.0.3" + }, + "luigi-3.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "prometheus_client >=0.5,<0.15", + "toml <2.0.0" + ], + "depends": [ + "python >=3.10,<3.11.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "tenacity >=8,<9", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8cd75337096f26f586a6b513f1877cf8", + "name": "luigi", + "sha256": "f3a1e5a0aa0bd68b819fc13e66b59cf24152351f084f75025fda028c913c0d4a", + "size": 1191646, + "subdir": "linux-64", + "timestamp": 1677013127919, + "version": "3.2.0" + }, + "luigi-3.2.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "toml <2.0.0", + "prometheus_client >=0.5,<0.15" + ], + "depends": [ + "python >=3.11,<3.12.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "tenacity >=8,<9", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c6e39ba6d71893d40af0668d89497371", + "name": "luigi", + "sha256": "d06edec895109c25724fc5b1c9d27907eeb382352e3fe88c1358311c6f103185", + "size": 1297833, + "subdir": "linux-64", + "timestamp": 1677014417917, + "version": "3.2.0" + }, + "luigi-3.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "prometheus_client >=0.5,<0.15", + "toml <2.0.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "tenacity >=8,<9", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9b73b7073cb93d5dae9bcbc080df4e6d", + "name": "luigi", + "sha256": "36c619ef2fa563d54bba14b7f321ee18a1d7ec48d6d9cbbdf6eeb50566afcb1f", + "size": 1181395, + "subdir": "linux-64", + "timestamp": 1677013066910, + "version": "3.2.0" + }, + "luigi-3.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "prometheus_client >=0.5,<0.15", + "toml <2.0.0" + ], + "depends": [ + "python >=3.8,<3.9.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "tenacity >=8,<9", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "690d37da9bb0ce963b300b1099aa8732", + "name": "luigi", + "sha256": "dfd990a3be14aa7924497e6bb45e1df2b95d86021801993860ca6eff85acfe81", + "size": 1185630, + "subdir": "linux-64", + "timestamp": 1677013034332, + "version": "3.2.0" + }, + "luigi-3.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "prometheus_client >=0.5,<0.15", + "toml <2.0.0" + ], + "depends": [ + "python >=3.9,<3.10.0a0", + "python-daemon", + "python-dateutil >=2.7.5,<3", + "tenacity >=8,<9", + "tornado >=5.0,<7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8540fc6368e57732648d88961a9bdd59", + "name": "luigi", + "sha256": "2a3fb804c9ec4aace5d958bc362438061e33e607c50406cbdc1a02a62c7131c7", + "size": 1186693, + "subdir": "linux-64", + "timestamp": 1677013098036, + "version": "3.2.0" + }, + "lxml-3.8.0-py27hb3ac1f5_0.conda": { + "build": "py27hb3ac1f5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "libxslt", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "e1cc91446a5894552b490bf7c5715c16", + "name": "lxml", + "sha256": "47c924aaa464d2ebdaf9b2e45f7a413cd036870329dcb2e701a448d37300321b", + "size": 1050789, + "subdir": "linux-64", + "timestamp": 1505745345946, + "version": "3.8.0" + }, + "lxml-3.8.0-py35h4935ab9_0.conda": { + "build": "py35h4935ab9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "libxslt", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "b99bf1a345c4d72ddc5775ebb2a8ae3e", + "name": "lxml", + "sha256": "7d61fad147396be4c00434da6f4ad837fb1e63427824dbeb2081166d5c5990b0", + "size": 1048256, + "subdir": "linux-64", + "timestamp": 1505745447727, + "version": "3.8.0" + }, + "lxml-3.8.0-py36h6c6e760_0.conda": { + "build": "py36h6c6e760_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "libxslt", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "9572244d954d527240638cb4408a441e", + "name": "lxml", + "sha256": "273e0d39bdd409b9dac07ccdce66f68fef26d1deaf68d7ec9d720d56b4838b2d", + "size": 1062786, + "subdir": "linux-64", + "timestamp": 1505745549332, + "version": "3.8.0" + }, + "lxml-4.1.0-py27hb025457_0.conda": { + "build": "py27hb025457_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "libxslt", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "3a3516ad20408ee38750f41cfdd4f23b", + "name": "lxml", + "sha256": "829ddde4bdeeefe261be887c58897277ac67cc6d784fbf19cdbb2468fd32ad44", + "size": 1356667, + "subdir": "linux-64", + "timestamp": 1508599348346, + "version": "4.1.0" + }, + "lxml-4.1.0-py35ha401a81_0.conda": { + "build": "py35ha401a81_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "libxslt", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "1f7bd1f31d8cb9c18d0ec90f8d5713db", + "name": "lxml", + "sha256": "d8f46da02ce5fcb89f040a53fe59845f5dadfd48ed3b998c3a4f5615805603a1", + "size": 1380652, + "subdir": "linux-64", + "timestamp": 1508599360221, + "version": "4.1.0" + }, + "lxml-4.1.0-py36h5b66e50_0.conda": { + "build": "py36h5b66e50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "libxslt", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "d7da9d4edd838c630029ded78e42adb0", + "name": "lxml", + "sha256": "fd03ea716051db6f6c5791dafbff30655bd69025aee314ac29ada1bd2fac2112", + "size": 1404056, + "subdir": "linux-64", + "timestamp": 1508599391098, + "version": "4.1.0" + }, + "lxml-4.1.1-py27hdd00cef_0.conda": { + "build": "py27hdd00cef_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "libxslt", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "de17f8ac909d146cd926cd92658311a5", + "name": "lxml", + "sha256": "b7a1220c39a394dc00b076304d2ca50835928ca7891b50b3aefb6c700676d1d1", + "size": 1351407, + "subdir": "linux-64", + "timestamp": 1511809610344, + "version": "4.1.1" + }, + "lxml-4.1.1-py27hf71bdeb_1.conda": { + "build": "py27hf71bdeb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "67a84fb9c6874203bcc3c671f0f6de36", + "name": "lxml", + "sha256": "167426526da3f6d5b79e985bf5abeafe6089c4a635237600954bd7e729ceb40a", + "size": 1353831, + "subdir": "linux-64", + "timestamp": 1516987084941, + "version": "4.1.1" + }, + "lxml-4.1.1-py35ha19ceee_0.conda": { + "build": "py35ha19ceee_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "libxslt", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "cbec6e59565bf6579f239548c56d43fc", + "name": "lxml", + "sha256": "cc9ae29a95180ab613a7de0773bdfb3ac5d09b6f7b1cdb0738245ab1fa76c14a", + "size": 1379761, + "subdir": "linux-64", + "timestamp": 1511809618977, + "version": "4.1.1" + }, + "lxml-4.1.1-py35hf71bdeb_1.conda": { + "build": "py35hf71bdeb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "a60d2014c4bdc9a187c862e194fca215", + "name": "lxml", + "sha256": "89ffc985faaa9d5e7c7511510017823717f66f56fe57784ad0f50dccdcc80e4a", + "size": 1380015, + "subdir": "linux-64", + "timestamp": 1516987092136, + "version": "4.1.1" + }, + "lxml-4.1.1-py36h4d89739_0.conda": { + "build": "py36h4d89739_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "libxslt", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "c407f1f90e8c7a437aeb198a7c3a2b8b", + "name": "lxml", + "sha256": "cee6558ac09783f0f4a268292aea76836a000578a8645701af85a458ab2f61a1", + "size": 1400076, + "subdir": "linux-64", + "timestamp": 1511809548186, + "version": "4.1.1" + }, + "lxml-4.1.1-py36hf71bdeb_1.conda": { + "build": "py36hf71bdeb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "0c18f524cc0ac333b7533bbc5b8eadca", + "name": "lxml", + "sha256": "f0d27c4b416148edfd87b823fc33ec1782e30ff6e6b72839a67084b20cd6436c", + "size": 1400721, + "subdir": "linux-64", + "timestamp": 1516987106864, + "version": "4.1.1" + }, + "lxml-4.2.0-py27h23eabaa_0.conda": { + "build": "py27h23eabaa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "6362aa9cb5e5d360490bfeba79a386bc", + "name": "lxml", + "sha256": "7d1598c2def72c81d5146e9c824c317111f6baab6f7de9d6cb885b2e77cb2342", + "size": 1325649, + "subdir": "linux-64", + "timestamp": 1521491331517, + "version": "4.2.0" + }, + "lxml-4.2.0-py35h23eabaa_0.conda": { + "build": "py35h23eabaa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "cce6976e6ee3a82e0d3f2c3034f5ceff", + "name": "lxml", + "sha256": "3251a903bb6d81c1aba33612d3b9236148118e2c76d0bc8d4c52013fba8ed4da", + "size": 1331146, + "subdir": "linux-64", + "timestamp": 1521491358013, + "version": "4.2.0" + }, + "lxml-4.2.0-py36h23eabaa_0.conda": { + "build": "py36h23eabaa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "eb97369c7d30276a91d3f32f0bf4b445", + "name": "lxml", + "sha256": "01700a81c4692ee2d208148ec4e4db4e2180d5d06052789dc5749105dd659cc0", + "size": 1345116, + "subdir": "linux-64", + "timestamp": 1521491358304, + "version": "4.2.0" + }, + "lxml-4.2.1-py27h23eabaa_0.conda": { + "build": "py27h23eabaa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "d1e793cd30a92b630c37843c2095692b", + "name": "lxml", + "sha256": "6cf62762b625ca448a8cc557c57bd03db8dcb14630760d500c74250c86d0a19b", + "size": 1329355, + "subdir": "linux-64", + "timestamp": 1522178755394, + "version": "4.2.1" + }, + "lxml-4.2.1-py35h23eabaa_0.conda": { + "build": "py35h23eabaa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "b14e8277274dabba6b83caba25717561", + "name": "lxml", + "sha256": "26590699e62922ddb0815e4a940491208cd650b738be1647c5d28888d8bc7b55", + "size": 1328608, + "subdir": "linux-64", + "timestamp": 1522178755201, + "version": "4.2.1" + }, + "lxml-4.2.1-py36h23eabaa_0.conda": { + "build": "py36h23eabaa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "cf8b69c6f1d18499bf634739e73c4cf4", + "name": "lxml", + "sha256": "a7041a1aa82e5291a2997906b3016bc08e5201883da22ed8de92a3a6042b79ba", + "size": 1345636, + "subdir": "linux-64", + "timestamp": 1522178072276, + "version": "4.2.1" + }, + "lxml-4.2.2-py27hf71bdeb_0.conda": { + "build": "py27hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "d293e9bdfdd87a539065bd3a6ab60fe1", + "name": "lxml", + "sha256": "a0bf5447295d2f297a81d8a988fd9600668418aa7251e87847162ba32fe07a6f", + "size": 1506866, + "subdir": "linux-64", + "timestamp": 1529940312365, + "version": "4.2.2" + }, + "lxml-4.2.2-py35hf71bdeb_0.conda": { + "build": "py35hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "e511a433004fb1597c1a0addf495dfa6", + "name": "lxml", + "sha256": "ca9623ef6bb1931f91b22831fb711962e593f355ac947d47256bd616bd0eaf00", + "size": 1503242, + "subdir": "linux-64", + "timestamp": 1529940334681, + "version": "4.2.2" + }, + "lxml-4.2.2-py36hf71bdeb_0.conda": { + "build": "py36hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "8329c9303a7811576dde59231aa2ac4a", + "name": "lxml", + "sha256": "e428dedc87b15f29054db500dbe19bb637a2339f8240b70015a6ba37518e4a52", + "size": 1518249, + "subdir": "linux-64", + "timestamp": 1529940316846, + "version": "4.2.2" + }, + "lxml-4.2.2-py37hf71bdeb_0.conda": { + "build": "py37hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "9416613c0e35849012483ba03bc929ff", + "name": "lxml", + "sha256": "f848a44b958f3a17e7d8dd4dfba92a6b12007095a6133864f7e1d878e9f1be59", + "size": 1509870, + "subdir": "linux-64", + "timestamp": 1530811233033, + "version": "4.2.2" + }, + "lxml-4.2.3-py27hf71bdeb_0.conda": { + "build": "py27hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "061b6ea31a9bee69c33cb37ec0cb1092", + "name": "lxml", + "sha256": "28d58bfd1ced3ca88c67f73609eba3f34daf206cf9508902cfcae2c2f1cb11cb", + "size": 1507006, + "subdir": "linux-64", + "timestamp": 1532461514268, + "version": "4.2.3" + }, + "lxml-4.2.3-py35hf71bdeb_0.conda": { + "build": "py35hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "e4f715f9a5c9d9250ad77d8e00f76bcc", + "name": "lxml", + "sha256": "9024e5a9842835eb26ae560bc42d81682cf583a9a4bc23b20fbb62cee9926063", + "size": 1502988, + "subdir": "linux-64", + "timestamp": 1532461588343, + "version": "4.2.3" + }, + "lxml-4.2.3-py36hf71bdeb_0.conda": { + "build": "py36hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "c87de45dcc67c00fd9de086b9f2f1b6b", + "name": "lxml", + "sha256": "6afd1022c161d14e1ab27081dab4b4987f7fec95310696f4384ad0eb7098f1cb", + "size": 1518851, + "subdir": "linux-64", + "timestamp": 1532461521509, + "version": "4.2.3" + }, + "lxml-4.2.3-py37hf71bdeb_0.conda": { + "build": "py37hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "2c846dd0a649c1118b051250fbf6eafe", + "name": "lxml", + "sha256": "12bbc0b56124f9f858e89d30a67d97d2fac69684f2648758025a343a682d1701", + "size": 1509365, + "subdir": "linux-64", + "timestamp": 1532461532778, + "version": "4.2.3" + }, + "lxml-4.2.4-py27hf71bdeb_0.conda": { + "build": "py27hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "16852a24b0f946b0ad271427e48f47a5", + "name": "lxml", + "sha256": "27deb2fa253927679ea9119caaf2281b5ee82e791ca0b28ec1dfc6f7bc153f8f", + "size": 1501954, + "subdir": "linux-64", + "timestamp": 1533744682774, + "version": "4.2.4" + }, + "lxml-4.2.4-py35hf71bdeb_0.conda": { + "build": "py35hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "78a8996f7b1a0da8fad36b2eea9c6b4d", + "name": "lxml", + "sha256": "985ba55959f7b0bf7c1e73f72b4152193271eec1755d300fd14ad274e53969a2", + "size": 1499469, + "subdir": "linux-64", + "timestamp": 1533744688189, + "version": "4.2.4" + }, + "lxml-4.2.4-py36hf71bdeb_0.conda": { + "build": "py36hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "343d1959cdf455bdb561b9ae7d5b70cf", + "name": "lxml", + "sha256": "f2553bf27c6b16d758a6bf2e80a4c2c822971600a4875976a7c7342a184eb743", + "size": 1515241, + "subdir": "linux-64", + "timestamp": 1533744623304, + "version": "4.2.4" + }, + "lxml-4.2.4-py37hf71bdeb_0.conda": { + "build": "py37hf71bdeb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "c282ccf261d347413bc26b90bf7517b2", + "name": "lxml", + "sha256": "176557ec8870dfab3d5cdd918288732c2ea406373db36a8414c6120956f786a5", + "size": 1506099, + "subdir": "linux-64", + "timestamp": 1533744687579, + "version": "4.2.4" + }, + "lxml-4.2.5-py27hefd8a0e_0.conda": { + "build": "py27hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "001733723e462d8fc234abea4b96e15f", + "name": "lxml", + "sha256": "1eed0ad9e2ded80e6db245fb096920f4c218bc006f1fec713e5b33cea8e6c01f", + "size": 1501939, + "subdir": "linux-64", + "timestamp": 1536698420009, + "version": "4.2.5" + }, + "lxml-4.2.5-py35hefd8a0e_0.conda": { + "build": "py35hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "3373a1ffd7cb35665e5fc8ae128b2e1e", + "name": "lxml", + "sha256": "00a2bdd5c131b3771f611bc87e23b3661969cb42ddaf03d2e27d5eb6d98a73da", + "size": 1498707, + "subdir": "linux-64", + "timestamp": 1536698596088, + "version": "4.2.5" + }, + "lxml-4.2.5-py36hefd8a0e_0.conda": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "df983f3638ccd63ace3027d414e8b837", + "name": "lxml", + "sha256": "f7feda0feb1c9ba67d0d4d86baa95b5669595e12ad2cd062a81e66f65fcd3b2d", + "size": 1519501, + "subdir": "linux-64", + "timestamp": 1536698603784, + "version": "4.2.5" + }, + "lxml-4.2.5-py37hefd8a0e_0.conda": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "8ce253829c5f21135be10861fb45c7ca", + "name": "lxml", + "sha256": "093f45405e995264d8e50404c6f3d657ddd15880b7fba32700cb6f4b39308cc6", + "size": 1508455, + "subdir": "linux-64", + "timestamp": 1536698509589, + "version": "4.2.5" + }, + "lxml-4.3.0-py27hefd8a0e_0.conda": { + "build": "py27hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "0a1fdd764b7be681e6c9ad3f3738b49f", + "name": "lxml", + "sha256": "ff03325b75535c870f2381d89de1486a57cf165b726a3e05da1a3f7da4d98824", + "size": 1346227, + "subdir": "linux-64", + "timestamp": 1547236255688, + "version": "4.3.0" + }, + "lxml-4.3.0-py36hefd8a0e_0.conda": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "04e9d82d8f23a2898044ee0ad506d672", + "name": "lxml", + "sha256": "82ccfbe11c1be4ebaed6cb561e862466bc4dc281a1a20f7d905eb5b49dc448d9", + "size": 1380739, + "subdir": "linux-64", + "timestamp": 1547236352842, + "version": "4.3.0" + }, + "lxml-4.3.0-py37hefd8a0e_0.conda": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "ce572870b959f2bb1c5ecc5c0b49d9d3", + "name": "lxml", + "sha256": "715f0dd3b46421d43627dd9abe9ad19e3e64256433443aae67141fb6c1e376ce", + "size": 1371866, + "subdir": "linux-64", + "timestamp": 1547236279487, + "version": "4.3.0" + }, + "lxml-4.3.1-py27hefd8a0e_0.conda": { + "build": "py27hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "02c35723fc9c826a018fbb3a101ebd02", + "name": "lxml", + "sha256": "5e9ed84dbbe53c2a39a8fff57519e7e76e4b38c3247a60d9a57d69ab588878cb", + "size": 1350997, + "subdir": "linux-64", + "timestamp": 1550348751246, + "version": "4.3.1" + }, + "lxml-4.3.1-py36hefd8a0e_0.conda": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "dd44af41584918b990078f585b208325", + "name": "lxml", + "sha256": "127f59283feee139e275e5cdaefd29f30b5eebf8db11c008d106bb30064f17a6", + "size": 1384120, + "subdir": "linux-64", + "timestamp": 1550348776672, + "version": "4.3.1" + }, + "lxml-4.3.1-py37hefd8a0e_0.conda": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "68328598ed3e63990d27c8ca062de9c8", + "name": "lxml", + "sha256": "e3101a51f4205ba7a9f3726a6fa052da84d578ef598808c8fa275243d68ae417", + "size": 1375111, + "subdir": "linux-64", + "timestamp": 1550349771708, + "version": "4.3.1" + }, + "lxml-4.3.2-py27hefd8a0e_0.conda": { + "build": "py27hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "99e44e8bc9a2189fb7b61d2d2dd0dd9f", + "name": "lxml", + "sha256": "3f76a1b70f3739c829e47ebf98c91e60d947ce2ee022e23554e5f041defd7286", + "size": 1352614, + "subdir": "linux-64", + "timestamp": 1552327659698, + "version": "4.3.2" + }, + "lxml-4.3.2-py36hefd8a0e_0.conda": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "9e2167b66d0399b8acb377de333fe11d", + "name": "lxml", + "sha256": "70bbcc7ca23c3018591c742ce73f896e929d463b30b11b6163e118882f5fe194", + "size": 1388157, + "subdir": "linux-64", + "timestamp": 1552327703073, + "version": "4.3.2" + }, + "lxml-4.3.2-py37hefd8a0e_0.conda": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "92cea67c41bbb26107f1c96b35c4ca01", + "name": "lxml", + "sha256": "fb49178aae2a2dc45228b198e80cdd407c867a8790555efc021687b1d8a8ae4c", + "size": 1379970, + "subdir": "linux-64", + "timestamp": 1552327644010, + "version": "4.3.2" + }, + "lxml-4.3.3-py27hefd8a0e_0.conda": { + "build": "py27hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "b00e7f2d95d9c5fe5f3f1839082308d5", + "name": "lxml", + "sha256": "c3b534cc571fbc47d7fc3597aaa5de19b5b65ca03e263b649a4dd89adcf11696", + "size": 1351560, + "subdir": "linux-64", + "timestamp": 1555430125044, + "version": "4.3.3" + }, + "lxml-4.3.3-py36hefd8a0e_0.conda": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "d2432cb04f477eb5abe9d1236b9c3fd0", + "name": "lxml", + "sha256": "0112522d765cac6e4ce13dd32b2cc456d8f5fa88f4da37a3d705042c6b9782da", + "size": 1386273, + "subdir": "linux-64", + "timestamp": 1555429929477, + "version": "4.3.3" + }, + "lxml-4.3.3-py37hefd8a0e_0.conda": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "64b50ee9af01e31cc9e32e6ae9ddc9e4", + "name": "lxml", + "sha256": "2e69eb45570defc0fa7b9452b16e9c66dc5d5918a3527579f45d483f472c6fe6", + "size": 1377341, + "subdir": "linux-64", + "timestamp": 1555429960245, + "version": "4.3.3" + }, + "lxml-4.3.4-py27hefd8a0e_0.conda": { + "build": "py27hefd8a0e_0", + "build_number": 0, + "depends": [ + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "9765e4908632af4145132d3ac3d235b6", + "name": "lxml", + "sha256": "16d8afce74cb769397340504d3d94816b9faf97af26fd4396d62110b023a8e41", + "size": 1348009, + "subdir": "linux-64", + "timestamp": 1562084916851, + "version": "4.3.4" + }, + "lxml-4.3.4-py36hefd8a0e_0.conda": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "03204d45fb5f4e1c6285dd4397dcf4c0", + "name": "lxml", + "sha256": "48c7052a2d2b1fb6c852d51a40fd0c44d2b048a9c2737fabe2edd01c63fe9dd4", + "size": 1382228, + "subdir": "linux-64", + "timestamp": 1562084855365, + "version": "4.3.4" + }, + "lxml-4.3.4-py37hefd8a0e_0.conda": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "ebba628f4ddd14b0889221fdc64895fa", + "name": "lxml", + "sha256": "122e47f44bfb809d6cd56afa02fb10ef810846a9dd08dd2ae5624a92ea4acb68", + "size": 1373634, + "subdir": "linux-64", + "timestamp": 1562084929368, + "version": "4.3.4" + }, + "lxml-4.4.1-py27hefd8a0e_0.conda": { + "build": "py27hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "a3edc13649d206ffb39083bf5cafa603", + "name": "lxml", + "sha256": "9a40912bcc9363348d1d5f339996f66215f8d0125e717e3d7c56dc4c77c9ca39", + "size": 1422330, + "subdir": "linux-64", + "timestamp": 1565963417212, + "version": "4.4.1" + }, + "lxml-4.4.1-py36hefd8a0e_0.conda": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "282cdcf76e8a59df7710ccd972912c7d", + "name": "lxml", + "sha256": "bfd5ae625e94b38339573d1d0134b980ab989fefd6b91962a72460426e1327d7", + "size": 1455878, + "subdir": "linux-64", + "timestamp": 1565963487076, + "version": "4.4.1" + }, + "lxml-4.4.1-py37hefd8a0e_0.conda": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "5c9012435267273de8e8c95b534b0306", + "name": "lxml", + "sha256": "6c501b8808607983e41cc721509312e3068b13a5a443effeebcb385cc49710de", + "size": 1441881, + "subdir": "linux-64", + "timestamp": 1565965057925, + "version": "4.4.1" + }, + "lxml-4.4.1-py38hefd8a0e_0.conda": { + "build": "py38hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "b7299a98922f7313eb5b8522b0d8419c", + "name": "lxml", + "sha256": "862146a040aa65963706774fcf58d5f4457ff61d4ee405c4b44ff700ded41250", + "size": 1532476, + "subdir": "linux-64", + "timestamp": 1573488981909, + "version": "4.4.1" + }, + "lxml-4.4.2-py27hefd8a0e_0.conda": { + "build": "py27hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "c61177a2bdd730fc6f925e6884ddc946", + "name": "lxml", + "sha256": "dd1b123ea27de792077e43a8143c191b3cdb63ebd232598a5da450af3c68455e", + "size": 1417016, + "subdir": "linux-64", + "timestamp": 1575392874252, + "version": "4.4.2" + }, + "lxml-4.4.2-py36hefd8a0e_0.conda": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "759bd55f156ff85ef0311cca2f961e3b", + "name": "lxml", + "sha256": "14bfd2b4af4a53bcdef12714959387912204bf6ead8c5f8eebca3e0eed002b2d", + "size": 1453684, + "subdir": "linux-64", + "timestamp": 1575392877840, + "version": "4.4.2" + }, + "lxml-4.4.2-py37hefd8a0e_0.conda": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "7fb7a36d1cfe4a5d309ef79412f249b9", + "name": "lxml", + "sha256": "aa3b9476eb4c859a0b05f28f44b8274663a9ac2a578eaa9af19e6dcbe3a8633a", + "size": 1447007, + "subdir": "linux-64", + "timestamp": 1575392863820, + "version": "4.4.2" + }, + "lxml-4.4.2-py38hefd8a0e_0.conda": { + "build": "py38hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "fb24c9252a45176433ad45a0d7872fdc", + "name": "lxml", + "sha256": "675fb5927a4cf314f4fc6e876490957d5534e2134b8acd94f7611458aec35fa1", + "size": 1536059, + "subdir": "linux-64", + "timestamp": 1575392881919, + "version": "4.4.2" + }, + "lxml-4.5.0-py36hefd8a0e_0.conda": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "f482d45277c72dc1cf1923d3869fcbe2", + "name": "lxml", + "sha256": "79f86c5e4a574cfb0ee17658495f1bead13aeb5d598b056d264981253933c5f7", + "size": 1460105, + "subdir": "linux-64", + "timestamp": 1580834949033, + "version": "4.5.0" + }, + "lxml-4.5.0-py37hefd8a0e_0.conda": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "280aabdc4d208e9c7b7a516dfee5dd99", + "name": "lxml", + "sha256": "a3413776f4017890c22d590c446de6954590ed30995d63127410705dd4a4738b", + "size": 1448679, + "subdir": "linux-64", + "timestamp": 1580834923784, + "version": "4.5.0" + }, + "lxml-4.5.0-py38hefd8a0e_0.conda": { + "build": "py38hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause, GPL-2.0, ZPL-2.0, and ElementTree", + "md5": "e6faa4d62203c803f0bbdebd3e0dc698", + "name": "lxml", + "sha256": "155a8dd652baa00520689947b91cd1ee8f883d1f97f6d7b57139dd3b82df54c4", + "size": 1539864, + "subdir": "linux-64", + "timestamp": 1580834925769, + "version": "4.5.0" + }, + "lxml-4.5.1-py36hefd8a0e_0.conda": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "d3e822ef2133119f79333dcf6560f77f", + "name": "lxml", + "sha256": "b117b54f99347cab1ac36671052631b79535298eb2aa46cda3e4cc4105ec1a82", + "size": 1275025, + "subdir": "linux-64", + "timestamp": 1591882873369, + "version": "4.5.1" + }, + "lxml-4.5.1-py37hefd8a0e_0.conda": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "2d73f71d5e20140c4a01e5009d48ae2a", + "name": "lxml", + "sha256": "d0505089793b55752b5fa202e90df66af2158ffd54b733806508dd12cc4f51a4", + "size": 1261010, + "subdir": "linux-64", + "timestamp": 1591882859724, + "version": "4.5.1" + }, + "lxml-4.5.1-py38hefd8a0e_0.conda": { + "build": "py38hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxslt >=1.1.33,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "6f184a61aa34ebe637988460cf29aeec", + "name": "lxml", + "sha256": "fe12f3e3259d6f91232d536a8c376abaddc65814c6bcec98b124f6625d1e9a3e", + "size": 1353229, + "subdir": "linux-64", + "timestamp": 1591882827218, + "version": "4.5.1" + }, + "lxml-4.5.2-py36hefd8a0e_0.conda": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "1458914727641ebac8b2387617579e88", + "name": "lxml", + "sha256": "ded06587010a134f9f7072ebf1ce43e1b0fc83971b2a3e51d06027441f85e179", + "size": 1271723, + "subdir": "linux-64", + "timestamp": 1594826614186, + "version": "4.5.2" + }, + "lxml-4.5.2-py37hefd8a0e_0.conda": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "d901cdafa7da5f8373b5e1873c34f157", + "name": "lxml", + "sha256": "f757a0c76eb0835e4faf8ba896a18fe9fb0b1b59c50712ef9b57bce251a71316", + "size": 1262458, + "subdir": "linux-64", + "timestamp": 1594824538992, + "version": "4.5.2" + }, + "lxml-4.5.2-py38hefd8a0e_0.conda": { + "build": "py38hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "653a203295559dbe75d75efb02577bf8", + "name": "lxml", + "sha256": "814c51abc4a1f3182652759173ccf04cda8aed7d7baf1c4ec5bcf936ac6bc76d", + "size": 1354197, + "subdir": "linux-64", + "timestamp": 1594826900981, + "version": "4.5.2" + }, + "lxml-4.6.1-py36hefd8a0e_0.conda": { + "build": "py36hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "5e4c377da5cfda5de2cac6a0839e5154", + "name": "lxml", + "sha256": "3c85867136243a0404fc7dc7613aa4d4230a7454a4e1096a41211c40e7468fbb", + "size": 1267646, + "subdir": "linux-64", + "timestamp": 1603216402424, + "version": "4.6.1" + }, + "lxml-4.6.1-py37hefd8a0e_0.conda": { + "build": "py37hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "b1879f2fed13232012bc0c157115c050", + "name": "lxml", + "sha256": "90dc710941dfef6ae7bf105549d04c3c3c16b2714f2fd4d67658e8da6eb40ce8", + "size": 1257597, + "subdir": "linux-64", + "timestamp": 1603216418742, + "version": "4.6.1" + }, + "lxml-4.6.1-py38hefd8a0e_0.conda": { + "build": "py38hefd8a0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "ef7a0c0de01137251f3daa253308fd2f", + "name": "lxml", + "sha256": "5277ea685efdf76453f7a2defb0536df8abe1be7f16c31a0ee95a63723078444", + "size": 1349714, + "subdir": "linux-64", + "timestamp": 1603216417985, + "version": "4.6.1" + }, + "lxml-4.6.2-py36h9120a33_0.conda": { + "build": "py36h9120a33_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "ceb19b2541d3cd09b2914b9781410e09", + "name": "lxml", + "sha256": "6ccac9f13f8b98a758ec94d64ed5393edf3852682dbcf20563856d9a372d9292", + "size": 1268522, + "subdir": "linux-64", + "timestamp": 1606516980497, + "version": "4.6.2" + }, + "lxml-4.6.2-py37h9120a33_0.conda": { + "build": "py37h9120a33_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "ab64a098fac490c70d118d6cac9f1190", + "name": "lxml", + "sha256": "ba4a4c62614a67a3e112c0b29671e57c3407b98c0bf77bfedc8cd5ce2b7a2c2f", + "size": 1259635, + "subdir": "linux-64", + "timestamp": 1606516979285, + "version": "4.6.2" + }, + "lxml-4.6.2-py38h9120a33_0.conda": { + "build": "py38h9120a33_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "7d19b02e47f6b809928e9a4643cc9634", + "name": "lxml", + "sha256": "8c829b6ad156b382171bb5a26d2b9d7a14e183d3531ac0b8ea262ae253da98e2", + "size": 1353093, + "subdir": "linux-64", + "timestamp": 1606516984778, + "version": "4.6.2" + }, + "lxml-4.6.2-py39h9120a33_0.conda": { + "build": "py39h9120a33_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "6bfcc54996ebd91714a210cefb90e942", + "name": "lxml", + "sha256": "35fea2d8ce2ade6bfe53815abdda52a2024ec8cba42ca46307c91b454357b9a8", + "size": 1347410, + "subdir": "linux-64", + "timestamp": 1606516960775, + "version": "4.6.2" + }, + "lxml-4.6.3-py310hec1077d_0.conda": { + "build": "py310hec1077d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "c471ab1f66bc695e8fa11127967fca67", + "name": "lxml", + "sha256": "360203e0334eaedb4ec11078ca41ec1f99c15ce3fa6b273616ed58bcd2644168", + "size": 4710353, + "subdir": "linux-64", + "timestamp": 1640791507708, + "version": "4.6.3" + }, + "lxml-4.6.3-py36h9120a33_0.conda": { + "build": "py36h9120a33_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "a1f8d064b205b069216e5e5cb2b1bd8d", + "name": "lxml", + "sha256": "b384b782d4f05950faf4ee46b2c59158dd1a52a2be7b068cf144c0373e333901", + "size": 1269629, + "subdir": "linux-64", + "timestamp": 1616443050444, + "version": "4.6.3" + }, + "lxml-4.6.3-py37h9120a33_0.conda": { + "build": "py37h9120a33_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "f7741ce2a25d0f7d0c0d81b9a4f8e10a", + "name": "lxml", + "sha256": "12cbe553364e833a4db3c7d01aa6ac11bd5342b9d7809c2ae0cb4b16c4f45b1d", + "size": 1265062, + "subdir": "linux-64", + "timestamp": 1616443048313, + "version": "4.6.3" + }, + "lxml-4.6.3-py38h9120a33_0.conda": { + "build": "py38h9120a33_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "470c020ddc8fd8756afc6f6ee688d94a", + "name": "lxml", + "sha256": "316a1a5a9e638ac268e25acb88d8a2fabcda17c3718134c332a5569db100e54c", + "size": 1354767, + "subdir": "linux-64", + "timestamp": 1616443350824, + "version": "4.6.3" + }, + "lxml-4.6.3-py39h9120a33_0.conda": { + "build": "py39h9120a33_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "3e9c00c9ec78179e4f4ff54602a12eb4", + "name": "lxml", + "sha256": "672b8d5d8a9286db9d2fe0ea0799be8d71031e8bfa93276800431e4258b15f15", + "size": 1352320, + "subdir": "linux-64", + "timestamp": 1616443358898, + "version": "4.6.3" + }, + "lxml-4.7.1-py37h1f438cf_0.conda": { + "build": "py37h1f438cf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "37728f7fd354f076473a358edd173bbf", + "name": "lxml", + "sha256": "13cb0b536193833a0bfe2c156b924a1715f31774122da1fdc253044c911d62c5", + "size": 1281895, + "subdir": "linux-64", + "timestamp": 1640153397171, + "version": "4.7.1" + }, + "lxml-4.7.1-py37h1f438cf_1.conda": { + "build": "py37h1f438cf_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "78f8b9be11f3cb41de39eaa4ae1e661f", + "name": "lxml", + "sha256": "2068d8664cf719bdff6dd592b1907182b17b513a84a054c8931705626dbe6e70", + "size": 1287795, + "subdir": "linux-64", + "timestamp": 1640178379946, + "version": "4.7.1" + }, + "lxml-4.7.1-py37hec1077d_0.conda": { + "build": "py37hec1077d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "8824eda41d8abef82aef08c5af7cf0c2", + "name": "lxml", + "sha256": "8a65f7f9aa8ec822d4a5cf2d906378d6abff47640d73bcb3d74b01b6ec733f92", + "size": 1277115, + "subdir": "linux-64", + "timestamp": 1640087751947, + "version": "4.7.1" + }, + "lxml-4.7.1-py38h1f438cf_0.conda": { + "build": "py38h1f438cf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "1dca77830472397c774f6ff07a58c7e9", + "name": "lxml", + "sha256": "89df5a0d2ae66367c947c155537b3d9e023de58d6a54ccefdd2c609c97c108b2", + "size": 1365800, + "subdir": "linux-64", + "timestamp": 1640167505942, + "version": "4.7.1" + }, + "lxml-4.7.1-py38h1f438cf_1.conda": { + "build": "py38h1f438cf_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "a7bce5a82f4742d041161d1ea861f982", + "name": "lxml", + "sha256": "b415c68df0599681a1866535df76f16a96ad440b9175ad381fa661140aa4e9d3", + "size": 1377227, + "subdir": "linux-64", + "timestamp": 1640164489622, + "version": "4.7.1" + }, + "lxml-4.7.1-py38hec1077d_0.conda": { + "build": "py38hec1077d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "4abc1e58b447506bc2cce7b80af93936", + "name": "lxml", + "sha256": "5cc0d74e8feab521db00dad4ac62bc139a6f7e3ad1daf2843e3abde5fca07cb8", + "size": 1368331, + "subdir": "linux-64", + "timestamp": 1640166577855, + "version": "4.7.1" + }, + "lxml-4.7.1-py39h1f438cf_0.conda": { + "build": "py39h1f438cf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "114540807c317bffc88250793d1f7ee1", + "name": "lxml", + "sha256": "e25cbe1a5728417b63b2e60f7a0594ceec0f92f05c518635f4be764fef9a4004", + "size": 1365149, + "subdir": "linux-64", + "timestamp": 1640167512186, + "version": "4.7.1" + }, + "lxml-4.7.1-py39h1f438cf_1.conda": { + "build": "py39h1f438cf_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "90547ab6130944339bfe6c71d4e49b57", + "name": "lxml", + "sha256": "92422afc5046d1e80e6f5b41892e676922857d452370866a84749ef173e0348c", + "size": 1377114, + "subdir": "linux-64", + "timestamp": 1640160259275, + "version": "4.7.1" + }, + "lxml-4.7.1-py39hec1077d_0.conda": { + "build": "py39hec1077d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "21d206e978e54842ca557a181ae7f19f", + "name": "lxml", + "sha256": "70299b97b629a7c852c32cc8a008d81254a59d9b1e98197b20a8cdd892b53fa9", + "size": 1368788, + "subdir": "linux-64", + "timestamp": 1640105873206, + "version": "4.7.1" + }, + "lxml-4.8.0-py310h1f438cf_0.conda": { + "build": "py310h1f438cf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "f246a519829bbbf782e7b3ed93e20a0c", + "name": "lxml", + "sha256": "8e35215435d18d70235724320a704b8c97f8296daaa8180725c2cc3ec5c491bf", + "size": 4781094, + "subdir": "linux-64", + "timestamp": 1646642809299, + "version": "4.8.0" + }, + "lxml-4.8.0-py37h1f438cf_0.conda": { + "build": "py37h1f438cf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "c3ef0c1b1f981489a364618f870d9ea5", + "name": "lxml", + "sha256": "c1cf8201f1f0e119557b9ed4e1c96f7ba01f92f9b4464f3f4560ceededc0d88d", + "size": 1284586, + "subdir": "linux-64", + "timestamp": 1646642772018, + "version": "4.8.0" + }, + "lxml-4.8.0-py38h1f438cf_0.conda": { + "build": "py38h1f438cf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "9b4d2b47f33bd971e7221ed81fbfc7fa", + "name": "lxml", + "sha256": "256dbaf35439f398e552e5b6e9e7d10e33f5c78a395a3e40de9077a4ffbc05aa", + "size": 1378713, + "subdir": "linux-64", + "timestamp": 1646625393119, + "version": "4.8.0" + }, + "lxml-4.8.0-py39h1f438cf_0.conda": { + "build": "py39h1f438cf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxslt >=1.1.28", + "libxslt >=1.1.34,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "md5": "c08c2a8221682044fcd7b5f74bcae363", + "name": "lxml", + "sha256": "942643a3db09616804c8b8b5c82ebed6b3eb6a786c0ea0b6a4c26275ca0d19e3", + "size": 1375913, + "subdir": "linux-64", + "timestamp": 1646624639995, + "version": "4.8.0" + }, + "lxml-4.9.1-py310h1edc446_0.conda": { + "build": "py310h1edc446_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "libxslt >=1.1.28", + "libxslt >=1.1.35,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "license_family": "Other", + "md5": "58804e8eb18ecac6225aaa3439966627", + "name": "lxml", + "sha256": "c27161d1aad99a48d7c215e28e189da920b3a92773e68ecce6a2391b964afae3", + "size": 5451014, + "subdir": "linux-64", + "timestamp": 1657545422195, + "version": "4.9.1" + }, + "lxml-4.9.1-py311h1edc446_0.conda": { + "build": "py311h1edc446_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "libxslt >=1.1.28", + "libxslt >=1.1.35,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "license_family": "Other", + "md5": "2cfd559696c4bf88b77b9d43f4c5fd65", + "name": "lxml", + "sha256": "878a4141b9d83daba30c133cec8cb6952aaf7768e0f96447433c86a5e79266b6", + "size": 1329292, + "subdir": "linux-64", + "timestamp": 1676823679793, + "version": "4.9.1" + }, + "lxml-4.9.1-py37h1edc446_0.conda": { + "build": "py37h1edc446_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "libxslt >=1.1.28", + "libxslt >=1.1.35,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "license_family": "Other", + "md5": "94d1edfa9365bff6d41e0a4065909d68", + "name": "lxml", + "sha256": "1ec4cf22a57905692b539fefe2644350ccf612df6d1c24259d373c355d89d689", + "size": 1289270, + "subdir": "linux-64", + "timestamp": 1657545665009, + "version": "4.9.1" + }, + "lxml-4.9.1-py38h1edc446_0.conda": { + "build": "py38h1edc446_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "libxslt >=1.1.28", + "libxslt >=1.1.35,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "license_family": "Other", + "md5": "49a167d34716145aa97c8f27724eadc7", + "name": "lxml", + "sha256": "47d12d68707951becdad5614fdce490d676246a97b4fd3efe7fb6c9627560438", + "size": 1356965, + "subdir": "linux-64", + "timestamp": 1657545279429, + "version": "4.9.1" + }, + "lxml-4.9.1-py39h1edc446_0.conda": { + "build": "py39h1edc446_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "libxslt >=1.1.28", + "libxslt >=1.1.35,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "license_family": "Other", + "md5": "4a0726cf275f0a7200afd1a35797945f", + "name": "lxml", + "sha256": "09c67963ba3dfddcfcacfa430e2e82e1aeced5a6ce02ce4bb15b1d1543c7a799", + "size": 1330389, + "subdir": "linux-64", + "timestamp": 1657545537815, + "version": "4.9.1" + }, + "lxml-4.9.2-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "libxslt >=1.1.28,<2.0.0a0", + "libxslt >=1.1.37,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "license_family": "Other", + "md5": "a4bc452df3cec3b4ad9ea3d20e99d63d", + "name": "lxml", + "sha256": "261f2b208d3f1a5a01d3c62e16b673ec7d2af294182bb282e60686d6b8a356a6", + "size": 1540316, + "subdir": "linux-64", + "timestamp": 1679646648983, + "version": "4.9.2" + }, + "lxml-4.9.2-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "libxslt >=1.1.28,<2.0.0a0", + "libxslt >=1.1.37,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "license_family": "Other", + "md5": "4ae2eb5c67ef23d77bbe941c1c33f7e3", + "name": "lxml", + "sha256": "1e7d2b285691b885b4709ad9641a5568318cd9471fefa7f952c7fd91428ba49e", + "size": 1571789, + "subdir": "linux-64", + "timestamp": 1679646846055, + "version": "4.9.2" + }, + "lxml-4.9.2-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "libxslt >=1.1.28,<2.0.0a0", + "libxslt >=1.1.37,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "license_family": "Other", + "md5": "b97e417e93ab7c72d94e09e43ff75f55", + "name": "lxml", + "sha256": "36afcc64a8a8a969872d3a8047462913cb3e44b98b1d27d37a14c1d373d3610d", + "size": 1584432, + "subdir": "linux-64", + "timestamp": 1679646751278, + "version": "4.9.2" + }, + "lxml-4.9.2-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "libxslt >=1.1.28,<2.0.0a0", + "libxslt >=1.1.37,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause and GPL-2.0-only and ZPL-2.0 and LicenseRef-ElementTree", + "license_family": "Other", + "md5": "05d007c95241e141b84d85955959a99f", + "name": "lxml", + "sha256": "ec3bc900bf5458e0bb2725e21f73c088ecf7fbfee68fcd19bc14ae9fdb657bc3", + "size": 1555164, + "subdir": "linux-64", + "timestamp": 1679646554227, + "version": "4.9.2" + }, + "lz4-1.1.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "543a981d03a68e9f769fbede28b4e0e1", + "name": "lz4", + "sha256": "ebd0a6d708e91c35b340f2264277b26843f305c376e222f5789540aebbdd00bb", + "size": 35433, + "subdir": "linux-64", + "timestamp": 1537199702830, + "version": "1.1.0" + }, + "lz4-1.1.0-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8389353773fad375ea71fae467aa7ce2", + "name": "lz4", + "sha256": "0c89e5b4def4680e4f2cc6614643252ab654be716bdb60f8f42330a85725d4f7", + "size": 36042, + "subdir": "linux-64", + "timestamp": 1537199747007, + "version": "1.1.0" + }, + "lz4-1.1.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "60fca39419bbb5910d1ab28548bf3571", + "name": "lz4", + "sha256": "c75237d0715e18154c7ef1b817337455e1b2c1b1dd6898d123e7a79fd267082d", + "size": 35944, + "subdir": "linux-64", + "timestamp": 1537199727393, + "version": "1.1.0" + }, + "lz4-1.1.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "525a35eaa3fc32a45431f5e2e7f33648", + "name": "lz4", + "sha256": "bfa8254831ef3f5b067e6ade7eb5ef8c856db10558d471a7c0e07e6665dde056", + "size": 35537, + "subdir": "linux-64", + "timestamp": 1537199665286, + "version": "1.1.0" + }, + "lz4-2.1.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1b48d17d12e80b61b10d020fc5329e85", + "name": "lz4", + "sha256": "2caa795081a78a3878fe9c3c7c668deb41bc60762ae42a93cdf2ea439d903033", + "size": 38171, + "subdir": "linux-64", + "timestamp": 1539723775825, + "version": "2.1.1" + }, + "lz4-2.1.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "57a9949178ecdc3a45ed1de4630ffba6", + "name": "lz4", + "sha256": "f19731a09df689edcdcb33cc061bab4f93681dba61f71fe612821caae2355223", + "size": 38225, + "subdir": "linux-64", + "timestamp": 1539723815791, + "version": "2.1.1" + }, + "lz4-2.1.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "31c223cb2319b54a871337797ab9fe6a", + "name": "lz4", + "sha256": "74a124206e3d50da46b20ede5afe8bb34cf5c219060b9c5487df23db31be9a6d", + "size": 38086, + "subdir": "linux-64", + "timestamp": 1539723815004, + "version": "2.1.1" + }, + "lz4-2.1.2-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3b49e353f8289289ebe0447628f22c5b", + "name": "lz4", + "sha256": "6328daedb85bf41a0214c116bf897f5b5f4c6132aea9a8bfa6708091f28df9e3", + "size": 37812, + "subdir": "linux-64", + "timestamp": 1541436368656, + "version": "2.1.2" + }, + "lz4-2.1.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5cb052866701fd7956187f94421f05b0", + "name": "lz4", + "sha256": "a347b32983e13d0f2b94ca74c1ba29ca5c204d7cb6cda8b41cd65a6f298fac9f", + "size": 38415, + "subdir": "linux-64", + "timestamp": 1541436353153, + "version": "2.1.2" + }, + "lz4-2.1.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "57f3181620f77c1c4a14caa1f50b705c", + "name": "lz4", + "sha256": "5674ef594d706af9b3b467ea5aa23d6d33176d453f38e90843ffad73c5234d9e", + "size": 38186, + "subdir": "linux-64", + "timestamp": 1541436332254, + "version": "2.1.2" + }, + "lz4-2.1.6-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1f2c09d8a4ad58450a9dbad6c347e1ce", + "name": "lz4", + "sha256": "477ecd46a0afe5fd02e089c6516a00b6bc1c94258446649cfb0888387e40337a", + "size": 39051, + "subdir": "linux-64", + "timestamp": 1547236710378, + "version": "2.1.6" + }, + "lz4-2.1.6-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5b4cddaa1d6730029c4e8b1b96058633", + "name": "lz4", + "sha256": "ccfb8dcac9eab00a0cecea6814b501d78b553eb500b8690a80279e832af4cfcf", + "size": 39012, + "subdir": "linux-64", + "timestamp": 1547236726127, + "version": "2.1.6" + }, + "lz4-2.1.6-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "782e41f4b35d3df9364a76f9e6776d8b", + "name": "lz4", + "sha256": "7c52f29e2e0ac83e80ccad2c6b8705080dab329b526b3ffc65b10bf0a1db613b", + "size": 39009, + "subdir": "linux-64", + "timestamp": 1547236677523, + "version": "2.1.6" + }, + "lz4-2.1.9-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "78bedde882592bf21017adfb07a1f2d0", + "name": "lz4", + "sha256": "49d676d2c4ca520366c57044d0827ca9d3aaff1089d54d2733e114a98b4d8739", + "size": 39163, + "subdir": "linux-64", + "timestamp": 1559920132291, + "version": "2.1.9" + }, + "lz4-2.1.9-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4130e0b579a21c60c7f0e54a31ac2811", + "name": "lz4", + "sha256": "11ade252a537df6accc8e6f3ed0e148b4b09ec1437005e06807f732476040881", + "size": 39281, + "subdir": "linux-64", + "timestamp": 1559920145812, + "version": "2.1.9" + }, + "lz4-2.1.9-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "08c1fd0103d9151503502b7e153116bc", + "name": "lz4", + "sha256": "b0b11befbfacee350e67a37fec9d5014d29c17e797647d2b7866304313f3c301", + "size": 39284, + "subdir": "linux-64", + "timestamp": 1559920127749, + "version": "2.1.9" + }, + "lz4-2.2.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c5006858483f27f1844e6b8cc37a5dc6", + "name": "lz4", + "sha256": "76fc46bd96dd2a3b88a5f03641cebdb49fbdc812c948a9eec51f7a5abb96bad1", + "size": 39677, + "subdir": "linux-64", + "timestamp": 1569356777893, + "version": "2.2.1" + }, + "lz4-2.2.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a9e38f4fa05c16962ff5161491fa71d4", + "name": "lz4", + "sha256": "811058dda3095fe4cf4f6e494a9c72a2a24f58a55e3a0806884310ad98597c1c", + "size": 39721, + "subdir": "linux-64", + "timestamp": 1569356780334, + "version": "2.2.1" + }, + "lz4-2.2.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2d8e566f07cce278635e39a7dfe2b2ca", + "name": "lz4", + "sha256": "1a49df6f6c98172e16680cde10b580c384fad457dcabdf7c9754ed597e9a06e3", + "size": 39865, + "subdir": "linux-64", + "timestamp": 1569356782185, + "version": "2.2.1" + }, + "lz4-2.2.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b7ac3b7852d475fe57a1d1c86e7d043e", + "name": "lz4", + "sha256": "6d7bab735c1797723d6591b4755c1d6235dad758465a3b2fc6349c1b7e4c50e7", + "size": 44541, + "subdir": "linux-64", + "timestamp": 1573638867595, + "version": "2.2.1" + }, + "lz4-3.1.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5e4caeedd9db0bb6d407fc7264771586", + "name": "lz4", + "sha256": "bb5dadbbabf2c86a183d22f9f4dd4e9f27ae9264b103c7660bd235b0b74d8f53", + "size": 46489, + "subdir": "linux-64", + "timestamp": 1613042036484, + "version": "3.1.0" + }, + "lz4-3.1.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6231b3ed6fb3405c0177850f8098a785", + "name": "lz4", + "sha256": "5d707a28742147aed0010ef8dbda6f298cfc473f18a9a156749de23f7d80c5c8", + "size": 46209, + "subdir": "linux-64", + "timestamp": 1595342417404, + "version": "3.1.0" + }, + "lz4-3.1.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3745b54e4d22c3567be8fd4af0ec3548", + "name": "lz4", + "sha256": "d815eb63d3f30fb4a1e98ba5e63a46b48e41270d5a8712df61f72db84677bdc7", + "size": 46478, + "subdir": "linux-64", + "timestamp": 1613042438804, + "version": "3.1.0" + }, + "lz4-3.1.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e2349be00d4e6489f832a3077b42475d", + "name": "lz4", + "sha256": "5c01885e8a63a0b7c53def920a44e4cd404f600e017cb663702fb881e66cac9a", + "size": 45877, + "subdir": "linux-64", + "timestamp": 1595342415756, + "version": "3.1.0" + }, + "lz4-3.1.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0d692720b7d92da716bcf9243ace7761", + "name": "lz4", + "sha256": "1d781cc55a1323b17d05d892e396fba6e9454be296b428795567c3a2ddcf7196", + "size": 46460, + "subdir": "linux-64", + "timestamp": 1613041622885, + "version": "3.1.0" + }, + "lz4-3.1.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8673762fbca59e7b8abf2a0e0ebd7361", + "name": "lz4", + "sha256": "200ecfe66a1e41a688934f8b8a280b07d08dc26926e8dbe022a6ab7a639a809c", + "size": 46207, + "subdir": "linux-64", + "timestamp": 1595342415739, + "version": "3.1.0" + }, + "lz4-3.1.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d31031115bd296b70b5f10c92731900c", + "name": "lz4", + "sha256": "e0efaf9a234857cfd3eb66dbee3f5297e5736fcc859fd9d925b74c5d529ff0d1", + "size": 46522, + "subdir": "linux-64", + "timestamp": 1613042264749, + "version": "3.1.0" + }, + "lz4-3.1.3-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0e78d0b76c0d6eebb50476fbff5e04ad", + "name": "lz4", + "sha256": "5bbb9c90878d75c34a3fc8ec8a03a14990ea0d4755067c79a1d439b3e5e03b96", + "size": 87010, + "subdir": "linux-64", + "timestamp": 1640887669052, + "version": "3.1.3" + }, + "lz4-3.1.3-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "lz4-c >=1.9.4,<1.10.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a0ed90958a10fad2cf808c8b9badb23e", + "name": "lz4", + "sha256": "de56b0f9b4b64cba2af6cb06a7745ba6720e477b41fe21f92ab0e7d4fc3c6839", + "size": 45992, + "subdir": "linux-64", + "timestamp": 1676919153235, + "version": "3.1.3" + }, + "lz4-3.1.3-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff9236d204af589c89a44747add1e330", + "name": "lz4", + "sha256": "ccfea98d1c60ef51a5b70319fd303cec09a37bb93d2c6ee25d31af81c792286e", + "size": 43120, + "subdir": "linux-64", + "timestamp": 1619516554661, + "version": "3.1.3" + }, + "lz4-3.1.3-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ddffbe9c003d50459c885a2d15cf9e4c", + "name": "lz4", + "sha256": "dc63698b498116e5de1932943129b877512b8232ea8b86f1bc2b6d785ed0a0ea", + "size": 42906, + "subdir": "linux-64", + "timestamp": 1619516546962, + "version": "3.1.3" + }, + "lz4-3.1.3-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7f482d27026f84f0cc6f68e864e8c8e4", + "name": "lz4", + "sha256": "675dd4e0af9e3e27ced2ae4ae8f82916b0308b2b0623ed0e9fdf5edf207f0d7a", + "size": 43545, + "subdir": "linux-64", + "timestamp": 1619516566078, + "version": "3.1.3" + }, + "lz4-3.1.3-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ec2ec9f9f07ef6620cd61dc44392702a", + "name": "lz4", + "sha256": "f71c3b28d2aaca88f967e1a7df0922fe514d1fa97ee8c2a76d04533b05777c00", + "size": 43059, + "subdir": "linux-64", + "timestamp": 1619516561285, + "version": "3.1.3" + }, + "lz4-c-1.8.0-h2d24295_0.conda": { + "build": "h2d24295_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "BSD 2-clause", + "md5": "b4891e6b2ad6c2817eed7832aae6ae68", + "name": "lz4-c", + "sha256": "d27d18cb0efc70eb2bf0710284a84c0b1b1374305f280698bc3c84315e2051b9", + "size": 125439, + "subdir": "linux-64", + "timestamp": 1510141889060, + "version": "1.8.0" + }, + "lz4-c-1.8.1.2-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "BSD 2-clause", + "md5": "19dfb87e3259ebded29f87e4b60ac2df", + "name": "lz4-c", + "sha256": "cbfbcdf77b6198ed3182d6eae5bc62abc519b3edb1fe6f374fcb65d00fa78779", + "size": 132801, + "subdir": "linux-64", + "timestamp": 1524590233890, + "version": "1.8.1.2" + }, + "lz4-c-1.9.2-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "md5": "4899d16ada033fa05d5189af56d8a279", + "name": "lz4-c", + "sha256": "7d465225030c07178b7f850db5def2519127d9962c492694ad0f52661fc1cb87", + "size": 196017, + "subdir": "linux-64", + "timestamp": 1587011750239, + "version": "1.9.2" + }, + "lz4-c-1.9.2-he6710b0_1.conda": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "md5": "415fed981d2c58e82c2aa9aea7443a6c", + "name": "lz4-c", + "sha256": "7bc13c80c2eff3d0124b727b127af7b7e007df87302d24b07d9d6966b4e10015", + "size": 194509, + "subdir": "linux-64", + "timestamp": 1595960707865, + "version": "1.9.2" + }, + "lz4-c-1.9.2-heb0550a_3.conda": { + "build": "heb0550a_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "md5": "e5ca74db6634f89f50979eadcea8b0c8", + "name": "lz4-c", + "sha256": "dcb108018b049fdb6694134c4f65a9ea838af131a814414e3289937db1763e0b", + "size": 179170, + "subdir": "linux-64", + "timestamp": 1601566162695, + "version": "1.9.2" + }, + "lz4-c-1.9.3-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "md5": "1c5839d25f73e4067609a257db7d3624", + "name": "lz4-c", + "sha256": "b4f4a28fe516bc1d0d76d5805213f63386a83187b4f231b7b20e2d929b6a9318", + "size": 189955, + "subdir": "linux-64", + "timestamp": 1611255479227, + "version": "1.9.3" + }, + "lz4-c-1.9.3-h295c915_1.conda": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d9bd18f73ff566e08add10a54a3463cf", + "name": "lz4-c", + "sha256": "e37c0efa15afddeaa329a76add1c657787efba334002b31449a3996175215330", + "size": 188953, + "subdir": "linux-64", + "timestamp": 1627657046002, + "version": "1.9.3" + }, + "lz4-c-1.9.4-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "53915e9402180a7f22ea619c41089520", + "name": "lz4-c", + "sha256": "763815f0f0795e4240df99d1992ae9799b3ac62eaea97438086526988ef31073", + "size": 158001, + "subdir": "linux-64", + "timestamp": 1670944701605, + "version": "1.9.4" + }, + "lz4-c-static-1.9.2-3.conda": { + "build": "3", + "build_number": 3, + "depends": [], + "license": "BSD-2-Clause", + "md5": "68a5a5d35fc3a2738e8875543430da79", + "name": "lz4-c-static", + "sha256": "c02d4302961d39c202205ea76d40de55cdaa59dfb226f29236670c2adfee3571", + "size": 102474, + "subdir": "linux-64", + "timestamp": 1601566165831, + "version": "1.9.2" + }, + "lz4-c-static-1.9.3-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "BSD-2-Clause", + "md5": "706c112bfeeac348216f9ad4246947d6", + "name": "lz4-c-static", + "sha256": "73bc32ee0f0a72e216672b1d60935cea5460ae48396f13272fbf1217b67c1cf6", + "size": 113815, + "subdir": "linux-64", + "timestamp": 1611255482435, + "version": "1.9.3" + }, + "lz4-c-static-1.9.3-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "44ea49f210ce5f4d6ad80a5bcfbd2329", + "name": "lz4-c-static", + "sha256": "54609ace38c3e84d6670b765d4b5f182df6d4d16a4cf1e1237866588bf7337f3", + "size": 113975, + "subdir": "linux-64", + "timestamp": 1627657048924, + "version": "1.9.3" + }, + "lz4-c-static-1.9.4-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8938da8ab23f099fc62d684c175534d9", + "name": "lz4-c-static", + "sha256": "5108dd4f113addfc96bb156a3b6af6900e4d78b69fe809b7cc9c3f0dd4a3e599", + "size": 94970, + "subdir": "linux-64", + "timestamp": 1670944704518, + "version": "1.9.4" + }, + "lzo-2.10-h1bfc0ba_1.conda": { + "build": "h1bfc0ba_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL v2+", + "license_family": "GPL2", + "md5": "8f4e1425e63940f4ec717d1a51d71b71", + "name": "lzo", + "sha256": "c58527bacc8f451796dfd2a41ffb33847fa262652c8653187a96124cb90454cf", + "size": 186403, + "subdir": "linux-64", + "timestamp": 1506561066267, + "version": "2.10" + }, + "lzo-2.10-h49e0be7_2.conda": { + "build": "h49e0be7_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL v2+", + "license_family": "GPL2", + "md5": "df80b5be9b08b552fb9a4daf9dc68e97", + "name": "lzo", + "sha256": "092e96b1b1325f60fbc90a39758f227f03d27da4f847519562efebdde0af4d6e", + "size": 186132, + "subdir": "linux-64", + "timestamp": 1511294307364, + "version": "2.10" + }, + "lzo-2.10-h7b6447c_2.conda": { + "build": "h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL v2+", + "license_family": "GPL2", + "md5": "65722a7644f424de73fea6e87edd7653", + "name": "lzo", + "sha256": "99dc28dd81f7d94a363a242e56fb9ebdaf350ca6445a8f1b31dfe78be474a5df", + "size": 188158, + "subdir": "linux-64", + "timestamp": 1587075113981, + "version": "2.10" + }, + "lzo-2.10-hc0eb8fc_0.conda": { + "build": "hc0eb8fc_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL v2+", + "license_family": "GPL2", + "md5": "9791667a88e2fe790e768cc344849c03", + "name": "lzo", + "sha256": "3bfd7b0fc9770a8fdc65d4ba459a5412dc7b19a3ca97970dce54e1f437bb4fbf", + "size": 185399, + "subdir": "linux-64", + "timestamp": 1505729180342, + "version": "2.10" + }, + "m4-1.4.18-h4e445db_0.conda": { + "build": "h4e445db_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL-3.0", + "md5": "799785dac3c1caa68af0ee04d8ddaaa7", + "name": "m4", + "sha256": "c42531839b61d39c29947a4ce4eb0ad372247eb266d4e461def4440a1454cfe0", + "size": 186783, + "subdir": "linux-64", + "timestamp": 1505665975958, + "version": "1.4.18" + }, + "macholib-1.16.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "altgraph >=0.17", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d100f186006bc0f87349b61544c2b99", + "name": "macholib", + "sha256": "9b2f4fa9c996f17db16cffa95a272701b131993479839db3bca851100cd19e7f", + "size": 73199, + "subdir": "linux-64", + "timestamp": 1670513278249, + "version": "1.16.2" + }, + "macholib-1.16.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "altgraph >=0.17", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18bd093a19d6d322a1ce86870277b07d", + "name": "macholib", + "sha256": "0c0bc16a0d360ae0cb35282bb1acf27ebd0c66892d89a85a827182828f22684b", + "size": 91392, + "subdir": "linux-64", + "timestamp": 1676858572371, + "version": "1.16.2" + }, + "macholib-1.16.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "altgraph >=0.17", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1936371687cfca87453462fc89aa5be3", + "name": "macholib", + "sha256": "94c3ac978e2d51fcfb8f00c573c01a495e98fef03e1f06dd31bcb3b0d5996546", + "size": 72584, + "subdir": "linux-64", + "timestamp": 1670513303510, + "version": "1.16.2" + }, + "macholib-1.16.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "altgraph >=0.17", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e91fe29019393ebb8244cacc480978f", + "name": "macholib", + "sha256": "9513e082a0538d5265c20a45578968f89067a13dc743369194ce658eebb43e6b", + "size": 72530, + "subdir": "linux-64", + "timestamp": 1670513353580, + "version": "1.16.2" + }, + "macholib-1.16.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "altgraph >=0.17", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f499800db78b53aaea76e368c676800", + "name": "macholib", + "sha256": "2086ee991e88116553fcd22bc42059c2e666f0c6584ffaff0f22b4aa64b9b913", + "size": 72676, + "subdir": "linux-64", + "timestamp": 1670513328733, + "version": "1.16.2" + }, + "magma-2.3.0-h51060c3_0.conda": { + "build": "h51060c3_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=8.0,<8.1.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1fde820f3aca32ccc48c8e3f35c65bf5", + "name": "magma", + "sha256": "71bc97ab6e60d56608e6f53d4146a2762e3ef18dda74663868f844916e606643", + "size": 24146299, + "subdir": "linux-64", + "timestamp": 1550812835675, + "version": "2.3.0" + }, + "magma-2.3.0-h87a4715_0.conda": { + "build": "h87a4715_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0f2fffb304f3bfee600e12191e11e7c7", + "name": "magma", + "sha256": "1afd98978db5a5861aa34df2329aba65cd522fccf4fbcf993fc0b7a8f4892f62", + "size": 35544640, + "subdir": "linux-64", + "timestamp": 1525909788890, + "version": "2.3.0" + }, + "magma-2.4.0-h8005fc1_0.conda": { + "build": "h8005fc1_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d1a47d80f4c26b9bb36e6daa88c64bf9", + "name": "magma", + "sha256": "18310cf16fcb9de56f8be0f59e5bb82a993491cced0d57c1dc6e50acd5898d6a", + "size": 42692977, + "subdir": "linux-64", + "timestamp": 1550847054324, + "version": "2.4.0" + }, + "magma-2.5.0-h6edc907_0.conda": { + "build": "h6edc907_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8d41aca8a4d4ae7b26a185ccbfe65e35", + "name": "magma", + "sha256": "92b2d40597cd2633cb3bc37583312af9960d20d512457b4fc319e136ec9a91bb", + "size": 47615784, + "subdir": "linux-64", + "timestamp": 1550780629067, + "version": "2.5.0" + }, + "magma-2.5.0-h72d0ac2_0.conda": { + "build": "h72d0ac2_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.1.243,<10.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "de8f247020bbd18bbbe04900a32121ec", + "name": "magma", + "sha256": "1f18f04ee8a68958727211ca567ebdfd311f4736f369a3ae55c2d38db531d875", + "size": 42495849, + "subdir": "linux-64", + "timestamp": 1584542237441, + "version": "2.5.0" + }, + "magma-2.5.0-h72fc40a_0.conda": { + "build": "h72fc40a_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f0ddbb123d47fe937008f05331aebe1b", + "name": "magma", + "sha256": "d1255b0d427eb197804ac78b65162156efb59c7394bd80f4e87fa9fb1e2ee0df", + "size": 45111126, + "subdir": "linux-64", + "timestamp": 1550793558277, + "version": "2.5.0" + }, + "magma-2.7.0-h8db6258_0.conda": { + "build": "h8db6258_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=11.3.1,<11.4.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a6ed6bfd47098170e0798c9783952278", + "name": "magma", + "sha256": "98dd3da647692db0739c3effe0353e59c683e7277992f1179246ef8c2becc84e", + "size": 101464847, + "subdir": "linux-64", + "timestamp": 1671636138247, + "version": "2.7.0" + }, + "make-4.2.1-h1bed415_1.conda": { + "build": "h1bed415_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPLv3", + "md5": "11e034d2d79bfed958791f1fdeb4adcf", + "name": "make", + "sha256": "366c7133c9b595f5862ef22b0af952e74550e8eeded4b18ea5eb35f8c2ba01a1", + "size": 425182, + "subdir": "linux-64", + "timestamp": 1522868610272, + "version": "4.2.1" + }, + "make-4.2.1-h3d8f0fa_0.conda": { + "build": "h3d8f0fa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPLv3", + "md5": "3af4bab89ec1558f77728c0e5d6360fc", + "name": "make", + "sha256": "d435ab6b633e092dc8418fb6e2390379837e6bb798f7c8b731b5855b1b66d29d", + "size": 423375, + "subdir": "linux-64", + "timestamp": 1507907563144, + "version": "4.2.1" + }, + "mako-1.0.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e59760ab75854e7d771cc95947afb3a4", + "name": "mako", + "sha256": "adaf0122125a1f9988746658b14d68ab04cbe3fb3c760a3282ba3f8b1b7f7fc3", + "size": 122444, + "subdir": "linux-64", + "timestamp": 1530737030980, + "version": "1.0.7" + }, + "mako-1.0.7-py27h3d58d4b_0.conda": { + "build": "py27h3d58d4b_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9140c533c0414d5a2ba6a12ea56fa609", + "name": "mako", + "sha256": "9bfe851012cc5ecf0a0748162a4db41bca007c034f1899b42be317a12af21c49", + "size": 120379, + "subdir": "linux-64", + "timestamp": 1505691393022, + "version": "1.0.7" + }, + "mako-1.0.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "ea68119a0bbd9e5544a611ee4eab75a7", + "name": "mako", + "sha256": "18c23d930fe6247c6c7593cb1c5db0e9abc6531fdd195818f2b23d15b971ccc8", + "size": 124729, + "subdir": "linux-64", + "timestamp": 1534352616211, + "version": "1.0.7" + }, + "mako-1.0.7-py35h69899ea_0.conda": { + "build": "py35h69899ea_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "72f64d7fbe945154f067424f3400befc", + "name": "mako", + "sha256": "4de3426fd9ced2b6ff3461ebbdaf38ad12ec1fd61eb1b85df297087f6e078325", + "size": 124518, + "subdir": "linux-64", + "timestamp": 1505691405805, + "version": "1.0.7" + }, + "mako-1.0.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "536c94a1eb575266d13a4b801ad32575", + "name": "mako", + "sha256": "ad697487ae08d90cad7e07daaefd2d217a2a7ceda1b52a2f959eaa9c615d399b", + "size": 121768, + "subdir": "linux-64", + "timestamp": 1530737008939, + "version": "1.0.7" + }, + "mako-1.0.7-py36h0727276_0.conda": { + "build": "py36h0727276_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "be3d68ac431d2a7e8d2f918bd5dd0e49", + "name": "mako", + "sha256": "c31cef6753b9161235bcac661a53166eb33f4f9cccf6ae6e12cf8ad9698215cc", + "size": 121574, + "subdir": "linux-64", + "timestamp": 1505691418723, + "version": "1.0.7" + }, + "mako-1.0.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3ff52011b679e68a36b8a727bdceed72", + "name": "mako", + "sha256": "fcbfa54f26f1af2c39e654d7d50ebc6ce91c35255f684941ed4792c9f1e663b0", + "size": 123544, + "subdir": "linux-64", + "timestamp": 1530737053909, + "version": "1.0.7" + }, + "mako-1.0.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "a19a9d8bf33d0472048a996677afea26", + "name": "mako", + "sha256": "90de562ccae7e0ef9e6efab2c5821e75e8960a0d368f69181b7781310621d652", + "size": 125502, + "subdir": "linux-64", + "timestamp": 1556068119593, + "version": "1.0.9" + }, + "mako-1.0.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "dbad9622192b11e5cfe6d41324c7f145", + "name": "mako", + "sha256": "bf48de024943ac9901a229c059fe3f2b3556ce352ee91eccfcd11a6aba2329a4", + "size": 125260, + "subdir": "linux-64", + "timestamp": 1556068271361, + "version": "1.0.9" + }, + "mako-1.0.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "49c9821c0e95f2cd049ea30e046bee36", + "name": "mako", + "sha256": "7a52decb332ba8819263ea61d6bae3444e636e9d01b822ad117c24f09ca28847", + "size": 126629, + "subdir": "linux-64", + "timestamp": 1556068117800, + "version": "1.0.9" + }, + "mako-1.2.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b3318eb7eb7618c4bb6286091d69cf9", + "name": "mako", + "sha256": "1127afa4ca6b1b00dff7b8689249c27bb3f69455a99d4b7bdf9690b77d9c3658", + "size": 129246, + "subdir": "linux-64", + "timestamp": 1665472499825, + "version": "1.2.3" + }, + "mako-1.2.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c02833a714fcc8dc9239e575473c97fc", + "name": "mako", + "sha256": "b7ba0b0a0a1d957a3bd744de7ee487c6026ae9ced9667f970ebdbf495ae29c31", + "size": 175363, + "subdir": "linux-64", + "timestamp": 1676827963723, + "version": "1.2.3" + }, + "mako-1.2.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "markupsafe >=0.9.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "525dbcd644eda6623219ef17bf5f893d", + "name": "mako", + "sha256": "ecc8bc51d7d3de3735c6c6b11ca4e865d3b83a5b09b49ea225893df259efa92a", + "size": 126946, + "subdir": "linux-64", + "timestamp": 1665472449780, + "version": "1.2.3" + }, + "mako-1.2.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "939884a7ac458192d95422d6b9581adf", + "name": "mako", + "sha256": "004b712d742997c6ab7341c29de014565541f06c9d8dda4c7cf1b9f5dccb864b", + "size": 127751, + "subdir": "linux-64", + "timestamp": 1665472474847, + "version": "1.2.3" + }, + "mako-1.2.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=0.9.2", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ef9ddb7afd6c84641a5da126fad96e6", + "name": "mako", + "sha256": "c8c270e0c0fb60678aa69adbc819bdbd6ed33b70c6c794c0d628c7c359a691a4", + "size": 127724, + "subdir": "linux-64", + "timestamp": 1665472524097, + "version": "1.2.3" + }, + "mapclassify-2.5.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "networkx", + "numpy >=1.3", + "pandas >=1.0", + "python >=3.10,<3.11.0a0", + "scikit-learn", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bd09a4e8e0c65842d5460c8e5659f42a", + "name": "mapclassify", + "sha256": "4ea10f094d58f5a470857929994f2ff2e140fd0b2a44b8c4186c45083614f968", + "size": 68499, + "subdir": "linux-64", + "timestamp": 1675157763842, + "version": "2.5.0" + }, + "mapclassify-2.5.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "networkx", + "numpy >=1.3", + "pandas >=1.0", + "python >=3.11,<3.12.0a0", + "scikit-learn", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "193f4ee5bb7001a4233d86ad5e46f993", + "name": "mapclassify", + "sha256": "a20898ebdb2d6c57011128c569cc1514188e75eec5e9678517dc03b106e9dbbd", + "size": 82102, + "subdir": "linux-64", + "timestamp": 1676858588658, + "version": "2.5.0" + }, + "mapclassify-2.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "networkx", + "numpy >=1.3", + "pandas >=1.0", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b2ce0804bc1470358197c43670ceb300", + "name": "mapclassify", + "sha256": "21727689ab008fdf53911e123ebfe3e82eb6b806dc1d0abd60c8f1b76ff4e704", + "size": 68742, + "subdir": "linux-64", + "timestamp": 1675157805003, + "version": "2.5.0" + }, + "mapclassify-2.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "networkx", + "numpy >=1.3", + "pandas >=1.0", + "python >=3.9,<3.10.0a0", + "scikit-learn", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "754abbcf29f3beb526833a5b07061efb", + "name": "mapclassify", + "sha256": "eed7c7d980b8e6515f98d9a4474b90120fa6a0ec56ebfb6d7eec2c0dab85fe7f", + "size": 68075, + "subdir": "linux-64", + "timestamp": 1675157845451, + "version": "2.5.0" + }, + "markdown-2.6.11-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e669e257d972b879d890c1c17af2f8a", + "name": "markdown", + "sha256": "d5a1ccfc5410e8647603d4b357e904fcac4f2a10a29ee028ffba0be6926d5d76", + "size": 109456, + "subdir": "linux-64", + "timestamp": 1519752448484, + "version": "2.6.11" + }, + "markdown-2.6.11-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "02dd5a0294cbf6399c13204c999e2446", + "name": "markdown", + "sha256": "94ee6c7688d75ed55239f80d21ee202031554045dc1423449bcf786051823fde", + "size": 110844, + "subdir": "linux-64", + "timestamp": 1519752475271, + "version": "2.6.11" + }, + "markdown-2.6.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1b231f7d932ec64d2c0153982d08f5ec", + "name": "markdown", + "sha256": "8ffc0795dac3649aae75f9a5c0f3e8b2390ac95bcff06a95ee9a4826103850dd", + "size": 111651, + "subdir": "linux-64", + "timestamp": 1519752435153, + "version": "2.6.11" + }, + "markdown-2.6.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6e544260a6457b49d1a7a5db788fce54", + "name": "markdown", + "sha256": "c6bc015c87f5030c8ca4e58841d92532133d8a9e764eaf8ce42ff7f8e7d2df6a", + "size": 109582, + "subdir": "linux-64", + "timestamp": 1530899102878, + "version": "2.6.11" + }, + "markdown-3.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6458aa7a8b018d60fec481730e2e7c26", + "name": "markdown", + "sha256": "854c8b5351e4f68a4572b1f4058aede4c43266f62b532978ac1bd052e6bfa3ac", + "size": 113791, + "subdir": "linux-64", + "timestamp": 1539712093409, + "version": "3.0.1" + }, + "markdown-3.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e93554141c1e35151a0e13d1006261f4", + "name": "markdown", + "sha256": "2912acff2d36dda56639407f1003c847a361eed9ca01ecf204dd157a990232ff", + "size": 114485, + "subdir": "linux-64", + "timestamp": 1539712107971, + "version": "3.0.1" + }, + "markdown-3.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4be7115d2f3879a9740736ff8794ea26", + "name": "markdown", + "sha256": "c77d4d1f324043d305ea55a9e4baea48045fb7e75ff518db543f4f03456a39a5", + "size": 112478, + "subdir": "linux-64", + "timestamp": 1539712099840, + "version": "3.0.1" + }, + "markdown-3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8fa3f65a1816636201d79a8be28240f1", + "name": "markdown", + "sha256": "eed25e14938625f130320a051afc77843ec05d9522094beb97930ca411404aca", + "size": 117997, + "subdir": "linux-64", + "timestamp": 1556068795863, + "version": "3.1" + }, + "markdown-3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "204d6d5799d0a6393ebf564f989419e8", + "name": "markdown", + "sha256": "0b3a535377042cfbc6bc95838fb8601d7e92bd1d7a867164450922a8f4ca0e0a", + "size": 119851, + "subdir": "linux-64", + "timestamp": 1556068836935, + "version": "3.1" + }, + "markdown-3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e3afdc5ebbf3c64471dc65bb5bfafbd", + "name": "markdown", + "sha256": "28d5789d6d54d68af32a87b51410af7f6611d70fbdc0feb0b78779d6cb733197", + "size": 118383, + "subdir": "linux-64", + "timestamp": 1556078766720, + "version": "3.1" + }, + "markdown-3.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ec6be2be5e7566e07b647238a579b07b", + "name": "markdown", + "sha256": "4ebf7734266ed16819794cfa2bf849c2a3286feb172ae6669cf6cc301955e2ac", + "size": 119780, + "subdir": "linux-64", + "timestamp": 1559920467671, + "version": "3.1.1" + }, + "markdown-3.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7995fb2a81d129b2b225f770cefe3e9e", + "name": "markdown", + "sha256": "9dd4f8bfe07d436ba15b8f6fe59e7b9c8ff69f1f2b7d1b0a6d7e762ef17e620f", + "size": 118653, + "subdir": "linux-64", + "timestamp": 1559920488852, + "version": "3.1.1" + }, + "markdown-3.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dd57fe9efd3a5b8e656c0d7316c807c9", + "name": "markdown", + "sha256": "487a6698fbe363df65a14953c17af0e68ec5d67ae5e6045f576aeb808cf86b9a", + "size": 120416, + "subdir": "linux-64", + "timestamp": 1559920465005, + "version": "3.1.1" + }, + "markdown-3.1.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e9d1096bb1bcc71ecfca886c65d833cc", + "name": "markdown", + "sha256": "34005f380567da7162e4c30fba6a862d34d4f174b59d21f569950416e1d972a2", + "size": 119112, + "subdir": "linux-64", + "timestamp": 1573489006550, + "version": "3.1.1" + }, + "markdown-3.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6ac73d23142bd3633df0c2bb7563bc7e", + "name": "markdown", + "sha256": "a29e2f06eed44efede148d23834ec8035b6c4bb944eb6087f327d733c2bd1065", + "size": 122043, + "subdir": "linux-64", + "timestamp": 1597433287012, + "version": "3.2.2" + }, + "markdown-3.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c006fe5e5ce18e3010aaf7cd487563ea", + "name": "markdown", + "sha256": "331d91bf16a84f24eb1495391efaebd34793c2cf006ac9afffd1f71177d8fee5", + "size": 120613, + "subdir": "linux-64", + "timestamp": 1597433295908, + "version": "3.2.2" + }, + "markdown-3.2.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b79afabfd7c747ede0332add12a9f369", + "name": "markdown", + "sha256": "3586480face82c0fcea8b5aaccb5d76ef57c777278beb9d687b32fd836edc865", + "size": 122663, + "subdir": "linux-64", + "timestamp": 1597433270579, + "version": "3.2.2" + }, + "markdown-3.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "42752119aa203791817d3c0520574170", + "name": "markdown", + "sha256": "7a3f6d36b475225623748d244535001946b43a9cb6cc9c0dd57e1ea396b01112", + "size": 126269, + "subdir": "linux-64", + "timestamp": 1602086994231, + "version": "3.3" + }, + "markdown-3.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b74a2bf20d5e1fc6c28ac07bc7919f74", + "name": "markdown", + "sha256": "5a1ea4a44cbbf3ef6177ab2574d8fdfd2dc6e5a6e87071c538f19e788f04da55", + "size": 126354, + "subdir": "linux-64", + "timestamp": 1602086973507, + "version": "3.3" + }, + "markdown-3.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4c29f2d92dbb4c9e85ef31917bbfb2e1", + "name": "markdown", + "sha256": "d2b999c706df6301824cbc21cc5e8099a6522ab93edfefb962046c312498d181", + "size": 126544, + "subdir": "linux-64", + "timestamp": 1602086998680, + "version": "3.3" + }, + "markdown-3.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8b214bb9a390afd9771f517e4a99435f", + "name": "markdown", + "sha256": "2a7241a13eceec89009b533f71a8d5da4d159ed8d0889d4437a8f09ffb7df47c", + "size": 127421, + "subdir": "linux-64", + "timestamp": 1602689134502, + "version": "3.3.1" + }, + "markdown-3.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38d32f461aad019613d002f293274bdc", + "name": "markdown", + "sha256": "6f7ca3b53988bc16eace16d4c08b01c017e9f33c11cc650f1b990a556e13b544", + "size": 129499, + "subdir": "linux-64", + "timestamp": 1602689131891, + "version": "3.3.1" + }, + "markdown-3.3.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "220dd4578882d2cd1b986105809f3366", + "name": "markdown", + "sha256": "d07124a9dbfa07a15d3c215bd0cadd91cb3b54c1c70df533b7a76b8ad79eb78e", + "size": 129358, + "subdir": "linux-64", + "timestamp": 1602689107690, + "version": "3.3.1" + }, + "markdown-3.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "57a872d5c48f6a02e676997762376690", + "name": "markdown", + "sha256": "cdc9c6e9dd509a1137ec3d8db7fb20afda5ac60b2a97049540ba01d57c40ed11", + "size": 128482, + "subdir": "linux-64", + "timestamp": 1603216488724, + "version": "3.3.2" + }, + "markdown-3.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "23cfee570befd46a1762d066c6055181", + "name": "markdown", + "sha256": "2a197de05b1036c2d9785d722dd1022935c11ba9907c0f08df04eec8cbfe9020", + "size": 130140, + "subdir": "linux-64", + "timestamp": 1603216520480, + "version": "3.3.2" + }, + "markdown-3.3.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1aff4a4a7a7820364d31ccfc2a19bc33", + "name": "markdown", + "sha256": "5f36c5d76972017008e3088b722533b8e06b13e17e36e85907c63d100e9239a5", + "size": 130188, + "subdir": "linux-64", + "timestamp": 1603216519132, + "version": "3.3.2" + }, + "markdown-3.3.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eece7f88b38d82aaf79c536428ef7ee3", + "name": "markdown", + "sha256": "421709bdcb4f8dfbc74cb94291cea8ad8d4b51b8c4055887afb27d3942244a3f", + "size": 130637, + "subdir": "linux-64", + "timestamp": 1605111115769, + "version": "3.3.3" + }, + "markdown-3.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "232561aee68dd2ac4f70fea202de0e40", + "name": "markdown", + "sha256": "0655569b35edb1049de44725d20dd49760232c56a4612f6b3dda4fee5a43c985", + "size": 130484, + "subdir": "linux-64", + "timestamp": 1605111091711, + "version": "3.3.3" + }, + "markdown-3.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a27315ca910c9ea53676373a7ce84550", + "name": "markdown", + "sha256": "b319dd368181e87460d4edd66766d72650c37e477eef5f4e8197ce0153edd10a", + "size": 129300, + "subdir": "linux-64", + "timestamp": 1605111086214, + "version": "3.3.3" + }, + "markdown-3.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f2d66c3ccdcbaaf7870217e34334753a", + "name": "markdown", + "sha256": "dc3ce9995d6b615f0635f0dc26d0b3df3fedefb68dd315d866de9f12e8cddf42", + "size": 129184, + "subdir": "linux-64", + "timestamp": 1605111122536, + "version": "3.3.3" + }, + "markdown-3.3.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "34edce8510e5ca06e863983d6478747c", + "name": "markdown", + "sha256": "cc6c328202588c15570dde192d34da64d8579a1dcd7439df78f768c084b9bbd4", + "size": 131289, + "subdir": "linux-64", + "timestamp": 1640791574499, + "version": "3.3.4" + }, + "markdown-3.3.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7de8adb1a37261130bce72a9004f4bc0", + "name": "markdown", + "sha256": "038bcd7dc7020cfdde4edc4f694ce7f584dbdfbb8d1085159ec6633105be8082", + "size": 130421, + "subdir": "linux-64", + "timestamp": 1614363873131, + "version": "3.3.4" + }, + "markdown-3.3.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "df51bd61fc4d041a06b62ef3db843be6", + "name": "markdown", + "sha256": "310b45ad7ef55ab8e19ed2c1b22d4ae171efa18ef3540f8a37ddcc5bea5bd7ee", + "size": 130234, + "subdir": "linux-64", + "timestamp": 1614363868576, + "version": "3.3.4" + }, + "markdown-3.3.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "79467b455f4e185199ffbe05869ef793", + "name": "markdown", + "sha256": "ca8d9f28dd9533004575903e6ca113eb73567ffe6d7b4b465dbffd11d07cbe45", + "size": 132169, + "subdir": "linux-64", + "timestamp": 1614363564728, + "version": "3.3.4" + }, + "markdown-3.3.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "80fe89ef073d07951cbc7b6c1423e709", + "name": "markdown", + "sha256": "7148af0373af06cd267c05a86262e4b74b834df207ab34f8d2b35559d7020a67", + "size": 132317, + "subdir": "linux-64", + "timestamp": 1614363930304, + "version": "3.3.4" + }, + "markdown-3.4.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2dff13e01ac630e7edc8c65365e56e15", + "name": "markdown", + "sha256": "26a8a27293df66c0d16d76818dfd3c462c7f0b40826433a86ee6e019f43af765", + "size": 135117, + "subdir": "linux-64", + "timestamp": 1671541964893, + "version": "3.4.1" + }, + "markdown-3.4.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ffa59d4d0208a2c9b3c394d100d6d930", + "name": "markdown", + "sha256": "913b52b69fd5d0ba4e8f6580542a44805c50926635bfd1815022e0a65ae6b964", + "size": 168182, + "subdir": "linux-64", + "timestamp": 1676837095436, + "version": "3.4.1" + }, + "markdown-3.4.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata >=4.4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8b82e0dc9997e4fdb6d43669037d8c3d", + "name": "markdown", + "sha256": "5a9e6e9fc8bd02d31506edf9fc55b613098d0ae83e036a197cbcbf5a400a8350", + "size": 134719, + "subdir": "linux-64", + "timestamp": 1671542016646, + "version": "3.4.1" + }, + "markdown-3.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata >=4.4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c7a0cd4ab56aaaed850d47288fa2e434", + "name": "markdown", + "sha256": "3e377c8bb84de59db851b386e5df2d61be9a7b5b506343745f8b47b52bd9b34d", + "size": 134907, + "subdir": "linux-64", + "timestamp": 1671541939225, + "version": "3.4.1" + }, + "markdown-3.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata >=4.4", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1217d899a8267030f93f0329c6d99da0", + "name": "markdown", + "sha256": "36b334b7c2240dfad6299c05839e291194afe859b7ed7cdf606988b795d42ed2", + "size": 134680, + "subdir": "linux-64", + "timestamp": 1671541990505, + "version": "3.4.1" + }, + "markdown-it-py-2.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "mdurl >=0.1,<1", + "python >=3.10,<3.11.0a0", + "typing_extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d57ea4dd182d1a53d647c0e291a18d97", + "name": "markdown-it-py", + "sha256": "5597f263d999bee2d285329eefa223b5770c38bf5359cf46607521381e98d031", + "size": 107257, + "subdir": "linux-64", + "timestamp": 1659718841133, + "version": "2.1.0" + }, + "markdown-it-py-2.1.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "mdurl >=0.1,<1", + "python >=3.11,<3.12.0a0", + "typing_extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a572def402f72e525c574dffb2334433", + "name": "markdown-it-py", + "sha256": "22b842b196800145ec930a1a3f71bc9a18e23c9a64db3a5f9c411fbbe808c77a", + "size": 138514, + "subdir": "linux-64", + "timestamp": 1676828178187, + "version": "2.1.0" + }, + "markdown-it-py-2.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "mdurl >=0.1,<1", + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01d6aa1f8441f417de19ebd7288070c7", + "name": "markdown-it-py", + "sha256": "776d87d2984b71c83748c0824b2b50be3800117a88b327fb3f618c02166c837c", + "size": 106279, + "subdir": "linux-64", + "timestamp": 1659718749957, + "version": "2.1.0" + }, + "markdown-it-py-2.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "mdurl >=0.1,<1", + "python >=3.8,<3.9.0a0", + "typing_extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98acffd519d016e556a19d390315d75e", + "name": "markdown-it-py", + "sha256": "55d518a9204d5da7effe7ae22fa7aca1361e6402d657b111fdb041175e4f4dd5", + "size": 106496, + "subdir": "linux-64", + "timestamp": 1659718774463, + "version": "2.1.0" + }, + "markdown-it-py-2.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "mdurl >=0.1,<1", + "python >=3.9,<3.10.0a0", + "typing_extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea89ed2caa5bc8d9a8fcc90ef5b36033", + "name": "markdown-it-py", + "sha256": "ece477467c85393414681263f9420337c9c35326f6767954e7204d6175100d4d", + "size": 106278, + "subdir": "linux-64", + "timestamp": 1659718803309, + "version": "2.1.0" + }, + "markdown2-2.3.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e7e68cf97054496e3cc4d2ee01517c5", + "name": "markdown2", + "sha256": "e7d6ed0628d1cc9b3ab02acd74f6a32307cb1f76aa1b2ba07b6e2d47465e8ddc", + "size": 53175, + "subdir": "linux-64", + "timestamp": 1522811434710, + "version": "2.3.5" + }, + "markdown2-2.3.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "579fc39292f577f0bc250db32f865a9d", + "name": "markdown2", + "sha256": "c67d76f84151969092e9c0f7c2af4d012d3ceb6111734d6ccda626d49183c914", + "size": 53739, + "subdir": "linux-64", + "timestamp": 1522811438604, + "version": "2.3.5" + }, + "markdown2-2.3.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5d40315f11d6be9f12bd7a79c6064dd", + "name": "markdown2", + "sha256": "75ad8fbebc60ee4c1575abbf4ae14bd30b616d91ec8345f0b64af1f36c181b5a", + "size": 54076, + "subdir": "linux-64", + "timestamp": 1522811455414, + "version": "2.3.5" + }, + "markdown2-2.3.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f3bc512a2f6c744eb3b3cc09e71bb2e", + "name": "markdown2", + "sha256": "9820c83d8e08f55827b18eedef38b02a1439dce4fd5c3d3987221540951d4709", + "size": 53997, + "subdir": "linux-64", + "timestamp": 1530899131612, + "version": "2.3.5" + }, + "markdown2-2.3.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80b9cd3f38ac3fa0c152ed816b8c5d7f", + "name": "markdown2", + "sha256": "e801fc884e92e1f3b00f382bcea6caa52f9724534ec40e404d7d01ae4f233bfb", + "size": 54563, + "subdir": "linux-64", + "timestamp": 1539645857482, + "version": "2.3.6" + }, + "markdown2-2.3.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5676f28e11711891cc762d478763e7d8", + "name": "markdown2", + "sha256": "5be343eec4806f1bbfa747590030254d307912dc2569c4c6a91f633be8275e59", + "size": 54734, + "subdir": "linux-64", + "timestamp": 1539645876776, + "version": "2.3.6" + }, + "markdown2-2.3.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc43701d883ea0b919a4bcc948c30477", + "name": "markdown2", + "sha256": "63d410da9ddd6d5aceeca81450631856c3032eac060167eef0b4df87ac38cb62", + "size": 54731, + "subdir": "linux-64", + "timestamp": 1539645879510, + "version": "2.3.6" + }, + "markdown2-2.3.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1984f09930aa1eacc9763cc9bc7c01cb", + "name": "markdown2", + "sha256": "7d213cf5cbe4509b71c5a8485a299a02aba16e38ebc6699544e603b0b8591dae", + "size": 56315, + "subdir": "linux-64", + "timestamp": 1548003484139, + "version": "2.3.7" + }, + "markdown2-2.3.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8888b3d7ca5b19c5710462b21fc9d09", + "name": "markdown2", + "sha256": "20c01856b62cb796dd44f18149944a789f38ba53126db7c48e5a923c50ee5ab1", + "size": 36433, + "subdir": "linux-64", + "timestamp": 1548003517914, + "version": "2.3.7" + }, + "markdown2-2.3.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ee2b2e615aa2cf09aa7848b6ee2d0cc", + "name": "markdown2", + "sha256": "fdd419da4ee0ff310f40d3f5c056bdd3d97405267fc311555abc33b2ef503993", + "size": 36464, + "subdir": "linux-64", + "timestamp": 1548003508434, + "version": "2.3.7" + }, + "markupsafe-1.0-py27h14c3975_1.conda": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "74718a66ccd7c2cd67a72dfa9f7bd73f", + "name": "markupsafe", + "sha256": "7821baed0b19237b02e6ec78d0e04ab88957eda11692a63f0036b6b95bf77d58", + "size": 25102, + "subdir": "linux-64", + "timestamp": 1530695395993, + "version": "1.0" + }, + "markupsafe-1.0-py27h97b2822_1.conda": { + "build": "py27h97b2822_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "770bfd89b19e0170624277ad9410b746", + "name": "markupsafe", + "sha256": "152b9db6ca2632825b246e91c8c77ed04649543d4417c22f8ab930c346a68500", + "size": 24669, + "subdir": "linux-64", + "timestamp": 1505672337096, + "version": "1.0" + }, + "markupsafe-1.0-py35h14c3975_1.conda": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "95dfd65612cd5a792d639b38315964a7", + "name": "markupsafe", + "sha256": "23b6c3f04ef1a9d785135276ab241aa74691f7e5598a4a0e9e0e429364ad327e", + "size": 25540, + "subdir": "linux-64", + "timestamp": 1534345501077, + "version": "1.0" + }, + "markupsafe-1.0-py35h4f4fcf6_1.conda": { + "build": "py35h4f4fcf6_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8c7da6c1b6bd3aafb6e51e7548a546d0", + "name": "markupsafe", + "sha256": "b4c9253023b1636230a5e1722fa9a33ada1c41c6cb9fd60d8ba16a7a905291a5", + "size": 25227, + "subdir": "linux-64", + "timestamp": 1505672351754, + "version": "1.0" + }, + "markupsafe-1.0-py36h14c3975_1.conda": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4a9171c7e0d6f4c9a91b07cac160345a", + "name": "markupsafe", + "sha256": "b073d2542a2369b9bc387a8bd422c32e82ddc42c35c9e4195c5a315c83baab03", + "size": 24736, + "subdir": "linux-64", + "timestamp": 1530695355187, + "version": "1.0" + }, + "markupsafe-1.0-py36hd9260cd_1.conda": { + "build": "py36hd9260cd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e849404d16476a772a9f27bd993358d6", + "name": "markupsafe", + "sha256": "feef47c1b123fa7263ce203f995330734b842f650bcb98f81e5edd986cfb688a", + "size": 24479, + "subdir": "linux-64", + "timestamp": 1505672366435, + "version": "1.0" + }, + "markupsafe-1.0-py37h14c3975_1.conda": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "faff805955fd61c51283b682cb213489", + "name": "markupsafe", + "sha256": "6020c5d17a2b7e9dc901838b0bf73dade40d9135f6aaebe890f3cefdb686c279", + "size": 24810, + "subdir": "linux-64", + "timestamp": 1530695375646, + "version": "1.0" + }, + "markupsafe-1.1.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cb6ff03816f1eb450b9f6494e2bf9c0a", + "name": "markupsafe", + "sha256": "fa5680ec47f076e9d54d565a4a44ec95a39ca768a7a75da6dd6f2b47c2d0733e", + "size": 26174, + "subdir": "linux-64", + "timestamp": 1542378546594, + "version": "1.1.0" + }, + "markupsafe-1.1.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "95a6248e0900b63273e22ada3a54372b", + "name": "markupsafe", + "sha256": "5bc0b02d4078dddae9eb83e7e25f4b3f8c31a41b65e7a1c752bb5a0617a44dc2", + "size": 26354, + "subdir": "linux-64", + "timestamp": 1542378580214, + "version": "1.1.0" + }, + "markupsafe-1.1.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "30886136f65f14caa42a2be3f226cde3", + "name": "markupsafe", + "sha256": "dcbca6c6bfd810102cf2ef5330667d1cd6be50815ccad20f5d7c0b2f3b3c3190", + "size": 26378, + "subdir": "linux-64", + "timestamp": 1542378536641, + "version": "1.1.0" + }, + "markupsafe-1.1.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b267e2cfa241f909df98fd85ad6627c9", + "name": "markupsafe", + "sha256": "078e814d96548d09218f38a5c78e8d192a38de6c819c34486543167e5a340970", + "size": 29434, + "subdir": "linux-64", + "timestamp": 1551141837511, + "version": "1.1.1" + }, + "markupsafe-1.1.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "809170a230a05d27a3530d342b434ec0", + "name": "markupsafe", + "sha256": "e399970eaf8c015258bf249696e150fe974e3a1e0efdde145fcd9889053d2747", + "size": 29732, + "subdir": "linux-64", + "timestamp": 1551141859307, + "version": "1.1.1" + }, + "markupsafe-1.1.1-py37h14c3975_1.conda": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7742ab22652ae403e21b8d940c1d335d", + "name": "markupsafe", + "sha256": "8c12e3b5fe91888d75c7a492df0b63b430645342093c88a330be0dc0eb5c4761", + "size": 26195, + "subdir": "linux-64", + "timestamp": 1594371535331, + "version": "1.1.1" + }, + "markupsafe-1.1.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0f2fd030c3be2a99ea6037138aa86990", + "name": "markupsafe", + "sha256": "d647ef0260b068b6ef82d666785607df73a2e78f6b0e44b5e36243ae96f33fa5", + "size": 29697, + "subdir": "linux-64", + "timestamp": 1551141822150, + "version": "1.1.1" + }, + "markupsafe-1.1.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3c00b559514e80ca92a4648f5045f29d", + "name": "markupsafe", + "sha256": "cea6b51aaca8f1e16396b26d0e0da35e0d84acf6591a9deddfdd40dbc4919b33", + "size": 33560, + "subdir": "linux-64", + "timestamp": 1573489028734, + "version": "1.1.1" + }, + "markupsafe-1.1.1-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f6f8dcf43545474ae00c852ae24f2f6e", + "name": "markupsafe", + "sha256": "b9461023a1234e2e99ac5f52fd8c02a735b86c816082719a56790ed85c73e142", + "size": 29423, + "subdir": "linux-64", + "timestamp": 1607027347436, + "version": "1.1.1" + }, + "markupsafe-2.0.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dc521c5d8686ca5e000c75cac7f905d6", + "name": "markupsafe", + "sha256": "02248efee8e44652efc1d60bf54cbebcfc7eced0b77343924cd36081f6d6dd9a", + "size": 24005, + "subdir": "linux-64", + "timestamp": 1620984896292, + "version": "2.0.0" + }, + "markupsafe-2.0.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dfb0481c46e33d927f86de7d9ae33017", + "name": "markupsafe", + "sha256": "f116d835bfb4be897a024aae079678079f88c24a23129ca563af1b832ce6965c", + "size": 23959, + "subdir": "linux-64", + "timestamp": 1620985118273, + "version": "2.0.0" + }, + "markupsafe-2.0.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a9ab8f5d4669e51d0a91554d672d0388", + "name": "markupsafe", + "sha256": "5bc1fbc8ad9c8538afbc364059dad36755333f419a421721aac2378059dc5b5b", + "size": 24022, + "subdir": "linux-64", + "timestamp": 1620985119631, + "version": "2.0.0" + }, + "markupsafe-2.0.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0797dd0396683df129d6c21219f02c41", + "name": "markupsafe", + "sha256": "ef57ea36ff285de7eb686be00e7b2829eccaab75117e5d172f3103b8cd70d645", + "size": 24054, + "subdir": "linux-64", + "timestamp": 1620985124304, + "version": "2.0.0" + }, + "markupsafe-2.0.1-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e763090241ff8bbb5aa1f4e60f027ff5", + "name": "markupsafe", + "sha256": "b9e1a3856faf77b6d3c89c9e26522c285baf9911989e967aff1cd21f67adfb62", + "size": 35335, + "subdir": "linux-64", + "timestamp": 1640791598404, + "version": "2.0.1" + }, + "markupsafe-2.0.1-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7654cee9bc3e582947e24ccd00b77f8c", + "name": "markupsafe", + "sha256": "94e7fdf704173e0e06497eeabb9dbcfc58811929e8f28de588e21b8547a493cd", + "size": 21908, + "subdir": "linux-64", + "timestamp": 1621528209086, + "version": "2.0.1" + }, + "markupsafe-2.0.1-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4c591d72e0c043d6bf0bac1e9184e796", + "name": "markupsafe", + "sha256": "e0d8343455da60eab2983a620a12f9689e49db79d82b8f678365ab0c1dfec5f3", + "size": 22006, + "subdir": "linux-64", + "timestamp": 1621528184683, + "version": "2.0.1" + }, + "markupsafe-2.0.1-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50dcb2135a5ded2e9f60a74bf5093e58", + "name": "markupsafe", + "sha256": "80c0b3f965568e071d3dbf7ca454da285fcd58702bd56deb05359890e10d03f0", + "size": 22039, + "subdir": "linux-64", + "timestamp": 1621528207169, + "version": "2.0.1" + }, + "markupsafe-2.0.1-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d55ebcb37453be6d5bddafb4509eab3", + "name": "markupsafe", + "sha256": "d19d019174d4470307ada32611d68f6054cce3c18158f03235e4c11efdece36a", + "size": 22096, + "subdir": "linux-64", + "timestamp": 1621523521377, + "version": "2.0.1" + }, + "markupsafe-2.1.1-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "constrains": [ + "jinja2 >=3.0.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "01b266ef21f9c040fef79461e4d0bd41", + "name": "markupsafe", + "sha256": "5b40bb8a880629c15057c34f750b75a3585f4c4aedd3dda6ca168331ca4fba18", + "size": 35189, + "subdir": "linux-64", + "timestamp": 1654598030197, + "version": "2.1.1" + }, + "markupsafe-2.1.1-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "constrains": [ + "jinja2 >=3.0.0" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5d815163b43fe73c9e224453d470f5cf", + "name": "markupsafe", + "sha256": "32e788cf1b8da585f7c76c753d3cfe04e42dd785b78fc9bfea508c7474be14a1", + "size": 25252, + "subdir": "linux-64", + "timestamp": 1676823521145, + "version": "2.1.1" + }, + "markupsafe-2.1.1-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "constrains": [ + "jinja2 >=3.0.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5785bf25230132d5de68de496d74e6c4", + "name": "markupsafe", + "sha256": "aab312feed3551273e113ff29a5f53979d67d135c8f91a7df1948ebcd00e8775", + "size": 21839, + "subdir": "linux-64", + "timestamp": 1654598126425, + "version": "2.1.1" + }, + "markupsafe-2.1.1-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "constrains": [ + "jinja2 >=3.0.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "51f06833956c53b2a7b7d02efeff7cd8", + "name": "markupsafe", + "sha256": "1ce241a4bde38cf8f74b27dc0ca0a7b21d3c7cd6406f982579061074a31bf0c5", + "size": 21916, + "subdir": "linux-64", + "timestamp": 1654598251803, + "version": "2.1.1" + }, + "markupsafe-2.1.1-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "constrains": [ + "jinja2 >=3.0.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "81867b86384d8b25db1141c360803b5f", + "name": "markupsafe", + "sha256": "8b51593adbc59f9faf61ac7ab0798f4416bbff0c758011db64dbd90b367a8bcf", + "size": 21903, + "subdir": "linux-64", + "timestamp": 1654597913064, + "version": "2.1.1" + }, + "marshmallow-2.15.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "4f07ca74a69abf75e900f198aa7e89b0", + "name": "marshmallow", + "sha256": "0cd0013fa95d84373f0b904eca5ba971a8cbf6afa3691b42099f2d76f23652d5", + "size": 72093, + "subdir": "linux-64", + "timestamp": 1543147994637, + "version": "2.15.0" + }, + "marshmallow-2.15.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "5b490fa5f959c53d512a19925feb606f", + "name": "marshmallow", + "sha256": "3930a284124d7361bb8d9f99191a2271904e3e0a8d50e190250b7ea6d9ce771f", + "size": 72885, + "subdir": "linux-64", + "timestamp": 1543147507402, + "version": "2.15.0" + }, + "marshmallow-2.15.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5862949be262c32977afc0f9e5fe146e", + "name": "marshmallow", + "sha256": "58c0bc659f22e987e1c3413d74758e5eee9f2966723f1cf36d6b41fefa0974bb", + "size": 72992, + "subdir": "linux-64", + "timestamp": 1543147417516, + "version": "2.15.0" + }, + "marshmallow-2.17.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9211742349f3c64e1b159c1b8fdb26f5", + "name": "marshmallow", + "sha256": "3f2b0152d2262c04d20cf89cd23d0e747ab74e4de22cfad55864ea5f5d6c300c", + "size": 79743, + "subdir": "linux-64", + "timestamp": 1547237250481, + "version": "2.17.0" + }, + "marshmallow-2.17.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "91cecb351b2fd49f7eb755ebf9300f21", + "name": "marshmallow", + "sha256": "15a0a48d4c03ff171c5061b512b0f2197fc08e70d9c5f89b5db70546f8719e5a", + "size": 79172, + "subdir": "linux-64", + "timestamp": 1547237336372, + "version": "2.17.0" + }, + "marshmallow-2.17.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e2cec400f852af5472e3751275c68ab3", + "name": "marshmallow", + "sha256": "96ee8b5313554eba8b97c6ee3d7e57664a6f8427d671ee5b19ac90f69afd1491", + "size": 79567, + "subdir": "linux-64", + "timestamp": 1547237332227, + "version": "2.17.0" + }, + "marshmallow-2.18.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "566bedc25e95cde8192305bfaa4468eb", + "name": "marshmallow", + "sha256": "f5d0db3069011c57385c3f6684512adfa09a592a1d9ee4026b3e2cd8e102fec5", + "size": 78655, + "subdir": "linux-64", + "timestamp": 1547759903355, + "version": "2.18.0" + }, + "marshmallow-2.18.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "dfd33e47f5e95010b8f440e9ffa0244b", + "name": "marshmallow", + "sha256": "e78905d54a48817a1ae9140a62e849daa262142f733adc2d15c851d6dedfbc5b", + "size": 79645, + "subdir": "linux-64", + "timestamp": 1547759935282, + "version": "2.18.0" + }, + "marshmallow-2.18.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4ae7fa3685ebfa95c87b3a0e9ba5811b", + "name": "marshmallow", + "sha256": "59ca96be4b15dad628176312c7e1e5e1417d24546f7ecf81a1a21fbb49f09fbe", + "size": 79773, + "subdir": "linux-64", + "timestamp": 1547759923835, + "version": "2.18.0" + }, + "marshmallow-3.0.0b8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b058a4f24db94b96653730ad08ea775e", + "name": "marshmallow", + "sha256": "5b4010a68b0855859bd0d282bfd9e7f15583545e76746ca5d70f6445fa3e5074", + "size": 67460, + "subdir": "linux-64", + "timestamp": 1536859740910, + "version": "3.0.0b8" + }, + "marshmallow-3.0.0b8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "191173a82cf6cd6a889fa32e7faa5e5d", + "name": "marshmallow", + "sha256": "0284da9bf138fa78b5aa577a1348aebad6dd631d4c0c12c64a5164475e1fb5ec", + "size": 68738, + "subdir": "linux-64", + "timestamp": 1536858986561, + "version": "3.0.0b8" + }, + "marshmallow-3.0.0b8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a7fc38b0563528624e3c23490469ad3e", + "name": "marshmallow", + "sha256": "83dff4ba3ca2f2bccb93c33fd89a24529bc8c0da9bcc4cb83c64e506e27f9eea", + "size": 69365, + "subdir": "linux-64", + "timestamp": 1536858987232, + "version": "3.0.0b8" + }, + "marshmallow-3.0.0b8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "94d8ef07283cf260950e1cd52e7a7df6", + "name": "marshmallow", + "sha256": "75ad1b47a50798b3e7e6be20e638dfaeba372a8985aa9905edd9076d39978d70", + "size": 69454, + "subdir": "linux-64", + "timestamp": 1536859751494, + "version": "3.0.0b8" + }, + "marshmallow-enum-1.5.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=2.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a56610b1d0212649384b911963621a3", + "name": "marshmallow-enum", + "sha256": "c9ed3f85461f6ef14e012ae9c36237f305b11ec132a285f00af92e38ad0fe48d", + "size": 11829, + "subdir": "linux-64", + "timestamp": 1642510546320, + "version": "1.5.1" + }, + "marshmallow-enum-1.5.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=2.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "471d1fd4a9f8c6acae03085d5f25575d", + "name": "marshmallow-enum", + "sha256": "9924a70871974457d8bb989e7b54eb89fe8ab99fd95efb1adc42e6cbcde51516", + "size": 13177, + "subdir": "linux-64", + "timestamp": 1676828193535, + "version": "1.5.1" + }, + "marshmallow-enum-1.5.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=2.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cce0817dba030755a463bb6eed61946a", + "name": "marshmallow-enum", + "sha256": "03cd87c9da4189c67e095cf9cfd0b966ae63280aa4f0aa3a39710eab6a24b472", + "size": 12440, + "subdir": "linux-64", + "timestamp": 1636044920652, + "version": "1.5.1" + }, + "marshmallow-enum-1.5.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=2.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f207baa7e4d87441049d0978f4db8c48", + "name": "marshmallow-enum", + "sha256": "0d15cd6b93ceccd5da63dc844fb2279c8c104c6c25706f4d2c6bd4c6184ce890", + "size": 12451, + "subdir": "linux-64", + "timestamp": 1636032904114, + "version": "1.5.1" + }, + "marshmallow-enum-1.5.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=2.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c89f20131c0e14fe9853110da4d546cf", + "name": "marshmallow-enum", + "sha256": "8a3ab7989c20061cf3401a0cc839072dd255e14394362e64b776c920089b29ce", + "size": 12484, + "subdir": "linux-64", + "timestamp": 1636032904097, + "version": "1.5.1" + }, + "marshmallow-oneofschema-3.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=3.0.0,<4.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e2f83c9c103e7180bfa4cbf694fdbac", + "name": "marshmallow-oneofschema", + "sha256": "055017d7058a77543a393833de7cb2ce1cc7a1a957a036431d5bbd2cd9d3fcc1", + "size": 11073, + "subdir": "linux-64", + "timestamp": 1659868973200, + "version": "3.0.1" + }, + "marshmallow-oneofschema-3.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=3.0.0,<4.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7a2fcac8b1d2a3ebfc02e75a0ba7e637", + "name": "marshmallow-oneofschema", + "sha256": "3292dddf959f678aa511297d8e7920b43e4c1544484d4829e14523cb85e0292e", + "size": 12924, + "subdir": "linux-64", + "timestamp": 1676837109545, + "version": "3.0.1" + }, + "marshmallow-oneofschema-3.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=3.0.0,<4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "25171cf159a0bddccc40e87cfca06a5e", + "name": "marshmallow-oneofschema", + "sha256": "819f189783a6dc1decae0883ea25c152dc2f09f2783a7914299e61684a9dcc99", + "size": 11002, + "subdir": "linux-64", + "timestamp": 1659868902952, + "version": "3.0.1" + }, + "marshmallow-oneofschema-3.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=3.0.0,<4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87ec8082817b89e46745bc12c3b885ed", + "name": "marshmallow-oneofschema", + "sha256": "0a89db47fdc478ef07b72fafbaf77bd7f4f5590b50bfc3bb0a1d8150b42073d8", + "size": 11049, + "subdir": "linux-64", + "timestamp": 1659868999324, + "version": "3.0.1" + }, + "marshmallow-oneofschema-3.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "marshmallow >=3.0.0,<4.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f266745c910133e894fbf1371aa519e4", + "name": "marshmallow-oneofschema", + "sha256": "858621eba19e7ec50ee64fe8b0a6f156d140a573ab2afca8048dd2c9427a468e", + "size": 11054, + "subdir": "linux-64", + "timestamp": 1659868933280, + "version": "3.0.1" + }, + "matplotlib-2.0.2-py27h334a7c2_1.conda": { + "build": "py27h334a7c2_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "functools32", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "subprocess32", + "tk 8.6.*", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "fab52beb006eb37298734862d260856d", + "name": "matplotlib", + "sha256": "339ad5678de8e61b72d1fdeff461efb6ca0bcfc867f0a53a2ce7e70635e5371d", + "size": 4962802, + "subdir": "linux-64", + "timestamp": 1505739391048, + "version": "2.0.2" + }, + "matplotlib-2.0.2-py35hdbc49ba_1.conda": { + "build": "py35hdbc49ba_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "0af338b561d94f2eaf0ac1deb3908a90", + "name": "matplotlib", + "sha256": "f6dfe542fe07cf050e8d54f42257719e157d21c0a1fa2b1963e3819b78284973", + "size": 4987306, + "subdir": "linux-64", + "timestamp": 1505739505786, + "version": "2.0.2" + }, + "matplotlib-2.0.2-py36h2acb4ad_1.conda": { + "build": "py36h2acb4ad_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "647b94c2b33964ee70f7da6508324678", + "name": "matplotlib", + "sha256": "3bc4cefcade124cf914afc7d1873c08823dc0b6729bf169f234e288b1194a9d9", + "size": 4965020, + "subdir": "linux-64", + "timestamp": 1505739618706, + "version": "2.0.2" + }, + "matplotlib-2.1.0-py27h09aba24_0.conda": { + "build": "py27h09aba24_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "functools32", + "icu >=58.2,<59.0a0", + "libpng >=1.6.32,<1.7.0a0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "subprocess32", + "tk 8.6.*", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "755369fc0e27ae99bae0f9ae7842e397", + "name": "matplotlib", + "sha256": "44657cc18b5b3de6423cd0350e9b6067a4a61776343dd0c5508024b9271e33db", + "size": 4964842, + "subdir": "linux-64", + "timestamp": 1507569223273, + "version": "2.1.0" + }, + "matplotlib-2.1.0-py35h2cbf27e_0.conda": { + "build": "py35h2cbf27e_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libpng >=1.6.32,<1.7.0a0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "38807618436c383822ad798218c2846a", + "name": "matplotlib", + "sha256": "9600326912b6c66f9b9dac6b61d716fe14ae1261cddc2e85bf84d63a6b423b85", + "size": 5004418, + "subdir": "linux-64", + "timestamp": 1507569240309, + "version": "2.1.0" + }, + "matplotlib-2.1.0-py36hba5de38_0.conda": { + "build": "py36hba5de38_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libpng >=1.6.32,<1.7.0a0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "78ae9fdbdb1f86da4f95483fba38fbfa", + "name": "matplotlib", + "sha256": "b070ea51b666dc2407388ab9b94fa319b1bb4d9f7515b44ab88236b196baa74e", + "size": 4980764, + "subdir": "linux-64", + "timestamp": 1507569254086, + "version": "2.1.0" + }, + "matplotlib-2.1.1-py27h0128e01_0.conda": { + "build": "py27h0128e01_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "functools32", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "subprocess32", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "853f7aab62de73c8a5be385526ae76d2", + "name": "matplotlib", + "sha256": "dd66b63aeef368d0c565b490499b1e803afd6a9af389215b1122741fb0123914", + "size": 4972891, + "subdir": "linux-64", + "timestamp": 1513104969782, + "version": "2.1.1" + }, + "matplotlib-2.1.1-py35ha26af80_0.conda": { + "build": "py35ha26af80_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "2d61ba969d42ab413513220338297e4d", + "name": "matplotlib", + "sha256": "97607f183513fbb7a2eee942543765b8218946db5fdd84e47fd3127662cffcf6", + "size": 5010513, + "subdir": "linux-64", + "timestamp": 1513105021847, + "version": "2.1.1" + }, + "matplotlib-2.1.1-py36ha26af80_0.conda": { + "build": "py36ha26af80_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "14ff757b5832a0145bee35a5cbf64eca", + "name": "matplotlib", + "sha256": "d90f739e4894580425b3a96c02412dba324f76291459feb221f9d0307f8a36ab", + "size": 4968943, + "subdir": "linux-64", + "timestamp": 1513105038559, + "version": "2.1.1" + }, + "matplotlib-2.1.2-py27h0e671d2_0.conda": { + "build": "py27h0e671d2_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "functools32", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "subprocess32", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "a3c72c35f92ade21fe4d8baaabba7932", + "name": "matplotlib", + "sha256": "c6d8f322ead0c8d01abfdbd5fa17f9bf80b76950a0521550e39aed9502f2f588", + "size": 4989323, + "subdir": "linux-64", + "timestamp": 1516655973219, + "version": "2.1.2" + }, + "matplotlib-2.1.2-py35h0e671d2_0.conda": { + "build": "py35h0e671d2_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "8bfa871e908d4837914fedde5deed8b4", + "name": "matplotlib", + "sha256": "43c01130057a78af68207d3d13fc301fdf06c02f0f82b02df6f9fa80e32d2eee", + "size": 4993736, + "subdir": "linux-64", + "timestamp": 1516653448577, + "version": "2.1.2" + }, + "matplotlib-2.1.2-py36h0e671d2_0.conda": { + "build": "py36h0e671d2_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "c3104054d674797540782a302f483f98", + "name": "matplotlib", + "sha256": "e09d63d96bedc8c9651daeb60c655f9fbf6baf89b5da98711d8fbc379afd09cb", + "size": 4967587, + "subdir": "linux-64", + "timestamp": 1516656710395, + "version": "2.1.2" + }, + "matplotlib-2.2.0-py27hbc4b006_0.conda": { + "build": "py27hbc4b006_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "functools32", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "subprocess32", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "56833537ac152a198709b6b024336d70", + "name": "matplotlib", + "sha256": "576ebbc50deca0f9e6965b29614424a1befb5084f565d020f099392da39703b0", + "size": 4980649, + "subdir": "linux-64", + "timestamp": 1520362827240, + "version": "2.2.0" + }, + "matplotlib-2.2.0-py35hbc4b006_0.conda": { + "build": "py35hbc4b006_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "e2d3f1af4822308d733f2e6e03511f56", + "name": "matplotlib", + "sha256": "a33caf27c4a9cf06d634d82401dee9eaae267a46c0d284e48fed944d1b96167f", + "size": 5016848, + "subdir": "linux-64", + "timestamp": 1520362907424, + "version": "2.2.0" + }, + "matplotlib-2.2.0-py36hbc4b006_0.conda": { + "build": "py36hbc4b006_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "aab0925effea653cff6fcfd3cfd0361e", + "name": "matplotlib", + "sha256": "460ad58b9f0065b48314ec5a2cd64bb720802921e556797f5b7425184d64b987", + "size": 4976061, + "subdir": "linux-64", + "timestamp": 1520362408511, + "version": "2.2.0" + }, + "matplotlib-2.2.2-py27h0e671d2_0.conda": { + "build": "py27h0e671d2_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "functools32", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "subprocess32", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "6fd9429d84edff31fc7714dc8e3795c1", + "name": "matplotlib", + "sha256": "afd803efb40860d75b89b96b2cfc2f9ab89c8f2569426df6cc95bb27dee10fa9", + "size": 4979198, + "subdir": "linux-64", + "timestamp": 1521486493845, + "version": "2.2.2" + }, + "matplotlib-2.2.2-py27h0e671d2_1.conda": { + "build": "py27h0e671d2_1", + "build_number": 1, + "depends": [ + "backports.functools_lru_cache", + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "functools32", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.*", + "pyqt >=5.9.2,<5.10.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "subprocess32", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "00bef5f96bb619af79fedaa4e74402b3", + "name": "matplotlib", + "sha256": "fb965dd57d7f4ef1ea92484908d6691fce00b340846a8c9e3b84ed9f86e27612", + "size": 4995523, + "subdir": "linux-64", + "timestamp": 1523048828677, + "version": "2.2.2" + }, + "matplotlib-2.2.2-py27hb69df0a_2.conda": { + "build": "py27hb69df0a_2", + "build_number": 2, + "depends": [ + "backports.functools_lru_cache", + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "functools32", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt >=5.6,<6.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "subprocess32", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "9ce2819ce92c2f5d3212693a665169af", + "name": "matplotlib", + "sha256": "c8a776d0c88bf01c2564dee578ce51455169b9335abc451335ddde52801cd437", + "size": 4995524, + "subdir": "linux-64", + "timestamp": 1531343362880, + "version": "2.2.2" + }, + "matplotlib-2.2.2-py35h0e671d2_0.conda": { + "build": "py35h0e671d2_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "a26e8084c5a74248162633120d1b81b6", + "name": "matplotlib", + "sha256": "76192ddc793525c8e0eea103c32a6f0236205bac6e4cd0fd73eb393dbaa65696", + "size": 5013037, + "subdir": "linux-64", + "timestamp": 1521486502890, + "version": "2.2.2" + }, + "matplotlib-2.2.2-py35h0e671d2_1.conda": { + "build": "py35h0e671d2_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.*", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "f7224b7a2298e5df621091ccee07d0a2", + "name": "matplotlib", + "sha256": "d0d2039a69bc39d2b6ea8f1a650b7e4bfd68e059a0de7e128de8a6140f995a08", + "size": 5000650, + "subdir": "linux-64", + "timestamp": 1523048852475, + "version": "2.2.2" + }, + "matplotlib-2.2.2-py36h0e671d2_0.conda": { + "build": "py36h0e671d2_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.6.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "7a7066649ef3d19c9becac7045165e54", + "name": "matplotlib", + "sha256": "703785e9ab6a624252ceded515c49b77de2f522a6670a00f8ce2f3e0c747f02d", + "size": 4991740, + "subdir": "linux-64", + "timestamp": 1521485857857, + "version": "2.2.2" + }, + "matplotlib-2.2.2-py36h0e671d2_1.conda": { + "build": "py36h0e671d2_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "freetype >=2.8,<2.9.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.*", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "e70c0ad7aa7411ca72e73a9a8cdc6113", + "name": "matplotlib", + "sha256": "71160a2a156e4df50ca90c3c326f415f7dab6c28b3f1a0aa58f60d56c8900df2", + "size": 4992357, + "subdir": "linux-64", + "timestamp": 1523048157112, + "version": "2.2.2" + }, + "matplotlib-2.2.2-py36hb69df0a_2.conda": { + "build": "py36hb69df0a_2", + "build_number": 2, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt >=5.6,<6.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "e644d44415859ab5d2e0fa2c29882094", + "name": "matplotlib", + "sha256": "bf43152f18ee3f64d86570d3d25edebd7a23af6b218e43b4725f863f7fd00d29", + "size": 4976673, + "subdir": "linux-64", + "timestamp": 1531343093196, + "version": "2.2.2" + }, + "matplotlib-2.2.2-py37hb69df0a_2.conda": { + "build": "py37hb69df0a_2", + "build_number": 2, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "e5cdce3e36500abf980ede56c5848dde", + "name": "matplotlib", + "sha256": "f41ea6e5a9edfb0072f8bc0cf2b3084ba7defa49271877cf2dad5409bfcc3252", + "size": 4973086, + "subdir": "linux-64", + "timestamp": 1531343229422, + "version": "2.2.2" + }, + "matplotlib-2.2.3-py27hb69df0a_0.conda": { + "build": "py27hb69df0a_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "functools32", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "subprocess32", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "46e2d77151400cc780e25d17c00941b3", + "name": "matplotlib", + "sha256": "66cc5581fb34f6a5f9efbd01a6e74b0b9ba5ed9eb31a79345801d3ecb9f4fa65", + "size": 4981764, + "subdir": "linux-64", + "timestamp": 1534273730171, + "version": "2.2.3" + }, + "matplotlib-2.2.3-py35hb69df0a_0.conda": { + "build": "py35hb69df0a_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "aea8fe797f5626ab795c285deaa86c8a", + "name": "matplotlib", + "sha256": "6c1d141c7ef43c1b0cf75a149b3d2ac1fd85bf5ce677bb8286d15b9762dfdc59", + "size": 5003435, + "subdir": "linux-64", + "timestamp": 1534273740421, + "version": "2.2.3" + }, + "matplotlib-2.2.3-py36hb69df0a_0.conda": { + "build": "py36hb69df0a_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "e4b7d0a48469af42b3c951b0b380abc4", + "name": "matplotlib", + "sha256": "f28af531d917380ca93bbb383a6b74ee38594027a82c5b02b2a3209b0cd96f19", + "size": 4994765, + "subdir": "linux-64", + "timestamp": 1534273679230, + "version": "2.2.3" + }, + "matplotlib-2.2.3-py37hb69df0a_0.conda": { + "build": "py37hb69df0a_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.7,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "92caaaf14b4f7f6ceec31229b2f5af8d", + "name": "matplotlib", + "sha256": "e84be3f4ba02235c3633533e1d6031c9280b35c211666dcd350206441d00fc40", + "size": 4992031, + "subdir": "linux-64", + "timestamp": 1534273737662, + "version": "2.2.3" + }, + "matplotlib-3.0.0-py35h5429711_0.conda": { + "build": "py35h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "10f235991421c83ec9d19285111d6421", + "name": "matplotlib", + "sha256": "7d398d77e5465936aa857a9dd6945265458baeafdd0ae0f84d9a9c7ed2587029", + "size": 5203512, + "subdir": "linux-64", + "timestamp": 1538078568491, + "version": "3.0.0" + }, + "matplotlib-3.0.0-py36h5429711_0.conda": { + "build": "py36h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "e5565c8566c1da19c2cf69abd9a4f5de", + "name": "matplotlib", + "sha256": "16cef954f9506f488c8d4138f6c15861a4dfbf1fb3044e51171e0daf18651e9b", + "size": 5178491, + "subdir": "linux-64", + "timestamp": 1538078715172, + "version": "3.0.0" + }, + "matplotlib-3.0.0-py37h5429711_0.conda": { + "build": "py37h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "369695341549ef23757b8da4136b6a1d", + "name": "matplotlib", + "sha256": "9306177eb9ba4bd8616b6ecbb054056d6d3e6f94ea9fe369dac0f2f5209aa5fd", + "size": 5178727, + "subdir": "linux-64", + "timestamp": 1538078655020, + "version": "3.0.0" + }, + "matplotlib-3.0.1-py36h5429711_0.conda": { + "build": "py36h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.35,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "a201d945f40a4cb73352a003512b67a7", + "name": "matplotlib", + "sha256": "f04983ece5e7aa7a6b623d8672995d0fe82b7ee085a1d11fde2ff176d2a1f337", + "size": 5171078, + "subdir": "linux-64", + "timestamp": 1540486138455, + "version": "3.0.1" + }, + "matplotlib-3.0.1-py37h5429711_0.conda": { + "build": "py37h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.35,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "54be57770d55b24c62f028c8e61e7f99", + "name": "matplotlib", + "sha256": "46469fff2726b0d270487a5ac062627d05f218bad5d27e51b379d49e63491c3e", + "size": 5183529, + "subdir": "linux-64", + "timestamp": 1540486096610, + "version": "3.0.1" + }, + "matplotlib-3.0.2-py36h5429711_0.conda": { + "build": "py36h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.35,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "9ed5f29632849c7231468a412074d86b", + "name": "matplotlib", + "sha256": "1a93406ea228b96d0e87c5b8f0ed44490ec08d1d8abea07154a05ef6e9012b11", + "size": 5180660, + "subdir": "linux-64", + "timestamp": 1544551502806, + "version": "3.0.2" + }, + "matplotlib-3.0.2-py37h5429711_0.conda": { + "build": "py37h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.35,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "5c083218d69cc022bad8c0bacb3beec7", + "name": "matplotlib", + "sha256": "5e9c99e056643db0f91993af614f72666c5a40f8cb5f0b2f7d2284c50e93e44c", + "size": 5173935, + "subdir": "linux-64", + "timestamp": 1544551372275, + "version": "3.0.2" + }, + "matplotlib-3.0.3-py36h5429711_0.conda": { + "build": "py36h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.36,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "17977e16ce9d540d1cbbf709ecdaf9c5", + "name": "matplotlib", + "sha256": "13298c86504b61fb69ccff1b082e68e24b0794d559078d1a0ac64c2f88f4a395", + "size": 5230183, + "subdir": "linux-64", + "timestamp": 1552571627898, + "version": "3.0.3" + }, + "matplotlib-3.0.3-py37h5429711_0.conda": { + "build": "py37h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.36,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "020d1d598921c23a97aba6002eef10ad", + "name": "matplotlib", + "sha256": "51566233d26d2ebb30b88f689c006f376f843513f2a2e528c3091f76eb35a21c", + "size": 5210453, + "subdir": "linux-64", + "timestamp": 1552571690266, + "version": "3.0.3" + }, + "matplotlib-3.1.0-py36h5429711_0.conda": { + "build": "py36h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "fa35528d6534f7e5b3d9899204f4c2b3", + "name": "matplotlib", + "sha256": "5ec4f96bc2c982eab140e142cb66a78125b009989416ddecf84f986b336e7a6b", + "size": 5216071, + "subdir": "linux-64", + "timestamp": 1559228071573, + "version": "3.1.0" + }, + "matplotlib-3.1.0-py37h5429711_0.conda": { + "build": "py37h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "cba9abf8bc26b400449ca919e21b158e", + "name": "matplotlib", + "sha256": "079160b3ab43af9fd4487c0282b47e5d7f3a0d38761396d9e878c0a5a7951ce6", + "size": 5209332, + "subdir": "linux-64", + "timestamp": 1559228090832, + "version": "3.1.0" + }, + "matplotlib-3.1.1-py36h5429711_0.conda": { + "build": "py36h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "489e2e329e54b8cf44b8cd841a4a3da6", + "name": "matplotlib", + "sha256": "ea6d213aedd9917207511c4f09e4ddeff0e75a16d1244d2c4ab7c0172dc3bf6b", + "size": 5201250, + "subdir": "linux-64", + "timestamp": 1566571973772, + "version": "3.1.1" + }, + "matplotlib-3.1.1-py37h5429711_0.conda": { + "build": "py37h5429711_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pyparsing", + "pyqt 5.9.*", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytz", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "2da248cc4d3f047912716f455bc2d3d0", + "name": "matplotlib", + "sha256": "eb3abe2f9334801be98d3c369fffb324f20b47756eeb3d2915dec16a6e6348a2", + "size": 5195391, + "subdir": "linux-64", + "timestamp": 1566571974233, + "version": "3.1.1" + }, + "matplotlib-3.1.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "matplotlib-base 3.1.2 py36hef1b27d_1", + "pyqt", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "d7883251a03370c1db934137475477fc", + "name": "matplotlib", + "sha256": "877c37bc35c1a60b30e8d9b06216040b7d5d100b302136749e0e80e87a56e36b", + "size": 21494, + "subdir": "linux-64", + "timestamp": 1580491892978, + "version": "3.1.2" + }, + "matplotlib-3.1.2-py36h4fdacc2_0.conda": { + "build": "py36h4fdacc2_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "pyqt 5.9.*", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "a720767646bc67ac06befcbae1082a30", + "name": "matplotlib", + "sha256": "1a3133128750140163ff21b75013280b393cde16351677d163519180faafc6e7", + "size": 5207798, + "subdir": "linux-64", + "timestamp": 1580487071006, + "version": "3.1.2" + }, + "matplotlib-3.1.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "matplotlib-base 3.1.2 py37hef1b27d_1", + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "cdfb730a67a6fb7d333bd36be5dd116f", + "name": "matplotlib", + "sha256": "cd69e00eb7deb8e768dfa294649e281020e2e162cd7deeb4f86ab606f9bbae37", + "size": 21517, + "subdir": "linux-64", + "timestamp": 1580491843427, + "version": "3.1.2" + }, + "matplotlib-3.1.2-py37h4fdacc2_0.conda": { + "build": "py37h4fdacc2_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "pyqt 5.9.*", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "ad823c63b7e4885ed18bea6848466e11", + "name": "matplotlib", + "sha256": "18f70fe18abbcf7365e5bf62ba3c2e66b3d9f4e727f3ae1559434b79bfbde75c", + "size": 5224935, + "subdir": "linux-64", + "timestamp": 1580487072542, + "version": "3.1.2" + }, + "matplotlib-3.1.2-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "matplotlib-base 3.1.2 py38hef1b27d_1", + "pyqt", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "1781036a02c5def820ea2923074d158a", + "name": "matplotlib", + "sha256": "f4c8688d9624b3782fd9e0412065990fb163e24eaf4b2fb51e39c9bac1d77a74", + "size": 21519, + "subdir": "linux-64", + "timestamp": 1580491863393, + "version": "3.1.2" + }, + "matplotlib-3.1.2-py38h4fdacc2_0.conda": { + "build": "py38h4fdacc2_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "pyqt 5.9.*", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "setuptools", + "tk 8.6.*", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "19a073abfe30a8bc668b4cc34d79551d", + "name": "matplotlib", + "sha256": "19814b4393552bfa08513eec96f9c783eb8a679aede595dad20990ff85596c3b", + "size": 5220564, + "subdir": "linux-64", + "timestamp": 1580499227376, + "version": "3.1.2" + }, + "matplotlib-3.1.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "matplotlib-base 3.1.3 py36hef1b27d_0", + "pyqt", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "a177db69d7e97a48989e43c014b43c90", + "name": "matplotlib", + "sha256": "565b4e7782ba9c14386fe16c75bc26872f839e6c1dcebef446b25af5d889ad64", + "size": 21694, + "subdir": "linux-64", + "timestamp": 1580847934872, + "version": "3.1.3" + }, + "matplotlib-3.1.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "matplotlib-base 3.1.3 py37hef1b27d_0", + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "6f0a33e7722f9973ff307f5c01d8aeb7", + "name": "matplotlib", + "sha256": "54f7cc84466f572d309e37e9d2ecfd86d91ab1843b7401752b28965cbe17ae5e", + "size": 21637, + "subdir": "linux-64", + "timestamp": 1580847933394, + "version": "3.1.3" + }, + "matplotlib-3.1.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "matplotlib-base 3.1.3 py38hef1b27d_0", + "pyqt", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "70d5f6df438d469dc78f082389ada23d", + "name": "matplotlib", + "sha256": "ea5d2eec7a95025c33f402f78ea6d7f619b56cb840494a2ff67fe2ae0045898c", + "size": 21646, + "subdir": "linux-64", + "timestamp": 1580847931136, + "version": "3.1.3" + }, + "matplotlib-3.2.1-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.2.1,<3.2.2.0a0", + "pyqt" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "2c8b812db0972132d550c2eb2b23144b", + "name": "matplotlib", + "sha256": "c7b30db679d7d3ad7d4574ce906ccd85bfd530ce1e1257ae53b5f5a8e1e3b80e", + "size": 21545, + "subdir": "linux-64", + "timestamp": 1592406282792, + "version": "3.2.1" + }, + "matplotlib-3.2.2-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.2.2,<3.2.3.0a0", + "pyqt" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "34b86d701fe234216fc316e9d3b6eb6c", + "name": "matplotlib", + "sha256": "f9b45824a9e5f750b2e61506042e2cf3fd0292cb04eaeadd9fda8ac64c89ad15", + "size": 21671, + "subdir": "linux-64", + "timestamp": 1592846179535, + "version": "3.2.2" + }, + "matplotlib-3.3.1-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.3.1,<3.3.2.0a0", + "pyqt" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "107c74291924c268371c030b15149ca8", + "name": "matplotlib", + "sha256": "c7fa256810e47abc1f62eaa0fa0f83ffb694798e833a36649c5b2bfa445ddb8e", + "size": 25031, + "subdir": "linux-64", + "timestamp": 1597876523567, + "version": "3.3.1" + }, + "matplotlib-3.3.2-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.3.2,<3.3.3.0a0", + "pyqt" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "8183aaffaefb83324c3cc942cf675b2e", + "name": "matplotlib", + "sha256": "a5a1f21af6ec0d9b3795623a4ab200bea52dba6aa6b4fddcd04daed7139de298", + "size": 24956, + "subdir": "linux-64", + "timestamp": 1603378389600, + "version": "3.3.2" + }, + "matplotlib-3.3.2-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.3.2,<3.3.3.0a0", + "pyqt" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "fb92a25afe26985d91bb557d183c3eff", + "name": "matplotlib", + "sha256": "fd7f5c41d72425d5aaa75cf498bf4939368b4d895bd72581116fc9bd88a20658", + "size": 24937, + "subdir": "linux-64", + "timestamp": 1607974698232, + "version": "3.3.2" + }, + "matplotlib-3.3.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.3.4,<3.3.5.0a0", + "pyqt", + "python >=3.6,<3.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "3ee27c5522482c5b120ee0465fd58e2b", + "name": "matplotlib", + "sha256": "786c854b61806aa0e9e2e0266d111093399886085e3e545129e7cdd1c0d2ce30", + "size": 26875, + "subdir": "linux-64", + "timestamp": 1613408293703, + "version": "3.3.4" + }, + "matplotlib-3.3.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.3.4,<3.3.5.0a0", + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "d610f3eacce8402c5faa61809b26f099", + "name": "matplotlib", + "sha256": "449750bc69fc21619a8046d03ccb623b8d8547645f390bdd49cda86fb27d5d0a", + "size": 26858, + "subdir": "linux-64", + "timestamp": 1613408312956, + "version": "3.3.4" + }, + "matplotlib-3.3.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.3.4,<3.3.5.0a0", + "pyqt", + "python >=3.8,<3.9.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "96033fd3465abc467ae394c6852930de", + "name": "matplotlib", + "sha256": "63b60fd9a1e5f7e66cee718c6237fe6e63e2e1895f9e295db69be3bd3ab601c3", + "size": 26870, + "subdir": "linux-64", + "timestamp": 1613408300205, + "version": "3.3.4" + }, + "matplotlib-3.3.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.3.4,<3.3.5.0a0", + "pyqt", + "python >=3.9,<3.10.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "384fc5e01ebfcf30e7161119d3029b5a", + "name": "matplotlib", + "sha256": "d04be7077b32da404120eb02a9e40919acdbbeb79396683f85df579c09bfd78a", + "size": 26877, + "subdir": "linux-64", + "timestamp": 1613408306859, + "version": "3.3.4" + }, + "matplotlib-3.4.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.4.2,<3.4.3.0a0", + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "e08d37d8bcc1d76308c7ccdb6d8feade", + "name": "matplotlib", + "sha256": "a00fb8c1d157717c62471a50cf8a70196c4d2e3744b053a3b023d53a68eeb366", + "size": 26716, + "subdir": "linux-64", + "timestamp": 1628003863058, + "version": "3.4.2" + }, + "matplotlib-3.4.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.4.2,<3.4.3.0a0", + "pyqt", + "python >=3.8,<3.9.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "e3c540c043eb1bfad9fef1955edecf00", + "name": "matplotlib", + "sha256": "d2cedf53b8a5600157cd7e4f94d7c3601990de00b519ff100389e24d828bfe12", + "size": 26708, + "subdir": "linux-64", + "timestamp": 1628003851295, + "version": "3.4.2" + }, + "matplotlib-3.4.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.4.2,<3.4.3.0a0", + "pyqt", + "python >=3.9,<3.10.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "6453b839ce21a04e86f42b615f79e1d8", + "name": "matplotlib", + "sha256": "a80f520e7d67dd884138123d1bc1c48a325c81b8387960849ffac29f0557f3ce", + "size": 26746, + "subdir": "linux-64", + "timestamp": 1628003857338, + "version": "3.4.2" + }, + "matplotlib-3.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.4.3,<3.4.4.0a0", + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "a41bd54f965eba7cb97307e4d836eb3f", + "name": "matplotlib", + "sha256": "6a9d88fbb2464b83df4d053673b078638ac6916a33b555190fb85e3e146f0f07", + "size": 28980, + "subdir": "linux-64", + "timestamp": 1634667376459, + "version": "3.4.3" + }, + "matplotlib-3.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.4.3,<3.4.4.0a0", + "pyqt", + "python >=3.8,<3.9.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "5981e9ffd8d9e8366375dbae6cbe0a9d", + "name": "matplotlib", + "sha256": "f5fcddd6c1f3f680cb759694649472e7ab96e8a6b837b4f650f37fd79eb03c1d", + "size": 28981, + "subdir": "linux-64", + "timestamp": 1634667370562, + "version": "3.4.3" + }, + "matplotlib-3.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.4.3,<3.4.4.0a0", + "pyqt", + "python >=3.9,<3.10.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "35b9e57535d7f009af201b7c24844ded", + "name": "matplotlib", + "sha256": "1097480ab72c577a22f4a37281c9eebdc31e04ba20f860eaee59c5ce3fdda356", + "size": 28975, + "subdir": "linux-64", + "timestamp": 1634667382642, + "version": "3.4.3" + }, + "matplotlib-3.5.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.0,<3.5.1.0a0", + "pyqt", + "python >=3.10,<3.11.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "81f50170a89cacbc9967115a0cd47429", + "name": "matplotlib", + "sha256": "4f2c99ffa4432cffdc92169720f6b1f323969008b84818e3e25cde416eb45c65", + "size": 6881, + "subdir": "linux-64", + "timestamp": 1641903424461, + "version": "3.5.0" + }, + "matplotlib-3.5.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.0,<3.5.1.0a0", + "pyqt", + "python >=3.7,<3.8.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "de8f622d86229f0867846fd15624f10c", + "name": "matplotlib", + "sha256": "664471d2b35643e52039ed18309e013ec555ff81db668edbb28ff37c10045768", + "size": 28331, + "subdir": "linux-64", + "timestamp": 1638290037116, + "version": "3.5.0" + }, + "matplotlib-3.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.0,<3.5.1.0a0", + "pyqt", + "python >=3.8,<3.9.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "060d9360bca249e5b291428cd7c8cc2b", + "name": "matplotlib", + "sha256": "1f05b1c12c6eba11972059864894db1b13a2a6a0ad9beaffaef6d52a31858aae", + "size": 28337, + "subdir": "linux-64", + "timestamp": 1638290024788, + "version": "3.5.0" + }, + "matplotlib-3.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.0,<3.5.1.0a0", + "pyqt", + "python >=3.9,<3.10.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "84b7f90772548c8fe7e0cab7e8a1e6ad", + "name": "matplotlib", + "sha256": "c2a4a6bebff053931464ade3f968d70d926ccd6de469a5d8c45a7fa4c7bb0706", + "size": 28340, + "subdir": "linux-64", + "timestamp": 1638290031107, + "version": "3.5.0" + }, + "matplotlib-3.5.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.1,<3.5.2.0a0", + "pyqt", + "python >=3.10,<3.11.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "60ec4648adefe13620c64b594832834b", + "name": "matplotlib", + "sha256": "e2a4046a687d10c1bac27edcda164327098bbd3d9bc5468361998eb41149f712", + "size": 28998, + "subdir": "linux-64", + "timestamp": 1645456139471, + "version": "3.5.1" + }, + "matplotlib-3.5.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base >=3.5.1,<3.5.2.0a0", + "pyqt", + "python >=3.10,<3.11.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "304d15441431900d0e57f60b9ab6c39d", + "name": "matplotlib", + "sha256": "d881dc64bf714abc8f509980c2064f07e022b4bf334e59d78c4453db239e24d4", + "size": 29369, + "subdir": "linux-64", + "timestamp": 1647442123464, + "version": "3.5.1" + }, + "matplotlib-3.5.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.1,<3.5.2.0a0", + "pyqt", + "python >=3.7,<3.8.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "d89aac4322863cb5f86696b1a39372cf", + "name": "matplotlib", + "sha256": "7d059056956084c5193eac76f4182af80da1722fae6818ff43f63aee8d3e6e94", + "size": 29021, + "subdir": "linux-64", + "timestamp": 1645456132756, + "version": "3.5.1" + }, + "matplotlib-3.5.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base >=3.5.1,<3.5.2.0a0", + "pyqt", + "python >=3.7,<3.8.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "5999f5b635f99557f13f4e3f95d55f06", + "name": "matplotlib", + "sha256": "61489bacb54341e98ce907d9eae9f28aef1abc759b7798e44b893bb86d0f8d7b", + "size": 29356, + "subdir": "linux-64", + "timestamp": 1647442116913, + "version": "3.5.1" + }, + "matplotlib-3.5.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.1,<3.5.2.0a0", + "pyqt", + "python >=3.8,<3.9.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "124e5d0bf0bfa1d2bc8aba14d0dabc84", + "name": "matplotlib", + "sha256": "0353604c09fb07ba1c9378e7e46dfde98d03b319cb9b29f0bf9f483e41f4e97d", + "size": 29021, + "subdir": "linux-64", + "timestamp": 1645456126748, + "version": "3.5.1" + }, + "matplotlib-3.5.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base >=3.5.1,<3.5.2.0a0", + "pyqt", + "python >=3.8,<3.9.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "d7a15b57f9ba4a2bad00be3fbda25206", + "name": "matplotlib", + "sha256": "82b07da744d2c9b1ea2f05e554a39ac017a54c640f34bed2bba341301e36cd51", + "size": 29352, + "subdir": "linux-64", + "timestamp": 1647442136443, + "version": "3.5.1" + }, + "matplotlib-3.5.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.1,<3.5.2.0a0", + "pyqt", + "python >=3.9,<3.10.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "c67d2cb89fa67f558045f1c324946168", + "name": "matplotlib", + "sha256": "34ec89028b47f87d2eef65b2c8383e711523e027ed8913493759fc232f176473", + "size": 28978, + "subdir": "linux-64", + "timestamp": 1645456120275, + "version": "3.5.1" + }, + "matplotlib-3.5.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base >=3.5.1,<3.5.2.0a0", + "pyqt", + "python >=3.9,<3.10.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "b0d025a5866f9e5df0793ebf34f7f245", + "name": "matplotlib", + "sha256": "3e01c78fec332ce2545142b42c82a1d7c5a70b4feb065f9414b34a646dcec379", + "size": 29346, + "subdir": "linux-64", + "timestamp": 1647442129989, + "version": "3.5.1" + }, + "matplotlib-3.5.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.2,<3.5.3.0a0", + "pyqt", + "python >=3.10,<3.11.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "2b031165bbdd41c2d6bd5252a814da70", + "name": "matplotlib", + "sha256": "924522216f4a65cbb93757e82dedbdc93831ba86492b5f8cbccbe66f409ef11a", + "size": 6673, + "subdir": "linux-64", + "timestamp": 1660168339775, + "version": "3.5.2" + }, + "matplotlib-3.5.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.2,<3.5.3.0a0", + "pyqt", + "python >=3.7,<3.8.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "919d9fb7f6c0df95a2f0292a3deae7d0", + "name": "matplotlib", + "sha256": "7c913216545c67f3f64f86cca49079682bb824ac556e123e46ae7fca9fe188bf", + "size": 6649, + "subdir": "linux-64", + "timestamp": 1660168323143, + "version": "3.5.2" + }, + "matplotlib-3.5.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.2,<3.5.3.0a0", + "pyqt", + "python >=3.8,<3.9.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "f41041b7007e869be29d89d855c82b78", + "name": "matplotlib", + "sha256": "9835cf9d70fc7d985fa351fc0c36e1325e8245d601a5b4c7def2f3c15da4adf9", + "size": 6645, + "subdir": "linux-64", + "timestamp": 1660168334021, + "version": "3.5.2" + }, + "matplotlib-3.5.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.2,<3.5.3.0a0", + "pyqt", + "python >=3.9,<3.10.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "1cfd5952ef711ba8fe8f9344ad0ebd04", + "name": "matplotlib", + "sha256": "42b9300413495f8f20b64142e242b4fbd02a3a601b35df7324323318a52610a9", + "size": 6647, + "subdir": "linux-64", + "timestamp": 1660168328602, + "version": "3.5.2" + }, + "matplotlib-3.5.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.3,<3.5.4.0a0", + "pyqt", + "python >=3.10,<3.11.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "ec527db1984ce511d87450abb51fd30b", + "name": "matplotlib", + "sha256": "a1ebdce8bb75f00b9abd617ed6e5af7ae6e282dede24b1ff296e375cc8139e34", + "size": 7061, + "subdir": "linux-64", + "timestamp": 1667357064526, + "version": "3.5.3" + }, + "matplotlib-3.5.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.3,<3.5.4.0a0", + "pyqt", + "python >=3.7,<3.8.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "466176a35ab16c0009ac108c24ddd3aa", + "name": "matplotlib", + "sha256": "7022889601bc0e9c5cf2901ebeeae93aee4c7c2d53b94d8b9f9b0779abd682ea", + "size": 7036, + "subdir": "linux-64", + "timestamp": 1667357075287, + "version": "3.5.3" + }, + "matplotlib-3.5.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.3,<3.5.4.0a0", + "pyqt", + "python >=3.8,<3.9.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "767111ef6fcaa4465e5391d719d0e313", + "name": "matplotlib", + "sha256": "9fbdfaf9721c0eb9e1c892fb18745c0cdc01059848d98402210b704d3e7b33aa", + "size": 7036, + "subdir": "linux-64", + "timestamp": 1667357069932, + "version": "3.5.3" + }, + "matplotlib-3.5.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.5.3,<3.5.4.0a0", + "pyqt", + "python >=3.9,<3.10.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "4f7f71069752dfde38d481cff3d6e89e", + "name": "matplotlib", + "sha256": "3117643d51ef6eb484e8b1a6b0b636e83d9a5e930aef169800d0c05f37daaf5c", + "size": 7038, + "subdir": "linux-64", + "timestamp": 1667357058777, + "version": "3.5.3" + }, + "matplotlib-3.6.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.6.2,<3.6.3.0a0", + "pyqt >=5", + "python >=3.10,<3.11.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "74894cae61175f00ef942bebbe37e6fd", + "name": "matplotlib", + "sha256": "5bfbcb35bb46807f2153e6bd1c3c9e2e7c31da7092c34ca1fb86ab3fa4144f28", + "size": 8000, + "subdir": "linux-64", + "timestamp": 1670466425065, + "version": "3.6.2" + }, + "matplotlib-3.6.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.6.2,<3.6.3.0a0", + "pyqt >=5", + "python >=3.11,<3.12.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "25f478ee2e9ca8f30b1a44b8985fdefb", + "name": "matplotlib", + "sha256": "c23bd702b02ab808991df54b29442a6bbd5c736d81bbf9fbfd31120ac9af3fba", + "size": 8117, + "subdir": "linux-64", + "timestamp": 1676828266772, + "version": "3.6.2" + }, + "matplotlib-3.6.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.6.2,<3.6.3.0a0", + "pyqt >=5", + "python >=3.8,<3.9.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "4e8a2a3da6ccc886f0210071824ae09b", + "name": "matplotlib", + "sha256": "c3f53637be90d6e4a92a9f7630fc53ca6c351128842daef1d4fd27b1b574da9d", + "size": 7974, + "subdir": "linux-64", + "timestamp": 1670466419260, + "version": "3.6.2" + }, + "matplotlib-3.6.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.6.2,<3.6.3.0a0", + "pyqt >=5", + "python >=3.9,<3.10.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "952d29fd920f5aaa23071d0f090452c4", + "name": "matplotlib", + "sha256": "a75fcf0638a8cf441524151065d5b14f6d88cc8adb2a171fa81e831a24c99f2a", + "size": 7979, + "subdir": "linux-64", + "timestamp": 1670466413774, + "version": "3.6.2" + }, + "matplotlib-3.7.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.7.0,<3.7.1.0a0", + "pyqt >=5", + "python >=3.10,<3.11.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "885b24a7ac1df5643270dec5294324b7", + "name": "matplotlib", + "sha256": "9a1a09ca3f0f2b6bf1465c559feb0ff2396a884bf969180d8bf2125c7ab6157b", + "size": 8185, + "subdir": "linux-64", + "timestamp": 1677674628579, + "version": "3.7.0" + }, + "matplotlib-3.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.7.0,<3.7.1.0a0", + "pyqt >=5", + "python >=3.8,<3.9.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "8127b871e346f00ce29cba7172cc75c2", + "name": "matplotlib", + "sha256": "4de5face1b890b66d4e953958fc94a6561751e855ca6a92db0cef4447d273d8c", + "size": 8162, + "subdir": "linux-64", + "timestamp": 1677674622632, + "version": "3.7.0" + }, + "matplotlib-3.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.7.0,<3.7.1.0a0", + "pyqt >=5", + "python >=3.9,<3.10.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "1c95e2388702549f0d2635535f4af23a", + "name": "matplotlib", + "sha256": "f30d624f574c7769cf4705b8e887611cfc90eb12eb09db5d005352ec6a48b4e2", + "size": 8165, + "subdir": "linux-64", + "timestamp": 1677674634360, + "version": "3.7.0" + }, + "matplotlib-3.7.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.7.1,<3.7.2.0a0", + "pyqt >=5", + "python >=3.10,<3.11.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "10bd9c8c2e54c43819a0b1e2e4e637e0", + "name": "matplotlib", + "sha256": "9a520805af9f095f60aa51f6a7656e43f903e49084bc747be69dc42e2b7d7ac0", + "size": 8400, + "subdir": "linux-64", + "timestamp": 1678724204363, + "version": "3.7.1" + }, + "matplotlib-3.7.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base >=3.7.1,<3.7.2.0a0", + "pyqt >=5", + "python >=3.10,<3.11.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "54ba9684d6aa92c6fb8a35f189ea4c8f", + "name": "matplotlib", + "sha256": "6b3495e95bab4777cbbee2a90e449c9e56498d502d2f23fb15e982da15393183", + "size": 8153, + "subdir": "linux-64", + "timestamp": 1679593840686, + "version": "3.7.1" + }, + "matplotlib-3.7.1-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base >=3.7.1,<3.7.2.0a0", + "pyqt >=5", + "python >=3.11,<3.12.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "1ab6287a720bcc3105022e518c97cb23", + "name": "matplotlib", + "sha256": "b5f35ca54b5355530712265f6dd8823b1c87c3e07e60bdeeac29b7bdd68747bd", + "size": 8143, + "subdir": "linux-64", + "timestamp": 1679593858918, + "version": "3.7.1" + }, + "matplotlib-3.7.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.7.1,<3.7.2.0a0", + "pyqt >=5", + "python >=3.8,<3.9.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "270ae6aabe3e4bed4a26798bd6ed0f1f", + "name": "matplotlib", + "sha256": "05d7371f0b4aa331769d6f76e9e96a457e69890c1d4aac69e1f6505d1b8e0fb0", + "size": 8362, + "subdir": "linux-64", + "timestamp": 1678724198367, + "version": "3.7.1" + }, + "matplotlib-3.7.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base >=3.7.1,<3.7.2.0a0", + "pyqt >=5", + "python >=3.8,<3.9.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "560ce48d2cd0aef48af3c3514df8cfb1", + "name": "matplotlib", + "sha256": "9271ca1bf92bdab729f17f17ff716c12b373da6810ef19c3279d4d743a576d06", + "size": 8132, + "subdir": "linux-64", + "timestamp": 1679593852552, + "version": "3.7.1" + }, + "matplotlib-3.7.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.7.1,<3.7.2.0a0", + "pyqt >=5", + "python >=3.9,<3.10.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "e36b2099ffd484d887363088dc892c35", + "name": "matplotlib", + "sha256": "90685c9b3a7fb1ae46cd82a49b12a60ac736b7175b1cc074cf867b45bb943d9d", + "size": 8359, + "subdir": "linux-64", + "timestamp": 1678724192544, + "version": "3.7.1" + }, + "matplotlib-3.7.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "matplotlib-base >=3.7.1,<3.7.2.0a0", + "pyqt >=5", + "python >=3.9,<3.10.0a0", + "tornado >=5" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "9655f1479daa083a4c795ce785d37e9e", + "name": "matplotlib", + "sha256": "17d327379beb8edc646dc3b5b69e5ca4fa8a64f6a382742fb86be5e6ed310c5c", + "size": 8128, + "subdir": "linux-64", + "timestamp": 1679593846728, + "version": "3.7.1" + }, + "matplotlib-base-3.1.2-py36hef1b27d_1.conda": { + "build": "py36hef1b27d_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "4773ffdfa0b78545d703f63304be998a", + "name": "matplotlib-base", + "sha256": "82f5275968d6561ac7ba8bdf8b39a4c3b69f6ac12197bfd4c161d751da773c49", + "size": 5211415, + "subdir": "linux-64", + "timestamp": 1580491870760, + "version": "3.1.2" + }, + "matplotlib-base-3.1.2-py37hef1b27d_1.conda": { + "build": "py37hef1b27d_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "f5f36d144b2c4b53ac9ac0605063786a", + "name": "matplotlib-base", + "sha256": "1189750a8d04b6986951fc82766e3e97caf6cdef63cc224af33775828542f40b", + "size": 5223278, + "subdir": "linux-64", + "timestamp": 1580491830952, + "version": "3.1.2" + }, + "matplotlib-base-3.1.2-py38hef1b27d_1.conda": { + "build": "py38hef1b27d_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "5e99f974f4c2757791aa10a27596230a", + "name": "matplotlib-base", + "sha256": "08a060dad8ee21c8d607d6b9318ca1088c4ae55f4a4e7915c75a87d64f251595", + "size": 5246167, + "subdir": "linux-64", + "timestamp": 1580491844468, + "version": "3.1.2" + }, + "matplotlib-base-3.1.3-py36hef1b27d_0.conda": { + "build": "py36hef1b27d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "b6e822d765f25307c0e3752bb4a585fa", + "name": "matplotlib-base", + "sha256": "b467370dba0326d7a80901c467308937cd6cc656108f41fd764d73b3222d8e5e", + "size": 5210110, + "subdir": "linux-64", + "timestamp": 1580847917644, + "version": "3.1.3" + }, + "matplotlib-base-3.1.3-py37hef1b27d_0.conda": { + "build": "py37hef1b27d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "4af6730fcfa65526d40d314267b76037", + "name": "matplotlib-base", + "sha256": "5ed37bba8c59f1d14bbf1f85b2e26d4bfd9a7395820db8ed48bccae8359c2f20", + "size": 5205079, + "subdir": "linux-64", + "timestamp": 1580847915792, + "version": "3.1.3" + }, + "matplotlib-base-3.1.3-py38hef1b27d_0.conda": { + "build": "py38hef1b27d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "a7ad7d097c25b7beeb76f370d51687a1", + "name": "matplotlib-base", + "sha256": "69bff390590e9aa349590c8c763b71724c17850cb11d84eae6fd6024df1ee608", + "size": 5247832, + "subdir": "linux-64", + "timestamp": 1580847915072, + "version": "3.1.3" + }, + "matplotlib-base-3.2.1-py36hef1b27d_0.conda": { + "build": "py36hef1b27d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "4667b1d1b2f703c226c5caa45f347281", + "name": "matplotlib-base", + "sha256": "91ff9982e8f598c43ce6b3c13c5321ab74652f7abea0295c40098d2a0dea5767", + "size": 5669990, + "subdir": "linux-64", + "timestamp": 1592406276085, + "version": "3.2.1" + }, + "matplotlib-base-3.2.1-py37hef1b27d_0.conda": { + "build": "py37hef1b27d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "507f38e44f5e6d2234573d7eee93f049", + "name": "matplotlib-base", + "sha256": "9885bf20d3041f9aaa4618c68fd3085d554f317a89010a616a97722e086f485b", + "size": 5637101, + "subdir": "linux-64", + "timestamp": 1592406272723, + "version": "3.2.1" + }, + "matplotlib-base-3.2.1-py38hef1b27d_0.conda": { + "build": "py38hef1b27d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.8,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "c84195510b95b78a8016458a68a4233e", + "name": "matplotlib-base", + "sha256": "ff626b35c5c3bddaa8ac8635aede56fad82822a2f0a00bd9133835d84fbf0e9c", + "size": 5680977, + "subdir": "linux-64", + "timestamp": 1592406274427, + "version": "3.2.1" + }, + "matplotlib-base-3.2.2-py36hef1b27d_0.conda": { + "build": "py36hef1b27d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.10,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "0b69f4207cc5ce066d4f130aa946058d", + "name": "matplotlib-base", + "sha256": "80d525366a1629b0028c6bb847b4ad5bc24c317caec2c35fe42e0220b675d002", + "size": 5655687, + "subdir": "linux-64", + "timestamp": 1592846187981, + "version": "3.2.2" + }, + "matplotlib-base-3.2.2-py37hef1b27d_0.conda": { + "build": "py37hef1b27d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.10,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "f1f3c413c0b43f3e4bff7426f671ff8f", + "name": "matplotlib-base", + "sha256": "ba427c08ea82d00c002e04f88abc73c79ac3359e5a35ace88ffa331b3fba63bf", + "size": 5643101, + "subdir": "linux-64", + "timestamp": 1592846172846, + "version": "3.2.2" + }, + "matplotlib-base-3.2.2-py38hef1b27d_0.conda": { + "build": "py38hef1b27d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.9.1,<3.0a0", + "icu >=58.2,<59.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pyparsing", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.10,<8.7.0a0", + "tornado" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "2b4193321aac5838885af78838ca9e07", + "name": "matplotlib-base", + "sha256": "658a2c81349f9dba498f023682dcda27b25e7238c3ea0f0b4f99627863aece31", + "size": 5664571, + "subdir": "linux-64", + "timestamp": 1592846190233, + "version": "3.2.2" + }, + "matplotlib-base-3.3.1-py36h817c723_0.conda": { + "build": "py36h817c723_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.10.2,<3.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "pillow >=6.2.0", + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.10,<8.7.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "9c566387de6f8a593f9a4dfcfeb3d3ed", + "name": "matplotlib-base", + "sha256": "f5bc8a3bc5c2d6e16ac3768008ccf283dea4fb871f92e78afc09427057a96768", + "size": 5301017, + "subdir": "linux-64", + "timestamp": 1597876463972, + "version": "3.3.1" + }, + "matplotlib-base-3.3.1-py37h817c723_0.conda": { + "build": "py37h817c723_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.10.2,<3.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "pillow >=6.2.0", + "pyparsing", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.10,<8.7.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "993849e1b99722fe22d8f47014af136d", + "name": "matplotlib-base", + "sha256": "099f804cd986f5962d92276b899cf77271fb4a69121fa4c52c5771e4dbd22a33", + "size": 5293019, + "subdir": "linux-64", + "timestamp": 1597876514601, + "version": "3.3.1" + }, + "matplotlib-base-3.3.1-py38h817c723_0.conda": { + "build": "py38h817c723_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "freetype >=2.10.2,<3.0a0", + "kiwisolver", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "setuptools", + "tk >=8.6.10,<8.7.0a0", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "31110ece4d92494d809462b9774b1a36", + "name": "matplotlib-base", + "sha256": "6df6fc214ffcbb54b1c06cb15f47811a7242d1748431e27ef736bb77de48e5b6", + "size": 5337630, + "subdir": "linux-64", + "timestamp": 1597876517109, + "version": "3.3.1" + }, + "matplotlib-base-3.3.2-py36h817c723_0.conda": { + "build": "py36h817c723_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.0.3,!=2.0.4,!=2.1.2,!=2.1.6", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "7df0326316a9c79776633de2bc17ecc8", + "name": "matplotlib-base", + "sha256": "0124062c0aab679f2bca61dc0b1c1dd0fba6d4007288a5b10c6eb600e38a3b7f", + "size": 5327526, + "subdir": "linux-64", + "timestamp": 1603373934044, + "version": "3.3.2" + }, + "matplotlib-base-3.3.2-py37h817c723_0.conda": { + "build": "py37h817c723_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.0.3,!=2.0.4,!=2.1.2,!=2.1.6", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "18b33268f2253b1c2edb1e82eeb6ab7a", + "name": "matplotlib-base", + "sha256": "176c21033d2fd35d7bf039c050f1a835ead9336258706f6a6f926725eb7aec2b", + "size": 5299745, + "subdir": "linux-64", + "timestamp": 1603376178061, + "version": "3.3.2" + }, + "matplotlib-base-3.3.2-py38h817c723_0.conda": { + "build": "py38h817c723_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.0.3,!=2.0.4,!=2.1.2,!=2.1.6", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "8bdc509599f37e4ad6efc24772e3e359", + "name": "matplotlib-base", + "sha256": "e95dc91b21793ed7621a0c1af056f4fc3782a0a66c54781b749c3d2f08e76211", + "size": 5343730, + "subdir": "linux-64", + "timestamp": 1603378384062, + "version": "3.3.2" + }, + "matplotlib-base-3.3.2-py39hd261b2b_0.conda": { + "build": "py39hd261b2b_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy", + "pillow >=6.2.0", + "pyparsing >=2.0.3,!=2.0.4,!=2.1.2,!=2.1.6", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "86ea975daf0af890406b72d86954ff6c", + "name": "matplotlib-base", + "sha256": "fe5773d8c5b0680ee23efd98774ee6cb8eb861e94e3c1b716885732f3a71e550", + "size": 5309995, + "subdir": "linux-64", + "timestamp": 1607974691989, + "version": "3.3.2" + }, + "matplotlib-base-3.3.4-py36h62a2d02_0.conda": { + "build": "py36h62a2d02_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.0.3,!=2.0.4,!=2.1.2,!=2.1.6", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "4e27b22fb2aa04e76fde4ebc1b633076", + "name": "matplotlib-base", + "sha256": "4f7eea5ee59342892298f91fc5d0849bb1643f69fe79673e6c094ffb2ef608bd", + "size": 5336619, + "subdir": "linux-64", + "timestamp": 1613408052887, + "version": "3.3.4" + }, + "matplotlib-base-3.3.4-py37h62a2d02_0.conda": { + "build": "py37h62a2d02_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.0.3,!=2.0.4,!=2.1.2,!=2.1.6", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "46f701bb43f5e1bebfdc3dd9b3dca66b", + "name": "matplotlib-base", + "sha256": "888eaa7ba36312c523def2849405ff4c3b623e2957931fcefcbdd4cdb22a3d6b", + "size": 5323692, + "subdir": "linux-64", + "timestamp": 1613408282761, + "version": "3.3.4" + }, + "matplotlib-base-3.3.4-py38h62a2d02_0.conda": { + "build": "py38h62a2d02_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.0.3,!=2.0.4,!=2.1.2,!=2.1.6", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "7156fafe3362d0b6a2de43e0002febb3", + "name": "matplotlib-base", + "sha256": "784c6acdb0b0f567bae1cb5be242286f8b1a7cca3e1a6262294b84149aa9298c", + "size": 5343184, + "subdir": "linux-64", + "timestamp": 1613408134644, + "version": "3.3.4" + }, + "matplotlib-base-3.3.4-py39h62a2d02_0.conda": { + "build": "py39h62a2d02_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.0.3,!=2.0.4,!=2.1.2,!=2.1.6", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "dbab28222c740af8e21a3e5e2882c178", + "name": "matplotlib-base", + "sha256": "d6b5abe3ba158d654d64588db3b572104b51b8a2470648969971bcec15d64d97", + "size": 5339825, + "subdir": "linux-64", + "timestamp": 1613408209886, + "version": "3.3.4" + }, + "matplotlib-base-3.4.2-py37hab158f2_0.conda": { + "build": "py37hab158f2_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "5489cae668463b516b41f2feff837065", + "name": "matplotlib-base", + "sha256": "b6b226415d11f33f579188d4895ec6a6f1be198fb691e5343a283bc8dc464cdc", + "size": 5859935, + "subdir": "linux-64", + "timestamp": 1628003839866, + "version": "3.4.2" + }, + "matplotlib-base-3.4.2-py38hab158f2_0.conda": { + "build": "py38hab158f2_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "36c7113b96158e7eb56d6b576f1aea61", + "name": "matplotlib-base", + "sha256": "f8b77c54d7ba78fabcb631bf782633acd3d652830d724fd0c1dcbb0390173d3f", + "size": 5881287, + "subdir": "linux-64", + "timestamp": 1628003669621, + "version": "3.4.2" + }, + "matplotlib-base-3.4.2-py39hab158f2_0.conda": { + "build": "py39hab158f2_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "e3af379c769976e787550e19af5f71d3", + "name": "matplotlib-base", + "sha256": "6bb36c5e219270c9e4624116826ea15935aff27031abe36204a53b1a23debbdd", + "size": 5877050, + "subdir": "linux-64", + "timestamp": 1628003754874, + "version": "3.4.2" + }, + "matplotlib-base-3.4.3-py37hbbc1b5f_0.conda": { + "build": "py37hbbc1b5f_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "6505d447ef706816c5c9c3d49d497ba8", + "name": "matplotlib-base", + "sha256": "aa7385aa5bc8f44baf30690262343b2c3be8d18cd861b61242cc4076991c4e6d", + "size": 5828071, + "subdir": "linux-64", + "timestamp": 1634667274247, + "version": "3.4.3" + }, + "matplotlib-base-3.4.3-py38hbbc1b5f_0.conda": { + "build": "py38hbbc1b5f_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "fcaedad4995ddf94998d09f58d30d790", + "name": "matplotlib-base", + "sha256": "03720a97b663fc5527286ec79b369a7089f451353c919902c301fc0cadf804f8", + "size": 5855836, + "subdir": "linux-64", + "timestamp": 1634667193827, + "version": "3.4.3" + }, + "matplotlib-base-3.4.3-py39hbbc1b5f_0.conda": { + "build": "py39hbbc1b5f_0", + "build_number": 0, + "depends": [ + "certifi >=2020.06.20", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "setuptools", + "tk", + "tornado" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "68f0f645685e616436d6722c686043f2", + "name": "matplotlib-base", + "sha256": "da72efc0a232a43e21d41a01db53ce11819a5fbed359a3e3c119eb397e30cbc1", + "size": 5846253, + "subdir": "linux-64", + "timestamp": 1634667358391, + "version": "3.4.3" + }, + "matplotlib-base-3.5.0-py310h2dab92d_0.conda": { + "build": "py310h2dab92d_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "12b07d61dcdc168e425dbe85b43d566e", + "name": "matplotlib-base", + "sha256": "ecef0ca7965caae3598eb0acb039f6afa6ea37d56cf04fb6cea6affe7e021a80", + "size": 5917616, + "subdir": "linux-64", + "timestamp": 1641903414938, + "version": "3.5.0" + }, + "matplotlib-base-3.5.0-py37h3ed280b_0.conda": { + "build": "py37h3ed280b_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "3252a6e9d5793baa33b30c7cb2f94423", + "name": "matplotlib-base", + "sha256": "b5f075efd21d914c332e527d2bff8e45d5d03d0086b701b28182a88d7a63152b", + "size": 5907828, + "subdir": "linux-64", + "timestamp": 1638290013064, + "version": "3.5.0" + }, + "matplotlib-base-3.5.0-py38h3ed280b_0.conda": { + "build": "py38h3ed280b_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "236825d70559ac3db3c39e014b51fdfe", + "name": "matplotlib-base", + "sha256": "f238e9453b244883ace36d47da74b4f954594aa750364a1d85c516d1a111d7e7", + "size": 5934500, + "subdir": "linux-64", + "timestamp": 1638289855775, + "version": "3.5.0" + }, + "matplotlib-base-3.5.0-py39h3ed280b_0.conda": { + "build": "py39h3ed280b_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "66981126290aa32ff89a9f91c03f29a1", + "name": "matplotlib-base", + "sha256": "c3c7c8ad7e972ee8d8c010d55b20a20566880c7e776bd980c757fb9c4d5e028c", + "size": 5931632, + "subdir": "linux-64", + "timestamp": 1638289932260, + "version": "3.5.0" + }, + "matplotlib-base-3.5.1-py310ha18d171_0.conda": { + "build": "py310ha18d171_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "052b8d5c21eb3a506a98f8d25e6ad1d3", + "name": "matplotlib-base", + "sha256": "486eae504b6d6b8e0af71452728fbc21170aded1e174c4b403147dd19e457d03", + "size": 5947822, + "subdir": "linux-64", + "timestamp": 1645456108049, + "version": "3.5.1" + }, + "matplotlib-base-3.5.1-py310ha18d171_1.conda": { + "build": "py310ha18d171_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "85d52c34235d53a213a4fefd007debe9", + "name": "matplotlib-base", + "sha256": "e4be572d4b067f766714db36cd691bd3df071bd9d028baca470867d8a84c17ab", + "size": 5969006, + "subdir": "linux-64", + "timestamp": 1647441945703, + "version": "3.5.1" + }, + "matplotlib-base-3.5.1-py37ha18d171_0.conda": { + "build": "py37ha18d171_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "075dbdf129cf68380e3e4d8b9ecfd97e", + "name": "matplotlib-base", + "sha256": "c15bf24a3cfc6636db49a43c58b2df23ae8c4f9b65f9e78b8c0000ab06ef9e56", + "size": 5892111, + "subdir": "linux-64", + "timestamp": 1645456017368, + "version": "3.5.1" + }, + "matplotlib-base-3.5.1-py37ha18d171_1.conda": { + "build": "py37ha18d171_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "a7442851e3cbd391471074146c4bc27b", + "name": "matplotlib-base", + "sha256": "6d4e18270898525e42456d7b759261b4178a29ca4559fbe3cdfaa289aa7a37e9", + "size": 5921805, + "subdir": "linux-64", + "timestamp": 1647441852378, + "version": "3.5.1" + }, + "matplotlib-base-3.5.1-py38ha18d171_0.conda": { + "build": "py38ha18d171_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "668c6a7d4871a8176a2df1eb3d278c25", + "name": "matplotlib-base", + "sha256": "e0e246f79f9f422bce91d16a30662b9c1bb00e5d6af9beb58f3884668f45b32a", + "size": 5917920, + "subdir": "linux-64", + "timestamp": 1645455937245, + "version": "3.5.1" + }, + "matplotlib-base-3.5.1-py38ha18d171_1.conda": { + "build": "py38ha18d171_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "61037444fe5aef294f20fadac4204392", + "name": "matplotlib-base", + "sha256": "235612796af4985a9ffaa89e1d7d4f878b17209a2e5c8b6e7ab6138f6dca965e", + "size": 5947432, + "subdir": "linux-64", + "timestamp": 1647442104672, + "version": "3.5.1" + }, + "matplotlib-base-3.5.1-py39ha18d171_0.conda": { + "build": "py39ha18d171_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "8ccfeff8dd84514601e5053b676b057c", + "name": "matplotlib-base", + "sha256": "02076b53dfa1d7db1bd6250c1b79a0bf7b20912df4c7f5ee4ec7c5d537143860", + "size": 5911886, + "subdir": "linux-64", + "timestamp": 1645455862011, + "version": "3.5.1" + }, + "matplotlib-base-3.5.1-py39ha18d171_1.conda": { + "build": "py39ha18d171_1", + "build_number": 1, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7", + "tk" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "ff751aa1636dc58c88c00610f2278507", + "name": "matplotlib-base", + "sha256": "4038b7d5c8e7c3851c16b5397bab6b59a53dedbd34438a1f4fb05fad2d191077", + "size": 5938134, + "subdir": "linux-64", + "timestamp": 1647442028622, + "version": "3.5.1" + }, + "matplotlib-base-3.5.2-py310hf590b9c_0.conda": { + "build": "py310hf590b9c_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "7f77970910c773d0581a2264bd8ea3b7", + "name": "matplotlib-base", + "sha256": "570a00b4a67b6c8af4b469c748a24ddd876328c3af1036ea1cffcf482f303409", + "size": 8222722, + "subdir": "linux-64", + "timestamp": 1660168311133, + "version": "3.5.2" + }, + "matplotlib-base-3.5.2-py37hf590b9c_0.conda": { + "build": "py37hf590b9c_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "7a9305687d57a85d1e654001878cee31", + "name": "matplotlib-base", + "sha256": "ba2a5f992326f08dd10b0021581d7fddde34e14dea8640a44ef06d995ee1fdbb", + "size": 5909579, + "subdir": "linux-64", + "timestamp": 1660168112539, + "version": "3.5.2" + }, + "matplotlib-base-3.5.2-py38hf590b9c_0.conda": { + "build": "py38hf590b9c_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "69326a678bf8c6f8985796c07244169b", + "name": "matplotlib-base", + "sha256": "df6893fa3000992d4342ed3743741b1465f565e6e855c14de42423bbe08ebec5", + "size": 5928089, + "subdir": "linux-64", + "timestamp": 1660168241713, + "version": "3.5.2" + }, + "matplotlib-base-3.5.2-py39hf590b9c_0.conda": { + "build": "py39hf590b9c_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.11.0,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "826adda976889400a9c0666a6f89275c", + "name": "matplotlib-base", + "sha256": "64d34055965625cdeacbeb21094664c81bb2140f7650529b91bac1063b339446", + "size": 5921849, + "subdir": "linux-64", + "timestamp": 1660168180954, + "version": "3.5.2" + }, + "matplotlib-base-3.5.3-py310hf590b9c_0.conda": { + "build": "py310hf590b9c_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.12.1,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "0ec04dce909f53dd4b23f1ea3b150c3d", + "name": "matplotlib-base", + "sha256": "691471f970f9a3c163f3499fc1cfc6b1fb8ed9a49f6257543629fb03dc4962f2", + "size": 6758378, + "subdir": "linux-64", + "timestamp": 1667356927731, + "version": "3.5.3" + }, + "matplotlib-base-3.5.3-py37hf590b9c_0.conda": { + "build": "py37hf590b9c_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.12.1,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "9f8bfc697e75496809765011c9116c10", + "name": "matplotlib-base", + "sha256": "fb14838b2286fd37a162ecf1ef40d8fe88c18899908e2d5a40d9f43f4665936f", + "size": 6705769, + "subdir": "linux-64", + "timestamp": 1667357048104, + "version": "3.5.3" + }, + "matplotlib-base-3.5.3-py38hf590b9c_0.conda": { + "build": "py38hf590b9c_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.12.1,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "a698f13799dfd2dea9e4e9dbfd2a400c", + "name": "matplotlib-base", + "sha256": "5f23ffb433974d8e94218c3ded9bf99c31ff99ed93605d8297c6f3a2ebfb64b6", + "size": 6732012, + "subdir": "linux-64", + "timestamp": 1667356986909, + "version": "3.5.3" + }, + "matplotlib-base-3.5.3-py39hf590b9c_0.conda": { + "build": "py39hf590b9c_0", + "build_number": 0, + "depends": [ + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.12.1,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "e4c9a86e73267635ec049c664f9a2c74", + "name": "matplotlib-base", + "sha256": "38a64730579e3c062c1ccc17e6cdec14162b13cc9ed225da613a648171fda263", + "size": 6715590, + "subdir": "linux-64", + "timestamp": 1667356866273, + "version": "3.5.3" + }, + "matplotlib-base-3.6.2-py310h945d387_0.conda": { + "build": "py310h945d387_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "81480e7f51b8512098ff7de7f1a1e916", + "name": "matplotlib-base", + "sha256": "009fed96a0bba7b0c16447dcc41875bfff68cb5e0fa128db128bee7114dca56c", + "size": 6880665, + "subdir": "linux-64", + "timestamp": 1670466402920, + "version": "3.6.2" + }, + "matplotlib-base-3.6.2-py311h945d387_0.conda": { + "build": "py311h945d387_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "28bd32499451f5c895822d3445559183", + "name": "matplotlib-base", + "sha256": "85503eb112f6ce2a7e1c070f922d61566a4659da3926aa19d97b9e377d025384", + "size": 7021290, + "subdir": "linux-64", + "timestamp": 1676828257531, + "version": "3.6.2" + }, + "matplotlib-base-3.6.2-py38h945d387_0.conda": { + "build": "py38h945d387_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "5ff4a8f74932ab09b0edae03aea046b5", + "name": "matplotlib-base", + "sha256": "bdf51737d8461792fc49c51799cc8fbe2c9b750947ae4f85d45de460b059d428", + "size": 6862931, + "subdir": "linux-64", + "timestamp": 1670466343218, + "version": "3.6.2" + }, + "matplotlib-base-3.6.2-py39h945d387_0.conda": { + "build": "py39h945d387_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10.4,<3.0a0", + "freetype >=2.3", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.2.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "4f5cb09d4c574c3bb9ac39b3b55e1647", + "name": "matplotlib-base", + "sha256": "dd2a76430d71a81363499814ff35a05a800efa5c87ff72925672ca25f0ec117e", + "size": 6844608, + "subdir": "linux-64", + "timestamp": 1670466285882, + "version": "3.6.2" + }, + "matplotlib-base-3.7.0-py310h1128e8f_0.conda": { + "build": "py310h1128e8f_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7", + "tk >=8.6.11,<8.7", + "tk >=8.6.11,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "9b0a9b8e8ee52a3f7047d997de3d5015", + "name": "matplotlib-base", + "sha256": "6e0a100f74f64ecd78da92158523a209541476d5220c870b38c8dd71dde916dc", + "size": 9229487, + "subdir": "linux-64", + "timestamp": 1677674540501, + "version": "3.7.0" + }, + "matplotlib-base-3.7.0-py38h417a72b_0.conda": { + "build": "py38h417a72b_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "importlib_resources >=5.2.0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "numpy >=1.20", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7", + "tk >=8.6.11,<8.7", + "tk >=8.6.11,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "7a86c716901c497abe23383e98340a37", + "name": "matplotlib-base", + "sha256": "4cba73bea8c84aa5fa800394ec6af0b1e31030aff6ea528a713bead5832bbae7", + "size": 6964119, + "subdir": "linux-64", + "timestamp": 1677674462058, + "version": "3.7.0" + }, + "matplotlib-base-3.7.0-py39h417a72b_0.conda": { + "build": "py39h417a72b_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "importlib_resources >=5.2.0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "numpy >=1.20", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7", + "tk >=8.6.11,<8.7", + "tk >=8.6.11,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "0ecc80a8563e3a935b8354b81a8d249e", + "name": "matplotlib-base", + "sha256": "613a589bc876f89e62a2a7dc60ac29854bbe970caa56b54a33ff107b470e170c", + "size": 6950032, + "subdir": "linux-64", + "timestamp": 1677674611833, + "version": "3.7.0" + }, + "matplotlib-base-3.7.1-py310h1128e8f_0.conda": { + "build": "py310h1128e8f_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7", + "tk >=8.6.11,<8.7", + "tk >=8.6.11,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "e02122655f036dbb00902c9414265e72", + "name": "matplotlib-base", + "sha256": "4a0b974b9e80e60ab926377d783bd49563a239ba4476a17cb7f770bb60da48e6", + "size": 9228889, + "subdir": "linux-64", + "timestamp": 1678724180150, + "version": "3.7.1" + }, + "matplotlib-base-3.7.1-py310h1128e8f_1.conda": { + "build": "py310h1128e8f_1", + "build_number": 1, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.7", + "tk >=8.6.12,<8.7", + "tk >=8.6.12,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "df99f74e469bcd02a2d10c0b67c1f5f5", + "name": "matplotlib-base", + "sha256": "d7af83b5e4a47b0d0845df1e2eddc233a27ce25e022d5427037bd2c79ac26637", + "size": 7009446, + "subdir": "linux-64", + "timestamp": 1679593629865, + "version": "3.7.1" + }, + "matplotlib-base-3.7.1-py311ha02d727_1.conda": { + "build": "py311ha02d727_1", + "build_number": 1, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20", + "numpy >=1.23.5,<2.0a0", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.7", + "tk >=8.6.12,<8.7", + "tk >=8.6.12,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "f0273d58c94d8bcd00f6e3f6a9881776", + "name": "matplotlib-base", + "sha256": "6a4c218938683060c0e54afb857f78f495964807dcbe7113fea605fbebd6e30a", + "size": 7913330, + "subdir": "linux-64", + "timestamp": 1679593828815, + "version": "3.7.1" + }, + "matplotlib-base-3.7.1-py38h417a72b_0.conda": { + "build": "py38h417a72b_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "importlib_resources >=5.2.0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "numpy >=1.20", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7", + "tk >=8.6.11,<8.7", + "tk >=8.6.11,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "cdb683b8248b51f542aae187f6685723", + "name": "matplotlib-base", + "sha256": "d9106902a400e436b896117428d7a27741ebfceb7c05d255d7d5e1eff688feae", + "size": 6984752, + "subdir": "linux-64", + "timestamp": 1678724103738, + "version": "3.7.1" + }, + "matplotlib-base-3.7.1-py38h417a72b_1.conda": { + "build": "py38h417a72b_1", + "build_number": 1, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "importlib_resources >=5.2.0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "numpy >=1.20", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7", + "tk >=8.6.12,<8.7", + "tk >=8.6.12,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "d52dda35813bd6a7e3681dfa5c2ddef7", + "name": "matplotlib-base", + "sha256": "08ef097c15107d2d0734295b379c099adec9b2dec8ca021c152d5ea13095fabe", + "size": 6985684, + "subdir": "linux-64", + "timestamp": 1679593761887, + "version": "3.7.1" + }, + "matplotlib-base-3.7.1-py39h417a72b_0.conda": { + "build": "py39h417a72b_0", + "build_number": 0, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "importlib_resources >=5.2.0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "numpy >=1.20", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7", + "tk >=8.6.11,<8.7", + "tk >=8.6.11,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "3e4492bad949dea9d82ec43e5e79a2c8", + "name": "matplotlib-base", + "sha256": "1d87de1184071acb31eca2c588b77a03aff54c9a1982e3adaf5d5ffbf40d4959", + "size": 6973019, + "subdir": "linux-64", + "timestamp": 1678724034563, + "version": "3.7.1" + }, + "matplotlib-base-3.7.1-py39h417a72b_1.conda": { + "build": "py39h417a72b_1", + "build_number": 1, + "depends": [ + "contourpy >=1.0.1", + "cycler >=0.10", + "fonttools >=4.22.0", + "freetype >=2.10", + "freetype >=2.10.4,<3.0a0", + "importlib_resources >=5.2.0", + "kiwisolver >=1.0.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "numpy >=1.20", + "packaging >=20.0", + "pillow >=6.2.0", + "pyparsing >=2.3.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7", + "tk >=8.6.12,<8.7", + "tk >=8.6.12,<8.7.0a0" + ], + "license": "LicenseRef-PSF-based", + "license_family": "PSF", + "md5": "ea0eb822277351efdb789f50471a87d7", + "name": "matplotlib-base", + "sha256": "1a893cb8336861590aa737728cd0c5e9231d6401fbc60e5ec095096d1a254609", + "size": 6973863, + "subdir": "linux-64", + "timestamp": 1679593695959, + "version": "3.7.1" + }, + "matplotlib-inline-0.1.6-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e859a6e0f1a83035d1b534aabc8d52cb", + "name": "matplotlib-inline", + "sha256": "b125401e787da57b7c9effb4b17e45b099c969a96d130e4e149d9df1080a8c03", + "size": 16086, + "subdir": "linux-64", + "timestamp": 1662014606193, + "version": "0.1.6" + }, + "matplotlib-inline-0.1.6-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fc4ea14c818d6b5e61d6021ffcbd4ac8", + "name": "matplotlib-inline", + "sha256": "507379fb7b1ffd204bae0a6d4fe0a6125fae5dcd127ad89f2bead3f11aecaeea", + "size": 18904, + "subdir": "linux-64", + "timestamp": 1676823852670, + "version": "0.1.6" + }, + "matplotlib-inline-0.1.6-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b49f71c4fa3357688d2c3657a1f51b2a", + "name": "matplotlib-inline", + "sha256": "4039071a21ed09fdf9c618f29d64e987cf41b3b27c548a255c43148128365717", + "size": 15882, + "subdir": "linux-64", + "timestamp": 1662014508146, + "version": "0.1.6" + }, + "matplotlib-inline-0.1.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aef017846ab77726eb2a77931b0b4059", + "name": "matplotlib-inline", + "sha256": "93fd81bc70a99bc9f08d1775099687c935f8d1a8a1dabf7841f2f21537c66854", + "size": 15971, + "subdir": "linux-64", + "timestamp": 1662014640999, + "version": "0.1.6" + }, + "matplotlib-inline-0.1.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "traitlets" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0485a63c7e4d4d8799fbf7f48449c8fb", + "name": "matplotlib-inline", + "sha256": "552f985eb72c2d34c8139a9dba5d7bff5f7f4c63bf6399dff61bd4c6d700d8e7", + "size": 15987, + "subdir": "linux-64", + "timestamp": 1662014553452, + "version": "0.1.6" + }, + "matrixprofile-1.1.10-py310h9102076_0.conda": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "protobuf >=3.11.2,<4.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f81baf5138fedaaa92af2547d8b00dfa", + "name": "matrixprofile", + "sha256": "a9f5edfc6406aaf33266ccade76a9798ecec7d58afc1e20da2ee7d3bab730b6e", + "size": 660684, + "subdir": "linux-64", + "timestamp": 1640812500855, + "version": "1.1.10" + }, + "matrixprofile-1.1.10-py36hce1f21e_0.conda": { + "build": "py36hce1f21e_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "matplotlib-base >=3.0.3", + "numpy >=1.16.6,<2.0a0", + "protobuf >=3.11.2,<4.0.0", + "python >=3.6,<3.7.0a0", + "scipy >=1.3.2,<2.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6ef7867f3eecf137d5a49fe2f14adf26", + "name": "matrixprofile", + "sha256": "e972faa6b46eb2a1439c993a260809ce17fed65f9adcdf78a7420a1348aada34", + "size": 324147, + "subdir": "linux-64", + "timestamp": 1633506374136, + "version": "1.1.10" + }, + "matrixprofile-1.1.10-py37hce1f21e_0.conda": { + "build": "py37hce1f21e_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "matplotlib-base >=3.0.3", + "numpy >=1.16.6,<2.0a0", + "protobuf >=3.11.2,<4.0.0", + "python >=3.7,<3.8.0a0", + "scipy >=1.3.2,<2.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8e16eee1bff55f525585f597e2aca589", + "name": "matrixprofile", + "sha256": "14a44f79f039fff64d7708d4a22773c538cf2a8c8b5175f241ebb2cf5969b8e1", + "size": 324688, + "subdir": "linux-64", + "timestamp": 1633506357264, + "version": "1.1.10" + }, + "matrixprofile-1.1.10-py38hce1f21e_0.conda": { + "build": "py38hce1f21e_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "matplotlib-base >=3.0.3", + "numpy >=1.16.6,<2.0a0", + "protobuf >=3.11.2,<4.0.0", + "python >=3.8,<3.9.0a0", + "scipy >=1.3.2,<2.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6457d0db74179fa09669c3b60075853b", + "name": "matrixprofile", + "sha256": "6938bce7b1dfe285ac736d3a21c555fcdedc02d4836c68bc2af72a0633f64cd3", + "size": 328617, + "subdir": "linux-64", + "timestamp": 1633506109956, + "version": "1.1.10" + }, + "matrixprofile-1.1.10-py39hce1f21e_0.conda": { + "build": "py39hce1f21e_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "matplotlib-base >=3.0.3", + "numpy >=1.16.6,<2.0a0", + "protobuf >=3.11.2,<4.0.0", + "python >=3.9,<3.10.0a0", + "scipy >=1.3.2,<2.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d45b594181e50755f748b10587900e9c", + "name": "matrixprofile", + "sha256": "663d23e4d37622d41f7cc83566b9aa3e8404b637b43847046846557d127dc705", + "size": 329546, + "subdir": "linux-64", + "timestamp": 1633506347128, + "version": "1.1.10" + }, + "maturin-0.13.7-py310h52d8a92_0.conda": { + "build": "py310h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "tomli >=1.1.0" + ], + "license": "MIT OR Apache-2.0", + "license_family": "MIT", + "md5": "a13d7fd4921493bffba489b738ed61d0", + "name": "maturin", + "sha256": "6c6915b32f9903b7ead02e2259d9a2285aa803b7597f49b77106ae0cb4c456c1", + "size": 7085638, + "subdir": "linux-64", + "timestamp": 1667960684826, + "version": "0.13.7" + }, + "maturin-0.13.7-py311h52d8a92_0.conda": { + "build": "py311h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "tomli >=1.1.0" + ], + "license": "MIT OR Apache-2.0", + "license_family": "MIT", + "md5": "c8ccbc130b71f1006559d8c4fe2ba426", + "name": "maturin", + "sha256": "ccdbbafa0704ea426b43b09f7f7f0e43cea03ba74470e0674a99e462d2cd3555", + "size": 6317747, + "subdir": "linux-64", + "timestamp": 1676844996833, + "version": "0.13.7" + }, + "maturin-0.13.7-py37h52d8a92_0.conda": { + "build": "py37h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "tomli >=1.1.0" + ], + "license": "MIT OR Apache-2.0", + "license_family": "MIT", + "md5": "a62492e80e35935f33313151fc6a0c7a", + "name": "maturin", + "sha256": "7bb495945063de44840543d26f92d31cd131c0f9f6356b03397d4e72ae36dae3", + "size": 7085409, + "subdir": "linux-64", + "timestamp": 1667960971824, + "version": "0.13.7" + }, + "maturin-0.13.7-py38h52d8a92_0.conda": { + "build": "py38h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "tomli >=1.1.0" + ], + "license": "MIT OR Apache-2.0", + "license_family": "MIT", + "md5": "29364fc452a25025fc16e2730d3df988", + "name": "maturin", + "sha256": "11549b83c8a3daa4547396f98317074495db690e19cb633e862497a2b717c468", + "size": 7080795, + "subdir": "linux-64", + "timestamp": 1667961114771, + "version": "0.13.7" + }, + "maturin-0.13.7-py39h52d8a92_0.conda": { + "build": "py39h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "tomli >=1.1.0" + ], + "license": "MIT OR Apache-2.0", + "license_family": "MIT", + "md5": "acdfff12bb11e755eb17791b2097ecae", + "name": "maturin", + "sha256": "88ac922691dfa2921c6f2a1e23e36c35c9d3d95230abd63cccd517110afdf1aa", + "size": 7080877, + "subdir": "linux-64", + "timestamp": 1667960828826, + "version": "0.13.7" + }, + "maven-3.5.3-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "openjdk" + ], + "license": "Apachev2", + "license_family": "Apache", + "md5": "41dd2393ff00e9f220205f3654c813db", + "name": "maven", + "sha256": "f915927eab2b2f590e9c76511a9ead393f550783bb41f12b6af8f66741143ff6", + "size": 8492761, + "subdir": "linux-64", + "timestamp": 1527872435202, + "version": "3.5.3" + }, + "maven-3.5.4-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "openjdk" + ], + "license": "Apachev2", + "license_family": "Apache", + "md5": "2ecd219cd5f042d727a115873b63fbb1", + "name": "maven", + "sha256": "453c155882eccd3ce7ff23bf71a6663c4f3da23c1a7fd85dd040c9ce2cbb36b9", + "size": 8535690, + "subdir": "linux-64", + "timestamp": 1539663717811, + "version": "3.5.4" + }, + "maven-3.6.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "openjdk" + ], + "license": "Apachev2", + "license_family": "Apache", + "md5": "8e65d99ed963aaa919ae27d3429e531c", + "name": "maven", + "sha256": "7d2c868eeecafb838ea6bfb26dd249ad661fb95c2eaea4a27f0d6c90e269a43a", + "size": 8765245, + "subdir": "linux-64", + "timestamp": 1542082060690, + "version": "3.6.0" + }, + "maven-3.8.1-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "openjdk" + ], + "license": "Apachev2", + "license_family": "Apache", + "md5": "87b0bed74489cbcfe0ba849248d9fb8a", + "name": "maven", + "sha256": "2bb99ac1886d7058840b5b4d09cb9c901e7b272de0e6e9933d300b7b344c4c70", + "size": 9217742, + "subdir": "linux-64", + "timestamp": 1617984199527, + "version": "3.8.1" + }, + "mayavi-4.6.2-py27hcf37d21_4.conda": { + "build": "py27hcf37d21_4", + "build_number": 4, + "depends": [ + "apptools", + "envisage", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy >=1.11.3,<2.0a0", + "pyqt >=4,<6", + "python >=2.7,<2.8.0a0", + "setuptools", + "traitsui", + "vtk 8.2.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "165e1c8ed0d9b2573955944e41f3184c", + "name": "mayavi", + "sha256": "8714fd142eecb8490e8f09f822fbc5a511a26099b991fe048db3dcfd81f68730", + "size": 13353652, + "subdir": "linux-64", + "timestamp": 1558738741740, + "version": "4.6.2" + }, + "mayavi-4.6.2-py36hcf37d21_4.conda": { + "build": "py36hcf37d21_4", + "build_number": 4, + "depends": [ + "apptools", + "envisage", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy >=1.11.3,<2.0a0", + "pyqt >=4,<6", + "python >=3.6,<3.7.0a0", + "setuptools", + "traitsui", + "vtk 8.2.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1301b2aef866c8a2dd27b714f4e3a52f", + "name": "mayavi", + "sha256": "42080bdf4edf13aa9e4335336dbedb31943bd5059083a8fb6a8903a52768ba89", + "size": 13336369, + "subdir": "linux-64", + "timestamp": 1559060934784, + "version": "4.6.2" + }, + "mayavi-4.6.2-py37hcf37d21_4.conda": { + "build": "py37hcf37d21_4", + "build_number": 4, + "depends": [ + "apptools", + "envisage", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy >=1.11.3,<2.0a0", + "pyqt >=4,<6", + "python >=3.7,<3.8.0a0", + "setuptools", + "traitsui", + "vtk 8.2.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f17709c184a1952397f11f42006a7020", + "name": "mayavi", + "sha256": "a827e848d75302e7973fdc28cf4eeee163247cc0bd4b115aa9ea6707ae48141d", + "size": 13206372, + "subdir": "linux-64", + "timestamp": 1559061022718, + "version": "4.6.2" + }, + "mayavi-4.7.1-py36h94891b3_2.conda": { + "build": "py36h94891b3_2", + "build_number": 2, + "depends": [ + "apptools", + "envisage", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy >=1.14.6,<2.0a0", + "pyqt >=4,<6", + "python >=3.6,<3.7.0a0", + "setuptools", + "traitsui", + "vtk 8.2.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "52bfb76dd13f5bd9fc47354326e5ea7c", + "name": "mayavi", + "sha256": "9c8283dac714bd0cbc5c43fe9e03831019f2cb449d82ea72dbb3a91cd3e6daf8", + "size": 13389614, + "subdir": "linux-64", + "timestamp": 1585309539589, + "version": "4.7.1" + }, + "mayavi-4.7.1-py37h94891b3_2.conda": { + "build": "py37h94891b3_2", + "build_number": 2, + "depends": [ + "apptools", + "envisage", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy >=1.14.6,<2.0a0", + "pyqt >=4,<6", + "python >=3.7,<3.8.0a0", + "setuptools", + "traitsui", + "vtk 8.2.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "80147243039fce50b78791c20b3ba820", + "name": "mayavi", + "sha256": "95f279e455ec7cdd21914df5bc0ec4fc19ed688b78a9c093a48ee170a6e4f7e5", + "size": 13261061, + "subdir": "linux-64", + "timestamp": 1585309542336, + "version": "4.7.1" + }, + "mccabe-0.6.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "181d832c60bdcaca655155713e09e86e", + "name": "mccabe", + "sha256": "24ce39e4ed3802d1032048e32578d9ecad8a250864eed0bc7422aeb943b444b6", + "size": 14420, + "subdir": "linux-64", + "timestamp": 1530812495236, + "version": "0.6.1" + }, + "mccabe-0.6.1-py27h0e7c7be_1.conda": { + "build": "py27h0e7c7be_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc38ac2a0e78d6b5d6cff6a7ae6b3596", + "name": "mccabe", + "sha256": "b8390290e246ed05e065f34a49387fb4160aa421f22ad5b9c8df6c4048b1f726", + "size": 13979, + "subdir": "linux-64", + "timestamp": 1505743111077, + "version": "0.6.1" + }, + "mccabe-0.6.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "504146ec147c751d1c916a7bfdbaea57", + "name": "mccabe", + "sha256": "4e54c371f7937bb9d7894340d61b460ef0c1a87709d20a17758e15602582ea43", + "size": 14843, + "subdir": "linux-64", + "timestamp": 1640806440553, + "version": "0.6.1" + }, + "mccabe-0.6.1-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4bf31a976bbca5bddeb2306c820f51b0", + "name": "mccabe", + "sha256": "782d58ee3cfc8bdf5abe73f3029357bd22779a8d650214926ec33277983172fc", + "size": 15609, + "subdir": "linux-64", + "timestamp": 1659535422117, + "version": "0.6.1" + }, + "mccabe-0.6.1-py311h06a4308_2.conda": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d531ad61fb1462a3670658583f0e787b", + "name": "mccabe", + "sha256": "ada92684bdd50db55a7830da08f30b229f066dc761f323e740f903fa1af87c59", + "size": 18301, + "subdir": "linux-64", + "timestamp": 1676825304938, + "version": "0.6.1" + }, + "mccabe-0.6.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "68ae200933648d5f0ee397aafd1ad8e8", + "name": "mccabe", + "sha256": "5b329f0b6fa13ad017d5a7accfb186c56003cfa251887d540c83daea92bca621", + "size": 14635, + "subdir": "linux-64", + "timestamp": 1535130107791, + "version": "0.6.1" + }, + "mccabe-0.6.1-py35hd8c1f23_1.conda": { + "build": "py35hd8c1f23_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e1582c2aa439a1b67663ddb8764dc68", + "name": "mccabe", + "sha256": "86be5136bbd10204c8f2c31d0a21653f633db4cae306524f4ca2e85c54039632", + "size": 14248, + "subdir": "linux-64", + "timestamp": 1505743122954, + "version": "0.6.1" + }, + "mccabe-0.6.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa7803897ff9266dc51bc97dd0c5b4a7", + "name": "mccabe", + "sha256": "5c72e85a67a8ce08e24ed2193442bbc093b3a9470cd8158fc998fbc738a9555e", + "size": 14439, + "subdir": "linux-64", + "timestamp": 1530812545198, + "version": "0.6.1" + }, + "mccabe-0.6.1-py36h5ad9710_1.conda": { + "build": "py36h5ad9710_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3614776ce60908e16a7ca929a7926335", + "name": "mccabe", + "sha256": "9d79e1325d9586a24eaa92e03aa706264ac2a1cb3ec636b4f3ae5ffb5aabb518", + "size": 14177, + "subdir": "linux-64", + "timestamp": 1505743134933, + "version": "0.6.1" + }, + "mccabe-0.6.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c12d643fcdd833be4b997b28c3484e41", + "name": "mccabe", + "sha256": "82efa955b2fd13f9830d6750556a23f56877cb97059c87a6f1d90f6fc8c297e7", + "size": 14472, + "subdir": "linux-64", + "timestamp": 1530812519822, + "version": "0.6.1" + }, + "mccabe-0.6.1-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc0778331f210ad1849124d4810b9fa0", + "name": "mccabe", + "sha256": "fb68f7b735e928c1258bb3d3c5603f7c88bf6f99ce2c45746552e0827424da1d", + "size": 15457, + "subdir": "linux-64", + "timestamp": 1659535455073, + "version": "0.6.1" + }, + "mccabe-0.6.1-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5dec11e3e49e564e6c3a50877767444e", + "name": "mccabe", + "sha256": "3349b74a44d698b5a1f8444c19710df4529497581056c1ccc75c27418413ad15", + "size": 14957, + "subdir": "linux-64", + "timestamp": 1573489052083, + "version": "0.6.1" + }, + "mccabe-0.6.1-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b1968424117a98c348faa6c55852e2f", + "name": "mccabe", + "sha256": "c904f60c035542d3269abba8d1d8becbfb6af4da0f198d57bb66d315c7883695", + "size": 15465, + "subdir": "linux-64", + "timestamp": 1659535520351, + "version": "0.6.1" + }, + "mccabe-0.6.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08d5aa6b770235d869e4f53215d67dbe", + "name": "mccabe", + "sha256": "21c048c78596a490ab914459092c42e810d7fa08330c689cb63cb467cf0d7bcd", + "size": 16384, + "subdir": "linux-64", + "timestamp": 1607574091060, + "version": "0.6.1" + }, + "mccabe-0.6.1-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f56d4d3dcec58a6edcba1dc7f5aa5ec", + "name": "mccabe", + "sha256": "39353f2a03062be0e64aebc4568ca3427767f30e2d69d9ac67dd03bdcc16f203", + "size": 15466, + "subdir": "linux-64", + "timestamp": 1659535487366, + "version": "0.6.1" + }, + "mdit-py-plugins-0.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "markdown-it-py >=1.0.0,<3.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e272858511c76ea58620f4c5b54dad3b", + "name": "mdit-py-plugins", + "sha256": "8cf83b57ce58e9491a4eadd05f9cd9a7f5eab8845cf03d0b97d3583241a43cfb", + "size": 53356, + "subdir": "linux-64", + "timestamp": 1659721352029, + "version": "0.3.0" + }, + "mdit-py-plugins-0.3.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "markdown-it-py >=1.0.0,<3.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0989e99327943faada572af330c6280d", + "name": "mdit-py-plugins", + "sha256": "b591c7968749ff589125a07873f2d6a833a043e2a0556b083128a9bb590d3399", + "size": 67989, + "subdir": "linux-64", + "timestamp": 1676837123613, + "version": "0.3.0" + }, + "mdit-py-plugins-0.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "markdown-it-py >=1.0.0,<3.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eaf00e0e93f4b3e33766b3f0689abba9", + "name": "mdit-py-plugins", + "sha256": "fe40f069e4851d0d0b2dd36ee1db52f43b400c57b088a962014bf0fac9e8a294", + "size": 52877, + "subdir": "linux-64", + "timestamp": 1659721281803, + "version": "0.3.0" + }, + "mdit-py-plugins-0.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "markdown-it-py >=1.0.0,<3.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e20b6ee7c79a4508c754a3fff7097fe2", + "name": "mdit-py-plugins", + "sha256": "16592c4a813032ef1c18dfb992249087504f8677cd085ee28115ffe16f5bfad0", + "size": 53007, + "subdir": "linux-64", + "timestamp": 1659721378603, + "version": "0.3.0" + }, + "mdit-py-plugins-0.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "markdown-it-py >=1.0.0,<3.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "153c84daf9e345cb0b4c9f0dcb6e3b7d", + "name": "mdit-py-plugins", + "sha256": "29328dbc3af9f86a5f0c314d90fc94a61b427f6e9a2dcbfe19d0b49383365d46", + "size": 52880, + "subdir": "linux-64", + "timestamp": 1659721312521, + "version": "0.3.0" + }, + "mdp-3.5-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "7335c875a3166832741be87f3d5796c3", + "name": "mdp", + "sha256": "6c7c2ec4a4d4b6fa536fab0f69a1a5d0a047297c6cd9a8509b2d7b41c78ad594", + "size": 488436, + "subdir": "linux-64", + "timestamp": 1537208279158, + "version": "3.5" + }, + "mdp-3.5-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "14dd6ba4735f0e4e7b32b7cfbb90f04a", + "name": "mdp", + "sha256": "bdd5f3221b465d3c53e60930933e5e0701d65508e5dd95878758fd7469123524", + "size": 506103, + "subdir": "linux-64", + "timestamp": 1640809525117, + "version": "3.5" + }, + "mdp-3.5-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "759bbcf7c7f36820c09e48bbabf95e85", + "name": "mdp", + "sha256": "3a8fa5f210a726d277303c3684595df6615ce611fa05bbe0bf829e2bdaedfb12", + "size": 506866, + "subdir": "linux-64", + "timestamp": 1537208300788, + "version": "3.5" + }, + "mdp-3.5-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "c7a32ed9b145457e9b87e27ce0f98909", + "name": "mdp", + "sha256": "5a9254f593acc92a1a7455e9873a074a7cdaec31f15fcf63a6f913bc082f9dd8", + "size": 502056, + "subdir": "linux-64", + "timestamp": 1537208304936, + "version": "3.5" + }, + "mdp-3.5-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "81432d393980d5ed416051d8b47c0de8", + "name": "mdp", + "sha256": "e2df9489e876db2254297f955f543580d311ecbaba4bfc1fa5e01b423338924f", + "size": 736278, + "subdir": "linux-64", + "timestamp": 1614009641098, + "version": "3.5" + }, + "mdp-3.5-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "804e77f8f68534f4c75742e5077af8af", + "name": "mdp", + "sha256": "00593d32644b2c08e178227ad390dfe6c1bcb70ed8b997509001ee115351a415", + "size": 495330, + "subdir": "linux-64", + "timestamp": 1537208214061, + "version": "3.5" + }, + "mdp-3.5-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "952f43790a5fe492aff1f9f83bb406f1", + "name": "mdp", + "sha256": "3362bc510c7e786ecf41384e28deddb9b5edd7f6a25211ed813c010ae37d18fc", + "size": 736545, + "subdir": "linux-64", + "timestamp": 1614009639231, + "version": "3.5" + }, + "mdp-3.5-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "91df2db72fa2dd8d9c9e03a4fed5f583", + "name": "mdp", + "sha256": "f5d8a5610829fbfd99dcb6f8281fffeaa964c6d9d1f29652771e3306d9f11ad7", + "size": 503065, + "subdir": "linux-64", + "timestamp": 1573469741875, + "version": "3.5" + }, + "mdp-3.5-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "e85316cbffc35649a356f1bb6e7e16cd", + "name": "mdp", + "sha256": "f3e09e8c884bdfee44430130cde36d888a47d9faf4a65056d8f015b8aa791e5b", + "size": 739251, + "subdir": "linux-64", + "timestamp": 1614009656298, + "version": "3.5" + }, + "mdp-3.5-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "future", + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "68ae7ec2b7843facf5e42b7d3f4b121f", + "name": "mdp", + "sha256": "734eddaebaeb2a36fcb37abcad14a54a3e80b6b97e06e02b8cddaae635117799", + "size": 744063, + "subdir": "linux-64", + "timestamp": 1614009618492, + "version": "3.5" + }, + "mdurl-0.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f1edd5cb1c88f35898cacb0308ac709", + "name": "mdurl", + "sha256": "ec6c4866d8463004450f3dee0853ee1889c31b7ac8928a20eaccefeb0816f2b1", + "size": 18391, + "subdir": "linux-64", + "timestamp": 1659716070293, + "version": "0.1.0" + }, + "mdurl-0.1.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "badfb1169478a26f76119f434b62b8c2", + "name": "mdurl", + "sha256": "02e9c49607d5ff87b4736315877268dfca422872695edf0ead999e2752615f62", + "size": 22743, + "subdir": "linux-64", + "timestamp": 1676827301164, + "version": "0.1.0" + }, + "mdurl-0.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "00a456768d23dd9268af1012383605b5", + "name": "mdurl", + "sha256": "c1d80a9bea03b99fee1d33ac4aead980e6a2dd6b7a0a2aeb8416dfc54a30c014", + "size": 18404, + "subdir": "linux-64", + "timestamp": 1659716142364, + "version": "0.1.0" + }, + "mdurl-0.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "69312410e814f0bff66c43199238b373", + "name": "mdurl", + "sha256": "5e23ce74fb59c0792ad736bb1a7f28302e24f14a7ebd06bf08530e09d956f8d1", + "size": 18401, + "subdir": "linux-64", + "timestamp": 1659716119261, + "version": "0.1.0" + }, + "mdurl-0.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4b648c8cb1fc9a37cf4bf3feb13c2db0", + "name": "mdurl", + "sha256": "8c5e0d27dbd580950ac13055c2650678f192ba56b637641cbd614764572c0949", + "size": 18385, + "subdir": "linux-64", + "timestamp": 1659716096534, + "version": "0.1.0" + }, + "meld3-1.0.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "b2a86f8491c0f215fa4dad5a1d7f21f3", + "name": "meld3", + "sha256": "2bc313a39120d01ef5842c6f4ab5523e20e729c7ef2786a0edf94f6cb09b8ea4", + "size": 46934, + "subdir": "linux-64", + "timestamp": 1537208770426, + "version": "1.0.2" + }, + "meld3-1.0.2-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "aab34117bbfedb75afb0475f02400c06", + "name": "meld3", + "sha256": "8613ae3461050d85b277bc10f510769e430cf8fe52751c84b80dccdd78250a85", + "size": 47572, + "subdir": "linux-64", + "timestamp": 1537208804028, + "version": "1.0.2" + }, + "meld3-1.0.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "db185f9f67bf9042a230f39aca782758", + "name": "meld3", + "sha256": "440b39269a3ed0481e17d0325a84d93c5830be612521b0dbc6ae253005c8fa64", + "size": 47014, + "subdir": "linux-64", + "timestamp": 1537208794172, + "version": "1.0.2" + }, + "meld3-1.0.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "eeb4a8663ae2abc195734f4936fff016", + "name": "meld3", + "sha256": "34a898072466d68304e2ca554fba994caf7cc664ba724ebddd3220a2539bed74", + "size": 46987, + "subdir": "linux-64", + "timestamp": 1537208718025, + "version": "1.0.2" + }, + "memory_profiler-0.47-py27hd3766c3_0.conda": { + "build": "py27hd3766c3_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8ba403624885af91dfd1a83e93966d21", + "name": "memory_profiler", + "sha256": "caf6031b9d82a80d21decaae735d91f8aa3e885cd84ecfbb8a4eb59711f77912", + "size": 38480, + "subdir": "linux-64", + "timestamp": 1508439461142, + "version": "0.47" + }, + "memory_profiler-0.47-py35hadf4a1a_0.conda": { + "build": "py35hadf4a1a_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9629719922ee74d35e115021bcefeb0c", + "name": "memory_profiler", + "sha256": "47a83a0b22ab34917ef9e2d91316629699acb15f36fc8ea400b82714f9871927", + "size": 39055, + "subdir": "linux-64", + "timestamp": 1508439456096, + "version": "0.47" + }, + "memory_profiler-0.47-py36hfa32046_0.conda": { + "build": "py36hfa32046_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "529b26f7fb12009c2ce25a5aa142ee4a", + "name": "memory_profiler", + "sha256": "8e5d6fb01e97dd07cceb3be0d6ada1d1fd52809903004d1071aa86e452225c18", + "size": 38668, + "subdir": "linux-64", + "timestamp": 1508439454332, + "version": "0.47" + }, + "memory_profiler-0.52.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9cf23581e0cdbd181956ee19da537707", + "name": "memory_profiler", + "sha256": "b897f4b0cbd85e908ac193d673948a62d92364bc9ff0535636bc907245c73f88", + "size": 40015, + "subdir": "linux-64", + "timestamp": 1519671808089, + "version": "0.52.0" + }, + "memory_profiler-0.52.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4592a9ab3d74d11a6bf157cc9e976424", + "name": "memory_profiler", + "sha256": "a86fb23aef1c007af5c365ba28658701eb2785fb3f9ce76ff67c0b0e48ca752b", + "size": 40085, + "subdir": "linux-64", + "timestamp": 1519671867540, + "version": "0.52.0" + }, + "memory_profiler-0.52.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1593ca6a07a4be151252743e01b4ef9a", + "name": "memory_profiler", + "sha256": "7a9f79e64e381f13c1a1a3350d55f7675bba9f2695487d6452d6f0a8e0d843a7", + "size": 39631, + "subdir": "linux-64", + "timestamp": 1519671852307, + "version": "0.52.0" + }, + "memory_profiler-0.52.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "43925f172e892915a5cb19da61aab953", + "name": "memory_profiler", + "sha256": "13bb1063b74e0a2a937561ecd7764026e4db6b694d23ccfee13e8e68ceefaa4e", + "size": 39775, + "subdir": "linux-64", + "timestamp": 1530899160650, + "version": "0.52.0" + }, + "memory_profiler-0.54.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "91dab9d694ac604395ffc06b83ea25a5", + "name": "memory_profiler", + "sha256": "f85a055f0b867a7ff9c052bbb92feb8d603d1e2ce0a60015ff958e9f08d11e55", + "size": 45873, + "subdir": "linux-64", + "timestamp": 1535498533597, + "version": "0.54.0" + }, + "memory_profiler-0.54.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bde1cbe050ed9e4ba78ab28826976b90", + "name": "memory_profiler", + "sha256": "95f3bf2b72c1a74c8268577b436a4abeed7cce61f6fb151f161886fa2a46c3e6", + "size": 46288, + "subdir": "linux-64", + "timestamp": 1535498555179, + "version": "0.54.0" + }, + "memory_profiler-0.54.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "be22841d2d8d567f256e1c11e9a2f029", + "name": "memory_profiler", + "sha256": "089006d9bf7499c4024350ce8a1459bc6a1a6162b822c83c05da0391c6366033", + "size": 46207, + "subdir": "linux-64", + "timestamp": 1535498519280, + "version": "0.54.0" + }, + "memory_profiler-0.54.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "03fffaec5d0c70e18de4e65b8a2fdbce", + "name": "memory_profiler", + "sha256": "d496b3d9f111910746442a9a4ada6972b8e8ce585e8cac2223937ec1435f6047", + "size": 45843, + "subdir": "linux-64", + "timestamp": 1535498561632, + "version": "0.54.0" + }, + "memory_profiler-0.55.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "67c87cfef16cb14811a64f4e49ede9a3", + "name": "memory_profiler", + "sha256": "d82fd225c92e4371200a2828e81f9d2bdac29dc8765da3654ac868f8ea886269", + "size": 48276, + "subdir": "linux-64", + "timestamp": 1545113182771, + "version": "0.55.0" + }, + "memory_profiler-0.55.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4aba2ff68decc9a771d6f1e9cfea3841", + "name": "memory_profiler", + "sha256": "3078868934c1bd15a44b01ee48a35b98b8bd284a97701d26262a38325a384932", + "size": 47778, + "subdir": "linux-64", + "timestamp": 1545113216388, + "version": "0.55.0" + }, + "memory_profiler-0.55.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "46b4ab28eb3f83041389cbf23503d3dd", + "name": "memory_profiler", + "sha256": "4ea2e25b78cbb57bf4c27ef22683244bd5b26e640163efb82e04a3d1823c883e", + "size": 47815, + "subdir": "linux-64", + "timestamp": 1545113185921, + "version": "0.55.0" + }, + "mercurial-4.3.3-py27h31da970_0.conda": { + "build": "py27h31da970_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "05d92c92fcffad2ffb525962e15f4314", + "name": "mercurial", + "sha256": "92eecd5f77f6a76e04152af4b653acb03017b4aab6a02843114ebd6245aac847", + "size": 2311139, + "subdir": "linux-64", + "timestamp": 1508506951099, + "version": "4.3.3" + }, + "mercurial-4.5-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "905f8a33eac7bbd5c1b40061c34d631c", + "name": "mercurial", + "sha256": "cf221d3ba6dfcf56e92bd17a942c10816c264df2ba7b63d26ec3ba5cdd3a65be", + "size": 2463185, + "subdir": "linux-64", + "timestamp": 1519147402240, + "version": "4.5" + }, + "mercurial-4.5.2-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "8df6a6241b1a1fe01bcc4493dca69c8c", + "name": "mercurial", + "sha256": "b636cc3448aeb288ab9960b9380eb32d90dff6cfec3ccaebc48e624de52540ea", + "size": 3377733, + "subdir": "linux-64", + "timestamp": 1522800370654, + "version": "4.5.2" + }, + "mercurial-4.5.3-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "aa7aa1649ba1da191df53c39d4109953", + "name": "mercurial", + "sha256": "b3996069799b6c8d04a3358a04adf59748be5ac6fb56b5c837f75bea3bcd338d", + "size": 3380266, + "subdir": "linux-64", + "timestamp": 1524159687770, + "version": "4.5.3" + }, + "mercurial-4.6-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "0cf8d0be2837f0c7a5feb6642c1d5d35", + "name": "mercurial", + "sha256": "5dc459ac71b845cbf435bd65155732e25c94a6f602e90141278841c1252d613f", + "size": 3738309, + "subdir": "linux-64", + "timestamp": 1527691667533, + "version": "4.6" + }, + "mercurial-4.6.1-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "235195646ea7ecb2946dfb5e8479a490", + "name": "mercurial", + "sha256": "4a0c06415acc0e3aaf4b419ffd6e1b02e24ad0414aefa0d465972588edf9dcec", + "size": 3745619, + "subdir": "linux-64", + "timestamp": 1529969537311, + "version": "4.6.1" + }, + "mercurial-4.6.2-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "9b41b880fafba7d44be519aa2b4598e7", + "name": "mercurial", + "sha256": "879d761e242a447fcb1d7014a8ac08dd20ad12c56062ea7c7ee9cb07ca0c90e2", + "size": 3762511, + "subdir": "linux-64", + "timestamp": 1532856519941, + "version": "4.6.2" + }, + "mercurial-4.7-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "0b26a1f22b56ecb80c4fe22d04fccd89", + "name": "mercurial", + "sha256": "61fb42ca9da65c210f0d367e89929dedae58c46966893345676c219ea109ae92", + "size": 3791282, + "subdir": "linux-64", + "timestamp": 1534830078787, + "version": "4.7" + }, + "mercurial-4.7.2-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "1fea27efbfb15ea0b850393857bb9873", + "name": "mercurial", + "sha256": "642357a1cdb14d2a9b1d87490d9b4009d2dbb80c642aed4a2294b4cdee163374", + "size": 3782433, + "subdir": "linux-64", + "timestamp": 1540059284865, + "version": "4.7.2" + }, + "mercurial-4.8.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "f0d337fd619f6ef41eb61dbce6496346", + "name": "mercurial", + "sha256": "eefd34067c1e611f00ec5f8f18fd9c8d9e0444b0eb45d5eefbe09190f5fbea4f", + "size": 4015657, + "subdir": "linux-64", + "timestamp": 1547237942056, + "version": "4.8.1" + }, + "mercurial-4.8.2-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "pygments", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL2", + "md5": "7aeeb7e0c834020ec7a2d0a55ae1bfe9", + "name": "mercurial", + "sha256": "b9a74faf95d8954dfdba3f3f1f66ec1d742c64ef0f4c095446b72c6da8e1fb45", + "size": 4016491, + "subdir": "linux-64", + "timestamp": 1547751410839, + "version": "4.8.2" + }, + "meson-0.45.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2", + "md5": "bc7535bb91101730a2562a175f13c76b", + "name": "meson", + "sha256": "c45361fa27478bc56de2dbe22f5716589ec65aa4873ba9b1f45f19c44580ad6c", + "size": 498458, + "subdir": "linux-64", + "timestamp": 1522872874103, + "version": "0.45.0" + }, + "meson-0.45.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "82e3713e14de3e0e4e08070924a44bef", + "name": "meson", + "sha256": "7a32ee06224bdd6c019e51a9c43c20ad1aea7d4e8c55cce84e22999fd436adf2", + "size": 497265, + "subdir": "linux-64", + "timestamp": 1522872899590, + "version": "0.45.0" + }, + "meson-0.46.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2", + "md5": "ade3e87a73c80604420d525bc925b50d", + "name": "meson", + "sha256": "ea6fb55eecedc21725640b5f9f48888f6354a0686c48e104c35069cccb4684b8", + "size": 534583, + "subdir": "linux-64", + "timestamp": 1528216393128, + "version": "0.46.1" + }, + "meson-0.46.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "3bda734a56750cf1e68042e94c3f5c49", + "name": "meson", + "sha256": "9bcb557530e829ed1d3fd0120a0d005a3553f8e40fce2a85c3e4e54239db8bd5", + "size": 528118, + "subdir": "linux-64", + "timestamp": 1528216372315, + "version": "0.46.1" + }, + "meson-0.46.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2", + "md5": "748a4512452df232fd7d4f35448e1edb", + "name": "meson", + "sha256": "a1561fd9cf8862cbb6b52d2a8cafabded5ae5d8a1657f2a355fcd59ae192b712", + "size": 528631, + "subdir": "linux-64", + "timestamp": 1530899197589, + "version": "0.46.1" + }, + "meson-0.47.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2", + "md5": "4ae19d9346c797146189436a9f9537c4", + "name": "meson", + "sha256": "2cce090d096dee1b9e7002c1bbb3022b412243523af546e3dfed03a269a28722", + "size": 564123, + "subdir": "linux-64", + "timestamp": 1532528336807, + "version": "0.47.1" + }, + "meson-0.47.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "7d209b87616f76a51acd34d1b0941b51", + "name": "meson", + "sha256": "6f309a67d1210e714ee530dbf5b499bd45fd0f67556e06da5be5dfbac29cf396", + "size": 552159, + "subdir": "linux-64", + "timestamp": 1532528265909, + "version": "0.47.1" + }, + "meson-0.47.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2", + "md5": "bdd3ec7062a3a2a1513db9b9c4daf613", + "name": "meson", + "sha256": "0af6025c19099a33b08866b0dcc1440e5272fbe00445981d2c92eac018337151", + "size": 558431, + "subdir": "linux-64", + "timestamp": 1532528335766, + "version": "0.47.1" + }, + "meson-0.47.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2", + "md5": "007b5468e19b69ece0124123bd55b49e", + "name": "meson", + "sha256": "5871504f899842a6d582e54971b1500354687b4899f9f4a19a96e398c811d698", + "size": 571568, + "subdir": "linux-64", + "timestamp": 1535385372100, + "version": "0.47.2" + }, + "meson-0.47.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "47c0c44c45dbcf0f071dfbfd8ccb8367", + "name": "meson", + "sha256": "6bcb448682ff94b5fdf9ba91fb3064dc15d443bda1021bc7af326ab9ef65a970", + "size": 569478, + "subdir": "linux-64", + "timestamp": 1535385185959, + "version": "0.47.2" + }, + "meson-0.47.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2", + "md5": "b59b5cb0fa727babfcfe42f8497d94cf", + "name": "meson", + "sha256": "5075fabb79ccfe1f0d334116655238793fc9a92f2e0b2183c7bc3c3ac5e5b76f", + "size": 565353, + "subdir": "linux-64", + "timestamp": 1535385212641, + "version": "0.47.2" + }, + "meson-0.48.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2", + "md5": "731b99ea70ac4ae4496b738ff8b48813", + "name": "meson", + "sha256": "d0924cd1c377cb3fcbf32cf0abb88a65b24f79228ad276bba2fab7d4e0631d0b", + "size": 603194, + "subdir": "linux-64", + "timestamp": 1538232401475, + "version": "0.48.0" + }, + "meson-0.48.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "73a590c47cc7410524a34e90ac209435", + "name": "meson", + "sha256": "84a7dbd93053a024f7bdbd73352600b6826446ac5aa1c8e35bad886eac472e86", + "size": 590125, + "subdir": "linux-64", + "timestamp": 1538232404877, + "version": "0.48.0" + }, + "meson-0.48.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2", + "md5": "a3b2c9a56655e81acd4abc5c362fbbdd", + "name": "meson", + "sha256": "c0291129e2a1d441b21cbefc889dfba235382a08a81557a49e6f33b544a0d4e6", + "size": 595638, + "subdir": "linux-64", + "timestamp": 1538232360479, + "version": "0.48.0" + }, + "meson-0.48.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "4a0659a4d6b00ca44607771bd2371966", + "name": "meson", + "sha256": "75f722dc993ccd061c76528ff4311b6fab06b10a99781862332f0896196c50fa", + "size": 594642, + "subdir": "linux-64", + "timestamp": 1540238468859, + "version": "0.48.1" + }, + "meson-0.48.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2", + "md5": "c2c15b28057145884ae57e3f5229f104", + "name": "meson", + "sha256": "baf6c7ab71a2fff755b8d96a03b6c0a65dbd1354eae62a712de7e06ba28b09dc", + "size": 595590, + "subdir": "linux-64", + "timestamp": 1540238463787, + "version": "0.48.1" + }, + "meson-0.48.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "9fbeb5cc59e70a57d836f47242a67ba9", + "name": "meson", + "sha256": "1acae710f196195d6b8543fff313780aaaf6a319f0cc1ecee1ce4a07dcb99cca", + "size": 600155, + "subdir": "linux-64", + "timestamp": 1542082294961, + "version": "0.48.2" + }, + "meson-0.48.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2", + "md5": "2bb6e97fd3d8d426d64c544976590575", + "name": "meson", + "sha256": "c86ad32349d3534ff688bd676136ceb8c866eeb07394072707be0fcdea9c1432", + "size": 600349, + "subdir": "linux-64", + "timestamp": 1542082285817, + "version": "0.48.2" + }, + "meson-0.49.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "a0989cc48481bcfb07ae848fa0978fa0", + "name": "meson", + "sha256": "fe5deb80b4403edf8e5c6c3549cfb9b7994a78528272306ae6a1dad5f3e7a237", + "size": 635814, + "subdir": "linux-64", + "timestamp": 1545081672239, + "version": "0.49.0" + }, + "meson-0.49.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2", + "md5": "c7acb8a641e7c58542f457b78c002e37", + "name": "meson", + "sha256": "28ba03a847c808b4ee13b80686df5c8eb035f313311ae8bec349c6bf9fbc43c6", + "size": 636534, + "subdir": "linux-64", + "timestamp": 1545081656729, + "version": "0.49.0" + }, + "meson-0.49.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "aa4819c674f6f6615de9a5e324f7c6e0", + "name": "meson", + "sha256": "b280de8863cd5599496b38e93acb0ebc2f85be2921d0bc71430a2664bf041e41", + "size": 637115, + "subdir": "linux-64", + "timestamp": 1549332119027, + "version": "0.49.1" + }, + "meson-0.49.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2", + "md5": "a27f8c7dd5dbc4caf7d4e5082beea602", + "name": "meson", + "sha256": "45de5f20fbc056fa6f9eee1a520261493225b513d45123f5de8fa118fa14d700", + "size": 643661, + "subdir": "linux-64", + "timestamp": 1549332069191, + "version": "0.49.1" + }, + "meson-0.49.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2", + "md5": "d8f59290a80acfae975c2998fcf38919", + "name": "meson", + "sha256": "315740cceae10216ae49129c9404ccdfd02317e9327b8d14c6b29624c42bf7d6", + "size": 638975, + "subdir": "linux-64", + "timestamp": 1551142307637, + "version": "0.49.2" + }, + "meson-0.49.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2", + "md5": "21006256a72ce7f2205925e7be5c01f4", + "name": "meson", + "sha256": "715ae5b9134a2a005ac16ba3ca54b705924203b7dc298489981ce75dca72b62b", + "size": 639858, + "subdir": "linux-64", + "timestamp": 1551142278033, + "version": "0.49.2" + }, + "meson-0.62.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "294e99a51a1ea5a3bc61a8e29ea3be74", + "name": "meson", + "sha256": "3269b5b909e827ffd7452e881b1459d39bfab8347e514955c72707d7154417dd", + "size": 1249111, + "subdir": "linux-64", + "timestamp": 1660064925161, + "version": "0.62.2" + }, + "meson-0.62.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7cfdbceaf2f8ecbab746df7fecc2cded", + "name": "meson", + "sha256": "a4989b5b4310f7e1053a0e41affa4029c1f985f8a82de8a33897ba16dc08deb3", + "size": 1732283, + "subdir": "linux-64", + "timestamp": 1676823379006, + "version": "0.62.2" + }, + "meson-0.62.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9b36bae1b8cf5a985cec818ec5db946e", + "name": "meson", + "sha256": "9bdb260cbeb1d2a8843b3485656368b9e306b36289566e7ca4eb20255832db7f", + "size": 1227912, + "subdir": "linux-64", + "timestamp": 1660064957947, + "version": "0.62.2" + }, + "meson-0.62.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0996aca9165d489b0f870f44f30cffcf", + "name": "meson", + "sha256": "8a6f73c414fe27badb023f1d0b53a8b476fb0819e9c2e2153591986cb5a819d1", + "size": 1234788, + "subdir": "linux-64", + "timestamp": 1660064990525, + "version": "0.62.2" + }, + "meson-0.62.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "be36ce43263b4dad1c8152ae4f0fba33", + "name": "meson", + "sha256": "4d7eaffe6adb1babe6bd0149dc2e6f40f38a5668a4a2c3b91ad981f270fbf21e", + "size": 1233777, + "subdir": "linux-64", + "timestamp": 1660064879188, + "version": "0.62.2" + }, + "meson-0.64.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ff43bdb79d6490985915269b11935195", + "name": "meson", + "sha256": "aba1be7de8e0d868906e6ad7d1d2b83089b14af4c74e45fd9a81b9e92d8f4035", + "size": 1388093, + "subdir": "linux-64", + "timestamp": 1674658514361, + "version": "0.64.1" + }, + "meson-0.64.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "619d01d1e5623176ea33fb5db98e628c", + "name": "meson", + "sha256": "d1cca734794fdf34152ece0b6327b8c1c90c3a9ced6237d9460acbacd1bdf05d", + "size": 1359214, + "subdir": "linux-64", + "timestamp": 1674658545766, + "version": "0.64.1" + }, + "meson-0.64.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d33e97a9c66893c69cd81cc2404d145d", + "name": "meson", + "sha256": "11972f50202dbaf60ebf2a62f1c16472e41c2fe65e11364b2903d399ae5b4b35", + "size": 1370290, + "subdir": "linux-64", + "timestamp": 1674658577091, + "version": "0.64.1" + }, + "meson-0.64.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "73e502d248f845bf2196b81834bf9471", + "name": "meson", + "sha256": "70db1a72ecb2c4db1e81d461a574de28deed2cfe3ef44e0abfe4bdacb70447f8", + "size": 1365294, + "subdir": "linux-64", + "timestamp": 1674658608487, + "version": "0.64.1" + }, + "meson-1.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "pip", + "python >=3.10,<3.11.0a0", + "setuptools", + "wheel" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "54e39c2433b22f43fea83bac7222817f", + "name": "meson", + "sha256": "c41399d72ca337d792a7318af19fc209960258bf393b88875796ce1d7693cb29", + "size": 1402825, + "subdir": "linux-64", + "timestamp": 1678870616695, + "version": "1.0.1" + }, + "meson-1.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "pip", + "python >=3.11,<3.12.0a0", + "setuptools", + "wheel" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ebf764b9f02ee3fde079615e353e10ac", + "name": "meson", + "sha256": "bbde87d2694f7972cc461c4d01c74e25d9ca5f89627349321c3e57bbff82bf45", + "size": 1782405, + "subdir": "linux-64", + "timestamp": 1679336653730, + "version": "1.0.1" + }, + "meson-1.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "pip", + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ca2a5c3909bf0fdb271773aae78f1b8f", + "name": "meson", + "sha256": "89e15f344da03a7f457450e3ec8ea501fc12c3fff60a0ab851dfd4c3c2d8e072", + "size": 1380346, + "subdir": "linux-64", + "timestamp": 1678870579817, + "version": "1.0.1" + }, + "meson-1.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ninja >=1.8.2", + "pip", + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1e4e6a8ebc9f53decdd519a6ac65db15", + "name": "meson", + "sha256": "d008c212dc5b33450f6151f64b177999505a688a65a746e962380a5024453035", + "size": 1381803, + "subdir": "linux-64", + "timestamp": 1678870543335, + "version": "1.0.1" + }, + "meson-python-0.12.1-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "meson >=0.63.3", + "ninja", + "pyproject-metadata >=0.6.1", + "python >=3.10,<3.11.0a0", + "tomli >=1.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bfe26123c51d47f7c024ac4b2832ad3e", + "name": "meson-python", + "sha256": "4c50a9553a04a4a79d401dc8626d1580fbd5888d9f29a9136fa0bf3b85a7930b", + "size": 65649, + "subdir": "linux-64", + "timestamp": 1680550570546, + "version": "0.12.1" + }, + "meson-python-0.12.1-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "meson >=0.63.3", + "ninja", + "pyproject-metadata >=0.6.1", + "python >=3.11,<3.12.0a0", + "tomli >=1.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "667ae3661b2ec75442ca6347c621da4b", + "name": "meson-python", + "sha256": "6f36e50743f4fb2fc0dd71224f88f81f9720ffa595700b8825e3664ac0f96770", + "size": 79900, + "subdir": "linux-64", + "timestamp": 1680550443546, + "version": "0.12.1" + }, + "meson-python-0.12.1-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "meson >=0.63.3", + "ninja", + "pyproject-metadata >=0.6.1", + "python >=3.8,<3.9.0a0", + "tomli >=1.0.0", + "typing-extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3949ee9c82c5a1afda02a2ec0d13ed9d", + "name": "meson-python", + "sha256": "921a494801ab4927c6b0ddb24c6afd87535f7f8d33637827c39a34b668a9bcc3", + "size": 64710, + "subdir": "linux-64", + "timestamp": 1680550487053, + "version": "0.12.1" + }, + "meson-python-0.12.1-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "meson >=0.63.3", + "ninja", + "pyproject-metadata >=0.6.1", + "python >=3.9,<3.10.0a0", + "tomli >=1.0.0", + "typing-extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31c5ce6035dac0b88b0373fde3089e72", + "name": "meson-python", + "sha256": "40ed3b3f13ef55136234d832b0a9994c5be98b3761c35df446774a7e067f096a", + "size": 65097, + "subdir": "linux-64", + "timestamp": 1680550528241, + "version": "0.12.1" + }, + "meson-python-0.7.0-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "meson >=0.60.0", + "ninja", + "pyproject-metadata >=0.5.0", + "python >=3.10,<3.11.0a0", + "tomli >=1.0.0", + "wheel >=0.36.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d67ec5ca93706c3dc22f370060b1b765", + "name": "meson-python", + "sha256": "8219104472bc4f8a45207e786e26e9af2b0dbe6b3f037c91dfeb96b9b0c261f6", + "size": 41656, + "subdir": "linux-64", + "timestamp": 1660137705048, + "version": "0.7.0" + }, + "meson-python-0.7.0-py311h5eee18b_1.conda": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "meson >=0.60.0", + "ninja", + "pyproject-metadata >=0.5.0", + "python >=3.11,<3.12.0a0", + "tomli >=1.0.0", + "wheel >=0.36.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a1d1db85c49c43e388edec04361b050b", + "name": "meson-python", + "sha256": "4439ba87e66119449cbaac4cca04de02dab3c1069efe08095082aec8227320d8", + "size": 53228, + "subdir": "linux-64", + "timestamp": 1676858637714, + "version": "0.7.0" + }, + "meson-python-0.7.0-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "meson >=0.60.0", + "ninja", + "pyproject-metadata >=0.5.0", + "python >=3.7,<3.8.0a0", + "tomli >=1.0.0", + "typing-extensions >=3.7.4", + "wheel >=0.36.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13bc51af4c3cdaf1d9091c5381b8e45d", + "name": "meson-python", + "sha256": "a55e8ef76a62a000b90804ec8bda7de583e95de05b46a91aa34c742db74b2d48", + "size": 41095, + "subdir": "linux-64", + "timestamp": 1660137756402, + "version": "0.7.0" + }, + "meson-python-0.7.0-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "meson >=0.60.0", + "ninja", + "pyproject-metadata >=0.5.0", + "python >=3.8,<3.9.0a0", + "tomli >=1.0.0", + "wheel >=0.36.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ec7d7ff980c283f839f3f45067132ca", + "name": "meson-python", + "sha256": "df08c7f31a49dc3b29c0f96ddb12f21050582d70e4c3aa32fa5d8438496b9c75", + "size": 41259, + "subdir": "linux-64", + "timestamp": 1660137575909, + "version": "0.7.0" + }, + "meson-python-0.7.0-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "meson >=0.60.0", + "ninja", + "pyproject-metadata >=0.5.0", + "python >=3.9,<3.10.0a0", + "tomli >=1.0.0", + "wheel >=0.36.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f06169ab45ac3a12f8b0bfa3faa93fe", + "name": "meson-python", + "sha256": "21755420543f0ee31e29d3b1dc3425240fbafd8a31534a820249e9dccc0f33d8", + "size": 41322, + "subdir": "linux-64", + "timestamp": 1660137641242, + "version": "0.7.0" + }, + "metakernel-0.20.14-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "36c7041226dd0067ddc9796b4da981dc", + "name": "metakernel", + "sha256": "713fb8fc9cdd0261f7b6a26493535803cd37fbeb3029e2c45a6c510d3dd8c88c", + "size": 121016, + "subdir": "linux-64", + "timestamp": 1522192331539, + "version": "0.20.14" + }, + "metakernel-0.20.14-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "50e764c6818ca651fc2b57fc76df2fa2", + "name": "metakernel", + "sha256": "53e93d1ccbca6ba31f4a0b8eed301ca7fe7dfa0ccb1f8d592b4f9a0cacdd6e0a", + "size": 122988, + "subdir": "linux-64", + "timestamp": 1522192344635, + "version": "0.20.14" + }, + "metakernel-0.20.14-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "db00b536e73de658b1bbad313d2d42da", + "name": "metakernel", + "sha256": "d961d30b434212ac79de7f4c500829ddb030126f88c84dc1787427a1901b2619", + "size": 122092, + "subdir": "linux-64", + "timestamp": 1522192339413, + "version": "0.20.14" + }, + "metakernel-0.20.14-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cd48717cb130733d99683f0df50eed75", + "name": "metakernel", + "sha256": "fd955c46773ebf2396474baf44df3ce593aae0c160bddebc3a3581af9178bae8", + "size": 123418, + "subdir": "linux-64", + "timestamp": 1530899234749, + "version": "0.20.14" + }, + "metakernel-0.20.7-py27hb56d6b3_0.conda": { + "build": "py27hb56d6b3_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "57db9af7bbfc94f76a1adec9894e4dd8", + "name": "metakernel", + "sha256": "793bc3ec79a828a14ccb1fb3c7bb68c76a1a698212b4d7a2a9efcf73a603c2d8", + "size": 120314, + "subdir": "linux-64", + "timestamp": 1506847986497, + "version": "0.20.7" + }, + "metakernel-0.20.7-py35h54656b8_0.conda": { + "build": "py35h54656b8_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "40cf2b360b8ef6536c21cf4b031a7c75", + "name": "metakernel", + "sha256": "2338fd4f5773b4618a305eaf3093e4ee4b87e6c711aa348ec83a7139f837e422", + "size": 123829, + "subdir": "linux-64", + "timestamp": 1506848038455, + "version": "0.20.7" + }, + "metakernel-0.20.7-py36hac07065_0.conda": { + "build": "py36hac07065_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2ee6b08e3d562ab0f38e198618f5d4af", + "name": "metakernel", + "sha256": "78c2a65a25a48b2c139c50c8053d412e29f8b4f89dc28df910fb7978d1f37814", + "size": 122977, + "subdir": "linux-64", + "timestamp": 1506848035994, + "version": "0.20.7" + }, + "metakernel-0.23.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1518cdc4bd1a2c277e91fa28bad286b3", + "name": "metakernel", + "sha256": "e48b877899f1a1e19aa48efeee605fc3843bf90490584fe71d1bd04233fe8f3d", + "size": 238906, + "subdir": "linux-64", + "timestamp": 1559060629700, + "version": "0.23.0" + }, + "metakernel-0.23.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "58ef7d5646b6f5c12fb9cfe41bd40758", + "name": "metakernel", + "sha256": "d69691bc36f2b7f5393f187cf79b0aaf46dd13d54650d6f5fcfd16e7a3da3656", + "size": 240276, + "subdir": "linux-64", + "timestamp": 1558738831115, + "version": "0.23.0" + }, + "metakernel-0.23.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "pexpect >=4.2", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3b1b626ea1743fd5c49c7e79e482b0bb", + "name": "metakernel", + "sha256": "96d02e8f4229d9e05c36ffbd57f74bf10a6705e78a32e3dc1a0cd0e042025cd5", + "size": 240338, + "subdir": "linux-64", + "timestamp": 1559060626275, + "version": "0.23.0" + }, + "metis-5.1.0-hdbfa776_3.conda": { + "build": "hdbfa776_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "Apache 2.0", + "md5": "8e7f00914a7ecfa4a6ddaca3d938e56c", + "name": "metis", + "sha256": "377180cf98e4a7c589c489f82008181da93d480887d1c493779ad78e3a18241b", + "size": 3881861, + "subdir": "linux-64", + "timestamp": 1636111015419, + "version": "5.1.0" + }, + "metis-5.1.0-hf484d3e_4.conda": { + "build": "hf484d3e_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "md5": "50547bdfcee973e6635d7457031372aa", + "name": "metis", + "sha256": "afb0b94ae1f85e939e3b4e4e27e893d60926b738de54e0dd52a1cf217a5d1394", + "size": 3864050, + "subdir": "linux-64", + "timestamp": 1528733678436, + "version": "5.1.0" + }, + "mistune-0.7.4-py27h6da7e90_0.conda": { + "build": "py27h6da7e90_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c1a2b1cbfd4c94cf98eebb574cd4f3bd", + "name": "mistune", + "sha256": "d70bd71f009d8b5ed59aae4812a7c5de2669e15a091234834613624c435215ce", + "size": 53722, + "subdir": "linux-64", + "timestamp": 1505688922769, + "version": "0.7.4" + }, + "mistune-0.7.4-py35hfd0f961_0.conda": { + "build": "py35hfd0f961_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "19548eb3e1ada1cb584af9130e26452f", + "name": "mistune", + "sha256": "be229ad8b7172d9d8a881480cd03cf5ca9368fec9e37884ff6201f53eee9f9c2", + "size": 54432, + "subdir": "linux-64", + "timestamp": 1505689771057, + "version": "0.7.4" + }, + "mistune-0.7.4-py36hbab8784_0.conda": { + "build": "py36hbab8784_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6f479991795e314e196090efb6d35cf5", + "name": "mistune", + "sha256": "441d220cc483f06cb0aaf51e4253698ead7d89fa2d44c60157dd2c3ed53034dc", + "size": 54192, + "subdir": "linux-64", + "timestamp": 1505689782769, + "version": "0.7.4" + }, + "mistune-0.8.1-py27h1bd0165_0.conda": { + "build": "py27h1bd0165_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "659587a52e5f6bea7f413d4a3e36a17a", + "name": "mistune", + "sha256": "3618427d3844d500fa07815ac96748bdbb58a85d2b2b1a5eae7d873e9167e54e", + "size": 55058, + "subdir": "linux-64", + "timestamp": 1510329860159, + "version": "0.8.1" + }, + "mistune-0.8.1-py35h9251d8c_0.conda": { + "build": "py35h9251d8c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "169f054be8bd0980623670085a5e5b5e", + "name": "mistune", + "sha256": "b51cb5ab94a47d16019213a6c96e89f5c2dc1e4285115f8b4aa9c795a3b02b5d", + "size": 55490, + "subdir": "linux-64", + "timestamp": 1510329863865, + "version": "0.8.1" + }, + "mistune-0.8.1-py36h3d5977c_0.conda": { + "build": "py36h3d5977c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0f312e75316fcb9ed3dccdb9e086c0a7", + "name": "mistune", + "sha256": "1ad9091671f0982910398be565f2e1bc37154b2cdaea729e6dcdcd2a592ac448", + "size": 55179, + "subdir": "linux-64", + "timestamp": 1510329865278, + "version": "0.8.1" + }, + "mistune-0.8.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "924597af1f6f68c2b00e22299e464b2f", + "name": "mistune", + "sha256": "9b143a617763032ab86f1cf7787cd9e825e9a4ed4d91d535e70acbe48129ef34", + "size": 54481, + "subdir": "linux-64", + "timestamp": 1515791342016, + "version": "0.8.3" + }, + "mistune-0.8.3-py27h14c3975_1.conda": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "45cf02db646766a25b37d515101e53b9", + "name": "mistune", + "sha256": "f4c0c024449e23b718e520dd8987e7065b21a1a687ad9c3d15bad8f614e4b670", + "size": 247346, + "subdir": "linux-64", + "timestamp": 1524516418991, + "version": "0.8.3" + }, + "mistune-0.8.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "49e36493de0d03c26d56431640adabb2", + "name": "mistune", + "sha256": "8110ac50ab9140cd1ccdd5cf0d2660f0c6acadd5ca14a3b428d4d79c4fc8ceb5", + "size": 54711, + "subdir": "linux-64", + "timestamp": 1515791399352, + "version": "0.8.3" + }, + "mistune-0.8.3-py35h14c3975_1.conda": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "25eee244cd696f91d80c05a4cc309f1d", + "name": "mistune", + "sha256": "45e5afea72b5ec3b5a68463f47d9eec6234c4b47b84013882079ab064a49b821", + "size": 249986, + "subdir": "linux-64", + "timestamp": 1524516991482, + "version": "0.8.3" + }, + "mistune-0.8.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bf4da1698bcd9152b1060e2669c970b5", + "name": "mistune", + "sha256": "d45d1f5bbaf794ae63b12121d03e630b6228048a5d6d2bb5bc0d8466896923bf", + "size": 54447, + "subdir": "linux-64", + "timestamp": 1515791272916, + "version": "0.8.3" + }, + "mistune-0.8.3-py36h14c3975_1.conda": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0602fa2dcdda6ed58e4acd75d680fb3c", + "name": "mistune", + "sha256": "fb33bf6f62448606ea1627c30f674b6d098e93da9f09c21b5c46a79af2d78e3d", + "size": 257184, + "subdir": "linux-64", + "timestamp": 1524516980361, + "version": "0.8.3" + }, + "mistune-0.8.3-py37h14c3975_1.conda": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bf33e14dca7dda83da1fb83e211d5841", + "name": "mistune", + "sha256": "e294e129672eea3323299c0ab29e60e262e524db817dbf89b297a3a3118c11d1", + "size": 257089, + "subdir": "linux-64", + "timestamp": 1530734368767, + "version": "0.8.3" + }, + "mistune-0.8.4-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e56ac07ed89d82aa9e9ccaa13b186f65", + "name": "mistune", + "sha256": "78af5f9e7d5ba36c2f7e6fc74c26b81bd75f2c36ef0f17dcc28b5e44106fca52", + "size": 56279, + "subdir": "linux-64", + "timestamp": 1539631526839, + "version": "0.8.4" + }, + "mistune-0.8.4-py310h7f8727e_1000.conda": { + "build": "py310h7f8727e_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c18c2aeb49791bbbdf6b982c06472b5d", + "name": "mistune", + "sha256": "e2fcd229069ed18c1216199fa5da8cbbd3e85faeb5b68f3cf9954fccfb81c8d7", + "size": 56103, + "subdir": "linux-64", + "timestamp": 1640791663692, + "version": "0.8.4" + }, + "mistune-0.8.4-py311h5eee18b_1000.conda": { + "build": "py311h5eee18b_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "713667dd7a8a1cd16230441a807c482a", + "name": "mistune", + "sha256": "44002b6d847b6dd86c7945e9143b3370a3f2b23430593a221fad8299e371b5b7", + "size": 64823, + "subdir": "linux-64", + "timestamp": 1676823711825, + "version": "0.8.4" + }, + "mistune-0.8.4-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b0ceb9b169eb68f007821638748209e3", + "name": "mistune", + "sha256": "b25006e3e8f3d9d621f0c65589eed622d96901351f5a3940ae8044239faee0b1", + "size": 56146, + "subdir": "linux-64", + "timestamp": 1539631542330, + "version": "0.8.4" + }, + "mistune-0.8.4-py37h14c3975_1001.conda": { + "build": "py37h14c3975_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "55d5c9b98d75bd939a054374f21cac19", + "name": "mistune", + "sha256": "fcd8fff9a6c7f3384134bdd8ea5c3a4e3dae83a847ecdd3922dc36f5ee0f17b9", + "size": 55080, + "subdir": "linux-64", + "timestamp": 1594373138585, + "version": "0.8.4" + }, + "mistune-0.8.4-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ccf857c3b5a84574b87a67ffb957af3f", + "name": "mistune", + "sha256": "b705c263260690ba65af4df6d7ed42545c9282e1d9a7aae689410ce0343ed25e", + "size": 56431, + "subdir": "linux-64", + "timestamp": 1539631557616, + "version": "0.8.4" + }, + "mistune-0.8.4-py38h7b6447c_1000.conda": { + "build": "py38h7b6447c_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5b985f581fab6e8aff8157976b0868a9", + "name": "mistune", + "sha256": "6f6e48e137e32f74d12f8dffcd1a68bb73882ed33213b5d941b6a8dbeb5b6a74", + "size": 55944, + "subdir": "linux-64", + "timestamp": 1573489078577, + "version": "0.8.4" + }, + "mistune-0.8.4-py39h27cfd23_1000.conda": { + "build": "py39h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b2649cc4dca6f4ab842491e845bb002c", + "name": "mistune", + "sha256": "e78ee2350c7b7bd496ca4cf82a6bb38d07ed2c4955e129d90ca25049f3c02efe", + "size": 58209, + "subdir": "linux-64", + "timestamp": 1607364912263, + "version": "0.8.4" + }, + "mistune-2.0.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "nbconvert >6.1.0" + ], + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bcf35f9ce918a28237d9bf043668c61f", + "name": "mistune", + "sha256": "4e35eac45425afc2b040b5049fca3d1c8007955da284a097bde65101c23b2900", + "size": 95070, + "subdir": "linux-64", + "timestamp": 1661496364548, + "version": "2.0.4" + }, + "mistune-2.0.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "nbconvert >6.1.0" + ], + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0aac33bec0e5fa8c8436507b3df4567d", + "name": "mistune", + "sha256": "94fc2b6b2c60d271ba866a5401552520fa09730428dc1ccf07961ac37e4351c1", + "size": 109883, + "subdir": "linux-64", + "timestamp": 1676823696152, + "version": "2.0.4" + }, + "mistune-2.0.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "nbconvert >6.1.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a0fab91247cdfe429a6b27568a656189", + "name": "mistune", + "sha256": "f381d257aa0cb648d57d84c9061337a4f9160ceb9555d23dfcda8e5b553aa651", + "size": 94481, + "subdir": "linux-64", + "timestamp": 1661496317987, + "version": "2.0.4" + }, + "mistune-2.0.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "nbconvert >6.1.0" + ], + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6cb8a979b88b6e2bc56cec4c17efd5b5", + "name": "mistune", + "sha256": "653a334fcdbcfd6af0911281983613d66e4b6ec3be1a701a9f4fe58306532286", + "size": 94781, + "subdir": "linux-64", + "timestamp": 1661496287860, + "version": "2.0.4" + }, + "mistune-2.0.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "nbconvert >6.1.0" + ], + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1135b4d9e8f77c40e70c8ce30b05640", + "name": "mistune", + "sha256": "4ba8e5458644ff690832b8dfd582c40127aa3330bcdcbd78f261be8de58b98fb", + "size": 94630, + "subdir": "linux-64", + "timestamp": 1661496257549, + "version": "2.0.4" + }, + "mkl-2017.0.4-h4c4d0af_0.conda": { + "build": "h4c4d0af_0", + "build_number": 0, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "50c9bb5083da872470154112068be106", + "name": "mkl", + "sha256": "c74610a9ea45866f51077b58e0b3ab8e935a8787df9a15927caaadb693ba0f76", + "size": 112436166, + "subdir": "linux-64", + "timestamp": 1508962814801, + "version": "2017.0.4" + }, + "mkl-2018.0.0-hb491cac_4.conda": { + "build": "hb491cac_4", + "build_number": 4, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "5578c181a9d1bfb6f261a783931ea454", + "name": "mkl", + "sha256": "3c9387f1097c4f9689a3f807b06a6ae1cf65e34bf59fc69221edd1db71ea4aff", + "size": 111616907, + "subdir": "linux-64", + "timestamp": 1505745615596, + "version": "2018.0.0" + }, + "mkl-2018.0.1-h19d6760_4.conda": { + "build": "h19d6760_4", + "build_number": 4, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "7b813e422a1134faea69eafe335715d8", + "name": "mkl", + "sha256": "fb5f119b085903f53829c754c2db0433acd63054c656b20c789ae7745bee6079", + "size": 123210984, + "subdir": "linux-64", + "timestamp": 1511376420864, + "version": "2018.0.1" + }, + "mkl-2018.0.2-1.conda": { + "build": "1", + "build_number": 1, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "be8cdd68957d75b2b7481527195b1779", + "name": "mkl", + "sha256": "19b81682bcfa7ae20e6552607a6f0d0bf2d2c877ba82cffbc778b125ba869db1", + "size": 136180419, + "subdir": "linux-64", + "timestamp": 1521735614312, + "version": "2018.0.2" + }, + "mkl-2018.0.3-1.conda": { + "build": "1", + "build_number": 1, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "62a8de41980316fd797ea306f0ebd2c9", + "name": "mkl", + "sha256": "88796d6dbc57895a6fc7245b17859d68e7cc3b6d52e628340cd64f9d917f7260", + "size": 133049738, + "subdir": "linux-64", + "timestamp": 1528122068610, + "version": "2018.0.3" + }, + "mkl-2019.0-117.conda": { + "build": "117", + "build_number": 117, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "dbbaa7a38c07ffc7b9b4bf23773fa420", + "name": "mkl", + "sha256": "2e14ac756386ece40d7f9a7527e89873ba0e7ad947b4f9f53efe4ab56a21c5d5", + "size": 137915545, + "subdir": "linux-64", + "timestamp": 1536594387752, + "version": "2019.0" + }, + "mkl-2019.0-118.conda": { + "build": "118", + "build_number": 118, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "639238cdaef8de8cf758bf6ac3fa679a", + "name": "mkl", + "sha256": "db42e1b9e90eb531819eec1e923d0083654ed3f5668626b4446347309e4ca0cd", + "size": 137949548, + "subdir": "linux-64", + "timestamp": 1537292399637, + "version": "2019.0" + }, + "mkl-2019.1-144.conda": { + "build": "144", + "build_number": 144, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "5b50c5144d50400c50696540684dc270", + "name": "mkl", + "sha256": "64eeb36349a20a23c46b6736b4b7d034d02884c803d2b91114c4dff3be5329ca", + "size": 138224302, + "subdir": "linux-64", + "timestamp": 1542661351585, + "version": "2019.1" + }, + "mkl-2019.3-199.conda": { + "build": "199", + "build_number": 199, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "2ca8c150e067d9ffd9cea8ad7976421b", + "name": "mkl", + "sha256": "2dcb2d0b7a4b16cd4c0b02fd1016f2ee5aac4f101f826098ec4fd181884ae8a2", + "size": 137429363, + "subdir": "linux-64", + "timestamp": 1552593931728, + "version": "2019.3" + }, + "mkl-2019.4-243.conda": { + "build": "243", + "build_number": 243, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "25511101129b3e0edda105b192b2d56d", + "name": "mkl", + "sha256": "fc0e0d6fe002bc82ebde913f4a8df63574d32dbf70b1b15b03f6108445974b34", + "size": 137562990, + "subdir": "linux-64", + "timestamp": 1559526865803, + "version": "2019.4" + }, + "mkl-2020.0-166.conda": { + "build": "166", + "build_number": 166, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "2aa64da972c9d954ba79d39961a01714", + "name": "mkl", + "sha256": "3311dd08f84d8bf4490a68ed47fee95ef0c36cfb1c1156f413d4934a72810511", + "size": 135159028, + "subdir": "linux-64", + "timestamp": 1580944423800, + "version": "2020.0" + }, + "mkl-2020.1-217.conda": { + "build": "217", + "build_number": 217, + "depends": [ + "intel-openmp" + ], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "e40310d2edec9211d84ba8ffae7274ee", + "name": "mkl", + "sha256": "10f62fb587f6821aeecda8deb8e72a41e65b3892c4bc4383da5b8928d9638d53", + "size": 135222815, + "subdir": "linux-64", + "timestamp": 1589162721090, + "version": "2020.1" + }, + "mkl-2020.2-256.conda": { + "build": "256", + "build_number": 256, + "depends": [ + "intel-openmp" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "a73b6cbcdbcc8f4a10d5b46181f418bb", + "name": "mkl", + "sha256": "e8734ce44ebca78c43464ef1e0ecf89be67bf0e394be1a08572c6a3f3857a31a", + "size": 145052203, + "subdir": "linux-64", + "timestamp": 1598384580372, + "version": "2020.2" + }, + "mkl-2021.2.0-h06a4308_296.conda": { + "build": "h06a4308_296", + "build_number": 296, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [ + "intel-openmp 2021.*" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "06c81ed0b0c637506b4b0305cf59d121", + "name": "mkl", + "sha256": "19cd4c513867c2fb79962122a6fb38fd36b49b3d08402907a389f3ce14b17f9c", + "size": 151289932, + "subdir": "linux-64", + "timestamp": 1618534385890, + "version": "2021.2.0" + }, + "mkl-2021.3.0-h06a4308_520.conda": { + "build": "h06a4308_520", + "build_number": 520, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [ + "intel-openmp 2021.*" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "1ade4a2bdc88efff997c2eb65d1d808f", + "name": "mkl", + "sha256": "20a2dd9a872ae1a6e1b1a9688d3f8e97068e92456dace783ca82032868ed7296", + "size": 148067245, + "subdir": "linux-64", + "timestamp": 1626182688537, + "version": "2021.3.0" + }, + "mkl-2021.4.0-h06a4308_640.conda": { + "build": "h06a4308_640", + "build_number": 640, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [ + "intel-openmp 2021.*" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "c9eee35aaa371ed39e4d8c0692f0e5bf", + "name": "mkl", + "sha256": "58cb5ed4263f1bc5eadd08824eaedfd80719c6eff4cfa2bcac0f1a39a9aca1e5", + "size": 149546539, + "subdir": "linux-64", + "timestamp": 1634547157986, + "version": "2021.4.0" + }, + "mkl-2022.0.1-h06a4308_117.conda": { + "build": "h06a4308_117", + "build_number": 117, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [ + "intel-openmp 2022.*" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "16cbca1fc71abbeaad1f8ad8cccf4cf7", + "name": "mkl", + "sha256": "5d185996d832dfedc25a33b1f0ba5e25fbf0669279de0ad0b2fb291d671b9c46", + "size": 133930671, + "subdir": "linux-64", + "timestamp": 1642705808227, + "version": "2022.0.1" + }, + "mkl-2022.1.0-hc2b9512_224.conda": { + "build": "hc2b9512_224", + "build_number": 224, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [ + "intel-openmp 2022.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "5fdbbe9486d8b48f9cec4f31758c5680", + "name": "mkl", + "sha256": "744ddaf160169deb941fc4528d05e7b59d66e8f7c776faa50d750c1a10e8b8ed", + "size": 136028865, + "subdir": "linux-64", + "timestamp": 1662497914900, + "version": "2022.1.0" + }, + "mkl-2023.0.0-h6d00ec8_25399.conda": { + "build": "h6d00ec8_25399", + "build_number": 25399, + "constrains": [ + "__glibc >=2.17" + ], + "depends": [ + "intel-openmp 2023.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.*" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "bdfb6a5b70db77fe2c3a1c40532a908c", + "name": "mkl", + "sha256": "8a7ad6bb53de8da76b913905174e1f51ad717f0d15a4107b1e7d3654c95e99df", + "size": 179711219, + "subdir": "linux-64", + "timestamp": 1677516738168, + "version": "2023.0.0" + }, + "mkl-devel-2017.0.4-h2e09e16_0.conda": { + "build": "h2e09e16_0", + "build_number": 0, + "depends": [ + "mkl 2017.0.4 h4c4d0af_0", + "mkl-include 2017.0.4 hf7c01fb_0", + "blas * mkl" + ], + "md5": "bcb0d3dac274e28226d47059982c8bc4", + "name": "mkl-devel", + "sha256": "ff403b7782be512d41334a7d074036e0153e2dd596ab8d3c53e47d49eada2dcb", + "size": 3668, + "subdir": "linux-64", + "timestamp": 1508963017151, + "version": "2017.0.4" + }, + "mkl-devel-2018.0.0-hed7f433_4.conda": { + "build": "hed7f433_4", + "build_number": 4, + "depends": [ + "mkl 2018.0.0 hb491cac_4", + "mkl-include 2018.0.0 h15fc484_2", + "blas * mkl" + ], + "md5": "42a7b511e11267bb1cb03c632dc0bd96", + "name": "mkl-devel", + "sha256": "c86884a3739074072dab6ded4d37027f61a8c61a008c8995e465707b7f308111", + "size": 3062, + "subdir": "linux-64", + "timestamp": 1505745774859, + "version": "2018.0.0" + }, + "mkl-devel-2018.0.1-h470d631_5.conda": { + "build": "h470d631_5", + "build_number": 5, + "depends": [ + "mkl", + "mkl-include", + "blas * mkl" + ], + "md5": "c55d4fd9003db7c12848f729b35829d4", + "name": "mkl-devel", + "sha256": "1bdd08e0082e4e1f9ea91886ac162f5d08d44ee789277d05ba22c22584579759", + "size": 3331, + "subdir": "linux-64", + "timestamp": 1516825134435, + "version": "2018.0.1" + }, + "mkl-devel-2018.0.1-hf16a5b4_4.conda": { + "build": "hf16a5b4_4", + "build_number": 4, + "depends": [ + "mkl 2018.0.1 h19d6760_4", + "mkl-include 2018.0.1 hc7b2577_4", + "blas * mkl" + ], + "md5": "2654e07edda084988d00a907dae7fede", + "name": "mkl-devel", + "sha256": "92b3747f92464ee80b7c3421ba0098427f4310b4102dedac308743799e7820ea", + "size": 3697, + "subdir": "linux-64", + "timestamp": 1511376588378, + "version": "2018.0.1" + }, + "mkl-devel-2018.0.2-1.conda": { + "build": "1", + "build_number": 1, + "depends": [ + "mkl 2018.0.2 1", + "mkl-include 2018.0.2 1", + "blas * mkl" + ], + "md5": "8652533028c0c35afd00d37dd3625e11", + "name": "mkl-devel", + "sha256": "933cbc341b0c056b1b9790a0ed96d8df0419f11d875b68712cc5d1f87070befd", + "size": 5959, + "subdir": "linux-64", + "timestamp": 1521735821183, + "version": "2018.0.2" + }, + "mkl-devel-2018.0.2-3.conda": { + "build": "3", + "build_number": 3, + "depends": [ + "mkl 2018.0.2 1", + "mkl-include 2018.0.2 1", + "blas * mkl" + ], + "md5": "052f2ffdecb153d1e2b6e41a3bb7694c", + "name": "mkl-devel", + "sha256": "8f05a68cabac9676e30d1e5b2dd2a8ff2e023488f2b8e84f523db341db6820b3", + "size": 6607, + "subdir": "linux-64", + "timestamp": 1526043010740, + "version": "2018.0.2" + }, + "mkl-devel-2018.0.2-4.conda": { + "build": "4", + "build_number": 4, + "depends": [ + "mkl 2018.0.2 1", + "mkl-include 2018.0.2 1", + "blas * mkl" + ], + "md5": "cb33d69d993f215a8dbc9125fb708a00", + "name": "mkl-devel", + "sha256": "c90bea7113bdf7d88aa6ca7e7c6d9371f37c4a61662ba24f84985aa548eb1798", + "size": 6573, + "subdir": "linux-64", + "timestamp": 1526831164354, + "version": "2018.0.2" + }, + "mkl-devel-2018.0.3-1.conda": { + "build": "1", + "build_number": 1, + "depends": [ + "mkl 2018.0.3 1", + "mkl-include 2018.0.3 1", + "blas * mkl" + ], + "md5": "80df251ca2ee0b8bf585c86560b17d8f", + "name": "mkl-devel", + "sha256": "1ca84303d19837dae960ca8b3cd02e9eeb45283a4c580255ed9ff8e5c91e9147", + "size": 6485, + "subdir": "linux-64", + "timestamp": 1528122418745, + "version": "2018.0.3" + }, + "mkl-devel-2019.0-117.conda": { + "build": "117", + "build_number": 117, + "depends": [ + "blas * mkl", + "mkl 2019.0 117", + "mkl-include 2019.0 117" + ], + "md5": "dda430d679c9a0c58ddec87f5adb9e4b", + "name": "mkl-devel", + "sha256": "aa7c91fe1a85ba2aaf145ed445b83c38b504c9e85b4c94ace02eca048f983e6e", + "size": 7614, + "subdir": "linux-64", + "timestamp": 1536594591299, + "version": "2019.0" + }, + "mkl-devel-2019.0-118.conda": { + "build": "118", + "build_number": 118, + "depends": [ + "blas * mkl", + "mkl 2019.0 118", + "mkl-include 2019.0 118" + ], + "md5": "ca681ca97fee36b1275735cbab9713a3", + "name": "mkl-devel", + "sha256": "99486375b5a02e3ba9068b9f99a220ec588c634de971d4a8a445a3a772d90b24", + "size": 6809, + "subdir": "linux-64", + "timestamp": 1537292709568, + "version": "2019.0" + }, + "mkl-devel-2019.0-119.conda": { + "build": "119", + "build_number": 119, + "depends": [ + "blas * mkl", + "mkl 2019.0 118", + "mkl-include 2019.0 118" + ], + "md5": "4c9110400af95f6ed1ddd42733fd9d8b", + "name": "mkl-devel", + "sha256": "53799e8e99b5a64ea2c9da1904e038190a7f317e6c24344e035ee99dffec8799", + "size": 11139, + "subdir": "linux-64", + "timestamp": 1539280882147, + "version": "2019.0" + }, + "mkl-devel-2019.1-144.conda": { + "build": "144", + "build_number": 144, + "depends": [ + "blas * mkl", + "mkl 2019.1 144", + "mkl-include 2019.1 144" + ], + "md5": "f7b9194dc075f99d8ee4434e470de490", + "name": "mkl-devel", + "sha256": "650072e0f77f60ac7751d6138031eabdb04744be0c81b77401bccabddfb4f971", + "size": 9966, + "subdir": "linux-64", + "timestamp": 1542661737733, + "version": "2019.1" + }, + "mkl-devel-2019.3-200.conda": { + "build": "200", + "build_number": 200, + "depends": [ + "blas * mkl", + "mkl 2019.3 199", + "mkl-include 2019.3 199" + ], + "md5": "3e7502a202dc2b0814cb77332fe57505", + "name": "mkl-devel", + "sha256": "fb22c0c420be977d8e066b7f153b8828593068456da894cc299a3b9f373ff1fb", + "size": 11654, + "subdir": "linux-64", + "timestamp": 1552594346124, + "version": "2019.3" + }, + "mkl-devel-2019.4-243.conda": { + "build": "243", + "build_number": 243, + "depends": [ + "blas * mkl", + "mkl 2019.4 243", + "mkl-include 2019.4 243" + ], + "md5": "f78a87ad23b65c1298525f90bfaa5391", + "name": "mkl-devel", + "sha256": "ab25e584950ca9992cb1384da5d0fe2a5eede454de4e2c0935a8f0c6e5a81a71", + "size": 12092, + "subdir": "linux-64", + "timestamp": 1559527106419, + "version": "2019.4" + }, + "mkl-devel-2020.0-167.conda": { + "build": "167", + "build_number": 167, + "depends": [ + "blas * mkl", + "mkl 2020.0 166", + "mkl-include 2020.0 166" + ], + "md5": "82f4847dbfdad4f5b42c1bc9579acbc4", + "name": "mkl-devel", + "sha256": "0d9f5d28a119a77695f42677b1dccd91c4cea5eab99476742395e6e7fb48fb1d", + "size": 12441, + "subdir": "linux-64", + "timestamp": 1580944619207, + "version": "2020.0" + }, + "mkl-devel-2020.1-218.conda": { + "build": "218", + "build_number": 218, + "depends": [ + "blas * mkl", + "mkl 2020.1 217", + "mkl-include 2020.1 217" + ], + "md5": "5cee18194e0f5a7d51cdfc8dc793d7bf", + "name": "mkl-devel", + "sha256": "330ec61380576b631f3631e11910531ab8ac01da08d7290261c37b5182fbc1bf", + "size": 12409, + "subdir": "linux-64", + "timestamp": 1589162951884, + "version": "2020.1" + }, + "mkl-devel-2020.2-257.conda": { + "build": "257", + "build_number": 257, + "depends": [ + "blas * mkl", + "mkl 2020.2 256", + "mkl-include 2020.2 256" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "49c7fc0b9a5a4df6f44d22a44d63d5de", + "name": "mkl-devel", + "sha256": "a3e505b38c04646353b1b6d21008949959edbd9a5e9f172ee2ee7e4e4a29057f", + "size": 13880, + "subdir": "linux-64", + "timestamp": 1598384790911, + "version": "2020.2" + }, + "mkl-devel-2021.2.0-h66538d2_296.conda": { + "build": "h66538d2_296", + "build_number": 296, + "depends": [ + "blas * mkl", + "mkl 2021.2.0 h06a4308_296", + "mkl-include 2021.2.0 h06a4308_296" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "b0b108b5d514e67801b0fe76d91bc3f4", + "name": "mkl-devel", + "sha256": "b55c3de5c1b698e30587a4071f5304642819e01b2917ec28cb706238984a6305", + "size": 26726, + "subdir": "linux-64", + "timestamp": 1618534587016, + "version": "2021.2.0" + }, + "mkl-devel-2021.3.0-h66538d2_520.conda": { + "build": "h66538d2_520", + "build_number": 520, + "depends": [ + "blas * mkl", + "mkl 2021.3.0 h06a4308_520", + "mkl-include 2021.3.0 h06a4308_520" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "798b0f0f6617b2e82d2dcc191c604900", + "name": "mkl-devel", + "sha256": "cce4ab7513a4aa8d05b1b7853bf7bebd96c4fc8b4be705e30cdd2019f52f9bea", + "size": 27541, + "subdir": "linux-64", + "timestamp": 1626182870662, + "version": "2021.3.0" + }, + "mkl-devel-2021.4.0-h66538d2_640.conda": { + "build": "h66538d2_640", + "build_number": 640, + "depends": [ + "blas * mkl", + "mkl 2021.4.0 h06a4308_640", + "mkl-include 2021.4.0 h06a4308_640" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "6f734ebd7355eeb992a7eabefce5d5f6", + "name": "mkl-devel", + "sha256": "828a35314b09ed7d68a0a7c76f12f911e52f44252635afede7446f0e4982236f", + "size": 27479, + "subdir": "linux-64", + "timestamp": 1634547339271, + "version": "2021.4.0" + }, + "mkl-devel-2022.0.1-h66538d2_117.conda": { + "build": "h66538d2_117", + "build_number": 117, + "depends": [ + "blas * mkl", + "mkl 2022.0.1 h06a4308_117", + "mkl-include 2022.0.1 h06a4308_117" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "e91c4f10bdd433efb822c50c5c24b351", + "name": "mkl-devel", + "sha256": "ae39452f67ec9c2d92b778608aa20d8ec90363632bd2c40f1263f4b0022fa521", + "size": 28116, + "subdir": "linux-64", + "timestamp": 1642705976071, + "version": "2022.0.1" + }, + "mkl-devel-2022.1.0-h66538d2_224.conda": { + "build": "h66538d2_224", + "build_number": 224, + "depends": [ + "blas * mkl", + "mkl 2022.1.0 hc2b9512_224", + "mkl-include 2022.1.0 h06a4308_224" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "c9f1f98b779b83111c6a1be24972b592", + "name": "mkl-devel", + "sha256": "30bb9b287cfc00ea529d59494f191e8676f4dad7f016341f93a7ddea92019a16", + "size": 26408, + "subdir": "linux-64", + "timestamp": 1662498036788, + "version": "2022.1.0" + }, + "mkl-devel-2023.0.0-h2fb9e7e_25399.conda": { + "build": "h2fb9e7e_25399", + "build_number": 25399, + "depends": [ + "blas * mkl", + "mkl 2023.0.0 h6d00ec8_25399", + "mkl-include 2023.0.0 h06a4308_25399" + ], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "9f10c44e96eead22aa8d169a9ab9284e", + "name": "mkl-devel", + "sha256": "006aa4fb7ef0a6abb8dfd562214f4f07ca8bb12f30509f3669f08bcde8d72167", + "size": 38013, + "subdir": "linux-64", + "timestamp": 1677516879366, + "version": "2023.0.0" + }, + "mkl-devel-dpcpp-2021.3.0-h66538d2_521.conda": { + "build": "h66538d2_521", + "build_number": 521, + "depends": [ + "mkl-devel 2021.3.0", + "mkl-dpcpp 2021.3.0 h66538d2_521" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "1972a93a641c5d98246fd52d12592f16", + "name": "mkl-devel-dpcpp", + "sha256": "97ca8d43803a1ee018aa81e68e245e071af2ca54db6e4b36315f5c88f36e59c7", + "size": 25126291, + "subdir": "linux-64", + "timestamp": 1645482089748, + "version": "2021.3.0" + }, + "mkl-devel-dpcpp-2021.4.0-h66538d2_640.conda": { + "build": "h66538d2_640", + "build_number": 640, + "depends": [ + "mkl-devel 2021.4.0", + "mkl-dpcpp 2021.4.0 h66538d2_640" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "c9d7d5967dc4cba03f86542705876dea", + "name": "mkl-devel-dpcpp", + "sha256": "ebeb2ec62a6421f17e0f5296c7e0b905a8f63fe4c2f1c488e049374919ce8e46", + "size": 27882510, + "subdir": "linux-64", + "timestamp": 1645482440821, + "version": "2021.4.0" + }, + "mkl-devel-dpcpp-2022.0.1-h66538d2_117.conda": { + "build": "h66538d2_117", + "build_number": 117, + "depends": [ + "mkl-devel 2022.0.1", + "mkl-dpcpp 2022.0.1 h66538d2_117" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "3efb113a498e54d94e2b9b864b355ddb", + "name": "mkl-devel-dpcpp", + "sha256": "a8ae918e29e2974ce1a7b13fce4b4b226c0632eb462f30add46d3099303ec9d3", + "size": 27204895, + "subdir": "linux-64", + "timestamp": 1645539618882, + "version": "2022.0.1" + }, + "mkl-devel-dpcpp-2022.1.0-h2fb9e7e_223.conda": { + "build": "h2fb9e7e_223", + "build_number": 223, + "depends": [ + "mkl-devel 2022.1.0", + "mkl-dpcpp 2022.1.0 h2fb9e7e_223" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "5fbf9bc1688385788adc6dd514b7da57", + "name": "mkl-devel-dpcpp", + "sha256": "4639b56795b74e302f645cdc5cc15ce19ff67f1a15590b471298f58e00c06e25", + "size": 42490204, + "subdir": "linux-64", + "timestamp": 1667585637597, + "version": "2022.1.0" + }, + "mkl-devel-dpcpp-2023.0.0-h2fb9e7e_25398.conda": { + "build": "h2fb9e7e_25398", + "build_number": 25398, + "depends": [ + "mkl-devel 2023.0.0", + "mkl-dpcpp 2023.0.0 h2fb9e7e_25398" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "0fe8703e6da4e67b64817d01c0c4575b", + "name": "mkl-devel-dpcpp", + "sha256": "853fcb4a14e6b90c8af3de9caaafe1fcf4c3e70b71a7f37a92631f61d614b4d9", + "size": 62046881, + "subdir": "linux-64", + "timestamp": 1679615669326, + "version": "2023.0.0" + }, + "mkl-dnn-0.14-h6bb024c_0.conda": { + "build": "h6bb024c_0", + "build_number": 0, + "depends": [ + "intel-openmp >=2018.0.3,<2019.0a0", + "libgcc-ng >=7.2.0", + "libmklml >=2018.0.3", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f0c9665729366c6b448d0e3e6d507a79", + "name": "mkl-dnn", + "sha256": "1987f2ff5b6dfa387d5481995ec9ffb1b379df449e85799bffe24f29069816ff", + "size": 1326710, + "subdir": "linux-64", + "timestamp": 1530347088059, + "version": "0.14" + }, + "mkl-dnn-0.19-hd09550d_1.conda": { + "build": "hd09550d_1", + "build_number": 1, + "depends": [ + "intel-openmp >=2019.4,<2020.0a0", + "libgcc-ng >=7.5.0", + "libmklml >=2019.0.5", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "316d5e871398199fb51e9cd4b18d5337", + "name": "mkl-dnn", + "sha256": "2d66c79e1a8575dd0f311f8c96e81beb302a4b11e248a55d17cc4722b2bdc046", + "size": 2022293, + "subdir": "linux-64", + "timestamp": 1643019947840, + "version": "0.19" + }, + "mkl-dnn-0.19-hfd86e86_1.conda": { + "build": "hfd86e86_1", + "build_number": 1, + "depends": [ + "intel-openmp >=2019.4,<2020.0a0", + "libgcc-ng >=7.3.0", + "libmklml >=2019.0.5", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f6e7af283d04b4964e43f392dfc6f975", + "name": "mkl-dnn", + "sha256": "1467735019d7d2c14fe4ac9b2784a040f3fba45a91984df34187c851efa4c3af", + "size": 2169158, + "subdir": "linux-64", + "timestamp": 1564763730429, + "version": "0.19" + }, + "mkl-dpcpp-2021.3.0-h66538d2_521.conda": { + "build": "h66538d2_521", + "build_number": 521, + "depends": [ + "dpcpp-cpp-rt 2021.*", + "intel-opencl-rt 2021.*", + "mkl 2021.3.0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "6772f555e9b5ca91cf3cdf82fe93bf43", + "name": "mkl-dpcpp", + "sha256": "b2e3737e1de823b76b5a0af2a236af929a360894247a0682f1f96f6e8216edd7", + "size": 62667739, + "subdir": "linux-64", + "timestamp": 1645481878589, + "version": "2021.3.0" + }, + "mkl-dpcpp-2021.4.0-h66538d2_640.conda": { + "build": "h66538d2_640", + "build_number": 640, + "depends": [ + "dpcpp-cpp-rt 2021.*", + "intel-opencl-rt 2021.*", + "mkl 2021.4.0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "e7fb3855209e735547c65720f2a6bbcc", + "name": "mkl-dpcpp", + "sha256": "e1606e7c7f3432fa9cf5ede1859e30ac12ead7f3ac1d946395efe97dbfd5b190", + "size": 67561473, + "subdir": "linux-64", + "timestamp": 1645482208671, + "version": "2021.4.0" + }, + "mkl-dpcpp-2022.0.1-h66538d2_117.conda": { + "build": "h66538d2_117", + "build_number": 117, + "depends": [ + "dpcpp-cpp-rt 2022.*", + "intel-opencl-rt 2022.*", + "mkl 2022.0.1" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "6e0b0a9189ed47e6c86b41286ad046ee", + "name": "mkl-dpcpp", + "sha256": "ebb03083859fa2671fcff634bc8ab96d0a05c2ead1c0200b029efd6881eabfd5", + "size": 90238777, + "subdir": "linux-64", + "timestamp": 1645539399634, + "version": "2022.0.1" + }, + "mkl-dpcpp-2022.1.0-h2fb9e7e_223.conda": { + "build": "h2fb9e7e_223", + "build_number": 223, + "depends": [ + "dpcpp-cpp-rt 2022.*", + "intel-opencl-rt 2022.*", + "mkl 2022.1.0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "4170efc0b01523cb6179905b55ed2ecb", + "name": "mkl-dpcpp", + "sha256": "29888f08e909c612527d9ec248cdb90e625739b0673cc083aae80f16c034a0d6", + "size": 50809476, + "subdir": "linux-64", + "timestamp": 1667585443825, + "version": "2022.1.0" + }, + "mkl-dpcpp-2023.0.0-h2fb9e7e_25398.conda": { + "build": "h2fb9e7e_25398", + "build_number": 25398, + "depends": [ + "dpcpp-cpp-rt 2023.*", + "intel-opencl-rt 2023.*", + "mkl 2023.0.0" + ], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "f373f806cccb8e10d0955fbd679d2015", + "name": "mkl-dpcpp", + "sha256": "06edb2ddcb66efb6aabfa9593329906893bcbcd7629ecbb4bc555f1ec2d59959", + "size": 59590071, + "subdir": "linux-64", + "timestamp": 1679615461246, + "version": "2023.0.0" + }, + "mkl-include-2017.0.4-hf7c01fb_0.conda": { + "build": "hf7c01fb_0", + "build_number": 0, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "415c443672a99caa55d801fce657a1d4", + "name": "mkl-include", + "sha256": "3697d3bd77e61fdf45f32c99efc7f07ccf5f6e010e244d3b5e007c0ecdbd763e", + "size": 436810, + "subdir": "linux-64", + "timestamp": 1508962803336, + "version": "2017.0.4" + }, + "mkl-include-2018.0.0-h15fc484_2.conda": { + "build": "h15fc484_2", + "build_number": 2, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "e9d830f5daaa02edf1efa1a720d5fcd1", + "name": "mkl-include", + "sha256": "de7f16f17fd67e1e4f5850e13adc5cfc812d0d29b15be910fa8edb9564dc6357", + "size": 441204, + "subdir": "linux-64", + "timestamp": 1505745612210, + "version": "2018.0.0" + }, + "mkl-include-2018.0.1-hc7b2577_4.conda": { + "build": "hc7b2577_4", + "build_number": 4, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "c6b61eb698f270090ba2cc81a0335d95", + "name": "mkl-include", + "sha256": "b2dbc8146535e1c738fc029fc669a9298b9919a59b99f4e66f05b3f50f2e6d9f", + "size": 448400, + "subdir": "linux-64", + "timestamp": 1511376417391, + "version": "2018.0.1" + }, + "mkl-include-2018.0.2-1.conda": { + "build": "1", + "build_number": 1, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "b7b212e6f2fc7b4a907af357e523c321", + "name": "mkl-include", + "sha256": "4afa3092e2a316ef331af887c394e433c99fb95242c32f751dc9fb07ced47bdd", + "size": 448889, + "subdir": "linux-64", + "timestamp": 1521735601913, + "version": "2018.0.2" + }, + "mkl-include-2018.0.3-1.conda": { + "build": "1", + "build_number": 1, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "a7d4ab05ea541a9f853ab2b12e6d313f", + "name": "mkl-include", + "sha256": "12904e9af4c548345e88d064a19a073be5dbe25632fd77104dd36454379c3cf2", + "size": 450112, + "subdir": "linux-64", + "timestamp": 1528122055507, + "version": "2018.0.3" + }, + "mkl-include-2019.0-117.conda": { + "build": "117", + "build_number": 117, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "b91368733368cf24a83b9c57b5cda9d5", + "name": "mkl-include", + "sha256": "4262f817d54cb0e7f5c8f0d574c06bc4e694b93ee9f94e27fd226a024e94e55f", + "size": 455870, + "subdir": "linux-64", + "timestamp": 1536594379207, + "version": "2019.0" + }, + "mkl-include-2019.0-118.conda": { + "build": "118", + "build_number": 118, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "6d44ed11b8e17b0f85f391925b82a4f4", + "name": "mkl-include", + "sha256": "9b25033fcfd9e7169715a79e7b311c9af9b12d850367b5653f7f037f6bdf7e9f", + "size": 455122, + "subdir": "linux-64", + "timestamp": 1537292392867, + "version": "2019.0" + }, + "mkl-include-2019.1-144.conda": { + "build": "144", + "build_number": 144, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "c5e08306602c9a4356db6e338d702a7a", + "name": "mkl-include", + "sha256": "61677290e82d81e11510d4492686907ba60bd7d0768b3e8b0f710ff77886af49", + "size": 454700, + "subdir": "linux-64", + "timestamp": 1542661344765, + "version": "2019.1" + }, + "mkl-include-2019.3-199.conda": { + "build": "199", + "build_number": 199, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "e509be4d427bb6c321f2c7b8ab9e1215", + "name": "mkl-include", + "sha256": "d8efbcadeec0c369ff6f5dd9bc2fe967cdaf16f181aa5948c8a6ace71e701a34", + "size": 456207, + "subdir": "linux-64", + "timestamp": 1552593611793, + "version": "2019.3" + }, + "mkl-include-2019.4-243.conda": { + "build": "243", + "build_number": 243, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "50fbc11a1f49977db2a2c6aec466eb82", + "name": "mkl-include", + "sha256": "59e6d77a2508b6a25147e4a998065ea118dd660a90a85164fedc0583bf5b1130", + "size": 459294, + "subdir": "linux-64", + "timestamp": 1559526511979, + "version": "2019.4" + }, + "mkl-include-2020.0-166.conda": { + "build": "166", + "build_number": 166, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "166b5c744bc00bdc5526415a4c6aa209", + "name": "mkl-include", + "sha256": "90047f448e7ddca94667712bca97fe6626c759313b27c634a382065a04c0545f", + "size": 458239, + "subdir": "linux-64", + "timestamp": 1580943976649, + "version": "2020.0" + }, + "mkl-include-2020.1-217.conda": { + "build": "217", + "build_number": 217, + "depends": [], + "license": "proprietary - Intel", + "license_family": "Proprietary", + "md5": "00c6f62f942b60e0c35acd307ea8839d", + "name": "mkl-include", + "sha256": "1af60cdbbed6b437769731f8aead9a464dd67ba4ffa90146830f5bc33c22fa10", + "size": 460565, + "subdir": "linux-64", + "timestamp": 1589162246527, + "version": "2020.1" + }, + "mkl-include-2020.2-256.conda": { + "build": "256", + "build_number": 256, + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "7cd5ab9039226cae546eb0adac814f3e", + "name": "mkl-include", + "sha256": "25d29ac9c9952bf2024622ecd6ecef519f318a4247b179def8b98b61d3ee2f25", + "size": 471237, + "subdir": "linux-64", + "timestamp": 1598384196673, + "version": "2020.2" + }, + "mkl-include-2021.2.0-h06a4308_296.conda": { + "build": "h06a4308_296", + "build_number": 296, + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "9b0a9dc16f83d33703c0459672467c88", + "name": "mkl-include", + "sha256": "744bb2b58891c8fb23646af85c1bd691246f5d5d468b483cac53bed47f6917ac", + "size": 534196, + "subdir": "linux-64", + "timestamp": 1618534009438, + "version": "2021.2.0" + }, + "mkl-include-2021.3.0-h06a4308_520.conda": { + "build": "h06a4308_520", + "build_number": 520, + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "104112ce3868848fdbcb769f2a973998", + "name": "mkl-include", + "sha256": "37a5cff2e57385108098dced3809448dc6439c52191adc617e1c6f48b15f97f2", + "size": 544719, + "subdir": "linux-64", + "timestamp": 1626182300408, + "version": "2021.3.0" + }, + "mkl-include-2021.4.0-h06a4308_640.conda": { + "build": "h06a4308_640", + "build_number": 640, + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "ddcc2ac097416673affea92f1a308cc8", + "name": "mkl-include", + "sha256": "ccb1c95fa58548d2f91af89c3f70cef6befc631f47d368996456c94e91d74077", + "size": 548295, + "subdir": "linux-64", + "timestamp": 1634546769614, + "version": "2021.4.0" + }, + "mkl-include-2022.0.1-h06a4308_117.conda": { + "build": "h06a4308_117", + "build_number": 117, + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "fada2580e196c732785c688edf191900", + "name": "mkl-include", + "sha256": "3caf44212863a4b5838974c87c13b5c62ecc832d91957e045922e57e15bb21b0", + "size": 599146, + "subdir": "linux-64", + "timestamp": 1642705449302, + "version": "2022.0.1" + }, + "mkl-include-2022.1.0-h06a4308_224.conda": { + "build": "h06a4308_224", + "build_number": 224, + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "fe26b964df897facc5661fd6124ebabd", + "name": "mkl-include", + "sha256": "3b8bf82944e1db66801250f0d1f10d0045876a620eaa515eceb62a60f0ff84a8", + "size": 606352, + "subdir": "linux-64", + "timestamp": 1662497672210, + "version": "2022.1.0" + }, + "mkl-include-2023.0.0-h06a4308_25399.conda": { + "build": "h06a4308_25399", + "build_number": 25399, + "depends": [], + "license": "LicenseRef-ProprietaryIntel", + "license_family": "Proprietary", + "md5": "6e7cdb2ea667c25a56d202e782acb6eb", + "name": "mkl-include", + "sha256": "ba5d14aea69bbdcd96e2286bae1b7708c6e9dc8943705cb000d859817b8bae0f", + "size": 721669, + "subdir": "linux-64", + "timestamp": 1677516520184, + "version": "2023.0.0" + }, + "mkl-service-1.1.2-py27h651fb7a_4.conda": { + "build": "py27h651fb7a_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "bd9e1938cc21a8fc6778ab4db38407c8", + "name": "mkl-service", + "sha256": "d450f62f6981a1907ac30618e9e7a67801c379c3fc344bfdb317fb409f4384d1", + "size": 11039, + "subdir": "linux-64", + "timestamp": 1530696013217, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py27h90e4bf4_5.conda": { + "build": "py27h90e4bf4_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "2db0c5d0c5983527c081193592143d2f", + "name": "mkl-service", + "sha256": "760bf10d0e9eefbc45dac9056dff446bbeb52b32f8227f981453ef35a585bd92", + "size": 11175, + "subdir": "linux-64", + "timestamp": 1537536181426, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py27hb2d42c5_4.conda": { + "build": "py27hb2d42c5_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "8dea84c726198b20277a189eaeabfb96", + "name": "mkl-service", + "sha256": "1983c6f49b0d159898a977fa26e4742f225a0648fc33a6c69732ca3418af20ba", + "size": 10482, + "subdir": "linux-64", + "timestamp": 1505745850011, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py27he904b0f_5.conda": { + "build": "py27he904b0f_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "f3836d41679a9e83996518172e27a32b", + "name": "mkl-service", + "sha256": "8e9070a91ee8ba7f57d6c6aedf6a37f52daff18c3aab540a77759ae580e416f3", + "size": 152757, + "subdir": "linux-64", + "timestamp": 1544935218549, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py35h0fc7090_4.conda": { + "build": "py35h0fc7090_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "1c4b1849c7018911089f27464c02103f", + "name": "mkl-service", + "sha256": "eb396ba77318c7506e93067fe40c051659891bac599f413f68faf753f99e0213", + "size": 10622, + "subdir": "linux-64", + "timestamp": 1505745864508, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py35h651fb7a_4.conda": { + "build": "py35h651fb7a_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "6da8698ab600416a0f75c7ba909baf89", + "name": "mkl-service", + "sha256": "a8ea30a9c24dcb5381bf39fbb218c0f674e4ac739b0ed30c4158db2239e64ab4", + "size": 10986, + "subdir": "linux-64", + "timestamp": 1534345616729, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py35h90e4bf4_5.conda": { + "build": "py35h90e4bf4_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "090dd6ee15b6b0b0920b0909dcf761e1", + "name": "mkl-service", + "sha256": "bbdefedc50615845be4a9aace38c55536ad32660e6aa414f4ccc8e29e6c60c58", + "size": 11326, + "subdir": "linux-64", + "timestamp": 1537536212365, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py36h17a0993_4.conda": { + "build": "py36h17a0993_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "78b5dca1f6e737ba1dd0eced5f906b67", + "name": "mkl-service", + "sha256": "574405e7a3863fe88cce772db5e326c45c8925002b97bfed31fad651def3b1ea", + "size": 10746, + "subdir": "linux-64", + "timestamp": 1505745879701, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py36h651fb7a_4.conda": { + "build": "py36h651fb7a_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "0cc6c79237bb0299944420fefb8df1d1", + "name": "mkl-service", + "sha256": "13ce6947d69565dda4be49ba40968552c0c13e8cb588499c28d7836256c4eaa0", + "size": 10983, + "subdir": "linux-64", + "timestamp": 1530695963798, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py36h90e4bf4_5.conda": { + "build": "py36h90e4bf4_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "955346931fb2b81aa416817ad0ac2af2", + "name": "mkl-service", + "sha256": "af9690e2aae7ad7c9b63a363bfe3e45242331782e64c32bbe59e9e490a543c84", + "size": 11285, + "subdir": "linux-64", + "timestamp": 1537536233558, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py36he904b0f_5.conda": { + "build": "py36he904b0f_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "ddce2f891dad301a9c3d7bc542c5ec29", + "name": "mkl-service", + "sha256": "5eb0a7b2d565b73eef19f04733c9f0c6b348d55b799ca30c6528f1c78e916693", + "size": 152987, + "subdir": "linux-64", + "timestamp": 1544935298106, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py37h651fb7a_4.conda": { + "build": "py37h651fb7a_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "222a883a910ea3a25f8012eae4e3062c", + "name": "mkl-service", + "sha256": "25fe8f944344d8f0d96d6ed1fe88abb8def51b4324ab303867f2675fb919865c", + "size": 11168, + "subdir": "linux-64", + "timestamp": 1530695988102, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py37h90e4bf4_5.conda": { + "build": "py37h90e4bf4_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "52daa43a6896ce5d8a56b600004f32c5", + "name": "mkl-service", + "sha256": "6e0e7c22f99f8a5f6c6c5be1a5731d04715a5c31c3bdac1e818c3f17ee568eff", + "size": 11154, + "subdir": "linux-64", + "timestamp": 1537536095245, + "version": "1.1.2" + }, + "mkl-service-1.1.2-py37he904b0f_5.conda": { + "build": "py37he904b0f_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "f7a15e57f47da0390f9376d887a73f27", + "name": "mkl-service", + "sha256": "1a99543b33e1d83f98bcb9946ad7195865afc249415f288d5c8360ec222b7a37", + "size": 152896, + "subdir": "linux-64", + "timestamp": 1544935303295, + "version": "1.1.2" + }, + "mkl-service-2.0.2-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "235457697ae76c7f68af95a788e0cd9c", + "name": "mkl-service", + "sha256": "1ee19fdc0b578146a19126df4e8586f3272415ff659633fdfc15d26711f6ec59", + "size": 63800, + "subdir": "linux-64", + "timestamp": 1559316481875, + "version": "2.0.2" + }, + "mkl-service-2.0.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dcda6ad67d3a6007d79c161a27aed402", + "name": "mkl-service", + "sha256": "fdda5a460ca47a61088b0161619bb66b6f290b186b48dc0cd8f342e2df19ef64", + "size": 66120, + "subdir": "linux-64", + "timestamp": 1559316384631, + "version": "2.0.2" + }, + "mkl-service-2.0.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c2b1f471b680a5441bb9e91d606177d4", + "name": "mkl-service", + "sha256": "52224894eadcd5f34877a8897d2ec921d17dd5c665334588ac76c3a15a85d0d8", + "size": 66322, + "subdir": "linux-64", + "timestamp": 1559316371110, + "version": "2.0.2" + }, + "mkl-service-2.3.0-py27he904b0f_0.conda": { + "build": "py27he904b0f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "18f60fc2784b9a08bb5de87ad056bb64", + "name": "mkl-service", + "sha256": "9936cffcb1c948b5dd5dc3eb17336757d8ddd5c7b2afdb90408f77cfadf1d821", + "size": 221700, + "subdir": "linux-64", + "timestamp": 1567795987414, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "76c28a916c154e7fd956803a4eb37dd7", + "name": "mkl-service", + "sha256": "feb7577f3bd31cd28cedb42550483b53298689dbf84351c5b862bf9d4bbe44fd", + "size": 56153, + "subdir": "linux-64", + "timestamp": 1618348284133, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py36he8ac12f_0.conda": { + "build": "py36he8ac12f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "348fd94657c9dea093c2043f94664b12", + "name": "mkl-service", + "sha256": "9a4e70570708a1b0f06d0a9f4873287e8d9206b900a8deae68da13d2da47d9d8", + "size": 53242, + "subdir": "linux-64", + "timestamp": 1607032457694, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py36he904b0f_0.conda": { + "build": "py36he904b0f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "ab099a569184e311e9285b73535bc20f", + "name": "mkl-service", + "sha256": "6331a08c3baf06e18684045c3909aef02386c181f3a1eb30c3215ee5fcf3a809", + "size": 224726, + "subdir": "linux-64", + "timestamp": 1567796014703, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "11bebc2d7a8044bd93c70260d129fe43", + "name": "mkl-service", + "sha256": "a0bd4ba428f4f987bed0ef0d338a8305d7e7891a11e20f780665be8122d385f6", + "size": 55903, + "subdir": "linux-64", + "timestamp": 1618348297275, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py37he8ac12f_0.conda": { + "build": "py37he8ac12f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22fa74dfc830fd037481f883d7e9c1e2", + "name": "mkl-service", + "sha256": "b0bb72ab7182f2135bbbaa111d2c492914460cf0324eb2768ef1718a95f7ff2c", + "size": 53447, + "subdir": "linux-64", + "timestamp": 1607032437913, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py37he904b0f_0.conda": { + "build": "py37he904b0f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "aed7b1373aafcf69fa06dcab738e8bb4", + "name": "mkl-service", + "sha256": "cab2c33fc884144127313e4523c8b67b2c5fa9412a3432a5d7dbc2ea2e2f4c8c", + "size": 223648, + "subdir": "linux-64", + "timestamp": 1567796042190, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "acae2ba3d7cdcbba920d047eff310ae9", + "name": "mkl-service", + "sha256": "dc85112d17d7d4fc625208fd116025b1b7766ca636084428ae2557222f66becb", + "size": 58757, + "subdir": "linux-64", + "timestamp": 1618348300432, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "308daa4149091343f2cf4b4f92c9587e", + "name": "mkl-service", + "sha256": "3a33efb8fadd5e193c6101b5a98e7d6ed93d0dff85a72a50ebdfc2b590aaf8f4", + "size": 64643, + "subdir": "linux-64", + "timestamp": 1573151203928, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py38he904b0f_0.conda": { + "build": "py38he904b0f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "5f00243e62fc780feb1f96058a108368", + "name": "mkl-service", + "sha256": "21d52390b0ab202cae20f78532f4000ae96055b6db8067dc575ff6e835cbc06b", + "size": 63601, + "subdir": "linux-64", + "timestamp": 1573489133528, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c863ddb728a8a457250be29b1e39b32b", + "name": "mkl-service", + "sha256": "cc59a6a164373018f865de42c613fa9e26e7d0699cba195f10cca4555b3676fc", + "size": 58662, + "subdir": "linux-64", + "timestamp": 1618348287948, + "version": "2.3.0" + }, + "mkl-service-2.3.0-py39he8ac12f_0.conda": { + "build": "py39he8ac12f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "08c9edbaa8d52f3c8fee4fcebd330a3d", + "name": "mkl-service", + "sha256": "e5ddd10501b449f230d22eb2a231778a04c893d267a3fbcfc6afb58d8e22ac9e", + "size": 55750, + "subdir": "linux-64", + "timestamp": 1607032458836, + "version": "2.3.0" + }, + "mkl-service-2.4.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "06f1d5d8e31213836a6bffe57e33dd16", + "name": "mkl-service", + "sha256": "802df0dda2004e951edefaf68a95426137d065f8749246a22646d3012ec73bd1", + "size": 181558, + "subdir": "linux-64", + "timestamp": 1641844379720, + "version": "2.4.0" + }, + "mkl-service-2.4.0-py310heee7806_0.conda": { + "build": "py310heee7806_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bcddcc5c2aa42f275e778614772e85a8", + "name": "mkl-service", + "sha256": "09ec541573907cfe56f454a35d6f995d5570a999046c086ce8e5fedb6b204f5d", + "size": 184186, + "subdir": "linux-64", + "timestamp": 1639659879355, + "version": "2.4.0" + }, + "mkl-service-2.4.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6c391f19f2d36aacad5ec85b0949ee45", + "name": "mkl-service", + "sha256": "23023c563216182a51fd58294d45a6a481d20a91d3f299f43727bcb705f1688a", + "size": 54693, + "subdir": "linux-64", + "timestamp": 1676845023960, + "version": "2.4.0" + }, + "mkl-service-2.4.0-py36h7f8727e_0.conda": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mkl >=2021.2.0,<2022.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "60a8cfa37f809329c874c8ff08ccd4b4", + "name": "mkl-service", + "sha256": "00ea4bab151382398005d30a9af9137861a7a46af31917f5c7c12bf062149189", + "size": 57614, + "subdir": "linux-64", + "timestamp": 1626183963757, + "version": "2.4.0" + }, + "mkl-service-2.4.0-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mkl >=2021.2.0,<2022.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b7716046057007575e9240381549b0cf", + "name": "mkl-service", + "sha256": "5241d081266a76a41c7609dc56b1ac8bfaee392695b8d4a03e2ccbe98f2c1f60", + "size": 57699, + "subdir": "linux-64", + "timestamp": 1626183943934, + "version": "2.4.0" + }, + "mkl-service-2.4.0-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mkl >=2021.2.0,<2022.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d44a183b4c54b461a8fa24805c53179a", + "name": "mkl-service", + "sha256": "a4b2a68d18486f17c2c5ef5b5d268643ea2fb65e99d61c8b73fd3a89ad076ab9", + "size": 60845, + "subdir": "linux-64", + "timestamp": 1626183937671, + "version": "2.4.0" + }, + "mkl-service-2.4.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mkl >=2021.2.0,<2022.0a0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "172ea5cc5cdc863201cdc4653f836bcb", + "name": "mkl-service", + "sha256": "4308d6bda152a035cb0ffd372dce0149d65ae53f756dd1776b695b5306c6a846", + "size": 60406, + "subdir": "linux-64", + "timestamp": 1626176932911, + "version": "2.4.0" + }, + "mkl_fft-1.0.1-py27h3010b51_0.conda": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD", + "md5": "36ad67f054b1c7f89e3e415cb7d695f8", + "name": "mkl_fft", + "sha256": "04be0bed3faf46172fefc7f5e5736713817b79fdb8bbb30db33bf03239fef598", + "size": 124523, + "subdir": "linux-64", + "timestamp": 1519403907993, + "version": "1.0.1" + }, + "mkl_fft-1.0.1-py35h3010b51_0.conda": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD", + "md5": "20d7e2b1c0b0f575c6e84ac64d2747f6", + "name": "mkl_fft", + "sha256": "992e59835324b0fc2d1f1448b243a551b0ac2eca4ab085444c13f38fae90c5b0", + "size": 127078, + "subdir": "linux-64", + "timestamp": 1519404566936, + "version": "1.0.1" + }, + "mkl_fft-1.0.1-py36h3010b51_0.conda": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mkl", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD", + "md5": "b2cd63bbf101c5c254fbfb7323bb12dd", + "name": "mkl_fft", + "sha256": "774aea442cca67c66b0a1b1c83bd00ca422464df9d072a01ace8eaa5bb22ee24", + "size": 127446, + "subdir": "linux-64", + "timestamp": 1519403814410, + "version": "1.0.1" + }, + "mkl_fft-1.0.10-py27ha843d7b_0.conda": { + "build": "py27ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cc6c6beeb06f835623c2c1214306d411", + "name": "mkl_fft", + "sha256": "af10b2d696d73d270b8c2a625f952b80df8a4571efe52a5600aa2487dd442e7f", + "size": 148516, + "subdir": "linux-64", + "timestamp": 1547238499605, + "version": "1.0.10" + }, + "mkl_fft-1.0.10-py36ha843d7b_0.conda": { + "build": "py36ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5f398300dd3dad46a24c43617a3b650e", + "name": "mkl_fft", + "sha256": "38130eefc53ed11d14fd43f47812a5769a3e2ce5f572a2a25fa3bee5b3c6536d", + "size": 156365, + "subdir": "linux-64", + "timestamp": 1547238568666, + "version": "1.0.10" + }, + "mkl_fft-1.0.10-py37ha843d7b_0.conda": { + "build": "py37ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4ac7e25eac2efb29acdfad617bd100f9", + "name": "mkl_fft", + "sha256": "65b4a1e2fa04a9ca15ae700af72099d5509af826012b7a1ddaa91a86eee368d1", + "size": 155596, + "subdir": "linux-64", + "timestamp": 1547238476684, + "version": "1.0.10" + }, + "mkl_fft-1.0.12-py27ha843d7b_0.conda": { + "build": "py27ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8b68ebcba0bc8634baf2cd7f71ead380", + "name": "mkl_fft", + "sha256": "c1772a373ff113b3e90e1442735a4068a4541280e2a218523749e67e94183989", + "size": 149972, + "subdir": "linux-64", + "timestamp": 1556550168042, + "version": "1.0.12" + }, + "mkl_fft-1.0.12-py36ha843d7b_0.conda": { + "build": "py36ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d1b5101d287e4e7e53a7e848321af135", + "name": "mkl_fft", + "sha256": "88ada36af46640ad1771adb7f1ea9aa2b1e16a722b0cbd667b2cfaa58dfc08a5", + "size": 158830, + "subdir": "linux-64", + "timestamp": 1556550129699, + "version": "1.0.12" + }, + "mkl_fft-1.0.12-py37ha843d7b_0.conda": { + "build": "py37ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2ccfd4c9d46c9b7b1c62d6f5e00391f1", + "name": "mkl_fft", + "sha256": "d40ab1e3827c16e3c4e0f93adb94cd35723fe53b894a6c54a47f3522b21a76b0", + "size": 157318, + "subdir": "linux-64", + "timestamp": 1556550047823, + "version": "1.0.12" + }, + "mkl_fft-1.0.14-py27ha843d7b_0.conda": { + "build": "py27ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "826c20efcda1375c0da31d1097c606a9", + "name": "mkl_fft", + "sha256": "019de3643e9e4c6b7848ba9b2b248b1c4654a35451e32a90efa34d0f32a4dc23", + "size": 149036, + "subdir": "linux-64", + "timestamp": 1565899092135, + "version": "1.0.14" + }, + "mkl_fft-1.0.14-py36ha843d7b_0.conda": { + "build": "py36ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "195363d1ae9e9cf4ecfad1be2bb3e09c", + "name": "mkl_fft", + "sha256": "3ce7a1096277aa4772651a14e78d634f63246d9719c71aa62ba4182fd6216c61", + "size": 158551, + "subdir": "linux-64", + "timestamp": 1565898881483, + "version": "1.0.14" + }, + "mkl_fft-1.0.14-py37ha843d7b_0.conda": { + "build": "py37ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c9638694f6c5d9d99a744699c0429e59", + "name": "mkl_fft", + "sha256": "f7b5fc1752aceac3bb45e589871bdbdedbe883d7d6e15348244d65c3660d845c", + "size": 158299, + "subdir": "linux-64", + "timestamp": 1565899130807, + "version": "1.0.14" + }, + "mkl_fft-1.0.15-py27ha843d7b_0.conda": { + "build": "py27ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f770a205911380a74294d589e183ded6", + "name": "mkl_fft", + "sha256": "7f705a2c099c895e4aa6d15d0c64692daebd2831202f930700d5fc0d182623f1", + "size": 149752, + "subdir": "linux-64", + "timestamp": 1573077616164, + "version": "1.0.15" + }, + "mkl_fft-1.0.15-py36ha843d7b_0.conda": { + "build": "py36ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9163dbec7de3bfff365e3082b02f195b", + "name": "mkl_fft", + "sha256": "3b53fd9c3cebe0b1bbc2f640eed67ef6d4d9492eb36c92abae3c91eca25bdb2d", + "size": 158471, + "subdir": "linux-64", + "timestamp": 1573077627240, + "version": "1.0.15" + }, + "mkl_fft-1.0.15-py37ha843d7b_0.conda": { + "build": "py37ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fa0c2516ecba7d889d37db63d320660e", + "name": "mkl_fft", + "sha256": "eac0b9b5e8616eab3b7426cb0cc65cc96c27dfc22b3d76a342d44dd9da219c07", + "size": 157463, + "subdir": "linux-64", + "timestamp": 1573077646133, + "version": "1.0.15" + }, + "mkl_fft-1.0.15-py38ha843d7b_0.conda": { + "build": "py38ha843d7b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "00722cdb7c9d7dc0481b8daa1a801c97", + "name": "mkl_fft", + "sha256": "e86270068702be6e98ed156d613dd8fe97cfb52aca313dc5dc67874f8e88ca2f", + "size": 162779, + "subdir": "linux-64", + "timestamp": 1573738232276, + "version": "1.0.15" + }, + "mkl_fft-1.0.2-py27h651fb7a_0.conda": { + "build": "py27h651fb7a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "4098a527f0f9e074b38761632043f0b7", + "name": "mkl_fft", + "sha256": "2cbd15e073794d6a6b52051349cc086db7d8d265f950a310f993218498126a17", + "size": 125601, + "subdir": "linux-64", + "timestamp": 1530725215767, + "version": "1.0.2" + }, + "mkl_fft-1.0.2-py35h651fb7a_0.conda": { + "build": "py35h651fb7a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "556f6c78cc32393e122331b8af820fba", + "name": "mkl_fft", + "sha256": "926b633ce13ed212349a774d515feb3c6fd05bce37fc4e7f1e4cbaebaa5091c7", + "size": 126744, + "subdir": "linux-64", + "timestamp": 1534346694665, + "version": "1.0.2" + }, + "mkl_fft-1.0.2-py36h651fb7a_0.conda": { + "build": "py36h651fb7a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "42ab36af024c635fed36d0dd5e214edf", + "name": "mkl_fft", + "sha256": "e1c922dec166ad98d561af65e4a90b51a88c0e80488347978254618b352bbb6a", + "size": 128069, + "subdir": "linux-64", + "timestamp": 1530723353179, + "version": "1.0.2" + }, + "mkl_fft-1.0.2-py37h651fb7a_0.conda": { + "build": "py37h651fb7a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "464b8022f7cdf21bd457a7a0f750cba9", + "name": "mkl_fft", + "sha256": "296c135f25bd488e07cca92c76718535f30a3aa087d7dde1cd0faa85be02d28e", + "size": 128445, + "subdir": "linux-64", + "timestamp": 1530716420410, + "version": "1.0.2" + }, + "mkl_fft-1.0.4-py27h4414c95_0.conda": { + "build": "py27h4414c95_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b1c9055500b2af02992e6375d7babe27", + "name": "mkl_fft", + "sha256": "8c89b6389bb1fd5db9407bd33e0779c088b2a6b33a8cd3c576054bb7624e7eca", + "size": 134411, + "subdir": "linux-64", + "timestamp": 1532663179487, + "version": "1.0.4" + }, + "mkl_fft-1.0.4-py27h4414c95_1.conda": { + "build": "py27h4414c95_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5a1c42475dedcc18f58be0348e108f66", + "name": "mkl_fft", + "sha256": "c24ab83a83bc1f74ae74c2afbc912632a455e757989bb54b069dc0cd1580037f", + "size": 134549, + "subdir": "linux-64", + "timestamp": 1532700925153, + "version": "1.0.4" + }, + "mkl_fft-1.0.4-py35h4414c95_0.conda": { + "build": "py35h4414c95_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4097cbeec0030685b31d78c96c4d39c6", + "name": "mkl_fft", + "sha256": "544be62d8d3ea590cef35589bd7eb71f32d621b8dc0f19a57358922b72f20dc2", + "size": 135571, + "subdir": "linux-64", + "timestamp": 1532663187879, + "version": "1.0.4" + }, + "mkl_fft-1.0.4-py35h4414c95_1.conda": { + "build": "py35h4414c95_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5ca3d2403ff4e7746fd5fa5a7a3def03", + "name": "mkl_fft", + "sha256": "5208f70bdae978b00c656f7e7e742d810017ed67618ee0a45d1b6dedf9e04e2b", + "size": 135740, + "subdir": "linux-64", + "timestamp": 1532701016345, + "version": "1.0.4" + }, + "mkl_fft-1.0.4-py36h4414c95_0.conda": { + "build": "py36h4414c95_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "86a26248a59b8e456aa10d9f9b658748", + "name": "mkl_fft", + "sha256": "9c5512da4f9a2d16133ee9c5b8f93aa4644d3274b8048cf9d2cceb4068b4932c", + "size": 136257, + "subdir": "linux-64", + "timestamp": 1532656775556, + "version": "1.0.4" + }, + "mkl_fft-1.0.4-py36h4414c95_1.conda": { + "build": "py36h4414c95_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f8596d275c84a67881597aa1ea7d7e3b", + "name": "mkl_fft", + "sha256": "e7322ab906a92f7042fe1db1fa0085177ee39d20e3d6f4f31357167ebeace521", + "size": 136564, + "subdir": "linux-64", + "timestamp": 1532700514318, + "version": "1.0.4" + }, + "mkl_fft-1.0.4-py37h4414c95_0.conda": { + "build": "py37h4414c95_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3c5f2cdd452b14bbcbd67d92796bfd11", + "name": "mkl_fft", + "sha256": "34e03a7b65227e663ad20806f6d5ba303aa012392df81250b91aa151597d3c02", + "size": 134905, + "subdir": "linux-64", + "timestamp": 1532656777260, + "version": "1.0.4" + }, + "mkl_fft-1.0.4-py37h4414c95_1.conda": { + "build": "py37h4414c95_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "107b5af7ef5cf7ef555741d7f3f2ac2c", + "name": "mkl_fft", + "sha256": "17238f293a9b4978d7c3a45580af1fe4b551a97f25ca8ccf14b3a38d82b04d27", + "size": 135276, + "subdir": "linux-64", + "timestamp": 1532701018408, + "version": "1.0.4" + }, + "mkl_fft-1.0.6-py27h423224d_0.conda": { + "build": "py27h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.6,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a02774708346c8259b4dc366a9b3be80", + "name": "mkl_fft", + "sha256": "4a537b3c1b045af58054ee3ee56f0856814dbf6ab8cf83753402b38b1fbcec16", + "size": 177421, + "subdir": "linux-64", + "timestamp": 1580501570031, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py27h7dd41cf_0.conda": { + "build": "py27h7dd41cf_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "51a9393f31850bf1e45fffe48e854cc6", + "name": "mkl_fft", + "sha256": "fb3717bd56f4bd63a8029785fac8b9e278c3cb2e485715ff4433c678eae7b1c6", + "size": 137142, + "subdir": "linux-64", + "timestamp": 1538068237670, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py27hd81dba3_0.conda": { + "build": "py27hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy-base >=1.0.6,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "095b71ba2edc228f6f3f47380f1930b9", + "name": "mkl_fft", + "sha256": "3ce6fab4742773e009442f4c76c2f4d27d1dd32141eb7d7d06205364e1257719", + "size": 176697, + "subdir": "linux-64", + "timestamp": 1544718170889, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py35h7dd41cf_0.conda": { + "build": "py35h7dd41cf_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3ced4e63ccb867e1ab030b999a76d49d", + "name": "mkl_fft", + "sha256": "bbb12218ca70b2677caf010030f0ed6eef5f437e1743185c14b7704137520a48", + "size": 136762, + "subdir": "linux-64", + "timestamp": 1538068269713, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py36h423224d_0.conda": { + "build": "py36h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "df8d1b53551b2afd7b759b3b376fe344", + "name": "mkl_fft", + "sha256": "1891f629ce055ba3c6c22a26d2f5f929d4facd9f17c494fe59814e2c5b82ff94", + "size": 182687, + "subdir": "linux-64", + "timestamp": 1580488396134, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py36h7dd41cf_0.conda": { + "build": "py36h7dd41cf_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "84fce22a1743a651c9a8254bec6c9b14", + "name": "mkl_fft", + "sha256": "2c299f74c1d022e872ca1b229ab6297282ca52b126bd664b836e20ef973f9db1", + "size": 137949, + "subdir": "linux-64", + "timestamp": 1538068191970, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py36hd81dba3_0.conda": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy-base >=1.0.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9ee1c3e242e5d7b7a381820914b38f6e", + "name": "mkl_fft", + "sha256": "ff424f9b654d8d4f17651729b20efcdc53ea4c5ac6e43fc9a569ad1a99ab125d", + "size": 182261, + "subdir": "linux-64", + "timestamp": 1544718232355, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py37h423224d_0.conda": { + "build": "py37h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6c9170b22bf9ff5f48cbb7ecea28c3ee", + "name": "mkl_fft", + "sha256": "a05539d8ae58193e1af1c8affe9f3735bc0b9e7312891baca7981abc01f7963e", + "size": 182440, + "subdir": "linux-64", + "timestamp": 1580488314346, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py37h7dd41cf_0.conda": { + "build": "py37h7dd41cf_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a6b056ab261ff08f4b82f683d1349cd0", + "name": "mkl_fft", + "sha256": "378ac91992e9c9a8ae41b60c24a3b53d865fa8be62f02dd17b7711aca0c73683", + "size": 137070, + "subdir": "linux-64", + "timestamp": 1538068178568, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py37hd81dba3_0.conda": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy-base >=1.0.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "95b6afb80605de7d53293bb62b47f921", + "name": "mkl_fft", + "sha256": "13cbe56fb199ed1ab630b6acf05fac02ef34d66aed9b9646669eb10b9bf83e6b", + "size": 181679, + "subdir": "linux-64", + "timestamp": 1544718346302, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py38h423224d_0.conda": { + "build": "py38h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "95f67e71a051f3c4b8e31f6d9476e45b", + "name": "mkl_fft", + "sha256": "468c9b76b21dfcb7e368ab7a96507f0cbc74c68ba4e4389abb0e8ed7dc306e57", + "size": 190052, + "subdir": "linux-64", + "timestamp": 1580495288476, + "version": "1.0.6" + }, + "mkl_fft-1.0.6-py39h63df603_0.conda": { + "build": "py39h63df603_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "413f14300d786a52ebf7417a4e6ffffa", + "name": "mkl_fft", + "sha256": "f9dad7d70f088e5bb8fe4a9868c21f2e7da5a2acc96a3d430b0e2a9c4911ed92", + "size": 176370, + "subdir": "linux-64", + "timestamp": 1607432338100, + "version": "1.0.6" + }, + "mkl_fft-1.1.0-py36h23d657b_0.conda": { + "build": "py36h23d657b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4d9969bc2703b886c53a2fa4eaf5e71a", + "name": "mkl_fft", + "sha256": "7a614d46a8a6d83605992c32b43c8bf768c6c8e4b6153fbe1a00fa6f6bd2f97d", + "size": 147259, + "subdir": "linux-64", + "timestamp": 1592407000998, + "version": "1.1.0" + }, + "mkl_fft-1.1.0-py37h23d657b_0.conda": { + "build": "py37h23d657b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "47f08b7d64477d43c3434867c5638e9d", + "name": "mkl_fft", + "sha256": "363651a146634a5f7d3648a4b517a9718ac6b6590ad41bfb365a0ec1632fb0ed", + "size": 146501, + "subdir": "linux-64", + "timestamp": 1592406998976, + "version": "1.1.0" + }, + "mkl_fft-1.1.0-py38h23d657b_0.conda": { + "build": "py38h23d657b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "637bb27a560c223bbc3d9e1e033ac926", + "name": "mkl_fft", + "sha256": "91872b39b4454f066caaf8add1c6d1580dd17098e8e84c87495d0ec2003b2792", + "size": 153438, + "subdir": "linux-64", + "timestamp": 1592406998848, + "version": "1.1.0" + }, + "mkl_fft-1.2.0-py36h23d657b_0.conda": { + "build": "py36h23d657b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "990956fdecc5d11df64f1c3f7036d9bf", + "name": "mkl_fft", + "sha256": "f6bcac57508c739a0ed29a108daefa529a01459fcb196aa162b6f671d8fb28c2", + "size": 152931, + "subdir": "linux-64", + "timestamp": 1600444550541, + "version": "1.2.0" + }, + "mkl_fft-1.2.0-py37h23d657b_0.conda": { + "build": "py37h23d657b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3c2255b81b93c65443f20b30bc4b9d24", + "name": "mkl_fft", + "sha256": "aaab72402650e5e1e62be30e2af25dcacf84805c96e562387b5a04d763300380", + "size": 151960, + "subdir": "linux-64", + "timestamp": 1600444522443, + "version": "1.2.0" + }, + "mkl_fft-1.2.0-py38h23d657b_0.conda": { + "build": "py38h23d657b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c716cfb0ad76f3c0f0bb0e9586e09bd4", + "name": "mkl_fft", + "sha256": "0d51b07d7b0e3eefd4560a98e144ec49ff4a37bba106d2f4b4b5db18ab480528", + "size": 160576, + "subdir": "linux-64", + "timestamp": 1600444504891, + "version": "1.2.0" + }, + "mkl_fft-1.2.1-py36h54f3939_0.conda": { + "build": "py36h54f3939_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "73a0c36208c16a4b672bae466273b75e", + "name": "mkl_fft", + "sha256": "6b8556694fc23581409aa5014979430a87b893e3ef6ed21cf8ecbfc2e3fa46d4", + "size": 152819, + "subdir": "linux-64", + "timestamp": 1613676685307, + "version": "1.2.1" + }, + "mkl_fft-1.2.1-py37h54f3939_0.conda": { + "build": "py37h54f3939_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "09e4eb1ec5c77a27bc97b246d91de911", + "name": "mkl_fft", + "sha256": "c70c0f6d3962f365339a292d0e4b096cee4b4d8462451f4ea3a3bbdd1e5b19a6", + "size": 151779, + "subdir": "linux-64", + "timestamp": 1613676673024, + "version": "1.2.1" + }, + "mkl_fft-1.2.1-py37h807cd23_1.conda": { + "build": "py37h807cd23_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base >=1.2.1,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "570b8fa852d69344c36c3869a405f2f7", + "name": "mkl_fft", + "sha256": "fe2df5742fe6e286e38d34e7a5c2147fedd9731db0dc260e49941d55b3ef30ef", + "size": 193461, + "subdir": "linux-64", + "timestamp": 1654863854655, + "version": "1.2.1" + }, + "mkl_fft-1.2.1-py38h54f3939_0.conda": { + "build": "py38h54f3939_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2fe791ae29b9fe15a93260ddce8c9977", + "name": "mkl_fft", + "sha256": "35a5af403c40012e53c1a3fe79109896a4942d34b2cf267a04f7cf8296d56c2e", + "size": 161158, + "subdir": "linux-64", + "timestamp": 1613676650333, + "version": "1.2.1" + }, + "mkl_fft-1.2.1-py38h807cd23_1.conda": { + "build": "py38h807cd23_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base >=1.2.1,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "65a94cc43803269aaf1771870181f93b", + "name": "mkl_fft", + "sha256": "11de4beeaee260fa4470a06d6daeeb0a88563318d51096b7c5d29b6844e406e4", + "size": 200815, + "subdir": "linux-64", + "timestamp": 1654864484155, + "version": "1.2.1" + }, + "mkl_fft-1.2.1-py39h54f3939_0.conda": { + "build": "py39h54f3939_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a89bca88762c662e736e4c76149a51b8", + "name": "mkl_fft", + "sha256": "2cf6f96de0af103b80f15344c19efa77bc8a99cfd55c9df318bf04678f29099d", + "size": 160523, + "subdir": "linux-64", + "timestamp": 1613676682979, + "version": "1.2.1" + }, + "mkl_fft-1.2.1-py39h807cd23_1.conda": { + "build": "py39h807cd23_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base >=1.2.1,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a210a3bcfb4eb8b205205281a539d8a2", + "name": "mkl_fft", + "sha256": "c678dae7d82c64323fc66e31f256a2ff32952d7b1efc45474a887aa17c97c2ce", + "size": 198286, + "subdir": "linux-64", + "timestamp": 1654864168879, + "version": "1.2.1" + }, + "mkl_fft-1.3.0-py36h42c9631_2.conda": { + "build": "py36h42c9631_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4beba30d70b8e28c832e26e22ba9e6dd", + "name": "mkl_fft", + "sha256": "b487b07b46cf20b26f53100f4e6de32f42851c3a69d44738c876ca170f1ae3ee", + "size": 175012, + "subdir": "linux-64", + "timestamp": 1618861123730, + "version": "1.3.0" + }, + "mkl_fft-1.3.0-py36h54f3939_0.conda": { + "build": "py36h54f3939_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b1b872f6f5be9c00e08b60f100ae3c5d", + "name": "mkl_fft", + "sha256": "9337b956a7d9761cfe8b5a225503c65b767b88a5e1dbe2581858dd335e93ca69", + "size": 173593, + "subdir": "linux-64", + "timestamp": 1614364012524, + "version": "1.3.0" + }, + "mkl_fft-1.3.0-py37h42c9631_2.conda": { + "build": "py37h42c9631_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1dfc6fe3e47ecb697aa864c8ed45d744", + "name": "mkl_fft", + "sha256": "159532c621c2c14644c281ce9d723b280c0e3f1cbb94afc5df1f36ba5707e475", + "size": 173751, + "subdir": "linux-64", + "timestamp": 1618850762751, + "version": "1.3.0" + }, + "mkl_fft-1.3.0-py37h54f3939_0.conda": { + "build": "py37h54f3939_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d5ac370421c8921ede796279e2a349ca", + "name": "mkl_fft", + "sha256": "00de76c419514c491e5157b3a63b9a01d9f89be89d2ebc49a587defc80f679dc", + "size": 171122, + "subdir": "linux-64", + "timestamp": 1614362923631, + "version": "1.3.0" + }, + "mkl_fft-1.3.0-py38h42c9631_2.conda": { + "build": "py38h42c9631_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "466c36695155a88248c4cde9871309e2", + "name": "mkl_fft", + "sha256": "d3a407b82a9f5c60407663f856bc24f7e2052fab1595d78c277ff8400d00ba57", + "size": 184714, + "subdir": "linux-64", + "timestamp": 1618854093151, + "version": "1.3.0" + }, + "mkl_fft-1.3.0-py38h54f3939_0.conda": { + "build": "py38h54f3939_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a7907679fd422d0b365b7abba03faa2e", + "name": "mkl_fft", + "sha256": "7518b894ad2f3f22c12ea26bc2fe5ab95d8ffb6d280eb63a3a10342f8e944aaa", + "size": 180992, + "subdir": "linux-64", + "timestamp": 1614363679071, + "version": "1.3.0" + }, + "mkl_fft-1.3.0-py39h42c9631_2.conda": { + "build": "py39h42c9631_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b34caac71202b6cabf25e204ca4de7af", + "name": "mkl_fft", + "sha256": "fbf574add25dd62f5f1df6b41098017e758bf95a4029a4fa7219ffaff92d6774", + "size": 183018, + "subdir": "linux-64", + "timestamp": 1618854090397, + "version": "1.3.0" + }, + "mkl_fft-1.3.0-py39h54f3939_0.conda": { + "build": "py39h54f3939_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "89501dfd25438e3e2d22b74af169cde4", + "name": "mkl_fft", + "sha256": "e167128ee6502be59dadd6a04275914ef0ae3f6e6eec2648492cee158e337423", + "size": 180609, + "subdir": "linux-64", + "timestamp": 1614363991480, + "version": "1.3.0" + }, + "mkl_fft-1.3.1-py310h6feb928_0.conda": { + "build": "py310h6feb928_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7925324b67fc15a5c65bccf40cf98bf3", + "name": "mkl_fft", + "sha256": "ee969d1ed16c9e8dc3cdf8d08e05a944be756a6d78465ca8f1e3491c33791aa4", + "size": 584832, + "subdir": "linux-64", + "timestamp": 1639978391944, + "version": "1.3.1" + }, + "mkl_fft-1.3.1-py310hd6ae3a3_0.conda": { + "build": "py310hd6ae3a3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a5b8880749ff58de60653472cd202aa0", + "name": "mkl_fft", + "sha256": "34be3dbd2bdd819f49d4f41c5c8b02be4deec033f359becbe5c69bdf6b0cf3ab", + "size": 580138, + "subdir": "linux-64", + "timestamp": 1641843696839, + "version": "1.3.1" + }, + "mkl_fft-1.3.1-py311h30b3d60_0.conda": { + "build": "py311h30b3d60_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.22,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6d5a0e45b9af9ae7bf6794bdb69290c5", + "name": "mkl_fft", + "sha256": "7b366878e488f0e6e7716b5f6050d4fd840ef3ec78de0003a81b1c10df2de6de", + "size": 187496, + "subdir": "linux-64", + "timestamp": 1676828111586, + "version": "1.3.1" + }, + "mkl_fft-1.3.1-py37hd3c417c_0.conda": { + "build": "py37hd3c417c_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fea25a63aadc117afb4bb6a1c52f3a06", + "name": "mkl_fft", + "sha256": "4e86bf2fbc93837deb0ccaf1f210d95c98b1bc5392d9f5ee1d4466a135d3b58d", + "size": 175851, + "subdir": "linux-64", + "timestamp": 1634555144690, + "version": "1.3.1" + }, + "mkl_fft-1.3.1-py38hd3c417c_0.conda": { + "build": "py38hd3c417c_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f0cb7b8e06ed6eef75a1ba9c01a4550c", + "name": "mkl_fft", + "sha256": "08d00049727bf4cca8719cc8a32b80efc23667268d5583d620770e9442a9e686", + "size": 184750, + "subdir": "linux-64", + "timestamp": 1634566418352, + "version": "1.3.1" + }, + "mkl_fft-1.3.1-py39hd3c417c_0.conda": { + "build": "py39hd3c417c_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "629b503bd4d1c5244f6dec56eb6b83fa", + "name": "mkl_fft", + "sha256": "02adf9b03e7499b9cc0193ed29d5efb4ca65823db5b6b3fb1c509f8f0d7a93fd", + "size": 186291, + "subdir": "linux-64", + "timestamp": 1634566416657, + "version": "1.3.1" + }, + "mkl_random-1.0.1-py27h4414c95_1.conda": { + "build": "py27h4414c95_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1fcd3c6b4dfd3ed614b7292132f5a889", + "name": "mkl_random", + "sha256": "a981b34bc51739749fe5f6d05ee7301ab92744258898579b5da99240fc3ecd1c", + "size": 317085, + "subdir": "linux-64", + "timestamp": 1530727514494, + "version": "1.0.1" + }, + "mkl_random-1.0.1-py27h629b387_0.conda": { + "build": "py27h629b387_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "142a0c4e0225198bd905888703603351", + "name": "mkl_random", + "sha256": "fcdd07bd698350c8243338fd96f94ae0f5a99a012768d4a83ba235e2fe372b5f", + "size": 320969, + "subdir": "linux-64", + "timestamp": 1520264757385, + "version": "1.0.1" + }, + "mkl_random-1.0.1-py35h4414c95_1.conda": { + "build": "py35h4414c95_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "83b07ffb4cabca702cfe09c2e6931560", + "name": "mkl_random", + "sha256": "cb7dabb0e6ed60d9dcc3115e793d5754fe8eaea5323864b48974e55c0160b9e7", + "size": 320600, + "subdir": "linux-64", + "timestamp": 1534347435802, + "version": "1.0.1" + }, + "mkl_random-1.0.1-py35h629b387_0.conda": { + "build": "py35h629b387_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "19514e02e78857b2510b59e29360aa5c", + "name": "mkl_random", + "sha256": "8ab08b6df9f10e68687bfdc6fd38a5fb9d0fd269b6cb088a16486c03e682c244", + "size": 322036, + "subdir": "linux-64", + "timestamp": 1520264780816, + "version": "1.0.1" + }, + "mkl_random-1.0.1-py36h4414c95_1.conda": { + "build": "py36h4414c95_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6ed1c6ef871cbacc1888f3ce6ca1e865", + "name": "mkl_random", + "sha256": "382e372cd49b907df035ca564cc7ad5f091b13b60b92a9525866cf4793ba06bc", + "size": 331797, + "subdir": "linux-64", + "timestamp": 1530727618262, + "version": "1.0.1" + }, + "mkl_random-1.0.1-py36h629b387_0.conda": { + "build": "py36h629b387_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "402c2804e5238032b2b6faac2859e8a1", + "name": "mkl_random", + "sha256": "c3290f9bc2bd6ef4a665ba94d72d7580b576a92a85c9b5ff1ccf375d996dfc38", + "size": 336221, + "subdir": "linux-64", + "timestamp": 1520264695959, + "version": "1.0.1" + }, + "mkl_random-1.0.1-py37h4414c95_1.conda": { + "build": "py37h4414c95_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d7706e1730463da9d175b0a97ca08158", + "name": "mkl_random", + "sha256": "d1b94306f92aca989de42ae42423963830522fa303012c0c99d7c23b043f36c7", + "size": 328794, + "subdir": "linux-64", + "timestamp": 1530727564583, + "version": "1.0.1" + }, + "mkl_random-1.0.2-py27h423224d_0.conda": { + "build": "py27h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.2,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "048173d7899e0170486ca3b8910aa530", + "name": "mkl_random", + "sha256": "90482415c9822d8ae362ae4133e6b03ca5ad8b259b741c1ff194e0750af26f6f", + "size": 343059, + "subdir": "linux-64", + "timestamp": 1580501604876, + "version": "1.0.2" + }, + "mkl_random-1.0.2-py27hd81dba3_0.conda": { + "build": "py27hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy-base >=1.0.2,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "32d04cee86c538746ef67821b8084646", + "name": "mkl_random", + "sha256": "de962858d062a7bca4394adc66a1c0f18ec647b2e52781db6d49eb1299cbd58c", + "size": 341421, + "subdir": "linux-64", + "timestamp": 1544718209705, + "version": "1.0.2" + }, + "mkl_random-1.0.2-py36h423224d_0.conda": { + "build": "py36h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.2,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "55fea9a6cd8a6c3a9207d4e5acec3d00", + "name": "mkl_random", + "sha256": "ed26db00fffe12a7c29f712ec7e29c4eb3fd43b2c442c74ca9984344d65339f1", + "size": 371894, + "subdir": "linux-64", + "timestamp": 1580488456855, + "version": "1.0.2" + }, + "mkl_random-1.0.2-py36hd81dba3_0.conda": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy-base >=1.0.2,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7f0277fbd9cf3c78e0d48153130bdf98", + "name": "mkl_random", + "sha256": "fc792bf044c2dfe18f8c2782b88fe766615350230893c845d988170b3f7a1362", + "size": 370967, + "subdir": "linux-64", + "timestamp": 1544718286750, + "version": "1.0.2" + }, + "mkl_random-1.0.2-py37h423224d_0.conda": { + "build": "py37h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.2,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "66abcbd533d35b943331e7e3ac6b88e5", + "name": "mkl_random", + "sha256": "ce35e75b42c42fa1ab4f196959f1122fa8766db16e41a10ddc0244fc41a1f388", + "size": 370501, + "subdir": "linux-64", + "timestamp": 1580488368347, + "version": "1.0.2" + }, + "mkl_random-1.0.2-py37hd81dba3_0.conda": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy-base >=1.0.2,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7b1f5bbe042bb32ab674743e31f9afe7", + "name": "mkl_random", + "sha256": "f122b5a35563a6a0188b65d7d635e20a1facf04346dea130af625835b942a7e8", + "size": 369705, + "subdir": "linux-64", + "timestamp": 1544718432566, + "version": "1.0.2" + }, + "mkl_random-1.0.2-py38h423224d_0.conda": { + "build": "py38h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "de57eca9c3f421a6663173dca90da948", + "name": "mkl_random", + "sha256": "00393e533b20f5815c0792ff519fe75441fb70d62bdb925ea4d5cd77a63a9f8c", + "size": 391578, + "subdir": "linux-64", + "timestamp": 1580495323926, + "version": "1.0.2" + }, + "mkl_random-1.0.2-py39h63df603_0.conda": { + "build": "py39h63df603_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.0.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cb7d56b724c6475c64d9f83c7e60ceee", + "name": "mkl_random", + "sha256": "20472394f0c99a3c42b4d6d2031a2234ebdae46b134525ec76cfbef2d7be029b", + "size": 354222, + "subdir": "linux-64", + "timestamp": 1607432375281, + "version": "1.0.2" + }, + "mkl_random-1.1.0-py27hd6b4f25_0.conda": { + "build": "py27hd6b4f25_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "19f93ad939ade19dbf7e3ad883eedf8c", + "name": "mkl_random", + "sha256": "5bce608db5df607772ca86d29ae675a2630dccbf9598be074304b379f68d5034", + "size": 303705, + "subdir": "linux-64", + "timestamp": 1569349545429, + "version": "1.1.0" + }, + "mkl_random-1.1.0-py36hd6b4f25_0.conda": { + "build": "py36hd6b4f25_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "1b3868e6a0e358c5bf6cd1ec9a38d930", + "name": "mkl_random", + "sha256": "077e240481d4e8932de927bdefdee9e1c90b2e1a99b54b5a0a30fcadd3d82c58", + "size": 331752, + "subdir": "linux-64", + "timestamp": 1569349555267, + "version": "1.1.0" + }, + "mkl_random-1.1.0-py37hd6b4f25_0.conda": { + "build": "py37hd6b4f25_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "4ee45c5cee9ac280e5d5bbc03b6bfd18", + "name": "mkl_random", + "sha256": "2a3ee377d113cd231d3cbc1e3a4a716844dd42db5f1e49255302d872dfb8c2af", + "size": 328728, + "subdir": "linux-64", + "timestamp": 1569349561861, + "version": "1.1.0" + }, + "mkl_random-1.1.0-py38h962f231_0.conda": { + "build": "py38h962f231_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "402bca875794d25258eed9ead690c32d", + "name": "mkl_random", + "sha256": "dfe0987c40cfd101dc36b59527ea28eb8a90803b61776e4d943ab3c2b5c40775", + "size": 347861, + "subdir": "linux-64", + "timestamp": 1573738291813, + "version": "1.1.0" + }, + "mkl_random-1.1.1-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2020.1,<2021.0a0", + "numpy >=1.14,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "7074c10aea6ac9934a6c50a54b0ca081", + "name": "mkl_random", + "sha256": "2852491734c90b072a40e1e27793a7025c4a2a9b304064d926d6d811c8ac786a", + "size": 334378, + "subdir": "linux-64", + "timestamp": 1590531511580, + "version": "1.1.1" + }, + "mkl_random-1.1.1-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2020.1,<2021.0a0", + "numpy >=1.14,<2.0a0", + "python >=3.7,<3.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "d53ccfb4a62152ac873d96ec89e84aa0", + "name": "mkl_random", + "sha256": "5fc59bfa9899309f290ceb5e5231cd4a5a04185eef93ff72da5b68d2c589b21b", + "size": 329465, + "subdir": "linux-64", + "timestamp": 1590531500653, + "version": "1.1.1" + }, + "mkl_random-1.1.1-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2020.1,<2021.0a0", + "numpy >=1.14,<2.0a0", + "python >=3.8,<3.9.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "d606c76928ccd2c811069c271d13dc3b", + "name": "mkl_random", + "sha256": "c77494eac08d32b62f90bdae10d58349747ec19c6108b2d5bd78f86ebeabb983", + "size": 349236, + "subdir": "linux-64", + "timestamp": 1590531546391, + "version": "1.1.1" + }, + "mkl_random-1.2.1-py36ha9443f7_2.conda": { + "build": "py36ha9443f7_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "26c0486e14dea42868c8d736fc868f2e", + "name": "mkl_random", + "sha256": "cbb246ca04dde6c4eea6313b08aee19fa2bf1b1a53e80fc9b45c70cde3a9e6be", + "size": 296344, + "subdir": "linux-64", + "timestamp": 1618861141231, + "version": "1.2.1" + }, + "mkl_random-1.2.1-py37h807cd23_1.conda": { + "build": "py37h807cd23_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base >=1.2.1,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cd80df8917732251acffffc1eb0bd35a", + "name": "mkl_random", + "sha256": "eb74ec81ee1d61ca88692ef9afd425c4b9ec8e797f7c03ab12771f2d680aae00", + "size": 349600, + "subdir": "linux-64", + "timestamp": 1654863888954, + "version": "1.2.1" + }, + "mkl_random-1.2.1-py37ha9443f7_2.conda": { + "build": "py37ha9443f7_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.7,<3.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "8b61405765398d3d06ee790dab90da0b", + "name": "mkl_random", + "sha256": "1c07eff9ec92bf904252f4d38759d5c5a68b5202373d01d5191cc220dcb31333", + "size": 293964, + "subdir": "linux-64", + "timestamp": 1618854106634, + "version": "1.2.1" + }, + "mkl_random-1.2.1-py38h807cd23_1.conda": { + "build": "py38h807cd23_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base >=1.2.1,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "66aefe6d2fdbd77fee3fa79f67486d54", + "name": "mkl_random", + "sha256": "7b2644552687b49fd236da5c4083c2b48932da87d895bfb4ccca9ab405952fa7", + "size": 350278, + "subdir": "linux-64", + "timestamp": 1654864516409, + "version": "1.2.1" + }, + "mkl_random-1.2.1-py38ha9443f7_2.conda": { + "build": "py38ha9443f7_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.8,<3.9.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "2e02ee8583282b53c645d9edde165b22", + "name": "mkl_random", + "sha256": "8f404465780e29c771cd673f81488aef097d79a06f8a7a1093b68c55ddcaa9c2", + "size": 312778, + "subdir": "linux-64", + "timestamp": 1618853977229, + "version": "1.2.1" + }, + "mkl_random-1.2.1-py39h807cd23_1.conda": { + "build": "py39h807cd23_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base >=1.2.1,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4ea2a6c7065d1a03fde6bdb373123054", + "name": "mkl_random", + "sha256": "95edb2e4b4b8e3e752d25afdffc679b2d3b6f798fadcbab85a63da3b21e0554e", + "size": 337739, + "subdir": "linux-64", + "timestamp": 1654864199152, + "version": "1.2.1" + }, + "mkl_random-1.2.1-py39ha9443f7_2.conda": { + "build": "py39ha9443f7_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.9,<3.10.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "9555674cbb915680e88da542a4fa2866", + "name": "mkl_random", + "sha256": "39799642912e727baef2b439f58c3274dfcb9d6baf8167b4ba345b13b9760e46", + "size": 317702, + "subdir": "linux-64", + "timestamp": 1618854115010, + "version": "1.2.1" + }, + "mkl_random-1.2.2-py310h00e6091_0.conda": { + "build": "py310h00e6091_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<2.0a0", + "python >=3.10,<3.11.0a0", + "blas * mkl" + ], + "license": "BSD-3-Clause", + "md5": "03c0cbc3976f219dd7313a628078fb15", + "name": "mkl_random", + "sha256": "d8e6e2820e24a3200d02c321a23961d54cfb49484c423919157c420f22868e78", + "size": 1033029, + "subdir": "linux-64", + "timestamp": 1641843589171, + "version": "1.2.2" + }, + "mkl_random-1.2.2-py310h83d4ef7_0.conda": { + "build": "py310h83d4ef7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<2.0a0", + "python >=3.10,<3.11.0a0", + "blas * mkl" + ], + "license": "BSD-3-Clause", + "md5": "249b2bd6c6a7a271ff51b4fd79ccae53", + "name": "mkl_random", + "sha256": "74cc83ee54c929cce9a4e9c7d1928a2d6b22a7f4aea05322c943c58f55edb98d", + "size": 1037301, + "subdir": "linux-64", + "timestamp": 1639980120043, + "version": "1.2.2" + }, + "mkl_random-1.2.2-py311hba01205_0.conda": { + "build": "py311hba01205_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.22,<2.0a0", + "python >=3.11,<3.12.0a0", + "blas * mkl" + ], + "license": "BSD-3-Clause", + "md5": "17b14925bcdf83674749e62a663e6a6a", + "name": "mkl_random", + "sha256": "a4db01643a9552766bcbfac624e971d8c75b9b525467edc504bcaa4e5260992d", + "size": 295893, + "subdir": "linux-64", + "timestamp": 1676828066969, + "version": "1.2.2" + }, + "mkl_random-1.2.2-py36h51133e4_0.conda": { + "build": "py36h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD-3-Clause", + "md5": "92ba925f9d976762224d6fb880c1a40f", + "name": "mkl_random", + "sha256": "50728e15638d46fda1f49274701c26aa59a6899e529b2adb7e69ab9135a9f7ec", + "size": 298548, + "subdir": "linux-64", + "timestamp": 1626186170019, + "version": "1.2.2" + }, + "mkl_random-1.2.2-py37h51133e4_0.conda": { + "build": "py37h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.7,<3.8.0a0", + "blas * mkl" + ], + "license": "BSD-3-Clause", + "md5": "a9dcda943aaf50f6dba8ba1b0d25ba1a", + "name": "mkl_random", + "sha256": "cdc8358a0c7d0f931f7bbe866ba0986c2a0066c282799bfbbc6430398bb88757", + "size": 293913, + "subdir": "linux-64", + "timestamp": 1626179132188, + "version": "1.2.2" + }, + "mkl_random-1.2.2-py38h51133e4_0.conda": { + "build": "py38h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.8,<3.9.0a0", + "blas * mkl" + ], + "license": "BSD-3-Clause", + "md5": "1e3b7251e474e099a4bfd672fdca17d8", + "name": "mkl_random", + "sha256": "df07f9cf6ae736e8612ce8ddf28a27b7de277f5b82de402ce214650938761121", + "size": 315495, + "subdir": "linux-64", + "timestamp": 1626186149062, + "version": "1.2.2" + }, + "mkl_random-1.2.2-py39h51133e4_0.conda": { + "build": "py39h51133e4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<2.0a0", + "python >=3.9,<3.10.0a0", + "blas * mkl" + ], + "license": "BSD-3-Clause", + "md5": "c753c11783825f0e0ffd23106c2696d5", + "name": "mkl_random", + "sha256": "8533eeb7f8dd4951f321fe6c252885d73ba4e7bea6c069b560fab557fc8eff23", + "size": 316903, + "subdir": "linux-64", + "timestamp": 1626186165897, + "version": "1.2.2" + }, + "mkl_umath-0.1.1-py37hb1251f7_0.conda": { + "build": "py37hb1251f7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "intel-cmplr-lib-rt >=2021.3.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bbb1d2f8a0a7b5cbe8b593257944444c", + "name": "mkl_umath", + "sha256": "625d0a7ada2ad8bbb97216113d3d16dbdafd566a1eeb34fa76091bd94b62eaa3", + "size": 119076, + "subdir": "linux-64", + "timestamp": 1646750489540, + "version": "0.1.1" + }, + "mkl_umath-0.1.1-py38hb1251f7_0.conda": { + "build": "py38hb1251f7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "intel-cmplr-lib-rt >=2021.3.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cbb9ac78e629bd8e3740e34e49cf9734", + "name": "mkl_umath", + "sha256": "58f7e58f98ba749bf49a847fd402aea73ef75caa480c517305538be159244f34", + "size": 120061, + "subdir": "linux-64", + "timestamp": 1646767933918, + "version": "0.1.1" + }, + "mkl_umath-0.1.1-py39hb1251f7_0.conda": { + "build": "py39hb1251f7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "intel-cmplr-lib-rt >=2021.3.0,<2022.0a0", + "libgcc-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a1b378b81ee169abf05f606ba736108", + "name": "mkl_umath", + "sha256": "9271e370b36c5bff200ac4b802a2447a1ad4f7d59111249706d92987e0871b6d", + "size": 120261, + "subdir": "linux-64", + "timestamp": 1646767931223, + "version": "0.1.1" + }, + "mklml-2018.0.3-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "libmklml 2018.0.3.*", + "mkl-include 2018.0.3.*" + ], + "md5": "42734a7276f0f916d295894f1cba6da4", + "name": "mklml", + "sha256": "35be06b02df7eec5cfd502b3c3cf88ed4b2c68b1e4222f0c25bbc63c5c4dfade", + "size": 5106, + "subdir": "linux-64", + "timestamp": 1530345172210, + "version": "2018.0.3" + }, + "mklml-2019.0.3-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "libmklml 2019.0.3.*", + "mkl-include 2019.*" + ], + "md5": "170c9bd1284516ab3054e154c0ed0ddf", + "name": "mklml", + "sha256": "ecc982efa753ee3403fceb13aeed70bf1ece2bb3347d6818ab40327c3d0f4211", + "size": 158439, + "subdir": "linux-64", + "timestamp": 1551761856979, + "version": "2019.0.3" + }, + "mklml-2019.0.5-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "libmklml 2019.0.5.*", + "mkl-include 2019.*" + ], + "md5": "6750f79700d4fa95c2769facfdbef7fb", + "name": "mklml", + "sha256": "e58c6b4574be9a263512b82ca050ec335b25466bc90fc411e5ccbdd072ee42af", + "size": 169256, + "subdir": "linux-64", + "timestamp": 1564678059223, + "version": "2019.0.5" + }, + "mklml-2019.0.5-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libmklml 2019.0.5.*", + "mkl-include 2019.*" + ], + "md5": "422d2a90e7cf0ff92690993893a60b26", + "name": "mklml", + "sha256": "34a2ccc173c3f0489fe9da6f35693093700b61be1dbc7a3402b78db5691c664a", + "size": 6222, + "subdir": "linux-64", + "timestamp": 1641844513766, + "version": "2019.0.5" + }, + "mlir-14.0.6-h9e868ea_0.conda": { + "build": "h9e868ea_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libllvm14 >=14.0.6,<14.1.0a0", + "libmlir 14.0.6 h9e868ea_0", + "libstdcxx-ng >=11.2.0", + "llvmdev 14.0.6.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "8fb619e530ea6b263757ba976142be92", + "name": "mlir", + "sha256": "90ab5322a016d57cc38437efbabe2ab79c610bf779791a3657be087070c1212d", + "size": 16797264, + "subdir": "linux-64", + "timestamp": 1662555412954, + "version": "14.0.6" + }, + "mmh3-3.0.0-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "d07d890742ca691637d2ec2005b5e039", + "name": "mmh3", + "sha256": "8eb86250987b6b9a2bf23c80c987e7b2cd1eebe49942831d46b74478afeb0e01", + "size": 41999, + "subdir": "linux-64", + "timestamp": 1650548010226, + "version": "3.0.0" + }, + "mmh3-3.0.0-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "e798089c72ee93e3ec8466fd4eb35bfd", + "name": "mmh3", + "sha256": "8248db23e1bbec3e9ab8d0465b3320a9eba13b73ae5ee77c3a74fb63ce9ccf8b", + "size": 17773, + "subdir": "linux-64", + "timestamp": 1676858657774, + "version": "3.0.0" + }, + "mmh3-3.0.0-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "21bf63a6f1fda4a3b9f09e4439ba7bc7", + "name": "mmh3", + "sha256": "16e0e55c648cbb3d873c5295c19677cb8de8093af08391d3a180f5d0862fe301", + "size": 17384, + "subdir": "linux-64", + "timestamp": 1650548037179, + "version": "3.0.0" + }, + "mmh3-3.0.0-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "69b18085546dad677784c3d4d74d903e", + "name": "mmh3", + "sha256": "fbc96135fc4c34e0a87e5162f33fef04b39dc2694fdfd0fb10a480966863a65b", + "size": 17425, + "subdir": "linux-64", + "timestamp": 1650547943782, + "version": "3.0.0" + }, + "mmh3-3.0.0-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "CC0-1.0", + "license_family": "CC", + "md5": "1f38bbfd774d8cb5641bf7b82a1e0766", + "name": "mmh3", + "sha256": "2d2293445f9d09a6a6e1b4f3afe30efbffbbb02e6bc5c0b5fec5f518fc0a9863", + "size": 17489, + "subdir": "linux-64", + "timestamp": 1650547971837, + "version": "3.0.0" + }, + "mock-2.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "funcsigs", + "pbr", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 2-Clause", + "md5": "bfccc596b493b4d83f3342a245c3c63c", + "name": "mock", + "sha256": "6d4951e0a6f7398cfed160902168d6ac29aec8ec070f9c689d12d0f5732f2a47", + "size": 110186, + "subdir": "linux-64", + "timestamp": 1530728013735, + "version": "2.0.0" + }, + "mock-2.0.0-py27h0c0c831_0.conda": { + "build": "py27h0c0c831_0", + "build_number": 0, + "depends": [ + "funcsigs", + "pbr", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 2-Clause", + "md5": "23418da79c58d0ca1938e2ef2d748679", + "name": "mock", + "sha256": "22079a6cf1f6fc0d1ca52cc4335edc386433039be67cb0089bf34ad03b70fc3e", + "size": 108428, + "subdir": "linux-64", + "timestamp": 1507935253282, + "version": "2.0.0" + }, + "mock-2.0.0-py35h70ca42c_0.conda": { + "build": "py35h70ca42c_0", + "build_number": 0, + "depends": [ + "pbr", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 2-Clause", + "md5": "7cd12e13831f9e077b3645faf0f30e11", + "name": "mock", + "sha256": "35bccbdc668bb1dc20876cb2152247dcf6cd94ed151ea8882aa395c9c416f88e", + "size": 114329, + "subdir": "linux-64", + "timestamp": 1507935269131, + "version": "2.0.0" + }, + "mock-2.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pbr", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 2-Clause", + "md5": "5d989ef2fb6455b6cefa005eb2174922", + "name": "mock", + "sha256": "6b1af1cf72c3a99262d7c1b2bd10c92f7d4d282fa42d3bd491b29903fe760c74", + "size": 111077, + "subdir": "linux-64", + "timestamp": 1530728059385, + "version": "2.0.0" + }, + "mock-2.0.0-py36h3c5bf6c_0.conda": { + "build": "py36h3c5bf6c_0", + "build_number": 0, + "depends": [ + "pbr", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 2-Clause", + "md5": "c8ab70f48a135daa0f1a277be33f4942", + "name": "mock", + "sha256": "087ce52627bd95949352fac0180c1488ffca667d08b9b7dd3e6663cbc3d87ebe", + "size": 111065, + "subdir": "linux-64", + "timestamp": 1507935278912, + "version": "2.0.0" + }, + "mock-2.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pbr", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 2-Clause", + "md5": "ecab85efc77bf0da4e9a79463a591461", + "name": "mock", + "sha256": "531c73ed0dab11aff6d2568d0de7c10228a6860bdd67dfd6db38ea8270147159", + "size": 111183, + "subdir": "linux-64", + "timestamp": 1530728036053, + "version": "2.0.0" + }, + "mock-3.0.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "funcsigs", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD-2-Clause", + "md5": "12de7726c8aee498b59effe0f41642b6", + "name": "mock", + "sha256": "c3a93d0df9c5c73d174b88a288182eaafe1be1ed372f45699455cdefdf184e47", + "size": 50066, + "subdir": "linux-64", + "timestamp": 1559063941031, + "version": "3.0.5" + }, + "mock-3.0.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-2-Clause", + "md5": "f9440de38c679fe8dc3b3d7aabe3dc4c", + "name": "mock", + "sha256": "784a71ad060ecfbc9924e09caf13a3f8ecd14c84f7a17db41efec1214ea50eb6", + "size": 50168, + "subdir": "linux-64", + "timestamp": 1559063989188, + "version": "3.0.5" + }, + "mock-3.0.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-2-Clause", + "md5": "f92a61577c2871e4eae3c7b0027a7b81", + "name": "mock", + "sha256": "a115d7d5fd40f11a9b44c11b4b9b06b9694983c990378b0181e7ea9964646600", + "size": 50136, + "subdir": "linux-64", + "timestamp": 1559063904620, + "version": "3.0.5" + }, + "mock-3.0.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-2-Clause", + "md5": "0dcc22353b90be75728ba2bd7cea12ae", + "name": "mock", + "sha256": "858726192790de5711a6e2501d6727ecf279f00f5f4beb90508c7f707c63ba13", + "size": 49232, + "subdir": "linux-64", + "timestamp": 1573750934389, + "version": "3.0.5" + }, + "modin-0.10.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.12", + "distributed >=2.12", + "pandas 1.2.4", + "python >=3.7,<3.8.0a0", + "ray-core >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d350edf0767a5f96487e22d2bc1adeaa", + "name": "modin", + "sha256": "ae823b86652938b2f5c411d18610bec7e7c3ace74af3ddd4f502f44b8c3ff4a4", + "size": 823174, + "subdir": "linux-64", + "timestamp": 1626550774766, + "version": "0.10.0" + }, + "modin-0.10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.12", + "distributed >=2.12", + "pandas 1.2.4", + "python >=3.8,<3.9.0a0", + "ray-core >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "072185ec3418a6818abdc8497fad3062", + "name": "modin", + "sha256": "295ec7a8d2e625a4ba1566a31776f88a58dcddd8b0e7b4277b65b19ca788ca72", + "size": 822967, + "subdir": "linux-64", + "timestamp": 1626550771024, + "version": "0.10.0" + }, + "modin-0.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.12", + "distributed >=2.12", + "pandas 1.2.4", + "python >=3.9,<3.10.0a0", + "ray-core >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5e881098a7bc46231ab7e4c17fa2b864", + "name": "modin", + "sha256": "3318bd62993290c2793612da4ef248526dd88d3e54de14bbfeeba4bbeaa2cec9", + "size": 832371, + "subdir": "linux-64", + "timestamp": 1626550365896, + "version": "0.10.0" + }, + "modin-0.10.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22", + "distributed >=2.22", + "pandas 1.3.2", + "python >=3.7,<3.8.0a0", + "ray-core >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8466e7e96e36606257c6f437d9611b85", + "name": "modin", + "sha256": "edce45c29f7baaa20cc0854bdfc2a45f7a9bd4df29519f26e7c4fd05398f953f", + "size": 881443, + "subdir": "linux-64", + "timestamp": 1632133579772, + "version": "0.10.2" + }, + "modin-0.10.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22", + "distributed >=2.22", + "pandas 1.3.2", + "python >=3.8,<3.9.0a0", + "ray-core >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "90de57a730b744a013d476b90c8aa117", + "name": "modin", + "sha256": "e752776079ccbb4360b22ec7c3d3eef2c1b539bc9aad64146d570122138bcb06", + "size": 903003, + "subdir": "linux-64", + "timestamp": 1632133807092, + "version": "0.10.2" + }, + "modin-0.10.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22", + "distributed >=2.22", + "pandas 1.3.2", + "python >=3.9,<3.10.0a0", + "ray-core >=1.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "17ad7048030a87b9f7db054ec7b1010c", + "name": "modin", + "sha256": "a2d04f12ff259ba19a5f1bada5db4046cceebcf5aacad17ad0044653450f71b9", + "size": 902760, + "subdir": "linux-64", + "timestamp": 1632133805209, + "version": "0.10.2" + }, + "modin-0.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.11.0 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dfdaaa6888a88588dc7654b1c87c2d24", + "name": "modin", + "sha256": "3c85ad015592d282878ff7ebaa3f6e8af134dd8dd95ef5269c1f6accec73070d", + "size": 13216, + "subdir": "linux-64", + "timestamp": 1640815321468, + "version": "0.11.0" + }, + "modin-0.11.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.11.0 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ff82ebb206869f3a77104f396b33dcb5", + "name": "modin", + "sha256": "e0f7a31701719b681866cf25b9c941b9ee61278c25046dca500b99bb5e9debad", + "size": 20045, + "subdir": "linux-64", + "timestamp": 1633013254457, + "version": "0.11.0" + }, + "modin-0.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.11.0 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8c4c84b3ed954cc86f1fdb9c2f27a4e5", + "name": "modin", + "sha256": "eb61fb03c630747ce203b187b3240ed938f19dabf61c092e13732c4a57edf7e8", + "size": 20038, + "subdir": "linux-64", + "timestamp": 1633013265133, + "version": "0.11.0" + }, + "modin-0.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.11.0 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "74fc4c8cb05c36adcbe21597599bafe6", + "name": "modin", + "sha256": "5ecc01ce22cd90cfbb480215daae0e3f6667c98d842a10ede09efbee111dfd52", + "size": 20069, + "subdir": "linux-64", + "timestamp": 1633013260010, + "version": "0.11.0" + }, + "modin-0.11.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.11.3 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1b78c75de4d37b89fffaddc0e1f20970", + "name": "modin", + "sha256": "7c47626a378d91e624a9860a9458de1e8f23906ef7f4eb816d2534fdd441d2f5", + "size": 21221, + "subdir": "linux-64", + "timestamp": 1640803825778, + "version": "0.11.3" + }, + "modin-0.11.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.11.3 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "64cc81c3dd8e9342ffe031f1a50233b8", + "name": "modin", + "sha256": "2c310a9d66e477dba67320a13176dd7d46f3308f2b6efdef893ee8825444ad99", + "size": 21222, + "subdir": "linux-64", + "timestamp": 1640803831655, + "version": "0.11.3" + }, + "modin-0.11.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.11.3 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aa5522508efceee0e1d08970a60c6b57", + "name": "modin", + "sha256": "bb142a3a3925c104ab3899211435c761f06b56a621544590b5664cbc5cabaa83", + "size": 21217, + "subdir": "linux-64", + "timestamp": 1640803837790, + "version": "0.11.3" + }, + "modin-0.15.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.15.2 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ca7bb871fd06b559f148a6e53fe86572", + "name": "modin", + "sha256": "0d9ffcae893add4d79d4201b60f04858ff596b093ff837b8a8e554ee9974b7c7", + "size": 14819, + "subdir": "linux-64", + "timestamp": 1659123869316, + "version": "0.15.2" + }, + "modin-0.15.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.15.2 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e4c1de3f933a4789829f9e0bd18ca67e", + "name": "modin", + "sha256": "24014085a8567b75c008fcf0b2d1bb94f431b33e992a4c316f9cd48dd034fa00", + "size": 14798, + "subdir": "linux-64", + "timestamp": 1659123885894, + "version": "0.15.2" + }, + "modin-0.15.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.15.2 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "67c43ccb42c554104efd3289bd806bfc", + "name": "modin", + "sha256": "2f69baf3f916e94efc33387ec73d806c39457c385090a2e75465d76b1ad90e23", + "size": 14782, + "subdir": "linux-64", + "timestamp": 1659123878148, + "version": "0.15.2" + }, + "modin-0.18.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.18.0 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e16be88b3d1e770a9dc5c96d6cffc7e1", + "name": "modin", + "sha256": "703407675dddcfa748a7efca0d56643f216c05ceb6002b5b8220e5db434a3a6e", + "size": 12794, + "subdir": "linux-64", + "timestamp": 1675936350157, + "version": "0.18.0" + }, + "modin-0.18.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.18.0 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "97079b52af5d18cdcd8cf4dc0bf2856c", + "name": "modin", + "sha256": "424092b4615dd8e4eab14e723ce089d700475862097089c7f2742df9e1b7faea", + "size": 12765, + "subdir": "linux-64", + "timestamp": 1675935992331, + "version": "0.18.0" + }, + "modin-0.18.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-dask 0.18.0 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1c684a1c284425c99738e60008225f23", + "name": "modin", + "sha256": "487391d8a083838889fde55eef8aecddf47c1f891b7f8fdbed695caeafa27628", + "size": 12769, + "subdir": "linux-64", + "timestamp": 1675936175401, + "version": "0.18.0" + }, + "modin-all-0.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.0 py310h06a4308_0", + "modin-dask 0.11.0 py310h06a4308_0", + "modin-omnisci 0.11.0 py310h06a4308_0", + "modin-ray 0.11.0 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "489410d1fa101e4c4f5ae1955ad45c9e", + "name": "modin-all", + "sha256": "58385d0d3d249634384faf02cf82e6572c2b2cf3c69868ab04099ea985d1db58", + "size": 13257, + "subdir": "linux-64", + "timestamp": 1640815328105, + "version": "0.11.0" + }, + "modin-all-0.11.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.0 py37h06a4308_0", + "modin-dask 0.11.0 py37h06a4308_0", + "modin-omnisci 0.11.0 py37h06a4308_0", + "modin-ray 0.11.0 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "82e46a7aba11bb4aa8d7fcb6e2924321", + "name": "modin-all", + "sha256": "6c77c3242f9e75f44c91fb08ba72e159767713d8660c3e5d52b8b801ade869d4", + "size": 20081, + "subdir": "linux-64", + "timestamp": 1633013270367, + "version": "0.11.0" + }, + "modin-all-0.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.0 py38h06a4308_0", + "modin-dask 0.11.0 py38h06a4308_0", + "modin-omnisci 0.11.0 py38h06a4308_0", + "modin-ray 0.11.0 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8dc4a1cf43bd772ea765847cd96676d0", + "name": "modin-all", + "sha256": "70e623be153ba8861a50c1c57ed13d25600b8b1505a2602ffc99a96a33939e05", + "size": 20061, + "subdir": "linux-64", + "timestamp": 1633013281029, + "version": "0.11.0" + }, + "modin-all-0.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.0 py39h06a4308_0", + "modin-dask 0.11.0 py39h06a4308_0", + "modin-omnisci 0.11.0 py39h06a4308_0", + "modin-ray 0.11.0 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0dd90664e9df8e4785047afb83b5207f", + "name": "modin-all", + "sha256": "656bfb2e9f29c655efc0ab912941bf1109d8e821f0362105ce9532c683b6897e", + "size": 20110, + "subdir": "linux-64", + "timestamp": 1633013275729, + "version": "0.11.0" + }, + "modin-all-0.11.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.3 py37h06a4308_0", + "modin-dask 0.11.3 py37h06a4308_0", + "modin-omnisci 0.11.3 py37h06a4308_0", + "modin-ray 0.11.3 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6356d671d60a0d97df743a9ec8651f2e", + "name": "modin-all", + "sha256": "debda9442e00eca0c29710227938a4cb53bddb16611b9aafe2dadbf47b4758a5", + "size": 21257, + "subdir": "linux-64", + "timestamp": 1640803843398, + "version": "0.11.3" + }, + "modin-all-0.11.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.3 py38h06a4308_0", + "modin-dask 0.11.3 py38h06a4308_0", + "modin-omnisci 0.11.3 py38h06a4308_0", + "modin-ray 0.11.3 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f62f1dad55aabbb5924db78b4900c1d7", + "name": "modin-all", + "sha256": "0af9a8d5193fbb17cae2ff752e9a049342ad38733a5ae443aed387d4e5495293", + "size": 21255, + "subdir": "linux-64", + "timestamp": 1640803849306, + "version": "0.11.3" + }, + "modin-all-0.11.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.3 py39h06a4308_0", + "modin-dask 0.11.3 py39h06a4308_0", + "modin-omnisci 0.11.3 py39h06a4308_0", + "modin-ray 0.11.3 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "43b42f79a4ca47f3a673563ec3dd6b29", + "name": "modin-all", + "sha256": "4581fd5330f47a5854728695ab935efded06152b65f1c117b5cc8a87a968af76", + "size": 21282, + "subdir": "linux-64", + "timestamp": 1640803855529, + "version": "0.11.3" + }, + "modin-all-0.15.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.15.2 py310h06a4308_0", + "modin-dask 0.15.2 py310h06a4308_0", + "modin-omnisci 0.15.2 py310h2f386ee_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "de0a017ca7a00a448fd70b3c852ffb8d", + "name": "modin-all", + "sha256": "8339677b2138d64ea72b75b76535e8b3230c719c10b632456c3db72f28d437e7", + "size": 14847, + "subdir": "linux-64", + "timestamp": 1659123894320, + "version": "0.15.2" + }, + "modin-all-0.15.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.15.2 py38h06a4308_0", + "modin-dask 0.15.2 py38h06a4308_0", + "modin-omnisci 0.15.2 py38hb070fc8_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "112b260070486e41ac377262ceaafe21", + "name": "modin-all", + "sha256": "39139ce8f6f830992775b48ad254d62a91c51634fe15aaa60070be3da4b201c3", + "size": 14813, + "subdir": "linux-64", + "timestamp": 1659123911436, + "version": "0.15.2" + }, + "modin-all-0.15.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.15.2 py39h06a4308_0", + "modin-dask 0.15.2 py39h06a4308_0", + "modin-omnisci 0.15.2 py39hb070fc8_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "442ca40e5e60c48b75c6bebe7a67cf87", + "name": "modin-all", + "sha256": "b0d291952aa254f9eaa9973f1b42970660532a40948656755570fc0eaeb2d9ea", + "size": 14810, + "subdir": "linux-64", + "timestamp": 1659123903290, + "version": "0.15.2" + }, + "modin-all-0.18.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.18.0 py310h06a4308_0", + "modin-dask 0.18.0 py310h06a4308_0", + "modin-ray 0.18.0 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e0d9627eb6d1a5dce7f5345ed73b2bce", + "name": "modin-all", + "sha256": "a05cd8435179db046da5f4744981e0e4681dd249f4a56c79f6baad83b1fca244", + "size": 12834, + "subdir": "linux-64", + "timestamp": 1675936355983, + "version": "0.18.0" + }, + "modin-all-0.18.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.18.0 py38h06a4308_0", + "modin-dask 0.18.0 py38h06a4308_0", + "modin-ray 0.18.0 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7755192b2ce527651f68d87092cf830c", + "name": "modin-all", + "sha256": "f524918212604e4896ce9bbb84f4fa602fd79e2efd7c251f4a925d684a289da1", + "size": 12787, + "subdir": "linux-64", + "timestamp": 1675935997841, + "version": "0.18.0" + }, + "modin-all-0.18.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.18.0 py39h06a4308_0", + "modin-dask 0.18.0 py39h06a4308_0", + "modin-ray 0.18.0 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c73672c51f85f74b4c3fa07262634f2c", + "name": "modin-all", + "sha256": "33edd9826408191d5932baa63362a71b8025b5d838bca3c557408a1005cbb903", + "size": 12793, + "subdir": "linux-64", + "timestamp": 1675936181189, + "version": "0.18.0" + }, + "modin-core-0.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.5", + "packaging", + "pandas 1.3.3", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e63da35b33896f43ab134ecfad870baf", + "name": "modin-core", + "sha256": "8f947dca576d6c8fb19ac81665c515e63bf13a3220157b17fd72ace7f8a964d0", + "size": 898821, + "subdir": "linux-64", + "timestamp": 1640815293673, + "version": "0.11.0" + }, + "modin-core-0.11.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.5", + "packaging", + "pandas 1.3.3", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d702963a140c532d02ce9ab87511fb48", + "name": "modin-core", + "sha256": "8996bf4b6adf2085d022c4fe29abf0676f44b7d01be6aa87e11432f671f30949", + "size": 874370, + "subdir": "linux-64", + "timestamp": 1633013174680, + "version": "0.11.0" + }, + "modin-core-0.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.5", + "packaging", + "pandas 1.3.3", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6a0c542b202c70a1602949aa573a3efc", + "name": "modin-core", + "sha256": "c72802fbbe64f1ba48532dbd673619987e64700aeed2bcdc620476915993d987", + "size": 885373, + "subdir": "linux-64", + "timestamp": 1633013200073, + "version": "0.11.0" + }, + "modin-core-0.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.5", + "packaging", + "pandas 1.3.3", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aa06222a5306e32f96652e4bba48a66c", + "name": "modin-core", + "sha256": "5e66aa08d06d71a6032e39bbf1d15616b7a31776e9a866c047034d841062caaa", + "size": 885359, + "subdir": "linux-64", + "timestamp": 1633013187846, + "version": "0.11.0" + }, + "modin-core-0.11.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.5", + "packaging", + "pandas 1.3.4", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a20e9907a7c6e401dde8e7c8530b43a2", + "name": "modin-core", + "sha256": "16bcd256e3ca2ffeb7f56d45bc31cb160d02f87dc9630e2cb0aba5dc260fae2a", + "size": 890948, + "subdir": "linux-64", + "timestamp": 1640803736551, + "version": "0.11.3" + }, + "modin-core-0.11.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.5", + "packaging", + "pandas 1.3.4", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "341667b5b268f8451768f9a9327ad158", + "name": "modin-core", + "sha256": "a33e7ca53be4411ccb1e37f04d57a47b202e8bb7b9ad11a925575a59f57ebb06", + "size": 902753, + "subdir": "linux-64", + "timestamp": 1640803750311, + "version": "0.11.3" + }, + "modin-core-0.11.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.16.5", + "packaging", + "pandas 1.3.4", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "117f775081823d637410e786aa71945c", + "name": "modin-core", + "sha256": "a5a3f7536c3c4a194f2661251783a6bbb2d91dc21b57fe2ee1b554c643cac812", + "size": 902280, + "subdir": "linux-64", + "timestamp": 1640803764206, + "version": "0.11.3" + }, + "modin-core-0.15.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec", + "numpy >=1.18.5", + "packaging", + "pandas 1.4.3", + "psutil", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8838272980b273a75f9c6f3134b09b2f", + "name": "modin-core", + "sha256": "a79aaf9fc0611e5efc8609ca03675b27502ddf0b97700a4cf81a2eb07134a298", + "size": 1038975, + "subdir": "linux-64", + "timestamp": 1659123751835, + "version": "0.15.2" + }, + "modin-core-0.15.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec", + "numpy >=1.18.5", + "packaging", + "pandas 1.4.3", + "psutil", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "32ae2254238d445602845d56a160e08e", + "name": "modin-core", + "sha256": "e63235ea49d0c0dd210ce44c9ada86f1c7ed72934422ce2c4136c05829c438c0", + "size": 1025715, + "subdir": "linux-64", + "timestamp": 1659123788886, + "version": "0.15.2" + }, + "modin-core-0.15.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec", + "numpy >=1.18.5", + "packaging", + "pandas 1.4.3", + "psutil", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "75803a5be310a23c314f169f8ec49b9f", + "name": "modin-core", + "sha256": "2bf0c0d001222ee35020e430155756b449990991c94146de2b55628d190a7cc2", + "size": 1024740, + "subdir": "linux-64", + "timestamp": 1659123769632, + "version": "0.15.2" + }, + "modin-core-0.18.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec", + "numpy >=1.18.5", + "packaging", + "pandas 1.5.2", + "psutil", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "80709e8616c9646e13b89eb271ef526e", + "name": "modin-core", + "sha256": "dac2b0f5a501df093b804a2220b3c261ee941e8e295735d94e66c05f012cc89a", + "size": 1212303, + "subdir": "linux-64", + "timestamp": 1675936330259, + "version": "0.18.0" + }, + "modin-core-0.18.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec", + "numpy >=1.18.5", + "packaging", + "pandas 1.5.2", + "psutil", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a6f84cbf8b2b08eea565811ad86855bf", + "name": "modin-core", + "sha256": "0c5264844ca39b624d0c14ca54114b8e61afc5c81693e5616d782f07abe58fa8", + "size": 1195459, + "subdir": "linux-64", + "timestamp": 1675935973794, + "version": "0.18.0" + }, + "modin-core-0.18.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec", + "numpy >=1.18.5", + "packaging", + "pandas 1.5.2", + "psutil", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6531a31c32521876dafbc58eedd351ce", + "name": "modin-core", + "sha256": "1657540cfdbfe4f2707e9fb114203ddacac5afab26d503a0369e528a31385d97", + "size": 1194887, + "subdir": "linux-64", + "timestamp": 1675936156077, + "version": "0.18.0" + }, + "modin-dask-0.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.11.0 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8bc44da2fbdc92975d68759a0356ad8d", + "name": "modin-dask", + "sha256": "f58ba366e5347530a3949e7b11359a8fb4a0c9e47f9a70496d28c329bb7561c8", + "size": 13306, + "subdir": "linux-64", + "timestamp": 1640815301481, + "version": "0.11.0" + }, + "modin-dask-0.11.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.11.0 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "41f3d172f843562db8601b4c101d06b1", + "name": "modin-dask", + "sha256": "ed7d501547a8e542b93680ec14b7802aef9784bdb91b6f962989bc68640bf9e0", + "size": 20163, + "subdir": "linux-64", + "timestamp": 1633013206621, + "version": "0.11.0" + }, + "modin-dask-0.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.11.0 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d4c59c1ae6712e639f791800e4889705", + "name": "modin-dask", + "sha256": "952e8629b0943338b1466f3b6eca4dbfee1f8c1ed2a46303f50bb99bdd8a9261", + "size": 20156, + "subdir": "linux-64", + "timestamp": 1633013217279, + "version": "0.11.0" + }, + "modin-dask-0.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.11.0 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ba0967b31c35fe6650f3a37c61a2a228", + "name": "modin-dask", + "sha256": "542e9270e3d3dbde3dcd41de8cc97df3091b23cf854a40340fc7993da826f744", + "size": 20174, + "subdir": "linux-64", + "timestamp": 1633013212030, + "version": "0.11.0" + }, + "modin-dask-0.11.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.11.3 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3b75bfba6ca529677d36da915fd5fada", + "name": "modin-dask", + "sha256": "6e52f8b20742e0d2195ea18c3f797eda10a3380a5faa4df92948bb2efc94196c", + "size": 21334, + "subdir": "linux-64", + "timestamp": 1640803771594, + "version": "0.11.3" + }, + "modin-dask-0.11.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.11.3 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "38328e3ea3fee9a90d248b2c8b7b7d63", + "name": "modin-dask", + "sha256": "747029e9a84b12218f029284c3e13f29d857c885f6a4f17d4a427ab2c774aca3", + "size": 21331, + "subdir": "linux-64", + "timestamp": 1640803777459, + "version": "0.11.3" + }, + "modin-dask-0.11.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.11.3 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "be3ce317f9e28b2284f7b374a0d473e1", + "name": "modin-dask", + "sha256": "ea7502eee7155e8a91677fb931aaf72675dc6ba959ad9769c21750eace9e2971", + "size": 21339, + "subdir": "linux-64", + "timestamp": 1640803783610, + "version": "0.11.3" + }, + "modin-dask-0.15.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0,<2022.2.0", + "distributed >=2.22.0,<2022.2.0", + "modin-core 0.15.2 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "037f00c05ce80d9564dd8f2cd5757a7c", + "name": "modin-dask", + "sha256": "95f6079da733adff70bf4e4c4cd9a10fe746b6fb893c75f7795c22edd06e9006", + "size": 14910, + "subdir": "linux-64", + "timestamp": 1659123800019, + "version": "0.15.2" + }, + "modin-dask-0.15.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0,<2022.2.0", + "distributed >=2.22.0,<2022.2.0", + "modin-core 0.15.2 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "25cd8e55188873671b66b8607f2ad3d6", + "name": "modin-dask", + "sha256": "e6100b55d016ecd5902b1ddaf38b9f323481347eaf443d4e214efbaea71fb969", + "size": 14885, + "subdir": "linux-64", + "timestamp": 1659123816477, + "version": "0.15.2" + }, + "modin-dask-0.15.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0,<2022.2.0", + "distributed >=2.22.0,<2022.2.0", + "modin-core 0.15.2 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "201bcad5fc69e44b3cb41073e9960daf", + "name": "modin-dask", + "sha256": "63edd6046148f736501c7b22e0e9535ee89994503bd4318fc5578ebfee438891", + "size": 14879, + "subdir": "linux-64", + "timestamp": 1659123808446, + "version": "0.15.2" + }, + "modin-dask-0.18.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.18.0 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aed22263b530422ad045042dcde00bca", + "name": "modin-dask", + "sha256": "d58c043d3f029bb150d941af8d44e3d5035493580364d50f4ea1532b585b8b77", + "size": 12899, + "subdir": "linux-64", + "timestamp": 1675936338194, + "version": "0.18.0" + }, + "modin-dask-0.18.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.18.0 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1ee49d77708127c1a4b6663fd237cae6", + "name": "modin-dask", + "sha256": "59c9023a963b9ecac05fab61a986cd418b830bda9a5193f48b5b3618678db8cf", + "size": 12868, + "subdir": "linux-64", + "timestamp": 1675935981347, + "version": "0.18.0" + }, + "modin-dask-0.18.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=2.22.0", + "distributed >=2.22.0", + "modin-core 0.18.0 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0d955d50f5975ffbeeea0af0df06d9f1", + "name": "modin-dask", + "sha256": "b07a7e373fbdae6aca0ab05494bfa990502ff0a3412ea9574434634abe7abb81", + "size": 12868, + "subdir": "linux-64", + "timestamp": 1675936163850, + "version": "0.18.0" + }, + "modin-omnisci-0.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.0 py310h06a4308_0", + "pyarrow >=3.0", + "pyomniscidbe", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fae49a62cffea68a7e59f6aef5ac6322", + "name": "modin-omnisci", + "sha256": "f22a7c5dc68ab8e40561870a948896880abdc092fdf8a1df05d5bed926cd9d8d", + "size": 13338, + "subdir": "linux-64", + "timestamp": 1640815308318, + "version": "0.11.0" + }, + "modin-omnisci-0.11.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.0 py37h06a4308_0", + "pyarrow >=3.0", + "pyomniscidbe", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5a34f6276ad80c916eeaa2b9dcb4eb31", + "name": "modin-omnisci", + "sha256": "b837fbca1e48c76862ec718165cf33ba81ea7fc4aa2be72e6fef769c065daba2", + "size": 20188, + "subdir": "linux-64", + "timestamp": 1633013222521, + "version": "0.11.0" + }, + "modin-omnisci-0.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.0 py38h06a4308_0", + "pyarrow >=3.0", + "pyomniscidbe", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "27561743e0c1a002b7304a61f66bb022", + "name": "modin-omnisci", + "sha256": "88a3ce218779804452ddd51722cd453c38ef523ff1ef6e93497c2d8d1073d64c", + "size": 20181, + "subdir": "linux-64", + "timestamp": 1633013233083, + "version": "0.11.0" + }, + "modin-omnisci-0.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.0 py39h06a4308_0", + "pyarrow >=3.0", + "pyomniscidbe", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4cd9ed0a1455d180eee4eaebbf14f3a4", + "name": "modin-omnisci", + "sha256": "849b3fd40cc0efe14e0c73c86c0f46e910c48c3c8a3dce41cb47363950864761", + "size": 20213, + "subdir": "linux-64", + "timestamp": 1633013227968, + "version": "0.11.0" + }, + "modin-omnisci-0.11.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.3 py37h06a4308_0", + "pyarrow >=3.0", + "pyomniscidbe 5.7.1.*", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8edc9ef5f0a2c174c887034f2d770f13", + "name": "modin-omnisci", + "sha256": "b5bc1f606a645b04ef36ef11ebf83edfdbf09e9cbadbcce5e87c2d321033ba59", + "size": 21379, + "subdir": "linux-64", + "timestamp": 1640803789443, + "version": "0.11.3" + }, + "modin-omnisci-0.11.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.3 py38h06a4308_0", + "pyarrow >=3.0", + "pyomniscidbe 5.7.1.*", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "935a786ab14053f0faac003b651b97cb", + "name": "modin-omnisci", + "sha256": "25a2ee960397f04743cb8556bc82ea0fffb1bf158cf01b4315b9f201a595f7c6", + "size": 21381, + "subdir": "linux-64", + "timestamp": 1640803795295, + "version": "0.11.3" + }, + "modin-omnisci-0.11.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "modin-core 0.11.3 py39h06a4308_0", + "pyarrow >=3.0", + "pyomniscidbe 5.7.1.*", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "71a05291f0d3383d5d653aac7cc8ad0d", + "name": "modin-omnisci", + "sha256": "d48b32ce0c1c0862c8de2110685f4354a5c8a7bdf7aa8788b2661b24a62b6cfc", + "size": 21371, + "subdir": "linux-64", + "timestamp": 1640803801589, + "version": "0.11.3" + }, + "modin-omnisci-0.15.2-py310h2f386ee_0.conda": { + "build": "py310h2f386ee_0", + "build_number": 0, + "constrains": [ + "pyarrow ==6.0.1" + ], + "depends": [ + "modin-core 0.15.2 py310h06a4308_0", + "pyomniscidbe 5.10.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "41b3c5d94737a5f0aaea2e4de7fcd059", + "name": "modin-omnisci", + "sha256": "42871496672831554c1ede1b489aebccc6a5fc4a28384da0e80f90dd1eeb3ec9", + "size": 511021, + "subdir": "linux-64", + "timestamp": 1659123825182, + "version": "0.15.2" + }, + "modin-omnisci-0.15.2-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "constrains": [ + "pyarrow ==6.0.1" + ], + "depends": [ + "modin-core 0.15.2 py38h06a4308_0", + "pyomniscidbe 5.10.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2f8bef4852d8a1cf911573a337028094", + "name": "modin-omnisci", + "sha256": "48da01e6b330214ca5b108084e46da960429b93c14bd046501c811ffea308a1f", + "size": 510984, + "subdir": "linux-64", + "timestamp": 1659123844135, + "version": "0.15.2" + }, + "modin-omnisci-0.15.2-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "constrains": [ + "pyarrow ==6.0.1" + ], + "depends": [ + "modin-core 0.15.2 py39h06a4308_0", + "pyomniscidbe 5.10.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "08b0194dec463938ed826d32e48c69b4", + "name": "modin-omnisci", + "sha256": "aa7adba4d716a83fe4e8405e62f442af0b4d6dfb64b84f2ea92ffe7fc22c1b8b", + "size": 511079, + "subdir": "linux-64", + "timestamp": 1659123835008, + "version": "0.15.2" + }, + "modin-ray-0.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aioredis <2", + "modin-core 0.11.0 py310h06a4308_0", + "pyarrow >=1.0", + "python >=3.10,<3.11.0a0", + "ray-core >=1.4.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fdea44a005785347285438214092ad93", + "name": "modin-ray", + "sha256": "7d27e60106e6571a57280740958f2d0fb5d6a78823ac7e8daee885ae70284b0c", + "size": 13336, + "subdir": "linux-64", + "timestamp": 1640815315001, + "version": "0.11.0" + }, + "modin-ray-0.11.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aioredis <2", + "modin-core 0.11.0 py37h06a4308_0", + "pyarrow >=1.0", + "python >=3.7,<3.8.0a0", + "ray-core >=1.4.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "40feadb0c326e01dd80c5bc2b36c1fb5", + "name": "modin-ray", + "sha256": "d9bfbeb130f70dcdb353d55af450bc1cc7cdb98fa72e956b87618cc39406acea", + "size": 20169, + "subdir": "linux-64", + "timestamp": 1633013238354, + "version": "0.11.0" + }, + "modin-ray-0.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aioredis <2", + "modin-core 0.11.0 py38h06a4308_0", + "pyarrow >=1.0", + "python >=3.8,<3.9.0a0", + "ray-core >=1.4.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aab6893bfa439788c6eccca8163f9a6d", + "name": "modin-ray", + "sha256": "8ffcfb8bbb6734e52cfa8d2e84fe45767c6cda3f9ac6ad495b787c8c65d14172", + "size": 20163, + "subdir": "linux-64", + "timestamp": 1633013249232, + "version": "0.11.0" + }, + "modin-ray-0.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aioredis <2", + "modin-core 0.11.0 py39h06a4308_0", + "pyarrow >=1.0", + "python >=3.9,<3.10.0a0", + "ray-core >=1.4.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "694bbf2e81f09ef11a226a04cbc317a5", + "name": "modin-ray", + "sha256": "c5ddd648ba7e593dba40e21bd02b57858ece1f4053900b8eb5dd1590736310d0", + "size": 20195, + "subdir": "linux-64", + "timestamp": 1633013243932, + "version": "0.11.0" + }, + "modin-ray-0.11.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aioredis <2", + "modin-core 0.11.3 py37h06a4308_0", + "pyarrow >=1.0", + "python >=3.7,<3.8.0a0", + "ray-core >=1.4.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e65f8a656eb78d24a06eb7a462f6c681", + "name": "modin-ray", + "sha256": "e772aafd3dce61d47db9af93f66f4ee882189754aba41f596d322cb5b14ed4d2", + "size": 21356, + "subdir": "linux-64", + "timestamp": 1640803807478, + "version": "0.11.3" + }, + "modin-ray-0.11.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aioredis <2", + "modin-core 0.11.3 py38h06a4308_0", + "pyarrow >=1.0", + "python >=3.8,<3.9.0a0", + "ray-core >=1.4.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3bf1d75a82ff5ff83243444b2a0dc587", + "name": "modin-ray", + "sha256": "6b2e20d7579db9415fbeca98b8786605646e4dcaa839297320d9c985eff93276", + "size": 21365, + "subdir": "linux-64", + "timestamp": 1640803813602, + "version": "0.11.3" + }, + "modin-ray-0.11.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aioredis <2", + "modin-core 0.11.3 py39h06a4308_0", + "pyarrow >=1.0", + "python >=3.9,<3.10.0a0", + "ray-core >=1.4.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b7990412646e4cef4576c34d7c5e20e6", + "name": "modin-ray", + "sha256": "ae723e61582f5bf9db7bdbd6d66efe5199b5ca043a7f082b5f7462b4e948d562", + "size": 21360, + "subdir": "linux-64", + "timestamp": 1640803819607, + "version": "0.11.3" + }, + "modin-ray-0.15.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aioredis <2", + "modin-core 0.15.2 py38h06a4308_0", + "protobuf <4", + "pyarrow >=4.0.1", + "python >=3.8,<3.9.0a0", + "ray-default >=1.4.0,<1.13", + "redis-py >=3.5.0,<4.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3b4313ce5b45d0b7b5ae60d30d6263c5", + "name": "modin-ray", + "sha256": "7f51b7c276833d9dae0514f1ef5bb1afbca9a743505c163d578de623071cd7cb", + "size": 14921, + "subdir": "linux-64", + "timestamp": 1659123861189, + "version": "0.15.2" + }, + "modin-ray-0.15.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aioredis <2", + "modin-core 0.15.2 py39h06a4308_0", + "protobuf <4", + "pyarrow >=4.0.1", + "python >=3.9,<3.10.0a0", + "ray-default >=1.4.0,<1.13", + "redis-py >=3.5.0,<4.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d8efea97369edecd58dde563aeb40b61", + "name": "modin-ray", + "sha256": "3625390c14730cd15a661697c660a2f4dcbc404f475776d666e7e4c3c47b46bf", + "size": 14914, + "subdir": "linux-64", + "timestamp": 1659123853429, + "version": "0.15.2" + }, + "modin-ray-0.18.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "grpcio !=1.45.*,!=1.46.*", + "modin-core 0.18.0 py310h06a4308_0", + "pyarrow", + "python >=3.10,<3.11.0a0", + "ray-default >=1.13.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e23fcf66f05ec156bf91a1307e888f54", + "name": "modin-ray", + "sha256": "9f20eb51e377774807b86c6eb6bc022b0fb0fea8f1cadc1d7cdbd792864d2255", + "size": 12908, + "subdir": "linux-64", + "timestamp": 1675936344185, + "version": "0.18.0" + }, + "modin-ray-0.18.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "grpcio !=1.45.*,!=1.46.*", + "modin-core 0.18.0 py38h06a4308_0", + "pyarrow", + "python >=3.8,<3.9.0a0", + "ray-default >=1.13.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4d201b81164d4523d879c7c2e8a8a371", + "name": "modin-ray", + "sha256": "c0507ceed92155906079f53c44f725bd48e22909d120cb0bd95c1c0307e021d2", + "size": 12875, + "subdir": "linux-64", + "timestamp": 1675935986796, + "version": "0.18.0" + }, + "modin-ray-0.18.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "grpcio !=1.45.*,!=1.46.*", + "modin-core 0.18.0 py39h06a4308_0", + "pyarrow", + "python >=3.9,<3.10.0a0", + "ray-default >=1.13.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1d1ab53997b64c043324d6eef12ae5fc", + "name": "modin-ray", + "sha256": "d7d0f90a90d1a4e6352df886000c46dca7860d2d9b649d9ffa0f87fa1c82242f", + "size": 12877, + "subdir": "linux-64", + "timestamp": 1675936169605, + "version": "0.18.0" + }, + "mongo-tools-3.6.9-h449a5d8_0.conda": { + "build": "h449a5d8_0", + "build_number": 0, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libpcap >=1.9.0,<1.10.0a0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "Apache 2.0", + "md5": "a2b561210d311b75bf34769a106a5047", + "name": "mongo-tools", + "sha256": "e932abee2c91e1395d25462057b254aae13f236e86ec3e71f88535a653c89973", + "size": 25955518, + "subdir": "linux-64", + "timestamp": 1544967667339, + "version": "3.6.9" + }, + "mongo-tools-4.0.4-h689ee8a_1.conda": { + "build": "h689ee8a_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.27,<3.0a0", + "libgcc-ng >=11.2.0", + "libpcap >=1.9.1,<1.10.0a0", + "openssl >=1.1.1o,<1.1.2a" + ], + "license": "Apache 2.0", + "md5": "7943ef7777e6dc3a9a2af6c216ac7031", + "name": "mongo-tools", + "sha256": "f59a4ae374049e55b0a2bd803aa2c36a0e092090f836f99fe1f42474b2dab808", + "size": 27124346, + "subdir": "linux-64", + "timestamp": 1656407072930, + "version": "4.0.4" + }, + "mongo-tools-4.0.4-h723b31f_0.conda": { + "build": "h723b31f_0", + "build_number": 0, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libpcap >=1.9.0,<1.10.0a0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "Apache 2.0", + "md5": "8e60f0432b90a4f70c511f9bee1a5c12", + "name": "mongo-tools", + "sha256": "bf24aac842f98bc17dbbaf5a5bc09cb68b647a3a946acc3544bf4de5edbd7fff", + "size": 27166087, + "subdir": "linux-64", + "timestamp": 1547743841506, + "version": "4.0.4" + }, + "mongodb-3.4.10-heb2b672_0.conda": { + "build": "heb2b672_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2l,<1.0.3a" + ], + "license": "AGPLv3", + "license_family": "AGPL", + "md5": "69e33956dc5db032b381d267f1be7aa9", + "name": "mongodb", + "sha256": "68a066e757c9f4c80786fe51927edc07f9b48a7133907c77cf4b33bd56ef1710", + "size": 20708546, + "subdir": "linux-64", + "timestamp": 1509408183668, + "version": "3.4.10" + }, + "mongodb-3.6.5-hab6429c_0.conda": { + "build": "hab6429c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a" + ], + "license": "AGPLv3", + "license_family": "AGPL", + "md5": "71164fff76fa91b7cd1ac1fae41463da", + "name": "mongodb", + "sha256": "c68410dd6ea2ecf536a41399d3f9018d5b2e10f0195632f349201c5c55cce115", + "size": 22372511, + "subdir": "linux-64", + "timestamp": 1529763163898, + "version": "3.6.5" + }, + "mongodb-4.0.2-h3a61b39_0.conda": { + "build": "h3a61b39_0", + "build_number": 0, + "depends": [ + "libcurl >=7.61.0,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.0.2p,<1.0.3a" + ], + "license": "AGPLv3", + "license_family": "AGPL", + "md5": "a1091368dfa6428fc647d606b47c3d86", + "name": "mongodb", + "sha256": "85d18465f89c4f805b5fcba19772b42fbd3827f9914608f1db7443b0769f122f", + "size": 19822222, + "subdir": "linux-64", + "timestamp": 1535820521500, + "version": "4.0.2" + }, + "mongodb-4.0.3-h597af5e_0.conda": { + "build": "h597af5e_0", + "build_number": 0, + "depends": [ + "libcurl >=7.61.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "AGPLv3", + "license_family": "AGPL", + "md5": "d863ffc52f3d38e2e76ea3754e1296c9", + "name": "mongodb", + "sha256": "82e5790079bc8c078037a1ae7e51ca7423a21a189172d2fbc47d313bf1f0050c", + "size": 19999200, + "subdir": "linux-64", + "timestamp": 1541024139648, + "version": "4.0.3" + }, + "more-itertools-4.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "75b76e44b7406718b9f917c6d59a0135", + "name": "more-itertools", + "sha256": "fff1200788860b3752ca45cf15bfa59e2bb3e78ca55a4f169e877f12469f05b7", + "size": 77383, + "subdir": "linux-64", + "timestamp": 1519236870023, + "version": "4.1.0" + }, + "more-itertools-4.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e5ff55b0cc230c5ff9672a1909a15352", + "name": "more-itertools", + "sha256": "7607487bf73e34f2304faa3ef3049488018015ce911b2b358c8b2bc8ab839f5a", + "size": 80358, + "subdir": "linux-64", + "timestamp": 1519236922150, + "version": "4.1.0" + }, + "more-itertools-4.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1772fd943260ac56007675abfff6289", + "name": "more-itertools", + "sha256": "9a9f02b26b7e768cbb43d3e68f847f748e730354da63efe40486ac20bfb37e5e", + "size": 79715, + "subdir": "linux-64", + "timestamp": 1519236808731, + "version": "4.1.0" + }, + "more-itertools-4.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb47d0d8069c93b758b9a6d387aabb0d", + "name": "more-itertools", + "sha256": "f43cb2c49136b64821ec93746c77f0b6e0db3a0a3e28e6014b3d64cf41e49ef2", + "size": 79211, + "subdir": "linux-64", + "timestamp": 1527787356661, + "version": "4.2.0" + }, + "more-itertools-4.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d1450634894cd33dc3c2dd45ce80d23", + "name": "more-itertools", + "sha256": "2764a912e0b2b953887c546db103add4cf97fae100347cd1fa798d7304b9b851", + "size": 82272, + "subdir": "linux-64", + "timestamp": 1527787381730, + "version": "4.2.0" + }, + "more-itertools-4.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "03af88bedcd8813f888368e7b737acc0", + "name": "more-itertools", + "sha256": "a5721a0a514d0f0f2c9ac49b2ef654d2d3cf3c5e68a30d1dbf174b0c0326826b", + "size": 81609, + "subdir": "linux-64", + "timestamp": 1527787302933, + "version": "4.2.0" + }, + "more-itertools-4.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "024b59e44110328c7e93681de4612240", + "name": "more-itertools", + "sha256": "eb8d94ca26f2e7e65cd2ea1a245cc5efdfedae4772ec16365c17ca729abd837b", + "size": 81650, + "subdir": "linux-64", + "timestamp": 1530693776170, + "version": "4.2.0" + }, + "more-itertools-4.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dcb0c830d22915f6bf0ae806cb8fef60", + "name": "more-itertools", + "sha256": "81567ca59cb7c4dc01b8cc1dcaf25d0d9cc0b42c8a4efd6f8e766fd01be630db", + "size": 83260, + "subdir": "linux-64", + "timestamp": 1533709186208, + "version": "4.3.0" + }, + "more-itertools-4.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d615af5a18a4c40e42bcc7faf97af308", + "name": "more-itertools", + "sha256": "0c23646362159885451e76b05a6d111756f806c3f2fdc352359d700c0c28ce72", + "size": 87762, + "subdir": "linux-64", + "timestamp": 1533709260446, + "version": "4.3.0" + }, + "more-itertools-4.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "55dd1e13b78768a21121cc90c9a6a499", + "name": "more-itertools", + "sha256": "66e8c7748bbedaffe908930bfa2af8d708d712071189fccc2ded9e0f3afb502b", + "size": 85602, + "subdir": "linux-64", + "timestamp": 1533709162620, + "version": "4.3.0" + }, + "more-itertools-4.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1efea29da1f3468cfbd63625d6b4be29", + "name": "more-itertools", + "sha256": "f974cb0883ee2cecccc39feac473f9f9742b837d5b37fcbc2cca11811f0f067d", + "size": 86891, + "subdir": "linux-64", + "timestamp": 1533709451738, + "version": "4.3.0" + }, + "more-itertools-5.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1aaa68e516c1da03cc7e79d98e2d4c66", + "name": "more-itertools", + "sha256": "7706e31a513840143b44ae54094ad82af055c2ab408e7c94174e24d2486681c8", + "size": 91346, + "subdir": "linux-64", + "timestamp": 1547239079749, + "version": "5.0.0" + }, + "more-itertools-5.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b53ef75ed439f88cfbd0b2e615165551", + "name": "more-itertools", + "sha256": "3e0416884e09924ac9d83dee37af1a2fd88c0405e7e65494df9f9c9abd408685", + "size": 92237, + "subdir": "linux-64", + "timestamp": 1547239124918, + "version": "5.0.0" + }, + "more-itertools-5.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.0.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d4b1161aff697125fab9c78d80b135d", + "name": "more-itertools", + "sha256": "e44c858575cc0167c60bc346a623843e365dfefc68a74750dc550df92ddffed7", + "size": 93535, + "subdir": "linux-64", + "timestamp": 1547239091064, + "version": "5.0.0" + }, + "more-itertools-6.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60e7732118992eb0d8b4612bc872b754", + "name": "more-itertools", + "sha256": "9eba1135bd506a0c660d1fe3e12071fb5d8052932158b95c3a6122042aa9233e", + "size": 91863, + "subdir": "linux-64", + "timestamp": 1552446164377, + "version": "6.0.0" + }, + "more-itertools-6.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "336381d2e16e65696f361ea5c3c19b6c", + "name": "more-itertools", + "sha256": "a4a16183b047cf5c3eb73dac9f706743cbc14739c5ae01d02eb5301dd8e41547", + "size": 91613, + "subdir": "linux-64", + "timestamp": 1552446316901, + "version": "6.0.0" + }, + "more-itertools-7.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "99a63a1be247935340d845b6a8d10462", + "name": "more-itertools", + "sha256": "d72180006c4a9afa9cb408a051e7c2a80c65424d4a2b63b19e9471ebfb7b06f2", + "size": 97300, + "subdir": "linux-64", + "timestamp": 1556083013106, + "version": "7.0.0" + }, + "more-itertools-7.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "afc1b7e0b7ffe476951bc0f88e829b88", + "name": "more-itertools", + "sha256": "7728e5afebe228c279cbfb90b2d0d16ef666824312b88e7f3feedefd6b3db54c", + "size": 95452, + "subdir": "linux-64", + "timestamp": 1556116252824, + "version": "7.0.0" + }, + "more-itertools-7.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd27a64f964f7372507a5ab4876e3a16", + "name": "more-itertools", + "sha256": "ea7256d7dad9edacdab8b7a673ae9096a35bff8dc12d975ded738f757b798423", + "size": 103257, + "subdir": "linux-64", + "timestamp": 1564701128262, + "version": "7.2.0" + }, + "more-itertools-7.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4146e7643e84c40ddb44115c6272c78c", + "name": "more-itertools", + "sha256": "8d0ff94a3c4083ed12ac0ce00d8bf3c403c87c4eef112581f3da855207c403a8", + "size": 102825, + "subdir": "linux-64", + "timestamp": 1564701101721, + "version": "7.2.0" + }, + "more-itertools-7.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca19ca4e2f15bc86d03fbfe8c2ee3751", + "name": "more-itertools", + "sha256": "ea5e42187a773fada4c45116f3740f7c7a7e3a8b15e150ba53d3f0dbffd2e8e2", + "size": 101647, + "subdir": "linux-64", + "timestamp": 1572609171161, + "version": "7.2.0" + }, + "morfessor-2.0.3-py27h349872b_0.conda": { + "build": "py27h349872b_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "169ec7e8266a9a04e104d8c5505fca53", + "name": "morfessor", + "sha256": "0144838606619deb7887f8c827b400a6bad545d5edf4c46fb268135bf6493ecb", + "size": 59966, + "subdir": "linux-64", + "timestamp": 1508795515589, + "version": "2.0.3" + }, + "morfessor-2.0.3-py35h28ae230_0.conda": { + "build": "py35h28ae230_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "027074a274b367bb6f293c73c03ef2b3", + "name": "morfessor", + "sha256": "f6cb24120fdcfa2e97831276aa8af50832eac5259eeef39853304323df7aecb4", + "size": 61888, + "subdir": "linux-64", + "timestamp": 1508795517053, + "version": "2.0.3" + }, + "morfessor-2.0.3-py36h8a99c1e_0.conda": { + "build": "py36h8a99c1e_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "8a5fd3fa19c4b00359672300ee988739", + "name": "morfessor", + "sha256": "93cf7928c5aab1547d5f312df1dd41cd5a2a8b38b7143e64e9c835ee4562adff", + "size": 61230, + "subdir": "linux-64", + "timestamp": 1508795529734, + "version": "2.0.3" + }, + "morfessor-2.0.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "6b09ceddd6646d43bbed7fd309778030", + "name": "morfessor", + "sha256": "0a47bfa461586be9674fe412706adafa9936f9896ac191edb8da6874f83e5184", + "size": 60626, + "subdir": "linux-64", + "timestamp": 1522129209180, + "version": "2.0.4" + }, + "morfessor-2.0.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "5c519369d37d130020ba4c89253d9cf6", + "name": "morfessor", + "sha256": "845279e9a189a9d739a9fe0a371dbaa77571dfed7e3d31afac2af6b4ae6a7a98", + "size": 61799, + "subdir": "linux-64", + "timestamp": 1522129214249, + "version": "2.0.4" + }, + "morfessor-2.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "e8e6d391f52efe168a8a576d7faf430e", + "name": "morfessor", + "sha256": "c28b6f3603fa76b6e001ab292b9dc1bd5cc31054fc45769ab88e724802609d7e", + "size": 61145, + "subdir": "linux-64", + "timestamp": 1522129214932, + "version": "2.0.4" + }, + "morfessor-2.0.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "4f065bf66226258ee9c174428cdf6a8f", + "name": "morfessor", + "sha256": "9f07dd8a51b4c42c16f3f1c294772356ee9b07dad15e8b2e94b80c1c37f600ce", + "size": 60163, + "subdir": "linux-64", + "timestamp": 1530888070446, + "version": "2.0.4" + }, + "moto-4.0.11-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aws-xray-sdk >=0.93,!=0.96", + "boto3 >=1.9.201", + "botocore >=1.12.201", + "cfn-lint >=0.4.0", + "cryptography >=3.3.1", + "docker-py >=2.5.1", + "ecdsa !=0.15", + "flask", + "flask_cors", + "graphql-core", + "idna >=2.5,<4", + "jinja2 >=2.10.1", + "jsondiff >=1.1.2", + "markupsafe !=2.0.0a1", + "openapi-spec-validator", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.1,<3.0.0", + "python-jose >=3.1.0,<4.0.0", + "pytz", + "pyyaml >=5.1", + "requests >=2.5", + "responses >=0.13.0", + "sshpubkeys >=3.1.0", + "werkzeug >=0.5,!=2.2.0,!=2.2.1", + "xmltodict" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "214cd6acbe2280e9593cfd887a31dd26", + "name": "moto", + "sha256": "87651b7ced271de0ad375f542c8bdaa651b47ec63ad883367d2719f0748c5fc3", + "size": 2771179, + "subdir": "linux-64", + "timestamp": 1671141758412, + "version": "4.0.11" + }, + "moto-4.0.11-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aws-xray-sdk >=0.93,!=0.96", + "boto3 >=1.9.201", + "botocore >=1.12.201", + "cfn-lint >=0.4.0", + "cryptography >=3.3.1", + "docker-py >=2.5.1", + "ecdsa !=0.15", + "flask", + "flask_cors", + "graphql-core", + "idna >=2.5,<4", + "importlib_metadata", + "jinja2 >=2.10.1", + "jsondiff >=1.1.2", + "markupsafe !=2.0.0a1", + "openapi-spec-validator", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1,<3.0.0", + "python-jose >=3.1.0,<4.0.0", + "pytz", + "pyyaml >=5.1", + "requests >=2.5", + "responses >=0.13.0", + "sshpubkeys >=3.1.0", + "werkzeug >=0.5,!=2.2.0,!=2.2.1", + "xmltodict" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "67d2339026769dc59a5d2e4d128c2dd8", + "name": "moto", + "sha256": "dbcc78ff7a113bdcdce5574ad4b433ec590ac5f01c5f1bef621eeb058682b02f", + "size": 2725140, + "subdir": "linux-64", + "timestamp": 1671141694713, + "version": "4.0.11" + }, + "moto-4.0.11-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-xray-sdk >=0.93,!=0.96", + "boto3 >=1.9.201", + "botocore >=1.12.201", + "cfn-lint >=0.4.0", + "cryptography >=3.3.1", + "docker-py >=2.5.1", + "ecdsa !=0.15", + "flask", + "flask_cors", + "graphql-core", + "idna >=2.5,<4", + "jinja2 >=2.10.1", + "jsondiff >=1.1.2", + "markupsafe !=2.0.0a1", + "openapi-spec-validator", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1,<3.0.0", + "python-jose >=3.1.0,<4.0.0", + "pytz", + "pyyaml >=5.1", + "requests >=2.5", + "responses >=0.13.0", + "sshpubkeys >=3.1.0", + "werkzeug >=0.5,!=2.2.0,!=2.2.1", + "xmltodict" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b83c39b5b57f54395527915155cd1cec", + "name": "moto", + "sha256": "e1c6ac38ac49fe982fc09d1121626f68b684958c052dbe5bc7f6eea7c8433781", + "size": 2745348, + "subdir": "linux-64", + "timestamp": 1671141627730, + "version": "4.0.11" + }, + "moto-4.0.11-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aws-xray-sdk >=0.93,!=0.96", + "boto3 >=1.9.201", + "botocore >=1.12.201", + "cfn-lint >=0.4.0", + "cryptography >=3.3.1", + "docker-py >=2.5.1", + "ecdsa !=0.15", + "flask", + "flask_cors", + "graphql-core", + "idna >=2.5,<4", + "jinja2 >=2.10.1", + "jsondiff >=1.1.2", + "markupsafe !=2.0.0a1", + "openapi-spec-validator", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1,<3.0.0", + "python-jose >=3.1.0,<4.0.0", + "pytz", + "pyyaml >=5.1", + "requests >=2.5", + "responses >=0.13.0", + "sshpubkeys >=3.1.0", + "werkzeug >=0.5,!=2.2.0,!=2.2.1", + "xmltodict" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9994a1150889c18f12790b03b6738b4d", + "name": "moto", + "sha256": "875710834dc2fd2b804987f1f3471bf636922d190c742137102d6797a37f205e", + "size": 2742089, + "subdir": "linux-64", + "timestamp": 1671141821140, + "version": "4.0.11" + }, + "moto-4.1.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aws-xray-sdk >=0.93,!=0.96", + "boto3 >=1.9.201", + "botocore >=1.12.201", + "cfn-lint >=0.40.0", + "cryptography >=3.3.1", + "docker-py >=2.5.1", + "ecdsa !=0.15", + "flask !=2.2.0,!=2.2.1", + "flask_cors", + "graphql-core", + "jinja2 >=2.10.1", + "jsondiff >=1.1.2", + "openapi-spec-validator >=0.2.8", + "pyparsing >=3.0.7", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.1,<3.0.0", + "python-jose >=3.1.0,<4.0.0", + "pyyaml >=5.1", + "requests >=2.5", + "responses >=0.13.0", + "sshpubkeys >=3.1.0", + "werkzeug >=0.5,!=2.2.0,!=2.2.1", + "xmltodict" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7d93abedb507f2eba1b852bbdb1ba7c5", + "name": "moto", + "sha256": "13b066ee58266ad4474518016bbd4deebbf3faaab120b0620bc0059bf89c9382", + "size": 2848658, + "subdir": "linux-64", + "timestamp": 1677780517180, + "version": "4.1.3" + }, + "moto-4.1.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aws-xray-sdk >=0.93,!=0.96", + "boto3 >=1.9.201", + "botocore >=1.12.201", + "cfn-lint >=0.40.0", + "cryptography >=3.3.1", + "docker-py >=2.5.1", + "ecdsa !=0.15", + "flask !=2.2.0,!=2.2.1", + "flask_cors", + "graphql-core", + "jinja2 >=2.10.1", + "jsondiff >=1.1.2", + "openapi-spec-validator >=0.2.8", + "pyparsing >=3.0.7", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.1,<3.0.0", + "python-jose >=3.1.0,<4.0.0", + "pyyaml >=5.1", + "requests >=2.5", + "responses >=0.13.0", + "sshpubkeys >=3.1.0", + "werkzeug >=0.5,!=2.2.0,!=2.2.1", + "xmltodict" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8ca2c6f89a5a3f0a38b90b2464cc549f", + "name": "moto", + "sha256": "f494d3f6959a62732695ff1ca20ba85a79f079e6903e745da94250f9b583403d", + "size": 3255408, + "subdir": "linux-64", + "timestamp": 1677784813804, + "version": "4.1.3" + }, + "moto-4.1.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aws-xray-sdk >=0.93,!=0.96", + "boto3 >=1.9.201", + "botocore >=1.12.201", + "cfn-lint >=0.40.0", + "cryptography >=3.3.1", + "docker-py >=2.5.1", + "ecdsa !=0.15", + "flask !=2.2.0,!=2.2.1", + "flask_cors", + "graphql-core", + "jinja2 >=2.10.1", + "jsondiff >=1.1.2", + "openapi-spec-validator >=0.2.8", + "pyparsing >=3.0.7", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1,<3.0.0", + "python-jose >=3.1.0,<4.0.0", + "pyyaml >=5.1", + "requests >=2.5", + "responses >=0.13.0", + "sshpubkeys >=3.1.0", + "werkzeug >=0.5,!=2.2.0,!=2.2.1", + "xmltodict" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5801e10becaf60d105c67bf49e743c76", + "name": "moto", + "sha256": "3d3c5ed02d9d90d28ba15014baddb0c2a15657bea62a79a53cf49c470ef6b9e2", + "size": 2820427, + "subdir": "linux-64", + "timestamp": 1677780393253, + "version": "4.1.3" + }, + "moto-4.1.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aws-xray-sdk >=0.93,!=0.96", + "boto3 >=1.9.201", + "botocore >=1.12.201", + "cfn-lint >=0.40.0", + "cryptography >=3.3.1", + "docker-py >=2.5.1", + "ecdsa !=0.15", + "flask !=2.2.0,!=2.2.1", + "flask_cors", + "graphql-core", + "jinja2 >=2.10.1", + "jsondiff >=1.1.2", + "openapi-spec-validator >=0.2.8", + "pyparsing >=3.0.7", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1,<3.0.0", + "python-jose >=3.1.0,<4.0.0", + "pyyaml >=5.1", + "requests >=2.5", + "responses >=0.13.0", + "sshpubkeys >=3.1.0", + "werkzeug >=0.5,!=2.2.0,!=2.2.1", + "xmltodict" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ef81039a012e533d5bfbc1278d2de268", + "name": "moto", + "sha256": "468aa8abbd55f73dac8fb4d1d8f8ae9c01cc7066432a7c112f79e33a16665ca2", + "size": 2818007, + "subdir": "linux-64", + "timestamp": 1677780457056, + "version": "4.1.3" + }, + "mpc-1.0.3-hec55b23_5.conda": { + "build": "hec55b23_5", + "build_number": 5, + "depends": [ + "gmp >=5.0.1,<7", + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "mpfr" + ], + "license": "LGPL 3", + "md5": "d9c58e92ec94e340634963a30d098868", + "name": "mpc", + "sha256": "f8955b4c4961e4b5f25182d8bae2cd4203c2f3152752a5145fa9604f2ee20946", + "size": 93040, + "subdir": "linux-64", + "timestamp": 1511294796834, + "version": "1.0.3" + }, + "mpc-1.0.3-hf803216_4.conda": { + "build": "hf803216_4", + "build_number": 4, + "depends": [ + "gmp >=5.0.1,<7", + "libgcc-ng >=7.2.0", + "mpfr 3.*" + ], + "license": "LGPL 3", + "md5": "c3cb2431483497c0f4eb869b4815672e", + "name": "mpc", + "sha256": "df64796796c0029a4f1157f416d9f73af37906c0f73eecb8514ef2c1dbdc8903", + "size": 92401, + "subdir": "linux-64", + "timestamp": 1505743972498, + "version": "1.0.3" + }, + "mpc-1.1.0-h10f8cd9_1.conda": { + "build": "h10f8cd9_1", + "build_number": 1, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "mpfr >=4.0.1,<5.0a0" + ], + "license": "LGPL 3", + "md5": "a04e160ec0a1117f7638590e534f16c7", + "name": "mpc", + "sha256": "90322d0e98d817ec615669aefb99d0bddce7e029ec7a7f3c5b48bd1bf4d41feb", + "size": 91993, + "subdir": "linux-64", + "timestamp": 1527612531645, + "version": "1.1.0" + }, + "mpfr-3.1.5-h11a74b3_2.conda": { + "build": "h11a74b3_2", + "build_number": 2, + "depends": [ + "gmp", + "gmp >=6.1.2", + "libgcc-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "bdab5ebe5404a9caaedafb08853cada0", + "name": "mpfr", + "sha256": "2ea91fd30e81a561cd67f81fb01ecf65d0bced80b5c9867a779330d265fcd200", + "size": 353280, + "subdir": "linux-64", + "timestamp": 1511294529949, + "version": "3.1.5" + }, + "mpfr-3.1.5-h12ff648_1.conda": { + "build": "h12ff648_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "7ca4868a7f5cdbebf8b4a3edf9b0bbeb", + "name": "mpfr", + "sha256": "3e209385e1d4cbcde47882c6fb0497cae61510bfdf25160ae71ab92e03962770", + "size": 352350, + "subdir": "linux-64", + "timestamp": 1505743909510, + "version": "3.1.5" + }, + "mpfr-4.0.1-hdf1c602_3.conda": { + "build": "hdf1c602_3", + "build_number": 3, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "0323b2e3372454579f8075f0ef6f41cc", + "name": "mpfr", + "sha256": "a99075b3af3f3ae6d98009046a4c03ecd8f0f226bd374e0c27076e96931f036f", + "size": 438978, + "subdir": "linux-64", + "timestamp": 1527610359076, + "version": "4.0.1" + }, + "mpfr-4.0.2-hb69a4c5_1.conda": { + "build": "hb69a4c5_1", + "build_number": 1, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0" + ], + "license": "LGPL-3.0-only", + "md5": "9000a148d49baa5a3b3428397889d37d", + "name": "mpfr", + "sha256": "eaa635e5db2ccff32d0fc43dce1492bc235075c843dc86522578f2f098c92a08", + "size": 498414, + "subdir": "linux-64", + "timestamp": 1593116348009, + "version": "4.0.2" + }, + "mpg123-1.25.8-h295c915_1000.conda": { + "build": "h295c915_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "b2211d0dd6345fa7500536e1aa6df25c", + "name": "mpg123", + "sha256": "3e2554dd1fbf8f0f920cbf11098021f70cb019ac2d40cbfadda622af1bc6166e", + "size": 304322, + "subdir": "linux-64", + "timestamp": 1632139645963, + "version": "1.25.8" + }, + "mpg123-1.30.0-h6a678d5_1000.conda": { + "build": "h6a678d5_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "46115ede16000304994b346d781d0226", + "name": "mpg123", + "sha256": "564ceb968db2dfcdccd8346b135f4a68c173caad2341e929e638c356668f90e6", + "size": 480973, + "subdir": "linux-64", + "timestamp": 1656450584250, + "version": "1.30.0" + }, + "mpi-1.0-mpich.conda": { + "build": "mpich", + "build_number": 8, + "depends": [], + "license": "MPICH", + "license_family": "Other", + "md5": "3310b0d36925b82ad3bd800758f4bf9f", + "name": "mpi", + "sha256": "03438633485604de5e53d7ab47da533e85ce229099014dd7b20b1fe284d2937a", + "size": 13671, + "subdir": "linux-64", + "timestamp": 1555635183453, + "version": "1.0" + }, + "mpi-1.0-openmpi.conda": { + "build": "openmpi", + "build_number": 0, + "depends": [], + "license": "BSD 3-clause", + "md5": "62f35e48332f4803730bfa1ffb9ea841", + "name": "mpi", + "sha256": "69ee039d7cfb05009dc41d3afab38290cf17fdc5a09cab81d7e0fef276bb49a7", + "size": 7037, + "subdir": "linux-64", + "timestamp": 1575396115448, + "version": "1.0" + }, + "mpi4py-3.0.3-py27h028fd6f_0.conda": { + "build": "py27h028fd6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mpich >=3.3,<3.4.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "053d6d0a73fba880aa66bb37d34ef79f", + "name": "mpi4py", + "sha256": "574a75629d40c2b3a2199ced81c16daaee040465a3393db21b6563e19a5fce0a", + "size": 549349, + "subdir": "linux-64", + "timestamp": 1575396802756, + "version": "3.0.3" + }, + "mpi4py-3.0.3-py27hd0bea5a_0.conda": { + "build": "py27hd0bea5a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openmpi >=4.0,<4.1.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "2a16e84851fd46cdd438ef01771598b0", + "name": "mpi4py", + "sha256": "6fe2eef9fc88afb800572fa5141bd1b26e5755ea1b9957319772de4edf4fcd55", + "size": 552475, + "subdir": "linux-64", + "timestamp": 1575397289640, + "version": "3.0.3" + }, + "mpi4py-3.0.3-py36h028fd6f_0.conda": { + "build": "py36h028fd6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mpich >=3.3,<3.4.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "c4a8b852a93ee4bb02e39526b433fe0a", + "name": "mpi4py", + "sha256": "755996bd8d971f5b60e4e35f84aefa9be5be65eb714fadb66cd869d2957dba9c", + "size": 554026, + "subdir": "linux-64", + "timestamp": 1575396757962, + "version": "3.0.3" + }, + "mpi4py-3.0.3-py36hd0bea5a_0.conda": { + "build": "py36hd0bea5a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openmpi >=4.0,<4.1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "334539a22c94737a652b63f4a3f3dffa", + "name": "mpi4py", + "sha256": "32a293945177c0a4c129eab50fbb8b8d38279bd6d1f8cb63007297883d2abf7e", + "size": 557417, + "subdir": "linux-64", + "timestamp": 1575397284445, + "version": "3.0.3" + }, + "mpi4py-3.0.3-py37h028fd6f_0.conda": { + "build": "py37h028fd6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mpich >=3.3,<3.4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "2128942356c81441bbefd5db74113c8a", + "name": "mpi4py", + "sha256": "3c43a8778cd3e21cddb0062d6a09966dfdd93d606faae5e7a30f264c732ef31e", + "size": 553609, + "subdir": "linux-64", + "timestamp": 1575396757721, + "version": "3.0.3" + }, + "mpi4py-3.0.3-py37hd0bea5a_0.conda": { + "build": "py37hd0bea5a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openmpi >=4.0,<4.1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "be913b6798a970ad227ac7bef0e1a923", + "name": "mpi4py", + "sha256": "4bc236acc12c5014fae777c649f77b9bdaf356af53365083b3bfd3a792aca151", + "size": 556982, + "subdir": "linux-64", + "timestamp": 1575397292358, + "version": "3.0.3" + }, + "mpi4py-3.0.3-py37hd955b32_1.conda": { + "build": "py37hd955b32_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "openmpi >=4.0,<4.1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "cf1f7abfff1296430af2c45047847cd7", + "name": "mpi4py", + "sha256": "95eb4ccc1a8ca47bb03a80f58f6105a5059c183062a8e62ad936bbc122c59990", + "size": 551460, + "subdir": "linux-64", + "timestamp": 1594374186510, + "version": "3.0.3" + }, + "mpi4py-3.0.3-py37hf046da1_1.conda": { + "build": "py37hf046da1_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "mpich >=3.3,<3.4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "7e901fa283410407f3c68f4ed62cdfc6", + "name": "mpi4py", + "sha256": "8fcee984665b91223d3f3230d765af94a5082dc3c21f169b8d9de2e06bc590f4", + "size": 548827, + "subdir": "linux-64", + "timestamp": 1594374096623, + "version": "3.0.3" + }, + "mpi4py-3.0.3-py38h028fd6f_0.conda": { + "build": "py38h028fd6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mpich >=3.3,<3.4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "e5479dc898e61765deee83aba69afe7c", + "name": "mpi4py", + "sha256": "58dfade77824f38d25b38159e7f920c015e519fffc3b6cca386b0a49bc2ef491", + "size": 585574, + "subdir": "linux-64", + "timestamp": 1575396794073, + "version": "3.0.3" + }, + "mpi4py-3.0.3-py38hd0bea5a_0.conda": { + "build": "py38hd0bea5a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openmpi >=4.0,<4.1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "dd6b5b09c6ab6b2514fb813d689df179", + "name": "mpi4py", + "sha256": "3886d7bb059be308e316c38ade63fee7e9e837852a210f18e87017daee5f2389", + "size": 587034, + "subdir": "linux-64", + "timestamp": 1575397312527, + "version": "3.0.3" + }, + "mpi4py-3.1.4-py310h3e5f7c9_0.conda": { + "build": "py310h3e5f7c9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openmpi >=4.0,<4.1.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e1d29946d2d71657282d7c0be52babca", + "name": "mpi4py", + "sha256": "6937ca0493c6febe891c9bd929be0b541b8381d0c7b1d5de7d0dd225571e7958", + "size": 590101, + "subdir": "linux-64", + "timestamp": 1671223561358, + "version": "3.1.4" + }, + "mpi4py-3.1.4-py310hfc96bbd_0.conda": { + "build": "py310hfc96bbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mpich >=3.3,<3.4.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "dc93df7e823a3041236e43d4c62fbab3", + "name": "mpi4py", + "sha256": "2cbd663523225d6177f809fee5d22045e4b5837d1ed437f323cf161d480df52d", + "size": 586257, + "subdir": "linux-64", + "timestamp": 1671223798897, + "version": "3.1.4" + }, + "mpi4py-3.1.4-py311h3e5f7c9_0.conda": { + "build": "py311h3e5f7c9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openmpi >=4.0,<4.1.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "de3f19d43b0a88b03037a2652653aa06", + "name": "mpi4py", + "sha256": "82766450bec9cf0318ba2d494580821661cfa45610a61f1b094b439487dce251", + "size": 553911, + "subdir": "linux-64", + "timestamp": 1676858780773, + "version": "3.1.4" + }, + "mpi4py-3.1.4-py311hfc96bbd_0.conda": { + "build": "py311hfc96bbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mpich >=3.3,<3.4.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5c583a1c0739d7aeba7e585b232c3a07", + "name": "mpi4py", + "sha256": "e3275a64ca402bf73ccc6a9b17878dfd07645e4fbb3c72d7ed393e400ba9b1a2", + "size": 552575, + "subdir": "linux-64", + "timestamp": 1676858739897, + "version": "3.1.4" + }, + "mpi4py-3.1.4-py37h3e5f7c9_0.conda": { + "build": "py37h3e5f7c9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openmpi >=4.0,<4.1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "637edcb5c0cbcb47af339e0ce434634b", + "name": "mpi4py", + "sha256": "cca3164965cf83e853a36033600eca5655c3161082dad8530cf04488e5ebd44a", + "size": 563396, + "subdir": "linux-64", + "timestamp": 1671223445145, + "version": "3.1.4" + }, + "mpi4py-3.1.4-py37hfc96bbd_0.conda": { + "build": "py37hfc96bbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mpich >=3.3,<3.4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ec96c0ffcfe170566ec7dd00c238802c", + "name": "mpi4py", + "sha256": "7c4edaf229bb33bbd2f1cd139e52b098000be3723d5ca1a3302f424527113c64", + "size": 559946, + "subdir": "linux-64", + "timestamp": 1671223680592, + "version": "3.1.4" + }, + "mpi4py-3.1.4-py38h3e5f7c9_0.conda": { + "build": "py38h3e5f7c9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openmpi >=4.0,<4.1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "94eff13facae534c73e5042d6c0fde52", + "name": "mpi4py", + "sha256": "f5e5c6637a5a596cb7b3ba7b7a92cd27c8a529493260796cdaa2f651a2bff40c", + "size": 593578, + "subdir": "linux-64", + "timestamp": 1671223619089, + "version": "3.1.4" + }, + "mpi4py-3.1.4-py38hfc96bbd_0.conda": { + "build": "py38hfc96bbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mpich >=3.3,<3.4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d0d15cb0a3b0a1625c8624f5ef585549", + "name": "mpi4py", + "sha256": "1cd58065ee74040ead865d017fa89f3b14e1dfaa36816fe007d7064321864c14", + "size": 591407, + "subdir": "linux-64", + "timestamp": 1671223857796, + "version": "3.1.4" + }, + "mpi4py-3.1.4-py39h3e5f7c9_0.conda": { + "build": "py39h3e5f7c9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openmpi >=4.0,<4.1.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "73fafcd90bbdc52b9b5938624922e873", + "name": "mpi4py", + "sha256": "f96cf0ae25364601f5046100c0267c13ab91f5e250613883a60aae634ad1f1e5", + "size": 595093, + "subdir": "linux-64", + "timestamp": 1671223503185, + "version": "3.1.4" + }, + "mpi4py-3.1.4-py39hfc96bbd_0.conda": { + "build": "py39hfc96bbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "mpich >=3.3,<3.4.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "1829343b9bace24ae84ee7bb61706ed8", + "name": "mpi4py", + "sha256": "576a612069f12500fc79dca5c782c91b6427819e6d9436ed9adbad155901ce3a", + "size": 592406, + "subdir": "linux-64", + "timestamp": 1671223739584, + "version": "3.1.4" + }, + "mpich-3.2.1-hf39692e_8.conda": { + "build": "hf39692e_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mpi 1.0 mpich" + ], + "license": "MPICH", + "license_family": "Other", + "md5": "ead47604310aff02578871638e279322", + "name": "mpich", + "sha256": "74e900c8c5f7a7143427c65a6fcff3274f0fee05927f106b0789245350cf079c", + "size": 3671943, + "subdir": "linux-64", + "timestamp": 1555635512696, + "version": "3.2.1" + }, + "mpich-3.3.2-external_0.conda": { + "build": "external_0", + "build_number": 0, + "depends": [ + "mpi 1.0 mpich" + ], + "license": "MPICH", + "license_family": "Other", + "md5": "3eb8fbc57b3dc88363a4866c35411e9c", + "name": "mpich", + "sha256": "bb27a58e21e50edb81c147eda1b34b64524d5152381b3f68d21cfe4be907ecdf", + "size": 15379, + "subdir": "linux-64", + "timestamp": 1575396471911, + "track_features": "mpich_external", + "version": "3.3.2" + }, + "mpich-3.3.2-hc856adb_0.conda": { + "build": "hc856adb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mpi 1.0 mpich" + ], + "license": "MPICH", + "license_family": "Other", + "md5": "3ca2b609c8caabd6ebe6122f60069fda", + "name": "mpich", + "sha256": "62adbd580e9b7956d5292abb3afacaff8fe8714a2e93c49fd0efacbcfea2f4c7", + "size": 4027940, + "subdir": "linux-64", + "timestamp": 1575396464358, + "version": "3.3.2" + }, + "mpich-mpicc-3.2.1-h7b6447c_8.conda": { + "build": "h7b6447c_8", + "build_number": 8, + "depends": [ + "gcc_linux-64 7.3.0.*", + "mpich 3.2.1 hf39692e_8" + ], + "license": "MPICH", + "license_family": "Other", + "md5": "459b7f4765335aed463752876b1d1356", + "name": "mpich-mpicc", + "sha256": "41615ee65e8c01ea77091276b09bed6f3ae03120b9a312888db86d44a55e2634", + "size": 13827, + "subdir": "linux-64", + "timestamp": 1555635526259, + "version": "3.2.1" + }, + "mpich-mpicc-3.3.2-hf39692e_0.conda": { + "build": "hf39692e_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 7.3.0.*", + "mpich 3.3.2 hc856adb_0" + ], + "license": "MPICH", + "license_family": "Other", + "md5": "30a90afe9ac4df5c1a7516c9b54b6e2a", + "name": "mpich-mpicc", + "sha256": "20ef6d0635f3e3368486221d33c45845f93f4e12ed808cc4c41525bdb68a659f", + "size": 15462, + "subdir": "linux-64", + "timestamp": 1575396475290, + "version": "3.3.2" + }, + "mpich-mpicxx-3.2.1-hfd86e86_8.conda": { + "build": "hfd86e86_8", + "build_number": 8, + "depends": [ + "gxx_linux-64 7.3.0.*", + "mpich 3.2.1 hf39692e_8" + ], + "license": "MPICH", + "license_family": "Other", + "md5": "1749f5f6cfe03d58fdc4a39c10addb60", + "name": "mpich-mpicxx", + "sha256": "3456e1b06341188009f81a01eff4219dd46a24c8c475f14f699b5d264b418791", + "size": 13873, + "subdir": "linux-64", + "timestamp": 1555635529681, + "version": "3.2.1" + }, + "mpich-mpicxx-3.3.2-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "gxx_linux-64 7.3.0.*", + "mpich 3.3.2 hc856adb_0" + ], + "license": "MPICH", + "license_family": "Other", + "md5": "be1e16f14608e1032e77d7991496156c", + "name": "mpich-mpicxx", + "sha256": "6ee5fb404a806756483458160075cd59ba42086b6083e167b8cf11e1b6bbe3e9", + "size": 15448, + "subdir": "linux-64", + "timestamp": 1575396478844, + "version": "3.3.2" + }, + "mpich-mpifort-3.2.1-h84218bc_8.conda": { + "build": "h84218bc_8", + "build_number": 8, + "depends": [ + "gfortran_linux-64 7.3.0.*", + "mpich 3.2.1 hf39692e_8" + ], + "license": "MPICH", + "license_family": "Other", + "md5": "d413928a79976ea5a022a49299c3711e", + "name": "mpich-mpifort", + "sha256": "264b8c13f5d26f82d2aed047997434f047877165faa98c091a7e04b405433a23", + "size": 13868, + "subdir": "linux-64", + "timestamp": 1555635533134, + "version": "3.2.1" + }, + "mpich-mpifort-3.3.2-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "gfortran_linux-64 7.3.0.*", + "mpich 3.3.2 hc856adb_0" + ], + "license": "MPICH", + "license_family": "Other", + "md5": "71a2c865d992390f862bf1ecdaebeffb", + "name": "mpich-mpifort", + "sha256": "92a374ae1929c5ab3102939a828d38ae2b81e815dc39879a60a5088c8e09bb3f", + "size": 15486, + "subdir": "linux-64", + "timestamp": 1575396482505, + "version": "3.3.2" + }, + "mpir-3.0.0-h3e5f119_1.conda": { + "build": "h3e5f119_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "dcbcde06e2e137147c8ba43440cbf37a", + "name": "mpir", + "sha256": "ff6eb030e9ba59fe6aad051cf9e8ba8d2fef85cf57aab94cbf1c9883947c4735", + "size": 487684, + "subdir": "linux-64", + "timestamp": 1511296144847, + "version": "3.0.0" + }, + "mpl-scatter-density-0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "fast-histogram >=0.3", + "matplotlib >=1.5", + "numpy >=1.11", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "b867f3991adebc03cd1def71a42e155c", + "name": "mpl-scatter-density", + "sha256": "ce09dfb45e621c429e7cf1440978f87be24c4d100a4542a9fd2a9db6122f7043", + "size": 1704991, + "subdir": "linux-64", + "timestamp": 1525295118007, + "version": "0.3" + }, + "mpl-scatter-density-0.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "fast-histogram >=0.3", + "matplotlib >=1.5", + "numpy >=1.11", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "b9dc601d474fcd5aebbb3696027ac4a2", + "name": "mpl-scatter-density", + "sha256": "f5d1e95fa94488b5f509a3666ee929acbf71be2d94915592029c145953029e7f", + "size": 1705334, + "subdir": "linux-64", + "timestamp": 1525295118155, + "version": "0.3" + }, + "mpl-scatter-density-0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "fast-histogram >=0.3", + "matplotlib >=1.5", + "numpy >=1.11", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "6fb2857eb0aaf9bdc28b0fe5e4d593c7", + "name": "mpl-scatter-density", + "sha256": "db1c6c45848e2b937ef0a651a60d8e665636d3ccdd2c968c18dcc50e65d6d8e0", + "size": 1705187, + "subdir": "linux-64", + "timestamp": 1525294023138, + "version": "0.3" + }, + "mpl-scatter-density-0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "fast-histogram >=0.3", + "matplotlib >=1.5", + "numpy >=1.11", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "a3e66467795b9d1ea5b3b3b996042268", + "name": "mpl-scatter-density", + "sha256": "b75ad319314d010d469a8f189fab06409920d07013089d32a9f7b5b1c56804fb", + "size": 1704947, + "subdir": "linux-64", + "timestamp": 1530891003814, + "version": "0.3" + }, + "mpl-scatter-density-0.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "fast-histogram >=0.3", + "matplotlib >=1.5", + "numpy >=1.11", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "a04bdbc46170f5b9c543045025c1e425", + "name": "mpl-scatter-density", + "sha256": "e86204f276961bcf41dae0fbd21e7ba0adc19a180c9f67e204eed721796d6c03", + "size": 1711127, + "subdir": "linux-64", + "timestamp": 1536255570778, + "version": "0.4" + }, + "mpl-scatter-density-0.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "fast-histogram >=0.3", + "matplotlib >=1.5", + "numpy >=1.11", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "5a2453bc2c3abca0c8f68cd168533143", + "name": "mpl-scatter-density", + "sha256": "6d31124d51673b4c0031468fd29cadf823ba2502cbbd346e37368f80bfe20ccd", + "size": 1711417, + "subdir": "linux-64", + "timestamp": 1536255716682, + "version": "0.4" + }, + "mpl-scatter-density-0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "fast-histogram >=0.3", + "matplotlib >=1.5", + "numpy >=1.11", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "c4d98cad9cf2ed815fe73ab3b70e74f6", + "name": "mpl-scatter-density", + "sha256": "6adc4bb9564e30e2efc953bbf0add7eb5e4a07642ba0007dc99c7595ce3e0d0b", + "size": 1710852, + "subdir": "linux-64", + "timestamp": 1536255682621, + "version": "0.4" + }, + "mpl-scatter-density-0.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "fast-histogram >=0.3", + "matplotlib >=1.5", + "numpy >=1.11", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "54db8a6758ac4e71dabb85b8dfdc7a1f", + "name": "mpl-scatter-density", + "sha256": "a647c4a89c7ea9b4fc2791fa945b244b51281c123790fabfd0e6987d5a50e65b", + "size": 1711842, + "subdir": "linux-64", + "timestamp": 1536255705284, + "version": "0.4" + }, + "mpl_sample_data-3.1.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "matplotlib-base 3.1.2 py36hef1b27d_1", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "10dd4e7ed999d61c60cdf51ab04f7f7a", + "name": "mpl_sample_data", + "sha256": "877cffb10ebd83adfc90a6608865906c64d2cb5c6eaa87e99f2d079b22fc3790", + "size": 1825819, + "subdir": "linux-64", + "timestamp": 1580491906088, + "version": "3.1.2" + }, + "mpl_sample_data-3.1.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "matplotlib-base 3.1.2 py37hef1b27d_1", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "0a055725cc59d6b1f3507332747eade4", + "name": "mpl_sample_data", + "sha256": "8b020d1c291d115492c7aba4b127b7810f1ddf5856b97f147c032a6cfcaa8a84", + "size": 1824068, + "subdir": "linux-64", + "timestamp": 1580491853267, + "version": "3.1.2" + }, + "mpl_sample_data-3.1.2-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "matplotlib-base 3.1.2 py38hef1b27d_1", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "4ca012c1045a7a383cefb1111fe43df4", + "name": "mpl_sample_data", + "sha256": "88183e15b4afc929a7b05d3933a0873b7a6057f1e635980a5b6f846a94b1bec5", + "size": 1825112, + "subdir": "linux-64", + "timestamp": 1580491876441, + "version": "3.1.2" + }, + "mpl_sample_data-3.1.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "matplotlib-base 3.1.3 py36hef1b27d_0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "c6b2bebd869b181d91e002e9cc4ce45e", + "name": "mpl_sample_data", + "sha256": "f90bf97b776b832bbafc04cc1c8abb3d2a3b863888d7885fd317faa129fa6b3d", + "size": 1825385, + "subdir": "linux-64", + "timestamp": 1580847946636, + "version": "3.1.3" + }, + "mpl_sample_data-3.1.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "matplotlib-base 3.1.3 py37hef1b27d_0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "16c41593a943867493386ad9324106e2", + "name": "mpl_sample_data", + "sha256": "ba32f9dc8cdbc76df99aefb27988039d4fa928408e4f821b947bf0cc8d942d90", + "size": 1825389, + "subdir": "linux-64", + "timestamp": 1580847945812, + "version": "3.1.3" + }, + "mpl_sample_data-3.1.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "matplotlib-base 3.1.3 py38hef1b27d_0", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-based", + "license_family": "PSF", + "md5": "d5c57cef7205b527acbfb975f8cd24fe", + "name": "mpl_sample_data", + "sha256": "94315917e89a9a0db9c6d2f8ac938b3e283d3530ba3da42e7e33b43446e4c20a", + "size": 1825631, + "subdir": "linux-64", + "timestamp": 1580847941427, + "version": "3.1.3" + }, + "mpld3-0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "86f4b360f2a8e99e2e2246c97db7f09a", + "name": "mpld3", + "sha256": "a7ce0edd5eb37fc68b66efbcda62cb24f3390040893943b00793bfabb9c6c44f", + "size": 124487, + "subdir": "linux-64", + "timestamp": 1522775909175, + "version": "0.3" + }, + "mpld3-0.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4c3dff271fe445fc2b9a41d8619cb009", + "name": "mpld3", + "sha256": "ddd556f29d45f069a7f8f7cc77b35fe10253858810624e00b1bef6ed93d634dd", + "size": 124419, + "subdir": "linux-64", + "timestamp": 1522775950358, + "version": "0.3" + }, + "mpld3-0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4c174d8d607855b8ea5b52abe353e306", + "name": "mpld3", + "sha256": "7239e7f20e339afcdd8826b090ab2c2443108817fedb2aed20b41bf3a1f1221f", + "size": 124714, + "subdir": "linux-64", + "timestamp": 1522775977476, + "version": "0.3" + }, + "mpld3-0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e3ffcd0d5335214440503d69f7ca1b22", + "name": "mpld3", + "sha256": "5af210da61946a1cc13397ae1b1a992673e1f57fda3c016af59d96f63c877966", + "size": 123679, + "subdir": "linux-64", + "timestamp": 1530899269539, + "version": "0.3" + }, + "mpld3-0.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9abaf8f3db3e6879d9babd1f8aa7e331", + "name": "mpld3", + "sha256": "676d3587e7a80c6481a10662aaf92ce5759afe8579dbfb4c80a549747e58a9aa", + "size": 125602, + "subdir": "linux-64", + "timestamp": 1574414047235, + "version": "0.3" + }, + "mpld3-0.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6009b8b2e2925fdd4f5747a4a9821c96", + "name": "mpld3", + "sha256": "dfea756294e03a96920d15177f77356b093ae0d185524493319ea1b2c9b9b6ac", + "size": 199702, + "subdir": "linux-64", + "timestamp": 1600444945965, + "version": "0.5.1" + }, + "mpld3-0.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e4fabf11e9c414cbf2a9253be936577d", + "name": "mpld3", + "sha256": "f39a3ef9efb10d1398cd92827b39bfcbfd83370ee365a84f2366becb5eeac810", + "size": 198607, + "subdir": "linux-64", + "timestamp": 1600444942489, + "version": "0.5.1" + }, + "mpld3-0.5.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5572b057064af6ef20e17b6a40949865", + "name": "mpld3", + "sha256": "b806ddcc6f25cb07f44d60b3b245b1cec3ff37abaa6be00fc924f9d9f6b4a41f", + "size": 200150, + "subdir": "linux-64", + "timestamp": 1600444917241, + "version": "0.5.1" + }, + "mpld3-0.5.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d16c768a8add073a7c212a0f8550500e", + "name": "mpld3", + "sha256": "d65003dfac27ef7f061656aef96f602d7c66c425482287d9de6f1ad251ff11e0", + "size": 193741, + "subdir": "linux-64", + "timestamp": 1612285389852, + "version": "0.5.2" + }, + "mpld3-0.5.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7e8f8b6543c4e7cf5286d4012dd44e63", + "name": "mpld3", + "sha256": "aff8017e4b6a15cc6a775ccfec4d20346ab9fdb218a1f871734e10ab971549d0", + "size": 193313, + "subdir": "linux-64", + "timestamp": 1612285352053, + "version": "0.5.2" + }, + "mpld3-0.5.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d63e1e9f990fa4a0f30c005cdef9be18", + "name": "mpld3", + "sha256": "64b0428d14821c3998f55dc87da5dbc84255b19bc7b24c1a7677042dde8d1841", + "size": 194084, + "subdir": "linux-64", + "timestamp": 1612285390745, + "version": "0.5.2" + }, + "mpld3-0.5.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2", + "matplotlib", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c3bf62416d12dd12ba30adbedf526977", + "name": "mpld3", + "sha256": "d660d504e8b7457a90a1e00079149c4c256f6dd86c21d13fbacd5af27563d0ae", + "size": 193946, + "subdir": "linux-64", + "timestamp": 1612285388834, + "version": "0.5.2" + }, + "mpld3-0.5.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=2.0", + "jinja2 >=2.7", + "matplotlib >=1.3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3e776cfb8ecc67d0a217cc7d1d158c8a", + "name": "mpld3", + "sha256": "293f3bb78ac083f76df72ae3b575160bb9116e74d14e266c86752dfef10c9f4a", + "size": 195366, + "subdir": "linux-64", + "timestamp": 1642515664664, + "version": "0.5.5" + }, + "mpld3-0.5.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=2.0", + "jinja2 >=2.7", + "matplotlib >=1.3", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "15bd740b887641c0ee779ae8b6604be1", + "name": "mpld3", + "sha256": "d9e91bcd0703d8f2ec0ebfc029dc47cf14c2752402c046111e23a5819f14f413", + "size": 212365, + "subdir": "linux-64", + "timestamp": 1676858798014, + "version": "0.5.5" + }, + "mpld3-0.5.5-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=2.0", + "jinja2 >=2.7", + "matplotlib >=1.3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aafe767467f4b72deceb4d5873856d12", + "name": "mpld3", + "sha256": "d01fe765153c74259a50c244b77fc5afa83adf6665abbde7f1e321f681833a47", + "size": 194879, + "subdir": "linux-64", + "timestamp": 1624427476189, + "version": "0.5.5" + }, + "mpld3-0.5.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=2.0", + "jinja2 >=2.7", + "matplotlib >=1.3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "16f00e393f098f7ff748ee6584fec9c4", + "name": "mpld3", + "sha256": "60782ab9dc2f1a2b790f9438b90e8275b3b6ca573f427b581313ff6b6ad1b7f4", + "size": 194384, + "subdir": "linux-64", + "timestamp": 1624433629074, + "version": "0.5.5" + }, + "mpld3-0.5.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=2.0", + "jinja2 >=2.7", + "matplotlib >=1.3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e7082b2c5a82375eb8d73fd83cf7c1e1", + "name": "mpld3", + "sha256": "422ff1eb5f96744e4e3f369fa3f6dd3de946c839795e66702a2e631a44ca7db2", + "size": 194711, + "subdir": "linux-64", + "timestamp": 1624433606443, + "version": "0.5.5" + }, + "mpld3-0.5.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=2.0", + "jinja2 >=2.7", + "matplotlib >=1.3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1853a279a48c965fc05e95b18f5957c5", + "name": "mpld3", + "sha256": "cfbcdadbf9aa61308864568e8a185f06cc455b3c5b1d4a6d193bb1fa0a7d48a0", + "size": 194633, + "subdir": "linux-64", + "timestamp": 1624433618789, + "version": "0.5.5" + }, + "mpmath-0.19-py27h4bb41bd_2.conda": { + "build": "py27h4bb41bd_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "76395c2864d3ffc744f2b090c7e57177", + "name": "mpmath", + "sha256": "e19ca5f4120c30c8d629e8f51e28f7bcc320f24b49df4854e338c7cb269b7570", + "size": 779531, + "subdir": "linux-64", + "timestamp": 1505745901141, + "version": "0.19" + }, + "mpmath-0.19-py35h5a16178_2.conda": { + "build": "py35h5a16178_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4dadc0fe7d01edb0c5c20a7bc214674e", + "name": "mpmath", + "sha256": "326389bbb416f2165d810f1168a1cdd0b4ddf1057e5abb2e71792e5937599b60", + "size": 805250, + "subdir": "linux-64", + "timestamp": 1505745920389, + "version": "0.19" + }, + "mpmath-0.19-py36h8cc018b_2.conda": { + "build": "py36h8cc018b_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8a9fae39b5d05bb55cec80f728b10cfa", + "name": "mpmath", + "sha256": "7e294f985f437dd492a41459b887887655b6dca6bddfed6b2e6af40ed0d98769", + "size": 799367, + "subdir": "linux-64", + "timestamp": 1505745939809, + "version": "0.19" + }, + "mpmath-1.0.0-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "512b8966860d724a621b70823877a55c", + "name": "mpmath", + "sha256": "7018c0056ab39b2d0ac43a83b90555b8ba2939d981fc44db348fc422458a774d", + "size": 794927, + "subdir": "linux-64", + "timestamp": 1530772160767, + "version": "1.0.0" + }, + "mpmath-1.0.0-py27h9669132_2.conda": { + "build": "py27h9669132_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6e3f5483b94cb6ebb97807613bfdc06b", + "name": "mpmath", + "sha256": "6d9f14a4775993685c6d22e0d255e8c78443e1c097c2c20e3583053623309b6f", + "size": 795929, + "subdir": "linux-64", + "timestamp": 1511810217800, + "version": "1.0.0" + }, + "mpmath-1.0.0-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1338bb5d424224a8b94ef90f4b9d2b64", + "name": "mpmath", + "sha256": "2e5a08cbbafb943ae40a746c189c1c55f5eb645813415acc43c62a4652b11921", + "size": 807876, + "subdir": "linux-64", + "timestamp": 1534804520047, + "version": "1.0.0" + }, + "mpmath-1.0.0-py35h7ce6e34_2.conda": { + "build": "py35h7ce6e34_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d5df96e559e9a5887c665e6b4bca78ef", + "name": "mpmath", + "sha256": "ebd7207e825f2454ae77339b6bad7f59b48332d8c92cdc2333f23d9eaafeeeb5", + "size": 808699, + "subdir": "linux-64", + "timestamp": 1511810223005, + "version": "1.0.0" + }, + "mpmath-1.0.0-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "73ba44df6289913aaa29da12ddeda7ab", + "name": "mpmath", + "sha256": "b7aa00af94e3989c5c0f4f46ce7f227852b1ca275213a0fbf5b22646bf5ae5b7", + "size": 793428, + "subdir": "linux-64", + "timestamp": 1530772188923, + "version": "1.0.0" + }, + "mpmath-1.0.0-py36hfeacd6b_2.conda": { + "build": "py36hfeacd6b_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7366e14847b54d421ebc46f14002f797", + "name": "mpmath", + "sha256": "339c0e41a5bb72150ec39f04d6a04c08a500e8c77e0af84d40367b9b8b963e94", + "size": 814419, + "subdir": "linux-64", + "timestamp": 1511810226368, + "version": "1.0.0" + }, + "mpmath-1.0.0-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "caa35f4ad72bfe26f2c0f138d152c4f6", + "name": "mpmath", + "sha256": "f6668607296fd97f67d3aea2aace8cba53d283211fb451a8d07478db1e837c59", + "size": 783089, + "subdir": "linux-64", + "timestamp": 1530772134808, + "version": "1.0.0" + }, + "mpmath-1.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3e739cae83263f70ce09150c3555094b", + "name": "mpmath", + "sha256": "87d675c8983cc0de2f78cd89e840b5072ef3d2df4fbef05f6f72c20620781663", + "size": 806940, + "subdir": "linux-64", + "timestamp": 1545078602385, + "version": "1.1.0" + }, + "mpmath-1.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7ce9a3e326e899b9d6078f605bad98fc", + "name": "mpmath", + "sha256": "34c1355db589177b359d1442f2a529b7e43ffaa7cde6ad77ebcb95e022cd8017", + "size": 794223, + "subdir": "linux-64", + "timestamp": 1545078640409, + "version": "1.1.0" + }, + "mpmath-1.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d77168a978e3c0665e7a6cc78c7b979b", + "name": "mpmath", + "sha256": "85efb5e0a0b1608e507788b7a894d56a7ee210cef9ebf318e004f3678ddb4878", + "size": 784037, + "subdir": "linux-64", + "timestamp": 1545078640500, + "version": "1.1.0" + }, + "mpmath-1.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7baff301325ba329392a65dfd64e8421", + "name": "mpmath", + "sha256": "6e40f5c996532066490e3494b00c7190150e54bb9a9e4d6023ee21e5de851391", + "size": 794914, + "subdir": "linux-64", + "timestamp": 1573120404744, + "version": "1.1.0" + }, + "mpmath-1.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "efddf758abceea210ced237bfa8021f5", + "name": "mpmath", + "sha256": "d94d2dc083b9ff7cd81c758ff3f711c5c0438b574d31e80f7a50aa7537962a7c", + "size": 792740, + "subdir": "linux-64", + "timestamp": 1607574102978, + "version": "1.1.0" + }, + "mpmath-1.2.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c915239c6d48f0b01ba1cac61a33a5fa", + "name": "mpmath", + "sha256": "90ee13cb0ca6fcbeeafa2cb102d8dbe18c5b998b0d103af76b4b1860489d9ec3", + "size": 787383, + "subdir": "linux-64", + "timestamp": 1640791702614, + "version": "1.2.1" + }, + "mpmath-1.2.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "75a7defd155e678f9953c813e59b888c", + "name": "mpmath", + "sha256": "764da5357a1a45075e1f8e7e2867953b3b2fe170e7ab150657d645fc6b65b07e", + "size": 1025797, + "subdir": "linux-64", + "timestamp": 1676841217311, + "version": "1.2.1" + }, + "mpmath-1.2.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "680dc7a8fc16789340cd8d12c989a2bf", + "name": "mpmath", + "sha256": "c547a6fee816cc912169f3ef3f6a3c4b22d7160e2aa00ca405c46147adc33d70", + "size": 795392, + "subdir": "linux-64", + "timestamp": 1616617265555, + "version": "1.2.1" + }, + "mpmath-1.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2d46ee4d7d43ea59667f53b9ef7b8e1a", + "name": "mpmath", + "sha256": "96fce343b745edfbb77dfeaf00d55b2fd4c997c17f456b99b45ed5296024b4eb", + "size": 793483, + "subdir": "linux-64", + "timestamp": 1616617267624, + "version": "1.2.1" + }, + "mpmath-1.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "631675cea091ff218b21b3a18378789d", + "name": "mpmath", + "sha256": "8e1290315dd4e45dfc737e0700183280bfb1ae9893cd3f045225c6d99cbb9683", + "size": 784741, + "subdir": "linux-64", + "timestamp": 1616617934782, + "version": "1.2.1" + }, + "mpmath-1.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e6d51011d941623fc1df795efb03dd1d", + "name": "mpmath", + "sha256": "5885fafd9f8ef95911156110252a627276567208690d4701b5932738c5e65fe3", + "size": 781783, + "subdir": "linux-64", + "timestamp": 1616616743372, + "version": "1.2.1" + }, + "msgpack-numpy-0.4.1-py27h8e01e4a_0.conda": { + "build": "py27h8e01e4a_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "85ea05a337ea0d5a1527b1fef327cea9", + "name": "msgpack-numpy", + "sha256": "06766f865e00ee05fe7f07068a2c415623ea66a37c9eb475c8cefea7ccd22c3e", + "size": 13213, + "subdir": "linux-64", + "timestamp": 1509290026098, + "version": "0.4.1" + }, + "msgpack-numpy-0.4.1-py35h45744f7_0.conda": { + "build": "py35h45744f7_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8cb5f50263e1adf5a67d1afa90d97eda", + "name": "msgpack-numpy", + "sha256": "5c7b4dfd6b8a84d9a086cb44f4b373ecbfe3a85b11a4b3d6db64477cc861482f", + "size": 13549, + "subdir": "linux-64", + "timestamp": 1509297596147, + "version": "0.4.1" + }, + "msgpack-numpy-0.4.1-py36hfef8c07_0.conda": { + "build": "py36hfef8c07_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1c97190912525b4d9276e9c84673ddd2", + "name": "msgpack-numpy", + "sha256": "b529e516d94bb1b870856d49b40860c38a4719a5a29e0b24456a0de51093dc2f", + "size": 13429, + "subdir": "linux-64", + "timestamp": 1509291483338, + "version": "0.4.1" + }, + "msgpack-numpy-0.4.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4d428619e6cfe9be6f4f171906d0e65a", + "name": "msgpack-numpy", + "sha256": "8f4feb6876aed297960fdb954c570bca675bafb20aeed24e5b78209fcb487b94", + "size": 14148, + "subdir": "linux-64", + "timestamp": 1520917137643, + "version": "0.4.3" + }, + "msgpack-numpy-0.4.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "74999186bf7d633ccacc20c07caa9797", + "name": "msgpack-numpy", + "sha256": "c9cce173728a3b64af78c21cacd303c72b45bf2ac07091946c007165e406888d", + "size": 14651, + "subdir": "linux-64", + "timestamp": 1520917156553, + "version": "0.4.3" + }, + "msgpack-numpy-0.4.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bc3d49d88fb50687e54111ba2a30a1a4", + "name": "msgpack-numpy", + "sha256": "b4aef5a29db78e064deac2211309b3032c958ed5b0749119ec5d534d93461b4b", + "size": 14620, + "subdir": "linux-64", + "timestamp": 1520917124189, + "version": "0.4.3" + }, + "msgpack-numpy-0.4.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f2409e292eb6fb541942a8972df77172", + "name": "msgpack-numpy", + "sha256": "ea5389ddf120b2ebb4fa7fa6d935d2b320b5599d159126163d5459f8a9fce0d1", + "size": 14434, + "subdir": "linux-64", + "timestamp": 1530899304884, + "version": "0.4.3" + }, + "msgpack-numpy-0.4.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "35da1424f26d4cf06a6b01747570c7d2", + "name": "msgpack-numpy", + "sha256": "b803d88148e2879e60ae5bf84f25d39240bf1d5a609f079c48cfa30775855111", + "size": 14133, + "subdir": "linux-64", + "timestamp": 1535508373931, + "version": "0.4.3.1" + }, + "msgpack-numpy-0.4.3.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fe3c847092ee7739a8be80dd108d1e57", + "name": "msgpack-numpy", + "sha256": "e0217a58bf55488fdf002e0c0de6e9dca77d8deacde75da2b85f607a3b1b7311", + "size": 14594, + "subdir": "linux-64", + "timestamp": 1535508399871, + "version": "0.4.3.1" + }, + "msgpack-numpy-0.4.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ae1051125ec9a172478f0c4888fce909", + "name": "msgpack-numpy", + "sha256": "9a4acaeea6648588f9589e7add35882e7b0b2fd34fef1d9306560c28c335f14e", + "size": 14460, + "subdir": "linux-64", + "timestamp": 1535508311327, + "version": "0.4.3.1" + }, + "msgpack-numpy-0.4.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5e1c4c625f24f0b187aabce9f6d6927b", + "name": "msgpack-numpy", + "sha256": "1e56a02f989fc0f25d675df328a0f88da7524a578f68f4a99af9125ccf1aa5bd", + "size": 14475, + "subdir": "linux-64", + "timestamp": 1535508390005, + "version": "0.4.3.1" + }, + "msgpack-numpy-0.4.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9d5cb8e69a520755e497e93f4f50823b", + "name": "msgpack-numpy", + "sha256": "4736c35d5a3fb82e8c7e179735aab8325c4799ac599eedb71dc1e36e72ddaa79", + "size": 14267, + "subdir": "linux-64", + "timestamp": 1538360733663, + "version": "0.4.3.2" + }, + "msgpack-numpy-0.4.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a91b78271f1d0fe54db82e122f5448f9", + "name": "msgpack-numpy", + "sha256": "c1cb0db9e51b40dec46ec215741536b2724bf3315dfb374a271074690da9c875", + "size": 14767, + "subdir": "linux-64", + "timestamp": 1538360751241, + "version": "0.4.3.2" + }, + "msgpack-numpy-0.4.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.3.0", + "numpy >=1.9.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "76d866c73f2b131a653ed92fafea7802", + "name": "msgpack-numpy", + "sha256": "1d8fbcd69da886d0b39a863ae7ce0dc45ca0aae424f013f6313e0d1c1e502b65", + "size": 14632, + "subdir": "linux-64", + "timestamp": 1538360674987, + "version": "0.4.3.2" + }, + "msgpack-numpy-0.4.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "numpy >=1.9.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b1ad1571f6c78e39760a52145ec55c01", + "name": "msgpack-numpy", + "sha256": "be5455f9f38541bdabe2c7a2904b4a2533b19b60db93861f5cbea5670a031086", + "size": 15838, + "subdir": "linux-64", + "timestamp": 1539720499137, + "version": "0.4.4.1" + }, + "msgpack-numpy-0.4.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "numpy >=1.9.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "936191ff6540ba7e5d0a15b54c82bcf5", + "name": "msgpack-numpy", + "sha256": "2f6027cdcd1fdeeb57fbb34d0f39ed6a92bc226b812a8279fcfd56dbffd8fc73", + "size": 16201, + "subdir": "linux-64", + "timestamp": 1539720510273, + "version": "0.4.4.1" + }, + "msgpack-numpy-0.4.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "numpy >=1.9.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6f0966d841bbf69b085ac346f741eadf", + "name": "msgpack-numpy", + "sha256": "fd9f60cf007ef2181c5bb207c0fe0bb577ff0d198654fa731c1802121cf83fcc", + "size": 16312, + "subdir": "linux-64", + "timestamp": 1539720524500, + "version": "0.4.4.1" + }, + "msgpack-numpy-0.4.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "numpy >=1.9.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f6b41336096593f1dde4d87a74743b15", + "name": "msgpack-numpy", + "sha256": "e12527241540447cfc6178fac16069ec26f592dd7df70aad6b3e0f5f3698f220", + "size": 15983, + "subdir": "linux-64", + "timestamp": 1542082685180, + "version": "0.4.4.2" + }, + "msgpack-numpy-0.4.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "numpy >=1.9.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8e106e50e33fcd9b0377cd4d750a2458", + "name": "msgpack-numpy", + "sha256": "c1270c55672faa3e051ed285f75a771bb09cfe2c09b0b352e85aa98b4c463ef0", + "size": 16393, + "subdir": "linux-64", + "timestamp": 1542082750326, + "version": "0.4.4.2" + }, + "msgpack-numpy-0.4.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "msgpack-python >=0.5.2", + "numpy >=1.9.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "792e409aa435da7923d9f4788b0b857d", + "name": "msgpack-numpy", + "sha256": "7bfc28503faaa0b17bc142581e66507c1d802a3b431c814be3d9eea6eff28231", + "size": 16400, + "subdir": "linux-64", + "timestamp": 1542082696170, + "version": "0.4.4.2" + }, + "msgpack-python-0.4.8-py27hc2fa789_0.conda": { + "build": "py27hc2fa789_0", + "build_number": 0, + "depends": [ + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1640fde5d9d4f10a43f4f03b2ab0368f", + "name": "msgpack-python", + "sha256": "379b12a3d18543ba6f3373657041152777d0303736628e8a78919b37e12535a3", + "size": 84379, + "subdir": "linux-64", + "timestamp": 1505733156824, + "version": "0.4.8" + }, + "msgpack-python-0.4.8-py35h783f4c8_0.conda": { + "build": "py35h783f4c8_0", + "build_number": 0, + "depends": [ + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b27ebd4cb07bff2a78cafa9c06044976", + "name": "msgpack-python", + "sha256": "23bb79569c57adbd531823b36fc75cdc1739a833d9008a1d3461338eb1063721", + "size": 85174, + "subdir": "linux-64", + "timestamp": 1505733176278, + "version": "0.4.8" + }, + "msgpack-python-0.4.8-py36hec4c5d1_0.conda": { + "build": "py36hec4c5d1_0", + "build_number": 0, + "depends": [ + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0d20b04aafb2c2c5ba2488f57ec22754", + "name": "msgpack-python", + "sha256": "58a01f397cfdb2b1766e1638aa82b0fbec51022c94111628c4870ac598661bcb", + "size": 84836, + "subdir": "linux-64", + "timestamp": 1505733195838, + "version": "0.4.8" + }, + "msgpack-python-0.5.1-py27h6bb024c_0.conda": { + "build": "py27h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f5091af511f6e2d2e7c01206f259fe87", + "name": "msgpack-python", + "sha256": "bbd4237b1c5dc95a0820679f2d4682f66c5db53f6ce11fc84f02cad0af633e0a", + "size": 90917, + "subdir": "linux-64", + "timestamp": 1515706352468, + "version": "0.5.1" + }, + "msgpack-python-0.5.1-py35h6bb024c_0.conda": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8ec2c5ef01b031d3bb5cc4563d81d3ba", + "name": "msgpack-python", + "sha256": "d1f843cfc76bce1d09e1f44d4a18dbc2cf0957ec9b3667e78392e74bcb32d28d", + "size": 92284, + "subdir": "linux-64", + "timestamp": 1515706443260, + "version": "0.5.1" + }, + "msgpack-python-0.5.1-py36h6bb024c_0.conda": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ba9170b73a8eae2489b8e2a9a69d7f6c", + "name": "msgpack-python", + "sha256": "15f557148a0a1cc32c0d77fdded2f6b07b0d0acca8830d867eb1a861d6b77d29", + "size": 91630, + "subdir": "linux-64", + "timestamp": 1515706282349, + "version": "0.5.1" + }, + "msgpack-python-0.5.5-py27h6bb024c_0.conda": { + "build": "py27h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7133025b94b838a23e081583f6ae13ab", + "name": "msgpack-python", + "sha256": "66b0c78778f78ff7486bf18661d21f57d3cdf6ce44e606bfd7af29fece362ec0", + "size": 89151, + "subdir": "linux-64", + "timestamp": 1519498251816, + "version": "0.5.5" + }, + "msgpack-python-0.5.5-py35h6bb024c_0.conda": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "41e8a55394e08773a320ec90a9f8586f", + "name": "msgpack-python", + "sha256": "de0ed9a2e75aa1c4b9a1661921fbe5474200c95403043dfa983a6b141ff266b1", + "size": 88064, + "subdir": "linux-64", + "timestamp": 1519498265435, + "version": "0.5.5" + }, + "msgpack-python-0.5.5-py36h6bb024c_0.conda": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cbc6f66f2a176f5b8507f561f477d694", + "name": "msgpack-python", + "sha256": "56cfb4caec67d26cbc3d53009e9216329ac6f8b23dbc4497e2a7506463aaf9e2", + "size": 88478, + "subdir": "linux-64", + "timestamp": 1519498222940, + "version": "0.5.5" + }, + "msgpack-python-0.5.6-py27h6bb024c_0.conda": { + "build": "py27h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "11c02d63c7a91ee6d9c9c0e8693faac0", + "name": "msgpack-python", + "sha256": "83a482171652524ef7ed21a3f519c2c02f423b3152a4966e950ef56cb8028005", + "size": 91276, + "subdir": "linux-64", + "timestamp": 1522178447056, + "version": "0.5.6" + }, + "msgpack-python-0.5.6-py27h6bb024c_1.conda": { + "build": "py27h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4f945110f48bb0b901715fff8f3e9b8a", + "name": "msgpack-python", + "sha256": "6e987dec1becdb7e6f93af93c1782abfe6bb209f851680257e14c0884b9cfeed", + "size": 93856, + "subdir": "linux-64", + "timestamp": 1533325664443, + "version": "0.5.6" + }, + "msgpack-python-0.5.6-py35h6bb024c_0.conda": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "248abfb54e82c090784ed5678b15f11c", + "name": "msgpack-python", + "sha256": "c095985f23b734cb34c2313eaaa8e9767e5ec155bb6d4234cd0810cf962fb049", + "size": 89849, + "subdir": "linux-64", + "timestamp": 1522177916404, + "version": "0.5.6" + }, + "msgpack-python-0.5.6-py35h6bb024c_1.conda": { + "build": "py35h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "42010cead331eb0a799ab43d8b947467", + "name": "msgpack-python", + "sha256": "018a2faae4315c5960ccbe0682dfe6bf0e7d2b0c9372ae62cbed2e09f926a73b", + "size": 93614, + "subdir": "linux-64", + "timestamp": 1533325571761, + "version": "0.5.6" + }, + "msgpack-python-0.5.6-py36h6bb024c_0.conda": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c467989750129972a8f4d18c658aca27", + "name": "msgpack-python", + "sha256": "aa9b7d5de2c6bbe2eb2137abbc01be506891402e2ec5f2ad2c0ebff53b0db06f", + "size": 90502, + "subdir": "linux-64", + "timestamp": 1522178524060, + "version": "0.5.6" + }, + "msgpack-python-0.5.6-py36h6bb024c_1.conda": { + "build": "py36h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a3b6688bd9f3c0e595389638d760cd31", + "name": "msgpack-python", + "sha256": "680f6a4ae7a364212dd8d2c8b83a131c7414f9ea725bbcfc06a80fc9fe0c444a", + "size": 94208, + "subdir": "linux-64", + "timestamp": 1533325664619, + "version": "0.5.6" + }, + "msgpack-python-0.5.6-py37h6bb024c_0.conda": { + "build": "py37h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bacb61b8dd4674d1b817eef26489e5b5", + "name": "msgpack-python", + "sha256": "c71d14e72ca3bad49646297acefe85c3153ebe4b164e88d75a65fbbef7350bb8", + "size": 92308, + "subdir": "linux-64", + "timestamp": 1530741173147, + "version": "0.5.6" + }, + "msgpack-python-0.5.6-py37h6bb024c_1.conda": { + "build": "py37h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9295ddd4ea524549ec345ccabaed905a", + "name": "msgpack-python", + "sha256": "26fdfa35fb8e5b77f16647d0a8f2f1739f71b056fe2c1495c86c42e32801eddd", + "size": 93789, + "subdir": "linux-64", + "timestamp": 1533325681691, + "version": "0.5.6" + }, + "msgpack-python-0.6.1-py27hfd86e86_1.conda": { + "build": "py27hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7f0e572b7eb3a1dfcf4eeadf8b8d2a4e", + "name": "msgpack-python", + "sha256": "a84df228c9a4c06525090432a48e24ad7743da3055878c7b76e344e461c89672", + "size": 86981, + "subdir": "linux-64", + "timestamp": 1548949633866, + "version": "0.6.1" + }, + "msgpack-python-0.6.1-py36hfd86e86_1.conda": { + "build": "py36hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4eca802a7e72a1077efbc7c921046141", + "name": "msgpack-python", + "sha256": "46904a4a1f322b934926110f0bd8103f0b79024d14006c68d7c81555e3b220e0", + "size": 88956, + "subdir": "linux-64", + "timestamp": 1548949677204, + "version": "0.6.1" + }, + "msgpack-python-0.6.1-py37hfd86e86_1.conda": { + "build": "py37hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "134a7ee4647a189a55fc063755e0acc9", + "name": "msgpack-python", + "sha256": "1cca5a0483f93fc42a477ac3f7becbbf49efd691d4f0a3c169d2329e5601f724", + "size": 88711, + "subdir": "linux-64", + "timestamp": 1548949651835, + "version": "0.6.1" + }, + "msgpack-python-0.6.1-py38hfd86e86_1.conda": { + "build": "py38hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "846add44550a96922cb30312d69ec45b", + "name": "msgpack-python", + "sha256": "50b9b3f039f703ad38cae09214200ca47ad847bc4e1f2f3ccddcf55b157616a7", + "size": 88503, + "subdir": "linux-64", + "timestamp": 1573120517751, + "version": "0.6.1" + }, + "msgpack-python-1.0.0-py36hfd86e86_1.conda": { + "build": "py36hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "93d1476b3fe79af269a8467d03d5d101", + "name": "msgpack-python", + "sha256": "3986584ad9c87ee82e77718cf24773d50f69a325b46f61d31319dc1fe07429ce", + "size": 91675, + "subdir": "linux-64", + "timestamp": 1585078612416, + "version": "1.0.0" + }, + "msgpack-python-1.0.0-py37hfd86e86_1.conda": { + "build": "py37hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c456b7465b1789d954a024992691067d", + "name": "msgpack-python", + "sha256": "f15540a62f0a02934ae23e79b418db27ea2f45bbdcd757103984cd04af282306", + "size": 91587, + "subdir": "linux-64", + "timestamp": 1585078609625, + "version": "1.0.0" + }, + "msgpack-python-1.0.0-py38hfd86e86_1.conda": { + "build": "py38hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dac85c0c3ed61b999ab6dbb5b45b57a5", + "name": "msgpack-python", + "sha256": "bc88fa3e3194f5b01f7129f836de5b1b33621b53979f28176f4c0bf2de903480", + "size": 93609, + "subdir": "linux-64", + "timestamp": 1585078610812, + "version": "1.0.0" + }, + "msgpack-python-1.0.0-py39h7739ffd_1.conda": { + "build": "py39h7739ffd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8cda1255cddc562dda9e5eee03d7b29c", + "name": "msgpack-python", + "sha256": "d671212a36a2498451401190e7f57aa623e470546911377660935a9bdc511ad0", + "size": 93758, + "subdir": "linux-64", + "timestamp": 1607574252633, + "version": "1.0.0" + }, + "msgpack-python-1.0.1-py36hff7bd54_0.conda": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aefcea42a3bd961c780330296dd5d1cf", + "name": "msgpack-python", + "sha256": "a1514fd44ba5fdbc0bc93c3df95d79617d92db674318dcc2d495c362184f50b7", + "size": 82982, + "subdir": "linux-64", + "timestamp": 1607965601297, + "version": "1.0.1" + }, + "msgpack-python-1.0.1-py37hff7bd54_0.conda": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "62ddfcd4fc37477b28b1700fc792a962", + "name": "msgpack-python", + "sha256": "e4e9dfb68d989459a424582eb26d14d7004ebfe837e4315c688f1bd943e644b5", + "size": 83778, + "subdir": "linux-64", + "timestamp": 1607965861255, + "version": "1.0.1" + }, + "msgpack-python-1.0.1-py38hff7bd54_0.conda": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "270e8b3112e2efd58204b2911b198443", + "name": "msgpack-python", + "sha256": "3f0f5256217ef95c10c744fbb5cbd43afa7ca1add0728078c186d372a96a8b9f", + "size": 85557, + "subdir": "linux-64", + "timestamp": 1607965869446, + "version": "1.0.1" + }, + "msgpack-python-1.0.1-py39hff7bd54_0.conda": { + "build": "py39hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2e91bc1fb0face95d9501a823492476d", + "name": "msgpack-python", + "sha256": "5e9603bb5ba77f3fc6c53400450d158dfd3ee2a5b2fa33aa19bcbc807f8b61b5", + "size": 84956, + "subdir": "linux-64", + "timestamp": 1607965873378, + "version": "1.0.1" + }, + "msgpack-python-1.0.2-py310hd09550d_1.conda": { + "build": "py310hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7c188bf10ce0c4edf7ab1ecde11f1485", + "name": "msgpack-python", + "sha256": "d6dd1fd04259ab5483a8696519ef77c9a73694a42ff12184a4bcd0f4a005bc53", + "size": 222803, + "subdir": "linux-64", + "timestamp": 1640884278832, + "version": "1.0.2" + }, + "msgpack-python-1.0.2-py36hff7bd54_1.conda": { + "build": "py36hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bcf53d20fba5c86eb6e06e747a17a287", + "name": "msgpack-python", + "sha256": "fdeb2a120e033bcec057da38cafe6d7b8795b99ba871bc550d8bfc5206388abc", + "size": 84069, + "subdir": "linux-64", + "timestamp": 1612287225411, + "version": "1.0.2" + }, + "msgpack-python-1.0.2-py37hff7bd54_1.conda": { + "build": "py37hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d513d440b4808cf814dc65a9ac4da61b", + "name": "msgpack-python", + "sha256": "b15ade0c56f202f310a19cf05dc677d3a8062f9abc39442cbd9abae1406535b6", + "size": 83411, + "subdir": "linux-64", + "timestamp": 1612287221395, + "version": "1.0.2" + }, + "msgpack-python-1.0.2-py38hff7bd54_1.conda": { + "build": "py38hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "258bacbc29874305ea2593c4e046127a", + "name": "msgpack-python", + "sha256": "679ae1b5e41dd595aae39913a03c90d1ecec8847edf68ef48cf74f9a9bef43f2", + "size": 85008, + "subdir": "linux-64", + "timestamp": 1612287200369, + "version": "1.0.2" + }, + "msgpack-python-1.0.2-py39hff7bd54_1.conda": { + "build": "py39hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f9c0f680736db92779ea3e6196a705d1", + "name": "msgpack-python", + "sha256": "8f381c5e1063c0bb91c617c1a864cecee8d5fde729ff78620541a0f0d698c515", + "size": 86019, + "subdir": "linux-64", + "timestamp": 1612287214639, + "version": "1.0.2" + }, + "msgpack-python-1.0.3-py310hd09550d_0.conda": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "29f619b42b5cc825ef32765c16b28b7e", + "name": "msgpack-python", + "sha256": "dd79dbdeabd5fab5034003f70bd4bccdc44f10d705b14a9afd8b320fd7755a56", + "size": 223171, + "subdir": "linux-64", + "timestamp": 1652362755770, + "version": "1.0.3" + }, + "msgpack-python-1.0.3-py311hdb19cb5_0.conda": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aa6ec1328c13c310f8c6cd75fc008f98", + "name": "msgpack-python", + "sha256": "789415ea412afdc0493caaf0ee8538c3dbea0cece26c51fe6872acd5365f52e8", + "size": 36694, + "subdir": "linux-64", + "timestamp": 1676823053826, + "version": "1.0.3" + }, + "msgpack-python-1.0.3-py37hd09550d_0.conda": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "90a329102aea88e2fedcd49568d6129a", + "name": "msgpack-python", + "sha256": "beb2aae309e8ed0e14404a88a97392d371afacbfe3ccb7d9e47c0f718352c4ce", + "size": 83461, + "subdir": "linux-64", + "timestamp": 1652362711863, + "version": "1.0.3" + }, + "msgpack-python-1.0.3-py38hd09550d_0.conda": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c64b1bcb40a89d090ea5cf08360b4f57", + "name": "msgpack-python", + "sha256": "7c80723c9fd7e19365789c2b2ff0d534ac7376dd9a602ba1a232046f9ed2f285", + "size": 85378, + "subdir": "linux-64", + "timestamp": 1652362785051, + "version": "1.0.3" + }, + "msgpack-python-1.0.3-py39hd09550d_0.conda": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "98c77043496513b7c7d7acb3fcc1a394", + "name": "msgpack-python", + "sha256": "43cdbc0a8598e5da2cce83e291de788661b6ad69d14a1e43379803808ed02da5", + "size": 85323, + "subdir": "linux-64", + "timestamp": 1652362815706, + "version": "1.0.3" + }, + "msitools-0.100-h81b3da8_0.conda": { + "build": "h81b3da8_0", + "build_number": 0, + "depends": [ + "gcab >=1.4,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "libgsf >=1.14,<1.15", + "libgsf >=1.14.50,<1.15.0a0", + "libuuid >=1.41.5,<2.0a0", + "libxml2 >=2.9.14,<2.10.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "1abb31741a35617057cd41ab6365ee01", + "name": "msitools", + "sha256": "1c009b9c57d7c9a9110c0a26936f2bee9ffa415ab804e9a5c70791398bdc6c92", + "size": 777004, + "subdir": "linux-64", + "timestamp": 1668170030034, + "version": "0.100" + }, + "msitools-0.100-hb6d4d65_1.conda": { + "build": "hb6d4d65_1", + "build_number": 1, + "depends": [ + "gcab >=1.4,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "libgsf >=1.14,<1.15", + "libgsf >=1.14.50,<1.15.0a0", + "libuuid >=1.41.5,<2.0a0", + "libxml2 >=2.10.3,<2.11.0a0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "1d4c1dc2d74323c41d64725ffdf2e402", + "name": "msitools", + "sha256": "7b6142fc7ef1c88569bb6f3e009d1f3a745c5d0958b56c7d1aa65963db34c160", + "size": 780630, + "subdir": "linux-64", + "timestamp": 1680018604515, + "version": "0.100" + }, + "msvc-headers-libs-14.15.26706-hc402f9b_0.conda": { + "build": "hc402f9b_0", + "build_number": 0, + "depends": [ + "curl", + "unzip" + ], + "license": "LicenseRef-MSVC_HEADERS", + "license_family": "Proprietary", + "md5": "36912abd78d498db8ed2d497becb5426", + "name": "msvc-headers-libs", + "sha256": "ac934cebb3bab9da87e1ae84fa8b3de6650c8c94db2141d0ba346ff02068754e", + "size": 29823, + "subdir": "linux-64", + "timestamp": 1668352693102, + "version": "14.15.26706" + }, + "mtq-0.7.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pymongo >=2.8", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pytz >=2013b" + ], + "license": "BSD", + "md5": "f5d227985af6fb2079f269c743bfe9b8", + "name": "mtq", + "sha256": "83e063f6c7167fd538f9954c485ca18c3bbf68ca23cc2099588f689849578d98", + "size": 54929, + "subdir": "linux-64", + "timestamp": 1530900491675, + "version": "0.7.1" + }, + "mtq-0.7.1-py27h6c7fcc8_0.conda": { + "build": "py27h6c7fcc8_0", + "build_number": 0, + "depends": [ + "pymongo >=2.8", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "pytz >=2013b" + ], + "license": "BSD", + "md5": "b2eabf437bd34e24022a6cd22d2a0d93", + "name": "mtq", + "sha256": "a63b5c8d6fe378caf4bd2b4a88916dae5e3c86d6f12fa7228ccf8eff724915e0", + "size": 54743, + "subdir": "linux-64", + "timestamp": 1509085459929, + "version": "0.7.1" + }, + "multidict-3.2.0-py35h7df3ad6_0.conda": { + "build": "py35h7df3ad6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0f5c47aa8b1e774277c437da4b7656ce", + "name": "multidict", + "sha256": "2356631c94920f89261eef5df4efe0f0354e1c37cc28133d68cdb375ef77fca9", + "size": 162791, + "subdir": "linux-64", + "timestamp": 1508004881941, + "version": "3.2.0" + }, + "multidict-3.2.0-py36h97a4c74_0.conda": { + "build": "py36h97a4c74_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9a103e94345227252f1391580273b2e1", + "name": "multidict", + "sha256": "eb4d1851b203fe934b67e67c9599920c6519705053224021012ec781ce4416c8", + "size": 163349, + "subdir": "linux-64", + "timestamp": 1508004883674, + "version": "3.2.0" + }, + "multidict-3.3.2-py35he92878e_0.conda": { + "build": "py35he92878e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fd4a4533dce99e153f6b47f3ef052751", + "name": "multidict", + "sha256": "9a3e1b08bf40b6e619be9145be220b5cbea1f934e1f5c5bd2c2a3b595d1ab6ba", + "size": 172005, + "subdir": "linux-64", + "timestamp": 1511809723915, + "version": "3.3.2" + }, + "multidict-3.3.2-py36h2e68417_0.conda": { + "build": "py36h2e68417_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cd63505ed82048473760ccd6cae45416", + "name": "multidict", + "sha256": "5e81da881dfe4ea523c39b25b65412bbcf94e2cd2623497b2d48f0a4daec4aa6", + "size": 173239, + "subdir": "linux-64", + "timestamp": 1511809729386, + "version": "3.3.2" + }, + "multidict-4.1.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "94d305c57e5d14697c92feb5e647068f", + "name": "multidict", + "sha256": "cc924af7a64596eddd98c07f0189ac7038a2944634920a826044bd7093c53e2c", + "size": 179964, + "subdir": "linux-64", + "timestamp": 1519066407463, + "version": "4.1.0" + }, + "multidict-4.1.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "aabc4561177c537be2221325a6fd28e6", + "name": "multidict", + "sha256": "047fe7386f78ea1cc5be929017e7a9c9a5fde968cfd183a28d86c20423fb88ea", + "size": 181230, + "subdir": "linux-64", + "timestamp": 1519066412763, + "version": "4.1.0" + }, + "multidict-4.2.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "50cd765ea812b5030dedc42713697dda", + "name": "multidict", + "sha256": "9b414ee404d3f419d6b25b97f81e96653a68d2c83371fb38dea467545baa7c1c", + "size": 180377, + "subdir": "linux-64", + "timestamp": 1524002303268, + "version": "4.2.0" + }, + "multidict-4.2.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4693d11b9a3399445ac3d84f8d37a28d", + "name": "multidict", + "sha256": "da25117609c25fd343cbaf638a76974e47f6b16c7f3de77dc30f3b439c82cf8f", + "size": 181999, + "subdir": "linux-64", + "timestamp": 1524002670050, + "version": "4.2.0" + }, + "multidict-4.3.1-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a2f53d77283a56b5beceab52c6281f90", + "name": "multidict", + "sha256": "2b5372880b386cc83540bafdf89d54d0d1af80eb602dec9fbcb55dab2cc49bfb", + "size": 180159, + "subdir": "linux-64", + "timestamp": 1526921459443, + "version": "4.3.1" + }, + "multidict-4.3.1-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cb0b8ff68295ac113d36a97a596e6dce", + "name": "multidict", + "sha256": "a413e1d8d02009acc21fe927f0a9bdaea07d83496ff142e292e903e29f7b5d8e", + "size": 181779, + "subdir": "linux-64", + "timestamp": 1526921700513, + "version": "4.3.1" + }, + "multidict-4.3.1-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "796087b8a0acc9286a27fbe300b220d6", + "name": "multidict", + "sha256": "f828c55f085429d042854f82f3f1660c6254386490df4877402ea1a62d39103a", + "size": 180995, + "subdir": "linux-64", + "timestamp": 1530736482353, + "version": "4.3.1" + }, + "multidict-4.4.0-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1b1e399db077af531096f3b74de378a1", + "name": "multidict", + "sha256": "cdc9de928eafce7668e87c1183e51f82c9c52c4e82063457c979d8aceb504e28", + "size": 162004, + "subdir": "linux-64", + "timestamp": 1536103771805, + "version": "4.4.0" + }, + "multidict-4.4.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d11869d8b801355b8d1414d7f1f18bc9", + "name": "multidict", + "sha256": "e09f33f5aa307c2d727428e9639ffa4be440f5f0745a9a53e052ed0d289d1f64", + "size": 162077, + "subdir": "linux-64", + "timestamp": 1536103715783, + "version": "4.4.0" + }, + "multidict-4.4.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "15b78128e2bf540932f3558be450a5d1", + "name": "multidict", + "sha256": "bf06fe8ea2bd58caaabd089b09cc75defdb814069330d474a54e9606c5c52818", + "size": 161757, + "subdir": "linux-64", + "timestamp": 1536103745626, + "version": "4.4.0" + }, + "multidict-4.4.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1893c1c2c38be15156bf9434431f5d26", + "name": "multidict", + "sha256": "c9877c0021c0ef03fab2d816134e5996b7c92a3677d402c7c7afe520d378aea4", + "size": 161388, + "subdir": "linux-64", + "timestamp": 1539643876712, + "version": "4.4.2" + }, + "multidict-4.4.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0cb6236f9fb715ff41f8afc4a2254aa3", + "name": "multidict", + "sha256": "ca4619cdcf0bd4952fe7e6523a72fa6e25cd6100d73bb7f8d0160da300b4c37f", + "size": 160415, + "subdir": "linux-64", + "timestamp": 1539643878330, + "version": "4.4.2" + }, + "multidict-4.5.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7cca47507842d6ba6122d3889ac71347", + "name": "multidict", + "sha256": "0ae9b1511e6589c7af4eab667d8d9c28902ba5eec342f07c82c30d0fab2439c2", + "size": 140336, + "subdir": "linux-64", + "timestamp": 1543598432854, + "version": "4.5.2" + }, + "multidict-4.5.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "02be42b5942ea0ca1f5534e6dac07020", + "name": "multidict", + "sha256": "b93ed5224a85aec0d698cdd695f06d328c5db0b8e9b6ef7fd48a696ff757cb6c", + "size": 140259, + "subdir": "linux-64", + "timestamp": 1543598392698, + "version": "4.5.2" + }, + "multidict-4.5.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "53785c7d3029e57c894563583ccd902c", + "name": "multidict", + "sha256": "74d600f8b63ae575e23e360e9c30f78df7649ac5d9f53bfd0ce7df4a943a898d", + "size": 141044, + "subdir": "linux-64", + "timestamp": 1573120597392, + "version": "4.5.2" + }, + "multidict-4.7.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e0eaae17ddda042cbe2d830ab92ff91d", + "name": "multidict", + "sha256": "4ede224e01035f02e15aeb69108df5175911544c765c6e38ce9b42db4ddd94d3", + "size": 69947, + "subdir": "linux-64", + "timestamp": 1579790758065, + "version": "4.7.3" + }, + "multidict-4.7.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4c5b1ad6fedbd4e9b6db872ad009ecc6", + "name": "multidict", + "sha256": "6b9a05269f151be134c484bdb7e1d263ef36a5dd2486866b1cf799f98dada8de", + "size": 69119, + "subdir": "linux-64", + "timestamp": 1579790739880, + "version": "4.7.3" + }, + "multidict-4.7.3-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f3def4490477dd40bb4072d9757a0abc", + "name": "multidict", + "sha256": "3775510a302860850667b34cd98f1ea3bd213a21ff641d49c9f0bf7c977da780", + "size": 72048, + "subdir": "linux-64", + "timestamp": 1579790754522, + "version": "4.7.3" + }, + "multidict-4.7.5-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "855860399c4888bce06b7d21232112d0", + "name": "multidict", + "sha256": "ab1fc93b9bc2b02a562c0bd7a5849b4f2d40f765c9bf3859a7d106edeea3e396", + "size": 67863, + "subdir": "linux-64", + "timestamp": 1600445107276, + "version": "4.7.5" + }, + "multidict-4.7.5-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8bb81d85af7d328d9a33b066ed29f935", + "name": "multidict", + "sha256": "00cf20649c9335d417bc7fbc0bae1d5caf58e5850fbf4b78485e0b675c2bcfb3", + "size": 66708, + "subdir": "linux-64", + "timestamp": 1600445117264, + "version": "4.7.5" + }, + "multidict-4.7.5-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "31e7efbb4a827e30d29e9550d403e220", + "name": "multidict", + "sha256": "fe685a3c60184fc5ed503602c4725614f88c7ac003ebd3e723310af0568dd469", + "size": 68953, + "subdir": "linux-64", + "timestamp": 1600445083986, + "version": "4.7.5" + }, + "multidict-4.7.6-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4133e84ac932f7b5883e1d9dda57f6a9", + "name": "multidict", + "sha256": "b2b24c39ea9ec4e38bc4aeabbc549c6be91edfb09864d3f95303ceb0eb0a3f37", + "size": 67522, + "subdir": "linux-64", + "timestamp": 1600456438434, + "version": "4.7.6" + }, + "multidict-4.7.6-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d504142fcf2f94ea62b3d3ace2e015fe", + "name": "multidict", + "sha256": "220f741c6590321603fddeed4c3231695ba4224a6a870bb2cfabcd3dbc246530", + "size": 66895, + "subdir": "linux-64", + "timestamp": 1600456437105, + "version": "4.7.6" + }, + "multidict-4.7.6-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "077963e3d3af84462549136646b48094", + "name": "multidict", + "sha256": "5e96a4c9cc72f497ed957ea06e87306de7543bc6bfb8c5c636176220ee0359cc", + "size": 68638, + "subdir": "linux-64", + "timestamp": 1600456441080, + "version": "4.7.6" + }, + "multidict-5.0.0-py36h27cfd23_2.conda": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "da5fdd20ea107f4bd3e382d2ab0c4825", + "name": "multidict", + "sha256": "6db46dd1a399b5bd6fcc05b0b1d222a630aad619556ae506fd12353ac1215fd1", + "size": 67990, + "subdir": "linux-64", + "timestamp": 1605111832932, + "version": "5.0.0" + }, + "multidict-5.0.0-py37h27cfd23_2.conda": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6f956dcbcc91c4c8514bfe4e1dbc1565", + "name": "multidict", + "sha256": "4afbbc8fd1993b494489f81c67d3e41e44050b98b0aadeccc75668321045271c", + "size": 68027, + "subdir": "linux-64", + "timestamp": 1605111868246, + "version": "5.0.0" + }, + "multidict-5.0.0-py38h27cfd23_2.conda": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0e7333cfc541e1403d7ecfa96eb04122", + "name": "multidict", + "sha256": "8324c142726e9464603912401073148ed5b91cda4ee79b69a959a644ae7e66fc", + "size": 69685, + "subdir": "linux-64", + "timestamp": 1605111893486, + "version": "5.0.0" + }, + "multidict-5.0.2-py36h27cfd23_2.conda": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2eec3f04a9ef62b78030fa5504f27fc1", + "name": "multidict", + "sha256": "9d2dff7734e8de16a3de1cceb877d05646a1dd552de178dbc2ce27f7a6b7c1e3", + "size": 67486, + "subdir": "linux-64", + "timestamp": 1606153631299, + "version": "5.0.2" + }, + "multidict-5.0.2-py37h27cfd23_2.conda": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f7f79314143323c0b83a0aa4b46c5156", + "name": "multidict", + "sha256": "09d3293b168c7f1aca44308b6f4f560e5dedaf60a380ea89a8e0a713951e1707", + "size": 68094, + "subdir": "linux-64", + "timestamp": 1606153666172, + "version": "5.0.2" + }, + "multidict-5.0.2-py38h27cfd23_2.conda": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5189830644edbf1931691a21eb10ac5e", + "name": "multidict", + "sha256": "0b3e63889356ad8ab444ab8cecb6c16593e1140a3aa1010964eb420bb2547087", + "size": 68868, + "subdir": "linux-64", + "timestamp": 1606153651519, + "version": "5.0.2" + }, + "multidict-5.0.2-py39h27cfd23_2.conda": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f75f2352c7ab4c9aacc5cc4d6eba932e", + "name": "multidict", + "sha256": "5f95ac8d31985eb42508a22d54292ea6c9d963462a1078a7b571842a3d8fbb7d", + "size": 68589, + "subdir": "linux-64", + "timestamp": 1606153634383, + "version": "5.0.2" + }, + "multidict-5.1.0-py310h7f8727e_2.conda": { + "build": "py310h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a62e960139ff8a47096a290888bc5605", + "name": "multidict", + "sha256": "ca9a158cf0a8c6bf8b0f02e01faddabfa4562380021d481ba66bd22b70c35c72", + "size": 151458, + "subdir": "linux-64", + "timestamp": 1640791755611, + "version": "5.1.0" + }, + "multidict-5.1.0-py36h27cfd23_2.conda": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6679c7a1a3c1cb52b0384ceb1e3e9b0e", + "name": "multidict", + "sha256": "2197887bc5580f59bb988403694cc89848ee650edf7a6b5ed2109c854e4467aa", + "size": 67161, + "subdir": "linux-64", + "timestamp": 1607367811823, + "version": "5.1.0" + }, + "multidict-5.1.0-py37h27cfd23_2.conda": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "526f42105dd750bf887f0d4f1c535542", + "name": "multidict", + "sha256": "c8caa5b329d24fda73470a266cc48f69d05114737ef003ef6ac5d9c1ad2f2fdf", + "size": 67792, + "subdir": "linux-64", + "timestamp": 1607367825144, + "version": "5.1.0" + }, + "multidict-5.1.0-py38h27cfd23_2.conda": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e0e30a75fb3b92e245244445bbeccbeb", + "name": "multidict", + "sha256": "21c9af84aa051afb37394f2ef47be13a048882ae1e55e81c9f1d3f3aa9cf3f90", + "size": 69568, + "subdir": "linux-64", + "timestamp": 1607367800165, + "version": "5.1.0" + }, + "multidict-5.1.0-py39h27cfd23_2.conda": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6786282788cd38463eaedd23ce1f056f", + "name": "multidict", + "sha256": "53156712d4d8b20da4650d2a5e33f24f1f50535048da123fd0319f40e193553d", + "size": 70189, + "subdir": "linux-64", + "timestamp": 1607367819794, + "version": "5.1.0" + }, + "multidict-5.2.0-py310h5eee18b_3.conda": { + "build": "py310h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f7ad5e6a3fb5a0a09c723d4114a6cd5a", + "name": "multidict", + "sha256": "4b8b6d57f30ea33656ea762e08e72e0656eed4783643a657022f88160b7075d4", + "size": 126977, + "subdir": "linux-64", + "timestamp": 1662369413566, + "version": "5.2.0" + }, + "multidict-5.2.0-py37h5eee18b_3.conda": { + "build": "py37h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "88e03c29eafacc62cc6239f5c8543571", + "name": "multidict", + "sha256": "d7e72256dcc8384deaac393278547678c46b61f4becd63e76c50ebd9eda7cb81", + "size": 60883, + "subdir": "linux-64", + "timestamp": 1662369482239, + "version": "5.2.0" + }, + "multidict-5.2.0-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cc462a37fd1b2526f23a584de58475ea", + "name": "multidict", + "sha256": "2fa53fefebb875ccaca4602ceb49fa63bd93f54b8b79e51833ece123f892e077", + "size": 64742, + "subdir": "linux-64", + "timestamp": 1640703823096, + "version": "5.2.0" + }, + "multidict-5.2.0-py37h7f8727e_2.conda": { + "build": "py37h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "beaade720a88cd17a7990f8909bb45e8", + "name": "multidict", + "sha256": "da16627bab22c572d653b526f010409d45c6fbebb7e7e65e4b7abfd4c0c42d27", + "size": 63761, + "subdir": "linux-64", + "timestamp": 1640703795978, + "version": "5.2.0" + }, + "multidict-5.2.0-py38h5eee18b_3.conda": { + "build": "py38h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cc24ff0e4ebd9cb4515b694788ec8469", + "name": "multidict", + "sha256": "21e0a84c2407c048a198bc92c2e7fc7b6d9f76f13774b5e2d7342eab88d51df5", + "size": 62648, + "subdir": "linux-64", + "timestamp": 1662369447628, + "version": "5.2.0" + }, + "multidict-5.2.0-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0412383b440d243103dce00fd436c283", + "name": "multidict", + "sha256": "aeb14b74a828a273ddcbb08e805d6baaf48786d066cd1f6e8d2151a63b8762fb", + "size": 66852, + "subdir": "linux-64", + "timestamp": 1640703795029, + "version": "5.2.0" + }, + "multidict-5.2.0-py38h7f8727e_2.conda": { + "build": "py38h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fab3ee3d09fc5d60dc318935763ee7d8", + "name": "multidict", + "sha256": "c6169e9c0107fca3d805becf52e54f4b36d6a9c2700654285b2e6999b03df380", + "size": 65748, + "subdir": "linux-64", + "timestamp": 1640703854037, + "version": "5.2.0" + }, + "multidict-5.2.0-py39h5eee18b_3.conda": { + "build": "py39h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7cc8647b3fbdabfdd7b7eba35b2bc37f", + "name": "multidict", + "sha256": "75893bd88f719dbd72316a73d95b7adad3b4616b12b1a68b978524ae18cf18c6", + "size": 62425, + "subdir": "linux-64", + "timestamp": 1662369517547, + "version": "5.2.0" + }, + "multidict-5.2.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ab4f78e15808135fae148f03ffb08750", + "name": "multidict", + "sha256": "c0bee099e5cee3df34907a06fd2c8397989aec91a2c34b831ecd78efab772feb", + "size": 66838, + "subdir": "linux-64", + "timestamp": 1640703854081, + "version": "5.2.0" + }, + "multidict-5.2.0-py39h7f8727e_2.conda": { + "build": "py39h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "beb2b4bd0a718493c52e438af1689dd7", + "name": "multidict", + "sha256": "6c487b2e5de407b5ad289bca82729e1b9078d2b28c116ef7d1f4b284057b9f19", + "size": 65678, + "subdir": "linux-64", + "timestamp": 1640703827445, + "version": "5.2.0" + }, + "multidict-6.0.2-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c81117de7ad41406d9c6d577ec431566", + "name": "multidict", + "sha256": "2415ebc156ff2ad50392b3097affca8b481cf0fba832c6287adb286d2b4e0d3d", + "size": 50442, + "subdir": "linux-64", + "timestamp": 1665674276559, + "version": "6.0.2" + }, + "multidict-6.0.2-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8097222e6cd05440d70500d4aed2bc29", + "name": "multidict", + "sha256": "a8e7da4421053f6f29e0c1a9430da9d3acb51e2bf9a709d066afd6475c2d374b", + "size": 55109, + "subdir": "linux-64", + "timestamp": 1676825331682, + "version": "6.0.2" + }, + "multidict-6.0.2-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cf38a2848044d2da497d003ad88b8641", + "name": "multidict", + "sha256": "921e9325ee43b38c251c0a208871247cd4a6581fcd90ae88e2d925802c5188c0", + "size": 48190, + "subdir": "linux-64", + "timestamp": 1665674372233, + "version": "6.0.2" + }, + "multidict-6.0.2-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "42201f930705df7c288c5a862b3fc84c", + "name": "multidict", + "sha256": "a8febbb0999ab9d7fd9e55c4ae00b0086ad8d9af6a71614b9263b350caf74531", + "size": 50432, + "subdir": "linux-64", + "timestamp": 1665674308223, + "version": "6.0.2" + }, + "multidict-6.0.2-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b1f4043f7e1d5974f58d2fdb88f19b01", + "name": "multidict", + "sha256": "ed4ee04acea93a606e43a5889e6fdba2ac4d93be198f6dfb641b97d402fbb1a3", + "size": 50144, + "subdir": "linux-64", + "timestamp": 1665674339367, + "version": "6.0.2" + }, + "multipledispatch-0.4.9-py27h9b5f95a_0.conda": { + "build": "py27h9b5f95a_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1b349a6be8c5e1ee26c7c1acda24bfb7", + "name": "multipledispatch", + "sha256": "da31b465485fa99e5d92b8db9fa424dde0820559bc5d78d48495c49daa12b638", + "size": 15624, + "subdir": "linux-64", + "timestamp": 1505739911465, + "version": "0.4.9" + }, + "multipledispatch-0.4.9-py35h2ff591a_0.conda": { + "build": "py35h2ff591a_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4b9a6b45241da6b17d099299dd37e52b", + "name": "multipledispatch", + "sha256": "f08b58125e9e49a3cee9739c2cb9c96209b48a25ed617a315ccb808711ee6dbf", + "size": 16184, + "subdir": "linux-64", + "timestamp": 1505739923352, + "version": "0.4.9" + }, + "multipledispatch-0.4.9-py36h41da3fb_0.conda": { + "build": "py36h41da3fb_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "18a14b1c5f9b1c3b104525af2a0af8d8", + "name": "multipledispatch", + "sha256": "6e479331e1bb23b7eb7d8c75b6764a13439d561f3be7f1a359b4713c68a1351e", + "size": 15922, + "subdir": "linux-64", + "timestamp": 1505739935395, + "version": "0.4.9" + }, + "multipledispatch-0.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4314d108f0c3f14d2b15fee01cde46f6", + "name": "multipledispatch", + "sha256": "0b6857c01c7277e08c0c110932299046d8ecd7a3b268a3a075a5ab32cc92b278", + "size": 18127, + "subdir": "linux-64", + "timestamp": 1520522049366, + "version": "0.5.0" + }, + "multipledispatch-0.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "11911457d87c831bac827556e43f4e32", + "name": "multipledispatch", + "sha256": "ff29dfe0abd794b6e9a83fc421e78e855f7d5b8ff819ee60cfc0f8469767308a", + "size": 18707, + "subdir": "linux-64", + "timestamp": 1520522077556, + "version": "0.5.0" + }, + "multipledispatch-0.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b644cef926d65a3299f000e2dc028e84", + "name": "multipledispatch", + "sha256": "c610fc32758277b7e4c1cf28700a3960e9fd88c80df8e67a5ff2fda7facdc01b", + "size": 18650, + "subdir": "linux-64", + "timestamp": 1520522091066, + "version": "0.5.0" + }, + "multipledispatch-0.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3741f4b3999f236521c0e7ab988daf19", + "name": "multipledispatch", + "sha256": "faf8a9025e616c801980d9d8bf8584e18b3e70836b752eb9847e2acf5cf1086e", + "size": 18407, + "subdir": "linux-64", + "timestamp": 1530771825486, + "version": "0.5.0" + }, + "multipledispatch-0.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "28069f9ac543edc1a14fa26c1519ea43", + "name": "multipledispatch", + "sha256": "47d78f9a67c3d5168aa789daed9c66a3747def041a074fe16479b6b656b8bc46", + "size": 21812, + "subdir": "linux-64", + "timestamp": 1534268875962, + "version": "0.6.0" + }, + "multipledispatch-0.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cfd4f3b63ee643440da44a826ee4b12b", + "name": "multipledispatch", + "sha256": "0130cd3d9d4351811e86b3a5146db6f13dbc921d85081c829a8709da0bdcee6e", + "size": 23374, + "subdir": "linux-64", + "timestamp": 1640791773703, + "version": "0.6.0" + }, + "multipledispatch-0.6.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3f6826a925120b3651a665e18371514e", + "name": "multipledispatch", + "sha256": "5c51172b171cb6ce392986d5bdfac96cf47931fca27649bc79bb6ba08146dfa0", + "size": 30047, + "subdir": "linux-64", + "timestamp": 1676841232463, + "version": "0.6.0" + }, + "multipledispatch-0.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e3b65f6c8a77360978e498087e81f942", + "name": "multipledispatch", + "sha256": "9efcfece9706064abeceda3f8f4584fb86ac5722690b784f89c353459f4a94c9", + "size": 22412, + "subdir": "linux-64", + "timestamp": 1534268844200, + "version": "0.6.0" + }, + "multipledispatch-0.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "121a70292fb84f8b13f32faf1968db24", + "name": "multipledispatch", + "sha256": "5fdd175e163b9ffb5f3fb1d77c58f98d42e67b2de319fe1a20b260cf8d60f474", + "size": 22106, + "subdir": "linux-64", + "timestamp": 1534268835630, + "version": "0.6.0" + }, + "multipledispatch-0.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "87f98c0429a2f3b44c48845f8d43ba60", + "name": "multipledispatch", + "sha256": "b0c73174d284ff3a48eda240b70cca7def9848f18da4e9085fcf52e97087846b", + "size": 22097, + "subdir": "linux-64", + "timestamp": 1534268887580, + "version": "0.6.0" + }, + "multipledispatch-0.6.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "96d7798aca81f3d12eb1378623658381", + "name": "multipledispatch", + "sha256": "240dfd27e7f588ae567178c2c2e01870d42fd8c15fcbdfa27827b130b7c33533", + "size": 23238, + "subdir": "linux-64", + "timestamp": 1573120615619, + "version": "0.6.0" + }, + "multipledispatch-0.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ac1386a4cff71fb8b5a8109ba3f20a28", + "name": "multipledispatch", + "sha256": "845a50424240a51f757a67056a57d8030b71aa7957407c8f04b54755bb1e5b00", + "size": 24673, + "subdir": "linux-64", + "timestamp": 1607574279743, + "version": "0.6.0" + }, + "multiprocess-0.70.12.2-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "dill >=0.2.5", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "de5b8e0ce02b97284ee7c0a78914caf7", + "name": "multiprocess", + "sha256": "c05f74d0a7891b7fe547b55a035214b76d2787378990dedb474a6d26bd3d1687", + "size": 229379, + "subdir": "linux-64", + "timestamp": 1640791798215, + "version": "0.70.12.2" + }, + "multiprocess-0.70.12.2-py36h7f8727e_0.conda": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "dill >=0.2.5", + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "766e3dcb28f18cb7ede83e1454d4040c", + "name": "multiprocess", + "sha256": "467cc90bd1dbd4813a4d2178357745d55e1d5240850bba1f2272e9133ae31736", + "size": 192440, + "subdir": "linux-64", + "timestamp": 1633079305502, + "version": "0.70.12.2" + }, + "multiprocess-0.70.12.2-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "dill >=0.2.5", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b7d0267c33fc3c011a55b4281e1a8e19", + "name": "multiprocess", + "sha256": "103aca1a02be99e294c46d7ea4ca61d6fd98d85f68c6a7610578a9d770e8be06", + "size": 201923, + "subdir": "linux-64", + "timestamp": 1633089808201, + "version": "0.70.12.2" + }, + "multiprocess-0.70.12.2-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "dill >=0.2.5", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ce58b803578c0ea28b51d0f5b59fe1f0", + "name": "multiprocess", + "sha256": "a77a2bd8b740994cf8cdde1f3d6f510c4c20fb83d984dbf7bf5237fa8652424f", + "size": 231732, + "subdir": "linux-64", + "timestamp": 1633089748658, + "version": "0.70.12.2" + }, + "multiprocess-0.70.12.2-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "dill >=0.2.5", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "11e2ff87453ab3dcbb102e3644e1d819", + "name": "multiprocess", + "sha256": "dc37f077cb9825af28af191877268e1779ec05a0796e0bab093806eb0576d5d2", + "size": 229922, + "subdir": "linux-64", + "timestamp": 1633089801713, + "version": "0.70.12.2" + }, + "multiprocess-0.70.14-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.6", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8fcce4029c9164c1afc58232d7732a54", + "name": "multiprocess", + "sha256": "7c3a12886e6432cdd908cdf2224d04dce83cc11da205f36a3cf21949693b79ff", + "size": 252200, + "subdir": "linux-64", + "timestamp": 1668006537468, + "version": "0.70.14" + }, + "multiprocess-0.70.14-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.6", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3912044665e692a474b7e9f666a42bae", + "name": "multiprocess", + "sha256": "7a61a5e82b94ba637ce590acd994d24547547b0f3830a318f77ece56721f7217", + "size": 330108, + "subdir": "linux-64", + "timestamp": 1676841248457, + "version": "0.70.14" + }, + "multiprocess-0.70.14-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.6", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "79c78ecc2e35f5ba5a7d627926369ce2", + "name": "multiprocess", + "sha256": "a1a2ad0c4738a2076b4cc8405cf3f29cde089963b3a27f40955216636712638e", + "size": 213718, + "subdir": "linux-64", + "timestamp": 1668006507801, + "version": "0.70.14" + }, + "multiprocess-0.70.14-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.6", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "59c2c0f94b5b94b85100326b5e67c756", + "name": "multiprocess", + "sha256": "813bf9704f2184db40db2957cc46af09e62c608f3b3f42f4c82af8a291c4b045", + "size": 243769, + "subdir": "linux-64", + "timestamp": 1668006567104, + "version": "0.70.14" + }, + "multiprocess-0.70.14-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.6", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9e0d662372c91776cfcbd6f33b0dcb7c", + "name": "multiprocess", + "sha256": "6a8e471195085347f81a8c65915f649f04dfa7f60d84decb62e6f3e639b52438", + "size": 245630, + "subdir": "linux-64", + "timestamp": 1668006476656, + "version": "0.70.14" + }, + "munch-2.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "b2d8d7320992c946ef36d3c5ec0cb78c", + "name": "munch", + "sha256": "37be9eeb9e85f344dee34a06ca1233a4709a05c1202f5ca39fa2bed02517338f", + "size": 13034, + "subdir": "linux-64", + "timestamp": 1523945995706, + "version": "2.3.1" + }, + "munch-2.3.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "60f1d8a5a8c99cd2d5036bc5eeaedbfb", + "name": "munch", + "sha256": "612e91bbe457a1d8ef79c469b04c7c8149f4ea2e1fb86cecb23a1c029f9c00f0", + "size": 13305, + "subdir": "linux-64", + "timestamp": 1523946051008, + "version": "2.3.1" + }, + "munch-2.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "bd0c23a3dc8cb312fbafd16704998061", + "name": "munch", + "sha256": "fabda0943bb49329469c1a7a9a3f6b6f151d039e317c298f8a9c7939233517da", + "size": 13382, + "subdir": "linux-64", + "timestamp": 1523946049887, + "version": "2.3.1" + }, + "munch-2.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "8c38a8686a327ab3ad47d079bb971cd5", + "name": "munch", + "sha256": "dd0c5e8ea599997bcb42cc213dcc80780013e4b1476e23ae5e691cc401ac0fbc", + "size": 13145, + "subdir": "linux-64", + "timestamp": 1526927419920, + "version": "2.3.2" + }, + "munch-2.3.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "ffd4d9a9db2a72ca74e8fc278e535c95", + "name": "munch", + "sha256": "e79edda1751ddf9bb11cf34431d4bf73994b4616c3a0c0ed1a7b2bc2a983f5d8", + "size": 13332, + "subdir": "linux-64", + "timestamp": 1526927438541, + "version": "2.3.2" + }, + "munch-2.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "78e88b0a6379a125b8ed1759d2721b08", + "name": "munch", + "sha256": "5d63c768ade036a3d007449207b7f8a1fb8998da63ba2b218ea3132410b1095d", + "size": 13393, + "subdir": "linux-64", + "timestamp": 1526927399962, + "version": "2.3.2" + }, + "munch-2.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "2cf1441bc2485e2d613fc855de0dfce8", + "name": "munch", + "sha256": "8cacb9767fd47c2300a736699ffa620bf4c4a386d9026b1b5fae00d103c034f8", + "size": 13289, + "subdir": "linux-64", + "timestamp": 1530876655123, + "version": "2.3.2" + }, + "murmurhash-0.28.0-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "cec3532b122bd377bb792cc7709a56a6", + "name": "murmurhash", + "sha256": "e1370b4f152e8aae481d239c5ce6cced2ad931a2a9d5c7cbcc34c3372054a850", + "size": 15846, + "subdir": "linux-64", + "timestamp": 1530900581889, + "version": "0.28.0" + }, + "murmurhash-0.28.0-py35he6710b0_0.conda": { + "build": "py35he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "3a8996baa6da04de259a562f40869f6c", + "name": "murmurhash", + "sha256": "a0ca339e42f7ccbc717c1b5d12354ac96a22a94557cc7da010a340660299a5fc", + "size": 16292, + "subdir": "linux-64", + "timestamp": 1535607608868, + "version": "0.28.0" + }, + "murmurhash-0.28.0-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "535383b6d547d44614f0c226e3ad4396", + "name": "murmurhash", + "sha256": "24f834bc090ba83dd8d581c8c7ec9e0482f3a2e523e78550fbf6b9fd9c31111a", + "size": 16087, + "subdir": "linux-64", + "timestamp": 1530900552760, + "version": "0.28.0" + }, + "murmurhash-0.28.0-py37hf484d3e_0.conda": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "060eec17f36a06d988a12f9b8877dce7", + "name": "murmurhash", + "sha256": "0ae0f1116100c7240cb989ddca20cad4fb4cfad58013e5e94d7e15fecbbe24a2", + "size": 16109, + "subdir": "linux-64", + "timestamp": 1530900522633, + "version": "0.28.0" + }, + "murmurhash-1.0.1-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "1d807b9f0086ffaf67751baab5ac55bf", + "name": "murmurhash", + "sha256": "f42b0484a719a6126e2037f3173bd5fb264abe90bced8b1d1ca870d48777a46a", + "size": 17203, + "subdir": "linux-64", + "timestamp": 1539719498471, + "version": "1.0.1" + }, + "murmurhash-1.0.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ce62d9b056a3f845b471ee3f4f4abea8", + "name": "murmurhash", + "sha256": "085e88888d979cd1a6fb2e57e5e3d8a7f427fa93050c78f2e057104be3ac8a31", + "size": 18253, + "subdir": "linux-64", + "timestamp": 1539719527773, + "version": "1.0.1" + }, + "murmurhash-1.0.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ebe56b8394d720b3698b09bf129f9da6", + "name": "murmurhash", + "sha256": "73dae8b0382dcc78ee4bef6fc806b58c28d87d0ac261238ec70ba913c0708ffb", + "size": 18295, + "subdir": "linux-64", + "timestamp": 1539719528263, + "version": "1.0.1" + }, + "murmurhash-1.0.2-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "4c82f93eb46be5f3b2eaa2f82dadb178", + "name": "murmurhash", + "sha256": "5b6c089f3b4679dd32e863ba2dacfa925796878f3775ca2bc5ab003c84481bdf", + "size": 26041, + "subdir": "linux-64", + "timestamp": 1552438745351, + "version": "1.0.2" + }, + "murmurhash-1.0.2-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4b767c591730559c687abf799504b84a", + "name": "murmurhash", + "sha256": "c07de2f7ca8592dd097926130621b3289a125d20544808af90daf3dcb44e684c", + "size": 27156, + "subdir": "linux-64", + "timestamp": 1552438907668, + "version": "1.0.2" + }, + "murmurhash-1.0.2-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "26c92b9e3c2f7d0785139214c0f61cf4", + "name": "murmurhash", + "sha256": "d35dc101793c6a95cf2de5836a6db3fb8c3f145e597259e97d42eb86c0fd6c2f", + "size": 27250, + "subdir": "linux-64", + "timestamp": 1552438724399, + "version": "1.0.2" + }, + "murmurhash-1.0.2-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "41f325679ae7a0216ddefcd88c733df1", + "name": "murmurhash", + "sha256": "4c5da28f56f77493564751c979d22ad8918d1e43ce88ae767cccf19cef17de22", + "size": 25784, + "subdir": "linux-64", + "timestamp": 1573120716560, + "version": "1.0.2" + }, + "murmurhash-1.0.5-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "28b24f676f2840603e462271acf758e1", + "name": "murmurhash", + "sha256": "56ce18e1cd25e927636f9b2fb827f01c74e36fdff9bb5831255203bed2fc3a40", + "size": 64666, + "subdir": "linux-64", + "timestamp": 1640791823622, + "version": "1.0.5" + }, + "murmurhash-1.0.5-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "718c76341be6a96648027d54a790991e", + "name": "murmurhash", + "sha256": "8b34e916da3072ac5bac3f030a71d99cc90ffa16f2aa62bb856a30caea548aef", + "size": 24637, + "subdir": "linux-64", + "timestamp": 1607456147005, + "version": "1.0.5" + }, + "murmurhash-1.0.5-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b2db5ddd2cf52f30b9f3981a880d6813", + "name": "murmurhash", + "sha256": "aa3515ac31010df8fd502dea088f6970f5260d3291a54ea4ef54c664457bbfdd", + "size": 24658, + "subdir": "linux-64", + "timestamp": 1607456148438, + "version": "1.0.5" + }, + "murmurhash-1.0.5-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "095bfbb54404a312e42d136d7bb543e6", + "name": "murmurhash", + "sha256": "032630ecfd22cca4eafd2abebd67c6cb0f9866edfd29220d808de5e52d769929", + "size": 24811, + "subdir": "linux-64", + "timestamp": 1607456150526, + "version": "1.0.5" + }, + "murmurhash-1.0.5-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "2a633da9d66533be102e3be1fc30c976", + "name": "murmurhash", + "sha256": "61dbd0693435926f3f86361aee7b83ec4b9806880f12ac2cb748994da5117455", + "size": 25325, + "subdir": "linux-64", + "timestamp": 1607456184981, + "version": "1.0.5" + }, + "murmurhash-1.0.7-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f38564578055a5e4dee0f158a630d268", + "name": "murmurhash", + "sha256": "1e13e5d9cbcc329349b081aa6b3cfc10f6eef68d8205d95e5c75d2d4162ce2c5", + "size": 65268, + "subdir": "linux-64", + "timestamp": 1651237298315, + "version": "1.0.7" + }, + "murmurhash-1.0.7-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f770e70810be8c49f41f2982e7f1189e", + "name": "murmurhash", + "sha256": "b0df1c949697dc7e317ba7cc61854c222acfd4ef29661dc24187bad17719be9f", + "size": 25728, + "subdir": "linux-64", + "timestamp": 1676837144249, + "version": "1.0.7" + }, + "murmurhash-1.0.7-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1b105b8cb0338f8772511343246e7a9", + "name": "murmurhash", + "sha256": "619cb097b01d556f97dcd5b32b9e2acaecfc0abf153fe3f30236d0dde45a5768", + "size": 24830, + "subdir": "linux-64", + "timestamp": 1651237254483, + "version": "1.0.7" + }, + "murmurhash-1.0.7-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "155657afdeb9d88d0e57bf04d51641d2", + "name": "murmurhash", + "sha256": "74f2dd0cb0d43fea73aeca64b8b3042e36cb6304850662e01f4d0e3dd9019445", + "size": 24997, + "subdir": "linux-64", + "timestamp": 1651237222742, + "version": "1.0.7" + }, + "murmurhash-1.0.7-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ec5528d641a009c236f14dbc67891e0", + "name": "murmurhash", + "sha256": "50def04362fa5f28f55fba744832a77972759316000d9a72f034000504aac972", + "size": 24990, + "subdir": "linux-64", + "timestamp": 1651237330698, + "version": "1.0.7" + }, + "mxnet-1.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "libmxnet 1.0.0 hb7fadbc_0", + "py-mxnet 1.0.0 py27hf484d3e_0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "b875e97d865aadc03c6f9172f1d7718b", + "name": "mxnet", + "namespace": "python", + "sha256": "6e997f1fd93b0c5363f2ffb1e435f1616917d1d844683520a43b659cd60ce3c2", + "size": 9887, + "subdir": "linux-64", + "timestamp": 1514730796091, + "version": "1.0.0" + }, + "mxnet-1.0.0-py27_nomkl_0.conda": { + "build": "py27_nomkl_0", + "build_number": 0, + "depends": [ + "libmxnet 1.0.0 nomklh2cb3ce3_0", + "py-mxnet 1.0.0 py27_nomklhf484d3e_0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "4492559c40b25d3aeff94e1d0d6e3218", + "name": "mxnet", + "namespace": "python", + "sha256": "6809d0cfbf48fd6426fd9044aead23b5ff84e4f36acaada9010215b14c3fb21c", + "size": 9944, + "subdir": "linux-64", + "timestamp": 1514731634607, + "version": "1.0.0" + }, + "mxnet-1.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "libmxnet 1.0.0 hb7fadbc_0", + "py-mxnet 1.0.0 py35hf484d3e_0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "a244251afb87a6a7fcbe5d4619b3a381", + "name": "mxnet", + "namespace": "python", + "sha256": "73a02d03cbaa1327fc3dbe0732454d5ae9025591eb7c0e170932c0317205288c", + "size": 9888, + "subdir": "linux-64", + "timestamp": 1514730803346, + "version": "1.0.0" + }, + "mxnet-1.0.0-py35_nomkl_0.conda": { + "build": "py35_nomkl_0", + "build_number": 0, + "depends": [ + "libmxnet 1.0.0 nomklh2cb3ce3_0", + "py-mxnet 1.0.0 py35_nomklhf484d3e_0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "54c5bcd58372596785101bf07dfc944f", + "name": "mxnet", + "namespace": "python", + "sha256": "f19037bf99af4d4e860f6c8cf7ab3f0bfcee73b4cca7bf15eeb806bdca7a8219", + "size": 9942, + "subdir": "linux-64", + "timestamp": 1514731641125, + "version": "1.0.0" + }, + "mxnet-1.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libmxnet 1.0.0 hb7fadbc_0", + "py-mxnet 1.0.0 py36hf484d3e_0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "4ccd7e942a4cbd3c9459f8ccef08a52a", + "name": "mxnet", + "namespace": "python", + "sha256": "884fefd26e30c5a78966fddcdeab56c8ec1d74800331f326a034feb635be3092", + "size": 9847, + "subdir": "linux-64", + "timestamp": 1514730810623, + "version": "1.0.0" + }, + "mxnet-1.0.0-py36_nomkl_0.conda": { + "build": "py36_nomkl_0", + "build_number": 0, + "depends": [ + "libmxnet 1.0.0 nomklh2cb3ce3_0", + "py-mxnet 1.0.0 py36_nomklhf484d3e_0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "c0e3340ae2165dc1ee94df8dea531423", + "name": "mxnet", + "namespace": "python", + "sha256": "a45d7436c092092278419cb05a347d800983c40148916d68972539779441bc72", + "size": 9916, + "subdir": "linux-64", + "timestamp": 1514731647724, + "version": "1.0.0" + }, + "mxnet-1.1.0-py27_nomklhba1e662_0.conda": { + "build": "py27_nomklhba1e662_0", + "build_number": 0, + "depends": [ + "libmxnet 1.1.0 nomklh028b6bb_0", + "py-mxnet 1.1.0 py27_nomklhf484d3e_0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "5e078aab125281a46e8429ec9c2e9f48", + "name": "mxnet", + "namespace": "python", + "sha256": "916d3a91c9a47c9d0e299cce181daf77c62beb20be5ae2b608d3dc8503a62a71", + "size": 16531, + "subdir": "linux-64", + "timestamp": 1522953612955, + "version": "1.1.0" + }, + "mxnet-1.1.0-py27hb4372cb_0.conda": { + "build": "py27hb4372cb_0", + "build_number": 0, + "depends": [ + "libmxnet 1.1.0 h47cb24f_0", + "py-mxnet 1.1.0 py27hf484d3e_0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "66c5f4a21354dca7f49974f55b7b2d50", + "name": "mxnet", + "namespace": "python", + "sha256": "ac8bcd49a4fd27fb29db3924e2387cf72159f3ad03925b683bef8aa391b5020e", + "size": 16470, + "subdir": "linux-64", + "timestamp": 1522952825075, + "version": "1.1.0" + }, + "mxnet-1.1.0-py35_nomklhba1e662_0.conda": { + "build": "py35_nomklhba1e662_0", + "build_number": 0, + "depends": [ + "libmxnet 1.1.0 nomklh028b6bb_0", + "py-mxnet 1.1.0 py35_nomklhf484d3e_0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "1cdd8f42ad50b78248687e96ee8d1595", + "name": "mxnet", + "namespace": "python", + "sha256": "f14f00c8479a63b8085625d5ca6b170010df8f09d74c6d33e618b5edbefb3f71", + "size": 16395, + "subdir": "linux-64", + "timestamp": 1522953869357, + "version": "1.1.0" + }, + "mxnet-1.1.0-py35hb4372cb_0.conda": { + "build": "py35hb4372cb_0", + "build_number": 0, + "depends": [ + "libmxnet 1.1.0 h47cb24f_0", + "py-mxnet 1.1.0 py35hf484d3e_0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "9d989d747da16040b610f923e42500b4", + "name": "mxnet", + "namespace": "python", + "sha256": "20850ee7e04657239a2b4823c612f27ad08a6727d68ffefb86905b8a463dbb25", + "size": 16355, + "subdir": "linux-64", + "timestamp": 1522953783712, + "version": "1.1.0" + }, + "mxnet-1.1.0-py36_nomklhba1e662_0.conda": { + "build": "py36_nomklhba1e662_0", + "build_number": 0, + "depends": [ + "libmxnet 1.1.0 nomklh028b6bb_0", + "py-mxnet 1.1.0 py36_nomklhf484d3e_0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "70b91303bec20678f3d98bfa9c6f08ce", + "name": "mxnet", + "namespace": "python", + "sha256": "741f330823e418a1584779926dd2b13c8690802509d3fa512002922d8c3db832", + "size": 16404, + "subdir": "linux-64", + "timestamp": 1522954188833, + "version": "1.1.0" + }, + "mxnet-1.1.0-py36hb4372cb_0.conda": { + "build": "py36hb4372cb_0", + "build_number": 0, + "depends": [ + "libmxnet 1.1.0 h47cb24f_0", + "py-mxnet 1.1.0 py36hf484d3e_0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "640634e416603a0504abcb24be1cd1a4", + "name": "mxnet", + "namespace": "python", + "sha256": "519bfdc0d49a1a34d49df6fe30fe429f3aaf6207a42f1aff9ce43f68cef0b589", + "size": 16361, + "subdir": "linux-64", + "timestamp": 1522953962330, + "version": "1.1.0" + }, + "mxnet-1.2.1-h8cc8929_0.conda": { + "build": "h8cc8929_0", + "build_number": 0, + "depends": [ + "libmxnet 1.2.1.*", + "py-mxnet 1.2.1.*" + ], + "md5": "39c1ad1798ceeb467a01f31f7b2f7eb5", + "name": "mxnet", + "namespace": "python", + "sha256": "ae03dfce4fb1438c0f8c70ef59a229bdfde98757a04ffbf4b9b5d966733a3537", + "size": 3020, + "subdir": "linux-64", + "timestamp": 1533368926791, + "version": "1.2.1" + }, + "mxnet-1.5.0-hea8a0af_0.conda": { + "build": "hea8a0af_0", + "build_number": 0, + "depends": [ + "libmxnet 1.5.0.*", + "py-mxnet 1.5.0.*" + ], + "md5": "1fa467faa5116de6365ae82163070609", + "name": "mxnet", + "namespace": "python", + "sha256": "e119d7afcfc5a190c30ed590ff64e18964c190740d47809eb29d0c5d3dc11418", + "size": 5730, + "subdir": "linux-64", + "timestamp": 1564770317442, + "version": "1.5.0" + }, + "mxnet-1.5.1-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libmxnet 1.5.1 openblas_h8848447_0", + "py-mxnet 1.5.1 py39h9bc9155_0" + ], + "md5": "e87dd3987d63366bbcee6344cd970176", + "name": "mxnet", + "namespace": "python", + "sha256": "0133188b070c05389a2d3bed079e9801100a4a35120cb1d500e7b7e429fcbd78", + "size": 9600, + "subdir": "linux-64", + "timestamp": 1665586798619, + "version": "1.5.1" + }, + "mxnet-1.9.1-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libmxnet 1.9.1 openblas_h8848447_0", + "py-mxnet 1.9.1 py38h4f77008_0" + ], + "md5": "8ad21be89a4bfb1c64bce8f8178eef1c", + "name": "mxnet", + "namespace": "python", + "sha256": "1851206f5c7f98994d9f7aa9b3c4dc59e73e43fd50e42ede1310b5ae739b8703", + "size": 11835, + "subdir": "linux-64", + "timestamp": 1666597083322, + "version": "1.9.1" + }, + "mxnet-gpu-1.2.1-hd441e4d_0.conda": { + "build": "hd441e4d_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.10 gpu_openblas", + "mxnet 1.2.1.*" + ], + "md5": "dfaa29ae1f0467085d6c4883ad77cbf7", + "name": "mxnet-gpu", + "sha256": "af92d4f491dff8bafc7567db7024012e4d1162aa4a2b4c69f1c9e56660b33d8c", + "size": 2890, + "subdir": "linux-64", + "timestamp": 1533385632352, + "version": "1.2.1" + }, + "mxnet-gpu-1.2.1-hf82a2c8_0.conda": { + "build": "hf82a2c8_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.20 gpu_mkl", + "mxnet 1.2.1.*" + ], + "md5": "0279ed6a636effaa8bf29ff6f4da0223", + "name": "mxnet-gpu", + "sha256": "9243d9a4f44182f7d9d89786bb45c3f98d33aaca0fa6c87312a97ed7aedc9ff4", + "size": 2887, + "subdir": "linux-64", + "timestamp": 1533385628370, + "version": "1.2.1" + }, + "mxnet-gpu_mkl-1.2.1-hf82a2c8_0.conda": { + "build": "hf82a2c8_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.20 gpu_mkl", + "mxnet 1.2.1.*" + ], + "md5": "1dc1e3fb5aec16abcfee09ef6f743352", + "name": "mxnet-gpu_mkl", + "sha256": "10cec3a51d481d4e6611806cec9c36e183d94407c312b7704a331c40ca39f846", + "size": 2816, + "subdir": "linux-64", + "timestamp": 1533677450611, + "version": "1.2.1" + }, + "mxnet-gpu_openblas-1.2.1-hd441e4d_0.conda": { + "build": "hd441e4d_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.10 gpu_openblas", + "mxnet 1.2.1.*" + ], + "md5": "4adf4784fcf03e8cf2a469bd058c7bbc", + "name": "mxnet-gpu_openblas", + "sha256": "08c6bc69e7c609d40ea4e7bc39a5f866870199feb419280abb87146f160ba719", + "size": 2829, + "subdir": "linux-64", + "timestamp": 1533677446920, + "version": "1.2.1" + }, + "mxnet-mkl-1.2.1-hd1a0b70_0.conda": { + "build": "hd1a0b70_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.40 mkl", + "mxnet 1.2.1.*" + ], + "md5": "26a18e62d899c11ef862c47361627131", + "name": "mxnet-mkl", + "sha256": "82cf8434e9279f56dd3deeb3c175bea3c0d7c959d02b0dd9a365debd96012016", + "size": 2788, + "subdir": "linux-64", + "timestamp": 1533677454252, + "version": "1.2.1" + }, + "mxnet-mkl-1.5.0-hb5687c5_0.conda": { + "build": "hb5687c5_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.40 mkl", + "mxnet 1.5.0.*" + ], + "md5": "1a938f1d902d95dd6e8991d62c79e3cd", + "name": "mxnet-mkl", + "sha256": "180ca3b80d6a217fef6ef2027878393ff4468a44a8e744f3f781961de128e3b8", + "size": 5790, + "subdir": "linux-64", + "timestamp": 1564770976806, + "version": "1.5.0" + }, + "mxnet-openblas-1.2.1-h0ffc63b_0.conda": { + "build": "h0ffc63b_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.30 openblas", + "mxnet 1.2.1.*" + ], + "md5": "8e1b4c35753deed65dec09f45d8481c7", + "name": "mxnet-openblas", + "sha256": "b5121687dcf4aaa9f2ff3b0ffe0cd9133e7cfccc9f103a479389b9972cb011f7", + "size": 2805, + "subdir": "linux-64", + "timestamp": 1533677442756, + "version": "1.2.1" + }, + "mxnet-openblas-1.5.0-h026006c_0.conda": { + "build": "h026006c_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.30 openblas", + "mxnet 1.5.0.*" + ], + "md5": "55fd2660d589b9758811ab7f55878026", + "name": "mxnet-openblas", + "sha256": "55b40708c9776f4dcd8e80c236430c873bc8aa14a395efa7c744f65b7458b683", + "size": 5817, + "subdir": "linux-64", + "timestamp": 1564770617404, + "version": "1.5.0" + }, + "mxnet-openblas-1.5.1-h687809c_0.conda": { + "build": "h687809c_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.50 openblas", + "libmxnet 1.5.1 openblas_h8848447_0" + ], + "md5": "d18e3ec82bb060e7de10cef3e9913f32", + "name": "mxnet-openblas", + "sha256": "77588a2f1437f1c16ecf48994066f167c14aae460b5ec07850911d44afbdfe98", + "size": 9679, + "subdir": "linux-64", + "timestamp": 1665586672530, + "version": "1.5.1" + }, + "mxnet-openblas-1.9.1-h687809c_0.conda": { + "build": "h687809c_0", + "build_number": 0, + "depends": [ + "_mutex_mxnet 0.0.50 openblas", + "libmxnet 1.9.1 openblas_h8848447_0" + ], + "md5": "cfb6d7ca71e9ba2596f4f0f600bc761e", + "name": "mxnet-openblas", + "sha256": "b0a94d79190aeaa28835a0bfff65bd13bd5061940c5a496693fe7a216b1015f8", + "size": 11917, + "subdir": "linux-64", + "timestamp": 1666596931909, + "version": "1.9.1" + }, + "mypy-0.550-py35heb60bfd_0.conda": { + "build": "py35heb60bfd_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.5,<3.6.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45086f84e5606cb04e36b53559e283fe", + "name": "mypy", + "sha256": "1f04f4437a305943d9dc0e112a9bf8747c143a4b5fed4c141930e824b0013b32", + "size": 1030681, + "subdir": "linux-64", + "timestamp": 1510777174033, + "version": "0.550" + }, + "mypy-0.550-py36hd8b1e0f_0.conda": { + "build": "py36hd8b1e0f_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ac3c66d089e101d31c6e3eb5f620b3f", + "name": "mypy", + "sha256": "344c4e5c0f6abc9609debc177df788fab2815190c9f6a220224d94c351951515", + "size": 1014320, + "subdir": "linux-64", + "timestamp": 1510777172356, + "version": "0.550" + }, + "mypy-0.570-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.5,<3.6.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "36b3e32433bf7b88c4f660740862f9e2", + "name": "mypy", + "sha256": "dcf6956fd8471e58911fffc64ea9038c73c11229218ac40db866d71fa867d511", + "size": 1089238, + "subdir": "linux-64", + "timestamp": 1520882532007, + "version": "0.570" + }, + "mypy-0.570-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "081651820aa027b3ca9fdaa82c0ea4dd", + "name": "mypy", + "sha256": "26511085194f7b57f0746990c92d6f781378370d05374b2848e5732a32cd3cc0", + "size": 1081003, + "subdir": "linux-64", + "timestamp": 1520882475152, + "version": "0.570" + }, + "mypy-0.580-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.5,<3.6.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9163fef122b696141a7db281ac662db", + "name": "mypy", + "sha256": "0d5735e571074d035e401c2eb44f188d6c63fc3bc5f1e017c680f16a2c23a788", + "size": 1092302, + "subdir": "linux-64", + "timestamp": 1522715424072, + "version": "0.580" + }, + "mypy-0.580-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa0d4d06a7287e1686474efa1ed9dc07", + "name": "mypy", + "sha256": "5c04c279b651bf8c3b345089946478a0d55c88eb1dc4375fcb480874f5159017", + "size": 1083360, + "subdir": "linux-64", + "timestamp": 1522715188470, + "version": "0.580" + }, + "mypy-0.590-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.5,<3.6.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "edbda5e5779c0cb076ecac11192c7ba1", + "name": "mypy", + "sha256": "3dcdbd2aafd580afd77123b5ed921a7eb70038652a1fd0ab307af7d2c283a4b4", + "size": 1113272, + "subdir": "linux-64", + "timestamp": 1524071620517, + "version": "0.590" + }, + "mypy-0.590-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3167ddd120f935b50ff8350f1974c4f0", + "name": "mypy", + "sha256": "d1793e7c2c55735651e7e2ad1f044b3195f06eb057fa8e9fcc3ccb0c188e1551", + "size": 1110650, + "subdir": "linux-64", + "timestamp": 1524071635134, + "version": "0.590" + }, + "mypy-0.600-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.5,<3.6.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e3a878f00a4b9019a419af9dadb0195b", + "name": "mypy", + "sha256": "7853f54dc5f4016f4d2d3d1268568250c2f8f55a25b7b3b236ad110e13e8ea84", + "size": 1125417, + "subdir": "linux-64", + "timestamp": 1526932453274, + "version": "0.600" + }, + "mypy-0.600-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c81ac53e9f4f598b0dd8805895b891b", + "name": "mypy", + "sha256": "9ff46f279af2f630eac816d1f174419b45cbf62053318ad2fca39804c72a0b95", + "size": 1122737, + "subdir": "linux-64", + "timestamp": 1526932432627, + "version": "0.600" + }, + "mypy-0.610-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.5,<3.6.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c57d1e789ed16d3fe7d2161bdc42a3b", + "name": "mypy", + "sha256": "235dd2b3943f1b59081b7fad8cd16d881adab6d772c96a09e16a6b1fc8fb65cb", + "size": 1161776, + "subdir": "linux-64", + "timestamp": 1529967689949, + "version": "0.610" + }, + "mypy-0.610-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d58882078b1145406d6aedb3423dbbe2", + "name": "mypy", + "sha256": "b7833bd3b2a79acedf0d2fa9c0d12dcefcde882318ae50ce178ba4895c0f0e8d", + "size": 1151648, + "subdir": "linux-64", + "timestamp": 1529967659326, + "version": "0.610" + }, + "mypy-0.610-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6bbae70dd9070b12ae2cc126b70f9803", + "name": "mypy", + "sha256": "6e42f870b201d980b09c32c2f32ab50c58b91455d62f0e5f3bf4842db757e2a3", + "size": 1144872, + "subdir": "linux-64", + "timestamp": 1530900712916, + "version": "0.610" + }, + "mypy-0.620-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.5,<3.6.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca54af9fc45549939a33e4a5c335c4cb", + "name": "mypy", + "sha256": "f50138cb73cf6fc7c31e1d8b0d17aa9aa8bfa0c6c7db2e0685c66392306fb4a9", + "size": 1198203, + "subdir": "linux-64", + "timestamp": 1534665866731, + "version": "0.620" + }, + "mypy-0.620-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e2bb2fbec8fc9c326c9f597700ce169", + "name": "mypy", + "sha256": "4cba358f5442ba427583258b3725b16df25c409df0eaaae9d34e90e3f50b021a", + "size": 1180614, + "subdir": "linux-64", + "timestamp": 1534665825874, + "version": "0.620" + }, + "mypy-0.620-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "psutil >=5.4.0,<5.5.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b210eacbc31e728227ae90b45252d4ec", + "name": "mypy", + "sha256": "ad8a198e14e91b2ec082e7c56a3e1e561a713f0556a1c380da369e0f88745aae", + "size": 1180874, + "subdir": "linux-64", + "timestamp": 1534665858270, + "version": "0.620" + }, + "mypy-0.630-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.0,<0.5.0", + "psutil >=5.4.0,<5.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "67e42ca5d92d0c2b3d0ea91d292c28d4", + "name": "mypy", + "sha256": "32c5ea006b0c760fb7063ba48262d5e54fae75cc0db09bc59d839b4e1e7ea0e3", + "size": 1241051, + "subdir": "linux-64", + "timestamp": 1538183685928, + "version": "0.630" + }, + "mypy-0.630-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.0,<0.5.0", + "psutil >=5.4.0,<5.5.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d539b530a02ba4611493ad11975600de", + "name": "mypy", + "sha256": "b5526c4a9a6ee12267766b32b79df2cce070f8d4ca3b1f6c81d6199c70c5bd52", + "size": 1250049, + "subdir": "linux-64", + "timestamp": 1538183689931, + "version": "0.630" + }, + "mypy-0.641-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.0,<0.5.0", + "psutil >=5.4.0,<5.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4748f00a0041596e0d30bd65c293bb91", + "name": "mypy", + "sha256": "72ae2d5aa996d9e1751635a95ecb815562781b2cf78087b650362952857f67fa", + "size": 1264304, + "subdir": "linux-64", + "timestamp": 1540982959871, + "version": "0.641" + }, + "mypy-0.641-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.0,<0.5.0", + "psutil >=5.4.0,<5.5.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f14499c6ca4e66912fbd196a0e04d211", + "name": "mypy", + "sha256": "293a46b1a9f758ef55fede8d6ab696d2b94ed30a6c3e80cc1f459d3f6a371cec", + "size": 1270971, + "subdir": "linux-64", + "timestamp": 1540982976015, + "version": "0.641" + }, + "mypy-0.650-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.0,<0.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d0d685a44f077058db70b5ae122edb1d", + "name": "mypy", + "sha256": "0df2a212a16e454793f96272680ddf5c03b8710b94da04ce8b02f54535f0a3ea", + "size": 1291826, + "subdir": "linux-64", + "timestamp": 1545163228599, + "version": "0.650" + }, + "mypy-0.650-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.0,<0.5.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d15bbfec1511347186a5d75996792e59", + "name": "mypy", + "sha256": "c9c2331f2b01a831c1a604f2d63c0a0b83edcdb1b7a8315cdafdb8c0bc65f16d", + "size": 1292857, + "subdir": "linux-64", + "timestamp": 1545163110547, + "version": "0.650" + }, + "mypy-0.660-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.0,<0.5.0", + "python >=3.6,<3.7.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "745443e8d8018ed94a1202615bcf2eca", + "name": "mypy", + "sha256": "b779e68ba0909add169eb9b6f7b7b6f58c3fd8930176f5ca6170ce9a9b44f65b", + "size": 1325457, + "subdir": "linux-64", + "timestamp": 1547791542788, + "version": "0.660" + }, + "mypy-0.660-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.0,<0.5.0", + "python >=3.7,<3.8.0a0", + "typed-ast >=1.1.0,<1.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3260b7644f11ca45ecba9e81fa37fcf", + "name": "mypy", + "sha256": "e2d14b335168c9811ccbdf8ff2732e8497cc4ea2da1e564007a857cfe4e1cc4a", + "size": 1326341, + "subdir": "linux-64", + "timestamp": 1547791471098, + "version": "0.660" + }, + "mypy-0.981-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.3,<2", + "psutil >=4.0", + "python >=3.10,<3.11.0a0", + "toml", + "tomli >=1.1.0", + "typing_extensions >=3.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a26910335ba7214f2a36823c750e1b73", + "name": "mypy", + "sha256": "71367c6f1f6f17dbd6b0c5db40d6c63723b7ef22b2938767cec9a2a4eacb0871", + "size": 2773299, + "subdir": "linux-64", + "timestamp": 1668440271591, + "version": "0.981" + }, + "mypy-0.981-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.3,<2", + "psutil >=4.0", + "python >=3.11,<3.12.0a0", + "toml", + "typing_extensions >=3.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef95e62ad8e4ce53eb7caa1b543c2c84", + "name": "mypy", + "sha256": "73b87f4711b306014a79c5a3f1f3230975e236d3c41700c90349ae5daa96dbbc", + "size": 3020886, + "subdir": "linux-64", + "timestamp": 1676859841268, + "version": "0.981" + }, + "mypy-0.981-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.3,<2", + "psutil >=4.0", + "python >=3.7,<3.8.0a0", + "toml", + "tomli >=1.1.0", + "typed-ast >=1.4.0,<2", + "typing_extensions >=3.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "28f4b3de59cbf3df676fc83c120a3608", + "name": "mypy", + "sha256": "1547d146c51c8ebd31b9a9ce04567df6bad3b2b97c8b844e5caa5929a1614e50", + "size": 2731968, + "subdir": "linux-64", + "timestamp": 1668440382029, + "version": "0.981" + }, + "mypy-0.981-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.3,<2", + "psutil >=4.0", + "python >=3.8,<3.9.0a0", + "toml", + "tomli >=1.1.0", + "typing_extensions >=3.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "831c077b0681929b228390af87c01353", + "name": "mypy", + "sha256": "e2fa6a51942ffa036cfdbcafdfc84f51b62bf41e971abd086eefd51425018cfe", + "size": 2746228, + "subdir": "linux-64", + "timestamp": 1668440345040, + "version": "0.981" + }, + "mypy-0.981-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "mypy_extensions >=0.4.3,<2", + "psutil >=4.0", + "python >=3.9,<3.10.0a0", + "toml", + "tomli >=1.1.0", + "typing_extensions >=3.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8814769274407a73d75aae2c9497da7", + "name": "mypy", + "sha256": "3421811cc6697b658c7e4a14e1bbd1b8433cad0c45db03ef68d05211c74e7f57", + "size": 2743129, + "subdir": "linux-64", + "timestamp": 1668440307072, + "version": "0.981" + }, + "mypy_extensions-0.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "typing" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c703fa8049078d9d0e8aab553c407a48", + "name": "mypy_extensions", + "sha256": "cace8b8838e76ee51cebafcdff4f197c456709576d7540879ea96fe4c5e8c3e8", + "size": 7676, + "subdir": "linux-64", + "timestamp": 1530900800066, + "version": "0.3.0" + }, + "mypy_extensions-0.3.0-py27ha5a17fb_0.conda": { + "build": "py27ha5a17fb_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "typing" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c2aaf7aae331d9f813607df02574c43", + "name": "mypy_extensions", + "sha256": "bf600f48e191e5a22c59534f98423b7e415504e0e0860c42a7b13ba77aae1b33", + "size": 7846, + "subdir": "linux-64", + "timestamp": 1511211977086, + "version": "0.3.0" + }, + "mypy_extensions-0.3.0-py35h319d151_0.conda": { + "build": "py35h319d151_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c9c25e51ab4f04909c103908c7ed47d", + "name": "mypy_extensions", + "sha256": "4420afd005d36ffad7e874e8ca757187eb8c374abf1ea73a2730c7e2b01deccf", + "size": 7957, + "subdir": "linux-64", + "timestamp": 1511211979076, + "version": "0.3.0" + }, + "mypy_extensions-0.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea8b1dfce15d128e36ec0c709576923b", + "name": "mypy_extensions", + "sha256": "9276ee44ee7c523b3b61e87492be3113f22349cf0457ce054fdf994dbfd1a374", + "size": 7620, + "subdir": "linux-64", + "timestamp": 1530900773290, + "version": "0.3.0" + }, + "mypy_extensions-0.3.0-py36h258aa37_0.conda": { + "build": "py36h258aa37_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f79fb111f0f530dab0792409fe735e8d", + "name": "mypy_extensions", + "sha256": "a8020be2778e3f4f213654ebe789f6ab5b218f411c3a078626d5df245898f7d4", + "size": 7968, + "subdir": "linux-64", + "timestamp": 1511211984292, + "version": "0.3.0" + }, + "mypy_extensions-0.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9002a2d7ff53c8c59c26e41d4b439b6f", + "name": "mypy_extensions", + "sha256": "c16da11eec8ccf61deacb8bd9a24ba0b5112b20caa3530ce51f30a84e1e46a60", + "size": 7689, + "subdir": "linux-64", + "timestamp": 1530900746110, + "version": "0.3.0" + }, + "mypy_extensions-0.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "typing" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c7b358e9416b784637a7d6efb7f8201", + "name": "mypy_extensions", + "sha256": "9ec3f5155b3119d07821afa9fcc27d436c00a33ca98fb8455bfa7175e0fd7658", + "size": 8569, + "subdir": "linux-64", + "timestamp": 1536113481397, + "version": "0.4.1" + }, + "mypy_extensions-0.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebcb8334980ba38009fbc10360c8ca94", + "name": "mypy_extensions", + "sha256": "88b78cf2967556c4db17424a12169c72d7734f96546d31eb0cf356f72b3c653d", + "size": 8690, + "subdir": "linux-64", + "timestamp": 1536113463977, + "version": "0.4.1" + }, + "mypy_extensions-0.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0d4577df11a3f3b5bae1d53af0ef6eb", + "name": "mypy_extensions", + "sha256": "ca07f0ce934ff4a54c33cc043e0cf9747312d72b214069304e18a64984febefa", + "size": 8638, + "subdir": "linux-64", + "timestamp": 1536113409242, + "version": "0.4.1" + }, + "mypy_extensions-0.4.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3fcdf4f99d8376374984dd83f840dbb", + "name": "mypy_extensions", + "sha256": "f877ce92ab32e7e10d90e8a91a5aca3f5d8b342d04cb692b5ec263e50ee33c9c", + "size": 9345, + "subdir": "linux-64", + "timestamp": 1613558452948, + "version": "0.4.1" + }, + "mypy_extensions-0.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3063c6635b1e50079f3c3958ff1d6648", + "name": "mypy_extensions", + "sha256": "2543512a12e6474c41b745e7eff1a45766832c2b85b9d65ed9ca52749b6b3bf1", + "size": 8636, + "subdir": "linux-64", + "timestamp": 1536113509057, + "version": "0.4.1" + }, + "mypy_extensions-0.4.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60b18532e6eac597181c61705fb8c625", + "name": "mypy_extensions", + "sha256": "7cf92944df540eeda2a480330d7fa8178c76edcf9ea6ba9fcfcbf1e157b2aff4", + "size": 9363, + "subdir": "linux-64", + "timestamp": 1613558456770, + "version": "0.4.1" + }, + "mypy_extensions-0.4.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f19514c5e09bdc58942ef25095fd97db", + "name": "mypy_extensions", + "sha256": "a4cd429f99b2f7f5b1231f662f3e0f76a51f3536e6a2ed7b743f364fb3da0f7c", + "size": 9056, + "subdir": "linux-64", + "timestamp": 1573120731824, + "version": "0.4.1" + }, + "mypy_extensions-0.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a9cdc80707c7db02f7862e15ee57eba2", + "name": "mypy_extensions", + "sha256": "921eca4a1756b07f9b88bfa5583c4753b2472b995e15d0c52832dc49579c83e4", + "size": 9390, + "subdir": "linux-64", + "timestamp": 1613558456126, + "version": "0.4.1" + }, + "mypy_extensions-0.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d5575d748ae70c47d77295f274c7423", + "name": "mypy_extensions", + "sha256": "3e547c4cc0bd4fa1e08cc3b8fec5c76f09ddf58d332ca36c84f622d9daba31a9", + "size": 9354, + "subdir": "linux-64", + "timestamp": 1613558326788, + "version": "0.4.1" + }, + "mypy_extensions-0.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5a390822e6787fcd7b9d13ad616754e1", + "name": "mypy_extensions", + "sha256": "f762e923ac2fdd7707e389e0ecfe1780200ae66f5ce56c0774bcbb6bba979800", + "size": 8989, + "subdir": "linux-64", + "timestamp": 1640791841558, + "version": "0.4.3" + }, + "mypy_extensions-0.4.3-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "468c213f5c7721af3e1656245eb1f581", + "name": "mypy_extensions", + "sha256": "1f55a32d5a201269b3a63ebf35accdb9aae6e35fdd3633eb2772113613331df3", + "size": 11214, + "subdir": "linux-64", + "timestamp": 1676837158360, + "version": "0.4.3" + }, + "mypy_extensions-0.4.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13732d6e87735047e809944df5c3f2f3", + "name": "mypy_extensions", + "sha256": "30cb7cfdd92ef71631b35102d9b8ee9c716345ca68c186aefadbd09ccb1b2a09", + "size": 9510, + "subdir": "linux-64", + "timestamp": 1582149851383, + "version": "0.4.3" + }, + "mypy_extensions-0.4.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7499e5f754ddbc70f34bdad6da87c86f", + "name": "mypy_extensions", + "sha256": "a1fa569f3bfd4262f45abde961451d83f2194319f7c05964ed1f2a01ac360936", + "size": 9479, + "subdir": "linux-64", + "timestamp": 1582149828175, + "version": "0.4.3" + }, + "mypy_extensions-0.4.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e099ec5bcbdcadae74a88316859a8837", + "name": "mypy_extensions", + "sha256": "bf99bb1093a373edc77cb988b8529b8bad22c6cf3d33b8c157c77e129e6a0a9b", + "size": 9968, + "subdir": "linux-64", + "timestamp": 1640165683889, + "version": "0.4.3" + }, + "mypy_extensions-0.4.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6e530e21a804080c85ba3c45ba33e0d", + "name": "mypy_extensions", + "sha256": "94f6017244aff6c4b7189780a49707d7ed4b9f4728c9e5c98ad0e7517892608b", + "size": 9517, + "subdir": "linux-64", + "timestamp": 1582150019773, + "version": "0.4.3" + }, + "mypy_extensions-0.4.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "821e12d2f09b08f91df33e2b9caf6570", + "name": "mypy_extensions", + "sha256": "dfeaf473ed9be74de33c53a02c843d68a40dbdfaa76a6b55c3d7bc071511ccbc", + "size": 10015, + "subdir": "linux-64", + "timestamp": 1640151569197, + "version": "0.4.3" + }, + "mypy_extensions-0.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6be26827a3cc2490c3ac9ccc6d2ce9ca", + "name": "mypy_extensions", + "sha256": "a569d15e047de19c2a8ebd19a77258ef3bd2c0f2b92f43c44d24e6e5635ddd14", + "size": 9181, + "subdir": "linux-64", + "timestamp": 1626908116886, + "version": "0.4.3" + }, + "mypy_extensions-0.4.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce49f082569beb0bf65e81efe2d01342", + "name": "mypy_extensions", + "sha256": "2aec1d0fc90051add67e4a49c0225f062a890ef1d1a7064fa9f138318d54e914", + "size": 10022, + "subdir": "linux-64", + "timestamp": 1640165677703, + "version": "0.4.3" + }, + "mysql-5.7.20-h55eaa98_0.conda": { + "build": "h55eaa98_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "2766c71f4b29434a33de34ae28342ecf", + "name": "mysql", + "sha256": "fd54286ab0e9a2c43c9ab0fe551880ec7dc9a2d09f1a6eab0c4460f4bbc9d7da", + "size": 19432581, + "subdir": "linux-64", + "timestamp": 1510510424005, + "version": "5.7.20" + }, + "mysql-5.7.22-hef7e34c_0.conda": { + "build": "hef7e34c_0", + "build_number": 0, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libedit >=3.1.20170329,<3.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "e9530ecda7864342f1ade24d5fb5fe8f", + "name": "mysql", + "sha256": "7bd09509c0329df3cd3278511245c22fadd3de839d149061770dd48d6eed72c5", + "size": 19402610, + "subdir": "linux-64", + "timestamp": 1527083722955, + "version": "5.7.22" + }, + "mysql-5.7.24-hbb652a2_0.conda": { + "build": "hbb652a2_0", + "build_number": 0, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libedit >=3.1.20170329,<3.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "2c927754681c5d7b035b2a72317d19fc", + "name": "mysql", + "sha256": "7f1debeebf11da3de4f6661b447f6db1886d08ecdd70aeb4857d59ca225d5f1b", + "size": 20571080, + "subdir": "linux-64", + "timestamp": 1541008954973, + "version": "5.7.24" + }, + "mysql-connector-c-6.1.11-h24aacaa_2.conda": { + "build": "h24aacaa_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=8.4.0", + "libstdcxx-ng >=8.4.0", + "openssl >=1.1.1m,<1.1.2a" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "f52f4c495f9bc4d3cc0e12a287ba2353", + "name": "mysql-connector-c", + "sha256": "cbf2441f79149a8a4aea4d19403431ea57a7f519f64f7563305503d69b439473", + "size": 1298028, + "subdir": "linux-64", + "timestamp": 1642788160502, + "version": "6.1.11" + }, + "mysql-connector-c-6.1.11-h597af5e_0.conda": { + "build": "h597af5e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "d6e26d480a18d6133a9d1a21f71e4f34", + "name": "mysql-connector-c", + "sha256": "10d4acf72cb0682c8ba00d220c585b18aef831bd56d8f1ee8eda4148a3174d54", + "size": 1338721, + "subdir": "linux-64", + "timestamp": 1540380766928, + "version": "6.1.11" + }, + "mysql-connector-c-6.1.11-h597af5e_1.conda": { + "build": "h597af5e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "e616407dd0aa35657e12cce0ba8a06b1", + "name": "mysql-connector-c", + "sha256": "f04c2a7f87d1df539557ebd0d44cd30c4ec71a4ae9bce5a40570b8488d4ecb01", + "size": 1306638, + "subdir": "linux-64", + "timestamp": 1579119221091, + "version": "6.1.11" + }, + "mysql-connector-c-6.1.11-hf4847fb_0.conda": { + "build": "hf4847fb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "e47725db70376ccf5a30ff71e9dde377", + "name": "mysql-connector-c", + "sha256": "dc2a8795efb510dbc3b7e9959873734c792c76a8fe1c31ac9d273db8b9c46eca", + "size": 1323463, + "subdir": "linux-64", + "timestamp": 1524130832622, + "version": "6.1.11" + }, + "mysql-connector-python-8.0.12-py27haf6c83e_0.conda": { + "build": "py27haf6c83e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "b534982f91a7961b5cfe448f1473ba13", + "name": "mysql-connector-python", + "sha256": "f897d95fe934c5287a626ea8441ed5439026aa76e44807918b88128a3d90b9cb", + "size": 551789, + "subdir": "linux-64", + "timestamp": 1534744972606, + "version": "8.0.12" + }, + "mysql-connector-python-8.0.12-py35haf6c83e_0.conda": { + "build": "py35haf6c83e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "e8bfd1aafcc2852faa7fb3918cd9d993", + "name": "mysql-connector-python", + "sha256": "0ac81b94b7969f34943b71d1412d73092ae58f27c886d32b3753559054df54c2", + "size": 553303, + "subdir": "linux-64", + "timestamp": 1534744961095, + "version": "8.0.12" + }, + "mysql-connector-python-8.0.12-py36haf6c83e_0.conda": { + "build": "py36haf6c83e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "024761338e333583e1349931aab0ce35", + "name": "mysql-connector-python", + "sha256": "b11f17318ed5e17ee7e4cac2f2898e07d7aee985ef5472505e2e1e7319b2b025", + "size": 539699, + "subdir": "linux-64", + "timestamp": 1534744964171, + "version": "8.0.12" + }, + "mysql-connector-python-8.0.12-py37haf6c83e_0.conda": { + "build": "py37haf6c83e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "c13d1bac22717a287f645c93c2866381", + "name": "mysql-connector-python", + "sha256": "419b27aadc0c2657b14495a80e48afba0be95e7d9dfd963d4ebb05769283bcfd", + "size": 538789, + "subdir": "linux-64", + "timestamp": 1534744708435, + "version": "8.0.12" + }, + "mysql-connector-python-8.0.13-py27h9c95fcb_0.conda": { + "build": "py27h9c95fcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "a0066df13e1066b98a7e63110a41f151", + "name": "mysql-connector-python", + "sha256": "9041367deadcc0c6357da5d6429f16889b8a208c3faff3fefc36ee533e679b9b", + "size": 582152, + "subdir": "linux-64", + "timestamp": 1545159108356, + "version": "8.0.13" + }, + "mysql-connector-python-8.0.13-py36h9c95fcb_0.conda": { + "build": "py36h9c95fcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "d21f2da70dd39b37d4d6f92cbb32bbeb", + "name": "mysql-connector-python", + "sha256": "5824f62caca0f8989a6ca488847a80af556a9f6836220a537e0465f298f6837c", + "size": 571444, + "subdir": "linux-64", + "timestamp": 1545159121968, + "version": "8.0.13" + }, + "mysql-connector-python-8.0.13-py37h9c95fcb_0.conda": { + "build": "py37h9c95fcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "9780d734f5f187bf0bb4a8b23c411c9d", + "name": "mysql-connector-python", + "sha256": "111ac3ae8b79b9ba2e04bf287a3d6f9cdc14203188b4ba04b98c24c2ce318a5b", + "size": 570428, + "subdir": "linux-64", + "timestamp": 1545159140160, + "version": "8.0.13" + }, + "mysql-connector-python-8.0.16-py27h9c95fcb_0.conda": { + "build": "py27h9c95fcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "56d03d58bcd1a680c12a15815abcba8e", + "name": "mysql-connector-python", + "sha256": "e0120739e5acda61c2d297969c12bea9495c8d38d9b0116e0f792bb88b36f603", + "size": 618233, + "subdir": "linux-64", + "timestamp": 1559920932706, + "version": "8.0.16" + }, + "mysql-connector-python-8.0.16-py36h9c95fcb_0.conda": { + "build": "py36h9c95fcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "a865918c62f905e392f8b5cb1d4dc7bb", + "name": "mysql-connector-python", + "sha256": "60a89ec95ebf06237d1c901cb9fc76d3749c8e0b6c81d824bb7a88013d4d489b", + "size": 610187, + "subdir": "linux-64", + "timestamp": 1559920965339, + "version": "8.0.16" + }, + "mysql-connector-python-8.0.16-py37h9c95fcb_0.conda": { + "build": "py37h9c95fcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "3590b3952573518149abdd40bcd465a7", + "name": "mysql-connector-python", + "sha256": "f35608cce400eae909558ae83e3c3c17b6d2c035655317ee0618ce7f37dc7da6", + "size": 600737, + "subdir": "linux-64", + "timestamp": 1559920934011, + "version": "8.0.16" + }, + "mysql-connector-python-8.0.17-py27h9c95fcb_0.conda": { + "build": "py27h9c95fcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "edca0b4a81653a9627041017d67b8c9c", + "name": "mysql-connector-python", + "sha256": "bb63b78054790b3b47fca048a585023cc7fda9298239931ae47a758555dc6852", + "size": 630212, + "subdir": "linux-64", + "timestamp": 1569355677287, + "version": "8.0.17" + }, + "mysql-connector-python-8.0.17-py36h9c95fcb_0.conda": { + "build": "py36h9c95fcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "9ab1caaabc2dc5de2ab5c6b109fd9311", + "name": "mysql-connector-python", + "sha256": "f868b043b88cca71fd4bd7fa8a168f54aa79f98016148b993f54928c10a114c9", + "size": 621912, + "subdir": "linux-64", + "timestamp": 1569355653229, + "version": "8.0.17" + }, + "mysql-connector-python-8.0.17-py37h9c95fcb_0.conda": { + "build": "py37h9c95fcb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "a6a07c2466ffbbe5d73ba1e59afc12c4", + "name": "mysql-connector-python", + "sha256": "94701ca0c2260e2b4d386909db49e094f6c62796bbae89ee7892c6cc6adacccb", + "size": 618557, + "subdir": "linux-64", + "timestamp": 1569355675429, + "version": "8.0.17" + }, + "mysql-connector-python-8.0.18-py27h9c95fcb_1.conda": { + "build": "py27h9c95fcb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "4afca885f6df9417214a6795d7567ec6", + "name": "mysql-connector-python", + "sha256": "81437d3f8dd18ac9762c761340a3b465430ddc97f5c7bd53ecbcab8beef165c9", + "size": 632242, + "subdir": "linux-64", + "timestamp": 1573969142724, + "version": "8.0.18" + }, + "mysql-connector-python-8.0.18-py36h9c95fcb_1.conda": { + "build": "py36h9c95fcb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "fc2f1b1e17855ed0cf086e729ab71c4b", + "name": "mysql-connector-python", + "sha256": "d6ec5cb9b2252380aac2085fadb2dd10de39c491030f540944673325f79f47a8", + "size": 624541, + "subdir": "linux-64", + "timestamp": 1573969215703, + "version": "8.0.18" + }, + "mysql-connector-python-8.0.18-py37h9c95fcb_1.conda": { + "build": "py37h9c95fcb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "protobuf >=3.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "0b48c00b9da5d27e826ec9bd2edc3466", + "name": "mysql-connector-python", + "sha256": "454c951c2e7ebfbac940fd962888814e64b9c430c7b87dc177baa773176657b8", + "size": 622107, + "subdir": "linux-64", + "timestamp": 1573969155664, + "version": "8.0.18" + }, + "mysql-python-1.2.5-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL", + "license_family": "GPL2", + "md5": "b8a5d2a7c1c2f173db35c54d041bee8b", + "name": "mysql-python", + "sha256": "8cd9586c3500c61a184b6d5a79821c0210833c6cb3efc81f838cdf5d28605dd3", + "size": 222275, + "subdir": "linux-64", + "timestamp": 1557176520482, + "version": "1.2.5" + }, + "mysqlclient-1.3.12-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL 2.0", + "md5": "3383d4a58f78cd5562eeb5738cd7a9c5", + "name": "mysqlclient", + "sha256": "9fef0f78ef0173321d7ed8dedf75945170bbdb452d4da20f09587524b121a1ad", + "size": 86671, + "subdir": "linux-64", + "timestamp": 1524131151327, + "version": "1.3.12" + }, + "mysqlclient-1.3.12-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL 2.0", + "md5": "f1ff1d7004e7387a605c843c302278d1", + "name": "mysqlclient", + "sha256": "6c6f29634bd256b908af0f47afe34ab2f9d5eec3c310ce97078938d81bc98965", + "size": 86690, + "subdir": "linux-64", + "timestamp": 1524131218646, + "version": "1.3.12" + }, + "mysqlclient-1.3.12-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2.0", + "md5": "50463b7e5ffa4fccf741f44c5c4cdf6c", + "name": "mysqlclient", + "sha256": "e3393bb0050b287f50d0c40dd95c5714aca8f2249e34c002c05a07949fbd0eae", + "size": 86149, + "subdir": "linux-64", + "timestamp": 1524131212267, + "version": "1.3.12" + }, + "mysqlclient-1.3.13-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL 2.0", + "md5": "3d49015f69f07f3c68c2340d98b198e8", + "name": "mysqlclient", + "sha256": "6b6d0cf6ec125d08e7bc869c124b217dc39b4047752d1ec344bd96687a165e4e", + "size": 86763, + "subdir": "linux-64", + "timestamp": 1530556055420, + "version": "1.3.13" + }, + "mysqlclient-1.3.13-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL 2.0", + "md5": "ba4a43e701a61691b0a49da63ca891de", + "name": "mysqlclient", + "sha256": "2b6902dc18a6f6cd7fc75f2d5d3b17d179f6af29a7eeb4092dfd7219d4f2a2b3", + "size": 86811, + "subdir": "linux-64", + "timestamp": 1530556151194, + "version": "1.3.13" + }, + "mysqlclient-1.3.13-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2.0", + "md5": "5b84247639b0fa7ea0a2694d9b74efe8", + "name": "mysqlclient", + "sha256": "b4dd5bdb727c2ae572267a4af36453cbb64815a7f19b173765cc538488b3063e", + "size": 87011, + "subdir": "linux-64", + "timestamp": 1530556151041, + "version": "1.3.13" + }, + "mysqlclient-1.3.13-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL 2.0", + "md5": "4b489434a040abd81cda9ee75795ad09", + "name": "mysqlclient", + "sha256": "1ddf43d4eded7e2f624d0b9e6176a7a89be59e18dc5cb1cdb0c6eb2f8c1ba93d", + "size": 85606, + "subdir": "linux-64", + "timestamp": 1530900832328, + "version": "1.3.13" + }, + "mysqlclient-1.3.14-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL 2.0", + "md5": "c192e7a02307e1f1ed6ad84b5e60c12f", + "name": "mysqlclient", + "sha256": "81febcfdbf5e9a6538b0eb9d706d588dcee08cc5be8a333365dfb3b1851134de", + "size": 87727, + "subdir": "linux-64", + "timestamp": 1545126635760, + "version": "1.3.14" + }, + "mysqlclient-1.3.14-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2.0", + "md5": "99483d68709ad0b37c2c9ade18d3cefa", + "name": "mysqlclient", + "sha256": "90e963d33e9eb6ef7fc26164e6e475fba90a6ce58525f5ae146b9350cec3f40b", + "size": 87311, + "subdir": "linux-64", + "timestamp": 1545147363117, + "version": "1.3.14" + }, + "mysqlclient-1.3.14-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL 2.0", + "md5": "521a727ad0cdc791720d60166ae76b1f", + "name": "mysqlclient", + "sha256": "1db63e5a81651f432bd8867d7a92f87c9ed8c14e85ad6203d5d8feb94027d323", + "size": 87328, + "subdir": "linux-64", + "timestamp": 1545126654703, + "version": "1.3.14" + }, + "mysqlclient-1.4.4-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "md5": "f128d3b5546c64b1c29b38960eb45e56", + "name": "mysqlclient", + "sha256": "d320b85b3b59df3ff83a619c222ced31b4debc3d888e97fe5252fe9d5804dab1", + "size": 80231, + "subdir": "linux-64", + "timestamp": 1569434292890, + "version": "1.4.4" + }, + "mysqlclient-1.4.4-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "md5": "b581a9468ae01f79b5137dfa74fbe6d1", + "name": "mysqlclient", + "sha256": "97d6c270d725a4dab07f97857f2239d13a15bbfdf552c7d8f23b9c083541ce4c", + "size": 79306, + "subdir": "linux-64", + "timestamp": 1569434320784, + "version": "1.4.4" + }, + "mysqlclient-1.4.4-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "md5": "89a26df3e40c2920916bc450e641d920", + "name": "mysqlclient", + "sha256": "9def994c08979dc55ec55d3a626aae23829762fbba1cce29fd0a72e801e9782f", + "size": 79315, + "subdir": "linux-64", + "timestamp": 1569434323004, + "version": "1.4.4" + }, + "mysqlclient-1.4.4-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-2.0", + "md5": "64545902ed670209731c111f69bdd413", + "name": "mysqlclient", + "sha256": "c51d4996776037de6505e9facb2247476b1586f79fd94df7831e728de13cae93", + "size": 85121, + "subdir": "linux-64", + "timestamp": 1573120828657, + "version": "1.4.4" + }, + "mysqlclient-1.4.6-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "md5": "87f1c426f25df51d595e1a2fd28f7e44", + "name": "mysqlclient", + "sha256": "81d72867c53a88ccaa117a964fcaee37da851856b9411a9cf5e5e419d26a7467", + "size": 80472, + "subdir": "linux-64", + "timestamp": 1574368354464, + "version": "1.4.6" + }, + "mysqlclient-1.4.6-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "md5": "6abf70056a526dfbb432adc96c8314f6", + "name": "mysqlclient", + "sha256": "461e261a5c7917f729435e02b709a5c094fecc3d95b3500b3de3a99ebcf60423", + "size": 79600, + "subdir": "linux-64", + "timestamp": 1574368362263, + "version": "1.4.6" + }, + "mysqlclient-1.4.6-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "md5": "7b747fb023d06480e293900367b697b7", + "name": "mysqlclient", + "sha256": "b60fbf192b0b7e26d85aabc65ab61937b314ebafcf5fdcf8de74126d58423f95", + "size": 79313, + "subdir": "linux-64", + "timestamp": 1574368331932, + "version": "1.4.6" + }, + "mysqlclient-1.4.6-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-2.0", + "md5": "a8a8b987a4dc837610a2a392f783b728", + "name": "mysqlclient", + "sha256": "638dc7465da5d4f16bc9027d27526d293da6f8db0e50fda70c21d25eaec75cb2", + "size": 86572, + "subdir": "linux-64", + "timestamp": 1574368459887, + "version": "1.4.6" + }, + "mysqlclient-2.0.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "md5": "2514585ed8adc25e05daa9d2e353befe", + "name": "mysqlclient", + "sha256": "0164ce3be19d46ef375a0bc2134f5d73e4ff66dfbe505189031a8a481c065de0", + "size": 78002, + "subdir": "linux-64", + "timestamp": 1594308786811, + "version": "2.0.1" + }, + "mysqlclient-2.0.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "md5": "5860ef5beb9cae780877952ff278128e", + "name": "mysqlclient", + "sha256": "436c71d7e2b7b79c6a699eb6ab8bfa572fd5eb041494f702455af33d1a80410a", + "size": 79324, + "subdir": "linux-64", + "timestamp": 1594308796684, + "version": "2.0.1" + }, + "mysqlclient-2.0.1-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-2.0", + "md5": "80b870debdf767a70fa3bf3be60981b8", + "name": "mysqlclient", + "sha256": "76533affa41eeea1379977f9dfac4ce8d54f2f8d7036f7fd9493ba5ca58e6252", + "size": 80455, + "subdir": "linux-64", + "timestamp": 1594308787023, + "version": "2.0.1" + }, + "mysqlclient-2.0.2-py36h2531618_1.conda": { + "build": "py36h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "dbfdc8a06407da66a2a22a6266418295", + "name": "mysqlclient", + "sha256": "d75f266bc3a31f6df302603197951473de9dec9617b075fd97e2309665ae5428", + "size": 77412, + "subdir": "linux-64", + "timestamp": 1607622877766, + "version": "2.0.2" + }, + "mysqlclient-2.0.2-py37h2531618_1.conda": { + "build": "py37h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "aaa39e9d0a29ff8e7a2bce371ff95a59", + "name": "mysqlclient", + "sha256": "bcbd47e1fe2a7a7b6424489478b54174935b34d9747fcf1aae86129af2f04952", + "size": 78736, + "subdir": "linux-64", + "timestamp": 1607622885230, + "version": "2.0.2" + }, + "mysqlclient-2.0.2-py38h2531618_1.conda": { + "build": "py38h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "af59ebb135f6c64fce96317a065b048c", + "name": "mysqlclient", + "sha256": "67eb551b0ee4b376f2b6b55c24ada3277edec32ec3a152971de8406ee75d1370", + "size": 80098, + "subdir": "linux-64", + "timestamp": 1607622858120, + "version": "2.0.2" + }, + "mysqlclient-2.0.2-py39h2531618_1.conda": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "ce88b1fdc51d8e18f4d9318f8af5f2b4", + "name": "mysqlclient", + "sha256": "872729e303b33267fc2343975f5f475f05e24b9e941b4ecb25615a101b5d9c90", + "size": 77532, + "subdir": "linux-64", + "timestamp": 1607622880709, + "version": "2.0.2" + }, + "mysqlclient-2.0.3-py310h295c915_1.conda": { + "build": "py310h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "d72529de00c7aba4c2e3a9e69689ad62", + "name": "mysqlclient", + "sha256": "c7c8a42e3a851010e0143bf07853ae00d2b018a24765fb7e865040a6870dc1e2", + "size": 116550, + "subdir": "linux-64", + "timestamp": 1640791867333, + "version": "2.0.3" + }, + "mysqlclient-2.0.3-py311h6a678d5_1.conda": { + "build": "py311h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "627bc0c77a2941f7308d4e359094aba1", + "name": "mysqlclient", + "sha256": "6167a50b4f03f1967593f33f67f29fc9a6a3f31aaef619dea7b984bd40cc39a1", + "size": 85157, + "subdir": "linux-64", + "timestamp": 1676859865384, + "version": "2.0.3" + }, + "mysqlclient-2.0.3-py36h2531618_1.conda": { + "build": "py36h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "8661e1e561628f164b5635a9b226ab38", + "name": "mysqlclient", + "sha256": "3bde2aeca8895583412e86ae21804c868735a0ef3b7d1ea5ba96ccc8173462d1", + "size": 78690, + "subdir": "linux-64", + "timestamp": 1609786267405, + "version": "2.0.3" + }, + "mysqlclient-2.0.3-py37h2531618_1.conda": { + "build": "py37h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "3458b6649937a2d2949698c176368a92", + "name": "mysqlclient", + "sha256": "789cb1195ddb191fdfa64b37946c7792bea217573c1650373bb2c6c65dc049ef", + "size": 78336, + "subdir": "linux-64", + "timestamp": 1609786274255, + "version": "2.0.3" + }, + "mysqlclient-2.0.3-py38h2531618_1.conda": { + "build": "py38h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "9042209914c6e935c3ce79dbc9f512d7", + "name": "mysqlclient", + "sha256": "4b74d5726eb74927b30e52670a1fce6e2785f4abb43dd071dfb7dc7e0cbca41c", + "size": 79400, + "subdir": "linux-64", + "timestamp": 1609786298550, + "version": "2.0.3" + }, + "mysqlclient-2.0.3-py39h2531618_1.conda": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mysql-connector-c >=6.1.11,<6.1.12.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-2.0-or-later", + "md5": "014a192fd433bfe7324ccf976b4bee7e", + "name": "mysqlclient", + "sha256": "a66da7f2411d169fdcce37dd210205d8c532eedecf18d38150b70500b185285a", + "size": 79685, + "subdir": "linux-64", + "timestamp": 1609786164943, + "version": "2.0.3" + }, + "nasm-2.13.03-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD 2-Clause", + "md5": "5e6640d0465e207059aaafcb175b904f", + "name": "nasm", + "sha256": "8f3795cac44336e6b5204876aac2d065f38a923e84d69ddcad422549c1f0cacc", + "size": 445343, + "subdir": "linux-64", + "timestamp": 1539874298448, + "version": "2.13.03" + }, + "nasm-2.13.03-h7b6447c_1.conda": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD 2-Clause", + "md5": "f04a8839ed6a6143adc752f91fed01cc", + "name": "nasm", + "sha256": "b1a84494d98ff8f9c233c3de45eb62bf06465d01b032b455e0cdc0fecd9ceabe", + "size": 439038, + "subdir": "linux-64", + "timestamp": 1539877373259, + "version": "2.13.03" + }, + "natsort-5.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "17b7dddec9f86df4c238b45df91006ec", + "name": "natsort", + "sha256": "3cb90f1edbaf80138c4fb9e08ba265136da00907afc71f0bd7a800eb28771164", + "size": 47826, + "subdir": "linux-64", + "timestamp": 1519671801675, + "version": "5.2.0" + }, + "natsort-5.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "2542bcda892117a6166aa4c7ae191e14", + "name": "natsort", + "sha256": "499a5e29ac4260905fe841d9e8710f1c82d177266eb45f352c0e80575c2c7d5c", + "size": 50017, + "subdir": "linux-64", + "timestamp": 1519671819220, + "version": "5.2.0" + }, + "natsort-5.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e69ad31ed4671c2d3057d2c9affea283", + "name": "natsort", + "sha256": "101fe01fb3cf85ea3af3f09039cb3ffcc18015fc3cdfd4bc9caf612f4d3ce046", + "size": 49567, + "subdir": "linux-64", + "timestamp": 1519671856458, + "version": "5.2.0" + }, + "natsort-5.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "142066e2f2e962c674ef06b0d5af735f", + "name": "natsort", + "sha256": "9b3197bfcee44a65a2486078cbbf780ddb817509b9402b8c3841a11b8a3e2136", + "size": 48080, + "subdir": "linux-64", + "timestamp": 1524499316524, + "version": "5.3.0" + }, + "natsort-5.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "74b2651882b4c43b20e4b7d912a7cf64", + "name": "natsort", + "sha256": "40d4409cbbf9f17f497e08949a0c86f05b9a2e4134693a87da01a785c84b5c4f", + "size": 50253, + "subdir": "linux-64", + "timestamp": 1524499317430, + "version": "5.3.0" + }, + "natsort-5.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d3dfdc0d28be821ce6f8813fa70ba5e4", + "name": "natsort", + "sha256": "8304052a135570119fc599e43cc67eb2aa3c97741c00f4e435ad990f2eeaf65a", + "size": 50989, + "subdir": "linux-64", + "timestamp": 1524499114519, + "version": "5.3.0" + }, + "natsort-5.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9a00042cd3664010a6ab2ba1deb8cd9f", + "name": "natsort", + "sha256": "b9e113a541f490f77242bd5d90ed72617a209a22753e5712acceace293d06d86", + "size": 48412, + "subdir": "linux-64", + "timestamp": 1526918528412, + "version": "5.3.2" + }, + "natsort-5.3.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "29e370368a65330c6b7552103a2ae1d0", + "name": "natsort", + "sha256": "7383ae64a1a837149a560e2ae4b03890669403c777efa4c22e3763df06562894", + "size": 51926, + "subdir": "linux-64", + "timestamp": 1526918539517, + "version": "5.3.2" + }, + "natsort-5.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a0005818d14449fcfc9345a8a2557971", + "name": "natsort", + "sha256": "5bbd10980f584915a0880ac8a4f4ea42aa3b756799796d0c967716e87c282767", + "size": 50265, + "subdir": "linux-64", + "timestamp": 1526918498202, + "version": "5.3.2" + }, + "natsort-5.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c04cb99b0424c5d30d05996bb94e64ca", + "name": "natsort", + "sha256": "72cf38b811c66688c6f6c9964ddb489de2efb04cb44328784a0bcf4860d0b01d", + "size": 48107, + "subdir": "linux-64", + "timestamp": 1530900863422, + "version": "5.3.2" + }, + "natsort-5.3.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d2a2768992f0e2fb681ccafb4ff6348a", + "name": "natsort", + "sha256": "fffcf4947649f498c15b241bf1c89fc4d0fdc2181d591b83fb832ed3f04fa88b", + "size": 50237, + "subdir": "linux-64", + "timestamp": 1532628952893, + "version": "5.3.3" + }, + "natsort-5.3.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "70b71ca0d18d4d33de98860f2f3004cc", + "name": "natsort", + "sha256": "8093ed17d960987454b5d59d68728fb825c4632beffceb404e9c81735c88ae36", + "size": 53737, + "subdir": "linux-64", + "timestamp": 1532629003571, + "version": "5.3.3" + }, + "natsort-5.3.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "437280021d41d526f412dd66c69d1498", + "name": "natsort", + "sha256": "4ba10b7a06fafdd8a254bac33a03cb819039efdedabf6db53a27ba99ada236f6", + "size": 52067, + "subdir": "linux-64", + "timestamp": 1532629201983, + "version": "5.3.3" + }, + "natsort-5.3.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "9e41908da3ea4e4cd9632524729896d3", + "name": "natsort", + "sha256": "4419d4a1da17eeeddcf7b0a070502193c3ab363dc2986e2c261f7e048334e2c1", + "size": 50338, + "subdir": "linux-64", + "timestamp": 1532629015866, + "version": "5.3.3" + }, + "natsort-5.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "93c6b1e722c4417a3772b7adb1a3bf74", + "name": "natsort", + "sha256": "6d7fdb84744d3ac65ce3849d66dd5a8bb55e2b4a0c1f2f25271e824324ebf664", + "size": 52970, + "subdir": "linux-64", + "timestamp": 1538181352534, + "version": "5.4.0" + }, + "natsort-5.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a8a564161e47eee61f781fa020f85715", + "name": "natsort", + "sha256": "d7b7c41aa03d17fda4e7f4a1e26c5397a88599222bfd3ae562a6dfe09e3e0528", + "size": 56028, + "subdir": "linux-64", + "timestamp": 1538181335515, + "version": "5.4.0" + }, + "natsort-5.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5c9b5fd84e9bab7469e66f8b06f44209", + "name": "natsort", + "sha256": "37fe91251d1764c46c8cfec902655985296cb441570d09deee686b2c25ebf2cd", + "size": 52177, + "subdir": "linux-64", + "timestamp": 1538181331853, + "version": "5.4.0" + }, + "natsort-5.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "58b735623117955c448184f2a0406449", + "name": "natsort", + "sha256": "92266cc76dc33554c42009bb562f95174dadde259bf71637b37ef9e938eec96a", + "size": 53613, + "subdir": "linux-64", + "timestamp": 1539641077049, + "version": "5.4.1" + }, + "natsort-5.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7396760d6e1e15d58348e38d706b6ee7", + "name": "natsort", + "sha256": "b6601c110e5dcb0eb0f03936945233e4a425312ed46266fa613fa421cd229c06", + "size": 56910, + "subdir": "linux-64", + "timestamp": 1539641085199, + "version": "5.4.1" + }, + "natsort-5.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "bb3afa9c4fe9fd5c0867a103a1e853a8", + "name": "natsort", + "sha256": "2806e08d619c2371544ee96e03b80bdb4461dc16f0b6d750369906af77e78047", + "size": 53842, + "subdir": "linux-64", + "timestamp": 1539641081192, + "version": "5.4.1" + }, + "natsort-5.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d7ea288abbcae542e55a4ad8c89b2474", + "name": "natsort", + "sha256": "42c55c1e4aaa0ac6ce2c45ebf6953a83a6911c2eb9d6e007bf7c5591bd35007c", + "size": 55065, + "subdir": "linux-64", + "timestamp": 1542640546532, + "version": "5.5.0" + }, + "natsort-5.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "42cf0708f6cf336bdfcc720fb9db451b", + "name": "natsort", + "sha256": "5e74b5a5dbd404ae8360d4163703e064d84f14618462660ce9d482e4a67583bf", + "size": 56842, + "subdir": "linux-64", + "timestamp": 1542640578796, + "version": "5.5.0" + }, + "natsort-5.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "067366bc16f25319442d409906484b73", + "name": "natsort", + "sha256": "fb016082124f4ef068b92a3708c78375c7fe48e3e82741ec44fa43b7a53c66b7", + "size": 55087, + "subdir": "linux-64", + "timestamp": 1542640520824, + "version": "5.5.0" + }, + "navigator-updater-0.1.0-py27h0f9cd39_0.conda": { + "build": "py27h0f9cd39_0", + "build_number": 0, + "depends": [ + "pyqt >=5.6", + "python >=2.7,<2.8.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "f0c5f9b5e835fa1dc3eee93adac59310", + "name": "navigator-updater", + "sha256": "3cc52e5a5df2313f960c7df9883197ad9d3df6ec7d8054b3fdf38941632ac9c0", + "size": 687897, + "subdir": "linux-64", + "timestamp": 1505852418043, + "version": "0.1.0" + }, + "navigator-updater-0.1.0-py35h2ff6758_0.conda": { + "build": "py35h2ff6758_0", + "build_number": 0, + "depends": [ + "pyqt >=5.6", + "python >=3.5,<3.6.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "7e249a45b3ebcddb9a1c3669756ffc59", + "name": "navigator-updater", + "sha256": "c122b2793969f68763135769983d48c3ff169f60f53abddb8509efc4219c4fb8", + "size": 690010, + "subdir": "linux-64", + "timestamp": 1505852435849, + "version": "0.1.0" + }, + "navigator-updater-0.1.0-py36h14770f7_0.conda": { + "build": "py36h14770f7_0", + "build_number": 0, + "depends": [ + "pyqt >=5.6", + "python >=3.6,<3.7.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "504c1cfe6b04ceca949f463bc150e2bd", + "name": "navigator-updater", + "sha256": "de5053c1f1174ce90d24b988a430905f763c67e2867b6513332605f0487da34e", + "size": 687359, + "subdir": "linux-64", + "timestamp": 1505852453838, + "version": "0.1.0" + }, + "navigator-updater-0.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=2.7,<2.8.0a0", + "qtpy" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "2235532b8738bfc2e287d2702b14d8d3", + "name": "navigator-updater", + "sha256": "f9e964c80d8586d24c8f8ad0bb4d0ec4e8498762298b34d1db880bedf7b8ad88", + "size": 703310, + "subdir": "linux-64", + "timestamp": 1524671901356, + "version": "0.2.0" + }, + "navigator-updater-0.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.5,<3.6.0a0", + "qtpy" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "a70d40a1aeb5db22302c01da0ac285ea", + "name": "navigator-updater", + "sha256": "ec8420301cfe004f5641db4e87940b7c85607a5fad357c4991bdd71741a637ff", + "size": 707233, + "subdir": "linux-64", + "timestamp": 1524671938622, + "version": "0.2.0" + }, + "navigator-updater-0.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.6,<3.7.0a0", + "qtpy" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "84355b2a3a15beafeddb1ca46b6ecd92", + "name": "navigator-updater", + "sha256": "4af431e756721d47a3a0b214953fc35540007db7e29fb06be84ab3be12922ef3", + "size": 706809, + "subdir": "linux-64", + "timestamp": 1524671976329, + "version": "0.2.0" + }, + "navigator-updater-0.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyqt >=5.6", + "python >=2.7,<2.8.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "ab9ad8fff9c30fbd1a2215e5e4e64a9b", + "name": "navigator-updater", + "sha256": "1173a4cd0aa044a13706eb79bdb986dc7a87043bc40ef88afdfea4e1214f69c7", + "size": 706015, + "subdir": "linux-64", + "timestamp": 1527013162953, + "version": "0.2.1" + }, + "navigator-updater-0.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyqt >=5.6", + "python >=3.5,<3.6.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "d4a5fbc55da9350b42fc6f741bc84716", + "name": "navigator-updater", + "sha256": "964609a11e0af5d04f7a168d6b1bc98a58baa5194a73c732b08944a99a3b1a62", + "size": 711236, + "subdir": "linux-64", + "timestamp": 1527013238264, + "version": "0.2.1" + }, + "navigator-updater-0.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyqt >=5.6", + "python >=3.6,<3.7.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "1fa2df9cca0ae96df4b44a2dcf3a7607", + "name": "navigator-updater", + "sha256": "91944ee453731f1dc583b35d880d44ae823c816bcf2e32eca42d1b05343e43d2", + "size": 708108, + "subdir": "linux-64", + "timestamp": 1527013199875, + "version": "0.2.1" + }, + "navigator-updater-0.2.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "psutil", + "pyqt >=5.6", + "python >=3.6,<3.7.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "2d542fc3c5f0c69b493ab8c9badf5993", + "name": "navigator-updater", + "sha256": "ec437deeee78f280e76286d3b19dee267f289fe7ee26ff03d26e14eadeb04d3b", + "size": 703565, + "subdir": "linux-64", + "timestamp": 1641962611409, + "version": "0.2.1" + }, + "navigator-updater-0.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyqt >=5.6", + "python >=3.7,<3.8.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "4a50a3d5251c86af06265eb80b854a4d", + "name": "navigator-updater", + "sha256": "f8af07cc88f7e29377083b082a9d8f6716a562dee2963a39f45aa11aff52f80a", + "size": 707894, + "subdir": "linux-64", + "timestamp": 1531492426460, + "version": "0.2.1" + }, + "navigator-updater-0.2.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "psutil", + "pyqt >=5.6", + "python >=3.7,<3.8.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "0fa39f9ea1017a1accd5504bcef5aac6", + "name": "navigator-updater", + "sha256": "00c8360260a5150e0c9fe4e197d985423c26f7ee61edb02f45b6d2680d837366", + "size": 703014, + "subdir": "linux-64", + "timestamp": 1641965704226, + "version": "0.2.1" + }, + "navigator-updater-0.2.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pyqt >=5.6", + "python >=3.8,<3.9.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "efee8c4f7fc278a9eef82539dd5b7aa2", + "name": "navigator-updater", + "sha256": "d593e667c39ad6503c6ffb41f3672c9e6bc5d610036399e52a4cf0d9d930514a", + "size": 738686, + "subdir": "linux-64", + "timestamp": 1593556142641, + "version": "0.2.1" + }, + "navigator-updater-0.2.1-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "psutil", + "pyqt >=5.6", + "python >=3.8,<3.9.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "a62810f2fd1a592b0ae27589483920bd", + "name": "navigator-updater", + "sha256": "47789db0d1f325cf4dcb3c772530ccf90e0c48bb2d55c262cc82adf4cd657d09", + "size": 706745, + "subdir": "linux-64", + "timestamp": 1641980718513, + "version": "0.2.1" + }, + "navigator-updater-0.2.1-py39_1.conda": { + "build": "py39_1", + "build_number": 1, + "depends": [ + "psutil", + "pyqt >=5.6", + "python >=3.9,<3.10.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "ab1e92487b202d1cbf1da605c51e4a96", + "name": "navigator-updater", + "sha256": "877a4574c712ca86809757fcaeb0ec7443a9b8c5c63b5fcd7673967b51c69fd6", + "size": 703075, + "subdir": "linux-64", + "timestamp": 1641980718266, + "version": "0.2.1" + }, + "navigator-updater-0.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pyqt >=5.6", + "python >=3.9,<3.10.0a0", + "qtpy >=1.2" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "dde5f5211aaa6e8f781fd03c4f451ddc", + "name": "navigator-updater", + "sha256": "7df03666d048ecf3f0381b273ea3b9368305a862e98fbead426e2c5c9595f715", + "size": 704557, + "subdir": "linux-64", + "timestamp": 1608053504297, + "version": "0.2.1" + }, + "navigator-updater-0.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=17.5.0", + "cryptography >=3.3.2", + "libxml2 >=2.9.10", + "expat >=2.2.8", + "openssl >=1.1.1k", + "urllib3 >=1.26.4" + ], + "depends": [ + "conda", + "psutil >=5.6.5", + "pyqt >=5.6,<6.0a0", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "setuptools", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "259717c0799373c5f5a9c31c15265ea7", + "name": "navigator-updater", + "sha256": "1033b5d289e4aec4cbd2dfb6975afad1bed8450449af2cd7afc80ed152aa45dd", + "size": 2278049, + "subdir": "linux-64", + "timestamp": 1662476055423, + "version": "0.3.0" + }, + "navigator-updater-0.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=17.5.0", + "cryptography >=3.3.2", + "libxml2 >=2.9.10", + "expat >=2.2.8", + "openssl >=1.1.1k", + "urllib3 >=1.26.4" + ], + "depends": [ + "conda", + "psutil >=5.6.5", + "pyqt >=5.6,<6.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "setuptools", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "4f5b68fd13598634efc249701e0128b2", + "name": "navigator-updater", + "sha256": "8d80f694c0862f72f69dab31897b067f83ae4e0c9facfb71410fb567484c39fb", + "size": 2276400, + "subdir": "linux-64", + "timestamp": 1662476098419, + "version": "0.3.0" + }, + "navigator-updater-0.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=17.5.0", + "cryptography >=3.3.2", + "libxml2 >=2.9.10", + "expat >=2.2.8", + "openssl >=1.1.1k", + "urllib3 >=1.26.4" + ], + "depends": [ + "conda", + "psutil >=5.6.5", + "pyqt >=5.6,<6.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "setuptools", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "1f438ecf01b22ccdfe498acf4cec38f0", + "name": "navigator-updater", + "sha256": "cc134b463d02f80f99a3c7f98248dd0968df1bb0b1167a6f1664932c12ea97f1", + "size": 2276640, + "subdir": "linux-64", + "timestamp": 1662475991355, + "version": "0.3.0" + }, + "navigator-updater-0.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyopenssl >=17.5.0", + "cryptography >=3.3.2", + "libxml2 >=2.9.10", + "expat >=2.2.8", + "openssl >=1.1.1k", + "urllib3 >=1.26.4" + ], + "depends": [ + "conda", + "psutil >=5.6.5", + "pyqt >=5.6,<6.0a0", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.4", + "qtpy >=1.4.1", + "setuptools", + "ujson >=4.0.1" + ], + "license": "proprietary - Continuum Analytics, Inc.", + "license_family": "Proprietary", + "md5": "badb2483121cee1893cfa03d430d4225", + "name": "navigator-updater", + "sha256": "e6b2074c28d0f927411f0c91744db0a7f54c0e64a58cf2bfd4f93128e7233f6c", + "size": 2276888, + "subdir": "linux-64", + "timestamp": 1662475941081, + "version": "0.3.0" + }, + "nb_anacondacloud-1.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "130b2ec2f2566f48cd6a19ce03e2cba1", + "name": "nb_anacondacloud", + "sha256": "69614c4bb79f76c343ba96788002ce5bd70620b4969be2bc5d9e5cf2c7bbed8d", + "size": 29757, + "subdir": "linux-64", + "timestamp": 1641918412510, + "version": "1.4.0" + }, + "nb_anacondacloud-1.4.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "0f66ba85035bc679ae933e5b9c195a76", + "name": "nb_anacondacloud", + "sha256": "718b3e52df4963f0fc38c53d3823e87fd70e61ce675acc7ce2fae4b4575a371c", + "size": 35814, + "subdir": "linux-64", + "timestamp": 1676929504359, + "version": "1.4.0" + }, + "nb_anacondacloud-1.4.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "anaconda-client", + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "0dcfb0c8fec3c7774a4881b9cd34ed0c", + "name": "nb_anacondacloud", + "sha256": "476c2dbfc19ef303ee77493637c2f82de3c63e84635846e9dfd4621a992112b2", + "size": 28802, + "subdir": "linux-64", + "timestamp": 1594376401880, + "version": "1.4.0" + }, + "nb_anacondacloud-1.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b4e2abe3349c08715e6dadaef17fd8cb", + "name": "nb_anacondacloud", + "sha256": "130507fe877b38c12263a309b1da3eaf77bd4d0c7cec7b24959ea24a4184b0ed", + "size": 31507, + "subdir": "linux-64", + "timestamp": 1636039103552, + "version": "1.4.0" + }, + "nb_anacondacloud-1.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "21f2e1328b47283ae16ef361e612eb25", + "name": "nb_anacondacloud", + "sha256": "7d2ef307bfa07f9d12ea663f46070a4f3678f49437a1da27400e4558f779f784", + "size": 31458, + "subdir": "linux-64", + "timestamp": 1636039011538, + "version": "1.4.0" + }, + "nb_anacondacloud-1.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b6026f5d385f0f25e9a5d2be8d345ca8", + "name": "nb_anacondacloud", + "sha256": "8e39e054003549dc17327b1f0feace6b516c7ed6582793da10395e86a5be06fc", + "size": 31622, + "subdir": "linux-64", + "timestamp": 1636039103612, + "version": "1.4.0" + }, + "nb_conda-2.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "355aad17593613279abe372f09b82632", + "name": "nb_conda", + "sha256": "ac974e885843ca2029494424311e340a5b6ac41986fe3319bcf7e6280b8121f5", + "size": 32441, + "subdir": "linux-64", + "timestamp": 1530901089138, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py27hec22543_0.conda": { + "build": "py27hec22543_0", + "build_number": 0, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9edfc16ffbeb646f2f14f9b6fb2404da", + "name": "nb_conda", + "sha256": "cde7a1f962ee366c8dd7f4aaa7c2b41ab88b9bcb52f1b7486edf1a65676d36c5", + "size": 32724, + "subdir": "linux-64", + "timestamp": 1505746143309, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7dcc68323693120063bb23a96bf101e0", + "name": "nb_conda", + "sha256": "fb36f897cace85b4cf194644cda05f7bca2824a3eab373bfbd08ed034999a997", + "size": 33731, + "subdir": "linux-64", + "timestamp": 1641918478473, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "bc0bc0deea3b6554bace9ea4777eee97", + "name": "nb_conda", + "sha256": "8edbe9f1111b7584e5ad08ab7652cf35dd8b6423645a7038a2f2808ca35a906c", + "size": 39958, + "subdir": "linux-64", + "timestamp": 1676922449283, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py35hccc8299_0.conda": { + "build": "py35hccc8299_0", + "build_number": 0, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "md5": "077e11f07a6cfc64f9824c6517b082d3", + "name": "nb_conda", + "sha256": "376361cf275e23dfcdb0e1c20851a5431119ea3cfa79e0ac4aa5afa9e229dfe5", + "size": 33138, + "subdir": "linux-64", + "timestamp": 1505746162949, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "cb97738de9802120ae910b237979fdc4", + "name": "nb_conda", + "sha256": "0fb6454fc9513d02a4af86793e9e67c47ff23eaf9b532d23f07b338f6173372c", + "size": 32869, + "subdir": "linux-64", + "timestamp": 1530901047099, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py36h8118bb2_0.conda": { + "build": "py36h8118bb2_0", + "build_number": 0, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "99094b14557852865711241c73d1e058", + "name": "nb_conda", + "sha256": "051686e2017a10ddcf92b77d2de8550b8acf3652b76a3fb1230cb51f8340e1b0", + "size": 33034, + "subdir": "linux-64", + "timestamp": 1505746183638, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "eef81ad0497322a7c9badc1f96a1c968", + "name": "nb_conda", + "sha256": "93249572fa0e02faba43b0ba903bb40478108b126a47bb703e838e8898df1078", + "size": 32848, + "subdir": "linux-64", + "timestamp": 1530901005723, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "207e6f1f87ef5f007c440e256d2a957c", + "name": "nb_conda", + "sha256": "eac55116c592d7d75723d8b7ab5f368a25c362089ec0b0fef5ef0e746b867ca2", + "size": 33522, + "subdir": "linux-64", + "timestamp": 1636039129365, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "8aec01513effc9d853fd73abc41e229c", + "name": "nb_conda", + "sha256": "c90e70196fe6b03e8ed11ac04d580e7318ceb221782a6e958fec53a9d4ac3824", + "size": 33780, + "subdir": "linux-64", + "timestamp": 1597176851232, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c29cf4186300cd58614d2c741a0d6650", + "name": "nb_conda", + "sha256": "fefea92ef7cf3c2fc65f982bebcd27bd03aa69194cfe2dc0a45091b97dfef460", + "size": 34357, + "subdir": "linux-64", + "timestamp": 1636039102878, + "version": "2.2.1" + }, + "nb_conda-2.2.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "nb_conda_kernels >=2.0.0", + "notebook >=4.3.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "8dcaeff8a5ae9b82e9bc89eef7965567", + "name": "nb_conda", + "sha256": "40e6a15a027fbafca2e8a6f04a4f998e8a59547ce9096be7573f4b44a49e65c2", + "size": 33605, + "subdir": "linux-64", + "timestamp": 1636027104867, + "version": "2.2.1" + }, + "nb_conda_kernels-2.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "85ec8c75145547c4356746e6a55013fa", + "name": "nb_conda_kernels", + "sha256": "4e8ca5fddcb619737b2c134a5fee528b9ca765408172ed76f5851b0910fa67fa", + "size": 35249, + "subdir": "linux-64", + "timestamp": 1530900962715, + "version": "2.1.0" + }, + "nb_conda_kernels-2.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "025cff30bd65c6566ce18383eb39f2c5", + "name": "nb_conda_kernels", + "sha256": "42612a912a56af512fff9a250f585fa33a80674999dc5621873f424853e889f2", + "size": 35565, + "subdir": "linux-64", + "timestamp": 1530900930267, + "version": "2.1.0" + }, + "nb_conda_kernels-2.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "62833d55b8c616a8168c3d3cd9adc68d", + "name": "nb_conda_kernels", + "sha256": "8f5c6c888674dc7e76aa3ac68eb7b736cf9a9d89786d899bbd459da352d76d24", + "size": 35552, + "subdir": "linux-64", + "timestamp": 1530900896590, + "version": "2.1.0" + }, + "nb_conda_kernels-2.1.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "edc3b0a909bd0804bad94312a419b12d", + "name": "nb_conda_kernels", + "sha256": "556d4830bc9063fa3ffd0bbc4b6857b61ad2cfa8ee02cd6aa7ddd10a3de80048", + "size": 37939, + "subdir": "linux-64", + "timestamp": 1539189679365, + "version": "2.1.1" + }, + "nb_conda_kernels-2.1.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0c93d60df4960805e46e8411a84b23e8", + "name": "nb_conda_kernels", + "sha256": "f57ea76ba8423ede6cac52a222a649fb84c74edaf0c60e0f8409f502558d39cb", + "size": 38048, + "subdir": "linux-64", + "timestamp": 1539189690708, + "version": "2.1.1" + }, + "nb_conda_kernels-2.1.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0ff8e9ac9fda6b65bceaf20031beea83", + "name": "nb_conda_kernels", + "sha256": "f4ff9754e0cd23b79681ab2e6fbb33756fd645f0ac562245f7c4f57eecb0dab6", + "size": 38119, + "subdir": "linux-64", + "timestamp": 1539189688153, + "version": "2.1.1" + }, + "nb_conda_kernels-2.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ad46ef8111571e25dd43035d06bad19f", + "name": "nb_conda_kernels", + "sha256": "c9446c3449b87930135fda517b0fd1641553d9445981201fe14d00902b954695", + "size": 34430, + "subdir": "linux-64", + "timestamp": 1541446970833, + "version": "2.2.0" + }, + "nb_conda_kernels-2.2.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "90c0bbfd4f6fb8818281cd873d03f82d", + "name": "nb_conda_kernels", + "sha256": "2b440619f8a2ce78f93647612acb10bf839a81cdfd6fcddee530f44fa3b75ac9", + "size": 38913, + "subdir": "linux-64", + "timestamp": 1549986906228, + "version": "2.2.0" + }, + "nb_conda_kernels-2.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bc319c18c221f8503a4ba5cb5ef4d15c", + "name": "nb_conda_kernels", + "sha256": "989c181d5aa5a89820d4546dd321bffe2b93267c159480a4ecdced0a2efdd97e", + "size": 34525, + "subdir": "linux-64", + "timestamp": 1541446995398, + "version": "2.2.0" + }, + "nb_conda_kernels-2.2.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0b51d461811a7a794a9274b8f4a2f84f", + "name": "nb_conda_kernels", + "sha256": "6afe679d422b98f5a097b832d4c6fbda4631d01098fae3500ebf7107f9c27302", + "size": 39110, + "subdir": "linux-64", + "timestamp": 1549986911389, + "version": "2.2.0" + }, + "nb_conda_kernels-2.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3b525a514ed3239326dbf3166019f92a", + "name": "nb_conda_kernels", + "sha256": "9ef30d3fe979d9b7dfc5ce6d6d54e00f78b6e39335a761ec88f5aa809f9801a7", + "size": 34639, + "subdir": "linux-64", + "timestamp": 1541446954077, + "version": "2.2.0" + }, + "nb_conda_kernels-2.2.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5d7ec70fdbf00525461656b0f66e1815", + "name": "nb_conda_kernels", + "sha256": "8e7efe17342b591891b3824d0032fc80a0f3a3256cbe12c6fd0f83d50c609476", + "size": 39215, + "subdir": "linux-64", + "timestamp": 1549986892056, + "version": "2.2.0" + }, + "nb_conda_kernels-2.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "de1958503131a492cf96da189a76cd66", + "name": "nb_conda_kernels", + "sha256": "fdc5eb56dbe68fa4d69ff4dab5ab0286657abc864337cf6d3e713e8314c48f95", + "size": 39216, + "subdir": "linux-64", + "timestamp": 1556291027105, + "version": "2.2.1" + }, + "nb_conda_kernels-2.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7e22d0f8027899ff11b4f4fa66a2e9c3", + "name": "nb_conda_kernels", + "sha256": "89c9fac9dbc0748ac204d80a1332924bc45c4e01b89acaa9f253f417882b8226", + "size": 39264, + "subdir": "linux-64", + "timestamp": 1556291055922, + "version": "2.2.1" + }, + "nb_conda_kernels-2.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "838a84f59fa693259bdca2408148e1e6", + "name": "nb_conda_kernels", + "sha256": "272a685e7b3afca83d73daeadbe0dc54c4ee2ba91b7a723b6b44c16547ed3c96", + "size": 39425, + "subdir": "linux-64", + "timestamp": 1556291024643, + "version": "2.2.1" + }, + "nb_conda_kernels-2.2.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7ab99a951c00062daa107c0261100fff", + "name": "nb_conda_kernels", + "sha256": "2adb9114ad9adf765c031dc243a2962a4f6b99cecb9a94214a92e3554a97e4a1", + "size": 39840, + "subdir": "linux-64", + "timestamp": 1559921265476, + "version": "2.2.2" + }, + "nb_conda_kernels-2.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "34586005a2098c327594bf35b9c9cce7", + "name": "nb_conda_kernels", + "sha256": "d0bafd778b8859bde74aab43008b3b39082de20df9ab6343f584d7514d9c6b77", + "size": 39955, + "subdir": "linux-64", + "timestamp": 1559921284807, + "version": "2.2.2" + }, + "nb_conda_kernels-2.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "037fda6b914798ba5fc2ce096597f820", + "name": "nb_conda_kernels", + "sha256": "96ef1844b94f105a9d18a8afded009578fbc86fd726653fb8823986ff8c8a725", + "size": 39983, + "subdir": "linux-64", + "timestamp": 1559921258304, + "version": "2.2.2" + }, + "nb_conda_kernels-2.2.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "edada00c873bd940cfcca7737e313768", + "name": "nb_conda_kernels", + "sha256": "746d43f5ac5ef72cd0f7a8c2c61b1301fb6f64dab3f497f897ff0446c9683e8d", + "size": 39751, + "subdir": "linux-64", + "timestamp": 1585176300019, + "version": "2.2.3" + }, + "nb_conda_kernels-2.2.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8b331143120b8480491c4f853794d21d", + "name": "nb_conda_kernels", + "sha256": "065f93139ddfad4e756ac1868aaebdce4f482d437f201adc0a3b2c040842b2de", + "size": 39552, + "subdir": "linux-64", + "timestamp": 1585176246222, + "version": "2.2.3" + }, + "nb_conda_kernels-2.2.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c77f92fb7797f9c5670c27fe1af78572", + "name": "nb_conda_kernels", + "sha256": "4b3c529d3a75e96af72338443abc1fd73d93750ca0980a3c32ff876fb78b5c00", + "size": 39795, + "subdir": "linux-64", + "timestamp": 1585176297827, + "version": "2.2.3" + }, + "nb_conda_kernels-2.2.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "20d4e4aa1575f16f3b8ff9ca477c94e3", + "name": "nb_conda_kernels", + "sha256": "5d02330e7fdf3b94e0109fec862e81bd8efa67ff35624c85fafee48cd3dfb5f9", + "size": 29487, + "subdir": "linux-64", + "timestamp": 1598624818995, + "version": "2.2.4" + }, + "nb_conda_kernels-2.2.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c404323a6316addaf8cf8f06039fd052", + "name": "nb_conda_kernels", + "sha256": "4ad1669814747b2398c661a4adabd1de44e728abc840b0efb108b75cbb2a9805", + "size": 29641, + "subdir": "linux-64", + "timestamp": 1598624835807, + "version": "2.2.4" + }, + "nb_conda_kernels-2.2.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5c9e460a74c2102d129fc24b48fd1463", + "name": "nb_conda_kernels", + "sha256": "b01126914aea232071df4e414a53c4134aa3660d20c559e2038211e4bf6e1cdb", + "size": 29735, + "subdir": "linux-64", + "timestamp": 1598624798573, + "version": "2.2.4" + }, + "nb_conda_kernels-2.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a08e07a1b199b34551bc2225ad107c78", + "name": "nb_conda_kernels", + "sha256": "9ceed6587fdf2d453b02212157eada36310595872ef083155e67fdb387c45446", + "size": 26181, + "subdir": "linux-64", + "timestamp": 1600445383416, + "version": "2.3.0" + }, + "nb_conda_kernels-2.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d37a41de605874aca8db575496dc56b1", + "name": "nb_conda_kernels", + "sha256": "55a95c21ca08ba1ffd44414dced346ef15548e8719846b25eeea5e6cd311733a", + "size": 26230, + "subdir": "linux-64", + "timestamp": 1600445367338, + "version": "2.3.0" + }, + "nb_conda_kernels-2.3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "331de7cffc061da4963d4b2d94666f1d", + "name": "nb_conda_kernels", + "sha256": "dc20236ffc4c2ee04941fe95811599d809df20c7aa30e3651fee9a076ad765c1", + "size": 26433, + "subdir": "linux-64", + "timestamp": 1600445366743, + "version": "2.3.0" + }, + "nb_conda_kernels-2.3.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cb2e2a3c4120a33751925823de087e73", + "name": "nb_conda_kernels", + "sha256": "49b982fd790686e6cfc6be1cf0add77aeea3b2bb68c82f0d10645139d3a78b27", + "size": 28263, + "subdir": "linux-64", + "timestamp": 1640815352004, + "version": "2.3.1" + }, + "nb_conda_kernels-2.3.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "md5": "859bc7275d90ad05a0deaef0f6081ac8", + "name": "nb_conda_kernels", + "sha256": "786638bf3f190f20ec5335a9f1256d71320c69c51a97468a6fda334e6495c22c", + "size": 35039, + "subdir": "linux-64", + "timestamp": 1676845038638, + "version": "2.3.1" + }, + "nb_conda_kernels-2.3.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8681729897a44b889b1fcd44bac63ea4", + "name": "nb_conda_kernels", + "sha256": "632a4e1a7c243184761f3668b98474d7f8860742906011412ad9758ed577a975", + "size": 28190, + "subdir": "linux-64", + "timestamp": 1606776021501, + "version": "2.3.1" + }, + "nb_conda_kernels-2.3.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e247b2b99814062175030bdd185d2af8", + "name": "nb_conda_kernels", + "sha256": "e0f0e56f73ffe7e733277a0c4fdb7e714367ba531f6e44e3d3af00d27296188e", + "size": 28107, + "subdir": "linux-64", + "timestamp": 1606776024500, + "version": "2.3.1" + }, + "nb_conda_kernels-2.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "887ab6c9e5b089cf8e897901444c14a7", + "name": "nb_conda_kernels", + "sha256": "9d6102b7577865278a6dd9c3037ab7e9054e19f4882d0c0b0ad7cc25355037c5", + "size": 28270, + "subdir": "linux-64", + "timestamp": 1606775970765, + "version": "2.3.1" + }, + "nb_conda_kernels-2.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "18cf60951b87c0f71b449a67c2ec19f4", + "name": "nb_conda_kernels", + "sha256": "6fe8cd663cc2e1fff7ec7f1f601c63d8caccfa06e576c4f7497464861e3bbbe7", + "size": 33454, + "subdir": "linux-64", + "timestamp": 1636035820383, + "version": "2.3.1" + }, + "nbclassic-0.4.8-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3c65da9d1105f40737b03255775381f4", + "name": "nbclassic", + "sha256": "bbc628162a0641bbc4b1a068df78e6e3dbc37981d54c5fb9e32c11241d1ad940", + "size": 6092302, + "subdir": "linux-64", + "timestamp": 1668175216755, + "version": "0.4.8" + }, + "nbclassic-0.4.8-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ebf5b6a98af8950faba15da2c755cc8d", + "name": "nbclassic", + "sha256": "f4255976e3cc2274f5dd5207e9521a1a65c031b4b79efe8512b1a4ad41eb990b", + "size": 5322710, + "subdir": "linux-64", + "timestamp": 1676825366127, + "version": "0.4.8" + }, + "nbclassic-0.4.8-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c5bff72fbe96e910984f164a162efc16", + "name": "nbclassic", + "sha256": "800dc6f83fed88a6f03f4f64e35a91dda17a601c5d4a2442f6dcd169e308b698", + "size": 6107178, + "subdir": "linux-64", + "timestamp": 1668175011997, + "version": "0.4.8" + }, + "nbclassic-0.4.8-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1fdf56efe6822a80eccca773678a604f", + "name": "nbclassic", + "sha256": "9140a1254d62af76752f6c72c1374063f4e68c42b779d45658d42a5829871c29", + "size": 6107462, + "subdir": "linux-64", + "timestamp": 1668175149287, + "version": "0.4.8" + }, + "nbclassic-0.4.8-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7a24034f052298de3cef0e38c890c079", + "name": "nbclassic", + "sha256": "4edf8195a93f1e062f5b4e4c7c274b0a586119b7e392d73e32725c1aa2662d55", + "size": 6111372, + "subdir": "linux-64", + "timestamp": 1668175081374, + "version": "0.4.8" + }, + "nbclassic-0.5.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f7cbdca55e3781f5b1c7d5e4c6a8c22c", + "name": "nbclassic", + "sha256": "67471a56284130e5d1a42152738b2ec3a580154ac9e2369bc019d8d78b9a5676", + "size": 6349881, + "subdir": "linux-64", + "timestamp": 1676903214164, + "version": "0.5.2" + }, + "nbclassic-0.5.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6de7b1b4be1a1ab16cb9d16e8b49a056", + "name": "nbclassic", + "sha256": "741e7faa515f94032b7bf9580e096352f63b3f8bb7c11967f37f488a920746ec", + "size": 6443332, + "subdir": "linux-64", + "timestamp": 1678983537685, + "version": "0.5.2" + }, + "nbclassic-0.5.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0bc0c8e7717709d42b8bfa3094231d52", + "name": "nbclassic", + "sha256": "f599c600ec3fe5361b39454b2ebf18c5233ede6ae7831c0c472b79597c93a0e6", + "size": 6349944, + "subdir": "linux-64", + "timestamp": 1676903058740, + "version": "0.5.2" + }, + "nbclassic-0.5.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1a613bc5ad33b3000ee8110189fe984c", + "name": "nbclassic", + "sha256": "6b19263c5c64241a0cd5e95a0e7ea7197a1312ce13c2269fca258f8e19219c76", + "size": 6349002, + "subdir": "linux-64", + "timestamp": 1676902974274, + "version": "0.5.2" + }, + "nbclassic-0.5.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.17.0", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d43b24acd4016a06b4f89550e26480a", + "name": "nbclassic", + "sha256": "45e4b8307d1c93b1784b9a8f556e55fd0f7d71d3c59a3d072e5bb2396d3c3938", + "size": 6360840, + "subdir": "linux-64", + "timestamp": 1676903136597, + "version": "0.5.2" + }, + "nbclassic-0.5.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.8", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3441c4b542ace88b03ea03d3cfdb7acb", + "name": "nbclassic", + "sha256": "0015c488680656a59f15a091062b32ab2d7c484a6a06b521ca2153b3bff7a3f5", + "size": 6429900, + "subdir": "linux-64", + "timestamp": 1680009103075, + "version": "0.5.3" + }, + "nbclassic-0.5.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.8", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "69fb68f70e8dae61173653b846e17085", + "name": "nbclassic", + "sha256": "4b0c7dca93167c1aa648d90432e1ca7a6949634b5b33e43451d819d8ecd7f6b6", + "size": 6489551, + "subdir": "linux-64", + "timestamp": 1680008849118, + "version": "0.5.3" + }, + "nbclassic-0.5.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.8", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "507034d9a43f6521d8e6c0ce9f6c7283", + "name": "nbclassic", + "sha256": "dc2b01569e5797029f0a241e9215d4d82b4a5ccf4644133ef2a73da66a12229a", + "size": 6431635, + "subdir": "linux-64", + "timestamp": 1680008932793, + "version": "0.5.3" + }, + "nbclassic-0.5.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.8", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7d732b5198fa22b63a46556d75c1426b", + "name": "nbclassic", + "sha256": "967660d9df0db13ac3102eb974957dcac20e8981b52c8e82bb0f29a90fd44d88", + "size": 6429263, + "subdir": "linux-64", + "timestamp": 1680009018302, + "version": "0.5.3" + }, + "nbclassic-0.5.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.8", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "af9b1759b15f195eb33379c9078c0e6e", + "name": "nbclassic", + "sha256": "0531df73e15fa0100a2240614aaab051337689479554ccb2bdf677459daf28ab", + "size": 6481795, + "subdir": "linux-64", + "timestamp": 1680622955710, + "version": "0.5.4" + }, + "nbclassic-0.5.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.8", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ef34055d9658e00da3a0ef7d3b76a994", + "name": "nbclassic", + "sha256": "3899c7c271a4ef0ced44e26c976981a521c81e2b0f2bc3b30e18621c374215b9", + "size": 6523726, + "subdir": "linux-64", + "timestamp": 1680622864320, + "version": "0.5.4" + }, + "nbclassic-0.5.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.8", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9b276015895d289e9f5dbe9765a2b919", + "name": "nbclassic", + "sha256": "2e2da27f8221584b07cff343682457dad3dd58f75a28981bf8027530d3ba89d9", + "size": 6480598, + "subdir": "linux-64", + "timestamp": 1680623048427, + "version": "0.5.4" + }, + "nbclassic-0.5.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=6.1.1", + "jupyter_core >=4.6.1", + "jupyter_server >=1.8", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "notebook-shim >=0.1.0", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a10f8154f5798fe4384a7af93c7240f", + "name": "nbclassic", + "sha256": "88de25fa40664d13fca4eea9ccb062784ff5b20377fb5f750c7d31964d63d987", + "size": 6479001, + "subdir": "linux-64", + "timestamp": 1680622772030, + "version": "0.5.4" + }, + "nbclient-0.5.13-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=6.1.5", + "nbformat >=5.0", + "nest-asyncio", + "python >=3.10,<3.11.0a0", + "traitlets >=5.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "91a8151509de96d0f2d89ae889ea8cc4", + "name": "nbclient", + "sha256": "36ea6780a98d968788e452b997f09c0b2c43cc09809c5683611fb0c728acff76", + "size": 92636, + "subdir": "linux-64", + "timestamp": 1650290293630, + "version": "0.5.13" + }, + "nbclient-0.5.13-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=6.1.5", + "nbformat >=5.0", + "nest-asyncio", + "python >=3.11,<3.12.0a0", + "traitlets >=5.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0dd9c47f6e3d171cf4090f3225c915f6", + "name": "nbclient", + "sha256": "de00871358ae79d774578540bcba99f28b15c11a05b927ac9c87a8c8558cd600", + "size": 110376, + "subdir": "linux-64", + "timestamp": 1676823727061, + "version": "0.5.13" + }, + "nbclient-0.5.13-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=6.1.5", + "nbformat >=5.0", + "nest-asyncio", + "python >=3.7,<3.8.0a0", + "traitlets >=5.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee98084c6e459d0126cc2e160ae2b14f", + "name": "nbclient", + "sha256": "2b9c320011a86d811bbfd556614aaa89fa206df7b33dc36fd7b6e7626840ba4a", + "size": 92815, + "subdir": "linux-64", + "timestamp": 1650308409006, + "version": "0.5.13" + }, + "nbclient-0.5.13-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=6.1.5", + "nbformat >=5.0", + "nest-asyncio", + "python >=3.8,<3.9.0a0", + "traitlets >=5.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a0606d4de8c491a8381e72f7925000ca", + "name": "nbclient", + "sha256": "23732074c1f78570b16595b16cb1cf9b8b0f39c0dae83731bfd07bf324f4c20f", + "size": 93269, + "subdir": "linux-64", + "timestamp": 1650308401439, + "version": "0.5.13" + }, + "nbclient-0.5.13-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_client >=6.1.5", + "nbformat >=5.0", + "nest-asyncio", + "python >=3.9,<3.10.0a0", + "traitlets >=5.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5a8537d74e702b61fa3f50bc32cde091", + "name": "nbclient", + "sha256": "27060f5aacb3f29ae5a876b78cc5b2d1ebb49146689ed0637fb413f642087846", + "size": 93239, + "subdir": "linux-64", + "timestamp": 1650290544347, + "version": "0.5.13" + }, + "nbconvert-5.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bleach", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_client >=4.2", + "jupyter_core", + "mistune >0.6", + "nbformat", + "pandoc", + "pandocfilters >=1.4.1", + "pygments", + "python >=2.7,<2.8.0a0", + "testpath", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "b319aeb64a5415c37aa9a342eaa063bc", + "name": "nbconvert", + "sha256": "cdd107010c36036c48205db3a5fb91bc8b32e0a53f7f5ed4d58baf8e219afe5c", + "size": 393952, + "subdir": "linux-64", + "timestamp": 1530734567194, + "version": "5.3.1" + }, + "nbconvert-5.3.1-py27he041f76_0.conda": { + "build": "py27he041f76_0", + "build_number": 0, + "depends": [ + "bleach", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_client >=4.2", + "jupyter_core", + "mistune >0.6", + "nbformat", + "pandoc", + "pandocfilters >=1.4.1", + "pygments", + "python >=2.7,<2.8.0a0", + "testpath", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "ed6ca0b60472a918a90f8c0c00302d8e", + "name": "nbconvert", + "sha256": "f06261563610e19a6abc689532610787322c8436d4862abb97ed0978223dad74", + "size": 388579, + "subdir": "linux-64", + "timestamp": 1506349847685, + "version": "5.3.1" + }, + "nbconvert-5.3.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bleach", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_client >=4.2", + "jupyter_core", + "mistune >0.6", + "nbformat", + "pandoc", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.5,<3.6.0a0", + "testpath", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "389db26c9d4692fa9789fe9b6586c5e1", + "name": "nbconvert", + "sha256": "a490793e4f889b2310c9edaddd0211faa8a223923adfb55255f8983f636ea8b6", + "size": 398262, + "subdir": "linux-64", + "timestamp": 1534350963834, + "version": "5.3.1" + }, + "nbconvert-5.3.1-py35hc5194e3_0.conda": { + "build": "py35hc5194e3_0", + "build_number": 0, + "depends": [ + "bleach", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_client >=4.2", + "jupyter_core", + "mistune >0.6", + "nbformat", + "pandoc", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.5,<3.6.0a0", + "testpath", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "40e75b33749398c6d25745e9fd062b2c", + "name": "nbconvert", + "sha256": "68384f7183922d637925cb52f5ad6361407ea8c8f2e7072018cb4738b1317285", + "size": 391990, + "subdir": "linux-64", + "timestamp": 1506349862073, + "version": "5.3.1" + }, + "nbconvert-5.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bleach", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_client >=4.2", + "jupyter_core", + "mistune >0.6", + "nbformat", + "pandoc", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "8cb5fbd0446428c34ce7697c4e41cad4", + "name": "nbconvert", + "sha256": "75588020ed44c797083072073b02488b750b06dc3ed778d0c4ae4940e96c79ed", + "size": 393047, + "subdir": "linux-64", + "timestamp": 1530734538176, + "version": "5.3.1" + }, + "nbconvert-5.3.1-py36hb41ffb7_0.conda": { + "build": "py36hb41ffb7_0", + "build_number": 0, + "depends": [ + "bleach", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_client >=4.2", + "jupyter_core", + "mistune >0.6", + "nbformat", + "pandoc", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "25230911e8b655457f3eb31989c7b809", + "name": "nbconvert", + "sha256": "bbacea22848dff1058b0597fe681d31580cf197c21979956a7feb6c178c390f3", + "size": 391003, + "subdir": "linux-64", + "timestamp": 1506349856326, + "version": "5.3.1" + }, + "nbconvert-5.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bleach", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_client >=4.2", + "jupyter_core", + "mistune >0.6", + "nbformat", + "pandoc", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "38ea937ac6f9fefecb456fc056e2d063", + "name": "nbconvert", + "sha256": "52d27420e311386d552326ec2644889c1382cc1f6d8be626b98865606e8528a1", + "size": 392845, + "subdir": "linux-64", + "timestamp": 1530734600578, + "version": "5.3.1" + }, + "nbconvert-5.4.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1,<2.0.0", + "pandocfilters >=1.4.1", + "pygments", + "python >=2.7,<2.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "2a21ffaea0b3a8fe62cca4dd6c223f3b", + "name": "nbconvert", + "sha256": "a40fc9fea0e6b571ca6ffe253e79aad91f01c6e55cc3c2ab97edbf543db1bb98", + "size": 403176, + "subdir": "linux-64", + "timestamp": 1536785669537, + "version": "5.4.0" + }, + "nbconvert-5.4.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1,<2.0.0", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.5,<3.6.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "1e6b665e52856fafbdd912eba74406cc", + "name": "nbconvert", + "sha256": "b8bb3d38f46c00afdda8f97cbb525cfff8a9d969b9729840b235ec7489b1df8b", + "size": 406242, + "subdir": "linux-64", + "timestamp": 1536786577366, + "version": "5.4.0" + }, + "nbconvert-5.4.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1,<2.0.0", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "57b4c7e23dfaa8dadc04e355a3076663", + "name": "nbconvert", + "sha256": "33877b58018095c78fcaab223cbcb0d0d9685f551f0a808e19ee8abe8fcc0db9", + "size": 403167, + "subdir": "linux-64", + "timestamp": 1536785716634, + "version": "5.4.0" + }, + "nbconvert-5.4.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1,<2.0.0", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "9a0d3967acffc0ebaa1aeea2d9799d48", + "name": "nbconvert", + "sha256": "b31557d6ed73a58f7f5924d6ccb0ff92d72740c91b8a73f0001c3c297f1549fd", + "size": 403036, + "subdir": "linux-64", + "timestamp": 1536785660886, + "version": "5.4.0" + }, + "nbconvert-5.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1,<2.0.0", + "pandocfilters >=1.4.1", + "pygments", + "python >=2.7,<2.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "a8b587040c1fb1c365f7117969e90362", + "name": "nbconvert", + "sha256": "7a8a4734c01090f119a5fd75a3e40defaac457a8ea11f886cbb60af384176d3f", + "size": 409140, + "subdir": "linux-64", + "timestamp": 1551142563791, + "version": "5.4.1" + }, + "nbconvert-5.4.1-py27_3.conda": { + "build": "py27_3", + "build_number": 3, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=2.7,<2.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "16843a25ec9d964e30028c83622ec250", + "name": "nbconvert", + "sha256": "439d2c094246aeea7e71a457aa899b1cb835657021000adfea418f4979941676", + "size": 410204, + "subdir": "linux-64", + "timestamp": 1553303867011, + "version": "5.4.1" + }, + "nbconvert-5.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1,<2.0.0", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "1178e8be5ee35bde2e85a202f08eb93f", + "name": "nbconvert", + "sha256": "a73a46503b96a9422d7345b95eb7d8b4618caeea2942ee333d596f249be150c7", + "size": 409532, + "subdir": "linux-64", + "timestamp": 1551142602051, + "version": "5.4.1" + }, + "nbconvert-5.4.1-py36_3.conda": { + "build": "py36_3", + "build_number": 3, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "5d24ba1b08b2f510d5de86a093bba4dd", + "name": "nbconvert", + "sha256": "07ca244e304abcd3b0b2b859b977795b9e6d51ef06d80fa18b7a061623e3d549", + "size": 413231, + "subdir": "linux-64", + "timestamp": 1553304165737, + "version": "5.4.1" + }, + "nbconvert-5.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1,<2.0.0", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "9a832766cb8e4f19a7918cc74a0417bb", + "name": "nbconvert", + "sha256": "68cf0720f5fe24157a503b39decc4b8e3ffbd0af97cd99db60b0c4ec8b8b3a01", + "size": 410915, + "subdir": "linux-64", + "timestamp": 1551142541224, + "version": "5.4.1" + }, + "nbconvert-5.4.1-py37_3.conda": { + "build": "py37_3", + "build_number": 3, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "285b5ceb0229e9fea95c71b3766fd4d3", + "name": "nbconvert", + "sha256": "1af104682d0d4c4828d01277640c8ace29b0d105fa6c7f1bad57b09507c137d5", + "size": 413333, + "subdir": "linux-64", + "timestamp": 1553304078176, + "version": "5.4.1" + }, + "nbconvert-5.6.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=2.7,<2.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "5c1029eedcd319604f3c4bfbd01d4fc7", + "name": "nbconvert", + "sha256": "11573100fed9a4559d9144896d544db489ea0476aafec2f88e367eb83c49eb6c", + "size": 465913, + "subdir": "linux-64", + "timestamp": 1569265834887, + "version": "5.6.0" + }, + "nbconvert-5.6.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "ecb277ec538d4a81986af1600736b222", + "name": "nbconvert", + "sha256": "70d780db6f927a93f46e87ff3aa850d1fd7eac681d2ce15cb06b53363fce9e8a", + "size": 469643, + "subdir": "linux-64", + "timestamp": 1569265835117, + "version": "5.6.0" + }, + "nbconvert-5.6.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "328158666c1f5beeb2d3e9ad2c5635cf", + "name": "nbconvert", + "sha256": "c9f37dd58e77767717331e9416fb03ceb4d3c0e7f697ff2b6475feedf7668c1f", + "size": 469695, + "subdir": "linux-64", + "timestamp": 1569265837533, + "version": "5.6.0" + }, + "nbconvert-5.6.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=2.7,<2.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "a4bb1d9ea449228cd89ecb88f7357e04", + "name": "nbconvert", + "sha256": "2d25c8f7431bb155eab8f3f34d2c8fcf22abf1a4d683a4d5fb6f595e776726b8", + "size": 466326, + "subdir": "linux-64", + "timestamp": 1573063172289, + "version": "5.6.1" + }, + "nbconvert-5.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "651b4527a0f091f2a27fb7a03817b252", + "name": "nbconvert", + "sha256": "dff49f83ae8f9d16a63092e60f56c497cec547843370b47b3c986c15a8bd30a3", + "size": 470690, + "subdir": "linux-64", + "timestamp": 1573063138658, + "version": "5.6.1" + }, + "nbconvert-5.6.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "e3aa4350b1ee1eb0f4a2cc0091f7781d", + "name": "nbconvert", + "sha256": "d3c14cd89b2f7ad644f478b01af92847cd69a90bd0510652c0867f36783d291e", + "size": 469853, + "subdir": "linux-64", + "timestamp": 1573063116156, + "version": "5.6.1" + }, + "nbconvert-5.6.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "dffb872b4964ab468cbabb9ecb0a3697", + "name": "nbconvert", + "sha256": "80fadeb73a0f5cdfec31706c2e70c5e252d46e44bdab16271015b2aa65a0b34c", + "size": 462287, + "subdir": "linux-64", + "timestamp": 1594376844643, + "version": "5.6.1" + }, + "nbconvert-5.6.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2", + "jupyter_core", + "mistune >=0.8.1", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "51c3e01f107648c5a60704aa8b1c14bc", + "name": "nbconvert", + "sha256": "7bdf7510003bfc5186c0af4d3311d4bcb96b96a7a2cbe5a7f494c79ab08f1dee", + "size": 466668, + "subdir": "linux-64", + "timestamp": 1573572301607, + "version": "5.6.1" + }, + "nbconvert-6.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "9fb618f93a699432da9133ee5527d93a", + "name": "nbconvert", + "sha256": "c29dd328dfc63ef5df4396e090cb453fcfc8d6361c805017558dab60322cf983", + "size": 493184, + "subdir": "linux-64", + "timestamp": 1601068915180, + "version": "6.0.3" + }, + "nbconvert-6.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "8020f5d21c82bf9e1ab480cc4f3947a6", + "name": "nbconvert", + "sha256": "5a8cfcd66dd4a558b5134aac9b9af3447da98293876577ed57987a842f2d2777", + "size": 490100, + "subdir": "linux-64", + "timestamp": 1601068930254, + "version": "6.0.3" + }, + "nbconvert-6.0.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "65e230be4cd733caba3bfd4fe58e5f9c", + "name": "nbconvert", + "sha256": "cb123b1962f79677729b4ed5d25f22da3c9011cbe16e30a083203ebb8527dd67", + "size": 492709, + "subdir": "linux-64", + "timestamp": 1601061800309, + "version": "6.0.3" + }, + "nbconvert-6.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "632d4b240b55701b691226671de63f70", + "name": "nbconvert", + "sha256": "dbf734fc27a4f88fc1bca75627d6f5399a21ba815dcb0a47bec3cb98eb28482d", + "size": 488598, + "subdir": "linux-64", + "timestamp": 1601069248587, + "version": "6.0.4" + }, + "nbconvert-6.0.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "e55b7a93e5ea58d3b71955e3b64c0d6a", + "name": "nbconvert", + "sha256": "91a485b001f014e8c237ef90632eb492012e823c85ca5c4abe69868b088a5a44", + "size": 492771, + "subdir": "linux-64", + "timestamp": 1601069203621, + "version": "6.0.4" + }, + "nbconvert-6.0.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "82559e6257ba07399d31a461711596a8", + "name": "nbconvert", + "sha256": "23160ff9006c393b28b9d9151a158df2d3209125d06d1ba4522e0a0a58e6fe53", + "size": 493763, + "subdir": "linux-64", + "timestamp": 1601069197786, + "version": "6.0.4" + }, + "nbconvert-6.0.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "663d80ed957250f1ba2aedd52b1c8896", + "name": "nbconvert", + "sha256": "702478b2796455e66c6bb188ebb1e7a6ac6c43b44dc5412d200cdba8821bba2c", + "size": 490666, + "subdir": "linux-64", + "timestamp": 1601069247664, + "version": "6.0.5" + }, + "nbconvert-6.0.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "d1a0cfdf214d7512d3cba3200853e101", + "name": "nbconvert", + "sha256": "1a6d3614e39b7f831852b4400022a52f1087332aa75d557953e9485665fa38ff", + "size": 491231, + "subdir": "linux-64", + "timestamp": 1601069258337, + "version": "6.0.5" + }, + "nbconvert-6.0.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "5cc27f458ab8569547cfcb5cded2c791", + "name": "nbconvert", + "sha256": "c0aa1b7a66dc220d809784b7817d3afd53a9dd26db1a03ad841dada01f500c82", + "size": 496089, + "subdir": "linux-64", + "timestamp": 1601069244678, + "version": "6.0.5" + }, + "nbconvert-6.0.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "f96ea053d3b9ad69b5d1140dfaa859e9", + "name": "nbconvert", + "sha256": "926d78faf2dc4ad00b0f0c377266dbf05e59301fcfd6b96d6fe63115cc767e51", + "size": 496557, + "subdir": "linux-64", + "timestamp": 1601069221306, + "version": "6.0.6" + }, + "nbconvert-6.0.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "da6693fcbe363643030fcf65d048e42e", + "name": "nbconvert", + "sha256": "ab5188f91e4bd065ca43d458cb084bd06bac6dfa2d27a3dcb66957e2301cde4e", + "size": 494355, + "subdir": "linux-64", + "timestamp": 1601069160773, + "version": "6.0.6" + }, + "nbconvert-6.0.6-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "62a952b72cd3018e968df747b687cfe9", + "name": "nbconvert", + "sha256": "650788d7489fe48dfcc31bb134bd2cbd426462b73c52d1e13d73215b6b7c8d3f", + "size": 497088, + "subdir": "linux-64", + "timestamp": 1601069235170, + "version": "6.0.6" + }, + "nbconvert-6.0.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.6,<3.7.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "73609b06f46cd7e387edea6db3c8d4c4", + "name": "nbconvert", + "sha256": "4d343905ca2122f588eaf6543520603f53273d4dde3e0c6b54c2980ee4b4a9b1", + "size": 491656, + "subdir": "linux-64", + "timestamp": 1601914836882, + "version": "6.0.7" + }, + "nbconvert-6.0.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "de05e29355b4e83fad18b02774b299e8", + "name": "nbconvert", + "sha256": "4f4dd38315145d8593b7082ea7b5971fbbb69e0ca943afd8b439aad79d2ecdb1", + "size": 495805, + "subdir": "linux-64", + "timestamp": 1601914850146, + "version": "6.0.7" + }, + "nbconvert-6.0.7-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "f40d21b65e2ef1f25cc0b91ad84d76ce", + "name": "nbconvert", + "sha256": "bfa9e7bba5ac508b03fe3583e643ec7cc525409784a7ef52c725541f6a10b9fe", + "size": 492458, + "subdir": "linux-64", + "timestamp": 1601914861723, + "version": "6.0.7" + }, + "nbconvert-6.0.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandoc >=1.12.1", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.9,<3.10.0a0", + "testpath", + "traitlets >=4.2" + ], + "license": "BSD-3-Clause", + "md5": "32a0ada1afcbac9e6b58bc3fb898f08c", + "name": "nbconvert", + "sha256": "7db21e8f0e26aa1b839c7fe19996dd1bd75bdfabc42bb1caa673353346d6d2ed", + "size": 500112, + "subdir": "linux-64", + "timestamp": 1607370468907, + "version": "6.0.7" + }, + "nbconvert-6.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.10,<3.11.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d5f336e62c8119170d6bf4e1e69a173d", + "name": "nbconvert", + "sha256": "57646f4fc47efbe3f105e25b794a707f4ad20972730fc72304cb11aa047e119a", + "size": 494092, + "subdir": "linux-64", + "timestamp": 1641917120726, + "version": "6.1.0" + }, + "nbconvert-6.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1a808a1495bc048cefe346e86d02916b", + "name": "nbconvert", + "sha256": "5046742714dac69e4d4689ec13a4f5c1806a9ecc5baeb192c5f4e06459b9b5dc", + "size": 494474, + "subdir": "linux-64", + "timestamp": 1624479119430, + "version": "6.1.0" + }, + "nbconvert-6.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "17bbbaa994689cb955db812d4f8f594d", + "name": "nbconvert", + "sha256": "2d29ec0e7fe19f6b5518bd5e05082404e1240c16e0a3437c70290c6e18fc5701", + "size": 492357, + "subdir": "linux-64", + "timestamp": 1624479089606, + "version": "6.1.0" + }, + "nbconvert-6.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.9,<3.10.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1097c2e4f3b0d085cbb08755631b3c72", + "name": "nbconvert", + "sha256": "b8a9ccc9ea19c9437ec5088dcfb442bedf7be09d6e17d0f6b9c6a0ed9801ecec", + "size": 496998, + "subdir": "linux-64", + "timestamp": 1624472931773, + "version": "6.1.0" + }, + "nbconvert-6.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6eb2e8c8a1a5eccd675d1eaad8955352", + "name": "nbconvert", + "sha256": "fbc58292e44b2d40f992fa14627324674b517ff7a1f1575b5fa998cb60da7ab1", + "size": 494931, + "subdir": "linux-64", + "timestamp": 1641309285896, + "version": "6.2.0" + }, + "nbconvert-6.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ebdb440e72a0d9807615170b6b6279e2", + "name": "nbconvert", + "sha256": "3bb4df8ccb63fab3156a03b49268f1eafe21d9037f3d959b79e6dc82622d0ea4", + "size": 495599, + "subdir": "linux-64", + "timestamp": 1641309221616, + "version": "6.2.0" + }, + "nbconvert-6.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.9,<3.10.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fd8b5c7bed4296f1f0d4afac4bc3d74c", + "name": "nbconvert", + "sha256": "bee6f56520e02f57aa5c4bb493f8c89c60e8e7bdf93e3773e31532b367b6ff60", + "size": 495549, + "subdir": "linux-64", + "timestamp": 1641309255701, + "version": "6.2.0" + }, + "nbconvert-6.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f558dd8eb71e255bfda39fae665a24a6", + "name": "nbconvert", + "sha256": "8464b3b2a2d70672110f32c9f412dc3758cf035d5fffe92b8ad21195e4c65384", + "size": 500857, + "subdir": "linux-64", + "timestamp": 1641309221963, + "version": "6.3.0" + }, + "nbconvert-6.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bd47eb3584dd52ecc71083c2c82ed0cc", + "name": "nbconvert", + "sha256": "f300e5ee0d88994b660afec4646c47d9bea1fd2cf2996d41bdc3abfe40e2dfe6", + "size": 501449, + "subdir": "linux-64", + "timestamp": 1641309285666, + "version": "6.3.0" + }, + "nbconvert-6.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.2" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.9,<3.10.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e5861d538a5ca0bde4150a78ccebba81", + "name": "nbconvert", + "sha256": "6346ccdeddaa93e23bd040faad90560daf1633a2e8f1e0045deb95f97d5a17fe", + "size": 499470, + "subdir": "linux-64", + "timestamp": 1641309256199, + "version": "6.3.0" + }, + "nbconvert-6.4.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.6" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.10,<3.11.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f0b561f279ef331e057468e4bc3a167a", + "name": "nbconvert", + "sha256": "d9acbeb8b3f2cabe997e112e1ba536ce7c8e6cce3c83120eec71d28a2a97d52d", + "size": 511871, + "subdir": "linux-64", + "timestamp": 1649749538297, + "version": "6.4.1" + }, + "nbconvert-6.4.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.6" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2a8975412680e290306df20f8dda0480", + "name": "nbconvert", + "sha256": "fb9a1ff24156046aecd29388e7ed172220b129765f35c7cc1805aafec5a7f331", + "size": 508891, + "subdir": "linux-64", + "timestamp": 1649749522352, + "version": "6.4.1" + }, + "nbconvert-6.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.6" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8127fbac388bcaaa8b918018314c5ba4", + "name": "nbconvert", + "sha256": "e2d66de08d37430e6c0dc309c10681f00d60ceddb7e8fd165426cb45efb776d4", + "size": 507602, + "subdir": "linux-64", + "timestamp": 1649731396167, + "version": "6.4.1" + }, + "nbconvert-6.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer ==0.2.6" + ], + "depends": [ + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.9,<3.10.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dee8d43756f1990fd0a9be8c17746e78", + "name": "nbconvert", + "sha256": "892eda15ac57f5a89849423079077e71cab79fd8f1da4df42e2aaf518e037d07", + "size": 507188, + "subdir": "linux-64", + "timestamp": 1649749524325, + "version": "6.4.1" + }, + "nbconvert-6.4.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer >=1,<1.1" + ], + "depends": [ + "beautifulsoup4", + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.10,<3.11.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c6a46ef906ce0247f5c42c572fa9121e", + "name": "nbconvert", + "sha256": "a3fb8d128644399d208b07260d2235e1db871ca6bbba2c38fe497ee6abe51108", + "size": 508160, + "subdir": "linux-64", + "timestamp": 1649752052948, + "version": "6.4.4" + }, + "nbconvert-6.4.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer >=1,<1.1" + ], + "depends": [ + "beautifulsoup4", + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "478c55a69753d2be992c3cffebcea027", + "name": "nbconvert", + "sha256": "e7e75a7a116333c6fcc31802efff7a23c0538202530932acb6517ebba8555cc3", + "size": 504420, + "subdir": "linux-64", + "timestamp": 1649751943602, + "version": "6.4.4" + }, + "nbconvert-6.4.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer >=1,<1.1" + ], + "depends": [ + "beautifulsoup4", + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "122395fc219e8e260db643cf1b8941b5", + "name": "nbconvert", + "sha256": "1da7145f1dfee0c3ec07571f2c3a6fcd6719daa50a0d27f17f558be1018797c8", + "size": 505572, + "subdir": "linux-64", + "timestamp": 1649751975792, + "version": "6.4.4" + }, + "nbconvert-6.4.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer >=1,<1.1" + ], + "depends": [ + "beautifulsoup4", + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=2.4", + "jupyter_core", + "jupyterlab_pygments", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0,<0.6.0", + "nbformat >=4.4", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.9,<3.10.0a0", + "testpath", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa1c7a862bd01979ce81044f6ed38abd", + "name": "nbconvert", + "sha256": "01355be8734d9f7de72d8653009e2e06c6be61e34058cbc13db68d99842232f6", + "size": 505936, + "subdir": "linux-64", + "timestamp": 1649752009070, + "version": "6.4.4" + }, + "nbconvert-6.5.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer >=1,<1.1" + ], + "depends": [ + "beautifulsoup4", + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=3.0", + "jupyter_core >=4.7", + "jupyterlab_pygments", + "lxml", + "markupsafe >=2.0", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0", + "nbformat >=5.1", + "packaging", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.10,<3.11.0a0", + "tinycss2", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff21615093870f014e9c9195ad16dd60", + "name": "nbconvert", + "sha256": "3cdac1331f682fd1727eadd9d48972b47e2ef4988e138c672ca8e79342a8b9da", + "size": 528710, + "subdir": "linux-64", + "timestamp": 1668450742267, + "version": "6.5.4" + }, + "nbconvert-6.5.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer >=1,<1.1" + ], + "depends": [ + "beautifulsoup4", + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=3.0", + "jupyter_core >=4.7", + "jupyterlab_pygments", + "lxml", + "markupsafe >=2.0", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0", + "nbformat >=5.1", + "packaging", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.11,<3.12.0a0", + "tinycss2", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1238119a99db51057a3fdbc867dc4c9", + "name": "nbconvert", + "sha256": "f24b4f807cb94c5ed91571fed4499610d4447b693ddb6815b8064e56178a4925", + "size": 570229, + "subdir": "linux-64", + "timestamp": 1676823867797, + "version": "6.5.4" + }, + "nbconvert-6.5.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer >=1,<1.1" + ], + "depends": [ + "beautifulsoup4", + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=3.0", + "jupyter_core >=4.7", + "jupyterlab_pygments", + "lxml", + "markupsafe >=2.0", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0", + "nbformat >=5.1", + "packaging", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.7,<3.8.0a0", + "tinycss2", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "31f6601039dc96d7606d62d897803e24", + "name": "nbconvert", + "sha256": "ff16c339dd1000c82602f90debe02d990ed465d17466a398eb88660c49aff47c", + "size": 524255, + "subdir": "linux-64", + "timestamp": 1668450779707, + "version": "6.5.4" + }, + "nbconvert-6.5.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer >=1,<1.1" + ], + "depends": [ + "beautifulsoup4", + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=3.0", + "jupyter_core >=4.7", + "jupyterlab_pygments", + "lxml", + "markupsafe >=2.0", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0", + "nbformat >=5.1", + "packaging", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.8,<3.9.0a0", + "tinycss2", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f6ae8bc7e67eae53c4971806231fc234", + "name": "nbconvert", + "sha256": "8f8dbb1bd3e782f6e63e305db83b13c4f615e3c884568f7030577093e3b16ef3", + "size": 525607, + "subdir": "linux-64", + "timestamp": 1668450817218, + "version": "6.5.4" + }, + "nbconvert-6.5.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyppeteer >=1,<1.1" + ], + "depends": [ + "beautifulsoup4", + "bleach", + "defusedxml", + "entrypoints >=0.2.2", + "jinja2 >=3.0", + "jupyter_core >=4.7", + "jupyterlab_pygments", + "lxml", + "markupsafe >=2.0", + "mistune >=0.8.1,<2", + "nbclient >=0.5.0", + "nbformat >=5.1", + "packaging", + "pandocfilters >=1.4.1", + "pygments >=2.4.1", + "python >=3.9,<3.10.0a0", + "tinycss2", + "traitlets >=5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "accb9a3ec61c07410944d4ba4f9d4f94", + "name": "nbconvert", + "sha256": "c3465606a0b364b0de3ed8655db1eb959f1e8d17971b71c67ae58ee276a6b97d", + "size": 525064, + "subdir": "linux-64", + "timestamp": 1668450704669, + "version": "6.5.4" + }, + "nbformat-4.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipython_genutils", + "jsonschema >=2.4,!=2.5.0", + "jupyter_core", + "python >=2.7,<2.8.0a0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "356951b1df1ab248396a27caca677b6d", + "name": "nbformat", + "sha256": "b23566a4b234df83bc97f8fac5a835c6c58bcecde7300fcb880766382cc60bc8", + "size": 130625, + "subdir": "linux-64", + "timestamp": 1530734480977, + "version": "4.4.0" + }, + "nbformat-4.4.0-py27hed7f2b2_0.conda": { + "build": "py27hed7f2b2_0", + "build_number": 0, + "depends": [ + "ipython_genutils", + "jsonschema >=2.4,!=2.5.0", + "jupyter_core", + "python >=2.7,<2.8.0a0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "e932073bed1c0dc4eff95234ff62a01e", + "name": "nbformat", + "sha256": "516280227f6a7ea5daa8133faafa0c2e87524bf88acaea57a59f2d7b01d89c9a", + "size": 127708, + "subdir": "linux-64", + "timestamp": 1505672287946, + "version": "4.4.0" + }, + "nbformat-4.4.0-py35h12e6e07_0.conda": { + "build": "py35h12e6e07_0", + "build_number": 0, + "depends": [ + "ipython_genutils", + "jsonschema >=2.4,!=2.5.0", + "jupyter_core", + "python >=3.5,<3.6.0a0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "a623ea934fade199a985485f3bb88af6", + "name": "nbformat", + "sha256": "91efc5e10873363b5ef97d5c45c7b6b97229e425a202f795921518aef2bc15dd", + "size": 129967, + "subdir": "linux-64", + "timestamp": 1505672304181, + "version": "4.4.0" + }, + "nbformat-4.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython_genutils", + "jsonschema >=2.4,!=2.5.0", + "jupyter_core", + "python >=3.6,<3.7.0a0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "aff6568abb6ef38220f5fd70a274a1bf", + "name": "nbformat", + "sha256": "5191b24ba1ab78f3061abe1e218cc167927f0b2cb6ec87824f4db33f1e1e5cfb", + "size": 130956, + "subdir": "linux-64", + "timestamp": 1530734457345, + "version": "4.4.0" + }, + "nbformat-4.4.0-py36h31c9010_0.conda": { + "build": "py36h31c9010_0", + "build_number": 0, + "depends": [ + "ipython_genutils", + "jsonschema >=2.4,!=2.5.0", + "jupyter_core", + "python >=3.6,<3.7.0a0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "83bbdbc08fea15afb411101cbc6bf51a", + "name": "nbformat", + "sha256": "d5e67e862b87e94687703b1e7e9d2c2612af705d6f128fe3b00b9f69c7aeec28", + "size": 130292, + "subdir": "linux-64", + "timestamp": 1505672321210, + "version": "4.4.0" + }, + "nbformat-4.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython_genutils", + "jsonschema >=2.4,!=2.5.0", + "jupyter_core", + "python >=3.7,<3.8.0a0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "0be5895530200d1c7647975813b076f3", + "name": "nbformat", + "sha256": "d5895bc7bdc6fff39498a87bb5452183cc22d24f09df52ad2e1cde8bca1dd844", + "size": 131083, + "subdir": "linux-64", + "timestamp": 1530734505990, + "version": "4.4.0" + }, + "nbformat-4.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipython_genutils", + "jsonschema >=2.4,!=2.5.0", + "jupyter_core", + "python >=3.8,<3.9.0a0", + "traitlets >=4.1" + ], + "license": "BSD 3-clause", + "md5": "681518477c77fa645905e89e164f9b74", + "name": "nbformat", + "sha256": "81fd973e2de034f775c624f80ea4d108e9a670377662cb95919a5c0fbcf8241e", + "size": 132536, + "subdir": "linux-64", + "timestamp": 1574414063395, + "version": "4.4.0" + }, + "nbformat-5.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.10,<3.11.0a0", + "python-fastjsonschema", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "892ceced345c832f5b0845cd382fc846", + "name": "nbformat", + "sha256": "29f2dd15e40b71df25cfe2ed200958f9875f1d0880ef2b78b7e4f09bb2f2e9b3", + "size": 132457, + "subdir": "linux-64", + "timestamp": 1649844967383, + "version": "5.3.0" + }, + "nbformat-5.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.7,<3.8.0a0", + "python-fastjsonschema", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "845535307556bdae0600212c3e64f879", + "name": "nbformat", + "sha256": "40ea63fefbd219728417c1c7cc9f3448d65d13c17580fac348dbd43ea6d027c8", + "size": 132196, + "subdir": "linux-64", + "timestamp": 1649844957513, + "version": "5.3.0" + }, + "nbformat-5.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.8,<3.9.0a0", + "python-fastjsonschema", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a9c19f2c0244559b292acc2ce458e871", + "name": "nbformat", + "sha256": "66b73015bc78549c1660e5d5c02facbc3d561b51525a9da9ecfc54500fe61e87", + "size": 132602, + "subdir": "linux-64", + "timestamp": 1649827095894, + "version": "5.3.0" + }, + "nbformat-5.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.9,<3.10.0a0", + "python-fastjsonschema", + "traitlets >=4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5fa6d199fb409804ff43598c80c68356", + "name": "nbformat", + "sha256": "c48ca603937e44edfe26835ecf09c1bf25e29aa04a6783f6a5624bd20fdc426f", + "size": 131431, + "subdir": "linux-64", + "timestamp": 1649826828066, + "version": "5.3.0" + }, + "nbformat-5.5.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.10,<3.11.0a0", + "python-fastjsonschema", + "traitlets >=5.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb0149646e612de72664abc5095a0c99", + "name": "nbformat", + "sha256": "849961c0768fbbb3b8da452832db33547993995f876d222ecc2581c797441068", + "size": 131524, + "subdir": "linux-64", + "timestamp": 1663745091753, + "version": "5.5.0" + }, + "nbformat-5.5.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.7,<3.8.0a0", + "python-fastjsonschema", + "traitlets >=5.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5a2ca98b0ae489e4901a851149c26825", + "name": "nbformat", + "sha256": "8cba38d8cb263436f69b2321fe37dc518e7d7fc44260ba5d5365c52146538d65", + "size": 130895, + "subdir": "linux-64", + "timestamp": 1663745049084, + "version": "5.5.0" + }, + "nbformat-5.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.8,<3.9.0a0", + "python-fastjsonschema", + "traitlets >=5.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1983fba72eb9d9655fff18ef45e02e46", + "name": "nbformat", + "sha256": "3ae16fbb80ebf7e20f28b32ce29653909a0337b1f6cc12b2e33566a9e6cb20a1", + "size": 131285, + "subdir": "linux-64", + "timestamp": 1663744986178, + "version": "5.5.0" + }, + "nbformat-5.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.9,<3.10.0a0", + "python-fastjsonschema", + "traitlets >=5.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d879395b1c487a1dd4436f31b6722f42", + "name": "nbformat", + "sha256": "f098391b969172a605d3edf03394ad22823adae7afacc22907f423a942d939bf", + "size": 131129, + "subdir": "linux-64", + "timestamp": 1663745018901, + "version": "5.5.0" + }, + "nbformat-5.7.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.10,<3.11.0a0", + "python-fastjsonschema", + "traitlets >=5.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d0c9eadb6e137111f39ede8475f0010", + "name": "nbformat", + "sha256": "42b6a4fb15aa601db5332f5b2d47ba59e171aa6585d730ec139c92ee55d397fa", + "size": 137156, + "subdir": "linux-64", + "timestamp": 1670352459523, + "version": "5.7.0" + }, + "nbformat-5.7.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.11,<3.12.0a0", + "python-fastjsonschema", + "traitlets >=5.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e090797790cfbe9666db3abe02293ec2", + "name": "nbformat", + "sha256": "12107291317ed69ee6c0e5218ceb6c8d2b1034c1c539e17ce93594ceedd3ad9a", + "size": 155280, + "subdir": "linux-64", + "timestamp": 1676823537457, + "version": "5.7.0" + }, + "nbformat-5.7.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=3.6", + "jsonschema >=2.6", + "jupyter_core", + "python >=3.7,<3.8.0a0", + "python-fastjsonschema", + "traitlets >=5.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1a605ccdb462125d3fa79f7ed860a86", + "name": "nbformat", + "sha256": "86dff81d7e3b4c8bc67989e2d0dc01012f0c416185459e8ccab58d0bafe5bb61", + "size": 136579, + "subdir": "linux-64", + "timestamp": 1670352426079, + "version": "5.7.0" + }, + "nbformat-5.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.8,<3.9.0a0", + "python-fastjsonschema", + "traitlets >=5.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b1c3f04215f14763ec99468ead9ce275", + "name": "nbformat", + "sha256": "7f5114e6ddd863720636c6fac54b4aba10f409c3d92ffc56c1f84fc0d2952585", + "size": 136522, + "subdir": "linux-64", + "timestamp": 1670352391322, + "version": "5.7.0" + }, + "nbformat-5.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.6", + "jupyter_core", + "python >=3.9,<3.10.0a0", + "python-fastjsonschema", + "traitlets >=5.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3e4c16ab8ceb1c9f15fe71c3d70b67ef", + "name": "nbformat", + "sha256": "eced8bc09f7efe1937d289e72bfe7b822a46e34cdef9fab32496836186ff3ec2", + "size": 136691, + "subdir": "linux-64", + "timestamp": 1670352357619, + "version": "5.7.0" + }, + "nbpresent-3.0.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "5ca0db56a71adc0cf286d206a721c8ec", + "name": "nbpresent", + "sha256": "3b5c672cd7230c1fa15ebbfb716c7f5a3e009b6c839bb6e98fa494f902c0c3ae", + "size": 868310, + "subdir": "linux-64", + "timestamp": 1530901371825, + "version": "3.0.2" + }, + "nbpresent-3.0.2-py27hcce4ef4_1.conda": { + "build": "py27hcce4ef4_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "0fbae9f46250749135943888c9b4988e", + "name": "nbpresent", + "sha256": "8ac7d6746979efdc6269ca851f2062e640169e922785897cd2ec69f61bae231e", + "size": 833605, + "subdir": "linux-64", + "timestamp": 1505746483006, + "version": "3.0.2" + }, + "nbpresent-3.0.2-py35h9c03491_1.conda": { + "build": "py35h9c03491_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "md5": "dc3e76c4f5ead5f4308720e67483fd44", + "name": "nbpresent", + "sha256": "fda860d8f8a1734362e3cb58e7dc07b16ba8aeda8e706b9d81492922d836327b", + "size": 832641, + "subdir": "linux-64", + "timestamp": 1505746579276, + "version": "3.0.2" + }, + "nbpresent-3.0.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "0bada9af4f46f289554fff677a5f9577", + "name": "nbpresent", + "sha256": "760d502e9828d85981371d16c0998c50118fc2405500a3d1409433cc490f379f", + "size": 867507, + "subdir": "linux-64", + "timestamp": 1530901275349, + "version": "3.0.2" + }, + "nbpresent-3.0.2-py36h5f95a39_1.conda": { + "build": "py36h5f95a39_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2cf7d8ca141c600d924b74e57a5e1746", + "name": "nbpresent", + "sha256": "63b2302b9fb70d18bd7bcbec865632b3dd1db306ec1e6fe1044ee8e1a6dd8e81", + "size": 832467, + "subdir": "linux-64", + "timestamp": 1505746671850, + "version": "3.0.2" + }, + "nbpresent-3.0.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "notebook >=4.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b92ecad000f5f1dd3d2c93e2634f550a", + "name": "nbpresent", + "sha256": "57ced45d31560b2dd43c8aa13899c58840a3f2b4610a9301dba0fe6729713f31", + "size": 868467, + "subdir": "linux-64", + "timestamp": 1530901183647, + "version": "3.0.2" + }, + "nbserverproxy-0.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6cb754391db6ca44423e372a6cdebae5", + "name": "nbserverproxy", + "sha256": "785107e8ee87eb131edf89f3bb3d3a84c84902ebcce3fbe9d26c25eb4345316f", + "size": 14275, + "subdir": "linux-64", + "timestamp": 1522699251359, + "version": "0.7" + }, + "nbserverproxy-0.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6201a4a7a1e9f3fcac7ddd50fe7b980a", + "name": "nbserverproxy", + "sha256": "8afc914d5873b067e55fc0e200e210afe165f0a56801698a2bfcbd7b6e846616", + "size": 14169, + "subdir": "linux-64", + "timestamp": 1522699243523, + "version": "0.7" + }, + "nbserverproxy-0.8.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2aa7ffac2a81177be434874c7c0dd9d8", + "name": "nbserverproxy", + "sha256": "08ae8b526223a20524e817dcddb5050a9fe0e9aeeb4959cac72e0c1002383245", + "size": 15650, + "subdir": "linux-64", + "timestamp": 1526943639395, + "version": "0.8.3" + }, + "nbserverproxy-0.8.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "44011ee94e93bf8bd1d6da11e7d881ad", + "name": "nbserverproxy", + "sha256": "5b2320d74161484ed3254d29619131b73425116a28a4ca50a9483c5b848f509e", + "size": 15520, + "subdir": "linux-64", + "timestamp": 1526943497184, + "version": "0.8.3" + }, + "nbserverproxy-0.8.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "000769652b0f6743334d7f46a6494690", + "name": "nbserverproxy", + "sha256": "045b8747aeae6280c84599edaa510a2156478bbce3988b39faccf4d817757e90", + "size": 15418, + "subdir": "linux-64", + "timestamp": 1530901414128, + "version": "0.8.3" + }, + "nbserverproxy-0.8.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6892bb0ede7ff7213ad357b81aa77240", + "name": "nbserverproxy", + "sha256": "7eba47123de16759c5b20c2ba556a82bad2bc8423f5b05abf84dafba8904fc68", + "size": 16401, + "subdir": "linux-64", + "timestamp": 1640815417106, + "version": "0.8.5" + }, + "nbserverproxy-0.8.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0e857d5a5c79eca39e8eca9e8282ffab", + "name": "nbserverproxy", + "sha256": "b7df55b565eb67e92867a0ca9d840fcba2a45c4445b99e17df49be827bc7168c", + "size": 20249, + "subdir": "linux-64", + "timestamp": 1676859897941, + "version": "0.8.5" + }, + "nbserverproxy-0.8.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "11445ac43895c5c09ec92ebe0b5d27d1", + "name": "nbserverproxy", + "sha256": "0c5466566ea4e4f45aa1da34e47617e1a23c1ebbdd2596e964cfbcccfcbca434", + "size": 15807, + "subdir": "linux-64", + "timestamp": 1540990805521, + "version": "0.8.5" + }, + "nbserverproxy-0.8.5-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "720a1dba79c1415cf6c7f67cd879e1ce", + "name": "nbserverproxy", + "sha256": "d2210c32061c66b7ab54a0026c84c385cb408ad6c1ada7325fa5c7a189103117", + "size": 17793, + "subdir": "linux-64", + "timestamp": 1613733988252, + "version": "0.8.5" + }, + "nbserverproxy-0.8.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e45c7d3645a5fbada37083398c9e4152", + "name": "nbserverproxy", + "sha256": "6ff1d6701f14dd8c66c61b15fc5b6b000f48e0511682423d5ccba1032b93a85f", + "size": 15884, + "subdir": "linux-64", + "timestamp": 1540990810995, + "version": "0.8.5" + }, + "nbserverproxy-0.8.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8e9170c79e7e57b1284848cdbf85000a", + "name": "nbserverproxy", + "sha256": "2fbf2ef51845592328162f27ad4141a755de846e22badd15accc70d153a87d7d", + "size": 17776, + "subdir": "linux-64", + "timestamp": 1613734599440, + "version": "0.8.5" + }, + "nbserverproxy-0.8.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fe2a8187c2dabc4f46a4eadd39f24e37", + "name": "nbserverproxy", + "sha256": "06c52c7a2e434f39fa03588c63eca2e7dfd8d712c5fc05c9cd9aa59a701a0459", + "size": 17724, + "subdir": "linux-64", + "timestamp": 1613734731062, + "version": "0.8.5" + }, + "nbserverproxy-0.8.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f1d54d74c6c6121285ffbb7262585470", + "name": "nbserverproxy", + "sha256": "1b3b0a4c2cdd63e793b61dff1877aff6af6589cfd3ee2168ed9a76d4979b95b1", + "size": 17693, + "subdir": "linux-64", + "timestamp": 1613733986098, + "version": "0.8.5" + }, + "nbserverproxy-0.8.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0d70f4cf34d6a0143675bc8a3629dcb1", + "name": "nbserverproxy", + "sha256": "11ac4d3270e31e01b8be231b9b15467ed169b417dfc3b5b21127afb2427aa73a", + "size": 16326, + "subdir": "linux-64", + "timestamp": 1545146078007, + "version": "0.8.8" + }, + "nbserverproxy-0.8.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dbce8f75084400c5e672b793940fd5ec", + "name": "nbserverproxy", + "sha256": "1f7fe5de806e872f7318074f0394cca15943a25902a4a15321392ead8b5f83d4", + "size": 16331, + "subdir": "linux-64", + "timestamp": 1545130461873, + "version": "0.8.8" + }, + "nbserverproxy-0.8.8-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7a09d3fc82b0083bda8b4277d33f7a1a", + "name": "nbserverproxy", + "sha256": "3372cab1e7f1f55b7fbc02a5c98300370cc57e7a0aa983fd6de85b3e24b632b5", + "size": 16800, + "subdir": "linux-64", + "timestamp": 1600445758231, + "version": "0.8.8" + }, + "nbsmoke-0.2.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "pyflakes", + "pytest >=3.1.1", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "320a06d7d942cc2d9faa8385d06cfc7c", + "name": "nbsmoke", + "sha256": "620a459c164dcc51e31d9f3468c7400ef10a89d0c3dcf5101687aa2144d238e1", + "size": 18123, + "subdir": "linux-64", + "timestamp": 1528517095534, + "version": "0.2.7" + }, + "nbsmoke-0.2.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "pyflakes", + "pytest >=3.1.1", + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "134531b66e331229dbc17ba9b64e0f4e", + "name": "nbsmoke", + "sha256": "3696e10a920b3dad2c3d41717f5d685b8b083fa1cad6288ea48514fb1bfbac5d", + "size": 18500, + "subdir": "linux-64", + "timestamp": 1528517155291, + "version": "0.2.7" + }, + "nbsmoke-0.2.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "pyflakes", + "pytest >=3.1.1", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a414e739a8771dd1670716a4aeb3706c", + "name": "nbsmoke", + "sha256": "09efe412bea53a8dc53b63934c5cbd4602e7c7c1b2821a340bf72a814775926b", + "size": 18207, + "subdir": "linux-64", + "timestamp": 1528517073196, + "version": "0.2.7" + }, + "nbsmoke-0.2.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "pyflakes", + "pytest >=3.1.1", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f9216598507581c88860c99a7111f4a6", + "name": "nbsmoke", + "sha256": "b826bf3358600565b49ca7925d83ddcd4019e1769935787936400ab8e4b54255", + "size": 21037, + "subdir": "linux-64", + "timestamp": 1559058650998, + "version": "0.2.8" + }, + "nbsmoke-0.2.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "pyflakes", + "pytest >=3.1.1", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b88d320e4e4767b0528b059872634535", + "name": "nbsmoke", + "sha256": "d5a45af9cbf364443a27a28eed519dca62616cab8443058379372e462bcec5e7", + "size": 21241, + "subdir": "linux-64", + "timestamp": 1559058668396, + "version": "0.2.8" + }, + "nbsmoke-0.2.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "pyflakes", + "pytest >=3.1.1", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fdf02d3bd7ff887244a04195cfc169c2", + "name": "nbsmoke", + "sha256": "dc3c510f379fee56f8ca121e0cb30851d792581a8cd8dd683f0cfbd3cd020cb9", + "size": 21289, + "subdir": "linux-64", + "timestamp": 1559058657506, + "version": "0.2.8" + }, + "nbsmoke-0.2.8-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "pyflakes", + "pytest >=3.1.1", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e56bf957948fe988866b5d58048fb098", + "name": "nbsmoke", + "sha256": "63aa778222f7b44162c617769c6d73a5f6ff7aed63c7dee34420be2432084a79", + "size": 19910, + "subdir": "linux-64", + "timestamp": 1574238051624, + "version": "0.2.8" + }, + "nbsmoke-0.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "param >=1.7.0", + "pyflakes", + "pytest >=3.1.1", + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c073414701c04cc3df946445e55e7a99", + "name": "nbsmoke", + "sha256": "f36aaaa3e236c7d570ef2854e97d37da5881fa7dda4d2913324303a7e162c3ef", + "size": 44175, + "subdir": "linux-64", + "timestamp": 1658841577604, + "version": "0.6.0" + }, + "nbsmoke-0.6.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "param >=1.7.0", + "pyflakes", + "pytest >=3.1.1", + "python >=3.11,<3.12.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "19bcf972c40b91a04afeb6e03d3c7a28", + "name": "nbsmoke", + "sha256": "8762fcb26d05b02b82d06cd049b1fb71e01765432f72f6439496f6d1fc6799b0", + "size": 54389, + "subdir": "linux-64", + "timestamp": 1676859913340, + "version": "0.6.0" + }, + "nbsmoke-0.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "param >=1.7.0", + "pyflakes", + "pytest >=3.1.1", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07b5e1792822b66b1e03adb3356b2b64", + "name": "nbsmoke", + "sha256": "9dc3ee0c144d322dd97a05cc37083468bdef09def7feba7fcc0c2230d3a7cafe", + "size": 43934, + "subdir": "linux-64", + "timestamp": 1658841687624, + "version": "0.6.0" + }, + "nbsmoke-0.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "param >=1.7.0", + "pyflakes", + "pytest >=3.1.1", + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4b88e8383f6dfed415cfe70532eed4dd", + "name": "nbsmoke", + "sha256": "cbcf5711014e76c482669482266405c080d0e0c5010204fe195babe92b43eda7", + "size": 44092, + "subdir": "linux-64", + "timestamp": 1658841651220, + "version": "0.6.0" + }, + "nbsmoke-0.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "ipykernel", + "jupyter_client", + "nbconvert", + "nbformat", + "param >=1.7.0", + "pyflakes", + "pytest >=3.1.1", + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c3328efca8668f4fd171cc980b37cb45", + "name": "nbsmoke", + "sha256": "f7d2ed11111049405ea50cdf6889931ff865d54107c40a49add10815897b8756", + "size": 43887, + "subdir": "linux-64", + "timestamp": 1658841616057, + "version": "0.6.0" + }, + "nccl-1.3.5-cuda10.0_0.conda": { + "build": "cuda10.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7900e25ec846204dbdc4a083d7936cfd", + "name": "nccl", + "sha256": "e42f46cc2fab83ceee6282eb5d526aa01d245875b72c43c1a584743e5569d2f9", + "size": 1389642, + "subdir": "linux-64", + "timestamp": 1548260767320, + "version": "1.3.5" + }, + "nccl-1.3.5-cuda9.0_0.conda": { + "build": "cuda9.0_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ba67a122cf0a487f63e3a7f52a9fba35", + "name": "nccl", + "sha256": "e44d28d32d1948ac12e5afa4f4a52422deb45ed5bca71511dc483efb5affd233", + "size": 1409460, + "subdir": "linux-64", + "timestamp": 1523280871183, + "version": "1.3.5" + }, + "nccl-1.3.5-cuda9.2_0.conda": { + "build": "cuda9.2_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "041f6b9c59d9716ca66e3ba8973b29e0", + "name": "nccl", + "sha256": "880264d51ad5bd5cc1793811b1553e9a2cec4afaf8520016f941401a8c57d4d4", + "size": 1382366, + "subdir": "linux-64", + "timestamp": 1548262779624, + "version": "1.3.5" + }, + "nccl-2.8.3.1-h91b26fc_0.conda": { + "build": "h91b26fc_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.0|10.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2699d39962a2c0cc6066de07cb996f3b", + "name": "nccl", + "sha256": "f47b5beeda73cd7444e3b0da9a4c82f0f2acdaee64364ba1c9c093300db4f7d4", + "size": 24911785, + "subdir": "linux-64", + "timestamp": 1610053622356, + "version": "2.8.3.1" + }, + "nccl-2.8.3.1-hcaf9a05_0.conda": { + "build": "hcaf9a05_0", + "build_number": 0, + "depends": [ + "cudatoolkit 10.1|10.1.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a44bf31ab524405c46271a465ba96a85", + "name": "nccl", + "sha256": "4137465dc4a23e18da6d3248b3a143536ff98392b7046a66f4c9498742da4446", + "size": 25385590, + "subdir": "linux-64", + "timestamp": 1610061223661, + "version": "2.8.3.1" + }, + "nccl-2.8.3.1-heaad284_0.conda": { + "build": "heaad284_0", + "build_number": 0, + "depends": [ + "cudatoolkit 9.2|9.2.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1b8e1a31d97ce32f9800bed06451677b", + "name": "nccl", + "sha256": "97499fce22943924a00564bcd32b23d63d85adad3957333bffabd2c923c2eee5", + "size": 24992225, + "subdir": "linux-64", + "timestamp": 1610039477486, + "version": "2.8.3.1" + }, + "ncurses-6.0-h06874d7_1.conda": { + "build": "h06874d7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Free software (MIT-like)", + "md5": "f3168187c8b135a38a51cccbd507bcf9", + "name": "ncurses", + "sha256": "f9e813b435a981928c3369d75424eb641152bd9df7cdf8c4e812a020211a130a", + "size": 765230, + "subdir": "linux-64", + "timestamp": 1505666443588, + "version": "6.0" + }, + "ncurses-6.0-h9df7e31_2.conda": { + "build": "h9df7e31_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Free software (MIT-like)", + "md5": "a348c8141841b8a30bc25d4860d919a9", + "name": "ncurses", + "sha256": "e7668fb11ee83ecc45fd608fac08bc974fd1d9608ef5bc45ebdf84711050ff0f", + "size": 799334, + "subdir": "linux-64", + "timestamp": 1510350763235, + "version": "6.0" + }, + "ncurses-6.1-he6710b0_1.conda": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Free software (MIT-like)", + "md5": "2ddad69032f38ace29c50b2ee7c5e080", + "name": "ncurses", + "sha256": "140b1638f1fd5fb9d133b36d061a8f2444c8f3186ac89b625f3ebe2dd4e268ad", + "size": 795822, + "subdir": "linux-64", + "timestamp": 1543442069203, + "version": "6.1" + }, + "ncurses-6.1-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Free software (MIT-like)", + "md5": "3bcaf8362c7c584c81a7168e5848d0cb", + "name": "ncurses", + "sha256": "efb76cd9dc1caf7ee90b97cab631afab7c5c6fbdffd09865c4a652288cc777b8", + "size": 789982, + "subdir": "linux-64", + "timestamp": 1525867812788, + "version": "6.1" + }, + "ncurses-6.2-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Free software (MIT-like)", + "md5": "ec730dd6d57284e074e57a741abb51d4", + "name": "ncurses", + "sha256": "e941eef021920083008cf2049dd47e277a26be1caa68a34e577291ea1526d3bd", + "size": 835550, + "subdir": "linux-64", + "timestamp": 1582541487979, + "version": "6.2" + }, + "ncurses-6.2-he6710b0_1.conda": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Free software (MIT-like)", + "md5": "b7ddf5ee3934b7f54620e8f6c0ee8a95", + "name": "ncurses", + "sha256": "b06808e9d147ff7d56f37d64eb55f09bfc1108ef0af22cb461e7ad20810bc236", + "size": 836147, + "subdir": "linux-64", + "timestamp": 1588170439381, + "version": "6.2" + }, + "ncurses-6.3-h5eee18b_3.conda": { + "build": "h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "Free software (MIT-like)", + "md5": "0c616f387885c1bbb57ec0bd1e779ced", + "name": "ncurses", + "sha256": "4ce599f76d1e2704209eee1f6b1a05a8a5a679ae7bb02c2bab915cf6d694196f", + "size": 800185, + "subdir": "linux-64", + "timestamp": 1657006248503, + "version": "6.3" + }, + "ncurses-6.3-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "Free software (MIT-like)", + "md5": "210a664bef3f92f9d65e1f59044b9640", + "name": "ncurses", + "sha256": "f57986c3c46fca0f64164ca6aa82dd96003eaced7c1d7cb8ce5507ce8d262e52", + "size": 808040, + "subdir": "linux-64", + "timestamp": 1635849428122, + "version": "6.3" + }, + "ncurses-6.3-h7f8727e_2.conda": { + "build": "h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "Free software (MIT-like)", + "md5": "4edf660a09cc7adcb21120464b2a1783", + "name": "ncurses", + "sha256": "c1a4de3a57e4ed4f2a02b71dc722a0dde18fda80838a7d4aaeaefd834f8fbea2", + "size": 800937, + "subdir": "linux-64", + "timestamp": 1636570020698, + "version": "6.3" + }, + "ncurses-6.3-heee7806_1.conda": { + "build": "heee7806_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "Free software (MIT-like)", + "md5": "b780b386c5e3f8ff579164958c53c799", + "name": "ncurses", + "sha256": "c935478cd0b8e4cc3ca5497a3f9ac7190a25bffff4946db97ee3eeaba567df1e", + "size": 807820, + "subdir": "linux-64", + "timestamp": 1636114491849, + "version": "6.3" + }, + "ncurses-6.4-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT AND X11", + "license_family": "MIT", + "md5": "5558eec6e2191741a92f832ea826251c", + "name": "ncurses", + "sha256": "a3150cb7655d3781b2ff2d8a7f1eea6103dbbd8835adc7429f7377e4886f6129", + "size": 935878, + "subdir": "linux-64", + "timestamp": 1674734069410, + "version": "6.4" + }, + "ndg-httpsclient-0.4.3-py27ha68a7dc_0.conda": { + "build": "py27ha68a7dc_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1ab3729380b2edb138f65d4af9125836", + "name": "ndg-httpsclient", + "sha256": "61f102afc744771440ac3e0cc625742368bacd6b5c2cfe903c4cfc530776afa3", + "size": 43228, + "subdir": "linux-64", + "timestamp": 1508266085341, + "version": "0.4.3" + }, + "ndg-httpsclient-0.4.3-py35h6fea151_0.conda": { + "build": "py35h6fea151_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8de254f77cf866e0c76609c1438ed260", + "name": "ndg-httpsclient", + "sha256": "dc36b0296f5a5a0206c9da58e747575be8bde68b615e67a12e22693949d4bb6f", + "size": 43786, + "subdir": "linux-64", + "timestamp": 1508266098279, + "version": "0.4.3" + }, + "ndg-httpsclient-0.4.3-py36h9c7cbca_0.conda": { + "build": "py36h9c7cbca_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0d10a46ae5466c98d2fe853bc71de06a", + "name": "ndg-httpsclient", + "sha256": "22cff7a2d6b8589ee3e4886e4b477f23389dccacfa63b98384ae2853776740fa", + "size": 43588, + "subdir": "linux-64", + "timestamp": 1508266092583, + "version": "0.4.3" + }, + "ndg-httpsclient-0.4.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b07c4f02914c19401a0214075c7b5d38", + "name": "ndg-httpsclient", + "sha256": "c054407300058c0433a3ef59168ffe1bd2160707f5c95affbb00ed71f5d97d97", + "size": 41818, + "subdir": "linux-64", + "timestamp": 1521782455744, + "version": "0.4.4" + }, + "ndg-httpsclient-0.4.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "910931b391225ede35b74e30785a4eb0", + "name": "ndg-httpsclient", + "sha256": "e12202628861f575c0c4fa4b466d96f13ab1f87177197bd2a64f20dbed83e8e1", + "size": 42376, + "subdir": "linux-64", + "timestamp": 1521782466570, + "version": "0.4.4" + }, + "ndg-httpsclient-0.4.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5e3ad7f05b264c0912a387f914a7bdea", + "name": "ndg-httpsclient", + "sha256": "01e6e61efc396cbbee01b989e63077cac7b833819e0cdd78445c9b3601f49099", + "size": 42122, + "subdir": "linux-64", + "timestamp": 1521782409785, + "version": "0.4.4" + }, + "ndg-httpsclient-0.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dac227b7dbe82712ef53b0d4618171da", + "name": "ndg-httpsclient", + "sha256": "71e3b6fda182a2265564c0388e276cfa59d2ec32a4a0d07a36bc416b02824896", + "size": 43611, + "subdir": "linux-64", + "timestamp": 1526928758520, + "version": "0.5.0" + }, + "ndg-httpsclient-0.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "885c19dc19938374da46078cc4673ccf", + "name": "ndg-httpsclient", + "sha256": "67627e417a11edf050189c67317ee12b3bb3099f444e6dd7c6e21378b0a2dabb", + "size": 43617, + "subdir": "linux-64", + "timestamp": 1526928765235, + "version": "0.5.0" + }, + "ndg-httpsclient-0.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "97e84ec57ff911f395ca31adfdc9e050", + "name": "ndg-httpsclient", + "sha256": "cc80f7845af9b9bd561a569e5ce373f124d980e30f564f00973b1008e14a3723", + "size": 43795, + "subdir": "linux-64", + "timestamp": 1526928736839, + "version": "0.5.0" + }, + "ndg-httpsclient-0.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "287d295dd11947de97f7509ba90e2700", + "name": "ndg-httpsclient", + "sha256": "6503dcf705d7381e2fd79d0ff187fc5361731d4c4145474c8c7ea974751ef445", + "size": 43520, + "subdir": "linux-64", + "timestamp": 1530901449194, + "version": "0.5.0" + }, + "ndg-httpsclient-0.5.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "17c9f1871a48eecd660b37993dacd142", + "name": "ndg-httpsclient", + "sha256": "9d9761bd2623cfeb71b46777f92659a20e6941f8f78124a49a48949a447b57fc", + "size": 42711, + "subdir": "linux-64", + "timestamp": 1535499336972, + "version": "0.5.1" + }, + "ndg-httpsclient-0.5.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b7056f79485b7a24b6864008e0b5b0af", + "name": "ndg-httpsclient", + "sha256": "dddc620d4910ff6c78fa9d796a9541b1809ff34f1074a05a24e5f9276cda0720", + "size": 43202, + "subdir": "linux-64", + "timestamp": 1535499337992, + "version": "0.5.1" + }, + "ndg-httpsclient-0.5.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f1bc8fe492f16d324dbc0f3f5cd1407f", + "name": "ndg-httpsclient", + "sha256": "0f35269c0b36fc2f98e18f74a971e02a23dc89068a8b71d8ac583611e4605e43", + "size": 43331, + "subdir": "linux-64", + "timestamp": 1535499305979, + "version": "0.5.1" + }, + "ndg-httpsclient-0.5.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pyasn1 >=0.1.1", + "pyopenssl", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "deca90ed195226fd4f0e2ebc76140fa9", + "name": "ndg-httpsclient", + "sha256": "3d2480044263b5c8d4798d58b59c636519940d435fdbb00e669c0fa142684af6", + "size": 43263, + "subdir": "linux-64", + "timestamp": 1535499342238, + "version": "0.5.1" + }, + "neo4j-python-driver-1.5.3-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f9ea846a9497c06f06776abd293c6c7b", + "name": "neo4j-python-driver", + "sha256": "7f66d92d2bc7e586c8d23b3010f07800ec1e36e3d9db9be76d67746611ff2779", + "size": 183142, + "subdir": "linux-64", + "timestamp": 1522784568924, + "version": "1.5.3" + }, + "neo4j-python-driver-1.5.3-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0c92295a6ced79d832dc9e0b56d80e14", + "name": "neo4j-python-driver", + "sha256": "4ff451d44eeb33a34e548e82d5d4bf7f47e9762ae9dc5f5df23a355cb1595432", + "size": 182976, + "subdir": "linux-64", + "timestamp": 1522784547893, + "version": "1.5.3" + }, + "neo4j-python-driver-1.5.3-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f09a0a08391d2b90d7ab06898ae85fa1", + "name": "neo4j-python-driver", + "sha256": "55a27b95aa48f20e9b02f1d0d988860721461cea54be2a6972bba0e7c959bf46", + "size": 187887, + "subdir": "linux-64", + "timestamp": 1522784548809, + "version": "1.5.3" + }, + "neo4j-python-driver-1.6.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "neotime", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6c567b59e6b39a41d702b6274827e456", + "name": "neo4j-python-driver", + "sha256": "f2032a1d6dc6ad238d6b2a6c8c49aaf9d14fe3174cf45248f8a97a1dbec6f2d5", + "size": 190083, + "subdir": "linux-64", + "timestamp": 1527831949357, + "version": "1.6.0" + }, + "neo4j-python-driver-1.6.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "neotime", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f02e957737f32e1a943296a49af8922f", + "name": "neo4j-python-driver", + "sha256": "5cbf445eaf6972bd21e08a53dd79b09da9e6a006364df8708901ae7d7080b37b", + "size": 192770, + "subdir": "linux-64", + "timestamp": 1527832185623, + "version": "1.6.0" + }, + "neo4j-python-driver-1.6.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "neotime", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "834e0a50afa686ce1901ee161a467bfe", + "name": "neo4j-python-driver", + "sha256": "b4d704ec2c82a507cff9b3e6eae35c741c97b9b453268227ef02a289e458e9c9", + "size": 195795, + "subdir": "linux-64", + "timestamp": 1527832152601, + "version": "1.6.0" + }, + "neo4j-python-driver-1.6.0-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "neotime", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bdd7ee9e8b68379f75b68385a1ac5e7c", + "name": "neo4j-python-driver", + "sha256": "f86b9f40e1cd50b681e3689ac450a5a1c64252b7dc51f1e6322d9cc34fdbf24c", + "size": 195512, + "subdir": "linux-64", + "timestamp": 1530901522512, + "version": "1.6.0" + }, + "neo4j-python-driver-1.6.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5be50c81cce4fccb26fb87d51518e845", + "name": "neo4j-python-driver", + "sha256": "c3b3ac32964c5480644a2f75d1b0011a9a18fadf2133d1daaccb4703fd965966", + "size": 190458, + "subdir": "linux-64", + "timestamp": 1535500399834, + "version": "1.6.1" + }, + "neo4j-python-driver-1.6.1-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "44a5c444d9f808d4fe1d3d23eca40a61", + "name": "neo4j-python-driver", + "sha256": "8e654a4bd214c52011b1270bd7e8951fbfeb3c3bfd603518c6139ec6dd906b6a", + "size": 193112, + "subdir": "linux-64", + "timestamp": 1535500453906, + "version": "1.6.1" + }, + "neo4j-python-driver-1.6.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "880672d2ebc955442e7c6776429f85ff", + "name": "neo4j-python-driver", + "sha256": "4388e577eb2f85bafe6c5bf44a2f9f40970990e69afb0d2db5879766c22cfbc8", + "size": 196180, + "subdir": "linux-64", + "timestamp": 1535500420985, + "version": "1.6.1" + }, + "neo4j-python-driver-1.6.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aa042e42575ab0a8d8f225bca249bfc8", + "name": "neo4j-python-driver", + "sha256": "d35e986efc81a8a9da6604a05c65d25df98a8f47552adb76a0fe0fbeb349cf14", + "size": 195391, + "subdir": "linux-64", + "timestamp": 1535500467083, + "version": "1.6.1" + }, + "neo4j-python-driver-1.6.2-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3d81a75825bcbf427f82a87e587dc742", + "name": "neo4j-python-driver", + "sha256": "8177e6eebce5a87e8b952836ed2dbc103906c1aa7935e64f591551a2d8560a0e", + "size": 197114, + "subdir": "linux-64", + "timestamp": 1539648672339, + "version": "1.6.2" + }, + "neo4j-python-driver-1.6.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bd5384f9ae0c509bb83ec68cdcda738b", + "name": "neo4j-python-driver", + "sha256": "59b05b75c83f09555d81c4e8bf1fe8de244962eecf4afced61d25ae4278d100b", + "size": 200512, + "subdir": "linux-64", + "timestamp": 1539648697003, + "version": "1.6.2" + }, + "neo4j-python-driver-1.6.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "38e15beb301058c3c3c63920f054c06e", + "name": "neo4j-python-driver", + "sha256": "acf60df898dd0600ce41d97d7333e682f103ced76d29b6f5eba49c0e6f500ae5", + "size": 200128, + "subdir": "linux-64", + "timestamp": 1539648694654, + "version": "1.6.2" + }, + "neo4j-python-driver-1.7.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8b909e1d0d86c4e44c47eea88aaf6587", + "name": "neo4j-python-driver", + "sha256": "0653cc03ab7a99e7c12128aedb9859148a7f86f6bb4648f0a73eb0e9fd6e48b0", + "size": 57077, + "subdir": "linux-64", + "timestamp": 1548315598448, + "version": "1.7.1" + }, + "neo4j-python-driver-1.7.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2eb0f700e3b33ecd42e8254be76be8eb", + "name": "neo4j-python-driver", + "sha256": "6ce9d8e9a2b2d26de45e1916ead1d2f399f2a40a8e8c5b9ba04014ca688a4943", + "size": 57458, + "subdir": "linux-64", + "timestamp": 1548315616919, + "version": "1.7.1" + }, + "neo4j-python-driver-1.7.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1925a89c81ecbc5167c6fbcb3d4ef47a", + "name": "neo4j-python-driver", + "sha256": "adc93758d3c38c9bfdb7acb3c75f1a4e89111900c736b204934e9461d6276ed5", + "size": 57509, + "subdir": "linux-64", + "timestamp": 1548315623095, + "version": "1.7.1" + }, + "neo4j-python-driver-1.7.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b06b9840c9d2de380913314abe12fa1a", + "name": "neo4j-python-driver", + "sha256": "77c1336fc55c1cf68dad103e4c94e66d1f8edc525ea0b3db4720e5e5f74c07e9", + "size": 53936, + "subdir": "linux-64", + "timestamp": 1574354175105, + "version": "1.7.1" + }, + "neo4j-python-driver-4.1.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8aa0e0c73be21279868e7cb4847115aa", + "name": "neo4j-python-driver", + "sha256": "79fb21a79c31dc4f91730ac47baa495ffc08fbb38c7309bcfb16d4ef872bf97a", + "size": 262445, + "subdir": "linux-64", + "timestamp": 1600446251988, + "version": "4.1.1" + }, + "neo4j-python-driver-4.1.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fd927ed718ddf483f61182fa2195806f", + "name": "neo4j-python-driver", + "sha256": "cd0aef4ca31c2d4bb3c4ee9c47086a922451b733800bfc7b7a4feee6969399a5", + "size": 257624, + "subdir": "linux-64", + "timestamp": 1600446236189, + "version": "4.1.1" + }, + "neo4j-python-driver-4.1.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0f317d724f7aa864eca461c6bd7628d2", + "name": "neo4j-python-driver", + "sha256": "b5b651aa6f88c7683c032e764efa525d0e81f69eb4055672a4cbc0d64c11c000", + "size": 263479, + "subdir": "linux-64", + "timestamp": 1600446211701, + "version": "4.1.1" + }, + "neo4j-python-driver-4.2.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1b54e51996e3cc068d8299255d31a3d1", + "name": "neo4j-python-driver", + "sha256": "79440db212dff71542e3728dc8ca666a3b57224a55c1fd42a209ce4adabf2c7c", + "size": 263343, + "subdir": "linux-64", + "timestamp": 1606153805877, + "version": "4.2.0" + }, + "neo4j-python-driver-4.2.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "00377dfaae9a0c13d73c7bbf64338496", + "name": "neo4j-python-driver", + "sha256": "ce44ce8cdf792f35ad69e7d812e4a13bf2c2113147d18f4e6ead053b6b4b401f", + "size": 262247, + "subdir": "linux-64", + "timestamp": 1606153781397, + "version": "4.2.0" + }, + "neo4j-python-driver-4.2.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dadec5b6d6726a159e067475b7bfaa03", + "name": "neo4j-python-driver", + "sha256": "fe8f4f5cf15b4816f072d6432948a2d30bec6952e64418e6b5aac783923d0495", + "size": 261407, + "subdir": "linux-64", + "timestamp": 1606153762969, + "version": "4.2.0" + }, + "neo4j-python-driver-4.2.1-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "05f8097d62933f9af6a519ad506a8387", + "name": "neo4j-python-driver", + "sha256": "52e922405591a980f1e9c4dc04960fcc1224c6adc36d05836b229337c0cde512", + "size": 265745, + "subdir": "linux-64", + "timestamp": 1608577674836, + "version": "4.2.1" + }, + "neo4j-python-driver-4.2.1-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bae6e21cd9f9dd5a5f8e68dc67150e3f", + "name": "neo4j-python-driver", + "sha256": "90e01b418a9b13e8a3d4e6aa34eaf5086c16aacd73af8a1b826e37bad5cbb2fc", + "size": 264965, + "subdir": "linux-64", + "timestamp": 1608577666917, + "version": "4.2.1" + }, + "neo4j-python-driver-4.2.1-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e368f9f8f073380d298639f9a9d642b8", + "name": "neo4j-python-driver", + "sha256": "2c97ace52243b7c4c11322549d527c565ac80a0cedeb222e7c019c3f5a4b2d3f", + "size": 269155, + "subdir": "linux-64", + "timestamp": 1608577670751, + "version": "4.2.1" + }, + "neo4j-python-driver-4.2.1-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e755ab6a880cb6e0467cfb0a074d56b3", + "name": "neo4j-python-driver", + "sha256": "6e0d3038c4608187a858102b01ed13f8fb7109c0e97e9fe69047e2b66413cd30", + "size": 266412, + "subdir": "linux-64", + "timestamp": 1608579557898, + "version": "4.2.1" + }, + "neo4j-python-driver-4.3.1-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7180647e2500c6079efc90349f977747", + "name": "neo4j-python-driver", + "sha256": "8ff447e2ce4b986e98fe68d598a2ec7adf3a3cb0d30b5c8badc0517122a424e7", + "size": 287092, + "subdir": "linux-64", + "timestamp": 1622832415066, + "version": "4.3.1" + }, + "neo4j-python-driver-4.3.1-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5a1d01e162ab13146d65b24c401f4d4e", + "name": "neo4j-python-driver", + "sha256": "57825461129c0deba42714d40112136659fb2110526e7a4badb4650f0dee2395", + "size": 285373, + "subdir": "linux-64", + "timestamp": 1622832416379, + "version": "4.3.1" + }, + "neo4j-python-driver-4.3.1-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "neotime", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "810872563fb230afa2963ef3d9fa4b9f", + "name": "neo4j-python-driver", + "sha256": "82afe4e9bb968d3945f20f43885aa5ce6805e0148899f34ef5a3984f2dfdd889", + "size": 283788, + "subdir": "linux-64", + "timestamp": 1622832434431, + "version": "4.3.1" + }, + "neo4j-python-driver-4.3.1-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5e95fac54b7f1892995296a00e98cc0f", + "name": "neo4j-python-driver", + "sha256": "64f3d0268f3fdf846268ae7442b8824ca024ee26955c18a33781c6f4dca240f3", + "size": 284702, + "subdir": "linux-64", + "timestamp": 1623056903334, + "version": "4.3.1" + }, + "neo4j-python-driver-4.3.2-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c29b04cc57b21617c8017a46a6d4b097", + "name": "neo4j-python-driver", + "sha256": "325b30df730af8216e8b1592b46b02584f4ae2d5534d98084415f58b78952dc2", + "size": 276790, + "subdir": "linux-64", + "timestamp": 1625816304543, + "version": "4.3.2" + }, + "neo4j-python-driver-4.3.3-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6ee83b73ecc678dae464cac662d1438d", + "name": "neo4j-python-driver", + "sha256": "8308c02e98457c19f60276a9f954cbeb84bfc48c59dd976abdf539d7ed4568f8", + "size": 278096, + "subdir": "linux-64", + "timestamp": 1626240217775, + "version": "4.3.3" + }, + "neo4j-python-driver-4.3.4-py36h7f8727e_0.conda": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8001f8d94b45334ae4cf6ca20e0bf630", + "name": "neo4j-python-driver", + "sha256": "d5a5619e9cde2141f1402fddf55f5993868d682ac7d74d45cdbf9acf5c097058", + "size": 282977, + "subdir": "linux-64", + "timestamp": 1632894470778, + "version": "4.3.4" + }, + "neo4j-python-driver-4.3.4-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9928bd227ba91335d4d9536263eb03b5", + "name": "neo4j-python-driver", + "sha256": "8dcd4233101660c1266fe395da64349b101ead59ffac1244c53c44a8ec9d8a05", + "size": 282436, + "subdir": "linux-64", + "timestamp": 1632894449824, + "version": "4.3.4" + }, + "neo4j-python-driver-4.3.4-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0e7de9919672dda453ae6d3e75e0d7a7", + "name": "neo4j-python-driver", + "sha256": "710396f6cd1bcb5ac4de90b905cc5d52166c1b4e51067d7442d7b4ac527f4fcb", + "size": 281226, + "subdir": "linux-64", + "timestamp": 1632884026735, + "version": "4.3.4" + }, + "neo4j-python-driver-4.3.4-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "963207489a4372ba03a7f312d68d8410", + "name": "neo4j-python-driver", + "sha256": "ab22dee470b3a22436135b49345b1f9e53cc9c71d365c86a7edca27f19cb903f", + "size": 279696, + "subdir": "linux-64", + "timestamp": 1628152080160, + "version": "4.3.4" + }, + "neo4j-python-driver-4.4.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "29e5be62a1ad32c41bbb3a3ba2f51244", + "name": "neo4j-python-driver", + "sha256": "6bdd72cde0fe6b15bdf11bdf8d6ef441ee50dae6b11057259b04212349435c25", + "size": 304691, + "subdir": "linux-64", + "timestamp": 1640809595243, + "version": "4.4.0" + }, + "neo4j-python-driver-4.4.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3a4ace17a061759f9d1a089d7e447cd5", + "name": "neo4j-python-driver", + "sha256": "d97450440a3ec3876fe62495cc82a742cc1610b77d5478ce2fe3634b4a985e6e", + "size": 413653, + "subdir": "linux-64", + "timestamp": 1676859934644, + "version": "4.4.0" + }, + "neo4j-python-driver-4.4.0-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "09a7d9370c4e7fadb0e04564bbf70af5", + "name": "neo4j-python-driver", + "sha256": "0415772a2dc3abdc314265b781f484c9aca36e6fc8104b2b4e8d620b8a51f846", + "size": 299641, + "subdir": "linux-64", + "timestamp": 1639143576396, + "version": "4.4.0" + }, + "neo4j-python-driver-4.4.0-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "894ddae3a076cf9192b34292f07f08ec", + "name": "neo4j-python-driver", + "sha256": "dabcb5f82894bb534b42352ee2eed232fc709829bd845ad1e633c5e9f1da65e8", + "size": 302469, + "subdir": "linux-64", + "timestamp": 1639129998909, + "version": "4.4.0" + }, + "neo4j-python-driver-4.4.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5b85984000e846704b2398a4aef85c18", + "name": "neo4j-python-driver", + "sha256": "c52f8120366a4c07404a3f2c1ab388ed563d7d3d44f01a0e8ed83a3d5ced0157", + "size": 302015, + "subdir": "linux-64", + "timestamp": 1639143575346, + "version": "4.4.0" + }, + "neon-2.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=2.7,<2.8.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4d6ca5c4b7b410a6aaadaab8a271e0a5", + "name": "neon", + "sha256": "eff21baefa44df211974a57d38e3a48ac295693e11be1f3114c448bf4cec3e46", + "size": 633294, + "subdir": "linux-64", + "timestamp": 1539277024446, + "version": "2.6.0" + }, + "neon-2.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=3.10,<3.11.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ce115ff018242bdb6a3952d63bdbc433", + "name": "neon", + "sha256": "e70c9f463267de61260abbd82cf422092c0764cfe8915d4e3041dea2600efdbe", + "size": 634281, + "subdir": "linux-64", + "timestamp": 1642516077032, + "version": "2.6.0" + }, + "neon-2.6.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=3.11,<3.12.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b534a2ffef2e9a0bac3c833d37683294", + "name": "neon", + "sha256": "91ebaf6974cd2df36750fe0b0b189e486737d3d664c70a524fa3f6746ed76423", + "size": 813268, + "subdir": "linux-64", + "timestamp": 1676907347409, + "version": "2.6.0" + }, + "neon-2.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=3.6,<3.7.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "80ee02f5102dec4607a7927544d4c03a", + "name": "neon", + "sha256": "ac67cfe2dd06e08e613e7180327e5beb7e3943e4f57d811059fd494f76811f34", + "size": 639552, + "subdir": "linux-64", + "timestamp": 1539277022823, + "version": "2.6.0" + }, + "neon-2.6.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=3.6,<3.7.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "07f0045bb4720c262f26d4e543024cca", + "name": "neon", + "sha256": "3ea6e8737093756b5104c78613db7c47d89e7c296d15aa731c9a65ec000ad9ab", + "size": 876764, + "subdir": "linux-64", + "timestamp": 1614082820406, + "version": "2.6.0" + }, + "neon-2.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=3.7,<3.8.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7794ec52913fd81d26a3b9c181f45edc", + "name": "neon", + "sha256": "b423fccc470fdac90a924d9546bc1bdbed3b0c5f4c48312d2e2f95d4d5f04d05", + "size": 638234, + "subdir": "linux-64", + "timestamp": 1539277032483, + "version": "2.6.0" + }, + "neon-2.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=3.7,<3.8.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "401df968abfe61e3620827284adae54a", + "name": "neon", + "sha256": "08c7076a38b72929dfd6ec18d245d56cf1aa5242b8a049597848158b1979f26d", + "size": 876164, + "subdir": "linux-64", + "timestamp": 1614082832978, + "version": "2.6.0" + }, + "neon-2.6.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=3.8,<3.9.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ccc5a3935ba980ab1352b126a40760fb", + "name": "neon", + "sha256": "83fb2ce973ed7b46bb9d11d4df44a6d21586369f4ddde580735ded9d69d3801e", + "size": 636041, + "subdir": "linux-64", + "timestamp": 1574177594889, + "version": "2.6.0" + }, + "neon-2.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=3.8,<3.9.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "819d489789f963f88d2f9689bb9deaa8", + "name": "neon", + "sha256": "2df25f0f69d08dd20fa7456d91c0365b8e221325f5a7083896ec8cd8ae6ccf42", + "size": 879137, + "subdir": "linux-64", + "timestamp": 1614081901902, + "version": "2.6.0" + }, + "neon-2.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs", + "bokeh", + "cffi", + "configargparse", + "filelock", + "future", + "h5py", + "jinja2", + "numpy", + "pillow", + "py-cpuinfo", + "python >=3.9,<3.10.0a0", + "pyyaml" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2b6105f739c6a23e63767b3f594c0cfc", + "name": "neon", + "sha256": "727eef45a376d486cd2fb8cf6fbc845b5e081444ae5cd6c2de047f7ee46dc5d9", + "size": 876702, + "subdir": "linux-64", + "timestamp": 1614082830835, + "version": "2.6.0" + }, + "neotime-1.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "647f188f64ed8d191635fe03e4c8b05f", + "name": "neotime", + "sha256": "9ffbf9d371efeee61c74bb32060a496a12726ac279255a2a4ee03004eb0df86d", + "size": 33426, + "subdir": "linux-64", + "timestamp": 1527831764410, + "version": "1.0.0" + }, + "neotime-1.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "504a877b85c9165802d1ab632f586fae", + "name": "neotime", + "sha256": "ce0f593e77779c090fcb68ac87fa1c5e4bd57e9d9353b7c7e3faf5077b922922", + "size": 33959, + "subdir": "linux-64", + "timestamp": 1527831788682, + "version": "1.0.0" + }, + "neotime-1.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "bf781b1c57962c2f7b5d612be927aa82", + "name": "neotime", + "sha256": "329e4db3c072c0077447c95985932fdd3e99744cf7f97bba0b167ebff63a50a1", + "size": 33901, + "subdir": "linux-64", + "timestamp": 1527831750272, + "version": "1.0.0" + }, + "neotime-1.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "49ecf0724de3346f77899a2c185903e1", + "name": "neotime", + "sha256": "d45ba78c1cd18444b5f67ab0cb425a8706a39602135508b4a4063da2c5968a2a", + "size": 33845, + "subdir": "linux-64", + "timestamp": 1530901479876, + "version": "1.0.0" + }, + "neotime-1.7.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "c73ee185b4cfba2d477bd1590cdb551e", + "name": "neotime", + "sha256": "771d8a5b39c5aa8d73311a506d34e03c60567ad654f73064abde359ecacfa561", + "size": 38558, + "subdir": "linux-64", + "timestamp": 1539724322521, + "version": "1.7.1" + }, + "neotime-1.7.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "60a507230b7031e480a822b75602146c", + "name": "neotime", + "sha256": "1410cf07737cb1b088db1b7f61034621b843e7207998297f31291611c0102e70", + "size": 39111, + "subdir": "linux-64", + "timestamp": 1539724350062, + "version": "1.7.1" + }, + "neotime-1.7.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "d212d31d7498e70a1cf083c751597875", + "name": "neotime", + "sha256": "df99caca58ba48c6d0fc367a50c117b4ec81148ad913e7a21dcbefab404282bc", + "size": 38971, + "subdir": "linux-64", + "timestamp": 1539724347621, + "version": "1.7.1" + }, + "neotime-1.7.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "70c168222e96ac1272a8f365fe07612b", + "name": "neotime", + "sha256": "4faf5e02263672f1471c01c34959f2b50eb8f05f50e0daf063f084b9442f2563", + "size": 39836, + "subdir": "linux-64", + "timestamp": 1545120408730, + "version": "1.7.4" + }, + "neotime-1.7.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "6cb7782cdff46a093784cb1e5424e2a2", + "name": "neotime", + "sha256": "861848d57fb4c41b08db0c58f4722548ae56336b229338508ca479367d2a41a0", + "size": 41310, + "subdir": "linux-64", + "timestamp": 1640791885711, + "version": "1.7.4" + }, + "neotime-1.7.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "91003c943878e6b7d1484fc3d605c0b1", + "name": "neotime", + "sha256": "eddbf66e3fa04fa6ab6cddb7f54175a7ac68c182e38872e09f815a4ff8763b83", + "size": 52127, + "subdir": "linux-64", + "timestamp": 1676907365509, + "version": "1.7.4" + }, + "neotime-1.7.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "e535cd93f3d730c15b3927934752f1bd", + "name": "neotime", + "sha256": "9e41e454900f31a29111d2fb9c219b1b9687af7e885fd2c08c74d716a09fe742", + "size": 40447, + "subdir": "linux-64", + "timestamp": 1545120443628, + "version": "1.7.4" + }, + "neotime-1.7.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "4d1c8cb0887fe9ef6650f5ebab508dcd", + "name": "neotime", + "sha256": "5922faceb1008334de98ab5bd9a48f93b8760375e4a466b39bbe739022a6f8e8", + "size": 40485, + "subdir": "linux-64", + "timestamp": 1545120448749, + "version": "1.7.4" + }, + "neotime-1.7.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "d03586c0bb2e3fe1749452ed6e6b93b1", + "name": "neotime", + "sha256": "0ef1724a9fe88875d89f738f0858f8bb861818c9b0e0ec4e631498fcddb7ded7", + "size": 40767, + "subdir": "linux-64", + "timestamp": 1573738326635, + "version": "1.7.4" + }, + "neotime-1.7.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytz", + "six" + ], + "license": "Apache Software License", + "license_family": "Apache", + "md5": "6aeb9e5cac0fbcdcacfea2a83b013131", + "name": "neotime", + "sha256": "6e21ffd9750f8fac2e78936e29f632f63f154fd6b69f6ec890af2a0425fbc436", + "size": 263496, + "subdir": "linux-64", + "timestamp": 1608578515235, + "version": "1.7.4" + }, + "nest-asyncio-1.5.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "38b3a91da879bb3527698a292bffc26a", + "name": "nest-asyncio", + "sha256": "3d12a01771709498edc17b3e86dae9887a000aec5bd09172fcb8698c704da94e", + "size": 16242, + "subdir": "linux-64", + "timestamp": 1649830102129, + "version": "1.5.5" + }, + "nest-asyncio-1.5.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c0e82947520c1eb21a7d8ca5d4e08e30", + "name": "nest-asyncio", + "sha256": "d03086e37b69aa89566766837c8fe16431465f580499d01e8502d10fb0c001c3", + "size": 16117, + "subdir": "linux-64", + "timestamp": 1677784395188, + "version": "1.5.5" + }, + "nest-asyncio-1.5.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "cb475ee5273caa5a1685135b9f3cee4e", + "name": "nest-asyncio", + "sha256": "cf9f162e1ded8f57cbcdda0c8113ab95d7891b7007a2d9b0550879fdb9da3d30", + "size": 16108, + "subdir": "linux-64", + "timestamp": 1649847948369, + "version": "1.5.5" + }, + "nest-asyncio-1.5.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "bbf9623dd1f0b2d8091f8b5a6eb63da5", + "name": "nest-asyncio", + "sha256": "61157d251407aa8ae6f4f1979a3dd8d1702aad78bdd186943a4efbbf5e629513", + "size": 16085, + "subdir": "linux-64", + "timestamp": 1649847945010, + "version": "1.5.5" + }, + "nest-asyncio-1.5.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "42ad3a041fd65b749d817a61d9df260b", + "name": "nest-asyncio", + "sha256": "a636e36b4af90534a60b2f266a4591c4e722f967c176f07c596e227b3e244452", + "size": 16281, + "subdir": "linux-64", + "timestamp": 1649847942243, + "version": "1.5.5" + }, + "nest-asyncio-1.5.6-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a073174f1b672363bc535392a1e031b0", + "name": "nest-asyncio", + "sha256": "d3c22ecb1ecaac18a3f2d7c825da066338b71bf79ef04ccdd6db619a34d1ca6a", + "size": 14844, + "subdir": "linux-64", + "timestamp": 1672387223720, + "version": "1.5.6" + }, + "nest-asyncio-1.5.6-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "0a89aa9b5e5e36efeef8d4df24f6c39c", + "name": "nest-asyncio", + "sha256": "aa24de2bd4c097451acda3d5a5ef3052477b2d596a1a6148f4578762278d7ccd", + "size": 16977, + "subdir": "linux-64", + "timestamp": 1676823394794, + "version": "1.5.6" + }, + "nest-asyncio-1.5.6-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "6740c7cdeab99faa7ee9360703173194", + "name": "nest-asyncio", + "sha256": "1f042bbc278902fa2dce14421ddf69e4bdb27d5557cc2ea72b908d42c38fdbaf", + "size": 14626, + "subdir": "linux-64", + "timestamp": 1672387197034, + "version": "1.5.6" + }, + "nest-asyncio-1.5.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a2045f4ce9cf4d0011e8bcf9c6d4a6e3", + "name": "nest-asyncio", + "sha256": "45fba4fd2172fb580edbeb40dc69c618c62267c89f05f76fb40bafd7ed9d6a0e", + "size": 14649, + "subdir": "linux-64", + "timestamp": 1672387169775, + "version": "1.5.6" + }, + "nest-asyncio-1.5.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8320fdf3e688823edcbb724d84d1de75", + "name": "nest-asyncio", + "sha256": "432a0aa60c2a15ce4f71105f370482e097dfee25b5f72e3b3628e37759e4ff10", + "size": 14773, + "subdir": "linux-64", + "timestamp": 1672387143252, + "version": "1.5.6" + }, + "netcdf4-1.3.1-py27h03bd486_2.conda": { + "build": "py27h03bd486_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.5.0,<5.0a0", + "numpy >=1.14.0,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "e8bfc40c228d7e875a60c6fffb551ecb", + "name": "netcdf4", + "sha256": "05edc26b1c8c7e7c13e97ce617b3e7b3d70d33881ad94ee4441219c01526909d", + "size": 671694, + "subdir": "linux-64", + "timestamp": 1518363667560, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py27h73d701b_2.conda": { + "build": "py27h73d701b_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.5.0,<5.0a0", + "numpy >=1.14.0,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "918352db10a1c9b74b4d69dc3dc8d4d5", + "name": "netcdf4", + "sha256": "3c33b7197f49ca4facefd498abe623e66b115b437f082fcf262bc21d15b4ba4b", + "size": 673796, + "subdir": "linux-64", + "timestamp": 1518363705925, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py27h7620a78_2.conda": { + "build": "py27h7620a78_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "5264f5aaa241538768375909750f6dc5", + "name": "netcdf4", + "sha256": "176afdcc1dfbef18f57e400ebfffc69d575a1e6e9691861f814c8a8491139c5d", + "size": 669558, + "subdir": "linux-64", + "timestamp": 1511886279654, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py27hca9ce0b_2.conda": { + "build": "py27hca9ce0b_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "70e8b288abea321c9eeee1cec8cb1b3f", + "name": "netcdf4", + "sha256": "2df9f5b4406209f9639a58d32bc873091223bea28ef2e66b025b4a0bdc2b961a", + "size": 671005, + "subdir": "linux-64", + "timestamp": 1511886709425, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py35h03bd486_2.conda": { + "build": "py35h03bd486_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.5.0,<5.0a0", + "numpy >=1.14.0,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "ab86d4c9e977cbb0fc4fa54fc71d5e62", + "name": "netcdf4", + "sha256": "9009cecf408e34bf810d04285e102cc542ae4b2cf265b134fb6d2c5238d5e1ae", + "size": 673176, + "subdir": "linux-64", + "timestamp": 1518363694708, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py35h30e38b8_2.conda": { + "build": "py35h30e38b8_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "f7b695d320d09c7a3e0978fd3d0e15de", + "name": "netcdf4", + "sha256": "cabdc6b9a6d08513a1b7d20d45e2950114336490ad9755f0324992764d83482d", + "size": 665891, + "subdir": "linux-64", + "timestamp": 1511886713431, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py35h73d701b_2.conda": { + "build": "py35h73d701b_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.5.0,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "59668b1b82320d265c01cfe5d416aec0", + "name": "netcdf4", + "sha256": "401536f2aaf620b1b49932b08733db0d472d6f00c9c01e2b2edd74e912c7cf1c", + "size": 673184, + "subdir": "linux-64", + "timestamp": 1518363715132, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py35he671f65_2.conda": { + "build": "py35he671f65_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "10431628d8079475256d5c3273060f17", + "name": "netcdf4", + "sha256": "e49b03787e0da7ff4acfbb4bcef60aeccd0182fe39da2247b8d1ea5dab0e5595", + "size": 667610, + "subdir": "linux-64", + "timestamp": 1511886280672, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py36h03bd486_2.conda": { + "build": "py36h03bd486_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.5.0,<5.0a0", + "numpy >=1.14.0,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "4c1a2c97b9bc9276267385e8673d2e55", + "name": "netcdf4", + "sha256": "426e2cafb7e13126e491a845a64ca1b639e76d1c5ac239afaefa1cf90721a893", + "size": 696990, + "subdir": "linux-64", + "timestamp": 1518363361651, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py36h73d701b_2.conda": { + "build": "py36h73d701b_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.5.0,<5.0a0", + "numpy >=1.14.0,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "33629059438a0390b8ae72399ab0422f", + "name": "netcdf4", + "sha256": "daed406db0b6c387e1e1603407c31dc8d290529d1289d1178d5dba557eec6dc1", + "size": 697504, + "subdir": "linux-64", + "timestamp": 1518363699990, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py36h771828c_2.conda": { + "build": "py36h771828c_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "7705f821bc9f7f28601c97246405ba93", + "name": "netcdf4", + "sha256": "d642af42f9dcdc796544757f03101829a474aaf735b32108c67724f5785cbf3e", + "size": 692463, + "subdir": "linux-64", + "timestamp": 1511886732450, + "version": "1.3.1" + }, + "netcdf4-1.3.1-py36hfd655bd_2.conda": { + "build": "py36hfd655bd_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "d923593d40f974b7dd762096fbc9e8ae", + "name": "netcdf4", + "sha256": "a31529f7a8bcd14781f109240ae83bc48563603c038489c01335c2c9682f162e", + "size": 692403, + "subdir": "linux-64", + "timestamp": 1511886728330, + "version": "1.3.1" + }, + "netcdf4-1.4.0-py27h044acb6_1.conda": { + "build": "py27h044acb6_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "0ac26f2026ebd8d4b980a7167b868ea1", + "name": "netcdf4", + "sha256": "6eb72fcbd3800b91ef7943eb127b265cbe66dc612758aded4f2ccfea40b51689", + "size": 477808, + "subdir": "linux-64", + "timestamp": 1526241402976, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py27h0bb92ad_1.conda": { + "build": "py27h0bb92ad_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "d832353b07585614cb53e079a0fa434c", + "name": "netcdf4", + "sha256": "33e2c7ce2819c77cd0e96305cb054349ef8d2cf463d634ca06692a8fde0b0e19", + "size": 479678, + "subdir": "linux-64", + "timestamp": 1530902243178, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py27ha06eab4_1.conda": { + "build": "py27ha06eab4_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "e2fa00648bf58047060f88188f6a4c1f", + "name": "netcdf4", + "sha256": "ea6b76638594558af86ac10ab5903e89c408be40b46ad4f2831923258c34fda9", + "size": 479199, + "subdir": "linux-64", + "timestamp": 1530902164336, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py27hd4b6044_1.conda": { + "build": "py27hd4b6044_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "715eb3041013b354e0a2f917ff46cb62", + "name": "netcdf4", + "sha256": "fd13cee4aba0a0fe2d700c0d54fef25624f60c234fb61940151243e67b7c7ff3", + "size": 477894, + "subdir": "linux-64", + "timestamp": 1526241296747, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py35h044acb6_1.conda": { + "build": "py35h044acb6_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "b71009c9d535bffe2d4d8358ae7fe908", + "name": "netcdf4", + "sha256": "d22110d2d42712ea2248d1284b79012ed2f0bc061ce4eef7eed551b42f12412d", + "size": 481207, + "subdir": "linux-64", + "timestamp": 1526253869871, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py35hd4b6044_1.conda": { + "build": "py35hd4b6044_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "f4ebe5b1e606dbf0d589e980b9a77cb1", + "name": "netcdf4", + "sha256": "4b972b05a2b3444f3c6448835854b4385f7c386c1b06a553028e09d165f791f4", + "size": 481234, + "subdir": "linux-64", + "timestamp": 1526254055240, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py36h044acb6_1.conda": { + "build": "py36h044acb6_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "d908b7331d9ec3f91d0754b03186e821", + "name": "netcdf4", + "sha256": "059c8fea06df18407e4ad0afd3cede35d7b169d15592f8d1273293bcde1ecf32", + "size": 493718, + "subdir": "linux-64", + "timestamp": 1526241296953, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py36h0bb92ad_1.conda": { + "build": "py36h0bb92ad_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "d33035cf10198b1c5b4001ff7ca449c9", + "name": "netcdf4", + "sha256": "deb0f0fb569f45c1637afe71cadad936add65ccfa21a9e2cf06600be97c530d0", + "size": 493856, + "subdir": "linux-64", + "timestamp": 1530902084874, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py36ha06eab4_1.conda": { + "build": "py36ha06eab4_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "a0dcd4c5d423658aa68ac815777449ea", + "name": "netcdf4", + "sha256": "69e1718d4aed84f1a66005463039d3f9802d670127d2c0fbf2451f948f7d5d8b", + "size": 493042, + "subdir": "linux-64", + "timestamp": 1530902000224, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py36hd4b6044_1.conda": { + "build": "py36hd4b6044_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "bd409b9d75906eaac5a21cc8cfede3f1", + "name": "netcdf4", + "sha256": "bc89159eae40c5eba51f636e0ae6fd32ce429bc077bdc4639771831d82fc8043", + "size": 493331, + "subdir": "linux-64", + "timestamp": 1526241296867, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py37h0bb92ad_1.conda": { + "build": "py37h0bb92ad_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "239a85ad126f3f64b0a75281811bf8eb", + "name": "netcdf4", + "sha256": "31280e652970b925aae91cc2e5f99ff7cfecc4b913426d96e527e7915173ebfa", + "size": 492422, + "subdir": "linux-64", + "timestamp": 1530901915926, + "version": "1.4.0" + }, + "netcdf4-1.4.0-py37ha06eab4_1.conda": { + "build": "py37ha06eab4_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "be7d83a8d47c978e3d7ec5a290c4fbbf", + "name": "netcdf4", + "sha256": "d31c9904b10139f09f3773ddb1989c393e0f80384de4e2426db9fceaeb16e41b", + "size": 490040, + "subdir": "linux-64", + "timestamp": 1530901830507, + "version": "1.4.0" + }, + "netcdf4-1.4.1-py27h083d9da_0.conda": { + "build": "py27h083d9da_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "9f93fbc25da9c4f2978efacfd167ab26", + "name": "netcdf4", + "sha256": "2552f12a87cd3856262b978033deefbc9d349a603e2ee06a0db08b51662f8bda", + "size": 483556, + "subdir": "linux-64", + "timestamp": 1535559147402, + "version": "1.4.1" + }, + "netcdf4-1.4.1-py27h4b4f87f_0.conda": { + "build": "py27h4b4f87f_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "3aae3768e651d634496a2f846a303a0d", + "name": "netcdf4", + "sha256": "558e6c5f0ea5d63a401326ab56543292d56c99da42222b8c7bdd24db054b0423", + "size": 483561, + "subdir": "linux-64", + "timestamp": 1535558849433, + "version": "1.4.1" + }, + "netcdf4-1.4.1-py35h083d9da_0.conda": { + "build": "py35h083d9da_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "449ec032ec6d972fa3507011cade9cb3", + "name": "netcdf4", + "sha256": "4ab25aa646930e4351769f6e3984964eb272fcb015c18239360ef26ceae29693", + "size": 483854, + "subdir": "linux-64", + "timestamp": 1535558942685, + "version": "1.4.1" + }, + "netcdf4-1.4.1-py35h4b4f87f_0.conda": { + "build": "py35h4b4f87f_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "260a39c7f9a9ecbe1569d89ec1eabfc9", + "name": "netcdf4", + "sha256": "68cbbe271f6ac3276372dc253032e28d0c1dcff4d1f597e7f26dabf6cb1a84d0", + "size": 485441, + "subdir": "linux-64", + "timestamp": 1535558791248, + "version": "1.4.1" + }, + "netcdf4-1.4.1-py36h083d9da_0.conda": { + "build": "py36h083d9da_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "f61d92fc5055dd3df2f1e51e94d9eed0", + "name": "netcdf4", + "sha256": "da6291b7b3adfbbd7250edceb73c2697742da7872997bac924018fdb2756a140", + "size": 496920, + "subdir": "linux-64", + "timestamp": 1535558854959, + "version": "1.4.1" + }, + "netcdf4-1.4.1-py36h4b4f87f_0.conda": { + "build": "py36h4b4f87f_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "da220d56e1e72738a946beda7bc91a5f", + "name": "netcdf4", + "sha256": "e1a94c77e2972d50e2ebca6facfd8e1d91a78e08d84429f68912a5e0f78c8b75", + "size": 496337, + "subdir": "linux-64", + "timestamp": 1535559054817, + "version": "1.4.1" + }, + "netcdf4-1.4.1-py37h083d9da_0.conda": { + "build": "py37h083d9da_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "9721a97969654672afc4f07e976f43c0", + "name": "netcdf4", + "sha256": "e29f4b5f430d45cc90f862cea5fe5eb03b862c4b78d4bf057c58cf0568345488", + "size": 494968, + "subdir": "linux-64", + "timestamp": 1535559233173, + "version": "1.4.1" + }, + "netcdf4-1.4.1-py37h4b4f87f_0.conda": { + "build": "py37h4b4f87f_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "4c9073956d9e69f4e1e670d9f78347b9", + "name": "netcdf4", + "sha256": "70d2c63dce8995b50faecb360adb29eb0abe3778649e4afe903361744c392284", + "size": 495061, + "subdir": "linux-64", + "timestamp": 1535559258352, + "version": "1.4.1" + }, + "netcdf4-1.4.2-py27h083d9da_0.conda": { + "build": "py27h083d9da_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "3d7c68f6a05a9a0814dfbd8c96adad82", + "name": "netcdf4", + "sha256": "498e1d7860cf6a74e26d9f448333da605044f2cef9da40af4b4af4498c6def35", + "size": 463824, + "subdir": "linux-64", + "timestamp": 1541021399962, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py27h4b4f87f_0.conda": { + "build": "py27h4b4f87f_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "d012478dc3b4f49226204e8ef40ec84e", + "name": "netcdf4", + "sha256": "1e6b3dd12a3e60183bd6000c6e81f241b3dd153e75f68058e33ee27b356157c7", + "size": 463831, + "subdir": "linux-64", + "timestamp": 1541021514725, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py27h808af73_0.conda": { + "build": "py27h808af73_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "58380cfa82e58a668e9973090e22544f", + "name": "netcdf4", + "sha256": "a5e985682fae36983fa3d790ccfe8d36c2199091b9e2051de5401543bdcf72e0", + "size": 463915, + "subdir": "linux-64", + "timestamp": 1545407135615, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py36h083d9da_0.conda": { + "build": "py36h083d9da_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "d397b1ffe790afed7efcbd4ef90467e3", + "name": "netcdf4", + "sha256": "096c66ef68ae0a1cb1ee796a708b752385643a8c03345e92282f93edc9605493", + "size": 491424, + "subdir": "linux-64", + "timestamp": 1541021485723, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py36h4b4f87f_0.conda": { + "build": "py36h4b4f87f_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "c95e822c19c0661fcbbc2f4e7aac8c3d", + "name": "netcdf4", + "sha256": "a7bdf0a5fa828a49640a099fe34719a0d76b09194015f975e5e3287bb11f84a1", + "size": 491493, + "subdir": "linux-64", + "timestamp": 1541021491591, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py36h808af73_0.conda": { + "build": "py36h808af73_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "7dcb097683556f0e514b8f76ffdc3c87", + "name": "netcdf4", + "sha256": "21246d69bf9f1f5b0f5ddf77161fe389467ca36f912767be13af66d19cede0c0", + "size": 491178, + "subdir": "linux-64", + "timestamp": 1545407163532, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py36hd5c503a_0.conda": { + "build": "py36hd5c503a_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "95d641366962d5d6be0c9398d7824ef6", + "name": "netcdf4", + "sha256": "31b9cd3e56da7ac271dd0aacc0ab46952132e28705d828c2febbf7b72c14f231", + "size": 436679, + "subdir": "linux-64", + "timestamp": 1613633671203, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py37h083d9da_0.conda": { + "build": "py37h083d9da_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "a6fadf5fea1e5a87942d993b7aaed901", + "name": "netcdf4", + "sha256": "1c14c1058d822b9a3acb3164a165c7fde9b1ffe86641888f775250f27d5cad2d", + "size": 488937, + "subdir": "linux-64", + "timestamp": 1541021286037, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py37h4b4f87f_0.conda": { + "build": "py37h4b4f87f_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "33ab516a46ad0f285baa443bb78c091c", + "name": "netcdf4", + "sha256": "2ca7910fafe9e7d77e933ae3cc77da1948ad1fff82baea0f4526505e815a6a7a", + "size": 488963, + "subdir": "linux-64", + "timestamp": 1541021366560, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py37h808af73_0.conda": { + "build": "py37h808af73_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "8e212fbcc310bf39a35eaa5fc2fcc5a8", + "name": "netcdf4", + "sha256": "12b6acbe4387a75ec23c972bd4a05ca8068b11b94927022fef94d76ff7c2a552", + "size": 488215, + "subdir": "linux-64", + "timestamp": 1545407167170, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py37hd5c503a_0.conda": { + "build": "py37hd5c503a_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "9d75daf4fdf37646a16f257d94260047", + "name": "netcdf4", + "sha256": "bf8ac4b72c277d66b214d2c8aa903f8333de419b8db3e2872a61dbc061d69516", + "size": 433962, + "subdir": "linux-64", + "timestamp": 1613634550762, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py38hd5c503a_0.conda": { + "build": "py38hd5c503a_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "02509e3a0c5842040be1417ab4ce9532", + "name": "netcdf4", + "sha256": "0e8566ca6e85ff9fdb0b1b2764561a86a80d5af2dfd8dfe490a26be7227e6b4f", + "size": 462187, + "subdir": "linux-64", + "timestamp": 1613634567659, + "version": "1.4.2" + }, + "netcdf4-1.4.2-py39hd5c503a_0.conda": { + "build": "py39hd5c503a_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "3ff3306f67d6b2ac4dffa43334982225", + "name": "netcdf4", + "sha256": "4f4a01329490cfbf8241269de88877b4bd4cb87b4eb568dadb4bb4d6a7a9a8ba", + "size": 463435, + "subdir": "linux-64", + "timestamp": 1613633862778, + "version": "1.4.2" + }, + "netcdf4-1.5.3-py36hbf33ddf_0.conda": { + "build": "py36hbf33ddf_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.7.3,<5.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "0e849207c566e77eeb7268d7163e74fe", + "name": "netcdf4", + "sha256": "e59f2e3e321b49c4830d46ff2369d6b5e0ac72ce2cc3eab2973ea14a41865633", + "size": 513133, + "subdir": "linux-64", + "timestamp": 1582227310354, + "version": "1.5.3" + }, + "netcdf4-1.5.3-py37hbf33ddf_0.conda": { + "build": "py37hbf33ddf_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.7.3,<5.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "7e9e144bca7d1ad23eb32a2f0d44d117", + "name": "netcdf4", + "sha256": "19c832748717875bb97f14d34f84c37ada27d7d3a772372ce2a8de9519e2d350", + "size": 509444, + "subdir": "linux-64", + "timestamp": 1582227337484, + "version": "1.5.3" + }, + "netcdf4-1.5.3-py38hbf33ddf_0.conda": { + "build": "py38hbf33ddf_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.7.3,<5.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "10fb2cb4151c46d5c75e240f781a9f39", + "name": "netcdf4", + "sha256": "af3e08da33342e2881e15c97002324371d0480b9ddf55300e46e2a26d00bbd08", + "size": 539491, + "subdir": "linux-64", + "timestamp": 1582227382974, + "version": "1.5.3" + }, + "netcdf4-1.5.6-py36hd5c503a_0.conda": { + "build": "py36hd5c503a_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "7bdf0f659972c6b0bfa9a88c7922a639", + "name": "netcdf4", + "sha256": "2fea1bedcd9179b690af1c87597ec7e0abea33526c1f0338a9b1bf38d2a55bad", + "size": 441817, + "subdir": "linux-64", + "timestamp": 1613684297490, + "version": "1.5.6" + }, + "netcdf4-1.5.6-py37hd5c503a_0.conda": { + "build": "py37hd5c503a_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "4c51f78c660de22095ffc9461c7666c7", + "name": "netcdf4", + "sha256": "28d6ed1aa0681f35a35e70404d9a9e4ce6c5b87629e8ba540ce307486485a779", + "size": 439767, + "subdir": "linux-64", + "timestamp": 1613683560462, + "version": "1.5.6" + }, + "netcdf4-1.5.6-py38hd5c503a_0.conda": { + "build": "py38hd5c503a_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "2c07a1ee604663ec214d95673ee232c8", + "name": "netcdf4", + "sha256": "39287e3da954afa432e9659711cb9e15ef17d18d0840831638d4ae3a4a5696d0", + "size": 470217, + "subdir": "linux-64", + "timestamp": 1613684297569, + "version": "1.5.6" + }, + "netcdf4-1.5.6-py39hd5c503a_0.conda": { + "build": "py39hd5c503a_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "291419679cc117cbd5675e61110d5708", + "name": "netcdf4", + "sha256": "350ad9dbf89f6cc76bcd9dc7bfb6e8969dc0e8aff5619b08b7134a624413a67c", + "size": 471894, + "subdir": "linux-64", + "timestamp": 1613684286336, + "version": "1.5.6" + }, + "netcdf4-1.5.7-py310hf533683_0.conda": { + "build": "py310hf533683_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9348c9d4dd4c8f7a8cb0dc7d2eb6978", + "name": "netcdf4", + "sha256": "835f696563bba5dfc16703b7951fbd27d309bff19ed8e331106d5cd662c5add5", + "size": 1605246, + "subdir": "linux-64", + "timestamp": 1640809654226, + "version": "1.5.7" + }, + "netcdf4-1.5.7-py36h0a24e14_0.conda": { + "build": "py36h0a24e14_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "1c8245c6e7d7f5ae72c67ae650bc15c4", + "name": "netcdf4", + "sha256": "d27d7bf6da5755bdd7025425ea11190cd02eae4ba231869770b8504baf1c2b22", + "size": 440288, + "subdir": "linux-64", + "timestamp": 1624382985181, + "version": "1.5.7" + }, + "netcdf4-1.5.7-py37h0a24e14_0.conda": { + "build": "py37h0a24e14_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "843db9a4e26598a9012e14372e3746e5", + "name": "netcdf4", + "sha256": "0d0613be5b2119058e580b63c7929fbb25c33bdec64022729cbf2253c7dcad28", + "size": 438528, + "subdir": "linux-64", + "timestamp": 1624382987458, + "version": "1.5.7" + }, + "netcdf4-1.5.7-py37ha0f2276_1.conda": { + "build": "py37ha0f2276_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.8,<4.9.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0144ae57166f917c0877a773dff4d631", + "name": "netcdf4", + "sha256": "1224bd3fb66487418ee926dcdef3bd5dfe6f5028df61e55e88d35c0e4e9ca794", + "size": 438955, + "subdir": "linux-64", + "timestamp": 1643311678255, + "version": "1.5.7" + }, + "netcdf4-1.5.7-py38h0a24e14_0.conda": { + "build": "py38h0a24e14_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "7d963b85e79b53089ef453cdd10c7a28", + "name": "netcdf4", + "sha256": "e44e71a48a7766b2761793f7af9a5d26a54ac08b96b44fa0638f4a11194ddab1", + "size": 470653, + "subdir": "linux-64", + "timestamp": 1624383388525, + "version": "1.5.7" + }, + "netcdf4-1.5.7-py38ha0f2276_1.conda": { + "build": "py38ha0f2276_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.8,<4.9.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2cd4e287946d8c313318c5d88741417c", + "name": "netcdf4", + "sha256": "05a67d7ee271b2865581d169e3cf1f77e6ec98c03352510e521ac01429443490", + "size": 470493, + "subdir": "linux-64", + "timestamp": 1643311809468, + "version": "1.5.7" + }, + "netcdf4-1.5.7-py39h0a24e14_0.conda": { + "build": "py39h0a24e14_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "OSI Approved and MIT", + "md5": "eee3e3dc716ee72c4215ea7663226ab5", + "name": "netcdf4", + "sha256": "925fd88643c4c28bb80727134b656885e72472a08b760c21f7cd5fa636c92c91", + "size": 471985, + "subdir": "linux-64", + "timestamp": 1624383408294, + "version": "1.5.7" + }, + "netcdf4-1.5.7-py39ha0f2276_1.conda": { + "build": "py39ha0f2276_1", + "build_number": 1, + "depends": [ + "cftime", + "hdf5", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.8,<4.9.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0df0cd28cb51f69c7a9877cc8451cdcc", + "name": "netcdf4", + "sha256": "e0cbe26397678eb68ddcfeb2ed9a74e2d7706935cc30139c49704a5b8fdb61f6", + "size": 470683, + "subdir": "linux-64", + "timestamp": 1643311746646, + "version": "1.5.7" + }, + "netcdf4-1.5.7-py39he70f4c8_0.conda": { + "build": "py39he70f4c8_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "numpy >=1.20.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da1cc6cbe5a2acebe93dfcec470a06a1", + "name": "netcdf4", + "sha256": "10b7a168054db281b294623b2ddf6d736af0ad925d56c639965c932ef48b0d06", + "size": 470853, + "subdir": "linux-64", + "timestamp": 1624439489640, + "version": "1.5.7" + }, + "netcdf4-1.6.2-py310h6d89c78_0.conda": { + "build": "py310h6d89c78_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5", + "libgcc-ng >=11.2.0", + "libnetcdf >=4.8,<4.9.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ff4333ffc0cc7d560edb9a9bc313d1b", + "name": "netcdf4", + "sha256": "ba14bf5054c2510294d5bea3714fbde1fc0fe27c6783d41a3de8654538ff8b8a", + "size": 505519, + "subdir": "linux-64", + "timestamp": 1673455610537, + "version": "1.6.2" + }, + "netcdf4-1.6.2-py311h0e679e6_0.conda": { + "build": "py311h0e679e6_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5", + "libgcc-ng >=11.2.0", + "libnetcdf >=4.8,<4.9.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6447eaaf3980e70325731f1d3042b44", + "name": "netcdf4", + "sha256": "e2b09a96015d5049487b31b6eda7f7dbafdd040c1371f2c1f412ba2445a00ed6", + "size": 463914, + "subdir": "linux-64", + "timestamp": 1676841290599, + "version": "1.6.2" + }, + "netcdf4-1.6.2-py37h89d13dc_0.conda": { + "build": "py37h89d13dc_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5", + "libgcc-ng >=11.2.0", + "libnetcdf >=4.8,<4.9.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2cbb998bbd85447ce324961f7b4939d", + "name": "netcdf4", + "sha256": "ebd878d5e4bf2b726d3bbc9d753f5849b8374375a8cb159720e9b99f5bf65784", + "size": 491321, + "subdir": "linux-64", + "timestamp": 1673455796585, + "version": "1.6.2" + }, + "netcdf4-1.6.2-py38h89d13dc_0.conda": { + "build": "py38h89d13dc_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5", + "libgcc-ng >=11.2.0", + "libnetcdf >=4.8,<4.9.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a560b66624a12007eac13356adcb631c", + "name": "netcdf4", + "sha256": "2e0b2e4dc2f744537c166158ffa06a64684acb0c8892b45fc821820317897f0d", + "size": 543236, + "subdir": "linux-64", + "timestamp": 1673455535018, + "version": "1.6.2" + }, + "netcdf4-1.6.2-py39h89d13dc_0.conda": { + "build": "py39h89d13dc_0", + "build_number": 0, + "depends": [ + "cftime", + "hdf5", + "libgcc-ng >=11.2.0", + "libnetcdf >=4.8,<4.9.0a0", + "libnetcdf >=4.8.1,<5.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "50a84d13150f0c7ff1d33546b66938e2", + "name": "netcdf4", + "sha256": "36ff40ee4d3443a31e815a2ba4cd0fc0aca08a512de09724d8ba121cb62ae3e8", + "size": 516814, + "subdir": "linux-64", + "timestamp": 1673455696733, + "version": "1.6.2" + }, + "netifaces-0.10.9-py310h7f8727e_1004.conda": { + "build": "py310h7f8727e_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a199176c1af7b8cd902542ec6b4d5924", + "name": "netifaces", + "sha256": "b1993e6c57b34c141fe690765e8ee59c60b2bd67ebc33d263eaad56d85f97d78", + "size": 38896, + "subdir": "linux-64", + "timestamp": 1641838109030, + "version": "0.10.9" + }, + "netifaces-0.10.9-py311h5eee18b_1004.conda": { + "build": "py311h5eee18b_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c69a7323d0294d9b75fdc2edbb221cc1", + "name": "netifaces", + "sha256": "ada3c4ef696e81a6f24fe3e7dfd05ebb1fa49b7a2d0015f26f90e7bb645c0e85", + "size": 17431, + "subdir": "linux-64", + "timestamp": 1676859954905, + "version": "0.10.9" + }, + "netifaces-0.10.9-py36h27cfd23_1004.conda": { + "build": "py36h27cfd23_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e0d92667d56b76fb01a03ddb2343415", + "name": "netifaces", + "sha256": "f969d07e83afeead6daa91484e7f3bd40a35cc6fdef48188c1de882bd0f477cf", + "size": 21688, + "subdir": "linux-64", + "timestamp": 1622235270777, + "version": "0.10.9" + }, + "netifaces-0.10.9-py37h27cfd23_1004.conda": { + "build": "py37h27cfd23_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ddc97fee645cd364a99fc05e1ed8ea9b", + "name": "netifaces", + "sha256": "409e9c70703588e579e205a1a2a8d637ae015bb3c5cbcd3d4e9c3426361549b9", + "size": 21687, + "subdir": "linux-64", + "timestamp": 1622230224571, + "version": "0.10.9" + }, + "netifaces-0.10.9-py38h27cfd23_1004.conda": { + "build": "py38h27cfd23_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8370031057d2183b8ce37445a404135", + "name": "netifaces", + "sha256": "dec63f8abea97aa46824a9961ca8943ba1d951b7f482b9f46adb2eaab3c1860f", + "size": 21892, + "subdir": "linux-64", + "timestamp": 1622235272564, + "version": "0.10.9" + }, + "netifaces-0.10.9-py39h27cfd23_1004.conda": { + "build": "py39h27cfd23_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "420cd43e64281f4b7401d4fe8c921ac9", + "name": "netifaces", + "sha256": "bb4fd63b17ea87e40fcaf6979b5c681aa27faf0c9ad5baff1e2c43f9e470a765", + "size": 21939, + "subdir": "linux-64", + "timestamp": 1622234877856, + "version": "0.10.9" + }, + "nettle-3.4-hb69a4c5_1.conda": { + "build": "hb69a4c5_1", + "build_number": 1, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2 and LGPL3", + "license_family": "GPL", + "md5": "2fd390ba5f2c92a649941b22b8fce502", + "name": "nettle", + "sha256": "8f003694e968adf8f31e78a2ad120e986813f3665818f317ab19d01b6ffe7a75", + "size": 5059414, + "subdir": "linux-64", + "timestamp": 1576614385172, + "version": "3.4" + }, + "nettle-3.4.1-hbb512f6_0.conda": { + "build": "hbb512f6_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2 and LGPL3", + "license_family": "GPL", + "md5": "bb9590a8e6b61528406e909dd696256b", + "name": "nettle", + "sha256": "292462889c0fa59e9e89fa09fdba1b6dc96c3b5679fc81a7862054220634f2c7", + "size": 5287186, + "subdir": "linux-64", + "timestamp": 1587121305131, + "version": "3.4.1" + }, + "nettle-3.7.2-hbbd107a_0.conda": { + "build": "hbbd107a_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2 and LGPL3", + "license_family": "GPL", + "md5": "29c406e9413a9f331fc285290ba69af5", + "name": "nettle", + "sha256": "80c8f5196b902ef2579e3945e2a04abeebfcfc672e087064755d40ebeee7f804", + "size": 803620, + "subdir": "linux-64", + "timestamp": 1617771123412, + "version": "3.7.2" + }, + "nettle-3.7.2-hbbd107a_1.conda": { + "build": "hbbd107a_1", + "build_number": 1, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2 and LGPL3", + "license_family": "GPL", + "md5": "8bd7f1fb338c15b5dc0d9efc28c44d57", + "name": "nettle", + "sha256": "c60cf8a9c93ee9a24c3486fa375f491386d324da9d6e65c9ec49893886f1665d", + "size": 830299, + "subdir": "linux-64", + "timestamp": 1617808171380, + "version": "3.7.2" + }, + "nettle-3.7.3-hbbd107a_1.conda": { + "build": "hbbd107a_1", + "build_number": 1, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0" + ], + "license": "GPL-2.0-or-later AND LGPL-3.0-or-later", + "license_family": "GPL", + "md5": "9357ec2203a163a92a0337eb5e8e3356", + "name": "nettle", + "sha256": "8b41d588238bac265c740eafa2170b5df2fd31c2db3d7081301d98b0ba814a2d", + "size": 828846, + "subdir": "linux-64", + "timestamp": 1623151158563, + "version": "3.7.3" + }, + "networkx-1.11-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "decorator >=4.1.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "68524405edd79925d272bcb7e50677ba", + "name": "networkx", + "sha256": "aab0ac4325cbc47b6d82658583bdc306e172d3e877743e654c5e1a2c6451cfce", + "size": 1288001, + "subdir": "linux-64", + "timestamp": 1530771997213, + "version": "1.11" + }, + "networkx-1.11-py27h7358325_0.conda": { + "build": "py27h7358325_0", + "build_number": 0, + "depends": [ + "decorator >=3.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a3e4f05fde46f51745b785326ed90088", + "name": "networkx", + "sha256": "38b314d7d8b32b2dc146237a15e78d1f467085745272c8ad8cf058c412814b0b", + "size": 1287716, + "subdir": "linux-64", + "timestamp": 1505740012286, + "version": "1.11" + }, + "networkx-1.11-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "decorator >=4.1.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6e57b1eaa6dca59a728dd8c25c1819df", + "name": "networkx", + "sha256": "e8796291dc5ca304c9502b36d2b9314e6261e347b03bb9d9a8368aaaa834b8a0", + "size": 1309873, + "subdir": "linux-64", + "timestamp": 1534804476350, + "version": "1.11" + }, + "networkx-1.11-py35hf333c83_0.conda": { + "build": "py35hf333c83_0", + "build_number": 0, + "depends": [ + "decorator >=3.4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "424b56c57ab428c244bf88eed0c5b7c5", + "name": "networkx", + "sha256": "4332fff65c58bbad5bdc1e016ce5fb93c6129bb777cdd70df30ad2b60322b587", + "size": 1321421, + "subdir": "linux-64", + "timestamp": 1505740052169, + "version": "1.11" + }, + "networkx-1.11-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "decorator >=4.1.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "393bf1073b23214a75543f6e702a3ca7", + "name": "networkx", + "sha256": "6dcfa08da3c54eeedeba0b72d640c814792487af7363c4cc043704f73ec65251", + "size": 1313217, + "subdir": "linux-64", + "timestamp": 1530772049057, + "version": "1.11" + }, + "networkx-1.11-py36hfb3574a_0.conda": { + "build": "py36hfb3574a_0", + "build_number": 0, + "depends": [ + "decorator >=3.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "54f9dd41406ff70de38e9c6d0e762a13", + "name": "networkx", + "sha256": "ca0203c6624917afa1f410035b6a013769caab07d66315c889ffbb4120e77d3a", + "size": 1301768, + "subdir": "linux-64", + "timestamp": 1505740092966, + "version": "1.11" + }, + "networkx-1.11-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "decorator >=4.1.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "171039713576d98887b41148be6e86ce", + "name": "networkx", + "sha256": "cda4660a5f08da4ca1e1b4ed0a8205fa6e7eea468994d3b8706ae4b904b35f12", + "size": 1311132, + "subdir": "linux-64", + "timestamp": 1530771955799, + "version": "1.11" + }, + "networkx-2.0-py27hfc23926_0.conda": { + "build": "py27hfc23926_0", + "build_number": 0, + "depends": [ + "decorator >=3.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3c29b306339842ddb678e24332651431", + "name": "networkx", + "sha256": "d0aa13b0dee148864478e82f0b80e1259689621c8b827be43be700404b05d8c0", + "size": 1534651, + "subdir": "linux-64", + "timestamp": 1508437240672, + "version": "2.0" + }, + "networkx-2.0-py35hc690e10_0.conda": { + "build": "py35hc690e10_0", + "build_number": 0, + "depends": [ + "decorator >=3.4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "48d675d09c21a89dd26fca4b96c60eac", + "name": "networkx", + "sha256": "d07c984e145cdd52e8e0d630d66f5b3e064698ad15637b5fc2da7334a2335a22", + "size": 1548897, + "subdir": "linux-64", + "timestamp": 1508437258628, + "version": "2.0" + }, + "networkx-2.0-py36h7e96fb8_0.conda": { + "build": "py36h7e96fb8_0", + "build_number": 0, + "depends": [ + "decorator >=3.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "371140ba8fc6040b6c7f8b25359409db", + "name": "networkx", + "sha256": "f84ca5706d832a66af87e9afb942e3dc8d0cd11a41f9c5144d2fc1ee379efc78", + "size": 1553506, + "subdir": "linux-64", + "timestamp": 1508437237782, + "version": "2.0" + }, + "networkx-2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator >=4.1.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bf67c63079a740c7f8063f22757f9f9a", + "name": "networkx", + "sha256": "c3c2dcf5d5405d4ff9222af1aac8f619d05c7182c663cd344d0cf33ea949920c", + "size": 1587419, + "subdir": "linux-64", + "timestamp": 1516746441239, + "version": "2.1" + }, + "networkx-2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator >=4.1.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "805eb42cc0d345134775b17ec5fe4a57", + "name": "networkx", + "sha256": "da20d23677dc7b66f768bb6fee96517f786242c9fa058d5a70136a1b4ea2ade1", + "size": 1617998, + "subdir": "linux-64", + "timestamp": 1516746468741, + "version": "2.1" + }, + "networkx-2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator >=4.1.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4f10245434611c396831c5b99797717d", + "name": "networkx", + "sha256": "1adca69f722a086b07ea4dd5615db0afaf41038fa1618805fae8ad68e6b5a7d2", + "size": 1624222, + "subdir": "linux-64", + "timestamp": 1516746467678, + "version": "2.1" + }, + "networkx-2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator >=4.1.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c43459346c233f371f68dc4e60630871", + "name": "networkx", + "sha256": "c1076235db4db411ddc8917d6f53e0c87f01884cec5ec6c582820542e436fbdd", + "size": 1622105, + "subdir": "linux-64", + "timestamp": 1530772103223, + "version": "2.1" + }, + "networkx-2.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "decorator >=4.3.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "30fb4698a7072f3fbe3c9c965a4cae5e", + "name": "networkx", + "sha256": "acc4c4c3d2259d3c671b45ae5a4c62136706416141de17e29d49d649a363f9ba", + "size": 1683039, + "subdir": "linux-64", + "timestamp": 1538599993771, + "version": "2.2" + }, + "networkx-2.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "decorator >=4.3.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9d3cd411c807ccd36d9ca9c06d642784", + "name": "networkx", + "sha256": "2e55eb5716b22442490a173b777349a8cc5ea11e85681de916a65195725ba0e8", + "size": 1706191, + "subdir": "linux-64", + "timestamp": 1538600029845, + "version": "2.2" + }, + "networkx-2.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "decorator >=4.3.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9b987ac25263bc85b706955a0906007e", + "name": "networkx", + "sha256": "05f23557fcc6382d88ebcba11554be6e5cd327e18cff463154a3c56289096cfe", + "size": 1703384, + "subdir": "linux-64", + "timestamp": 1538600017904, + "version": "2.2" + }, + "networkx-2.8.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bf089cc26078277c23d6336a704b220d", + "name": "networkx", + "sha256": "3c513c3fb4417b82b50bcda395c1607a098d920f61cc5791814f12ae74a787e3", + "size": 2286910, + "subdir": "linux-64", + "timestamp": 1657784186893, + "version": "2.8.4" + }, + "networkx-2.8.4-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4df7e9984d6a4d32ef02e78bed6bca81", + "name": "networkx", + "sha256": "e32687f054df3f2b056a691faa9ada525c5560647d66d42ca89f59742be72406", + "size": 2784268, + "subdir": "linux-64", + "timestamp": 1678964406250, + "version": "2.8.4" + }, + "networkx-2.8.4-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "93e51f7c932273076278102547094625", + "name": "networkx", + "sha256": "8d91f456fe12dd7c9481a23ac5a39fc0424859f5bf5e803980b8c7dcf1bed653", + "size": 3339140, + "subdir": "linux-64", + "timestamp": 1678964443436, + "version": "2.8.4" + }, + "networkx-2.8.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ce32443eb2665ec87b95184c6763f8da", + "name": "networkx", + "sha256": "58f802116687c0aa2518dc50d6223c676504041db04a09a2b5ff3b6c15b23f3a", + "size": 2281452, + "subdir": "linux-64", + "timestamp": 1657784134360, + "version": "2.8.4" + }, + "networkx-2.8.4-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "366a94800771ace203b41109ece199cc", + "name": "networkx", + "sha256": "4060ba3dab77c99cd9c4aa278a1cea290c1e2cea9d88877e5bf1352eb77fc1aa", + "size": 2775720, + "subdir": "linux-64", + "timestamp": 1678964480653, + "version": "2.8.4" + }, + "networkx-2.8.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "072f57f7baf66c330c0c8a896983f90e", + "name": "networkx", + "sha256": "3d1e1bc0ff51298d60ed8b53eaa144997efcbb49fcec34f2c1e2ca68fe20b6fe", + "size": 2273627, + "subdir": "linux-64", + "timestamp": 1657784226631, + "version": "2.8.4" + }, + "networkx-2.8.4-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "33078cdd2badc6670fdec80d2a0121ec", + "name": "networkx", + "sha256": "d3d37a03de15b033e4f78649fa851bcbd4f3ab917ae955a23cb3f35a9a44dd92", + "size": 2765297, + "subdir": "linux-64", + "timestamp": 1678964368614, + "version": "2.8.4" + }, + "neuralprophet-0.3.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.11.3.1", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.4.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a05962009028dfc6c8341472e39a5c87", + "name": "neuralprophet", + "sha256": "0a9b7825fd096686d5421fcb274d92170c90f0cbdbb6d04fa5ea8400f88f05c5", + "size": 204762, + "subdir": "linux-64", + "timestamp": 1649651928650, + "version": "0.3.2" + }, + "neuralprophet-0.3.2-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.11.3.1", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.4.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "451f6f9a9d66d77ea96ec55f33104b49", + "name": "neuralprophet", + "sha256": "5f4aff109d8fb2d12a8cb376580a0ba52ab5500ca85e874dbdb3420958600006", + "size": 205097, + "subdir": "linux-64", + "timestamp": 1662379745515, + "version": "0.3.2" + }, + "neuralprophet-0.3.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.11.3.1", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.4.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63db49694b9e78007451ee6b83090ce6", + "name": "neuralprophet", + "sha256": "d2f4a6d881f99fb8a50f42e55524f816631345bd77617040025fbfa9f0fb21d7", + "size": 203024, + "subdir": "linux-64", + "timestamp": 1649670049167, + "version": "0.3.2" + }, + "neuralprophet-0.3.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.11.3.1", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.4.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f51150f78eb2711654dd519e1ed81d70", + "name": "neuralprophet", + "sha256": "1b4c6e6bff0d1a85ebab8bc1c18a9cc2c328480ea046b7e5bd091202a09feebe", + "size": 204234, + "subdir": "linux-64", + "timestamp": 1662379544534, + "version": "0.3.2" + }, + "neuralprophet-0.3.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.11.3.1", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.4.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c3f1f8b915b53af02a7095c1d764f4b", + "name": "neuralprophet", + "sha256": "64c81527633cd83960fdbc0071c15fb35a3121f1cc2d71d00558d2bf8346eb40", + "size": 204787, + "subdir": "linux-64", + "timestamp": 1649670045219, + "version": "0.3.2" + }, + "neuralprophet-0.3.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.11.3.1", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.4.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "86d77009c4bce330a9562287fd65a7a9", + "name": "neuralprophet", + "sha256": "a8cb65b1106a3fab7f769af89bdb7a92c1f50a017da0dd3014ed1afc89a12aa9", + "size": 204286, + "subdir": "linux-64", + "timestamp": 1662379802290, + "version": "0.3.2" + }, + "neuralprophet-0.3.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.11.3.1", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.4.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c8cfcfe36e0e16cc60f9ab95e8395b8", + "name": "neuralprophet", + "sha256": "9076ff1354012875cd737f29ec4906e3934df3f33fff84a8552869d26cf8eccd", + "size": 204105, + "subdir": "linux-64", + "timestamp": 1649652182557, + "version": "0.3.2" + }, + "neuralprophet-0.3.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.11.3.1", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.4.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "369522dd33a542dfe35adbc77a6b11c9", + "name": "neuralprophet", + "sha256": "fd4cba920c06ef5c80a1fe92d5219983b4386277a834b82721ecc6da40fa373d", + "size": 204472, + "subdir": "linux-64", + "timestamp": 1662379612883, + "version": "0.3.2" + }, + "neuralprophet-0.4.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.13", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "plotly >=4.14.3", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.8.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ae50902add28ac2d7558d51729f7adc1", + "name": "neuralprophet", + "sha256": "8026cd4067c2548787b1499ffe8e17d8886b25449dd887e70d92244e642dd21b", + "size": 320528, + "subdir": "linux-64", + "timestamp": 1675378039681, + "version": "0.4.2" + }, + "neuralprophet-0.4.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.13", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "plotly >=4.14.3", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.8.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2", + "typing_extensions >=4.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2fbe6cbf4be33fff5b57cc920fc6e6c2", + "name": "neuralprophet", + "sha256": "17b9e0a9f9e9356b76a9a7ad8b17bb2a3755fd6daf3acb9b4fcb28fe73bde4ba", + "size": 319410, + "subdir": "linux-64", + "timestamp": 1675378148234, + "version": "0.4.2" + }, + "neuralprophet-0.4.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.13", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "plotly >=4.14.3", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.8.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4b6e2b83f67423c5ff01f39da3c26ab3", + "name": "neuralprophet", + "sha256": "6c3010c0e3aaf1c20fc828c94b0d7e0e21d0e8028505d0ddac48fe3ce2dbb038", + "size": 319721, + "subdir": "linux-64", + "timestamp": 1675378255639, + "version": "0.4.2" + }, + "neuralprophet-0.4.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "holidays >=0.13", + "ipywidgets >=7.5.1", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.15.4", + "pandas >=1.0.4", + "plotly >=4.14.3", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.0", + "pytorch >=1.8.0", + "torch-lr-finder >=0.2.1", + "tqdm >=4.50.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "491df26f8300e4334fb64adc306c1fe6", + "name": "neuralprophet", + "sha256": "f2b65bd7540e210e65debc1df53a859aca3e85f31a9ea444a3cc15298e0a35ac", + "size": 319443, + "subdir": "linux-64", + "timestamp": 1675378360179, + "version": "0.4.2" + }, + "nginx-1.14.2-hf7769d2_0.conda": { + "build": "hf7769d2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgd >=2.2.5,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "openssl >=1.1.1a,<1.1.2a", + "pcre >=8.42,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "726a958f3b36dcf34980a8c629da3646", + "name": "nginx", + "sha256": "504cb889bb0fc088dd781a15d53588185510effba183114c5378a3064ac7c1c9", + "size": 501740, + "subdir": "linux-64", + "timestamp": 1547240426764, + "version": "1.14.2" + }, + "nginx-1.15.1-h2b10cb8_0.conda": { + "build": "h2b10cb8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgd >=2.2.5,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "openssl >=1.0.2p,<1.0.3a", + "pcre >=8.42,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "6dd7134549959d94d4a81ad312e00ce8", + "name": "nginx", + "sha256": "2921239241f256ccb1e5461022a9c38465b45490d9e261275beace985f912fb9", + "size": 495608, + "subdir": "linux-64", + "timestamp": 1534495115960, + "version": "1.15.1" + }, + "nginx-1.15.1-hf7769d2_0.conda": { + "build": "hf7769d2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgd >=2.2.5,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "openssl >=1.1.1a,<1.1.2a", + "pcre >=8.42,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "60cb12668b517bc3629f0aae99323c5d", + "name": "nginx", + "sha256": "52e06bb25e69e7be91725a5df49175720f3ad8dc5df31a5c0655906b1b4ebde6", + "size": 504849, + "subdir": "linux-64", + "timestamp": 1540584291263, + "version": "1.15.1" + }, + "nginx-1.15.5-hf7769d2_0.conda": { + "build": "hf7769d2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgd >=2.2.5,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "libxslt >=1.1.32,<2.0a0", + "openssl >=1.1.1a,<1.1.2a", + "pcre >=8.42,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9cc2c4eed17c2d7aacf16b369cdb60ba", + "name": "nginx", + "sha256": "24fa16e08ae2c737d33b358297533e626c75fea3d9c3d019408ff59965a60e02", + "size": 507435, + "subdir": "linux-64", + "timestamp": 1540591370849, + "version": "1.15.5" + }, + "nginx-1.19.10-h674efe4_0.conda": { + "build": "h674efe4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgd >=2.2.5,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "openssl >=1.1.1k,<1.1.2a", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "7396cae13ad23a143cefb6909804cf06", + "name": "nginx", + "sha256": "2242f078e56f8b398b372a7f88fe153e82246e660677957908912f2baa08b6dc", + "size": 522756, + "subdir": "linux-64", + "timestamp": 1618347667615, + "version": "1.19.10" + }, + "nginx-1.19.2-hf7769d2_0.conda": { + "build": "hf7769d2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgd >=2.2.5,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "openssl >=1.1.1g,<1.1.2a", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "cdb098419cfce17f55aa2352e3496860", + "name": "nginx", + "sha256": "5a8c147c0520367e14c2b871fb249d90049b16ef4e460943bbef1ea6b39a7b2c", + "size": 517956, + "subdir": "linux-64", + "timestamp": 1600445866811, + "version": "1.19.2" + }, + "nginx-1.19.8-h674efe4_0.conda": { + "build": "h674efe4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgd >=2.2.5,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "openssl >=1.1.1j,<1.1.2a", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "963003cb85a44eb5f69ecff7336c52a1", + "name": "nginx", + "sha256": "84595415052298a858eaff3bdf400ef92bbd40accb9b2fc623a156bf5f75f1d3", + "size": 522680, + "subdir": "linux-64", + "timestamp": 1615353459212, + "version": "1.19.8" + }, + "nginx-1.19.9-h674efe4_0.conda": { + "build": "h674efe4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgd >=2.2.5,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxslt >=1.1.34,<2.0a0", + "openssl >=1.1.1k,<1.1.2a", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "fe8f952a722f15b72791d457354ab822", + "name": "nginx", + "sha256": "2898b39c04aa570b48e3ba35eeee7f69f6c89439afff2a3dbdb6155d693cbaed", + "size": 523468, + "subdir": "linux-64", + "timestamp": 1617132697268, + "version": "1.19.9" + }, + "nginx-1.21.6-h67d3620_1.conda": { + "build": "h67d3620_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libgd 2.3.3.*", + "libgd >=2.3.3,<2.4.0a0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxml2", + "libxslt 1.1.*", + "libxslt >=1.1.35,<2.0a0", + "openssl >=1.1.1o,<1.1.2a", + "pcre2 >=10.37,<10.38.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "2f51881304bf419130cd9b18d8b784ab", + "name": "nginx", + "sha256": "9d08872aa7d4f2fe85dc239b667f407b8fa3906c682664369893d0599daf8529", + "size": 510568, + "subdir": "linux-64", + "timestamp": 1656436056231, + "version": "1.21.6" + }, + "nginx-1.21.6-hd80bfc7_0.conda": { + "build": "hd80bfc7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libgd 2.2.*", + "libgd >=2.2.5,<2.3.0a0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libxml2", + "libxslt 1.1.*", + "libxslt >=1.1.34,<2.0a0", + "openssl >=1.1.1m,<1.1.2a", + "pcre2 >=10.37,<10.38.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "3ccfff6b1f51112815ffe5425ecdbbc7", + "name": "nginx", + "sha256": "e6a0f13119b7074ddcea60c20fc466cf5364ef1d08b8a547c34fd4adf4669bae", + "size": 524700, + "subdir": "linux-64", + "timestamp": 1646390801760, + "version": "1.21.6" + }, + "ninja-1.10.0-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4afaa553407315e3e1d7bb3dc8456898", + "name": "ninja", + "namespace": "global", + "sha256": "b7de381d248f764cf2e00ed60cc0b10743504c1466d923025f2c03280b6ece91", + "size": 1506562, + "subdir": "linux-64", + "timestamp": 1596052731355, + "version": "1.10.0" + }, + "ninja-1.10.0-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0883b69836d5bc88bef552794c30c86f", + "name": "ninja", + "namespace": "global", + "sha256": "ceb4f66b0f1b22e041a6398af867416fb11e48124d90bd37f43375af1dd922bc", + "size": 1506573, + "subdir": "linux-64", + "timestamp": 1596052751078, + "version": "1.10.0" + }, + "ninja-1.10.0-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3944e82b0f865c9ae4997125508008c5", + "name": "ninja", + "namespace": "global", + "sha256": "43906885d1deea8f9cb24dc94c0d39eb1126870217e6a5b0878650d7fbeec43c", + "size": 1506563, + "subdir": "linux-64", + "timestamp": 1596052771755, + "version": "1.10.0" + }, + "ninja-1.10.1-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3266dbe9c604daf636bbc936395bbd6d", + "name": "ninja", + "namespace": "global", + "sha256": "224649304b2576c59776433f3a55f9ad8e6997ed03a91ab7a5ebd4a8b0c044ba", + "size": 1509600, + "subdir": "linux-64", + "timestamp": 1599132690968, + "version": "1.10.1" + }, + "ninja-1.10.1-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "84f16351bc7fb0559995a66582d66d37", + "name": "ninja", + "namespace": "global", + "sha256": "8574954f1392eccda67eec5afa44fa2b7f3c4cb40a3342a787698e1fb750d83d", + "size": 1510286, + "subdir": "linux-64", + "timestamp": 1599132561156, + "version": "1.10.1" + }, + "ninja-1.10.1-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6ff0425c6f4d04286ec7eb901345699c", + "name": "ninja", + "namespace": "global", + "sha256": "e4ff300b114fc716168126ad2a9c605dacaad0697e4d725540ab400b100a39be", + "size": 1510268, + "subdir": "linux-64", + "timestamp": 1599132649978, + "version": "1.10.1" + }, + "ninja-1.10.2-h06a4308_5.conda": { + "build": "h06a4308_5", + "build_number": 5, + "depends": [ + "ninja-base 1.10.2 hd09550d_5", + "python" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6fc219bbc4c8dbb9060b5b7fe31ae83d", + "name": "ninja", + "namespace": "global", + "sha256": "e1b20ab99288abb48493a75af7ddd8e5360c78167150b09eb6bf923f22e2e2d1", + "size": 7831, + "subdir": "linux-64", + "timestamp": 1651243066654, + "version": "1.10.2" + }, + "ninja-1.10.2-h5e70eb0_2.conda": { + "build": "h5e70eb0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ca0f69c67e608bd44a5c45c5a3036950", + "name": "ninja", + "namespace": "global", + "sha256": "7e8f846a61246054b17c390b084ca5a125a0bd2b7e15a2a37ba71c6c8cd48340", + "size": 1529439, + "subdir": "linux-64", + "timestamp": 1636631453946, + "version": "1.10.2" + }, + "ninja-1.10.2-hd09550d_2.conda": { + "build": "hd09550d_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c44f3de6e9ca3bf4ec00be7132eb55f8", + "name": "ninja", + "namespace": "global", + "sha256": "b85d949417dd9de39ba942dd063904c860206dd1bb4cc557d69a09f1b246fb38", + "size": 1522502, + "subdir": "linux-64", + "timestamp": 1636631285248, + "version": "1.10.2" + }, + "ninja-1.10.2-hff7bd54_1.conda": { + "build": "hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "32e009f34b1218b74ca31cad447bc77c", + "name": "ninja", + "namespace": "global", + "sha256": "63ac782ccfb83def71653060e4c35a520e9fe6fbdd41b9d27f7752a61291b703", + "size": 1512570, + "subdir": "linux-64", + "timestamp": 1617652633259, + "version": "1.10.2" + }, + "ninja-1.10.2-py310hd09550d_3.conda": { + "build": "py310hd09550d_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e1fb6eba106194902151eb45e676e136", + "name": "ninja", + "namespace": "global", + "sha256": "c3ede49abf9d01fe8d0a3bd7d1f7426d3f5a7f4f82f92005b37328a3d8bd2a02", + "size": 1522780, + "subdir": "linux-64", + "timestamp": 1640791961629, + "version": "1.10.2" + }, + "ninja-1.10.2-py36hff7bd54_0.conda": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "abb35987a6f621a3c03bab715e2c5fa8", + "name": "ninja", + "namespace": "global", + "sha256": "6336b7f8c9cf9e76474d224888c00be974f7fb581276b255c024834836a6345b", + "size": 1507147, + "subdir": "linux-64", + "timestamp": 1606603258848, + "version": "1.10.2" + }, + "ninja-1.10.2-py37h5e70eb0_3.conda": { + "build": "py37h5e70eb0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0954452aaeb6dffdde93871f60f67b52", + "name": "ninja", + "namespace": "global", + "sha256": "7a79ddc562177f436dafde569054ba40a07733d7450362746d3c74b1d7dcf94c", + "size": 1529438, + "subdir": "linux-64", + "timestamp": 1636622443378, + "version": "1.10.2" + }, + "ninja-1.10.2-py37hd09550d_3.conda": { + "build": "py37hd09550d_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aa7c2506576e6a13c1f63255bea1e728", + "name": "ninja", + "namespace": "global", + "sha256": "53d8f959750b7a6a7f93fd2cc70667a8081ec551cfa11407349c24243b2b53d4", + "size": 1523700, + "subdir": "linux-64", + "timestamp": 1636643923057, + "version": "1.10.2" + }, + "ninja-1.10.2-py37hff7bd54_0.conda": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3edeeedd0c97ba1d90f35abb329b895d", + "name": "ninja", + "namespace": "global", + "sha256": "8ef975855045ef481029f67a275a13acb55c2c0981b9d6f6305b5abc8146d2f3", + "size": 1507792, + "subdir": "linux-64", + "timestamp": 1606603235006, + "version": "1.10.2" + }, + "ninja-1.10.2-py38h5e70eb0_3.conda": { + "build": "py38h5e70eb0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9cda02df0b98995bc4a33f480f189aa5", + "name": "ninja", + "namespace": "global", + "sha256": "311f6bded09f82fb20385de5861ea51cbcdf8a8fd9242690411bd4054d98b1a7", + "size": 1527306, + "subdir": "linux-64", + "timestamp": 1636634758229, + "version": "1.10.2" + }, + "ninja-1.10.2-py38hd09550d_3.conda": { + "build": "py38hd09550d_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "43a6a9539505cf9b085a9fb017860ed9", + "name": "ninja", + "namespace": "global", + "sha256": "8fc563b3c31ea110054f54a1e98457ec5fa1c5bd7efa3bbd03f9e3447486a219", + "size": 1523694, + "subdir": "linux-64", + "timestamp": 1636643866113, + "version": "1.10.2" + }, + "ninja-1.10.2-py38hff7bd54_0.conda": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f1e64f0f900188d088edd3d869353180", + "name": "ninja", + "namespace": "global", + "sha256": "e3b5ad355f38df69ddfbcaa030833949d8ba9f3851ff18b2e48c6e7b24c00600", + "size": 1507120, + "subdir": "linux-64", + "timestamp": 1606603234210, + "version": "1.10.2" + }, + "ninja-1.10.2-py39h5e70eb0_3.conda": { + "build": "py39h5e70eb0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0a2341968cbc03a265832277e0136add", + "name": "ninja", + "namespace": "global", + "sha256": "08d0a5bc12b71cc9e7f49f5c825025f5040c6889ba1a6ba99fd9f62ba8b586e5", + "size": 1527338, + "subdir": "linux-64", + "timestamp": 1636634764770, + "version": "1.10.2" + }, + "ninja-1.10.2-py39hd09550d_3.conda": { + "build": "py39hd09550d_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2a6c5712dfdc5d2d9cbc87d498962167", + "name": "ninja", + "namespace": "global", + "sha256": "8245293d68980d1ae5a3d0e79155906c9b4297a069e364d9a227a72a4d84e5af", + "size": 1523712, + "subdir": "linux-64", + "timestamp": 1636643814099, + "version": "1.10.2" + }, + "ninja-1.10.2-py39hff7bd54_0.conda": { + "build": "py39hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "12859cbc59077e82313ac51dcfae42c5", + "name": "ninja", + "namespace": "global", + "sha256": "1725427563cc27c37f647bdcd2ab898196c8b2762c8f741d67ed584afa3a850a", + "size": 1507156, + "subdir": "linux-64", + "timestamp": 1606603287719, + "version": "1.10.2" + }, + "ninja-1.8.2-h6bb024c_0.conda": { + "build": "h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "81ba0de46fc3c92a05cd0a81e19bcfb0", + "name": "ninja", + "namespace": "global", + "sha256": "79ea73d149efcfb06c27a0d9c79d473174cd114ccb2e2e3fe3d529f3a99c9004", + "size": 1071815, + "subdir": "linux-64", + "timestamp": 1519804730291, + "version": "1.8.2" + }, + "ninja-1.8.2-h6bb024c_1.conda": { + "build": "h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "38bb28b17b2fa6dcd86859a0aba54a8f", + "name": "ninja", + "namespace": "global", + "sha256": "1b34a8815ca25186a0b207d7e9a259abf6eedf5bfb6c1570dda79c9a6e80bdd0", + "size": 1071680, + "subdir": "linux-64", + "timestamp": 1522872752538, + "version": "1.8.2" + }, + "ninja-1.8.2-py27h6bb024c_1.conda": { + "build": "py27h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "35876fd6549dfafe6211ebe97da7073c", + "name": "ninja", + "namespace": "global", + "sha256": "c96bff0d64e5282018871fcf48101ebed7abb5c9a8901f5f5dbf65efe06c8cf2", + "size": 1071771, + "subdir": "linux-64", + "timestamp": 1525797627709, + "version": "1.8.2" + }, + "ninja-1.8.2-py35h6bb024c_1.conda": { + "build": "py35h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "29589b536a2a1756f2276c05f8146f21", + "name": "ninja", + "namespace": "global", + "sha256": "cd887da043700f1046ae35dac0be134ed3518dbc088c94d3f28c7d2199174b68", + "size": 1071693, + "subdir": "linux-64", + "timestamp": 1525797716102, + "version": "1.8.2" + }, + "ninja-1.8.2-py36h6bb024c_1.conda": { + "build": "py36h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "962f208fa92515b73038930932551733", + "name": "ninja", + "namespace": "global", + "sha256": "61c31ebbce8006488185dea13efd7875009fe5065422a5fa47dbc85e68fea711", + "size": 1071772, + "subdir": "linux-64", + "timestamp": 1525797734754, + "version": "1.8.2" + }, + "ninja-1.8.2-py37h6bb024c_1.conda": { + "build": "py37h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "87a7e01f9458aa0c4ba6fe82355459ba", + "name": "ninja", + "namespace": "global", + "sha256": "459727c23e84bf3bee57273c37ece7284ce2b8475849aabeb9218179c1b66f71", + "size": 1071689, + "subdir": "linux-64", + "timestamp": 1530780138788, + "version": "1.8.2" + }, + "ninja-1.9.0-py27hfd86e86_0.conda": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b1734f47a7c83214633b99bc14d77cb7", + "name": "ninja", + "namespace": "global", + "sha256": "8c5a235ca6ea646b5ce81c8ec22ceb6a9f113741c01ca80033b06e1f4aabbebe", + "size": 1288522, + "subdir": "linux-64", + "timestamp": 1553108598795, + "version": "1.9.0" + }, + "ninja-1.9.0-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e90cb61de274eac945a865f263820c20", + "name": "ninja", + "namespace": "global", + "sha256": "c76d71b043d78fdee5cf5d2aa6a1eefce176e10c1c63b267ee43f9d754b2d1d0", + "size": 1288541, + "subdir": "linux-64", + "timestamp": 1553108618986, + "version": "1.9.0" + }, + "ninja-1.9.0-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "912d132bfeb888ef03e0892bb9b586f5", + "name": "ninja", + "namespace": "global", + "sha256": "4bf915f3ac55f3251aa95438b526ca50ff16f3054059b4ba75805ef4aab8065b", + "size": 1288535, + "subdir": "linux-64", + "timestamp": 1553108582404, + "version": "1.9.0" + }, + "ninja-1.9.0-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b82ecf34d50394a9d0fb956d1991d90d", + "name": "ninja", + "namespace": "global", + "sha256": "f47d5748b2d328bd77c80aff9ab6b03dd23b7adee0e9ed2035e01a82a5c97c29", + "size": 1287333, + "subdir": "linux-64", + "timestamp": 1573120930543, + "version": "1.9.0" + }, + "ninja-base-1.10.2-hd09550d_5.conda": { + "build": "hd09550d_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "09dcbad622d58caaeefe46cd399f0a76", + "name": "ninja-base", + "sha256": "9ba078120c0415fce40c1aab5cd6fa9561ee6565227f561feeee4df9c3443108", + "size": 111309, + "subdir": "linux-64", + "timestamp": 1651243065856, + "version": "1.10.2" + }, + "nlohmann_json-3.10.5-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [], + "license": "MIT", + "license_family": "MIT", + "md5": "4844d660f6a17a26116c0b8b8381f5f7", + "name": "nlohmann_json", + "sha256": "07496d983d9c9effb8e0b109023e3cf3f48c447744d7e89d97d6d56df5c0176a", + "size": 113996, + "subdir": "linux-64", + "timestamp": 1645446448382, + "version": "3.10.5" + }, + "nlohmann_json-3.11.2-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [], + "license": "MIT", + "license_family": "MIT", + "md5": "36890f7abd98066b607211b1773e6343", + "name": "nlohmann_json", + "sha256": "fd26e0dadf88a0de5851d059eddc2079defdda748a74b32a36393dfe25a8a48a", + "size": 127326, + "subdir": "linux-64", + "timestamp": 1680082329609, + "version": "3.11.2" + }, + "nltk-3.2.4-py27h41293c3_0.conda": { + "build": "py27h41293c3_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7adedc1c9ae128ffb6301d0f82b00feb", + "name": "nltk", + "sha256": "a8387436ec145173aabc0f690af57ba8b881c89880648d3167476bb22581310d", + "size": 1690230, + "subdir": "linux-64", + "timestamp": 1505746706958, + "version": "3.2.4" + }, + "nltk-3.2.4-py35h7ba7875_0.conda": { + "build": "py35h7ba7875_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5f1ca2fed4f6f5379fe0114c02e9de1d", + "name": "nltk", + "sha256": "4cb3cc42fc7a6392641e7af28ccfd758f0fa9cfe243ebd83c2bce519f6506c33", + "size": 1722347, + "subdir": "linux-64", + "timestamp": 1505746745240, + "version": "3.2.4" + }, + "nltk-3.2.4-py36h1a0979f_0.conda": { + "build": "py36h1a0979f_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "50b87574023bc155b789164d3d76629b", + "name": "nltk", + "sha256": "65196fe11f7a71592ccd86d1614e41245d8fd91551c54f6318ee1c55cfa654b4", + "size": 1708786, + "subdir": "linux-64", + "timestamp": 1505746783334, + "version": "3.2.4" + }, + "nltk-3.2.5-py27hec5f4de_0.conda": { + "build": "py27hec5f4de_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "88e851f1b03bb6e40cd7ed81f6c65868", + "name": "nltk", + "sha256": "5f3bbc52149ebca8ddacb7e936e56f0011e3e6ba86c68607021b0490df56664d", + "size": 1719335, + "subdir": "linux-64", + "timestamp": 1511297630074, + "version": "3.2.5" + }, + "nltk-3.2.5-py35h09ad193_0.conda": { + "build": "py35h09ad193_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a57c08002dc9c8d94adac4e01cd1640a", + "name": "nltk", + "sha256": "9f41421ed0369c976bd0f18649f092d48cc674d6e9cce96b63da6a2661bec10e", + "size": 1727405, + "subdir": "linux-64", + "timestamp": 1511297648895, + "version": "3.2.5" + }, + "nltk-3.2.5-py36h7532b22_0.conda": { + "build": "py36h7532b22_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e2c942bff38a658d997b0f6e869ebef8", + "name": "nltk", + "sha256": "5d956a9da5c792e986d611fe00fa906b9eb0ef5ecd9e6a4e779ea444915be4b7", + "size": 1739223, + "subdir": "linux-64", + "timestamp": 1511297656593, + "version": "3.2.5" + }, + "nltk-3.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d204e356a43eaf376e2e9259485e6457", + "name": "nltk", + "sha256": "ee431b5e8f11096c639bcef8c55d8f4f8dcf7b9bbd2d2fb80b8b3377535aa1c3", + "size": 1718090, + "subdir": "linux-64", + "timestamp": 1525821329822, + "version": "3.3.0" + }, + "nltk-3.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a5a846ddf61a3ce2ee8df3809c4fbe47", + "name": "nltk", + "sha256": "54ff3249ee5651199afb6ab4add07cef9ed46c0cc4f41eee86abd8cc0743e139", + "size": 1726857, + "subdir": "linux-64", + "timestamp": 1525821367531, + "version": "3.3.0" + }, + "nltk-3.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bf57abd5020e285aa826b78d8429b448", + "name": "nltk", + "sha256": "12af198adcce0f8457c3dc9e053b21ff4b2c2487e181fa05e692557eb8d9fd12", + "size": 1713263, + "subdir": "linux-64", + "timestamp": 1525821341555, + "version": "3.3.0" + }, + "nltk-3.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "653734f79b7956360f19411665cc3267", + "name": "nltk", + "sha256": "221e96571f86f6a2cadf97c5fef9875ecb6f1aa1c8c721e960b4f31310ac05f7", + "size": 1732687, + "subdir": "linux-64", + "timestamp": 1530902296328, + "version": "3.3.0" + }, + "nltk-3.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gensim", + "matplotlib", + "numpy", + "pyparsing", + "python >=2.7,<2.8.0a0", + "python-crfsuite", + "requests", + "scikit-learn", + "scipy", + "six", + "twython" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "675febdc70f3393b6a30d203d1c65308", + "name": "nltk", + "sha256": "6ad320ffc1c1d60b52845e612d9fe828a4a767bc6b4033c3807f3c93ae0f944c", + "size": 1761213, + "subdir": "linux-64", + "timestamp": 1545082857509, + "version": "3.4" + }, + "nltk-3.4-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5c7f6d3a2b2c6584c911f7a3c883e6fc", + "name": "nltk", + "sha256": "1f08a23d35ab748a01ed6c0f551831b34829690df09bb754fd381bf20414e846", + "size": 1739889, + "subdir": "linux-64", + "timestamp": 1545271229483, + "version": "3.4" + }, + "nltk-3.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gensim", + "matplotlib", + "numpy", + "pyparsing", + "python >=3.6,<3.7.0a0", + "python-crfsuite", + "requests", + "scikit-learn", + "scipy", + "six", + "twython" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7f6a97dfe7039c593a71ec0bb7d5f701", + "name": "nltk", + "sha256": "6978c0ff3e1ee77b613bacd3d4cb80bc9160a0af1b02fd58474419768d243584", + "size": 1757801, + "subdir": "linux-64", + "timestamp": 1545082962795, + "version": "3.4" + }, + "nltk-3.4-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "da719913aa723a644cec64814e6c8dab", + "name": "nltk", + "sha256": "808363e16be95d0eb640b046470812ba53ef3fa510d6506c62e8429dea9e6142", + "size": 1759815, + "subdir": "linux-64", + "timestamp": 1545271244532, + "version": "3.4" + }, + "nltk-3.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "gensim", + "matplotlib", + "numpy", + "pyparsing", + "python >=3.7,<3.8.0a0", + "python-crfsuite", + "requests", + "scikit-learn", + "scipy", + "six", + "twython" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0369bfbda3ca3e3b754f93a9456e2a36", + "name": "nltk", + "sha256": "cbb185079bbb3d58a77748de95916b9a6c28b7b419354c6979c620f39a8487cb", + "size": 1752831, + "subdir": "linux-64", + "timestamp": 1545095281954, + "version": "3.4" + }, + "nltk-3.4-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dd112226472422a205331a0568219123", + "name": "nltk", + "sha256": "01c4d67ba719a65ac3afc56789422ad37323be20be48ea60af7ca98b7955bb3f", + "size": 1774520, + "subdir": "linux-64", + "timestamp": 1545271239439, + "version": "3.4" + }, + "nltk-3.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f2163feb024b5581121b837ec2475ea2", + "name": "nltk", + "sha256": "e62b108e9f7a75e3bd97a7c2c4a0025b68a789e5a86a71bd0256bec59d6330fe", + "size": 1790885, + "subdir": "linux-64", + "timestamp": 1555950458120, + "version": "3.4.1" + }, + "nltk-3.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d9b2cc049ea2a7c0df641511f2fc4d86", + "name": "nltk", + "sha256": "9f9ba3edae599cd7d8680952e68a7dc09a36139f42f0d7548c1b0e7d0349b2d0", + "size": 1811430, + "subdir": "linux-64", + "timestamp": 1555950590545, + "version": "3.4.1" + }, + "nltk-3.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "94a1adb46d48c60e7b0050cc3d3323d8", + "name": "nltk", + "sha256": "223eebcecff477aa3528a7d15e4825379e6b4e9e18221c03ee4f7500b2ed3142", + "size": 1803027, + "subdir": "linux-64", + "timestamp": 1555950558879, + "version": "3.4.1" + }, + "nltk-3.4.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "42dd4329822ff19f89f894987e8d8ca8", + "name": "nltk", + "sha256": "30f0565c721e32fa922b934aa6f131c7e99c6f905bca2ca73aac745ca111abb1", + "size": 1774024, + "subdir": "linux-64", + "timestamp": 1562086274175, + "version": "3.4.3" + }, + "nltk-3.4.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "59ca5893f0f84b2a4d9f0e9e83a8807d", + "name": "nltk", + "sha256": "d5fd0a63619f8711bbd6a4a50c10301c9b6107bac6ed3e1eaac1beeda6c9ead6", + "size": 1793508, + "subdir": "linux-64", + "timestamp": 1562086276480, + "version": "3.4.3" + }, + "nltk-3.4.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a1c355c92e011c7828293a9d772950fe", + "name": "nltk", + "sha256": "b73b3cc8c284483928ef78d623b103834026fc413ac90dd9d1ff0fc19bea9a14", + "size": 1786764, + "subdir": "linux-64", + "timestamp": 1562086265302, + "version": "3.4.3" + }, + "nltk-3.4.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d9d6126352f7161126fa0090cdf084f8", + "name": "nltk", + "sha256": "ebdbf0494ea1c43e0a0f079df765dc084e05adc017af98d2e40fefc975aca4b9", + "size": 1775524, + "subdir": "linux-64", + "timestamp": 1563286242411, + "version": "3.4.4" + }, + "nltk-3.4.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d42190f3613837274ff36768fcd7a313", + "name": "nltk", + "sha256": "66421004987529e7183708ae8804bf69a616fb59707fe8bb11294bebc9c4bd96", + "size": 1796179, + "subdir": "linux-64", + "timestamp": 1563286247909, + "version": "3.4.4" + }, + "nltk-3.4.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7fc4f3967d00c9e672114cdeaf540f16", + "name": "nltk", + "sha256": "d88bfe9e59f0fb89a70046979b0f1ec06288c0db2981e77d5b7f70e00d98cd00", + "size": 1788531, + "subdir": "linux-64", + "timestamp": 1563286243579, + "version": "3.4.4" + }, + "nltk-3.4.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "05528c221289768745372abfc838e57e", + "name": "nltk", + "sha256": "c96a45f58b59684cbbefe1eb37d15d092c74dff9202800b99d76872644c9395c", + "size": 1796341, + "subdir": "linux-64", + "timestamp": 1566580480929, + "version": "3.4.5" + }, + "nltk-3.4.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "636d2581ad37007089fbd2ff49364bdf", + "name": "nltk", + "sha256": "33b83c341f472129eb517449e2443ac1c13602541ff249a691d3dd96149f2059", + "size": 1817072, + "subdir": "linux-64", + "timestamp": 1566580491576, + "version": "3.4.5" + }, + "nltk-3.4.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1581a1bf0d9246ae873dac2b57e2a510", + "name": "nltk", + "sha256": "dd1960e8a335241851dc3cb5c99e7ffad4d83fa1a5e9335df334a30f4ab93149", + "size": 1808859, + "subdir": "linux-64", + "timestamp": 1566580469184, + "version": "3.4.5" + }, + "nltk-3.4.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8451514bdfb75fe89afa5e2406d2792a", + "name": "nltk", + "sha256": "0592b42eefec268f8b2421d72aea049481b0a911f61d8ff1f62d143ca652dff9", + "size": 1815118, + "subdir": "linux-64", + "timestamp": 1573738348537, + "version": "3.4.5" + }, + "nodeenv-1.7.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e9d77c9a95b28ba3294a662fb6920523", + "name": "nodeenv", + "sha256": "56a357efe36d147c215e341ad080dc64e682af840404742f2c253db79c9acf64", + "size": 43967, + "subdir": "linux-64", + "timestamp": 1663181171744, + "version": "1.7.0" + }, + "nodeenv-1.7.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "54fda4a57ed24395885439693cee3d7a", + "name": "nodeenv", + "sha256": "077554e3e055addc6d6f8001d65defdb224c279626dbdd6ef9d021fca66e32f6", + "size": 53819, + "subdir": "linux-64", + "timestamp": 1676845054283, + "version": "1.7.0" + }, + "nodeenv-1.7.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "495963b92e507f7e6b25f37d517142d8", + "name": "nodeenv", + "sha256": "281e16449a25cafde9eb986e0c09586cc558946223efa71deedc6c8fdb2ed071", + "size": 43650, + "subdir": "linux-64", + "timestamp": 1663181224651, + "version": "1.7.0" + }, + "nodeenv-1.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f635cbc4c9b833474d578fb872800a6e", + "name": "nodeenv", + "sha256": "e63da9e593d3c4ad56746ff84c7fa1acfef0d7af623998c478b6443f157030a2", + "size": 43882, + "subdir": "linux-64", + "timestamp": 1663181197761, + "version": "1.7.0" + }, + "nodeenv-1.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "842d798d83a2a29101751c1e7a3f3789", + "name": "nodeenv", + "sha256": "2354804c5c07d335bdba8f58e13000a3877b81cb10355ef501f6f95d944323cc", + "size": 43925, + "subdir": "linux-64", + "timestamp": 1663181132273, + "version": "1.7.0" + }, + "nodejs-10.13.0-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "5a6606a52db2fa6a99ca1df5bb4b73dd", + "name": "nodejs", + "sha256": "59c8100a13b5f6ed5788467ebb49e66a2284da372f09592bd92bd16c89abe860", + "size": 13590904, + "subdir": "linux-64", + "timestamp": 1541177751056, + "version": "10.13.0" + }, + "nodejs-14.8.0-hda19d22_0.conda": { + "build": "hda19d22_0", + "build_number": 0, + "depends": [ + "icu >=68.1,<69.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libuv >=1.40.0,<1.41.0a0", + "openssl >=1.1.1j,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "254040e8a6969685e12e6490f2676a96", + "name": "nodejs", + "sha256": "65bfb8851fed059e0725f8e40cf785327866ca47414ce71c0aa64a9b566c2322", + "size": 13880875, + "subdir": "linux-64", + "timestamp": 1615888823149, + "version": "14.8.0" + }, + "nodejs-16.13.1-hb931c9a_0.conda": { + "build": "hb931c9a_0", + "build_number": 0, + "depends": [ + "icu >=68.1,<69.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libuv >=1.40.0,<1.41.0a0", + "openssl >=1.1.1l,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "93d2c8c9ad6cedd30f8fc9735eb66ec2", + "name": "nodejs", + "sha256": "48cf9c014ec456148d59bb98e4ca82aeb00a9c92cd341b5878fda9b8b96ee80a", + "size": 13562186, + "subdir": "linux-64", + "timestamp": 1638847541442, + "version": "16.13.1" + }, + "nodejs-16.6.1-hb931c9a_0.conda": { + "build": "hb931c9a_0", + "build_number": 0, + "depends": [ + "icu >=68.1,<69.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libuv >=1.40.0,<1.41.0a0", + "openssl >=1.1.1k,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "7fd168adf96591c98f574da675d9bf4e", + "name": "nodejs", + "sha256": "5b43f647632553a54bc7f646ca3a6f84c231832b11a7c613f7612b16f63a34cb", + "size": 13675957, + "subdir": "linux-64", + "timestamp": 1629196936573, + "version": "16.6.1" + }, + "nodejs-18.15.0-ha637b67_0.conda": { + "build": "ha637b67_0", + "build_number": 0, + "depends": [ + "icu >=58,<59.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuv >=1.44.2,<1.45.0a0", + "openssl >=1.1.1t,<1.1.2a", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da4d402d73331d8f20cde23d7dc07932", + "name": "nodejs", + "sha256": "62e99e9f125a378981b459e16df98ad3e1185567b1f6e909aeb843db98e2dc72", + "size": 16234243, + "subdir": "linux-64", + "timestamp": 1680792375119, + "version": "18.15.0" + }, + "nodejs-6.11.2-h3db8ef7_0.conda": { + "build": "h3db8ef7_0", + "build_number": 0, + "depends": [ + "libgcc", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "0572de1bd6f6382f04fa85ae388c61e4", + "name": "nodejs", + "sha256": "d5024a7441f2c11117a2472f37237dc0ffbe4be7b8c3980ff48ed8a51d83d49b", + "size": 9821528, + "subdir": "linux-64", + "timestamp": 1505746369243, + "version": "6.11.2" + }, + "nodejs-8.11.1-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "f1a9dcbdc19fe416dec1c68d3f28dfe7", + "name": "nodejs", + "sha256": "e739301fe46c38ef62bb44c418d1407ddf80d3e1a6932f2fb211e8135712422c", + "size": 12230849, + "subdir": "linux-64", + "timestamp": 1525983296113, + "version": "8.11.1" + }, + "nodejs-8.11.3-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "1f0c65120b64678c63cbe00e7b399c6e", + "name": "nodejs", + "sha256": "a8bb1a7f1d64c66e0e490112f269dd08332fd6547acce56efa54ce78bec24284", + "size": 12246594, + "subdir": "linux-64", + "timestamp": 1531554770281, + "version": "8.11.3" + }, + "nodejs-8.11.4-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "d819b4628228752aa239893541d32115", + "name": "nodejs", + "sha256": "95fb047cd74190fc27c40bc7d037db18b269482e8d86a7fa327805b8ff4ad91c", + "size": 12612295, + "subdir": "linux-64", + "timestamp": 1535909408715, + "version": "8.11.4" + }, + "nodejs-8.12.0-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "af32512f04b67540b20c4d8d2c7bebf8", + "name": "nodejs", + "sha256": "9bd2de83911c4a71bb00d0591bc0b1f9f022ec5ba4031329256a4434b6bfc641", + "size": 12552912, + "subdir": "linux-64", + "timestamp": 1538330254726, + "version": "8.12.0" + }, + "nodejs-8.9.3-h439df22_0.conda": { + "build": "h439df22_0", + "build_number": 0, + "depends": [ + "libgcc", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "md5": "cd6be78f94d5c919d647f869a51d80a4", + "name": "nodejs", + "sha256": "901b073ad4e31a48468419291a8133673b14127919300e1d98cf31eab0f3e353", + "size": 12298781, + "subdir": "linux-64", + "timestamp": 1517163745353, + "version": "8.9.3" + }, + "nomkl-2.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "blas * openblas" + ], + "license": "BSD", + "md5": "bae820ca31af6289b897257f9278f8e1", + "name": "nomkl", + "sha256": "e95aa1cc58be9725c767a6db4fe0e9892d66d686bd70bf1e0b711b16cb7761a2", + "size": 2731, + "subdir": "linux-64", + "timestamp": 1525427522765, + "track_features": "", + "version": "2.0" + }, + "nomkl-3.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "blas * openblas" + ], + "license": "BSD", + "md5": "740391f874e19e5f291bf7a025a86329", + "name": "nomkl", + "sha256": "e84ad4935f911edd1bcda84a463f0e1a5285d3710c70c19e70248d52d61599e5", + "size": 46705, + "subdir": "linux-64", + "timestamp": 1527877217548, + "track_features": "", + "version": "3.0" + }, + "nose-1.3.7-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "LGPL-2.1", + "md5": "1f91c594d474f5df14f3ad466bb3c8c1", + "name": "nose", + "sha256": "21f3419d6627b19e0794f4c7c0675bc3ad461363417ceeb23cb3f2a3b671139e", + "size": 220680, + "subdir": "linux-64", + "timestamp": 1530695924405, + "version": "1.3.7" + }, + "nose-1.3.7-py27heec2199_2.conda": { + "build": "py27heec2199_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "LGPL-2.1", + "md5": "bbbc54bd57fbc14519f84f61b6dcfa5d", + "name": "nose", + "sha256": "d23079c11a1aaf5f0d1ea57180eb9b8c4d14b55c913c4a3aed5805fbc412877d", + "size": 217576, + "subdir": "linux-64", + "timestamp": 1505688871443, + "version": "1.3.7" + }, + "nose-1.3.7-py310h06a4308_1007.conda": { + "build": "py310h06a4308_1007", + "build_number": 1007, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1-only", + "md5": "3eccbe3b62e022a0e95755677f37f712", + "name": "nose", + "sha256": "93509a9b54c13832cbfa9c438808862868ca4b92c450046a7f43905271282c7d", + "size": 174920, + "subdir": "linux-64", + "timestamp": 1640873180428, + "version": "1.3.7" + }, + "nose-1.3.7-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "LGPL-2.1", + "md5": "aceed9e8b52b407c03f71d7bb0ca05d8", + "name": "nose", + "sha256": "3b01e679bafff820d5158898885d7131b4fab3717ee81f7359aab2560ebb9ca1", + "size": 220751, + "subdir": "linux-64", + "timestamp": 1534345565529, + "version": "1.3.7" + }, + "nose-1.3.7-py35hdc64897_2.conda": { + "build": "py35hdc64897_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "LGPL-2.1", + "md5": "7799d5c489152dc2e6ff45e6672efb67", + "name": "nose", + "sha256": "5e0979bb19f171101389b2c8fc9f84ec2eab6e381b820132d2623557d0d6b94b", + "size": 220547, + "subdir": "linux-64", + "timestamp": 1505688890606, + "version": "1.3.7" + }, + "nose-1.3.7-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "LGPL-2.1", + "md5": "5c74c18dccc71c0d4ebff19eace95b92", + "name": "nose", + "sha256": "24728949504787cbe501622885ef07fa852f13e1750ca18a71d2dd1ecb82193d", + "size": 222243, + "subdir": "linux-64", + "timestamp": 1530695876499, + "version": "1.3.7" + }, + "nose-1.3.7-py36hcdf7029_2.conda": { + "build": "py36hcdf7029_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "LGPL-2.1", + "md5": "2f09d1d575560f6f20597f562736e65a", + "name": "nose", + "sha256": "081f59bc016daa8d6755a88bac5b6284f7f2f6ddb79278cccc83a3a0ba4dd0f1", + "size": 222011, + "subdir": "linux-64", + "timestamp": 1505688910137, + "version": "1.3.7" + }, + "nose-1.3.7-py37_1004.conda": { + "build": "py37_1004", + "build_number": 1004, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "LGPL-2.1", + "md5": "86b8e9a4d0a48dba905b6ca785404bb2", + "name": "nose", + "sha256": "6b277b1ff5cdafdda3c37b37ed53735010b3d25bb6ab80d91453a5ffe4788ffb", + "size": 218962, + "subdir": "linux-64", + "timestamp": 1594377700587, + "version": "1.3.7" + }, + "nose-1.3.7-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "LGPL-2.1", + "md5": "bd5ad412c391fa97b02281bbadeb1e2a", + "name": "nose", + "sha256": "6a7ec11b0136c709c9935ca596813005fe4e028d258f754db40617de452f30e0", + "size": 218896, + "subdir": "linux-64", + "timestamp": 1530695903401, + "version": "1.3.7" + }, + "nose-1.3.7-py38_2.conda": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "LGPL-2.1", + "md5": "e59ba950ed73ea03c406261ee97c6f38", + "name": "nose", + "sha256": "bd196b3949935c1a26920003947cf7a2bac898e7938b3c5f5a17132173f5169b", + "size": 222201, + "subdir": "linux-64", + "timestamp": 1573143550513, + "version": "1.3.7" + }, + "nose-parameterized-0.6.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "e4b6c2ba55112ce9db9890203e6da9fc", + "name": "nose-parameterized", + "sha256": "ea0294818c2d8b2ef5450308e643f99bebbdd6aec8e288421e9551e16b109ab1", + "size": 19555, + "subdir": "linux-64", + "timestamp": 1530917278148, + "version": "0.6.0" + }, + "nose-parameterized-0.6.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8473013bf81ec957f65d9fbd478b0e38", + "name": "nose-parameterized", + "sha256": "8f68da6d6a30784b677d4e3e4dc5f7596db69982c0b9ad4566f5d738016404d5", + "size": 23618, + "subdir": "linux-64", + "timestamp": 1676725816241, + "version": "0.6.0" + }, + "nose-parameterized-0.6.0-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "3c1f433be990c20b6e1b8face3079214", + "name": "nose-parameterized", + "sha256": "425f679884dd11a19caadf148d404b72ae056314ba98a9f2b244f6a2b76e4bb3", + "size": 28607, + "subdir": "linux-64", + "timestamp": 1676859970589, + "version": "0.6.0" + }, + "nose-parameterized-0.6.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "31e6fe0e849cb2a2e4c085f4daf417c5", + "name": "nose-parameterized", + "sha256": "8e16ae03df2eab8a1868587ff5efa87bb32210ca3eed2192c00b6fc3f85c0aef", + "size": 19965, + "subdir": "linux-64", + "timestamp": 1530917306378, + "version": "0.6.0" + }, + "nose-parameterized-0.6.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "280a46dc9fcaa04b7da1611c2ab1f770", + "name": "nose-parameterized", + "sha256": "c59619430d446fa563ad52ac26d52f0fec165aa65c59f949483dacab04db8597", + "size": 23261, + "subdir": "linux-64", + "timestamp": 1676725791423, + "version": "0.6.0" + }, + "nose-parameterized-0.6.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "939253ba7a2ebeb922720c022bc4077b", + "name": "nose-parameterized", + "sha256": "0f0ae8fd72ab430df57e05ab99cc448a0cba65662d08b4d6395ea1d4799b3fe1", + "size": 19972, + "subdir": "linux-64", + "timestamp": 1530917335717, + "version": "0.6.0" + }, + "nose-parameterized-0.6.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ee29f97fec30b1ee8cc4dd42ef2a8672", + "name": "nose-parameterized", + "sha256": "b03641cb03278bae7cfea0b8a51fc4e06ce282e9be38e530e472355c7ee9df81", + "size": 23387, + "subdir": "linux-64", + "timestamp": 1676725767333, + "version": "0.6.0" + }, + "nose-parameterized-0.6.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f15392f3b56868a7547a57a998010b6a", + "name": "nose-parameterized", + "sha256": "ab1a684239fd9b554f7145bf703091598a36bc294150d4e69251605e662489a4", + "size": 23410, + "subdir": "linux-64", + "timestamp": 1676725840564, + "version": "0.6.0" + }, + "nosexcover-1.0.11-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "coverage >=3.4", + "nose", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ab7be08beb71091668b533577b0e23d", + "name": "nosexcover", + "sha256": "f612becf26e2b91ea3e2421885261ffb0bfab5252d2a53580de7164d652b0194", + "size": 9575, + "subdir": "linux-64", + "timestamp": 1537199344631, + "version": "1.0.11" + }, + "nosexcover-1.0.11-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "coverage >=3.4", + "nose", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "67373f4f08df9393550bacfa456761a2", + "name": "nosexcover", + "sha256": "e338717b677bcc20dae2b1a1b5d531eedf505dad0628cece44e393d59d354318", + "size": 9749, + "subdir": "linux-64", + "timestamp": 1537199360253, + "version": "1.0.11" + }, + "nosexcover-1.0.11-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "coverage >=3.4", + "nose", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "165186f878adbdf4817d4c38ceba2d2a", + "name": "nosexcover", + "sha256": "10d5e89381daec15732ebd31f5cbb07b199b5cd7911e3d3f7ccc393101e5efe5", + "size": 9802, + "subdir": "linux-64", + "timestamp": 1537199392978, + "version": "1.0.11" + }, + "nosexcover-1.0.11-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "coverage >=3.4", + "nose", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a00ad4743b323936e71f63458ae672e8", + "name": "nosexcover", + "sha256": "0627d20ea9bd1e2fcc41be4de9f376269805daa6ca1542ad3607aed0cb657a9e", + "size": 9730, + "subdir": "linux-64", + "timestamp": 1537199323264, + "version": "1.0.11" + }, + "notebook-5.0.0-py27h3661c2b_2.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27h3661c2b_2", + "build_number": 2, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "571970c89e2df56b5751007651642c35", + "name": "notebook", + "sha256": "4d455fac6020a5b997b96a135d3e2b94c670e2b2c74dd167bf2f95086f51412c", + "size": 3534471, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1506020374312, + "type": "app", + "version": "5.0.0" + }, + "notebook-5.0.0-py35h65c930e_2.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35h65c930e_2", + "build_number": 2, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "5eee0aa3f718a693392d457c8107a00b", + "name": "notebook", + "sha256": "127cd0f84771fb3844fbf99d946dd31287e592f08b2bdc3a8a58fffd68be16c8", + "size": 3535045, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1506020402472, + "type": "app", + "version": "5.0.0" + }, + "notebook-5.0.0-py36h0b20546_2.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h0b20546_2", + "build_number": 2, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "38bc70970f1d7d175da8b401f34a5f82", + "name": "notebook", + "sha256": "eddb2259784e53f8c66de9bf5163c796538ad77446dbf9b8dfd5b1fbb98cb203", + "size": 3527072, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1506020410740, + "type": "app", + "version": "5.0.0" + }, + "notebook-5.1.0-py27hd3eeb0d_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27hd3eeb0d_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "2c451fdd9b518fc7e4ef3b0fa87ed8c1", + "name": "notebook", + "sha256": "4cb6e88e15c2f15a6e034afddc599a704668d8adf9ccd5715edc3f6ea8d3618d", + "size": 3834634, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1509990491201, + "type": "app", + "version": "5.1.0" + }, + "notebook-5.1.0-py35ha1dae67_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35ha1dae67_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "b0f2cc0cf4436419accee3ddd4cb3680", + "name": "notebook", + "sha256": "3fcd33fbe363ddcb1c7b00e960cda8fe5dfe7038fa8f456bd58c62391442c75d", + "size": 3840030, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1509990500195, + "type": "app", + "version": "5.1.0" + }, + "notebook-5.1.0-py36h2e4799b_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h2e4799b_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "190ac55f68a04acc36c0c294d77288c6", + "name": "notebook", + "sha256": "49e88897b0898146fbd9f260974f6fd7d06290ca99404b71478591482be25afe", + "size": 3843273, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1509990480452, + "type": "app", + "version": "5.1.0" + }, + "notebook-5.2.0-py27h7e51e94_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27h7e51e94_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "ff80e0e24dc610ff56638a766cf8a842", + "name": "notebook", + "sha256": "107f42c98acbaa8813ccc7036aab537e77ff32bd67980c35ae1db3246b4986da", + "size": 3847862, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1509991843909, + "type": "app", + "version": "5.2.0" + }, + "notebook-5.2.0-py35h8f773aa_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35h8f773aa_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "38366320c2439ebc0fa21fcdd71cb69b", + "name": "notebook", + "sha256": "b2830500a6e82b86bd97fd2c18268133937e0ae07d86b23aae61a378d666df42", + "size": 3847957, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1509991866488, + "type": "app", + "version": "5.2.0" + }, + "notebook-5.2.0-py36h840ffc4_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h840ffc4_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "aaa9eb72a938eb1d0eee867a825142b7", + "name": "notebook", + "sha256": "87355b5ac2921664e0d1b0d0a21e10468e43c554011eaf6ac950e86e20c97bc1", + "size": 3853312, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1509991848101, + "type": "app", + "version": "5.2.0" + }, + "notebook-5.2.1-py27h4055434_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27h4055434_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "d6033d8d74e74ae83c44f3b33753f103", + "name": "notebook", + "sha256": "75a8668faef3ea39e677891f0f76ef8981a514bafda139b15f1df1845e9160d9", + "size": 3836848, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1509992476473, + "type": "app", + "version": "5.2.1" + }, + "notebook-5.2.1-py35h35fdc29_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35h35fdc29_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "56082c9c14af7cd03ed953b1021cc5cd", + "name": "notebook", + "sha256": "de8dbb829495df954b6646d78e951182e3bd01cb5adb3cc1bf9f2ec43e6d0e85", + "size": 3848184, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1509992472447, + "type": "app", + "version": "5.2.1" + }, + "notebook-5.2.1-py36h690a4eb_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h690a4eb_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "md5": "82d2a57f111e349faba976b57e8dcf20", + "name": "notebook", + "sha256": "d0b74bd09e97ed08791a2b8886f144c869e9eece87a8119ba12c9b2bcfb1e191", + "size": 3843927, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1509992468606, + "type": "app", + "version": "5.2.1" + }, + "notebook-5.2.2-py27h6748267_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27h6748267_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4a8c53e67eb187e7097dcea417af0dd3", + "name": "notebook", + "sha256": "c66597563b71ad0865ea2cdd59be029b558d3d690fa29888cc43a2668f85b0e6", + "size": 3845921, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1512056125257, + "type": "app", + "version": "5.2.2" + }, + "notebook-5.2.2-py35he644770_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35he644770_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "949b870831e265ce7bcf72d4e92c45c0", + "name": "notebook", + "sha256": "a7ccb36023e8614d276e55cfa702f019500881340238de7ba007d6871766806a", + "size": 3847148, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1512056138485, + "type": "app", + "version": "5.2.2" + }, + "notebook-5.2.2-py36h40a37e6_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h40a37e6_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5689ddeb2377ebbe2d87fa2bef2a0674", + "name": "notebook", + "sha256": "66a731dd00b28bdfe74975a17812b9c86ad84becd8df3142b793bf12efbfa64a", + "size": 3843801, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1512056154533, + "type": "app", + "version": "5.2.2" + }, + "notebook-5.3.1-py27_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "send2trash", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "255f699e32d1bb550c7d16b7cfb4f689", + "name": "notebook", + "sha256": "14fe3146cd931239d62bb96eb9bc4d73c1d2ff52a953913697872e25e8e8694d", + "size": 3876314, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1516378987281, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py27_1.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_1", + "build_number": 1, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "42b0f6ef0a7bdedc26530c1bbc63c135", + "name": "notebook", + "sha256": "1dac42a9bc27a4caee23c0e2921d90be7ce35b6890e8078b17a93f0df9db20bc", + "size": 3873309, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1516901002181, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py27_2.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_2", + "build_number": 2, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6f24c2d104d00ce5ccba438395f5a246", + "name": "notebook", + "sha256": "9bcd9699a909b82b8868a121c826b3e5079ed12108cda2e8c656ae2506369d0d", + "size": 3872574, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1517284522349, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py27_3.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_3", + "build_number": 3, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f27eda24ddc9093e5f0a2a647b388e69", + "name": "notebook", + "sha256": "ac49abdc92955390da9d8c321719cdb181d9fae83b486a2e7cc28e8370b71816", + "size": 3872471, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1517599660480, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py35_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "send2trash", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "03819751e221824536ce7a263ee5f865", + "name": "notebook", + "sha256": "e5531e893c2eedcf9e98a38889dd0ea5fec4cac738a8e2341018149b928a7352", + "size": 3882930, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1516378995284, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py35_1.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35_1", + "build_number": 1, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9b7e9bfc44c4e73c645637180cdb367d", + "name": "notebook", + "sha256": "58d535ebcd67775e12574dd4e3a1480979cc9579ad266c0cb7cbed4c31f2df21", + "size": 3886793, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1516900994402, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py35_2.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35_2", + "build_number": 2, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2f1f0b1cf4cdbc377d7e6a9bfbf64012", + "name": "notebook", + "sha256": "bb7af04c59b593fb5c5449fa8d9f056427958d9ec9e7a3869bf408993ce0e711", + "size": 3886705, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1517284501106, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py35_3.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35_3", + "build_number": 3, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "aaec7adea447fba73b9a2f8ef923b6eb", + "name": "notebook", + "sha256": "3ef421e5f176097f78436fb7e4fb14aa921b68b247f8cbf04978d22ed4f32a69", + "size": 3886598, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1517599711424, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client", + "jupyter_core", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "send2trash", + "terminado >=0.3.3", + "tornado >=4,<6", + "traitlets >=4.3" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "605de687de9e6abbdffcbaf300f50bb1", + "name": "notebook", + "sha256": "f1a0a5134ee1ef2e5f6a58f40c5305592aab8d669cc95ed4eaecc8ee65e9895a", + "size": 3888829, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1516379018481, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py36_1.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_1", + "build_number": 1, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "07686f527590965e077e81a120e3f4b3", + "name": "notebook", + "sha256": "f76335b6ee166b2fdb16d69028900755e807ad72cbd5f1b1370db7ddf5cf1031", + "size": 3888476, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1516901069049, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py36_2.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_2", + "build_number": 2, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "75da60589e647706b994cf070aed71dd", + "name": "notebook", + "sha256": "f05c9cdb063f67ae6f7e89eda152ca7223d65efc580dfadc2f9f96783a9b1bc9", + "size": 3876305, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1517284536277, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.3.1-py36_3.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_3", + "build_number": 3, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8d05448a30b9b013d6aa59e5b8d6f3c4", + "name": "notebook", + "sha256": "3a331e27d542412aff4db72711cef37905fa53a7fe1f0aef9df87f993e7e27de", + "size": 3888428, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1517599668303, + "type": "app", + "version": "5.3.1" + }, + "notebook-5.4.0-py27_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "79eaf8bac4ee7982f69a3de572e54674", + "name": "notebook", + "sha256": "c43af4abea338cca77482e25d78167e5d66f41a77dd08658f631153d012800cb", + "size": 3869376, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1517597710556, + "type": "app", + "version": "5.4.0" + }, + "notebook-5.4.0-py35_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c0d377d96161be7e58bc74235ad91e7d", + "name": "notebook", + "sha256": "67c4192657d4f7c842f870c92cda183254fc39c319bef8210d14741fd36f3f99", + "size": 3889322, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1517597772373, + "type": "app", + "version": "5.4.0" + }, + "notebook-5.4.0-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f7bee22f5f8174d9117cd9ea5f4e2953", + "name": "notebook", + "sha256": "ae34febd8b4e5e844a8df81721e5cedd3c904f47ce91fcecd2e5f8c40d69ab51", + "size": 3877782, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1517597712745, + "type": "app", + "version": "5.4.0" + }, + "notebook-5.4.1-py27_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "db8c945df70f7f8bfd5004f61c6a00be", + "name": "notebook", + "sha256": "24f9e464c9287a79c771ad17b80aea48c6e019b0c97faba5df177ce8aa9f7a59", + "size": 3883372, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1521583897536, + "type": "app", + "version": "5.4.1" + }, + "notebook-5.4.1-py35_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5599e0357af7e6db7d0ba6872fb3d84e", + "name": "notebook", + "sha256": "42f82a9a6645bb1bfc5b05bcac9c7b9a6dcbafd143279d8d75d62ca2c368d6d5", + "size": 3887107, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1521583997287, + "type": "app", + "version": "5.4.1" + }, + "notebook-5.4.1-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "fc48b88a1dd326144fbfec56d636d2f9", + "name": "notebook", + "sha256": "05527765d95243a2a505a60a2e5a3c3c5961438f5cc4a32cd9bf33c3ff740023", + "size": 3882824, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1521584005149, + "type": "app", + "version": "5.4.1" + }, + "notebook-5.5.0-py27_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "11216fcaa5e182a7f767445d659c4136", + "name": "notebook", + "sha256": "9072db46b40c9ef9519a4be4a8b8b658cb7b1393d694a70caea1fafbae5c58c3", + "size": 4024928, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1526402013440, + "type": "app", + "version": "5.5.0" + }, + "notebook-5.5.0-py35_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.5,<3.6.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5c31d9e046fc6b5905818569e226c6af", + "name": "notebook", + "sha256": "f39ec5999a73f5674ad84ea6e555184e11852a15f9904fc11ff42d44a6c3093f", + "size": 4030925, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1526402062117, + "type": "app", + "version": "5.5.0" + }, + "notebook-5.5.0-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d0b7c4df6b7343488fe89a5a5692fe01", + "name": "notebook", + "sha256": "abbf10aa43325e140ed34c64e8feef8160ef561426ed7fcdf665c93deff3a23a", + "size": 4038160, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1526401999139, + "type": "app", + "version": "5.5.0" + }, + "notebook-5.5.0-py37_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b1af3ff60a55dbef67e059e7d30aec26", + "name": "notebook", + "sha256": "3b4baa07593e19e883a4313ec5de4007e042e33ee41bd97d6bcd26b506b08642", + "size": 4038552, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1530734695114, + "type": "app", + "version": "5.5.0" + }, + "notebook-5.6.0-py27_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9c64feccf14c17555289465bf6f01582", + "name": "notebook", + "sha256": "ff17cb4c1b005080cd158c3548046ec8b5b9a290933dbf5421353e8aa68e33f9", + "size": 4313894, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1531776180120, + "type": "app", + "version": "5.6.0" + }, + "notebook-5.6.0-py35_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.5,<3.6.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c790171283ec14d34b3598ca163533ec", + "name": "notebook", + "sha256": "7983a3d368e718c1d31acc0961ef7c07324bee5ffc6177ed44cb849e13efae58", + "size": 4311127, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1531776242622, + "type": "app", + "version": "5.6.0" + }, + "notebook-5.6.0-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8dc9e8d7fe9efb1aa1478a7075ce634d", + "name": "notebook", + "sha256": "f7435cb14c521c6975b4f8ddd69b9218526a428f8874ad1a0739e32f0d8b08ba", + "size": 4318806, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1531776294400, + "type": "app", + "version": "5.6.0" + }, + "notebook-5.6.0-py37_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "65c9f81d717bfe33a924abe23c472245", + "name": "notebook", + "sha256": "2e0f4b8ee98bfbfeb75e70989978f567bda1671ac5d0521e992d2872dbba8bdc", + "size": 4315963, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1531776296525, + "type": "app", + "version": "5.6.0" + }, + "notebook-5.7.0-py27_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "009634147c6a74e25863a1571a343175", + "name": "notebook", + "sha256": "6089495bf5de96e583a8d1b1eb790b161457cf3f0b17395789849c655366cfd4", + "size": 4295209, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1538589087538, + "type": "app", + "version": "5.7.0" + }, + "notebook-5.7.0-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "fe8456cffadc5341b949dbcb10c3c888", + "name": "notebook", + "sha256": "c32f270ef191b4e6b9f0bac3b2181655122e531df9975b7aac34ef4d25317639", + "size": 4287832, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1538589087433, + "type": "app", + "version": "5.7.0" + }, + "notebook-5.7.0-py37_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d875120c53261941c9dc8aeb4c377eda", + "name": "notebook", + "sha256": "c03bd77bbb70ae4e94b54e81ffb3bdebd4d7f0852fc331e01a97ba399139a8a1", + "size": 4285532, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1538589076147, + "type": "app", + "version": "5.7.0" + }, + "notebook-5.7.1-py27_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b2af1af295390d117b4601a2ecf7c516", + "name": "notebook", + "sha256": "8a6c959544df6a68aced2d70440352f5752af9c86b76e4a00a29cda855f12a4d", + "size": 4298161, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1542407389252, + "type": "app", + "version": "5.7.1" + }, + "notebook-5.7.1-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e6531ee39b88a76596ba504c92967a33", + "name": "notebook", + "sha256": "7226a14817cdfc204beb10d68c74ce9463df7aec52079c21fb4b65a3552f495b", + "size": 4290558, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1542407422611, + "type": "app", + "version": "5.7.1" + }, + "notebook-5.7.1-py37_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d9623bb2d076f53ec7c0da5e72b9f7bf", + "name": "notebook", + "sha256": "23e22a459e3451d43d9d3d4317617f316b240d139693c3908ce9eea10f6c3af0", + "size": 4294176, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1542407415587, + "type": "app", + "version": "5.7.1" + }, + "notebook-5.7.10-py27_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert <6.0", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "04a37a8cda5841f380ae3a241e7c94f6", + "name": "notebook", + "sha256": "356e7874d8d5f02386e4500f0367c899b5c07607dc70cd9d121aab5b946c686d", + "size": 4425516, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1595953412335, + "type": "app", + "version": "5.7.10" + }, + "notebook-5.7.10-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert <6.0", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "baec6e2f09f9c94adb6655b965071dd9", + "name": "notebook", + "sha256": "9dfa8f7e2d0acb779aca6b818e794246d1cb3cdfe05070345aac1b044a62f42a", + "size": 4446597, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1595951667014, + "type": "app", + "version": "5.7.10" + }, + "notebook-5.7.10-py37_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert <6.0", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "078fba5ad6b793b817c9e965d76c1788", + "name": "notebook", + "sha256": "82a5841eeacc8f7661d7e3d94548d83b8b80876dd666d2e8bc271ab379f0cce2", + "size": 4424642, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1595951650778, + "type": "app", + "version": "5.7.10" + }, + "notebook-5.7.10-py38_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert <6.0", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6cbd920ec7658c2bc5f892b998a790fe", + "name": "notebook", + "sha256": "6f6d9ede2b726a32fe9e0ebe9f5bc94b5ff0d2994700aac47f71c83db3195ec3", + "size": 4425366, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1595951667522, + "type": "app", + "version": "5.7.10" + }, + "notebook-5.7.2-py27_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "389cb7ce27767b0e61abb8d53aa586c8", + "name": "notebook", + "sha256": "9424a20e4d40786647a3b009e4f395d9e4271ffdf11bcd3dff628ce8679229f5", + "size": 4287966, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1542640958808, + "type": "app", + "version": "5.7.2" + }, + "notebook-5.7.2-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "69ad779aeb437aa3dc0cfe01c4f5bf7f", + "name": "notebook", + "sha256": "758d0de022b92f3a496d0b6da80f05d494a347f79210a8b3b2544d3c2270292e", + "size": 4288318, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1542640982432, + "type": "app", + "version": "5.7.2" + }, + "notebook-5.7.2-py37_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0dab3a205bb6b77e3d5d8a547961204e", + "name": "notebook", + "sha256": "a2e5ae0b7f80c160ef2df37688086c9114f157f6551495ae19c446c4de114e93", + "size": 4300139, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1542640963040, + "type": "app", + "version": "5.7.2" + }, + "notebook-5.7.4-py27_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a2f0c1cf36aad87479c56bca6dee91ac", + "name": "notebook", + "sha256": "832ba68cb7f4d1f436242f3cb3de16501a0b1ef094165537d358702e04aedf1f", + "size": 4299816, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1545057355411, + "type": "app", + "version": "5.7.4" + }, + "notebook-5.7.4-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "41cd339a0dede38646f16d06d3da3cf9", + "name": "notebook", + "sha256": "948dd4911538ab6a56b89a5aa6ba921dc5b8791b3e593e70465745548489452f", + "size": 4298014, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1545057383859, + "type": "app", + "version": "5.7.4" + }, + "notebook-5.7.4-py37_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4,<6", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d1acc889f11c41a2493e689a06ff1e30", + "name": "notebook", + "sha256": "aa0d2dec9c83179a41ba5b348b1eb165d07ed58ea1bcf945bfce070c9c4bb39b", + "size": 4296966, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1545057381894, + "type": "app", + "version": "5.7.4" + }, + "notebook-5.7.6-py27_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "28d432aad38558ab99bbe7979e9e1fbd", + "name": "notebook", + "sha256": "2290a5daa9f1e7405a89e7d478307b824c2f7d927a440ce2561e8c7b9fea867f", + "size": 4304300, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1552325462953, + "type": "app", + "version": "5.7.6" + }, + "notebook-5.7.6-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6dd5f3f10ef2834d50d5db1acc23ab52", + "name": "notebook", + "sha256": "e7fc4dcc0a51f9acde3a76cb76f1d3a7fbbfda5ab876d060de598ee13651d11a", + "size": 4304955, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1552325468150, + "type": "app", + "version": "5.7.6" + }, + "notebook-5.7.6-py37_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cb4df0c855ebcafdf0afe74bd25ee899", + "name": "notebook", + "sha256": "1a5c7efcda0f5e8c6b54e919ab0f3992b98b4b22b752ec1817b1646cca1cd09b", + "size": 4299214, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1552325463940, + "type": "app", + "version": "5.7.6" + }, + "notebook-5.7.7-py27_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3ec670b5698b8f7ab5bd9b997ffa263b", + "name": "notebook", + "sha256": "6cc9c99bddbc280a9fe9f80aacc4c4fcda5633e3d61ff72ec70f4696baa5ae80", + "size": 4314674, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1553778893599, + "type": "app", + "version": "5.7.7" + }, + "notebook-5.7.7-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2a9b0ca0e094605c532d3580f45c7a5e", + "name": "notebook", + "sha256": "b27e0241276d5d08b15816c2d4d1127da67ccc6fc03270175f636d62b40ed2eb", + "size": 4302298, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1553779054958, + "type": "app", + "version": "5.7.7" + }, + "notebook-5.7.7-py37_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ee5e6eb3fdc40162628f311d85671f53", + "name": "notebook", + "sha256": "be614bab61ed2ee467aa5658b92633183411e65f7e4a55e07320ac1848d4232d", + "size": 4303376, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1553778896535, + "type": "app", + "version": "5.7.7" + }, + "notebook-5.7.8-py27_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cb44daa3899db1a4e4c9013063f1f96a", + "name": "notebook", + "sha256": "9329f69f4884277522fbce4673af857d20e6d1111bfe14f9fa586694bfadffda", + "size": 4305616, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1554133769498, + "type": "app", + "version": "5.7.8" + }, + "notebook-5.7.8-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b8dc7bb5bbaf504a415eecc40c4f4980", + "name": "notebook", + "sha256": "0da01e7ad2ce3db707d3a502ac587933e5e22c8a075bdf7dbc3a19f7b6116003", + "size": 4306093, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1554133780255, + "type": "app", + "version": "5.7.8" + }, + "notebook-5.7.8-py37_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4df54f431ec0f49c999dfcf16ce69f04", + "name": "notebook", + "sha256": "b97b723cd45a8c35160e5c77fa2888ff7c984d79ef27f3a96d007b12e87922ae", + "size": 4302509, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1554133790519, + "type": "app", + "version": "5.7.8" + }, + "notebook-5.7.9-py27_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert <6.0", + "nbformat", + "prometheus_client", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4acfbe82f094a39b856b720ba68b9bcb", + "name": "notebook", + "sha256": "87e74c6e9da70b62cffe1609c416337efdf86cc6a6c349e3c2a59a44c824d4cd", + "size": 4411837, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1588949767586, + "type": "app", + "version": "5.7.9" + }, + "notebook-5.7.9-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert <6.0", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dadd16ed20ddc84d6da7f24748d67c47", + "name": "notebook", + "sha256": "5a6de9c7261f7971cad63d4e4e761654ff5f2e8921d4cd59e5e9181e77b0f41d", + "size": 4396025, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1588949779012, + "type": "app", + "version": "5.7.9" + }, + "notebook-5.7.9-py37_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert <6.0", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "597e06e4f7da4a8233ad588297783779", + "name": "notebook", + "sha256": "f16cafe32b27f023c98fa8aa62b7420dfdae6489cde24ad606c28c3137b03e06", + "size": 4419393, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1588949774808, + "type": "app", + "version": "5.7.9" + }, + "notebook-5.7.9-py38_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.2.0", + "jupyter_core >=4.4.0", + "nbconvert <6.0", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=4.1,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2734206491d75cbb7642d8db461f01d2", + "name": "notebook", + "sha256": "481bafaa7c5176cfabb1da52546b6885eb71df553bd0a1867ba05456c30365dc", + "size": 4426569, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1588949755871, + "type": "app", + "version": "5.7.9" + }, + "notebook-6.0.0-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.1", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0852b6bcbe14c05c7f1cd10ef7ab0916", + "name": "notebook", + "sha256": "e71753ec7ca6cefa5a5916be560445cdbda2e8d6926c3b00f52aa84d5a40924f", + "size": 4072383, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1563372829054, + "type": "app", + "version": "6.0.0" + }, + "notebook-6.0.0-py37_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.1", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "89d1a5bc5eac913906d9784c17044b83", + "name": "notebook", + "sha256": "f706c00cc27d7d06a39b717f440ac2b66a28e72254f6c07b8ec2bc483273f4d6", + "size": 4073297, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1563372826867, + "type": "app", + "version": "6.0.0" + }, + "notebook-6.0.1-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.1", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9b7253f743217fcc376e792af4843ae7", + "name": "notebook", + "sha256": "1f913840c3e7758cf8a806a324ca67ad722e3f97265bebb34dd578cd37d3d469", + "size": 4105309, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1568217583118, + "type": "app", + "version": "6.0.1" + }, + "notebook-6.0.1-py37_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.1", + "jupyter_core >=4.4.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "398b596a0150bc237b7174483189fd2d", + "name": "notebook", + "sha256": "ce9f00cb35d69683fec24d35a66d1cf92b0313d4a979e9fc12e7a783191b9346", + "size": 4097113, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1568217598986, + "type": "app", + "version": "6.0.1" + }, + "notebook-6.0.2-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a08c50a80811699584513f0ad4e52f4e", + "name": "notebook", + "sha256": "babae175186f12eeabacdc387c78b8832b4e0013ede18e45cdcd9ca0fefa5bd1", + "size": 4161866, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1573576088030, + "type": "app", + "version": "6.0.2" + }, + "notebook-6.0.2-py37_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "608fef62c254a257c3a354d1b7fcfc6f", + "name": "notebook", + "sha256": "77b99aff295b43e4bec35f3d796570766e87f6c47f3256c43276915f6239050f", + "size": 4160649, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1573576091832, + "type": "app", + "version": "6.0.2" + }, + "notebook-6.0.2-py38_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.0", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0,<7", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dfc48ea9f594833361f000e80c7d8731", + "name": "notebook", + "sha256": "0ce055bca3eac8972752456cea2bd646825b62a21bd8af54c807b7c73ca21b78", + "size": 4156252, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1574238699415, + "type": "app", + "version": "6.0.2" + }, + "notebook-6.0.3-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1c2cfc36b3c5998f707972edc4c7d10b", + "name": "notebook", + "sha256": "d575d8da6f2e30be1053a7586ac4740c6a495b4e3f1f776ebe014c590e295543", + "size": 4154216, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1580148794141, + "type": "app", + "version": "6.0.3" + }, + "notebook-6.0.3-py37_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1b6921de979a0335f41f7fe897e43aae", + "name": "notebook", + "sha256": "eac221fbd62e878515b48e99cb2c146ab50759f65927e05cda7384972be4c6c0", + "size": 4155405, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1580148806627, + "type": "app", + "version": "6.0.3" + }, + "notebook-6.0.3-py38_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "84b9f928f27ef3fb0e198316c92880f9", + "name": "notebook", + "sha256": "57f0f5e348688b0771ee051397cfcec99d71cce679bc9a67ca727f729376a460", + "size": 4160818, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1580148766770, + "type": "app", + "version": "6.0.3" + }, + "notebook-6.1.1-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7fe0dc55cff461d609d24d1495ab4498", + "name": "notebook", + "sha256": "b0b0e205c22c610a23d2f06b8dd444a8e25ccfa328864ef43e1f2dd76ac77b6c", + "size": 4223717, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1596838642871, + "type": "app", + "version": "6.1.1" + }, + "notebook-6.1.1-py37_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa71967cea66d802734b922324b2245d", + "name": "notebook", + "sha256": "47fdf8858cb3d9fadb566a50cf2b534c97c27a6cf3fa046d0bb7cece0a954185", + "size": 4231122, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1596838688558, + "type": "app", + "version": "6.1.1" + }, + "notebook-6.1.1-py38_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a90b675d8e46db6dd92b48f085df274", + "name": "notebook", + "sha256": "be2a62bd5a3a6abda7f2309f4f2ddce7bededb40adb91341f18438b246d7fc7e", + "size": 4233953, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1596838674769, + "type": "app", + "version": "6.1.1" + }, + "notebook-6.1.4-py36_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7fad11613dae65a2ec8461fdf3190de7", + "name": "notebook", + "sha256": "f302742aafc962e54c8464e978e5307536f83fb0385b8fbb056d2caa1db02313", + "size": 4254489, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1601501621727, + "type": "app", + "version": "6.1.4" + }, + "notebook-6.1.4-py37_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f7fba90ec2fcaca56ae25674c0ad4f9", + "name": "notebook", + "sha256": "02d4b5e6529f383ede9ebf2a04065c1f55da0edef1a91854e76fc24ef3e82be6", + "size": 4248786, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1601501623496, + "type": "app", + "version": "6.1.4" + }, + "notebook-6.1.4-py38_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e741949b256b46520f7d6b811cc2cdb3", + "name": "notebook", + "sha256": "357410a5d448250d108464a959297c045e35e59571b6c9c9f2568b26f4d157fb", + "size": 4250228, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1601501614764, + "type": "app", + "version": "6.1.4" + }, + "notebook-6.1.4-py39h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "28d194e87a02c3a8fdef138c9daf7cbe", + "name": "notebook", + "sha256": "184f58b679ec0b664dd46a3e1d7fdde53abf4b1dcd22a2ca9419850a8c876dcf", + "size": 4266637, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1607529945972, + "type": "app", + "version": "6.1.4" + }, + "notebook-6.1.5-py36h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6fd061726b40939bcb285de601f41c91", + "name": "notebook", + "sha256": "23d9402adbcbd83bcf0d7fc0a080ebe9ffc6f3f48fd4b0175accf097915a5e69", + "size": 4263363, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1607976391259, + "type": "app", + "version": "6.1.5" + }, + "notebook-6.1.5-py37h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9a598b861620937201de73cb16dbff3d", + "name": "notebook", + "sha256": "2aa914b5f27029e16ca55f9f8350aefd6914967f94b657801d940076bfa71614", + "size": 4251435, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1607976347603, + "type": "app", + "version": "6.1.5" + }, + "notebook-6.1.5-py38h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b7be1c23a9962ada77ab7306c5abcb47", + "name": "notebook", + "sha256": "a3553751888e45598f65978a0a1b1830e0d1d9cf93cbf0fda5c8b3ccab242de8", + "size": 4257311, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1607976398003, + "type": "app", + "version": "6.1.5" + }, + "notebook-6.1.5-py39h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "abaedbc830e1c40a262e272cd4ccea5b", + "name": "notebook", + "sha256": "628bd4a872bdc79dbccf983628b6bb47bbcdd688bc56b1d8abdfbb2bc7f9b607", + "size": 4252245, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1607976371819, + "type": "app", + "version": "6.1.5" + }, + "notebook-6.1.6-py36h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f4dacce0bd5e7b4851c31a57cc8a397f", + "name": "notebook", + "sha256": "8a9f6d7d5606991935232653b7f04823c1b90e38f81368de8e0aff1c2b95d99c", + "size": 4259146, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1608835632177, + "type": "app", + "version": "6.1.6" + }, + "notebook-6.1.6-py37h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "038353b68772f9f9a5708a1c88174af3", + "name": "notebook", + "sha256": "339b36018501b196f22b96aed272dad0f3ee46ef06c461a0570400b5f652f00e", + "size": 4256217, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1608835593876, + "type": "app", + "version": "6.1.6" + }, + "notebook-6.1.6-py38h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f5cd928732262df7a4a07138bb5cf1ab", + "name": "notebook", + "sha256": "e4def334c4c56f63d3084af810cdb39c1ccc4fc33ee802b821f8e78c61d9ef21", + "size": 4261423, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1608835633388, + "type": "app", + "version": "6.1.6" + }, + "notebook-6.1.6-py39h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6e49d1434abf3fb6b1aad2bdecf217ac", + "name": "notebook", + "sha256": "fb82bf3fd41789df067af898e9bd33977e581d5d2639685846991d65e0e148da", + "size": 4267637, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1608835629116, + "type": "app", + "version": "6.1.6" + }, + "notebook-6.2.0-py36h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a3266212efa66bb4395bf29efc84ed39", + "name": "notebook", + "sha256": "6641b9d7e47f13e3a7dfc00e6775f87aeb0a6ed175fffba226f361153bdd474a", + "size": 4260765, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1611341060825, + "type": "app", + "version": "6.2.0" + }, + "notebook-6.2.0-py37h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dc04835a10eece76fc5e0e6b491f73cc", + "name": "notebook", + "sha256": "85c709a7b782bdef7144d28dcd74d800ae0895ecdf92fab9f6f918b3d8ca87fe", + "size": 4255114, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1611341027352, + "type": "app", + "version": "6.2.0" + }, + "notebook-6.2.0-py38h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a1a41fd01067b64e0e12dd39f91c0e4c", + "name": "notebook", + "sha256": "223b23a6e7bf7a793c7b0a53880b875290008b8f8689818d402e9ab243730147", + "size": 4255045, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1611341017313, + "type": "app", + "version": "6.2.0" + }, + "notebook-6.2.0-py39h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1fe03e401a1c75b212255478c603978c", + "name": "notebook", + "sha256": "def285f3c77137819de254d1f93abfc095926953077072204325a2a31c1456d3", + "size": 4265533, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1611340611646, + "type": "app", + "version": "6.2.0" + }, + "notebook-6.3.0-py36h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7974972c9a1943fd4b35385a35d6c51a", + "name": "notebook", + "sha256": "e4ca47a8b5beedeface1c7021fefd3141b9d4320795b864b1cb478ffdaf7ae43", + "size": 4271540, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1616443508688, + "type": "app", + "version": "6.3.0" + }, + "notebook-6.3.0-py37h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "35fb65eb2dedb4b81415acb3b1a4c483", + "name": "notebook", + "sha256": "5753d9c2be30c011142425957178134caf15cd585a280ad223f8180ea0ff45cc", + "size": 4269602, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1616443501918, + "type": "app", + "version": "6.3.0" + }, + "notebook-6.3.0-py38h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a93c01053e48a7e34e41ecee709ae67", + "name": "notebook", + "sha256": "c4ebc502d9d9bab527d6bdbc93a5255c6fb63f38ff9b421d2f18ef5836ebb352", + "size": 4276562, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1616443517244, + "type": "app", + "version": "6.3.0" + }, + "notebook-6.3.0-py39h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "37f7cddf27475b28863e777d950d7929", + "name": "notebook", + "sha256": "5fcc4923a7fc06348e09094d5409520a57d82e773a8865b3347f5b0a23918119", + "size": 4273334, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1616443164184, + "type": "app", + "version": "6.3.0" + }, + "notebook-6.4.0-py36h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "78d46926ae0c395da72d8361b1754945", + "name": "notebook", + "sha256": "2f809389db0de992d9fbf3af363833676c4ed9703700d1ce82bb2a4a8f1b97d0", + "size": 4264831, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1621523718518, + "type": "app", + "version": "6.4.0" + }, + "notebook-6.4.0-py37h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "96dfbd21c35557dd54df2d30dcd49d76", + "name": "notebook", + "sha256": "96456df41ff73213185773b5ab0162e14ee28fbcbfe88d4be674a06e78ca0398", + "size": 4266054, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1621523716449, + "type": "app", + "version": "6.4.0" + }, + "notebook-6.4.0-py38h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash", + "terminado >=0.8.1", + "tornado >=5.0", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d14f87ce114d804abcbd109814d5a06a", + "name": "notebook", + "sha256": "99084cdc019523f3efe3ed2a0758d43332d44702267082387e2b69337ec7450e", + "size": 4273362, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1621528398612, + "type": "app", + "version": "6.4.0" + }, + "notebook-6.4.0-py39h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "61be4b7a5c90c1e587e2cb542ddda423", + "name": "notebook", + "sha256": "b1c55579a9bf9cc110c48dd8be3c51e1eac47edaa9a6093c509ff319ed2855d9", + "size": 4268590, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1621625672341, + "type": "app", + "version": "6.4.0" + }, + "notebook-6.4.1-py36h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "11a60086605971fbe63a5f22856b0cb3", + "name": "notebook", + "sha256": "9841e7fd989b7c5596b798c5da7265803db65df524c3c7214062995cd5aed5ae", + "size": 4328491, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1628267042819, + "type": "app", + "version": "6.4.1" + }, + "notebook-6.4.1-py37h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c53a66a396fa13ec222abff180df4c2d", + "name": "notebook", + "sha256": "911a791de49787dcd027fe718b68a6288e6c0ebb196cbe4352ff52456229e4e0", + "size": 4327425, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1628267222046, + "type": "app", + "version": "6.4.1" + }, + "notebook-6.4.1-py38h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "afba28fdbafd148ff64456e6b2b31afd", + "name": "notebook", + "sha256": "d2f6247b7c9a441629306fc12c931c842d6bd40da34d96a0ce4651bb7218c9e4", + "size": 4334294, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1628267163991, + "type": "app", + "version": "6.4.1" + }, + "notebook-6.4.1-py39h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8477ef81dcb5501f821026ff7b5e63f8", + "name": "notebook", + "sha256": "0edec4771e58dba087b17f1855dfb8f8839a883d80f8f97f33325fbca421ea1e", + "size": 4329439, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1628267106277, + "type": "app", + "version": "6.4.1" + }, + "notebook-6.4.11-py310h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "995f0c3a915118069eeee94355b834fe", + "name": "notebook", + "sha256": "6df98387d737300110a7dc777680f6b856a9120822db6c452d556b1da282421f", + "size": 4411477, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1651734648785, + "type": "app", + "version": "6.4.11" + }, + "notebook-6.4.11-py37h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d703de1a41f100e8007e97841e23f910", + "name": "notebook", + "sha256": "16c22869f5b98e95ec1438ed6a3550c92bba7da126b282c5a9fe8a642d4cd62a", + "size": 4401016, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1651734579793, + "type": "app", + "version": "6.4.11" + }, + "notebook-6.4.11-py38h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2e58e04bd54880bea66b833c68f5f8c0", + "name": "notebook", + "sha256": "24dda7e43e7bb8b53e1058d3d7a9031b9cfb1067a7405a59b1d53d8a1fc70355", + "size": 4402232, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1651734703901, + "type": "app", + "version": "6.4.11" + }, + "notebook-6.4.11-py39h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1897c07c782a8fa453d2394d510b7f8", + "name": "notebook", + "sha256": "24cf58a9b5ed20243a2e3c395dd751cf6a31a5f61246575e527707eedcaf274c", + "size": 4406760, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1651734760641, + "type": "app", + "version": "6.4.11" + }, + "notebook-6.4.12-py310h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ec185f9ba23cb7f7eaaeb46d89a2137", + "name": "notebook", + "sha256": "91fe045b5fd429b6a0119c051c49763e10ffdfbef0f798bcb2586674679db3dd", + "size": 4410013, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1659083858285, + "type": "app", + "version": "6.4.12" + }, + "notebook-6.4.12-py37h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b9266575067ec130a0ffcf641fdb7446", + "name": "notebook", + "sha256": "f0e744cbba3ff75e68f5142b3f2ed0b26e4fbfea523f6ad3f6dec8530450d567", + "size": 4406944, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1659083924293, + "type": "app", + "version": "6.4.12" + }, + "notebook-6.4.12-py38h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6e75e584bef4a13459f4d5350fe1782c", + "name": "notebook", + "sha256": "871d5b5e12d5b3cb256d361fd14ba4d4d1f912aef83091477d26e71ecd4b1ab6", + "size": 4405985, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1659083709869, + "type": "app", + "version": "6.4.12" + }, + "notebook-6.4.12-py39h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b1782a590d18e6907cc29b67a446a8be", + "name": "notebook", + "sha256": "16bec47f56c0bcde7977201af69c10fa4cb145b1572dc1943b7ac45dc919323b", + "size": 4408077, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1659083778795, + "type": "app", + "version": "6.4.12" + }, + "notebook-6.4.2-py36h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8c4be18d2dd4f508f757183080fd9a18", + "name": "notebook", + "sha256": "f12c409ec9c734e2c1d962fd566c777dc3a521796f50f57f861f3ab87189b7cd", + "size": 4322143, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1628508027496, + "type": "app", + "version": "6.4.2" + }, + "notebook-6.4.2-py37h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1fcd2f91b2cfffa3e4ef29c090e78e6f", + "name": "notebook", + "sha256": "85dd5b242093c69649811d0805292d8c7dc9cd7906867f48fe3086e0f3f70784", + "size": 4327489, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1628515884642, + "type": "app", + "version": "6.4.2" + }, + "notebook-6.4.2-py38h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a49f1a8e5eafd919b1e29359ada680ca", + "name": "notebook", + "sha256": "6cfdd0375d5ffa2f0c46ae3ba76069d9ef09b7be373732a71afd284ad8e1b543", + "size": 4323931, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1628516219137, + "type": "app", + "version": "6.4.2" + }, + "notebook-6.4.2-py39h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ca0087ec2a54898b2f9506107394abd1", + "name": "notebook", + "sha256": "200b8b0fb1021dc912eaca1bf8054bd6dae0967da095c932b3f35244f2a521a3", + "size": 4334656, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1628516219423, + "type": "app", + "version": "6.4.2" + }, + "notebook-6.4.3-py36h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a14a510d7323ca836e758e34525515d", + "name": "notebook", + "sha256": "339bfb127dc3ef971813939c1078cca8f65f74346ff0ea348fa06b36e87f4ccb", + "size": 4375342, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1629197269593, + "type": "app", + "version": "6.4.3" + }, + "notebook-6.4.3-py37h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9c79247decdaed6193fa903a582afa3a", + "name": "notebook", + "sha256": "1baf28d41e2a74a48468dcc6acf8e00ea22f62ffde6a35f8f200a380cacfa046", + "size": 4374493, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1629205813957, + "type": "app", + "version": "6.4.3" + }, + "notebook-6.4.3-py38h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "73e27a047ab31fa224ea2a620a7955ab", + "name": "notebook", + "sha256": "0861794fb42b55c4277ad85201d85d6cd3e510b2079e6d357ed44395b760d906", + "size": 4378842, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1629205645590, + "type": "app", + "version": "6.4.3" + }, + "notebook-6.4.3-py39h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "09cf8d96e1cefa35e2f36a80ca456521", + "name": "notebook", + "sha256": "8cdab65236e6d9378ad60062c33a3eff51b93bc543f5196ee9cb11577ec2cd0b", + "size": 4383707, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1629205814578, + "type": "app", + "version": "6.4.3" + }, + "notebook-6.4.5-py37h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a5123c1346bd6a605699e326d402af65", + "name": "notebook", + "sha256": "b82a94de28d94f184c9595f000e841719906bb1a1fdd40b3dcf7132f199534e4", + "size": 4376019, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1635411689698, + "type": "app", + "version": "6.4.5" + }, + "notebook-6.4.5-py38h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8c881a6c3b533431e6581d486fb1bf8f", + "name": "notebook", + "sha256": "e023b35d0a7ff6ec1638ea0bef7316cbf09e2233672d3266fd258ba5fa0d6a20", + "size": 4380734, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1635411683662, + "type": "app", + "version": "6.4.5" + }, + "notebook-6.4.5-py39h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.5.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e25a6fa3dbca9ff64db5b00e4a7d729b", + "name": "notebook", + "sha256": "d4756b026c1c2ee63366b33fe298a919f61e4c8484802a7dad310ddc4dcc0c24", + "size": 4381382, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1635411690469, + "type": "app", + "version": "6.4.5" + }, + "notebook-6.4.6-py310h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dd5d8bbe7eb4ec79f16216d0cc3886e7", + "name": "notebook", + "sha256": "f29933416c1d777983d8dde68e17a74d236e4d58abb474a909b57b27a4b18a0e", + "size": 4381117, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1641917356276, + "type": "app", + "version": "6.4.6" + }, + "notebook-6.4.6-py37h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e6caf66d99135052bfc01bba2fda9e3", + "name": "notebook", + "sha256": "b5e192b99e69d3cb7ad9fb3756551529bf742f48c5a404d94f45fabd30d4d801", + "size": 4377792, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1637161817007, + "type": "app", + "version": "6.4.6" + }, + "notebook-6.4.6-py38h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22aa37201d899844b4228d3d59a5bceb", + "name": "notebook", + "sha256": "2cc54c83ac1873fcafa04848eb80c64701a76dfe98bb7b6146f8ddf7c28dfb5e", + "size": 4383223, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1637161821073, + "type": "app", + "version": "6.4.6" + }, + "notebook-6.4.6-py39h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7ef24660c112218591231669de098ae1", + "name": "notebook", + "sha256": "cfa888816df19665d676ea2f45195712b14885a6cbf385e19a13b1946323f1e8", + "size": 4377135, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1637161803717, + "type": "app", + "version": "6.4.6" + }, + "notebook-6.4.8-py310h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f2832688a2e7db95aa97d36156c499b0", + "name": "notebook", + "sha256": "cf011c27499065a1231170d79bb0243e65ead6b5af98b712915ac0639bfe4988", + "size": 4401698, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1645002596662, + "type": "app", + "version": "6.4.8" + }, + "notebook-6.4.8-py37h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "560c0692780da00cec13933990081aaf", + "name": "notebook", + "sha256": "b0358747b8d68cc220bb1644a3d5cf8e742f5ec5e7a829aae543f26acc19792a", + "size": 4388671, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1644986026092, + "type": "app", + "version": "6.4.8" + }, + "notebook-6.4.8-py38h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "606fa21d2b403e0f7ad729242d22deb6", + "name": "notebook", + "sha256": "be27fcf28d730293b7dadbd33c6b29c7e8d41a8ef421d51ccf776cf4e1fc00ac", + "size": 4392408, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1645002581081, + "type": "app", + "version": "6.4.8" + }, + "notebook-6.4.8-py39h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbconvert", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "87fed315e272bff8f5d5912b23b66f53", + "name": "notebook", + "sha256": "66ce255d824f29d079a84b72d92899889334637a62b90a9bad0fb012c64f7580", + "size": 4395574, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1645002575385, + "type": "app", + "version": "6.4.8" + }, + "notebook-6.5.2-py310h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbclassic >=0.4.7", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "11acdc3a7c3304921c9d073f6b4cf647", + "name": "notebook", + "sha256": "b99d9f8310cabf91e9f3ed91931b54877d75354361384a01299d6c1c26c2ed40", + "size": 526252, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1668179999416, + "type": "app", + "version": "6.5.2" + }, + "notebook-6.5.2-py311h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbclassic >=0.4.7", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b63b74ed8d880e9fdd29e5e1ebcbfaf0", + "name": "notebook", + "sha256": "25a66303853698a8f3ad5774c311d2e02cf5cac1a7408531bab54120f24a6673", + "size": 623718, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1676918975856, + "type": "app", + "version": "6.5.2" + }, + "notebook-6.5.2-py37h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbclassic >=0.4.7", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "134886f92ce31fc13199e0e491b01d04", + "name": "notebook", + "sha256": "c4c9e4ba290f2fe97525f34080d12befeb95393bbc6def79ba8e03ea42a391a4", + "size": 519728, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1668179939557, + "type": "app", + "version": "6.5.2" + }, + "notebook-6.5.2-py38h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbclassic >=0.4.7", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bbf75eed1bb1d709122df32580275a84", + "name": "notebook", + "sha256": "51456e04e966cb77381e50b05eb5513aaf60f2cccf4e185e795166045f5e37c4", + "size": 522062, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1668180059918, + "type": "app", + "version": "6.5.2" + }, + "notebook-6.5.2-py39h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbclassic >=0.4.7", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e57d817d09d57659a235209791f438a5", + "name": "notebook", + "sha256": "47cd84987670da28649baebb1c86e5b3e053d04e10efd210115af3d8470d406c", + "size": 523042, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1668180119805, + "type": "app", + "version": "6.5.2" + }, + "notebook-6.5.3-py310h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbclassic >=0.4.7", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "94bbdf129f69f0d6bebc52903a60bf91", + "name": "notebook", + "sha256": "0f67ac8f65cc3d20d43dbcd52e5ce330fad67dd3f6a1545b343b86ccd9af010a", + "size": 556998, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1680012183396, + "type": "app", + "version": "6.5.3" + }, + "notebook-6.5.3-py311h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbclassic >=0.4.7", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.11,<3.12.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8cda77ebb0e4dfbfb3e637771dba585a", + "name": "notebook", + "sha256": "f3322d3274d876b5e96c511767f9406087a52c49c494efdf6713f062332b849e", + "size": 692849, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1680012055601, + "type": "app", + "version": "6.5.3" + }, + "notebook-6.5.3-py38h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbclassic >=0.4.7", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c8d0e3cb8cd8f8d1606128b4cb291d88", + "name": "notebook", + "sha256": "db0ec70005843504c8e45143a15e563ad505f6a40cff67dd8c51c90564c3d16e", + "size": 552507, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1680012119058, + "type": "app", + "version": "6.5.3" + }, + "notebook-6.5.3-py39h06a4308_0.conda": { + "app_cli_opts": [ + { + "args": "--port %s", + "default": "8080", + "name": "port", + "summary": "Server port ..." + } + ], + "app_entry": "jupyter-notebook", + "app_type": "web", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argon2-cffi", + "ipykernel", + "ipython_genutils", + "jinja2", + "jupyter_client >=5.3.4", + "jupyter_core >=4.6.1", + "nbclassic >=0.4.7", + "nbconvert >=5", + "nbformat", + "nest-asyncio >=1.5", + "prometheus_client", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "send2trash >=1.8.0", + "terminado >=0.8.3", + "tornado >=6.1", + "traitlets >=4.2.1" + ], + "icon": "df7feebede9861a203b480c119e38b49.png", + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "112f6ff15a747b8e07960e646c92b8be", + "name": "notebook", + "sha256": "947f01aa3cec27146efa5718830ffd27f0bef41674233bde85d70caccaf5dcae", + "size": 552951, + "subdir": "linux-64", + "summary": "Jupyter Notebook", + "timestamp": 1680012246096, + "type": "app", + "version": "6.5.3" + }, + "notebook-shim-0.2.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_server >=1.8,<3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fc559bc8ff77360e786c7a12fbed5fbb", + "name": "notebook-shim", + "sha256": "c37add2abe5f38dc4ed90ef6b035a8bd3c6769f1aec2d55a65dbc72df019fe2f", + "size": 23162, + "subdir": "linux-64", + "timestamp": 1668160675427, + "version": "0.2.2" + }, + "notebook-shim-0.2.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_server >=1.8,<3", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "553d6565082e7332300e7840aa9f87e4", + "name": "notebook-shim", + "sha256": "6d432dd5520a56a13325d94365d983ecd344e35a2bd57a219e8f9466c5bacedd", + "size": 25685, + "subdir": "linux-64", + "timestamp": 1676825066023, + "version": "0.2.2" + }, + "notebook-shim-0.2.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_server >=1.8,<3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b41f1ea2654812e38b0f369259991e9a", + "name": "notebook-shim", + "sha256": "8cf6690fb2ec1fd2cdff44b149d43a4c7a50a64cc731b2760759c02016e0c54b", + "size": 22961, + "subdir": "linux-64", + "timestamp": 1668160612300, + "version": "0.2.2" + }, + "notebook-shim-0.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_server >=1.8,<3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7b5a8fdb26c87cae9dd023bfa6ecf125", + "name": "notebook-shim", + "sha256": "976e55d78191bb9c5fb9f518848f15310c8cfef7a8b64f675ef24571206c3d09", + "size": 22997, + "subdir": "linux-64", + "timestamp": 1668160706352, + "version": "0.2.2" + }, + "notebook-shim-0.2.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_server >=1.8,<3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7fd7fc05a3d34d67c464981c5f69ff3c", + "name": "notebook-shim", + "sha256": "5f22a7f849946cdef4f94f1db0f98abfbbeef68f4abfbd2b29977d3dd4c8420a", + "size": 23022, + "subdir": "linux-64", + "timestamp": 1668160644514, + "version": "0.2.2" + }, + "nspr-4.22-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MPL 2", + "md5": "8f098f1aaad17c937c1a078d173d8717", + "name": "nspr", + "sha256": "5cce191df58f329effb02248f107d8be44c6f1ec97b8b8633d3f3bc4c058d317", + "size": 1361835, + "subdir": "linux-64", + "timestamp": 1588087601204, + "version": "4.22" + }, + "nspr-4.28-hdbfa776_0.conda": { + "build": "hdbfa776_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MPL-2.0", + "md5": "df600694f26d8b858117ad907c949410", + "name": "nspr", + "sha256": "3ea5db17a4970991141904e6b7a1fcffcc00aa2616c09f8bea9e6d287be4b004", + "size": 230006, + "subdir": "linux-64", + "timestamp": 1636044936217, + "version": "4.28" + }, + "nspr-4.33-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MPL-2.0", + "license_family": "OTHER", + "md5": "78454e8819eb6701abc74b2ab2889f21", + "name": "nspr", + "sha256": "b72b03f5036498d7ee592d4eb74c0bdbed1b97d149edc7f49e646237efec8874", + "size": 227396, + "subdir": "linux-64", + "timestamp": 1643617339565, + "version": "4.33" + }, + "nss-3.46.1-hab99668_0.conda": { + "build": "hab99668_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "nspr >=4.22,<5.0a0", + "sqlite >=3.31.1,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MPL 2", + "md5": "20f4c6e6275c29b0ede35360b212dec8", + "name": "nss", + "sha256": "11375da1a7a39300cb0d0895831758e1320cdd67bbf7f6bcd1c640ec2196e084", + "size": 1764344, + "subdir": "linux-64", + "timestamp": 1588094503330, + "version": "3.46.1" + }, + "nss-3.56-h5657611_0.conda": { + "build": "h5657611_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "nspr >=4.27", + "sqlite >=3.36.0,<4.0a0", + "zlib" + ], + "license": "MPL 2", + "md5": "6efc81fadd476fc4358249fd3d9aeeee", + "name": "nss", + "sha256": "00d1efe6ab5d00e6ed74dd8494261d579917c0a2a8643c4cbc937c4a078210e0", + "size": 1953443, + "subdir": "linux-64", + "timestamp": 1636111922987, + "version": "3.56" + }, + "nss-3.74-h0370c37_0.conda": { + "build": "h0370c37_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "nspr >=4.33,<5", + "nspr >=4.33,<5.0a0", + "sqlite >=3.37.0,<4.0a0" + ], + "license": "MPL-2.0", + "license_family": "OTHER", + "md5": "fb2426b2f3cb17c9015fcbdf917a2f7b", + "name": "nss", + "sha256": "b91e6cd8f73b9f5395a09cf8b3548ea9c56849327b6c51a250bc30f3ae526ad3", + "size": 1982683, + "subdir": "linux-64", + "timestamp": 1644222015064, + "version": "3.74" + }, + "nsync-1.24.0-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "18f13db46b33ffb261ac836934ed12e0", + "name": "nsync", + "sha256": "7c4b1ced99d3017090a386710b90de0a629cc065f52bb5895558190f08e2e273", + "size": 49187, + "subdir": "linux-64", + "timestamp": 1622094522407, + "version": "1.24.0" + }, + "numba-0.35.0-np113py27_10.conda": { + "build": "np113py27_10", + "build_number": 10, + "depends": [ + "funcsigs", + "llvmlite 0.20.*", + "numpy 1.13*", + "python 2.7*", + "singledispatch" + ], + "license": "BSD", + "md5": "1b00f33e7bc58461adcadb892eadd634", + "name": "numba", + "sha256": "25a153e551d10c99c27a0600653022ca168923c0034439195f535fe1966fea30", + "size": 2321739, + "subdir": "linux-64", + "version": "0.35.0" + }, + "numba-0.35.0-np113py35_10.conda": { + "build": "np113py35_10", + "build_number": 10, + "depends": [ + "llvmlite 0.20.*", + "numpy 1.13*", + "python 3.5*" + ], + "license": "BSD", + "md5": "183e05ad3213218a533c5d729e875838", + "name": "numba", + "sha256": "f7f0f9436b3bc2c0c0c075f3702568a1b515404280211d206afacecf5f727af5", + "size": 2362956, + "subdir": "linux-64", + "version": "0.35.0" + }, + "numba-0.35.0-np113py36_10.conda": { + "build": "np113py36_10", + "build_number": 10, + "depends": [ + "llvmlite 0.20.*", + "numpy 1.13*", + "python 3.6*" + ], + "license": "BSD", + "md5": "a20a7f39ebbdb96c619b52ffcd7cb959", + "name": "numba", + "sha256": "e90d46418b52b8ba739bc027faae015e55496f86eaf0ab90eea83c9ef4f5bee5", + "size": 2357749, + "subdir": "linux-64", + "version": "0.35.0" + }, + "numba-0.36.1-np110py27h97c9c31_0.conda": { + "build": "np110py27h97c9c31_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.10,<1.11.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "b22f3a54bdd98a5b6fbce31e5d65bfe8", + "name": "numba", + "sha256": "586199a9fbd7117b5103b1d4097f76cb9ec87aa9b1558a0824ec86b8e5646ce1", + "size": 2099252, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np110py35heb30733_0.conda": { + "build": "np110py35heb30733_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.10,<1.11.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "0395e7cf05da95d4c11e467ba3f87155", + "name": "numba", + "sha256": "e26f29e0818c003d0f9359136fc8dc086a54252bcb36bbb2682ee6e15f4bf111", + "size": 2155942, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np111py27h2ed7fd9_0.conda": { + "build": "np111py27h2ed7fd9_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.11,<1.12.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "ff36c1333bb6ef475ca5f0468e1acfb6", + "name": "numba", + "sha256": "97445ae1cc89a6807f17568eb990f74efa8dfc2dcb1d5ab31d7f98d96201089c", + "size": 2099312, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np111py35h3a0790d_0.conda": { + "build": "np111py35h3a0790d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.11,<1.12.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "82c5110199ea7f2172ef451e69b4f0a0", + "name": "numba", + "sha256": "2d3a9ca335c71376c62e0027f12f0b80869ed4bf766ab84fb73d12a60f395ba7", + "size": 2173306, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np111py36h9f231e2_0.conda": { + "build": "np111py36h9f231e2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.11,<1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "d918a0f2823755b9035943cc133ca8f7", + "name": "numba", + "sha256": "a3d57402c9b728ccececb978588d53fed160a985c6e39ea76cae416e13e68508", + "size": 2151554, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np112py27h00f7d58_0.conda": { + "build": "np112py27h00f7d58_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.12,<1.13.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "552e81ea839fb53a4cf3a6aa0360d357", + "name": "numba", + "sha256": "2a2d164194a30cea5305d3c5f45b78448bde8b2938d8a2b519ab3dfe1e7f86c1", + "size": 2090450, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np112py35he47b545_0.conda": { + "build": "np112py35he47b545_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.12,<1.13.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "9d30079ba49c2d946e80a09262179f28", + "name": "numba", + "sha256": "632b7d9fc3cc490eaa6a614a5d58603b30678a03f58de8c7e43e5f3a8fb030cc", + "size": 2164821, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np112py36hf993da8_0.conda": { + "build": "np112py36hf993da8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.12,<1.13.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "6a3acef40543b57e1a48af1c54a65394", + "name": "numba", + "sha256": "0a10367d1122413f9ebbf7c6e39550483a0ecff66dda7f52b23f52b347dfe060", + "size": 2142489, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np113py27hee5a248_0.conda": { + "build": "np113py27hee5a248_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.13,<1.14.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "96af92e15b51855ca3bf8138e365e93c", + "name": "numba", + "sha256": "50904a88b7ac0b9e851716459b44c0300aa8321f962dd7ad8eab05dde34c4506", + "size": 2104615, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np113py35hf1afa12_0.conda": { + "build": "np113py35hf1afa12_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.13,<1.14.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "8e2b04bcf27a077ffd4c445fa508f1fd", + "name": "numba", + "sha256": "0acba8380e895a9b44c5dc5a7a561dc69406afe1f014c81d33f77586174f11ab", + "size": 2148452, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.1-np113py36hd14f252_0.conda": { + "build": "np113py36hd14f252_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.13,<1.14.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "c25c22e80f418bb953ac4c9a3092f082", + "name": "numba", + "sha256": "939e707bd149258b749f6a9ea0c2ea80bac32e3f751521585cb036b4dd523f56", + "size": 2142692, + "subdir": "linux-64", + "timestamp": 1512604800000, + "version": "0.36.1" + }, + "numba-0.36.2-np110py27h2a5c770_0.conda": { + "build": "np110py27h2a5c770_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.10,<1.11.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "58c34da870a9154c3fc43d86a33e697f", + "name": "numba", + "sha256": "bd46c798e6a24f870079868df3966e6ba002fca7a912f7652b65c55666ce734c", + "size": 2100005, + "subdir": "linux-64", + "timestamp": 1513741177911, + "version": "0.36.2" + }, + "numba-0.36.2-np110py35ha5fb34f_0.conda": { + "build": "np110py35ha5fb34f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.10,<1.11.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "48a476e0acc79ae2e3d83d4b4575be8a", + "name": "numba", + "sha256": "062a775cc9d2ffb96bb9dff85f8b4ab03fb3440945cc95a0acff1dc3982c6745", + "size": 2156202, + "subdir": "linux-64", + "timestamp": 1513737650048, + "version": "0.36.2" + }, + "numba-0.36.2-np111py27haafad4c_0.conda": { + "build": "np111py27haafad4c_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.11,<1.12.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "6843269e515647ba0d2f645726a93681", + "name": "numba", + "sha256": "5ace9c3cf9f3d6327ad2b61bf592ee49b03d1b736afd6a4d8c8c5057bb2b683a", + "size": 2113151, + "subdir": "linux-64", + "timestamp": 1513738106712, + "version": "0.36.2" + }, + "numba-0.36.2-np111py35h14f0b80_0.conda": { + "build": "np111py35h14f0b80_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.11,<1.12.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "341cae76a6fb4b28c22e57ef58fd0b33", + "name": "numba", + "sha256": "68924bed319d35943dcb39d5b9c6785769c3c8f5862f775ed9ec944b671d5b19", + "size": 2171503, + "subdir": "linux-64", + "timestamp": 1513738954723, + "version": "0.36.2" + }, + "numba-0.36.2-np111py36h12fd6ba_0.conda": { + "build": "np111py36h12fd6ba_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.11,<1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "c69358f2bffe623240a9152ba268c3a1", + "name": "numba", + "sha256": "8361e32fa1a30c0c74eef3796358e000d5c0dd995adecdc2d6036284c91e3604", + "size": 2150920, + "subdir": "linux-64", + "timestamp": 1513739359054, + "version": "0.36.2" + }, + "numba-0.36.2-np112py27h603bb47_0.conda": { + "build": "np112py27h603bb47_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.12,<1.13.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "1728aeb2045cdeebd323d932d2421236", + "name": "numba", + "sha256": "4499adb432cfe3fead8e1863707e11784a5c449c2f6a973ac453f028f7d42169", + "size": 2092224, + "subdir": "linux-64", + "timestamp": 1513739762361, + "version": "0.36.2" + }, + "numba-0.36.2-np112py35h68e262a_0.conda": { + "build": "np112py35h68e262a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.12,<1.13.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "22de7d0ae101d0deaf3e043f422317f2", + "name": "numba", + "sha256": "6348c7cc92f0264a65c5d617a4fb5ce943678936b885c953a208c2ef0500ba1f", + "size": 2149545, + "subdir": "linux-64", + "timestamp": 1513740751985, + "version": "0.36.2" + }, + "numba-0.36.2-np112py36hbcd2105_0.conda": { + "build": "np112py36hbcd2105_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.12,<1.13.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "e5472e5865d421dd42c3edb91fe550a3", + "name": "numba", + "sha256": "5433884cb23bf837ef15b8e820101a8e5a97a8e06c9bde3fafe2bda1e95fcaf7", + "size": 2141801, + "subdir": "linux-64", + "timestamp": 1513740272851, + "version": "0.36.2" + }, + "numba-0.36.2-np113py27h0c80d70_0.conda": { + "build": "np113py27h0c80d70_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.13,<1.14.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "c0dd5a4bf85fa2f6464ab9783c872f8b", + "name": "numba", + "sha256": "0ed2136599d1986457ef9868bbec809c94ed9b6deb907490a6b80b99a96db330", + "size": 2092082, + "subdir": "linux-64", + "timestamp": 1513738503816, + "version": "0.36.2" + }, + "numba-0.36.2-np113py35ha7cad2d_0.conda": { + "build": "np113py35ha7cad2d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.13,<1.14.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "af7cb9cb86fb6e1f47b904e0c9df0257", + "name": "numba", + "sha256": "e2b5a79ee20fab6a570aaf8a5e3db20d6dcd4436e89122ca87d311e7b3200e58", + "size": 2163113, + "subdir": "linux-64", + "timestamp": 1513742028593, + "version": "0.36.2" + }, + "numba-0.36.2-np113py36h7a10136_0.conda": { + "build": "np113py36h7a10136_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.13,<1.14.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "63103beff3e4587d2f0657586d25caff", + "name": "numba", + "sha256": "68e90d6678ffbc201b218476078f71877838e03b32209f97c0dcd048113d054f", + "size": 2128237, + "subdir": "linux-64", + "timestamp": 1513741603471, + "version": "0.36.2" + }, + "numba-0.36.2-np114py27he2868da_0.conda": { + "build": "np114py27he2868da_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.14,<1.15.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "2c76be8f81ce7502377636bcffa53056", + "name": "numba", + "sha256": "63a026a13958899d3473d486a009369ddae49c2c3b3630aece5730566a8c9f08", + "size": 2104651, + "subdir": "linux-64", + "timestamp": 1517878246171, + "version": "0.36.2" + }, + "numba-0.36.2-np114py35ha126a20_0.conda": { + "build": "np114py35ha126a20_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.14,<1.15.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "50fead3be300f5c75a6def82a418b50d", + "name": "numba", + "sha256": "de924694f8389310ff89e4f632fb73fec10dd4791fdd38c4442406beacbca38f", + "size": 2163053, + "subdir": "linux-64", + "timestamp": 1517878654303, + "version": "0.36.2" + }, + "numba-0.36.2-np114py36hc6662d5_0.conda": { + "build": "np114py36hc6662d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.21.*", + "numpy >=1.14,<1.15.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "5465ff7e4cec30c5c72c052510a118b1", + "name": "numba", + "sha256": "e5bd98fa9ac0e19ea2a7790466941dde76bc5e83aae9bd5ed17b0d4b04453470", + "size": 2141944, + "subdir": "linux-64", + "timestamp": 1517879065668, + "version": "0.36.2" + }, + "numba-0.37.0-np110py27h105fbcc_0.conda": { + "build": "np110py27h105fbcc_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.10,<1.11.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "6592273496c733049da1b31cd662698e", + "name": "numba", + "sha256": "a5630b730ffdd781a0c1e5f592c20460b558c087eca52694715dd1a484700b5a", + "size": 2128590, + "subdir": "linux-64", + "timestamp": 1518740978913, + "version": "0.37.0" + }, + "numba-0.37.0-np110py35h8b0d19d_0.conda": { + "build": "np110py35h8b0d19d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.10,<1.11.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "9b4f98d2ccc6582e585a018b06295703", + "name": "numba", + "sha256": "911f9624528020ceff117c486cc5dd907637b34314a02946b4f5d92b426616a4", + "size": 2187084, + "subdir": "linux-64", + "timestamp": 1518738883168, + "version": "0.37.0" + }, + "numba-0.37.0-np111py27h2eedcfd_0.conda": { + "build": "np111py27h2eedcfd_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.11,<1.12.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "0e4cb5063082200b8532f73fd4698035", + "name": "numba", + "sha256": "f215987fa9ded66976b8c8bc3e52611c379218e1e9fecc6487c188f9563b0ef5", + "size": 2144240, + "subdir": "linux-64", + "timestamp": 1518739770121, + "version": "0.37.0" + }, + "numba-0.37.0-np111py35h3e3e0ff_0.conda": { + "build": "np111py35h3e3e0ff_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.11,<1.12.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "0e02a1d6447720c24e6a984b0e465d3b", + "name": "numba", + "sha256": "d056f63c22bc708cd74590a64743e6b9e05ca0365a5e37e15796e5e0732b5437", + "size": 2204047, + "subdir": "linux-64", + "timestamp": 1518737654461, + "version": "0.37.0" + }, + "numba-0.37.0-np111py36h8336faa_0.conda": { + "build": "np111py36h8336faa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.11,<1.12.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "5cf27013eb0a935ab44b8ec398a2d1a8", + "name": "numba", + "sha256": "a9810f97297df0a67f4fa0c6d00dfc7c5ba81b02f4b7f126e9cfb98f39b7edd3", + "size": 2167752, + "subdir": "linux-64", + "timestamp": 1518740594772, + "version": "0.37.0" + }, + "numba-0.37.0-np112py27h96054c9_0.conda": { + "build": "np112py27h96054c9_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.12,<1.13.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "e6d885f6bc640cd7f475bc29d9a285be", + "name": "numba", + "sha256": "d175db888698f0fe403f6d44517d7fb2e643dbbe2e48af3184a6547998ae3f75", + "size": 2121516, + "subdir": "linux-64", + "timestamp": 1518739289171, + "version": "0.37.0" + }, + "numba-0.37.0-np112py35h0b3d877_0.conda": { + "build": "np112py35h0b3d877_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.12,<1.13.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "3eaf87de7d21310387720a600be7f658", + "name": "numba", + "sha256": "93701822a5fd765e1e6275919af8121479c9f83e60b690c7da2d83a8872145ab", + "size": 2180939, + "subdir": "linux-64", + "timestamp": 1518742332942, + "version": "0.37.0" + }, + "numba-0.37.0-np112py36ha11926f_0.conda": { + "build": "np112py36ha11926f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.12,<1.13.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "b5886adab5e372e55b940b9821f0da81", + "name": "numba", + "sha256": "111931fb78ea42637aea2502cb92457042094498ab8d30b8f50bc3ca15339c6c", + "size": 2160151, + "subdir": "linux-64", + "timestamp": 1518738060388, + "version": "0.37.0" + }, + "numba-0.37.0-np113py27h18d2f7f_0.conda": { + "build": "np113py27h18d2f7f_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.13,<1.14.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "07784c439069d031d23d03d1318c282f", + "name": "numba", + "sha256": "08da32d30588f7455a4757ff9fade63036a441def0f155a8a4dee88d272853da", + "size": 2121941, + "subdir": "linux-64", + "timestamp": 1518740174292, + "version": "0.37.0" + }, + "numba-0.37.0-np113py35h384d3fa_0.conda": { + "build": "np113py35h384d3fa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.13,<1.14.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "0efba34a791e92773c7bab6ca5252363", + "name": "numba", + "sha256": "b99926147b856dc70767044d03c813eb40314045788157fb4bdadc8fd8d883bf", + "size": 2196033, + "subdir": "linux-64", + "timestamp": 1518741405170, + "version": "0.37.0" + }, + "numba-0.37.0-np113py36ha6e7140_0.conda": { + "build": "np113py36ha6e7140_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.13,<1.14.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "080bfa9e76a1a9cd3d4a57a8d268c08f", + "name": "numba", + "sha256": "dbda5818e1307f5ba635b6947bed7fde5ea9431f8f0f69ade5d5d9e91b5bd469", + "size": 2173539, + "subdir": "linux-64", + "timestamp": 1518738477658, + "version": "0.37.0" + }, + "numba-0.37.0-np114py27h76b0b06_0.conda": { + "build": "np114py27h76b0b06_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.14,<1.15.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD", + "md5": "9e1ce2f4e85795063572c692c70c81dc", + "name": "numba", + "sha256": "677309f3494dae044565cbc22e41306fe59abf7c9662d99d8d25fa2262afa8a6", + "size": 2135187, + "subdir": "linux-64", + "timestamp": 1518736712175, + "version": "0.37.0" + }, + "numba-0.37.0-np114py35h095f75c_0.conda": { + "build": "np114py35h095f75c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.14,<1.15.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "0b5fdbab797d91a4773bc0ba67ae0689", + "name": "numba", + "sha256": "7af8003824c85e079c24962e23a87d6931897a24def54df4d62b5b3ebd4333fa", + "size": 2181259, + "subdir": "linux-64", + "timestamp": 1518737209155, + "version": "0.37.0" + }, + "numba-0.37.0-np114py36h5fcf951_0.conda": { + "build": "np114py36h5fcf951_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.22.*", + "numpy >=1.14,<1.15.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "9218789933b4ec960340eb98d6785159", + "name": "numba", + "sha256": "bca12c0bc60b8373ab5865856c0d36fef236f135f8fd9671a744b3be2841458c", + "size": 2160511, + "subdir": "linux-64", + "timestamp": 1518741861173, + "version": "0.37.0" + }, + "numba-0.38.0-py27h637b7d7_0.conda": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.23.*", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "886c9e79d2ae2f462fdb4e792f84016e", + "name": "numba", + "sha256": "62ba017c3238841f67460c31e3a910b914381be4489c743bb447f57719e7460b", + "size": 2179809, + "subdir": "linux-64", + "timestamp": 1526595523754, + "version": "0.38.0" + }, + "numba-0.38.0-py35h637b7d7_0.conda": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.23.*", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "5203b7dac740dfcb248d42131a67e847", + "name": "numba", + "sha256": "b15957b837b6f4df951816426b2b4785200bbadf61b0ce466745a91e227a308a", + "size": 2254783, + "subdir": "linux-64", + "timestamp": 1526595571925, + "version": "0.38.0" + }, + "numba-0.38.0-py36h637b7d7_0.conda": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.23.*", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "31584f01c6bf3c7d200eb43584e011a2", + "name": "numba", + "sha256": "88c3b687c7a75fb39d0042ef0afe31dade9222440ea2e1c9f9b5b929e73c792d", + "size": 2217622, + "subdir": "linux-64", + "timestamp": 1526595228660, + "version": "0.38.0" + }, + "numba-0.38.1-py27h04863e7_0.conda": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.23.*", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "7a89d6a75d46a7c0eaa032c77eef9926", + "name": "numba", + "sha256": "a07e8303ce832ae052f36bef2c3e8e56c5dec77484ba82b968669753f90bdda7", + "size": 2180226, + "subdir": "linux-64", + "timestamp": 1529658599982, + "version": "0.38.1" + }, + "numba-0.38.1-py35h04863e7_0.conda": { + "build": "py35h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.23.*", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "5107477802637d7eff6a4dd7b603c52f", + "name": "numba", + "sha256": "e26ae7955a9341e04f75530f7cca1791d28dade6f15b3643ea96168591864021", + "size": 2239023, + "subdir": "linux-64", + "timestamp": 1529658623288, + "version": "0.38.1" + }, + "numba-0.38.1-py36h04863e7_0.conda": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.23.*", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "c2c1b66666ad295540ffc9a686f2c630", + "name": "numba", + "sha256": "81ca34edbe7087c93617162f5e6e0f4da31db3502e00e8ff375e3bde1f1262f2", + "size": 2219667, + "subdir": "linux-64", + "timestamp": 1529658561894, + "version": "0.38.1" + }, + "numba-0.39.0-py27h04863e7_0.conda": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "funcsigs", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.24.*", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "d400a0e957e31a4358b404fd21af0340", + "name": "numba", + "sha256": "f099ff8cf6bd8866ca2f9fe48d42ae6da7bdc0f806566f2a9aff3be0bd4ed7ba", + "size": 2209705, + "subdir": "linux-64", + "timestamp": 1531257034346, + "version": "0.39.0" + }, + "numba-0.39.0-py35h04863e7_0.conda": { + "build": "py35h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite 0.24.*", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "75a7d9f31e95aa91cf219a6dd0eeb6e6", + "name": "numba", + "sha256": "598779b021f1a839b5f7a83df10d7a40895230536ef292b637acaa311986e599", + "size": 2260616, + "subdir": "linux-64", + "timestamp": 1534899392490, + "version": "0.39.0" + }, + "numba-0.39.0-py36h04863e7_0.conda": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.24.*", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "5979df8909236eab0a9c4d2b77ed2dcc", + "name": "numba", + "sha256": "8ef4bced888c7575701f1169cdb047a6edd5a87bbfc4316cfe919fee4a4e3cc1", + "size": 2237377, + "subdir": "linux-64", + "timestamp": 1531257503034, + "version": "0.39.0" + }, + "numba-0.39.0-py37h04863e7_0.conda": { + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "llvmlite 0.24.*", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "c9744c0b4e2dcdfcd80951f36130b115", + "name": "numba", + "sha256": "4d759c8eafda219e5115891c37385856db9fe306f77666c6037bf945a3a04947", + "size": 2248618, + "subdir": "linux-64", + "timestamp": 1531258379379, + "version": "0.39.0" + }, + "numba-0.40.0-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.25.0,<0.26.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "619ff0c8a8a2f9e0e1cafdca881d76db", + "name": "numba", + "sha256": "75c3ed531d88e4c165db971a8692b391e67e9d48eff70744feaeaed18dbaeb1e", + "size": 2412717, + "subdir": "linux-64", + "timestamp": 1538621953011, + "version": "0.40.0" + }, + "numba-0.40.0-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.25.0,<0.26.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "5699d1f166ccc34c962c47c0d4a0a3f6", + "name": "numba", + "sha256": "9eb54a6dac9947e4ef07a74804ed1ab388e2b671ce24449ba765925a00b064ef", + "size": 2461641, + "subdir": "linux-64", + "timestamp": 1538622249475, + "version": "0.40.0" + }, + "numba-0.40.0-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.25.0,<0.26.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "0c12ca89166735e6ebf9474d1c57dbd1", + "name": "numba", + "sha256": "90bd19f56df55a2b19824cf7b5887b394510abc9e299723468eb3ac733b502d2", + "size": 2444600, + "subdir": "linux-64", + "timestamp": 1538621695236, + "version": "0.40.0" + }, + "numba-0.41.0-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.26.0,<0.27.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.1" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "3726e11283d4fe02c4cc76a99cdd3c1f", + "name": "numba", + "sha256": "259c7f13abc5923e509db50c89e0b40432093004e453f2ea6c0d7a9971c20cce", + "size": 2485689, + "subdir": "linux-64", + "timestamp": 1543476833072, + "version": "0.41.0" + }, + "numba-0.41.0-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.26.0,<0.27.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.1" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "7bd432b9d1054ec58ca6381eb0217dca", + "name": "numba", + "sha256": "f3906175ca3f1b120f0493af595f848883a7ca7fd5fa5e6a538bf4591b396676", + "size": 2537119, + "subdir": "linux-64", + "timestamp": 1543476762035, + "version": "0.41.0" + }, + "numba-0.41.0-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.26.0,<0.27.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.1" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "060114179af1859160d6c1feb9d0fc89", + "name": "numba", + "sha256": "456473b70e8a0f2b1bdbe18ca61e50eadd12352e37206f6d5146efcb5afb9b61", + "size": 2535507, + "subdir": "linux-64", + "timestamp": 1543488987403, + "version": "0.41.0" + }, + "numba-0.42.0-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.27.0,<0.28.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.1" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "81b59b7f90a090a2e0e443ce21db6435", + "name": "numba", + "sha256": "90727f3f836be0cfff0362475667b584d70adffa94be1e4c2ba0bc1b58bcafd6", + "size": 2511477, + "subdir": "linux-64", + "timestamp": 1546601698419, + "version": "0.42.0" + }, + "numba-0.42.0-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.27.0,<0.28.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.1" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "f58f173dbb11787b5fe070f161432fec", + "name": "numba", + "sha256": "fbc9374d3d41483737fe9cb32475385700f378cdd035074d51f79eb25f3a4303", + "size": 2543683, + "subdir": "linux-64", + "timestamp": 1546601712148, + "version": "0.42.0" + }, + "numba-0.42.0-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.27.0,<0.28.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.1" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "13db45d923da6a107131fc1c8cc284a7", + "name": "numba", + "sha256": "2605a4d768bf7e74dc1e06724b18ddb640e9f58d31af21121ad69495ae97aa95", + "size": 2560754, + "subdir": "linux-64", + "timestamp": 1546601709768, + "version": "0.42.0" + }, + "numba-0.43.0-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.28.0,<0.29.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "80d00a1a4f7dddbac556c91b4875863c", + "name": "numba", + "sha256": "e7de9178b5f19a82295f71be31b96cf8e82997c24be53621364967b1eb160f5a", + "size": 2646535, + "subdir": "linux-64", + "timestamp": 1552591592478, + "version": "0.43.0" + }, + "numba-0.43.0-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.28.0,<0.29.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "ff3f4f2e4c44ca1cfdfc3fbcf6b5cd70", + "name": "numba", + "sha256": "330fce9d29e7953e441ea56e6706ef0094e495c131482e5d8e46ed5a2d546efa", + "size": 2699405, + "subdir": "linux-64", + "timestamp": 1552591593286, + "version": "0.43.0" + }, + "numba-0.43.0-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.28.0,<0.29.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "1f061f93fc6b90e4a7d9cea9b1b0990f", + "name": "numba", + "sha256": "3fc4a7e7d7cd9cc97a925eae4a2df1f633497f837024e7154c06f4cb10b4a0c0", + "size": 2681404, + "subdir": "linux-64", + "timestamp": 1552591515345, + "version": "0.43.0" + }, + "numba-0.43.1-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.28.0,<0.29.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "d4d4384d96a7d2db394ddb69fb23142d", + "name": "numba", + "sha256": "c16b868dab12c0d05231e81be4574ea7339a95716667511c66db3d90ab12532b", + "size": 2650911, + "subdir": "linux-64", + "timestamp": 1553670358844, + "version": "0.43.1" + }, + "numba-0.43.1-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.28.0,<0.29.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "e9e8eb17ff0fcd3987c5de9f039b5d15", + "name": "numba", + "sha256": "cfc75d43f75e212a3ba7b7be8869eaf407fd1857a1793e6ffdab4e470a1c7e8f", + "size": 2689903, + "subdir": "linux-64", + "timestamp": 1553670369679, + "version": "0.43.1" + }, + "numba-0.43.1-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.28.0,<0.29.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "9699970baf29735dd0a3a505b2a33310", + "name": "numba", + "sha256": "d696306e36eecc6cb52052cf20024b91ca77e15dd32b5636161c9bd7c30bd894", + "size": 2687407, + "subdir": "linux-64", + "timestamp": 1553670336724, + "version": "0.43.1" + }, + "numba-0.44.0-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "fde6d0d44430d45a55ee6678d7fc2b7f", + "name": "numba", + "sha256": "651a9a352319bee25c4f8c84aaf02e0ecb5d75faf01e8f3dab8ed548fb13e53b", + "size": 2718857, + "subdir": "linux-64", + "timestamp": 1560886555594, + "version": "0.44.0" + }, + "numba-0.44.0-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "c76396a7304ac180b280ac2ff8ffc882", + "name": "numba", + "sha256": "13133de390bc5cfc503984460aa78fb99b56af13d88e5932495f47fdda64a65e", + "size": 2772309, + "subdir": "linux-64", + "timestamp": 1560886567011, + "version": "0.44.0" + }, + "numba-0.44.0-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "8d6826f01cb20ec0f7e6afa922500775", + "name": "numba", + "sha256": "160d2ed6c077480441e8f4ef60e002513c5c5d784112715411aa0e71d45b3493", + "size": 2770459, + "subdir": "linux-64", + "timestamp": 1560886484112, + "version": "0.44.0" + }, + "numba-0.44.1-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "0148190fa414e9329564c9f7d83f05a4", + "name": "numba", + "sha256": "d8364b81263ff83b5c491d5f8196da9df7f2edb3b7085f7af19fcb81b9e0efc7", + "size": 2720858, + "subdir": "linux-64", + "timestamp": 1560889821566, + "version": "0.44.1" + }, + "numba-0.44.1-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "e1db40009cb68307cefcab646c45ffd8", + "name": "numba", + "sha256": "ce242fe78efbf9982e40b795a2d32c7ff655ed6aada08373abf352e609cdc414", + "size": 2776244, + "subdir": "linux-64", + "timestamp": 1560889853986, + "version": "0.44.1" + }, + "numba-0.44.1-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "e436b04c7d9de3e1a9e848273b2aee8b", + "name": "numba", + "sha256": "9138df24f4e4ed487bcbbe6f186d80adda42cd56a3a85407e935606c70246fe9", + "size": 2774383, + "subdir": "linux-64", + "timestamp": 1560889940592, + "version": "0.44.1" + }, + "numba-0.45.0-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "20b395732c53342a9c641e09b2510a2a", + "name": "numba", + "sha256": "ef829a67332b699862ce57a2eb23f593c1028b3c89fb8a85b2d4dd23c15968dd", + "size": 2860323, + "subdir": "linux-64", + "timestamp": 1563756517229, + "version": "0.45.0" + }, + "numba-0.45.0-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "01f92b67c0916a53998afe405bcc1756", + "name": "numba", + "sha256": "f3e40be57196a217f4e261f47a9aaf1b74b7b62490df3699c51b9c2eb3523bd1", + "size": 2916205, + "subdir": "linux-64", + "timestamp": 1563756508221, + "version": "0.45.0" + }, + "numba-0.45.0-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "a662d37af8ad4c70bed57727b66e5fd1", + "name": "numba", + "sha256": "09419c6f2f6e05fe358e53b10902eb5d064b2c049f332c72d2e3a49c1b97d770", + "size": 2913730, + "subdir": "linux-64", + "timestamp": 1563756553934, + "version": "0.45.0" + }, + "numba-0.45.1-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "fcfa57af6f48e93f765e978cfc8c1496", + "name": "numba", + "sha256": "eb42884685901a6fabed88e8cd48cf4f7748b60e55981611487bfff14ce1e24e", + "size": 2841630, + "subdir": "linux-64", + "timestamp": 1565199227581, + "version": "0.45.1" + }, + "numba-0.45.1-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "91a35f993eb983d4f2780c026e840978", + "name": "numba", + "sha256": "e220ab31fde000ccb56e39d651ce58a9e7714517dfed0cdcccdf5e21937e75a6", + "size": 2920739, + "subdir": "linux-64", + "timestamp": 1565199227300, + "version": "0.45.1" + }, + "numba-0.45.1-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.29.0", + "llvmlite >=0.29.0,<0.30.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.4" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "1fe24345d54f603f860ed7bd06c7bb48", + "name": "numba", + "sha256": "285e03e0cc7b5e75a55362a35461dd1a8a4ad4e3c85e4d64890792bbdd90cc8e", + "size": 2917077, + "subdir": "linux-64", + "timestamp": 1565199223381, + "version": "0.45.1" + }, + "numba-0.46.0-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.30.0", + "llvmlite >=0.30.0,<0.31.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.8", + "setuptools" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "c0727989d5fd505badaccb7bf8176402", + "name": "numba", + "sha256": "376724b4cd1c8dbb54b3942c9786fb197106fcef53eb5d52d105eb7aafc2b939", + "size": 2969421, + "subdir": "linux-64", + "timestamp": 1572011783830, + "version": "0.46.0" + }, + "numba-0.46.0-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.30.0", + "llvmlite >=0.30.0,<0.31.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.8", + "setuptools" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "f551a29b32916b238589082dbc381d57", + "name": "numba", + "sha256": "fbc126a602a3dc0b06679559b184fbf971928eec74666b72d3e32e9f695b66bc", + "size": 3028816, + "subdir": "linux-64", + "timestamp": 1572011883856, + "version": "0.46.0" + }, + "numba-0.46.0-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.30.0", + "llvmlite >=0.30.0,<0.31.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.8", + "setuptools" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "77af70902fe718705e72a0ddbbdbf276", + "name": "numba", + "sha256": "3bd9060fc48279f73761676525ae1119d7a68ff19d6d38dc8f0ad55877f129a8", + "size": 3023177, + "subdir": "linux-64", + "timestamp": 1572011921381, + "version": "0.46.0" + }, + "numba-0.47.0-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "funcsigs", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.31.0", + "llvmlite >=0.31.0,<0.32.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "singledispatch", + "tbb >=2019.8", + "setuptools" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "15016064092116b09836e7fb4db53feb", + "name": "numba", + "sha256": "d11606d38d4933e2fde4e232e945e03d64f7a5f5ec5e57b13ff29266e20341be", + "size": 3104575, + "subdir": "linux-64", + "timestamp": 1579016886641, + "version": "0.47.0" + }, + "numba-0.47.0-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.31.0", + "llvmlite >=0.31.0,<0.32.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.8", + "setuptools" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "4d57ed53faaaed11bc613aa45ed0cd13", + "name": "numba", + "sha256": "116e0a51450756d2d8d106c7390f8214edd33cd595df268d5c94a8212c45afd5", + "size": 3144614, + "subdir": "linux-64", + "timestamp": 1579016865770, + "version": "0.47.0" + }, + "numba-0.47.0-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.31.0", + "llvmlite >=0.31.0,<0.32.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.8", + "setuptools" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "ad56139b0f73747d2c98bc9cbe8a64b2", + "name": "numba", + "sha256": "b5e30925d02fe128417c331e7793b46488ae9445f5651719518f59e4aea562aa", + "size": 3161263, + "subdir": "linux-64", + "timestamp": 1579016803908, + "version": "0.47.0" + }, + "numba-0.47.0-py38h962f231_0.conda": { + "build": "py38h962f231_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.31.0", + "llvmlite >=0.31.0,<0.32.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "tbb >=2019.8", + "setuptools" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "5ca428cb058f34e6211490d906e15db1", + "name": "numba", + "sha256": "f5d72ba9aafe30d7d735fc4a5c428599d27a21aa683c097a84413bf5399460f4", + "size": 3173287, + "subdir": "linux-64", + "timestamp": 1579101408315, + "version": "0.47.0" + }, + "numba-0.48.0-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.31.0", + "llvmlite >=0.31.0,<0.32.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "tbb >=2019.8" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "eedc6e9fc7a2be7da9cb0e5fa55651bd", + "name": "numba", + "sha256": "df706ee8abefccfc75c1fc86eae732f5a8a7493234a882f0c3476053559884c3", + "size": 3156753, + "subdir": "linux-64", + "timestamp": 1580335942146, + "version": "0.48.0" + }, + "numba-0.48.0-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.31.0", + "llvmlite >=0.31.0,<0.32.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2019.8" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "656b972195a69252fbd60273e07545f3", + "name": "numba", + "sha256": "740a28aea515b4c3a8d4be72d9593fc911e2cfa66ba33f380472a2533091c943", + "size": 3177808, + "subdir": "linux-64", + "timestamp": 1580336151465, + "version": "0.48.0" + }, + "numba-0.48.0-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.31.0", + "llvmlite >=0.31.0,<0.32.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2019.8" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "ee3b08206289be7e132c145aea35fa66", + "name": "numba", + "sha256": "dea6077299e1e0b5714b182cbc6c7f62054284be1a642b92699882c69c66abad", + "size": 3185375, + "subdir": "linux-64", + "timestamp": 1580336141684, + "version": "0.48.0" + }, + "numba-0.49.0-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.32.0", + "llvmlite >=0.32.0,<0.33.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "cdbf81e0d643b5e90441ccf110b97a3d", + "name": "numba", + "sha256": "355305dd79ecd5b364a27ea1f3effd44028fb0ff408da4a03c4e9159cb6823b5", + "size": 3235253, + "subdir": "linux-64", + "timestamp": 1587143300452, + "version": "0.49.0" + }, + "numba-0.49.0-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.32.0", + "llvmlite >=0.32.0,<0.33.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "2ac09a2a5a498ae7b0f82973a28cb122", + "name": "numba", + "sha256": "e1c29901256abf8924dee08d1fbf8b05bf192a23bce72100e2f461d5b86e147e", + "size": 3232687, + "subdir": "linux-64", + "timestamp": 1587145361780, + "version": "0.49.0" + }, + "numba-0.49.0-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.32.0", + "llvmlite >=0.32.0,<0.33.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "c3c7403ca0c11da6b76801cf6219f2e4", + "name": "numba", + "sha256": "08873d7d69da22f26868f74f9be3f657256e498af7318227f634f4d8260608de", + "size": 3284720, + "subdir": "linux-64", + "timestamp": 1587143320031, + "version": "0.49.0" + }, + "numba-0.49.1-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.32.1", + "llvmlite >=0.32.1,<0.33.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "a9dc0ee6b35deef35e157b5e41b3d863", + "name": "numba", + "sha256": "6f72d7c85ef046af3885f8aa4fc050785ea369788432165d047f923e6aa1b36a", + "size": 3240594, + "subdir": "linux-64", + "timestamp": 1589294718610, + "version": "0.49.1" + }, + "numba-0.49.1-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.32.1", + "llvmlite >=0.32.1,<0.33.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "1fcbbf2b53637f9e1c27d215d32fee55", + "name": "numba", + "sha256": "62bba3ac32c0d1ebd16b51199794ed79e849c6fb1c0a5cca5490933880134359", + "size": 3255255, + "subdir": "linux-64", + "timestamp": 1589294929656, + "version": "0.49.1" + }, + "numba-0.49.1-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.32.1", + "llvmlite >=0.32.1,<0.33.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "d99eaf20763c1429b96c1d67908fe363", + "name": "numba", + "sha256": "32e77ab8eefca0dab1fd0b5ceffbee465653f4bd0996f62145957ddfa2fb5f02", + "size": 3264606, + "subdir": "linux-64", + "timestamp": 1589294698909, + "version": "0.49.1" + }, + "numba-0.50.1-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.33.0", + "llvmlite >=0.33.0,<0.34.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "04c064ed9af457029094668d4a00dd97", + "name": "numba", + "sha256": "509c70d3ae942b217fd8f067b104625cc02d080e98a54770e7adf1af7f3582ee", + "size": 3292330, + "subdir": "linux-64", + "timestamp": 1593094353128, + "version": "0.50.1" + }, + "numba-0.50.1-py36h0573a6f_1.conda": { + "build": "py36h0573a6f_1", + "build_number": 1, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.33.0 *_1", + "llvmlite >=0.33.0,<0.34.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "b265e1b2c87849801eabd5364bd5e9c3", + "name": "numba", + "sha256": "a2de64bd6d373634a2f54621d2d37c2935efb9d71121b04818b4f0c50fef8746", + "size": 3294032, + "subdir": "linux-64", + "timestamp": 1594578690688, + "version": "0.50.1" + }, + "numba-0.50.1-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.33.0", + "llvmlite >=0.33.0,<0.34.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "d581da682ac419cdfd586aeb98a6167b", + "name": "numba", + "sha256": "f3340049262860fd8f8bd79734adbdfda689d700ec174436af82a8410a825daa", + "size": 3265902, + "subdir": "linux-64", + "timestamp": 1593094392773, + "version": "0.50.1" + }, + "numba-0.50.1-py37h0573a6f_1.conda": { + "build": "py37h0573a6f_1", + "build_number": 1, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.33.0 *_1", + "llvmlite >=0.33.0,<0.34.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "a116195166b361e22f74b902bc3860f3", + "name": "numba", + "sha256": "1560389072397929039212ea70c35d6f7311cd1397925e497be95c48f973224b", + "size": 3290743, + "subdir": "linux-64", + "timestamp": 1594578656536, + "version": "0.50.1" + }, + "numba-0.50.1-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.33.0", + "llvmlite >=0.33.0,<0.34.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "82238741f1a9b8aa44eea21c881ae8d3", + "name": "numba", + "sha256": "10fd3151d34ac30152abda1871e25e08e5249fdffada3ad8cbb188076cf56aa0", + "size": 3299310, + "subdir": "linux-64", + "timestamp": 1593094403922, + "version": "0.50.1" + }, + "numba-0.50.1-py38h0573a6f_1.conda": { + "build": "py38h0573a6f_1", + "build_number": 1, + "constrains": [ + "tbb >=2018.0.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.33.0 *_1", + "llvmlite >=0.33.0,<0.34.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2020.0" + ], + "license": "BSD 2-clause", + "license_family": "BSD", + "md5": "e90bfe983ce38eb257c50c6b5c43637b", + "name": "numba", + "sha256": "425f9e12b4c7dd4a7c34368369f8ecbd8f349329102384a6fad3af4572fd28c0", + "size": 3322951, + "subdir": "linux-64", + "timestamp": 1594577680090, + "version": "0.50.1" + }, + "numba-0.51.2-py36h0573a6f_1.conda": { + "build": "py36h0573a6f_1", + "build_number": 1, + "constrains": [ + "tbb >=2019.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.34.0,<0.35", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "tbb >=2020.2" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8dccfa240719b8797e652738b2464d4a", + "name": "numba", + "sha256": "638ff5806fd0e43d3f109224a5d65c91289d7c4cbd741526ab6de337c7a9bb3b", + "size": 3395049, + "subdir": "linux-64", + "timestamp": 1600094363539, + "version": "0.51.2" + }, + "numba-0.51.2-py37h04863e7_1.conda": { + "build": "py37h04863e7_1", + "build_number": 1, + "constrains": [ + "tbb >=2019.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.34.0,<0.35", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2020.2" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "1cc5787dc972690f6d2cf1d47fb5d489", + "name": "numba", + "sha256": "1e1806c2c84e1025343a566e5a37a9729067c5bb0ae05181a9f2b272fb234abb", + "size": 3392466, + "subdir": "linux-64", + "timestamp": 1600102583223, + "version": "0.51.2" + }, + "numba-0.51.2-py37h0573a6f_1.conda": { + "build": "py37h0573a6f_1", + "build_number": 1, + "constrains": [ + "tbb >=2019.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.34.0,<0.35", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2020.2" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "0ccae6b387794bc75b83a10838ad8290", + "name": "numba", + "sha256": "53db9c27276de4015836b9442ca69821cb64114a5181d403ca2c5ca2427cb8f1", + "size": 3387842, + "subdir": "linux-64", + "timestamp": 1600094310247, + "version": "0.51.2" + }, + "numba-0.51.2-py38h0573a6f_1.conda": { + "build": "py38h0573a6f_1", + "build_number": 1, + "constrains": [ + "tbb >=2019.5" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.34.0,<0.35", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2020.2" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "632b14f9a0891827ea5f2f30f7e03bef", + "name": "numba", + "sha256": "5ea76e8da8a014dab26a204f8a034d16ee4bb689fe3532907c3258c5fa2c70fa", + "size": 3423002, + "subdir": "linux-64", + "timestamp": 1600100745046, + "version": "0.51.2" + }, + "numba-0.52.0-py36ha9443f7_0.conda": { + "build": "py36ha9443f7_0", + "build_number": 0, + "constrains": [ + "scipy >=1.0", + "libopenblas !=0.3.6", + "tbb >=2019.5,<=2020.3", + "cudatoolkit >=9.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.35.0,<0.36.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ea49e3792741ab391e1e923404e910ea", + "name": "numba", + "sha256": "b52ff72d62f70feacb8279c5d87fbe81610ae7be2eb465df96a239e68fafb3cf", + "size": 3375447, + "subdir": "linux-64", + "timestamp": 1614888223231, + "version": "0.52.0" + }, + "numba-0.52.0-py37ha9443f7_0.conda": { + "build": "py37ha9443f7_0", + "build_number": 0, + "constrains": [ + "cudatoolkit >=9.0", + "tbb >=2019.5,<=2020.3", + "libopenblas !=0.3.6", + "scipy >=1.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.35.0,<0.36.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5699e770d31b3c36f11e8b352528a23e", + "name": "numba", + "sha256": "2c9bf9f2a2983a2d30e433efe05bd6bef9533fb0caf0f2acbb3573710b457fba", + "size": 3345794, + "subdir": "linux-64", + "timestamp": 1614889124183, + "version": "0.52.0" + }, + "numba-0.52.0-py38ha9443f7_0.conda": { + "build": "py38ha9443f7_0", + "build_number": 0, + "constrains": [ + "cudatoolkit >=9.0", + "libopenblas !=0.3.6", + "scipy >=1.0", + "tbb >=2019.5,<=2020.3" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.35.0,<0.36.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "2831a018871293de357d03a27a2d7077", + "name": "numba", + "sha256": "baed3ab026fc8cb19aa3819cc17adffaf32f71f2d2d4c86d6e2c717941635cd6", + "size": 3371161, + "subdir": "linux-64", + "timestamp": 1614888233096, + "version": "0.52.0" + }, + "numba-0.53.0-py36ha9443f7_0.conda": { + "build": "py36ha9443f7_0", + "build_number": 0, + "constrains": [ + "scipy >=1.0", + "cudatoolkit >=9.0", + "libopenblas !=0.3.6", + "tbb >=2019.5,<=2020.3" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.36.0,<0.37.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d45d53b6e9af73ff514573894ecaa83e", + "name": "numba", + "sha256": "c41db828997da9ede5bddab5792a31f46e8372301d1d1719f3d651b0fff4ffbc", + "size": 3429948, + "subdir": "linux-64", + "timestamp": 1615887492337, + "version": "0.53.0" + }, + "numba-0.53.0-py37ha9443f7_0.conda": { + "build": "py37ha9443f7_0", + "build_number": 0, + "constrains": [ + "scipy >=1.0", + "libopenblas !=0.3.6", + "tbb >=2019.5,<=2020.3", + "cudatoolkit >=9.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.36.0,<0.37.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "bcf6dfb1448ef2c1f1783f83565871a8", + "name": "numba", + "sha256": "5c087efc2ba6ecdc59b18570afb1d2e4456fa551d2b37800cf400a838bc09faf", + "size": 3451734, + "subdir": "linux-64", + "timestamp": 1615889343026, + "version": "0.53.0" + }, + "numba-0.53.0-py38ha9443f7_0.conda": { + "build": "py38ha9443f7_0", + "build_number": 0, + "constrains": [ + "scipy >=1.0", + "tbb >=2019.5,<=2020.3", + "cudatoolkit >=9.0", + "libopenblas !=0.3.6" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.36.0,<0.37.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "fa4731afacff682a7e7812b16fae8487", + "name": "numba", + "sha256": "313c720aaf0fe3d76a67a610baff5d2a1b586595773fe884eff8902fc7e839d0", + "size": 3453140, + "subdir": "linux-64", + "timestamp": 1615889322474, + "version": "0.53.0" + }, + "numba-0.53.0-py39ha9443f7_0.conda": { + "build": "py39ha9443f7_0", + "build_number": 0, + "constrains": [ + "scipy >=1.0", + "libopenblas !=0.3.6", + "cudatoolkit >=9.0", + "tbb >=2019.5,<=2020.3" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.36.0,<0.37.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ce09e8fb1dc06589c16f2bfe690e8883", + "name": "numba", + "sha256": "9c7aa53990040c16e2013e23a43eae662c5ed762612f206308fb918d8e4738fa", + "size": 3478630, + "subdir": "linux-64", + "timestamp": 1615889351510, + "version": "0.53.0" + }, + "numba-0.53.1-py36ha9443f7_0.conda": { + "build": "py36ha9443f7_0", + "build_number": 0, + "constrains": [ + "libopenblas !=0.3.6", + "cudatoolkit >=9.0", + "tbb >=2019.5,<=2020.3", + "scipy >=1.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.36.0,<0.37.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "cb7607f51ee2090364e859ea6dcb3ad7", + "name": "numba", + "sha256": "c13266a780a31df59f2c053a744100f601c01ff967f6aad3bbdc6558073606a5", + "size": 3435180, + "subdir": "linux-64", + "timestamp": 1616772073859, + "version": "0.53.1" + }, + "numba-0.53.1-py37ha9443f7_0.conda": { + "build": "py37ha9443f7_0", + "build_number": 0, + "constrains": [ + "tbb >=2019.5,<=2020.3", + "scipy >=1.0", + "cudatoolkit >=9.0", + "libopenblas !=0.3.6" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.36.0,<0.37.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "18e24eed52e94e2bc9d5ca659efff126", + "name": "numba", + "sha256": "351b88decd21a4606f5baecaae5275abdb55df225ba4c5655a6e9e1de22500bc", + "size": 3454895, + "subdir": "linux-64", + "timestamp": 1616774351774, + "version": "0.53.1" + }, + "numba-0.53.1-py38ha9443f7_0.conda": { + "build": "py38ha9443f7_0", + "build_number": 0, + "constrains": [ + "tbb >=2019.5,<=2020.3", + "scipy >=1.0", + "cudatoolkit >=9.0", + "libopenblas !=0.3.6" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.36.0,<0.37.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8660e6f10449493daebc4ecd0a744ace", + "name": "numba", + "sha256": "f0ba404a631c8b8ac99df161a6393fbfbf6b7816427520a8b559ca62dd741c7a", + "size": 3479615, + "subdir": "linux-64", + "timestamp": 1616774133826, + "version": "0.53.1" + }, + "numba-0.53.1-py39ha9443f7_0.conda": { + "build": "py39ha9443f7_0", + "build_number": 0, + "constrains": [ + "tbb >=2019.5,<=2020.3", + "scipy >=1.0", + "libopenblas !=0.3.6", + "cudatoolkit >=9.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "llvmlite >=0.36.0,<0.37.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "tbb >=2020.3" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "be4fda700ed48c401f211434f6867bbf", + "name": "numba", + "sha256": "70564095283b457b4653f0f978f9af707cdfc91fa3ab6852b386eff542a7fe95", + "size": 3485636, + "subdir": "linux-64", + "timestamp": 1616774355087, + "version": "0.53.1" + }, + "numba-0.54.1-py37h51133e4_0.conda": { + "build": "py37h51133e4_0", + "build_number": 0, + "constrains": [ + "numpy >=1.17,<1.21.0a0" + ], + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvmlite >=0.37.0,<0.38.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2021.4.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5ee7127ee44b2ca69be845acf16065cd", + "name": "numba", + "sha256": "131fe804fa90012fcad295c7a8b542f0bdc09a9d583cab6a013bfd6ec83696e3", + "size": 3435187, + "subdir": "linux-64", + "timestamp": 1635186008761, + "version": "0.54.1" + }, + "numba-0.54.1-py38h51133e4_0.conda": { + "build": "py38h51133e4_0", + "build_number": 0, + "constrains": [ + "numpy >=1.17,<1.21.0a0" + ], + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvmlite >=0.37.0,<0.38.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2021.4.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5f34c49b6011a2157266b71a393ca668", + "name": "numba", + "sha256": "323f76edb94edbf650e2c9dc095764dadb14eb6611926fba939d04a5b4327fa4", + "size": 3487499, + "subdir": "linux-64", + "timestamp": 1635186012359, + "version": "0.54.1" + }, + "numba-0.54.1-py39h51133e4_0.conda": { + "build": "py39h51133e4_0", + "build_number": 0, + "constrains": [ + "numpy >=1.17,<1.21.0a0" + ], + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvmlite >=0.37.0,<0.38.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "tbb >=2021.4.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "05ccf30483b9e14cde5a668832a7b24c", + "name": "numba", + "sha256": "ff1e9a2be034db55cd683c9de1792abf721014e449c2bb0f1271ac286f6f6d37", + "size": 3489856, + "subdir": "linux-64", + "timestamp": 1635174419479, + "version": "0.54.1" + }, + "numba-0.55.0-py310h00e6091_0.conda": { + "build": "py310h00e6091_0", + "build_number": 0, + "constrains": [ + "numpy >=1.18,<1.22.0a0" + ], + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvmlite >=0.38.0,<0.39.0a0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "177fcb710277e0a41c4475de8d51eab6", + "name": "numba", + "sha256": "a4ac4f157dddcb876349fcba1923cf2e8b83ffa2b6f4d5adfa9923eef452e3cf", + "size": 4173895, + "subdir": "linux-64", + "timestamp": 1642675246485, + "version": "0.55.0" + }, + "numba-0.55.1-py310h00e6091_0.conda": { + "build": "py310h00e6091_0", + "build_number": 0, + "constrains": [ + "cudatoolkit >=9.2", + "scipy >=1.0", + "libopenblas !=0.3.6", + "tbb >=2021.0", + "numpy >=1.18,<1.22" + ], + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvmlite >=0.38.0,<0.39.0a0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ccc181b2648de07dc494a366d85ad784", + "name": "numba", + "sha256": "a2608951211b083de3f9f50ab4100bb18ef0c2adb433f66fc6cd184bd828c24d", + "size": 4205172, + "subdir": "linux-64", + "timestamp": 1648044168716, + "version": "0.55.1" + }, + "numba-0.55.1-py37h51133e4_0.conda": { + "build": "py37h51133e4_0", + "build_number": 0, + "constrains": [ + "cudatoolkit >=9.2", + "scipy >=1.0", + "libopenblas !=0.3.6", + "tbb >=2021.0", + "numpy >=1.18,<1.22" + ], + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvmlite >=0.38.0,<0.39.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e0f80ac760dbc3c31d9621d9dad71362", + "name": "numba", + "sha256": "1917dbda0fb6b85b7a966a125b5edefcfb6cba6c8d85e73adbe5d56c55c56fda", + "size": 3552310, + "subdir": "linux-64", + "timestamp": 1648042278567, + "version": "0.55.1" + }, + "numba-0.55.1-py38h51133e4_0.conda": { + "build": "py38h51133e4_0", + "build_number": 0, + "constrains": [ + "cudatoolkit >=9.2", + "scipy >=1.0", + "libopenblas !=0.3.6", + "tbb >=2021.0", + "numpy >=1.18,<1.22" + ], + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvmlite >=0.38.0,<0.39.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "388150496201de9ae24999f443d6aba2", + "name": "numba", + "sha256": "25bed3f0a5efa935532dbb01bb616ec626689acf038287d934a5a1aadbdacdc8", + "size": 3576669, + "subdir": "linux-64", + "timestamp": 1648040615744, + "version": "0.55.1" + }, + "numba-0.55.1-py39h51133e4_0.conda": { + "build": "py39h51133e4_0", + "build_number": 0, + "constrains": [ + "cudatoolkit >=9.2", + "scipy >=1.0", + "libopenblas !=0.3.6", + "tbb >=2021.0", + "numpy >=1.18,<1.22" + ], + "depends": [ + "_openmp_mutex >=4.5", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvmlite >=0.38.0,<0.39.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "139ed78e8b07cfb670d94e28ff2c0710", + "name": "numba", + "sha256": "2bf0bf82a056dfa0962c7ffd253819971cc4d0d08551a37f9cab4829ec7cd0bb", + "size": 3580395, + "subdir": "linux-64", + "timestamp": 1648045822890, + "version": "0.55.1" + }, + "numba-0.56.3-py310h1128e8f_0.conda": { + "build": "py310h1128e8f_0", + "build_number": 0, + "constrains": [ + "libopenblas !=0.3.6", + "tbb >=2021.0, <2022", + "cuda-python >=11.6", + "scipy >=1.0", + "cudatoolkit >=10.2" + ], + "depends": [ + "_openmp_mutex >=5.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "llvmlite >=0.39.*,<0.40", + "numpy >=1.21,!=1.22.0,!=1.22.1,!=1.22.2,<1.23", + "python >=3.10,<3.11.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "6b3ca62f897d7c3af085b13315ea4fc1", + "name": "numba", + "sha256": "68698ee854a37f7eb5fe166a80a92c6a49d47b962cecc34c9bef24897d004e91", + "size": 3782720, + "subdir": "linux-64", + "timestamp": 1666885262805, + "version": "0.56.3" + }, + "numba-0.56.3-py37h417a72b_0.conda": { + "build": "py37h417a72b_0", + "build_number": 0, + "constrains": [ + "libopenblas !=0.3.6", + "tbb >=2021.0, <2022", + "cuda-python >=11.6", + "scipy >=1.0", + "cudatoolkit >=10.2" + ], + "depends": [ + "_openmp_mutex >=5.1", + "importlib_metadata", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "llvmlite >=0.39.*,<0.40", + "numpy >=1.18,!=1.22.0,!=1.22.1,!=1.22.2,<1.23", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d2116b0f229432737affd4a1581c6908", + "name": "numba", + "sha256": "95e5a0cbf314fcac1891eb9b9d526ff019ddbca5a9645abfd8809f0738579fa6", + "size": 3686191, + "subdir": "linux-64", + "timestamp": 1666882752814, + "version": "0.56.3" + }, + "numba-0.56.3-py38h417a72b_0.conda": { + "build": "py38h417a72b_0", + "build_number": 0, + "constrains": [ + "libopenblas !=0.3.6", + "tbb >=2021.0, <2022", + "cuda-python >=11.6", + "scipy >=1.0", + "cudatoolkit >=10.2" + ], + "depends": [ + "_openmp_mutex >=5.1", + "importlib_metadata", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "llvmlite >=0.39.*,<0.40", + "numpy >=1.18,!=1.22.0,!=1.22.1,!=1.22.2,<1.23", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5d8e02f558f98423a2810dcd28449835", + "name": "numba", + "sha256": "491044d46e3d68eeda62204676586d567030d83e95010e67bcfc72a0ff304e9f", + "size": 3711499, + "subdir": "linux-64", + "timestamp": 1666880537400, + "version": "0.56.3" + }, + "numba-0.56.3-py39h417a72b_0.conda": { + "build": "py39h417a72b_0", + "build_number": 0, + "constrains": [ + "libopenblas !=0.3.6", + "tbb >=2021.0, <2022", + "cuda-python >=11.6", + "scipy >=1.0", + "cudatoolkit >=10.2" + ], + "depends": [ + "_openmp_mutex >=5.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "llvmlite >=0.39.*,<0.40", + "numpy >=1.19,!=1.22.0,!=1.22.1,!=1.22.2,<1.23", + "python >=3.9,<3.10.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "232e6402059e9fa2d6ae0d3dbaeb05fa", + "name": "numba", + "sha256": "31a84d61864a5c5f83607a9e62232030f7044d0cafb527c4d55f7b82c9184fcd", + "size": 3713712, + "subdir": "linux-64", + "timestamp": 1666878316854, + "version": "0.56.3" + }, + "numba-0.56.4-py310h1128e8f_0.conda": { + "build": "py310h1128e8f_0", + "build_number": 0, + "constrains": [ + "libopenblas !=0.3.6", + "cuda-python >=11.6", + "cudatoolkit >=10.2", + "tbb >=2021.0, <2022", + "scipy >=1.0" + ], + "depends": [ + "_openmp_mutex >=5.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "llvmlite >=0.39.*,<0.40", + "numpy >=1.21,!=1.22.0,!=1.22.1,!=1.22.2,<1.24", + "python >=3.10,<3.11.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e3ce51906f90e677897f3f2bd29980c5", + "name": "numba", + "sha256": "6753e8b7af2a8bf33dfd2fe070deb15d5f4726523c5eb76c7967b3059e414c68", + "size": 4298134, + "subdir": "linux-64", + "timestamp": 1670258389389, + "version": "0.56.4" + }, + "numba-0.56.4-py37h417a72b_0.conda": { + "build": "py37h417a72b_0", + "build_number": 0, + "constrains": [ + "libopenblas !=0.3.6", + "cuda-python >=11.6", + "cudatoolkit >=10.2", + "tbb >=2021.0, <2022", + "scipy >=1.0" + ], + "depends": [ + "_openmp_mutex >=5.1", + "importlib_metadata", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "llvmlite >=0.39.*,<0.40", + "numpy >=1.18,!=1.22.0,!=1.22.1,!=1.22.2,<1.24", + "python >=3.7,<3.8.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8e0d67005a496c5baca3db3e95876e73", + "name": "numba", + "sha256": "00459fbdcf8e1e67970bf32d02fc8bf6b253b615c9b39fc4dc39f46e63503020", + "size": 4200389, + "subdir": "linux-64", + "timestamp": 1670260584777, + "version": "0.56.4" + }, + "numba-0.56.4-py38h417a72b_0.conda": { + "build": "py38h417a72b_0", + "build_number": 0, + "constrains": [ + "libopenblas !=0.3.6", + "cuda-python >=11.6", + "cudatoolkit >=10.2", + "tbb >=2021.0, <2022", + "scipy >=1.0" + ], + "depends": [ + "_openmp_mutex >=5.1", + "importlib_metadata", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "llvmlite >=0.39.*,<0.40", + "numpy >=1.18,!=1.22.0,!=1.22.1,!=1.22.2,<1.24", + "python >=3.8,<3.9.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c2bcb188f52436b2a0d935ea78024968", + "name": "numba", + "sha256": "0f7c8f4c684caaa21217995e09c86d42841b4be372cc8ea89b0ae669b8f17b9b", + "size": 4225324, + "subdir": "linux-64", + "timestamp": 1670263041009, + "version": "0.56.4" + }, + "numba-0.56.4-py39h417a72b_0.conda": { + "build": "py39h417a72b_0", + "build_number": 0, + "constrains": [ + "libopenblas !=0.3.6", + "cuda-python >=11.6", + "cudatoolkit >=10.2", + "tbb >=2021.0, <2022", + "scipy >=1.0" + ], + "depends": [ + "_openmp_mutex >=5.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "llvmlite >=0.39.*,<0.40", + "numpy >=1.19,!=1.22.0,!=1.22.1,!=1.22.2,<1.24", + "python >=3.9,<3.10.0a0", + "setuptools", + "tbb >=2021.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d6f78c8a9a2e08c3fcb7dca1735b9445", + "name": "numba", + "sha256": "ddbc7f1f63882c07bc32bd165f6fd76408f6306f09337c7c3b601aebc02371f0", + "size": 4229132, + "subdir": "linux-64", + "timestamp": 1670265250909, + "version": "0.56.4" + }, + "numba-dppy-0.17.4-py37h93b75d6_0.conda": { + "build": "py37h93b75d6_0", + "build_number": 0, + "depends": [ + "dpctl 0.11.*", + "dpnp 0.8.*|0.9.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvm-spirv 11.*", + "numba 0.54.*|0.55.*", + "packaging", + "python >=3.7,<3.8.0a0", + "spirv-tools" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3f7ed360e57be2036fa13057eccb79ed", + "name": "numba-dppy", + "sha256": "27abc7e1ebdc445de319815da409b94d1ce94e3cd8467c91af6f47ca3ac78bf8", + "size": 275452, + "subdir": "linux-64", + "timestamp": 1646240788568, + "version": "0.17.4" + }, + "numba-dppy-0.17.4-py38h93b75d6_0.conda": { + "build": "py38h93b75d6_0", + "build_number": 0, + "depends": [ + "dpctl 0.11.*", + "dpnp 0.8.*|0.9.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvm-spirv 11.*", + "numba 0.54.*|0.55.*", + "packaging", + "python >=3.8,<3.9.0a0", + "spirv-tools" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1db7e3aba3c9563c689ded35b9047155", + "name": "numba-dppy", + "sha256": "0c7e046f23c714a5e4284c9fcfcea9927ff375392c1b8168d694cca835501344", + "size": 277129, + "subdir": "linux-64", + "timestamp": 1646240997889, + "version": "0.17.4" + }, + "numba-dppy-0.17.4-py39h93b75d6_0.conda": { + "build": "py39h93b75d6_0", + "build_number": 0, + "depends": [ + "dpctl 0.11.*", + "dpnp 0.8.*|0.9.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "llvm-spirv 11.*", + "numba 0.54.*|0.55.*", + "packaging", + "python >=3.9,<3.10.0a0", + "spirv-tools" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e5e9bb64ae98e202d96144c2ec75acea", + "name": "numba-dppy", + "sha256": "d84b6e3e9f952aab9e62e0e4148d226d3579189bf7b65102d90d3b2e28817437", + "size": 276740, + "subdir": "linux-64", + "timestamp": 1646240897251, + "version": "0.17.4" + }, + "numcodecs-0.10.2-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "entrypoints", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.10,<3.11.0a0", + "typing-extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c04f84ee4dd6473e7a40766b4a6418a", + "name": "numcodecs", + "sha256": "21136b2f179594b5ba868c66c45fd8109ebb33c43893a8cbef147bcbefa1b3c0", + "size": 744148, + "subdir": "linux-64", + "timestamp": 1669115997066, + "version": "0.10.2" + }, + "numcodecs-0.10.2-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "entrypoints", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0af96c7c36321d2f3381f0a2492106ac", + "name": "numcodecs", + "sha256": "2c5b30b8395874b816a9ee5aad360862cdca7281c8caa1ea30de25fd54c94dac", + "size": 731163, + "subdir": "linux-64", + "timestamp": 1669116107658, + "version": "0.10.2" + }, + "numcodecs-0.10.2-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "entrypoints", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3759e743fec13f2053da7088d9e76a9f", + "name": "numcodecs", + "sha256": "a9eaf2bb622babddc543b6db749ca33916dcf65def860e3d5b8efa12a6a3746c", + "size": 744641, + "subdir": "linux-64", + "timestamp": 1669116322382, + "version": "0.10.2" + }, + "numcodecs-0.10.2-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "entrypoints", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.7.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ecf09971ce910fede4763ed2d604cbc", + "name": "numcodecs", + "sha256": "dc3041d8d50e063809963b7875cb3f7ef812f06449a06f6111c4013a3d680090", + "size": 740148, + "subdir": "linux-64", + "timestamp": 1669116217121, + "version": "0.10.2" + }, + "numcodecs-0.11.0-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "entrypoints", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df0a4737e14e866078f7225ea533e091", + "name": "numcodecs", + "sha256": "9477be5ab84a235369fbf914c57b1580093c6867f63dc7a11dbc988cfd0ff5d6", + "size": 738159, + "subdir": "linux-64", + "timestamp": 1674851683153, + "version": "0.11.0" + }, + "numcodecs-0.11.0-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "entrypoints", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ddb236745ec9024f663a5a2ccd056c16", + "name": "numcodecs", + "sha256": "83143aeabbc05b148af2eb2a39056e2883ae3eff41fb48c78958587ad545419e", + "size": 690871, + "subdir": "linux-64", + "timestamp": 1676841365393, + "version": "0.11.0" + }, + "numcodecs-0.11.0-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "entrypoints", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "75530ccb76e3c3e286382a60d9cbfc75", + "name": "numcodecs", + "sha256": "c26970012a9372b08cbd8dfcc86cbe5988111321324e8e208cd703baa23329e5", + "size": 743097, + "subdir": "linux-64", + "timestamp": 1674851576942, + "version": "0.11.0" + }, + "numcodecs-0.11.0-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "entrypoints", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1a3e10624a63d699272e2f6c5b66c77", + "name": "numcodecs", + "sha256": "9b8e7b3868557353f7745a594902d629fbb62e36324e8068b7d9a1b3ef1b686a", + "size": 739670, + "subdir": "linux-64", + "timestamp": 1674851470620, + "version": "0.11.0" + }, + "numcodecs-0.5.4-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "backports.lzma", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c231590b14cd7a36847521d4f5cf9213", + "name": "numcodecs", + "sha256": "2e00e0292981f258875cac9934f5bcc092e8d21d5afea883fe4815f9ae20f2d8", + "size": 539790, + "subdir": "linux-64", + "timestamp": 1549908522580, + "version": "0.5.4" + }, + "numcodecs-0.5.4-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e6161f79ca3af20a801cf555b69692de", + "name": "numcodecs", + "sha256": "d537686e0bd20e9fae6209e3cddf6e3898cf17462597b2a9cd0f38f8da9c2b3c", + "size": 549608, + "subdir": "linux-64", + "timestamp": 1549908614445, + "version": "0.5.4" + }, + "numcodecs-0.5.4-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "64aaecc7b9f99ecffbbd0349b56eea6a", + "name": "numcodecs", + "sha256": "4a9c4471287578c2de120e06ff9752f6c849136469d2612f4c8152f1599b7acd", + "size": 548545, + "subdir": "linux-64", + "timestamp": 1549908472673, + "version": "0.5.4" + }, + "numcodecs-0.6.2-py27he6710b0_1001.conda": { + "build": "py27he6710b0_1001", + "build_number": 1001, + "depends": [ + "backports.lzma", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "0fec8f84dc7b583b5bbace25f647f55e", + "name": "numcodecs", + "sha256": "69a5a1cec2de403a1ed9b690c5310918fe165dcc37e861ad848360f9b16771c4", + "size": 613861, + "subdir": "linux-64", + "timestamp": 1548715450184, + "version": "0.6.2" + }, + "numcodecs-0.6.2-py36he6710b0_1001.conda": { + "build": "py36he6710b0_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "77c3c4db4b7aac305e0ab2e28350db23", + "name": "numcodecs", + "sha256": "6759b1fb8e81446cf5d3b41fb80082b7894e34893545b1df2bface604ee57295", + "size": 626014, + "subdir": "linux-64", + "timestamp": 1548715512727, + "version": "0.6.2" + }, + "numcodecs-0.6.2-py37he6710b0_1001.conda": { + "build": "py37he6710b0_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "204fa46308962f51487cbdba01ebb939", + "name": "numcodecs", + "sha256": "152037f202995539eb8729fc37895d73f831ec9d5b92498a98a56cfe5ce50fac", + "size": 624478, + "subdir": "linux-64", + "timestamp": 1548715525049, + "version": "0.6.2" + }, + "numcodecs-0.6.3-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "backports.lzma", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "2bd3cedb8548bb260d35328c929be910", + "name": "numcodecs", + "sha256": "6a9eb25d423e4a533063e3b142fabf5205152cbc37daa77c26f9798da0ec1233", + "size": 614376, + "subdir": "linux-64", + "timestamp": 1548973295487, + "version": "0.6.3" + }, + "numcodecs-0.6.3-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e0b89ce6d06d3c0cfbea1236bac37e20", + "name": "numcodecs", + "sha256": "70e61b80d35b10645c77cc07e8170c6507b548b3a0df46da7171ac9b6a40eb28", + "size": 626634, + "subdir": "linux-64", + "timestamp": 1548973232998, + "version": "0.6.3" + }, + "numcodecs-0.6.3-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d31657a4a4d751168eb5556c06014cad", + "name": "numcodecs", + "sha256": "248a02181b37193700f86cbb910e9c1468be237f6f73f44b92908a71dfb87548", + "size": 625665, + "subdir": "linux-64", + "timestamp": 1548973223293, + "version": "0.6.3" + }, + "numcodecs-0.6.3-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "6b5649c5510ae304b6938a4d964411d9", + "name": "numcodecs", + "sha256": "63134df8003a6016be327f9b4548460bb362a2f8d7566900239353eb73dd90ae", + "size": 630998, + "subdir": "linux-64", + "timestamp": 1574092625500, + "version": "0.6.3" + }, + "numcodecs-0.6.4-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "backports.lzma", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "137a2422316a32ecb618bad9b25a7c3c", + "name": "numcodecs", + "sha256": "9a22967cf33caeeb487d51985e1c44156259126ebf3370211c2caa582b2a6422", + "size": 632669, + "subdir": "linux-64", + "timestamp": 1573969828975, + "version": "0.6.4" + }, + "numcodecs-0.6.4-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "39f6c2bb6f8eddacb2bbea13e5d4b746", + "name": "numcodecs", + "sha256": "69f7d4e01059d003793a954d0472300852d59037b3653d573434ac3b63e1eaea", + "size": 644105, + "subdir": "linux-64", + "timestamp": 1573969888309, + "version": "0.6.4" + }, + "numcodecs-0.6.4-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "51600fdd38fe2d29773f24e9a56e1a71", + "name": "numcodecs", + "sha256": "18f46c06dcd2439241e5c15bbc4783ed3a426720ccfd3a876e6227731bab7e1e", + "size": 643205, + "subdir": "linux-64", + "timestamp": 1573969887800, + "version": "0.6.4" + }, + "numcodecs-0.6.4-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "7fc816c38da589bbbbcbfec01e27ee07", + "name": "numcodecs", + "sha256": "28b36a76ad318382051644c04d4792705ebef612bf0df17150c30ceac1d69360", + "size": 652543, + "subdir": "linux-64", + "timestamp": 1573969853067, + "version": "0.6.4" + }, + "numcodecs-0.7.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "877dfc7b29a67c94b28864b74fdb03ab", + "name": "numcodecs", + "sha256": "f46ecd37e4115e1f5d580406fefe120f5bd7ab56309025eb2cac755ed24ec03d", + "size": 650334, + "subdir": "linux-64", + "timestamp": 1600140385332, + "version": "0.7.1" + }, + "numcodecs-0.7.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4cd9fe136d4a03fac64e99613a07e5f3", + "name": "numcodecs", + "sha256": "45273f2a512a97040f204b31ea0b489ac7350c184159bc15fffe118a7c804f4c", + "size": 650821, + "subdir": "linux-64", + "timestamp": 1600140374182, + "version": "0.7.1" + }, + "numcodecs-0.7.1-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "3342589295522a3746044f3c3df97ad4", + "name": "numcodecs", + "sha256": "a4506481766fa7cfa42d1b29a522a56062c5b0e5e82e4de863a4ca81ac10340f", + "size": 661073, + "subdir": "linux-64", + "timestamp": 1600140372562, + "version": "0.7.1" + }, + "numcodecs-0.7.2-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "44ac14235ce8dacfec1ddf5ee415cbed", + "name": "numcodecs", + "sha256": "862cff2b2034f2e88c686dec396999f8a4569c851d4ea188b301b8e70a912cb8", + "size": 632177, + "subdir": "linux-64", + "timestamp": 1601500159695, + "version": "0.7.2" + }, + "numcodecs-0.7.2-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e96dce667fa8a47447b7848b9c2ed73d", + "name": "numcodecs", + "sha256": "2d46b200613f5d2561072e978c3e19fe2500a68a37860139c5257543597c03a6", + "size": 632413, + "subdir": "linux-64", + "timestamp": 1601500170441, + "version": "0.7.2" + }, + "numcodecs-0.7.2-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "9bee81d24170c52addeb7eb4af585572", + "name": "numcodecs", + "sha256": "d66e58aa8cba378d3f1ee791286ba8b45fe177bb8a91d422b974bbe4ad732c85", + "size": 641730, + "subdir": "linux-64", + "timestamp": 1601500133629, + "version": "0.7.2" + }, + "numcodecs-0.7.3-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "d09a19aa2af2a6640d98ca06cc2c675e", + "name": "numcodecs", + "sha256": "0c27dc2cef712c9cd95c563862025aa5d8dd2c9288f56e5517f259c071f0bf67", + "size": 2964155, + "subdir": "linux-64", + "timestamp": 1640809791525, + "version": "0.7.3" + }, + "numcodecs-0.7.3-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4a7e46d5fdac400fd02d626e7d7c07aa", + "name": "numcodecs", + "sha256": "113f9fba97b8c531da2ca08297cad6660f7325cfd066b8007f7216560d38abda", + "size": 633503, + "subdir": "linux-64", + "timestamp": 1611692474240, + "version": "0.7.3" + }, + "numcodecs-0.7.3-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f184eed708f46acf86f1d3b831098ee7", + "name": "numcodecs", + "sha256": "f7e4706030b3cffde4f3df905854b9642c610c344e6854a696ddbcbeb4a433a3", + "size": 634671, + "subdir": "linux-64", + "timestamp": 1611693159912, + "version": "0.7.3" + }, + "numcodecs-0.7.3-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "82c73e579c05bd243bd2acdfaae8a611", + "name": "numcodecs", + "sha256": "38963717d6bf7386c4d1ece48f010f18b340a229fc6e5f7b9f141d823f110270", + "size": 643024, + "subdir": "linux-64", + "timestamp": 1611693157991, + "version": "0.7.3" + }, + "numcodecs-0.7.3-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "be69520e9414cd013e917055801306e5", + "name": "numcodecs", + "sha256": "401d81a4be0bbf5948a89c618b044e46f126e9f85277e30a6c27d3b865ed85b7", + "size": 640616, + "subdir": "linux-64", + "timestamp": 1611693133810, + "version": "0.7.3" + }, + "numcodecs-0.8.0-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "aa68a451c07a4795a22a6982022c0f2c", + "name": "numcodecs", + "sha256": "0221214d77dc3032b0f92021af2c226c5e59b05380af1a5cc6696ec8f251fb05", + "size": 665435, + "subdir": "linux-64", + "timestamp": 1623875448708, + "version": "0.8.0" + }, + "numcodecs-0.8.0-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ac161b0309e0e04845e13569c0e7b4f2", + "name": "numcodecs", + "sha256": "496e5517539ba352060c4ab858f89e0d1de5b513f0e086d54b04e52fed63e1bc", + "size": 664756, + "subdir": "linux-64", + "timestamp": 1623875455723, + "version": "0.8.0" + }, + "numcodecs-0.8.0-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "1f60b0f58011d77643f2fafb9c764d1c", + "name": "numcodecs", + "sha256": "11fa931b7e98534cf2d6bb1845e27128c54c0ad3f2d5d85c8c2d76dc9d7d8dc8", + "size": 674902, + "subdir": "linux-64", + "timestamp": 1623875164882, + "version": "0.8.0" + }, + "numcodecs-0.8.0-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "956c2b69265a6dd63adc6dc062f3dd7b", + "name": "numcodecs", + "sha256": "5b321182584058c4f6feedde24085592af3cc3ffbf55c4f0f82af7303e6e2dd5", + "size": 673644, + "subdir": "linux-64", + "timestamp": 1623929453927, + "version": "0.8.0" + }, + "numcodecs-0.9.1-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66447f14baa4e5fe0ae3a5272f28702d", + "name": "numcodecs", + "sha256": "2fc0bf45837f6342895ced66cc1b3dea9bcf59e40e9ff5e50fc1f2dde7464122", + "size": 667800, + "subdir": "linux-64", + "timestamp": 1640877899869, + "version": "0.9.1" + }, + "numcodecs-0.9.1-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "027046a5c38f495bcc1c2b273cb30405", + "name": "numcodecs", + "sha256": "fea68e547c553764ea802782e34a664386b4d752fce64e46597c7043b02cda41", + "size": 678146, + "subdir": "linux-64", + "timestamp": 1640878116420, + "version": "0.9.1" + }, + "numcodecs-0.9.1-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python", + "numpy >=1.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "942c6f3bd2fc947e835fda549cb93a85", + "name": "numcodecs", + "sha256": "0ba5f68a923fac22fb70c7bd7935fa0e9b2495bef18daf9cfdfe8c9cce0cc8a9", + "size": 679841, + "subdir": "linux-64", + "timestamp": 1640878015151, + "version": "0.9.1" + }, + "numexpr-2.6.2-py27_nomklhd298b71_1.conda": { + "build": "py27_nomklhd298b71_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "MIT", + "md5": "3c486ded211fb2ae08075013bd48928f", + "name": "numexpr", + "sha256": "4cc196ce586a228621aabb6be29c891fe131a5b6eb5f39fda09f65e6c7ae61ba", + "size": 173784, + "subdir": "linux-64", + "timestamp": 1509732259384, + "version": "2.6.2" + }, + "numexpr-2.6.2-py27h9521900_2.conda": { + "build": "py27h9521900_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "f8de4adec8de4033fa3682d247d3123f", + "name": "numexpr", + "sha256": "1cfdc2fabf3e6dfeb8f5f7b309d14caa645c8c9e1bcf997fcc4fc118a525a290", + "size": 173129, + "subdir": "linux-64", + "timestamp": 1510243903284, + "version": "2.6.2" + }, + "numexpr-2.6.2-py27he5efce1_1.conda": { + "build": "py27he5efce1_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "bdaa4103301719c6f8f0546ce8898769", + "name": "numexpr", + "sha256": "0d666e1cb91333c2c20e92541b20e63d05039a26510de853adc77d63f76256c3", + "size": 172075, + "subdir": "linux-64", + "timestamp": 1505729208538, + "version": "2.6.2" + }, + "numexpr-2.6.2-py35_nomklhc474e42_1.conda": { + "build": "py35_nomklhc474e42_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "MIT", + "md5": "cca3acd8454d6fe343239f46f66049cf", + "name": "numexpr", + "sha256": "818f1989a4f31259996e3a913267a9649cd4d83e7c5532ce07cc7d70fca9bacb", + "size": 174282, + "subdir": "linux-64", + "timestamp": 1509732572985, + "version": "2.6.2" + }, + "numexpr-2.6.2-py35h5f89caa_1.conda": { + "build": "py35h5f89caa_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "f63c45cba0c11d9b7ad96562961dffbc", + "name": "numexpr", + "sha256": "9e699652d1be22df338c55dfa52866f5957944340ed842222f9a57e048109f4a", + "size": 174610, + "subdir": "linux-64", + "timestamp": 1505729245198, + "version": "2.6.2" + }, + "numexpr-2.6.2-py35hf56bd38_2.conda": { + "build": "py35hf56bd38_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "6c4798149ff3d31f8dc1c406b9618252", + "name": "numexpr", + "sha256": "9158e6c336f07112b450be9bdc683030cae236f5564a1c33d1e3c08bb8440e7d", + "size": 175737, + "subdir": "linux-64", + "timestamp": 1510243938794, + "version": "2.6.2" + }, + "numexpr-2.6.2-py36_nomklhd302951_1.conda": { + "build": "py36_nomklhd302951_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "MIT", + "md5": "b295962aa23d4694769f9b50250d2331", + "name": "numexpr", + "sha256": "335efc2570d5c885b0e9d9ae3c24bf02fa2f6a9a835f466d6e0a8660b9c7d43a", + "size": 173904, + "subdir": "linux-64", + "timestamp": 1509732583795, + "version": "2.6.2" + }, + "numexpr-2.6.2-py36hc561933_2.conda": { + "build": "py36hc561933_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "5905c328fb9a3d201c1bd5299030ed22", + "name": "numexpr", + "sha256": "bbd44395c227ee634ffd1607fd814b283fdca1ef51a5b37a3c955ed56a0a5225", + "size": 174408, + "subdir": "linux-64", + "timestamp": 1510243793818, + "version": "2.6.2" + }, + "numexpr-2.6.2-py36hdd3393f_1.conda": { + "build": "py36hdd3393f_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "186ad683dfe203c582f0e47cf4b3c605", + "name": "numexpr", + "sha256": "a44d9bc0457d1066e93821036be85b903be97fb39a27d39ccdcf6ac230fa06d6", + "size": 172694, + "subdir": "linux-64", + "timestamp": 1505729282190, + "version": "2.6.2" + }, + "numexpr-2.6.4-py27_nomklh19cb0ea_0.conda": { + "build": "py27_nomklh19cb0ea_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "MIT", + "md5": "a3650f82e497a26d8efe656334fce146", + "name": "numexpr", + "sha256": "66c3e126e98cc1f8a47fc4c6d25319731cdd1bfdc083396634b6a21a76b90cc8", + "size": 174237, + "subdir": "linux-64", + "timestamp": 1512072425919, + "version": "2.6.4" + }, + "numexpr-2.6.4-py27hd318778_0.conda": { + "build": "py27hd318778_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.1,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "c3271a9da36ee0d55fa6456037c1a637", + "name": "numexpr", + "sha256": "780e5eb9c64c7cd5abc0a0fa687b6c796805c0cc481dea948b664eef4a891436", + "size": 174242, + "subdir": "linux-64", + "timestamp": 1512070836514, + "version": "2.6.4" + }, + "numexpr-2.6.4-py35_nomklh55d25e0_0.conda": { + "build": "py35_nomklh55d25e0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "MIT", + "md5": "41e7c455f1068eedfc742f03a9b6c8c0", + "name": "numexpr", + "sha256": "1b516db383487e7f6ff8702d1f7fcaed78347d061d81026e848657c53f4a7854", + "size": 175783, + "subdir": "linux-64", + "timestamp": 1512072640677, + "version": "2.6.4" + }, + "numexpr-2.6.4-py35h119f745_0.conda": { + "build": "py35h119f745_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.1,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "f2fdec7b3cddb10b8c541423f318774f", + "name": "numexpr", + "sha256": "17e0a608d3c6b50b8a07a49d03f63bb921355f5667be47061046ce81db5c0f39", + "size": 176360, + "subdir": "linux-64", + "timestamp": 1512070836353, + "version": "2.6.4" + }, + "numexpr-2.6.4-py36_nomklh2c28f9d_0.conda": { + "build": "py36_nomklh2c28f9d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "MIT", + "md5": "863e1d8ece169f17242b35d9aa1b0d38", + "name": "numexpr", + "sha256": "2571b098690335916b7a7333a3ba8f6c2c5b0996fc2c60c4468361f914c7e0f2", + "size": 174440, + "subdir": "linux-64", + "timestamp": 1512072676863, + "version": "2.6.4" + }, + "numexpr-2.6.4-py36hc4a3f9a_0.conda": { + "build": "py36hc4a3f9a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.1,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "19864f6e65e6eb6160ae5b26b390ae81", + "name": "numexpr", + "sha256": "62ddfe23a7b7aa3d399d69d264f5c676631587365edde84026356cdf7b945435", + "size": 175260, + "subdir": "linux-64", + "timestamp": 1512070443051, + "version": "2.6.4" + }, + "numexpr-2.6.5-py27_nomklhaa809a4_0.conda": { + "build": "py27_nomklhaa809a4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "MIT", + "md5": "977cb9b06130d255d960bb97f1bfe722", + "name": "numexpr", + "sha256": "c9e6185bc481aceed0e67813e2d43deff4638846360c38d04f9cb1a321077ac9", + "size": 182394, + "subdir": "linux-64", + "timestamp": 1525808998240, + "version": "2.6.5" + }, + "numexpr-2.6.5-py27h6cfcb94_0.conda": { + "build": "py27h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "4ceb95f9005f63838da39ff0844892fd", + "name": "numexpr", + "sha256": "c77d8e12f58b2afdbc851455b93b256b2da7ecd48b48341251eb4e6c17939548", + "size": 179414, + "subdir": "linux-64", + "timestamp": 1530739186995, + "version": "2.6.5" + }, + "numexpr-2.6.5-py27h7bf3b9c_0.conda": { + "build": "py27h7bf3b9c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "67d703b3095b68ec4ef70b822a1150a7", + "name": "numexpr", + "sha256": "a837bf235458b4502e8f4129c5cb55b34e7b847afea9e6b684049ac150d2533e", + "size": 181231, + "subdir": "linux-64", + "timestamp": 1525809640004, + "version": "2.6.5" + }, + "numexpr-2.6.5-py27hedc7406_0.conda": { + "build": "py27hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b9390eae7306dc7442ba6abef1977a27", + "name": "numexpr", + "sha256": "ebed2a9197728d64c11fb1628dee6d66e98c1b10ded7b7eecbd666a59b8542c6", + "size": 179070, + "subdir": "linux-64", + "timestamp": 1530739231919, + "version": "2.6.5" + }, + "numexpr-2.6.5-py35_nomklhaa809a4_0.conda": { + "build": "py35_nomklhaa809a4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "MIT", + "md5": "860d55fd71077df45e587f4bdf1d8e72", + "name": "numexpr", + "sha256": "8872638fd3f99212ad79fdebc5101f72b596eaac3fc9b3ec1015f9312c112bef", + "size": 182821, + "subdir": "linux-64", + "timestamp": 1525808982903, + "version": "2.6.5" + }, + "numexpr-2.6.5-py35h7bf3b9c_0.conda": { + "build": "py35h7bf3b9c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "5727050c8911101e08a451bba66da32e", + "name": "numexpr", + "sha256": "58fb4ba5c74c3ef79131fe551c4a45420869cf874638d1ec261111e4631afa5b", + "size": 183405, + "subdir": "linux-64", + "timestamp": 1525809679048, + "version": "2.6.5" + }, + "numexpr-2.6.5-py36_nomklhaa809a4_0.conda": { + "build": "py36_nomklhaa809a4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "MIT", + "md5": "fa7f8099af241bf6415156b2c3753d27", + "name": "numexpr", + "sha256": "a9c6d7a6db543c0b47f5a2babb9cd29fe8fbd94d65427e917648dd6d6a2034cc", + "size": 182159, + "subdir": "linux-64", + "timestamp": 1525808993075, + "version": "2.6.5" + }, + "numexpr-2.6.5-py36h6cfcb94_0.conda": { + "build": "py36h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "549b0ed0ef43e9d0f78b8968e5a3a0a6", + "name": "numexpr", + "sha256": "1780ef06ce301036da8cea77aa25369796a8dc075df10f0b75403298c8dadd7a", + "size": 180476, + "subdir": "linux-64", + "timestamp": 1530739081603, + "version": "2.6.5" + }, + "numexpr-2.6.5-py36h7bf3b9c_0.conda": { + "build": "py36h7bf3b9c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "MIT", + "md5": "6eb687882d91ccd99550b7587b249cfe", + "name": "numexpr", + "sha256": "b147aaf4ca5e0ec50460ca249396184bd36046733b996fcb381febd8e5172731", + "size": 181871, + "subdir": "linux-64", + "timestamp": 1525809680278, + "version": "2.6.5" + }, + "numexpr-2.6.5-py36hedc7406_0.conda": { + "build": "py36hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e8ff8d0fa9eefb97482278b79e3bef8f", + "name": "numexpr", + "sha256": "218a8969b17b8a7c8ac6d3f8d386a66a076e6d58ad5098610449776900c16b36", + "size": 180207, + "subdir": "linux-64", + "timestamp": 1530739142580, + "version": "2.6.5" + }, + "numexpr-2.6.5-py37h6cfcb94_0.conda": { + "build": "py37h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "0a60683d2f73d6d9d00e84858d0354c9", + "name": "numexpr", + "sha256": "dc93a3a6884d0e232d446761bf52f7c44bb6bef85ba91ee8e3e2ca13cff7aabe", + "size": 179993, + "subdir": "linux-64", + "timestamp": 1530739277577, + "version": "2.6.5" + }, + "numexpr-2.6.5-py37hedc7406_0.conda": { + "build": "py37hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "97d11421eb18a3361b7ce71463c2143c", + "name": "numexpr", + "sha256": "a2039d07d745b7e26485b918d0f392094138bf0e62d84a9780f17e25e845aab4", + "size": 180148, + "subdir": "linux-64", + "timestamp": 1530739323869, + "version": "2.6.5" + }, + "numexpr-2.6.6-py27h00253c6_0.conda": { + "build": "py27h00253c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d2e959fcbc39edaf017686d0a7ed7619", + "name": "numexpr", + "sha256": "b6ad098a0e4ea2f5ecae094950d025e796f90d43cb7b41442085129af7cff666", + "size": 180964, + "subdir": "linux-64", + "timestamp": 1533747298252, + "version": "2.6.6" + }, + "numexpr-2.6.6-py27h98f89e9_0.conda": { + "build": "py27h98f89e9_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "3f2ecbf42f0db7f46fb77fbf10fb7f68", + "name": "numexpr", + "sha256": "0c455d6d7959c08131629b356ed1f5e2e3090d10c0c1dd6403471e4790a54372", + "size": 181440, + "subdir": "linux-64", + "timestamp": 1533746689291, + "version": "2.6.6" + }, + "numexpr-2.6.6-py35h00253c6_0.conda": { + "build": "py35h00253c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "0921cb63f560d433b122d91dfd61b635", + "name": "numexpr", + "sha256": "0d69c0708b8f3a091ba0823705fe55c0399b798189dc1eb2edd20cde68dc949d", + "size": 183856, + "subdir": "linux-64", + "timestamp": 1533747372404, + "version": "2.6.6" + }, + "numexpr-2.6.6-py35h98f89e9_0.conda": { + "build": "py35h98f89e9_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "5518d9e02684031478254539219a0abe", + "name": "numexpr", + "sha256": "07c8f882795488961a276a68253ff08355c97c96d6c2bd54a6f2586ef099d596", + "size": 183326, + "subdir": "linux-64", + "timestamp": 1533746789160, + "version": "2.6.6" + }, + "numexpr-2.6.6-py36h00253c6_0.conda": { + "build": "py36h00253c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a66cc66b2078925b12596e8b568d0547", + "name": "numexpr", + "sha256": "4d0da3df472920cb4f9b3e4accd23ec925466a6a316a57faa37eb5315029e860", + "size": 181587, + "subdir": "linux-64", + "timestamp": 1533747091265, + "version": "2.6.6" + }, + "numexpr-2.6.6-py36h98f89e9_0.conda": { + "build": "py36h98f89e9_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6b220aa5e943d921bcda869b8798b48c", + "name": "numexpr", + "sha256": "eecf0ad63844ccd793fd91f0023b7b67cf85877323fc34ab65bc0e934ad811d7", + "size": 182185, + "subdir": "linux-64", + "timestamp": 1533746689464, + "version": "2.6.6" + }, + "numexpr-2.6.6-py37h00253c6_0.conda": { + "build": "py37h00253c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "df7587d0d7d2056a8c847ff96cfc0980", + "name": "numexpr", + "sha256": "ff27c20165792584aa4bd1bba34f750715ecf4ba60b23c2578c44579c8d73785", + "size": 182213, + "subdir": "linux-64", + "timestamp": 1533747390192, + "version": "2.6.6" + }, + "numexpr-2.6.6-py37h98f89e9_0.conda": { + "build": "py37h98f89e9_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a669721e176cab95151c2d3448ed9be9", + "name": "numexpr", + "sha256": "e2f147f60aea7f713340fa61fbbace5ebe37d013557b024075f54239980b9a5d", + "size": 182500, + "subdir": "linux-64", + "timestamp": 1533746714069, + "version": "2.6.6" + }, + "numexpr-2.6.7-py27h00253c6_0.conda": { + "build": "py27h00253c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b4f8580aad4ba3520b3c17407d69b973", + "name": "numexpr", + "sha256": "fc71c700e0f8516224c852d0426f38c956b26c0a9d1b9ac42eff37c366ff2e84", + "size": 182253, + "subdir": "linux-64", + "timestamp": 1534175579324, + "version": "2.6.7" + }, + "numexpr-2.6.7-py27h6cfcb94_0.conda": { + "build": "py27h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b0f93448a3194edaa5e01b0b809e4511", + "name": "numexpr", + "sha256": "cf8be2972270811584b213a19c410f11881cd700c2af7c89dbeee66adff9aab4", + "size": 182470, + "subdir": "linux-64", + "timestamp": 1534355527453, + "version": "2.6.7" + }, + "numexpr-2.6.7-py27h98f89e9_0.conda": { + "build": "py27h98f89e9_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "77824927e0ed3eabec4d8e58c809c7dd", + "name": "numexpr", + "sha256": "7f1bded8399e65ff5cdcb9811729d10a19a434be635d967fa3262d22993215a0", + "size": 182879, + "subdir": "linux-64", + "timestamp": 1534174219578, + "version": "2.6.7" + }, + "numexpr-2.6.7-py27hbd46f51_0.conda": { + "build": "py27hbd46f51_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "28f75c763072e8535fbc2cb1506b31c2", + "name": "numexpr", + "sha256": "1a97acfe3c39a2854c261f58f813301b26342aab199be5bca60c7a7ce7fde45c", + "size": 182408, + "subdir": "linux-64", + "timestamp": 1534781214540, + "version": "2.6.7" + }, + "numexpr-2.6.7-py27hedc7406_0.conda": { + "build": "py27hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "125e399a191b006ed62b4130b4c0d7d5", + "name": "numexpr", + "sha256": "79d955aa4ca3219015bae32fa688eb89e6bd181f7a778eaa3c1381c22dbd73a1", + "size": 182372, + "subdir": "linux-64", + "timestamp": 1534355584321, + "version": "2.6.7" + }, + "numexpr-2.6.7-py35h00253c6_0.conda": { + "build": "py35h00253c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "4907bea140ec57bbc77eaf4ed1d322a5", + "name": "numexpr", + "sha256": "fd4ef94ce2d07ff08a536154748ae4428361fee295950a543de0297196714ec6", + "size": 182766, + "subdir": "linux-64", + "timestamp": 1534175055795, + "version": "2.6.7" + }, + "numexpr-2.6.7-py35h6cfcb94_0.conda": { + "build": "py35h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "53a0e45dc679985144f320677d223e58", + "name": "numexpr", + "sha256": "f8717eb6182660008216007560d1e87d7f1052667d9a0256b1bd07a43adaaba7", + "size": 184398, + "subdir": "linux-64", + "timestamp": 1534355639955, + "version": "2.6.7" + }, + "numexpr-2.6.7-py35h98f89e9_0.conda": { + "build": "py35h98f89e9_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "a58d1cfc3a9c837935006c1121959751", + "name": "numexpr", + "sha256": "93a4a311fdcaf07303d6fc52a4c60a6393fa9514729115771d3060d37411d02e", + "size": 183321, + "subdir": "linux-64", + "timestamp": 1534175106498, + "version": "2.6.7" + }, + "numexpr-2.6.7-py35hedc7406_0.conda": { + "build": "py35hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "42d114eb0105d0f79d61be3e2f319186", + "name": "numexpr", + "sha256": "621f20c28c369d157551eb25bd762a4be1d71002884fe979c42ddaebcd71b58e", + "size": 182778, + "subdir": "linux-64", + "timestamp": 1534355695148, + "version": "2.6.7" + }, + "numexpr-2.6.7-py36h00253c6_0.conda": { + "build": "py36h00253c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "5c6ced54a2b9ace29b167a8820affd95", + "name": "numexpr", + "sha256": "30ec1cf59519e13625e2b7c201fc92b0ac238533f963bdc90f029fc2de5026a7", + "size": 182030, + "subdir": "linux-64", + "timestamp": 1534175147216, + "version": "2.6.7" + }, + "numexpr-2.6.7-py36h6cfcb94_0.conda": { + "build": "py36h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "cc061b92eb3813adf302eb1a04d5e067", + "name": "numexpr", + "sha256": "f27e81ca1747eb2208db803eb59c096c9b4fdf68b0479c47c081ea3c33eb3323", + "size": 182778, + "subdir": "linux-64", + "timestamp": 1534355754114, + "version": "2.6.7" + }, + "numexpr-2.6.7-py36h98f89e9_0.conda": { + "build": "py36h98f89e9_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "280e8f7309eb69dc5e006c1c9c6b995f", + "name": "numexpr", + "sha256": "4fc4831db543e76247e70474719d5df08a85821c77bf16c3200d490ce4a3d004", + "size": 182472, + "subdir": "linux-64", + "timestamp": 1534174274279, + "version": "2.6.7" + }, + "numexpr-2.6.7-py36hbd46f51_0.conda": { + "build": "py36hbd46f51_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "bbc5cbfd441c2fcc3011f857516bbcc1", + "name": "numexpr", + "sha256": "824543832f3762664608d502fd53297f003a32c9165628288bba10a1e3f06852", + "size": 182032, + "subdir": "linux-64", + "timestamp": 1534780768747, + "version": "2.6.7" + }, + "numexpr-2.6.7-py36hedc7406_0.conda": { + "build": "py36hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "94142b559f4f29cdcba4e674757293f9", + "name": "numexpr", + "sha256": "7caa021574141327054ccade1f6d20441cbcbedbfe9767014fa8dfaacff5333b", + "size": 181912, + "subdir": "linux-64", + "timestamp": 1534355811246, + "version": "2.6.7" + }, + "numexpr-2.6.7-py37h00253c6_0.conda": { + "build": "py37h00253c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3395c8ec1ff58665c8d9dad6d7904ad2", + "name": "numexpr", + "sha256": "757c20d68160f64fe985c014c4bda84a7783fd6b11831c01193ad723e4058f0d", + "size": 183765, + "subdir": "linux-64", + "timestamp": 1534174291159, + "version": "2.6.7" + }, + "numexpr-2.6.7-py37h6cfcb94_0.conda": { + "build": "py37h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "61b5f670bb096e452c3d46324c228f9c", + "name": "numexpr", + "sha256": "2f73f5c12a3432a5c1326c7edb8949523c42ecf4df965fef4875ea1ab6f2d7ee", + "size": 183125, + "subdir": "linux-64", + "timestamp": 1534355398584, + "version": "2.6.7" + }, + "numexpr-2.6.7-py37h98f89e9_0.conda": { + "build": "py37h98f89e9_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "0776f2c97ec213eb96d88e9177337407", + "name": "numexpr", + "sha256": "8c67648c1a4ef065bc3884ae8c1dd7d9087bdba10c3825445fb9f94cf34a257d", + "size": 182877, + "subdir": "linux-64", + "timestamp": 1534174011221, + "version": "2.6.7" + }, + "numexpr-2.6.7-py37hedc7406_0.conda": { + "build": "py37hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "82874f57abdae2c22fac48cc826fa71c", + "name": "numexpr", + "sha256": "fcaeed4f811f10fff2f4ba7baa17fff66cde8f1b7b724848224e056461415e11", + "size": 182540, + "subdir": "linux-64", + "timestamp": 1534355471547, + "version": "2.6.7" + }, + "numexpr-2.6.8-py27h2ffa06c_0.conda": { + "build": "py27h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "1733ef3289b44efecb17d45312af0f86", + "name": "numexpr", + "sha256": "f70bfe84c108c8a70a1102f13b7f91912ce441afe9ff8e678ace204926d7e842", + "size": 185250, + "subdir": "linux-64", + "timestamp": 1536942981952, + "version": "2.6.8" + }, + "numexpr-2.6.8-py27h619cd38_0.conda": { + "build": "py27h619cd38_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "49bb0242af5c47fc161e4dd6c6d2bd49", + "name": "numexpr", + "sha256": "e7470144b78da990d93ccde4cd9f0b196da2edca8056c4828c274e82a99179b8", + "size": 183843, + "subdir": "linux-64", + "timestamp": 1535416750257, + "version": "2.6.8" + }, + "numexpr-2.6.8-py27h9e4a6bb_0.conda": { + "build": "py27h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.15.4,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5439046ac06d41f6e0561dfac0ba892f", + "name": "numexpr", + "sha256": "7ed7e65de8ca054ebd11047e7102891713cf9d21cab8afdf2607d81d1dea00f0", + "size": 188160, + "subdir": "linux-64", + "timestamp": 1544745371266, + "version": "2.6.8" + }, + "numexpr-2.6.8-py27hd89afb7_0.conda": { + "build": "py27hd89afb7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "a66817d4ccca03ef39c93a9b71956dfc", + "name": "numexpr", + "sha256": "880e42b0b2f9866626bccdaf0e3f996c6051a4fc489bca9c3c5607ac66ad94e7", + "size": 183477, + "subdir": "linux-64", + "timestamp": 1535413543360, + "version": "2.6.8" + }, + "numexpr-2.6.8-py35h2ffa06c_0.conda": { + "build": "py35h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "b59866a06a683e32cf0cae48c8abc197", + "name": "numexpr", + "sha256": "1e585e0ff364b5869fef5f0142062ae74d8d0954402dd70a998703b4b4dc3f6b", + "size": 186530, + "subdir": "linux-64", + "timestamp": 1536943012575, + "version": "2.6.8" + }, + "numexpr-2.6.8-py35h619cd38_0.conda": { + "build": "py35h619cd38_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "2fd5a14562641092a2679a44d39fba7a", + "name": "numexpr", + "sha256": "5afc7be18fb2f44ca0f60eb5d6ca7dcb3f7384792028cee9e49b1d0be7e0b089", + "size": 185115, + "subdir": "linux-64", + "timestamp": 1535414277644, + "version": "2.6.8" + }, + "numexpr-2.6.8-py35hd89afb7_0.conda": { + "build": "py35hd89afb7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "09f6f8af5028e5a6a1ecf6f5a18b23db", + "name": "numexpr", + "sha256": "644c9ae0736a32634d7d4ab86da4ebe135a8023a88fb73b05566a2e9517a4e86", + "size": 183801, + "subdir": "linux-64", + "timestamp": 1535416841930, + "version": "2.6.8" + }, + "numexpr-2.6.8-py36h2ffa06c_0.conda": { + "build": "py36h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "591e2dae27e2ccc201892c44abce93a2", + "name": "numexpr", + "sha256": "419af43b7e2f665e65a886785389d99366ecbf02afd714e65270eb7c599e1016", + "size": 184669, + "subdir": "linux-64", + "timestamp": 1536942995618, + "version": "2.6.8" + }, + "numexpr-2.6.8-py36h619cd38_0.conda": { + "build": "py36h619cd38_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2b0b1dda670bb9c391a992664f1d5d76", + "name": "numexpr", + "sha256": "6b2951b0e3164ecfa3dc555ea5535d2c7eab90039d9c89887af32e2405ee48f8", + "size": 183306, + "subdir": "linux-64", + "timestamp": 1535413928805, + "version": "2.6.8" + }, + "numexpr-2.6.8-py36h9e4a6bb_0.conda": { + "build": "py36h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.15.4,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "48de32630e9015e10c3938a6e61353d0", + "name": "numexpr", + "sha256": "ee298e74efdbf29ffe9b7302822d81c5a0ee948d12a366f3da7bd86aae28ae1c", + "size": 187766, + "subdir": "linux-64", + "timestamp": 1544745511037, + "version": "2.6.8" + }, + "numexpr-2.6.8-py36hd89afb7_0.conda": { + "build": "py36hd89afb7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "bb1fb94a4ad4f3ca1d7ee90c4a090827", + "name": "numexpr", + "sha256": "ae50055663932ff8fc22d400b291899dcdb11331b2a053eebc042920e81f4c9f", + "size": 182901, + "subdir": "linux-64", + "timestamp": 1535415129709, + "version": "2.6.8" + }, + "numexpr-2.6.8-py37h2ffa06c_0.conda": { + "build": "py37h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ef4122f398193ccd625dd3a564ccfefa", + "name": "numexpr", + "sha256": "5cc2409d3dabd0a235b68260c5e0ee6f13e95a2116b69c6b1e48706d66125e45", + "size": 185455, + "subdir": "linux-64", + "timestamp": 1536942982196, + "version": "2.6.8" + }, + "numexpr-2.6.8-py37h619cd38_0.conda": { + "build": "py37h619cd38_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3749d249546d1011139f3c5e6fe2dd9c", + "name": "numexpr", + "sha256": "924cfa15458d1c5ce8c62d8fff9259218e85d55a6da13c20e1ad1c91bb4fd61c", + "size": 183540, + "subdir": "linux-64", + "timestamp": 1535414265636, + "version": "2.6.8" + }, + "numexpr-2.6.8-py37h9e4a6bb_0.conda": { + "build": "py37h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.15.4,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e70b2b93f29093716a4f461c77839ec0", + "name": "numexpr", + "sha256": "9c9eb59203109adab1b59bd1d9e003b7fe48d434304d640a535e5b4d9c47a0e5", + "size": 187998, + "subdir": "linux-64", + "timestamp": 1544745347483, + "version": "2.6.8" + }, + "numexpr-2.6.8-py37hd89afb7_0.conda": { + "build": "py37hd89afb7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d35b555dc5ccd965700020f7f0884426", + "name": "numexpr", + "sha256": "7810007af71295baf6e6aa31167535d406ff4d0679315f252306737d9a62f11a", + "size": 183224, + "subdir": "linux-64", + "timestamp": 1535415186939, + "version": "2.6.8" + }, + "numexpr-2.6.9-py27h2ffa06c_0.conda": { + "build": "py27h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "78629c9c3bbaf0b02dd706f694f3a100", + "name": "numexpr", + "sha256": "a64b5e60db9b65a509a01d503f0f8ab47dc6af47c4fd7b120f04095c1d352829", + "size": 188584, + "subdir": "linux-64", + "timestamp": 1547241333036, + "version": "2.6.9" + }, + "numexpr-2.6.9-py27h9e4a6bb_0.conda": { + "build": "py27h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.15.4,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "61fa8d1ab58b029ea825e4ff848bd536", + "name": "numexpr", + "sha256": "b90a81dc29fab7521838fc782fef8f9868ce966aef2f6b5c10c600819f476308", + "size": 187468, + "subdir": "linux-64", + "timestamp": 1547241659752, + "version": "2.6.9" + }, + "numexpr-2.6.9-py36h2ffa06c_0.conda": { + "build": "py36h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "69b6e1da106209e985dce889d7bf79f6", + "name": "numexpr", + "sha256": "e7ebd11199074d9d3f731743ed5aa5612d524cc7f49dbb9875567533892164af", + "size": 188099, + "subdir": "linux-64", + "timestamp": 1547241393424, + "version": "2.6.9" + }, + "numexpr-2.6.9-py36h9e4a6bb_0.conda": { + "build": "py36h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.15.4,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "bd9cf7bd0895e9dc3b15028ea3c9a9c6", + "name": "numexpr", + "sha256": "5e4e263ba9e722405519450db771f94d2a21fc4d519254cb44ce980cab5ee8d8", + "size": 187794, + "subdir": "linux-64", + "timestamp": 1547241603321, + "version": "2.6.9" + }, + "numexpr-2.6.9-py37h2ffa06c_0.conda": { + "build": "py37h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e0f1fba43dc78b6c85ce5c33ac504e43", + "name": "numexpr", + "sha256": "46349b26d5a733f8d8c55aa378e97eabe5d02aa8ef18a7178d06d2ac151d6cd4", + "size": 188797, + "subdir": "linux-64", + "timestamp": 1547241409282, + "version": "2.6.9" + }, + "numexpr-2.6.9-py37h9e4a6bb_0.conda": { + "build": "py37h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.15.4,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e364e321955f24cdaf872d200ed37eae", + "name": "numexpr", + "sha256": "7a933817fbd9ad3dd70818be3d32741a8d1795555258f72c29d9f9ee26463b36", + "size": 189014, + "subdir": "linux-64", + "timestamp": 1547241570608, + "version": "2.6.9" + }, + "numexpr-2.7.0-py27h2ffa06c_0.conda": { + "build": "py27h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.4,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "3d9b0fadc03e9cfb04f6ebc40c967728", + "name": "numexpr", + "sha256": "cf7633680362b4faaebf94860665d6e6710c0c6cf835452bbbc062121bb1fde4", + "size": 187854, + "subdir": "linux-64", + "timestamp": 1565958459923, + "version": "2.7.0" + }, + "numexpr-2.7.0-py27h9e4a6bb_0.conda": { + "build": "py27h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.4,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "8d27715b29c578a89b8e85da1fdc9228", + "name": "numexpr", + "sha256": "b98d72709a252d7795dc01c454c664d21b8a8c70d200ae34463c9a911acfc4ff", + "size": 187508, + "subdir": "linux-64", + "timestamp": 1565959715865, + "version": "2.7.0" + }, + "numexpr-2.7.0-py36h22eb022_0.conda": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ac919cebf6701fc9ed28596254e657d1", + "name": "numexpr", + "sha256": "c1f15a201a9316903106d81c4a634e2cd924e2755c1116c9d2d25ad1769a55c4", + "size": 187559, + "subdir": "linux-64", + "timestamp": 1580251812345, + "version": "2.7.0" + }, + "numexpr-2.7.0-py36h2ffa06c_0.conda": { + "build": "py36h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.4,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "70918345980f911642ef94a85184333a", + "name": "numexpr", + "sha256": "d2caae7c251d94476b2680bfa020c6fa9ffb4d4adf134ed8d1c3366f8c3fb7ee", + "size": 189724, + "subdir": "linux-64", + "timestamp": 1565959411572, + "version": "2.7.0" + }, + "numexpr-2.7.0-py36h9e4a6bb_0.conda": { + "build": "py36h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.4,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "bb37752cde5abc83cc4f8b64e73f131e", + "name": "numexpr", + "sha256": "2a86d75bd94c95cb90569720655fea1ddc3a80fab2becb323762830c1f8a2b88", + "size": 187423, + "subdir": "linux-64", + "timestamp": 1565959902187, + "version": "2.7.0" + }, + "numexpr-2.7.0-py36hd81dba3_0.conda": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "47e6822d0505364da527f2eb8c4617a3", + "name": "numexpr", + "sha256": "6ff98ccfe4c27f5f69ff634cc0831f74e5f9be2e7e1cdce28ba9afb5dc6e9d02", + "size": 190185, + "subdir": "linux-64", + "timestamp": 1580251889298, + "version": "2.7.0" + }, + "numexpr-2.7.0-py37h22eb022_0.conda": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "32db4388f3566252e4d07c79adaf0ebe", + "name": "numexpr", + "sha256": "213e16e103acd307a6c32e7bd4153c4f361c124bb1126dce1d75cc102573d70e", + "size": 189360, + "subdir": "linux-64", + "timestamp": 1580251728317, + "version": "2.7.0" + }, + "numexpr-2.7.0-py37h2ffa06c_0.conda": { + "build": "py37h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.4,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "bb5bfc66dc9dff0df7d4ba0bb0978b6f", + "name": "numexpr", + "sha256": "6180f71e59c84741ae4e1b918a67f8a72d931236cf376e47a7f36e600234257a", + "size": 190668, + "subdir": "linux-64", + "timestamp": 1565959535406, + "version": "2.7.0" + }, + "numexpr-2.7.0-py37h9e4a6bb_0.conda": { + "build": "py37h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.4,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "000c399732514d871915b696766337b3", + "name": "numexpr", + "sha256": "ed87702d8b3b28a8883fafa8617ec18f117aba5e084cc4d7c05d497fe6b75f98", + "size": 187703, + "subdir": "linux-64", + "timestamp": 1565959658323, + "version": "2.7.0" + }, + "numexpr-2.7.0-py37hd81dba3_0.conda": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ff77ca80280dc3b7215944e3912ad6e9", + "name": "numexpr", + "sha256": "76c49cd285218129d8eaff59bb62c83e82297ca96db1ce23090bf4197e78c0dc", + "size": 189005, + "subdir": "linux-64", + "timestamp": 1580251876620, + "version": "2.7.0" + }, + "numexpr-2.7.0-py38h22eb022_0.conda": { + "build": "py38h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "01a0df94832a35fd6b37bdd79e40fc30", + "name": "numexpr", + "sha256": "c54f590a101cc8efa93b372a2dd9bbbcf924d2f95ce1dec2240a1b7ccbce2209", + "size": 189932, + "subdir": "linux-64", + "timestamp": 1580251760326, + "version": "2.7.0" + }, + "numexpr-2.7.0-py38h2ffa06c_0.conda": { + "build": "py38h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy-base >=1.17.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "6c1f3160ddfe6a62e7288015b316fe9e", + "name": "numexpr", + "sha256": "db01015d0e8f0c57f4c542829f8799ef35db765e37419df6041b61148133db35", + "size": 194882, + "subdir": "linux-64", + "timestamp": 1573738369459, + "version": "2.7.0" + }, + "numexpr-2.7.0-py38h9e4a6bb_0.conda": { + "build": "py38h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base >=1.17.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "064c8cda8b87f327a47ae9548cffe052", + "name": "numexpr", + "sha256": "ec0a59e0de1dca5f7d4545b9cbd06d1f0c25dfdc887b3251c14f7c6629c3c214", + "size": 194362, + "subdir": "linux-64", + "timestamp": 1573738323688, + "version": "2.7.0" + }, + "numexpr-2.7.0-py38hd81dba3_0.conda": { + "build": "py38hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "0aa8050ef190ec3684bc295dbdeb8b4b", + "name": "numexpr", + "sha256": "8ea11dac2907145224324745991ecb966605026f63dfb2364c5e9e196b492a60", + "size": 188453, + "subdir": "linux-64", + "timestamp": 1580251969482, + "version": "2.7.0" + }, + "numexpr-2.7.1-py36h134e634_0.conda": { + "build": "py36h134e634_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "80a02fb8444ce91c083cc68c72c2df11", + "name": "numexpr", + "sha256": "7323df01050c6978ec432cd09133cf9b5f4e41bcbc8489d5a07b6d47decc0137", + "size": 189176, + "subdir": "linux-64", + "timestamp": 1607693818563, + "version": "2.7.1" + }, + "numexpr-2.7.1-py36h423224d_0.conda": { + "build": "py36h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2a3a6cb1c1f7a06cb01de08445e4724d", + "name": "numexpr", + "sha256": "971d29e9cafa40ca11cb3a0f09c7afadb2a5d4cb0554a60840a79883ba253059", + "size": 190004, + "subdir": "linux-64", + "timestamp": 1580839244361, + "version": "2.7.1" + }, + "numexpr-2.7.1-py36h63df603_0.conda": { + "build": "py36h63df603_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b5ef65beff94b8c69b931cdee392dd76", + "name": "numexpr", + "sha256": "2a660b97ac32c60753ce26d4d0dafd7534e6b29e66e0ad858d6e722d4c70fce3", + "size": 190345, + "subdir": "linux-64", + "timestamp": 1607693826600, + "version": "2.7.1" + }, + "numexpr-2.7.1-py36h7ea95a0_0.conda": { + "build": "py36h7ea95a0_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a957f3444c0c369c96c8446b3af45acc", + "name": "numexpr", + "sha256": "b83e6134e1ed92b857fd6eddf485c47f34b0b2816fbe172bd52b041f34ce0e5e", + "size": 188872, + "subdir": "linux-64", + "timestamp": 1580839142640, + "version": "2.7.1" + }, + "numexpr-2.7.1-py37h134e634_0.conda": { + "build": "py37h134e634_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7c9f60cf517126b3fc8d56ae01b58084", + "name": "numexpr", + "sha256": "d11de73c5a6cb9e2bd907ded28820ff9344d65923f99c6ac7000506cec3fdf2b", + "size": 190806, + "subdir": "linux-64", + "timestamp": 1607693820365, + "version": "2.7.1" + }, + "numexpr-2.7.1-py37h423224d_0.conda": { + "build": "py37h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "bae7167f265bebf68798140da7260363", + "name": "numexpr", + "sha256": "1f6ad93184e8c97e27a20b1ce1c5211b927f963dde7e0a5f5d74f706453915ed", + "size": 190982, + "subdir": "linux-64", + "timestamp": 1580839210804, + "version": "2.7.1" + }, + "numexpr-2.7.1-py37h63df603_0.conda": { + "build": "py37h63df603_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "73f2b2793c70eb7e416269c57eef9244", + "name": "numexpr", + "sha256": "870762456b34621e1f0fa07a84f21ff816290d890ceb366d43f1c083f074cb54", + "size": 190543, + "subdir": "linux-64", + "timestamp": 1607693827040, + "version": "2.7.1" + }, + "numexpr-2.7.1-py37h7ea95a0_0.conda": { + "build": "py37h7ea95a0_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1908d565f4236471742bb0d0ec93b301", + "name": "numexpr", + "sha256": "7686624fde0cf3e60b6ec13151ec6fd4d49b083478b0c5f8be1a5d8a97683f71", + "size": 189651, + "subdir": "linux-64", + "timestamp": 1580839178576, + "version": "2.7.1" + }, + "numexpr-2.7.1-py38h134e634_0.conda": { + "build": "py38h134e634_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "54b739c12bff252ed3721788df28504c", + "name": "numexpr", + "sha256": "80545ce0c1d409384420edb6331531b0aa9b03eba86ad0ab716e2df2cb48146c", + "size": 191341, + "subdir": "linux-64", + "timestamp": 1607693841113, + "version": "2.7.1" + }, + "numexpr-2.7.1-py38h423224d_0.conda": { + "build": "py38h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "82cc027f4fb2744022f05921858347a0", + "name": "numexpr", + "sha256": "f3c1ddbd76205a98a2152ad8017e65090c66a455f3532d2b5fdde11d604cf244", + "size": 191123, + "subdir": "linux-64", + "timestamp": 1580839235989, + "version": "2.7.1" + }, + "numexpr-2.7.1-py38h63df603_0.conda": { + "build": "py38h63df603_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "ade8fd34969c7a5e158c5d37d4a9f77c", + "name": "numexpr", + "sha256": "9e720279599d11f4ffedab6c41055416fe2dfc94cc48edfac6bb73ef8653513b", + "size": 189844, + "subdir": "linux-64", + "timestamp": 1607693838018, + "version": "2.7.1" + }, + "numexpr-2.7.1-py38h7ea95a0_0.conda": { + "build": "py38h7ea95a0_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "183351cf789e042a8ca98a19d4022a14", + "name": "numexpr", + "sha256": "15936979c71c35d603fca83b2ade2c5aef63ebd5c7991337f50c94e9c40a275a", + "size": 190271, + "subdir": "linux-64", + "timestamp": 1580839194871, + "version": "2.7.1" + }, + "numexpr-2.7.1-py39h134e634_0.conda": { + "build": "py39h134e634_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "5849add3ef59cd37e5c1703d8f363da5", + "name": "numexpr", + "sha256": "697ded8648a3e9c1aee33b01789733365c22e5ca25330a4e26e3332acb868313", + "size": 188399, + "subdir": "linux-64", + "timestamp": 1607693831114, + "version": "2.7.1" + }, + "numexpr-2.7.1-py39h63df603_0.conda": { + "build": "py39h63df603_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "d01a90ed5cc2c88d403f92cadfe0f5fd", + "name": "numexpr", + "sha256": "e2af9f5031d2de484c86b74d37dfd895c72c91a183393fb9a1bf22f9b058ef60", + "size": 189965, + "subdir": "linux-64", + "timestamp": 1607693829865, + "version": "2.7.1" + }, + "numexpr-2.7.2-py36h4be448d_0.conda": { + "build": "py36h4be448d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ff6247ad0602927e97a53a40d11b33be", + "name": "numexpr", + "sha256": "71e0957117a3508aa66836e42aa7d8e75add53fd650ee65761d85f3f1ec3f75b", + "size": 188350, + "subdir": "linux-64", + "timestamp": 1609354703309, + "version": "2.7.2" + }, + "numexpr-2.7.2-py36hb2eb853_0.conda": { + "build": "py36hb2eb853_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "310ace914e977621e4812067a082228d", + "name": "numexpr", + "sha256": "6096a3b19421077f1b9c082065eea11be2b4b1c7dee4193a2e58d741938d8aa6", + "size": 186672, + "subdir": "linux-64", + "timestamp": 1609354711703, + "version": "2.7.2" + }, + "numexpr-2.7.2-py37h4be448d_0.conda": { + "build": "py37h4be448d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "9317815ab558b701b5df71ea85b27a35", + "name": "numexpr", + "sha256": "6a032e46cdc5153c2c460ea788f8c7eb35397b6d3bfa8cd6f446deba31334680", + "size": 187061, + "subdir": "linux-64", + "timestamp": 1609354703903, + "version": "2.7.2" + }, + "numexpr-2.7.2-py37hb2eb853_0.conda": { + "build": "py37hb2eb853_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d9e0377049d437f410016089cc9f7a73", + "name": "numexpr", + "sha256": "1a41634fc5a5c9c8bcb5ab9a820af579aa5e697f177c8a22c05c2f079380b297", + "size": 188004, + "subdir": "linux-64", + "timestamp": 1609354679943, + "version": "2.7.2" + }, + "numexpr-2.7.2-py38h4be448d_0.conda": { + "build": "py38h4be448d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "4fda29b6a8052ca499d8106db7b918a4", + "name": "numexpr", + "sha256": "030c112c93e5c6c0aea6a2119e06016c72201e5df945d6a40753dc7b478749dd", + "size": 189031, + "subdir": "linux-64", + "timestamp": 1609354670825, + "version": "2.7.2" + }, + "numexpr-2.7.2-py38hb2eb853_0.conda": { + "build": "py38hb2eb853_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "dc729a362105d86a8afb36170cbc1b59", + "name": "numexpr", + "sha256": "01743edb7324c5765d87379a3c0bdb0bc0acdcc4eef2971f48d9f25eecad0d5a", + "size": 190240, + "subdir": "linux-64", + "timestamp": 1609354741932, + "version": "2.7.2" + }, + "numexpr-2.7.2-py39h4be448d_0.conda": { + "build": "py39h4be448d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "586f7d95d78327646fb218040ebbaef0", + "name": "numexpr", + "sha256": "4c3ac06c3a5d8a1f354c64f1ccf4c9fd549904ef8100b0b6d673d25bb8efac76", + "size": 186578, + "subdir": "linux-64", + "timestamp": 1609354701682, + "version": "2.7.2" + }, + "numexpr-2.7.2-py39hb2eb853_0.conda": { + "build": "py39hb2eb853_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "1ae13bb54c0c743e942fbd43eb83c885", + "name": "numexpr", + "sha256": "152c90d75c6c90b8c7fcaaaa6b3f144f9734d0f471b9b2910c0d595f28a86b6e", + "size": 186527, + "subdir": "linux-64", + "timestamp": 1609354727405, + "version": "2.7.2" + }, + "numexpr-2.7.3-py310hd732450_1.conda": { + "build": "py310hd732450_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "7130dd77e58b2b93e66f00949a465c41", + "name": "numexpr", + "sha256": "068b502f5a9e359b6547fa60352325c51cf027290385ea3327a4c70c0d926394", + "size": 382731, + "subdir": "linux-64", + "timestamp": 1640792037686, + "version": "2.7.3" + }, + "numexpr-2.7.3-py310hfd7a2a2_1.conda": { + "build": "py310hfd7a2a2_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "1ef964fe3b8788ad02e396d87cdf1fa4", + "name": "numexpr", + "sha256": "0c93b23ac859e836707d3f82e4057077ef27293e8842767befb2c3c4d5ab8ed7", + "size": 381872, + "subdir": "linux-64", + "timestamp": 1640792004468, + "version": "2.7.3" + }, + "numexpr-2.7.3-py36h22e1b3c_1.conda": { + "build": "py36h22e1b3c_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c2628f0d1be17c14931ce964f9c6ac35", + "name": "numexpr", + "sha256": "6ff8019d3953abcc46d3ff04e4c7d0951362fa8f9ffa30df148ca64707d7cca0", + "size": 193225, + "subdir": "linux-64", + "timestamp": 1618856649034, + "version": "2.7.3" + }, + "numexpr-2.7.3-py36h4be448d_0.conda": { + "build": "py36h4be448d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "cf7f7fb70061c3ab935ca3bfa15bf272", + "name": "numexpr", + "sha256": "518c3803bf27fe68fae084f10072d0f81d49beb3206af649fcad436d9c02f3ca", + "size": 188964, + "subdir": "linux-64", + "timestamp": 1614797290882, + "version": "2.7.3" + }, + "numexpr-2.7.3-py36h4be448d_1.conda": { + "build": "py36h4be448d_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "cf7e619b8452cf5a5d395ab7196c73a3", + "name": "numexpr", + "sha256": "8cd28f5de753b785eb78cdfd78141f015b945a66306d6b84d71827c9bf7a0e1a", + "size": 192463, + "subdir": "linux-64", + "timestamp": 1618853264127, + "version": "2.7.3" + }, + "numexpr-2.7.3-py36hb2eb853_0.conda": { + "build": "py36hb2eb853_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "beb788391dbdb706acd6de9cb77fa66b", + "name": "numexpr", + "sha256": "3103ca7dae8966c158075a3dad96e9e32e0b0264b1af736b3f59e4588f65569f", + "size": 187700, + "subdir": "linux-64", + "timestamp": 1614798606172, + "version": "2.7.3" + }, + "numexpr-2.7.3-py37h22e1b3c_1.conda": { + "build": "py37h22e1b3c_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "cb41a8c23772fe6f36375d45ee6c1774", + "name": "numexpr", + "sha256": "659b8bf28e88b74a20e8a93529017b1d8fce19a270d3a5a49f883bf6c9bc96b5", + "size": 192612, + "subdir": "linux-64", + "timestamp": 1618856649024, + "version": "2.7.3" + }, + "numexpr-2.7.3-py37h4be448d_0.conda": { + "build": "py37h4be448d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "309df264af1090629fa99259dfd21dbe", + "name": "numexpr", + "sha256": "5241d85d36a6eb9d5473b0af39498f4a9ed27387f52dd772e3a9049e99f63441", + "size": 188144, + "subdir": "linux-64", + "timestamp": 1614798586381, + "version": "2.7.3" + }, + "numexpr-2.7.3-py37h4be448d_1.conda": { + "build": "py37h4be448d_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "bdde40f8231ea96b4663707ac35bb54b", + "name": "numexpr", + "sha256": "10e1982909a488d75c2cb45a4cab4beb65b4bc4769c165d69de5c55dc6d62c9d", + "size": 192877, + "subdir": "linux-64", + "timestamp": 1618856601430, + "version": "2.7.3" + }, + "numexpr-2.7.3-py37hb2eb853_0.conda": { + "build": "py37hb2eb853_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a6f88858771c50ef3e211487a9759b32", + "name": "numexpr", + "sha256": "806de1d0699723a9c5876ed6e18565db322809ad4da157bd7d9c9a8d2d5e592c", + "size": 188961, + "subdir": "linux-64", + "timestamp": 1614798606801, + "version": "2.7.3" + }, + "numexpr-2.7.3-py38h22e1b3c_1.conda": { + "build": "py38h22e1b3c_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "fdd4dd744e6409461fbc9543e30da04f", + "name": "numexpr", + "sha256": "f41dc5784a6dab2fe738c61d23c22de923bc50065be563042689ba6436152dc7", + "size": 192098, + "subdir": "linux-64", + "timestamp": 1618856281691, + "version": "2.7.3" + }, + "numexpr-2.7.3-py38h4be448d_0.conda": { + "build": "py38h4be448d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "1bcd0c35b067248a19f6e038dc65645c", + "name": "numexpr", + "sha256": "097a6367694fbca84850fe3845bb8baa087a74803d9f3fefdef044abd25130aa", + "size": 190031, + "subdir": "linux-64", + "timestamp": 1614798587769, + "version": "2.7.3" + }, + "numexpr-2.7.3-py38h4be448d_1.conda": { + "build": "py38h4be448d_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "d78f7f636e325f37d0031a8d124c0ad8", + "name": "numexpr", + "sha256": "dd16cd5def2d6b12b9ef9a2f698353b16353959bfca01f47733decb97a6ace13", + "size": 192285, + "subdir": "linux-64", + "timestamp": 1618856595172, + "version": "2.7.3" + }, + "numexpr-2.7.3-py38hb2eb853_0.conda": { + "build": "py38hb2eb853_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "4bf141038ebbb05eda7de675a236afcc", + "name": "numexpr", + "sha256": "0ad9dd0c79fde8be4c09b0625ad8e368b049e2196685a069c4c5dab0be249090", + "size": 189794, + "subdir": "linux-64", + "timestamp": 1614798586990, + "version": "2.7.3" + }, + "numexpr-2.7.3-py39h22e1b3c_1.conda": { + "build": "py39h22e1b3c_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "11c31bf5cac5197d595401bb61936f65", + "name": "numexpr", + "sha256": "9fcc725756ce256a8f96eb2ac636a690593e676aefb1a78db69c595b5e76221f", + "size": 189515, + "subdir": "linux-64", + "timestamp": 1618856659098, + "version": "2.7.3" + }, + "numexpr-2.7.3-py39h4be448d_0.conda": { + "build": "py39h4be448d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "a0a8df65f5cc95f82c25e85c82458b99", + "name": "numexpr", + "sha256": "a2e94c21e062750e42a92a91931f695fd17ac0042be315587e01d7831ccf7617", + "size": 186592, + "subdir": "linux-64", + "timestamp": 1614798567566, + "version": "2.7.3" + }, + "numexpr-2.7.3-py39h4be448d_1.conda": { + "build": "py39h4be448d_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "d2d816ae07c3bd24db7b035fa4041601", + "name": "numexpr", + "sha256": "e18d0265300e510c07d433976e29f6fcb1d9a92080272e0494a0b8f123874b4f", + "size": 191306, + "subdir": "linux-64", + "timestamp": 1618856233103, + "version": "2.7.3" + }, + "numexpr-2.7.3-py39hb2eb853_0.conda": { + "build": "py39hb2eb853_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "366f852bb183565ce05188dc1a0c226f", + "name": "numexpr", + "sha256": "418878378457e1e93e688250d461697dd3333d51a04187c1b217755ee5ccfca5", + "size": 187300, + "subdir": "linux-64", + "timestamp": 1614798573440, + "version": "2.7.3" + }, + "numexpr-2.8.1-py310h757a811_1.conda": { + "build": "py310h757a811_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f4a7f3703da5fdb72d739d3384a7cee", + "name": "numexpr", + "sha256": "7fca8bae873952717f703580accb60f4399db504a94f5ecd80e1f58f18fd9889", + "size": 325184, + "subdir": "linux-64", + "timestamp": 1656068790927, + "version": "2.8.1" + }, + "numexpr-2.8.1-py310h757a811_2.conda": { + "build": "py310h757a811_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a7f2bfa018da0f8f65e6c6538bb5dc67", + "name": "numexpr", + "sha256": "545d100f697a3de414773540ae25251e08b3a54e4ce445b01ffaae5ae5efb596", + "size": 324901, + "subdir": "linux-64", + "timestamp": 1656072358446, + "version": "2.8.1" + }, + "numexpr-2.8.1-py310hcea2de6_1.conda": { + "build": "py310hcea2de6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "034058e966556902e36770f6ed83878c", + "name": "numexpr", + "sha256": "a78bc2b48457ba092eed4625cc2341c97c0ead155ca2e2a3be559b5ab4fd77df", + "size": 325298, + "subdir": "linux-64", + "timestamp": 1656068602954, + "version": "2.8.1" + }, + "numexpr-2.8.1-py310hcea2de6_2.conda": { + "build": "py310hcea2de6_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "185811bc4c010330252e6cfffb666f41", + "name": "numexpr", + "sha256": "7b3a452cab0629648b981f0ecdb4184827126ae73b0d79bbc5a03780a488e6e7", + "size": 325033, + "subdir": "linux-64", + "timestamp": 1656072175861, + "version": "2.8.1" + }, + "numexpr-2.8.1-py37h6abb31d_0.conda": { + "build": "py37h6abb31d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95ff643f5726d30fab220f37f696d570", + "name": "numexpr", + "sha256": "c9410e4c4f7c436e5800e5be07f3558612f6b3069cd4f59166e76e9a5a9b00a9", + "size": 126305, + "subdir": "linux-64", + "timestamp": 1640704262878, + "version": "2.8.1" + }, + "numexpr-2.8.1-py37h807cd23_1.conda": { + "build": "py37h807cd23_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bac2d44c430d7fa1fc3c1eaacfba8984", + "name": "numexpr", + "sha256": "c12d2ead285a993988679becbba30c34a3c805f3be353da0ed487e29480f93ee", + "size": 124564, + "subdir": "linux-64", + "timestamp": 1656068491025, + "version": "2.8.1" + }, + "numexpr-2.8.1-py37h807cd23_2.conda": { + "build": "py37h807cd23_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45e80281c41452482d8caba169e2db39", + "name": "numexpr", + "sha256": "d946c36714ec534f9abb8d5151f8ebeb7858c788b982da13f4fffad5fbe3c870", + "size": 124943, + "subdir": "linux-64", + "timestamp": 1656072016955, + "version": "2.8.1" + }, + "numexpr-2.8.1-py37hd2a5715_1.conda": { + "build": "py37hd2a5715_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "220e61f330b43ae193ebd2d8db7d7d4f", + "name": "numexpr", + "sha256": "043ba0d4b64c5945fc1d40d5b83a8ad28ac630d5db816b47a1ec023cf48d1b08", + "size": 124476, + "subdir": "linux-64", + "timestamp": 1656068696370, + "version": "2.8.1" + }, + "numexpr-2.8.1-py37hd2a5715_2.conda": { + "build": "py37hd2a5715_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6aeab7f8f36eabe925c401e186f2a331", + "name": "numexpr", + "sha256": "3f5fd4bcae9950f3bac1fdf89247fd28bd204379e7ec48e30de23de472e6b658", + "size": 124859, + "subdir": "linux-64", + "timestamp": 1656072221842, + "version": "2.8.1" + }, + "numexpr-2.8.1-py37hecfb737_0.conda": { + "build": "py37hecfb737_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52e407724874a0593474d13f91ff24b4", + "name": "numexpr", + "sha256": "49286548030589097c686beb22919de21386888816760b4e576c9f0052d071ce", + "size": 126963, + "subdir": "linux-64", + "timestamp": 1640686140004, + "version": "2.8.1" + }, + "numexpr-2.8.1-py38h6abb31d_0.conda": { + "build": "py38h6abb31d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb930a390cae19b698b6ca2c1da8f74b", + "name": "numexpr", + "sha256": "12880df3c7f84465c5568a4a487ac96ab4344f2180387bdbce9e6c0946807fb2", + "size": 127752, + "subdir": "linux-64", + "timestamp": 1640704277727, + "version": "2.8.1" + }, + "numexpr-2.8.1-py38h807cd23_1.conda": { + "build": "py38h807cd23_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60a2e655c9e3b8fa859e31e31f664820", + "name": "numexpr", + "sha256": "8052023337e4841aeb812b3d4889c43d8d3585afa945b883a0d91f4a028d6e6d", + "size": 125321, + "subdir": "linux-64", + "timestamp": 1656068540072, + "version": "2.8.1" + }, + "numexpr-2.8.1-py38h807cd23_2.conda": { + "build": "py38h807cd23_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14ad5575b6311120a126ee27537aec69", + "name": "numexpr", + "sha256": "ee96348d92c95b7b3c3f207af316670c151115cf9f2250544d321c2e3008bf95", + "size": 125439, + "subdir": "linux-64", + "timestamp": 1656072114413, + "version": "2.8.1" + }, + "numexpr-2.8.1-py38hd2a5715_1.conda": { + "build": "py38hd2a5715_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c8cd637694cbb23be5fa7b3bdbfebc14", + "name": "numexpr", + "sha256": "ca2109f5af6d1d13d6af0f32cfe14467bb76770f00278e5779c90b8a02602f02", + "size": 125253, + "subdir": "linux-64", + "timestamp": 1656068743081, + "version": "2.8.1" + }, + "numexpr-2.8.1-py38hd2a5715_2.conda": { + "build": "py38hd2a5715_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "169078f62bae3542a7d5318607269a46", + "name": "numexpr", + "sha256": "0dd45355aa48f2a46b402798d6dc31021422cf79ad08ee8888c113b75b5cb744", + "size": 125368, + "subdir": "linux-64", + "timestamp": 1656072313413, + "version": "2.8.1" + }, + "numexpr-2.8.1-py38hecfb737_0.conda": { + "build": "py38hecfb737_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2e1beed4be65d533b13df66d1a9ec42", + "name": "numexpr", + "sha256": "a15d828c1e71407a4d5b8f73bf992544cc32996901f81025cf488285b42d21ae", + "size": 128092, + "subdir": "linux-64", + "timestamp": 1640704258852, + "version": "2.8.1" + }, + "numexpr-2.8.1-py39h6abb31d_0.conda": { + "build": "py39h6abb31d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebde53682fcd8e509507ca713e63d787", + "name": "numexpr", + "sha256": "62df49eda0c2070eb269b16f8db4e891daf8522e6d91c5d76913fc759476b9d5", + "size": 126590, + "subdir": "linux-64", + "timestamp": 1640689905588, + "version": "2.8.1" + }, + "numexpr-2.8.1-py39h807cd23_1.conda": { + "build": "py39h807cd23_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8a64acb550e0043b54d10a3c89e3af2", + "name": "numexpr", + "sha256": "cf08e154dd4586d30459031e040d6ac5b86e0b711bd02a994e04d0e3341e0f39", + "size": 124779, + "subdir": "linux-64", + "timestamp": 1656068439979, + "version": "2.8.1" + }, + "numexpr-2.8.1-py39h807cd23_2.conda": { + "build": "py39h807cd23_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca0a52587a8ec6cd27326f08703e2626", + "name": "numexpr", + "sha256": "707de35183e468c700ce0a90468b3cc37431e22228c42977922e62c21ba799d7", + "size": 125149, + "subdir": "linux-64", + "timestamp": 1656072066283, + "version": "2.8.1" + }, + "numexpr-2.8.1-py39hd2a5715_1.conda": { + "build": "py39hd2a5715_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52fa6e4cc1128349f035a146ab2afa28", + "name": "numexpr", + "sha256": "82846fce4c3104a1bdd5d5512abad20dd17e760cb2500d8372ed783ccbf57805", + "size": 124703, + "subdir": "linux-64", + "timestamp": 1656068649547, + "version": "2.8.1" + }, + "numexpr-2.8.1-py39hd2a5715_2.conda": { + "build": "py39hd2a5715_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c1d8e994001ff1cdb18593b2000d00f", + "name": "numexpr", + "sha256": "5bc4d5a76bedaf48f98232de1104d316dc4c6fab9dff952fa357522be3c79d42", + "size": 125069, + "subdir": "linux-64", + "timestamp": 1656072267467, + "version": "2.8.1" + }, + "numexpr-2.8.1-py39hecfb737_0.conda": { + "build": "py39hecfb737_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e63c053edcb618133aebf7df10cbd97b", + "name": "numexpr", + "sha256": "98cd011e12d24b454ded328b7d3819cc2be1142b794ac9e568dc36b903850fb5", + "size": 126245, + "subdir": "linux-64", + "timestamp": 1640689891396, + "version": "2.8.1" + }, + "numexpr-2.8.3-py310h757a811_0.conda": { + "build": "py310h757a811_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5553f8cdaf761cbb4e8e40151eb53fd", + "name": "numexpr", + "sha256": "93e943a5ba02ca6772a464f3397589c0547d9a354b733384bf1bda24258ebb91", + "size": 328857, + "subdir": "linux-64", + "timestamp": 1656940629161, + "version": "2.8.3" + }, + "numexpr-2.8.3-py310hcea2de6_0.conda": { + "build": "py310hcea2de6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "742e93a3d62e6f1fc3a90eebbf5be20d", + "name": "numexpr", + "sha256": "ef3ba379c7655c21da18c530fee6e5bbc438d857cf8cecb508413c34ffd21508", + "size": 328905, + "subdir": "linux-64", + "timestamp": 1656940434352, + "version": "2.8.3" + }, + "numexpr-2.8.3-py311h802d673_0.conda": { + "build": "py311h802d673_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.22.3,<2.0a0", + "packaging", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63cfd5726f41f6659775ea048f884a8f", + "name": "numexpr", + "sha256": "5d98703a49a8ac985c7446705e261f8d34a3a5af90aa73bbd80140f6b5018dc1", + "size": 150781, + "subdir": "linux-64", + "timestamp": 1676828163518, + "version": "2.8.3" + }, + "numexpr-2.8.3-py311hd846eea_0.conda": { + "build": "py311hd846eea_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "packaging", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cfe1b041db0dd22d8049467a7db87757", + "name": "numexpr", + "sha256": "2cbfa929cb699fa35802e36c1fa657affe1cf30df117bf0a2451911bd0a658f6", + "size": 150705, + "subdir": "linux-64", + "timestamp": 1676828145252, + "version": "2.8.3" + }, + "numexpr-2.8.3-py37h807cd23_0.conda": { + "build": "py37h807cd23_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "38ceb29960aef8427e931b8520333285", + "name": "numexpr", + "sha256": "83bc7568ee80050bb041e9d5f1d652ffe4c932d527181f5737cc98553656fea8", + "size": 127072, + "subdir": "linux-64", + "timestamp": 1656940534830, + "version": "2.8.3" + }, + "numexpr-2.8.3-py37hd2a5715_0.conda": { + "build": "py37hd2a5715_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0feae15719474e55473ac95f32442e7b", + "name": "numexpr", + "sha256": "8540b2ecdbea9f4f2ad6b1e68bb3d77eaa49365fdb2da7a2443dde44b9984b31", + "size": 127001, + "subdir": "linux-64", + "timestamp": 1656940721412, + "version": "2.8.3" + }, + "numexpr-2.8.3-py38h807cd23_0.conda": { + "build": "py38h807cd23_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "469db45c646fa5e2eecf7c2ef294f229", + "name": "numexpr", + "sha256": "4e64df920b01c3e705117c875275dc6d977da5b7f2326d2837c4d4f49546819f", + "size": 127561, + "subdir": "linux-64", + "timestamp": 1656940372231, + "version": "2.8.3" + }, + "numexpr-2.8.3-py38hd2a5715_0.conda": { + "build": "py38hd2a5715_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "808a4be8c061c93a8a856f8675090056", + "name": "numexpr", + "sha256": "72b14d6489c941dd86e47688efbb18529f50dc73ead5b5cc9ca936424e22934d", + "size": 127480, + "subdir": "linux-64", + "timestamp": 1656940581465, + "version": "2.8.3" + }, + "numexpr-2.8.3-py39h807cd23_0.conda": { + "build": "py39h807cd23_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0814cff069dca900757fca476b1f809b", + "name": "numexpr", + "sha256": "4daa843930bc12be589dc065e1cc3bf0a55fab337d2e7459c8c3baca93629190", + "size": 127399, + "subdir": "linux-64", + "timestamp": 1656940484765, + "version": "2.8.3" + }, + "numexpr-2.8.3-py39hd2a5715_0.conda": { + "build": "py39hd2a5715_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b613c52f85a39e69b4465233fb370e5", + "name": "numexpr", + "sha256": "fc24809ede0089e6403167247d51c0b02deebb6f68077062b1250bb9ea847c5b", + "size": 127329, + "subdir": "linux-64", + "timestamp": 1656940674781, + "version": "2.8.3" + }, + "numexpr-2.8.4-py310h757a811_0.conda": { + "build": "py310h757a811_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98cc93011aae8ddbbe887e020382a293", + "name": "numexpr", + "sha256": "2a35ba38844581ec3071bb92af8e398cc4e715dc3681d42a4c627ddd03c3ee99", + "size": 137036, + "subdir": "linux-64", + "timestamp": 1668713944803, + "version": "2.8.4" + }, + "numexpr-2.8.4-py310h8879344_0.conda": { + "build": "py310h8879344_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8db8fd5f149185a8acc094c3a953029", + "name": "numexpr", + "sha256": "2dd25fa293d553cf6c08dc205fbee457d0a5f3d018d8f7661fe623389fc9fb7e", + "size": 137092, + "subdir": "linux-64", + "timestamp": 1668714138771, + "version": "2.8.4" + }, + "numexpr-2.8.4-py311h802d673_0.conda": { + "build": "py311h802d673_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.22.3,<2.0a0", + "packaging", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c8a07a533ec40d9ab1af4a8556a95468", + "name": "numexpr", + "sha256": "1dd0f7c212c3c619bb6bd427c7023f425d0241785ac7a13b75b3606d8bd6f340", + "size": 151401, + "subdir": "linux-64", + "timestamp": 1679336725499, + "version": "2.8.4" + }, + "numexpr-2.8.4-py311hd846eea_0.conda": { + "build": "py311hd846eea_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "packaging", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f664093491b6f777b6f8aaafe28afe07", + "name": "numexpr", + "sha256": "274a7ee8b10b3f3731f52d426ea99ea64d25341c2b0e0c0a10f7d3e457569244", + "size": 151358, + "subdir": "linux-64", + "timestamp": 1679336696405, + "version": "2.8.4" + }, + "numexpr-2.8.4-py37hd2a5715_0.conda": { + "build": "py37hd2a5715_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "162706aafedc14a1a1646fa1a6ae830d", + "name": "numexpr", + "sha256": "98b66827ee2fb5dc044db18417081e0a0868fcf822c9ea6658c09691c1094210", + "size": 136284, + "subdir": "linux-64", + "timestamp": 1668713992619, + "version": "2.8.4" + }, + "numexpr-2.8.4-py37he184ba9_0.conda": { + "build": "py37he184ba9_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "89a13032d928d95880a3c3c51d50aaed", + "name": "numexpr", + "sha256": "0730c29a7def6783ac89a1aeb23ccf2663cf929f6fad93ad2a1125eacbb89b34", + "size": 136370, + "subdir": "linux-64", + "timestamp": 1668714187272, + "version": "2.8.4" + }, + "numexpr-2.8.4-py38hd2a5715_0.conda": { + "build": "py38hd2a5715_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a8fdf3a535c3927f24312e22f2bb81b", + "name": "numexpr", + "sha256": "598b817b0007e0bdab01c5b694c85ec10d0a21ace5a4ffb01b4aa26ce42778fd", + "size": 137033, + "subdir": "linux-64", + "timestamp": 1668714088102, + "version": "2.8.4" + }, + "numexpr-2.8.4-py38he184ba9_0.conda": { + "build": "py38he184ba9_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab4451ab826d589db149f3ae21b4cd2d", + "name": "numexpr", + "sha256": "3f2da0c1e1a342a968038e6c5d4456c54394088061c0b75ecf8f6a0d9e195a5c", + "size": 137122, + "subdir": "linux-64", + "timestamp": 1668714284675, + "version": "2.8.4" + }, + "numexpr-2.8.4-py39hd2a5715_0.conda": { + "build": "py39hd2a5715_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a2d69a1398d61a575e4e92f770deab44", + "name": "numexpr", + "sha256": "a32b43968d0cff59ef725137386a455b4022b89db645649765bfc16656f87673", + "size": 136366, + "subdir": "linux-64", + "timestamp": 1668714040294, + "version": "2.8.4" + }, + "numexpr-2.8.4-py39he184ba9_0.conda": { + "build": "py39he184ba9_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "759926e056b4c6dd4dc6cb191baab1ab", + "name": "numexpr", + "sha256": "30dae0889a7532915e454335b141597e0ab5029194a543ac01d41dd36ae6b4a3", + "size": 136453, + "subdir": "linux-64", + "timestamp": 1668714235894, + "version": "2.8.4" + }, + "numpy-1.11.3-py27h1b885b7_8.conda": { + "build": "py27h1b885b7_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27hdbf6ddf_8", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "57d14eb0098432d8a03d87bb09ab3fa4", + "name": "numpy", + "sha256": "fabbdc2d870a26bf24707e301da84377d0aae09f9a97add4cca2a53e075c57ed", + "size": 10127, + "subdir": "linux-64", + "timestamp": 1530724249473, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h1b885b7_9.conda": { + "build": "py27h1b885b7_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27h3dfced4_9", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1c84d5c7818b63c1183ca9f2888d3c1e", + "name": "numpy", + "sha256": "04c4245d5ae48111b92011447800e331ae950f551ffde59a9536c463dd3e11ed", + "size": 10415, + "subdir": "linux-64", + "timestamp": 1532661314859, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h1d66e8a_10.conda": { + "build": "py27h1d66e8a_10", + "build_number": 10, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py27h81de0dd_10", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ad1f0ab99c2eec4c56aa18da4cf2fb45", + "name": "numpy", + "sha256": "aaf169845021be21efe3192d90d2123b94665e6855ba653d3fc670d65be30da0", + "size": 10823, + "subdir": "linux-64", + "timestamp": 1535405816018, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h28100ab_7.conda": { + "build": "py27h28100ab_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27h2b20989_7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2bb995eb94fe38639d870a69944e83bf", + "name": "numpy", + "sha256": "fb6674455f0af69f27aaf2aa818c6f76c4d4439989787e2f99075c04a9d92a76", + "size": 10512, + "subdir": "linux-64", + "timestamp": 1530380848462, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h28100ab_8.conda": { + "build": "py27h28100ab_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27h2b20989_8", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1846bcc8403663c8a68e648ee74967e8", + "name": "numpy", + "sha256": "77ef597e96a224ef7d071ce29e91b943a1f3c0e022ff51bbe229ea0c57f2a9f0", + "size": 10576, + "subdir": "linux-64", + "timestamp": 1530550938484, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h2aefc1b_8.conda": { + "build": "py27h2aefc1b_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27h2b20989_8", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b60d04d61d19f7fc359e69179f99c6e9", + "name": "numpy", + "sha256": "dba7ab6548a39ad8a05894779fcbd61a9de20c2c47a108aed446a89bbd909dee", + "size": 10127, + "subdir": "linux-64", + "timestamp": 1530723986577, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h2aefc1b_9.conda": { + "build": "py27h2aefc1b_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27h7cdd4dd_9", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0ff2707b50d9dfd965855bf39ae85c3e", + "name": "numpy", + "sha256": "a75a02692fcb0f031e5287d86c278ea543a174abb0b414fc2c14db64796a6196", + "size": 10398, + "subdir": "linux-64", + "timestamp": 1532660216708, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h3b04361_9.conda": { + "build": "py27h3b04361_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27h81de0dd_9", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3a6d5ad5ce307a5ed56f01eba15d27f8", + "name": "numpy", + "sha256": "706cdc5e1ae52fc47afdef28084238399be1785ec5906bfac1961b5f792c06c2", + "size": 10747, + "subdir": "linux-64", + "timestamp": 1535389047457, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h3dfced4_4.conda": { + "build": "py27h3dfced4_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "aef3193b4ef5f4fdfdd9b9972db4014e", + "name": "numpy", + "sha256": "ffc3e88e6197c5fad6fe2f1b75f645424ab527cbbb0c75cbcf1f8ae6f43331d3", + "size": 3006276, + "subdir": "linux-64", + "timestamp": 1519835702812, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h7e9f1db_11.conda": { + "build": "py27h7e9f1db_11", + "build_number": 11, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py27hde5b4d6_11", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c513ee30c88f4b288372872c677a29b5", + "name": "numpy", + "sha256": "9d00db25c546fd4e9be268cba7e1a894c3d1f44b8defbc53d7080d401e8b05b7", + "size": 15810, + "subdir": "linux-64", + "timestamp": 1544632837600, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h7e9f1db_12.conda": { + "build": "py27h7e9f1db_12", + "build_number": 12, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py27hde5b4d6_12", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ce75a90e999a3824b248763cdfb6fdea", + "name": "numpy", + "sha256": "3ee4179affabce687f6d03046786d0a71fad8781470ec58f819fe3e1b397be9f", + "size": 16264, + "subdir": "linux-64", + "timestamp": 1544763176263, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h99e49ec_10.conda": { + "build": "py27h99e49ec_10", + "build_number": 10, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py27h2f8d375_10", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fb67fba0012e01d0388934624154815c", + "name": "numpy", + "sha256": "cf7ef1bcc781e0f10630ecb2fde3da6eaf397b08ae1dfe675ac2d1aad83e68bc", + "size": 11095, + "subdir": "linux-64", + "timestamp": 1536892577694, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h99e49ec_11.conda": { + "build": "py27h99e49ec_11", + "build_number": 11, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py27h2f8d375_11", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "34a4e14af9586dbf772fbf69fb83964f", + "name": "numpy", + "sha256": "4f59f6478a4e0d147816dd10de295e7b109d0c06d31426f0319763482df355ad", + "size": 15811, + "subdir": "linux-64", + "timestamp": 1544631969255, + "version": "1.11.3" + }, + "numpy-1.11.3-py27h99e49ec_12.conda": { + "build": "py27h99e49ec_12", + "build_number": 12, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py27h2f8d375_12", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e890a5f7a184635c517b21d9978a4732", + "name": "numpy", + "sha256": "5c7aba530b699e04b3f35a069d2692b38bdd528a3acea8453f98f7bd3f504af9", + "size": 16280, + "subdir": "linux-64", + "timestamp": 1544762982577, + "version": "1.11.3" + }, + "numpy-1.11.3-py27hb510916_10.conda": { + "build": "py27hb510916_10", + "build_number": 10, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py27h74e8950_10", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cd0a9d07846833fec475f61e194ea5f9", + "name": "numpy", + "sha256": "21c1aa9df569d88d9c1b1af7549192f7d721d378259d7f7286ced7b14791d803", + "size": 10849, + "subdir": "linux-64", + "timestamp": 1535405709187, + "version": "1.11.3" + }, + "numpy-1.11.3-py27hcd700cb_7.conda": { + "build": "py27hcd700cb_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27hdbf6ddf_7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "828feffdbcc68eed13e0c20f6d82c3f8", + "name": "numpy", + "sha256": "6ac3d671e294dce5004f8e576bfe6d70aa384d49197ff3a316c42116b8944b11", + "size": 10492, + "subdir": "linux-64", + "timestamp": 1530382537273, + "version": "1.11.3" + }, + "numpy-1.11.3-py27hcd700cb_8.conda": { + "build": "py27hcd700cb_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27hdbf6ddf_8", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e1903978964171ee21a95cf1bce8901b", + "name": "numpy", + "sha256": "dd485299571152fa447eb5e9e9f325166b079896f7d0ab2a883f99d877ac5026", + "size": 10557, + "subdir": "linux-64", + "timestamp": 1530551577594, + "version": "1.11.3" + }, + "numpy-1.11.3-py27hec00662_9.conda": { + "build": "py27hec00662_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py27h74e8950_9", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "aace9773d1bdbe185726546478e7e548", + "name": "numpy", + "sha256": "178d3a5d781ef09d75f7ab6b99590ea23eeac769e7d5b8c99645b8bea13cfadf", + "size": 10761, + "subdir": "linux-64", + "timestamp": 1535388059268, + "version": "1.11.3" + }, + "numpy-1.11.3-py35h1b885b7_8.conda": { + "build": "py35h1b885b7_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py35hdbf6ddf_8", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ee54bf88f7cbce8e2657abfc9f69ef42", + "name": "numpy", + "sha256": "ab3e2a291d653e5aa9e3cae3b1414057c263257066a6f83f4fe816b20176f9e4", + "size": 10066, + "subdir": "linux-64", + "timestamp": 1534346268822, + "version": "1.11.3" + }, + "numpy-1.11.3-py35h1b885b7_9.conda": { + "build": "py35h1b885b7_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py35h3dfced4_9", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "15fca03cc06422e98270f9f84a5c0ffd", + "name": "numpy", + "sha256": "c3b9418481ea283945073e8bfa8c4f997542f9449f075590fe733b71f77cec07", + "size": 10387, + "subdir": "linux-64", + "timestamp": 1532661265678, + "version": "1.11.3" + }, + "numpy-1.11.3-py35h1d66e8a_10.conda": { + "build": "py35h1d66e8a_10", + "build_number": 10, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py35h81de0dd_10", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "441ac46f3be6d621f4caf9e09e265f71", + "name": "numpy", + "sha256": "810908c93a6ee849d50cb06fd7e38e7d97745583fad87efaf4e85430a4e5fe90", + "size": 10860, + "subdir": "linux-64", + "timestamp": 1535406560073, + "version": "1.11.3" + }, + "numpy-1.11.3-py35h2aefc1b_8.conda": { + "build": "py35h2aefc1b_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py35h2b20989_8", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "63c4e2abb37b9cb45e57c5a23ff11a2a", + "name": "numpy", + "sha256": "3b40d0f730bcca951d34cc28974c38ce1c32710426a772928dd6f5e7fcff25d6", + "size": 10064, + "subdir": "linux-64", + "timestamp": 1534346544391, + "version": "1.11.3" + }, + "numpy-1.11.3-py35h2aefc1b_9.conda": { + "build": "py35h2aefc1b_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py35h7cdd4dd_9", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "53cd7787d0053d42c9975e7df38a2c27", + "name": "numpy", + "sha256": "39464ebde98293eeff002d1a155093b5164d71a13b2ebfaa5518aab177010903", + "size": 10421, + "subdir": "linux-64", + "timestamp": 1532660201013, + "version": "1.11.3" + }, + "numpy-1.11.3-py35h3b04361_9.conda": { + "build": "py35h3b04361_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py35h81de0dd_9", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7679916baadb2be3dd92e685a54e2b93", + "name": "numpy", + "sha256": "a252554d925042e784e5690deffd95de6c95a0e2b6159cf89c76548597885b18", + "size": 10757, + "subdir": "linux-64", + "timestamp": 1535389084737, + "version": "1.11.3" + }, + "numpy-1.11.3-py35h3dfced4_4.conda": { + "build": "py35h3dfced4_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "592890c2ca4c5312b51cd9a6a1f86ab1", + "name": "numpy", + "sha256": "dc1228fbb82afdbf927341b4fa9f07cdb01b8f248e5e859c4fe971b8b3cd6a4e", + "size": 3046205, + "subdir": "linux-64", + "timestamp": 1519835721886, + "version": "1.11.3" + }, + "numpy-1.11.3-py35h99e49ec_10.conda": { + "build": "py35h99e49ec_10", + "build_number": 10, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py35h2f8d375_10", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5b7f2bb243bb7c42a86f37419d2041fa", + "name": "numpy", + "sha256": "b9e0adb7226c03747d3446c0002bd13e47bfa5d778440d573ae98c878ee657be", + "size": 11119, + "subdir": "linux-64", + "timestamp": 1536892610447, + "version": "1.11.3" + }, + "numpy-1.11.3-py35hb510916_10.conda": { + "build": "py35hb510916_10", + "build_number": 10, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py35h74e8950_10", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "72fe03ff41f8487bd1a4538d5797bf7a", + "name": "numpy", + "sha256": "5f073242d36e1b75d1401247e8118e45dec95a5fc9480d5cfc90faab6030ff92", + "size": 10876, + "subdir": "linux-64", + "timestamp": 1535405683419, + "version": "1.11.3" + }, + "numpy-1.11.3-py35hec00662_9.conda": { + "build": "py35hec00662_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py35h74e8950_9", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c4667d133c4bb6da6b53fd1010e78ef7", + "name": "numpy", + "sha256": "0d74fd6ee9c2c963c3b6eed4f7dd347d9bcc16e6bf3830c31d23c72e72b4aefb", + "size": 10720, + "subdir": "linux-64", + "timestamp": 1535388398082, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h1b885b7_8.conda": { + "build": "py36h1b885b7_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36hdbf6ddf_8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "575c6b611eb15b09d7acb1f1ed5b1ad1", + "name": "numpy", + "sha256": "12ffe6e4fcbfe204decfee9f3faa6f17d1c5f3ac68ba9aa755f5b74248e1164e", + "size": 10151, + "subdir": "linux-64", + "timestamp": 1530721953993, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h1b885b7_9.conda": { + "build": "py36h1b885b7_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36h3dfced4_9", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "34df123a2a9008547b7dd03f023a10cf", + "name": "numpy", + "sha256": "ce3ff7579239ad178bf5586376d0cdd6ad820a0b5853413e59a17e3fdfff48cc", + "size": 10378, + "subdir": "linux-64", + "timestamp": 1532661253358, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h1d66e8a_10.conda": { + "build": "py36h1d66e8a_10", + "build_number": 10, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py36h81de0dd_10", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "07e62bfe79734440dfaeaab5fc2b41b4", + "name": "numpy", + "sha256": "3d69af5c22339814aee1dd1b12583bd2937a047b6b73e3e7bc1cfcbe1c4639e6", + "size": 10861, + "subdir": "linux-64", + "timestamp": 1535405858317, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h28100ab_7.conda": { + "build": "py36h28100ab_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36h2b20989_7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "67f51e7a81905caea4640f24ed143dcb", + "name": "numpy", + "sha256": "2a4d62dff72a7803f51cacae36ad796afa95574bd7e71c7a6b77cec3468d2da6", + "size": 10489, + "subdir": "linux-64", + "timestamp": 1530381182235, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h28100ab_8.conda": { + "build": "py36h28100ab_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36h2b20989_8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "95404371fecfb03f92a2ea8142a36611", + "name": "numpy", + "sha256": "56e42ea6a41fab6086272d437919ca61b98f79dbe139b83a4340fc59d035f229", + "size": 10569, + "subdir": "linux-64", + "timestamp": 1530551327597, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h2aefc1b_8.conda": { + "build": "py36h2aefc1b_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36h2b20989_8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fc98a01f7699d218724de3e1d2d5b36e", + "name": "numpy", + "sha256": "f6691c415350b11e74c9ef175a31be267217334e64d82e9557c0935700b17d5d", + "size": 10157, + "subdir": "linux-64", + "timestamp": 1530722232504, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h2aefc1b_9.conda": { + "build": "py36h2aefc1b_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36h7cdd4dd_9", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7efc9a2edc7cbc100c1ce7e831c86291", + "name": "numpy", + "sha256": "636c4b9fc26dcafccd2982f97f70cc084b8a2f62284c787c9de14ed9f05564df", + "size": 10386, + "subdir": "linux-64", + "timestamp": 1532660168072, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h3b04361_9.conda": { + "build": "py36h3b04361_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36h81de0dd_9", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "47421ba4e0abfff66c71788d5ed284c0", + "name": "numpy", + "sha256": "3f27dcf389a458e2fdd238beabfe021a23ac60766d253a0bdc933a4f0f861b39", + "size": 10734, + "subdir": "linux-64", + "timestamp": 1535386707413, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h3dfced4_4.conda": { + "build": "py36h3dfced4_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "6b3fcb7dfa1c9b165e6f468b8f0110f0", + "name": "numpy", + "sha256": "90379a002186cc57ae92cd8b681d523595e8c13a6b5c8e7773cb3a7b11103ce8", + "size": 3015990, + "subdir": "linux-64", + "timestamp": 1519835691560, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h7e9f1db_11.conda": { + "build": "py36h7e9f1db_11", + "build_number": 11, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py36hde5b4d6_11", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "99b570f76c13abde875521cb4b07c98a", + "name": "numpy", + "sha256": "fbe6864d67d7983369b5598bce95510808c7d58a75591b390aa38905c78109dd", + "size": 15765, + "subdir": "linux-64", + "timestamp": 1544632741414, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h7e9f1db_12.conda": { + "build": "py36h7e9f1db_12", + "build_number": 12, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py36hde5b4d6_12", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "67b09eaeb82bc0d057379cfbb8c87386", + "name": "numpy", + "sha256": "d7f20c79969abdda23464ff085feff52059660a7092e38c3fb4bed7efa633a7f", + "size": 16321, + "subdir": "linux-64", + "timestamp": 1544763324615, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h99e49ec_10.conda": { + "build": "py36h99e49ec_10", + "build_number": 10, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py36h2f8d375_10", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9e6faef319012536e338b812151e7170", + "name": "numpy", + "sha256": "30272db3a3e2bf0aa6337837c33e25414338b13a9d6880065dcee6c6ad635cb2", + "size": 11121, + "subdir": "linux-64", + "timestamp": 1536892545248, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h99e49ec_11.conda": { + "build": "py36h99e49ec_11", + "build_number": 11, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py36h2f8d375_11", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7e23ebb9b895c4b85fec653f79d5dbb5", + "name": "numpy", + "sha256": "360529c6149b832e07adbaa83949cce25c1ef5d64e84c83abdbb55f30a996b5a", + "size": 15772, + "subdir": "linux-64", + "timestamp": 1544632137700, + "version": "1.11.3" + }, + "numpy-1.11.3-py36h99e49ec_12.conda": { + "build": "py36h99e49ec_12", + "build_number": 12, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py36h2f8d375_12", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "33aeaf6c8b2debbef087cffff5d70c3e", + "name": "numpy", + "sha256": "536295957a87148c8c14db22b26fe8ff0d1af730c1ebc9d43ae8b948a7723019", + "size": 16339, + "subdir": "linux-64", + "timestamp": 1544763141894, + "version": "1.11.3" + }, + "numpy-1.11.3-py36hb510916_10.conda": { + "build": "py36hb510916_10", + "build_number": 10, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py36h74e8950_10", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "25cb1dc76b0c04a403c6027e52b35690", + "name": "numpy", + "sha256": "8261f5dd1afed0a7e78dd35f167c486d6a294e4af6511df4640f413f2e0b3e2a", + "size": 10870, + "subdir": "linux-64", + "timestamp": 1535405715224, + "version": "1.11.3" + }, + "numpy-1.11.3-py36hcd700cb_7.conda": { + "build": "py36hcd700cb_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36hdbf6ddf_7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0a073cbc9cf3f30b6285cece69c80eda", + "name": "numpy", + "sha256": "99aea877fb9232030639d3d492eee67a99b576764da38878d590c620a25a95da", + "size": 10474, + "subdir": "linux-64", + "timestamp": 1530382706962, + "version": "1.11.3" + }, + "numpy-1.11.3-py36hcd700cb_8.conda": { + "build": "py36hcd700cb_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36hdbf6ddf_8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f0ab3abd1799f427bc87e654a9c40278", + "name": "numpy", + "sha256": "b9083a66d4cb75133c98460357e8dea7ff80e5f4910a9a5e7f3cc040590b2078", + "size": 10606, + "subdir": "linux-64", + "timestamp": 1530553796319, + "version": "1.11.3" + }, + "numpy-1.11.3-py36hec00662_9.conda": { + "build": "py36hec00662_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py36h74e8950_9", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bfef88538b32222c164fd8f2bf001017", + "name": "numpy", + "sha256": "f899fd632db84e21ebd9e386dfa2b71fd09f89f3d7f19535041ba089fe160b42", + "size": 10729, + "subdir": "linux-64", + "timestamp": 1535388554021, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h1b885b7_8.conda": { + "build": "py37h1b885b7_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37hdbf6ddf_8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4f894d81c4f7a441927246fb70927759", + "name": "numpy", + "sha256": "4f93047d2cabfacb2f2b0d37d135035f01d10aaa68f52b4308135ba55c9d0240", + "size": 10125, + "subdir": "linux-64", + "timestamp": 1530722976531, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h1b885b7_9.conda": { + "build": "py37h1b885b7_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37h3dfced4_9", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "392b446e78c0c3e69606798c5145efed", + "name": "numpy", + "sha256": "6e377a7ab734855b72bdbcb4635b91fe0a9fd2179234d6e10b55519a21d72159", + "size": 10370, + "subdir": "linux-64", + "timestamp": 1532661049249, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h1d66e8a_10.conda": { + "build": "py37h1d66e8a_10", + "build_number": 10, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py37h81de0dd_10", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9e76917fe623e8ee097e91952de2031a", + "name": "numpy", + "sha256": "bc04f38d000e5b82951d061338b71749708fcdc2958a11ea40b67cf53efc108c", + "size": 10862, + "subdir": "linux-64", + "timestamp": 1535405857804, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h28100ab_7.conda": { + "build": "py37h28100ab_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37h2b20989_7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bf06ae81be9edf1955ca2e950023d4e6", + "name": "numpy", + "sha256": "8d7ec894029574d17404e3e130a191f76c41b479d6472a2a92bc8bf53735c141", + "size": 10505, + "subdir": "linux-64", + "timestamp": 1530380821757, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h28100ab_8.conda": { + "build": "py37h28100ab_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37h2b20989_8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3644169a0f7c3622d243dd49c7558ec2", + "name": "numpy", + "sha256": "ffb1936194f496bf7c259da23cb127ca790214e64915ad5e1c1f9ec7f62a7895", + "size": 10558, + "subdir": "linux-64", + "timestamp": 1530550585429, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h2aefc1b_8.conda": { + "build": "py37h2aefc1b_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37h2b20989_8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3d6d9e24665b0564cb6c1f7a37020ccd", + "name": "numpy", + "sha256": "bb3b9e81f7c35f4fb91d59bb3503e5c53f116418e6e46516ae44b8553721f566", + "size": 10129, + "subdir": "linux-64", + "timestamp": 1530723225523, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h2aefc1b_9.conda": { + "build": "py37h2aefc1b_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37h7cdd4dd_9", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "762ed67e4c4255e2eab161bb1720eaa7", + "name": "numpy", + "sha256": "7c412954b648c6ea7103983515625ec9ead24f6718bef499cf0b87382b6c4faf", + "size": 10381, + "subdir": "linux-64", + "timestamp": 1532660217462, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h3b04361_9.conda": { + "build": "py37h3b04361_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37h81de0dd_9", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "12b46791e15f46aea0dce5014889839b", + "name": "numpy", + "sha256": "77edb40a7c1db6d15ee2f963ac81194a128324fa827f1eef954d4ee33ba15dfd", + "size": 10723, + "subdir": "linux-64", + "timestamp": 1535386889156, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h7e9f1db_11.conda": { + "build": "py37h7e9f1db_11", + "build_number": 11, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py37hde5b4d6_11", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e61222705562b543ab58e45280254108", + "name": "numpy", + "sha256": "842deeb367cb5aa3b4ab188cc72e80afdf273efac66410251b3ddb6e0fc96c59", + "size": 15759, + "subdir": "linux-64", + "timestamp": 1544632776176, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h7e9f1db_12.conda": { + "build": "py37h7e9f1db_12", + "build_number": 12, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py37hde5b4d6_12", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5f5609977c9c0e3201052c26d8592a7d", + "name": "numpy", + "sha256": "1d7628b776fb55129f8dba02c9a38e7c624e8632cf101d77c23ae7757afd41a1", + "size": 16267, + "subdir": "linux-64", + "timestamp": 1544763258338, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h99e49ec_10.conda": { + "build": "py37h99e49ec_10", + "build_number": 10, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py37h2f8d375_10", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "12ca89c34f547af2c02ccac63666ee92", + "name": "numpy", + "sha256": "ed88bb3fd0ae6b2a3a72e534db39b605b8bd41ba305156b5ce5c7fcef2ab1ab8", + "size": 11092, + "subdir": "linux-64", + "timestamp": 1536892540313, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h99e49ec_11.conda": { + "build": "py37h99e49ec_11", + "build_number": 11, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py37h2f8d375_11", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6b269e371abda10ac1e0a81129555fb5", + "name": "numpy", + "sha256": "d5887a7be4affec224ee5003640487cec67df55a6c7e16d44d1319de63ff2c95", + "size": 15802, + "subdir": "linux-64", + "timestamp": 1544631865079, + "version": "1.11.3" + }, + "numpy-1.11.3-py37h99e49ec_12.conda": { + "build": "py37h99e49ec_12", + "build_number": 12, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py37h2f8d375_12", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "020806a479aeb955453d3fbfa0510146", + "name": "numpy", + "sha256": "a346bafabbc9deb0ac4613845c2bdcfa9a7a33a2257f3a9d829bd2791f1ddd71", + "size": 16321, + "subdir": "linux-64", + "timestamp": 1544762979347, + "version": "1.11.3" + }, + "numpy-1.11.3-py37hb510916_10.conda": { + "build": "py37hb510916_10", + "build_number": 10, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py37h74e8950_10", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a43d8970b299122e1d5f883df745ecd1", + "name": "numpy", + "sha256": "5d7dba1bba0c7b71ed964dfe165ab5ba6f5df88c2a1242cb58d20a8578d73a97", + "size": 10850, + "subdir": "linux-64", + "timestamp": 1535405076667, + "version": "1.11.3" + }, + "numpy-1.11.3-py37hcd700cb_7.conda": { + "build": "py37hcd700cb_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37hdbf6ddf_7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c33c1adcf2128fc76282d6bfa506506f", + "name": "numpy", + "sha256": "fe1c89f3f3fb80a4d3552a4c257a5c5b6f3f9aeebdf7a91e65f3a600d5ad11a3", + "size": 10467, + "subdir": "linux-64", + "timestamp": 1530382720502, + "version": "1.11.3" + }, + "numpy-1.11.3-py37hcd700cb_8.conda": { + "build": "py37hcd700cb_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37hdbf6ddf_8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "de84014cd9a9da6453cc6382f328eddb", + "name": "numpy", + "sha256": "9b0e4cb9c4b83a791ef898a39442a2e78a98cdf224159d78aa00269d6bb62e0c", + "size": 10560, + "subdir": "linux-64", + "timestamp": 1530553935444, + "version": "1.11.3" + }, + "numpy-1.11.3-py37hec00662_9.conda": { + "build": "py37hec00662_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.11.3 py37h74e8950_9", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "264f418d5af443fc66111911f05fd3a3", + "name": "numpy", + "sha256": "4cd5b26c4fd0550795d8a2c8c812254b89628566ab8d4ff0f0daae86a81d8b3c", + "size": 10725, + "subdir": "linux-64", + "timestamp": 1535388451133, + "version": "1.11.3" + }, + "numpy-1.11.3-py38h7e9f1db_12.conda": { + "build": "py38h7e9f1db_12", + "build_number": 12, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.11.3 py38hde5b4d6_12", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "32c4ca158c483878fc8b9779823f1dd1", + "name": "numpy", + "sha256": "db19911aed9d8ceddf5d19663a0ffae563d106afe7e7a577d7070aace53f5d16", + "size": 12256, + "subdir": "linux-64", + "timestamp": 1572609508566, + "version": "1.11.3" + }, + "numpy-1.11.3-py38h99e49ec_12.conda": { + "build": "py38h99e49ec_12", + "build_number": 12, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py38h2f8d375_12", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fa931f2f77ca9abe343dd4dfe5ec6a59", + "name": "numpy", + "sha256": "fef69f103c3c51770bbc80bc325707c61dd26b15b2c357454104552afc392390", + "size": 12244, + "subdir": "linux-64", + "timestamp": 1572609732487, + "version": "1.11.3" + }, + "numpy-1.12.1-py27h9378851_1.conda": { + "build": "py27h9378851_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "mkl >=2018.0.0,<2019.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "6e71230bc63af78efc4ae3ddc7a93348", + "name": "numpy", + "sha256": "3575f2504bcfac6fecb905113d6e2211c41d851e27120d2f462aa213586b18f1", + "size": 3141739, + "subdir": "linux-64", + "timestamp": 1510000469790, + "version": "1.12.1" + }, + "numpy-1.12.1-py35hca0bb5e_1.conda": { + "build": "py35hca0bb5e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "6a357e2101ec073a562181eb8c2b4933", + "name": "numpy", + "sha256": "fbcf3fbb88d71cb676d49082a3dc43600329a36bac5ada6bf05d6445de352f7f", + "size": 3184557, + "subdir": "linux-64", + "timestamp": 1510000485112, + "version": "1.12.1" + }, + "numpy-1.12.1-py36he24570b_1.conda": { + "build": "py36he24570b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "1b169f94c358c808fc58c6056490d6e1", + "name": "numpy", + "sha256": "35b44d9e620b031e97ebe1206d44d73f376586bc80d9e2db011395e9456859a8", + "size": 3197460, + "subdir": "linux-64", + "timestamp": 1510000486903, + "version": "1.12.1" + }, + "numpy-1.13.1-py27hd1b6e02_2.conda": { + "build": "py27hd1b6e02_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "mkl >=2018.0.0,<2019.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "456d575fc61a8057480282dd1f11577d", + "name": "numpy", + "sha256": "6929ef32f512ac003898a52fcf5457edf5f6b9a8d7bae198ea8c78274bdd21be", + "size": 3255168, + "subdir": "linux-64", + "timestamp": 1506013346735, + "version": "1.13.1" + }, + "numpy-1.13.1-py35h8926d81_2.conda": { + "build": "py35h8926d81_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "14ac0b8cc2f6d3777ee4bb653e6e92ec", + "name": "numpy", + "sha256": "66fa21d3d9a9e71ef694b37ac5b931e1625416847e744992143e55c30b54cc50", + "size": 3298389, + "subdir": "linux-64", + "timestamp": 1506013892685, + "version": "1.13.1" + }, + "numpy-1.13.1-py36h5bc529a_2.conda": { + "build": "py36h5bc529a_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "2e203e6600d917feb4eb31bc644993a1", + "name": "numpy", + "sha256": "aeb984dc1169c0e2cdd23a8d37b510fb00e90ec280a6b2d4024deab2ddc0e4c7", + "size": 3287349, + "subdir": "linux-64", + "timestamp": 1506013887446, + "version": "1.13.1" + }, + "numpy-1.13.3-py27_nomklh2b20989_4.conda": { + "build": "py27_nomklh2b20989_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "7704cc5bef3f8205cb602743c23e529b", + "name": "numpy", + "sha256": "8dac7b3e8cbfcc2f9c038d140a954a7828d50b6bd9b7a2fdc2606b94159d77a7", + "size": 3286414, + "subdir": "linux-64", + "timestamp": 1522176769381, + "version": "1.13.3" + }, + "numpy-1.13.3-py27_nomklhfe0a00b_0.conda": { + "build": "py27_nomklhfe0a00b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "ec0bc534e5d0d195e97d104cf6490a89", + "name": "numpy", + "sha256": "ece6d3bcb8022986ba5773314e3869d16ddf7a69665202ff2dd1eb31e03ac315", + "size": 3236785, + "subdir": "linux-64", + "timestamp": 1509731938354, + "version": "1.13.3" + }, + "numpy-1.13.3-py27h3dfced4_2.conda": { + "build": "py27h3dfced4_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "8c2f6631d17e8dbe94ed79dd6b96f425", + "name": "numpy", + "sha256": "5e2ac6b73031c8b932ad852e20c02af1b8362a30253c1792ec7e23a69e769811", + "size": 3240225, + "subdir": "linux-64", + "timestamp": 1516836864513, + "version": "1.13.3" + }, + "numpy-1.13.3-py27ha266831_3.conda": { + "build": "py27ha266831_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "59f6369d3c5009cffbbce441afa94a10", + "name": "numpy", + "sha256": "6ce033387792b77d6ec3aee4c873d7750f908a7829435ea420dab146d55b3337", + "size": 3240514, + "subdir": "linux-64", + "timestamp": 1520447824092, + "version": "1.13.3" + }, + "numpy-1.13.3-py27hbcc08e0_0.conda": { + "build": "py27hbcc08e0_0", + "build_number": 0, + "depends": [ + "mkl >=2018.0.0,<2019.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "d5546bbdcf7efde6f80404eaf0df8386", + "name": "numpy", + "sha256": "4e167e7e6297761646684a0ce17571e9e0c69d3e55a1a576cf7d4ce54fd2e5c2", + "size": 3258036, + "subdir": "linux-64", + "timestamp": 1507324248605, + "version": "1.13.3" + }, + "numpy-1.13.3-py27hdbf6ddf_4.conda": { + "build": "py27hdbf6ddf_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "mkl_fft", + "mkl_random", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "a296406cb1b0833d88508a020135907b", + "name": "numpy", + "sha256": "7a16d1966f568c5b01067a212b9cfa493439d524821e8313e16eb1e6ff269368", + "size": 3333711, + "subdir": "linux-64", + "timestamp": 1522178718483, + "version": "1.13.3" + }, + "numpy-1.13.3-py35_nomklh2b20989_4.conda": { + "build": "py35_nomklh2b20989_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "f24bbecd2c4fdfc89ce291d4f5ffff86", + "name": "numpy", + "sha256": "1c7c240c4519f39fc67f4de2a07a60e836adc7f8ee74fd22d1f66ebe8cdf1f0a", + "size": 3305226, + "subdir": "linux-64", + "timestamp": 1522178211509, + "version": "1.13.3" + }, + "numpy-1.13.3-py35_nomklhb7e7d7c_0.conda": { + "build": "py35_nomklhb7e7d7c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "9f74d01b1fd404cd0a6448495414adad", + "name": "numpy", + "sha256": "7ce29b70d44547992decb769a64c0e069d387c35943b3944b4d64dd0ee598f40", + "size": 3302946, + "subdir": "linux-64", + "timestamp": 1509732091536, + "version": "1.13.3" + }, + "numpy-1.13.3-py35h3dfced4_2.conda": { + "build": "py35h3dfced4_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "dba71e21b985bab56648a99702f411e6", + "name": "numpy", + "sha256": "4cde5532b8273accabb6441ff5df987d94cf9e1d59c8d63f87c9688cac6720f7", + "size": 3281875, + "subdir": "linux-64", + "timestamp": 1516836901340, + "version": "1.13.3" + }, + "numpy-1.13.3-py35ha266831_3.conda": { + "build": "py35ha266831_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "b231e4f99cdb7132124236982fdc4504", + "name": "numpy", + "sha256": "013c9a217f1117f189a8cbc0046c6bb8b06bd26370223d6bf0fe1ef5b2caa046", + "size": 3281983, + "subdir": "linux-64", + "timestamp": 1520448426914, + "version": "1.13.3" + }, + "numpy-1.13.3-py35hd829ed6_0.conda": { + "build": "py35hd829ed6_0", + "build_number": 0, + "depends": [ + "mkl >=2018.0.0,<2019.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "cae06433e1871055cb6419b64483b015", + "name": "numpy", + "sha256": "29fe6e75c92e1a2af6cba2a46dc23fa6ced22e92ea05ac3fa7a7d69f0947547c", + "size": 3276493, + "subdir": "linux-64", + "timestamp": 1507324287123, + "version": "1.13.3" + }, + "numpy-1.13.3-py35hdbf6ddf_4.conda": { + "build": "py35hdbf6ddf_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "mkl_fft", + "mkl_random", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "8f00c4b5748bdc5f3f5cf1a888e248a8", + "name": "numpy", + "sha256": "0b2046528e62f5a73dbd098767b543232a9a08ac110ba607bab6a0525342704f", + "size": 3355635, + "subdir": "linux-64", + "timestamp": 1522178730625, + "version": "1.13.3" + }, + "numpy-1.13.3-py36_nomklh2b20989_4.conda": { + "build": "py36_nomklh2b20989_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "1f4944e53781cddb50b15131719ba2a5", + "name": "numpy", + "sha256": "9039551f023f68ce6b26edbb13652d91b47cea118aaf73e2abfa3076afc04264", + "size": 3320777, + "subdir": "linux-64", + "timestamp": 1522178211202, + "version": "1.13.3" + }, + "numpy-1.13.3-py36_nomklhbef0cb9_0.conda": { + "build": "py36_nomklhbef0cb9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "e9947ba2e566c9cdc9715bab829b5680", + "name": "numpy", + "sha256": "0d3f8d8bd843a9ec1bcd3c7d370c840ee97e069571438ff6814262d1badc4209", + "size": 3270944, + "subdir": "linux-64", + "timestamp": 1509732107063, + "version": "1.13.3" + }, + "numpy-1.13.3-py36h3dfced4_2.conda": { + "build": "py36h3dfced4_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "23d5311328b09fe128d800131586deec", + "name": "numpy", + "sha256": "0f32bea34972794fd0facfcfe50deb14636ac7fb2572b0519c65c29804c3643b", + "size": 3276321, + "subdir": "linux-64", + "timestamp": 1516836903302, + "version": "1.13.3" + }, + "numpy-1.13.3-py36ha12f23b_0.conda": { + "build": "py36ha12f23b_0", + "build_number": 0, + "depends": [ + "mkl >=2018.0.0,<2019.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "a15538da715aaee28c056d92c295cb05", + "name": "numpy", + "sha256": "9d554718b25cb7b72119991d0f198cb2a0784aad6fab7fea954fc3702efdcd51", + "size": 3270483, + "subdir": "linux-64", + "timestamp": 1507324009304, + "version": "1.13.3" + }, + "numpy-1.13.3-py36ha266831_3.conda": { + "build": "py36ha266831_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "f648600e494e644c36554b21e6a68416", + "name": "numpy", + "sha256": "78ddd407f64ffcfb9f60822e3cc35ad7d8c4da87b5f7f22ffb9f8f42851505a6", + "size": 3297415, + "subdir": "linux-64", + "timestamp": 1520451920394, + "version": "1.13.3" + }, + "numpy-1.13.3-py36hdbf6ddf_4.conda": { + "build": "py36hdbf6ddf_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "mkl_fft", + "mkl_random", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "f3b9d277e1d25041c62250f64242c359", + "name": "numpy", + "sha256": "1f41d97ec2eac3b43a4db1136265a1f0f79e67b8ab9cfb9bb2688b3e09afefcd", + "size": 3372322, + "subdir": "linux-64", + "timestamp": 1522178766285, + "version": "1.13.3" + }, + "numpy-1.13.3-py38_nomklh199bd5d_4.conda": { + "build": "py38_nomklh199bd5d_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0873bde19e8786104fd82a5dbe811dd4", + "name": "numpy", + "sha256": "ef2b73c6592651f4f858e5df1d12518a060a5697b0175b4f19b21c3b66678f0f", + "size": 3356424, + "subdir": "linux-64", + "timestamp": 1574354128704, + "version": "1.13.3" + }, + "numpy-1.13.3-py38he85021b_4.conda": { + "build": "py38he85021b_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cb5973eeca7459d6143219563fa61b95", + "name": "numpy", + "sha256": "35f95c7a4e86fd6046a0d39fb8a88613a5c9211dff9d65dda4b38d26a24c95cc", + "size": 3407367, + "subdir": "linux-64", + "timestamp": 1574353842218, + "version": "1.13.3" + }, + "numpy-1.14.0-py27_nomklh7cdd4dd_0.conda": { + "build": "py27_nomklh7cdd4dd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "e653a30f4f144ccf9834acf252e35b4d", + "name": "numpy", + "sha256": "cb1613b3669afead61f11863eb9ad0b68fa0adb022340ca9b63966bdb5bf60ac", + "size": 3346058, + "subdir": "linux-64", + "timestamp": 1515516714023, + "version": "1.14.0" + }, + "numpy-1.14.0-py27h3dfced4_0.conda": { + "build": "py27h3dfced4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.1,<2019.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "446a121e39dd96bc4d1036d80bd8fe86", + "name": "numpy", + "sha256": "6303c2badd95054e6541f97b6029c2082b6a4963ecb97e3e588172c212e310ef", + "size": 3368224, + "subdir": "linux-64", + "timestamp": 1515516267486, + "version": "1.14.0" + }, + "numpy-1.14.0-py27h3dfced4_1.conda": { + "build": "py27h3dfced4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "a1fea0333815ad1e836c6aebb3346a67", + "name": "numpy", + "sha256": "c80e3058b89f2a3b7fbe186cf049980153fc0c72895913b9401081c44bf3aa03", + "size": 3349797, + "subdir": "linux-64", + "timestamp": 1516832188067, + "version": "1.14.0" + }, + "numpy-1.14.0-py27ha266831_2.conda": { + "build": "py27ha266831_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "8689768dd7c9af5b9b474581f01d4ea7", + "name": "numpy", + "sha256": "bc8108dfc1a08de45cb4d950d582aedd5076a7b6d75dfeaf10b24e385426a87f", + "size": 3348843, + "subdir": "linux-64", + "timestamp": 1520448374124, + "version": "1.14.0" + }, + "numpy-1.14.0-py35_nomklh7cdd4dd_0.conda": { + "build": "py35_nomklh7cdd4dd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "8d1e2233a86f2de7e50868dbb8cb925a", + "name": "numpy", + "sha256": "7226bbd079490b98c68bbafcee695cade12ccbf373e22bd69f7f51c042576bd0", + "size": 3414486, + "subdir": "linux-64", + "timestamp": 1515516727637, + "version": "1.14.0" + }, + "numpy-1.14.0-py35h3dfced4_0.conda": { + "build": "py35h3dfced4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.1,<2019.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "646af8ef96b77ff2e2de591a00a24382", + "name": "numpy", + "sha256": "8ef6426a5a4d309f6d56472257375aa886ba5c6fe8319bc3168c68e9c4b8c03c", + "size": 3392568, + "subdir": "linux-64", + "timestamp": 1515516403173, + "version": "1.14.0" + }, + "numpy-1.14.0-py35h3dfced4_1.conda": { + "build": "py35h3dfced4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "e58e43045513417f0e2f9bb54d8fcc9e", + "name": "numpy", + "sha256": "2d1f4a22efd5d3877886ff360943bd52b3a40a42f00362f1c392b757da1cd47b", + "size": 3396519, + "subdir": "linux-64", + "timestamp": 1516832230784, + "version": "1.14.0" + }, + "numpy-1.14.0-py35ha266831_2.conda": { + "build": "py35ha266831_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "afc1b3657feb11b93a6a576a50c97930", + "name": "numpy", + "sha256": "748cd0e3e50d8f83733643c4a1ec1d82c7f9cf5d74b3ed8447a03e935840b66e", + "size": 3417550, + "subdir": "linux-64", + "timestamp": 1520448578576, + "version": "1.14.0" + }, + "numpy-1.14.0-py36_nomklh7cdd4dd_0.conda": { + "build": "py36_nomklh7cdd4dd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "61ff5d790d0a9bfedb07134acebaa0a0", + "name": "numpy", + "sha256": "699ae93ddc7fc8214d8655eebd9028beb680acbd9ed1bcb2f63304c92fb16f5e", + "size": 3405510, + "subdir": "linux-64", + "timestamp": 1515516729151, + "version": "1.14.0" + }, + "numpy-1.14.0-py36h3dfced4_0.conda": { + "build": "py36h3dfced4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.1,<2019.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "8b85bdeefe9fe3db91b6503b6dbf6a10", + "name": "numpy", + "sha256": "01deffd7a61ad7a11318aafdcb016b29b66e40f1697b68d32bfa473cbd7a840b", + "size": 3383728, + "subdir": "linux-64", + "timestamp": 1515516199405, + "version": "1.14.0" + }, + "numpy-1.14.0-py36h3dfced4_1.conda": { + "build": "py36h3dfced4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "e2065470c8ceeb042e2065418a250258", + "name": "numpy", + "sha256": "dbcf896cbf0aacc482f1de7c2c03fab6615e0a861a12684c2719b0ef9c1f4d28", + "size": 3411777, + "subdir": "linux-64", + "timestamp": 1516832315827, + "version": "1.14.0" + }, + "numpy-1.14.0-py36ha266831_2.conda": { + "build": "py36ha266831_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "390716df84af730d0bd2875d55c33bf1", + "name": "numpy", + "sha256": "fcde73b8598b5ba00408972875cde970a4e789a8f19499aadfcfc86e16e2df5c", + "size": 3383872, + "subdir": "linux-64", + "timestamp": 1520447663083, + "version": "1.14.0" + }, + "numpy-1.14.1-py27_nomklh5cab86c_2.conda": { + "build": "py27_nomklh5cab86c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "f4857530b43ad28dc0927a0719785c40", + "name": "numpy", + "sha256": "3da69b72c650ccbd0c1a2b0b0e86a30ddac1816b1b6ce9ebda4a6e1e50398f85", + "size": 3378075, + "subdir": "linux-64", + "timestamp": 1520453354669, + "version": "1.14.1" + }, + "numpy-1.14.1-py27_nomklh7cdd4dd_1.conda": { + "build": "py27_nomklh7cdd4dd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "b8bc3c6bc942054a94052cf0689e9f9c", + "name": "numpy", + "sha256": "ef08a44df1ecefbeb8d9beffb65c5b9a7fdd95336d37538aa4986e4c8367fb6b", + "size": 3378213, + "subdir": "linux-64", + "timestamp": 1519238005628, + "version": "1.14.1" + }, + "numpy-1.14.1-py27h3dfced4_1.conda": { + "build": "py27h3dfced4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "fabaadc2c447d5bea23fa19a45295933", + "name": "numpy", + "sha256": "7366dadba824d58203096168ff1efe74ef9ad89c48737fd60f9dbcf83c50dab4", + "size": 3355329, + "subdir": "linux-64", + "timestamp": 1519225906866, + "version": "1.14.1" + }, + "numpy-1.14.1-py27ha266831_2.conda": { + "build": "py27ha266831_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "109b26cb80236cd4dc552b695db8c6d6", + "name": "numpy", + "sha256": "d5c1fc7bdda9a8b2173296fd0998eb4904ff54773d6ad807c46485373316a878", + "size": 3381737, + "subdir": "linux-64", + "timestamp": 1520453527834, + "version": "1.14.1" + }, + "numpy-1.14.1-py35_nomklh5cab86c_2.conda": { + "build": "py35_nomklh5cab86c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "702a7ba825d688406b11a7d46bea8bf2", + "name": "numpy", + "sha256": "bbc2dd0c1c8cc1781a4c61b9e142c872ce017512e8752918f486d89ef8ccd820", + "size": 3422515, + "subdir": "linux-64", + "timestamp": 1520453498981, + "version": "1.14.1" + }, + "numpy-1.14.1-py35_nomklh7cdd4dd_1.conda": { + "build": "py35_nomklh7cdd4dd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "8f28d82bc67264364b05bc4ec542c292", + "name": "numpy", + "sha256": "b568ed30963dec774c417baad11b17ed05fd9a5a27e98e826fc47b493e283d72", + "size": 3398784, + "subdir": "linux-64", + "timestamp": 1519237980921, + "version": "1.14.1" + }, + "numpy-1.14.1-py35h3dfced4_1.conda": { + "build": "py35h3dfced4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "4550e89df3c9185dfcd4fd1a8457bec9", + "name": "numpy", + "sha256": "ff12a03ac446b9a70f844a9e6fea0a5adf8d3beafd11fe8457291b0b984ad008", + "size": 3399588, + "subdir": "linux-64", + "timestamp": 1519178485319, + "version": "1.14.1" + }, + "numpy-1.14.1-py35ha266831_2.conda": { + "build": "py35ha266831_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "cd63b45bedf4bcfcc1776164f707855e", + "name": "numpy", + "sha256": "2d9ac2f0c7ab1d1068c17f4a0ccd2261cff430c7bd11de1d40d7131c373810ff", + "size": 3426176, + "subdir": "linux-64", + "timestamp": 1520453708805, + "version": "1.14.1" + }, + "numpy-1.14.1-py36_nomklh5cab86c_2.conda": { + "build": "py36_nomklh5cab86c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "af2bfceaf1b7246a14a17e3b12c90190", + "name": "numpy", + "sha256": "6ce747f6d90b6ad5cc2075f6e45ac23cbc82cb50e537c62474cd6f2b6ba7688c", + "size": 3411096, + "subdir": "linux-64", + "timestamp": 1520453670284, + "version": "1.14.1" + }, + "numpy-1.14.1-py36_nomklh7cdd4dd_1.conda": { + "build": "py36_nomklh7cdd4dd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "0f7265d2ae3d9058370c661ea691de56", + "name": "numpy", + "sha256": "6d65b31cc4e761a96c33cb1c0f538bfc26250bd33c4177399bff894c075f77bb", + "size": 3389245, + "subdir": "linux-64", + "timestamp": 1519238005310, + "version": "1.14.1" + }, + "numpy-1.14.1-py36h3dfced4_1.conda": { + "build": "py36h3dfced4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "63daaad5097ed2174a2e1b33b452ac5a", + "name": "numpy", + "sha256": "df4d688125edfabcdc7ea10a553d619d86b6aef876e787b7da71146a59011b03", + "size": 3415003, + "subdir": "linux-64", + "timestamp": 1519178338176, + "version": "1.14.1" + }, + "numpy-1.14.1-py36ha266831_2.conda": { + "build": "py36ha266831_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "f3606bd995a0c451b12fb7543789f14f", + "name": "numpy", + "sha256": "c690555e88e06cc48a009edbc6f1add7e5d18301b262a368ae4f7ccb5d56e23e", + "size": 3390898, + "subdir": "linux-64", + "timestamp": 1520453600684, + "version": "1.14.1" + }, + "numpy-1.14.2-py27_nomklh2b20989_0.conda": { + "build": "py27_nomklh2b20989_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "8cb4c1b3f6b1301a63aa6126a3c1e1f8", + "name": "numpy", + "sha256": "41fbfae595fe5ef7f995283252814108f6891a84c1c9fa9e4c862f9d337aa84e", + "size": 3354347, + "subdir": "linux-64", + "timestamp": 1520892520349, + "version": "1.14.2" + }, + "numpy-1.14.2-py27_nomklh2b20989_1.conda": { + "build": "py27_nomklh2b20989_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "b930db85044f5c173522a259dde94af2", + "name": "numpy", + "sha256": "de951827deda7c49b625c42bfe4b201fc5ad74e5b74e352a59a837f994a6e977", + "size": 3404180, + "subdir": "linux-64", + "timestamp": 1521814843401, + "version": "1.14.2" + }, + "numpy-1.14.2-py27hdbf6ddf_0.conda": { + "build": "py27hdbf6ddf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "be28e2396a747744393deff695005861", + "name": "numpy", + "sha256": "16e3615a143e6a0fdad9d3220fd22d7f4bcc83e4fa10d56fbc4b1e9ddb5629a3", + "size": 3358658, + "subdir": "linux-64", + "timestamp": 1520892821484, + "version": "1.14.2" + }, + "numpy-1.14.2-py27hdbf6ddf_1.conda": { + "build": "py27hdbf6ddf_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "mkl_fft", + "mkl_random", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "a3109a0acc0263d039f8e9ba62e01afd", + "name": "numpy", + "sha256": "1e6e5095bc67af49d0f3c7dc86b3e9192f9c600cec0b2eed8cd8c650d251dcf6", + "size": 3455814, + "subdir": "linux-64", + "timestamp": 1521815144772, + "version": "1.14.2" + }, + "numpy-1.14.2-py35_nomklh2b20989_0.conda": { + "build": "py35_nomklh2b20989_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "f6beab6ef63af5c621d8f77227a9a0c1", + "name": "numpy", + "sha256": "1ca2de70c43ce7758af29296238838eddb2dd195c74b2eb7227277330aa9a2af", + "size": 3423958, + "subdir": "linux-64", + "timestamp": 1520892611584, + "version": "1.14.2" + }, + "numpy-1.14.2-py35_nomklh2b20989_1.conda": { + "build": "py35_nomklh2b20989_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "6e285537e4b961ba9a1149159c8f3a41", + "name": "numpy", + "sha256": "31075c5d4d665ed3922ef919aae2550227d32a53d3152e72a7272494ed1930b4", + "size": 3424653, + "subdir": "linux-64", + "timestamp": 1521814956308, + "version": "1.14.2" + }, + "numpy-1.14.2-py35hdbf6ddf_0.conda": { + "build": "py35hdbf6ddf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "a4d1e402625ed888f6bac8b33ca28eb3", + "name": "numpy", + "sha256": "4d390f158bf7c5908d2d771688532f668d7eb8ece51d270abee72eb7198a16da", + "size": 3426226, + "subdir": "linux-64", + "timestamp": 1520952936786, + "version": "1.14.2" + }, + "numpy-1.14.2-py35hdbf6ddf_1.conda": { + "build": "py35hdbf6ddf_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "mkl_fft", + "mkl_random", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "9eeb7823ba9f2699a7c4d82c222e008d", + "name": "numpy", + "sha256": "0b41475d609156bd67438e7834355bf1582c62d207637e60555f0d0f57abfbde", + "size": 3474519, + "subdir": "linux-64", + "timestamp": 1521815123684, + "version": "1.14.2" + }, + "numpy-1.14.2-py36_nomklh2b20989_0.conda": { + "build": "py36_nomklh2b20989_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "672b23240cb343085d51ba8e7e8dac70", + "name": "numpy", + "sha256": "f5259a1598b14887c8795a70c11e4c9ec72d392d57fb92d72042f6ab1feba77b", + "size": 3389262, + "subdir": "linux-64", + "timestamp": 1520892136072, + "version": "1.14.2" + }, + "numpy-1.14.2-py36_nomklh2b20989_1.conda": { + "build": "py36_nomklh2b20989_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "ae2c821067c78b7161e5110f8577f6ff", + "name": "numpy", + "sha256": "449f31f60c04119746ce45d6cdb4d7664ed2155e4c84da30ff7a454e64ea4c11", + "size": 3416724, + "subdir": "linux-64", + "timestamp": 1521814953953, + "version": "1.14.2" + }, + "numpy-1.14.2-py36hdbf6ddf_0.conda": { + "build": "py36hdbf6ddf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "9080ba8d85efa661c3af3a789be11d47", + "name": "numpy", + "sha256": "c7d361dee02345517d028bee647c295ef0ba869257fe6337cb2bb2968c5234d5", + "size": 3391643, + "subdir": "linux-64", + "timestamp": 1520892861165, + "version": "1.14.2" + }, + "numpy-1.14.2-py36hdbf6ddf_1.conda": { + "build": "py36hdbf6ddf_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "mkl_fft", + "mkl_random", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "d8b3a5983320d8a3197ca6850edb96e7", + "name": "numpy", + "sha256": "dcea6aa16344d3d129390c9c21b8f786d37b6112e9781021e4207521762946a9", + "size": 3467219, + "subdir": "linux-64", + "timestamp": 1521815124384, + "version": "1.14.2" + }, + "numpy-1.14.3-py27h28100ab_1.conda": { + "build": "py27h28100ab_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.3 py27h0ea5e3f_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4bdbb4215281e9cf20e53d246d61e307", + "name": "numpy", + "sha256": "763855c9319ef0584047e44638c3da1ca37a1d1956da09e1d7be264e1f9c6e73", + "size": 40099, + "subdir": "linux-64", + "timestamp": 1526858657771, + "version": "1.14.3" + }, + "numpy-1.14.3-py27hcd700cb_1.conda": { + "build": "py27hcd700cb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.3 py27h9be14a7_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "336280bccb6a8188ec296d9569d595de", + "name": "numpy", + "sha256": "1b278d52bd432ddb002b91297c240606e68081e23c1fbfd3d956c03045568c65", + "size": 40197, + "subdir": "linux-64", + "timestamp": 1526859343221, + "version": "1.14.3" + }, + "numpy-1.14.3-py35h28100ab_1.conda": { + "build": "py35h28100ab_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.3 py35h0ea5e3f_1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8dd605ce5f1a317bacec4816152fe4c0", + "name": "numpy", + "sha256": "f9ae85045db9234e5c91f4f7aa635aeb0bc67d37feda4074b8023340059c9c76", + "size": 40119, + "subdir": "linux-64", + "timestamp": 1526858708819, + "version": "1.14.3" + }, + "numpy-1.14.3-py35hcd700cb_1.conda": { + "build": "py35hcd700cb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.3 py35h9be14a7_1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cb5e03779be617ab83171694d775de64", + "name": "numpy", + "sha256": "091dac76127d06cb27d143ae175d220633b7ad631d2999e2be4c7ebff5821ead", + "size": 40088, + "subdir": "linux-64", + "timestamp": 1526859360035, + "version": "1.14.3" + }, + "numpy-1.14.3-py36h28100ab_1.conda": { + "build": "py36h28100ab_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.3 py36h0ea5e3f_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1861ff55a60e3305cc99eae526fa5c28", + "name": "numpy", + "sha256": "fa6a566e8feb24adda620412ae22599ca5ba5e63b61d5fdb1416ab288cc39e46", + "size": 39999, + "subdir": "linux-64", + "timestamp": 1526858552443, + "version": "1.14.3" + }, + "numpy-1.14.3-py36hcd700cb_1.conda": { + "build": "py36hcd700cb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.3 py36h9be14a7_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "eb5a88395d3bcaaa1f292dfd547f2d03", + "name": "numpy", + "sha256": "96ab98dd63e6d907490ef45f9ecc1ed04331c709d3014c304d17a2b557dc965f", + "size": 40176, + "subdir": "linux-64", + "timestamp": 1526859008604, + "version": "1.14.3" + }, + "numpy-1.14.4-py27h28100ab_0.conda": { + "build": "py27h28100ab_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.4 py27h2b20989_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2913d28e2c3df7382ed9f264530e5d8a", + "name": "numpy", + "sha256": "a335553e6189be3b4d3ccdd78360122e3d9b3c65e9507251e0ae1c0efddcb880", + "size": 91150, + "subdir": "linux-64", + "timestamp": 1528829253124, + "version": "1.14.4" + }, + "numpy-1.14.4-py27hcd700cb_0.conda": { + "build": "py27hcd700cb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.4 py27hdbf6ddf_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "360221670b95dce7690c0e848ef03783", + "name": "numpy", + "sha256": "60fd3ef3202550479b61784e49a086926b8ae30061b6fba610c49c16438e1cd5", + "size": 89987, + "subdir": "linux-64", + "timestamp": 1528829711977, + "version": "1.14.4" + }, + "numpy-1.14.4-py35h28100ab_0.conda": { + "build": "py35h28100ab_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.4 py35h2b20989_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3989914f3ddede86965470a346370dfc", + "name": "numpy", + "sha256": "3a4547834c2c897b7d54f8259f548fd9473cf43bd09725845c9a6b5abe889687", + "size": 91141, + "subdir": "linux-64", + "timestamp": 1528829305327, + "version": "1.14.4" + }, + "numpy-1.14.4-py35hcd700cb_0.conda": { + "build": "py35hcd700cb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.4 py35hdbf6ddf_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "324c73807572aaefb49ea27a588a0e9b", + "name": "numpy", + "sha256": "1cb4992c648611cf0e8a4f5f4811b6aa4e0fd11d0f1afcd59ec90bbb4d93cf22", + "size": 91254, + "subdir": "linux-64", + "timestamp": 1528829824740, + "version": "1.14.4" + }, + "numpy-1.14.4-py36h28100ab_0.conda": { + "build": "py36h28100ab_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.4 py36h2b20989_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a624675e85b39d88e68cea6eb14afd1b", + "name": "numpy", + "sha256": "50557971c48b7d47af9b8a0ca4d981c8c9b14da827c739323dc48600b68e1306", + "size": 89903, + "subdir": "linux-64", + "timestamp": 1528829274095, + "version": "1.14.4" + }, + "numpy-1.14.4-py36hcd700cb_0.conda": { + "build": "py36hcd700cb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.4 py36hdbf6ddf_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0015563ca1ef016b956b52ce86f6151f", + "name": "numpy", + "sha256": "5e9143538d87793e954eeda4bfe45d7237aa65bcd8a7313b68f1e878e7ce6cc3", + "size": 91267, + "subdir": "linux-64", + "timestamp": 1528829733692, + "version": "1.14.4" + }, + "numpy-1.14.5-py27h1b885b7_4.conda": { + "build": "py27h1b885b7_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py27hdbf6ddf_4", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3eb111db3756e93735a5e3add1724795", + "name": "numpy", + "sha256": "554c536853abeda3840142b216b283232991bf85bc7e60806f30c82e184b9e79", + "size": 34807, + "subdir": "linux-64", + "timestamp": 1531326775194, + "version": "1.14.5" + }, + "numpy-1.14.5-py27h28100ab_0.conda": { + "build": "py27h28100ab_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py27h2b20989_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "47aa1a8cd3d9f3291766660349cf365b", + "name": "numpy", + "sha256": "aa03032377a5efcaa42819a4b4bdfc4eb3c0069ffb91bd0c9c4fd4ea872e3295", + "size": 89835, + "subdir": "linux-64", + "timestamp": 1528900955568, + "version": "1.14.5" + }, + "numpy-1.14.5-py27h28100ab_1.conda": { + "build": "py27h28100ab_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py27h2b20989_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "eb9540c6a021820d6e29c446dc53a9c1", + "name": "numpy", + "sha256": "653f59e058be73bbffb6c53ecd631bc92a759d945afeaed3fde51e61f6b0536b", + "size": 89690, + "subdir": "linux-64", + "timestamp": 1530354204566, + "version": "1.14.5" + }, + "numpy-1.14.5-py27h28100ab_2.conda": { + "build": "py27h28100ab_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py27h2b20989_2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "177462c9c3573240dfec3a13505006e3", + "name": "numpy", + "sha256": "76c9c4d2948e9e1806cafab27afa6746764651ec451b6f273c738fdf42bf9b8b", + "size": 90486, + "subdir": "linux-64", + "timestamp": 1530382372341, + "version": "1.14.5" + }, + "numpy-1.14.5-py27h28100ab_3.conda": { + "build": "py27h28100ab_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py27h2b20989_3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a37990af8a38a5576f20d70b1b0ac64d", + "name": "numpy", + "sha256": "adc58e6d544362556f562f09a35709890d19280103af6746494cda2036bd9217", + "size": 90552, + "subdir": "linux-64", + "timestamp": 1530553808550, + "version": "1.14.5" + }, + "numpy-1.14.5-py27h2aefc1b_4.conda": { + "build": "py27h2aefc1b_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py27h2b20989_4", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4947edde7161c8181789d6229c4634af", + "name": "numpy", + "sha256": "17bce5a72dc7aeb736c0e7cc46e2f40b3079501e3ae6021623302bff90f3e37d", + "size": 34790, + "subdir": "linux-64", + "timestamp": 1531326447057, + "version": "1.14.5" + }, + "numpy-1.14.5-py27hcd700cb_0.conda": { + "build": "py27hcd700cb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py27hdbf6ddf_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "49bdf9f99dbb8109cffcd3f6967db256", + "name": "numpy", + "sha256": "7e73461df063551a53df4a501d02349b9b60f87ebe32ca3739673a3c1c0bcdb9", + "size": 90887, + "subdir": "linux-64", + "timestamp": 1528901280225, + "version": "1.14.5" + }, + "numpy-1.14.5-py27hcd700cb_1.conda": { + "build": "py27hcd700cb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py27hdbf6ddf_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a2717cbd1a24d799f02a5ea8c07ae57f", + "name": "numpy", + "sha256": "c9d39a59c18027be18682253b5aab6e9a1dccb18483ba0460f55949b47ff5848", + "size": 89795, + "subdir": "linux-64", + "timestamp": 1530353552583, + "version": "1.14.5" + }, + "numpy-1.14.5-py27hcd700cb_2.conda": { + "build": "py27hcd700cb_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py27hdbf6ddf_2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a1ca8e9675d85b71bcbf6ce681246a17", + "name": "numpy", + "sha256": "74762c648cd6d6bfabca6004143fd94bf2d53b64f26ff233304cace40b04d747", + "size": 90554, + "subdir": "linux-64", + "timestamp": 1530382988516, + "version": "1.14.5" + }, + "numpy-1.14.5-py27hcd700cb_3.conda": { + "build": "py27hcd700cb_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py27hdbf6ddf_3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e89527e343be5a379f48274eb8d80b0b", + "name": "numpy", + "sha256": "43b59d85a9cc5997bf97c5fdadcfd36b2a44744dc4fba03457dd9d7e936718ac", + "size": 89572, + "subdir": "linux-64", + "timestamp": 1530554329108, + "version": "1.14.5" + }, + "numpy-1.14.5-py35h1b885b7_4.conda": { + "build": "py35h1b885b7_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py35hdbf6ddf_4", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "474d947ce3943d5bb8d243560bf106cc", + "name": "numpy", + "sha256": "4ab870b47b1a6eb4dbf337d9b7e3634129929e55beb79b90e7088d99814988a6", + "size": 34768, + "subdir": "linux-64", + "timestamp": 1534346990064, + "version": "1.14.5" + }, + "numpy-1.14.5-py35h2aefc1b_4.conda": { + "build": "py35h2aefc1b_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py35h2b20989_4", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "580216345bceebf99fe147c34fb5f21b", + "name": "numpy", + "sha256": "67df8923ea444dc7b78a7f3fbdf91874f737165bcc63d60c5ec2f52bff792bdb", + "size": 34763, + "subdir": "linux-64", + "timestamp": 1534347292966, + "version": "1.14.5" + }, + "numpy-1.14.5-py35hcd700cb_0.conda": { + "build": "py35hcd700cb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py35hdbf6ddf_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "507566330aa8866b9e3fcce7908319ed", + "name": "numpy", + "sha256": "dda5c56a911ebf772366c71a010021d1c40a8f61459321068b36b87d4593fd0f", + "size": 89908, + "subdir": "linux-64", + "timestamp": 1528901303482, + "version": "1.14.5" + }, + "numpy-1.14.5-py36h1b885b7_4.conda": { + "build": "py36h1b885b7_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py36hdbf6ddf_4", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fdac340d45be97300d354352d1d569f5", + "name": "numpy", + "sha256": "1ca687574a0021b29b5c8d834d7e429b64670a3a730e5780f15d4afd28285afa", + "size": 34760, + "subdir": "linux-64", + "timestamp": 1531342872355, + "version": "1.14.5" + }, + "numpy-1.14.5-py36h28100ab_0.conda": { + "build": "py36h28100ab_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py36h2b20989_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d59d087425f1cdafc0033a67784bfffd", + "name": "numpy", + "sha256": "fb9e4b709e76056af24224adf9f24db985843cef4381546d687c725fd59cf249", + "size": 89844, + "subdir": "linux-64", + "timestamp": 1528900503265, + "version": "1.14.5" + }, + "numpy-1.14.5-py36h28100ab_1.conda": { + "build": "py36h28100ab_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py36h2b20989_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9b10a4d8e84f14c808667b4b95189bcf", + "name": "numpy", + "sha256": "f7a77bacc6fc6299f1e5d3f48f1e681e106495621b17ca1eedc0ba5880db2481", + "size": 89726, + "subdir": "linux-64", + "timestamp": 1530353095209, + "version": "1.14.5" + }, + "numpy-1.14.5-py36h28100ab_2.conda": { + "build": "py36h28100ab_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py36h2b20989_2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f8b0ed36c7db28234a0e19d16d2c6bad", + "name": "numpy", + "sha256": "e0d397f238366580066cc79b1de0658a335adaeff336832cf8d76aadd4770421", + "size": 90497, + "subdir": "linux-64", + "timestamp": 1530382418267, + "version": "1.14.5" + }, + "numpy-1.14.5-py36h28100ab_3.conda": { + "build": "py36h28100ab_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py36h2b20989_3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "35e10d00e5c3de56a43a9e13e033345c", + "name": "numpy", + "sha256": "52d79ad9def695bc8e92b21a1cd42ee5fa0ef45f71dd6a4e6ab5b28b9ef1d6ea", + "size": 89573, + "subdir": "linux-64", + "timestamp": 1530552845169, + "version": "1.14.5" + }, + "numpy-1.14.5-py36h2aefc1b_4.conda": { + "build": "py36h2aefc1b_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py36h2b20989_4", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a25e54a3ac7ffe7b4f7ed947c6dcf3af", + "name": "numpy", + "sha256": "4b1e69b35976b7a8148ff51c7c5f31310d095d6cac3504ef6b853324f71ea686", + "size": 34722, + "subdir": "linux-64", + "timestamp": 1531327711917, + "version": "1.14.5" + }, + "numpy-1.14.5-py36hcd700cb_0.conda": { + "build": "py36hcd700cb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py36hdbf6ddf_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a1ce6ff5d329cb709a67d6ab88fe7cf0", + "name": "numpy", + "sha256": "a36713b7575876ea4a84f72cb9e33795d17492b768ed1446dc79e1fd0d6d6988", + "size": 89900, + "subdir": "linux-64", + "timestamp": 1528901008333, + "version": "1.14.5" + }, + "numpy-1.14.5-py36hcd700cb_1.conda": { + "build": "py36hcd700cb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py36hdbf6ddf_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2144d541641b8827068497252a806a41", + "name": "numpy", + "sha256": "1de173044731ea2a5ae0039619c9a18a28dfbdd5fe6860365eab97d9d1251f39", + "size": 90752, + "subdir": "linux-64", + "timestamp": 1530353606379, + "version": "1.14.5" + }, + "numpy-1.14.5-py36hcd700cb_2.conda": { + "build": "py36hcd700cb_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py36hdbf6ddf_2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ccf434b389937ab521342eb279c9ceb9", + "name": "numpy", + "sha256": "ed24441db06588e65c816f50949801f3e26528a9ee75341969858e8b719c0a08", + "size": 90533, + "subdir": "linux-64", + "timestamp": 1530383344134, + "version": "1.14.5" + }, + "numpy-1.14.5-py36hcd700cb_3.conda": { + "build": "py36hcd700cb_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py36hdbf6ddf_3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6fc8da09ea4617d0d7f57fd3905c8352", + "name": "numpy", + "sha256": "43d7a631764f0205a9e391d6c9c372af8ea81a0ba0ee2e648cf47dbee84c0443", + "size": 89578, + "subdir": "linux-64", + "timestamp": 1530553452313, + "version": "1.14.5" + }, + "numpy-1.14.5-py37h1b885b7_4.conda": { + "build": "py37h1b885b7_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py37hdbf6ddf_4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "46c739c5a8ffa130e23aad6c6a097668", + "name": "numpy", + "sha256": "d9100444714a1622d4d468ceaae16bfc55ed19bee9a26fc1786aa8d0837b7c21", + "size": 34740, + "subdir": "linux-64", + "timestamp": 1531327401991, + "version": "1.14.5" + }, + "numpy-1.14.5-py37h28100ab_1.conda": { + "build": "py37h28100ab_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py37h2b20989_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4ad7f93b98683f55a3a4b8fed1f2f610", + "name": "numpy", + "sha256": "7b10ff34bcbb2bba221e3d2c187e471a82200c77f02d50eaac92a243ecbe6c1f", + "size": 89741, + "subdir": "linux-64", + "timestamp": 1530353347449, + "version": "1.14.5" + }, + "numpy-1.14.5-py37h28100ab_2.conda": { + "build": "py37h28100ab_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py37h2b20989_2", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "400e33a6a8b289e99dc6133113c2d60e", + "name": "numpy", + "sha256": "398ed8fb8196916d1148185ac3e98f6de5a144f0d358317c61935fdd48e32b24", + "size": 90492, + "subdir": "linux-64", + "timestamp": 1530382891686, + "version": "1.14.5" + }, + "numpy-1.14.5-py37h28100ab_3.conda": { + "build": "py37h28100ab_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py37h2b20989_3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4ea27dd92f7801ab5b2d62e55585ac79", + "name": "numpy", + "sha256": "78544a4cc216fa2e970f680f495e4f274448aee5d09fcfc3b7b9232b3a56d8a0", + "size": 90553, + "subdir": "linux-64", + "timestamp": 1530553165211, + "version": "1.14.5" + }, + "numpy-1.14.5-py37h2aefc1b_4.conda": { + "build": "py37h2aefc1b_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.5 py37h2b20989_4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "47893d4e7fe3db4421457601dd5f7a8b", + "name": "numpy", + "sha256": "f308e47f2daec8172bbdf1e0c888c809908cfb9ddbfb805d4d019f313620f2c7", + "size": 34707, + "subdir": "linux-64", + "timestamp": 1531327081227, + "version": "1.14.5" + }, + "numpy-1.14.5-py37hcd700cb_1.conda": { + "build": "py37hcd700cb_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py37hdbf6ddf_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3b2d4fbdec3ea6922dcf069aca8bfd5b", + "name": "numpy", + "sha256": "0e7eb2a0d022e449574d288d4db7380b873ec0e3639ba1d19f83ed5917d6b988", + "size": 89803, + "subdir": "linux-64", + "timestamp": 1530353695727, + "version": "1.14.5" + }, + "numpy-1.14.5-py37hcd700cb_2.conda": { + "build": "py37hcd700cb_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py37hdbf6ddf_2", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "23682693ee9e13776021fedc366d2dac", + "name": "numpy", + "sha256": "4acd8ec8b4f1f8ca7df770bca900faacdf2805e8bb90a8f7f808bdea9fc083fd", + "size": 90563, + "subdir": "linux-64", + "timestamp": 1530383342192, + "version": "1.14.5" + }, + "numpy-1.14.5-py37hcd700cb_3.conda": { + "build": "py37hcd700cb_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.5 py37hdbf6ddf_3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "05c0904b7890ba51d8428b142b34878f", + "name": "numpy", + "sha256": "4c35d21b9e6f18087ca635a1997b9e2fad6135d030b6ebf1937aa4f8a7171b43", + "size": 89581, + "subdir": "linux-64", + "timestamp": 1530553452068, + "version": "1.14.5" + }, + "numpy-1.14.6-py27h3b04361_4.conda": { + "build": "py27h3b04361_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.6 py27h81de0dd_4", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a71979c6fdd16fcf9645bb4c947df246", + "name": "numpy", + "sha256": "0d3b4e73cc2857b2262a8d5bfd4a58a827541b02226828dcdcb338e8aa9ca21c", + "size": 45963, + "subdir": "linux-64", + "timestamp": 1538074664403, + "version": "1.14.6" + }, + "numpy-1.14.6-py27h3b04361_5.conda": { + "build": "py27h3b04361_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.6 py27hde5b4d6_5", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "397210139d1acf72fb79b4ddd680a607", + "name": "numpy", + "sha256": "092b3c030e795fd696fc0bc76dc4016a49b64d6d111290548376f6c0f5e5541b", + "size": 46392, + "subdir": "linux-64", + "timestamp": 1569339416130, + "version": "1.14.6" + }, + "numpy-1.14.6-py27hec00662_4.conda": { + "build": "py27hec00662_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.6 py27h2f8d375_4", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4fed0022aeb10896ba8fbb4679b48865", + "name": "numpy", + "sha256": "66fe3470d54ce2a7f9394743b3c14f192aafa88a85147054210d4fb1e5bbec0e", + "size": 45953, + "subdir": "linux-64", + "timestamp": 1538074873093, + "version": "1.14.6" + }, + "numpy-1.14.6-py27hec00662_5.conda": { + "build": "py27hec00662_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.6 py27h2f8d375_5", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fd7b8ca8056192d9cc47306b6efcd049", + "name": "numpy", + "sha256": "0b2811fbdebaf6c1fa16c5ee5be1c395b7a6ffcd3ff50eb48de0135802bcc9f7", + "size": 46276, + "subdir": "linux-64", + "timestamp": 1569339394947, + "version": "1.14.6" + }, + "numpy-1.14.6-py35h3b04361_4.conda": { + "build": "py35h3b04361_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.6 py35h81de0dd_4", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "003f656ddbf02426e423732399f6d594", + "name": "numpy", + "sha256": "83615cffefc554ccf255ead322cad1cf3c9720622e596680b2f14905bc472b9a", + "size": 45853, + "subdir": "linux-64", + "timestamp": 1538074936064, + "version": "1.14.6" + }, + "numpy-1.14.6-py35hec00662_4.conda": { + "build": "py35hec00662_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.6 py35h2f8d375_4", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2ed3dca8ec9ae1934a0f1d270030e002", + "name": "numpy", + "sha256": "b991d2e9dbba17f2a13680c94761c4661e0ac61183854cf882c981724fdb4d5f", + "size": 45833, + "subdir": "linux-64", + "timestamp": 1538074512547, + "version": "1.14.6" + }, + "numpy-1.14.6-py36h3b04361_4.conda": { + "build": "py36h3b04361_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.6 py36h81de0dd_4", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "15032b9908d3cd8a66d8799909841626", + "name": "numpy", + "sha256": "7b3f517b9241133a4d25e5c800f5e0af1f7d0900f152b1ed14ffe94de4a1ced1", + "size": 45975, + "subdir": "linux-64", + "timestamp": 1538075090719, + "version": "1.14.6" + }, + "numpy-1.14.6-py36h3b04361_5.conda": { + "build": "py36h3b04361_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.6 py36hde5b4d6_5", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bd9dd49e720ea31c1205602d19518adc", + "name": "numpy", + "sha256": "c1dfa79d5471bf70f0de0bdb11e2fc9b6e1e27053d4564bbe5d2dc4d24167c6f", + "size": 46375, + "subdir": "linux-64", + "timestamp": 1569339435883, + "version": "1.14.6" + }, + "numpy-1.14.6-py36hec00662_4.conda": { + "build": "py36hec00662_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.6 py36h2f8d375_4", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9a9aa12a5bbaf765607012b1f2ce6485", + "name": "numpy", + "sha256": "bc33cd9a018d7f67fbd2e63b69cbb34035e46755795a7907ae193361da9d599b", + "size": 45951, + "subdir": "linux-64", + "timestamp": 1538074863701, + "version": "1.14.6" + }, + "numpy-1.14.6-py36hec00662_5.conda": { + "build": "py36hec00662_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.6 py36h2f8d375_5", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "85c00cd952bd8f28275203f065cd922e", + "name": "numpy", + "sha256": "7b29751a152d6b60ca7514b74c3832456381b527f47be23e19e70c1a1a49e2ed", + "size": 46408, + "subdir": "linux-64", + "timestamp": 1569339285993, + "version": "1.14.6" + }, + "numpy-1.14.6-py37h3b04361_4.conda": { + "build": "py37h3b04361_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.6 py37h81de0dd_4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "707bd3524d6a69ef777ead0ee3f8309d", + "name": "numpy", + "sha256": "b36a295d2c632bf469bc18c6b50a6ac1065af758427c4ab7090d12bd284ef80e", + "size": 45996, + "subdir": "linux-64", + "timestamp": 1538074957728, + "version": "1.14.6" + }, + "numpy-1.14.6-py37h3b04361_5.conda": { + "build": "py37h3b04361_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.6 py37hde5b4d6_5", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f6db9173a1b9e52781a5974e275f5abf", + "name": "numpy", + "sha256": "948be63f238daf43ed879311b9f172fadec6a295de35c58cd3bf18c347f1958a", + "size": 46430, + "subdir": "linux-64", + "timestamp": 1569339435202, + "version": "1.14.6" + }, + "numpy-1.14.6-py37hec00662_4.conda": { + "build": "py37hec00662_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.6 py37h2f8d375_4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ff70ee0c966a9bf2c8c982d901cd3fe1", + "name": "numpy", + "sha256": "ac434bc9db7280e1e2dc328c92c4804bd4739e216f620ac879396058c3cc31d4", + "size": 45825, + "subdir": "linux-64", + "timestamp": 1538074424595, + "version": "1.14.6" + }, + "numpy-1.14.6-py37hec00662_5.conda": { + "build": "py37hec00662_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.6 py37h2f8d375_5", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "648c81c880553e2deb7d3c11d4280cb6", + "name": "numpy", + "sha256": "d38b43e99a93fdb263fe21f7c53efe5de23678abc947f9eeb071f7adab610922", + "size": 46464, + "subdir": "linux-64", + "timestamp": 1569339389689, + "version": "1.14.6" + }, + "numpy-1.14.6-py38h056ac22_4.conda": { + "build": "py38h056ac22_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.14.6 py38hde5b4d6_4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c3b412bc1a5e4343c36703824d7f312a", + "name": "numpy", + "sha256": "4688c3c7a5f3b1e3482cfdbc5ef9a6e0237b6047615583a0801f051b6531a7ce", + "size": 35659, + "subdir": "linux-64", + "timestamp": 1574081552811, + "version": "1.14.6" + }, + "numpy-1.14.6-py38h1e1a116_4.conda": { + "build": "py38h1e1a116_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.14.6 py38h2f8d375_4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1738b585b06a61974c7225f9a99bdeef", + "name": "numpy", + "sha256": "93c364609c95bd5c222e2c7eb9fb5c89e19fed47e8c6334d0d6280e8a4fcb0e4", + "size": 35607, + "subdir": "linux-64", + "timestamp": 1574081295349, + "version": "1.14.6" + }, + "numpy-1.15.0-py27h1b885b7_0.conda": { + "build": "py27h1b885b7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.0 py27h3dfced4_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1804895c2d89e3d245a0b0e978cfe544", + "name": "numpy", + "sha256": "8d6cd02beb825fa3f862e494c2afbe05a0e7ee849c8147fe3e1de3e9fd38a3be", + "size": 35062, + "subdir": "linux-64", + "timestamp": 1532704187980, + "version": "1.15.0" + }, + "numpy-1.15.0-py27h2aefc1b_0.conda": { + "build": "py27h2aefc1b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.15.0 py27h7cdd4dd_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "330894b75e6d5f4810473920d3bf8dfd", + "name": "numpy", + "sha256": "64ac0223324164ec0ba79adeb6025e4fc2beba2d2958bac2d08cfe724b8c4fb8", + "size": 34930, + "subdir": "linux-64", + "timestamp": 1532703541812, + "version": "1.15.0" + }, + "numpy-1.15.0-py35h1b885b7_0.conda": { + "build": "py35h1b885b7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.0 py35h3dfced4_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "25cc1e2d8481df61dff932fb5e730fd4", + "name": "numpy", + "sha256": "a6076434aabffac66036673733b29d0a5fcb5ed61376031ee18c8d307e738232", + "size": 35066, + "subdir": "linux-64", + "timestamp": 1532704545516, + "version": "1.15.0" + }, + "numpy-1.15.0-py35h2aefc1b_0.conda": { + "build": "py35h2aefc1b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.15.0 py35h7cdd4dd_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "752840b818bf0ae09e0b6654463f9cfe", + "name": "numpy", + "sha256": "5c0365934c14df32c62127ee6a5c14916047e4d2670ccf4cceaed2553e5d7539", + "size": 34926, + "subdir": "linux-64", + "timestamp": 1532703769720, + "version": "1.15.0" + }, + "numpy-1.15.0-py36h1b885b7_0.conda": { + "build": "py36h1b885b7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.0 py36h3dfced4_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "95411e001f25b744e6febdbbb10e8599", + "name": "numpy", + "sha256": "e16a0a4d5d811e4a7658c330709ec7a8eee0b08c8b9409ee5407b3f049c92250", + "size": 34982, + "subdir": "linux-64", + "timestamp": 1532704518202, + "version": "1.15.0" + }, + "numpy-1.15.0-py36h2aefc1b_0.conda": { + "build": "py36h2aefc1b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.15.0 py36h7cdd4dd_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "142df56ad47ef373b2841a0b9b89ed6d", + "name": "numpy", + "sha256": "4a4cfb96a5a4d723d483e5f49fd8416eb872745f72ed36364e5982650d8f29fa", + "size": 34989, + "subdir": "linux-64", + "timestamp": 1532703550992, + "version": "1.15.0" + }, + "numpy-1.15.0-py37h1b885b7_0.conda": { + "build": "py37h1b885b7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.0 py37h3dfced4_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0c4b11a3086caffed884ac72c209221e", + "name": "numpy", + "sha256": "e3dcaa617f8046db26a6674268fbe947aa0cb4c8a485ba60c96738958152fcf2", + "size": 34985, + "subdir": "linux-64", + "timestamp": 1532704587756, + "version": "1.15.0" + }, + "numpy-1.15.0-py37h2aefc1b_0.conda": { + "build": "py37h2aefc1b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.15.0 py37h7cdd4dd_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "35cd6e21cf52d67d9058c1730a01e2cb", + "name": "numpy", + "sha256": "15d6252bb4adf5c6a7b1934d48936b77ef1b794e4a5441e734b64df6f380e47d", + "size": 35016, + "subdir": "linux-64", + "timestamp": 1532703757997, + "version": "1.15.0" + }, + "numpy-1.15.1-py27h1d66e8a_0.conda": { + "build": "py27h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.1 py27h81de0dd_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3aed14e7897e7e19cce5a4de77aaf198", + "name": "numpy", + "sha256": "a39967e2d543961c21f8b5d3f1dd68be71f5f3ee03cc17c5bf0ded3269127a1e", + "size": 36600, + "subdir": "linux-64", + "timestamp": 1535407582730, + "version": "1.15.1" + }, + "numpy-1.15.1-py27h3b04361_0.conda": { + "build": "py27h3b04361_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.1 py27h81de0dd_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d526df07442f9e22f221a8a4da4999e1", + "name": "numpy", + "sha256": "e06fa3382eca2aae4a265c0e534975ec60a96b5f592fc9d01e7288c77e834a64", + "size": 36539, + "subdir": "linux-64", + "timestamp": 1535389873335, + "version": "1.15.1" + }, + "numpy-1.15.1-py27h99e49ec_0.conda": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.1 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0926053c1c544f57a732945a11b85425", + "name": "numpy", + "sha256": "ce2577c429ea8b362f215b2c5797467a4fc8a33f85c6e05563e797b795810518", + "size": 36685, + "subdir": "linux-64", + "timestamp": 1536895334350, + "version": "1.15.1" + }, + "numpy-1.15.1-py27hb510916_0.conda": { + "build": "py27hb510916_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.1 py27h74e8950_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ca1c4b867fb67c9867722da2e09ab51b", + "name": "numpy", + "sha256": "32d483da17f47d480ac08f293a63e62ac2f35de7af8fd91f16189a8f7565c104", + "size": 36519, + "subdir": "linux-64", + "timestamp": 1535407056627, + "version": "1.15.1" + }, + "numpy-1.15.1-py27hec00662_0.conda": { + "build": "py27hec00662_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.15.1 py27h74e8950_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dc658a08b0313a53f8f837b779d89633", + "name": "numpy", + "sha256": "0dfb1f6744e147ae320122d56c6c921d6115bafe3b4305677655f8660b014fce", + "size": 36484, + "subdir": "linux-64", + "timestamp": 1535389548249, + "version": "1.15.1" + }, + "numpy-1.15.1-py35h1d66e8a_0.conda": { + "build": "py35h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.1 py35h81de0dd_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2edd78b03c90258ad356ac0b75ebfcbf", + "name": "numpy", + "sha256": "b2056ddeded9e8aeb6f7cc7f0977ccbc7332f93a88e8de0913c460e39610ad77", + "size": 36596, + "subdir": "linux-64", + "timestamp": 1535408278866, + "version": "1.15.1" + }, + "numpy-1.15.1-py35h3b04361_0.conda": { + "build": "py35h3b04361_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.1 py35h81de0dd_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "24b8a18db8b4a99e5d7e05a2e822e31a", + "name": "numpy", + "sha256": "23575baa3c681aa31cb84482a83a4dd9ce472ac09b41ddc5d803ef08fca517b6", + "size": 36541, + "subdir": "linux-64", + "timestamp": 1535389511765, + "version": "1.15.1" + }, + "numpy-1.15.1-py35h99e49ec_0.conda": { + "build": "py35h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.1 py35h2f8d375_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9d2dbee67f687607793d403676f7ac6e", + "name": "numpy", + "sha256": "15affe521d2937d763800ac40fb3d726364169dc927862c9f704d560977fa684", + "size": 36635, + "subdir": "linux-64", + "timestamp": 1536895286333, + "version": "1.15.1" + }, + "numpy-1.15.1-py35hb510916_0.conda": { + "build": "py35hb510916_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.1 py35h74e8950_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cb62265457a1d1640c45171eb2d2b2b1", + "name": "numpy", + "sha256": "f82bc27c68be8fe7cfd5563686b1df5c702d059f824c2b8d511139dab679ea3b", + "size": 36572, + "subdir": "linux-64", + "timestamp": 1535407049408, + "version": "1.15.1" + }, + "numpy-1.15.1-py35hec00662_0.conda": { + "build": "py35hec00662_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.15.1 py35h74e8950_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0e11155e68f036e0960528b7b72dd86c", + "name": "numpy", + "sha256": "3cb043e03b22425061a5cc00ffacb3471e84e183f0e064de6089f5b1d4924e43", + "size": 36485, + "subdir": "linux-64", + "timestamp": 1535389403990, + "version": "1.15.1" + }, + "numpy-1.15.1-py36h1d66e8a_0.conda": { + "build": "py36h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.1 py36h81de0dd_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "57517049a48686109d44d49214330ac4", + "name": "numpy", + "sha256": "a4a6a85d6e21cc116a3903d1b3b7179c65da4741c4c64e4afe2f72d9dc01b8ce", + "size": 36580, + "subdir": "linux-64", + "timestamp": 1535407129597, + "version": "1.15.1" + }, + "numpy-1.15.1-py36h3b04361_0.conda": { + "build": "py36h3b04361_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.1 py36h81de0dd_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "16fcf4bd277aa3b0a016de5c870b784b", + "name": "numpy", + "sha256": "a59d53e21f051fd54f363819d61289061613d271615c66349d066346112a5cdd", + "size": 36489, + "subdir": "linux-64", + "timestamp": 1535389881478, + "version": "1.15.1" + }, + "numpy-1.15.1-py36h99e49ec_0.conda": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.1 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2f316e8614fe22cd149f560d5655a4d1", + "name": "numpy", + "sha256": "5020707296f789c22b2eb30c82999d930a77702db1254c676c7d490a7dcce653", + "size": 36698, + "subdir": "linux-64", + "timestamp": 1536895336631, + "version": "1.15.1" + }, + "numpy-1.15.1-py36hb510916_0.conda": { + "build": "py36hb510916_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.1 py36h74e8950_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "87e9b5855d490894d0c803ff38790f3a", + "name": "numpy", + "sha256": "5a80e06d350b183d0649a68ea35ddd2bae29694a0eb227212868e6751822112b", + "size": 36559, + "subdir": "linux-64", + "timestamp": 1535407086031, + "version": "1.15.1" + }, + "numpy-1.15.1-py36hec00662_0.conda": { + "build": "py36hec00662_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.15.1 py36h74e8950_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0fbaea7d660499cba6b14087d044797c", + "name": "numpy", + "sha256": "b2825c6f8d1ac3e3ac31994b2cc2372d82ce6bcaa6713975739fd096478b5ea9", + "size": 36521, + "subdir": "linux-64", + "timestamp": 1535389603433, + "version": "1.15.1" + }, + "numpy-1.15.1-py37h1d66e8a_0.conda": { + "build": "py37h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.1 py37h81de0dd_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "02c23ed0196b23192f2e91c5bef063ce", + "name": "numpy", + "sha256": "d5475e9e382a35b91c21629bf225b86fc7c6970b3fef8bf86c016546dbbc2a8c", + "size": 36543, + "subdir": "linux-64", + "timestamp": 1535408275702, + "version": "1.15.1" + }, + "numpy-1.15.1-py37h3b04361_0.conda": { + "build": "py37h3b04361_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.1 py37h81de0dd_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c1a3a5bf47259ee58341c727db62cd91", + "name": "numpy", + "sha256": "db6e17eacf85357b0fe2b38aceb92a98d340e1e443e1df5ebfa52c1a49fde92c", + "size": 36549, + "subdir": "linux-64", + "timestamp": 1535389886591, + "version": "1.15.1" + }, + "numpy-1.15.1-py37h99e49ec_0.conda": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.1 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e37e2a2f3eeede753c90f23824fcc96a", + "name": "numpy", + "sha256": "8df4dce0babe4ec40bc37477032fbd6bcd24d949a7c77452ba27f064f6d4563a", + "size": 36693, + "subdir": "linux-64", + "timestamp": 1536895340717, + "version": "1.15.1" + }, + "numpy-1.15.1-py37hb510916_0.conda": { + "build": "py37hb510916_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.1 py37h74e8950_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6a7aaaabff0d24b6714305d795faf892", + "name": "numpy", + "sha256": "d208999253ae8800f353b1a71b1f9bfb6ee5b8c25471e0ce259a14605a92bb45", + "size": 36560, + "subdir": "linux-64", + "timestamp": 1535407102337, + "version": "1.15.1" + }, + "numpy-1.15.1-py37hec00662_0.conda": { + "build": "py37hec00662_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.15.1 py37h74e8950_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "72f7eb2b0e3ad1a8c4a116c1a24d4369", + "name": "numpy", + "sha256": "2132ddb6b9fd166f25b429baa88ba40076274c6c45ee238aa20bbb15d7ef7f84", + "size": 36470, + "subdir": "linux-64", + "timestamp": 1535389600937, + "version": "1.15.1" + }, + "numpy-1.15.2-py27h1d66e8a_0.conda": { + "build": "py27h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.2 py27h81de0dd_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5b8762acc6b4895d0750f0794d112130", + "name": "numpy", + "sha256": "1ac09b997ae6be2b08da249365498c0572c7617a9d7a3e5a7661167b5b98b86a", + "size": 47438, + "subdir": "linux-64", + "timestamp": 1538073714737, + "version": "1.15.2" + }, + "numpy-1.15.2-py27h1d66e8a_1.conda": { + "build": "py27h1d66e8a_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.2 py27h81de0dd_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cbdb94dbd5373aa64b8b9c34d6bcf83a", + "name": "numpy", + "sha256": "c5929ced54500dc024174ea894c39200da384f3f0331b8068515f77f20ebde43", + "size": 48136, + "subdir": "linux-64", + "timestamp": 1538500430792, + "version": "1.15.2" + }, + "numpy-1.15.2-py27h99e49ec_0.conda": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1db44ec09133e9946b52bfca3bbbc714", + "name": "numpy", + "sha256": "660f66e77f65ae349496931b020b0c5a4c501dbdacb120bf43c66c7f10405ded", + "size": 47402, + "subdir": "linux-64", + "timestamp": 1538073538538, + "version": "1.15.2" + }, + "numpy-1.15.2-py27h99e49ec_1.conda": { + "build": "py27h99e49ec_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py27h2f8d375_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "62f68f2eb7fce282fe4d3a0f1898a0c0", + "name": "numpy", + "sha256": "70f2b206c28f0ff3a0487303eea486a27d522c0349ee6b021908202f8e8ae700", + "size": 47987, + "subdir": "linux-64", + "timestamp": 1538500385303, + "version": "1.15.2" + }, + "numpy-1.15.2-py35h1d66e8a_0.conda": { + "build": "py35h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.2 py35h81de0dd_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b737ca183d5ea33dfdcbfe709f8c05f5", + "name": "numpy", + "sha256": "f20c45b05febb41f4e7e7f7416ae808b88dcc68915c45a684c832aff047ee671", + "size": 47486, + "subdir": "linux-64", + "timestamp": 1538073738748, + "version": "1.15.2" + }, + "numpy-1.15.2-py35h99e49ec_0.conda": { + "build": "py35h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py35h2f8d375_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e6aaa01bb6848eb0f9fa0052505e848f", + "name": "numpy", + "sha256": "2f14f2cf1a848ed657086fbdfcf12ec88daae38dd0e969ee0c4778b2a83954d0", + "size": 47423, + "subdir": "linux-64", + "timestamp": 1538073967538, + "version": "1.15.2" + }, + "numpy-1.15.2-py36h1d66e8a_0.conda": { + "build": "py36h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.2 py36h81de0dd_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c6c46b7edb489843fb2ed5b4298d4686", + "name": "numpy", + "sha256": "4fa081bf9772753308003ab1d94bc1b985c914303066a87a2c053660ccf5cae4", + "size": 47470, + "subdir": "linux-64", + "timestamp": 1538074354653, + "version": "1.15.2" + }, + "numpy-1.15.2-py36h1d66e8a_1.conda": { + "build": "py36h1d66e8a_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.2 py36h81de0dd_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3211e2ebccf00776f2f80c8ec340f51f", + "name": "numpy", + "sha256": "eb62ced5c01488c89e56ced241438406b65ef05ef80ac67938ef7c6329bd32b9", + "size": 48029, + "subdir": "linux-64", + "timestamp": 1538500668649, + "version": "1.15.2" + }, + "numpy-1.15.2-py36h99e49ec_0.conda": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ca75763e8d278d48c0169ca0dab5f24a", + "name": "numpy", + "sha256": "a07fb91e05832586c55a46c6005302b02589c0c2ffe839883888fe366a8bd230", + "size": 47506, + "subdir": "linux-64", + "timestamp": 1538074241440, + "version": "1.15.2" + }, + "numpy-1.15.2-py36h99e49ec_1.conda": { + "build": "py36h99e49ec_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py36h2f8d375_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9ad798e586939f4c564cf432b92cdc94", + "name": "numpy", + "sha256": "11aa27ddbc64b951eed88757d16f71dab2212de1e0863afc4681317202d1d1f8", + "size": 47993, + "subdir": "linux-64", + "timestamp": 1538500379496, + "version": "1.15.2" + }, + "numpy-1.15.2-py37h1d66e8a_0.conda": { + "build": "py37h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.2 py37h81de0dd_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "be7ca4ea74b16eb61118c6981e081d57", + "name": "numpy", + "sha256": "03b8dbc9b4970ab3c17e6cfff8fb9b95f51429e3c18799cc1e84e2d6494a82d9", + "size": 47412, + "subdir": "linux-64", + "timestamp": 1538073682252, + "version": "1.15.2" + }, + "numpy-1.15.2-py37h1d66e8a_1.conda": { + "build": "py37h1d66e8a_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.2 py37h81de0dd_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c6bfb20278ac7344554138ab1a8dc521", + "name": "numpy", + "sha256": "5f7844432ef21d41076ccb0a9b566f0c1f6f0fef3e2c6f00dae0e5d8065548e1", + "size": 48134, + "subdir": "linux-64", + "timestamp": 1538504451435, + "version": "1.15.2" + }, + "numpy-1.15.2-py37h99e49ec_0.conda": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4543e6c3f32fce6cdaaa55a5979a6737", + "name": "numpy", + "sha256": "a317d21dc30886f81cc7653aeb0436522f3a0da4594c64c4d22b09109f06c3c5", + "size": 47413, + "subdir": "linux-64", + "timestamp": 1538073472259, + "version": "1.15.2" + }, + "numpy-1.15.2-py37h99e49ec_1.conda": { + "build": "py37h99e49ec_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py37h2f8d375_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "05a4b9d2544d9b4f71f0fbd9dbbab4a2", + "name": "numpy", + "sha256": "a7110ff33ed5d2be57f9a66351ab81a6fa1bc1f6d37abd159bc976314cfed4f0", + "size": 48045, + "subdir": "linux-64", + "timestamp": 1538504550809, + "version": "1.15.2" + }, + "numpy-1.15.3-py27h1d66e8a_0.conda": { + "build": "py27h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.3 py27h81de0dd_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "171cc8cbec7920a7a98b8ee70fe6c91c", + "name": "numpy", + "sha256": "28a4180ba0e05edf7bca8f9ebb8ac324c68c540f6ec5c38888281e23690e28a3", + "size": 35111, + "subdir": "linux-64", + "timestamp": 1540314318231, + "version": "1.15.3" + }, + "numpy-1.15.3-py27h99e49ec_0.conda": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.3 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1412c6b6e99278e8c53ff138b931d96e", + "name": "numpy", + "sha256": "0a53222f9bd7151e97bdfd1afaaf3c55e07b618b389c530f680557fdd5f25ea6", + "size": 34999, + "subdir": "linux-64", + "timestamp": 1540314067451, + "version": "1.15.3" + }, + "numpy-1.15.3-py36h1d66e8a_0.conda": { + "build": "py36h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.3 py36h81de0dd_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "83047977190eac5efeddd21f7ed0768d", + "name": "numpy", + "sha256": "9e996079789d38fd901225e3f564498c288b71358e4224cdf34dc1f6c42a02ba", + "size": 35034, + "subdir": "linux-64", + "timestamp": 1540314343193, + "version": "1.15.3" + }, + "numpy-1.15.3-py36h99e49ec_0.conda": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.3 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bf2f774b7c8e7feb2cd060af4d786d8a", + "name": "numpy", + "sha256": "fc7a8ec0cc9be89bd0a63b78999d413902397fbc7d129c9f189cbaaf8aae4d21", + "size": 34999, + "subdir": "linux-64", + "timestamp": 1540314085588, + "version": "1.15.3" + }, + "numpy-1.15.3-py37h1d66e8a_0.conda": { + "build": "py37h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.3 py37h81de0dd_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7074abd275c2b637d54430c9a1f07b9c", + "name": "numpy", + "sha256": "32fd8d1b69adfb498f5ccf4c75497d29647a1e2a858a258c27710bb9e0445dad", + "size": 35035, + "subdir": "linux-64", + "timestamp": 1540314556123, + "version": "1.15.3" + }, + "numpy-1.15.3-py37h99e49ec_0.conda": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.3 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "adb8f0bc7c1b9f08b4ce458a5ddfb436", + "name": "numpy", + "sha256": "62dca3089532c46a901af9589bf2fc4d058326423d46d112e673c9daf5d63c4a", + "size": 34997, + "subdir": "linux-64", + "timestamp": 1540314120026, + "version": "1.15.3" + }, + "numpy-1.15.4-py27h1d66e8a_0.conda": { + "build": "py27h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.4 py27h81de0dd_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b388903b1c93b637ae5d7d6fb9a22be1", + "name": "numpy", + "sha256": "4a8478a2a79291bdd3e13588b985c34ad5f44a4eb26ddf8c89e824f9252a93af", + "size": 34839, + "subdir": "linux-64", + "timestamp": 1541517021003, + "version": "1.15.4" + }, + "numpy-1.15.4-py27h7e9f1db_0.conda": { + "build": "py27h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.15.4 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "93f7c98214616336714519abcbd8bfca", + "name": "numpy", + "sha256": "86ab242330e2fc121478f93c4bad5f8065bfaa7c0e7d8393be8158c7208d6b3b", + "size": 46753, + "subdir": "linux-64", + "timestamp": 1544718236196, + "version": "1.15.4" + }, + "numpy-1.15.4-py27h99e49ec_0.conda": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.4 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3b8ca7e4a03b8f15fece758544150e4a", + "name": "numpy", + "sha256": "9bd626d731b79d4b9d352d585c8bb78d6cdc86dc5b6339b695ba47fff999ac3b", + "size": 34867, + "subdir": "linux-64", + "timestamp": 1541516712938, + "version": "1.15.4" + }, + "numpy-1.15.4-py36h1d66e8a_0.conda": { + "build": "py36h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.4 py36h81de0dd_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8f96bd34d60cf7c2198df6d3772f5b6d", + "name": "numpy", + "sha256": "bf1f41f4dd42d4f610221262713bbd8f322286614e476c5daa66a3d0e974efc3", + "size": 34837, + "subdir": "linux-64", + "timestamp": 1541516971923, + "version": "1.15.4" + }, + "numpy-1.15.4-py36h7e9f1db_0.conda": { + "build": "py36h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.15.4 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "321e9fac207ff8d8b6ad7ca39c45e2fb", + "name": "numpy", + "sha256": "54a85d0cbed4beee5edfa1f1d3a5de4513c611cfbcf6fa6cf77ff1a28490e65a", + "size": 46810, + "subdir": "linux-64", + "timestamp": 1544718317867, + "version": "1.15.4" + }, + "numpy-1.15.4-py36h99e49ec_0.conda": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.4 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9c92adc79c913cca411b924497c00ae8", + "name": "numpy", + "sha256": "4ea81af958576b52d5d3d93750e2a0626dba30af826242d22a57c856636ebff6", + "size": 34856, + "subdir": "linux-64", + "timestamp": 1541516710496, + "version": "1.15.4" + }, + "numpy-1.15.4-py37h1d66e8a_0.conda": { + "build": "py37h1d66e8a_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "mkl_fft >=1.0.4", + "mkl_random", + "numpy-base 1.15.4 py37h81de0dd_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a7924f43b10e6206bfb14e5b5fd7f666", + "name": "numpy", + "sha256": "edceb0b30c2c5227686ff05a152f4c9d373f0ad7815e79a116cfc1b08ffd6e3b", + "size": 34820, + "subdir": "linux-64", + "timestamp": 1541516936685, + "version": "1.15.4" + }, + "numpy-1.15.4-py37h7e9f1db_0.conda": { + "build": "py37h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.15.4 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "564d5045abd99174f091b44fcbf00015", + "name": "numpy", + "sha256": "9ae61c696f59ddbf1244843b9c5ab7ac21cec2f33d98a7f6008139e7177d8ad2", + "size": 46777, + "subdir": "linux-64", + "timestamp": 1544718483928, + "version": "1.15.4" + }, + "numpy-1.15.4-py37h99e49ec_0.conda": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.4 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c3b82b942755e79d284080784d67f59c", + "name": "numpy", + "sha256": "cdfdb7877151af2af2108a808be70a73daae5af983ab9dfd68d9bc978661430c", + "size": 34859, + "subdir": "linux-64", + "timestamp": 1541516556315, + "version": "1.15.4" + }, + "numpy-1.16.0-py27h7e9f1db_0.conda": { + "build": "py27h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.0 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1b974cc80d94b7b9a7ef1ad78e2ec50e", + "name": "numpy", + "sha256": "fb7f14bfee8dc4bb474727312cda5ccb3915d0a8d7f6ef98b6612ae5877f25c3", + "size": 48325, + "subdir": "linux-64", + "timestamp": 1551398152571, + "version": "1.16.0" + }, + "numpy-1.16.0-py27h7e9f1db_1.conda": { + "build": "py27h7e9f1db_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.0 py27hde5b4d6_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "aeac151408ee24fb15557abc8eab4c1a", + "name": "numpy", + "sha256": "56aca6bd7c4da0174eba76fd408dca905a94daa5a11255ae543d10ec20176664", + "size": 48745, + "subdir": "linux-64", + "timestamp": 1551802058816, + "version": "1.16.0" + }, + "numpy-1.16.0-py27h99e49ec_0.conda": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "60526d33b56bd97b6e34e1df0d5bf304", + "name": "numpy", + "sha256": "d83e7fb72f59d0e1028e33459f1d45046e7ed426ffcd65ddaa3b91d0a1b286da", + "size": 48249, + "subdir": "linux-64", + "timestamp": 1551397995143, + "version": "1.16.0" + }, + "numpy-1.16.0-py27h99e49ec_1.conda": { + "build": "py27h99e49ec_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py27h2f8d375_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c7e9dd1f36ebe35fee712bbf429cd86f", + "name": "numpy", + "sha256": "739c6e424a140b123c201c79ab35574aa4cf5a2633e624dad8596e8502202ff0", + "size": 48758, + "subdir": "linux-64", + "timestamp": 1551801711529, + "version": "1.16.0" + }, + "numpy-1.16.0-py36h7e9f1db_0.conda": { + "build": "py36h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.0 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0adbc64e30a8f60c3f99a99ef36369ec", + "name": "numpy", + "sha256": "ad489c536a1e34a11cd29eaba3f1fed8c3186cf9ed6af76e58dc5f8408510cab", + "size": 48315, + "subdir": "linux-64", + "timestamp": 1551398204357, + "version": "1.16.0" + }, + "numpy-1.16.0-py36h7e9f1db_1.conda": { + "build": "py36h7e9f1db_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.0 py36hde5b4d6_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7ec97429ebeec7470c12cecd3b22a36f", + "name": "numpy", + "sha256": "62f60dbf5503c8943bfd6f03295bb79ff9a7b4509db469f030903665fb28c499", + "size": 48749, + "subdir": "linux-64", + "timestamp": 1551802104144, + "version": "1.16.0" + }, + "numpy-1.16.0-py36h99e49ec_0.conda": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bd9a27e6c12d78e0e62ccbe4481c4203", + "name": "numpy", + "sha256": "748f06c32394b89e9abdf719c2afa56ee47a63d1ceab683d5b14e8826ec028b3", + "size": 48327, + "subdir": "linux-64", + "timestamp": 1551398078821, + "version": "1.16.0" + }, + "numpy-1.16.0-py36h99e49ec_1.conda": { + "build": "py36h99e49ec_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py36h2f8d375_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d980d95a89d42183c5cb6271e7c7ca52", + "name": "numpy", + "sha256": "0c5c2821c5cd97786fe6218a16096892dcf37450230e82cdf2fdbab9534a0468", + "size": 48657, + "subdir": "linux-64", + "timestamp": 1551801797340, + "version": "1.16.0" + }, + "numpy-1.16.0-py37h7e9f1db_0.conda": { + "build": "py37h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.0 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b021a00bff79110d5ad21449cf3f3f6c", + "name": "numpy", + "sha256": "f85fa04a1d4275ba34b2b95ce58db5703f59e16e09c177262a831870408d175a", + "size": 48389, + "subdir": "linux-64", + "timestamp": 1551398069626, + "version": "1.16.0" + }, + "numpy-1.16.0-py37h7e9f1db_1.conda": { + "build": "py37h7e9f1db_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.0 py37hde5b4d6_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e8dc3dd1d700efcfd6cd10860c832e37", + "name": "numpy", + "sha256": "524305b7427cdc5a99f88423f1d348365688e1e947b4e0d05d6b153a18b74dd3", + "size": 48722, + "subdir": "linux-64", + "timestamp": 1551801953198, + "version": "1.16.0" + }, + "numpy-1.16.0-py37h99e49ec_0.conda": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "85b142aa7e025b2bc670ef79740dc053", + "name": "numpy", + "sha256": "ed18549376c9653fbfeebc27e7b56cc8651233af11a567a4ff38597f1ceb994f", + "size": 48340, + "subdir": "linux-64", + "timestamp": 1551398033129, + "version": "1.16.0" + }, + "numpy-1.16.0-py37h99e49ec_1.conda": { + "build": "py37h99e49ec_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py37h2f8d375_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "36ff954a4370bef280c398180eed11cc", + "name": "numpy", + "sha256": "2ecdae382c92625ef7462a850f0b5fc5b28da8aa75beb6839feddb572afcde77", + "size": 48732, + "subdir": "linux-64", + "timestamp": 1551801682601, + "version": "1.16.0" + }, + "numpy-1.16.1-py27h7e9f1db_0.conda": { + "build": "py27h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.1 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8a754a48c80204de2a0e710ee6070dd2", + "name": "numpy", + "sha256": "29f659f71ef376daaa5db54f0003ea9f1a748a554138d376542a041120317bd2", + "size": 48541, + "subdir": "linux-64", + "timestamp": 1551457208800, + "version": "1.16.1" + }, + "numpy-1.16.1-py27h7e9f1db_1.conda": { + "build": "py27h7e9f1db_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.1 py27hde5b4d6_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5f0c6b0dd1634d29b784ba4ef1cb3dfa", + "name": "numpy", + "sha256": "08c7d2790799cf9057da08d1b6d56e99c111ad173d12bc4a301a81046e24edf7", + "size": 48769, + "subdir": "linux-64", + "timestamp": 1551468320350, + "version": "1.16.1" + }, + "numpy-1.16.1-py27h99e49ec_0.conda": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9c36c1ab055c7b510c475fe73df7c536", + "name": "numpy", + "sha256": "d4a3820e4022c3242a4fcd202933c084eebe469ffd3066a7b2ce3571a2e08d04", + "size": 48319, + "subdir": "linux-64", + "timestamp": 1551457074995, + "version": "1.16.1" + }, + "numpy-1.16.1-py27h99e49ec_1.conda": { + "build": "py27h99e49ec_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py27h2f8d375_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "65b34487968d8436b52cc714ba38f374", + "name": "numpy", + "sha256": "ad91a3898c49b41645bfe7460bcd34a93a19e39130cc6e4037921c7adee35375", + "size": 48711, + "subdir": "linux-64", + "timestamp": 1551468061464, + "version": "1.16.1" + }, + "numpy-1.16.1-py36h7e9f1db_0.conda": { + "build": "py36h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.1 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1c066282dc5151c24f446a1fc82b0b8f", + "name": "numpy", + "sha256": "34af8742d1d0ee21761fa44d64ad568ddb0d68f5ed1585c8a37eb91edfbdec07", + "size": 48521, + "subdir": "linux-64", + "timestamp": 1551457139698, + "version": "1.16.1" + }, + "numpy-1.16.1-py36h7e9f1db_1.conda": { + "build": "py36h7e9f1db_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.1 py36hde5b4d6_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4e85b484847308c8baaf3749e019fe29", + "name": "numpy", + "sha256": "b411b2f9e7eccc696faf72b68f91156efd30d94c01706a027a7f07f5595d1b85", + "size": 48843, + "subdir": "linux-64", + "timestamp": 1551468263373, + "version": "1.16.1" + }, + "numpy-1.16.1-py36h99e49ec_0.conda": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3a4d7db5481cd3b149e9cd2b9afe989a", + "name": "numpy", + "sha256": "eca8b2939010cd478a47552c0dea22a9c7882ee4651135b929c1080c7f0ac54a", + "size": 48334, + "subdir": "linux-64", + "timestamp": 1551457106934, + "version": "1.16.1" + }, + "numpy-1.16.1-py36h99e49ec_1.conda": { + "build": "py36h99e49ec_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py36h2f8d375_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c7427880000beba24b06a7aa8a37f1b4", + "name": "numpy", + "sha256": "3960d36e4614f9da17c5c4ad1c58a654cfe763dd833644aba1b7f1050c5defbd", + "size": 48694, + "subdir": "linux-64", + "timestamp": 1551468096951, + "version": "1.16.1" + }, + "numpy-1.16.1-py37h7e9f1db_0.conda": { + "build": "py37h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.1 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "353f00b788a03649b8a9678a820d2937", + "name": "numpy", + "sha256": "93b1bc169adb5cdfb8cfa5aa07ea61f2d6973228a40ef5a247c332ed7ed18652", + "size": 48518, + "subdir": "linux-64", + "timestamp": 1551457177425, + "version": "1.16.1" + }, + "numpy-1.16.1-py37h7e9f1db_1.conda": { + "build": "py37h7e9f1db_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.1 py37hde5b4d6_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c84486f21b3ace3afaa2ccc7ca653d4a", + "name": "numpy", + "sha256": "dc9f0d4f388762d8fdbd4bcf8f0edb0ad649b50307ead1f1c7e08e7c4e64584d", + "size": 48780, + "subdir": "linux-64", + "timestamp": 1551468149397, + "version": "1.16.1" + }, + "numpy-1.16.1-py37h99e49ec_0.conda": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e88ad7cb7347e748ff04a1f8cd3e882d", + "name": "numpy", + "sha256": "e3b937a2f61f11812e95042a6c33b4a8e2cfcd7f08cb756f27d9df6564e08c32", + "size": 48411, + "subdir": "linux-64", + "timestamp": 1551457034367, + "version": "1.16.1" + }, + "numpy-1.16.1-py37h99e49ec_1.conda": { + "build": "py37h99e49ec_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py37h2f8d375_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "131c014ec64f217137fd10fc7b58f03e", + "name": "numpy", + "sha256": "0b7c8a879e4ad4ba1ab4734de5d0a4eb2cd9bcc5ba83e8acd28defc060855fd7", + "size": 48705, + "subdir": "linux-64", + "timestamp": 1551468093572, + "version": "1.16.1" + }, + "numpy-1.16.2-py27h7e9f1db_0.conda": { + "build": "py27h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.2 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4ee9eb70516b2a15a03de0a9fb8c75d1", + "name": "numpy", + "sha256": "972bdc857e169fb2d91c8386e93cfbbf73950738aaab470a9474cceae4aa0f7e", + "size": 48852, + "subdir": "linux-64", + "timestamp": 1551471411466, + "version": "1.16.2" + }, + "numpy-1.16.2-py27h99e49ec_0.conda": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.2 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fa38477f52952c6907ca48724137cdd0", + "name": "numpy", + "sha256": "95eeae40332f1642654021b2e9e68cb9437151fe62115c924762e237dde5e487", + "size": 48790, + "subdir": "linux-64", + "timestamp": 1551471231079, + "version": "1.16.2" + }, + "numpy-1.16.2-py36h7e9f1db_0.conda": { + "build": "py36h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.2 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "af3d6525f736c31dc6764d6a47883c92", + "name": "numpy", + "sha256": "dd268dcf979a25cc9f458f2ecd6e2f264515c46cc35fa2438e90db67f6120090", + "size": 48969, + "subdir": "linux-64", + "timestamp": 1551471520907, + "version": "1.16.2" + }, + "numpy-1.16.2-py36h99e49ec_0.conda": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.2 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f9b14cacb1ffd6415ed108880d1c119a", + "name": "numpy", + "sha256": "66de5c525b8b85a15e7dc7600e9ed57f63f2e79841d6fb9b73dbbd95d17a2b15", + "size": 48781, + "subdir": "linux-64", + "timestamp": 1551471220609, + "version": "1.16.2" + }, + "numpy-1.16.2-py37h7e9f1db_0.conda": { + "build": "py37h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.2 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "df1ea73c46837b11fcf0a0c24cf62db9", + "name": "numpy", + "sha256": "ddc24ef03d65d1ee65bb885d11910f008b67f49a020d70403daf6635ac2a7b86", + "size": 48962, + "subdir": "linux-64", + "timestamp": 1551471375641, + "version": "1.16.2" + }, + "numpy-1.16.2-py37h99e49ec_0.conda": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.2 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "141497d03357d06d187935924fe063cf", + "name": "numpy", + "sha256": "e55183b72d4bdc29cdb481c032c642d88d9a1b1dd494f49124c557ee47da5de9", + "size": 48784, + "subdir": "linux-64", + "timestamp": 1551471203547, + "version": "1.16.2" + }, + "numpy-1.16.3-py27h7e9f1db_0.conda": { + "build": "py27h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.3 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "374319cd6d4096bd0d13bc29857ffd3b", + "name": "numpy", + "sha256": "fa3fcd50201d8c66c8e18a4a56a15a11d542293b7873a390e3426cdf2d5b9ec9", + "size": 48955, + "subdir": "linux-64", + "timestamp": 1555949732605, + "version": "1.16.3" + }, + "numpy-1.16.3-py27h99e49ec_0.conda": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.3 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "75d5bf9c6bf6ef68ffea64e8f58735ad", + "name": "numpy", + "sha256": "2e396ae0ae4ad29937c2856d5321dd7d24b3d3d5bf68463a06e932e70560585c", + "size": 48776, + "subdir": "linux-64", + "timestamp": 1555949431373, + "version": "1.16.3" + }, + "numpy-1.16.3-py36h7e9f1db_0.conda": { + "build": "py36h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.3 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5a00f9e12271c4aadc9eeb5bc341c092", + "name": "numpy", + "sha256": "c7ec4468984d1a50fcf1b9fbf20adcfe91136857aedc3ddf361d671534ace105", + "size": 48866, + "subdir": "linux-64", + "timestamp": 1555949759152, + "version": "1.16.3" + }, + "numpy-1.16.3-py36h99e49ec_0.conda": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.3 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1a68af416ccb3db75a50aaa2be5234fc", + "name": "numpy", + "sha256": "7245ce021197fa96695762ccdc21dcee3c2c2832283a2c7d934948990b3d53cf", + "size": 48873, + "subdir": "linux-64", + "timestamp": 1555949575241, + "version": "1.16.3" + }, + "numpy-1.16.3-py37h7e9f1db_0.conda": { + "build": "py37h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.3 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1621a5d9654f9839871fd2432ec69a85", + "name": "numpy", + "sha256": "514817b5319e0626b619e5014072f2db8a9fa80587b05b44ce93e796ba1c7d3e", + "size": 48839, + "subdir": "linux-64", + "timestamp": 1555949602270, + "version": "1.16.3" + }, + "numpy-1.16.3-py37h99e49ec_0.conda": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.3 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "84ef7336e168a78c1d5087c6387d56e0", + "name": "numpy", + "sha256": "c58a741b1d69e3ddc8ae62026938e6e0541d8d6a9ce0b98ea2de5265deb15f1b", + "size": 48881, + "subdir": "linux-64", + "timestamp": 1555949467632, + "version": "1.16.3" + }, + "numpy-1.16.4-py27h7e9f1db_0.conda": { + "build": "py27h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.4 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "de1a3a29ff7edebcae4940925c04aa53", + "name": "numpy", + "sha256": "a9b52369a8d34fa88518ccba0853a1db79d2f6bcc668c105f172f50e8e23e39a", + "size": 48924, + "subdir": "linux-64", + "timestamp": 1559140725820, + "version": "1.16.4" + }, + "numpy-1.16.4-py27h99e49ec_0.conda": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.4 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f5313f60c5c2eaebbdcaafe814b4b811", + "name": "numpy", + "sha256": "5bb779d39556f23250356bfac09d265c9a6a70d2089c11ddfbcaaf8c81ca7d21", + "size": 48828, + "subdir": "linux-64", + "timestamp": 1559140307867, + "version": "1.16.4" + }, + "numpy-1.16.4-py36h7e9f1db_0.conda": { + "build": "py36h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.4 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "43c07a601f49c5dcae54118407454839", + "name": "numpy", + "sha256": "231e398eea4c0089068373d26a08b494af04a4fab6483f5a6a902fb2d344bb43", + "size": 48917, + "subdir": "linux-64", + "timestamp": 1559141073019, + "version": "1.16.4" + }, + "numpy-1.16.4-py36h99e49ec_0.conda": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.4 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "48db3095f7716c3dd4a1e99deb9411e7", + "name": "numpy", + "sha256": "412deef49aea893d53b813a3cca07d9c029a92365eb30df162fbec6ec16748b1", + "size": 48843, + "subdir": "linux-64", + "timestamp": 1559140310232, + "version": "1.16.4" + }, + "numpy-1.16.4-py37h7e9f1db_0.conda": { + "build": "py37h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.4 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3cc05cedc12608be33eb2dc8e0687fc8", + "name": "numpy", + "sha256": "34a619f789f8f82ad27e48214709ebce7ad99a7ee09e4faa9e734cdcf496a566", + "size": 48886, + "subdir": "linux-64", + "timestamp": 1559140484633, + "version": "1.16.4" + }, + "numpy-1.16.4-py37h99e49ec_0.conda": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.4 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fe79a777eab41c12ee3658298acc5530", + "name": "numpy", + "sha256": "a206bd96bd683093dd5a07f3d0abe49403cff3924bb4b7f5c02730f91b8069b6", + "size": 48850, + "subdir": "linux-64", + "timestamp": 1559140377071, + "version": "1.16.4" + }, + "numpy-1.16.5-py27h7e9f1db_0.conda": { + "build": "py27h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.5 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "032cb00a5ed53098d4ff1fdc694d78d6", + "name": "numpy", + "sha256": "946ea0c8881c7e2101bcac54ce55fb633a244f1b044c9adbaf7e1acaadfa9591", + "size": 49384, + "subdir": "linux-64", + "timestamp": 1568311621217, + "version": "1.16.5" + }, + "numpy-1.16.5-py27h99e49ec_0.conda": { + "build": "py27h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.5 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e44e4f4ff03d8980a41b1624a4d984db", + "name": "numpy", + "sha256": "e234f44d7cce0a81412c82419572146bf3d411b93dfb50e4156a253213f49f61", + "size": 49294, + "subdir": "linux-64", + "timestamp": 1568311482102, + "version": "1.16.5" + }, + "numpy-1.16.5-py36h7e9f1db_0.conda": { + "build": "py36h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.5 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2624dcce0c7e816a3df92e4b04472808", + "name": "numpy", + "sha256": "a8f80832f95d859f39e5705b260d5d3673878556077e6365071748f97a8ba7fb", + "size": 49389, + "subdir": "linux-64", + "timestamp": 1568311824177, + "version": "1.16.5" + }, + "numpy-1.16.5-py36h99e49ec_0.conda": { + "build": "py36h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.5 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7bf1b1d66a65caab574f446be311f814", + "name": "numpy", + "sha256": "a0780b883ca29d7fd1726f29f050a3d54c3b29aea15f6256be61ea62955e1458", + "size": 49260, + "subdir": "linux-64", + "timestamp": 1568311463237, + "version": "1.16.5" + }, + "numpy-1.16.5-py37h7e9f1db_0.conda": { + "build": "py37h7e9f1db_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.5 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b30e4b00dd7f6e1a52c17d4920d57384", + "name": "numpy", + "sha256": "81bc4f7bfb0bdd0e9366d4019581ab8de1a7ea8fc6fecbaa35a0240e76fabfe5", + "size": 49387, + "subdir": "linux-64", + "timestamp": 1568311816208, + "version": "1.16.5" + }, + "numpy-1.16.5-py37h99e49ec_0.conda": { + "build": "py37h99e49ec_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.5 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ffd39c11dba74e5ac2f8b5060c9f509b", + "name": "numpy", + "sha256": "dab5e0784194758f70764576cf79f63c4d5d5d49e56961192adc87c65c656c4a", + "size": 49266, + "subdir": "linux-64", + "timestamp": 1568311580162, + "version": "1.16.5" + }, + "numpy-1.16.6-py27h30dfecb_0.conda": { + "build": "py27h30dfecb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "33e3029fdf91609231e8c98d0f32c7ab", + "name": "numpy", + "sha256": "72c2370ed1eb5848fc5f32a719c75c6cb2cb5a35b84fa13ac1977e24b7200a94", + "size": 49623, + "subdir": "linux-64", + "timestamp": 1580501499365, + "version": "1.16.6" + }, + "numpy-1.16.6-py27hbc911f0_0.conda": { + "build": "py27hbc911f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.6 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5082124bd26fcd79b48f5b4d5445a89d", + "name": "numpy", + "sha256": "9ce70426b7b62c13a45d3084e245d4130bd82d086b007f8e93c264abbd1243c5", + "size": 49072, + "subdir": "linux-64", + "timestamp": 1580501622533, + "version": "1.16.6" + }, + "numpy-1.16.6-py36h0a8e133_3.conda": { + "build": "py36h0a8e133_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py36h41b4c56_3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9d1884bbeb8366120cb3ca4e17b6c1a9", + "name": "numpy", + "sha256": "59f746bdf05855ab0df34f310173b5e415ddda8198beee8cc0aa039f072bb775", + "size": 50477, + "subdir": "linux-64", + "timestamp": 1618845018673, + "version": "1.16.6" + }, + "numpy-1.16.6-py36h2d18471_3.conda": { + "build": "py36h2d18471_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft >=1.2.1,<2.0a0", + "mkl_random >=1.2.1,<2.0a0", + "numpy-base 1.16.6 py36hdc34a94_3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "87eb2b02a524988c902a46d23e7755ee", + "name": "numpy", + "sha256": "b630facc6c709650e81da3f1b5156da82f999bac592bc81c56530b03fcda846c", + "size": 51194, + "subdir": "linux-64", + "timestamp": 1618845174550, + "version": "1.16.6" + }, + "numpy-1.16.6-py36h30dfecb_0.conda": { + "build": "py36h30dfecb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3d53ef71a7b92e1fe966513bafd7eb0b", + "name": "numpy", + "sha256": "b0b03b9ecf547566c88032081c558289454d5460edb441d3665ffbb62211b733", + "size": 49078, + "subdir": "linux-64", + "timestamp": 1580488185096, + "version": "1.16.6" + }, + "numpy-1.16.6-py36hbc911f0_0.conda": { + "build": "py36hbc911f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.6 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2610228315620935f8d28bad1452a745", + "name": "numpy", + "sha256": "e5cb528811ca6cdfb4fe80b8321082c015f0a7831ea25156d5699f510bb706d0", + "size": 49043, + "subdir": "linux-64", + "timestamp": 1580488486831, + "version": "1.16.6" + }, + "numpy-1.16.6-py37h0708ffd_4.conda": { + "build": "py37h0708ffd_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.16.6 py37ha8aedfd_4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "909a26e33eec7c815bbf13982a954741", + "name": "numpy", + "sha256": "a82b8540694b662e79dd259f7bc332160bf59dc3b15fb2236d80f6a0434b2a77", + "size": 39411, + "subdir": "linux-64", + "timestamp": 1654863150786, + "version": "1.16.6" + }, + "numpy-1.16.6-py37h0a8e133_3.conda": { + "build": "py37h0a8e133_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py37h41b4c56_3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4df05be64c3602eaf4a9d983132a4f8b", + "name": "numpy", + "sha256": "8aa9cceb33461b0ca69a922ce52cee3a40b9247ead6f1ba0d55b0b880fedeb9b", + "size": 50914, + "subdir": "linux-64", + "timestamp": 1618844450384, + "version": "1.16.6" + }, + "numpy-1.16.6-py37h2d18471_3.conda": { + "build": "py37h2d18471_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft >=1.2.1,<2.0a0", + "mkl_random >=1.2.1,<2.0a0", + "numpy-base 1.16.6 py37hdc34a94_3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a416857de1a5903763ce4bb1745d9901", + "name": "numpy", + "sha256": "866dbe3d3dbeed7be26e4666aea800e52b77513eb7bc46c19a718cace1f1c697", + "size": 51026, + "subdir": "linux-64", + "timestamp": 1618845187107, + "version": "1.16.6" + }, + "numpy-1.16.6-py37h30dfecb_0.conda": { + "build": "py37h30dfecb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "49df92c96985a47f9fcd466fdc0e4820", + "name": "numpy", + "sha256": "2e6ae9059dcc9bfbef9d652dfe998bd54e234ee491d4c0340e713726c6ac7077", + "size": 49140, + "subdir": "linux-64", + "timestamp": 1580488174106, + "version": "1.16.6" + }, + "numpy-1.16.6-py37h7895c89_4.conda": { + "build": "py37h7895c89_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft >=1.2.1,<2.0a0", + "mkl_random >=1.2.1,<2.0a0", + "numpy-base 1.16.6 py37h73d599e_4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50da049eb362845fbbb159936df267f3", + "name": "numpy", + "sha256": "fec36baac3b4c220438755fcf52e5735dc1e8593866ad22b6a6d160d6e4ca260", + "size": 39503, + "subdir": "linux-64", + "timestamp": 1654863901855, + "version": "1.16.6" + }, + "numpy-1.16.6-py37hbc911f0_0.conda": { + "build": "py37hbc911f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.6 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9336e1e59bca5ca8a4bd9b07e8f737cb", + "name": "numpy", + "sha256": "b67e87aeea9bff41d355cf9305fa885325d244fae5ac651dd1cc13068eefbc98", + "size": 49156, + "subdir": "linux-64", + "timestamp": 1580488397932, + "version": "1.16.6" + }, + "numpy-1.16.6-py38h0708ffd_4.conda": { + "build": "py38h0708ffd_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.16.6 py38ha8aedfd_4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aa48770e731ad3b513eae665dfcf9d54", + "name": "numpy", + "sha256": "153302b24700fa86e0370792eee28c7d343a46bd000aa793dd03da879080e637", + "size": 39411, + "subdir": "linux-64", + "timestamp": 1654863587523, + "version": "1.16.6" + }, + "numpy-1.16.6-py38h0a8e133_3.conda": { + "build": "py38h0a8e133_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py38h41b4c56_3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e54d9a64e37c436d46aed4b6d277cbf8", + "name": "numpy", + "sha256": "b9b2f97d57f1a7cb9274183b06519569fdc422ab8447c40ab67fe8c711c528f7", + "size": 51314, + "subdir": "linux-64", + "timestamp": 1618841695189, + "version": "1.16.6" + }, + "numpy-1.16.6-py38h2d18471_3.conda": { + "build": "py38h2d18471_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft >=1.2.1,<2.0a0", + "mkl_random >=1.2.1,<2.0a0", + "numpy-base 1.16.6 py38hdc34a94_3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0262f5705bacb2fa250bbaad310d8ac2", + "name": "numpy", + "sha256": "3df05e9c0e71067a21f7ffb0a25d19004aee20a45b73b7677a662234d9cf0610", + "size": 51013, + "subdir": "linux-64", + "timestamp": 1618845175787, + "version": "1.16.6" + }, + "numpy-1.16.6-py38h30dfecb_0.conda": { + "build": "py38h30dfecb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py38h2f8d375_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c6bd778c5ac5fad55b3823244d147b1f", + "name": "numpy", + "sha256": "a9b2b778adfb420c5e612516b0d564e87c9effb0d644f77253b1e6770f2bb01b", + "size": 49454, + "subdir": "linux-64", + "timestamp": 1580495282184, + "version": "1.16.6" + }, + "numpy-1.16.6-py38h7895c89_4.conda": { + "build": "py38h7895c89_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft >=1.2.1,<2.0a0", + "mkl_random >=1.2.1,<2.0a0", + "numpy-base 1.16.6 py38h73d599e_4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3aa49c8d3ac3e84b2f72c635b4570479", + "name": "numpy", + "sha256": "f7913074bebb941007b930e4dde9e7957015d645c2ab729984927428460c13a0", + "size": 39479, + "subdir": "linux-64", + "timestamp": 1654864529560, + "version": "1.16.6" + }, + "numpy-1.16.6-py38hbc911f0_0.conda": { + "build": "py38hbc911f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.6 py38hde5b4d6_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1d28615f45bcd8f1fcf1beea07549551", + "name": "numpy", + "sha256": "b2f057b8dfeb2c9c167800c1ff869103cffd62d04dbc9dcb6b12807e8e3294eb", + "size": 49489, + "subdir": "linux-64", + "timestamp": 1580495343135, + "version": "1.16.6" + }, + "numpy-1.16.6-py39h0708ffd_4.conda": { + "build": "py39h0708ffd_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.16.6 py39ha8aedfd_4", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "14045c9ac60bbaab27116e25051159d3", + "name": "numpy", + "sha256": "2fb545f95496cdc49e1b0822db428c5cd9c47cd3798fa03fd516b8cbd3e02c9d", + "size": 39433, + "subdir": "linux-64", + "timestamp": 1654863369754, + "version": "1.16.6" + }, + "numpy-1.16.6-py39h0a8e133_3.conda": { + "build": "py39h0a8e133_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py39h41b4c56_3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4d28592d79d2573273cf2719970d9bea", + "name": "numpy", + "sha256": "c07f5ebb5e6d45134789268196c0b3c45d85cb2f2d92e3fde71ed79cf5c35986", + "size": 51106, + "subdir": "linux-64", + "timestamp": 1618841693744, + "version": "1.16.6" + }, + "numpy-1.16.6-py39h2d18471_3.conda": { + "build": "py39h2d18471_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft >=1.2.1,<2.0a0", + "mkl_random >=1.2.1,<2.0a0", + "numpy-base 1.16.6 py39hdc34a94_3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7a534200714c91c6e8fbfc877ee98f89", + "name": "numpy", + "sha256": "258e9e40091eee53cfa107190cc33dd462a74f3ddab2970b9a50d130cd0e4d76", + "size": 51236, + "subdir": "linux-64", + "timestamp": 1618845176540, + "version": "1.16.6" + }, + "numpy-1.16.6-py39h7895c89_4.conda": { + "build": "py39h7895c89_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft >=1.2.1,<2.0a0", + "mkl_random >=1.2.1,<2.0a0", + "numpy-base 1.16.6 py39h73d599e_4", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2f13003b1834b81dd0122b501eae970b", + "name": "numpy", + "sha256": "56f078c80e298980565424e25d15f8e32b5c0fe4210b50f9004f236df81932c1", + "size": 39486, + "subdir": "linux-64", + "timestamp": 1654864212547, + "version": "1.16.6" + }, + "numpy-1.16.6-py39h89c1606_1.conda": { + "build": "py39h89c1606_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft >=1.0.6,<2.0a0", + "mkl_random >=1.0.2,<2.0a0", + "numpy-base 1.16.6 py39h76555f2_1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8a0e823a323b1ef1b08633f3f8c02d30", + "name": "numpy", + "sha256": "691fb4d559c283f7d5de9e69ea129c9cbd425f7dcb9e7da8725b6379995bc4ae", + "size": 49498, + "subdir": "linux-64", + "timestamp": 1607432395876, + "version": "1.16.6" + }, + "numpy-1.16.6-py39hdd937aa_1.conda": { + "build": "py39hdd937aa_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py39hfb011de_1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ffb3af20fe6dcb65bf58333aef3ad408", + "name": "numpy", + "sha256": "5c49ca03dce62fa69eed112abf179f675e841ab7cd5101da8388d2be362e5f82", + "size": 49125, + "subdir": "linux-64", + "timestamp": 1607432252450, + "version": "1.16.6" + }, + "numpy-1.17.2-py36haad9e8e_0.conda": { + "build": "py36haad9e8e_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.17.2.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "17f763c930294b82f100db8530254ddf", + "name": "numpy", + "sha256": "e589dcf1f7e80410d101348b85010ab992ec01e8a216780c972e2f54fd81a4b0", + "size": 4510, + "subdir": "linux-64", + "timestamp": 1569435736573, + "version": "1.17.2" + }, + "numpy-1.17.2-py36hf9bf1b6_0.conda": { + "build": "py36hf9bf1b6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.2.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "714d47610cca345aea8fed4efce552ee", + "name": "numpy", + "sha256": "f6fa5df388c85bbdbc9d3177f34ae368135cb738e1ae5101214955f01281b281", + "size": 4533, + "subdir": "linux-64", + "timestamp": 1569435477915, + "version": "1.17.2" + }, + "numpy-1.17.2-py37haad9e8e_0.conda": { + "build": "py37haad9e8e_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.17.2.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "93caa083c8c0c0201fdb560cab226627", + "name": "numpy", + "sha256": "659ea9d317460c861d1dabe8182d8ec6992f542c318e7a05d160a8d21409306d", + "size": 4540, + "subdir": "linux-64", + "timestamp": 1569436238507, + "version": "1.17.2" + }, + "numpy-1.17.2-py37hf9bf1b6_0.conda": { + "build": "py37hf9bf1b6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.2.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9ecdd3f8a41112b011a4912d06c63e6c", + "name": "numpy", + "sha256": "cefbf0ea47ffb671fe11555977b6fa126085f183399e8869b8dc6a5d924b5ae9", + "size": 4536, + "subdir": "linux-64", + "timestamp": 1569436013036, + "version": "1.17.2" + }, + "numpy-1.17.3-py36h7e8d029_0.conda": { + "build": "py36h7e8d029_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.3.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "70263fab5987acb00835a7f2ae3a60b3", + "name": "numpy", + "sha256": "55cf66269f7f7854ad2cf60e5c7014d31a006c02da13ce3ef4566b13168edab9", + "size": 4608, + "subdir": "linux-64", + "timestamp": 1573069594490, + "version": "1.17.3" + }, + "numpy-1.17.3-py36hd14ec0e_0.conda": { + "build": "py36hd14ec0e_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.17.3.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0eda32e9293dbcd73913fc8f46278089", + "name": "numpy", + "sha256": "81ad9db3f4e469da45a665e0072527543c7f506b15d71b6a083a44f990973e49", + "size": 4626, + "subdir": "linux-64", + "timestamp": 1573069514845, + "version": "1.17.3" + }, + "numpy-1.17.3-py37h7e8d029_0.conda": { + "build": "py37h7e8d029_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.3.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8eceb186493fd4e96ff7ab44d81d7675", + "name": "numpy", + "sha256": "ab4133244a3bf836ce8bdf1e7e08f8be26f35e015214537f57b7a8045233ace4", + "size": 4593, + "subdir": "linux-64", + "timestamp": 1573069602765, + "version": "1.17.3" + }, + "numpy-1.17.3-py37hd14ec0e_0.conda": { + "build": "py37hd14ec0e_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.17.3.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e8404b6f4f5ceff13e4c8368c8a14e58", + "name": "numpy", + "sha256": "a567c45688d4ef54801aa61205d830c0ffd2420abb25227f3e405239e0f165b2", + "size": 4608, + "subdir": "linux-64", + "timestamp": 1573069524877, + "version": "1.17.3" + }, + "numpy-1.17.3-py38h7e8d029_0.conda": { + "build": "py38h7e8d029_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.3.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5f2b196b515f8fe6b37e3d224650577d", + "name": "numpy", + "sha256": "6d22d58ea9270234944684a23adfb5b73434f03a57075c81310520466adefe31", + "size": 4602, + "subdir": "linux-64", + "timestamp": 1573069507535, + "version": "1.17.3" + }, + "numpy-1.17.4-py36hc1035e2_0.conda": { + "build": "py36hc1035e2_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.17.4.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b72a6115bcfa7866bfb78f13410684c2", + "name": "numpy", + "sha256": "6ac702cc8e34bed04bb1b87a6131a454a20d3954cb79047ca5140db1074dbe20", + "size": 4613, + "subdir": "linux-64", + "timestamp": 1574868717785, + "version": "1.17.4" + }, + "numpy-1.17.4-py36hd5be1e1_0.conda": { + "build": "py36hd5be1e1_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.4.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b975890526e69ed7f54544dbbc6dfe2e", + "name": "numpy", + "sha256": "faa5fa45dee192b54278e58198b142ff914b56c1471bd00a697cf4c835e3555f", + "size": 4632, + "subdir": "linux-64", + "timestamp": 1574868452544, + "version": "1.17.4" + }, + "numpy-1.17.4-py37hc1035e2_0.conda": { + "build": "py37hc1035e2_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.17.4.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "36845685352ff2d2bd237682ea9bcd34", + "name": "numpy", + "sha256": "9347bdd6fdfc350e682317a1f180cbf325cdde563427f20ac84a5fce933779d3", + "size": 4631, + "subdir": "linux-64", + "timestamp": 1574868621830, + "version": "1.17.4" + }, + "numpy-1.17.4-py37hd5be1e1_0.conda": { + "build": "py37hd5be1e1_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.4.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1051d1ec6233e04695f19b1f7de9b3de", + "name": "numpy", + "sha256": "d300582a396d9e0437f7bce763f7e2d3fbb62c2ee3c84e5860efbe3f1b468382", + "size": 4592, + "subdir": "linux-64", + "timestamp": 1574868417879, + "version": "1.17.4" + }, + "numpy-1.17.4-py38hc1035e2_0.conda": { + "build": "py38hc1035e2_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.17.4.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1124907e6f4091198c1e26bef4f72b18", + "name": "numpy", + "sha256": "cceedcd01e9e7f0abe74acc5137e366112148ba9b36f8c61d1ff64b5edce647f", + "size": 4641, + "subdir": "linux-64", + "timestamp": 1574868659513, + "version": "1.17.4" + }, + "numpy-1.17.4-py38hd5be1e1_0.conda": { + "build": "py38hd5be1e1_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.4.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c8669b75770b9b8e740ae683c6db2171", + "name": "numpy", + "sha256": "24628fa60ba70fad4c42523888cc8d300123f35784916a5140edc0a8a24321da", + "size": 4593, + "subdir": "linux-64", + "timestamp": 1574868686829, + "version": "1.17.4" + }, + "numpy-1.18.1-py36h4f9e942_0.conda": { + "build": "py36h4f9e942_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.18.1.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fc20344bb162bf251cd7aedbd78fda5e", + "name": "numpy", + "sha256": "213f2d57349e0dcaeae0214326d88276d97097da0ed0915056c967e6b6dc7074", + "size": 5331, + "subdir": "linux-64", + "timestamp": 1579206028849, + "version": "1.18.1" + }, + "numpy-1.18.1-py36h94c655d_0.conda": { + "build": "py36h94c655d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.1.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "10041ee2fd8f39df47121ea1de746b71", + "name": "numpy", + "sha256": "5979ea70f2d87a83843046fa97b4be252b0721b68da1c7d7d24923a694864393", + "size": 5310, + "subdir": "linux-64", + "timestamp": 1579205859722, + "version": "1.18.1" + }, + "numpy-1.18.1-py37h4f9e942_0.conda": { + "build": "py37h4f9e942_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.18.1.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ab4634753f99d1542cd04a2550e9d494", + "name": "numpy", + "sha256": "50c61ed4302f5d2dcd633b50436ac2a3bd0368eb09ab21de5f3dae8cfd88e58c", + "size": 5336, + "subdir": "linux-64", + "timestamp": 1579205960526, + "version": "1.18.1" + }, + "numpy-1.18.1-py37h94c655d_0.conda": { + "build": "py37h94c655d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.1.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c0d35ab730e57610e6733b9dc1210ec8", + "name": "numpy", + "sha256": "0125dc76cffc216325206cce005004dd7e965470faa2b1755920160ef001daa8", + "size": 5297, + "subdir": "linux-64", + "timestamp": 1579205864833, + "version": "1.18.1" + }, + "numpy-1.18.1-py38h4f9e942_0.conda": { + "build": "py38h4f9e942_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.18.1.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "73d18a45b5bd4d8cafa440f31a1726e7", + "name": "numpy", + "sha256": "eb74b155131159b9bc4fcc3380d650228307c3d2e05c11ae9e94872ed4c56cd0", + "size": 5274, + "subdir": "linux-64", + "timestamp": 1579206013599, + "version": "1.18.1" + }, + "numpy-1.18.1-py38h94c655d_0.conda": { + "build": "py38h94c655d_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.1.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "06dd928d15048b1642ff17234fd48126", + "name": "numpy", + "sha256": "c97b09176fb245df625483c1567e485e9cf3a2f4a89bd1ec1d8726d489b1d1d7", + "size": 5298, + "subdir": "linux-64", + "timestamp": 1579205968928, + "version": "1.18.1" + }, + "numpy-1.18.5-py36h7130bb8_0.conda": { + "build": "py36h7130bb8_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.5.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "809b833b721ed08671758b92873c7837", + "name": "numpy", + "sha256": "d10be65e2f7b8240de5113caa2bff2175690c09632814ea820f509b45600f4c3", + "size": 4773, + "subdir": "linux-64", + "timestamp": 1592853196683, + "version": "1.18.5" + }, + "numpy-1.18.5-py36ha1c710e_0.conda": { + "build": "py36ha1c710e_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.18.5.*", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "891d320f143a7b5b617bf4f873c5b6d8", + "name": "numpy", + "sha256": "a14b1dae6a3aa73eb84d830469770f682985304f5a92f8ca5614ce0f6ae548d7", + "size": 4795, + "subdir": "linux-64", + "timestamp": 1592853215170, + "version": "1.18.5" + }, + "numpy-1.18.5-py37h7130bb8_0.conda": { + "build": "py37h7130bb8_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.5.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e71d6be8eddc9b97999718c3505e445c", + "name": "numpy", + "sha256": "f17b0e21c03afc893fa863bf92ae15c96b81bc7a93c6c3bbee4dca29f0f2bf91", + "size": 4752, + "subdir": "linux-64", + "timestamp": 1592853192562, + "version": "1.18.5" + }, + "numpy-1.18.5-py37ha1c710e_0.conda": { + "build": "py37ha1c710e_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.18.5.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8d44b86d6585b7a7d93c790a158fc15d", + "name": "numpy", + "sha256": "4ccb660f77f403d06c5b74d7fe84d046d89baf44788f95dc4cccaf11362a941c", + "size": 4774, + "subdir": "linux-64", + "timestamp": 1592853214364, + "version": "1.18.5" + }, + "numpy-1.18.5-py38h7130bb8_0.conda": { + "build": "py38h7130bb8_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.5.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9d68f2f2806561bcce83b0addb20a525", + "name": "numpy", + "sha256": "677a58fae2be438baf29cc1e2e1597ec2d7415ccbea93f307717872806ba8037", + "size": 4784, + "subdir": "linux-64", + "timestamp": 1592853194943, + "version": "1.18.5" + }, + "numpy-1.18.5-py38ha1c710e_0.conda": { + "build": "py38ha1c710e_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.18.5.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "22a2b9f5cd51636ca17943d2b8c0675e", + "name": "numpy", + "sha256": "d7c9b6af85edaf70017046b2d4a760eee209be265be4cece393eb55e7810c7ec", + "size": 4795, + "subdir": "linux-64", + "timestamp": 1592853198106, + "version": "1.18.5" + }, + "numpy-1.19.1-py36h30dfecb_0.conda": { + "build": "py36h30dfecb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.19.1 py36h75fe3a5_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6db21845f8a777821243491f487a0a3d", + "name": "numpy", + "sha256": "a49d16d8211eceac9bd9298bd0f9eed38fccece4f1aab4e40d0b605cdec9c917", + "size": 21617, + "subdir": "linux-64", + "timestamp": 1596233933479, + "version": "1.19.1" + }, + "numpy-1.19.1-py36hbc911f0_0.conda": { + "build": "py36hbc911f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.1 py36hfa32c7d_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8d1e545c18c070b9c11a372c265e99a1", + "name": "numpy", + "sha256": "5d40e30f0c54369a8da9817cd745a14682b206ae509e2534e34bb2633ac2922e", + "size": 21614, + "subdir": "linux-64", + "timestamp": 1596233933376, + "version": "1.19.1" + }, + "numpy-1.19.1-py37h30dfecb_0.conda": { + "build": "py37h30dfecb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.19.1 py37h75fe3a5_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "09f2242c0678974ec0d627c951ef7740", + "name": "numpy", + "sha256": "9de1f88eefc9ce9cf4f627a4edae200526922bd7178f35adc81d51a57857b70d", + "size": 21614, + "subdir": "linux-64", + "timestamp": 1596233946674, + "version": "1.19.1" + }, + "numpy-1.19.1-py37hbc911f0_0.conda": { + "build": "py37hbc911f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.1 py37hfa32c7d_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f404d84cba294f32096f7ec400a8e299", + "name": "numpy", + "sha256": "5ba7828481c2600535f46008b4dc0313861e659eddef04c5fb20097fdee49452", + "size": 21660, + "subdir": "linux-64", + "timestamp": 1596233914614, + "version": "1.19.1" + }, + "numpy-1.19.1-py38h30dfecb_0.conda": { + "build": "py38h30dfecb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.19.1 py38h75fe3a5_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f431bcf2c1d532a1729709ad9a47a0a3", + "name": "numpy", + "sha256": "a9103cccc4a5c727376fbb13dea85c5d82bedb845f8808e32c292fc37e72959f", + "size": 21591, + "subdir": "linux-64", + "timestamp": 1596233926457, + "version": "1.19.1" + }, + "numpy-1.19.1-py38hbc911f0_0.conda": { + "build": "py38hbc911f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.1 py38hfa32c7d_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "638c0145515b8aa7241b6b92d544e74e", + "name": "numpy", + "sha256": "21f8ac365fccf06ba14b27ee7616e68c1d0264283cd8b1c68eb3cb212ab01cb8", + "size": 21534, + "subdir": "linux-64", + "timestamp": 1596233933229, + "version": "1.19.1" + }, + "numpy-1.19.2-py36h54aff64_0.conda": { + "build": "py36h54aff64_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.2 py36hfa32c7d_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4a21e30d9344e37ea2d848f52f6a2d8e", + "name": "numpy", + "sha256": "b942f9fd66e4e2caaa75153ee12f0d85177bbc9918b8483aa1f06e10d0f9c4d8", + "size": 22159, + "subdir": "linux-64", + "timestamp": 1603487994722, + "version": "1.19.2" + }, + "numpy-1.19.2-py36h6163131_0.conda": { + "build": "py36h6163131_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.19.2 py36h75fe3a5_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "eb2c2ec06c66162f850de0846fdc9dbd", + "name": "numpy", + "sha256": "f16edb9f19268243f0df5ad6f589dbb7c2d91197d991d54ad82179639b7efb49", + "size": 22120, + "subdir": "linux-64", + "timestamp": 1603483896489, + "version": "1.19.2" + }, + "numpy-1.19.2-py37h54aff64_0.conda": { + "build": "py37h54aff64_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.2 py37hfa32c7d_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0417b15ff7fe8ad063f217e07c87d200", + "name": "numpy", + "sha256": "4fef73aba34c1f924ca7365ed243c3b6be71482f86162531b2a5a7fcfb2342cd", + "size": 22118, + "subdir": "linux-64", + "timestamp": 1603479816521, + "version": "1.19.2" + }, + "numpy-1.19.2-py37h6163131_0.conda": { + "build": "py37h6163131_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.19.2 py37h75fe3a5_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0b528858713be9de05bfbdf81e33535c", + "name": "numpy", + "sha256": "9897b8de90dc01048df50820e05a8bde730ee88e74022ded28611dab4320f6f7", + "size": 22145, + "subdir": "linux-64", + "timestamp": 1603481052303, + "version": "1.19.2" + }, + "numpy-1.19.2-py37h7895c89_1.conda": { + "build": "py37h7895c89_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.2 py37h4c65ebe_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "832007c1a144aed7a294b4309e65ac8c", + "name": "numpy", + "sha256": "33ab59f3b9115974b36f019b6fa9a9326c545d8994e7032a9e66fc93335d0a52", + "size": 9807, + "subdir": "linux-64", + "timestamp": 1654872407155, + "version": "1.19.2" + }, + "numpy-1.19.2-py37hc896f84_1.conda": { + "build": "py37hc896f84_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.19.2 py37h21a3de8_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e0490d3f41b674813f3b875fe71e332a", + "name": "numpy", + "sha256": "e1c04dfc7619be99020573008063f1a9ee0af37c48c6c4106fb9fd1b65ee7c5c", + "size": 9795, + "subdir": "linux-64", + "timestamp": 1654873745511, + "version": "1.19.2" + }, + "numpy-1.19.2-py38h54aff64_0.conda": { + "build": "py38h54aff64_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.2 py38hfa32c7d_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f63dfd30b7bbac33e0c9ee4924ffefda", + "name": "numpy", + "sha256": "0ff91a5690f73266b186bf64bc263b48a97c0eec57e31ad67489cc8274d46ede", + "size": 22140, + "subdir": "linux-64", + "timestamp": 1603570674681, + "version": "1.19.2" + }, + "numpy-1.19.2-py38h6163131_0.conda": { + "build": "py38h6163131_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.19.2 py38h75fe3a5_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5b40fa6d854c008565364bf9c52b4e95", + "name": "numpy", + "sha256": "a8f7d303198e5db994775235817d35dc954b1ff8ff362d88d55edbafbf76175f", + "size": 22147, + "subdir": "linux-64", + "timestamp": 1603479836038, + "version": "1.19.2" + }, + "numpy-1.19.2-py38h7895c89_1.conda": { + "build": "py38h7895c89_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.2 py38h4c65ebe_1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff58826a18b5efc39f40c9741653687c", + "name": "numpy", + "sha256": "22b2056f7a47a02458b94acf55d7a39c8cb5a764f0b44cb4033c871611103b28", + "size": 9806, + "subdir": "linux-64", + "timestamp": 1654873282861, + "version": "1.19.2" + }, + "numpy-1.19.2-py38hc896f84_1.conda": { + "build": "py38hc896f84_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.19.2 py38h21a3de8_1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b18318bfd610c952e16fa839751ca5a5", + "name": "numpy", + "sha256": "40495dbf4e8abfe7e2a5b6fd52c4f31d02fe953f81c05ac764b51b34948d7d68", + "size": 9799, + "subdir": "linux-64", + "timestamp": 1654874610250, + "version": "1.19.2" + }, + "numpy-1.19.2-py39h7895c89_1.conda": { + "build": "py39h7895c89_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.2 py39h4c65ebe_1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b15cee84bad55533bc7270da87cc91cd", + "name": "numpy", + "sha256": "0987bc043597677197560bcc3fea269e0b5a521e65d75b07aac6bf1756180c06", + "size": 9808, + "subdir": "linux-64", + "timestamp": 1654872832668, + "version": "1.19.2" + }, + "numpy-1.19.2-py39h87658db_0.conda": { + "build": "py39h87658db_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.19.2 py39h0f7b65f_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bcfec0fed066d701773aad43bab63efe", + "name": "numpy", + "sha256": "646b3918a6cfd2fa840218d6cab1ef71a77a3186ad4f9576bc8dcf6cb3d390fa", + "size": 22241, + "subdir": "linux-64", + "timestamp": 1607448348743, + "version": "1.19.2" + }, + "numpy-1.19.2-py39h89c1606_0.conda": { + "build": "py39h89c1606_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.2 py39h2ae0177_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "93324e78be8981e874c28d3c2ba089ee", + "name": "numpy", + "sha256": "348f3220db9c6fc4c48507ee5a1892417ecbeba37fbcf7ac16f33ab4aa78d04c", + "size": 22178, + "subdir": "linux-64", + "timestamp": 1607448329201, + "version": "1.19.2" + }, + "numpy-1.19.2-py39hc896f84_1.conda": { + "build": "py39hc896f84_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.19.2 py39h21a3de8_1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "72e6093a370ac287e3b367a0c950d724", + "name": "numpy", + "sha256": "d64f19199b5e09d70be6c3f2ddc707b48687c181ec1fcd5df6b388f05e13a478", + "size": 9795, + "subdir": "linux-64", + "timestamp": 1654874165520, + "version": "1.19.2" + }, + "numpy-1.19.5-py37hc896f84_4.conda": { + "build": "py37hc896f84_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.19.5 py37h21a3de8_4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0191969984d742f8230171d9a43a8567", + "name": "numpy", + "sha256": "def798f3fac07977ccdcb7262895af5c3d354061408d1a8147fd4212aea2408a", + "size": 10309, + "subdir": "linux-64", + "timestamp": 1677550484352, + "version": "1.19.5" + }, + "numpy-1.19.5-py37hd5178e2_4.conda": { + "build": "py37hd5178e2_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.5 py37h622ebfc_4", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0733dcd5560d585eb1ad1eb9df0c1b1f", + "name": "numpy", + "sha256": "1aef9b02d458e2a717d9d4c0508027417e46a44c9a824fc8c6519b7eafde70c3", + "size": 10339, + "subdir": "linux-64", + "timestamp": 1677551469989, + "version": "1.19.5" + }, + "numpy-1.19.5-py38hc896f84_4.conda": { + "build": "py38hc896f84_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.19.5 py38h21a3de8_4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ecefa242fedf293919b4df307b7d213f", + "name": "numpy", + "sha256": "3b913208840c5efb3c1bfa2dfa30bf562aea56b221a33354596b720c1ff76d2d", + "size": 10312, + "subdir": "linux-64", + "timestamp": 1677549837210, + "version": "1.19.5" + }, + "numpy-1.19.5-py38hd5178e2_4.conda": { + "build": "py38hd5178e2_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.5 py38h622ebfc_4", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "afc5f561fd18b3ad55997e024f9a6226", + "name": "numpy", + "sha256": "b3e55caf6cec9d093c4095dda683c361833cc00e16ed6c1381c3bf3946a00ac2", + "size": 10327, + "subdir": "linux-64", + "timestamp": 1677550816189, + "version": "1.19.5" + }, + "numpy-1.19.5-py39hc896f84_4.conda": { + "build": "py39hc896f84_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.19.5 py39h21a3de8_4", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dcea82661f0783d75abf07fd39bc955b", + "name": "numpy", + "sha256": "a774b3b0ba4d3094496bed68838cb44c85938be151f08cbc128db59241c3b2d3", + "size": 10324, + "subdir": "linux-64", + "timestamp": 1677550158992, + "version": "1.19.5" + }, + "numpy-1.19.5-py39hd5178e2_4.conda": { + "build": "py39hd5178e2_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.19.5 py39h622ebfc_4", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "78e3fb6937e8535776578f3c1872ada2", + "name": "numpy", + "sha256": "d8ad2ee7a1c958d050389ebd2a093c23f4edbbf707d38f6d31ea782479806dfb", + "size": 10335, + "subdir": "linux-64", + "timestamp": 1677551143392, + "version": "1.19.5" + }, + "numpy-1.20.1-py37h5a90a98_0.conda": { + "build": "py37h5a90a98_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.20.1 py37h34387ca_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "abca3dab91fe3b6db8d4f6a090c5b9a9", + "name": "numpy", + "sha256": "ff255c06ee82b1c42863da0ca2e57a35e0a4da8a593ca91be8b89028798c04ff", + "size": 22921, + "subdir": "linux-64", + "timestamp": 1618494317820, + "version": "1.20.1" + }, + "numpy-1.20.1-py37h93e21f0_0.conda": { + "build": "py37h93e21f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.20.1 py37h7d8b39e_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "18b8ef163d2e37662df409c4e294837c", + "name": "numpy", + "sha256": "da0c982f0aad5a49a3b1d44c9540abb16595f6fbc6cd0e4c7aea869851cfdce4", + "size": 22891, + "subdir": "linux-64", + "timestamp": 1618497462988, + "version": "1.20.1" + }, + "numpy-1.20.1-py38h5a90a98_0.conda": { + "build": "py38h5a90a98_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.20.1 py38h34387ca_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "80d0ad21c71fb020c5e8ecfe42a24c3f", + "name": "numpy", + "sha256": "ce50ad48cdccb856deb7f8a6554f6aef00fd896fbf032cf1ba2553b2d2f714af", + "size": 22884, + "subdir": "linux-64", + "timestamp": 1618497502384, + "version": "1.20.1" + }, + "numpy-1.20.1-py38h93e21f0_0.conda": { + "build": "py38h93e21f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.20.1 py38h7d8b39e_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e38538afb376c0f772ce8f09db54a6ae", + "name": "numpy", + "sha256": "ac530b0d85080bd32828a457aab152f947c8990546cbf71d0f8bf22ba5b0e82f", + "size": 22897, + "subdir": "linux-64", + "timestamp": 1618497542490, + "version": "1.20.1" + }, + "numpy-1.20.1-py39h5a90a98_0.conda": { + "build": "py39h5a90a98_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.20.1 py39h34387ca_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "efeb344e95e215f3cd105bb620d58493", + "name": "numpy", + "sha256": "7359bbc010bc1d69b4596cd7dcd3fe71cd9808412b042c88b7e13a58a24f3d03", + "size": 22998, + "subdir": "linux-64", + "timestamp": 1618497490181, + "version": "1.20.1" + }, + "numpy-1.20.1-py39h93e21f0_0.conda": { + "build": "py39h93e21f0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.20.1 py39h7d8b39e_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "621324002617a734c7f5c2e2cb2288f5", + "name": "numpy", + "sha256": "fcb37045bc9900266440b424093ce312c2764addcf239d785eb4db8655aebb8e", + "size": 22895, + "subdir": "linux-64", + "timestamp": 1618497546436, + "version": "1.20.1" + }, + "numpy-1.20.2-py37h2d18471_0.conda": { + "build": "py37h2d18471_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.20.2 py37hfae3a4d_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cd8eea1343b76cad893abc72a99bcd8e", + "name": "numpy", + "sha256": "9b081c290f1fb11b0d500a44142a7fdfe4b502d9ca626e65754910d1cbb8c0b7", + "size": 23325, + "subdir": "linux-64", + "timestamp": 1620831425976, + "version": "1.20.2" + }, + "numpy-1.20.2-py37h62767a5_0.conda": { + "build": "py37h62767a5_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.20.2 py37he2ba247_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "967d005c5202b14f1e574cbaa447775e", + "name": "numpy", + "sha256": "f02d3d91ee168d9084e0526e6ba0f79b8c66a061bae34b37bf7e1583661d545d", + "size": 23316, + "subdir": "linux-64", + "timestamp": 1620831430820, + "version": "1.20.2" + }, + "numpy-1.20.2-py38h2d18471_0.conda": { + "build": "py38h2d18471_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.20.2 py38hfae3a4d_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "863fab45e654fb641a95eea674dd2bee", + "name": "numpy", + "sha256": "71ac24c7ba16eaa871789f2f881bf71f1fe6bbc4b18450ab4656d8f9ba91dcbb", + "size": 23296, + "subdir": "linux-64", + "timestamp": 1620831195041, + "version": "1.20.2" + }, + "numpy-1.20.2-py38h62767a5_0.conda": { + "build": "py38h62767a5_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.20.2 py38he2ba247_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c33ae874659c78f04df50ebf6ce1f7d1", + "name": "numpy", + "sha256": "21add96e1a7d8bb44b0b6f20292ec2586d301a4fe84fe390947835e433c4eb53", + "size": 23279, + "subdir": "linux-64", + "timestamp": 1620827112513, + "version": "1.20.2" + }, + "numpy-1.20.2-py39h2d18471_0.conda": { + "build": "py39h2d18471_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.20.2 py39hfae3a4d_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3c7911d82459468bb78e46c7398819e8", + "name": "numpy", + "sha256": "0a6b0ca59f81eb702944db6c52314a8fc880cb9977f29584e2d6d04dc5cb3afe", + "size": 23349, + "subdir": "linux-64", + "timestamp": 1620831436482, + "version": "1.20.2" + }, + "numpy-1.20.2-py39h62767a5_0.conda": { + "build": "py39h62767a5_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.20.2 py39he2ba247_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "235f036a61636d6ca6a62db50ccd9f29", + "name": "numpy", + "sha256": "be4575ca98b2aafc5a695963b72ad525b036c69f0cb8a94a4d5f612b9f826397", + "size": 23299, + "subdir": "linux-64", + "timestamp": 1620831419933, + "version": "1.20.2" + }, + "numpy-1.20.3-py37h3dbb7de_0.conda": { + "build": "py37h3dbb7de_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.20.3 py37h39b7dee_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c4574990ec3f801712c9bbdbcaf073af", + "name": "numpy", + "sha256": "952bc3dc60cc2baefaed73f31794c4d4679ab9b93f24a70524d264133f520828", + "size": 23251, + "subdir": "linux-64", + "timestamp": 1626272017140, + "version": "1.20.3" + }, + "numpy-1.20.3-py37hf144106_0.conda": { + "build": "py37hf144106_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.20.3 py37h74d4b33_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1222cab1b2e9957fe775d324ac818c11", + "name": "numpy", + "sha256": "b937b76e66db11ea884ae7c43304872368a437b5b7e665f074c3acf5d7ea3a3e", + "size": 23395, + "subdir": "linux-64", + "timestamp": 1626265018470, + "version": "1.20.3" + }, + "numpy-1.20.3-py38h3dbb7de_0.conda": { + "build": "py38h3dbb7de_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.20.3 py38h39b7dee_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e77a860de21569949772f50cc67bfee8", + "name": "numpy", + "sha256": "f87b46c63b49c946ac1921e4d68d3ae076f1c445bd47fe172164ab83b528cd37", + "size": 23330, + "subdir": "linux-64", + "timestamp": 1626272006810, + "version": "1.20.3" + }, + "numpy-1.20.3-py38hf144106_0.conda": { + "build": "py38hf144106_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.20.3 py38h74d4b33_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "73e25e5efbd86d6493ae8050cb33735b", + "name": "numpy", + "sha256": "14c3b347e052f1320def79ff3d3418861f682aa0141907df53b6bb54bf2643b7", + "size": 23390, + "subdir": "linux-64", + "timestamp": 1626271770716, + "version": "1.20.3" + }, + "numpy-1.20.3-py39h3dbb7de_0.conda": { + "build": "py39h3dbb7de_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.20.3 py39h39b7dee_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "98d5274a9d3f7c16969c7fad36c52172", + "name": "numpy", + "sha256": "3e8804fea450839cb916277933f3fa19db2b665ba03b9d8df0da88096faf528c", + "size": 23398, + "subdir": "linux-64", + "timestamp": 1626272023141, + "version": "1.20.3" + }, + "numpy-1.20.3-py39hf144106_0.conda": { + "build": "py39hf144106_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.20.3 py39h74d4b33_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6f28e938bc6684fed256fa12cdcd0164", + "name": "numpy", + "sha256": "e771a3b03b8cf2dd97debb4e8938e1cc975f572478e5db8ad0ff14a42a88c62f", + "size": 23315, + "subdir": "linux-64", + "timestamp": 1626265020843, + "version": "1.20.3" + }, + "numpy-1.21.2-py310h20f2e39_0.conda": { + "build": "py310h20f2e39_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.2 py310h79a1101_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fe958151dcf8a77e2297f78ae66c703c", + "name": "numpy", + "sha256": "6cb394feffc6379e0ea3f00a7125e062adb907ea9bfd497a6dd217b3d289de5d", + "size": 23768, + "subdir": "linux-64", + "timestamp": 1639497139009, + "version": "1.21.2" + }, + "numpy-1.21.2-py310hd8d4704_0.conda": { + "build": "py310hd8d4704_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.21.2 py310h2b8c604_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c25c875b07a7d446cc7d5ac1128f7aab", + "name": "numpy", + "sha256": "a82f4d0a511ac2eca59ba0851f0e1d1a22422b0822dae3f22f37ceaa9de8a8ff", + "size": 23709, + "subdir": "linux-64", + "timestamp": 1639483351398, + "version": "1.21.2" + }, + "numpy-1.21.2-py37h20f2e39_0.conda": { + "build": "py37h20f2e39_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.2 py37h79a1101_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0dea300a15cdeb0788798a12b9b028c0", + "name": "numpy", + "sha256": "874ee2c4e1bf6d6ad76eed406623e4b057a6a6e12e6f8d7c6ff5464cfbdfb57e", + "size": 23461, + "subdir": "linux-64", + "timestamp": 1634106947077, + "version": "1.21.2" + }, + "numpy-1.21.2-py37hd8d4704_0.conda": { + "build": "py37hd8d4704_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.21.2 py37h2b8c604_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7ba971b8f5a8f624544aeee6351adf71", + "name": "numpy", + "sha256": "fc0ca1148ce2029491694b3029d9ec212e40d4ce8e2ec3b6060f19027b864c0e", + "size": 23366, + "subdir": "linux-64", + "timestamp": 1634106908866, + "version": "1.21.2" + }, + "numpy-1.21.2-py38h20f2e39_0.conda": { + "build": "py38h20f2e39_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.2 py38h79a1101_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "568eb6f5f5c62fda453f8f00cb2fd080", + "name": "numpy", + "sha256": "bc88abc1ed76d59a357e387474c0184d03d7db5fbfd877358abf04b217c82499", + "size": 23370, + "subdir": "linux-64", + "timestamp": 1634095896332, + "version": "1.21.2" + }, + "numpy-1.21.2-py38hd8d4704_0.conda": { + "build": "py38hd8d4704_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.21.2 py38h2b8c604_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f91675b1574586f6b1ff77f16815f305", + "name": "numpy", + "sha256": "30d9889dd0bd43604522720d50c2297ab407a1d1352d48d1aaee6a4ee0f9b191", + "size": 23407, + "subdir": "linux-64", + "timestamp": 1634106948544, + "version": "1.21.2" + }, + "numpy-1.21.2-py39h20f2e39_0.conda": { + "build": "py39h20f2e39_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.2 py39h79a1101_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "349c2bcce64ce687d6ee01ead78a470e", + "name": "numpy", + "sha256": "8045c82b1a7999a9e387ac68fd89ad301069dea7c5edfe5a22e069818d950bb3", + "size": 23355, + "subdir": "linux-64", + "timestamp": 1634095904852, + "version": "1.21.2" + }, + "numpy-1.21.2-py39hd8d4704_0.conda": { + "build": "py39hd8d4704_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.21.2 py39h2b8c604_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d13c0344193650783ce74f0f1de2f19b", + "name": "numpy", + "sha256": "69606fcccfd9f501c1130361cdca15073f9fd9ccbc721b880808ba3fdb7db8d9", + "size": 23359, + "subdir": "linux-64", + "timestamp": 1634106936390, + "version": "1.21.2" + }, + "numpy-1.21.5-py310h1794996_3.conda": { + "build": "py310h1794996_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py310hcba007f_3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "fe46fd5dfe15ce0035f5806fdcfe90e6", + "name": "numpy", + "sha256": "cb5fa636210cda5ce4c8dddeea85fcb2c4ac7112460f4bc3b5a49df00b85f95a", + "size": 10030, + "subdir": "linux-64", + "timestamp": 1653918973320, + "version": "1.21.5" + }, + "numpy-1.21.5-py310h4f1e569_1.conda": { + "build": "py310h4f1e569_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.21.5 py310hf2716ce_1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a3a37d91b361c5b548889bb7fbef38fc", + "name": "numpy", + "sha256": "8c043817c14680fd531fb8813d43c4ddad5ec5656e3c46c0af5731c0ca2074b1", + "size": 24732, + "subdir": "linux-64", + "timestamp": 1649783065068, + "version": "1.21.5" + }, + "numpy-1.21.5-py310h4f1e569_2.conda": { + "build": "py310h4f1e569_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.21.5 py310hf2716ce_2", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "0aa8e5ef5ac3640325d58f79a457265d", + "name": "numpy", + "sha256": "53b2249af253f01c51dc926dbb1a8cd85a1822385019a962b009cf95e386051f", + "size": 9956, + "subdir": "linux-64", + "timestamp": 1651563875437, + "version": "1.21.5" + }, + "numpy-1.21.5-py310hac523dd_3.conda": { + "build": "py310hac523dd_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.21.5 py310h375b286_3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "92d8009be95ae4aff6046389fea5b526", + "name": "numpy", + "sha256": "cbdb73d18dff3c24f45b96a1c10f1fa46205110946ed98fc1ebc8143cd5ea5bd", + "size": 10011, + "subdir": "linux-64", + "timestamp": 1653916846314, + "version": "1.21.5" + }, + "numpy-1.21.5-py310hfa59a62_1.conda": { + "build": "py310hfa59a62_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py310h9585f30_1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7f649372a0df0c614e46d118e9529dda", + "name": "numpy", + "sha256": "b9e4646f1f10e140fd1490aae4bf454efd8a636c5fd903edff58aba39114d529", + "size": 24737, + "subdir": "linux-64", + "timestamp": 1649783081391, + "version": "1.21.5" + }, + "numpy-1.21.5-py310hfa59a62_2.conda": { + "build": "py310hfa59a62_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py310h9585f30_2", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7f1c16092caef2dc2184a226dbc72fac", + "name": "numpy", + "sha256": "822585fbbc9a6097a2172861e1dc09b38eaae85d207cfd5c5fe01297b157f964", + "size": 9984, + "subdir": "linux-64", + "timestamp": 1651565851444, + "version": "1.21.5" + }, + "numpy-1.21.5-py37h6c91a56_3.conda": { + "build": "py37h6c91a56_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py37ha15fc14_3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "343ce82eed48d2fe2401feacb941617e", + "name": "numpy", + "sha256": "654152c72eb4651e20e766fd2d3cebf12705f16ca0d66c2c27ab4ec37fed8e15", + "size": 10014, + "subdir": "linux-64", + "timestamp": 1653917887949, + "version": "1.21.5" + }, + "numpy-1.21.5-py37h7a5d4dd_1.conda": { + "build": "py37h7a5d4dd_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.21.5 py37hb8be1f0_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "1f596c207e54fee34ccc8ab565becae5", + "name": "numpy", + "sha256": "dde69172093076738c616d3aa8defdf98b547f56364fe6152cca0ba26eb4370f", + "size": 24708, + "subdir": "linux-64", + "timestamp": 1649782985460, + "version": "1.21.5" + }, + "numpy-1.21.5-py37h7a5d4dd_2.conda": { + "build": "py37h7a5d4dd_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.21.5 py37hb8be1f0_2", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a674e6dac6cacb5316acbce7e2ce4315", + "name": "numpy", + "sha256": "5d98d5be7b142b5d6f7432ab1fb298b00204ce7e749755ba3c5da4d59d0d13ce", + "size": 9932, + "subdir": "linux-64", + "timestamp": 1651564839436, + "version": "1.21.5" + }, + "numpy-1.21.5-py37he7a7128_1.conda": { + "build": "py37he7a7128_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py37hf524024_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d18230e70921b5930e86296a3702a431", + "name": "numpy", + "sha256": "0ebbab95815b31cafeafc6886b1096c15081ac27d4066bb670e8525df269e13f", + "size": 24672, + "subdir": "linux-64", + "timestamp": 1649783041597, + "version": "1.21.5" + }, + "numpy-1.21.5-py37he7a7128_2.conda": { + "build": "py37he7a7128_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py37hf524024_2", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e943777ed4a4b6a0da1651d7601f2f21", + "name": "numpy", + "sha256": "0cee73230318dd8028836c3e05af20eca1dc5e16f88a5c27975310cb2ec97c2d", + "size": 9954, + "subdir": "linux-64", + "timestamp": 1651566832823, + "version": "1.21.5" + }, + "numpy-1.21.5-py37hf838250_3.conda": { + "build": "py37hf838250_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.21.5 py37h1e6e340_3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "87b6bb98975436b550dfc0154687535f", + "name": "numpy", + "sha256": "716f552481dec1ab8cba96e312999cc64e1f381299d6d5935de834d7a5d3f112", + "size": 9983, + "subdir": "linux-64", + "timestamp": 1653915751324, + "version": "1.21.5" + }, + "numpy-1.21.5-py38h6c91a56_3.conda": { + "build": "py38h6c91a56_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py38ha15fc14_3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "1380e47281d335ddd417b310caa056ab", + "name": "numpy", + "sha256": "7086b3650934e3fe758fa09eaad22da1fb37692f9457185d7c1f96cc55a7fc64", + "size": 10006, + "subdir": "linux-64", + "timestamp": 1653918415296, + "version": "1.21.5" + }, + "numpy-1.21.5-py38h7a5d4dd_1.conda": { + "build": "py38h7a5d4dd_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.21.5 py38hb8be1f0_1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "256ad7a060aa1c3e7b26ac4094345b07", + "name": "numpy", + "sha256": "ca105e36e5c2cbc8aa29921b3b1f3f149622ad5bae1454ab2cefddcf1e7a1910", + "size": 24648, + "subdir": "linux-64", + "timestamp": 1649765128185, + "version": "1.21.5" + }, + "numpy-1.21.5-py38h7a5d4dd_2.conda": { + "build": "py38h7a5d4dd_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.21.5 py38hb8be1f0_2", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "eb0399be1eb6a68e827d28af1f75264b", + "name": "numpy", + "sha256": "29901c36774a4c24cb5f44bd249416ff6aec90fdba77f2f2ed8a70ba8d35c85e", + "size": 9935, + "subdir": "linux-64", + "timestamp": 1651565330622, + "version": "1.21.5" + }, + "numpy-1.21.5-py38he7a7128_1.conda": { + "build": "py38he7a7128_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py38hf524024_1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9e411b9aef044e9f3b1b0719699118cc", + "name": "numpy", + "sha256": "36d86584140e104e73022489e9bf9bf36862a9d95a1436e3d4a4ef2c646ed273", + "size": 24744, + "subdir": "linux-64", + "timestamp": 1649783033088, + "version": "1.21.5" + }, + "numpy-1.21.5-py38he7a7128_2.conda": { + "build": "py38he7a7128_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py38hf524024_2", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "8f23f137fc9dbbacd244a501e94c4a70", + "name": "numpy", + "sha256": "9c4cd6e68248f91b86a6cdee92cd6d771e6774710e440f6e0462f816698da468", + "size": 9956, + "subdir": "linux-64", + "timestamp": 1651567321698, + "version": "1.21.5" + }, + "numpy-1.21.5-py38hf838250_3.conda": { + "build": "py38hf838250_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.21.5 py38h1e6e340_3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2afc121c4c941caa40f8f0285d175ede", + "name": "numpy", + "sha256": "bbab9107e64f7dbead5864c8b872cc9f18c8d15b98d1f625ae61a8da61b78f70", + "size": 9983, + "subdir": "linux-64", + "timestamp": 1653916278412, + "version": "1.21.5" + }, + "numpy-1.21.5-py39h6c91a56_3.conda": { + "build": "py39h6c91a56_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py39ha15fc14_3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "0e63d02626cd81dfa466c5e44bb6c558", + "name": "numpy", + "sha256": "eae9213005df3fd11fc94a09b313d7993fb39377f3215ded133353b02bdccfd8", + "size": 10008, + "subdir": "linux-64", + "timestamp": 1653919491718, + "version": "1.21.5" + }, + "numpy-1.21.5-py39h7a5d4dd_1.conda": { + "build": "py39h7a5d4dd_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.21.5 py39hb8be1f0_1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "1d77f91766fc2d0547a599ab5978e223", + "name": "numpy", + "sha256": "7aca36e1ab357f17ac4f05684f5e57fb4843ec310369e31b17306983e35eb47c", + "size": 24659, + "subdir": "linux-64", + "timestamp": 1649764891257, + "version": "1.21.5" + }, + "numpy-1.21.5-py39h7a5d4dd_2.conda": { + "build": "py39h7a5d4dd_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.21.5 py39hb8be1f0_2", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "910394698112428a0810882042b3909f", + "name": "numpy", + "sha256": "8194fc1af4507426fce3b488a8804bf4132558d7db7edddcebf1f213045c8e91", + "size": 9935, + "subdir": "linux-64", + "timestamp": 1651564359036, + "version": "1.21.5" + }, + "numpy-1.21.5-py39he7a7128_1.conda": { + "build": "py39he7a7128_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py39hf524024_1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "32234727246050cb90998b751a8b8d67", + "name": "numpy", + "sha256": "5b75ce9405e3d506e510d0089ea346adae61299111073c7aa95eba5e3175d701", + "size": 24754, + "subdir": "linux-64", + "timestamp": 1649764892736, + "version": "1.21.5" + }, + "numpy-1.21.5-py39he7a7128_2.conda": { + "build": "py39he7a7128_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.21.5 py39hf524024_2", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2c3e20607af2de5f27512abcf2038cbe", + "name": "numpy", + "sha256": "d42e47afdee118a935e4ac3297c68b9a10652e2720b0d2feadf94f4cbaf9a279", + "size": 9957, + "subdir": "linux-64", + "timestamp": 1651566346644, + "version": "1.21.5" + }, + "numpy-1.21.5-py39hf838250_3.conda": { + "build": "py39hf838250_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.21.5 py39h1e6e340_3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "417289c32cff118816482ae5f17d6c02", + "name": "numpy", + "sha256": "9002842f0d1d5b45399779daa98e5129952a307c539b09d9c50df7ca91892732", + "size": 9985, + "subdir": "linux-64", + "timestamp": 1653917365288, + "version": "1.21.5" + }, + "numpy-1.22.3-py310h4f1e569_0.conda": { + "build": "py310h4f1e569_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.22.3 py310hf2716ce_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a07b58bf079ed712e6991d3bdd3d0abc", + "name": "numpy", + "sha256": "e32a86cba8c057a2fed9c5b1d5a41df00cca1cc049136cf6a103c5352875c98c", + "size": 10202, + "subdir": "linux-64", + "timestamp": 1652804707113, + "version": "1.22.3" + }, + "numpy-1.22.3-py310hfa59a62_0.conda": { + "build": "py310hfa59a62_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.22.3 py310h9585f30_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "df1e8183d83e07f2c074d02a856d9757", + "name": "numpy", + "sha256": "c74a3391b0fbaa2e95c136f3a2e813c82757ae8757525e74af6c83b9e210ba44", + "size": 10227, + "subdir": "linux-64", + "timestamp": 1652802638914, + "version": "1.22.3" + }, + "numpy-1.22.3-py311h5585df3_1.conda": { + "build": "py311h5585df3_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.22.3 py311hc9e7d78_1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "88c24a9c694f6ff9860bccfc9159239f", + "name": "numpy", + "sha256": "35f23dfdc88da5c11fba64b5f628c49970eb0bee13f269d5b0ebd62669bb2f22", + "size": 10654, + "subdir": "linux-64", + "timestamp": 1676824681962, + "version": "1.22.3" + }, + "numpy-1.22.3-py311h75bd12f_1.conda": { + "build": "py311h75bd12f_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.22.3 py311h0ff3221_1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "abf9651901fa955eb55a23edeadd1ce3", + "name": "numpy", + "sha256": "0dc415ebbf8973a02a4d58460f84de733cd70efb7dfc7d5e2d3ce71a10bf65c9", + "size": 10659, + "subdir": "linux-64", + "timestamp": 1676824838031, + "version": "1.22.3" + }, + "numpy-1.22.3-py38h7a5d4dd_0.conda": { + "build": "py38h7a5d4dd_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.22.3 py38hb8be1f0_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "235a696eabc8c957b803ad57892b3cf4", + "name": "numpy", + "sha256": "c5a513f56853d403a35ad704c7ac9d147947300b0eaf5fda43c448b7755f09c4", + "size": 10172, + "subdir": "linux-64", + "timestamp": 1652805382409, + "version": "1.22.3" + }, + "numpy-1.22.3-py38he7a7128_0.conda": { + "build": "py38he7a7128_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.22.3 py38hf524024_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "57ef9da633aa96194a9306a29a31c5b7", + "name": "numpy", + "sha256": "9b8951b6753684ce3909b9e9dc2d4a23d502e9c89b213977a95e7b0c9cf8717b", + "size": 10193, + "subdir": "linux-64", + "timestamp": 1652803331594, + "version": "1.22.3" + }, + "numpy-1.22.3-py39h7a5d4dd_0.conda": { + "build": "py39h7a5d4dd_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy-base 1.22.3 py39hb8be1f0_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "dd0418c6f1a73d1e230109f41de11886", + "name": "numpy", + "sha256": "696c4a3ccecfa56908ebe6b65a8dc87039fe582b9e08831294403d192915cff3", + "size": 10167, + "subdir": "linux-64", + "timestamp": 1652804015577, + "version": "1.22.3" + }, + "numpy-1.22.3-py39he7a7128_0.conda": { + "build": "py39he7a7128_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.22.3 py39hf524024_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2ec9cc512b416656811a29eefae380e5", + "name": "numpy", + "sha256": "52cc6d12b7f22c46c850f4c04a677d158ec178793cee8b2b48535b0021aa510b", + "size": 10187, + "subdir": "linux-64", + "timestamp": 1652801901707, + "version": "1.22.3" + }, + "numpy-1.23.1-py310h1794996_0.conda": { + "build": "py310h1794996_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.1 py310hcba007f_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "3235a413ef52ccaadd8db5389d656b0e", + "name": "numpy", + "sha256": "af3fd6fda196498a03c0b797268089929349d921bb0258fe3259dfd362f5ed01", + "size": 10887, + "subdir": "linux-64", + "timestamp": 1659435971988, + "version": "1.23.1" + }, + "numpy-1.23.1-py310hac523dd_0.conda": { + "build": "py310hac523dd_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.1 py310h375b286_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ecae35f1cf9ff5dfc932f2ce7ffdfa96", + "name": "numpy", + "sha256": "07b1766237b9f036d7e8fabdab19abfe62b8ba4ce540c40b7739fd00e587f9d9", + "size": 10869, + "subdir": "linux-64", + "timestamp": 1659434130540, + "version": "1.23.1" + }, + "numpy-1.23.1-py38h6c91a56_0.conda": { + "build": "py38h6c91a56_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.1 py38ha15fc14_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "6766937e6abfb7891998389667463f1a", + "name": "numpy", + "sha256": "93779522e06db156a6c02d8c118d2717e57ac899b5c64567e2094bcebe68a4f6", + "size": 10860, + "subdir": "linux-64", + "timestamp": 1659435317316, + "version": "1.23.1" + }, + "numpy-1.23.1-py38hf838250_0.conda": { + "build": "py38hf838250_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.1 py38h1e6e340_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "453aec4dc62ea5ea1988d150e9fa6baf", + "name": "numpy", + "sha256": "b81132b534c1fabbb8ba3d128ce3bde0a62c3620b5dc1db136849893623f484e", + "size": 10847, + "subdir": "linux-64", + "timestamp": 1659433474976, + "version": "1.23.1" + }, + "numpy-1.23.1-py39h6c91a56_0.conda": { + "build": "py39h6c91a56_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.1 py39ha15fc14_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "fb8a5b9a4ee186965578eb407a65c9a5", + "name": "numpy", + "sha256": "ae1f3a76308828c52657e94e21b58e3d2d9fe0ed979703616fb9008ed282e035", + "size": 10858, + "subdir": "linux-64", + "timestamp": 1659434725898, + "version": "1.23.1" + }, + "numpy-1.23.1-py39hf838250_0.conda": { + "build": "py39hf838250_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.1 py39h1e6e340_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7f1aa28dfae0b3abf4f3ee8112d0d8f6", + "name": "numpy", + "sha256": "776b10be5088218bbe3658cfde37a39fc4d80aeaad6a842d8d5d35b09a8b403b", + "size": 10834, + "subdir": "linux-64", + "timestamp": 1659432884365, + "version": "1.23.1" + }, + "numpy-1.23.3-py310hac523dd_0.conda": { + "build": "py310hac523dd_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.3 py310h375b286_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a6d71242ad60c55ff1bbdc10d4092d94", + "name": "numpy", + "sha256": "b8a1da94164c08e430ab750c42954b60816f799315f31261a6a8172eee02e78a", + "size": 10162, + "subdir": "linux-64", + "timestamp": 1665776367315, + "version": "1.23.3" + }, + "numpy-1.23.3-py310hac523dd_1.conda": { + "build": "py310hac523dd_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.3 py310h375b286_1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "011fecff883956e7c9ce28fcd02d3f1c", + "name": "numpy", + "sha256": "c8cb8771a6a7514b8b530ddc617e1c1a295545eac7d260e67ee997bf9d095d86", + "size": 10512, + "subdir": "linux-64", + "timestamp": 1667234292219, + "version": "1.23.3" + }, + "numpy-1.23.3-py310hd5efca6_0.conda": { + "build": "py310hd5efca6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.3 py310h8e6c178_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c9f691a4ace17b174d0e2dedb721d839", + "name": "numpy", + "sha256": "4be3b6d28135a5c789ba3d2da2bf83059827bfc181e20be4c769351eeff63eb9", + "size": 10182, + "subdir": "linux-64", + "timestamp": 1665774579260, + "version": "1.23.3" + }, + "numpy-1.23.3-py310hd5efca6_1.conda": { + "build": "py310hd5efca6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.3 py310h8e6c178_1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "888d6d51e9d0b4fa83d902e67bf6c434", + "name": "numpy", + "sha256": "0acd3c8807a0aab20b4b3e2274892ab80c027dbc9a2792ba194e5d772155304a", + "size": 10536, + "subdir": "linux-64", + "timestamp": 1667236111670, + "version": "1.23.3" + }, + "numpy-1.23.3-py38h14f4228_0.conda": { + "build": "py38h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.3 py38h31eccc5_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "40ac12a45464c306aa3f707f157b9b4b", + "name": "numpy", + "sha256": "2d7ad47c6141e78e53ddac88a96a91a49a458061347c7e3602a88c9935e6c172", + "size": 10155, + "subdir": "linux-64", + "timestamp": 1665773378478, + "version": "1.23.3" + }, + "numpy-1.23.3-py38h14f4228_1.conda": { + "build": "py38h14f4228_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.3 py38h31eccc5_1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fcc26c3dfbcb03a8116c0556e66d4752", + "name": "numpy", + "sha256": "678b71fb093d2927536a436c73dbaf07bcb7ecb616f53ce930d0784dd9f73027", + "size": 10501, + "subdir": "linux-64", + "timestamp": 1667235489143, + "version": "1.23.3" + }, + "numpy-1.23.3-py38hf838250_0.conda": { + "build": "py38hf838250_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.3 py38h1e6e340_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5bda0418ae53a9dc4028e9ac150dd7ab", + "name": "numpy", + "sha256": "2466b808717fbf71e7d1d949a08be9c343cb1610f59a82e6166aada7f7469bfd", + "size": 10135, + "subdir": "linux-64", + "timestamp": 1665775168971, + "version": "1.23.3" + }, + "numpy-1.23.3-py38hf838250_1.conda": { + "build": "py38hf838250_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.3 py38h1e6e340_1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0e2960088f20554fb9dc26cd35972c34", + "name": "numpy", + "sha256": "c5d23b44ab1800e9e85d6d321d3129c76b6f6eb6244f32d1e8a135a95227f332", + "size": 10491, + "subdir": "linux-64", + "timestamp": 1667233670908, + "version": "1.23.3" + }, + "numpy-1.23.3-py39h14f4228_0.conda": { + "build": "py39h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.3 py39h31eccc5_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e1dd69401ac2acd5d5cb4427dcb666c2", + "name": "numpy", + "sha256": "59e9f66f12f31701b3ecd003910557d370fcc12e272823a6c22a6fe5fda98f37", + "size": 10149, + "subdir": "linux-64", + "timestamp": 1665773993580, + "version": "1.23.3" + }, + "numpy-1.23.3-py39h14f4228_1.conda": { + "build": "py39h14f4228_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.3 py39h31eccc5_1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1d2cb9e0f37a4993b7e56c1f34884baf", + "name": "numpy", + "sha256": "7657bc155a631d4d2c16b4db283634371fb0371c9257751aaf0435f2261c7a20", + "size": 10513, + "subdir": "linux-64", + "timestamp": 1667236717773, + "version": "1.23.3" + }, + "numpy-1.23.3-py39hf838250_0.conda": { + "build": "py39hf838250_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.3 py39h1e6e340_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aea7ac624b5980bbc5b33ae3adaa8328", + "name": "numpy", + "sha256": "b5ca73dfa9d90c2354860195949905b83f4e2ae9af7b0c41b014c518ca87ea40", + "size": 10135, + "subdir": "linux-64", + "timestamp": 1665775783481, + "version": "1.23.3" + }, + "numpy-1.23.3-py39hf838250_1.conda": { + "build": "py39hf838250_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.3 py39h1e6e340_1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c3f6c2ec45dca9f1a5769958b62a8608", + "name": "numpy", + "sha256": "6c761d24d7573f86a88a056020049616bb45f33425006c7f99aab904c9ba07bc", + "size": 10488, + "subdir": "linux-64", + "timestamp": 1667234889870, + "version": "1.23.3" + }, + "numpy-1.23.4-py310hac523dd_0.conda": { + "build": "py310hac523dd_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.4 py310h375b286_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4f53e357d652b1356fad024cc4520d99", + "name": "numpy", + "sha256": "9bcd3aaa41e7320c4628eb5339c3a756ddb90e102beb4b19f951dc53e4a0fe53", + "size": 10554, + "subdir": "linux-64", + "timestamp": 1668599501101, + "version": "1.23.4" + }, + "numpy-1.23.4-py310hd5efca6_0.conda": { + "build": "py310hd5efca6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.4 py310h8e6c178_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "545499c0ef05dd0e5c362364b26bda3a", + "name": "numpy", + "sha256": "12eee4aff63223d5e364c5303dd14b394a9688fe088141b997ba5563ba9a5142", + "size": 10580, + "subdir": "linux-64", + "timestamp": 1668596137742, + "version": "1.23.4" + }, + "numpy-1.23.4-py38h14f4228_0.conda": { + "build": "py38h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.4 py38h31eccc5_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "244fd7bf6435c66dcf93b728acd38c70", + "name": "numpy", + "sha256": "15067cb09a051903a0c960d37827e149f6613d4697628b75cfbdb08be5f20529", + "size": 10558, + "subdir": "linux-64", + "timestamp": 1668593966118, + "version": "1.23.4" + }, + "numpy-1.23.4-py38hf838250_0.conda": { + "build": "py38hf838250_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.4 py38h1e6e340_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "386d21ccb86e000e9b0c4585fdf22e6a", + "name": "numpy", + "sha256": "bdd70fde6538c563b3c03c39138201ffc076f6433a70756058111e036acb810d", + "size": 10547, + "subdir": "linux-64", + "timestamp": 1668597230935, + "version": "1.23.4" + }, + "numpy-1.23.4-py39h14f4228_0.conda": { + "build": "py39h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.4 py39h31eccc5_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0482a449823a1ce103147f9529366ee7", + "name": "numpy", + "sha256": "414d5af82eb402dcb3cd4bbe8793c99c9bb13290d8f1a4f5c2ab07bf6be67cba", + "size": 10551, + "subdir": "linux-64", + "timestamp": 1668595078110, + "version": "1.23.4" + }, + "numpy-1.23.4-py39hf838250_0.conda": { + "build": "py39hf838250_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.4 py39h1e6e340_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b013ad3a4f3dea9248f532ac7b3c1178", + "name": "numpy", + "sha256": "878e5eaf6ad701e122f8aa0ca96997a5a87b2cff5dbd73ee6cba3458d82b7583", + "size": 10528, + "subdir": "linux-64", + "timestamp": 1668598397191, + "version": "1.23.4" + }, + "numpy-1.23.5-py310hac523dd_0.conda": { + "build": "py310hac523dd_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.5 py310h375b286_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b2cd10face2873ce3f708d6f1ad51ea0", + "name": "numpy", + "sha256": "010d7c4cc7b46d6f926c9b004528d10b833f9f89e06f1234564f24fce7c2c45e", + "size": 10567, + "subdir": "linux-64", + "timestamp": 1672337464580, + "version": "1.23.5" + }, + "numpy-1.23.5-py310hd5efca6_0.conda": { + "build": "py310hd5efca6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.5 py310h8e6c178_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "14704ba32c38d4d8d78e5812f274a795", + "name": "numpy", + "sha256": "5508a85cf71b98f2f06b8e8ab7d6efcd083ffc339ee003769db7e04a57a02be9", + "size": 10597, + "subdir": "linux-64", + "timestamp": 1672340596303, + "version": "1.23.5" + }, + "numpy-1.23.5-py311h5585df3_0.conda": { + "build": "py311h5585df3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.5 py311hc9e7d78_0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "15150594fc6631361e7f7c9f413553fd", + "name": "numpy", + "sha256": "097cb3a781cb799d76c35b4e2a5ffc974f0627830ff6f5f341174e266185f1e4", + "size": 10704, + "subdir": "linux-64", + "timestamp": 1676824043754, + "version": "1.23.5" + }, + "numpy-1.23.5-py311h75bd12f_0.conda": { + "build": "py311h75bd12f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.5 py311h0ff3221_0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "df3b95813c15a02cb4eb457981ecdbff", + "name": "numpy", + "sha256": "c5eb688339ff5021a3adad671856548158adb26d374e520d1328b774e59e0b1f", + "size": 10746, + "subdir": "linux-64", + "timestamp": 1676824212689, + "version": "1.23.5" + }, + "numpy-1.23.5-py38h14f4228_0.conda": { + "build": "py38h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.5 py38h31eccc5_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1fd032f934e674393fc04aef93102cdb", + "name": "numpy", + "sha256": "d86fd20fb05351aa3a3fb6e73fd7b190a6667ca578ed11667f49ad29b4f03386", + "size": 10575, + "subdir": "linux-64", + "timestamp": 1672339520917, + "version": "1.23.5" + }, + "numpy-1.23.5-py38hf838250_0.conda": { + "build": "py38hf838250_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.5 py38h1e6e340_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "52ed429a43fcb9d63a821c8c937dae14", + "name": "numpy", + "sha256": "c9b4e25807233fb288a4f130b95796065702c90e42c02a34304951a00c1bd3ca", + "size": 10548, + "subdir": "linux-64", + "timestamp": 1672336389645, + "version": "1.23.5" + }, + "numpy-1.23.5-py39h14f4228_0.conda": { + "build": "py39h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mkl_fft", + "mkl_random", + "numpy-base 1.23.5 py39h31eccc5_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f16b88f2008cc6bcccaa0649adb017a", + "name": "numpy", + "sha256": "1738abe80216beb1ec3fb2e08b95810bbbab65080a1fdf9e275930afd9dea8e2", + "size": 10574, + "subdir": "linux-64", + "timestamp": 1672341605630, + "version": "1.23.5" + }, + "numpy-1.23.5-py39hf838250_0.conda": { + "build": "py39hf838250_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy-base 1.23.5 py39h1e6e340_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4ecfe83aad6d52f5dc1ab3f8743c05de", + "name": "numpy", + "sha256": "ba234df693ac5f06ccb4246b028f11fde07b2877cfefbdd40777e9f5b44c4558", + "size": 10557, + "subdir": "linux-64", + "timestamp": 1672338478940, + "version": "1.23.5" + }, + "numpy-1.9.3-py27_nomklhbee5d10_3.conda": { + "build": "py27_nomklhbee5d10_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "eb14ce7b923f5883194f6ba9d2260498", + "name": "numpy", + "sha256": "ad5125749a6b80cdcfe07a8c2257c4a30f935170828d617c846e9faedf30ec1b", + "size": 2769027, + "subdir": "linux-64", + "timestamp": 1509731891180, + "version": "1.9.3" + }, + "numpy-1.9.3-py27h1b885b7_7.conda": { + "build": "py27h1b885b7_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py27hdbf6ddf_7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "49cf9ff3ef43ec0fc3e406d8931e7354", + "name": "numpy", + "sha256": "e1ec0ac93e9217ff3f2f9212ce36300d815bf7016fb9cc0b2e49ba1e94d8d8db", + "size": 9670, + "subdir": "linux-64", + "timestamp": 1534345655411, + "version": "1.9.3" + }, + "numpy-1.9.3-py27h28100ab_5.conda": { + "build": "py27h28100ab_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5140c2af9d64032fa39826f0eeb9e327", + "name": "numpy", + "sha256": "04dd737176fe500faa8e8525c0926d33ee5d807d06b7b7ace01b61c8ef699092", + "size": 10262, + "subdir": "linux-64", + "timestamp": 1530278937649, + "version": "1.9.3" + }, + "numpy-1.9.3-py27h28100ab_6.conda": { + "build": "py27h28100ab_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py27h2b20989_6", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2a85528d1cc9d0042c76d72147d4f7cf", + "name": "numpy", + "sha256": "39f85cda2309b99b921b6173b451c62997b06085919e256a22d276bf307fcbe0", + "size": 10089, + "subdir": "linux-64", + "timestamp": 1530379924075, + "version": "1.9.3" + }, + "numpy-1.9.3-py27h28100ab_7.conda": { + "build": "py27h28100ab_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py27h2b20989_7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7423793ba3e327069e4f29cd2d7984b2", + "name": "numpy", + "sha256": "d2c9bdb2dbff117cb29c20ca472f9c54f4b6f972818d274a0fc93ce462a6d3fc", + "size": 10191, + "subdir": "linux-64", + "timestamp": 1530550405055, + "version": "1.9.3" + }, + "numpy-1.9.3-py27h2aefc1b_7.conda": { + "build": "py27h2aefc1b_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py27h2b20989_7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "068651c524f3402d7918f1e41c0c4d06", + "name": "numpy", + "sha256": "8be4248f6923b9a18fbf68dabc0bae1266f0bba47222ab4df9d7962ed3f6be31", + "size": 9724, + "subdir": "linux-64", + "timestamp": 1534345708610, + "version": "1.9.3" + }, + "numpy-1.9.3-py27h7e35acb_3.conda": { + "build": "py27h7e35acb_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "mkl >=2018.0.0,<2019.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "377d5d926e3cf64ecdd4e0a2bee7e3b2", + "name": "numpy", + "sha256": "03a3af94aabdffcdc78910ec4144b4151c2f534cb4205fcbe6d6d7fe1bdeaf92", + "size": 2769074, + "subdir": "linux-64", + "timestamp": 1506015990456, + "version": "1.9.3" + }, + "numpy-1.9.3-py27hcd700cb_5.conda": { + "build": "py27hcd700cb_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fcf2616c70688a13c6224fe8c2ca6e7b", + "name": "numpy", + "sha256": "2d6997d12a5db5d18ef7e4c875f676feb9267b64476a6784c96b03236e06f9dd", + "size": 10238, + "subdir": "linux-64", + "timestamp": 1530279172184, + "version": "1.9.3" + }, + "numpy-1.9.3-py27hcd700cb_6.conda": { + "build": "py27hcd700cb_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py27hdbf6ddf_6", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f5b7c949320bab9e041edab2ff88ea52", + "name": "numpy", + "sha256": "6d0174297a97eb467001e037bce9a82281764ec299fca537aa34f17d4e7796f0", + "size": 10117, + "subdir": "linux-64", + "timestamp": 1530382963644, + "version": "1.9.3" + }, + "numpy-1.9.3-py27hcd700cb_7.conda": { + "build": "py27hcd700cb_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py27hdbf6ddf_7", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "17ada95286999da5ad0d26f62070f1fc", + "name": "numpy", + "sha256": "39bc9e1e911b87e011bcd8ef326f41807a8fab2c14b4bd9ab8e0c40ad32f3fa8", + "size": 10201, + "subdir": "linux-64", + "timestamp": 1530553009302, + "version": "1.9.3" + }, + "numpy-1.9.3-py35_nomklh11ed3e2_3.conda": { + "build": "py35_nomklh11ed3e2_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "6ff343b45c65faababa3cf56869774c7", + "name": "numpy", + "sha256": "a2f1defd1eecf5e6ac5a14ca6c3046654befa13f576fe6d54402b56234d45d8b", + "size": 2819438, + "subdir": "linux-64", + "timestamp": 1509731487200, + "version": "1.9.3" + }, + "numpy-1.9.3-py35h1b885b7_7.conda": { + "build": "py35h1b885b7_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py35hdbf6ddf_7", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "05f0f51d537bc5845c14f33b190a760c", + "name": "numpy", + "sha256": "fe15fdf0254a736cbd2a4ec2a8c69bb9a403da1028a47db891d34baace83aea8", + "size": 9681, + "subdir": "linux-64", + "timestamp": 1534345875570, + "version": "1.9.3" + }, + "numpy-1.9.3-py35h28100ab_7.conda": { + "build": "py35h28100ab_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py35h2b20989_7", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ca020d57d577259526ae0f00fef1fd0e", + "name": "numpy", + "sha256": "74a5128f83e6e220f8b77a48fc59f8b2457dac8857de18e9e145061fd38ebf65", + "size": 10163, + "subdir": "linux-64", + "timestamp": 1530694232705, + "version": "1.9.3" + }, + "numpy-1.9.3-py35h2aefc1b_7.conda": { + "build": "py35h2aefc1b_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py35h2b20989_7", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a00d02e187f86be16c520ef14cd9aed3", + "name": "numpy", + "sha256": "9d0b4ca2ef1954d816835458a6cde84528990df29a81974df9365a27633550f9", + "size": 9730, + "subdir": "linux-64", + "timestamp": 1534345932315, + "version": "1.9.3" + }, + "numpy-1.9.3-py35hcd700cb_7.conda": { + "build": "py35hcd700cb_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py35hdbf6ddf_7", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f6978371f7d81bd65aa2aa2f8b8e763a", + "name": "numpy", + "sha256": "8736cc615b324c1ea1bd2ec2005e487606536e9524cf58e41475b97832396d62", + "size": 10189, + "subdir": "linux-64", + "timestamp": 1530694446144, + "version": "1.9.3" + }, + "numpy-1.9.3-py35hff6eb55_3.conda": { + "build": "py35hff6eb55_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "ff98e15535ec737d89b9dde01ab517cd", + "name": "numpy", + "sha256": "9361ff69af87f54d5a38f8f8b2c6e8535104489ea2f42da2ee256059d3507ee3", + "size": 2818415, + "subdir": "linux-64", + "timestamp": 1506015816757, + "version": "1.9.3" + }, + "numpy-1.9.3-py36_nomklh9e07ec8_3.conda": { + "build": "py36_nomklh9e07ec8_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "91d4a54cc7138dfa98fd1db0fce858a3", + "name": "numpy", + "sha256": "a445344358e475c7cd258592156e98b4eabb9995af868cf65253f5a7580770cd", + "size": 2812815, + "subdir": "linux-64", + "timestamp": 1509732019133, + "version": "1.9.3" + }, + "numpy-1.9.3-py36h1b885b7_7.conda": { + "build": "py36h1b885b7_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py36hdbf6ddf_7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0426ef4a46da304b5a0957b18517c665", + "name": "numpy", + "sha256": "3c8e5a8947e2f85dd659cb442e11b3cf579215b19c794fdaa6ed6fa7ad5e9c69", + "size": 9724, + "subdir": "linux-64", + "timestamp": 1534345762713, + "version": "1.9.3" + }, + "numpy-1.9.3-py36h28100ab_5.conda": { + "build": "py36h28100ab_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "32beb5034059a4e0f7a6317c09cf02c5", + "name": "numpy", + "sha256": "8e2fcf6c2268e00b8199d7626e60411d4aa67cede0fdfa97d700fdbdb23d3284", + "size": 10244, + "subdir": "linux-64", + "timestamp": 1530278932212, + "version": "1.9.3" + }, + "numpy-1.9.3-py36h28100ab_6.conda": { + "build": "py36h28100ab_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py36h2b20989_6", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a31b5b54f8fc0761283071e611854727", + "name": "numpy", + "sha256": "52f2ce3ab87c7e0cf49427d9284c706beeeb6c393adbc82df953b8f8d88da0b1", + "size": 10089, + "subdir": "linux-64", + "timestamp": 1530380591786, + "version": "1.9.3" + }, + "numpy-1.9.3-py36h28100ab_7.conda": { + "build": "py36h28100ab_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py36h2b20989_7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9c1f95d7feac0342368e2e12d8f76981", + "name": "numpy", + "sha256": "fea0c77b0b2101a3bc9502ed6d3ce2621a6e01782913ef5ed11c1715d63e3b11", + "size": 10186, + "subdir": "linux-64", + "timestamp": 1530550436550, + "version": "1.9.3" + }, + "numpy-1.9.3-py36h2aefc1b_7.conda": { + "build": "py36h2aefc1b_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py36h2b20989_7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d8fc29fc9e3a021d318df936ab1e6e66", + "name": "numpy", + "sha256": "b10ef6a00295787b524cc6441a57dba5ca348a4007667511ca76fe27fb1822bd", + "size": 9722, + "subdir": "linux-64", + "timestamp": 1534345819227, + "version": "1.9.3" + }, + "numpy-1.9.3-py36h35fcb08_3.conda": { + "build": "py36h35fcb08_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "mkl >=2018.0.0,<2019.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "60d2413d54cee55c621c33d26bbd32e9", + "name": "numpy", + "sha256": "7b74e51c3f83aaf84fcbbd5cc5dbafa172e3f9d98acb768979965b7dc0f5552d", + "size": 2794227, + "subdir": "linux-64", + "timestamp": 1506016053195, + "version": "1.9.3" + }, + "numpy-1.9.3-py36hcd700cb_5.conda": { + "build": "py36hcd700cb_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a5be80479fde3653466bdf7a5558e27b", + "name": "numpy", + "sha256": "0f4f3076d5df93dd5b02eb686fc96a1747b8800cb34a781a30bc3ec4478b68c0", + "size": 10276, + "subdir": "linux-64", + "timestamp": 1530279227064, + "version": "1.9.3" + }, + "numpy-1.9.3-py36hcd700cb_6.conda": { + "build": "py36hcd700cb_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py36hdbf6ddf_6", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6aa52894d7020700a48e892cd2afb950", + "name": "numpy", + "sha256": "5c8a612bb21833f0e1052b89c6148f28d31bf32de02792530570c6f1574e6beb", + "size": 10118, + "subdir": "linux-64", + "timestamp": 1530383323079, + "version": "1.9.3" + }, + "numpy-1.9.3-py36hcd700cb_7.conda": { + "build": "py36hcd700cb_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py36hdbf6ddf_7", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "55f427e1b2d20970ead13178dbf3b5c9", + "name": "numpy", + "sha256": "b2e3780600de897f59cb29f4570a69f2fa2ddab2fd56ecbde43c4615455e05f2", + "size": 10141, + "subdir": "linux-64", + "timestamp": 1530553481359, + "version": "1.9.3" + }, + "numpy-1.9.3-py37h1b885b7_7.conda": { + "build": "py37h1b885b7_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py37hdbf6ddf_7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c46a59f3cdac261439d562ff03f8e817", + "name": "numpy", + "sha256": "1047fa46e2cafe30ee8d380d0ec3925679b53e17fbf8ad6f8f1f9ede6e17f15d", + "size": 9675, + "subdir": "linux-64", + "timestamp": 1534345986669, + "version": "1.9.3" + }, + "numpy-1.9.3-py37h28100ab_5.conda": { + "build": "py37h28100ab_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base >=1.9.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0034b821fd3a5c9401540f835a999cf4", + "name": "numpy", + "sha256": "2bc24c79ed63ea9e571e8b3603a284a964b18ae9d5b55ea1341b6d8b8878739b", + "size": 10284, + "subdir": "linux-64", + "timestamp": 1530278994315, + "version": "1.9.3" + }, + "numpy-1.9.3-py37h28100ab_6.conda": { + "build": "py37h28100ab_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py37h2b20989_6", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7b29ce32b47451cd924b1aad26b15bbe", + "name": "numpy", + "sha256": "2d05d8363705f7dacce06428165700d264804cc625ad896b18178843c15a9a55", + "size": 10093, + "subdir": "linux-64", + "timestamp": 1530381175946, + "version": "1.9.3" + }, + "numpy-1.9.3-py37h28100ab_7.conda": { + "build": "py37h28100ab_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py37h2b20989_7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6ddfa1127e71f2d2fa436e8a4577db97", + "name": "numpy", + "sha256": "56b1bc3c859b7bd1b5c3842aedf8438d8fd13e58257bd8a23714ed8de6d0e848", + "size": 10155, + "subdir": "linux-64", + "timestamp": 1530550818362, + "version": "1.9.3" + }, + "numpy-1.9.3-py37h2aefc1b_7.conda": { + "build": "py37h2aefc1b_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py37h2b20989_7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "053e4789281e2a7f5f73397807a70caa", + "name": "numpy", + "sha256": "7fac4a23c2770a401888fd13f14fef9b931825fcfc75c9eedba7dcd164027308", + "size": 9677, + "subdir": "linux-64", + "timestamp": 1534346040768, + "version": "1.9.3" + }, + "numpy-1.9.3-py37hcd700cb_5.conda": { + "build": "py37hcd700cb_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base >=1.9.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1f005e315e2577f8ba13b235d89ee9b2", + "name": "numpy", + "sha256": "fb8b4cad90149837f827000e24ed08e5ac1a6e0e8ec07117f4e777e33432cd88", + "size": 10239, + "subdir": "linux-64", + "timestamp": 1530279184440, + "version": "1.9.3" + }, + "numpy-1.9.3-py37hcd700cb_6.conda": { + "build": "py37hcd700cb_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py37hdbf6ddf_6", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "68ba450bf955cc7e33e93c5ad74a3148", + "name": "numpy", + "sha256": "5411dd58c8532cabccfe513b8fc21131c52b339c43064879f58b13449c20a00b", + "size": 10117, + "subdir": "linux-64", + "timestamp": 1530382640595, + "version": "1.9.3" + }, + "numpy-1.9.3-py37hcd700cb_7.conda": { + "build": "py37hcd700cb_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "numpy-base 1.9.3 py37hdbf6ddf_7", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "92a7520adaca4ffd8c1218595c7a4062", + "name": "numpy", + "sha256": "86745654afd78328cff1af7b58a26a90f25f2f1c9d590e85607b42b36b6f8578", + "size": 10197, + "subdir": "linux-64", + "timestamp": 1530553569297, + "version": "1.9.3" + }, + "numpy-base-1.11.3-py27h1793315_9.conda": { + "build": "py27h1793315_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "8eafb404d7ff862700e81aaba0953039", + "name": "numpy-base", + "sha256": "7d7fff07a52e499bbe335bfd67ae1af9e26b59c3a405a05a6d3183183efbbf80", + "size": 3003814, + "subdir": "linux-64", + "timestamp": 1534775017983, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h2b20989_7.conda": { + "build": "py27h2b20989_7", + "build_number": 7, + "constrains": [ + "numpy 1.11.3 py27h28100ab_7" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "14a9e49587812f425006a5e4ee0f55c5", + "name": "numpy-base", + "sha256": "960528fa539764e2557ce78a6dbf77aafd6c63dd0c155e5fa8b13edbcb99c66f", + "size": 3005532, + "subdir": "linux-64", + "timestamp": 1530380274899, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h2b20989_8.conda": { + "build": "py27h2b20989_8", + "build_number": 8, + "constrains": [ + "numpy 1.11.3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "8efd608a1ad946afc871176651877eb1", + "name": "numpy-base", + "sha256": "dc31607a3858f6b54c343c34d9d7b1ad931751038e0edc2a88d822e9e45e14fc", + "size": 3005591, + "subdir": "linux-64", + "timestamp": 1530550803630, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h2f8d375_10.conda": { + "build": "py27h2f8d375_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py27h99e49ec_10" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "d87047cd6291b46e59500f3f59e289ca", + "name": "numpy-base", + "sha256": "b90a9194dae34d5d9c2cb1c7a9b071ce31509207f9f59aa5c0bc4b10b884177b", + "size": 3012636, + "subdir": "linux-64", + "timestamp": 1536892560859, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h2f8d375_11.conda": { + "build": "py27h2f8d375_11", + "build_number": 11, + "constrains": [ + "numpy 1.11.3 py27h99e49ec_11" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "c11d537cd1db4544b95e4fb78e52abe7", + "name": "numpy-base", + "sha256": "48890455cfc08a2e63e78d2ce829bd18146b53441db1ff86a9239a64a037ed5c", + "size": 2981140, + "subdir": "linux-64", + "timestamp": 1544631941844, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h2f8d375_12.conda": { + "build": "py27h2f8d375_12", + "build_number": 12, + "constrains": [ + "numpy 1.11.3 py27h99e49ec_12" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "2501b3461bc86df957a035bde78da02a", + "name": "numpy-base", + "sha256": "b4d6a23ac3d01b9a123e563c812f4c726e52284d67f12973c2d2f41b2bf7309a", + "size": 3002428, + "subdir": "linux-64", + "timestamp": 1544762959067, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h3dfced4_9.conda": { + "build": "py27h3dfced4_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py27h1b885b7_9" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "5cabf79db1248898216c581754beb56c", + "name": "numpy-base", + "sha256": "72762031bbc0f9806677d2fff549ab4704de3786efac3e2a3914dd2ca39895d3", + "size": 2984396, + "subdir": "linux-64", + "timestamp": 1532661262725, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h74e8950_10.conda": { + "build": "py27h74e8950_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py27hb510916_10" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "62445aacfa57b5efb5c9756b258f53a6", + "name": "numpy-base", + "sha256": "3bc934ffc5faaf979bd401dc86ea5c0bef2e45ae4a4139ff7f2788da6fd74274", + "size": 3012508, + "subdir": "linux-64", + "timestamp": 1535405687501, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h74e8950_9.conda": { + "build": "py27h74e8950_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py27hec00662_9" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "d342baeea8fe78c72ccf6d81c8a697a1", + "name": "numpy-base", + "sha256": "658976e75fe4375652c815747ce4c630c3e90c08def386aec1ca09716cb5845c", + "size": 2993048, + "subdir": "linux-64", + "timestamp": 1535387751989, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h7cdd4dd_9.conda": { + "build": "py27h7cdd4dd_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py27h2aefc1b_9" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "8169b9bc8688db2c886ff50a11a744d8", + "name": "numpy-base", + "sha256": "b0cb481ae4eb9876e89ced6e56d09c01d72cd3d50c5e7f6d4d1d7f41bdcaba2b", + "size": 3006496, + "subdir": "linux-64", + "timestamp": 1532660114432, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h81de0dd_10.conda": { + "build": "py27h81de0dd_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py27h1d66e8a_10" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "42eaf52b036786494dfc831933a24c0c", + "name": "numpy-base", + "sha256": "ccf573de6e5ff8941ea63a3511d1b5bf00bd73d1601344045eb63d51d106bc61", + "size": 3011359, + "subdir": "linux-64", + "timestamp": 1535405784392, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27h81de0dd_9.conda": { + "build": "py27h81de0dd_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py27h3b04361_9" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "a6b0c0dfefb00113dd636c5fa5e7f5e5", + "name": "numpy-base", + "sha256": "b9d6c30b9df1e1008f70b3719bc1d2547b673c5bdcf4773d3dd837732ecc8b41", + "size": 3011355, + "subdir": "linux-64", + "timestamp": 1535388991931, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27hc937464_9.conda": { + "build": "py27hc937464_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "139e56df3ae890d2bffafd3f96b12d73", + "name": "numpy-base", + "sha256": "d0a7290c6c05ef54bfdb6fdc98a621926a09cae14abf68671f8abd2612baee6e", + "size": 2983496, + "subdir": "linux-64", + "timestamp": 1534775212607, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27hdbf6ddf_7.conda": { + "build": "py27hdbf6ddf_7", + "build_number": 7, + "constrains": [ + "numpy 1.11.3 py27hcd700cb_7" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "d7faefccd395718d0bb75d18f622c0ed", + "name": "numpy-base", + "sha256": "69bf1f51fbb453076e193997edf01f6d5e54b59c50f6bc76f00cb7b34019a30c", + "size": 3005764, + "subdir": "linux-64", + "timestamp": 1530382440543, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27hdbf6ddf_8.conda": { + "build": "py27hdbf6ddf_8", + "build_number": 8, + "constrains": [ + "numpy 1.11.3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "141bd44a0cbe50524b178573a989dafd", + "name": "numpy-base", + "sha256": "9501dabb2ba5ce1a8c701a35b562b044eed9e4fb739c167c10815b5f5c940f93", + "size": 2983509, + "subdir": "linux-64", + "timestamp": 1530551361837, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27hde5b4d6_11.conda": { + "build": "py27hde5b4d6_11", + "build_number": 11, + "constrains": [ + "numpy 1.11.3 py27h7e9f1db_11" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "4cd6cc31abe96102504870f794f36ec5", + "name": "numpy-base", + "sha256": "6f3e6a28ed16aaef97984b45a6238afeb4103054c86ab2be5c9be72346831e1a", + "size": 2980541, + "subdir": "linux-64", + "timestamp": 1544632807533, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py27hde5b4d6_12.conda": { + "build": "py27hde5b4d6_12", + "build_number": 12, + "constrains": [ + "numpy 1.11.3 py27h7e9f1db_12" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "4d7551afa295963bc066d5d8f1925e19", + "name": "numpy-base", + "sha256": "97f5a17951daf25c8b1dc4007e20f451646d5b005a537416131aecb0eed90c9b", + "size": 2981047, + "subdir": "linux-64", + "timestamp": 1544763149155, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35h1793315_9.conda": { + "build": "py35h1793315_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "0cf20ea05898aaa6b47d38078e972be1", + "name": "numpy-base", + "sha256": "239fe6edd8fa36abccdeee8497e43081d27fa622d65b8597cb5ab60911c759df", + "size": 3041896, + "subdir": "linux-64", + "timestamp": 1534774621195, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35h2b20989_8.conda": { + "build": "py35h2b20989_8", + "build_number": 8, + "constrains": [ + "numpy 1.11.3 py35h2aefc1b_8" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "c2be4706cc9f1e0efc6be194b81f118b", + "name": "numpy-base", + "sha256": "bb6c350f0727dadfbb048f92f838ad0f7e4007be184c9af0f13d1c7ca36cf445", + "size": 3042350, + "subdir": "linux-64", + "timestamp": 1534346529446, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35h2f8d375_10.conda": { + "build": "py35h2f8d375_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py35h99e49ec_10" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "6fde8cf4c9caaff43983352aa1703917", + "name": "numpy-base", + "sha256": "e2e80d8d47e946ff77b9477a35c59555ce48e1a0b078683cd71185db73f2ddca", + "size": 3032017, + "subdir": "linux-64", + "timestamp": 1536892593528, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35h3dfced4_9.conda": { + "build": "py35h3dfced4_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py35h1b885b7_9" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "e2804ab80b901e22918f074e561a2bff", + "name": "numpy-base", + "sha256": "cb44dcb80a1fc00df587232b1413f6465f6af67857b9e21344426021178c649a", + "size": 3043720, + "subdir": "linux-64", + "timestamp": 1532661233988, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35h74e8950_10.conda": { + "build": "py35h74e8950_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py35hb510916_10" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "311923a195950b7fddd4fca98aa7ae9c", + "name": "numpy-base", + "sha256": "e153ae5d86e12169523d2dbc3420d8785b96ad90f8269ba1a6d08d4c797a2c33", + "size": 3049661, + "subdir": "linux-64", + "timestamp": 1535405666419, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35h74e8950_9.conda": { + "build": "py35h74e8950_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py35hec00662_9" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "245e27107dd1d9f29d1c13fe7ae90c0f", + "name": "numpy-base", + "sha256": "f072e5c9efb81e54e0c7aaaebe8ae35d4a3f4fc1accc0e1763a0b013afaf3109", + "size": 3032082, + "subdir": "linux-64", + "timestamp": 1535388137827, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35h7cdd4dd_9.conda": { + "build": "py35h7cdd4dd_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py35h2aefc1b_9" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "8b41150d6e7a755f9d77c1ed4836c3c1", + "name": "numpy-base", + "sha256": "f805fe4c6181efbf0a2452d1346c230d5248d2dd65f2bd16c05aee3ca1f14900", + "size": 3023284, + "subdir": "linux-64", + "timestamp": 1532660149698, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35h81de0dd_10.conda": { + "build": "py35h81de0dd_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py35h1d66e8a_10" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "ac5eb98251ca3f7eb545e76d2e3ec528", + "name": "numpy-base", + "sha256": "f47e6835ab9f16ac7450b9464041546ee549302c5f84e6f0a1d7dd4fc08dab62", + "size": 3048930, + "subdir": "linux-64", + "timestamp": 1535406536153, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35h81de0dd_9.conda": { + "build": "py35h81de0dd_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py35h3b04361_9" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "61ba36e5dacc31fc30df6408acc789ec", + "name": "numpy-base", + "sha256": "57b958581a1371ab516f8245227121bdbde79fd317eedc54f13e4f7115c0bc49", + "size": 3030785, + "subdir": "linux-64", + "timestamp": 1535389029286, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35hc937464_9.conda": { + "build": "py35hc937464_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "638c93381349a0faec0179404dcad8ec", + "name": "numpy-base", + "sha256": "56f62ca0aa416612da9f2f65d3d6b84416ba84a0dc81ded186a70df6432afe9b", + "size": 3020646, + "subdir": "linux-64", + "timestamp": 1534774826637, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py35hdbf6ddf_8.conda": { + "build": "py35hdbf6ddf_8", + "build_number": 8, + "constrains": [ + "numpy 1.11.3 py35h1b885b7_8" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "1c121f093f4dd9abc6f8e304cc99d21d", + "name": "numpy-base", + "sha256": "815c0799a75e2fde49aa200e9dd18b437d1648359b80d08aff5117e22d4bbd70", + "size": 3041324, + "subdir": "linux-64", + "timestamp": 1534346254091, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h1793315_9.conda": { + "build": "py36h1793315_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "3f30769a0e3e570913d4860043d281d0", + "name": "numpy-base", + "sha256": "6c72f1205994006a150651a17d1cfb5764231e4f1f7ca8bba6175a88f4ee0f44", + "size": 3012506, + "subdir": "linux-64", + "timestamp": 1534775413388, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h2b20989_7.conda": { + "build": "py36h2b20989_7", + "build_number": 7, + "constrains": [ + "numpy 1.11.3 py36h28100ab_7" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "0de7578e8082b048b015e907b4238f75", + "name": "numpy-base", + "sha256": "c27155c6c40e08ca94629895f6bc0cbccf02316297021e07cce06cbdf26c4883", + "size": 3015163, + "subdir": "linux-64", + "timestamp": 1530380580452, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h2b20989_8.conda": { + "build": "py36h2b20989_8", + "build_number": 8, + "constrains": [ + "numpy 1.11.3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "3f7167077cbcef1221d2dae4b6218f99", + "name": "numpy-base", + "sha256": "ac0894d38643ca06bd58f8877ccdd6ab7e8d98cbf2d25fdb7712adc776f41d06", + "size": 3036147, + "subdir": "linux-64", + "timestamp": 1530551206974, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h2f8d375_10.conda": { + "build": "py36h2f8d375_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py36h99e49ec_10" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "39fbd1237792f6265d34b67ef37080f5", + "name": "numpy-base", + "sha256": "609b6d57cede5bc7a4ae38a2c00361b8296f533471b195c86819aa41da437202", + "size": 3021368, + "subdir": "linux-64", + "timestamp": 1536892532401, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h2f8d375_11.conda": { + "build": "py36h2f8d375_11", + "build_number": 11, + "constrains": [ + "numpy 1.11.3 py36h99e49ec_11" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "46843728eb6dacb44c377f05f33a0f0f", + "name": "numpy-base", + "sha256": "a702ab970b75193b4bc5e550a07e532b642583ed55cd274f216d6be195648cc9", + "size": 3039560, + "subdir": "linux-64", + "timestamp": 1544632112739, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h2f8d375_12.conda": { + "build": "py36h2f8d375_12", + "build_number": 12, + "constrains": [ + "numpy 1.11.3 py36h99e49ec_12" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "8ef237b85e8c508f20a6e49c7ee89576", + "name": "numpy-base", + "sha256": "69f36dccc1126cc4efe4193e0567590cc75b8df624985130a083b68768d6dc9f", + "size": 3040097, + "subdir": "linux-64", + "timestamp": 1544763110442, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h3dfced4_9.conda": { + "build": "py36h3dfced4_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py36h1b885b7_9" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "3e97328183d83068ea9fa8a7e3b9b482", + "name": "numpy-base", + "sha256": "93d1c34db96d1bcf64c7658166ca4ead848a1ce3d7a4bbc55b0fe99938e30b94", + "size": 3014185, + "subdir": "linux-64", + "timestamp": 1532661219173, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h74e8950_10.conda": { + "build": "py36h74e8950_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py36hb510916_10" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "1768de59b0ea456809ded4cc1889375f", + "name": "numpy-base", + "sha256": "b754991b92cb16bdebe6de7eecf265227e05ca29902ac024de7a0ec7ae558c58", + "size": 3021283, + "subdir": "linux-64", + "timestamp": 1535405692946, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h74e8950_9.conda": { + "build": "py36h74e8950_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py36hec00662_9" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "c6e5122ac13ac6ea0a880fd5b8bfe94d", + "name": "numpy-base", + "sha256": "4409ef92c24fe22265fee3eb386010ead704e040f47a0621248988e9e778b574", + "size": 3021296, + "subdir": "linux-64", + "timestamp": 1535388291466, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h7cdd4dd_9.conda": { + "build": "py36h7cdd4dd_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py36h2aefc1b_9" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "ea8df77070a2b0be3e718d7fbdbd7c0d", + "name": "numpy-base", + "sha256": "2d677f700853544b26e1651203f5069a086a7e9f2fa2ab47856df4634f73d18d", + "size": 3035106, + "subdir": "linux-64", + "timestamp": 1532660117894, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h81de0dd_10.conda": { + "build": "py36h81de0dd_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py36h1d66e8a_10" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "6acaa16278376424e706765a51f94783", + "name": "numpy-base", + "sha256": "58ea5b5c2e5c92e116749375b48171d5e6996b34febd97fa2248de759759b36c", + "size": 3021289, + "subdir": "linux-64", + "timestamp": 1535405831143, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36h81de0dd_9.conda": { + "build": "py36h81de0dd_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py36h3b04361_9" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "19e866c97ecf44a3977745c1e2aa856b", + "name": "numpy-base", + "sha256": "c87c54b0ee1ff735ed07c881453a449d547fb2e96eb3ee422508885034c91b5a", + "size": 3041874, + "subdir": "linux-64", + "timestamp": 1535386683752, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36hc937464_9.conda": { + "build": "py36hc937464_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "64e12d472329bedb884a02c30842b4dd", + "name": "numpy-base", + "sha256": "0211f2f2bdcd720b5cdad76e9ffb3dceadd6852b882207f1b819a15f0a285df6", + "size": 3034226, + "subdir": "linux-64", + "timestamp": 1534775614120, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36hdbf6ddf_7.conda": { + "build": "py36hdbf6ddf_7", + "build_number": 7, + "constrains": [ + "numpy 1.11.3 py36hcd700cb_7" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "4c9f50c91b4e57fbb07ef18787c0f85b", + "name": "numpy-base", + "sha256": "f21b9b9a7dc3f44a8f7c9296d47b147a6ee175d7759f8f8a47004213490e1cf2", + "size": 3036522, + "subdir": "linux-64", + "timestamp": 1530382651295, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36hdbf6ddf_8.conda": { + "build": "py36hdbf6ddf_8", + "build_number": 8, + "constrains": [ + "numpy 1.11.3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "35ffcefa320a1089b133fc80fb6a068a", + "name": "numpy-base", + "sha256": "a1252c2273092437d00dcc3610cbd389b91a1af1cc1e31e5bfb07324e710f799", + "size": 3014954, + "subdir": "linux-64", + "timestamp": 1530553516869, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36hde5b4d6_11.conda": { + "build": "py36hde5b4d6_11", + "build_number": 11, + "constrains": [ + "numpy 1.11.3 py36h7e9f1db_11" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "63d68e711d1323a78943ad36681f7266", + "name": "numpy-base", + "sha256": "b58d0d7b9ad280b6891d825e5d714bf598dd60a9155e7e73b8344359903df337", + "size": 3019857, + "subdir": "linux-64", + "timestamp": 1544632711282, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py36hde5b4d6_12.conda": { + "build": "py36hde5b4d6_12", + "build_number": 12, + "constrains": [ + "numpy 1.11.3 py36h7e9f1db_12" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "808d2b2570a768f2057a3d02231618d5", + "name": "numpy-base", + "sha256": "e1f76d5fd95fa464495e006aac5d02df965160c9f13b1b3ef6c2e38a2e11f0ef", + "size": 3039971, + "subdir": "linux-64", + "timestamp": 1544763289408, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h1793315_9.conda": { + "build": "py37h1793315_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "fc57e914565c07cc5412600b2da4152d", + "name": "numpy-base", + "sha256": "cb39a12dda9c4ed0e35b2a5b76668628bc69fd82df01e183e8ea72d82fdb7ecb", + "size": 2997430, + "subdir": "linux-64", + "timestamp": 1534775809689, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h2b20989_7.conda": { + "build": "py37h2b20989_7", + "build_number": 7, + "constrains": [ + "numpy 1.11.3 py37h28100ab_7" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "67c88a950d73b610c45d1405d23ef06c", + "name": "numpy-base", + "sha256": "d753a0b5f91c76cd5b903c8be6aa094b3b9dec22f985ab6e459e47693577f61f", + "size": 3020570, + "subdir": "linux-64", + "timestamp": 1530380343058, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h2b20989_8.conda": { + "build": "py37h2b20989_8", + "build_number": 8, + "constrains": [ + "numpy 1.11.3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "5cad8b94e6c89db83a883b88d1d200a5", + "name": "numpy-base", + "sha256": "bcf0fa4ba49bbea8680077fbadd83d34734fa6e454fb49e857c3561d7c1b3f1b", + "size": 3020508, + "subdir": "linux-64", + "timestamp": 1530550558653, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h2f8d375_10.conda": { + "build": "py37h2f8d375_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py37h99e49ec_10" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "8acfa45d2e1e6a7ac3398a2aac3afd0c", + "name": "numpy-base", + "sha256": "8e25a547997d82b6b654c42e566a95f55499fcdeee0c2f8500022aafff360ab1", + "size": 3027832, + "subdir": "linux-64", + "timestamp": 1536892527790, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h2f8d375_11.conda": { + "build": "py37h2f8d375_11", + "build_number": 11, + "constrains": [ + "numpy 1.11.3 py37h99e49ec_11" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "d28c81b71af7673fc0b948f181c12a1b", + "name": "numpy-base", + "sha256": "596bfa5673efa16096ea6ad44b5601360adafbe858ccb75e1e479828e465b4cb", + "size": 3025487, + "subdir": "linux-64", + "timestamp": 1544631836888, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h2f8d375_12.conda": { + "build": "py37h2f8d375_12", + "build_number": 12, + "constrains": [ + "numpy 1.11.3 py37h99e49ec_12" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "e7bf56f8db65d5a3d05b64f300aa86ec", + "name": "numpy-base", + "sha256": "c2adc729c921f96d7b62861cda38b47fea1cd8684f8bdc9d97565aa97917ab24", + "size": 3006779, + "subdir": "linux-64", + "timestamp": 1544762954177, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h3dfced4_9.conda": { + "build": "py37h3dfced4_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py37h1b885b7_9" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "790de3487374bfee3ca3468c80776057", + "name": "numpy-base", + "sha256": "0164681b38c767fb618161f76738694f2d210f0b7c9c76367f735956d483d0eb", + "size": 3000558, + "subdir": "linux-64", + "timestamp": 1532661026067, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h74e8950_10.conda": { + "build": "py37h74e8950_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py37hb510916_10" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "d288b77fc107d0d96bbf27366bec1af4", + "name": "numpy-base", + "sha256": "e5a00970cf104fc2db4bf2c519db196f5c32f8ac3f0088ffdbe24fcbcdc49ec1", + "size": 3027399, + "subdir": "linux-64", + "timestamp": 1535405061702, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h74e8950_9.conda": { + "build": "py37h74e8950_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py37hec00662_9" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "e5c516d0b7faf6823ec4eb24eef9187d", + "name": "numpy-base", + "sha256": "7d74765f2524cab91a9500657119e6f0f51361650f26f7b6b48a252a1841002e", + "size": 3008401, + "subdir": "linux-64", + "timestamp": 1535388233877, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h7cdd4dd_9.conda": { + "build": "py37h7cdd4dd_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py37h2aefc1b_9" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "7c29291aad0c9adce056a4d28a3bea63", + "name": "numpy-base", + "sha256": "3040efeea8cce4d5704cadf80b5ddbd0716d63d048a9d56d4ad323540f731918", + "size": 3020282, + "subdir": "linux-64", + "timestamp": 1532660178666, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h81de0dd_10.conda": { + "build": "py37h81de0dd_10", + "build_number": 10, + "constrains": [ + "numpy 1.11.3 py37h1d66e8a_10" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "12c49cb817d2fa829512047b36ba0112", + "name": "numpy-base", + "sha256": "d9a1fe0b1a0d076c9eb17fed62cfa97866fa0346e4fc07c6c37879f775847743", + "size": 3026920, + "subdir": "linux-64", + "timestamp": 1535405831166, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37h81de0dd_9.conda": { + "build": "py37h81de0dd_9", + "build_number": 9, + "constrains": [ + "numpy 1.11.3 py37h3b04361_9" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "57f12b915042dcc5dfb4e7645ecf8e9f", + "name": "numpy-base", + "sha256": "4d8b3d89d34b4a26b067ff103b972214017298d125078cc5a357e8fdeb82cb99", + "size": 3007629, + "subdir": "linux-64", + "timestamp": 1535386867941, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37hc937464_9.conda": { + "build": "py37hc937464_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "2546e1bccb0c618fe875ddb87a62cdd8", + "name": "numpy-base", + "sha256": "d9040c783848dd5bbc3e6189c89c04825aaed9e5b50dea5a1001e240488633bf", + "size": 3018529, + "subdir": "linux-64", + "timestamp": 1534776013494, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37hdbf6ddf_7.conda": { + "build": "py37hdbf6ddf_7", + "build_number": 7, + "constrains": [ + "numpy 1.11.3 py37hcd700cb_7" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "68df38acfab6580ddbd692237d5c1784", + "name": "numpy-base", + "sha256": "b3006212e3927157459ac6d6f955d5dd7761ba4faf2d5d79f926d4f8bcffed03", + "size": 3000305, + "subdir": "linux-64", + "timestamp": 1530382662622, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37hdbf6ddf_8.conda": { + "build": "py37hdbf6ddf_8", + "build_number": 8, + "constrains": [ + "numpy 1.11.3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "39f3b22d99562b55b9bae0a627e8ff0f", + "name": "numpy-base", + "sha256": "c08801ca3087c5f00d6156a25f1b2134b43f56891531aeff45d7500518212af0", + "size": 3000950, + "subdir": "linux-64", + "timestamp": 1530553581760, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37hde5b4d6_11.conda": { + "build": "py37hde5b4d6_11", + "build_number": 11, + "constrains": [ + "numpy 1.11.3 py37h7e9f1db_11" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "38f4b8ea22d6cc2ff5a10d9724d7bcb0", + "name": "numpy-base", + "sha256": "2da11e88eb667eeeaaa8dddf87385f1f7c633381436a1704cafdb1f17b2a75fb", + "size": 3025266, + "subdir": "linux-64", + "timestamp": 1544632706577, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py37hde5b4d6_12.conda": { + "build": "py37hde5b4d6_12", + "build_number": 12, + "constrains": [ + "numpy 1.11.3 py37h7e9f1db_12" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "4e83ca08c06b98a373716aaee4644967", + "name": "numpy-base", + "sha256": "5a6f8a14127297d663b0e9e6029797b34967b5525ad35cfd3315827812fe5153", + "size": 3007731, + "subdir": "linux-64", + "timestamp": 1544763230115, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py38h2f8d375_12.conda": { + "build": "py38h2f8d375_12", + "build_number": 12, + "constrains": [ + "numpy 1.11.3 py38h99e49ec_12" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "e370aeb416ba1f1561b4f959782b9b5d", + "name": "numpy-base", + "sha256": "c5fc236b697bdab6bcc7ce435d9b40a6828d2e933c1b87be20acb27aa557226f", + "size": 3069690, + "subdir": "linux-64", + "timestamp": 1572609721493, + "version": "1.11.3" + }, + "numpy-base-1.11.3-py38hde5b4d6_12.conda": { + "build": "py38hde5b4d6_12", + "build_number": 12, + "constrains": [ + "numpy 1.11.3 py38h7e9f1db_12" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "c568b26b3645ddff0c655545736f126d", + "name": "numpy-base", + "sha256": "ce5ee0484aa89a66f28aac0750c6e185522f68e7ba1fd4afa6cf2070276b27ed", + "size": 3069890, + "subdir": "linux-64", + "timestamp": 1572609496617, + "version": "1.11.3" + }, + "numpy-base-1.14.3-py27h0ea5e3f_1.conda": { + "build": "py27h0ea5e3f_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.3 py27h28100ab_1" + ], + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "md5": "0447576988d9f6813f57036777f1821d", + "name": "numpy-base", + "sha256": "779c95ee06656e65e4b70a448c28240a53871443276c4a76d154898588ea0543", + "size": 3383058, + "subdir": "linux-64", + "timestamp": 1526858626640, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py27h2b20989_0.conda": { + "build": "py27h2b20989_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "md5": "68c62b168142a77bea7f11ecef489a09", + "name": "numpy-base", + "sha256": "7d4cc599350fad806d2aa4f42a688a8dfb3ed54a4dc2c1c6b1cf7d52470dec0a", + "size": 3408276, + "subdir": "linux-64", + "timestamp": 1525977093654, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py27h9be14a7_1.conda": { + "build": "py27h9be14a7_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.3 py27hcd700cb_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "46327da253ef07d8bafc693f402e0682", + "name": "numpy-base", + "sha256": "32da02b904af3c4db9a12a1c69cef49567813e2401983a6f3e60dddc8a52f45f", + "size": 3429408, + "subdir": "linux-64", + "timestamp": 1526859325100, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py27hdbf6ddf_0.conda": { + "build": "py27hdbf6ddf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py", + "blas * mkl" + ], + "md5": "fb58b4a6348adeb7c0c552200f84c902", + "name": "numpy-base", + "sha256": "625a5e629d15ffa6d15d3acbff32429c6545ef4fe87ba721a95fd4dbf37f4fe7", + "size": 3454870, + "subdir": "linux-64", + "timestamp": 1525977377358, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py35h0ea5e3f_1.conda": { + "build": "py35h0ea5e3f_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.3 py35h28100ab_1" + ], + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "md5": "2f88ec3614495c0a09d90a7194a1288f", + "name": "numpy-base", + "sha256": "1d7ec4e82d82042eee20acbbc46fa3bfd9347dfcf3b65f1ef0582497dbee1ab5", + "size": 3427573, + "subdir": "linux-64", + "timestamp": 1526858681472, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py35h2b20989_0.conda": { + "build": "py35h2b20989_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "md5": "19d7ccfb0cd3f69a20c310be579a1200", + "name": "numpy-base", + "sha256": "f9e4339d264520e4fdafd440efb323355c5ca1aa9e95bd4bd770f5445c42adfe", + "size": 3430094, + "subdir": "linux-64", + "timestamp": 1525976852270, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py35h9be14a7_1.conda": { + "build": "py35h9be14a7_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.3 py35hcd700cb_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "bf73abf2dc66f153284473f0ace4221b", + "name": "numpy-base", + "sha256": "35b2ae7fdebbbd68a02e18d489dc674172400f79b7714a3c7614b9560dfa5a6f", + "size": 3477522, + "subdir": "linux-64", + "timestamp": 1526859339760, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py35hdbf6ddf_0.conda": { + "build": "py35hdbf6ddf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py", + "blas * mkl" + ], + "md5": "5601610527e4d5ac8015435cf8744d4f", + "name": "numpy-base", + "sha256": "2c3a8c0465ab2d0b52afc76d79a38fd25a059459a83791a47704a6a285985ad7", + "size": 3479181, + "subdir": "linux-64", + "timestamp": 1525977737239, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py36h0ea5e3f_1.conda": { + "build": "py36h0ea5e3f_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.3 py36h28100ab_1" + ], + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "md5": "3ca9617c4150a291eb7e8b112c9e62cb", + "name": "numpy-base", + "sha256": "39cfbe87afcd367aa37b845f21da4ead0d45716d29a777acb925bc10379accc0", + "size": 3440905, + "subdir": "linux-64", + "timestamp": 1526858435951, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py36h2b20989_0.conda": { + "build": "py36h2b20989_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "md5": "504a5c261aac3c6e1fbfb88e410286b5", + "name": "numpy-base", + "sha256": "14539b166d317b2cf4b0d818a1eb9cc3b5688afe32ff462dcb086a4a19588225", + "size": 3442729, + "subdir": "linux-64", + "timestamp": 1525976598624, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py36h9be14a7_1.conda": { + "build": "py36h9be14a7_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.3 py36hcd700cb_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "7ebc14c69cb24e9757f632d51f27f7d8", + "name": "numpy-base", + "sha256": "d7454e25d12767d6fb2c95196893588c70c1b909134ac16123e1db3d4ef2363c", + "size": 3469569, + "subdir": "linux-64", + "timestamp": 1526858969963, + "version": "1.14.3" + }, + "numpy-base-1.14.3-py36hdbf6ddf_0.conda": { + "build": "py36hdbf6ddf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.2,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py", + "blas * mkl" + ], + "md5": "c94844370233ef63b71bda9264318a1e", + "name": "numpy-base", + "sha256": "3038c40bf6f2657eca611fbe15cb17882e41c19f149da2b57b03c85dd8d19e77", + "size": 3488655, + "subdir": "linux-64", + "timestamp": 1525977061421, + "version": "1.14.3" + }, + "numpy-base-1.14.4-py27h2b20989_0.conda": { + "build": "py27h2b20989_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.4 py27h28100ab_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "dcdc14ea57b42ee25d3dae1c7443f2a9", + "name": "numpy-base", + "sha256": "4ae3d9de50dc8eb1dcbf794c45325463a9ce1319408d364196ac055d3de0cb02", + "size": 3441786, + "subdir": "linux-64", + "timestamp": 1528829162887, + "version": "1.14.4" + }, + "numpy-base-1.14.4-py27hdbf6ddf_0.conda": { + "build": "py27hdbf6ddf_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.4 py27hcd700cb_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "41d5b0042604bbdc8a0989852ed8c6d5", + "name": "numpy-base", + "sha256": "7f6805560d0cf2171a21fad60923a2e98387256b8b55cd01c067c8d3a0828a9b", + "size": 3504612, + "subdir": "linux-64", + "timestamp": 1528829618777, + "version": "1.14.4" + }, + "numpy-base-1.14.4-py35h2b20989_0.conda": { + "build": "py35h2b20989_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.4 py35h28100ab_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "b7dd7a01d461f67e34cbefc9a555900b", + "name": "numpy-base", + "sha256": "ae36994f732302e53bad531a21b6394069314962dbd47245c391970a9a5190a0", + "size": 3504891, + "subdir": "linux-64", + "timestamp": 1528829210648, + "version": "1.14.4" + }, + "numpy-base-1.14.4-py35hdbf6ddf_0.conda": { + "build": "py35hdbf6ddf_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.4 py35hcd700cb_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "9d510cf52eb09d939733579e3bf1d356", + "name": "numpy-base", + "sha256": "0373db83d4a7671294bead88b314588c1ee4fd33b0d6320d86717a973bdc39a3", + "size": 3553735, + "subdir": "linux-64", + "timestamp": 1528829746076, + "version": "1.14.4" + }, + "numpy-base-1.14.4-py36h2b20989_0.conda": { + "build": "py36h2b20989_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.4 py36h28100ab_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "12df696e16d97a4f453bdac6e0117e51", + "name": "numpy-base", + "sha256": "3ecf968810fa691f3400b32c63ed2ec83fa18844e5dd82e7ac1cdf90e5a6d47f", + "size": 3476461, + "subdir": "linux-64", + "timestamp": 1528829194891, + "version": "1.14.4" + }, + "numpy-base-1.14.4-py36hdbf6ddf_0.conda": { + "build": "py36hdbf6ddf_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.4 py36hcd700cb_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "b8c69e48df7b2f4e8b1933f14215ab75", + "name": "numpy-base", + "sha256": "726576457c921cad3153b6a78382b2ddec03f8c0370c797ef1378b7b10b1ad29", + "size": 3540007, + "subdir": "linux-64", + "timestamp": 1528829651825, + "version": "1.14.4" + }, + "numpy-base-1.14.5-py27h2b20989_0.conda": { + "build": "py27h2b20989_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.5 py27h28100ab_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "b52f2234dad449b846ebd9959d4cb78c", + "name": "numpy-base", + "sha256": "f95b15a836f977d550e339079fb4ac1a5e6bc4fdd7fb4a95389d1730eee8ced6", + "size": 3440508, + "subdir": "linux-64", + "timestamp": 1528900913985, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py27h2b20989_1.conda": { + "build": "py27h2b20989_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.5 py27h28100ab_1" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "cd4cb657707658a180330c66b7f73f23", + "name": "numpy-base", + "sha256": "22133cd285c2845ba82939f06dd4f46b9bd945a23841fc09c0069b7138bc52be", + "size": 3440090, + "subdir": "linux-64", + "timestamp": 1530354187670, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py27h2b20989_2.conda": { + "build": "py27h2b20989_2", + "build_number": 2, + "constrains": [ + "numpy 1.14.5 py27h28100ab_2" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "e26e05db861ddb3fe0de96be2e774041", + "name": "numpy-base", + "sha256": "f3fb43a9a91ea98cdb95fdfa8b1416ce6cbbbaa960b06898f23762d2bc62a6de", + "size": 3459613, + "subdir": "linux-64", + "timestamp": 1530382222361, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py27h2b20989_3.conda": { + "build": "py27h2b20989_3", + "build_number": 3, + "constrains": [ + "numpy 1.14.5 py27h28100ab_3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "d1db881c92c2c81a1338e7ff1b88a55d", + "name": "numpy-base", + "sha256": "6212a3b904ac3ff1bdb71343b3ecf489b5c0199b8e69728cb175da881ac7054a", + "size": 3459988, + "subdir": "linux-64", + "timestamp": 1530553500400, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py27h2b20989_4.conda": { + "build": "py27h2b20989_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.5 py27h2aefc1b_4" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "8f2378f28328ac05cd3f3bd00ce1f50f", + "name": "numpy-base", + "sha256": "65eabc8b7e41dcbf42b580e8cb3972b7fbc1a61101921cc69c3395443e6444d8", + "size": 3405223, + "subdir": "linux-64", + "timestamp": 1531326430685, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py27hdbf6ddf_0.conda": { + "build": "py27hdbf6ddf_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.5 py27hcd700cb_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "f137dbe7c3d8e180d24fd8d9c0fba047", + "name": "numpy-base", + "sha256": "33d25b69ec08768167ef1e609c02d45c8b9d9fedd43de61a407b7db23d0b78da", + "size": 3504136, + "subdir": "linux-64", + "timestamp": 1528901248948, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py27hdbf6ddf_1.conda": { + "build": "py27hdbf6ddf_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.5 py27hcd700cb_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "c9e5d8972d97144a889817dd55660a56", + "name": "numpy-base", + "sha256": "c68226a5d5a31bf5717e0382db988a2de8cbfdee8dc7ae632887ecfd4f5889ca", + "size": 3503788, + "subdir": "linux-64", + "timestamp": 1530353515611, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py27hdbf6ddf_2.conda": { + "build": "py27hdbf6ddf_2", + "build_number": 2, + "constrains": [ + "numpy 1.14.5 py27hcd700cb_2" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "ef406fb2b28348d760f4f8e254eaca6d", + "name": "numpy-base", + "sha256": "253ecd43918f6c4ac368ca03bdecdd50f3ba023a1c2e63aa672b7feafe4dcb50", + "size": 3485855, + "subdir": "linux-64", + "timestamp": 1530382744009, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py27hdbf6ddf_3.conda": { + "build": "py27hdbf6ddf_3", + "build_number": 3, + "constrains": [ + "numpy 1.14.5 py27hcd700cb_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "dae7a0404d082c723d3dec7f0fc94727", + "name": "numpy-base", + "sha256": "129783c322a99d91380a1266db413bfb75d17edf77ce0aeb61cad7d9d8f5798f", + "size": 3488133, + "subdir": "linux-64", + "timestamp": 1530554161054, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py27hdbf6ddf_4.conda": { + "build": "py27hdbf6ddf_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.5 py27h1b885b7_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "136f86e908a0115911db88bc4854f6c7", + "name": "numpy-base", + "sha256": "66dbc0df4195b82f6a0da586def1d058b4e8eed5809c87e5e54b2b040065aaa6", + "size": 3427523, + "subdir": "linux-64", + "timestamp": 1531326758643, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py35h2b20989_0.conda": { + "build": "py35h2b20989_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.5 py35h28100ab_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "04b854d83fe30eb093e5d4743b81ec57", + "name": "numpy-base", + "sha256": "813d73ee792653bd2045e06a44875050773f4b82b727c42fe7cd70f8c938cbde", + "size": 3483729, + "subdir": "linux-64", + "timestamp": 1528900946070, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py35h2b20989_4.conda": { + "build": "py35h2b20989_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.5 py35h2aefc1b_4" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "3643b7500be1740991575c6a39c7ee6a", + "name": "numpy-base", + "sha256": "88e88a521ed200a30ac8f6fb1a8acb662a15025051e3475b9b6b1b5b6d218ab4", + "size": 3425606, + "subdir": "linux-64", + "timestamp": 1534347276868, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py35hdbf6ddf_0.conda": { + "build": "py35hdbf6ddf_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.5 py35hcd700cb_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "4ccfcdcd9cac79156e98e8850afaeeea", + "name": "numpy-base", + "sha256": "8026b421c98c38c876d79c122bf1f22ef4c88637617b221c2dcfbd9e079e91b7", + "size": 3553284, + "subdir": "linux-64", + "timestamp": 1528901264729, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py35hdbf6ddf_4.conda": { + "build": "py35hdbf6ddf_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.5 py35h1b885b7_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "9fe722db2256b8fb1e7ed61dfd685921", + "name": "numpy-base", + "sha256": "852d1c956494c9a109da3add2d9ef9b30b87d46fcc9506b3aeb1999d3f49f46b", + "size": 3474128, + "subdir": "linux-64", + "timestamp": 1534346974730, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36h2b20989_0.conda": { + "build": "py36h2b20989_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.5 py36h28100ab_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "afaa2fa95c8a7c3f290acb73d06c1075", + "name": "numpy-base", + "sha256": "c1bc0434c7967ba56b8e10fe82e88f8e5774fe0c3d692b7ec32acbe34a0bab3d", + "size": 3492368, + "subdir": "linux-64", + "timestamp": 1528900361631, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36h2b20989_1.conda": { + "build": "py36h2b20989_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.5 py36h28100ab_1" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "5e29194eb1ca967bf67216c84ba2bae0", + "name": "numpy-base", + "sha256": "c35367d84492206a99ebdc73ab1aaa35de05d2d5061981da2dc968e31b704809", + "size": 3474099, + "subdir": "linux-64", + "timestamp": 1530352911359, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36h2b20989_2.conda": { + "build": "py36h2b20989_2", + "build_number": 2, + "constrains": [ + "numpy 1.14.5 py36h28100ab_2" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "c3b711162ad0844472ca9a580158f37e", + "name": "numpy-base", + "sha256": "5e746836ccaf9dd24635fec1a69e4f3f3745aa90514f8da86b00db5e9387eba4", + "size": 3476282, + "subdir": "linux-64", + "timestamp": 1530382306729, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36h2b20989_3.conda": { + "build": "py36h2b20989_3", + "build_number": 3, + "constrains": [ + "numpy 1.14.5 py36h28100ab_3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "709d6f7ecdb2dc697f36b48a82f38ac1", + "name": "numpy-base", + "sha256": "780f8f9a16675ab8108129a11ab7440b58f9c6d741cc6808081df0307b9e05d1", + "size": 3492194, + "subdir": "linux-64", + "timestamp": 1530552739585, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36h2b20989_4.conda": { + "build": "py36h2b20989_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.5 py36h2aefc1b_4" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "dfef7b08d1a53da80589713105e66b56", + "name": "numpy-base", + "sha256": "a567412601b3bcbe9fa645099ab2612a9497f3cc27efd0db5bf3f540390d2193", + "size": 3415094, + "subdir": "linux-64", + "timestamp": 1531327695065, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36hdbf6ddf_0.conda": { + "build": "py36hdbf6ddf_0", + "build_number": 0, + "constrains": [ + "numpy 1.14.5 py36hcd700cb_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "0b6db305046642d952ac7159d9a4d7a3", + "name": "numpy-base", + "sha256": "07c5db8a7bde689b4aa0f7104e0b2710622b351f045bd1f6486fa228707647f9", + "size": 3524480, + "subdir": "linux-64", + "timestamp": 1528900963107, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36hdbf6ddf_1.conda": { + "build": "py36hdbf6ddf_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.5 py36hcd700cb_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "89f166e9b082ad3c67afcb4786c18322", + "name": "numpy-base", + "sha256": "9a7bba66fd37d39b6013c2ed24058bbae420b7e66597ab9dd709a3a9157f57dd", + "size": 3523726, + "subdir": "linux-64", + "timestamp": 1530353566518, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36hdbf6ddf_2.conda": { + "build": "py36hdbf6ddf_2", + "build_number": 2, + "constrains": [ + "numpy 1.14.5 py36hcd700cb_2" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "cdbd19e53610431cdfa78fa7ce7029c2", + "name": "numpy-base", + "sha256": "a0cc536ff773866910a6b9078fae2106c6fa564ddf2027c332bdd07ff4562154", + "size": 3523473, + "subdir": "linux-64", + "timestamp": 1530383180770, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36hdbf6ddf_3.conda": { + "build": "py36hdbf6ddf_3", + "build_number": 3, + "constrains": [ + "numpy 1.14.5 py36hcd700cb_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "38e87a109f1daae3ed822b8e465841ac", + "name": "numpy-base", + "sha256": "76c1e69e0bed24cc630433dc0924d8526523a051ceb49335631bfd450aafc0bc", + "size": 3539023, + "subdir": "linux-64", + "timestamp": 1530553377190, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py36hdbf6ddf_4.conda": { + "build": "py36hdbf6ddf_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.5 py36h1b885b7_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "70e8406773a8e811b1a1c63e5e3744ad", + "name": "numpy-base", + "sha256": "297207a2440da94fa60e72d698468e3b74bfd2c18ac74cd91dc7079ce2b70a17", + "size": 3464912, + "subdir": "linux-64", + "timestamp": 1531342855068, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py37h2b20989_1.conda": { + "build": "py37h2b20989_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.5 py37h28100ab_1" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "39caf3d8f212d69834ea4c94229a47c3", + "name": "numpy-base", + "sha256": "397ad919f2012008ea6d7fb0d9438569f44f6056b44e628a36034019dd53b3f1", + "size": 3459169, + "subdir": "linux-64", + "timestamp": 1530353310003, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py37h2b20989_2.conda": { + "build": "py37h2b20989_2", + "build_number": 2, + "constrains": [ + "numpy 1.14.5 py37h28100ab_2" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "f3bff9e10799c70efb80eb04f2fafa8b", + "name": "numpy-base", + "sha256": "72d42f3818233a744bb78d58cce98944471f095501d322a4cb01e087f3d61b77", + "size": 3476311, + "subdir": "linux-64", + "timestamp": 1530382719240, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py37h2b20989_3.conda": { + "build": "py37h2b20989_3", + "build_number": 3, + "constrains": [ + "numpy 1.14.5 py37h28100ab_3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "2d115e5c8b1b36ad95ff20781ef2cab9", + "name": "numpy-base", + "sha256": "bb58dba1a69fe57f2d80264b7fbb0b0f758c3e788dc7180a3794d082e4452a17", + "size": 3476498, + "subdir": "linux-64", + "timestamp": 1530553106104, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py37h2b20989_4.conda": { + "build": "py37h2b20989_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.5 py37h2aefc1b_4" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "edea4eef3d3c46ea7c509e694fbd93d2", + "name": "numpy-base", + "sha256": "572d88f283017f398d5718df3cb63cca6724b65a8f963a3eb4234e1c2cf3fda4", + "size": 3422103, + "subdir": "linux-64", + "timestamp": 1531327064346, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py37hdbf6ddf_1.conda": { + "build": "py37hdbf6ddf_1", + "build_number": 1, + "constrains": [ + "numpy 1.14.5 py37hcd700cb_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "bcf433a7b158f0954d0dfbeac68d0604", + "name": "numpy-base", + "sha256": "ea49bd07a486f81375f6d66c87d8e1e1565b7fa3db027e2597470699521bf54e", + "size": 3505789, + "subdir": "linux-64", + "timestamp": 1530353639685, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py37hdbf6ddf_2.conda": { + "build": "py37hdbf6ddf_2", + "build_number": 2, + "constrains": [ + "numpy 1.14.5 py37hcd700cb_2" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "1f39ed3ac6d01288fd8051440ec9f265", + "name": "numpy-base", + "sha256": "336b01604f7ba81ed54c33a26dbb5c1b6586b9a580af0d2f87a52e11cd8a9a20", + "size": 3526985, + "subdir": "linux-64", + "timestamp": 1530383125671, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py37hdbf6ddf_3.conda": { + "build": "py37hdbf6ddf_3", + "build_number": 3, + "constrains": [ + "numpy 1.14.5 py37hcd700cb_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "21fe4090389747a407de809d3c8c33d2", + "name": "numpy-base", + "sha256": "d7fcd3234839f3e081c61a7d77acfd67df686160399a312c348f5c942fd79964", + "size": 3506054, + "subdir": "linux-64", + "timestamp": 1530553379902, + "version": "1.14.5" + }, + "numpy-base-1.14.5-py37hdbf6ddf_4.conda": { + "build": "py37hdbf6ddf_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.5 py37h1b885b7_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "ea74110b7745573521d57575e4b515c5", + "name": "numpy-base", + "sha256": "049da818735e7b0f2f0df8559c3e474ce130796b17fe5eb6c6687f4ffa29ae82", + "size": 3446817, + "subdir": "linux-64", + "timestamp": 1531327385152, + "version": "1.14.5" + }, + "numpy-base-1.14.6-py27h2f8d375_4.conda": { + "build": "py27h2f8d375_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py27hec00662_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "5d58fcd563bd99d777b965ee5f005098", + "name": "numpy-base", + "sha256": "74d46b742a830d01c2424152b68d48dcd0b608c5c98293605a8293a437cb64c2", + "size": 3424018, + "subdir": "linux-64", + "timestamp": 1538074835750, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py27h2f8d375_5.conda": { + "build": "py27h2f8d375_5", + "build_number": 5, + "constrains": [ + "numpy 1.14.6 py27hec00662_5" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "d5b8e46aa2d3c85018d782fa03eb4005", + "name": "numpy-base", + "sha256": "52747cd80813759f0a0ac681566b0fd952e20dfda1fd6765e8e4891ebae6baf4", + "size": 3406944, + "subdir": "linux-64", + "timestamp": 1569339380897, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py27h81de0dd_4.conda": { + "build": "py27h81de0dd_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py27h3b04361_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "062bc9c60266a44b3d3a1b00abfb4e20", + "name": "numpy-base", + "sha256": "eda9adf5dfb46ae1db1b601ac011a1f655a676356e4e7013a6879117dbd6669b", + "size": 3468658, + "subdir": "linux-64", + "timestamp": 1538074646411, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py27hde5b4d6_5.conda": { + "build": "py27hde5b4d6_5", + "build_number": 5, + "constrains": [ + "numpy 1.14.6 py27h3b04361_5" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "7c71d881e86ebb460e601cf075e3db10", + "name": "numpy-base", + "sha256": "efb1f0182b96e0978b8cdf4be0a72a75978232189ad4c20873a3ebaa75995c3e", + "size": 3431249, + "subdir": "linux-64", + "timestamp": 1569339397590, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py35h2f8d375_4.conda": { + "build": "py35h2f8d375_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py35hec00662_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "e39064b7e6750c4e93263ee172c3d58f", + "name": "numpy-base", + "sha256": "04618bcb8c3e6563c6145aedb6916a841096d140cb736d4115b5825732c6ff01", + "size": 3445224, + "subdir": "linux-64", + "timestamp": 1538074493229, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py35h81de0dd_4.conda": { + "build": "py35h81de0dd_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py35h3b04361_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "ea01e2cb2d171a968147f93002b9d81d", + "name": "numpy-base", + "sha256": "b3718d4e9270064cd3cfd4631bb446e41c397dd93f7670dec8de9e1fde6670fd", + "size": 3519813, + "subdir": "linux-64", + "timestamp": 1538074906028, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py36h2f8d375_4.conda": { + "build": "py36h2f8d375_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py36hec00662_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "d95b6515327b5ef25f355235bb82ca93", + "name": "numpy-base", + "sha256": "91f437e03f1cc98a559bb9cd1c5cb790ce7de5fba8f58c80d5b8120863ce4d67", + "size": 3438144, + "subdir": "linux-64", + "timestamp": 1538074826622, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py36h2f8d375_5.conda": { + "build": "py36h2f8d375_5", + "build_number": 5, + "constrains": [ + "numpy 1.14.6 py36hec00662_5" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "77090931f21b16d43757e38d54606838", + "name": "numpy-base", + "sha256": "a5a22686b404a9a51aaa07ef4d87b131101b061667a67da72ee5d0d1c6a88efb", + "size": 3452639, + "subdir": "linux-64", + "timestamp": 1569339268849, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py36h81de0dd_4.conda": { + "build": "py36h81de0dd_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py36h3b04361_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "e4b682abcdbbaa674539b7d63f5d9c44", + "name": "numpy-base", + "sha256": "ec1ca858ce1209a9be2147ace2b0508bc8aebae9ea293fb8a9d333dccae6d988", + "size": 3486921, + "subdir": "linux-64", + "timestamp": 1538075066840, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py36hde5b4d6_5.conda": { + "build": "py36hde5b4d6_5", + "build_number": 5, + "constrains": [ + "numpy 1.14.6 py36h3b04361_5" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "bda13e8d5a6577243561a8c5f87d8f4b", + "name": "numpy-base", + "sha256": "d8d0d63c0610d71db5ad9e6f0045aef68327d3059b15fd558fa2460fd97b052e", + "size": 3508007, + "subdir": "linux-64", + "timestamp": 1569339416422, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py37h2f8d375_4.conda": { + "build": "py37h2f8d375_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py37hec00662_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "5aa21c1c513f328286993c158eee89cc", + "name": "numpy-base", + "sha256": "797911531e19baa8ae7d682ab48549c32b678cab11b7085aa439bbb01e793862", + "size": 3440514, + "subdir": "linux-64", + "timestamp": 1538074406834, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py37h2f8d375_5.conda": { + "build": "py37h2f8d375_5", + "build_number": 5, + "constrains": [ + "numpy 1.14.6 py37hec00662_5" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "6ab4ab16a8512d205023354dcad96d36", + "name": "numpy-base", + "sha256": "2ee5d422916f0d8f28214fe49a1fe86f4c586be8088cf49520af2ba53ad1da91", + "size": 3411513, + "subdir": "linux-64", + "timestamp": 1569339375784, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py37h81de0dd_4.conda": { + "build": "py37h81de0dd_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py37h3b04361_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "e4862e6def8667f4d6dd18f5f75cdb1f", + "name": "numpy-base", + "sha256": "b2c35a0267a1b08b495c1cbcd36f4214bc8a7a318ad5cdc382d3b6818a1b3b5a", + "size": 3491053, + "subdir": "linux-64", + "timestamp": 1538074923650, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py37hde5b4d6_5.conda": { + "build": "py37hde5b4d6_5", + "build_number": 5, + "constrains": [ + "numpy 1.14.6 py37h3b04361_5" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "a8865ab06759e80a2da8b6b630a5a568", + "name": "numpy-base", + "sha256": "71ddddb9fd6d8165833fffa465172937e3631c79b457198b41ae64019444e1df", + "size": 3486469, + "subdir": "linux-64", + "timestamp": 1569339415460, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py38h2f8d375_4.conda": { + "build": "py38h2f8d375_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py38h1e1a116_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "601c936b4f1b62e559cebd9bf6a9521d", + "name": "numpy-base", + "sha256": "70787fafba4264ef2f387a7438a7522818e9bff9d6cd905c0178b80e19ba24ea", + "size": 3480804, + "subdir": "linux-64", + "timestamp": 1574081282166, + "version": "1.14.6" + }, + "numpy-base-1.14.6-py38hde5b4d6_4.conda": { + "build": "py38hde5b4d6_4", + "build_number": 4, + "constrains": [ + "numpy 1.14.6 py38h056ac22_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "71449a39d6bfebb33f549bd299c227a2", + "name": "numpy-base", + "sha256": "b48b538d1f1e7bc850abf1146f1bff5e3671108d215c7b20170aed61c05c593d", + "size": 3532672, + "subdir": "linux-64", + "timestamp": 1574081539538, + "version": "1.14.6" + }, + "numpy-base-1.15.0-py27h1793315_0.conda": { + "build": "py27h1793315_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "e2c2d103ed017a9bc0363e2d82241cee", + "name": "numpy-base", + "sha256": "c6a5e5d403b0b64c3436b6e5cd1eaf795aa2bdc7f68f9e54aa2e1f59f0242f93", + "size": 3520146, + "subdir": "linux-64", + "timestamp": 1534776841547, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py27h3dfced4_0.conda": { + "build": "py27h3dfced4_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.0 py27h1b885b7_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "af137fd07540f9cf242b4838d61dc2d8", + "name": "numpy-base", + "sha256": "fbe5af89588d98258d0efbf85dc7feb48518dbd1919848b0723423dd2bf2fabf", + "size": 3498146, + "subdir": "linux-64", + "timestamp": 1532704137885, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py27h7cdd4dd_0.conda": { + "build": "py27h7cdd4dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.0 py27h2aefc1b_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "74aa889d5a7611e28001e617f664cd2a", + "name": "numpy-base", + "sha256": "15ad0873fd61fb26b057d24fe8ba72c3e8d8ba3c9ab5818d5d7f51d50168cc3f", + "size": 3476058, + "subdir": "linux-64", + "timestamp": 1532703398020, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py27hc937464_0.conda": { + "build": "py27hc937464_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "c9c4e61ccbe1e4d90564f5dae9ac11c5", + "name": "numpy-base", + "sha256": "f35d7bb879ed9c9f3a955d87cd52e1735bcdf85991eaffef25a30d3713599b78", + "size": 3453749, + "subdir": "linux-64", + "timestamp": 1534777018249, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py35h1793315_0.conda": { + "build": "py35h1793315_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "77e2c30a8dd720e503d400315c88876f", + "name": "numpy-base", + "sha256": "392964168f5f016bcab357686c374a1d33580d8386a7ad75b84cb73e619c5f37", + "size": 3546605, + "subdir": "linux-64", + "timestamp": 1534776465129, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py35h3dfced4_0.conda": { + "build": "py35h3dfced4_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.0 py35h1b885b7_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "db8a431ef38ef19615dd1088f3f9ae66", + "name": "numpy-base", + "sha256": "ad08ab00599f85edf0f62cf08c7af04edc97894c17c43bb3c33c361fb97b8120", + "size": 3572409, + "subdir": "linux-64", + "timestamp": 1532704512767, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py35h7cdd4dd_0.conda": { + "build": "py35h7cdd4dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.0 py35h2aefc1b_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "fb75f70a79aab533781f749d8797412e", + "name": "numpy-base", + "sha256": "fcb042f13c517bf017d71be463b532c093542bae56e2a6b2bb381f3bfad7b1a9", + "size": 3526873, + "subdir": "linux-64", + "timestamp": 1532703650867, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py35hc937464_0.conda": { + "build": "py35hc937464_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "47524c1552a5874b2de7910bfa73db0d", + "name": "numpy-base", + "sha256": "7e508f93d53022ef1f266bf0aceda3c99a10fcd46f02f1556f8db5b4ce127b96", + "size": 3501778, + "subdir": "linux-64", + "timestamp": 1534776656915, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py36h1793315_0.conda": { + "build": "py36h1793315_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "372cd34171458d90aca0dbc6e051a4c4", + "name": "numpy-base", + "sha256": "e0c451a9d3c25e89ca51c40a981f05a2ff57a91c275f6c4e5057fdf32fed47a3", + "size": 3562053, + "subdir": "linux-64", + "timestamp": 1534777215714, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py36h3dfced4_0.conda": { + "build": "py36h3dfced4_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.0 py36h1b885b7_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "205acbd3dd0af8f4e7e7700393bbfa35", + "name": "numpy-base", + "sha256": "f36dc4bfd033522abf5d1167c2660c212eeeec151b0b47a961c064643166d24f", + "size": 3542344, + "subdir": "linux-64", + "timestamp": 1532704474927, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py36h7cdd4dd_0.conda": { + "build": "py36h7cdd4dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.0 py36h2aefc1b_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "49669482f7e1225ef5d582662e6ed28c", + "name": "numpy-base", + "sha256": "b9ae46f6c3d90bbcc1af0490a781e132f27568a8dfccdd81853c345f2da6a768", + "size": 3517074, + "subdir": "linux-64", + "timestamp": 1532703420854, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py36hc937464_0.conda": { + "build": "py36hc937464_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "d42371dd70089945ec0cf7b4e7e3ccec", + "name": "numpy-base", + "sha256": "0665869db1b2b18e1d8af8076851947a40034c29c1c5071c3986da09b97ebe5f", + "size": 3517427, + "subdir": "linux-64", + "timestamp": 1534777399979, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py37h1793315_0.conda": { + "build": "py37h1793315_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "9eb6898eb61391afc8cad684149c0803", + "name": "numpy-base", + "sha256": "e30f6f2ebba7dcc1456161080fbabc18643700b1eb3a27a8a30af925cd5cf5bd", + "size": 3520469, + "subdir": "linux-64", + "timestamp": 1534777593309, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py37h3dfced4_0.conda": { + "build": "py37h3dfced4_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.0 py37h1b885b7_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "d7508dd9b52968ec34e909036285a585", + "name": "numpy-base", + "sha256": "f8c0cfbbd583813e2b31991b9bc7a39d8050c3e32cd71f42a72c3e7ef00c9378", + "size": 3520438, + "subdir": "linux-64", + "timestamp": 1532704521722, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py37h7cdd4dd_0.conda": { + "build": "py37h7cdd4dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.0 py37h2aefc1b_0" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "94b971e3023ea5fee8bd7a6225315ed0", + "name": "numpy-base", + "sha256": "333378120048646e21d362241f75c33c686119da022421bbaf7c1f1cadc77e3c", + "size": 3496199, + "subdir": "linux-64", + "timestamp": 1532703654610, + "version": "1.15.0" + }, + "numpy-base-1.15.0-py37hc937464_0.conda": { + "build": "py37hc937464_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "a449c2ff69b83daca290148fd5b9ecce", + "name": "numpy-base", + "sha256": "d2dc3b0b76d862ffc2754c2e5a817dc3de110ba4299f728d8bbf6cf8e4266dde", + "size": 3472588, + "subdir": "linux-64", + "timestamp": 1534777772553, + "version": "1.15.0" + }, + "numpy-base-1.15.1-py27h2f8d375_0.conda": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "c980a0288c82ee4480743dd4ca0494b0", + "name": "numpy-base", + "sha256": "a051e93e0d683ba6fa805aa13bdba4b6029ec2a8a2072971d1b60f77f9de74b6", + "size": 3494253, + "subdir": "linux-64", + "timestamp": 1536895316662, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py27h74e8950_0.conda": { + "build": "py27h74e8950_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "0af61be91406adc6daa3790f73fd2b1b", + "name": "numpy-base", + "sha256": "b10814771560b436def8e4b8b312a101c36031816db78880fbda62c6d2301990", + "size": 3470851, + "subdir": "linux-64", + "timestamp": 1535389394251, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py27h81de0dd_0.conda": { + "build": "py27h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "0dfff7e4122b52716aa2d3ebc80dd1fe", + "name": "numpy-base", + "sha256": "7a48d2720fa0491d83788c7d57695aed20c5da0c955f614da0536f7674d278cb", + "size": 3517153, + "subdir": "linux-64", + "timestamp": 1535389805791, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py35h2f8d375_0.conda": { + "build": "py35h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1 py35h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "f05b50001d4bcd2c243c665f6ab2664c", + "name": "numpy-base", + "sha256": "426f24985cbe857dfce69a82369249be2330ff549394c9912b31a233fb806366", + "size": 3517483, + "subdir": "linux-64", + "timestamp": 1536895272494, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py35h74e8950_0.conda": { + "build": "py35h74e8950_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "47386b3b9e47c8f58d4b449117990e1d", + "name": "numpy-base", + "sha256": "2771218e42ce396a6954bc1aab9b8482b7496d7472313f66e002d2516e70e077", + "size": 3542749, + "subdir": "linux-64", + "timestamp": 1535389366469, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py35h81de0dd_0.conda": { + "build": "py35h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "1d714ff8fb3241e3ae6277c3181a7da5", + "name": "numpy-base", + "sha256": "5949554adf213a123c348255fff0a11ddf17c6d151768a7a54cd0ef9616ac0f7", + "size": 3568838, + "subdir": "linux-64", + "timestamp": 1535389452640, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py36h2f8d375_0.conda": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "096f1e4f25c43d121376f92110a81ba2", + "name": "numpy-base", + "sha256": "6c60f9975eed20a109a29478e0932cb3ce6cbc5e580d841fcc5be6a9e3f743dd", + "size": 3530414, + "subdir": "linux-64", + "timestamp": 1536895322157, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py36h74e8950_0.conda": { + "build": "py36h74e8950_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "e91f6d49e91f536a7ba4ea622c22dae9", + "name": "numpy-base", + "sha256": "44ecc29ab96f5af708bfcb9b4707a35b579862ab13bc7431bef10daf4937da0d", + "size": 3530742, + "subdir": "linux-64", + "timestamp": 1535389480468, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py36h81de0dd_0.conda": { + "build": "py36h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "18fed472643b8550ecf780d41bea6d3a", + "name": "numpy-base", + "sha256": "c0116f44d890f0f8c6b2810c0cc22e12165243db0b0a183a7df620c54481ab9e", + "size": 3580636, + "subdir": "linux-64", + "timestamp": 1535389847620, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py37h2f8d375_0.conda": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "72563439bd7755475975b005d415b808", + "name": "numpy-base", + "sha256": "dd5d682ab598a9d19fa2854431b8a5d08ed53d0a76d917da11ddb1b0719f5628", + "size": 3511835, + "subdir": "linux-64", + "timestamp": 1536895325842, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py37h74e8950_0.conda": { + "build": "py37h74e8950_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "04713c37e1749ecaa6e0d7edf5afbcdf", + "name": "numpy-base", + "sha256": "33f2292747631819daaabf7350b2898e241665bf3e2111fc10a6c7c126270a5f", + "size": 3486260, + "subdir": "linux-64", + "timestamp": 1535389467846, + "version": "1.15.1" + }, + "numpy-base-1.15.1-py37h81de0dd_0.conda": { + "build": "py37h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "e07b7d7c6c7046a9678e378e468c346b", + "name": "numpy-base", + "sha256": "956d1f2e2745e21358e2815469f982c3fed1666e434c67ce7627d4e69de33b77", + "size": 3536063, + "subdir": "linux-64", + "timestamp": 1535389845725, + "version": "1.15.1" + }, + "numpy-base-1.15.2-py27h2f8d375_0.conda": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.2 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "b50acd349994fb1abaf806b29e85f8f9", + "name": "numpy-base", + "sha256": "db84e6b201cb8041b4a0952f9318775cf7f2f8e78e2b4892f7d26d8333a645e6", + "size": 3503305, + "subdir": "linux-64", + "timestamp": 1538073508434, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py27h2f8d375_1.conda": { + "build": "py27h2f8d375_1", + "build_number": 1, + "constrains": [ + "numpy 1.15.2 py27h99e49ec_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "eece0a91edf5c114dc90b7ea74776093", + "name": "numpy-base", + "sha256": "513b8dfe0a857a68ca3647b74f214aa61b2eac773f54a9b577a88d4b372ca850", + "size": 3504038, + "subdir": "linux-64", + "timestamp": 1538500374510, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py27h81de0dd_0.conda": { + "build": "py27h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.2 py27h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "58462a52d99db3f18931a3b61024af55", + "name": "numpy-base", + "sha256": "ba4e1bb466a88b7919efc465189e6717fd4205ecf39d8699559423b0af5ef043", + "size": 3526360, + "subdir": "linux-64", + "timestamp": 1538073672738, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py27h81de0dd_1.conda": { + "build": "py27h81de0dd_1", + "build_number": 1, + "constrains": [ + "numpy 1.15.2 py27h1d66e8a_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "70c603c36939f9f70b94dfc1175ac362", + "name": "numpy-base", + "sha256": "6b9d57341e5ff59cde063d58a3186a55a036b15af4862c6ac1380855c4295017", + "size": 3528547, + "subdir": "linux-64", + "timestamp": 1538500416087, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py35h2f8d375_0.conda": { + "build": "py35h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.2 py35h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "20c2cb7d6f88b5a572ba619682a0d4c4", + "name": "numpy-base", + "sha256": "3f0e383952b7b932e9aa9e1bb71e104c809791efd2abea710a42ab4cd07510f5", + "size": 3554797, + "subdir": "linux-64", + "timestamp": 1538073919846, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py35h81de0dd_0.conda": { + "build": "py35h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.2 py35h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "270f49f0219174c63e990a6907722a8c", + "name": "numpy-base", + "sha256": "aafc62f4889de55392a2e87f5d2ad9c346eca0011a1a597a72d168f85d547818", + "size": 3579799, + "subdir": "linux-64", + "timestamp": 1538073717837, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py36h2f8d375_0.conda": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.2 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "6f2e6ebd7cb3091fa457ef172671d15b", + "name": "numpy-base", + "sha256": "3586ec55c64680836f83578ee29cd76c6b0a68db26baaede922fe331fd3467c1", + "size": 3541093, + "subdir": "linux-64", + "timestamp": 1538074191298, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py36h2f8d375_1.conda": { + "build": "py36h2f8d375_1", + "build_number": 1, + "constrains": [ + "numpy 1.15.2 py36h99e49ec_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "3b31f24f607838c02beda3a55ac25e86", + "name": "numpy-base", + "sha256": "44e079bc105fad61cb864a1a27761d14ac1fdb0c0568f1e059b1e820b48f68c8", + "size": 3541854, + "subdir": "linux-64", + "timestamp": 1538500368412, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py36h81de0dd_0.conda": { + "build": "py36h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.2 py36h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "92e9c1dcf41a4193a0d7ce3d83ca4883", + "name": "numpy-base", + "sha256": "01d25124977a8c375488a633d971f82f74c3501d88801d87be3985f7bab226d5", + "size": 3591697, + "subdir": "linux-64", + "timestamp": 1538074301960, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py36h81de0dd_1.conda": { + "build": "py36h81de0dd_1", + "build_number": 1, + "constrains": [ + "numpy 1.15.2 py36h1d66e8a_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "0c47644e1c63929e93cb2fed07cb450e", + "name": "numpy-base", + "sha256": "4cd38ff37ec775c2f1356564b3d566bcb8c50a09d7aed9fca7495ef2c102c439", + "size": 3564971, + "subdir": "linux-64", + "timestamp": 1538500643328, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py37h2f8d375_0.conda": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.2 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "05e805fbd568d83480c617a6a4d0d09e", + "name": "numpy-base", + "sha256": "a4b23b8cf687aa58302104c0dd4bbf49f8440e093637355de1a99077377d55f8", + "size": 3496492, + "subdir": "linux-64", + "timestamp": 1538073456069, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py37h2f8d375_1.conda": { + "build": "py37h2f8d375_1", + "build_number": 1, + "constrains": [ + "numpy 1.15.2 py37h99e49ec_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "4e46a8e7d3228c4f5b8e2c9a4b3e5bdf", + "name": "numpy-base", + "sha256": "1cafd2a066c83a9d8468e7b3b225585a133a13e2824313496fc2a03c07c68d2c", + "size": 3498165, + "subdir": "linux-64", + "timestamp": 1538504536351, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py37h81de0dd_0.conda": { + "build": "py37h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.2 py37h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "03d719cf26d4c159438c8e3abe8cc3a5", + "name": "numpy-base", + "sha256": "2f2478ba0bbb5f84a7867608a88b0261901bc5d35c6f0d7da599cf095cbadd7c", + "size": 3546835, + "subdir": "linux-64", + "timestamp": 1538073633618, + "version": "1.15.2" + }, + "numpy-base-1.15.2-py37h81de0dd_1.conda": { + "build": "py37h81de0dd_1", + "build_number": 1, + "constrains": [ + "numpy 1.15.2 py37h1d66e8a_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "f7f3e68499eaa8182cb5561a003da842", + "name": "numpy-base", + "sha256": "18db0301a9da5d322728fb5de55e207ebf9b2b0b825a3ce6afe47d677972acba", + "size": 3548566, + "subdir": "linux-64", + "timestamp": 1538504438223, + "version": "1.15.2" + }, + "numpy-base-1.15.3-py27h2f8d375_0.conda": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.3 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "34f6805a7ee203dec3413157d035dc8a", + "name": "numpy-base", + "sha256": "c6e4ec526df94ab3ace9e3e27dbe6f431863ce5280fc539d7b75e32f53e564e0", + "size": 3470611, + "subdir": "linux-64", + "timestamp": 1540314053224, + "version": "1.15.3" + }, + "numpy-base-1.15.3-py27h81de0dd_0.conda": { + "build": "py27h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.3 py27h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "156955b1d3ccedcbe5e7900cdb06c39c", + "name": "numpy-base", + "sha256": "3aa08a9543b02b48c83c393acd96fb30c1d6c2e4a3f33c31dafc3182ce9dafda", + "size": 3515192, + "subdir": "linux-64", + "timestamp": 1540314300855, + "version": "1.15.3" + }, + "numpy-base-1.15.3-py36h2f8d375_0.conda": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.3 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "994085156f4e7fff27bbf7fae60283d8", + "name": "numpy-base", + "sha256": "b171a83e4565b24484c38f52761ab4f6855136fa9f02ec1396a39a62a3106948", + "size": 3508036, + "subdir": "linux-64", + "timestamp": 1540314071276, + "version": "1.15.3" + }, + "numpy-base-1.15.3-py36h81de0dd_0.conda": { + "build": "py36h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.3 py36h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "23c746d1b95d0ed29c7a42a6da522ee4", + "name": "numpy-base", + "sha256": "d187b4a66398abbd9b15bc416a91965666907e5e2c880859f2ad5cd315a203f5", + "size": 3555669, + "subdir": "linux-64", + "timestamp": 1540314314048, + "version": "1.15.3" + }, + "numpy-base-1.15.3-py37h2f8d375_0.conda": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.3 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "009622fcb436e0a656673d53071685ea", + "name": "numpy-base", + "sha256": "6930ab4310b10099ce1f046b8fd8593989de7148f1bebca100dfbba53fb0e65b", + "size": 3490961, + "subdir": "linux-64", + "timestamp": 1540314105727, + "version": "1.15.3" + }, + "numpy-base-1.15.3-py37h81de0dd_0.conda": { + "build": "py37h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.3 py37h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "dca8ed793476a68746c88f321a77ecf4", + "name": "numpy-base", + "sha256": "2a1e14b9b43a60460df41fadd93906c1911c9e02c7977657fa23a240bdadb819", + "size": 3563304, + "subdir": "linux-64", + "timestamp": 1540314526322, + "version": "1.15.3" + }, + "numpy-base-1.15.4-py27h2f8d375_0.conda": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.4 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "20283c94f3391622002b2ca77bd26325", + "name": "numpy-base", + "sha256": "0f4f4e764ef6733809dff0dd2e47dad16fa23dda7a8c4b72fadf7beb279dda0c", + "size": 3478340, + "subdir": "linux-64", + "timestamp": 1541516682142, + "version": "1.15.4" + }, + "numpy-base-1.15.4-py27h81de0dd_0.conda": { + "build": "py27h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.4 py27h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "c77343a1bd3ac57bd22f9673a7d0e6f0", + "name": "numpy-base", + "sha256": "cf322e7a4fab3fe49651cf9f8c678ca9487db3c8a083771bd00013681559d9f6", + "size": 3500708, + "subdir": "linux-64", + "timestamp": 1541516991745, + "version": "1.15.4" + }, + "numpy-base-1.15.4-py27hde5b4d6_0.conda": { + "build": "py27hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.4 py27h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "c821a2ea50f1ac3ea4ff20a9b58d303e", + "name": "numpy-base", + "sha256": "a56115506149a8ec5723609659daaffb0ef7e547c4fbb45ee615c4a65093bcb1", + "size": 3511520, + "subdir": "linux-64", + "timestamp": 1544718119335, + "version": "1.15.4" + }, + "numpy-base-1.15.4-py36h2f8d375_0.conda": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.4 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "26fdf31fb576afa124d05d82f3393807", + "name": "numpy-base", + "sha256": "a4404bbd489c8fdb25e8cac37301a055176aebfc07f8c0ebe33ef6803f3b145a", + "size": 3502970, + "subdir": "linux-64", + "timestamp": 1541516682376, + "version": "1.15.4" + }, + "numpy-base-1.15.4-py36h81de0dd_0.conda": { + "build": "py36h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.4 py36h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "07f6ec462d3df5c950dd777343b63171", + "name": "numpy-base", + "sha256": "e7dceb305e8661a42916247e1979f61b33ca9eea7de1e219086ae87902b06d48", + "size": 3547857, + "subdir": "linux-64", + "timestamp": 1541516934789, + "version": "1.15.4" + }, + "numpy-base-1.15.4-py36hde5b4d6_0.conda": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.4 py36h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "057ade69adaef4ff36a6c798941a989d", + "name": "numpy-base", + "sha256": "0afc1cb195454da7f99b0478c29136bc26ff38e349552ffd81a4e12ce8aed65c", + "size": 3585523, + "subdir": "linux-64", + "timestamp": 1544718180181, + "version": "1.15.4" + }, + "numpy-base-1.15.4-py37h2f8d375_0.conda": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.4 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "a9f8170ebbc952003e00d5070e2de930", + "name": "numpy-base", + "sha256": "33f154ce121eb0f11e8a02f11be8229bb3ea9c53d40b0122e84a3d21d4abe079", + "size": 3508181, + "subdir": "linux-64", + "timestamp": 1541516534104, + "version": "1.15.4" + }, + "numpy-base-1.15.4-py37h81de0dd_0.conda": { + "build": "py37h81de0dd_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.4 py37h1d66e8a_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "d10af5021b01a46c5ae864a961d36bfb", + "name": "numpy-base", + "sha256": "e24e75809d9bc615ef63184f3cdb33818e07de1882c1836b00fa81036de667b3", + "size": 3557773, + "subdir": "linux-64", + "timestamp": 1541516895297, + "version": "1.15.4" + }, + "numpy-base-1.15.4-py37hde5b4d6_0.conda": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.15.4 py37h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "a00fdca365d123f5a373c159edb712cf", + "name": "numpy-base", + "sha256": "4b791faaf454db6b948b5cb5c04d0a586ba9552e660c00fd5a1b122b14a1a222", + "size": 3545096, + "subdir": "linux-64", + "timestamp": 1544718267245, + "version": "1.15.4" + }, + "numpy-base-1.16.0-py27h2f8d375_0.conda": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.0 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "77535dc2a4050d9547cbc8d1b021c57c", + "name": "numpy-base", + "sha256": "807c2c20405ca4705b217ba7f7c8f6541f5572c50465ad36cb06be9d096422de", + "size": 3553516, + "subdir": "linux-64", + "timestamp": 1551397975783, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py27h2f8d375_1.conda": { + "build": "py27h2f8d375_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.0 py27h99e49ec_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "4aef202c5c9d8d3d1794f0a621e481d3", + "name": "numpy-base", + "sha256": "fd4ea4df7a9cd1c337223f1b4124281d2aceb0f11a7865c693dd9eb4fcee7d56", + "size": 3554059, + "subdir": "linux-64", + "timestamp": 1551801641952, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py27hde5b4d6_0.conda": { + "build": "py27hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.0 py27h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "f17e8645450f1eeb3f069ef66c8b8546", + "name": "numpy-base", + "sha256": "6554c3cb75bbd929a13ea316481e1307649a1e837576341ce9b0a0f0376f5174", + "size": 3601729, + "subdir": "linux-64", + "timestamp": 1551398126159, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py27hde5b4d6_1.conda": { + "build": "py27hde5b4d6_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.0 py27h7e9f1db_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "62d683ee6e50a499e0670973a4ceeb1e", + "name": "numpy-base", + "sha256": "e95f6e20770fcb795f5f0bf5cba27327d0126f6b33883f421784ef2ee5f88a85", + "size": 3600718, + "subdir": "linux-64", + "timestamp": 1551801971662, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py36h2f8d375_0.conda": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.0 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "b8901c39e9590609ed23e47e7d1ad9c5", + "name": "numpy-base", + "sha256": "24496e9c38a1941ce6440c280fbf80b9426fe019676d276202f48b0cfa3cd879", + "size": 3631215, + "subdir": "linux-64", + "timestamp": 1551398059317, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py36h2f8d375_1.conda": { + "build": "py36h2f8d375_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.0 py36h99e49ec_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "058af3f90f58b8ec91c510661fe221de", + "name": "numpy-base", + "sha256": "033046cd440e9d40a57d8eb8d4fc09ce9d356f089710312360d0dc314dca1248", + "size": 3603987, + "subdir": "linux-64", + "timestamp": 1551801724471, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py36hde5b4d6_0.conda": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.0 py36h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "ea51542bf5641e37007278feb4967695", + "name": "numpy-base", + "sha256": "95674462a7e430391608fdea911c4054bd40fcea7c5f3c799ae70e06c152ffbb", + "size": 3656331, + "subdir": "linux-64", + "timestamp": 1551398176956, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py36hde5b4d6_1.conda": { + "build": "py36hde5b4d6_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.0 py36h7e9f1db_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "7ab6d919da1211783df8d8027e45082b", + "name": "numpy-base", + "sha256": "8782f153563fa8bc628c3c44fa7cbb0f6decfb6fc7987b036d7c79d6849f2f5b", + "size": 3655661, + "subdir": "linux-64", + "timestamp": 1551802013064, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py37h2f8d375_0.conda": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.0 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "35efcdc868efbbb77b3f4eaadfe2b23f", + "name": "numpy-base", + "sha256": "10081d5e2ee7b6a4066fb7effd50e0b0141ea12ee18686a1338bdadd5b3edae6", + "size": 3586956, + "subdir": "linux-64", + "timestamp": 1551398009560, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py37h2f8d375_1.conda": { + "build": "py37h2f8d375_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.0 py37h99e49ec_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "c3949f6e4fdda68d5bf654ed47005bf4", + "name": "numpy-base", + "sha256": "297a07796366c55d01fe1d5a1868e636747ad3d93467bac3947a2fecec035297", + "size": 3612420, + "subdir": "linux-64", + "timestamp": 1551801618210, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py37hde5b4d6_0.conda": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.0 py37h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "296d6ba917a6216c0b5c73f50c0fe4f9", + "name": "numpy-base", + "sha256": "232da952c7069a7f507161dc052ccfe3af94661efe6768452ab2d400c1ed9be4", + "size": 3661055, + "subdir": "linux-64", + "timestamp": 1551398047661, + "version": "1.16.0" + }, + "numpy-base-1.16.0-py37hde5b4d6_1.conda": { + "build": "py37hde5b4d6_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.0 py37h7e9f1db_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "a2b230c4e4a29e6fcaf9f0ec09192417", + "name": "numpy-base", + "sha256": "f1063f0b20145d068cc18000bbfba7dee1f9f162e2e04d5873eb5628b10df035", + "size": 3663332, + "subdir": "linux-64", + "timestamp": 1551801861338, + "version": "1.16.0" + }, + "numpy-base-1.16.1-py27h2f8d375_0.conda": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.1 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "a30640dbba0ae23ef49067c8d1ba17cc", + "name": "numpy-base", + "sha256": "cbb4fdc3906636c5de31f778ec5cbfcffeedaa5b3d31548bc020f5fb46bb8043", + "size": 3566863, + "subdir": "linux-64", + "timestamp": 1551457053099, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py27h2f8d375_1.conda": { + "build": "py27h2f8d375_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.1 py27h99e49ec_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "d0f37b5f84d1ed304a55b56bfe40c3e3", + "name": "numpy-base", + "sha256": "b8aaed8f9a711c253f2c706adb830a2e1fa97d5f13a12e375ac6e17910e19118", + "size": 3566944, + "subdir": "linux-64", + "timestamp": 1551468046336, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py27hde5b4d6_0.conda": { + "build": "py27hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.1 py27h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "26707df92919ea377f41e860afb98261", + "name": "numpy-base", + "sha256": "75957fa936c47cdbdb57893b566a78bca6c1a0adedbd9515d05d174f1c25a15f", + "size": 3615080, + "subdir": "linux-64", + "timestamp": 1551457176464, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py27hde5b4d6_1.conda": { + "build": "py27hde5b4d6_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.1 py27h7e9f1db_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "c6056c828fd37d60873d8edceb31d254", + "name": "numpy-base", + "sha256": "728bbefb89151af5a49301b38e6450af69595ca1534d048032b9781e009cb02a", + "size": 3616010, + "subdir": "linux-64", + "timestamp": 1551468285186, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py36h2f8d375_0.conda": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.1 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "38c8e276a76580c825c5166327b3c8eb", + "name": "numpy-base", + "sha256": "264b2942efc7b473eeef9151653de33932a0c01049e861a4e5ebf0e1f80fbc1a", + "size": 3644455, + "subdir": "linux-64", + "timestamp": 1551457084791, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py36h2f8d375_1.conda": { + "build": "py36h2f8d375_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.1 py36h99e49ec_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "9318c3464a5503bd7f7c263055bf1a99", + "name": "numpy-base", + "sha256": "33319707e083eb8edc90117f31e49028cb80bd558082503d103d3faa7d021765", + "size": 3621591, + "subdir": "linux-64", + "timestamp": 1551468082286, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py36hde5b4d6_0.conda": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.1 py36h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "fe646eb6108c98857a9312f1ff86399e", + "name": "numpy-base", + "sha256": "7c028c770c02a73ceb41322d6a65659a9fe276c6de59024909a6bed889033d49", + "size": 3669938, + "subdir": "linux-64", + "timestamp": 1551457118643, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py36hde5b4d6_1.conda": { + "build": "py36hde5b4d6_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.1 py36h7e9f1db_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "f8010131c5f17491bcdbd73187ba0a53", + "name": "numpy-base", + "sha256": "40f204ef88819ba25914a66813f2c7e7a4349113d186453b385b41db7dc59936", + "size": 3671060, + "subdir": "linux-64", + "timestamp": 1551468235995, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py37h2f8d375_0.conda": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.1 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "0322bd2ea4668e2eb961a6b9cbef4417", + "name": "numpy-base", + "sha256": "f6348ededcb75958daa8b216d3ac84456e47b831a4e87596844bd237a6a06d9a", + "size": 3602788, + "subdir": "linux-64", + "timestamp": 1551457012875, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py37h2f8d375_1.conda": { + "build": "py37h2f8d375_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.1 py37h99e49ec_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "9a08799407e4bef2526c255fad00df46", + "name": "numpy-base", + "sha256": "8d02d360edbc0628ac5be41042b16763036756ab335f49b72f8f5471e4fd83fa", + "size": 3602391, + "subdir": "linux-64", + "timestamp": 1551468076103, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py37hde5b4d6_0.conda": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.1 py37h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "7a31ed0b29fbb0426efce56abd737780", + "name": "numpy-base", + "sha256": "4b3f7f4b6dd48bbc8906d51f1c7bdab9e6e5f364ab05937794e1a76263798024", + "size": 3676507, + "subdir": "linux-64", + "timestamp": 1551457146799, + "version": "1.16.1" + }, + "numpy-base-1.16.1-py37hde5b4d6_1.conda": { + "build": "py37hde5b4d6_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.1 py37h7e9f1db_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "057c75851632f99dafc3aedf0a4c1da0", + "name": "numpy-base", + "sha256": "14a772b9bc098b1fbd082bfd96fb03e4686ad49816a4150980bfc398d50151d0", + "size": 3675465, + "subdir": "linux-64", + "timestamp": 1551468127269, + "version": "1.16.1" + }, + "numpy-base-1.16.2-py27h2f8d375_0.conda": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.2 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "fb622a08f9da87f85a6940525162f1e7", + "name": "numpy-base", + "sha256": "49131d74ceb81f7543dc77024df74f159bfc31e4154ce19db9af3c6cc7b72dc6", + "size": 3595953, + "subdir": "linux-64", + "timestamp": 1551471213027, + "version": "1.16.2" + }, + "numpy-base-1.16.2-py27hde5b4d6_0.conda": { + "build": "py27hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.2 py27h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "d3528484ade2f5e966c0e6b30b1f90ac", + "name": "numpy-base", + "sha256": "fefcd254a552cf30c33c3ee3f8362c7b76d4ab2e5a36a5e7b19ec3d0d1e7dfb1", + "size": 3644529, + "subdir": "linux-64", + "timestamp": 1551471383092, + "version": "1.16.2" + }, + "numpy-base-1.16.2-py36h2f8d375_0.conda": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.2 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "bda998a178d7cf63907c2ca9ffc87de9", + "name": "numpy-base", + "sha256": "1d6911771337db063232cbec482d655fe9bf33bf0ea9daf5da0d30e3c3f3672b", + "size": 3623488, + "subdir": "linux-64", + "timestamp": 1551471206893, + "version": "1.16.2" + }, + "numpy-base-1.16.2-py36hde5b4d6_0.conda": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.2 py36h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "3ca20d27e44536bed729239600487ad6", + "name": "numpy-base", + "sha256": "5f943fc80187894f795125071e528dbdaae1427679f2bcda729ace54e3dd00c6", + "size": 3697917, + "subdir": "linux-64", + "timestamp": 1551471480217, + "version": "1.16.2" + }, + "numpy-base-1.16.2-py37h2f8d375_0.conda": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.2 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "e7db38f392cf941c07532989e7d59407", + "name": "numpy-base", + "sha256": "1b418c241fdff235d6fdf202b9f603702142ab9401cab22270821a1d3c02d1bf", + "size": 3628802, + "subdir": "linux-64", + "timestamp": 1551471189642, + "version": "1.16.2" + }, + "numpy-base-1.16.2-py37hde5b4d6_0.conda": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.2 py37h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.1,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "0fa9d3334aac9df73f88b9985db85686", + "name": "numpy-base", + "sha256": "5f58098852a446517d4394d5a57367aa84ca2822b7c647885310da84906b53d5", + "size": 3654890, + "subdir": "linux-64", + "timestamp": 1551471345326, + "version": "1.16.2" + }, + "numpy-base-1.16.3-py27h2f8d375_0.conda": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.3 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "3d1b004ad5f0dddec5a3d2b01880a35f", + "name": "numpy-base", + "sha256": "2291394100f26d39f112fbd415b0c112095edccc7e0286d51cf5e18600726cd3", + "size": 3599228, + "subdir": "linux-64", + "timestamp": 1555949411522, + "version": "1.16.3" + }, + "numpy-base-1.16.3-py27hde5b4d6_0.conda": { + "build": "py27hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.3 py27h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "077538d63dcff2211700e1005804141d", + "name": "numpy-base", + "sha256": "acf802160169a5d83758d0071f6c780d9c21d530392e2319ad05b1dcb84b1a5b", + "size": 3645986, + "subdir": "linux-64", + "timestamp": 1555949690025, + "version": "1.16.3" + }, + "numpy-base-1.16.3-py36h2f8d375_0.conda": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.3 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "490c0025f7d72d739e022263b18fc1a3", + "name": "numpy-base", + "sha256": "23ebabe7026db0f44581b40d490680c46d87af847878374e6c9edf74c24d2e2f", + "size": 3649029, + "subdir": "linux-64", + "timestamp": 1555949536687, + "version": "1.16.3" + }, + "numpy-base-1.16.3-py36hde5b4d6_0.conda": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.3 py36h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "04bed581f77c3404ae74dea1e7470541", + "name": "numpy-base", + "sha256": "beecdb2cff64a7203d387a86d43b9d96935106ab247ff1474809c1329aa0814d", + "size": 3698563, + "subdir": "linux-64", + "timestamp": 1555949712025, + "version": "1.16.3" + }, + "numpy-base-1.16.3-py37h2f8d375_0.conda": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.3 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "8bc792fc69eb7577bc250e113b40ca3c", + "name": "numpy-base", + "sha256": "93307f5b244a157fe2884d1c612019c9e2f5e5ef66cf4a933d4bd659db5a60c1", + "size": 3609615, + "subdir": "linux-64", + "timestamp": 1555949433549, + "version": "1.16.3" + }, + "numpy-base-1.16.3-py37hde5b4d6_0.conda": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.3 py37h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "b296888d908e42b5d014a42f0fea5dda", + "name": "numpy-base", + "sha256": "a8ea995860e83f404b553d2e0de72656e11cc99acfb0bc06f7926c7455ac0efe", + "size": 3679059, + "subdir": "linux-64", + "timestamp": 1555949572836, + "version": "1.16.3" + }, + "numpy-base-1.16.4-py27h2f8d375_0.conda": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.4 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "bdac15d47f79a1600383d71275bd35dc", + "name": "numpy-base", + "sha256": "9b8fdba2b953a28328be31283cd0eea0902b2d8cc6c09a264e69d49891c02100", + "size": 3600812, + "subdir": "linux-64", + "timestamp": 1559140281552, + "version": "1.16.4" + }, + "numpy-base-1.16.4-py27hde5b4d6_0.conda": { + "build": "py27hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.4 py27h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "114d28c6f59a4343bd1c2f85d2b37eeb", + "name": "numpy-base", + "sha256": "9409c423e25f70070d745b7c169f1714772f500d62c77479dbeda1778419e6a1", + "size": 3650429, + "subdir": "linux-64", + "timestamp": 1559140633668, + "version": "1.16.4" + }, + "numpy-base-1.16.4-py36h2f8d375_0.conda": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.4 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "e7c3002decc13e29ef9a7e02fd7eda5f", + "name": "numpy-base", + "sha256": "fef2347db5c9d7283c2c30a3728279e54fec56ec8851e92e0ba00e2a2026da0e", + "size": 3651217, + "subdir": "linux-64", + "timestamp": 1559140288680, + "version": "1.16.4" + }, + "numpy-base-1.16.4-py36hde5b4d6_0.conda": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.4 py36h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "1a0837482576f23ad6d64f14af9bc80b", + "name": "numpy-base", + "sha256": "d5451f9e66ecdb82d3378e11f1bc8df3d3ddb2d03dc7e472d2128052c4cfc30d", + "size": 3704189, + "subdir": "linux-64", + "timestamp": 1559141027012, + "version": "1.16.4" + }, + "numpy-base-1.16.4-py37h2f8d375_0.conda": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.4 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "f19eaeb78b5b275a8c59120f2306a050", + "name": "numpy-base", + "sha256": "b727ff910d2f24de0696343dd14d4c3e950e65fa36ab76b39610623adb3bb671", + "size": 3639450, + "subdir": "linux-64", + "timestamp": 1559140350416, + "version": "1.16.4" + }, + "numpy-base-1.16.4-py37hde5b4d6_0.conda": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.4 py37h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.3,<2021.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "b2dd0ab825c54140363e65caf6f5d639", + "name": "numpy-base", + "sha256": "703f91ccde5465949e4f577c3f1b3c6b3f51693115a3fdd9f929816f6f3ce626", + "size": 3685928, + "subdir": "linux-64", + "timestamp": 1559140438644, + "version": "1.16.4" + }, + "numpy-base-1.16.5-py27h2f8d375_0.conda": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.5 py27h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "0fdbf11543984ade18b14341fe6f99bd", + "name": "numpy-base", + "sha256": "cf36ea82ce1065b380b68efcda160b09cdd4ec328b22cd577285adddf0262b3c", + "size": 3606036, + "subdir": "linux-64", + "timestamp": 1568311456201, + "version": "1.16.5" + }, + "numpy-base-1.16.5-py27hde5b4d6_0.conda": { + "build": "py27hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.5 py27h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "7a6c12a86c0288cc17a759d4637cc099", + "name": "numpy-base", + "sha256": "1083ae047757e99e99c2387da93a9bfd76c6ca570d3db9637f5ac9400e413196", + "size": 3655066, + "subdir": "linux-64", + "timestamp": 1568311576635, + "version": "1.16.5" + }, + "numpy-base-1.16.5-py36h2f8d375_0.conda": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.5 py36h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "2653cb088ae708045b1734c2779591a5", + "name": "numpy-base", + "sha256": "3ca1e990978a3a5aeb10b8a108157c58105c6a356e5ba4927ace99822cf46a3a", + "size": 3661428, + "subdir": "linux-64", + "timestamp": 1568311435624, + "version": "1.16.5" + }, + "numpy-base-1.16.5-py36hde5b4d6_0.conda": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.5 py36h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "d6d76225f8d00915c36af51501c33f52", + "name": "numpy-base", + "sha256": "ebb50837cea4cf21087120c5057eaf846c08d1c04a45d2894a29e9952be5e3a1", + "size": 3708309, + "subdir": "linux-64", + "timestamp": 1568311772568, + "version": "1.16.5" + }, + "numpy-base-1.16.5-py37h2f8d375_0.conda": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.5 py37h99e49ec_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "7a680c54457f21cd971d8fcdc82bf22d", + "name": "numpy-base", + "sha256": "370e3daf4dfeeaf871a7295c6a96d8240a4dd9b580cab4cda5508fcc81a671d5", + "size": 3639240, + "subdir": "linux-64", + "timestamp": 1568311550017, + "version": "1.16.5" + }, + "numpy-base-1.16.5-py37hde5b4d6_0.conda": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.5 py37h7e9f1db_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "70e9df53fc2e0b954ad00b615eb6f202", + "name": "numpy-base", + "sha256": "2c653910777b7c0251e9f09d5e67b239d8b5fbd7b0b1099eaa3d14d31a5a4743", + "size": 3686841, + "subdir": "linux-64", + "timestamp": 1568311765698, + "version": "1.16.5" + }, + "numpy-base-1.16.6-py27h2f8d375_0.conda": { + "build": "py27h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.6 py27h30dfecb_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "2283423f1e72fe62d7df3f9771def402", + "name": "numpy-base", + "sha256": "147eb2c7384196a5e5914311ab638b2b796bf4e4c91b7107537c0921373911f3", + "size": 3612949, + "subdir": "linux-64", + "timestamp": 1580501485894, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py27hde5b4d6_0.conda": { + "build": "py27hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.6 py27hbc911f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "5fc2e7b6a556a94c7c098677a0cc7b25", + "name": "numpy-base", + "sha256": "82ea31c84d344b59b419603693c18008c7c20a37fda6e3d4987a7cf39012ef49", + "size": 3658442, + "subdir": "linux-64", + "timestamp": 1580501534491, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py36h2f8d375_0.conda": { + "build": "py36h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.6 py36h30dfecb_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "9922e898c0019d54a3f06a6db275279c", + "name": "numpy-base", + "sha256": "0cae07bb42af6814dd1654b460daf20d3aad9b4d12982b149944eed828c01d1e", + "size": 3664890, + "subdir": "linux-64", + "timestamp": 1580488168216, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py36h41b4c56_3.conda": { + "build": "py36h41b4c56_3", + "build_number": 3, + "constrains": [ + "numpy 1.16.6 py36h0a8e133_3" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "605cf8fd6d674336bbb1573bc06b0c20", + "name": "numpy-base", + "sha256": "86b6b1c97fab3b11f0269eb1768ec7696dbfa8123c7f5d22b7bf613871d80c98", + "size": 3667422, + "subdir": "linux-64", + "timestamp": 1618845005545, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py36hdc34a94_3.conda": { + "build": "py36hdc34a94_3", + "build_number": 3, + "constrains": [ + "numpy 1.16.6 py36h2d18471_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "d9df8e053f2f2d6e1219d559bfdba598", + "name": "numpy-base", + "sha256": "1d54d81cfcf32d94b7c6db2d7a17916e9a5da819af8e7b6a620304282161e1c5", + "size": 3716314, + "subdir": "linux-64", + "timestamp": 1618845083423, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py36hde5b4d6_0.conda": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.6 py36hbc911f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "61401fed480868aec928ce41169f5f94", + "name": "numpy-base", + "sha256": "423336d346a5e38a8acbefd51ee49b9165fd2ad07d4cf4e314d88ebfbbd36782", + "size": 3712338, + "subdir": "linux-64", + "timestamp": 1580488296932, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py37h2f8d375_0.conda": { + "build": "py37h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.6 py37h30dfecb_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "2328d7ecba73bc392d633b554de7ce70", + "name": "numpy-base", + "sha256": "c5fd9e081e7e6e7dfd3e79840c2449046f054b795ef06c610f77822720eade23", + "size": 3620968, + "subdir": "linux-64", + "timestamp": 1580488160332, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py37h41b4c56_3.conda": { + "build": "py37h41b4c56_3", + "build_number": 3, + "constrains": [ + "numpy 1.16.6 py37h0a8e133_3" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "17d07688495f92699b3e879dc838e118", + "name": "numpy-base", + "sha256": "893446f5d1fc90623513fc60ee42d52daeeaeb915a464d4c1947048482595278", + "size": 3647913, + "subdir": "linux-64", + "timestamp": 1618844438290, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py37h73d599e_4.conda": { + "build": "py37h73d599e_4", + "build_number": 4, + "constrains": [ + "numpy 1.16.6 py37h7895c89_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "2a40f395fe0ba560819fd54de7235532", + "name": "numpy-base", + "sha256": "137edbb069680a53aa8176b958b4eba0e02af98771d38b6b9ce622b772322da0", + "size": 3766295, + "subdir": "linux-64", + "timestamp": 1654863824285, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py37ha8aedfd_4.conda": { + "build": "py37ha8aedfd_4", + "build_number": 4, + "constrains": [ + "numpy 1.16.6 py37h0708ffd_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "cedce4d15dfca4d2d8a5b7a4ba61dc5c", + "name": "numpy-base", + "sha256": "215f48cc2ec5c8b3a042ee95e7c1a01393ce1e3cf53a83cd989e601425c68234", + "size": 3720325, + "subdir": "linux-64", + "timestamp": 1654863139695, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py37hdc34a94_3.conda": { + "build": "py37hdc34a94_3", + "build_number": 3, + "constrains": [ + "numpy 1.16.6 py37h2d18471_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "8ec6aefe754edb86e160f657f113aba7", + "name": "numpy-base", + "sha256": "28b8b80eb14f0f07aac4433f684995467c81e949179ac66ef0008892e1326edc", + "size": 3692993, + "subdir": "linux-64", + "timestamp": 1618845091469, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py37hde5b4d6_0.conda": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.6 py37hbc911f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "e80fc79e2d5b7dc85f436cc383c45b0a", + "name": "numpy-base", + "sha256": "0ade86dac514a73cdbbca6c887825f507d59dc43521e32ffb5751957c39edd06", + "size": 3669333, + "subdir": "linux-64", + "timestamp": 1580488260871, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py38h2f8d375_0.conda": { + "build": "py38h2f8d375_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.6 py38h30dfecb_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "485524f3eadcd5d9fb380e168387f738", + "name": "numpy-base", + "sha256": "07ba5d6aeee2a6e00bc28458e7d6449f13b15e5452e582f29df51a1622cb5c04", + "size": 3674948, + "subdir": "linux-64", + "timestamp": 1580495265343, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py38h41b4c56_3.conda": { + "build": "py38h41b4c56_3", + "build_number": 3, + "constrains": [ + "numpy 1.16.6 py38h0a8e133_3" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "2fdaccb80bcd744fa3b3accd21de62f7", + "name": "numpy-base", + "sha256": "604abd65763c8478fb402104cd24885f5ef4e88426da0285a125de6e6d95f485", + "size": 3703234, + "subdir": "linux-64", + "timestamp": 1618841681824, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py38h73d599e_4.conda": { + "build": "py38h73d599e_4", + "build_number": 4, + "constrains": [ + "numpy 1.16.6 py38h7895c89_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "4ef0190fd3e82daefd5c4bfe2cb25754", + "name": "numpy-base", + "sha256": "2e5935ee49a672f692bc0580d6f98bc98352dc7ce8e0d1a78a2efeceb4796abf", + "size": 3805451, + "subdir": "linux-64", + "timestamp": 1654864457128, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py38ha8aedfd_4.conda": { + "build": "py38ha8aedfd_4", + "build_number": 4, + "constrains": [ + "numpy 1.16.6 py38h0708ffd_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "da92e2f4b4f665ad44d0ad2d3f2ed86b", + "name": "numpy-base", + "sha256": "68d76a84aef206f0b3d1f7652c0bf7ae1aef056645385f1636314c4ad7e9c074", + "size": 3752860, + "subdir": "linux-64", + "timestamp": 1654863576126, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py38hdc34a94_3.conda": { + "build": "py38hdc34a94_3", + "build_number": 3, + "constrains": [ + "numpy 1.16.6 py38h2d18471_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "fba2389ef4c03e6283af654813bb2877", + "name": "numpy-base", + "sha256": "de05040f88204ebe057eefbdc7c32634767b56c55e746e70d54de2c044a21a11", + "size": 3725356, + "subdir": "linux-64", + "timestamp": 1618845083204, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py38hde5b4d6_0.conda": { + "build": "py38hde5b4d6_0", + "build_number": 0, + "constrains": [ + "numpy 1.16.6 py38hbc911f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "md5": "538f572b85f9ee20302978efa8fa32c8", + "name": "numpy-base", + "sha256": "70e83264174fe94e26206d6b863215b67ce6a29d2251199e79ba1698f64528fd", + "size": 3752384, + "subdir": "linux-64", + "timestamp": 1580495253140, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py39h41b4c56_3.conda": { + "build": "py39h41b4c56_3", + "build_number": 3, + "constrains": [ + "numpy 1.16.6 py39h0a8e133_3" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "md5": "48eb317aa103f3705d96b63fc8d14c8b", + "name": "numpy-base", + "sha256": "a61ce0d6a5e29f35d446f4adfb6df50cade28e8f6b778df5b91626f3b21ccfb2", + "size": 3675888, + "subdir": "linux-64", + "timestamp": 1618841679997, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py39h73d599e_4.conda": { + "build": "py39h73d599e_4", + "build_number": 4, + "constrains": [ + "numpy 1.16.6 py39h7895c89_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "md5": "296cab6e1ff44650c03165aea5d98199", + "name": "numpy-base", + "sha256": "7acdbd313374dd7caf77378ae823e7b8cb09750aeb1f9e92da1f785da22c313a", + "size": 3799382, + "subdir": "linux-64", + "timestamp": 1654864143849, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py39h76555f2_1.conda": { + "build": "py39h76555f2_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.6 py39h89c1606_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "md5": "db7127a985403e657fedf364d4e59dd5", + "name": "numpy-base", + "sha256": "8ab95e57336ae312cdaad59d8d43e172513762169040bbbf062e841fe2c415a2", + "size": 3751905, + "subdir": "linux-64", + "timestamp": 1607432304179, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py39ha8aedfd_4.conda": { + "build": "py39ha8aedfd_4", + "build_number": 4, + "constrains": [ + "numpy 1.16.6 py39h0708ffd_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "md5": "d6ad5680f0cc7520ae66ba6e09d1d4a2", + "name": "numpy-base", + "sha256": "59d31680fa4ce49417c63d4304a4900ffe468b7c510524d5a1ae7c2236708da0", + "size": 3757129, + "subdir": "linux-64", + "timestamp": 1654863357983, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py39hdc34a94_3.conda": { + "build": "py39hdc34a94_3", + "build_number": 3, + "constrains": [ + "numpy 1.16.6 py39h2d18471_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "md5": "b2d39fa714cf29d197d8b5b5dd34bf6f", + "name": "numpy-base", + "sha256": "cddddda193c3dc5b67a089bbbdbb33424a06f105be523928ab875d63c6c71161", + "size": 3724513, + "subdir": "linux-64", + "timestamp": 1618845079125, + "version": "1.16.6" + }, + "numpy-base-1.16.6-py39hfb011de_1.conda": { + "build": "py39hfb011de_1", + "build_number": 1, + "constrains": [ + "numpy 1.16.6 py39hdd937aa_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "md5": "63d7aafcf1b595f8f9f550249fc37d1c", + "name": "numpy-base", + "sha256": "9d2b397f1f3791999cca0bd8d04c988224eb02d4401815620843767790cbbdc4", + "size": 3677645, + "subdir": "linux-64", + "timestamp": 1607432240355, + "version": "1.16.6" + }, + "numpy-base-1.17.2-py36h2f8d375_0.conda": { + "build": "py36h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "129b3a800a0aff871b1c5d3b52802246", + "name": "numpy-base", + "sha256": "ac83edb16d954795eb55b560c57cb9d5e02c482112fce5e750bf1a1968fb07fc", + "size": 4373834, + "subdir": "linux-64", + "timestamp": 1569435344110, + "version": "1.17.2" + }, + "numpy-base-1.17.2-py36hde5b4d6_0.conda": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "886f064a7fe4a4f6e90ea2a766b57f82", + "name": "numpy-base", + "sha256": "e496b79ac86e538da495fdb158bdc9fd127097db909e391019a0f7f51a14f26a", + "size": 4423038, + "subdir": "linux-64", + "timestamp": 1569435627808, + "version": "1.17.2" + }, + "numpy-base-1.17.2-py37h2f8d375_0.conda": { + "build": "py37h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b0909515e326e9b338c875d09f1a400d", + "name": "numpy-base", + "sha256": "d14f1fae9a4cb458616a484bfd7589210f01fef267ea43d9685c13f5f7d1b2c6", + "size": 4360443, + "subdir": "linux-64", + "timestamp": 1569435383275, + "version": "1.17.2" + }, + "numpy-base-1.17.2-py37hde5b4d6_0.conda": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "da194b5f91e97762269d07e8c1c1e928", + "name": "numpy-base", + "sha256": "0797a0b9b4c2e12e5252c0c5f19dcf4f246dde45b5b760d0a24d6c052a998d14", + "size": 4423783, + "subdir": "linux-64", + "timestamp": 1569435627128, + "version": "1.17.2" + }, + "numpy-base-1.17.3-py36h2f8d375_0.conda": { + "build": "py36h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cedeb7ae3f0ee296edff18f2557a081d", + "name": "numpy-base", + "sha256": "9ac81467393add8bcce57ea87bd49bbc54b1a5b49c917ab2793ab1cde0ebf622", + "size": 4330375, + "subdir": "linux-64", + "timestamp": 1573063145971, + "version": "1.17.3" + }, + "numpy-base-1.17.3-py36hde5b4d6_0.conda": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3c7757b94080c406e668b05744d05ff4", + "name": "numpy-base", + "sha256": "031596c7061243795c6cb7d0fb2b94d3de4b719cba2511a0a90819502978db32", + "size": 4376839, + "subdir": "linux-64", + "timestamp": 1573063141627, + "version": "1.17.3" + }, + "numpy-base-1.17.3-py37h2f8d375_0.conda": { + "build": "py37h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "73e74c9e577cca44e8c7837e2c70bfb6", + "name": "numpy-base", + "sha256": "2eb92bd624d8127db4e2add8829a81dcf9fb0826753af704df9da65b9da94a02", + "size": 4324795, + "subdir": "linux-64", + "timestamp": 1573063215039, + "version": "1.17.3" + }, + "numpy-base-1.17.3-py37hde5b4d6_0.conda": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e90185d687591b5430b1a60810def06c", + "name": "numpy-base", + "sha256": "eff2b64eb331dc9489dc11dbf54a4a0d92daf23f8acdbf08d9f47c08342b69b4", + "size": 4371184, + "subdir": "linux-64", + "timestamp": 1573063281034, + "version": "1.17.3" + }, + "numpy-base-1.17.3-py38h2f8d375_0.conda": { + "build": "py38h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "40edbb76ecacefb1e6ab639b514822b1", + "name": "numpy-base", + "sha256": "a253e85d3429f0bbc07e7c5331c97af93bd70b71ddbae245f7f380892ad06c5d", + "size": 4380835, + "subdir": "linux-64", + "timestamp": 1573063156983, + "version": "1.17.3" + }, + "numpy-base-1.17.3-py38hde5b4d6_0.conda": { + "build": "py38hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "574b124928d338e09524af8161504d5a", + "name": "numpy-base", + "sha256": "739098acf74d383c6ffe5b8af44064e72aa4aa03a6333ddef6d272198199d746", + "size": 4422089, + "subdir": "linux-64", + "timestamp": 1573121176802, + "version": "1.17.3" + }, + "numpy-base-1.17.4-py36h2f8d375_0.conda": { + "build": "py36h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "18f52fbb2a276cbdf23b5f49e829c59f", + "name": "numpy-base", + "sha256": "85d71413f67f96cdfa57a1d063cc785665991c30bc8af74315503df294eb20f4", + "size": 4305953, + "subdir": "linux-64", + "timestamp": 1574868330469, + "version": "1.17.4" + }, + "numpy-base-1.17.4-py36hde5b4d6_0.conda": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d9c8c489019cb40a21512c17b07b7bb9", + "name": "numpy-base", + "sha256": "7c03be6123a5f1d46448a9b3c6c10f19dae9f08aa524aa38f11ba6006356c57d", + "size": 4378876, + "subdir": "linux-64", + "timestamp": 1574868415139, + "version": "1.17.4" + }, + "numpy-base-1.17.4-py37h2f8d375_0.conda": { + "build": "py37h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "82ba4266d3e72556400450580d5a7ba4", + "name": "numpy-base", + "sha256": "544b6eef6ae93cb2ff1e201047a0d9bb24c2bee3091227e924cfd60782a3ad2a", + "size": 4290645, + "subdir": "linux-64", + "timestamp": 1574868347172, + "version": "1.17.4" + }, + "numpy-base-1.17.4-py37hde5b4d6_0.conda": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "046579f6567c781adf99ca1c5ded0c4a", + "name": "numpy-base", + "sha256": "db4368a0bd53d2c650acb110ed1cfa56846c5e0af0c51031e5ff2c63c4f42ac7", + "size": 4346717, + "subdir": "linux-64", + "timestamp": 1574868401546, + "version": "1.17.4" + }, + "numpy-base-1.17.4-py38h2f8d375_0.conda": { + "build": "py38h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "437f39a573f894e466b375a55065f946", + "name": "numpy-base", + "sha256": "19cf57cac2049d2367c7c95c7c4788533f9009f62e661846faee507d86acc097", + "size": 4349422, + "subdir": "linux-64", + "timestamp": 1574868323390, + "version": "1.17.4" + }, + "numpy-base-1.17.4-py38hde5b4d6_0.conda": { + "build": "py38hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bd09be98781e06a4a6b57356da1fdee2", + "name": "numpy-base", + "sha256": "d36dc458aa4e329d0ecb8447d98a456e819a87f34332d7af0f5830409321ed7b", + "size": 4433195, + "subdir": "linux-64", + "timestamp": 1574868388914, + "version": "1.17.4" + }, + "numpy-base-1.18.1-py36h2f8d375_0.conda": { + "build": "py36h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "36bd05e17f6bbcc2d5aad93ecddd4da6", + "name": "numpy-base", + "sha256": "4ae7bfd4d3768873a9f85bd4265b8c86e5ca7ea710f83098354473a9cf4c3bbb", + "size": 4344171, + "subdir": "linux-64", + "timestamp": 1579191406483, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py36h2f8d375_1.conda": { + "build": "py36h2f8d375_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "38afa23be21c13b8399fd6b26fd60776", + "name": "numpy-base", + "sha256": "fef298b230ab9b6ff02c79baf0a52e111e1e0ecce5e30598faa6576e2c0dfae5", + "size": 4332367, + "subdir": "linux-64", + "timestamp": 1579712644823, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py36hde5b4d6_0.conda": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c2ae40ee230cbfe77518cd2d53a7f2d2", + "name": "numpy-base", + "sha256": "080bf4e9fa1c3394cc9e2bac325b4080e232df3c5e7cd77a1ddcfe5b0451bd69", + "size": 4369215, + "subdir": "linux-64", + "timestamp": 1579191431300, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py36hde5b4d6_1.conda": { + "build": "py36hde5b4d6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "88159e051f4df8b518525d72bb82d3fb", + "name": "numpy-base", + "sha256": "1f2eec48404687714ae00b9b0d13fd9c76ebd3a438c6a3ded9504db64414a89b", + "size": 4370376, + "subdir": "linux-64", + "timestamp": 1579712562571, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py37h2f8d375_0.conda": { + "build": "py37h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3a771b625ba0e2666641d9acef0ede30", + "name": "numpy-base", + "sha256": "13a24f758fc6b7ea2ff8b4d540c61f55db2344c26508176c974b658ac9d2bbc2", + "size": 4355172, + "subdir": "linux-64", + "timestamp": 1579191511039, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py37h2f8d375_1.conda": { + "build": "py37h2f8d375_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9e64871bfe9d6d8d50fe3e6cf2e7ec94", + "name": "numpy-base", + "sha256": "31ac3f13a83cde22ceeb92c257d0786504e3b2bf1e143a1a5a43303cee9928fe", + "size": 4361648, + "subdir": "linux-64", + "timestamp": 1579712542748, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py37hde5b4d6_0.conda": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1e37bc9fcc50b9144e72c598fc852cb2", + "name": "numpy-base", + "sha256": "6e46a541d04d7b18f3ebd319581189b4883ed29c6c2eccdbd4607772b587fbc4", + "size": 4338349, + "subdir": "linux-64", + "timestamp": 1579191527561, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py37hde5b4d6_1.conda": { + "build": "py37hde5b4d6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dc08d80c0be10d8bc31c5e179605a782", + "name": "numpy-base", + "sha256": "a281dd75638e0dcfe7221969fb02fad07e08b62f6f8e342a7fa64519f96d5173", + "size": 4356801, + "subdir": "linux-64", + "timestamp": 1579712522394, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py38h2f8d375_0.conda": { + "build": "py38h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "28dafe09af45b74cb9b2f0b632152d04", + "name": "numpy-base", + "sha256": "701a4ef4d3fcbfac5ea33707ef98f89ef35f0620a0c2f2af515148ab2b70a972", + "size": 4400305, + "subdir": "linux-64", + "timestamp": 1579191524637, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py38h2f8d375_1.conda": { + "build": "py38h2f8d375_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "09d0d13d98737c7abf613ac3a7299144", + "name": "numpy-base", + "sha256": "3cf7be6dd08726ed25504dc55971398ba0acf7d89218e69a5ff4fb6d1b8fff6f", + "size": 4394494, + "subdir": "linux-64", + "timestamp": 1579712574818, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py38hde5b4d6_0.conda": { + "build": "py38hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6f88d18879bff71dda74d51497572d10", + "name": "numpy-base", + "sha256": "9dd5961bdfa028bfe9361184c6da6c93f3e039db10f6375b6316b1b8944a9d89", + "size": 4420838, + "subdir": "linux-64", + "timestamp": 1579191444410, + "version": "1.18.1" + }, + "numpy-base-1.18.1-py38hde5b4d6_1.conda": { + "build": "py38hde5b4d6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b235cbd9ce1e60f28e609625b8333107", + "name": "numpy-base", + "sha256": "69316f08912ef700c8cbcc5d11d4f6bd07970625cdc89ee8fbe72724e7ad5eb9", + "size": 4392962, + "subdir": "linux-64", + "timestamp": 1579712584895, + "version": "1.18.1" + }, + "numpy-base-1.18.5-py36h2f8d375_0.conda": { + "build": "py36h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "03e6281ac6e680fce717dee5fe752442", + "name": "numpy-base", + "sha256": "14d0a0e08b11889ef72fca3426199f6e7519f081e97e9b12a19d77e108c235ae", + "size": 4305339, + "subdir": "linux-64", + "timestamp": 1592509309336, + "version": "1.18.5" + }, + "numpy-base-1.18.5-py36hde5b4d6_0.conda": { + "build": "py36hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0123d5a3a6802b0d2a1823537da9f4e1", + "name": "numpy-base", + "sha256": "97c1b5e6890aea06793f2054d4e1a6bafa60f34548f3dafde1f1426be27d8cf2", + "size": 4270754, + "subdir": "linux-64", + "timestamp": 1592509293298, + "version": "1.18.5" + }, + "numpy-base-1.18.5-py37h2f8d375_0.conda": { + "build": "py37h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b8185d7ac4ae5b487eb2fa3545c67a9d", + "name": "numpy-base", + "sha256": "cd8a27b1d799bd368f236acd2a1daa72e506d3d4fda2380d0ccb17a9251c5dc3", + "size": 4271879, + "subdir": "linux-64", + "timestamp": 1592509266354, + "version": "1.18.5" + }, + "numpy-base-1.18.5-py37hde5b4d6_0.conda": { + "build": "py37hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4c9b4f293b241b0d296edd5c3b048d65", + "name": "numpy-base", + "sha256": "3cc4104d86b860ad355e2a9f03a20ba4bc6aba9311f4c2bd3174cfa0ac2b4353", + "size": 4276880, + "subdir": "linux-64", + "timestamp": 1592509307268, + "version": "1.18.5" + }, + "numpy-base-1.18.5-py38h2f8d375_0.conda": { + "build": "py38h2f8d375_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4fb35ecb05c2fcc201b27ccc22cd325d", + "name": "numpy-base", + "sha256": "fa3479809ecf3d0c52132e9e2c7c585d47ff8e7f5d60040e1a51d335452cae6f", + "size": 4317825, + "subdir": "linux-64", + "timestamp": 1592509302386, + "version": "1.18.5" + }, + "numpy-base-1.18.5-py38hde5b4d6_0.conda": { + "build": "py38hde5b4d6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ad7ae231fa68d01361a0ea434a0bc028", + "name": "numpy-base", + "sha256": "692776907bc45732f83bbea7e934ddfe7b3d79d160c3d38b0198c5e6c50028e6", + "size": 4348780, + "subdir": "linux-64", + "timestamp": 1592509314255, + "version": "1.18.5" + }, + "numpy-base-1.19.1-py36h75fe3a5_0.conda": { + "build": "py36h75fe3a5_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.1 py36h30dfecb_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0a0e40d4a442422fb1561c4d3bcb909d", + "name": "numpy-base", + "sha256": "59fb71db9511cf40459118eb80b532a7c12761e631861d5dbf277507edfbd416", + "size": 4330167, + "subdir": "linux-64", + "timestamp": 1596233920696, + "version": "1.19.1" + }, + "numpy-base-1.19.1-py36hfa32c7d_0.conda": { + "build": "py36hfa32c7d_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.1 py36hbc911f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1120ec8173527e3aecc0c7fc474e71f0", + "name": "numpy-base", + "sha256": "f7c7da711a8a5e78f347fa682734166adbb8bf5da47def3053de63ea183b6a15", + "size": 4311229, + "subdir": "linux-64", + "timestamp": 1596233920385, + "version": "1.19.1" + }, + "numpy-base-1.19.1-py37h75fe3a5_0.conda": { + "build": "py37h75fe3a5_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.1 py37h30dfecb_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e70ee49325fe9de5faed0c16cfb45242", + "name": "numpy-base", + "sha256": "ba207dec33249b9ed28795412f2ae8ac39beb1f3c2f01642ae35c145036d5b2f", + "size": 4323027, + "subdir": "linux-64", + "timestamp": 1596233933018, + "version": "1.19.1" + }, + "numpy-base-1.19.1-py37hfa32c7d_0.conda": { + "build": "py37hfa32c7d_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.1 py37hbc911f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "db0529a0f6a29bf805359a11da36639f", + "name": "numpy-base", + "sha256": "ff35dfccd388276a9affbf27759525d94c8d1cc0d6ef58c4d6e27575d8fa02f5", + "size": 4318461, + "subdir": "linux-64", + "timestamp": 1596233901027, + "version": "1.19.1" + }, + "numpy-base-1.19.1-py38h75fe3a5_0.conda": { + "build": "py38h75fe3a5_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.1 py38h30dfecb_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "de8f78b914f7b8ae1fee30c330e5478b", + "name": "numpy-base", + "sha256": "d2f0b1720ece3f94256e435e38209af63ef6e0922dd1ca0520d781d965738926", + "size": 4402471, + "subdir": "linux-64", + "timestamp": 1596233914368, + "version": "1.19.1" + }, + "numpy-base-1.19.1-py38hfa32c7d_0.conda": { + "build": "py38hfa32c7d_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.1 py38hbc911f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "34f54c03c5705e0f7edd45ddc1aa77cc", + "name": "numpy-base", + "sha256": "169f5735fcd006b5f3c11b2452f8ffc67e7716b588421b1bc65da30706f394e3", + "size": 4397106, + "subdir": "linux-64", + "timestamp": 1596233919560, + "version": "1.19.1" + }, + "numpy-base-1.19.2-py36h75fe3a5_0.conda": { + "build": "py36h75fe3a5_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.2 py36h6163131_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6c8c16a83e623e77b73171d2eb9c7386", + "name": "numpy-base", + "sha256": "8c9b5e56916d224a20b1c55fa753675b4322c4affd88e882938e2d2d04ea1bfa", + "size": 4341479, + "subdir": "linux-64", + "timestamp": 1603483883552, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py36hfa32c7d_0.conda": { + "build": "py36hfa32c7d_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.2 py36h54aff64_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "51e269263105b1d843f38fc9953d91fd", + "name": "numpy-base", + "sha256": "e016245846ab1d5083d85cadde40b3bf204823d9c9458be4c89b8b32ec86a69a", + "size": 4318309, + "subdir": "linux-64", + "timestamp": 1603487980556, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py37h21a3de8_1.conda": { + "build": "py37h21a3de8_1", + "build_number": 1, + "constrains": [ + "numpy 1.19.2 py37hc896f84_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ba43f217f5bef786869d5e19dad7a416", + "name": "numpy-base", + "sha256": "ccb40931a8006da3533be1807300d77becb6b1868c96ed18f0294bce997899d7", + "size": 10094142, + "subdir": "linux-64", + "timestamp": 1654873730663, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py37h4c65ebe_1.conda": { + "build": "py37h4c65ebe_1", + "build_number": 1, + "constrains": [ + "numpy 1.19.2 py37h7895c89_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "77ff8f4f99a5e2cf510925f177273556", + "name": "numpy-base", + "sha256": "d39432840f2ce143953d90e7e181c4e64a239ab1ca31056e9dc9bd9e5886a813", + "size": 10096090, + "subdir": "linux-64", + "timestamp": 1654872390020, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py37h75fe3a5_0.conda": { + "build": "py37h75fe3a5_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.2 py37h6163131_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5dfa362bcd97e744ae27387deb858ed0", + "name": "numpy-base", + "sha256": "29f14ae11729687d4db392c8c014d33c7c5704c42f17f9c65decc4401cb07985", + "size": 4318241, + "subdir": "linux-64", + "timestamp": 1603481040499, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py37hfa32c7d_0.conda": { + "build": "py37hfa32c7d_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.2 py37h54aff64_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dc9c33b5ad3562e79e452c790fd863ef", + "name": "numpy-base", + "sha256": "b5c6ac41498442ba1f06c264b4aa4a95fa72b920b43004c86462c9689e93adae", + "size": 4321337, + "subdir": "linux-64", + "timestamp": 1603479803658, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py38h21a3de8_1.conda": { + "build": "py38h21a3de8_1", + "build_number": 1, + "constrains": [ + "numpy 1.19.2 py38hc896f84_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2f20c9c1d90029eba0307eed49721e82", + "name": "numpy-base", + "sha256": "7d5cdafb6301bebceead1134752eb7454a0febd1b6a0048b31db911d604947cc", + "size": 10562224, + "subdir": "linux-64", + "timestamp": 1654874594865, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py38h4c65ebe_1.conda": { + "build": "py38h4c65ebe_1", + "build_number": 1, + "constrains": [ + "numpy 1.19.2 py38h7895c89_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "83c361c392e57e81e247b3e96547f1cd", + "name": "numpy-base", + "sha256": "308e26b140da1176fa85a28f492afee96639fff995a45376d2c5306283a59486", + "size": 10572806, + "subdir": "linux-64", + "timestamp": 1654873267257, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py38h75fe3a5_0.conda": { + "build": "py38h75fe3a5_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.2 py38h6163131_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "29ce01ad078d09862744869a39449522", + "name": "numpy-base", + "sha256": "d87459df18cf839ea1a31204df745cbb4611fe5b1bf8810be81ffa5accb40ca2", + "size": 4375040, + "subdir": "linux-64", + "timestamp": 1603479822502, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py38hfa32c7d_0.conda": { + "build": "py38hfa32c7d_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.2 py38h54aff64_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "96e71076ea262302106ebb2f823a6670", + "name": "numpy-base", + "sha256": "af785908687190c1e2a6368f13c8ed376c3abe77dd08c3b9fbcb1f9bdf61c307", + "size": 4374216, + "subdir": "linux-64", + "timestamp": 1603570661608, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py39h0f7b65f_0.conda": { + "build": "py39h0f7b65f_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.2 py39h87658db_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "94e4b8c610a90c3b6b32146d235369da", + "name": "numpy-base", + "sha256": "6e25a01e0dd387b5e71b3c8b1e64866d6967d734a64a5e5f1f85947a1ab276e0", + "size": 4400789, + "subdir": "linux-64", + "timestamp": 1607448334843, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py39h21a3de8_1.conda": { + "build": "py39h21a3de8_1", + "build_number": 1, + "constrains": [ + "numpy 1.19.2 py39hc896f84_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "229c01abdf915fd21cbf0863099895a0", + "name": "numpy-base", + "sha256": "2ad0fbc79b004161941f3a134056d3a1eef8b6813dbec3782527ba3cd7729f1f", + "size": 4419614, + "subdir": "linux-64", + "timestamp": 1654874153814, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py39h2ae0177_0.conda": { + "build": "py39h2ae0177_0", + "build_number": 0, + "constrains": [ + "numpy 1.19.2 py39h89c1606_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "562eca207b22a6681475f5cc88066d31", + "name": "numpy-base", + "sha256": "22b3eed70832fb98ef499bacd3018493ee6b69d675fc0c4e6586068423cc7d6d", + "size": 4405188, + "subdir": "linux-64", + "timestamp": 1607448314407, + "version": "1.19.2" + }, + "numpy-base-1.19.2-py39h4c65ebe_1.conda": { + "build": "py39h4c65ebe_1", + "build_number": 1, + "constrains": [ + "numpy 1.19.2 py39h7895c89_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "952ee1857e229948633624b76223aa02", + "name": "numpy-base", + "sha256": "c0e0c3fdcee8b4c8e6ca2cf1adfd7738e5b978eff7bb38b174ccdd224c297734", + "size": 4420070, + "subdir": "linux-64", + "timestamp": 1654872821112, + "version": "1.19.2" + }, + "numpy-base-1.19.5-py37h21a3de8_4.conda": { + "build": "py37h21a3de8_4", + "build_number": 4, + "constrains": [ + "numpy 1.19.5 py37hc896f84_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "49a638a3fb2f90275e246ccfed25bf68", + "name": "numpy-base", + "sha256": "d728689db72b3f26cf3354527a9ba7c07569f52582a3d022c7450fd6e9fa45ae", + "size": 5256316, + "subdir": "linux-64", + "timestamp": 1677550472607, + "version": "1.19.5" + }, + "numpy-base-1.19.5-py37h622ebfc_4.conda": { + "build": "py37h622ebfc_4", + "build_number": 4, + "constrains": [ + "numpy 1.19.5 py37hd5178e2_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7726d587495d9b49d1791c699df9b25d", + "name": "numpy-base", + "sha256": "ebd5360f0e1de65a3d0cbd735b99a19f713619ceef7cba9c60c5abf0873554c0", + "size": 5257429, + "subdir": "linux-64", + "timestamp": 1677551457873, + "version": "1.19.5" + }, + "numpy-base-1.19.5-py38h21a3de8_4.conda": { + "build": "py38h21a3de8_4", + "build_number": 4, + "constrains": [ + "numpy 1.19.5 py38hc896f84_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee7298dfbfcef426cbe04745e087c7e0", + "name": "numpy-base", + "sha256": "c2aeca2f249da76584ddb3da83f9e9abc4cc1771013ae103caa1033464853bf8", + "size": 5319992, + "subdir": "linux-64", + "timestamp": 1677549822698, + "version": "1.19.5" + }, + "numpy-base-1.19.5-py38h622ebfc_4.conda": { + "build": "py38h622ebfc_4", + "build_number": 4, + "constrains": [ + "numpy 1.19.5 py38hd5178e2_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "083a23c303499d53c4c455bd30a33667", + "name": "numpy-base", + "sha256": "e4bd01e98ce4b8c799037645919b0e051370fd2811cb8d3edc024253aaff5b01", + "size": 5320183, + "subdir": "linux-64", + "timestamp": 1677550804067, + "version": "1.19.5" + }, + "numpy-base-1.19.5-py39h21a3de8_4.conda": { + "build": "py39h21a3de8_4", + "build_number": 4, + "constrains": [ + "numpy 1.19.5 py39hc896f84_4" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2d111345c519aafa8c05cb9bef9f8757", + "name": "numpy-base", + "sha256": "c538f831e1eadcb756033effaa5b244158fb4ee5949c9ddafa80a56723430b4b", + "size": 5301147, + "subdir": "linux-64", + "timestamp": 1677550147157, + "version": "1.19.5" + }, + "numpy-base-1.19.5-py39h622ebfc_4.conda": { + "build": "py39h622ebfc_4", + "build_number": 4, + "constrains": [ + "numpy 1.19.5 py39hd5178e2_4" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f464a69dafde986934779910c8da24a6", + "name": "numpy-base", + "sha256": "318c6f3fae644cd3077324c591f3d991a76619f705549f2937cebbff19c114d8", + "size": 5300652, + "subdir": "linux-64", + "timestamp": 1677551131013, + "version": "1.19.5" + }, + "numpy-base-1.20.1-py37h34387ca_0.conda": { + "build": "py37h34387ca_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.1 py37h5a90a98_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6b75cd5859637a4d2db982de4833f9cd", + "name": "numpy-base", + "sha256": "037ee8a43f3e025d3eb22d9b5d52fb947585ed91c9a9ff542b05080ad90e263a", + "size": 4706308, + "subdir": "linux-64", + "timestamp": 1618494303734, + "version": "1.20.1" + }, + "numpy-base-1.20.1-py37h7d8b39e_0.conda": { + "build": "py37h7d8b39e_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.1 py37h93e21f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bbc41f232da4804a3b1f094fedda89b5", + "name": "numpy-base", + "sha256": "7adfad2263d6d73e7c3e0a5a9d8c039d2f42ca55cbbe89c4674f20fb6e389508", + "size": 4684469, + "subdir": "linux-64", + "timestamp": 1618497448592, + "version": "1.20.1" + }, + "numpy-base-1.20.1-py38h34387ca_0.conda": { + "build": "py38h34387ca_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.1 py38h5a90a98_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "09904582fcb85846f9b125417b1e9c83", + "name": "numpy-base", + "sha256": "bdc02280e08c22df68e0c2bca1197852d69e571d152b8eb67a38c3d9bcc648e2", + "size": 4784634, + "subdir": "linux-64", + "timestamp": 1618497488151, + "version": "1.20.1" + }, + "numpy-base-1.20.1-py38h7d8b39e_0.conda": { + "build": "py38h7d8b39e_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.1 py38h93e21f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b790b4a82a538017f30fd4ca9c0e2301", + "name": "numpy-base", + "sha256": "121d32c3b78a3db5f85ac19ad4e6927cef0a707e9c557d13fb82254b2714628b", + "size": 4792294, + "subdir": "linux-64", + "timestamp": 1618497527785, + "version": "1.20.1" + }, + "numpy-base-1.20.1-py39h34387ca_0.conda": { + "build": "py39h34387ca_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.1 py39h5a90a98_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ba33591634514601bd052984855cdb4f", + "name": "numpy-base", + "sha256": "0759084c5e3d4ca60dc7e1eafa08a4d26a67a086936d3e54de4842f7ecae0a8d", + "size": 4763977, + "subdir": "linux-64", + "timestamp": 1618497474777, + "version": "1.20.1" + }, + "numpy-base-1.20.1-py39h7d8b39e_0.conda": { + "build": "py39h7d8b39e_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.1 py39h93e21f0_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ea4b705ad02e47db557184b27a25a7db", + "name": "numpy-base", + "sha256": "dbbf925f2a7d43598d2ec7743444f17d23d56bb6062c14d783827a998b2c6a10", + "size": 4792897, + "subdir": "linux-64", + "timestamp": 1618497530259, + "version": "1.20.1" + }, + "numpy-base-1.20.2-py37he2ba247_0.conda": { + "build": "py37he2ba247_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.2 py37h62767a5_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "22ac06eb7474bfb60b35955b0e0ed733", + "name": "numpy-base", + "sha256": "40cf42226f3e59d814e7b90e3b9f98965ee63b700a8fe29e291ffb2e477fdd40", + "size": 4716113, + "subdir": "linux-64", + "timestamp": 1620831415968, + "version": "1.20.2" + }, + "numpy-base-1.20.2-py37hfae3a4d_0.conda": { + "build": "py37hfae3a4d_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.2 py37h2d18471_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "41d04be6fe5541d5502419bfd84a6bd2", + "name": "numpy-base", + "sha256": "46bf09a5d6c6be96e5d7a248350f418d9d09c4f5da83acc80bed091842727e19", + "size": 4697808, + "subdir": "linux-64", + "timestamp": 1620831410905, + "version": "1.20.2" + }, + "numpy-base-1.20.2-py38he2ba247_0.conda": { + "build": "py38he2ba247_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.2 py38h62767a5_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "415903217754b88c9b79df98fff20813", + "name": "numpy-base", + "sha256": "42ddc506ae720bc59e5e84b71e9cce4ae8bc682534e77b9c253543fe6c0e3b91", + "size": 4770419, + "subdir": "linux-64", + "timestamp": 1620827096629, + "version": "1.20.2" + }, + "numpy-base-1.20.2-py38hfae3a4d_0.conda": { + "build": "py38hfae3a4d_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.2 py38h2d18471_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6e9c74cd23cc6caf5a401c259d6a3881", + "name": "numpy-base", + "sha256": "0aa1c9fab1d0436b23a0aa18eb7ebe779d3db596e4e56959091c309a2ec5c69f", + "size": 4799908, + "subdir": "linux-64", + "timestamp": 1620831180574, + "version": "1.20.2" + }, + "numpy-base-1.20.2-py39he2ba247_0.conda": { + "build": "py39he2ba247_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.2 py39h62767a5_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f09bb1c96eba905947ec21221b034510", + "name": "numpy-base", + "sha256": "afb7f57b911dc3ce9b4158c4037c6f20a2932e87a8314130cc21714a94e74566", + "size": 4803773, + "subdir": "linux-64", + "timestamp": 1620831405549, + "version": "1.20.2" + }, + "numpy-base-1.20.2-py39hfae3a4d_0.conda": { + "build": "py39hfae3a4d_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.2 py39h2d18471_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "028ecdccae2df31080cf5461329e3ee7", + "name": "numpy-base", + "sha256": "e910c6efd47cb13aca90d0a284208223062b1d8a665b52f339ad1e53620d5425", + "size": 4775955, + "subdir": "linux-64", + "timestamp": 1620831420619, + "version": "1.20.2" + }, + "numpy-base-1.20.3-py37h39b7dee_0.conda": { + "build": "py37h39b7dee_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.3 py37h3dbb7de_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "91783d8209b241c7af831f699b93e680", + "name": "numpy-base", + "sha256": "99c83eb001f16b3e648ccc01e9482d19034a0822aaaaa6e4d9ded95d26ff6124", + "size": 4683140, + "subdir": "linux-64", + "timestamp": 1626272002902, + "version": "1.20.3" + }, + "numpy-base-1.20.3-py37h74d4b33_0.conda": { + "build": "py37h74d4b33_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.3 py37hf144106_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8f3ca04688969d81e8896fa151de67bd", + "name": "numpy-base", + "sha256": "ba39a22bf64dbdc1c8486c0e4078f88c5e498feca0fe5ab7d59da87e972fe0cf", + "size": 4683251, + "subdir": "linux-64", + "timestamp": 1626265002908, + "version": "1.20.3" + }, + "numpy-base-1.20.3-py38h39b7dee_0.conda": { + "build": "py38h39b7dee_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.3 py38h3dbb7de_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9bdd0be392d06cdf35af6089bd27d82d", + "name": "numpy-base", + "sha256": "914e4a173fe337f1a2cbf4a414194066ea618bd1ff3f5d3d2a78f855e496d120", + "size": 4808783, + "subdir": "linux-64", + "timestamp": 1626271993406, + "version": "1.20.3" + }, + "numpy-base-1.20.3-py38h74d4b33_0.conda": { + "build": "py38h74d4b33_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.3 py38hf144106_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5e6fc96b00de92309e3aa19af38f1929", + "name": "numpy-base", + "sha256": "3339238df1ac6100ccda5e366c34f3b3dc66322d24b8540ff4e4177fbf594adf", + "size": 4763915, + "subdir": "linux-64", + "timestamp": 1626271757410, + "version": "1.20.3" + }, + "numpy-base-1.20.3-py39h39b7dee_0.conda": { + "build": "py39h39b7dee_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.3 py39h3dbb7de_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d901ded81d74c0de23845c8a1b5ca012", + "name": "numpy-base", + "sha256": "5514dd05d2208bab0a292768e49739e95da4c2b84d5aff35c38c1ca700a828e9", + "size": 4802148, + "subdir": "linux-64", + "timestamp": 1626272008985, + "version": "1.20.3" + }, + "numpy-base-1.20.3-py39h74d4b33_0.conda": { + "build": "py39h74d4b33_0", + "build_number": 0, + "constrains": [ + "numpy 1.20.3 py39hf144106_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b195e024a48f1eb83a5c7b635a16c9bb", + "name": "numpy-base", + "sha256": "d0e0da0f54360ee281654cb7f347f6cd933edf9f09c5fd43b906eefa3add909c", + "size": 4803800, + "subdir": "linux-64", + "timestamp": 1626265005484, + "version": "1.20.3" + }, + "numpy-base-1.21.2-py310h2b8c604_0.conda": { + "build": "py310h2b8c604_0", + "build_number": 0, + "constrains": [ + "numpy 1.21.2 py310hd8d4704_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c03e349f59daef2c2152cce14ecd1b6f", + "name": "numpy-base", + "sha256": "28941540a13cbd7071df70d8ce62b491bc9bd77dd8b3463032f327bfd1ff6b24", + "size": 11659774, + "subdir": "linux-64", + "timestamp": 1639483330093, + "version": "1.21.2" + }, + "numpy-base-1.21.2-py310h79a1101_0.conda": { + "build": "py310h79a1101_0", + "build_number": 0, + "constrains": [ + "numpy 1.21.2 py310h20f2e39_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "469a00ddcb5f615a31aefc3e57eb8f52", + "name": "numpy-base", + "sha256": "2d116afc022c095b59eb154e21f6ebeb3e985e44c46ad8fd4b63c8e530a6a269", + "size": 11694429, + "subdir": "linux-64", + "timestamp": 1639497117707, + "version": "1.21.2" + }, + "numpy-base-1.21.2-py37h2b8c604_0.conda": { + "build": "py37h2b8c604_0", + "build_number": 0, + "constrains": [ + "numpy 1.21.2 py37hd8d4704_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bf25f99bd65e2c25077c6a4742438782", + "name": "numpy-base", + "sha256": "59b2c5a8589f26cbb6594e6e1b6ab31bfe0b741ac6bcf767bdcebc66ddd3f1e7", + "size": 5009559, + "subdir": "linux-64", + "timestamp": 1634106895827, + "version": "1.21.2" + }, + "numpy-base-1.21.2-py37h79a1101_0.conda": { + "build": "py37h79a1101_0", + "build_number": 0, + "constrains": [ + "numpy 1.21.2 py37h20f2e39_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a378b639c34d21e13e4d45cada95eb9f", + "name": "numpy-base", + "sha256": "555e047e442f376c62c4a838c2b747ed288e730125285ce2387b77742fb87d5b", + "size": 5019294, + "subdir": "linux-64", + "timestamp": 1634106931400, + "version": "1.21.2" + }, + "numpy-base-1.21.2-py38h2b8c604_0.conda": { + "build": "py38h2b8c604_0", + "build_number": 0, + "constrains": [ + "numpy 1.21.2 py38hd8d4704_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "69ca7bf7d25f561a0f02d2c5594ed80f", + "name": "numpy-base", + "sha256": "4877ee6b5d323588f9c404a39045d7252ecd1ccf16e5fddb4bb0d1d95a5e8152", + "size": 5071006, + "subdir": "linux-64", + "timestamp": 1634106932275, + "version": "1.21.2" + }, + "numpy-base-1.21.2-py38h79a1101_0.conda": { + "build": "py38h79a1101_0", + "build_number": 0, + "constrains": [ + "numpy 1.21.2 py38h20f2e39_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d04d70a31f4120f3127bf1a749dcbeaa", + "name": "numpy-base", + "sha256": "8ba95cabda65117158ebbf5a4adde57a210ca7f46f0896ebb9eebe598e6100b7", + "size": 5059821, + "subdir": "linux-64", + "timestamp": 1634095881100, + "version": "1.21.2" + }, + "numpy-base-1.21.2-py39h2b8c604_0.conda": { + "build": "py39h2b8c604_0", + "build_number": 0, + "constrains": [ + "numpy 1.21.2 py39hd8d4704_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a94ef4f5e9be4fc33752eeeebd20115b", + "name": "numpy-base", + "sha256": "6d14777da4dc2942be029c7c4b0be939e449f5aff2f27389c80c0c1639886935", + "size": 5110524, + "subdir": "linux-64", + "timestamp": 1634106920988, + "version": "1.21.2" + }, + "numpy-base-1.21.2-py39h79a1101_0.conda": { + "build": "py39h79a1101_0", + "build_number": 0, + "constrains": [ + "numpy 1.21.2 py39h20f2e39_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "212fcc9c14b21a1cf43a6de5c2e3cf54", + "name": "numpy-base", + "sha256": "7fbd8ba6f8a56cc3abd8f4bd5a2f7a6a1bd29d8e7acf4973e50cd9d898ab322d", + "size": 5115088, + "subdir": "linux-64", + "timestamp": 1634095888862, + "version": "1.21.2" + }, + "numpy-base-1.21.5-py310h375b286_3.conda": { + "build": "py310h375b286_3", + "build_number": 3, + "constrains": [ + "numpy 1.21.5 py310hac523dd_3" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "493da9d1034c5095435c5302a39b449a", + "name": "numpy-base", + "sha256": "665ec061cf37ffd786da7abff1de9458e232eb91934be2fc049720cb248f0cd4", + "size": 12563835, + "subdir": "linux-64", + "timestamp": 1653916827576, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py310h9585f30_1.conda": { + "build": "py310h9585f30_1", + "build_number": 1, + "constrains": [ + "numpy 1.21.5 py310hfa59a62_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2454f9e4012d9f075a2796129cba27cd", + "name": "numpy-base", + "sha256": "1f6e0729e7564094b6b1fa7fda1c847f0b91ad5a8c109b5e52c30c96343f6cc0", + "size": 11653325, + "subdir": "linux-64", + "timestamp": 1649783057219, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py310h9585f30_2.conda": { + "build": "py310h9585f30_2", + "build_number": 2, + "constrains": [ + "numpy 1.21.5 py310hfa59a62_2" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f7b17e4c1821c558d90169287dea8c59", + "name": "numpy-base", + "sha256": "1241141cab6c275c87c5ccd02b3caff63c3e5b2592f15f196734bfb73141416c", + "size": 11670603, + "subdir": "linux-64", + "timestamp": 1651565832729, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py310hcba007f_3.conda": { + "build": "py310hcba007f_3", + "build_number": 3, + "constrains": [ + "numpy 1.21.5 py310h1794996_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "08f6e2a75b2d31bd1ad07603fbd98dc8", + "name": "numpy-base", + "sha256": "3889a8717edbb288b0e89c91d3b910242fd14883596143c0da53d0ca653f74ec", + "size": 12576161, + "subdir": "linux-64", + "timestamp": 1653918954465, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py310hf2716ce_1.conda": { + "build": "py310hf2716ce_1", + "build_number": 1, + "constrains": [ + "numpy 1.21.5 py310h4f1e569_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "cac9b1d7ab49f033d536b87d2307e2e1", + "name": "numpy-base", + "sha256": "be644ad4cfcd07ca89731d09bf5b935363949bad9851d8d0a51a864a939021ea", + "size": 11683213, + "subdir": "linux-64", + "timestamp": 1649783042666, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py310hf2716ce_2.conda": { + "build": "py310hf2716ce_2", + "build_number": 2, + "constrains": [ + "numpy 1.21.5 py310h4f1e569_2" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b79d6a9c3e5009140eb482ceee75c2ff", + "name": "numpy-base", + "sha256": "840c148f3c393d7ee460f5100fa4105cbbd9f6e4f3a1fff226c80ae53e1f4a7b", + "size": 11670643, + "subdir": "linux-64", + "timestamp": 1651563857224, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py37h1e6e340_3.conda": { + "build": "py37h1e6e340_3", + "build_number": 3, + "constrains": [ + "numpy 1.21.5 py37hf838250_3" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "da8ea4edb7e6f160ddc8a9f59e88798c", + "name": "numpy-base", + "sha256": "f2e1cb793ba672df2e2ec714ba1dfd8eb28fa328d6df66c5c565d2dd05e513aa", + "size": 5083051, + "subdir": "linux-64", + "timestamp": 1653915737686, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py37ha15fc14_3.conda": { + "build": "py37ha15fc14_3", + "build_number": 3, + "constrains": [ + "numpy 1.21.5 py37h6c91a56_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9a98ec37e983e97bd6f0e08713d4e71e", + "name": "numpy-base", + "sha256": "879680988b9a5898eaf0c36b25eed4293abdc030cd26ea88bdf29ce42a1302df", + "size": 5078252, + "subdir": "linux-64", + "timestamp": 1653917873833, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py37hb8be1f0_1.conda": { + "build": "py37hb8be1f0_1", + "build_number": 1, + "constrains": [ + "numpy 1.21.5 py37h7a5d4dd_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "61ca200866fcfdd07eccdc04c5bf1709", + "name": "numpy-base", + "sha256": "a6f3f10865af6a4524c7b14e7eb2c1c6ebb1bebbbbacb6b1677dfcdae2aafdc7", + "size": 5022473, + "subdir": "linux-64", + "timestamp": 1649782970693, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py37hb8be1f0_2.conda": { + "build": "py37hb8be1f0_2", + "build_number": 2, + "constrains": [ + "numpy 1.21.5 py37h7a5d4dd_2" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "86b159d16a3200675e58f31d40d3fd20", + "name": "numpy-base", + "sha256": "5b08b2132d0e22cf619c3b3c9d7a62bd830021aa790adb4302c8f60ea5ec24ff", + "size": 5024066, + "subdir": "linux-64", + "timestamp": 1651564826085, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py37hf524024_1.conda": { + "build": "py37hf524024_1", + "build_number": 1, + "constrains": [ + "numpy 1.21.5 py37he7a7128_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "67578848c692225223948ef4de7813ee", + "name": "numpy-base", + "sha256": "f173681485434e96165487996562fbc444f730f97380807353a07f2989cc1478", + "size": 5016608, + "subdir": "linux-64", + "timestamp": 1649783024841, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py37hf524024_2.conda": { + "build": "py37hf524024_2", + "build_number": 2, + "constrains": [ + "numpy 1.21.5 py37he7a7128_2" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "dc38ff3963c51aac0d1477f02cc2f6a6", + "name": "numpy-base", + "sha256": "9fa91c5ecc0f2bfd6607e6e25f97f6ef979434ac7556ae0a11c9866e554bebe6", + "size": 5020789, + "subdir": "linux-64", + "timestamp": 1651566819368, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py38h1e6e340_3.conda": { + "build": "py38h1e6e340_3", + "build_number": 3, + "constrains": [ + "numpy 1.21.5 py38hf838250_3" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a4657642f519ab8e5c4b32c19c1dec39", + "name": "numpy-base", + "sha256": "80c208e15a9b16889b3828492e3bf08f30f85eac17421eb5eb6b367bf5acf3e8", + "size": 5145979, + "subdir": "linux-64", + "timestamp": 1653916264664, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py38ha15fc14_3.conda": { + "build": "py38ha15fc14_3", + "build_number": 3, + "constrains": [ + "numpy 1.21.5 py38h6c91a56_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "df2b53a8f9518b6cdeda50a2210ef4c9", + "name": "numpy-base", + "sha256": "daf531eca19f7df4de7199ea610a1e4c0a95a0639fd0a995cae1de9e2768770b", + "size": 5146089, + "subdir": "linux-64", + "timestamp": 1653918401329, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py38hb8be1f0_1.conda": { + "build": "py38hb8be1f0_1", + "build_number": 1, + "constrains": [ + "numpy 1.21.5 py38h7a5d4dd_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "069b985d16159d5795670f15d585aa2f", + "name": "numpy-base", + "sha256": "64351c2d3321cc596b54e07addbd9910d410ce1fdfb67f086c5f2ce831cce544", + "size": 5069616, + "subdir": "linux-64", + "timestamp": 1649765112899, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py38hb8be1f0_2.conda": { + "build": "py38hb8be1f0_2", + "build_number": 2, + "constrains": [ + "numpy 1.21.5 py38h7a5d4dd_2" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "548465eee203935df9d30389a4fb83d7", + "name": "numpy-base", + "sha256": "6b3671627ed402777292f127a8bc257fe9d3533ae0d844572b4c3511b274b911", + "size": 5082223, + "subdir": "linux-64", + "timestamp": 1651565316969, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py38hf524024_1.conda": { + "build": "py38hf524024_1", + "build_number": 1, + "constrains": [ + "numpy 1.21.5 py38he7a7128_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "39d018ce248ad9b3c04142f155f4af2d", + "name": "numpy-base", + "sha256": "d1dd0bae2e768cbf5e29fe3ab885c6812a67ddafefe1ad71a77e9ea52dbbbccd", + "size": 5061746, + "subdir": "linux-64", + "timestamp": 1649783015859, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py38hf524024_2.conda": { + "build": "py38hf524024_2", + "build_number": 2, + "constrains": [ + "numpy 1.21.5 py38he7a7128_2" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "bc48ead5f03b0c8fc71bac9bef939b2b", + "name": "numpy-base", + "sha256": "706aa71fa55be3705737f754625a051ba7e10a651a4fa250e7df212965b08d93", + "size": 5083802, + "subdir": "linux-64", + "timestamp": 1651567308031, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py39h1e6e340_3.conda": { + "build": "py39h1e6e340_3", + "build_number": 3, + "constrains": [ + "numpy 1.21.5 py39hf838250_3" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "8e39e800797e1f967d10a778c129a4f2", + "name": "numpy-base", + "sha256": "feb29d4a1b2d3b02b74ed939db4ae617319c0a2887a24cd781865869c7b8d5c9", + "size": 5126025, + "subdir": "linux-64", + "timestamp": 1653917351255, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py39ha15fc14_3.conda": { + "build": "py39ha15fc14_3", + "build_number": 3, + "constrains": [ + "numpy 1.21.5 py39h6c91a56_3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7331de0d2aaf92f8d16d99a28e206169", + "name": "numpy-base", + "sha256": "1f6cd39aaa7271ac9d08237539c78ad3f4134a9f6256037bc62d766c82b0bdb0", + "size": 5122571, + "subdir": "linux-64", + "timestamp": 1653919477728, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py39hb8be1f0_1.conda": { + "build": "py39hb8be1f0_1", + "build_number": 1, + "constrains": [ + "numpy 1.21.5 py39h7a5d4dd_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "cf777985fd7b83c212003951bb74b798", + "name": "numpy-base", + "sha256": "0957b0606a0a75e4be368072d3c6bb91b1cc249ba8ee7300631639986fab7baa", + "size": 5075645, + "subdir": "linux-64", + "timestamp": 1649764875185, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py39hb8be1f0_2.conda": { + "build": "py39hb8be1f0_2", + "build_number": 2, + "constrains": [ + "numpy 1.21.5 py39h7a5d4dd_2" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ebc2facf83aaabe682d41a91e49b339a", + "name": "numpy-base", + "sha256": "4aa7877ec99ec5e6f05fcd9b3310de059e75bcaad74d252ce6b50bebd96b3e21", + "size": 5101779, + "subdir": "linux-64", + "timestamp": 1651564345402, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py39hf524024_1.conda": { + "build": "py39hf524024_1", + "build_number": 1, + "constrains": [ + "numpy 1.21.5 py39he7a7128_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "30aa0bb2adc449fda829d381cb24efc7", + "name": "numpy-base", + "sha256": "582738c771c05d790af442945b76819ae28fb9db848d0eac4a26588db131ac5d", + "size": 5079997, + "subdir": "linux-64", + "timestamp": 1649764875885, + "version": "1.21.5" + }, + "numpy-base-1.21.5-py39hf524024_2.conda": { + "build": "py39hf524024_2", + "build_number": 2, + "constrains": [ + "numpy 1.21.5 py39he7a7128_2" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c714a07cf173aa536798e56ae2b4a746", + "name": "numpy-base", + "sha256": "da81e98bb9b119a28cba35c9aa5cfabd9dedba0f77ad6484d7d46e7bb4b7d2af", + "size": 5101581, + "subdir": "linux-64", + "timestamp": 1651566332949, + "version": "1.21.5" + }, + "numpy-base-1.22.3-py310h9585f30_0.conda": { + "build": "py310h9585f30_0", + "build_number": 0, + "constrains": [ + "numpy 1.22.3 py310hfa59a62_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "da4d2e68bc141f83fc0b43843816e55c", + "name": "numpy-base", + "sha256": "16e57cae6b4b24538b5d36257181dbdae2c1a1d15dcaef8a6c4c716fe108202b", + "size": 12334405, + "subdir": "linux-64", + "timestamp": 1652802619412, + "version": "1.22.3" + }, + "numpy-base-1.22.3-py310hf2716ce_0.conda": { + "build": "py310hf2716ce_0", + "build_number": 0, + "constrains": [ + "numpy 1.22.3 py310h4f1e569_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ca4473e9819ec09b86aca73be75ff111", + "name": "numpy-base", + "sha256": "895026082bc8030ba683a0f20e47cf4304b54c690f023e539e6a48be671a08ac", + "size": 12335293, + "subdir": "linux-64", + "timestamp": 1652804688097, + "version": "1.22.3" + }, + "numpy-base-1.22.3-py311h0ff3221_1.conda": { + "build": "py311h0ff3221_1", + "build_number": 1, + "constrains": [ + "numpy 1.22.3 py311h75bd12f_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ec8ad662e3270b87fee898aca206ccbc", + "name": "numpy-base", + "sha256": "dbba898ac5c9e9c3474b6e40fc4189b8fc5906b665f32f04e0c06024e0e4284a", + "size": 7039373, + "subdir": "linux-64", + "timestamp": 1676824824950, + "version": "1.22.3" + }, + "numpy-base-1.22.3-py311hc9e7d78_1.conda": { + "build": "py311hc9e7d78_1", + "build_number": 1, + "constrains": [ + "numpy 1.22.3 py311h5585df3_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "80107bbdf99e567c97224fb17e7fcb18", + "name": "numpy-base", + "sha256": "74eca06b4103a4861fb13737394fc3aaafffa8866040b73bfb394ba287ec7622", + "size": 7040453, + "subdir": "linux-64", + "timestamp": 1676824669303, + "version": "1.22.3" + }, + "numpy-base-1.22.3-py38hb8be1f0_0.conda": { + "build": "py38hb8be1f0_0", + "build_number": 0, + "constrains": [ + "numpy 1.22.3 py38h7a5d4dd_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "5b457e4730d2ba80370e67b46db64a67", + "name": "numpy-base", + "sha256": "07538eb51abbae4ae6ab0d526eb2857faa0fb88b8c2c87a4ea8d1eec7ed18dee", + "size": 5668352, + "subdir": "linux-64", + "timestamp": 1652805368194, + "version": "1.22.3" + }, + "numpy-base-1.22.3-py38hf524024_0.conda": { + "build": "py38hf524024_0", + "build_number": 0, + "constrains": [ + "numpy 1.22.3 py38he7a7128_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f2dab1ba1f41cd293d282e0d32bfbebf", + "name": "numpy-base", + "sha256": "19571197005f7aa0a87ed4fb2f755d6ac6865d508fdacd191021c0f7946f1453", + "size": 5664204, + "subdir": "linux-64", + "timestamp": 1652803317026, + "version": "1.22.3" + }, + "numpy-base-1.22.3-py39hb8be1f0_0.conda": { + "build": "py39hb8be1f0_0", + "build_number": 0, + "constrains": [ + "numpy 1.22.3 py39h7a5d4dd_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f2cee1fd3aa29b9349361a454d7b608e", + "name": "numpy-base", + "sha256": "ae39314aac2765dd7abedc3a894f28798f79a795043f2530acad06b2f25fa72e", + "size": 5675307, + "subdir": "linux-64", + "timestamp": 1652804001140, + "version": "1.22.3" + }, + "numpy-base-1.22.3-py39hf524024_0.conda": { + "build": "py39hf524024_0", + "build_number": 0, + "constrains": [ + "numpy 1.22.3 py39he7a7128_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "6193ea3b7c456352a4153bf00d9bcadf", + "name": "numpy-base", + "sha256": "f854eca47da70badc59e63af4013e1bd71134a783d5fd660622b94ea17806e8c", + "size": 5674778, + "subdir": "linux-64", + "timestamp": 1652801886819, + "version": "1.22.3" + }, + "numpy-base-1.23.1-py310h375b286_0.conda": { + "build": "py310h375b286_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.1 py310hac523dd_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "3c72adc72b416eafe51fce6f512e91e0", + "name": "numpy-base", + "sha256": "24bb8de75115c8c30240ad14630d52327232d046ff6e84a012c822d5ccaf3c01", + "size": 15028760, + "subdir": "linux-64", + "timestamp": 1659434112799, + "version": "1.23.1" + }, + "numpy-base-1.23.1-py310hcba007f_0.conda": { + "build": "py310hcba007f_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.1 py310h1794996_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "aacf6c3fc0c9d7333de7542df84924e6", + "name": "numpy-base", + "sha256": "85258a50403f6ff7bb0a0a0fb07f8d903689e67ce0df8f3d38b1b41a476b4751", + "size": 15023331, + "subdir": "linux-64", + "timestamp": 1659435953834, + "version": "1.23.1" + }, + "numpy-base-1.23.1-py38h1e6e340_0.conda": { + "build": "py38h1e6e340_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.1 py38hf838250_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "df4b0890256ab252ea3762eb39a8b2bf", + "name": "numpy-base", + "sha256": "e98f0e8e9b6ce2ef909f87522871fa3f608f6988bc8866bb0164f86007e13051", + "size": 5893586, + "subdir": "linux-64", + "timestamp": 1659433462676, + "version": "1.23.1" + }, + "numpy-base-1.23.1-py38ha15fc14_0.conda": { + "build": "py38ha15fc14_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.1 py38h6c91a56_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "bb469d29c4c0f202450ead5a3ff38b2b", + "name": "numpy-base", + "sha256": "0e92b58193fba4b8f1d07f513ded05f0b4a0952d4caaa9b8d12a14b06356d438", + "size": 5891763, + "subdir": "linux-64", + "timestamp": 1659435304694, + "version": "1.23.1" + }, + "numpy-base-1.23.1-py39h1e6e340_0.conda": { + "build": "py39h1e6e340_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.1 py39hf838250_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7399d578fdbc49fb681bdc6daa9c342f", + "name": "numpy-base", + "sha256": "a5d9ec897d97a5a9e14f194cf198396652546b11df617931ae4d578201c6f440", + "size": 5862336, + "subdir": "linux-64", + "timestamp": 1659432871716, + "version": "1.23.1" + }, + "numpy-base-1.23.1-py39ha15fc14_0.conda": { + "build": "py39ha15fc14_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.1 py39h6c91a56_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "96109997f9135bee4283db03dc325e2c", + "name": "numpy-base", + "sha256": "6a92839f43db9248112a2b1803b94ca2be2dde1fba3522054bc7e676db12c2f6", + "size": 5862357, + "subdir": "linux-64", + "timestamp": 1659434713520, + "version": "1.23.1" + }, + "numpy-base-1.23.3-py310h375b286_1.conda": { + "build": "py310h375b286_1", + "build_number": 1, + "constrains": [ + "numpy 1.23.3 py310hac523dd_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "360d7c607a32cd87e99bd9525c617a82", + "name": "numpy-base", + "sha256": "5202650f4d60e3f3c514b4f98ab2d66c57c3773980e7905c9ec598a4dbf4c32c", + "size": 6973816, + "subdir": "linux-64", + "timestamp": 1667234277079, + "version": "1.23.3" + }, + "numpy-base-1.23.3-py310h8e6c178_1.conda": { + "build": "py310h8e6c178_1", + "build_number": 1, + "constrains": [ + "numpy 1.23.3 py310hd5efca6_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "24729daa6434c867e095ea258ca00c00", + "name": "numpy-base", + "sha256": "936c1aee9637f9d2b627a6e5b957ca3a62d79b95c413c8068e8794eca3d39557", + "size": 6974290, + "subdir": "linux-64", + "timestamp": 1667236095851, + "version": "1.23.3" + }, + "numpy-base-1.23.3-py38h1e6e340_0.conda": { + "build": "py38h1e6e340_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.3 py38hf838250_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2fee041109539c25663e52a74e484d23", + "name": "numpy-base", + "sha256": "aedb7c7035d5fe105836d0eb3974a57b7830f8555244b16bbcf2e924a3508fbf", + "size": 5904001, + "subdir": "linux-64", + "timestamp": 1665775154160, + "version": "1.23.3" + }, + "numpy-base-1.23.3-py38h1e6e340_1.conda": { + "build": "py38h1e6e340_1", + "build_number": 1, + "constrains": [ + "numpy 1.23.3 py38hf838250_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4db751680330e183ac3535e660cc84ed", + "name": "numpy-base", + "sha256": "8d5d9271142a990832580683d5c3b437bbf494100004437a709e3f908c15ca07", + "size": 6986845, + "subdir": "linux-64", + "timestamp": 1667233656053, + "version": "1.23.3" + }, + "numpy-base-1.23.3-py38h31eccc5_0.conda": { + "build": "py38h31eccc5_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.3 py38h14f4228_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3ba012270ac677989ebf464180b200ea", + "name": "numpy-base", + "sha256": "d010cdd4b3618f52f8f7fd802f572973f34433dcc1215381f30296900e287aac", + "size": 5904543, + "subdir": "linux-64", + "timestamp": 1665773363529, + "version": "1.23.3" + }, + "numpy-base-1.23.3-py38h31eccc5_1.conda": { + "build": "py38h31eccc5_1", + "build_number": 1, + "constrains": [ + "numpy 1.23.3 py38h14f4228_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "08f309576f6cde7e48ba536b17f73343", + "name": "numpy-base", + "sha256": "f7b746e93e30e275636239ce9bb25e270a19addd4aad86229fd3315560a2b3ef", + "size": 6988413, + "subdir": "linux-64", + "timestamp": 1667235473997, + "version": "1.23.3" + }, + "numpy-base-1.23.3-py39h1e6e340_0.conda": { + "build": "py39h1e6e340_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.3 py39hf838250_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "158b54ce6e1f2b086b9bec269d02be15", + "name": "numpy-base", + "sha256": "01c7d01858a985d8a50d7926c306ee600725bb51798e6045166475ba74076d18", + "size": 5879745, + "subdir": "linux-64", + "timestamp": 1665775767796, + "version": "1.23.3" + }, + "numpy-base-1.23.3-py39h1e6e340_1.conda": { + "build": "py39h1e6e340_1", + "build_number": 1, + "constrains": [ + "numpy 1.23.3 py39hf838250_1" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "00a19627eb46264341da4f2f7c013c32", + "name": "numpy-base", + "sha256": "7268f16b310a3cd9a014d14b5e70eacc8d68d912bfcbb9ff135fc96e76ade7de", + "size": 6965483, + "subdir": "linux-64", + "timestamp": 1667234874984, + "version": "1.23.3" + }, + "numpy-base-1.23.3-py39h31eccc5_0.conda": { + "build": "py39h31eccc5_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.3 py39h14f4228_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3237ea0df7ed502901102007e53ee1fd", + "name": "numpy-base", + "sha256": "ea9af29cc0d908224cff54771eaee60dd57eb26cd33fc007dc25ce8af04309b6", + "size": 5881599, + "subdir": "linux-64", + "timestamp": 1665773978393, + "version": "1.23.3" + }, + "numpy-base-1.23.3-py39h31eccc5_1.conda": { + "build": "py39h31eccc5_1", + "build_number": 1, + "constrains": [ + "numpy 1.23.3 py39h14f4228_1" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5cc84aa9eb78c713d5ce7b9122d54221", + "name": "numpy-base", + "sha256": "d928d5d05566174630bc1256b7a2cb0ca41bbebe93b3dd7e35b8cf47bec94da1", + "size": 6967408, + "subdir": "linux-64", + "timestamp": 1667236702226, + "version": "1.23.3" + }, + "numpy-base-1.23.4-py310h375b286_0.conda": { + "build": "py310h375b286_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.4 py310hac523dd_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fbf7cfe8fdb0d4b4fee08c9939952979", + "name": "numpy-base", + "sha256": "1cec17260fd415cdb29a70fa5ec923dc1011238dc1ac29dd2857b64478aa97b7", + "size": 7002189, + "subdir": "linux-64", + "timestamp": 1668599484845, + "version": "1.23.4" + }, + "numpy-base-1.23.4-py310h8e6c178_0.conda": { + "build": "py310h8e6c178_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.4 py310hd5efca6_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "443e5806d7da64f57b36a7dc682ca0a0", + "name": "numpy-base", + "sha256": "17114d566c0a0f2f550848604681dcb963baa8412774093e82f0b406240b91f8", + "size": 7004004, + "subdir": "linux-64", + "timestamp": 1668596121299, + "version": "1.23.4" + }, + "numpy-base-1.23.4-py38h1e6e340_0.conda": { + "build": "py38h1e6e340_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.4 py38hf838250_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b49fb33e001f9f6fb7cd86a723a230b4", + "name": "numpy-base", + "sha256": "8605da66e7b1554999732c77f695e8952a18af4befad1385b5642c87b9ec8445", + "size": 7016748, + "subdir": "linux-64", + "timestamp": 1668597215205, + "version": "1.23.4" + }, + "numpy-base-1.23.4-py38h31eccc5_0.conda": { + "build": "py38h31eccc5_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.4 py38h14f4228_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a33f04d4365fbe0a0a5f23f2618b123b", + "name": "numpy-base", + "sha256": "92e35845a60a5ed5de4d3c45e8fe6614c4148e830fbeffe627be33bb125be2fb", + "size": 7017918, + "subdir": "linux-64", + "timestamp": 1668593950327, + "version": "1.23.4" + }, + "numpy-base-1.23.4-py39h1e6e340_0.conda": { + "build": "py39h1e6e340_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.4 py39hf838250_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "223df6a6fcbaf0f62d606266c342c504", + "name": "numpy-base", + "sha256": "7c241adc5350c157f210a14ddf2518f75040aebdf0d506b431f7f52764bc2d71", + "size": 6995997, + "subdir": "linux-64", + "timestamp": 1668598380771, + "version": "1.23.4" + }, + "numpy-base-1.23.4-py39h31eccc5_0.conda": { + "build": "py39h31eccc5_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.4 py39h14f4228_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aee180b8bf892a15b492e505b01002d0", + "name": "numpy-base", + "sha256": "d18216c492293f39a57ade938003d982d1be7916613c5781294b6041781bebdd", + "size": 6998194, + "subdir": "linux-64", + "timestamp": 1668595062672, + "version": "1.23.4" + }, + "numpy-base-1.23.5-py310h375b286_0.conda": { + "build": "py310h375b286_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.5 py310hac523dd_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9638ad86e60249bae0a55a131d769f50", + "name": "numpy-base", + "sha256": "93bf7d00647f30bb6d483c9dfadf18aa8e2cc4ed2ec836a8b6b5a32a8d117b32", + "size": 7015077, + "subdir": "linux-64", + "timestamp": 1672337449337, + "version": "1.23.5" + }, + "numpy-base-1.23.5-py310h8e6c178_0.conda": { + "build": "py310h8e6c178_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.5 py310hd5efca6_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eecdd94d4fd0e4a266bc67810091dba8", + "name": "numpy-base", + "sha256": "cd335211b4542c68d68dfef5862ba26c69a7e726f76495add405f32e3c7e5080", + "size": 7015246, + "subdir": "linux-64", + "timestamp": 1672340580564, + "version": "1.23.5" + }, + "numpy-base-1.23.5-py311h0ff3221_0.conda": { + "build": "py311h0ff3221_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.5 py311h75bd12f_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2beb449e47c8f9e53a56ad1c30c955aa", + "name": "numpy-base", + "sha256": "6dc621c628e97e26855fff60215cdb96b08abeec855dacae9a6c851bd0ba0dc9", + "size": 7311832, + "subdir": "linux-64", + "timestamp": 1676824199179, + "version": "1.23.5" + }, + "numpy-base-1.23.5-py311hc9e7d78_0.conda": { + "build": "py311hc9e7d78_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.5 py311h5585df3_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "01549ffb52ff1876a28130dabaa79ddd", + "name": "numpy-base", + "sha256": "eda5c93c2645468f4b5d78d86f83356a8ab9c53ec746138608fd58cb57dfa4d5", + "size": 7307420, + "subdir": "linux-64", + "timestamp": 1676824030883, + "version": "1.23.5" + }, + "numpy-base-1.23.5-py38h1e6e340_0.conda": { + "build": "py38h1e6e340_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.5 py38hf838250_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "435c31703fbd58fa9076616b86e12c7f", + "name": "numpy-base", + "sha256": "3ec726425d906dd5ca40b480a1bf8c7428eae38ed53cbdaeba839a26032b4428", + "size": 7035328, + "subdir": "linux-64", + "timestamp": 1672336374433, + "version": "1.23.5" + }, + "numpy-base-1.23.5-py38h31eccc5_0.conda": { + "build": "py38h31eccc5_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.5 py38h14f4228_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0ce8eb513a64aedb9121172d9feb6fd6", + "name": "numpy-base", + "sha256": "3c8fd3c9ae2dfb62762b88d4098516de32a276935178ded25907f74ab78066b1", + "size": 7036574, + "subdir": "linux-64", + "timestamp": 1672339505555, + "version": "1.23.5" + }, + "numpy-base-1.23.5-py39h1e6e340_0.conda": { + "build": "py39h1e6e340_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.5 py39hf838250_0" + ], + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7b533cd4994a84e1130981dacbc66159", + "name": "numpy-base", + "sha256": "5c728610189fa951489ff3af5760619354cb0385fcaceecddb3dfe19740c7f3e", + "size": 7013921, + "subdir": "linux-64", + "timestamp": 1672338463726, + "version": "1.23.5" + }, + "numpy-base-1.23.5-py39h31eccc5_0.conda": { + "build": "py39h31eccc5_0", + "build_number": 0, + "constrains": [ + "numpy 1.23.5 py39h14f4228_0" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "991b9b84db6b37a19d47a4b5fc5755cc", + "name": "numpy-base", + "sha256": "e7307c59aa855ccd4b680545208e66e8549277f22b58e21be51b30d7a9abdfc7", + "size": 7015021, + "subdir": "linux-64", + "timestamp": 1672341589882, + "version": "1.23.5" + }, + "numpy-base-1.9.3-py27h1793315_7.conda": { + "build": "py27h1793315_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "e697deb3a854ace91d22c6147fda4d16", + "name": "numpy-base", + "sha256": "6bf768ee9c25b1fd8295993cd375a26eea6fd63229da2c9b600b8341350b1a47", + "size": 2767477, + "subdir": "linux-64", + "timestamp": 1534512656226, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py27h2b20989_5.conda": { + "build": "py27h2b20989_5", + "build_number": 5, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "709557aeb67dda5e8336920e8d34db5d", + "name": "numpy-base", + "sha256": "9ef374b9ee0c9d2bbfb27e37fb286db7ad9f374039d35c47944e33814673fc52", + "size": 2770368, + "subdir": "linux-64", + "timestamp": 1530278910117, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py27h2b20989_6.conda": { + "build": "py27h2b20989_6", + "build_number": 6, + "constrains": [ + "numpy 1.9.3 py27h28100ab_6" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "c18a8e7ca2e1245d005c366d66c6faea", + "name": "numpy-base", + "sha256": "54b5fe6af07c7db31ae182c953efcb58eec3d830b619fb9bd128bf9601c045a3", + "size": 2788430, + "subdir": "linux-64", + "timestamp": 1530379403825, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py27h2b20989_7.conda": { + "build": "py27h2b20989_7", + "build_number": 7, + "constrains": [ + "numpy 1.9.3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "b565fdd0f45971f23eec855f85e26e6f", + "name": "numpy-base", + "sha256": "427dc6d5ff8b4343313521890f221385391d8655f5360561adf5bbc83a97e4a3", + "size": 2770386, + "subdir": "linux-64", + "timestamp": 1530550385791, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py27hc937464_7.conda": { + "build": "py27hc937464_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=2.7,<2.8.0a0" + ], + "md5": "0004b7235d0d59ce6cd59e8441696967", + "name": "numpy-base", + "sha256": "911affdc434358fab05e04c7619465a190bea8afc308700b4da3bd6674edbc1b", + "size": 2767274, + "subdir": "linux-64", + "timestamp": 1534773437988, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py27hdbf6ddf_5.conda": { + "build": "py27hdbf6ddf_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "93b98fa01a40671fdef5b1d51646949b", + "name": "numpy-base", + "sha256": "fdf95626f2bc490d83a935abd3c3927873f53e0a72724f32fb4c9fcface137c9", + "size": 2769615, + "subdir": "linux-64", + "timestamp": 1530279148833, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py27hdbf6ddf_6.conda": { + "build": "py27hdbf6ddf_6", + "build_number": 6, + "constrains": [ + "numpy 1.9.3 py27hcd700cb_6" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "4c2b20a691da6ef8061f355130fd9d04", + "name": "numpy-base", + "sha256": "324ef6152bcc81dc166ebacde09413d5f976ad99a7112a2e6f6bc70485934c20", + "size": 3563090, + "subdir": "linux-64", + "timestamp": 1530382812495, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py27hdbf6ddf_7.conda": { + "build": "py27hdbf6ddf_7", + "build_number": 7, + "constrains": [ + "numpy 1.9.3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=2.7,<2.8.0a0", + "tbb4py" + ], + "md5": "d8ff04b1c0442389b70e77656bebf4e2", + "name": "numpy-base", + "sha256": "64046d0e8c2d3af20d0495ac7e7edb354ece9420ee2fa038a83df414d0b8c603", + "size": 2788363, + "subdir": "linux-64", + "timestamp": 1530552937617, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py35h1793315_7.conda": { + "build": "py35h1793315_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "b99fea34b8ec485c90f3967a056ae427", + "name": "numpy-base", + "sha256": "5ad9233b2d524a16026d47409bb3ea4519fab58e0c38c0f9da7ae2e407491d52", + "size": 2800025, + "subdir": "linux-64", + "timestamp": 1534772969911, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py35h2b20989_7.conda": { + "build": "py35h2b20989_7", + "build_number": 7, + "constrains": [ + "numpy 1.9.3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "c509d7bdb13a20ae08fd2c7dede12c04", + "name": "numpy-base", + "sha256": "0734f3a40bc569fe5f60223f135142d7474f93d74634bf3b63ad3fdf1d6f3ab8", + "size": 2823125, + "subdir": "linux-64", + "timestamp": 1530694195074, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py35hc937464_7.conda": { + "build": "py35hc937464_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.5,<3.6.0a0" + ], + "md5": "1073c314ef9e9236b30f203a9474cbe0", + "name": "numpy-base", + "sha256": "368850ec0cfc9a753776fff02da866a42e28f9b1876db3a63e3642dc822f2cee", + "size": 2800158, + "subdir": "linux-64", + "timestamp": 1534773213666, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py35hdbf6ddf_7.conda": { + "build": "py35hdbf6ddf_7", + "build_number": 7, + "constrains": [ + "numpy 1.9.3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.5,<3.6.0a0", + "tbb4py" + ], + "md5": "fdb3cedf80d65dd6980df57583ac8a3d", + "name": "numpy-base", + "sha256": "66de56a093c5e665d467346fddfe740d089150a35321a61323c30df80d430a35", + "size": 2800816, + "subdir": "linux-64", + "timestamp": 1530694422519, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py36h1793315_7.conda": { + "build": "py36h1793315_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "495daa9d6194d90960753f7fe624645e", + "name": "numpy-base", + "sha256": "faf9d9888da9554d3caef28e98b1e625f10913d5ceea71d219d455664968ee74", + "size": 2815284, + "subdir": "linux-64", + "timestamp": 1534773665035, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py36h2b20989_5.conda": { + "build": "py36h2b20989_5", + "build_number": 5, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "062029e4126784d802cf9a8dd57fa150", + "name": "numpy-base", + "sha256": "89765f48f0e5ceeaa68185e5273b920df33802a62c391900b37b0294172787a6", + "size": 2814874, + "subdir": "linux-64", + "timestamp": 1530278902183, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py36h2b20989_6.conda": { + "build": "py36h2b20989_6", + "build_number": 6, + "constrains": [ + "numpy 1.9.3 py36h28100ab_6" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "6bb0cbcd808d9a160ff12d49d792d90d", + "name": "numpy-base", + "sha256": "b6b39e18fab365d21264949b86fe50ccb9148628101c669befbdad2ced9ab10a", + "size": 2795181, + "subdir": "linux-64", + "timestamp": 1530380183640, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py36h2b20989_7.conda": { + "build": "py36h2b20989_7", + "build_number": 7, + "constrains": [ + "numpy 1.9.3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "f7ff334279610d79fe7388bdbc3e8b6c", + "name": "numpy-base", + "sha256": "019592674afbeaef9f9f0fec7b7f74718b43236cab37f20a23fbc17c5bb2a5f9", + "size": 2794195, + "subdir": "linux-64", + "timestamp": 1530550409615, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py36hc937464_7.conda": { + "build": "py36hc937464_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.6,<3.7.0a0" + ], + "md5": "5197e448aff8441a1aab0dc087ed4b25", + "name": "numpy-base", + "sha256": "1f1ad7ad350cdd520574e3aa84159526ae8b36ec5f953c413491955fc6a72739", + "size": 2794011, + "subdir": "linux-64", + "timestamp": 1534773898366, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py36hdbf6ddf_5.conda": { + "build": "py36hdbf6ddf_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "16a86aa1ecbeb2836f51a30b34a6fb18", + "name": "numpy-base", + "sha256": "102aaafdacb3d2ac02f40f8b7cbe016132452e05a981aff608a52b7dd473646e", + "size": 2815272, + "subdir": "linux-64", + "timestamp": 1530279203667, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py36hdbf6ddf_6.conda": { + "build": "py36hdbf6ddf_6", + "build_number": 6, + "constrains": [ + "numpy 1.9.3 py36hcd700cb_6" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "d04c91d86794dff0fa3153fcffa0f6c3", + "name": "numpy-base", + "sha256": "51dbb02f913f4edd8494600d3092ef207e9d04c8f63d31c81a07741e51103365", + "size": 3570250, + "subdir": "linux-64", + "timestamp": 1530383205268, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py36hdbf6ddf_7.conda": { + "build": "py36hdbf6ddf_7", + "build_number": 7, + "constrains": [ + "numpy 1.9.3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.6,<3.7.0a0", + "tbb4py" + ], + "md5": "2c9c8ada1039a4c454ca63b3d2bc34c0", + "name": "numpy-base", + "sha256": "a691a05e24c992af3c713ccb5fbc14803446725e644d944be987b450b3f44080", + "size": 2815448, + "subdir": "linux-64", + "timestamp": 1530553092861, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py37h1793315_7.conda": { + "build": "py37h1793315_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "f0cc034ccc79d8329cc7279abcd290ca", + "name": "numpy-base", + "sha256": "e96525374c1644e70e6bce8309732da88ca6fed98eac58c813796c82baf9ef23", + "size": 2800445, + "subdir": "linux-64", + "timestamp": 1534774128123, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py37h2b20989_5.conda": { + "build": "py37h2b20989_5", + "build_number": 5, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "743639edf50a9be62e3b6b0c3555d3ba", + "name": "numpy-base", + "sha256": "b5d34207242bd0a113d293f9883ae5b5f5c3cee695252ea0757fd35c5a824f86", + "size": 2783898, + "subdir": "linux-64", + "timestamp": 1530278961848, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py37h2b20989_6.conda": { + "build": "py37h2b20989_6", + "build_number": 6, + "constrains": [ + "numpy 1.9.3 py37h28100ab_6" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "a4500501ac62f2667fd4483dc427d1bb", + "name": "numpy-base", + "sha256": "5ae4de8a37dde760808f429e8292c87839c3d07c3673b74cda222f9d81fdfc28", + "size": 2783634, + "subdir": "linux-64", + "timestamp": 1530380489567, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py37h2b20989_7.conda": { + "build": "py37h2b20989_7", + "build_number": 7, + "constrains": [ + "numpy 1.9.3" + ], + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "ef0b05f5514ae065cdfa55641d55e98a", + "name": "numpy-base", + "sha256": "e5d0b89e6bfc53ee7aeba9592d6f872ff3ee16057a9f2ddaa841c4d3c41c1fbb", + "size": 2783807, + "subdir": "linux-64", + "timestamp": 1530550707727, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py37hc937464_7.conda": { + "build": "py37hc937464_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "python >=3.7,<3.8.0a0" + ], + "md5": "cb21814d27fe765cc6226a60cb6b1ff5", + "name": "numpy-base", + "sha256": "24cd0c0382f1742005b7b92111863744041dc53e19e3f28e0da5ab4cbc83f0a2", + "size": 2799521, + "subdir": "linux-64", + "timestamp": 1534774368143, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py37hdbf6ddf_5.conda": { + "build": "py37hdbf6ddf_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "e329e9e88d74108fe7d6ed8fc5558103", + "name": "numpy-base", + "sha256": "2983beee3f4cf8370a49a7309d580688cc78c9fdb052d774c116440d8b2dfeac", + "size": 2783680, + "subdir": "linux-64", + "timestamp": 1530279157175, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py37hdbf6ddf_6.conda": { + "build": "py37hdbf6ddf_6", + "build_number": 6, + "constrains": [ + "numpy 1.9.3 py37hcd700cb_6" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "4e67b89f4a28f6747de9bba198c97298", + "name": "numpy-base", + "sha256": "70b42e1de6a997d9ebd5fce73c0c986d2809436af496bc50095f45ae83e93cf3", + "size": 3558998, + "subdir": "linux-64", + "timestamp": 1530382457985, + "version": "1.9.3" + }, + "numpy-base-1.9.3-py37hdbf6ddf_7.conda": { + "build": "py37hdbf6ddf_7", + "build_number": 7, + "constrains": [ + "numpy 1.9.3" + ], + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2018.0.3,<2019.0a0", + "python >=3.7,<3.8.0a0", + "tbb4py" + ], + "md5": "eb5333cf11e3ca7a621bc7a61c4dc7d0", + "name": "numpy-base", + "sha256": "6cf8a10b77b440be05582cb87457ff9c62685ce72276c59d1181ee1740901dd7", + "size": 2783837, + "subdir": "linux-64", + "timestamp": 1530553299002, + "version": "1.9.3" + }, + "numpy-devel-1.11.3-h025eb46_7.conda": { + "build": "h025eb46_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.11.3 py36h2b20989_7" + ], + "md5": "4be211c9d99c44af461f76c5a3b92de3", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f8739c5bde7d20df25f8f6e1208981c7cbc7e93c88bcba169faee2c88d064bb7", + "size": 9441, + "subdir": "linux-64", + "timestamp": 1530381427032, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-h025eb46_8.conda": { + "build": "h025eb46_8", + "build_number": 8, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.11.3 py36h2b20989_8" + ], + "md5": "979da3c8bfaa90c63db696f08c6fa2c5", + "name": "numpy-devel", + "namespace": "python", + "sha256": "4717a09f2ba11dfbeeaf03378eef10647d85e03f9e3f4c84c767155fa5d74e9f", + "size": 9538, + "subdir": "linux-64", + "timestamp": 1530551408338, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-ha22f7c6_7.conda": { + "build": "ha22f7c6_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py37hdbf6ddf_7" + ], + "md5": "a45edde9bb0f23c33714a90c6277c0d3", + "name": "numpy-devel", + "namespace": "python", + "sha256": "5483fbfef378fb5dad0801ec88b4b9e4ac3576b5ea650cf0d4af16c3227429e3", + "size": 9433, + "subdir": "linux-64", + "timestamp": 1530382848807, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-ha22f7c6_8.conda": { + "build": "ha22f7c6_8", + "build_number": 8, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py37hdbf6ddf_8" + ], + "md5": "986fedcc0534547f720080325c39c969", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e797e76576d2bd2198c43d64c14ad5086981e6953b00908593917458137534fe", + "size": 9498, + "subdir": "linux-64", + "timestamp": 1530554148759, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h008b2eb_10.conda": { + "build": "py27h008b2eb_10", + "build_number": 10, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py27h2f8d375_10", + "python >=2.7,<2.8.0a0" + ], + "md5": "9d2b53ced637fb9ccb1394cc0d1943e9", + "name": "numpy-devel", + "namespace": "python", + "sha256": "3b46b6b2f07b04da56d1d0c885e6b043d346c63dc8894c0f892f03090df1cb96", + "size": 9991, + "subdir": "linux-64", + "timestamp": 1536892585777, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h008b2eb_11.conda": { + "build": "py27h008b2eb_11", + "build_number": 11, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py27h2f8d375_11", + "python >=2.7,<2.8.0a0" + ], + "md5": "d2a77f0f3e4028bb8ba9365eca941fdf", + "name": "numpy-devel", + "namespace": "python", + "sha256": "03dd0f9293b2d670a934d9861639945857f9fa0b717f35d2c3ea1f92046b7d04", + "size": 14484, + "subdir": "linux-64", + "timestamp": 1544631982195, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h008b2eb_12.conda": { + "build": "py27h008b2eb_12", + "build_number": 12, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py27h2f8d375_12", + "python >=2.7,<2.8.0a0" + ], + "md5": "2168f80a731385814b61b8b7cef621e3", + "name": "numpy-devel", + "namespace": "python", + "sha256": "1419e03185efc7de04917371cedb5895d30b36bbc87425368e690a70812ec2a3", + "size": 14987, + "subdir": "linux-64", + "timestamp": 1544762994853, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h4ba5984_11.conda": { + "build": "py27h4ba5984_11", + "build_number": 11, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py27hde5b4d6_11", + "python >=2.7,<2.8.0a0" + ], + "md5": "6b08341f80933ed8b95e8a713a144c7e", + "name": "numpy-devel", + "namespace": "python", + "sha256": "54f1bd349dada424163292860d5d963cea5c92e311ac564d28bd358c7d7d03b0", + "size": 14413, + "subdir": "linux-64", + "timestamp": 1544632852352, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h4ba5984_12.conda": { + "build": "py27h4ba5984_12", + "build_number": 12, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py27hde5b4d6_12", + "python >=2.7,<2.8.0a0" + ], + "md5": "f2faa1308e6d943ad87341b0100ff924", + "name": "numpy-devel", + "namespace": "python", + "sha256": "3e6f81faf7822d439982d493e1a11a461b20f1e65e82aabc867411f55dd90e6c", + "size": 14919, + "subdir": "linux-64", + "timestamp": 1544763191362, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h55f8cf0_10.conda": { + "build": "py27h55f8cf0_10", + "build_number": 10, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py27h74e8950_10", + "python >=2.7,<2.8.0a0" + ], + "md5": "588e8862751de22bc42cbe4ad2ab8ed2", + "name": "numpy-devel", + "namespace": "python", + "sha256": "90fc744b470591404b604fa37de2316fc906fa988c5a6949acb7b49288b40784", + "size": 9691, + "subdir": "linux-64", + "timestamp": 1535405721079, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h55f8cf0_9.conda": { + "build": "py27h55f8cf0_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py27h74e8950_9", + "python >=2.7,<2.8.0a0" + ], + "md5": "b98eaf849f0c652a44eb7afeea082409", + "name": "numpy-devel", + "namespace": "python", + "sha256": "1b0a46d6eb9cf16b2bc71578a54b0a739e9357404f8bed38aa20963a6f30595e", + "size": 9699, + "subdir": "linux-64", + "timestamp": 1535388183373, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h6bdb83d_10.conda": { + "build": "py27h6bdb83d_10", + "build_number": 10, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py27h81de0dd_10", + "python >=2.7,<2.8.0a0" + ], + "md5": "3a066aa908a70e8b33081ac87ddaa46a", + "name": "numpy-devel", + "namespace": "python", + "sha256": "3ee3dc9635a654182200998b03e6506444d4c0c5b18f768f3b8b0fbdc82d2e8f", + "size": 9713, + "subdir": "linux-64", + "timestamp": 1535405844328, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h6bdb83d_9.conda": { + "build": "py27h6bdb83d_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py27h3dfced4_9", + "python >=2.7,<2.8.0a0" + ], + "md5": "782ca978d45a0cadb0368b90dc8cc865", + "name": "numpy-devel", + "namespace": "python", + "sha256": "03de8cdb7b1a083706099432897e1016b0bee103a1b2166ec44aedea6a8930d8", + "size": 9388, + "subdir": "linux-64", + "timestamp": 1532661349366, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h8f55a68_9.conda": { + "build": "py27h8f55a68_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py27hc937464_9", + "python >=2.7,<2.8.0a0" + ], + "md5": "027ef6315c27ca7d84a8c63969e2cbe2", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ffd416b5ffedacec223991c3c563f5c5c0f5512f9f7e633ea184345f0a3e2b22", + "size": 9138, + "subdir": "linux-64", + "timestamp": 1534775228228, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27h99ba2d1_9.conda": { + "build": "py27h99ba2d1_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py27h1793315_9", + "python >=2.7,<2.8.0a0" + ], + "md5": "79cba887fe139e4005fec8aa132e6b83", + "name": "numpy-devel", + "namespace": "python", + "sha256": "95a8519d6b5f88345e2d77e2419cf66a577e88a90fc8107ff91fdad6bc19830d", + "size": 9104, + "subdir": "linux-64", + "timestamp": 1534775035254, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py27he073198_9.conda": { + "build": "py27he073198_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.11.3 py27h7cdd4dd_9", + "python >=2.7,<2.8.0a0" + ], + "md5": "9cd8396a7dfccaa9ada441d0c7bd5548", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6e88f6b2e7cd532a3aaa8b23e5a8c111d5a3dfd6db5f9eeb9d15626f40df0e0a", + "size": 9387, + "subdir": "linux-64", + "timestamp": 1532660248568, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py35h008b2eb_10.conda": { + "build": "py35h008b2eb_10", + "build_number": 10, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py35h2f8d375_10", + "python >=3.5,<3.6.0a0" + ], + "md5": "14bd2ebfd1b63c5b1473a7d017dfa7ff", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e0718bc3ffc4c65a52a12d3d5bcd2984e074b53966c99b0baf3ff24883eef962", + "size": 9958, + "subdir": "linux-64", + "timestamp": 1536892619006, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py35h55f8cf0_10.conda": { + "build": "py35h55f8cf0_10", + "build_number": 10, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py35h74e8950_10", + "python >=3.5,<3.6.0a0" + ], + "md5": "ee97e36f40b6838b8e8e1010e2568d0d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "13535b4fb53df695ee6dca08f92b7cfaf82ed980f1563409ae37044988e7dbc1", + "size": 9748, + "subdir": "linux-64", + "timestamp": 1535405695848, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py35h55f8cf0_9.conda": { + "build": "py35h55f8cf0_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py35h74e8950_9", + "python >=3.5,<3.6.0a0" + ], + "md5": "a1ca1b8573d6f5bae0f65151809a4e20", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2d6e3ed94b2efe0e826e75052cd5e5cbe4df9cc5667b8f6db5f4d86b661265d7", + "size": 9686, + "subdir": "linux-64", + "timestamp": 1535388581111, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py35h6bdb83d_10.conda": { + "build": "py35h6bdb83d_10", + "build_number": 10, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py35h81de0dd_10", + "python >=3.5,<3.6.0a0" + ], + "md5": "17acdaaa686717c48ed067fe7f248734", + "name": "numpy-devel", + "namespace": "python", + "sha256": "8ddd63897a72f6050f9e9b7e240b7eab24eb86e50b58dcd223073f8e8fc80096", + "size": 9713, + "subdir": "linux-64", + "timestamp": 1535406574519, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py35h6bdb83d_9.conda": { + "build": "py35h6bdb83d_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py35h3dfced4_9", + "python >=3.5,<3.6.0a0" + ], + "md5": "37d9070ef73b4a7071a8e8718e832698", + "name": "numpy-devel", + "namespace": "python", + "sha256": "4f265d6d75f0856a45a012afae4c4e0d4adac4706d7a4656728220894544741b", + "size": 9388, + "subdir": "linux-64", + "timestamp": 1532661311670, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py35h8f55a68_9.conda": { + "build": "py35h8f55a68_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py35hc937464_9", + "python >=3.5,<3.6.0a0" + ], + "md5": "32016fccf9d8c9a8848c6fbf172c9c19", + "name": "numpy-devel", + "namespace": "python", + "sha256": "49cd56ae946927cdc79ccfaf67885351615af3056cf002a0d0b16fe03f0dc5c3", + "size": 9126, + "subdir": "linux-64", + "timestamp": 1534774842509, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py35h99ba2d1_9.conda": { + "build": "py35h99ba2d1_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py35h1793315_9", + "python >=3.5,<3.6.0a0" + ], + "md5": "cfc6b8dc3e3a9632f7d264ee2c341ac7", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6f97d6cf4ff65453447763095d60780d13a630012493d03d17d3fbefadeae01f", + "size": 9131, + "subdir": "linux-64", + "timestamp": 1534774640284, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py35he073198_9.conda": { + "build": "py35he073198_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.11.3 py35h7cdd4dd_9", + "python >=3.5,<3.6.0a0" + ], + "md5": "3b3388ef18b36f1907384c909043e0d3", + "name": "numpy-devel", + "namespace": "python", + "sha256": "bbb540a10c38c8e7c57d7f1dfeda524c84c8c955c5780a4a65f661bd77e98ef7", + "size": 9390, + "subdir": "linux-64", + "timestamp": 1532660222243, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h008b2eb_10.conda": { + "build": "py36h008b2eb_10", + "build_number": 10, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py36h2f8d375_10", + "python >=3.6,<3.7.0a0" + ], + "md5": "d7625749b4b990b1a42177871c4e6f0a", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a9f3328f604b674655f8655a328fe0065ada72fed26248c51891d47c2375dc7b", + "size": 9959, + "subdir": "linux-64", + "timestamp": 1536892551198, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h008b2eb_11.conda": { + "build": "py36h008b2eb_11", + "build_number": 11, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py36h2f8d375_11", + "python >=3.6,<3.7.0a0" + ], + "md5": "31fbda586b97e09713aedc62e917d7d4", + "name": "numpy-devel", + "namespace": "python", + "sha256": "02fc2de1ea5450e7c18f8e0287c832ed650c13dd6f1778d536bab6b252c4a97f", + "size": 14425, + "subdir": "linux-64", + "timestamp": 1544632148643, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h008b2eb_12.conda": { + "build": "py36h008b2eb_12", + "build_number": 12, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py36h2f8d375_12", + "python >=3.6,<3.7.0a0" + ], + "md5": "5dc4a4d3e0a42212a7a2b76c1daec8db", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2ff6b71104ba6b3b47fc94a708048d8901a65eccff7d2467b01576c9a1745514", + "size": 14952, + "subdir": "linux-64", + "timestamp": 1544763157700, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h4ba5984_11.conda": { + "build": "py36h4ba5984_11", + "build_number": 11, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py36hde5b4d6_11", + "python >=3.6,<3.7.0a0" + ], + "md5": "939b3c929478f9a97edb8ccb22a3636c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "827e30ffd18fc63711f2bc36cf16ba8c21db20db8158a83c40be54e611db2e3c", + "size": 14462, + "subdir": "linux-64", + "timestamp": 1544632758293, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h4ba5984_12.conda": { + "build": "py36h4ba5984_12", + "build_number": 12, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py36hde5b4d6_12", + "python >=3.6,<3.7.0a0" + ], + "md5": "5dc524d55112fb7d6dd3577d13bb80de", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b68e4eef03b7544af65d6c64dd59dccd689c997e1b2fd1b3ed5538d7c892acb1", + "size": 14938, + "subdir": "linux-64", + "timestamp": 1544763352024, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h55f8cf0_10.conda": { + "build": "py36h55f8cf0_10", + "build_number": 10, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py36h74e8950_10", + "python >=3.6,<3.7.0a0" + ], + "md5": "34c6337c6a4d1a774589d704d4be75b0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2de4269d4ed4183a17ba4d5f56bf280cf9541e16e453492396b4b15e81c72983", + "size": 9725, + "subdir": "linux-64", + "timestamp": 1535405729837, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h55f8cf0_9.conda": { + "build": "py36h55f8cf0_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py36h74e8950_9", + "python >=3.6,<3.7.0a0" + ], + "md5": "675ad81666722e6a9cb479e9c10c6b3d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "3c3ba3663f271e3851de524e063a43a3d25d9526048599c07e43c38602cb9583", + "size": 9643, + "subdir": "linux-64", + "timestamp": 1535388644978, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h6bdb83d_10.conda": { + "build": "py36h6bdb83d_10", + "build_number": 10, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py36h81de0dd_10", + "python >=3.6,<3.7.0a0" + ], + "md5": "48f0eaa576537afc762cd1393a0a4d42", + "name": "numpy-devel", + "namespace": "python", + "sha256": "d70dad21e6ee84ee00105107b25a3042f9df352f6e728db977c1da6b9ab1bb88", + "size": 9706, + "subdir": "linux-64", + "timestamp": 1535405871358, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h6bdb83d_9.conda": { + "build": "py36h6bdb83d_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py36h3dfced4_9", + "python >=3.6,<3.7.0a0" + ], + "md5": "702c33e884eb0b0af354e5d85104ceff", + "name": "numpy-devel", + "namespace": "python", + "sha256": "d8e11d0b47f5199533dfe7b1ac781d70b286847e18430a6e9269fd19b628f024", + "size": 9361, + "subdir": "linux-64", + "timestamp": 1532661281595, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h8f55a68_9.conda": { + "build": "py36h8f55a68_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py36hc937464_9", + "python >=3.6,<3.7.0a0" + ], + "md5": "4b8d9084cd604119bb1f2751a5ae0d58", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a6f566d6292d367007c426ef26f04027931c0d62fb5529ca543fc17de98e77f3", + "size": 9106, + "subdir": "linux-64", + "timestamp": 1534775629834, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36h99ba2d1_9.conda": { + "build": "py36h99ba2d1_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py36h1793315_9", + "python >=3.6,<3.7.0a0" + ], + "md5": "84b597cd98302fed4946df4385265666", + "name": "numpy-devel", + "namespace": "python", + "sha256": "557f957dce72f4f5410412befa9107da390187e5662411998f86d8024a1544d7", + "size": 9126, + "subdir": "linux-64", + "timestamp": 1534775432374, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py36he073198_9.conda": { + "build": "py36he073198_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.11.3 py36h7cdd4dd_9", + "python >=3.6,<3.7.0a0" + ], + "md5": "a55b52c7aa61cecf49158eee5da97050", + "name": "numpy-devel", + "namespace": "python", + "sha256": "26be6c9072657c020412dd8bc310916710cdb5d644791d832e407b9013774b14", + "size": 9355, + "subdir": "linux-64", + "timestamp": 1532660189572, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h008b2eb_10.conda": { + "build": "py37h008b2eb_10", + "build_number": 10, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py37h2f8d375_10", + "python >=3.7,<3.8.0a0" + ], + "md5": "c3cc139616128f71d5756c2abe144a0c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "3ddbd5bb40eb754f042482c42471ab4507b154fc706290f7b1c1da198ff94c03", + "size": 9961, + "subdir": "linux-64", + "timestamp": 1536892546190, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h008b2eb_11.conda": { + "build": "py37h008b2eb_11", + "build_number": 11, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py37h2f8d375_11", + "python >=3.7,<3.8.0a0" + ], + "md5": "68d27f885daf4f8260328af7e5ea54a3", + "name": "numpy-devel", + "namespace": "python", + "sha256": "fe8afe8a23e7860242cc5e4976086009b8995641ccc231733289dfe51ed5cf44", + "size": 14426, + "subdir": "linux-64", + "timestamp": 1544631880123, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h008b2eb_12.conda": { + "build": "py37h008b2eb_12", + "build_number": 12, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py37h2f8d375_12", + "python >=3.7,<3.8.0a0" + ], + "md5": "f37a44770118127318d5f9bfefa6662a", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7c4ded36b3306c215a94ce9cf7e6bc99b1c922e5977a72fdaf762c65e4d73c4d", + "size": 14938, + "subdir": "linux-64", + "timestamp": 1544762992014, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h4ba5984_11.conda": { + "build": "py37h4ba5984_11", + "build_number": 11, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py37hde5b4d6_11", + "python >=3.7,<3.8.0a0" + ], + "md5": "87340725f5b5bcbf21a355e452e7a865", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a6d6736e98c38de0abe0a372f5f7d68fd025f4ec6d6426eb12888325157cc126", + "size": 14422, + "subdir": "linux-64", + "timestamp": 1544632790474, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h4ba5984_12.conda": { + "build": "py37h4ba5984_12", + "build_number": 12, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.11.3 py37hde5b4d6_12", + "python >=3.7,<3.8.0a0" + ], + "md5": "5a140f2e55dc8f6ba33e1d292b9a5945", + "name": "numpy-devel", + "namespace": "python", + "sha256": "4d15bca903bc0bb2e035e6729e87f1da721d3c17418c2a14b89b893abde51b42", + "size": 14937, + "subdir": "linux-64", + "timestamp": 1544763274876, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h55f8cf0_10.conda": { + "build": "py37h55f8cf0_10", + "build_number": 10, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py37h74e8950_10", + "python >=3.7,<3.8.0a0" + ], + "md5": "4c2a2ce4d0ade0873e28fe5be372ed3b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0676b16e22074a429f6c887f98e9edc130cc226d2d29d82f56ddf78648859a47", + "size": 9710, + "subdir": "linux-64", + "timestamp": 1535405086745, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h55f8cf0_9.conda": { + "build": "py37h55f8cf0_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py37h74e8950_9", + "python >=3.7,<3.8.0a0" + ], + "md5": "50a1eda57513347fc70130c8ba7335c6", + "name": "numpy-devel", + "namespace": "python", + "sha256": "c5d8831d1ceae6003ae15c6a8db10c5033594a021f96655bca527bd394919484", + "size": 9686, + "subdir": "linux-64", + "timestamp": 1535388607297, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h6bdb83d_10.conda": { + "build": "py37h6bdb83d_10", + "build_number": 10, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py37h81de0dd_10", + "python >=3.7,<3.8.0a0" + ], + "md5": "b46d3a8889dfa709db6df8aa60cecd62", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6d54238ccdc1b8a4a45098c8894a835ba805614480ae8303ce187b2da2f1fbcc", + "size": 9684, + "subdir": "linux-64", + "timestamp": 1535405871621, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h6bdb83d_9.conda": { + "build": "py37h6bdb83d_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py37h3dfced4_9", + "python >=3.7,<3.8.0a0" + ], + "md5": "f611d7329ff2b5be9b9bb11ff68a27c7", + "name": "numpy-devel", + "namespace": "python", + "sha256": "039f603fd3b5eb343e1154876e1bbcbac81e8e3c4316aa792e9a116a937f696d", + "size": 9358, + "subdir": "linux-64", + "timestamp": 1532661075280, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h8f55a68_9.conda": { + "build": "py37h8f55a68_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.11.3 py37hc937464_9", + "python >=3.7,<3.8.0a0" + ], + "md5": "1b6992b776cd42ea4f3f1e2804f3a884", + "name": "numpy-devel", + "namespace": "python", + "sha256": "50e6b8d6aa8104e77b6834be8186c97732e0ad1f8ff716a4eda27188b14f2316", + "size": 9131, + "subdir": "linux-64", + "timestamp": 1534776029870, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37h99ba2d1_9.conda": { + "build": "py37h99ba2d1_9", + "build_number": 9, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.11.3 py37h1793315_9", + "python >=3.7,<3.8.0a0" + ], + "md5": "cb3ecdb6ed819e87532c64f9a0a53e49", + "name": "numpy-devel", + "namespace": "python", + "sha256": "52d752a7eb49960b075fe108f6e8c598561c0bd49c51382da73005f72b00e0bb", + "size": 9110, + "subdir": "linux-64", + "timestamp": 1534775827979, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py37he073198_9.conda": { + "build": "py37he073198_9", + "build_number": 9, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.11.3 py37h7cdd4dd_9", + "python >=3.7,<3.8.0a0" + ], + "md5": "2f8b35a18d666977a5f1ba303fed107c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "9a6f71ddce75310b803be621622ab6dd5f0823fd89ef7e9e8f0ebb8354e9da9e", + "size": 9361, + "subdir": "linux-64", + "timestamp": 1532660242751, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py38h008b2eb_12.conda": { + "build": "py38h008b2eb_12", + "build_number": 12, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.11.3 py38h2f8d375_12", + "python >=3.8,<3.9.0a0" + ], + "md5": "f727c47faa9610e05a05444e9af4b624", + "name": "numpy-devel", + "namespace": "python", + "sha256": "699173f05b0c0e33743f475f45c2bdac26d8fd1a4c5b7d741d15ca887a55a145", + "size": 10901, + "subdir": "linux-64", + "timestamp": 1572609739590, + "version": "1.11.3" + }, + "numpy-devel-1.11.3-py38h4ba5984_12.conda": { + "build": "py38h4ba5984_12", + "build_number": 12, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.11.3 py38hde5b4d6_12", + "python >=3.8,<3.9.0a0" + ], + "md5": "52322f87f904dd71ecf768b9b74750e0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "d93a58dad1ca0a65f7f33fba9069d7889e2932e87f69874fbc4417571ea40329", + "size": 10910, + "subdir": "linux-64", + "timestamp": 1572609516189, + "version": "1.11.3" + }, + "numpy-devel-1.14.4-py27h025eb46_0.conda": { + "build": "py27h025eb46_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.4 py27h2b20989_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "39f3cebe2795f27579c8076c275a913d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "4854b31209d89ac93fcd6a399ef476ec4fb305dca2f3bcc6478bb14d07a2978d", + "size": 88655, + "subdir": "linux-64", + "timestamp": 1528829309281, + "version": "1.14.4" + }, + "numpy-devel-1.14.4-py27ha22f7c6_0.conda": { + "build": "py27ha22f7c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.4 py27hdbf6ddf_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "943d5b226ea43498f4c8393d60416794", + "name": "numpy-devel", + "namespace": "python", + "sha256": "c3273231d2f4c3f77c07c7f03dc5527f2d5b49473803f08db3b4434add5ee4cb", + "size": 88764, + "subdir": "linux-64", + "timestamp": 1528829775643, + "version": "1.14.4" + }, + "numpy-devel-1.14.4-py35h025eb46_0.conda": { + "build": "py35h025eb46_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.4 py35h2b20989_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "9e3ddb5cd87f59f5751aa090296f01a5", + "name": "numpy-devel", + "namespace": "python", + "sha256": "c3760b6b1a3622035f3ff5e4c78c2b16a95de37588287f7e9a20aa522f6ff9cd", + "size": 89850, + "subdir": "linux-64", + "timestamp": 1528829372965, + "version": "1.14.4" + }, + "numpy-devel-1.14.4-py35ha22f7c6_0.conda": { + "build": "py35ha22f7c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.4 py35hdbf6ddf_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "3c1798625ec0470034a4a79abca16b7c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2364ae11a0047ff88929f5bff8f367605ddd9fd8eb8bb693ce19222ccf9710fd", + "size": 88753, + "subdir": "linux-64", + "timestamp": 1528829876956, + "version": "1.14.4" + }, + "numpy-devel-1.14.4-py36h025eb46_0.conda": { + "build": "py36h025eb46_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.4 py36h2b20989_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "d3c3656669c7d9e5737d7373929f080d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f49ec9e9403ec84f5a09c0e09519ccef509fe755396d8d57d078a51779be985f", + "size": 89832, + "subdir": "linux-64", + "timestamp": 1528829332530, + "version": "1.14.4" + }, + "numpy-devel-1.14.4-py36ha22f7c6_0.conda": { + "build": "py36ha22f7c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.4 py36hdbf6ddf_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "7996aac4fac12639fac283b1df0db7cc", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f92e0be3284f194ccce970db4fb1ca34299cfc202f37a0d465c60343260d8fe7", + "size": 89982, + "subdir": "linux-64", + "timestamp": 1528829814533, + "version": "1.14.4" + }, + "numpy-devel-1.14.5-py27h025eb46_0.conda": { + "build": "py27h025eb46_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py27h2b20989_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "07cfcf50c9c229ec3b35a6753be1ab98", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7d342f4c07ed19b4238412139c888a323eb987ebb688b6261885113028ce3f27", + "size": 88503, + "subdir": "linux-64", + "timestamp": 1528900980980, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py27h025eb46_1.conda": { + "build": "py27h025eb46_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py27h2b20989_1", + "python >=2.7,<2.8.0a0" + ], + "md5": "8b8c267f2bf5b50030e40a0128f59466", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b4631d5a547e24e7e15fac59dfc6bc517385d12e2e32f5be6b4646182f40babe", + "size": 89398, + "subdir": "linux-64", + "timestamp": 1530354214761, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py27h025eb46_2.conda": { + "build": "py27h025eb46_2", + "build_number": 2, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py27h2b20989_2", + "python >=2.7,<2.8.0a0" + ], + "md5": "f6098783121a9901a4cf5cf4593f1aa6", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7a22ff3ad0b3dcd5c2b9068240f480e3caa6d061ca65e1bf526f22bee5114acb", + "size": 89273, + "subdir": "linux-64", + "timestamp": 1530382407056, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py27h025eb46_3.conda": { + "build": "py27h025eb46_3", + "build_number": 3, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py27h2b20989_3", + "python >=2.7,<2.8.0a0" + ], + "md5": "efd2f4e3f945b7988bfc1b70adc24463", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a2a576256f78a7a587c3f9e64ad128b48fe8ba5c87e3b90d25bc1a90153db794", + "size": 89321, + "subdir": "linux-64", + "timestamp": 1530553954780, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py27h025eb46_4.conda": { + "build": "py27h025eb46_4", + "build_number": 4, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py27h2b20989_4", + "python >=2.7,<2.8.0a0" + ], + "md5": "306006fe24d7b546efb985bd19125019", + "name": "numpy-devel", + "namespace": "python", + "sha256": "434b762807f7fd40b963c726aefcb12e2efbc9e133ac95f305ba328bd98972e1", + "size": 33535, + "subdir": "linux-64", + "timestamp": 1531326458226, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py27ha22f7c6_0.conda": { + "build": "py27ha22f7c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py27hdbf6ddf_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "2612c0c42d6ceb8ad825e083fa3f11a6", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ebc9870953f41dadba8a34daca09c0e62d85f93e8f69f26c02d8e335bd1b07b3", + "size": 88597, + "subdir": "linux-64", + "timestamp": 1528901320875, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py27ha22f7c6_1.conda": { + "build": "py27ha22f7c6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py27hdbf6ddf_1", + "python >=2.7,<2.8.0a0" + ], + "md5": "824bd5960dac6284b66a5a370234a6fa", + "name": "numpy-devel", + "namespace": "python", + "sha256": "d4c69ca786575eb34c99034770b7df3b3518ec0b7dc97c2ee5b1803e3374c1bb", + "size": 89503, + "subdir": "linux-64", + "timestamp": 1530353597493, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py27ha22f7c6_2.conda": { + "build": "py27ha22f7c6_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py27hdbf6ddf_2", + "python >=2.7,<2.8.0a0" + ], + "md5": "a2cc9d5959954deb9eed41bfd0f3f8e8", + "name": "numpy-devel", + "namespace": "python", + "sha256": "1609ac17d737c8336e3eb1055836d13c2a56ea85a3f5f5c53f05872071b75d72", + "size": 89263, + "subdir": "linux-64", + "timestamp": 1530383269906, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py27ha22f7c6_3.conda": { + "build": "py27ha22f7c6_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py27hdbf6ddf_3", + "python >=2.7,<2.8.0a0" + ], + "md5": "9f38440e0732c8aebef91ee2ccd6fc1c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "d3122d22fcff67dce04016c03b0bdaeea7d38d33e3ad44315b3641a94eddc642", + "size": 88275, + "subdir": "linux-64", + "timestamp": 1530554471956, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py27ha22f7c6_4.conda": { + "build": "py27ha22f7c6_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py27hdbf6ddf_4", + "python >=2.7,<2.8.0a0" + ], + "md5": "4cb36eaf16853f4cf6375482b31b66ea", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2806f04542439c6e597dda8d6515619c75f5c053643466574666f69cf121e280", + "size": 33464, + "subdir": "linux-64", + "timestamp": 1531326786348, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py35h025eb46_0.conda": { + "build": "py35h025eb46_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py35h2b20989_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "c9b8d8121a119a75d72e95c07c8da414", + "name": "numpy-devel", + "namespace": "python", + "sha256": "5bf079fdf75f477aa8e7f57dc3bf4d735ef8b4af8b19fbeb1a38df7774dfb78c", + "size": 89468, + "subdir": "linux-64", + "timestamp": 1528901015458, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py35h025eb46_4.conda": { + "build": "py35h025eb46_4", + "build_number": 4, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py35h2b20989_4", + "python >=3.5,<3.6.0a0" + ], + "md5": "747b5b0dc68487b3cc5e88a591df2ebe", + "name": "numpy-devel", + "namespace": "python", + "sha256": "4e16b0c5433cf345eb19732ef7bf8f6b82a858a3230804d3d7f21c38a0473d91", + "size": 33411, + "subdir": "linux-64", + "timestamp": 1534347301487, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py35ha22f7c6_0.conda": { + "build": "py35ha22f7c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py35hdbf6ddf_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "465d16b2b08532b6b25b18fbe0bc1200", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a2d0d005f114c32c97a00bb61c875030e76505bf89c3aa95e687956bf4a28ec5", + "size": 88574, + "subdir": "linux-64", + "timestamp": 1528901334725, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py35ha22f7c6_4.conda": { + "build": "py35ha22f7c6_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py35hdbf6ddf_4", + "python >=3.5,<3.6.0a0" + ], + "md5": "9e282ecb64e0ea30af132c9f2bfc85c4", + "name": "numpy-devel", + "namespace": "python", + "sha256": "07023b6389df6d62facade32bdffccbbea8a9991014e404721da1042fed97ff2", + "size": 33499, + "subdir": "linux-64", + "timestamp": 1534347002295, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36h025eb46_0.conda": { + "build": "py36h025eb46_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py36h2b20989_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "3da3e415076725aecbd30b05f2b5f447", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b9eceb2a4dc7f5ce5e9dfc6e001aac35670c0bf4357f6d73a732b73ec4fd7a48", + "size": 89463, + "subdir": "linux-64", + "timestamp": 1528900647127, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36h025eb46_1.conda": { + "build": "py36h025eb46_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py36h2b20989_1", + "python >=3.6,<3.7.0a0" + ], + "md5": "3a2a5bf534844403d6b021639271e555", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2f09ab5675ae8692b0adf3bfc2e512c0366abd999dd30d543f2e5be0b44f1b22", + "size": 89416, + "subdir": "linux-64", + "timestamp": 1530353151260, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36h025eb46_2.conda": { + "build": "py36h025eb46_2", + "build_number": 2, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py36h2b20989_2", + "python >=3.6,<3.7.0a0" + ], + "md5": "10a23756f6f13bf9f40aa169e30bc54d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "609386b9b530c1b64abcc390286f1399681e12f756a6a48a0ba79c017834ce15", + "size": 88192, + "subdir": "linux-64", + "timestamp": 1530382490198, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36h025eb46_3.conda": { + "build": "py36h025eb46_3", + "build_number": 3, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py36h2b20989_3", + "python >=3.6,<3.7.0a0" + ], + "md5": "4db4f3ebc0399fcd7e6578713f72a057", + "name": "numpy-devel", + "namespace": "python", + "sha256": "4f565545635f93321c3308783acc7900f81da44269c113fca9c17c459121771d", + "size": 88259, + "subdir": "linux-64", + "timestamp": 1530552882038, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36h025eb46_4.conda": { + "build": "py36h025eb46_4", + "build_number": 4, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py36h2b20989_4", + "python >=3.6,<3.7.0a0" + ], + "md5": "3c216bba5ceb65c23d80ea95192c941f", + "name": "numpy-devel", + "namespace": "python", + "sha256": "570bf42253d93534447fe97436d04d5b3d14d584fc41de2e2c0aa78bb82914cd", + "size": 33525, + "subdir": "linux-64", + "timestamp": 1531327723893, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36ha22f7c6_0.conda": { + "build": "py36ha22f7c6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py36hdbf6ddf_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "03baeefdd4a83a5c5487e2c42ab5f196", + "name": "numpy-devel", + "namespace": "python", + "sha256": "94eef72b972e095cedc663b9abb59e7e120c2f7d795a040a940a8d435208cbee", + "size": 89574, + "subdir": "linux-64", + "timestamp": 1528901040388, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36ha22f7c6_1.conda": { + "build": "py36ha22f7c6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py36hdbf6ddf_1", + "python >=3.6,<3.7.0a0" + ], + "md5": "4a05a8924260d185dcdc202d7dd84a7b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "28a5b702b2bf3aa25fe6b0758f419dc786009c08f1d3eebf11ca9e988cb54013", + "size": 88449, + "subdir": "linux-64", + "timestamp": 1530353627147, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36ha22f7c6_2.conda": { + "build": "py36ha22f7c6_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py36hdbf6ddf_2", + "python >=3.6,<3.7.0a0" + ], + "md5": "63085893c0ea9fc0dd7685b67185f475", + "name": "numpy-devel", + "namespace": "python", + "sha256": "5d7c882ea5b18537cb4d8e73d4034774a3744b64a7b099864aabbce4377552e0", + "size": 89239, + "subdir": "linux-64", + "timestamp": 1530383467294, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36ha22f7c6_3.conda": { + "build": "py36ha22f7c6_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py36hdbf6ddf_3", + "python >=3.6,<3.7.0a0" + ], + "md5": "06186c1479fda0f8517a2ae27c2bee01", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e45cf2d79770cca244e7d943ca509dacacfd9cc9b445c50c679b57f7fab0fbbf", + "size": 89316, + "subdir": "linux-64", + "timestamp": 1530553595265, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py36ha22f7c6_4.conda": { + "build": "py36ha22f7c6_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py36hdbf6ddf_4", + "python >=3.6,<3.7.0a0" + ], + "md5": "42a615cf3a1eca180358282980b6ea27", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6506bc8627e3f70e1c43efbbc02708fd7c6515cdc0955e9af3f6c5be035180fc", + "size": 33574, + "subdir": "linux-64", + "timestamp": 1531342884738, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py37h025eb46_1.conda": { + "build": "py37h025eb46_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py37h2b20989_1", + "python >=3.7,<3.8.0a0" + ], + "md5": "4576d88bb0c8df4e5d23f0c35cea5160", + "name": "numpy-devel", + "namespace": "python", + "sha256": "124935760023dc5a96cfd623287f1869fe428525780eda700b424415eb01c9ff", + "size": 88389, + "subdir": "linux-64", + "timestamp": 1530353369729, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py37h025eb46_2.conda": { + "build": "py37h025eb46_2", + "build_number": 2, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py37h2b20989_2", + "python >=3.7,<3.8.0a0" + ], + "md5": "e656c1bba62b1b55d6c9dadb77e91914", + "name": "numpy-devel", + "namespace": "python", + "sha256": "dd80b53e4d52c563fe0c0cb4c4f2f362c58552583f1f216f5c1fda01e0df709c", + "size": 88203, + "subdir": "linux-64", + "timestamp": 1530382924196, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py37h025eb46_3.conda": { + "build": "py37h025eb46_3", + "build_number": 3, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py37h2b20989_3", + "python >=3.7,<3.8.0a0" + ], + "md5": "0e4d57207936a39ecf25739bf40ae074", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a0276f2b97d3f943e8547c1219a565611b48b6f38fb63fa69ff38aed07a5ad39", + "size": 88260, + "subdir": "linux-64", + "timestamp": 1530553192351, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py37h025eb46_4.conda": { + "build": "py37h025eb46_4", + "build_number": 4, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.14.5 py37h2b20989_4", + "python >=3.7,<3.8.0a0" + ], + "md5": "a1df1608ed99f619b752cea06e4f58a3", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7bf23be635ad7f0f57227b1c7006bd01f702ffbb0ae1a3e7bec754ad21678305", + "size": 33523, + "subdir": "linux-64", + "timestamp": 1531327093064, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py37ha22f7c6_1.conda": { + "build": "py37ha22f7c6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py37hdbf6ddf_1", + "python >=3.7,<3.8.0a0" + ], + "md5": "5bc7af4c8054d0c4d78f75141e16f17c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f763f12b3670600ccca09ec7f870292b466161a9f5d70dd562ae9a5c61eb783f", + "size": 89497, + "subdir": "linux-64", + "timestamp": 1530353746701, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py37ha22f7c6_2.conda": { + "build": "py37ha22f7c6_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py37hdbf6ddf_2", + "python >=3.7,<3.8.0a0" + ], + "md5": "bb7f07a20b9e6e660885a842d08df871", + "name": "numpy-devel", + "namespace": "python", + "sha256": "167f2dc9da3cc96d523cf88ba30ced6503f04371f4c61ea82cc3337caafb21e4", + "size": 89258, + "subdir": "linux-64", + "timestamp": 1530383471566, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py37ha22f7c6_3.conda": { + "build": "py37ha22f7c6_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py37hdbf6ddf_3", + "python >=3.7,<3.8.0a0" + ], + "md5": "9e76aa132fda63129502c7243d405d91", + "name": "numpy-devel", + "namespace": "python", + "sha256": "d1c4e324d6c737796ab63efb086b12ff719675021732a11d79e39cee4327d601", + "size": 88280, + "subdir": "linux-64", + "timestamp": 1530553531284, + "version": "1.14.5" + }, + "numpy-devel-1.14.5-py37ha22f7c6_4.conda": { + "build": "py37ha22f7c6_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.5 py37hdbf6ddf_4", + "python >=3.7,<3.8.0a0" + ], + "md5": "7643144480bba4d1255fe5748f26800e", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b8eabdaa1bd2ffe6e83b308952aff94ebdd9a3bdf2a9b94123c28080b2325d5d", + "size": 33546, + "subdir": "linux-64", + "timestamp": 1531327414224, + "version": "1.14.5" + }, + "numpy-devel-1.14.6-py27h008b2eb_4.conda": { + "build": "py27h008b2eb_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.14.6 py27h2f8d375_4", + "python >=2.7,<2.8.0a0" + ], + "md5": "d2ea38dea4a9435f76ed5a7c14565e30", + "name": "numpy-devel", + "namespace": "python", + "sha256": "5ae092d9b3e497e34f24b56e821e6222538f998ca47c2b1bbc141ee0dcb66c99", + "size": 44489, + "subdir": "linux-64", + "timestamp": 1538074887733, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py27h008b2eb_5.conda": { + "build": "py27h008b2eb_5", + "build_number": 5, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.14.6 py27h2f8d375_5", + "python >=2.7,<2.8.0a0" + ], + "md5": "cba1246f301a08fa83e9a5f871aabdbf", + "name": "numpy-devel", + "namespace": "python", + "sha256": "24841de4ca301ef491912e01487bf7db041b75abade54ef1b4836fbed06ca893", + "size": 44726, + "subdir": "linux-64", + "timestamp": 1569339402622, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py27h4ba5984_5.conda": { + "build": "py27h4ba5984_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.14.6 py27hde5b4d6_5", + "python >=2.7,<2.8.0a0" + ], + "md5": "9291e65a9fbaf7edd1deb7847d021226", + "name": "numpy-devel", + "namespace": "python", + "sha256": "874dd42ada33987f310d7f2c0ff243287e7fa49699d38a798a79fac9721a5f7e", + "size": 44763, + "subdir": "linux-64", + "timestamp": 1569339428290, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py27h6bdb83d_4.conda": { + "build": "py27h6bdb83d_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.6 py27h81de0dd_4", + "python >=2.7,<2.8.0a0" + ], + "md5": "1abfe028be2acc8e536dacbc6ecaae1d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "97484f563701abee71e500a0f66d78d0396b199fcdeadda398317e1cd5a81aba", + "size": 44489, + "subdir": "linux-64", + "timestamp": 1538074674706, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py35h008b2eb_4.conda": { + "build": "py35h008b2eb_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.14.6 py35h2f8d375_4", + "python >=3.5,<3.6.0a0" + ], + "md5": "f284e8e9901b2bd25e059e28b910d248", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f71ae09bb4e4bb867738a61edd6f06d77edc78bf1a4fb89a1e8b4bfed16926a9", + "size": 44656, + "subdir": "linux-64", + "timestamp": 1538074519142, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py35h6bdb83d_4.conda": { + "build": "py35h6bdb83d_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.6 py35h81de0dd_4", + "python >=3.5,<3.6.0a0" + ], + "md5": "cd413cd16a01299ff332d87e6084b45c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "fa1454aa1ad489beba4e3ddb12e8af1c7632386446b1ccc301291130db3eef56", + "size": 44455, + "subdir": "linux-64", + "timestamp": 1538074964408, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py36h008b2eb_4.conda": { + "build": "py36h008b2eb_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.14.6 py36h2f8d375_4", + "python >=3.6,<3.7.0a0" + ], + "md5": "c07c72810e79c1ab9709dfa41bbed499", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f6cc2ccb795654e84c092042b7cbba85f280c5ebb4c15cefbae1dd942c3cfe66", + "size": 44494, + "subdir": "linux-64", + "timestamp": 1538074877402, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py36h008b2eb_5.conda": { + "build": "py36h008b2eb_5", + "build_number": 5, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.14.6 py36h2f8d375_5", + "python >=3.6,<3.7.0a0" + ], + "md5": "9e912a093c3e2bb34d6ebf1f774fbe3b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6c4f3ec540992b55f1054ffafd9f6e439cff147781cf41f8ff375f0410046502", + "size": 44909, + "subdir": "linux-64", + "timestamp": 1569339295847, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py36h4ba5984_5.conda": { + "build": "py36h4ba5984_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.14.6 py36hde5b4d6_5", + "python >=3.6,<3.7.0a0" + ], + "md5": "c2451ef8d78e431df27523e9bbbbf45c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0f809eee96c88b71f963526da6f1281214d9fd8dc9746fca71383c6ffb912500", + "size": 44952, + "subdir": "linux-64", + "timestamp": 1569339447875, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py36h6bdb83d_4.conda": { + "build": "py36h6bdb83d_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.6 py36h81de0dd_4", + "python >=3.6,<3.7.0a0" + ], + "md5": "9a995ad125b9b3ccb5f4adf64fca71ba", + "name": "numpy-devel", + "namespace": "python", + "sha256": "afafccb08712f23487a035939016287a7eb2b107eeeb27b68d1d673c138e004a", + "size": 44464, + "subdir": "linux-64", + "timestamp": 1538075108641, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py37h008b2eb_4.conda": { + "build": "py37h008b2eb_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.14.6 py37h2f8d375_4", + "python >=3.7,<3.8.0a0" + ], + "md5": "c0aa82520f5ebb8a60f716cf91fc9888", + "name": "numpy-devel", + "namespace": "python", + "sha256": "31acaa447c612afe43afafbf4352c3120d5060869c1ee0a268cf45207c62da04", + "size": 44636, + "subdir": "linux-64", + "timestamp": 1538074432691, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py37h008b2eb_5.conda": { + "build": "py37h008b2eb_5", + "build_number": 5, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.14.6 py37h2f8d375_5", + "python >=3.7,<3.8.0a0" + ], + "md5": "0bb148185e16fa6b850851deb7e033e0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "94d2cd2dcaab0c8ad54988cde95fc3ba3d38942629dafdf7549ccd5c7653a2e6", + "size": 44877, + "subdir": "linux-64", + "timestamp": 1569339398068, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py37h4ba5984_5.conda": { + "build": "py37h4ba5984_5", + "build_number": 5, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.14.6 py37hde5b4d6_5", + "python >=3.7,<3.8.0a0" + ], + "md5": "436a98177e6e541dcb892b6a0f570ea0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0fdd8ff266636a27bf34801d31780d0a79bf5a510fea3ea6f1f114684ea6bf38", + "size": 44945, + "subdir": "linux-64", + "timestamp": 1569339447219, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py37h6bdb83d_4.conda": { + "build": "py37h6bdb83d_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.14.6 py37h81de0dd_4", + "python >=3.7,<3.8.0a0" + ], + "md5": "5f377f4f7dd5750081eb8d129fe6102d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a24a5da773269cdfdcc9abf69cbafc648f0535125f6db82efac9dd40894d3742", + "size": 44441, + "subdir": "linux-64", + "timestamp": 1538074982262, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py38h008b2eb_4.conda": { + "build": "py38h008b2eb_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.14.6 py38h2f8d375_4", + "python >=3.8,<3.9.0a0" + ], + "md5": "78dec7f345148dd7b722aa51b0c11920", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0bdf23319de24ff6666a8e6bcca68744e08b469d77f4c3155a3b048bde2d25f7", + "size": 34052, + "subdir": "linux-64", + "timestamp": 1574081303574, + "version": "1.14.6" + }, + "numpy-devel-1.14.6-py38h4ba5984_4.conda": { + "build": "py38h4ba5984_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.14.6 py38hde5b4d6_4", + "python >=3.8,<3.9.0a0" + ], + "md5": "1bd116da6b60331aa6e1276c94391cdd", + "name": "numpy-devel", + "namespace": "python", + "sha256": "115293d40b13756ed0114aa062990ff727644f92a621532075a608feb53b9020", + "size": 34085, + "subdir": "linux-64", + "timestamp": 1574081562288, + "version": "1.14.6" + }, + "numpy-devel-1.15.0-py27h6bdb83d_0.conda": { + "build": "py27h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.0 py27h3dfced4_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "2a94cd12af5264d72eaa482ff76726f8", + "name": "numpy-devel", + "namespace": "python", + "sha256": "378546665c1c0a4cfb0aced17101485361f8c1042e2d8d70c025a8ead61838d7", + "size": 33717, + "subdir": "linux-64", + "timestamp": 1532704211399, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py27h8f55a68_0.conda": { + "build": "py27h8f55a68_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.0 py27hc937464_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "c9f9f1924b2351df574c6b1ca4719803", + "name": "numpy-devel", + "namespace": "python", + "sha256": "26b770a59e12a5101f060e161f72fcffaa223a1304ec2695ad9ce7b75b38f1ba", + "size": 34944, + "subdir": "linux-64", + "timestamp": 1534777033859, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py27h99ba2d1_0.conda": { + "build": "py27h99ba2d1_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.0 py27h1793315_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "c9d2e71e4a58c37ed19aa67ee9d82203", + "name": "numpy-devel", + "namespace": "python", + "sha256": "db2707b5ad1d3c6700ee563bbf87629bcf6947902c569a8cfd6dbeb5b07501e5", + "size": 34964, + "subdir": "linux-64", + "timestamp": 1534776859741, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py27he073198_0.conda": { + "build": "py27he073198_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.15.0 py27h7cdd4dd_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "ef92e60c04a1a46dc9148b4d618c4fb4", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e32b7938cd30eab0e01f868c91cc67bbc9925f0d69954314c670916094a264bb", + "size": 33767, + "subdir": "linux-64", + "timestamp": 1532703560130, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py35h6bdb83d_0.conda": { + "build": "py35h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.0 py35h3dfced4_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "ee86d288da369690abaa9f7f6abdb43c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "bd172150993dca842feb0f9a6b49fe00e8f356bf3363a787f6db946d68b6ed4b", + "size": 33714, + "subdir": "linux-64", + "timestamp": 1532704630272, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py35h8f55a68_0.conda": { + "build": "py35h8f55a68_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.0 py35hc937464_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "c9d4bb6277150b3b85d563705d81bde2", + "name": "numpy-devel", + "namespace": "python", + "sha256": "201231f868156f2a0b990da8a01665927acf5ff8ca28f0a6a6170cd891a385b6", + "size": 34994, + "subdir": "linux-64", + "timestamp": 1534776673544, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py35h99ba2d1_0.conda": { + "build": "py35h99ba2d1_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.0 py35h1793315_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "5a9bb84eae265bf1ffc258744af06b5c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "3445b1c8d18cf0d90a8c8db70bff60f9fef7879643f2250481a8b71473897e15", + "size": 35020, + "subdir": "linux-64", + "timestamp": 1534776483685, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py35he073198_0.conda": { + "build": "py35he073198_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.15.0 py35h7cdd4dd_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "8f6a2fdb1d160c6af3c91fbbcdc2e34d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "8d4c72f530e71053a780284144639bea6f17a6b3656c65eeee7ff0e3136092d1", + "size": 33907, + "subdir": "linux-64", + "timestamp": 1532703797276, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py36h6bdb83d_0.conda": { + "build": "py36h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.0 py36h3dfced4_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "092e78155585ef228e4f56bfc1d6f2a5", + "name": "numpy-devel", + "namespace": "python", + "sha256": "fb6806419188871ff5b3183553e5a3620b007cd4efa647f3c55f859a8518c98c", + "size": 33798, + "subdir": "linux-64", + "timestamp": 1532704545794, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py36h8f55a68_0.conda": { + "build": "py36h8f55a68_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.0 py36hc937464_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "c1e136afa99bb4e041cc34590a392814", + "name": "numpy-devel", + "namespace": "python", + "sha256": "bc7e198e70c90d545afea6ff3f3c4c4a30b43e452b682165e05efeb5fa6d16a0", + "size": 34934, + "subdir": "linux-64", + "timestamp": 1534777416697, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py36h99ba2d1_0.conda": { + "build": "py36h99ba2d1_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.0 py36h1793315_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "88d800dd29e118224b53629a9c1ba829", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0696af7cde5f3e649437164d4186dedd7ca63e41cc0125827a3e844728aae98c", + "size": 35014, + "subdir": "linux-64", + "timestamp": 1534777234407, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py36he073198_0.conda": { + "build": "py36he073198_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.15.0 py36h7cdd4dd_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "c2ccef730ab48180b410f825b5bd90ad", + "name": "numpy-devel", + "namespace": "python", + "sha256": "fabcb4b75d92a60b57270b25ada11f8a34374ab074c4a9598523cdbb26bccd20", + "size": 33773, + "subdir": "linux-64", + "timestamp": 1532703625362, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py37h6bdb83d_0.conda": { + "build": "py37h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.0 py37h3dfced4_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "b8ea9767f9eeff1db299712e5c27eb8e", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a2c50a48806efa01ee66cf418cb83704b5abee6fa6cd74a55f4900cfd619af40", + "size": 33806, + "subdir": "linux-64", + "timestamp": 1532704715051, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py37h8f55a68_0.conda": { + "build": "py37h8f55a68_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.0 py37hc937464_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "09ffb527a85cec505146a63db14b111d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "49f9ae9dee615a1975926d0e1ef663cbd2f7f9a1e14128986e37746cc81ab43e", + "size": 34934, + "subdir": "linux-64", + "timestamp": 1534777789200, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py37h99ba2d1_0.conda": { + "build": "py37h99ba2d1_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.0 py37h1793315_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "fd0f4dc85f27c7ff823791b6b7d1f855", + "name": "numpy-devel", + "namespace": "python", + "sha256": "caebdf38da7cf1f68750ab83c5d7fa373ee487f6722a114ff1b3d683558229a6", + "size": 35027, + "subdir": "linux-64", + "timestamp": 1534777612071, + "version": "1.15.0" + }, + "numpy-devel-1.15.0-py37he073198_0.conda": { + "build": "py37he073198_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.15.0 py37h7cdd4dd_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "8b02c0defa57250c6738cb2b2068956f", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0d9fc3aedc0959b55e88fc1fcc285d96183bfbc7c689e3163b22600a59981396", + "size": 33671, + "subdir": "linux-64", + "timestamp": 1532703779866, + "version": "1.15.0" + }, + "numpy-devel-1.15.1-py27h008b2eb_0.conda": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.1 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "38a68d05fcf2784b9a3f735baf6cd10d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6a1e6e23c4aa431212db681c48cae33d1201ace29ad8664c3c7b78c5a4b4669b", + "size": 35331, + "subdir": "linux-64", + "timestamp": 1536895342652, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py27h55f8cf0_0.conda": { + "build": "py27h55f8cf0_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.1 py27h74e8950_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "b359db4bc0cf1db9e42b6ac43a6b5dd0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b478e50614f6c5d8ebf8c0d6e07c0e0742c506073d23435df94d7fa5b1a5f814", + "size": 35226, + "subdir": "linux-64", + "timestamp": 1535389607676, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py27h6bdb83d_0.conda": { + "build": "py27h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.1 py27h81de0dd_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "7721bf747825d77b97f6694f7cb994d1", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0534b5996d851601142ffe00db2f7099c51f04618e350d855f855c7abb21dc15", + "size": 35294, + "subdir": "linux-64", + "timestamp": 1535389895270, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py35h008b2eb_0.conda": { + "build": "py35h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.1 py35h2f8d375_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "a9223edf3ee2501638bee8cbc6d44915", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b5e8e8ee80a968fb4f515f0a5959c592efc15d04cb1c6339b5c243eed95bc2f4", + "size": 35342, + "subdir": "linux-64", + "timestamp": 1536895293110, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py35h55f8cf0_0.conda": { + "build": "py35h55f8cf0_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.1 py35h74e8950_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "3930431742fe7adf4e11bb9fbdbc24f9", + "name": "numpy-devel", + "namespace": "python", + "sha256": "91f5c04800a89c762dc5a2d856c95951fb2c45b15e5be5583aa8339e215d1acb", + "size": 35208, + "subdir": "linux-64", + "timestamp": 1535389431517, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py35h6bdb83d_0.conda": { + "build": "py35h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.1 py35h81de0dd_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "bb2989f5438ec285013c38d96d74ee88", + "name": "numpy-devel", + "namespace": "python", + "sha256": "18c197bbf68e5629bf24b8bc2ab947c24d2954c93e5d845155273c6f6bbd5a34", + "size": 35277, + "subdir": "linux-64", + "timestamp": 1535389587657, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py36h008b2eb_0.conda": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.1 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "6827cfe8787bed199c5ae5e2cf659a3c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "51e5064940f7301d3d42b560c698c6870e9a7ed3b9c3a8b990a6e2537fb3c222", + "size": 35388, + "subdir": "linux-64", + "timestamp": 1536895342764, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py36h55f8cf0_0.conda": { + "build": "py36h55f8cf0_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.1 py36h74e8950_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "62e6328f3e61689bb00ceb5832868184", + "name": "numpy-devel", + "namespace": "python", + "sha256": "c881f938af8d0941fb9ee929fa012be8e1fb73ef9cdf26110ee3f5c563aa4226", + "size": 35272, + "subdir": "linux-64", + "timestamp": 1535389651379, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py36h6bdb83d_0.conda": { + "build": "py36h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.1 py36h81de0dd_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "0e43f027ffd953c4c192bc2348e23897", + "name": "numpy-devel", + "namespace": "python", + "sha256": "179b3d18dca36a18b9027f72d85100a7a6717c38e6e99edd212988c0381cc1b5", + "size": 35197, + "subdir": "linux-64", + "timestamp": 1535389913980, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py37h008b2eb_0.conda": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.1 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "3a840c4f65a4d491fbb41be97335f60b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "de28762443bbbab4c5f7f3aff088dbaf10271ca0bf2244665c29b071f129b7c0", + "size": 35376, + "subdir": "linux-64", + "timestamp": 1536895347153, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py37h55f8cf0_0.conda": { + "build": "py37h55f8cf0_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.15.1 py37h74e8950_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "93dd66a726d344d6abbbf2d48063dadb", + "name": "numpy-devel", + "namespace": "python", + "sha256": "41f0368a1258fe2a5b457b6d1603d92fc10787a19c6f0d219e652e3b391375bd", + "size": 35276, + "subdir": "linux-64", + "timestamp": 1535389651114, + "version": "1.15.1" + }, + "numpy-devel-1.15.1-py37h6bdb83d_0.conda": { + "build": "py37h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.1 py37h81de0dd_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "c54bd7d98e5349da4c78a5ed51729907", + "name": "numpy-devel", + "namespace": "python", + "sha256": "160d234795c3c8f4868933a2db0a4efc8f2b779fad45269cc07228a368e42345", + "size": 35212, + "subdir": "linux-64", + "timestamp": 1535389915731, + "version": "1.15.1" + }, + "numpy-devel-1.15.2-py27h008b2eb_0.conda": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "b0af31ff0417e7ef96f97344fa25dced", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ec9547b05c9129ea42e8c166a129b3cc37d6b2c9d229b398f5d3cab1d51c700c", + "size": 46020, + "subdir": "linux-64", + "timestamp": 1538073550365, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py27h008b2eb_1.conda": { + "build": "py27h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py27h2f8d375_1", + "python >=2.7,<2.8.0a0" + ], + "md5": "bea9d54aaabcfcfa2d956f0714855a0d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "bd092ad49c46b0766e1cb50c89f649463c0a26b1e1b08de664bf297dd3ddb806", + "size": 46676, + "subdir": "linux-64", + "timestamp": 1538500389581, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py27h6bdb83d_0.conda": { + "build": "py27h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.2 py27h81de0dd_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "88a13876e0fa5b750f40b8f1742d1e83", + "name": "numpy-devel", + "namespace": "python", + "sha256": "d5225df52f5661ed2c9ee742d5b7c6d4ac03f2d402c63b54a1d19290cb3005cd", + "size": 46118, + "subdir": "linux-64", + "timestamp": 1538073738872, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py27h6bdb83d_1.conda": { + "build": "py27h6bdb83d_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.2 py27h81de0dd_1", + "python >=2.7,<2.8.0a0" + ], + "md5": "ebf3e85a18dc4410d5cf5cdbaed82445", + "name": "numpy-devel", + "namespace": "python", + "sha256": "37c2aa37c3643cffb7c92b17643e4d10e06ffe56a54c695c7374c9763681032a", + "size": 46612, + "subdir": "linux-64", + "timestamp": 1538500437804, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py35h008b2eb_0.conda": { + "build": "py35h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py35h2f8d375_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "58b62240a659cf151866727de226a2fa", + "name": "numpy-devel", + "namespace": "python", + "sha256": "5eedbfd696a1ceb4c9abd129e1bb932f55b8f13acaad5034f0e911b4ca8a5a51", + "size": 46128, + "subdir": "linux-64", + "timestamp": 1538073990461, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py35h6bdb83d_0.conda": { + "build": "py35h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.2 py35h81de0dd_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "5476f3b54ca688776168e2a4c0df8e68", + "name": "numpy-devel", + "namespace": "python", + "sha256": "47a398461244dd5357356d09c7b2d3aba004120be9ebcb1c4ccbd9a91e48b37d", + "size": 46037, + "subdir": "linux-64", + "timestamp": 1538073749185, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py36h008b2eb_0.conda": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "155c7b9b2d54218a86270b47bc383009", + "name": "numpy-devel", + "namespace": "python", + "sha256": "4967f6b31460a70ff70cfee49d48822d8ba7505a42434224e2233fe00b664a3e", + "size": 46147, + "subdir": "linux-64", + "timestamp": 1538074267828, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py36h008b2eb_1.conda": { + "build": "py36h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py36h2f8d375_1", + "python >=3.6,<3.7.0a0" + ], + "md5": "c8260b8c00254b553a9bc713b5acbf3d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6c6ab97ea6c9a182d66ac5e8cf9368f1c76dd209e0f3f4cb1814a42f5324675e", + "size": 46660, + "subdir": "linux-64", + "timestamp": 1538500383705, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py36h6bdb83d_0.conda": { + "build": "py36h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.2 py36h81de0dd_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "bbbdcf0ad29f612f0a6c024cd2ebe74a", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e0aff15730bdb05fd5fb73be35dce3fec4f5555be93b27f86b5cea409a937953", + "size": 46125, + "subdir": "linux-64", + "timestamp": 1538074379474, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py36h6bdb83d_1.conda": { + "build": "py36h6bdb83d_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.2 py36h81de0dd_1", + "python >=3.6,<3.7.0a0" + ], + "md5": "a18b198d993214b3903e56619a73551d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "eff7be80f47e37c6496cc9548e79b126124a294f924203f46d6098a7c0d28408", + "size": 46603, + "subdir": "linux-64", + "timestamp": 1538500682431, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py37h008b2eb_0.conda": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "88097d63f201649a1661331434d154e0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ef849711f2570ccd69dbdc585d5b3cac9ed01fc990d74bb770fdf3b80091be9d", + "size": 46141, + "subdir": "linux-64", + "timestamp": 1538073478336, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py37h008b2eb_1.conda": { + "build": "py37h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.2 py37h2f8d375_1", + "python >=3.7,<3.8.0a0" + ], + "md5": "647574127cfdfe7cf5e7ac4208a3f071", + "name": "numpy-devel", + "namespace": "python", + "sha256": "cb9d3488dfc77f13e5b5aeb62772ef775ffcfc2253bad84de444007889e5774c", + "size": 46576, + "subdir": "linux-64", + "timestamp": 1538504556389, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py37h6bdb83d_0.conda": { + "build": "py37h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.2 py37h81de0dd_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "ead91ace1822c30968047076822c9fb3", + "name": "numpy-devel", + "namespace": "python", + "sha256": "bb3ef279c60a9ee7ef52573ce9cb9bb2de330a8fee4a5456fdecffdd0e3ba44b", + "size": 46117, + "subdir": "linux-64", + "timestamp": 1538073704389, + "version": "1.15.2" + }, + "numpy-devel-1.15.2-py37h6bdb83d_1.conda": { + "build": "py37h6bdb83d_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.2 py37h81de0dd_1", + "python >=3.7,<3.8.0a0" + ], + "md5": "085ae6ca4b763229fc2ecd27dbb587ec", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7d0ef7e458d7ec35c364288f86123e606bdc7c878ba7b8657650f794b10ea34f", + "size": 46604, + "subdir": "linux-64", + "timestamp": 1538504458472, + "version": "1.15.2" + }, + "numpy-devel-1.15.3-py27h008b2eb_0.conda": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.3 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "6f07fdcc9ee66b365b42c90e853e3739", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b868bd2328ed242775405d4b4a8f2509dedc3ee92332bab960aee445edacaef8", + "size": 33764, + "subdir": "linux-64", + "timestamp": 1540314073313, + "version": "1.15.3" + }, + "numpy-devel-1.15.3-py27h6bdb83d_0.conda": { + "build": "py27h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.3 py27h81de0dd_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "1bcd0ca25ed9914a81b208a6e87ae4c8", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2c0fe570d5a2338e2abfdd6c9de00ca6cf8e238dee649e22a9aa611830589ed9", + "size": 33695, + "subdir": "linux-64", + "timestamp": 1540314327322, + "version": "1.15.3" + }, + "numpy-devel-1.15.3-py36h008b2eb_0.conda": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.3 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "5b136e05c541614387be233a95eeeba0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "71de21eb598978533763cc484bcc1d4ad948de1de89bc1267ab5bf422bdf31f7", + "size": 33757, + "subdir": "linux-64", + "timestamp": 1540314091844, + "version": "1.15.3" + }, + "numpy-devel-1.15.3-py36h6bdb83d_0.conda": { + "build": "py36h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.3 py36h81de0dd_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "cf29170a7766a553d317349e66b0d0f0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e36e7d911e1f7e58433be935bb6b8f4f03179fdbee6836e23c98900fa2e1d5e7", + "size": 33701, + "subdir": "linux-64", + "timestamp": 1540314359646, + "version": "1.15.3" + }, + "numpy-devel-1.15.3-py37h008b2eb_0.conda": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.3 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "5b61bf24dc32cb929bd0040f99351089", + "name": "numpy-devel", + "namespace": "python", + "sha256": "64ba383b5cbd2079f8925aada77dc47d0056955ee146aef36a8d6bf32b46ca1f", + "size": 33752, + "subdir": "linux-64", + "timestamp": 1540314126462, + "version": "1.15.3" + }, + "numpy-devel-1.15.3-py37h6bdb83d_0.conda": { + "build": "py37h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.3 py37h81de0dd_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "b8ee7e99f0cfab4986bc130735d37c22", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f4e74b764f012363d05c35dcbbe68f33d4e4d4930615c8717e898a37a745343a", + "size": 33772, + "subdir": "linux-64", + "timestamp": 1540314576526, + "version": "1.15.3" + }, + "numpy-devel-1.15.4-py27h008b2eb_0.conda": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.4 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "c3bdf70eb893de61151a467431a17d01", + "name": "numpy-devel", + "namespace": "python", + "sha256": "70ef66b1a500c4e3547c9f1af483b902967857fc13afc14678820f33d00eb8a6", + "size": 33459, + "subdir": "linux-64", + "timestamp": 1541516724680, + "version": "1.15.4" + }, + "numpy-devel-1.15.4-py27h4ba5984_0.conda": { + "build": "py27h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.15.4 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "d9b0d2ece91088c80faf429241f4f0d0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "522c3cefe8c821156e8f0c9787c7d54e47c71256a7d1a1f7ac061b648d1add0a", + "size": 45200, + "subdir": "linux-64", + "timestamp": 1544718222254, + "version": "1.15.4" + }, + "numpy-devel-1.15.4-py27h6bdb83d_0.conda": { + "build": "py27h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.4 py27h81de0dd_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "ed975596095fdffeca0fdb23eb6f4034", + "name": "numpy-devel", + "namespace": "python", + "sha256": "fe92a375c69dd005046296cd21b8528fd013b4de82b3f2fe97f1cd7d07df21a3", + "size": 33461, + "subdir": "linux-64", + "timestamp": 1541517037044, + "version": "1.15.4" + }, + "numpy-devel-1.15.4-py36h008b2eb_0.conda": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.4 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "85cde747409687d0caef41316e39e3ad", + "name": "numpy-devel", + "namespace": "python", + "sha256": "edddd338c850c1b3317a0a48ef19bb9684a0c8637e8ef588acc65b37608204d1", + "size": 33516, + "subdir": "linux-64", + "timestamp": 1541516723265, + "version": "1.15.4" + }, + "numpy-devel-1.15.4-py36h4ba5984_0.conda": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.15.4 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "5e07479de4c89899419e8123cbeef31e", + "name": "numpy-devel", + "namespace": "python", + "sha256": "5e9acbed9d728ace75d2491f17fcb7b5ff78109abd4647688d2cfaed78c81d2b", + "size": 45189, + "subdir": "linux-64", + "timestamp": 1544718302154, + "version": "1.15.4" + }, + "numpy-devel-1.15.4-py36h6bdb83d_0.conda": { + "build": "py36h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.4 py36h81de0dd_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "5c86af5fd26cf0bc2e6eebad30056bee", + "name": "numpy-devel", + "namespace": "python", + "sha256": "32c3fea9a42b8d1942f26ca28c67db99c8b21393aa0067d46aa99b24043ce4f4", + "size": 33481, + "subdir": "linux-64", + "timestamp": 1541516989986, + "version": "1.15.4" + }, + "numpy-devel-1.15.4-py37h008b2eb_0.conda": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.15.4 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "368b61577cfe225c8760082b6befacd0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "34fddaddaea225eacdb8302407a30c71d5e5e87955c77ab252c82e8ee17b109c", + "size": 33447, + "subdir": "linux-64", + "timestamp": 1541516567198, + "version": "1.15.4" + }, + "numpy-devel-1.15.4-py37h4ba5984_0.conda": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.15.4 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "ef07f8a20f88e4e07d8b3912d43cba9e", + "name": "numpy-devel", + "namespace": "python", + "sha256": "71afb3198ace37c0a64029cb2abc11fce647f6bb871e88f015dcd2076d73126e", + "size": 45273, + "subdir": "linux-64", + "timestamp": 1544718456532, + "version": "1.15.4" + }, + "numpy-devel-1.15.4-py37h6bdb83d_0.conda": { + "build": "py37h6bdb83d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.15.4 py37h81de0dd_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "1f86a9a92374279d74f6bd9e502b3e54", + "name": "numpy-devel", + "namespace": "python", + "sha256": "877ea6f7d96db42d2ab6f5ef02381b9328d595caa4e1e306c9798c2a8b80bd38", + "size": 33534, + "subdir": "linux-64", + "timestamp": 1541516957166, + "version": "1.15.4" + }, + "numpy-devel-1.16.0-py27h008b2eb_0.conda": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "b834be9d155af3824b8572fb6f3e9aec", + "name": "numpy-devel", + "namespace": "python", + "sha256": "8e52958a1991ec22be60b2eea478e38b40eb25992919faf10ff4a86db1c6eab2", + "size": 46776, + "subdir": "linux-64", + "timestamp": 1551398002904, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py27h008b2eb_1.conda": { + "build": "py27h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py27h2f8d375_1", + "python >=2.7,<2.8.0a0" + ], + "md5": "5fed997b7c808d686ffeb39a71f51731", + "name": "numpy-devel", + "namespace": "python", + "sha256": "97d821ffb58505de9d4f6c6713c796b98d4aa74e26a67ec82ec3fbc13acd3c90", + "size": 47112, + "subdir": "linux-64", + "timestamp": 1551801743153, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py27h4ba5984_0.conda": { + "build": "py27h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.0 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "0264f444ebd65119ec1bf8a56d4691c3", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7221d3f75c970a8b92cdeecc1d8db6a4fa33903dcc61f007a5ee193ee5ad798f", + "size": 46823, + "subdir": "linux-64", + "timestamp": 1551398142543, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py27h4ba5984_1.conda": { + "build": "py27h4ba5984_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.0 py27hde5b4d6_1", + "python >=2.7,<2.8.0a0" + ], + "md5": "eb66705a577c526bf090f0709579b575", + "name": "numpy-devel", + "namespace": "python", + "sha256": "1278c10f313f0c7542a5985a93e77774fa4abb162edf0e7a2903da6cd288b989", + "size": 47199, + "subdir": "linux-64", + "timestamp": 1551802022127, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py36h008b2eb_0.conda": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "8fb41a2080a528086e2a20384c41f1fd", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ebea5aed64db5e9469b874cf785b927952cb75ab43faf21e033c2abba8478ce9", + "size": 46781, + "subdir": "linux-64", + "timestamp": 1551398086632, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py36h008b2eb_1.conda": { + "build": "py36h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py36h2f8d375_1", + "python >=3.6,<3.7.0a0" + ], + "md5": "2d099cebb9a072a98e34a325ec69af0f", + "name": "numpy-devel", + "namespace": "python", + "sha256": "abcd4378ec42106420f08a86aa933a998e2fed4390572f506bd1cf62d4285d47", + "size": 47108, + "subdir": "linux-64", + "timestamp": 1551801836857, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py36h4ba5984_0.conda": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.0 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "0c7714c6b4e32a295ec85623f1495294", + "name": "numpy-devel", + "namespace": "python", + "sha256": "332ff973d5d821a31d75a83c6934d306fd9fd685169a99675a36d1d8113f016c", + "size": 46828, + "subdir": "linux-64", + "timestamp": 1551398192914, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py36h4ba5984_1.conda": { + "build": "py36h4ba5984_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.0 py36hde5b4d6_1", + "python >=3.6,<3.7.0a0" + ], + "md5": "46069e3329ec613461787653227f796f", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2c343709e028c7afb1e278646cad88b9ea51cf016d65b9e453fca7b0a1a73e52", + "size": 47233, + "subdir": "linux-64", + "timestamp": 1551802064861, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py37h008b2eb_0.conda": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "9706bdcd7026d6625e12790d70321fa6", + "name": "numpy-devel", + "namespace": "python", + "sha256": "44f8c0bfe437ac4260fd275bdbfc046f4ca16cdbb7de7a628d13c0ffbf3dd456", + "size": 46770, + "subdir": "linux-64", + "timestamp": 1551398046106, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py37h008b2eb_1.conda": { + "build": "py37h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.0 py37h2f8d375_1", + "python >=3.7,<3.8.0a0" + ], + "md5": "eebff1a6b3ab63248b79e60760d6c293", + "name": "numpy-devel", + "namespace": "python", + "sha256": "51a37322e452f01492fe0d136ac58b3b0032bc0c2a5616e32e421f3788eb433e", + "size": 47122, + "subdir": "linux-64", + "timestamp": 1551801716065, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py37h4ba5984_0.conda": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.0 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "7b12b92ab6b7b33e4842c6372c0c6ada", + "name": "numpy-devel", + "namespace": "python", + "sha256": "15789df34e642df2d2152b69a836410fb24d3319a3ccad7bdfcde814535529ec", + "size": 46815, + "subdir": "linux-64", + "timestamp": 1551398061398, + "version": "1.16.0" + }, + "numpy-devel-1.16.0-py37h4ba5984_1.conda": { + "build": "py37h4ba5984_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.0 py37hde5b4d6_1", + "python >=3.7,<3.8.0a0" + ], + "md5": "2f2325d047d2b8198ec5e33ab68839d3", + "name": "numpy-devel", + "namespace": "python", + "sha256": "9f858d08fd8a2602f1b09b764f32b0517ef5af70a97776431ba6b058b465ac84", + "size": 47211, + "subdir": "linux-64", + "timestamp": 1551801917796, + "version": "1.16.0" + }, + "numpy-devel-1.16.1-py27h008b2eb_0.conda": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "4338cf27a7b7f8c15705f4e5cbd88045", + "name": "numpy-devel", + "namespace": "python", + "sha256": "56dcd32827764dbe28b998792fd570f72176e5801081903b34bd32a5ca869d6d", + "size": 46819, + "subdir": "linux-64", + "timestamp": 1551457083243, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py27h008b2eb_1.conda": { + "build": "py27h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py27h2f8d375_1", + "python >=2.7,<2.8.0a0" + ], + "md5": "e7ee3c87aeae2b63b236b64cb7e69326", + "name": "numpy-devel", + "namespace": "python", + "sha256": "fb3299c3d27592803944bcdf42244f047fdc4814634aa6c953282e800ce9bba6", + "size": 47161, + "subdir": "linux-64", + "timestamp": 1551468067453, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py27h4ba5984_0.conda": { + "build": "py27h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.1 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "6d507ff8a0d3644ccc08c324dd48b826", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7ffb290dcc900a70a03e5e8d720e5ab5ded3af4da249faccdb90283071a47a9e", + "size": 46864, + "subdir": "linux-64", + "timestamp": 1551457193824, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py27h4ba5984_1.conda": { + "build": "py27h4ba5984_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.1 py27hde5b4d6_1", + "python >=2.7,<2.8.0a0" + ], + "md5": "2042ef9eddf57f9891596e8e9713ef9a", + "name": "numpy-devel", + "namespace": "python", + "sha256": "4806b2aa4692a430d92b16dbd80e4e34d2f65f8b459185961854da47b0948d9a", + "size": 47265, + "subdir": "linux-64", + "timestamp": 1551468305901, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py36h008b2eb_0.conda": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "0de72242650a9f221167fa159244b5c0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f8f7d1324fbe0af8bcb1afe0b742add6a7da7d4dec1394edd9f1f40b1c811b45", + "size": 46874, + "subdir": "linux-64", + "timestamp": 1551457116150, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py36h008b2eb_1.conda": { + "build": "py36h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py36h2f8d375_1", + "python >=3.6,<3.7.0a0" + ], + "md5": "c607c93e8fd8fc779fafc8dd9d739e18", + "name": "numpy-devel", + "namespace": "python", + "sha256": "dd7e58a06838d5a4d343ea02846836fc4824046d3355e2daaaae08ee6a488cfc", + "size": 47160, + "subdir": "linux-64", + "timestamp": 1551468103681, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py36h4ba5984_0.conda": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.1 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "e75ce89a684a4b89b5daa2f03ce7cbe2", + "name": "numpy-devel", + "namespace": "python", + "sha256": "d2c7977c892093d66d73c65d1df74ce1efd7316ac77284d8851ada645deb33b9", + "size": 46851, + "subdir": "linux-64", + "timestamp": 1551457131637, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py36h4ba5984_1.conda": { + "build": "py36h4ba5984_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.1 py36hde5b4d6_1", + "python >=3.6,<3.7.0a0" + ], + "md5": "fe101ab76df1efe4cc9bb78b54b0200c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b1800a751a3e28ba66986e99cf843086c5afa7c0f8e81852de2ed2dfea7602b3", + "size": 47282, + "subdir": "linux-64", + "timestamp": 1551468252733, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py37h008b2eb_0.conda": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "d3c17cd7a636cb38cb20b3d414d20911", + "name": "numpy-devel", + "namespace": "python", + "sha256": "5a2fad6ddff6aaaef11fc1c1f1bcc78eddcb7d14fd767a6c9ec168bef22a4a57", + "size": 46822, + "subdir": "linux-64", + "timestamp": 1551457043809, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py37h008b2eb_1.conda": { + "build": "py37h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.1 py37h2f8d375_1", + "python >=3.7,<3.8.0a0" + ], + "md5": "9bc4ded8528c3391d6ab0102d508021d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7af02474a60e4216aa121681254d0607ffbf1508ace78ca4bc3ed22c8dd4a9c0", + "size": 47203, + "subdir": "linux-64", + "timestamp": 1551468101130, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py37h4ba5984_0.conda": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.1 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "6cd13a41cb27d143677c74a94619805c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "8521d649750a82e5f43d9066f5b9ca48f48294ffe6a931880616f110ed269aeb", + "size": 46842, + "subdir": "linux-64", + "timestamp": 1551457166349, + "version": "1.16.1" + }, + "numpy-devel-1.16.1-py37h4ba5984_1.conda": { + "build": "py37h4ba5984_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.1 py37hde5b4d6_1", + "python >=3.7,<3.8.0a0" + ], + "md5": "6fce1ce1fc77c55b6e67ab9e9f471c2f", + "name": "numpy-devel", + "namespace": "python", + "sha256": "333346e81835c74b1b1af9a1ca9e3f33288684e3860daec361c28e57f4e62fef", + "size": 47205, + "subdir": "linux-64", + "timestamp": 1551468140825, + "version": "1.16.1" + }, + "numpy-devel-1.16.2-py27h008b2eb_0.conda": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.2 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "a4c4d1b368c9c3f874f75c3095aa3ddd", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a3908fac9c33490478f492c955ba8047e344a685afc4dc18a18dce0e572c2608", + "size": 47357, + "subdir": "linux-64", + "timestamp": 1551471239371, + "version": "1.16.2" + }, + "numpy-devel-1.16.2-py27h4ba5984_0.conda": { + "build": "py27h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.2 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "5c44f1451431bfa75d366859395deb8b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "56db6a648a3ffe5a9e3258a14652aac1a618c50f9b1cf32dca2f2a28df577671", + "size": 47300, + "subdir": "linux-64", + "timestamp": 1551471399768, + "version": "1.16.2" + }, + "numpy-devel-1.16.2-py36h008b2eb_0.conda": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.2 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "d14d7c338e2d0a29e4374303fc909d0b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f637fe9d310c72adf3799c7330ddef79dd9325699ef4700dde56c07911803476", + "size": 47324, + "subdir": "linux-64", + "timestamp": 1551471227096, + "version": "1.16.2" + }, + "numpy-devel-1.16.2-py36h4ba5984_0.conda": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.2 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "4619f5679cd43baf09b92fb3873568bf", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b8f346dad63e26efdce6ebd1f843d1992405ad35ed06cda35c4baeb6e473e92e", + "size": 47306, + "subdir": "linux-64", + "timestamp": 1551471503420, + "version": "1.16.2" + }, + "numpy-devel-1.16.2-py37h008b2eb_0.conda": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.2 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "cabefde2b4a45a75ae2dbd91a0ad4a8b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "139169c35d22ef8ad922b4c47d99430d441283de817858eec72db54d11cbc51e", + "size": 47258, + "subdir": "linux-64", + "timestamp": 1551471210707, + "version": "1.16.2" + }, + "numpy-devel-1.16.2-py37h4ba5984_0.conda": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.1,<2021.0a0", + "numpy-base 1.16.2 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "5581339c7ff6dc8c819383abe5c79bc9", + "name": "numpy-devel", + "namespace": "python", + "sha256": "247e26dc1cf7d99c0299db45857090a953edc5e7b8158b782f206f093d9dd64e", + "size": 47384, + "subdir": "linux-64", + "timestamp": 1551471364436, + "version": "1.16.2" + }, + "numpy-devel-1.16.3-py27h008b2eb_0.conda": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.3 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "b48dcaf8cc5fab616ca175ea2294d90f", + "name": "numpy-devel", + "namespace": "python", + "sha256": "8b135bdae4527682e6dcf32f2e63f0e5dea3ce7d740fb75eed6219a6f23115b1", + "size": 47260, + "subdir": "linux-64", + "timestamp": 1555949438337, + "version": "1.16.3" + }, + "numpy-devel-1.16.3-py27h4ba5984_0.conda": { + "build": "py27h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.3,<2021.0a0", + "numpy-base 1.16.3 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "dc87f0a77723aa1e5daf47a9448d8dec", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e5c0fb2ba32be3e10162b03a84bc3232c4c0940a2833ab7103c74a0a8f843e15", + "size": 47280, + "subdir": "linux-64", + "timestamp": 1555949716242, + "version": "1.16.3" + }, + "numpy-devel-1.16.3-py36h008b2eb_0.conda": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.3 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "e505d8ad61312e26e1e63ba3dfd8c5ce", + "name": "numpy-devel", + "namespace": "python", + "sha256": "69b461e1055e2960dacad83eac8fa9d97f55663ad382c8cba24bac09ce03462e", + "size": 47276, + "subdir": "linux-64", + "timestamp": 1555949594576, + "version": "1.16.3" + }, + "numpy-devel-1.16.3-py36h4ba5984_0.conda": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.3,<2021.0a0", + "numpy-base 1.16.3 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "a6b328c88557c665aa7beef1ec7a3568", + "name": "numpy-devel", + "namespace": "python", + "sha256": "1b16033c1d08f36c4df10c89e2661882cde6bea68d0ca545aef2d4a191c47e27", + "size": 47251, + "subdir": "linux-64", + "timestamp": 1555949739677, + "version": "1.16.3" + }, + "numpy-devel-1.16.3-py37h008b2eb_0.conda": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.3 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "ba634143b843087a6e092e3204697506", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a4483019be13bbb257b826a1b24c2a90ad2e5bf5748f24c036cd1ac242b3ef27", + "size": 47194, + "subdir": "linux-64", + "timestamp": 1555949484170, + "version": "1.16.3" + }, + "numpy-devel-1.16.3-py37h4ba5984_0.conda": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.3,<2021.0a0", + "numpy-base 1.16.3 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "80e114136f21764b24425f420c4eab06", + "name": "numpy-devel", + "namespace": "python", + "sha256": "31282a42e348d0bb35d3c003c0f740b4746620b0ea681ab468f7de4ac058567a", + "size": 47296, + "subdir": "linux-64", + "timestamp": 1555949590636, + "version": "1.16.3" + }, + "numpy-devel-1.16.4-py27h008b2eb_0.conda": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.4 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "5d99775fd63fae4281c3e0aae86d5675", + "name": "numpy-devel", + "namespace": "python", + "sha256": "96ccd688601a7b3d60b0894d85e71b24d4576f579bc75c9ca650660b19fc8019", + "size": 47352, + "subdir": "linux-64", + "timestamp": 1559140319110, + "version": "1.16.4" + }, + "numpy-devel-1.16.4-py27h4ba5984_0.conda": { + "build": "py27h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.3,<2021.0a0", + "numpy-base 1.16.4 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "ea1d1913850ea9e243382404a30b7067", + "name": "numpy-devel", + "namespace": "python", + "sha256": "59e402605bff0cd17a32cf969f21c344d9f0663fbc14068a2f880917e7a175d7", + "size": 47409, + "subdir": "linux-64", + "timestamp": 1559140688832, + "version": "1.16.4" + }, + "numpy-devel-1.16.4-py36h008b2eb_0.conda": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.4 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "72af0580fd1e61bf7af7369285f899cc", + "name": "numpy-devel", + "namespace": "python", + "sha256": "3c627f77fe286f05736c019a0830034c2eecf34654b672969574b53e94fa7480", + "size": 47349, + "subdir": "linux-64", + "timestamp": 1559140322290, + "version": "1.16.4" + }, + "numpy-devel-1.16.4-py36h4ba5984_0.conda": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.3,<2021.0a0", + "numpy-base 1.16.4 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "5fe2e8a6866447830498041c2edb27df", + "name": "numpy-devel", + "namespace": "python", + "sha256": "227e499e9772657d29855d32550b3e0cef70a0314a3cee0da96d87c1bd440767", + "size": 47409, + "subdir": "linux-64", + "timestamp": 1559141052319, + "version": "1.16.4" + }, + "numpy-devel-1.16.4-py37h008b2eb_0.conda": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.4 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "9d1eff8ce53621a0129941092c711731", + "name": "numpy-devel", + "namespace": "python", + "sha256": "29b42d9a933d0a18b1b56ffbbc5adeb766ae434412824dbac4daca10e6a26a4e", + "size": 47331, + "subdir": "linux-64", + "timestamp": 1559140392135, + "version": "1.16.4" + }, + "numpy-devel-1.16.4-py37h4ba5984_0.conda": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.3,<2021.0a0", + "numpy-base 1.16.4 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "0b32c227f6f76fe1d375e51e03282206", + "name": "numpy-devel", + "namespace": "python", + "sha256": "5ec67b7dde9af93b377c4aef617c30fc49ee5b004df14a6de08a8216e1ca87b6", + "size": 47415, + "subdir": "linux-64", + "timestamp": 1559140464153, + "version": "1.16.4" + }, + "numpy-devel-1.16.5-py27h008b2eb_0.conda": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.5 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "f731b50eae2fc292386f18d76449804d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7ddf562224c840472bfc2ce2ebb03b96a6a731edd04a68ad4762337c93d81ff2", + "size": 47683, + "subdir": "linux-64", + "timestamp": 1568311501259, + "version": "1.16.5" + }, + "numpy-devel-1.16.5-py27h4ba5984_0.conda": { + "build": "py27h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.16.5 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "2e30b051064f650ac151e66d9a7b6345", + "name": "numpy-devel", + "namespace": "python", + "sha256": "1621aa280ac86518cd37170eb2146ba06048950f89c5c7a2d59c0358cf5e0d4d", + "size": 47690, + "subdir": "linux-64", + "timestamp": 1568311601186, + "version": "1.16.5" + }, + "numpy-devel-1.16.5-py36h008b2eb_0.conda": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.5 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "d2b08ffb1fedb07c1bc8ef728fdafa03", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7fd6164fbe4b2f77027f5f55fccde9a1c0ef43fd81740dc93b166b6eae144b79", + "size": 47686, + "subdir": "linux-64", + "timestamp": 1568311488779, + "version": "1.16.5" + }, + "numpy-devel-1.16.5-py36h4ba5984_0.conda": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.16.5 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "fdbffadfabd0b8342b2c1dca037a845b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "5f0bff1e0db9eb6783c5329bc7074b74aaaf2857d14dc85cbdeb7411d99a6114", + "size": 47689, + "subdir": "linux-64", + "timestamp": 1568311800208, + "version": "1.16.5" + }, + "numpy-devel-1.16.5-py37h008b2eb_0.conda": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.5 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "37fb8fa6d166fee7eb65922f734f56f1", + "name": "numpy-devel", + "namespace": "python", + "sha256": "c5c6135b6664fcf4edf6f306c805e11437fccdec02d15f0c8d183f6ca52ff72c", + "size": 47679, + "subdir": "linux-64", + "timestamp": 1568311600718, + "version": "1.16.5" + }, + "numpy-devel-1.16.5-py37h4ba5984_0.conda": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.16.5 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "ea96859b2cf3cb287f585fd0999de469", + "name": "numpy-devel", + "namespace": "python", + "sha256": "459f0fc0b14ec71e368a47287541135ef004a4c9bc8525ed635ba06fb24efb4c", + "size": 47689, + "subdir": "linux-64", + "timestamp": 1568311792686, + "version": "1.16.5" + }, + "numpy-devel-1.16.6-py27h008b2eb_0.conda": { + "build": "py27h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py27h2f8d375_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "c113b2c8053ad08d9b0eaff7edb42931", + "name": "numpy-devel", + "namespace": "python", + "sha256": "3c7fd37d80126063aa26f451991ba9f9258ff66807fab682ba4921b5e97b75e0", + "size": 47958, + "subdir": "linux-64", + "timestamp": 1580501506935, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py27h4ba5984_0.conda": { + "build": "py27h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.16.6 py27hde5b4d6_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "5a57b21bc819dfbfb9b15c87413344ea", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7546a64495e1883e3dd922a3b2753bf21ffe95bfbc8f500a5a7fcd4050c541c0", + "size": 47432, + "subdir": "linux-64", + "timestamp": 1580501613250, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py36h008b2eb_0.conda": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "c99e341e6d6a4311dadae58a647de3a0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "50e26d63c9754fb56c2847fa1ed18ddc6cd817453db63b4af797bbe3636b8e68", + "size": 47396, + "subdir": "linux-64", + "timestamp": 1580488233101, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py36h4ba5984_0.conda": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.16.6 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "549a0af8fefe6afe800aa26447763609", + "name": "numpy-devel", + "namespace": "python", + "sha256": "af31212a3febc0a0fe59f3376829dcaa4f38b8c09c22d8ab1c57a6cc18a80d0d", + "size": 47413, + "subdir": "linux-64", + "timestamp": 1580488470902, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py36hca8f349_3.conda": { + "build": "py36hca8f349_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py36h41b4c56_3", + "python >=3.6,<3.7.0a0" + ], + "md5": "48eadbcb2d75a1443ff484305287abd2", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f1d7d6ebccbf19d871e199c67cef80fa6137ae409bf2d1e5e23806267d226351", + "size": 48902, + "subdir": "linux-64", + "timestamp": 1618845026716, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py36hef7d012_3.conda": { + "build": "py36hef7d012_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base 1.16.6 py36hdc34a94_3", + "python >=3.6,<3.7.0a0" + ], + "md5": "29a1fd10a4b3ea4d6e5faff25b3b803c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f5c111f1b72660a282a9df772392346be486755fa5b37721ea452347b9aff283", + "size": 49490, + "subdir": "linux-64", + "timestamp": 1618845164367, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py37h008b2eb_0.conda": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "a7ef6c696912c18cd71bf790d9ccdb9c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2d5221c3347431f1684f80a9ebc013f72440274027d7be6c3f9cc5612dd630d9", + "size": 47510, + "subdir": "linux-64", + "timestamp": 1580488182345, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py37h4ba5984_0.conda": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.16.6 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "37fb2e75f2b5c10276dd6922a07ab650", + "name": "numpy-devel", + "namespace": "python", + "sha256": "15438f6676c605f11fb55a3b4e4c0b41dae4131d4a6a4c212e53a2737eea89f7", + "size": 47461, + "subdir": "linux-64", + "timestamp": 1580488381352, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py37hb168745_4.conda": { + "build": "py37hb168745_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.16.6 py37ha8aedfd_4", + "python >=3.7,<3.8.0a0" + ], + "md5": "774bf7fc1125c28aaadf4f647d30b608", + "name": "numpy-devel", + "namespace": "python", + "sha256": "11e7b9ef8523186cbad331222d29a8bbdf3019a94832105c8430105b88504311", + "size": 37668, + "subdir": "linux-64", + "timestamp": 1654863156474, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py37hca8f349_3.conda": { + "build": "py37hca8f349_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py37h41b4c56_3", + "python >=3.7,<3.8.0a0" + ], + "md5": "033833ee766ef1cb5b075fdd8093a40e", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6485602b928b309eb0b1aa9e08246ca8fb8332465d2476729edc56f3135e63c2", + "size": 49241, + "subdir": "linux-64", + "timestamp": 1618844457521, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py37hef7d012_3.conda": { + "build": "py37hef7d012_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base 1.16.6 py37hdc34a94_3", + "python >=3.7,<3.8.0a0" + ], + "md5": "32dbf8f215f031c613950e5c63ec630d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a078d9e1ac9dff4ad324079d3d82781898d9d7b40e7f1a3db439e42bb074053c", + "size": 49346, + "subdir": "linux-64", + "timestamp": 1618845176561, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py37hef7d012_4.conda": { + "build": "py37hef7d012_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base 1.16.6 py37h73d599e_4", + "python >=3.7,<3.8.0a0" + ], + "md5": "5e8f2b3f3cbbc0c289fa9338a852e711", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b50e64b35bc54ec73eae065d884c82d5cef39b4cf76123cefdd490aa803d65f3", + "size": 37736, + "subdir": "linux-64", + "timestamp": 1654863894954, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py38h008b2eb_0.conda": { + "build": "py38h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py38h2f8d375_0", + "python >=3.8,<3.9.0a0" + ], + "md5": "dbd90c22ef6a92a20cd5699a5abcd04b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "590e2e32b2ec20495aa82b209752c34bea93a287dba17913a557bc490f2b2c7f", + "size": 47829, + "subdir": "linux-64", + "timestamp": 1580495292888, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py38h4ba5984_0.conda": { + "build": "py38h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.16.6 py38hde5b4d6_0", + "python >=3.8,<3.9.0a0" + ], + "md5": "5c079621b149b2ce6e41211c6b599990", + "name": "numpy-devel", + "namespace": "python", + "sha256": "8842cdea297da411885408154c9269b63b7280d8a71487d76a5f04208a1e8609", + "size": 47830, + "subdir": "linux-64", + "timestamp": 1580495332862, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py38hb168745_4.conda": { + "build": "py38hb168745_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.16.6 py38ha8aedfd_4", + "python >=3.8,<3.9.0a0" + ], + "md5": "4d296636202eb976bdc26c1c4bb44830", + "name": "numpy-devel", + "namespace": "python", + "sha256": "1433743fd6e492b6f897bd56d0b6372a93d16669c51a7eca910c982defaf1b50", + "size": 37668, + "subdir": "linux-64", + "timestamp": 1654863593275, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py38hca8f349_3.conda": { + "build": "py38hca8f349_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py38h41b4c56_3", + "python >=3.8,<3.9.0a0" + ], + "md5": "72681331f2b68e5f937ba8b18cbcc0ce", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0d410246f646dcb6eaa46017643d2b4260c542d291819926491b095e7e30fd82", + "size": 49623, + "subdir": "linux-64", + "timestamp": 1618841703439, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py38hef7d012_3.conda": { + "build": "py38hef7d012_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base 1.16.6 py38hdc34a94_3", + "python >=3.8,<3.9.0a0" + ], + "md5": "c69ac7e8400f337c8e9e1f8a954df566", + "name": "numpy-devel", + "namespace": "python", + "sha256": "4beb3858aadd27de39fe61439a793a3523a1fc151b55f731dfe3d90d6b61c6f9", + "size": 49389, + "subdir": "linux-64", + "timestamp": 1618845166412, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py38hef7d012_4.conda": { + "build": "py38hef7d012_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base 1.16.6 py38h73d599e_4", + "python >=3.8,<3.9.0a0" + ], + "md5": "54b19fbdebdb772ef6a8aafef4014fda", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ae3c1f218dc7c2a92969bdd646ddda5c0da9ad0d7d10b818ce72e079ba4c8645", + "size": 37728, + "subdir": "linux-64", + "timestamp": 1654864522495, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py39h1fb7909_1.conda": { + "build": "py39h1fb7909_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.16.6 py39h76555f2_1", + "python >=3.9,<3.10.0a0" + ], + "md5": "131b8b870882c231abb51ab05b900e04", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7d64c0abb742d9949bb5249521d7e673d37ef69e579427475b118883baaaa5af", + "size": 47754, + "subdir": "linux-64", + "timestamp": 1607432385091, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py39hb168745_4.conda": { + "build": "py39hb168745_4", + "build_number": 4, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.20,<1.0a0", + "numpy-base 1.16.6 py39ha8aedfd_4", + "python >=3.9,<3.10.0a0" + ], + "md5": "9fc1af6c5ffd6d964ffbf9b009783b97", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7cbf06bc6abb861cc67f4c37ff01224c9580e32c4e909b6722ce1bdc80387691", + "size": 37682, + "subdir": "linux-64", + "timestamp": 1654863375783, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py39hca8f349_1.conda": { + "build": "py39hca8f349_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py39hfb011de_1", + "python >=3.9,<3.10.0a0" + ], + "md5": "fc29833eb1a14c8e018c46f0d79acd46", + "name": "numpy-devel", + "namespace": "python", + "sha256": "402969319ef5e19a784b8830b8922d8b6598a29d1e90a6454dcbb09ac7b551f4", + "size": 47472, + "subdir": "linux-64", + "timestamp": 1607432259550, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py39hca8f349_3.conda": { + "build": "py39hca8f349_3", + "build_number": 3, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.16.6 py39h41b4c56_3", + "python >=3.9,<3.10.0a0" + ], + "md5": "e3da6df695c12cfb2cbad0318a187c6f", + "name": "numpy-devel", + "namespace": "python", + "sha256": "405e4e32a1f81293d559b07a0bc02c02b45f2822a76e6f61a8bad2c618b8af95", + "size": 49467, + "subdir": "linux-64", + "timestamp": 1618841702080, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py39hef7d012_3.conda": { + "build": "py39hef7d012_3", + "build_number": 3, + "depends": [ + "blas 1.0 mkl", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base 1.16.6 py39hdc34a94_3", + "python >=3.9,<3.10.0a0" + ], + "md5": "1af83eb43b32a4480b1a3c0f03296a01", + "name": "numpy-devel", + "namespace": "python", + "sha256": "4990ebb6167def79a889222ec41fcdf0523611237eccbb7f1fdf176e775244a7", + "size": 49596, + "subdir": "linux-64", + "timestamp": 1618845166738, + "version": "1.16.6" + }, + "numpy-devel-1.16.6-py39hef7d012_4.conda": { + "build": "py39hef7d012_4", + "build_number": 4, + "depends": [ + "blas 1.0 mkl", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy-base 1.16.6 py39h73d599e_4", + "python >=3.9,<3.10.0a0" + ], + "md5": "5d34c11899f27b84af9b0d54e47c4acd", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e4edfe7623e3659bae72567c7f84bb3cef4bab703965fd306edfbe49d28d54bb", + "size": 37720, + "subdir": "linux-64", + "timestamp": 1654864205468, + "version": "1.16.6" + }, + "numpy-devel-1.17.2-py36h008b2eb_0.conda": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.2 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ffc37eec7eeecb9348e59d37aeae7910", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f57bb7442a441d113a8eb2bb40cb3a18860b857b1a117ee4438507da8ffde3b0", + "size": 58013, + "subdir": "linux-64", + "timestamp": 1569435368309, + "version": "1.17.2" + }, + "numpy-devel-1.17.2-py36h4ba5984_0.conda": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.17.2 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e89e8fab05d26af991492aed3f7e6280", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b22e86d783f5d5c6cdbbd6d33c0177781fd9a28837de75d490bc4b55bf043b44", + "size": 57792, + "subdir": "linux-64", + "timestamp": 1569435649401, + "version": "1.17.2" + }, + "numpy-devel-1.17.2-py37h008b2eb_0.conda": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.2 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "018b10fe9e69a2d93ddac19cf55466c8", + "name": "numpy-devel", + "namespace": "python", + "sha256": "591af32ccf5e03e7f2e2e1e4e39d7e32bab3d991c2daf58078c7f18e69e25aee", + "size": 57583, + "subdir": "linux-64", + "timestamp": 1569435402742, + "version": "1.17.2" + }, + "numpy-devel-1.17.2-py37h4ba5984_0.conda": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.17.2 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8e325dc4e0b934481958461712ce06fa", + "name": "numpy-devel", + "namespace": "python", + "sha256": "dcf1e8d4488985988748f7f7fef2fe31d97416b319f575031c1451987a320cf4", + "size": 58143, + "subdir": "linux-64", + "timestamp": 1569435647774, + "version": "1.17.2" + }, + "numpy-devel-1.17.3-py36h008b2eb_0.conda": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.3 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e91b7f958fa97ae16ceee25b5aca2486", + "name": "numpy-devel", + "namespace": "python", + "sha256": "830fc5b3ab48fce86f1e0ea937d1c187a6c6ce4d18e39945919c9a5f8776ffbc", + "size": 58331, + "subdir": "linux-64", + "timestamp": 1573063161087, + "version": "1.17.3" + }, + "numpy-devel-1.17.3-py36h4ba5984_0.conda": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.17.3 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "367f6a06da539b645b7ab363d09ec70d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "3d6ac299f090c5c9cbc511465440b599c5bc3405d0e8c34c19c8e81d23d9fd6e", + "size": 58388, + "subdir": "linux-64", + "timestamp": 1573063153731, + "version": "1.17.3" + }, + "numpy-devel-1.17.3-py37h008b2eb_0.conda": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.3 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "47acfc8e67d66fe9d4d151f91aa85d30", + "name": "numpy-devel", + "namespace": "python", + "sha256": "2fa0cbe7d5b68a7c36e47b1647aba016936bad226e5e84b5bd8757c0e733090b", + "size": 58334, + "subdir": "linux-64", + "timestamp": 1573063231145, + "version": "1.17.3" + }, + "numpy-devel-1.17.3-py37h4ba5984_0.conda": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.17.3 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "55959dbfa6f109ba1417585f41b2735e", + "name": "numpy-devel", + "namespace": "python", + "sha256": "cbb4cfa4dc992f75364e0e842d615c2859082f0d13da7063152ca74cf02d5f70", + "size": 58330, + "subdir": "linux-64", + "timestamp": 1573063301158, + "version": "1.17.3" + }, + "numpy-devel-1.17.3-py38h008b2eb_0.conda": { + "build": "py38h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.3 py38h2f8d375_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "023235633fc33b75b56f63bc5e0f5cb2", + "name": "numpy-devel", + "namespace": "python", + "sha256": "13f267d522c40554429bf5b6b38961024604945f930b1442a416bdd2beebfe57", + "size": 58272, + "subdir": "linux-64", + "timestamp": 1573063169423, + "version": "1.17.3" + }, + "numpy-devel-1.17.3-py38h4ba5984_0.conda": { + "build": "py38h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.17.3 py38hde5b4d6_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "aef5beec17dbb32dddf6b607bf7a9508", + "name": "numpy-devel", + "namespace": "python", + "sha256": "30a24f4c7215c3536edee18b9a41bcf8dcc519d8a86d9a42ce03c62625a72e45", + "size": 45907, + "subdir": "linux-64", + "timestamp": 1573121189454, + "version": "1.17.3" + }, + "numpy-devel-1.17.4-py36h008b2eb_0.conda": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.4 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2efecc8f3f4756b28c556c447d137855", + "name": "numpy-devel", + "namespace": "python", + "sha256": "11ced0ba205f50e95439293cc64293a6e360652077f4a8330f398c3acf77a42b", + "size": 58444, + "subdir": "linux-64", + "timestamp": 1574868344842, + "version": "1.17.4" + }, + "numpy-devel-1.17.4-py36h4ba5984_0.conda": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.17.4 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9d66bf15dc54ed5f6c6f55a0d0408372", + "name": "numpy-devel", + "namespace": "python", + "sha256": "8f0c6f2feda11152a37e499420597fef0d890c5ee0901b91cd906e6929ed3357", + "size": 58647, + "subdir": "linux-64", + "timestamp": 1574868434946, + "version": "1.17.4" + }, + "numpy-devel-1.17.4-py37h008b2eb_0.conda": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.4 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4a49c1e0e6bbd23f559af62e434565a9", + "name": "numpy-devel", + "namespace": "python", + "sha256": "4220c5b3b25973ab9d44d85f3dba7a4cfda39bef5c3d02fc9a419cb3d850bf3a", + "size": 57859, + "subdir": "linux-64", + "timestamp": 1574868360917, + "version": "1.17.4" + }, + "numpy-devel-1.17.4-py37h4ba5984_0.conda": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.17.4 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2e994ed7da315e60a3c048e362f2123a", + "name": "numpy-devel", + "namespace": "python", + "sha256": "71e368362a19b1332c883c66f0a47a7166066432c4b881cfc9aa3b31c4fe302c", + "size": 58556, + "subdir": "linux-64", + "timestamp": 1574868421644, + "version": "1.17.4" + }, + "numpy-devel-1.17.4-py38h008b2eb_0.conda": { + "build": "py38h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.17.4 py38h2f8d375_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "57bff024a92d1ed901d4ad9869d0c2f5", + "name": "numpy-devel", + "namespace": "python", + "sha256": "69840ecf45c4bd8b1816933dd6f1ca0f70e582312f242cf855579e0e84df59b8", + "size": 58428, + "subdir": "linux-64", + "timestamp": 1574868339517, + "version": "1.17.4" + }, + "numpy-devel-1.17.4-py38h4ba5984_0.conda": { + "build": "py38h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.17.4 py38hde5b4d6_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "215bb9c9e75a577733ec0951c05d2165", + "name": "numpy-devel", + "namespace": "python", + "sha256": "ec3323129de23538928c799a1ec6fc146fd200ddd2c32fac068376f0696b247d", + "size": 58575, + "subdir": "linux-64", + "timestamp": 1574868405061, + "version": "1.17.4" + }, + "numpy-devel-1.18.1-py36h008b2eb_0.conda": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.1 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2d958f6c41d5d85db93f89e90414b18c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e11d0dbfaf23074cc8a8c6deee8ca5ad88c4818f90530f35ab29e92e431f0dc0", + "size": 27888, + "subdir": "linux-64", + "timestamp": 1579191419891, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py36h008b2eb_1.conda": { + "build": "py36h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.1 py36h2f8d375_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d3ec604a071d51aea39faede2b580b2c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "c6b1cfbbc3df771a7ad5449b391850443dacc36e7fd49efa2bd48a6ee4b629fb", + "size": 26850, + "subdir": "linux-64", + "timestamp": 1579712662623, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py36h4ba5984_0.conda": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.18.1 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7b0fc3fc920d6ddce21d6e7f73681654", + "name": "numpy-devel", + "namespace": "python", + "sha256": "a06c7b3e9e06257aa1675031308eccc54e2a3a3659c2119709fd8ed0b03b9696", + "size": 27829, + "subdir": "linux-64", + "timestamp": 1579191445797, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py36h4ba5984_1.conda": { + "build": "py36h4ba5984_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.18.1 py36hde5b4d6_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0e9726fa3345dcd6058fb87c2fee2459", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7a0083b9c9c2f50d7a794f504bb5ddabbc6ddf44b3763eecebc32fdf52e673dd", + "size": 26945, + "subdir": "linux-64", + "timestamp": 1579712576660, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py37h008b2eb_0.conda": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.1 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d64d8cbd7cdd4ac4c6198514245c36f7", + "name": "numpy-devel", + "namespace": "python", + "sha256": "7c8f47cd01d59792b5444b296e1eed83387905c46a93e3bf58a5e903e5463e4d", + "size": 27742, + "subdir": "linux-64", + "timestamp": 1579191529246, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py37h008b2eb_1.conda": { + "build": "py37h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.1 py37h2f8d375_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "55c286a0444ae72f13e5a6a10acfd09d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "03543c23afcd53da86686557a49114d95c0f0e990ded0503770c4ca61b0fb4db", + "size": 26964, + "subdir": "linux-64", + "timestamp": 1579712556772, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py37h4ba5984_0.conda": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.18.1 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "282f593c5d8e4cef4339ffcbe7fc3de5", + "name": "numpy-devel", + "namespace": "python", + "sha256": "904b73182197ad7e0bbc9f69e4c2d810113cfd2df6bac2f4b555529ceb7e468f", + "size": 27879, + "subdir": "linux-64", + "timestamp": 1579191546774, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py37h4ba5984_1.conda": { + "build": "py37h4ba5984_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.18.1 py37hde5b4d6_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "78cf9192001f29f3a8379f33c3c84efe", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b8aa4e07e81f644a3b5b65e2f5679e7ec118302e27b82351eab9d55fbd1ab2d3", + "size": 26807, + "subdir": "linux-64", + "timestamp": 1579712536462, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py38h008b2eb_0.conda": { + "build": "py38h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.1 py38h2f8d375_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a79c2a573c973f941849aac0d99d4ede", + "name": "numpy-devel", + "namespace": "python", + "sha256": "37290899e2310d7be4e3d91b8eeb4823b1084630e559c431109fd8eb95a74faa", + "size": 27886, + "subdir": "linux-64", + "timestamp": 1579191543385, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py38h008b2eb_1.conda": { + "build": "py38h008b2eb_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.1 py38h2f8d375_1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2af3b126dc33e741e652160ab1fba427", + "name": "numpy-devel", + "namespace": "python", + "sha256": "45f4b5c32f7f10070dc30e8b3e05498790561c53746c03406acd5443251671f6", + "size": 26931, + "subdir": "linux-64", + "timestamp": 1579712588357, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py38h4ba5984_0.conda": { + "build": "py38h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.18.1 py38hde5b4d6_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "13966ebd6df34a09a1eed86ebfd407e8", + "name": "numpy-devel", + "namespace": "python", + "sha256": "550c639881bf4e6a43b009745ad1c203e29d37437202346ba68bb34ed8ffc837", + "size": 27815, + "subdir": "linux-64", + "timestamp": 1579191458810, + "version": "1.18.1" + }, + "numpy-devel-1.18.1-py38h4ba5984_1.conda": { + "build": "py38h4ba5984_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.18.1 py38hde5b4d6_1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "02df3b61e6857440440dc338be0927b1", + "name": "numpy-devel", + "namespace": "python", + "sha256": "b3d1dd2e22e26682e184c1a308c1edd40c30cec7fc82a2aead5627b8077005ca", + "size": 26981, + "subdir": "linux-64", + "timestamp": 1579712599872, + "version": "1.18.1" + }, + "numpy-devel-1.18.5-py36h008b2eb_0.conda": { + "build": "py36h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.5 py36h2f8d375_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "73d26f9b21a3ac7a08ff019fd3675173", + "name": "numpy-devel", + "namespace": "python", + "sha256": "245b1c0d6d3ca66294d3f9a6756fe1b33b180c4da79d3e6307fa53f3af5b2033", + "size": 27029, + "subdir": "linux-64", + "timestamp": 1592509320518, + "version": "1.18.5" + }, + "numpy-devel-1.18.5-py36h4ba5984_0.conda": { + "build": "py36h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.18.5 py36hde5b4d6_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2515b2914e77e3d3dc9e240ae16e35b5", + "name": "numpy-devel", + "namespace": "python", + "sha256": "81d9dd82714f4263572f943d80306c39cd2bcdad419b28f28f28f77b1ef5f6bc", + "size": 27067, + "subdir": "linux-64", + "timestamp": 1592509304550, + "version": "1.18.5" + }, + "numpy-devel-1.18.5-py37h008b2eb_0.conda": { + "build": "py37h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.5 py37h2f8d375_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "54318c113dff053b73171d87e1d524f1", + "name": "numpy-devel", + "namespace": "python", + "sha256": "bf2c13e9b6f4651a9db8cada8a0e1bbaec8b22271126baf0f1307ea2428017da", + "size": 26935, + "subdir": "linux-64", + "timestamp": 1592509276589, + "version": "1.18.5" + }, + "numpy-devel-1.18.5-py37h4ba5984_0.conda": { + "build": "py37h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.18.5 py37hde5b4d6_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7039c66e08c8c30fc4d505089c8eb5a2", + "name": "numpy-devel", + "namespace": "python", + "sha256": "02374e1334bc2d24d0a8357c8e56a90474ac8fc42e165b76c6701e4a1c5ce8f4", + "size": 26944, + "subdir": "linux-64", + "timestamp": 1592509320019, + "version": "1.18.5" + }, + "numpy-devel-1.18.5-py38h008b2eb_0.conda": { + "build": "py38h008b2eb_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libopenblas >=0.3.3,<1.0a0", + "numpy-base 1.18.5 py38h2f8d375_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "43f40563b6e9343c224023b97b1358e0", + "name": "numpy-devel", + "namespace": "python", + "sha256": "1b6ddb7af7d200d50b8a4486c32d57fb8cba48edb96c00bb2220f49d93a26431", + "size": 26976, + "subdir": "linux-64", + "timestamp": 1592509314017, + "version": "1.18.5" + }, + "numpy-devel-1.18.5-py38h4ba5984_0.conda": { + "build": "py38h4ba5984_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy-base 1.18.5 py38hde5b4d6_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "907a1cc58a44b49ee1385e4b040bf5ad", + "name": "numpy-devel", + "namespace": "python", + "sha256": "3e2fc7608a65ba17b42b631b97fc95e4d8747df722068d42afbc7f2aa6ba0051", + "size": 26970, + "subdir": "linux-64", + "timestamp": 1592509325986, + "version": "1.18.5" + }, + "numpy-devel-1.9.3-py27h025eb46_6.conda": { + "build": "py27h025eb46_6", + "build_number": 6, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.9.3 py27h2b20989_6", + "python >=2.7,<2.8.0a0" + ], + "md5": "ecd34d0c6470e8571ba3f4c653ca01c7", + "name": "numpy-devel", + "namespace": "python", + "sha256": "180eebf7ff8fee4e22650aa14eb88731850c867009a951705d8723663268830a", + "size": 9133, + "subdir": "linux-64", + "timestamp": 1530380225388, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py27h025eb46_7.conda": { + "build": "py27h025eb46_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.9.3 py27h2b20989_7", + "python >=2.7,<2.8.0a0" + ], + "md5": "2cecb203d5c2babd8c81c31eb5cf7803", + "name": "numpy-devel", + "namespace": "python", + "sha256": "52807ffcd8b10bca7c3dd027ccef8c64a111a20de2bea6782ba1e790aaa45fa2", + "size": 9136, + "subdir": "linux-64", + "timestamp": 1530550418712, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py27h8f55a68_7.conda": { + "build": "py27h8f55a68_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.9.3 py27hc937464_7", + "python >=2.7,<2.8.0a0" + ], + "md5": "637f2556ec3e1726da3050d9fb5509ec", + "name": "numpy-devel", + "namespace": "python", + "sha256": "4f9c2610a3e65d520b5c61e2950c23c8f0088ed94cec3681f7c540d5e3bdf1a0", + "size": 8768, + "subdir": "linux-64", + "timestamp": 1534773452166, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py27h99ba2d1_7.conda": { + "build": "py27h99ba2d1_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py27h1793315_7", + "python >=2.7,<2.8.0a0" + ], + "md5": "04fa1ab365961a0455887cf9710c0a6c", + "name": "numpy-devel", + "namespace": "python", + "sha256": "04c6e156cec2dea30b0e4569cd6c8fbdc578b943eff4f98ec37fa1f2d1d99d1c", + "size": 8763, + "subdir": "linux-64", + "timestamp": 1534512672825, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py27ha22f7c6_6.conda": { + "build": "py27ha22f7c6_6", + "build_number": 6, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py27hdbf6ddf_6", + "python >=2.7,<2.8.0a0" + ], + "md5": "cecba232e4d81d456ed02abc8d6d42e5", + "name": "numpy-devel", + "namespace": "python", + "sha256": "eeabe86841ba8543c374401a1e631b9d2ffa120f9a44baf18c7250867512e1dd", + "size": 9069, + "subdir": "linux-64", + "timestamp": 1530383301717, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py27ha22f7c6_7.conda": { + "build": "py27ha22f7c6_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py27hdbf6ddf_7", + "python >=2.7,<2.8.0a0" + ], + "md5": "26d59c46f5a9c046824e46a4c1485b8a", + "name": "numpy-devel", + "namespace": "python", + "sha256": "0ee5b6457fe8199cc16b8fe870324a37bf5bbeaa1887faa5c3bc9ac425d22cf9", + "size": 9148, + "subdir": "linux-64", + "timestamp": 1530553218467, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py35h025eb46_7.conda": { + "build": "py35h025eb46_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.9.3 py35h2b20989_7", + "python >=3.5,<3.6.0a0" + ], + "md5": "0d6222ad816946a68a3461a80b97cf80", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f929d16f391b0f0fc498df449ed89f69a5cf504b121e47d3167dc887663e20f7", + "size": 9181, + "subdir": "linux-64", + "timestamp": 1530694276368, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py35h8f55a68_7.conda": { + "build": "py35h8f55a68_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.9.3 py35hc937464_7", + "python >=3.5,<3.6.0a0" + ], + "md5": "81596e63d5b3cf192c2a27312e4ccff1", + "name": "numpy-devel", + "namespace": "python", + "sha256": "11469e4703e04d36e5a346a7ba9acf9f65779224bf34ab4fc9456f75339b7300", + "size": 8771, + "subdir": "linux-64", + "timestamp": 1534773229138, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py35h99ba2d1_7.conda": { + "build": "py35h99ba2d1_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py35h1793315_7", + "python >=3.5,<3.6.0a0" + ], + "md5": "eb9f2bc128e172ff71f79a9a7e3ee176", + "name": "numpy-devel", + "namespace": "python", + "sha256": "8894291e048a428a47f70a5748528d6046adaeb9b0aaf58235be708cdcb25966", + "size": 8725, + "subdir": "linux-64", + "timestamp": 1534772987108, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py35ha22f7c6_7.conda": { + "build": "py35ha22f7c6_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py35hdbf6ddf_7", + "python >=3.5,<3.6.0a0" + ], + "md5": "7cc7e19cbb9f09f2497d5dc8772045be", + "name": "numpy-devel", + "namespace": "python", + "sha256": "4dd5fc3a88416e0b63f0b0e025a65876283c2870ca63afe94319a0ffcd700214", + "size": 9163, + "subdir": "linux-64", + "timestamp": 1530694468713, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py36h025eb46_6.conda": { + "build": "py36h025eb46_6", + "build_number": 6, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.9.3 py36h2b20989_6", + "python >=3.6,<3.7.0a0" + ], + "md5": "6a43baf697604bcc3e669b13f81718c5", + "name": "numpy-devel", + "namespace": "python", + "sha256": "fa569d210991e9e1fa787720224077a4cb19d407ca68edcd1a1b0eb51306e49c", + "size": 9059, + "subdir": "linux-64", + "timestamp": 1530380885972, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py36h025eb46_7.conda": { + "build": "py36h025eb46_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.9.3 py36h2b20989_7", + "python >=3.6,<3.7.0a0" + ], + "md5": "ea3de92706eed4551ede4bef622a1402", + "name": "numpy-devel", + "namespace": "python", + "sha256": "6354c963aece979136658f37da8480f038480a9013ef6aa1b172b7c17adba2d3", + "size": 9152, + "subdir": "linux-64", + "timestamp": 1530550449566, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py36h8f55a68_7.conda": { + "build": "py36h8f55a68_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.9.3 py36hc937464_7", + "python >=3.6,<3.7.0a0" + ], + "md5": "2b95b01963c4e0b4b78801e8e7ff989d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "83ed387636bce3d658f4aab0bf2185308d4d8de319e23fcaa5f1a3c722e8ab66", + "size": 8725, + "subdir": "linux-64", + "timestamp": 1534773913606, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py36h99ba2d1_7.conda": { + "build": "py36h99ba2d1_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py36h1793315_7", + "python >=3.6,<3.7.0a0" + ], + "md5": "83a929e7a21902918d57ae5261221f72", + "name": "numpy-devel", + "namespace": "python", + "sha256": "62724cde9aef24410e7068fab66c18c38d1bb602f8c5d20ec52b62278de2c141", + "size": 8715, + "subdir": "linux-64", + "timestamp": 1534773682547, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py36ha22f7c6_6.conda": { + "build": "py36ha22f7c6_6", + "build_number": 6, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py36hdbf6ddf_6", + "python >=3.6,<3.7.0a0" + ], + "md5": "8f7679b0e449ca831f32cc8c5515f646", + "name": "numpy-devel", + "namespace": "python", + "sha256": "f1f9d8cadc25d0ca7d7f816749a34c028da7325afbc050ef142477631b0d4145", + "size": 9037, + "subdir": "linux-64", + "timestamp": 1530383451195, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py36ha22f7c6_7.conda": { + "build": "py36ha22f7c6_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py36hdbf6ddf_7", + "python >=3.6,<3.7.0a0" + ], + "md5": "d8c770fd423f9c95ba96599fde8848f6", + "name": "numpy-devel", + "namespace": "python", + "sha256": "59326376cf3c8ca886a965c240ddf221a656566c7e9deae7219852eefc8d4e16", + "size": 9122, + "subdir": "linux-64", + "timestamp": 1530553689513, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py37h025eb46_6.conda": { + "build": "py37h025eb46_6", + "build_number": 6, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.9.3 py37h2b20989_6", + "python >=3.7,<3.8.0a0" + ], + "md5": "1026241afa80c5314a19695fb059a22b", + "name": "numpy-devel", + "namespace": "python", + "sha256": "084e221902cf98816c578f20014ebce532875718bb2b680f16711b9482dfac74", + "size": 9057, + "subdir": "linux-64", + "timestamp": 1530381454006, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py37h025eb46_7.conda": { + "build": "py37h025eb46_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "numpy-base 1.9.3 py37h2b20989_7", + "python >=3.7,<3.8.0a0" + ], + "md5": "a09cec56cd929d80c6510b34e24d8c4d", + "name": "numpy-devel", + "namespace": "python", + "sha256": "cd947b8d84309465af60f82a2ddff8d05c839dc0f797fd185405abb61bcffafc", + "size": 9175, + "subdir": "linux-64", + "timestamp": 1530550936698, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py37h8f55a68_7.conda": { + "build": "py37h8f55a68_7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "numpy-base 1.9.3 py37hc937464_7", + "python >=3.7,<3.8.0a0" + ], + "md5": "c51cc7c2a28886f5a9820dc03de71cd8", + "name": "numpy-devel", + "namespace": "python", + "sha256": "467d7898ba9b53c9d82818329c040004dfeb791e9ae1d30c8b30545c1e55fbe1", + "size": 8731, + "subdir": "linux-64", + "timestamp": 1534774383503, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py37h99ba2d1_7.conda": { + "build": "py37h99ba2d1_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py37h1793315_7", + "python >=3.7,<3.8.0a0" + ], + "md5": "23b57066ae14869b845a50e50d6e7a72", + "name": "numpy-devel", + "namespace": "python", + "sha256": "872a0f52ff5a3fc62e19147cc2555acbce8472bf7fbf81818bee751c7b38cae8", + "size": 8722, + "subdir": "linux-64", + "timestamp": 1534774147168, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py37ha22f7c6_6.conda": { + "build": "py37ha22f7c6_6", + "build_number": 6, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py37hdbf6ddf_6", + "python >=3.7,<3.8.0a0" + ], + "md5": "ba785ffd38560c3cb55ffde838320fc4", + "name": "numpy-devel", + "namespace": "python", + "sha256": "e054e62935e3e12e884bb9f52887a1058349e303e4364b51ebd5e510da1a1201", + "size": 9043, + "subdir": "linux-64", + "timestamp": 1530382696081, + "version": "1.9.3" + }, + "numpy-devel-1.9.3-py37ha22f7c6_7.conda": { + "build": "py37ha22f7c6_7", + "build_number": 7, + "depends": [ + "blas 1.0 mkl", + "mkl >=2018.0.3,<2019.0a0", + "numpy-base 1.9.3 py37hdbf6ddf_7", + "python >=3.7,<3.8.0a0" + ], + "md5": "8811f4f349e90ab914db4935a1315236", + "name": "numpy-devel", + "namespace": "python", + "sha256": "bdf2721a2f84a5f1f65e4a3cc432df0eeb52ea77e7352b569000fccd2788de66", + "size": 9173, + "subdir": "linux-64", + "timestamp": 1530553809592, + "version": "1.9.3" + }, + "numpydoc-0.7.0-py27h9647a75_0.conda": { + "build": "py27h9647a75_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "sphinx" + ], + "license": "BSD 3-Clause", + "md5": "3f232ab79d4f80d825eb6b5b16073290", + "name": "numpydoc", + "sha256": "6eec7567f4b0bea4bf41c84a05fd69f2324a4f1e40165cf26cd44e4f170c4bcf", + "size": 38610, + "subdir": "linux-64", + "timestamp": 1505747054545, + "version": "0.7.0" + }, + "numpydoc-0.7.0-py35he089a57_0.conda": { + "build": "py35he089a57_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "sphinx" + ], + "license": "BSD 3-Clause", + "md5": "b27a4b384d524747b6d6b21a388c09c3", + "name": "numpydoc", + "sha256": "3c3e94666d17ba047ea47dfa80cc40c04372fbd5e74fd6feb632659d4d1a1773", + "size": 39493, + "subdir": "linux-64", + "timestamp": 1505747068085, + "version": "0.7.0" + }, + "numpydoc-0.7.0-py36h18f165f_0.conda": { + "build": "py36h18f165f_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "sphinx" + ], + "license": "BSD 3-Clause", + "md5": "6aeb076e01e74fb915c59f1ee8baeaee", + "name": "numpydoc", + "sha256": "8c295b44af077912c42304545dbf6b73e85d486a7433e33affa9e5a4e5bcf403", + "size": 38805, + "subdir": "linux-64", + "timestamp": 1505747082188, + "version": "0.7.0" + }, + "numpydoc-0.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "sphinx" + ], + "license": "BSD 3-Clause", + "md5": "2ed546df63c2828e966566a7b9aab3e7", + "name": "numpydoc", + "sha256": "c8f8d2a1725546ebde8948fcb0409cd99ebecd4e00ac7f1e5f8b8b6c8c5430d5", + "size": 42686, + "subdir": "linux-64", + "timestamp": 1522687461487, + "version": "0.8.0" + }, + "numpydoc-0.8.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "sphinx" + ], + "license": "BSD 3-Clause", + "md5": "21e4297c16e59d6a52fcd32ea74ebbd4", + "name": "numpydoc", + "sha256": "36889ac212e7243e5d8bdce02333f7784d8fcbce08f2c636954827a12d5822a3", + "size": 43763, + "subdir": "linux-64", + "timestamp": 1522687396508, + "version": "0.8.0" + }, + "numpydoc-0.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "sphinx" + ], + "license": "BSD 3-Clause", + "md5": "6c78488b7d876d9ab0e3328c4ec4e5e0", + "name": "numpydoc", + "sha256": "c7aa23fee6f029bc451f94dbe268f0ce5dbf94048e29bcd2b1ff0944b2424776", + "size": 43252, + "subdir": "linux-64", + "timestamp": 1522687467693, + "version": "0.8.0" + }, + "numpydoc-0.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "sphinx" + ], + "license": "BSD 3-Clause", + "md5": "7f8b30d6e38bb29ec3b5a3a2ac32439e", + "name": "numpydoc", + "sha256": "d23f60ff464d6ab2a753a2eed6657ff90792e02b5515ad80ba8012af2a105fe0", + "size": 43110, + "subdir": "linux-64", + "timestamp": 1530733649694, + "version": "0.8.0" + }, + "numpydoc-1.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.10", + "python >=3.10,<3.11.0a0", + "sphinx >=3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3ea014022e6ef54e70e51f89401301f9", + "name": "numpydoc", + "sha256": "3cd60cc6806f5ea527d09f4383a1a4550cd878520f1975dbd4ce1f139d83df08", + "size": 88734, + "subdir": "linux-64", + "timestamp": 1657530012299, + "version": "1.4.0" + }, + "numpydoc-1.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.10", + "python >=3.7,<3.8.0a0", + "sphinx >=3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b0dfa145372c0cfe35c274bd8718b8e5", + "name": "numpydoc", + "sha256": "0d004bd124c3632033f5be3bbf23dc84d7fdffd0d6a17e424bf5c48bc54d6d43", + "size": 87094, + "subdir": "linux-64", + "timestamp": 1657529967568, + "version": "1.4.0" + }, + "numpydoc-1.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.10", + "python >=3.8,<3.9.0a0", + "sphinx >=3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "28d198a0ccd4deca32155da3eaecbfc7", + "name": "numpydoc", + "sha256": "17f8140cf87a015fd3543460508f5ccb0e670b4fb0896d8e1f460cffc9b9df8f", + "size": 87443, + "subdir": "linux-64", + "timestamp": 1657529901922, + "version": "1.4.0" + }, + "numpydoc-1.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.10", + "python >=3.9,<3.10.0a0", + "sphinx >=3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "779115139e991adc2cba80ce1e04b93b", + "name": "numpydoc", + "sha256": "0d3010ccbf2830f07ab7bb718a4cec299fa4d9c3557136617d10097d367b308c", + "size": 87302, + "subdir": "linux-64", + "timestamp": 1657529935769, + "version": "1.4.0" + }, + "numpydoc-1.5.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.10", + "python >=3.10,<3.11.0a0", + "sphinx >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f8e05440828adcfde29b2606195b53c", + "name": "numpydoc", + "sha256": "31f2c82fd033725925483f9deb3ad14af4cc1ddc966d91bb4d2a07c0d2559fdf", + "size": 93748, + "subdir": "linux-64", + "timestamp": 1668085935282, + "version": "1.5.0" + }, + "numpydoc-1.5.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.10", + "python >=3.11,<3.12.0a0", + "sphinx >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1cb0a2dba4c02a5fec085e925ee187e4", + "name": "numpydoc", + "sha256": "5f3336391e77905aa1d8520029f0cab9be5c7776d2c985c561512f23b547b122", + "size": 116148, + "subdir": "linux-64", + "timestamp": 1676845068929, + "version": "1.5.0" + }, + "numpydoc-1.5.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.10", + "python >=3.7,<3.8.0a0", + "sphinx >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f61e61ad702778a72497b9a553b3a1d0", + "name": "numpydoc", + "sha256": "e9598c1ab6bfee2caf6bb6d834994d233bc0dde94d75e13ac31daf5d30099ff7", + "size": 92101, + "subdir": "linux-64", + "timestamp": 1668085964369, + "version": "1.5.0" + }, + "numpydoc-1.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.10", + "python >=3.8,<3.9.0a0", + "sphinx >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ebf96b73cbab6632089b15bd6a2a9835", + "name": "numpydoc", + "sha256": "b85928d32e6ad7c251d6c7ddbde6abd8b3fc7c93e519fba95718b05c062ae3de", + "size": 92333, + "subdir": "linux-64", + "timestamp": 1668086021357, + "version": "1.5.0" + }, + "numpydoc-1.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.10", + "python >=3.9,<3.10.0a0", + "sphinx >=4.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d73167c39bda9a80837574805277d693", + "name": "numpydoc", + "sha256": "3990b65499caa97baa307e37b8f37484750eef630b3f8994894c2f4ed8b31559", + "size": 92174, + "subdir": "linux-64", + "timestamp": 1668085993171, + "version": "1.5.0" + }, + "nvcc_linux-64-10.0-h91b26fc_10.conda": { + "build": "h91b26fc_10", + "build_number": 10, + "depends": [], + "license": "BSD-3-Clause", + "md5": "91c316296f3a55a9c2ca029174c2bd42", + "name": "nvcc_linux-64", + "sha256": "0027f4095dd44d6902dcf36f88dfb21780c007820abd5fc2476f589b8af61ec2", + "size": 11102, + "subdir": "linux-64", + "timestamp": 1610053422395, + "version": "10.0" + }, + "nvcc_linux-64-10.1-hcaf9a05_10.conda": { + "build": "hcaf9a05_10", + "build_number": 10, + "depends": [], + "license": "BSD-3-Clause", + "md5": "0f32711e520414f3c8d0fa6e90d0b161", + "name": "nvcc_linux-64", + "sha256": "eece64ef397fc9e1566eb1340576d1a795dadd49bac430e398447b36b6ddcb7c", + "size": 11072, + "subdir": "linux-64", + "timestamp": 1610061017161, + "version": "10.1" + }, + "nvcc_linux-64-9.2-heaad284_10.conda": { + "build": "heaad284_10", + "build_number": 10, + "depends": [], + "license": "BSD-3-Clause", + "md5": "281c279ef7fca58d9627cf6462e21814", + "name": "nvcc_linux-64", + "sha256": "1f9d4e405d9232049c0565168f5f417a3bc5eab062f6c0ee1826abea1cad3a2a", + "size": 11080, + "subdir": "linux-64", + "timestamp": 1610039234021, + "version": "9.2" + }, + "oauthenticator-15.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema", + "jupyterhub >=1.2", + "python >=3.10,<3.11.0a0", + "requests", + "ruamel.yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bbe214420f71ada8123f4d1fb759e629", + "name": "oauthenticator", + "sha256": "f6662ed7c4415f823c8a91a47b7b59d10c50223e386515cede3d9d3fd7ff2f26", + "size": 95561, + "subdir": "linux-64", + "timestamp": 1663706821453, + "version": "15.1.0" + }, + "oauthenticator-15.1.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema", + "jupyterhub >=1.2", + "python >=3.11,<3.12.0a0", + "requests", + "ruamel.yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3970e07b7442ace471873d718abd807a", + "name": "oauthenticator", + "sha256": "7e00b6b51daf4a2aa8ebe495e94a209317a2ae55ce02a52169d0b1fdfadad235", + "size": 122229, + "subdir": "linux-64", + "timestamp": 1679340122399, + "version": "15.1.0" + }, + "oauthenticator-15.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema", + "jupyterhub >=1.2", + "python >=3.7,<3.8.0a0", + "requests", + "ruamel.yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "371017c66503ec6ed7fcbefcadd5fc2e", + "name": "oauthenticator", + "sha256": "6af7f10200873e482880b9bd9964e6c31648b96b0dd77c9c4be5ff6b0afec82c", + "size": 94187, + "subdir": "linux-64", + "timestamp": 1663706776707, + "version": "15.1.0" + }, + "oauthenticator-15.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema", + "jupyterhub >=1.2", + "python >=3.8,<3.9.0a0", + "requests", + "ruamel.yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f5203c3a602b7a9bc94bc758f419c443", + "name": "oauthenticator", + "sha256": "95701f2eccf393203e7d045136cfee845dc075da69b860d57f9c8538cdba0d4b", + "size": 94992, + "subdir": "linux-64", + "timestamp": 1663706710659, + "version": "15.1.0" + }, + "oauthenticator-15.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema", + "jupyterhub >=1.2", + "python >=3.9,<3.10.0a0", + "requests", + "ruamel.yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "97079c32ff4e9f87238ab124f8c53b51", + "name": "oauthenticator", + "sha256": "8cc46c65dbaea12b634e262d5526451526079b4911b8ff18323cd2a92c074d94", + "size": 94855, + "subdir": "linux-64", + "timestamp": 1663706744667, + "version": "15.1.0" + }, + "oauthlib-2.0.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3904949532a9f65212f85fd54752f149", + "name": "oauthlib", + "sha256": "fb74c910f18e18af1f23db9af950b9053d300eaa290a6b62ad088d4845df248c", + "size": 121244, + "subdir": "linux-64", + "timestamp": 1525813349005, + "version": "2.0.7" + }, + "oauthlib-2.0.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "68b1445d7cfd00ad5d33956943620646", + "name": "oauthlib", + "sha256": "00815760ab82c47a0a6e67a3fa693a81dea83f3314710b6dbb4a7aabe7b97a44", + "size": 125091, + "subdir": "linux-64", + "timestamp": 1525813627940, + "version": "2.0.7" + }, + "oauthlib-2.0.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "44bb91037824b644d9877b15e31d4514", + "name": "oauthlib", + "sha256": "306df9f318ac5286aff72f7de449cca9f353a9491455952b89ce30f7c900a0bc", + "size": 124221, + "subdir": "linux-64", + "timestamp": 1525813627094, + "version": "2.0.7" + }, + "oauthlib-2.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f144f09103c1266ce07f9f779e8ca95a", + "name": "oauthlib", + "sha256": "51c9048a7a23ba0faa2c351952c1d14d79c25cd55b7783f73e5cd3ca1207279c", + "size": 123112, + "subdir": "linux-64", + "timestamp": 1527855962685, + "version": "2.1.0" + }, + "oauthlib-2.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e87a0e218b6225e93cae245d6cc57c69", + "name": "oauthlib", + "sha256": "bed74906f78e90329f193f1f13435bec94d13c22a9739b9d5b5d6c60c8cda1b3", + "size": 125173, + "subdir": "linux-64", + "timestamp": 1527855887913, + "version": "2.1.0" + }, + "oauthlib-2.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "100f990571f19064ea9f5b58df03786c", + "name": "oauthlib", + "sha256": "32f074272ece9372ab2598e30695df0dd0814840f27eb3a0127a1ff4c5c71714", + "size": 122066, + "subdir": "linux-64", + "timestamp": 1527855926813, + "version": "2.1.0" + }, + "oauthlib-2.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8cbe7047c3faf1a20427e4170db7e0d1", + "name": "oauthlib", + "sha256": "22156c78e09ff7d6eeb24df9f7169a4c3c47fc025bc462bd3dad4ad0f86d0bd9", + "size": 124718, + "subdir": "linux-64", + "timestamp": 1545089218274, + "version": "2.1.0" + }, + "oauthlib-3.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6ac590f32b9585cfb67560ac7a9f8f00", + "name": "oauthlib", + "sha256": "e20b0fca77d09fae4ac9f945b5b88d25bd53834cbeadbb5ccbb33fe6c6808515", + "size": 145390, + "subdir": "linux-64", + "timestamp": 1547792451516, + "version": "3.0.0" + }, + "oauthlib-3.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d479268e44fee0e4722a1af5c8ee4386", + "name": "oauthlib", + "sha256": "0a94517c80aedf6a1211bb84ebab62d1b81ca24e0fd557c7abc94d8fc970edb9", + "size": 144661, + "subdir": "linux-64", + "timestamp": 1547791686191, + "version": "3.0.0" + }, + "oauthlib-3.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "blinker", + "cryptography", + "pyjwt >=1.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d5f8536b703b348d714953249f41b37d", + "name": "oauthlib", + "sha256": "98d2bb24b0b507b3f9806d186de0c2cd2dabe241af99ea73286fdace30038a1f", + "size": 144203, + "subdir": "linux-64", + "timestamp": 1547791732682, + "version": "3.0.0" + }, + "oauthlib-3.2.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "blinker >=1.4.0", + "cryptography >=3.0.0", + "pyjwt >=2.0.0,<3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bf5947216eada5efde09c59c90b6be0c", + "name": "oauthlib", + "sha256": "88684ba3e4917f6d78fe5351d5883a89010f38829a9766ac0563b551e4fa8a8f", + "size": 199503, + "subdir": "linux-64", + "timestamp": 1665490956937, + "version": "3.2.1" + }, + "oauthlib-3.2.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "blinker >=1.4.0", + "cryptography >=3.0.0", + "pyjwt >=2.0.0,<3", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "016524efa629c2a474d3fcd76781891b", + "name": "oauthlib", + "sha256": "c5d88f5dcbb2f6e03ea69aa30279d8f4e63c6b9b51a4562077bdf1500b70ab2c", + "size": 238125, + "subdir": "linux-64", + "timestamp": 1676841382173, + "version": "3.2.1" + }, + "oauthlib-3.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "blinker >=1.4.0", + "cryptography >=3.0.0", + "pyjwt >=2.0.0,<3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1996283ddecdb6b5413624936d40cf99", + "name": "oauthlib", + "sha256": "d0699e49d5be4b981eda55652943488387107f29bc6ab7c9e65e363290342ccc", + "size": 197478, + "subdir": "linux-64", + "timestamp": 1665490985773, + "version": "3.2.1" + }, + "oauthlib-3.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "blinker >=1.4.0", + "cryptography >=3.0.0", + "pyjwt >=2.0.0,<3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4fc48028c0860be6e054948a72e51d99", + "name": "oauthlib", + "sha256": "22dc0fdbbbfd851a8117a3c3dfc9f235bbc9619c579072e6d832c06ecd8ebf69", + "size": 197924, + "subdir": "linux-64", + "timestamp": 1665490926140, + "version": "3.2.1" + }, + "oauthlib-3.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "blinker >=1.4.0", + "cryptography >=3.0.0", + "pyjwt >=2.0.0,<3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aed0923d873af51403d0836ef5250b67", + "name": "oauthlib", + "sha256": "10ab2ab6531c14c9ad13039063f30a6597f3ed9d2ee45a1d756eb25fd5976209", + "size": 197700, + "subdir": "linux-64", + "timestamp": 1665491013966, + "version": "3.2.1" + }, + "oauthlib-3.2.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "blinker >=1.4.0", + "cryptography >=3.0.0", + "pyjwt >=2.0.0,<3", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "01673b4bf828f62d49f4629f973128e4", + "name": "oauthlib", + "sha256": "2b935874441bd4022aeab6df9509ccfa0bf4e1bbb525d21aeea97ee5564f0104", + "size": 215256, + "subdir": "linux-64", + "timestamp": 1679489651614, + "version": "3.2.2" + }, + "oauthlib-3.2.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "blinker >=1.4.0", + "cryptography >=3.0.0", + "pyjwt >=2.0.0,<3", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2163b705ea623a4861c18f71e5703d1c", + "name": "oauthlib", + "sha256": "5d0381b85aee27b5b6bc786dff78828541dc0f5df9f95dc31bc7ba449dddee64", + "size": 251225, + "subdir": "linux-64", + "timestamp": 1679489741805, + "version": "3.2.2" + }, + "oauthlib-3.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "blinker >=1.4.0", + "cryptography >=3.0.0", + "pyjwt >=2.0.0,<3", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2e56a8dbe7fc6ec05f03f32114bc6a06", + "name": "oauthlib", + "sha256": "caaf661a424ff154aec5c447581bfbdbf3c6bb9528c2faea2328639cadcd0489", + "size": 214453, + "subdir": "linux-64", + "timestamp": 1679489680671, + "version": "3.2.2" + }, + "oauthlib-3.2.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "blinker >=1.4.0", + "cryptography >=3.0.0", + "pyjwt >=2.0.0,<3", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "160feed3948fccc13c6c33066b479ac7", + "name": "oauthlib", + "sha256": "0403ef2610fd8bd0785c9ad99d698bb234e7c7ef0763f848144cf2f463149174", + "size": 213845, + "subdir": "linux-64", + "timestamp": 1679489711205, + "version": "3.2.2" + }, + "objconv-2.49-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "51352f7df3bb064f7a138fa246ca1350", + "name": "objconv", + "sha256": "eeec1ebac06abe3fa8bf6dbbb49fbcf971e39878212e0f6bb4dc437bcd8433a6", + "size": 264132, + "subdir": "linux-64", + "timestamp": 1588116287087, + "version": "2.49" + }, + "odo-0.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "dask >=0.11.1", + "datashape >=0.5.0", + "multipledispatch >=0.4.7", + "networkx >=1.0", + "numpy >=1.7", + "pandas >=0.15.0", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c08f0e0964f2f8a2b2c544cfc6ea8c89", + "name": "odo", + "sha256": "a241fa057d2bfcb33c88401cb76bb93dcbc7ae678050843b505275804acaac32", + "size": 211600, + "subdir": "linux-64", + "timestamp": 1530780038362, + "version": "0.5.1" + }, + "odo-0.5.1-py27h9170de3_0.conda": { + "build": "py27h9170de3_0", + "build_number": 0, + "depends": [ + "dask >=0.11.1", + "datashape >=0.5.0", + "multipledispatch >=0.4.7", + "networkx >=1.0", + "numpy >=1.7", + "pandas >=0.15.0", + "python >=2.7,<2.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "15c95c1da157465ee51b2beda7112f8c", + "name": "odo", + "sha256": "e575681b49947dc60cca3f2dbe1a3db153727143647ffc5bc1201cfbe9e1da23", + "size": 209160, + "subdir": "linux-64", + "timestamp": 1505740114297, + "version": "0.5.1" + }, + "odo-0.5.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dask >=0.11.1", + "datashape >=0.5.0", + "multipledispatch >=0.4.7", + "networkx >=1.0", + "numpy >=1.7", + "pandas >=0.15.0", + "python >=3.10,<3.11.0a0", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d18c5a473fafd76480911099369dd7f8", + "name": "odo", + "sha256": "8cfa14133f3be59c3dadd05daaaf171a2e78a3ba58dff4f55852e0db1b148816", + "size": 217190, + "subdir": "linux-64", + "timestamp": 1640812588751, + "version": "0.5.1" + }, + "odo-0.5.1-py35h102315f_0.conda": { + "build": "py35h102315f_0", + "build_number": 0, + "depends": [ + "dask >=0.11.1", + "datashape >=0.5.0", + "multipledispatch >=0.4.7", + "networkx >=1.0", + "numpy >=1.7", + "pandas >=0.15.0", + "python >=3.5,<3.6.0a0", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a9030e94c6f24ef3f965d1de69c6e613", + "name": "odo", + "sha256": "9117cd6181b7ab6c384504bef3e3e093b6f753c3322473ba7bc10b9920d0c8f0", + "size": 214472, + "subdir": "linux-64", + "timestamp": 1505740135679, + "version": "0.5.1" + }, + "odo-0.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "dask >=0.11.1", + "datashape >=0.5.0", + "multipledispatch >=0.4.7", + "networkx >=1.0", + "numpy >=1.7", + "pandas >=0.15.0", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "752fc51d079f75d7890e502560f5e914", + "name": "odo", + "sha256": "d8598e1bbb575e8c690d348f7429d27ea47249d00beea8ba434471778a2ed647", + "size": 211977, + "subdir": "linux-64", + "timestamp": 1530780075033, + "version": "0.5.1" + }, + "odo-0.5.1-py36h90ed295_0.conda": { + "build": "py36h90ed295_0", + "build_number": 0, + "depends": [ + "dask >=0.11.1", + "datashape >=0.5.0", + "multipledispatch >=0.4.7", + "networkx >=1.0", + "numpy >=1.7", + "pandas >=0.15.0", + "python >=3.6,<3.7.0a0", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9eec20578cd6725632a1e367d09fd111", + "name": "odo", + "sha256": "9cc380b68f2e020b54d636c31e1987d53b1af06cee8fde4b0590f3fd18ae348a", + "size": 209977, + "subdir": "linux-64", + "timestamp": 1505740157583, + "version": "0.5.1" + }, + "odo-0.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "dask >=0.11.1", + "datashape >=0.5.0", + "multipledispatch >=0.4.7", + "networkx >=1.0", + "numpy >=1.7", + "pandas >=0.15.0", + "python >=3.7,<3.8.0a0", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "00c5bbcea47453e424c6c8ac0293c3b7", + "name": "odo", + "sha256": "7e04769cb8caa6f3eefc7d5fd3f14046a5867d7cbee7b064ee387ac462fe0bb6", + "size": 209943, + "subdir": "linux-64", + "timestamp": 1530780006978, + "version": "0.5.1" + }, + "odo-0.5.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "dask >=0.11.1", + "datashape >=0.5.0", + "multipledispatch >=0.4.7", + "networkx >=1.0", + "numpy >=1.7", + "pandas >=0.15.0", + "python >=3.8,<3.9.0a0", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a3241dfd683ddf3ef56ae9b8d20ac1c2", + "name": "odo", + "sha256": "535a296ff130a6631767b8eba576dce18dfa648e70ff22ffb244a9ca9f6da435", + "size": 213907, + "subdir": "linux-64", + "timestamp": 1574235835534, + "version": "0.5.1" + }, + "olefile-0.44-py27h4bd3e3c_0.conda": { + "build": "py27h4bd3e3c_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License 2-Clause", + "license_family": "BSD", + "md5": "14259e24962f31c55dccf1382bc2c93e", + "name": "olefile", + "sha256": "73aee4c26ba627bcbf9c70409d950aee6197fff57c027eb117b8729e9db3ab94", + "size": 54094, + "subdir": "linux-64", + "timestamp": 1505744401417, + "version": "0.44" + }, + "olefile-0.44-py35h2c86149_0.conda": { + "build": "py35h2c86149_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD License 2-Clause", + "license_family": "BSD", + "md5": "67d9a4a6d24ba627700d93460b443146", + "name": "olefile", + "sha256": "0c773c657b5db1608410e60c745dc9d0fe39d506205169f2dca26008ee453b38", + "size": 53275, + "subdir": "linux-64", + "timestamp": 1505744413921, + "version": "0.44" + }, + "olefile-0.44-py36h79f9f78_0.conda": { + "build": "py36h79f9f78_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License 2-Clause", + "license_family": "BSD", + "md5": "55498b83854301bfbffb61ef7e705b10", + "name": "olefile", + "sha256": "74f7b1ce03f4235ddb06db117c1474f095fbb7fdc92091c351b8bcfe2ce85e1b", + "size": 54071, + "subdir": "linux-64", + "timestamp": 1505744426115, + "version": "0.44" + }, + "olefile-0.45.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD License 2-Clause", + "license_family": "BSD", + "md5": "8cb94b767d93411a4bdb48981ae3fc9d", + "name": "olefile", + "sha256": "d67732ce55e0dac701eac6cd90b08110978ad1cfa9ee9d07dc173b19d92531b7", + "size": 48914, + "subdir": "linux-64", + "timestamp": 1517331222763, + "version": "0.45.1" + }, + "olefile-0.45.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD License 2-Clause", + "license_family": "BSD", + "md5": "458b2deccc11d35e6ab7c3076e4f9828", + "name": "olefile", + "sha256": "4977cefc76921decb7c1cea727cc8b4f7268d246484c39d29a34377baf2a27d1", + "size": 48935, + "subdir": "linux-64", + "timestamp": 1517331233527, + "version": "0.45.1" + }, + "olefile-0.45.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD License 2-Clause", + "license_family": "BSD", + "md5": "8ac3a440755a2b147d48e49dcb43f686", + "name": "olefile", + "sha256": "546cf74676c558c45b531ac446ee711f76475989f81938c57f5e8b188a686c80", + "size": 49577, + "subdir": "linux-64", + "timestamp": 1517331239303, + "version": "0.45.1" + }, + "olefile-0.45.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD License 2-Clause", + "license_family": "BSD", + "md5": "8d544bd0938504b62a337c46f65c43e9", + "name": "olefile", + "sha256": "c7c686fb5860f6ffc9b13cbac3c9168d4893b80de2e367de737535e5d11c7dea", + "size": 48580, + "subdir": "linux-64", + "timestamp": 1530792989148, + "version": "0.45.1" + }, + "olefile-0.46-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "017ba724a7ea40b5a94aa56c774bf7eb", + "name": "olefile", + "sha256": "b38fc45a450c5b25679b31bf4b8ac71139fad9c536df975fee681a2ccad14c37", + "size": 49873, + "subdir": "linux-64", + "timestamp": 1536697159606, + "version": "0.46" + }, + "olefile-0.46-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7763c62458916733c5a75e0ea4199229", + "name": "olefile", + "sha256": "ae0229016ebb8da9338c835ee2efc7192baef469ba024184877e1176a6afe3ec", + "size": 51124, + "subdir": "linux-64", + "timestamp": 1536697215244, + "version": "0.46" + }, + "olefile-0.46-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8c386abf0c35116af89ca062daa44097", + "name": "olefile", + "sha256": "c171b2056fbc1b3912ef222642da07327e01a4fad3c8ead7af5049136646ffd4", + "size": 49507, + "subdir": "linux-64", + "timestamp": 1536697214297, + "version": "0.46" + }, + "olefile-0.46-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9a0c0faad20393a813e10c731325eadf", + "name": "olefile", + "sha256": "5fc9fea1b28873f503e5fbb5d12b3aa37a93d13a0919e1f268e196d2676d7c2c", + "size": 50707, + "subdir": "linux-64", + "timestamp": 1536697142672, + "version": "0.46" + }, + "omniscidb-5.6.2-h2b6add4_0_cpu.conda": { + "build": "h2b6add4_0_cpu", + "build_number": 0, + "depends": [ + "arrow-cpp >=2.0.0,<2.0.1.0a0", + "blosc >=1.21.0,<2.0a0", + "boost-cpp >=1.73.0,<1.73.1.0a0", + "bzip2", + "double-conversion", + "gxx_linux-64", + "libarchive >=3.4.2,<3.5.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libclang-cpp <12", + "libgcc-ng >=8.4.0", + "libgdal >=3.0.2,<3.1.0a0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "librdkafka >=1.6.0,<1.7.0a0", + "libstdcxx-ng >=8.4.0", + "libthrift >=0.13.0,<0.14.0a0", + "ncurses", + "omniscidb-common >=5.6.2,<5.6.3.0a0", + "openjdk 8.*", + "openssl >=1.1.1k,<1.1.2a", + "snappy >=1.1.8,<2.0a0", + "tbb >=2021.2.0", + "xz", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "230ea75c58cf2db3513cff39c5a9b3d5", + "name": "omniscidb", + "sha256": "268b52c0ddc4812f66edd3dac423d4b5581555f367bc010ae1e25eeabd04bfa1", + "size": 9870464, + "subdir": "linux-64", + "timestamp": 1626375037313, + "version": "5.6.2" + }, + "omniscidb-5.7.0-h244a1a9_0_cpu.conda": { + "build": "h244a1a9_0_cpu", + "build_number": 0, + "depends": [ + "arrow-cpp >=2.0.0,<2.0.1.0a0", + "blosc >=1.21.0,<2.0a0", + "boost-cpp >=1.73.0,<1.73.1.0a0", + "bzip2", + "double-conversion", + "gxx_linux-64", + "libarchive >=3.4.2,<3.5.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libclang-cpp <12", + "libgcc-ng >=9.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "librdkafka >=1.6.0,<1.7.0a0", + "libstdcxx-ng >=9.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "ncurses", + "omniscidb-common >=5.7.0,<5.7.1.0a0", + "openjdk 8.*", + "openssl >=1.1.1l,<1.1.2a", + "snappy >=1.1.8,<2.0a0", + "tbb >=2021.3.0", + "xz", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7b38587f0c0f1fdf30eb19c7e3706ee5", + "name": "omniscidb", + "sha256": "8100e8ba41078bdc2c4270834a24aa4ab5a0645a03292be5ea8c9554d5523b46", + "size": 9842562, + "subdir": "linux-64", + "timestamp": 1630620642504, + "version": "5.7.0" + }, + "omniscidb-5.7.1-h244a1a9_0_cpu.conda": { + "build": "h244a1a9_0_cpu", + "build_number": 0, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "blosc >=1.21.0,<2.0a0", + "boost-cpp >=1.73.0,<1.73.1.0a0", + "bzip2", + "double-conversion", + "fmt >=7.1.3,<8.0a0", + "gxx_linux-64", + "libarchive >=3.4.2,<3.5.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libclang-cpp <12", + "libgcc-ng >=9.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "librdkafka >=1.6.0,<1.7.0a0", + "libstdcxx-ng >=9.3.0", + "libthrift >=0.14.2,<0.14.3.0a0", + "ncurses", + "omniscidb-common >=5.7.1,<5.7.2.0a0", + "openjdk 8.*", + "openssl >=1.1.1l,<1.1.2a", + "snappy >=1.1.8,<2.0a0", + "tbb >=2021.3.0", + "xz", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e4e22d1e117c60718e863a9c047c8cb7", + "name": "omniscidb", + "sha256": "4e997b2aeaa8adc2ba7a1961767ea6960ce733581ac1cd913906ece7f4157728", + "size": 9853710, + "subdir": "linux-64", + "timestamp": 1632952651465, + "version": "5.7.1" + }, + "omniscidb-common-5.10.1-hc204824_0.conda": { + "build": "hc204824_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=9.3.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c3656b3afaee272f2e5d70c851d26c86", + "name": "omniscidb-common", + "sha256": "704ab7778309a9bc2f3544fcea49683a3190cf067973a8b1a6e3b7fd31d73729", + "size": 37090416, + "subdir": "linux-64", + "timestamp": 1658969685920, + "version": "5.10.1" + }, + "omniscidb-common-5.6.2-hd589b2d_0.conda": { + "build": "hd589b2d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=8.4.0", + "libstdcxx-ng >=8.4.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8aaa3f49e368ad17a0c3e8b56bfdb1b8", + "name": "omniscidb-common", + "sha256": "eb193e68cb0ae7a18f3d0cd4f9617c509517af7a0d768efaec08d07dcdf6a535", + "size": 35393096, + "subdir": "linux-64", + "timestamp": 1626374412309, + "version": "5.6.2" + }, + "omniscidb-common-5.7.0-hfd7591c_0.conda": { + "build": "hfd7591c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8d4e01ee43dfb53967617d3b9d524043", + "name": "omniscidb-common", + "sha256": "c07f60c53459bc06678bbcfe3f5566d3bb480d0cf70a4c7560f971b81c5f921c", + "size": 34338977, + "subdir": "linux-64", + "timestamp": 1630620400840, + "version": "5.7.0" + }, + "omniscidb-common-5.7.1-hfd7591c_0.conda": { + "build": "hfd7591c_0", + "build_number": 0, + "depends": [ + "fmt >=7.1.3,<8.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "74e032ab0cdb28832fff1b7a1c7de294", + "name": "omniscidb-common", + "sha256": "99686626926782576061c89d50b566aedee1f1380305e5ba6eabe35e289ac64a", + "size": 37360098, + "subdir": "linux-64", + "timestamp": 1632952410634, + "version": "5.7.1" + }, + "omniscidbe-5.10.1-py310h65c4a83_0.conda": { + "build": "py310h65c4a83_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "double-conversion >=3.1.5,<3.3.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "gxx_linux-64", + "icu >=58.2,<59.0a0", + "libarchive >=3.5.2,<3.6.0a0", + "libgcc-ng >=11.2.0", + "libgcc-ng >=9.3.0", + "libgcc-ng >=9.4.0", + "libgdal >=3.4.1,<3.5.0a0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libstdcxx-ng >=9.4.0", + "libthrift >=0.15.0,<0.15.1.0a0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "ncurses", + "numpy >=1.16,<2.0a0", + "omniscidb-common 5.10.1 hc204824_0", + "openjdk 8.*", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.10,<3.11.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "tbb >=2021.5.0", + "utf8proc", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "bc2814dd3f1abb553f8a3600651b4244", + "name": "omniscidbe", + "sha256": "aa18975187b0526b265fae7b5c973cfaf7f54a81ca3b4c1ad84e88c508db5431", + "size": 31985888, + "subdir": "linux-64", + "timestamp": 1658970110706, + "version": "5.10.1" + }, + "omniscidbe-5.10.1-py37h7744c1e_0.conda": { + "build": "py37h7744c1e_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "double-conversion >=3.1.5,<3.3.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "gxx_linux-64", + "icu >=58.2,<59.0a0", + "libarchive >=3.5.2,<3.6.0a0", + "libgcc-ng >=11.2.0", + "libgcc-ng >=9.3.0", + "libgcc-ng >=9.4.0", + "libgdal >=3.4.1,<3.5.0a0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libstdcxx-ng >=9.4.0", + "libthrift >=0.15.0,<0.15.1.0a0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "ncurses", + "numpy >=1.16,<2.0a0", + "omniscidb-common 5.10.1 hc204824_0", + "openjdk 8.*", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.7,<3.8.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "tbb >=2021.5.0", + "utf8proc", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e5826938b64a6c5585b6d3c3dca9e902", + "name": "omniscidbe", + "sha256": "4741d1c7a765efe6882629fd3a3e91c389cb2b5a215711a8347cade4cce401de", + "size": 31972150, + "subdir": "linux-64", + "timestamp": 1658969919735, + "version": "5.10.1" + }, + "omniscidbe-5.10.1-py38h7744c1e_0.conda": { + "build": "py38h7744c1e_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "double-conversion >=3.1.5,<3.3.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "gxx_linux-64", + "icu >=58.2,<59.0a0", + "libarchive >=3.5.2,<3.6.0a0", + "libgcc-ng >=11.2.0", + "libgcc-ng >=9.3.0", + "libgcc-ng >=9.4.0", + "libgdal >=3.4.1,<3.5.0a0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libstdcxx-ng >=9.4.0", + "libthrift >=0.15.0,<0.15.1.0a0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "ncurses", + "numpy >=1.16,<2.0a0", + "omniscidb-common 5.10.1 hc204824_0", + "openjdk 8.*", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.8,<3.9.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "tbb >=2021.5.0", + "utf8proc", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ba58450c57df91bd2fd7576c08952ed5", + "name": "omniscidbe", + "sha256": "93a9fa7195f2235098b15518bfbd7929079050e4d7fb7f1dfc281555cec2cbd0", + "size": 31980836, + "subdir": "linux-64", + "timestamp": 1658970014477, + "version": "5.10.1" + }, + "omniscidbe-5.10.1-py39h7744c1e_0.conda": { + "build": "py39h7744c1e_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "blosc >=1.21.0,<2.0a0", + "brotli >=1.0.9,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "double-conversion >=3.1.5,<3.3.0a0", + "gflags >=2.2.2,<2.3.0a0", + "grpc-cpp >=1.46.1,<1.47.0a0", + "gxx_linux-64", + "icu >=58.2,<59.0a0", + "libarchive >=3.5.2,<3.6.0a0", + "libgcc-ng >=11.2.0", + "libgcc-ng >=9.3.0", + "libgcc-ng >=9.4.0", + "libgdal >=3.4.1,<3.5.0a0", + "libllvm11 >=11.1.0,<11.2.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libstdcxx-ng >=9.4.0", + "libthrift >=0.15.0,<0.15.1.0a0", + "libthrift >=0.15.0,<0.16.0a0", + "lz4-c >=1.9.3,<1.10.0a0", + "ncurses", + "numpy >=1.16,<2.0a0", + "omniscidb-common 5.10.1 hc204824_0", + "openjdk 8.*", + "orc >=1.7.4,<1.7.5.0a0", + "python >=3.9,<3.10.0a0", + "re2 >=2022.4.1,<2022.4.2.0a0", + "snappy >=1.1.9,<2.0a0", + "tbb >=2021.5.0", + "utf8proc", + "xerces-c >=3.2.3,<3.3.0a0", + "xz >=5.2.5,<6.0a0", + "zlib", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "773f2bc8fe8b8b9a26286f71fae53b55", + "name": "omniscidbe", + "sha256": "4174ac3cfd415cdcda46011214035118713d5a2b1900d6f45f41723a8a46e038", + "size": 31985429, + "subdir": "linux-64", + "timestamp": 1658969827395, + "version": "5.10.1" + }, + "omniscidbe-5.7.0-h7185ff3_0_cpu.conda": { + "build": "h7185ff3_0_cpu", + "build_number": 0, + "depends": [ + "arrow-cpp >=2.0.0,<2.0.1.0a0", + "blosc >=1.21.0,<2.0a0", + "boost-cpp >=1.73.0,<1.73.1.0a0", + "bzip2", + "double-conversion", + "gxx_linux-64", + "libarchive >=3.4.2,<3.5.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libclang-cpp <12", + "libgcc-ng >=9.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "librdkafka", + "libstdcxx-ng >=9.3.0", + "libthrift >=0.13.0,<0.14.0a0", + "ncurses", + "omniscidb-common >=5.7.0,<5.7.1.0a0", + "openjdk 8.*", + "snappy", + "tbb >=2021.3.0", + "xz", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a5da0b18226fa5f25f982dfbb7e062e0", + "name": "omniscidbe", + "sha256": "3745131e6253679efba335b1503d910a8eff56cba4c39c0ca8eb883e4c9a45d5", + "size": 5720686, + "subdir": "linux-64", + "timestamp": 1630620825344, + "version": "5.7.0" + }, + "omniscidbe-5.7.1-h7185ff3_0_cpu.conda": { + "build": "h7185ff3_0_cpu", + "build_number": 0, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "blosc >=1.21.0,<2.0a0", + "boost-cpp >=1.73.0,<1.73.1.0a0", + "bzip2", + "double-conversion", + "fmt >=7.1.3,<8.0a0", + "gxx_linux-64", + "libarchive >=3.4.2,<3.5.0a0", + "libboost >=1.73.0,<1.73.1.0a0", + "libclang-cpp <12", + "libgcc-ng >=9.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libllvm10 >=10.0.1,<10.1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "librdkafka", + "libstdcxx-ng >=9.3.0", + "libthrift >=0.14.2,<0.14.3.0a0", + "ncurses", + "omniscidb-common >=5.7.1,<5.7.2.0a0", + "openjdk 8.*", + "snappy", + "tbb >=2021.3.0", + "xz", + "zlib" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c30d86f496b849e08263755a7bd60ec9", + "name": "omniscidbe", + "sha256": "b015478ec2021b4a8e9affee45e58e5365e294fd3b8b70947723391913ad73ae", + "size": 5714000, + "subdir": "linux-64", + "timestamp": 1632952834421, + "version": "5.7.1" + }, + "oneccl-devel-2021.3.0-h06a4308_343.conda": { + "build": "h06a4308_343", + "build_number": 343, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "b5eb4145c3b2ef2a2540ca152b1c32d2", + "name": "oneccl-devel", + "sha256": "ddfadd64f59217b214fcf870d42347542c9a2ac8e75e8b8bae4ed34d54f05be9", + "size": 6283184, + "subdir": "linux-64", + "timestamp": 1626976054533, + "version": "2021.3.0" + }, + "oneccl-devel-2021.4.0-h06a4308_433.conda": { + "build": "h06a4308_433", + "build_number": 433, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "7c4a1dac906a78187ba2599bbff5522a", + "name": "oneccl-devel", + "sha256": "cce54c02ca81181ada54f2c053b04c9119270a9706b2a217ecd667786653ac3a", + "size": 5109996, + "subdir": "linux-64", + "timestamp": 1641816034296, + "version": "2021.4.0" + }, + "oneccl-devel-2021.5.0-h06a4308_478.conda": { + "build": "h06a4308_478", + "build_number": 478, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "57c33e5137b4ad600a67198d215ebbd8", + "name": "oneccl-devel", + "sha256": "4aade546c3e4bd6d1b31fd96d3b688ad5732358a6e2adc876cadb26572c81348", + "size": 3865474, + "subdir": "linux-64", + "timestamp": 1642778518809, + "version": "2021.5.0" + }, + "oneccl-devel-2021.8.0-h06a4308_25371.conda": { + "build": "h06a4308_25371", + "build_number": 25371, + "depends": [], + "license": "Intel Simplified Software License", + "license_family": "Proprietary", + "md5": "deeeb98b5b6c6a396fc8233b98ee85b3", + "name": "oneccl-devel", + "sha256": "94388852c3afd4c38572e6ac483145c25e349bb00a934163ce86884154128641", + "size": 6757081, + "subdir": "linux-64", + "timestamp": 1679614950758, + "version": "2021.8.0" + }, + "oniguruma-6.9.3-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD 2-Clause", + "md5": "b6644d9a68147b694bac466ea6c393be", + "name": "oniguruma", + "sha256": "019c7043b2a3c4f9edd48055ed7ee4fb19ab85d7e4d38c2977e91110425af131", + "size": 240048, + "subdir": "linux-64", + "timestamp": 1604334840254, + "version": "6.9.3" + }, + "oniguruma-6.9.6-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "md5": "0ccc0aa989353fb5189bf64f2e3e4572", + "name": "oniguruma", + "sha256": "26ef26fe03930277c9b935722bc57f1717b581a5857ce4c11ad3e1804e78ed44", + "size": 244429, + "subdir": "linux-64", + "timestamp": 1611951807244, + "version": "6.9.6" + }, + "oniguruma-6.9.7-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "md5": "db7544d24aa6efd452caadac574d735b", + "name": "oniguruma", + "sha256": "97ea4f3e053473abc98ad0eecba5d053884e31133f05fc0086004589bf0a85b0", + "size": 247321, + "subdir": "linux-64", + "timestamp": 1618437041421, + "version": "6.9.7" + }, + "oniguruma-6.9.7.1-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "BSD-2-Clause", + "md5": "3415c8dd052c9032955fa24b870725ea", + "name": "oniguruma", + "sha256": "fe12572a09f65e732e22695d76ea8ec23c6d1c2eb23af26bfd64f68987373d09", + "size": 249393, + "subdir": "linux-64", + "timestamp": 1618609977611, + "version": "6.9.7.1" + }, + "onnx-1.10.2-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf >=3.19.1,<3.20.0a0", + "libprotobuf >=3.19.1,<4.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.17.0,<2.0a0", + "protobuf >=3.12.2", + "python >=3.7,<3.8.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90807f19c6be34c8288a15e1ef16747d", + "name": "onnx", + "sha256": "18fac2be02bef61b437c484765222216d897d3b82a2b1d3c4f695c313456bed9", + "size": 7527267, + "subdir": "linux-64", + "timestamp": 1643910764413, + "version": "1.10.2" + }, + "onnx-1.10.2-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf >=3.19.1,<3.20.0a0", + "libprotobuf >=3.19.1,<4.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "protobuf >=3.12.2", + "python >=3.8,<3.9.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c7f34c29ddaad13d49842e3a9ae9c82", + "name": "onnx", + "sha256": "342c7af050bd528e24aee7a40749b782e3491f6645aeaf86b5eb06b805b473ba", + "size": 7538003, + "subdir": "linux-64", + "timestamp": 1643912874094, + "version": "1.10.2" + }, + "onnx-1.10.2-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf >=3.19.1,<3.20.0a0", + "libprotobuf >=3.19.1,<4.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "protobuf >=3.12.2", + "python >=3.9,<3.10.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2406c0eeb8193986ec41aeddd339d1d4", + "name": "onnx", + "sha256": "ba1992ccc98d3422747bdfcacedbb40ca7775eddcc1a545edb29af73c6a92f67", + "size": 7537530, + "subdir": "linux-64", + "timestamp": 1643928881132, + "version": "1.10.2" + }, + "onnx-1.12.0-py310h38ec052_0.conda": { + "build": "py310h38ec052_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libprotobuf >=3.20.1,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "protobuf", + "python >=3.10,<3.11.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d14c4a18ad08760dba669730cb5b7f9", + "name": "onnx", + "sha256": "c6410598cdb46e5f30f3bcded5a58d4aa829813049707191453f8028ed616528", + "size": 7678936, + "subdir": "linux-64", + "timestamp": 1661366730619, + "version": "1.12.0" + }, + "onnx-1.12.0-py310h38ec052_1.conda": { + "build": "py310h38ec052_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libprotobuf >=3.20.1,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "protobuf", + "python >=3.10,<3.11.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3dc21d0b154496bc12c18de4e0dc1f92", + "name": "onnx", + "sha256": "f398cbd2d69e62f5cf4643dbc7efb97447a76f3a28c38e405090a3bf48e98b51", + "size": 7960375, + "subdir": "linux-64", + "timestamp": 1672851194693, + "version": "1.12.0" + }, + "onnx-1.12.0-py37h6736146_0.conda": { + "build": "py37h6736146_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libprotobuf >=3.20.1,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "protobuf", + "python >=3.7,<3.8.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e82698011a74f364afd3cbb5f19b0ffb", + "name": "onnx", + "sha256": "1a4f117c62ba098e6d5b57c0b87cdd118f01ff83abb644f654275b54e9234eac", + "size": 7677356, + "subdir": "linux-64", + "timestamp": 1661366489328, + "version": "1.12.0" + }, + "onnx-1.12.0-py37h6736146_1.conda": { + "build": "py37h6736146_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libprotobuf >=3.20.1,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "protobuf", + "python >=3.7,<3.8.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b600f20a639712e1f46d310c12623a8", + "name": "onnx", + "sha256": "426de5961cdb1bdf482b225da49742cd3daf83d62ea26427589288bb476d6bbc", + "size": 7961755, + "subdir": "linux-64", + "timestamp": 1672850528128, + "version": "1.12.0" + }, + "onnx-1.12.0-py38h6736146_0.conda": { + "build": "py38h6736146_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libprotobuf >=3.20.1,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "protobuf", + "python >=3.8,<3.9.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "42fad1ccea504386e801c549aa2765f2", + "name": "onnx", + "sha256": "66db9100f7aca6a929d96a18a7ed10db8d4310e1386ceaecd969b3c73247a584", + "size": 7676712, + "subdir": "linux-64", + "timestamp": 1661366255958, + "version": "1.12.0" + }, + "onnx-1.12.0-py38h6736146_1.conda": { + "build": "py38h6736146_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libprotobuf >=3.20.1,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "protobuf", + "python >=3.8,<3.9.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0defee699377a65696225213a47d90c1", + "name": "onnx", + "sha256": "5d3e8ad94dd8287bc36b3a8b18c82008b84c960db1b59405418fbc5df7ba8f05", + "size": 7958104, + "subdir": "linux-64", + "timestamp": 1672850973550, + "version": "1.12.0" + }, + "onnx-1.12.0-py39h6736146_0.conda": { + "build": "py39h6736146_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libprotobuf >=3.20.1,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "protobuf", + "python >=3.9,<3.10.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39d38fa80c974701a06e8da7916f3661", + "name": "onnx", + "sha256": "2b472274713c31c6ddd05586de9cbfcf044d322b9aef75fa83f727f882060580", + "size": 7673637, + "subdir": "linux-64", + "timestamp": 1661366027849, + "version": "1.12.0" + }, + "onnx-1.12.0-py39h6736146_1.conda": { + "build": "py39h6736146_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libprotobuf >=3.20.1,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "protobuf", + "python >=3.9,<3.10.0a0", + "six", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "73e6c796c870a4781791fbb8ab7df8dd", + "name": "onnx", + "sha256": "d67dbce833cec001a9ca4fe7ff1766a1923d662a8356d32fc7cafc1356593b24", + "size": 7955574, + "subdir": "linux-64", + "timestamp": 1672850752083, + "version": "1.12.0" + }, + "onnx-1.13.0-py310h12ddb61_0.conda": { + "build": "py310h12ddb61_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libprotobuf >=3.20.3,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "protobuf >=3.20.2,<4", + "python >=3.10,<3.11.0a0", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bbf44416b274f23c5023f7c20650f8bb", + "name": "onnx", + "sha256": "00a0672d2fd5aad4240f7565a702cdc61d93ea91919a61b5fcd19cc87cf70a0a", + "size": 8338533, + "subdir": "linux-64", + "timestamp": 1675284619737, + "version": "1.13.0" + }, + "onnx-1.13.0-py311h12ddb61_1.conda": { + "build": "py311h12ddb61_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libprotobuf >=3.20.3,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "protobuf >=3.20.2,<4", + "python >=3.11,<3.12.0a0", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66dbcfb3f2cc8b285175692a8c2babce", + "name": "onnx", + "sha256": "4c168e2fd64d35c174974c39679e43d76251f908eba74f7569200758d6c410a8", + "size": 8223960, + "subdir": "linux-64", + "timestamp": 1676837309971, + "version": "1.13.0" + }, + "onnx-1.13.0-py37h12ddb61_0.conda": { + "build": "py37h12ddb61_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libprotobuf >=3.20.3,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "protobuf >=3.20.2,<4", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47b2acd5fe95e8787ba58297cb7627c7", + "name": "onnx", + "sha256": "ddebf487168fb2ab6347aa8225af48901befc69015e5aedb7c68a2b5ef0652af", + "size": 8340954, + "subdir": "linux-64", + "timestamp": 1675284435684, + "version": "1.13.0" + }, + "onnx-1.13.0-py38h12ddb61_0.conda": { + "build": "py38h12ddb61_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libprotobuf >=3.20.3,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "protobuf >=3.20.2,<4", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "948cfe6b3e2833918dd4dffc05ff00bf", + "name": "onnx", + "sha256": "e5a659a18528fbcb81c438ac879227310aa8b0ff6ac21721df7721b72949e94b", + "size": 8328145, + "subdir": "linux-64", + "timestamp": 1675284802907, + "version": "1.13.0" + }, + "onnx-1.13.0-py39h12ddb61_0.conda": { + "build": "py39h12ddb61_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libprotobuf >=3.20.3,<4.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "protobuf >=3.20.2,<4", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.6.2.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8bba2ac5ef6136e23411af5c8f235745", + "name": "onnx", + "sha256": "01cd532da28eb8e66cb52ebe6aac28d5557c5127e45f45f1d8d912e241b366ce", + "size": 8338621, + "subdir": "linux-64", + "timestamp": 1675284989363, + "version": "1.13.0" + }, + "onnxconverter-common-1.13.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "onnx", + "packaging", + "protobuf", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "07a04a419f2564199788df951c3a474a", + "name": "onnxconverter-common", + "sha256": "11be396f93baf0689f3b829691fdb57e6426ca737d47ed7714c9a0791d899c6f", + "size": 158305, + "subdir": "linux-64", + "timestamp": 1671635177613, + "version": "1.13.0" + }, + "onnxconverter-common-1.13.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "onnx", + "packaging", + "protobuf", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d91dc3976a9218487ec5d82f24ba2072", + "name": "onnxconverter-common", + "sha256": "df77930c6992c6131e9160c710fe243989fa7fb22d040710a141ee6b16be1ccc", + "size": 206804, + "subdir": "linux-64", + "timestamp": 1676841401270, + "version": "1.13.0" + }, + "onnxconverter-common-1.13.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "onnx", + "packaging", + "protobuf", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2eaa3268278565a95ee9d50a05c6a48b", + "name": "onnxconverter-common", + "sha256": "2f7339dac5e66be237f8508b967b64e2915c455951fef4e3a3512ee1a37c39dd", + "size": 156806, + "subdir": "linux-64", + "timestamp": 1671635103505, + "version": "1.13.0" + }, + "onnxconverter-common-1.13.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "onnx", + "packaging", + "protobuf", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca91255054c20367147ef422afc77340", + "name": "onnxconverter-common", + "sha256": "0622bf5400514fa0eac91130d9d7df8edf46d534653be54545e76d30d84df624", + "size": 157089, + "subdir": "linux-64", + "timestamp": 1671635153893, + "version": "1.13.0" + }, + "onnxconverter-common-1.13.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "onnx", + "packaging", + "protobuf", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d5fe1b499e1e9cbfc33045095a085027", + "name": "onnxconverter-common", + "sha256": "6e77c391c298e19715cf875f32f073d02c11adc0e848aac93792ebce3a496e30", + "size": 156730, + "subdir": "linux-64", + "timestamp": 1671635129844, + "version": "1.13.0" + }, + "onnxmltools-1.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "onnx", + "python >=3.10,<3.11.0a0", + "skl2onnx" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8cadd08a4b472c55b514673593567bd9", + "name": "onnxmltools", + "sha256": "f7a6e8d547ee955dfb204e8420339a7bf0474b5bea186ff76d92881133863ace", + "size": 312715, + "subdir": "linux-64", + "timestamp": 1671721331834, + "version": "1.11.0" + }, + "onnxmltools-1.11.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "onnx", + "python >=3.7,<3.8.0a0", + "skl2onnx" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5b20e6ef2d2bd2d3a0062c4a91ddace9", + "name": "onnxmltools", + "sha256": "bba3eafc38ccb6a1b53be9fe853fb5af5b1ebc18411fa3de3b9ece07d7ad5aac", + "size": 310542, + "subdir": "linux-64", + "timestamp": 1671721256666, + "version": "1.11.0" + }, + "onnxmltools-1.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "onnx", + "python >=3.8,<3.9.0a0", + "skl2onnx" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "887c31eb2bdf2d1d5de55b9b15a2ac92", + "name": "onnxmltools", + "sha256": "470e643ba0a5a96ba3fcdb34c4c9004743e88026e5136a3c47765d76ee27890d", + "size": 311580, + "subdir": "linux-64", + "timestamp": 1671721294415, + "version": "1.11.0" + }, + "onnxmltools-1.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy", + "onnx", + "python >=3.9,<3.10.0a0", + "skl2onnx" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cc0692f43aa11c20758e93b9bc3a187c", + "name": "onnxmltools", + "sha256": "961d89bda301ef291d23eb4385e8c76669fc1b41b4980aafc37ee95860ba2f60", + "size": 311413, + "subdir": "linux-64", + "timestamp": 1671721211794, + "version": "1.11.0" + }, + "onnxruntime-1.12.1-py310h2c1dd4f_0.conda": { + "build": "py310h2c1dd4f_0", + "build_number": 0, + "depends": [ + "coloredlogs", + "libcurl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "protobuf", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "re2 >=2022.4.1,<2022.4.2.0a0", + "sympy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5be87f9b0d5af75f16890f3a3e7fbb46", + "name": "onnxruntime", + "sha256": "1589aeab3285b1f746de01366cb9b92ce171c61a676ae4fc0e4a1980f6d3b24b", + "size": 4795163, + "subdir": "linux-64", + "timestamp": 1664951063779, + "version": "1.12.1" + }, + "onnxruntime-1.12.1-py37h8de7196_0.conda": { + "build": "py37h8de7196_0", + "build_number": 0, + "depends": [ + "coloredlogs", + "libcurl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "re2 >=2022.4.1,<2022.4.2.0a0", + "sympy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f626a25815f5d6a1c64b93730d939179", + "name": "onnxruntime", + "sha256": "7890b2f06b445a30a3088806fa96340892ec1e26bbcf2937e9aaa1a49f779831", + "size": 4938222, + "subdir": "linux-64", + "timestamp": 1664950030425, + "version": "1.12.1" + }, + "onnxruntime-1.12.1-py38h8de7196_0.conda": { + "build": "py38h8de7196_0", + "build_number": 0, + "depends": [ + "coloredlogs", + "libcurl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "re2 >=2022.4.1,<2022.4.2.0a0", + "sympy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e3a0d962ae1c498d59118b9bf271483", + "name": "onnxruntime", + "sha256": "bac4e136a02456b439bcf08695e94e66cdd94350db3bb65d763fb128c22f9b75", + "size": 4933464, + "subdir": "linux-64", + "timestamp": 1664952097768, + "version": "1.12.1" + }, + "onnxruntime-1.12.1-py39h8de7196_0.conda": { + "build": "py39h8de7196_0", + "build_number": 0, + "depends": [ + "coloredlogs", + "libcurl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "re2 >=2022.4.1,<2022.4.2.0a0", + "sympy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4d061ea896509adeacbdfa9988f6f1c", + "name": "onnxruntime", + "sha256": "2dfaa3b5b8ad02da7af8bda98339196c317d7ea9aa494769b43a190ee9d4f984", + "size": 4910137, + "subdir": "linux-64", + "timestamp": 1664953133854, + "version": "1.12.1" + }, + "onnxruntime-novec-1.12.1-py310hab7e82e_0.conda": { + "build": "py310hab7e82e_0", + "build_number": 0, + "constrains": [ + "onnxruntime <0a0" + ], + "depends": [ + "coloredlogs", + "libcurl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "protobuf", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "re2 >=2022.4.1,<2022.4.2.0a0", + "sympy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2003595f39a7f57cc0fe3522ac6d78f8", + "name": "onnxruntime-novec", + "sha256": "583ed7cfc91e96f107da2ca1e6589bc8cccb2e584117241a58d2603493180d49", + "size": 4736698, + "subdir": "linux-64", + "timestamp": 1664955128613, + "version": "1.12.1" + }, + "onnxruntime-novec-1.12.1-py37ha761a4e_0.conda": { + "build": "py37ha761a4e_0", + "build_number": 0, + "constrains": [ + "onnxruntime <0a0" + ], + "depends": [ + "coloredlogs", + "libcurl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "re2 >=2022.4.1,<2022.4.2.0a0", + "sympy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a30e8920d4124b577e1aa87bdf89ca4", + "name": "onnxruntime-novec", + "sha256": "e442ca11db244ae4c815e4fe5fe5fc78b56e475155e01f9a2e433c646d63cfd0", + "size": 4871962, + "subdir": "linux-64", + "timestamp": 1664954134168, + "version": "1.12.1" + }, + "onnxruntime-novec-1.12.1-py38ha761a4e_0.conda": { + "build": "py38ha761a4e_0", + "build_number": 0, + "constrains": [ + "onnxruntime <0a0" + ], + "depends": [ + "coloredlogs", + "libcurl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "re2 >=2022.4.1,<2022.4.2.0a0", + "sympy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ecc336e0f19a9257ff3e45831b97bae", + "name": "onnxruntime-novec", + "sha256": "e99484c8ee6047e4bc7e6c4f2e2456566733aa8055c8e646cf04d2b4c196a913", + "size": 4844657, + "subdir": "linux-64", + "timestamp": 1664956122930, + "version": "1.12.1" + }, + "onnxruntime-novec-1.12.1-py39ha761a4e_0.conda": { + "build": "py39ha761a4e_0", + "build_number": 0, + "constrains": [ + "onnxruntime <0a0" + ], + "depends": [ + "coloredlogs", + "libcurl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "protobuf", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "re2 >=2022.4.1,<2022.4.2.0a0", + "sympy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc7c283edd8420183f113832bb6867dd", + "name": "onnxruntime-novec", + "sha256": "592f13e3aae3a8e5918fa72b1129333df4e920814abdb75af070d675ff4b3a3e", + "size": 4847814, + "subdir": "linux-64", + "timestamp": 1664957116362, + "version": "1.12.1" + }, + "openblas-0.2.20-4.conda": { + "build": "4", + "build_number": 4, + "depends": [ + "libopenblas >=0.2.20,<0.2.21.0a0", + "openblas-devel >=0.2.20,<0.2.21.0a0" + ], + "license": "BSD", + "md5": "b947e10dcd419eae6b48a6ecec650d81", + "name": "openblas", + "sha256": "fd84375a4b45bd7e0477fb4f3acbb9a19451f3d319126403b30f80561e69a4b8", + "size": 5128, + "subdir": "linux-64", + "timestamp": 1515516241962, + "version": "0.2.20" + }, + "openblas-0.2.20-7.conda": { + "build": "7", + "build_number": 7, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.2.20,<0.2.21.0a0", + "openblas-devel >=0.2.20,<0.2.21.0a0" + ], + "license": "BSD", + "md5": "a0a1badfd516359095cbf504370b0fc2", + "name": "openblas", + "sha256": "589a26b65bad9ccb94b0e744cd6c0f61e3ab754870f9d14eb4e114f5032f2840", + "size": 46893, + "subdir": "linux-64", + "timestamp": 1527877219124, + "version": "0.2.20" + }, + "openblas-0.2.20-h9b22ed0_3.conda": { + "build": "h9b22ed0_3", + "build_number": 3, + "depends": [ + "openblas-devel >=0.2.20,<0.2.21.0a0" + ], + "license": "BSD", + "md5": "0312cdd630807f4ebd92ee6ded6c9c92", + "name": "openblas", + "sha256": "e70956eb0658d64ba12f45d0374964f067f258a9334acee362583b8c711ddade", + "size": 5179, + "subdir": "linux-64", + "timestamp": 1509731037394, + "version": "0.2.20" + }, + "openblas-0.3.10-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.10 h5a2b251_0", + "nomkl 3.0 0", + "openblas-devel 0.3.10 0" + ], + "license": "BSD", + "md5": "c7528b64b5f2c974a3294b3ec88a509a", + "name": "openblas", + "sha256": "9518ae732e5af78b153f6f7372b60d6aee271291f707cbdf044874c10db82ddb", + "size": 20879, + "subdir": "linux-64", + "timestamp": 1594191958270, + "version": "0.3.10" + }, + "openblas-0.3.13-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.13 h4367d64_0", + "nomkl 3.0 0", + "openblas-devel 0.3.13 h06a4308_0" + ], + "license": "BSD", + "md5": "1a790b664cf1ca0c71434bca42a1fb3c", + "name": "openblas", + "sha256": "a434c5494c130a530b77df97b680e84f3c244d4bb2a17b855696074cd3019fb8", + "size": 22129, + "subdir": "linux-64", + "timestamp": 1616438153633, + "version": "0.3.13" + }, + "openblas-0.3.17-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.17 hf726d26_1", + "nomkl 3.0 0", + "openblas-devel 0.3.17 h06a4308_1" + ], + "license": "BSD-3-clause", + "md5": "ce0aa9435ad2ff6869ded9ce4e749b61", + "name": "openblas", + "sha256": "6d204e258f4b6370c3f0d583aedbdff3d3a2d7daba1b808bbd207a5583448ef0", + "size": 11561, + "subdir": "linux-64", + "timestamp": 1643995262210, + "version": "0.3.17" + }, + "openblas-0.3.18-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.18 hf726d26_0", + "nomkl 3.0 0", + "openblas-devel 0.3.18 h06a4308_0" + ], + "license": "BSD-3-clause", + "md5": "a761a0d6e8c943bde1e3b23f9baffc6b", + "name": "openblas", + "sha256": "97111f217e610a239e3eeeefe3c6c8b161cd99f820684877525aa7ca7436d5ef", + "size": 11777, + "subdir": "linux-64", + "timestamp": 1649691298201, + "version": "0.3.18" + }, + "openblas-0.3.2-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "openblas-devel >=0.3.2,<0.3.3.0a0" + ], + "license": "BSD", + "md5": "84998125ef48c3344b09a3601cc1cff0", + "name": "openblas", + "sha256": "580d54a9e0e617e864658cc4cac757c02ab6b08f0859493e121e77fec169fd1f", + "size": 7168, + "subdir": "linux-64", + "timestamp": 1534770596667, + "version": "0.3.2" + }, + "openblas-0.3.2-1.conda": { + "build": "1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libopenblas >=0.3.2,<0.3.3.0a0", + "nomkl 3.0 0", + "openblas-devel >=0.3.2,<0.3.3.0a0" + ], + "license": "BSD", + "md5": "b64764096ded18bf79aeeb095b9e59f8", + "name": "openblas", + "sha256": "2f8ba494de989deb31bc3624b25ea4457d0fbe62b243af82fb6c7f2379af7a67", + "size": 7533, + "subdir": "linux-64", + "timestamp": 1534782572073, + "version": "0.3.2" + }, + "openblas-0.3.20-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.20 h043d6bf_0", + "nomkl 3.0 0", + "openblas-devel 0.3.20 h06a4308_0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "36f2434a388477e3bf23db1ea833cf49", + "name": "openblas", + "sha256": "3efc3503234f65cb0fd176dd12f835b6125b3655a13d6d67100646144ca49125", + "size": 11925, + "subdir": "linux-64", + "timestamp": 1652995324540, + "version": "0.3.20" + }, + "openblas-0.3.20-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.20 h043d6bf_1", + "nomkl 3.0 0", + "openblas-devel 0.3.20 h06a4308_1" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "200f5cae9bae29217f2867a70a00e1b0", + "name": "openblas", + "sha256": "73f952d2b02c4addd7e792ea0e2c467d60f87bd615662d12c063be62ba86aa18", + "size": 11924, + "subdir": "linux-64", + "timestamp": 1653477019211, + "version": "0.3.20" + }, + "openblas-0.3.21-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.21 h043d6bf_0", + "nomkl 3.0 0", + "openblas-devel 0.3.21 h06a4308_0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa2570bf5a0b54f0e87495d298ec8447", + "name": "openblas", + "sha256": "c8f89a2f4d566ecaddf8cd0bac4deffec638c7dc1217335d592732927ff636a6", + "size": 11830, + "subdir": "linux-64", + "timestamp": 1664897205817, + "version": "0.3.21" + }, + "openblas-0.3.3-1.conda": { + "build": "1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.3 h5a2b251_1", + "nomkl 3.0 0", + "openblas-devel 0.3.3 1" + ], + "license": "BSD", + "md5": "12fee0b2939ef2f4cfcebb458f768201", + "name": "openblas", + "sha256": "2e121928f57d28de9781f35bf5bc59a9b7cadb5caf229288b80a4a81a9efcbb8", + "size": 7665, + "subdir": "linux-64", + "timestamp": 1536076222460, + "version": "0.3.3" + }, + "openblas-0.3.3-2.conda": { + "build": "2", + "build_number": 2, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.3 h5a2b251_2", + "nomkl 3.0 0", + "openblas-devel 0.3.3 2" + ], + "license": "BSD", + "md5": "0a44809abd250df9252b9342e079cab7", + "name": "openblas", + "sha256": "878567882fda68eceee238ed50d6b27de123b9a3eb444f4400d8cca4d382bf2b", + "size": 12500, + "subdir": "linux-64", + "timestamp": 1536889165159, + "version": "0.3.3" + }, + "openblas-0.3.3-3.conda": { + "build": "3", + "build_number": 3, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.3 h5a2b251_3", + "nomkl 3.0 0", + "openblas-devel 0.3.3 3" + ], + "license": "BSD", + "md5": "b6cda8a9df293c1478cf1e7852bfcaba", + "name": "openblas", + "sha256": "4b94e8719e5ce97419eb7b36aa9aca25c478ee8a3de4d3de3d81f2b66fcc75c8", + "size": 8461, + "subdir": "linux-64", + "timestamp": 1537472801522, + "version": "0.3.3" + }, + "openblas-0.3.6-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.6 h5a2b251_0", + "nomkl 3.0 0", + "openblas-devel 0.3.6 0" + ], + "license": "BSD", + "md5": "c1f82744655212ebdf8d8a5e2f3b7e12", + "name": "openblas", + "sha256": "b93a552714913e87f6ef6257cfd5a4ade213296727399facd8ed6a4dbe31cd20", + "size": 18918, + "subdir": "linux-64", + "timestamp": 1559239840450, + "version": "0.3.6" + }, + "openblas-0.3.6-1.conda": { + "build": "1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.6 h5a2b251_1", + "nomkl 3.0 0", + "openblas-devel 0.3.6 1" + ], + "license": "BSD", + "md5": "43f286ce49f1cd1dbe0df7e2a1ecd3f9", + "name": "openblas", + "sha256": "e4c9fe04f20e252a4eb5c983b3c602f1cbb6dddab75f77de3ab713028163ee13", + "size": 19904, + "subdir": "linux-64", + "timestamp": 1563464699545, + "version": "0.3.6" + }, + "openblas-0.3.6-2.conda": { + "build": "2", + "build_number": 2, + "depends": [ + "blas 1.0 openblas", + "libopenblas 0.3.6 h5a2b251_2", + "nomkl 3.0 0", + "openblas-devel 0.3.6 2" + ], + "license": "BSD", + "md5": "14618d3a39d4d66ecee4b1010e9c311d", + "name": "openblas", + "sha256": "06eb5740a9c5d8737af47ac1fef4cfddeface0f67427b72c7ac1ed237b98b3c5", + "size": 20261, + "subdir": "linux-64", + "timestamp": 1573061093949, + "version": "0.3.6" + }, + "openblas-devel-0.2.20-4.conda": { + "build": "4", + "build_number": 4, + "depends": [ + "libopenblas >=0.2.20,<0.2.21.0a0", + "blas * openblas" + ], + "md5": "930ed7cbd16558677597b20d80f7fbba", + "name": "openblas-devel", + "sha256": "1dd4afb4699b9108cd42f39897c3a9895e69cb21347d189be1234a8e2d79b593", + "size": 65189, + "subdir": "linux-64", + "timestamp": 1515516241238, + "version": "0.2.20" + }, + "openblas-devel-0.2.20-7.conda": { + "build": "7", + "build_number": 7, + "depends": [ + "libopenblas >=0.2.20,<0.2.21.0a0", + "blas * openblas" + ], + "md5": "660c063f62818ac0a869af382336115f", + "name": "openblas-devel", + "sha256": "19f5a9c7d7285e0923bb80265beac7ef40ca6c042bfc4dcba14d4df09054829d", + "size": 107970, + "subdir": "linux-64", + "timestamp": 1527877218186, + "version": "0.2.20" + }, + "openblas-devel-0.2.20-h1e4b922_3.conda": { + "build": "h1e4b922_3", + "build_number": 3, + "depends": [ + "libopenblas >=0.2.20,<0.2.21.0a0", + "blas * openblas" + ], + "md5": "830f8bdfc563157edc06bee2934d04ac", + "name": "openblas-devel", + "sha256": "da0babd71d2a8f6692a3f4e1564c3f4756f0e8979399c01b1364d31385d7988c", + "size": 65218, + "subdir": "linux-64", + "timestamp": 1509731031975, + "version": "0.2.20" + }, + "openblas-devel-0.3.10-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "libopenblas 0.3.10 h5a2b251_0", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "46e54b43d87f50b72f882338a2021ea8", + "name": "openblas-devel", + "sha256": "6afa48a40dbb23ab290ce0b294ab92369030671d75f5f26b1fdb13e25c4dc016", + "size": 59917, + "subdir": "linux-64", + "timestamp": 1594191957081, + "version": "0.3.10" + }, + "openblas-devel-0.3.13-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libopenblas 0.3.13 h4367d64_0", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "b377ceb273e72cab916c66d9c39fe01e", + "name": "openblas-devel", + "sha256": "54275cc6df83631cb32f60b70c655b3e6571af1ef7e29bc41c0fe07e6fa9fb52", + "size": 61538, + "subdir": "linux-64", + "timestamp": 1616438152528, + "version": "0.3.13" + }, + "openblas-devel-0.3.17-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [ + "libopenblas 0.3.17 hf726d26_1", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "34ee2a392050105d774452a5e5f86a41", + "name": "openblas-devel", + "sha256": "f679efa2e30d25df9c834f3780cb7dc6dd8cfca45643b86b21e7a803004d4be0", + "size": 73825, + "subdir": "linux-64", + "timestamp": 1643995261367, + "version": "0.3.17" + }, + "openblas-devel-0.3.18-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libopenblas 0.3.18 hf726d26_0", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "1dda6b477eb4fcc5ab8a1632e41c99f2", + "name": "openblas-devel", + "sha256": "d5ace0b60cea802bc7ebb52adc6ade788eafe2feae34c3ef1e8aed7fe952016e", + "size": 74181, + "subdir": "linux-64", + "timestamp": 1649691297331, + "version": "0.3.18" + }, + "openblas-devel-0.3.2-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "libopenblas >=0.3.2,<0.3.3.0a0", + "blas * openblas" + ], + "md5": "5b1dbe5c132de43eaad72a89ae80e773", + "name": "openblas-devel", + "sha256": "981aa45d6a6ddfdd418142fbee501a0a5c0bd1393f3f5176808d3b7181a2ab22", + "size": 68507, + "subdir": "linux-64", + "timestamp": 1534770595903, + "version": "0.3.2" + }, + "openblas-devel-0.3.2-1.conda": { + "build": "1", + "build_number": 1, + "depends": [ + "libopenblas >=0.3.2,<0.3.3.0a0", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "62b7570141785a768d276877b63c8c3e", + "name": "openblas-devel", + "sha256": "9f6f1c900233b6b011540b6b59e64b2af45b873baed498e0d174d85f2ac4b9a3", + "size": 68806, + "subdir": "linux-64", + "timestamp": 1534782570252, + "version": "0.3.2" + }, + "openblas-devel-0.3.20-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libopenblas 0.3.20 h043d6bf_0", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "f94b982f3d893545ab94c5d6627be724", + "name": "openblas-devel", + "sha256": "0ebc71a98978939b99df2dcbd600e21ff3e725e040abfc3abcc4e85f1dcc3e3c", + "size": 74080, + "subdir": "linux-64", + "timestamp": 1652995323660, + "version": "0.3.20" + }, + "openblas-devel-0.3.20-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [ + "libopenblas 0.3.20 h043d6bf_1", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "5a40fd95201de4ed0499b4b60e66e7f2", + "name": "openblas-devel", + "sha256": "f97ddcab39f79481cc714f50397b0c46ef9e550a16c5ba17dbdced03308e5509", + "size": 74321, + "subdir": "linux-64", + "timestamp": 1653477018322, + "version": "0.3.20" + }, + "openblas-devel-0.3.21-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libopenblas 0.3.21 h043d6bf_0", + "nomkl 3.0 0", + "blas * openblas" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "49dab913f6565bcef2362d26b7ee64a3", + "name": "openblas-devel", + "sha256": "42cc00419d0badd3110bc54d4b7dd134c9840cd3ff815f610f4dda4aa452a623", + "size": 83060, + "subdir": "linux-64", + "timestamp": 1664897204906, + "version": "0.3.21" + }, + "openblas-devel-0.3.3-1.conda": { + "build": "1", + "build_number": 1, + "depends": [ + "libopenblas 0.3.3 h5a2b251_1", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "95d36512df2b3bc123271bacad25a44a", + "name": "openblas-devel", + "sha256": "e08d6d3b9e837fefe73686fa93be6965b3cc30afa8c1e88e0bd2cefebfc129be", + "size": 69004, + "subdir": "linux-64", + "timestamp": 1536076221867, + "version": "0.3.3" + }, + "openblas-devel-0.3.3-2.conda": { + "build": "2", + "build_number": 2, + "depends": [ + "libopenblas 0.3.3 h5a2b251_2", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "8002621852f75d0401e37f7e6848cd11", + "name": "openblas-devel", + "sha256": "e40b89cb92ca029ac993d6a46823cbfaf92a1eeba1e0b68cb17a7d57901e9085", + "size": 73795, + "subdir": "linux-64", + "timestamp": 1536889164288, + "version": "0.3.3" + }, + "openblas-devel-0.3.3-3.conda": { + "build": "3", + "build_number": 3, + "depends": [ + "libopenblas 0.3.3 h5a2b251_3", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "4bf325fbfe02b47b3ce2e0356465785a", + "name": "openblas-devel", + "sha256": "a8e90ab3a0ac459cb59312b465560cdb97ca8012c335567b25f8ca8cc38804a9", + "size": 69789, + "subdir": "linux-64", + "timestamp": 1537472800225, + "version": "0.3.3" + }, + "openblas-devel-0.3.6-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "libopenblas 0.3.6 h5a2b251_0", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "7b6e6825efc2c57db24a72ac29fbfb2c", + "name": "openblas-devel", + "sha256": "00c52e8701ec205619b514e68c5bd6d9daa7064ca9494fd568b03a10ed18f2b7", + "size": 80071, + "subdir": "linux-64", + "timestamp": 1559239838833, + "version": "0.3.6" + }, + "openblas-devel-0.3.6-1.conda": { + "build": "1", + "build_number": 1, + "depends": [ + "libopenblas 0.3.6 h5a2b251_1", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "ac78b8bc8a0f7c3d5c0fd2bac1b1ddee", + "name": "openblas-devel", + "sha256": "8b74909a5ad6ecfcb1c724ac0f286f04edbdf1f99c6be8f0e42832ce38bcf470", + "size": 81080, + "subdir": "linux-64", + "timestamp": 1563464697763, + "version": "0.3.6" + }, + "openblas-devel-0.3.6-2.conda": { + "build": "2", + "build_number": 2, + "depends": [ + "libopenblas 0.3.6 h5a2b251_2", + "nomkl 3.0 0", + "blas * openblas" + ], + "md5": "87b8bfa97a5ddf9ce70f9b43d5fde777", + "name": "openblas-devel", + "sha256": "b729e7ec4a7bbdc8b7efcfed4967dcb5ac8f629b24df81f56f3c5cbc5f760b48", + "size": 81206, + "subdir": "linux-64", + "timestamp": 1573061092520, + "version": "0.3.6" + }, + "opencensus-context-0.1.2-py310h06a4308_4.conda": { + "build": "py310h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "4283fb40f0e1a1f841d2a0df81fe75ed", + "name": "opencensus-context", + "sha256": "f2418d8d0a5c028b25e0a2c3ff419818177eac9c5a2023ab0a4f421785a98e12", + "size": 14082, + "subdir": "linux-64", + "timestamp": 1640792058678, + "version": "0.1.2" + }, + "opencensus-context-0.1.2-py311h06a4308_4.conda": { + "build": "py311h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "md5": "7a312588b37bd29e0a2cffd8b66bf5b0", + "name": "opencensus-context", + "sha256": "2d7228c645482de1bef108acc3a62347e6142fdbb1469b5045d0648d9bf753ce", + "size": 15793, + "subdir": "linux-64", + "timestamp": 1676860081535, + "version": "0.1.2" + }, + "opencensus-context-0.1.2-py36h06a4308_4.conda": { + "build": "py36h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "525977fa859a269e35803038da2cccf6", + "name": "opencensus-context", + "sha256": "fb06b4654cb7022137c81bad6cfdda8e0b57b4f2d8d21b4c7ffb74d9ab4e5b7a", + "size": 15431, + "subdir": "linux-64", + "timestamp": 1621432726614, + "version": "0.1.2" + }, + "opencensus-context-0.1.2-py37h06a4308_4.conda": { + "build": "py37h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "1720646011c7821f0034db01faa6f698", + "name": "opencensus-context", + "sha256": "1273c3019bc7129de4714c51a8ee3ce66255f92217445949220c449f807e04fc", + "size": 15482, + "subdir": "linux-64", + "timestamp": 1621432651704, + "version": "0.1.2" + }, + "opencensus-context-0.1.2-py38h06a4308_4.conda": { + "build": "py38h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "da3a12b389335cb891014845860a7315", + "name": "opencensus-context", + "sha256": "912a558c31ed8cdcc61975b722bc88784b2dd5ba5e9900f133f151391726876f", + "size": 15537, + "subdir": "linux-64", + "timestamp": 1621432715172, + "version": "0.1.2" + }, + "opencensus-context-0.1.2-py39h06a4308_4.conda": { + "build": "py39h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "7585ad98d4b227f149bed1cdef075039", + "name": "opencensus-context", + "sha256": "93b47faef14d212720db48ccdd0d5f026a41bd9bc8129a0ae7f8181690569788", + "size": 15532, + "subdir": "linux-64", + "timestamp": 1621432709715, + "version": "0.1.2" + }, + "opencv-3.3.1-py27h17fce66_0.conda": { + "build": "py27h17fce66_0", + "build_number": 0, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "02fd3a0877f7105031249f62d428e6a7", + "name": "opencv", + "sha256": "6ed687b7101b757fff7b61d0946e8b183409363ed8ac08d6a0c3653ac2f06a57", + "size": 22273475, + "subdir": "linux-64", + "timestamp": 1512494740979, + "version": "3.3.1" + }, + "opencv-3.3.1-py27h61133dd_2.conda": { + "build": "py27h61133dd_2", + "build_number": 2, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "bba352a691bf50b869ab632abf35e332", + "name": "opencv", + "sha256": "884df90be651b339d4bd02d105afadd5072727211d35b8de7813b7c5f8842895", + "size": 22211035, + "subdir": "linux-64", + "timestamp": 1525315569501, + "version": "3.3.1" + }, + "opencv-3.3.1-py27h6cbbc71_1.conda": { + "build": "py27h6cbbc71_1", + "build_number": 1, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6217fb1061e1fde690a5771beea0d948", + "name": "opencv", + "sha256": "d2a5940af66d64a71ddfc39f72075e3e4f5aa5450ea0f763b1d287e7d800b295", + "size": 22212723, + "subdir": "linux-64", + "timestamp": 1512682656517, + "version": "3.3.1" + }, + "opencv-3.3.1-py27h9248ab4_2.conda": { + "build": "py27h9248ab4_2", + "build_number": 2, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ac45cac9fa08b29b343c732945eb90d2", + "name": "opencv", + "sha256": "bff7c37350249428f7940ef8cc849b82d7e670b095cadf4699c73ed238d252e9", + "size": 22213233, + "subdir": "linux-64", + "timestamp": 1525315896087, + "version": "3.3.1" + }, + "opencv-3.3.1-py27h9bb06ff_1.conda": { + "build": "py27h9bb06ff_1", + "build_number": 1, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c0b19427ee1590f21508cd402073170e", + "name": "opencv", + "sha256": "03ca791e62261dee75841d303ef2186466de9e7263fb1eb1cda3237e6b3b60e5", + "size": 22268626, + "subdir": "linux-64", + "timestamp": 1512682684211, + "version": "3.3.1" + }, + "opencv-3.3.1-py27hdcf4849_0.conda": { + "build": "py27hdcf4849_0", + "build_number": 0, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d9adb272c7cfd441aeaaae34ee5fb0df", + "name": "opencv", + "sha256": "0314d97830ac6deb19337fe2fc93760f4c892967ba8c7416d7729feb25ce8f7f", + "size": 22273122, + "subdir": "linux-64", + "timestamp": 1512494698106, + "version": "3.3.1" + }, + "opencv-3.3.1-py35h0b7da17_0.conda": { + "build": "py35h0b7da17_0", + "build_number": 0, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d9e14b312fe25bdc6a3c007da88e52aa", + "name": "opencv", + "sha256": "8d3f97d1da717646cc3cb454beaf34211b00424af6e6628b352a373717017ab2", + "size": 22272793, + "subdir": "linux-64", + "timestamp": 1512494765659, + "version": "3.3.1" + }, + "opencv-3.3.1-py35h61133dd_2.conda": { + "build": "py35h61133dd_2", + "build_number": 2, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ae6e37a8c875fb602436b8f039bbcaf6", + "name": "opencv", + "sha256": "7f9f8e1a268a2caa915eb46ef862249882da7a8b6bdec1cfdab8e011bae22f20", + "size": 22212235, + "subdir": "linux-64", + "timestamp": 1525315399780, + "version": "3.3.1" + }, + "opencv-3.3.1-py35h6cbbc71_1.conda": { + "build": "py35h6cbbc71_1", + "build_number": 1, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6b7c75e258ac0a3bc7d77ee918b201a8", + "name": "opencv", + "sha256": "959a85d213bb0f8fb36adc0f071d7b3d54be7079bc301c774fc5f21ff5a0801c", + "size": 22210072, + "subdir": "linux-64", + "timestamp": 1512682922592, + "version": "3.3.1" + }, + "opencv-3.3.1-py35h9248ab4_2.conda": { + "build": "py35h9248ab4_2", + "build_number": 2, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "90a148259008ef2f8bf592756320dcca", + "name": "opencv", + "sha256": "f2e7c36e48634b087b7004b183f50e61affc6ab6962a0e9c6a94fe551b63d56d", + "size": 22257650, + "subdir": "linux-64", + "timestamp": 1525315574859, + "version": "3.3.1" + }, + "opencv-3.3.1-py35h9bb06ff_1.conda": { + "build": "py35h9bb06ff_1", + "build_number": 1, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "da6aa507b60ef694ec522ffebf91ef61", + "name": "opencv", + "sha256": "f37732da2e8939779d3034766f9883e2f440a538f4549f94ed1442b2867fdc3d", + "size": 22268093, + "subdir": "linux-64", + "timestamp": 1512682916826, + "version": "3.3.1" + }, + "opencv-3.3.1-py35hb7523de_0.conda": { + "build": "py35hb7523de_0", + "build_number": 0, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0499ee0ee9199ce21bc2dc68e99ecba0", + "name": "opencv", + "sha256": "596de54f62738a12c84b6ec2e052a05e3fa5365118870f3d6e9c627f5143f234", + "size": 22221547, + "subdir": "linux-64", + "timestamp": 1512494771435, + "version": "3.3.1" + }, + "opencv-3.3.1-py36h0a11808_0.conda": { + "build": "py36h0a11808_0", + "build_number": 0, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9a1cf68ee49e48ccd5d6932f76a9415d", + "name": "opencv", + "sha256": "8ab32f3cd504017e22fc2428e5bede3146e299e029a29427d8bab56e7db2385e", + "size": 22213222, + "subdir": "linux-64", + "timestamp": 1512494267015, + "version": "3.3.1" + }, + "opencv-3.3.1-py36h0f6f1c3_0.conda": { + "build": "py36h0f6f1c3_0", + "build_number": 0, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5c2a9433ff948411621b98f81db29a9b", + "name": "opencv", + "sha256": "164b22121476159888e14b32c0f8914379d317b370ee6df837c891145233fd92", + "size": 22213572, + "subdir": "linux-64", + "timestamp": 1512494609806, + "version": "3.3.1" + }, + "opencv-3.3.1-py36h61133dd_2.conda": { + "build": "py36h61133dd_2", + "build_number": 2, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9b3f78bfd056fb8ae54e36f1d0e851b4", + "name": "opencv", + "sha256": "2caa2ad736441d15d77c3b7dd10d6a1e17cb9f682c1b6e60faf5c7395a25217a", + "size": 22257234, + "subdir": "linux-64", + "timestamp": 1525315883852, + "version": "3.3.1" + }, + "opencv-3.3.1-py36h6cbbc71_1.conda": { + "build": "py36h6cbbc71_1", + "build_number": 1, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d17f3164dcdd3b97f044ba83261d008f", + "name": "opencv", + "sha256": "56a6d36d948b4fea00d14853118cfa0fd0af76b967c22e3d26336ce598b79340", + "size": 22266758, + "subdir": "linux-64", + "timestamp": 1512688232234, + "version": "3.3.1" + }, + "opencv-3.3.1-py36h9248ab4_2.conda": { + "build": "py36h9248ab4_2", + "build_number": 2, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=2.0.14,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dc862cf958cd1bdbfc32f5531f525666", + "name": "opencv", + "sha256": "b8d75e3738999075929cef26096b3c769a60f2fbafe4c25811aa2f3aedb9dea7", + "size": 22257453, + "subdir": "linux-64", + "timestamp": 1525315846671, + "version": "3.3.1" + }, + "opencv-3.3.1-py36h9bb06ff_1.conda": { + "build": "py36h9bb06ff_1", + "build_number": 1, + "depends": [ + "ffmpeg >=3.4,<3.5.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=1.900.1,<2.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7c2b463778d730aca791371fe4268292", + "name": "opencv", + "sha256": "e6d07bbaf6be0655795d57c005697cb917f6f2b9fbcd2cf86825dee25dd4e28a", + "size": 22209292, + "subdir": "linux-64", + "timestamp": 1512682624333, + "version": "3.3.1" + }, + "opencv-3.4.1-py27h40b0b35_1.conda": { + "build": "py27h40b0b35_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ef02782d80564ba780bded7a8d0a0874", + "name": "opencv", + "sha256": "1e4dc2f460e3b05744707a3766471895eff9b80feb83498f894a59fe01371231", + "size": 7224, + "subdir": "linux-64", + "timestamp": 1527006897288, + "version": "3.4.1" + }, + "opencv-3.4.1-py27h40b0b35_2.conda": { + "build": "py27h40b0b35_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "py-opencv 3.4.1 py27hf78e8e8_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e7c1df2c7f8fad879980edf0d1d8252d", + "name": "opencv", + "sha256": "a87cc5ba3969a0df6bab8c38d2112f65a4a50e9ba5737fb11ef337ddb8d8b099", + "size": 7264, + "subdir": "linux-64", + "timestamp": 1527006897288, + "version": "3.4.1" + }, + "opencv-3.4.1-py27h40b0b35_3.conda": { + "build": "py27h40b0b35_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "py-opencv 3.4.1 py27he6673a0_3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a80d252c973cce2fe62c7c2f3ca95649", + "name": "opencv", + "sha256": "e1d2a4885a4fd75803e9dcf52e8008dae08ed12db29a60c920ff2933c204fed2", + "size": 7760, + "subdir": "linux-64", + "timestamp": 1530792749940, + "version": "3.4.1" + }, + "opencv-3.4.1-py27h6fd60c2_1.conda": { + "build": "py27h6fd60c2_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "75692a5b180e0f5d70ceb4eea1374eb9", + "name": "opencv", + "sha256": "9b7ae250d49023d7f203506f836cd874cc2a0e051844c6450b99696267b99e97", + "size": 7246, + "subdir": "linux-64", + "timestamp": 1527005982683, + "version": "3.4.1" + }, + "opencv-3.4.1-py27h6fd60c2_2.conda": { + "build": "py27h6fd60c2_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.1 py27h0676e08_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1b387e037822168d58bcc0be0235de18", + "name": "opencv", + "sha256": "cb524a41f3ce4069165b1dbe955cc77e9a3a20ba2a8d254ee20003beec7e54c7", + "size": 7233, + "subdir": "linux-64", + "timestamp": 1527005982683, + "version": "3.4.1" + }, + "opencv-3.4.1-py27h6fd60c2_3.conda": { + "build": "py27h6fd60c2_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.1 py27h8fa1ad8_3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a7152ed8d11cec6b3bed5a4190e4710b", + "name": "opencv", + "sha256": "ef49bffaa2c0b9d9ee3e7d834e1cf94da4ed37c9f114b072db3f664b13c4b753", + "size": 7778, + "subdir": "linux-64", + "timestamp": 1530791079672, + "version": "3.4.1" + }, + "opencv-3.4.1-py35h40b0b35_1.conda": { + "build": "py35h40b0b35_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a98ca20477f69d90b7d9821c6ae69d45", + "name": "opencv", + "sha256": "7b30a735d4f2a12f78504de918bb479dd5b3097e602111eef0bd44b4db3be7f1", + "size": 7222, + "subdir": "linux-64", + "timestamp": 1527006917343, + "version": "3.4.1" + }, + "opencv-3.4.1-py35h40b0b35_2.conda": { + "build": "py35h40b0b35_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "py-opencv 3.4.1 py35hf78e8e8_1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6cb217c782d2df3afa4a03d8534a9cc1", + "name": "opencv", + "sha256": "8de5ed08a1c435076478492834c262d5eb913f9c0ad580028b421f5eaff214aa", + "size": 7231, + "subdir": "linux-64", + "timestamp": 1527006917343, + "version": "3.4.1" + }, + "opencv-3.4.1-py35h6fd60c2_1.conda": { + "build": "py35h6fd60c2_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b3d7ccec2c0d610b94a830bd8e31b87f", + "name": "opencv", + "sha256": "d765e0e74a15938a2f8b4b52af0c695bf586d1de3536afd4e7e5ed87e2afa99c", + "size": 7215, + "subdir": "linux-64", + "timestamp": 1527006004741, + "version": "3.4.1" + }, + "opencv-3.4.1-py35h6fd60c2_2.conda": { + "build": "py35h6fd60c2_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.1 py35h0676e08_1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7bc4c12017382d495ef18821e97edb89", + "name": "opencv", + "sha256": "0a9132a655601a67b4a968eb1610ca8f32d0eaa5d39ee67b35b93f1aa32fe7db", + "size": 7256, + "subdir": "linux-64", + "timestamp": 1527006004741, + "version": "3.4.1" + }, + "opencv-3.4.1-py36h40b0b35_1.conda": { + "build": "py36h40b0b35_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ffe6c8abe1c0e1219aa1fba6879e3afe", + "name": "opencv", + "sha256": "b8c3ea0ecb6b4a3b45aab4bd101c89dec280d5af8741ea66f02bd17a75b667be", + "size": 7238, + "subdir": "linux-64", + "timestamp": 1527006937301, + "version": "3.4.1" + }, + "opencv-3.4.1-py36h40b0b35_2.conda": { + "build": "py36h40b0b35_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "py-opencv 3.4.1 py36hf78e8e8_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8fe841cfcd50338959d41f29134a04a1", + "name": "opencv", + "sha256": "2bc31d8b6b5eb5e44948afcaee3f87e6066cee9cd5d5c4a0b763a1f2be8ec82d", + "size": 7222, + "subdir": "linux-64", + "timestamp": 1527006937301, + "version": "3.4.1" + }, + "opencv-3.4.1-py36h40b0b35_3.conda": { + "build": "py36h40b0b35_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "py-opencv 3.4.1 py36he6673a0_3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6ddba8ed5a957764eac947d1230d2b62", + "name": "opencv", + "sha256": "b307efdd616347a70c4afbab72079b940dc64125079b7c0b12fd47b7e6e44253", + "size": 7768, + "subdir": "linux-64", + "timestamp": 1530792763321, + "version": "3.4.1" + }, + "opencv-3.4.1-py36h6fd60c2_1.conda": { + "build": "py36h6fd60c2_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "bf7d27ae24d9f5d8980df6bf00dc5beb", + "name": "opencv", + "sha256": "74107496a8d2c206d9d26f05699b1ce82f61d2e0e2a5894b8c296a833aad9888", + "size": 7245, + "subdir": "linux-64", + "timestamp": 1527006026877, + "version": "3.4.1" + }, + "opencv-3.4.1-py36h6fd60c2_2.conda": { + "build": "py36h6fd60c2_2", + "build_number": 2, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.1 py36h0676e08_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "206d64c3f74b39828dbcfdc400176132", + "name": "opencv", + "sha256": "83ebd8f2ec3ff95dcfe0c77c3746c3f043d12d7df16922d8a1c70c3c9ffa3b57", + "size": 7230, + "subdir": "linux-64", + "timestamp": 1527006026877, + "version": "3.4.1" + }, + "opencv-3.4.1-py36h6fd60c2_3.conda": { + "build": "py36h6fd60c2_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.1 py36h8fa1ad8_3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "66f09525e1f07ebf798fa033ef918380", + "name": "opencv", + "sha256": "72da19d09da13891a95b5a2a5f26cd96cd93e7b89acf502271876d97279174f5", + "size": 7770, + "subdir": "linux-64", + "timestamp": 1530791092728, + "version": "3.4.1" + }, + "opencv-3.4.1-py37h40b0b35_3.conda": { + "build": "py37h40b0b35_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.8.18,<1.8.19.0a0", + "py-opencv 3.4.1 py37he6673a0_3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b9fb8d113f49f5ae88ff09bf0357edb0", + "name": "opencv", + "sha256": "eba96ac85f7bb0db62e5717b3b538b269622800ae9db885fa37f6299417714cf", + "size": 7756, + "subdir": "linux-64", + "timestamp": 1530792776415, + "version": "3.4.1" + }, + "opencv-3.4.1-py37h6fd60c2_3.conda": { + "build": "py37h6fd60c2_3", + "build_number": 3, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.1 py37h8fa1ad8_3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "05167de9a308c03cb4ee09c37b247883", + "name": "opencv", + "sha256": "5da36a131309e0f7a82e4870357c4c841ea8d299c6a1051939e6d7e0745f6b21", + "size": 7780, + "subdir": "linux-64", + "timestamp": 1530791106090, + "version": "3.4.1" + }, + "opencv-3.4.2-py27h40b0b35_0.conda": { + "build": "py27h40b0b35_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "py-opencv 3.4.2 py27he6673a0_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ebda2f4860f382ccabdee19f069e6ac5", + "name": "opencv", + "sha256": "efbbedf301567de014a0f418509d1fe78e696d60ff08ec2f79a642d9c3242f45", + "size": 10182, + "subdir": "linux-64", + "timestamp": 1533644313336, + "version": "3.4.2" + }, + "opencv-3.4.2-py27h40b0b35_1.conda": { + "build": "py27h40b0b35_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "py-opencv 3.4.2 py27h765d7f9_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cca15cb904e3ed452a8af26b3e38dc93", + "name": "opencv", + "sha256": "256091690ce55a2cdc6bf26cc6fcbe4d9da49a0197b422dda5e2cb8bce08242e", + "size": 10947, + "subdir": "linux-64", + "timestamp": 1535562135112, + "version": "3.4.2" + }, + "opencv-3.4.2-py27h6fd60c2_0.conda": { + "build": "py27h6fd60c2_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.2 py27h8fa1ad8_0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7bf06351db2d5882499b29a624f6c04b", + "name": "opencv", + "sha256": "557093d7048d77c99df80fc9af1cff4f11dc6a18728c8cffe8e8d7c89dc27b60", + "size": 10189, + "subdir": "linux-64", + "timestamp": 1533642756899, + "version": "3.4.2" + }, + "opencv-3.4.2-py27h6fd60c2_1.conda": { + "build": "py27h6fd60c2_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.2 py27hb342d67_1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "15ca39dc34e1148542d18f2ba6b50686", + "name": "opencv", + "sha256": "3a30d558635b86e92a53cbca221d82bb244455ed43f25a7eada42482bc702093", + "size": 10908, + "subdir": "linux-64", + "timestamp": 1535562153929, + "version": "3.4.2" + }, + "opencv-3.4.2-py35h40b0b35_0.conda": { + "build": "py35h40b0b35_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "py-opencv 3.4.2 py35he6673a0_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d74b73c523cb67a845b2687e65db456a", + "name": "opencv", + "sha256": "73d3178cf0a89e7c8a9da7865b7c348b2f4c63c521d9baa9169108fe3235ed05", + "size": 10146, + "subdir": "linux-64", + "timestamp": 1533644338585, + "version": "3.4.2" + }, + "opencv-3.4.2-py35h40b0b35_1.conda": { + "build": "py35h40b0b35_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "py-opencv 3.4.2 py35h765d7f9_1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "addb7c8bc714742d22c07b20721b3943", + "name": "opencv", + "sha256": "241fae23191739487c410b7562b0d993b4be5b2e656ea4c57fa9ba086405c62b", + "size": 10898, + "subdir": "linux-64", + "timestamp": 1535562154008, + "version": "3.4.2" + }, + "opencv-3.4.2-py35h6fd60c2_0.conda": { + "build": "py35h6fd60c2_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.2 py35h8fa1ad8_0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4244f68ee3ce2811cd965a26717a6b86", + "name": "opencv", + "sha256": "a36b80e8b32d7e379c31f470a7214dc245d94913d00ece6bcc59a9468c746361", + "size": 10150, + "subdir": "linux-64", + "timestamp": 1533642780993, + "version": "3.4.2" + }, + "opencv-3.4.2-py35h6fd60c2_1.conda": { + "build": "py35h6fd60c2_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.2 py35hb342d67_1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "990395f54d54108a74be44b635231d2a", + "name": "opencv", + "sha256": "f881a3346601954a39d2e592a6693162b340978c03945ed4cd736afe6efbf25c", + "size": 10892, + "subdir": "linux-64", + "timestamp": 1535562135510, + "version": "3.4.2" + }, + "opencv-3.4.2-py36h40b0b35_0.conda": { + "build": "py36h40b0b35_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "py-opencv 3.4.2 py36he6673a0_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "43cedc2677c8af0e06bcec18711494a0", + "name": "opencv", + "sha256": "0dfa5eb7eed6688d5043f0b3562daaf5d634cbc8fa1ff7881cd5a25869e5fad0", + "size": 10169, + "subdir": "linux-64", + "timestamp": 1533644389237, + "version": "3.4.2" + }, + "opencv-3.4.2-py36h40b0b35_1.conda": { + "build": "py36h40b0b35_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "py-opencv 3.4.2 py36h765d7f9_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "740c602743f55f55f631a5af63d4f28b", + "name": "opencv", + "sha256": "da6d58b9aa445ddd1868ae892c629ac359a43aa820a65bd9bcd388f043dbaaae", + "size": 10945, + "subdir": "linux-64", + "timestamp": 1535562175449, + "version": "3.4.2" + }, + "opencv-3.4.2-py36h6fd60c2_0.conda": { + "build": "py36h6fd60c2_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.2 py36h8fa1ad8_0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c52de7b35cbf185a1cd9ed69d4492140", + "name": "opencv", + "sha256": "5806df79dd658ea1055df075c83764b9aec37f3ed4e634bb580e7ee4988d132c", + "size": 10124, + "subdir": "linux-64", + "timestamp": 1533642829270, + "version": "3.4.2" + }, + "opencv-3.4.2-py36h6fd60c2_1.conda": { + "build": "py36h6fd60c2_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.2 py36hb342d67_1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "05ada27cac3ad6ea1a2539429dfa212e", + "name": "opencv", + "sha256": "9888443435bc79bf82c18d7e48393f382d29095eff12ebd4373082a5b1e89b8e", + "size": 10942, + "subdir": "linux-64", + "timestamp": 1535562175359, + "version": "3.4.2" + }, + "opencv-3.4.2-py37h40b0b35_0.conda": { + "build": "py37h40b0b35_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "py-opencv 3.4.2 py37he6673a0_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9b7b774e6d2007716228f2a9285a5457", + "name": "opencv", + "sha256": "76a8c311c6e87de2cb0ecbf9cf36bdb4640325f322363037c98ce64875c98bcf", + "size": 10148, + "subdir": "linux-64", + "timestamp": 1533644363950, + "version": "3.4.2" + }, + "opencv-3.4.2-py37h40b0b35_1.conda": { + "build": "py37h40b0b35_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.8.20,<1.9.0a0", + "py-opencv 3.4.2 py37h765d7f9_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a6ad492852b898296df51e2dd666cca6", + "name": "opencv", + "sha256": "d408d30749c5769239cd4314292374256cad5b2d744c36e9227f0ad543ebe2dc", + "size": 10906, + "subdir": "linux-64", + "timestamp": 1535562198809, + "version": "3.4.2" + }, + "opencv-3.4.2-py37h6fd60c2_0.conda": { + "build": "py37h6fd60c2_0", + "build_number": 0, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.2 py37h8fa1ad8_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "eca43200e6d7e0085b0e838600f22f8f", + "name": "opencv", + "sha256": "b8f8dd89671ef82a97f7e9a65f7443910c8909cf11a989645fa9e6fb8d54c188", + "size": 10139, + "subdir": "linux-64", + "timestamp": 1533642805044, + "version": "3.4.2" + }, + "opencv-3.4.2-py37h6fd60c2_1.conda": { + "build": "py37h6fd60c2_1", + "build_number": 1, + "depends": [ + "hdf5 >=1.10.2,<1.10.3.0a0", + "py-opencv 3.4.2 py37hb342d67_1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "bbd9e977d0c9d26cd529f551b5ebf803", + "name": "opencv", + "sha256": "3a1018e9b77e482799f83a4e78d77c26444230fee307b397fc27f839fe720c39", + "size": 10945, + "subdir": "linux-64", + "timestamp": 1535562198646, + "version": "3.4.2" + }, + "opencv-4.5.4-py310h15b3d91_1.conda": { + "build": "py310h15b3d91_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "numpy 1.21.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5c4f60c2d93071e2ad7aa806efedb947", + "name": "opencv", + "sha256": "8a505956ebde37f8e4746c5dc4dde2f6fde1de4986e29df0d377c4024021c346", + "size": 26940461, + "subdir": "linux-64", + "timestamp": 1647367605599, + "version": "4.5.4" + }, + "opencv-4.5.4-py310h3dbb160_2.conda": { + "build": "py310h3dbb160_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.21.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2d748ed92ed159c81be0f73cc8dafc64", + "name": "opencv", + "sha256": "b8081b4c54c66aa79d63de803db27a87d8f6f96a6d9b4caf8b6ee8489e7c1e0a", + "size": 26978577, + "subdir": "linux-64", + "timestamp": 1648815666835, + "version": "4.5.4" + }, + "opencv-4.5.4-py310h3dbb160_3.conda": { + "build": "py310h3dbb160_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.21.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "348cf3463ca3c33a057df928047a6ecb", + "name": "opencv", + "sha256": "5934900b8b8b9bdd67c60491cf89731fee9384fca2166f9f71bf4df475cd11eb", + "size": 26879314, + "subdir": "linux-64", + "timestamp": 1648891298823, + "version": "4.5.4" + }, + "opencv-4.5.4-py37h7f95952_1.conda": { + "build": "py37h7f95952_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2f66aea999d1349adf925eae099817a7", + "name": "opencv", + "sha256": "566caa1c878201624e54b35fa24dc0550d9fb5d6c8734e8cbd596d82d9805978", + "size": 26931385, + "subdir": "linux-64", + "timestamp": 1647369750936, + "version": "4.5.4" + }, + "opencv-4.5.4-py37hbeebcbe_2.conda": { + "build": "py37hbeebcbe_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "80595935b9e0b3620a62fe5e08e9bfa3", + "name": "opencv", + "sha256": "d01697989ab40f589b7b69f8436e52f7ad74f9969464d4aa51fc63bc636b2f4b", + "size": 26952653, + "subdir": "linux-64", + "timestamp": 1648833791234, + "version": "4.5.4" + }, + "opencv-4.5.4-py37hbeebcbe_3.conda": { + "build": "py37hbeebcbe_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a95dbc64b161f4b938234c0287a7517c", + "name": "opencv", + "sha256": "19eeb3bdb6ec6f277c4dc642f12c3a57197b0d2368c8310a072a7d590aaedab5", + "size": 26950898, + "subdir": "linux-64", + "timestamp": 1648891342337, + "version": "4.5.4" + }, + "opencv-4.5.4-py38h7f95952_1.conda": { + "build": "py38h7f95952_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b32025736bbe8bdcd28cee8cf098fa27", + "name": "opencv", + "sha256": "f17b3319d7152b38eb784fe08a6c897160a60320d5cf13559c45c8f3bb612ae5", + "size": 26877537, + "subdir": "linux-64", + "timestamp": 1647368488365, + "version": "4.5.4" + }, + "opencv-4.5.4-py38hbeebcbe_2.conda": { + "build": "py38hbeebcbe_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "145412048ea5acefcecd0889e843b178", + "name": "opencv", + "sha256": "76d5699ab5d9e1577a971bc259c498d6146ffd81c4b6e93c63c3107fdfd80cf0", + "size": 26952277, + "subdir": "linux-64", + "timestamp": 1648815890308, + "version": "4.5.4" + }, + "opencv-4.5.4-py38hbeebcbe_3.conda": { + "build": "py38hbeebcbe_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "380f6ad19e34734511e5c7b393f4cd64", + "name": "opencv", + "sha256": "128701fe1cccb00789f904381b2786c31494ed40d368c2d8fbfc945cea795c7b", + "size": 26967590, + "subdir": "linux-64", + "timestamp": 1648873187215, + "version": "4.5.4" + }, + "opencv-4.5.4-py39h7f95952_1.conda": { + "build": "py39h7f95952_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1de4d6d3259770e2997a8ee05e4bf812", + "name": "opencv", + "sha256": "ba95d33402146ae4734210db90c48588cc0a74ef470e463a58a7154af817c0ae", + "size": 26933004, + "subdir": "linux-64", + "timestamp": 1647366707123, + "version": "4.5.4" + }, + "opencv-4.5.4-py39hbeebcbe_2.conda": { + "build": "py39hbeebcbe_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b247753da9a93cbf8e1f94d3fa850556", + "name": "opencv", + "sha256": "9292df5295bdd5869d116dde507691269729d2fb04832516de67969610a793cb", + "size": 26967807, + "subdir": "linux-64", + "timestamp": 1648833805801, + "version": "4.5.4" + }, + "opencv-4.5.4-py39hbeebcbe_3.conda": { + "build": "py39hbeebcbe_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=4.5", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.17,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf 3.5.1", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1a611f432d7e10b8962bca0ca12c6a9c", + "name": "opencv", + "sha256": "abfa12f367ff88845f13d9642174f24639135c7ddaf5b089d2c3a8fd9f83f91c", + "size": 26910180, + "subdir": "linux-64", + "timestamp": 1648873442169, + "version": "4.5.4" + }, + "opencv-4.5.5-py310h496257e_3.conda": { + "build": "py310h496257e_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.21.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cef646ec06dad83e1800a6684375f6d8", + "name": "opencv", + "sha256": "8284d61863ec13c1c02997cec912ebe349388ccd6a4dfa9f34c3f4e358310f61", + "size": 27828996, + "subdir": "linux-64", + "timestamp": 1656607995829, + "version": "4.5.5" + }, + "opencv-4.5.5-py310h496257e_4.conda": { + "build": "py310h496257e_4", + "build_number": 4, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.21.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt-main >=5.15,<6", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.7,<6", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f428cd8c9ac96ed6b2946e65d6384424", + "name": "opencv", + "sha256": "b257079f82b631e3a147750e332bfb250ba4934f456d8d90dc2260c364c6e1a2", + "size": 27852847, + "subdir": "linux-64", + "timestamp": 1659979471169, + "version": "4.5.5" + }, + "opencv-4.5.5-py310hd7713a7_2.conda": { + "build": "py310hd7713a7_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.21.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8b74fdf030426c84d44868fcb1ab617e", + "name": "opencv", + "sha256": "dda7653396ba8ac95346c71f8553e76fc77019ffba0603e974d73de190879078", + "size": 27832573, + "subdir": "linux-64", + "timestamp": 1656001417112, + "version": "4.5.5" + }, + "opencv-4.5.5-py310hf7f654e_0.conda": { + "build": "py310hf7f654e_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.18,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.21.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "59a7b8054635eed4140987a287d838cc", + "name": "opencv", + "sha256": "83f994f89dd9822172ed30caf6333c3207f10cee6880847241dde99439630d5e", + "size": 27450883, + "subdir": "linux-64", + "timestamp": 1652958456683, + "version": "4.5.5" + }, + "opencv-4.5.5-py310hf7f654e_1.conda": { + "build": "py310hf7f654e_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.21.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "051db4612cc6526a1dc458f00a2a97ed", + "name": "opencv", + "sha256": "896a2324c3ca702ec8038279e4e2248053eb353d64975c306140a251afbf5b90", + "size": 27454713, + "subdir": "linux-64", + "timestamp": 1655910131926, + "version": "4.5.5" + }, + "opencv-4.5.5-py37h1ca2c5e_3.conda": { + "build": "py37h1ca2c5e_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6d7123b28b20ba269ef8b6c5b1163304", + "name": "opencv", + "sha256": "c0e8870db8d4bbe4333a563c3c1f070805367a2db0e424b3df84318a203c69a5", + "size": 27815410, + "subdir": "linux-64", + "timestamp": 1656607291090, + "version": "4.5.5" + }, + "opencv-4.5.5-py37h1ca2c5e_4.conda": { + "build": "py37h1ca2c5e_4", + "build_number": 4, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt-main >=5.15,<6", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.7,<6", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "510ad3e346fa66ddc12488ee03019f4c", + "name": "opencv", + "sha256": "c2ca3d8ba77a50872ed2af64a822028e02198a75cb3dad31239fb3358fb8fdd4", + "size": 27838866, + "subdir": "linux-64", + "timestamp": 1659978027699, + "version": "4.5.5" + }, + "opencv-4.5.5-py37h905f02f_0.conda": { + "build": "py37h905f02f_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.18,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "63115921b874578ba79d4f7603c495f6", + "name": "opencv", + "sha256": "b2c6e2abb949bdabaae5291cf97408c3b5f147323edf1ef69466753161a20bb3", + "size": 27458753, + "subdir": "linux-64", + "timestamp": 1652956655549, + "version": "4.5.5" + }, + "opencv-4.5.5-py37h905f02f_1.conda": { + "build": "py37h905f02f_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f761000f3a165bbb2b0047fbdb00d52b", + "name": "opencv", + "sha256": "c0437951890abf3714170d9f35a560fe5e54ae6eec1e17604ae144836babfd06", + "size": 27450524, + "subdir": "linux-64", + "timestamp": 1655908945619, + "version": "4.5.5" + }, + "opencv-4.5.5-py37ha5a2927_2.conda": { + "build": "py37ha5a2927_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2e0b52e1dfd8308c2998eada412b053b", + "name": "opencv", + "sha256": "93565113cc55346df91b6235ceb8686e62cddff54c61f5284dc021460ab05b77", + "size": 27826958, + "subdir": "linux-64", + "timestamp": 1656000357038, + "version": "4.5.5" + }, + "opencv-4.5.5-py38h1ca2c5e_3.conda": { + "build": "py38h1ca2c5e_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bf48b2aa326480db4003533ec3c90ff9", + "name": "opencv", + "sha256": "5067a1e93d8bd98a6e66b12afdc61b6c4fe9646c6057e702924eea3049bb75d0", + "size": 27821203, + "subdir": "linux-64", + "timestamp": 1656608704410, + "version": "4.5.5" + }, + "opencv-4.5.5-py38h1ca2c5e_4.conda": { + "build": "py38h1ca2c5e_4", + "build_number": 4, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt-main >=5.15,<6", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.7,<6", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d82e9144414dfe4d3dbbe75bd6a288a9", + "name": "opencv", + "sha256": "51263ddca8ebc402716e1dee799fe4e9484b4d890152aef62b2864145915599c", + "size": 27846382, + "subdir": "linux-64", + "timestamp": 1659976576164, + "version": "4.5.5" + }, + "opencv-4.5.5-py38h905f02f_0.conda": { + "build": "py38h905f02f_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.18,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "635697715949370d0f44048756c0e96f", + "name": "opencv", + "sha256": "258dc759a554f2b2f861e35ed8e4ed0beaf0eae9ca4ab89eefc618b4a6043fff", + "size": 27453140, + "subdir": "linux-64", + "timestamp": 1652957868579, + "version": "4.5.5" + }, + "opencv-4.5.5-py38h905f02f_1.conda": { + "build": "py38h905f02f_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4563fc7de71ed3e125c0380651c8c965", + "name": "opencv", + "sha256": "88369b82778b059c456b7cf0c37edb01e79cc37fee027adcdbff333e22ab20fd", + "size": 27454723, + "subdir": "linux-64", + "timestamp": 1655908283048, + "version": "4.5.5" + }, + "opencv-4.5.5-py38ha5a2927_2.conda": { + "build": "py38ha5a2927_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bf4f22fd087ef6a4fdb73d59f37abd78", + "name": "opencv", + "sha256": "96ef48b8e274b4ede2f5d88b7c74206db07edd5deca775481c006ad7d923b9be", + "size": 27822475, + "subdir": "linux-64", + "timestamp": 1656003300384, + "version": "4.5.5" + }, + "opencv-4.5.5-py39h1ca2c5e_3.conda": { + "build": "py39h1ca2c5e_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cd7385b1faf0df2e3bf69b0f6a0a5088", + "name": "opencv", + "sha256": "717510ca2bc0308273a9102380f6f2e435de78c5a9d1e31b51694d66aeab1c89", + "size": 27826279, + "subdir": "linux-64", + "timestamp": 1656609367575, + "version": "4.5.5" + }, + "opencv-4.5.5-py39h1ca2c5e_4.conda": { + "build": "py39h1ca2c5e_4", + "build_number": 4, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt-main >=5.15,<6", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.7,<6", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0fccea221d98d1a03ed6ad7c8c19e393", + "name": "opencv", + "sha256": "9187951b2d6e642d608717c3f4b3a2f18ac0404f27d8f59293096b66888c16d7", + "size": 27848189, + "subdir": "linux-64", + "timestamp": 1659975074509, + "version": "4.5.5" + }, + "opencv-4.5.5-py39h905f02f_0.conda": { + "build": "py39h905f02f_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.18,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "57c2a2d527f738ac1979547cf00e741a", + "name": "opencv", + "sha256": "13088acf6e53fce4a5d42b3a99c181e4fa32dbcc0a7f46c835c9bddf9631f76c", + "size": 27451728, + "subdir": "linux-64", + "timestamp": 1652957283086, + "version": "4.5.5" + }, + "opencv-4.5.5-py39h905f02f_1.conda": { + "build": "py39h905f02f_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6d631733091cfdb6b90741d703690d91", + "name": "opencv", + "sha256": "9883f6918baf307445ece3caf135b3ce83c9aea567f9bb645b6c5b0cfd0368ba", + "size": 27453111, + "subdir": "linux-64", + "timestamp": 1655909536144, + "version": "4.5.5" + }, + "opencv-4.5.5-py39ha5a2927_2.conda": { + "build": "py39ha5a2927_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy 1.16.*", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt 5.9.7", + "qt >=5.9.7,<5.10.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "73cd14b0857b267dfa9df47f63f34924", + "name": "opencv", + "sha256": "ded6dac7bb68a388f86ae2326f84d8762390a2260c13aa6a5b755d0356199f7a", + "size": 27827205, + "subdir": "linux-64", + "timestamp": 1656002366809, + "version": "4.5.5" + }, + "opencv-4.6.0-py310h1128e8f_3.conda": { + "build": "py310h1128e8f_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen >=3.3.7", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy >=1.21,<2", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt-main >=5.15,<6", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.7,<6", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "06d2e57e585745be01a613b45d694729", + "name": "opencv", + "sha256": "3cc8bd0d31dacc85500c77d85f563e9ed8ae9b46d466ac9ff23af834326abbdc", + "size": 33951229, + "subdir": "linux-64", + "timestamp": 1676456401234, + "version": "4.6.0" + }, + "opencv-4.6.0-py310hefb4dc4_0.conda": { + "build": "py310hefb4dc4_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7d3f75c59e4a4fc5fe5eb9c9b6d45f28", + "name": "opencv", + "sha256": "78d11c677dc9fc787c06a766cd88c692708f7eb41074d2fab2ea13a09999e652", + "size": 28023829, + "subdir": "linux-64", + "timestamp": 1663875553489, + "version": "4.6.0" + }, + "opencv-4.6.0-py310hefb4dc4_1.conda": { + "build": "py310hefb4dc4_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a2be23c0de23634b51754d539168c079", + "name": "opencv", + "sha256": "83cd158f81a6a9e0d3eef80b86a8e3d8536c73a1ce4e586cc469aae05052acba", + "size": 28092909, + "subdir": "linux-64", + "timestamp": 1664377432589, + "version": "4.6.0" + }, + "opencv-4.6.0-py310hefb4dc4_2.conda": { + "build": "py310hefb4dc4_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.10,<3.11.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "08bedcd08f07a8f4eb9e05f996aa7d4e", + "name": "opencv", + "sha256": "c8833928484149bd3ff70a481cd8e84072c84a2e2dab5c9e9cb6a1038dd654b3", + "size": 28105235, + "subdir": "linux-64", + "timestamp": 1664553442251, + "version": "4.6.0" + }, + "opencv-4.6.0-py311hba01205_3.conda": { + "build": "py311hba01205_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen >=3.3.7", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy >=1.22,<2", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.11,<3.12.0a0", + "qt-main >=5.15,<6", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.7,<6", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "776b74d4ac8210caba3bdc2717338bf4", + "name": "opencv", + "sha256": "4cd4f46b66147252e40eb97ff5a920ac90f57035721a6eb8b0543e1e1f95104b", + "size": 29762125, + "subdir": "linux-64", + "timestamp": 1676838441014, + "version": "4.6.0" + }, + "opencv-4.6.0-py37h417a72b_3.conda": { + "build": "py37h417a72b_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen >=3.3.7", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy >=1.16,<2", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt-main >=5.15,<6", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.7,<6", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aa6a9d149afde9c511a63586e7d0935b", + "name": "opencv", + "sha256": "8cd1cfdec004188316b7530bdde2f9afc9f5daf20c8144492fe5182fdf64e209", + "size": 33933780, + "subdir": "linux-64", + "timestamp": 1676454953747, + "version": "4.6.0" + }, + "opencv-4.6.0-py37hd653453_0.conda": { + "build": "py37hd653453_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "db3fefd7b1d7240fe80afa7a01798ff1", + "name": "opencv", + "sha256": "efb10d5977b6a752c025d3d557c38fded6078b27b73d90d51ca59216b3f19ebb", + "size": 28026065, + "subdir": "linux-64", + "timestamp": 1663873983878, + "version": "4.6.0" + }, + "opencv-4.6.0-py37hd653453_1.conda": { + "build": "py37hd653453_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bdd0d7a44c1cac803c26364fbaf9ab7f", + "name": "opencv", + "sha256": "dbadbc5c051b91a2667b573e88c91ee6062ed712aede3e38f35b52155d5e9a00", + "size": 28085825, + "subdir": "linux-64", + "timestamp": 1664372632937, + "version": "4.6.0" + }, + "opencv-4.6.0-py37hd653453_2.conda": { + "build": "py37hd653453_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "836ef8d7d30050069ad41ebf2553f3ab", + "name": "opencv", + "sha256": "1b23aa6e8eba0f08f2b7794141c3d07c2304a69038b9968766b0b8d09bfb797d", + "size": 28096353, + "subdir": "linux-64", + "timestamp": 1664551770288, + "version": "4.6.0" + }, + "opencv-4.6.0-py38h417a72b_3.conda": { + "build": "py38h417a72b_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen >=3.3.7", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy >=1.16,<2", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt-main >=5.15,<6", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.7,<6", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b6bebc9ec3e3c76f299a4791af5e5ee6", + "name": "opencv", + "sha256": "1c21dd9a4bb8921c9f7048e4133209e9efe5ea8588be1d97eb9cbc3bc2cd36bc", + "size": 33938079, + "subdir": "linux-64", + "timestamp": 1676453464489, + "version": "4.6.0" + }, + "opencv-4.6.0-py38hd653453_0.conda": { + "build": "py38hd653453_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2308d5965ef8ed10aecb909403742512", + "name": "opencv", + "sha256": "e46182198def61e0559eac012c48d8a0d573d32c9356d58865fbe0e739500f6d", + "size": 28025164, + "subdir": "linux-64", + "timestamp": 1663878510122, + "version": "4.6.0" + }, + "opencv-4.6.0-py38hd653453_1.conda": { + "build": "py38hd653453_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "09485f8928ceb70bc01fe73260b92e21", + "name": "opencv", + "sha256": "45d2aca652b62873e64387571dcc696054ff746b7f61efc602d687f767d89c08", + "size": 28090017, + "subdir": "linux-64", + "timestamp": 1664375863510, + "version": "4.6.0" + }, + "opencv-4.6.0-py38hd653453_2.conda": { + "build": "py38hd653453_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a41050f106e03cf33759f9b34ed39987", + "name": "opencv", + "sha256": "3d70b91f9214c4cb8b257d88695a42090f50ce4bd74087c54343008364cc1a2b", + "size": 28102261, + "subdir": "linux-64", + "timestamp": 1664555102998, + "version": "4.6.0" + }, + "opencv-4.6.0-py39h417a72b_3.conda": { + "build": "py39h417a72b_3", + "build_number": 3, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen >=3.3.7", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy >=1.16,<2", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt-main >=5.15,<6", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.7,<6", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8795741e05b83402b4ea77409e3d4dad", + "name": "opencv", + "sha256": "666a02c61102dd233b597ff974999d58682cbbd2c78b7bc2418b4c55cd96d753", + "size": 33949214, + "subdir": "linux-64", + "timestamp": 1676457842931, + "version": "4.6.0" + }, + "opencv-4.6.0-py39hd653453_0.conda": { + "build": "py39hd653453_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "23cd9f050f40e01d58ac8851c22d9609", + "name": "opencv", + "sha256": "7bd9a20da023031747181b7f8082d54cb274535150f83d42982ae421c3bc589e", + "size": 28021553, + "subdir": "linux-64", + "timestamp": 1663877058409, + "version": "4.6.0" + }, + "opencv-4.6.0-py39hd653453_1.conda": { + "build": "py39hd653453_1", + "build_number": 1, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "641120b9254f8094a9dec7cc60ae373a", + "name": "opencv", + "sha256": "17c4763b41b6d151ec45d0d8394d42b94fdfaf1dfc46c52996f2b29f121d41c7", + "size": 28090590, + "subdir": "linux-64", + "timestamp": 1664374281016, + "version": "4.6.0" + }, + "opencv-4.6.0-py39hd653453_2.conda": { + "build": "py39hd653453_2", + "build_number": 2, + "depends": [ + "_openmp_mutex >=5.1", + "blas * openblas", + "eigen", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "harfbuzz >=4.3.0,<5.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp-base", + "numpy", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "qt-main >=5.15,<6", + "qt-webengine >=5.15.7,<6", + "qtwebkit 5.*", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8a4a88b1d4b6d583e94021d8c304d06d", + "name": "opencv", + "sha256": "f9449ec17485f9a770192462375aa3dfebeabfeb8aa513b15f8987635f1b08db", + "size": 28022982, + "subdir": "linux-64", + "timestamp": 1664550050489, + "version": "4.6.0" + }, + "openh264-1.8.0-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "1004e731b3cdd4c68f83d6871086b17f", + "name": "openh264", + "sha256": "8c242f5f202e2e1972335dc5ac65431f8cf9a7eedb6cd9af9c718ab4f8e876ea", + "size": 674613, + "subdir": "linux-64", + "timestamp": 1576633242115, + "version": "1.8.0" + }, + "openh264-2.1.0-hd408876_0.conda": { + "build": "hd408876_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8641d9ae108a575a2e1401f6a71fd278", + "name": "openh264", + "sha256": "3094084b25ecac47c117d35cc38ef80d436c3bfb46853dd0ae2b2eed241a2d33", + "size": 739419, + "subdir": "linux-64", + "timestamp": 1587147185809, + "version": "2.1.0" + }, + "openh264-2.1.1-h4ff587b_0.conda": { + "build": "h4ff587b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9f5901ce86b961bbc11054ebe2ec4097", + "name": "openh264", + "sha256": "a68032e0136053857833231b0a466de57e131b7eb8761572303461b021708b30", + "size": 727562, + "subdir": "linux-64", + "timestamp": 1640014414497, + "version": "2.1.1" + }, + "openjdk-11.0.13-h87a67e3_0.conda": { + "build": "h87a67e3_0", + "build_number": 0, + "depends": [ + "dbus", + "expat", + "freetype", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libxcb", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-only", + "license_family": "GPL", + "md5": "c21185eded808a3acf807869a3beca84", + "name": "openjdk", + "sha256": "1f15196f03a8d9f338f9567d6339d67aae0250cfba65c0c51be4c3256f8b52d0", + "size": 357582239, + "subdir": "linux-64", + "timestamp": 1642156521678, + "version": "11.0.13" + }, + "openjdk-8.0.152-h46b5887_1.conda": { + "build": "h46b5887_1", + "build_number": 1, + "depends": [], + "license": "GPLv2", + "license_family": "GPL", + "md5": "eb0f085e94a55914e6b8bbca6e044715", + "name": "openjdk", + "sha256": "1c270e6b7e9fc0d6f0b0ff3ff2902ba2a1c4caecb94b11d2231da36bfae03a25", + "size": 60224250, + "subdir": "linux-64", + "timestamp": 1511651164872, + "track_features": "", + "version": "8.0.152" + }, + "openjdk-8.0.152-h6bedd7e_0.conda": { + "build": "h6bedd7e_0", + "build_number": 0, + "depends": [], + "license": "GPLv2", + "license_family": "GPL", + "md5": "db97c3bca7782cf951a05738a82536d0", + "name": "openjdk", + "sha256": "2d00e6b5169475f10ab62b174d8ecdcd8acf3980353e7c5fd67bec02f7061b94", + "size": 59086882, + "subdir": "linux-64", + "timestamp": 1510575278043, + "track_features": "", + "version": "8.0.152" + }, + "openjdk-8.0.152-h7b6447c_2.conda": { + "build": "h7b6447c_2", + "build_number": 2, + "depends": [], + "license": "GPLv2", + "license_family": "GPL", + "md5": "8ba0fe33aa73b2799b697f0a4c55f7de", + "name": "openjdk", + "sha256": "e72e062ec343c5b3a2a9ee89da63410b382d6e37f6e01346fa6deb29597b8f65", + "size": 60670540, + "subdir": "linux-64", + "timestamp": 1581437462341, + "track_features": "", + "version": "8.0.152" + }, + "openjdk-8.0.152-h7b6447c_3.conda": { + "build": "h7b6447c_3", + "build_number": 3, + "depends": [], + "license": "GPLv2", + "license_family": "GPL", + "md5": "e3100a32e7741538a72196a721f988d9", + "name": "openjdk", + "sha256": "4c514309c98c0635f106293509c3190e3aa03812ba2dfa7687f40b1545d78b2e", + "size": 60156831, + "subdir": "linux-64", + "timestamp": 1581682020627, + "track_features": "", + "version": "8.0.152" + }, + "openjpeg-2.2.0-h622c3cc_2.conda": { + "build": "h622c3cc_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.8,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 2-clauses", + "md5": "2d2c3cc881b204f1f2f8d39356fe9011", + "name": "openjpeg", + "sha256": "54ed38de92cc026a4faa906b6db119770483fde948b1bfec2f04bde2040614f5", + "size": 291317, + "subdir": "linux-64", + "timestamp": 1510610341685, + "version": "2.2.0" + }, + "openjpeg-2.2.0-hdc6a14e_1.conda": { + "build": "hdc6a14e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.8,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 2-clauses", + "md5": "8a69cce7ea119fae952af179387b6827", + "name": "openjpeg", + "sha256": "67a4bd1c5b02d3ba96bb4ed308b2539627fe35687547ce4c209a287c87165c73", + "size": 289899, + "subdir": "linux-64", + "timestamp": 1507908083481, + "version": "2.2.0" + }, + "openjpeg-2.3.0-h05c96fa_1.conda": { + "build": "h05c96fa_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 2-Clause", + "md5": "b69d59e92e5f05b707d592f12d46b1c4", + "name": "openjpeg", + "sha256": "5c4d04842b75bea87c98de3cc9f540d95f26262687dd06b6a56a37d5b76bfe81", + "size": 308287, + "subdir": "linux-64", + "timestamp": 1527098564255, + "version": "2.3.0" + }, + "openjpeg-2.3.0-hef292c2_0.conda": { + "build": "hef292c2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 2-Clause", + "md5": "6413aff5b01778e77aaae7886f1f34e8", + "name": "openjpeg", + "sha256": "e31bfd1b0542d1f2c669a343f9ce9468e5eb11ac25c2dca88f31e27191ce99b9", + "size": 306395, + "subdir": "linux-64", + "timestamp": 1522877116711, + "version": "2.3.0" + }, + "openjpeg-2.4.0-h3ad879b_0.conda": { + "build": "h3ad879b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0" + ], + "license": "BSD 2-Clause", + "md5": "86baecb47ecaa7f7ff2657a1f03b90c9", + "name": "openjpeg", + "sha256": "7db5ad4d3119105b26a023702b24eb4d190700e9393df04aec3ad1e0f07c7354", + "size": 338774, + "subdir": "linux-64", + "timestamp": 1630084830020, + "version": "2.4.0" + }, + "openldap-2.4.57-he2b52b7_0.conda": { + "build": "he2b52b7_0", + "build_number": 0, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "OLDAP-2.8", + "license_family": "BSD", + "md5": "dbb7797904c7118c46865d332acc659a", + "name": "openldap", + "sha256": "df2aa3487cab1aeca75b0983dadcbbef011089be37e05c3e55c92d541933fe17", + "size": 738983, + "subdir": "linux-64", + "timestamp": 1611875242859, + "version": "2.4.57" + }, + "openldap-2.4.58-h8242995_1.conda": { + "build": "h8242995_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1q,<1.1.2a" + ], + "license": "OLDAP-2.8", + "license_family": "BSD", + "md5": "8a2030df6117ecd492d91794c0099eff", + "name": "openldap", + "sha256": "b32c2415bbdca2487422e0f327dd839e38c0fb9fd52e924413680ac63b5cde1a", + "size": 738009, + "subdir": "linux-64", + "timestamp": 1659704810080, + "version": "2.4.58" + }, + "openldap-2.4.58-he2b52b7_0.conda": { + "build": "he2b52b7_0", + "build_number": 0, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1j,<1.1.2a" + ], + "license": "OLDAP-2.8", + "license_family": "BSD", + "md5": "851b6103f9058c996c9e7981d6710a85", + "name": "openldap", + "sha256": "04bb25ca024dd2bd37eb325407791b01e0850ea46e2144e3bbb110ff6cd88abd", + "size": 734975, + "subdir": "linux-64", + "timestamp": 1615922801332, + "version": "2.4.58" + }, + "openldap-2.5.4-he2b52b7_0.conda": { + "build": "he2b52b7_0", + "build_number": 0, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "OLDAP-2.8", + "license_family": "BSD", + "md5": "1c05e4baa48e863af64f1de87a67cd9f", + "name": "openldap", + "sha256": "8f3e1970ae0eadb927a4eaf87d733987827e7e230645e99a561b17a05191210a", + "size": 763932, + "subdir": "linux-64", + "timestamp": 1619733284631, + "version": "2.5.4" + }, + "openldap-2.5.5-h2aa78c0_1.conda": { + "build": "h2aa78c0_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.27,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1o,<1.1.2a" + ], + "license": "OLDAP-2.8", + "license_family": "BSD", + "md5": "c9967bf9ce05e16a01b719551fff8a1f", + "name": "openldap", + "sha256": "bdb959bc0b7e90e4c856c34e8cdd4812f5038057b3ca0a59e193de87474a5969", + "size": 754595, + "subdir": "linux-64", + "timestamp": 1656412108864, + "version": "2.5.5" + }, + "openldap-2.5.5-he2b52b7_0.conda": { + "build": "he2b52b7_0", + "build_number": 0, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1k,<1.1.2a" + ], + "license": "OLDAP-2.8", + "license_family": "BSD", + "md5": "e80dcc0f30105a352c7839fef6c96b0d", + "name": "openldap", + "sha256": "1e8d56dd31a614a3324d9f2fe0970559328d631cb482522c2098002f53ec8fe9", + "size": 762354, + "subdir": "linux-64", + "timestamp": 1622827467285, + "version": "2.5.5" + }, + "openmpi-4.0.2-hb1b8bf9_1.conda": { + "build": "hb1b8bf9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mpi 1.0 openmpi", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9cbbf1db09347d57b17dacdb032b991b", + "name": "openmpi", + "sha256": "214b799b44e04c0a74c8f6a880c5e37e1b5457d7adfe9720837e38aadfe57c91", + "size": 3622192, + "subdir": "linux-64", + "timestamp": 1575396999134, + "version": "4.0.2" + }, + "openmpi-mpicc-4.0.2-h7b6447c_1.conda": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "gcc_linux-64 7.3.0.*", + "openmpi 4.0.2 hb1b8bf9_1" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a2c6b4d7668d5ee12518a472681bb4cc", + "name": "openmpi-mpicc", + "sha256": "a9023f5f95033c29d24b540747cfc898178406ba209c4788562e7b600351eb7f", + "size": 17585, + "subdir": "linux-64", + "timestamp": 1575397006405, + "version": "4.0.2" + }, + "openmpi-mpicxx-4.0.2-hfd86e86_1.conda": { + "build": "hfd86e86_1", + "build_number": 1, + "depends": [ + "gxx_linux-64 7.3.0.*", + "openmpi 4.0.2 hb1b8bf9_1" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5b87c4e3481aee24fe262761a63dff39", + "name": "openmpi-mpicxx", + "sha256": "df4aedfbac9cc0454055c11513fba9931dc3d2f8cc7ce3bd63d9c9584c5cdeab", + "size": 17597, + "subdir": "linux-64", + "timestamp": 1575397009893, + "version": "4.0.2" + }, + "openmpi-mpifort-4.0.2-h84218bc_1.conda": { + "build": "h84218bc_1", + "build_number": 1, + "depends": [ + "gfortran_linux-64 7.3.0.*", + "openmpi 4.0.2 hb1b8bf9_1" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "561fa48e48357af9027087f13370de05", + "name": "openmpi-mpifort", + "sha256": "328a252ac08d739f0af0e11a8b6ecb1ccd956b654c717a9cd6bd56b22897bbbf", + "size": 17616, + "subdir": "linux-64", + "timestamp": 1575397013408, + "version": "4.0.2" + }, + "openpyxl-2.4.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fbef1dc278633549e8abb09515f79d63", + "name": "openpyxl", + "sha256": "f9f2fab225ad530ae9de9ff0ab971e13fb6da834fde771b8e10a1974d5106762", + "size": 307954, + "subdir": "linux-64", + "timestamp": 1516746832586, + "version": "2.4.10" + }, + "openpyxl-2.4.10-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f072c45419ca87f3a9c302fde4551e0", + "name": "openpyxl", + "sha256": "f3aebd4759433fa496f1b05a281252e0769fead3c4fd87ff946b0363713f2a98", + "size": 313230, + "subdir": "linux-64", + "timestamp": 1516746859319, + "version": "2.4.10" + }, + "openpyxl-2.4.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4c76fdd9954a4f87b987365da9e2db7a", + "name": "openpyxl", + "sha256": "af9b95656e50f440b605fc464c50541ceea11dec9e5984d2112bb81021db4893", + "size": 307512, + "subdir": "linux-64", + "timestamp": 1516746864583, + "version": "2.4.10" + }, + "openpyxl-2.4.8-py27h9f0c937_1.conda": { + "build": "py27h9f0c937_1", + "build_number": 1, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62885b7a16ea347b23598346b7bc9811", + "name": "openpyxl", + "sha256": "41ef6fda01522219f944b5a585d73c2d84dcaaa312bc4c6c740ad21b948b5657", + "size": 302482, + "subdir": "linux-64", + "timestamp": 1506047880224, + "version": "2.4.8" + }, + "openpyxl-2.4.8-py35hd6c89d3_1.conda": { + "build": "py35hd6c89d3_1", + "build_number": 1, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2075617988f6a17611b38ca1dbae8d19", + "name": "openpyxl", + "sha256": "8c469b5bd4e506c133043985a033a170e361ae2764120adfaa31979ee61421f2", + "size": 307352, + "subdir": "linux-64", + "timestamp": 1506047904578, + "version": "2.4.8" + }, + "openpyxl-2.4.8-py36h41dd2a8_1.conda": { + "build": "py36h41dd2a8_1", + "build_number": 1, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22ad3996b0339071d5fbc9c8661fcc15", + "name": "openpyxl", + "sha256": "1748238d3a1bda0e6a790e8a50ac88f954572559f3cf1dcceea0fc691eb8da51", + "size": 308062, + "subdir": "linux-64", + "timestamp": 1506047929116, + "version": "2.4.8" + }, + "openpyxl-2.4.9-py27hb67eb42_0.conda": { + "build": "py27hb67eb42_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c81dc80726c066444b84d19587debbbd", + "name": "openpyxl", + "sha256": "092ae7e5739a3b59b487ed1f20d2d23a878408c3e7114ff389611ed8ccc729cb", + "size": 307409, + "subdir": "linux-64", + "timestamp": 1512057513932, + "version": "2.4.9" + }, + "openpyxl-2.4.9-py35h1699e3f_0.conda": { + "build": "py35h1699e3f_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "307d9c4a949401f7f8b57a8b4e88408f", + "name": "openpyxl", + "sha256": "b63e31895a8902dd27d6247970382e4e11317104efef67ce189540a47210b738", + "size": 312793, + "subdir": "linux-64", + "timestamp": 1512057516672, + "version": "2.4.9" + }, + "openpyxl-2.4.9-py36hb5dfbf6_0.conda": { + "build": "py36hb5dfbf6_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56779b1310844a60d33511bfef81c329", + "name": "openpyxl", + "sha256": "4d7252d1b1af692df85873b646e6e45d4b159e7a629a0b93b57bad022f740e96", + "size": 310027, + "subdir": "linux-64", + "timestamp": 1512057528614, + "version": "2.4.9" + }, + "openpyxl-2.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17c811db86f11f4ae7a311e9aca2f452", + "name": "openpyxl", + "sha256": "4ffebb71e3a1bd0573968063e1445af5860c695157d82133df0bfc675ed3c36d", + "size": 327595, + "subdir": "linux-64", + "timestamp": 1519151867854, + "version": "2.5.0" + }, + "openpyxl-2.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f4a37585aa25d713b5017ec8bf7ae3d6", + "name": "openpyxl", + "sha256": "4c875345f3cad3e4fa0e0897b4c342e1434beaa6042d584167feda5d59d557d6", + "size": 332229, + "subdir": "linux-64", + "timestamp": 1519151909957, + "version": "2.5.0" + }, + "openpyxl-2.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be2807c5decc88e3c0f1723a8381e2f6", + "name": "openpyxl", + "sha256": "cd5fb21853224ac5dbb0b4337206edafa704b61284f51a198af4934c50ba5514", + "size": 333238, + "subdir": "linux-64", + "timestamp": 1519151868129, + "version": "2.5.0" + }, + "openpyxl-2.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6dffc93a4bcd9334235e9e6b963bb712", + "name": "openpyxl", + "sha256": "125490e29e2281401cadbdcec0c82ae2184932e16edb3d5ad89ea8a57a060250", + "size": 330660, + "subdir": "linux-64", + "timestamp": 1521568256821, + "version": "2.5.1" + }, + "openpyxl-2.5.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ed0eb37fd0550c57bb440a5901b7f5f", + "name": "openpyxl", + "sha256": "8f6513d0dd19b2ced2d442a8bb47ac0c241778322e950bed972a4f534e2c52f7", + "size": 336334, + "subdir": "linux-64", + "timestamp": 1521568376572, + "version": "2.5.1" + }, + "openpyxl-2.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2daf2ca9d083b79d1cfbd313554aa06d", + "name": "openpyxl", + "sha256": "4149442459594aba8d122f93b48f707968ac65524731ce987de494e719d8f44e", + "size": 331013, + "subdir": "linux-64", + "timestamp": 1521568377110, + "version": "2.5.1" + }, + "openpyxl-2.5.11-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef5ca94afda3b141ca660636568c2802", + "name": "openpyxl", + "sha256": "24c26fbe2d4278e3667aaf0a11e1e9f526a229f1f5e85b7c8a34e31bde96b38b", + "size": 347198, + "subdir": "linux-64", + "timestamp": 1543601685454, + "version": "2.5.11" + }, + "openpyxl-2.5.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d206b2027695a9ddcb3afb87e6e492f7", + "name": "openpyxl", + "sha256": "5353f822b9b680227bf9c45f85fd77521058626f46aac2071367a2997922fef0", + "size": 353069, + "subdir": "linux-64", + "timestamp": 1543601703430, + "version": "2.5.11" + }, + "openpyxl-2.5.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f8ae6bd9343c3004c8f8985cd27bc3c", + "name": "openpyxl", + "sha256": "494811e46edb9c44ef07208f429bc9a0e0ff66fa1caf935298ffff4c34f53b8d", + "size": 351558, + "subdir": "linux-64", + "timestamp": 1543601689696, + "version": "2.5.11" + }, + "openpyxl-2.5.12-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c9ec72ca9b1b010b92def5ed9f03e16", + "name": "openpyxl", + "sha256": "661475c1107decf9e9d041e3afeb010b5517f76fba98c164f1d547092a959d7c", + "size": 346904, + "subdir": "linux-64", + "timestamp": 1545076401837, + "version": "2.5.12" + }, + "openpyxl-2.5.12-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d873ba8cc7cd18260fd216e905577dbf", + "name": "openpyxl", + "sha256": "d44bae3a18d4085beb331ba427b4fb87a12551964f1988e56bbe01332a7a0905", + "size": 350913, + "subdir": "linux-64", + "timestamp": 1545076430836, + "version": "2.5.12" + }, + "openpyxl-2.5.12-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff70808b238cd3e7bf8064e79007dbf4", + "name": "openpyxl", + "sha256": "170cc09faa9bfebd641fa9ad10326870f6f99b90194a0ac3b081a34322ee7b18", + "size": 350191, + "subdir": "linux-64", + "timestamp": 1545076434860, + "version": "2.5.12" + }, + "openpyxl-2.5.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2723a8924732630fddf9503e1e1b543", + "name": "openpyxl", + "sha256": "4093303644183aed9d47b0f32acd13c9e759df633bc7d119584f815d7a45afa7", + "size": 330046, + "subdir": "linux-64", + "timestamp": 1523291597403, + "version": "2.5.2" + }, + "openpyxl-2.5.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a5b68e5aaf1007a8af1550ce953f3956", + "name": "openpyxl", + "sha256": "879552a8b2af122e4e20d37854c936222b04ceec3a249608c72e8d5df6b74886", + "size": 338125, + "subdir": "linux-64", + "timestamp": 1523291616242, + "version": "2.5.2" + }, + "openpyxl-2.5.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4638c16b58e64457197c049f0584441f", + "name": "openpyxl", + "sha256": "d94b72496c6084b6a18f494c9553029eccfac52c2e932fe1e596fe2e18f62387", + "size": 332924, + "subdir": "linux-64", + "timestamp": 1523291623719, + "version": "2.5.2" + }, + "openpyxl-2.5.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "27101854f475e19100751bd15f13bdd0", + "name": "openpyxl", + "sha256": "5f0e4ad2ea99ade25615d649f39e586e2d64b74ebc9549b7f7f2ebf3b5a51584", + "size": 332707, + "subdir": "linux-64", + "timestamp": 1524229244641, + "version": "2.5.3" + }, + "openpyxl-2.5.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "06e3dcd7effaeea8fbcb00ef040dfb06", + "name": "openpyxl", + "sha256": "bf3dd10583b234ee279af49dee9471facc87f2df6ae2fc3a23b7926ab71f8ffd", + "size": 338296, + "subdir": "linux-64", + "timestamp": 1524229292445, + "version": "2.5.3" + }, + "openpyxl-2.5.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6bcb703bcbfbf2469d85c9e34186eb40", + "name": "openpyxl", + "sha256": "8649429b63259bf18853a36a0983a24ac20341e32298bda0fbc94520cd665deb", + "size": 332708, + "subdir": "linux-64", + "timestamp": 1524229284409, + "version": "2.5.3" + }, + "openpyxl-2.5.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e308bead20676f7d4c1c59d00a4c6523", + "name": "openpyxl", + "sha256": "d7f973201f104258e466226997deedb419fa66f77e68aab56898b699ad8c29fa", + "size": 330538, + "subdir": "linux-64", + "timestamp": 1528907433508, + "version": "2.5.4" + }, + "openpyxl-2.5.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2e1532cc3142bd73772946bf9acd8d2", + "name": "openpyxl", + "sha256": "a0feac154585903bb02a9f1ed3ed2897a7b71d6af865783088ccb25c5d045b41", + "size": 334807, + "subdir": "linux-64", + "timestamp": 1528907473191, + "version": "2.5.4" + }, + "openpyxl-2.5.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "479e229c5e4a13839d49f1e6c7bec963", + "name": "openpyxl", + "sha256": "e0862043773df06b0da6e2645ac9aa146ecf4bf1c002db44f196c42d9aa58d21", + "size": 333205, + "subdir": "linux-64", + "timestamp": 1528907421082, + "version": "2.5.4" + }, + "openpyxl-2.5.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "800d63b16acd6108995339628d230c20", + "name": "openpyxl", + "sha256": "edc8e8d371248bf9e32c315536d02e143ccb2a36d435cb4f692bc20d45df46be", + "size": 331851, + "subdir": "linux-64", + "timestamp": 1530736092680, + "version": "2.5.4" + }, + "openpyxl-2.5.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4cb92360b6e41a31d78e9690ba427942", + "name": "openpyxl", + "sha256": "1020c0a4bab7f3a07d137120b603da75acbdec6da762ea5eab468484e0b4bb8e", + "size": 335240, + "subdir": "linux-64", + "timestamp": 1533750994215, + "version": "2.5.5" + }, + "openpyxl-2.5.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b02c2c22aa39267f807a10ac5c627218", + "name": "openpyxl", + "sha256": "4985e03a2f452e0e0f6d42299021f24667e2e46baf774c5910d7fffc9170a79d", + "size": 343259, + "subdir": "linux-64", + "timestamp": 1533751032438, + "version": "2.5.5" + }, + "openpyxl-2.5.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "06e52682b9a03c01fd448877abd1ec88", + "name": "openpyxl", + "sha256": "f21f270888a0b7225ee2e10483a73618bf745801b04e57131e463bc6c9f77b0a", + "size": 340898, + "subdir": "linux-64", + "timestamp": 1533750984811, + "version": "2.5.5" + }, + "openpyxl-2.5.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c1be3deeae6078d041db0388dfe377e", + "name": "openpyxl", + "sha256": "a1338dd421c25dd3b831665940b7e16e4b6d56fdf82835b1dd622798a4dc60d2", + "size": 337130, + "subdir": "linux-64", + "timestamp": 1533750963943, + "version": "2.5.5" + }, + "openpyxl-2.5.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "182fb0a55bf820f2e3a46f92d16291ac", + "name": "openpyxl", + "sha256": "353ae7a65792ac729dd514c0bccacc1ef53bf0ee9fd4d718c87c8a5a6ffd20ff", + "size": 338880, + "subdir": "linux-64", + "timestamp": 1536078441351, + "version": "2.5.6" + }, + "openpyxl-2.5.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d20d0a7ba08973a9205b0e292a9f800e", + "name": "openpyxl", + "sha256": "4a867ae808522f9e0936d1e279ab7e9b108036f132a8f732461b0544eac76289", + "size": 347951, + "subdir": "linux-64", + "timestamp": 1536078461422, + "version": "2.5.6" + }, + "openpyxl-2.5.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d54df7a14e068c8d764fa1c0c08bccd", + "name": "openpyxl", + "sha256": "beb69ff753676a198ae30837dda5c05d674ac26b3f6a2041e6d6723c5e3c89f6", + "size": 342444, + "subdir": "linux-64", + "timestamp": 1536078396678, + "version": "2.5.6" + }, + "openpyxl-2.5.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d158bb480928330ed63035a0487c73ef", + "name": "openpyxl", + "sha256": "b74293a7b4b1e087ebee5cf2c99ed642d0558c191243f89fc804866719f5c295", + "size": 345007, + "subdir": "linux-64", + "timestamp": 1536078471901, + "version": "2.5.6" + }, + "openpyxl-2.5.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d3d495fdd24b2bb3c58d1bbc47954627", + "name": "openpyxl", + "sha256": "f29ab62c13f043bf762e7fc2e708a9ac6d564c6401958cad89d8989201e06fc6", + "size": 345815, + "subdir": "linux-64", + "timestamp": 1538160093858, + "version": "2.5.8" + }, + "openpyxl-2.5.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f366854ae23bfd6cf0da03c1ecc6a16", + "name": "openpyxl", + "sha256": "5893ebf84787743cedb435ce5261ed523a609db018b87782a434d88614e873b7", + "size": 349462, + "subdir": "linux-64", + "timestamp": 1538160118163, + "version": "2.5.8" + }, + "openpyxl-2.5.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7711c1d252955f4ef9bc86e1594abb8c", + "name": "openpyxl", + "sha256": "c3b5ffd1581596ccde1a6882b8093c842b9a151d86b8ee0e76098ad20eb9a820", + "size": 348846, + "subdir": "linux-64", + "timestamp": 1538160095530, + "version": "2.5.8" + }, + "openpyxl-2.5.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b89ed1228d5de903c24a3f7fd511f4a", + "name": "openpyxl", + "sha256": "1cc6dc076f0738bd9899606e0dba8826098eaf906308a3fc6efbf6a7aa3a3060", + "size": 343812, + "subdir": "linux-64", + "timestamp": 1540234630662, + "version": "2.5.9" + }, + "openpyxl-2.5.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d622f4028b7d38cd43ffd4aa79b62e02", + "name": "openpyxl", + "sha256": "0d4639c17680dc857a48a8f125e89b0d442806ec9a771dcd3e3d9876400fac18", + "size": 346743, + "subdir": "linux-64", + "timestamp": 1540234652147, + "version": "2.5.9" + }, + "openpyxl-2.5.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02a586bee66fc772993d9f9b1659d97d", + "name": "openpyxl", + "sha256": "3df2a0428a8cadfa2f057dc3f0114be3164b52ffab6b4314c8219de5dd9960af", + "size": 346042, + "subdir": "linux-64", + "timestamp": 1540234660102, + "version": "2.5.9" + }, + "openpyxl-2.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51c025d41fbf64c0abbde5ae1a39dee8", + "name": "openpyxl", + "sha256": "7c469955320fc82bd15fdf24d718338cfbed71a39f189078d262e6ea5135844b", + "size": 350960, + "subdir": "linux-64", + "timestamp": 1550350185615, + "version": "2.6.0" + }, + "openpyxl-2.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9b8792a04b7c243eafbe27430b100cc", + "name": "openpyxl", + "sha256": "10ff400d4b2a1696bad6498f85115d4df7a6dec2d6e6f7f120f57b60f9e33368", + "size": 351383, + "subdir": "linux-64", + "timestamp": 1550350192342, + "version": "2.6.0" + }, + "openpyxl-2.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5cf119ddef5c5f767c1ad59c78a40912", + "name": "openpyxl", + "sha256": "df24283b17d2ad5e307ca222d97c7582c5ee72f6030c3ecb2db238aa21d8eb96", + "size": 350469, + "subdir": "linux-64", + "timestamp": 1550350128637, + "version": "2.6.0" + }, + "openpyxl-2.6.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee937205d1293ff760f850db1a7f7ad7", + "name": "openpyxl", + "sha256": "16523966577fbd9d6df616ed85d0c02e0447cd02d4252f68a5b45ca9d5bdb2b6", + "size": 349396, + "subdir": "linux-64", + "timestamp": 1553289356750, + "version": "2.6.1" + }, + "openpyxl-2.6.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e54e064e062cb863f277d9fc460b59b", + "name": "openpyxl", + "sha256": "d1ad34206b04df94026f1c904a772c97cacb357b6722fcd84bc7c871b245123d", + "size": 355560, + "subdir": "linux-64", + "timestamp": 1553289474048, + "version": "2.6.1" + }, + "openpyxl-2.6.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "et_xmlfile", + "jdcal", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a57ff58b20a3c1d29edcf84bc5cb5b78", + "name": "openpyxl", + "sha256": "2a4c0a119bbcb3c8ad7117cd8a759cf882be6298515b98dfb73f45d33a89880a", + "size": 351313, + "subdir": "linux-64", + "timestamp": 1553289247402, + "version": "2.6.1" + }, + "openpyxl-3.0.10-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e570037bdef24d2efeeccb6ea7cb14a", + "name": "openpyxl", + "sha256": "462b1f36a8509691f0a0b05d26aedf66c02cdcc27d4be458d9bcd23ba5243ac3", + "size": 1251593, + "subdir": "linux-64", + "timestamp": 1657175766078, + "version": "3.0.10" + }, + "openpyxl-3.0.10-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e5a74318b4e03731f8ba71101d2399da", + "name": "openpyxl", + "sha256": "df0e76ddc1fed021ee78360c4410162962adba5c5e2ea3eebc087435bce81311", + "size": 647773, + "subdir": "linux-64", + "timestamp": 1676841431143, + "version": "3.0.10" + }, + "openpyxl-3.0.10-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9fb6f80ad03756a2c285a30481dbd57", + "name": "openpyxl", + "sha256": "f9e36dffee047a9798d4007388ddf9534768e3a4f1e79e4e596a95d6ee4ad40c", + "size": 539847, + "subdir": "linux-64", + "timestamp": 1657175708597, + "version": "3.0.10" + }, + "openpyxl-3.0.10-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2212c937710f721ad1c02ee3ab0b915", + "name": "openpyxl", + "sha256": "817432029803554c27f40e5dd139245ca3522ba30a95c6f970924cbb65075d98", + "size": 554699, + "subdir": "linux-64", + "timestamp": 1657175662545, + "version": "3.0.10" + }, + "openpyxl-3.0.10-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "et_xmlfile", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18049cc9a5cdb7661dc639108b939bf1", + "name": "openpyxl", + "sha256": "6fe4d32df9db0189901ed9a30660e4052ca3a0f97bfc32c845fcffc0aa5c21f2", + "size": 549433, + "subdir": "linux-64", + "timestamp": 1657175616466, + "version": "3.0.10" + }, + "openresty-1.13.6.2-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "luajit", + "openssl >=1.1.1a,<1.1.2a", + "pcre >=8.42,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "multiple", + "md5": "e3abb0369c1974ee8c96e3aa2e4760e7", + "name": "openresty", + "sha256": "aaae73ed6bf56f769e44527049533546f933072251e66c50f8955659e02a57fa", + "size": 2667644, + "subdir": "linux-64", + "timestamp": 1545963349735, + "version": "1.13.6.2" + }, + "openresty-1.15.8.3-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "82e7f3e2cc5d4f3f6fbc819cd6bb7d78", + "name": "openresty", + "sha256": "2cd9b096b07f31747a1b71910c1fbb79090e7bedd4a1d118310eabb26625c316", + "size": 4226656, + "subdir": "linux-64", + "timestamp": 1599153184266, + "version": "1.15.8.3" + }, + "openresty-1.15.8.3-h20c2e04_1.conda": { + "build": "h20c2e04_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "95ed701ff148d7932e5c8d3d767a0b51", + "name": "openresty", + "sha256": "c28568f998c9e0c2c6ebe16b18e5358d64c22f66176ec8ab43a77a284b5ce1c2", + "size": 4230706, + "subdir": "linux-64", + "timestamp": 1599603324250, + "version": "1.15.8.3" + }, + "openresty-1.17.8.1-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "bf26a04821622220d4d85e98c2848a57", + "name": "openresty", + "sha256": "cbc8f2d3eb9c4111d3629a2ff70778e2fc7391d828633120887d8aaca17e3ea4", + "size": 4231729, + "subdir": "linux-64", + "timestamp": 1599847694434, + "version": "1.17.8.1" + }, + "openresty-1.17.8.2-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "a949bf605098ac20cd8afad1b48304d1", + "name": "openresty", + "sha256": "cb6fe927ea79e924aec0a2189830af0a9695132a92e758309ab41cc331fe837d", + "size": 4262478, + "subdir": "linux-64", + "timestamp": 1600481598300, + "version": "1.17.8.2" + }, + "openresty-1.19.3.1-h303737a_0.conda": { + "build": "h303737a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "pcre >=8.44,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "691ee928cce00ee2da6f14b49b1c4627", + "name": "openresty", + "sha256": "dddb6d5f9e11aae9733766fb3ab05c1f71b5a273fd2db92f58d347628a07b64f", + "size": 4312547, + "subdir": "linux-64", + "timestamp": 1605119113461, + "version": "1.19.3.1" + }, + "openresty-1.19.9.1-h0b77cf5_0.conda": { + "build": "h0b77cf5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openssl >=1.1.1k,<1.1.2a", + "pcre >=8.45,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "1cff424cbf8609ca96603317756420a0", + "name": "openresty", + "sha256": "4678153ab0ffddf929fb7103f1f1f392a5f6737e3fbf7c0aa023edcfb0ff7df7", + "size": 4298533, + "subdir": "linux-64", + "timestamp": 1629117052298, + "version": "1.19.9.1" + }, + "openssl-1.0.2l-h077ae2c_5.conda": { + "build": "h077ae2c_5", + "build_number": 5, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "c7b751c2f28bd1f1ade90bddcd6b48ff", + "name": "openssl", + "sha256": "3fcf32d2a362127566cbebb301b1208b90c619408364ce2eccd5a73ce6244d14", + "size": 2466811, + "subdir": "linux-64", + "timestamp": 1508174907958, + "version": "1.0.2l" + }, + "openssl-1.0.2l-h9d1a558_3.conda": { + "build": "h9d1a558_3", + "build_number": 3, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "a31fb4c7879665b6080d4b011fec1de8", + "name": "openssl", + "sha256": "0ece4c4111dbf7767c1954f039f4a9ae4ca96fdfd90e899c00c12230c4decd7f", + "size": 2451693, + "subdir": "linux-64", + "timestamp": 1505862551189, + "version": "1.0.2l" + }, + "openssl-1.0.2l-hd940f6d_1.conda": { + "build": "hd940f6d_1", + "build_number": 1, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "ac45b999f8ed77f01e4c13f7bb45a3ba", + "name": "openssl", + "sha256": "fa01ff130db895fd6bbccd49adc05a51e3bdd0a9c4c3f70364675be8e8022982", + "size": 2451734, + "subdir": "linux-64", + "timestamp": 1505666977729, + "version": "1.0.2l" + }, + "openssl-1.0.2m-h26d622b_1.conda": { + "build": "h26d622b_1", + "build_number": 1, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "8f3a038a93fc0d484bef9ce83cacb9b1", + "name": "openssl", + "sha256": "9a8a35d04b04b91ce7aeb68dc372402212e8784d8920b1bfceae4a9b58dd8d71", + "size": 2460236, + "subdir": "linux-64", + "timestamp": 1510610580577, + "version": "1.0.2m" + }, + "openssl-1.0.2m-h8cfc7e7_0.conda": { + "build": "h8cfc7e7_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "aa4411ffcc121a20a9ad1158413d7bf4", + "name": "openssl", + "sha256": "b3011f1aa3b2324ce4b9ae3ae3e9fb41ceaf691c9557a83048884180622f7f2a", + "size": 2459711, + "subdir": "linux-64", + "timestamp": 1509743095949, + "version": "1.0.2m" + }, + "openssl-1.0.2n-hb7f436b_0.conda": { + "build": "hb7f436b_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "8ecbcd2ba7c6fe4a4d7406a4d604d0e3", + "name": "openssl", + "sha256": "e9cd58cfb48b5f870e51a2c9eb2100337ee389e2c1f80237882540642e1a7857", + "size": 2474540, + "subdir": "linux-64", + "timestamp": 1512662607716, + "version": "1.0.2n" + }, + "openssl-1.0.2o-h14c3975_1.conda": { + "build": "h14c3975_1", + "build_number": 1, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "5eadd48c9126618d252ef74bb5ce2f40", + "name": "openssl", + "sha256": "1561ddbf5e4c3a5ff6c29a34773acf643413577fc95abb8a7f6656691c0015fc", + "size": 2460638, + "subdir": "linux-64", + "timestamp": 1533231765655, + "version": "1.0.2o" + }, + "openssl-1.0.2o-h20670df_0.conda": { + "build": "h20670df_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "76f3250fd0e30ed418293fc3fe8fa999", + "name": "openssl", + "sha256": "674afeed6477730385a26d2416ff95338285ee2df64c650f798d4ad3324ec06c", + "size": 2460016, + "subdir": "linux-64", + "timestamp": 1522162879001, + "version": "1.0.2o" + }, + "openssl-1.0.2p-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "3fde3082470dd99e73e377be189a4fcb", + "name": "openssl", + "sha256": "1dd3b9e47061e37d24aa1746d7ca8aa54c674378301fe4b5edcfc92f3dac28e5", + "size": 2465959, + "subdir": "linux-64", + "timestamp": 1534253690735, + "version": "1.0.2p" + }, + "openssl-1.0.2q-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "672fd6ed5da54e39061fa5e1bdb7ab34", + "name": "openssl", + "sha256": "8f8272795df99597b67fa40ee17786510b847fb778c29a6e8d63ead78d1a0f21", + "size": 2237532, + "subdir": "linux-64", + "timestamp": 1551219164928, + "version": "1.0.2q" + }, + "openssl-1.0.2r-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "4aeccb8de42d72586b7e608c36999acc", + "name": "openssl", + "sha256": "d460fdae7d0f6e16ccad5693b2e7f6e4ab2101d879faabace5f8cc73207dcf14", + "size": 2250677, + "subdir": "linux-64", + "timestamp": 1551220820214, + "version": "1.0.2r" + }, + "openssl-1.0.2s-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "df23f80a17fba0ffa83d5a50e5ef9531", + "name": "openssl", + "sha256": "ea545a091d74e079160aba59229028e95b4184c9bc52be7e916bdf297715feee", + "size": 2243076, + "subdir": "linux-64", + "timestamp": 1559070442483, + "version": "1.0.2s" + }, + "openssl-1.0.2t-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "78234a70c176644b948dfb7033da2152", + "name": "openssl", + "sha256": "5166ba4de68298370ccc4c9bd4029039c45ee3cc4c02c8c4765ac9ff9bcc92f3", + "size": 2607411, + "subdir": "linux-64", + "timestamp": 1568211667259, + "version": "1.0.2t" + }, + "openssl-1.0.2t-h7b6447c_1.conda": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "b02206618a7c0b55ee23b72f809ecd04", + "name": "openssl", + "sha256": "67ded877f6d5dc1992cc2df117c4169d6c683a4bb5f83327ba099c3ae5177b52", + "size": 2255939, + "subdir": "linux-64", + "timestamp": 1568298632304, + "version": "1.0.2t" + }, + "openssl-1.0.2u-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "3532022c9bc60fd9920d60aa36a8a7dd", + "name": "openssl", + "sha256": "5caed509cbf8b00abe61b737d3a77693b92ef1f33a192b1dc233fed6ac08829a", + "size": 2260374, + "subdir": "linux-64", + "timestamp": 1576852237184, + "version": "1.0.2u" + }, + "openssl-1.1.1a-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "9576688f6df6f35a068401c06fd650d8", + "name": "openssl", + "sha256": "68da736cf79747ecec1440f85ad16d0d14d6070f43912e787ba1b33869295185", + "size": 3509710, + "subdir": "linux-64", + "timestamp": 1542740345038, + "version": "1.1.1a" + }, + "openssl-1.1.1b-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "63a8cfd96803dcbc1847b43d5685c20a", + "name": "openssl", + "sha256": "9bbff3374a2b875f285baf7da1b970e51db86f08dfd343b0adb6115a9d3b7f67", + "size": 2702626, + "subdir": "linux-64", + "timestamp": 1551214768361, + "version": "1.1.1b" + }, + "openssl-1.1.1b-h7b6447c_1.conda": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "977c45a9bc2b43c03a7bcbd5d1a402c8", + "name": "openssl", + "sha256": "9cd87d1ff2d3e19577331c440387562d7992276a4598cde2fd4ff0295822f5e1", + "size": 2710494, + "subdir": "linux-64", + "timestamp": 1551973352851, + "version": "1.1.1b" + }, + "openssl-1.1.1c-h7b6447c_1.conda": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "867d9103fda1fa03a2ab69a3883ec952", + "name": "openssl", + "sha256": "ccc0ff7c0b977d01105298fb3602c200864a8321a9e9d6e009d8a14457f2a03c", + "size": 2644969, + "subdir": "linux-64", + "timestamp": 1559152830804, + "version": "1.1.1c" + }, + "openssl-1.1.1d-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "521bf1cbe0de241ae8975304fb05ce3e", + "name": "openssl", + "sha256": "083b4334615af00c3fa28ce2f55b257fefdb90be7b87d65557a23ed8c09f7585", + "size": 2615295, + "subdir": "linux-64", + "timestamp": 1568192113265, + "version": "1.1.1d" + }, + "openssl-1.1.1d-h7b6447c_1.conda": { + "build": "h7b6447c_1", + "build_number": 1, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "49f4684ccfc445034266ce87c0ae5a00", + "name": "openssl", + "sha256": "6c50b0427885922797f274790e29137f8e2d5461a53f69986a5a4e83cb257f34", + "size": 2616137, + "subdir": "linux-64", + "timestamp": 1568287441501, + "version": "1.1.1d" + }, + "openssl-1.1.1d-h7b6447c_2.conda": { + "build": "h7b6447c_2", + "build_number": 2, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "65a696d93e95008af6e2f99907961a44", + "name": "openssl", + "sha256": "c39b37f82af16b29bb7046cd034f89c53d28f0fa639ecc0163d8355ff32a374f", + "size": 2633300, + "subdir": "linux-64", + "timestamp": 1569594008754, + "version": "1.1.1d" + }, + "openssl-1.1.1d-h7b6447c_3.conda": { + "build": "h7b6447c_3", + "build_number": 3, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "6b5180ab38f741f4c7e0ac14d9941531", + "name": "openssl", + "sha256": "190d84dbc5dcb5da6bef86e5b30f3defecf9d5c561785170138946e9fe9824c7", + "size": 2616718, + "subdir": "linux-64", + "timestamp": 1571239236113, + "version": "1.1.1d" + }, + "openssl-1.1.1d-h7b6447c_4.conda": { + "build": "h7b6447c_4", + "build_number": 4, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "048319376adb5d3a2e023a805bf121b3", + "name": "openssl", + "sha256": "1d429ed37c08ad08f86bd821fca70f9e0f1cbf5f02ca9ba57e9c0834ccbf63fc", + "size": 2637883, + "subdir": "linux-64", + "timestamp": 1581354302002, + "version": "1.1.1d" + }, + "openssl-1.1.1e-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "710bbe87575fa7d130c9fdc24eec18ae", + "name": "openssl", + "sha256": "b2717a277430b405149a8695bfc8a9e799d8488bfe765dec409c6b04c9ac6b1d", + "size": 2652893, + "subdir": "linux-64", + "timestamp": 1584465134548, + "version": "1.1.1e" + }, + "openssl-1.1.1f-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "a691fd7d4f129e534263f2d2bce79530", + "name": "openssl", + "sha256": "70cadd97edca8f83b96318f71e0445d45bb32c80e1bed045d954a98f8c9c6b3a", + "size": 2644995, + "subdir": "linux-64", + "timestamp": 1585661946070, + "version": "1.1.1f" + }, + "openssl-1.1.1g-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "d64818ba115b875b04e1cc23851c0851", + "name": "openssl", + "sha256": "5359cc4e056b0e41de0d3e0835ae74145d996f14b9f2cce3351cf17b90d5f503", + "size": 2637685, + "subdir": "linux-64", + "timestamp": 1587477157134, + "version": "1.1.1g" + }, + "openssl-1.1.1h-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "674a36538310f1237b8aeb978beb397b", + "name": "openssl", + "sha256": "3a01ac0f4e3a1419c8c32711e61da37167a955b8d072419532705567b51a63ed", + "size": 2656888, + "subdir": "linux-64", + "timestamp": 1600781555948, + "version": "1.1.1h" + }, + "openssl-1.1.1i-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "ab2bf4db2634735f28b682e30af66f25", + "name": "openssl", + "sha256": "a6d814ccc292e4f2e0802c68c92ee040ecd5efbeae0d7b9528ca408fab4cc612", + "size": 2650582, + "subdir": "linux-64", + "timestamp": 1607536520614, + "version": "1.1.1i" + }, + "openssl-1.1.1j-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "57de76d761383015d047da134e4b7946", + "name": "openssl", + "sha256": "ad6e948d0396fc3da14147b532408b456c5a460d812cdf63ad8fa91d8585ca71", + "size": 2652692, + "subdir": "linux-64", + "timestamp": 1613667958104, + "version": "1.1.1j" + }, + "openssl-1.1.1k-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.3.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "9c1822b18564cdc68c493366da6f46f4", + "name": "openssl", + "sha256": "dd9ff7c11ee7690256772eeae1cfebb63d8643c8329ff489ec93f64863e7b421", + "size": 2657446, + "subdir": "linux-64", + "timestamp": 1616684152302, + "version": "1.1.1k" + }, + "openssl-1.1.1l-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.5.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "0e915dd5bd00c5684e84c59cf561b2af", + "name": "openssl", + "sha256": "87da3a25d5534f656873ade1ae86d18a64de35d55cf4776eae6b8b461d2e59c6", + "size": 2636799, + "subdir": "linux-64", + "timestamp": 1630591938970, + "version": "1.1.1l" + }, + "openssl-1.1.1m-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.5.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "8ce61ffe2f4938f04b3d3325b4987cdb", + "name": "openssl", + "sha256": "035e75f6a4af78c2d70dc2a7f69bdc12691837c9b776c7cd0cb37f62a5fb997e", + "size": 2636540, + "subdir": "linux-64", + "timestamp": 1641962265267, + "version": "1.1.1m" + }, + "openssl-1.1.1n-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.5.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "6a628baa5cc1c79c86026c21abfed46d", + "name": "openssl", + "sha256": "a688204990178637228bdf12f5655460a5bf27746243dc8ea64e470db37e0036", + "size": 2636533, + "subdir": "linux-64", + "timestamp": 1647850792453, + "version": "1.1.1n" + }, + "openssl-1.1.1o-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.5.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "dff07c1e2347fed6e5a3afbbcd5bddcc", + "name": "openssl", + "sha256": "ad0413946d9dd5e56a99f01a241a9125462f6c23ebc4f11550191fefeac0d936", + "size": 2642661, + "subdir": "linux-64", + "timestamp": 1652103194742, + "version": "1.1.1o" + }, + "openssl-1.1.1p-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=11.2.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "bfdaf29c41b954aac15c9e54d0730609", + "name": "openssl", + "sha256": "cff15bb359a1b65b4d080e920d3972f139c78c67ccca150f500000f13009e636", + "size": 2634352, + "subdir": "linux-64", + "timestamp": 1656430278347, + "version": "1.1.1p" + }, + "openssl-1.1.1q-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.5.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "2ac47797afee2ece8d339c18b095b8d8", + "name": "openssl", + "sha256": "49804293b87141523b2606836ece8e2aaa5202983698fd91e7c36bdb8c8a8de5", + "size": 2649280, + "subdir": "linux-64", + "timestamp": 1657551292835, + "version": "1.1.1q" + }, + "openssl-1.1.1s-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.5.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "25f9c4e2394976be98d01cccef2ce43a", + "name": "openssl", + "sha256": "8f374e0af9321268f4bd7a553985997208ff20168613cd4d7b0969e7bacb6493", + "size": 3766094, + "subdir": "linux-64", + "timestamp": 1667573681602, + "version": "1.1.1s" + }, + "openssl-1.1.1t-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libgcc-ng >=7.5.0" + ], + "license": "OpenSSL", + "license_family": "Apache", + "md5": "0410db682c02665511bd4203ade48a32", + "name": "openssl", + "sha256": "4ce120ae62323a43f8c80431ae2824f24b0919eae03b132fd93e5b143a2ad83a", + "size": 3919704, + "subdir": "linux-64", + "timestamp": 1676330616325, + "version": "1.1.1t" + }, + "opentracing-1.2.2-py27he997089_0.conda": { + "build": "py27he997089_0", + "build_number": 0, + "depends": [ + "futures", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "219ee38d9b2107f7714138c37d48ccc2", + "name": "opentracing", + "sha256": "61efa492b1135a98596877629be1c3e6f0d454e6a2e17129d6f0d24c6fb0668c", + "size": 19326, + "subdir": "linux-64", + "timestamp": 1507653757575, + "version": "1.2.2" + }, + "opentracing-1.2.2-py35hce244ff_0.conda": { + "build": "py35hce244ff_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0936ec7884cfa68630c20f7fd59cc08f", + "name": "opentracing", + "sha256": "44ad87a6420ccb3577b99b539963f7f8457f2031331d92406bf36ce1ef81f6e9", + "size": 19628, + "subdir": "linux-64", + "timestamp": 1507653786061, + "version": "1.2.2" + }, + "opentracing-1.2.2-py36hee76fbe_0.conda": { + "build": "py36hee76fbe_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ac1f45d3e4283ce5ccada6f46d628bc", + "name": "opentracing", + "sha256": "a6476dc72bddecc683f3c5cbbaa1930aa274ea62c0c89495a284323a1ca420a3", + "size": 19575, + "subdir": "linux-64", + "timestamp": 1507653788827, + "version": "1.2.2" + }, + "opentracing-1.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "06d266961f5b18502c0fcb7b4fb6d757", + "name": "opentracing", + "sha256": "3220888c7855e8ec0234c9492ef94327281cc4098650e2b31443225d8720748b", + "size": 21892, + "subdir": "linux-64", + "timestamp": 1519152830083, + "version": "1.3.0" + }, + "opentracing-1.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f90a32cc0cc45bb6ce41e7dacac09762", + "name": "opentracing", + "sha256": "7ae2852a09f0173f69aa618ffdea838121b425d8e748330c0aaa94fc83871a32", + "size": 22155, + "subdir": "linux-64", + "timestamp": 1519152858937, + "version": "1.3.0" + }, + "opentracing-1.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "994928847728040996aa4f20606d22cb", + "name": "opentracing", + "sha256": "9e61ed19cdfd222e08f8366ea1e084cf190b6dd047285afbb5b3ecffed6a9976", + "size": 22283, + "subdir": "linux-64", + "timestamp": 1519152798757, + "version": "1.3.0" + }, + "opentracing-1.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a0716f4ee72039a31b29f01ec3d95ff", + "name": "opentracing", + "sha256": "8d4eabcbd65910f47440b4d2c41fa9fc651864f1b7d92b7926dee064307fc7e7", + "size": 22050, + "subdir": "linux-64", + "timestamp": 1530902329643, + "version": "1.3.0" + }, + "opentracing-2.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f3763c3b0865cc5322b7120f044da67", + "name": "opentracing", + "sha256": "61dbaf5cbb69887d15939ba5d9760eaa1d5ea9119697ae38d8a03fd42c560d83", + "size": 45056, + "subdir": "linux-64", + "timestamp": 1535427912273, + "version": "2.0.0" + }, + "opentracing-2.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cf46905f10be7ff4fd4f0fec392717a0", + "name": "opentracing", + "sha256": "da0fbc60d98084e440b84342829cc2724d87218063693247b90708b45c65b51a", + "size": 45029, + "subdir": "linux-64", + "timestamp": 1535428016227, + "version": "2.0.0" + }, + "opentracing-2.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a6f540dfd2ce84d522b7cc3bb3a2157e", + "name": "opentracing", + "sha256": "96e4b0e0e1b5814628a99ec203b900842e37d61aba7704e7827c9b49f7efe22e", + "size": 45823, + "subdir": "linux-64", + "timestamp": 1535427982502, + "version": "2.0.0" + }, + "opentracing-2.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "071bebe7ea536b9a2cba15f1272f53d4", + "name": "opentracing", + "sha256": "a5e92a0f6294c18fa94ad4e1043449029b16590f1ddb70dbd0f221f6bd7ccdb4", + "size": 44929, + "subdir": "linux-64", + "timestamp": 1535427934979, + "version": "2.0.0" + }, + "opentracing-2.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63ad02a52b78a65eed6d40030df0f255", + "name": "opentracing", + "sha256": "0a26c171cefcdabfd28958dd6e12aa6fc2e41421ed7e5d7cc353492f2276e8dc", + "size": 52845, + "subdir": "linux-64", + "timestamp": 1559058764248, + "version": "2.2.0" + }, + "opentracing-2.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0563191c2524c537a6d502067c6e831b", + "name": "opentracing", + "sha256": "cda7076e351f20a9288517e10f5bddd0958d50f4ff6df8a3be4254d2773838e6", + "size": 53618, + "subdir": "linux-64", + "timestamp": 1559058730287, + "version": "2.2.0" + }, + "opentracing-2.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d82ffa9d3bd48d875bfd2a15d7575f75", + "name": "opentracing", + "sha256": "911d8e683150f72085a11cf411b7674446f2f452f0ee42d6a31cd1f0fc934f6f", + "size": 53675, + "subdir": "linux-64", + "timestamp": 1559058732890, + "version": "2.2.0" + }, + "opentracing-2.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3753e30890447a74a77c2f49dd795d3f", + "name": "opentracing", + "sha256": "0c4b1f012765f2066040358d93b483173a3ba5b51bab5254857972e13f05b827", + "size": 48879, + "subdir": "linux-64", + "timestamp": 1573489421259, + "version": "2.2.0" + }, + "opentracing-2.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b83628912c2552a0cf5b3b828874c233", + "name": "opentracing", + "sha256": "9b30dd400d72a589af87e85882c68da65c07671f19dd201479bfb368928ed736", + "size": 49854, + "subdir": "linux-64", + "timestamp": 1601500374437, + "version": "2.3.0" + }, + "opentracing-2.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fec7d7d26548085c16a0d58bb2ec5ef5", + "name": "opentracing", + "sha256": "947f15cce6d7b71a1268eb0faade73dd1bda4a58cf83bd89ebb6d2576e39c7af", + "size": 49129, + "subdir": "linux-64", + "timestamp": 1601500392025, + "version": "2.3.0" + }, + "opentracing-2.3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "843478d0a56bf9eab633999255f389cf", + "name": "opentracing", + "sha256": "e3f9efc2186f61273da02c63f56a4dc32e0f346db524c08f03cc0ba1116b868a", + "size": 50225, + "subdir": "linux-64", + "timestamp": 1601500387552, + "version": "2.3.0" + }, + "opentracing-2.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33554c48ac293a3e03e978c57b86d700", + "name": "opentracing", + "sha256": "f4c2391d61f15b931dd03862505c381ef72d3ccc027569382da8a73ca3bfc4e6", + "size": 50373, + "subdir": "linux-64", + "timestamp": 1640792076441, + "version": "2.4.0" + }, + "opentracing-2.4.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9ba8f9a30c87e39586631e60fee760d", + "name": "opentracing", + "sha256": "6107b5f97969f1b4d1b71a2c7ebf9c5cd859cd35b2d6046c05f8804f5d510c17", + "size": 60463, + "subdir": "linux-64", + "timestamp": 1676845084785, + "version": "2.4.0" + }, + "opentracing-2.4.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c7d22b311aadabc141eb8888d57d1362", + "name": "opentracing", + "sha256": "ed4489ce2c3ea2e20b500a5007f0eefd50e3f4b28c3c3baff0e80c56c3216c29", + "size": 49279, + "subdir": "linux-64", + "timestamp": 1606154039439, + "version": "2.4.0" + }, + "opentracing-2.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0ffba4a397a91185c98378eccb0fdbf", + "name": "opentracing", + "sha256": "dfd911ef6a57fc959f0b92f09d0f74f090ed079a24ae2889a4616d1bee8f238b", + "size": 50029, + "subdir": "linux-64", + "timestamp": 1606154057264, + "version": "2.4.0" + }, + "opentracing-2.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b0ef443c30abf31709331d8f84b8c93", + "name": "opentracing", + "sha256": "5e3219934e52063a56e7e56d8c13a4f977e0c61c18608c62e289e7097e23813c", + "size": 50188, + "subdir": "linux-64", + "timestamp": 1606154067433, + "version": "2.4.0" + }, + "opentracing-2.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fcfc0b5ece2064da217ef32f67258f72", + "name": "opentracing", + "sha256": "72c8532947373221f6722786f467787acd7a8953601f4cb67bfbad3a51f3eb7a", + "size": 49381, + "subdir": "linux-64", + "timestamp": 1606154039490, + "version": "2.4.0" + }, + "opentracing_instrumentation-2.3.0-py27hd1289c1_0.conda": { + "build": "py27hd1289c1_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "futures", + "opentracing >=1.1,<1.3", + "python >=2.7,<2.8.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b366f4753f8a82e17521e23970a6fbeb", + "name": "opentracing_instrumentation", + "sha256": "5d12c32f3f9a35dbfc113d30174d33a9ce78d9ec0a50e1fca9332abc7a047605", + "size": 35370, + "subdir": "linux-64", + "timestamp": 1510720292740, + "version": "2.3.0" + }, + "opentracing_instrumentation-2.3.0-py35h1954a9b_0.conda": { + "build": "py35h1954a9b_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<1.3", + "python >=3.5,<3.6.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eeab291898805007aa1b387c39b18cfb", + "name": "opentracing_instrumentation", + "sha256": "b2ecd51de871872b743515471c7dacd161a363da3b1489cbe1ac5e71615c63a1", + "size": 36032, + "subdir": "linux-64", + "timestamp": 1510720297498, + "version": "2.3.0" + }, + "opentracing_instrumentation-2.3.0-py36h1c37d0f_0.conda": { + "build": "py36h1c37d0f_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<1.3", + "python >=3.6,<3.7.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7bf5be4efc711a9ee6f6bd5ba9d2a8d", + "name": "opentracing_instrumentation", + "sha256": "d47cdf7541036ae73ff7dda7d42050cee151acc072ac87b13a747ecf6a4e1f35", + "size": 35733, + "subdir": "linux-64", + "timestamp": 1510720308140, + "version": "2.3.0" + }, + "opentracing_instrumentation-2.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "futures", + "opentracing >=1.1,<1.3", + "python >=2.7,<2.8.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9cc34c57594d4d4275aa607c480d9572", + "name": "opentracing_instrumentation", + "sha256": "10c8bc67c455acca180e4dfad79c1fe36f5e7aa3c61dd1af9a0ad27f12bcc898", + "size": 35063, + "subdir": "linux-64", + "timestamp": 1519485873094, + "version": "2.4.0" + }, + "opentracing_instrumentation-2.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<1.3", + "python >=3.5,<3.6.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b845547b180a7dfed07eca0ffb60cbd5", + "name": "opentracing_instrumentation", + "sha256": "8fdb13683c7423068b9b96086758bce3ff001dfe3be8234710b30b65c5223027", + "size": 36121, + "subdir": "linux-64", + "timestamp": 1519485896266, + "version": "2.4.0" + }, + "opentracing_instrumentation-2.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<1.3", + "python >=3.6,<3.7.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d61b246f2eee81aafcf446fb9e1a6b2", + "name": "opentracing_instrumentation", + "sha256": "ea94253685cd6c1e9a43b55d4458ba23285090c6ce7c2e2209f5af9039984c79", + "size": 35869, + "subdir": "linux-64", + "timestamp": 1519485864780, + "version": "2.4.0" + }, + "opentracing_instrumentation-2.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "futures", + "opentracing >=1.1,<1.3", + "python >=2.7,<2.8.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ba82330f4d384c70cfe6d5bb6849214", + "name": "opentracing_instrumentation", + "sha256": "6b33d11c65dd64708253d380a8566c50daf43b2cbccdbc564a65caaabaf6f912", + "size": 35555, + "subdir": "linux-64", + "timestamp": 1524509922856, + "version": "2.4.1" + }, + "opentracing_instrumentation-2.4.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "contextlib2", + "future", + "futures", + "opentracing >=1.1,<2", + "python >=2.7,<2.8.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5d4e81736c94389b53011f6010c3159", + "name": "opentracing_instrumentation", + "sha256": "a6ce7f13cf7b2212b5bc03bfed056b0be69802caee021ea1593e2fa6c3de0e97", + "size": 35397, + "subdir": "linux-64", + "timestamp": 1530902419670, + "version": "2.4.1" + }, + "opentracing_instrumentation-2.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<1.3", + "python >=3.5,<3.6.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0cc295059a78fdcf769f4d12b50cbb9", + "name": "opentracing_instrumentation", + "sha256": "9b08aa06f78fd26fcc6e3a6aa20be3f514224db4a8439e901e8b3f61724ae372", + "size": 36146, + "subdir": "linux-64", + "timestamp": 1524509930924, + "version": "2.4.1" + }, + "opentracing_instrumentation-2.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<1.3", + "python >=3.6,<3.7.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c80378618550d739ff2a9d4ea0b7b2c", + "name": "opentracing_instrumentation", + "sha256": "3a92d00fe099379468c2d80c222103cf59ca6f9924af5200694b426d6e8aeac7", + "size": 36215, + "subdir": "linux-64", + "timestamp": 1524509932161, + "version": "2.4.1" + }, + "opentracing_instrumentation-2.4.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<2", + "python >=3.6,<3.7.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c677382dee0d6856d86767fc6aa3894", + "name": "opentracing_instrumentation", + "sha256": "bddaf2bbdc3542464169a0a00064dee9e5868ef897066e88f4d7c4605757df31", + "size": 36062, + "subdir": "linux-64", + "timestamp": 1530902390175, + "version": "2.4.1" + }, + "opentracing_instrumentation-2.4.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<2", + "python >=3.7,<3.8.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "226c68cdc11075b674909cc396751349", + "name": "opentracing_instrumentation", + "sha256": "6164d30da0688aa30559e954252af460d7d7cabae5ae7754ecfc6491c73502eb", + "size": 36102, + "subdir": "linux-64", + "timestamp": 1530902359937, + "version": "2.4.1" + }, + "opentracing_instrumentation-2.4.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<2", + "python >=2.7,<2.8.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "881d8b745fe0fbeff6aa7da0eeac31bd", + "name": "opentracing_instrumentation", + "sha256": "c9f99fe3d24abc0f885cca7e9d821fb4902ca3247b137a280f9a7ab3b6cddb52", + "size": 37165, + "subdir": "linux-64", + "timestamp": 1536110353858, + "version": "2.4.3" + }, + "opentracing_instrumentation-2.4.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<2", + "python >=3.5,<3.6.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6738e48965cc7f89d599eced9f9e944", + "name": "opentracing_instrumentation", + "sha256": "93e7365f6cc2059b5e9b87efc7d2f1698d42014a0613b969703bb6d7c8d7e252", + "size": 38242, + "subdir": "linux-64", + "timestamp": 1536110422853, + "version": "2.4.3" + }, + "opentracing_instrumentation-2.4.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<2", + "python >=3.6,<3.7.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6457e4870a03af4470fd6daa7c96f30d", + "name": "opentracing_instrumentation", + "sha256": "9e6b9fa16a9f38123cbbe26739d775ff4492530670428a73a74bcd5d622f1213", + "size": 37438, + "subdir": "linux-64", + "timestamp": 1536110328929, + "version": "2.4.3" + }, + "opentracing_instrumentation-2.4.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=1.1,<2", + "python >=3.7,<3.8.0a0", + "six", + "tornado >=4.1", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "78fc797f662c536a8a32cca04c73dc3d", + "name": "opentracing_instrumentation", + "sha256": "b9e85d7feb62999033e3721eac4da76c6b417d42892ace9b3b7a0736de180591", + "size": 37472, + "subdir": "linux-64", + "timestamp": 1536110406492, + "version": "2.4.3" + }, + "opentracing_instrumentation-3.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "futures", + "opentracing >=2,<3", + "python >=2.7,<2.8.0a0", + "six", + "tornado >=4.1,<5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0aa2758bd0758837b8c07b104a06044", + "name": "opentracing_instrumentation", + "sha256": "58d6198875c011806128ed3ea39a3af7ed055193845457fc1931ad08516e8190", + "size": 41936, + "subdir": "linux-64", + "timestamp": 1559921574029, + "version": "3.0.1" + }, + "opentracing_instrumentation-3.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=2,<3", + "python >=3.6,<3.7.0a0", + "six", + "tornado >=4.1,<5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0bc0851c3f405ccd9b23bf78addd05a", + "name": "opentracing_instrumentation", + "sha256": "8785893940aac681f31934f8a51a309024e8bfc0e0ff10d185950fd2b0ee4680", + "size": 42682, + "subdir": "linux-64", + "timestamp": 1559921567107, + "version": "3.0.1" + }, + "opentracing_instrumentation-3.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=2,<3", + "python >=3.7,<3.8.0a0", + "six", + "tornado >=4.1,<5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3efe190a47fe3d8ddac1d4b9e851d10", + "name": "opentracing_instrumentation", + "sha256": "a423d686d1ebcbec698faba83fc2ac1a5193c08a5554e8b13cc5749335bf7fc4", + "size": 42738, + "subdir": "linux-64", + "timestamp": 1559921556782, + "version": "3.0.1" + }, + "opentracing_instrumentation-3.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "futures", + "opentracing >=2,<3", + "python >=2.7,<2.8.0a0", + "six", + "tornado >=4.1,<5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8ff837ec0340cec446a28d2f7a1b78d", + "name": "opentracing_instrumentation", + "sha256": "826d64e70c536d8c7cb75e0817a76bb304635bdd69ed5557b016c5ed89773cb1", + "size": 47066, + "subdir": "linux-64", + "timestamp": 1564682602850, + "version": "3.1.1" + }, + "opentracing_instrumentation-3.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=2,<3", + "python >=3.6,<3.7.0a0", + "six", + "tornado >=4.1,<5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c66ea5deac62e0141efb18b19b9daa4", + "name": "opentracing_instrumentation", + "sha256": "a547e7df19c3f1c61b62173f458d5adbfdd436ff705c1d8f7c57000c0c22ec3f", + "size": 47725, + "subdir": "linux-64", + "timestamp": 1564682689268, + "version": "3.1.1" + }, + "opentracing_instrumentation-3.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "contextlib2", + "future", + "opentracing >=2,<3", + "python >=3.7,<3.8.0a0", + "six", + "tornado >=4.1,<5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ecba9f893fd197aebb75098b16ad81f6", + "name": "opentracing_instrumentation", + "sha256": "1fd7754b9071e222cca05cb42b66a7e176cd341194c77f00850a0addc8e6d50e", + "size": 47801, + "subdir": "linux-64", + "timestamp": 1564682529383, + "version": "3.1.1" + }, + "opentsne-0.3.11-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.38.1", + "numpy >=1.14.6,<2.0a0", + "pynndescent >=0.3", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6e513b330808dfb34018f90fceef97f6", + "name": "opentsne", + "sha256": "edbd0d7737d1c118d513a01bae534306a69f07b7f36624b53b6b20e3cf714bf4", + "size": 453192, + "subdir": "linux-64", + "timestamp": 1568037207773, + "version": "0.3.11" + }, + "opentsne-0.3.11-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.38.1", + "numpy >=1.14.6,<2.0a0", + "pynndescent >=0.3", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b60f68bdd4fb59e67c82ef064e1db37b", + "name": "opentsne", + "sha256": "f64b1f7ec4367db72233deb347912277740680bf2891dc6ca39daac887aaa75a", + "size": 452478, + "subdir": "linux-64", + "timestamp": 1568037036621, + "version": "0.3.11" + }, + "opentsne-0.3.11-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numba >=0.38.1", + "numpy >=1.14.6,<2.0a0", + "pynndescent >=0.3", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "313414f0d1341366a9d7ab044231fc2a", + "name": "opentsne", + "sha256": "518f86cb0b77813a696203c506030acc83051173ac5d4f8f4d754d07eeee7b69", + "size": 305495, + "subdir": "linux-64", + "timestamp": 1574087201489, + "version": "0.3.11" + }, + "opentsne-0.4.3-py36hfd86e86_1.conda": { + "build": "py36hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numba >=0.38.1", + "numpy >=1.14.6,<2.0a0", + "pynndescent >=0.3", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2081dcc16f9644f795bff054a15d67ac", + "name": "opentsne", + "sha256": "e2ca84c91f7debd39c3858b10f065ea06cea1652cd2e7478f8cfbeaf1d1ae5ce", + "size": 555048, + "subdir": "linux-64", + "timestamp": 1594138770328, + "version": "0.4.3" + }, + "opentsne-0.4.3-py37hfd86e86_1.conda": { + "build": "py37hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numba >=0.38.1", + "numpy >=1.14.6,<2.0a0", + "pynndescent >=0.3", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "906e7a82cfe4834b96f9cd8d11813815", + "name": "opentsne", + "sha256": "ab4a3a9ba3bb9081f6ff83646fcf1fbe379eae272f44ec61f3fc31a997e3d04d", + "size": 554589, + "subdir": "linux-64", + "timestamp": 1594138766260, + "version": "0.4.3" + }, + "opentsne-0.4.3-py38hfd86e86_1.conda": { + "build": "py38hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numba >=0.38.1", + "numpy >=1.14.6,<2.0a0", + "pynndescent >=0.3", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0d2c6d7c7cb0b843217f89eba5551e9a", + "name": "opentsne", + "sha256": "8e0c333b05c91e2dfe3c101d1a89014f6173d91b5490a9588f09a49fd32d09f7", + "size": 567426, + "subdir": "linux-64", + "timestamp": 1594138775855, + "version": "0.4.3" + }, + "opentsne-0.6.2-py310h3c18c91_0.conda": { + "build": "py310h3c18c91_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "fftw", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a1938796d7e9721751f7996d1260f15b", + "name": "opentsne", + "sha256": "dc0ebf4a6c812acf197acb919716e8ff0a9d4b969478d61fc3329c89000a255b", + "size": 1810341, + "subdir": "linux-64", + "timestamp": 1659348862208, + "version": "0.6.2" + }, + "opentsne-0.6.2-py311heed92f4_0.conda": { + "build": "py311heed92f4_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "fftw", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.11,<3.12.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f5b08fd3c9d721a95596231151ebc34e", + "name": "opentsne", + "sha256": "44af42b65f6d7fe134c18fa3f9c833db7cccfc9a9da0e26e2d0f5e632b93b515", + "size": 397966, + "subdir": "linux-64", + "timestamp": 1676860128095, + "version": "0.6.2" + }, + "opentsne-0.6.2-py37h79cecc1_0.conda": { + "build": "py37h79cecc1_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "fftw", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9ac8808c2834d5ed59f75f77864e3864", + "name": "opentsne", + "sha256": "bd31cbbfe8f6617e413a848de959054658b8fb20db4ffb974c6e2cf1cfb7c5fa", + "size": 382621, + "subdir": "linux-64", + "timestamp": 1659348667991, + "version": "0.6.2" + }, + "opentsne-0.6.2-py38h79cecc1_0.conda": { + "build": "py38h79cecc1_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "fftw", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7aedb0f094aac19222fdcb3eb2cd8eba", + "name": "opentsne", + "sha256": "59eefd2fd2c038c3d2aea888811fa67a91f06558669e241c415c5ec4b49564b8", + "size": 394295, + "subdir": "linux-64", + "timestamp": 1659348579553, + "version": "0.6.2" + }, + "opentsne-0.6.2-py39h79cecc1_0.conda": { + "build": "py39h79cecc1_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "fftw", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.20", + "scipy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "56a6d392db0d4364f4e6c731ac236ad8", + "name": "opentsne", + "sha256": "28fa16ce377f9c72c384d963c3ecbdeab9a5349c85b143c7199fefc66db51e5d", + "size": 395184, + "subdir": "linux-64", + "timestamp": 1659348754424, + "version": "0.6.2" + }, + "optax-0.1.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "chex >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.21,<2", + "python >=3.10,<3.11.0a0", + "typing_extensions >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fd7ee06cc5593d37fbd8026cfe1b074a", + "name": "optax", + "sha256": "5542032b2759373495d359fda24462916742043061376fe989fe2b6995129acb", + "size": 214636, + "subdir": "linux-64", + "timestamp": 1670009662821, + "version": "0.1.4" + }, + "optax-0.1.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "chex >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.21,<2", + "python >=3.11,<3.12.0a0", + "typing_extensions >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d9334bf94a1b9c71f4638a008ad2fa0b", + "name": "optax", + "sha256": "60e81f083007a1be66e76ce106b0cd6286025b288f4159968817fbe58a6f00e3", + "size": 275553, + "subdir": "linux-64", + "timestamp": 1676860145693, + "version": "0.1.4" + }, + "optax-0.1.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "chex >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.20,<2", + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "85439d8e3b9765a6ecefaa489d0e5d02", + "name": "optax", + "sha256": "fbc608bb94baf53fafd83d5dfd394af4a9cf47103aa95356d7018800ce5a09b6", + "size": 210660, + "subdir": "linux-64", + "timestamp": 1670009632057, + "version": "0.1.4" + }, + "optax-0.1.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "chex >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.20,<2", + "python >=3.8,<3.9.0a0", + "typing_extensions >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bf3173d68e44d75f4603ca2ae7a37e65", + "name": "optax", + "sha256": "1322311a4c22bc37d6a6d8397fb71c540c6ec865a956a8e4fb6509f338dcf340", + "size": 212883, + "subdir": "linux-64", + "timestamp": 1670009566717, + "version": "0.1.4" + }, + "optax-0.1.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "chex >=0.1.5", + "jax >=0.1.55", + "jaxlib >=0.1.37", + "numpy >=1.20,<2", + "python >=3.9,<3.10.0a0", + "typing_extensions >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1687c668212de771c20d9c6c63596368", + "name": "optax", + "sha256": "dbbad7b959764e8c3256bcfe71cae24166bc12e322f125e3d222411d32739c70", + "size": 213233, + "subdir": "linux-64", + "timestamp": 1670009600947, + "version": "0.1.4" + }, + "optimum-1.4.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "coloredlogs", + "huggingface_hub >=0.8.0", + "numpy", + "packaging", + "python >=3.10,<3.11.0a0", + "pytorch >=1.9", + "sympy", + "transformers >=4.20.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5ddf9534ba1161e62d2cba09f67b3329", + "name": "optimum", + "sha256": "79dfb65b08379c70f103e1cc42d7c326203505baf3f5047601420ac0df479041", + "size": 183771, + "subdir": "linux-64", + "timestamp": 1668102540890, + "version": "1.4.1" + }, + "optimum-1.4.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "coloredlogs", + "huggingface_hub >=0.8.0", + "numpy", + "packaging", + "python >=3.7,<3.8.0a0", + "pytorch >=1.9", + "sympy", + "transformers >=4.20.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "948311fd01aa71cf01f464799d7782e3", + "name": "optimum", + "sha256": "0958ba66ba17263385730cec321ea4087b9984b592ab4b4060a01c02d9ec090a", + "size": 180321, + "subdir": "linux-64", + "timestamp": 1668102615946, + "version": "1.4.1" + }, + "optimum-1.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "coloredlogs", + "huggingface_hub >=0.8.0", + "numpy", + "packaging", + "python >=3.8,<3.9.0a0", + "pytorch >=1.9", + "sympy", + "transformers >=4.20.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d2675446b0197a1fb4b0d84e7526ec32", + "name": "optimum", + "sha256": "bea0bde7e9440d7daeef7315d20a0deb7b15673306ed6eb7f33ee8ffeca8ef1a", + "size": 181762, + "subdir": "linux-64", + "timestamp": 1668102499926, + "version": "1.4.1" + }, + "optimum-1.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "coloredlogs", + "huggingface_hub >=0.8.0", + "numpy", + "packaging", + "python >=3.9,<3.10.0a0", + "pytorch >=1.9", + "sympy", + "transformers >=4.20.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c4d3f7c95bac15571e104d226be86588", + "name": "optimum", + "sha256": "9d3238416c3cad1ce3eb8ee210bc99a089bf628fa810c7a382a05145fb0a81f0", + "size": 181710, + "subdir": "linux-64", + "timestamp": 1668102578234, + "version": "1.4.1" + }, + "optional-lite-3.5.0-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSL-1.0", + "license_family": "Other", + "md5": "16863b8a31c7fbd68d88d04c2bc89b5f", + "name": "optional-lite", + "sha256": "06f8d05ee93fe8572885ca94944467daa8ef0cdc041019362fc34be42d0470f4", + "size": 16185, + "subdir": "linux-64", + "timestamp": 1659013253086, + "version": "3.5.0" + }, + "orange-canvas-core-0.1.27-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "cachecontrol >=0.12.6", + "commonmark >=0.8.1", + "dictdiffer", + "docutils", + "importlib_metadata", + "lockfile >=0.9", + "pip >=18.0", + "pyqt", + "python >=3.10,<3.11.0a0", + "qasync", + "requests", + "setuptools", + "wheel" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "159c7e5d518a5caaf34f645f8a917b7b", + "name": "orange-canvas-core", + "sha256": "60e0dcc4124b63d1193ddb8d6f3fcd3398d5245d437daf19a9691ea60511dafb", + "size": 743335, + "subdir": "linux-64", + "timestamp": 1659464138544, + "version": "0.1.27" + }, + "orange-canvas-core-0.1.27-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "cachecontrol >=0.12.6", + "commonmark >=0.8.1", + "dictdiffer", + "docutils", + "importlib_metadata", + "lockfile >=0.9", + "pip >=18.0", + "pyqt", + "python >=3.11,<3.12.0a0", + "qasync", + "requests", + "setuptools", + "wheel" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "a655b1a66a01513ad72c9a9cbc80d024", + "name": "orange-canvas-core", + "sha256": "67f3b5eced4609fc3a81ba8a400ac5156f7ab628e8fd0a0089fbe6d138a395d7", + "size": 980332, + "subdir": "linux-64", + "timestamp": 1676845102500, + "version": "0.1.27" + }, + "orange-canvas-core-0.1.27-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "cachecontrol >=0.12.6", + "commonmark >=0.8.1", + "dictdiffer", + "docutils", + "importlib_metadata", + "lockfile >=0.9", + "pip >=18.0", + "pyqt", + "python >=3.7,<3.8.0a0", + "qasync", + "requests", + "setuptools", + "wheel" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "b76850f8dc319603277351e34ac345ff", + "name": "orange-canvas-core", + "sha256": "0ddc8ea5f2622d578b256be51e5d4a05a108a588796f465a3bb66a3446660b2a", + "size": 732074, + "subdir": "linux-64", + "timestamp": 1659464174151, + "version": "0.1.27" + }, + "orange-canvas-core-0.1.27-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "cachecontrol >=0.12.6", + "commonmark >=0.8.1", + "dictdiffer", + "docutils", + "importlib_metadata", + "lockfile >=0.9", + "pip >=18.0", + "pyqt", + "python >=3.8,<3.9.0a0", + "qasync", + "requests", + "setuptools", + "wheel" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "797ee24dddf58959d5e8ac1b95a05cae", + "name": "orange-canvas-core", + "sha256": "cb22e64fabf3f08a72cc491ad8954e43a4a3578a2f1bfdfc3a5fc911700f937d", + "size": 738476, + "subdir": "linux-64", + "timestamp": 1659464191740, + "version": "0.1.27" + }, + "orange-canvas-core-0.1.27-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "cachecontrol >=0.12.6", + "commonmark >=0.8.1", + "dictdiffer", + "docutils", + "importlib_metadata", + "lockfile >=0.9", + "pip >=18.0", + "pyqt", + "python >=3.9,<3.10.0a0", + "qasync", + "requests", + "setuptools", + "wheel" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "25a855e70bac5d46f7ff508a8c57267d", + "name": "orange-canvas-core", + "sha256": "c23666992eef37ea49de08fadce88478671d3049efa33a3337de9a21d92bacbb", + "size": 735839, + "subdir": "linux-64", + "timestamp": 1659464156200, + "version": "0.1.27" + }, + "orange-widget-base-4.17.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "matplotlib-base", + "orange-canvas-core >=0.1.20,<0.2a", + "pyqtgraph", + "python >=3.10,<3.11.0a0", + "typing_extensions >=3.7.4.3" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "6012127c244bedcef9c2b2f8cc94d130", + "name": "orange-widget-base", + "sha256": "9c1304ace7c0941b397e3bd51068ee7164e10e66815dbecb26240a4ac9b2b273", + "size": 407395, + "subdir": "linux-64", + "timestamp": 1659466969371, + "version": "4.17.0" + }, + "orange-widget-base-4.17.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "matplotlib-base", + "orange-canvas-core >=0.1.20,<0.2a", + "pyqtgraph", + "python >=3.11,<3.12.0a0", + "typing_extensions >=3.7.4.3" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "f5bd5d09924378a38abfc8d4529e405f", + "name": "orange-widget-base", + "sha256": "e1aad238e31e76c46c0ed1df188a6007e482a40171ebd31d058a770119611ed4", + "size": 543882, + "subdir": "linux-64", + "timestamp": 1676860161609, + "version": "4.17.0" + }, + "orange-widget-base-4.17.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "matplotlib-base", + "orange-canvas-core >=0.1.20,<0.2a", + "pyqtgraph", + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.7.4.3" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "aba16143841eb1c77643317b6da1438b", + "name": "orange-widget-base", + "sha256": "b78c381728f636d505c46ca2516e93ef7ff09fe1007397a3e2a6d4af8bb387af", + "size": 399666, + "subdir": "linux-64", + "timestamp": 1659466863726, + "version": "4.17.0" + }, + "orange-widget-base-4.17.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "matplotlib-base", + "orange-canvas-core >=0.1.20,<0.2a", + "pyqtgraph", + "python >=3.8,<3.9.0a0", + "typing_extensions >=3.7.4.3" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "c70ce18b0bd06e30209eb78795a19bbf", + "name": "orange-widget-base", + "sha256": "c8e45d62a1ae78aac0233d51287b9d713d2e5409b701cb4918ed15e4ca8c2b51", + "size": 402753, + "subdir": "linux-64", + "timestamp": 1659466925421, + "version": "4.17.0" + }, + "orange-widget-base-4.17.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "anyqt >=0.1.0", + "matplotlib-base", + "orange-canvas-core >=0.1.20,<0.2a", + "pyqtgraph", + "python >=3.9,<3.10.0a0", + "typing_extensions >=3.7.4.3" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "780aa2ca66695d58ced1c9e573ee62d3", + "name": "orange-widget-base", + "sha256": "5b99304ca857399d3cb6074f3f7a891aef839a86cbe493187776e60cb469df74", + "size": 402969, + "subdir": "linux-64", + "timestamp": 1659466894211, + "version": "4.17.0" + }, + "orange3-3.11.0-py35h637b7d7_0.conda": { + "app_entry": "orange-canvas", + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "anyqt", + "bottleneck", + "chardet >=2.3.0", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pip", + "pyqtgraph", + "python >=3.5,<3.6.0a0", + "scikit-learn >=0.18.1", + "scipy", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "bdd0dca6a05dcf4f332b11026d7685f9", + "name": "orange3", + "sha256": "1541297b1ec3a2426ba32a9c78906e4bf81058c8c283b14b08940c0e76c72941", + "size": 4251297, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1521131534635, + "type": "app", + "version": "3.11.0" + }, + "orange3-3.11.0-py36h637b7d7_0.conda": { + "app_entry": "orange-canvas", + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "anyqt", + "bottleneck", + "chardet >=2.3.0", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pip", + "pyqtgraph", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.18.1", + "scipy", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "89b3dc9448231d6403efe88c0c15f515", + "name": "orange3", + "sha256": "e38b7b739d88d77cf42022cd4ac7f787cf1371dd88de8902dff6948ddf23fb93", + "size": 4226454, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1521131536175, + "type": "app", + "version": "3.11.0" + }, + "orange3-3.13.0-py35h637b7d7_0.conda": { + "app_entry": "orange-canvas", + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.5,<3.6.0a0", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "9d5f560dcd5adc65ddda7ee296a1b9c9", + "name": "orange3", + "sha256": "b0d7ebe7fbcb6ccb268944e37268019df61d4391882179ba5bd4c31456507f2b", + "size": 4249855, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1524107994339, + "type": "app", + "version": "3.13.0" + }, + "orange3-3.13.0-py36h04863e7_0.conda": { + "app_entry": "orange-canvas", + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "7766e8c936d83c1b9530c1472d3adfaf", + "name": "orange3", + "sha256": "154637eb49c96fb0d22f987706a56e124fa72ec86844f1f83546000fe27a24e4", + "size": 4471515, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1530903101534, + "type": "app", + "version": "3.13.0" + }, + "orange3-3.13.0-py36h637b7d7_0.conda": { + "app_entry": "orange-canvas", + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "d2794f20505cf3fb81206da83badbb4a", + "name": "orange3", + "sha256": "38046fb6e9a8bf595e3a1165fba6d981fc4a20e57517e44f7df7ac07256dafeb", + "size": 4215435, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1524108263804, + "type": "app", + "version": "3.13.0" + }, + "orange3-3.13.0-py37h04863e7_0.conda": { + "app_entry": "orange-canvas", + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "a6cc5011ca926485da6bbe988b4e5f79", + "name": "orange3", + "sha256": "76b6f063815320c67c328981566d06324020b61ca6212dd5a8404078ca73a4b8", + "size": 4477472, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1530902922503, + "type": "app", + "version": "3.13.0" + }, + "orange3-3.15.0-py35h962f231_0.conda": { + "app_entry": "orange-canvas", + "build": "py35h962f231_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.5,<3.6.0a0", + "python-louvain", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "7bb0c2c20ea77954876025ff1dea7f87", + "name": "orange3", + "sha256": "f7febdd8e5840b57cec4c197c1916ef3cc55d328beb90f9ac1e7f431c861cf3d", + "size": 4525039, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1535786763979, + "type": "app", + "version": "3.15.0" + }, + "orange3-3.15.0-py36h962f231_0.conda": { + "app_entry": "orange-canvas", + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "python-louvain", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "a4afa2f084a9e51befd6815af1f3397f", + "name": "orange3", + "sha256": "726f7afcbf088d075fcf941c6300f0423aeefe97a8103b7492b4e025aeba4f39", + "size": 4507407, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1535786606782, + "type": "app", + "version": "3.15.0" + }, + "orange3-3.15.0-py37h962f231_0.conda": { + "app_entry": "orange-canvas", + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.7,<3.8.0a0", + "python-louvain", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "f42ad58d1abb28f8acaced69c71b2d48", + "name": "orange3", + "sha256": "6a9b12f69dabf5cda04c04853d5ffa2d459f57e15298b7f979181953d1d5ea6d", + "size": 4518749, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1535786796366, + "type": "app", + "version": "3.15.0" + }, + "orange3-3.16.0-py35h962f231_0.conda": { + "app_entry": "orange-canvas", + "build": "py35h962f231_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.5,<3.6.0a0", + "python-louvain", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "07af1c44e6625c89e63156513dc4eae7", + "name": "orange3", + "sha256": "08b1b7b98b74d2203f82a33d75bf2dc289e011b3fbbd52a0f5e96a19840c522a", + "size": 4560895, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1537908859565, + "type": "app", + "version": "3.16.0" + }, + "orange3-3.16.0-py36h962f231_0.conda": { + "app_entry": "orange-canvas", + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "python-louvain", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "e23de0edee11a2687fdf929e1d75a97a", + "name": "orange3", + "sha256": "a571e15484df794279584ad0e548d4f0c1647806f86f9d060da9d6e68bb2c119", + "size": 4565741, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1537908863361, + "type": "app", + "version": "3.16.0" + }, + "orange3-3.16.0-py37h962f231_0.conda": { + "app_entry": "orange-canvas", + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.7,<3.8.0a0", + "python-louvain", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "6e72daa9540d951813436fb76c68da53", + "name": "orange3", + "sha256": "f4d11b751511c5bb6f624b906e91e73825eb8b8239f32c1e8a683055970b0258", + "size": 4531406, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1537908849558, + "type": "app", + "version": "3.16.0" + }, + "orange3-3.17.0-py36h962f231_0.conda": { + "app_entry": "orange-canvas", + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "python-louvain", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "c74508a47ea37df19c256b89c06950a3", + "name": "orange3", + "sha256": "7acf5ae27b8fa19c4ee83cb700c847b14318da2df8dab57259c889c12d045863", + "size": 4592845, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1540994059488, + "type": "app", + "version": "3.17.0" + }, + "orange3-3.17.0-py37h962f231_0.conda": { + "app_entry": "orange-canvas", + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "commonmark >=0.5.5", + "dill", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.11.3,<2.0a0", + "pip", + "pyqtgraph >=0.10.0", + "python >=3.7,<3.8.0a0", + "python-louvain", + "scikit-learn >=0.18.1", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL3", + "license_family": "GPL3", + "md5": "c2dc85e0748b6dc3edb074a008fcfb6b", + "name": "orange3", + "sha256": "0817d39eb419684d0b8293355ed25c596d064bd0ac04fc7851e3eabd1dada349", + "size": 4590170, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1540994053348, + "type": "app", + "version": "3.17.0" + }, + "orange3-3.19.0-py36he6710b0_0.conda": { + "app_entry": "orange-canvas", + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "docutils", + "fasttsne >=0.2.12", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.15.4,<2.0a0", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "python-louvain", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "45471be03b2cd9c356679bcc2550054d", + "name": "orange3", + "sha256": "24484e12789ed617e9b1a006c66c45e50092d28a19f5fdb1733eb2f4a7f3111a", + "size": 4698150, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1547969636997, + "type": "app", + "version": "3.19.0" + }, + "orange3-3.19.0-py37he6710b0_0.conda": { + "app_entry": "orange-canvas", + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "docutils", + "fasttsne >=0.2.12", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.15.4,<2.0a0", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.7,<3.8.0a0", + "python-louvain", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "f621dab43fa729d7ef750b3040d7b7db", + "name": "orange3", + "sha256": "398f2bc5689f99999e1a4ad1a93379ec72cfa8655de24ae2e9938825d49932dc", + "size": 4687074, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1547970744129, + "type": "app", + "version": "3.19.0" + }, + "orange3-3.23.0-py36he6710b0_0.conda": { + "app_entry": "orange-canvas", + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.16.4,<2.0a0", + "opentsne >=0.3.11", + "orange-canvas-core >=0.1.3,<0.2a", + "orange-widget-base >=4.0a,<4.1a", + "pandas", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "python-louvain >=0.13", + "pyyaml", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "f5ebf464f30cbfa337b9df9499697c34", + "name": "orange3", + "sha256": "f9cb5adc470e8585388ce83087221c138e1cddae0ff25e822f935315e67071b1", + "size": 3113423, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1568037694709, + "type": "app", + "version": "3.23.0" + }, + "orange3-3.23.0-py36he6710b0_1.conda": { + "app_entry": "orange-canvas", + "build": "py36he6710b0_1", + "build_number": 1, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.17.2,<2.0a0", + "opentsne >=0.3.11", + "orange-canvas-core >=0.1.3,<0.2a", + "orange-widget-base >=4.0a,<4.1a", + "pandas", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "python-louvain >=0.13", + "pyyaml", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "7381d887ebdff2721fd054c9bb2bfa74", + "name": "orange3", + "sha256": "1cfba59905343f7f122c611ad0313c8f623f991d103051e1b10a5f2872318d10", + "size": 3103760, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1569601384893, + "type": "app", + "version": "3.23.0" + }, + "orange3-3.23.0-py37he6710b0_0.conda": { + "app_entry": "orange-canvas", + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.16.4,<2.0a0", + "opentsne >=0.3.11", + "orange-canvas-core >=0.1.3,<0.2a", + "orange-widget-base >=4.0a,<4.1a", + "pandas", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.7,<3.8.0a0", + "python-louvain >=0.13", + "pyyaml", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "88090ffa2d470038e5d0718a6b40ad04", + "name": "orange3", + "sha256": "30e594d32f483168ccdae4bcb5c14faaedbe896e4d31c8b93024574ea22b3388", + "size": 3113531, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1568037870683, + "type": "app", + "version": "3.23.0" + }, + "orange3-3.23.0-py37he6710b0_1.conda": { + "app_entry": "orange-canvas", + "build": "py37he6710b0_1", + "build_number": 1, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.17.2,<2.0a0", + "opentsne >=0.3.11", + "orange-canvas-core >=0.1.3,<0.2a", + "orange-widget-base >=4.0a,<4.1a", + "pandas", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.7,<3.8.0a0", + "python-louvain >=0.13", + "pyyaml", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "16c898f01ba8a3b20589ff109b10b2c5", + "name": "orange3", + "sha256": "0157779a7f12f1a385a1f6417fafbdc604267df01f9747813ebfe7e56c3ac67c", + "size": 3114962, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1569601381548, + "type": "app", + "version": "3.23.0" + }, + "orange3-3.23.1-py36he6710b0_0.conda": { + "app_entry": "orange-canvas", + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx", + "numpy >=1.17.2,<2.0a0", + "opentsne >=0.3.11", + "orange-canvas-core >=0.1.7,<0.2a", + "orange-widget-base >=4.0a,<4.1a", + "pandas", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "python-louvain >=0.13", + "pyyaml", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "6f615943351ff193bc936b550ad12236", + "name": "orange3", + "sha256": "bebce0d397f11f5ef8e9fe43beb5b7ad000ee9779d0a9721d673f1bb4a8e65c2", + "size": 3113596, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1571239216002, + "type": "app", + "version": "3.23.1" + }, + "orange3-3.23.1-py37he6710b0_0.conda": { + "app_entry": "orange-canvas", + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "bottleneck >=1.0.0", + "chardet >=3.0.2", + "docutils", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx", + "numpy >=1.17.2,<2.0a0", + "opentsne >=0.3.11", + "orange-canvas-core >=0.1.7,<0.2a", + "orange-widget-base >=4.0a,<4.1a", + "pandas", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.7,<3.8.0a0", + "python-louvain >=0.13", + "pyyaml", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "8c40e7f1e45efba05960adfe0a8f1eef", + "name": "orange3", + "sha256": "cacd4e011e9f3aa7b33d0182a1698ffa382ebe7b4759ced8fd5d79ddcd2bbc14", + "size": 3111516, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1571239232235, + "type": "app", + "version": "3.23.1" + }, + "orange3-3.26.0-py36he6710b0_0.conda": { + "app_entry": "orange-canvas", + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "baycomp >=1.0.2", + "bottleneck >=1.0.0", + "cachecontrol >=0.12.6", + "chardet >=3.0.2", + "docutils", + "httpx >=0.12", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.18.5,<2.0a0", + "openpyxl", + "opentsne >=0.3.11", + "orange-canvas-core >=0.1.15,<0.2a", + "orange-widget-base >=4.6.0", + "pandas", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.6,<3.7.0a0", + "python-louvain >=0.13", + "pyyaml", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "478eb1d85b70a38bce0b368a7fd5d5e3", + "name": "orange3", + "sha256": "e01b07edb09c9d2f0e32b43c4ac6d7f98e70912d135f0e92307e29877fea13d8", + "size": 3440332, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1594070730847, + "type": "app", + "version": "3.26.0" + }, + "orange3-3.26.0-py37he6710b0_0.conda": { + "app_entry": "orange-canvas", + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "baycomp >=1.0.2", + "bottleneck >=1.0.0", + "cachecontrol >=0.12.6", + "chardet >=3.0.2", + "docutils", + "httpx >=0.12", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.18.5,<2.0a0", + "openpyxl", + "opentsne >=0.3.11", + "orange-canvas-core >=0.1.15,<0.2a", + "orange-widget-base >=4.6.0", + "pandas", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.7,<3.8.0a0", + "python-louvain >=0.13", + "pyyaml", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "7136560ca26bd3d5da82d365498e5a41", + "name": "orange3", + "sha256": "1315bdafaaa28c3682ed1ac79267b00a4585ae38eefafa8b570fc1411a92bd62", + "size": 3434172, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1594070739034, + "type": "app", + "version": "3.26.0" + }, + "orange3-3.26.0-py38he6710b0_0.conda": { + "app_entry": "orange-canvas", + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.8", + "baycomp >=1.0.2", + "bottleneck >=1.0.0", + "cachecontrol >=0.12.6", + "chardet >=3.0.2", + "docutils", + "httpx >=0.12", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "numpy >=1.18.5,<2.0a0", + "openpyxl", + "opentsne >=0.3.11", + "orange-canvas-core >=0.1.15,<0.2a", + "orange-widget-base >=4.6.0", + "pandas", + "pip >=9.0", + "pyqtgraph >=0.10.0", + "python >=3.8,<3.9.0a0", + "python-louvain >=0.13", + "pyyaml", + "requests", + "scikit-learn >=0.20.0", + "scipy >=0.16.1", + "serverfiles", + "setuptools >=36.3", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0", + "license_family": "GPL3", + "md5": "072f5046e7c78a5f639b6fea1d280ac0", + "name": "orange3", + "sha256": "db4586ad6f31ab056c657b470071d95baf0e476a30a98ea97959eea963e9465a", + "size": 3498015, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1594070755049, + "type": "app", + "version": "3.26.0" + }, + "orange3-3.32.0-py310h1128e8f_0.conda": { + "app_entry": "orange-canvas", + "build": "py310h1128e8f_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.13", + "baycomp >=1.0.2", + "bottleneck >=1.3.2", + "catboost !=1.0.0", + "chardet >=3.0.2", + "httpx >=0.21", + "ipykernel !=6.11.0", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.5", + "networkx", + "numpy >=1.17.3", + "numpy >=1.21.5,<2.0a0", + "openpyxl", + "opentsne >=0.6.1", + "orange-canvas-core >=0.1.24,<0.2a", + "orange-widget-base >=4.16.1", + "pandas >=1.3.0", + "pip >=18.0", + "pygments >=2.8.0", + "pyqt >=5.12,!=5.15.1", + "pyqtgraph >=0.11.1,!=0.12.4", + "pyqtwebengine >=5.12", + "python >=3.10,<3.11.0a0", + "python-louvain >=0.13", + "pyyaml", + "qtconsole >=4.7.2", + "requests", + "scikit-learn >=1.0.1", + "scipy >=1.3.1", + "serverfiles", + "setuptools >=41.0.0", + "xgboost", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0-or-later", + "md5": "33e5346948c9f2e91cebc10171a44044", + "name": "orange3", + "sha256": "c59686165b2438dfac6d2b851a5154196b6ff29888935ac0519d581b85f5d297", + "size": 28531523, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1659557086796, + "type": "app", + "version": "3.32.0" + }, + "orange3-3.32.0-py37h417a72b_0.conda": { + "app_entry": "orange-canvas", + "build": "py37h417a72b_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.13", + "baycomp >=1.0.2", + "bottleneck >=1.3.2", + "catboost !=1.0.0", + "chardet >=3.0.2", + "httpx >=0.21", + "ipykernel !=6.11.0", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.5", + "networkx", + "numpy >=1.16.6,<2.0a0", + "numpy >=1.17.3", + "openpyxl", + "opentsne >=0.6.1", + "orange-canvas-core >=0.1.24,<0.2a", + "orange-widget-base >=4.16.1", + "pandas >=1.3.0", + "pip >=18.0", + "pygments >=2.8.0", + "pyqt >=5.12,!=5.15.1", + "pyqtgraph >=0.11.1,!=0.12.4", + "pyqtwebengine >=5.12", + "python >=3.7,<3.8.0a0", + "python-louvain >=0.13", + "pyyaml", + "qtconsole >=4.7.2", + "requests", + "scikit-learn >=1.0.1", + "scipy >=1.3.1", + "serverfiles", + "setuptools >=41.0.0", + "xgboost", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0-or-later", + "md5": "d8ea40d21aae87261075ea83a962997f", + "name": "orange3", + "sha256": "be226ac72b715398c64ca71e515127ce26e59e20199a2a68c679c76dce3e5cfa", + "size": 27164285, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1659556942333, + "type": "app", + "version": "3.32.0" + }, + "orange3-3.32.0-py38h417a72b_0.conda": { + "app_entry": "orange-canvas", + "build": "py38h417a72b_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.13", + "baycomp >=1.0.2", + "bottleneck >=1.3.2", + "catboost !=1.0.0", + "chardet >=3.0.2", + "httpx >=0.21", + "ipykernel !=6.11.0", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.5", + "networkx", + "numpy >=1.16.6,<2.0a0", + "numpy >=1.17.3", + "openpyxl", + "opentsne >=0.6.1", + "orange-canvas-core >=0.1.24,<0.2a", + "orange-widget-base >=4.16.1", + "pandas >=1.3.0", + "pip >=18.0", + "pygments >=2.8.0", + "pyqt >=5.12,!=5.15.1", + "pyqtgraph >=0.11.1,!=0.12.4", + "pyqtwebengine >=5.12", + "python >=3.8,<3.9.0a0", + "python-louvain >=0.13", + "pyyaml", + "qtconsole >=4.7.2", + "requests", + "scikit-learn >=1.0.1", + "scipy >=1.3.1", + "serverfiles", + "setuptools >=41.0.0", + "xgboost", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0-or-later", + "md5": "e9780d417b9b1a58f5bd3f84e5e92ade", + "name": "orange3", + "sha256": "15ed9ab1630818b668d433a782f72ef069e11e130a98e5e3d46cc50e63b9f849", + "size": 27206565, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1659557212846, + "type": "app", + "version": "3.32.0" + }, + "orange3-3.32.0-py39h417a72b_0.conda": { + "app_entry": "orange-canvas", + "build": "py39h417a72b_0", + "build_number": 0, + "depends": [ + "anyqt >=0.0.13", + "baycomp >=1.0.2", + "bottleneck >=1.3.2", + "catboost !=1.0.0", + "chardet >=3.0.2", + "httpx >=0.21", + "ipykernel !=6.11.0", + "joblib >=0.9.4", + "keyring", + "keyrings.alt", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.5", + "networkx", + "numpy >=1.16.6,<2.0a0", + "numpy >=1.17.3", + "openpyxl", + "opentsne >=0.6.1", + "orange-canvas-core >=0.1.24,<0.2a", + "orange-widget-base >=4.16.1", + "pandas >=1.3.0", + "pip >=18.0", + "pygments >=2.8.0", + "pyqt >=5.12,!=5.15.1", + "pyqtgraph >=0.11.1,!=0.12.4", + "pyqtwebengine >=5.12", + "python >=3.9,<3.10.0a0", + "python-louvain >=0.13", + "pyyaml", + "qtconsole >=4.7.2", + "requests", + "scikit-learn >=1.0.1", + "scipy >=1.3.1", + "serverfiles", + "setuptools >=41.0.0", + "xgboost", + "xlrd >=0.9.2", + "xlsxwriter" + ], + "icon": "7174a3206fb39f6d383b8f26840e8e6e.png", + "license": "GPL-3.0-or-later", + "md5": "5c5486ea818422579a33efc501462ec4", + "name": "orange3", + "sha256": "a330eb0c79696e0df5b4ac81589764768bfcf78c0107f43cc18d5c3c42bb828f", + "size": 27206365, + "subdir": "linux-64", + "summary": "data visualization and data analysis tool", + "timestamp": 1659557338480, + "type": "app", + "version": "3.32.0" + }, + "orc-1.4.3-hdbcaa40_0.conda": { + "build": "hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "protobuf", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "f70db73666739121b339c2be8e3e60bf", + "name": "orc", + "sha256": "4c48a586c3fca6d25def37bfab285054474ae7da7913365092f012cfcf2a4440", + "size": 647420, + "subdir": "linux-64", + "timestamp": 1529458834856, + "version": "1.4.3" + }, + "orc-1.5.1-hdbcaa40_0.conda": { + "build": "hdbcaa40_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "protobuf", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "4018ae9d187273ac4c3e0096fd678a32", + "name": "orc", + "sha256": "2cbc2f8bab435f862a60e39285d99350d384da41d0c2ff1647e2198e0f75743f", + "size": 1510201, + "subdir": "linux-64", + "timestamp": 1529508837719, + "version": "1.5.1" + }, + "orc-1.5.6-h45e4b6e_0.conda": { + "build": "h45e4b6e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "93e8bbe4100c1933bcba6e49459ada79", + "name": "orc", + "sha256": "06f77ff58eaeb5a9b3369b30203dea957d6518856164564e2572abba3051fea9", + "size": 1723080, + "subdir": "linux-64", + "timestamp": 1567109684474, + "version": "1.5.6" + }, + "orc-1.6.2-h69b9f2a_0.conda": { + "build": "h69b9f2a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9fc92105546c4cec6a5092c4c8b6a737", + "name": "orc", + "sha256": "b695a05bdf2d3b339d2dad27a2b9ed83aa46c1e1736f71aecb456bbc5bf52ef5", + "size": 2141171, + "subdir": "linux-64", + "timestamp": 1585309488741, + "version": "1.6.2" + }, + "orc-1.6.2-h69b9f2a_1.conda": { + "build": "h69b9f2a_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3f1a5df563ee2f4f705ff86946cf8506", + "name": "orc", + "sha256": "40c2d837546506116f65cec800acb65eccea61c6bfb55c80c0cfa5600282e874", + "size": 2129404, + "subdir": "linux-64", + "timestamp": 1580397676085, + "version": "1.6.2" + }, + "orc-1.6.2-hf484d3e_1.conda": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.4,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "snappy >=1.1.7,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0fa8221945786f2187694416bef47ecd", + "name": "orc", + "sha256": "330f24dbc4f1d47be91e10c26d5a9a3917ca553d15e8a94f508aaa774b3a4ed0", + "size": 2130082, + "subdir": "linux-64", + "timestamp": 1585309599304, + "version": "1.6.2" + }, + "orc-1.6.4-h69b9f2a_0.conda": { + "build": "h69b9f2a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ffe05529215d63bf79a85dd1a4de22b2", + "name": "orc", + "sha256": "2965280f92c960dd899e83760cbd543298726447883155ffd926d82f159d2633", + "size": 2241806, + "subdir": "linux-64", + "timestamp": 1601509287869, + "version": "1.6.4" + }, + "orc-1.6.4-hc68dd99_0.conda": { + "build": "hc68dd99_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7f5c3755dd507c219ad4d36c61f218ec", + "name": "orc", + "sha256": "ac911b60c46eb5ea2c799066e57832f10550c4d493fb5b0535a9aa882ac26179", + "size": 2265381, + "subdir": "linux-64", + "timestamp": 1601509344313, + "version": "1.6.4" + }, + "orc-1.6.5-h31f52df_2.conda": { + "build": "h31f52df_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "snappy >=1.1.8,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "01cc58c67828dee36445d59538ad1cf4", + "name": "orc", + "sha256": "97d7d360fa50d71c82a5a871df3ac6a815775171d256a70d6915dc103529f37c", + "size": 605035, + "subdir": "linux-64", + "timestamp": 1607217205492, + "version": "1.6.5" + }, + "orc-1.6.5-h973521d_1.conda": { + "build": "h973521d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "snappy >=1.1.8,<2.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.5,<1.5.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4bf2548c1cac9d375e9512e88d27cbe5", + "name": "orc", + "sha256": "ae8fea87bc84e1fc221dde85a3efa6514e0674be0f758ff952f70e3f50047e1a", + "size": 601407, + "subdir": "linux-64", + "timestamp": 1607048310084, + "version": "1.6.5" + }, + "orc-1.6.7-h973521d_2.conda": { + "build": "h973521d_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "snappy >=1.1.8,<2.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3078466b66836db45dd280f379c25258", + "name": "orc", + "sha256": "769b5c8ea11554adc944051d5a021f94f70d4153202e7207f4e47d205a5b3533", + "size": 642392, + "subdir": "linux-64", + "timestamp": 1619508612546, + "version": "1.6.7" + }, + "orc-1.6.8-h973521d_2.conda": { + "build": "h973521d_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "snappy >=1.1.8,<2.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "da11a62aab5f7bfed4802ba3db198e21", + "name": "orc", + "sha256": "9253cdc301547b30833f89fb2c04ccd1b1d2b7a9d070a316b04aff19a1aea4b5", + "size": 638372, + "subdir": "linux-64", + "timestamp": 1623089849857, + "version": "1.6.8" + }, + "orc-1.6.9-h14377d0_2.conda": { + "build": "h14377d0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "snappy >=1.1.8,<2.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b94a879332ef85c1271206231b293a66", + "name": "orc", + "sha256": "4a8b55dfb4c82682ba212aa71db86fd8fb821afeaa6d87c4de7f259fc945e5c0", + "size": 638734, + "subdir": "linux-64", + "timestamp": 1625642988664, + "version": "1.6.9" + }, + "orc-1.6.9-ha97a36c_3.conda": { + "build": "ha97a36c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "snappy >=1.1.8,<2.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e86ce44715168601f640f0383ab24ea4", + "name": "orc", + "sha256": "1ee955d1cafef28a4009dcd846b0950a5e6436a389040a5fa8d23caadb5c1155", + "size": 638039, + "subdir": "linux-64", + "timestamp": 1631219336906, + "version": "1.6.9" + }, + "orc-1.7.4-h07ed6aa_0.conda": { + "build": "h07ed6aa_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "snappy >=1.1.9,<2.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "78b7ab0e0376e1b136fb1dea60082a43", + "name": "orc", + "sha256": "77c242f414f3bb5bf81bc5c713abd1020229ee78572bc1f0847c85011d96088c", + "size": 930458, + "subdir": "linux-64", + "timestamp": 1652942927748, + "version": "1.7.4" + }, + "orc-1.7.4-hb3bc3d3_1.conda": { + "build": "hb3bc3d3_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "lz4-c >=1.9.4,<1.10.0a0", + "snappy >=1.1.9,<2.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f22a2b60db7a8b2079c91f3978eb4a98", + "name": "orc", + "sha256": "45fbe57065a6ee88c6d96133a16c447dba9ba5da137bc6758e6626d803a37453", + "size": 995194, + "subdir": "linux-64", + "timestamp": 1676482768554, + "version": "1.7.4" + }, + "orderedmultidict-0.7.11-py27hb58a934_0.conda": { + "build": "py27hb58a934_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "64d844baf042a0c9beffc9f8ffe43ac2", + "name": "orderedmultidict", + "sha256": "f74ad2eb3e85fb70d2d11595d7c1a94f6f01f876e418de02bda40a4df5bb38a5", + "size": 19153, + "subdir": "linux-64", + "timestamp": 1505743234283, + "version": "0.7.11" + }, + "orderedmultidict-0.7.11-py35hc76afa9_0.conda": { + "build": "py35hc76afa9_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "75221926be199fb28e6c007c05157ada", + "name": "orderedmultidict", + "sha256": "2cc235e1ce0706f717c24aea6706a7d5d45163fe4b0f1361b825433f74d59322", + "size": 19738, + "subdir": "linux-64", + "timestamp": 1505743246068, + "version": "0.7.11" + }, + "orderedmultidict-0.7.11-py36h9635bf0_0.conda": { + "build": "py36h9635bf0_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "856fa63fce427e9dcad931a5e1763896", + "name": "orderedmultidict", + "sha256": "15023d9b8699f10115d4c49ec2d555e6e1ed5d243f9a4a3ced6f46375383dca9", + "size": 19379, + "subdir": "linux-64", + "timestamp": 1505743257914, + "version": "0.7.11" + }, + "orderedmultidict-1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "f7c4ff82f1e2575950a7871cd77d52b5", + "name": "orderedmultidict", + "sha256": "0476d4d1ec05e487dd9e95908a2599873313a8747e43e13927c5937091bfd4e1", + "size": 19397, + "subdir": "linux-64", + "timestamp": 1529446165134, + "version": "1.0" + }, + "orderedmultidict-1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "84a9ac829e07b1d6cfa84390e0dedbca", + "name": "orderedmultidict", + "sha256": "2e2cd317155fb1b5265fdbe4000e225b185c44fb0b7e35d18f93c3d477da9dbd", + "size": 19857, + "subdir": "linux-64", + "timestamp": 1529446193582, + "version": "1.0" + }, + "orderedmultidict-1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "0b808c5edfbd439e60d2f741c6326940", + "name": "orderedmultidict", + "sha256": "49e0dcf0573f6fe7680c493489dc5b4c5e14232b59d0e7f6b5f076cf5b4f80fc", + "size": 19825, + "subdir": "linux-64", + "timestamp": 1529446156871, + "version": "1.0" + }, + "orderedmultidict-1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "73158dfead7ef43fa8109a87618468d3", + "name": "orderedmultidict", + "sha256": "e1433f9068b39e0ce2d0daf14f043e94b7fa2df7dda78ada8c424828b25de363", + "size": 19813, + "subdir": "linux-64", + "timestamp": 1530879350823, + "version": "1.0" + }, + "orderedmultidict-1.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "8bdd1ef9a53c1b48478d0b57281c9828", + "name": "orderedmultidict", + "sha256": "7cac725821973e8f3954032babbab082eac77a8b2c72133e59f223590fc0bebd", + "size": 21237, + "subdir": "linux-64", + "timestamp": 1564686106187, + "version": "1.0.1" + }, + "orderedmultidict-1.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "e640497773fd56ebce8ed9f27dcdae8e", + "name": "orderedmultidict", + "sha256": "0bc247b0e0e33ebbb24435c26160044f76546bc9eb78c8ce9592fd36615cc674", + "size": 21091, + "subdir": "linux-64", + "timestamp": 1640792094543, + "version": "1.0.1" + }, + "orderedmultidict-1.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "e45e0dbac7ece614635d70619b40f7b3", + "name": "orderedmultidict", + "sha256": "2f68557ec14641d54d73c821fd1a5c0cd1bb9266916a61d3012316dd928be486", + "size": 26039, + "subdir": "linux-64", + "timestamp": 1676825389920, + "version": "1.0.1" + }, + "orderedmultidict-1.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "198b6c7c3a36a6b5b32fc9d4e6521449", + "name": "orderedmultidict", + "sha256": "b71c2621c7b3a7e473851e7ed6ed0745ac45b3ab4af1ed6f474f3f9b31727ecc", + "size": 21492, + "subdir": "linux-64", + "timestamp": 1564686351726, + "version": "1.0.1" + }, + "orderedmultidict-1.0.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "c79068785428a72087eafd0062407d48", + "name": "orderedmultidict", + "sha256": "4417b15372daa7587e23b29fdea83a2a92a0b088a1c5c6f3184a33b06d23f922", + "size": 21552, + "subdir": "linux-64", + "timestamp": 1632894679908, + "version": "1.0.1" + }, + "orderedmultidict-1.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "9ce7f83486d9f75466ac2eb5bd437a2a", + "name": "orderedmultidict", + "sha256": "b7edaee394dbc90055b9b87d591de031c4cdbc21a8920f61479d03390661c5b7", + "size": 21520, + "subdir": "linux-64", + "timestamp": 1564686304048, + "version": "1.0.1" + }, + "orderedmultidict-1.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "50c8d81cb94464274cc87756b74612f5", + "name": "orderedmultidict", + "sha256": "0925bdd9a2558bee83a484c06ebd9b0976120169cd07b074d021daf42f9e0216", + "size": 21400, + "subdir": "linux-64", + "timestamp": 1632884238634, + "version": "1.0.1" + }, + "orderedmultidict-1.0.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "594ce3b05a09db5a8a6db0eee32a142f", + "name": "orderedmultidict", + "sha256": "5f73222d6e0e3ddee5f1dfc534b0e1e3c795b2c5161305035f32a36e3bd79e43", + "size": 21309, + "subdir": "linux-64", + "timestamp": 1573738386222, + "version": "1.0.1" + }, + "orderedmultidict-1.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "6855599a5adcc7208c1ef98c7d709fda", + "name": "orderedmultidict", + "sha256": "057510662ff49f7c50772d57027b66c37935e94606dfda2df6ce847f9b58b74f", + "size": 21484, + "subdir": "linux-64", + "timestamp": 1632884224511, + "version": "1.0.1" + }, + "orderedmultidict-1.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six >=1.8.0" + ], + "license": "PUBLIC-DOMAIN", + "md5": "b37c28c82bfe2477f6ba7d30d35b08fd", + "name": "orderedmultidict", + "sha256": "c9f4c1953ecb52f31b4ec70934a2b02d7235c87b65cb5d10d0dc63b02ec3b72b", + "size": 21452, + "subdir": "linux-64", + "timestamp": 1632894657844, + "version": "1.0.1" + }, + "orjson-3.7.8-py310h52d8a92_0.conda": { + "build": "py310h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0f3230995e81957cf14f59b3aa3a1b31", + "name": "orjson", + "sha256": "b59c4c6e2dabd1ab7de2c3a9813e7a51808a1413bb56b9dae6978c1c74e94937", + "size": 270267, + "subdir": "linux-64", + "timestamp": 1668613228119, + "version": "3.7.8" + }, + "orjson-3.7.8-py311h52d8a92_0.conda": { + "build": "py311h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b6893433f9e72dc8cc61eb801eefbc97", + "name": "orjson", + "sha256": "93f165c7b03a936627dbe19cfc42d0d87f83340a6c91985ac7b3f86d540a3c50", + "size": 246065, + "subdir": "linux-64", + "timestamp": 1676860255067, + "version": "3.7.8" + }, + "orjson-3.7.8-py37h52d8a92_0.conda": { + "build": "py37h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9cc6d343ae59747e5e47d46011862509", + "name": "orjson", + "sha256": "6380ffa42614b7cfca7cb1f1296118355e0ef4cda23ab23e1109637f10a7cbd4", + "size": 270103, + "subdir": "linux-64", + "timestamp": 1668613358075, + "version": "3.7.8" + }, + "orjson-3.7.8-py38h52d8a92_0.conda": { + "build": "py38h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "97fb44a113c26119e5cbce953b19eed8", + "name": "orjson", + "sha256": "a91fcde8e4d3b85d8da4d0870726fdf1b3a5e7fe73072ee3b98aecdff4459f33", + "size": 270091, + "subdir": "linux-64", + "timestamp": 1668612968449, + "version": "3.7.8" + }, + "orjson-3.7.8-py39h52d8a92_0.conda": { + "build": "py39h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "73738d8c338a985ad604fd7fb5980fa5", + "name": "orjson", + "sha256": "e6582a93a35edca70e8dedad13323509354d929ba692d6ee844cd5c1f17b128c", + "size": 270433, + "subdir": "linux-64", + "timestamp": 1668613098313, + "version": "3.7.8" + }, + "owslib-0.15.0-py27hebf82df_0.conda": { + "build": "py27hebf82df_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz", + "requests" + ], + "license": "BSD 3-Clause", + "md5": "e88292f9cd1e1a21c8084ac2243da413", + "name": "owslib", + "sha256": "0e0dc4e40ab66c4cd3aa478c71c25e975f489dc107cf5dc62c466520fe3ac720", + "size": 224716, + "subdir": "linux-64", + "timestamp": 1511989948398, + "version": "0.15.0" + }, + "owslib-0.15.0-py35h75c690b_0.conda": { + "build": "py35h75c690b_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz", + "requests" + ], + "license": "BSD 3-Clause", + "md5": "27f4a13a286ee7bf4ddf971e9f7c7d9d", + "name": "owslib", + "sha256": "ed101d19f5c57363d3192c85630fbaeb3a586bc41e53cfc731fea7d842d22cd3", + "size": 228068, + "subdir": "linux-64", + "timestamp": 1511990092008, + "version": "0.15.0" + }, + "owslib-0.15.0-py36h143ed5c_0.conda": { + "build": "py36h143ed5c_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz", + "requests" + ], + "license": "BSD 3-Clause", + "md5": "d308189f3a81d0b3f4878559fdba3cb8", + "name": "owslib", + "sha256": "7a406d79679df42954fbada1a4683b329dbba240643f66f15c77ebea5a90d7d5", + "size": 224901, + "subdir": "linux-64", + "timestamp": 1511990190686, + "version": "0.15.0" + }, + "owslib-0.16.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=2.7,<2.8.0a0", + "python-dateutil >=1.5", + "pytz", + "requests >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "70453307010705035689ad532e5a9b7f", + "name": "owslib", + "sha256": "1bde728147251c962ccbf50818911746d17b1538026f5dc7a93e31f05a0e10ec", + "size": 223752, + "subdir": "linux-64", + "timestamp": 1519484579159, + "version": "0.16.0" + }, + "owslib-0.16.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=3.5,<3.6.0a0", + "python-dateutil >=1.5", + "pytz", + "requests >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "7343653f775c70b174bbf75b4d096389", + "name": "owslib", + "sha256": "24d36edae705bbd1f93d29d1fb89b76cb6aabda51ce3594b3173a1c25cfc4ec6", + "size": 230915, + "subdir": "linux-64", + "timestamp": 1519484606194, + "version": "0.16.0" + }, + "owslib-0.16.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=3.6,<3.7.0a0", + "python-dateutil >=1.5", + "pytz", + "requests >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "8f03ba0cc23eebb97d72ca9ff309cdc7", + "name": "owslib", + "sha256": "180abec5fba85f92aa16a6fccdd9669e77f007c82ad8cd020a831cb47fde072d", + "size": 223897, + "subdir": "linux-64", + "timestamp": 1519484540543, + "version": "0.16.0" + }, + "owslib-0.16.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=3.7,<3.8.0a0", + "python-dateutil >=1.5", + "pytz", + "requests >=1.0" + ], + "license": "BSD 3-Clause", + "md5": "e636d72cce91cfa80b4a68c4e821eed7", + "name": "owslib", + "sha256": "716e1215eba8d2e8749f392a3af05a8a83ef56c58f682a117cb6110ac400281d", + "size": 229173, + "subdir": "linux-64", + "timestamp": 1530811367806, + "version": "0.16.0" + }, + "owslib-0.17.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=2.7,<2.8.0a0", + "python-dateutil >=1.5", + "pytz", + "requests >=1.0" + ], + "license": "BSD-3-Clause", + "md5": "2ec366fb26b406f05b252860981b4a2a", + "name": "owslib", + "sha256": "022d412ecac9517de55bbeaa1525e848880588381f4f435a536ea8270ef8d825", + "size": 259031, + "subdir": "linux-64", + "timestamp": 1539655659457, + "version": "0.17.0" + }, + "owslib-0.17.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=3.6,<3.7.0a0", + "python-dateutil >=1.5", + "pytz", + "requests >=1.0" + ], + "license": "BSD-3-Clause", + "md5": "4e7f630e1459a41e9606eb91db18dd66", + "name": "owslib", + "sha256": "138fe79b7d72259e2f76d884d272d8a51f8958fe7785f8d53db7bf51226c7236", + "size": 256611, + "subdir": "linux-64", + "timestamp": 1539655681616, + "version": "0.17.0" + }, + "owslib-0.17.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lxml", + "pyproj", + "python >=3.7,<3.8.0a0", + "python-dateutil >=1.5", + "pytz", + "requests >=1.0" + ], + "license": "BSD-3-Clause", + "md5": "16598b1a8f25d41081908105d5645b99", + "name": "owslib", + "sha256": "cb8f01e8d3c9256a90293e00eb6b68817e45333a201f3195d4d753e1f2dc53aa", + "size": 260133, + "subdir": "linux-64", + "timestamp": 1539655695903, + "version": "0.17.0" + }, + "p7zip-16.02-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "LGPL-2.0-or-later AND LicenseRef-scancode-rar-winrar-eula", + "license_family": "Other", + "md5": "96459b30ee733127ac21d0c47625a81a", + "name": "p7zip", + "sha256": "cc1548956e2dd9bd08a5e184ab36809b62ca6c2fa742600b998b75bcfb740f2c", + "size": 1562431, + "subdir": "linux-64", + "timestamp": 1668093866783, + "version": "16.02" + }, + "packaging-16.8-py27h5e07c7c_1.conda": { + "build": "py27h5e07c7c_1", + "build_number": 1, + "depends": [ + "pyparsing", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "e689749766fba6fc536c4b1e2c06277b", + "name": "packaging", + "sha256": "4b1f407ebc7ecc7d6dcf74951dabe58e3f2b9fdbee50ab968c59e306772e496b", + "size": 32774, + "subdir": "linux-64", + "timestamp": 1505747167646, + "version": "16.8" + }, + "packaging-16.8-py35h2260b46_1.conda": { + "build": "py35h2260b46_1", + "build_number": 1, + "depends": [ + "pyparsing", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "bf3e95327e3d41aea29a71d42b7c45c9", + "name": "packaging", + "sha256": "e9382c1efc1f878182fd7ba260373e5be1419dec372b810260990e3bb3563d3a", + "size": 33659, + "subdir": "linux-64", + "timestamp": 1505747180870, + "version": "16.8" + }, + "packaging-16.8-py36ha668100_1.conda": { + "build": "py36ha668100_1", + "build_number": 1, + "depends": [ + "pyparsing", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "0c7eaa42b32531846e44614178318518", + "name": "packaging", + "sha256": "8165f2724f0cde3813aff97ddc668a87f58d64b9eb724a5f358792a52ab7034b", + "size": 33165, + "subdir": "linux-64", + "timestamp": 1505747194122, + "version": "16.8" + }, + "packaging-17.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "272ccd9fe3695a4e71bc3e378e1e5242", + "name": "packaging", + "sha256": "01998ef3a8e87ab924bda12fb5f2749e45a51bda532c87bbb08096ff82ee4c7c", + "size": 34445, + "subdir": "linux-64", + "timestamp": 1520366655881, + "version": "17.1" + }, + "packaging-17.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "da307a2c3f9ce98a921995d9a6e7e60b", + "name": "packaging", + "sha256": "db01342486c5621b5583a667a6a8de19b33bed36cddeb5de6540f9d646996cfb", + "size": 35083, + "subdir": "linux-64", + "timestamp": 1520366661130, + "version": "17.1" + }, + "packaging-17.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "e81a8a2421354eb390542c4ca120c4a8", + "name": "packaging", + "sha256": "236702625a19ead9252ef5d8ccc0b2073d83f1ba77bfb67b6e0bef29ed106e4b", + "size": 34915, + "subdir": "linux-64", + "timestamp": 1520366670313, + "version": "17.1" + }, + "packaging-17.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "c5036527f68e9b86ee668096170bcf16", + "name": "packaging", + "sha256": "ea3a400825eaf6f8c2539b7ec0b8e3e99e72932fa422354d5b724a543b2a85e5", + "size": 34933, + "subdir": "linux-64", + "timestamp": 1530694961123, + "version": "17.1" + }, + "packaging-18.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "266f3451dc5db45a2e150eb2f9bb6e54", + "name": "packaging", + "sha256": "d3a67012aa1918d8eecc94cfb31675e59df72dc66b57495fcaeeaf8ebbac8165", + "size": 34635, + "subdir": "linux-64", + "timestamp": 1538580176942, + "version": "18.0" + }, + "packaging-18.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "ece542be34e4923d66abfcdb42edc628", + "name": "packaging", + "sha256": "ff655c0f0e2c0e294b4220e38fafaa2f04aa869264cdd7979e05da1e72d2d990", + "size": 35041, + "subdir": "linux-64", + "timestamp": 1538580176512, + "version": "18.0" + }, + "packaging-18.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "18fbeaf3d4e0f174f6bd754b78147249", + "name": "packaging", + "sha256": "ddfc8132f3bdc217223197d31ab451a7626c537763b5b90fe8433bff1b66d40f", + "size": 34977, + "subdir": "linux-64", + "timestamp": 1538580155562, + "version": "18.0" + }, + "packaging-19.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "e6e7ccff6f17a05ae3af48e4c14fdc98", + "name": "packaging", + "sha256": "5af7f0312f4c32e058683f936f3e62faf70385df49c894ce279786f990b96d56", + "size": 39422, + "subdir": "linux-64", + "timestamp": 1549321738149, + "version": "19.0" + }, + "packaging-19.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "4dbf89e51cfce80481453413fca0e24b", + "name": "packaging", + "sha256": "73b8b1ec967efbbe0fb4fb89eaa1a8ed032e8538c752abb518d1f98d4658a988", + "size": 39723, + "subdir": "linux-64", + "timestamp": 1549321777314, + "version": "19.0" + }, + "packaging-19.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "5728d99f6889a5079e8e74809f47c478", + "name": "packaging", + "sha256": "72bc74fc513d69290e8c3d7b5fd70185eca6a282d291ec031eaa87fd1ee00723", + "size": 39732, + "subdir": "linux-64", + "timestamp": 1549321715241, + "version": "19.0" + }, + "packaging-19.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "635ee5b72437ef79629ae59cb6b1f3ef", + "name": "packaging", + "sha256": "109b20d0ac548efe4ea4aaa83c4b53cde31edd7c40aa8d322fef8cbe5bf2587f", + "size": 47452, + "subdir": "linux-64", + "timestamp": 1565898857152, + "version": "19.1" + }, + "packaging-19.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "baffd2856ae0aab95c67b2b18494c8fb", + "name": "packaging", + "sha256": "c88dc9a4400a0240ef872a4713a71e7a89d277b3b7a342bbafcad357f19d340f", + "size": 48062, + "subdir": "linux-64", + "timestamp": 1565898810376, + "version": "19.1" + }, + "packaging-19.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyparsing", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0 or BSD 2-Clause", + "md5": "3915d2ec9779a576239759a0e6875fea", + "name": "packaging", + "sha256": "141d7b6b8d4aee38dd1ce6672d1a82ecd51ce1b14b21b26b15c49b3319beea15", + "size": 48184, + "subdir": "linux-64", + "timestamp": 1565898790660, + "version": "19.1" + }, + "packaging-22.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 or BSD-2-Clause", + "license_family": "Apache", + "md5": "def74f82ff8818339ec8d80cdc836374", + "name": "packaging", + "sha256": "d27a960a18db803174bfb3f3d024893610b282eb129d5a8b4ab7e5e0225ddcb8", + "size": 70410, + "subdir": "linux-64", + "timestamp": 1671697443717, + "version": "22.0" + }, + "packaging-22.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0 or BSD-2-Clause", + "license_family": "Apache", + "md5": "b86fd7c9cbbee0684a0495b3a273f6bf", + "name": "packaging", + "sha256": "9b510661c2d490fc3d718c082b954e008e934fa214cf9e9332a8bf712d2b785e", + "size": 84671, + "subdir": "linux-64", + "timestamp": 1676822659145, + "version": "22.0" + }, + "packaging-22.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 or BSD-2-Clause", + "license_family": "Apache", + "md5": "74d6ef6fbc69680d883cce4b3288d9f6", + "name": "packaging", + "sha256": "a0548e1c2965ae7de6bf4e06701b0b6d79754596f70b82fdc6a228ee91ea342d", + "size": 69319, + "subdir": "linux-64", + "timestamp": 1671697469527, + "version": "22.0" + }, + "packaging-22.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 or BSD-2-Clause", + "license_family": "Apache", + "md5": "f09d8a44adf4dae78562c6f9af3603d6", + "name": "packaging", + "sha256": "6e6d2d74c93de77eca01f9eab6064651b2e95bb8816dfa1bbceb5aefb01bdeb8", + "size": 69688, + "subdir": "linux-64", + "timestamp": 1671697494995, + "version": "22.0" + }, + "packaging-22.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 or BSD-2-Clause", + "license_family": "Apache", + "md5": "f0d5483df1e0c0221c519d557da09dec", + "name": "packaging", + "sha256": "ebe041f67bc63c737595576c0bd701d6c0973fa878b7ad8c7022740a9f7ef682", + "size": 69758, + "subdir": "linux-64", + "timestamp": 1671697520700, + "version": "22.0" + }, + "packaging-23.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 or BSD-2-Clause", + "license_family": "Apache", + "md5": "adcfc4deb28a6dc4e467d86f8d80f68f", + "name": "packaging", + "sha256": "63c368d865f8b211c406f6682b8777b1de4ffea05c88c4b3c95ebc718a61f6f2", + "size": 69951, + "subdir": "linux-64", + "timestamp": 1678965365352, + "version": "23.0" + }, + "packaging-23.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0 or BSD-2-Clause", + "license_family": "Apache", + "md5": "00e34d9a35fc77d5f6d4a475c947a93e", + "name": "packaging", + "sha256": "1d223a57d85524697f6ec979f05265d6e7e67ee0946b0a546354b9584601feee", + "size": 89679, + "subdir": "linux-64", + "timestamp": 1678965391422, + "version": "23.0" + }, + "packaging-23.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 or BSD-2-Clause", + "license_family": "Apache", + "md5": "87dd3a3af0b6c6f5bbb99b7f205c2612", + "name": "packaging", + "sha256": "da4323aa671d8f6c03d462309306321bdbec668d39235dbf8f6ed44e5db6af80", + "size": 69208, + "subdir": "linux-64", + "timestamp": 1678965417418, + "version": "23.0" + }, + "packaging-23.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 or BSD-2-Clause", + "license_family": "Apache", + "md5": "a3da65d1bfc6e59f5411c11c0fd1315f", + "name": "packaging", + "sha256": "b9a6215fb8888320729c1599f4ffde209910a348303c3a9cc7177c271f4a20a5", + "size": 69265, + "subdir": "linux-64", + "timestamp": 1678965339154, + "version": "23.0" + }, + "pamela-0.3.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e4c9b0ea2360a288544fe9385ef4336d", + "name": "pamela", + "sha256": "766b551dafd0d0086024d4702cd9603611bfe40032f1d24797f11adfbb7620c1", + "size": 14576, + "subdir": "linux-64", + "timestamp": 1540558189653, + "version": "0.3.0" + }, + "pamela-0.3.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a745b5de977acb0299c8d932c781a65a", + "name": "pamela", + "sha256": "0d5aff328fa2a5aa0423de1490772b1df9f18b3d9ed7aa1a02a81e1fa14494e2", + "size": 14600, + "subdir": "linux-64", + "timestamp": 1540558210176, + "version": "0.3.0" + }, + "pamela-0.3.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8b3e50e065aa21fef5399e82d3a9a8a0", + "name": "pamela", + "sha256": "6f2835e6b5e5d52b3cca1840591ab107465cbca40f9f17a181833c9494c4d2c8", + "size": 14629, + "subdir": "linux-64", + "timestamp": 1540558191399, + "version": "0.3.0" + }, + "pandarallel-1.6.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.1", + "pandas >=1", + "psutil", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ae31744407e854dee0cebe340b25be9", + "name": "pandarallel", + "sha256": "26ee0ab094cd5c662c622e1179da25f5a0e9d2185dea2895f6b13629e09ee0d5", + "size": 33863, + "subdir": "linux-64", + "timestamp": 1674548655076, + "version": "1.6.4" + }, + "pandarallel-1.6.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.1", + "pandas >=1", + "psutil", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07d2d52ec134f81a5e08af2df108c5de", + "name": "pandarallel", + "sha256": "5c96174bbc7d44f9ca7331c8dade73e39ecfc00d813671a2644522afecff6cd7", + "size": 41562, + "subdir": "linux-64", + "timestamp": 1676860272705, + "version": "1.6.4" + }, + "pandarallel-1.6.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.1", + "pandas >=1", + "psutil", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5c1fd6799cf3f9799852130507faf335", + "name": "pandarallel", + "sha256": "ae051c4bbb228307394720ff9ec375dc1913f600644e52941f10cf89b1c2dad5", + "size": 33036, + "subdir": "linux-64", + "timestamp": 1674548607203, + "version": "1.6.4" + }, + "pandarallel-1.6.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.1", + "pandas >=1", + "psutil", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1fabdf8e9fe1570fce66997e44976b0a", + "name": "pandarallel", + "sha256": "6e3aee87f8e55a3597a91841c4f1131b2b35456eed86d777d312768fac0c50ec", + "size": 33390, + "subdir": "linux-64", + "timestamp": 1674548505846, + "version": "1.6.4" + }, + "pandarallel-1.6.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dill >=0.3.1", + "pandas >=1", + "psutil", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "98e787428263b839a7f11e2ea5bf6ea9", + "name": "pandarallel", + "sha256": "8dfabfd5c7502f9a46675cf192f98e69b64338ab5e223821c6cf6e7715ca3636", + "size": 33443, + "subdir": "linux-64", + "timestamp": 1674548558152, + "version": "1.6.4" + }, + "pandas-0.20.3-py27h820b67f_2.conda": { + "build": "py27h820b67f_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "636a54a52a15490bc602661e590191b7", + "name": "pandas", + "sha256": "cbaea667f8169934a7cdc375d12df03bc48d927db2acd8e1650bcc718d84e3c8", + "size": 8025278, + "subdir": "linux-64", + "timestamp": 1505726159262, + "version": "0.20.3" + }, + "pandas-0.20.3-py27hfd1eabf_2.conda": { + "build": "py27hfd1eabf_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "bfac67a2625385e9508c6d4bd39ab7bc", + "name": "pandas", + "sha256": "5dc012eead10043261ab0cdd83ce3e50ffcd2b0bbccd22648e52f7b9f60b0f54", + "size": 8017573, + "subdir": "linux-64", + "timestamp": 1509790431578, + "version": "0.20.3" + }, + "pandas-0.20.3-py35h85c2c75_2.conda": { + "build": "py35h85c2c75_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "c1e3a8eebb765e57ac370bc1e20bde4f", + "name": "pandas", + "sha256": "4f6b01fd6fcf97b88ded4bb3c694d0d5b25e1dadd875e568abfd0bf6a4594241", + "size": 8009344, + "subdir": "linux-64", + "timestamp": 1505726630344, + "version": "0.20.3" + }, + "pandas-0.20.3-py35hd2a53da_2.conda": { + "build": "py35hd2a53da_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "07381707fe72a70ab94146f15f14e150", + "name": "pandas", + "sha256": "4735a044c21182cf4827dbb85376bbcb90f5e1edc760706fdf16520ce539afc0", + "size": 8024158, + "subdir": "linux-64", + "timestamp": 1509790912478, + "version": "0.20.3" + }, + "pandas-0.20.3-py36h6022372_2.conda": { + "build": "py36h6022372_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "0130a932ca2706efb1451f88da39f296", + "name": "pandas", + "sha256": "7661d2582bd09200caedc7a644eafb0dd93b9166663b74829acd3734a0496875", + "size": 8040424, + "subdir": "linux-64", + "timestamp": 1509791421335, + "version": "0.20.3" + }, + "pandas-0.20.3-py36h842e28d_2.conda": { + "build": "py36h842e28d_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "b0c50c8ab986d8b7c1698e748e694722", + "name": "pandas", + "sha256": "b3e34d55ccfa72dd9639a089f5eedac4c30b55c898e91cf4ededb908760c0b11", + "size": 8057158, + "subdir": "linux-64", + "timestamp": 1505727113870, + "version": "0.20.3" + }, + "pandas-0.21.0-py27he307072_1.conda": { + "build": "py27he307072_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "c3c949debcc837797a75de111c9458b1", + "name": "pandas", + "sha256": "4e5c688158a07d2e56951503ab6acaa21074daaa53d2c29f5129cfcc60b7c4eb", + "size": 8524897, + "subdir": "linux-64", + "timestamp": 1509936158807, + "version": "0.21.0" + }, + "pandas-0.21.0-py35hee8c687_1.conda": { + "build": "py35hee8c687_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "27df34b223b5bde7593f970d6fa81f98", + "name": "pandas", + "sha256": "2fe36ab18948bcd0a9a7345cb495bb5d14f507f0f65430325a34b2189e905d34", + "size": 8498104, + "subdir": "linux-64", + "timestamp": 1509936147894, + "version": "0.21.0" + }, + "pandas-0.21.0-py36h78bd809_1.conda": { + "build": "py36h78bd809_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "b8f0327bfdf966bd74ac837c25c5ab1b", + "name": "pandas", + "sha256": "8a19bedf8091bcb38d9646901e6cbeaf4200f6fc77444b3b219039291080641d", + "size": 8536893, + "subdir": "linux-64", + "timestamp": 1509936175170, + "version": "0.21.0" + }, + "pandas-0.21.1-py27h38cdd7d_0.conda": { + "build": "py27h38cdd7d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "a1b1fb21f58bb20563a0b2e37953319f", + "name": "pandas", + "sha256": "d27234f97995ea0086a7ac5f7d9d44499585ea8e905ecf97f512af81ced3624f", + "size": 8526134, + "subdir": "linux-64", + "timestamp": 1513100665293, + "version": "0.21.1" + }, + "pandas-0.21.1-py35h20b78c2_0.conda": { + "build": "py35h20b78c2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "7acb47b4a4107ebe74b8a302e575f521", + "name": "pandas", + "sha256": "20b6244b3780757a5ba59683bfeddf68184c3d705e2a402386e08888c44c3451", + "size": 8519240, + "subdir": "linux-64", + "timestamp": 1513100676956, + "version": "0.21.1" + }, + "pandas-0.21.1-py36h20b78c2_0.conda": { + "build": "py36h20b78c2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "7ee8cfdb9c95a19d7e9af33dfb7e2c64", + "name": "pandas", + "sha256": "012e046071d040ea7f7df5a78405138031c831f7419e9ae0aed1f7cc62506f82", + "size": 8556582, + "subdir": "linux-64", + "timestamp": 1513100703036, + "version": "0.21.1" + }, + "pandas-0.22.0-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "31d63b146487f30a0c629ef5b1c44e91", + "name": "pandas", + "sha256": "72cad223cfa7eae34966c556bf554a89bcd8c7d17c681d3abb513876276109d2", + "size": 8538837, + "subdir": "linux-64", + "timestamp": 1514667573488, + "version": "0.22.0" + }, + "pandas-0.22.0-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "cb24c3299a1b04de5a6e8d517e3956cf", + "name": "pandas", + "sha256": "d5cdb710f9b1ee8f49cecf62c395ce9be48d9ea33a77c0d1842bbac7360a5f39", + "size": 8528996, + "subdir": "linux-64", + "timestamp": 1514667587794, + "version": "0.22.0" + }, + "pandas-0.22.0-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "87dfb2467a9f44419d137fd3b587a4e4", + "name": "pandas", + "sha256": "ee60a30ae7f3176dfcf05ff6d41e7218b55215ed31ae6587f41bdc4ed645c57a", + "size": 8551501, + "subdir": "linux-64", + "timestamp": 1514667404610, + "version": "0.22.0" + }, + "pandas-0.23.0-py27h637b7d7_0.conda": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "00e42781c9b2bcf7611e4f2407fab604", + "name": "pandas", + "sha256": "2191ed570e2f20a928b7eed6cd7785ed8476050d193f3b8379c3e006507143a1", + "size": 9288992, + "subdir": "linux-64", + "timestamp": 1526491814198, + "version": "0.23.0" + }, + "pandas-0.23.0-py35h637b7d7_0.conda": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "02cc18e9209ef65de2ae9568174e23c0", + "name": "pandas", + "sha256": "bcf77b0811ec51a1e08d5c10a64b1c2f1cdd701b80accbdf122df227c56e5da7", + "size": 9284822, + "subdir": "linux-64", + "timestamp": 1526491815687, + "version": "0.23.0" + }, + "pandas-0.23.0-py36h637b7d7_0.conda": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "27444106ef118b362206bab8c57d6c34", + "name": "pandas", + "sha256": "d5f1d5bad5262024fb0f0772e35f2a6e62ca5cd61772db23f21ca72fae8c5204", + "size": 9288239, + "subdir": "linux-64", + "timestamp": 1526491828878, + "version": "0.23.0" + }, + "pandas-0.23.1-py27h637b7d7_0.conda": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "570b38d2c1b4c6ae6853c78a07e5affa", + "name": "pandas", + "sha256": "bdbbca6ce3421c2d289a46c9bf219e947bec8fc3d2342274cb6af73c2347d89b", + "size": 9295690, + "subdir": "linux-64", + "timestamp": 1528897380256, + "version": "0.23.1" + }, + "pandas-0.23.1-py35h637b7d7_0.conda": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "1ab5354b24ca458ce550f75a8e4f432f", + "name": "pandas", + "sha256": "661e6153d57f8bf89aedc3af0bb3ec0d8fc997c5d453b6c9d4d9ea306638a5c4", + "size": 9272740, + "subdir": "linux-64", + "timestamp": 1528897408045, + "version": "0.23.1" + }, + "pandas-0.23.1-py36h637b7d7_0.conda": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "77d0cf3b8d888217f5eb6cfbadba40a6", + "name": "pandas", + "sha256": "495887fd04fc4d29016ed8755f14143880c1b76a6f27ac047e2fdb3f9c1089e1", + "size": 9319465, + "subdir": "linux-64", + "timestamp": 1528897417163, + "version": "0.23.1" + }, + "pandas-0.23.2-py27h04863e7_0.conda": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "eb265e9e5fe878741bda7fe4d07818b7", + "name": "pandas", + "sha256": "21fd581897716d9b91f050d02dda08748fa8c62dd610e584a721dca16cea5187", + "size": 8019157, + "subdir": "linux-64", + "timestamp": 1531087183978, + "version": "0.23.2" + }, + "pandas-0.23.2-py36h04863e7_0.conda": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "0853f60aff0b39e70b78e3423394a8b5", + "name": "pandas", + "sha256": "c8422d2af8b783bdb53e095444dcc05e7d9adf4d8c58c144e5fef65a6964bd49", + "size": 8075910, + "subdir": "linux-64", + "timestamp": 1531087844536, + "version": "0.23.2" + }, + "pandas-0.23.2-py37h04863e7_0.conda": { + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "eac9723d226411a7d79cb06c25096a50", + "name": "pandas", + "sha256": "4757dfb773b493bb434d604e6b8a6c88f5c5c2afab6d6537fcef940565d09319", + "size": 8030328, + "subdir": "linux-64", + "timestamp": 1531088501052, + "version": "0.23.2" + }, + "pandas-0.23.3-py27h04863e7_0.conda": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "d0d03c50ddc603309e88853a695c1ef9", + "name": "pandas", + "sha256": "5ddbbae4c9163f63b7715b5f808ad65627984a7bfbaa75479d1493ecd162f560", + "size": 8021259, + "subdir": "linux-64", + "timestamp": 1531786060347, + "version": "0.23.3" + }, + "pandas-0.23.3-py35h04863e7_0.conda": { + "build": "py35h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "3616458c5520870ded6ff5299c7a59bb", + "name": "pandas", + "sha256": "d524a0b0f147caeeb7adda1ba956705a3ee5d5d99416d52615df5fda74aa3f09", + "size": 8033109, + "subdir": "linux-64", + "timestamp": 1531785968368, + "version": "0.23.3" + }, + "pandas-0.23.3-py36h04863e7_0.conda": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "7ae09b45d4fada8f2d3124186fec6164", + "name": "pandas", + "sha256": "522b4ad72b7d2ab5a5522aa429e66fe0b89a411f8ca2c81023d335f703878032", + "size": 8076011, + "subdir": "linux-64", + "timestamp": 1531786113306, + "version": "0.23.3" + }, + "pandas-0.23.3-py37h04863e7_0.conda": { + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "d8d690ca81783717f1860efca8c94031", + "name": "pandas", + "sha256": "9009efcb2b13372d4e3a8d549c56c5db188388ad88e62a289baddfc19093df67", + "size": 8060697, + "subdir": "linux-64", + "timestamp": 1531786074078, + "version": "0.23.3" + }, + "pandas-0.23.4-py27h04863e7_0.conda": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "c216f93856d2a272c0367c48355992bd", + "name": "pandas", + "sha256": "5b805facbab02fc8cd370e2538203233c42a34d81419e5aea0b8a197ae95cd4a", + "size": 8024680, + "subdir": "linux-64", + "timestamp": 1533666814551, + "version": "0.23.4" + }, + "pandas-0.23.4-py35h04863e7_0.conda": { + "build": "py35h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "445bed45853f3ff82727320c7c1992a0", + "name": "pandas", + "sha256": "2807010fc740d912d640b351fb607096e4720575fd9787d9e4ee10a1243bcfab", + "size": 8057994, + "subdir": "linux-64", + "timestamp": 1533666819351, + "version": "0.23.4" + }, + "pandas-0.23.4-py36h04863e7_0.conda": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "192bb46ed6808298dc064f13ff653cd4", + "name": "pandas", + "sha256": "da988657342230b530baa661a775fdc3b7e1dfa0444179b5a00cc85450b4d9f8", + "size": 8052349, + "subdir": "linux-64", + "timestamp": 1533666327713, + "version": "0.23.4" + }, + "pandas-0.23.4-py37h04863e7_0.conda": { + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "b905f433c2f9f8dec1896bc390e170a8", + "name": "pandas", + "sha256": "f89bb0059ce01ebe40b12cad4752ffb6fa08cf3969d5741ff7c9631355178451", + "size": 8039491, + "subdir": "linux-64", + "timestamp": 1533666819586, + "version": "0.23.4" + }, + "pandas-0.24.0-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.12.1,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "e2587a4c037904e3e28b2752648837fd", + "name": "pandas", + "sha256": "009075f76f61ac08b4317fe47f53a90b818792eef05ade257285c0d2ac4618fd", + "size": 8783090, + "subdir": "linux-64", + "timestamp": 1548457280868, + "version": "0.24.0" + }, + "pandas-0.24.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.12.1,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "d9d9cee68b7a76e31eed87beba92ab5f", + "name": "pandas", + "sha256": "d1807180cc3d5896434e8c833a7584cf04ed1feb5a2764ec0c463a8e9ef831fc", + "size": 8965999, + "subdir": "linux-64", + "timestamp": 1548457329616, + "version": "0.24.0" + }, + "pandas-0.24.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "2bf939c65523accf4262ae73dc80ba86", + "name": "pandas", + "sha256": "677cb66a96b91117a8ae4ba51c8c684d5dc07e62497aa9a2549ec70fdea3a3f0", + "size": 8952162, + "subdir": "linux-64", + "timestamp": 1548457189389, + "version": "0.24.0" + }, + "pandas-0.24.1-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.12.1,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "5d6bb6869bd4df56d1baa2101cb671c2", + "name": "pandas", + "sha256": "4376726d24e8eb565d402edf691b8adfbbbfc27473067cc159526e8c5aef4b84", + "size": 8790197, + "subdir": "linux-64", + "timestamp": 1549300849344, + "version": "0.24.1" + }, + "pandas-0.24.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.12.1,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "ff1801f74978afd8638e482c38aabd0f", + "name": "pandas", + "sha256": "067f0b0efda35a8331cca72cd688000de4dcb3844b0fb62e640d206f78cf3b5b", + "size": 8975418, + "subdir": "linux-64", + "timestamp": 1549301027196, + "version": "0.24.1" + }, + "pandas-0.24.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "78b4e7606acbf7090413488c39f13141", + "name": "pandas", + "sha256": "77d48c057f2f4d044ecf56ca793296dff26efe50a832da889051271541a9535d", + "size": 8923314, + "subdir": "linux-64", + "timestamp": 1549315967046, + "version": "0.24.1" + }, + "pandas-0.24.2-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.12.1,<2.0a0", + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "2edfbae20468725bcb714391e5433298", + "name": "pandas", + "sha256": "f5ea790ffe196c4dd23b7a4d11011f6c63f511d9820a6cbf04a7262401c31774", + "size": 8798287, + "subdir": "linux-64", + "timestamp": 1552578744199, + "version": "0.24.2" + }, + "pandas-0.24.2-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.12.1,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "286a1edbed7873b64b3667d31b910d1d", + "name": "pandas", + "sha256": "3c480980aa3378c3624e9dedf64acbfe17894346032dd6035b39a617373c0ab2", + "size": 8956122, + "subdir": "linux-64", + "timestamp": 1552578747529, + "version": "0.24.2" + }, + "pandas-0.24.2-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.*", + "pytz" + ], + "license": "BSD 3-clause", + "md5": "062b86832d96262a40e94b7001d61a54", + "name": "pandas", + "sha256": "021822276fb35a94019c4e86c4d9497c7707126a4642a6a2672d936946e3da67", + "size": 8976253, + "subdir": "linux-64", + "timestamp": 1552578741555, + "version": "0.24.2" + }, + "pandas-0.25.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "85926f2e35598fdf6081feec5a20f848", + "name": "pandas", + "sha256": "0cf0e233635f7d4a5cbbcc3c97da04a206a95c386405f4cd229383aaff5c38e2", + "size": 9194017, + "subdir": "linux-64", + "timestamp": 1564515269660, + "version": "0.25.0" + }, + "pandas-0.25.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "89394984b0d957fcc1b2b17efc497798", + "name": "pandas", + "sha256": "e1e92463b7f60b9b25545065460d5d83b0b633dbefde9d532e7cca4fbac55260", + "size": 9148890, + "subdir": "linux-64", + "timestamp": 1564515534654, + "version": "0.25.0" + }, + "pandas-0.25.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "f72c127c1613c800825e67343585712d", + "name": "pandas", + "sha256": "bd75cd68c7861fb55c83b7f877f5ea18c959eaccdac179776537384c10a5de64", + "size": 9169391, + "subdir": "linux-64", + "timestamp": 1566830699639, + "version": "0.25.1" + }, + "pandas-0.25.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "adaeb2d48ebb9d821365656866c8d5f7", + "name": "pandas", + "sha256": "419a6368f4a27a90dc4073f65b747ab8ed23fadc58b6885c098b01898ca7d8ca", + "size": 9192277, + "subdir": "linux-64", + "timestamp": 1566830216094, + "version": "0.25.1" + }, + "pandas-0.25.2-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "d3d6a33460499c13af474efa34035024", + "name": "pandas", + "sha256": "1fb5dd7106d7a6a7103493298f8ac8f94311c2fca2d945982da71f02b2531b35", + "size": 9214544, + "subdir": "linux-64", + "timestamp": 1571668870283, + "version": "0.25.2" + }, + "pandas-0.25.2-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "4689bf0f53564f33e5f4fceb339815a1", + "name": "pandas", + "sha256": "23244f7596382227e30f66f136ac6c2f61a9ec9fa042ccc3700c12a58cd0afb4", + "size": 9201480, + "subdir": "linux-64", + "timestamp": 1571668951270, + "version": "0.25.2" + }, + "pandas-0.25.3-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "6ea8f7dbb44aec5f30f4b0a41dbb738e", + "name": "pandas", + "sha256": "55d3aacad9d9621753de791682c028fde81fc02df0b41cbe73ca344eee3abc99", + "size": 9205633, + "subdir": "linux-64", + "timestamp": 1573939970712, + "version": "0.25.3" + }, + "pandas-0.25.3-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "27c0abf57304ee25f75fa3820cb02a83", + "name": "pandas", + "sha256": "a513a19134c143f27521c6d4a15abedb7fda2ce3fc781a0765052c54422d6127", + "size": 9198337, + "subdir": "linux-64", + "timestamp": 1573939648528, + "version": "0.25.3" + }, + "pandas-0.25.3-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.13.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "97f6832a5bb41d275585e972bc8c7adf", + "name": "pandas", + "sha256": "b5ce0652284b8433d56751cfa4168ac0d4fb9af4fe57944fb6c01d9be41a25ba", + "size": 9543452, + "subdir": "linux-64", + "timestamp": 1574355206652, + "version": "0.25.3" + }, + "pandas-1.0.0-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "848f05d621ab046dc4fe105a148949c7", + "name": "pandas", + "sha256": "6f6c058130066cd8200dbfcc8b41483a77d5f375438c456651919a60d2c5bf80", + "size": 8975427, + "subdir": "linux-64", + "timestamp": 1580340113810, + "version": "1.0.0" + }, + "pandas-1.0.0-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "66eca3b24540b91670091ba1d6c93a60", + "name": "pandas", + "sha256": "6845a37f956644a3a2bf5b753d46266d583f8918874e18f6a5ccab1e035a0362", + "size": 8952431, + "subdir": "linux-64", + "timestamp": 1580340387906, + "version": "1.0.0" + }, + "pandas-1.0.0-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "8848febd7984b41565d63ab359ad1f85", + "name": "pandas", + "sha256": "35518c5347c431b11dcd22f53b647d5c5c731b95ae85a54afaf6a6adc2102152", + "size": 9267764, + "subdir": "linux-64", + "timestamp": 1580340413520, + "version": "1.0.0" + }, + "pandas-1.0.1-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "8377c2de568f6548b5649885f6abf38e", + "name": "pandas", + "sha256": "48f07b999bd72da1b253b68d69332254e61a96a997d13c97f44e0e4488403afe", + "size": 8986744, + "subdir": "linux-64", + "timestamp": 1581352600432, + "version": "1.0.1" + }, + "pandas-1.0.1-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "5aafa8abffa30c287dba9bc23decd3e2", + "name": "pandas", + "sha256": "58d241ce11e0ffd935ea3086feb4af3044c27ef450c1ec5a266a6582b9261b86", + "size": 8935217, + "subdir": "linux-64", + "timestamp": 1581355941398, + "version": "1.0.1" + }, + "pandas-1.0.1-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "1fa9f772671a7cbada36f502f07ea077", + "name": "pandas", + "sha256": "3d130f0c7f0453e68a05a706987b09b4206138e5b9e44754fbc74ede4e106746", + "size": 9239621, + "subdir": "linux-64", + "timestamp": 1581352573955, + "version": "1.0.1" + }, + "pandas-1.0.2-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "1a27e860cdba4f362778e07a1aeb0b9f", + "name": "pandas", + "sha256": "85604f24b98c8bddfa345d40962b275ee2048fdbf6c89359a71251199ca836e0", + "size": 8972457, + "subdir": "linux-64", + "timestamp": 1584457653469, + "version": "1.0.2" + }, + "pandas-1.0.2-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "db693b06a1e27312c5d97369b939708e", + "name": "pandas", + "sha256": "68caddc5b0f1a128d6f24034dd7ce444cab63d3385761223bdd14fc78714db93", + "size": 8946496, + "subdir": "linux-64", + "timestamp": 1584457796445, + "version": "1.0.2" + }, + "pandas-1.0.2-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "39e34fdcedd2095c72d8fa43ccea4a24", + "name": "pandas", + "sha256": "3a166df3034afa62089336c60892270d6f778efe70bb8483249caf9312fd1865", + "size": 9296002, + "subdir": "linux-64", + "timestamp": 1584457660255, + "version": "1.0.2" + }, + "pandas-1.0.3-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "54884363a008e3ad006bf343873e4325", + "name": "pandas", + "sha256": "096f2e5cb3487e4188952d0663ab6cda5897e87e39099c7f351185c6c0360cab", + "size": 8999126, + "subdir": "linux-64", + "timestamp": 1584976709198, + "version": "1.0.3" + }, + "pandas-1.0.3-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "36853f43b92715e8c1307959db317a6f", + "name": "pandas", + "sha256": "68856a1d0fdc5dedcf142ebd15305610049426f8a0794bd351cf6e595a08a9e5", + "size": 8977415, + "subdir": "linux-64", + "timestamp": 1584976707684, + "version": "1.0.3" + }, + "pandas-1.0.3-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD 3-clause", + "md5": "b74d121d22ffe692490245f223c1178e", + "name": "pandas", + "sha256": "5583bcefe4e3a23ab45d1f86e83a0e2bc8d004cd2b433fe54e45f4964d6ec3fe", + "size": 9264003, + "subdir": "linux-64", + "timestamp": 1584976788170, + "version": "1.0.3" + }, + "pandas-1.0.4-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "2af5fd655bdd92adba96fdc9070b4676", + "name": "pandas", + "sha256": "85b4c8e33e45475969512512eb33c2a1787a9f0cf1bd06df2148b01aa3cb0cff", + "size": 9097934, + "subdir": "linux-64", + "timestamp": 1592321713322, + "version": "1.0.4" + }, + "pandas-1.0.4-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "37eb0398180dd5b322392db27513ce02", + "name": "pandas", + "sha256": "535ad3eb654ec8a02654ccf6874a128d451e7dff11b8e44978a50a7b9c0e9aa1", + "size": 9138639, + "subdir": "linux-64", + "timestamp": 1592321705109, + "version": "1.0.4" + }, + "pandas-1.0.4-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "9328e6daa78479cab54de200a90694d3", + "name": "pandas", + "sha256": "fc663d05060f3b59cd520122a0e718ffdc8068e012bd8839049dda6d32480dff", + "size": 9460542, + "subdir": "linux-64", + "timestamp": 1592321709740, + "version": "1.0.4" + }, + "pandas-1.0.5-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "89381b3ea4d443a6507abd968ca3563b", + "name": "pandas", + "sha256": "cb725a452383d850f71f0b2028b1ca1ec5d3683e96d16181218cdeea85f4fccc", + "size": 8195235, + "subdir": "linux-64", + "timestamp": 1592842330819, + "version": "1.0.5" + }, + "pandas-1.0.5-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "9d2668148f2863cdda9ece108449ee44", + "name": "pandas", + "sha256": "40331b37fbeddc94dd2168cc1cfc973d3f247bdd08ac3216a31d6e24668a64d5", + "size": 8200168, + "subdir": "linux-64", + "timestamp": 1592842287392, + "version": "1.0.5" + }, + "pandas-1.0.5-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6.1", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "a7c72cea645aae78b22be8eeaa06d192", + "name": "pandas", + "sha256": "2c069659642505ccb89e0f36a97e72dafef0a702da0298b3e8774ec746edad83", + "size": 8496712, + "subdir": "linux-64", + "timestamp": 1592842302472, + "version": "1.0.5" + }, + "pandas-1.1.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "520a54f9aa05a7d91d081c69a629090d", + "name": "pandas", + "sha256": "3741b646b639e7a327416efcb41cc917dc5603a3ef5b801c5c6afe909060fe2c", + "size": 8534412, + "subdir": "linux-64", + "timestamp": 1596826510442, + "version": "1.1.0" + }, + "pandas-1.1.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "6e00fc751133a177c6a0c0e852c909df", + "name": "pandas", + "sha256": "a95da930f722d00c751a6db6a0346c06e9d305d8d6554d112c13c36bf02b9863", + "size": 8522523, + "subdir": "linux-64", + "timestamp": 1596826453837, + "version": "1.1.0" + }, + "pandas-1.1.0-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "f3cc23a9dae0b287fe87771126c4ee4d", + "name": "pandas", + "sha256": "19c000704d42d34f2ad5733710c1b185602d2c3e0db0c053d3da1f4953081920", + "size": 8833868, + "subdir": "linux-64", + "timestamp": 1596826504079, + "version": "1.1.0" + }, + "pandas-1.1.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "3dc5457628b33a391f6026c02c785774", + "name": "pandas", + "sha256": "b6b55514595d8e529978297eac55b11be9c760d112770b763111f4d1f0eddeb2", + "size": 8575656, + "subdir": "linux-64", + "timestamp": 1598372172205, + "version": "1.1.1" + }, + "pandas-1.1.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "ea7f33f5969f69e8931b1d417e6ef4d3", + "name": "pandas", + "sha256": "a588adc2f315b86b37f7df42265624e10ba1cb4ac78f1fdded60609c84185847", + "size": 8564456, + "subdir": "linux-64", + "timestamp": 1598372242604, + "version": "1.1.1" + }, + "pandas-1.1.1-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "f796fd13ad2fa37cbcb7fa39ca7a393b", + "name": "pandas", + "sha256": "c8d92307f2d63a8ad2cdf949ee36d3723584c68b9aa0768f34bbe705f75cb50d", + "size": 8845130, + "subdir": "linux-64", + "timestamp": 1598372147405, + "version": "1.1.1" + }, + "pandas-1.1.2-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "a2f27a2ac20f298a2b821afe681e1392", + "name": "pandas", + "sha256": "d9fcce7b206c492aa54cb9d63008cfb29f9b56db98754f56acd1e02f8f640bfd", + "size": 8571948, + "subdir": "linux-64", + "timestamp": 1601567910257, + "version": "1.1.2" + }, + "pandas-1.1.2-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "20033917c9e4a09a5265a01acbf2ca38", + "name": "pandas", + "sha256": "127bd5342bc3a0e8be38535d4487a63f1dcfe59715318893c0ba4d6ddf59a4cf", + "size": 8534535, + "subdir": "linux-64", + "timestamp": 1601567896094, + "version": "1.1.2" + }, + "pandas-1.1.2-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "a45e801b974df7af572f1d3df31dff35", + "name": "pandas", + "sha256": "6154715d44f1d0cc5b30ac232aba35ce1c9884f40d960fada268ad0623c3b817", + "size": 8882407, + "subdir": "linux-64", + "timestamp": 1601567875750, + "version": "1.1.2" + }, + "pandas-1.1.3-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "d9f0ff158d8397b5fec819fa220e1b4d", + "name": "pandas", + "sha256": "87852ce3217c39c27fa169dbacb1ea165d43185dd36912f9c4789e27ff55154c", + "size": 8548334, + "subdir": "linux-64", + "timestamp": 1602088788707, + "version": "1.1.3" + }, + "pandas-1.1.3-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "e91002ea29484aa859c93693c06b2adf", + "name": "pandas", + "sha256": "49e61410c0d9ca00ee53616013921f3463690f344556ed0e129a5d1e53c6a284", + "size": 8537336, + "subdir": "linux-64", + "timestamp": 1602088724846, + "version": "1.1.3" + }, + "pandas-1.1.3-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "2e018aac87fad4276fb669d5d26c8d14", + "name": "pandas", + "sha256": "b71737b37fd9c81a7eec4395d9526da63b0a42c5e6280ba05ec996ac84d5e497", + "size": 8882112, + "subdir": "linux-64", + "timestamp": 1602088720000, + "version": "1.1.3" + }, + "pandas-1.1.3-py39h31985d5_0.conda": { + "build": "py39h31985d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "2167ef07ddf1a2759fe712e51e695a73", + "name": "pandas", + "sha256": "2dec3260a2d44e3431adb6ff8dbebc3161298a2f9fcfed7d00537a118d655414", + "size": 8898395, + "subdir": "linux-64", + "timestamp": 1607707828292, + "version": "1.1.3" + }, + "pandas-1.1.5-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "5bc6af8aa398eb4614dd460ee21c260a", + "name": "pandas", + "sha256": "52630e914f7cf1d4f66e41f385770a7b818a148bf340f469e75ba7476277103c", + "size": 8554812, + "subdir": "linux-64", + "timestamp": 1608056777263, + "version": "1.1.5" + }, + "pandas-1.1.5-py36ha9443f7_0.conda": { + "build": "py36ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "d5ae5a1e53f35a1dc8ad9c243e6c13fb", + "name": "pandas", + "sha256": "2f9d4f0dd56aa9159386f3467d3ce869d6623e3761a7e94e04f4ac3b7975642a", + "size": 8549611, + "subdir": "linux-64", + "timestamp": 1608063725977, + "version": "1.1.5" + }, + "pandas-1.1.5-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.4,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "87d1831cca9f003ab1508f1da2b2cca3", + "name": "pandas", + "sha256": "380c3ba5cb597b8cfac1cd5bb4aa7da46cbdec280d62b108153a8718155edcb5", + "size": 8537734, + "subdir": "linux-64", + "timestamp": 1608056794708, + "version": "1.1.5" + }, + "pandas-1.1.5-py37ha9443f7_0.conda": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "ec0adb534a82f87bc8c1cd13212445b1", + "name": "pandas", + "sha256": "451f7900eff7312fa630ddaa5e16e15619f491a3b58fc8ecd807b9c9c67a7a2d", + "size": 8546893, + "subdir": "linux-64", + "timestamp": 1608063717675, + "version": "1.1.5" + }, + "pandas-1.1.5-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "7ea24b80f89a0a6e0c9c5a63a7cf6a2f", + "name": "pandas", + "sha256": "6266d4440ce500cbb398980e977f8f593a0ed920ba10d5ec350dfda764620939", + "size": 8861375, + "subdir": "linux-64", + "timestamp": 1608056834110, + "version": "1.1.5" + }, + "pandas-1.1.5-py38ha9443f7_0.conda": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "6b645b820390561b2c0ddf1f020cc083", + "name": "pandas", + "sha256": "04ded42abdd4f53b10b82b5951ba89e4036599179d5272b72e228e79efb0f885", + "size": 8865671, + "subdir": "linux-64", + "timestamp": 1608063718803, + "version": "1.1.5" + }, + "pandas-1.1.5-py39ha9443f7_0.conda": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "2ff7a29e37093d5a7a996709b0ba0bc8", + "name": "pandas", + "sha256": "12154154bf8707bd6b6ed8837f7a50236c5df4fe4d3008b2cf2ecb70db7b5e52", + "size": 8837048, + "subdir": "linux-64", + "timestamp": 1608063705625, + "version": "1.1.5" + }, + "pandas-1.2.0-py37ha9443f7_0.conda": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "5caac245fdba4cb08a3043f9543b2889", + "name": "pandas", + "sha256": "1a6129f02d621ee99d18c693d7f6db1396e852f7ffd62746536270d4238d83d0", + "size": 8910370, + "subdir": "linux-64", + "timestamp": 1609008050945, + "version": "1.2.0" + }, + "pandas-1.2.0-py38ha9443f7_0.conda": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "6b9afc31f745e8b7488a5859c5903f7c", + "name": "pandas", + "sha256": "e110f5cd9fb07ee51702c73ffa08e695f542a764da56afb55247aad5805ad743", + "size": 9236650, + "subdir": "linux-64", + "timestamp": 1609008290138, + "version": "1.2.0" + }, + "pandas-1.2.0-py39ha9443f7_0.conda": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "8dd26ba37933ccb5ee3369d6ed4d27db", + "name": "pandas", + "sha256": "77b7689c8b473911fe6ee221203ac2954bc5a8668685558f081ca86771627e60", + "size": 9241562, + "subdir": "linux-64", + "timestamp": 1609862877025, + "version": "1.2.0" + }, + "pandas-1.2.1-py37ha9443f7_0.conda": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "0715f9e458424a98ab7da94110f236de", + "name": "pandas", + "sha256": "cd8fa7c32dbdc85b95d2d9d0bd4038dc27afc0028d8847c0b4528d6671fdb3dd", + "size": 8956136, + "subdir": "linux-64", + "timestamp": 1611171734357, + "version": "1.2.1" + }, + "pandas-1.2.1-py38ha9443f7_0.conda": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "a256e5b22d83d5fff85dd335fe975b23", + "name": "pandas", + "sha256": "df33c3de5b0f2eb754723d1877c215ede609f4740259f9fa185dce3d4cce21a0", + "size": 9283306, + "subdir": "linux-64", + "timestamp": 1611171696418, + "version": "1.2.1" + }, + "pandas-1.2.1-py39ha9443f7_0.conda": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "b161c3c2045d7c92a7876cdb08fea50c", + "name": "pandas", + "sha256": "19a212152167472c1e2beb19bd17f9ee343ee486c6085e71bc01e7a59ebaaabd", + "size": 9280462, + "subdir": "linux-64", + "timestamp": 1611243180289, + "version": "1.2.1" + }, + "pandas-1.2.2-py37ha9443f7_0.conda": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "8d795843a9257b5bfb3e5394cb31b90f", + "name": "pandas", + "sha256": "58650b3eb0df560ceefa6b8755fe1e19e59b8426c6606821e2a4aa9a46802072", + "size": 8964372, + "subdir": "linux-64", + "timestamp": 1613685195915, + "version": "1.2.2" + }, + "pandas-1.2.2-py38ha9443f7_0.conda": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "20569d8395bcc804cb59cab8d9500e39", + "name": "pandas", + "sha256": "c0ad81f710e5c06882e37936781be846f5b78fa4e052facbf2d750842d72a37f", + "size": 9257726, + "subdir": "linux-64", + "timestamp": 1613685218390, + "version": "1.2.2" + }, + "pandas-1.2.2-py39ha9443f7_0.conda": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "9f5c97f1aed68b792ac2b5c1ccb12820", + "name": "pandas", + "sha256": "44ebbc49f48886387876bce1bf233d15bc9fa289f1d64a2bcb6b826b8ba1cee6", + "size": 9251682, + "subdir": "linux-64", + "timestamp": 1613685209438, + "version": "1.2.2" + }, + "pandas-1.2.3-py37ha9443f7_0.conda": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "52bed617592726c149b5871d52403623", + "name": "pandas", + "sha256": "89075c8defbff1856233a69a7ebe41e293d79c9ed051e6a5a546bbc5b2c74ccf", + "size": 8962606, + "subdir": "linux-64", + "timestamp": 1614711206706, + "version": "1.2.3" + }, + "pandas-1.2.3-py38ha9443f7_0.conda": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "9bff5082f144ef27a7b78ea328c633f6", + "name": "pandas", + "sha256": "7a4e29f2b3f802eecceb5bf58617d62bc8daee41bc0063bb7672c451e885d4a1", + "size": 9251819, + "subdir": "linux-64", + "timestamp": 1614711502960, + "version": "1.2.3" + }, + "pandas-1.2.3-py39ha9443f7_0.conda": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "06fbe066370ec956e0d4ecd59f0018d7", + "name": "pandas", + "sha256": "2fdd33f325e21b1f7cd0fc8baf0ae3015d3cb916bd1ccc3abc86fffe2ce69de2", + "size": 9302012, + "subdir": "linux-64", + "timestamp": 1614711479927, + "version": "1.2.3" + }, + "pandas-1.2.4-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "md5": "c765c13d62fa029d197c36ab61fc9cde", + "name": "pandas", + "sha256": "7fc5b1cb9db73738f01ab5fdc8c5904dce46fe7c1e24481cf76d9ad703af3930", + "size": 8957694, + "subdir": "linux-64", + "timestamp": 1618365739112, + "version": "1.2.4" + }, + "pandas-1.2.4-py37ha9443f7_0.conda": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "8dd9d486b5c1bb1357b2aa3338a6d87b", + "name": "pandas", + "sha256": "105bc7c30c2a8857ebc49b5a5455294ccb3e5874dec2de24b5bd55594b8264d3", + "size": 8928182, + "subdir": "linux-64", + "timestamp": 1618261562729, + "version": "1.2.4" + }, + "pandas-1.2.4-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "md5": "c3421801d50aa753e86e2fcb5c9142eb", + "name": "pandas", + "sha256": "25f1dfbfeefe68a6c4f76a96b33dab53ba3bac586308c3d99acc39d1a9aec419", + "size": 9291204, + "subdir": "linux-64", + "timestamp": 1618365707232, + "version": "1.2.4" + }, + "pandas-1.2.4-py38ha9443f7_0.conda": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "5bd3fd807a294f387feabc65821b75d0", + "name": "pandas", + "sha256": "a0e174604e418d6514831b1334395697157b4e5d7a411de42ca05dcb463c3a18", + "size": 9267505, + "subdir": "linux-64", + "timestamp": 1618264582354, + "version": "1.2.4" + }, + "pandas-1.2.4-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "md5": "39035815f0088fb3c1e67eaf18b984c5", + "name": "pandas", + "sha256": "4ffe42f901da9a14b5c90d9ad2d43e46605bb57d61102e6a4b8279067cce03fd", + "size": 9293884, + "subdir": "linux-64", + "timestamp": 1618362639771, + "version": "1.2.4" + }, + "pandas-1.2.4-py39ha9443f7_0.conda": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.2" + ], + "license": "BSD-3-Clause", + "md5": "095a5ef212525e4439df3dad21b06926", + "name": "pandas", + "sha256": "92a619eaaba623a746717f9d6cf27722b17118eaca6179df5b8acd362f6e4679", + "size": 9301328, + "subdir": "linux-64", + "timestamp": 1618264415749, + "version": "1.2.4" + }, + "pandas-1.2.5-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20.2,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "md5": "e85acc69d6411d90a97bbf093bd242e4", + "name": "pandas", + "sha256": "10db65bcf3e66d5f954b257b22a1ad1a5db97018c5fb18a1d85230e27971a774", + "size": 8930982, + "subdir": "linux-64", + "timestamp": 1624383818563, + "version": "1.2.5" + }, + "pandas-1.2.5-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "md5": "0810a1b360e18d716299ecee293e5413", + "name": "pandas", + "sha256": "bcdbb1866a8dd46e5df4b866a019c4decaa68a7c509bf3dbb0c5df556d297be0", + "size": 9254935, + "subdir": "linux-64", + "timestamp": 1624383783215, + "version": "1.2.5" + }, + "pandas-1.2.5-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.6.8", + "numpy >=1.20.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "65bb716eebef11437dd18f0a5902a43b", + "name": "pandas", + "sha256": "7508aae7943b38bb440ddf826d247a3f953b158eef16ce7365df7c487b0bb87c", + "size": 9300643, + "subdir": "linux-64", + "timestamp": 1624465755690, + "version": "1.2.5" + }, + "pandas-1.3.0-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "constrains": [], + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.20.3,<2.0a0", + "python >=3.7.1,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7edf3fd8f60d92b677a6c61342bc3a24", + "name": "pandas", + "sha256": "87bd65fc716dcad855fb552517aab3eceecd8cdac0499a000f0690a800a17fcc", + "size": 9676585, + "subdir": "linux-64", + "timestamp": 1626783937717, + "version": "1.3.0" + }, + "pandas-1.3.0-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "constrains": [], + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.20.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e7fcd603dee177c038558a5d2932604", + "name": "pandas", + "sha256": "a0c72c7da76dcd5950412da17c437b54f84f84958f789e5b337bd9a56b6868d3", + "size": 10048852, + "subdir": "linux-64", + "timestamp": 1626777057769, + "version": "1.3.0" + }, + "pandas-1.3.0-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "constrains": [], + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.20.3,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b670b0f9c5b2168ed79583d72553cd67", + "name": "pandas", + "sha256": "634ff6c911edd034a112419cb14f03c88b73c86304155e4e46b13e16c0f8e2f5", + "size": 10038227, + "subdir": "linux-64", + "timestamp": 1626784423334, + "version": "1.3.0" + }, + "pandas-1.3.1-py37h8c16a72_0.conda": { + "build": "py37h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "84ea64cde3e32f1bfc7bbf7a9ea6e14c", + "name": "pandas", + "sha256": "ad31a1c5cba512dc9fa2dfc032e0202c18e6d49f6493e2145c472e0242e7d7de", + "size": 9701807, + "subdir": "linux-64", + "timestamp": 1627570482091, + "version": "1.3.1" + }, + "pandas-1.3.1-py38h8c16a72_0.conda": { + "build": "py38h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "25e047482415b366273096556546efc6", + "name": "pandas", + "sha256": "bc45ed4d50b4a2948e2d77794d462c89720bc626fa3e918a5f85a18b9294ada4", + "size": 10056790, + "subdir": "linux-64", + "timestamp": 1627562754555, + "version": "1.3.1" + }, + "pandas-1.3.1-py39h8c16a72_0.conda": { + "build": "py39h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "040f7e616b265c4f2686d6717160b461", + "name": "pandas", + "sha256": "daa381687559b2a29c2ad7a11e33b3f132d871a4cfc0c901ae95dca5112b0991", + "size": 10023265, + "subdir": "linux-64", + "timestamp": 1627570429844, + "version": "1.3.1" + }, + "pandas-1.3.2-py37h8c16a72_0.conda": { + "build": "py37h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d4d8503c816fe2f9b4322fcad41a2334", + "name": "pandas", + "sha256": "457db411722f108c03f7b5f869ffa9cf2e71ac1984bc37909e39a79fa90ecfaa", + "size": 9659147, + "subdir": "linux-64", + "timestamp": 1629682488712, + "version": "1.3.2" + }, + "pandas-1.3.2-py38h8c16a72_0.conda": { + "build": "py38h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5b734e92ed96f70472dbd8f598ae691a", + "name": "pandas", + "sha256": "231a53af5a98ee0813ae8973b52683866e9f3c21b840f3cdf02d52cf686f067f", + "size": 10039297, + "subdir": "linux-64", + "timestamp": 1629673829678, + "version": "1.3.2" + }, + "pandas-1.3.2-py39h8c16a72_0.conda": { + "build": "py39h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "859eb0ab953e60106623641c8ad496ab", + "name": "pandas", + "sha256": "df4fc050c7a79ccf5103fd8f1a416197df0a537673eb2158376e9105464236eb", + "size": 10020648, + "subdir": "linux-64", + "timestamp": 1629682619870, + "version": "1.3.2" + }, + "pandas-1.3.3-py37h8c16a72_0.conda": { + "build": "py37h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d48224a0535208d0ba6825dd91b115a9", + "name": "pandas", + "sha256": "8534a158c464f801cb5e71dfc048da16e40798c87c4d70133637e4419e3963e2", + "size": 9674236, + "subdir": "linux-64", + "timestamp": 1632912537903, + "version": "1.3.3" + }, + "pandas-1.3.3-py38h8c16a72_0.conda": { + "build": "py38h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f32e088c2b8e54889f2e0580a92fb73e", + "name": "pandas", + "sha256": "509481b30423bceabd75f885b00274c40f7fa1c2cfb3f26b69a7280b51e2871c", + "size": 10051622, + "subdir": "linux-64", + "timestamp": 1632924654473, + "version": "1.3.3" + }, + "pandas-1.3.3-py39h8c16a72_0.conda": { + "build": "py39h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c5cb07e9fa7b486451fcb9e1af943c7d", + "name": "pandas", + "sha256": "1c851fbc5b5d0e9bf6714514a0b588d4b6504ff33038d9688474c4523e137f99", + "size": 10042589, + "subdir": "linux-64", + "timestamp": 1632920172098, + "version": "1.3.3" + }, + "pandas-1.3.4-py37h8c16a72_0.conda": { + "build": "py37h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e7247740ca3962632611e5976a1c316", + "name": "pandas", + "sha256": "500fb6fc9a81af87e76f24f7694bcf2829511f1be129fde3168f328045deb9d0", + "size": 9660637, + "subdir": "linux-64", + "timestamp": 1635495066877, + "version": "1.3.4" + }, + "pandas-1.3.4-py38h8c16a72_0.conda": { + "build": "py38h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "640f54609e147e4907590509c3fd27a8", + "name": "pandas", + "sha256": "2eaa087e7f4ca721cc07e662bf0dd0779f936e0f6b5192e40d59bf09f19c7fdc", + "size": 10038060, + "subdir": "linux-64", + "timestamp": 1635506815901, + "version": "1.3.4" + }, + "pandas-1.3.4-py39h8c16a72_0.conda": { + "build": "py39h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f0c533fb12d7adeba1989c9654182dc7", + "name": "pandas", + "sha256": "2fa858ff1a31d17028f8d0caf7e14668ddfc206907269693e619823c79b99a84", + "size": 10032543, + "subdir": "linux-64", + "timestamp": 1635506799285, + "version": "1.3.4" + }, + "pandas-1.3.5-py37h8c16a72_0.conda": { + "build": "py37h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0aaa3dbe8568ceed1cb7d513fa98e47d", + "name": "pandas", + "sha256": "0039e3d84743ec6cf5db9d7e403c9b42b3fc8dc5ac68de7c72b5405435dd3d9e", + "size": 9729497, + "subdir": "linux-64", + "timestamp": 1641461400562, + "version": "1.3.5" + }, + "pandas-1.3.5-py38h8c16a72_0.conda": { + "build": "py38h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "59b06f7195eb96fea2a49ce2eb814751", + "name": "pandas", + "sha256": "e92b1f0932e52422f90a05dcfe0635c8d10e3d99d21c29ef2e718bf9d9f9aafd", + "size": 10052062, + "subdir": "linux-64", + "timestamp": 1641461402605, + "version": "1.3.5" + }, + "pandas-1.3.5-py39h8c16a72_0.conda": { + "build": "py39h8c16a72_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.2.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.7.3", + "pytz >=2017.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d94850db8b8e8ed640663f1a51a7684a", + "name": "pandas", + "sha256": "d13db7e73c003e44f74005260b7105340248a32f041c1489865536ea51e14ce4", + "size": 10052763, + "subdir": "linux-64", + "timestamp": 1641467043208, + "version": "1.3.5" + }, + "pandas-1.4.1-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.1", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d74bd7a96b914c538e1d67090a4c850d", + "name": "pandas", + "sha256": "e32dcc35a5d337e5125beba54ade63f2f08a57b9452b84e8a0d0f4306d753833", + "size": 26533120, + "subdir": "linux-64", + "timestamp": 1644984497698, + "version": "1.4.1" + }, + "pandas-1.4.1-py310h295c915_1.conda": { + "build": "py310h295c915_1", + "build_number": 1, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.1", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "823564049680f06c771c627e141611f2", + "name": "pandas", + "sha256": "64c83b5e099a86a69f9315510857898a49074633e0b1dc0a9c16b7db0b023982", + "size": 26345689, + "subdir": "linux-64", + "timestamp": 1647937090026, + "version": "1.4.1" + }, + "pandas-1.4.1-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "84d13e883a08af38e6ed9b006b727731", + "name": "pandas", + "sha256": "9c52638da48ebb44873e313a5c5d869892e6be9706c736e26fa9f0edd953ad22", + "size": 10356733, + "subdir": "linux-64", + "timestamp": 1645002573229, + "version": "1.4.1" + }, + "pandas-1.4.1-py38h295c915_1.conda": { + "build": "py38h295c915_1", + "build_number": 1, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b161a4c56c041892998734daaf9125fc", + "name": "pandas", + "sha256": "613a6061122683b232d16b278b677b2f29be275344bcbf2f436c6f22e2de7d37", + "size": 10291957, + "subdir": "linux-64", + "timestamp": 1647937039276, + "version": "1.4.1" + }, + "pandas-1.4.1-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6f676043b5e72565151bf141547b810e", + "name": "pandas", + "sha256": "5e005f1556fd469aac78c0c1a90ce561b68cd2152b15eadd512ee231987ccf1b", + "size": 10344708, + "subdir": "linux-64", + "timestamp": 1645003633433, + "version": "1.4.1" + }, + "pandas-1.4.1-py39h295c915_1.conda": { + "build": "py39h295c915_1", + "build_number": 1, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "78222c98681a80785bd585536b3fa276", + "name": "pandas", + "sha256": "22a2ee985f01b315fca513384870af5e5b63251bd2f5207cb19262232b8a1add", + "size": 10313287, + "subdir": "linux-64", + "timestamp": 1647955127812, + "version": "1.4.1" + }, + "pandas-1.4.2-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.1", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9ccb3c5c70ac584ad5e97791dc87fbc1", + "name": "pandas", + "sha256": "d1410010fdd64bb328ef3e1f6f8a485cc7ee0c7dbcebec8338fbb679c812f460", + "size": 26509843, + "subdir": "linux-64", + "timestamp": 1650622912131, + "version": "1.4.2" + }, + "pandas-1.4.2-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d7b47268902a9d1145351c377de60633", + "name": "pandas", + "sha256": "6c755341c95e68dd35982f854f0c225ec404115031bdd0a0796aba5ead151412", + "size": 10342048, + "subdir": "linux-64", + "timestamp": 1650622643018, + "version": "1.4.2" + }, + "pandas-1.4.2-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d72a62d1a1365f465c8e135ef0e3c3f7", + "name": "pandas", + "sha256": "1e113bdd8ee5983d68dee3e4f58ee7dfbc78825b8707286dbb5d7c4ae2c032ea", + "size": 10345432, + "subdir": "linux-64", + "timestamp": 1650622404234, + "version": "1.4.2" + }, + "pandas-1.4.3-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.1", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "21261e9a668c27b7eaf6f8f4ce8d68b1", + "name": "pandas", + "sha256": "20065fc420c538cc1f8e32a4993f45391b1d5658dad1ed72b9cee546295d7049", + "size": 26798209, + "subdir": "linux-64", + "timestamp": 1657538987413, + "version": "1.4.3" + }, + "pandas-1.4.3-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7cc6907e7f7a73e443bc6434737cf901", + "name": "pandas", + "sha256": "35a6a6c02ff245840e6618200c5b9e16d08c56bdd8dce2139b8dbfd403807369", + "size": 10428695, + "subdir": "linux-64", + "timestamp": 1657538461962, + "version": "1.4.3" + }, + "pandas-1.4.3-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cbc37bda59c24cf60d2d49e5e3215165", + "name": "pandas", + "sha256": "6af639f207b09dbec360b678ebfb40aa3eab0994e4b3f45a959026dd43f8bf75", + "size": 10332125, + "subdir": "linux-64", + "timestamp": 1657538708888, + "version": "1.4.3" + }, + "pandas-1.4.4-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.1", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7437e4bb1aed5b95a3944e7445665288", + "name": "pandas", + "sha256": "2b67b66a9afe4a0bb33d2736a0c42966c9cb85dbedefb46dac40d90205793159", + "size": 26752310, + "subdir": "linux-64", + "timestamp": 1663773730637, + "version": "1.4.4" + }, + "pandas-1.4.4-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "908d540c2bae8bdc893b515387915e18", + "name": "pandas", + "sha256": "992bc3991f3c732032295604e40f064a177fe4110e6b4e92fc49d7a0a9fcc034", + "size": 10400671, + "subdir": "linux-64", + "timestamp": 1663773208909, + "version": "1.4.4" + }, + "pandas-1.4.4-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "bottleneck >=1.3.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.1", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3906adc591c4c8973d9e0a175144a98e", + "name": "pandas", + "sha256": "635ee1960ff142dc7fc3f109d64afc64ab2b959c3adc2c6ad993ca7428fd9b35", + "size": 10314064, + "subdir": "linux-64", + "timestamp": 1663773447154, + "version": "1.4.4" + }, + "pandas-1.5.1-py310h1128e8f_0.conda": { + "build": "py310h1128e8f_0", + "build_number": 0, + "constrains": [ + "brotli >=0.7.0", + "numba >=0.53.1", + "tzdata >=2022a", + "blosc >=1.21.0", + "sqlalchemy >=1.4.16", + "matplotlib-base >=3.3.2", + "gcsfs >=2021.7.0", + "jinja2 >=3.0.0", + "pyxlsb >=1.0.8", + "beautifulsoup4 >=4.9.3", + "xlrd >=2.0.1", + "zstandard >=0.15.2", + "html5lib >=1.1", + "fastparquet >=0.4.0", + "scipy >=1.7.1", + "psycopg2 >=2.8.6", + "pymysql >=1.0.2", + "xlsxwriter >=1.4.3", + "pyreadstat >=1.1.2", + "s3fs >=2021.08.0", + "lxml >=4.6.3", + "pyarrow >=1.0.1", + "tabulate >=0.8.9", + "python-snappy >=0.6.0", + "pytables >=3.6.1", + "fsspec >=2021.7.0", + "xlwt >=1.3.0", + "pandas-gbq >=0.15.0", + "xarray >=0.19.0", + "openpyxl >=3.0.7" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.21,<2.0a0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2fb288a94e340f7801e71554713a2b10", + "name": "pandas", + "sha256": "d0c686ff6972d34627d21cacbacf70bfd16f028d14ae8d54a3d13592fac5d507", + "size": 12474583, + "subdir": "linux-64", + "timestamp": 1668628783900, + "version": "1.5.1" + }, + "pandas-1.5.1-py38h417a72b_0.conda": { + "build": "py38h417a72b_0", + "build_number": 0, + "constrains": [ + "brotli >=0.7.0", + "numba >=0.53.1", + "tzdata >=2022a", + "blosc >=1.21.0", + "sqlalchemy >=1.4.16", + "matplotlib-base >=3.3.2", + "gcsfs >=2021.7.0", + "jinja2 >=3.0.0", + "pyxlsb >=1.0.8", + "beautifulsoup4 >=4.9.3", + "xlrd >=2.0.1", + "zstandard >=0.15.2", + "html5lib >=1.1", + "fastparquet >=0.4.0", + "scipy >=1.7.1", + "psycopg2 >=2.8.6", + "pymysql >=1.0.2", + "xlsxwriter >=1.4.3", + "pyreadstat >=1.1.2", + "s3fs >=2021.08.0", + "lxml >=4.6.3", + "pyarrow >=1.0.1", + "tabulate >=0.8.9", + "python-snappy >=0.6.0", + "pytables >=3.6.1", + "fsspec >=2021.7.0", + "xlwt >=1.3.0", + "pandas-gbq >=0.15.0", + "xarray >=0.19.0", + "openpyxl >=3.0.7" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.16,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "531de912644e67fa3c1d4d1f4aeb8e50", + "name": "pandas", + "sha256": "8795800301ba26b75ea679ec1c3daf865277f671aa0d8150845f4259ac726464", + "size": 12593179, + "subdir": "linux-64", + "timestamp": 1668629301789, + "version": "1.5.1" + }, + "pandas-1.5.1-py39h417a72b_0.conda": { + "build": "py39h417a72b_0", + "build_number": 0, + "constrains": [ + "brotli >=0.7.0", + "numba >=0.53.1", + "tzdata >=2022a", + "blosc >=1.21.0", + "sqlalchemy >=1.4.16", + "matplotlib-base >=3.3.2", + "gcsfs >=2021.7.0", + "jinja2 >=3.0.0", + "pyxlsb >=1.0.8", + "beautifulsoup4 >=4.9.3", + "xlrd >=2.0.1", + "zstandard >=0.15.2", + "html5lib >=1.1", + "fastparquet >=0.4.0", + "scipy >=1.7.1", + "psycopg2 >=2.8.6", + "pymysql >=1.0.2", + "xlsxwriter >=1.4.3", + "pyreadstat >=1.1.2", + "s3fs >=2021.08.0", + "lxml >=4.6.3", + "pyarrow >=1.0.1", + "tabulate >=0.8.9", + "python-snappy >=0.6.0", + "pytables >=3.6.1", + "fsspec >=2021.7.0", + "xlwt >=1.3.0", + "pandas-gbq >=0.15.0", + "xarray >=0.19.0", + "openpyxl >=3.0.7" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.16,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1a18e13e6f3fee6b4ea470f586cfe7a7", + "name": "pandas", + "sha256": "78243a9b3c258aef7b423d786d2fad8e4dfeb7ce134cfdcfb35a2be8da027734", + "size": 12466226, + "subdir": "linux-64", + "timestamp": 1668629820909, + "version": "1.5.1" + }, + "pandas-1.5.2-py310h1128e8f_0.conda": { + "build": "py310h1128e8f_0", + "build_number": 0, + "constrains": [ + "xlrd >=2.0.1", + "fsspec >=2021.7.0", + "pytables >=3.6.1", + "beautifulsoup4 >=4.9.3", + "psycopg2 >=2.8.6", + "numba >=0.53.1", + "pyarrow >=1.0.1", + "pyxlsb >=1.0.8", + "tabulate >=0.8.9", + "sqlalchemy >=1.4.16", + "xarray >=0.19.0", + "fastparquet >=0.4.0", + "html5lib >=1.1", + "jinja2 >=3.0.0", + "matplotlib-base >=3.3.2", + "blosc >=1.21.0", + "openpyxl >=3.0.7", + "xlsxwriter >=1.4.3", + "xlwt >=1.3.0", + "pyreadstat >=1.1.2", + "python-snappy >=0.6.0", + "brotli >=0.7.0", + "pymysql >=1.0.2", + "zstandard >=0.15.2", + "gcsfs >=2021.7.0", + "lxml >=4.6.3", + "scipy >=1.7.1", + "s3fs >=2021.08.0", + "pandas-gbq >=0.15.0", + "tzdata >=2022a" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.21,<2.0a0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "db789006e348fd4352ab6c9f6ca33b30", + "name": "pandas", + "sha256": "6fada089612e9060bf815054a18fcb58d68296ad4b2dd9c785de2740bcfd6c6d", + "size": 12500077, + "subdir": "linux-64", + "timestamp": 1670425513958, + "version": "1.5.2" + }, + "pandas-1.5.2-py311hba01205_0.conda": { + "build": "py311hba01205_0", + "build_number": 0, + "constrains": [ + "psycopg2 >=2.8.6", + "matplotlib-base >=3.3.2", + "lxml >=4.6.3", + "s3fs >=2021.08.0", + "pyxlsb >=1.0.8", + "tzdata >=2022a", + "pymysql >=1.0.2", + "beautifulsoup4 >=4.9.3", + "python-snappy >=0.6.0", + "xlsxwriter >=1.4.3", + "gcsfs >=2021.7.0", + "blosc >=1.21.0", + "scipy >=1.7.1", + "xlrd >=2.0.1", + "pytables >=3.6.1", + "tabulate >=0.8.9", + "xarray >=0.19.0", + "numba >=0.53.1", + "brotli >=0.7.0", + "fastparquet >=0.4.0", + "fsspec >=2021.7.0", + "jinja2 >=3.0.0", + "pandas-gbq >=0.15.0", + "zstandard >=0.15.2", + "xlwt >=1.3.0", + "html5lib >=1.1", + "pyarrow >=1.0.1", + "pyreadstat >=1.1.2", + "sqlalchemy >=1.4.16", + "openpyxl >=3.0.7" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.23,<2.0a0", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "637afbf1aa5c999000b3fffdb7e2a617", + "name": "pandas", + "sha256": "4d6ca05255d2d5a2a37eabc5fa7ea9d85689920dc425f539b85e18700ecce93c", + "size": 13532598, + "subdir": "linux-64", + "timestamp": 1676828679137, + "version": "1.5.2" + }, + "pandas-1.5.2-py38h417a72b_0.conda": { + "build": "py38h417a72b_0", + "build_number": 0, + "constrains": [ + "xlrd >=2.0.1", + "fsspec >=2021.7.0", + "pytables >=3.6.1", + "beautifulsoup4 >=4.9.3", + "psycopg2 >=2.8.6", + "numba >=0.53.1", + "pyarrow >=1.0.1", + "pyxlsb >=1.0.8", + "tabulate >=0.8.9", + "sqlalchemy >=1.4.16", + "xarray >=0.19.0", + "fastparquet >=0.4.0", + "html5lib >=1.1", + "jinja2 >=3.0.0", + "matplotlib-base >=3.3.2", + "blosc >=1.21.0", + "openpyxl >=3.0.7", + "xlsxwriter >=1.4.3", + "xlwt >=1.3.0", + "pyreadstat >=1.1.2", + "python-snappy >=0.6.0", + "brotli >=0.7.0", + "pymysql >=1.0.2", + "zstandard >=0.15.2", + "gcsfs >=2021.7.0", + "lxml >=4.6.3", + "scipy >=1.7.1", + "s3fs >=2021.08.0", + "pandas-gbq >=0.15.0", + "tzdata >=2022a" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.16,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7c76aec8e3f010586e4a026fb5235bfb", + "name": "pandas", + "sha256": "420ce698a086f2c73bfc53cbdcfc8396cb2c46e8dab5cfb17f7f43ec6287f6c9", + "size": 12614223, + "subdir": "linux-64", + "timestamp": 1670426433193, + "version": "1.5.2" + }, + "pandas-1.5.2-py39h417a72b_0.conda": { + "build": "py39h417a72b_0", + "build_number": 0, + "constrains": [ + "xlrd >=2.0.1", + "fsspec >=2021.7.0", + "pytables >=3.6.1", + "beautifulsoup4 >=4.9.3", + "psycopg2 >=2.8.6", + "numba >=0.53.1", + "pyarrow >=1.0.1", + "pyxlsb >=1.0.8", + "tabulate >=0.8.9", + "sqlalchemy >=1.4.16", + "xarray >=0.19.0", + "fastparquet >=0.4.0", + "html5lib >=1.1", + "jinja2 >=3.0.0", + "matplotlib-base >=3.3.2", + "blosc >=1.21.0", + "openpyxl >=3.0.7", + "xlsxwriter >=1.4.3", + "xlwt >=1.3.0", + "pyreadstat >=1.1.2", + "python-snappy >=0.6.0", + "brotli >=0.7.0", + "pymysql >=1.0.2", + "zstandard >=0.15.2", + "gcsfs >=2021.7.0", + "lxml >=4.6.3", + "scipy >=1.7.1", + "s3fs >=2021.08.0", + "pandas-gbq >=0.15.0", + "tzdata >=2022a" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.16,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cec24d3ac2c4dfc674c52a186a9381aa", + "name": "pandas", + "sha256": "101cc4e7773eba1635a15ca3c2f7b67cf05f87f8474b2f23b7260d612600ec80", + "size": 12486062, + "subdir": "linux-64", + "timestamp": 1670425963917, + "version": "1.5.2" + }, + "pandas-1.5.3-py310h1128e8f_0.conda": { + "build": "py310h1128e8f_0", + "build_number": 0, + "constrains": [ + "xarray >=0.19.0", + "matplotlib-base >=3.3.2", + "fastparquet >=0.4.0", + "numba >=0.53.1", + "xlsxwriter >=1.4.3", + "lxml >=4.6.3", + "pytables >=3.6.1", + "scipy >=1.7.1", + "blosc >=1.21.0", + "pandas-gbq >=0.15.0", + "zstandard >=0.15.2", + "xlwt >=1.3.0", + "html5lib >=1.1", + "xlrd >=2.0.1", + "psycopg2 >=2.8.6", + "openpyxl >=3.0.7", + "pyreadstat >=1.1.2", + "gcsfs >=2021.7.0", + "pyxlsb >=1.0.8", + "tzdata >=2022a", + "python-snappy >=0.6.0", + "fsspec >=2021.7.0", + "sqlalchemy >=1.4.16", + "pyarrow >=1.0.1", + "s3fs >=2021.08.0", + "pymysql >=1.0.2", + "tabulate >=0.8.9", + "beautifulsoup4 >=4.9.3", + "brotli >=0.7.0", + "jinja2 >=3.0.0" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.21,<2.0a0", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c35f8ea378f1aa91cb9a4037a7a43fc2", + "name": "pandas", + "sha256": "9ffc6adee3b700b86fbde49afc6e4037b82a849460832aa37eee6ef319f08a9a", + "size": 12567394, + "subdir": "linux-64", + "timestamp": 1677836477780, + "version": "1.5.3" + }, + "pandas-1.5.3-py311hba01205_0.conda": { + "build": "py311hba01205_0", + "build_number": 0, + "constrains": [ + "s3fs >=2021.08.0", + "tabulate >=0.8.9", + "pyreadstat >=1.1.2", + "pyarrow >=1.0.1", + "numba >=0.53.1", + "python-snappy >=0.6.0", + "openpyxl >=3.0.7", + "pandas-gbq >=0.15.0", + "gcsfs >=2021.7.0", + "blosc >=1.21.0", + "html5lib >=1.1", + "matplotlib-base >=3.3.2", + "scipy >=1.7.1", + "xlrd >=2.0.1", + "xlwt >=1.3.0", + "lxml >=4.6.3", + "brotli >=0.7.0", + "fsspec >=2021.7.0", + "xarray >=0.19.0", + "jinja2 >=3.0.0", + "xlsxwriter >=1.4.3", + "pymysql >=1.0.2", + "zstandard >=0.15.2", + "pytables >=3.6.1", + "tzdata >=2022a", + "pyxlsb >=1.0.8", + "psycopg2 >=2.8.6", + "fastparquet >=0.4.0", + "beautifulsoup4 >=4.9.3", + "sqlalchemy >=1.4.16" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.23,<2.0a0", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d49480f6c068e8c5f669d08b25788428", + "name": "pandas", + "sha256": "0ff877aeb4f921216a45e6409d4c306495f0c6752faf427d8e35d066bb21c97d", + "size": 13542972, + "subdir": "linux-64", + "timestamp": 1679337148903, + "version": "1.5.3" + }, + "pandas-1.5.3-py38h417a72b_0.conda": { + "build": "py38h417a72b_0", + "build_number": 0, + "constrains": [ + "xarray >=0.19.0", + "matplotlib-base >=3.3.2", + "fastparquet >=0.4.0", + "numba >=0.53.1", + "xlsxwriter >=1.4.3", + "lxml >=4.6.3", + "pytables >=3.6.1", + "scipy >=1.7.1", + "blosc >=1.21.0", + "pandas-gbq >=0.15.0", + "zstandard >=0.15.2", + "xlwt >=1.3.0", + "html5lib >=1.1", + "xlrd >=2.0.1", + "psycopg2 >=2.8.6", + "openpyxl >=3.0.7", + "pyreadstat >=1.1.2", + "gcsfs >=2021.7.0", + "pyxlsb >=1.0.8", + "tzdata >=2022a", + "python-snappy >=0.6.0", + "fsspec >=2021.7.0", + "sqlalchemy >=1.4.16", + "pyarrow >=1.0.1", + "s3fs >=2021.08.0", + "pymysql >=1.0.2", + "tabulate >=0.8.9", + "beautifulsoup4 >=4.9.3", + "brotli >=0.7.0", + "jinja2 >=3.0.0" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.20.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "53ed93df10e5f42901c5e2157a2f15a9", + "name": "pandas", + "sha256": "40a63e45079e8069ddde9ae51dd2b3eab1064f5e106c7be59faa56e7bda04ed7", + "size": 12654983, + "subdir": "linux-64", + "timestamp": 1677836949366, + "version": "1.5.3" + }, + "pandas-1.5.3-py39h417a72b_0.conda": { + "build": "py39h417a72b_0", + "build_number": 0, + "constrains": [ + "xarray >=0.19.0", + "matplotlib-base >=3.3.2", + "fastparquet >=0.4.0", + "numba >=0.53.1", + "xlsxwriter >=1.4.3", + "lxml >=4.6.3", + "pytables >=3.6.1", + "scipy >=1.7.1", + "blosc >=1.21.0", + "pandas-gbq >=0.15.0", + "zstandard >=0.15.2", + "xlwt >=1.3.0", + "html5lib >=1.1", + "xlrd >=2.0.1", + "psycopg2 >=2.8.6", + "openpyxl >=3.0.7", + "pyreadstat >=1.1.2", + "gcsfs >=2021.7.0", + "pyxlsb >=1.0.8", + "tzdata >=2022a", + "python-snappy >=0.6.0", + "fsspec >=2021.7.0", + "sqlalchemy >=1.4.16", + "pyarrow >=1.0.1", + "s3fs >=2021.08.0", + "pymysql >=1.0.2", + "tabulate >=0.8.9", + "beautifulsoup4 >=4.9.3", + "brotli >=0.7.0", + "jinja2 >=3.0.0" + ], + "depends": [ + "bottleneck >=1.3.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numexpr >=2.7.3", + "numpy >=1.20.3,<2.0a0", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.1", + "pytz >=2020.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d4d4678ada21d96c49ee4583de1a7b3a", + "name": "pandas", + "sha256": "295cefd913f8c3cba6438485f198cd55162e476583df22057be2d36edeba02c7", + "size": 12541258, + "subdir": "linux-64", + "timestamp": 1677836026367, + "version": "1.5.3" + }, + "pandas-datareader-0.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "lxml", + "pandas >=0.19.2", + "python >=2.7,<2.8.0a0", + "requests >=2.3.0", + "requests-file", + "requests-ftp", + "wrapt" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "7a8863f64ce0e0489bd5859fe10443fa", + "name": "pandas-datareader", + "sha256": "4cc6339e1925774408707b84fa0b7ede631a11aaf0c948edf0bbaa12e554bcbc", + "size": 138688, + "subdir": "linux-64", + "timestamp": 1519364631254, + "version": "0.6.0" + }, + "pandas-datareader-0.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "lxml", + "pandas >=0.19.2", + "python >=3.5,<3.6.0a0", + "requests >=2.3.0", + "requests-file", + "requests-ftp", + "wrapt" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "ab71dc62b69a9675e789a3ad315eec2d", + "name": "pandas-datareader", + "sha256": "aea9f1839d554d9cfed3eea96ffca39dd2deda3eb328ff0a453333a37ae296da", + "size": 143188, + "subdir": "linux-64", + "timestamp": 1519364651302, + "version": "0.6.0" + }, + "pandas-datareader-0.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lxml", + "pandas >=0.19.2", + "python >=3.6,<3.7.0a0", + "requests >=2.3.0", + "requests-file", + "requests-ftp", + "wrapt" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "195c37fc47193bf1c0cfb14c69ff740a", + "name": "pandas-datareader", + "sha256": "1a2a8ee72db3ed6f9b9e658eca5f48ed513e9dc1c120c145eba86448c9be096d", + "size": 141895, + "subdir": "linux-64", + "timestamp": 1519364587829, + "version": "0.6.0" + }, + "pandas-datareader-0.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lxml", + "pandas >=0.19.2", + "python >=3.7,<3.8.0a0", + "requests >=2.3.0", + "requests-file", + "requests-ftp", + "wrapt" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "d41988c6db4c381c76ab2ac47a60a897", + "name": "pandas-datareader", + "sha256": "ec2bc68839fcf7ebf457469ab2b6c8745ba5ef4948e29286b21c95089779f910", + "size": 143125, + "subdir": "linux-64", + "timestamp": 1530904697740, + "version": "0.6.0" + }, + "pandas-datareader-0.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "lxml", + "pandas >=0.19.2", + "python >=2.7,<2.8.0a0", + "requests >=2.3.0", + "wrapt" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "846a667eb20e62dc1dd6f3c1330c640d", + "name": "pandas-datareader", + "sha256": "5d88ef3c367e6f50790ed29884aeb17a4fff2b5035884c9f64bebdc255f6bf12", + "size": 148741, + "subdir": "linux-64", + "timestamp": 1539713945539, + "version": "0.7.0" + }, + "pandas-datareader-0.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "lxml", + "pandas >=0.19.2", + "python >=3.6,<3.7.0a0", + "requests >=2.3.0", + "wrapt" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "8a2f9eb04723f6099a757f67e9f116bb", + "name": "pandas-datareader", + "sha256": "c7049c54cea72cb7fd03daae021e6fe0b98ed452664ac3d1dc979fc571d48f07", + "size": 148765, + "subdir": "linux-64", + "timestamp": 1539713959188, + "version": "0.7.0" + }, + "pandas-datareader-0.7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "lxml", + "pandas >=0.19.2", + "python >=3.7,<3.8.0a0", + "requests >=2.3.0", + "wrapt" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "502a6a26320c071c2dc70e56fb0ccb14", + "name": "pandas-datareader", + "sha256": "c4344983a67491edef53f2daf733712f8b91fff48f31b4880b44c6bfab3f74fe", + "size": 150619, + "subdir": "linux-64", + "timestamp": 1539713961167, + "version": "0.7.0" + }, + "pandas-profiling-1.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.8", + "matplotlib >=1.4", + "pandas >=0.19", + "python >=2.7,<2.8.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "738697a362c301e34101434eb9828c15", + "name": "pandas-profiling", + "sha256": "54a708323dda93dafff9d693ce903baf0d83ae1199c4085b3d68fe7a100db22a", + "size": 40679, + "subdir": "linux-64", + "timestamp": 1522775496116, + "version": "1.4.1" + }, + "pandas-profiling-1.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.8", + "matplotlib >=1.4", + "pandas >=0.19", + "python >=3.5,<3.6.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "780fc0b4c54f1c7910d9c02fcbd41aa0", + "name": "pandas-profiling", + "sha256": "65a7db2cccaaa02cf28c0bdd5d311225773c67eb84a5c92d5f0f07bdbe9660d2", + "size": 40678, + "subdir": "linux-64", + "timestamp": 1522775535414, + "version": "1.4.1" + }, + "pandas-profiling-1.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.8", + "matplotlib >=1.4", + "pandas >=0.19", + "python >=3.6,<3.7.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "93d59d14b42840665090549dfbcadb98", + "name": "pandas-profiling", + "sha256": "276850337ca68a25f1d7c68d43035beee852317e880759a6dae1be315e7ed6ba", + "size": 40201, + "subdir": "linux-64", + "timestamp": 1522775535395, + "version": "1.4.1" + }, + "pandas-profiling-1.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.8", + "matplotlib >=1.4", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c66d6dc6d0e31fbc7e25d04b33163596", + "name": "pandas-profiling", + "sha256": "c122618d4101085837f3fc6ea97a3756ae08d61ac78eb279f76c5e06eb7a64fd", + "size": 40438, + "subdir": "linux-64", + "timestamp": 1530904733349, + "version": "1.4.1" + }, + "pandas-profiling-1.4.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.8", + "matplotlib >=1.4", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "six >=1.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "592a93c8f9485e84d207f1b3e02003d3", + "name": "pandas-profiling", + "sha256": "0c900094ac8e89f95b9b9ea19872f72846394e776c1261fa5894caba4c34d05c", + "size": 41034, + "subdir": "linux-64", + "timestamp": 1574169723462, + "version": "1.4.1" + }, + "pandas-profiling-3.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "htmlmin >=0.1.12", + "htmlmin >=0.1.12", + "imagehash", + "jinja2 >=2.11.1", + "joblib >=1.0.1,<1.1.0", + "markupsafe >=2.0.1,<2.1.0", + "matplotlib-base >=3.2.0", + "missingno >=0.4.2", + "multimethod >=1.4", + "numpy >=1.16.0", + "pandas >=0.25.3,!=1.0.1,!=1.0.0,!=1.0.2,!=1.1.0", + "phik >=0.11.1", + "pydantic >=1.8.1", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.0.0", + "requests >=2.24.0", + "scipy >=1.4.1", + "seaborn >=0.10.1", + "tangled-up-in-unicode 0.1.0.*", + "tqdm >=4.48.2", + "visions 0.7.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b81f89e1d8b5f8e2c0c4ac7d2fad7043", + "name": "pandas-profiling", + "sha256": "30d0d41dfed6801954839047b8694324494314d5f54da4149465aa3ddbfae059", + "size": 246453, + "subdir": "linux-64", + "timestamp": 1650891183179, + "version": "3.1.0" + }, + "pandas-profiling-3.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "htmlmin >=0.1.12", + "htmlmin >=0.1.12", + "imagehash", + "jinja2 >=2.11.1", + "joblib >=1.0.1,<1.1.0", + "markupsafe >=2.0.1,<2.1.0", + "matplotlib-base >=3.2.0", + "missingno >=0.4.2", + "multimethod >=1.4", + "numpy >=1.16.0", + "pandas >=0.25.3,!=1.0.1,!=1.0.0,!=1.0.2,!=1.1.0", + "phik >=0.11.1", + "pydantic >=1.8.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.0.0", + "requests >=2.24.0", + "scipy >=1.4.1", + "seaborn >=0.10.1", + "tangled-up-in-unicode 0.1.0.*", + "tqdm >=4.48.2", + "visions 0.7.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0aa5bb7acef266047348d0ff179dd62d", + "name": "pandas-profiling", + "sha256": "cbfa5905053108d5d9fbcb8279bfb805b33022ac299264081ffd6651dd3c5c57", + "size": 242616, + "subdir": "linux-64", + "timestamp": 1650891303711, + "version": "3.1.0" + }, + "pandas-profiling-3.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "htmlmin >=0.1.12", + "htmlmin >=0.1.12", + "imagehash", + "jinja2 >=2.11.1", + "joblib >=1.0.1,<1.1.0", + "markupsafe >=2.0.1,<2.1.0", + "matplotlib-base >=3.2.0", + "missingno >=0.4.2", + "multimethod >=1.4", + "numpy >=1.16.0", + "pandas >=0.25.3,!=1.0.1,!=1.0.0,!=1.0.2,!=1.1.0", + "phik >=0.11.1", + "pydantic >=1.8.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.0.0", + "requests >=2.24.0", + "scipy >=1.4.1", + "seaborn >=0.10.1", + "tangled-up-in-unicode 0.1.0.*", + "tqdm >=4.48.2", + "visions 0.7.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "623767eb1af1cfb9056690b043b9e535", + "name": "pandas-profiling", + "sha256": "6c928c6e52d9876cb26ee98a02925052dbdfd440b5bb6ac972bbc61b08ba243d", + "size": 244140, + "subdir": "linux-64", + "timestamp": 1650891245426, + "version": "3.1.0" + }, + "pandas-profiling-3.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "htmlmin >=0.1.12", + "htmlmin >=0.1.12", + "imagehash", + "jinja2 >=2.11.1", + "joblib >=1.0.1,<1.1.0", + "markupsafe >=2.0.1,<2.1.0", + "matplotlib-base >=3.2.0", + "missingno >=0.4.2", + "multimethod >=1.4", + "numpy >=1.16.0", + "pandas >=0.25.3,!=1.0.1,!=1.0.0,!=1.0.2,!=1.1.0", + "phik >=0.11.1", + "pydantic >=1.8.1", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.0.0", + "requests >=2.24.0", + "scipy >=1.4.1", + "seaborn >=0.10.1", + "tangled-up-in-unicode 0.1.0.*", + "tqdm >=4.48.2", + "visions 0.7.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d7bd089e1db3773b5273b1af8f6785a", + "name": "pandas-profiling", + "sha256": "f6432ab74abbf0e07ab1ba0825f4e0460abdec34e8c40ce3300fae6c7e498fb2", + "size": 244327, + "subdir": "linux-64", + "timestamp": 1650891098653, + "version": "3.1.0" + }, + "pandas-profiling-3.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-core >=4.6.3", + "tangled-up-in-unicode==0.2.0", + "jupyter-client >=5.3.4", + "ipywidgets >=7.5.1" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.6", + "missingno >=0.4.2,<0.6", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc37897b80605ddecbf6e07b832056f6", + "name": "pandas-profiling", + "sha256": "fb8ba63baf67a25a41afcd854bbd9b1680f53789729b48402609c0ece0334913", + "size": 283179, + "subdir": "linux-64", + "timestamp": 1668630237540, + "version": "3.4.0" + }, + "pandas-profiling-3.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-core >=4.6.3", + "tangled-up-in-unicode==0.2.0", + "jupyter-client >=5.3.4", + "ipywidgets >=7.5.1" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.6", + "missingno >=0.4.2,<0.6", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6719073bc4267be292b283a5e78e9745", + "name": "pandas-profiling", + "sha256": "62b4efe339bb1e9b7c085574d664e638b5d01213ef626f465f785e58adc78fe3", + "size": 280451, + "subdir": "linux-64", + "timestamp": 1668630347200, + "version": "3.4.0" + }, + "pandas-profiling-3.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-core >=4.6.3", + "tangled-up-in-unicode==0.2.0", + "jupyter-client >=5.3.4", + "ipywidgets >=7.5.1" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.6", + "missingno >=0.4.2,<0.6", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2dda069fbc4779e9752d844b3f9154d6", + "name": "pandas-profiling", + "sha256": "ce989c0dbe7e8a06247e459f28f6e971f002f01ae3969f1f010f8c9824825822", + "size": 281215, + "subdir": "linux-64", + "timestamp": 1668630178029, + "version": "3.4.0" + }, + "pandas-profiling-3.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-core >=4.6.3", + "tangled-up-in-unicode==0.2.0", + "jupyter-client >=5.3.4", + "ipywidgets >=7.5.1" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.6", + "missingno >=0.4.2,<0.6", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a61433d29079359d4e1fd54979b56c7", + "name": "pandas-profiling", + "sha256": "b2ce62939306fae2eae02ba136b37f0c45de5669e585ab25671b3b8058d05689", + "size": 280797, + "subdir": "linux-64", + "timestamp": 1668630293674, + "version": "3.4.0" + }, + "pandas-profiling-3.6.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-client >=5.3.4", + "ipywidgets >=7.5.1", + "tangled-up-in-unicode==0.2.0", + "jupyter-core >=4.6.3" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.7", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "typeguard >=2.13.2,<2.14", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2812628ade9806741b05624e936fc448", + "name": "pandas-profiling", + "sha256": "4e12f087a4f2cafa9e7c56bcbabb3936a4148e94c8c98292c81689591d7bb670", + "size": 305576, + "subdir": "linux-64", + "timestamp": 1674806970052, + "version": "3.6.3" + }, + "pandas-profiling-3.6.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-client >=5.3.4", + "ipywidgets >=7.5.1", + "tangled-up-in-unicode==0.2.0", + "jupyter-core >=4.6.3" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.7", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "typeguard >=2.13.2,<2.14", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0cbf687a4ebc448ca3850ad8029759e", + "name": "pandas-profiling", + "sha256": "a7f0364dd07f9c56d10ef735d523464b2f265ce2924d592e903a9223dd889ae9", + "size": 301244, + "subdir": "linux-64", + "timestamp": 1674806855357, + "version": "3.6.3" + }, + "pandas-profiling-3.6.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-client >=5.3.4", + "ipywidgets >=7.5.1", + "tangled-up-in-unicode==0.2.0", + "jupyter-core >=4.6.3" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.7", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "typeguard >=2.13.2,<2.14", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f5e6d976120ecb15326f7f4a90346c5b", + "name": "pandas-profiling", + "sha256": "9c203fda8ba66465ac8feda8f286bae67ef8d857440a72fffdcac28bb4603d22", + "size": 303911, + "subdir": "linux-64", + "timestamp": 1674806916980, + "version": "3.6.3" + }, + "pandas-profiling-3.6.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-client >=5.3.4", + "ipywidgets >=7.5.1", + "tangled-up-in-unicode==0.2.0", + "jupyter-core >=4.6.3" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.7", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "typeguard >=2.13.2,<2.14", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7b788dea54dbe16b3002f6696ad4d7e", + "name": "pandas-profiling", + "sha256": "7e19cdda095e21dea9e31b62bb947d982e922e5c454bf86ff2c03e97bff52a54", + "size": 303028, + "subdir": "linux-64", + "timestamp": 1674807024179, + "version": "3.6.3" + }, + "pandas-stubs-1.5.0.221003-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "types-pytz >=2022.1.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f95f9e0f7a9b9398459407beb2f6eae9", + "name": "pandas-stubs", + "sha256": "40151570ba47094265046dbd3b9819757f141c0f0af2b1542bd8b3166455244f", + "size": 84012, + "subdir": "linux-64", + "timestamp": 1665524533902, + "version": "1.5.0.221003" + }, + "pandas-stubs-1.5.0.221003-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "types-pytz >=2022.1.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b2bb159c5d1229b753b3b0e507d80e7c", + "name": "pandas-stubs", + "sha256": "784b538b37b92a2ec6cc83d65699a281de35678470509d3944f339b6126cfdc5", + "size": 83952, + "subdir": "linux-64", + "timestamp": 1665524570743, + "version": "1.5.0.221003" + }, + "pandas-stubs-1.5.0.221003-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "types-pytz >=2022.1.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "16388f6fd51fd42bf9a116045b4c8bc1", + "name": "pandas-stubs", + "sha256": "0a504b57a58aa25a69aa811daae4af18175508c2666e178109a97e0557ff01c9", + "size": 83970, + "subdir": "linux-64", + "timestamp": 1665524605440, + "version": "1.5.0.221003" + }, + "pandas-stubs-1.5.3.230203-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "types-pytz >=2022.1.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "79f4ff59dd16514036d85003f4c432a5", + "name": "pandas-stubs", + "sha256": "3dc73a5dc17c7fc788587a15b9c00c67932f91d92d9e69120a64df01514fb0f9", + "size": 94111, + "subdir": "linux-64", + "timestamp": 1676319918008, + "version": "1.5.3.230203" + }, + "pandas-stubs-1.5.3.230203-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "types-pytz >=2022.1.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2e6b729495651088d5d3c04444788d4c", + "name": "pandas-stubs", + "sha256": "27acee6f60a88a15ca242b0ba072d7b69388ad1d55497d40cf1074faa41ff833", + "size": 90293, + "subdir": "linux-64", + "timestamp": 1676907413988, + "version": "1.5.3.230203" + }, + "pandas-stubs-1.5.3.230203-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "types-pytz >=2022.1.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bf78e6d3ef820458149ea94fa4797126", + "name": "pandas-stubs", + "sha256": "11d482b689b1cd2e25ed739fb4962b76698722d45a06ebfbbde8993684bbe33f", + "size": 94175, + "subdir": "linux-64", + "timestamp": 1676319831352, + "version": "1.5.3.230203" + }, + "pandas-stubs-1.5.3.230203-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "types-pytz >=2022.1.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "91a52e067d82b8c37e451f893fda4ad5", + "name": "pandas-stubs", + "sha256": "a5cbf463d5cb28c192c9fe398f1a962db462721a0ef605143cd8f1a7c6d01676", + "size": 94159, + "subdir": "linux-64", + "timestamp": 1676319874569, + "version": "1.5.3.230203" + }, + "pandasql-0.7.3-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "28ed291f47e11827cd6026b3e3ddc398", + "name": "pandasql", + "sha256": "3fe892397a1d8045d237783f1dda5fb5c92c7d7d248baf21745dfd7b299635e4", + "size": 33403, + "subdir": "linux-64", + "timestamp": 1537831835158, + "version": "0.7.3" + }, + "pandasql-0.7.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.10,<3.11.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "cb568810d0fccb286afaf436e21372fe", + "name": "pandasql", + "sha256": "d74efc7919fd86477a69449b5481bb1cf2f972f8d7d7d1a59d949d6a21c7ac7d", + "size": 33891, + "subdir": "linux-64", + "timestamp": 1640809871669, + "version": "0.7.3" + }, + "pandasql-0.7.3-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.11,<3.12.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "bb72e5de2760f33cc081e53e99d576a3", + "name": "pandasql", + "sha256": "991052a7bfa00a4fab048d471455055f4f199a3b6bd4b2b5983cd3b5e7db7ee4", + "size": 35937, + "subdir": "linux-64", + "timestamp": 1676907429920, + "version": "0.7.3" + }, + "pandasql-0.7.3-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.5,<3.6.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "a5b87fbed23a239a18cfcb7841360d72", + "name": "pandasql", + "sha256": "31b64853cb09c79314654e671b0ede533a1053ee8cb2eb353d5b875c7aeb6f65", + "size": 33699, + "subdir": "linux-64", + "timestamp": 1537831897349, + "version": "0.7.3" + }, + "pandasql-0.7.3-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "6b66e865b06cb4426a3a6343629eecf5", + "name": "pandasql", + "sha256": "2ae54e0cb9ec9cfffda7d3cc376d8581fdd5740f706e6cd4d27ee5d35ea7e737", + "size": 33599, + "subdir": "linux-64", + "timestamp": 1537831893000, + "version": "0.7.3" + }, + "pandasql-0.7.3-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "4aa8523c9f5af333f1f78ee1c23e611d", + "name": "pandasql", + "sha256": "25271145260d772b92fae0c2fc08f6883d90e2ccf41b4b0c4a2088167fc82c70", + "size": 326072, + "subdir": "linux-64", + "timestamp": 1632894686605, + "version": "0.7.3" + }, + "pandasql-0.7.3-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "43358d5b2fe99275b6cf865708d6efd5", + "name": "pandasql", + "sha256": "8d56e9fb06677a43e288c0ec3849ff8ff35b66e499a060dd6e8bdf5d4611d826", + "size": 33687, + "subdir": "linux-64", + "timestamp": 1537831818283, + "version": "0.7.3" + }, + "pandasql-0.7.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "cd85f9026c9e05b5158756b31427ef11", + "name": "pandasql", + "sha256": "ac238bc36d10dbf972a74cc4e2aa5127250695394bc715ee1841f2552df5eebd", + "size": 326374, + "subdir": "linux-64", + "timestamp": 1632893905416, + "version": "0.7.3" + }, + "pandasql-0.7.3-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.8,<3.9.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "70afb256b7cc9e6dc271e180ba15f2ea", + "name": "pandasql", + "sha256": "af21b08970820983f631faf403bf6170cdf53514216536d3e6a88d702b83b0e2", + "size": 33884, + "subdir": "linux-64", + "timestamp": 1574169746251, + "version": "0.7.3" + }, + "pandasql-0.7.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.8,<3.9.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "3827604b34ad4b7051b30716b5527cb5", + "name": "pandasql", + "sha256": "403de96f24f06fc2b4638ce6a461c765fddb3c2745c31a4d5f3783be27e351e3", + "size": 326235, + "subdir": "linux-64", + "timestamp": 1632894663260, + "version": "0.7.3" + }, + "pandasql-0.7.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "numpy", + "pandas", + "python >=3.9,<3.10.0a0", + "sqlalchemy" + ], + "license": "BSD", + "md5": "79f6880e7ed379d84e654733a60c8ca8", + "name": "pandasql", + "sha256": "13011e3b220e37309c083674f4fdf1ca215b0f261c5e1dafa6ddd32942759129", + "size": 326368, + "subdir": "linux-64", + "timestamp": 1632893903189, + "version": "0.7.3" + }, + "pandoc-1.19.2.1-hea2e7c5_1.conda": { + "build": "hea2e7c5_1", + "build_number": 1, + "depends": [ + "gmp", + "zlib" + ], + "license": "GPL-2.0", + "md5": "bdbf297e3a26dc8809699cb3c7642407", + "name": "pandoc", + "sha256": "2aa072389444e189f769bff33e604377aeae1b7cedbe619d8b0d8f67c3d19818", + "size": 13313181, + "subdir": "linux-64", + "timestamp": 1505690017009, + "version": "1.19.2.1" + }, + "pandoc-2.10-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "db655575f8cb6565608c8c20c51e7382", + "name": "pandoc", + "sha256": "2d31515402521ac6836c28043256ae4382b36211f9525ffa5e06aab0221456bd", + "size": 13028687, + "subdir": "linux-64", + "timestamp": 1594828065281, + "version": "2.10" + }, + "pandoc-2.10.1-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "843974d2e9f8cc3bef80af0c991e9045", + "name": "pandoc", + "sha256": "7ce793ad91c7b6f3a1e8653bd9981bb57e57193136a63f1aa9b7d72718187564", + "size": 13353343, + "subdir": "linux-64", + "timestamp": 1597465289006, + "version": "2.10.1" + }, + "pandoc-2.11-hb0f4dca_0.conda": { + "build": "hb0f4dca_0", + "build_number": 0, + "depends": [], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "bec1a1eba342745f23ac4f392444c5c7", + "name": "pandoc", + "sha256": "37a1a9ea8c911508463a3d03b3fd5ad6b591f440777e0ec5f9ef6b7604497448", + "size": 10107535, + "subdir": "linux-64", + "timestamp": 1602698657595, + "version": "2.11" + }, + "pandoc-2.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "b1de5a57d2bd761d1bf03bb89a12a933", + "name": "pandoc", + "sha256": "a8c0bfe515532f57f1b156157f2c72025dc9cb799e46a6370e99a083ab7b3c27", + "size": 9916539, + "subdir": "linux-64", + "timestamp": 1615916811730, + "version": "2.12" + }, + "pandoc-2.12-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "40d926bae84f4fb3dcde252821572579", + "name": "pandoc", + "sha256": "4d5b937557874449a706a2632b2787c1676d2e54fe048c2fc6156b106ea57f03", + "size": 10932454, + "subdir": "linux-64", + "timestamp": 1669357485464, + "version": "2.12" + }, + "pandoc-2.12-h06a4308_3.conda": { + "build": "h06a4308_3", + "build_number": 3, + "depends": [], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "9201d6eb0288b47003c2a86ca3659280", + "name": "pandoc", + "sha256": "67655d9891d060697ee4fc65c0b56ad23e8cd9d109a3bbe4f8127a2517d9b0a2", + "size": 10959035, + "subdir": "linux-64", + "timestamp": 1677512220201, + "version": "2.12" + }, + "pandoc-2.2.1-h629c226_0.conda": { + "build": "h629c226_0", + "build_number": 0, + "depends": [ + "gmp", + "zlib" + ], + "license": "GPL-2.0", + "md5": "6c7e60e96a7d2ff0ed25c2a579534d46", + "name": "pandoc", + "sha256": "192212920e6aed898c8494e5748868ae2edba5d12c3397089f64f83b03ee557c", + "size": 15033853, + "subdir": "linux-64", + "timestamp": 1529960076437, + "version": "2.2.1" + }, + "pandoc-2.2.3.2-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "gmp", + "zlib" + ], + "license": "GPL-2.0", + "md5": "ffcb692b36767b7d6989c9f3ac4d1974", + "name": "pandoc", + "sha256": "c5ade06b645e8d968e2819357224c2f525fd4b930279698ee115d3a996d38005", + "size": 14727375, + "subdir": "linux-64", + "timestamp": 1535414070085, + "version": "2.2.3.2" + }, + "pandoc-2.9.2.1-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "56e49c8efe2f955e18f29100eb8889bd", + "name": "pandoc", + "sha256": "3be147ac1e4a18433e55eb2c57e1460948c446bb569c9379993ecbe0141bae1c", + "size": 12888965, + "subdir": "linux-64", + "timestamp": 1593119933618, + "version": "2.9.2.1" + }, + "pandocfilters-1.4.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e320781dd14ac6580867cf3ce95696cb", + "name": "pandocfilters", + "sha256": "53d57c08c3559564dfe93f5e2d124b00a289d6c4ca508a72e043f87a107b7717", + "size": 13012, + "subdir": "linux-64", + "timestamp": 1530734410710, + "version": "1.4.2" + }, + "pandocfilters-1.4.2-py27h428e1e5_1.conda": { + "build": "py27h428e1e5_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "03fafce86ff0eaa70d7b7b29c5a48370", + "name": "pandocfilters", + "sha256": "7029af80d43946e12576ec73da765c9b4a104843e8f36691c0e4c7c20075481e", + "size": 12706, + "subdir": "linux-64", + "timestamp": 1505957316103, + "version": "1.4.2" + }, + "pandocfilters-1.4.2-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e3a26c587faf38c5b553a8b6ace1d75a", + "name": "pandocfilters", + "sha256": "204bcc6808f2c4aa2c8ec0b31ce466f9ed99b7927fd379d726838f31286b4dc7", + "size": 13211, + "subdir": "linux-64", + "timestamp": 1534350928442, + "version": "1.4.2" + }, + "pandocfilters-1.4.2-py35h1565a15_1.conda": { + "build": "py35h1565a15_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e8aa08fe36cad441375ba6ee54b01054", + "name": "pandocfilters", + "sha256": "e8742818570ad3dbb4d25309266cd9b88db9b4ebfaf2515cb17df9609fc3e507", + "size": 13026, + "subdir": "linux-64", + "timestamp": 1505957330485, + "version": "1.4.2" + }, + "pandocfilters-1.4.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f513ecde1dda8df2a1c97b680874c789", + "name": "pandocfilters", + "sha256": "a4a637bea88642bb874882ec48d0c11d64090484a097d1690340bc6042d4c720", + "size": 13163, + "subdir": "linux-64", + "timestamp": 1530734390903, + "version": "1.4.2" + }, + "pandocfilters-1.4.2-py36ha6701b7_1.conda": { + "build": "py36ha6701b7_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e44967dc14c4dc0c994a23834818f94b", + "name": "pandocfilters", + "sha256": "ac602f843ecff74fd7bd1c27c8dc9eca321c45ead7c76a49def42c530903e65e", + "size": 12783, + "subdir": "linux-64", + "timestamp": 1505957345027, + "version": "1.4.2" + }, + "pandocfilters-1.4.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0ca585bcdb2d0f7bed41b951a8654581", + "name": "pandocfilters", + "sha256": "a3450238dcab46bb40cda43bb10d233cd2b2e4a1a9e10dc446c556665ff5d947", + "size": 13086, + "subdir": "linux-64", + "timestamp": 1530734431114, + "version": "1.4.2" + }, + "pandocfilters-1.4.2-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3191caf7d985f9f14b751eb2fef0ba54", + "name": "pandocfilters", + "sha256": "e00a72540b8a9838e28b3f5419ff7ada70ef9bd89a7a5a0ce315e633c0d21687", + "size": 13559, + "subdir": "linux-64", + "timestamp": 1573489436104, + "version": "1.4.2" + }, + "pandocfilters-1.4.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "531d32b75b8e4267de438962b8c97dba", + "name": "pandocfilters", + "sha256": "661e7d1dc8452696bc1447342f9929c16a42f7013525ca8a6476b8aa37ab915a", + "size": 13969, + "subdir": "linux-64", + "timestamp": 1641916309204, + "version": "1.4.3" + }, + "pandocfilters-1.4.3-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "61930eb554f46fb242f17b836cc75c2e", + "name": "pandocfilters", + "sha256": "dc1615cf6e4282d87eb7e5061f654eab03a096c6dbf6d92cc77c64ffe94c5b07", + "size": 16279, + "subdir": "linux-64", + "timestamp": 1676823740667, + "version": "1.4.3" + }, + "pandocfilters-1.4.3-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f26f22278d31aba4897288e36dc0f0c", + "name": "pandocfilters", + "sha256": "fa85bd753027d07d1e3296ca9ac912b8191937724783d93d1a658292bbf070ce", + "size": 13955, + "subdir": "linux-64", + "timestamp": 1605120971185, + "version": "1.4.3" + }, + "pandocfilters-1.4.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "99a6508435bac0a83d3dbdd9c0a85d60", + "name": "pandocfilters", + "sha256": "451b266e137c84e87e1526a3b1d6ac7055952702bacfb0a15fb9752aed4aa963", + "size": 14033, + "subdir": "linux-64", + "timestamp": 1605120477845, + "version": "1.4.3" + }, + "pandocfilters-1.4.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a1e8be1705ee4281d968f421eb7fafe2", + "name": "pandocfilters", + "sha256": "642240340ab3dae6ed4308eb5aa4d686a6a6effc8a4b66be410a3a77c3955ded", + "size": 14132, + "subdir": "linux-64", + "timestamp": 1605120495561, + "version": "1.4.3" + }, + "pandocfilters-1.4.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6f5e39f4a7cb77f2c766ab11136d6d7a", + "name": "pandocfilters", + "sha256": "efdb5d6d85d453fe8dcd6a84fbb088f16a62538e80d6c17a9beaf456e57e0862", + "size": 14000, + "subdir": "linux-64", + "timestamp": 1605120938890, + "version": "1.4.3" + }, + "panel-0.13.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4", + "requests", + "tqdm >=4.48.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a591babbf26809645dbc5d59937e319b", + "name": "panel", + "sha256": "9b74174964cf9bb343d95ae26d44f2676c2cca500e6b4c8f3e81b3d3cb9306f6", + "size": 11476839, + "subdir": "linux-64", + "timestamp": 1650637296449, + "version": "0.13.0" + }, + "panel-0.13.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4", + "requests", + "tqdm >=4.48.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "45bbd3f926280a0bed423bc9fa687069", + "name": "panel", + "sha256": "be3ba2aeb7587a5b21f878c3c4f953fed11c87ed102cdc87ebe1c7d29cfef882", + "size": 11462901, + "subdir": "linux-64", + "timestamp": 1650637773946, + "version": "0.13.0" + }, + "panel-0.13.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4", + "requests", + "tqdm >=4.48.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1b4651fb56928d29763046add568f4e7", + "name": "panel", + "sha256": "a953c2200522b5c19243a80dd9ed4d85ce4dbf43588362a15a85df4285e82f0a", + "size": 11476125, + "subdir": "linux-64", + "timestamp": 1650637620405, + "version": "0.13.0" + }, + "panel-0.13.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4", + "requests", + "tqdm >=4.48.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cc50e47ef0beab37af5dd70378f312b9", + "name": "panel", + "sha256": "2fc6c14af5613d2dc4516a83a0a868cc66a8ab85928b66d47797e5fc0e1a34b0", + "size": 11473660, + "subdir": "linux-64", + "timestamp": 1650637471138, + "version": "0.13.0" + }, + "panel-0.13.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4", + "requests", + "tqdm >=4.48.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d5f7923a838438f39acffdd5e790863", + "name": "panel", + "sha256": "314b34ea98138fc194af153f6b101fef9f13a9a7bd76526afa94fb51ed934896", + "size": 11513843, + "subdir": "linux-64", + "timestamp": 1658134048959, + "version": "0.13.1" + }, + "panel-0.13.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4", + "requests", + "tqdm >=4.48.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "55f41be8031e1833b037a40c6063cf19", + "name": "panel", + "sha256": "0ed42b16da25fb7c55f6e0e78bab8df7984e90917c429682b8f45d8aa8191652", + "size": 11506149, + "subdir": "linux-64", + "timestamp": 1658134278280, + "version": "0.13.1" + }, + "panel-0.13.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4", + "requests", + "tqdm >=4.48.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5176b935a3cf9450b21021a9a9e0c7ed", + "name": "panel", + "sha256": "d47fd0680ed8e95636126f31822473a92f42e3a4fffb4115a994e0a3dc6f38aa", + "size": 11502830, + "subdir": "linux-64", + "timestamp": 1658134158814, + "version": "0.13.1" + }, + "panel-0.13.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4", + "requests", + "tqdm >=4.48.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "99fa601733eb293ab8b7c1fb82d2c024", + "name": "panel", + "sha256": "c6dbf9a72409f32f2af510633e597a4f5f0527f6c383aad0b452a33d0e6483b5", + "size": 11503775, + "subdir": "linux-64", + "timestamp": 1658133926009, + "version": "0.13.1" + }, + "panel-0.14.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "af7bf92d2640c3d51defdc3e5def1d5d", + "name": "panel", + "sha256": "c060b0b56ef1617fee5a6c2fe781b7cc89279e86513acea76e87514ad345c70a", + "size": 13337907, + "subdir": "linux-64", + "timestamp": 1668084708518, + "version": "0.14.1" + }, + "panel-0.14.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "81a03bb3997896dec330c0f1f050d497", + "name": "panel", + "sha256": "4f37a4958caee7b9e7a130de808e441299c5a4a98ebb215a5abf0d6f8382355b", + "size": 13332513, + "subdir": "linux-64", + "timestamp": 1668084942299, + "version": "0.14.1" + }, + "panel-0.14.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dcee31e415f250f74eb45013c7c935da", + "name": "panel", + "sha256": "7002e1ad4041342664e58fecdcacd14cf52f8d2a40d555bb426b4f76f62a333c", + "size": 13352168, + "subdir": "linux-64", + "timestamp": 1668085057464, + "version": "0.14.1" + }, + "panel-0.14.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c681cf0cab82d447700e7c0dce208220", + "name": "panel", + "sha256": "ef0acc8c0b5e91e6baec82e28a375e9d2b1b4dcd8b672d2d87ee623f1ff83f31", + "size": 13348968, + "subdir": "linux-64", + "timestamp": 1668084824094, + "version": "0.14.1" + }, + "panel-0.14.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7815449426798a4ba32aef5ca23c2a47", + "name": "panel", + "sha256": "dd02f405b2d77fc14551bb55f683a2ade7611ff5d50d6d208538da036f2df417", + "size": 13139889, + "subdir": "linux-64", + "timestamp": 1674166520094, + "version": "0.14.2" + }, + "panel-0.14.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.11,<3.12.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0811c0d24e70f783d38046da9ff39a91", + "name": "panel", + "sha256": "c5f1e902042a6dd7a24b269d7f9fe38355797a035107874bd693520ec0032bd7", + "size": 12326590, + "subdir": "linux-64", + "timestamp": 1676841576119, + "version": "0.14.2" + }, + "panel-0.14.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7df24572c31d94a40afee078ce52b018", + "name": "panel", + "sha256": "68cae25b09585ff7541bdf2d9d0c7be82ac37f66d0f97662702373eadc14ca39", + "size": 13130275, + "subdir": "linux-64", + "timestamp": 1674166635856, + "version": "0.14.2" + }, + "panel-0.14.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0c3d57f93f635404e5c57bbd4d804f79", + "name": "panel", + "sha256": "2e6c066604c2a7af2ae482d94f3aff8203fee98e7a44d5a5925153a83aebb8ea", + "size": 13126654, + "subdir": "linux-64", + "timestamp": 1674166747950, + "version": "0.14.2" + }, + "panel-0.14.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b3fad17c67ffb8b1903b6e4a8151157f", + "name": "panel", + "sha256": "05cb886db609b25d321228a5fb04c4b19f8c6b0a6224a21909903668ddd9c0c2", + "size": 13132897, + "subdir": "linux-64", + "timestamp": 1674166403057, + "version": "0.14.2" + }, + "panel-0.14.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "holoviews >1.14.1" + ], + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.10,<3.11.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85bda757f29f916bd67971257129fe8a", + "name": "panel", + "sha256": "7ed6f88f2124be13c37adcd1aa8da73ce3d1723548f783f611594b26b3526aec", + "size": 13035316, + "subdir": "linux-64", + "timestamp": 1676380048816, + "version": "0.14.3" + }, + "panel-0.14.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "holoviews >1.14.1" + ], + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.11,<3.12.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3fe27119f1a6d8e71d51994e8d9ad69f", + "name": "panel", + "sha256": "db0dede83858997451509ded915d470d18a12852e4efaa8ad669627e582008ec", + "size": 12384110, + "subdir": "linux-64", + "timestamp": 1679337269721, + "version": "0.14.3" + }, + "panel-0.14.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "holoviews >1.14.1" + ], + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.7,<3.8.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "538a1676f25662abd398b565c5b66463", + "name": "panel", + "sha256": "0822ab190f2a2d50bdf8d96c42196e679dbae60574b63f1e1d1d3820b2729bd3", + "size": 13009140, + "subdir": "linux-64", + "timestamp": 1676379926530, + "version": "0.14.3" + }, + "panel-0.14.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "holoviews >1.14.1" + ], + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.8,<3.9.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0eeea93ff597e013938ae5a80b0df02d", + "name": "panel", + "sha256": "9ba79490c38c4672421de31783b378d879883a13a62386ed477880123c492c1d", + "size": 13015175, + "subdir": "linux-64", + "timestamp": 1676379688150, + "version": "0.14.3" + }, + "panel-0.14.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "holoviews >1.14.1" + ], + "depends": [ + "bleach", + "bokeh >=2.4.0,<2.5.0", + "markdown", + "param >=1.12.0", + "pyct >=0.4.4", + "python >=3.9,<3.10.0a0", + "pyviz_comms >=0.7.4", + "requests", + "setuptools >=42", + "tqdm >=4.48.0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5ef07f2dd82eef3b32f044b726a6a592", + "name": "panel", + "sha256": "583e19fcebb3bf464f4be668ff101dbaf7ccf84a4cca5bb972d96b6e62ca5d9e", + "size": 13007110, + "subdir": "linux-64", + "timestamp": 1676379803902, + "version": "0.14.3" + }, + "pango-1.40.11-h8191d47_0.conda": { + "build": "h8191d47_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.4,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "e664833ad1271dc31aea2a059af4922e", + "name": "pango", + "sha256": "8d096865a8d3d1166a52f175d0815374b0b0fe40c11fd69f84d23b2092d966a8", + "size": 471426, + "subdir": "linux-64", + "timestamp": 1507908473485, + "version": "1.40.11" + }, + "pango-1.40.11-hedb6d6b_0.conda": { + "build": "hedb6d6b_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.4,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.5.0,<2.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "8447b9f9945309fd7f3744a4abd2826e", + "name": "pango", + "sha256": "7a5b482c9d72770c01a61069c9e1e891154e5b2336438c00a24d702ca05cbb8e", + "size": 470614, + "subdir": "linux-64", + "timestamp": 1505852505434, + "version": "1.40.11" + }, + "pango-1.41.0-hd475d92_0.conda": { + "build": "hd475d92_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.4,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "harfbuzz >=1.7.4,<2.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "4414382e02a1fb4b33fae534e2ddf695", + "name": "pango", + "sha256": "cbe921d83e0c82caa9faa4284139f3c9f9e42ce5297f52c5194d7e023a256fe2", + "size": 475369, + "subdir": "linux-64", + "timestamp": 1516745276300, + "version": "1.41.0" + }, + "pango-1.42.0-h377f3fa_0.conda": { + "build": "h377f3fa_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.12.6,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "fribidi >=1.0.2,<2.0a0", + "glib >=2.53.6,<3.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "7f013353fb8eb7325298c0dbb0508452", + "name": "pango", + "sha256": "7afad91d3d1c15ee1aa25380e9da3729460041b3ac1eb1e0bc00d359acf7a040", + "size": 468878, + "subdir": "linux-64", + "timestamp": 1522873317442, + "version": "1.42.0" + }, + "pango-1.42.0-h8589676_1.conda": { + "build": "h8589676_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.2,<2.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.11,<2.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "pcre >=8.42,<9.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "e1fb73e3a625f791973fd51645534127", + "name": "pango", + "sha256": "0f5454a3400ff4c30ef0f168c40dd1d56efeab2b7c14a07cd05d5b1169b468de", + "size": 467641, + "subdir": "linux-64", + "timestamp": 1527929593648, + "version": "1.42.0" + }, + "pango-1.42.1-h8589676_0.conda": { + "build": "h8589676_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.2,<2.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.11,<2.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "pcre >=8.42,<9.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "7dd0d8df1b989b389463c983c043b2ca", + "name": "pango", + "sha256": "9b27cd6dbc577a06819132619826925871a2c5eb9cec5d8cc22a9428d4f3e262", + "size": 467671, + "subdir": "linux-64", + "timestamp": 1528214360282, + "version": "1.42.1" + }, + "pango-1.42.2-h8589676_0.conda": { + "build": "h8589676_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.4,<2.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.11,<2.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "pcre >=8.42,<9.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "e20e504797aacea6803ea97f2e0e6e55", + "name": "pango", + "sha256": "2c80fdc3d4576da959b3b518e352cd553708e14ccd834546bf5fd1d5b25929ce", + "size": 474380, + "subdir": "linux-64", + "timestamp": 1532888443830, + "version": "1.42.2" + }, + "pango-1.42.3-h8589676_0.conda": { + "build": "h8589676_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.4,<2.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.11,<2.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "pcre >=8.42,<9.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "e9a13ee32811fae364e6e2cfba8b29c7", + "name": "pango", + "sha256": "ffa8597b6868b7a2a5e49977b72f8a2225f5a94a16ae853602b5decf7f01ab97", + "size": 470007, + "subdir": "linux-64", + "timestamp": 1534390752714, + "version": "1.42.3" + }, + "pango-1.42.4-h049681c_0.conda": { + "build": "h049681c_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.4,<2.0a0", + "glib >=2.56.1,<3.0a0", + "graphite2 >=1.3.12,<2.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.34,<1.7.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "pcre >=8.42,<9.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "bfd8859e7ea05185e93cd73f9a1106b9", + "name": "pango", + "sha256": "876d2134df029bcf73665e8ae786da9c5488a973d9e6896b0f11544ae58d1977", + "size": 475166, + "subdir": "linux-64", + "timestamp": 1535469857531, + "version": "1.42.4" + }, + "pango-1.42.4-h145f868_1.conda": { + "build": "h145f868_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.5,<2.0a0", + "glib >=2.63.1,<3.0a0", + "graphite2 >=1.3.14,<2.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "icu >=58.2,<59.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.10,<2.10.0a0", + "pcre >=8.44,<9.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "2eea91691ecb50a5d1a19a916f74065e", + "name": "pango", + "sha256": "34cad6f1831b0056f5b5135eeb3a9539dfdb186374fb9139adc9f4d83d146f2a", + "size": 477475, + "subdir": "linux-64", + "timestamp": 1593125051973, + "version": "1.42.4" + }, + "pango-1.42.4-h5aa6e80_1.conda": { + "build": "h5aa6e80_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.5,<2.0a0", + "glib >=2.63.1,<3.0a0", + "graphite2 >=1.3.13,<2.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libuuid >=1.0.3,<2.0a0", + "libxml2 >=2.9.9,<2.10.0a0", + "pcre >=8.43,<9.0a0", + "pixman >=0.34.0,<1.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-2.1", + "md5": "66d5d01f806d078c0a72db70697108ae", + "name": "pango", + "sha256": "3a233f325877d0d1b3b9dc965bccdd8053ea869514da8d6c4ef05bc4b9bc3bc5", + "size": 478631, + "subdir": "linux-64", + "timestamp": 1589913721138, + "version": "1.42.4" + }, + "pango-1.45.3-hd140c19_0.conda": { + "build": "hd140c19_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "fribidi >=1.0.9,<2.0a0", + "glib >=2.65.0,<3.0a0", + "harfbuzz >=2.4.0,<3.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "md5": "b259d47f79b9b256d1c32acdec2e979c", + "name": "pango", + "sha256": "94ee90ae59c502607d9ee6b23fbe5bbdff1a310e791fa0dfc090d5cde44a7fdf", + "size": 369591, + "subdir": "linux-64", + "timestamp": 1593480756047, + "version": "1.45.3" + }, + "pango-1.50.7-h05da053_0.conda": { + "build": "h05da053_0", + "build_number": 0, + "depends": [ + "cairo >=1.12.10", + "cairo >=1.16.0,<2.0a0", + "fontconfig >=2.13.0", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "fribidi >=1.0.10,<2.0a0", + "fribidi >=1.0.6", + "glib >=2.62,<3.0a0", + "glib >=2.69.1,<3.0a0", + "harfbuzz >=2.6.0", + "harfbuzz >=4.3.0,<5.0a0", + "libgcc-ng >=11.2.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "8edfede58ce63596d319e4946fa762e4", + "name": "pango", + "sha256": "7f9575f8d78ff13724a789bf2e3e48f8330d2667b0184aaa6c0eddc7bbed2d87", + "size": 437565, + "subdir": "linux-64", + "timestamp": 1656532965838, + "version": "1.50.7" + }, + "param-1.12.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7478526c3a9ce26e0526f39b1cded510", + "name": "param", + "sha256": "68ce638584689e2c414ba2e4646065dca0c7672b2e26c9c819b3b7e48fe830e9", + "size": 149031, + "subdir": "linux-64", + "timestamp": 1668767082637, + "version": "1.12.2" + }, + "param-1.12.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c3d8d4d93da24577d1fc452bf49c2871", + "name": "param", + "sha256": "aa281b8647560884a1469f7043b35cff5301f15da3f9d4a4fc138e94d9010843", + "size": 147299, + "subdir": "linux-64", + "timestamp": 1668767007047, + "version": "1.12.2" + }, + "param-1.12.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4549e7f4fec028ca5e36789f689fde51", + "name": "param", + "sha256": "3d4cb4434334441f6460210e10560720c77a21bd5349827ce1b98c9297a187fb", + "size": 148379, + "subdir": "linux-64", + "timestamp": 1668767057479, + "version": "1.12.2" + }, + "param-1.12.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4dd17eefbd8b1e80a1a170d0ca341412", + "name": "param", + "sha256": "158c1e28a934e8373e87ec7e866a0b6432382864c0511e4355fb54d0736b03c9", + "size": 147855, + "subdir": "linux-64", + "timestamp": 1668767032285, + "version": "1.12.2" + }, + "param-1.12.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7b87b17d1df17b3924eb6a461ca854e0", + "name": "param", + "sha256": "163515e7ee38f41aa0489aae849e874a04c9facc82024a75829d200e15173c78", + "size": 152692, + "subdir": "linux-64", + "timestamp": 1671697451287, + "version": "1.12.3" + }, + "param-1.12.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b538d4ac99c2334dbc6f1b5fca26fe0d", + "name": "param", + "sha256": "834d1d93b31c1bc7de674555de0b9dfee5ef23b710c0261173ed4be3ae93d4a0", + "size": 187386, + "subdir": "linux-64", + "timestamp": 1676828710669, + "version": "1.12.3" + }, + "param-1.12.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "797d8a1f6626b806ddcbfa80a51c690b", + "name": "param", + "sha256": "d8a8e69e4d1bc2804435fe8c0111d811999c7fe10bdc2a8cbb31635c990b243e", + "size": 150890, + "subdir": "linux-64", + "timestamp": 1671697527583, + "version": "1.12.3" + }, + "param-1.12.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "26212fa89bbd40d3113d9c6109d62367", + "name": "param", + "sha256": "6d465baa7b5bbd65eb528034488571f339e2bb21e1ced4249487dc7d9747d02e", + "size": 151576, + "subdir": "linux-64", + "timestamp": 1671697502039, + "version": "1.12.3" + }, + "param-1.12.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f3a4f19d066a5d7deaad4d0cb7a8a91f", + "name": "param", + "sha256": "674ad1074f328ecce12f56a21dc72e70bc902d890e91efdad3044f57ee880c62", + "size": 151092, + "subdir": "linux-64", + "timestamp": 1671697476694, + "version": "1.12.3" + }, + "param-1.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "32502a07ce37395a34422229082ca01b", + "name": "param", + "sha256": "b13e0887c49d0986e39f74caffdfcdfbfe80e4f59195f8584b5b25aa10bd4f37", + "size": 99438, + "subdir": "linux-64", + "timestamp": 1522952104793, + "version": "1.6.0" + }, + "param-1.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b6af3f4f56daa09fbb3e6e7f8d03e765", + "name": "param", + "sha256": "1542c7e54fe4d39883c0b10e18fa6a86eed9277ead924ae8cdb4fe40ea25f774", + "size": 99575, + "subdir": "linux-64", + "timestamp": 1522952125797, + "version": "1.6.0" + }, + "param-1.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a203c4c8acf1e951427bd48a95839007", + "name": "param", + "sha256": "35a83bd91e0d234979210be6201923649b563229272cdfb46491f1070708913b", + "size": 98998, + "subdir": "linux-64", + "timestamp": 1522952125542, + "version": "1.6.0" + }, + "param-1.6.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "695963f09c0cf8cc4fd8a4f31455a7f2", + "name": "param", + "sha256": "7f7072cd7125e362c76a6555021eb0d5e21c4e4cfc6c87d03f2340614fd51e90", + "size": 88038, + "subdir": "linux-64", + "timestamp": 1524842416193, + "version": "1.6.1" + }, + "param-1.6.1-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1cfb9a01a6a0296bb0dc7936f82a0514", + "name": "param", + "sha256": "d04837bc46a368da9ef7e20c17a94d9c369f34d1eddfde18f6fba66a4b3641e9", + "size": 88307, + "subdir": "linux-64", + "timestamp": 1530872794637, + "version": "1.6.1" + }, + "param-1.6.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "72f2f783ff0c0442d1de95367a049b41", + "name": "param", + "sha256": "c9719c4be3a4aab80a1e74cbe087ac8e5814d79fc1114d101457fdb3ccfedd95", + "size": 91573, + "subdir": "linux-64", + "timestamp": 1524842431738, + "version": "1.6.1" + }, + "param-1.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f39646512c9b9ba38e6a838436485b3d", + "name": "param", + "sha256": "0d9443c7aa6416208356bb4f833ad9bb1dc5598f6254f70214829db64aa38481", + "size": 89328, + "subdir": "linux-64", + "timestamp": 1524842379659, + "version": "1.6.1" + }, + "param-1.6.1-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d50e3433f3271b3c0e47fa5215ba53f4", + "name": "param", + "sha256": "48a97003307e71861eaa0b9b5363839247ccc5faf04260853f2f778e2d624d66", + "size": 91188, + "subdir": "linux-64", + "timestamp": 1530872845835, + "version": "1.6.1" + }, + "param-1.6.1-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "487c465bf28992b078c62c7a69aaa9a1", + "name": "param", + "sha256": "eb871b7f6a0ef95423f5c2a1732a9a986f9deeb94deefcb3319406ae34974822", + "size": 91152, + "subdir": "linux-64", + "timestamp": 1530872819934, + "version": "1.6.1" + }, + "param-1.7.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0635982c6c6bd2b16110baa7ace2d900", + "name": "param", + "sha256": "7f3d70fa2c45f3eaf21d8d3ab1de5ada12ac448947b6a57f67e8d79540a4f85b", + "size": 92605, + "subdir": "linux-64", + "timestamp": 1532441649453, + "version": "1.7.0" + }, + "param-1.7.0-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "462c47c7ded97d57d1ed4eac6dcd9ed1", + "name": "param", + "sha256": "8a031d1a7fde2e7dab8db7c8bc44daa05c7f31d2c710f3de674cc111210f556d", + "size": 94781, + "subdir": "linux-64", + "timestamp": 1532441993533, + "version": "1.7.0" + }, + "param-1.7.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "071ae75c8ebab1c004cefe77624b729b", + "name": "param", + "sha256": "84d5146514222866d550590f91a4c840bb58694164f134c60ad1df7b43685ded", + "size": 92603, + "subdir": "linux-64", + "timestamp": 1532441908614, + "version": "1.7.0" + }, + "param-1.7.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a280b2e64a20bd79ff0eeb8ef1fde241", + "name": "param", + "sha256": "797bfd8895910e487aadf8d1d97ff4a8cf757e8b749948fb97412bed91a2fe3a", + "size": 92558, + "subdir": "linux-64", + "timestamp": 1532442041636, + "version": "1.7.0" + }, + "param-1.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "75ee7dc2be029ffcd58f1b98f0741641", + "name": "param", + "sha256": "0237e2961b98c50fb8f398a12184ca754698cdd27d6d6ef32288292288e6ce85", + "size": 102446, + "subdir": "linux-64", + "timestamp": 1539643622888, + "version": "1.8.1" + }, + "param-1.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c89f2b0775a461c4f02f39b859bad436", + "name": "param", + "sha256": "cda4d550540318152c2f4c4ae602de030e6c9103ca79cdc2ec39d0041c185f47", + "size": 105469, + "subdir": "linux-64", + "timestamp": 1539643635858, + "version": "1.8.1" + }, + "param-1.8.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "89ced4ced76a9c76d38bcd1dc5c89625", + "name": "param", + "sha256": "8bb2cd845270c89d55ff3017d82761cc2466b02071e0d7fe5c3c4c5910779d0c", + "size": 105547, + "subdir": "linux-64", + "timestamp": 1539643627485, + "version": "1.8.1" + }, + "parameterized-0.6.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c361f109e57977a5aed44beb3b867093", + "name": "parameterized", + "sha256": "59af335015b9ea0ad1f9557232a5b9b0ad0c225316f47f0ac56a136f625763b7", + "size": 22794, + "subdir": "linux-64", + "timestamp": 1515150775409, + "version": "0.6.1" + }, + "parameterized-0.6.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "89d1771257ec1e09a735877d7c639097", + "name": "parameterized", + "sha256": "144391cb99d747dc5c758ffd897f6f48d178249b37363dcc7b40888156f0304e", + "size": 22945, + "subdir": "linux-64", + "timestamp": 1515150790432, + "version": "0.6.1" + }, + "parameterized-0.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "dc4cffd2e040a1c52dc84aa84aa71450", + "name": "parameterized", + "sha256": "e50bdb5239f944a81774920e12cfaa73b5ea212bc985ed9a25ba67376c563a73", + "size": 23075, + "subdir": "linux-64", + "timestamp": 1515150790049, + "version": "0.6.1" + }, + "parameterized-0.6.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5af7aac67a5e49bebe823f20ca3b0935", + "name": "parameterized", + "sha256": "044aa67cd12ac1cdc2adb8fe87c39d12adf70d0a21b828ddda6e57b7385f2876", + "size": 22717, + "subdir": "linux-64", + "timestamp": 1530904768202, + "version": "0.6.1" + }, + "parameterized-0.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e4d761275e551d5437ac4115bfd58dde", + "name": "parameterized", + "sha256": "fff4125bf445a845a60d687f01d8f0bbc457096b65afcabd354521ca0f08f2ea", + "size": 30195, + "subdir": "linux-64", + "timestamp": 1552440030279, + "version": "0.7.0" + }, + "parameterized-0.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "513a259903bdc49a1a3ce05c1845d46a", + "name": "parameterized", + "sha256": "f6d70687ba9f45a43a46d2dfff45c14a81c544e8877ad702bee422ce11fa1c52", + "size": 30804, + "subdir": "linux-64", + "timestamp": 1552440047346, + "version": "0.7.0" + }, + "parameterized-0.7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "2ce1129137235c70a2951057ae7134dd", + "name": "parameterized", + "sha256": "9783f55dfecadbdc8e9f6d4562d844d3e4bb0e9f15be3a331e5b5ae072ca48d7", + "size": 30569, + "subdir": "linux-64", + "timestamp": 1552439959819, + "version": "0.7.0" + }, + "parameterized-0.7.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "49480e78b43bfe3c6c66e782a8950df7", + "name": "parameterized", + "sha256": "03da2414440ab099fee59d98b7897b12dfa8db8c32d8021b52f4392032373ff2", + "size": 30284, + "subdir": "linux-64", + "timestamp": 1573489454709, + "version": "0.7.0" + }, + "paramiko-1.18.4-py27hdc62b2d_0.conda": { + "build": "py27hdc62b2d_0", + "build_number": 0, + "depends": [ + "ecdsa >=0.11,<2.0", + "pycrypto >=2.1,!=2.4,<3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "d2230d91583e4b9575b5a83f77807f15", + "name": "paramiko", + "sha256": "cfa24d3fd4a69f0a25ba8c88805f930b230d530f00ff159a9c0d9384e3b41d4c", + "size": 222071, + "subdir": "linux-64", + "timestamp": 1511040514375, + "version": "1.18.4" + }, + "paramiko-1.18.4-py35h49e6b62_0.conda": { + "build": "py35h49e6b62_0", + "build_number": 0, + "depends": [ + "ecdsa >=0.11,<2.0", + "pycrypto >=2.1,!=2.4,<3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "e77d77dc6f5df1862d45fdb2b8edbbda", + "name": "paramiko", + "sha256": "417803cce921827f830bbe3c874c51b8103049125e0e5dc471c38e62b05117b5", + "size": 225371, + "subdir": "linux-64", + "timestamp": 1511040521925, + "version": "1.18.4" + }, + "paramiko-1.18.4-py36h0d01e40_0.conda": { + "build": "py36h0d01e40_0", + "build_number": 0, + "depends": [ + "ecdsa >=0.11,<2.0", + "pycrypto >=2.1,!=2.4,<3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "09e2e5fc03759e98a996ca50c510021d", + "name": "paramiko", + "sha256": "86c5742b4d05f32218e2c9ab24d8405895a2478c811848fbc8161420e65e2c39", + "size": 226373, + "subdir": "linux-64", + "timestamp": 1511040524071, + "version": "1.18.4" + }, + "paramiko-2.4.0-py27hc00b698_0.conda": { + "build": "py27hc00b698_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "6072e23c0b8b99cef08b3b5b47ad67a1", + "name": "paramiko", + "sha256": "dcd4e2838bd332fb7d4729b11ac68110c4e5996b10091367f865056274788676", + "size": 239190, + "subdir": "linux-64", + "timestamp": 1511038405357, + "version": "2.4.0" + }, + "paramiko-2.4.0-py35h25c86cb_0.conda": { + "build": "py35h25c86cb_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "1e421d4b56a148a02f38363ee5b6bda3", + "name": "paramiko", + "sha256": "7ce98ba4510519665a525055d29f18951ecb91c187640b89660e41d1a3f968ae", + "size": 242909, + "subdir": "linux-64", + "timestamp": 1511038402836, + "version": "2.4.0" + }, + "paramiko-2.4.0-py36hd285e23_0.conda": { + "build": "py36hd285e23_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "525aefcff6fc7855c2c31c75315f98c5", + "name": "paramiko", + "sha256": "1ad1ea8751bfb80ed16a8948c3a7034524ab5284d8a263911c0ba63afbe82845", + "size": 236851, + "subdir": "linux-64", + "timestamp": 1511038408968, + "version": "2.4.0" + }, + "paramiko-2.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "4edbfe90ad0ce057affaaa2ae1e90208", + "name": "paramiko", + "sha256": "7e331f0b6ee0f1f330d9cc2b70696330b1778e609b9e41b74beb1cce4cb8b677", + "size": 241090, + "subdir": "linux-64", + "timestamp": 1521614258685, + "version": "2.4.1" + }, + "paramiko-2.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "f9b4b73d5bec708cc4237904e895a8d6", + "name": "paramiko", + "sha256": "f9e3d8a4de86ef94e249601c26a1f21eb7ece9f692a3a19e359627939d3c4f86", + "size": 244750, + "subdir": "linux-64", + "timestamp": 1521614268202, + "version": "2.4.1" + }, + "paramiko-2.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "bbfde1d48ca24159ce53a623d6585d52", + "name": "paramiko", + "sha256": "a0199e6a2cb17feb077ab8fd0017cde961724f571b60ebc8f9078e62828f6c5e", + "size": 242418, + "subdir": "linux-64", + "timestamp": 1521614225438, + "version": "2.4.1" + }, + "paramiko-2.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "f17dc48d3f98fe40b1913f7b82f7ccbf", + "name": "paramiko", + "sha256": "7796b109299ba8b884f657456002db5a9933550ff19874a122339af762ef8425", + "size": 242591, + "subdir": "linux-64", + "timestamp": 1530876169938, + "version": "2.4.1" + }, + "paramiko-2.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "feaf518882dc3453a480df1097ed2088", + "name": "paramiko", + "sha256": "81c7450a725dd7ed3cef5ab04ebe95c77befd1986465c0ebdf5371c744557866", + "size": 240541, + "subdir": "linux-64", + "timestamp": 1539637529220, + "version": "2.4.2" + }, + "paramiko-2.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "b1cd60aa70ad9d51451e2b9b9bcd0322", + "name": "paramiko", + "sha256": "27c917a8809cef89e3c85a185cffefcdb7b3d02fcd276021f28858bf8c47b3a9", + "size": 241862, + "subdir": "linux-64", + "timestamp": 1539637548905, + "version": "2.4.2" + }, + "paramiko-2.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=1.5", + "pyasn1 >=0.1.7", + "pynacl >=1.0.1", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "70d75deb42bb857175c01ac0300d06b6", + "name": "paramiko", + "sha256": "35e579a48751c188a31a72615e6687bce785e0cbfa77a1d93f563dfaa2694545", + "size": 238306, + "subdir": "linux-64", + "timestamp": 1539637550485, + "version": "2.4.2" + }, + "paramiko-2.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=2.5", + "pynacl >=1.0.1", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "0c74d1f3c0f92b642ef7e12a4387469f", + "name": "paramiko", + "sha256": "4c357731e74ce1d70027ff8c353f5ba647cbd4edd6f81c66ad1a279ebb6cd728", + "size": 251287, + "subdir": "linux-64", + "timestamp": 1568312009074, + "version": "2.6.0" + }, + "paramiko-2.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=2.5", + "pynacl >=1.0.1", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "8ef6bc65a61f2996bfacc00bbf1a9ebb", + "name": "paramiko", + "sha256": "94830456e9a75b9f73e288e858c63f14748dedc990da5504c35b46a29b0f4442", + "size": 253112, + "subdir": "linux-64", + "timestamp": 1568312057643, + "version": "2.6.0" + }, + "paramiko-2.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=2.5", + "pynacl >=1.0.1", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "e4a168516d8ae222722d8b82ccbe93ae", + "name": "paramiko", + "sha256": "49ea418e858d2bb67952b7df5a76887cd52ef0397c1a10952bbedb455d9e3634", + "size": 253305, + "subdir": "linux-64", + "timestamp": 1568312082227, + "version": "2.6.0" + }, + "paramiko-2.6.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "bcrypt >=3.1.3", + "cryptography >=2.5", + "pynacl >=1.0.1", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "92cc4ff3403bf8a66b5583cd924d9dba", + "name": "paramiko", + "sha256": "55fb8ad10dc04ef9c3c416bd16f2ca1a2e634887b2764ec7bd1914a87c9b413a", + "size": 251431, + "subdir": "linux-64", + "timestamp": 1574169767277, + "version": "2.6.0" + }, + "parquet-cpp-1.4.0-h3238a2a_0.conda": { + "build": "h3238a2a_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.9.0,<0.10.0a0", + "libboost >=1.65.1,<1.65.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "thrift-cpp >=0.11.0,<0.12.0a0" + ], + "license": "Apache 2.0", + "md5": "aac41b78966193f8729691cda0786d3f", + "name": "parquet-cpp", + "sha256": "bc5430b8819ff91a336bb65292227fbe1f77abf979b4542759dd78b2e25b5c3f", + "size": 780441, + "subdir": "linux-64", + "timestamp": 1529459998939, + "version": "1.4.0" + }, + "parsedatetime-2.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e9e3a279f9fe094486c2e80e515e85c3", + "name": "parsedatetime", + "sha256": "bb8527accb26518f5199ee431648fd452359ac5b7a80b8b8b5559e0a1b04bedc", + "size": 63318, + "subdir": "linux-64", + "timestamp": 1530735654045, + "version": "2.4" + }, + "parsedatetime-2.4-py27h48d1ce5_0.conda": { + "build": "py27h48d1ce5_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "12cc462ed7409694e7c24674b55729d2", + "name": "parsedatetime", + "sha256": "2a0d0f0b1023e4cd36010bc01841ed4c8cac6d22bc7f9992c42c30c8ca4f0a73", + "size": 63300, + "subdir": "linux-64", + "timestamp": 1505747208352, + "version": "2.4" + }, + "parsedatetime-2.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ad8d5b5febdd64ffd75ca8a8c3c31eaa", + "name": "parsedatetime", + "sha256": "047ff37772275886992d9e5fce2891e9ed4c408582cfc0d5bba557eaf906be83", + "size": 62725, + "subdir": "linux-64", + "timestamp": 1640806646685, + "version": "2.4" + }, + "parsedatetime-2.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cd2839c569797eb7e41d176983ff5b23", + "name": "parsedatetime", + "sha256": "b99b15057f285200d6cfa265121dcb02c51265cfc89b7e9cbb173af7bd4ef7a4", + "size": 82247, + "subdir": "linux-64", + "timestamp": 1676838520102, + "version": "2.4" + }, + "parsedatetime-2.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e3ef03938593f303f837da004fab1525", + "name": "parsedatetime", + "sha256": "c46fa8176b78aa6e26f9670e25eb58195a0e845df3137be7ff7b5667976ed097", + "size": 63366, + "subdir": "linux-64", + "timestamp": 1534352018290, + "version": "2.4" + }, + "parsedatetime-2.4-py35he51eadf_0.conda": { + "build": "py35he51eadf_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "82dce170802a02244dce08f07846387e", + "name": "parsedatetime", + "sha256": "2059199c8b280a094e4093da40cb71393b1a11799cf61c886b71e48ec2a8d10a", + "size": 63154, + "subdir": "linux-64", + "timestamp": 1505747221904, + "version": "2.4" + }, + "parsedatetime-2.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5d681407b8fb51a84b264c604f63c48c", + "name": "parsedatetime", + "sha256": "b9a722957f4b641d4592aaa11ed36f9e160b87e944b9c0d05fe954faad0d1b0e", + "size": 62517, + "subdir": "linux-64", + "timestamp": 1530735633065, + "version": "2.4" + }, + "parsedatetime-2.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "08e8dd8f40c61093138316001d36acee", + "name": "parsedatetime", + "sha256": "88575ddfbd89645cc096ee9b5d51f7600d4515f18edc7fbdf8627b7ecd6820c5", + "size": 63530, + "subdir": "linux-64", + "timestamp": 1613733957229, + "version": "2.4" + }, + "parsedatetime-2.4-py36ha668ad1_0.conda": { + "build": "py36ha668ad1_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e4d90c01f2241b2c5c188d0ef19f50f6", + "name": "parsedatetime", + "sha256": "5c177faa56fa4b240c4b7d950bb4ccf686746a58a2db30f909a1c57ec2d73c16", + "size": 62275, + "subdir": "linux-64", + "timestamp": 1505747235613, + "version": "2.4" + }, + "parsedatetime-2.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5b26a74bf8f860a8a34e3d514c76265a", + "name": "parsedatetime", + "sha256": "5f368349914420086b9dcab636bc7ad88ccdcd4699d18646e3fe2f0ba83ecaba", + "size": 62010, + "subdir": "linux-64", + "timestamp": 1530735675865, + "version": "2.4" + }, + "parsedatetime-2.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "eaae74e113b2cc83756c5f0c5123937d", + "name": "parsedatetime", + "sha256": "f016d9b859bb07a0220d0bf611dd862a214f7550aa3a5f7625ccca6a99b61c1b", + "size": 63747, + "subdir": "linux-64", + "timestamp": 1613733967071, + "version": "2.4" + }, + "parsedatetime-2.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bca202af050fb4863672c17db9195968", + "name": "parsedatetime", + "sha256": "aa58ab95b6cc95fae1cd9bd181182f57480d810c0ed72c1612bbc420e31d09d5", + "size": 62998, + "subdir": "linux-64", + "timestamp": 1573489476815, + "version": "2.4" + }, + "parsedatetime-2.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "64ee0101d6ad001c65f300ebf37633ef", + "name": "parsedatetime", + "sha256": "6a65ebdd5134a0444408b15aaead4b3ff57258c648bbac6200cf1381a4a9f9c2", + "size": 63681, + "subdir": "linux-64", + "timestamp": 1613733966370, + "version": "2.4" + }, + "parsedatetime-2.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0bbd7f4e60be6c7e069b5e9341d6e1b7", + "name": "parsedatetime", + "sha256": "affed91af64f56ace8b19d8bcaca9d8e7e20b83e9a7851e93e3089ed3db00bfc", + "size": 63511, + "subdir": "linux-64", + "timestamp": 1613733209068, + "version": "2.4" + }, + "parsedatetime-2.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3eff46158c9f274838739e4a07823d7b", + "name": "parsedatetime", + "sha256": "e354006ff70b5c8f9d465c60dc9f7a569409b21b2e3ad1be170ab60bb1d4cb3c", + "size": 63417, + "subdir": "linux-64", + "timestamp": 1599891671908, + "version": "2.5" + }, + "parsedatetime-2.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9bd17f9984330ae4fd9fe1e11e7900c5", + "name": "parsedatetime", + "sha256": "97ef333ef9ce67ecd5611ee36cbc62ce28cd1d55250cfa1c1fa7632ed770ce42", + "size": 63803, + "subdir": "linux-64", + "timestamp": 1599891696781, + "version": "2.5" + }, + "parsedatetime-2.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e8d734e3bce20d45b109e486092d29d3", + "name": "parsedatetime", + "sha256": "a13c74aadb6b0b01e286d15c6f593508205bab283dbb7c12106d5151af145a95", + "size": 63745, + "subdir": "linux-64", + "timestamp": 1599891685477, + "version": "2.5" + }, + "parsedatetime-2.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cffb5d67476015c60e961778308480cc", + "name": "parsedatetime", + "sha256": "33c1c26722ab0205661661a1d45c157105d7770391ca0b053d533103de1c9fca", + "size": 63756, + "subdir": "linux-64", + "timestamp": 1599892098261, + "version": "2.6" + }, + "parsedatetime-2.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e068b2864d4744494d622447224793a7", + "name": "parsedatetime", + "sha256": "11f00903230df14669d77cab2040d6734405df9c275e877344efd5622471ff07", + "size": 63168, + "subdir": "linux-64", + "timestamp": 1599892064680, + "version": "2.6" + }, + "parsedatetime-2.6-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1b89e2a47492eb4719d469669a52d8dd", + "name": "parsedatetime", + "sha256": "db4ce612cc75ac64e59cd810c67b286e6dc669180a4a63dad533e16bfa17422a", + "size": 63553, + "subdir": "linux-64", + "timestamp": 1599892098617, + "version": "2.6" + }, + "parsel-1.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml >=2.3", + "pytest-runner", + "python >=2.7,<2.8.0a0", + "six >=1.5.2", + "w3lib >=1.8.0" + ], + "license": "BSD", + "md5": "92a55edb0d630e654e60440e7f6a5389", + "name": "parsel", + "sha256": "37d538dac5372fbff68a96e9ee471ed804042750b1846a610d59dc7903421a81", + "size": 28293, + "subdir": "linux-64", + "timestamp": 1519759470222, + "version": "1.4.0" + }, + "parsel-1.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml >=2.3", + "pytest-runner", + "python >=3.5,<3.6.0a0", + "six >=1.5.2", + "w3lib >=1.8.0" + ], + "license": "BSD", + "md5": "7ba6857b59e6cb2d92cbea71a234d379", + "name": "parsel", + "sha256": "e585cd773f2371b456b4989926b18aaa69ce4f9b6f74a937232a1cc212e3bf87", + "size": 28602, + "subdir": "linux-64", + "timestamp": 1519759459952, + "version": "1.4.0" + }, + "parsel-1.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml >=2.3", + "pytest-runner", + "python >=3.6,<3.7.0a0", + "six >=1.5.2", + "w3lib >=1.8.0" + ], + "license": "BSD", + "md5": "af198d1bc70373be3019221b51b834e0", + "name": "parsel", + "sha256": "aaf372d92e2bfd17886691a094379d59f8c5f21aecd2d25f5672ff70d40f8e38", + "size": 28464, + "subdir": "linux-64", + "timestamp": 1519759454248, + "version": "1.4.0" + }, + "parsel-1.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml >=2.3", + "pytest-runner", + "python >=3.7,<3.8.0a0", + "six >=1.5.2", + "w3lib >=1.8.0" + ], + "license": "BSD", + "md5": "4a94172d8c8e42ab221941ae1dc56fbc", + "name": "parsel", + "sha256": "07901effc438b1b4783ea60ebdbfc4cf9a3dc35daeda9d9c6ad23eba7899a7fb", + "size": 28509, + "subdir": "linux-64", + "timestamp": 1530904832243, + "version": "1.4.0" + }, + "parsel-1.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "functools32", + "lxml >=2.3", + "pytest-runner", + "python >=2.7,<2.8.0a0", + "six >=1.5.2", + "w3lib >=1.8.0" + ], + "license": "BSD", + "md5": "a05ccdae92b2e6d8946d2b728d6afbe4", + "name": "parsel", + "sha256": "a390d610e1b94ff72fed3f9c50b3c744915a838573e5686ad6e3153c9d821140", + "size": 29093, + "subdir": "linux-64", + "timestamp": 1532552155377, + "version": "1.5.0" + }, + "parsel-1.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml >=2.3", + "pytest-runner", + "python >=3.5,<3.6.0a0", + "six >=1.5.2", + "w3lib >=1.8.0" + ], + "license": "BSD", + "md5": "293399bc9360d154db1de241bab80c26", + "name": "parsel", + "sha256": "db2ce32ac388fa9caa6a345b2f6cdf2ef3cab91320ec1ceab4689cb646175153", + "size": 29527, + "subdir": "linux-64", + "timestamp": 1532552169418, + "version": "1.5.0" + }, + "parsel-1.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml >=2.3", + "pytest-runner", + "python >=3.6,<3.7.0a0", + "six >=1.5.2", + "w3lib >=1.8.0" + ], + "license": "BSD", + "md5": "091742669077387427e8ac9d79283781", + "name": "parsel", + "sha256": "ac9cc674c8b099307f577022644787df0ece5f79ba19309e1a0641443ef03731", + "size": 29437, + "subdir": "linux-64", + "timestamp": 1532552112984, + "version": "1.5.0" + }, + "parsel-1.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml >=2.3", + "pytest-runner", + "python >=3.7,<3.8.0a0", + "six >=1.5.2", + "w3lib >=1.8.0" + ], + "license": "BSD", + "md5": "709ceaed82e54917b6c012156073dbb5", + "name": "parsel", + "sha256": "b057d03d99a0ccf32a17bb90f97cd82b54daab7d1e8f1d8f537e0baa4341df07", + "size": 29360, + "subdir": "linux-64", + "timestamp": 1532552180464, + "version": "1.5.0" + }, + "parsel-1.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "functools32", + "lxml >=2.3", + "pytest-runner", + "python >=2.7,<2.8.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "5e9196485f0bb61e7a9368749467d8a8", + "name": "parsel", + "sha256": "c70d29508d342b5686df75f1c055f0a348988832585945a5b0556f86f89bf621", + "size": 29732, + "subdir": "linux-64", + "timestamp": 1541008836876, + "version": "1.5.1" + }, + "parsel-1.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml >=2.3", + "pytest-runner", + "python >=3.6,<3.7.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "315ae3cc5800afa3ad80f756da099254", + "name": "parsel", + "sha256": "ccd58e12ec7b4491dfce6f17c8ef2355d48699d518f6e0f9554f08a598f6d458", + "size": 30186, + "subdir": "linux-64", + "timestamp": 1541008882556, + "version": "1.5.1" + }, + "parsel-1.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml >=2.3", + "pytest-runner", + "python >=3.7,<3.8.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "e872bfbad3ce9fdbbb5ee9b80d258e39", + "name": "parsel", + "sha256": "c00009fac7b419dc25e1546314f8ac86353626bc3f375e275b29fed1c3ab3376", + "size": 30218, + "subdir": "linux-64", + "timestamp": 1541008811908, + "version": "1.5.1" + }, + "parsel-1.5.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "functools32", + "lxml", + "pytest-runner", + "python >=2.7,<2.8.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "fd2ac108876dcdc07a3481cfb7def930", + "name": "parsel", + "sha256": "b29d129d5dcb031f566cc46550dbd7539dd72692bf377a08f8be76060840494a", + "size": 197129, + "subdir": "linux-64", + "timestamp": 1569347409099, + "version": "1.5.2" + }, + "parsel-1.5.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "pytest-runner", + "python >=3.10,<3.11.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "e5ae93581ea6e61065531a6fa8476771", + "name": "parsel", + "sha256": "91957043c07ad36ddced312c045f154ede48955bd8d1fe69e761ff3c6d5ca9ac", + "size": 31822, + "subdir": "linux-64", + "timestamp": 1640809891624, + "version": "1.5.2" + }, + "parsel-1.5.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "pytest-runner", + "python >=3.6,<3.7.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "c7b4eac5b87b8f1677294b6802e81c86", + "name": "parsel", + "sha256": "09f8d978e9b02adc49969a38736ff5194a8d22e5a2c37a7706d9a7496d11b3f1", + "size": 197434, + "subdir": "linux-64", + "timestamp": 1569347389690, + "version": "1.5.2" + }, + "parsel-1.5.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "pytest-runner", + "python >=3.6,<3.7.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "fbf0d9ded7abfd84696c05da1992467f", + "name": "parsel", + "sha256": "f393b60ff2c88337b4eed1777c1c99820f3418a4832b0f93aa6ca404a26ede27", + "size": 268750, + "subdir": "linux-64", + "timestamp": 1613041296771, + "version": "1.5.2" + }, + "parsel-1.5.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "pytest-runner", + "python >=3.7,<3.8.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "309aefc501d946141399046e3ad3314f", + "name": "parsel", + "sha256": "cf56bb445f8f1f3414d694d2feae107d9fd132043c7d74326ee763593fea4c50", + "size": 197276, + "subdir": "linux-64", + "timestamp": 1569347423540, + "version": "1.5.2" + }, + "parsel-1.5.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "pytest-runner", + "python >=3.7,<3.8.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "97ba24458aebb05edcb581c6d0902f27", + "name": "parsel", + "sha256": "7e10d5d28142b19e02de89cdde47c18df454bafba1042bae0014005695b48565", + "size": 269153, + "subdir": "linux-64", + "timestamp": 1613041616115, + "version": "1.5.2" + }, + "parsel-1.5.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "pytest-runner", + "python >=3.8,<3.9.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "3e677a1271ff45b16d6a26123de094cd", + "name": "parsel", + "sha256": "d3b6b479dbdd60492a056da8b1434334b2e5e807cb6136ae7780b402d545f423", + "size": 31739, + "subdir": "linux-64", + "timestamp": 1574177616060, + "version": "1.5.2" + }, + "parsel-1.5.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "pytest-runner", + "python >=3.8,<3.9.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "747ba4c5abea88f9331ea8c36101a92d", + "name": "parsel", + "sha256": "1197bed36da2b6b53f2068ebe13853028432a85c4b0844ec28df37f33035df91", + "size": 268541, + "subdir": "linux-64", + "timestamp": 1613041627763, + "version": "1.5.2" + }, + "parsel-1.5.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "pytest-runner", + "python >=3.9,<3.10.0a0", + "six >=1.5.2", + "w3lib >=1.19.0" + ], + "license": "BSD", + "md5": "269cde47ff6441faf032004772b518be", + "name": "parsel", + "sha256": "c7886d8b1548d8c5079421ab4b840df9eea0983813ca695ce8f01629f89973d0", + "size": 268400, + "subdir": "linux-64", + "timestamp": 1613042427785, + "version": "1.5.2" + }, + "parsel-1.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "python >=3.10,<3.11.0a0", + "six >=1.6.0", + "w3lib >=1.19.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "76664c06fc3322e7b6d4e62fc2df9cd4", + "name": "parsel", + "sha256": "74ac48c1900e183ae0a027c7ac442f5484f56fac42786d31e80e99f4d96339c6", + "size": 358768, + "subdir": "linux-64", + "timestamp": 1646740004884, + "version": "1.6.0" + }, + "parsel-1.6.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "python >=3.11,<3.12.0a0", + "six >=1.6.0", + "w3lib >=1.19.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "29b360ed136f548f63b3c2641e835196", + "name": "parsel", + "sha256": "63e578b2d34f460e1c45d607fb6134f194775fa46f3c0fb7cae41f638f05f317", + "size": 38521, + "subdir": "linux-64", + "timestamp": 1676905952775, + "version": "1.6.0" + }, + "parsel-1.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "python >=3.7,<3.8.0a0", + "six >=1.6.0", + "w3lib >=1.19.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cba5f80039928ea9a1107c4209b1adbb", + "name": "parsel", + "sha256": "6397638157b00a841271a2c6ddf875cb69aa8947ac78ecc5b3f3ae22890d47f2", + "size": 358787, + "subdir": "linux-64", + "timestamp": 1646721868412, + "version": "1.6.0" + }, + "parsel-1.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "python >=3.8,<3.9.0a0", + "six >=1.6.0", + "w3lib >=1.19.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9b9553abcf4b1ec1cdf488c377853666", + "name": "parsel", + "sha256": "d8d51e3a907253ee4f5ad9877f632c8c9c4909146d9c4ac25ba19accbb347304", + "size": 358362, + "subdir": "linux-64", + "timestamp": 1646739993580, + "version": "1.6.0" + }, + "parsel-1.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "python >=3.9,<3.10.0a0", + "six >=1.6.0", + "w3lib >=1.19.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f362a5068bdeb3d0d219c8fd06f60fb3", + "name": "parsel", + "sha256": "5bb511ed49018947c447dbded143359394bda11a6155b0d05d51df0091dd592a", + "size": 358516, + "subdir": "linux-64", + "timestamp": 1646722560868, + "version": "1.6.0" + }, + "parso-0.1.0-py27h04a9d95_0.conda": { + "build": "py27h04a9d95_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "ffc2ed0527efa37accd1ecfd08b992c5", + "name": "parso", + "sha256": "811e1206de9fc1c5da4b52b75c66fbde13935905045e556a6e6c3b81eff46908", + "size": 124032, + "subdir": "linux-64", + "timestamp": 1512058743385, + "version": "0.1.0" + }, + "parso-0.1.0-py35ha74fa24_0.conda": { + "build": "py35ha74fa24_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "f3e49483979fcef914c9ff6862a0d7da", + "name": "parso", + "sha256": "ae8defbdf72020321159cba54528906c864dd524625b6c895aa7b77ad9da61af", + "size": 124574, + "subdir": "linux-64", + "timestamp": 1512058746177, + "version": "0.1.0" + }, + "parso-0.1.0-py36h2b61f4d_0.conda": { + "build": "py36h2b61f4d_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "332ec257488ef6d6c27d616bbbad925c", + "name": "parso", + "sha256": "d690516da4c77de521523f396384399d8d6512227b105da6862ba9b286fc5d9d", + "size": 124871, + "subdir": "linux-64", + "timestamp": 1512058740045, + "version": "0.1.0" + }, + "parso-0.1.1-py27h718acc2_0.conda": { + "build": "py27h718acc2_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "1f7f01caaffa5f1e0fa01b29fb86e383", + "name": "parso", + "sha256": "52838721a80b362a3697c335042967fdcc762ee936f06032d9c0a8627fccbdba", + "size": 124235, + "subdir": "linux-64", + "timestamp": 1512061040687, + "version": "0.1.1" + }, + "parso-0.1.1-py35h1b200a3_0.conda": { + "build": "py35h1b200a3_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "9db46d8b27e186520aea99a2965d5124", + "name": "parso", + "sha256": "5900b314e06663fa6f16576cd44ea788e5e0b6a1433515bb2d9588b7c1410685", + "size": 126590, + "subdir": "linux-64", + "timestamp": 1512061082892, + "version": "0.1.1" + }, + "parso-0.1.1-py36h35f843b_0.conda": { + "build": "py36h35f843b_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "dd8366cb4b1af1f07507f816b8e4bab5", + "name": "parso", + "sha256": "68151b7383a5f589d94d57c9396d6b938975525f9a73dee69dc0500e1529aeae", + "size": 125250, + "subdir": "linux-64", + "timestamp": 1512061097157, + "version": "0.1.1" + }, + "parso-0.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "75d26d898e83d03ef7c24e03bfdcdf62", + "name": "parso", + "sha256": "4d90e8163eb25dfc53dc362e6256df5f01af92c41398e26d718e399802f0cdf9", + "size": 122793, + "subdir": "linux-64", + "timestamp": 1523908483796, + "version": "0.2.0" + }, + "parso-0.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f58a52faea54be40f20d709208101d1", + "name": "parso", + "sha256": "6b4d718ce223bb1065295d8f5e9615865190ef3dc2437664fdbeae20d70bd652", + "size": 124922, + "subdir": "linux-64", + "timestamp": 1523908576129, + "version": "0.2.0" + }, + "parso-0.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "24bde6c8328a3d06d5d8c5189a959db3", + "name": "parso", + "sha256": "c8be8b0a8dabffd96fbe6bcbe96e2c355f6c4a8b3777ed6ac81fc8e995d1fdc1", + "size": 122067, + "subdir": "linux-64", + "timestamp": 1523908472081, + "version": "0.2.0" + }, + "parso-0.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6145c769a9adeb14347caad10bc45eb8", + "name": "parso", + "sha256": "e79190ec61da8dc35237365f70e060a85db87cdb7a7ebc198730e41a09728d84", + "size": 123623, + "subdir": "linux-64", + "timestamp": 1527827411093, + "version": "0.2.1" + }, + "parso-0.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43424ace6313b0f88e2ee9aa62ac6c12", + "name": "parso", + "sha256": "bd7a1ef733c102c11b9017eecc4f969fa33e8097d1421b7b794634687bfec1b4", + "size": 124372, + "subdir": "linux-64", + "timestamp": 1527827433773, + "version": "0.2.1" + }, + "parso-0.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4c81e2c93fd27b6cfb4c351aea27cebb", + "name": "parso", + "sha256": "32eac59748cada26c379938b43055a69acad88ea006c5f359e7ec64749212743", + "size": 124804, + "subdir": "linux-64", + "timestamp": 1527827715671, + "version": "0.2.1" + }, + "parso-0.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f016277ce9a0f803b1688a9bda852020", + "name": "parso", + "sha256": "c3600ed12b6dde3d123c85499884783f81f202d8e06591178c1149eeb4a62491", + "size": 122609, + "subdir": "linux-64", + "timestamp": 1530694801920, + "version": "0.2.1" + }, + "parso-0.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9dca443fece2e40b161025cbe9428518", + "name": "parso", + "sha256": "139e3b1c24f76cc2825c6302628b7f77264b7713f0c9df347c10535cb3eae475", + "size": 120120, + "subdir": "linux-64", + "timestamp": 1531849970262, + "version": "0.3.0" + }, + "parso-0.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83701da03844f8262b547a4119154c89", + "name": "parso", + "sha256": "0c892b0e47c31d09d49a049cd83ec8c207ec0fcc45127f83cd161c2969d924e9", + "size": 120702, + "subdir": "linux-64", + "timestamp": 1531850037547, + "version": "0.3.0" + }, + "parso-0.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bae4cd9cd51f43026d990be19ab5cba3", + "name": "parso", + "sha256": "0d2e2776b9fdf45567e4d864b05c5d9eb838b2aff9d9dc34d9345de3401c3685", + "size": 121265, + "subdir": "linux-64", + "timestamp": 1531850040932, + "version": "0.3.0" + }, + "parso-0.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f91b33de6c6623895fcb060932a010d2", + "name": "parso", + "sha256": "29856c4253088d796d35d93be545c5ae95ab9a9127d5664f0e56601a7ef2de2d", + "size": 118997, + "subdir": "linux-64", + "timestamp": 1531849993318, + "version": "0.3.0" + }, + "parso-0.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a90959717161b81792a3236350fe29c6", + "name": "parso", + "sha256": "261c147f36b90c68c3497138884bbe00636c05621acc2c4564d63d720dcb688b", + "size": 120272, + "subdir": "linux-64", + "timestamp": 1532364925798, + "version": "0.3.1" + }, + "parso-0.3.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43435918b0c68d0a3ab90724eafbf7fd", + "name": "parso", + "sha256": "f781182940c64dbf0627dc14f9dd172d49c75862f21b89602027203ff65a96a5", + "size": 122642, + "subdir": "linux-64", + "timestamp": 1532364967412, + "version": "0.3.1" + }, + "parso-0.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8997cf919dafb88a4790d8f29c329e51", + "name": "parso", + "sha256": "8d6bca656c9f29c12f8a70b16435fee40ecacab7c54c01aa4c8121eda2585239", + "size": 121325, + "subdir": "linux-64", + "timestamp": 1532364847610, + "version": "0.3.1" + }, + "parso-0.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c33a114a70b73979b22798bd81dafa93", + "name": "parso", + "sha256": "d1cfacf89be2254bd0e869199da4a70cfbfaa470b5ed4b51a862813851a9539d", + "size": 119020, + "subdir": "linux-64", + "timestamp": 1532364967554, + "version": "0.3.1" + }, + "parso-0.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd2c062cdfda4f0675b832600f158c2d", + "name": "parso", + "sha256": "4c9025c96710bd6fee757a9a993db3abb7de2a27d6e3110fa15944b6c2e9c3ef", + "size": 124629, + "subdir": "linux-64", + "timestamp": 1549324552541, + "version": "0.3.2" + }, + "parso-0.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "786566c9829483df81941c653dc1b786", + "name": "parso", + "sha256": "3db05b719776050e56c22872e6c2c8588bb4d77935f1975ab983ecf697232f53", + "size": 127285, + "subdir": "linux-64", + "timestamp": 1549324307792, + "version": "0.3.2" + }, + "parso-0.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e095a2cfad55c8b15734eb7141177b3", + "name": "parso", + "sha256": "6bb008decaa96205508d02597cdafba8d6b142b51f2509ae27637ef9e8e654ee", + "size": 125029, + "subdir": "linux-64", + "timestamp": 1549324237762, + "version": "0.3.2" + }, + "parso-0.3.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a6fe2cd7a500709eaf76eacb7705a83d", + "name": "parso", + "sha256": "2d7151780b845080ae087a87acab34155cc5755727fe2eff877dccf5a7b21043", + "size": 128003, + "subdir": "linux-64", + "timestamp": 1551142932472, + "version": "0.3.4" + }, + "parso-0.3.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "81f61380eabfa6ec4a3c3033d0d7c108", + "name": "parso", + "sha256": "879c2942998ec2e06dc04d8a34746cec03a8a82182882f772ec3b3915c2b9588", + "size": 128906, + "subdir": "linux-64", + "timestamp": 1551142943781, + "version": "0.3.4" + }, + "parso-0.3.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e79eb3483b2f850f459f9091609df4e", + "name": "parso", + "sha256": "a9bb6769b22445aaf36368bc48febb1063f91bceadcfefca66b5eb186178666b", + "size": 128307, + "subdir": "linux-64", + "timestamp": 1551142907675, + "version": "0.3.4" + }, + "partd-0.3.10-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "locket", + "python >=2.7,<2.8.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "515d7115feabd061f681161feaabfd36", + "name": "partd", + "sha256": "23470e03d757561a9c2fd0900a51261f2bfe32c192352b35cb4c308a9c379843", + "size": 36357, + "subdir": "linux-64", + "timestamp": 1553289287582, + "version": "0.3.10" + }, + "partd-0.3.10-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "locket", + "python >=3.6,<3.7.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "4a47986835d7a997d36c2bb9d081d10f", + "name": "partd", + "sha256": "48df5278cb0e0a6b609dcffc2d6abf7e0dad3ad909c7f3e57467ad43ba6fe65c", + "size": 36932, + "subdir": "linux-64", + "timestamp": 1553289762500, + "version": "0.3.10" + }, + "partd-0.3.10-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "locket", + "python >=3.7,<3.8.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "99bc51d711a663cfbf4988615c8675cd", + "name": "partd", + "sha256": "5fc9db20d8fa343c9647bd7b9e3dd565eacbdca64b3a3da6392054d5cffab32d", + "size": 36815, + "subdir": "linux-64", + "timestamp": 1553289424927, + "version": "0.3.10" + }, + "partd-0.3.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "locket", + "python >=2.7,<2.8.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "29d9197906546f196e7437c848747915", + "name": "partd", + "sha256": "2f92ee50e18974236bf24bc873bba7f0cc8c04a5bd82b37c92382e392b52bf88", + "size": 32565, + "subdir": "linux-64", + "timestamp": 1530741822140, + "version": "0.3.8" + }, + "partd-0.3.8-py27h4e55004_0.conda": { + "build": "py27h4e55004_0", + "build_number": 0, + "depends": [ + "locket", + "python >=2.7,<2.8.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "d2bbebd2bd5471055b2469e4f34a0980", + "name": "partd", + "sha256": "1b65c128449e7a4b4d1f5817944ba49abdad69352c64914989292b591144f705", + "size": 32308, + "subdir": "linux-64", + "timestamp": 1505732816039, + "version": "0.3.8" + }, + "partd-0.3.8-py35h68187f2_0.conda": { + "build": "py35h68187f2_0", + "build_number": 0, + "depends": [ + "locket", + "python >=3.5,<3.6.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "bdf5662bfce63ddb3fe8bf3c0bd39720", + "name": "partd", + "sha256": "ad249782a55cbc2a7b95fa3d321c7bf6fb6af79e076f7a49ceb5ebb2a327b594", + "size": 33161, + "subdir": "linux-64", + "timestamp": 1505732828325, + "version": "0.3.8" + }, + "partd-0.3.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "locket", + "python >=3.6,<3.7.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "63db8a0905342cc975dd84ae66b7a4f3", + "name": "partd", + "sha256": "93e024a075c3af875336414586711b57ee0bf8f90375b5573813e62df27d1665", + "size": 33061, + "subdir": "linux-64", + "timestamp": 1530741799311, + "version": "0.3.8" + }, + "partd-0.3.8-py36h36fd896_0.conda": { + "build": "py36h36fd896_0", + "build_number": 0, + "depends": [ + "locket", + "python >=3.6,<3.7.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "3098dbd9220662732a230f3509f072af", + "name": "partd", + "sha256": "f6f171c5e4ba91b0e341fda69a8fd9814d094d456b5c5f037e38d9809292f04a", + "size": 32709, + "subdir": "linux-64", + "timestamp": 1505732840860, + "version": "0.3.8" + }, + "partd-0.3.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "locket", + "python >=3.7,<3.8.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "d17472f2676354122406cc200cfe7a22", + "name": "partd", + "sha256": "24c52f7b94c066ee51445f9c25762fe826b940a62ac109c4aa69dbea62fdc645", + "size": 33036, + "subdir": "linux-64", + "timestamp": 1530741846053, + "version": "0.3.8" + }, + "partd-0.3.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "locket", + "python >=2.7,<2.8.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "3ace2d39ed0a0e88c5550e4bbc9ad09f", + "name": "partd", + "sha256": "14962095b15741795838a6ddc01a1e3b46badfadb151cd077598845497b15796", + "size": 34894, + "subdir": "linux-64", + "timestamp": 1539635289776, + "version": "0.3.9" + }, + "partd-0.3.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "locket", + "python >=3.6,<3.7.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "f0d3225749a5ea85ddd2f1dd550d44f5", + "name": "partd", + "sha256": "ddda83e8255b1b63c89790aeb44cd57d0deafadb4063f8b3c5a1c222535eea39", + "size": 35035, + "subdir": "linux-64", + "timestamp": 1539635313058, + "version": "0.3.9" + }, + "partd-0.3.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "locket", + "python >=3.7,<3.8.0a0", + "toolz" + ], + "license": "BSD 3-Clause", + "md5": "386d2c6b63c86a11f5ec619701131beb", + "name": "partd", + "sha256": "49d7ca0dc09ff65caa69c6a6d6aa1b91c9bf954c242f62bf490db1ad6fe680fd", + "size": 35270, + "subdir": "linux-64", + "timestamp": 1539635316139, + "version": "0.3.9" + }, + "passlib-1.7.1-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "argon2_cffi >=16.2", + "bcrypt >=3.1.0", + "cryptography", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3b3a32ef2fa3d0f2387b748414ec481d", + "name": "passlib", + "sha256": "5656b07395e807966d1798b467b440b421ce108138d7c7205783f85655cb165d", + "size": 626053, + "subdir": "linux-64", + "timestamp": 1530736322052, + "version": "1.7.1" + }, + "passlib-1.7.1-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "argon2_cffi >=16.2", + "bcrypt >=3.1.0", + "cryptography", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "070d17591f31f7bca6d733f80da76891", + "name": "passlib", + "sha256": "809e3f20e34493c0b83cc02f8ac740c85b001849681cafb73b467272c473a352", + "size": 634333, + "subdir": "linux-64", + "timestamp": 1534352263944, + "version": "1.7.1" + }, + "passlib-1.7.1-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "argon2_cffi >=16.2", + "bcrypt >=3.1.0", + "cryptography", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f2f441e45288d2664c2703dce095b81f", + "name": "passlib", + "sha256": "28e11cb470ceed53b8bbfbea79bc16fe5f392811eb8ba4228592254f2f7559cc", + "size": 638626, + "subdir": "linux-64", + "timestamp": 1530736295447, + "version": "1.7.1" + }, + "passlib-1.7.1-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "argon2_cffi >=16.2", + "bcrypt >=3.1.0", + "cryptography", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "21ef0581a1637052667e67a8582c92c5", + "name": "passlib", + "sha256": "73c9dee1d7692c75c370852cd79cc9ce01cc3d29a010066d49d8e3c60a5e9ebc", + "size": 626450, + "subdir": "linux-64", + "timestamp": 1530736352217, + "version": "1.7.1" + }, + "paste-2.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "a653a47a8b694ac865256dc306ddaf6f", + "name": "paste", + "sha256": "08757da821b9b19110cbdda487eb60c530d2f41533715ac45c18bdbc5894f17d", + "size": 690856, + "subdir": "linux-64", + "timestamp": 1530892747444, + "version": "2.0.3" + }, + "paste-2.0.3-py27h6ae3614_0.conda": { + "build": "py27h6ae3614_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "4d8621a8a483c17e52424be5f55a9016", + "name": "paste", + "sha256": "505adca1e01cb9223d4ad774ab4b2ea4dfa12d7b793844568710c9e454f1a3c2", + "size": 690990, + "subdir": "linux-64", + "timestamp": 1507872935529, + "version": "2.0.3" + }, + "paste-2.0.3-py35hc7cf8aa_0.conda": { + "build": "py35hc7cf8aa_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "e5a1bb06d60fcf06c318a9cbf1e66936", + "name": "paste", + "sha256": "346c46271d3c5eaa4a13be8a8e2ece8803d752283b3f5db31537cdb2a8152ca6", + "size": 691011, + "subdir": "linux-64", + "timestamp": 1507872943089, + "version": "2.0.3" + }, + "paste-2.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "57ae3b81e8ea7787b15c2873b126bf1b", + "name": "paste", + "sha256": "c840573ebeb5aa9f5794a9dc02506c1177d811b4fada08e70b0eb0ef59101a78", + "size": 692101, + "subdir": "linux-64", + "timestamp": 1530892715996, + "version": "2.0.3" + }, + "paste-2.0.3-py36h9fb3c17_0.conda": { + "build": "py36h9fb3c17_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "3dfc33ef448f9cc82737e071f1f3b2af", + "name": "paste", + "sha256": "376f7dd4a12283ed50acfe72ff126469f94b47ffba061fa903ef0cdac1ca608a", + "size": 687625, + "subdir": "linux-64", + "timestamp": 1507872945963, + "version": "2.0.3" + }, + "paste-2.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "ea5a982349613239efd55c5e31d46311", + "name": "paste", + "sha256": "ed5f8180d591f465332df3d630896586dfbb75e31e8440a04025f90a1ae1985e", + "size": 691354, + "subdir": "linux-64", + "timestamp": 1530892680953, + "version": "2.0.3" + }, + "paste-3.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "61fee9907f7befa46144424d58f5ae81", + "name": "paste", + "sha256": "354683a359647b681506dd58980a875b02ed8d53fdf1a23b29d30f1c528f3c02", + "size": 687521, + "subdir": "linux-64", + "timestamp": 1541185719171, + "version": "3.0.2" + }, + "paste-3.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "0bcb162bf0ff0bacfe15dd9cb0989242", + "name": "paste", + "sha256": "2cf35c666ad8b04dc75684d73e61a009a0466ae8085af3ed4043634bb1c4d9ad", + "size": 688504, + "subdir": "linux-64", + "timestamp": 1541185700413, + "version": "3.0.2" + }, + "paste-3.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "24e4c7fcf888c0237fe4b9476e1987de", + "name": "paste", + "sha256": "738ae489ec4358b02d4d39f6ac6afcd81f609e683f2bb0b56f31472139308058", + "size": 692369, + "subdir": "linux-64", + "timestamp": 1541185677177, + "version": "3.0.2" + }, + "paste-3.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "adbf5f1aa4942f86273c339ef562214d", + "name": "paste", + "sha256": "f602404b6335737f022616262892a91b824924e2a909a71a4d732d297d5a810b", + "size": 687955, + "subdir": "linux-64", + "timestamp": 1541448245408, + "version": "3.0.3" + }, + "paste-3.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "e5aa3691745279820bc95cfcf511eb64", + "name": "paste", + "sha256": "4d39174c61a3766231fa5ae6dbdcf39b31d86f336cf170fc2c844618a143de91", + "size": 688518, + "subdir": "linux-64", + "timestamp": 1541448279347, + "version": "3.0.3" + }, + "paste-3.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "92536a159558407bfa2680f410511e37", + "name": "paste", + "sha256": "8748e784bee151fb64f9bcae0fc92cb72a66a3ecfce7606824f726f30f9e7c13", + "size": 692438, + "subdir": "linux-64", + "timestamp": 1541448229338, + "version": "3.0.3" + }, + "paste-3.0.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "72ddb66f2b27521209c46b9b13ddd807", + "name": "paste", + "sha256": "ecabcae549c2290735820ad93b08b32e294c7c4c242ea9b7e6068e10d76a6188", + "size": 693706, + "subdir": "linux-64", + "timestamp": 1542083346593, + "version": "3.0.4" + }, + "paste-3.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "d007d623f362d1e4327c10749f9ae950", + "name": "paste", + "sha256": "5fc19ea557ff72fbf937e2c9d9b87bf378390f91bc35b8dde171fe227740d56e", + "size": 693322, + "subdir": "linux-64", + "timestamp": 1542083314798, + "version": "3.0.4" + }, + "paste-3.0.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "8ed302bc3ad2400d915f52b212edd9f0", + "name": "paste", + "sha256": "d9137984b42979717c2c63385a543bdeac7793a18fb108368c47938e8f034be9", + "size": 687837, + "subdir": "linux-64", + "timestamp": 1542083307221, + "version": "3.0.4" + }, + "paste-3.0.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "8499f00600ca57048a062880c3b342df", + "name": "paste", + "sha256": "c92c767ff4011f8902c9b98bd8ef0b8f24a66128204a7b0d9a067d79470609f8", + "size": 692097, + "subdir": "linux-64", + "timestamp": 1545117918364, + "version": "3.0.5" + }, + "paste-3.0.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "3e2282ecdd3498cca205eea2a9aa296a", + "name": "paste", + "sha256": "26f9f694404fdc71acafae9c5d3f9dba7b6843df55dc199d3b4f5b544cace06f", + "size": 693376, + "subdir": "linux-64", + "timestamp": 1545117944185, + "version": "3.0.5" + }, + "paste-3.0.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "cf7449ec67669389a84315de9aaf1564", + "name": "paste", + "sha256": "a5b0844e95f991227be685bb41b6e83406e1050668267094de1ee1459f8b3a38", + "size": 687820, + "subdir": "linux-64", + "timestamp": 1545117944438, + "version": "3.0.5" + }, + "paste-3.0.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "aa092c5c037a01d7b4ff18bf6abbd28e", + "name": "paste", + "sha256": "5cde58e6c722acb6b831240717e543796077d6374f7e741557a3a76b2eb8f765", + "size": 693225, + "subdir": "linux-64", + "timestamp": 1547243981876, + "version": "3.0.6" + }, + "paste-3.0.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "be8b10ccf3757e5c361d3077ed6883be", + "name": "paste", + "sha256": "55fdf92eb1688e40ae26b6444687b2449e5f58573f559daea3998831c46c92cd", + "size": 692256, + "subdir": "linux-64", + "timestamp": 1547243992566, + "version": "3.0.6" + }, + "paste-3.0.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "4dab01fedf78d09239245a920a2d3ebf", + "name": "paste", + "sha256": "e43f81fe7c71df9f27f292a23015a62d33ca1ed15c45a60c4786713733968bf6", + "size": 691422, + "subdir": "linux-64", + "timestamp": 1547243970009, + "version": "3.0.6" + }, + "paste-3.0.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "9aa7d43f0c4d391b54e87425bd18f602", + "name": "paste", + "sha256": "0dcd9868aef7e6dbe7a430747d32098feef0518e005f873edc1776f90446d2af", + "size": 693607, + "subdir": "linux-64", + "timestamp": 1552362758857, + "version": "3.0.8" + }, + "paste-3.0.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "0b44383201da5aae496e0d6baf5353b8", + "name": "paste", + "sha256": "54efcf34ffa7841c1876d72ec9dd0247f993efae930f92d484c652a2485ff836", + "size": 699057, + "subdir": "linux-64", + "timestamp": 1552362835179, + "version": "3.0.8" + }, + "paste-3.0.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "280953186d3fbf449ac31959763774a9", + "name": "paste", + "sha256": "4583836e8d9be200d8a9915dbfcf45f1528ca162bc5b4adf0d511fb58722769c", + "size": 698071, + "subdir": "linux-64", + "timestamp": 1552362731446, + "version": "3.0.8" + }, + "paste-3.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "efabe05206357922441307c93bcd0ba1", + "name": "paste", + "sha256": "9ee5ddde60bea198bc546b00f79f930a8e8ed9f741d1b58bb45357efe0168bb5", + "size": 700384, + "subdir": "linux-64", + "timestamp": 1564686694288, + "version": "3.1.0" + }, + "paste-3.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "7eb139b5518eb98deebaf9615f4d8a44", + "name": "paste", + "sha256": "61a95b212911a2aaf354bc965b4cd166b9bcb0dcebc8d78f626a3fd352c25b28", + "size": 702450, + "subdir": "linux-64", + "timestamp": 1564686774636, + "version": "3.1.0" + }, + "paste-3.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "09842e20cd4054033ca25710bd82e27e", + "name": "paste", + "sha256": "c5012d2fe4ee4632c00976171c70e34217977fad4a5c632dc040bdc425a12a88", + "size": 700307, + "subdir": "linux-64", + "timestamp": 1564686611445, + "version": "3.1.0" + }, + "paste-3.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "907b79b49a2fa99f5c8cc40651651fe4", + "name": "paste", + "sha256": "c696e21cad8850910e1aba60d3b532af47d08acb12765b8462ae0c674a3e32e7", + "size": 699383, + "subdir": "linux-64", + "timestamp": 1569369279124, + "version": "3.2.0" + }, + "paste-3.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "fceac9084a3c49c9e54a0a6b3d04b2a4", + "name": "paste", + "sha256": "efa29d040b502fb9207edd1a5d8ae5f032d8c30556d305f01d32b1b5ff7e3491", + "size": 700831, + "subdir": "linux-64", + "timestamp": 1569369282308, + "version": "3.2.0" + }, + "paste-3.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "789007ce22e8644e6509a00f54ed3e0c", + "name": "paste", + "sha256": "011b41c20e7b7822a2fef2ec30782ae5957e3e89b2a54a396825f06b66ca1c18", + "size": 699665, + "subdir": "linux-64", + "timestamp": 1569369270485, + "version": "3.2.0" + }, + "paste-3.2.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "ec782b668ef67c4a0e4f2486ac282586", + "name": "paste", + "sha256": "97b316e12acf5d49ff1ac808b2216d45370b1437c81ab4d113e1e838e8944b84", + "size": 701226, + "subdir": "linux-64", + "timestamp": 1573970237133, + "version": "3.2.2" + }, + "paste-3.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "92fc4c547e196cb421a855809f60e1c8", + "name": "paste", + "sha256": "b9f0daf653275b44f10ca301c4118f14ab7ec92727ab3a3aadebc78ebd5efc7a", + "size": 702113, + "subdir": "linux-64", + "timestamp": 1573970241154, + "version": "3.2.2" + }, + "paste-3.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "a8af80bf730e836d1373524192e0d5e2", + "name": "paste", + "sha256": "034c9f3d35389f39ede75312e7fa9dcd683a18eb7d1ddf4d7065f4142a568366", + "size": 701150, + "subdir": "linux-64", + "timestamp": 1573970183926, + "version": "3.2.2" + }, + "paste-3.2.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "6ecc25dc3e2169286514f66bc864766a", + "name": "paste", + "sha256": "041a5e491df742072345e46b0609a6469defddf945149459fdc95c83c8162676", + "size": 704181, + "subdir": "linux-64", + "timestamp": 1573970275669, + "version": "3.2.2" + }, + "paste-3.4.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "48d2b3547336325af1a5d1bf454b32a0", + "name": "paste", + "sha256": "5a80d957518d2676e9a2c87d9dbc70fa82dd80431aad852989350619f12c4366", + "size": 701412, + "subdir": "linux-64", + "timestamp": 1600967841807, + "version": "3.4.5" + }, + "paste-3.4.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "166c67be5873c5e7cbf2e2752bf2d6cc", + "name": "paste", + "sha256": "ba53e49047b391948de809bee566b21f2531c335354821db8b6fb28fd94ccae0", + "size": 694753, + "subdir": "linux-64", + "timestamp": 1600965735369, + "version": "3.4.5" + }, + "paste-3.4.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "7b9b58034ba2e0833f0762749ac2a5ef", + "name": "paste", + "sha256": "37f1489532bdc3a0647efaf7e200f24d0088e535147fc8be0b44fb60ab451a0a", + "size": 697911, + "subdir": "linux-64", + "timestamp": 1600967893836, + "version": "3.4.5" + }, + "paste-3.4.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "7a97624f9c2ff6d63188f7b26c5ebf95", + "name": "paste", + "sha256": "bb3269666bfff479255042944f39ddca38a779b1f03d086fcf749d48a70b2b31", + "size": 702757, + "subdir": "linux-64", + "timestamp": 1601051418355, + "version": "3.4.6" + }, + "paste-3.4.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "3c972217fbeedd6660e3566420711c10", + "name": "paste", + "sha256": "d40ab90b04d6925bb23bc6b26eb1d664ac6b5ea19df2fa13f2ef7f9440428a67", + "size": 701691, + "subdir": "linux-64", + "timestamp": 1601051388540, + "version": "3.4.6" + }, + "paste-3.4.6-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "ab7798291a4b0afa60e5f14449d7940f", + "name": "paste", + "sha256": "4157a31328daab551636cfeb5787d31afb566787bfb36e3a5f64c1297c909ec8", + "size": 701463, + "subdir": "linux-64", + "timestamp": 1601052184604, + "version": "3.4.6" + }, + "paste-3.5.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "c276a8d0444b6c7828dcdaf914104850", + "name": "paste", + "sha256": "33106fcfb6c69b04199679c294869ec450aa02f7e8b4c554e7f5d39ece095088", + "size": 706064, + "subdir": "linux-64", + "timestamp": 1640806667577, + "version": "3.5.0" + }, + "paste-3.5.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "ef56c40ffc522f440172d4c05ae67c2f", + "name": "paste", + "sha256": "26deeb8a1bc226780c7029a5dcb198e8846a0c08b3eae8ecd40d5b72b76f7501", + "size": 828583, + "subdir": "linux-64", + "timestamp": 1676860296484, + "version": "3.5.0" + }, + "paste-3.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "0fa9dd14e138bb812c15342520f47912", + "name": "paste", + "sha256": "47b744bc0da19249ca96575ecb872aae04a518dcc8d19f9be7b9222dc581652a", + "size": 697086, + "subdir": "linux-64", + "timestamp": 1602614439779, + "version": "3.5.0" + }, + "paste-3.5.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "d028f9164de21d889fe7799d3515bdf3", + "name": "paste", + "sha256": "a37aec09b3521fc6061c19828c0becd4441046bffa1fd093a44d9da6700feb55", + "size": 706415, + "subdir": "linux-64", + "timestamp": 1615981301651, + "version": "3.5.0" + }, + "paste-3.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "6c62b9f9a6a8c0ed91e140f2e7e82c84", + "name": "paste", + "sha256": "4f51a83deeeb613ab9f3cb3f37e39ceb409d674e41528c562ec8102d37176974", + "size": 701938, + "subdir": "linux-64", + "timestamp": 1602614436527, + "version": "3.5.0" + }, + "paste-3.5.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "4bbb489b3c894a1d148956fd705a2a35", + "name": "paste", + "sha256": "616a7da379ea394bbb4ea479ec7e6109748e8fcab7cde1044632c6cd78438244", + "size": 699491, + "subdir": "linux-64", + "timestamp": 1615979747682, + "version": "3.5.0" + }, + "paste-3.5.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "019a5462b82438f63caf2bb204f9a853", + "name": "paste", + "sha256": "393a97a5cd7a68a740739467b929437703003f9c55eb658b110002a3b2962f54", + "size": 702540, + "subdir": "linux-64", + "timestamp": 1602614420497, + "version": "3.5.0" + }, + "paste-3.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "cd3cb717fe16196447149517be8e5035", + "name": "paste", + "sha256": "59bbd0c2acb0ce2a5f7ee2c98068661e3b3c59935849094db9af2190ac001d2d", + "size": 699173, + "subdir": "linux-64", + "timestamp": 1615981642125, + "version": "3.5.0" + }, + "paste-3.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "six >=1.4.0" + ], + "license": "MIT", + "md5": "99a740a16fdfeb5dade23266842c55c0", + "name": "paste", + "sha256": "d173dee023968c6b9d03ec3503e9cc2d7fa18b70912a3870c00d20908c342a32", + "size": 706209, + "subdir": "linux-64", + "timestamp": 1615981634333, + "version": "3.5.0" + }, + "pastedeploy-1.5.2-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9df1b8103ab402b9f4e98fb9f90504f8", + "name": "pastedeploy", + "sha256": "80a39d148f823f3fd6a5c438a3cd1b179f20e7371d795f9d1ccdf51c17009881", + "size": 28764, + "subdir": "linux-64", + "timestamp": 1530025619316, + "version": "1.5.2" + }, + "pastedeploy-1.5.2-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1797ca4aaf2820fdd5b85c14b1c9b95e", + "name": "pastedeploy", + "sha256": "2a370c46aec1e0454b0ddfb0b7db3b89fa1f57c4cfd549ecb58ed51ebe0efff0", + "size": 29555, + "subdir": "linux-64", + "timestamp": 1530025687874, + "version": "1.5.2" + }, + "pastedeploy-1.5.2-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e35136abbafc131646740a630150095f", + "name": "pastedeploy", + "sha256": "3ca3291001309dafa99a88dcf784f2df07ae95323c45439c9fe57ff651857d91", + "size": 29036, + "subdir": "linux-64", + "timestamp": 1530025400784, + "version": "1.5.2" + }, + "pastedeploy-1.5.2-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c47b82bc664f1cce594799b37bf8d6f7", + "name": "pastedeploy", + "sha256": "6ea0eeec5e1ab18d043bf32f004385c3d4d93ca3aa838a15f1d8c109d16924a4", + "size": 29175, + "subdir": "linux-64", + "timestamp": 1530875201238, + "version": "1.5.2" + }, + "pastedeploy-2.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b92f56864502c7a27bb144379069325e", + "name": "pastedeploy", + "sha256": "5a92aec46410cfb5723f5fd3815320f597c221b108b9f6b799172d2796f5d9bb", + "size": 29448, + "subdir": "linux-64", + "timestamp": 1545166742215, + "version": "2.0.1" + }, + "pastedeploy-2.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff4101fc0df3b7870d4b32e3bd3e312b", + "name": "pastedeploy", + "sha256": "bb2fd0ce96eda0eef08aae49a95788e6fe011f4227050af8309b09f3ced494a9", + "size": 30028, + "subdir": "linux-64", + "timestamp": 1640806688502, + "version": "2.0.1" + }, + "pastedeploy-2.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "53bca43786bd949f1bbbd15cc5a2d2c7", + "name": "pastedeploy", + "sha256": "581723f267fc79453e1bac65f60fafa19df8d238d305fbd47d92d195efb3bfb7", + "size": 38998, + "subdir": "linux-64", + "timestamp": 1676903959453, + "version": "2.0.1" + }, + "pastedeploy-2.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5eed2521d2310466d600520af7ff9d0e", + "name": "pastedeploy", + "sha256": "d6fbd6ff5e4df60612121dbb56165860058333ea235fd45ca13b7cf58aa3119a", + "size": 29650, + "subdir": "linux-64", + "timestamp": 1545166792208, + "version": "2.0.1" + }, + "pastedeploy-2.0.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0538a763885c884e7117edf4aedfab41", + "name": "pastedeploy", + "sha256": "f20bef22efc200d8758c69360b7df2d6872a1f0cbf84adf3fa12ecc928913a83", + "size": 268169, + "subdir": "linux-64", + "timestamp": 1613160048009, + "version": "2.0.1" + }, + "pastedeploy-2.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "088cf12b23b463fa5dedfffcd9612e79", + "name": "pastedeploy", + "sha256": "ab0eade313e804ccc8a3b8c14f9fef9959aff2ef1f89e247246ee449b67f601f", + "size": 29698, + "subdir": "linux-64", + "timestamp": 1545166790640, + "version": "2.0.1" + }, + "pastedeploy-2.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a5f89915e7a588238441c7e74aef639e", + "name": "pastedeploy", + "sha256": "44dbf9eb3f9c8cc485e3fb0a935bcc9a93f6c76faa20f019fbdc00ff839a6b65", + "size": 268705, + "subdir": "linux-64", + "timestamp": 1613160043223, + "version": "2.0.1" + }, + "pastedeploy-2.0.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ddef40aaa9d949c73bfdd38113b9876", + "name": "pastedeploy", + "sha256": "66d7f7a95e2456a4508e0a07603b5dfdf90f90e640691b533d90f09d99bd33e6", + "size": 30092, + "subdir": "linux-64", + "timestamp": 1574355278108, + "version": "2.0.1" + }, + "pastedeploy-2.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "045e04392a50bd60cc87b42f4a380e96", + "name": "pastedeploy", + "sha256": "4bb5dc014a691ccb4a98c20881f9238defbd5083501c60e9eccf4a564abff54a", + "size": 269048, + "subdir": "linux-64", + "timestamp": 1613159689292, + "version": "2.0.1" + }, + "pastedeploy-2.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b3fd93e72727c714ddf36ca91334b20e", + "name": "pastedeploy", + "sha256": "bdb22449f4b1681b91c927616f66ee63466544bebc78f0cc49b6be27bf3dac06", + "size": 268444, + "subdir": "linux-64", + "timestamp": 1613159582761, + "version": "2.0.1" + }, + "patch-2.7.5-h5000ff1_0.conda": { + "build": "h5000ff1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "a2378823a03d0f4cf7c36896d6b0e371", + "name": "patch", + "sha256": "2d4b988a08ae0d082f9384c7cdcb4a1770734f7dd6410872b7395e3437c6c383", + "size": 116757, + "subdir": "linux-64", + "timestamp": 1505747276104, + "version": "2.7.5" + }, + "patch-2.7.6-h1bed415_0.conda": { + "build": "h1bed415_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "d609766ee7bdf897fd6d454c0a1ba9c5", + "name": "patch", + "sha256": "0c3e3a6fab5457c5201e957ce813373bf53994f4c7c6a930382380e74d615543", + "size": 124726, + "subdir": "linux-64", + "timestamp": 1524180098707, + "version": "2.7.6" + }, + "patch-2.7.6-h7b6447c_1001.conda": { + "build": "h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL 3", + "md5": "5a47ace7ef08447fe6a602ff16129393", + "name": "patch", + "sha256": "eadc5b8a783adba6c0d39d2f270b180632f22d4330c93a5700b1bddc01905216", + "size": 122130, + "subdir": "linux-64", + "timestamp": 1573953235116, + "version": "2.7.6" + }, + "patchelf-0.10-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL 3", + "md5": "c221a2b56a120705a6adfbd0ed9cbb27", + "name": "patchelf", + "sha256": "0e9de7eba8c41bd540a4ea68d98f0e681d98675906dd73cd8a332869fad85c44", + "size": 76147, + "subdir": "linux-64", + "timestamp": 1573939748444, + "version": "0.10" + }, + "patchelf-0.11-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0-or-later", + "md5": "624b4b34c3a37bf9700c198c6f979db9", + "name": "patchelf", + "sha256": "82aee429dcf95f8b2dc6b62a7f7978c4ddc7fef8d6e9a5f769c50fab014bf429", + "size": 77297, + "subdir": "linux-64", + "timestamp": 1605302153390, + "version": "0.11" + }, + "patchelf-0.11-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0-or-later", + "md5": "2c137fd8e1d5f3c3aa1d77c5782d6f0a", + "name": "patchelf", + "sha256": "8e09dc04b1e9802bad45152153206a4e7cc1c2231650ddca22637f15de5c9df0", + "size": 76897, + "subdir": "linux-64", + "timestamp": 1592415053365, + "version": "0.11" + }, + "patchelf-0.12-h2531618_1.conda": { + "build": "h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0-or-later", + "md5": "9f60c3a6d4d86a25197f5bf25b091d45", + "name": "patchelf", + "sha256": "7cff9b74ea07c97a65974466adf71da9049c0885befc4e1d1154a1e4527ac6b4", + "size": 90019, + "subdir": "linux-64", + "timestamp": 1607736113848, + "version": "0.12" + }, + "patchelf-0.12-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL-3.0-or-later", + "md5": "e8a297fdeee6c3f6b90012978495cffc", + "name": "patchelf", + "sha256": "0abe9a36e14d36c88c9e9ffd7cf0ca89b25f34a2afc05f29709658e6033567c0", + "size": 84685, + "subdir": "linux-64", + "timestamp": 1602272538593, + "version": "0.12" + }, + "patchelf-0.13-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "GPL-3.0-or-later", + "md5": "546bd64a8cbb7d261fd1e5236cac9369", + "name": "patchelf", + "sha256": "301dcada573a92c860d3deb5669fd9ac211c37cf66f24c5492ef228ed1aa8f85", + "size": 87228, + "subdir": "linux-64", + "timestamp": 1631287810666, + "version": "0.13" + }, + "patchelf-0.15.0-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "4c54bc27f243adff7dd838253bf832ef", + "name": "patchelf", + "sha256": "a9def184e7334e956d30f6462bcf613b69ad4ee9248809f4fcb08e9061952788", + "size": 98817, + "subdir": "linux-64", + "timestamp": 1669245116075, + "version": "0.15.0" + }, + "patchelf-0.17.2-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "63ad6ea1e47f568a1bdb5edb66734026", + "name": "patchelf", + "sha256": "b9f23d21314cbb1657a8058913d4074c0c1f28bac66573e899085ec820a8200c", + "size": 100532, + "subdir": "linux-64", + "timestamp": 1675208106638, + "version": "0.17.2" + }, + "patchelf-0.9-he6710b0_3.conda": { + "build": "he6710b0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "GPL 3", + "md5": "9483f9ef5b81b9aa298d42471c84e949", + "name": "patchelf", + "sha256": "7e9278d43ebc782ec473a9e8397e28f768569d1e288f1fec162b609e0d6d6ef7", + "size": 69467, + "subdir": "linux-64", + "timestamp": 1539357188942, + "version": "0.9" + }, + "patchelf-0.9-hf484d3e_2.conda": { + "build": "hf484d3e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "6ffe8cc946b421b4d938cebff483d93f", + "name": "patchelf", + "sha256": "0475c621dcc9360eb1c95cf659b8c94dfa0172824c2f0afd26110f5c49125880", + "size": 66460, + "subdir": "linux-64", + "timestamp": 1530813663930, + "version": "0.9" + }, + "patchelf-0.9-hf79760b_2.conda": { + "build": "hf79760b_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "GPL 3", + "md5": "43ca45100f5413ac309c4ef5ad6a36d1", + "name": "patchelf", + "sha256": "392289b547a1ad2c13987a9f4a30b1a70738675dd59612cf7aee64d27609f612", + "size": 67493, + "subdir": "linux-64", + "timestamp": 1505742063357, + "version": "0.9" + }, + "path-13.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "41d99094e453e972080ce34b916d876c", + "name": "path", + "sha256": "f86f8e2fb97051c673fd8fbddf2b836b13f4b6b7cf81763a78e7bd063022044b", + "size": 35403, + "subdir": "linux-64", + "timestamp": 1576515154502, + "version": "13.1.0" + }, + "path-13.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f15bf62c672e8684b6f4aafd48c780e2", + "name": "path", + "sha256": "69b7e874611b7c845de29981ba4843ac2d223e9be1582b4bef49c0c2cf160715", + "size": 35910, + "subdir": "linux-64", + "timestamp": 1576515171745, + "version": "13.1.0" + }, + "path-13.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "72cc1265aeeb17a755a3e6b3026b0c19", + "name": "path", + "sha256": "ac16b55513b66e97490709be22db82a382971b872a958bcd15e4ad01390f5557", + "size": 35633, + "subdir": "linux-64", + "timestamp": 1576515224748, + "version": "13.1.0" + }, + "path-13.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "44de50c533f1eebb905d2508608727b5", + "name": "path", + "sha256": "9f7451a2096bc4da7776d564980c804c351dcd0f8a4066d11e7b4d1e7215e6d0", + "size": 36618, + "subdir": "linux-64", + "timestamp": 1585316285296, + "version": "13.2.0" + }, + "path-13.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f09dd8a6f62f20d60d37e35d137ab21c", + "name": "path", + "sha256": "65a95583adda8d7dd1a053d2c944823422f78e3e5c81ee2e8fa621ffe913b4d5", + "size": 36739, + "subdir": "linux-64", + "timestamp": 1585316332572, + "version": "13.2.0" + }, + "path-13.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3b6ddee54a19432816f85aa176a34e0", + "name": "path", + "sha256": "2483c74bcd2762f149e7a61a1d413bb0ff1260422ebbb8a9f27f8f400997ae72", + "size": 36860, + "subdir": "linux-64", + "timestamp": 1585316365159, + "version": "13.2.0" + }, + "path-14.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb697e0eb4408b841b02e4933498095e", + "name": "path", + "sha256": "08918fce2d700500f4f92dbbdc8585ab31868a9c44a0597e683ba6dd2a6f15e5", + "size": 39333, + "subdir": "linux-64", + "timestamp": 1592331199331, + "version": "14.0.1" + }, + "path-14.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2f27f7e7396e1cded389f8d4a9fc0cb", + "name": "path", + "sha256": "f4e160345796592788e7dd5a3be411317b5dd93baaec205f8b102ab67a869b69", + "size": 39435, + "subdir": "linux-64", + "timestamp": 1592331198807, + "version": "14.0.1" + }, + "path-14.0.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64fe7bcb72c55e5dc6c20c9a1bb0f235", + "name": "path", + "sha256": "d54269f3d1fe8afd8116a87ff4111c22eee134204a43b1a6dab1b87b17774653", + "size": 39071, + "subdir": "linux-64", + "timestamp": 1592331166810, + "version": "14.0.1" + }, + "path-15.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b868341e005b416f67ddb09bbbcad79", + "name": "path", + "sha256": "8c239c7b22970b70b83d6f95439ea09624227bdbd5fc95fca2b914db46d4e6ee", + "size": 39017, + "subdir": "linux-64", + "timestamp": 1598376517166, + "version": "15.0.0" + }, + "path-15.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01e3eb9c7c321959c587ad23a395d098", + "name": "path", + "sha256": "2ff6e4d1e4e485e2edd6274d6a41752fbed08115e90134a8cbe823283ba15c57", + "size": 37090, + "subdir": "linux-64", + "timestamp": 1596907237237, + "version": "15.0.0" + }, + "path-15.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e36938fbd9aa27e8151650312984d77", + "name": "path", + "sha256": "8534fe16827cea3ed8a035b0d4e4d9d60d37e7ba03e36749d41f2a52d1ddd6d9", + "size": 39325, + "subdir": "linux-64", + "timestamp": 1598376541054, + "version": "15.0.0" + }, + "path-15.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "09af98a7ace0431e248ee43274451a8b", + "name": "path", + "sha256": "4d4b527b8cdd87678ce338f1d7ab0e830f52f8acf6c13dac94d135d17687d98e", + "size": 39281, + "subdir": "linux-64", + "timestamp": 1607027120950, + "version": "15.0.0" + }, + "path-15.0.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9be32948eee64c3ca0b72a43d888571", + "name": "path", + "sha256": "2a3139b4a5b268b9f7aa17d76620b83a9d37d1d245de7c40300c64ea70a52ec0", + "size": 38179, + "subdir": "linux-64", + "timestamp": 1607537266102, + "version": "15.0.1" + }, + "path-15.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15231e66eee7dd3b364b057ec2b57786", + "name": "path", + "sha256": "8601c886a76a084a57745f38a0b7e31d3e12e29353df27e4a20af09d57141eab", + "size": 37824, + "subdir": "linux-64", + "timestamp": 1607537257215, + "version": "15.0.1" + }, + "path-15.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ffe145366c55af9ad134168352abe73", + "name": "path", + "sha256": "fc2f5ca06eebfec4805f59a0223d5a17ed9ab5668ae40feaf8d0b256e7146f17", + "size": 38424, + "subdir": "linux-64", + "timestamp": 1607537263633, + "version": "15.0.1" + }, + "path-15.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a6fd17ce8ff3856e04c7f792d41b47b", + "name": "path", + "sha256": "e08849f1e6fde2c41d5761bcb40262e2c0945ac9e2c0b6c0cb01df5147a027ce", + "size": 37927, + "subdir": "linux-64", + "timestamp": 1607537225044, + "version": "15.0.1" + }, + "path-15.1.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3563224b7402ddc89ed8cf5a757ac448", + "name": "path", + "sha256": "26dd3d185e815e53d5af74b07f095269cd8e2494b73f059a15bd1c0879fc76e3", + "size": 37849, + "subdir": "linux-64", + "timestamp": 1611952384575, + "version": "15.1.0" + }, + "path-15.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c912fa04f2e9e584e12ceafdb55ff6bc", + "name": "path", + "sha256": "66e4bd05fb3a0088d52a8b60b0f1c2111cb9b485368df769c1c48735f2c33b32", + "size": 37968, + "subdir": "linux-64", + "timestamp": 1611952370728, + "version": "15.1.0" + }, + "path-15.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f2886f70faa8e3a6cecd8c8c839b331", + "name": "path", + "sha256": "843639da2d4d305e4119602872e0747c6e68176e7ef48d706f960469c4f85fc3", + "size": 38413, + "subdir": "linux-64", + "timestamp": 1611952403087, + "version": "15.1.0" + }, + "path-15.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a37e2fd3b6cc5871194c9b3ced69af10", + "name": "path", + "sha256": "c12940920488a52f8d28e959d7324f8bb164e528a6f95aae64bb7ce5764eeeda", + "size": 38608, + "subdir": "linux-64", + "timestamp": 1611952414004, + "version": "15.1.0" + }, + "path-15.1.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0abea30e031a585431d242b74ead05b1", + "name": "path", + "sha256": "9a13abcaecb077c27cf1f7b59a6cbbe2069b39dffef2b263c0133859557f6550", + "size": 37930, + "subdir": "linux-64", + "timestamp": 1613935753928, + "version": "15.1.1" + }, + "path-15.1.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d5a7a10b6f936de63099c23676982a38", + "name": "path", + "sha256": "aa306a98ce83e40a35714f63faf46e2071567ba3e5e40211b0de211388fe469e", + "size": 38266, + "subdir": "linux-64", + "timestamp": 1613935750981, + "version": "15.1.1" + }, + "path-15.1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fbfe4b36f14e3aef1bde91d805f778d9", + "name": "path", + "sha256": "69e4f4ee0aa18e8c3809a69e32391505d9aff2809e2b32376ffe2d38c5d0f803", + "size": 38073, + "subdir": "linux-64", + "timestamp": 1613935765371, + "version": "15.1.1" + }, + "path-15.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ecf49b621f481a2486d71a01995a882", + "name": "path", + "sha256": "75ed2117156a74f901cafc07b6ebb3d7ea373d735b5b8bd71df5f639faeaaf35", + "size": 38487, + "subdir": "linux-64", + "timestamp": 1613934905572, + "version": "15.1.1" + }, + "path-15.1.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "97bd3733220ae4f0c267832ca46c7618", + "name": "path", + "sha256": "082d57576329edcc0f566ca5645ca5ffda9e24cc2d31665ebf916c0f3ad17ee5", + "size": 37800, + "subdir": "linux-64", + "timestamp": 1614022264613, + "version": "15.1.2" + }, + "path-15.1.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f0e28df3e3048fa370dc93d8930b0161", + "name": "path", + "sha256": "2bd7996554ed970401fc6a1ee4bfac55be6198bbf0f35b8997d8e442fa1e6b74", + "size": 38272, + "subdir": "linux-64", + "timestamp": 1614022253169, + "version": "15.1.2" + }, + "path-15.1.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f50335fbb0444ab745cdb1405783e4fa", + "name": "path", + "sha256": "03999c5a2334a2aa09dbe3ec4a25ec7439815207482d7126e1a3cc3b457befb0", + "size": 38390, + "subdir": "linux-64", + "timestamp": 1614022254139, + "version": "15.1.2" + }, + "path-15.1.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37a86e15b5ab9966b5046f0856347c5d", + "name": "path", + "sha256": "595efac9e9dedf1f227d30d50a76360f108cdb00a92f20c79ab2aeb97aff61a3", + "size": 38184, + "subdir": "linux-64", + "timestamp": 1614022253105, + "version": "15.1.2" + }, + "path-16.0.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4715e5dfd67a9efcd40fd10880a9223", + "name": "path", + "sha256": "d7b973693e5804f731f71d7cb6ef2128094c767e2296226163c34cfbf8bf3f6b", + "size": 37550, + "subdir": "linux-64", + "timestamp": 1623603921621, + "version": "16.0.0" + }, + "path-16.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4938a0127c9680dc31f2eaa27c4f8148", + "name": "path", + "sha256": "89905dfa819fbf6248fa8e91947ea0d9726327393774df6a7078360d61e88c0e", + "size": 38145, + "subdir": "linux-64", + "timestamp": 1623598197165, + "version": "16.0.0" + }, + "path-16.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4deabd83643f46825c557e20a2de036", + "name": "path", + "sha256": "2b8da11a0de61089b71af7e78b583939e729457dbd628bc83bdc68e543b4303d", + "size": 37695, + "subdir": "linux-64", + "timestamp": 1623603900649, + "version": "16.0.0" + }, + "path-16.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb06546cd88963dc7c76ba6ee77b1503", + "name": "path", + "sha256": "b51961ecbc767236214365d1f1f3edd57fc5d11d0d9a4e6b199b79c17a3d5289", + "size": 38272, + "subdir": "linux-64", + "timestamp": 1623603444292, + "version": "16.0.0" + }, + "path.py-10.3.1-py27hc258cac_0.conda": { + "build": "py27hc258cac_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "02460f873cc8c1089440cdb0688f80ce", + "name": "path.py", + "sha256": "b38adc42c25cd1c6139d80972a13fe051633f72d0aef6798573759a278c57f55", + "size": 51525, + "subdir": "linux-64", + "timestamp": 1505747289147, + "version": "10.3.1" + }, + "path.py-10.3.1-py35hb82cfee_0.conda": { + "build": "py35hb82cfee_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "d6c616061e32046f26b51606139f80c7", + "name": "path.py", + "sha256": "6cb08408e8a68bf85a56af05502068550e71c07025823a88144a704d5a823476", + "size": 52400, + "subdir": "linux-64", + "timestamp": 1505747301722, + "version": "10.3.1" + }, + "path.py-10.3.1-py36he0c6f6d_0.conda": { + "build": "py36he0c6f6d_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a1fdd7774abeb41e124b27b00ff8f005", + "name": "path.py", + "sha256": "980eb1ecadb8838c881fa82f065f43724741d82eb72e79bd98d4d3299c3e3768", + "size": 52529, + "subdir": "linux-64", + "timestamp": 1505747314417, + "version": "10.3.1" + }, + "path.py-10.5-py27hefe4bee_0.conda": { + "build": "py27hefe4bee_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "cabcfe82d7a661d4fa44d5dcfdb2846e", + "name": "path.py", + "sha256": "61c6803b25bb67dc887609df3c7d52265994c0c59bc84f8367b23383f8d919e0", + "size": 52117, + "subdir": "linux-64", + "timestamp": 1511835103535, + "version": "10.5" + }, + "path.py-10.5-py35h39c98c1_0.conda": { + "build": "py35h39c98c1_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "ebec0ebea1b50ae1e9ae120bda82176a", + "name": "path.py", + "sha256": "e69cf090b39beb9e951a18516d3ca1f0af0962d9bb1e3ec898b5cdc7fec0c3ee", + "size": 54137, + "subdir": "linux-64", + "timestamp": 1511835112475, + "version": "10.5" + }, + "path.py-10.5-py36h55ceabb_0.conda": { + "build": "py36h55ceabb_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a182090a9a700bc9d60ad5f101ec555a", + "name": "path.py", + "sha256": "faf8a2ab2aed267a52c525817059a41ebe44701e18ac44639200f26c82ff0aee", + "size": 53502, + "subdir": "linux-64", + "timestamp": 1511835113517, + "version": "10.5" + }, + "path.py-11.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "8b9bbf3ee2741fd7747bf51af3b114d1", + "name": "path.py", + "sha256": "b7469164fb30888c3674afe7aeb9fea4d055f6ea6f06095d7f0e023ad60bc133", + "size": 53110, + "subdir": "linux-64", + "timestamp": 1519067206640, + "version": "11.0" + }, + "path.py-11.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "c7fbc4d0181f85e47d19c5ee7f17cc1a", + "name": "path.py", + "sha256": "59212b9e321d1824be90f35bedbc6dd60a667ca365401fa29a70da294b6ce6c1", + "size": 53889, + "subdir": "linux-64", + "timestamp": 1519067234606, + "version": "11.0" + }, + "path.py-11.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e13cd5f090d9aa32d750060f906f310a", + "name": "path.py", + "sha256": "c4869ba06f4be64c7b1785e29f3ca2e39118add3ddb1073f37f14996dd4e4474", + "size": 53447, + "subdir": "linux-64", + "timestamp": 1519067233938, + "version": "11.0" + }, + "path.py-11.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c90105b4692f2b5b7f2804aecf6316e3", + "name": "path.py", + "sha256": "432b396c7ebecebc5d0ac763c758ac151d84a72f9d24427eeae80fcb43bfcda6", + "size": 53347, + "subdir": "linux-64", + "timestamp": 1522691281678, + "version": "11.0.1" + }, + "path.py-11.0.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "1d861ff490231fc6f90b94af8ad554c5", + "name": "path.py", + "sha256": "7009b3ee0a2cffe3e4fe008f095a220179ab9348c2c7640223242b15ce9de682", + "size": 53936, + "subdir": "linux-64", + "timestamp": 1522691381956, + "version": "11.0.1" + }, + "path.py-11.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c4d01c0e7460ccf6f93ad095d703006d", + "name": "path.py", + "sha256": "fe7339f9189dcfd5fe81b94e6de3683d13ed2fd6d5ef32f81706163bba29af71", + "size": 54207, + "subdir": "linux-64", + "timestamp": 1522691386144, + "version": "11.0.1" + }, + "path.py-11.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c0da5d51480905039478af699d74daf1", + "name": "path.py", + "sha256": "002b628a7f6be056cabb41263f59d383b61669b8319996c5ebaefdb82e70552e", + "size": 53652, + "subdir": "linux-64", + "timestamp": 1530904864039, + "version": "11.0.1" + }, + "path.py-11.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "4d9db83ae10c988640df491c6d1d543c", + "name": "path.py", + "sha256": "d6122f160a73e8f021ea766ad02f56e5682779920277953bf3b84dae061677cb", + "size": 53765, + "subdir": "linux-64", + "timestamp": 1536078153768, + "version": "11.1.0" + }, + "path.py-11.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "83be042964cf8a45b835ebd6d2b50211", + "name": "path.py", + "sha256": "fd1068e8e17607359b26a2e396c9fee0c590b5d7c18f95f18d10d89652c1c6f6", + "size": 54301, + "subdir": "linux-64", + "timestamp": 1536078175267, + "version": "11.1.0" + }, + "path.py-11.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "5e6f92b5c6d2cfa7f79de1ffc0d96f79", + "name": "path.py", + "sha256": "1fe344871fbd3f3b093628980ffc51c856f25ff5687856d6adde0f9d56d42637", + "size": 53862, + "subdir": "linux-64", + "timestamp": 1536078111972, + "version": "11.1.0" + }, + "path.py-11.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f2fc11c0a6eeeb56a012446a5d92e1e9", + "name": "path.py", + "sha256": "1846a73ba14efef8c7b263c2ee3d279f6bdf6264dcc91ed73a5cbb24f974a6cd", + "size": 54212, + "subdir": "linux-64", + "timestamp": 1536078174085, + "version": "11.1.0" + }, + "path.py-11.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.os", + "importlib_metadata >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "55813147f44510d9ceeadf8cad8513e3", + "name": "path.py", + "sha256": "e5288a0c00638f06840b958ce622ab2af6923eef71d7a5fc01f7593b62d7fa2d", + "size": 55544, + "subdir": "linux-64", + "timestamp": 1539704237344, + "version": "11.5.0" + }, + "path.py-11.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "backports.os", + "importlib_metadata >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9d68b006c5dc85fdae14402cdad9c706", + "name": "path.py", + "sha256": "7a21980d7462d3b511063864d4c3a93562eef37abdd6d2a42bf7f5a06964de47", + "size": 56487, + "subdir": "linux-64", + "timestamp": 1539703409465, + "version": "11.5.0" + }, + "path.py-11.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "backports.os", + "importlib_metadata >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "afdec4b8405d88743e2d84c8bce4a3b7", + "name": "path.py", + "sha256": "c93bfc6df302891e3ecc20a22113b0a09844a029a5e02021bdf3115656925887", + "size": 57619, + "subdir": "linux-64", + "timestamp": 1539704277974, + "version": "11.5.0" + }, + "pathlib-1.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a9e08f2c189c30b9a08956e96f1ba3a", + "name": "pathlib", + "sha256": "821efd25a4bd2ed570b9ebac60ceceb15a75d493fc8f7915bd5c7dd5b4b124f4", + "size": 29736, + "subdir": "linux-64", + "timestamp": 1531088626342, + "version": "1.0.1" + }, + "pathlib-1.0.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e801773af0d1419a5293fe5120572adc", + "name": "pathlib", + "sha256": "c1212601dbbd10962e526d6a5b15b41db60d4dd7c150c0d4daa58976c0c983e3", + "size": 29635, + "subdir": "linux-64", + "timestamp": 1539187056033, + "version": "1.0.1" + }, + "pathlib-1.0.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "372eec4061728adeec7756ad436b780e", + "name": "pathlib", + "sha256": "d4dea0d716d81be992af927cb97b27982d20f890ecd182a104549466c4095bd2", + "size": 30089, + "subdir": "linux-64", + "timestamp": 1539187066880, + "version": "1.0.1" + }, + "pathlib-1.0.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "718f8e4f50f3727931a4ea8c378924c8", + "name": "pathlib", + "sha256": "5bb749edecbdf518902a2d247f69d98433599925fc420911fae971b07eca0724", + "size": 29868, + "subdir": "linux-64", + "timestamp": 1539187068635, + "version": "1.0.1" + }, + "pathlib-1.0.1-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "501e1f76582fde2d96820eab9fd9e77a", + "name": "pathlib", + "sha256": "96def71b3abda73517bf755abcc62f81fdcdb2d351b85b79e7a0c6eb9244c56d", + "size": 3860, + "subdir": "linux-64", + "timestamp": 1594381414622, + "version": "1.0.1" + }, + "pathlib2-2.3.0-py27h6e9d198_0.conda": { + "build": "py27h6e9d198_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "scandir", + "six" + ], + "license": "MIT", + "md5": "0256e024193f9ea5c8f43ab7bc0476ce", + "name": "pathlib2", + "sha256": "33eea628559844e8448c99ac53e0a06c8e5187f6e3a8a24665dd95f1b920aaa4", + "size": 33106, + "subdir": "linux-64", + "timestamp": 1505688567061, + "version": "2.3.0" + }, + "pathlib2-2.3.0-py35hd637de4_0.conda": { + "build": "py35hd637de4_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "9e904670a8c3ec6d9a0d639902a9888b", + "name": "pathlib2", + "sha256": "175de0900ecccdab7a7eee9372f75d92e75fc39f13b0ee7eab1871b6cc0f720d", + "size": 34078, + "subdir": "linux-64", + "timestamp": 1505688577838, + "version": "2.3.0" + }, + "pathlib2-2.3.0-py36h49efa8e_0.conda": { + "build": "py36h49efa8e_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "931f968530e34c45031d6d62aa0f5106", + "name": "pathlib2", + "sha256": "54b78ff1b4a6f9bc864b8479ae6f2e5b04cdf6e69dec7f952162526fba2eb57c", + "size": 33499, + "subdir": "linux-64", + "timestamp": 1505688588892, + "version": "2.3.0" + }, + "pathlib2-2.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "scandir", + "six" + ], + "license": "MIT", + "md5": "b7d1aa120fb3dd846cb584954faa1390", + "name": "pathlib2", + "sha256": "6aface5b6de5c7a192ae9ae623d6b549a045591e38ff9cee6b87d395abbfc407", + "size": 33126, + "subdir": "linux-64", + "timestamp": 1524228904691, + "version": "2.3.2" + }, + "pathlib2-2.3.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "5f8efab06ca4eada425dbb0d97f29296", + "name": "pathlib2", + "sha256": "2c3f9d82eca36f43ba7e9b9da5ea22ba3161291f78a95e522efea657221996d0", + "size": 33992, + "subdir": "linux-64", + "timestamp": 1524228959014, + "version": "2.3.2" + }, + "pathlib2-2.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "761336a381937df532feadead5e39435", + "name": "pathlib2", + "sha256": "bb810a5e73ea018cd9441c1dd6b87dadce6a13fdb102c953e574b69e63ebc583", + "size": 33565, + "subdir": "linux-64", + "timestamp": 1524228958716, + "version": "2.3.2" + }, + "pathlib2-2.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "235fa0f7eaf7a6c3430e0e771910bb99", + "name": "pathlib2", + "sha256": "c86e61257f3c6793f63aa3e524ef593012823f9b112b17185c1b63d68056c2f5", + "size": 34089, + "subdir": "linux-64", + "timestamp": 1530735374606, + "version": "2.3.2" + }, + "pathlib2-2.3.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "scandir", + "six" + ], + "license": "MIT", + "md5": "b1dcd110819ffc5e823774c0c841d34a", + "name": "pathlib2", + "sha256": "a25a3043b60011310b4c0fc8032c1dc9e28c0b1d7e462e7bd098fc7c6f61342e", + "size": 33248, + "subdir": "linux-64", + "timestamp": 1545075901250, + "version": "2.3.3" + }, + "pathlib2-2.3.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "3482b50d2953499530199b3648c36de2", + "name": "pathlib2", + "sha256": "0bb6a23af143d9ab43b62f80ee8191f1fb470b012ddfbd944d70399d7567311c", + "size": 33678, + "subdir": "linux-64", + "timestamp": 1545075939285, + "version": "2.3.3" + }, + "pathlib2-2.3.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "04203959a437b2c46bbf2a8dc3c97dca", + "name": "pathlib2", + "sha256": "5f3e0a39dbd128e2ba8a85dd6621b65ad511bc88db14a8063a530bff8fbbea1e", + "size": 34297, + "subdir": "linux-64", + "timestamp": 1545075940918, + "version": "2.3.3" + }, + "pathlib2-2.3.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "scandir", + "six" + ], + "license": "MIT", + "md5": "3fffe2f9a4aaae2469b3aeadd22f5702", + "name": "pathlib2", + "sha256": "c0e7d48c21649271b89ae5e9682fa0edb932e2108b09fb8b2088e65d162517f2", + "size": 37697, + "subdir": "linux-64", + "timestamp": 1562085533512, + "version": "2.3.4" + }, + "pathlib2-2.3.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "0f7276755c9b635521c5e57bc6b16b42", + "name": "pathlib2", + "sha256": "669cdbcd3fa614eba39aaa5f8fe0a3d63df34640dbcbe709e1211a16b5f44a90", + "size": 38074, + "subdir": "linux-64", + "timestamp": 1562085530712, + "version": "2.3.4" + }, + "pathlib2-2.3.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "caa100382365f5c6050874fb3619cb47", + "name": "pathlib2", + "sha256": "51ceeb230db8b83a2d6b02f2457e1180030f573bd68d7ed9453225fc2bf061cc", + "size": 38119, + "subdir": "linux-64", + "timestamp": 1562085495388, + "version": "2.3.4" + }, + "pathlib2-2.3.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "scandir", + "six" + ], + "license": "MIT", + "md5": "9500032ca935a8c1d3776f2b7b1d71d5", + "name": "pathlib2", + "sha256": "89acfe76cc9211c4a77552afc5dbc4250225d2a867eaf16c3b9df86edeceec84", + "size": 37686, + "subdir": "linux-64", + "timestamp": 1569855091937, + "version": "2.3.5" + }, + "pathlib2-2.3.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "0633761a53d4bfecd0ca69c56eb09347", + "name": "pathlib2", + "sha256": "61b4c91a31b780b1f16d604dfd0eb25a7efa3102a96e01f6656e384cc8c4d043", + "size": 37987, + "subdir": "linux-64", + "timestamp": 1569855095642, + "version": "2.3.5" + }, + "pathlib2-2.3.5-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "a3502ad91c8d8ea6b1ad638471d1b015", + "name": "pathlib2", + "sha256": "9a51930c6b94b9eafa2eefc0cdb9cf066d3ee4c1cc1cac0c9198c0485a96dbec", + "size": 37930, + "subdir": "linux-64", + "timestamp": 1607024988505, + "version": "2.3.5" + }, + "pathlib2-2.3.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "b587365a9adab71a6afb781b137d0d3a", + "name": "pathlib2", + "sha256": "82b2f96215d24c842ffbc42756314947aa574c99596cbe9ddf4c75ae59510170", + "size": 38220, + "subdir": "linux-64", + "timestamp": 1569855086726, + "version": "2.3.5" + }, + "pathlib2-2.3.5-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "0c9d5b58487fdba01d05c080fc76963f", + "name": "pathlib2", + "sha256": "7235be32303220f715d44aca1fcd213f7d30d208869bcf82c36f89134d70cb5b", + "size": 35799, + "subdir": "linux-64", + "timestamp": 1594380999505, + "version": "2.3.5" + }, + "pathlib2-2.3.5-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "aec55a7585dbed9d9f3c5c9bc9ba65c9", + "name": "pathlib2", + "sha256": "4ba4fe47c7758785dba3cef123e2f954bc410c878f48595cf28b970b66b55574", + "size": 38419, + "subdir": "linux-64", + "timestamp": 1607025004893, + "version": "2.3.5" + }, + "pathlib2-2.3.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "md5": "ad56f29e969effeb3cadbdd1ea3e6251", + "name": "pathlib2", + "sha256": "3ce26804bdbbd537cce1415cadd28420b234eed5abfd3b1256c92e46507d8794", + "size": 36829, + "subdir": "linux-64", + "timestamp": 1573738466914, + "version": "2.3.5" + }, + "pathlib2-2.3.5-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "md5": "09a39e9f97b28c4a6b7739b0ac05f22a", + "name": "pathlib2", + "sha256": "5dde06736f3583471cc77b90661d748d9565aeab026133ac7ada0edf7848566a", + "size": 38651, + "subdir": "linux-64", + "timestamp": 1607025015486, + "version": "2.3.5" + }, + "pathlib2-2.3.5-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "md5": "ad33f9e6a58229d49f42f8ec531918ea", + "name": "pathlib2", + "sha256": "7c104d24a474915a153fcea2222708151adb32af12bcf8d57079669c01d3df63", + "size": 38263, + "subdir": "linux-64", + "timestamp": 1607024979439, + "version": "2.3.5" + }, + "pathlib2-2.3.6-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f61c31ae50643f765b029b0b0607c76", + "name": "pathlib2", + "sha256": "299b5feb60f3f30d690e6deb3f55ea9e07be2b49f798bd9f2fcf8c9e3d59090a", + "size": 37246, + "subdir": "linux-64", + "timestamp": 1640792253378, + "version": "2.3.6" + }, + "pathlib2-2.3.6-py311h06a4308_2.conda": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a73870d8f18546788c32eb27c17ebf7", + "name": "pathlib2", + "sha256": "a168e60675d88a5eddb9d290dabfa49fcb9c1cf11ae3811b16e0e9b100b09e09", + "size": 48418, + "subdir": "linux-64", + "timestamp": 1676841608362, + "version": "2.3.6" + }, + "pathlib2-2.3.6-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1cc482957a1516f0b3612677a459c170", + "name": "pathlib2", + "sha256": "06fad5f2bd181db73d7d70ad9b89d6aba08a1c4cccf3f02b05c18dd3f7a30d9f", + "size": 36897, + "subdir": "linux-64", + "timestamp": 1625585351481, + "version": "2.3.6" + }, + "pathlib2-2.3.6-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95a682aaec46af7937e53fd3e4e21a09", + "name": "pathlib2", + "sha256": "2f0c5a84fdcc7163abd0cf101db08c3748b5e76a7101a81369cf6f8a7f68002b", + "size": 36926, + "subdir": "linux-64", + "timestamp": 1625578972879, + "version": "2.3.6" + }, + "pathlib2-2.3.6-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc53e7463ac650b4568e7356c5d1e938", + "name": "pathlib2", + "sha256": "fb7505507d99517970d86ac683cfc2ed8ce3b14b6edd37ecc4c0ce4aa0f89242", + "size": 36662, + "subdir": "linux-64", + "timestamp": 1625585703464, + "version": "2.3.6" + }, + "pathlib2-2.3.6-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02df679f4abb9cb196a45048151a9f6a", + "name": "pathlib2", + "sha256": "b78590930eff43ad023a07ff7a1a724a2dae32e07fe03218a25477d0ee1da7be", + "size": 36702, + "subdir": "linux-64", + "timestamp": 1625585724675, + "version": "2.3.6" + }, + "pathspec-0.10.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "801ec405b191788df01b7a49c9a5449c", + "name": "pathspec", + "sha256": "5efc5cdb3a0bf2d653c9ba59454add36879597b179bdd1b05af81876ad240336", + "size": 49684, + "subdir": "linux-64", + "timestamp": 1674681590611, + "version": "0.10.3" + }, + "pathspec-0.10.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "16bcb1fb60ec142822e8f78b5a39ea00", + "name": "pathspec", + "sha256": "b58483b8fcac805c7be5abfbed74f4e2872a41c31dbf8ddd5d9e2851e2bd2656", + "size": 53355, + "subdir": "linux-64", + "timestamp": 1679337308390, + "version": "0.10.3" + }, + "pathspec-0.10.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "f24367099f2fb27e3cc1a12c41f1c4dd", + "name": "pathspec", + "sha256": "1b7143002e68cae0d4cce8362edea18b7e8318e3474ae74064ac37dd03b56ac5", + "size": 49307, + "subdir": "linux-64", + "timestamp": 1674681669753, + "version": "0.10.3" + }, + "pathspec-0.10.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "03a9978f01e6ca88daf3375d1117ff0d", + "name": "pathspec", + "sha256": "4eed26029d2720727c6e05803461c0bb8e40d992126ea4e4c0ed6a016fd80100", + "size": 48817, + "subdir": "linux-64", + "timestamp": 1674681643001, + "version": "0.10.3" + }, + "pathspec-0.10.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "45011d01d7be2ffb268edd36c9ea42e1", + "name": "pathspec", + "sha256": "186c994ed8b97f98cda09c7954e63d8cf8dc55462cfea7b3805958186c65739b", + "size": 48787, + "subdir": "linux-64", + "timestamp": 1674681616718, + "version": "0.10.3" + }, + "pathspec-0.9.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "15b0c0c87f9d7d9fe5245006bc4ecca8", + "name": "pathspec", + "sha256": "5870eebebb9a124d2f9d6b13707e30b80da3a4df092753df0377925fcc641052", + "size": 46764, + "subdir": "linux-64", + "timestamp": 1659627207596, + "version": "0.9.0" + }, + "pathspec-0.9.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "c607738d292e779ad506e3497988375f", + "name": "pathspec", + "sha256": "a9860a442a08f47e6654e1bcf71babdaf2cc45f1af2cc079e83dd61eeb2ef1a8", + "size": 55512, + "subdir": "linux-64", + "timestamp": 1676822816239, + "version": "0.9.0" + }, + "pathspec-0.9.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "f93f561ab8b0c5ce045149374a027c5e", + "name": "pathspec", + "sha256": "765e35ab9d43ed21273f5c8622669e3ddb6935f03591cae54a1f02be829cff1d", + "size": 46416, + "subdir": "linux-64", + "timestamp": 1659627152968, + "version": "0.9.0" + }, + "pathspec-0.9.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "b1d98bfb820feeb5d4601d63ed75817f", + "name": "pathspec", + "sha256": "5bd78bec14b0b53149a37f6d45cecf869a7630f90baf45f87f659b5b7c35992b", + "size": 46518, + "subdir": "linux-64", + "timestamp": 1659627229424, + "version": "0.9.0" + }, + "pathspec-0.9.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0", + "license_family": "Other", + "md5": "d5d0270f99341a1f944d4634e97cae34", + "name": "pathspec", + "sha256": "ce8e91bb0037063af01bec4c96d8239c39be31348adae9a73f22a7c8b6b061ea", + "size": 46449, + "subdir": "linux-64", + "timestamp": 1659627175364, + "version": "0.9.0" + }, + "pathy-0.10.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "smart_open >=5.2.1,<7.0.0", + "typer >=0.3.0,<1.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c9f72418cc8ee19e6f6d7ed5e88ed2d1", + "name": "pathy", + "sha256": "3708e5c61f9ee6b488c2a6d6880de8d45d41ab01b7d6b96d49174d1f7ef6ae7b", + "size": 88929, + "subdir": "linux-64", + "timestamp": 1674586021226, + "version": "0.10.1" + }, + "pathy-0.10.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "smart_open >=5.2.1,<7.0.0", + "typer >=0.3.0,<1.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fbb73c7c423a1375a87a86df346556ea", + "name": "pathy", + "sha256": "6186038714bf4535f6e054c3705aac7d7b51506320d14092180b40c9bcb67091", + "size": 112336, + "subdir": "linux-64", + "timestamp": 1676845119436, + "version": "0.10.1" + }, + "pathy-0.10.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "smart_open >=5.2.1,<7.0.0", + "typer >=0.3.0,<1.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "742a3ba4861e17c788f994ef3e11c46c", + "name": "pathy", + "sha256": "6a6d85d609807bd31f77eee2cc0f949d550b9ed6b0f14ea062bd0859188b2398", + "size": 87675, + "subdir": "linux-64", + "timestamp": 1674585969739, + "version": "0.10.1" + }, + "pathy-0.10.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "smart_open >=5.2.1,<7.0.0", + "typer >=0.3.0,<1.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a519c77f1cb3057743e8dabfc72a41b7", + "name": "pathy", + "sha256": "b06e8faabe886694ce176d540412d7f9adb78f2a1c7d9930499ac83eff2f04de", + "size": 88132, + "subdir": "linux-64", + "timestamp": 1674585943671, + "version": "0.10.1" + }, + "pathy-0.10.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "smart_open >=5.2.1,<7.0.0", + "typer >=0.3.0,<1.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1b010e5afdb8b8a02e1f28277b4ec20e", + "name": "pathy", + "sha256": "03f165850201b897c90a4fdde374c8c23c83eaa29d4162e878d176e9eb1f255f", + "size": 87945, + "subdir": "linux-64", + "timestamp": 1674585995548, + "version": "0.10.1" + }, + "pathy-0.6.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "smart_open >=5.0.0,<6.0.0", + "typer >=0.3.0,<1.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6b04e2265fa1641d8b5e3f4c4d6087bb", + "name": "pathy", + "sha256": "b4d8c8fc6e610542fb84c538d899d98c3e3ba44d3edcce8a315d1fcd5904724f", + "size": 74885, + "subdir": "linux-64", + "timestamp": 1651566281816, + "version": "0.6.1" + }, + "pathy-0.6.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "smart_open >=5.0.0,<6.0.0", + "typer >=0.3.0,<1.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3da9c275becc61ba9e696355be3ec7c7", + "name": "pathy", + "sha256": "c813af4318e878fef3c3d3e3035ad9cfbb87ba6863ddd0db62fccc698755cc2e", + "size": 73835, + "subdir": "linux-64", + "timestamp": 1651566312040, + "version": "0.6.1" + }, + "pathy-0.6.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "smart_open >=5.0.0,<6.0.0", + "typer >=0.3.0,<1.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ba139b3b47a28cc57da46da4014d9fd3", + "name": "pathy", + "sha256": "66089079ed320b8712af1cb1e084bcd0c0625ce0fbfdf5d1896204aaf24e86cf", + "size": 74435, + "subdir": "linux-64", + "timestamp": 1651566207206, + "version": "0.6.1" + }, + "pathy-0.6.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "smart_open >=5.0.0,<6.0.0", + "typer >=0.3.0,<1.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7493cc34806df7db8988de78a9a34fb1", + "name": "pathy", + "sha256": "210cf5c77cc391eb92bc77b245564516a70135bdc05557bcd14fd38e3a3d9bc2", + "size": 74338, + "subdir": "linux-64", + "timestamp": 1651566240562, + "version": "0.6.1" + }, + "patsy-0.4.1-py27hd1cf8c0_0.conda": { + "build": "py27hd1cf8c0_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=2.7,<2.8.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "2cd8d41f368e9254b59d9ef6480fc5e6", + "name": "patsy", + "sha256": "83ff86716a9c05413206494704502852666d6fa1f5ed2de9b3aa9224cfcdc8e6", + "size": 274956, + "subdir": "linux-64", + "timestamp": 1505750859899, + "version": "0.4.1" + }, + "patsy-0.4.1-py35h51b66d5_0.conda": { + "build": "py35h51b66d5_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.5,<3.6.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "aca71330c4275d545f7efb700b50c674", + "name": "patsy", + "sha256": "53bfcf0d4f628b75bfe299e06f9c6969f9224a54a00daf7e49ca9c4bb488f069", + "size": 279362, + "subdir": "linux-64", + "timestamp": 1505750875629, + "version": "0.4.1" + }, + "patsy-0.4.1-py36ha3be15e_0.conda": { + "build": "py36ha3be15e_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.6,<3.7.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "641c036554cd286ce98fc78669af1bb5", + "name": "patsy", + "sha256": "21349f74f866e70629e9e7e9f2bb3fdcf9de0c8421c61067a04b3a4b08febed4", + "size": 276265, + "subdir": "linux-64", + "timestamp": 1505750891697, + "version": "0.4.1" + }, + "patsy-0.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=2.7,<2.8.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "9b334ad58412263afba77d090723383a", + "name": "patsy", + "sha256": "99c7758f62e023ce5f9180aab1103b8eaf0ab3c4bdab295f5cecd77550475022", + "size": 280053, + "subdir": "linux-64", + "timestamp": 1515791337598, + "version": "0.5.0" + }, + "patsy-0.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.5,<3.6.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "97466f87253f37afe8e361c04b858a2d", + "name": "patsy", + "sha256": "093086a0f67adfbce0c928caf8317657885612daf5af30f111b66347b0274594", + "size": 278203, + "subdir": "linux-64", + "timestamp": 1515791501104, + "version": "0.5.0" + }, + "patsy-0.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.6,<3.7.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "3a5fc588081d5484013ee4f2c934b1b4", + "name": "patsy", + "sha256": "e7379bd3aea7bd7ca69f44be618e8073b2deebeb864f1c353bdb58d313328f3f", + "size": 280230, + "subdir": "linux-64", + "timestamp": 1515791277570, + "version": "0.5.0" + }, + "patsy-0.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.7,<3.8.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "0f1b43315bbb3fffbf60bfce1530b866", + "name": "patsy", + "sha256": "6338fd55b0d07f1bc6baa0089c2328693e6e498b257777a0f86e02cf0831d30b", + "size": 279906, + "subdir": "linux-64", + "timestamp": 1530904896409, + "version": "0.5.0" + }, + "patsy-0.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=2.7,<2.8.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "346affd09b49010a1c45da667edea18f", + "name": "patsy", + "sha256": "eb187cb0a793fd5f5da29136df16864931c7f3d851fc53e5692b7f15f6fd210a", + "size": 280459, + "subdir": "linux-64", + "timestamp": 1540996270545, + "version": "0.5.1" + }, + "patsy-0.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.6,<3.7.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "1dc52f8ec76ceff1307b8c86496a4845", + "name": "patsy", + "sha256": "174734c3f75073620af5b5d9d55704856edf22b0cefbdc8e5fc174af7a0df880", + "size": 281024, + "subdir": "linux-64", + "timestamp": 1540996289343, + "version": "0.5.1" + }, + "patsy-0.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.7,<3.8.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "9dd5353d8b99c527f66158cdadb89787", + "name": "patsy", + "sha256": "e5a6eb24349d5bd0215cdcc0da3143429c0dffc7603d3b2f4dc912924c628bae", + "size": 280235, + "subdir": "linux-64", + "timestamp": 1540996298710, + "version": "0.5.1" + }, + "patsy-0.5.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.8,<3.9.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "3fc7aa77bedd5a60263c6328928d6e59", + "name": "patsy", + "sha256": "7151bda0b0d4a8daddc96a060310dfe95785a19a37c4a6c03d7aec426a005071", + "size": 280376, + "subdir": "linux-64", + "timestamp": 1574355293115, + "version": "0.5.1" + }, + "patsy-0.5.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.9,<3.10.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause, PSF2", + "license_family": "BSD", + "md5": "83d19d5eeac138ec39abebd692c5404f", + "name": "patsy", + "sha256": "4bfd4ecfd3ff7b21530b0dd08fe36b44db201fa9613d1b58395174f69481c17f", + "size": 276880, + "subdir": "linux-64", + "timestamp": 1607693805630, + "version": "0.5.1" + }, + "patsy-0.5.2-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "numpy >=1.4.0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "936ffb3de168a6853c152025948c98cb", + "name": "patsy", + "sha256": "2c87c45250c0cb2b6154eee8f056a0a6918ed392395ed63ed5d54ed4cc2fe637", + "size": 279272, + "subdir": "linux-64", + "timestamp": 1644379659690, + "version": "0.5.2" + }, + "patsy-0.5.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.7,<3.8.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "c9f30ef6042d108a010ff375aa7d7499", + "name": "patsy", + "sha256": "5688e1feabd8a491a0694bf63f64924ec2887bf5f8c34b66185484ccb8136139", + "size": 275704, + "subdir": "linux-64", + "timestamp": 1633530142070, + "version": "0.5.2" + }, + "patsy-0.5.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "numpy >=1.4.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "53d3c34e3862f2cca310c2e13865d156", + "name": "patsy", + "sha256": "b4ee7288081fbae1ffed2a64efecc10192a5e2262f8bd2dd4908f27f8bd83fdb", + "size": 280403, + "subdir": "linux-64", + "timestamp": 1644395890850, + "version": "0.5.2" + }, + "patsy-0.5.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.8,<3.9.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "1a8f678b6b19ead02382fcd91af64ec7", + "name": "patsy", + "sha256": "615a4b0842383fc8bfcbd4bb02d531e0984753f9ae492f4ff5e5df74705e6332", + "size": 276313, + "subdir": "linux-64", + "timestamp": 1633530136234, + "version": "0.5.2" + }, + "patsy-0.5.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "numpy >=1.4.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "fbc8aaadd6ac50179e637bb0220e1cd9", + "name": "patsy", + "sha256": "d2ca133942675aeb7fdc52c1aa0252b664733372ac2d54c1c4137fa59b1543f4", + "size": 283124, + "subdir": "linux-64", + "timestamp": 1644377767224, + "version": "0.5.2" + }, + "patsy-0.5.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.9,<3.10.0a0", + "scipy", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "16ef7e9bbbffcd5e8a7d2c7f06e06fa1", + "name": "patsy", + "sha256": "ada8e0d990f0d913ff9752f3a650f1d11444408d9476dcf39c2b01cf15aff721", + "size": 275132, + "subdir": "linux-64", + "timestamp": 1633529464107, + "version": "0.5.2" + }, + "patsy-0.5.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "numpy >=1.4.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "63c10e951b8f82e4fb44d8deca873b9f", + "name": "patsy", + "sha256": "4680dc56371f316a1aa922778277600046a4af5769f94d4846f0b6069ff1618f", + "size": 278165, + "subdir": "linux-64", + "timestamp": 1644395888965, + "version": "0.5.2" + }, + "patsy-0.5.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "3cfeba605997d5e6e48225f60d6b1ab4", + "name": "patsy", + "sha256": "5c90cf83bc44adb060cb732d5acc74a076c01d27c68f355cb95932189a0b0bae", + "size": 289437, + "subdir": "linux-64", + "timestamp": 1674585981372, + "version": "0.5.3" + }, + "patsy-0.5.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "107a7b86a6252065c5e2ffdc68463750", + "name": "patsy", + "sha256": "fd1f417193179686016c52c41b3c63d7f5487e08d16afd12a0f8c360d719c02b", + "size": 357155, + "subdir": "linux-64", + "timestamp": 1676841622771, + "version": "0.5.3" + }, + "patsy-0.5.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "f9bc32f3f7473ca85de0209dccd3b264", + "name": "patsy", + "sha256": "54c4ca90d63264ec7a3c54b05c58e0733af831eb6b9671f242b12c9ddcc47341", + "size": 288063, + "subdir": "linux-64", + "timestamp": 1674586012398, + "version": "0.5.3" + }, + "patsy-0.5.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "3b13407d48a0001eb2535934cd247246", + "name": "patsy", + "sha256": "a0b944bc0aa7351e3542ddc7040a4b80ae0b3cccf325b6ca283dc7c6c1cfbb94", + "size": 288626, + "subdir": "linux-64", + "timestamp": 1674585918087, + "version": "0.5.3" + }, + "patsy-0.5.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.4.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-2-Clause AND PSF-2.0", + "license_family": "BSD", + "md5": "95002b30b1657b04c510c72977b4b7eb", + "name": "patsy", + "sha256": "517a758c5d9b3e9018ea077d7fbd003c0eaeee2047472e89430855907e8f223d", + "size": 288674, + "subdir": "linux-64", + "timestamp": 1674585951087, + "version": "0.5.3" + }, + "pbkdf2-1.3-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "6ca61ca899730e1c1ef496493b771617", + "name": "pbkdf2", + "sha256": "5926fbc36577feb6867f18aa6b1649545b4c7d75fda2089e967ef0519c55ec5c", + "size": 13289, + "subdir": "linux-64", + "timestamp": 1540356021429, + "version": "1.3" + }, + "pbkdf2-1.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "4760862e55c99aaa5c3fa0953784d944", + "name": "pbkdf2", + "sha256": "6d2e3aeb7fd23bdcbf5372b499bd3caf694f8c13e9f0e04ed1a560dc6f4cd8d7", + "size": 13804, + "subdir": "linux-64", + "timestamp": 1640792271352, + "version": "1.3" + }, + "pbkdf2-1.3-py311h06a4308_2.conda": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "156c146c1a839b5103d24a0d029fe4b7", + "name": "pbkdf2", + "sha256": "3841c0293d269cac38c6c7e250aa3a9f1a546c9f65f08921e7cb5086fdef55af", + "size": 16588, + "subdir": "linux-64", + "timestamp": 1676906097043, + "version": "1.3" + }, + "pbkdf2-1.3-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ef18bbd734ff65a299c015ee9e1901ea", + "name": "pbkdf2", + "sha256": "83a927ce6946e99d6abc59b6fc99f52627bbd7e8554c773deaf95f7d445190ea", + "size": 13373, + "subdir": "linux-64", + "timestamp": 1540356034499, + "version": "1.3" + }, + "pbkdf2-1.3-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0ed5eb9434ccf2c39c98183ffbfd9b4c", + "name": "pbkdf2", + "sha256": "46d749ffb802786718064f19a69364706cd202220bb38e0586c123dc191946b1", + "size": 255710, + "subdir": "linux-64", + "timestamp": 1614007679761, + "version": "1.3" + }, + "pbkdf2-1.3-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "97c036cf4d9ac753ba07042676d187f5", + "name": "pbkdf2", + "sha256": "f80a4dcd16e2a73da2d1c2d23bc36bc50b61148c1078f5aa27669bfef5c5edcc", + "size": 13480, + "subdir": "linux-64", + "timestamp": 1540356035705, + "version": "1.3" + }, + "pbkdf2-1.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "474ed454655882caa53b5e8d5b1ffdf9", + "name": "pbkdf2", + "sha256": "b179e230878699940d9d268e519f8992ada7541d3aea7828edae88bd749322a4", + "size": 256332, + "subdir": "linux-64", + "timestamp": 1614006796696, + "version": "1.3" + }, + "pbkdf2-1.3-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "b73ee4241e0d91d1d7ea20cde5a94cc1", + "name": "pbkdf2", + "sha256": "b27d9bb52f142e5132422e3ad5216472c8dab8f0cd94ba3e39730406073797b4", + "size": 13731, + "subdir": "linux-64", + "timestamp": 1573489507429, + "version": "1.3" + }, + "pbkdf2-1.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "b57b04d2203442eb4ca7e882ffea29f9", + "name": "pbkdf2", + "sha256": "e72a50ac340f3649a61c187419c00c054374d479c86b9176296ef8c88d1f9aa0", + "size": 256503, + "subdir": "linux-64", + "timestamp": 1614007686092, + "version": "1.3" + }, + "pbr-3.1.1-py27hf64632f_0.conda": { + "build": "py27hf64632f_0", + "build_number": 0, + "depends": [ + "pip", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b39a117f69d8084305426ac028dd76fd", + "name": "pbr", + "sha256": "666e9118f7bdb5a267e7dec193158afdd4e07c098248fc04ecba8776435be7cb", + "size": 118325, + "subdir": "linux-64", + "timestamp": 1505691190625, + "version": "3.1.1" + }, + "pbr-3.1.1-py35hdfb5056_0.conda": { + "build": "py35hdfb5056_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "69a1faf5f3890ce565044abf37a98dd0", + "name": "pbr", + "sha256": "d41d1646f0df63f7880f05079730115ab623c6657294aba53ba35d82737ba827", + "size": 120361, + "subdir": "linux-64", + "timestamp": 1505691204523, + "version": "3.1.1" + }, + "pbr-3.1.1-py36hb5f6b33_0.conda": { + "build": "py36hb5f6b33_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d08f395d7ccaa9b5560a683dbde7e048", + "name": "pbr", + "sha256": "1400c8998a371d5b1fc5c373968b0a0039194f6c30efc1cd40ca81890f07fc90", + "size": 118006, + "subdir": "linux-64", + "timestamp": 1505691218732, + "version": "3.1.1" + }, + "pbr-4.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pip", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cfc637f121a0b6149f8e7fec712c5b1b", + "name": "pbr", + "sha256": "d428bc00bf2bfb009cdc63721ded09559231af71b99e0b67bcf33f06759cc256", + "size": 117734, + "subdir": "linux-64", + "timestamp": 1522784725287, + "version": "4.0.0" + }, + "pbr-4.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "56a097a9a298b73962877934f6f1ae2f", + "name": "pbr", + "sha256": "96a925b01c0d5aa51748e4375c4dac5600be85930c870cf63ac1968165db8635", + "size": 120825, + "subdir": "linux-64", + "timestamp": 1522784726643, + "version": "4.0.0" + }, + "pbr-4.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f694a11c618cc7b1023bd3e1cf4555aa", + "name": "pbr", + "sha256": "e47786aa1cd31e29d63c97e1ca652172e45d4be7f96635ecbee87fd809c58bfd", + "size": 118349, + "subdir": "linux-64", + "timestamp": 1522784710281, + "version": "4.0.0" + }, + "pbr-4.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pip", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "280e809fd67d371cac451f17617acea8", + "name": "pbr", + "sha256": "da447490b662da4eacea041a8eb5c0be7ff202727c1e7e8e27e8e4d25e383a9b", + "size": 118414, + "subdir": "linux-64", + "timestamp": 1524071873069, + "version": "4.0.2" + }, + "pbr-4.0.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dceb14a734b4040ea6bdfc75afb3e446", + "name": "pbr", + "sha256": "44f679e26fde297111688b57dfc51da4f6856ed0b455333f1e70e36f0d2f121d", + "size": 121586, + "subdir": "linux-64", + "timestamp": 1524071876476, + "version": "4.0.2" + }, + "pbr-4.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "49f3d7080f4673819bfdcdf7ec45e65b", + "name": "pbr", + "sha256": "07823d9520f1e812c0e1cd0f0b6bdee40f09bf28b3ab2e3cf99fae608e8b9b8c", + "size": 119004, + "subdir": "linux-64", + "timestamp": 1524071876058, + "version": "4.0.2" + }, + "pbr-4.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pip", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9c032451455f50dc00cf54796c2ad085", + "name": "pbr", + "sha256": "7d5deae9941706632951a1bc2610b4a24b2671865a3d2de34bfa22e92d44446e", + "size": 121041, + "subdir": "linux-64", + "timestamp": 1526930542535, + "version": "4.0.3" + }, + "pbr-4.0.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4a1177d1c0f19d4e07630935c0ebbb4e", + "name": "pbr", + "sha256": "15e03439e55a13c3bed13950fc02ef459b58bd34764c0c58027a939a8860f830", + "size": 121532, + "subdir": "linux-64", + "timestamp": 1526930563790, + "version": "4.0.3" + }, + "pbr-4.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1981fac855a27b7ae8bc02b13f0541b6", + "name": "pbr", + "sha256": "ac96bc3e401698249893a2ea04cae3ecdeea7d20ea89cc9433dfdac4b3388d78", + "size": 120820, + "subdir": "linux-64", + "timestamp": 1526930507554, + "version": "4.0.3" + }, + "pbr-4.0.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pip", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "df98fd9265ce56f82f2ee8c2cacdb4c7", + "name": "pbr", + "sha256": "232859950947215e67af366eb0a54dbb0a6229c8d5818e96cba57d3f9b84c5ff", + "size": 120322, + "subdir": "linux-64", + "timestamp": 1529429830780, + "version": "4.0.4" + }, + "pbr-4.0.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f4e34c731dd4681c54f62d9abea2b298", + "name": "pbr", + "sha256": "e7b4a42bb0e964a331d895c164631dac974226fcaf03644ff59787030e2cf890", + "size": 122067, + "subdir": "linux-64", + "timestamp": 1529429867723, + "version": "4.0.4" + }, + "pbr-4.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "192bfd0bc16035382ad21353a6746560", + "name": "pbr", + "sha256": "201316711f15d3f05dc1514382da718ba65f7bb7afd4719960ed0f151911f00c", + "size": 120898, + "subdir": "linux-64", + "timestamp": 1529429774328, + "version": "4.0.4" + }, + "pbr-4.0.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7ccd32cdb24b88271c7b0ae0fb3a3f3d", + "name": "pbr", + "sha256": "154419fe2d6630609e6ebe4b7c75f7fa376392aa8902eb4eb2dc705016c6bb91", + "size": 122365, + "subdir": "linux-64", + "timestamp": 1530727990716, + "version": "4.0.4" + }, + "pbr-4.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pip", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "62c628e8a20bb97ec5ce87149cd4fbd2", + "name": "pbr", + "sha256": "0aabc2f9d13f0608f6b730cf25a6bf528ae2a55df9728b1fb1cddadc190d08ac", + "size": 122262, + "subdir": "linux-64", + "timestamp": 1532883560547, + "version": "4.2.0" + }, + "pbr-4.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c0422d50bd5b67088cb3457d9f5eabe3", + "name": "pbr", + "sha256": "3aea17c5247dd646a6d10cbff243c8e3aad062f70c40239625ca94366c86a95c", + "size": 125474, + "subdir": "linux-64", + "timestamp": 1532883591757, + "version": "4.2.0" + }, + "pbr-4.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "691ff69ba67157b9f2940c5ce4e77d2b", + "name": "pbr", + "sha256": "6b664b4986966e660d50e0347fbd0385c817a2b68c314dfbe56ac3aadddcfa94", + "size": 124545, + "subdir": "linux-64", + "timestamp": 1532883517218, + "version": "4.2.0" + }, + "pbr-4.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "71e285b69a5ff85a1b8d791603da38b2", + "name": "pbr", + "sha256": "39456fba15c5f587fcfd64546ec46898f5da474502b5dd3cd45185091c6358c0", + "size": 123012, + "subdir": "linux-64", + "timestamp": 1532883584370, + "version": "4.2.0" + }, + "pbr-4.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pip", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fd02d282aded35e7319d1ca79e694fb2", + "name": "pbr", + "sha256": "1ad1ce64bb9703aa48bfe3f28064f611b7cc0c9c5c0d9be5a55f2ef1d309eac5", + "size": 129497, + "subdir": "linux-64", + "timestamp": 1539652335586, + "version": "4.3.0" + }, + "pbr-4.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9961c707c8371fa1cf7c5437e5cc2a11", + "name": "pbr", + "sha256": "1015304dbcbed5167193152ee73e3c6dc32b14166f544326c8e358bacb002f9a", + "size": 130672, + "subdir": "linux-64", + "timestamp": 1539652356149, + "version": "4.3.0" + }, + "pbr-4.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "24d2867ab567208348b8dbbcecc3c2d4", + "name": "pbr", + "sha256": "7e743964c704a4d8187e54b905a857443dbcb5d9a02f9ac7b7bf9181ba3de6a1", + "size": 130642, + "subdir": "linux-64", + "timestamp": 1539652351087, + "version": "4.3.0" + }, + "pbr-5.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pip", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2e2bd628b579a9b551d288377b022ae5", + "name": "pbr", + "sha256": "083678c38376cf070c764b5055143526e9d4325ace982fb59d113e24f640fa57", + "size": 129898, + "subdir": "linux-64", + "timestamp": 1540997142618, + "version": "5.1.0" + }, + "pbr-5.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a7ee4019d60eafd676c82e9065e9ac60", + "name": "pbr", + "sha256": "2a5539271e1cfb62b83d9fc29dff52597cb950978f2e6145dee2064aea02663c", + "size": 130879, + "subdir": "linux-64", + "timestamp": 1540997160915, + "version": "5.1.0" + }, + "pbr-5.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "07ad63a31848dad39e7e021d084b5351", + "name": "pbr", + "sha256": "590691f97451d127d6d0ddfafd58a885d7ac9dc7a18359d84fdeb7698fceb8aa", + "size": 130675, + "subdir": "linux-64", + "timestamp": 1540997117298, + "version": "5.1.0" + }, + "pbr-5.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pip", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b149e0dbd7d327747c09770afdab7b01", + "name": "pbr", + "sha256": "eba82c1feb144e780da42279ec49c5913eb60e9fd83b64f04787a7f7eccc7f77", + "size": 128398, + "subdir": "linux-64", + "timestamp": 1542083670674, + "version": "5.1.1" + }, + "pbr-5.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9489d18c421264f58eb943a2e682b638", + "name": "pbr", + "sha256": "3b4156eb2ce0bfcb4b4635ae9a889f44fe6d955145a5507e13f217dd8e89f491", + "size": 129212, + "subdir": "linux-64", + "timestamp": 1542083709549, + "version": "5.1.1" + }, + "pbr-5.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pip", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "918e557728390ec60d6320c4d03e0a81", + "name": "pbr", + "sha256": "c326958889d868b551ea04894791a2ea9762ecaf47f04a4e936f3862767d884b", + "size": 129224, + "subdir": "linux-64", + "timestamp": 1542083647488, + "version": "5.1.1" + }, + "pcre-8.41-hc27e229_1.conda": { + "build": "hc27e229_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8ae87d1400c7483fbe495ddcd4942093", + "name": "pcre", + "sha256": "2c9f04734ce5dcfe5cce6d3f84a25e45641b1eb86a6126371b983cb3256a44d5", + "size": 206233, + "subdir": "linux-64", + "timestamp": 1510610241348, + "version": "8.41" + }, + "pcre-8.41-hc71a17e_0.conda": { + "build": "hc71a17e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1e45a6213bb6ffa7a4195e34748a5892", + "name": "pcre", + "sha256": "2609724381fe9eb6f51947130c58facbb3371a8786f2a75396b6891bb72adac5", + "size": 203280, + "subdir": "linux-64", + "timestamp": 1505734397623, + "version": "8.41" + }, + "pcre-8.42-h439df22_0.conda": { + "build": "h439df22_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "77402f56ad7d305885d766a67793b8b4", + "name": "pcre", + "sha256": "ff4497fa72910ac758ec732c36fbcb58b465a7e3f9396bef70ccc66deaeeaa47", + "size": 203590, + "subdir": "linux-64", + "timestamp": 1523631954672, + "version": "8.42" + }, + "pcre-8.43-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6be631812222c93f9bb4e10998cfa8c5", + "name": "pcre", + "sha256": "86033419346ea946493d67d0f57917f55ca43e4a89b483601bcce39b62ec2ec7", + "size": 213607, + "subdir": "linux-64", + "timestamp": 1552419679242, + "version": "8.43" + }, + "pcre-8.44-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e337926bb92177a2a3aded95a895470d", + "name": "pcre", + "sha256": "033e48e5ce9fe1e5bd581da8ca8d8ef40db31ef26f23559a645cb865a7416708", + "size": 216927, + "subdir": "linux-64", + "timestamp": 1593049055043, + "version": "8.44" + }, + "pcre-8.45-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b32ccc24d1d9808618c1e898da60f68d", + "name": "pcre", + "sha256": "2bf0144c02007ade42d6a5305987974cc751c7f2e2107d6f88c23d43ce354d5a", + "size": 212404, + "subdir": "linux-64", + "timestamp": 1624477853289, + "version": "8.45" + }, + "pcre2-10.35-h14c3975_1.conda": { + "build": "h14c3975_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e8e6f77c5c0745ca08da3406fb8d1123", + "name": "pcre2", + "sha256": "23b6ca2f202037603b3835b9ce39b8bc40a62fda4912eea0b88f385a8044b084", + "size": 498755, + "subdir": "linux-64", + "timestamp": 1601274249294, + "version": "10.35" + }, + "pcre2-10.35-h86c1b69_1.conda": { + "build": "h86c1b69_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bda46e96d744fa7d70da017acf817cf1", + "name": "pcre2", + "sha256": "044ab286a24df90aa5fd82d45604b27a86d4b75db483ee96670e7b56d1c1de46", + "size": 499544, + "subdir": "linux-64", + "timestamp": 1601274215857, + "version": "10.35" + }, + "pcre2-10.37-he7ceb23_1.conda": { + "build": "he7ceb23_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e79f09bd40e513df54e51d6722245ab9", + "name": "pcre2", + "sha256": "f2662b141a2f8ca5958b86e8cb918e0df34cca14f51f1af4aaaee63a1a0e668f", + "size": 859233, + "subdir": "linux-64", + "timestamp": 1641403802629, + "version": "10.37" + }, + "pdm-2.2.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "blinker", + "cachecontrol >=0.12.11", + "certifi >=2022.6.15", + "findpython >=0.2.0", + "packaging >=20.9", + "pdm-pep517 <2.0.0,>=1.0.0", + "pep517 >=0.11.0", + "platformdirs", + "python >=3.10,<3.11.0a0", + "python-dotenv >=0.15", + "python-installer <0.6,>=0.5.1", + "requests-toolbelt", + "resolvelib <0.9,>=0.8", + "rich >=12.3.0", + "shellingham >=1.3.2", + "tomli >=1.1.0", + "tomlkit <1,>=0.11.1", + "unearth >=0.6.0", + "virtualenv >=20" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f7f8563b2843e12671f4f915d89e29d3", + "name": "pdm", + "sha256": "5e784b9b52d647091f8c5aa98d286bece8518bee74d764cf24eea6a688acf5cc", + "size": 316923, + "subdir": "linux-64", + "timestamp": 1670440572140, + "version": "2.2.1" + }, + "pdm-2.2.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "blinker", + "cachecontrol >=0.12.11", + "certifi >=2022.6.15", + "findpython >=0.2.0", + "packaging >=20.9", + "pdm-pep517 <2.0.0,>=1.0.0", + "pep517 >=0.11.0", + "platformdirs", + "python >=3.11,<3.12.0a0", + "python-dotenv >=0.15", + "python-installer <0.6,>=0.5.1", + "requests-toolbelt", + "resolvelib <0.9,>=0.8", + "rich >=12.3.0", + "shellingham >=1.3.2", + "tomlkit <1,>=0.11.1", + "unearth >=0.6.0", + "virtualenv >=20" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d59c37437d04e3f50d73a47b3310ff72", + "name": "pdm", + "sha256": "666a93aec54531c168ba2bf59c0f22c4b47c5aca8e4f11b789044548b9dd0939", + "size": 407996, + "subdir": "linux-64", + "timestamp": 1676845134948, + "version": "2.2.1" + }, + "pdm-2.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "blinker", + "cachecontrol >=0.12.11", + "certifi >=2022.6.15", + "findpython >=0.2.0", + "importlib-metadata >=3.6", + "packaging >=20.9", + "pdm-pep517 <2.0.0,>=1.0.0", + "pep517 >=0.11.0", + "platformdirs", + "python >=3.7,<3.8.0a0", + "python-dotenv >=0.15", + "python-installer <0.6,>=0.5.1", + "requests-toolbelt", + "resolvelib <0.9,>=0.8", + "rich >=12.3.0", + "shellingham >=1.3.2", + "tomli >=1.1.0", + "tomlkit <1,>=0.11.1", + "typing-extensions", + "unearth >=0.6.0", + "virtualenv >=20" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d84b62ea38594a266f49db0c57f755f", + "name": "pdm", + "sha256": "bfaa72e0cb0e5b0c4863ec3b48635d119185c3595815c762a0ba8c4396acaef8", + "size": 310582, + "subdir": "linux-64", + "timestamp": 1670440509102, + "version": "2.2.1" + }, + "pdm-2.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "blinker", + "cachecontrol >=0.12.11", + "certifi >=2022.6.15", + "findpython >=0.2.0", + "importlib-metadata >=3.6", + "packaging >=20.9", + "pdm-pep517 <2.0.0,>=1.0.0", + "pep517 >=0.11.0", + "platformdirs", + "python >=3.8,<3.9.0a0", + "python-dotenv >=0.15", + "python-installer <0.6,>=0.5.1", + "requests-toolbelt", + "resolvelib <0.9,>=0.8", + "rich >=12.3.0", + "shellingham >=1.3.2", + "tomli >=1.1.0", + "tomlkit <1,>=0.11.1", + "unearth >=0.6.0", + "virtualenv >=20" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de10558218b54264573b2498a24d1271", + "name": "pdm", + "sha256": "4418ddc3f2be27cc55c37a7a26bb8c0b130511c3f3dbe6d03f56971af26ba2fc", + "size": 312607, + "subdir": "linux-64", + "timestamp": 1670440602828, + "version": "2.2.1" + }, + "pdm-2.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "blinker", + "cachecontrol >=0.12.11", + "certifi >=2022.6.15", + "findpython >=0.2.0", + "importlib-metadata >=3.6", + "packaging >=20.9", + "pdm-pep517 <2.0.0,>=1.0.0", + "pep517 >=0.11.0", + "platformdirs", + "python >=3.9,<3.10.0a0", + "python-dotenv >=0.15", + "python-installer <0.6,>=0.5.1", + "requests-toolbelt", + "resolvelib <0.9,>=0.8", + "rich >=12.3.0", + "shellingham >=1.3.2", + "tomli >=1.1.0", + "tomlkit <1,>=0.11.1", + "unearth >=0.6.0", + "virtualenv >=20" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "291f778829fed6ed73aad243bd2d13b9", + "name": "pdm", + "sha256": "a1f9ef87a7c1ce1406fb1ddcc32f7f04a8eca5ceb13161e73d824ecd50d5f2d3", + "size": 312529, + "subdir": "linux-64", + "timestamp": 1670440541111, + "version": "2.2.1" + }, + "pdm-pep517-1.0.6-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0cece935adf63374594b5b63efc4a30", + "name": "pdm-pep517", + "sha256": "6e368e25338d0d26465394c4a07c35334ab44ced0f9cbaf0738d6559c7de8e41", + "size": 443223, + "subdir": "linux-64", + "timestamp": 1669763773491, + "version": "1.0.6" + }, + "pdm-pep517-1.0.6-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01be5bee1e1306dfce21d0825e106d7f", + "name": "pdm-pep517", + "sha256": "bf08cf703e7e6e9c3e16e54499b153742211ad81c9ffa311f10aa13de0878a15", + "size": 541528, + "subdir": "linux-64", + "timestamp": 1676827348051, + "version": "1.0.6" + }, + "pdm-pep517-1.0.6-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7b17c81994fbe91af8705dc621cc032", + "name": "pdm-pep517", + "sha256": "92414bcb44e69a6a0a63d2649d04e7fe82613d76774b05717e834b62221024f8", + "size": 435371, + "subdir": "linux-64", + "timestamp": 1669763799098, + "version": "1.0.6" + }, + "pdm-pep517-1.0.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f45d78421cf25d53dedb3455d68a98f8", + "name": "pdm-pep517", + "sha256": "948ae52164638867c9c49148426795f667a11374ea4860e19f977750280743a9", + "size": 437744, + "subdir": "linux-64", + "timestamp": 1669763722441, + "version": "1.0.6" + }, + "pdm-pep517-1.0.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8780ad818f105cb71848c3b78214a4a", + "name": "pdm-pep517", + "sha256": "cbf21ebca26ff6d2d697c613886a9c3af7741cd3cffccb80a7944f77613a2ca3", + "size": 437554, + "subdir": "linux-64", + "timestamp": 1669763747917, + "version": "1.0.6" + }, + "pefile-2022.5.30-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "35c90c00e69d622b462e745fe8845ff4", + "name": "pefile", + "sha256": "1b6b8bd78d80d3e57263f232c731f1e10f23b5eb61a067c13ddae1b92c7d5e9c", + "size": 132218, + "subdir": "linux-64", + "timestamp": 1670877403937, + "version": "2022.5.30" + }, + "pefile-2022.5.30-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f603edee1631f5d2c9a9d17795c31e4", + "name": "pefile", + "sha256": "ce24abcedbb81ecbb3eeddf6d046101b776ba2a9854c5bdb7e50698b260c08fb", + "size": 162702, + "subdir": "linux-64", + "timestamp": 1676860313730, + "version": "2022.5.30" + }, + "pefile-2022.5.30-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1157c92483beb6fd041050b45c266489", + "name": "pefile", + "sha256": "cb2b857a8ec64e5b8782b525523a5eaf90c01487df1e40b99c32b3facff8b13a", + "size": 127670, + "subdir": "linux-64", + "timestamp": 1670877373486, + "version": "2022.5.30" + }, + "pefile-2022.5.30-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18599edfcdf430960040fa576967b00d", + "name": "pefile", + "sha256": "06abfe45de99e327a40eaabc83f9e3d9c43c602125ee90a80aee94250be51f99", + "size": 128545, + "subdir": "linux-64", + "timestamp": 1670877342899, + "version": "2022.5.30" + }, + "pefile-2022.5.30-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8eeb868663bd8b4f8edab96c2ee6054", + "name": "pefile", + "sha256": "160f2781d1a39ac9fb3a7822c5107b73153285f910957bdad061496527cebebf", + "size": 128185, + "subdir": "linux-64", + "timestamp": 1670877434248, + "version": "2022.5.30" + }, + "pegen-0.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4eff12565d672cc782ae9eb3cf517028", + "name": "pegen", + "sha256": "c6b1a02d507317d66bc9a83ff5e040a5a80c5f4692fecf05933906f147825ac5", + "size": 65073, + "subdir": "linux-64", + "timestamp": 1678308899710, + "version": "0.2.0" + }, + "pegen-0.2.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71baebec8e15faec9a73200f866ba7c5", + "name": "pegen", + "sha256": "57abf25203c4a589c7a978d39665b52a02cea5a5be8991b077cd3754ab763de2", + "size": 81518, + "subdir": "linux-64", + "timestamp": 1679340576353, + "version": "0.2.0" + }, + "pegen-0.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc4db51fac364885c1c9ed22aa0c7d0c", + "name": "pegen", + "sha256": "36f94d413a4cc654453361ee9f0452ad25c88aeaf88d842adbff1bacb1fa1c7d", + "size": 64000, + "subdir": "linux-64", + "timestamp": 1678308927976, + "version": "0.2.0" + }, + "pegen-0.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "53b729a9af23b7c4d92b4779a717a0cb", + "name": "pegen", + "sha256": "04b6b83031a622d0770aebe6a3028193d1c76ead4cc2ec009fff91c3fce1e0d3", + "size": 63860, + "subdir": "linux-64", + "timestamp": 1678308956370, + "version": "0.2.0" + }, + "pendulum-1.4.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-dateutil", + "pytzdata", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ae2c1f76f658d82c4e1f5f4592a39c72", + "name": "pendulum", + "sha256": "93473e691a60a589eb1352f8e295609011ea14614434580bef3523cdcd2ab5e3", + "size": 141071, + "subdir": "linux-64", + "timestamp": 1579634504836, + "version": "1.4.4" + }, + "pendulum-1.4.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytzdata", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a4de17e08370a89e6d21f78fc8959e4", + "name": "pendulum", + "sha256": "44722ad24375fc594ab6dfe524b0e1b75226a7fe939627fc60d1603c65f74199", + "size": 140548, + "subdir": "linux-64", + "timestamp": 1579634445614, + "version": "1.4.4" + }, + "pendulum-1.4.4-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil", + "pytzdata", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0012989dd7fb8915693fb98e8888372b", + "name": "pendulum", + "sha256": "1df23882cd7d5feca194a24c5fc5c5046a79ff676d4d74b7b838982ed360c9f8", + "size": 429065, + "subdir": "linux-64", + "timestamp": 1632893916671, + "version": "1.4.4" + }, + "pendulum-1.4.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytzdata", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48fb388db101797c8fd0d8211ae51985", + "name": "pendulum", + "sha256": "5fd1ee5f0cae78dbb50fe78cea8b87ed8239040cc99efc64ddcaf14f1d254105", + "size": 141010, + "subdir": "linux-64", + "timestamp": 1579634557456, + "version": "1.4.4" + }, + "pendulum-1.4.4-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil", + "pytzdata", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "899ccc0b4c276e4bbebb226826f6cea9", + "name": "pendulum", + "sha256": "1f293293c8f0dd75835158f4b213954716bebfb0b35b6bb7ecb77693efed39f0", + "size": 429469, + "subdir": "linux-64", + "timestamp": 1632884230206, + "version": "1.4.4" + }, + "pendulum-1.4.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil", + "pytzdata", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eaea9e22419437cc65aa78c0684d4d04", + "name": "pendulum", + "sha256": "32ac26919d1908af3d8b0b211b2377cdbe52a060f1660cf65bf1ae0b74df4ec2", + "size": 142001, + "subdir": "linux-64", + "timestamp": 1579634521153, + "version": "1.4.4" + }, + "pendulum-1.4.4-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil", + "pytzdata", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b34716a4eaf1f6c8d83b74c1b90ecdc", + "name": "pendulum", + "sha256": "21c7f456a77bc9774c678d0f49eb7cd7dd6326f427b4cdf91404307adb1dbe89", + "size": 429390, + "subdir": "linux-64", + "timestamp": 1632894666895, + "version": "1.4.4" + }, + "pendulum-1.4.4-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil", + "pytzdata", + "tzlocal" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba8a830bacbff9ca11804345a0f07523", + "name": "pendulum", + "sha256": "451338c1f79122db3f5fa1c87f0e35c83c01baa3e30238a4c33839dc73be4724", + "size": 430320, + "subdir": "linux-64", + "timestamp": 1632894649820, + "version": "1.4.4" + }, + "pendulum-2.0.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6,<3.0", + "pytzdata >=2018.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a096fbe93a7db9a61ea19f28e1a498b7", + "name": "pendulum", + "sha256": "884137ceccc07555b3db8f7fc252e0a03119c59e32d6fcde90ea487d2d8bd08e", + "size": 132863, + "subdir": "linux-64", + "timestamp": 1592416820148, + "version": "2.0.5" + }, + "pendulum-2.0.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6,<3.0", + "pytzdata >=2018.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c92cafd8c2936258f4b383b0f5b8cf7d", + "name": "pendulum", + "sha256": "00b15fa9ed3a3658e62ab74a3ef98e8db033ac93dba90a61283a11c174b4eb46", + "size": 133339, + "subdir": "linux-64", + "timestamp": 1592416812580, + "version": "2.0.5" + }, + "pendulum-2.0.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6,<3.0", + "pytzdata >=2018.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b033576f203cfcf058b59e2ca10191ef", + "name": "pendulum", + "sha256": "cdfde728d0f8992b78008ae54e9d00705bb3ac5f3258511654d4db8a9168a4c2", + "size": 135375, + "subdir": "linux-64", + "timestamp": 1592416820162, + "version": "2.0.5" + }, + "pendulum-2.1.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6,<3.0", + "pytzdata >=2018.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e3369bc584d1d4628c3de4ea875b6168", + "name": "pendulum", + "sha256": "ba616c5533919b9fea09d051c2a67bb8474fcd73fcd64d3e6b94e47a19e3b292", + "size": 143874, + "subdir": "linux-64", + "timestamp": 1585316327073, + "version": "2.1.0" + }, + "pendulum-2.1.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6,<3.0", + "pytzdata >=2018.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "46e68e256603884bcbefcaf5277e79c0", + "name": "pendulum", + "sha256": "eb908b41349b406615a23288b943c3555f88c2d21baa289e2a2eb10aa4769259", + "size": 143979, + "subdir": "linux-64", + "timestamp": 1585316268912, + "version": "2.1.0" + }, + "pendulum-2.1.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6,<3.0", + "pytzdata >=2018.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9df3cfd86ff62e2362b3f8ccc00eddd0", + "name": "pendulum", + "sha256": "5cdf9c742a60de8ab8a28128df20eb73eee285867630c868e37ac6073c30840e", + "size": 145082, + "subdir": "linux-64", + "timestamp": 1585316336878, + "version": "2.1.0" + }, + "pendulum-2.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.6,<3.0", + "pytzdata >=2020.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "857c65dfec6802839e022cf6f3474850", + "name": "pendulum", + "sha256": "9bf9416102a059dd1ff311142eadabd9fd3af79fa4d33f37aab88c108d6d4e21", + "size": 145942, + "subdir": "linux-64", + "timestamp": 1597791238308, + "version": "2.1.2" + }, + "pendulum-2.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.6,<3.0", + "pytzdata >=2020.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd0442a4a99c1d4564feab25dab7ae0e", + "name": "pendulum", + "sha256": "93d8abcc9b8feba7e33009f47c2dc59fd346e18247acf12617154379b718eed9", + "size": 147607, + "subdir": "linux-64", + "timestamp": 1597791234705, + "version": "2.1.2" + }, + "pendulum-2.1.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.6,<3.0", + "pytzdata >=2020.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1e003c1855d1bde9d662ee809cf56b1", + "name": "pendulum", + "sha256": "149545b8dd770e477936e2d9b4271fc9419c1f007474372c326c4b34bbf754a5", + "size": 147757, + "subdir": "linux-64", + "timestamp": 1597791217882, + "version": "2.1.2" + }, + "pep517-0.12.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "edaa6dc195a2acd315d14d238d4c72fe", + "name": "pep517", + "sha256": "4fa5a0f815230aaaff589d4e3f66e6f465b55b007c5a5f6d8fe19bd7d70f60f5", + "size": 33745, + "subdir": "linux-64", + "timestamp": 1640809920511, + "version": "0.12.0" + }, + "pep517-0.12.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4036bfb02627775d1fd7bd52b2237c08", + "name": "pep517", + "sha256": "b81cff178183eae6f5bb4049285655bbfa2fc450197a9f491d0fd19e737d3f71", + "size": 42913, + "subdir": "linux-64", + "timestamp": 1676825079787, + "version": "0.12.0" + }, + "pep517-0.12.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "python >=3.7,<3.8.0a0", + "tomli >=1.1.0", + "zipp" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5bdd39856de4e7d4ede69d88675d4180", + "name": "pep517", + "sha256": "4194c28f86b1d8d424e2bdcac7ac694e3b588ccd43d6fdd31b29439fa472b568", + "size": 35125, + "subdir": "linux-64", + "timestamp": 1637318599281, + "version": "0.12.0" + }, + "pep517-0.12.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a4de794b841b8b20bd0e7a50093c59f1", + "name": "pep517", + "sha256": "7a319da1949c78797ac41fcc3d23ee0d61064dd543c6f274fd85063b2be89816", + "size": 35404, + "subdir": "linux-64", + "timestamp": 1637318439229, + "version": "0.12.0" + }, + "pep517-0.12.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f259ac8d588c6a2c556b9a0a6352f012", + "name": "pep517", + "sha256": "d5f1cd16977ffd9aefc60d23570354d1fe730a21f6d1702d475e1f5febbbd4c6", + "size": 35500, + "subdir": "linux-64", + "timestamp": 1637305781059, + "version": "0.12.0" + }, + "pep8-1.7.0-py27h444351c_0.conda": { + "build": "py27h444351c_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "704b2b847400ea7f51fb6980ee523ed4", + "name": "pep8", + "sha256": "462bf8a29a8fd677f2a83723496d827c65654e1c6c902803dd779f08c02cb5a9", + "size": 53376, + "subdir": "linux-64", + "timestamp": 1505750905892, + "version": "1.7.0" + }, + "pep8-1.7.0-py35hee76f29_0.conda": { + "build": "py35hee76f29_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "d41927456e79823ef1d41efb564f630e", + "name": "pep8", + "sha256": "6fcd388e487b9d55f56d34f8250254530c4266811aabf212888dc3b87cafd712", + "size": 53948, + "subdir": "linux-64", + "timestamp": 1505750918586, + "version": "1.7.0" + }, + "pep8-1.7.0-py36h26ade29_0.conda": { + "build": "py36h26ade29_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "72be130f8eedec2cfff7a9877cc09cdd", + "name": "pep8", + "sha256": "e61936a53307d66f026f415c643c03992d651f07eb57aa046d25a309f73a2c59", + "size": 53546, + "subdir": "linux-64", + "timestamp": 1505750931677, + "version": "1.7.0" + }, + "pep8-1.7.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "76e89ec047a0ec595651471d77a39b7a", + "name": "pep8", + "sha256": "4074206095507cda10d310cbbeec5dd7652b9accc9a6b2303502a2ff1f0f0581", + "size": 53309, + "subdir": "linux-64", + "timestamp": 1515707146020, + "version": "1.7.1" + }, + "pep8-1.7.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "c8f54e4e5f04b63de98ffa1da8ff2a24", + "name": "pep8", + "sha256": "b6b06f697d5fdc55077c647899d6deee8b52fad4626d9646157374d06b4b8505", + "size": 54084, + "subdir": "linux-64", + "timestamp": 1640792289291, + "version": "1.7.1" + }, + "pep8-1.7.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d8887f946193ed7fda91b6cc5c049cc", + "name": "pep8", + "sha256": "619c18b178841ccd06e210fc8bbb1f0be3507a9a80d6f3086a4a1ae4084700e9", + "size": 53804, + "subdir": "linux-64", + "timestamp": 1657175636754, + "version": "1.7.1" + }, + "pep8-1.7.1-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc9b72d0f87b7506ddf2bf35439dd79e", + "name": "pep8", + "sha256": "43fb5264d853bcc65873cb8bae5f875f37481d7354bf5b6eaf2f5c9ce74e0308", + "size": 70970, + "subdir": "linux-64", + "timestamp": 1676860328959, + "version": "1.7.1" + }, + "pep8-1.7.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "42814c8ca332631ebbc88ed9b7104a20", + "name": "pep8", + "sha256": "f6b53fee8a955d5be64566415410916a36a9dd99632a1a636ce0a1438db49eb1", + "size": 53755, + "subdir": "linux-64", + "timestamp": 1515707263905, + "version": "1.7.1" + }, + "pep8-1.7.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c8ac66c2f9372e10a3cf7e60d193b8f6", + "name": "pep8", + "sha256": "40ca44f06c4bb6048c5cccfc8228fa08ba71f615cc04ac034debea0e484b20d4", + "size": 53951, + "subdir": "linux-64", + "timestamp": 1515707060611, + "version": "1.7.1" + }, + "pep8-1.7.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "db74e8f4f2a0dd937b5bee04eebf1642", + "name": "pep8", + "sha256": "784332924509339f1fd7245cac52b0a6f75926a0e4bf2ed17704f6f8f8a1fe44", + "size": 53888, + "subdir": "linux-64", + "timestamp": 1530904927231, + "version": "1.7.1" + }, + "pep8-1.7.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8b359154f66ac3bab011284bc5d1c09a", + "name": "pep8", + "sha256": "1ff2137348700e44e1bd9c97ae27aad4c0d72c0b2056a4e9fb37c82819a1b6d8", + "size": 53441, + "subdir": "linux-64", + "timestamp": 1657175568184, + "version": "1.7.1" + }, + "pep8-1.7.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "db7a0375bde4cb8773242376e115f799", + "name": "pep8", + "sha256": "12b89d4aa6609ce0957a9a06dc95b06e0a66d139c8cb7a5701cfcaa182c1f7c0", + "size": 54390, + "subdir": "linux-64", + "timestamp": 1573489521707, + "version": "1.7.1" + }, + "pep8-1.7.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3894abbfb368851b7ae72d7625f73d41", + "name": "pep8", + "sha256": "47c029375da5c0f0c5ba7a4dfa0a8b039cece06b7c381daf506b6277dd11e2fe", + "size": 53533, + "subdir": "linux-64", + "timestamp": 1657175540509, + "version": "1.7.1" + }, + "pep8-1.7.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "32a148df58ac95959c85b08503a0f825", + "name": "pep8", + "sha256": "d82666dcec5a56912ca15d8a8fbec53fb20aaa16d29c35c3237fcd0896d50668", + "size": 55626, + "subdir": "linux-64", + "timestamp": 1607573999361, + "version": "1.7.1" + }, + "pep8-1.7.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f0000d6e6698b556c5f9991fbba7e12b", + "name": "pep8", + "sha256": "4504c687752f0d4233e4eaedf8453d56846686c701c7c92b7faafb5deb085725", + "size": 53960, + "subdir": "linux-64", + "timestamp": 1657175597438, + "version": "1.7.1" + }, + "pep8-naming-0.11.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "75b81179fe49bb9dcc7483ab32908083", + "name": "pep8-naming", + "sha256": "3b1c037206495935c76bf9057bf6cf719a4c4c413ede4e77c317a3f9bfb40085", + "size": 18479, + "subdir": "linux-64", + "timestamp": 1600457461276, + "version": "0.11.1" + }, + "pep8-naming-0.11.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b77fffbfd2d4753393bb2da5ce1a40df", + "name": "pep8-naming", + "sha256": "645d27a354238759020098ee7908c302097e97465b310c9b3c9e6e7f82f493de", + "size": 18507, + "subdir": "linux-64", + "timestamp": 1600457428850, + "version": "0.11.1" + }, + "pep8-naming-0.11.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92b431cf240f40d12911b0f4c79a5f92", + "name": "pep8-naming", + "sha256": "fb356623b19ad40ac5b86776539b46f41d5997587719bc8776bca263381c83b9", + "size": 18499, + "subdir": "linux-64", + "timestamp": 1600457472599, + "version": "0.11.1" + }, + "pep8-naming-0.12.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flake8 >=3.9.1", + "flake8-polyfill >=1.0.2,<2", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "00f26acb3d665acaf0e55c882872e5ac", + "name": "pep8-naming", + "sha256": "31ba51f3689b02155c89f111e0ba9ef2f57bb545967adc1041de4114063ef786", + "size": 19505, + "subdir": "linux-64", + "timestamp": 1642517395105, + "version": "0.12.0" + }, + "pep8-naming-0.12.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flake8 >=3.9.1", + "flake8-polyfill >=1.0.2,<2", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2e136e20d1c6ba360586aa1736ff1f7", + "name": "pep8-naming", + "sha256": "5b49cce5171f959015cd6dba23d99ff26ccaab8b13d07c6b855b83435a5e3e95", + "size": 24433, + "subdir": "linux-64", + "timestamp": 1677697086323, + "version": "0.12.0" + }, + "pep8-naming-0.12.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "flake8 >=3.9.1", + "flake8-polyfill >=1.0.2,<2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "241b8472b67417d9541fae1da03e3f43", + "name": "pep8-naming", + "sha256": "860767aaa682111ca7542a46c940bf4195c93de705ca587e6cab5983109bbbd2", + "size": 19078, + "subdir": "linux-64", + "timestamp": 1626239146985, + "version": "0.12.0" + }, + "pep8-naming-0.12.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flake8 >=3.9.1", + "flake8-polyfill >=1.0.2,<2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47b210cf4bbfe8dc5617434041599faa", + "name": "pep8-naming", + "sha256": "1ec9eac85979861d0cf183a54d4c7a9feaa756968eaa11d2c83de140946b0f75", + "size": 19073, + "subdir": "linux-64", + "timestamp": 1626246191159, + "version": "0.12.0" + }, + "pep8-naming-0.12.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flake8 >=3.9.1", + "flake8-polyfill >=1.0.2,<2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4bdbe558ad7f21ae7952619fb99880b", + "name": "pep8-naming", + "sha256": "b03feac7d5ea8daeb1ac3fd35857f4bab48612e09ab359e90bceb1734e2b7f09", + "size": 19084, + "subdir": "linux-64", + "timestamp": 1626246053073, + "version": "0.12.0" + }, + "pep8-naming-0.12.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flake8 >=3.9.1", + "flake8-polyfill >=1.0.2,<2", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7818374aa82104a74db7783b3a47fef1", + "name": "pep8-naming", + "sha256": "f9882e2bb9f9b0cc81bfe569568f812df05f57855ea6516056bb811a46ca8175", + "size": 19040, + "subdir": "linux-64", + "timestamp": 1626246204478, + "version": "0.12.0" + }, + "pep8-naming-0.4.1-py27h7a85148_0.conda": { + "build": "py27h7a85148_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d58dc0268c1ce45b84c067ea79508848", + "name": "pep8-naming", + "sha256": "945032cb6111b377d25e346c318fbb0c679ef23676097c210553d1f878a79ed6", + "size": 12588, + "subdir": "linux-64", + "timestamp": 1505750944907, + "version": "0.4.1" + }, + "pep8-naming-0.4.1-py35h8375fd2_0.conda": { + "build": "py35h8375fd2_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "962c7d2847251c9fc2c60e4ee1b5b399", + "name": "pep8-naming", + "sha256": "6839d5668493e2b19cef09aad8c1259e8f8afd9e37c6a7ea01e401e76942ce9a", + "size": 12775, + "subdir": "linux-64", + "timestamp": 1505750957202, + "version": "0.4.1" + }, + "pep8-naming-0.4.1-py36h11f6f4a_0.conda": { + "build": "py36h11f6f4a_0", + "build_number": 0, + "depends": [ + "flake8", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e522f5012d95b1588c9d769fb6ffe750", + "name": "pep8-naming", + "sha256": "ccd3c09cfc54cae885d64801498dc46b0245fcf65c1e7d194fc140bbcd29606c", + "size": 12660, + "subdir": "linux-64", + "timestamp": 1505750970278, + "version": "0.4.1" + }, + "pep8-naming-0.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "54298a5a9c36c43a174ce2c54c9cceac", + "name": "pep8-naming", + "sha256": "d1b419fc16eaa07e7b0c8fbd77cd41516261c41d33ac1d49b89645ce82f52ea9", + "size": 12893, + "subdir": "linux-64", + "timestamp": 1524096797138, + "version": "0.5.0" + }, + "pep8-naming-0.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12816f43ede6b370391d33e79bafcfe2", + "name": "pep8-naming", + "sha256": "bdca0b68fb339458b26a25de09eb9543c6c834649a11b6fe12ce2daa383bdb42", + "size": 13135, + "subdir": "linux-64", + "timestamp": 1524096341968, + "version": "0.5.0" + }, + "pep8-naming-0.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c108c4950fdb575803a7c4e92744980", + "name": "pep8-naming", + "sha256": "c0add867dd715c3225b0074bbd12b1258ba603df0cd3b5c0c895bead6cf69f17", + "size": 12963, + "subdir": "linux-64", + "timestamp": 1524096837080, + "version": "0.5.0" + }, + "pep8-naming-0.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9171024ff33b3fd9b37ef8a5d415eea", + "name": "pep8-naming", + "sha256": "d1e6a11fa828f67ab7a65a908058b650a8c141864ededa19807b63c3278cac5b", + "size": 14747, + "subdir": "linux-64", + "timestamp": 1526940289890, + "version": "0.7.0" + }, + "pep8-naming-0.7.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c3834d21049d4983c5cae6d5d31ed82", + "name": "pep8-naming", + "sha256": "3273dd8b6eb07309345d9e491faa063b6937b48b74d2afdf18ae037dfe812faf", + "size": 15083, + "subdir": "linux-64", + "timestamp": 1526940315519, + "version": "0.7.0" + }, + "pep8-naming-0.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b26f481a5441298368c555c5715872f4", + "name": "pep8-naming", + "sha256": "ef12e7033fa0485610e9092a07efc209bf2de53f9fef8ae903d08a8474285685", + "size": 14903, + "subdir": "linux-64", + "timestamp": 1526940264744, + "version": "0.7.0" + }, + "pep8-naming-0.7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3fb3620e65c5a9622683437ce7dd335", + "name": "pep8-naming", + "sha256": "7cdcb89f1453ab4fc31a8ef870df5b7356372a0b5ba27ab3d74fb35a863919ab", + "size": 14935, + "subdir": "linux-64", + "timestamp": 1530904958779, + "version": "0.7.0" + }, + "pep8-naming-0.8.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8dcc8a154257111c182ca228062d539f", + "name": "pep8-naming", + "sha256": "fd86ca8ef94bcd52fb981078f231c5df2212265f611a3beb087ae66c782fc1e0", + "size": 20963, + "subdir": "linux-64", + "timestamp": 1552440350766, + "version": "0.8.2" + }, + "pep8-naming-0.8.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b66d79bbac843381e0b32d0802eec41", + "name": "pep8-naming", + "sha256": "97a2d141e49551a651ed7e89d0c92ad1db1f15e77d7a988580a015225f4ad2c2", + "size": 21068, + "subdir": "linux-64", + "timestamp": 1552440537016, + "version": "0.8.2" + }, + "pep8-naming-0.8.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31740b9c5e69fb9a33c1b818c1a83062", + "name": "pep8-naming", + "sha256": "49faf05b35fa0cdb3eceaf56eb3e7f914574fd82a7f73db6af299d4be216105b", + "size": 20712, + "subdir": "linux-64", + "timestamp": 1613557188999, + "version": "0.8.2" + }, + "pep8-naming-0.8.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "559800b30282d88e51af838b26e5c0d6", + "name": "pep8-naming", + "sha256": "c76bbd4372687f6d43c29addbd67cf2b6d80d7a7ff141870ba0ff5d6abec44cc", + "size": 21027, + "subdir": "linux-64", + "timestamp": 1552440355993, + "version": "0.8.2" + }, + "pep8-naming-0.8.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8eb1b66fe847ac4df657b23e49dd0145", + "name": "pep8-naming", + "sha256": "cec4e6573effa538a8126e471b4c8afa652241cf2d1892eb7a524f0977b3bed9", + "size": 20676, + "subdir": "linux-64", + "timestamp": 1613557176000, + "version": "0.8.2" + }, + "pep8-naming-0.8.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b5f3f86c05ddeeec20ccfe33344ccd2", + "name": "pep8-naming", + "sha256": "c5a1356a709f816352c19c5b6ce6587ed6032ad1b38856587df8c7f44a9d7716", + "size": 17041, + "subdir": "linux-64", + "timestamp": 1574177627575, + "version": "0.8.2" + }, + "pep8-naming-0.8.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "57c60a2fd827af1fcebb0fdfed394a4e", + "name": "pep8-naming", + "sha256": "03cb405b00c86051369824ae8379a6a8e145396c2f1a3849759d9743ae745435", + "size": 20718, + "subdir": "linux-64", + "timestamp": 1613557179541, + "version": "0.8.2" + }, + "pep8-naming-0.8.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flake8", + "flake8-polyfill >=1.0.2,<2", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f1d4d7e3ab1fb7e75387ecd2dd2e7d5", + "name": "pep8-naming", + "sha256": "6e398fd0ba7f880e2aa1c9af491e8507faeb31863891d463029d38ad385ef242", + "size": 20859, + "subdir": "linux-64", + "timestamp": 1613557191379, + "version": "0.8.2" + }, + "perf-1.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six", + "statistics" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "2ac7be4e279d2c2bf6ee46536c2ccc1d", + "name": "perf", + "sha256": "d83cf154002a888bf551b3f5ca971edaf791bc23f8292e4f4f8e04bba77858b4", + "size": 151283, + "subdir": "linux-64", + "timestamp": 1531066797639, + "version": "1.5.1" + }, + "perf-1.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "784436e672e648bc1e6c83652afaa56a", + "name": "perf", + "sha256": "2c7bbe927d73043b88c6a2b54e3876565433a26a0288b59589f3d73e14890405", + "size": 153742, + "subdir": "linux-64", + "timestamp": 1531066723689, + "version": "1.5.1" + }, + "perf-1.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "48813109a2db383f756ea69067f541f6", + "name": "perf", + "sha256": "21520a064fd3f32a80493477bf5daf0b8445669d1168fbe5a98da9f582391b76", + "size": 153492, + "subdir": "linux-64", + "timestamp": 1531066761202, + "version": "1.5.1" + }, + "performance-0.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "perf", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "85974a430ca145e690da8410b6a467e8", + "name": "performance", + "sha256": "9fd841788ed6a89e8eb344b39ff92323aed16b6c08de65c0fc93fe1ef04cc2a2", + "size": 2351113, + "subdir": "linux-64", + "timestamp": 1531066838299, + "version": "0.6.1" + }, + "performance-0.6.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "perf", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "ac270acf32e6f12f814fcb007159d88e", + "name": "performance", + "sha256": "3eda0b8935a314e8b01e736d7288ea97ff237cc6d967b22b05327e8dab68ea0a", + "size": 2344078, + "subdir": "linux-64", + "timestamp": 1531066879194, + "version": "0.6.1" + }, + "performance-0.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "perf", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "5e3922f5f4615aa7b1a2ba29277cb4bf", + "name": "performance", + "sha256": "ef531d7e87cf8a481e134550af711dcfeb4a5c946b4b3b1c9a642494fc7e62c8", + "size": 2353338, + "subdir": "linux-64", + "timestamp": 1545167681307, + "version": "0.7.0" + }, + "performance-0.7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "perf", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "a66aed695241d3539c3c1cd1c0a67180", + "name": "performance", + "sha256": "d5b99bb44e61fcf1dbfeb4d3e03a0c12f103f83252417a87abc39a33cfbeca25", + "size": 2355340, + "subdir": "linux-64", + "timestamp": 1545167715195, + "version": "0.7.0" + }, + "perl-5.26.0-hae598fd_0.conda": { + "build": "hae598fd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "Perl", + "license_family": "Other", + "md5": "bd4ad3dc0f8fe11561042ff0953f6786", + "name": "perl", + "sha256": "43368bef499c51fef86848dff762e3bdfa194ab691fdd608e8430cd51a2d4fbe", + "size": 10924654, + "subdir": "linux-64", + "timestamp": 1505666299464, + "version": "5.26.0" + }, + "perl-5.26.2-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "Perl Artistic", + "license_family": "Other", + "md5": "146f65488ff2239f08a9f98942b60e1c", + "name": "perl", + "sha256": "8a8bfdb15fd0446503d6698b99e9f8c34fcf85c2fd00305edd447970a136a2b1", + "size": 10963304, + "subdir": "linux-64", + "timestamp": 1527832845796, + "version": "5.26.2" + }, + "perl-5.32.1-0_h5eee18b_perl5.conda": { + "build": "0_h5eee18b_perl5", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libnsl >=2.0.0,<2.1.0a0" + ], + "license": "GPL-1.0-or-later OR Artistic-1.0-Perl", + "license_family": "Other", + "md5": "bcfda54960f1646e408a6a4764b6530a", + "name": "perl", + "sha256": "f1ba4f6074c7332d7e5dfe5f63c4e027afc002aa14677dff3e8d4362d9581cb1", + "size": 14138330, + "subdir": "linux-64", + "timestamp": 1667421052418, + "version": "5.32.1" + }, + "perl-5.34.0-h5eee18b_1.conda": { + "build": "h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "GPL-1.0-or-later OR Artistic-1.0-Perl", + "license_family": "Other", + "md5": "9073c929dd0c3e474468c3b09d587cb0", + "name": "perl", + "sha256": "0d1ad6518f5e8b1a300a05d85d1c604c7674823d1038a903c0003a245d850d4a", + "size": 12949043, + "subdir": "linux-64", + "timestamp": 1667810458984, + "version": "5.34.0" + }, + "perl-5.34.0-h5eee18b_2.conda": { + "build": "h5eee18b_2", + "build_number": 2, + "depends": [ + "gdbm >=1.18", + "gdbm >=1.18,<1.19.0a0", + "libgcc-ng >=11.2.0" + ], + "license": "GPL-1.0-or-later OR Artistic-1.0-Perl", + "license_family": "Other", + "md5": "2362442477bfdd0ff1ce8d8cc753e7e8", + "name": "perl", + "sha256": "66922a345409109c9f685d23eed409486102ed569c95bb2c8116fb17d88595a9", + "size": 12989495, + "subdir": "linux-64", + "timestamp": 1667922215060, + "version": "5.34.0" + }, + "perl-xml-parser-2.44_01-pl5340hf309648_0.conda": { + "build": "pl5340hf309648_0", + "build_number": 0, + "depends": [ + "expat >=2.4.9,<3.0a0", + "libgcc-ng >=11.2.0", + "perl" + ], + "license": "Artistic-1.0-Perl", + "license_family": "Other", + "md5": "093b2039848c639f122e175f80731242", + "name": "perl-xml-parser", + "sha256": "ab2bc8e9895de59ceba636df1188885ff43936b5c82a29b2e5f749e25ec54a61", + "size": 152116, + "subdir": "linux-64", + "timestamp": 1667973093517, + "version": "2.44_01" + }, + "persistent-4.2.4.2-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "24df9cca885fd8ddaa0825f81109638a", + "name": "persistent", + "sha256": "f78e02242c7689e6d20012e963e0e90f1d1816f0338985247cd9e1e23a028ccf", + "size": 139502, + "subdir": "linux-64", + "timestamp": 1524234019051, + "version": "4.2.4.2" + }, + "persistent-4.2.4.2-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "ccbc6da7abada3465716f57f3cf2bf91", + "name": "persistent", + "sha256": "45f50cd60ca8e56e5a9e1058734c85b32f78139ba04c580656a7dc8249069dda", + "size": 143809, + "subdir": "linux-64", + "timestamp": 1524234019054, + "version": "4.2.4.2" + }, + "persistent-4.2.4.2-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "8143d813c0245b4a65442b178f848202", + "name": "persistent", + "sha256": "2885fb43e88696c7e8fc05458a99cdfffbb65b30683645563a1fc408aa24e6c9", + "size": 142638, + "subdir": "linux-64", + "timestamp": 1524233955220, + "version": "4.2.4.2" + }, + "persistent-4.2.4.2-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "c97e58bda5a83759b1d250fb55c0bb7b", + "name": "persistent", + "sha256": "a442d437f03ed7d21e2207e2239c437a342cf396afc7a9eadd50e8a6842f8d1e", + "size": 142323, + "subdir": "linux-64", + "timestamp": 1530875289185, + "version": "4.2.4.2" + }, + "persistent-4.4.2-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "c8a3194058ead81515172e78d9bef1e6", + "name": "persistent", + "sha256": "b67d6f1a5436582f4b6ee56c9bb79293cd5cb273417c5bf3b5a9595d476e69d5", + "size": 146932, + "subdir": "linux-64", + "timestamp": 1536263262663, + "version": "4.4.2" + }, + "persistent-4.4.2-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "9cabadab1bf33ee856c245f92eacadbb", + "name": "persistent", + "sha256": "8ddf44942dd5444bcd8f70135666fb2e62ef40ffdc861a08fae46cc552862df8", + "size": 151401, + "subdir": "linux-64", + "timestamp": 1536263306125, + "version": "4.4.2" + }, + "persistent-4.4.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "78040841941fa4967f09916f6f94d6d4", + "name": "persistent", + "sha256": "01ba13fcf80446a9f626939bb27a9dded3693e54458a15f2ab6fabac5f365c7a", + "size": 149786, + "subdir": "linux-64", + "timestamp": 1536263204267, + "version": "4.4.2" + }, + "persistent-4.4.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "defd860b0b7987075d61b2f86a0641d4", + "name": "persistent", + "sha256": "a1867a581dc3d5fdd8a2f1b5ef16a2b38a395bbb816271844951f08336613888", + "size": 149553, + "subdir": "linux-64", + "timestamp": 1536263320102, + "version": "4.4.2" + }, + "persistent-4.4.3-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "81a3c7e5896379ad44a15b4833db7007", + "name": "persistent", + "sha256": "02218129a6098e3022b2dfdd8c485de6fa7385f081b3a5e67058c6738a06f0e7", + "size": 148377, + "subdir": "linux-64", + "timestamp": 1540998348216, + "version": "4.4.3" + }, + "persistent-4.4.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "61f77092720c3128aa9fd18d21ec2aab", + "name": "persistent", + "sha256": "447145ac7ca409e35ee9c3298751093b92342b4605a8e3e51ba4bcc7a0280fb6", + "size": 151608, + "subdir": "linux-64", + "timestamp": 1540998355528, + "version": "4.4.3" + }, + "persistent-4.4.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "4e32e0c35cbf0f7bac6cd9aaaae6fec2", + "name": "persistent", + "sha256": "6e0116f8d3a0c6b7ef83b4ebe69487d61377387e6464ec253fc197f3451b04a6", + "size": 151649, + "subdir": "linux-64", + "timestamp": 1540998372160, + "version": "4.4.3" + }, + "persistent-4.5.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "577101b18c45dba096695caadb80fb52", + "name": "persistent", + "sha256": "730736911f8b90a74a7f8b9d0e2044c49825a51942ba27f94b36cdb83c194685", + "size": 317450, + "subdir": "linux-64", + "timestamp": 1569438664504, + "version": "4.5.0" + }, + "persistent-4.5.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "577feb1a468d8888fe8a9155c56ba048", + "name": "persistent", + "sha256": "99649b71d71ab9574d196dfdb1e943c1868d505c8c3fb6a398205b0f976ad1dd", + "size": 393184, + "subdir": "linux-64", + "timestamp": 1613040224459, + "version": "4.5.0" + }, + "persistent-4.5.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "6f79f1be713663387667e5331c6f839a", + "name": "persistent", + "sha256": "7d181cb8adcdd3ce909931439bf1f0e25ffe7f8fad517fc87ba751fbb7ca6fbb", + "size": 321301, + "subdir": "linux-64", + "timestamp": 1569438674435, + "version": "4.5.0" + }, + "persistent-4.5.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "247d7abd54c4fa871ededf6376684a22", + "name": "persistent", + "sha256": "a360ee307762c5142809f1d432ec42137320554a095444ac3a6d7a0b6d6563f9", + "size": 393289, + "subdir": "linux-64", + "timestamp": 1613040208234, + "version": "4.5.0" + }, + "persistent-4.5.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "e0080a0c4e95b0e12be4e215f2134576", + "name": "persistent", + "sha256": "1c591ad7762e21011ed17dda7950228b04fa59c1838112c1037c3413727eea14", + "size": 320644, + "subdir": "linux-64", + "timestamp": 1569438659883, + "version": "4.5.0" + }, + "persistent-4.5.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "70bfa3f83ba916eb053c91154627c155", + "name": "persistent", + "sha256": "1a5bd8d6543de97d44f9ef32a48811168672703a7feed4bea2dd4db4cb5d2a20", + "size": 395485, + "subdir": "linux-64", + "timestamp": 1613039811451, + "version": "4.5.0" + }, + "persistent-4.6.4-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "4f9596c891298055a48452d212dbca15", + "name": "persistent", + "sha256": "5d2bfdb8af08c040745f84623ac55c12c156d43a8f5d93992fba151776a08c63", + "size": 232823, + "subdir": "linux-64", + "timestamp": 1640812656341, + "version": "4.6.4" + }, + "persistent-4.6.4-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "f76df59e2a745eebc236d36f394457f5", + "name": "persistent", + "sha256": "09651ca4615c545f21016a2409298a66efc8109f732e232192fd9425fc8e41a4", + "size": 204668, + "subdir": "linux-64", + "timestamp": 1676906120262, + "version": "4.6.4" + }, + "persistent-4.6.4-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "e794e8ad953b8bacb0c62c29113e41dd", + "name": "persistent", + "sha256": "d1288a24c2ca6bad3bcc1297df219ba9c3cba568c01613d9d0fe784d74f66775", + "size": 407509, + "subdir": "linux-64", + "timestamp": 1613041347028, + "version": "4.6.4" + }, + "persistent-4.6.4-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "33db350e3a03ff6be108a1802c324adf", + "name": "persistent", + "sha256": "b88224f8cd298e48e2ee8b5e7448d49fa77955649660c8403f40863bb1060734", + "size": 407462, + "subdir": "linux-64", + "timestamp": 1613041334596, + "version": "4.6.4" + }, + "persistent-4.6.4-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "075fd2fb0a02959034e8a0f59c5bb856", + "name": "persistent", + "sha256": "afdf65b61c3d2970da2580ad30a74161907a002489e12693eb3949076cb87ef8", + "size": 407885, + "subdir": "linux-64", + "timestamp": 1613041344151, + "version": "4.6.4" + }, + "persistent-4.6.4-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "56a59fdc0f405701b352f09a06fa3e8d", + "name": "persistent", + "sha256": "7041befd704d63caef71a15639aa310ddb993b9b9acdf14fe4af48485984c08d", + "size": 409103, + "subdir": "linux-64", + "timestamp": 1613041050150, + "version": "4.6.4" + }, + "petl-1.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "6140bd835ee4b6c38282902c78b0d684", + "name": "petl", + "sha256": "9a7cddf2867489dc21330fd57a3e34e9b63be901c561b54087bf84086634b49a", + "size": 273524, + "subdir": "linux-64", + "timestamp": 1530904996412, + "version": "1.1.1" + }, + "petl-1.1.1-py27h32202ed_0.conda": { + "build": "py27h32202ed_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "229b76d6c71f314ed674cc79628d2920", + "name": "petl", + "sha256": "0e057c885019c565c5517ed1e103480f3d3a45772a186c57d025d0bbc7316c3f", + "size": 277260, + "subdir": "linux-64", + "timestamp": 1511754968082, + "version": "1.1.1" + }, + "petl-1.1.1-py35h8d510cf_0.conda": { + "build": "py35h8d510cf_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "dad24c862e8981f79ca7dd5887afcf35", + "name": "petl", + "sha256": "29d5aa3b64fd5a18d46c77eb92d4b7471928a3c2847008c62451f1fa14ddf21f", + "size": 286845, + "subdir": "linux-64", + "timestamp": 1511754975943, + "version": "1.1.1" + }, + "petl-1.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0d475ef47e50fc277dd3a5854a66bb2d", + "name": "petl", + "sha256": "e4b8eb37dd4cc29e84798b8c57db32c979d238ac2857a6cb67fd23698857710c", + "size": 280471, + "subdir": "linux-64", + "timestamp": 1530905031810, + "version": "1.1.1" + }, + "petl-1.1.1-py36h13e1632_0.conda": { + "build": "py36h13e1632_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "51efc40991b3e993d680956d1efa845f", + "name": "petl", + "sha256": "ff8bd92722affe1acb5ed2025a2af533c3e0dbd4f92470d61a7103b019c0ed15", + "size": 284193, + "subdir": "linux-64", + "timestamp": 1511754977165, + "version": "1.1.1" + }, + "petl-1.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "362cedf84b267b2d525420d94f6ed36d", + "name": "petl", + "sha256": "95adfc1167ec958daa3c90ef9b0c30539bf34c730168bf02c045f144b9c5c92f", + "size": 273059, + "subdir": "linux-64", + "timestamp": 1530905066819, + "version": "1.1.1" + }, + "petl-1.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "0d3225bb491dc12e46691291b91ea8a7", + "name": "petl", + "sha256": "7f6de6542f323851ae31a819b8e059812032ead14dd2d968782b782b2a4b1a54", + "size": 270109, + "subdir": "linux-64", + "timestamp": 1535503111514, + "version": "1.2.0" + }, + "petl-1.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "1daccef9db9513512cfda4578ffe1470", + "name": "petl", + "sha256": "96d657c0064c30f0f26e5c9fde6fdd1cc1c18f7bcd8813155a879316eaf2be26", + "size": 276190, + "subdir": "linux-64", + "timestamp": 1535503132343, + "version": "1.2.0" + }, + "petl-1.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4af5515fe1da16424abfebbcfc650dbd", + "name": "petl", + "sha256": "8215bb43abb74542d74b76cec54b6a68ee6008cf8e843619faea0b4989d04a83", + "size": 273812, + "subdir": "linux-64", + "timestamp": 1535503060091, + "version": "1.2.0" + }, + "petl-1.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1b88fe5565abcce14020c62f0c5c8697", + "name": "petl", + "sha256": "2be4ab75c8cf18a890c1f95a28b095ddd8838b8d53b70dcfb8f5d0dcbf1ef98d", + "size": 266228, + "subdir": "linux-64", + "timestamp": 1535503161531, + "version": "1.2.0" + }, + "pexpect-4.2.1-py27hcf82287_0.conda": { + "build": "py27hcf82287_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "a93bacecaa91b83b2407a7819338b1f6", + "name": "pexpect", + "sha256": "019abf8c8b7f0c7df704551edd7c5a058d555e5160d64c25087289b57aba6116", + "size": 70786, + "subdir": "linux-64", + "timestamp": 1505690249749, + "version": "4.2.1" + }, + "pexpect-4.2.1-py35h8b56cb4_0.conda": { + "build": "py35h8b56cb4_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "a0fb2ad3990c5fc5299711927368d2a0", + "name": "pexpect", + "sha256": "c8254d3737723932cf55677f8b96ebc6870809d08a0343a69031d9966c42f59a", + "size": 73231, + "subdir": "linux-64", + "timestamp": 1505690261284, + "version": "4.2.1" + }, + "pexpect-4.2.1-py36h3b9d41b_0.conda": { + "build": "py36h3b9d41b_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "cfd1707b351c4b85ba096da9fd93333f", + "name": "pexpect", + "sha256": "050032d3906d844dab0d3fc88ca192353adccbbaa66043d1a8b9cf08b3e9ff18", + "size": 72650, + "subdir": "linux-64", + "timestamp": 1505690272959, + "version": "4.2.1" + }, + "pexpect-4.3.0-py27hdeba8d9_0.conda": { + "build": "py27hdeba8d9_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "baf13aa3442b7e92895701b2b4ae0466", + "name": "pexpect", + "sha256": "eb5b28da2cccd0f009bed34a86b6fc6a6e3d9b426f473a350a9adabf6ba776a5", + "size": 70610, + "subdir": "linux-64", + "timestamp": 1511841205793, + "version": "4.3.0" + }, + "pexpect-4.3.0-py35hf410859_0.conda": { + "build": "py35hf410859_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "3c864a48ee56dfea4eac938b6d6f8f74", + "name": "pexpect", + "sha256": "b9727a482b00abd6a251c684f0cf003075296abd15c987c9c010ed3e3fae6333", + "size": 74242, + "subdir": "linux-64", + "timestamp": 1511841241715, + "version": "4.3.0" + }, + "pexpect-4.3.0-py36h673ed17_0.conda": { + "build": "py36h673ed17_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "7d2960ed3df396ff5a98ebca428975dc", + "name": "pexpect", + "sha256": "10c9c4db941b44c89a31576fa470331090892fb36c94b083b5a7a19d2a9b8321", + "size": 73651, + "subdir": "linux-64", + "timestamp": 1511841221450, + "version": "4.3.0" + }, + "pexpect-4.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "dfc1233893c9753ea888ebccbb5194b1", + "name": "pexpect", + "sha256": "8666eb40bcea8dcb09bb1653f2bfc2305b1d1381b5f63fefd8d6b61c23053a63", + "size": 71666, + "subdir": "linux-64", + "timestamp": 1515707134531, + "version": "4.3.1" + }, + "pexpect-4.3.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "93888b88d430dad76320f094ee02219e", + "name": "pexpect", + "sha256": "6d815325ddb8aeb402245057a84efe0f6162c5899ad5e76d95bf6bf6a9a335f6", + "size": 72842, + "subdir": "linux-64", + "timestamp": 1515707263999, + "version": "4.3.1" + }, + "pexpect-4.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "8e198b1bae3c3e3fa35dcfa2c91689a2", + "name": "pexpect", + "sha256": "9aee75f336d9c9b0ffacaf539bc0c176756f08267d68a5c020b5dac1fb534be0", + "size": 73517, + "subdir": "linux-64", + "timestamp": 1515707046838, + "version": "4.3.1" + }, + "pexpect-4.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "8d06d69b5c7910f78e97e8df3e78d0ee", + "name": "pexpect", + "sha256": "52ae92f91444fcb62d0efdc6be145dbbacf34bebce02a786640b231dcb8727a4", + "size": 72159, + "subdir": "linux-64", + "timestamp": 1519148005297, + "version": "4.4.0" + }, + "pexpect-4.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "ab9f66e5feae271eb74697e517cd71e3", + "name": "pexpect", + "sha256": "3c29cfe21b4335c9338b439f34bd0edd1e355f93d907e3ce59559dcd86fb590a", + "size": 73248, + "subdir": "linux-64", + "timestamp": 1519148040547, + "version": "4.4.0" + }, + "pexpect-4.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "a66c925817ac2e5459d30de2dd4aa837", + "name": "pexpect", + "sha256": "fa7a07d06a81e3980a763441d594ccc5029e6f3858081019dfb0949e6aa64b33", + "size": 72717, + "subdir": "linux-64", + "timestamp": 1519148032012, + "version": "4.4.0" + }, + "pexpect-4.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "4e867fbd524858d820d610c868efec57", + "name": "pexpect", + "sha256": "696f6f36aa2e5bbe920807a4bbb466f5061cf71e4a0543a9ebd8c5c9b567c9b6", + "size": 74954, + "subdir": "linux-64", + "timestamp": 1523907815124, + "version": "4.5.0" + }, + "pexpect-4.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "b13a417ee16d63c685832b66dd57894b", + "name": "pexpect", + "sha256": "ce0fa95ee411a21142f388238318139dc761b49a3f289a1029b8b0e124985c97", + "size": 77397, + "subdir": "linux-64", + "timestamp": 1523907936265, + "version": "4.5.0" + }, + "pexpect-4.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "13451e6d0bee5beeb6460dd4040e4fef", + "name": "pexpect", + "sha256": "5cc6ec634aac5073884041d6c2904a43565b3e62a30d9c4bfde4349aaab1746b", + "size": 76768, + "subdir": "linux-64", + "timestamp": 1523907819876, + "version": "4.5.0" + }, + "pexpect-4.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "91beb0afcef6fc1a48ed5026d8bf26db", + "name": "pexpect", + "sha256": "270c647f67b74e05d48a4290921ef744266fd2842bb501e984fd81b0c046a098", + "size": 74812, + "subdir": "linux-64", + "timestamp": 1527826477402, + "version": "4.6.0" + }, + "pexpect-4.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "89bda772efdd42d2fde47bf01797efac", + "name": "pexpect", + "sha256": "54c790e5ec49d438d9bcb92d4519cd090c125ce4c5cb70cd806b5af2740de20b", + "size": 77033, + "subdir": "linux-64", + "timestamp": 1527826506177, + "version": "4.6.0" + }, + "pexpect-4.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "37daa5b50d9a3b0c4762b4faa3ebfeff", + "name": "pexpect", + "sha256": "6a2e9372ef5bd62d36f7bd399420c8c6984d568a03b3c88b8084dbdd46350bc7", + "size": 77857, + "subdir": "linux-64", + "timestamp": 1527826457979, + "version": "4.6.0" + }, + "pexpect-4.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "8a4529f0c4ddf424a59a80de0658c960", + "name": "pexpect", + "sha256": "32c5e1a5eda6c2e17539ebc35d8cdac03aebf6eb5356678cf3fae9976515acaf", + "size": 76660, + "subdir": "linux-64", + "timestamp": 1530694759457, + "version": "4.6.0" + }, + "pexpect-4.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "f255c946da427ed0846cb576e4160c78", + "name": "pexpect", + "sha256": "84f3828003938f9390011633b9e38895025900a96f0f11406e55db58820ac258", + "size": 80038, + "subdir": "linux-64", + "timestamp": 1555427841602, + "version": "4.7.0" + }, + "pexpect-4.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "696544d82009fe45f3733dd1db4b8e38", + "name": "pexpect", + "sha256": "863a27fb49754d37f3af85b2c2715bbe0507648f318ba8d68bceb144795b6084", + "size": 81996, + "subdir": "linux-64", + "timestamp": 1555428003756, + "version": "4.7.0" + }, + "pexpect-4.7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "93a5f01c9e8caf0fe01844482f590f1b", + "name": "pexpect", + "sha256": "64e3047e846571f71c694557203c08084ff63ece6bdc162018344008e3c13ebc", + "size": 82067, + "subdir": "linux-64", + "timestamp": 1555427971652, + "version": "4.7.0" + }, + "pexpect-4.7.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "e7eceeee32a93322109816a2f7053bc3", + "name": "pexpect", + "sha256": "454fc4d89baed25cba7cb119e0fdb018581a197def62ae8c2e51ecf3ddbf11c9", + "size": 79814, + "subdir": "linux-64", + "timestamp": 1573469456924, + "version": "4.7.0" + }, + "pexpect-4.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "eb077887b90adbb0ad075ac5a9520696", + "name": "pexpect", + "sha256": "df0bd011b08058f181abd10e1c1cca9b218838f50128b8aa6b63f88f56e179b7", + "size": 83897, + "subdir": "linux-64", + "timestamp": 1580151337466, + "version": "4.8.0" + }, + "pexpect-4.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "89d664a7b02d729817e53747cbeff392", + "name": "pexpect", + "sha256": "ecf8faa4a81a7a0f77b0ec90d88f101b6c1d45e313042218366af9e850999054", + "size": 84033, + "subdir": "linux-64", + "timestamp": 1580151296597, + "version": "4.8.0" + }, + "pexpect-4.8.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "ptyprocess >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "08c6e4591b3b153b409cc07efe8a6044", + "name": "pexpect", + "sha256": "b4b5c7c17ae6ebc2d3e69ae422211a2c3531421a16672c408812247a62b8ac41", + "size": 78763, + "subdir": "linux-64", + "timestamp": 1594383347774, + "version": "4.8.0" + }, + "pexpect-4.8.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ptyprocess >=0.5", + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "license_family": "Other", + "md5": "62403871da068ad7d751d8af727190b2", + "name": "pexpect", + "sha256": "24669aef558c291819d374138182b2f720e087f8ed00826db3631599fec1e62e", + "size": 83084, + "subdir": "linux-64", + "timestamp": 1580151297821, + "version": "4.8.0" + }, + "phik-0.12.2-py310hdb19cb5_0.conda": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "joblib >=0.14.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.3", + "numpy >=1.18.0", + "pandas >=0.25.1", + "python >=3.10,<3.11.0a0", + "scipy >=1.5.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "05769186bba2a56d61300428b0375653", + "name": "phik", + "sha256": "9bdc7eca476e2bf4835b507c7ce8a34c730370a6c715764addedfcb3c81f5e4f", + "size": 636750, + "subdir": "linux-64", + "timestamp": 1668544895753, + "version": "0.12.2" + }, + "phik-0.12.2-py37hdb19cb5_0.conda": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "joblib >=0.14.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.3", + "numpy >=1.18.0", + "pandas >=0.25.1", + "python >=3.7,<3.8.0a0", + "scipy >=1.5.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "71466710c7d5d5c785483aa9bde14907", + "name": "phik", + "sha256": "5ec3e99899ec32b4737dee55d9ddfabb1f4659327302608222e47950b8129b9b", + "size": 635315, + "subdir": "linux-64", + "timestamp": 1668544786611, + "version": "0.12.2" + }, + "phik-0.12.2-py38hdb19cb5_0.conda": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "joblib >=0.14.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.3", + "numpy >=1.18.0", + "pandas >=0.25.1", + "python >=3.8,<3.9.0a0", + "scipy >=1.5.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "63b5a77e8ad9a549a278b77b6da448c5", + "name": "phik", + "sha256": "c11d1a15543a19afabf4b14e0538b6b65539c9a808c9b66df0f8a4932b91495c", + "size": 635140, + "subdir": "linux-64", + "timestamp": 1668544726557, + "version": "0.12.2" + }, + "phik-0.12.2-py39hdb19cb5_0.conda": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "joblib >=0.14.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.3", + "numpy >=1.18.0", + "pandas >=0.25.1", + "python >=3.9,<3.10.0a0", + "scipy >=1.5.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e4ad4886687b26785c2fcf83fc7b6796", + "name": "phik", + "sha256": "5bc9ba607ebea5a2ab83bebb3f2e724230ada6b613cf935a24842b59f97d7fd6", + "size": 635712, + "subdir": "linux-64", + "timestamp": 1668544841611, + "version": "0.12.2" + }, + "phik-0.12.3-py310hdb19cb5_0.conda": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "joblib >=0.14.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.3", + "numpy >=1.18.0", + "pandas >=0.25.1", + "python >=3.10,<3.11.0a0", + "scipy >=1.5.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "586d069da79f6b263f625e313d40ac86", + "name": "phik", + "sha256": "98a7c89ef800ad17ae001697de4fb5021dfb91b6c2f9c03f9de81666a5597e85", + "size": 637161, + "subdir": "linux-64", + "timestamp": 1670955853084, + "version": "0.12.3" + }, + "phik-0.12.3-py311hdb19cb5_0.conda": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "joblib >=0.14.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.3", + "numpy >=1.18.0", + "pandas >=0.25.1", + "python >=3.11,<3.12.0a0", + "scipy >=1.5.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e5367168af9a48c14a57b205a4969c0d", + "name": "phik", + "sha256": "b8f9c059f9e49f569bf0ef1069b7a2a77260ee515f2550294fc5b58333b21f03", + "size": 646775, + "subdir": "linux-64", + "timestamp": 1676845164532, + "version": "0.12.3" + }, + "phik-0.12.3-py37hdb19cb5_0.conda": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "joblib >=0.14.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.3", + "numpy >=1.18.0", + "pandas >=0.25.1", + "python >=3.7,<3.8.0a0", + "scipy >=1.5.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "be710e2a99b09e1823c40d764f34ab3f", + "name": "phik", + "sha256": "bd00cd026e1b8883b41ce8b0dcc94764d098c74d0ceb1d5280b54fe91ed20756", + "size": 637066, + "subdir": "linux-64", + "timestamp": 1670955964411, + "version": "0.12.3" + }, + "phik-0.12.3-py38hdb19cb5_0.conda": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "joblib >=0.14.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.3", + "numpy >=1.18.0", + "pandas >=0.25.1", + "python >=3.8,<3.9.0a0", + "scipy >=1.5.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "93c757c140b01ed61b2b84423bda8c24", + "name": "phik", + "sha256": "c2c59ce452ff192de3d9b5c8311aa84d743adb5e1ec35abed104d95d7d854cf3", + "size": 636225, + "subdir": "linux-64", + "timestamp": 1670956017415, + "version": "0.12.3" + }, + "phik-0.12.3-py39hdb19cb5_0.conda": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "joblib >=0.14.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib-base >=2.2.3", + "numpy >=1.18.0", + "pandas >=0.25.1", + "python >=3.9,<3.10.0a0", + "scipy >=1.5.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1dfe4808681b3fe004fec19705937438", + "name": "phik", + "sha256": "d169fdcb08ad4a6d6608839b9c94f9e8969be37193506465657c81583bfbf604", + "size": 636994, + "subdir": "linux-64", + "timestamp": 1670955910775, + "version": "0.12.3" + }, + "phonenumbers-8.10.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "77860513b3a2a4899ebfec8b6cd3ea06", + "name": "phonenumbers", + "sha256": "59817f82eb1e4a7d9b6ccf25a56ec183703e5e2a2cf7f7cf2d2f9d769a464ca2", + "size": 3945043, + "subdir": "linux-64", + "timestamp": 1542408111438, + "version": "8.10.0" + }, + "phonenumbers-8.10.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "62f6675b0deea60623769e55c0c9e3a2", + "name": "phonenumbers", + "sha256": "2b566dafc75c82eb140fce861521b5472513a4f0632e863a773d91fd221224c8", + "size": 3587221, + "subdir": "linux-64", + "timestamp": 1542408135746, + "version": "8.10.0" + }, + "phonenumbers-8.10.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3f4fac1fa55176fdffabf2140ec19468", + "name": "phonenumbers", + "sha256": "6d9edd65f236de81a79ebcb4f0e19d6a340b4e9b1228cf80b5e4da855df3128c", + "size": 3573812, + "subdir": "linux-64", + "timestamp": 1542408115481, + "version": "8.10.0" + }, + "phonenumbers-8.10.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4041219e6e106cb3f326f8ab281b3eee", + "name": "phonenumbers", + "sha256": "18ca278395801688c020bfa433d4fb493d9f6075cd8f177ec0046ca03061c4e5", + "size": 3926510, + "subdir": "linux-64", + "timestamp": 1543602329663, + "version": "8.10.1" + }, + "phonenumbers-8.10.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ff5df5d2071f984ccae9275b8e1740a4", + "name": "phonenumbers", + "sha256": "fb08ffcba5c1f5a41b155c8743f1eca63b43eed7cc741db7fe0dd8f37665fb0e", + "size": 3578147, + "subdir": "linux-64", + "timestamp": 1543602334049, + "version": "8.10.1" + }, + "phonenumbers-8.10.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "87b1d20b45729cea3412d555a4928510", + "name": "phonenumbers", + "sha256": "d6a1757025e08cc7d963734a2347f026cc77b987cc2ec7d8e9afc4dc3c3af577", + "size": 3567947, + "subdir": "linux-64", + "timestamp": 1543602352549, + "version": "8.10.1" + }, + "phonenumbers-8.10.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "82db0381c85106ff883b0eb57f114299", + "name": "phonenumbers", + "sha256": "e7a64426772e9e94d22134f11449d5060708fc25671821121e07add4fbe6f1ce", + "size": 3924426, + "subdir": "linux-64", + "timestamp": 1545142518590, + "version": "8.10.2" + }, + "phonenumbers-8.10.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0cf8a627795d958fa24dcc27d5454fb3", + "name": "phonenumbers", + "sha256": "50abf64a2cf7c4d034c2ed50be2af12e4395670b1c1707f31152b1e7726408c5", + "size": 3567663, + "subdir": "linux-64", + "timestamp": 1545126151557, + "version": "8.10.2" + }, + "phonenumbers-8.10.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7695c54486c75b1cabe0f12925b4b0eb", + "name": "phonenumbers", + "sha256": "4a7d3d7e95292b9102481a5b8e77c2585f3c9d415bb5fb452ad146f9fd44f130", + "size": 3566333, + "subdir": "linux-64", + "timestamp": 1545142487786, + "version": "8.10.2" + }, + "phonenumbers-8.10.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8127e09eeb4eb8e765750c1f5179da2d", + "name": "phonenumbers", + "sha256": "54fae1bb44d6e2223e901d6008bba2b72e049519e44dc5716b7d9b07f407222b", + "size": 3897600, + "subdir": "linux-64", + "timestamp": 1550350624589, + "version": "8.10.5" + }, + "phonenumbers-8.10.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cb8f6771b37effecde6e1227abc3d490", + "name": "phonenumbers", + "sha256": "ead442b64035371174e066c498b82da5e700e00dbf207a39e69474315f68dabf", + "size": 3542898, + "subdir": "linux-64", + "timestamp": 1550350732422, + "version": "8.10.5" + }, + "phonenumbers-8.10.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "288513b2c9a5fa08d37952a7a0adcee1", + "name": "phonenumbers", + "sha256": "ea234d8888e80c52515b854a84b17ed3e16aa3aa197e01e843de00f2e933300d", + "size": 3551334, + "subdir": "linux-64", + "timestamp": 1550350551443, + "version": "8.10.5" + }, + "phonenumbers-8.8.0-py27h8056f28_0.conda": { + "build": "py27h8056f28_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6dd7c453f00b49760e7a31041cb5e415", + "name": "phonenumbers", + "sha256": "076ccd9e33af69e8635a3b58e67be1756934a9e8b5a15aceebfc75a7103e20f5", + "size": 3165477, + "subdir": "linux-64", + "timestamp": 1505751016381, + "version": "8.8.0" + }, + "phonenumbers-8.8.0-py35h01792f9_0.conda": { + "build": "py35h01792f9_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f4ce4ee07eafd925b3f397ac27cbae67", + "name": "phonenumbers", + "sha256": "14bb222e43c1739c4bb5491eefdbba3c4e93c864de8797659949779959632575", + "size": 3248519, + "subdir": "linux-64", + "timestamp": 1505751092664, + "version": "8.8.0" + }, + "phonenumbers-8.8.0-py36h078def6_0.conda": { + "build": "py36h078def6_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "68c24486603d3cf42cd6865fd68628f7", + "name": "phonenumbers", + "sha256": "67fe4386bec531487aa263e0f7d801e307264f14b5e4d0c25426a553b4f9f186", + "size": 2839889, + "subdir": "linux-64", + "timestamp": 1505751166757, + "version": "8.8.0" + }, + "phonenumbers-8.8.6-py27h05b9aca_0.conda": { + "build": "py27h05b9aca_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "98fa17abd9a67b7b1a09ae879bfadf3b", + "name": "phonenumbers", + "sha256": "1423db3c2d391334d0327304e4ea4af472df4dba6b5b6f931319c0e04067cacb", + "size": 3629927, + "subdir": "linux-64", + "timestamp": 1511323104705, + "version": "8.8.6" + }, + "phonenumbers-8.8.6-py35ha0406aa_0.conda": { + "build": "py35ha0406aa_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "71fdc3e85071d9c9a6e836957668645a", + "name": "phonenumbers", + "sha256": "b7107a05ec78dfeb9794ed00b018d7e7b4f0c0b2ab3cb71852c9ddb10509d335", + "size": 3740494, + "subdir": "linux-64", + "timestamp": 1511323129136, + "version": "8.8.6" + }, + "phonenumbers-8.8.6-py36h7f468f6_0.conda": { + "build": "py36h7f468f6_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ef0df38f52844750d09f4d3ac9250364", + "name": "phonenumbers", + "sha256": "c998735e329ff157ba6e373c58d56bd83a4194e294358f4619bd63f667abf362", + "size": 3216304, + "subdir": "linux-64", + "timestamp": 1511323128311, + "version": "8.8.6" + }, + "phonenumbers-8.9.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3f41dd9d4270882780b5e830558ebffb", + "name": "phonenumbers", + "sha256": "29ab94b57ba4b11cfccd22e99a3688e954c873a3531ac66f33ffa3e09106361b", + "size": 3641906, + "subdir": "linux-64", + "timestamp": 1520909954754, + "version": "8.9.1" + }, + "phonenumbers-8.9.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ac8a585b49faf7ccbbcf40b272645207", + "name": "phonenumbers", + "sha256": "e8dee15cc530236d0218f2979ed7a79b2c9c79842de1a993a64312f403ec0611", + "size": 3746384, + "subdir": "linux-64", + "timestamp": 1520910005476, + "version": "8.9.1" + }, + "phonenumbers-8.9.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7273806c889af3fc23d11eff1eeff2d6", + "name": "phonenumbers", + "sha256": "708e353d3aa42722ea6ea616f43157a49b3ef4b1c443f134ebb5622e27807944", + "size": 3251688, + "subdir": "linux-64", + "timestamp": 1520909936194, + "version": "8.9.1" + }, + "phonenumbers-8.9.11-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "824df4a89f6b26022c706643f72e01b1", + "name": "phonenumbers", + "sha256": "d092a484665c304eae27691480eff028adef4339dde4f5ac4aef6efe397bcadd", + "size": 3700959, + "subdir": "linux-64", + "timestamp": 1535509305649, + "version": "8.9.11" + }, + "phonenumbers-8.9.11-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a7b72da394d3dfc524e96d4f6976fbe8", + "name": "phonenumbers", + "sha256": "e973726621495e073638478ec94d09ca6281e3ab6f9b7bd4c783c3f42d1ff692", + "size": 3818511, + "subdir": "linux-64", + "timestamp": 1535509403452, + "version": "8.9.11" + }, + "phonenumbers-8.9.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "267ccac1d91000efcb3350caee0070c8", + "name": "phonenumbers", + "sha256": "3aef40508e0b96e0c2e897b56a76e7cc7398de7cd145674ff5295d4c13d0c9cd", + "size": 3329727, + "subdir": "linux-64", + "timestamp": 1535509347196, + "version": "8.9.11" + }, + "phonenumbers-8.9.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "48676a09204a01218d01d864de175116", + "name": "phonenumbers", + "sha256": "e4e614fe3aa287a6899875169402a932428bc9aa9d96eb4a2a6ecbb3915cdaca", + "size": 3300891, + "subdir": "linux-64", + "timestamp": 1535509419225, + "version": "8.9.11" + }, + "phonenumbers-8.9.15-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8615d0ddae070f8a8508aa2999e20fe7", + "name": "phonenumbers", + "sha256": "6bb0ec8872da0d35a2bbd8f0d9017b45f3dacc0509b8f2622c06d3cf59fc23d7", + "size": 3736658, + "subdir": "linux-64", + "timestamp": 1539656165147, + "version": "8.9.15" + }, + "phonenumbers-8.9.15-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c6c5b5f0aeb1179a841b751f2b8fb308", + "name": "phonenumbers", + "sha256": "e9e16652d069821ecda8a955e93ea081e2c6b8e8c29150ccd2f929d1d5ffc91e", + "size": 3330657, + "subdir": "linux-64", + "timestamp": 1539656199637, + "version": "8.9.15" + }, + "phonenumbers-8.9.15-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5fbb846145ac145b9f4f1443f25fcfd5", + "name": "phonenumbers", + "sha256": "b28ae27e38c5ccad178f56375d9dd61c00864ec52be24009cf9eba3c1868bb8f", + "size": 3317571, + "subdir": "linux-64", + "timestamp": 1539656197508, + "version": "8.9.15" + }, + "phonenumbers-8.9.16-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "baa4ca0037789de433ac54fb5fa70e45", + "name": "phonenumbers", + "sha256": "57cb262f0468c66b5a10b55949838dd995c3faf3c3ea1fa5a460df44942036be", + "size": 3979048, + "subdir": "linux-64", + "timestamp": 1540998982424, + "version": "8.9.16" + }, + "phonenumbers-8.9.16-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a220ba155fabd6e7ad398cc221b42565", + "name": "phonenumbers", + "sha256": "bd59b6843c566b3fa978232a9371cae9c10371e5d122e6a2255839d49eb1566b", + "size": 3613093, + "subdir": "linux-64", + "timestamp": 1540999007512, + "version": "8.9.16" + }, + "phonenumbers-8.9.16-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0fa22b8798e15b76e1ca490ff2efcaf0", + "name": "phonenumbers", + "sha256": "416a3981b549baf149c5f93d3ba66225f4efe55213b5599750eb7553a9feaa7a", + "size": 3610534, + "subdir": "linux-64", + "timestamp": 1540999062123, + "version": "8.9.16" + }, + "phonenumbers-8.9.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fa498e18fa5c5c867c9ccec4ead227ef", + "name": "phonenumbers", + "sha256": "ed799859a138718089b6b206716772ce1f7064393d04790b05cb99ea224998fa", + "size": 3648886, + "subdir": "linux-64", + "timestamp": 1522786083984, + "version": "8.9.2" + }, + "phonenumbers-8.9.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ff1078da67d8c984485785666adbd1bf", + "name": "phonenumbers", + "sha256": "667d43c8cafbebeced1894972d2b85c047af435b6d4b371048f056ea355002fc", + "size": 3741667, + "subdir": "linux-64", + "timestamp": 1522786146723, + "version": "8.9.2" + }, + "phonenumbers-8.9.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bf5cb4971a194f157e50cd674d0fc2cc", + "name": "phonenumbers", + "sha256": "380bdacf04d7d871585d135f7d38c8a48de38c43ca8b430dfe62572862f23afa", + "size": 3255200, + "subdir": "linux-64", + "timestamp": 1522786151753, + "version": "8.9.2" + }, + "phonenumbers-8.9.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b943e680050579cf8fd6767306ff68b3", + "name": "phonenumbers", + "sha256": "afba784a74e75f83be885d361fcff5223ffbe62fe2d21dae150da624a4f3062a", + "size": 3648044, + "subdir": "linux-64", + "timestamp": 1524085400970, + "version": "8.9.4" + }, + "phonenumbers-8.9.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ade8c664ff8097caaf73f5332c65fbb3", + "name": "phonenumbers", + "sha256": "a23505051d9c3978d13b1879d07d725d7fb79dcd9ba4127f01d34b0d54c25548", + "size": 3740988, + "subdir": "linux-64", + "timestamp": 1524085374486, + "version": "8.9.4" + }, + "phonenumbers-8.9.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4d4f090044dd731b1bdec7eee2eb29ca", + "name": "phonenumbers", + "sha256": "30f9fb02cd2b8fc5367359d74e67d5673fbad9eaf8d312516b22a74d98cd9e78", + "size": 3253703, + "subdir": "linux-64", + "timestamp": 1524085421159, + "version": "8.9.4" + }, + "phonenumbers-8.9.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e1887f2c588719e6d84a5caf0a971c0b", + "name": "phonenumbers", + "sha256": "58dd0916668d61d003197da1d9156bf8991f54cb90a9b0bc126de23d0bed61d1", + "size": 3688933, + "subdir": "linux-64", + "timestamp": 1526937858316, + "version": "8.9.6" + }, + "phonenumbers-8.9.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f78e08b9e6cbc0ba8a18ff076652a68a", + "name": "phonenumbers", + "sha256": "18e506c63d6290357068286b868bb9ad1d353fff42bfdf824d77ed6cb4235d9b", + "size": 3790611, + "subdir": "linux-64", + "timestamp": 1526937878515, + "version": "8.9.6" + }, + "phonenumbers-8.9.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dd7544a5154416cda0e153bc7d0a9dc9", + "name": "phonenumbers", + "sha256": "b35fca51fcf0d77391426a93d44882d574f253c51da6dcd5a3db1b39fd779fd9", + "size": 3275454, + "subdir": "linux-64", + "timestamp": 1526937861338, + "version": "8.9.6" + }, + "phonenumbers-8.9.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "23c7bc00debaec00e033efa630bb3271", + "name": "phonenumbers", + "sha256": "b90103cb0c64f6b4b92769496a84af08efb55146c7a4e8b72303ebf2bc180d09", + "size": 3763628, + "subdir": "linux-64", + "timestamp": 1528218934064, + "version": "8.9.7" + }, + "phonenumbers-8.9.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fcc6b71c1118f086847810196397cc3f", + "name": "phonenumbers", + "sha256": "a23212322ab13a397c68184c607c24a4043aa555af6988d45d7935d42dbc04c8", + "size": 3827973, + "subdir": "linux-64", + "timestamp": 1528218969597, + "version": "8.9.7" + }, + "phonenumbers-8.9.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "89222d1b77d01097c65d0abc41a10a61", + "name": "phonenumbers", + "sha256": "fad63d75b124fce2b71871f01cfb47051b6716a1842520ec0ce4b33a8a171693", + "size": 3329568, + "subdir": "linux-64", + "timestamp": 1528218896421, + "version": "8.9.7" + }, + "phonenumbers-8.9.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3056386e9f80b92d5aa1fdcab86b045f", + "name": "phonenumbers", + "sha256": "9abfee9930ea1c77981e2b1063403bac269c65bb39d3eec00d469eb22e151b80", + "size": 3764699, + "subdir": "linux-64", + "timestamp": 1529438190517, + "version": "8.9.8" + }, + "phonenumbers-8.9.8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3d06deb896c5a807cd02475f1eb42405", + "name": "phonenumbers", + "sha256": "19369a8df8b78fec6456aea5f249dee4cf78ecc1da11299f44b1bf381404f7cb", + "size": 3869502, + "subdir": "linux-64", + "timestamp": 1529438508035, + "version": "8.9.8" + }, + "phonenumbers-8.9.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a6c31bfc8c377f069de57898a1d33499", + "name": "phonenumbers", + "sha256": "aa3bfa613b530d1f4bdb9e08db68c2221d8e4c32f78b19f6c40343bd52177ba5", + "size": 3344591, + "subdir": "linux-64", + "timestamp": 1529438483522, + "version": "8.9.8" + }, + "phonenumbers-8.9.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1d48c351f7fc73b40f89e7081f499957", + "name": "phonenumbers", + "sha256": "8bea0f08b52277fbda93ec051ee88c3666052fd29d1b0fc4eef7f579355bdfc2", + "size": 3323567, + "subdir": "linux-64", + "timestamp": 1530905142616, + "version": "8.9.8" + }, + "picklable-itertools-0.1.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "b39262e2e81b3e02379f21b9c4a073c1", + "name": "picklable-itertools", + "sha256": "e1b000114040e6e5f4747229687b686e0c388d10e95edfdefab10380d637baf9", + "size": 26203, + "subdir": "linux-64", + "timestamp": 1537278625690, + "version": "0.1.1" + }, + "picklable-itertools-0.1.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "9d1c49fa86390c68b5fa69b59ad00fe8", + "name": "picklable-itertools", + "sha256": "fe3f6b5b43ea99bb76f1d6860f107245910a3f8a185db3867b90cace31501547", + "size": 30141, + "subdir": "linux-64", + "timestamp": 1643113051939, + "version": "0.1.1" + }, + "picklable-itertools-0.1.1-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "7e0eee4fb85f11f0501d6467abb9d597", + "name": "picklable-itertools", + "sha256": "ca8f0072a860ff3f5bf8057831fcd6fbd3b1d9358b387c88f75b9e8270f48510", + "size": 34175, + "subdir": "linux-64", + "timestamp": 1676906138640, + "version": "0.1.1" + }, + "picklable-itertools-0.1.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "63194352d0fc5ae6f3361bedea845970", + "name": "picklable-itertools", + "sha256": "efe0bfb89f0516c76284ea4cc5c40ac0a577ef9b638ec475c98198ca80ebcdf5", + "size": 26495, + "subdir": "linux-64", + "timestamp": 1537278630993, + "version": "0.1.1" + }, + "picklable-itertools-0.1.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "4385578a2b673ee104e0c44942a8bfae", + "name": "picklable-itertools", + "sha256": "31acc705b84a9372fee3e70d89eb5d1da84b4a8ce6917a9ad064f57b8a6d019f", + "size": 26344, + "subdir": "linux-64", + "timestamp": 1537278645296, + "version": "0.1.1" + }, + "picklable-itertools-0.1.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "1791bb92b383bc285c2854558407a112", + "name": "picklable-itertools", + "sha256": "7f4a8835c0ef51172bcd3159d45a89db51370a69ad3dde190c3e19e1a53d3be0", + "size": 268097, + "subdir": "linux-64", + "timestamp": 1613553932758, + "version": "0.1.1" + }, + "picklable-itertools-0.1.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "830473712fa744b9bb1c82110bd45a9a", + "name": "picklable-itertools", + "sha256": "25cffba701f3d98759b0085bb17171fcea26f27e1b4206f16c57fb8658a1e036", + "size": 26440, + "subdir": "linux-64", + "timestamp": 1537278581841, + "version": "0.1.1" + }, + "picklable-itertools-0.1.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "7b9c30f4728e821b0ae8b824f69bea7a", + "name": "picklable-itertools", + "sha256": "548c58be6e3687fb055b6ab3a319afd5b9e0e5dc3f482d762c3cadcf4f8aa65f", + "size": 267737, + "subdir": "linux-64", + "timestamp": 1613553923873, + "version": "0.1.1" + }, + "picklable-itertools-0.1.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "5a097021cedf7d05ba5a10f9f26ecd0c", + "name": "picklable-itertools", + "sha256": "3ac44feb14a3308facfc7c62da49aa39d4e540a4a383e2fadc8cdcef248e5914", + "size": 268178, + "subdir": "linux-64", + "timestamp": 1613553931327, + "version": "0.1.1" + }, + "picklable-itertools-0.1.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "six" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "ac6db7a1dc45634dd2982409bdd62250", + "name": "picklable-itertools", + "sha256": "3ef05223a538bf113160dd368ec9984ce41b33a9d8dcba1771f12b1054b0fc21", + "size": 267480, + "subdir": "linux-64", + "timestamp": 1613553921168, + "version": "0.1.1" + }, + "pickle5-0.0.11-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-2.0", + "md5": "c3fe65a9c00a513bb9680df255860a39", + "name": "pickle5", + "sha256": "65f0f08fbe8e4c809bc2830e4d6deff8f8e669421f5ceca9ccb8d6b9b6a5a41b", + "size": 173884, + "subdir": "linux-64", + "timestamp": 1621432720502, + "version": "0.0.11" + }, + "pickle5-0.0.11-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "md5": "4ec7208fd05c1d69ceae8a39ad9a48a8", + "name": "pickle5", + "sha256": "46879c83bfc3cd17201619d65fa40b460385aaa79167017a0ae095a66f79fda2", + "size": 173410, + "subdir": "linux-64", + "timestamp": 1621428095016, + "version": "0.0.11" + }, + "pickleshare-0.7.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pathlib2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7d7f479349cc0f2263443de6a18c66ef", + "name": "pickleshare", + "sha256": "9bfda0709df00f5ac633e80de55beafcda1496e621856ed476bce999d990f412", + "size": 11831, + "subdir": "linux-64", + "timestamp": 1530733913904, + "version": "0.7.4" + }, + "pickleshare-0.7.4-py27h09770e1_0.conda": { + "build": "py27h09770e1_0", + "build_number": 0, + "depends": [ + "pathlib2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ed43c33a9d29910334753b46b391ba3f", + "name": "pickleshare", + "sha256": "450f77d8fde02a402759370e548b94717bbbcb80b8177ac7b19b7075fae047f4", + "size": 11752, + "subdir": "linux-64", + "timestamp": 1505690117722, + "version": "0.7.4" + }, + "pickleshare-0.7.4-py35hd57304d_0.conda": { + "build": "py35hd57304d_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "b1a741a2ddb80ff6fc0a937571d5bf05", + "name": "pickleshare", + "sha256": "a77a7ec28c49d65b576e37f71df054bb72256cc31d42e1d4ac7efe13d60592dc", + "size": 11873, + "subdir": "linux-64", + "timestamp": 1505690128538, + "version": "0.7.4" + }, + "pickleshare-0.7.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a4807e16e584eef06b8cc4498f4bb7f9", + "name": "pickleshare", + "sha256": "70bac61d1589a030c177197f5ce9600c70c573de34932e3b7a182639a6f0a081", + "size": 11983, + "subdir": "linux-64", + "timestamp": 1530733894410, + "version": "0.7.4" + }, + "pickleshare-0.7.4-py36h63277f8_0.conda": { + "build": "py36h63277f8_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a218e8b82f5d1e31c3db808ed542ddae", + "name": "pickleshare", + "sha256": "9a90b8da94505e7cb295daefac620c21bfb4c31e4c502af37303915e992a46d2", + "size": 11793, + "subdir": "linux-64", + "timestamp": 1505690139442, + "version": "0.7.4" + }, + "pickleshare-0.7.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "0a0cf921a7ec07182d69337f0fafe67c", + "name": "pickleshare", + "sha256": "513e4a84f48e6ff84b7cce54b8026286b4eb0fb259dfc1673d84afd6cd1484dd", + "size": 12079, + "subdir": "linux-64", + "timestamp": 1530733933953, + "version": "0.7.4" + }, + "pickleshare-0.7.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pathlib2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "3089beafacd3084aef5bd9dcffd16cf3", + "name": "pickleshare", + "sha256": "4a84fa54ace55a0dd6f51e59c79013ff9f0a9ce529c615fed6e39bac879bf2d6", + "size": 13144, + "subdir": "linux-64", + "timestamp": 1538597743403, + "version": "0.7.5" + }, + "pickleshare-0.7.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8977cc23ff0d9018999d986bbe6d44f0", + "name": "pickleshare", + "sha256": "5fa3544e8d21f3137ba63cbf65ab0cd4de7b90cab8b50f6ed309e1e613e02ebe", + "size": 13177, + "subdir": "linux-64", + "timestamp": 1538597773015, + "version": "0.7.5" + }, + "pickleshare-0.7.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3672172b55b8accb6d85ebd1163ca969", + "name": "pickleshare", + "sha256": "3e78a8a02feca767e668e2b2026ba0d860842cd8865b4da74063286b616715e1", + "size": 13108, + "subdir": "linux-64", + "timestamp": 1538597722845, + "version": "0.7.5" + }, + "pickleshare-0.7.5-py37_1001.conda": { + "build": "py37_1001", + "build_number": 1001, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "307c9e01edc58778a7a57f95923a4d51", + "name": "pickleshare", + "sha256": "3c25046ba3c45024e9cb745c3ce092b8f39025f679b4f016dd73a2fb11a09543", + "size": 12957, + "subdir": "linux-64", + "timestamp": 1594384104043, + "version": "0.7.5" + }, + "pickleshare-0.7.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "98e791535fcf956d46a2803986109895", + "name": "pickleshare", + "sha256": "10694f416dc050a23eb131d2ae51f348147d9b5bd460d966e94b945b9ea0370a", + "size": 15700, + "subdir": "linux-64", + "timestamp": 1575498328366, + "version": "0.7.5" + }, + "pickleshare-0.7.5-py38_1000.conda": { + "build": "py38_1000", + "build_number": 1000, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "c3d01ac533506015522e26353e85387d", + "name": "pickleshare", + "sha256": "946902596d3d0db1d118102c5814c0a01be121f76103d68943184c33db3f3d7e", + "size": 13615, + "subdir": "linux-64", + "timestamp": 1573489536066, + "version": "0.7.5" + }, + "pigz-2.4-h84994c4_0.conda": { + "build": "h84994c4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "zlib", + "license_family": "other", + "md5": "85be146bdb6d17817414ff5bb70b1766", + "name": "pigz", + "sha256": "30dc91760f9a3c19f91bfdd7ecdf4ec42e50e517fd1d5b87fb7787f9aa464d6c", + "size": 65411, + "subdir": "linux-64", + "timestamp": 1529594787590, + "version": "2.4" + }, + "pigz-2.6-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0", + "zlib >=1.2.6" + ], + "license": "zlib", + "license_family": "other", + "md5": "c350c6260f1fdd1e0d4e1f9aa8d5bc65", + "name": "pigz", + "sha256": "b120b5e0c98a2c44e1d47920597485f26e2f4f716c1dffc1fb114199721bc672", + "size": 71200, + "subdir": "linux-64", + "timestamp": 1623153770630, + "version": "2.6" + }, + "pigz-2.6-h8f29fe8_0.conda": { + "build": "h8f29fe8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "zlib", + "license_family": "other", + "md5": "4e7b45ab89fb2f4596d7fc75f4c36325", + "name": "pigz", + "sha256": "e8c67c9e4b6d86aee91e38eb5817d6f95fdb7a1801d0db5495ed1b49f77a93b5", + "size": 71138, + "subdir": "linux-64", + "timestamp": 1623072335564, + "version": "2.6" + }, + "pillow-4.2.1-py27h7cd2321_0.conda": { + "build": "py27h7cd2321_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.8,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "f5abe701894d62440fca618f8de0b23e", + "name": "pillow", + "sha256": "a34dd78e76593751c17231362a6dd84f745c45fc4d26771e1445cd9c998bb054", + "size": 524667, + "subdir": "linux-64", + "timestamp": 1505744454000, + "version": "4.2.1" + }, + "pillow-4.2.1-py35h03abc04_0.conda": { + "build": "py35h03abc04_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.8,<5.0a0", + "olefile", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "0d3e043d8197cd9f2b1cdc44d6cc72be", + "name": "pillow", + "sha256": "5f55135a1ba1f3e45cac5bbf3f9f2e34d9dd6aafb4ba4430714b0519713985ac", + "size": 531104, + "subdir": "linux-64", + "timestamp": 1505744486716, + "version": "4.2.1" + }, + "pillow-4.2.1-py36h9119f52_0.conda": { + "build": "py36h9119f52_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.8,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "3352611e1e0f6eba3dd89c2f4d922de1", + "name": "pillow", + "sha256": "84a7f4f659c6d5a5050ccaf89905093447a8e224191c8a2b2cd63e08884983a1", + "size": 526545, + "subdir": "linux-64", + "timestamp": 1505744519253, + "version": "4.2.1" + }, + "pillow-4.3.0-py27h353bd0c_1.conda": { + "build": "py27h353bd0c_1", + "build_number": 1, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "72c3bc5627896a96b799e23e4e0db77f", + "name": "pillow", + "sha256": "65a6d32b872f7e218848b293f051a364628b5ec6a7e0001541ff3dac2094f77c", + "size": 544048, + "subdir": "linux-64", + "timestamp": 1512163198571, + "version": "4.3.0" + }, + "pillow-4.3.0-py35h550890c_1.conda": { + "build": "py35h550890c_1", + "build_number": 1, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.5,<3.6.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "2d6274c8876514fa0d8de27558e0e8b9", + "name": "pillow", + "sha256": "c5d6117e382263496d06ae380d8edfe2ad99c0009b4be81a6d0b2c686e8133c3", + "size": 547039, + "subdir": "linux-64", + "timestamp": 1512163149461, + "version": "4.3.0" + }, + "pillow-4.3.0-py36h6f462bf_1.conda": { + "build": "py36h6f462bf_1", + "build_number": 1, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "b034edc20845713f9328c9aaa2e3e8e2", + "name": "pillow", + "sha256": "98ff9a6f349ff20def009dafada323752fb8179982ff55d72d4f3c33045fdcd7", + "size": 541584, + "subdir": "linux-64", + "timestamp": 1512163229153, + "version": "4.3.0" + }, + "pillow-5.0.0-py27h3deb7b8_0.conda": { + "build": "py27h3deb7b8_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "1b2ccdf1f675eb2fbebbf89abad37b85", + "name": "pillow", + "sha256": "04106406de4b48feefb356d07d290fca521732a91edb256714a87f0bc171e748", + "size": 539313, + "subdir": "linux-64", + "timestamp": 1515097663552, + "version": "5.0.0" + }, + "pillow-5.0.0-py35h3deb7b8_0.conda": { + "build": "py35h3deb7b8_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.5,<3.6.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "466ee74f396eed24aa16dd407a611a95", + "name": "pillow", + "sha256": "89a0d0f99dc819b28c8ed7102a58b14333249ab7947d1950d362ad3a250a735e", + "size": 538139, + "subdir": "linux-64", + "timestamp": 1515097703212, + "version": "5.0.0" + }, + "pillow-5.0.0-py36h3deb7b8_0.conda": { + "build": "py36h3deb7b8_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "f57eee349bd9e2ccf3b4387f86ddb554", + "name": "pillow", + "sha256": "139d608f3c1b9c1c81a71b9a7c57efb73f388b33fb31f0525e8f69e02249c1e7", + "size": 538612, + "subdir": "linux-64", + "timestamp": 1515097744186, + "version": "5.0.0" + }, + "pillow-5.1.0-py27h3deb7b8_0.conda": { + "build": "py27h3deb7b8_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "e7670d2df9deb4a2f0de5a4508ef55ce", + "name": "pillow", + "sha256": "d046a187ef3f61c5cdec675edf24ad63281275e27b3c070bbd775e5ebb16d487", + "size": 559905, + "subdir": "linux-64", + "timestamp": 1523904277268, + "version": "5.1.0" + }, + "pillow-5.1.0-py27heded4f4_0.conda": { + "build": "py27heded4f4_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "becf7a2f6901f9482e5a6b70badb2523", + "name": "pillow", + "sha256": "f6c3dd43c0a657212ef75fff6a85bef1de42373888b35669a573a5ad124a27d2", + "size": 557074, + "subdir": "linux-64", + "timestamp": 1530793030619, + "version": "5.1.0" + }, + "pillow-5.1.0-py35h3deb7b8_0.conda": { + "build": "py35h3deb7b8_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.5,<3.6.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "f1e5f6e7885372d83fe046e39700419c", + "name": "pillow", + "sha256": "69265febf4991fd10ccfe8b31dcc9062aeb38d618f292dcadc809c36980948f5", + "size": 558787, + "subdir": "linux-64", + "timestamp": 1523904291956, + "version": "5.1.0" + }, + "pillow-5.1.0-py36h3deb7b8_0.conda": { + "build": "py36h3deb7b8_0", + "build_number": 0, + "depends": [ + "freetype >=2.8,<2.9.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "e49e86510d7ae6b06ecd4c62643c2157", + "name": "pillow", + "sha256": "344b1802856356c3b3aaa8be591d4903573d76362d520133513a56aeffd140dd", + "size": 556654, + "subdir": "linux-64", + "timestamp": 1523904286416, + "version": "5.1.0" + }, + "pillow-5.1.0-py36heded4f4_0.conda": { + "build": "py36heded4f4_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "fb6c352083864a30f36faec8fd1dc81e", + "name": "pillow", + "sha256": "74e35f3d008f76bc387ee90dbfc0146be5355963affe267505ddcf6fc949bf84", + "size": 558597, + "subdir": "linux-64", + "timestamp": 1530793073367, + "version": "5.1.0" + }, + "pillow-5.1.0-py37heded4f4_0.conda": { + "build": "py37heded4f4_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "c5a1eb76af53a1fbbb825b40f99eca35", + "name": "pillow", + "sha256": "63c13dbe8d980b9435ccdc1454792213e8931fea44ea0b21d17d49c1312c5922", + "size": 552364, + "subdir": "linux-64", + "timestamp": 1530793115839, + "version": "5.1.0" + }, + "pillow-5.2.0-py27heded4f4_0.conda": { + "build": "py27heded4f4_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "2b33c2b7b3bdbf6108a5d94887515682", + "name": "pillow", + "sha256": "8966b83c39a1acf34b0f489d9233e05e2b48ac0b5ac7583541bc050d726639a8", + "size": 565264, + "subdir": "linux-64", + "timestamp": 1532639726822, + "version": "5.2.0" + }, + "pillow-5.2.0-py35heded4f4_0.conda": { + "build": "py35heded4f4_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.5,<3.6.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "6123cd6617be17ddfbcc43f02e637a80", + "name": "pillow", + "sha256": "dda81a086b267329f55188b7b22caed51ec3bb2b20ca98d7a7264449cf8dbaf9", + "size": 568358, + "subdir": "linux-64", + "timestamp": 1532639672983, + "version": "5.2.0" + }, + "pillow-5.2.0-py36heded4f4_0.conda": { + "build": "py36heded4f4_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "6064ea1ce3065c62b2ee41330daaa8d1", + "name": "pillow", + "sha256": "a54ef17ad525d451e53f21dfac5fc853f8a6887a41cf829d500eb171b340acd2", + "size": 560520, + "subdir": "linux-64", + "timestamp": 1532639727788, + "version": "5.2.0" + }, + "pillow-5.2.0-py37heded4f4_0.conda": { + "build": "py37heded4f4_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "886e299de8558015027750418880d3f1", + "name": "pillow", + "sha256": "e216aed321f2e522bcdb6475d3f2b2be9f000e37950caddbbaa686e4e89a5372", + "size": 562147, + "subdir": "linux-64", + "timestamp": 1532639677480, + "version": "5.2.0" + }, + "pillow-5.3.0-py27h34e0f95_0.conda": { + "build": "py27h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "3bcea14015dfa6dc0ab7cd200b79181b", + "name": "pillow", + "sha256": "7f7a511aa44b1bddc0639947d58143d46f2d07d1935ebbd48144ee457716e599", + "size": 575508, + "subdir": "linux-64", + "timestamp": 1538496183948, + "version": "5.3.0" + }, + "pillow-5.3.0-py36h34e0f95_0.conda": { + "build": "py36h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "f45b9666ba75e0b1cde8b7bb66fca60b", + "name": "pillow", + "sha256": "4fcee8088077bef6221ea7e90bcea4bb1c9b10a78a16ce65fb9adab5f1ad48b2", + "size": 570938, + "subdir": "linux-64", + "timestamp": 1538496219175, + "version": "5.3.0" + }, + "pillow-5.3.0-py37h34e0f95_0.conda": { + "build": "py37h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "a120416bfca426ec343a7da1353bef4c", + "name": "pillow", + "sha256": "c0928e69557fcf8e4edda085fe1e455c7c254147b819cd7b7026efff9e248962", + "size": 572125, + "subdir": "linux-64", + "timestamp": 1538496194003, + "version": "5.3.0" + }, + "pillow-5.4.1-py27h34e0f95_0.conda": { + "build": "py27h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "718c78b000c344fd4d9b96f7af049841", + "name": "pillow", + "sha256": "6e0802e6a581b5e31b6bf5a8d5c49a66251f1d28da95e815f6362658643da27c", + "size": 583440, + "subdir": "linux-64", + "timestamp": 1547244966387, + "version": "5.4.1" + }, + "pillow-5.4.1-py36h34e0f95_0.conda": { + "build": "py36h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "343aed4a3884e0c4eb99937452ade8f1", + "name": "pillow", + "sha256": "405d0b89b4c80ca2bc11b0b243525732250aa5b6720faf8e7b7a116aaa09afe2", + "size": 581174, + "subdir": "linux-64", + "timestamp": 1547244967043, + "version": "5.4.1" + }, + "pillow-5.4.1-py37h34e0f95_0.conda": { + "build": "py37h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.9,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "19ae3f9ff0f9ee94b23695422a3f0936", + "name": "pillow", + "sha256": "aa747b9a0b429fc1619480f148c692781cf02fec1e77d89a56191cfd22f7671c", + "size": 582232, + "subdir": "linux-64", + "timestamp": 1547244975725, + "version": "5.4.1" + }, + "pillow-6.0.0-py27h34e0f95_0.conda": { + "build": "py27h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "133759b51b4ff59f65ea19292b917c28", + "name": "pillow", + "sha256": "a32398415416f16559b20fad5f6fd9ede6d03090ba00b32926a2252d35109834", + "size": 591396, + "subdir": "linux-64", + "timestamp": 1555451330581, + "version": "6.0.0" + }, + "pillow-6.0.0-py36h34e0f95_0.conda": { + "build": "py36h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "cd97e67f0716ab19bfc4aa7a4b11fd3f", + "name": "pillow", + "sha256": "ea4bc618793254a2e1ddbca35088d0fa244ae42ca7075474d6243ec02bd0b5bd", + "size": 588365, + "subdir": "linux-64", + "timestamp": 1555451367343, + "version": "6.0.0" + }, + "pillow-6.0.0-py37h34e0f95_0.conda": { + "build": "py37h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "950a591a41b372c7f71eacfe94359cd4", + "name": "pillow", + "sha256": "9795e9f57b3f7299ac21ef35558d16d5ff9c87799f83d94b5840276dc269d254", + "size": 586433, + "subdir": "linux-64", + "timestamp": 1555451330116, + "version": "6.0.0" + }, + "pillow-6.1.0-py27h34e0f95_0.conda": { + "build": "py27h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "caf33632594378c417ca3865f5f7862d", + "name": "pillow", + "sha256": "d892411827f27e90e6995d6558780b650f5d991fc58b5e63523738ffbe94e38b", + "size": 601058, + "subdir": "linux-64", + "timestamp": 1563206526992, + "version": "6.1.0" + }, + "pillow-6.1.0-py36h34e0f95_0.conda": { + "build": "py36h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "132b3d3feda7e9151234ec2ad9bf2e25", + "name": "pillow", + "sha256": "a990527529ee99a6c5ef0e6b406c12154201fc201a5bc0b42989217de0850e03", + "size": 595841, + "subdir": "linux-64", + "timestamp": 1563206550131, + "version": "6.1.0" + }, + "pillow-6.1.0-py37h34e0f95_0.conda": { + "build": "py37h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "e313c9f2d0c5baa28318b41aa3bb76fb", + "name": "pillow", + "sha256": "6f864b6ad1799199d83bdc7cab7e1e734482f0c3d456054d39a55390ddc12666", + "size": 599742, + "subdir": "linux-64", + "timestamp": 1563206560457, + "version": "6.1.0" + }, + "pillow-6.2.0-py27h34e0f95_0.conda": { + "build": "py27h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "6bac61a2d2de17267fdded5f88660f55", + "name": "pillow", + "sha256": "d44bb595152ca6a1708f1588d54dda7f5b6a82d796a682bb44abe746c5b92afb", + "size": 604493, + "subdir": "linux-64", + "timestamp": 1570463231728, + "version": "6.2.0" + }, + "pillow-6.2.0-py36h34e0f95_0.conda": { + "build": "py36h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "8d65598cb12e3fc9abbcf1c2c385af36", + "name": "pillow", + "sha256": "120c09341cd3eaee73dc6826751e21c91c3a82eddd6efc535b2220d734388f14", + "size": 603030, + "subdir": "linux-64", + "timestamp": 1570463244088, + "version": "6.2.0" + }, + "pillow-6.2.0-py37h34e0f95_0.conda": { + "build": "py37h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "4ed6a949a0050d4e52f667217df79e1d", + "name": "pillow", + "sha256": "a09a2dce242aa72a10f08f418a2c20f3ccac534b836ecff008ad0dd0a4bfb600", + "size": 600988, + "subdir": "linux-64", + "timestamp": 1570463239077, + "version": "6.2.0" + }, + "pillow-6.2.1-py27h34e0f95_0.conda": { + "build": "py27h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=2.7,<2.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "4b2518b1284b91f9b797e7b4f3b380bc", + "name": "pillow", + "sha256": "0508d2a13aa7faf3efe29b376ca1486153c68bab2f300cd42d89bb280254421d", + "size": 601321, + "subdir": "linux-64", + "timestamp": 1573052428728, + "version": "6.2.1" + }, + "pillow-6.2.1-py36h34e0f95_0.conda": { + "build": "py36h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "e9cdd7a903ba435f1fe34d653a74e625", + "name": "pillow", + "sha256": "9a73b1e5691b1bc3d5a30e852e7524474079f2a1591e165f00607a50491d5645", + "size": 603373, + "subdir": "linux-64", + "timestamp": 1573052444776, + "version": "6.2.1" + }, + "pillow-6.2.1-py37h34e0f95_0.conda": { + "build": "py37h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "279e338098e6dd39c48fce5bfda5003b", + "name": "pillow", + "sha256": "f51773c36c95e6a7a023ed4bd301f99d83694e89e04c352d330143fd36772175", + "size": 601600, + "subdir": "linux-64", + "timestamp": 1573052442682, + "version": "6.2.1" + }, + "pillow-6.2.1-py38h34e0f95_0.conda": { + "build": "py38h34e0f95_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.0.10,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "3b97986ff26caa919c6405121402f7db", + "name": "pillow", + "sha256": "ab791b7dcb3b30bad5f23c7806c658457fb0a7d8f06635efac0eb8bd489e8e96", + "size": 602992, + "subdir": "linux-64", + "timestamp": 1573469573595, + "version": "6.2.1" + }, + "pillow-7.0.0-py36hb39fc2d_0.conda": { + "build": "py36hb39fc2d_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "d830feca2324254e2b84fcc3baa25a81", + "name": "pillow", + "sha256": "385c6f40ae88c41aeabff6f6bfd4f73dfc35afd4081d735f6fb94c635a780d40", + "size": 614184, + "subdir": "linux-64", + "timestamp": 1578413332351, + "version": "7.0.0" + }, + "pillow-7.0.0-py37hb39fc2d_0.conda": { + "build": "py37hb39fc2d_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "e1ba7b95b20b3dcec93800858cd0582a", + "name": "pillow", + "sha256": "7f5b5e356cbca3636c91cc9344bfc07b7be35d06cd3795dbe61fe55ee8ddc148", + "size": 611844, + "subdir": "linux-64", + "timestamp": 1578413343899, + "version": "7.0.0" + }, + "pillow-7.0.0-py38hb39fc2d_0.conda": { + "build": "py38hb39fc2d_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "f88e9ed03726200d9313c1e4b5ca5491", + "name": "pillow", + "sha256": "e8ed3772063ef7e6eb1abd05f4127560ede0b89c52b3d634f50cca0c122d2e84", + "size": 615837, + "subdir": "linux-64", + "timestamp": 1578413341200, + "version": "7.0.0" + }, + "pillow-7.1.2-py36hb39fc2d_0.conda": { + "build": "py36hb39fc2d_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "5689b39177b1142e8ae003f19774fc3b", + "name": "pillow", + "sha256": "79c9b2e8f478aaa0345f12a8b9024b62d079633f650969cea1031dd41e1a6608", + "size": 618321, + "subdir": "linux-64", + "timestamp": 1588471882757, + "version": "7.1.2" + }, + "pillow-7.1.2-py37hb39fc2d_0.conda": { + "build": "py37hb39fc2d_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "352bb812ef71328a45f7384ba02b486d", + "name": "pillow", + "sha256": "66cebd2da67f8f9677cb0518698d65bfa2914ee88fbd55230059829d95791134", + "size": 617311, + "subdir": "linux-64", + "timestamp": 1588471882131, + "version": "7.1.2" + }, + "pillow-7.1.2-py38hb39fc2d_0.conda": { + "build": "py38hb39fc2d_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PIL", + "md5": "684cef34ce36546e6f0edf3b430a0bf8", + "name": "pillow", + "sha256": "81b75b66897d0eaf4948f7d0f669cfeb6e11359087007d07effacbc89b4a0a89", + "size": 619264, + "subdir": "linux-64", + "timestamp": 1588471881910, + "version": "7.1.2" + }, + "pillow-7.2.0-py36hb39fc2d_0.conda": { + "build": "py36hb39fc2d_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk >=8.6.10,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "66fc4bd633e4684d1ef2c136eb6d0e93", + "name": "pillow", + "sha256": "2c836273926a09671ad47998bb25acf67396a7b327d05ee6149f333e975c06d8", + "size": 633833, + "subdir": "linux-64", + "timestamp": 1594307365389, + "version": "7.2.0" + }, + "pillow-7.2.0-py37hb39fc2d_0.conda": { + "build": "py37hb39fc2d_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk >=8.6.10,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "d3eade53ed3efa54015baf678a2bfee0", + "name": "pillow", + "sha256": "b0027a55c433d28ec72e10e2bd1782e6fabc729ec9de51800c4928e2dd2704a2", + "size": 631654, + "subdir": "linux-64", + "timestamp": 1594307398305, + "version": "7.2.0" + }, + "pillow-7.2.0-py38hb39fc2d_0.conda": { + "build": "py38hb39fc2d_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "jpeg >=9b,<10a", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk >=8.6.10,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "7b7c1df60df8eada9117bc48f12a61aa", + "name": "pillow", + "sha256": "e2ec3b737cab6dda2155c513de7ab5741f10326c22ef58c43c5b0b6558a14776", + "size": 631984, + "subdir": "linux-64", + "timestamp": 1594307358675, + "version": "7.2.0" + }, + "pillow-8.0.0-py36h9a89aac_0.conda": { + "build": "py36h9a89aac_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.3,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "23b0574a027e124c5caed12c63c1f616", + "name": "pillow", + "sha256": "90d936697322c4196d1af08ad1c220213ba0e2fdafc180123f05521c419c2c86", + "size": 635350, + "subdir": "linux-64", + "timestamp": 1602788773457, + "version": "8.0.0" + }, + "pillow-8.0.0-py37h9a89aac_0.conda": { + "build": "py37h9a89aac_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.3,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "3592273c66ed96f199dd6aa9fe5b05f0", + "name": "pillow", + "sha256": "3735bc77875774b954975e4f09eed383de4d0fd845831e7403e5f78fcb742fd7", + "size": 638566, + "subdir": "linux-64", + "timestamp": 1602788761871, + "version": "8.0.0" + }, + "pillow-8.0.0-py38h9a89aac_0.conda": { + "build": "py38h9a89aac_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.3,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "48bedf66c468a113137918c594cc385a", + "name": "pillow", + "sha256": "f159d55fb7d1039cf2822e7a27288947c44ddab8bfabe6597ac0a1f0abc6bf52", + "size": 635511, + "subdir": "linux-64", + "timestamp": 1602788778754, + "version": "8.0.0" + }, + "pillow-8.0.1-py36h9a89aac_0.conda": { + "build": "py36h9a89aac_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "31d21c6ef820be1fb0d78403cbfbcb37", + "name": "pillow", + "sha256": "4ec10e68a4785e8d03485f683ec21b37fe7391a0bb50eb2f3746707fe3854db5", + "size": 640438, + "subdir": "linux-64", + "timestamp": 1603478914834, + "version": "8.0.1" + }, + "pillow-8.0.1-py36he98fc37_0.conda": { + "build": "py36he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "aa325f3a76c4fdb33ccdb7703d6e6196", + "name": "pillow", + "sha256": "d86a494fe63c43ff71d0926a0705d1c49d2389fe238a73479c848cd3617743d6", + "size": 635474, + "subdir": "linux-64", + "timestamp": 1603822302635, + "version": "8.0.1" + }, + "pillow-8.0.1-py37h9a89aac_0.conda": { + "build": "py37h9a89aac_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "138daec34696798cff42fc61f9149bda", + "name": "pillow", + "sha256": "9003618e374a6acf0f0056bbecd101877bef6ba64cd558afa873528b0b8dc635", + "size": 637725, + "subdir": "linux-64", + "timestamp": 1603478874893, + "version": "8.0.1" + }, + "pillow-8.0.1-py37he98fc37_0.conda": { + "build": "py37he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "134e1d521c5e951efd169cdefa88eec1", + "name": "pillow", + "sha256": "4e340eda2ac814a5073457ab756159d40a2d386347509d04bb710ce1e2fa2b48", + "size": 633404, + "subdir": "linux-64", + "timestamp": 1603822320358, + "version": "8.0.1" + }, + "pillow-8.0.1-py38h9a89aac_0.conda": { + "build": "py38h9a89aac_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "39846eb722b1f162c102ef2c186d8259", + "name": "pillow", + "sha256": "4497417c1455519a8c2fc9e7e3945d1daf64fa1f9f5a2880412139775c82d3f8", + "size": 635428, + "subdir": "linux-64", + "timestamp": 1603395998038, + "version": "8.0.1" + }, + "pillow-8.0.1-py38he98fc37_0.conda": { + "build": "py38he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "e74d197bd82209d42cedf6d3fec24c1b", + "name": "pillow", + "sha256": "f8c921c2274bf4cc089f9e138cbdd1f6f19582b603dfdbad657c7d275459f064", + "size": 634549, + "subdir": "linux-64", + "timestamp": 1603822320887, + "version": "8.0.1" + }, + "pillow-8.0.1-py39he98fc37_0.conda": { + "build": "py39he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "51dfc5e9f4b2bc2b5f2f56442abb2725", + "name": "pillow", + "sha256": "bec147463738c706ea1baafd7c038bc26dbb3b26336b7db8597ef2bd83869b91", + "size": 660647, + "subdir": "linux-64", + "timestamp": 1607027453668, + "version": "8.0.1" + }, + "pillow-8.1.0-py36he98fc37_0.conda": { + "build": "py36he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "6b2f8e1ad79992122814928a41ef46b1", + "name": "pillow", + "sha256": "beca6ae850d66ac326a82c96299c849dc8162e3e0f19c1f05a2842f79a91ee15", + "size": 640886, + "subdir": "linux-64", + "timestamp": 1609786801229, + "version": "8.1.0" + }, + "pillow-8.1.0-py37he98fc37_0.conda": { + "build": "py37he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "4ab9241bbecc0da016dd10b90fef9d54", + "name": "pillow", + "sha256": "d9b6efc8b024d2967f1f0acdd65aaf66d1529c9af957daf68b272d60e9286a52", + "size": 637950, + "subdir": "linux-64", + "timestamp": 1609786803984, + "version": "8.1.0" + }, + "pillow-8.1.0-py38he98fc37_0.conda": { + "build": "py38he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "67b29dbf82014d6b23b7dc1b24f31478", + "name": "pillow", + "sha256": "bd60d17c0c05a1d14613d237fcfb2e82f6debd83909691af2ee236cbd9a65dc6", + "size": 641316, + "subdir": "linux-64", + "timestamp": 1609786851026, + "version": "8.1.0" + }, + "pillow-8.1.0-py39he98fc37_0.conda": { + "build": "py39he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "3189c335d3acd317401ea5c1ef7ccf2e", + "name": "pillow", + "sha256": "70d37c63648dcc51cd06a124e93c2020a02e2ddba2bdfbcd72aa2e8e1104c2c9", + "size": 646968, + "subdir": "linux-64", + "timestamp": 1609786718844, + "version": "8.1.0" + }, + "pillow-8.1.1-py36he98fc37_0.conda": { + "build": "py36he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "159159eb76a227baf3cfb67eca9bc8de", + "name": "pillow", + "sha256": "2f4500068ed5a7a3de2449af9cb4803e092b485425857cadbfb2a880ed995667", + "size": 640999, + "subdir": "linux-64", + "timestamp": 1614711496822, + "version": "8.1.1" + }, + "pillow-8.1.1-py37he98fc37_0.conda": { + "build": "py37he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "f1025880cdc6f816d2a719c491cb6ab0", + "name": "pillow", + "sha256": "da5006b88ff425ad6a823d0588dd2399d9b862f067184a34936fd1fcda658eaa", + "size": 633590, + "subdir": "linux-64", + "timestamp": 1614711502015, + "version": "8.1.1" + }, + "pillow-8.1.1-py38he98fc37_0.conda": { + "build": "py38he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "5372f37c6b4dcc3d814915386c459b15", + "name": "pillow", + "sha256": "b182318d00f5d84e0c91ff7c0efaa751e1f94e2039aff5c64ad9525475f5865f", + "size": 640570, + "subdir": "linux-64", + "timestamp": 1614711506646, + "version": "8.1.1" + }, + "pillow-8.1.1-py39he98fc37_0.conda": { + "build": "py39he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "5f0e4d8192f27aeeee15d3eaa1954744", + "name": "pillow", + "sha256": "64fdc342be50b564623f6ba13fa2e1be0094faee10c9acd5fd2f97c5da91bc51", + "size": 651590, + "subdir": "linux-64", + "timestamp": 1614711493006, + "version": "8.1.1" + }, + "pillow-8.1.2-py36he98fc37_0.conda": { + "build": "py36he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "f1e134658ef3df1ddf73ce8aaab1cb36", + "name": "pillow", + "sha256": "fee2e42b456c81a9e5df8cb292a8853db8f61019aa6f48efd13986094e11b120", + "size": 642203, + "subdir": "linux-64", + "timestamp": 1615224097587, + "version": "8.1.2" + }, + "pillow-8.1.2-py37he98fc37_0.conda": { + "build": "py37he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "1df87f6e43f3cf56eef77c1a92f74d53", + "name": "pillow", + "sha256": "515da1c8f20c22af176db45e6f2d9620c56db3e77a3bb54ef3010cb33fe45a77", + "size": 638664, + "subdir": "linux-64", + "timestamp": 1615057420609, + "version": "8.1.2" + }, + "pillow-8.1.2-py38he98fc37_0.conda": { + "build": "py38he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "f9e29b0201efee773a719e27ed4d013c", + "name": "pillow", + "sha256": "9680e8957f459e4729fffb0f958e5dafbb7e6c50f81e2d077fcc036d67397008", + "size": 636540, + "subdir": "linux-64", + "timestamp": 1615224161236, + "version": "8.1.2" + }, + "pillow-8.1.2-py39he98fc37_0.conda": { + "build": "py39he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "0894cd445870565ea7ab81d6d1130862", + "name": "pillow", + "sha256": "665b240f9884e99b01d451b1615e1e3510f523968b286712df497eda9a4fcfdb", + "size": 646827, + "subdir": "linux-64", + "timestamp": 1615224163037, + "version": "8.1.2" + }, + "pillow-8.2.0-py36he98fc37_0.conda": { + "build": "py36he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "b84a5d2b10b85bfdfb89c67a9c009e22", + "name": "pillow", + "sha256": "98f5ef9885c953377c0af1873d16f460739502126e4fc86e7c22ce09d8739157", + "size": 642352, + "subdir": "linux-64", + "timestamp": 1617386230630, + "version": "8.2.0" + }, + "pillow-8.2.0-py37he98fc37_0.conda": { + "build": "py37he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "1b751499942fd67bd70a541a475810fe", + "name": "pillow", + "sha256": "61ec67a3e9ea472a0a4e557751ec3d4d39c0fc7cb657e7dd4db8252f98c05e82", + "size": 636575, + "subdir": "linux-64", + "timestamp": 1617386228468, + "version": "8.2.0" + }, + "pillow-8.2.0-py38he98fc37_0.conda": { + "build": "py38he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "3704e6705fb98021d5a7559f25a2d52b", + "name": "pillow", + "sha256": "fdf2a0603b5dfbb83cfad8ed72cbb52eae822e5d5f6050f08ab5223d46baf373", + "size": 643557, + "subdir": "linux-64", + "timestamp": 1617383653613, + "version": "8.2.0" + }, + "pillow-8.2.0-py39he98fc37_0.conda": { + "build": "py39he98fc37_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.11,<3.0a0", + "libgcc-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "md5": "4c59d756229bc3331ee3957207cd361d", + "name": "pillow", + "sha256": "86ad95d6ba97e2345953e0fb7168db45aaf8d8dc813761cd553643c8a4c9faaf", + "size": 653500, + "subdir": "linux-64", + "timestamp": 1617385642760, + "version": "8.2.0" + }, + "pillow-8.3.1-py36h2c7a002_0.conda": { + "build": "py36h2c7a002_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.6,<3.7.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "84f4447920476061f0e5fd51aaaa8a09", + "name": "pillow", + "sha256": "4186c18db59e2a2506100c4d5d1457ea95f9976779528df5a0c8c0f4a7c41aab", + "size": 652246, + "subdir": "linux-64", + "timestamp": 1625649151492, + "version": "8.3.1" + }, + "pillow-8.3.1-py36h5aabda8_0.conda": { + "build": "py36h5aabda8_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "olefile", + "python >=3.6,<3.7.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "5fc397955b178d784f4f5dbca3a738dd", + "name": "pillow", + "sha256": "c4da4f39529faaa796b296d2abc4ffcd69fc1c20b0c86ecb1a8a634495735e79", + "size": 653806, + "subdir": "linux-64", + "timestamp": 1625670720843, + "version": "8.3.1" + }, + "pillow-8.3.1-py37h2c7a002_0.conda": { + "build": "py37h2c7a002_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "5e64a771d960eeb6d47d2a7e421225a4", + "name": "pillow", + "sha256": "f0a92c6a77408b176e56c17e92e0ae1e5e6bf21074a6d3ddd07abe28f04f1606", + "size": 650553, + "subdir": "linux-64", + "timestamp": 1625655892328, + "version": "8.3.1" + }, + "pillow-8.3.1-py37h5aabda8_0.conda": { + "build": "py37h5aabda8_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "4cc87c6fb7d54662fec99609b4b16d06", + "name": "pillow", + "sha256": "51fd917c4273ddaecd4187333184fe0b9b6e338bdef704963838177f11a98dcd", + "size": 647973, + "subdir": "linux-64", + "timestamp": 1625670702141, + "version": "8.3.1" + }, + "pillow-8.3.1-py38h2c7a002_0.conda": { + "build": "py38h2c7a002_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "93d838807af07bbc798ed6729c9da925", + "name": "pillow", + "sha256": "20ffaca11b4db1796de7c931038fcfd9359f85de99cf918ecc15e652bcb5de09", + "size": 653294, + "subdir": "linux-64", + "timestamp": 1625655892412, + "version": "8.3.1" + }, + "pillow-8.3.1-py38h5aabda8_0.conda": { + "build": "py38h5aabda8_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "3a1934ad7a7610aba5559a030df9bd8d", + "name": "pillow", + "sha256": "365eeb042a4b82b817bf32a70dc89b95795f1e74d0210a62cd45af335c328c34", + "size": 649590, + "subdir": "linux-64", + "timestamp": 1625670696790, + "version": "8.3.1" + }, + "pillow-8.3.1-py39h2c7a002_0.conda": { + "build": "py39h2c7a002_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "olefile", + "openjpeg >=2.3.0,<3.0a0", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "6e6788b6c554b5ee0b1f20bbf4eeb923", + "name": "pillow", + "sha256": "c9889edca870bbeedd34d9937fe8930a06e22b467e55d40e80900ecb69c66e48", + "size": 663764, + "subdir": "linux-64", + "timestamp": 1625655490878, + "version": "8.3.1" + }, + "pillow-8.3.1-py39h5aabda8_0.conda": { + "build": "py39h5aabda8_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "olefile", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "c2fcee61b7a46a1fb8379f122e61e811", + "name": "pillow", + "sha256": "a9f5877ddcb1523a2b37c64981d276e5390081fa1d4840874328574f626dee2c", + "size": 659687, + "subdir": "linux-64", + "timestamp": 1625670421468, + "version": "8.3.1" + }, + "pillow-8.4.0-py310h63577eb_0.conda": { + "build": "py310h63577eb_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=8.4.0", + "libstdcxx-ng >=8.4.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "olefile", + "python >=3.10,<3.11.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "b1ee0b08d1b19269b88eb868802d1b2a", + "name": "pillow", + "sha256": "7dc84b142fdf45dcb1c8f685fc34ffeee6194575372957b53a72509ebf4ec7c2", + "size": 1239559, + "subdir": "linux-64", + "timestamp": 1643111226093, + "version": "8.4.0" + }, + "pillow-8.4.0-py37h5aabda8_0.conda": { + "build": "py37h5aabda8_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "olefile", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "757ed8bddc4a39decd97dd9374fa4f5f", + "name": "pillow", + "sha256": "d5807b2c42e8b4253190ffd78381c177e6166826b7cf9aac31b4d8944f8bcd52", + "size": 659289, + "subdir": "linux-64", + "timestamp": 1634549384212, + "version": "8.4.0" + }, + "pillow-8.4.0-py38h5aabda8_0.conda": { + "build": "py38h5aabda8_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "olefile", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "0092862a1a3ddf9f364698796d789aa1", + "name": "pillow", + "sha256": "00ea2896d628da173aeaa4260bc56788132222012704e309470193198ad26e9d", + "size": 660677, + "subdir": "linux-64", + "timestamp": 1634538125138, + "version": "8.4.0" + }, + "pillow-8.4.0-py39h5aabda8_0.conda": { + "build": "py39h5aabda8_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "olefile", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "fe12ba8f50f4c9fb7f97c29e24f7de04", + "name": "pillow", + "sha256": "adf27f02dd2f920f3007a3ca6658e1f17c578163508ffc6c3d4e478fa8a5efb0", + "size": 668114, + "subdir": "linux-64", + "timestamp": 1634549388954, + "version": "8.4.0" + }, + "pillow-9.0.1-py310h22f2fdc_0.conda": { + "build": "py310h22f2fdc_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.10,<3.11.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "bb592fe35035d609c091c8782f852224", + "name": "pillow", + "sha256": "9f6b3762141f69c49aed1e2ab2e4782ae1a872b59e9f6c381959ede13c0ceb55", + "size": 1139325, + "subdir": "linux-64", + "timestamp": 1646325112795, + "version": "9.0.1" + }, + "pillow-9.0.1-py37h22f2fdc_0.conda": { + "build": "py37h22f2fdc_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "cdd41b824621d235f25d7f02a4060dd1", + "name": "pillow", + "sha256": "aadaf030127e7632a131c0ecc28b2c76c75a7fcccb1eb7ff7be21cf04e9dd834", + "size": 668033, + "subdir": "linux-64", + "timestamp": 1646325091733, + "version": "9.0.1" + }, + "pillow-9.0.1-py38h22f2fdc_0.conda": { + "build": "py38h22f2fdc_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "13c7b8b727dc6af99e9f6d75b3ec18f3", + "name": "pillow", + "sha256": "2bf283b58146c8c59d93351ae83ca78c770ee135b983f9a405aae3d03cee2985", + "size": 674741, + "subdir": "linux-64", + "timestamp": 1646306967387, + "version": "9.0.1" + }, + "pillow-9.0.1-py39h22f2fdc_0.conda": { + "build": "py39h22f2fdc_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "af9738244e2dca1bf5d04a81a34f28d5", + "name": "pillow", + "sha256": "ea1c3b72759bad5942a00290d52bae62f4630f004be604b5a5dfd958b28c3bb5", + "size": 685262, + "subdir": "linux-64", + "timestamp": 1646325095608, + "version": "9.0.1" + }, + "pillow-9.2.0-py310hace64e9_0.conda": { + "build": "py310hace64e9_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.10,<3.11.0a0", + "tk", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "7bcc19b0980a1fc820d528715b5a8db6", + "name": "pillow", + "sha256": "73fb8cf420b737850049052ba5d648472ddce6f5b1027e5636c2818c41e2c987", + "size": 1235935, + "subdir": "linux-64", + "timestamp": 1657724329870, + "version": "9.2.0" + }, + "pillow-9.2.0-py310hace64e9_1.conda": { + "build": "py310hace64e9_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.10,<3.11.0a0", + "tk", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "9151d24a3e7d7890fedefd517d201d72", + "name": "pillow", + "sha256": "c71cfb6a0ea9b61e4fe584d6885bb09d0e81939a8221308e306055fe9021b8ba", + "size": 1240228, + "subdir": "linux-64", + "timestamp": 1657829171881, + "version": "9.2.0" + }, + "pillow-9.2.0-py37hace64e9_0.conda": { + "build": "py37hace64e9_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "b1f3f4cc5eb324786de6dbc57ef416ec", + "name": "pillow", + "sha256": "9908fb913104cf9918c0d83ad7f53e552cbbbc511af93570451d6486cd892af6", + "size": 674890, + "subdir": "linux-64", + "timestamp": 1657724434199, + "version": "9.2.0" + }, + "pillow-9.2.0-py37hace64e9_1.conda": { + "build": "py37hace64e9_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "9c2c3e7eb562d10c5f8f8806648bcf2d", + "name": "pillow", + "sha256": "3db16271f4df62b69fb7a65b2461234e0dcb76ec61c4f7442cd0f3d09ce79786", + "size": 679989, + "subdir": "linux-64", + "timestamp": 1657829271742, + "version": "9.2.0" + }, + "pillow-9.2.0-py38hace64e9_0.conda": { + "build": "py38hace64e9_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "3aae7160d010856c0791ee1dde2e5ece", + "name": "pillow", + "sha256": "a38978b0b10990eba9f5e86fb33ae57ab11dc268669a380bba1dc2de1f9e41e2", + "size": 676893, + "subdir": "linux-64", + "timestamp": 1657724485955, + "version": "9.2.0" + }, + "pillow-9.2.0-py38hace64e9_1.conda": { + "build": "py38hace64e9_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "a6b7baf62d6399704dfdeab8c0ec55f6", + "name": "pillow", + "sha256": "18c46fece147bc3b2bb93331b25b3dd9f84a9e6a61edaad0f7e2385435fface7", + "size": 681853, + "subdir": "linux-64", + "timestamp": 1657828928919, + "version": "9.2.0" + }, + "pillow-9.2.0-py39hace64e9_0.conda": { + "build": "py39hace64e9_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "74149ea36989dc01a91a30e6b9e9610a", + "name": "pillow", + "sha256": "ef736dfc53b8f2774e82e21da4a77f996bf28e0cc62995ed4350628c7687b680", + "size": 681438, + "subdir": "linux-64", + "timestamp": 1657724381965, + "version": "9.2.0" + }, + "pillow-9.2.0-py39hace64e9_1.conda": { + "build": "py39hace64e9_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "c6a8cd5e780e5ad1a7dbd5ea54195f7b", + "name": "pillow", + "sha256": "2abf87e6352160b9f6b8f43c8ef5050370060f3483eefc99e444d770280037d1", + "size": 686104, + "subdir": "linux-64", + "timestamp": 1657829034677, + "version": "9.2.0" + }, + "pillow-9.3.0-py310h6a678d5_2.conda": { + "build": "py310h6a678d5_2", + "build_number": 2, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.10,<3.11.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "cb4281cf781163ec3d6221efeff99eff", + "name": "pillow", + "sha256": "57b711785b20435aa3bdbb8169dd6e79fdc2353161a78e97e64f5d2850f79cee", + "size": 753391, + "subdir": "linux-64", + "timestamp": 1675358421882, + "version": "9.3.0" + }, + "pillow-9.3.0-py310hace64e9_0.conda": { + "build": "py310hace64e9_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.10,<3.11.0a0", + "tk", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "7c8c68cfedd5645acca774c8cf868fea", + "name": "pillow", + "sha256": "893d0c7a552e6db0c7092331ad4b4cd953649bc4e54d7317039b45775c4e801a", + "size": 745553, + "subdir": "linux-64", + "timestamp": 1671482912279, + "version": "9.3.0" + }, + "pillow-9.3.0-py310hace64e9_1.conda": { + "build": "py310hace64e9_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.10,<3.11.0a0", + "tk", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "57a262f1a1bd832cb2baea9b6fce252f", + "name": "pillow", + "sha256": "a2ae21dcef6df844634be1361be22e6b642c79a86b3cd5a0f728c11fbe5d529a", + "size": 745999, + "subdir": "linux-64", + "timestamp": 1671656565302, + "version": "9.3.0" + }, + "pillow-9.3.0-py311h6a678d5_2.conda": { + "build": "py311h6a678d5_2", + "build_number": 2, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.11,<3.12.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "7d412d6a0282fa19de0b0b07715f076e", + "name": "pillow", + "sha256": "7f0d54f49d5e4456d99e6b606c048348c3e756310f1aa0ed0445b80dec33502c", + "size": 838144, + "subdir": "linux-64", + "timestamp": 1676827382376, + "version": "9.3.0" + }, + "pillow-9.3.0-py37h6a678d5_2.conda": { + "build": "py37h6a678d5_2", + "build_number": 2, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.7,<3.8.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "2c9a7b024312f7d2e7080d53c8a4a07d", + "name": "pillow", + "sha256": "481e47dc34c66db4a162746be8430ae1df2716068defceee93a7e2968e0ffc15", + "size": 744007, + "subdir": "linux-64", + "timestamp": 1675358280680, + "version": "9.3.0" + }, + "pillow-9.3.0-py37hace64e9_0.conda": { + "build": "py37hace64e9_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "52b610cb164d9fa7b21e823e82ecd939", + "name": "pillow", + "sha256": "7af3b312a70f2976c0af7b2493a9c4c2a4b85672eb542fbf0d10445b46d864cf", + "size": 736332, + "subdir": "linux-64", + "timestamp": 1671482820612, + "version": "9.3.0" + }, + "pillow-9.3.0-py37hace64e9_1.conda": { + "build": "py37hace64e9_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.7,<3.8.0a0", + "tk", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "cf536a776b91faffe80ab8940023b939", + "name": "pillow", + "sha256": "b57288e7dc6d576c17a5df6375af3d07e52a2f3b33babed8ac7d977ac4ac3adc", + "size": 736565, + "subdir": "linux-64", + "timestamp": 1671656528687, + "version": "9.3.0" + }, + "pillow-9.3.0-py38h6a678d5_2.conda": { + "build": "py38h6a678d5_2", + "build_number": 2, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.8,<3.9.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "1fff4ed2c4020e74edf3930a05a0659d", + "name": "pillow", + "sha256": "adefb689144a22dd361276d0d6678a59307341843a9316aec7866fa50cc69a80", + "size": 745325, + "subdir": "linux-64", + "timestamp": 1675358375012, + "version": "9.3.0" + }, + "pillow-9.3.0-py38hace64e9_0.conda": { + "build": "py38hace64e9_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "c530a038ada7065ce2d38b391118181b", + "name": "pillow", + "sha256": "9dd2645cd6ba1cddcc1e2959d32d0af64c51bab57d61888d4b455be4b94a0dc7", + "size": 737943, + "subdir": "linux-64", + "timestamp": 1671482774617, + "version": "9.3.0" + }, + "pillow-9.3.0-py38hace64e9_1.conda": { + "build": "py38hace64e9_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.8,<3.9.0a0", + "tk", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "25eba78d0ac0b82f750c09f89d033097", + "name": "pillow", + "sha256": "090311970fe3df40cc31cc6f9a02026b105c77807b030d8e33bddad34ce45175", + "size": 738181, + "subdir": "linux-64", + "timestamp": 1671656454338, + "version": "9.3.0" + }, + "pillow-9.3.0-py39h6a678d5_2.conda": { + "build": "py39h6a678d5_2", + "build_number": 2, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.9,<3.10.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "5b66790c395350b3bbff759878d0af1f", + "name": "pillow", + "sha256": "4ee7c871e137a3482fc5c2d019fc89e2d36ea92491626b5e728c8dd3dd20a81b", + "size": 749097, + "subdir": "linux-64", + "timestamp": 1675358328194, + "version": "9.3.0" + }, + "pillow-9.3.0-py39hace64e9_0.conda": { + "build": "py39hace64e9_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "79a57cd0343ae25b65b50bacccabe0f0", + "name": "pillow", + "sha256": "06d0aeeb45d3ee387fc9d0df7b27fd78d5436ae2787079ca558c73e05e81e967", + "size": 741521, + "subdir": "linux-64", + "timestamp": 1671482866313, + "version": "9.3.0" + }, + "pillow-9.3.0-py39hace64e9_1.conda": { + "build": "py39hace64e9_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "libwebp >=0.3.0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.9,<3.10.0a0", + "tk", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "967228d5e402441bbdadc7762b80ac54", + "name": "pillow", + "sha256": "e8e918f18aee041d3e971cf2c9e0a9a9996796e4206f5c6371717b3d1ca66b73", + "size": 742497, + "subdir": "linux-64", + "timestamp": 1671656491261, + "version": "9.3.0" + }, + "pillow-9.4.0-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.10,<3.11.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "8b3af83284248cad7e4632d2d2e66ba7", + "name": "pillow", + "sha256": "3f74cb9e4ce8725d9f5a97d5629065d2af83d2ee74f6ef9daf6abe9472721fbd", + "size": 748021, + "subdir": "linux-64", + "timestamp": 1677510429171, + "version": "9.4.0" + }, + "pillow-9.4.0-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.11,<3.12.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "62750be6fc2f0d1d2587f7894a7ba663", + "name": "pillow", + "sha256": "11925b79457c4d8cc192619e90042ee5e08bf5c3b11ca452c9c8d47b08dc875a", + "size": 834577, + "subdir": "linux-64", + "timestamp": 1679337355357, + "version": "9.4.0" + }, + "pillow-9.4.0-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.7,<3.8.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "ff8d322cc4dc1a5d6e60632598ee86ef", + "name": "pillow", + "sha256": "88c337364d7c1e3cca0c510c4a4f44c6bf78c1705590c59f66cb471c765863c0", + "size": 738781, + "subdir": "linux-64", + "timestamp": 1677510384427, + "version": "9.4.0" + }, + "pillow-9.4.0-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.8,<3.9.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "8afd1f4f8b23a1c44fca4975253b17f7", + "name": "pillow", + "sha256": "2e6dbd8bb4c86d3487fd34effe00e3df202cdcf2b77ca3e89aafffc0f7794edf", + "size": 740537, + "subdir": "linux-64", + "timestamp": 1677510473765, + "version": "9.4.0" + }, + "pillow-9.4.0-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.2.0,<5.0a0", + "libwebp >=1.2.0,<1.3.0a0", + "python >=3.9,<3.10.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "LicenseRef-PIL", + "license_family": "Other", + "md5": "1cc922d372daf875357916d7fd48ae03", + "name": "pillow", + "sha256": "c3f82679a5adb18f7530613d5aae91b97d5194bebe87dd0f5c4bbababcef723e", + "size": 744740, + "subdir": "linux-64", + "timestamp": 1677510338846, + "version": "9.4.0" + }, + "pip-10.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64b4b92c4ac21b7d26fed2039ee1f92c", + "name": "pip", + "sha256": "7835dc977760ad967955ee6f09080bab229922e7d31aa2621cb2ee721d587174", + "size": 1657216, + "subdir": "linux-64", + "timestamp": 1524226843245, + "version": "10.0.1" + }, + "pip-10.0.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1737fb8c4a622af4db5d528d95f11e05", + "name": "pip", + "sha256": "4c9b6b05afc01bf50706d5947f38153d5c8a74e0c1a8df83f09be4436346b8bd", + "size": 1646302, + "subdir": "linux-64", + "timestamp": 1524226856853, + "version": "10.0.1" + }, + "pip-10.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7cf3d5e0c4888c8308160918ae32af10", + "name": "pip", + "sha256": "1d2e7bda191071a83e998c41c10eb26f8c03538e9d06a5d054e6e962a9b6b2fe", + "size": 1656960, + "subdir": "linux-64", + "timestamp": 1524226858887, + "version": "10.0.1" + }, + "pip-10.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c41df006ebcf8d341697bc1f3dcfd5c3", + "name": "pip", + "sha256": "8822b1d964c5772de990836e093844b082fbbc69ab9b21f8bfbd3fa2404dba53", + "size": 1627238, + "subdir": "linux-64", + "timestamp": 1530212750848, + "version": "10.0.1" + }, + "pip-18.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e406f108812f7825ea1909352a34ec80", + "name": "pip", + "sha256": "defa71a3241fd824cabd383bded02795c584a681e45b1f7695f00e29af6a04e0", + "size": 1631600, + "subdir": "linux-64", + "timestamp": 1541177326945, + "version": "18.1" + }, + "pip-18.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a4415552ff8fa8d810b530584efab975", + "name": "pip", + "sha256": "920711314fb992e7a96f39fdc4ef5d2a601ee19a802cfda82c6725d09a80991d", + "size": 1647403, + "subdir": "linux-64", + "timestamp": 1541177346323, + "version": "18.1" + }, + "pip-18.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3234dcc6ac756fb1b727c6bbf0682a9e", + "name": "pip", + "sha256": "d4944412bf58edb30ca25d81947250f8f783142751df4a0de1002f1adee53262", + "size": 1614069, + "subdir": "linux-64", + "timestamp": 1541177320708, + "version": "18.1" + }, + "pip-19.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7a4d09e9531bd0eee9f88c7e0a7e00e5", + "name": "pip", + "sha256": "5ef4987760ec0cecf6eec5e211246163d0b3606fc38a6f172335ec5e8de89c5f", + "size": 1665289, + "subdir": "linux-64", + "timestamp": 1549297898985, + "version": "19.0.1" + }, + "pip-19.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2ba4fc37caa3b986bb9c8f6dc9af67d", + "name": "pip", + "sha256": "796293a3ff540a49bc1c4801d0ddc239e4fd430e20c8900be4a4a9e43494f143", + "size": 1664994, + "subdir": "linux-64", + "timestamp": 1549297926302, + "version": "19.0.1" + }, + "pip-19.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45d8785a7ba761758ea7125c6f6f9a05", + "name": "pip", + "sha256": "8df539263df199af4a900c8071440623f9e7a599ed7cf7728aeffa9dac129b7a", + "size": 1633587, + "subdir": "linux-64", + "timestamp": 1549297862788, + "version": "19.0.1" + }, + "pip-19.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd87a34b5e50878fb319bec2b4e852d5", + "name": "pip", + "sha256": "26d41a22baa50b710568ce018c9650d77305056320413a28248c1a29219ac323", + "size": 1671718, + "subdir": "linux-64", + "timestamp": 1551143702790, + "version": "19.0.3" + }, + "pip-19.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4eabaad61522ece40c6d1dd8254ee063", + "name": "pip", + "sha256": "e8383573eb365b9c95e12dcbbefb18c95e5fd2a09ab61dff786e31e530d2ef96", + "size": 1686079, + "subdir": "linux-64", + "timestamp": 1551143731304, + "version": "19.0.3" + }, + "pip-19.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b109da0c8ac49014c780b44c92a8ff8", + "name": "pip", + "sha256": "8013f67b8e96c9d894affbe7cd8049227c12310e0550cdb6ec379668edf52a2e", + "size": 1640063, + "subdir": "linux-64", + "timestamp": 1551143673935, + "version": "19.0.3" + }, + "pip-19.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af38623d60ce96ab293c3dde254398c8", + "name": "pip", + "sha256": "796a870d4853f912dce4f9e2918de52996244c07c7722960a87839c03af2a26f", + "size": 1699626, + "subdir": "linux-64", + "timestamp": 1556290044671, + "version": "19.1" + }, + "pip-19.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f953dabf6e686c447028fd0521f41fa5", + "name": "pip", + "sha256": "739deb5ae047445936de6509ee1749e8a939d4cc9dd9cce6f109314b5149d1ed", + "size": 1698406, + "subdir": "linux-64", + "timestamp": 1556290127488, + "version": "19.1" + }, + "pip-19.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "414fc1620f9b135c0afaabe1610107ba", + "name": "pip", + "sha256": "af6a730bc5ed28e4d740b9338ce1e797349ee0d950e1f254b50a4c11b3f09654", + "size": 1666727, + "subdir": "linux-64", + "timestamp": 1556289956939, + "version": "19.1" + }, + "pip-19.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2996658bcbc9b88c604205912b0b9599", + "name": "pip", + "sha256": "96ad94a0c99d37b614048610e50ae28d05e6c1de2f60ceec10dc53e176882f30", + "size": 1682260, + "subdir": "linux-64", + "timestamp": 1557501831795, + "version": "19.1.1" + }, + "pip-19.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "97edbec1d41987174f5fc2247d5ab0ed", + "name": "pip", + "sha256": "ccabe4e9db448ed2fabec30a63593a1854495269d0550c5caa7a049bd9c7952a", + "size": 1696323, + "subdir": "linux-64", + "timestamp": 1557501846964, + "version": "19.1.1" + }, + "pip-19.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4aa26ede23abe0ada3cc3769bb07e81c", + "name": "pip", + "sha256": "41f2ff279f08230be7dde7852d20dd110806baf2e0039bea7cb5360d249286a5", + "size": 1650040, + "subdir": "linux-64", + "timestamp": 1557501803017, + "version": "19.1.1" + }, + "pip-19.2.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6668bc9ae062add62d7f92a7a613e3d5", + "name": "pip", + "sha256": "987d4e041edd553bb08e765ad72b852e5986d78835a99c1f557670fafd7ec411", + "size": 1754851, + "subdir": "linux-64", + "timestamp": 1565895085184, + "version": "19.2.2" + }, + "pip-19.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "267ec3e9c5ce3e910c7b369d4d6c1f77", + "name": "pip", + "sha256": "097c411256106b6c623008b7f7a68873d43f9de2cc759da180e814048c1bc945", + "size": 1738311, + "subdir": "linux-64", + "timestamp": 1565895140527, + "version": "19.2.2" + }, + "pip-19.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8700b27d75254b6e2e2b05ec016edb5", + "name": "pip", + "sha256": "26ab264e96fd66d7e209ac3a748a409b602a8e7914631e8104432cb66911d856", + "size": 1723277, + "subdir": "linux-64", + "timestamp": 1565895028559, + "version": "19.2.2" + }, + "pip-19.2.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d85c47d590b5de6b591ac76dc0f8f1b", + "name": "pip", + "sha256": "f3de3cf60fb6660b5c8f137a18420bebf2879f360fbd09d82a8fe484c9221af7", + "size": 1757178, + "subdir": "linux-64", + "timestamp": 1569332241670, + "version": "19.2.3" + }, + "pip-19.2.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0fa3f4f0ced14f6678b316c37ee4f682", + "name": "pip", + "sha256": "862761cee730a80e3d879ace91ac65d3e407e83b52d6a71472318b3c7f72e24c", + "size": 1757298, + "subdir": "linux-64", + "timestamp": 1569332269804, + "version": "19.2.3" + }, + "pip-19.2.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c52d51bd66077ae929f00648a75ef619", + "name": "pip", + "sha256": "435a037cc954a8df405fdcdf64259d2044eed1ba572620489618abdb228dec28", + "size": 1722596, + "subdir": "linux-64", + "timestamp": 1569332239100, + "version": "19.2.3" + }, + "pip-19.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02426633c580f212db0ae9a556818b30", + "name": "pip", + "sha256": "da251c0f57f9b27dc658b2938d1780a575bce960350e35ef39bed8685ecbbdd4", + "size": 1755709, + "subdir": "linux-64", + "timestamp": 1571668699362, + "version": "19.3.1" + }, + "pip-19.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc6a824a518587e09f01bc957ca9ef61", + "name": "pip", + "sha256": "e7878c1f4fedab69c80d4a5ef8d9ac0697c7a1bfd3b5091a0e3e367ab7cd8450", + "size": 1755344, + "subdir": "linux-64", + "timestamp": 1571668731567, + "version": "19.3.1" + }, + "pip-19.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3de5bb7cf93a8ee31d7526dc8985694", + "name": "pip", + "sha256": "e8fda6c49b720f73eff260f7a9d2e89b69b8e19dcd5047f6cecd86916a6b3d10", + "size": 1723529, + "subdir": "linux-64", + "timestamp": 1571668699607, + "version": "19.3.1" + }, + "pip-19.3.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "84a15c4ad23a6df13ecb3b02c0d73bbe", + "name": "pip", + "sha256": "308d92756dfcd83fe0d1d38f34f9ef6b58bb700e24ef2217477ffbeed3e26819", + "size": 1732722, + "subdir": "linux-64", + "timestamp": 1571958776067, + "version": "19.3.1" + }, + "pip-20.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "46ca184e73b78eb0851ae52ab0392059", + "name": "pip", + "sha256": "e60602de6d65098aaffa386f6b7577172a70b4f00a93582aaa5021e488f91087", + "size": 1765673, + "subdir": "linux-64", + "timestamp": 1580148298627, + "version": "20.0.2" + }, + "pip-20.0.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "84b2773c27aff24f1c013a82be67bab5", + "name": "pip", + "sha256": "9570ea5cf243a3b237eee7d0ce6bbfee3c1e4b82ae68a3b1afa8a68136de6cbf", + "size": 1765846, + "subdir": "linux-64", + "timestamp": 1580397114520, + "version": "20.0.2" + }, + "pip-20.0.2-py36_3.conda": { + "build": "py36_3", + "build_number": 3, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b82824c537709e399a0f980009248889", + "name": "pip", + "sha256": "df08b1260b47659c43270faf83ab704cf6a5aea334c153eb24207598d1d4f7cb", + "size": 1780459, + "subdir": "linux-64", + "timestamp": 1588890272451, + "version": "20.0.2" + }, + "pip-20.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "588ca86189d84e8ca3ad9db24d74c0b0", + "name": "pip", + "sha256": "16ade7cba2a57f5d25805876d7b6883debd7ab669608cf7e2d6f6840a87a0270", + "size": 1747811, + "subdir": "linux-64", + "timestamp": 1580148260135, + "version": "20.0.2" + }, + "pip-20.0.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dfe1549c5a65671d436dc45bc89debe8", + "name": "pip", + "sha256": "b15bb8e3bf874a9cdba2b47d2e07e79efa8f9138d4fe4ad5ce84599b1fc9280d", + "size": 1734633, + "subdir": "linux-64", + "timestamp": 1580397126321, + "version": "20.0.2" + }, + "pip-20.0.2-py37_3.conda": { + "build": "py37_3", + "build_number": 3, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "416e72e9172e1c857525bc195db4eb0f", + "name": "pip", + "sha256": "0e681ec1eafa38eeb96211d35786a6239ba57553a66ee564dcb16c7a5c6ee32f", + "size": 1749059, + "subdir": "linux-64", + "timestamp": 1588890230766, + "version": "20.0.2" + }, + "pip-20.0.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "65aa431e418241542d83126a541782cd", + "name": "pip", + "sha256": "3f8003f7c0045f569415d9b9cf37f5f7787e433af83cdbd38b813978f85db433", + "size": 1740790, + "subdir": "linux-64", + "timestamp": 1580148306521, + "version": "20.0.2" + }, + "pip-20.0.2-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e4f4c5a3892a9721bbacb36a39bede3", + "name": "pip", + "sha256": "25cf101c7db30c9e62dc13b960a33dd7d470d34429d168ef3d170ca763ba2953", + "size": 1741898, + "subdir": "linux-64", + "timestamp": 1580397180562, + "version": "20.0.2" + }, + "pip-20.0.2-py38_3.conda": { + "build": "py38_3", + "build_number": 3, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b0e400abe7f57e4f8ad15e98437e1b7", + "name": "pip", + "sha256": "50a737c9f902487805fc3f45e82608eaf4ecbc6b263c2d1dcc1c114978187770", + "size": 1742732, + "subdir": "linux-64", + "timestamp": 1588890253231, + "version": "20.0.2" + }, + "pip-20.1.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "017ddb6aa0da696d4d9030f07da02180", + "name": "pip", + "sha256": "7b74eed1318ca2dce163080bce2c4fd0247600c4d4b49046605d41288bece323", + "size": 1839724, + "subdir": "linux-64", + "timestamp": 1592322693602, + "version": "20.1.1" + }, + "pip-20.1.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ace68442d50179ea98cc885cbbe9ef7e", + "name": "pip", + "sha256": "1b306acc004c1e09ebfc16adcfff07172cdfd47cbef331f54b18d8d8dde71fa2", + "size": 1794880, + "subdir": "linux-64", + "timestamp": 1592322688722, + "version": "20.1.1" + }, + "pip-20.1.1-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c0afbd7792c1e35539d9a8dfe9a0b11", + "name": "pip", + "sha256": "e5d7d53cebedaa7154e3120e62da4aed1d71fad7f7c3791199c77be4b45806fb", + "size": 1817281, + "subdir": "linux-64", + "timestamp": 1592322703559, + "version": "20.1.1" + }, + "pip-20.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0fb0011c331f8b9fc6aa0bfbb1062d91", + "name": "pip", + "sha256": "46157f5bba49627702e0caf8e4aa27975ff1e34e732153fa0c4a73d707ec1c35", + "size": 1866060, + "subdir": "linux-64", + "timestamp": 1596834015769, + "version": "20.2.1" + }, + "pip-20.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff6e22fbe079e127ea1362ce12fa5790", + "name": "pip", + "sha256": "84aa730fb609208baa6f3396dbfdaeafb6c624d0da3aa98e155ccaf39ef4bbb6", + "size": 1814449, + "subdir": "linux-64", + "timestamp": 1596834010148, + "version": "20.2.1" + }, + "pip-20.2.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d3440fb34ec72b8dfb9264c1d59cf1a2", + "name": "pip", + "sha256": "4b79bcaa33c00c218f7ecc94c8cc49751594e4679122d187d2e3482c4a623a35", + "size": 1842798, + "subdir": "linux-64", + "timestamp": 1596834007825, + "version": "20.2.1" + }, + "pip-20.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c02d2e3afe1ba15ac8310682af33906f", + "name": "pip", + "sha256": "205a7c893502b160b2502b7a1b2da522b13bd85f6c50cc939875f52ebea7740e", + "size": 1849547, + "subdir": "linux-64", + "timestamp": 1597262895015, + "version": "20.2.2" + }, + "pip-20.2.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1bb5020d2e6168adcb57db33056868f2", + "name": "pip", + "sha256": "96edaf197ad2fc787309773d9c7c843e7169e584f452d65c9b90a1f6ba378384", + "size": 1863245, + "subdir": "linux-64", + "timestamp": 1604430520304, + "version": "20.2.2" + }, + "pip-20.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bef2f1e079e942d2550c973d1e2d2c80", + "name": "pip", + "sha256": "bacad0d7e69ef9aab2f74d22cb91bb5a6ddb97c4a0f70dfa630faf85d69cda24", + "size": 1838513, + "subdir": "linux-64", + "timestamp": 1597262848633, + "version": "20.2.2" + }, + "pip-20.2.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a6ee904691b0077f12792653b836df9", + "name": "pip", + "sha256": "da1c354acf1d5acc597292156a4a9fc432ad7c22e7d0261464438160258b0c26", + "size": 1820198, + "subdir": "linux-64", + "timestamp": 1604430532351, + "version": "20.2.2" + }, + "pip-20.2.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4caf7e38197d003f65444ecfc6a3b6c5", + "name": "pip", + "sha256": "c1a4f01065a2aeb852b70a5d526bdf0b193e1a1011d072ac836d89d854f9af2b", + "size": 1824929, + "subdir": "linux-64", + "timestamp": 1597262890229, + "version": "20.2.2" + }, + "pip-20.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce06ffd6af11d48bb7512ca667858ca2", + "name": "pip", + "sha256": "60219f16fbdd69ebbf62bb172bf6406af8050fe0adf10a74d7583b859b9477e5", + "size": 1843356, + "subdir": "linux-64", + "timestamp": 1604430517386, + "version": "20.2.2" + }, + "pip-20.2.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b55cdf98353514ad68b8fc26bf824be1", + "name": "pip", + "sha256": "05616146a7b709aaf55087a7955caa61442c48b087e1d951f2876bc497da12ba", + "size": 1837748, + "subdir": "linux-64", + "timestamp": 1604430523247, + "version": "20.2.2" + }, + "pip-20.2.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc3a3063d7248899a3f16af3a57d0ce4", + "name": "pip", + "sha256": "8c04dd826d3dd90ebc824cf87c6450a6bcdbced5d8c06f45aa8269ca027daae8", + "size": 1858219, + "subdir": "linux-64", + "timestamp": 1601587525402, + "version": "20.2.3" + }, + "pip-20.2.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "159daf78fc998971116b52cfdcc29475", + "name": "pip", + "sha256": "1766ef6c31fd4110621aaf38fac4bfb2113095920be708d4b690912bf874699c", + "size": 1865123, + "subdir": "linux-64", + "timestamp": 1604432556774, + "version": "20.2.3" + }, + "pip-20.2.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6942a1308a7a7020e32027a3269cc4ee", + "name": "pip", + "sha256": "a4c76e779c019020e3dab24f66eb591fcd70e640b777de9f6bff0634b430fb39", + "size": 1825781, + "subdir": "linux-64", + "timestamp": 1601587554748, + "version": "20.2.3" + }, + "pip-20.2.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d2450ac468064fa93252be3c493479a", + "name": "pip", + "sha256": "701cc1d471b6d52330ab052bacc5b6d07786819a18e38c357fc029e8adea0ad9", + "size": 1816235, + "subdir": "linux-64", + "timestamp": 1604432765288, + "version": "20.2.3" + }, + "pip-20.2.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca01bf6bd8aafca8dc2a9efba81388eb", + "name": "pip", + "sha256": "60a42367fdfda3dd81f57e728d0166ee869fa3e1598cebbd7786ed52e812c1fa", + "size": 1831690, + "subdir": "linux-64", + "timestamp": 1601587558921, + "version": "20.2.3" + }, + "pip-20.2.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b0a479d96569b51597205a6cad86dad", + "name": "pip", + "sha256": "a1b56900f562b8da286f20377b7ce019bbd2e5bd616eb316b103e45363063452", + "size": 1827824, + "subdir": "linux-64", + "timestamp": 1604432791179, + "version": "20.2.3" + }, + "pip-20.2.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df6d4c0ae601270ce9e83f9cd3ba3fd2", + "name": "pip", + "sha256": "6aabb716706062946e17fe15a81ea7194bfa3705f479a1b5a79cf8fee8634bac", + "size": 1839736, + "subdir": "linux-64", + "timestamp": 1604432572958, + "version": "20.2.3" + }, + "pip-20.2.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d3700f47a5416040cf192c578f544e1", + "name": "pip", + "sha256": "299d781ff00d73c45bc3303cf2556cf81479f79a35a378f24cc1d7d9debe631f", + "size": 1845534, + "subdir": "linux-64", + "timestamp": 1603217526804, + "version": "20.2.4" + }, + "pip-20.2.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d71fc259b56fbb657c5563f3b9308a2d", + "name": "pip", + "sha256": "30f98a70cdb888cf401b6d8565e0df1ebf7a5fbc056229dfebe18a123009b911", + "size": 1849802, + "subdir": "linux-64", + "timestamp": 1604432667397, + "version": "20.2.4" + }, + "pip-20.2.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "91931d4db5039838db3eea1c55be2f2c", + "name": "pip", + "sha256": "663292d08be20828bb97b3a7deed02a1428d842174a0ffc172d3f5972f88fcda", + "size": 1811969, + "subdir": "linux-64", + "timestamp": 1603217557609, + "version": "20.2.4" + }, + "pip-20.2.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "579dc3e01fe5c6509266eb19e76bdf03", + "name": "pip", + "sha256": "f341dc810b1d7fe3c6b598051c2ee1e9812dfdd9f7f50caa8854a3341365525f", + "size": 1818439, + "subdir": "linux-64", + "timestamp": 1604432624932, + "version": "20.2.4" + }, + "pip-20.2.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "533d88758ffabffe02025d07cc80a36b", + "name": "pip", + "sha256": "a0320caab2c55d6d77e721ad71283cecadde42374b4258249d84fa81b14a992a", + "size": 1820464, + "subdir": "linux-64", + "timestamp": 1603217563508, + "version": "20.2.4" + }, + "pip-20.2.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6a4e48300049bb00bce40e91a3c3847", + "name": "pip", + "sha256": "612bd0779f43ca29f086a3e46e62b746631a75ff0215da3628c663c602b44f1b", + "size": 1844052, + "subdir": "linux-64", + "timestamp": 1604432649478, + "version": "20.2.4" + }, + "pip-20.2.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0fc6cb97575b03c9d292d95088cdbdf8", + "name": "pip", + "sha256": "e6eae40a8ecd08b877fd36527dd08ecf275066e8b77aead3aa93a823b13bb8bf", + "size": 1846184, + "subdir": "linux-64", + "timestamp": 1604432669174, + "version": "20.2.4" + }, + "pip-20.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a323bbabc6ef7ce75e2d8ee3bb362f0", + "name": "pip", + "sha256": "5577b3222c9c28d5a7a9504d69c9eb5c302114af3cfb651a76451a3a2e3fe123", + "size": 1877714, + "subdir": "linux-64", + "timestamp": 1606776240577, + "version": "20.3" + }, + "pip-20.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f861d6df4d0cc766cb591e32c92a431", + "name": "pip", + "sha256": "ba8f2701222f0794c6e9b6702465570c3de6888da2e67ff43b2926720cccb450", + "size": 1828605, + "subdir": "linux-64", + "timestamp": 1606776218804, + "version": "20.3" + }, + "pip-20.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ba8d7f9674324e40572f7849c906daf", + "name": "pip", + "sha256": "e15fa8026a9387f39a7102915f6c2d400f7d87c5c68501c3a8ba01034a5c237f", + "size": 1856237, + "subdir": "linux-64", + "timestamp": 1606776256928, + "version": "20.3" + }, + "pip-20.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0183dd3ace65e163e0a350c73fb2c52d", + "name": "pip", + "sha256": "20a4d595e15bab3fedcb9ff81c368b3daaa037e46879caa6af8c9a23da5474ad", + "size": 1856512, + "subdir": "linux-64", + "timestamp": 1606776278577, + "version": "20.3" + }, + "pip-20.3.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e2ffd22abef9c11f29c282b7eb58123", + "name": "pip", + "sha256": "af89de9f0ea1e6a2401de02cf4a6ed6829e8b09c7d78d63c633a38b5b3d6b5c6", + "size": 1879622, + "subdir": "linux-64", + "timestamp": 1607368431017, + "version": "20.3.1" + }, + "pip-20.3.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "070446cd8cf87ed6c39f4da526b95d38", + "name": "pip", + "sha256": "59460afcbc684584e2205a52ad17e977cefed5662416b1da7da0f4d12e036b63", + "size": 1847611, + "subdir": "linux-64", + "timestamp": 1607368436399, + "version": "20.3.1" + }, + "pip-20.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18f9471048e129c0ef2b3138f9837ee5", + "name": "pip", + "sha256": "c595a93e9690bd3721d75a1674da022a40d31ddd0382b33178efc9cda603a55c", + "size": 1838548, + "subdir": "linux-64", + "timestamp": 1607368410638, + "version": "20.3.1" + }, + "pip-20.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a487c8e49843088f0478697fe91dfd3", + "name": "pip", + "sha256": "604fb81198b1543d1d435121f8b2214989e1f7e213b51991b372e7d4ea56ff6c", + "size": 1835519, + "subdir": "linux-64", + "timestamp": 1607368440154, + "version": "20.3.1" + }, + "pip-20.3.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df33e5854e6b57f5cf2b99b5c35ab2a9", + "name": "pip", + "sha256": "271859fd5ab1ef0f5229243e88fd0a00a1924369e68556492a97f07525590b47", + "size": 1864603, + "subdir": "linux-64", + "timestamp": 1608057587060, + "version": "20.3.3" + }, + "pip-20.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c15c9c36557d8c9cda89a4196b363c2", + "name": "pip", + "sha256": "1e856419de1670ee57f7a485d8148782371719d5ecc703c1a52f72a9d37f7353", + "size": 1852242, + "subdir": "linux-64", + "timestamp": 1608057597059, + "version": "20.3.3" + }, + "pip-20.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71a30f302e20eda4707f1a7e470d77d5", + "name": "pip", + "sha256": "8c6baccb305737a418730ef6096465efeb5184446330fa61e0fa58be1bdf179d", + "size": 1857479, + "subdir": "linux-64", + "timestamp": 1608057593405, + "version": "20.3.3" + }, + "pip-20.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "edf7a43d48d7c9db9cfa2175b80a46e5", + "name": "pip", + "sha256": "78fde4f1b5676493546af13a386d339f4c909c8fc79d2d6f3382846b5f2c4c9b", + "size": 1856446, + "subdir": "linux-64", + "timestamp": 1608057589642, + "version": "20.3.3" + }, + "pip-21.0.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee1a9dcbed1f553b0690194656224e92", + "name": "pip", + "sha256": "e2c7fde62361165c02a41eb831d5cbebb9d7be3fe5c75f4ccf67253a9f485a19", + "size": 1910920, + "subdir": "linux-64", + "timestamp": 1613684917668, + "version": "21.0.1" + }, + "pip-21.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87a0ddac1ebce749e8c6c85a1b49a764", + "name": "pip", + "sha256": "e54c1b16721049a755095cb55333f9f502aea884dc8ca162a49aa4ee4d9c0109", + "size": 1846020, + "subdir": "linux-64", + "timestamp": 1613685632198, + "version": "21.0.1" + }, + "pip-21.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "294c4e999e656e8d2fbbb7955869703b", + "name": "pip", + "sha256": "dc5bc203bfac9ba49aefb0d75c90e215b11889b4168d6d5dc99f529a40a6d6ec", + "size": 1855767, + "subdir": "linux-64", + "timestamp": 1613685638502, + "version": "21.0.1" + }, + "pip-21.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f7883920f7d5d5641460f7faf0b65d36", + "name": "pip", + "sha256": "172d0c55318db23b4eb82c8db2bf82f1dffb33797fa2475dad418ca2dd4f07de", + "size": 1855339, + "subdir": "linux-64", + "timestamp": 1613685627054, + "version": "21.0.1" + }, + "pip-21.1.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a1a6e45a0f653623a6fe54b1150b19e", + "name": "pip", + "sha256": "b78b2bc270a1e62d8196fbb36bec2a7c6e3bdf179ecda83896227ee29b0db985", + "size": 1884573, + "subdir": "linux-64", + "timestamp": 1621540043926, + "version": "21.1.1" + }, + "pip-21.1.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d3a1894b9a1e76db45af1271337e28b", + "name": "pip", + "sha256": "1702b05caa6d163c36f9348074119ef959c6eab12cc5fd11dc825b224cec629e", + "size": 1841921, + "subdir": "linux-64", + "timestamp": 1621539896415, + "version": "21.1.1" + }, + "pip-21.1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7dcd2bd0480d7702a58341bc34dcdb42", + "name": "pip", + "sha256": "f8e3e62236147345c0a52badf3a83b6d0ed896c6ed89edbb183f73c7efed4523", + "size": 1850697, + "subdir": "linux-64", + "timestamp": 1621535355834, + "version": "21.1.1" + }, + "pip-21.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0c35b1ab3161080fd8ecab9a0b5d0c0", + "name": "pip", + "sha256": "8f6a802ad6b92b935229701cdf62f82970c38544c4a035800389b3c6a300a433", + "size": 1849107, + "subdir": "linux-64", + "timestamp": 1621540043503, + "version": "21.1.1" + }, + "pip-21.1.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "24962efecf5de3c83e71e443139b7c5a", + "name": "pip", + "sha256": "6dad3197fdf6c88027c9afad1951bbbd48fa88669d768a42b74907c2389fdf8d", + "size": 1873184, + "subdir": "linux-64", + "timestamp": 1623077847294, + "version": "21.1.2" + }, + "pip-21.1.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56a1f4f9e22863960125d5baeba901e4", + "name": "pip", + "sha256": "599beaab75efe0f2e461df9863947e187c66ff64f18941b60cf423fc970d1c3a", + "size": 1859700, + "subdir": "linux-64", + "timestamp": 1623077853443, + "version": "21.1.2" + }, + "pip-21.1.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13be1f753e57e60c33109ee04697603f", + "name": "pip", + "sha256": "d6672c2a91319a81d53323d2f41335b5556c69c47fe0cb66323455525642841a", + "size": 1850182, + "subdir": "linux-64", + "timestamp": 1623077854746, + "version": "21.1.2" + }, + "pip-21.1.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da1e0d56d442ff247c04fc5e3500c6fb", + "name": "pip", + "sha256": "eccc94c23bdf595b4b59fde42b8bc8ceb743db1f3cf59638545420d27f795941", + "size": 1848576, + "subdir": "linux-64", + "timestamp": 1623077799379, + "version": "21.1.2" + }, + "pip-21.1.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56c41564b5422884919dc6385f801930", + "name": "pip", + "sha256": "5c679e62a490ba6e388bd87a76d7d650295f0c2beabd1b8ad688da8cb932874c", + "size": 1871105, + "subdir": "linux-64", + "timestamp": 1624898116904, + "version": "21.1.3" + }, + "pip-21.1.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2673b7ef44d3fc551fcbbc3e90dfaca9", + "name": "pip", + "sha256": "fc4102ff01c01b7b222b125339771851db1d294b2205361bfe36bb1f1d146c8e", + "size": 1856931, + "subdir": "linux-64", + "timestamp": 1624898091371, + "version": "21.1.3" + }, + "pip-21.1.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33822c5c57bc6714a093bdfb27808de5", + "name": "pip", + "sha256": "e573ff17cf7581340ea9d154b6054d2abb19e32d13562ce1518f0b5ca3b6e663", + "size": 1869094, + "subdir": "linux-64", + "timestamp": 1624898105171, + "version": "21.1.3" + }, + "pip-21.1.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f7911bb8044299c9290a0040973098ed", + "name": "pip", + "sha256": "74aa86915c1e34a0fbab5f6c2ca8d4a78a6167304e23f78073c5453107095211", + "size": 1861423, + "subdir": "linux-64", + "timestamp": 1624898103032, + "version": "21.1.3" + }, + "pip-21.2.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2596437d2afaa7d7a2245020268f37fa", + "name": "pip", + "sha256": "327018a34e4fce4beeb0770ad661ccec7e65f8d248800540983bb4f282259a28", + "size": 1924432, + "subdir": "linux-64", + "timestamp": 1627796648423, + "version": "21.2.2" + }, + "pip-21.2.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e992ff1ba4b444c494ed991059c2ddb2", + "name": "pip", + "sha256": "823c7f0b68d1dd60f534c5bc596ecf29789939875251810fe023232c3d951e54", + "size": 1888175, + "subdir": "linux-64", + "timestamp": 1627796631586, + "version": "21.2.2" + }, + "pip-21.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d90475d332d19662328852c9d397dfd", + "name": "pip", + "sha256": "67e25dcedaf2b1c7ccedde4756baf21b8ca9455b22f8824abf5eac2c360cfcf5", + "size": 1902120, + "subdir": "linux-64", + "timestamp": 1627796630757, + "version": "21.2.2" + }, + "pip-21.2.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96ef86568db40b61e9f582ba27f7ae25", + "name": "pip", + "sha256": "222355cd9d6957b8478a85206868ee9c2f0fd429c48bf613b5299c7054dc8727", + "size": 1900801, + "subdir": "linux-64", + "timestamp": 1627796597623, + "version": "21.2.2" + }, + "pip-21.2.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad10e6236d2efb54b4d3461226164a3c", + "name": "pip", + "sha256": "1e15d3bcdc1c10cc80c4945776e7e50c43bbfd2597a9b46d9deec7ee073164f3", + "size": 1898306, + "subdir": "linux-64", + "timestamp": 1628716206449, + "version": "21.2.3" + }, + "pip-21.2.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df3428c0d905e24d0792f15ba4c6c2fe", + "name": "pip", + "sha256": "71b0f6df3a5b5900fa950a09ba6038d617faaaf31f3a3b158ca05b40416f8ca3", + "size": 1927214, + "subdir": "linux-64", + "timestamp": 1628716202684, + "version": "21.2.3" + }, + "pip-21.2.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9226ba5110dcc49c0cf117d0354f11fe", + "name": "pip", + "sha256": "3ffa4dafdd8050b145786daab306ee3677f4f999858ab0d1bfd5bcb1f674183a", + "size": 1932669, + "subdir": "linux-64", + "timestamp": 1628716200710, + "version": "21.2.3" + }, + "pip-21.2.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21e7c1e885a4aa8bbb198cab7a8a9e91", + "name": "pip", + "sha256": "7dfc2ae4cc75d577e5dde292f6cf7bbbab8004619d2cc77b743f96d167525662", + "size": 1900021, + "subdir": "linux-64", + "timestamp": 1628707881908, + "version": "21.2.3" + }, + "pip-21.2.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4e2586f845008770fa152082c04b27c", + "name": "pip", + "sha256": "c503bfc114de7d69b4f4b67a91d3e86c1601d8de21a8d25a22c7c23ad67ca5e0", + "size": 1921009, + "subdir": "linux-64", + "timestamp": 1633509621201, + "version": "21.2.4" + }, + "pip-21.2.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "998a1f616d0f971cd8a5741040b5fc8e", + "name": "pip", + "sha256": "dd5111a97634a8b395f646d1f105c10a32b8d2d018dc555291e8b1095b55f404", + "size": 1884804, + "subdir": "linux-64", + "timestamp": 1629205793868, + "version": "21.2.4" + }, + "pip-21.2.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4cc887ba625309097ff29d8ce96329d9", + "name": "pip", + "sha256": "c120859d1fa3da7f45b0d5ef824e6c3c8312a807aa70b94f5e11dd05ee4b026f", + "size": 1877048, + "subdir": "linux-64", + "timestamp": 1633498705574, + "version": "21.2.4" + }, + "pip-21.2.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74bcf27ebb94020ea1c838279382cadf", + "name": "pip", + "sha256": "f706390196a28c3d4826664006fa06ddef0c3c1be0675571f1162bb7ed2e3656", + "size": 1878437, + "subdir": "linux-64", + "timestamp": 1633509590979, + "version": "21.2.4" + }, + "pip-22.1.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "44c964a18eaff5bd61d2ddd0a7a89a80", + "name": "pip", + "sha256": "9c0c6068735ed06f022808463880ab4297d257b29c1a829aebaf14e03124184d", + "size": 2639990, + "subdir": "linux-64", + "timestamp": 1655220797041, + "version": "22.1.2" + }, + "pip-22.1.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f76956f3647aedaca145c481936aab49", + "name": "pip", + "sha256": "e7f57f6affa8c1584e6c735b3e42c4871621da837a7d68b8a1714bf07ef8f107", + "size": 2555768, + "subdir": "linux-64", + "timestamp": 1655220896199, + "version": "22.1.2" + }, + "pip-22.1.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5813bbeb4ded078095d35c867b3d8373", + "name": "pip", + "sha256": "a1b706d60e51fb9891b3eb1526d57344caa060efca34905763b35bb8e17a788f", + "size": 2571093, + "subdir": "linux-64", + "timestamp": 1655220829757, + "version": "22.1.2" + }, + "pip-22.1.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4485e29fb8b9be5ca1a7690c1dcec9e3", + "name": "pip", + "sha256": "a10c268c045b76339eda24cf11ed3d2cfbad0125409859b29ca8fbfb531252de", + "size": 2571977, + "subdir": "linux-64", + "timestamp": 1655220863056, + "version": "22.1.2" + }, + "pip-22.2.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b446157ab55432767f85b69b135dc452", + "name": "pip", + "sha256": "95216c77ef97b9c18cce2c3eed08b8ad11806cdce9ca9ad988f0efdbd3b3a2c2", + "size": 2483775, + "subdir": "linux-64", + "timestamp": 1664552837524, + "version": "22.2.2" + }, + "pip-22.2.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc9da2b0bc5986d4b8691bf49ce1439e", + "name": "pip", + "sha256": "a56dd2f42820e5b5e781e426613e44c1ccfa6778eb582bfaa252a4ca89815f7f", + "size": 3071806, + "subdir": "linux-64", + "timestamp": 1669778796770, + "version": "22.2.2" + }, + "pip-22.2.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0086cc0feaebeb94b7619cb6c040032b", + "name": "pip", + "sha256": "5494cc1304a61ac4afd4db248191a051ccab749349d692fb003543989f9bfa9b", + "size": 2404488, + "subdir": "linux-64", + "timestamp": 1664552773764, + "version": "22.2.2" + }, + "pip-22.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ed3e0331e7c614b3148c9911e1fc15e3", + "name": "pip", + "sha256": "3fb76b94cfa5ea9732bfb241b3d234ec0a5a48d16755c3c1ef3c94630f91eb26", + "size": 2417732, + "subdir": "linux-64", + "timestamp": 1664552878795, + "version": "22.2.2" + }, + "pip-22.2.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb97bf53e76d609bf93b2e9dd04799d8", + "name": "pip", + "sha256": "fdba7456a74a339886b29076f9adf301b07085f92bf32433d5ade81cf287553d", + "size": 2418169, + "subdir": "linux-64", + "timestamp": 1664552732381, + "version": "22.2.2" + }, + "pip-22.3.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e3d6059e30595fba64fccb77f9044f0", + "name": "pip", + "sha256": "0b147ce6165256b7a25983cf587e2fc7cb70884039b2d7e2b9497a15848137f5", + "size": 2912898, + "subdir": "linux-64", + "timestamp": 1670597508832, + "version": "22.3.1" + }, + "pip-22.3.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "352428d11ace1b907a0d1933cb21d070", + "name": "pip", + "sha256": "22dd4000562cc8ab608fb478357743604ef6a4f90ddcdcba265657128575d1e8", + "size": 3059654, + "subdir": "linux-64", + "timestamp": 1676822509382, + "version": "22.3.1" + }, + "pip-22.3.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4bddce1e6446e82068f446b627d9c17a", + "name": "pip", + "sha256": "b39d7eac5d8e8c4aaa9805bb1df34bf957b41565e728b69859922592a1065f9d", + "size": 2825048, + "subdir": "linux-64", + "timestamp": 1670597444069, + "version": "22.3.1" + }, + "pip-22.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d68389c38118ff466fa861c8904950c", + "name": "pip", + "sha256": "75254ecb5902a7bddb28260d984bd0b75c363fbb2378645ac8cc37e43f2849a1", + "size": 2841625, + "subdir": "linux-64", + "timestamp": 1670597539231, + "version": "22.3.1" + }, + "pip-22.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "551a81c65d85d3bfd0f849fdda5bfad8", + "name": "pip", + "sha256": "848261f981fd07eb8b7b64cb772062886b10407df96ec646cded06be99024cb5", + "size": 2840489, + "subdir": "linux-64", + "timestamp": 1670597477663, + "version": "22.3.1" + }, + "pip-23.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8f27960f21f51c3945fae93e2993e85", + "name": "pip", + "sha256": "603d93a0439af820fd2066013d0eafad63661683084805a4a5fd16317025f744", + "size": 2721809, + "subdir": "linux-64", + "timestamp": 1678181441092, + "version": "23.0.1" + }, + "pip-23.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "06ec6690fc9814ab769a62dfeeb26419", + "name": "pip", + "sha256": "f82e173b31ca829768ce2aaf39a04f4878c90bc397d02b906176dd40470295be", + "size": 2894556, + "subdir": "linux-64", + "timestamp": 1679337383184, + "version": "23.0.1" + }, + "pip-23.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "76496ff05a04113680df82fd3566e215", + "name": "pip", + "sha256": "b0806ade4619de8fdef079e295950d8103ccbb324ed0a93042ff0acf793fa80f", + "size": 2652508, + "subdir": "linux-64", + "timestamp": 1678181371709, + "version": "23.0.1" + }, + "pip-23.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e36d76b4611ca9b5d8bd180232aecbac", + "name": "pip", + "sha256": "767d66e72218bdbfa0aa79283c0f520958bab999a00b2fa835da7614aeea7b6f", + "size": 2651296, + "subdir": "linux-64", + "timestamp": 1678181406206, + "version": "23.0.1" + }, + "pip-9.0.1-py27_5.conda": { + "build": "py27_5", + "build_number": 5, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da695cbc561b2f8969037f76218a23d1", + "name": "pip", + "sha256": "8547581881c283934b6e3d745704a369c70e0f9a437951c22217546706099767", + "size": 1960309, + "subdir": "linux-64", + "timestamp": 1519845766230, + "version": "9.0.1" + }, + "pip-9.0.1-py27h4c18a59_2.conda": { + "build": "py27h4c18a59_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6abac0e2a527e393b4415dee19c0eed2", + "name": "pip", + "sha256": "eeb6543d18fa9d0c4dc0fcafcc5ab14eb14b58a3717a6ef106ad436dd6996e05", + "size": 1524512, + "subdir": "linux-64", + "timestamp": 1505671923748, + "version": "9.0.1" + }, + "pip-9.0.1-py27ha730c48_4.conda": { + "build": "py27ha730c48_4", + "build_number": 4, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eac414cbb464f63a8e55cb070454325a", + "name": "pip", + "sha256": "868ec64182b46c81a72e0fee13b1f3991c534c910450482e2770e968c2bdd328", + "size": 1948762, + "subdir": "linux-64", + "timestamp": 1509124762500, + "version": "9.0.1" + }, + "pip-9.0.1-py27hbf658b2_3.conda": { + "build": "py27hbf658b2_3", + "build_number": 3, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e2fa8071eb4b9190db654864d115b7df", + "name": "pip", + "sha256": "927baa83df4bb2efdfc96fdb74c23b94e9b6c0b2d6239c0ca7870d9db9f61d01", + "size": 1526143, + "subdir": "linux-64", + "timestamp": 1506357742693, + "version": "9.0.1" + }, + "pip-9.0.1-py35_5.conda": { + "build": "py35_5", + "build_number": 5, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3830b3088b98536c06cc1cf7b4ebed47", + "name": "pip", + "sha256": "49e92928b63b278cbba2452adf5b66642e3d28b85fcc20016ad65a48210dcdf7", + "size": 1995704, + "subdir": "linux-64", + "timestamp": 1519845811319, + "version": "9.0.1" + }, + "pip-9.0.1-py35h7e7da9d_4.conda": { + "build": "py35h7e7da9d_4", + "build_number": 4, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f80683d695de6547bdb61d45b9c3849", + "name": "pip", + "sha256": "9b9e3ba371fed5c04cd1564bdd79d7b77afe4151a8b345de03a795f65d204adb", + "size": 1995495, + "subdir": "linux-64", + "timestamp": 1509124771925, + "version": "9.0.1" + }, + "pip-9.0.1-py35haa8ec2a_3.conda": { + "build": "py35haa8ec2a_3", + "build_number": 3, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d18c12a09908303003549a0e9312d0a0", + "name": "pip", + "sha256": "0fc1d14a821e478988a0b9d8e6cbd7795b54e572c3c76f84074c724c5134aa7e", + "size": 1561998, + "subdir": "linux-64", + "timestamp": 1506357769885, + "version": "9.0.1" + }, + "pip-9.0.1-py35he1b8d41_2.conda": { + "build": "py35he1b8d41_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e44662c0d50f1c8fd34605e9db65578", + "name": "pip", + "sha256": "c5610cf7d9358a9de49818d00f41a3ccae1dddfd5a9b7303e436dbc37c2a435f", + "size": 1544916, + "subdir": "linux-64", + "timestamp": 1505671952867, + "version": "9.0.1" + }, + "pip-9.0.1-py36_5.conda": { + "build": "py36_5", + "build_number": 5, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58c5057b96c6f3641aedf79dcae00c14", + "name": "pip", + "sha256": "891b50c0fe7cf1f84161dd6b9e8f78f6e3b7440862250b5e53d561a3a1c72efb", + "size": 1938574, + "subdir": "linux-64", + "timestamp": 1519845805656, + "version": "9.0.1" + }, + "pip-9.0.1-py36h30f8307_2.conda": { + "build": "py36h30f8307_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d069cfa8eb8bf46b94f0b40038c6d7a", + "name": "pip", + "sha256": "b656256c61f060ed1bbf69c7e05a90045e3ed711ad9a5e27a3603dff30e0bf31", + "size": 1514791, + "subdir": "linux-64", + "timestamp": 1505671982188, + "version": "9.0.1" + }, + "pip-9.0.1-py36h6c6f9ce_4.conda": { + "build": "py36h6c6f9ce_4", + "build_number": 4, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c97ff3da3a7b5e8aa24da06ab456b095", + "name": "pip", + "sha256": "7dd1f4d46bca53f5a2448bf4ad766a875d11dc4b5cae482c4e39587963521a3b", + "size": 1937113, + "subdir": "linux-64", + "timestamp": 1509124780144, + "version": "9.0.1" + }, + "pip-9.0.1-py36h8ec8b28_3.conda": { + "build": "py36h8ec8b28_3", + "build_number": 3, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1155fa69134a87151956c9b3e001a07", + "name": "pip", + "sha256": "16506d5be4257c5b56f33bf18d9466c0453a9c82ff70f821f52d759f71ffe4fc", + "size": 1504657, + "subdir": "linux-64", + "timestamp": 1506357774387, + "version": "9.0.1" + }, + "pip-9.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1c7bd09b0679531c4fba5b3ec7ab559", + "name": "pip", + "sha256": "d2ead4395a2f11fe36a16cc0cff2302d361adb804ec20647d47929f4fbcc5ba0", + "size": 2001318, + "subdir": "linux-64", + "timestamp": 1522444269703, + "version": "9.0.3" + }, + "pip-9.0.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f5bd57d6b397e8a15633a3dc8dd9c6c", + "name": "pip", + "sha256": "29210acf44393061d8150aad7fc3bdb9679a2785c53ebc1829f842a57f895461", + "size": 2017472, + "subdir": "linux-64", + "timestamp": 1522444297467, + "version": "9.0.3" + }, + "pip-9.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ae4020a1baca178fb9beca6d4382da20", + "name": "pip", + "sha256": "f8161a5c3e2cf1ae5657693b9ada10b228301a11f6d5a55fbca063e5fd81a8b1", + "size": 1995651, + "subdir": "linux-64", + "timestamp": 1522444316409, + "version": "9.0.3" + }, + "pipenv-2022.7.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "pip >=22.0.4", + "python >=3.10,<3.11.0a0", + "setuptools >=36.2.1", + "virtualenv", + "virtualenv-clone >=0.2.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5602cae7121f2c40f3efe89c4f1d62ce", + "name": "pipenv", + "sha256": "0ce6aa2ad9b55864b3e85f4bddcc79581cb8c7c42e126ea688d010d595d4356d", + "size": 4005749, + "subdir": "linux-64", + "timestamp": 1657899500849, + "version": "2022.7.4" + }, + "pipenv-2022.7.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "pip >=22.0.4", + "python >=3.11,<3.12.0a0", + "setuptools >=36.2.1", + "virtualenv", + "virtualenv-clone >=0.2.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e54b8b910bc6490d3188024c905a9f93", + "name": "pipenv", + "sha256": "a6ba98e5d64eff7e13ecab436f6e45b31c3b5e8f6d332301b3802a3724f03a7f", + "size": 5491647, + "subdir": "linux-64", + "timestamp": 1676845191963, + "version": "2022.7.4" + }, + "pipenv-2022.7.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "pip >=22.0.4", + "python >=3.7,<3.8.0a0", + "setuptools >=36.2.1", + "virtualenv", + "virtualenv-clone >=0.2.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b98b6e27e88e5d5c9830dd588d9448a8", + "name": "pipenv", + "sha256": "f5de72ed66a41f51fe385cf5eb7cc2820f9b027e4ba099ea4ae6ac4847895e0d", + "size": 3894628, + "subdir": "linux-64", + "timestamp": 1657899253227, + "version": "2022.7.4" + }, + "pipenv-2022.7.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "pip >=22.0.4", + "python >=3.8,<3.9.0a0", + "setuptools >=36.2.1", + "virtualenv", + "virtualenv-clone >=0.2.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c33c9b7b7c66f04014c903e70ac5c2c", + "name": "pipenv", + "sha256": "c7a4eb9d17a9160e6f696477476fe0e3ef5ace38921819c621f270b4b5af7e7b", + "size": 3918897, + "subdir": "linux-64", + "timestamp": 1657899146628, + "version": "2022.7.4" + }, + "pipenv-2022.7.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "pip >=22.0.4", + "python >=3.9,<3.10.0a0", + "setuptools >=36.2.1", + "virtualenv", + "virtualenv-clone >=0.2.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ed95d516177027baf0240b359d68336", + "name": "pipenv", + "sha256": "5c7f6c49cff6b78bd4f0c3fbbc9908b175a88a158e14812d922d90102951c4b0", + "size": 3923280, + "subdir": "linux-64", + "timestamp": 1657899359700, + "version": "2022.7.4" + }, + "pivottablejs-0.9.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "a06ea1dabe7286d068c7d9682640faa7", + "name": "pivottablejs", + "sha256": "fbe5525723593917f1532f706ccfbe163edfbf4d6d56043d975ac0a136e384ab", + "size": 7589, + "subdir": "linux-64", + "timestamp": 1519198348354, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "e083af6fad1de09a7a22461e21dad65a", + "name": "pivottablejs", + "sha256": "46d31067c137af017d6b57f0ab4bf1e4d8ba0795a2b59f032d4f4c35550dc74c", + "size": 8413, + "subdir": "linux-64", + "timestamp": 1640812675303, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "93fc66637d93f8e03ebe7488308c4300", + "name": "pivottablejs", + "sha256": "88b3b793f8ae8d9653534a66aa727e2f881f28be01fc7d3c0f3cf2031ec55e0e", + "size": 9184, + "subdir": "linux-64", + "timestamp": 1676907445871, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "e1571b7a5fcd1f4c7c077a70c8fce821", + "name": "pivottablejs", + "sha256": "46f8d00e44b1e480313be3294a5bc7517881af5840bf1607998d96aceee08990", + "size": 7615, + "subdir": "linux-64", + "timestamp": 1519198371825, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "740842e4258cf6ce688f9acb8b6553f4", + "name": "pivottablejs", + "sha256": "d3a55d55ff23dcc2fda7983c48060983817b964745bf8835e9d52258b5b4b1df", + "size": 7587, + "subdir": "linux-64", + "timestamp": 1519198333222, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "18020eadd406fd3b0faf4ba143d299cf", + "name": "pivottablejs", + "sha256": "ba02d1d83eef536747af6a1d9124cd197541d5ed8eb7e238ca5ecfd254f0fcec", + "size": 250839, + "subdir": "linux-64", + "timestamp": 1614011670321, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "ad627f3c3fb8d83007df731f56251e25", + "name": "pivottablejs", + "sha256": "20e0320ea8eba3447662a8d268abb377e06356f015bcb72b6cc0640467b01261", + "size": 7494, + "subdir": "linux-64", + "timestamp": 1530905184520, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "ddc711e07b18eea2f5191317262a7d73", + "name": "pivottablejs", + "sha256": "247d34513fa4e4eacdb3062a6fc34d082f46117197d9cd978b9c2a241ca9c75c", + "size": 250813, + "subdir": "linux-64", + "timestamp": 1614011461083, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "57e5bb42ba443868cce7a7b36f0cee4b", + "name": "pivottablejs", + "sha256": "408e86154730707a254c59c0d033fdb99912f9fa4d90761ef961e360e1cb9f3b", + "size": 8608, + "subdir": "linux-64", + "timestamp": 1574235848226, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "0161acc717997effa374834b0a17427b", + "name": "pivottablejs", + "sha256": "17cb73ba11f1491b3c24e2e7adef78e25b9607f0733b2a66fdb0582652a152df", + "size": 251142, + "subdir": "linux-64", + "timestamp": 1614011674570, + "version": "0.9.0" + }, + "pivottablejs-0.9.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "cb5bf8603388aa1563886e7a64243acc", + "name": "pivottablejs", + "sha256": "7847d987d86d38fa9651b8a2a466e341653ea1874f2f1de33f02ee1063f234c3", + "size": 251101, + "subdir": "linux-64", + "timestamp": 1614011467121, + "version": "0.9.0" + }, + "pivottablejs-airgap-2.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "94ea87db6ad3a58c64600ddc4edb1b2d", + "name": "pivottablejs-airgap", + "sha256": "d786ab652b4589ddec89bf56c7204454ce367d895602d0769769fc6245076df0", + "size": 271691, + "subdir": "linux-64", + "timestamp": 1519194992067, + "version": "2.1.0" + }, + "pivottablejs-airgap-2.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "797ae8882b091d0c561954ae61b51e52", + "name": "pivottablejs-airgap", + "sha256": "a6176264f1648ba6b2c922f5a043f0960eedcdace8befb6b8ed72fed62d8b5fa", + "size": 271732, + "subdir": "linux-64", + "timestamp": 1519195005735, + "version": "2.1.0" + }, + "pivottablejs-airgap-2.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6060d1426a9d8a42e31dbab8a3659790", + "name": "pivottablejs-airgap", + "sha256": "3d6b7fcbf1031974a7f1f4638446c7af4e4789384705f7e7f32bfcb979890291", + "size": 271806, + "subdir": "linux-64", + "timestamp": 1519195095409, + "version": "2.1.0" + }, + "pivottablejs-airgap-2.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f5ff4f610ef04ce059324763eff8499e", + "name": "pivottablejs-airgap", + "sha256": "9264e572bf647090d229e7322f25a8acf79abbd4ecf26f713578ad342deafe57", + "size": 289132, + "subdir": "linux-64", + "timestamp": 1519199258557, + "version": "2.7.0" + }, + "pivottablejs-airgap-2.7.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "f5dfedb37a0fd19edb71a7df19a43a81", + "name": "pivottablejs-airgap", + "sha256": "77db9bf0cb9c0fed8435917d9d1eeeda0adf068b4140b85a36f8985bcb354189", + "size": 289147, + "subdir": "linux-64", + "timestamp": 1640815436937, + "version": "2.7.0" + }, + "pivottablejs-airgap-2.7.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "78799e913ac969b2ce2fbc567dbfab7c", + "name": "pivottablejs-airgap", + "sha256": "0f01cc17c8b28365d74d7c843a80f7acb0f0a3ba11ca597e14d1ab30121d7b12", + "size": 289142, + "subdir": "linux-64", + "timestamp": 1519199273714, + "version": "2.7.0" + }, + "pivottablejs-airgap-2.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "07c0f596adb10c6711dcf6d59948b456", + "name": "pivottablejs-airgap", + "sha256": "80cb004c7a86352d3a94a47ae9be78f60f494b2f77ec2ca961e63661fe742bb9", + "size": 289175, + "subdir": "linux-64", + "timestamp": 1519199249503, + "version": "2.7.0" + }, + "pivottablejs-airgap-2.7.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4e88bf69785fd2b4a3381f7cdd26bff8", + "name": "pivottablejs-airgap", + "sha256": "77873794c489bf6efda73ee3e1b2d7adbbde0d0407dd0ab737ddbcd70bac9145", + "size": 530141, + "subdir": "linux-64", + "timestamp": 1614013206011, + "version": "2.7.0" + }, + "pivottablejs-airgap-2.7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "79b78e28ad1797fd8f90e76467e668a5", + "name": "pivottablejs-airgap", + "sha256": "b12d06b3da1eafb542723c3e55a10e2e48ad457dcd7d780d2425cc07c92eb6fe", + "size": 289076, + "subdir": "linux-64", + "timestamp": 1530905219425, + "version": "2.7.0" + }, + "pivottablejs-airgap-2.7.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5d03d932f10a255e34f3834b29cefa86", + "name": "pivottablejs-airgap", + "sha256": "e5f1bdd6fa5c35311beece3f8aedf73db3fb158938ebdada6dff2aa5f2861c8b", + "size": 532119, + "subdir": "linux-64", + "timestamp": 1614014090644, + "version": "2.7.0" + }, + "pivottablejs-airgap-2.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "e31ca3882728f4221e260f4a3f623ed0", + "name": "pivottablejs-airgap", + "sha256": "87e4d8ed196980353b880b00562c7f3c89e22e04d17b40f51a4695e361293190", + "size": 531309, + "subdir": "linux-64", + "timestamp": 1614014096991, + "version": "2.7.0" + }, + "pivottablejs-airgap-2.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "notebook", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "95508f0effc96b69b0376693cb4c643e", + "name": "pivottablejs-airgap", + "sha256": "8ec30c6859537b791bf5aa53d55bc012b75a3342ad72ec739be0d64294ec13f6", + "size": 533059, + "subdir": "linux-64", + "timestamp": 1614013651239, + "version": "2.7.0" + }, + "pixman-0.34.0-h83dc358_2.conda": { + "build": "h83dc358_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "a2a83d89ee459dccfa79c506675bb4f1", + "name": "pixman", + "sha256": "b845d09e1fe79b732bf127319db1a487c1bf309c2713368dca43ea402e1a44de", + "size": 352586, + "subdir": "linux-64", + "timestamp": 1507907681204, + "version": "0.34.0" + }, + "pixman-0.34.0-ha72d70b_1.conda": { + "build": "ha72d70b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "863d749133a23a392fe00b1dbbee4de2", + "name": "pixman", + "sha256": "2be9c9d0189fd48f1aba3b240be73eea94092d48690771bac0de3874b8f61d90", + "size": 352103, + "subdir": "linux-64", + "timestamp": 1505741726054, + "version": "0.34.0" + }, + "pixman-0.34.0-hceecf20_3.conda": { + "build": "hceecf20_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "2a421e46174397898d3053af8ea4698b", + "name": "pixman", + "sha256": "526477026099a61eb6ad9afa7eda060d0a6e86cbcde9c1d91f0301219d31caf6", + "size": 353939, + "subdir": "linux-64", + "timestamp": 1510175761788, + "version": "0.34.0" + }, + "pixman-0.36.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "md5": "8209a1280fed927ca7752420968b1af1", + "name": "pixman", + "sha256": "07149fef42afa3b2e0a38d96467e13200e5c7889ee616f0491a97157ed0f0d34", + "size": 369496, + "subdir": "linux-64", + "timestamp": 1547245646019, + "version": "0.36.0" + }, + "pixman-0.38.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "md5": "7a603e29563e7c3eb184afaf28dd000d", + "name": "pixman", + "sha256": "e9bea5425bd9a12c190c8b31ebdb907eca87d81af0e634dc3bcc544fe5373a83", + "size": 373125, + "subdir": "linux-64", + "timestamp": 1552420972972, + "version": "0.38.0" + }, + "pixman-0.40.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "md5": "d0795722579384430a722ab916695e3e", + "name": "pixman", + "sha256": "c0092d518567b55bc88fdc2f85fa63f2dd2aefa278cf1a4f417394f3339967bb", + "size": 378986, + "subdir": "linux-64", + "timestamp": 1592924281332, + "version": "0.40.0" + }, + "pixman-0.40.0-h7f8727e_0.conda": { + "build": "h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "MIT", + "md5": "8fc1fd3cad6fbd44f57e05b3ac290411", + "name": "pixman", + "sha256": "03114424ea83a7a3d55a8a0a24d87bdb401de99ee02b65fe6cd0906020ece7f7", + "size": 381819, + "subdir": "linux-64", + "timestamp": 1632408724146, + "version": "0.40.0" + }, + "pixman-0.40.0-h7f8727e_1.conda": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "MIT", + "md5": "406469dab3fdd6c24eae7dd18f649930", + "name": "pixman", + "sha256": "ae368aa9612252cb188438801639a2aff9e6d585b5fa73346f882f9e7e9c5c2d", + "size": 382132, + "subdir": "linux-64", + "timestamp": 1632711422664, + "version": "0.40.0" + }, + "pkg-config-0.29.2-h1bed415_7.conda": { + "build": "h1bed415_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 2", + "md5": "d9cc63ef21fd0faf00e9a4b40743c676", + "name": "pkg-config", + "sha256": "c4d6d20ff1acff734c772fea151a1ce9fcd1e66673f6a9703f848d7d32377614", + "size": 249443, + "subdir": "linux-64", + "timestamp": 1516189720680, + "version": "0.29.2" + }, + "pkg-config-0.29.2-h1bed415_8.conda": { + "build": "h1bed415_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 2", + "md5": "ae72cea145478a1d5a06808b6539da9f", + "name": "pkg-config", + "sha256": "05d222bbeebfb2f5c1cfd9612cf06446c525a7369e1213a7a7f644fe03902d31", + "size": 250772, + "subdir": "linux-64", + "timestamp": 1523306120929, + "version": "0.29.2" + }, + "pkg-config-0.29.2-h4878432_4.conda": { + "build": "h4878432_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 2", + "md5": "9ae8758f6e159247e8578fbd121e9bab", + "name": "pkg-config", + "sha256": "da08f6717fcd2ecb96f92d2a8ecb5f233e904c22574ad00a1653701bb5b2e27e", + "size": 248035, + "subdir": "linux-64", + "timestamp": 1505666393261, + "version": "0.29.2" + }, + "pkg-config-0.29.2-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL 2", + "md5": "937e780e387e22bada572ae7d3695a22", + "name": "pkg-config", + "sha256": "f9fadc09e0790ea9694a48d94fbb6a221ad10e761ffc389786347150db6e73f7", + "size": 125705, + "subdir": "linux-64", + "timestamp": 1596130841706, + "version": "0.29.2" + }, + "pkg-config-0.29.2-he821fa1_6.conda": { + "build": "he821fa1_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 2", + "md5": "71482ce9536f1ded9385c5707105c2aa", + "name": "pkg-config", + "sha256": "3ed7d45a38204f1c31bafafad0de4b5833b909dad23707eb6cde35a4d1fd2d48", + "size": 249285, + "subdir": "linux-64", + "timestamp": 1511643221202, + "version": "0.29.2" + }, + "pkg-config-0.29.2-hf7364cd_5.conda": { + "build": "hf7364cd_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL 2", + "md5": "e7077b31a100b7fa3ca591d861dfb7e3", + "name": "pkg-config", + "sha256": "874347fda4e7d2fe0e0e7a621e118158f0a72ad85a24aaeb2b6c0659b1a8240c", + "size": 249101, + "subdir": "linux-64", + "timestamp": 1507907493288, + "version": "0.29.2" + }, + "pkgconfig-1.2.2-py27h48ab9b6_1.conda": { + "build": "py27h48ab9b6_1", + "build_number": 1, + "depends": [ + "pkg-config", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c30bf0db282e76b74c2aa73e98aeab7", + "name": "pkgconfig", + "sha256": "f8f11836250b53ef2f0c29fcf49232297d2f9865e3b840b6356d01e15a605c2c", + "size": 10122, + "subdir": "linux-64", + "timestamp": 1505732162964, + "version": "1.2.2" + }, + "pkgconfig-1.2.2-py35hd3dfabb_1.conda": { + "build": "py35hd3dfabb_1", + "build_number": 1, + "depends": [ + "pkg-config", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ce83835ef47887b89b998aa4a373232", + "name": "pkgconfig", + "sha256": "f7fc052f6cac853313a3ed7a225c2e24e2c6a032e2fe480759d9259ee49478b7", + "size": 10343, + "subdir": "linux-64", + "timestamp": 1505732173915, + "version": "1.2.2" + }, + "pkgconfig-1.2.2-py36h08d3f6d_1.conda": { + "build": "py36h08d3f6d_1", + "build_number": 1, + "depends": [ + "pkg-config", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e5aa978836da8b90387032c6166ac09", + "name": "pkgconfig", + "sha256": "ac9d8fd9025534cb3a99b25da763cc02c0b2430f404658a1a98712c529830044", + "size": 10258, + "subdir": "linux-64", + "timestamp": 1505732184986, + "version": "1.2.2" + }, + "pkgconfig-1.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e52d76b933fa814e2d58def7bf813d36", + "name": "pkgconfig", + "sha256": "4167decd38c4592d94be31b011489e9885e5daff9757a326b43f8bca54bbbe76", + "size": 11276, + "subdir": "linux-64", + "timestamp": 1522192646457, + "version": "1.3.1" + }, + "pkgconfig-1.3.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "28c1db86cfec8d336b66f17a73d95533", + "name": "pkgconfig", + "sha256": "e47982a9219c4eb82fb086e79ef52c426160da0944542934e3de13a001bb772e", + "size": 11586, + "subdir": "linux-64", + "timestamp": 1522192720375, + "version": "1.3.1" + }, + "pkgconfig-1.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8cebb1f66a308a242bad4d0ec2908986", + "name": "pkgconfig", + "sha256": "2c8969208e4e69925e441e485f72e268a10362b31f6fbac4cdbe0caf46a4720b", + "size": 11468, + "subdir": "linux-64", + "timestamp": 1522192721840, + "version": "1.3.1" + }, + "pkgconfig-1.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4ceded42eb04277fc7c0c88f1fdcc6a", + "name": "pkgconfig", + "sha256": "7db433103c6a1d835fcf1ef2bc5d84a2fb8fd6411801a1b419a40cf8f87b7809", + "size": 11427, + "subdir": "linux-64", + "timestamp": 1530770962237, + "version": "1.3.1" + }, + "pkgconfig-1.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4851588d579440f04eca81bd738a9cf", + "name": "pkgconfig", + "sha256": "bed89183dd307f6c4340a49bd9a4bbacc051085757f9a132654f4fbddc5cdc25", + "size": 11734, + "subdir": "linux-64", + "timestamp": 1536262689439, + "version": "1.4.0" + }, + "pkgconfig-1.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "699c6e815efbb14f4ee305f0478eec60", + "name": "pkgconfig", + "sha256": "8c9be0f309abb971e8890701476211c02e875dec4d05670d8a4eb0ffe9939aef", + "size": 11955, + "subdir": "linux-64", + "timestamp": 1536262734216, + "version": "1.4.0" + }, + "pkgconfig-1.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2b535a88d7e7c1b348be11bfea8802b", + "name": "pkgconfig", + "sha256": "d320e7511b0537c481f9035bed3b8adbf9a4990bdd218a9dd589c491b038260a", + "size": 11967, + "subdir": "linux-64", + "timestamp": 1536262615889, + "version": "1.4.0" + }, + "pkgconfig-1.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0ba073078db3f0b5988170cd8e433599", + "name": "pkgconfig", + "sha256": "7d9949f0123c06bf152962a4b952bd8ff6ce9dccfa6ebd08bc0d64a60a796d37", + "size": 11901, + "subdir": "linux-64", + "timestamp": 1536262768462, + "version": "1.4.0" + }, + "pkgconfig-1.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47692fb4c997f39b0a8b125cfaeda7f4", + "name": "pkgconfig", + "sha256": "7b654854e40c06bc9dea80dc4ed0b5f364ceeeb7b5e02bf3247661506b4bc4ed", + "size": 11910, + "subdir": "linux-64", + "timestamp": 1573489557510, + "version": "1.4.0" + }, + "pkgconfig-1.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3178cb9b6d3573b5785b3261d47a9207", + "name": "pkgconfig", + "sha256": "cab9dc1ce804095ac1442d09c9060fd740975a67fef036ea44808d44e59b46e7", + "size": 13389, + "subdir": "linux-64", + "timestamp": 1607465348836, + "version": "1.4.0" + }, + "pkgconfig-1.5.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e50b8ae68583ac23ecfd735ed440c839", + "name": "pkgconfig", + "sha256": "54dccbdf1620db0a35054f9d3d476e867c123abc699e002031ae6bd6a8905649", + "size": 13173, + "subdir": "linux-64", + "timestamp": 1613764525145, + "version": "1.5.2" + }, + "pkgconfig-1.5.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe5a665ae1c154a395e6a11b52749ff7", + "name": "pkgconfig", + "sha256": "620f21ca955a9e9d99ebd6c39bc22f7405fd224045184b5cd5af5f61c78dcc78", + "size": 13143, + "subdir": "linux-64", + "timestamp": 1613763741175, + "version": "1.5.2" + }, + "pkgconfig-1.5.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b30d78625632669be98369a63401aeb", + "name": "pkgconfig", + "sha256": "808a8fb09bbac1240d64e523678eb4267f6c90c45163128bfa4b096e735b8ad6", + "size": 13297, + "subdir": "linux-64", + "timestamp": 1613764531926, + "version": "1.5.2" + }, + "pkgconfig-1.5.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ea289f11144a99a6820a1dc0962ec07", + "name": "pkgconfig", + "sha256": "75d381baf12e30510454e5e1f63b3783a151109c18cc5455264f77e0a4850ed7", + "size": 13812, + "subdir": "linux-64", + "timestamp": 1640887309137, + "version": "1.5.4" + }, + "pkgconfig-1.5.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3243275391966873d017852677ee719e", + "name": "pkgconfig", + "sha256": "7e03aef009c4f00905fc35a02d435437f756e6d77327c933759c9051053b9fb5", + "size": 16625, + "subdir": "linux-64", + "timestamp": 1676903868004, + "version": "1.5.4" + }, + "pkgconfig-1.5.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92770f01c0a0fa3bd1ddc979ac13778e", + "name": "pkgconfig", + "sha256": "85b95bc552392c711f1eeb2b4658c80583a44193a5adab6417cde2553103185d", + "size": 13811, + "subdir": "linux-64", + "timestamp": 1623158605892, + "version": "1.5.4" + }, + "pkgconfig-1.5.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74a6e2a95303b8f61e62f26e89ddce9a", + "name": "pkgconfig", + "sha256": "2df97cbde62baf0693e5e1cca7ab828039147fed450e8f65234166d3d2356484", + "size": 13746, + "subdir": "linux-64", + "timestamp": 1623164120839, + "version": "1.5.4" + }, + "pkgconfig-1.5.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "786396b2249ec984b1f54d62fc29210a", + "name": "pkgconfig", + "sha256": "1fd57087406f14a36c620d815b372c62b20c1974db51cdf07bbf0fd2ad7fcb01", + "size": 13821, + "subdir": "linux-64", + "timestamp": 1623164118648, + "version": "1.5.4" + }, + "pkgconfig-1.5.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0656250185080d809258a0c0c31a33c2", + "name": "pkgconfig", + "sha256": "d49c8deffdb4253c619388c5bc91ad607888ad76549bcdb0d9891bd0db139e0d", + "size": 13917, + "subdir": "linux-64", + "timestamp": 1623249728276, + "version": "1.5.4" + }, + "pkgconfig-1.5.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22b94aabb9e7db73a2eb586641b66f44", + "name": "pkgconfig", + "sha256": "e2f306efc7cadaf5e5cf9d05bb8aad9c2adadc827322d1425447b50de3c21d7d", + "size": 13581, + "subdir": "linux-64", + "timestamp": 1640037467869, + "version": "1.5.5" + }, + "pkgconfig-1.5.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f057ba8b7ffec834298d73135833bdd", + "name": "pkgconfig", + "sha256": "dd2641d428a0eb990efd7b4416631eb7c5993046fa00ca9af50a161c25f33a04", + "size": 13597, + "subdir": "linux-64", + "timestamp": 1640037435929, + "version": "1.5.5" + }, + "pkgconfig-1.5.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pkg-config", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3809be4784c2eeb02a0278f89ab6a8ab", + "name": "pkgconfig", + "sha256": "01da12fc71032f30c852530473760e27c22895e190f2bd9273a1d6dae42d70d0", + "size": 13587, + "subdir": "linux-64", + "timestamp": 1640037502702, + "version": "1.5.5" + }, + "pkginfo-1.4.1-py27hee1a9ad_1.conda": { + "build": "py27hee1a9ad_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33fda2147f9c5f771821cb560869d5c3", + "name": "pkginfo", + "sha256": "2eb14681274d34ad3bdf5151bf28f9e8f228f4d80ee5f68101628266db1953ca", + "size": 39866, + "subdir": "linux-64", + "timestamp": 1505742271904, + "version": "1.4.1" + }, + "pkginfo-1.4.1-py35hb526c55_1.conda": { + "build": "py35hb526c55_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "65dbd8831db68751dd1b85917ea832f0", + "name": "pkginfo", + "sha256": "f37afefa4813e7e8e7e9b632ab3c5c8ad79a1ba7c97c1b75213bce721d6b8c51", + "size": 41395, + "subdir": "linux-64", + "timestamp": 1505742285395, + "version": "1.4.1" + }, + "pkginfo-1.4.1-py36h215d178_1.conda": { + "build": "py36h215d178_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c3e71b973077b8f8c652eb87e787fa8", + "name": "pkginfo", + "sha256": "96871324a47f4e289000508e36c18c5226f1fe7dd8a62825c0282900265bea9f", + "size": 40807, + "subdir": "linux-64", + "timestamp": 1505742299170, + "version": "1.4.1" + }, + "pkginfo-1.4.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0aa802edf0fe3738f98c3c5bb6da2ea", + "name": "pkginfo", + "sha256": "71cc3e1bd5e0c44af2114bf90e4ad2aa43383ef50a27b82bf0f227f61e461a76", + "size": 40232, + "subdir": "linux-64", + "timestamp": 1522082489840, + "version": "1.4.2" + }, + "pkginfo-1.4.2-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c1164a9e4c228a0b7d17839c2b5e8c7", + "name": "pkginfo", + "sha256": "40d413c6c1702a7b11938fd65b813a5887efb8a9477292920be77fce5755937c", + "size": 41812, + "subdir": "linux-64", + "timestamp": 1522082490769, + "version": "1.4.2" + }, + "pkginfo-1.4.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5476ea1216e55c6dccdd9eb608b70863", + "name": "pkginfo", + "sha256": "689651d0fbdded1240fa7f52c64b456800340b3449fe2be35c54d4e73611c844", + "size": 41421, + "subdir": "linux-64", + "timestamp": 1522082490754, + "version": "1.4.2" + }, + "pkginfo-1.4.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "163c6a5ceda88bdca67928b644ce369b", + "name": "pkginfo", + "sha256": "857ca6ba32f3e4040cf700ceb7b3b9ce45741d95e1a7d9b6d5468ce6621c6b5e", + "size": 41054, + "subdir": "linux-64", + "timestamp": 1530813565309, + "version": "1.4.2" + }, + "pkginfo-1.5.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4af69549d314e8e987032a87334b2b9b", + "name": "pkginfo", + "sha256": "5b1ab21c2741f6c7600e94b839c3762280af1048e9c5e026feb3ef4cda832707", + "size": 44094, + "subdir": "linux-64", + "timestamp": 1547907454507, + "version": "1.5.0.1" + }, + "pkginfo-1.5.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "754be7823afb2fe3f32bd98cb0024076", + "name": "pkginfo", + "sha256": "001dea51be299d55a61902f08c88c0a6b44538291d6789c299be17dd8e3a446e", + "size": 45349, + "subdir": "linux-64", + "timestamp": 1547907473434, + "version": "1.5.0.1" + }, + "pkginfo-1.5.0.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9fe8e313427dd51b703d5c161107b2b6", + "name": "pkginfo", + "sha256": "12c7a8a1e030d1fe8babbcd2bdd0be97cd757085d9a8880e9e03cbcfe99953a0", + "size": 45336, + "subdir": "linux-64", + "timestamp": 1605300309430, + "version": "1.5.0.1" + }, + "pkginfo-1.5.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b28cba507c2def491959282b1b19e2de", + "name": "pkginfo", + "sha256": "de0af37aaa6f16f1f10a8f9d7f9b183b9043320c8071ec7fe7667cf3be4486e3", + "size": 45343, + "subdir": "linux-64", + "timestamp": 1547907471808, + "version": "1.5.0.1" + }, + "pkginfo-1.5.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "89e8eba0b231cf780c8f250a5397d2e8", + "name": "pkginfo", + "sha256": "c36b96dfb89b4763b33c43693ec61433aea350f3a4e988fbd31942b2db88244a", + "size": 44926, + "subdir": "linux-64", + "timestamp": 1605300329910, + "version": "1.5.0.1" + }, + "pkginfo-1.5.0.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e834506e96efb22ccafe64aa614cb85", + "name": "pkginfo", + "sha256": "e5e874f5d36f5dd921d651436442ebaef402f7517bb9d441e72857da88189b02", + "size": 44069, + "subdir": "linux-64", + "timestamp": 1573040570315, + "version": "1.5.0.1" + }, + "pkginfo-1.5.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c218f6665fde012ec62f727ff9c1a2da", + "name": "pkginfo", + "sha256": "705b7cb61cab3cf74569099f0e4dadc9f00a3dff63c82c1727141736c98f202d", + "size": 45759, + "subdir": "linux-64", + "timestamp": 1605300342094, + "version": "1.5.0.1" + }, + "pkginfo-1.5.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aba05a92797f25e88a63e5eb45be912a", + "name": "pkginfo", + "sha256": "18916f44d813a72bad50c2385c3bcdf1de44991f1fe8ec1b1273b8c2bebaad96", + "size": 45851, + "subdir": "linux-64", + "timestamp": 1605300324374, + "version": "1.5.0.1" + }, + "pkginfo-1.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1939af06112b7fe79473826e0132cb18", + "name": "pkginfo", + "sha256": "dbb60281feb37a606f2155015f40565e5826013b2d976fda2545e63051ad3aba", + "size": 43691, + "subdir": "linux-64", + "timestamp": 1603217627866, + "version": "1.6.0" + }, + "pkginfo-1.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "609726087435008f0e1e8dc70a1c9511", + "name": "pkginfo", + "sha256": "f06e1caf34719736c8ea368e4c7a8d801b05bc2d6cbdeadb1adfaa2e93f63b8e", + "size": 43266, + "subdir": "linux-64", + "timestamp": 1603217581672, + "version": "1.6.0" + }, + "pkginfo-1.6.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11b7a428fa0f2b5cab1b7c970597bc48", + "name": "pkginfo", + "sha256": "1889a6d550ca78656355f7253b6581045df36b2880e2ef6525927d333e04bbf3", + "size": 44000, + "subdir": "linux-64", + "timestamp": 1603217605775, + "version": "1.6.0" + }, + "pkginfo-1.6.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "447f31d37c70d186904745bd81242652", + "name": "pkginfo", + "sha256": "ff850bb0503535b64ceec1f87fddb19528cf855573cdbbb31ded88d4147827e5", + "size": 43906, + "subdir": "linux-64", + "timestamp": 1605121962492, + "version": "1.6.1" + }, + "pkginfo-1.6.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5409a634de0d53ad1205402c2409c68", + "name": "pkginfo", + "sha256": "c31a6b08d86d233fafa2820db269255539d87b5e85571076d058132bb0af0e34", + "size": 43377, + "subdir": "linux-64", + "timestamp": 1605121726724, + "version": "1.6.1" + }, + "pkginfo-1.6.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cf8e2879d193b7895d4c53e6ccc496c8", + "name": "pkginfo", + "sha256": "e0fcd94848e1faf0ee0238ba8fabc5b3c85e0bdd677443c8dcff2e516e67ce4d", + "size": 44245, + "subdir": "linux-64", + "timestamp": 1605121743728, + "version": "1.6.1" + }, + "pkginfo-1.6.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83aa36cf331ebdef295a636ee8721ec7", + "name": "pkginfo", + "sha256": "d1f967f46da4aa6e3b86542637fae6a76bccd93f8c2d2ce066071aaf1bf32270", + "size": 44374, + "subdir": "linux-64", + "timestamp": 1605121739116, + "version": "1.6.1" + }, + "pkginfo-1.7.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "904ac27fc8b2e53ecfec118fd9404994", + "name": "pkginfo", + "sha256": "9336ccb3f99c68ba1b9a87444b0e1a29803429adda57dd83d0462f44d7f1c251", + "size": 43941, + "subdir": "linux-64", + "timestamp": 1610825011306, + "version": "1.7.0" + }, + "pkginfo-1.7.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47c6c37b0a78aae9849b3eeba6172f71", + "name": "pkginfo", + "sha256": "ee363032d4a1285dea500d2fdb4ec2a2d038c78150d8a161f9043fb646704b96", + "size": 43866, + "subdir": "linux-64", + "timestamp": 1610825025755, + "version": "1.7.0" + }, + "pkginfo-1.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5820b1ebd449cafc4bc181d7f75689cc", + "name": "pkginfo", + "sha256": "0a93c2c7e1a5b4dee2574b8fa676a81f8e3896e02fda2f68270fb524a766c3b8", + "size": 44121, + "subdir": "linux-64", + "timestamp": 1610824368841, + "version": "1.7.0" + }, + "pkginfo-1.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d46b4847a051a93fba9096fe844c14dd", + "name": "pkginfo", + "sha256": "751d8a4086ce4e1181e325a9d5d2f8d7a627e410dfb1e06ad6efc2ed1d193550", + "size": 44356, + "subdir": "linux-64", + "timestamp": 1610825012244, + "version": "1.7.0" + }, + "pkginfo-1.7.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "946fcde2d57be0fa6bcde523ae4f7998", + "name": "pkginfo", + "sha256": "29cac7c1c43acfde8549c55b9ba95d2f06f5a7e735dc5b8a69fd5c816565dce2", + "size": 44373, + "subdir": "linux-64", + "timestamp": 1640792393578, + "version": "1.7.1" + }, + "pkginfo-1.7.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "250f114a29b9e70481bc4706bfb460b5", + "name": "pkginfo", + "sha256": "3e7fe48e03be562c2e3cbe303a449e07c48353fc03570bc4ff428ece4d1939ea", + "size": 43480, + "subdir": "linux-64", + "timestamp": 1626087089553, + "version": "1.7.1" + }, + "pkginfo-1.7.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d140bd6538655d3f3218e80ed8bb3561", + "name": "pkginfo", + "sha256": "c847140b4318facc12e4dff636f44b8c703b77ac287977f88e66f26313d41cac", + "size": 43044, + "subdir": "linux-64", + "timestamp": 1626087188353, + "version": "1.7.1" + }, + "pkginfo-1.7.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e038c4d550cf630fc51f0eba4d219ee4", + "name": "pkginfo", + "sha256": "9485c4e2a398b461148954a372e62bf6de7f9547fb543e18f3d4635dcd5f706b", + "size": 43761, + "subdir": "linux-64", + "timestamp": 1626087187000, + "version": "1.7.1" + }, + "pkginfo-1.7.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "439efeb67a917d63d089d0a9f8803ca3", + "name": "pkginfo", + "sha256": "81ecf91eabc9ccf57163f8eac21f289dcb22570036ff8156545221114dcb62b9", + "size": 43681, + "subdir": "linux-64", + "timestamp": 1626087203997, + "version": "1.7.1" + }, + "pkginfo-1.8.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "379124f04a7668a2aba455607a1dc648", + "name": "pkginfo", + "sha256": "c07374ef8b5635154d251339c856ee67cb7f455ef20233c7c54656f7f7a62efd", + "size": 47154, + "subdir": "linux-64", + "timestamp": 1666725148021, + "version": "1.8.3" + }, + "pkginfo-1.8.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b3c5d0c34cf09d15925e3a72a98d1a4", + "name": "pkginfo", + "sha256": "56c2e6ccfb0038bcafa076cf25d22bd8d4c7b5bdece110d4a9cce37a60705d8a", + "size": 60783, + "subdir": "linux-64", + "timestamp": 1676823189855, + "version": "1.8.3" + }, + "pkginfo-1.8.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e483ff06a583f867c10c0ae482888ab0", + "name": "pkginfo", + "sha256": "c0ddb6c78ff8c67699aebc35ca3dbb8be4b8059094774f64181e9affa968a841", + "size": 46105, + "subdir": "linux-64", + "timestamp": 1666725121594, + "version": "1.8.3" + }, + "pkginfo-1.8.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7134ca736b0509344681acc92c6f7745", + "name": "pkginfo", + "sha256": "23028d3224e72094cf23c367079974fe5843000e76dc712911a59c750006c81b", + "size": 46553, + "subdir": "linux-64", + "timestamp": 1666725096028, + "version": "1.8.3" + }, + "pkginfo-1.8.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95cccdc4e701f366ec70d44ac9d1251b", + "name": "pkginfo", + "sha256": "406b1832cff6906fe38d27f3966fa4f6b471433b9a356af3a32776fc6a79634b", + "size": 46584, + "subdir": "linux-64", + "timestamp": 1666725070643, + "version": "1.8.3" + }, + "pkginfo-1.9.6-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbfdb06321633a65799fa8fb599dac10", + "name": "pkginfo", + "sha256": "fc61a92510ac913d91b4156af3e1fe891642e4858d2a947ce46b0215a2e56dbc", + "size": 52574, + "subdir": "linux-64", + "timestamp": 1679431242816, + "version": "1.9.6" + }, + "pkginfo-1.9.6-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52761274e7046375767d1fa8bf466e78", + "name": "pkginfo", + "sha256": "32c536604523e7c9f69a061e73b511983320b25b892e17bf651d778d4709d616", + "size": 66302, + "subdir": "linux-64", + "timestamp": 1679431191344, + "version": "1.9.6" + }, + "pkginfo-1.9.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6987591273502c91389795a7040eb0ed", + "name": "pkginfo", + "sha256": "19b43036a19426c47574d1ea842c0cef74fc6af52450a24b480c16ea0c6007b8", + "size": 51491, + "subdir": "linux-64", + "timestamp": 1679431216864, + "version": "1.9.6" + }, + "pkginfo-1.9.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "307c728b9bfa4ed1ff27b57d32463c22", + "name": "pkginfo", + "sha256": "5fa3ca7136b32d990c5d1ea67b8ae6c5a754dc514064267be722fffbd3c1c02c", + "size": 51582, + "subdir": "linux-64", + "timestamp": 1679431267143, + "version": "1.9.6" + }, + "pkgutil-resolve-name-1.3.10-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT AND PSF-2.0", + "license_family": "PSF", + "md5": "6286b7b80dcf0ef02f03241123e31de3", + "name": "pkgutil-resolve-name", + "sha256": "fb28fc0ff883ce376ff971fe94502aacde56743d2d35ed78e75b6e9de69c26e0", + "size": 9474, + "subdir": "linux-64", + "timestamp": 1661463378870, + "version": "1.3.10" + }, + "pkgutil-resolve-name-1.3.10-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT AND PSF-2.0", + "license_family": "PSF", + "md5": "98d1ad83f433d2aa29a0e510d823b81e", + "name": "pkgutil-resolve-name", + "sha256": "01fc01095c932f293edbd71cb9186774788e9d60c0cef66c8bf863b876dcc467", + "size": 9471, + "subdir": "linux-64", + "timestamp": 1661463353650, + "version": "1.3.10" + }, + "plac-0.9.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "66b2524b3eaabf3b57070e72b6e721e7", + "name": "plac", + "sha256": "0252f92ee9235176f9fa3780b4e3da8fa1dd5fc209a1fc0856073ec718762e3b", + "size": 39077, + "subdir": "linux-64", + "timestamp": 1530961286861, + "version": "0.9.6" + }, + "plac-0.9.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "29ec791e1c76a2d8aa2a0c6eacdfa017", + "name": "plac", + "sha256": "2274ccffd20b72ffa5c7441a49430471573085f98127954fb921ab34725d2636", + "size": 39474, + "subdir": "linux-64", + "timestamp": 1535606045360, + "version": "0.9.6" + }, + "plac-0.9.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "51a0b6a1c03994f68cd8a709366fdd89", + "name": "plac", + "sha256": "5da8e3e20c8c8b015b231234af006421fea827df8e18bee70d3c0f8f825e3a2d", + "size": 39400, + "subdir": "linux-64", + "timestamp": 1530961316923, + "version": "0.9.6" + }, + "plac-0.9.6-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "bb5cf8ee68c4615e330cad87eb65f59e", + "name": "plac", + "sha256": "d414fc86f834856ab0a1b1016c28c762e543c66aa1bdb5dc7d57bb957583920d", + "size": 40839, + "subdir": "linux-64", + "timestamp": 1594261930547, + "version": "0.9.6" + }, + "plac-0.9.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a1f35c699ceea54835749ca43f33fff1", + "name": "plac", + "sha256": "8e21d960ab87f4eb9f64c54ca5554f691a2a9a807b7f7e5cf65a92f41497b628", + "size": 39048, + "subdir": "linux-64", + "timestamp": 1530961347417, + "version": "0.9.6" + }, + "plac-0.9.6-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "12a03c4fff0153ea7ef6487b6240d636", + "name": "plac", + "sha256": "051c88ac13f3cbf3684df524b5cd418c2255b5b863a347c69d84a29361d51638", + "size": 40850, + "subdir": "linux-64", + "timestamp": 1594261938051, + "version": "0.9.6" + }, + "plac-0.9.6-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "2de82b68f6afcf3d4b4cc1ff5be95503", + "name": "plac", + "sha256": "a40a6a058758388afafc392df36a8e649b6a56457e8e56c815d3e5284d1d37f9", + "size": 41012, + "subdir": "linux-64", + "timestamp": 1594261929297, + "version": "0.9.6" + }, + "plac-1.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9617d0f62867609cceeab51c84db40fc", + "name": "plac", + "sha256": "73fbc6aaf1e8cef8ab321114593cbc809973116b44780365187d4bac29f98e79", + "size": 38979, + "subdir": "linux-64", + "timestamp": 1534617727354, + "version": "1.0.0" + }, + "plac-1.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7db459519c29a37b1e0ec8f35396f071", + "name": "plac", + "sha256": "a6ed7abda47bf7758acbfe3b34f55cfad9a6528b004fa8fc68e50118f3dffd59", + "size": 39774, + "subdir": "linux-64", + "timestamp": 1534617700791, + "version": "1.0.0" + }, + "plac-1.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ad270403dd5ae7bd2b116b6e2abd6345", + "name": "plac", + "sha256": "719c9d16e4571efe9e6e3a5d1019bed3bad03f194d8cd7b956699a90395720e0", + "size": 39839, + "subdir": "linux-64", + "timestamp": 1534617713692, + "version": "1.0.0" + }, + "plac-1.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "105186ba3e3709f10f42beb80fb8cced", + "name": "plac", + "sha256": "4e98f24e041d819667ddce4fb9100a9ee39e5aac78066a9a06ebc5643015d4cf", + "size": 39843, + "subdir": "linux-64", + "timestamp": 1534617777702, + "version": "1.0.0" + }, + "plac-1.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7563653c15976669495576cec8347ddb", + "name": "plac", + "sha256": "093e2210322d8ed955787e558ee8bb168895f55300a05f8e8fd2efc187fa2bee", + "size": 41436, + "subdir": "linux-64", + "timestamp": 1569351450133, + "version": "1.1.0" + }, + "plac-1.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "de11c5de218e01f90aa59e0d358123b4", + "name": "plac", + "sha256": "e3d19e2c6e09a3d045815b670b1ab8281d857414afc7593ad9838fb73951d176", + "size": 41926, + "subdir": "linux-64", + "timestamp": 1569351447912, + "version": "1.1.0" + }, + "plac-1.1.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "dacd0634b1d0b93e9afed47decea8fc7", + "name": "plac", + "sha256": "5bfa69a71146ad7d363d7c1d7d061cac54e0294aad44150fdca9c12901bdfcad", + "size": 41663, + "subdir": "linux-64", + "timestamp": 1594260037860, + "version": "1.1.0" + }, + "plac-1.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b13788fdaeed6c96cdae7d1a11b31fd7", + "name": "plac", + "sha256": "1956420f0cd34733b92644ddd72e120192c29df5a652f1c9e4daf29617be9b50", + "size": 41872, + "subdir": "linux-64", + "timestamp": 1569351512919, + "version": "1.1.0" + }, + "plac-1.1.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "0bd31a1c465feba2e5e491bddf0aab9b", + "name": "plac", + "sha256": "0594c51b765ec94119ef36bdc78cbbadc8ae9a4a2ea8895944cb2fde2c44365c", + "size": 41699, + "subdir": "linux-64", + "timestamp": 1594259996483, + "version": "1.1.0" + }, + "plac-1.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5c6cbe271da7890795936b9307c152eb", + "name": "plac", + "sha256": "e2e9d5e48b0346db9990292d92c1532d17f54bf4eeff1f839981132b6a00f3fb", + "size": 41295, + "subdir": "linux-64", + "timestamp": 1573040633995, + "version": "1.1.0" + }, + "plac-1.1.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c40796e101cade46b0a27394d66853e7", + "name": "plac", + "sha256": "629adb0dda586c104992f67e85d6bf130457707cde0f4aa5587257147eab7017", + "size": 42438, + "subdir": "linux-64", + "timestamp": 1594259996417, + "version": "1.1.0" + }, + "plac-1.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "af2c9b7fe2fe5c43aec1a92308d0eb31", + "name": "plac", + "sha256": "93271d96271fbacf8b5c38a75cfa80449b278a56ddb2f3a39f018f30bc5499e2", + "size": 42547, + "subdir": "linux-64", + "timestamp": 1608239075931, + "version": "1.1.0" + }, + "plac-1.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "1377d705ddaceed55f5fad4191a81893", + "name": "plac", + "sha256": "a2b04039eec9ecd8816750c64b744298472ef476fc6c9ca775bbd5cf7274b86f", + "size": 43305, + "subdir": "linux-64", + "timestamp": 1594261196294, + "version": "1.2.0" + }, + "plac-1.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d371b830931d5b5c2636cfb93a1bae92", + "name": "plac", + "sha256": "d9c51b2da7250fe15e8ef27cf295e60ca113107f4028e566e3d35a5d733c29fb", + "size": 42860, + "subdir": "linux-64", + "timestamp": 1594261193524, + "version": "1.2.0" + }, + "plac-1.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "df0d53a0fdda82724e7887c14cf5ef79", + "name": "plac", + "sha256": "5a1758fbcf6b082c6fee9e1b93f4308ba34ae842860ec83648fc9ba49ad16da3", + "size": 43641, + "subdir": "linux-64", + "timestamp": 1594261193134, + "version": "1.2.0" + }, + "plac-1.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "027ab9481ad5d4b88e71c13e49e34ce1", + "name": "plac", + "sha256": "7d80b4902a8479558f2b5e3ad49a8e86dbc2a183ce0da719b6146391cb1b6dce", + "size": 43916, + "subdir": "linux-64", + "timestamp": 1608234238061, + "version": "1.2.0" + }, + "plac-1.3.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3ae79abfe10d14f60fddc8d6f7a80932", + "name": "plac", + "sha256": "c56bf77f117fd30f3a83c2959e7f80bdb6ebd3266018273f3cebd94b4c36b39f", + "size": 42445, + "subdir": "linux-64", + "timestamp": 1609094540905, + "version": "1.3.0" + }, + "plac-1.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "fcceedaa7c71b105799addb72b610b38", + "name": "plac", + "sha256": "f0bf9e2933417e7115eb395f7e9223f4a55013c609b74db16f2596e67a649da7", + "size": 42890, + "subdir": "linux-64", + "timestamp": 1609094537703, + "version": "1.3.0" + }, + "plac-1.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "836d6ead2f5f6e2d0ef81668696c5779", + "name": "plac", + "sha256": "9ff96e20fc3e374e069701c3efaa6d7dec1fbb6664bce2c388a81ecb9298b5b9", + "size": 42909, + "subdir": "linux-64", + "timestamp": 1609094531036, + "version": "1.3.0" + }, + "plac-1.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b5b5df654b52f32875dbbb8b3f5cee66", + "name": "plac", + "sha256": "183969da9d888b4adb44f219b0980ecc6ed5af8369033ace4df406bb3adb7b8a", + "size": 42556, + "subdir": "linux-64", + "timestamp": 1609094547936, + "version": "1.3.0" + }, + "plac-1.3.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "64be29b0217fcc00d60a738a539b5781", + "name": "plac", + "sha256": "a19200108ea31a2c530169375ae318258a4bd7a71e24bbc925c836329a8232e5", + "size": 43332, + "subdir": "linux-64", + "timestamp": 1610305918611, + "version": "1.3.1" + }, + "plac-1.3.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "95fce72f8c0bb5d772057519a57e8d90", + "name": "plac", + "sha256": "c9e6ecf9fed5c89d4504261f0f291314a9425d1e4274f2c40b8c95ea21387357", + "size": 44621, + "subdir": "linux-64", + "timestamp": 1610482751205, + "version": "1.3.1" + }, + "plac-1.3.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "dcf5e22666f6d9e73bd0d34587f066a4", + "name": "plac", + "sha256": "92f06bba66df7e192906af12816eb07fd43b857bac95e0a9d259721b98556b16", + "size": 43416, + "subdir": "linux-64", + "timestamp": 1610305919988, + "version": "1.3.1" + }, + "plac-1.3.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "6ab433facef532d7aa2604ef2ca4d121", + "name": "plac", + "sha256": "6e350d147beff97c10846adf24ce83cbab69cc2ab9260f1eaacc2258a6cab68f", + "size": 45056, + "subdir": "linux-64", + "timestamp": 1610482748749, + "version": "1.3.1" + }, + "plac-1.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "bde6fd81ec1232352585b3d2dfcea88a", + "name": "plac", + "sha256": "b0a1fd6fb2ae2c6b4a5d4423a836e3421e49b7bf97d7b1474925cea1deeb5786", + "size": 43527, + "subdir": "linux-64", + "timestamp": 1610305936647, + "version": "1.3.1" + }, + "plac-1.3.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "0233f18ad068a5f286ea11fae140c5ae", + "name": "plac", + "sha256": "ea97b588d8273d34a711190a95f32067dcd47a898ebb8103c0e4488018563521", + "size": 44698, + "subdir": "linux-64", + "timestamp": 1610482741508, + "version": "1.3.1" + }, + "plac-1.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "1c924746e8b0f89d5e8c2e55d9e63726", + "name": "plac", + "sha256": "834bf15c6b15c86ea3427b9f75b239085cb18f3eaaa3029edc3044c1bcb2d11b", + "size": 43664, + "subdir": "linux-64", + "timestamp": 1610305906701, + "version": "1.3.1" + }, + "plac-1.3.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "2ab29897d87a8b4ab094ac21876c2632", + "name": "plac", + "sha256": "ef58b5725f7e1c1ccbe1c7da97f28b819155e3c7407c0853f8a7926bebdec98c", + "size": 45269, + "subdir": "linux-64", + "timestamp": 1610482284886, + "version": "1.3.1" + }, + "plac-1.3.2-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "618df6e4e693389bfdc654b0f2dc7d7f", + "name": "plac", + "sha256": "6f37ae877614a84a9623031d0ea52f5918c9c6a96cf74970776869dac4263245", + "size": 44441, + "subdir": "linux-64", + "timestamp": 1642499657111, + "version": "1.3.2" + }, + "plac-1.3.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "6e87c4af186cf25bdbe5ba8ce81ff04a", + "name": "plac", + "sha256": "b42fd77d62154cedb7973d3cccf0869b08c476518a6a4a433fb3268977c6d6af", + "size": 43498, + "subdir": "linux-64", + "timestamp": 1613763288531, + "version": "1.3.2" + }, + "plac-1.3.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "5031ed8ed864056c3318af1626c54552", + "name": "plac", + "sha256": "dab1f23f294f0d8630941f2bd21d03307864b348fec8aa983fd407e2f3937a24", + "size": 43676, + "subdir": "linux-64", + "timestamp": 1613763963548, + "version": "1.3.2" + }, + "plac-1.3.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "bd522966ad95491ea531d0da9d7d62f1", + "name": "plac", + "sha256": "b9e20130ebe9381f3d9cf773adacf902a53929ac2f08a974756d633d8fae9e6e", + "size": 44216, + "subdir": "linux-64", + "timestamp": 1613763973206, + "version": "1.3.2" + }, + "plac-1.3.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c14110554a43f346e4f7ecb3265ddb8d", + "name": "plac", + "sha256": "7510ea7bbbdb0424135b0d4378d06abbeaf978cd9d49cbdaae6b510f298071e3", + "size": 43862, + "subdir": "linux-64", + "timestamp": 1613763975623, + "version": "1.3.2" + }, + "plac-1.3.3-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "190e782ea3eaf7ae5f1ec6e653b8705a", + "name": "plac", + "sha256": "3fc0d2aa87a96718597c8591ff117c86fdcc0e1878469e8efcbf03a1f8576742", + "size": 43548, + "subdir": "linux-64", + "timestamp": 1616529588892, + "version": "1.3.3" + }, + "plac-1.3.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "20735298cff020d0ccc9beb2dd542951", + "name": "plac", + "sha256": "2413ab3137bd96511ac244c9a6ce20658e58cfce3570e87e359548a181af0c51", + "size": 43591, + "subdir": "linux-64", + "timestamp": 1616527547348, + "version": "1.3.3" + }, + "plac-1.3.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a3cd9368cb6c5205fdea1693bafe9010", + "name": "plac", + "sha256": "4ec660f0e7563ee81565d723ac51d53c412af34ea83a52938886d9ba155d4ff0", + "size": 43895, + "subdir": "linux-64", + "timestamp": 1616529705369, + "version": "1.3.3" + }, + "plac-1.3.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e06695d9eebda728c4420d1d44213b07", + "name": "plac", + "sha256": "0bdd59d6fafe7f8ed2df41ee395f2b062c9c8790d6a0a3adddb4f90c6c6067ec", + "size": 43722, + "subdir": "linux-64", + "timestamp": 1616529697700, + "version": "1.3.3" + }, + "plaster-1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df80eea72effd512aeacbc4f7e6976fc", + "name": "plaster", + "sha256": "8d516d6e5284367df6886b796bbc537e3af8ee86d2704a3e12772e097d0172a7", + "size": 17290, + "subdir": "linux-64", + "timestamp": 1530025602486, + "version": "1.0" + }, + "plaster-1.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee35fe6bf7e548e862789ac8a4cd28d8", + "name": "plaster", + "sha256": "0776bd356385ffd0fafc4239e57feaac9e76ef6008709910d1394db46dd6860c", + "size": 17000, + "subdir": "linux-64", + "timestamp": 1530029413270, + "version": "1.0" + }, + "plaster-1.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3ad8cc340d5415de2f232171bcca020", + "name": "plaster", + "sha256": "64d1f1d77da34bad949467e72dd1cbad25200c46c071406d6f2d37ae5af5067d", + "size": 17652, + "subdir": "linux-64", + "timestamp": 1640792411549, + "version": "1.0" + }, + "plaster-1.0-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "301e7e131df08d2cf81a63cc5f283b81", + "name": "plaster", + "sha256": "88d651df0452710a22ea84011a2e26451edc1f477b4b6695082dc8f25ef6bdc2", + "size": 20670, + "subdir": "linux-64", + "timestamp": 1676903973648, + "version": "1.0" + }, + "plaster-1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92a6b4f5701149bb354438e4ec6cc99f", + "name": "plaster", + "sha256": "38d95ccfdf7dfe3395a5635624a58a5e9831da089fec7e025f39537dee1b8bf2", + "size": 17799, + "subdir": "linux-64", + "timestamp": 1530025663010, + "version": "1.0" + }, + "plaster-1.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c7b659e3bb80d5fd67bda532468bf368", + "name": "plaster", + "sha256": "f96bc6c73c5486aa26b82d9994e990ca4325872118b2aea6627bbd88fcbec138", + "size": 17416, + "subdir": "linux-64", + "timestamp": 1530029422783, + "version": "1.0" + }, + "plaster-1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1be4d6d240a5986ccca6922ce6a2106a", + "name": "plaster", + "sha256": "1997118d5353e9473ac6fb97e83a13b6c17a8b1823380adf8ac27efdf64602ad", + "size": 17697, + "subdir": "linux-64", + "timestamp": 1530025482145, + "version": "1.0" + }, + "plaster-1.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "10f66ed9067ee62ab12e86f1420d9feb", + "name": "plaster", + "sha256": "3f2245664cc5ac0fcd84601a606310d8219b9e3cf1c36f08c62108a414c8f6a0", + "size": 17248, + "subdir": "linux-64", + "timestamp": 1530029363625, + "version": "1.0" + }, + "plaster-1.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48558a6bbe82d42e9d0ace4076993d70", + "name": "plaster", + "sha256": "08b48441d8ad2e7f905289175b0c2d4d845ec33f00c723fd36923cbc5dca31ba", + "size": 259008, + "subdir": "linux-64", + "timestamp": 1613559648912, + "version": "1.0" + }, + "plaster-1.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e86ed3f1f3db6a3cb6e8747e8489a17f", + "name": "plaster", + "sha256": "183ee9fe09692d861ddb77253b023ab8854069a098c00188ad54fc626758a904", + "size": 17234, + "subdir": "linux-64", + "timestamp": 1530875228065, + "version": "1.0" + }, + "plaster-1.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f988c2763ddc7cadc3db29a4dca22072", + "name": "plaster", + "sha256": "594a0b125cc0a7c8da5dc4abefe5a01f6259b920131b9f6a710441d12813e05d", + "size": 258758, + "subdir": "linux-64", + "timestamp": 1613560715473, + "version": "1.0" + }, + "plaster-1.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e0783b5afa763c5fa0733d2ee8c30f0", + "name": "plaster", + "sha256": "d11dde83ac35f4a30ff99e4b3813b777bb0b4c95b97a179dd178f68f839b151e", + "size": 17809, + "subdir": "linux-64", + "timestamp": 1574273614453, + "version": "1.0" + }, + "plaster-1.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e804b3442d027f5aed8789507666660a", + "name": "plaster", + "sha256": "4b2bbec8d62d60d37af72723fff0d6f0bc6017adfc5423941fbb7a98a3437ee1", + "size": 257293, + "subdir": "linux-64", + "timestamp": 1613560597146, + "version": "1.0" + }, + "plaster-1.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43e8bcb3ae8598610fa7333ea497464a", + "name": "plaster", + "sha256": "31e1ad95f6d4957dde72dbc49f9fbfcbbec887339b9fa3459da1086374f81a0f", + "size": 257751, + "subdir": "linux-64", + "timestamp": 1613560324599, + "version": "1.0" + }, + "plaster_pastedeploy-0.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb9b146c02298d05e78ec6f740b317ba", + "name": "plaster_pastedeploy", + "sha256": "0a77f78977f1015e6e98b75e063abbcd4f12f3af575c4a35fc3c56168b8823f0", + "size": 12360, + "subdir": "linux-64", + "timestamp": 1530027728433, + "version": "0.5" + }, + "plaster_pastedeploy-0.5-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e6e94d5eb5e79842c045de04c7d2f59", + "name": "plaster_pastedeploy", + "sha256": "227f767803571897270886b491eaa26a55b6e87f7c3c20026256e95cebe0a24a", + "size": 11910, + "subdir": "linux-64", + "timestamp": 1530031909194, + "version": "0.5" + }, + "plaster_pastedeploy-0.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "26004f71f1030491daf0d0a3b35e8ab0", + "name": "plaster_pastedeploy", + "sha256": "63560e16d810a4daeda38e89bb508995122d57114547ab11fdb6ac96e89cc935", + "size": 12539, + "subdir": "linux-64", + "timestamp": 1530027157828, + "version": "0.5" + }, + "plaster_pastedeploy-0.5-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8eb981a333cd890a6dbc8311be73b9d", + "name": "plaster_pastedeploy", + "sha256": "fe601b5fdeb27712b4f35f03dbebd1d50291622a0054f7c54ee3a9e76f72dd7e", + "size": 12047, + "subdir": "linux-64", + "timestamp": 1530031951619, + "version": "0.5" + }, + "plaster_pastedeploy-0.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b192f7785a267840949ae0c4a067be90", + "name": "plaster_pastedeploy", + "sha256": "f6e0ced7493e23ded7e6492ed8915a56f60e1585dda50734eb19285b2f3b764a", + "size": 11890, + "subdir": "linux-64", + "timestamp": 1530027761994, + "version": "0.5" + }, + "plaster_pastedeploy-0.5-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4213c626fa4fea7be0ecfaec8dbacac6", + "name": "plaster_pastedeploy", + "sha256": "d01833cd24bd7033aef2054b341c40e9927d2ef72688a73402b65d8ca14e8f43", + "size": 11977, + "subdir": "linux-64", + "timestamp": 1530031903762, + "version": "0.5" + }, + "plaster_pastedeploy-0.5-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba4adfb21e33c8b740bf7df30f945b72", + "name": "plaster_pastedeploy", + "sha256": "02c37b08faca8c933408e0a5a3df54b0384b86fc5943ef5a6bfd5df55be8d16b", + "size": 11951, + "subdir": "linux-64", + "timestamp": 1530875254810, + "version": "0.5" + }, + "plaster_pastedeploy-0.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96efd295a0c4a2f8acc7c4d1eff46c52", + "name": "plaster_pastedeploy", + "sha256": "e2bd091df83d0b2ad29af5f591666835ff24960b2b2f1c9a14f5b14b2c60fab9", + "size": 12095, + "subdir": "linux-64", + "timestamp": 1535513610816, + "version": "0.6" + }, + "plaster_pastedeploy-0.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f3fe5aafe83cd5c6c4f20e2bef1e1c7", + "name": "plaster_pastedeploy", + "sha256": "2fbfdfb971173fb1d4eaa1c923c2a98ca6f56fe9fc3e79ca45e729f13598de16", + "size": 12179, + "subdir": "linux-64", + "timestamp": 1535513635052, + "version": "0.6" + }, + "plaster_pastedeploy-0.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17fab75fe709c0317e4384eea5b61e53", + "name": "plaster_pastedeploy", + "sha256": "4bfa8012cd85151a22fc3742cf3013ab974e045bafa617ef31e60243271f220c", + "size": 12060, + "subdir": "linux-64", + "timestamp": 1535513590544, + "version": "0.6" + }, + "plaster_pastedeploy-0.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3d93ae07d7998bfd0ffaecedf667020", + "name": "plaster_pastedeploy", + "sha256": "4cefc43dceecfa64936c473b43c0bde851a4f742b04537f30d893aef70cb45af", + "size": 12162, + "subdir": "linux-64", + "timestamp": 1535513625682, + "version": "0.6" + }, + "plaster_pastedeploy-0.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3035d41d7256533054fb54ce63f578fe", + "name": "plaster_pastedeploy", + "sha256": "2790b11257e325f735bb55036a430176765593dd456fb93031e83f55e124579e", + "size": 174677, + "subdir": "linux-64", + "timestamp": 1564702865473, + "version": "0.7" + }, + "plaster_pastedeploy-0.7-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8256ca33944cf962a77f6d1657ebf6d", + "name": "plaster_pastedeploy", + "sha256": "4e4d268d7c03feb7ad481c9157f72ac2ea928f9c7f21e79c5f475625273b1bb8", + "size": 12325, + "subdir": "linux-64", + "timestamp": 1640809938698, + "version": "0.7" + }, + "plaster_pastedeploy-0.7-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ecea835252799e7859e5b567b0962266", + "name": "plaster_pastedeploy", + "sha256": "30a5aba8cba67494543dda00fe02b1d6d77bce2ad1a4054a2329b28739ef580d", + "size": 14199, + "subdir": "linux-64", + "timestamp": 1676904124628, + "version": "0.7" + }, + "plaster_pastedeploy-0.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9665eec48fe252d190c409fb53a0035e", + "name": "plaster_pastedeploy", + "sha256": "70fd3a3a7a7b2d8386d123059ddf279ee0451a733903176a83820bd4fbdec20d", + "size": 174390, + "subdir": "linux-64", + "timestamp": 1564703241115, + "version": "0.7" + }, + "plaster_pastedeploy-0.7-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee0ee2330bc8a7ced5f8ccdcb84afaed", + "name": "plaster_pastedeploy", + "sha256": "2a002e273cec03e7c7d8f8b7b2c472b1d1d7ac6480079940363d27bf795d4afa", + "size": 252176, + "subdir": "linux-64", + "timestamp": 1613564906289, + "version": "0.7" + }, + "plaster_pastedeploy-0.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3461323205e4ca4411f780b5d89907e0", + "name": "plaster_pastedeploy", + "sha256": "5a35f8604c889bcbc5763c1f9f0096695e2239cbd9ae3d10a7e6e1be532dbfea", + "size": 173886, + "subdir": "linux-64", + "timestamp": 1564703214317, + "version": "0.7" + }, + "plaster_pastedeploy-0.7-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17fe57eeb6d78d0f1ab11d5ef7868c26", + "name": "plaster_pastedeploy", + "sha256": "acc1a507d80976d324d4892bea066f2dc1d4910dcefa9b7c84d5a8cc265528c0", + "size": 252349, + "subdir": "linux-64", + "timestamp": 1613564889042, + "version": "0.7" + }, + "plaster_pastedeploy-0.7-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23a0a0e4a2bf683a59bdd21c6fec4b05", + "name": "plaster_pastedeploy", + "sha256": "3789c975255079dcbd4cba607fe3aabda56e4ab2c31cfb91c09b14b8dc0e2859", + "size": 12646, + "subdir": "linux-64", + "timestamp": 1574169832084, + "version": "0.7" + }, + "plaster_pastedeploy-0.7-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5902253d8dffc55feda0e08ecc8a0b8a", + "name": "plaster_pastedeploy", + "sha256": "843d5f4790790110523dcaf9011c6e0f9119c23718bfe95f59a5402719f3e6ac", + "size": 251196, + "subdir": "linux-64", + "timestamp": 1613564866046, + "version": "0.7" + }, + "plaster_pastedeploy-0.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pastedeploy >=1.5.0", + "plaster >=0.5", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "503fbf0888604c9712a027828b21a1f1", + "name": "plaster_pastedeploy", + "sha256": "cd6f02b9a743239009c01ca4765586ab72fbbfa1bf410981028a467fd5d6dd35", + "size": 251551, + "subdir": "linux-64", + "timestamp": 1613564886325, + "version": "0.7" + }, + "platformdirs-2.5.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "05febbc2c59a3cb738b705e60476d8bf", + "name": "platformdirs", + "sha256": "45c27cda159170c55b98959f80abb5db174d7ad765605fb15738687430ae9475", + "size": 23833, + "subdir": "linux-64", + "timestamp": 1662711483860, + "version": "2.5.2" + }, + "platformdirs-2.5.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c8deff5c66e75b9aedd1dbe86d45785", + "name": "platformdirs", + "sha256": "4bf159f8313d8f013e095cbb4728d7543246435700c4873119719d78554ae157", + "size": 27769, + "subdir": "linux-64", + "timestamp": 1676823068357, + "version": "2.5.2" + }, + "platformdirs-2.5.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "44002afe3b17666386879b20363fc6d6", + "name": "platformdirs", + "sha256": "67a335fa3eee41d0f2d0742c411c50ff3bbdc30ca3ac86f2a277481b32ef09f6", + "size": 23483, + "subdir": "linux-64", + "timestamp": 1662711415444, + "version": "2.5.2" + }, + "platformdirs-2.5.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ccec269c93b319564600972f676dc337", + "name": "platformdirs", + "sha256": "0027d98de646fadf52e9596510affb229fada734d8701382442dcff50656b4ee", + "size": 23506, + "subdir": "linux-64", + "timestamp": 1662711442793, + "version": "2.5.2" + }, + "platformdirs-2.5.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f90b2f33e16c086722922a2a4447f61d", + "name": "platformdirs", + "sha256": "5b07990f432907082276def4b05cdc62b0cf9e8f5ad6405f44ab0ca45116c473", + "size": 23508, + "subdir": "linux-64", + "timestamp": 1662711511953, + "version": "2.5.2" + }, + "plotly-2.0.15-py27h139127e_0.conda": { + "build": "py27h139127e_0", + "build_number": 0, + "depends": [ + "decorator", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "03363e9c6196541c8d6f458dc88b3402", + "name": "plotly", + "sha256": "dc7e47bacd3a279b11269b6cac8a7f997b0b4e343b5ff2671fb27fd8c83f26b2", + "size": 889080, + "subdir": "linux-64", + "timestamp": 1505727187734, + "version": "2.0.15" + }, + "plotly-2.0.15-py35h43bf465_0.conda": { + "build": "py35h43bf465_0", + "build_number": 0, + "depends": [ + "decorator", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "573e1a124c9575c6a110823f5b0087a0", + "name": "plotly", + "sha256": "bd724e093a3d8532999dda888824fe10f76c1cdac1b4d5422f9aae594fb5d413", + "size": 891910, + "subdir": "linux-64", + "timestamp": 1505727205158, + "version": "2.0.15" + }, + "plotly-2.0.15-py36hd032def_0.conda": { + "build": "py36hd032def_0", + "build_number": 0, + "depends": [ + "decorator", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "45a822134df73d8903b87167ba23d39c", + "name": "plotly", + "sha256": "0ca53054cd367acb9f05141354659aff200fd443330aebcc1fc70e2bfefd11e2", + "size": 888876, + "subdir": "linux-64", + "timestamp": 1505727222680, + "version": "2.0.15" + }, + "plotly-2.1.0-py27h77e25ac_0.conda": { + "build": "py27h77e25ac_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "six" + ], + "license": "MIT", + "md5": "c29ed80613ae811be84ab783e74c4e97", + "name": "plotly", + "sha256": "8e9bc85a646d1fc74945a04ef256b610e031292f95a2e254fc16eb65a046579b", + "size": 900119, + "subdir": "linux-64", + "timestamp": 1507755452718, + "version": "2.1.0" + }, + "plotly-2.1.0-py35hac5c16f_0.conda": { + "build": "py35hac5c16f_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "six" + ], + "license": "MIT", + "md5": "d892277a83de2bf5f23dfa5581fb1d34", + "name": "plotly", + "sha256": "09b6a06680fb7882335a6c64bd2eb5bcc05cbb5a46c2b3e2b275eb6a86ccb689", + "size": 906077, + "subdir": "linux-64", + "timestamp": 1507755448474, + "version": "2.1.0" + }, + "plotly-2.1.0-py36h56a57e5_0.conda": { + "build": "py36h56a57e5_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "six" + ], + "license": "MIT", + "md5": "1422b165cbc4162b831714b75f0a9c33", + "name": "plotly", + "sha256": "55f00f9bb0580d0bb5751965e2a8aa2d08a3ae373876abcd15147b951ebfc382", + "size": 901277, + "subdir": "linux-64", + "timestamp": 1507755463997, + "version": "2.1.0" + }, + "plotly-2.2.2-py27hb784091_0.conda": { + "build": "py27hb784091_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "six" + ], + "license": "MIT", + "md5": "8b8e392729033a6e389af164e0d477d2", + "name": "plotly", + "sha256": "b41f70de91e8da0e12fff3f8760630a90bc6dabe3c135c73b00a0d78ce3df35b", + "size": 924343, + "subdir": "linux-64", + "timestamp": 1511841140859, + "version": "2.2.2" + }, + "plotly-2.2.2-py35h6d67e38_0.conda": { + "build": "py35h6d67e38_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "six" + ], + "license": "MIT", + "md5": "da5036eb8ef9d8d71da014cbeeb2e624", + "name": "plotly", + "sha256": "a41e09157c4ecb13664ecf9671018f097193d8b5655798e1d174db62ada40aee", + "size": 926982, + "subdir": "linux-64", + "timestamp": 1511841173025, + "version": "2.2.2" + }, + "plotly-2.2.2-py36hd7be514_0.conda": { + "build": "py36hd7be514_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "six" + ], + "license": "MIT", + "md5": "ef7980a46426b559d92adabc9801d4f0", + "name": "plotly", + "sha256": "e4bd1746048740241b84b2c6252a74811e3713c807b159a4b7da8238c9449699", + "size": 924731, + "subdir": "linux-64", + "timestamp": 1511841175739, + "version": "2.2.2" + }, + "plotly-2.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "c7fd39a80b226832d2bd7ad6794e2eb8", + "name": "plotly", + "sha256": "24ed94dd9821d9799b3f2a765a59b02a98136426ba628f47f5dae6b4de3744ab", + "size": 956719, + "subdir": "linux-64", + "timestamp": 1519156199172, + "version": "2.4.0" + }, + "plotly-2.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "51f23a61260998328f2355cd62a0bd8a", + "name": "plotly", + "sha256": "c3adadeb3e516672e836911a06164561ad48c648c91ee4d818527af94ebb3cfb", + "size": 959464, + "subdir": "linux-64", + "timestamp": 1519156219718, + "version": "2.4.0" + }, + "plotly-2.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "f2691f667d66257a54e428f12afd6356", + "name": "plotly", + "sha256": "d374eea953e86276a802d7584d232d05c6510ed2b73e24e241bca3713edba67a", + "size": 960565, + "subdir": "linux-64", + "timestamp": 1519156185274, + "version": "2.4.0" + }, + "plotly-2.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "90808dea8333d8a0c4298ac9f76dda2a", + "name": "plotly", + "sha256": "4e67d018855dd492a01889253df455588516a08bb2fdb5ca64763d68e1149dc2", + "size": 9542496, + "subdir": "linux-64", + "timestamp": 1519752654163, + "version": "2.4.1" + }, + "plotly-2.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "4066692614a919e1faa2d987f5d93939", + "name": "plotly", + "sha256": "5648fd4fbf01e202a7742fd715764f1a9cb9ac0aeb1319a24c52888973e1306d", + "size": 9549123, + "subdir": "linux-64", + "timestamp": 1519752692176, + "version": "2.4.1" + }, + "plotly-2.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "d78449755a67495be03b86246cf1d8f9", + "name": "plotly", + "sha256": "4b73c91e80d4b4d55f45e753f356f7b809c0f77424548578fd00b912759a0fc7", + "size": 9539877, + "subdir": "linux-64", + "timestamp": 1519752644872, + "version": "2.4.1" + }, + "plotly-2.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "5644250265375e2ce1654d405281ca46", + "name": "plotly", + "sha256": "3896912b5de0de16d4d2ee488d2e8b1b871da358ada1def938408a80f2706808", + "size": 9571029, + "subdir": "linux-64", + "timestamp": 1522360535732, + "version": "2.5.1" + }, + "plotly-2.5.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "bd107750ea6422f180202b43779adab1", + "name": "plotly", + "sha256": "c24c855a3ad728c4cb6ec9b7351a6f6ddef29baced235ab358a584eea8716e48", + "size": 9574173, + "subdir": "linux-64", + "timestamp": 1522360585808, + "version": "2.5.1" + }, + "plotly-2.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "9c0d68c4682357e7a62a3619feade9f0", + "name": "plotly", + "sha256": "6a0e50f8eafa17f4aa016d14006aec7d5ab5fc8331abe96af966009a8e0cd01c", + "size": 9568358, + "subdir": "linux-64", + "timestamp": 1522360555199, + "version": "2.5.1" + }, + "plotly-2.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "fcee59c2ab0f3508280ba0244bcdbed6", + "name": "plotly", + "sha256": "63cfa577dc7b5ada44af14c193a00ec0d7461fd496c41bdea68d8d18c5eeba18", + "size": 9604870, + "subdir": "linux-64", + "timestamp": 1526915214605, + "version": "2.6.0" + }, + "plotly-2.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "ffdfdd3262691090bba59656688273a5", + "name": "plotly", + "sha256": "da9f717138ae07c599c5790abc44a837cf7fb4beb3871584b19cad9115eebafd", + "size": 9612544, + "subdir": "linux-64", + "timestamp": 1526915303473, + "version": "2.6.0" + }, + "plotly-2.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "9fbf40accf5f1066763493aac06b8e04", + "name": "plotly", + "sha256": "cb2074b6a225b25b3c9e33302ea2ebcfd46c0a74c826114527ba4b8e686f5d09", + "size": 9618493, + "subdir": "linux-64", + "timestamp": 1526915194567, + "version": "2.6.0" + }, + "plotly-2.7.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "d819a0f39d89efdacb467d7e8b4583b2", + "name": "plotly", + "sha256": "86cd451451a95fb5299415bf628bf5dc639249f56499c034691f7225838af6c1", + "size": 9620588, + "subdir": "linux-64", + "timestamp": 1527630714145, + "version": "2.7.0" + }, + "plotly-2.7.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "82c6a12ff887d6090e3c93ced5a9ae30", + "name": "plotly", + "sha256": "18804931bdb6e89b161ecf01c667129d9058aa710d8af59b4efb75334e319061", + "size": 9620447, + "subdir": "linux-64", + "timestamp": 1527630755206, + "version": "2.7.0" + }, + "plotly-2.7.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "9fd311d11a3c16d3802f0d5c0f5fe71e", + "name": "plotly", + "sha256": "1876b6055648a688c0feaa7da7c6844de33ab3b7fa83d353a9c93d398f4338db", + "size": 9614667, + "subdir": "linux-64", + "timestamp": 1527630733463, + "version": "2.7.0" + }, + "plotly-2.7.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "5ffa8530837afd2e51a454dfd793d743", + "name": "plotly", + "sha256": "72d65149e02e4350610e1b1acc4d30a50c1c230f40c2efdb7e84f6485c348378", + "size": 9618752, + "subdir": "linux-64", + "timestamp": 1530738619458, + "version": "2.7.0" + }, + "plotly-3.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "f98eb4854af684b9b48f12f45a24725b", + "name": "plotly", + "sha256": "65d8a233758174245412bdd9b2e108d0e6627110f985ea0c6004f7f013b1d601", + "size": 13098755, + "subdir": "linux-64", + "timestamp": 1532536734163, + "version": "3.1.0" + }, + "plotly-3.1.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "9225c888aa860680808cacfdb6f8287b", + "name": "plotly", + "sha256": "acaa3688726fd6563c12bdecbb5f72424d924dc56ff1408561b2a7174975cce0", + "size": 13095622, + "subdir": "linux-64", + "timestamp": 1534353846187, + "version": "3.1.0" + }, + "plotly-3.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "1f4748761afcdc88d18328cc2856ff55", + "name": "plotly", + "sha256": "1a49e5615f7dfd76564bbdf58a6f46b6ba4001c4ecc08f53939e4f356940a148", + "size": 13082682, + "subdir": "linux-64", + "timestamp": 1532537304958, + "version": "3.1.0" + }, + "plotly-3.1.0-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "db799c992e59ba670e7cf57bba63e537", + "name": "plotly", + "sha256": "ac767cf3285c982c84cf09f9545ef2a48eca2ec88a74cbc8016b4e1238d6bb25", + "size": 13080072, + "subdir": "linux-64", + "timestamp": 1534354443667, + "version": "3.1.0" + }, + "plotly-3.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "d9d2b1815a795887bc6f4832ca4bd638", + "name": "plotly", + "sha256": "4de663e5b52cd4c74bdeb6c8a55e9875d243b08e044bbead6c0ac3b2f4559623", + "size": 13074667, + "subdir": "linux-64", + "timestamp": 1532537892336, + "version": "3.1.0" + }, + "plotly-3.1.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "f6bedd57f4d819762d46a64fbb946bd5", + "name": "plotly", + "sha256": "b9a48fba1011303dba0d7501802efb46afe356abfceaf4a600686889f0fa7fa2", + "size": 12732694, + "subdir": "linux-64", + "timestamp": 1534355034872, + "version": "3.1.0" + }, + "plotly-3.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "c77b71a8389fc08f52077e4fcb1076fe", + "name": "plotly", + "sha256": "3e985e13fdb3203106d2ae07c5824c6e8642f19d8e1f09fcf6e3b06924a8b854", + "size": 12734221, + "subdir": "linux-64", + "timestamp": 1532537202334, + "version": "3.1.0" + }, + "plotly-3.1.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "9afaf39cc1fce1d14488d0fb92b54903", + "name": "plotly", + "sha256": "54d786fdfd584314db534e2208e03fd3eb9b77e1e3955d52739f0001dd8c7e60", + "size": 12732203, + "subdir": "linux-64", + "timestamp": 1534353429440, + "version": "3.1.0" + }, + "plotly-3.1.1-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "34522363cd65087482d77c465f1f64a2", + "name": "plotly", + "sha256": "009701c5cb08a3e8c300df61148b864c4849430d89a340f5a4eed8f722591b6c", + "size": 12754689, + "subdir": "linux-64", + "timestamp": 1534656888250, + "version": "3.1.1" + }, + "plotly-3.1.1-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "860c848f9c5fb5f491d568f1b6bbbcde", + "name": "plotly", + "sha256": "a067a828a4bb5b313c8d684d63f3faf31963abc26526a6eca39d4b6826fb6216", + "size": 12736337, + "subdir": "linux-64", + "timestamp": 1534657158817, + "version": "3.1.1" + }, + "plotly-3.1.1-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "afbc4a64ffcef6becf57849dc62edc45", + "name": "plotly", + "sha256": "e2743ff9c8955df4fe8a0764fbb3058800f302b85cacf43e126e0627c173827f", + "size": 13076292, + "subdir": "linux-64", + "timestamp": 1534657164405, + "version": "3.1.1" + }, + "plotly-3.1.1-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "46c4faef370d7833093ff33c0912c3bb", + "name": "plotly", + "sha256": "2015cc109b7d1fc980c4d3337e112787493b2039fd445ec5944a0103026b1b06", + "size": 12732162, + "subdir": "linux-64", + "timestamp": 1534657154294, + "version": "3.1.1" + }, + "plotly-3.2.1-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "5082001b107fa6de5d280a393ffc1692", + "name": "plotly", + "sha256": "d1f9e3be90b1efe71173093bf9f04a8ac51905c98807807bff665a419f02badb", + "size": 13137989, + "subdir": "linux-64", + "timestamp": 1537470817056, + "version": "3.2.1" + }, + "plotly-3.2.1-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.5,<3.6.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "c9b6a1b91b2dd7ac6cb58f9ca5cbad54", + "name": "plotly", + "sha256": "e896deb788c5585d28d452a839ed369dae8b7a1cd1f5499f07b1f13464a99a2b", + "size": 13113236, + "subdir": "linux-64", + "timestamp": 1537470997881, + "version": "3.2.1" + }, + "plotly-3.2.1-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "6b94b9c5b4e3d7142a28b887b94e8d67", + "name": "plotly", + "sha256": "a3402123f91debdaa1153a6957ca67bd82be8e9cd4ae7fbc238a0c7293628c4f", + "size": 12768829, + "subdir": "linux-64", + "timestamp": 1537471249779, + "version": "3.2.1" + }, + "plotly-3.2.1-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "e73fb4447b68da58d782a5311422c17e", + "name": "plotly", + "sha256": "f9c7f0d274ad98e10874b968a9d47cd05267d1f787e398c30707b1a7702c45d6", + "size": 13109795, + "subdir": "linux-64", + "timestamp": 1537471186606, + "version": "3.2.1" + }, + "plotly-3.3.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "21ad048f6599c8474a0567ef2de421d8", + "name": "plotly", + "sha256": "f0e319fc8b200c77714bac63134a15c5f90b57cd73aa313822b7f68621d2564c", + "size": 13225571, + "subdir": "linux-64", + "timestamp": 1538365694807, + "version": "3.3.0" + }, + "plotly-3.3.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "d3c5074dd1e2c2ea226a58854744de5f", + "name": "plotly", + "sha256": "fb92fb0159adc0c29a647390bb93cdb6666c6e53a15615b2de0581e707032677", + "size": 13206062, + "subdir": "linux-64", + "timestamp": 1538365854027, + "version": "3.3.0" + }, + "plotly-3.3.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "d73ce06131238a1d53e34f9338846211", + "name": "plotly", + "sha256": "ce531563bc6099db10a7f3b74a89463cff52f8eab00fd27d75fce7c8d180122e", + "size": 13205365, + "subdir": "linux-64", + "timestamp": 1538365847564, + "version": "3.3.0" + }, + "plotly-3.4.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "629400c7b3bbf09d2924dc2b6df3d870", + "name": "plotly", + "sha256": "fba0dd79733c27b7ac673d6ea1c7f33c01b3e468871f7c9c03c5790335dfc871", + "size": 12977143, + "subdir": "linux-64", + "timestamp": 1541439401400, + "version": "3.4.0" + }, + "plotly-3.4.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "b3886cd2e885b6c5dda062c3c6684a48", + "name": "plotly", + "sha256": "c80f7f7f7f403ed9d8dd6304ada6bc17257a8cfaf089bba4f74f5d7cf6b84dd0", + "size": 12956827, + "subdir": "linux-64", + "timestamp": 1541439334244, + "version": "3.4.0" + }, + "plotly-3.4.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "5c4393a3b6cf431bef24dd82b3b52639", + "name": "plotly", + "sha256": "798999c60f9ffde970170bc5206c52c9410ba684f87af9b0cd1bd2c7cb61ecf4", + "size": 12961023, + "subdir": "linux-64", + "timestamp": 1541439369313, + "version": "3.4.0" + }, + "plotly-3.4.1-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "3b06d339fb949a5cfc2473d851329eb9", + "name": "plotly", + "sha256": "e857c2dcc98ec2e30ffbd9641a22a898ab16b9a6b6716d4c3e2d63172178d405", + "size": 13345332, + "subdir": "linux-64", + "timestamp": 1542084409103, + "version": "3.4.1" + }, + "plotly-3.4.1-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "215531924b013dc0479dba99cb5e590f", + "name": "plotly", + "sha256": "53b9de285063535f83ae145f6e698bea55c0649e51f44efdd8780a39a8d71508", + "size": 13320410, + "subdir": "linux-64", + "timestamp": 1542084377371, + "version": "3.4.1" + }, + "plotly-3.4.1-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "a152b5abe83f169e3706ed1730b2638b", + "name": "plotly", + "sha256": "d8226f99c7176b318c11b6054105d49b386a66df7434b1d4193e56a91b6df056", + "size": 12960366, + "subdir": "linux-64", + "timestamp": 1542084374710, + "version": "3.4.1" + }, + "plotly-3.4.2-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "f32e4387f68fb7d0f85451c6c71a0f8d", + "name": "plotly", + "sha256": "1ace6cf5b89e94c77e68685b2630c56fe94942d42b2f37dec928b32cc971633e", + "size": 12974249, + "subdir": "linux-64", + "timestamp": 1543606439060, + "version": "3.4.2" + }, + "plotly-3.4.2-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "1ae12694cca69e2cbeb1f72fa698396d", + "name": "plotly", + "sha256": "41c07e8cdfbe8f4fb922a5eab8ed54a9dbfe2861d89d64a1af92d3b6b2b634a1", + "size": 13326229, + "subdir": "linux-64", + "timestamp": 1543606548117, + "version": "3.4.2" + }, + "plotly-3.4.2-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "ca4d4c870f1eafac79ede87e9373b351", + "name": "plotly", + "sha256": "53c67811588810755d5f6d49388621a85d17e014eeb7b34083005471c1300ac1", + "size": 13329080, + "subdir": "linux-64", + "timestamp": 1543606530104, + "version": "3.4.2" + }, + "plotly-3.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "953e70629afecd7008724b76a0c363ef", + "name": "plotly", + "sha256": "deb9f21c4e7e1fe9ba78a82e9cb395565831acc6ad8c2c63f3336f92d10bc268", + "size": 13072512, + "subdir": "linux-64", + "timestamp": 1547926120383, + "version": "3.5.0" + }, + "plotly-3.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "cc273db42c93746dd37ca98588ce6946", + "name": "plotly", + "sha256": "027ebabf34db76b38ea7d05f87d825a05c3baa7c5e204781e4c11c1c4f15e277", + "size": 13057716, + "subdir": "linux-64", + "timestamp": 1547926142204, + "version": "3.5.0" + }, + "plotly-3.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "a35e7d2b3c7b0d972097bc06b4d37c4f", + "name": "plotly", + "sha256": "ab1ffa764503778c600ae9816b9d23528a4b18d9dc290970482ded0449884932", + "size": 13047228, + "subdir": "linux-64", + "timestamp": 1547926134097, + "version": "3.5.0" + }, + "plotly-3.6.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=2.7,<2.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "47c175270b8075301d8beabc294603af", + "name": "plotly", + "sha256": "f7ffd03d56c831d9f5c4f3f82fe566c8d2c751259e5a3255095726a6605f2e75", + "size": 13148462, + "subdir": "linux-64", + "timestamp": 1550351504166, + "version": "3.6.1" + }, + "plotly-3.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.6,<3.7.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "a1d5f72d7b8e06151800f412db15a806", + "name": "plotly", + "sha256": "d82b535b1f64f80bfa07bcdb66761d1f1d3e72136eb58f0b6dc70c800392e0ea", + "size": 13513195, + "subdir": "linux-64", + "timestamp": 1550351623342, + "version": "3.6.1" + }, + "plotly-3.6.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator >=4.0.6", + "nbformat >=4.2", + "python >=3.7,<3.8.0a0", + "pytz", + "requests", + "retrying >=1.3.3", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "fc294dd40cd4bc30dcf7f00b1877fa5c", + "name": "plotly", + "sha256": "5a091ffc031e7de03f1882a2fc94ca07540428f255beea5e6d4ab0ade31b730d", + "size": 13511401, + "subdir": "linux-64", + "timestamp": 1550351584658, + "version": "3.6.1" + }, + "plotly-5.9.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "tenacity >=6.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1cbcee0a82dbdf97ebb1c81e0379444b", + "name": "plotly", + "sha256": "5876445c7e290a5842d524476c6fcb3b77e1151fb4352aa2c80b823b1ef53bb1", + "size": 4319691, + "subdir": "linux-64", + "timestamp": 1658160435387, + "version": "5.9.0" + }, + "plotly-5.9.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "tenacity >=6.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "949dc962482077df4374f675a0de286a", + "name": "plotly", + "sha256": "4ac029ec1841cdf3817899b7fcac8afa6f360338b4bf0149b9ca210d77b381c1", + "size": 5187701, + "subdir": "linux-64", + "timestamp": 1676841735198, + "version": "5.9.0" + }, + "plotly-5.9.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "tenacity >=6.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0fa2708228c558c0d8725803ee811de8", + "name": "plotly", + "sha256": "63cbb2beb4527c7419f20b0a28d072775df75483cb6fed20342c6c7ab8a9b3cf", + "size": 4243394, + "subdir": "linux-64", + "timestamp": 1658160216909, + "version": "5.9.0" + }, + "plotly-5.9.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "tenacity >=6.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e0f798af97bbcba1901e94763a83947", + "name": "plotly", + "sha256": "87a895075a46c5ecf772f284bce53788cbdc70821a7b45ca2a0b8a7d24705834", + "size": 4240019, + "subdir": "linux-64", + "timestamp": 1658160841728, + "version": "5.9.0" + }, + "plotly-5.9.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "tenacity >=6.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a5a09ba7ee25c89fbaf6e4dc4a755971", + "name": "plotly", + "sha256": "eeeed7fb97fc88d3e061d21a3c365b2bca97a72dc1bcfc630416d5c61cfa1b86", + "size": 4283026, + "subdir": "linux-64", + "timestamp": 1658160642488, + "version": "5.9.0" + }, + "pluggy-0.13.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec1f7985a578165798e83ad561a9fee4", + "name": "pluggy", + "sha256": "7bda4c5f65526fb3a85396f28edc7f21b60e2887c9cbbead5501d9764200cd04", + "size": 32709, + "subdir": "linux-64", + "timestamp": 1569265817646, + "version": "0.13.0" + }, + "pluggy-0.13.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "29d08eab7afcf1996c4d91868220c6b8", + "name": "pluggy", + "sha256": "4ec8bc9c4930e377823bd38043d1811cca5f1067b04c52df783307abcd0fcdad", + "size": 32937, + "subdir": "linux-64", + "timestamp": 1569265838961, + "version": "0.13.0" + }, + "pluggy-0.13.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3fe6231331924c1eeab05057a43bd576", + "name": "pluggy", + "sha256": "a01667555724a418ac5ef90072e060eab7c2906f73d0b46c5056060efd9c85ba", + "size": 33078, + "subdir": "linux-64", + "timestamp": 1569265767466, + "version": "0.13.0" + }, + "pluggy-0.13.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "987cc26103f0d3ff16a281b345b94006", + "name": "pluggy", + "sha256": "ce402dc80846d23d22cb6af60e05c4b3e063db257724b87c6f926e6c86447c83", + "size": 30876, + "subdir": "linux-64", + "timestamp": 1572609212685, + "version": "0.13.0" + }, + "pluggy-0.13.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "521838ac0ba959075203b447523158dc", + "name": "pluggy", + "sha256": "2a4d26806377d9fbc5e699e8e63aff9e43c3e245ed98e4f6d8c48d2ee9ed7e3f", + "size": 33392, + "subdir": "linux-64", + "timestamp": 1574699625975, + "version": "0.13.1" + }, + "pluggy-0.13.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "361bb5505fa523465a8a13e090f4fead", + "name": "pluggy", + "sha256": "9c7418343aafd7133db83af59554c8e771a995b03cd79b4effa17f20ed73c068", + "size": 31391, + "subdir": "linux-64", + "timestamp": 1642499759971, + "version": "0.13.1" + }, + "pluggy-0.13.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f7f153a88a58407e2ec71b0fedb72552", + "name": "pluggy", + "sha256": "21c3e6815c1142a86aed3f3f3ea297a3e63e5af1b8dee805328be3a51e64e789", + "size": 33793, + "subdir": "linux-64", + "timestamp": 1574699642985, + "version": "0.13.1" + }, + "pluggy-0.13.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5423c077aa934bfc679525346c24f96d", + "name": "pluggy", + "sha256": "bdf2dea51642d0bb3762ce6b9c565fb53e9b97f26745af83406e46c251754d35", + "size": 34196, + "subdir": "linux-64", + "timestamp": 1615976356156, + "version": "0.13.1" + }, + "pluggy-0.13.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c1e5f46384a5163964b4d1563348518", + "name": "pluggy", + "sha256": "d19537989db577fb9996076a82bd34e19075dae77e6f4b9071e876e86ca8b0e5", + "size": 33861, + "subdir": "linux-64", + "timestamp": 1574699614689, + "version": "0.13.1" + }, + "pluggy-0.13.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "61713e12614e27fa7dfba7ecfcc3e051", + "name": "pluggy", + "sha256": "9d265fffaf43ebea917909f0dd392a5634d8b321403c7bcc0e4cc464346b88a1", + "size": 34229, + "subdir": "linux-64", + "timestamp": 1615976347734, + "version": "0.13.1" + }, + "pluggy-0.13.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "70732fdd93d8500f2c657de2378d37ae", + "name": "pluggy", + "sha256": "24f32ac6a092c26e13a0ac0ad8f175f9d4c7c10c67eb79e9fbed6bc3ea0ab222", + "size": 33948, + "subdir": "linux-64", + "timestamp": 1574699695602, + "version": "0.13.1" + }, + "pluggy-0.13.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e25e8a00605b6b286f96900d6e8caa9", + "name": "pluggy", + "sha256": "da03b35b906cd0e2ef293bd634fa084083702dcbbfbe9a4265b884776335f654", + "size": 34176, + "subdir": "linux-64", + "timestamp": 1615976360217, + "version": "0.13.1" + }, + "pluggy-0.13.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbe0d59689a00db3999458882f1756f4", + "name": "pluggy", + "sha256": "961dbaadec041404b39059a58c0e462bc6e74ed3ddce644ed49fcde9b506844a", + "size": 34050, + "subdir": "linux-64", + "timestamp": 1615976364098, + "version": "0.13.1" + }, + "pluggy-0.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87c0f1e10d84ba0cf9dc93116abf50b4", + "name": "pluggy", + "sha256": "ac3e9ac0b5b0bf98b03b14d67dd4584eaccf65d07b6d9cc8c3558f998cf14da6", + "size": 23554, + "subdir": "linux-64", + "timestamp": 1530693699401, + "version": "0.6.0" + }, + "pluggy-0.6.0-py27h1f4f128_0.conda": { + "build": "py27h1f4f128_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "503a698c0410d8289748c5aecf809ec8", + "name": "pluggy", + "sha256": "407bdbc6b64292d7091f069e1dfd1bce99131b0f7de39425aac2fbc70c9b2003", + "size": 23679, + "subdir": "linux-64", + "timestamp": 1511930208362, + "version": "0.6.0" + }, + "pluggy-0.6.0-py35hb428803_0.conda": { + "build": "py35hb428803_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c04509fd19e4066d5643831129509fb3", + "name": "pluggy", + "sha256": "c3c0b5ada494df657154b559a8e8a1f45c844e7cd4c9310b9559ef0b79876817", + "size": 24434, + "subdir": "linux-64", + "timestamp": 1511930197503, + "version": "0.6.0" + }, + "pluggy-0.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b69543b3138d6a3c5e6f51bab1bca701", + "name": "pluggy", + "sha256": "91e1504e5f05de04681ab53a504a3d8ce3f00bfa1b59e79315bcfa29f746f353", + "size": 23619, + "subdir": "linux-64", + "timestamp": 1530693661709, + "version": "0.6.0" + }, + "pluggy-0.6.0-py36hb689045_0.conda": { + "build": "py36hb689045_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "10b7edc84a0db338241edaffbdd130f6", + "name": "pluggy", + "sha256": "65f48625dd4aa96998ce7e84282c2c552b3f50cb09841f2d83b7887336560370", + "size": 24160, + "subdir": "linux-64", + "timestamp": 1511930242042, + "version": "0.6.0" + }, + "pluggy-0.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9330ac3973db519349a6d922252c0d60", + "name": "pluggy", + "sha256": "b24bacf334f8b09c743c041f04da4e1aff0cd3af61c91bcf9a572ea07f162b58", + "size": 23866, + "subdir": "linux-64", + "timestamp": 1530693681008, + "version": "0.6.0" + }, + "pluggy-0.7.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d95d925419660d67a84dd2a9a7405420", + "name": "pluggy", + "sha256": "bdf028b3bfc9239de2b6d18f489e08dd52634f63ccd15cff567a09b390bee151", + "size": 26577, + "subdir": "linux-64", + "timestamp": 1532976798483, + "version": "0.7.1" + }, + "pluggy-0.7.1-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8537848604a33608970ae55c014ec514", + "name": "pluggy", + "sha256": "37a60b642de66af773f3a1e845ccadb07ae714211e97faef1b97bcc72b3ade22", + "size": 26601, + "subdir": "linux-64", + "timestamp": 1534344865406, + "version": "0.7.1" + }, + "pluggy-0.7.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d7f31182ae49e4b6c4dbc8d0e52cf07f", + "name": "pluggy", + "sha256": "c834b4100a123ea98fceee1b1af7dc029324475d23b1353dfc6dd022c71cb5bb", + "size": 27179, + "subdir": "linux-64", + "timestamp": 1532976908613, + "version": "0.7.1" + }, + "pluggy-0.7.1-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f250008e5204193db5501d0733359a3b", + "name": "pluggy", + "sha256": "dc80a6213e03ca5d60d21ad212c759d1cad023578c22ea5f8a63f4916308137d", + "size": 27183, + "subdir": "linux-64", + "timestamp": 1534344913031, + "version": "0.7.1" + }, + "pluggy-0.7.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02b83571be60e5b340b545bdbf13e586", + "name": "pluggy", + "sha256": "d8a401ba757918f007bff756ec3779ae11b1395a0e884a19887713acc290aeb9", + "size": 26908, + "subdir": "linux-64", + "timestamp": 1532976697992, + "version": "0.7.1" + }, + "pluggy-0.7.1-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b15c7106ae00f5ea18e1c4222516c515", + "name": "pluggy", + "sha256": "0843ac2f7822673b1703e7d7593789df53f8e7bb0ce8c784e746ee86564a97b0", + "size": 27147, + "subdir": "linux-64", + "timestamp": 1534344888868, + "version": "0.7.1" + }, + "pluggy-0.7.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c7cb59039b17baee1045d0ea01cbc0f", + "name": "pluggy", + "sha256": "1ab78cc0f58a35784412235c9abdab33768ea29b84bf8a8b53a29ab960b585cd", + "size": 27036, + "subdir": "linux-64", + "timestamp": 1532977009932, + "version": "0.7.1" + }, + "pluggy-0.7.1-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ddc48e398ab2952b0003c4002ee371c9", + "name": "pluggy", + "sha256": "d55ca3ec8fc43c395d75956cb35f1412f98bdd3f7a43ed3af046234eb56ac36b", + "size": 27245, + "subdir": "linux-64", + "timestamp": 1534344937158, + "version": "0.7.1" + }, + "pluggy-0.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4c3390d5df3b6d7b876e61e38a74ff8d", + "name": "pluggy", + "sha256": "16a4012751fcd9c800ea3b4cea09588cb96d68330cbbd0f3d083770f5057e27b", + "size": 30166, + "subdir": "linux-64", + "timestamp": 1540234292369, + "version": "0.8.0" + }, + "pluggy-0.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d45d0b7b8d7abaf42e14f38f70e22f4b", + "name": "pluggy", + "sha256": "3a9c360bc91936f0bc5f00240395aa7c770b57aabbec63e74f8d700484ec15d7", + "size": 30238, + "subdir": "linux-64", + "timestamp": 1540234348329, + "version": "0.8.0" + }, + "pluggy-0.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2a89ce948dd7ac64b39a96b8914ba10", + "name": "pluggy", + "sha256": "889c0967f48ab9574459f410414f0b1930cd28c14d0e292296173b583f903cbd", + "size": 30601, + "subdir": "linux-64", + "timestamp": 1540234321571, + "version": "0.8.0" + }, + "pluggy-0.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8dde6a2bb1d8e799b1283c5da621121a", + "name": "pluggy", + "sha256": "c59d726d03a368f627b35bfe5784dd14f7e2d453943add4b667148fd834755de", + "size": 31678, + "subdir": "linux-64", + "timestamp": 1547753132826, + "version": "0.8.1" + }, + "pluggy-0.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5df4261d7f5850490be8c85ef467d54e", + "name": "pluggy", + "sha256": "6ed4f17dcf8f851f10af8b8e66f105f8303c5eb689ce71729556ef4ab44ae5a2", + "size": 31798, + "subdir": "linux-64", + "timestamp": 1547753154702, + "version": "0.8.1" + }, + "pluggy-0.8.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c3d27cca8bbee5d2552c632d4e3dfd3", + "name": "pluggy", + "sha256": "c3457c1544be30a905de65f7dc5260115a69f67a504d1a803dca8d2fcbcc8cb4", + "size": 32085, + "subdir": "linux-64", + "timestamp": 1547753198233, + "version": "0.8.1" + }, + "pluggy-0.9.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0cf05630f65ba9724ce5722530000cf0", + "name": "pluggy", + "sha256": "2deb7895a451c03f9db609d2c050d76406168e9e881bf65aa490ffcfeadac7b2", + "size": 32162, + "subdir": "linux-64", + "timestamp": 1551144146727, + "version": "0.9.0" + }, + "pluggy-0.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "deb021867925af96da0657d873b5b92e", + "name": "pluggy", + "sha256": "0c1db52999417b4703d3eebe1169b94e18094a165a2c802ba9c10c11170134b8", + "size": 32311, + "subdir": "linux-64", + "timestamp": 1551144166686, + "version": "0.9.0" + }, + "pluggy-0.9.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ade632b82631a2f4c5c53b934c3ca7ad", + "name": "pluggy", + "sha256": "4e178590f651f3ebdfe586cf16595dfe407f3ff52e78d24e2d3104113f1a61ff", + "size": 32380, + "subdir": "linux-64", + "timestamp": 1551144116309, + "version": "0.9.0" + }, + "pluggy-1.0.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b96380162a84640a34ede74691658db", + "name": "pluggy", + "sha256": "353c9b72a6dfea69ac868916bdaa361bc423f29eb74027bf582976ef39ec4168", + "size": 29216, + "subdir": "linux-64", + "timestamp": 1648024755502, + "version": "1.0.0" + }, + "pluggy-1.0.0-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9161481e52853483e8233f259fb25272", + "name": "pluggy", + "sha256": "55403e91d0bdd1326bd876994116913e48baac6d0d5840990d64f8ef35146daf", + "size": 33138, + "subdir": "linux-64", + "timestamp": 1676822832891, + "version": "1.0.0" + }, + "pluggy-1.0.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "09dda5bfa35d658fe43f061a91c4be2d", + "name": "pluggy", + "sha256": "2086d687e37215cca1dfc7609f1886c7a722be117f4314653393b74dae4c01fa", + "size": 28710, + "subdir": "linux-64", + "timestamp": 1633704415683, + "version": "1.0.0" + }, + "pluggy-1.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib_metadata >=0.12", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db23020de306910bb9c89e55580276dd", + "name": "pluggy", + "sha256": "6293ece3ae01863d0099ff5a4e014a52897fd0a8c323d28fd7770d965b34f0d4", + "size": 28963, + "subdir": "linux-64", + "timestamp": 1633715242220, + "version": "1.0.0" + }, + "pluggy-1.0.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "importlib_metadata >=0.12", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb6d02937ffc02b9022ed3a1e1508f97", + "name": "pluggy", + "sha256": "24b94085173ce9c75a8ffcfe43feb27162a232eedac57bc1da3568c973ddaa83", + "size": 29234, + "subdir": "linux-64", + "timestamp": 1648042607519, + "version": "1.0.0" + }, + "pluggy-1.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "38bcf81d521dd553183b937b8f0c8b46", + "name": "pluggy", + "sha256": "fc252716ddbad0adf2ab44466772d87eccdd9acde8c363606c6b5e416229b2f9", + "size": 29018, + "subdir": "linux-64", + "timestamp": 1633715082877, + "version": "1.0.0" + }, + "pluggy-1.0.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87bb1d3f6cf3e409a1dac38cee99918e", + "name": "pluggy", + "sha256": "5de419470ba9f03555209166c9a745e0192f33b47cca51742a9e3f601feec156", + "size": 29102, + "subdir": "linux-64", + "timestamp": 1648042603024, + "version": "1.0.0" + }, + "pluggy-1.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "68864156114d67b5fce5756952edf812", + "name": "pluggy", + "sha256": "3b1015f0124e38cb45446ad584eabf9a1cb0a202913dd1d7379435599aa0b3c6", + "size": 29026, + "subdir": "linux-64", + "timestamp": 1633715241414, + "version": "1.0.0" + }, + "pluggy-1.0.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb4fed11ed43cf727dbd51883cc1d9fa", + "name": "pluggy", + "sha256": "5611dd0e5a6d9c0d76b7da44825211d2c1792aa150268ad109ffa2e6eb2f25c1", + "size": 29107, + "subdir": "linux-64", + "timestamp": 1648024480363, + "version": "1.0.0" + }, + "ply-3.10-py27hd6d9ae5_0.conda": { + "build": "py27hd6d9ae5_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d64467022ec0fd95de149a37ee48d08c", + "name": "ply", + "sha256": "4279c7643779f80404924786eab735d391c12bd14b5f9b7467a142e4e245792d", + "size": 83265, + "subdir": "linux-64", + "timestamp": 1505751193645, + "version": "3.10" + }, + "ply-3.10-py35h459f1a0_0.conda": { + "build": "py35h459f1a0_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ddecc738e8b008dad1f6a46633c75ca9", + "name": "ply", + "sha256": "dbf72db389c920faa83e567e84dcc247f35acc9b2d5350bd702462bcd14e7f80", + "size": 83653, + "subdir": "linux-64", + "timestamp": 1505751206621, + "version": "3.10" + }, + "ply-3.10-py36hed35086_0.conda": { + "build": "py36hed35086_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "fa7a4d84a544d66c43bd2f1e82da7b1a", + "name": "ply", + "sha256": "4c4061448d82614bfc1d0caf26cad2cbf8630c926dd9e7b9675c0485a02035b7", + "size": 82780, + "subdir": "linux-64", + "timestamp": 1505751219980, + "version": "3.10" + }, + "ply-3.11-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4f0eb3ae2bb07ea014d540e079cacbc0", + "name": "ply", + "sha256": "b66ff5d7d8481adc57e23d1a9eb42056f4042cdf107ba9d92230a42b546275b4", + "size": 83928, + "subdir": "linux-64", + "timestamp": 1519148046159, + "version": "3.11" + }, + "ply-3.11-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ef39417278853a79e018bafdefc88eda", + "name": "ply", + "sha256": "bb4798f9ff26b3b46e40ff6fa2685304c095ad643df9946f58afa5706359e88d", + "size": 82136, + "subdir": "linux-64", + "timestamp": 1640792429668, + "version": "3.11" + }, + "ply-3.11-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5e38758b2f9d1bb6c46cf1fd8efb7540", + "name": "ply", + "sha256": "d900265772855f616e14208fd50b0946470a06ac69292f4cac663a5c6fd2400f", + "size": 113843, + "subdir": "linux-64", + "timestamp": 1676824981885, + "version": "3.11" + }, + "ply-3.11-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "bb842d8b2d19bbfd6de042264341bc36", + "name": "ply", + "sha256": "ab3b2cda68929a0359d9118c55632f50a629fa7625c0eac6ef3bd89f945c158d", + "size": 84552, + "subdir": "linux-64", + "timestamp": 1519148093111, + "version": "3.11" + }, + "ply-3.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6de0215143fd7809e5f9077febe3cb4f", + "name": "ply", + "sha256": "070cc88bc3c95c0857822595a6fb395b352ee26d671068c4891e5494e16fd882", + "size": 83311, + "subdir": "linux-64", + "timestamp": 1519148094947, + "version": "3.11" + }, + "ply-3.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3bdc1cc765a33c321405b37355cdbdf1", + "name": "ply", + "sha256": "afb09898fa199ff4909fa43b0e00f2db329ba69483ea519fcafabadff335280a", + "size": 83561, + "subdir": "linux-64", + "timestamp": 1530873685472, + "version": "3.11" + }, + "ply-3.11-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d6a69c576c6e4d19e3074eaae3d149f2", + "name": "ply", + "sha256": "dc81ddcba0de3d39dbd9f609a82eb2e66269f872c7c1fdc52a27273a27fc782f", + "size": 82451, + "subdir": "linux-64", + "timestamp": 1573040646911, + "version": "3.11" + }, + "ply-3.11-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6c89bf6d2fdf6d24126e34cb83fd10f1", + "name": "ply", + "sha256": "e3cf6693b6ca0d07696d9aea7feb130c959621826a829ad22d06cbccb6ef9f46", + "size": 83046, + "subdir": "linux-64", + "timestamp": 1607029370982, + "version": "3.11" + }, + "plyvel-1.4.0-py310hdb19cb5_0.conda": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "78b13c1885dcce0cd7226212181890ff", + "name": "plyvel", + "sha256": "a2ff9d8409092bc3a50ea7bd645beea0cbb2f63a9bc17286b4d0648fa49eebff", + "size": 423169, + "subdir": "linux-64", + "timestamp": 1659776194651, + "version": "1.4.0" + }, + "plyvel-1.4.0-py37hdb19cb5_0.conda": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "03121874442dd0ab46a16a541cc435ce", + "name": "plyvel", + "sha256": "91fa7572154699350e6131b2df4166e176c8c1d23a19b46234a1a87aaadd3449", + "size": 397696, + "subdir": "linux-64", + "timestamp": 1659776229514, + "version": "1.4.0" + }, + "plyvel-1.4.0-py38hdb19cb5_0.conda": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "bcf11f4d4d368af4a2ad033659991aae", + "name": "plyvel", + "sha256": "086210540188db6228f1ba01a02bc120aec9939891570eea288b0e580859ae7d", + "size": 434473, + "subdir": "linux-64", + "timestamp": 1659776148855, + "version": "1.4.0" + }, + "plyvel-1.4.0-py39hdb19cb5_0.conda": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9c3a46f63cf0b8e650087d601f290dbf", + "name": "plyvel", + "sha256": "8a068df127e872aa37da87c883f23f0136ca7045e649e072dfcd50aee750f509", + "size": 423965, + "subdir": "linux-64", + "timestamp": 1659776114234, + "version": "1.4.0" + }, + "plyvel-1.5.0-py310hdb19cb5_0.conda": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eeb11531988f32c522a716810accfeee", + "name": "plyvel", + "sha256": "bf257a4bd3a7e5a738d8e1608e579bb16b0d1e18f7444f56bb50dd24951f5e4e", + "size": 462235, + "subdir": "linux-64", + "timestamp": 1676300872330, + "version": "1.5.0" + }, + "plyvel-1.5.0-py311hdb19cb5_0.conda": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "10f60cdc1be89ac8f0ba0d36cca4ed0a", + "name": "plyvel", + "sha256": "2e3e215a4031635e3ef8016e1daa61f71708b3912085930b16c0700913057f90", + "size": 437162, + "subdir": "linux-64", + "timestamp": 1676860386562, + "version": "1.5.0" + }, + "plyvel-1.5.0-py37hdb19cb5_0.conda": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6dd8754d3da1f71fe1613344b15304f7", + "name": "plyvel", + "sha256": "0ceafd4afeffeb6b8e5283dbfde6a7cd0f03ea1bf7b803bb7da7ee8d04acaa49", + "size": 442468, + "subdir": "linux-64", + "timestamp": 1676300766616, + "version": "1.5.0" + }, + "plyvel-1.5.0-py38hdb19cb5_0.conda": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2c683881570b46fc31e90f684520c3eb", + "name": "plyvel", + "sha256": "a094959c2fa158b3bec0217c8707ef6e45a7098e7c4530109635326c8c82cc68", + "size": 482213, + "subdir": "linux-64", + "timestamp": 1676300837391, + "version": "1.5.0" + }, + "plyvel-1.5.0-py39hdb19cb5_0.conda": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ecd5fa3183e85fa093d244229e47b468", + "name": "plyvel", + "sha256": "3644a4e660953979d1c35642cd92f64917c37a6ded33a5d027720170470163ee", + "size": 469067, + "subdir": "linux-64", + "timestamp": 1676300801495, + "version": "1.5.0" + }, + "pmdarima-1.8.5-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "cython >=0.29,!=0.29.18", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "numpy >=1.21.5,<2.0a0", + "pandas >=0.19", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.22", + "scipy >=1.3.2", + "setuptools >=38.6.0,!=50.0.0", + "statsmodels >=0.11,!=0.12.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f02f166965b71f87de8de8064b5d698", + "name": "pmdarima", + "sha256": "d8a3c5d14c5f00b467b50008ff627fe73ae59376edc2d146114ff244bfb3a220", + "size": 1195794, + "subdir": "linux-64", + "timestamp": 1650013596746, + "version": "1.8.5" + }, + "pmdarima-1.8.5-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "cython >=0.29,!=0.29.18", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "numpy >=1.20.3,<2.0a0", + "pandas >=0.19", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.22", + "scipy >=1.3.2", + "setuptools >=38.6.0,!=50.0.0", + "statsmodels >=0.11,!=0.12.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eddcd247876b43dd624a9a750c3edec2", + "name": "pmdarima", + "sha256": "297c0f18e823741afe76a5d3d1f6e249730db41fc9afa76dfd568b48c6858eba", + "size": 581367, + "subdir": "linux-64", + "timestamp": 1650031723249, + "version": "1.8.5" + }, + "pmdarima-1.8.5-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "cython >=0.29,!=0.29.18", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "numpy >=1.20.3,<2.0a0", + "pandas >=0.19", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.22", + "scipy >=1.3.2", + "setuptools >=38.6.0,!=50.0.0", + "statsmodels >=0.11,!=0.12.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2560a0624b77897c9ea758dc0f207b13", + "name": "pmdarima", + "sha256": "8efe035cf1bc0170c49a9b964239ad6f69e75cf5fa890c89a87b0186928bc005", + "size": 596334, + "subdir": "linux-64", + "timestamp": 1650031710573, + "version": "1.8.5" + }, + "pmdarima-1.8.5-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "cython >=0.29,!=0.29.18", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "numpy >=1.20.3,<2.0a0", + "pandas >=0.19", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.22", + "scipy >=1.3.2", + "setuptools >=38.6.0,!=50.0.0", + "statsmodels >=0.11,!=0.12.0", + "urllib3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c973aa026a47a25f6b46c1f58a59ac3", + "name": "pmdarima", + "sha256": "10fa982b4daa78192a62027a26dc0932fd5d256e0cb6103c0b14d98e05338b36", + "size": 593132, + "subdir": "linux-64", + "timestamp": 1650013844620, + "version": "1.8.5" + }, + "poetry-1.0.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.7.6,<0.8.0", + "clikit >=0.4.2,<0.5.0", + "html5lib >=1.0,<2.0", + "importlib_metadata >=1.1.3,<1.2.0", + "jsonschema >=3.1,<4.0", + "keyring >=18.0.1,<19.0.0", + "lockfile >=0.9", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.8.0,<0.9.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.5.11,<0.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a853d4b698dfb81d194cf64a4e22c12b", + "name": "poetry", + "sha256": "b6de4465b9e42ee5e5fa43817d896af3cbef9a8f08fe6963d5b17c911c2b1a67", + "size": 325782, + "subdir": "linux-64", + "timestamp": 1597354612487, + "version": "1.0.10" + }, + "poetry-1.0.10-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.7.6,<0.8.0", + "clikit >=0.4.2,<0.5.0", + "html5lib >=1.0,<2.0", + "importlib_metadata >=1.1.3,<1.2.0", + "jsonschema >=3.1,<4.0", + "keyring >=18.0.1,<19.0.0", + "lockfile >=0.9", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.8.0,<0.9.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.5.11,<0.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f053d4557fbbcb6bc48ece7d78c16b7e", + "name": "poetry", + "sha256": "f83f98c3bd3c66256640670a8d6f643b5fff0417975114cba96934b750beea09", + "size": 325471, + "subdir": "linux-64", + "timestamp": 1597354609906, + "version": "1.0.10" + }, + "poetry-1.0.10-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.7.6,<0.8.0", + "clikit >=0.4.2,<0.5.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=18.0.1,<19.0.0", + "lockfile >=0.9", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.8.0,<0.9.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.5.11,<0.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01e6937a137b820b76b6ef607827d3b6", + "name": "poetry", + "sha256": "1b2108c2d425a0cbf00641fef7ec08f77d81cb808eabe150463da248ee7d3fd9", + "size": 330642, + "subdir": "linux-64", + "timestamp": 1597354627799, + "version": "1.0.10" + }, + "poetry-1.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.7.6,<0.8.0", + "clikit >=0.4.1,<0.5.0", + "functools32 >=3.2.3,<3.3", + "glob2 >=0.6,<1", + "html5lib >=1.0,<2.0", + "importlib_metadata >=0.23,<1", + "jsonschema >=3.1,<4.0", + "keyring >=18.0,<19", + "lockfile >=0.9", + "pathlib2 >=2.3,<3", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.8.0,<0.9.0", + "shellingham >=1.1,<2.0", + "subprocess32 >=3.5,<4", + "tomlkit >=0.5.8,<0.6.0", + "typing >=3.6,<4", + "virtualenv >=16.0,<17" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2190590f942b19997829b4824cf4f8e", + "name": "poetry", + "sha256": "136273e2c01b05622ced8891f42b99ab60f0316242fe6d72230a2f02d731ffde", + "size": 315741, + "subdir": "linux-64", + "timestamp": 1579616106381, + "version": "1.0.2" + }, + "poetry-1.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.7.6,<0.8.0", + "clikit >=0.4.1,<0.5.0", + "html5lib >=1.0,<2.0", + "importlib_metadata >=0.23,<1", + "jsonschema >=3.1,<4.0", + "keyring >=19.0,<20", + "lockfile >=0.9", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.8.0,<0.9.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.5.8,<0.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9b86dcf6abd8358182bbaef1e206b57", + "name": "poetry", + "sha256": "a3ee23b32a8b50e797ee323e4d6aae6eab33bb4461d3fae7e2452b7bb1ba9fef", + "size": 320672, + "subdir": "linux-64", + "timestamp": 1579615985886, + "version": "1.0.2" + }, + "poetry-1.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.7.6,<0.8.0", + "clikit >=0.4.1,<0.5.0", + "html5lib >=1.0,<2.0", + "importlib_metadata >=0.23,<1", + "jsonschema >=3.1,<4.0", + "keyring >=19.0,<20", + "lockfile >=0.9", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.8.0,<0.9.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.5.8,<0.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc077bd3e8987c7723323e994d295bf3", + "name": "poetry", + "sha256": "66b4d60de0cf72127d8a5cd70bd92141d0c434569ceb736a192248183b4ea8ad", + "size": 319301, + "subdir": "linux-64", + "timestamp": 1579616023382, + "version": "1.0.2" + }, + "poetry-1.0.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.7.6,<0.8.0", + "clikit >=0.4.2,<0.5.0", + "html5lib >=1.0,<2.0", + "importlib_metadata >=1.1.3,<1.2.0", + "jsonschema >=3.1,<4.0", + "keyring >=18.0.1,<19.0.0", + "lockfile >=0.9", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.8.0,<0.9.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.5.11,<0.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6001ad2d1c1a1a01b476c21330f961c6", + "name": "poetry", + "sha256": "cf1780af1fbbbdff32af5b7a27ce13c084a571cb1a0aa1c4241fe731ce580ea9", + "size": 324229, + "subdir": "linux-64", + "timestamp": 1594845777440, + "version": "1.0.9" + }, + "poetry-1.0.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.7.6,<0.8.0", + "clikit >=0.4.2,<0.5.0", + "html5lib >=1.0,<2.0", + "importlib_metadata >=1.1.3,<1.2.0", + "jsonschema >=3.1,<4.0", + "keyring >=18.0.1,<19.0.0", + "lockfile >=0.9", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.8.0,<0.9.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.5.11,<0.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e96931332c8617d9114a47707401ded", + "name": "poetry", + "sha256": "595d83152a7ad3cce6d7f37d632391c587d97e3f844cb183155e3001fb2155bd", + "size": 325437, + "subdir": "linux-64", + "timestamp": 1594843317744, + "version": "1.0.9" + }, + "poetry-1.0.9-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.7.6,<0.8.0", + "clikit >=0.4.2,<0.5.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=18.0.1,<19.0.0", + "lockfile >=0.9", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.8.0,<0.9.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.5.11,<0.6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c41ae0d090b7100d23be16531ce93318", + "name": "poetry", + "sha256": "a75818727ab3d0625064b246cb535b41e1d8e7fee3a25a52189b16bbdaf5cab9", + "size": 326568, + "subdir": "linux-64", + "timestamp": 1594845488448, + "version": "1.0.9" + }, + "poetry-1.1.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "importlib-metadata >=1.6.0,<2.0.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b5ab6e97b277e8ebab10cb37287fd22", + "name": "poetry", + "sha256": "83383ed53157ea6d242faaa9c0d7293b7e7d77b353fdfcbcd7ad998f24f377ba", + "size": 246990, + "subdir": "linux-64", + "timestamp": 1606170917842, + "version": "1.1.4" + }, + "poetry-1.1.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "importlib-metadata >=1.6.0,<2.0.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "06424d546ef61e6f11d64cbaf453c805", + "name": "poetry", + "sha256": "a039df76dbdaf111dfccb5a5eec1ca3a87148a714c1a875e206d41b536605d64", + "size": 247757, + "subdir": "linux-64", + "timestamp": 1606170906002, + "version": "1.1.4" + }, + "poetry-1.1.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e848a6024ff23dfe96a691fb3c7b0167", + "name": "poetry", + "sha256": "5f69464c3633dd28302c453124231d312259bf1979687158af5dbd5dabfaccc2", + "size": 250919, + "subdir": "linux-64", + "timestamp": 1606170910231, + "version": "1.1.4" + }, + "poetry-1.1.5-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "importlib-metadata >=1.6.0,<2.0.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4349f42c287cbf21f8dafc4dbb070707", + "name": "poetry", + "sha256": "70e03754831aa07d5bd049c75c4232ffad84bff9e7ebdb50d52902af24686a4c", + "size": 247303, + "subdir": "linux-64", + "timestamp": 1615562463498, + "version": "1.1.5" + }, + "poetry-1.1.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "importlib-metadata >=1.6.0,<2.0.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e0e3618dd7ebb15b8cdc42658cc55ed", + "name": "poetry", + "sha256": "65ef10d7e1028e6d7632f4d73a0e8e033c8fb1125035d0f74ad86e102a69175a", + "size": 247741, + "subdir": "linux-64", + "timestamp": 1615564131393, + "version": "1.1.5" + }, + "poetry-1.1.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd41b418ed3571bc827dd60936b278cc", + "name": "poetry", + "sha256": "fef7c150ed5da49dc787ef0434529c9f57d880bf259352fc1b5bcdbf2eff1de5", + "size": 249662, + "subdir": "linux-64", + "timestamp": 1615564129949, + "version": "1.1.5" + }, + "poetry-1.1.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "10404f4336a5b6b94e92b9b8d9cafcd6", + "name": "poetry", + "sha256": "7a2bf35903cd950c7e9d9dc84e56d841cb463351dab3f23818f0e3e2b90f91a7", + "size": 251409, + "subdir": "linux-64", + "timestamp": 1615563728165, + "version": "1.1.5" + }, + "poetry-1.1.6-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "importlib-metadata >=1.6.0,<2.0.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8f60be62046c203bfd8a09e6ce7b209", + "name": "poetry", + "sha256": "40cc54d6bbbac625cc2541a639ba233e42a5e9ac65d4646993c64b74347d28e3", + "size": 247816, + "subdir": "linux-64", + "timestamp": 1618437316981, + "version": "1.1.6" + }, + "poetry-1.1.6-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "importlib-metadata >=1.6.0,<2.0.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc8bbd99830f1615f91284e3406b617c", + "name": "poetry", + "sha256": "88caf0a0782049f33ab8cd4c54ff57acb1685b668538838d116624d21d0de9d2", + "size": 249835, + "subdir": "linux-64", + "timestamp": 1618434209548, + "version": "1.1.6" + }, + "poetry-1.1.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "86fa4a17b3293feeb8e70d2c2ddde631", + "name": "poetry", + "sha256": "84fe56d2bb934a1a61a9dfd165e56b05905d18613652f60c4c1c521b5fddb606", + "size": 252184, + "subdir": "linux-64", + "timestamp": 1618437316492, + "version": "1.1.6" + }, + "poetry-1.1.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<21.3.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.15.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66751b9c52c7500ab0c285cf4d7eb1f5", + "name": "poetry", + "sha256": "de98fe077406d01ae444a0815303c4abec22610b884f165d8a94b2c4db11ec65", + "size": 252117, + "subdir": "linux-64", + "timestamp": 1618437326569, + "version": "1.1.6" + }, + "poetry-1.1.7-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "crashtest >=0.3.0,<0.4.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<24.0.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.19.0", + "python >=3.10,<3.11.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26,<21.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "73f85f4d536148ffa42d2382a8558784", + "name": "poetry", + "sha256": "1dfb776c8e1e6b819806abef96b078cc51d59528dd9e4d9b5a2540dca03f4351", + "size": 256592, + "subdir": "linux-64", + "timestamp": 1640887217130, + "version": "1.1.7" + }, + "poetry-1.1.7-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "crashtest >=0.3.0,<0.4.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<24.0.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "platformdirs >=2,<3", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.19.0", + "python >=3.10,<3.11.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "701052f11f72239cfa6dff79de13cc0b", + "name": "poetry", + "sha256": "6743eb9ce9ba157367e048eb4b23c47da536a821621a804717f28c2f3961dc4b", + "size": 254739, + "subdir": "linux-64", + "timestamp": 1663171923600, + "version": "1.1.7" + }, + "poetry-1.1.7-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "crashtest >=0.3.0,<0.4.0", + "html5lib >=1.0,<2.0", + "importlib-metadata >=1.6.0,<2.0.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<24.0.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "platformdirs >=2,<3", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.19.0", + "python >=3.7,<3.8.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90af7e9e43477e06573e4ea2177c32da", + "name": "poetry", + "sha256": "a5a267c38b489e7882868bafcd6aece106219701674341c286d240e80240183c", + "size": 250650, + "subdir": "linux-64", + "timestamp": 1663171874369, + "version": "1.1.7" + }, + "poetry-1.1.7-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "crashtest >=0.3.0,<0.4.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<24.0.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "platformdirs >=2,<3", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.19.0", + "python >=3.8,<3.9.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "91a2eafe3c47c452df39bbf562d7d64a", + "name": "poetry", + "sha256": "6e21426c6b4d73bf473b981cbfcaf61b312f35503ccb65f27274f67aac8fb308", + "size": 252356, + "subdir": "linux-64", + "timestamp": 1663171958157, + "version": "1.1.7" + }, + "poetry-1.1.7-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "cachecontrol >=0.12.4,<0.13.0", + "cachy >=0.3.0,<0.4.0", + "cleo >=0.8.1,<0.9.0", + "clikit >=0.6.2,<0.7.0", + "crashtest >=0.3.0,<0.4.0", + "html5lib >=1.0,<2.0", + "jsonschema >=3.1,<4.0", + "keyring >=21.2.0,<24.0.0", + "lockfile >=0.9", + "packaging >=20.4,<21.0", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.4,<2.0", + "platformdirs >=2,<3", + "poetry-core >=1.0.0,<2.0.0", + "pyparsing >=2.2,<3.0", + "pyrsistent >=0.14.2,<0.19.0", + "python >=3.9,<3.10.0a0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.10.0", + "shellingham >=1.1,<2.0", + "tomlkit >=0.7.0,<1.0.0", + "virtualenv >=20.0.26" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "143878daa97ac0bcc45e1befc80a0cc6", + "name": "poetry", + "sha256": "7cbb3362c2ce67be0adeb9a9a0e456a40e0e0a75cf43b8bedcd7774fe1ce843a", + "size": 252010, + "subdir": "linux-64", + "timestamp": 1663171835751, + "version": "1.1.7" + }, + "poetry-1.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "cachecontrol-with-filecache >=0.12.9,<0.13.0" + ], + "depends": [ + "cachecontrol >=0.12.9,<0.13.0", + "cleo >=2.0.0,<3.0.0", + "crashtest >=0.4.1,<0.5.0", + "dulwich >=0.21.2,<0.22.0", + "filelock >=3.8.0", + "filelock >=3.8.0,<4.0.0", + "html5lib >=1.0,<2.0", + "jsonschema >=4.10.0,<5.0.0", + "keyring >=23.9.0,<24.0.0", + "lockfile >=0.12.2,<0.13.0", + "packaging >=20.4", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.9.4,<2.0", + "platformdirs >=2.5.2,<3.0.0", + "poetry-core 1.5.1.*", + "poetry-plugin-export >=1.3.0,<2.0.0", + "pyproject_hooks >=1.0.0,<2.0.0", + "python >=3.10,<3.11.0a0", + "python-build >=0.10.0,<0.11.0", + "python-installer >=0.6.0,<0.7.0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.11.0", + "shellingham >=1.5,<2.0", + "tomli >=2.0.1,<3.0.0", + "tomlkit >=0.11.1,<1.0.0,!=0.11.2,!=0.11.3", + "trove-classifiers >=2022.5.19", + "urllib3 >=1.26.0,<2.0.0", + "virtualenv >=20.4.3,<21.0.0,!=20.4.5,!=20.4.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b334290b2c0f09a1ecf85cfef52151a", + "name": "poetry", + "sha256": "8cefdf99b88fdaf2bf5ab22a6c8a2b629e6100d0e1d53ba72b403bf5a7b12837", + "size": 350388, + "subdir": "linux-64", + "timestamp": 1680193285231, + "version": "1.4.0" + }, + "poetry-1.4.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "cachecontrol-with-filecache >=0.12.9,<0.13.0" + ], + "depends": [ + "cachecontrol >=0.12.9,<0.13.0", + "cleo >=2.0.0,<3.0.0", + "crashtest >=0.4.1,<0.5.0", + "dulwich >=0.21.2,<0.22.0", + "filelock >=3.8.0", + "filelock >=3.8.0,<4.0.0", + "html5lib >=1.0,<2.0", + "jsonschema >=4.10.0,<5.0.0", + "keyring >=23.9.0,<24.0.0", + "lockfile >=0.12.2,<0.13.0", + "packaging >=20.4", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.9.4,<2.0", + "platformdirs >=2.5.2,<3.0.0", + "poetry-core 1.5.1.*", + "poetry-plugin-export >=1.3.0,<2.0.0", + "pyproject_hooks >=1.0.0,<2.0.0", + "python >=3.11,<3.12.0a0", + "python-build >=0.10.0,<0.11.0", + "python-installer >=0.6.0,<0.7.0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.11.0", + "shellingham >=1.5,<2.0", + "tomlkit >=0.11.1,<1.0.0,!=0.11.2,!=0.11.3", + "trove-classifiers >=2022.5.19", + "urllib3 >=1.26.0,<2.0.0", + "virtualenv >=20.4.3,<21.0.0,!=20.4.5,!=20.4.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "70f1b52eef26ae8c61a513eaad41399f", + "name": "poetry", + "sha256": "d982835574eccdeada59f4a0d295ed17b845a675a23709c6694c53957d315165", + "size": 470936, + "subdir": "linux-64", + "timestamp": 1680193213423, + "version": "1.4.0" + }, + "poetry-1.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "cachecontrol-with-filecache >=0.12.9,<0.13.0" + ], + "depends": [ + "cachecontrol >=0.12.9,<0.13.0", + "cleo >=2.0.0,<3.0.0", + "crashtest >=0.4.1,<0.5.0", + "dulwich >=0.21.2,<0.22.0", + "filelock >=3.8.0", + "filelock >=3.8.0,<4.0.0", + "html5lib >=1.0,<2.0", + "importlib-metadata >=4.4", + "jsonschema >=4.10.0,<5.0.0", + "keyring >=23.9.0,<24.0.0", + "lockfile >=0.12.2,<0.13.0", + "packaging >=20.4", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.9.4,<2.0", + "platformdirs >=2.5.2,<3.0.0", + "poetry-core 1.5.1.*", + "poetry-plugin-export >=1.3.0,<2.0.0", + "pyproject_hooks >=1.0.0,<2.0.0", + "python >=3.8,<3.9.0a0", + "python-build >=0.10.0,<0.11.0", + "python-installer >=0.6.0,<0.7.0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.11.0", + "shellingham >=1.5,<2.0", + "tomli >=2.0.1,<3.0.0", + "tomlkit >=0.11.1,<1.0.0,!=0.11.2,!=0.11.3", + "trove-classifiers >=2022.5.19", + "urllib3 >=1.26.0,<2.0.0", + "virtualenv >=20.4.3,<21.0.0,!=20.4.5,!=20.4.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4853023376ffa86aa244fd7448c478bf", + "name": "poetry", + "sha256": "2f1d4027f327dfb5309e35f469c88fe026709d86ff547ed3c03f607febcd1b01", + "size": 345567, + "subdir": "linux-64", + "timestamp": 1680193249495, + "version": "1.4.0" + }, + "poetry-1.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "cachecontrol-with-filecache >=0.12.9,<0.13.0" + ], + "depends": [ + "cachecontrol >=0.12.9,<0.13.0", + "cleo >=2.0.0,<3.0.0", + "crashtest >=0.4.1,<0.5.0", + "dulwich >=0.21.2,<0.22.0", + "filelock >=3.8.0", + "filelock >=3.8.0,<4.0.0", + "html5lib >=1.0,<2.0", + "importlib-metadata >=4.4", + "jsonschema >=4.10.0,<5.0.0", + "keyring >=23.9.0,<24.0.0", + "lockfile >=0.12.2,<0.13.0", + "packaging >=20.4", + "pexpect >=4.7.0,<5.0.0", + "pkginfo >=1.9.4,<2.0", + "platformdirs >=2.5.2,<3.0.0", + "poetry-core 1.5.1.*", + "poetry-plugin-export >=1.3.0,<2.0.0", + "pyproject_hooks >=1.0.0,<2.0.0", + "python >=3.9,<3.10.0a0", + "python-build >=0.10.0,<0.11.0", + "python-installer >=0.6.0,<0.7.0", + "requests >=2.18,<3.0", + "requests-toolbelt >=0.9.1,<0.11.0", + "shellingham >=1.5,<2.0", + "tomli >=2.0.1,<3.0.0", + "tomlkit >=0.11.1,<1.0.0,!=0.11.2,!=0.11.3", + "trove-classifiers >=2022.5.19", + "urllib3 >=1.26.0,<2.0.0", + "virtualenv >=20.4.3,<21.0.0,!=20.4.5,!=20.4.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f0c7b77b1c91cfd8e664bd1387ab1479", + "name": "poetry", + "sha256": "7cbc38ce7f68494a9a39d037347f60ef1021ed0f97fdbcdccff70f2122028763", + "size": 345821, + "subdir": "linux-64", + "timestamp": 1680193176329, + "version": "1.4.0" + }, + "poetry-core-1.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8b9d1029a6a3f2a5a0475c041be4c548", + "name": "poetry-core", + "sha256": "d5ad37496a615d8b86d49c214e142ae39676a97d4ceb000b80236e1ad9246d84", + "size": 837934, + "subdir": "linux-64", + "timestamp": 1670361555024, + "version": "1.4.0" + }, + "poetry-core-1.4.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a768e29af4c0f304848a4dac46e0822e", + "name": "poetry-core", + "sha256": "502795a4aedde024c5368ca431b08db61bc00ecf030f6565166ab26d63f810c2", + "size": 1069000, + "subdir": "linux-64", + "timestamp": 1676823085585, + "version": "1.4.0" + }, + "poetry-core-1.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata >=1.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e021422990f7e326bac9bc78bc20283", + "name": "poetry-core", + "sha256": "dbe390d6708a6898e8fa0d037537843c9b8a6c045322ba91b6b85613330cbf5d", + "size": 822821, + "subdir": "linux-64", + "timestamp": 1670361644259, + "version": "1.4.0" + }, + "poetry-core-1.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c18c0e4685ce811e61369e36829e114", + "name": "poetry-core", + "sha256": "0bcff28229b12ebccaeae8672bbd9823d565f1612c122691dca76b5cb8f959bd", + "size": 828150, + "subdir": "linux-64", + "timestamp": 1670361584444, + "version": "1.4.0" + }, + "poetry-core-1.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d58bc88aa50dc83a6e32b1316c05570", + "name": "poetry-core", + "sha256": "47c9d495504aba36da45ea315ecbfdc8a7754a5d61c403034ddc036d1691bc1e", + "size": 827470, + "subdir": "linux-64", + "timestamp": 1670361614193, + "version": "1.4.0" + }, + "poetry-core-1.5.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ccc291a34c50116f454385210a72ec3", + "name": "poetry-core", + "sha256": "640d29361cbac7dd01b16ac5039de112bb76fc18d64ba28162df239fc5abfa3d", + "size": 717729, + "subdir": "linux-64", + "timestamp": 1680018708577, + "version": "1.5.1" + }, + "poetry-core-1.5.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "755503273010e286a82ddacc12a0a248", + "name": "poetry-core", + "sha256": "bd3c2e43cf7d4550d9cc18eda6e0038030866523b9e550aac5c4f83c2d68c65c", + "size": 949998, + "subdir": "linux-64", + "timestamp": 1680018678812, + "version": "1.5.1" + }, + "poetry-core-1.5.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4c7225598a7434855a2f9f460bcc7a7", + "name": "poetry-core", + "sha256": "90e8832e9f0857b94704dd192b51e5fe6fb9a2c5d2f9411690a34448689a56ec", + "size": 708808, + "subdir": "linux-64", + "timestamp": 1680018737763, + "version": "1.5.1" + }, + "poetry-core-1.5.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fbbd9b1b88a07f7f39ab9752f480ebc2", + "name": "poetry-core", + "sha256": "27731a9129c171a9794d3272a90f43de47ec345a4aa6fb72b66bc5a887efa1aa", + "size": 706816, + "subdir": "linux-64", + "timestamp": 1680018766098, + "version": "1.5.1" + }, + "poetry-core-1.5.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "079754fdd1cca387b03ce55839946559", + "name": "poetry-core", + "sha256": "3871baebdbc2d89264706a42bac3e53c69f9a23a850f2fa8b95d854a8e475224", + "size": 717804, + "subdir": "linux-64", + "timestamp": 1678914396360, + "version": "1.5.2" + }, + "poetry-core-1.5.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "759ed4920999300715854d1e85c64cca", + "name": "poetry-core", + "sha256": "49c70f39b1baaa8a09b27ee4b0cd19a5ca172010ced7a6a39e206556e4a40ed2", + "size": 952358, + "subdir": "linux-64", + "timestamp": 1678914427188, + "version": "1.5.2" + }, + "poetry-core-1.5.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "565e45a6ffa51298e805e86f973016c1", + "name": "poetry-core", + "sha256": "a19dd9a3dc61fc8ca723d2834f0af54ab27a3f78414bed2ebd5689783acda532", + "size": 708403, + "subdir": "linux-64", + "timestamp": 1678914365915, + "version": "1.5.2" + }, + "poetry-core-1.5.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "163ce8fcd446e90a455d0247952b6fcd", + "name": "poetry-core", + "sha256": "55dceac7caa9b0c815215dd856feae09759baf89598e18d9c278560279272b7c", + "size": 707327, + "subdir": "linux-64", + "timestamp": 1678914335881, + "version": "1.5.2" + }, + "poetry-plugin-export-1.3.0-py310h4849bfd_0.conda": { + "build": "py310h4849bfd_0", + "build_number": 0, + "constrains": [ + "poetry >=1.3.0,<2.0.0" + ], + "depends": [ + "poetry-core >=1.3.0,<2.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "824a7fdf5bac436523ba62d682158504", + "name": "poetry-plugin-export", + "sha256": "c7368d6131375191b5c4d5efeb5fc016afe39ec94d99327ce3c289abc1816d4d", + "size": 22835, + "subdir": "linux-64", + "timestamp": 1680122890921, + "version": "1.3.0" + }, + "poetry-plugin-export-1.3.0-py311h4849bfd_0.conda": { + "build": "py311h4849bfd_0", + "build_number": 0, + "constrains": [ + "poetry >=1.3.0,<2.0.0" + ], + "depends": [ + "poetry-core >=1.3.0,<2.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "405e8dddcdba3ca09bf5f1404a459f75", + "name": "poetry-plugin-export", + "sha256": "af727d2c16d6b077fc7c8dd74e17ca118131ae4fb736ed2272b9e856ecb554d8", + "size": 27612, + "subdir": "linux-64", + "timestamp": 1680122815077, + "version": "1.3.0" + }, + "poetry-plugin-export-1.3.0-py38h4849bfd_0.conda": { + "build": "py38h4849bfd_0", + "build_number": 0, + "constrains": [ + "poetry >=1.3.0,<2.0.0" + ], + "depends": [ + "poetry-core >=1.3.0,<2.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "559b5172133ea60f55c390d6cd999928", + "name": "poetry-plugin-export", + "sha256": "cf4a47e9e8e5ff8c074ec8c82c750c76b44acae437cbd37cdafc15cc03fd5fb8", + "size": 22730, + "subdir": "linux-64", + "timestamp": 1680122865048, + "version": "1.3.0" + }, + "poetry-plugin-export-1.3.0-py39h4849bfd_0.conda": { + "build": "py39h4849bfd_0", + "build_number": 0, + "constrains": [ + "poetry >=1.3.0,<2.0.0" + ], + "depends": [ + "poetry-core >=1.3.0,<2.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc1258ec1be5a6a7239162e9fede7815", + "name": "poetry-plugin-export", + "sha256": "04e36c5d1b99d26641336cececd55b1aa168128a8c7b137bda4a7496d363dffa", + "size": 22649, + "subdir": "linux-64", + "timestamp": 1680122839548, + "version": "1.3.0" + }, + "pomegranate-0.10.0-py27hdd07704_0.conda": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6428ecfb5bd125d8852db2b6761fcd98", + "name": "pomegranate", + "sha256": "a1c64af839ebb752e32cee40011876fab65da156ee73d4c972b682069ebd75ea", + "size": 2177761, + "subdir": "linux-64", + "timestamp": 1536116473216, + "version": "0.10.0" + }, + "pomegranate-0.10.0-py35hdd07704_0.conda": { + "build": "py35hdd07704_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "pyyaml", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34f4cfcf60d35b7c8d06eab89f9f2958", + "name": "pomegranate", + "sha256": "8f84f27c28bb715f1653895bf24d34cfe844c53837bc66c198b13b5bff9157a2", + "size": 2155033, + "subdir": "linux-64", + "timestamp": 1536116445794, + "version": "0.10.0" + }, + "pomegranate-0.10.0-py36hdd07704_0.conda": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66c5f074c5abd2e9e4483256e04eae5f", + "name": "pomegranate", + "sha256": "0fff97015b89a82f6e6b416cb144febc4e07b4a58458ee33e20766ddf4c3b46b", + "size": 2197730, + "subdir": "linux-64", + "timestamp": 1536116475560, + "version": "0.10.0" + }, + "pomegranate-0.10.0-py37hdd07704_0.conda": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1000f9e97132311746190d825b94fe23", + "name": "pomegranate", + "sha256": "cc44e31aee4b950f6db74c21e9ec974fa30e237af3f42008709f63a6dcea4063", + "size": 2184681, + "subdir": "linux-64", + "timestamp": 1536116473928, + "version": "0.10.0" + }, + "pomegranate-0.11.0-py27hdd07704_0.conda": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f1686f2371167dc7e3951455587f8b3", + "name": "pomegranate", + "sha256": "cdc1f46f01cead8d36b092bd894777eb90abecb7a5e72438ddbf45e6d08a97fd", + "size": 2299256, + "subdir": "linux-64", + "timestamp": 1568318232726, + "version": "0.11.0" + }, + "pomegranate-0.11.0-py36hdd07704_0.conda": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3cc26bf0ab0846fe9ba2109d5fa59b1a", + "name": "pomegranate", + "sha256": "19e99c8c1a649833f665e446816b63fc973fa704f7557e0edcccdae76c1bf98b", + "size": 2346229, + "subdir": "linux-64", + "timestamp": 1568318234780, + "version": "0.11.0" + }, + "pomegranate-0.11.0-py37hdd07704_0.conda": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2bccff641ef5ff14168daafd2c3576d5", + "name": "pomegranate", + "sha256": "2e7bddd94d6d64ac22c990e8d1ef8f13669440c5dcd83a64cc2473af80b8ee99", + "size": 2338036, + "subdir": "linux-64", + "timestamp": 1568318240636, + "version": "0.11.0" + }, + "pomegranate-0.11.1-py27ha516724_0.conda": { + "build": "py27ha516724_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7efe44d38fc143ab6332acd2215afd93", + "name": "pomegranate", + "sha256": "1bc0e65891bb046b00b4d2b6219845c1721e9fbad7f1db2ef9d10421e7e044d9", + "size": 2163169, + "subdir": "linux-64", + "timestamp": 1569434642545, + "version": "0.11.1" + }, + "pomegranate-0.11.1-py36ha516724_0.conda": { + "build": "py36ha516724_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb24b06bb669b59cebda237fd0e5f382", + "name": "pomegranate", + "sha256": "c30ef849378d2db470104e3afebfa37d24e98b14bdc8be5626149934cb30b9e7", + "size": 2207123, + "subdir": "linux-64", + "timestamp": 1569434544641, + "version": "0.11.1" + }, + "pomegranate-0.11.1-py37ha516724_0.conda": { + "build": "py37ha516724_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba8b76193c6028e27343072cbc2d6762", + "name": "pomegranate", + "sha256": "81adcb192639e0d74f4319ef7c164ef1a4e300f80311a3c9a824c87ab39ff3ca", + "size": 2201291, + "subdir": "linux-64", + "timestamp": 1569434595092, + "version": "0.11.1" + }, + "pomegranate-0.11.1-py38ha516724_0.conda": { + "build": "py38ha516724_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39c9f212bf1fa3b0711e14a0c71e0844", + "name": "pomegranate", + "sha256": "e3e61095b311464f17a6683915d572d2d1454e302c09b0e54b20b01be88433cd", + "size": 2314490, + "subdir": "linux-64", + "timestamp": 1574170213594, + "version": "0.11.1" + }, + "pomegranate-0.13.4-py36ha516724_0.conda": { + "build": "py36ha516724_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8147d81db7bb0bfed194efcf91bca608", + "name": "pomegranate", + "sha256": "0c92b5ddbdea51ec6c9ffb79ff9147fd6a3c38ac016a348c15b293ce5a8e1238", + "size": 2111833, + "subdir": "linux-64", + "timestamp": 1601588027865, + "version": "0.13.4" + }, + "pomegranate-0.13.4-py37ha516724_0.conda": { + "build": "py37ha516724_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "42c7382ec781c85340849233a5f6c1f5", + "name": "pomegranate", + "sha256": "e637d4fbcf05a34041ea3c7f171d41043fa4fdbba0e105f7f7e04d2c995b5499", + "size": 2105762, + "subdir": "linux-64", + "timestamp": 1601587983253, + "version": "0.13.4" + }, + "pomegranate-0.13.4-py38ha516724_0.conda": { + "build": "py38ha516724_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02b1834a4ac8cb03ec5dcea949884c84", + "name": "pomegranate", + "sha256": "62a77a0b03d5de5350ccc4926dca6c32dba7807e4c249d6db0adea0b65ce0f84", + "size": 2237266, + "subdir": "linux-64", + "timestamp": 1601587987653, + "version": "0.13.4" + }, + "pomegranate-0.13.5-py36ha3f3c68_0.conda": { + "build": "py36ha3f3c68_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "04fb132e539a2fbe0598de55e33104ff", + "name": "pomegranate", + "sha256": "fb0e691006fcdb9d60d9042f3692aa098895bc64d90830ca298b70ec09346ffc", + "size": 2390147, + "subdir": "linux-64", + "timestamp": 1602607112015, + "version": "0.13.5" + }, + "pomegranate-0.13.5-py37ha3f3c68_0.conda": { + "build": "py37ha3f3c68_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e00018a802e3cb79875e5f42b296e111", + "name": "pomegranate", + "sha256": "4fd46c3630866dc781243a36b0c6b49e0775f6ec651c87f5e4b7ed2bf1a87c63", + "size": 2380472, + "subdir": "linux-64", + "timestamp": 1602607107495, + "version": "0.13.5" + }, + "pomegranate-0.13.5-py38ha3f3c68_0.conda": { + "build": "py38ha3f3c68_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "afb20db7fb13254fb1983933c149cd41", + "name": "pomegranate", + "sha256": "a03a7767c43639a831568468a39d84eba132f49b22261d0724ebfb9f466a9300", + "size": 2527138, + "subdir": "linux-64", + "timestamp": 1602607093132, + "version": "0.13.5" + }, + "pomegranate-0.14.0-py36h9a67853_0.conda": { + "build": "py36h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4758e9407aa52483c768342bec467224", + "name": "pomegranate", + "sha256": "c57f21ff26550c6584887b032bd9aa92109e7f52247eb1a57e19a9f564b0fa0e", + "size": 2650873, + "subdir": "linux-64", + "timestamp": 1612291602750, + "version": "0.14.0" + }, + "pomegranate-0.14.0-py37h9a67853_0.conda": { + "build": "py37h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e3c923c064404ce02f504e5a43b64860", + "name": "pomegranate", + "sha256": "a568f7d06c71971dbed7c0bbfd2baa948d7292e173a5d5aeae068ad2b1c8e673", + "size": 2653172, + "subdir": "linux-64", + "timestamp": 1612292128943, + "version": "0.14.0" + }, + "pomegranate-0.14.0-py38h9a67853_0.conda": { + "build": "py38h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2788edd6adb281e5bf6cc493c784948b", + "name": "pomegranate", + "sha256": "f07bcc86b3f2febae81a7796c19a437d272659e2c10783b8421561e34b39ebec", + "size": 2800431, + "subdir": "linux-64", + "timestamp": 1612293197670, + "version": "0.14.0" + }, + "pomegranate-0.14.0-py39h9a67853_0.conda": { + "build": "py39h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f06e9b69114dce9b6e2f06a8fbc71028", + "name": "pomegranate", + "sha256": "f19e5809002af74cbd82670a1f4ad3791d5def150e14c90f47e524e0b4a99bca", + "size": 2799423, + "subdir": "linux-64", + "timestamp": 1612293235746, + "version": "0.14.0" + }, + "pomegranate-0.14.2-py36h9a67853_0.conda": { + "build": "py36h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "469f5b76cd22d5b42d5d7306c02f19d9", + "name": "pomegranate", + "sha256": "b37a13a31221e6e95e0e83446ba14f7784bc572e949f50da112e677ecb7860ce", + "size": 2693835, + "subdir": "linux-64", + "timestamp": 1613765768126, + "version": "0.14.2" + }, + "pomegranate-0.14.2-py37h9a67853_0.conda": { + "build": "py37h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a4bcde852c2849e36e9bf20373604d55", + "name": "pomegranate", + "sha256": "e58d4f0c903d97085834def17f9c79d728b02d90fbee45dc1909d5448bda9553", + "size": 2690393, + "subdir": "linux-64", + "timestamp": 1613764974006, + "version": "0.14.2" + }, + "pomegranate-0.14.2-py38h9a67853_0.conda": { + "build": "py38h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "655d81b8e6c1b3f8b197cd859de8fc68", + "name": "pomegranate", + "sha256": "494649ec33033f3648ac40f029a11c46b3a1bc350e1a8bcf6da3bd0ea4f9c2e8", + "size": 2838179, + "subdir": "linux-64", + "timestamp": 1613765769950, + "version": "0.14.2" + }, + "pomegranate-0.14.2-py39h9a67853_0.conda": { + "build": "py39h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7682e5358e1f9baabf1a3fd58254c134", + "name": "pomegranate", + "sha256": "da025bd2752f7bc59f360e81f155d4a941fc8b928319d4a203cd349bca09452f", + "size": 2832690, + "subdir": "linux-64", + "timestamp": 1613765784078, + "version": "0.14.2" + }, + "pomegranate-0.14.3-py310h2571103_0.conda": { + "build": "py310h2571103_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c8ff4217e89d09cbc566ff935ac3e2ed", + "name": "pomegranate", + "sha256": "1f99728c9a0dada3ec0b32fbf9430a58f08da6e780b44734b9bd3e6776076e36", + "size": 9068931, + "subdir": "linux-64", + "timestamp": 1641556985679, + "version": "0.14.3" + }, + "pomegranate-0.14.3-py36h9a67853_0.conda": { + "build": "py36h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc91b187de9f5bd23860fc5ac9f2105c", + "name": "pomegranate", + "sha256": "6620d94662dbd0b7533b81ccc5a67f3bbff0cb4b121dfbc07716224b2f066fd6", + "size": 2524400, + "subdir": "linux-64", + "timestamp": 1616184157204, + "version": "0.14.3" + }, + "pomegranate-0.14.3-py37h9a67853_0.conda": { + "build": "py37h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e5300a185943b9b47ce1e53ab55a482d", + "name": "pomegranate", + "sha256": "d7b7e6b8d7b98789621df96d961c67ef64b10f46fb1a542e0d81d8d5db7be32f", + "size": 2520195, + "subdir": "linux-64", + "timestamp": 1616182162144, + "version": "0.14.3" + }, + "pomegranate-0.14.3-py38h9a67853_0.conda": { + "build": "py38h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8894ff5b0ec084ae495c618a9e16a117", + "name": "pomegranate", + "sha256": "79a462504abd0bc976329e41bced8cef4701d3efaf2841978f4b2789d1a6779c", + "size": 2657896, + "subdir": "linux-64", + "timestamp": 1616183276077, + "version": "0.14.3" + }, + "pomegranate-0.14.3-py39h9a67853_0.conda": { + "build": "py39h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96ce1968d67419aa84b676d14aebc2d0", + "name": "pomegranate", + "sha256": "79f297ebed116e1b2ba32b4188c61b029bad0b700e92787a12fb272b4e921b85", + "size": 2666492, + "subdir": "linux-64", + "timestamp": 1616183271653, + "version": "0.14.3" + }, + "pomegranate-0.14.4-py36h9a67853_0.conda": { + "build": "py36h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "637941cde071fccaeeef0bc99cf6e944", + "name": "pomegranate", + "sha256": "6e96bae16e8e2612758c6e2cbeb048cf59ca650073571b478ce59c1a0c8b61f6", + "size": 2520303, + "subdir": "linux-64", + "timestamp": 1617209185554, + "version": "0.14.4" + }, + "pomegranate-0.14.4-py37h9a67853_0.conda": { + "build": "py37h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4daa6090e96781cf500113a42c054485", + "name": "pomegranate", + "sha256": "116656a58159eb3ce6ee64aac061b2d3deb6d9885cd72bf717e3804e703423ce", + "size": 2502682, + "subdir": "linux-64", + "timestamp": 1617211452363, + "version": "0.14.4" + }, + "pomegranate-0.14.4-py38h9a67853_0.conda": { + "build": "py38h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f24a764d0dc6912ad041a01080729d70", + "name": "pomegranate", + "sha256": "bf186b926b7ab2ab7cba5a3bba5b5e1bd98c03e979b3796eb2829fbd50f411f7", + "size": 2629631, + "subdir": "linux-64", + "timestamp": 1617211685298, + "version": "0.14.4" + }, + "pomegranate-0.14.4-py39h9a67853_0.conda": { + "build": "py39h9a67853_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "scipy >=0.17.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "936c18dd637a62ca51183607c022cce5", + "name": "pomegranate", + "sha256": "16a54c127e0574c0bf5080e97bed90b9d7b673708a0bbc4d8aea29807ee456ad", + "size": 2639848, + "subdir": "linux-64", + "timestamp": 1617211699378, + "version": "0.14.4" + }, + "pomegranate-0.8.0-py27h0eee2d8_0.conda": { + "build": "py27h0eee2d8_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c9efd52c335fdd226a53fd0991703add", + "name": "pomegranate", + "sha256": "c10b155cba227d25539ab98a1ad574bbde5009771b8025b0293aa50a27ff20fe", + "size": 2086229, + "subdir": "linux-64", + "timestamp": 1508967527450, + "version": "0.8.0" + }, + "pomegranate-0.8.0-py35hef112b0_0.conda": { + "build": "py35hef112b0_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ed0ef226c7118d3afd16839773a8b319", + "name": "pomegranate", + "sha256": "41bc77aeb254c164d955d32b8b706ad3dfbfe87c777a983c6fbfbaa4ef8ada8e", + "size": 2042489, + "subdir": "linux-64", + "timestamp": 1508967660421, + "version": "0.8.0" + }, + "pomegranate-0.8.0-py36ha26ad33_0.conda": { + "build": "py36ha26ad33_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f81c53c6e87273e22ac22ea69066fd12", + "name": "pomegranate", + "sha256": "50f88684f0bc98a4e02b578842d5400a92a2163b305d9a63166311418cd10f26", + "size": 2082306, + "subdir": "linux-64", + "timestamp": 1508967670885, + "version": "0.8.0" + }, + "pomegranate-0.8.1-py27h8df36fd_0.conda": { + "build": "py27h8df36fd_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "68bbb251ea3e7e2cd5bae17cc5cf8c6e", + "name": "pomegranate", + "sha256": "5899018568f0cdb6954d8cef78bc28285ff0859f2548809a8ba5746e87ca1b74", + "size": 2036213, + "subdir": "linux-64", + "timestamp": 1511844799955, + "version": "0.8.1" + }, + "pomegranate-0.8.1-py35h5d3529e_0.conda": { + "build": "py35h5d3529e_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4c9ee946cec81d8dbc5c499970cbce1e", + "name": "pomegranate", + "sha256": "32857959fab0c652f4fe135e9978210fa697d13e21e0465297d3aca6d53ab422", + "size": 1987687, + "subdir": "linux-64", + "timestamp": 1511844795628, + "version": "0.8.1" + }, + "pomegranate-0.8.1-py36h0cb749a_0.conda": { + "build": "py36h0cb749a_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1b874f8246113d231353ad1318f2f11", + "name": "pomegranate", + "sha256": "e8420331d0aa374c326a633c673612e5d026a0a8b71a86e061741cbd93b15743", + "size": 2026128, + "subdir": "linux-64", + "timestamp": 1511844718798, + "version": "0.8.1" + }, + "pomegranate-0.9.0-py27h035aef0_0.conda": { + "build": "py27h035aef0_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9833677e479d201308176cf21a7d1c1", + "name": "pomegranate", + "sha256": "41c6cfd7a20636582f0c9a0cf65bc6a1724d7b7118fbd7a03081d7ee2471c383", + "size": 2087042, + "subdir": "linux-64", + "timestamp": 1530905437733, + "version": "0.9.0" + }, + "pomegranate-0.9.0-py27h3010b51_0.conda": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "434e3a949f0274c61014bcc2e24e201f", + "name": "pomegranate", + "sha256": "ea87addbe151cd9d320ae7ae306ed3fee13a8c1181ef4d1c41222f83d1ee9580", + "size": 2101102, + "subdir": "linux-64", + "timestamp": 1519365663091, + "version": "0.9.0" + }, + "pomegranate-0.9.0-py35h3010b51_0.conda": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.14.1,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18646a0b54edc179bfcdae4410646bb0", + "name": "pomegranate", + "sha256": "ef0a4945868caa22870f8a870d5ea2c56e331590ea3e2eef7d7ef838e4669554", + "size": 2059178, + "subdir": "linux-64", + "timestamp": 1519365598539, + "version": "0.9.0" + }, + "pomegranate-0.9.0-py36h035aef0_0.conda": { + "build": "py36h035aef0_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f131b70660c496df42fb1d38e8c0b19", + "name": "pomegranate", + "sha256": "9ce068112f9eaa416614e87285bca8416f5186b6ea3b221090c8bd3f587e2506", + "size": 2096526, + "subdir": "linux-64", + "timestamp": 1530905654528, + "version": "0.9.0" + }, + "pomegranate-0.9.0-py36h3010b51_0.conda": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8865fb60cb259ca50efce0045cf92843", + "name": "pomegranate", + "sha256": "a1814e30926af3237b0f06f2b6373660e563a758932b69a68d11a60c0b68941a", + "size": 2103642, + "subdir": "linux-64", + "timestamp": 1519365530525, + "version": "0.9.0" + }, + "pomegranate-0.9.0-py37h035aef0_0.conda": { + "build": "py37h035aef0_0", + "build_number": 0, + "depends": [ + "joblib >=0.9.0b4", + "libgcc-ng >=7.2.0", + "networkx >=1.8.1,<2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.17.0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0d3b326faccebce5e8d3f6aa9abc83a", + "name": "pomegranate", + "sha256": "ad34ff68c13af876e3ee54f784f5a2367c3cae2be168d0dc4cd33e1ef75c6db7", + "size": 2085972, + "subdir": "linux-64", + "timestamp": 1530905868584, + "version": "0.9.0" + }, + "poppler-0.60.1-hc909a00_0.conda": { + "build": "hc909a00_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.10,<2.0a0", + "curl", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.8,<5.0a0", + "libxcb >=1.12,<2.0a0", + "openjpeg >=2.2.0,<3.0a0", + "poppler-data >=0.4.8", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPLv2", + "license_family": "GPL", + "md5": "909489c8553aaba4cb526eecb85ade82", + "name": "poppler", + "sha256": "01caeec5543793988c78b9849f2cd15b5653c88b95f54bfe3b1928e4d8c4ee9c", + "size": 5250144, + "subdir": "linux-64", + "timestamp": 1507908143347, + "version": "0.60.1" + }, + "poppler-0.65.0-h581218d_1.conda": { + "build": "h581218d_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.1,<3.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxcb >=1.13,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "poppler-data >=0.4.9", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPLv2", + "license_family": "GPL", + "md5": "3ff27d06ad341019b198f813c503bc9b", + "name": "poppler", + "sha256": "e28473c69bc3bc48a77555fd38a78dc961fb39739b8b5357a44212e74dd39f5d", + "size": 1390907, + "subdir": "linux-64", + "timestamp": 1527261451326, + "version": "0.65.0" + }, + "poppler-0.65.0-ha54bb34_0.conda": { + "build": "ha54bb34_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.12.6,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.56.1,<3.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxcb >=1.13,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "poppler-data >=0.4.9", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPLv2", + "license_family": "GPL", + "md5": "fc3314a54df6d47ada5749c4166c4738", + "name": "poppler", + "sha256": "b0bc7cc4c7a80dfe9f5cd50a0139d7a1a1b61116a917257d88f282cf68dd03c2", + "size": 1393939, + "subdir": "linux-64", + "timestamp": 1527192438417, + "version": "0.65.0" + }, + "poppler-0.81.0-h01f5e8b_2.conda": { + "build": "h01f5e8b_2", + "build_number": 2, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "curl", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.68.2,<3.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "openjpeg >=2.3.0,<3.0a0", + "poppler-data", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPLv2", + "license_family": "GPL", + "md5": "a7f0680bd2a0ac63c1a44724039b5989", + "name": "poppler", + "sha256": "fd7d8022f2a4b56a002277901dba668495e2e123ba2d80f59f1e5b84b7cfdc4a", + "size": 9631696, + "subdir": "linux-64", + "timestamp": 1623340073756, + "version": "0.81.0" + }, + "poppler-0.81.0-ha7185a5_2.conda": { + "build": "ha7185a5_2", + "build_number": 2, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "curl", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.65.0,<3.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "openjpeg >=2.3.0,<3.0a0", + "poppler-data", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPLv2", + "license_family": "GPL", + "md5": "fea3edd45a174a4d1c32e0044d837d63", + "name": "poppler", + "sha256": "eea253426600f237464888f6aa9f70e05f0646ca22bced90f5dbecd9eb6c1ae2", + "size": 9573421, + "subdir": "linux-64", + "timestamp": 1622310181985, + "version": "0.81.0" + }, + "poppler-0.81.0-he6a58d2_1.conda": { + "build": "he6a58d2_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "curl", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.10.2,<3.0a0", + "glib >=2.65.0,<3.0a0", + "jpeg >=9b,<10a", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "libxcb >=1.14,<2.0a0", + "openjpeg >=2.3.0,<3.0a0", + "poppler-data", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPLv2", + "license_family": "GPL", + "md5": "ccc48cbaa7f685982354351fd99087ad", + "name": "poppler", + "sha256": "c6dcf2fecaf2381147d06cde02653757ff3d37c8d17747e3e95bba46ff3e7e80", + "size": 9389855, + "subdir": "linux-64", + "timestamp": 1597158499539, + "version": "0.81.0" + }, + "poppler-21.11.0-h9f6c795_0.conda": { + "build": "h9f6c795_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "curl", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "jpeg >=9d,<10a", + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "openjpeg >=2.4.0,<3.0a0", + "poppler-data", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPLv2", + "license_family": "GPL", + "md5": "eb16c85f2a0c26aa411d335c77eba7e3", + "name": "poppler", + "sha256": "78849a24c5561ecc6d3fdf23dba1f3e56ec41b3977abcd4ee733bc8f350655a8", + "size": 10730035, + "subdir": "linux-64", + "timestamp": 1643108724400, + "version": "21.11.0" + }, + "poppler-22.12.0-h381b16e_0.conda": { + "build": "h381b16e_0", + "build_number": 0, + "depends": [ + "boost-cpp >=1.73.0,<2.0a0", + "cairo >=1.16.0,<2.0a0", + "fontconfig >=2.14.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libcurl >=7.86.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libiconv >=1.16,<2.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "nspr >=4.33,<5.0a0", + "nss >=3.74,<4.0a0", + "openjpeg >=2.3.0,<3.0a0", + "poppler-data", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-only", + "license_family": "GPL", + "md5": "113a6c2696d699a23460a0a76d0dac26", + "name": "poppler", + "sha256": "f783f47cb4fb041f3a3e8d1c6117d6d5db5a4523df5cad780e2aeb82684ceb64", + "size": 18104047, + "subdir": "linux-64", + "timestamp": 1674032114468, + "version": "22.12.0" + }, + "poppler-data-0.4.10-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "Adobe+GPLv2", + "license_family": "GPL", + "md5": "13fa7d3d7d75723268bb0bf2137ae17a", + "name": "poppler-data", + "sha256": "965825853f0133a5b1091c4f4eb505ccc63eaab272d6dbb8e90bc3c409f0210c", + "size": 2197373, + "subdir": "linux-64", + "timestamp": 1603822302896, + "version": "0.4.10" + }, + "poppler-data-0.4.11-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "GPL-2.0-or-later and GPL-3.0-or-later and BSD-3-Clause", + "license_family": "GPL", + "md5": "8e84a8383b919274915f7729a3558905", + "name": "poppler-data", + "sha256": "ea6a6e053b51c197f0412d79e46d58cd4a92fabe52cdfaba6d3488638d86d1d5", + "size": 2190040, + "subdir": "linux-64", + "timestamp": 1644332583277, + "version": "0.4.11" + }, + "poppler-data-0.4.11-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "GPL-2.0-or-later and GPL-3.0-or-later and BSD-3-Clause", + "license_family": "GPL", + "md5": "fd6d432aa8fcef7896c9fbe683fea831", + "name": "poppler-data", + "sha256": "417522f742f2875501951d39cacbc03b33b387ae84ff0b6e7f24cfac47642b86", + "size": 2684993, + "subdir": "linux-64", + "timestamp": 1673863550016, + "version": "0.4.11" + }, + "poppler-data-0.4.8-hf2eda46_0.conda": { + "build": "hf2eda46_0", + "build_number": 0, + "depends": [], + "license": "Adobe+GPLv2", + "license_family": "GPL", + "md5": "9f4cd956b0f866a38f844e657e60cbe8", + "name": "poppler-data", + "sha256": "9d8990ea582bfe4d65057afcb36b0ee630a5ea3fdc621fc08b8f762846abbebd", + "size": 2014467, + "subdir": "linux-64", + "timestamp": 1507908048306, + "version": "0.4.8" + }, + "poppler-data-0.4.9-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "Adobe+GPLv2", + "license_family": "GPL", + "md5": "0e75419f83b679dac9fa4e832f75fc93", + "name": "poppler-data", + "sha256": "0fdb5f020a10010f82eeaa223842350a7d77f27ec327aa00ebb2310a48363c9d", + "size": 1985347, + "subdir": "linux-64", + "timestamp": 1527172404757, + "version": "0.4.9" + }, + "poppler-qt-22.12.0-h381b16e_0.conda": { + "build": "h381b16e_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "fontconfig >=2.14.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "jpeg >=9e,<10a", + "lcms2 >=2.12,<3.0a0", + "libcurl >=7.86.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libiconv >=1.16,<2.0a0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtiff >=4.1.0,<5.0a0", + "nspr >=4.33,<5.0a0", + "nss >=3.74,<4.0a0", + "openjpeg >=2.3.0,<3.0a0", + "poppler 22.12.0 h381b16e_0", + "qt-main >=5.15.2,<5.16.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-only", + "license_family": "GPL", + "md5": "690e2761dad81d42daf80f00825e8337", + "name": "poppler-qt", + "sha256": "c4cef363a9b2d80b58ab600c1f21a5afc43171405af24122714df4f5a61814ba", + "size": 5145983, + "subdir": "linux-64", + "timestamp": 1674032167087, + "version": "22.12.0" + }, + "portalocker-1.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "34e869008f7adf32fef260b649e06552", + "name": "portalocker", + "sha256": "028ea32f07b4ac6da261a737cf4a82e304cfc6b3da1fbe3ecaf20a80a9ff6732", + "size": 19578, + "subdir": "linux-64", + "timestamp": 1569509988703, + "version": "1.5.1" + }, + "portalocker-1.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "61fa6237d206c14d2287ae4f7f34d65c", + "name": "portalocker", + "sha256": "fb13d52c6c369537dec24167bda44d96a5b364f072973da5a16801af840d27b8", + "size": 19643, + "subdir": "linux-64", + "timestamp": 1569509984982, + "version": "1.5.1" + }, + "portalocker-1.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "2f397bbd40a3b281046e8405a5b1eaec", + "name": "portalocker", + "sha256": "ae9bf93b9b91c7efc04979b86cc36449f283622788343859800b84d685b5f39a", + "size": 19651, + "subdir": "linux-64", + "timestamp": 1569509989315, + "version": "1.5.1" + }, + "portalocker-1.5.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "0359026ee6601f9a6290fa8b4a1ccda8", + "name": "portalocker", + "sha256": "8f655a8110452e81f906d43f06f7adc537ae08fe49d719105059192a5f6f8dd8", + "size": 19964, + "subdir": "linux-64", + "timestamp": 1574370831513, + "version": "1.5.2" + }, + "portalocker-1.5.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "becf7d2d4581814c138bd43d07355ef5", + "name": "portalocker", + "sha256": "ce6c6fba3cc3260869982e46ec1037b3d67db3b2338cd2b1dc34dd6880047a45", + "size": 20040, + "subdir": "linux-64", + "timestamp": 1574370802801, + "version": "1.5.2" + }, + "portalocker-1.5.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "4c27d962012cf68fe358a10945b04041", + "name": "portalocker", + "sha256": "5b9dba0dadcbb378e58297b7300419d8da55e16ba42b48d7f2fcb6eb5170aa61", + "size": 20059, + "subdir": "linux-64", + "timestamp": 1574370851107, + "version": "1.5.2" + }, + "portalocker-1.5.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "1d8e466c1ab84103530a028d5de7671b", + "name": "portalocker", + "sha256": "55ba5b4fcbf5db0b780a10ccc2815e65e2d692ea5d321fab3204e4ccfffa2103", + "size": 20123, + "subdir": "linux-64", + "timestamp": 1574370890943, + "version": "1.5.2" + }, + "portalocker-1.7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "c59d283c5942bfe7a7d6030c8e5377c6", + "name": "portalocker", + "sha256": "65bc89389e378fcb8f02d4693b8944725d4033f716e3ac7b3754e1caa7cfd971", + "size": 19139, + "subdir": "linux-64", + "timestamp": 1596941269669, + "version": "1.7.0" + }, + "portalocker-1.7.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "871e82b5656b44354f55746f8be3a9ca", + "name": "portalocker", + "sha256": "cb6a145068034fcd69ed69c066c36f0f40f6314102453fad39188526a371a084", + "size": 23263, + "subdir": "linux-64", + "timestamp": 1596476623649, + "version": "1.7.1" + }, + "portalocker-1.7.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "742e0ce0cfad2c0bd80a166978a6013c", + "name": "portalocker", + "sha256": "6eeab575b9cbb040725ac1c003e78555c852c5a38c8b734768b1f6490827320f", + "size": 23187, + "subdir": "linux-64", + "timestamp": 1596576521174, + "version": "1.7.1" + }, + "portalocker-1.7.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "ea96dbd9bd942bec9ff2bacf5cce979e", + "name": "portalocker", + "sha256": "0f00ef1154998be11e521ccc04eb7828402906a91a865f6846ba5c4397e744f1", + "size": 23377, + "subdir": "linux-64", + "timestamp": 1596576539542, + "version": "1.7.1" + }, + "portalocker-2.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "010e4df1e029f7bcb5b17e3a943eec4c", + "name": "portalocker", + "sha256": "1088900142056e78d00eacca02954ebb0984045e387c6b3ef8d673b7a3f998e7", + "size": 25412, + "subdir": "linux-64", + "timestamp": 1597348445279, + "version": "2.0.0" + }, + "portalocker-2.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "233f93d52ab62b6ef3d4e57d577a3a52", + "name": "portalocker", + "sha256": "a323e7e2978a9a45f205128142f2f004921188233dba7023c5d438b90d29dfc1", + "size": 25409, + "subdir": "linux-64", + "timestamp": 1597348442837, + "version": "2.0.0" + }, + "portalocker-2.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "87601c49b5311696f75b7f83b3d230fa", + "name": "portalocker", + "sha256": "0a57e0da2eb3f8b2c70fc94253bd92907151f64a571af508e8ea1e89975d60dd", + "size": 25401, + "subdir": "linux-64", + "timestamp": 1597348450297, + "version": "2.0.0" + }, + "portalocker-2.1.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "b311e2751f5633b90e9a5603f28b5748", + "name": "portalocker", + "sha256": "de32eac89fc10dde45360af837d0d5cdaa27f65211acb234cc3a27900024faef", + "size": 25440, + "subdir": "linux-64", + "timestamp": 1611516841364, + "version": "2.1.0" + }, + "portalocker-2.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "d4064a3b84a9c068a12561239f5c5bd7", + "name": "portalocker", + "sha256": "4472b61867085087baf36a8693b23dbae9898d8ad035be7d2d7778c52f24f2c5", + "size": 25454, + "subdir": "linux-64", + "timestamp": 1611516804532, + "version": "2.1.0" + }, + "portalocker-2.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "0b06dab5dd7b4c149d62297f6e98dbf6", + "name": "portalocker", + "sha256": "e366698eff2b7b6c85c47c18af54a21c61805988c382a9396f0fc611c79b5fc8", + "size": 25643, + "subdir": "linux-64", + "timestamp": 1611516847354, + "version": "2.1.0" + }, + "portalocker-2.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "8a60db4baf538803c1b4088772bfbf54", + "name": "portalocker", + "sha256": "5036788ef896cbe60aa3ec57d884c31540cb810f13d6faf9b1571e5214e5b92d", + "size": 25574, + "subdir": "linux-64", + "timestamp": 1611516809131, + "version": "2.1.0" + }, + "portalocker-2.2.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "004aa3adc60c39c5740f39bb187d08be", + "name": "portalocker", + "sha256": "bf17b2bc493e59ad6264b9c6bce6fb877212b38823a33ecbd7a4256d85811065", + "size": 28590, + "subdir": "linux-64", + "timestamp": 1612295805671, + "version": "2.2.0" + }, + "portalocker-2.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "d4f6a5e97f4ebb125be127ca9cf5c109", + "name": "portalocker", + "sha256": "a3537fac2bd14ea2da32b956fbdb62b683fbdda781864fdb77a8a3b6462f41b6", + "size": 28831, + "subdir": "linux-64", + "timestamp": 1612296003664, + "version": "2.2.0" + }, + "portalocker-2.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "d2fe11c7093aaee4dc007a29762f9f4e", + "name": "portalocker", + "sha256": "917397eb46617d27dabb670439b5dee463f0b73ccdb12d62df6d092353c4438b", + "size": 28956, + "subdir": "linux-64", + "timestamp": 1612296011993, + "version": "2.2.0" + }, + "portalocker-2.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "f1aa4c000d0ab74e2ea7952885dc2f35", + "name": "portalocker", + "sha256": "ca7fe74ed19d3b44360932141fab66d1c18cf2f4dbaea57c2adb0da909015afe", + "size": 28926, + "subdir": "linux-64", + "timestamp": 1612295976238, + "version": "2.2.0" + }, + "portalocker-2.2.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "e524da61d623e2a4035f734fe1d12b1e", + "name": "portalocker", + "sha256": "ee21fe25c72d080029885ad888850b9f47be4dde5eb45e838388cd1dc5538c37", + "size": 28687, + "subdir": "linux-64", + "timestamp": 1613764168396, + "version": "2.2.1" + }, + "portalocker-2.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "81c04537c9f635948312b371383abe53", + "name": "portalocker", + "sha256": "237d6d2e2a92d6d00bd7d29fd1b94d9acdf547bc7cc45851e952b39532798bec", + "size": 28790, + "subdir": "linux-64", + "timestamp": 1613764176523, + "version": "2.2.1" + }, + "portalocker-2.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "14cb607d96fbcb336effd108a889231d", + "name": "portalocker", + "sha256": "187628aa1d4b569a2ce9508fe699557aaa9c983501a1cb3019bcbc54d4214ad4", + "size": 28721, + "subdir": "linux-64", + "timestamp": 1613764162610, + "version": "2.2.1" + }, + "portalocker-2.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "6c325fe137be8bf1f990fc8963a4e7d7", + "name": "portalocker", + "sha256": "c7b42a1d54bfd69c90cc0ba30f06acd7b992dac0b111908c5a72537e2a9fc8bf", + "size": 28719, + "subdir": "linux-64", + "timestamp": 1613763398576, + "version": "2.2.1" + }, + "portalocker-2.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "558246164f3835b0033555d71589a95c", + "name": "portalocker", + "sha256": "e294c08b8634109bd39b85740396cf76e56071bdd737ad1c4f9ec94256a9210e", + "size": 28859, + "subdir": "linux-64", + "timestamp": 1640806843265, + "version": "2.3.0" + }, + "portalocker-2.3.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "4e446c9f3e1bcb515597d708c7071ab6", + "name": "portalocker", + "sha256": "873a204f2aed22e3fb8201dc86337504a00ac7f5cb4655024737233e04e2f5f4", + "size": 35771, + "subdir": "linux-64", + "timestamp": 1676860427341, + "version": "2.3.0" + }, + "portalocker-2.3.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "e108ec3a633c24d1f88b5b93fc76d53e", + "name": "portalocker", + "sha256": "af8129f7661a3612818434a606ae82cda5da3ec84001cf328aaea50e4f2433f7", + "size": 28677, + "subdir": "linux-64", + "timestamp": 1617135593719, + "version": "2.3.0" + }, + "portalocker-2.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "22fdd72ea64550ec3fba343e15e3455e", + "name": "portalocker", + "sha256": "e50c2d9b2257ea5f12695d9d401c6a298a6f05b6866f27fe22824b711592486b", + "size": 28686, + "subdir": "linux-64", + "timestamp": 1617135583140, + "version": "2.3.0" + }, + "portalocker-2.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "9c782b6826b329309c4edc13d6619086", + "name": "portalocker", + "sha256": "eb48e905944c7243e1fc3630100d6d5a7b085bf9d30153b1869121388c4a27b0", + "size": 29040, + "subdir": "linux-64", + "timestamp": 1617135589491, + "version": "2.3.0" + }, + "portalocker-2.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "5c1ed1eed4bc597c57c020948eb06b71", + "name": "portalocker", + "sha256": "3a0fd859ef87e5c0d66f61ccbefd4ebdd5d2a0e737e75e6777f4560f6818ac68", + "size": 29036, + "subdir": "linux-64", + "timestamp": 1617133107238, + "version": "2.3.0" + }, + "portaudio-19.6.0-h14c3975_2.conda": { + "build": "h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "c343bfc870bba6c651acdc16c8e5bb40", + "name": "portaudio", + "sha256": "9275b3064796202e76b8c8c36453bde24f11409be2b3888dba45bcf82f5213bb", + "size": 71295, + "subdir": "linux-64", + "timestamp": 1530906545584, + "version": "19.6.0" + }, + "portaudio-19.6.0-h7b6447c_4.conda": { + "build": "h7b6447c_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "md5": "c61566cf7f5bedce1ff79fad2f8270b9", + "name": "portaudio", + "sha256": "0dbdd444d7c0fcbbfb53ddca32ad0acb16a1edff2f4569d8cc6cd1dc5ab6c031", + "size": 116638, + "subdir": "linux-64", + "timestamp": 1583787621961, + "version": "19.6.0" + }, + "portend-2.2-py27h1a604f0_0.conda": { + "build": "py27h1a604f0_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "tempora >=1.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "27fa69918787f06da9e5eae36dddf4ea", + "name": "portend", + "sha256": "252fe7b348ad1874c1a7606d894b3f653c38a7f4d4b6e0433d4e64b9a3b34645", + "size": 9728, + "subdir": "linux-64", + "timestamp": 1507585901772, + "version": "2.2" + }, + "portend-2.2-py35h7ec60bb_0.conda": { + "build": "py35h7ec60bb_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "tempora >=1.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ff89142c0c87571f95641bba851bf2f", + "name": "portend", + "sha256": "e23148e3edff31759b0a96993aa670a075afebb33f035984efdd3199a8bcc629", + "size": 9854, + "subdir": "linux-64", + "timestamp": 1507585916146, + "version": "2.2" + }, + "portend-2.2-py36h36a8bbd_0.conda": { + "build": "py36h36a8bbd_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "tempora >=1.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd8d6d14089f85d1256132182b9cc2ee", + "name": "portend", + "sha256": "088e4b7456a4c1e99a3a710a6a9f33e898a08c86fe7198898a9b16e3d5ef2d12", + "size": 9775, + "subdir": "linux-64", + "timestamp": 1507585905873, + "version": "2.2" + }, + "portend-2.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "tempora >=1.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e894d770f5f74478626ff196539fc8b5", + "name": "portend", + "sha256": "a96e2dde519b7b079d7a58fb9e57351cb045f9c5f387795cfe05ec0f248989b2", + "size": 9561, + "subdir": "linux-64", + "timestamp": 1529425079822, + "version": "2.3" + }, + "portend-2.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "tempora >=1.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0e4e1418c555279ac63ef38be19296dd", + "name": "portend", + "sha256": "98e8b99bc0087f191a418e0ede955a3f9a791dabe775c63aa7d54e6baeb50ae1", + "size": 9716, + "subdir": "linux-64", + "timestamp": 1529425173969, + "version": "2.3" + }, + "portend-2.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "tempora >=1.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "281b0991cd4699adf9a925af870e9c35", + "name": "portend", + "sha256": "6bc87f69ec8d11a28a3239ff297c14e3f73f8c89449b22d518d7b612b910cb8c", + "size": 9629, + "subdir": "linux-64", + "timestamp": 1529425084211, + "version": "2.3" + }, + "portend-2.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "tempora >=1.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6d2654cf37b872d2d45c9eb09e584eb", + "name": "portend", + "sha256": "3d46a273c99d2d9122c59b5f5856247a2468b6cd35106b85bd0c002edeb0feb5", + "size": 9591, + "subdir": "linux-64", + "timestamp": 1530812087791, + "version": "2.3" + }, + "portpicker-1.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "5df9fc988663fd17c9869817cff0632d", + "name": "portpicker", + "sha256": "afdf60ec3fb6421f06bc06804e2c2f4a3663acc46b056cdbf860656a400e1d1d", + "size": 17963, + "subdir": "linux-64", + "timestamp": 1530905906624, + "version": "1.2.0" + }, + "portpicker-1.2.0-py27h86e0a49_0.conda": { + "build": "py27h86e0a49_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "f104663b065fe11b039c5bcdadf1d122", + "name": "portpicker", + "sha256": "a415ad7dcff3777e38467ae3e6425c4807151a9f5f5971214101e4bc03650243", + "size": 17334, + "subdir": "linux-64", + "timestamp": 1508267238017, + "version": "1.2.0" + }, + "portpicker-1.2.0-py35h8f64c34_0.conda": { + "build": "py35h8f64c34_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "56de3d7624de2a230b64e50a06627418", + "name": "portpicker", + "sha256": "a59626935b379c6b1713e2bc0fff4a62326fd636e425a0779b931c27e816e07c", + "size": 20845, + "subdir": "linux-64", + "timestamp": 1508267246844, + "version": "1.2.0" + }, + "portpicker-1.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "cec5af53c6a49b20a7e21db10d72649b", + "name": "portpicker", + "sha256": "3ca289d03290860f7e6a4db7a57710fc17f959d6c43e32edfe146d701bfe08e7", + "size": 21349, + "subdir": "linux-64", + "timestamp": 1530905934867, + "version": "1.2.0" + }, + "portpicker-1.2.0-py36h7b3aa6a_0.conda": { + "build": "py36h7b3aa6a_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "46588c4d20a350d049a29a4fa396cb16", + "name": "portpicker", + "sha256": "62e758ebef3d57f57359d06e062d30a90e9fdb0d8117c58c3a3688a74c53f399", + "size": 20783, + "subdir": "linux-64", + "timestamp": 1508267236125, + "version": "1.2.0" + }, + "portpicker-1.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "de2d72c287c267919ede4ce918e3c149", + "name": "portpicker", + "sha256": "14c13358a595d6264a254550e295f9d8423421574b963be2c625934038862e06", + "size": 21376, + "subdir": "linux-64", + "timestamp": 1530905962010, + "version": "1.2.0" + }, + "portpicker-1.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "195ab14a8dd2a0f5df05fb5fbf64ac2b", + "name": "portpicker", + "sha256": "0b5f31a3e16a5f7e5131807391daecdc56fb995fcfc1f1234cddfce518b1d2cb", + "size": 165457, + "subdir": "linux-64", + "timestamp": 1548089723848, + "version": "1.3.0" + }, + "portpicker-1.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "b39ea5a7fb0c768ba5823339d5cc2978", + "name": "portpicker", + "sha256": "08822e91ebb291f1ca02993f95f38e6aa25917b20035b528d6c9cd8b07493130", + "size": 170096, + "subdir": "linux-64", + "timestamp": 1548089729671, + "version": "1.3.0" + }, + "portpicker-1.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "4c2b4937a082ef1e0b5f5f8d5b1af571", + "name": "portpicker", + "sha256": "13697dd0fcd6a51913fd76168e40f5692a1cba6a81cc8dcff6664ab7c798f286", + "size": 170109, + "subdir": "linux-64", + "timestamp": 1548089727595, + "version": "1.3.0" + }, + "portpicker-1.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "8ea3600e24ab1a14ab244f7b9d2dccaa", + "name": "portpicker", + "sha256": "8d2f1a3aae914db0ae531a69b6dbb3063ab029d428f39f1e4ff72a5f14be339d", + "size": 175634, + "subdir": "linux-64", + "timestamp": 1552363480705, + "version": "1.3.1" + }, + "portpicker-1.3.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "861f2d33432620a7495529fa35fbd272", + "name": "portpicker", + "sha256": "58a6a0b5a2f289aae95361ac5c3dba0d6de9bd5010399b069caea82fcb7018ae", + "size": 26538, + "subdir": "linux-64", + "timestamp": 1640792488530, + "version": "1.3.1" + }, + "portpicker-1.3.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "8bf8d6e4a02016ee22fea0e33fd184ea", + "name": "portpicker", + "sha256": "0cfe858a11706cf1148bad83d7382e52bc1f40ad1662c27acda1dcdf7176c9e7", + "size": 28525, + "subdir": "linux-64", + "timestamp": 1676904140042, + "version": "1.3.1" + }, + "portpicker-1.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "963473aabcbcdb6014559976e51102db", + "name": "portpicker", + "sha256": "95403516f25e3db2c364a63fea55486d0a0aaf2a49a3ac9ccb02e05a5632418b", + "size": 179561, + "subdir": "linux-64", + "timestamp": 1552363509921, + "version": "1.3.1" + }, + "portpicker-1.3.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "0c02485bd89528a3e1b1e2e384c1c9a7", + "name": "portpicker", + "sha256": "176b50fb40b918c03c9cdd77c5a40163c465e3dba6549567155d39c7d03909a5", + "size": 266143, + "subdir": "linux-64", + "timestamp": 1613556405245, + "version": "1.3.1" + }, + "portpicker-1.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "b41c349abbbf45d5c4dc8f5cd54904e1", + "name": "portpicker", + "sha256": "666067d51559d34385f5f5aa38a8fcf8d556a01e3a3f289fa284d99334cb9300", + "size": 179700, + "subdir": "linux-64", + "timestamp": 1552363417679, + "version": "1.3.1" + }, + "portpicker-1.3.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "eb5d43502011dfdd59a4aec4d4007574", + "name": "portpicker", + "sha256": "9d43b005a5b0e1cab6a8c2d01ccc784464830cde2e9c02d0379ed05f7f8a45e7", + "size": 265460, + "subdir": "linux-64", + "timestamp": 1613555733670, + "version": "1.3.1" + }, + "portpicker-1.3.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "bdabc4d05154889282d39d08e679ed12", + "name": "portpicker", + "sha256": "ebd8f0994e5ccb31785aea3ab24853d756c34cae20080266c2f13d0378a1e1ab", + "size": 26717, + "subdir": "linux-64", + "timestamp": 1573040658515, + "version": "1.3.1" + }, + "portpicker-1.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "583f01810a9cf92267bf675350d8b1d9", + "name": "portpicker", + "sha256": "2094593d42dc667d4d521ad380deeb77fa58347d03b4fc4ec77c8736805adf1b", + "size": 266031, + "subdir": "linux-64", + "timestamp": 1613556402027, + "version": "1.3.1" + }, + "portpicker-1.5.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d6ea5c83bd5a3a6fe4bedc5f4fbb47fe", + "name": "portpicker", + "sha256": "e383f0fa6153f022af86830687d122828bbfab09c6d51d7f96c68dfa2e9cfbdd", + "size": 27828, + "subdir": "linux-64", + "timestamp": 1679925940633, + "version": "1.5.2" + }, + "portpicker-1.5.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a01151227061804cdeacd29e265a3811", + "name": "portpicker", + "sha256": "4842a73db748302eb32ae13d7ceae0773ff2c710fe72acceb84f48d12410d9c2", + "size": 29857, + "subdir": "linux-64", + "timestamp": 1679925915698, + "version": "1.5.2" + }, + "portpicker-1.5.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ee57f8736118900bdd7ba0b273812906", + "name": "portpicker", + "sha256": "71926a1d7011331fe136dc82723b7f7b2ced3d769f967f5e64963d706085ad95", + "size": 27739, + "subdir": "linux-64", + "timestamp": 1679925965040, + "version": "1.5.2" + }, + "portpicker-1.5.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "psutil", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5020489e1f2a0394b1c38422dae5f731", + "name": "portpicker", + "sha256": "95fb226471eeb8935aaeea93b39099f8ea8043ad4e54339e9b994455c42a976e", + "size": 27756, + "subdir": "linux-64", + "timestamp": 1679925988735, + "version": "1.5.2" + }, + "posix_ipc-1.0.4-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "18cc59b8e42c6e77a057603dfc9fff1e", + "name": "posix_ipc", + "sha256": "4622cfecb365e551953c4fafa8bf86165d7926dd830e8bfc210a5da58f393549", + "size": 15281, + "subdir": "linux-64", + "timestamp": 1527110167598, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "3cfc86fadb6df7fb3d69f0e7c4f0be13", + "name": "posix_ipc", + "sha256": "aa7009854cae73f8e28c03211ea098baa9e7bdf1c65a6f79fd9e230bea2bd61b", + "size": 175219, + "subdir": "linux-64", + "timestamp": 1560789526659, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "fe58d3466a752741dd4cd44267daa67b", + "name": "posix_ipc", + "sha256": "66763898b93cb7c81ce22dd10416e3c499994b9ae4ee7db891328a39d974eab7", + "size": 45698, + "subdir": "linux-64", + "timestamp": 1640792512526, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "md5": "1f89664962449ee2424c5cd787dfb81f", + "name": "posix_ipc", + "sha256": "5c4434b5485aa59ab8727b7b9c1ffd617d90e86638f9aa733276ac75c6d5826a", + "size": 16174, + "subdir": "linux-64", + "timestamp": 1676907489981, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "d5b501903bf337bbdb0e8f2be099f34f", + "name": "posix_ipc", + "sha256": "1b34f1610c0c1b96c2a05507d55726c2652737d5329e60c0c0c0efcf75c1dfb0", + "size": 16032, + "subdir": "linux-64", + "timestamp": 1527110152421, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "775b63938cfae4d8a7546d6ebc0c81d3", + "name": "posix_ipc", + "sha256": "75fdbba3c37aeccc712f14cfb5eec9fe5380d80a02df442478bfa1f14b9337fc", + "size": 15996, + "subdir": "linux-64", + "timestamp": 1527110157355, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "025b6c595da2e1607db9ab19826b2e2f", + "name": "posix_ipc", + "sha256": "be9e67f1e1db9fe31e09f4a2d09909ee75160bff90233c531e690086e5926c17", + "size": 254793, + "subdir": "linux-64", + "timestamp": 1613555754244, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "cb086d5db60364dc66332807212021c4", + "name": "posix_ipc", + "sha256": "22f69efe5d9dbeab121e29ba853ff178ab71c894ee6e31f7b5ddd0407b9f60ce", + "size": 175732, + "subdir": "linux-64", + "timestamp": 1560789545855, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "add8582a15b92a9a2dd1b819a8c57a1f", + "name": "posix_ipc", + "sha256": "3a7660ace758141a874a2e22d9d183ba3ce9d80333e6d55e76b2b651b8d09b2a", + "size": 254608, + "subdir": "linux-64", + "timestamp": 1613556406756, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "b4fc165ea7101ff9e8ae6c9d4d88f2d9", + "name": "posix_ipc", + "sha256": "60b0586ff6e31ebe6ff2851a527abceedae02ea0d7563b56c80341be3da2e0ff", + "size": 175331, + "subdir": "linux-64", + "timestamp": 1560789509638, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "26e92398850d7d50aa39923690aa458c", + "name": "posix_ipc", + "sha256": "adbad93c21b108326cea05eca90c05506f6a04294dd7d9c6857c548e073c9893", + "size": 254576, + "subdir": "linux-64", + "timestamp": 1613556415152, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "ef8a9aaad65e1ad0267f4779c760201a", + "name": "posix_ipc", + "sha256": "4096d3cf2ef07435f13b9ed9ed4f09a6e4a9eaf6044c8e4885e521560771fde2", + "size": 22825, + "subdir": "linux-64", + "timestamp": 1573730236889, + "version": "1.0.4" + }, + "posix_ipc-1.0.4-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "7e51d5386f53b59230548432fcd2dcbe", + "name": "posix_ipc", + "sha256": "f17722dfa0961bb78f03061f9037d1642a3cd2389e27b92a91a6abcd6fcdff62", + "size": 256562, + "subdir": "linux-64", + "timestamp": 1613556356672, + "version": "1.0.4" + }, + "postgresql-10.3-h1ad7b7a_0.conda": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16,<1.17.0a0", + "libgcc-ng >=7.2.0", + "libpq 10.3 h1ad7b7a_0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "b05cb79b6e6a524950b4344f447008f7", + "name": "postgresql", + "sha256": "d66386e43a16cd3f69b5b609322b1e926f11810690b98c6db3f1cef6745d8fe1", + "size": 3624197, + "subdir": "linux-64", + "timestamp": 1522426575765, + "version": "10.3" + }, + "postgresql-10.4-h1ad7b7a_0.conda": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.2.0", + "libpq 10.4 h1ad7b7a_0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "a62f5c9caae40e8331a89042ed80818b", + "name": "postgresql", + "sha256": "63d6af20f815d78079fb204a2bed49b5f6cc4bd2e69253e9f6740e517fd831fc", + "size": 3620705, + "subdir": "linux-64", + "timestamp": 1532852660167, + "version": "10.4" + }, + "postgresql-10.5-h1ad7b7a_0.conda": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.2.0", + "libpq 10.5 h1ad7b7a_0", + "openssl >=1.0.2p,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "a76cac7c9566c8c8b2853f0a1c89f9a8", + "name": "postgresql", + "sha256": "53436fe5b714f6302c98fe704cc539dad9953fbe0067e8af863df13c9fedfa71", + "size": 3623790, + "subdir": "linux-64", + "timestamp": 1534395012602, + "version": "10.5" + }, + "postgresql-11.1-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libpq 11.1 h20c2e04_0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "1fbec95e6cf821c3a1869b0b89435ac5", + "name": "postgresql", + "sha256": "be0fa14475ddf84f8083289c30bf0db14e17f4770b7d566db590d16ea8d2eefa", + "size": 3881927, + "subdir": "linux-64", + "timestamp": 1545233729193, + "version": "11.1" + }, + "postgresql-11.2-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "libpq 11.2 h20c2e04_0", + "openssl >=1.1.1b,<1.1.2a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "1028315476c411842d65cd61b267338c", + "name": "postgresql", + "sha256": "7df9acf76f5d7626748976fbf9b81016a52d1f5b74c2dd040f4e241c57dbad4a", + "size": 3830976, + "subdir": "linux-64", + "timestamp": 1552511065718, + "version": "11.2" + }, + "postgresql-12.2-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "krb5 >=1.17.1,<1.18.0a0", + "libgcc-ng >=7.3.0", + "libpq 12.2 h20c2e04_0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "975f2ff5a34a31a21fdabacbc1a32e1e", + "name": "postgresql", + "sha256": "fb46b2a7715a239822f0565b2113897040cc0c685cb79219b4c9684c3957ba10", + "size": 3963931, + "subdir": "linux-64", + "timestamp": 1582128112417, + "version": "12.2" + }, + "postgresql-12.2-h553bfba_1.conda": { + "build": "h553bfba_1", + "build_number": 1, + "depends": [ + "krb5 >=1.19.1,<1.20.0a0", + "libgcc-ng >=7.3.0", + "libpq 12.2 h553bfba_1", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "e86456ef7e1fcb7279e5654e80f9a370", + "name": "postgresql", + "sha256": "ce781939a25dfa00fe05fce4bc9ebdce4ab9ae81ce2206c89c9b6d07c4148bb1", + "size": 3964572, + "subdir": "linux-64", + "timestamp": 1621644128584, + "version": "12.2" + }, + "postgresql-12.9-h16c4e8d_3.conda": { + "build": "h16c4e8d_3", + "build_number": 3, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=11.2.0", + "libpq 12.9 h16c4e8d_3", + "openssl >=1.1.1o,<1.1.2a", + "readline >=8.0,<9.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "md5": "8c7729a8e36adf040d6dea69ab95f340", + "name": "postgresql", + "sha256": "367b83be65ecdd1ede5d043c6a59b569baa6f33e1af1bb8a8d2c0a618bf27f9a", + "size": 3923026, + "subdir": "linux-64", + "timestamp": 1656062959900, + "version": "12.9" + }, + "postgresql-12.9-hc2c5182_1.conda": { + "build": "hc2c5182_1", + "build_number": 1, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "libpq 12.9 hc2c5182_1", + "openssl >=1.1.1l,<1.1.2a", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "md5": "7d8d611666e7ba4f7bd9f536f5f2219a", + "name": "postgresql", + "sha256": "6c57b1942f29ec94015f13d8c9a678eee8071e6e2ec2b40f09ad2c70fec641e7", + "size": 3984916, + "subdir": "linux-64", + "timestamp": 1638892716446, + "version": "12.9" + }, + "postgresql-12.9-hc2c5182_2.conda": { + "build": "hc2c5182_2", + "build_number": 2, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "libpq 12.9 hc2c5182_2", + "openssl >=1.1.1o,<1.1.2a", + "readline >=8.0,<9.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "md5": "061268ec6b69b1e6eb6941095555f5bf", + "name": "postgresql", + "sha256": "f6ddc6be66f7cfcf5955e371b349d382868e5b282453fca13321a645b041bbbc", + "size": 3979367, + "subdir": "linux-64", + "timestamp": 1655472407217, + "version": "12.9" + }, + "postgresql-9.5.10-hc58ae56_0.conda": { + "build": "hc58ae56_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PostgreSQL", + "md5": "03571b486c8223126e4308b266ae097a", + "name": "postgresql", + "sha256": "1f2b17b14a15fb822491e63fe58dec1cbb858c7bc91d986f2710c18f413be844", + "size": 5188669, + "subdir": "linux-64", + "timestamp": 1510350812412, + "version": "9.5.10" + }, + "postgresql-9.6.5-hc049884_0.conda": { + "build": "hc049884_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2l,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PostgreSQL", + "md5": "95695a4d028e409f8e85f6939804ab91", + "name": "postgresql", + "sha256": "39680ac7e2fff66a0aaae20e5bd908455777bb71b8bd3f5b28abcdcde0c9a49b", + "size": 5455363, + "subdir": "linux-64", + "timestamp": 1509502830242, + "version": "9.6.5" + }, + "postgresql-9.6.6-h14fc437_0.conda": { + "build": "h14fc437_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PostgreSQL", + "md5": "c7bd2086a4a95d783088a5a364e0896a", + "name": "postgresql", + "sha256": "e9fa2344bed01c7d99ef7bab2519a8eb7e276bbaea83124ca4e66182bca302ba", + "size": 5445725, + "subdir": "linux-64", + "timestamp": 1510610870969, + "version": "9.6.6" + }, + "postgresql-9.6.6-h55bab6d_0.conda": { + "build": "h55bab6d_0", + "build_number": 0, + "depends": [ + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PostgreSQL", + "md5": "f063f2198fa52a83a494bed4a74a8791", + "name": "postgresql", + "sha256": "39a3e620c7b6d802ed47be895e27ef7f80fc05c5795ba2a33268d49b685ddac7", + "size": 5444248, + "subdir": "linux-64", + "timestamp": 1511386757152, + "version": "9.6.6" + }, + "postgresql-9.6.6-h95429c6_1.conda": { + "build": "h95429c6_1", + "build_number": 1, + "depends": [ + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PostgreSQL", + "md5": "6d7011fad307bbe0b93610ab2f8376c5", + "name": "postgresql", + "sha256": "a9e4c521fa20741ae6a76c53784b2d76af152aa93a79405b65127f91961a9012", + "size": 5443812, + "subdir": "linux-64", + "timestamp": 1511816990411, + "version": "9.6.6" + }, + "pre-commit-2.20.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cfgv >=2.0.0", + "identify >=1.0.0", + "nodeenv >=0.11.1", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.1", + "toml", + "virtualenv >=20.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca0ba28f7af527291e6cfeeaccf293ed", + "name": "pre-commit", + "sha256": "21a2c6e94b721a453a88da0dfe8de4d843456f2a941034589f909b17c3918801", + "size": 236061, + "subdir": "linux-64", + "timestamp": 1663261435133, + "version": "2.20.0" + }, + "pre-commit-2.20.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cfgv >=2.0.0", + "identify >=1.0.0", + "nodeenv >=0.11.1", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.1", + "toml", + "virtualenv >=20.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebe13723b793444049caa88f98ee9337", + "name": "pre-commit", + "sha256": "8ab860b094663eca7560ce5d71823324c21a7e4ebb2c4580407fab6b71c2c77f", + "size": 277186, + "subdir": "linux-64", + "timestamp": 1676860444360, + "version": "2.20.0" + }, + "pre-commit-2.20.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cfgv >=2.0.0", + "identify >=1.0.0", + "importlib_metadata", + "nodeenv >=0.11.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.1", + "toml", + "virtualenv >=20.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f75b0fc71eb39cbf5b5b1897638c8a9b", + "name": "pre-commit", + "sha256": "9bd7d4fcf6c1b836ea415bc3507c9fc032357d076879a55baffbf73f5745a69d", + "size": 233245, + "subdir": "linux-64", + "timestamp": 1663261463918, + "version": "2.20.0" + }, + "pre-commit-2.20.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cfgv >=2.0.0", + "identify >=1.0.0", + "nodeenv >=0.11.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "toml", + "virtualenv >=20.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "481fedbe47e5d2809ce435b22d703b10", + "name": "pre-commit", + "sha256": "b2adb10c24fe256f148e731d8eb78cee53e2d63aa74e4f4e6269ea355ed0a249", + "size": 233329, + "subdir": "linux-64", + "timestamp": 1663261490955, + "version": "2.20.0" + }, + "pre-commit-2.20.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cfgv >=2.0.0", + "identify >=1.0.0", + "nodeenv >=0.11.1", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "toml", + "virtualenv >=20.0.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7117999f40280a87d511a6dc0fd94297", + "name": "pre-commit", + "sha256": "b86ced34ffe4fec502d17e44ea4c2d73d6d20da387cef395baab60f026c3ddf1", + "size": 233018, + "subdir": "linux-64", + "timestamp": 1663261517105, + "version": "2.20.0" + }, + "pre-commit-3.2.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cfgv >=2.0.0", + "identify >=1.0.0", + "nodeenv >=0.11.1", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.1", + "virtualenv >=20.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43f38dcab065e5a2d0480e9fce57ed62", + "name": "pre-commit", + "sha256": "cbf6354d41449ab21d4dd12e62609ea00f12152cd8f114ddc3534760a0aa436f", + "size": 249059, + "subdir": "linux-64", + "timestamp": 1679988375222, + "version": "3.2.1" + }, + "pre-commit-3.2.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cfgv >=2.0.0", + "identify >=1.0.0", + "nodeenv >=0.11.1", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.1", + "virtualenv >=20.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "745870291ff6dc592468b2835f31875d", + "name": "pre-commit", + "sha256": "f18d40b6e673f5f2563e677c90d048ab1b5054634c1e24172a836a0951c1114d", + "size": 290882, + "subdir": "linux-64", + "timestamp": 1679988336496, + "version": "3.2.1" + }, + "pre-commit-3.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cfgv >=2.0.0", + "identify >=1.0.0", + "nodeenv >=0.11.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.1", + "virtualenv >=20.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0de96f603a43236dc192902d4e3ae1c2", + "name": "pre-commit", + "sha256": "e75d3f3f4ba2930e700ae4ed460980e73d9c920a3007aa6eb180347ad7d11e5a", + "size": 247207, + "subdir": "linux-64", + "timestamp": 1679988294944, + "version": "3.2.1" + }, + "pre-commit-3.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cfgv >=2.0.0", + "identify >=1.0.0", + "nodeenv >=0.11.1", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.1", + "virtualenv >=20.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7efdf057ea1bd7acb4f6fa63e167d7bc", + "name": "pre-commit", + "sha256": "7f90d7773621e64d5cf11ce6cf1e6a181d6113b67e204039e83db90b7706e7fe", + "size": 247647, + "subdir": "linux-64", + "timestamp": 1679988412331, + "version": "3.2.1" + }, + "preshed-1.0.0-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "69b0f0ccb31501024b282b1081319384", + "name": "preshed", + "sha256": "eafb230e2a5d5365b00d618041d5d90163001202086ffae0ec98899d1b92a26d", + "size": 75494, + "subdir": "linux-64", + "timestamp": 1530905998666, + "version": "1.0.0" + }, + "preshed-1.0.0-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4d256309fb3773ece945c2ba53c5eafd", + "name": "preshed", + "sha256": "47c71928112ca0f0d2ff7f8bac410d6f48c3d65e90235aecc97a8adf90b195ff", + "size": 78865, + "subdir": "linux-64", + "timestamp": 1530906036306, + "version": "1.0.0" + }, + "preshed-1.0.0-py37hf484d3e_0.conda": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ad2ccd5c81ea84a127a16dc3bad28230", + "name": "preshed", + "sha256": "3aeb72d14e301f8daae016ea79cf70254dd3f3b82e03e7c97921d02a93f98c92", + "size": 78854, + "subdir": "linux-64", + "timestamp": 1530906074434, + "version": "1.0.0" + }, + "preshed-1.0.1-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "17f67fcf9c5b3d7875e4a645cb6e14a9", + "name": "preshed", + "sha256": "12571cf8ff499a0079286906d2cb03d0c37786453aeffe24b1a53bdb0f0d42da", + "size": 74811, + "subdir": "linux-64", + "timestamp": 1535508980980, + "version": "1.0.1" + }, + "preshed-1.0.1-py35he6710b0_0.conda": { + "build": "py35he6710b0_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "2a742ec73ca3984ee55979076523bb88", + "name": "preshed", + "sha256": "7391dfbb3856fc4b99078f6facee314af259b4b773ba5734954e748e9060aa4f", + "size": 79310, + "subdir": "linux-64", + "timestamp": 1535509026447, + "version": "1.0.1" + }, + "preshed-1.0.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c077ad7cd1c89a9b72e64d8eb409b083", + "name": "preshed", + "sha256": "efaa79204669bcb0e2a6e62b8b6b8094dd5a2cc6e9478a79694d5c3e823d9246", + "size": 79264, + "subdir": "linux-64", + "timestamp": 1535508954037, + "version": "1.0.1" + }, + "preshed-1.0.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "83ade6eb0ec70c5ccd1639cd719439e5", + "name": "preshed", + "sha256": "74aa71d8d707323e53d055944a58428e380e920a2bbc93ac1f17fee6295eb1f2", + "size": 79074, + "subdir": "linux-64", + "timestamp": 1535508992974, + "version": "1.0.1" + }, + "preshed-2.0.1-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "902911619f887ddc685f56c8e2a0ea5a", + "name": "preshed", + "sha256": "68195d3ec1dee0b311a5c5d742bed7430a104de5109a1a6e66bf69f6066f8111", + "size": 75411, + "subdir": "linux-64", + "timestamp": 1539718732584, + "version": "2.0.1" + }, + "preshed-2.0.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "917a6ad6248a04c44806cadbb574c3f4", + "name": "preshed", + "sha256": "38af5e2885e84f45612a31f0f35b0a4186c36a0581639fe7090fd834b9f3ead5", + "size": 79849, + "subdir": "linux-64", + "timestamp": 1539718741547, + "version": "2.0.1" + }, + "preshed-2.0.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "40ab0ff502b360a0bc1d8082f6795861", + "name": "preshed", + "sha256": "702ae6fcfc44934d25a8ff4acf6467424756b9ffb7363f1643b9a4ccb5b92a27", + "size": 79603, + "subdir": "linux-64", + "timestamp": 1539718749468, + "version": "2.0.1" + }, + "preshed-2.0.1-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "47126f0edda0937e0399c4cb8dd92a3e", + "name": "preshed", + "sha256": "2a730d4da1f01719baacd223fac363cc6025f564be459d70d5819cdc421829d9", + "size": 91818, + "subdir": "linux-64", + "timestamp": 1573469607260, + "version": "2.0.1" + }, + "preshed-3.0.2-py27he6710b0_1.conda": { + "build": "py27he6710b0_1", + "build_number": 1, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash <1.1.0,>=0.28.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "81e996ea7941cd4c8ef75b61fa026ab6", + "name": "preshed", + "sha256": "a7c1d49c093242c977f2ec0e8d7557a117334900ccfa2ddd77b0398cb708101c", + "size": 115220, + "subdir": "linux-64", + "timestamp": 1574380699024, + "version": "3.0.2" + }, + "preshed-3.0.2-py36he6710b0_1.conda": { + "build": "py36he6710b0_1", + "build_number": 1, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash <1.1.0,>=0.28.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "aece9ceb0a6bd8985e4f67bf5372c92f", + "name": "preshed", + "sha256": "44446efdd311886b53160eed0b5af8187de75bbd2c9d22fdebf43e5c71d917d1", + "size": 118263, + "subdir": "linux-64", + "timestamp": 1574380711991, + "version": "3.0.2" + }, + "preshed-3.0.2-py37he6710b0_1.conda": { + "build": "py37he6710b0_1", + "build_number": 1, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash <1.1.0,>=0.28.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d4ac2f81499e5d603730230cf6c366af", + "name": "preshed", + "sha256": "fce3df65c890979204d1fb30a4939d0a9b1ceba843dc9b5b5ab66fe100c2d39a", + "size": 118283, + "subdir": "linux-64", + "timestamp": 1574380705293, + "version": "3.0.2" + }, + "preshed-3.0.2-py38he6710b0_1.conda": { + "build": "py38he6710b0_1", + "build_number": 1, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash <1.1.0,>=0.28.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "ede85a86d716dde7f9d1076c2b6c55c1", + "name": "preshed", + "sha256": "8a21bb11055afef8f0dc0aad6949071d00bac327fd3c2ed513d8034e1e497c53", + "size": 130767, + "subdir": "linux-64", + "timestamp": 1574380766960, + "version": "3.0.2" + }, + "preshed-3.0.2-py39h2531618_1.conda": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash <1.1.0,>=0.28.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "16479830d7cca1550afdedf1aebe3b3d", + "name": "preshed", + "sha256": "21eac4b2e55b6b2194ab194cbd99fc06edfc9cfeb253329866a4477f3af171ff", + "size": 122638, + "subdir": "linux-64", + "timestamp": 1608237194543, + "version": "3.0.2" + }, + "preshed-3.0.5-py310h295c915_4.conda": { + "build": "py310h295c915_4", + "build_number": 4, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "359b07d85300bac04d96b10b7366e530", + "name": "preshed", + "sha256": "3a162cce3180d6ef03346d1a7379800e44a8d3c0130284c45e178921dd902f39", + "size": 426823, + "subdir": "linux-64", + "timestamp": 1640810023024, + "version": "3.0.5" + }, + "preshed-3.0.5-py36h2531618_1.conda": { + "build": "py36h2531618_1", + "build_number": 1, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3a39f34ddd52a6538c1bf6c379146211", + "name": "preshed", + "sha256": "27a55f60f98e775f2c432760fdf6573ea87562c87151b75bef4b9912313672ea", + "size": 109502, + "subdir": "linux-64", + "timestamp": 1620312834704, + "version": "3.0.5" + }, + "preshed-3.0.5-py36h2531618_2.conda": { + "build": "py36h2531618_2", + "build_number": 2, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "93d84a6e793791bfe0e04eed19ffde95", + "name": "preshed", + "sha256": "0846648ebcad8c57eecb1e956c67ed9e1ced4d66bd1ebd5da7fe2646e5e00f29", + "size": 109850, + "subdir": "linux-64", + "timestamp": 1620314209566, + "version": "3.0.5" + }, + "preshed-3.0.5-py36h2531618_4.conda": { + "build": "py36h2531618_4", + "build_number": 4, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "76cfa40ec32159650dc4fad0dd2b01c4", + "name": "preshed", + "sha256": "dda7e2c3dc85fbcf966bb52fcf22cfc833c96d6cddba467c1c8e8aece64b344c", + "size": 112444, + "subdir": "linux-64", + "timestamp": 1621860918987, + "version": "3.0.5" + }, + "preshed-3.0.5-py37h2531618_1.conda": { + "build": "py37h2531618_1", + "build_number": 1, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b7bff02910f02932fa330294a179af06", + "name": "preshed", + "sha256": "0fec3be326fa99f0ede2a388576ed06cd77f147eb1dd025b8fd65c6d315cd784", + "size": 110934, + "subdir": "linux-64", + "timestamp": 1620313708320, + "version": "3.0.5" + }, + "preshed-3.0.5-py37h2531618_2.conda": { + "build": "py37h2531618_2", + "build_number": 2, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c1b8beaeabb4fab9b511def6f787a53e", + "name": "preshed", + "sha256": "b0b28357c6d0777f3f4dcad0b8e58ab4a8066a31a9982945e3ad94bf15f40af6", + "size": 110003, + "subdir": "linux-64", + "timestamp": 1620314208660, + "version": "3.0.5" + }, + "preshed-3.0.5-py37h2531618_4.conda": { + "build": "py37h2531618_4", + "build_number": 4, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "bbf55842cd88689bded2d4103f5dda4e", + "name": "preshed", + "sha256": "d0624248e0201264c942e59306d950327bd8657d4bf6c05a6d6025a631aabb5e", + "size": 113131, + "subdir": "linux-64", + "timestamp": 1621856053369, + "version": "3.0.5" + }, + "preshed-3.0.5-py38h2531618_1.conda": { + "build": "py38h2531618_1", + "build_number": 1, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "ea61d59f12c0294cc1a492fb071c03a4", + "name": "preshed", + "sha256": "55c697c7ef38a5487a3a27920009d9ffbf2cb57059c8974d712c33fd14b90afd", + "size": 116700, + "subdir": "linux-64", + "timestamp": 1620309640979, + "version": "3.0.5" + }, + "preshed-3.0.5-py38h2531618_2.conda": { + "build": "py38h2531618_2", + "build_number": 2, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "16f6f42dbe2b6949893b137ee114da55", + "name": "preshed", + "sha256": "b165f1860c336b98221a2f24d5de42a11eb96cae561cdd0111c2f8a051e587a7", + "size": 116786, + "subdir": "linux-64", + "timestamp": 1620314202802, + "version": "3.0.5" + }, + "preshed-3.0.5-py38h2531618_4.conda": { + "build": "py38h2531618_4", + "build_number": 4, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "d2f63322e88a302f7f5b7adce7d0480c", + "name": "preshed", + "sha256": "10f89f63e18d4262fee7380facd42ab2b7e0ae128030327c2ab1b8c32e2c83e6", + "size": 119320, + "subdir": "linux-64", + "timestamp": 1621860912002, + "version": "3.0.5" + }, + "preshed-3.0.5-py39h2531618_1.conda": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "2b060f72651895ab28a8942a1cbdb347", + "name": "preshed", + "sha256": "ed1d73973028bd3656849946f166063d5835aa42545a94a1dadc646580342f1b", + "size": 115670, + "subdir": "linux-64", + "timestamp": 1620313711272, + "version": "3.0.5" + }, + "preshed-3.0.5-py39h2531618_2.conda": { + "build": "py39h2531618_2", + "build_number": 2, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "0535467150d366e65847cf2d0da9b9f0", + "name": "preshed", + "sha256": "36e02a563ee2c8e149cc156c7ab69971b86624c5c4b8ed3a8b980888b7a78982", + "size": 115627, + "subdir": "linux-64", + "timestamp": 1620313283003, + "version": "3.0.5" + }, + "preshed-3.0.5-py39h2531618_4.conda": { + "build": "py39h2531618_4", + "build_number": 4, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "e1e383cb624cba7d63619914a35c416f", + "name": "preshed", + "sha256": "48e36b74fd461ce43dc6517a4dd582e34c09f5fb9b8f72ae5291db85c32c523c", + "size": 118689, + "subdir": "linux-64", + "timestamp": 1621860918873, + "version": "3.0.5" + }, + "preshed-3.0.6-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9bb44c25adcab464a9f9ea95e8d1f5c5", + "name": "preshed", + "sha256": "00c2f194c138749b373af9da3d8ee7faf514d8f61c5b4ca553c13acbd23734b9", + "size": 425967, + "subdir": "linux-64", + "timestamp": 1651241041994, + "version": "3.0.6" + }, + "preshed-3.0.6-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14186398dc3b5f4f82d852b84a9e54f7", + "name": "preshed", + "sha256": "6180eafe53ea6a764f56ab99bf3c3a037af2123b0324a0eae9f18a3b17350688", + "size": 109781, + "subdir": "linux-64", + "timestamp": 1676841803335, + "version": "3.0.6" + }, + "preshed-3.0.6-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6aedbbea2ab3ec019cb890a81d7337f8", + "name": "preshed", + "sha256": "136a2d161a87e538f83f52d1edc751dc1ddd6405e6b9f2e678d462a0ee6bc148", + "size": 110523, + "subdir": "linux-64", + "timestamp": 1651241119985, + "version": "3.0.6" + }, + "preshed-3.0.6-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d55c9b02ebcc2e23375d50140083d9d9", + "name": "preshed", + "sha256": "0717fb0f2e2a55855e947395c74959179f036aaefa5b2d7cc8aecd1ca807daf2", + "size": 116613, + "subdir": "linux-64", + "timestamp": 1651240988092, + "version": "3.0.6" + }, + "preshed-3.0.6-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "801995ea2b8a392f0256df980b622ebd", + "name": "preshed", + "sha256": "3a999e589b2c75d1b055d88b40aa1b8af24640689a74503ab700e695abc35db9", + "size": 115899, + "subdir": "linux-64", + "timestamp": 1651241081118, + "version": "3.0.6" + }, + "pretend-1.0.8-py27hed95a35_0.conda": { + "build": "py27hed95a35_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a4fd0022e2a5aba9229d318880451f34", + "name": "pretend", + "sha256": "6909a861ea0437d7f7fb4379cd26168325aa2ad401979b91bb523ab2d74eb1a3", + "size": 9315, + "subdir": "linux-64", + "timestamp": 1505691929052, + "version": "1.0.8" + }, + "pretend-1.0.8-py35h155362e_0.conda": { + "build": "py35h155362e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8455262b80fd49fba6e2121e83b35f86", + "name": "pretend", + "sha256": "39693d381e54745bbe36e20978a71167c68ac1338abcc53b43b0ea2c2f508e40", + "size": 9586, + "subdir": "linux-64", + "timestamp": 1505691939581, + "version": "1.0.8" + }, + "pretend-1.0.8-py36h6e1c97c_0.conda": { + "build": "py36h6e1c97c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "265bf6b0fac4052a854735ac8a6b87f3", + "name": "pretend", + "sha256": "2aa83ed967308522cab8725f624eb785ff997006d1bdd197107e14fe02d528c7", + "size": 9494, + "subdir": "linux-64", + "timestamp": 1505691950271, + "version": "1.0.8" + }, + "pretend-1.0.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e46aa7eb5b8050e53dfe3107bcab1540", + "name": "pretend", + "sha256": "5309816a51fe2c7aea3c912526c562caf83db50a1b11ae2ffcc1b4d40fcabb54", + "size": 9835, + "subdir": "linux-64", + "timestamp": 1524087177661, + "version": "1.0.9" + }, + "pretend-1.0.9-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "770e5af26b076a1d90bec694e0471e21", + "name": "pretend", + "sha256": "7d7db8d36aceb048cab55b31b1f723c31592d661a83c5ebc98d28946fc4c3a33", + "size": 9924, + "subdir": "linux-64", + "timestamp": 1640792530803, + "version": "1.0.9" + }, + "pretend-1.0.9-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "34155d07d47b42bc33665ffcc70c0e76", + "name": "pretend", + "sha256": "9da5b54700b3f7bd247c634e456d752be4a8ebab42eff9e3f80b32a9891f95d0", + "size": 11477, + "subdir": "linux-64", + "timestamp": 1676860459614, + "version": "1.0.9" + }, + "pretend-1.0.9-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2bfb472bd47d144ddeb94231901ea15b", + "name": "pretend", + "sha256": "c6ec08a8b18ad98e3fce51c88c0bf0fb6115bf0e9f4f9edfbde579a85597a3b7", + "size": 9937, + "subdir": "linux-64", + "timestamp": 1524087148691, + "version": "1.0.9" + }, + "pretend-1.0.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0f4f76718ace648cccbe29a32729681e", + "name": "pretend", + "sha256": "b15eb0f33dcd3895a8fd5f9e5ccee5b8dc8ae96f520235db0df3a14596766751", + "size": 9883, + "subdir": "linux-64", + "timestamp": 1524087207108, + "version": "1.0.9" + }, + "pretend-1.0.9-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cc04b8718d545ee7b441fcbba13d2e94", + "name": "pretend", + "sha256": "f5b7ba34e23ef50ae1d21b2c361dfc86c39352682fe7d46cba10f5553d17d028", + "size": 11123, + "subdir": "linux-64", + "timestamp": 1605213669292, + "version": "1.0.9" + }, + "pretend-1.0.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5d5252ee9bc3d6445c00927bd6505bf5", + "name": "pretend", + "sha256": "992921c9996bd2e0401c6a07b4bb8e92110b4e9d9fccf1b980f7bdac531b780e", + "size": 9761, + "subdir": "linux-64", + "timestamp": 1530732963809, + "version": "1.0.9" + }, + "pretend-1.0.9-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "10ccb13c9e27ac4ea07ceee346f05eea", + "name": "pretend", + "sha256": "87d8ca54ea864d5183a4d088a629331d577de16b26f25ab3670262cdb64edff7", + "size": 11108, + "subdir": "linux-64", + "timestamp": 1605213685419, + "version": "1.0.9" + }, + "pretend-1.0.9-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "22d9e9f0e2b14330d5cda5c6ecb9473f", + "name": "pretend", + "sha256": "67209ec1417c065cec6e1b283fd960dd24bcfdec91ebb4797604e37c5c31b3ee", + "size": 10259, + "subdir": "linux-64", + "timestamp": 1573040669550, + "version": "1.0.9" + }, + "pretend-1.0.9-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a5b0cf4cb9a003cacf56b2179a23995a", + "name": "pretend", + "sha256": "0c05c10ee0eea7e19226ea873c06789d2367d1892b0b2857c8db77edf0000328", + "size": 11225, + "subdir": "linux-64", + "timestamp": 1605213727891, + "version": "1.0.9" + }, + "pretend-1.0.9-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f91c796d4c12cfefec6dab88d9cea9cc", + "name": "pretend", + "sha256": "c7a5fe4d9ddaf87d2e55907ca0274068e34e4be82fc8f3b5cd1feb1ac7eef070", + "size": 11139, + "subdir": "linux-64", + "timestamp": 1605213720193, + "version": "1.0.9" + }, + "prettytable-3.5.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "ptable >=9999" + ], + "depends": [ + "python >=3.10,<3.11.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6b4b4a47d0dcd6ebd1c63a6964f3144e", + "name": "prettytable", + "sha256": "8a4b101ed81844be2d75349cd9d56d584dc2e94d21757ca144b0173293593273", + "size": 50771, + "subdir": "linux-64", + "timestamp": 1671655718202, + "version": "3.5.0" + }, + "prettytable-3.5.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "ptable >=9999" + ], + "depends": [ + "python >=3.11,<3.12.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "000a8eccdf677cc1a2694304ca3956f5", + "name": "prettytable", + "sha256": "aec66f720e45154371f82ce031c008ca595fec1f4624e1ab44bb411cefc32648", + "size": 60456, + "subdir": "linux-64", + "timestamp": 1676845213650, + "version": "3.5.0" + }, + "prettytable-3.5.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "ptable >=9999" + ], + "depends": [ + "importlib-metadata", + "python >=3.7,<3.8.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8323c4f16962f44a02df72ab6b10403f", + "name": "prettytable", + "sha256": "0f9e6aab7462ccc9b132168fea535055aa3eea934aa2476566996475e59ebc14", + "size": 50559, + "subdir": "linux-64", + "timestamp": 1671655696079, + "version": "3.5.0" + }, + "prettytable-3.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "ptable >=9999" + ], + "depends": [ + "python >=3.8,<3.9.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "739048043f467fa27b81205a5a62c1db", + "name": "prettytable", + "sha256": "b20a25c1e21e5cef4b8fe7e62df814139662df96fda65c86890173db27be7027", + "size": 50500, + "subdir": "linux-64", + "timestamp": 1671655739953, + "version": "3.5.0" + }, + "prettytable-3.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "ptable >=9999" + ], + "depends": [ + "python >=3.9,<3.10.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a99d9003ab947b1d23b6743f03bd1b0", + "name": "prettytable", + "sha256": "16babe2bf490fb18ccb8f878993ec7be6ef46bd0e1931b8760f98774ea76509b", + "size": 50591, + "subdir": "linux-64", + "timestamp": 1671655673437, + "version": "3.5.0" + }, + "priority-1.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "d1ac1af9134f636de006fadd9fb49c86", + "name": "priority", + "sha256": "2321a42893fb6f1a0bba258752a890d8fe9223937bc0fd8cf46e9f4626bc7354", + "size": 17641, + "subdir": "linux-64", + "timestamp": 1530919398155, + "version": "1.3.0" + }, + "priority-1.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "a5ed2fb5b36162a8c8c9fe9925a564a2", + "name": "priority", + "sha256": "a7d40b198e6bbfea085808eeeb77d147440c88fc6ff6a924d649ec2c51697762", + "size": 17807, + "subdir": "linux-64", + "timestamp": 1640792548420, + "version": "1.3.0" + }, + "priority-1.3.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "cb66dd364efb23beaddb281f6a1030b9", + "name": "priority", + "sha256": "cdf0b2da0a167ec3225e2aebd0128acca293b13e3b690905bcc5aa6377c84e4f", + "size": 20650, + "subdir": "linux-64", + "timestamp": 1676907504452, + "version": "1.3.0" + }, + "priority-1.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "6026057a693686ad2d416c55afa7eba0", + "name": "priority", + "sha256": "89166faa4356dcdf287b06dc2a7584bc982b92597129e888ded55655677a7bec", + "size": 17726, + "subdir": "linux-64", + "timestamp": 1530919342367, + "version": "1.3.0" + }, + "priority-1.3.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "f8d602178eb5c582eece6284e1bfa621", + "name": "priority", + "sha256": "5793f63127ccc4963ad11520f6bf611195b458996768ff163c353d7fb377f515", + "size": 260743, + "subdir": "linux-64", + "timestamp": 1614082674243, + "version": "1.3.0" + }, + "priority-1.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "9ef02f239c50f7872150058797a57527", + "name": "priority", + "sha256": "8e898784ffa6557df55d858a86bdf865345fae7fb59424ad8ea3eac37182d5ba", + "size": 17610, + "subdir": "linux-64", + "timestamp": 1530919370497, + "version": "1.3.0" + }, + "priority-1.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "97133d44d09ef4def0f86562739004c9", + "name": "priority", + "sha256": "69714c8ff69cf554206415e7d3dd7f91f074fa88df7989c2edd80ed59d8f5b16", + "size": 260557, + "subdir": "linux-64", + "timestamp": 1614082662374, + "version": "1.3.0" + }, + "priority-1.3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "f0f6e3bdf5627e9f23ec7b34b273805f", + "name": "priority", + "sha256": "d2a07f57f296aad3d731802237cf9890fddf78799f2e3084a9e9826e96ea68d4", + "size": 18177, + "subdir": "linux-64", + "timestamp": 1573040681352, + "version": "1.3.0" + }, + "priority-1.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT License", + "license_family": "MIT", + "md5": "a224c5165e9c87740b2531e4825d07d2", + "name": "priority", + "sha256": "2adf37c78de222883d4c479a1d0add7af5c9b40f46462396479539597999fee8", + "size": 260524, + "subdir": "linux-64", + "timestamp": 1614082668971, + "version": "1.3.0" + }, + "prison-0.2.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "requests", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0041e7d2d27d60cbfc6d6d6527f3ea49", + "name": "prison", + "sha256": "0a223743aa52df7cbb296a6ace2536e45fd60358af3ab5821570f5d597acb51f", + "size": 14788, + "subdir": "linux-64", + "timestamp": 1659783360869, + "version": "0.2.1" + }, + "prison-0.2.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "requests", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d26d649e575a784b56a52bb7676c2949", + "name": "prison", + "sha256": "0c5ca981cdb7191f64fe17c719a79d41ceec4e383b6b34a051ede217537b6a48", + "size": 17794, + "subdir": "linux-64", + "timestamp": 1676828724805, + "version": "0.2.1" + }, + "prison-0.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f4c52c25acf53d0f3bedac87bec5909", + "name": "prison", + "sha256": "71c5d65908628727d8c3e95bc532eab0a956271e8a8bf4a8ebb5ed23f63fdc87", + "size": 14756, + "subdir": "linux-64", + "timestamp": 1659783259511, + "version": "0.2.1" + }, + "prison-0.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4c5f470f7317ca7d84581495ced0e570", + "name": "prison", + "sha256": "c7a5fb40681534ee37b612a2c01257763ab2e9184f3f55b37ebd965ac619bbd2", + "size": 14767, + "subdir": "linux-64", + "timestamp": 1659783287459, + "version": "0.2.1" + }, + "prison-0.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d20429763bf5745376acf8ada1fc562", + "name": "prison", + "sha256": "5bc24827187a26f34800af763d90b987935145b17e1d7026e1a4cbe73605295f", + "size": 14731, + "subdir": "linux-64", + "timestamp": 1659783319459, + "version": "0.2.1" + }, + "progress-1.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "86256d1e025849cd207b2a30b13b20f1", + "name": "progress", + "sha256": "ba3f4cb7d9481ea0a0ed6db7e15bbe59dc3de07021160294c9d870d6936a0215", + "size": 13710, + "subdir": "linux-64", + "timestamp": 1529956628447, + "version": "1.4" + }, + "progress-1.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "b3c7b3b4d03bc559f405b645fef11abe", + "name": "progress", + "sha256": "bbef619baf1d94163384702d21237614ed41eb9738f8affc1f0631fa69de06c2", + "size": 13926, + "subdir": "linux-64", + "timestamp": 1529956635825, + "version": "1.4" + }, + "progress-1.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "bb2e8d72455c085949e79690fdcea943", + "name": "progress", + "sha256": "81fbadc8e76fc05f2b13b935b8d756dff15752223ecd4cefdc3daf56242171ba", + "size": 13887, + "subdir": "linux-64", + "timestamp": 1529956595228, + "version": "1.4" + }, + "progress-1.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "2e1a08a3d86d2bb211ca312bd91cb38c", + "name": "progress", + "sha256": "d69eb6c31f46d1fbedd324d04bdb02f3d724664e947d5b795b95a7b1c9f74978", + "size": 13723, + "subdir": "linux-64", + "timestamp": 1530906105333, + "version": "1.4" + }, + "progress-1.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "4cd5f9531d3fbf0f0a79687d20bc5da1", + "name": "progress", + "sha256": "fe610c6fa40ff76ef5f3828f329c4abeda7b940a28b6cd9a5254d57c2bb890a9", + "size": 14684, + "subdir": "linux-64", + "timestamp": 1552441014220, + "version": "1.5" + }, + "progress-1.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "407d5a872b7ee06ac8c1734a9eeb7e17", + "name": "progress", + "sha256": "64c6a78fbc7373af4edb034f6395a16a238267a78c5436f905fab6fcf9c1ffe4", + "size": 14043, + "subdir": "linux-64", + "timestamp": 1640792566008, + "version": "1.5" + }, + "progress-1.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "ba1b92d29705aa13ce452195dfcbe368", + "name": "progress", + "sha256": "320692f7c6bfdbf707c187727b1ac118fb9c191019ad2d86e35b692a0b6b0b6a", + "size": 16742, + "subdir": "linux-64", + "timestamp": 1676860475772, + "version": "1.5" + }, + "progress-1.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "f5813bcf6272969366f827b00d80b0e0", + "name": "progress", + "sha256": "6a7f543dad6d9d4449b87d78d2d6f78ba635cd93b01dca7176aefccd88968635", + "size": 14644, + "subdir": "linux-64", + "timestamp": 1552441180624, + "version": "1.5" + }, + "progress-1.5-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "58b494d4fb86ec05dd4c1eaeea9b9f50", + "name": "progress", + "sha256": "5af4cfa1ce10794425f7fb410c29901014026141bf9331b6e24bda387409b77f", + "size": 14611, + "subdir": "linux-64", + "timestamp": 1614269530733, + "version": "1.5" + }, + "progress-1.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "ba92b503a4449ba89a6d0472f44a0751", + "name": "progress", + "sha256": "397b50e950dc283a196d638669e21690e36459687def7ded79fe2fda1e90d604", + "size": 14555, + "subdir": "linux-64", + "timestamp": 1552440998896, + "version": "1.5" + }, + "progress-1.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "ab52ca94298d3bc39999223aa9a3e445", + "name": "progress", + "sha256": "51498f27092cf6c2db08f6a669bc88c0eae33cd2b767ebf78775d2b352b5d213", + "size": 14549, + "subdir": "linux-64", + "timestamp": 1614270550861, + "version": "1.5" + }, + "progress-1.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "f8ab1fca8b0a8def418d7a8b0a59f570", + "name": "progress", + "sha256": "c4bf1cbcdca5f9b78319a2a458cc66d6cafbcb9212f77f2a9abf9ad61020ede5", + "size": 13849, + "subdir": "linux-64", + "timestamp": 1573040695412, + "version": "1.5" + }, + "progress-1.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "c94eb5184997fc9f4f2370966bf1396f", + "name": "progress", + "sha256": "23d81f78b84850420bda2c09af2a9932118832100f701853149ce0e012fbe650", + "size": 14575, + "subdir": "linux-64", + "timestamp": 1614270556092, + "version": "1.5" + }, + "progress-1.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "b4cb9f94993687927f80661ce5bf6122", + "name": "progress", + "sha256": "d01c11bac97d5136420b0b7ac90c15108a8b0c17425cd69a9ae1ec75f68526be", + "size": 14673, + "subdir": "linux-64", + "timestamp": 1614270555094, + "version": "1.5" + }, + "progressbar2-3.34.3-py27h93d0879_0.conda": { + "build": "py27h93d0879_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=2.7,<2.8.0a0", + "python-utils" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3e0af66207674c19cb782e62391c1add", + "name": "progressbar2", + "sha256": "8a83f4ad74d4f15c0f545b0189417b6b29accc5bac74f83e60d3a57ab39436dd", + "size": 40308, + "subdir": "linux-64", + "timestamp": 1511984437951, + "version": "3.34.3" + }, + "progressbar2-3.34.3-py35h6582cdf_0.conda": { + "build": "py35h6582cdf_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.5,<3.6.0a0", + "python-utils" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a5f09cef759950a3a7e265958a45f57a", + "name": "progressbar2", + "sha256": "cadf47992b8a7f87a8029b7c8da781ae4234d789569f01311f13157522bc986e", + "size": 40718, + "subdir": "linux-64", + "timestamp": 1511984460632, + "version": "3.34.3" + }, + "progressbar2-3.34.3-py36h0413d66_0.conda": { + "build": "py36h0413d66_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.6,<3.7.0a0", + "python-utils" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cd13f6d7d9b001a1b5268ab6c999be20", + "name": "progressbar2", + "sha256": "82f7a361c709d574c9b325b37bcc0deb7709ccfb381da8662533d1b8a3a2f3f5", + "size": 40559, + "subdir": "linux-64", + "timestamp": 1511984433486, + "version": "3.34.3" + }, + "progressbar2-3.35.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=2.7,<2.8.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9e12a23c866f75c950000f558fb116b7", + "name": "progressbar2", + "sha256": "9f99e2e8a9668ebdebdc64d45350cf6502dc6f022623ef84acff150d747b2c81", + "size": 35689, + "subdir": "linux-64", + "timestamp": 1519674277466, + "version": "3.35.2" + }, + "progressbar2-3.35.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.5,<3.6.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b81b7c5b9c5a9ddb2eaef29ee79e0b87", + "name": "progressbar2", + "sha256": "97c236a76147d14975e30ca34427715b72e2c7d977a159d673e4aaad578922ba", + "size": 35971, + "subdir": "linux-64", + "timestamp": 1519674278206, + "version": "3.35.2" + }, + "progressbar2-3.35.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.6,<3.7.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1531f9e09e8433a111e59efb9ecc64b5", + "name": "progressbar2", + "sha256": "32ccc2381ce5e87c46be5ad29cb29cf7f50ae5ba91850822ef91779b1b5fed19", + "size": 35745, + "subdir": "linux-64", + "timestamp": 1519674348862, + "version": "3.35.2" + }, + "progressbar2-3.36.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=2.7,<2.8.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dbbd4964a1f08c1b17b1d8f11d60262c", + "name": "progressbar2", + "sha256": "66c8545d8ac74fd4a06c51bc50df7a2bc68d798e56fb2081f1a078b485bfc4df", + "size": 35837, + "subdir": "linux-64", + "timestamp": 1522785670242, + "version": "3.36.0" + }, + "progressbar2-3.36.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.5,<3.6.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1a49c8687efa0754b611319dbd55b868", + "name": "progressbar2", + "sha256": "8638c0d0b6d10c7c1d0f1dc8b5a020a809e7d7cbedb5314827f340da4b741634", + "size": 36537, + "subdir": "linux-64", + "timestamp": 1522785703552, + "version": "3.36.0" + }, + "progressbar2-3.36.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.6,<3.7.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "95d46ddd0fd2b1dc8aefa52fbf9d58a9", + "name": "progressbar2", + "sha256": "ff45480f1b6bb5b1df5ab71a2f71575c3eaad04d2cc1b1521400834749c81afc", + "size": 36292, + "subdir": "linux-64", + "timestamp": 1522785677616, + "version": "3.36.0" + }, + "progressbar2-3.37.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=2.7,<2.8.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d023e568e944aa30d82421c762af077e", + "name": "progressbar2", + "sha256": "aef15e935519638a2e2f3d7424e481f00adcbb29eb773cc4a6032c3aa705e2df", + "size": 36645, + "subdir": "linux-64", + "timestamp": 1524082444850, + "version": "3.37.1" + }, + "progressbar2-3.37.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.10,<3.11.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "77e1a099cabdb7bd5b9e9e5d285cfc8f", + "name": "progressbar2", + "sha256": "6b396212fce3613a6da30a59f40d7c08299bbd65596b745c01f6c5699a89975d", + "size": 37274, + "subdir": "linux-64", + "timestamp": 1640810044350, + "version": "3.37.1" + }, + "progressbar2-3.37.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.5,<3.6.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c3b31dba5f4b1b3b22067edac6f91962", + "name": "progressbar2", + "sha256": "17b87f740e40feab38e2a11242b34464fdb3c93197c7565e980e418f23577358", + "size": 37114, + "subdir": "linux-64", + "timestamp": 1524082574301, + "version": "3.37.1" + }, + "progressbar2-3.37.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.6,<3.7.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "23f7b7054828e03afbc90f1bfc179e2d", + "name": "progressbar2", + "sha256": "c7d56fc4d3d21238547106ad944d1416262e24f181e4a333d7bd58e5e0f1c989", + "size": 37104, + "subdir": "linux-64", + "timestamp": 1524082458600, + "version": "3.37.1" + }, + "progressbar2-3.37.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.6,<3.7.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "364dfd6e06d5c9cf3d2a2bcca80474ca", + "name": "progressbar2", + "sha256": "31d1b9917f2e6f56e032428f3e54e61013e3d0981062beb02e1db7746d39db7a", + "size": 38285, + "subdir": "linux-64", + "timestamp": 1614270279032, + "version": "3.37.1" + }, + "progressbar2-3.37.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.7,<3.8.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "be7c540faca4669c31f12d7ea447f22d", + "name": "progressbar2", + "sha256": "692809b07a41c1894c03486d024543466a3ff0e72d8fd0e9f89415ea44285bc9", + "size": 36964, + "subdir": "linux-64", + "timestamp": 1530906170405, + "version": "3.37.1" + }, + "progressbar2-3.37.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.7,<3.8.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "add6b47858fc80913fa0b0d1f4263278", + "name": "progressbar2", + "sha256": "c4932a1cb6e57f1da388af262d1c5cca9fa2e665967f03a30d4f9131d1715caf", + "size": 38461, + "subdir": "linux-64", + "timestamp": 1614270566719, + "version": "3.37.1" + }, + "progressbar2-3.37.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.8,<3.9.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "945ccc11043b4aae9b20c1fb68b3de53", + "name": "progressbar2", + "sha256": "7afb26b46ccdf2519aa0319a5688a818c3875ddc02476410a71729c4969cfaee", + "size": 37410, + "subdir": "linux-64", + "timestamp": 1574177645058, + "version": "3.37.1" + }, + "progressbar2-3.37.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.8,<3.9.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a74ceb79907b1367b034432d9db5fe55", + "name": "progressbar2", + "sha256": "857448847846f2d70faebc9cb0a0520b6f5de81349165defbcffa22a0ac93edd", + "size": 38746, + "subdir": "linux-64", + "timestamp": 1614270554387, + "version": "3.37.1" + }, + "progressbar2-3.37.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest-runner >=2.8", + "python >=3.9,<3.10.0a0", + "python-utils", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "55949a67cd0bca91f611dbcbc2878ed4", + "name": "progressbar2", + "sha256": "c0039ec3119c096c92258899b6aa3dc522c7aed6049ed93170b1c47b33f09034", + "size": 38723, + "subdir": "linux-64", + "timestamp": 1614270556826, + "version": "3.37.1" + }, + "progressbar2-4.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-utils >=3.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "da0b167be037c74d325f3ae493f7eeb1", + "name": "progressbar2", + "sha256": "e7756f96535408c49aaac28d1caaebc5ad1eae3815b067d6fd6cf443c2cd855d", + "size": 52965, + "subdir": "linux-64", + "timestamp": 1676902998730, + "version": "4.2.0" + }, + "progressbar2-4.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-utils >=3.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9ca3b46817afca2dafd98fd69d44aed3", + "name": "progressbar2", + "sha256": "a671f6beb0848aff012c046ecbe458741b73229235465e02bfccce27347761ac", + "size": 52261, + "subdir": "linux-64", + "timestamp": 1676902950249, + "version": "4.2.0" + }, + "progressbar2-4.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-utils >=3.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2120026f4f6e3d640b356ddbb7674f52", + "name": "progressbar2", + "sha256": "de4c18d0c27922a166cfd6e8866048d63c9227b8359f6f2bd477deb80ff9266e", + "size": 52486, + "subdir": "linux-64", + "timestamp": 1676902973997, + "version": "4.2.0" + }, + "progressbar2-4.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-utils >=3.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88626c109589ed9663c232756b7c12d5", + "name": "progressbar2", + "sha256": "dc674cc964ee3359c3123bd6b0c9169a3f8e5016df990aad1985d356f23c5697", + "size": 52368, + "subdir": "linux-64", + "timestamp": 1676903023981, + "version": "4.2.0" + }, + "proj-6.2.1-h05a3930_0.conda": { + "build": "h05a3930_0", + "build_number": 0, + "constrains": [ + "proj4 ==999999999999" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "sqlite >=3.37.0,<4.0a0" + ], + "license": "MIT", + "md5": "4a35e2d120d6b19d87a124b0c3bb0617", + "name": "proj", + "sha256": "315174b629c331b2e37131f7d9270221d870025e12b7c05fd517261db2b611cb", + "size": 9352087, + "subdir": "linux-64", + "timestamp": 1643031993108, + "version": "6.2.1" + }, + "proj-6.2.1-haa6030c_0.conda": { + "build": "haa6030c_0", + "build_number": 0, + "constrains": [ + "proj4 ==999999999999" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "sqlite >=3.30.1,<4.0a0" + ], + "license": "MIT", + "md5": "592b6e6008bc602d094b18d0b39ce22f", + "name": "proj", + "sha256": "c8181a5e6fbb23351c602ab5c41b95fce403fcfe53b8fbd66130baa548d4736b", + "size": 9396760, + "subdir": "linux-64", + "timestamp": 1573143179535, + "version": "6.2.1" + }, + "proj-7.0.0-h59a7b90_1.conda": { + "build": "h59a7b90_1", + "build_number": 1, + "constrains": [ + "proj4 ==999999999999" + ], + "depends": [ + "libcurl >=7.69.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "sqlite >=3.31.1,<4.0a0" + ], + "license": "MIT", + "md5": "8655ce0fb05981b5c9c581df576bd38d", + "name": "proj", + "sha256": "b0de206dce9dc9819f1a903ac2f61159e1cf68f241cdc4f04badeb04fba78042", + "size": 2822725, + "subdir": "linux-64", + "timestamp": 1585316604123, + "version": "7.0.0" + }, + "proj-7.0.1-h59a7b90_1.conda": { + "build": "h59a7b90_1", + "build_number": 1, + "constrains": [ + "proj4 ==999999999999" + ], + "depends": [ + "libcurl >=7.69.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libtiff >=4.1.0,<5.0a0", + "sqlite >=3.31.1,<4.0a0" + ], + "license": "MIT", + "md5": "62a82567bd7cf44fa894701aedcdcc3d", + "name": "proj", + "sha256": "6ea0da6d24847d5311d9b14b4c4de4bb2a6d6fcff1b2d1da07fdacecc39ea88a", + "size": 2832160, + "subdir": "linux-64", + "timestamp": 1590571836312, + "version": "7.0.1" + }, + "proj-7.2.0-h1217e81_1.conda": { + "build": "h1217e81_1", + "build_number": 1, + "constrains": [ + "proj4 ==999999999999" + ], + "depends": [ + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "sqlite >=3.37.0,<4.0a0" + ], + "license": "MIT", + "md5": "b9b4aba2e160c1e08687b051d1587e3e", + "name": "proj", + "sha256": "97a131564de079ed4c2cc8ff21c239521b02269f833d32b8085a16a748740e50", + "size": 2724342, + "subdir": "linux-64", + "timestamp": 1642790878513, + "version": "7.2.0" + }, + "proj-8.0.1-h1217e81_0.conda": { + "build": "h1217e81_0", + "build_number": 0, + "constrains": [ + "proj4 ==999999999999" + ], + "depends": [ + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "sqlite >=3.37.0,<4.0a0" + ], + "license": "MIT", + "md5": "9bf26997bee76d93ae5a2ed774ff9cdb", + "name": "proj", + "sha256": "80df5da0d6b4e8b02e42c1a3f87433b3fee1c4f8db40da36875b56a831722efb", + "size": 2805157, + "subdir": "linux-64", + "timestamp": 1643032942314, + "version": "8.0.1" + }, + "proj-8.2.1-ha227179_0.conda": { + "build": "ha227179_0", + "build_number": 0, + "constrains": [ + "proj4 ==999999999999" + ], + "depends": [ + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libtiff >=4.1.0,<5.0a0", + "sqlite >=3.11", + "sqlite >=3.37.2,<4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "edcdc32b05a85adf9d6275205863fc4b", + "name": "proj", + "sha256": "01482346fd7a57d895ffbd4114f0a7d2848a5a6cec6b7bfee34a3cc623a45ee9", + "size": 2714011, + "subdir": "linux-64", + "timestamp": 1644419771726, + "version": "8.2.1" + }, + "proj4-4.9.3-h95c2755_7.conda": { + "build": "h95c2755_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "946b48ae6785a45707a8a19d0f02cd80", + "name": "proj4", + "sha256": "6490176c61affcb8e95ddea99acebb5cc2c857eebafee5e5ba41f8a08a325468", + "size": 3055287, + "subdir": "linux-64", + "timestamp": 1510610376350, + "version": "4.9.3" + }, + "proj4-4.9.3-ha04b9cc_6.conda": { + "build": "ha04b9cc_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "69b177b984d8ed34c4b45fe094e78e39", + "name": "proj4", + "sha256": "c2f2e289f4838e7753da76889d7c99eef1ffe4948c8943005f9a92e9c4dc858a", + "size": 3040808, + "subdir": "linux-64", + "timestamp": 1509379066831, + "version": "4.9.3" + }, + "proj4-4.9.3-hc8507d1_7.conda": { + "build": "hc8507d1_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "54a93277c56388171f186670826ba1cc", + "name": "proj4", + "sha256": "fcfea4e75657f23930ec49d5839d1f94528a8a94d11bfabcbd496b7228bc7e09", + "size": 3055400, + "subdir": "linux-64", + "timestamp": 1510629153987, + "version": "4.9.3" + }, + "proj4-5.0.1-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "87b31f3cb450e1eb65d4a8b8dcaaab50", + "name": "proj4", + "sha256": "faaf99cebbaa40e684f240037028bb23a0d1b7ba8746577bb7336571a4ca6592", + "size": 6949525, + "subdir": "linux-64", + "timestamp": 1527741136659, + "version": "5.0.1" + }, + "proj4-5.1.0-h14c3975_1.conda": { + "build": "h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "3626b15e7a2cbf34240622ae190e38d5", + "name": "proj4", + "sha256": "7d70c77d7a33af49a4775c0ce2d8efa388ddbaa71574efdcbd369db7ad64bbe6", + "size": 6955455, + "subdir": "linux-64", + "timestamp": 1532641674089, + "version": "5.1.0" + }, + "proj4-5.2.0-h295c915_1001.conda": { + "build": "h295c915_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "md5": "ab40f2da97e3abc0ea01afb3182889af", + "name": "proj4", + "sha256": "c244ba7f5d083a5905d9d075c5db2134552e68640ae18c55bb8747ed7c108886", + "size": 6985924, + "subdir": "linux-64", + "timestamp": 1643033751822, + "version": "5.2.0" + }, + "proj4-5.2.0-he6710b0_1.conda": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "md5": "4902188f473013e8fc70e5a6c923d62d", + "name": "proj4", + "sha256": "8257bbb6c8172166fb3b648863440e5555552b5db8ae08beada437bc5183402b", + "size": 6965902, + "subdir": "linux-64", + "timestamp": 1545255198719, + "version": "5.2.0" + }, + "prometheus_client-0.14.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "10a26e84b3736bc9decdcfec008f2ed8", + "name": "prometheus_client", + "sha256": "cae60c5c2d7a790e63c59e3ab0348c2a5343fc35ee83eab888693a2612cce3f7", + "size": 93272, + "subdir": "linux-64", + "timestamp": 1659455234403, + "version": "0.14.1" + }, + "prometheus_client-0.14.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "74866d95e06bb1dde3c8a5b4f3c023a3", + "name": "prometheus_client", + "sha256": "e080c0c21859ef4b81526aeee36f529daab6d9722726085402d949157dac32a2", + "size": 122854, + "subdir": "linux-64", + "timestamp": 1679340540306, + "version": "0.14.1" + }, + "prometheus_client-0.14.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8015d5ee8f8439d19b459f95f596131d", + "name": "prometheus_client", + "sha256": "14e41339ae9dc6c101a816c15676a54422f51f4abb1c0dda7f49076e1c109b7d", + "size": 92005, + "subdir": "linux-64", + "timestamp": 1659455181292, + "version": "0.14.1" + }, + "prometheus_client-0.14.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cce701f2997e4b5dcf5ef3cb811ac58a", + "name": "prometheus_client", + "sha256": "1a240c7308f677f179a66ff6997f71974ec0c411bdf5d32f476b973ae82da687", + "size": 92517, + "subdir": "linux-64", + "timestamp": 1659455269732, + "version": "0.14.1" + }, + "prometheus_client-0.14.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0d2e32497598f52ee6e4c006899de629", + "name": "prometheus_client", + "sha256": "d545a94557145c2f67588fab416728df0c9073d8d513a349f75ab48b8de8424e", + "size": 92451, + "subdir": "linux-64", + "timestamp": 1659455142164, + "version": "0.14.1" + }, + "prometheus_client-0.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5a725e7ec8bbcab32a09ed9dda996b79", + "name": "prometheus_client", + "sha256": "6bc434063d131811476106e4db13256d9e831805e1aad3a9bd73b70a68e519fb", + "size": 51295, + "subdir": "linux-64", + "timestamp": 1531775839437, + "version": "0.2.0" + }, + "prometheus_client-0.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9ad5311385429e46af878e5dbeb5e8fd", + "name": "prometheus_client", + "sha256": "9f6f98ec5365fefef662a5779321cae7294a2194f35a8d28e3404bbee40fa843", + "size": 52763, + "subdir": "linux-64", + "timestamp": 1531775855886, + "version": "0.2.0" + }, + "prometheus_client-0.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fe273854060fa34239142d51455cb9d4", + "name": "prometheus_client", + "sha256": "e04bef227ace60bc86581aac429d9790349383c82035adf7d464a8babc482684", + "size": 51835, + "subdir": "linux-64", + "timestamp": 1531775872107, + "version": "0.2.0" + }, + "prometheus_client-0.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dd8a68b2ddf4aa725086495853131a0e", + "name": "prometheus_client", + "sha256": "235b45b1152a847e2c5e3967da3655b510237283b65e11882ef9cb2dc029f5fd", + "size": 51900, + "subdir": "linux-64", + "timestamp": 1531775869208, + "version": "0.2.0" + }, + "prometheus_client-0.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "64560a09bc942c4503d722c29df4bf82", + "name": "prometheus_client", + "sha256": "14add208cf2fe7088bc94c618b3fffd26fe1413f6878b0956e5e61c38da4958b", + "size": 53237, + "subdir": "linux-64", + "timestamp": 1532527304528, + "version": "0.3.0" + }, + "prometheus_client-0.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3f672ebc74a24a6a7a9e0537f0511876", + "name": "prometheus_client", + "sha256": "9415a429672b41cc11b3bb6b3e36297376a389ba64f5eb355e2aa225511f3dc7", + "size": 54337, + "subdir": "linux-64", + "timestamp": 1532527400388, + "version": "0.3.0" + }, + "prometheus_client-0.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f310571e932c7a8de9cbe885afc272d8", + "name": "prometheus_client", + "sha256": "64771308ec889cb0ee40505dd55738755c62b8566d9cbdd6e901510b075dbb62", + "size": 53755, + "subdir": "linux-64", + "timestamp": 1532527267473, + "version": "0.3.0" + }, + "prometheus_client-0.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "77903b8f717c889ab712c29459fe8d1d", + "name": "prometheus_client", + "sha256": "4349ba908797ad831ae32e4f7585f4191dba8bb7793178e13899809d17680a87", + "size": 53851, + "subdir": "linux-64", + "timestamp": 1532527401900, + "version": "0.3.0" + }, + "prometheus_client-0.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b5010c0e646c9a2dfe8f96906d43d24e", + "name": "prometheus_client", + "sha256": "de966cba9a6180ec5251883ef3c5efc0e8688edab8cfdc4315af78571e274e41", + "size": 53561, + "subdir": "linux-64", + "timestamp": 1532977042612, + "version": "0.3.1" + }, + "prometheus_client-0.3.1-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3ea47ccbafbbe0c52c48678bc56c0e6e", + "name": "prometheus_client", + "sha256": "84e3cbeeba157d0e16070e40b37f5ab2ea60ebf479c5d78a27ff2a5f72f49336", + "size": 53035, + "subdir": "linux-64", + "timestamp": 1534351243232, + "version": "0.3.1" + }, + "prometheus_client-0.3.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8c342a16528072c3022743653637352f", + "name": "prometheus_client", + "sha256": "eb8b2ae2117bf9820e28f0b8c91206d7476a1aebef6c66c462d3be41c504e36a", + "size": 54592, + "subdir": "linux-64", + "timestamp": 1532977068347, + "version": "0.3.1" + }, + "prometheus_client-0.3.1-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8cf399793535c10f8e2b70427b60935f", + "name": "prometheus_client", + "sha256": "0db6ca2062fa298503be5ea7b84b1b992a0c08747eb181abe34430e611b1c141", + "size": 54023, + "subdir": "linux-64", + "timestamp": 1534351274476, + "version": "0.3.1" + }, + "prometheus_client-0.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4766fafddbb5fa073a4b5f16321bf391", + "name": "prometheus_client", + "sha256": "f1e5253dc12262f28b5e78a7624e0d52a833f0cf2b4a8db9f33a64864d83ddab", + "size": 54025, + "subdir": "linux-64", + "timestamp": 1532977858504, + "version": "0.3.1" + }, + "prometheus_client-0.3.1-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "22e833f625cc75bd5481491692ced7fb", + "name": "prometheus_client", + "sha256": "073ca565048885274502679a07cc0b31372444d9cba3b99210263660d086d92f", + "size": 53538, + "subdir": "linux-64", + "timestamp": 1534351305979, + "version": "0.3.1" + }, + "prometheus_client-0.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d4a18bdcd82c3b64f53fe504ecad8352", + "name": "prometheus_client", + "sha256": "2f0e7fb1000843fa1d78e7d7975fbf122f1f39616a6a2bd5f491d5d95a849498", + "size": 53569, + "subdir": "linux-64", + "timestamp": 1532977096560, + "version": "0.3.1" + }, + "prometheus_client-0.3.1-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "twisted" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cc94d23a862e3f32aa037f2331be441c", + "name": "prometheus_client", + "sha256": "5cdeb28d322907b3768cd257bebee8cf5ec30e761e8cf2597db95905da2f468f", + "size": 53657, + "subdir": "linux-64", + "timestamp": 1534351215035, + "version": "0.3.1" + }, + "prometheus_client-0.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0ffea99142d0361995858855b8dcd165", + "name": "prometheus_client", + "sha256": "9051c4815c458e4a21a0097a27dad10a7fdc6a09e1c5c71ed3fd64b1880d2733", + "size": 66379, + "subdir": "linux-64", + "timestamp": 1539022699731, + "version": "0.4.0" + }, + "prometheus_client-0.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5bdd7f07ba5a2ec28a0bd8e700f87a6f", + "name": "prometheus_client", + "sha256": "78394388f4a9a521d90973e79031032c56fccc29e7258c832128fb02a3ba90e6", + "size": 66636, + "subdir": "linux-64", + "timestamp": 1539022715464, + "version": "0.4.0" + }, + "prometheus_client-0.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1e20879a31b4fe0f60520c09e4997da9", + "name": "prometheus_client", + "sha256": "a24864a3d460f31cde6ad3d7eb982d57cad741752a5cef9190cc76c605295a80", + "size": 65424, + "subdir": "linux-64", + "timestamp": 1539022685106, + "version": "0.4.0" + }, + "prometheus_client-0.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0b197a10774954c5740c602687eaf9e9", + "name": "prometheus_client", + "sha256": "be8ac734feaac8d6f17570a75fcd5885a0510d7a49704be0532d1bff5a6a1e03", + "size": 65430, + "subdir": "linux-64", + "timestamp": 1539636151790, + "version": "0.4.2" + }, + "prometheus_client-0.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "22e1fdf5c2d0a3028bef67ed6a7923c2", + "name": "prometheus_client", + "sha256": "d18eb83d7f6640446e909a74240f0eb43a72600e6bb0e7f3d8846acb75ac0cef", + "size": 66861, + "subdir": "linux-64", + "timestamp": 1539636185368, + "version": "0.4.2" + }, + "prometheus_client-0.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d5357af91be3550161d920d891c7bc69", + "name": "prometheus_client", + "sha256": "dca25001deb9df29bb9df62c7e99f0a77596a5ad819da1c2d214a0be60280fec", + "size": 65592, + "subdir": "linux-64", + "timestamp": 1539636180340, + "version": "0.4.2" + }, + "prometheus_client-0.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3cdcce69d22d8ca203a3c4cb2729ad1e", + "name": "prometheus_client", + "sha256": "7b7ebef4a57721f6401459dfc47c0df8442384a5c8b92d1b9e67133047a1ec10", + "size": 71237, + "subdir": "linux-64", + "timestamp": 1545082278434, + "version": "0.5.0" + }, + "prometheus_client-0.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8f5c647bde487ee0769922026299682e", + "name": "prometheus_client", + "sha256": "b7c580a45da7501eecb32eff90eacd24fab6e363b662251190d05e6e1b6c43c3", + "size": 70228, + "subdir": "linux-64", + "timestamp": 1545082310494, + "version": "0.5.0" + }, + "prometheus_client-0.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "70c0b0736815e33556857666363ec3ec", + "name": "prometheus_client", + "sha256": "742aa9213dd96a53106480c9246be05ef660c12f0e4fb9da808e243f26028d38", + "size": 71130, + "subdir": "linux-64", + "timestamp": 1545082314018, + "version": "0.5.0" + }, + "prometheus_client-0.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c43889134bf8da129c912485bd83f990", + "name": "prometheus_client", + "sha256": "7e3fc28a9517fd4abba97da2d5055372dfd6ed4c14cbf193e8d6badf22b22a4b", + "size": 73537, + "subdir": "linux-64", + "timestamp": 1551144511451, + "version": "0.6.0" + }, + "prometheus_client-0.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "062a1d8a3c893ea71f6e3704b1862703", + "name": "prometheus_client", + "sha256": "46b7b04ef6e8d96f0f80852059522d1ab755b58e19f417b2b518e727d8cce71d", + "size": 73495, + "subdir": "linux-64", + "timestamp": 1551144532597, + "version": "0.6.0" + }, + "prometheus_client-0.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cb30c1b78e17aed8efcaf4bd1c53843b", + "name": "prometheus_client", + "sha256": "16514501293abec11895bdbbbed43d4ed0549ae9866730dc679bf504d4393975", + "size": 73463, + "subdir": "linux-64", + "timestamp": 1551144508050, + "version": "0.6.0" + }, + "promise-2.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six", + "typing" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "72f7c508bd9f6e5ace25e852e17dfc9f", + "name": "promise", + "sha256": "34d1950e8cf736818c7a05a26f17d1d814ecc70e58c3fed5684ad2efa1bc4f14", + "size": 38527, + "subdir": "linux-64", + "timestamp": 1567009387330, + "version": "2.2.1" + }, + "promise-2.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d3bb01e2391f27904b1f4148dd9dd9c2", + "name": "promise", + "sha256": "556fe3267d323928bb79becbaf8fd436dd301ffdcac36f20427c83fef5a24ede", + "size": 38745, + "subdir": "linux-64", + "timestamp": 1567009407756, + "version": "2.2.1" + }, + "promise-2.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1bc870d6dc286ce1c92d5b4bbf9aecf4", + "name": "promise", + "sha256": "49f530172ecae8059f17bc1b1d1b9dc7b37e6b5c2d85548abb36c374bedc3aa6", + "size": 38729, + "subdir": "linux-64", + "timestamp": 1567009416427, + "version": "2.2.1" + }, + "promise-2.2.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "502cac17322cda1798b5c3bdec9968b5", + "name": "promise", + "sha256": "6a6275be47d7d6cd825841c85cc9d51987cec49f2f2a5823894884da2f3056e6", + "size": 38155, + "subdir": "linux-64", + "timestamp": 1574092672934, + "version": "2.2.1" + }, + "promise-2.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e129a0891a5ef4337dca818861f54ac", + "name": "promise", + "sha256": "1b910b68e2a36ebfc9a3180be29ba7378bbac822e6a46a1a8a78a123215fcf07", + "size": 38784, + "subdir": "linux-64", + "timestamp": 1640792583813, + "version": "2.3" + }, + "promise-2.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d7fb9e5acadeadcc3913c165a02bceed", + "name": "promise", + "sha256": "53fa642342e8778f3bedd34a91e54d988a4ca35c4e8bf194e7183c92bc33f0dc", + "size": 48176, + "subdir": "linux-64", + "timestamp": 1676860507132, + "version": "2.3" + }, + "promise-2.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17294bb436b05c1144fb40239459f66c", + "name": "promise", + "sha256": "8671b9c1e90a91bf23535d426e97f12ecce36957d8c2aa04a436b77bd1dbf701", + "size": 39298, + "subdir": "linux-64", + "timestamp": 1598040874913, + "version": "2.3" + }, + "promise-2.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c31ba1936fc3e5aff524699a8a21a23", + "name": "promise", + "sha256": "373f25b525842aafcd8590a6c1eccbae484c2b4cea7d677bf64cc6136b5e5f69", + "size": 39377, + "subdir": "linux-64", + "timestamp": 1614011682294, + "version": "2.3" + }, + "promise-2.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14fa906ca53097986432f7371f1bf889", + "name": "promise", + "sha256": "06c0236d07f325c4fe6ba5c190459881d8027b496a17f7ffe961b51df2dc1225", + "size": 39585, + "subdir": "linux-64", + "timestamp": 1598040891942, + "version": "2.3" + }, + "promise-2.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "237e842e364e9cd1b3c9b3faa660ecc7", + "name": "promise", + "sha256": "3a82aa059b4d6e75d7ed042cb7723f8c78c6d6d7a626f881e2ae552845fcaa3f", + "size": 39709, + "subdir": "linux-64", + "timestamp": 1614011672476, + "version": "2.3" + }, + "promise-2.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5fbdeee9b8befcf9f211fc4ad0d2fdfb", + "name": "promise", + "sha256": "52e747646e202399286c7dad27cfaa8f9d986f691678cb59c847f3ae51236418", + "size": 39566, + "subdir": "linux-64", + "timestamp": 1598040879817, + "version": "2.3" + }, + "promise-2.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aef9f1316ac0861e3f00775a7e1af28d", + "name": "promise", + "sha256": "33b9fb2395b26370e3390639f7b44346da3e22c6f9b25d4e90c9976b4ab8827b", + "size": 39740, + "subdir": "linux-64", + "timestamp": 1614011671895, + "version": "2.3" + }, + "promise-2.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2a540afff9117de2106f35c6756436cd", + "name": "promise", + "sha256": "910d55b163dc756465b82a7183442ea2c29a4135bc81bff09dd12bc24ae6bc51", + "size": 39617, + "subdir": "linux-64", + "timestamp": 1614011677561, + "version": "2.3" + }, + "prompt-toolkit-3.0.36-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "prompt_toolkit 3.0.36" + ], + "depends": [ + "python >=3.10,<3.11.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0391bde02f6f6528e97f565c4187ecfa", + "name": "prompt-toolkit", + "sha256": "f20ab57dc5c6033117f843dce3a958315fca629b4c5484e9401c08e0f3f7b76a", + "size": 605939, + "subdir": "linux-64", + "timestamp": 1672387422560, + "version": "3.0.36" + }, + "prompt-toolkit-3.0.36-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "prompt_toolkit 3.0.36" + ], + "depends": [ + "python >=3.11,<3.12.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "142a33a3e3aaa53181fd3178bf5813db", + "name": "prompt-toolkit", + "sha256": "6d2ac6eb30398424d4a7989d9ee87fcae54547fbc1b3847e727609d755a31002", + "size": 724071, + "subdir": "linux-64", + "timestamp": 1676824871153, + "version": "3.0.36" + }, + "prompt-toolkit-3.0.36-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "prompt_toolkit 3.0.36" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "374cfe5a394591d82d6635d66d57ad14", + "name": "prompt-toolkit", + "sha256": "e7136a8f496e61ec92a1be21808ff5338360fa679f3b8f4f759f79b064e99ed5", + "size": 584204, + "subdir": "linux-64", + "timestamp": 1672387367483, + "version": "3.0.36" + }, + "prompt-toolkit-3.0.36-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "prompt_toolkit 3.0.36" + ], + "depends": [ + "python >=3.8,<3.9.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a2559f302bce2c3c90a0c28050ec3d9a", + "name": "prompt-toolkit", + "sha256": "598272246c65b1da57513e8b29b3801b6e368b264ff249bba605c992bc10ea22", + "size": 587969, + "subdir": "linux-64", + "timestamp": 1672387395908, + "version": "3.0.36" + }, + "prompt-toolkit-3.0.36-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "prompt_toolkit 3.0.36" + ], + "depends": [ + "python >=3.9,<3.10.0a0", + "wcwidth" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "059b3b0f011176a7f5417788b8fc7a76", + "name": "prompt-toolkit", + "sha256": "98d9d103cef95f13302b380c823250da1dca5950a1c9163e83ee1a76426c44d0", + "size": 588054, + "subdir": "linux-64", + "timestamp": 1672387338600, + "version": "3.0.36" + }, + "prompt_toolkit-1.0.15-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "c055c8a1292340f441c373afb1ae6375", + "name": "prompt_toolkit", + "sha256": "16ee4a9d1e159f2f6c0216ac8fb74ca894668f5488c9ea305dd2bfeac6e49cc2", + "size": 339800, + "subdir": "linux-64", + "timestamp": 1530733844862, + "version": "1.0.15" + }, + "prompt_toolkit-1.0.15-py27h1b593e1_0.conda": { + "build": "py27h1b593e1_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "10b783e56f0a11b0e7f3f8a19e9bfb0a", + "name": "prompt_toolkit", + "sha256": "a6c4e34ba063a0a2caea5fd8b121496aa2ae36e53b21292762db3d822a2ad8dd", + "size": 339595, + "subdir": "linux-64", + "timestamp": 1505690322202, + "version": "1.0.15" + }, + "prompt_toolkit-1.0.15-py35hc09de7a_0.conda": { + "build": "py35hc09de7a_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.5,<3.6.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "c148cf07dfc65ff0c62be05d87e20265", + "name": "prompt_toolkit", + "sha256": "362ab5d4649b5c571d38804b811c5502111fc9600f875bab5e62eb0613b48c97", + "size": 351839, + "subdir": "linux-64", + "timestamp": 1505690339946, + "version": "1.0.15" + }, + "prompt_toolkit-1.0.15-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "aa51a7fae8e71c3c27a02192f92d9846", + "name": "prompt_toolkit", + "sha256": "fc9e3d8600f2326e205ff62a0e70179b62e9a02c34c79ca4d26654b7024f0dde", + "size": 347746, + "subdir": "linux-64", + "timestamp": 1530733819749, + "version": "1.0.15" + }, + "prompt_toolkit-1.0.15-py36h17d85b1_0.conda": { + "build": "py36h17d85b1_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "da86e064efcf27be061a5fa478d65430", + "name": "prompt_toolkit", + "sha256": "882a49ba013e55a142d4855af68fc902fb338d2572afb715a3235bc3969bda6d", + "size": 347710, + "subdir": "linux-64", + "timestamp": 1505690357987, + "version": "1.0.15" + }, + "prompt_toolkit-1.0.15-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "ad1d355c6a672aad1201ae3b6988bc1c", + "name": "prompt_toolkit", + "sha256": "46c899326d8e1d30528bcd2d6f65881893dacd9d2d7b7c364d4026b836a31346", + "size": 338530, + "subdir": "linux-64", + "timestamp": 1530733872047, + "version": "1.0.15" + }, + "prompt_toolkit-2.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "3fcf09c6b8a85f0d3ac572ad71139bf0", + "name": "prompt_toolkit", + "sha256": "4a2e4a57a42dcb790dd94633892b918640b30e920a6161882b4a6010f17375b4", + "size": 442556, + "subdir": "linux-64", + "timestamp": 1528213645297, + "version": "2.0.2" + }, + "prompt_toolkit-2.0.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.5,<3.6.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "902f38c5bcd9865fea7cfd7b36e9558e", + "name": "prompt_toolkit", + "sha256": "1be5878a4a80e898292d6278b3e16a4a6f8d3e090dd96980fbf4053fefc7e793", + "size": 450214, + "subdir": "linux-64", + "timestamp": 1528213787695, + "version": "2.0.2" + }, + "prompt_toolkit-2.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "3a49bb476d5f3015fef7e860ab85cf00", + "name": "prompt_toolkit", + "sha256": "c6190f0516f2eec78044a853ee740bb07bb68d11df869657d6dfe30a94038199", + "size": 436993, + "subdir": "linux-64", + "timestamp": 1528213773178, + "version": "2.0.2" + }, + "prompt_toolkit-2.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "eca5f4f7d766122eb297035e2fd9fc3a", + "name": "prompt_toolkit", + "sha256": "943d21c4bce9b1d92c21e65e4d3e13e052dc6b89a423a5dd68628af5f7c71e23", + "size": 442972, + "subdir": "linux-64", + "timestamp": 1528896624244, + "version": "2.0.3" + }, + "prompt_toolkit-2.0.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.5,<3.6.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "b6cbb21c48c8a208f420f14c85887831", + "name": "prompt_toolkit", + "sha256": "90fd07fabb20d269291b54b1afc9f728cac3c1b63a5b022b45ecc6ddb481514e", + "size": 450228, + "subdir": "linux-64", + "timestamp": 1528896660367, + "version": "2.0.3" + }, + "prompt_toolkit-2.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "92d955f78cf3019b176dcf6232d91ef2", + "name": "prompt_toolkit", + "sha256": "ee48bc5322d8ad8dbcc43e059a7fb72370aebd449c15618818a799a73253a575", + "size": 437338, + "subdir": "linux-64", + "timestamp": 1528895937303, + "version": "2.0.3" + }, + "prompt_toolkit-2.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "5c289c35b5d6c2e31b0a77ddc43df8bf", + "name": "prompt_toolkit", + "sha256": "850b309ede524177dfd969c9305f4fa3f52a639f95f9355bf3eefa1d2bde5ab2", + "size": 440410, + "subdir": "linux-64", + "timestamp": 1530733789839, + "version": "2.0.3" + }, + "prompt_toolkit-2.0.4-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "bed96331954ee6ddb2c7046cdb69fea1", + "name": "prompt_toolkit", + "sha256": "39803d5ea228b68492633a87e5c67d896e9668c614cd156d4b0cd0c6b7a029a9", + "size": 454051, + "subdir": "linux-64", + "timestamp": 1532371108087, + "version": "2.0.4" + }, + "prompt_toolkit-2.0.4-py27h28b3542_2.conda": { + "build": "py27h28b3542_2", + "build_number": 2, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "dbf1d630076b9e5e4fc7688b968149e2", + "name": "prompt_toolkit", + "sha256": "2f88e0da5f80ea920dbfc8f9ce86bb38aa8c7fc34d041f81fc4629125d840b73", + "size": 447968, + "subdir": "linux-64", + "timestamp": 1534350742231, + "version": "2.0.4" + }, + "prompt_toolkit-2.0.4-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "pygments", + "python >=3.5,<3.6.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "8958a679d117e069674d240a21c7201e", + "name": "prompt_toolkit", + "sha256": "aeaa18053d8eaa6d21bfa212f5e4e0f9e009b487b2972db63bb24f15307d8a82", + "size": 453673, + "subdir": "linux-64", + "timestamp": 1532371105480, + "version": "2.0.4" + }, + "prompt_toolkit-2.0.4-py35h28b3542_2.conda": { + "build": "py35h28b3542_2", + "build_number": 2, + "depends": [ + "pygments", + "python >=3.5,<3.6.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "32a0fcf2997033ce507a94ef807b4194", + "name": "prompt_toolkit", + "sha256": "1d352c5888f35176f193eac75329dc72076f9e95edd2f67b31a36f030c5819fa", + "size": 448004, + "subdir": "linux-64", + "timestamp": 1534350773955, + "version": "2.0.4" + }, + "prompt_toolkit-2.0.4-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "ba9995256381db070eb563fade35715e", + "name": "prompt_toolkit", + "sha256": "00c2720526fe4edc4d87f16daa30d6a11ce1d5813cc7319663eb8929649a643c", + "size": 455287, + "subdir": "linux-64", + "timestamp": 1532371101118, + "version": "2.0.4" + }, + "prompt_toolkit-2.0.4-py36h28b3542_2.conda": { + "build": "py36h28b3542_2", + "build_number": 2, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "ded3ac1c729eac0684da9a4d3254a483", + "name": "prompt_toolkit", + "sha256": "0381134f56e87f74ad9635e6cd3d45e00e64ae808638d93b4aa3b333c656bcf7", + "size": 449485, + "subdir": "linux-64", + "timestamp": 1534350806919, + "version": "2.0.4" + }, + "prompt_toolkit-2.0.4-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "9fc68f18216ffcd4fb3a084a5b2b5847", + "name": "prompt_toolkit", + "sha256": "1a0cd49c406f2ddaa8b8d24ee6bc7d34c4006e8f3a1bb77ddd2cfde5a1a86e4e", + "size": 452405, + "subdir": "linux-64", + "timestamp": 1532371123728, + "version": "2.0.4" + }, + "prompt_toolkit-2.0.4-py37h28b3542_2.conda": { + "build": "py37h28b3542_2", + "build_number": 2, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "d46e73d30f8705e154be2d0ba66986ef", + "name": "prompt_toolkit", + "sha256": "a2256ffd92c7aa382869b038b40fcb24603a94312bdab98f5785af3f0755e66c", + "size": 446253, + "subdir": "linux-64", + "timestamp": 1534350713990, + "version": "2.0.4" + }, + "prompt_toolkit-2.0.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "7f5b9c5c9481f97551f91c827c12e398", + "name": "prompt_toolkit", + "sha256": "6bfad5dff6e4ef75839e9626e4ba7af5e2cbc38ff42a5b6063a46ddbd4cbd2a9", + "size": 460525, + "subdir": "linux-64", + "timestamp": 1538595199112, + "version": "2.0.5" + }, + "prompt_toolkit-2.0.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "938bd839befc50e9499307c4219fcf96", + "name": "prompt_toolkit", + "sha256": "82b220d190b5a0c8f794d1c83aac1018c4e58f42ea39b005d452adaf5acdb074", + "size": 462583, + "subdir": "linux-64", + "timestamp": 1538595223900, + "version": "2.0.5" + }, + "prompt_toolkit-2.0.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "5d60c76df2decbc280ec8cc3545ea391", + "name": "prompt_toolkit", + "sha256": "5230197648ab8ae0133c17b4e397442f459fec7f9d3010ffbeb75d4ef37118a9", + "size": 452625, + "subdir": "linux-64", + "timestamp": 1538595185531, + "version": "2.0.5" + }, + "prompt_toolkit-2.0.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "5c9062b2d21b63b0405069eec6e1a1cb", + "name": "prompt_toolkit", + "sha256": "a87d3737504d08b2a155be98011256375cc271fa97dfc697390a6f8c80d3b71f", + "size": 464062, + "subdir": "linux-64", + "timestamp": 1539632255267, + "version": "2.0.6" + }, + "prompt_toolkit-2.0.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "df5e196287dd6f3cc134a72fefb08405", + "name": "prompt_toolkit", + "sha256": "2df0c9b8b2d1ec1f39dde96b4ea71a6795f71109bfe270273a617138747e2d3a", + "size": 459758, + "subdir": "linux-64", + "timestamp": 1539632267003, + "version": "2.0.6" + }, + "prompt_toolkit-2.0.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "fcf3c0af00d1694955bed360601cf8be", + "name": "prompt_toolkit", + "sha256": "2d4eb6451d694e6da71dea4feee940b9d11d82627c9cb5edd2fb5efa7323078a", + "size": 456507, + "subdir": "linux-64", + "timestamp": 1539632262910, + "version": "2.0.6" + }, + "prompt_toolkit-2.0.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "6945c49a966692c6585082ce99d8b21e", + "name": "prompt_toolkit", + "sha256": "b21d8d4e28dda9b051a68ae5950eea45f8cd741a30c99d6594860fc6a9ab4ba0", + "size": 459948, + "subdir": "linux-64", + "timestamp": 1541000121255, + "version": "2.0.7" + }, + "prompt_toolkit-2.0.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "33ec3c737a096e9a8672251d48a14386", + "name": "prompt_toolkit", + "sha256": "96013b61621b1be8290c78373abb07fc1adec3daf41c62fcab364727cfe91c9e", + "size": 460931, + "subdir": "linux-64", + "timestamp": 1541000156868, + "version": "2.0.7" + }, + "prompt_toolkit-2.0.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "98479f7fe90e4eb801e49593be46f880", + "name": "prompt_toolkit", + "sha256": "3c9c02ec81995b25cdccb92435bff49c50657ae15a64d50a9408abc8b5e4c707", + "size": 465045, + "subdir": "linux-64", + "timestamp": 1541000167199, + "version": "2.0.7" + }, + "prompt_toolkit-2.0.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "81a8976598b07c01c389e0519c27827d", + "name": "prompt_toolkit", + "sha256": "7aba2a8fd6130ff58e5626286ecd2476c327f05e100bef8123de61a7e1151f03", + "size": 469612, + "subdir": "linux-64", + "timestamp": 1551145013935, + "version": "2.0.9" + }, + "prompt_toolkit-2.0.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "79bc66a4e07acbfac63cbed211f0b0d0", + "name": "prompt_toolkit", + "sha256": "6316b6af0bfe47342eadb047cc7164a2f716ec588b11cef8812f2389b80e24de", + "size": 477997, + "subdir": "linux-64", + "timestamp": 1551145062794, + "version": "2.0.9" + }, + "prompt_toolkit-2.0.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "six >=1.9.0", + "wcwidth" + ], + "license": "BSD 3-clause", + "md5": "7c8c53fe43805dbcf2ecc20f71a7eb4f", + "name": "prompt_toolkit", + "sha256": "9bde47029a861ab9d13036ce95496138633c0e9d94d19d3844ec26658095e280", + "size": 474743, + "subdir": "linux-64", + "timestamp": 1551145007370, + "version": "2.0.9" + }, + "prophet-1.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "cython >=0.22", + "holidays >=0.10.2", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.21.2,<2.0a0", + "pandas >=1.0.4", + "pystan ~=2.19.1.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.8.0", + "setuptools-git >=1.2", + "tqdm >=4.36.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "defcfbaed36dc9ba54229181da909196", + "name": "prophet", + "sha256": "32ea6e07654079041bde61d031129f3b75ddbd61af6563f818d5bea2e06f9ea4", + "size": 620547, + "subdir": "linux-64", + "timestamp": 1646670019631, + "version": "1.0.1" + }, + "prophet-1.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "cython >=0.22", + "holidays >=0.10.2", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.21.2,<2.0a0", + "pandas >=1.0.4", + "pystan ~=2.19.1.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.8.0", + "setuptools-git >=1.2", + "tqdm >=4.36.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3af2cde6b7dc7b9144f5427b355634f", + "name": "prophet", + "sha256": "28599ab91be18539f4b370ee26e5a8a9d3a526307acd30de04c045a9616422e3", + "size": 628881, + "subdir": "linux-64", + "timestamp": 1646669769688, + "version": "1.0.1" + }, + "prophet-1.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "convertdate >=2.1.2", + "cython >=0.22", + "holidays >=0.10.2", + "lunarcalendar >=0.0.9", + "matplotlib-base >=2.0.0", + "numpy >=1.21.2,<2.0a0", + "pandas >=1.0.4", + "pystan ~=2.19.1.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.8.0", + "setuptools-git >=1.2", + "tqdm >=4.36.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7dabbd06d216ea2fc45cf2e32779123e", + "name": "prophet", + "sha256": "634a033040be35ca73ba774f61c2753827908420a9fd8f303ec0c21a4ae345fe", + "size": 628898, + "subdir": "linux-64", + "timestamp": 1646669536273, + "version": "1.0.1" + }, + "proto-plus-1.22.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.19.0,<5.0.0dev", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3d51d8e605e0692d689501a4c84ba705", + "name": "proto-plus", + "sha256": "0f72762223ac840285c66c211854b08de1e49ac8c785b4d2575f73fd5f27dbb4", + "size": 61138, + "subdir": "linux-64", + "timestamp": 1663770687255, + "version": "1.22.1" + }, + "proto-plus-1.22.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.19.0,<5.0.0dev", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cdeb73e0d29f9a3d21a743583836c60f", + "name": "proto-plus", + "sha256": "f8dfb9cfd23281c9c6a2dbd48060c29a8c16a1546b40e2e48f8726dd281ef447", + "size": 77084, + "subdir": "linux-64", + "timestamp": 1676860522132, + "version": "1.22.1" + }, + "proto-plus-1.22.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.19.0,<5.0.0dev", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1170b91639f8b5527af8e9b9fd94e06f", + "name": "proto-plus", + "sha256": "95dbfa19c4624f44993a49e57f28185a30de5c4f9aa5048deaf1e66480794c66", + "size": 60399, + "subdir": "linux-64", + "timestamp": 1663770621501, + "version": "1.22.1" + }, + "proto-plus-1.22.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.19.0,<5.0.0dev", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7e09cff34b595d36eb2eec9c206277e1", + "name": "proto-plus", + "sha256": "4b99707ac33ef473720ff4138460b54146bde283fb7a9551b5ae6c20b2210949", + "size": 60666, + "subdir": "linux-64", + "timestamp": 1663770595753, + "version": "1.22.1" + }, + "proto-plus-1.22.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "protobuf >=3.19.0,<5.0.0dev", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cb51ef2c797566bdf14a5b382a3da927", + "name": "proto-plus", + "sha256": "52e735049a8c7beae12f32b4ae1f47524647396f9f4b24aa1aa4406eb4863774", + "size": 60962, + "subdir": "linux-64", + "timestamp": 1663770648489, + "version": "1.22.1" + }, + "protobuf-3.10.1-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.10.1.*", + "libprotobuf >=3.10.1,<3.11.0a0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a54b444526d2999068b54306462ce9e0", + "name": "protobuf", + "sha256": "dc318bfb70b3004d092e847a7083e09935d30084e725504b1663e70723995eff", + "size": 649918, + "subdir": "linux-64", + "timestamp": 1573967328838, + "version": "3.10.1" + }, + "protobuf-3.10.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.10.1.*", + "libprotobuf >=3.10.1,<3.11.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a22fac75733bc471a91391ea8731aaa9", + "name": "protobuf", + "sha256": "24c5f771c1f2f5ca8204c1e756fe84f00afa81d21087bef896147b363a071e50", + "size": 652275, + "subdir": "linux-64", + "timestamp": 1573967332028, + "version": "3.10.1" + }, + "protobuf-3.10.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.10.1.*", + "libprotobuf >=3.10.1,<3.11.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fb7e7b0e2e584e38db3798126d3667ad", + "name": "protobuf", + "sha256": "fd8d66921cd9348bca19aa371ad9e54de48b80bd2f202436ac5018f1c9744160", + "size": 652456, + "subdir": "linux-64", + "timestamp": 1573967351342, + "version": "3.10.1" + }, + "protobuf-3.10.1-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.10.1.*", + "libprotobuf >=3.10.1,<3.11.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0c862cfaebcc3fa1cc1138ae9ccffd6a", + "name": "protobuf", + "sha256": "73ddbd9052656895c9bef227000164a3485e3eb3334c696875199e755465ee5a", + "size": 664761, + "subdir": "linux-64", + "timestamp": 1573967365887, + "version": "3.10.1" + }, + "protobuf-3.11.2-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.2.*", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8c846387997a5d237a0421fc3b85e7a3", + "name": "protobuf", + "sha256": "96f9306b8581cc3044558744ce285be46726eab8c1fe38cdc1629ee5c4d91470", + "size": 653693, + "subdir": "linux-64", + "timestamp": 1576541978932, + "version": "3.11.2" + }, + "protobuf-3.11.2-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.2.*", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "28d35a9707c2224c4ccba75b61c444ef", + "name": "protobuf", + "sha256": "5a11abef43b11350b3eb27662e92a023fcfe209ae439b3ccbbad86beb08ba79f", + "size": 650224, + "subdir": "linux-64", + "timestamp": 1576541982274, + "version": "3.11.2" + }, + "protobuf-3.11.2-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.2.*", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "258ca4130eb77dc1fad679aa65bddda4", + "name": "protobuf", + "sha256": "46bf1413f8d48d573dc5e62a1b652b68bbb674379126bb7772d4718fc7c4e849", + "size": 655367, + "subdir": "linux-64", + "timestamp": 1576541961397, + "version": "3.11.2" + }, + "protobuf-3.11.2-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.2.*", + "libprotobuf >=3.11.2,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1121d6ffa57870c986bda5a6f67da8d2", + "name": "protobuf", + "sha256": "536123fc738892fce844fcd7dd7ac6c53cf2726c5873fbf2e23d36b3b592a43e", + "size": 664045, + "subdir": "linux-64", + "timestamp": 1576542000389, + "version": "3.11.2" + }, + "protobuf-3.11.3-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.3.*", + "libprotobuf >=3.11.3,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c52d63e913ca7cb7f452955b25293851", + "name": "protobuf", + "sha256": "a476344a8c44ff26a0008f930607aacaf13974b8321ea2b4db2c86a4284836b6", + "size": 655175, + "subdir": "linux-64", + "timestamp": 1581544436423, + "version": "3.11.3" + }, + "protobuf-3.11.3-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.3.*", + "libprotobuf >=3.11.3,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "19400ea0383706b94b25bf10ad9af6eb", + "name": "protobuf", + "sha256": "28b2458b77b21dac7e12604a1042c72f58d0f24692d0513c83f303dfe39eb851", + "size": 650707, + "subdir": "linux-64", + "timestamp": 1581544414798, + "version": "3.11.3" + }, + "protobuf-3.11.3-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.3.*", + "libprotobuf >=3.11.3,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ae3713ce37d56e1de68bfccd0ee26170", + "name": "protobuf", + "sha256": "5efda433ac4fcaf9fe159e9cec4fad80958f362044107e213d17e408e4438434", + "size": 660615, + "subdir": "linux-64", + "timestamp": 1581544410834, + "version": "3.11.3" + }, + "protobuf-3.11.4-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.4.*", + "libprotobuf >=3.11.4,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fa0d75afea29743aa68686ae37c76427", + "name": "protobuf", + "sha256": "fb184e7d687d1390a33c26ad86cbc6bcd4986b97ced0b4d225907d44d657d874", + "size": 650475, + "subdir": "linux-64", + "timestamp": 1581952699444, + "version": "3.11.4" + }, + "protobuf-3.11.4-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.4.*", + "libprotobuf >=3.11.4,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3bb4ab8d8b77be8939733766347f7828", + "name": "protobuf", + "sha256": "65d9c56c3f84f63cae7121b87c9dbf32e0db76f1b070260801a3759d0c0a9b07", + "size": 651720, + "subdir": "linux-64", + "timestamp": 1581952684639, + "version": "3.11.4" + }, + "protobuf-3.11.4-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.11.4.*", + "libprotobuf >=3.11.4,<3.12.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "546d20ed175086f9ad012d3654e7c8ee", + "name": "protobuf", + "sha256": "fb8fd8483760f2d1f165eac411b4436d99a672e7de7163d7cfed03aca1dc35c4", + "size": 657026, + "subdir": "linux-64", + "timestamp": 1581952695124, + "version": "3.11.4" + }, + "protobuf-3.12.3-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.12.3.*", + "libprotobuf >=3.12.3,<3.13.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ee439985c834d2143100e98bace472e6", + "name": "protobuf", + "sha256": "5407bd8b9692ffa3caaab817328248446de14090fcf7e941a51fb6931e9330b5", + "size": 659944, + "subdir": "linux-64", + "timestamp": 1591841173835, + "version": "3.12.3" + }, + "protobuf-3.12.3-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.12.3.*", + "libprotobuf >=3.12.3,<3.13.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "59f6b0702bfa64f2e56c9ed5788a498d", + "name": "protobuf", + "sha256": "1dda3df647a2b8287f1193d59eeef4e5562e29c95215c354072e849ffd446996", + "size": 660749, + "subdir": "linux-64", + "timestamp": 1591841183875, + "version": "3.12.3" + }, + "protobuf-3.12.3-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.12.3.*", + "libprotobuf >=3.12.3,<3.13.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "888316f9eee9083736f348baa86836ff", + "name": "protobuf", + "sha256": "74eeb6b21f552ca5760f7c4a09687696c002fdabb14c2f4988c628e94859c5cb", + "size": 663483, + "subdir": "linux-64", + "timestamp": 1591841189162, + "version": "3.12.3" + }, + "protobuf-3.12.4-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.12.4.*", + "libprotobuf >=3.12.4,<3.13.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0dd9020baa2fe97e77525dab217d3600", + "name": "protobuf", + "sha256": "3d620a7f73bd4c54d94c05e99766f8079f3a8ce41279e64eefd276186e67230e", + "size": 665500, + "subdir": "linux-64", + "timestamp": 1597437996877, + "version": "3.12.4" + }, + "protobuf-3.12.4-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.12.4.*", + "libprotobuf >=3.12.4,<3.13.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e87d19bf379653e0e51cf124b7d58d8b", + "name": "protobuf", + "sha256": "5abce6b59c3e1c1da1fe36c7f2e5a8c5457038fe1d1a844467abb727161756fb", + "size": 664869, + "subdir": "linux-64", + "timestamp": 1597437998970, + "version": "3.12.4" + }, + "protobuf-3.12.4-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.12.4.*", + "libprotobuf >=3.12.4,<3.13.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bfed65c157fdac949828086045af42de", + "name": "protobuf", + "sha256": "eafa0669943f9e95b43de0a333f26e1159330341c3a4541d96f627e2a13487aa", + "size": 671495, + "subdir": "linux-64", + "timestamp": 1597437967055, + "version": "3.12.4" + }, + "protobuf-3.13.0-py36he6710b0_1.conda": { + "build": "py36he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.13.0.*", + "libprotobuf >=3.13.0,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0c90d57d58988244aae05a463acc8626", + "name": "protobuf", + "sha256": "26214a19b080396321f908eee9eb08c148e84ee0ed05ff5f09b2c1a495fffcfd", + "size": 658072, + "subdir": "linux-64", + "timestamp": 1601504435864, + "version": "3.13.0" + }, + "protobuf-3.13.0-py37he6710b0_1.conda": { + "build": "py37he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.13.0.*", + "libprotobuf >=3.13.0,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "be4b6032a1048f2d41f8ccf6b63639cb", + "name": "protobuf", + "sha256": "c759887b6e84b24ac29f6267abcc28be882929046544f03943c59b07d4e27122", + "size": 661612, + "subdir": "linux-64", + "timestamp": 1601504421885, + "version": "3.13.0" + }, + "protobuf-3.13.0-py37hf484d3e_0.conda": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.13.0.*", + "libprotobuf >=3.13.0,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6f333c4b06d627f12b03c31f726521f9", + "name": "protobuf", + "sha256": "96a3437a34ea117a25ff094473ecd5823c11dde1ce965f038adf139b6a3c2623", + "size": 647932, + "subdir": "linux-64", + "timestamp": 1597940347337, + "version": "3.13.0" + }, + "protobuf-3.13.0-py37hf484d3e_1.conda": { + "build": "py37hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.13.0.*", + "libprotobuf >=3.13.0,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fe1d2037a8876a156cf4c78429746c01", + "name": "protobuf", + "sha256": "8e8f7a6e9ca6ccaab52ed33d395eedd86d4d517b591cb85bc9fe9bd73bca8b22", + "size": 657407, + "subdir": "linux-64", + "timestamp": 1601504492451, + "version": "3.13.0" + }, + "protobuf-3.13.0-py38he6710b0_1.conda": { + "build": "py38he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.13.0.*", + "libprotobuf >=3.13.0,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "009b11f0f075b6c777af885825c9a44a", + "name": "protobuf", + "sha256": "4090903755f21a1dfa3858ffabbaa94b06f172522968223aaed67f6ab1a45ef5", + "size": 664739, + "subdir": "linux-64", + "timestamp": 1601504465955, + "version": "3.13.0" + }, + "protobuf-3.13.0.1-py36he6710b0_1.conda": { + "build": "py36he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.13.0.1.*", + "libprotobuf >=3.13.0.1,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5ab708d00bcb5170c1c78e44440e0ab5", + "name": "protobuf", + "sha256": "35a38005a706938f8b86f07c4859f5a0b1fbaf4c5044d5bc2ed88e185ce79d87", + "size": 648651, + "subdir": "linux-64", + "timestamp": 1602616332348, + "version": "3.13.0.1" + }, + "protobuf-3.13.0.1-py37he6710b0_1.conda": { + "build": "py37he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.13.0.1.*", + "libprotobuf >=3.13.0.1,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d8e21ac4402bd428646a11ffa643467e", + "name": "protobuf", + "sha256": "425018122dfc41bcf8cd41d289e2a3c05cc364bd3fb6fb1d14805b4699b2a051", + "size": 649313, + "subdir": "linux-64", + "timestamp": 1602616335335, + "version": "3.13.0.1" + }, + "protobuf-3.13.0.1-py38he6710b0_1.conda": { + "build": "py38he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.13.0.1.*", + "libprotobuf >=3.13.0.1,<3.14.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "628b90e9a009de98bc658d9a89814661", + "name": "protobuf", + "sha256": "e45c60ed2d32171537c269a2d50ddc88ffd62c35c8593af7b3f00f19f2f24f20", + "size": 651214, + "subdir": "linux-64", + "timestamp": 1602616340549, + "version": "3.13.0.1" + }, + "protobuf-3.14.0-py36h2531618_1.conda": { + "build": "py36h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.14.0.*", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c41bed148dea9a269268d3cd296f8474", + "name": "protobuf", + "sha256": "986f85afbb5e5d77cf850ea70524b1a655365e7d8df5e647f563b1d465de27eb", + "size": 309806, + "subdir": "linux-64", + "timestamp": 1612296164599, + "version": "3.14.0" + }, + "protobuf-3.14.0-py37h2531618_1.conda": { + "build": "py37h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.14.0.*", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1d0e1c91bbf8e4348e081f02cee6cc1c", + "name": "protobuf", + "sha256": "c2a9b4f1e98460b89e2c1515d3d2fd2a1aa6489957b57903802643a899904dc6", + "size": 309897, + "subdir": "linux-64", + "timestamp": 1612296151228, + "version": "3.14.0" + }, + "protobuf-3.14.0-py38h2531618_1.conda": { + "build": "py38h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.14.0.*", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7a0ebdc3956014ad0f9efdf53bc69d86", + "name": "protobuf", + "sha256": "46695f369d151eb6395eb90ea6e962d6a83a03e5bb94a57cf3eadd9f9398ffcc", + "size": 316160, + "subdir": "linux-64", + "timestamp": 1612296159855, + "version": "3.14.0" + }, + "protobuf-3.14.0-py39h2531618_1.conda": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.14.0.*", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fe9b309df59dbbcfbd77c43e468c9ef6", + "name": "protobuf", + "sha256": "3618aaf7ba09dcf7ee8964159055d0f2b376fc1f1911189a41fdbbc3814f2159", + "size": 313160, + "subdir": "linux-64", + "timestamp": 1612296162097, + "version": "3.14.0" + }, + "protobuf-3.17.2-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.17.2.*", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9cc027e638f24a35a0911d771e4be5c0", + "name": "protobuf", + "sha256": "8d5bf81e6fea980fd60e6ff56781a9e93ec8d8b4b33ce1e6c2404b3911179f12", + "size": 1350538, + "subdir": "linux-64", + "timestamp": 1640792625757, + "version": "3.17.2" + }, + "protobuf-3.17.2-py36h295c915_0.conda": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.17.2.*", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "55803214cd3f23722023552cad7c7648", + "name": "protobuf", + "sha256": "302f39a2e821a1d2c9aadf19d13557e0cff42fd7c2dfbe0960bced88ed3b9f14", + "size": 326717, + "subdir": "linux-64", + "timestamp": 1626459552333, + "version": "3.17.2" + }, + "protobuf-3.17.2-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.17.2.*", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ed5488976db8661b8380456290a645f3", + "name": "protobuf", + "sha256": "089a793cee7d049eff368861cd0f5ea6336643dd63b705a921dbc656047742da", + "size": 327051, + "subdir": "linux-64", + "timestamp": 1626452361906, + "version": "3.17.2" + }, + "protobuf-3.17.2-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.17.2.*", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a03f3dfbf1238b6db818e9a31562115c", + "name": "protobuf", + "sha256": "39c1b9169577fb037934d16932ea289b26b1b1e7df7b0cea4b15f3604c3f0353", + "size": 333151, + "subdir": "linux-64", + "timestamp": 1626459534541, + "version": "3.17.2" + }, + "protobuf-3.17.2-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.17.2.*", + "libprotobuf >=3.17.2,<3.18.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb3bff2160cdc0d7f38369e1c2db2342", + "name": "protobuf", + "sha256": "d52da200e33e371fd39c261a38c1755271b7acea3f64d00f0dfd376fc822341f", + "size": 329753, + "subdir": "linux-64", + "timestamp": 1626459555773, + "version": "3.17.2" + }, + "protobuf-3.19.1-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.19.1.*", + "libprotobuf >=3.19.1,<3.20.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cebf491b00f646831acb13b40443e5ac", + "name": "protobuf", + "sha256": "805f0991e186a246d149db2a665795b3d981cb1417496404a81b43384f0d96db", + "size": 1353965, + "subdir": "linux-64", + "timestamp": 1655800227805, + "version": "3.19.1" + }, + "protobuf-3.19.1-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.19.1.*", + "libprotobuf >=3.19.1,<3.20.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "356a4a5da0976801618380cf1d66ee5a", + "name": "protobuf", + "sha256": "0832c706bbf9f545628803e2cd42e89c6a60a94fc5ddca59e397e99f5367b9e0", + "size": 312911, + "subdir": "linux-64", + "timestamp": 1641480716434, + "version": "3.19.1" + }, + "protobuf-3.19.1-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.19.1.*", + "libprotobuf >=3.19.1,<3.20.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d235460e27f0113a59c9bc9b4b0018b9", + "name": "protobuf", + "sha256": "5fbf5bcce1b0c765f921f5a6633b62401ab6f879dfe62784b29e62cd5c407c5a", + "size": 315732, + "subdir": "linux-64", + "timestamp": 1641495490725, + "version": "3.19.1" + }, + "protobuf-3.19.1-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.19.1.*", + "libprotobuf >=3.19.1,<3.20.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "14470ff8ff7daafcb04271d3ce15225c", + "name": "protobuf", + "sha256": "77def3c0a06dab71bec896d94567aa4ab72f38094ddb660cbc57590ac675e683", + "size": 316675, + "subdir": "linux-64", + "timestamp": 1641480715429, + "version": "3.19.1" + }, + "protobuf-3.19.6-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.19.6.*", + "libprotobuf >=3.19.6,<3.20.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bffb4185912c4a174c9fc3befb467fa8", + "name": "protobuf", + "sha256": "33abe7b0c9125b9ee1c9618268a8660b2e9797f7f767f0144577a8fc15156d02", + "size": 335113, + "subdir": "linux-64", + "timestamp": 1675281662997, + "version": "3.19.6" + }, + "protobuf-3.19.6-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.19.6.*", + "libprotobuf >=3.19.6,<3.20.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "67a2f24b7fdc24de4e126128454aeae9", + "name": "protobuf", + "sha256": "75bafe4b2651513b8614df3a10c847b2c6aae5ca04e1f6bdf0d830c55e0e2f16", + "size": 330271, + "subdir": "linux-64", + "timestamp": 1675281619494, + "version": "3.19.6" + }, + "protobuf-3.19.6-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.19.6.*", + "libprotobuf >=3.19.6,<3.20.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "16ee3dbd111796bce3c6e2ad1f358944", + "name": "protobuf", + "sha256": "931c3f7ecee9b3c1754e0cf5887c10442ab1a96dddd03bc46e12a49d2e23508c", + "size": 333315, + "subdir": "linux-64", + "timestamp": 1675281749521, + "version": "3.19.6" + }, + "protobuf-3.19.6-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.19.6.*", + "libprotobuf >=3.19.6,<3.20.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9bd1b600337cf36495ebe5cae8e9d964", + "name": "protobuf", + "sha256": "90df14576525ea6ac8b639048a9d07f9871e4b5383701fe5a61a1e6349776ccf", + "size": 332906, + "subdir": "linux-64", + "timestamp": 1675281706197, + "version": "3.19.6" + }, + "protobuf-3.20.1-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.20.1.*", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e53c62c79c8e0abc4d7e0d6156888b69", + "name": "protobuf", + "sha256": "e019c8de44e3cb77da47a2a8ed56dfb3eb72e20723bf45a44410f5e0474f49fc", + "size": 1363699, + "subdir": "linux-64", + "timestamp": 1652441733428, + "version": "3.20.1" + }, + "protobuf-3.20.1-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.20.1.*", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f4782aa020c6ae194af2d8afd75275b3", + "name": "protobuf", + "sha256": "05c31c7779b0b88efbf9c33bdf36430f76bedc738a4af0538291659650487a57", + "size": 297231, + "subdir": "linux-64", + "timestamp": 1652441616116, + "version": "3.20.1" + }, + "protobuf-3.20.1-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.20.1.*", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "21c564cac1f36542e345cb244a200d46", + "name": "protobuf", + "sha256": "840ac9f5c6d5503e606575b35ccfd39944ebe3ee75c6b528ca4e45ff501afc64", + "size": 300106, + "subdir": "linux-64", + "timestamp": 1652441531461, + "version": "3.20.1" + }, + "protobuf-3.20.1-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libprotobuf 3.20.1.*", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "76bbfd2bbb80346675378d14ea29a90d", + "name": "protobuf", + "sha256": "6fdd66b93c10fe62aaf2f835bb36bc0b06269a3f34a5ba525da55139b78110bb", + "size": 299871, + "subdir": "linux-64", + "timestamp": 1652441824198, + "version": "3.20.1" + }, + "protobuf-3.20.3-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.20.3.*", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9608bfcdcafed2541380c8a692321fdb", + "name": "protobuf", + "sha256": "992065d632d13cfd16869d5eaec70c82cd59274e5429e235a6dac1d5f636433c", + "size": 335863, + "subdir": "linux-64", + "timestamp": 1675281211637, + "version": "3.20.3" + }, + "protobuf-3.20.3-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.20.3.*", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b5924faf73035b3e2c1d1f6ffa8d7171", + "name": "protobuf", + "sha256": "e96c698fe8eed8bd0dafb8104b22fb28c7ab7dd6fa7b1dd49eea134427edee95", + "size": 372910, + "subdir": "linux-64", + "timestamp": 1676828758195, + "version": "3.20.3" + }, + "protobuf-3.20.3-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.20.3.*", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bed78446b72af8dc2abdceac7352b14b", + "name": "protobuf", + "sha256": "c17064382b89abd531f2d60c16dc33b4a9a3e9db766665e5b2ac2446d084f660", + "size": 331354, + "subdir": "linux-64", + "timestamp": 1675281298966, + "version": "3.20.3" + }, + "protobuf-3.20.3-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.20.3.*", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "02b63671afbe60cc90334eb0cfa07ba0", + "name": "protobuf", + "sha256": "be154237956cd315f9d6f838a6533b86fb9dc568649a0b229f4334429563cc1e", + "size": 334114, + "subdir": "linux-64", + "timestamp": 1675281255438, + "version": "3.20.3" + }, + "protobuf-3.20.3-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libprotobuf 3.20.3.*", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38650c7a95654b722c8c5158008c9c01", + "name": "protobuf", + "sha256": "5f87731e99ed82198d31d264f70549ab849d43ac26be6bbf230b601161c3a9c6", + "size": 333945, + "subdir": "linux-64", + "timestamp": 1675281342341, + "version": "3.20.3" + }, + "protobuf-3.4.1-py27h2ba6a9c_0.conda": { + "build": "py27h2ba6a9c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "New BSD License", + "license_family": "BSD", + "md5": "deec8e763447b013ae95713e33492bfb", + "name": "protobuf", + "sha256": "12c3afb6b0e6dddc49ef1c17867354cbb9c56ce33b2b8b7971d3b49f0a6406fa", + "size": 536445, + "subdir": "linux-64", + "timestamp": 1510782604119, + "version": "3.4.1" + }, + "protobuf-3.4.1-py35he6b9134_0.conda": { + "build": "py35he6b9134_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "New BSD License", + "license_family": "BSD", + "md5": "73efc6ab2da929d41f96cfbdc1283f4f", + "name": "protobuf", + "sha256": "2af8307e8be91b3909054790cc1aac7c784e1a825e3ae4b30ab739f883edef17", + "size": 541122, + "subdir": "linux-64", + "timestamp": 1510782633634, + "version": "3.4.1" + }, + "protobuf-3.4.1-py36h306e679_0.conda": { + "build": "py36h306e679_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.4.1,<3.5.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "New BSD License", + "license_family": "BSD", + "md5": "2b2352dde9c4da23734791aeac796407", + "name": "protobuf", + "sha256": "306e7c72d4de8cefa1413f9604b7185ebf9420e797490b73715ef01f2cd58bd1", + "size": 535589, + "subdir": "linux-64", + "timestamp": 1510782634408, + "version": "3.4.1" + }, + "protobuf-3.5.1-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "New BSD License", + "license_family": "BSD", + "md5": "568fe348267bce26fdc7230cff98813f", + "name": "protobuf", + "sha256": "b7f1d1bd8d9a4a63f90ead86b30325aee441a99ebb394ec30242822822f215bd", + "size": 558381, + "subdir": "linux-64", + "timestamp": 1519948869259, + "version": "3.5.1" + }, + "protobuf-3.5.1-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "New BSD License", + "license_family": "BSD", + "md5": "a3ac021b14c64de10b1fe738b17c7dbd", + "name": "protobuf", + "sha256": "dd58f1990bc48ddde8b32b4081e39815a6d83b392b8f5f8ee3602972973a47d6", + "size": 566727, + "subdir": "linux-64", + "timestamp": 1519948917107, + "version": "3.5.1" + }, + "protobuf-3.5.1-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.1,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "New BSD License", + "license_family": "BSD", + "md5": "f5ef90eeba1df54c4818f4e17820b92b", + "name": "protobuf", + "sha256": "46ba23957a3ed97ade88d3055262e85cd3ecc52031143579cda4e4c87ad6a67e", + "size": 558736, + "subdir": "linux-64", + "timestamp": 1519951148379, + "version": "3.5.1" + }, + "protobuf-3.5.2-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d91108789dcbdbcc0eeff31f1babead5", + "name": "protobuf", + "sha256": "b6f3cdd2ebf325bcb6a1ac17e1a042a8d09cf1bb69864389add279134d98a85f", + "size": 569652, + "subdir": "linux-64", + "timestamp": 1523041714162, + "version": "3.5.2" + }, + "protobuf-3.5.2-py27hf484d3e_1.conda": { + "build": "py27hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ff005ae4bde1f5dc27de3caadac5e2fb", + "name": "protobuf", + "sha256": "8652e6c3e5234b4f3361066ebb3cc1b87915fb830bde0e2145ba68476f0e0113", + "size": 567872, + "subdir": "linux-64", + "timestamp": 1530782452752, + "version": "3.5.2" + }, + "protobuf-3.5.2-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2fe69b301f2fc22bdc8ff337cbdaa66a", + "name": "protobuf", + "sha256": "415ef62584297248e554fc5ebec53c0a1ed8ffe923fd56e588891a9bfcbf09b2", + "size": 578127, + "subdir": "linux-64", + "timestamp": 1523041757204, + "version": "3.5.2" + }, + "protobuf-3.5.2-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7950196aa2a660500e7e0bca72f1bf6a", + "name": "protobuf", + "sha256": "0a8a91dcd99a9cea8aac1945bda99cab0f19d099b1790c2402039cbbfe24cd49", + "size": 571440, + "subdir": "linux-64", + "timestamp": 1523041758796, + "version": "3.5.2" + }, + "protobuf-3.5.2-py36hf484d3e_1.conda": { + "build": "py36hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "72df2c6fbe0afe816fb183dc9bbb848a", + "name": "protobuf", + "sha256": "9ec7d78f34405b1af7c935b38f09b5b711dc3e63aab34012ac09bcfcc89261b7", + "size": 572099, + "subdir": "linux-64", + "timestamp": 1530782526319, + "version": "3.5.2" + }, + "protobuf-3.5.2-py37hf484d3e_1.conda": { + "build": "py37hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.5.2,<3.6.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "48299f9b1e18cd9b38c01bbd6c59d5d2", + "name": "protobuf", + "sha256": "c7e02072f75c48cd25cd440a9ecd51a30b3fb1a162ea6c6ab63fbce09335cc79", + "size": 569953, + "subdir": "linux-64", + "timestamp": 1530782597373, + "version": "3.5.2" + }, + "protobuf-3.6.0-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1af0c396e3ced77449a2886ae65b289c", + "name": "protobuf", + "sha256": "8785598b386f4c13fe5604d805a1d061fc5c74895eb0ce831f8c5b51db442136", + "size": 568184, + "subdir": "linux-64", + "timestamp": 1534346112937, + "version": "3.6.0" + }, + "protobuf-3.6.0-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f8cd07ec952bdee0c8d06000278e61e9", + "name": "protobuf", + "sha256": "f4119e1a8b0449cd63e519bf49807d208d2e9aef0e402e17af115760ef69cc11", + "size": 576089, + "subdir": "linux-64", + "timestamp": 1534346126750, + "version": "3.6.0" + }, + "protobuf-3.6.0-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "395c3807fdde8e2ca8c80f608bca2b70", + "name": "protobuf", + "sha256": "d65f957541040391b229bf1133e72ae3482fd99619da6e3d5e28d987e5b30683", + "size": 572471, + "subdir": "linux-64", + "timestamp": 1534346128872, + "version": "3.6.0" + }, + "protobuf-3.6.0-py37hf484d3e_0.conda": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libprotobuf >=3.6.0,<3.6.1.0a0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b79bf18ede16a325eb73b804f08824eb", + "name": "protobuf", + "sha256": "729b9777a5110cb6bf1edf70bab7016ff4fa331a4eff213c355497a4e34c24dd", + "size": 572846, + "subdir": "linux-64", + "timestamp": 1534346195097, + "version": "3.6.0" + }, + "protobuf-3.6.1-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.1,<3.6.2.0a0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f03655415c876f0a88f2042959de1512", + "name": "protobuf", + "sha256": "706042952f439bdb88762c614d773b6c5ed9e372d66b2dbb0d2a42da77aefc7e", + "size": 573644, + "subdir": "linux-64", + "timestamp": 1541097908950, + "version": "3.6.1" + }, + "protobuf-3.6.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.1,<3.6.2.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b52f24c39597e8da9d931cbd036cb361", + "name": "protobuf", + "sha256": "ceb89dae72168d9dd3d8bfbd3bd67ab9987021e84619602622902628e137f0e6", + "size": 573276, + "subdir": "linux-64", + "timestamp": 1541097946270, + "version": "3.6.1" + }, + "protobuf-3.6.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.6.1,<3.6.2.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2c3ee22418d2d9fb8b4c8ff169b3bfbe", + "name": "protobuf", + "sha256": "2bbb3238f77eca5e9d9648057fc37a23b35f7f21cdb0632b25778998dbee4911", + "size": 573076, + "subdir": "linux-64", + "timestamp": 1541097926829, + "version": "3.6.1" + }, + "protobuf-3.7.1-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.7.1,<3.8.0a0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "57577ce53fbebe07f424410859ec7148", + "name": "protobuf", + "sha256": "f18cfe5ef1bddfcea9e610f4d7e5d8133ada5a40877ef8cca118ba3778f0dd9d", + "size": 605459, + "subdir": "linux-64", + "timestamp": 1556566035184, + "version": "3.7.1" + }, + "protobuf-3.7.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.7.1,<3.8.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fbf9b636bcea44273185ceb5979164d9", + "name": "protobuf", + "sha256": "01ae9f3c4b239c89aadeee8fffb734554e587670d37654513aa88d3501c5974f", + "size": 609751, + "subdir": "linux-64", + "timestamp": 1556566035093, + "version": "3.7.1" + }, + "protobuf-3.7.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf >=3.7.1,<3.8.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6792bdbdb00f45c8d2f75d074b143217", + "name": "protobuf", + "sha256": "04803cdd95360b831f29bfa68ff097a1f2893a28f40e3c15cb255514e569b1a0", + "size": 610140, + "subdir": "linux-64", + "timestamp": 1556565986563, + "version": "3.7.1" + }, + "protobuf-3.8.0-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.8.0.*", + "libprotobuf >=3.8.0,<3.9.0a0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f62dddc17f5f8738676db2b391df1b1b", + "name": "protobuf", + "sha256": "a432f011089fb9272a13f034b22af7efe36ea36849cf385c73a360ad072e03de", + "size": 636507, + "subdir": "linux-64", + "timestamp": 1559918960273, + "version": "3.8.0" + }, + "protobuf-3.8.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.8.0.*", + "libprotobuf >=3.8.0,<3.9.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5b78b841e1665d64f69ab34397c0615c", + "name": "protobuf", + "sha256": "1d4a18469c4842569ee18dc4d934fed59ffa6b712c7b9f0d17b939189bbfcbf2", + "size": 639066, + "subdir": "linux-64", + "timestamp": 1559918946891, + "version": "3.8.0" + }, + "protobuf-3.8.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.8.0.*", + "libprotobuf >=3.8.0,<3.9.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2b8409e7242a69304bf82be59d690395", + "name": "protobuf", + "sha256": "ca631e72009b9361db0b55647df975597d0f7fd444363fd12b55ed7c6bb3e11f", + "size": 634482, + "subdir": "linux-64", + "timestamp": 1559918951632, + "version": "3.8.0" + }, + "protobuf-3.9.2-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.9.2.*", + "libprotobuf >=3.9.2,<3.10.0a0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1bcb903c678048969d2a345b10267047", + "name": "protobuf", + "sha256": "97f29115f7e4e6c049d66bbb6c53140fd855d9fbfc6ad37d05ea13ba020a103a", + "size": 644120, + "subdir": "linux-64", + "timestamp": 1569267604069, + "version": "3.9.2" + }, + "protobuf-3.9.2-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.9.2.*", + "libprotobuf >=3.9.2,<3.10.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "86517edb9f161440c879818eed3095f0", + "name": "protobuf", + "sha256": "ae44ebc9eef20bc0ea72617634fc38887139b264677d9fb54fbc26ddfe3f6558", + "size": 642634, + "subdir": "linux-64", + "timestamp": 1569267603633, + "version": "3.9.2" + }, + "protobuf-3.9.2-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.9.2.*", + "libprotobuf >=3.9.2,<3.10.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b2f2f2f9b09a283fba42a7f3d3e40e46", + "name": "protobuf", + "sha256": "1a27f2c384dcdd99c0f69a5476980bce0c016c7b3b22fcc4871b7086368608c8", + "size": 646415, + "subdir": "linux-64", + "timestamp": 1569267602123, + "version": "3.9.2" + }, + "protobuf-3.9.2-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libprotobuf 3.9.2.*", + "libprotobuf >=3.9.2,<3.10.0a0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6fa547b9ce431a4880c9926e1861fb8d", + "name": "protobuf", + "sha256": "605e58f800cd528971c335d06e46f376eb754c4894f127fd7bdfe06a27001c1b", + "size": 648744, + "subdir": "linux-64", + "timestamp": 1573469677508, + "version": "3.9.2" + }, + "pscript-0.5.5-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "f2ad052da70e82a26606e159e1f9d22b", + "name": "pscript", + "sha256": "250b3faddd9e717072db9c1ef403ba21507d0f82f1ea1c96f9ba3863e191fce0", + "size": 108778, + "subdir": "linux-64", + "timestamp": 1531495030190, + "version": "0.5.5" + }, + "pscript-0.5.5-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "6d0e967370f8805d65af6bd014bf5ec1", + "name": "pscript", + "sha256": "1031fe7ad78c042f2ea6126d591cdd6b59e113663ae97f2ef74aa318f62995d7", + "size": 107678, + "subdir": "linux-64", + "timestamp": 1531495038652, + "version": "0.5.5" + }, + "pscript-0.5.5-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "e2ac0dbaf39d39408102375375d231b2", + "name": "pscript", + "sha256": "ad8d260c7da38e61b11ef083823bbd4ceca3781978f0c39ae170a7bbccebcb1d", + "size": 108606, + "subdir": "linux-64", + "timestamp": 1531495105848, + "version": "0.5.5" + }, + "pscript-0.5.5-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "ccef5519636de2b56e8ffc95bd949e83", + "name": "pscript", + "sha256": "a2197d945ca75c5e5a079571d758695dd9356a7db3187f9b966e49e3cf339113", + "size": 108156, + "subdir": "linux-64", + "timestamp": 1531495045718, + "version": "0.5.5" + }, + "pscript-0.6.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "30da22414b287f236fdc5080c5e11b59", + "name": "pscript", + "sha256": "f718dc28a3eefb6871519160333af718e132111dbebca98c9e1c8c5cc71c7811", + "size": 110429, + "subdir": "linux-64", + "timestamp": 1535512096894, + "version": "0.6.0" + }, + "pscript-0.6.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "00f8e839a3133cb33f4461663c905b2c", + "name": "pscript", + "sha256": "6356861f25ef4fb9d361c2b40c24a421d1c9053227edcf611ef1b8d0c8dfcd21", + "size": 107660, + "subdir": "linux-64", + "timestamp": 1535512103651, + "version": "0.6.0" + }, + "pscript-0.6.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "452899e6471dc6fe08c34bc85a4cc70e", + "name": "pscript", + "sha256": "195317dd58ff51612147ab7749bccc95123007e54fd204fe021158894ada4a7c", + "size": 106558, + "subdir": "linux-64", + "timestamp": 1535512061070, + "version": "0.6.0" + }, + "pscript-0.6.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "0c26d97fa15c2119b9750b2f8c955d1b", + "name": "pscript", + "sha256": "0b9a5078198662d6cb02e75e85d947f3620ccb5399fa80d3c5628c1bcf839602", + "size": 108209, + "subdir": "linux-64", + "timestamp": 1535512038148, + "version": "0.6.0" + }, + "pscript-0.6.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "f18b7f68c1489e1d793eecdd038020f1", + "name": "pscript", + "sha256": "40b3d7a732d72d52ab0cb391f8100b3a8a15f830f6ccb42ff73e1d0fddb15039", + "size": 109544, + "subdir": "linux-64", + "timestamp": 1538364765716, + "version": "0.6.1" + }, + "pscript-0.6.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "54f544deb552c261ff4931dd80292a16", + "name": "pscript", + "sha256": "d554a67f9b31548bfab7774fdd10c3f8316eb0e554652c6e6b11a8d9a73fc2ac", + "size": 109539, + "subdir": "linux-64", + "timestamp": 1538364801801, + "version": "0.6.1" + }, + "pscript-0.6.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "4a6f20db52c43be7e99bd8b79c5cd39a", + "name": "pscript", + "sha256": "808e14d8f4b7a3723f6ca41e8c316e95917ae00b6b5abd19fab24db8cd2d4ca1", + "size": 107000, + "subdir": "linux-64", + "timestamp": 1538364719363, + "version": "0.6.1" + }, + "pscript-0.6.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "1d998647f73ee54f3749845d6c7a930c", + "name": "pscript", + "sha256": "9924194feb7d1890e88d82e24a59137300e4d88cf0000f18592ddc1e03a52c4b", + "size": 110661, + "subdir": "linux-64", + "timestamp": 1541000758386, + "version": "0.6.2" + }, + "pscript-0.6.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "c11e366a2d754f70f533b4431376ee16", + "name": "pscript", + "sha256": "6da6c63c20f14aec65fd7ef39e5216c0625d06cdee49a095fc65b3c1cfcec706", + "size": 108556, + "subdir": "linux-64", + "timestamp": 1541000787802, + "version": "0.6.2" + }, + "pscript-0.6.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "4df26979959388f587be7dffd315641c", + "name": "pscript", + "sha256": "4a8c2492988ff217f5d042bed8cdb2c503a9b65042074e3500de9e3deec87032", + "size": 108202, + "subdir": "linux-64", + "timestamp": 1541000819705, + "version": "0.6.2" + }, + "pscript-0.6.3-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "bd653353ce0106ba27d8a78c0efe582a", + "name": "pscript", + "sha256": "e20230ea2c81ee54eedb57d1a21ec6295d8febade02fb18a44ac9d2103ac4f70", + "size": 112369, + "subdir": "linux-64", + "timestamp": 1541175412475, + "version": "0.6.3" + }, + "pscript-0.6.3-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "d2942f32252fed8d30d21a9398707c40", + "name": "pscript", + "sha256": "1ede70ed1c0ffbd4a6fc418ee53876a09353467ca36e02a004d02c0b2d4f4eaa", + "size": 108544, + "subdir": "linux-64", + "timestamp": 1541175426339, + "version": "0.6.3" + }, + "pscript-0.6.3-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "c2836287fe81c5d3f15f596aef94c1fc", + "name": "pscript", + "sha256": "7b794ad6cfa1baa59f9b14014905cc80a4ab3716e79ec5606ee1427357017c72", + "size": 110016, + "subdir": "linux-64", + "timestamp": 1541175390859, + "version": "0.6.3" + }, + "pscript-0.7.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "8f92ecbd2f2ffe185711a7469fa71f15", + "name": "pscript", + "sha256": "d7401c302368fb47005b68ee2af3e52f6cd0a5e96c594b05c25e4a8ae895c00d", + "size": 113293, + "subdir": "linux-64", + "timestamp": 1542085136319, + "version": "0.7.0" + }, + "pscript-0.7.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "de2b8ddfb9b0d7a6411a12992fe8f9f9", + "name": "pscript", + "sha256": "9aab578f5e40a490e500d3c5a80551b27f8adbe82f5f7c75eec9273496237ac7", + "size": 109530, + "subdir": "linux-64", + "timestamp": 1542085162367, + "version": "0.7.0" + }, + "pscript-0.7.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "485b395ae4e0d3ed36c99aebd09d7433", + "name": "pscript", + "sha256": "ac4e431b681fa487306141c6e6378a5042d6bf61698d5cdd1c1af34883505271", + "size": 109290, + "subdir": "linux-64", + "timestamp": 1542085117000, + "version": "0.7.0" + }, + "psqlodbc-13.00-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "LGPL-2.0", + "license_family": "GPL", + "md5": "2242f1844d3d14bb520ec2e3203819e2", + "name": "psqlodbc", + "sha256": "e87a8b077e055681a30b463d6555fd53d4b76ca042f0970aad9c649f6faa89b0", + "size": 332164, + "subdir": "linux-64", + "timestamp": 1612297900989, + "version": "13.00" + }, + "psqlodbc-13.01-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "LGPL-2.0", + "license_family": "GPL", + "md5": "634ce2cd3e063aba7861aed86828d230", + "name": "psqlodbc", + "sha256": "2b4123f4292eaed31c3d4cafe00bcabbf59e69797e0a23b9d2902f2f486cdb77", + "size": 332332, + "subdir": "linux-64", + "timestamp": 1620071698526, + "version": "13.01" + }, + "psutil-5.2.2-py27h9b5ba61_0.conda": { + "build": "py27h9b5ba61_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "79c8b31f4690a0145cd489289baa95dc", + "name": "psutil", + "sha256": "db12e3d9b7865d8d940cd67ee3040824eb00047f99fa7f00888fff3951bf6168", + "size": 248182, + "subdir": "linux-64", + "timestamp": 1505733101999, + "version": "5.2.2" + }, + "psutil-5.2.2-py35h75e6a48_0.conda": { + "build": "py35h75e6a48_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0f36f2056d8ee50d4a9c019271e8b12e", + "name": "psutil", + "sha256": "68c970fbb36a552cdca59ac964578437d8b27140abde43fd59383166fc1abb25", + "size": 255181, + "subdir": "linux-64", + "timestamp": 1505733119236, + "version": "5.2.2" + }, + "psutil-5.2.2-py36h74c8701_0.conda": { + "build": "py36h74c8701_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a186a9fd5ac44de09d6a3d152cf31f5c", + "name": "psutil", + "sha256": "d79d01b2456d0e691b1d7e2d9fe68560aab3888efd916a7c865fe9cc333a9951", + "size": 251860, + "subdir": "linux-64", + "timestamp": 1505733136390, + "version": "5.2.2" + }, + "psutil-5.3.1-py27h4c169b4_0.conda": { + "build": "py27h4c169b4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "989ca08b4182fea4bcb36cb27f1bebc1", + "name": "psutil", + "sha256": "9778db80ba220945fbcd7a58cdf6510915aac843ca0311f2e46bac206e227504", + "size": 283675, + "subdir": "linux-64", + "timestamp": 1507234353221, + "version": "5.3.1" + }, + "psutil-5.3.1-py35h6e9e629_0.conda": { + "build": "py35h6e9e629_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b3cf2ce776f77b39ba1a9e006be7a66e", + "name": "psutil", + "sha256": "b58c56bef6a1649e495f8a0ef813dbc227237c330535de43795f68c10c068d93", + "size": 291620, + "subdir": "linux-64", + "timestamp": 1507231337345, + "version": "5.3.1" + }, + "psutil-5.3.1-py36h0e357b8_0.conda": { + "build": "py36h0e357b8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5e8349ddd873eb894d4c2d0d4b180c8c", + "name": "psutil", + "sha256": "c77126daa62c3d74ace00ec1d103792ee61e03d3190d69cc74929fe22012c19b", + "size": 287508, + "subdir": "linux-64", + "timestamp": 1507229148439, + "version": "5.3.1" + }, + "psutil-5.4.0-py27h7da3062_0.conda": { + "build": "py27h7da3062_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cc5ed1b1a2a52c5c8a93bd9cf0931df1", + "name": "psutil", + "sha256": "18b3284b1f71d906e90a4bdd92d1c5c78752a5b108b6aaef211861d35f98c6bd", + "size": 292397, + "subdir": "linux-64", + "timestamp": 1508449438610, + "version": "5.4.0" + }, + "psutil-5.4.0-py35ha5baf80_0.conda": { + "build": "py35ha5baf80_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "053c294197ad60931641b804ff3fd529", + "name": "psutil", + "sha256": "1a376d73d3597b590b49dada40ab46bf4cbb100eb03d3679628d7be64307c8c7", + "size": 296543, + "subdir": "linux-64", + "timestamp": 1508449389898, + "version": "5.4.0" + }, + "psutil-5.4.0-py36h84c53db_0.conda": { + "build": "py36h84c53db_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "810f33d8df5366f627e70453fb55e7a0", + "name": "psutil", + "sha256": "278fbbaae693f8d7f0d1612d6082a9d93bfb8cc9f4b0cea1865830b9d6328c73", + "size": 295127, + "subdir": "linux-64", + "timestamp": 1508449440841, + "version": "5.4.0" + }, + "psutil-5.4.1-py27h61c8946_0.conda": { + "build": "py27h61c8946_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ee61fe74cb45effdecd327740afd81f4", + "name": "psutil", + "sha256": "71e13ebfe449e5316c225a19e6cb105b787d902ce783e9b697606307a4542405", + "size": 291977, + "subdir": "linux-64", + "timestamp": 1511830596621, + "version": "5.4.1" + }, + "psutil-5.4.1-py35h2e39a06_0.conda": { + "build": "py35h2e39a06_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f2ea0abb0c3ed5669d3d9118faa88275", + "name": "psutil", + "sha256": "615b2cfc98f2c2f2243621534631ea3c0f91dce512044b311f225662e9391279", + "size": 300052, + "subdir": "linux-64", + "timestamp": 1511830600352, + "version": "5.4.1" + }, + "psutil-5.4.1-py36hecd8e42_0.conda": { + "build": "py36hecd8e42_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "42292f66166da8d5a63118ba553d7991", + "name": "psutil", + "sha256": "c43964362d86986bf3de8e3161b9cbb979e05deab375aaf4a59657c14148844c", + "size": 296663, + "subdir": "linux-64", + "timestamp": 1511830602974, + "version": "5.4.1" + }, + "psutil-5.4.3-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a7b5251e2f2645a269bea66719b83b8b", + "name": "psutil", + "sha256": "5b83be2b82c2e56f5abea7a3a79d2ed890536011ead4bffdbc58374e1f515f85", + "size": 296764, + "subdir": "linux-64", + "timestamp": 1515707223055, + "version": "5.4.3" + }, + "psutil-5.4.3-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5a9cb7ad7489707cc9330f7317921118", + "name": "psutil", + "sha256": "8836c92a576ec44c6c034be37250e328249f64edfa7c0384dccac67cb51380ac", + "size": 303300, + "subdir": "linux-64", + "timestamp": 1515707274118, + "version": "5.4.3" + }, + "psutil-5.4.3-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "160951ad44f90bab63bcca1e126bb8cd", + "name": "psutil", + "sha256": "b0fe7763538c48b26a517e4ec2ad9e4ff9cbd332ff2b4b7a5ea5f3bf1ee385ea", + "size": 296931, + "subdir": "linux-64", + "timestamp": 1515707077799, + "version": "5.4.3" + }, + "psutil-5.4.5-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "05238917f3e9c69be286ab92b8c51723", + "name": "psutil", + "sha256": "7065a5f09291fd30c3884a9ddb84b90296a786e46269c5eaafaf011ab33eb2b9", + "size": 298051, + "subdir": "linux-64", + "timestamp": 1523906406386, + "version": "5.4.5" + }, + "psutil-5.4.5-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "510593f644a47ed6f4584fb1adcbd8d1", + "name": "psutil", + "sha256": "4cd7141bbd52997923e9197952271c4f461fbe6734bdc31f390173fc71a4bf73", + "size": 306483, + "subdir": "linux-64", + "timestamp": 1523906472086, + "version": "5.4.5" + }, + "psutil-5.4.5-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2d4be1b6d29da1a5e127a90809e8bd6a", + "name": "psutil", + "sha256": "14c205d3ebf90cb13a70dff3ed690f9df15ae0427e0837cca13817b27e38e027", + "size": 302225, + "subdir": "linux-64", + "timestamp": 1523906471758, + "version": "5.4.5" + }, + "psutil-5.4.6-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9ec5054478bdb23b1a34aef6ab59e7fa", + "name": "psutil", + "sha256": "1df8b1628cd0fb2498a9aed9dc7bcd613759c8d51769b1a86aecfcfff28bd89e", + "size": 299797, + "subdir": "linux-64", + "timestamp": 1528894952118, + "version": "5.4.6" + }, + "psutil-5.4.6-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "75354c4344c9acb240bf3c31bf20ea2e", + "name": "psutil", + "sha256": "59c73f4d4479ec41138200366504b380766dcbc4633304e0fe5e320bbb123b47", + "size": 306284, + "subdir": "linux-64", + "timestamp": 1528894870942, + "version": "5.4.6" + }, + "psutil-5.4.6-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d971268b08dc4686614a26acf033d0df", + "name": "psutil", + "sha256": "0e09bd97e83fdc1958c0a9fa73751d7f6903297420aa2093ff819ad9054e5cbc", + "size": 300116, + "subdir": "linux-64", + "timestamp": 1528894789364, + "version": "5.4.6" + }, + "psutil-5.4.6-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2e88ac7385ff18f89c2637fb84d39393", + "name": "psutil", + "sha256": "a99f85a07b1619ac1355cd703abc980a97f9215851d7cd60026caa00abf404b9", + "size": 302250, + "subdir": "linux-64", + "timestamp": 1530736450228, + "version": "5.4.6" + }, + "psutil-5.4.7-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e8033a76c8095d3cff4699de02b1d295", + "name": "psutil", + "sha256": "bc486fee7adb2e6646818c9f0681cbd4ce9338c908b6d14de02a50a23852b5f1", + "size": 299588, + "subdir": "linux-64", + "timestamp": 1534945421867, + "version": "5.4.7" + }, + "psutil-5.4.7-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f24dcddd569bbfa53a2f886fbe5cae72", + "name": "psutil", + "sha256": "1e46b3646a14d37c7c1a64b9e86b5cce884977a5e7f3a354c7f32b7192ac040f", + "size": 305666, + "subdir": "linux-64", + "timestamp": 1534945423546, + "version": "5.4.7" + }, + "psutil-5.4.7-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a3c6be7a185e6af4a2929268b9409ec4", + "name": "psutil", + "sha256": "be1d386113a2029d187f7dfc902c763d32fbc7ab47a2b7bb451c923f9f42779d", + "size": 303967, + "subdir": "linux-64", + "timestamp": 1534944967787, + "version": "5.4.7" + }, + "psutil-5.4.7-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "84b59bb9c0d3c43fa079271b4af66739", + "name": "psutil", + "sha256": "66a005868ee0b2c7824b5f0a7f1acf8a23f0a5bb29d4545aad3d54d19a970060", + "size": 301496, + "subdir": "linux-64", + "timestamp": 1534945424444, + "version": "5.4.7" + }, + "psutil-5.4.8-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bacb1b58555f5c857a620c25d9f0189f", + "name": "psutil", + "sha256": "b8d4bce0ed82f2925620855c5e611dfbcf940cacd1951d48344fd4441bc70e10", + "size": 304138, + "subdir": "linux-64", + "timestamp": 1541001167115, + "version": "5.4.8" + }, + "psutil-5.4.8-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "71bce94560632a77e6f5f53690ca4f4a", + "name": "psutil", + "sha256": "4885c17d7fbd9c71420e8ccf04e6f800a5cc14f6978720b5500990bc4bf75598", + "size": 308789, + "subdir": "linux-64", + "timestamp": 1541001187068, + "version": "5.4.8" + }, + "psutil-5.4.8-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "52e591adeede43da070747fe654338f8", + "name": "psutil", + "sha256": "a783ed3f86ba95d26d6d4e27ae41186c85a6402516a44d4bda4f70c492269045", + "size": 305665, + "subdir": "linux-64", + "timestamp": 1541001179834, + "version": "5.4.8" + }, + "psutil-5.5.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "062c9ad71d73c57951f39a1e1132ca34", + "name": "psutil", + "sha256": "aad12bf6bd33f311bc49020823e565c92f0ed60f1b76874014baf89bcf1920ee", + "size": 305237, + "subdir": "linux-64", + "timestamp": 1549323659789, + "version": "5.5.0" + }, + "psutil-5.5.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b5d07e91f9c583efacde70d5db611f0e", + "name": "psutil", + "sha256": "57c3ca46433543232bd77b21e37610187ccd73a8c0460e27c195cbdcf7c2058e", + "size": 310519, + "subdir": "linux-64", + "timestamp": 1549323725888, + "version": "5.5.0" + }, + "psutil-5.5.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "395b4598e68c235c55babd1a2918d0ac", + "name": "psutil", + "sha256": "ab2f3764497cfb94c14702fe51a9b96c9a81859eed5ac3cbbe6405e2b0c85606", + "size": 307944, + "subdir": "linux-64", + "timestamp": 1549323631911, + "version": "5.5.0" + }, + "psutil-5.6.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2f718bc307630b7d51f749d35026c3e3", + "name": "psutil", + "sha256": "b0376143c5e08529974209875902568bb517f6b565b195f8c8f74fa98a9ef2aa", + "size": 312389, + "subdir": "linux-64", + "timestamp": 1552339276670, + "version": "5.6.0" + }, + "psutil-5.6.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2c5480442815df20f6c94e0d5440818a", + "name": "psutil", + "sha256": "1b23e7fd69e1b347370411ce6a5ca873c84e91ec989219a6d3e4584dadadfe97", + "size": 316956, + "subdir": "linux-64", + "timestamp": 1552339301712, + "version": "5.6.0" + }, + "psutil-5.6.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "375a2548ac41b3adbac1b256143bfef1", + "name": "psutil", + "sha256": "03f2835db7143b5e6781803c7608a4fe8c608b4c9439de9a4ce39762ac02e3fa", + "size": 314629, + "subdir": "linux-64", + "timestamp": 1552339267076, + "version": "5.6.0" + }, + "psutil-5.6.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ed8a1db9911561d1935fb7f94c6fe2b8", + "name": "psutil", + "sha256": "79b7ad8e3e50a7a20fdc23e506c8cc2cf9478727a9fc1507af254b2a494fee0a", + "size": 312673, + "subdir": "linux-64", + "timestamp": 1552341714832, + "version": "5.6.1" + }, + "psutil-5.6.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1d9446edc11e47667e87919e92f39e46", + "name": "psutil", + "sha256": "8ceec8032fdc4b5422466f51539bbff91538efd342eaf55b075249a792b975f6", + "size": 317018, + "subdir": "linux-64", + "timestamp": 1552341779424, + "version": "5.6.1" + }, + "psutil-5.6.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "db340cfb0d1a2e62f4e6c45fe728aa03", + "name": "psutil", + "sha256": "46910d21c24c91ec4d40d904f02d0c61ec8baa7f76cf7c13ee24fd8f25912079", + "size": 314370, + "subdir": "linux-64", + "timestamp": 1552341739302, + "version": "5.6.1" + }, + "psutil-5.6.2-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "03ffee178a0cc6d3eef2ee1343ad07ae", + "name": "psutil", + "sha256": "122734acfa5681bd971169f98c6dc4345423940d321beb294b8c1153f5b00ded", + "size": 317999, + "subdir": "linux-64", + "timestamp": 1556550657297, + "version": "5.6.2" + }, + "psutil-5.6.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "409609b85e4fd54f3b6f20dfade708bb", + "name": "psutil", + "sha256": "d669e9e0355fbdeb0c9ef504b257bf9431bca5d113f3552c7b263e916b0bd292", + "size": 322636, + "subdir": "linux-64", + "timestamp": 1556550710527, + "version": "5.6.2" + }, + "psutil-5.6.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "04cbae8060d8ebeebd26ad2b6ba68d5a", + "name": "psutil", + "sha256": "40b64380155f2a4a1b7ba27cd763fd55259b498a460b8aa1218451dd72b51300", + "size": 319872, + "subdir": "linux-64", + "timestamp": 1556550660366, + "version": "5.6.2" + }, + "psutil-5.6.3-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2590d9520dd3a7c9b440293605eb7ad7", + "name": "psutil", + "sha256": "1ba22e5718cf3f57ae6714d697f999aba052ae11945972ea932bf564d3b47631", + "size": 318274, + "subdir": "linux-64", + "timestamp": 1562079562432, + "version": "5.6.3" + }, + "psutil-5.6.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d60ba105fee282c63a5a268f97585855", + "name": "psutil", + "sha256": "9a7677f95ab9be9366f8e66cead72ae1ea9fad1f7328cab3643d1222fe1a71f2", + "size": 320453, + "subdir": "linux-64", + "timestamp": 1562079573258, + "version": "5.6.3" + }, + "psutil-5.6.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "30b5949182fd7c4b277863776ccb2f50", + "name": "psutil", + "sha256": "34a3a46fdbb0d3d52d53fc5069dea1ec57adef0876888ef5e2e6158652c42133", + "size": 320403, + "subdir": "linux-64", + "timestamp": 1562079552762, + "version": "5.6.3" + }, + "psutil-5.6.3-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3423a65d80c29a26e81a9d7aafd887ec", + "name": "psutil", + "sha256": "72a66324a50513181ed274de43399c041430502d6ba59694dcde7f9640047c3f", + "size": 326836, + "subdir": "linux-64", + "timestamp": 1573040778759, + "version": "5.6.3" + }, + "psutil-5.6.5-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "743eed09770cba6b98cc766c01d2d407", + "name": "psutil", + "sha256": "ff102707aad879279af3ec9521aeab977db939065a4b7eeb9e1b381f86e0c28b", + "size": 323384, + "subdir": "linux-64", + "timestamp": 1573251818978, + "version": "5.6.5" + }, + "psutil-5.6.5-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "942cd4c0ccfb6e09c8f6bf4967f96131", + "name": "psutil", + "sha256": "8a5979ce9fac199d6a8f2e40844a308005502f5b25777e3fd43a6334c41ad920", + "size": 325347, + "subdir": "linux-64", + "timestamp": 1573251891526, + "version": "5.6.5" + }, + "psutil-5.6.5-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aa09c487310aff83fbad9c9a1d4b0554", + "name": "psutil", + "sha256": "851000433813e7966c6c444da255f2250267e7a5f34110cf7ebaf57faef28771", + "size": 325139, + "subdir": "linux-64", + "timestamp": 1573251811026, + "version": "5.6.5" + }, + "psutil-5.6.5-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "417e0d59b1bf014fb69e82671a0ded82", + "name": "psutil", + "sha256": "fc7f3f62243e7d965fd3cf9eb91dda2aae06c45b3ce8ab1cba133b5ce87eab7e", + "size": 333978, + "subdir": "linux-64", + "timestamp": 1573251927219, + "version": "5.6.5" + }, + "psutil-5.6.7-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e40d6a5c73b95fe8d52c8bc6243a0c6f", + "name": "psutil", + "sha256": "38cf315e7c4db7d0b314d284bef8599dcc7307e2a50dea8899f6b2aee64ca93e", + "size": 323475, + "subdir": "linux-64", + "timestamp": 1575391191482, + "version": "5.6.7" + }, + "psutil-5.6.7-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b3dc836e4215cefb652ad2d761ad15c3", + "name": "psutil", + "sha256": "784381edfb82d1a82e0e5dfef0c0eda486e04346f356ae9beac70b9dc42b633f", + "size": 325584, + "subdir": "linux-64", + "timestamp": 1575391215774, + "version": "5.6.7" + }, + "psutil-5.6.7-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dcb7299969c5f781c0b145ff9f42b985", + "name": "psutil", + "sha256": "2be945549d4611966eee2ce9d3e92f63108c3cefad8238f998253bbcb59ce875", + "size": 325722, + "subdir": "linux-64", + "timestamp": 1575391169241, + "version": "5.6.7" + }, + "psutil-5.6.7-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e967df2bb5fa8608e3dab48d262fb598", + "name": "psutil", + "sha256": "3014695368fd3941d6ee9055980800c28e9f4c9b9f274527d932472ac3854044", + "size": 334278, + "subdir": "linux-64", + "timestamp": 1575391227103, + "version": "5.6.7" + }, + "psutil-5.7.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "be498dcb880e2702e3200a3aa76eff9f", + "name": "psutil", + "sha256": "061fd7db6000975f7c181d3d8787cefe1eaff93b280c45c111f633d1adc5800c", + "size": 323010, + "subdir": "linux-64", + "timestamp": 1584038020947, + "version": "5.7.0" + }, + "psutil-5.7.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1f15a3d11b1fa5a7ceddc94fdd3e3844", + "name": "psutil", + "sha256": "f177c60ea36dd3c872a2f6265cfed497d41047c570c5f75974dfcd5ea3084fba", + "size": 326848, + "subdir": "linux-64", + "timestamp": 1584038013108, + "version": "5.7.0" + }, + "psutil-5.7.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a2b9680dc770cd0b1652e8d3ee9aa581", + "name": "psutil", + "sha256": "8e23e985ae65129ecabad059a45c36c02b594033a240f960224cef979516ea6d", + "size": 328511, + "subdir": "linux-64", + "timestamp": 1584038046109, + "version": "5.7.0" + }, + "psutil-5.7.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ccc68640a0cdd0a2dae4854afac823b0", + "name": "psutil", + "sha256": "a2d99aed872f7a6ff3d0c7f1876d71aabfc91b1e9e15174a9b1f948e4745cd5e", + "size": 335327, + "subdir": "linux-64", + "timestamp": 1598370307874, + "version": "5.7.2" + }, + "psutil-5.7.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9579fdbe84bb17b669f03e014a9e583b", + "name": "psutil", + "sha256": "9741036d5f5e6a4fa64b313082f5fd1d5c7fedf83d6a2028e9446d06b95a30ad", + "size": 339306, + "subdir": "linux-64", + "timestamp": 1598370291656, + "version": "5.7.2" + }, + "psutil-5.7.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d61de71199c48f655d77dce04b30a59", + "name": "psutil", + "sha256": "12a50aa3c9fa732287e15269b5e8c4fe5bce8ebf82e86603b14f762e810d6bc7", + "size": 337704, + "subdir": "linux-64", + "timestamp": 1598370307763, + "version": "5.7.2" + }, + "psutil-5.7.2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f7fc5f31db0079082de1d0314d8cfdb1", + "name": "psutil", + "sha256": "2c60d7c4215545d1876f0374313686b41efdd24173618e68c0938b73ab96d871", + "size": 342117, + "subdir": "linux-64", + "timestamp": 1607027338983, + "version": "5.7.2" + }, + "psutil-5.8.0-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1794286a3043b9bb34d278129513f749", + "name": "psutil", + "sha256": "396794a2d45ac28c5924ef1c51e9a7cfed23f0f7f26d1870b99af26075c58029", + "size": 379744, + "subdir": "linux-64", + "timestamp": 1640792653691, + "version": "5.8.0" + }, + "psutil-5.8.0-py311h5eee18b_1.conda": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "039e044a3a8834990d774803c86e2b21", + "name": "psutil", + "sha256": "5fc42a7142269c07c36ddcad6ddbc77ce8a8572dc09cb1efb37c9a632539b990", + "size": 475467, + "subdir": "linux-64", + "timestamp": 1676825001707, + "version": "5.8.0" + }, + "psutil-5.8.0-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "217d0eea49d2e6a48928267f0e273e61", + "name": "psutil", + "sha256": "ea4f5813b6b7ed71b26c10551388714589ac9ed8d5e20e329cbd4c8ccdc3a483", + "size": 336455, + "subdir": "linux-64", + "timestamp": 1612297669545, + "version": "5.8.0" + }, + "psutil-5.8.0-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "81d7a9224b14d8ae07be8042d2118fbc", + "name": "psutil", + "sha256": "445d5f55341bfa185f772b83c1dcfb059cd61dbd6af8b12c9f589e5f68e5720b", + "size": 337019, + "subdir": "linux-64", + "timestamp": 1612298060797, + "version": "5.8.0" + }, + "psutil-5.8.0-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "62e8566b28df8e8d2eaa80d432737440", + "name": "psutil", + "sha256": "6228f1699b0b30445ae6f66cf8f1eddaa9f4ea4abdedf6d89a707addf7cdda31", + "size": 335311, + "subdir": "linux-64", + "timestamp": 1612298067868, + "version": "5.8.0" + }, + "psutil-5.8.0-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "66fd46675b276d2f7e4d9e775530c897", + "name": "psutil", + "sha256": "ca98000e31ebdf9e971c4943a39a195e841f0ffcdacefee9e60d41349d8cf075", + "size": 339738, + "subdir": "linux-64", + "timestamp": 1612298042840, + "version": "5.8.0" + }, + "psutil-5.9.0-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b48c5c1b4198a08f61426140a29254fc", + "name": "psutil", + "sha256": "7d1dfdf5a62eda9ae0e32ce0de3cbc43b94020ef0ea99cc55d7caa0568a1dc01", + "size": 376813, + "subdir": "linux-64", + "timestamp": 1656431395375, + "version": "5.9.0" + }, + "psutil-5.9.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb0e15716b6b92092aa0e9b89629fa09", + "name": "psutil", + "sha256": "a23c726ca36fdb43a70a38072a575e42c8f9011557e80f2d8f492eb9076bbe02", + "size": 474445, + "subdir": "linux-64", + "timestamp": 1679337420563, + "version": "5.9.0" + }, + "psutil-5.9.0-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "59476cbfff7e687867d2936ab987d856", + "name": "psutil", + "sha256": "4ecfdc8cbc48c6b9ac06700785481ef3fb2f6059a7c4aab833bae9020737c974", + "size": 335976, + "subdir": "linux-64", + "timestamp": 1656431320563, + "version": "5.9.0" + }, + "psutil-5.9.0-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9ec1a6d1ec901e832d4062992f736bdd", + "name": "psutil", + "sha256": "5b8199670b095b5ba409cd964355f95a23c752739afa0bd9d9ed9bb7d7c20e2f", + "size": 338082, + "subdir": "linux-64", + "timestamp": 1656431426074, + "version": "5.9.0" + }, + "psutil-5.9.0-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c1eb10450b919f4984e2975d7bfde814", + "name": "psutil", + "sha256": "0e80501d8741f1d1ef33b1b3f14be69bf1bd3e0b63e6a5e7e96a021b390d9262", + "size": 338350, + "subdir": "linux-64", + "timestamp": 1656431352923, + "version": "5.9.0" + }, + "psycopg2-2.7.3.1-py27h1368252_0.conda": { + "build": "py27h1368252_0", + "build_number": 0, + "depends": [ + "libpq", + "openssl 1.0.*", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "20208748272304f5ee96bf9bb5d66a11", + "name": "psycopg2", + "sha256": "6836518084b138aa73015cb157cb105568b3ef0ccde918c023735c2cec930d2c", + "size": 282742, + "subdir": "linux-64", + "timestamp": 1507670558694, + "version": "2.7.3.1" + }, + "psycopg2-2.7.3.1-py35h11414ae_0.conda": { + "build": "py35h11414ae_0", + "build_number": 0, + "depends": [ + "libpq", + "openssl 1.0.*", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "8033233c8d24d94f198abbd6eb158add", + "name": "psycopg2", + "sha256": "6a27b441663b3becc3af92a6f06df0db6ea940fd8b21dde7be07574d5b1c6f53", + "size": 292431, + "subdir": "linux-64", + "timestamp": 1507670629753, + "version": "2.7.3.1" + }, + "psycopg2-2.7.3.1-py36h369a60c_0.conda": { + "build": "py36h369a60c_0", + "build_number": 0, + "depends": [ + "libpq", + "openssl 1.0.*", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "2914ed334cb202ad8bba1c73dec51d78", + "name": "psycopg2", + "sha256": "fc2a4eeca9528acf0bedeeb096abab81ede22bf7895a6380ce2a703ecb3dd7a8", + "size": 289196, + "subdir": "linux-64", + "timestamp": 1507670628450, + "version": "2.7.3.1" + }, + "psycopg2-2.7.3.2-py27h6397e30_0.conda": { + "build": "py27h6397e30_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq", + "libpq >=9.6.6", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "26c97c5ce6221fb6b350da5f5d6cfdfa", + "name": "psycopg2", + "sha256": "b0e21c0e9c2b3cfc92fcdef8a05b20ea8f369e32477e52bd93b02fd7374eeeb6", + "size": 282922, + "subdir": "linux-64", + "timestamp": 1512073747201, + "version": "2.7.3.2" + }, + "psycopg2-2.7.3.2-py35hcc7b94d_0.conda": { + "build": "py35hcc7b94d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq", + "libpq >=9.6.6", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "13d9840094ad830c832c93017de6c959", + "name": "psycopg2", + "sha256": "51ce15682a8fb80ecba8b28bcbded84f67930720e4d04e76d800570cadc2a4e8", + "size": 289787, + "subdir": "linux-64", + "timestamp": 1512073779084, + "version": "2.7.3.2" + }, + "psycopg2-2.7.3.2-py36h2b1659c_0.conda": { + "build": "py36h2b1659c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq", + "libpq >=9.6.6", + "openssl 1.0.*", + "openssl >=1.0.2m,<1.0.3a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "d7094dae22b180015e69dc807684c7e5", + "name": "psycopg2", + "sha256": "1141ae4875d3cb1c3fe468ed71cd11e03fb760c2d94258e3b141c4d5a30bfe2d", + "size": 287550, + "subdir": "linux-64", + "timestamp": 1512073781810, + "version": "2.7.3.2" + }, + "psycopg2-2.7.4-py27hb7f436b_0.conda": { + "build": "py27hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq >=9.6.6", + "openssl >=1.0.2n,<1.0.3a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "d97fc08a29f5d030af8b98835412e1ab", + "name": "psycopg2", + "sha256": "d9aad69e6c086d8cce02a796fc0cd38e302348999ceb579314f1da9c6ec82626", + "size": 285892, + "subdir": "linux-64", + "timestamp": 1519749132477, + "version": "2.7.4" + }, + "psycopg2-2.7.4-py35hb7f436b_0.conda": { + "build": "py35hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq >=9.6.6", + "openssl >=1.0.2n,<1.0.3a", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "31f353dec3293226ef2bd143e7bb45d7", + "name": "psycopg2", + "sha256": "a3384bd145cf4979ecf57ddbef68f04fc609d932ad7843d2371528e42e329213", + "size": 290486, + "subdir": "linux-64", + "timestamp": 1519749158437, + "version": "2.7.4" + }, + "psycopg2-2.7.4-py36hb7f436b_0.conda": { + "build": "py36hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq >=9.6.6", + "openssl >=1.0.2n,<1.0.3a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "337063b4f38efc3d2cb2625eb515acfe", + "name": "psycopg2", + "sha256": "cf3a189c60bebbc1760fc757f163e22e1f62203687cb840a86f18314d18ed7fa", + "size": 288301, + "subdir": "linux-64", + "timestamp": 1519749101681, + "version": "2.7.4" + }, + "psycopg2-2.7.5-py27hb7f436b_0.conda": { + "build": "py27hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq >=10.3,<11.0a0", + "openssl >=1.0.2o,<1.0.3a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "02f5acad992e2b1c4bfd97dbe891f958", + "name": "psycopg2", + "sha256": "8a6884a27f059cc66de0f399260846cd5e5bbf0a617021cf95f843a84f944155", + "size": 288435, + "subdir": "linux-64", + "timestamp": 1529567676370, + "version": "2.7.5" + }, + "psycopg2-2.7.5-py35hb7f436b_0.conda": { + "build": "py35hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq >=10.3,<11.0a0", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "f5c51bedb3ee4d0dbe38c8408ee2fc5b", + "name": "psycopg2", + "sha256": "048e3f51ba68ada5f8ddf5c21642d73e394c40a4fb1e25f0c1c70db5a027eabf", + "size": 295568, + "subdir": "linux-64", + "timestamp": 1529567735239, + "version": "2.7.5" + }, + "psycopg2-2.7.5-py36hb7f436b_0.conda": { + "build": "py36hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq >=10.3,<11.0a0", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "fdda79e5bca8d3e8bd744da5d8a727d6", + "name": "psycopg2", + "sha256": "eeafca908a03109aaeabc99259455086dcf0facd0af2af6b0942518742c6a767", + "size": 293635, + "subdir": "linux-64", + "timestamp": 1529567670536, + "version": "2.7.5" + }, + "psycopg2-2.7.5-py37hb7f436b_0.conda": { + "build": "py37hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libpq >=10.3,<11.0a0", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "29952622728711d316b5864cb0db7949", + "name": "psycopg2", + "sha256": "51986c183caddc67f4dbf88e2b203dc8b15701d90af00ccbfefbdee4891fb1e0", + "size": 291196, + "subdir": "linux-64", + "timestamp": 1530873224976, + "version": "2.7.5" + }, + "psycopg2-2.7.6.1-py27h1ba5d50_0.conda": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.1,<12.0a0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "069693a16074f899d0aa5a59829d749b", + "name": "psycopg2", + "sha256": "08238c8755759b213c2ff1460c7ce5b7110d9221aca5644e5bcd8b80e0ab9bf8", + "size": 293359, + "subdir": "linux-64", + "timestamp": 1545240146256, + "version": "2.7.6.1" + }, + "psycopg2-2.7.6.1-py36h1ba5d50_0.conda": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.1,<12.0a0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "86493586db96a23530dd79c67edc2d55", + "name": "psycopg2", + "sha256": "a1eb5c07d3267bd50f73413575387ba2962317ca4e18b7e9a2039c713c05afaa", + "size": 297433, + "subdir": "linux-64", + "timestamp": 1545240170243, + "version": "2.7.6.1" + }, + "psycopg2-2.7.6.1-py37h1ba5d50_0.conda": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.1,<12.0a0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "c144eb87e97adc7b80905bf13adc5298", + "name": "psycopg2", + "sha256": "0e2ab8e46bca9ffc7a076dbd45d47bf4cd850e7dcd9006b5c61fcdbbc770db8c", + "size": 293699, + "subdir": "linux-64", + "timestamp": 1545240186919, + "version": "2.7.6.1" + }, + "psycopg2-2.8.3-py27h1ba5d50_0.conda": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.2,<12.0a0", + "openssl >=1.1.1d,<1.1.2a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "80fa578a9388b5f15c973b363264b3ce", + "name": "psycopg2", + "sha256": "257b5a4a6d9f02dc7de663616c60edfc4c9dd228a6b000ce24bdef72e57e8872", + "size": 164796, + "subdir": "linux-64", + "timestamp": 1569267908465, + "version": "2.8.3" + }, + "psycopg2-2.8.3-py36h1ba5d50_0.conda": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.2,<12.0a0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "2ed08623b179b58fc703614101f495f1", + "name": "psycopg2", + "sha256": "7796ce1c3389b978d83c9606e03898410868d04376e500f9670703cb1120e262", + "size": 165320, + "subdir": "linux-64", + "timestamp": 1569267908241, + "version": "2.8.3" + }, + "psycopg2-2.8.3-py37h1ba5d50_0.conda": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.2,<12.0a0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "28d000120cc35481b9f795ce5ea605db", + "name": "psycopg2", + "sha256": "8189f3d86862f8e8dcc6126df707de91288ce780c4e89a3172ceb5fd67f6300b", + "size": 164772, + "subdir": "linux-64", + "timestamp": 1569267901452, + "version": "2.8.3" + }, + "psycopg2-2.8.4-py27h1ba5d50_0.conda": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.2,<12.0a0", + "openssl >=1.1.1d,<1.1.2a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "fe90670ab3f6ee730a0cd356faf03c22", + "name": "psycopg2", + "sha256": "723ff99e41982f4834abb09c9c7c45478a67c7747999a23f98a3316d4e8ae6d1", + "size": 165184, + "subdir": "linux-64", + "timestamp": 1573224741345, + "version": "2.8.4" + }, + "psycopg2-2.8.4-py36h1ba5d50_0.conda": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.2,<12.0a0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "069cbaa1b75f7800178b3db85503431f", + "name": "psycopg2", + "sha256": "ab26863901eb82b35a3cf9b3810ab6e66e63616c49bd43652310a931f3371531", + "size": 165554, + "subdir": "linux-64", + "timestamp": 1573224774680, + "version": "2.8.4" + }, + "psycopg2-2.8.4-py37h1ba5d50_0.conda": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.2,<12.0a0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "223e485e9ab4ad168fc840541289bd28", + "name": "psycopg2", + "sha256": "deea688e9a3a1983d31dba2b155f014cb17184a39b246dd6189b1d1a2c97dce5", + "size": 165536, + "subdir": "linux-64", + "timestamp": 1573224727000, + "version": "2.8.4" + }, + "psycopg2-2.8.4-py38h1ba5d50_0.conda": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=11.2,<12.0a0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "5e6c2b34db57b3762862139024fad57f", + "name": "psycopg2", + "sha256": "a4ad7adcbd8a4a7e512fc075d620e7a279b84af5bfbacc2bf015c40e2508cbdc", + "size": 174996, + "subdir": "linux-64", + "timestamp": 1573224807574, + "version": "2.8.4" + }, + "psycopg2-2.8.5-py36h1ba5d50_0.conda": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "21371bd46fae46b8b5c1abcf029f1460", + "name": "psycopg2", + "sha256": "ae4c1b47d3be590d7c48f68c1efe299c77a72d256d28be0e268169006ae7a906", + "size": 165603, + "subdir": "linux-64", + "timestamp": 1594305176865, + "version": "2.8.5" + }, + "psycopg2-2.8.5-py36h3c74f83_1.conda": { + "build": "py36h3c74f83_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "310c2e7345ecd016215b9d0a0c32893f", + "name": "psycopg2", + "sha256": "45cc849755582c391d2c05c36944a534002c32773f811bf8dd6d129a544175c6", + "size": 167137, + "subdir": "linux-64", + "timestamp": 1608147629467, + "version": "2.8.5" + }, + "psycopg2-2.8.5-py37h1ba5d50_0.conda": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "bcfd1e5e4dc07f13d9b78d72685d4f06", + "name": "psycopg2", + "sha256": "b0509de21751cedcb67108bc5cd8796f023c92cbb943733928e7d3459c06c1c0", + "size": 169566, + "subdir": "linux-64", + "timestamp": 1594305174294, + "version": "2.8.5" + }, + "psycopg2-2.8.5-py37h3c74f83_1.conda": { + "build": "py37h3c74f83_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "ac150e77b8a9e7dbab4a19b9d339bf21", + "name": "psycopg2", + "sha256": "ef1d8770b8a94d996ba304f290f79cb5452ac92a097a6957be1fb20b4f359ea1", + "size": 164937, + "subdir": "linux-64", + "timestamp": 1608147623088, + "version": "2.8.5" + }, + "psycopg2-2.8.5-py38h1ba5d50_0.conda": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "openssl >=1.1.1g,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "40d7d3b758b52ccbea6d291881f7ce3e", + "name": "psycopg2", + "sha256": "6fe4a0a86b671c417643097795c73b1c3a48b7be8aa87535b9772b56e1d857d5", + "size": 168683, + "subdir": "linux-64", + "timestamp": 1594305156932, + "version": "2.8.5" + }, + "psycopg2-2.8.5-py38h3c74f83_1.conda": { + "build": "py38h3c74f83_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "7e33a3290eea5e9abc5eb1e6caba189e", + "name": "psycopg2", + "sha256": "b46917c4d9f4f41323c78fbe71087849c7f1ebcc6ca4b32dc672df8329734729", + "size": 169023, + "subdir": "linux-64", + "timestamp": 1608147642932, + "version": "2.8.5" + }, + "psycopg2-2.8.5-py39h3c74f83_1.conda": { + "build": "py39h3c74f83_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "9dc27de89730ed2596c2e0af64714997", + "name": "psycopg2", + "sha256": "21c295454e7da144da8fc11994d4055fa8f1ac00277719dd3683c3fc71ec8241", + "size": 169276, + "subdir": "linux-64", + "timestamp": 1608147659540, + "version": "2.8.5" + }, + "psycopg2-2.8.6-py310h37d81fd_2.conda": { + "build": "py310h37d81fd_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libpq >=12.9,<13.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0-or-later AND Other", + "license_family": "LGPL", + "md5": "28d60918744702f2dfdad3eee7a6bde7", + "name": "psycopg2", + "sha256": "21664d1b994b6a34cffc574a564628201a6b4884169ebd327ab870ee4e351e98", + "size": 403314, + "subdir": "linux-64", + "timestamp": 1662147837297, + "version": "2.8.6" + }, + "psycopg2-2.8.6-py310h8f2d780_1.conda": { + "build": "py310h8f2d780_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libpq >=12.9,<13.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "c3b9fc2d9a452382bbf7c9f41a3aab54", + "name": "psycopg2", + "sha256": "8c23f5804077f77b584dbdd514a79dffaf5c86df0e75641f08d3fe50b5b68bb6", + "size": 365312, + "subdir": "linux-64", + "timestamp": 1640792685730, + "version": "2.8.6" + }, + "psycopg2-2.8.6-py36h3c74f83_1.conda": { + "build": "py36h3c74f83_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "774431c35b47d5caa1e2f85f3c440d5d", + "name": "psycopg2", + "sha256": "4f10b4b566d2b7dc9912d88cbe736ecdf3740b51c0960f1215b3a1ab52888414", + "size": 161154, + "subdir": "linux-64", + "timestamp": 1612298666200, + "version": "2.8.6" + }, + "psycopg2-2.8.6-py37h37d81fd_2.conda": { + "build": "py37h37d81fd_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libpq >=12.9,<13.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0-or-later AND Other", + "license_family": "LGPL", + "md5": "9284ba77bd79982e98e60af2cf4388ed", + "name": "psycopg2", + "sha256": "0ff0aed2a68420a2b73b73122a8dda8f7468b4331cb4d733e3b560a8b2e59b87", + "size": 163879, + "subdir": "linux-64", + "timestamp": 1662147710561, + "version": "2.8.6" + }, + "psycopg2-2.8.6-py37h3c74f83_1.conda": { + "build": "py37h3c74f83_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "2aaad8584e5bd8069bf3eec37973c059", + "name": "psycopg2", + "sha256": "ae0eafede4c2b39b89a2d69300382cc8e703b9164598991b8461e567a7850c34", + "size": 162320, + "subdir": "linux-64", + "timestamp": 1612298630248, + "version": "2.8.6" + }, + "psycopg2-2.8.6-py38h37d81fd_2.conda": { + "build": "py38h37d81fd_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libpq >=12.9,<13.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0-or-later AND Other", + "license_family": "LGPL", + "md5": "f4dc21875a629e6a1be5746839462fff", + "name": "psycopg2", + "sha256": "91068f546d746a0a4ba395b9c5b86d2497d902446b29a240e4308166096dd31a", + "size": 165953, + "subdir": "linux-64", + "timestamp": 1662147783986, + "version": "2.8.6" + }, + "psycopg2-2.8.6-py38h3c74f83_1.conda": { + "build": "py38h3c74f83_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "157830d778efbb159f5c755cf798e88c", + "name": "psycopg2", + "sha256": "cffbb2ac075f8f6152cdafc4abc12cfc1566fa4c35e28219a1937e73f66f05bf", + "size": 163784, + "subdir": "linux-64", + "timestamp": 1612298201840, + "version": "2.8.6" + }, + "psycopg2-2.8.6-py39h37d81fd_2.conda": { + "build": "py39h37d81fd_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libpq >=12.9,<13.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0-or-later AND Other", + "license_family": "LGPL", + "md5": "809d9b0e73ac27811300965f3acdb848", + "name": "psycopg2", + "sha256": "13f8484d6f1c0a121a02982e5500a7f022070d1f36e624bdd004b15027a3c9c0", + "size": 165770, + "subdir": "linux-64", + "timestamp": 1662147748321, + "version": "2.8.6" + }, + "psycopg2-2.8.6-py39h3c74f83_1.conda": { + "build": "py39h3c74f83_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libpq >=12.2,<13.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL, BSD-like, ZPL", + "license_family": "LGPL", + "md5": "736b31ff54e8744aeaf6acfbb10cae41", + "name": "psycopg2", + "sha256": "0b5fc6dea436fb4384bf1469bfb063eaa8e671be9ade2fba8b3d8a2c68e02804", + "size": 167622, + "subdir": "linux-64", + "timestamp": 1612298650628, + "version": "2.8.6" + }, + "psycopg2-2.9.3-py310h37d81fd_0.conda": { + "build": "py310h37d81fd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libpq >=12.9,<13.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "fb746d039e2596a4b759a4013a1b0519", + "name": "psycopg2", + "sha256": "a850f57d9e1dc372a7a2dda86204fe49e5d09540650a9f47919a4d4e202d65e8", + "size": 175717, + "subdir": "linux-64", + "timestamp": 1666817566994, + "version": "2.9.3" + }, + "psycopg2-2.9.3-py311h37d81fd_0.conda": { + "build": "py311h37d81fd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libpq >=12.9,<13.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "277affa9cd6b31258f33781e8f3d262d", + "name": "psycopg2", + "sha256": "d7439c48472795bedd1b0b173f5c0dda70439d017097929c3ebb7b347cad7a5b", + "size": 186746, + "subdir": "linux-64", + "timestamp": 1676845237768, + "version": "2.9.3" + }, + "psycopg2-2.9.3-py37h37d81fd_0.conda": { + "build": "py37h37d81fd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libpq >=12.9,<13.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "5ad25a35222c38a29227f9cba03bee5d", + "name": "psycopg2", + "sha256": "94bf4f74c0d03035883036b0a35f5d94b8e118797a251d0f5d572e78c076b3c3", + "size": 173105, + "subdir": "linux-64", + "timestamp": 1666817496835, + "version": "2.9.3" + }, + "psycopg2-2.9.3-py38h37d81fd_0.conda": { + "build": "py38h37d81fd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libpq >=12.9,<13.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "4cc64937d5b04b9a2e9263fd326da765", + "name": "psycopg2", + "sha256": "d267bf2c81b1dcdce3de75a0fcca834e1c9b5f300e302a51c969d7dc5dadb01a", + "size": 175107, + "subdir": "linux-64", + "timestamp": 1666817601837, + "version": "2.9.3" + }, + "psycopg2-2.9.3-py39h37d81fd_0.conda": { + "build": "py39h37d81fd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libpq >=12.9,<13.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "659fb9c4c26ca4a597a5dc35c9477533", + "name": "psycopg2", + "sha256": "4306a2b8f7d012c996982c95538195f2a194528db53ba11908260c47444da2d0", + "size": 174978, + "subdir": "linux-64", + "timestamp": 1666817531722, + "version": "2.9.3" + }, + "pthread-stubs-0.3-h0ce48e5_1.conda": { + "build": "h0ce48e5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "973a642312d2a28927aaf5b477c67250", + "name": "pthread-stubs", + "sha256": "119c5ad43fb92b2f14a25c53276072ee77ff6b40c72e6617b523b9de0eb0822a", + "size": 5360, + "subdir": "linux-64", + "timestamp": 1505733967605, + "version": "0.3" + }, + "ptyprocess-0.5.2-py27h4ccb14c_0.conda": { + "build": "py27h4ccb14c_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "f7d2c74130091171fcee97c7e1264f82", + "name": "ptyprocess", + "sha256": "1a46a0ff334d3153e0d8873a06308c4e4dad5d3670c1fce26d3a2f7686259e2c", + "size": 22427, + "subdir": "linux-64", + "timestamp": 1505690216282, + "version": "0.5.2" + }, + "ptyprocess-0.5.2-py35h38ce0a3_0.conda": { + "build": "py35h38ce0a3_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "fa2a6ca0cd239c563c455a6d2d008e05", + "name": "ptyprocess", + "sha256": "578b0195ddb2ceb10956984bea8c764ee23423a5339f1f769206961c149f6872", + "size": 22629, + "subdir": "linux-64", + "timestamp": 1505690227056, + "version": "0.5.2" + }, + "ptyprocess-0.5.2-py36h69acd42_0.conda": { + "build": "py36h69acd42_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "ea94742d66984670db57f6f6aa29ec97", + "name": "ptyprocess", + "sha256": "c514f0199bfb225dffe2a33e6ad6abc81bd5711cb2ac57b99a517657ad5d27aa", + "size": 22390, + "subdir": "linux-64", + "timestamp": 1505690237910, + "version": "0.5.2" + }, + "ptyprocess-0.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "a6ca296e6df5018e7df1baf87d48a92f", + "name": "ptyprocess", + "sha256": "c73cbb02ea32315327a84a8615bb51cd4532b7be8777413c59752b23020a364f", + "size": 22954, + "subdir": "linux-64", + "timestamp": 1529940995642, + "version": "0.6.0" + }, + "ptyprocess-0.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "d5a42bc056ce58f29e1b4bfbae0eb344", + "name": "ptyprocess", + "sha256": "9ec3a521092a601d82ad8e9440e141fee8a77bf1d3961f8412440a1ea25989ed", + "size": 23302, + "subdir": "linux-64", + "timestamp": 1529941006472, + "version": "0.6.0" + }, + "ptyprocess-0.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "d509376e83a5aa61426727290652949a", + "name": "ptyprocess", + "sha256": "495726c3341100a1a55a9a92e49a129f6f569e599c731f22458674211cf7b30c", + "size": 23308, + "subdir": "linux-64", + "timestamp": 1529940952792, + "version": "0.6.0" + }, + "ptyprocess-0.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "e426840f47d5226e764802cb2d6226d6", + "name": "ptyprocess", + "sha256": "6c244dba78c500bfe8b36af64603659af5c0678f4ca931ced13f61622d4f78d3", + "size": 23136, + "subdir": "linux-64", + "timestamp": 1530694737919, + "version": "0.6.0" + }, + "ptyprocess-0.6.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "14f792d4d08f09ca5718ad58d98f8336", + "name": "ptyprocess", + "sha256": "f6f48d7d8e8ad9e6e09aa4a329376335e3770954dc3c81b518b3b1b48b85607f", + "size": 23667, + "subdir": "linux-64", + "timestamp": 1573040795975, + "version": "0.6.0" + }, + "pugixml-1.11.4-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "048faaa67d54080c4a40af6aab2af80f", + "name": "pugixml", + "sha256": "a25128ad71ea282b6e4506cb9a013c24cf851fca7b5a44c5648968399c85e51c", + "size": 107804, + "subdir": "linux-64", + "timestamp": 1641920820198, + "version": "1.11.4" + }, + "pugixml-1.11.4-h295c915_1.conda": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad588f4ba5768cbed4c9f4f17821c096", + "name": "pugixml", + "sha256": "753f155683f9cee112c22c06ce1c0073ee32c5117212093f0e696de2fba2acf7", + "size": 108297, + "subdir": "linux-64", + "timestamp": 1644215826526, + "version": "1.11.4" + }, + "pure-sasl-0.4.0-py27h6e92d2f_0.conda": { + "build": "py27h6e92d2f_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "be6de8235841d65a6c34ad0734eb5746", + "name": "pure-sasl", + "sha256": "da1c6907a4bcca9c095f041a51886376fef38342dcd663c41a14344491863970", + "size": 20051, + "subdir": "linux-64", + "timestamp": 1512152747066, + "version": "0.4.0" + }, + "pure-sasl-0.4.0-py35h3910ffa_0.conda": { + "build": "py35h3910ffa_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "89b929b344fed6a0b6e7849612e99d05", + "name": "pure-sasl", + "sha256": "148f36858a2c79ba80815f31fafc8fd921e1a224d67e120605ddc90f0145dc4e", + "size": 20547, + "subdir": "linux-64", + "timestamp": 1512152768267, + "version": "0.4.0" + }, + "pure-sasl-0.4.0-py36h4dcc5df_0.conda": { + "build": "py36h4dcc5df_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6d4d8b38084ce566c87c3526bebf5974", + "name": "pure-sasl", + "sha256": "84761d350ff424444cbcf29dc46480c6e5d8b7576db59aca76e6a66bb5aac2dd", + "size": 20284, + "subdir": "linux-64", + "timestamp": 1512152784226, + "version": "0.4.0" + }, + "pure-sasl-0.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "aab1607c657bc760078bb94f011634ca", + "name": "pure-sasl", + "sha256": "1c1c26b24fc4d5700990711811d9ccea25eb4f53e0178a6127d0df1afb4fbffb", + "size": 20812, + "subdir": "linux-64", + "timestamp": 1522103965645, + "version": "0.5.0" + }, + "pure-sasl-0.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "886697a9accf963ac569d4183d107a23", + "name": "pure-sasl", + "sha256": "52150232331af7dfd7b0a20f2b1d97e725b45058111579c013ff8434fe10a398", + "size": 21234, + "subdir": "linux-64", + "timestamp": 1522103972629, + "version": "0.5.0" + }, + "pure-sasl-0.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6e29b7fb8f3563e3565a77ce48f4d9b6", + "name": "pure-sasl", + "sha256": "55601bf57c38152d65c5499a737205d8b34468fad21ebf8b86a3f571576321b7", + "size": 21037, + "subdir": "linux-64", + "timestamp": 1522103976657, + "version": "0.5.0" + }, + "pure-sasl-0.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "87360c88867f436deebf2be12a30fcc8", + "name": "pure-sasl", + "sha256": "5a56fe5b5f0f0b77053bfdb42a68262c3233e3567f4c26a45091523b9d5c0fd1", + "size": 21112, + "subdir": "linux-64", + "timestamp": 1527851855605, + "version": "0.5.1" + }, + "pure-sasl-0.5.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "91fbdb6d8bd8b3ebd37a543f86591b23", + "name": "pure-sasl", + "sha256": "aa9a791b33ca345e27907ace95d419942f20aba8705d803aaa7025252b306be4", + "size": 21554, + "subdir": "linux-64", + "timestamp": 1527851868541, + "version": "0.5.1" + }, + "pure-sasl-0.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ba03c0f1d41677ccb4d5720fd06808f2", + "name": "pure-sasl", + "sha256": "5bab78dca752e0ea7903195fa23b29f8fbc5fc10cb2b382187c8f183a3c17f76", + "size": 21366, + "subdir": "linux-64", + "timestamp": 1527851811771, + "version": "0.5.1" + }, + "pure-sasl-0.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a36c52009d19ea5938328f4f9cce39d3", + "name": "pure-sasl", + "sha256": "0155f4a81ec10bc5644aec33561d4cce1a74ae78e2735ecf48584f7d9dd23a48", + "size": 21568, + "subdir": "linux-64", + "timestamp": 1530906201675, + "version": "0.5.1" + }, + "py-1.4.34-py27he5894e4_1.conda": { + "build": "py27he5894e4_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "812e2dfd00e669e7c96ecc29b115be8a", + "name": "py", + "sha256": "1accdb3375b6b7cc95de404dc76538334c233f730d0cc4fc2bc7f29bdb515cfe", + "size": 143498, + "subdir": "linux-64", + "timestamp": 1505688184827, + "version": "1.4.34" + }, + "py-1.4.34-py35hd71111f_1.conda": { + "build": "py35hd71111f_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "d490155bb1f81dd6bb69dc936228e0aa", + "name": "py", + "sha256": "043c43897d88c0ae5823d2cd744be8a5b943803ee2539e74cb21ad288f4c28c8", + "size": 146270, + "subdir": "linux-64", + "timestamp": 1505688197893, + "version": "1.4.34" + }, + "py-1.4.34-py36h0712aa3_1.conda": { + "build": "py36h0712aa3_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "971a6ae91344dfbdc734527539c0bc32", + "name": "py", + "sha256": "bc838cd03b63b7b1c4da40211b1665bf341bf383cb816cd108decfa73da4361e", + "size": 144429, + "subdir": "linux-64", + "timestamp": 1505688211014, + "version": "1.4.34" + }, + "py-1.5.2-py27h203d672_0.conda": { + "build": "py27h203d672_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "a9855471d67a28d6f39f66a290e2cd20", + "name": "py", + "sha256": "e5d0aecaaff17653f77a433f2a6405c7dd13fd95406413972c8decd5de0a9171", + "size": 146167, + "subdir": "linux-64", + "timestamp": 1511322549308, + "version": "1.5.2" + }, + "py-1.5.2-py35hfe8c5ce_0.conda": { + "build": "py35hfe8c5ce_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "85be9052032ba24bf242c4b44fa4723b", + "name": "py", + "sha256": "dd486cf50db29e8adda8fcd4a25fcacac8f88f3e63768b26192f32e192ecf1cf", + "size": 147024, + "subdir": "linux-64", + "timestamp": 1511322563707, + "version": "1.5.2" + }, + "py-1.5.2-py36h29bf505_0.conda": { + "build": "py36h29bf505_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "407f0a08701ff2efcfcd574ab6727c67", + "name": "py", + "sha256": "3d4485a88443eed34348b0fc975d1ebbb98130c68492795d67d74a059b5c11de", + "size": 147116, + "subdir": "linux-64", + "timestamp": 1511322565174, + "version": "1.5.2" + }, + "py-1.5.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7273d649f53bbe016d2e8317916fb7c2", + "name": "py", + "sha256": "bfd215d51c5c0632e783c3337855d4b450909ed16d9a96fe8c60edc768716138", + "size": 144328, + "subdir": "linux-64", + "timestamp": 1522163180006, + "version": "1.5.3" + }, + "py-1.5.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "9e1a35f0d01176ce7ac2d53278fa0b32", + "name": "py", + "sha256": "bbf55db02a9067d1afe7285e80aa743fd1973268fc9a27c481c73dec7d2281a7", + "size": 149237, + "subdir": "linux-64", + "timestamp": 1522163218363, + "version": "1.5.3" + }, + "py-1.5.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "adbaefe2ab29c4c9402fd37bcf53647f", + "name": "py", + "sha256": "20a0d7d89501af6d43318f04a79cf0d20eb8d0ea95557d94641b5e0ca2a68caf", + "size": 147200, + "subdir": "linux-64", + "timestamp": 1522163217552, + "version": "1.5.3" + }, + "py-1.5.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "44e6746292cedcf79e6c4b51a3e84968", + "name": "py", + "sha256": "29c53b7d429a5a1008503eaf58bf009d3fcc91f806554fc3db3891a5d875e0e7", + "size": 147097, + "subdir": "linux-64", + "timestamp": 1530693620778, + "version": "1.5.3" + }, + "py-1.5.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "3b43f9b7ed950f24db6a93c582a7917e", + "name": "py", + "sha256": "9c9693e4e73705c870a7cd2ae1647b1f2efcc7b1e12a283f70e9e23931143bf8", + "size": 146416, + "subdir": "linux-64", + "timestamp": 1531784091229, + "version": "1.5.4" + }, + "py-1.5.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "8c0a728b4aefe260e55a1e189dcd963d", + "name": "py", + "sha256": "497c8d9c33ed2018f3b47e0c288cac808c1ac1aae62da7aaa1f09e5c4448d67a", + "size": 149390, + "subdir": "linux-64", + "timestamp": 1531784133541, + "version": "1.5.4" + }, + "py-1.5.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "335fda29014a58a057c0f9e30ff1dd2f", + "name": "py", + "sha256": "4cf24313fdf13557cd571f50bd001a359c3e78be6a6765c520f3f928cf089a1e", + "size": 149450, + "subdir": "linux-64", + "timestamp": 1531784016590, + "version": "1.5.4" + }, + "py-1.5.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1d36e463b645f9dab8cae0788b49d19b", + "name": "py", + "sha256": "d32c22d2eed1b1366ec735ca6d771aa94398f5f840bbf1a493791622e442ca20", + "size": 149416, + "subdir": "linux-64", + "timestamp": 1531784192329, + "version": "1.5.4" + }, + "py-1.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e0fbe2941dead82f39ee5350d14a1a5b", + "name": "py", + "sha256": "bdf49d4f07f467a089b9bcda464741a713002f9d8c3db8013b99e239279aea9d", + "size": 147284, + "subdir": "linux-64", + "timestamp": 1536073016853, + "version": "1.6.0" + }, + "py-1.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "d44d46ce531640428eafb84d7a778e38", + "name": "py", + "sha256": "cab3c82e2bab1dcca73faad6d1effe164b1f1388c4b8242f47cdf38cf436e046", + "size": 148058, + "subdir": "linux-64", + "timestamp": 1536073016853, + "version": "1.6.0" + }, + "py-1.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0b729aeae45b3536510d41e61dfdc88b", + "name": "py", + "sha256": "bfc52f91ceb6577479bba8f432bf72f0f3c92a85e6773aa997fc9295cb53533b", + "size": 146299, + "subdir": "linux-64", + "timestamp": 1536072989027, + "version": "1.6.0" + }, + "py-1.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3cdd30b49b05c1ce3c1a2ee7b529443b", + "name": "py", + "sha256": "fba0269965daf8e108122b07b8656c43ebe4386421546a7d51e74677bb17c434", + "size": 146352, + "subdir": "linux-64", + "timestamp": 1536073044758, + "version": "1.6.0" + }, + "py-1.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "bc73cb3c576d9b9c2e3f94fa64c3ae9d", + "name": "py", + "sha256": "e00004229d74922d7d8be522920d181a32786e9579b8ae4be4ea05bf7f5bb3db", + "size": 147402, + "subdir": "linux-64", + "timestamp": 1539631993187, + "version": "1.7.0" + }, + "py-1.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c454552408296ef671bddf209b3ed9b1", + "name": "py", + "sha256": "6f0bfa2f7e0c2e0adfbb414d6b88bc6a92d67a06cdffe98ad0233b6e4ab42d91", + "size": 148661, + "subdir": "linux-64", + "timestamp": 1539632007428, + "version": "1.7.0" + }, + "py-1.7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "67c9fed9f89ca83785718a851f29f8a7", + "name": "py", + "sha256": "158c288cc92716457ca132d16650a4dbc1f71bd16a1e9e9ebeec6445f804468b", + "size": 148429, + "subdir": "linux-64", + "timestamp": 1539631998253, + "version": "1.7.0" + }, + "py-1.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ad872da7da537fa66ab33553d5fee36a", + "name": "py", + "sha256": "bb97ea08f34994326e78bfcf500f835a9a926b184bf40ebe396eabd406248a24", + "size": 150829, + "subdir": "linux-64", + "timestamp": 1551146090097, + "version": "1.8.0" + }, + "py-1.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2ab5ff23f3754aca79022194c61615a6", + "name": "py", + "sha256": "20d4697677ea7eff0eab82649af19e04d8015aedff87fa68af3f8ca2cade920d", + "size": 150001, + "subdir": "linux-64", + "timestamp": 1551146107081, + "version": "1.8.0" + }, + "py-1.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "9b9d99e3f3db65dfd942a706e3830bb6", + "name": "py", + "sha256": "0321b83e62aefd709b3116a9436af935d19b15ac9cdda1a1458823a6f5b93379", + "size": 151878, + "subdir": "linux-64", + "timestamp": 1551146067263, + "version": "1.8.0" + }, + "py-boost-1.65.1-py27h3b928e7_3.conda": { + "build": "py27h3b928e7_3", + "build_number": 3, + "depends": [ + "libboost 1.65.1 h4055789_3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Boost-1.0", + "md5": "6398b3dbee3504f22c1b83a316eba06d", + "name": "py-boost", + "sha256": "ea98c611cb7e5d06003b3e737a33451f9db56e427155b836d24db9741c4eaf0d", + "size": 279644, + "subdir": "linux-64", + "timestamp": 1508786716540, + "version": "1.65.1" + }, + "py-boost-1.65.1-py27hf484d3e_4.conda": { + "build": "py27hf484d3e_4", + "build_number": 4, + "depends": [ + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "Boost-1.0", + "md5": "440f72acff8e58486fd3ec0c26f26164", + "name": "py-boost", + "sha256": "f2dab63016d4b3127d35cd33a2f1cc8b36002af407cc2d57fdfcdd8870876eb9", + "size": 281226, + "subdir": "linux-64", + "timestamp": 1515095659386, + "version": "1.65.1" + }, + "py-boost-1.65.1-py35hdf000e1_3.conda": { + "build": "py35hdf000e1_3", + "build_number": 3, + "depends": [ + "libboost 1.65.1 h4055789_3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy", + "python >=3.5,<3.6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Boost-1.0", + "md5": "63a36d525efb8bf5872ebe3ca721f538", + "name": "py-boost", + "sha256": "85804823066c04632363b7492841fab561c34cf82e1f4effea49b3ad3f3c1459", + "size": 278274, + "subdir": "linux-64", + "timestamp": 1508786699581, + "version": "1.65.1" + }, + "py-boost-1.65.1-py35hf484d3e_4.conda": { + "build": "py35hf484d3e_4", + "build_number": 4, + "depends": [ + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "Boost-1.0", + "md5": "cbc39b0bbdd37655abd4262d78e38aa0", + "name": "py-boost", + "sha256": "b42880e2b6c085853e9dd078acb90a067289e87be086ccc704462be96780fa65", + "size": 278500, + "subdir": "linux-64", + "timestamp": 1515095557209, + "version": "1.65.1" + }, + "py-boost-1.65.1-py36hf484d3e_4.conda": { + "build": "py36hf484d3e_4", + "build_number": 4, + "depends": [ + "libboost >=1.65.1,<1.66.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "9e188bf86afd318541b17a9e4f0fff10", + "name": "py-boost", + "sha256": "e88e8a28a553f074560a56c36a340aed2131402902bea31cfdf739465c5b21fa", + "size": 279757, + "subdir": "linux-64", + "timestamp": 1515095440777, + "version": "1.65.1" + }, + "py-boost-1.65.1-py36hff4598c_3.conda": { + "build": "py36hff4598c_3", + "build_number": 3, + "depends": [ + "libboost 1.65.1 h4055789_3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Boost-1.0", + "md5": "3016390289a94c7585c0d9ac86304f69", + "name": "py-boost", + "sha256": "74494ea1d2771a51684bd93b51164dd3e7424f43d5061a2556a2aa8c472a4b0b", + "size": 278390, + "subdir": "linux-64", + "timestamp": 1508786733552, + "version": "1.65.1" + }, + "py-boost-1.67.0-py27h04863e7_4.conda": { + "build": "py27h04863e7_4", + "build_number": 4, + "depends": [ + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "Boost-1.0", + "md5": "45c24b9055fd07d1816e9e96c4c72c0f", + "name": "py-boost", + "sha256": "62597afe05f275001eddc90dba6265f5902220277b8deb56497cb8e5419aee36", + "size": 287395, + "subdir": "linux-64", + "timestamp": 1530782153386, + "version": "1.67.0" + }, + "py-boost-1.67.0-py35h04863e7_4.conda": { + "build": "py35h04863e7_4", + "build_number": 4, + "depends": [ + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "Boost-1.0", + "md5": "9f43b4003b0074ab167f93cf21c83de8", + "name": "py-boost", + "sha256": "2017d5fe82fdf3370c617a86d3f9a25d47106323254456f231e9c3fca46c7997", + "size": 293089, + "subdir": "linux-64", + "timestamp": 1534944641004, + "version": "1.67.0" + }, + "py-boost-1.67.0-py36h04863e7_4.conda": { + "build": "py36h04863e7_4", + "build_number": 4, + "depends": [ + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "7ba5df3bd814b7aad30c4ea04543ef14", + "name": "py-boost", + "sha256": "5392b654e0aee8944b4ad9b51231a731acd3464f1bc55b1a4928328f0aad3093", + "size": 284369, + "subdir": "linux-64", + "timestamp": 1530782210803, + "version": "1.67.0" + }, + "py-boost-1.67.0-py37h04863e7_4.conda": { + "build": "py37h04863e7_4", + "build_number": 4, + "depends": [ + "libboost >=1.67.0,<1.67.1.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "d02ece53b0dfb48bd44e5996f92bc87b", + "name": "py-boost", + "sha256": "0e78985cbd1620c018738810a87431a82aa1bdf5d5abd150bca874c2ad892c0b", + "size": 284366, + "subdir": "linux-64", + "timestamp": 1530782267799, + "version": "1.67.0" + }, + "py-boost-1.71.0-py310h00e6091_0.conda": { + "build": "py310h00e6091_0", + "build_number": 0, + "depends": [ + "libboost >=1.71.0,<1.71.1.0a0 haf77d95_0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Boost-1.0", + "md5": "67b6175b5fe3d062e795eadd0c4a6aed", + "name": "py-boost", + "sha256": "fc6a8d99211cfd35355b6cbe5c662f68bb977f700f0508334562999e1c91e0cd", + "size": 29316, + "subdir": "linux-64", + "timestamp": 1640823523168, + "version": "1.71.0" + }, + "py-boost-1.71.0-py310h00e6091_1.conda": { + "build": "py310h00e6091_1", + "build_number": 1, + "depends": [ + "libboost >=1.71.0,<1.71.1.0a0 haf77d95_1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Boost-1.0", + "md5": "50745c8148f5d62c061b2002444adb56", + "name": "py-boost", + "sha256": "b16d22c68f295fd9fdfb5acb50051d426fae7c5e7f9ad5999fcde64edf2b84f4", + "size": 218144, + "subdir": "linux-64", + "timestamp": 1642511533168, + "version": "1.71.0" + }, + "py-boost-1.71.0-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "libboost >=1.71.0,<1.71.1.0a0 h97c9712_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "238d99367dd34d30e152c777859491fc", + "name": "py-boost", + "sha256": "e5a32e1851b380815528e4f1c6ff77519db18c5589a0a36ca669d485da0756fc", + "size": 216901, + "subdir": "linux-64", + "timestamp": 1597485868536, + "version": "1.71.0" + }, + "py-boost-1.71.0-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "libboost >=1.71.0,<1.71.1.0a0 h97c9712_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "40b7019c3f5f7f1719062b43791b9f7d", + "name": "py-boost", + "sha256": "769051c9684814f54e60571a1316cc2780b488b85826037b4cbd005eb49d7115", + "size": 217041, + "subdir": "linux-64", + "timestamp": 1597485989217, + "version": "1.71.0" + }, + "py-boost-1.71.0-py37h51133e4_1.conda": { + "build": "py37h51133e4_1", + "build_number": 1, + "depends": [ + "libboost >=1.71.0,<1.71.1.0a0 haf77d95_1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "421223a1abb0fc8b71b5fb3dacab5ff3", + "name": "py-boost", + "sha256": "ddaad62d75ad804d2ab096bc99f250286aa28c85eae93c94254fa8c11aaea1d9", + "size": 201352, + "subdir": "linux-64", + "timestamp": 1642425120003, + "version": "1.71.0" + }, + "py-boost-1.71.0-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "libboost >=1.71.0,<1.71.1.0a0 h97c9712_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "b8373538b0450586967c166b3084e7c3", + "name": "py-boost", + "sha256": "0fd719608ea01ea6a0fa91767e9bfa67a5cbca01c921c4128a3bf50fe603c75d", + "size": 231216, + "subdir": "linux-64", + "timestamp": 1597486057870, + "version": "1.71.0" + }, + "py-boost-1.71.0-py38h51133e4_1.conda": { + "build": "py38h51133e4_1", + "build_number": 1, + "depends": [ + "libboost >=1.71.0,<1.71.1.0a0 haf77d95_1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "1068b48acb6f09d7c348ac346afe0e5a", + "name": "py-boost", + "sha256": "bcb566be7bce275119a1edf6cc37cc256cb09136c511c174c341d357d44951c5", + "size": 215615, + "subdir": "linux-64", + "timestamp": 1642425231565, + "version": "1.71.0" + }, + "py-boost-1.71.0-py38h962f231_0.conda": { + "build": "py38h962f231_0", + "build_number": 0, + "depends": [ + "libboost >=1.71.0,<1.71.1.0a0 h97c9712_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "2beceb4a8e61d2ce270113025b732abd", + "name": "py-boost", + "sha256": "b3ec198b583c3c9fef28e0e4ede409b6e8313cc44b5dbdabc171074cf5b4cf80", + "size": 223975, + "subdir": "linux-64", + "timestamp": 1572611048021, + "version": "1.71.0" + }, + "py-boost-1.71.0-py39h51133e4_1.conda": { + "build": "py39h51133e4_1", + "build_number": 1, + "depends": [ + "libboost >=1.71.0,<1.71.1.0a0 haf77d95_1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Boost-1.0", + "md5": "c4595896bab1d3cee3d1956923e50583", + "name": "py-boost", + "sha256": "943d060165bee557248ff1262b739a09085e6aeff36f70ce1623e5b46ece906a", + "size": 215279, + "subdir": "linux-64", + "timestamp": 1642425158617, + "version": "1.71.0" + }, + "py-boost-1.73.0-py310h00e6091_12.conda": { + "build": "py310h00e6091_12", + "build_number": 12, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h28710b8_12", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "350d59b36633bc652fdd8154e3ed5031", + "name": "py-boost", + "sha256": "0eec913ec09eaec46241c4fe31bee20f91008fd78ee00407b188f821d7aca927", + "size": 212950, + "subdir": "linux-64", + "timestamp": 1655880116025, + "version": "1.73.0" + }, + "py-boost-1.73.0-py36h962f231_10.conda": { + "build": "py36h962f231_10", + "build_number": 10, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h37e3b65_10", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "bf7524b4468b3cbb159d5b22f33282bd", + "name": "py-boost", + "sha256": "ead2c7b30afd41036faa84f2bad77b997ddeed0266f1dcaa3641159bf6d3e8e6", + "size": 207943, + "subdir": "linux-64", + "timestamp": 1601386269954, + "version": "1.73.0" + }, + "py-boost-1.73.0-py36h962f231_11.conda": { + "build": "py36h962f231_11", + "build_number": 11, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h37e3b65_11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "5df6e374acea055aa9ff91bbeaf840cb", + "name": "py-boost", + "sha256": "6f47b378fca9b515053a6e446ece64214c9f6ea127f789309705a7f9f3e03376", + "size": 208861, + "subdir": "linux-64", + "timestamp": 1601470652659, + "version": "1.73.0" + }, + "py-boost-1.73.0-py36ha9443f7_11.conda": { + "build": "py36ha9443f7_11", + "build_number": 11, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h3ff78a5_11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Boost-1.0", + "md5": "7edddf45ff21e5b0b5d386d0c5d7ec28", + "name": "py-boost", + "sha256": "ccb4e12a844dd7d22989fd54d88c9151eb601a447dbad283daf7889dccac945c", + "size": 209366, + "subdir": "linux-64", + "timestamp": 1611677407946, + "version": "1.73.0" + }, + "py-boost-1.73.0-py37h04863e7_10.conda": { + "build": "py37h04863e7_10", + "build_number": 10, + "depends": [ + "libboost 1.73.0 hf484d3e_10", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "3c83f923301927a6182e3a3532affd29", + "name": "py-boost", + "sha256": "c677099986a63a3325b8df0c827092d7cc275188d337e915452d734b15cc77fc", + "size": 206235, + "subdir": "linux-64", + "timestamp": 1601386877440, + "version": "1.73.0" + }, + "py-boost-1.73.0-py37h04863e7_11.conda": { + "build": "py37h04863e7_11", + "build_number": 11, + "depends": [ + "libboost 1.73.0 hf484d3e_11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "2c6e6eda0f5dfc087292bf2b56c5291d", + "name": "py-boost", + "sha256": "8d16b0768941ce7fef9789fff38496df6abb4808a6ce5d72721b5d9afb20b6c8", + "size": 207251, + "subdir": "linux-64", + "timestamp": 1601471397180, + "version": "1.73.0" + }, + "py-boost-1.73.0-py37h51133e4_12.conda": { + "build": "py37h51133e4_12", + "build_number": 12, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h28710b8_12", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "ce90a9c4b3d92fb2e1181befc1b23582", + "name": "py-boost", + "sha256": "3831f2f0a8058ad4de826ccaa6a692e44118940c018fa09202248fcfb6947c7f", + "size": 199274, + "subdir": "linux-64", + "timestamp": 1655880058187, + "version": "1.73.0" + }, + "py-boost-1.73.0-py37h962f231_10.conda": { + "build": "py37h962f231_10", + "build_number": 10, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h37e3b65_10", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "c3f8a700aa473ffce460752f043bf994", + "name": "py-boost", + "sha256": "1eec14925597da82edfa7a1c1f27c69441a91d0522c25fc31ce2641a9830cadb", + "size": 207974, + "subdir": "linux-64", + "timestamp": 1601386147926, + "version": "1.73.0" + }, + "py-boost-1.73.0-py37h962f231_11.conda": { + "build": "py37h962f231_11", + "build_number": 11, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h37e3b65_11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "1d8702ed22c9ab3f2f50c1b66f954d02", + "name": "py-boost", + "sha256": "5be12dbae8700419c949a62dd73838e69dda7a29e0b1e79882186b9463b5dae6", + "size": 208894, + "subdir": "linux-64", + "timestamp": 1601470803246, + "version": "1.73.0" + }, + "py-boost-1.73.0-py37ha9443f7_11.conda": { + "build": "py37ha9443f7_11", + "build_number": 11, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h3ff78a5_11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Boost-1.0", + "md5": "2cabd0bd383cad54498e53a99e34facc", + "name": "py-boost", + "sha256": "a148e950f97223cbc6c0fc895647d65847143eabdc0dd20024baa841b3227c76", + "size": 209351, + "subdir": "linux-64", + "timestamp": 1611677214668, + "version": "1.73.0" + }, + "py-boost-1.73.0-py38h51133e4_12.conda": { + "build": "py38h51133e4_12", + "build_number": 12, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h28710b8_12", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "71b13b920c44b08a93389f43dd748b24", + "name": "py-boost", + "sha256": "e9e4a2b21f728e52ea743f9c2c46b5036b4f2cf0e29982c5ac6cc6d478cc96d8", + "size": 213101, + "subdir": "linux-64", + "timestamp": 1655879943412, + "version": "1.73.0" + }, + "py-boost-1.73.0-py38h962f231_10.conda": { + "build": "py38h962f231_10", + "build_number": 10, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h37e3b65_10", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "24b4e89b14f73363ab729fa05190b7c6", + "name": "py-boost", + "sha256": "e1b7c9da6f58bdd36bddac4e41869df9cfe5a9e5736d8d14b77955b8aa36e66d", + "size": 222538, + "subdir": "linux-64", + "timestamp": 1601386209473, + "version": "1.73.0" + }, + "py-boost-1.73.0-py38h962f231_11.conda": { + "build": "py38h962f231_11", + "build_number": 11, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h37e3b65_11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "40a1bb7869c088c3b1cd28e3178f01f0", + "name": "py-boost", + "sha256": "d979bc314e6974106b0aa5e7ff3f4ab0a07303b987a522e1818296f3e4881195", + "size": 223953, + "subdir": "linux-64", + "timestamp": 1601470741827, + "version": "1.73.0" + }, + "py-boost-1.73.0-py38ha9443f7_11.conda": { + "build": "py38ha9443f7_11", + "build_number": 11, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h3ff78a5_11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Boost-1.0", + "md5": "69dedfb9d325070bd3fcd42122f8406d", + "name": "py-boost", + "sha256": "9e9bf186a59602d8dfaeefe43e77e824a2cc2dc8cd2efa7fd8c992648eaf176f", + "size": 224286, + "subdir": "linux-64", + "timestamp": 1611677313741, + "version": "1.73.0" + }, + "py-boost-1.73.0-py39h51133e4_12.conda": { + "build": "py39h51133e4_12", + "build_number": 12, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h28710b8_12", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSL-1.0", + "license_family": "OTHER", + "md5": "4e3b0206a2054ef315b81f82a650a439", + "name": "py-boost", + "sha256": "2bb206d117f56d98c10380cb33b47844f35f714ac7a6c9485f4eb999d5801fe1", + "size": 213097, + "subdir": "linux-64", + "timestamp": 1655880000921, + "version": "1.73.0" + }, + "py-boost-1.73.0-py39ha9443f7_11.conda": { + "build": "py39ha9443f7_11", + "build_number": 11, + "depends": [ + "libboost >=1.73.0,<1.73.1.0a0 h3ff78a5_11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Boost-1.0", + "md5": "d570decb3ef2fa196c079ba77ebccca4", + "name": "py-boost", + "sha256": "24d3c0abfc5c56f24f73e3483d051814ae247e6a013131839de854e7c2dd6a17", + "size": 224456, + "subdir": "linux-64", + "timestamp": 1611677499056, + "version": "1.73.0" + }, + "py-cpuinfo-4.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a019555eca9b5eb4fb4ab5d5cf48a02", + "name": "py-cpuinfo", + "sha256": "8cccd48806f38234c0be47ec777f509c27d1b55ab545f88013e256899de416d2", + "size": 36817, + "subdir": "linux-64", + "timestamp": 1529238993098, + "version": "4.0.0" + }, + "py-cpuinfo-4.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab6c6b417d3e66676d2b0ac158eaf929", + "name": "py-cpuinfo", + "sha256": "e40b60e9f17d3403bb1f1ee1946c791ddc36a10a360845f1ae1d49c4bfa94af1", + "size": 37340, + "subdir": "linux-64", + "timestamp": 1529239005706, + "version": "4.0.0" + }, + "py-cpuinfo-4.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9dc08450a53a6d5b11ff60eb3cb00e1", + "name": "py-cpuinfo", + "sha256": "04d02606a900afab8c2128338ea8932ca6a3aac8bd22a4100cdb93aa7fcde78e", + "size": 36473, + "subdir": "linux-64", + "timestamp": 1529238981525, + "version": "4.0.0" + }, + "py-cpuinfo-4.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "46bbccce3a04b61c983e5081af0b68fc", + "name": "py-cpuinfo", + "sha256": "7d4d6492f4b366d8131f156fd1839d7e1698aab80a618a21d4b9c9ab4181b785", + "size": 36726, + "subdir": "linux-64", + "timestamp": 1530872912884, + "version": "4.0.0" + }, + "py-lief-0.10.1-py310h295c915_1.conda": { + "build": "py310h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "liblief 0.10.1 h295c915_1", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e04f11992b110af1b5645e3094fb8fc5", + "name": "py-lief", + "sha256": "30a9b9bc163753ed53eb5904c6884f9c24e8e540dce952489c4a34b73860a154", + "size": 1065990, + "subdir": "linux-64", + "timestamp": 1640821620380, + "version": "0.10.1" + }, + "py-lief-0.10.1-py36h403a769_0.conda": { + "build": "py36h403a769_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.10.1 he6710b0_0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e144141f6e42fb4a5d5ba56bcf48eb5f", + "name": "py-lief", + "sha256": "3d59acb8bf63a71b72514b8a4f0516e0cb3aae2d548efa37bac2f8c7079ce0fd", + "size": 943474, + "subdir": "linux-64", + "timestamp": 1588594572525, + "version": "0.10.1" + }, + "py-lief-0.10.1-py37h403a769_0.conda": { + "build": "py37h403a769_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.10.1 he6710b0_0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e0544e3b6ba427d5adfc90edd56da097", + "name": "py-lief", + "sha256": "5ff841eeb9bc6f13ea36b547604f5eae3ec5217bab387bb589acae86a0b863db", + "size": 941043, + "subdir": "linux-64", + "timestamp": 1588594250064, + "version": "0.10.1" + }, + "py-lief-0.10.1-py38h403a769_0.conda": { + "build": "py38h403a769_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.10.1 he6710b0_0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ad8be42248839b5464e2b08636ca36f0", + "name": "py-lief", + "sha256": "50d5548447bccd22b632e798f938a646b9a5d750ced0dd58963feef5c1b4003a", + "size": 1079298, + "subdir": "linux-64", + "timestamp": 1588594034625, + "version": "0.10.1" + }, + "py-lief-0.10.1-py39h2531618_1.conda": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.10.1 h2531618_1", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d8b0a072c68568384026905223bcfc37", + "name": "py-lief", + "sha256": "8384ea5b3c9ce6471f96d64eef64f4e3b1301d78dd830db1f5d606a8af4f2e1d", + "size": 1070102, + "subdir": "linux-64", + "timestamp": 1607402088727, + "version": "0.10.1" + }, + "py-lief-0.11.5-py310h295c915_1.conda": { + "build": "py310h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "liblief 0.11.5 h295c915_1", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3b06ec404a12ea894717d4acd4a4f28a", + "name": "py-lief", + "sha256": "bf10c0d64a59b59fb8638eb4e2d19b3b79061d261f59aefc266098dfeaf7a307", + "size": 1133956, + "subdir": "linux-64", + "timestamp": 1648524414384, + "version": "0.11.5" + }, + "py-lief-0.11.5-py37h295c915_1.conda": { + "build": "py37h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "liblief 0.11.5 h295c915_1", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ef446b4540c5f67fedddb0a0673ac633", + "name": "py-lief", + "sha256": "bb95f9a5c621d1c607441a5c75e3af53182fdc7162fd94b2311ff3e228c3cdfb", + "size": 1016072, + "subdir": "linux-64", + "timestamp": 1648523895595, + "version": "0.11.5" + }, + "py-lief-0.11.5-py38h295c915_1.conda": { + "build": "py38h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "liblief 0.11.5 h295c915_1", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ac968b6913ff35a410009f8f70f1d30a", + "name": "py-lief", + "sha256": "e5ade2812c4bf3125224d56026a7e4a8606f97cf8805b3fd9ebd15d5082b92a0", + "size": 1134227, + "subdir": "linux-64", + "timestamp": 1648524154796, + "version": "0.11.5" + }, + "py-lief-0.11.5-py39h295c915_1.conda": { + "build": "py39h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "liblief 0.11.5 h295c915_1", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "05a2d7053f546980d8463f56eb44b504", + "name": "py-lief", + "sha256": "b592b4749c42c70cb296caf81b2cdb5e9a718ce1c8cf85568c30ec69110e7f9f", + "size": 1133534, + "subdir": "linux-64", + "timestamp": 1648524673212, + "version": "0.11.5" + }, + "py-lief-0.12.3-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "liblief 0.12.3 h6a678d5_0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "deb974cab7b8521457561e115ac21bfc", + "name": "py-lief", + "sha256": "3c759fd9e602d447984ea03d1963a4a64fbfab28bdc7a0c74ef263a83eff57fc", + "size": 1465158, + "subdir": "linux-64", + "timestamp": 1670880875825, + "version": "0.12.3" + }, + "py-lief-0.12.3-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "liblief 0.12.3 h6a678d5_0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cfb50b26cb3b361c6dd530fe2e464e8c", + "name": "py-lief", + "sha256": "523076c5cfa56c1485fc40e4c9acc75fd022d4724e930d6ac52ca468cb096ed6", + "size": 1332632, + "subdir": "linux-64", + "timestamp": 1676841196631, + "version": "0.12.3" + }, + "py-lief-0.12.3-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "liblief 0.12.3 h6a678d5_0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cae266a1ac9b626273267988aae44201", + "name": "py-lief", + "sha256": "90be2074a718a9205b14ab2d2a81e07d5612b9ea1893dc30f03340cd415f2a73", + "size": 1355009, + "subdir": "linux-64", + "timestamp": 1670878757521, + "version": "0.12.3" + }, + "py-lief-0.12.3-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "liblief 0.12.3 h6a678d5_0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6146d6560f8b64852c7cc9e848674b87", + "name": "py-lief", + "sha256": "b1ce532878c4778b102bde76ffd85fddf0456890af33d63bd230423ef8b26dc0", + "size": 1462191, + "subdir": "linux-64", + "timestamp": 1670879818783, + "version": "0.12.3" + }, + "py-lief-0.12.3-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "liblief 0.12.3 h6a678d5_0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f0f49575a94f56b68474562e3fa60366", + "name": "py-lief", + "sha256": "c8f06ccab3104d705aa2e3fcc9131b0536f4b722a1c8b95d88e64dcde62f3a59", + "size": 1477680, + "subdir": "linux-64", + "timestamp": 1670877648423, + "version": "0.12.3" + }, + "py-lief-0.8.3-py27h1532aa0_0.conda": { + "build": "py27h1532aa0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "liblief 0.8.3 h1532aa0_0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c402f1267440de8bbb1137328683d8b3", + "name": "py-lief", + "sha256": "e8ccc37c823be7a758776e41c9a686227a8cbd79d5734a93b775bc7e5ffaeade", + "size": 2015121, + "subdir": "linux-64", + "timestamp": 1528207748961, + "version": "0.8.3" + }, + "py-lief-0.8.3-py35h1532aa0_0.conda": { + "build": "py35h1532aa0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "liblief 0.8.3 h1532aa0_0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "97e2a0b3f37ef24bbd263de28446afc2", + "name": "py-lief", + "sha256": "82d2817a14a9f17aa2c18f569c354263d125d9b92dbea9f7065cc47c4f2d5358", + "size": 2003043, + "subdir": "linux-64", + "timestamp": 1528207136652, + "version": "0.8.3" + }, + "py-lief-0.8.3-py36h1532aa0_0.conda": { + "build": "py36h1532aa0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "liblief 0.8.3 h1532aa0_0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "937629cd25787ca31dccdea077957d71", + "name": "py-lief", + "sha256": "cdbc6e74dbcc03e796d0872ea435b1f8103f54aa9c1b8bf5d678c70712b448ff", + "size": 2003501, + "subdir": "linux-64", + "timestamp": 1528207444282, + "version": "0.8.3" + }, + "py-lief-0.9.0-py27h1532aa0_0.conda": { + "build": "py27h1532aa0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "liblief 0.9.0 h1532aa0_0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b80bfb3b61c69b98e4d83feb9dcab8c6", + "name": "py-lief", + "sha256": "c02dfb79d08bc9ecdbab91652bb366db0bef30b671bf01e6c755e4c7b49981cb", + "size": 2493594, + "subdir": "linux-64", + "timestamp": 1528676064407, + "version": "0.9.0" + }, + "py-lief-0.9.0-py27h7725739_1.conda": { + "build": "py27h7725739_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.9.0 h7725739_1", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "49ae9e7e469f8c21bd60751b41245731", + "name": "py-lief", + "sha256": "5d27d9733a4abab126e254820c75fb8714edf130bfb654a1aa1b15236794b3c3", + "size": 2654785, + "subdir": "linux-64", + "timestamp": 1541029497560, + "version": "0.9.0" + }, + "py-lief-0.9.0-py27h7725739_2.conda": { + "build": "py27h7725739_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.9.0 h7725739_2", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "00bf890d04fdf15767c1e3ca9a65e1b1", + "name": "py-lief", + "sha256": "5befbea5fbd9fc21d174cdd6c7ff1fb09f98c451761bc055da0330862f052bf1", + "size": 1334683, + "subdir": "linux-64", + "timestamp": 1547592380460, + "version": "0.9.0" + }, + "py-lief-0.9.0-py35h1532aa0_0.conda": { + "build": "py35h1532aa0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "liblief 0.9.0 h1532aa0_0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6b3df2e19120c244f4942d659a3cf1b7", + "name": "py-lief", + "sha256": "9d0189ef05238af4e7eed0af43f6280271eac6df386d03f7ad08a5ee0d16ae06", + "size": 2484735, + "subdir": "linux-64", + "timestamp": 1528676824186, + "version": "0.9.0" + }, + "py-lief-0.9.0-py36h1532aa0_0.conda": { + "build": "py36h1532aa0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "liblief 0.9.0 h1532aa0_0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ae5308afad1a1bb9393fde1630d281af", + "name": "py-lief", + "sha256": "f822820bec2afd39b04fb6adcfafdaa2ea2c04b24d2c41f678bbaceba0761dba", + "size": 2485994, + "subdir": "linux-64", + "timestamp": 1528676443833, + "version": "0.9.0" + }, + "py-lief-0.9.0-py36h7725739_1.conda": { + "build": "py36h7725739_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.9.0 h7725739_1", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "810d762c4e9cf21f912f8ab30b468e60", + "name": "py-lief", + "sha256": "9dbb5db6bd2cf9935bf35722339150a504afe6d92ea766eb674382b6d8970825", + "size": 2635340, + "subdir": "linux-64", + "timestamp": 1541029008879, + "version": "0.9.0" + }, + "py-lief-0.9.0-py36h7725739_2.conda": { + "build": "py36h7725739_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.9.0 h7725739_2", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0fedc27c42ce470b0a3e16673832d815", + "name": "py-lief", + "sha256": "7654124160dace6389cec6121463651289c1e2b62119f1996c8230fd247598bb", + "size": 1311765, + "subdir": "linux-64", + "timestamp": 1547592894374, + "version": "0.9.0" + }, + "py-lief-0.9.0-py37h1532aa0_0.conda": { + "build": "py37h1532aa0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "liblief 0.9.0 h1532aa0_0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2a9f06557bd0c0cf2861cec0856425fd", + "name": "py-lief", + "sha256": "2dbac6bbcac0e0ecf5bdb9229fd42fefa7934c7c212e32b9b339c6c95cec6209", + "size": 2486527, + "subdir": "linux-64", + "timestamp": 1531770257700, + "version": "0.9.0" + }, + "py-lief-0.9.0-py37h7725739_1.conda": { + "build": "py37h7725739_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.9.0 h7725739_1", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "99b9c256e83b3440eb6f7fa06554c3b8", + "name": "py-lief", + "sha256": "faaf4b1b5bcc78961d9d22a974b0be112ed921276c03e40c8a2ba89e978ced0a", + "size": 2631890, + "subdir": "linux-64", + "timestamp": 1541029256807, + "version": "0.9.0" + }, + "py-lief-0.9.0-py37h7725739_2.conda": { + "build": "py37h7725739_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "liblief 0.9.0 h7725739_2", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "741bfbe036c518e492faae88f558c2f7", + "name": "py-lief", + "sha256": "db2c8183f767acdc1c9c45fbbc148a473e51f1b83d94a90594cde3239168166a", + "size": 1312777, + "subdir": "linux-64", + "timestamp": 1547593382791, + "version": "0.9.0" + }, + "py-mxnet-1.0.0-py27_nomklhf484d3e_0.conda": { + "build": "py27_nomklhf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.0.0 nomklh2cb3ce3_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "c3fcae9bef8c95b14d85d93bece74c86", + "name": "py-mxnet", + "sha256": "129519140507aab6f545dac522704357674e09dac083103cb69f026678175c2b", + "size": 514164, + "subdir": "linux-64", + "timestamp": 1514731518019, + "version": "1.0.0" + }, + "py-mxnet-1.0.0-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.0.0 hb7fadbc_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "2221cbe10367a9cb12c692fcc02903a7", + "name": "py-mxnet", + "sha256": "229de271168c03bc1d95f4450667e7e76863acadf79cd175919ba013b69ba47b", + "size": 592673, + "subdir": "linux-64", + "timestamp": 1514730658321, + "version": "1.0.0" + }, + "py-mxnet-1.0.0-py35_nomklhf484d3e_0.conda": { + "build": "py35_nomklhf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.0.0 nomklh2cb3ce3_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=3.5,<3.6.0a0", + "requests >=2.18.4,<3", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "b3960491ca2c75fd05192013f0809c2e", + "name": "py-mxnet", + "sha256": "f4772ec653626e201d608e819965fe6644bdb1aa94e45ccb893b765ed68ce1a0", + "size": 533321, + "subdir": "linux-64", + "timestamp": 1514731560600, + "version": "1.0.0" + }, + "py-mxnet-1.0.0-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.0.0 hb7fadbc_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=3.5,<3.6.0a0", + "requests >=2.18.4,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "5e234d03522e22d4794e0b537545df94", + "name": "py-mxnet", + "sha256": "6b8950bd8c663062cf6f6c7f35f7753b58454fbcf1dbce5204068d2cc4c9ef3b", + "size": 613807, + "subdir": "linux-64", + "timestamp": 1514730730868, + "version": "1.0.0" + }, + "py-mxnet-1.0.0-py36_nomklhf484d3e_0.conda": { + "build": "py36_nomklhf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.0.0 nomklh2cb3ce3_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "b0ee085385cfdd40dfb691f38c49b1e2", + "name": "py-mxnet", + "sha256": "443b60de0d15282f54e37060011287bd9d956a3a1b4f41d18f26e91548e3d32f", + "size": 529647, + "subdir": "linux-64", + "timestamp": 1514731605997, + "version": "1.0.0" + }, + "py-mxnet-1.0.0-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.0.0 hb7fadbc_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "26f401b1fb8072448e98a50a0c4dccaa", + "name": "py-mxnet", + "sha256": "311df96eec37cdc982ddae40de3a09ed6e564ce105166b9d7421c3650e89d67e", + "size": 601511, + "subdir": "linux-64", + "timestamp": 1514730772242, + "version": "1.0.0" + }, + "py-mxnet-1.1.0-py27_nomklhf484d3e_0.conda": { + "build": "py27_nomklhf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.1.0 nomklh028b6bb_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "1394b75d0c65f44aae34f5a4a9772e56", + "name": "py-mxnet", + "sha256": "6c6ae014b62b679d1f38205de7057102bd3dbef19fab0e23b5a6a809a5c77c73", + "size": 559194, + "subdir": "linux-64", + "timestamp": 1522953592864, + "version": "1.1.0" + }, + "py-mxnet-1.1.0-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.1.0 h47cb24f_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "dd12c615e911f528ffcf1c8852a36e7d", + "name": "py-mxnet", + "sha256": "0c734ed9bc80b115c6097089c9b8c08a171e098909009dd41243b62e470ae2cd", + "size": 650575, + "subdir": "linux-64", + "timestamp": 1522952820011, + "version": "1.1.0" + }, + "py-mxnet-1.1.0-py35_nomklhf484d3e_0.conda": { + "build": "py35_nomklhf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.1.0 nomklh028b6bb_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=3.5,<3.6.0a0", + "requests >=2.18.4,<3", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "e12ca9c1922c54fa1c8d3b745053758d", + "name": "py-mxnet", + "sha256": "5a2b850d3ae11e743fd08b5494077bae742576e59fe20b369ca824eaf1134945", + "size": 571575, + "subdir": "linux-64", + "timestamp": 1522953866320, + "version": "1.1.0" + }, + "py-mxnet-1.1.0-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.1.0 h47cb24f_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=3.5,<3.6.0a0", + "requests >=2.18.4,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "b580b6b1c9e8d1923e96fccde655f8d6", + "name": "py-mxnet", + "sha256": "9ef00e3d8cd64d270b01fc9d24182d85349917f421c892a1985f83e810b3e072", + "size": 571410, + "subdir": "linux-64", + "timestamp": 1522953780746, + "version": "1.1.0" + }, + "py-mxnet-1.1.0-py36_nomklhf484d3e_0.conda": { + "build": "py36_nomklhf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.1.0 nomklh028b6bb_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3", + "blas * openblas" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "81601ed1d1daafa7bb629ca20ddf9d4e", + "name": "py-mxnet", + "sha256": "0657086a5aaac01c27afea9b1a996308fc36750afb69d44eea81b6b7bf5c6ccd", + "size": 567843, + "subdir": "linux-64", + "timestamp": 1522954169169, + "version": "1.1.0" + }, + "py-mxnet-1.1.0-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.1.0 h47cb24f_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.13.3", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "1db6b3a83993c6575cdfb388a412437e", + "name": "py-mxnet", + "sha256": "41ad5afa113b8d3fb6b32b343a7ae46b955cdda6019703205ec5bb860b238c54", + "size": 575658, + "subdir": "linux-64", + "timestamp": 1522953958863, + "version": "1.1.0" + }, + "py-mxnet-1.2.1-py27h6c82189_0.conda": { + "build": "py27h6c82189_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.2.1.*", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.15.0", + "python >=2.7,<2.8.0a0", + "requests >=2.18.4,<2.19.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "292a81aa00db033e4b9e45e2a3c712ee", + "name": "py-mxnet", + "sha256": "9ced2a30ff454b31fa0052ff70e8ad7ab3d48ee3aa0c3fef05c9bed48094933f", + "size": 627084, + "subdir": "linux-64", + "timestamp": 1533367722763, + "version": "1.2.1" + }, + "py-mxnet-1.2.1-py35h6c82189_0.conda": { + "build": "py35h6c82189_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.2.1.*", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.15.0", + "python >=3.5,<3.6.0a0", + "requests >=2.18.4,<2.19.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "df1e890321c867301f79ef63814d529a", + "name": "py-mxnet", + "sha256": "f01db710fda08f0f9be6885ec550ff7e811494cbd79d655bd4a6abe45e4b5784", + "size": 640628, + "subdir": "linux-64", + "timestamp": 1533368042029, + "version": "1.2.1" + }, + "py-mxnet-1.2.1-py36h6c82189_0.conda": { + "build": "py36h6c82189_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libmxnet 1.2.1.*", + "libstdcxx-ng >=7.2.0", + "numpy >=1.8.2,<=1.15.0", + "python >=3.6,<3.7.0a0", + "requests >=2.18.4,<2.19.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "b9528464ff1c4c139b9b4507b9332e3d", + "name": "py-mxnet", + "sha256": "c0a3e880521c1109388b122be96fb5d5d8714bc73b3be35261a7fd1f45965c7f", + "size": 635077, + "subdir": "linux-64", + "timestamp": 1533368181477, + "version": "1.2.1" + }, + "py-mxnet-1.5.0-py27hc738527_0.conda": { + "build": "py27hc738527_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libmxnet 1.5.0.*", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.0,<=2.0.0", + "python >=2.7,<2.8.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "0ca1b75119309b11ba68b40e451546f8", + "name": "py-mxnet", + "sha256": "d41a45167ba840c549091495929d034e6acd708da90d6710f943b1847f813562", + "size": 894597, + "subdir": "linux-64", + "timestamp": 1564770063957, + "version": "1.5.0" + }, + "py-mxnet-1.5.0-py310h72e8b00_0.conda": { + "build": "py310h72e8b00_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=9.3.0", + "libmxnet 1.5.0.*", + "libstdcxx-ng >=9.3.0", + "numpy >=1.16.0,<=2.0.0", + "python >=3.10,<3.11.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "78cd70c9374992d3fcc706cd4a51900a", + "name": "py-mxnet", + "sha256": "657a2bb21e0ed081e8fe454dc41fcd456b7833e4d0b1a4686e0a096cd19faa39", + "size": 1244360, + "subdir": "linux-64", + "timestamp": 1640822283950, + "version": "1.5.0" + }, + "py-mxnet-1.5.0-py36hc738527_0.conda": { + "build": "py36hc738527_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libmxnet 1.5.0.*", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.0,<=2.0.0", + "python >=3.6,<3.7.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "c21ee1a292bfb72fedd90e71d45ad762", + "name": "py-mxnet", + "sha256": "db65766fa2c5b70ad30c10a1565a10020156c9785fbb43c3fb5b013a41bd149f", + "size": 920846, + "subdir": "linux-64", + "timestamp": 1564770123849, + "version": "1.5.0" + }, + "py-mxnet-1.5.0-py37hc738527_0.conda": { + "build": "py37hc738527_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libmxnet 1.5.0.*", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.0,<=2.0.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "ee6076bb99b357cf1c3f79de769a606a", + "name": "py-mxnet", + "sha256": "2420ecaffe0deefdf2c51e08c2adec3729920577f5fae6ae264edb0ad094f565", + "size": 920144, + "subdir": "linux-64", + "timestamp": 1564770024855, + "version": "1.5.0" + }, + "py-mxnet-1.5.0-py37hf6b7f80_0.conda": { + "build": "py37hf6b7f80_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmxnet 1.5.0.*", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.0,<=2.0.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "65c372bd829d6afa15383fc2e2736527", + "name": "py-mxnet", + "sha256": "81291bd03517e8f2386f43f4f864523a8b2ca520a7e539c1745e7a3f3e0fa57d", + "size": 902192, + "subdir": "linux-64", + "timestamp": 1633671754550, + "version": "1.5.0" + }, + "py-mxnet-1.5.0-py38hf6b7f80_0.conda": { + "build": "py38hf6b7f80_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmxnet 1.5.0.*", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "c0f61e43a757e0ddff16daa1cd07cc23", + "name": "py-mxnet", + "sha256": "4f5bc6c8c62842063cd7de647096298ce862362868d452973e559c2023c1b934", + "size": 920246, + "subdir": "linux-64", + "timestamp": 1633682563997, + "version": "1.5.0" + }, + "py-mxnet-1.5.0-py39hf6b7f80_0.conda": { + "build": "py39hf6b7f80_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libmxnet 1.5.0.*", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.0,<=2.0.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "9b791884fba7f0d9348b7df4a2f110e2", + "name": "py-mxnet", + "sha256": "072a8feb1e4172ea1ab341ee7d09d36d717b835472bb5d6e37d60a42cf52f95c", + "size": 901587, + "subdir": "linux-64", + "timestamp": 1633682554818, + "version": "1.5.0" + }, + "py-mxnet-1.5.1-py310h9bc9155_0.conda": { + "build": "py310h9bc9155_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libmxnet 1.5.1 openblas_h8848447_0", + "libstdcxx-ng >=11.2.0", + "numpy >1.16.0,<=2.0.0", + "python >=3.10,<3.11.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "7b0c83895ff3735e00a04282f8ce2446", + "name": "py-mxnet", + "sha256": "b988ffff60b9575f6032e66e812f9cc6789b477b12b0b8a664018815a899248c", + "size": 910862, + "subdir": "linux-64", + "timestamp": 1665586706822, + "version": "1.5.1" + }, + "py-mxnet-1.5.1-py311h9bc9155_0.conda": { + "build": "py311h9bc9155_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libmxnet 1.5.1 openblas_h8848447_0", + "libstdcxx-ng >=11.2.0", + "numpy >1.16.0,<=2.0.0", + "python >=3.11,<3.12.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "af72786f3e636f10efd2be049d7bda9a", + "name": "py-mxnet", + "sha256": "d0ec5d3720e5d4364ea6bc04cbb36eaf989e6bc3df9cc25d25981ca817a8130d", + "size": 1171650, + "subdir": "linux-64", + "timestamp": 1676859809739, + "version": "1.5.1" + }, + "py-mxnet-1.5.1-py37h9bc9155_0.conda": { + "build": "py37h9bc9155_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libmxnet 1.5.1 openblas_h8848447_0", + "libstdcxx-ng >=11.2.0", + "numpy >1.16.0,<=2.0.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "b0902ba036043f3935fd56ea3684e42e", + "name": "py-mxnet", + "sha256": "83e9125fcc9f1531d91f42eb495ca4c48c1402cc0e488f87ccf598952311960f", + "size": 903084, + "subdir": "linux-64", + "timestamp": 1665586765912, + "version": "1.5.1" + }, + "py-mxnet-1.5.1-py38h9bc9155_0.conda": { + "build": "py38h9bc9155_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libmxnet 1.5.1 openblas_h8848447_0", + "libstdcxx-ng >=11.2.0", + "numpy >1.16.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "c258715abcd2f96e8f8509bf7de9729b", + "name": "py-mxnet", + "sha256": "efb670a20e0bb883b6413b556cf587cab47d36cd8dc21f13c4202d6ff744827f", + "size": 910475, + "subdir": "linux-64", + "timestamp": 1665586736472, + "version": "1.5.1" + }, + "py-mxnet-1.5.1-py39h9bc9155_0.conda": { + "build": "py39h9bc9155_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libmxnet 1.5.1 openblas_h8848447_0", + "libstdcxx-ng >=11.2.0", + "numpy >1.16.0,<=2.0.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "33d7801e2ab22a488913c1b660c1efb5", + "name": "py-mxnet", + "sha256": "3004673058b24230ed58833a26bd8513a8cd9207fe90ccaa12291505d000e096", + "size": 907277, + "subdir": "linux-64", + "timestamp": 1665586795485, + "version": "1.5.1" + }, + "py-mxnet-1.9.1-py310h04ad4eb_0.conda": { + "build": "py310h04ad4eb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libmxnet 1.9.1 openblas_h8848447_0", + "libstdcxx-ng >=11.2.0", + "numpy >1.16.0,<=2.0.0", + "python >=3.10,<3.11.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "cb1dd03456b8074e75a9f9bc1270c15e", + "name": "py-mxnet", + "sha256": "90ddc7d92bd47b95550eaa2dff8826e0693c5023037b29968030ffcdbd66151d", + "size": 1288513, + "subdir": "linux-64", + "timestamp": 1666597041573, + "version": "1.9.1" + }, + "py-mxnet-1.9.1-py37h4f77008_0.conda": { + "build": "py37h4f77008_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libmxnet 1.9.1 openblas_h8848447_0", + "libstdcxx-ng >=11.2.0", + "numpy >1.16.0,<=2.0.0", + "python >=3.7,<3.8.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "8651f34e006d30957f12c03f63c22419", + "name": "py-mxnet", + "sha256": "86d12e5e921b540887552208e902761bef22c0465bf4274838edd32ca5aa5516", + "size": 1274584, + "subdir": "linux-64", + "timestamp": 1666596971096, + "version": "1.9.1" + }, + "py-mxnet-1.9.1-py38h4f77008_0.conda": { + "build": "py38h4f77008_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libmxnet 1.9.1 openblas_h8848447_0", + "libstdcxx-ng >=11.2.0", + "numpy >1.16.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "9bd03a85e61c6e0e3b6590e96250fa93", + "name": "py-mxnet", + "sha256": "5aebb7ba2fa47d10f59f7c6d9e649f0268385522772666bcfa816a5dc61f9a82", + "size": 1285542, + "subdir": "linux-64", + "timestamp": 1666597077129, + "version": "1.9.1" + }, + "py-mxnet-1.9.1-py39h4f77008_0.conda": { + "build": "py39h4f77008_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libmxnet 1.9.1 openblas_h8848447_0", + "libstdcxx-ng >=11.2.0", + "numpy >1.16.0,<=2.0.0", + "python >=3.9,<3.10.0a0", + "requests >=2.20.0,<3" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "0f25ad1bad7075d794383be772bc7117", + "name": "py-mxnet", + "sha256": "e8519e6941cc0a0b29060a3ecd04598af3c2b7a2bb3e4e3af802cb1a511cd017", + "size": 1281571, + "subdir": "linux-64", + "timestamp": 1666597006232, + "version": "1.9.1" + }, + "py-opencv-3.4.1-py27h0676e08_1.conda": { + "build": "py27h0676e08_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 h1a3b859_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5ab4093b7845e70b71004e9b765fe5d2", + "name": "py-opencv", + "sha256": "badbbf260d55e6d3fb14a2d158d352123f6695225f5911d7d8ed6cbf9f2cc757", + "size": 1036366, + "subdir": "linux-64", + "timestamp": 1527005759652, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py27h8fa1ad8_3.conda": { + "build": "py27h8fa1ad8_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 h8fa1ad8_3", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "856c143187ac298e32adbad29fafef82", + "name": "py-opencv", + "sha256": "e4006e43d6bba6a805948f093d1ed47960396efb270f13ab3ed20b023f3a7da2", + "size": 1037605, + "subdir": "linux-64", + "timestamp": 1530790886299, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py27he6673a0_3.conda": { + "build": "py27he6673a0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 he6673a0_3", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "daa3b067fdad7814470f9264130a4b64", + "name": "py-opencv", + "sha256": "5f72a6b86257c4c6fe5ddb925f144bd7bcdb7a635491b867e232c755a78ff57f", + "size": 1037012, + "subdir": "linux-64", + "timestamp": 1530792554092, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py27hf78e8e8_1.conda": { + "build": "py27hf78e8e8_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 h62359dd_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cc887d926d7fba9cf09dd9fb9dfd9971", + "name": "py-opencv", + "sha256": "7f6c53b363ae8946dfcccdfbdba2cd74b414930c1ef6dcf75aa379f2fc50003b", + "size": 1036519, + "subdir": "linux-64", + "timestamp": 1527006680556, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py35h0676e08_1.conda": { + "build": "py35h0676e08_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 h1a3b859_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "313be1735f91e26771bbabadd361614f", + "name": "py-opencv", + "sha256": "ed9babbdb1d16e1fef918ace6342c29a121aaa61eb24149695998eb5fe39417f", + "size": 1036340, + "subdir": "linux-64", + "timestamp": 1527005926299, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py35hf78e8e8_1.conda": { + "build": "py35hf78e8e8_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 h62359dd_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c0095a1d29369a858a7c49076dfb64f4", + "name": "py-opencv", + "sha256": "f3cb15d14ab804d1b28f7957e52354829b33d057ccf1d5245d1ae99fcf9e1eed", + "size": 1036313, + "subdir": "linux-64", + "timestamp": 1527006842927, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py36h0676e08_1.conda": { + "build": "py36h0676e08_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 h1a3b859_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ee1a900519ccf56cd737e4c4db73e27f", + "name": "py-opencv", + "sha256": "a96d2b9af123ecd626d00e26f57bec86a554df09933e9a22c3a5f8d042cb4d03", + "size": 1036055, + "subdir": "linux-64", + "timestamp": 1527005958807, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py36h8fa1ad8_3.conda": { + "build": "py36h8fa1ad8_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 h8fa1ad8_3", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1d7eb6aaabee9dd4a7f690c74f8794c3", + "name": "py-opencv", + "sha256": "87c2905caa0573ab982b093a0d3636b3acee3ecbb442ffac9204b1f8f6a133ff", + "size": 1037059, + "subdir": "linux-64", + "timestamp": 1530791034625, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py36he6673a0_3.conda": { + "build": "py36he6673a0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 he6673a0_3", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "edae1e295f00af75a0c0de1087b92fbe", + "name": "py-opencv", + "sha256": "97b39d6f3f5ecb926a92fbb563464b0722cacfc8905c8595c4d5a5b86ab3c6e0", + "size": 1037998, + "subdir": "linux-64", + "timestamp": 1530792701758, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py36hf78e8e8_1.conda": { + "build": "py36hf78e8e8_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 h62359dd_1", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "11f08eb0f81025c026b11b532406f8ee", + "name": "py-opencv", + "sha256": "c9662d5fac24295b2c9364e826675a51f7c1d5da9d90337a674a839269cd403a", + "size": 1036268, + "subdir": "linux-64", + "timestamp": 1527006875624, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py37h8fa1ad8_3.conda": { + "build": "py37h8fa1ad8_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 h8fa1ad8_3", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ce1ddcdbc2a6324ad7b1ae35bcbbce92", + "name": "py-opencv", + "sha256": "6b62ce9b0b7290128a2ac6320f22d4658b46e0adb611d56c312333ea15072fb4", + "size": 1037068, + "subdir": "linux-64", + "timestamp": 1530791065886, + "version": "3.4.1" + }, + "py-opencv-3.4.1-py37he6673a0_3.conda": { + "build": "py37he6673a0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.1 he6673a0_3", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7f2954a54a81c67b1a65ddbd25434851", + "name": "py-opencv", + "sha256": "1311d0fd989338e9ca5387c1deb3dd53f7e4f2d8b11449a580da16d68ffe39c4", + "size": 1037055, + "subdir": "linux-64", + "timestamp": 1530792734396, + "version": "3.4.1" + }, + "py-opencv-3.4.2-py27h765d7f9_1.conda": { + "build": "py27h765d7f9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libopencv 3.4.2 h765d7f9_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d03ec5a1eaa32652dae258d0c1a3bf31", + "name": "py-opencv", + "sha256": "b583613313fac790ff0627bb82d67dd1c9595d882cd71aacbc21db9d3381652c", + "size": 1076617, + "subdir": "linux-64", + "timestamp": 1535561441982, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py27h8fa1ad8_0.conda": { + "build": "py27h8fa1ad8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.2 h8fa1ad8_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "bf946ca195addb085a088f0f1ee2116d", + "name": "py-opencv", + "sha256": "be4445d580c457f4fc9400bbe590cc47e4bc1edf80cd3e07a29c52fccf70ab0d", + "size": 1064779, + "subdir": "linux-64", + "timestamp": 1533642253333, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py27hb342d67_1.conda": { + "build": "py27hb342d67_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libopencv 3.4.2 hb342d67_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "aa1301d4a66e361718fcd3da81da0c9f", + "name": "py-opencv", + "sha256": "5e77eb68c4b9bae2c9bc761b4bf905f1cb2386c3597b920a65681687619b7f29", + "size": 1075994, + "subdir": "linux-64", + "timestamp": 1535561687028, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py27he6673a0_0.conda": { + "build": "py27he6673a0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.2 he6673a0_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "fb10ca01ff248135f9ef776bc0263a74", + "name": "py-opencv", + "sha256": "3c2856212789d92d6155317a1401c974db5ca9cebb27f7e5fe370a52b08f6df2", + "size": 1064723, + "subdir": "linux-64", + "timestamp": 1533643809922, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py35h765d7f9_1.conda": { + "build": "py35h765d7f9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libopencv 3.4.2 h765d7f9_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b9ad618c5446bf699e4fbd9f6c5b5319", + "name": "py-opencv", + "sha256": "9a7f62662ca8e983ad18cc472f58bf6d304cf421cfdec7c7aea174f59a93a0c3", + "size": 1076779, + "subdir": "linux-64", + "timestamp": 1535561687060, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py35h8fa1ad8_0.conda": { + "build": "py35h8fa1ad8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.2 h8fa1ad8_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b25bc2bcecc5cd4b72d04c83d052ece9", + "name": "py-opencv", + "sha256": "34736fec696add767fdf490d4778ea3844ad15cdc695273d446dc339faa54cf5", + "size": 1065303, + "subdir": "linux-64", + "timestamp": 1533642412096, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py35hb342d67_1.conda": { + "build": "py35hb342d67_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libopencv 3.4.2 hb342d67_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f8edcb89054765a615aaec9a21a7e605", + "name": "py-opencv", + "sha256": "4ea20fecc89f538432b0d0145b0369538590d7ce8beebad825451f2f84b68237", + "size": 1076787, + "subdir": "linux-64", + "timestamp": 1535561590213, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py35he6673a0_0.conda": { + "build": "py35he6673a0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.2 he6673a0_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c3fe6c1669787f8fc4fbf0b5e4474587", + "name": "py-opencv", + "sha256": "126b6b2f832f9de8c41dbcf8de401b9459d7e869ed76270df8505d7d06595fb6", + "size": 1065544, + "subdir": "linux-64", + "timestamp": 1533643968899, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py36h765d7f9_1.conda": { + "build": "py36h765d7f9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libopencv 3.4.2 h765d7f9_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "97ac2c668729ffd7f93d3dbcc5bcb941", + "name": "py-opencv", + "sha256": "7eaf00cf0e7a71cbbbc7fc5727ea08794f3105b30d1d2932fa2891d9e081f7dd", + "size": 1076839, + "subdir": "linux-64", + "timestamp": 1535561875879, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py36h8fa1ad8_0.conda": { + "build": "py36h8fa1ad8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.2 h8fa1ad8_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0dc8e5ee0022ba4b729f9a56bef08e48", + "name": "py-opencv", + "sha256": "beec6fd23bf2ff3e0d5ec796527b18dd1a28b1ab902dd61df2caf0bfe4958df1", + "size": 1065584, + "subdir": "linux-64", + "timestamp": 1533642731575, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py36hb342d67_1.conda": { + "build": "py36hb342d67_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libopencv 3.4.2 hb342d67_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8616407e2d4242d740a656dab2fbc189", + "name": "py-opencv", + "sha256": "7667483e790d29d7ddcf098eeb46c5afcaead7cfdd1789f8e08d791b92126a5f", + "size": 1076784, + "subdir": "linux-64", + "timestamp": 1535561875789, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py36he6673a0_0.conda": { + "build": "py36he6673a0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.2 he6673a0_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dde872c883ff8aa6e78a755d67004c0f", + "name": "py-opencv", + "sha256": "a1d3bfb35ee62b3015a9c9024826791c2d903ac719a3ac59b24c3fae5967efe9", + "size": 1065528, + "subdir": "linux-64", + "timestamp": 1533644286844, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py37h765d7f9_1.conda": { + "build": "py37h765d7f9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libopencv 3.4.2 h765d7f9_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1afe75d8026dac1f968828c71684e396", + "name": "py-opencv", + "sha256": "202a014cd191541f4c532d594a03e42f5642c7760009344496f62ddcc2aaee22", + "size": 1076773, + "subdir": "linux-64", + "timestamp": 1535562094538, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py37h8fa1ad8_0.conda": { + "build": "py37h8fa1ad8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.2 h8fa1ad8_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f0dfe24c5381b7e17826d5182099dc74", + "name": "py-opencv", + "sha256": "b9069c1f51019be2df06cb3ae0ed232a3c56f3ee5e0e6115e90b6f417dbdf764", + "size": 1065389, + "subdir": "linux-64", + "timestamp": 1533642571120, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py37hb342d67_1.conda": { + "build": "py37hb342d67_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libopencv 3.4.2 hb342d67_1", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4ad275950c862ee05446b427f28c4dba", + "name": "py-opencv", + "sha256": "798c59e45d5527e405c5331b996f0d10faea34ee930422d00fca3d81d9ddcc63", + "size": 1076794, + "subdir": "linux-64", + "timestamp": 1535562103938, + "version": "3.4.2" + }, + "py-opencv-3.4.2-py37he6673a0_0.conda": { + "build": "py37he6673a0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopencv 3.4.2 he6673a0_0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9734588e65a254867c55943b17f71998", + "name": "py-opencv", + "sha256": "201523c29b6d8490c1c026b158e226e41ccc176fba78596f809b8677eda3acc0", + "size": 1065606, + "subdir": "linux-64", + "timestamp": 1533644127838, + "version": "3.4.2" + }, + "py-opencv-4.5.4-h06a4308_2.conda": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [ + "opencv >=4.5.4,<5.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5a0b74c30557505248bd9b3feaa3b434", + "name": "py-opencv", + "sha256": "182f0d869701867bbe27fbb1ae095faabebc2f2ddcbe7d0efb20aca39b996a69", + "size": 29630, + "subdir": "linux-64", + "timestamp": 1648833862634, + "version": "4.5.4" + }, + "py-opencv-4.5.4-h06a4308_3.conda": { + "build": "h06a4308_3", + "build_number": 3, + "depends": [ + "opencv 4.5.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5cece3b99ee0fee09e3e3795507b31cc", + "name": "py-opencv", + "sha256": "580b4c402d1367211f4ccb382af419b9706be1ef5e1621a627f3a134251c6fae", + "size": 29788, + "subdir": "linux-64", + "timestamp": 1648873511303, + "version": "4.5.4" + }, + "py-opencv-4.5.5-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "914796681d4a4f7d1254ca206c40e361", + "name": "py-opencv", + "sha256": "b12faba0a11b5b1fa62ed168ca21c6f5f0913625f1b53c8592fd938c8046da38", + "size": 10373, + "subdir": "linux-64", + "timestamp": 1652956711521, + "version": "4.5.5" + }, + "py-opencv-4.5.5-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4f270454e75b4fecae8bbe93b7a2d90a", + "name": "py-opencv", + "sha256": "a46d299b60e2d564feff2b716909fae95bba1b6266abf6f63b0d114611415a20", + "size": 10486, + "subdir": "linux-64", + "timestamp": 1655908341712, + "version": "4.5.5" + }, + "py-opencv-4.5.5-h06a4308_2.conda": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "caf4d573d21197d6937e83170811eb3a", + "name": "py-opencv", + "sha256": "48ee7b7d7d94322d040e04446d022c84c10c73cd8754696d1956c377b7cb074c", + "size": 10564, + "subdir": "linux-64", + "timestamp": 1656000414609, + "version": "4.5.5" + }, + "py-opencv-4.5.5-h06a4308_3.conda": { + "build": "h06a4308_3", + "build_number": 3, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "30928a5803f8973868bf6a23ad300ba2", + "name": "py-opencv", + "sha256": "00018db3592385534e9dae254b4767193f320bea9cd3d5814f0cca61f12a8673", + "size": 14434, + "subdir": "linux-64", + "timestamp": 1656607349016, + "version": "4.5.5" + }, + "py-opencv-4.5.5-h06a4308_4.conda": { + "build": "h06a4308_4", + "build_number": 4, + "depends": [ + "opencv 4.5.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "75274c178eed233dcce3472dc907e948", + "name": "py-opencv", + "sha256": "269f768846ae721f16035ff8a5a943bc2d21f4624802590c8ff5e22c245f733a", + "size": 14505, + "subdir": "linux-64", + "timestamp": 1659975133503, + "version": "4.5.5" + }, + "py-opencv-4.6.0-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "opencv 4.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9115052d0a046a4d91a85331774c53c3", + "name": "py-opencv", + "sha256": "bf6a101130d80f005b788548b8d999eebca5aeabe6316d39f8e2bbd771a4c71e", + "size": 12966, + "subdir": "linux-64", + "timestamp": 1663874042899, + "version": "4.6.0" + }, + "py-opencv-4.6.0-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [ + "opencv 4.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c2518b6f0d7640fe4f2f7a4ab08037c5", + "name": "py-opencv", + "sha256": "cfa2c05d142bafad8335bdcd429c8c9f237863cfb0022ba7f2c8e2dc27dd653f", + "size": 13000, + "subdir": "linux-64", + "timestamp": 1664372699808, + "version": "4.6.0" + }, + "py-opencv-4.6.0-h06a4308_2.conda": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [ + "opencv 4.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "57e59409e85b3249c4bb3449989247b5", + "name": "py-opencv", + "sha256": "b865a72732ac9f419bd3e1ab15a7f9d27e48ce5fb73df0f5f1d16259b4aec20c", + "size": 13003, + "subdir": "linux-64", + "timestamp": 1664550122536, + "version": "4.6.0" + }, + "py-opencv-4.6.0-h06a4308_3.conda": { + "build": "h06a4308_3", + "build_number": 3, + "depends": [ + "opencv 4.6.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eedd5b9ad9a5dc4cd398fe40df177cce", + "name": "py-opencv", + "sha256": "c7b685c4a21b83262a0d3149bb64d1ff389fbe42b0aac1ce69d93147c3313ddd", + "size": 13753, + "subdir": "linux-64", + "timestamp": 1676453528679, + "version": "4.6.0" + }, + "py-spy-0.3.11-hadfb35e_1.conda": { + "build": "hadfb35e_1", + "build_number": 1, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "libgcc-ng >=7.5.0", + "libunwind >=1.5.0,<2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc5ab1c37abfd4418212f19d9de24148", + "name": "py-spy", + "sha256": "93d51cda4024bc5e9d6cb0c8611effa5055ff706e43d7f0480b29c4cd12f64d8", + "size": 1361664, + "subdir": "linux-64", + "timestamp": 1640799872281, + "version": "0.3.11" + }, + "py-spy-0.3.14-h52d8a92_0.conda": { + "build": "h52d8a92_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "libgcc-ng >=11.2.0", + "libunwind >=1.5.0,<2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe1e3c7829fbfc189f13f8d78bb06917", + "name": "py-spy", + "sha256": "35aac5147222f29838bd7ab1eee01b61eac6679b08de344b8213fd06048cbb01", + "size": 1506768, + "subdir": "linux-64", + "timestamp": 1677738359658, + "version": "0.3.14" + }, + "py-xgboost-0.7-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxgboost 0.7 hf484d3e_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "0d682e8d6610b4ac0baaaec023e6be20", + "name": "py-xgboost", + "sha256": "cc9f49db65b04f8f3bcf34db48e4fce3785b40ff9e303237d057f61dba99a56d", + "size": 1322279, + "subdir": "linux-64", + "timestamp": 1521481044382, + "version": "0.7" + }, + "py-xgboost-0.7-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxgboost 0.7 hf484d3e_0", + "numpy", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy" + ], + "md5": "eb5d00ac0ccbfb9d317391a11ac6e6bf", + "name": "py-xgboost", + "sha256": "9bddae07b5823a4e7db2cc284b8b246ab418c3f23e72ff3edd169982874ca30c", + "size": 1318646, + "subdir": "linux-64", + "timestamp": 1521481006463, + "version": "0.7" + }, + "py-xgboost-0.7-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxgboost 0.7 hf484d3e_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "b010a0b61355d02c29413bf30cf6dd59", + "name": "py-xgboost", + "sha256": "f15a7ed0288b30cc1e7a1f614bea94397a3513a30fd36793b629cceb680d529e", + "size": 1317074, + "subdir": "linux-64", + "timestamp": 1521481025571, + "version": "0.7" + }, + "py-xgboost-0.71-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxgboost 0.71 hf484d3e_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "e13060a8727d004f43b432c5e6edf678", + "name": "py-xgboost", + "sha256": "3efbbb5f1dda908245adf0ca5b9786177ca72b677a5485b2ba41f17da318d3b8", + "size": 1387320, + "subdir": "linux-64", + "timestamp": 1525821737512, + "version": "0.71" + }, + "py-xgboost-0.71-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxgboost 0.71 hf484d3e_0", + "numpy", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy" + ], + "md5": "e00efc387b73ec0a1534a022ba8b8ae0", + "name": "py-xgboost", + "sha256": "8ea560979145c3f692aff416d16777450d49225c7ad33ae08747effc80fe53e8", + "size": 1391696, + "subdir": "linux-64", + "timestamp": 1525821761246, + "version": "0.71" + }, + "py-xgboost-0.71-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxgboost 0.71 hf484d3e_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "8544f6720b9815600643bc20e3810979", + "name": "py-xgboost", + "sha256": "055c491bc97cccf0d341860f4c240ab89b96a677102653bbe571d3bf3483934f", + "size": 1388651, + "subdir": "linux-64", + "timestamp": 1525821783911, + "version": "0.71" + }, + "py-xgboost-0.72-py27h83be7fe_0.conda": { + "build": "py27h83be7fe_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 8.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.72 h83be7fe_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "b84057085c374fa671e97b6fda872674", + "name": "py-xgboost", + "sha256": "5c57ac9b9cfc2e4c331dd896619ba57ed499d8a960f3b7ed12d3b993872ca9d9", + "size": 3086487, + "subdir": "linux-64", + "timestamp": 1530222959531, + "version": "0.72" + }, + "py-xgboost-0.72-py27h87a4715_0.conda": { + "build": "py27h87a4715_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.72 h87a4715_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "0f8123da5555d6f12aacd3ae9373c258", + "name": "py-xgboost", + "sha256": "d2219eb94c6021b84a49854bf7d138a94835a99961755b4dde8c64d2299c7bbc", + "size": 3312032, + "subdir": "linux-64", + "timestamp": 1530223654550, + "version": "0.72" + }, + "py-xgboost-0.72-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxgboost 0.72 hf484d3e_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "725f7139181291c4a0b2bc899294ae83", + "name": "py-xgboost", + "sha256": "99c178ffd1b446d38130400402a82ea137b95f7467b6aaaabf74c9a37ecb414a", + "size": 1470520, + "subdir": "linux-64", + "timestamp": 1530218280279, + "version": "0.72" + }, + "py-xgboost-0.72-py35h83be7fe_0.conda": { + "build": "py35h83be7fe_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 8.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.72 h83be7fe_0", + "numpy", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy" + ], + "md5": "9679b55b9b33a757c69d26cf958868e7", + "name": "py-xgboost", + "sha256": "4271bc872e59b07c928cd1a8da6f0537bfdd214529aba882cee5a7e878041801", + "size": 3086360, + "subdir": "linux-64", + "timestamp": 1530223003800, + "version": "0.72" + }, + "py-xgboost-0.72-py35h87a4715_0.conda": { + "build": "py35h87a4715_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.72 h87a4715_0", + "numpy", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy" + ], + "md5": "f95272820849ba048e883b8a0438d8cd", + "name": "py-xgboost", + "sha256": "3b951f5c88bf3b1e61219eeedd4e2999894f5cfd16db27aa7e04aa75f95846bf", + "size": 3308533, + "subdir": "linux-64", + "timestamp": 1530223633126, + "version": "0.72" + }, + "py-xgboost-0.72-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxgboost 0.72 hf484d3e_0", + "numpy", + "python >=3.5,<3.6.0a0", + "scikit-learn", + "scipy" + ], + "md5": "12882bad7b165cd93aa2ef56e317825f", + "name": "py-xgboost", + "sha256": "c435227d6c657634daba498bb28442c2f0f3e623ab25ecd507f7b6f2e900a55d", + "size": 1471380, + "subdir": "linux-64", + "timestamp": 1530218305177, + "version": "0.72" + }, + "py-xgboost-0.72-py36h83be7fe_0.conda": { + "build": "py36h83be7fe_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 8.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.72 h83be7fe_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "fd87c24eee2cf95fe9153a7c1f0151b9", + "name": "py-xgboost", + "sha256": "d5dd6efa04cc4fcb75b9679b56cc8507c66768d2d387b5c98c8493c13d027c97", + "size": 3082468, + "subdir": "linux-64", + "timestamp": 1530222982082, + "version": "0.72" + }, + "py-xgboost-0.72-py36h87a4715_0.conda": { + "build": "py36h87a4715_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.72 h87a4715_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "db7e92a1bc1f5470018be9d29bc68cab", + "name": "py-xgboost", + "sha256": "de13af61a7e85d9e8c0623cf709dada9c5c51cf4da5ba71a1bb30ed35efad783", + "size": 3307767, + "subdir": "linux-64", + "timestamp": 1530223676433, + "version": "0.72" + }, + "py-xgboost-0.72-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "libxgboost 0.72 hf484d3e_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "3614daa54f620a5d5b86c3c0f48166e8", + "name": "py-xgboost", + "sha256": "4f531641bd5d475b695e33e34b4afcda92f4756ab443829fc04e5f12a3d235aa", + "size": 1470089, + "subdir": "linux-64", + "timestamp": 1530218327979, + "version": "0.72" + }, + "py-xgboost-0.80-py27h51060c3_0.conda": { + "build": "py27h51060c3_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 8.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.80 h51060c3_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "4f2f2cd4512699b65542a5a7faceb7ba", + "name": "py-xgboost", + "sha256": "f67197ecb16b47516c71b209defc68e156171f8cb6e88c82ecc7bb06bb24c57b", + "size": 4057349, + "subdir": "linux-64", + "timestamp": 1541468890399, + "version": "0.80" + }, + "py-xgboost-0.80-py27h6cbba54_0.conda": { + "build": "py27h6cbba54_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 9.2.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.80 h6cbba54_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "bc4653cc5012a0ba73a669d816c122aa", + "name": "py-xgboost", + "sha256": "297fb6ec994e76be84c12eb5d08797bf7ab810db5ec05deb0b11c0417b9676fa", + "size": 4444716, + "subdir": "linux-64", + "timestamp": 1541450174629, + "version": "0.80" + }, + "py-xgboost-0.80-py27h6edc907_0.conda": { + "build": "py27h6edc907_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.80 h6edc907_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "64e86d2eed11574a55193d3a918614de", + "name": "py-xgboost", + "sha256": "45f37ad2d3e33cb9f6f8d119125efa2e01be7da1e3e77619aefaa9adf2f9d42d", + "size": 4400646, + "subdir": "linux-64", + "timestamp": 1541451157424, + "version": "0.80" + }, + "py-xgboost-0.80-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.80 he6710b0_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "23b0bea2fa9ebc0dbbf231a0c56ec687", + "name": "py-xgboost", + "sha256": "0ff75d9a036a3b74f157b2fc6344f1cc8ba319dbe6d6ecc9e0e270be83f8946e", + "size": 1529261, + "subdir": "linux-64", + "timestamp": 1540835374604, + "version": "0.80" + }, + "py-xgboost-0.80-py36h51060c3_0.conda": { + "build": "py36h51060c3_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 8.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.80 h51060c3_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "c814be9bbe48158d12524755ebd6e285", + "name": "py-xgboost", + "sha256": "e858d4f6118e6d40a01b3c0290ec5b8b1c89c059d68b64d2c4c81ff404393b1b", + "size": 4056498, + "subdir": "linux-64", + "timestamp": 1541468916503, + "version": "0.80" + }, + "py-xgboost-0.80-py36h6cbba54_0.conda": { + "build": "py36h6cbba54_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 9.2.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.80 h6cbba54_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "5e8ce58f337ef20395fe14377a8fe309", + "name": "py-xgboost", + "sha256": "4136451fb8ff230c6df7dfd99aa12f550b60aca32b5b849e4c9037143805b077", + "size": 4439526, + "subdir": "linux-64", + "timestamp": 1541450122239, + "version": "0.80" + }, + "py-xgboost-0.80-py36h6edc907_0.conda": { + "build": "py36h6edc907_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.80 h6edc907_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "37e25b1088d6835b9558be11826bf496", + "name": "py-xgboost", + "sha256": "3a9e3ac539ca79086dd7342180bc86913ab0878db1e21f2b97a093970fd0260e", + "size": 4400092, + "subdir": "linux-64", + "timestamp": 1541451100572, + "version": "0.80" + }, + "py-xgboost-0.80-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.80 he6710b0_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "4d6e2bd2a761eb1996f3df2542d042ac", + "name": "py-xgboost", + "sha256": "89afdc880084b204a2ecbb82bf4a4e0e54eaae7d9336d1d84dc9222461b0d54f", + "size": 1528505, + "subdir": "linux-64", + "timestamp": 1540835348915, + "version": "0.80" + }, + "py-xgboost-0.80-py37h51060c3_0.conda": { + "build": "py37h51060c3_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 8.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.80 h51060c3_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "5d31d87a3451f29f9388f0bc6230984c", + "name": "py-xgboost", + "sha256": "fd48863bc34d58b1574bd196b1c32746d81997e27413bf5725e0d5878d0a67dc", + "size": 4057345, + "subdir": "linux-64", + "timestamp": 1541468864376, + "version": "0.80" + }, + "py-xgboost-0.80-py37h6cbba54_0.conda": { + "build": "py37h6cbba54_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 9.2.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.80 h6cbba54_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "5ca4876c5121201d844ef0207d0c9755", + "name": "py-xgboost", + "sha256": "cc1d7729b6fe9516ea2eac20c414fb7b06cbd0f76c1a48f8ef8ad9a7b6e01738", + "size": 4443279, + "subdir": "linux-64", + "timestamp": 1541450148152, + "version": "0.80" + }, + "py-xgboost-0.80-py37h6edc907_0.conda": { + "build": "py37h6edc907_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit 9.0.*", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.80 h6edc907_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "99bd90833175fa7695e6585234031c39", + "name": "py-xgboost", + "sha256": "e7dbf5b1db7e3c15b7469b65b6934a5d60f3d47794be943e4a306e62ec92e83a", + "size": 4398425, + "subdir": "linux-64", + "timestamp": 1541451129429, + "version": "0.80" + }, + "py-xgboost-0.80-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.80 he6710b0_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "41fdf1027a58ca931605648c34cf2602", + "name": "py-xgboost", + "sha256": "fc533da0de30774807cb598842898254104542f62da514015b06f0015f837c7a", + "size": 1529206, + "subdir": "linux-64", + "timestamp": 1540835400111, + "version": "0.80" + }, + "py-xgboost-0.90-py27h4d71fd4_0.conda": { + "build": "py27h4d71fd4_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 h4d71fd4_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "0181afbbacc2850be14255afddc94070", + "name": "py-xgboost", + "sha256": "900ec3041ab0341f193115394f4c40e43092cfc85dbe0a04a5e1f09c2bb86e0c", + "size": 7074009, + "subdir": "linux-64", + "timestamp": 1560802346388, + "version": "0.90" + }, + "py-xgboost-0.90-py27h688424c_0.conda": { + "build": "py27h688424c_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 h688424c_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "c72a07eab15747a7b3c5aa3bba0a7143", + "name": "py-xgboost", + "sha256": "ad0771e0610f7c704be72ed0ed067304e27da82874479c3c9d3c3622d9054388", + "size": 7373604, + "subdir": "linux-64", + "timestamp": 1560801163198, + "version": "0.90" + }, + "py-xgboost-0.90-py27h6edc907_0.conda": { + "build": "py27h6edc907_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit >=9.0,<9.1.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.90 h6edc907_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "f6c67b9a80d94115ffac44aba9673982", + "name": "py-xgboost", + "sha256": "610740a3ebb6a397e7f1280bd9c0066e3b3f74ea7fd31f91a6e4e39a009f3c55", + "size": 5855647, + "subdir": "linux-64", + "timestamp": 1560804953735, + "version": "0.90" + }, + "py-xgboost-0.90-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 he6710b0_0", + "numpy", + "python >=2.7,<2.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "a63a1c289fb3c4788aecf8f177b8653b", + "name": "py-xgboost", + "sha256": "c9cdcc4d87aca2222828415509c9277905f87669996e15a013418290b7d9b682", + "size": 1642842, + "subdir": "linux-64", + "timestamp": 1559931238194, + "version": "0.90" + }, + "py-xgboost-0.90-py310h295c915_1.conda": { + "build": "py310h295c915_1", + "build_number": 1, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libxgboost 0.90 h295c915_1", + "numpy", + "python >=3.10,<3.11.0a0", + "scikit-learn", + "scipy" + ], + "md5": "487b3ac705b82552f97419153bacd55d", + "name": "py-xgboost", + "sha256": "84f04c2ecf634a181e48d60873274032735709878bb1a861ef5464385d6659f6", + "size": 77852, + "subdir": "linux-64", + "timestamp": 1642675488455, + "version": "0.90" + }, + "py-xgboost-0.90-py36h4d71fd4_0.conda": { + "build": "py36h4d71fd4_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 h4d71fd4_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "88595f53947afde1501b36d052fa2f61", + "name": "py-xgboost", + "sha256": "220a2882d4e38e3184722941ed0e64876f110b5d58bbd946c9cd0901e3ec6995", + "size": 7074325, + "subdir": "linux-64", + "timestamp": 1560802305503, + "version": "0.90" + }, + "py-xgboost-0.90-py36h688424c_0.conda": { + "build": "py36h688424c_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 h688424c_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "ffcb5c99bbb957ff71a9ef2a0a2722f2", + "name": "py-xgboost", + "sha256": "8b74f1fc13eaed4ff756955bb9862433342ca75cdd4fe24081973c9f5d3730b6", + "size": 7368142, + "subdir": "linux-64", + "timestamp": 1560801119508, + "version": "0.90" + }, + "py-xgboost-0.90-py36h6edc907_0.conda": { + "build": "py36h6edc907_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit >=9.0,<9.1.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.90 h6edc907_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "de384ff70ef45ee8d7f3b9efaf52f2cd", + "name": "py-xgboost", + "sha256": "c892dd216f4f4992823fdcb1df3d5651736cffb504e2b4929c36ec3df23aa028", + "size": 5855733, + "subdir": "linux-64", + "timestamp": 1560804882247, + "version": "0.90" + }, + "py-xgboost-0.90-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 he6710b0_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "2b1af4c21f53d3d5cf86211dc83c8404", + "name": "py-xgboost", + "sha256": "387708d28204ed1ba01e2058a38db837e9d68f5fb0a953c2fc47350a269ee8c9", + "size": 1644100, + "subdir": "linux-64", + "timestamp": 1559931214505, + "version": "0.90" + }, + "py-xgboost-0.90-py36he6710b0_1.conda": { + "build": "py36he6710b0_1", + "build_number": 1, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 he6710b0_1", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "b3a8441b0614a944d9f344a8d073c849", + "name": "py-xgboost", + "sha256": "01a14a2bf92316b8b46bc831d3cba5f25c5cf374e782ad04550a4bebd24e961f", + "size": 75688, + "subdir": "linux-64", + "timestamp": 1572481322489, + "version": "0.90" + }, + "py-xgboost-0.90-py36hf484d3e_1.conda": { + "build": "py36hf484d3e_1", + "build_number": 1, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 0.90 hf484d3e_1", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "md5": "65a434f5e9809089c2bb8ca5d8152937", + "name": "py-xgboost", + "sha256": "802b3a5499166b6c2b1eed9300f0c0f4411977641265198a916bfbc84b7d204a", + "size": 73987, + "subdir": "linux-64", + "timestamp": 1572476427471, + "version": "0.90" + }, + "py-xgboost-0.90-py37h4d71fd4_0.conda": { + "build": "py37h4d71fd4_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 h4d71fd4_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "5f4fa3a5267acd7d5834d97bfa6cdff6", + "name": "py-xgboost", + "sha256": "0506dbef576fbbef67209e7f91900dab90d258b1c7bc05e292cfffca40481781", + "size": 7072933, + "subdir": "linux-64", + "timestamp": 1560802389367, + "version": "0.90" + }, + "py-xgboost-0.90-py37h688424c_0.conda": { + "build": "py37h688424c_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 h688424c_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "3770c18b3e46cdaac1ad647c5f494890", + "name": "py-xgboost", + "sha256": "55ad82db062ac40e1b8ed80e0ad7f233f07a6d9100730fc3de094296f59c241b", + "size": 7364580, + "subdir": "linux-64", + "timestamp": 1560801212287, + "version": "0.90" + }, + "py-xgboost-0.90-py37h6edc907_0.conda": { + "build": "py37h6edc907_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 1.0 gpu_0", + "cudatoolkit >=9.0,<9.1.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "libxgboost 0.90 h6edc907_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "f0fd0872378edbad7f2acfdf7b3b7b1e", + "name": "py-xgboost", + "sha256": "99f31f381e37e88d8ecd8957361ac1fca9367b474533965058de453b77aeb16e", + "size": 5850840, + "subdir": "linux-64", + "timestamp": 1560804918838, + "version": "0.90" + }, + "py-xgboost-0.90-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 he6710b0_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "7d1b9706259b1665604199b877e8be09", + "name": "py-xgboost", + "sha256": "ef6e5815d3fb02b7cce749d3b55cda581d04156fa9cd15d25a782d33e9c01717", + "size": 1642061, + "subdir": "linux-64", + "timestamp": 1559931263195, + "version": "0.90" + }, + "py-xgboost-0.90-py37he6710b0_1.conda": { + "build": "py37he6710b0_1", + "build_number": 1, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 he6710b0_1", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "54fedc3d131819d457aee6b56a801b79", + "name": "py-xgboost", + "sha256": "ea458d435a07ac9a2988c21cc8507f9088323ae96763bc099169c46a945fb199", + "size": 75937, + "subdir": "linux-64", + "timestamp": 1572481336959, + "version": "0.90" + }, + "py-xgboost-0.90-py37hf484d3e_1.conda": { + "build": "py37hf484d3e_1", + "build_number": 1, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 0.90 hf484d3e_1", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "md5": "bdf3157dc86b1eecdd8177216e6c138b", + "name": "py-xgboost", + "sha256": "1f21d5db7e9ba1109aafde3244e4bb0670f87c147ef87e0c0239a403218bae00", + "size": 74089, + "subdir": "linux-64", + "timestamp": 1572476594188, + "version": "0.90" + }, + "py-xgboost-1.3.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.3.3 h2531618_0", + "numpy", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "md5": "ceabdb7caf8fd880ce57d3b283770690", + "name": "py-xgboost", + "sha256": "83e3b3a952c282bbec7124f630bc7707368ca4beb9f03fef8aed46889a058bac", + "size": 139907, + "subdir": "linux-64", + "timestamp": 1619724757433, + "version": "1.3.3" + }, + "py-xgboost-1.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.3.3 h2531618_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "md5": "a3dce4c18617db1cf1cf10936a0b3bbe", + "name": "py-xgboost", + "sha256": "fe7388e20bea3441ca3ef1de5f94940287a40cebedefe5ac09ad357be86b4e5f", + "size": 140106, + "subdir": "linux-64", + "timestamp": 1619724744921, + "version": "1.3.3" + }, + "py-xgboost-1.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.3.3 h2531618_0", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "md5": "3d0810cc0c1c738169dc2fb100f85cf2", + "name": "py-xgboost", + "sha256": "257d3a936c96512018076a3005e81ef6d3d4041eeca2802ca4b3c0771c09fd8d", + "size": 141065, + "subdir": "linux-64", + "timestamp": 1619724770153, + "version": "1.3.3" + }, + "py-xgboost-1.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.3.3 h2531618_0", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "md5": "e2fb3b8c1806cfbc79a6fdd988bc3e9e", + "name": "py-xgboost", + "sha256": "1fe424c7c8ddc24e2c4e6d011a8e00ff90617591d2dc1a5796672e13b1ea44ec", + "size": 140949, + "subdir": "linux-64", + "timestamp": 1619724732387, + "version": "1.3.3" + }, + "py-xgboost-1.5.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.0 h295c915_1", + "numpy", + "python >=3.10,<3.11.0a0", + "scikit-learn", + "scipy", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "fbe95adf65bd54c222b990dcadf77a5c", + "name": "py-xgboost", + "sha256": "e496a00f0383eb072c421826b9699f3113689ac592d25a38be0a84e5b6635132", + "size": 161107, + "subdir": "linux-64", + "timestamp": 1640814318695, + "version": "1.5.0" + }, + "py-xgboost-1.5.0-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.0 h6a678d5_2", + "numpy", + "python >=3.10,<3.11.0a0", + "scikit-learn", + "scipy", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "42c2c0a23fecdd6c5d33ae1f0a60c1e8", + "name": "py-xgboost", + "sha256": "5904f56641520ce65ab8c5aeeeb3c566840848602360f477c067c8d48ee5c81b", + "size": 159311, + "subdir": "linux-64", + "timestamp": 1659549314254, + "version": "1.5.0" + }, + "py-xgboost-1.5.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.0 h295c915_1", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "1ae73ddf0546d2468a8cfeeab845d424", + "name": "py-xgboost", + "sha256": "612bd1a7633f22c3ab0b67f69f3835ca308df2c4579285ef6efd9e08ee54086d", + "size": 165952, + "subdir": "linux-64", + "timestamp": 1638290192696, + "version": "1.5.0" + }, + "py-xgboost-1.5.0-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.0 h6a678d5_2", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "75a6cd398c24503f6f459bba37445fa9", + "name": "py-xgboost", + "sha256": "5500032dd4fdea1aa2887519f0290e6537e6d34129d51b60ea1d84d7d72c8a06", + "size": 155927, + "subdir": "linux-64", + "timestamp": 1659549326958, + "version": "1.5.0" + }, + "py-xgboost-1.5.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.0 h295c915_1", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "b52ce59abcfecedcbe6177e375fd3a49", + "name": "py-xgboost", + "sha256": "6fc130a6f45e3e59b974fbd4e13a92430d84e1098f4c90df2687cc7ebd1a7c3a", + "size": 167169, + "subdir": "linux-64", + "timestamp": 1638290173733, + "version": "1.5.0" + }, + "py-xgboost-1.5.0-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.0 h6a678d5_2", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "d1573255c7fb4bcfc35239796a5a3373", + "name": "py-xgboost", + "sha256": "652e76c4bd4df6948b4e39b2f5ff59f7393edf3f47eca5b1892a3c6d88aef119", + "size": 157421, + "subdir": "linux-64", + "timestamp": 1659549287829, + "version": "1.5.0" + }, + "py-xgboost-1.5.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.0 h295c915_1", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn", + "scipy", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "6378611429a79a35fef25a4514ee31ff", + "name": "py-xgboost", + "sha256": "1909795b1991347bd4a6fb5d50112049a66573cf2e8821dbe3369295bc97cbc6", + "size": 167048, + "subdir": "linux-64", + "timestamp": 1638290183183, + "version": "1.5.0" + }, + "py-xgboost-1.5.0-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.0 h6a678d5_2", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn", + "scipy", + "setuptools" + ], + "license": "Apache-2.0", + "md5": "823f67dd57136e266b24adb5229c381e", + "name": "py-xgboost", + "sha256": "b49a9074853c25538327e1549e1fd2c060e52885a21a78534ebeb27c0b69440c", + "size": 157148, + "subdir": "linux-64", + "timestamp": 1659549301055, + "version": "1.5.0" + }, + "py-xgboost-1.5.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.1 h6a678d5_0", + "numpy", + "python >=3.10,<3.11.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c0c5160c99b16f34e27b62aab3501c5d", + "name": "py-xgboost", + "sha256": "12fe99a89efcac9015a7cc257432b252160b575cdc60632e321ba4ec4e504a17", + "size": 168262, + "subdir": "linux-64", + "timestamp": 1675119992057, + "version": "1.5.1" + }, + "py-xgboost-1.5.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.1 h6a678d5_0", + "numpy", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "963a0c646081145d4e7c974d15a4deab", + "name": "py-xgboost", + "sha256": "ac0e5288f0cbb106b2df7f5bac2e8eefa0f660e48449d95d881f1e7e73ac8a9a", + "size": 164685, + "subdir": "linux-64", + "timestamp": 1675119981595, + "version": "1.5.1" + }, + "py-xgboost-1.5.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.1 h6a678d5_0", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "43092bde275e3c38bce47b1147427cc6", + "name": "py-xgboost", + "sha256": "350b4cc83605be8a5e18485c25a561591e4873458a8b34b503ac1322a2fd924a", + "size": 166070, + "subdir": "linux-64", + "timestamp": 1675119960677, + "version": "1.5.1" + }, + "py-xgboost-1.5.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.5.1 h6a678d5_0", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9fd301d057d932d387c9a06b55ea4110", + "name": "py-xgboost", + "sha256": "2ed7a45a7e1ce48f1d539ee00212c78f8ab22c327e3510d4321cc10d079d6358", + "size": 165779, + "subdir": "linux-64", + "timestamp": 1675119971238, + "version": "1.5.1" + }, + "py-xgboost-1.7.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.7.3 h6a678d5_0", + "numpy", + "python >=3.10,<3.11.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a5435516a23e19d311aa603e2639095f", + "name": "py-xgboost", + "sha256": "1073d376349ebcd1df526367ac1283622aef5f8b6d5f70cee243fd3e97112332", + "size": 221117, + "subdir": "linux-64", + "timestamp": 1675458048077, + "version": "1.7.3" + }, + "py-xgboost-1.7.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.7.3 h6a678d5_0", + "numpy", + "python >=3.11,<3.12.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0b29c28ef923f5b992e7aba587049852", + "name": "py-xgboost", + "sha256": "af7a09e377a5f1a67d7f28666eaf322d2c30dc6d8cc228ea8e388adfedbe3f9e", + "size": 284872, + "subdir": "linux-64", + "timestamp": 1676922101332, + "version": "1.7.3" + }, + "py-xgboost-1.7.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.7.3 h6a678d5_0", + "numpy", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9cc8beca797d8f32e3e341fa6f88611f", + "name": "py-xgboost", + "sha256": "cfc108354a18ef91965d964ccb9d90f92ace3349597299ec763fdc76494c1dd6", + "size": 218168, + "subdir": "linux-64", + "timestamp": 1675458768612, + "version": "1.7.3" + }, + "py-xgboost-1.7.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "_py-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.7.3 h6a678d5_0", + "numpy", + "python >=3.9,<3.10.0a0", + "scikit-learn", + "scipy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "54c345168c3c5e29931a89caafb203cf", + "name": "py-xgboost", + "sha256": "d9a7a6f34b0ee4793e0f66bf06bd86ab4bff5b3cdabef36a251781b0bb8c5e3b", + "size": 217871, + "subdir": "linux-64", + "timestamp": 1675458551510, + "version": "1.7.3" + }, + "py-xgboost-cpu-0.72-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.72 py27hf484d3e_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "53a6df2b25bf5ff6500ea3d147c5b093", + "name": "py-xgboost-cpu", + "sha256": "dfc9fb8d1d41520cc1c99e2cab63495383cdba6e848d934895f2a89f44b8c388", + "size": 9043, + "subdir": "linux-64", + "timestamp": 1530218540635, + "version": "0.72" + }, + "py-xgboost-cpu-0.72-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.72 py35hf484d3e_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "813b256856c8ea63b31adb0e4f4bdd01", + "name": "py-xgboost-cpu", + "sha256": "cbae6db2b9ba2a29c479aba1aec95282de68d12d78b9c3f7e407dac1f011ea5a", + "size": 9051, + "subdir": "linux-64", + "timestamp": 1530218549298, + "version": "0.72" + }, + "py-xgboost-cpu-0.72-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.72 py36hf484d3e_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "5d8f49ced2bff4136b6284a5a2580a67", + "name": "py-xgboost-cpu", + "sha256": "27d7e906a3bf721f7b95ff5393770cce3aa3f1dde80028800f22a4a34b76b7e2", + "size": 9011, + "subdir": "linux-64", + "timestamp": 1530218558358, + "version": "0.72" + }, + "py-xgboost-cpu-0.80-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py27he6710b0_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "7a83745bbdddb3f9ba0249a0de3de9d5", + "name": "py-xgboost-cpu", + "sha256": "716934deaa120b1524811fa22a4250b671c69e39f6c82c03f272a8f488d2a33e", + "size": 11175, + "subdir": "linux-64", + "timestamp": 1540835620936, + "version": "0.80" + }, + "py-xgboost-cpu-0.80-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py36he6710b0_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "811df3bcfb9a44c73167ca073da1a063", + "name": "py-xgboost-cpu", + "sha256": "bc2004c951476de3848d03329ff633abe1a10bb10f3917e65ab48ade859b2079", + "size": 11213, + "subdir": "linux-64", + "timestamp": 1540835608437, + "version": "0.80" + }, + "py-xgboost-cpu-0.80-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py37he6710b0_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "ea9362f4ab55d22b5894d471a19eb010", + "name": "py-xgboost-cpu", + "sha256": "ab24ca87ab5272e97e8c1d349b80c71edf4f35bcc369a32c133f48841dda3c84", + "size": 11205, + "subdir": "linux-64", + "timestamp": 1540835634197, + "version": "0.80" + }, + "py-xgboost-cpu-0.90-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py27he6710b0_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "d186c73a386b1f5f252eaeffeea749b7", + "name": "py-xgboost-cpu", + "sha256": "c230ff39b9377bd8e4dec268f08566ef40af1c0b37860093fb8503cb39809a05", + "size": 11410, + "subdir": "linux-64", + "timestamp": 1559931474125, + "version": "0.90" + }, + "py-xgboost-cpu-0.90-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "py-xgboost 0.90 py310h295c915_1", + "python >=3.10,<3.11.0a0" + ], + "md5": "31d9b5a5edd9348975e6d005c369ad81", + "name": "py-xgboost-cpu", + "sha256": "e0e361217ba9ec2e25419cc5ea132ac780ad3075b4a271fe1a9b1d3c7eac3634", + "size": 12206, + "subdir": "linux-64", + "timestamp": 1642675566289, + "version": "0.90" + }, + "py-xgboost-cpu-0.90-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py36he6710b0_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "811f5f298a933e9e22e8104ae0a72873", + "name": "py-xgboost-cpu", + "sha256": "23be4ccb2263e3a095801e5f94c5309490ff9048be23ce4ade086c26a3e1dc64", + "size": 11402, + "subdir": "linux-64", + "timestamp": 1559931467012, + "version": "0.90" + }, + "py-xgboost-cpu-0.90-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "py-xgboost 0.90 py36he6710b0_1", + "python >=3.6,<3.7.0a0" + ], + "md5": "b40aa66300d8f10466b1c62b2269c0a3", + "name": "py-xgboost-cpu", + "sha256": "4415df001aa661c08f83da36e150f073e38ac114bc236cd5398246521a49a163", + "size": 11694, + "subdir": "linux-64", + "timestamp": 1572481791836, + "version": "0.90" + }, + "py-xgboost-cpu-0.90-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py37he6710b0_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "cb9e42ddeddfef1d1de4314781a15c7b", + "name": "py-xgboost-cpu", + "sha256": "466ecf098ad5356fa46800bc69ef6f95318ee69995f54abd86f307918ee1d70c", + "size": 11400, + "subdir": "linux-64", + "timestamp": 1559931481691, + "version": "0.90" + }, + "py-xgboost-cpu-0.90-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "py-xgboost 0.90 py37he6710b0_1", + "python >=3.7,<3.8.0a0" + ], + "md5": "5e63bd7ddb2342794fd22c3e1e09a2bd", + "name": "py-xgboost-cpu", + "sha256": "3f04e95d428f66ea926e5b844dc32a9c80ad3323ac4a453b003ddcb9899b425e", + "size": 11679, + "subdir": "linux-64", + "timestamp": 1572481799295, + "version": "0.90" + }, + "py-xgboost-cpu-1.3.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.3.3 py36h06a4308_0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "b0cccbd8ee80032cafabccfa795b346c", + "name": "py-xgboost-cpu", + "sha256": "ba332d3aa1e8032fba3bc24fd747b88581f4f515049639420ca19995d27c55c6", + "size": 23381, + "subdir": "linux-64", + "timestamp": 1619725002020, + "version": "1.3.3" + }, + "py-xgboost-cpu-1.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.3.3 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "0c5afb12969bc1cbd18a6b08ae63794e", + "name": "py-xgboost-cpu", + "sha256": "13dadfbf502318802ab95c78e13668683eaed232353199ef1801cd2b11a7d9fd", + "size": 23397, + "subdir": "linux-64", + "timestamp": 1619724982811, + "version": "1.3.3" + }, + "py-xgboost-cpu-1.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.3.3 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "c6397110193e04a121e3bd7035170697", + "name": "py-xgboost-cpu", + "sha256": "15c2917b8aabec915037b0aca7e80de5602d131786cfbe9c8f03cf00ae35e6bc", + "size": 23387, + "subdir": "linux-64", + "timestamp": 1619725021019, + "version": "1.3.3" + }, + "py-xgboost-cpu-1.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.3.3 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "9f8b1bd822e77624b2d4e6d005df9e7c", + "name": "py-xgboost-cpu", + "sha256": "f6ecf8be89f3fe0229f27810c52f3f5d1dcc81ef8448a020a14e2ab2fc167c67", + "size": 23402, + "subdir": "linux-64", + "timestamp": 1619724956436, + "version": "1.3.3" + }, + "py-xgboost-cpu-1.5.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "py-xgboost 1.5.0 py310h06a4308_1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "a6ac8d0d9e9b9c7c782b51580fbe4921", + "name": "py-xgboost-cpu", + "sha256": "6b15a12d49baf2ce96b3be0d10e2c03d87a8a4a9e623c54e6c2561af53d4f9af", + "size": 14441, + "subdir": "linux-64", + "timestamp": 1641558639316, + "version": "1.5.0" + }, + "py-xgboost-cpu-1.5.0-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "py-xgboost 1.5.0 py310h06a4308_2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "05560f2c3d83d89393aaf8b25c788cc8", + "name": "py-xgboost-cpu", + "sha256": "d83706ecb84cf2c4ab48bd103d66c3ee029f9c41d71ec0a01d96d036a71f5eb8", + "size": 15122, + "subdir": "linux-64", + "timestamp": 1659549521322, + "version": "1.5.0" + }, + "py-xgboost-cpu-1.5.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "py-xgboost 1.5.0 py37h06a4308_1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "de00e6ab690781d6f8677b2b962215ff", + "name": "py-xgboost-cpu", + "sha256": "0628787097df59f628fdda760f68576f5f20ce52a7e3e35943849d85ce588915", + "size": 25170, + "subdir": "linux-64", + "timestamp": 1638290409529, + "version": "1.5.0" + }, + "py-xgboost-cpu-1.5.0-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "py-xgboost 1.5.0 py37h06a4308_2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "48ad154239201714f59f395a7cb1bfef", + "name": "py-xgboost-cpu", + "sha256": "b698a4d7e48c4d5425bfa3cb3921695d384700e6dd5af9429f4495d5609ac4e6", + "size": 15093, + "subdir": "linux-64", + "timestamp": 1659549537132, + "version": "1.5.0" + }, + "py-xgboost-cpu-1.5.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "py-xgboost 1.5.0 py38h06a4308_1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "abf68e3f59791e9657029387c21b9e82", + "name": "py-xgboost-cpu", + "sha256": "a775674a90df8d7e82be2bba0b2094e3289c10f81fbd15da1480f190d5aafd0d", + "size": 25170, + "subdir": "linux-64", + "timestamp": 1638290371679, + "version": "1.5.0" + }, + "py-xgboost-cpu-1.5.0-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "py-xgboost 1.5.0 py38h06a4308_2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "56ef39323c2122a11c69d24cca10aa5e", + "name": "py-xgboost-cpu", + "sha256": "8219207da0577ed1f7c58ab23e18457c3e218030f58e9fc4f1a240517047839a", + "size": 15099, + "subdir": "linux-64", + "timestamp": 1659549492102, + "version": "1.5.0" + }, + "py-xgboost-cpu-1.5.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "py-xgboost 1.5.0 py39h06a4308_1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "81ab8104b9229f5f95a1fbd5a05a5f25", + "name": "py-xgboost-cpu", + "sha256": "f82de6f6474f3a2b3130b3451153cd94ab81115ddbed7539a50da880f3c99913", + "size": 25158, + "subdir": "linux-64", + "timestamp": 1638290386388, + "version": "1.5.0" + }, + "py-xgboost-cpu-1.5.0-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "py-xgboost 1.5.0 py39h06a4308_2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "93f50cca6f14f3451a8f39a602d48e21", + "name": "py-xgboost-cpu", + "sha256": "57078b0d0bf7d72cf3b6541e5326158ad2b28436f88583af13ffa8505f36ea78", + "size": 15085, + "subdir": "linux-64", + "timestamp": 1659549506056, + "version": "1.5.0" + }, + "py-xgboost-cpu-1.5.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.5.1 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "967192928671288c0a34ddde0c758279", + "name": "py-xgboost-cpu", + "sha256": "af86101f697cbcf8f4d057199bc06a88a96601a7a31b1aaa3c17a610a5456c09", + "size": 14436, + "subdir": "linux-64", + "timestamp": 1675120186314, + "version": "1.5.1" + }, + "py-xgboost-cpu-1.5.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.5.1 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "75473ee4f26d9b5d4d4ccbbf68925eaf", + "name": "py-xgboost-cpu", + "sha256": "e4b8b60996d304eeb83331ce8bbf1b5e127df1e438c9d210f404b317da6c7ba8", + "size": 14400, + "subdir": "linux-64", + "timestamp": 1675120173130, + "version": "1.5.1" + }, + "py-xgboost-cpu-1.5.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.5.1 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2d5dbc8e383ace91fcf9a56b40f297e7", + "name": "py-xgboost-cpu", + "sha256": "bdbd5804253ec5f8917dcb0f56bbf46baa709d8ae19603fa6ecd03545e279193", + "size": 14403, + "subdir": "linux-64", + "timestamp": 1675120143758, + "version": "1.5.1" + }, + "py-xgboost-cpu-1.5.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.5.1 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e93218c7aa9b7463799d8d1e83a6bb70", + "name": "py-xgboost-cpu", + "sha256": "f59021e7c7b9f89b9e596319bf80d56f7320091432cec838f5bf7a1e1aefc4be", + "size": 14400, + "subdir": "linux-64", + "timestamp": 1675120158205, + "version": "1.5.1" + }, + "py-xgboost-cpu-1.7.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.7.3 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dc817e9381321d8c1378f0c4e349c5a5", + "name": "py-xgboost-cpu", + "sha256": "6f8faddec6fffaa8ccdc000773e33d84894f64b776c7586d066580cbd456063b", + "size": 12211, + "subdir": "linux-64", + "timestamp": 1675458316362, + "version": "1.7.3" + }, + "py-xgboost-cpu-1.7.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.7.3 py311h06a4308_0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "549fd0a42a0e8c150471009e41a81c18", + "name": "py-xgboost-cpu", + "sha256": "3b2ed0569d9c33bbfb16689b0210d76e84f3b514087e050e8f3e686a5883f635", + "size": 12245, + "subdir": "linux-64", + "timestamp": 1676922342105, + "version": "1.7.3" + }, + "py-xgboost-cpu-1.7.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.7.3 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "005c25a28b539da5931123fb7f9d1703", + "name": "py-xgboost-cpu", + "sha256": "687cc7f5070ddcfeca6cb67a74eade49ab4318be09de5f8a5dd0e36a934239c2", + "size": 12182, + "subdir": "linux-64", + "timestamp": 1675458781236, + "version": "1.7.3" + }, + "py-xgboost-cpu-1.7.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.7.3 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1547d29bdbfe7a2a4e49d265feafe58f", + "name": "py-xgboost-cpu", + "sha256": "1c063699e2d48b96afbab858d227fb1f55d202e8064a47398bed7c491f95582c", + "size": 12179, + "subdir": "linux-64", + "timestamp": 1675458564271, + "version": "1.7.3" + }, + "py-xgboost-gpu-0.72-py27h895cc61_0.conda": { + "build": "py27h895cc61_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.72 py27h83be7fe_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "7624a12c8264c59bacaa87e8ffbc187c", + "name": "py-xgboost-gpu", + "sha256": "499d5338378e316f4896e98546f09f62f6459d538354f6625bbd4691173c7722", + "size": 7748, + "subdir": "linux-64", + "timestamp": 1530223015221, + "version": "0.72" + }, + "py-xgboost-gpu-0.72-py27hbd78df6_0.conda": { + "build": "py27hbd78df6_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.72 py27h87a4715_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "adcc5ef4606390c65c7d94cdc6cedadb", + "name": "py-xgboost-gpu", + "sha256": "715e73569a1da8f1944a624857ebcc04fd2ad5af96bcef9c3d8e2d6ec7f5da7d", + "size": 7807, + "subdir": "linux-64", + "timestamp": 1530223693659, + "version": "0.72" + }, + "py-xgboost-gpu-0.72-py35h895cc61_0.conda": { + "build": "py35h895cc61_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.72 py35h83be7fe_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "b441df967684ab3c4a639fa0651d07d6", + "name": "py-xgboost-gpu", + "sha256": "cc6022496caae103a2aa6aa44c4d7ccb90dd7517ad8ca64c6945f35af17a466d", + "size": 7744, + "subdir": "linux-64", + "timestamp": 1530223029161, + "version": "0.72" + }, + "py-xgboost-gpu-0.72-py35hbd78df6_0.conda": { + "build": "py35hbd78df6_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.72 py35h87a4715_0", + "python >=3.5,<3.6.0a0" + ], + "md5": "f13a75f4b1d6432add663fe0d773187c", + "name": "py-xgboost-gpu", + "sha256": "1023dcbdede01a319d891a11a7dc7432f75a77d6063c564063a40643f20aeb3b", + "size": 7786, + "subdir": "linux-64", + "timestamp": 1530223687424, + "version": "0.72" + }, + "py-xgboost-gpu-0.72-py36h895cc61_0.conda": { + "build": "py36h895cc61_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.72 py36h83be7fe_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "2d3f6c402d920430b4f2bbbf71663446", + "name": "py-xgboost-gpu", + "sha256": "aff836e1ee8a28d1742b651ac085c2c6f91b92215336d348bfec9d4d4b0808a5", + "size": 7731, + "subdir": "linux-64", + "timestamp": 1530223022396, + "version": "0.72" + }, + "py-xgboost-gpu-0.72-py36hbd78df6_0.conda": { + "build": "py36hbd78df6_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.72 py36h87a4715_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "ecc66f43760ab4110fe5159bd28a21a7", + "name": "py-xgboost-gpu", + "sha256": "a1f97ba247a644918af1d1108d8a5b2fc26839f6282d496256f91a7c47341974", + "size": 7776, + "subdir": "linux-64", + "timestamp": 1530223700830, + "version": "0.72" + }, + "py-xgboost-gpu-0.80-py27h895cc61_0.conda": { + "build": "py27h895cc61_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py27h51060c3_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "7dbad1c90bee39e733230e60fb24d322", + "name": "py-xgboost-gpu", + "sha256": "9995318544ca9638c5cbd3457c1a2b724dfb9ae8f130b84f83387052ad0c96c8", + "size": 7557, + "subdir": "linux-64", + "timestamp": 1541468942352, + "version": "0.80" + }, + "py-xgboost-gpu-0.80-py27hbd78df6_0.conda": { + "build": "py27hbd78df6_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py27h6edc907_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "eb951f0f03a6e51563f758e827a9d509", + "name": "py-xgboost-gpu", + "sha256": "12f7591d0ae255e56bc4010175fbec35d13cade47da3a638656d8afe8086a596", + "size": 7718, + "subdir": "linux-64", + "timestamp": 1541451192428, + "version": "0.80" + }, + "py-xgboost-gpu-0.80-py27hc51cea8_0.conda": { + "build": "py27hc51cea8_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py27h6cbba54_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "d9b6252fb01f53df23094a54a51909e2", + "name": "py-xgboost-gpu", + "sha256": "e07bb00655b8881bf8486e0f60bc21312869e544c514e1bf9e7b9758d41b6250", + "size": 7652, + "subdir": "linux-64", + "timestamp": 1541450205986, + "version": "0.80" + }, + "py-xgboost-gpu-0.80-py36h895cc61_0.conda": { + "build": "py36h895cc61_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py36h51060c3_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "dc2e70e82a18ac2410a15205437b311a", + "name": "py-xgboost-gpu", + "sha256": "75b69632df041c35ca08b952f578cc11f517543b274fe6ebe424c0b8249a6ca6", + "size": 7555, + "subdir": "linux-64", + "timestamp": 1541468949333, + "version": "0.80" + }, + "py-xgboost-gpu-0.80-py36hbd78df6_0.conda": { + "build": "py36hbd78df6_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py36h6edc907_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "db39f0cb53455e3eaf606fe858e6c426", + "name": "py-xgboost-gpu", + "sha256": "3743e783e9e159855365634640d23397cd0b3611b84a9faca4a24e454d04524d", + "size": 7713, + "subdir": "linux-64", + "timestamp": 1541451178563, + "version": "0.80" + }, + "py-xgboost-gpu-0.80-py36hc51cea8_0.conda": { + "build": "py36hc51cea8_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py36h6cbba54_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "f205d39f6d62f331f64701102dc759c4", + "name": "py-xgboost-gpu", + "sha256": "a61a8c8c95a0ff69381e3bf4b1b1065e939f4054ebef6f1453dc0ebfc82a97a9", + "size": 7617, + "subdir": "linux-64", + "timestamp": 1541450192167, + "version": "0.80" + }, + "py-xgboost-gpu-0.80-py37h895cc61_0.conda": { + "build": "py37h895cc61_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py37h51060c3_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "f2a76280476372b8e5dde023719d6e39", + "name": "py-xgboost-gpu", + "sha256": "c6f91ddc82524c1c2526ef5405168c81f0a1f01ea1a209e588429a43c80e6e5b", + "size": 7540, + "subdir": "linux-64", + "timestamp": 1541468935782, + "version": "0.80" + }, + "py-xgboost-gpu-0.80-py37hbd78df6_0.conda": { + "build": "py37hbd78df6_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py37h6edc907_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "de5cc331291b29975bcac2872e64338c", + "name": "py-xgboost-gpu", + "sha256": "752ef87c6d64393f8a7440ca39c0e2cfcb3448c20d72c8fbf290af2f03c2e305", + "size": 7716, + "subdir": "linux-64", + "timestamp": 1541451185653, + "version": "0.80" + }, + "py-xgboost-gpu-0.80-py37hc51cea8_0.conda": { + "build": "py37hc51cea8_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.80 py37h6cbba54_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "4c50c0e67bb1f7f7c2e4f50358272399", + "name": "py-xgboost-gpu", + "sha256": "162e1fa1796cdc908c21f5fe49c5f349f71fced9653576ff19211e1fbcc5ec9f", + "size": 7620, + "subdir": "linux-64", + "timestamp": 1541450199236, + "version": "0.80" + }, + "py-xgboost-gpu-0.90-py27h28bbb66_0.conda": { + "build": "py27h28bbb66_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py27h688424c_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "ab5d0e3004cb3b6b72cf187f24a4b534", + "name": "py-xgboost-gpu", + "sha256": "4d808e38d11e842f42713c41d5e066b59f6e8fa95fe7d658e6dfe7118c77bb0f", + "size": 7946, + "subdir": "linux-64", + "timestamp": 1560801253423, + "version": "0.90" + }, + "py-xgboost-gpu-0.90-py27hbd78df6_0.conda": { + "build": "py27hbd78df6_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py27h6edc907_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "0339bcda3f9e847078df44c2a7ffc111", + "name": "py-xgboost-gpu", + "sha256": "33df1a8e4106a0355fa5a019d677911d48e4fc5eb0920db4d95c058de27d5beb", + "size": 7952, + "subdir": "linux-64", + "timestamp": 1560804989567, + "version": "0.90" + }, + "py-xgboost-gpu-0.90-py27hc51cea8_0.conda": { + "build": "py27hc51cea8_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py27h4d71fd4_0", + "python >=2.7,<2.8.0a0" + ], + "md5": "f4caa29daf502c185221f1d49a217819", + "name": "py-xgboost-gpu", + "sha256": "727f0d44f13b6a7352f12b2d6fc3776e54dc47e5aeca727905ef79c394682315", + "size": 7954, + "subdir": "linux-64", + "timestamp": 1560802425854, + "version": "0.90" + }, + "py-xgboost-gpu-0.90-py36h28bbb66_0.conda": { + "build": "py36h28bbb66_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py36h688424c_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "7d0ea1304c050efed535484aa5e1a332", + "name": "py-xgboost-gpu", + "sha256": "d834c267acd11d528b15d657c293d36488d5753fc3f1d39d2275ec95e87e5f80", + "size": 7942, + "subdir": "linux-64", + "timestamp": 1560801248378, + "version": "0.90" + }, + "py-xgboost-gpu-0.90-py36hbd78df6_0.conda": { + "build": "py36hbd78df6_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py36h6edc907_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "8fccf85e95b69a1454e4b4dff4229f77", + "name": "py-xgboost-gpu", + "sha256": "7646a7c0dd8b76cbb7660a216ac3bb1ad154a5f9149bd8d38c5faad29b720b2f", + "size": 7945, + "subdir": "linux-64", + "timestamp": 1560804980242, + "version": "0.90" + }, + "py-xgboost-gpu-0.90-py36hc51cea8_0.conda": { + "build": "py36hc51cea8_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py36h4d71fd4_0", + "python >=3.6,<3.7.0a0" + ], + "md5": "3f599a1199a95d890cc383d2492b3ee0", + "name": "py-xgboost-gpu", + "sha256": "95c1c89410ab86e7cddc181a318a512fb95f83e8045c053a2e6c5c5413d5f264", + "size": 7940, + "subdir": "linux-64", + "timestamp": 1560802420681, + "version": "0.90" + }, + "py-xgboost-gpu-0.90-py37h28bbb66_0.conda": { + "build": "py37h28bbb66_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py37h688424c_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "b0d6c9c870a6849823d31e73ebe5e28d", + "name": "py-xgboost-gpu", + "sha256": "2c6d5e01622589c0c6c4058f972a381b559ec26c31b3160cae35e5aca2d900a2", + "size": 7937, + "subdir": "linux-64", + "timestamp": 1560801258742, + "version": "0.90" + }, + "py-xgboost-gpu-0.90-py37hbd78df6_0.conda": { + "build": "py37hbd78df6_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py37h6edc907_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "1b72e9a74fe65cc036f72be5f0f2a235", + "name": "py-xgboost-gpu", + "sha256": "26e68e77278daeb2f908d5d58685ede798e0a1e5612c07e18233e6080f235ec7", + "size": 7939, + "subdir": "linux-64", + "timestamp": 1560804985019, + "version": "0.90" + }, + "py-xgboost-gpu-0.90-py37hc51cea8_0.conda": { + "build": "py37hc51cea8_0", + "build_number": 0, + "depends": [ + "py-xgboost 0.90 py37h4d71fd4_0", + "python >=3.7,<3.8.0a0" + ], + "md5": "35e14e93b24b76dbdff85efc3b0ee1ce", + "name": "py-xgboost-gpu", + "sha256": "ad9d6df93c9bf735910b06d3b0ec815d5b22dc6b94a771eaceeb21895113bbaa", + "size": 7944, + "subdir": "linux-64", + "timestamp": 1560802431006, + "version": "0.90" + }, + "py4j-0.10.6-py27h23eb7b3_1.conda": { + "build": "py27h23eb7b3_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "591529cfbb94cedcac95000613540f8c", + "name": "py4j", + "sha256": "e455764fa120d01350cf69f2efd184a1bf4a94069cbe3191b2064ebf7555cfdb", + "size": 233246, + "subdir": "linux-64", + "timestamp": 1505751237293, + "version": "0.10.6" + }, + "py4j-0.10.6-py35h59e76d9_1.conda": { + "build": "py35h59e76d9_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f8b50835862696d743d69024bbdc9fa1", + "name": "py4j", + "sha256": "3a3e6c7fbca579f028f9f70c575b2c08cd2f7949cc7c2ab2e5a65493a6b7cf44", + "size": 236844, + "subdir": "linux-64", + "timestamp": 1505751252785, + "version": "0.10.6" + }, + "py4j-0.10.6-py36hf94ae02_1.conda": { + "build": "py36hf94ae02_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7c54acc74b1c60c7b1dc2e6ed4be99dc", + "name": "py4j", + "sha256": "62b81d163a434a0f8f7f28bf1e039676e05498e49ecb14275f1e4dd7724de509", + "size": 236774, + "subdir": "linux-64", + "timestamp": 1505751268410, + "version": "0.10.6" + }, + "py4j-0.10.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "321c29a44be11fbf33eccf1b5427e798", + "name": "py4j", + "sha256": "9046efaa0db7e35ebffbff466af1eacea6e476edea9e392948c0678901a65454", + "size": 243548, + "subdir": "linux-64", + "timestamp": 1526075945304, + "version": "0.10.7" + }, + "py4j-0.10.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4345e7193721a7a45d4004dc81fc19d5", + "name": "py4j", + "sha256": "32d7a9ffcd911b75f7ccd7ea2082e1c244ca01d34e58b67fdd9ef2f5ce2f2f36", + "size": 248492, + "subdir": "linux-64", + "timestamp": 1526076138149, + "version": "0.10.7" + }, + "py4j-0.10.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "47911d51f0f377ad8c6a4e9cffc8980c", + "name": "py4j", + "sha256": "d44b8c0c304c4ec507d919f53e4bdcc899fb747a9b5b3b5023fe00b87dde13b0", + "size": 245603, + "subdir": "linux-64", + "timestamp": 1526075947876, + "version": "0.10.7" + }, + "py4j-0.10.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b76b502b32925c91da921f435a3f1657", + "name": "py4j", + "sha256": "2ea7b841af695e4283486725fcfcdc74f1eaf0068fcd6ea08c4970fc35dd807c", + "size": 247285, + "subdir": "linux-64", + "timestamp": 1530898277927, + "version": "0.10.7" + }, + "py4j-0.10.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "32c0e00982478dc9c4c04fab165c2e43", + "name": "py4j", + "sha256": "cbfc01907a48937e77f90d7cf618ad5751cfa519709fd5759ae49fcac28d9254", + "size": 242867, + "subdir": "linux-64", + "timestamp": 1541001759032, + "version": "0.10.8.1" + }, + "py4j-0.10.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "644200e9602138699ba282c2cab33bb3", + "name": "py4j", + "sha256": "c8d2901fed1dadc4a194e98e75394fa17590352d521021d86271327e5f984615", + "size": 245193, + "subdir": "linux-64", + "timestamp": 1541001741606, + "version": "0.10.8.1" + }, + "py4j-0.10.8.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "efbf7a1c097e32f1752e07b37b8ecb90", + "name": "py4j", + "sha256": "3a69b00e1b01c79e44a410ce24ea3ac9ac86b0c530162ee9d1830abdb4c77cb2", + "size": 245467, + "subdir": "linux-64", + "timestamp": 1541001731425, + "version": "0.10.8.1" + }, + "py4j-0.10.8.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2e126b293e09640656ea1736b821b209", + "name": "py4j", + "sha256": "89707a69c177093cd1ed723a529174790dd16be66751c14bb4eede4e5fa4cd94", + "size": 247898, + "subdir": "linux-64", + "timestamp": 1573662629288, + "version": "0.10.8.1" + }, + "py4j-0.10.9.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3f48738a217f3e754c428a5ac963fcdd", + "name": "py4j", + "sha256": "eeb55f1e3b19574b75a70ed65712a357e0b73c0c5bef0f7ac47fef59a2a638ca", + "size": 259038, + "subdir": "linux-64", + "timestamp": 1669626900609, + "version": "0.10.9.3" + }, + "py4j-0.10.9.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f194abd545de33adac779876516b17e2", + "name": "py4j", + "sha256": "a1c0a3cda33bc17c8425020bf6ab4cc34b0b2d20bfc263a86cd47c3f0a5ab1c1", + "size": 298898, + "subdir": "linux-64", + "timestamp": 1676845253989, + "version": "0.10.9.3" + }, + "py4j-0.10.9.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "72d0e49e98438b551a1ff1ec8d52bdcb", + "name": "py4j", + "sha256": "4b7766052b7e34279f64b0c960f56b82734ba53f2aaf7dfcc4ae6160143a2edc", + "size": 255602, + "subdir": "linux-64", + "timestamp": 1669626851136, + "version": "0.10.9.3" + }, + "py4j-0.10.9.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7c7f90e85ddc6c5c343b21f9640ac79c", + "name": "py4j", + "sha256": "ed8133449490339a1d4663fb42328a3ce9be23c21360c8fe120043d1a14f188f", + "size": 256972, + "subdir": "linux-64", + "timestamp": 1669626924859, + "version": "0.10.9.3" + }, + "py4j-0.10.9.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "af0bb8caacd703f1bd80997833009175", + "name": "py4j", + "sha256": "10a7583883da78f9d2602c675a909ea9850789336a0786737eedbc45b54f6282", + "size": 257014, + "subdir": "linux-64", + "timestamp": 1669626875768, + "version": "0.10.9.3" + }, + "pyamg-3.3.2-py27h41dcbd8_0.conda": { + "build": "py27h41dcbd8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest >=2", + "python >=2.7,<2.8.0a0", + "scipy >=0.12.0,<1.8", + "zlib", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "fa67e73047283e5171fee788bdc1209d", + "name": "pyamg", + "sha256": "d0ff25d69ddcd5aee682af8edc71938fce04f1011ff0f51817feac9076b94b25", + "size": 915260, + "subdir": "linux-64", + "timestamp": 1509088514589, + "version": "3.3.2" + }, + "pyamg-3.3.2-py27h54d9346_0.conda": { + "build": "py27h54d9346_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest >=2", + "python >=2.7,<2.8.0a0", + "scipy >=0.12.0,<1.8", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "faa25ca899d2735c5dde3ae7c85320bd", + "name": "pyamg", + "sha256": "cdc0168c9b2bce41a4dddf3b52220c7ac3d320892f6b3c83dbb02b439d11cf88", + "size": 915826, + "subdir": "linux-64", + "timestamp": 1530906260320, + "version": "3.3.2" + }, + "pyamg-3.3.2-py35hc0f34cd_0.conda": { + "build": "py35hc0f34cd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest >=2", + "python >=3.5,<3.6.0a0", + "scipy >=0.12.0,<1.8", + "zlib", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "fb60b5e1741e1ec0459dbc41e82ee5d5", + "name": "pyamg", + "sha256": "3b69b6b9489b584de7c290b04e1b95d5a21c6d907ec89f6b8569dc35501b7681", + "size": 917716, + "subdir": "linux-64", + "timestamp": 1509088597637, + "version": "3.3.2" + }, + "pyamg-3.3.2-py36h54d9346_0.conda": { + "build": "py36h54d9346_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest >=2", + "python >=3.6,<3.7.0a0", + "scipy >=0.12.0,<1.8", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "0388770774302480b17150fc9b676957", + "name": "pyamg", + "sha256": "928d67db171659ad964ff6bda5215a129841531fa7facfb8782a6ead126e06e6", + "size": 914804, + "subdir": "linux-64", + "timestamp": 1530906350330, + "version": "3.3.2" + }, + "pyamg-3.3.2-py36ha1d9e31_0.conda": { + "build": "py36ha1d9e31_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pytest >=2", + "python >=3.6,<3.7.0a0", + "scipy >=0.12.0,<1.8", + "zlib", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "63e6bd51ef45458fb365e0cfbf1d1960", + "name": "pyamg", + "sha256": "df1d4b777e8476d8080ac5033a81a7bcd189cdedba506c0185780abf4a6eb665", + "size": 918998, + "subdir": "linux-64", + "timestamp": 1509088328312, + "version": "3.3.2" + }, + "pyamg-3.3.2-py37h54d9346_0.conda": { + "build": "py37h54d9346_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pytest >=2", + "python >=3.7,<3.8.0a0", + "scipy >=0.12.0,<1.8", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "md5": "c52501ed3a312de42d91aac8b06ab4d5", + "name": "pyamg", + "sha256": "453ac77e2b6a654dc7ead0dc69e49850845c7eaa808f6a046c642d259c44927b", + "size": 912131, + "subdir": "linux-64", + "timestamp": 1530906439644, + "version": "3.3.2" + }, + "pyamg-4.0.0-py27ha516724_0.conda": { + "build": "py27ha516724_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "e2bf119f097020fd40f78c36fe7fff49", + "name": "pyamg", + "sha256": "ea3e03f23f81ac41c785b6d6074456661e1c25642fd801468ed270fa7313e1bc", + "size": 1110435, + "subdir": "linux-64", + "timestamp": 1536513555060, + "version": "4.0.0" + }, + "pyamg-4.0.0-py35ha516724_0.conda": { + "build": "py35ha516724_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "e0c208b4c4682583377469290b66ee42", + "name": "pyamg", + "sha256": "df4cfa09c33a433d5e9d48db10c14722cf6bf71a8f6674f604bbd4513dcdbb90", + "size": 1108925, + "subdir": "linux-64", + "timestamp": 1536513776970, + "version": "4.0.0" + }, + "pyamg-4.0.0-py36ha516724_0.conda": { + "build": "py36ha516724_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "c14c7a35879c3a3f3a7d489965addddc", + "name": "pyamg", + "sha256": "2764ec68a95c92ffac97c017a3e83f3425ec47d3ae585787d734d084fc59dda0", + "size": 1110576, + "subdir": "linux-64", + "timestamp": 1536513802990, + "version": "4.0.0" + }, + "pyamg-4.0.0-py37ha516724_0.conda": { + "build": "py37ha516724_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "30f537da5df426f9c83556ea47a53dda", + "name": "pyamg", + "sha256": "08b46427a4eef1c9a92ade3a131c6fd3703c62007fe496f9bcb4fbf5b44a621f", + "size": 1107512, + "subdir": "linux-64", + "timestamp": 1536513716615, + "version": "4.0.0" + }, + "pyamg-4.0.0-py38ha516724_0.conda": { + "build": "py38ha516724_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "bad7be65614deb0aec2ea43621bd43a3", + "name": "pyamg", + "sha256": "1c08b0ca3fda723a74e72d2dba247c72d85c7f68e91d2ece8247fbf42eaf2ca5", + "size": 1096280, + "subdir": "linux-64", + "timestamp": 1574170355622, + "version": "4.0.0" + }, + "pyamg-4.1.0-py310h2571103_0.conda": { + "build": "py310h2571103_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "28c8847893dae0edf6b1a375a71adf42", + "name": "pyamg", + "sha256": "8aea9b4c1c751afe55abac0aa37b9e45e65ba4dc127b1e9fd9812fbd43122b1a", + "size": 5424693, + "subdir": "linux-64", + "timestamp": 1640810142029, + "version": "4.1.0" + }, + "pyamg-4.1.0-py36h9a67853_0.conda": { + "build": "py36h9a67853_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "8a0f02b13026fabcd1f35939addf5565", + "name": "pyamg", + "sha256": "9cb6967cc94fd581d2f7ed33a1434225e9409204e8cdc015a650e71d93a28374", + "size": 1160118, + "subdir": "linux-64", + "timestamp": 1618088926568, + "version": "4.1.0" + }, + "pyamg-4.1.0-py37h9a67853_0.conda": { + "build": "py37h9a67853_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "85ae0f3a18314e5d6dca7a8207875a61", + "name": "pyamg", + "sha256": "8626e64aa419946f0adfe7ea4745c960b7b35b123bd21a9b3c8cdd124197c6ac", + "size": 1164469, + "subdir": "linux-64", + "timestamp": 1618088613504, + "version": "4.1.0" + }, + "pyamg-4.1.0-py38h9a67853_0.conda": { + "build": "py38h9a67853_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "9b0bffd5f67e0c5ee3c226e5518991fb", + "name": "pyamg", + "sha256": "93b83b6d2f23b13b464c199db525d5b438b9bc8699693785171655ce1a6f86b8", + "size": 1160618, + "subdir": "linux-64", + "timestamp": 1618088892453, + "version": "4.1.0" + }, + "pyamg-4.1.0-py39h9a67853_0.conda": { + "build": "py39h9a67853_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.12.0,<1.8" + ], + "license": "MIT", + "md5": "262548823d010e5b8ef7291eb3f11da1", + "name": "pyamg", + "sha256": "2a37e8fe722ff5f8d13f6a12ccf1abb358516e22c166733697051919d8acf945", + "size": 1169426, + "subdir": "linux-64", + "timestamp": 1618085959655, + "version": "4.1.0" + }, + "pyamg-4.2.3-py310h3c18c91_0.conda": { + "build": "py310h3c18c91_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=0.12.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5155b95458cde608f58cfbddecc972e3", + "name": "pyamg", + "sha256": "c4cca050c8095e5e5a0715c68e35db115e14323d0cf51595fb199e77f1f34f0a", + "size": 1253151, + "subdir": "linux-64", + "timestamp": 1665482260104, + "version": "4.2.3" + }, + "pyamg-4.2.3-py311heed92f4_0.conda": { + "build": "py311heed92f4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0", + "scipy >=0.12.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f788f9a2a861c15c0db343db73a42735", + "name": "pyamg", + "sha256": "8b55965c7a0e4319ab613db72aca2ecbec12b722f5dd85a1f7f6bbb8d4eb675e", + "size": 1361671, + "subdir": "linux-64", + "timestamp": 1676860600240, + "version": "4.2.3" + }, + "pyamg-4.2.3-py37h79cecc1_0.conda": { + "build": "py37h79cecc1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.12.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "68d9864b872bea45d9b330ca7fec0768", + "name": "pyamg", + "sha256": "ede201f92fdb5897a7fa47cb3a3ef0a01b090a437a21bc1c2cf55db54d4f7b61", + "size": 1235334, + "subdir": "linux-64", + "timestamp": 1665482387499, + "version": "4.2.3" + }, + "pyamg-4.2.3-py38h79cecc1_0.conda": { + "build": "py38h79cecc1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.12.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e7f4f94000b244396de8bf4e6ae8dc4", + "name": "pyamg", + "sha256": "ff02d35ae2e2b3375c6255fa67f5bc2edbd32e6275e613711011661255997bd1", + "size": 1241540, + "subdir": "linux-64", + "timestamp": 1665482004716, + "version": "4.2.3" + }, + "pyamg-4.2.3-py39h79cecc1_0.conda": { + "build": "py39h79cecc1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.12.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "afc634da8b81dc504179d53d334e6e55", + "name": "pyamg", + "sha256": "6f23c3106231108cd786907d2a36ee9fb7dc998b30d08bad6403cc6d3a0fe940", + "size": 1260716, + "subdir": "linux-64", + "timestamp": 1665482137873, + "version": "4.2.3" + }, + "pyaml-18.11.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pyyaml" + ], + "license": "WTFPL", + "md5": "257d3835708f2f9d99290855ca42696b", + "name": "pyaml", + "sha256": "17783269be0fa60a5e17a4eaaeeb13993a896a1f15a390ca7477cbd89c01f9b5", + "size": 28541, + "subdir": "linux-64", + "timestamp": 1543386785329, + "version": "18.11.0" + }, + "pyaml-18.11.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml" + ], + "license": "WTFPL", + "md5": "f8f2bc15059b4cf45272ad846952578f", + "name": "pyaml", + "sha256": "1b70f51864a7eb21228599a0e98ccddc4d0128febecff8d88476fab1ab00191b", + "size": 28439, + "subdir": "linux-64", + "timestamp": 1543386802670, + "version": "18.11.0" + }, + "pyaml-18.11.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml" + ], + "license": "WTFPL", + "md5": "df8e3b39cb40cf7ded717c0d019bdbe2", + "name": "pyaml", + "sha256": "a1fb4630d233c492eecb93488e35c0ac20c13c103ce0f7c05f075e9a6f5c9927", + "size": 28447, + "subdir": "linux-64", + "timestamp": 1543386785188, + "version": "18.11.0" + }, + "pyarrow-0.11.0-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.11.0,<0.12.0a0", + "futures", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.2,<2.0a0", + "pandas", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "Apache 2.0", + "md5": "6b6d2537f68e126f1534e7a33f727173", + "name": "pyarrow", + "sha256": "2db8490bad42f4559acb79bfa7c7a0b3a3b75ece041ae9351d3add9eaec1c4f6", + "size": 1636695, + "subdir": "linux-64", + "timestamp": 1539968045849, + "version": "0.11.0" + }, + "pyarrow-0.11.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.11.0,<0.12.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.2,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache 2.0", + "md5": "9dcae87097e04c9515aa30370610d038", + "name": "pyarrow", + "sha256": "02759c949cbe8c088252bc45d75437a20d37f21c6567ad61b8c9c8112f86fb6f", + "size": 1665191, + "subdir": "linux-64", + "timestamp": 1539998724556, + "version": "0.11.0" + }, + "pyarrow-0.11.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.11.0,<0.12.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.2,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "Apache 2.0", + "md5": "0b72735da47fb6a006d26d360492f88a", + "name": "pyarrow", + "sha256": "627ae44bf49e40cbcc3d697eafb1884f406cd1d8c9efc515b9b0dd830e9b68ba", + "size": 1660036, + "subdir": "linux-64", + "timestamp": 1539968220904, + "version": "0.11.0" + }, + "pyarrow-0.11.1-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.11.1,<0.12.0a0", + "futures", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.3,<2.0a0", + "pandas", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "Apache 2.0", + "md5": "69c2ac60672637878edb29a0cfb22d3a", + "name": "pyarrow", + "sha256": "90560fa7849f38496bc86feb47ea537634c94674b7996038d3e80ca64a8d2e6e", + "size": 1634263, + "subdir": "linux-64", + "timestamp": 1541002378882, + "version": "0.11.1" + }, + "pyarrow-0.11.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.11.1,<0.12.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.3,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache 2.0", + "md5": "d5aa4ad7bf20a37d40e7d1ddae5cf0ac", + "name": "pyarrow", + "sha256": "ce6e8fa64872a4cfc8bb1101ce1a02482416d53bf4a360e6895b6743029f7cdd", + "size": 1661567, + "subdir": "linux-64", + "timestamp": 1541002382910, + "version": "0.11.1" + }, + "pyarrow-0.11.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.11.1,<0.12.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.3,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "Apache 2.0", + "md5": "fac4952327d4934d7b343ad1459a9b67", + "name": "pyarrow", + "sha256": "cc4beb6059c8488eae15454c01e6f05cdde63c70764014dbd19e811bd1895eab", + "size": 1657419, + "subdir": "linux-64", + "timestamp": 1541002386860, + "version": "0.11.1" + }, + "pyarrow-0.13.0-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.13.0,<0.14.0a0", + "arrow-cpp >=0.13.0,<1.0a0", + "boost-cpp", + "futures", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14,<2.0a0", + "pandas", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache 2.0", + "md5": "484d79d93b665b12e9a5992a64247661", + "name": "pyarrow", + "sha256": "404f0a7b0c3f1763c252157b867e3f212e92e6dd9bc8de660d6dddbaa90f1953", + "size": 1890078, + "subdir": "linux-64", + "timestamp": 1567110538602, + "version": "0.13.0" + }, + "pyarrow-0.13.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.13.0,<0.14.0a0", + "arrow-cpp >=0.13.0,<1.0a0", + "boost-cpp", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache 2.0", + "md5": "397a118498226c38a47af348bbed34b6", + "name": "pyarrow", + "sha256": "5e40fad21c92e27cb16dbeb413738ba9dce54d59cc6d8304d1c3db60a4ead46a", + "size": 1921808, + "subdir": "linux-64", + "timestamp": 1567110786008, + "version": "0.13.0" + }, + "pyarrow-0.13.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.13.0,<0.14.0a0", + "arrow-cpp >=0.13.0,<1.0a0", + "boost-cpp", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache 2.0", + "md5": "0b1aa75b9528be96b4d817becef06cad", + "name": "pyarrow", + "sha256": "d79634f8b20c55d26093fb242ff2c1fc575f4c7b9480fb13b82afdc0035db12d", + "size": 1917433, + "subdir": "linux-64", + "timestamp": 1567111012547, + "version": "0.13.0" + }, + "pyarrow-0.13.0-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.13.0,<0.14.0a0", + "arrow-cpp >=0.13.0,<1.0a0", + "boost-cpp", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14,<2.0a0", + "pandas", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache 2.0", + "md5": "41c5d8d5cdccc8d4298209a93a715e63", + "name": "pyarrow", + "sha256": "f82a2fe4ae65a11f14aba5de5daea5ab9d3a7476840cb4786bf100e8bfbd1b94", + "size": 1954926, + "subdir": "linux-64", + "timestamp": 1574413029677, + "version": "0.13.0" + }, + "pyarrow-0.15.1-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.15.1,<0.15.2.0a0", + "arrow-cpp >=0.15.1,<1.0a0", + "boost-cpp", + "glog", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "96ca04c397f39993e301f31f580c1674", + "name": "pyarrow", + "sha256": "c8f54fffa4be38e5817fe949e72ff1d2356fabe0279d5c4ef6a2fd4e2a728b1d", + "size": 2750559, + "subdir": "linux-64", + "timestamp": 1582573753026, + "version": "0.15.1" + }, + "pyarrow-0.15.1-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.15.1,<0.15.2.0a0", + "arrow-cpp >=0.15.1,<1.0a0", + "boost-cpp", + "glog", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "006ee3f6f4e766f1daad8f26b9d972e9", + "name": "pyarrow", + "sha256": "d4d324569bfe20e8eade43eb6f96a00cdd554dd3fad94e6a58c10e04a1741073", + "size": 2750367, + "subdir": "linux-64", + "timestamp": 1580504702305, + "version": "0.15.1" + }, + "pyarrow-0.15.1-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.15.1,<0.15.2.0a0", + "arrow-cpp >=0.15.1,<1.0a0", + "boost-cpp", + "glog", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "511595b99361958925e2f71e68f3da1e", + "name": "pyarrow", + "sha256": "934c024f1cbea637152255e235dfda75ba74f1bd7b7cb8d34981f820324a9ff9", + "size": 2714266, + "subdir": "linux-64", + "timestamp": 1582573734465, + "version": "0.15.1" + }, + "pyarrow-0.15.1-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.15.1,<0.15.2.0a0", + "arrow-cpp >=0.15.1,<1.0a0", + "boost-cpp", + "glog", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "227bf813a59216e3fef4faf574921462", + "name": "pyarrow", + "sha256": "8d00496cc61d1c7c9b6237472e18480088a9375786b825ec9d13eee6e93ee1df", + "size": 2715167, + "subdir": "linux-64", + "timestamp": 1580504633622, + "version": "0.15.1" + }, + "pyarrow-0.15.1-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.15.1,<0.15.2.0a0", + "arrow-cpp >=0.15.1,<1.0a0", + "boost-cpp", + "glog", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.8,<3.9.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "1b1404b8ed52c8c82752d4b0fa610a27", + "name": "pyarrow", + "sha256": "339e28b587815c8f3dee5e3f065a0e2a881f82f7d99c520143d1e7e22ed7fbd0", + "size": 2686471, + "subdir": "linux-64", + "timestamp": 1582573729376, + "version": "0.15.1" + }, + "pyarrow-0.15.1-py38h962f231_0.conda": { + "build": "py38h962f231_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=0.15.1,<0.15.2.0a0", + "arrow-cpp >=0.15.1,<1.0a0", + "boost-cpp", + "glog", + "grpc-cpp >=1.26.0,<1.27.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.8,<3.9.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "2e7d24f03597b3708cb4f743f2c45b60", + "name": "pyarrow", + "sha256": "3fe454b498474ce4496008869c6e864bfd52bca40183076dfa9bf91b4f93a20c", + "size": 2682228, + "subdir": "linux-64", + "timestamp": 1580504694269, + "version": "0.15.1" + }, + "pyarrow-0.9.0-py27hfc40096_2.conda": { + "build": "py27hfc40096_2", + "build_number": 2, + "depends": [ + "arrow-cpp >=0.9.0,<0.10.0a0", + "futures", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "parquet-cpp >=1.4.0,<1.5.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "Apache 2.0", + "md5": "ae270f47cf180a520bec8de92114e044", + "name": "pyarrow", + "sha256": "b471dd863a0c1e742128ade8285f5403a28aa182add67c96b059a8f3df0242c0", + "size": 1045507, + "subdir": "linux-64", + "timestamp": 1529460484415, + "version": "0.9.0" + }, + "pyarrow-0.9.0-py35hfc40096_2.conda": { + "build": "py35hfc40096_2", + "build_number": 2, + "depends": [ + "arrow-cpp >=0.9.0,<0.10.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "parquet-cpp >=1.4.0,<1.5.0a0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "Apache 2.0", + "md5": "02598f8308bb833e5418c7f62182de9c", + "name": "pyarrow", + "sha256": "5c67a63dfa5fd770514a71f4dc4beb8e1cbd4032e2d9aaa7d8e7267833a0e68d", + "size": 1048078, + "subdir": "linux-64", + "timestamp": 1529460605015, + "version": "0.9.0" + }, + "pyarrow-0.9.0-py36hfc40096_2.conda": { + "build": "py36hfc40096_2", + "build_number": 2, + "depends": [ + "arrow-cpp >=0.9.0,<0.10.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas", + "parquet-cpp >=1.4.0,<1.5.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache 2.0", + "md5": "9845f9f2176f5037dded02dc778ecf30", + "name": "pyarrow", + "sha256": "e816dba6ac1d8a56d820f49ed60a0223c6eaf788ee4f1bfa49cac9fd0c16b53b", + "size": 1060097, + "subdir": "linux-64", + "timestamp": 1529460539021, + "version": "0.9.0" + }, + "pyarrow-10.0.1-py310h468efa6_0.conda": { + "build": "py310h468efa6_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=10.0.1,<10.0.2.0a0", + "boost-cpp", + "gflags", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "43d33dc769234e1acb847f3c54ac1383", + "name": "pyarrow", + "sha256": "8207a91ba676f600e07de49d54960132f08581c2544290370dc46a07b3e69aff", + "size": 4678250, + "subdir": "linux-64", + "timestamp": 1680270607402, + "version": "10.0.1" + }, + "pyarrow-10.0.1-py311hd8e8d9b_0.conda": { + "build": "py311hd8e8d9b_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=10.0.1,<10.0.2.0a0", + "boost-cpp", + "gflags", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "422c22e3084eac6f52b1d554276709e8", + "name": "pyarrow", + "sha256": "0045c27d026e425b3dc1be4a0ec6edec7118a082209f03bb290a469be17750aa", + "size": 4609320, + "subdir": "linux-64", + "timestamp": 1680269956999, + "version": "10.0.1" + }, + "pyarrow-10.0.1-py38h992f0b0_0.conda": { + "build": "py38h992f0b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=10.0.1,<10.0.2.0a0", + "boost-cpp", + "gflags", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ab23a08398ff8b9bb39eaa96399afa8f", + "name": "pyarrow", + "sha256": "03d8eada1395c922380182c2c1976fa4048c4aa0d4f7789776018570a5c39e57", + "size": 4654092, + "subdir": "linux-64", + "timestamp": 1680270287113, + "version": "10.0.1" + }, + "pyarrow-10.0.1-py39h992f0b0_0.conda": { + "build": "py39h992f0b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=10.0.1,<10.0.2.0a0", + "boost-cpp", + "gflags", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1550f6cb59d5534428bf7f5cc5bc7ddf", + "name": "pyarrow", + "sha256": "8f299a7b004e346bb8b18c953f2ac6424d5b6bc3b44d8f0e12269d1549124db9", + "size": 4613650, + "subdir": "linux-64", + "timestamp": 1680270929091, + "version": "10.0.1" + }, + "pyarrow-2.0.0-py36he0739d4_0.conda": { + "build": "py36he0739d4_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=2.0.0,<2.0.1.0a0", + "arrow-cpp >=2.0.0,<3.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "6e7a2541a8ad7322f6cd05077ce90f4d", + "name": "pyarrow", + "sha256": "9d3cfe87fb7d64960a4f21406d083ae55a748249ceb12c5ae8a7516519a8b54f", + "size": 2718905, + "subdir": "linux-64", + "timestamp": 1612021302356, + "version": "2.0.0" + }, + "pyarrow-2.0.0-py37he0739d4_0.conda": { + "build": "py37he0739d4_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=2.0.0,<2.0.1.0a0", + "arrow-cpp >=2.0.0,<3.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "fd659e249f11410fd7d00dc46132a096", + "name": "pyarrow", + "sha256": "76bd8d543150b877f65b74222c9006a203a9c5ac339688b9f32fd65538e03863", + "size": 2674645, + "subdir": "linux-64", + "timestamp": 1612021325310, + "version": "2.0.0" + }, + "pyarrow-2.0.0-py38he0739d4_0.conda": { + "build": "py38he0739d4_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=2.0.0,<2.0.1.0a0", + "arrow-cpp >=2.0.0,<3.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.8,<3.9.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "76e51ec1d2d82d84694c2398995192b7", + "name": "pyarrow", + "sha256": "3bfdc98c54ac43ec902b5ff281cdf75f2304659fdb373ef0a388b898a61ea36e", + "size": 2716792, + "subdir": "linux-64", + "timestamp": 1612021344334, + "version": "2.0.0" + }, + "pyarrow-2.0.0-py39he0739d4_0.conda": { + "build": "py39he0739d4_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=2.0.0,<2.0.1.0a0", + "arrow-cpp >=2.0.0,<3.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.9,<3.10.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "73f6c47b297a5cb2c9e73208c3229f6b", + "name": "pyarrow", + "sha256": "2b6c4bbecf4f8112f634aa35638730659fdaf40cee4e6a6362ff157fed4a0082", + "size": 2575395, + "subdir": "linux-64", + "timestamp": 1612020683263, + "version": "2.0.0" + }, + "pyarrow-3.0.0-py36he0739d4_0.conda": { + "build": "py36he0739d4_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "fc5e3ecf84bcb4989a83d04b1944f3b3", + "name": "pyarrow", + "sha256": "b5a2d8f5de39d145679f5294ae572a5c460532652d06feeda8d2736c996c8ea6", + "size": 2776610, + "subdir": "linux-64", + "timestamp": 1612122443882, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py36he0739d4_1.conda": { + "build": "py36he0739d4_1", + "build_number": 1, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "7970b3d037b719bef7388f22fe3b2f40", + "name": "pyarrow", + "sha256": "acc248daffc293a5417e58f7cacdf3ffc7ddf5178de4e076c49fef6dab66f4ad", + "size": 1919199, + "subdir": "linux-64", + "timestamp": 1613152191451, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py36he0739d4_3.conda": { + "build": "py36he0739d4_3", + "build_number": 3, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "651b3f74accb0dc3ddb2ab1255b5b646", + "name": "pyarrow", + "sha256": "447b8fed4c26368556fc4ce041a333c4ec20a004e1223ab78a1591be980b3935", + "size": 1917731, + "subdir": "linux-64", + "timestamp": 1615279127904, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py37he0739d4_0.conda": { + "build": "py37he0739d4_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "36f9d218c9ac9263464a8e0b72b9a38a", + "name": "pyarrow", + "sha256": "c83809b76ff62067692f9d769b9295111eb7d9a9514f36382ad0167fbebab2ed", + "size": 2729473, + "subdir": "linux-64", + "timestamp": 1612122943156, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py37he0739d4_1.conda": { + "build": "py37he0739d4_1", + "build_number": 1, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "25e35c9d5b5a350eb06549575e553dde", + "name": "pyarrow", + "sha256": "9ae3b3933027ce5dd565e6ca67bfaf07566d553b9bc97784fc844c273ca08bf5", + "size": 1907589, + "subdir": "linux-64", + "timestamp": 1613152627779, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py37he0739d4_3.conda": { + "build": "py37he0739d4_3", + "build_number": 3, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "1dcc229b49565bba9cd650d424b911e1", + "name": "pyarrow", + "sha256": "e04832ca74ac2dab64384c90c4027f92a178c278d917a8a4ca3e24af55764783", + "size": 1905308, + "subdir": "linux-64", + "timestamp": 1615279458144, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py38he0739d4_0.conda": { + "build": "py38he0739d4_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.8,<3.9.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "e5ee4566d519cd8cf11326f4a0c61c8e", + "name": "pyarrow", + "sha256": "53c24bc35fa012b99dd1c67e82d5942858773e5ddbfae89da4913b915a1d7105", + "size": 2779273, + "subdir": "linux-64", + "timestamp": 1612122928064, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py38he0739d4_1.conda": { + "build": "py38he0739d4_1", + "build_number": 1, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.8,<3.9.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "0c6c0a38284b9c7a13d0323221f89770", + "name": "pyarrow", + "sha256": "c6fa08e954406f2c8bd908c783856575adc9aa6126ca2c7cc9f1adb5519769d6", + "size": 1988043, + "subdir": "linux-64", + "timestamp": 1613152652177, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py38he0739d4_3.conda": { + "build": "py38he0739d4_3", + "build_number": 3, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.8,<3.9.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "38b17d95803c0042a9ec196a3dd0b620", + "name": "pyarrow", + "sha256": "6e4f1dc8cfc52796873bb934f476f2660c8d94a580ccb78709dca0ddf2da1057", + "size": 1988773, + "subdir": "linux-64", + "timestamp": 1615279367389, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py39he0739d4_0.conda": { + "build": "py39he0739d4_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.9,<3.10.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "1cf2a0cbd19fb6e6ffca83576482f2f6", + "name": "pyarrow", + "sha256": "79fa01efa2fd7032c3a254ddbe47669b9351472f7b169f0f0238f97705067cde", + "size": 2633089, + "subdir": "linux-64", + "timestamp": 1612122906419, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py39he0739d4_1.conda": { + "build": "py39he0739d4_1", + "build_number": 1, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.9,<3.10.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "92d271096cadd4f3fda8bb9d223d9c3f", + "name": "pyarrow", + "sha256": "8eba738a950e9a98eab36b13bf9bb7adfb5393f75e300b74d3486287aa9b3a6e", + "size": 1976506, + "subdir": "linux-64", + "timestamp": 1613152631344, + "version": "3.0.0" + }, + "pyarrow-3.0.0-py39he0739d4_3.conda": { + "build": "py39he0739d4_3", + "build_number": 3, + "depends": [ + "arrow-cpp >=3.0.0,<3.0.1.0a0", + "arrow-cpp >=3.0.0,<4.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.9,<3.10.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "acd00fcf9d6811dc4ad2a3c9f9c3f6e6", + "name": "pyarrow", + "sha256": "79c2c7c38a7a830e9fd959abdffa446a3125a9830d59374137c4d028e226de55", + "size": 1984327, + "subdir": "linux-64", + "timestamp": 1615279423127, + "version": "3.0.0" + }, + "pyarrow-4.0.1-py36he0739d4_3.conda": { + "build": "py36he0739d4_3", + "build_number": 3, + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "arrow-cpp >=4.0.1,<5.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.6,<3.7.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "585fb2da8698a820c233d4df9bff638a", + "name": "pyarrow", + "sha256": "8364f97888f158443ba7bdead3ca33029f1c2827f4932afe6ecd5c13b4c5c6a2", + "size": 2016405, + "subdir": "linux-64", + "timestamp": 1623164905824, + "version": "4.0.1" + }, + "pyarrow-4.0.1-py37he0739d4_3.conda": { + "build": "py37he0739d4_3", + "build_number": 3, + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "arrow-cpp >=4.0.1,<5.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.7,<3.8.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "2632ba6537d7c40d7c34632604f8e508", + "name": "pyarrow", + "sha256": "66ee5bbf872246171fa270c6a01806551cf8c66bbd029ef76474e9a4d5ae3bf4", + "size": 2011180, + "subdir": "linux-64", + "timestamp": 1623174344326, + "version": "4.0.1" + }, + "pyarrow-4.0.1-py38he0739d4_3.conda": { + "build": "py38he0739d4_3", + "build_number": 3, + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "arrow-cpp >=4.0.1,<5.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11,<2.0a0", + "pandas", + "python >=3.8,<3.9.0a0", + "six", + "snappy" + ], + "license": "Apache 2.0", + "md5": "c8bbcbd853b7b0a47a33faacc74f2abc", + "name": "pyarrow", + "sha256": "07c5e1684f8a2f9fef0da8c4b0ea412d8d18f143bd3cab2414cc013acedecac9", + "size": 2101157, + "subdir": "linux-64", + "timestamp": 1623164893443, + "version": "4.0.1" + }, + "pyarrow-4.0.1-py39he0739d4_3.conda": { + "build": "py39he0739d4_3", + "build_number": 3, + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "arrow-cpp >=4.0.1,<5.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "pandas", + "python >=3.9,<3.10.0a0", + "six", + "snappy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "55a50657b8d1b0aea2c855b8140eae08", + "name": "pyarrow", + "sha256": "26156faa47575e59b0d5953be01e3cdd4ca7bd4ccb332a1f95579a6813aab7a9", + "size": 2105582, + "subdir": "linux-64", + "timestamp": 1623236297252, + "version": "4.0.1" + }, + "pyarrow-8.0.0-py310h468efa6_0.conda": { + "build": "py310h468efa6_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=8.0.0,<8.0.1.0a0", + "arrow-cpp >=8.0.0,<9.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.10,<3.11.0a0", + "snappy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "519a1220bda64c77c65a76806f737e9f", + "name": "pyarrow", + "sha256": "12c48e9bf53e7198fab55911c38eede8a1266b69090e1462c51bc805bd2f74ec", + "size": 2696067, + "subdir": "linux-64", + "timestamp": 1657263889195, + "version": "8.0.0" + }, + "pyarrow-8.0.0-py311h4eef722_0.conda": { + "build": "py311h4eef722_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=8.0.0,<8.0.1.0a0", + "arrow-cpp >=8.0.0,<9.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.11,<3.12.0a0", + "snappy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bd1300bbd512083b4fd623d5c4583891", + "name": "pyarrow", + "sha256": "b023d138452bf77d58ff06fef157ccf181ae95174b405dc5e9ad752fd85d7623", + "size": 2737792, + "subdir": "linux-64", + "timestamp": 1676842038681, + "version": "8.0.0" + }, + "pyarrow-8.0.0-py37h992f0b0_0.conda": { + "build": "py37h992f0b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=8.0.0,<8.0.1.0a0", + "arrow-cpp >=8.0.0,<9.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "snappy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "60a5631fce15ae723bfe7115164bafe0", + "name": "pyarrow", + "sha256": "e3684c32fa1d38bc4f44ef31c9bac5b9bdf451100ae300ce7c69ae7d1fd8f172", + "size": 2697184, + "subdir": "linux-64", + "timestamp": 1657264242131, + "version": "8.0.0" + }, + "pyarrow-8.0.0-py38h992f0b0_0.conda": { + "build": "py38h992f0b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=8.0.0,<8.0.1.0a0", + "arrow-cpp >=8.0.0,<9.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "snappy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "93ebbaf621a46b0777b865d89fb1e218", + "name": "pyarrow", + "sha256": "e92ab8f572cada591ea12f6c45c811f64b59ddc1d2015ea3d2c62e390bb91f1c", + "size": 2751982, + "subdir": "linux-64", + "timestamp": 1657264577008, + "version": "8.0.0" + }, + "pyarrow-8.0.0-py39h992f0b0_0.conda": { + "build": "py39h992f0b0_0", + "build_number": 0, + "depends": [ + "arrow-cpp >=8.0.0,<8.0.1.0a0", + "arrow-cpp >=8.0.0,<9.0a0", + "boost-cpp", + "gflags", + "glog", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "snappy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "51e0f4699672dceacce943e59752448b", + "name": "pyarrow", + "sha256": "c3a7edfbb06ecfda6ba79aaa96906c2fc0217f72ec40336a98aa0f6d8d082727", + "size": 2765157, + "subdir": "linux-64", + "timestamp": 1657264915458, + "version": "8.0.0" + }, + "pyasn1-0.3.7-py27haf6b024_0.conda": { + "build": "py27haf6b024_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "79d604b3b78e0dcbe8f6658503fd1052", + "name": "pyasn1", + "sha256": "0ba13e048d93643c5c91df5da6b0b70fa4e90f2bd8cdcf7f7e06a0edb3f1af40", + "size": 96271, + "subdir": "linux-64", + "timestamp": 1507699147990, + "version": "0.3.7" + }, + "pyasn1-0.3.7-py35h2fee745_0.conda": { + "build": "py35h2fee745_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a617cc148ee3e3cd47872de7eadda27c", + "name": "pyasn1", + "sha256": "a2088abb02de46770d205ab51eef5ee5902e6f005e3bd6378e4a6271b3573a3e", + "size": 99966, + "subdir": "linux-64", + "timestamp": 1507699158410, + "version": "0.3.7" + }, + "pyasn1-0.3.7-py36h0f28794_0.conda": { + "build": "py36h0f28794_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "076fa5c3962f84604f013fa88a06b886", + "name": "pyasn1", + "sha256": "33988b63d4aaf49a1e0048f4fa17806fc680d021cfd5d7639dbcb5233463bafc", + "size": 98721, + "subdir": "linux-64", + "timestamp": 1507699160557, + "version": "0.3.7" + }, + "pyasn1-0.4.2-py27h1564b0d_0.conda": { + "build": "py27h1564b0d_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ef723a8b92884e40cce2db12bb40ebaa", + "name": "pyasn1", + "sha256": "c172c2bfdfec9286ee5a66ff4a1d9e205c00e0866c69436316572cac892db106", + "size": 103764, + "subdir": "linux-64", + "timestamp": 1512020060836, + "version": "0.4.2" + }, + "pyasn1-0.4.2-py35h8f845f4_0.conda": { + "build": "py35h8f845f4_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9cbcb5db1b0aef81243c5e07173b8f98", + "name": "pyasn1", + "sha256": "b248812a999a52b8cd4588c0a6fc15e5a759dfd01e4fb964e80bf39581b2e452", + "size": 107193, + "subdir": "linux-64", + "timestamp": 1512020078577, + "version": "0.4.2" + }, + "pyasn1-0.4.2-py36h4d1db45_0.conda": { + "build": "py36h4d1db45_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "41a9f13cad3c583396e422c5d69373ce", + "name": "pyasn1", + "sha256": "4a9d4903bc36bf4c78454da1e75209dbabe0c2347c09fdcf59d12d2a9c952f6e", + "size": 104824, + "subdir": "linux-64", + "timestamp": 1512020073821, + "version": "0.4.2" + }, + "pyasn1-0.4.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b9ab961b0228881cec9cc066dd3f54ad", + "name": "pyasn1", + "sha256": "510095c3837ceaccc5d7e0162ab3b3029f682211e2345d3e580339395dc9ce55", + "size": 101771, + "subdir": "linux-64", + "timestamp": 1527630313230, + "version": "0.4.3" + }, + "pyasn1-0.4.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "209a65e277b9601f7b5717c1350fa952", + "name": "pyasn1", + "sha256": "1610bdb65abb2d197b110ab18f54a6944ef1ece87da7c599146f48ad53c46471", + "size": 106732, + "subdir": "linux-64", + "timestamp": 1527630331626, + "version": "0.4.3" + }, + "pyasn1-0.4.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7e563b388e16a20caf87e5dc5e1ce3ad", + "name": "pyasn1", + "sha256": "63ae55e20ef4754d4a0de8edc560359202a8788276364d77907e7bf20794135c", + "size": 104325, + "subdir": "linux-64", + "timestamp": 1527630287450, + "version": "0.4.3" + }, + "pyasn1-0.4.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "80664fec0a4e501ceaa475b738594950", + "name": "pyasn1", + "sha256": "b2c955b39e1f5ab80eca27547d77145cc6dade7bbe8b291f5f8ccd87ebc24f85", + "size": 104419, + "subdir": "linux-64", + "timestamp": 1530875982901, + "version": "0.4.3" + }, + "pyasn1-0.4.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3031fb36d1829cb15a41eb7f6271338c", + "name": "pyasn1", + "sha256": "1473a538f64b1d2e5f5075f6d4ead57bae91ea60addeeae12512842b95cfeb26", + "size": 103758, + "subdir": "linux-64", + "timestamp": 1532994013386, + "version": "0.4.4" + }, + "pyasn1-0.4.4-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a890714400d86b8a85c7dddabb5cc652", + "name": "pyasn1", + "sha256": "0cafde22d76db5e156ec0902e654ef997247dec770689b60fb63744e3dea0cbf", + "size": 102189, + "subdir": "linux-64", + "timestamp": 1534351048068, + "version": "0.4.4" + }, + "pyasn1-0.4.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "525296768f65165509e48c748bbdef91", + "name": "pyasn1", + "sha256": "82da69b4c8c8b37fb91c4e98c364a420b421136924d316a731e8a885a2ec18e7", + "size": 107293, + "subdir": "linux-64", + "timestamp": 1532994016677, + "version": "0.4.4" + }, + "pyasn1-0.4.4-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f9bb056bbf25da39e48625df2a41aaa6", + "name": "pyasn1", + "sha256": "236a91907f4413a3e399849e4b4e9062c5a8b4351d158e16bf7f622d41fc74d9", + "size": 107260, + "subdir": "linux-64", + "timestamp": 1534351071898, + "version": "0.4.4" + }, + "pyasn1-0.4.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c36fa2cba8679305bbfccb3385252c07", + "name": "pyasn1", + "sha256": "aa58b4fd82f5ba499439a8d67dd859db68c040011d6f8f8a9763d55abd71c4cc", + "size": 104608, + "subdir": "linux-64", + "timestamp": 1532993933710, + "version": "0.4.4" + }, + "pyasn1-0.4.4-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "16aaadb0f08fe3f85195102626ffb2bd", + "name": "pyasn1", + "sha256": "7e353b4a5aae47528e563d845ae117a20f271081045c8678c8dd07f5c0f44ce6", + "size": 104616, + "subdir": "linux-64", + "timestamp": 1534351096601, + "version": "0.4.4" + }, + "pyasn1-0.4.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a75f55eaddfe522454b1c3b25e416db6", + "name": "pyasn1", + "sha256": "8ef2f12a08f0ec9a2b29fe35f3765a59f9e56a0f4a28e80a8e688372f59b3b1c", + "size": 104853, + "subdir": "linux-64", + "timestamp": 1532994161555, + "version": "0.4.4" + }, + "pyasn1-0.4.4-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "2e3b2ea2eb613ea2d75e9d47f721ba26", + "name": "pyasn1", + "sha256": "e8551d85a511e0c376cae495e78b686e636b07f01000871e8964bfaa71139d3e", + "size": 104834, + "subdir": "linux-64", + "timestamp": 1534351025433, + "version": "0.4.4" + }, + "pyasn1-modules-0.2.1-py27h997e151_0.conda": { + "build": "py27h997e151_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "de3759eb3c3708eb5b67d0729f13a21d", + "name": "pyasn1-modules", + "sha256": "f2000d3ad652c9247e1c3fea51953ce8581f7ea72bd2c96d26aceef327fbe12f", + "size": 92039, + "subdir": "linux-64", + "timestamp": 1512021376366, + "version": "0.2.1" + }, + "pyasn1-modules-0.2.1-py35h00c9b8e_0.conda": { + "build": "py35h00c9b8e_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "60ae35f33b972b6df8f4411daf885cdc", + "name": "pyasn1-modules", + "sha256": "d372e292b184690eba27bcb9ff55bca74a0264324fad341e8228cc42d1181aff", + "size": 94220, + "subdir": "linux-64", + "timestamp": 1512021423900, + "version": "0.2.1" + }, + "pyasn1-modules-0.2.1-py36hc893066_0.conda": { + "build": "py36hc893066_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "52068d92d4a25bb337c876fb91f769f0", + "name": "pyasn1-modules", + "sha256": "daa91cbab8d54f23d3d222dc4719ff617bc4b8f2425932685b9e88e8d8fa8f71", + "size": 92260, + "subdir": "linux-64", + "timestamp": 1512021426347, + "version": "0.2.1" + }, + "pyasn1-modules-0.2.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e495065fbefb6c94c2c74eef00e39390", + "name": "pyasn1-modules", + "sha256": "695527885d5bf2dabfbef91705d1f8b457e04c66582455b68d5555a5baa1037f", + "size": 92478, + "subdir": "linux-64", + "timestamp": 1530555748057, + "version": "0.2.2" + }, + "pyasn1-modules-0.2.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f8581b3a7a50afcc7a73aa865aa57593", + "name": "pyasn1-modules", + "sha256": "a8498f1275e3fb25dbe7d1810a8e88b536d9ca2ca36eff774182aa794eacc066", + "size": 93491, + "subdir": "linux-64", + "timestamp": 1530555730388, + "version": "0.2.2" + }, + "pyasn1-modules-0.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "cc216406fdaad24374d936f287cecc0a", + "name": "pyasn1-modules", + "sha256": "2af21f239a44c15014fd31208cfb32e91114fba4b48c92c0a63aa256ccdfb760", + "size": 93986, + "subdir": "linux-64", + "timestamp": 1530555725302, + "version": "0.2.2" + }, + "pyasn1-modules-0.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e227b52080897f6bd7dca1190b518dc6", + "name": "pyasn1-modules", + "sha256": "9cdb6c79347acd808b73fad66231ebcefcf2dc778e20757254626fa635b974c0", + "size": 93134, + "subdir": "linux-64", + "timestamp": 1530906503510, + "version": "0.2.2" + }, + "pyasn1-modules-0.2.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "25ea9165e7056afbe4fb37fab069a3dd", + "name": "pyasn1-modules", + "sha256": "d140b83ea1f68811e3e4ca54c3d75fae2374b2806f33e98cb237bb49688bf024", + "size": 95941, + "subdir": "linux-64", + "timestamp": 1547247284016, + "version": "0.2.3" + }, + "pyasn1-modules-0.2.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "6ddef45afcd7538d33ade1124f60c7ca", + "name": "pyasn1-modules", + "sha256": "441d309f5171d2b2d579a9edf89a7bb6d40da7b61b9b88e42afd4052e78f864c", + "size": 96354, + "subdir": "linux-64", + "timestamp": 1547247310354, + "version": "0.2.3" + }, + "pyasn1-modules-0.2.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b0c9734c2d93dd68983abb57f98dddcf", + "name": "pyasn1-modules", + "sha256": "ba263667cb07a96bd5e7962bdf240e6e2986e113e277cc8b5535ab207fa0648f", + "size": 96859, + "subdir": "linux-64", + "timestamp": 1547247312605, + "version": "0.2.3" + }, + "pyasn1-modules-0.2.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "57be1351cb2f38d607dcb56a118a422d", + "name": "pyasn1-modules", + "sha256": "47d173f374c778a001760e10969dcd4d7ab218c61a21dcdcd93ac132acd1418b", + "size": 97791, + "subdir": "linux-64", + "timestamp": 1550351773780, + "version": "0.2.4" + }, + "pyasn1-modules-0.2.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "72107d83b895e843385971ed2a9eb2fe", + "name": "pyasn1-modules", + "sha256": "5ef5df25cc40ab7dce034266f80f9e7b6974b43ad88a145bbf2d7bdc9c2b29f0", + "size": 99073, + "subdir": "linux-64", + "timestamp": 1550351801685, + "version": "0.2.4" + }, + "pyasn1-modules-0.2.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4e9a38ff515f3a1cd804793dc9f8822e", + "name": "pyasn1-modules", + "sha256": "0fb87b5905b98ad5767891ade0c1f00e8874fa75d4b408673ee125304cf0bbe5", + "size": 98447, + "subdir": "linux-64", + "timestamp": 1550351714947, + "version": "0.2.4" + }, + "pyasn1-modules-0.2.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "baab91602c0685b494b8708aaf912e10", + "name": "pyasn1-modules", + "sha256": "cd9fb3a2a914d2968f9a700e7111471b4244879412be098499a349c2086405a7", + "size": 126471, + "subdir": "linux-64", + "timestamp": 1564681994673, + "version": "0.2.6" + }, + "pyasn1-modules-0.2.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4891250e9c728ed4ac1da9f6673ff4c6", + "name": "pyasn1-modules", + "sha256": "84ad13cf7e9ca219ae16b0fcfe41d50f11cb143cc440f97e30e0f964044e12e8", + "size": 128768, + "subdir": "linux-64", + "timestamp": 1564682099461, + "version": "0.2.6" + }, + "pyasn1-modules-0.2.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "748a17694fdb0e8fd44a12b33cd3a635", + "name": "pyasn1-modules", + "sha256": "c8696f5d70ccffc351213fc9423e6bce56401ffc31e9d8f4872c400a5f30652c", + "size": 127662, + "subdir": "linux-64", + "timestamp": 1564681973092, + "version": "0.2.6" + }, + "pyasn1-modules-0.2.6-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.4.1,<0.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "553bd9d04593ca1c847d49744b320762", + "name": "pyasn1-modules", + "sha256": "61d72c03feb0df69a36d9f7565bc08e43df7b4c6fddc4673b5d63e8c37f19709", + "size": 127107, + "subdir": "linux-64", + "timestamp": 1573469696231, + "version": "0.2.6" + }, + "pyaudio-0.2.11-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "49e5508211810ae481c2b351131f120a", + "name": "pyaudio", + "sha256": "507d24dc7181682bdfcafd2ae606fc23ff07dbce0f2dc0d4189aeeaa4228af15", + "size": 64202, + "subdir": "linux-64", + "timestamp": 1530915515954, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py27h14c3975_1.conda": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "portaudio", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c94c12084d286eae3bd24767bd6503fa", + "name": "pyaudio", + "sha256": "499331bca4de2961378be70f4acac7f2a863cead91229932161b5e897dd37e25", + "size": 64817, + "subdir": "linux-64", + "timestamp": 1533481567078, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py27h7b6447c_2.conda": { + "build": "py27h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "portaudio", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "4586da5fb259084f37a7e57ef5280b4a", + "name": "pyaudio", + "sha256": "542b0cebab2fc8a35687745b2e97bb74bfd26b165a39aa957758f069abcc38cb", + "size": 209407, + "subdir": "linux-64", + "timestamp": 1584482883206, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py310h7f8727e_2.conda": { + "build": "py310h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "portaudio", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "0f7e3dd1beeddcda1867361949b24a1d", + "name": "pyaudio", + "sha256": "48158f4d6cf395d78c264e8dc7c69276adc0790eda5ad33d6151e000a2e9ee2a", + "size": 56974, + "subdir": "linux-64", + "timestamp": 1640792717845, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py311h5eee18b_2.conda": { + "build": "py311h5eee18b_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "portaudio", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "1b5d6f0e26137037325cc5915e005450", + "name": "pyaudio", + "sha256": "e9a911f15427ff4c6949a1e80f49f33b8cb97da7b4a82b98aec449d784ef21ea", + "size": 33889, + "subdir": "linux-64", + "timestamp": 1676907521780, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py35h14c3975_1.conda": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "portaudio", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "2ef63900bd3e329383526b3a57784e69", + "name": "pyaudio", + "sha256": "5808504ca2d8b2da51c86fb351ab45ee4b9307530ad68fa0a668d75dcd224716", + "size": 65140, + "subdir": "linux-64", + "timestamp": 1533481569057, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "fc2e7c6737f4bb8a289acb675301a661", + "name": "pyaudio", + "sha256": "47ad5235b0c9b4f37e7d8bbaad2e611266549d6695ee4996e84a838553bf99f3", + "size": 64069, + "subdir": "linux-64", + "timestamp": 1530906693981, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py36h14c3975_1.conda": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "portaudio", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c240de3c7e1c3519afe0c82cbeb613cd", + "name": "pyaudio", + "sha256": "785db98ce29a6ad48a32310afabc1031af45ca2f26a7899c3e5b9aada3e2f4df", + "size": 64913, + "subdir": "linux-64", + "timestamp": 1533481488544, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py36h7b6447c_2.conda": { + "build": "py36h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "portaudio", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a0b520ada9f4af479ff76e699d377234", + "name": "pyaudio", + "sha256": "fe151f1cdaf41f9704ae44ae4e362352a376fca1f234da6467e514ad69f31c20", + "size": 209945, + "subdir": "linux-64", + "timestamp": 1584480229141, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5f084d0910a5f1613aa10b8b5b289492", + "name": "pyaudio", + "sha256": "05829b471d7cf90bbe35cd9b93e3f304a48f1a2d4746a33bfb172ecaef8aef05", + "size": 64149, + "subdir": "linux-64", + "timestamp": 1530906723118, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py37h14c3975_1.conda": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "portaudio", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "29e40e9adad17072dbdfe71278a1db99", + "name": "pyaudio", + "sha256": "341d5068d26232ddaff0ede59c5df59f2f8cf47293880b6e56a996508cdef437", + "size": 64906, + "subdir": "linux-64", + "timestamp": 1533481690025, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py37h7b6447c_2.conda": { + "build": "py37h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "portaudio", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "0e585992224d91cfe968a93fa66ce6e1", + "name": "pyaudio", + "sha256": "c0b6fa14446a612adcadb4ce61741a00ad0b42005818092e92691329992e7925", + "size": 210583, + "subdir": "linux-64", + "timestamp": 1584480220237, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "portaudio", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "58aecd506c02c6e00a4e0a15d2b96111", + "name": "pyaudio", + "sha256": "c6eee31c5fa4e6198e596233b3c984e9e21ace626e72870091f50c1baa5ba7bc", + "size": 73750, + "subdir": "linux-64", + "timestamp": 1573662654233, + "version": "0.2.11" + }, + "pyaudio-0.2.11-py38h7b6447c_2.conda": { + "build": "py38h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "portaudio", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "cc0a09ad64cec8072cc9d0eed0a498a1", + "name": "pyaudio", + "sha256": "8ec4ef5e7bcbad1924e74d01a11569e537c024cb346fd4df22cd39b11a6b432b", + "size": 210059, + "subdir": "linux-64", + "timestamp": 1584480242358, + "version": "0.2.11" + }, + "pybind11-2.10.1-py310hdb19cb5_0.conda": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pybind11-global 2.10.1 py310hdb19cb5_0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d763e1832b619b66da72ac9002f50668", + "name": "pybind11", + "sha256": "63978e8ad120ab63f0192d9de8dac514eb19a03496dbace28e0d17b7e34483d1", + "size": 183729, + "subdir": "linux-64", + "timestamp": 1668512310349, + "version": "2.10.1" + }, + "pybind11-2.10.1-py311hdb19cb5_0.conda": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pybind11-global 2.10.1 py311hdb19cb5_0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7cd3f2c27a0d5e634c2fe8f416b90999", + "name": "pybind11", + "sha256": "94c3431455b4150efb62b6539e29f902b856301838a087c2ec93b8e987cdcb72", + "size": 177677, + "subdir": "linux-64", + "timestamp": 1676825114502, + "version": "2.10.1" + }, + "pybind11-2.10.1-py37hdb19cb5_0.conda": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pybind11-global 2.10.1 py37hdb19cb5_0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8684383fd7f1f9ed06baa112ced7a5d5", + "name": "pybind11", + "sha256": "96f30120ea79147ab98dd3eab8b11d0977bcc024ae736dbcc55b379aad85aa6f", + "size": 183356, + "subdir": "linux-64", + "timestamp": 1668512294566, + "version": "2.10.1" + }, + "pybind11-2.10.1-py38hdb19cb5_0.conda": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pybind11-global 2.10.1 py38hdb19cb5_0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8bca78d01852e7121ac7678e0e014786", + "name": "pybind11", + "sha256": "e785c43528c230542cf0caa5f1a00b501a8e2522ec75f63687408ffd38144bf5", + "size": 183483, + "subdir": "linux-64", + "timestamp": 1668512341407, + "version": "2.10.1" + }, + "pybind11-2.10.1-py39hdb19cb5_0.conda": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pybind11-global 2.10.1 py39hdb19cb5_0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85598615522dfc57d0d687b94579874d", + "name": "pybind11", + "sha256": "80667427a6a495d809cd29a88cf39a9ce02dec879ec7a31149bbb5ef9a992c8e", + "size": 183463, + "subdir": "linux-64", + "timestamp": 1668512325930, + "version": "2.10.1" + }, + "pybind11-2.2.3-py27hfd86e86_0.conda": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8a04329c88c961adc8ff9d6d6918e9de", + "name": "pybind11", + "sha256": "c9b85336358cc6a3a6062e438add0fa8e7e3a48d09cd543482179979efde63a3", + "size": 120985, + "subdir": "linux-64", + "timestamp": 1536510858912, + "version": "2.2.3" + }, + "pybind11-2.2.3-py35hfd86e86_0.conda": { + "build": "py35hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "90dc68ec2625d326dfd083bbeaae82d5", + "name": "pybind11", + "sha256": "5042b53c032e6e1408cd9617f4b63d56e3e287e051804d78d199aa10cd1d2e09", + "size": 121041, + "subdir": "linux-64", + "timestamp": 1536510910109, + "version": "2.2.3" + }, + "pybind11-2.2.3-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c4df3d55b41fa87b5c4b55626c64a560", + "name": "pybind11", + "sha256": "4acfcf5c5ca7c150ae632e84a2fbe6f03bb3fb81a4112c2782c1b509cff1f5b3", + "size": 121025, + "subdir": "linux-64", + "timestamp": 1536510993256, + "version": "2.2.3" + }, + "pybind11-2.2.3-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0c71a8281fa5f59d076b0834405316ed", + "name": "pybind11", + "sha256": "0902d68859f1e933b29b2ed3fcf26bbb52d75ac0793046d2e928aa70e2aeded0", + "size": 120975, + "subdir": "linux-64", + "timestamp": 1536510822610, + "version": "2.2.3" + }, + "pybind11-2.2.4-py27hfd86e86_0.conda": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "06064ac55ac02db369b2728ab54146ee", + "name": "pybind11", + "sha256": "c33ed7925bd93d02e703bf570f298adf7bdd5a9eba9402380f6ff27ece56c4e7", + "size": 121670, + "subdir": "linux-64", + "timestamp": 1539658007441, + "version": "2.2.4" + }, + "pybind11-2.2.4-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8cf1af28c5c41393cf95ea4cd2ccc8dd", + "name": "pybind11", + "sha256": "df3a978a366de4f2d9ee47979e05aa3e723dd747f0a91b0e35f827c9b99a8b0a", + "size": 121694, + "subdir": "linux-64", + "timestamp": 1539658034601, + "version": "2.2.4" + }, + "pybind11-2.2.4-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b5efcfc8eb253228c4f1249a6d9bbc52", + "name": "pybind11", + "sha256": "7ee3dd52b2a18bcea3cafd6ba9624d1e5bdcf5264ef8c3498616cc7d83665e08", + "size": 121601, + "subdir": "linux-64", + "timestamp": 1539658018456, + "version": "2.2.4" + }, + "pybind11-2.4.2-py27hfd86e86_0.conda": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9c627491af4e0221e4154f75887b2943", + "name": "pybind11", + "sha256": "edd7fda625c6460aeb038adfbac57483c7b30df01c55492e581ead8e346e5cd8", + "size": 130274, + "subdir": "linux-64", + "timestamp": 1569426205840, + "version": "2.4.2" + }, + "pybind11-2.4.2-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "52deae3fcfd5c8571f26583080f6c57b", + "name": "pybind11", + "sha256": "25080d7032ba54172432e56354734c12ad5dc9d7c0b3b1e08223a6ba19a118ea", + "size": 130277, + "subdir": "linux-64", + "timestamp": 1569426177414, + "version": "2.4.2" + }, + "pybind11-2.4.2-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e871a3c340d570e214d655d9d6a3c147", + "name": "pybind11", + "sha256": "32bfdd511e724df91727a22ec9d6b77e82650178dcaaf544950439bfcbf78984", + "size": 130275, + "subdir": "linux-64", + "timestamp": 1569426202685, + "version": "2.4.2" + }, + "pybind11-2.4.2-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b47c375cb726f04c9b0841c6ec19ecdb", + "name": "pybind11", + "sha256": "b496fa76620b67652db4358967ff908431f3bbedf979438225b9c7c1afaa7e8f", + "size": 133617, + "subdir": "linux-64", + "timestamp": 1573662685529, + "version": "2.4.2" + }, + "pybind11-2.4.3-py27hfd86e86_0.conda": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d264928c07cb1671b8c916c9b3210ea9", + "name": "pybind11", + "sha256": "60886e9dfd67a8c8e34b1743706ea7af2de8fec52d136f5e2c392e5260eed804", + "size": 130620, + "subdir": "linux-64", + "timestamp": 1573970600933, + "version": "2.4.3" + }, + "pybind11-2.4.3-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f82a9a2c9b1c9760c8f42a43c4ebcc29", + "name": "pybind11", + "sha256": "42e5ff256862acc67a40b3153f54156cdd8faebee656563167947bef4bfce06c", + "size": 130643, + "subdir": "linux-64", + "timestamp": 1573970574341, + "version": "2.4.3" + }, + "pybind11-2.4.3-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9e2cd640571851ed2528f5a8dc961331", + "name": "pybind11", + "sha256": "e79a30cbd36513d6c27aaf54ee850d904ede09f3b87c2528d11457ac0d7a8d5b", + "size": 130637, + "subdir": "linux-64", + "timestamp": 1573970584192, + "version": "2.4.3" + }, + "pybind11-2.4.3-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d19d9e8b6cf48ca977071ff24b08fb02", + "name": "pybind11", + "sha256": "b5737c7dbed39a28d8e2546a207469c7fcf3d8d0a81f0529a3f5e56bdfb91eb0", + "size": 137261, + "subdir": "linux-64", + "timestamp": 1573970614238, + "version": "2.4.3" + }, + "pybind11-2.5.0-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e56c55a47bc4c01e5f5a3cf01e767922", + "name": "pybind11", + "sha256": "12fc24e4f93f9b809ca64be9e2921f9d494b363855a568bd939c642fbe825acc", + "size": 138179, + "subdir": "linux-64", + "timestamp": 1595273568877, + "version": "2.5.0" + }, + "pybind11-2.5.0-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "77587fcfdb20b69639a2e08c087ec7a8", + "name": "pybind11", + "sha256": "e4b719335865af45b5ba7099361884de44e6409e80c5e1ff79e05213ef9c0043", + "size": 138170, + "subdir": "linux-64", + "timestamp": 1595274121409, + "version": "2.5.0" + }, + "pybind11-2.5.0-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "48bab838938632e3bcdf23e942b060ff", + "name": "pybind11", + "sha256": "8cf779b45e1b321602ee0f31365144cc856f8ee356fc38d41bc0f264f2fd55da", + "size": 137880, + "subdir": "linux-64", + "timestamp": 1595274109313, + "version": "2.5.0" + }, + "pybind11-2.5.0-py39hff7bd54_1.conda": { + "build": "py39hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "11e5ddec32f0a2cdae641b919f1a9a80", + "name": "pybind11", + "sha256": "87a9e074c357924a13980efb1cfd8cd899a5dfa0fb33f5d245f797c86082f45d", + "size": 137332, + "subdir": "linux-64", + "timestamp": 1607613286833, + "version": "2.5.0" + }, + "pybind11-2.6.2-py36hff7bd54_1.conda": { + "build": "py36hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "29d10309a00cced6b471f7f49ebe572f", + "name": "pybind11", + "sha256": "55fb63f8621fb8e0d9a06595ef49f26630c59453e0096bbb51ea58320ed412f9", + "size": 156893, + "subdir": "linux-64", + "timestamp": 1621869757013, + "version": "2.6.2" + }, + "pybind11-2.6.2-py37hff7bd54_1.conda": { + "build": "py37hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "424e82006ea896c2fdd65dec0cff8ec4", + "name": "pybind11", + "sha256": "7a5d51d8f7ac4863b25f440f4b82363632edffba83595305cea45ab712ba873b", + "size": 157498, + "subdir": "linux-64", + "timestamp": 1621865107627, + "version": "2.6.2" + }, + "pybind11-2.6.2-py38hff7bd54_1.conda": { + "build": "py38hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e71d0352cb89a645a5f4df4f047c13af", + "name": "pybind11", + "sha256": "73d7f37707f5391444382bd1175f01ef3e0c17ee20f692e2528bb1f822b404ec", + "size": 157712, + "subdir": "linux-64", + "timestamp": 1621869965988, + "version": "2.6.2" + }, + "pybind11-2.6.2-py39hff7bd54_1.conda": { + "build": "py39hff7bd54_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "37d9b0b49834020dadf5bae686b40215", + "name": "pybind11", + "sha256": "904a17c17a76951f01976d4de74fcbc98132a7da330cd51b2472c7219d3b6872", + "size": 157376, + "subdir": "linux-64", + "timestamp": 1621869954156, + "version": "2.6.2" + }, + "pybind11-2.7.0-py310hd09550d_1.conda": { + "build": "py310hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2dc55313ce3ac700edaa21c659238ebb", + "name": "pybind11", + "sha256": "15d04a13f34abface645f515e7428e4734922728ba8710bc24038e8a1fc78871", + "size": 163002, + "subdir": "linux-64", + "timestamp": 1640792745049, + "version": "2.7.0" + }, + "pybind11-2.7.0-py36hd09550d_1.conda": { + "build": "py36hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1357b7ecf3b700ec6bad1dcdeaf5ae7d", + "name": "pybind11", + "sha256": "32022fee8c4a8b881a6eda3760544aa81126538c1868d127001f044a906bfa21", + "size": 162147, + "subdir": "linux-64", + "timestamp": 1627054043127, + "version": "2.7.0" + }, + "pybind11-2.7.0-py37hd09550d_1.conda": { + "build": "py37hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "369224de976aa87dede638f83792410f", + "name": "pybind11", + "sha256": "d3bbeb5cc051138443fe4c30a505597acf572469791a3f9a7f781190c64cba7e", + "size": 161959, + "subdir": "linux-64", + "timestamp": 1627061497506, + "version": "2.7.0" + }, + "pybind11-2.7.0-py38hd09550d_1.conda": { + "build": "py38hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7f901c58412d60368bbe66ee4383a14c", + "name": "pybind11", + "sha256": "dabeb5f7e744e8d1d697f30dab8641340e8e789af6d53cfb7204a619a44a28d7", + "size": 162301, + "subdir": "linux-64", + "timestamp": 1627061498816, + "version": "2.7.0" + }, + "pybind11-2.7.0-py39hd09550d_1.conda": { + "build": "py39hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f5f620e61749ae91714e7d08c5f335da", + "name": "pybind11", + "sha256": "cdb0b1bdbadc522a3a95ed04d89b187dd798333db9e4efc3d3e9dfb67989f395", + "size": 162514, + "subdir": "linux-64", + "timestamp": 1627061511421, + "version": "2.7.0" + }, + "pybind11-2.8.1-py37hd09550d_0.conda": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1cdf9f92dedd506db5992f9811e23917", + "name": "pybind11", + "sha256": "5e9a8b5ac7c143eaf02c4e283a4eff4ea6109f17728e644863758df36bb65833", + "size": 172834, + "subdir": "linux-64", + "timestamp": 1638777346026, + "version": "2.8.1" + }, + "pybind11-2.8.1-py38hd09550d_0.conda": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "19f9908c96cebad16d5c6a3d463d2c42", + "name": "pybind11", + "sha256": "6d05abe21b5afd57114315000e46f4f7ff6f5838bb08cda7dd00f1897bdd9177", + "size": 172713, + "subdir": "linux-64", + "timestamp": 1638795463877, + "version": "2.8.1" + }, + "pybind11-2.8.1-py39hd09550d_0.conda": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7f6d9b09ee04640684c7198bf3516d37", + "name": "pybind11", + "sha256": "dba3164abf466b4af40d6bfa0d02fd20bf2e3952ff45a735ac383d25ad568bf9", + "size": 172902, + "subdir": "linux-64", + "timestamp": 1638795472356, + "version": "2.8.1" + }, + "pybind11-2.9.1-py310h2571103_0.conda": { + "build": "py310h2571103_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ea4e2759bbca9f5aa851fbaf122051a4", + "name": "pybind11", + "sha256": "31e1b4065840b79ef9c0121d7e866f0baca1cdc414254f56314d2fc636da1692", + "size": 176463, + "subdir": "linux-64", + "timestamp": 1646325328343, + "version": "2.9.1" + }, + "pybind11-2.9.1-py37hae6d005_0.conda": { + "build": "py37hae6d005_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "31df19f5866bf6a8161f1cc6accf274c", + "name": "pybind11", + "sha256": "ccfe745c12cd65e5a4aac5d3fbc643588fccc06c381854b67b3aa96babb74b49", + "size": 178235, + "subdir": "linux-64", + "timestamp": 1646308126914, + "version": "2.9.1" + }, + "pybind11-2.9.1-py38hae6d005_0.conda": { + "build": "py38hae6d005_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dc5b426a8e17871183501a3adb6d997b", + "name": "pybind11", + "sha256": "172fb38f535da1ba7b6c8cc4314f4389652a3949af8d6f185a9624ab402578f4", + "size": 178075, + "subdir": "linux-64", + "timestamp": 1646307197943, + "version": "2.9.1" + }, + "pybind11-2.9.1-py39hae6d005_0.conda": { + "build": "py39hae6d005_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d2980cc146cfe13e9a48cc96ed09a2f5", + "name": "pybind11", + "sha256": "265ac765410298e57bb66a585640d554693093ab3ad5d9b3fa254ae88fc5cdaf", + "size": 178101, + "subdir": "linux-64", + "timestamp": 1646325340448, + "version": "2.9.1" + }, + "pybind11-2.9.2-py310h3c18c91_0.conda": { + "build": "py310h3c18c91_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d67a865d7cd6f13cac44f0158ccdf575", + "name": "pybind11", + "sha256": "a0662c7ffb3f68a454b0b730a4638eba4952d4a5747ae9f4e6004e084a01fd22", + "size": 171613, + "subdir": "linux-64", + "timestamp": 1661448098701, + "version": "2.9.2" + }, + "pybind11-2.9.2-py37h79cecc1_0.conda": { + "build": "py37h79cecc1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fea29dd54e334d53ae5b59f5e68cbea6", + "name": "pybind11", + "sha256": "1fc67f45d7313d448a4f56b98762213e81b8baae5d013e36b7cd73604d31e100", + "size": 173866, + "subdir": "linux-64", + "timestamp": 1661447361907, + "version": "2.9.2" + }, + "pybind11-2.9.2-py38h79cecc1_0.conda": { + "build": "py38h79cecc1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "91bea5ceea2e2eae971976bee43a2b36", + "name": "pybind11", + "sha256": "4d2e5d0b1d9b911e1bb059500336b4d827c205955a33e3659fcfe6fd07144280", + "size": 173863, + "subdir": "linux-64", + "timestamp": 1661447604951, + "version": "2.9.2" + }, + "pybind11-2.9.2-py39h79cecc1_0.conda": { + "build": "py39h79cecc1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9f1d448c1502d2dbb8b050dfb69a010e", + "name": "pybind11", + "sha256": "c947155e1e1131b2fd936c72420c1671887677d31acf467da1d4a8c20a2d264d", + "size": 173690, + "subdir": "linux-64", + "timestamp": 1661447853546, + "version": "2.9.2" + }, + "pybind11-global-2.10.1-py310hdb19cb5_0.conda": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d001bcd3904d7d6efcdf5ccbc7f3edb7", + "name": "pybind11-global", + "sha256": "bd1b3d327ad584ac63139eabffeaf9d3fb4ba6b10be2ab55fb49a75dfcaf2c7f", + "size": 172337, + "subdir": "linux-64", + "timestamp": 1668512247581, + "version": "2.10.1" + }, + "pybind11-global-2.10.1-py311hdb19cb5_0.conda": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "03a405bc6bafc233be8e4f32c18e38f0", + "name": "pybind11-global", + "sha256": "ce7ff50a74ea4362a9bed00ebf6374492f530ed45b700203db14f50290b95964", + "size": 163623, + "subdir": "linux-64", + "timestamp": 1676825101996, + "version": "2.10.1" + }, + "pybind11-global-2.10.1-py37hdb19cb5_0.conda": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5a540a77550996827160bd361c060052", + "name": "pybind11-global", + "sha256": "b294f352d373b8c6fe7009e4e9d0d698a5695b08561deeae77361e23e77b8f96", + "size": 172306, + "subdir": "linux-64", + "timestamp": 1668512231295, + "version": "2.10.1" + }, + "pybind11-global-2.10.1-py38hdb19cb5_0.conda": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8eceac5d56754214818e751e7c1b830a", + "name": "pybind11-global", + "sha256": "e2f02579c4efcde51760469fdf123ae46b355fe172518eb5a14622ad67a4cc76", + "size": 172328, + "subdir": "linux-64", + "timestamp": 1668512278985, + "version": "2.10.1" + }, + "pybind11-global-2.10.1-py39hdb19cb5_0.conda": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "constrains": [ + "pybind11-abi ==4" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3e0615f02be5358fbbfc639563190325", + "name": "pybind11-global", + "sha256": "6691fc8d0a04958f8102e31008c99e808fa51261372a002339422df5c5d68338", + "size": 172519, + "subdir": "linux-64", + "timestamp": 1668512263281, + "version": "2.10.1" + }, + "pycairo-1.13.3-py27h44fc0e4_1.conda": { + "build": "py27h44fc0e4_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.10,<2.0a0", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "7b62ddffc6efb28d58507dd075e54ffc", + "name": "pycairo", + "sha256": "8a2e24d770f69b26dd62670b3815bf6c7e263f1c9762973a9d1324af1a0bedd7", + "size": 52313, + "subdir": "linux-64", + "timestamp": 1510610244580, + "version": "1.13.3" + }, + "pycairo-1.13.3-py27hea6d626_0.conda": { + "build": "py27hea6d626_0", + "build_number": 0, + "depends": [ + "cairo 1.14.*", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "8ae1dac52b1146a5fe3f366573fd4bde", + "name": "pycairo", + "sha256": "46c32e1abfea96e472d6a9e4c6041ab76e2ae263fbc210fc9e41b2ad25700ccd", + "size": 51783, + "subdir": "linux-64", + "timestamp": 1505751289291, + "version": "1.13.3" + }, + "pycairo-1.13.3-py35h77ace0a_1.conda": { + "build": "py35h77ace0a_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.10,<2.0a0", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "2cc8f6b9834fa71802464f6ded1d45ec", + "name": "pycairo", + "sha256": "8f5cbc90dd9340424bb1d2b80017c6f50acdfab476ffc7c58b8e2b6408292450", + "size": 52794, + "subdir": "linux-64", + "timestamp": 1510610245931, + "version": "1.13.3" + }, + "pycairo-1.13.3-py36h8764da6_1.conda": { + "build": "py36h8764da6_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.10,<2.0a0", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "ae9ec6a7ab477690fde412581fa62c28", + "name": "pycairo", + "sha256": "27513514bb8205c2c325d2cc418d93fd88d8fe07f4049cc8fcbbbb2508aada4a", + "size": 52758, + "subdir": "linux-64", + "timestamp": 1510610243337, + "version": "1.13.3" + }, + "pycairo-1.15.4-py27h1b9232e_1.conda": { + "build": "py27h1b9232e_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.10,<2.0a0", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "8c879c398307a071783bad5f12fe707f", + "name": "pycairo", + "sha256": "471fdd5ffa347d25a7959bda7c8c1855e6624b5795b85279e8a1b253697d35ac", + "size": 64549, + "subdir": "linux-64", + "timestamp": 1515723963587, + "version": "1.15.4" + }, + "pycairo-1.15.4-py35h1b9232e_1.conda": { + "build": "py35h1b9232e_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.10,<2.0a0", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "8c97e0e11af53c542607fd70871914f1", + "name": "pycairo", + "sha256": "29f62df9155bb5cd73033ee2aa90a20c622a2e4294e2843166b7e90bd9aef952", + "size": 64843, + "subdir": "linux-64", + "timestamp": 1515723968008, + "version": "1.15.4" + }, + "pycairo-1.15.4-py36h1b9232e_1.conda": { + "build": "py36h1b9232e_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.10,<2.0a0", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "be9d9c409f58d3f023d2392da38c4b30", + "name": "pycairo", + "sha256": "842be906ad457b9325572aa92431df63e1ef515976620189dde602a2ad9c6232", + "size": 64906, + "subdir": "linux-64", + "timestamp": 1515723939461, + "version": "1.15.4" + }, + "pycairo-1.15.4-py37h1b9232e_1.conda": { + "build": "py37h1b9232e_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "d1126f16d76d99f3b40355e3098ee2bc", + "name": "pycairo", + "sha256": "38d7645e33856bbdb0c86d88b384a36b7f2b88116e2a2d325dfa95c3cd57b928", + "size": 64802, + "subdir": "linux-64", + "timestamp": 1530915555865, + "version": "1.15.4" + }, + "pycairo-1.17.1-py27h2a1e443_0.conda": { + "build": "py27h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "705ca55b23b81c1cf2486d877a0bba19", + "name": "pycairo", + "sha256": "ea4103cd7ab2244c1cf2551ab1f04009bf2353591b4662d10525b42b2f006120", + "size": 70515, + "subdir": "linux-64", + "timestamp": 1535474309628, + "version": "1.17.1" + }, + "pycairo-1.17.1-py35h2a1e443_0.conda": { + "build": "py35h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "9d8ae680228880aaa3c78acbb9386a6a", + "name": "pycairo", + "sha256": "6437c6c1493b6b2eadac90ff83d6e8c2ee7a241cc44a4e0d56d2365f4a042a52", + "size": 70651, + "subdir": "linux-64", + "timestamp": 1535474400887, + "version": "1.17.1" + }, + "pycairo-1.17.1-py36h2a1e443_0.conda": { + "build": "py36h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "7f3157d360765010fcb7973422f012ab", + "name": "pycairo", + "sha256": "0e22e75e26f91ac9f47c4baef03a08ea53e298cb9804d6000bb79ec08358c70b", + "size": 70688, + "subdir": "linux-64", + "timestamp": 1535474196292, + "version": "1.17.1" + }, + "pycairo-1.17.1-py37h2a1e443_0.conda": { + "build": "py37h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "36497ebd38551f035b44c57c0267f16a", + "name": "pycairo", + "sha256": "c1de0c25bed62bdf50fe10cae9184213a20269c56f7dea8ca772b43f378451ca", + "size": 70613, + "subdir": "linux-64", + "timestamp": 1535474402327, + "version": "1.17.1" + }, + "pycairo-1.18.0-py27h2a1e443_0.conda": { + "build": "py27h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "44a4d0172914e8e712497f30c61bc9db", + "name": "pycairo", + "sha256": "ed217b37d55bb4619cc54cec17b56bfa8eedf1d974e07f3689543fb36cb7bf3e", + "size": 71325, + "subdir": "linux-64", + "timestamp": 1541440813892, + "version": "1.18.0" + }, + "pycairo-1.18.0-py36h2a1e443_0.conda": { + "build": "py36h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "66611a117e98206f1de6782234b52c78", + "name": "pycairo", + "sha256": "93e3d72128df09155b5448be983c7594f59d5cbc947b523689e4d9d02cac867d", + "size": 71553, + "subdir": "linux-64", + "timestamp": 1541440813346, + "version": "1.18.0" + }, + "pycairo-1.18.0-py37h2a1e443_0.conda": { + "build": "py37h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "fd3248e11e815cbf5c830bf36a1bf33a", + "name": "pycairo", + "sha256": "782bef47da4aa14b0a581617aed5979b540fd7bc772637e61e37ce3d4170b40c", + "size": 71545, + "subdir": "linux-64", + "timestamp": 1541440788081, + "version": "1.18.0" + }, + "pycairo-1.18.1-py27h2a1e443_0.conda": { + "build": "py27h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "87e5abce446ba4edcd45e2bc17ee04d3", + "name": "pycairo", + "sha256": "dcece7b38fa1062b7d8acf2180f206f9e04edb5f2afbd1edcf13607f2aa89421", + "size": 72352, + "subdir": "linux-64", + "timestamp": 1555954983602, + "version": "1.18.1" + }, + "pycairo-1.18.1-py36h2a1e443_0.conda": { + "build": "py36h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "f42cdabbe9b0603d1d3aef6ea17fe781", + "name": "pycairo", + "sha256": "ec53eab7afb4e84d057ce975b4ad2bc5c88a578723777e052805067554d84afb", + "size": 72669, + "subdir": "linux-64", + "timestamp": 1555955003640, + "version": "1.18.1" + }, + "pycairo-1.18.1-py37h2a1e443_0.conda": { + "build": "py37h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "3a36a0cc4293b9c13daa8e0380fe10d9", + "name": "pycairo", + "sha256": "1ba8954fac168298f7906fb77902b7a67ef7fc20eb9bd5bac39c234a65ff2bd3", + "size": 72582, + "subdir": "linux-64", + "timestamp": 1555954992079, + "version": "1.18.1" + }, + "pycairo-1.18.2-py27h2a1e443_0.conda": { + "build": "py27h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "a9e8b8a4af7599214ad1788cc0cdce6e", + "name": "pycairo", + "sha256": "1a22799bfcd30394c70d780c6b2489281c47c6de8f2d5e4ca486c6e5d3a9cfd8", + "size": 73921, + "subdir": "linux-64", + "timestamp": 1573081357553, + "version": "1.18.2" + }, + "pycairo-1.18.2-py36h2a1e443_0.conda": { + "build": "py36h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "425c0c1476221487c017453dcca7c6ce", + "name": "pycairo", + "sha256": "098a72c6bf9fc7fe888a611cb168abadeb2a86c7959468855b05f63523b20010", + "size": 74045, + "subdir": "linux-64", + "timestamp": 1573081029073, + "version": "1.18.2" + }, + "pycairo-1.18.2-py37h2a1e443_0.conda": { + "build": "py37h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "668fbc8fd4fecf19b4adf6efa6089968", + "name": "pycairo", + "sha256": "b0d245b1f504748a4e6e5488c49aa54850d44e56535974e603940827713667d4", + "size": 73999, + "subdir": "linux-64", + "timestamp": 1573081382169, + "version": "1.18.2" + }, + "pycairo-1.18.2-py38h2a1e443_0.conda": { + "build": "py38h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "c05a0dd53a21c60dce45161f35d225a8", + "name": "pycairo", + "sha256": "32e37c9e65ce5dfd4754045843e14088422e70d30378fe82b012a79d09faa560", + "size": 74493, + "subdir": "linux-64", + "timestamp": 1573081554699, + "version": "1.18.2" + }, + "pycairo-1.19.0-py36h2a1e443_0.conda": { + "build": "py36h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "7e25363ac127eb41bd34887c434bb760", + "name": "pycairo", + "sha256": "841d0cfff32aa12e2a69cb79d480c7a9cf4defef4ff1cfb0c6491a10462097dc", + "size": 74243, + "subdir": "linux-64", + "timestamp": 1580838524187, + "version": "1.19.0" + }, + "pycairo-1.19.0-py37h2a1e443_0.conda": { + "build": "py37h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "c9ba48982f6180968ba817dd25d11d24", + "name": "pycairo", + "sha256": "0457019e40548cb3d7866247371f40d7b9b401fbdd9ea65d03dbc15f0c53d823", + "size": 75020, + "subdir": "linux-64", + "timestamp": 1580838500441, + "version": "1.19.0" + }, + "pycairo-1.19.0-py38h2a1e443_0.conda": { + "build": "py38h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "d60fec9e21ae8b177de11cec9194988d", + "name": "pycairo", + "sha256": "fa3b76fe74b87a5bde2aeadfcbab560a0e5206909104962ba067359666c3da53", + "size": 74503, + "subdir": "linux-64", + "timestamp": 1580838624031, + "version": "1.19.0" + }, + "pycairo-1.19.1-py310he41a700_0.conda": { + "build": "py310he41a700_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "0cd41a562929983e1c99bdbfa0b3ee0d", + "name": "pycairo", + "sha256": "4eeeb3e6b1c5450f8a51d98207cca3d0977766abacfdf1eb1a9efef7acf40816", + "size": 184148, + "subdir": "linux-64", + "timestamp": 1640792776581, + "version": "1.19.1" + }, + "pycairo-1.19.1-py36h2a1e443_0.conda": { + "build": "py36h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "5e874856af7858fb0cd9bc1785803f86", + "name": "pycairo", + "sha256": "54ba74e7e002f97ce45b9fff950d956b14577e7fab781b5e7fba998d0ccb75d9", + "size": 75020, + "subdir": "linux-64", + "timestamp": 1593109585977, + "version": "1.19.1" + }, + "pycairo-1.19.1-py36h708ec4a_0.conda": { + "build": "py36h708ec4a_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "dc55ba0df5d837d5f888caaabb1e26c2", + "name": "pycairo", + "sha256": "d32f68ceaaa576c9434787ad83701000ee2d3d607257edde17b0fafc1a621d3e", + "size": 74270, + "subdir": "linux-64", + "timestamp": 1614246496330, + "version": "1.19.1" + }, + "pycairo-1.19.1-py37h2a1e443_0.conda": { + "build": "py37h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "377004cf4fd57accbe255fd1ca2a83e3", + "name": "pycairo", + "sha256": "0a011d746e1af505172788a73632ad80dae9603f54eaff8d63eac1a280b89be4", + "size": 74159, + "subdir": "linux-64", + "timestamp": 1593109592234, + "version": "1.19.1" + }, + "pycairo-1.19.1-py37h708ec4a_0.conda": { + "build": "py37h708ec4a_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "b25663286066f47682715285e946dfb0", + "name": "pycairo", + "sha256": "3f2af926e95e2f32e03220e263686be75fc8fe2643a1482d08d0b79e9564c0ff", + "size": 74326, + "subdir": "linux-64", + "timestamp": 1614247356550, + "version": "1.19.1" + }, + "pycairo-1.19.1-py38h2a1e443_0.conda": { + "build": "py38h2a1e443_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "f57fcba3870cd5049e2bfa0b87810337", + "name": "pycairo", + "sha256": "23f499c5c977fd03f49b918a1f36d70be4f8f129e6107f99d07f71fe0dacc32c", + "size": 75293, + "subdir": "linux-64", + "timestamp": 1593109594395, + "version": "1.19.1" + }, + "pycairo-1.19.1-py38h708ec4a_0.conda": { + "build": "py38h708ec4a_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "658f8571889df0b71a29dcfe590208dd", + "name": "pycairo", + "sha256": "92829f7820eac8ca54442d530c057570754264cebe4a54df3577e0ec51f8e0b9", + "size": 74874, + "subdir": "linux-64", + "timestamp": 1614247360963, + "version": "1.19.1" + }, + "pycairo-1.19.1-py39h708ec4a_0.conda": { + "build": "py39h708ec4a_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL 2.1, MPL 1.1", + "md5": "da6e8df2d83e17ccb30cbf70f903bc06", + "name": "pycairo", + "sha256": "06788e0ad1b4bcd010e7f451481358ae3a1cec32ac6284bdbf0101698e4c61e9", + "size": 74964, + "subdir": "linux-64", + "timestamp": 1614247353534, + "version": "1.19.1" + }, + "pycairo-1.21.0-py310h287db57_0.conda": { + "build": "py310h287db57_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1-only OR MPL-1.1", + "license_family": "LGPL", + "md5": "6fdbe37160c13aa8a13934219c9c628c", + "name": "pycairo", + "sha256": "5a838d81b608f86784e05223ea3277570da1a7907026be49e410618563afe04b", + "size": 123164, + "subdir": "linux-64", + "timestamp": 1656618788946, + "version": "1.21.0" + }, + "pycairo-1.21.0-py311h287db57_0.conda": { + "build": "py311h287db57_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.1-only OR MPL-1.1", + "license_family": "LGPL", + "md5": "44bf6b3b7f47cc1068815a34c1d178e4", + "name": "pycairo", + "sha256": "888490b9cb47895743c5cebe21a7304938fc81c0b7a09e7bd6f0c7a7c62d8adc", + "size": 121502, + "subdir": "linux-64", + "timestamp": 1676860629114, + "version": "1.21.0" + }, + "pycairo-1.21.0-py37h287db57_0.conda": { + "build": "py37h287db57_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-only OR MPL-1.1", + "license_family": "LGPL", + "md5": "8aa58a599d0b3ca96a1d467a4d1bea31", + "name": "pycairo", + "sha256": "277c0a486464c76df39c6740ebd38d4b42ef4a6f0219627ce09d07ce50620a0f", + "size": 123007, + "subdir": "linux-64", + "timestamp": 1656618689680, + "version": "1.21.0" + }, + "pycairo-1.21.0-py38h287db57_0.conda": { + "build": "py38h287db57_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-only OR MPL-1.1", + "license_family": "LGPL", + "md5": "20eba8502540da9b3c708790d35ebd4a", + "name": "pycairo", + "sha256": "c00ece2ad4a7a24be9df5556015a11b49055087f389437a6a93c155dc940149b", + "size": 123218, + "subdir": "linux-64", + "timestamp": 1656618833017, + "version": "1.21.0" + }, + "pycairo-1.21.0-py39h287db57_0.conda": { + "build": "py39h287db57_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-only OR MPL-1.1", + "license_family": "LGPL", + "md5": "3c9e2fb1bac7a790ee1afd973866d5d5", + "name": "pycairo", + "sha256": "62473d153b646d03335b32a89f7d4e1a6d241f8417d433c148ae94c9be6a54f6", + "size": 123105, + "subdir": "linux-64", + "timestamp": 1656618733221, + "version": "1.21.0" + }, + "pycairo-1.23.0-py310hd1222b9_0.conda": { + "build": "py310hd1222b9_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1-only OR MPL-1.1", + "license_family": "LGPL", + "md5": "c62e09c977bd687688ddb8feddd82b73", + "name": "pycairo", + "sha256": "0d183e02ec48746378cd44f4d4aa3baffaa7ff159eb46efcd2d82839782ed2d8", + "size": 136401, + "subdir": "linux-64", + "timestamp": 1680531122418, + "version": "1.23.0" + }, + "pycairo-1.23.0-py311hd1222b9_0.conda": { + "build": "py311hd1222b9_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.1-only OR MPL-1.1", + "license_family": "LGPL", + "md5": "9cd59584c826a1d8297db05cbaff799c", + "name": "pycairo", + "sha256": "ad3167087496c5014405e3cf7eb0570e8fda372994790457fc0e022fc9705d9c", + "size": 136597, + "subdir": "linux-64", + "timestamp": 1680531170228, + "version": "1.23.0" + }, + "pycairo-1.23.0-py38hd1222b9_0.conda": { + "build": "py38hd1222b9_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-only OR MPL-1.1", + "license_family": "LGPL", + "md5": "7b83a0ec920e494265464a8ee7708e1b", + "name": "pycairo", + "sha256": "ee96387e8f2ee71ee2c2be6fc9d09b29a629f1231596e8ad8c3e781a07872eba", + "size": 136388, + "subdir": "linux-64", + "timestamp": 1680531263366, + "version": "1.23.0" + }, + "pycairo-1.23.0-py39hd1222b9_0.conda": { + "build": "py39hd1222b9_0", + "build_number": 0, + "depends": [ + "cairo >=1.16.0,<2.0a0", + "glib >=2.69.1,<3.0a0", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-only OR MPL-1.1", + "license_family": "LGPL", + "md5": "832551aea20c48f55366a05e08d412cc", + "name": "pycairo", + "sha256": "455061eddb8572b25dd59242cf9f947d76ce2dd5ccbb989848d5d4ac219e52e0", + "size": 136215, + "subdir": "linux-64", + "timestamp": 1680531216512, + "version": "1.23.0" + }, + "pycares-3.1.1-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8865bc60f47a3a50f6d8cfdf06e3902d", + "name": "pycares", + "sha256": "948ec8301a753a06c132a60cb748b4b4662a654db0c914e27e64c58758f1ae57", + "size": 79241, + "subdir": "linux-64", + "timestamp": 1613479115305, + "version": "3.1.1" + }, + "pycares-3.1.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5eb1225da9d59ba351f040273bd42ddb", + "name": "pycares", + "sha256": "e6caec81c76aa8d6baf414c178b91dda134a238dd8652c29959e85ce5d54cdd0", + "size": 81210, + "subdir": "linux-64", + "timestamp": 1592521957201, + "version": "3.1.1" + }, + "pycares-3.1.1-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f88b1a7d5eaa20bbdda35a4ed1b0bef9", + "name": "pycares", + "sha256": "dfa2534461daf03e57acb9601f7f249d8f1490543d9a8966d5cdfcbbe3ca476d", + "size": 79614, + "subdir": "linux-64", + "timestamp": 1613479867001, + "version": "3.1.1" + }, + "pycares-3.1.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "94a39bf7e23fe09b461498fd73cf5921", + "name": "pycares", + "sha256": "36fe41360423e0a7bfb2935bee64c5a41cccb66627922f82199b69c22ef3bfb5", + "size": 79346, + "subdir": "linux-64", + "timestamp": 1592521918294, + "version": "3.1.1" + }, + "pycares-3.1.1-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9fc9ec53f5a180452d2fec17565ace7b", + "name": "pycares", + "sha256": "e8d0ca2ed857632c11f87e0a9e4b92a084be912449a8dfcbd4e0fa147bd93cb8", + "size": 79248, + "subdir": "linux-64", + "timestamp": 1613479245027, + "version": "3.1.1" + }, + "pycares-3.1.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "713059e883bcf26429b36212b98b95c8", + "name": "pycares", + "sha256": "f9be8642b94f7dae2295c44f043df4ca12c6fce8e7901b73891417406381d7bc", + "size": 79210, + "subdir": "linux-64", + "timestamp": 1592521957352, + "version": "3.1.1" + }, + "pycares-3.1.1-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec44d17b13ffe2100ea8454c231bbbc2", + "name": "pycares", + "sha256": "ed732586ddef82371d39792df277af9d4e2903580354f7a369e41f9eb2600876", + "size": 79521, + "subdir": "linux-64", + "timestamp": 1613479872247, + "version": "3.1.1" + }, + "pycares-4.0.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "idna >=2.1", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71f29d7684c6353576fdec2583e22bd3", + "name": "pycares", + "sha256": "e68cd8aae7f99058e86dc7cbc4d820c7a959869121723decba2a9861f0f57914", + "size": 220443, + "subdir": "linux-64", + "timestamp": 1640810233019, + "version": "4.0.0" + }, + "pycares-4.0.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "idna >=2.1", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6280216372942d4457b72b09d2d5acce", + "name": "pycares", + "sha256": "04012156beb41410915bcc864f64b55490ba188f3b8c5787db1dcca14c76a18f", + "size": 92661, + "subdir": "linux-64", + "timestamp": 1676842064910, + "version": "4.0.0" + }, + "pycares-4.0.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d42b7805c759a0337d4e7a1e14b64317", + "name": "pycares", + "sha256": "a36fda069c5f4aa8eef383113db7ded8190880a9801e4404ed1b2b9809a7fce4", + "size": 89577, + "subdir": "linux-64", + "timestamp": 1621340186943, + "version": "4.0.0" + }, + "pycares-4.0.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ed7e1d4043a5a91ad7b6e1ebd1f2615e", + "name": "pycares", + "sha256": "760d60a10bebb172a22174f914d2e27e5e11db029d58d5b90958fb76f643dd88", + "size": 87619, + "subdir": "linux-64", + "timestamp": 1621340192654, + "version": "4.0.0" + }, + "pycares-4.0.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12c315a1ca79705841a8720c6774d8c8", + "name": "pycares", + "sha256": "d99af64b8afb4424929b6117a0e72091811a51fbc0cab6abab0808dc741f5ade", + "size": 90001, + "subdir": "linux-64", + "timestamp": 1621340195661, + "version": "4.0.0" + }, + "pycares-4.0.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.5.0", + "idna >=2.1", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3120ab54f2691b20ba5fd5bed7d81a22", + "name": "pycares", + "sha256": "3a4f51a7cf4e16bfbd26ff5ac67c23f1e3d733192381abecef299602f57f9233", + "size": 88095, + "subdir": "linux-64", + "timestamp": 1621340191496, + "version": "4.0.0" + }, + "pyclipper-1.2.0-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ce94122603e44b49f89ed1ccffe55cd", + "name": "pyclipper", + "sha256": "e30c9372d6aee5a0a745025d08b0e82a2c4b2369d806058014b4ba2cf0c144d4", + "size": 121135, + "subdir": "linux-64", + "timestamp": 1605228006458, + "version": "1.2.0" + }, + "pyclipper-1.2.0-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66fd19f6482af234bf18a4f2dd9a43a0", + "name": "pyclipper", + "sha256": "754f7fe3b3711d3e7ddda4a5e89d5155e0f8485f607e1505a496e4a1e3b0522b", + "size": 120889, + "subdir": "linux-64", + "timestamp": 1605227994047, + "version": "1.2.0" + }, + "pyclipper-1.2.0-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "28b24cb2e2e32e81576d672c7d6f8f65", + "name": "pyclipper", + "sha256": "fbd5533ae31feb9a3691f4f501ccdf0c3e4774e70a8df8b18bbc06bbbf926000", + "size": 123556, + "subdir": "linux-64", + "timestamp": 1605228002321, + "version": "1.2.0" + }, + "pyclipper-1.2.1-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e3b356d02a94b04d098681daed359fb1", + "name": "pyclipper", + "sha256": "1e2d8c022bf1bab187eaca330e7a20236327dc72be1c3cd5969d8762bf0b8399", + "size": 119566, + "subdir": "linux-64", + "timestamp": 1609094854639, + "version": "1.2.1" + }, + "pyclipper-1.2.1-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c74343aa7a3df8ee0a896571e561435", + "name": "pyclipper", + "sha256": "bd6e61eb4d28bdccf919837e43053060f95d339c89f88083c2e30b9e898e93bf", + "size": 120920, + "subdir": "linux-64", + "timestamp": 1609094860691, + "version": "1.2.1" + }, + "pyclipper-1.2.1-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01ddd6ddec2efe50c37e599267047ae6", + "name": "pyclipper", + "sha256": "1b24d7274716703e7061c9df84ce413f1d7fc25d1826159cd1abc6c0e77c4197", + "size": 122276, + "subdir": "linux-64", + "timestamp": 1609094865680, + "version": "1.2.1" + }, + "pyclipper-1.2.1-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8fe4a86eab94d033a95d9296e0f9ec45", + "name": "pyclipper", + "sha256": "a05b2819c2926be07beb1adb0a53e7200e65a1f7619d85d4caf9bf3ebf3dbb50", + "size": 121854, + "subdir": "linux-64", + "timestamp": 1609094833590, + "version": "1.2.1" + }, + "pyclipper-1.3.0-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d046f00615a69e19f3dd9cf3162dd6f", + "name": "pyclipper", + "sha256": "7994c1b724d50e25b705a1297a82b203aad36ed54126240fa6ba888ef482c076", + "size": 502833, + "subdir": "linux-64", + "timestamp": 1640792809393, + "version": "1.3.0" + }, + "pyclipper-1.3.0-py36h295c915_0.conda": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08dd8bcaaceb5fe6a503f5417add181b", + "name": "pyclipper", + "sha256": "a2c361012f791460329f93fcebcf4c18de007d29384525922f835039aefe275b", + "size": 117963, + "subdir": "linux-64", + "timestamp": 1626196801309, + "version": "1.3.0" + }, + "pyclipper-1.3.0-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebc80a5927e7ca16fadafe35756804a1", + "name": "pyclipper", + "sha256": "3817be14f35f17f317d33d725174012d7103d8fa0e4f6a78eb561748a55e3bab", + "size": 117791, + "subdir": "linux-64", + "timestamp": 1626203816846, + "version": "1.3.0" + }, + "pyclipper-1.3.0-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14bd98ce5fcfdff776295c262d27e9e3", + "name": "pyclipper", + "sha256": "601dd5c4272ef0fe6453b1e209ba12c61ea6ef1cf064356a096f7eeb38fd6ffd", + "size": 121193, + "subdir": "linux-64", + "timestamp": 1626203815262, + "version": "1.3.0" + }, + "pyclipper-1.3.0-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f68d9705e99065141cd0f681ab431649", + "name": "pyclipper", + "sha256": "9004868415a29a27fe517922e881a347f79e005f41c3cab55afdbf192af300c4", + "size": 119803, + "subdir": "linux-64", + "timestamp": 1626203528114, + "version": "1.3.0" + }, + "pyclipper-1.3.0.post3-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT and BSL-1.0", + "license_family": "MIT", + "md5": "ca7266e90034a455db502accea512676", + "name": "pyclipper", + "sha256": "b365df838332b232adb06c4c7cb787f6826e96292e869e3987499043d23d92c8", + "size": 650857, + "subdir": "linux-64", + "timestamp": 1664521741703, + "version": "1.3.0.post3" + }, + "pyclipper-1.3.0.post3-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT and BSL-1.0", + "license_family": "MIT", + "md5": "64946986942346d5143a36632fdd25e6", + "name": "pyclipper", + "sha256": "1ea6d8f3fa3f9a5c93f19efc73f6ebf328f67f97af0adfde950a607c11ec55fd", + "size": 119024, + "subdir": "linux-64", + "timestamp": 1676860654563, + "version": "1.3.0.post3" + }, + "pyclipper-1.3.0.post3-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT and BSL-1.0", + "license_family": "MIT", + "md5": "668bf3e6833275d1fbda190c40e2a5b9", + "name": "pyclipper", + "sha256": "2e042b7d94328f6166b4b682bb3a41ed9f165f986467091ce868af1f71c3c0e4", + "size": 121692, + "subdir": "linux-64", + "timestamp": 1664521681509, + "version": "1.3.0.post3" + }, + "pyclipper-1.3.0.post3-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT and BSL-1.0", + "license_family": "MIT", + "md5": "45b87cc99f03c8ce4dc87ea7f9f7764b", + "name": "pyclipper", + "sha256": "16e098d7f5acab40f8a533699dc449b05e1b7009beeeaefb0b9218b811172dbb", + "size": 122539, + "subdir": "linux-64", + "timestamp": 1664521640441, + "version": "1.3.0.post3" + }, + "pyclipper-1.3.0.post3-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT and BSL-1.0", + "license_family": "MIT", + "md5": "6a637472af58d8a009f437ebfa1b9071", + "name": "pyclipper", + "sha256": "4983b29ab29e99af749b1abf9d2a29f44a5bbe0b971a126f021f1755dc4baa2b", + "size": 121856, + "subdir": "linux-64", + "timestamp": 1664521783891, + "version": "1.3.0.post3" + }, + "pycodestyle-2.10.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "944099e90375c32189d9f4f8f63bd6f7", + "name": "pycodestyle", + "sha256": "696718a980445f7c8897b2e4552ae56f0a802a8cc75ae9fa06cfeaa8f656259d", + "size": 69503, + "subdir": "linux-64", + "timestamp": 1674267300744, + "version": "2.10.0" + }, + "pycodestyle-2.10.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "69982d53c72ef02e2d7a4696735350c7", + "name": "pycodestyle", + "sha256": "863c71516309a27ae98e4d0252697805e173a5b1febe87cc2a93e1d2b3b28645", + "size": 82981, + "subdir": "linux-64", + "timestamp": 1677708807333, + "version": "2.10.0" + }, + "pycodestyle-2.10.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "28d71cbf0f6ae6b3379b726cd86c63e1", + "name": "pycodestyle", + "sha256": "e32cf12d96d5f649178e2e414dd1f73aa2848a36f0530f8fd83844ac7606c12f", + "size": 69188, + "subdir": "linux-64", + "timestamp": 1674267325646, + "version": "2.10.0" + }, + "pycodestyle-2.10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "800f7e39d4a238560954fc04010d7191", + "name": "pycodestyle", + "sha256": "44241c9e92f426ce5e4a47699f98910b6560aefc8b1e5ac6cad657205f24e9b9", + "size": 69536, + "subdir": "linux-64", + "timestamp": 1674267250691, + "version": "2.10.0" + }, + "pycodestyle-2.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bde587f7a5e37850c4245828f20eaec1", + "name": "pycodestyle", + "sha256": "6cb9109e5298b09f58db17622c8404ebb8c94eacc8b7b830f5c68df67e3ccef0", + "size": 69359, + "subdir": "linux-64", + "timestamp": 1674267275705, + "version": "2.10.0" + }, + "pycodestyle-2.3.1-py27h904819d_0.conda": { + "build": "py27h904819d_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48f4d1f7f8672cee018df4698e44fa81", + "name": "pycodestyle", + "sha256": "4e7d57484528efacba7c9224a27c506ac1b30b944c0c03cd18203ff9a638fe64", + "size": 57225, + "subdir": "linux-64", + "timestamp": 1505743034562, + "version": "2.3.1" + }, + "pycodestyle-2.3.1-py35h8d2105a_0.conda": { + "build": "py35h8d2105a_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "79ad1b880bd2f4aa04c61d076058fe4f", + "name": "pycodestyle", + "sha256": "0b9f2b672b7575e2cab37ae732a6d0f5e795a4710b11b19e67030345320774b1", + "size": 56418, + "subdir": "linux-64", + "timestamp": 1505743046270, + "version": "2.3.1" + }, + "pycodestyle-2.3.1-py36hf609f19_0.conda": { + "build": "py36hf609f19_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb114d3e985cabfecdce7a32db5b7161", + "name": "pycodestyle", + "sha256": "70fc0d03307c5f09206bc7769026821e15c88228982164cc4741d73ce38e254b", + "size": 57146, + "subdir": "linux-64", + "timestamp": 1505743058118, + "version": "2.3.1" + }, + "pycodestyle-2.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f79e6311aeb930ea91695dbf9711b1a6", + "name": "pycodestyle", + "sha256": "93dfeac26936003d611a69e4788ba178eed3c33358479a5b4140100fc9eade3e", + "size": 60300, + "subdir": "linux-64", + "timestamp": 1523431231057, + "version": "2.4.0" + }, + "pycodestyle-2.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4431ad655939131fef84fec2292fcaaa", + "name": "pycodestyle", + "sha256": "e96c07243698a816922878d878707fec0ea169e6f765db2cc286678e3f2dfc6e", + "size": 61789, + "subdir": "linux-64", + "timestamp": 1523431419456, + "version": "2.4.0" + }, + "pycodestyle-2.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "41def2fff4b06b27b000f647003f06d9", + "name": "pycodestyle", + "sha256": "05113c8b91b8302eb94add2881a50e326f43dcb6c6dc256a489c49521087d5bb", + "size": 61173, + "subdir": "linux-64", + "timestamp": 1523431292755, + "version": "2.4.0" + }, + "pycodestyle-2.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4fa1f1560bcdde70fd3d271d6d097f95", + "name": "pycodestyle", + "sha256": "47317e16c093c972a9cc73846291abfe160e06447de044e398635143bca74112", + "size": 61024, + "subdir": "linux-64", + "timestamp": 1530812671772, + "version": "2.4.0" + }, + "pycodestyle-2.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "214892164e5d992cc629e4df1822f23f", + "name": "pycodestyle", + "sha256": "6e7c3820b70e66aebc284aad4a8c6bd9b070d9d54a2bebd6c28a4a6bd0099b5c", + "size": 62321, + "subdir": "linux-64", + "timestamp": 1549337982411, + "version": "2.5.0" + }, + "pycodestyle-2.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8591db11144e9f18791d8df5dc6bb328", + "name": "pycodestyle", + "sha256": "71aed53b9c2c6ac10ecc9975845327fd6e1325a7b67f4ba70f461c6037bc28e0", + "size": 63102, + "subdir": "linux-64", + "timestamp": 1549328766162, + "version": "2.5.0" + }, + "pycodestyle-2.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cfe716390e61673c9cc8214aa8b855f2", + "name": "pycodestyle", + "sha256": "56e2878eff08da509388160b369e72fdcf78e49dfd1329833b5e2b745f6eff8f", + "size": 62720, + "subdir": "linux-64", + "timestamp": 1549337996211, + "version": "2.5.0" + }, + "pycodestyle-2.5.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "337866d0d448a5c3fcd533e7d0a997a4", + "name": "pycodestyle", + "sha256": "5d435b62838b1367920c42a35139150d46c9c6e1433c3521c0eefb6356d7ea16", + "size": 63144, + "subdir": "linux-64", + "timestamp": 1573662738408, + "version": "2.5.0" + }, + "pycosat-0.6.2-py27h1cf261c_1.conda": { + "build": "py27h1cf261c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f0288394b8791a610b15e07ab7800974", + "name": "pycosat", + "sha256": "b35325a09c6c534b2a6177a10659105f6381d6d37e7016c476f5d3f05ae40a1a", + "size": 79916, + "subdir": "linux-64", + "timestamp": 1505742082091, + "version": "0.6.2" + }, + "pycosat-0.6.2-py35h9693557_1.conda": { + "build": "py35h9693557_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "87331008de63c915d910d174974d29c6", + "name": "pycosat", + "sha256": "588b5806b2243a3ac88bc70037d03c70fb4543e3d9ffde74fb456d3000eefabb", + "size": 80757, + "subdir": "linux-64", + "timestamp": 1505742100736, + "version": "0.6.2" + }, + "pycosat-0.6.2-py36h1a0ea17_1.conda": { + "build": "py36h1a0ea17_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "41a333de8a6f118c7d6590377b6eaca0", + "name": "pycosat", + "sha256": "20b6bc9fb76e2bb52afe6e35d73c95adf0d0c11e26af0cddc474507a12fa11cc", + "size": 80688, + "subdir": "linux-64", + "timestamp": 1505742119471, + "version": "0.6.2" + }, + "pycosat-0.6.3-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "0c911807437441200c039d9ec0ce2182", + "name": "pycosat", + "sha256": "4ac73d24f54b5ff6604800e79205b9a5c7867cd9c4ab0558cfc8914ef2ac1a9a", + "size": 80996, + "subdir": "linux-64", + "timestamp": 1530812765823, + "version": "0.6.3" + }, + "pycosat-0.6.3-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7d503d8f32141e0580481689ecb15914", + "name": "pycosat", + "sha256": "c58f7383334d6705e7503a3ea54226537e95df26526fc1d801492c9776c9002a", + "size": 82578, + "subdir": "linux-64", + "timestamp": 1576875191844, + "version": "0.6.3" + }, + "pycosat-0.6.3-py27ha4109ae_0.conda": { + "build": "py27ha4109ae_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "161458bf8cc21ccbc6ab7b7566cd4ae5", + "name": "pycosat", + "sha256": "8797b25f8b2de857fadfb5e93f0d6533f16d225d6353bba50456123d1b9c2670", + "size": 80045, + "subdir": "linux-64", + "timestamp": 1509357302743, + "version": "0.6.3" + }, + "pycosat-0.6.3-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "80ba1057540675a3cac666ebd439e924", + "name": "pycosat", + "sha256": "7c15870e6c5d0fcac011760718e3738f2774f4e0cd4daddd8d7e7f5e6d70cb99", + "size": 165906, + "subdir": "linux-64", + "timestamp": 1640792835472, + "version": "0.6.3" + }, + "pycosat-0.6.3-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "686162ffd578e3775601c80c76405afa", + "name": "pycosat", + "sha256": "8d4bf6a8392c40c4a192bc8e77c0b2c9270a844ba0201746ffad909b2cf44dea", + "size": 82324, + "subdir": "linux-64", + "timestamp": 1535130168795, + "version": "0.6.3" + }, + "pycosat-0.6.3-py35h6b6bb97_0.conda": { + "build": "py35h6b6bb97_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "46cd0001e6cf9db1ae42f9d68a4659bb", + "name": "pycosat", + "sha256": "15b0f991ac1f9f900604d325588936781bca2258e90c24d3d3b5a34c8e4abc84", + "size": 81195, + "subdir": "linux-64", + "timestamp": 1509357322619, + "version": "0.6.3" + }, + "pycosat-0.6.3-py36h0a5515d_0.conda": { + "build": "py36h0a5515d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0a3806af3c13b6e94fd771baaf13e0d7", + "name": "pycosat", + "sha256": "76ea269dd49122d146be0a143c46ea7d07034b3ebc0426cb9ccc4dd87c91f029", + "size": 80643, + "subdir": "linux-64", + "timestamp": 1509357342673, + "version": "0.6.3" + }, + "pycosat-0.6.3-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "80a7f73e796a31c68cd0d323f7980cbc", + "name": "pycosat", + "sha256": "5ad88fa9d8012f45044caad194f6aa65b55c3f508dc9e98784075101596ed727", + "size": 80758, + "subdir": "linux-64", + "timestamp": 1530812821149, + "version": "0.6.3" + }, + "pycosat-0.6.3-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "501dd4efb2c7664aaf645d7ff7f60afc", + "name": "pycosat", + "sha256": "8ac6efb06d657fb56b0a841cea0cd1648d1ff0a33f8ec9cf8e4c108e860299fe", + "size": 83470, + "subdir": "linux-64", + "timestamp": 1605545868440, + "version": "0.6.3" + }, + "pycosat-0.6.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0f4ca8f70a7df77e6eb9097ccc981f74", + "name": "pycosat", + "sha256": "b2eb585e3949a99bacc7e778d50d9cace3a5f2b5e8d61f7a88fbf9f3705ab39f", + "size": 84258, + "subdir": "linux-64", + "timestamp": 1576875237881, + "version": "0.6.3" + }, + "pycosat-0.6.3-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "acae2108df7bea8c656b7f4800a55767", + "name": "pycosat", + "sha256": "df376f6065bfabbbd9a17ccd038693822789db6f3b6585a26e229dfd9b4fbcc9", + "size": 81228, + "subdir": "linux-64", + "timestamp": 1530812793022, + "version": "0.6.3" + }, + "pycosat-0.6.3-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6f072a01efab84f1a47849c33b036940", + "name": "pycosat", + "sha256": "afb7d516d9bf846c781fd9578be6b6cab7711dcfacb7b569b61ebedb2fcbee4f", + "size": 83018, + "subdir": "linux-64", + "timestamp": 1605545871945, + "version": "0.6.3" + }, + "pycosat-0.6.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5c700d04be72f10edda08ee0eba049b5", + "name": "pycosat", + "sha256": "3d4ed68cd3d0bf5daa73de8729d822681e9cd48a01f9122adae92e65d4d1ca52", + "size": 83546, + "subdir": "linux-64", + "timestamp": 1576875211158, + "version": "0.6.3" + }, + "pycosat-0.6.3-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "0d947f38e311718dcbd15095da81ee68", + "name": "pycosat", + "sha256": "976fda9b454bf52a7bb2d537b4a8ce2baef83e224695a1018fc750a5ff0df50d", + "size": 83761, + "subdir": "linux-64", + "timestamp": 1605545859253, + "version": "0.6.3" + }, + "pycosat-0.6.3-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "d08493903ff7893fbd82b943eabcabee", + "name": "pycosat", + "sha256": "da16e019848c9fab23fc6ca2e477d8f256db3cf69dfc8e9eaf771862313f2f47", + "size": 88874, + "subdir": "linux-64", + "timestamp": 1573668802680, + "version": "0.6.3" + }, + "pycosat-0.6.3-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "4549fa8bc89c922705e0d20374076081", + "name": "pycosat", + "sha256": "39a9ea37e5ffa41413148a5fdd4c6fccc2adc3cdd45acb118d395f6c184b25f0", + "size": 83884, + "subdir": "linux-64", + "timestamp": 1588116986637, + "version": "0.6.3" + }, + "pycosat-0.6.3-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "ae68246cc683110894b517ca80a24072", + "name": "pycosat", + "sha256": "c7c981ccd6a0af3419338c8efecdfda260936934cd27b4d552eb23fee92364f1", + "size": 84072, + "subdir": "linux-64", + "timestamp": 1605545841785, + "version": "0.6.3" + }, + "pycosat-0.6.4-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4bb7de740c7700b576abbfed6444eefd", + "name": "pycosat", + "sha256": "f2090e325f6814535eb79596ae383bdf0b9f998d9a3d114a6d2385de2721a5af", + "size": 84278, + "subdir": "linux-64", + "timestamp": 1666805641437, + "version": "0.6.4" + }, + "pycosat-0.6.4-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dcfa307788c70b5302a8f61c9cd77864", + "name": "pycosat", + "sha256": "ad159b86c13efc2df30d5c4eca37d780c5f5ca36d9f4af9f504e46f1bd06f2b1", + "size": 85920, + "subdir": "linux-64", + "timestamp": 1676838542087, + "version": "0.6.4" + }, + "pycosat-0.6.4-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a5cf3f0022a6d7c8d30b48ff16777eeb", + "name": "pycosat", + "sha256": "409b746acb84c422d319676ec20fc3f39c0e305641e9215211f3b6e95d8bb368", + "size": 86179, + "subdir": "linux-64", + "timestamp": 1666805610529, + "version": "0.6.4" + }, + "pycosat-0.6.4-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d611076dccfebaa904b91ee70a88ed5", + "name": "pycosat", + "sha256": "7e92a09e1c663e89756757a92c17a04e6ca82d515c1af9fb0b1f1076d8b38808", + "size": 85921, + "subdir": "linux-64", + "timestamp": 1666805578320, + "version": "0.6.4" + }, + "pycosat-0.6.4-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "891c93711f866a5b7476b3a1afe1e4a9", + "name": "pycosat", + "sha256": "41cefe4647c1160079e41a6346f196f44b7fdcace84127df29e075683cc6c897", + "size": 85854, + "subdir": "linux-64", + "timestamp": 1666805546234, + "version": "0.6.4" + }, + "pycparser-2.18-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9c151228e0c17fc033c231717fbdbd50", + "name": "pycparser", + "sha256": "7d39052daabe670a507afad5664085e0d49e4cebfdc6905b0a51456f9471e1cf", + "size": 169277, + "subdir": "linux-64", + "timestamp": 1530694140145, + "version": "2.18" + }, + "pycparser-2.18-py27hefa08c5_1.conda": { + "build": "py27hefa08c5_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "96c3fef7a8e94a6d67a49346924b4820", + "name": "pycparser", + "sha256": "dcb4d648939cf3141f867eb4e516b4779df3d87ebd975c2a00d71f83786ecb7d", + "size": 171221, + "subdir": "linux-64", + "timestamp": 1505691615710, + "version": "2.18" + }, + "pycparser-2.18-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b1d8034bdbb86588c52449cd30bba14f", + "name": "pycparser", + "sha256": "65649bb973af88a2270ee354fbf950f7dff2efc41ceab2d74a60da3bd4fb9900", + "size": 171141, + "subdir": "linux-64", + "timestamp": 1534345125332, + "version": "2.18" + }, + "pycparser-2.18-py35h61b3040_1.conda": { + "build": "py35h61b3040_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "abb5e09a23e0c06ff57214adbb7b7f85", + "name": "pycparser", + "sha256": "3477bfeb15f35ed5dd254c0586349a0b582ae5bbdfc8a5a181c6ffcf096548cb", + "size": 173095, + "subdir": "linux-64", + "timestamp": 1505691628432, + "version": "2.18" + }, + "pycparser-2.18-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f6650349b0272d55a04c787d4475d826", + "name": "pycparser", + "sha256": "85c24d4a30f726339c5c48d531d3d48bb1bdf42e91302f4b7425cd3042afeef7", + "size": 170983, + "subdir": "linux-64", + "timestamp": 1530694101212, + "version": "2.18" + }, + "pycparser-2.18-py36hf9f622e_1.conda": { + "build": "py36hf9f622e_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7c19ddb3a941a55847d9dac637e83bfe", + "name": "pycparser", + "sha256": "e8129dc38f3648820ac7736fa1bf6ef20b98485d46d0cbaf3ee4bd6049de8d70", + "size": 168798, + "subdir": "linux-64", + "timestamp": 1505691641245, + "version": "2.18" + }, + "pycparser-2.18-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1a89d632a12bec6c763b4d2575c9f696", + "name": "pycparser", + "sha256": "7f27a8ee787646bdc4788c265be549482bfc97aeb8c546051e4e52b926e60533", + "size": 170462, + "subdir": "linux-64", + "timestamp": 1530694121331, + "version": "2.18" + }, + "pycparser-2.19-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b7096cfcbed54d1fc47d61cf27b9d6d4", + "name": "pycparser", + "sha256": "e062afdc5884aef3f7cc02935d7261bcb91bc566ee4a57030365ea6966f8b5c3", + "size": 176024, + "subdir": "linux-64", + "timestamp": 1538230997120, + "version": "2.19" + }, + "pycparser-2.19-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9c769b3b0cd8943c554cdbca50f059a6", + "name": "pycparser", + "sha256": "29a41fc94aac850952a0fabdec0d5e57768e3f569789488dc7b342e25f25e040", + "size": 178330, + "subdir": "linux-64", + "timestamp": 1538231045384, + "version": "2.19" + }, + "pycparser-2.19-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0ff29e2776ba31021e15013132f94c4e", + "name": "pycparser", + "sha256": "6b0df487545d788c7ac848d61fbd202ecb00b0aa3c6a00dd942d239b5a0241d8", + "size": 174020, + "subdir": "linux-64", + "timestamp": 1538231037307, + "version": "2.19" + }, + "pycparser-2.19-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "417b57fa424177de6886f0cf423e3d92", + "name": "pycparser", + "sha256": "5a680576c8110cd75bb2c5f3c72f2204b168f3c9688898de8abd8383ca1eb2af", + "size": 175182, + "subdir": "linux-64", + "timestamp": 1538231005324, + "version": "2.19" + }, + "pycrypto-2.6.1-py27h14c3975_7.conda": { + "build": "py27h14c3975_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "md5": "cb12a05cf1c95d7cda015e87d811db48", + "name": "pycrypto", + "sha256": "6f494feea3a76e82cd13a872e99980f0a25807b51ca9c5ba68dec5b6167cbb39", + "size": 375958, + "subdir": "linux-64", + "timestamp": 1518031831449, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py27h14c3975_8.conda": { + "build": "py27h14c3975_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "md5": "5de1fdb29a2aa204fce933667c144b80", + "name": "pycrypto", + "sha256": "b2294d6cd43febde48462f843c3fe8fd5a370ec4f2454ebda7bfc307309ab567", + "size": 373617, + "subdir": "linux-64", + "timestamp": 1525880640238, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py27h14c3975_9.conda": { + "build": "py27h14c3975_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "md5": "0897a6f8bd8fb0db4453ed8c69922407", + "name": "pycrypto", + "sha256": "ba89302c3702a792be1aa8086f403cd30559b6805af6db5064e30b8b47d553a3", + "size": 380968, + "subdir": "linux-64", + "timestamp": 1530915799669, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py27h9abbf5c_1.conda": { + "build": "py27h9abbf5c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain", + "md5": "2361185e12e403be9e26c5f53064cb0e", + "name": "pycrypto", + "sha256": "add9b1cad32d19dc2a84f05eb270fc4916e93c7f7226e486f1af15bd5a661f25", + "size": 383840, + "subdir": "linux-64", + "timestamp": 1505751432811, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py310h7f8727e_10.conda": { + "build": "py310h7f8727e_10", + "build_number": 10, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Public Domain", + "md5": "97edd6081a8187e655a23e72194fc561", + "name": "pycrypto", + "sha256": "e443c843ecac5e390de37b90033324a34d84a43575e8cfd8523bbeb9ad0fcf02", + "size": 515501, + "subdir": "linux-64", + "timestamp": 1640792876112, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py35h14c3975_7.conda": { + "build": "py35h14c3975_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain", + "md5": "e6ca0d97b26014144e38c3c8d44d42b8", + "name": "pycrypto", + "sha256": "7bd9f798f6386e20dbb8e7b3fd9a6ad8a04f93773f56a2534dc04a2bfe66bb58", + "size": 395940, + "subdir": "linux-64", + "timestamp": 1518031025722, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py35h14c3975_8.conda": { + "build": "py35h14c3975_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain", + "md5": "83a448b288871939f78ebd3285a651dc", + "name": "pycrypto", + "sha256": "c29e402fc2778c3020f7ebc7d1e5d4ba4e46ce2ed5970f39987c2291ceaf258c", + "size": 389385, + "subdir": "linux-64", + "timestamp": 1525880791275, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py35h9852db7_1.conda": { + "build": "py35h9852db7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain", + "md5": "f87dc20f3d9b30835436bf5df29ff615", + "name": "pycrypto", + "sha256": "8886004ca9b1b95cecdcfd418e050f413daca43cb72ea763c857b18f8857cf4e", + "size": 390542, + "subdir": "linux-64", + "timestamp": 1505751519886, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py36h14c3975_7.conda": { + "build": "py36h14c3975_7", + "build_number": 7, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "md5": "82aaeaa57e07c2f99d7bd448275186ac", + "name": "pycrypto", + "sha256": "a5244ce0e42c261972529a7da08fa2e485cdbf4b16732de05896226c2bfaf29c", + "size": 387476, + "subdir": "linux-64", + "timestamp": 1518032255619, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py36h14c3975_8.conda": { + "build": "py36h14c3975_8", + "build_number": 8, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "md5": "203adccaf0424056ae0a6216ffc40da7", + "name": "pycrypto", + "sha256": "3d400d606c2fd0e5991e7a6f8c411a1da801089c711860991a72e14a6c697d21", + "size": 387302, + "subdir": "linux-64", + "timestamp": 1525880560244, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py36h14c3975_9.conda": { + "build": "py36h14c3975_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "md5": "aa90647b3cfa7c3f7fc37440aac80514", + "name": "pycrypto", + "sha256": "25c5c7e111db42b55c79b5182da7e8053afff06df407b343332594bd69de778f", + "size": 387173, + "subdir": "linux-64", + "timestamp": 1530915872715, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py36h6998063_1.conda": { + "build": "py36h6998063_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "md5": "9325c1bf140257dbe94d347cc7e4074d", + "name": "pycrypto", + "sha256": "8520dd20a4d8ec15a650c52636df03100c1af66b8a447876c2e72f89f9816286", + "size": 393488, + "subdir": "linux-64", + "timestamp": 1505751622581, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py36h7b6447c_10.conda": { + "build": "py36h7b6447c_10", + "build_number": 10, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain", + "md5": "f09a8614707a8d91adb53768ffea1e69", + "name": "pycrypto", + "sha256": "a30c6fd75c0a736b8a8dea1c815a8d4ec15b8b48467b88bca767d455e2e33462", + "size": 394530, + "subdir": "linux-64", + "timestamp": 1592300573143, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py37h14c3975_9.conda": { + "build": "py37h14c3975_9", + "build_number": 9, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain", + "md5": "bfa67cd18a9565c9305d7d0eff8643e9", + "name": "pycrypto", + "sha256": "2f79a1a39e5acab9ae32f33f0ba97514a15b0d36c241005cc00dafe622c1166a", + "size": 370549, + "subdir": "linux-64", + "timestamp": 1530915641052, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py37h7b6447c_10.conda": { + "build": "py37h7b6447c_10", + "build_number": 10, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain", + "md5": "84546eb10f025448ecc0f321c7b1b6e5", + "name": "pycrypto", + "sha256": "c99478aa9fd1f1194db84a685c8e10877f44962735c86e6144b39f675c29a43d", + "size": 384154, + "subdir": "linux-64", + "timestamp": 1592300557782, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py38h7b6447c_10.conda": { + "build": "py38h7b6447c_10", + "build_number": 10, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain", + "md5": "47f72646ddbfb6bfc6ac314c9ca801cf", + "name": "pycrypto", + "sha256": "c12079b3e9f9c3bd69d651d8a723e24da96ace454006271e075b743e6be09469", + "size": 381851, + "subdir": "linux-64", + "timestamp": 1592300524865, + "version": "2.6.1" + }, + "pycrypto-2.6.1-py39h27cfd23_10.conda": { + "build": "py39h27cfd23_10", + "build_number": 10, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Public Domain", + "md5": "570f9b6fe9842e08400817bc10518cd2", + "name": "pycrypto", + "sha256": "51c737695ab1d961f97b21c5f6d5b4549322f4e96fb49a6351a275903672743a", + "size": 381893, + "subdir": "linux-64", + "timestamp": 1608509342519, + "version": "2.6.1" + }, + "pycryptodome-3.10.1-py310hdd9d17f_0.conda": { + "build": "py310hdd9d17f_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "80e1ca67e7905882b3d89c9621c8da36", + "name": "pycryptodome", + "sha256": "af2a1e160aba510563a44a2a388b2e6d8c9ffd98d3ebed4f430dc4b64ce49367", + "size": 1528093, + "subdir": "linux-64", + "timestamp": 1640792917597, + "version": "3.10.1" + }, + "pycryptodome-3.10.1-py36h3dc18e1_0.conda": { + "build": "py36h3dc18e1_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "4bb2fe5d8ae9a8cfad4e8875f7a91e64", + "name": "pycryptodome", + "sha256": "18fce6991367d74e4a101db87f4d0f6af67224a392efb3a4790c561b1d5e03df", + "size": 1354178, + "subdir": "linux-64", + "timestamp": 1613764662992, + "version": "3.10.1" + }, + "pycryptodome-3.10.1-py37h3dc18e1_0.conda": { + "build": "py37h3dc18e1_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "4b2d6c9d515f37ec61a0408661acf278", + "name": "pycryptodome", + "sha256": "72f35adb9b60a84d7f81d77eb79ae9ae08bf31805fe8884c6771dd7e1cb9c434", + "size": 1325468, + "subdir": "linux-64", + "timestamp": 1613763878003, + "version": "3.10.1" + }, + "pycryptodome-3.10.1-py38h3dc18e1_0.conda": { + "build": "py38h3dc18e1_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "3f908b6a9df94bcefe7eebbf1f1e3b6e", + "name": "pycryptodome", + "sha256": "de4eaa5fc6b0681cebfaaa6351ab38911e2f2736144f1e401078a3ff204e9281", + "size": 1326715, + "subdir": "linux-64", + "timestamp": 1613764643100, + "version": "3.10.1" + }, + "pycryptodome-3.10.1-py39h3dc18e1_0.conda": { + "build": "py39h3dc18e1_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "32d7f4371123c340fe93cc8b0f08a6ea", + "name": "pycryptodome", + "sha256": "42c745cf8f4b9f1ab336409f89117471a24af894db91cff11658b2dce1af53e5", + "size": 1336367, + "subdir": "linux-64", + "timestamp": 1613764661809, + "version": "3.10.1" + }, + "pycryptodome-3.12.0-py37hdd9d17f_0.conda": { + "build": "py37hdd9d17f_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause AND Unlicense", + "license_family": "BSD", + "md5": "abe764a2b55ec40d520f70275bfd6dc3", + "name": "pycryptodome", + "sha256": "224cbb2068cd95fba19a0be35033ddf64b464c20ecc3333a45d73adfcbe5fc01", + "size": 1354429, + "subdir": "linux-64", + "timestamp": 1641468817030, + "version": "3.12.0" + }, + "pycryptodome-3.12.0-py38hdd9d17f_0.conda": { + "build": "py38hdd9d17f_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause AND Unlicense", + "license_family": "BSD", + "md5": "6ad7e56b8f38fbd44474958788ad3e40", + "name": "pycryptodome", + "sha256": "4b76c36aa870766f363ca49eadb3dbc901bbe6c7dff966e0f45a9ffdf9b4d270", + "size": 1367426, + "subdir": "linux-64", + "timestamp": 1641468826979, + "version": "3.12.0" + }, + "pycryptodome-3.12.0-py39hdd9d17f_0.conda": { + "build": "py39hdd9d17f_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause AND Unlicense", + "license_family": "BSD", + "md5": "3a30e810f95dd1d2d3791f4dc069ef3c", + "name": "pycryptodome", + "sha256": "c28123445ebfd7a17697df90995e9edaba466839d8026133080b8ac5811db790", + "size": 1353452, + "subdir": "linux-64", + "timestamp": 1641468814807, + "version": "3.12.0" + }, + "pycryptodome-3.15.0-py310h276157c_0.conda": { + "build": "py310h276157c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause AND Unlicense", + "license_family": "BSD", + "md5": "1457fd58c15a0b65b1f26f87aaaaf906", + "name": "pycryptodome", + "sha256": "da995d5a38c43a0d83587957d28528a8682a3b1307f631716c951ea5a18d8a12", + "size": 1692002, + "subdir": "linux-64", + "timestamp": 1658311109929, + "version": "3.15.0" + }, + "pycryptodome-3.15.0-py311h276157c_0.conda": { + "build": "py311h276157c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause AND Unlicense", + "license_family": "BSD", + "md5": "d6006747843b92d627515a54f63c18da", + "name": "pycryptodome", + "sha256": "add4487dcdd93940cae75f550c27078ccc0b088e7d8e6c0235e8b26f31bdf5a6", + "size": 1569291, + "subdir": "linux-64", + "timestamp": 1676842099194, + "version": "3.15.0" + }, + "pycryptodome-3.15.0-py37h276157c_0.conda": { + "build": "py37h276157c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause AND Unlicense", + "license_family": "BSD", + "md5": "874f2f534e347f17db19a86e24f95a41", + "name": "pycryptodome", + "sha256": "7863ade9056113a48d45a37bc0c26e1d14b5ad5bdb90915f6fe3f91f72e03564", + "size": 1420395, + "subdir": "linux-64", + "timestamp": 1658311052169, + "version": "3.15.0" + }, + "pycryptodome-3.15.0-py38h276157c_0.conda": { + "build": "py38h276157c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause AND Unlicense", + "license_family": "BSD", + "md5": "9e28842507510bf0ad3894dd57f32223", + "name": "pycryptodome", + "sha256": "487477c698c3e68e52b55f421f3b4c3bdc8a87812db41a0ff14a939059b030a6", + "size": 1419476, + "subdir": "linux-64", + "timestamp": 1658311204402, + "version": "3.15.0" + }, + "pycryptodome-3.15.0-py39h276157c_0.conda": { + "build": "py39h276157c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause AND Unlicense", + "license_family": "BSD", + "md5": "b22453d24f1e69c779c664c0428b7d80", + "name": "pycryptodome", + "sha256": "fede0d9e51b903f01c72baf3ff9790457de93cda9fdf4fe3209e7584c2e7aab7", + "size": 1419189, + "subdir": "linux-64", + "timestamp": 1658311156796, + "version": "3.15.0" + }, + "pycryptodome-3.6.6-py27hb69a4c5_0.conda": { + "build": "py27hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "8956d5bf7ab4729d6c66a906a8c8f87a", + "name": "pycryptodome", + "sha256": "fc59c65d5eac3adb569360908772e303633837d542fd5737678f1ba9d2b5b22d", + "size": 5296471, + "subdir": "linux-64", + "timestamp": 1539803850892, + "version": "3.6.6" + }, + "pycryptodome-3.6.6-py36hb69a4c5_0.conda": { + "build": "py36hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "260a8bc50d9f370a47801388d7964ea6", + "name": "pycryptodome", + "sha256": "3ecc30456edaa99d1167083668531dd9366a259185970710fb0db585a5270c4e", + "size": 5356052, + "subdir": "linux-64", + "timestamp": 1539809133235, + "version": "3.6.6" + }, + "pycryptodome-3.6.6-py37hb69a4c5_0.conda": { + "build": "py37hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "0590b051692aacb03787b8a7f155a441", + "name": "pycryptodome", + "sha256": "b94db8d196fbccf47350b38ae9006acb8da4fcca065d33e6a7db8e3bde64cdba", + "size": 5291372, + "subdir": "linux-64", + "timestamp": 1539803880819, + "version": "3.6.6" + }, + "pycryptodome-3.7.0-py27hb69a4c5_0.conda": { + "build": "py27hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "44585e94ea29d8605460001e4c8aa651", + "name": "pycryptodome", + "sha256": "e5b3242b051863b56391980354e07df94b0a8ce044f4c61b4e20e4f6a5a895fa", + "size": 5354537, + "subdir": "linux-64", + "timestamp": 1541018531531, + "version": "3.7.0" + }, + "pycryptodome-3.7.0-py36hb69a4c5_0.conda": { + "build": "py36hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "96d0f949143819486dae163f3732a64b", + "name": "pycryptodome", + "sha256": "dcc3733c782df2c923a789a2a82f27c038ea8ea7d1dc7a5ccab6ed319103d267", + "size": 5376900, + "subdir": "linux-64", + "timestamp": 1541018587880, + "version": "3.7.0" + }, + "pycryptodome-3.7.0-py37hb69a4c5_0.conda": { + "build": "py37hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "6d4dacb3092b91d88acdd084f6abfd39", + "name": "pycryptodome", + "sha256": "a895bc98da94c5f853d716612538abd333d826ebb26a05c048c0b87ba60da10f", + "size": 5353146, + "subdir": "linux-64", + "timestamp": 1541018482890, + "version": "3.7.0" + }, + "pycryptodome-3.7.2-py27hb69a4c5_0.conda": { + "build": "py27hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "b1e73fcf7579856923f713c6a66b3c49", + "name": "pycryptodome", + "sha256": "95d8b433fccd51468dcf76c6ee0353464e0ff7aea14a1af81209ca0a3a422c7e", + "size": 5378277, + "subdir": "linux-64", + "timestamp": 1545131988090, + "version": "3.7.2" + }, + "pycryptodome-3.7.2-py36hb69a4c5_0.conda": { + "build": "py36hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "0195a7f78f824390ba30c687d7c0771d", + "name": "pycryptodome", + "sha256": "29f8c1bb61c78adf72d9b258f54b219f6598a0ab077bfae4a54aa67fd3570cd6", + "size": 5371965, + "subdir": "linux-64", + "timestamp": 1545132038746, + "version": "3.7.2" + }, + "pycryptodome-3.7.2-py37hb69a4c5_0.conda": { + "build": "py37hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "5f1aa771d551541da1aa62ceabfeee4d", + "name": "pycryptodome", + "sha256": "2aa4bcf18d174ee883d7bf20df74bd1788738be76180406e69310c1612c1a679", + "size": 5393696, + "subdir": "linux-64", + "timestamp": 1545132036566, + "version": "3.7.2" + }, + "pycryptodome-3.7.3-py27hb69a4c5_0.conda": { + "build": "py27hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "d028d7e0a2157140f17e4c3d3e6347b1", + "name": "pycryptodome", + "sha256": "c62dec95c3f60b6b6e49dd88bbb017646a24f5ed3a5820734f2c520cebd95c9b", + "size": 5380755, + "subdir": "linux-64", + "timestamp": 1552441507805, + "version": "3.7.3" + }, + "pycryptodome-3.7.3-py36hb69a4c5_0.conda": { + "build": "py36hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "64c2a90392c57cbcdbdbdcd1f1678ee5", + "name": "pycryptodome", + "sha256": "1091f9eb4f0e6af9436f2314cfd320956044f171b80df3d2ebb9716cc9ba28ca", + "size": 5413841, + "subdir": "linux-64", + "timestamp": 1552441805644, + "version": "3.7.3" + }, + "pycryptodome-3.7.3-py37hb69a4c5_0.conda": { + "build": "py37hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "c8f106aafe54d71a20d24248fe86332e", + "name": "pycryptodome", + "sha256": "da5f6c9323cdd7beed064135203b46239390f5c93a389cf99fd7a7b4afe5be35", + "size": 5430851, + "subdir": "linux-64", + "timestamp": 1552441470185, + "version": "3.7.3" + }, + "pycryptodome-3.8.2-py27hb69a4c5_0.conda": { + "build": "py27hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "6b2d6935f4eed325ecc5ab9d67defe7c", + "name": "pycryptodome", + "sha256": "8fa382c9171841f650df7e95f8a738d696a768cb0be3fd27fa5eb7579526f3e0", + "size": 7210002, + "subdir": "linux-64", + "timestamp": 1569426661925, + "version": "3.8.2" + }, + "pycryptodome-3.8.2-py36hb69a4c5_0.conda": { + "build": "py36hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "50662deab3e3292ca79754e411e6edcc", + "name": "pycryptodome", + "sha256": "9d8bbb63a5340de2af8acf5ac190db9c90c16899d660e83bfe26d6e9220a8e7e", + "size": 7202930, + "subdir": "linux-64", + "timestamp": 1569426661913, + "version": "3.8.2" + }, + "pycryptodome-3.8.2-py37hb69a4c5_0.conda": { + "build": "py37hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "f9e69a29ec44b78d6a8d0ffb57dd9920", + "name": "pycryptodome", + "sha256": "8accfb22e5398620fcf28533968b1de528dbd84fce481ebe5c5f20869a696973", + "size": 7172288, + "subdir": "linux-64", + "timestamp": 1569426637685, + "version": "3.8.2" + }, + "pycryptodome-3.8.2-py38hb69a4c5_0.conda": { + "build": "py38hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "2c29572455d45f1c0105dc20bea95a71", + "name": "pycryptodome", + "sha256": "6e0dcf95baf1aa2e601cfcafa1b66a33de22c85205bc1034242fe53ada7bfea8", + "size": 7199675, + "subdir": "linux-64", + "timestamp": 1573668891783, + "version": "3.8.2" + }, + "pycryptodome-3.9.8-py36hb69a4c5_0.conda": { + "build": "py36hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "24dcb0a6b787c1a41345338e9a08d6dd", + "name": "pycryptodome", + "sha256": "3b163e3860f33dc0287483296903340acb36257f76cb6f97843e15b6f897e90e", + "size": 10140427, + "subdir": "linux-64", + "timestamp": 1599232795358, + "version": "3.9.8" + }, + "pycryptodome-3.9.8-py37hb69a4c5_0.conda": { + "build": "py37hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "258515a76e8f3604b76fabb97eb0f311", + "name": "pycryptodome", + "sha256": "b6c3c0f0786c2daac53fa5d781493ad1369c4a38f535af991898f7b7b2070e98", + "size": 10113250, + "subdir": "linux-64", + "timestamp": 1599232787795, + "version": "3.9.8" + }, + "pycryptodome-3.9.8-py38hb69a4c5_0.conda": { + "build": "py38hb69a4c5_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "9aa8b324828f3a90716ab886b614d47b", + "name": "pycryptodome", + "sha256": "090dca68201a31387908d03edefdfcbe4527a1298442fba0a9de8f8039b58bfc", + "size": 10205583, + "subdir": "linux-64", + "timestamp": 1599232772670, + "version": "3.9.8" + }, + "pycryptodome-3.9.9-py36h3dc18e1_0.conda": { + "build": "py36h3dc18e1_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "eb55cb7df943337198a32632fd10013f", + "name": "pycryptodome", + "sha256": "538ebf68f58cdb736af65867af8b994b9e4e97d9648447854dcb81477c8bcc0e", + "size": 10064873, + "subdir": "linux-64", + "timestamp": 1606344657300, + "version": "3.9.9" + }, + "pycryptodome-3.9.9-py37h3dc18e1_0.conda": { + "build": "py37h3dc18e1_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "51de572b78cdebb3dfc6efa17e139f37", + "name": "pycryptodome", + "sha256": "df14487e0bb77edba9f5178929c8e57d3bc9a4c603658fb445c7747541ee889f", + "size": 10059707, + "subdir": "linux-64", + "timestamp": 1606344681392, + "version": "3.9.9" + }, + "pycryptodome-3.9.9-py38h3dc18e1_0.conda": { + "build": "py38h3dc18e1_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "dabfc4421433df84be1a6be5e642db30", + "name": "pycryptodome", + "sha256": "351071d48ff1dc7d2e28e752871c7b5a699539b50aa9f62e74fcda265c0fd9a4", + "size": 10089340, + "subdir": "linux-64", + "timestamp": 1606344679486, + "version": "3.9.9" + }, + "pycryptodome-3.9.9-py39h3dc18e1_0.conda": { + "build": "py39h3dc18e1_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "5bc6b009cf22d30531fd659f52576c6f", + "name": "pycryptodome", + "sha256": "2960ac6c7f472f9056866a89bfa565922d294089e73f1b87240ecc1f4d933939", + "size": 10128403, + "subdir": "linux-64", + "timestamp": 1606344688074, + "version": "3.9.9" + }, + "pycryptodomex-3.10.1-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "0ab66de192a824f9baa8add6fe50d968", + "name": "pycryptodomex", + "sha256": "3be0152088b88a402e4905ce1b503bde3203f216df9d632990c08f6d15cfe35b", + "size": 1526931, + "subdir": "linux-64", + "timestamp": 1640792959074, + "version": "3.10.1" + }, + "pycryptodomex-3.10.1-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "c36ebfa8c6b241884a274fab591b5b59", + "name": "pycryptodomex", + "sha256": "6b58dc63783e59dfd3c49b86317c661ede4a1da523ddf0ecdcb0ff486f8b3574", + "size": 1354686, + "subdir": "linux-64", + "timestamp": 1613763958000, + "version": "3.10.1" + }, + "pycryptodomex-3.10.1-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "a113ad75b585307fba85fd290bd06242", + "name": "pycryptodomex", + "sha256": "ecf2d48929a2478d58a752152a12e386f9e8fe6a37cdfddba8ea1a4ab2ad05ec", + "size": 1323601, + "subdir": "linux-64", + "timestamp": 1613764703991, + "version": "3.10.1" + }, + "pycryptodomex-3.10.1-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "efb7f75fe2f3adce686b47f742f9c77b", + "name": "pycryptodomex", + "sha256": "91753e8d7b592a88b0421cc4316ce7e5f2d4e71f4b4e9810ba4d9287f8cc417d", + "size": 1328104, + "subdir": "linux-64", + "timestamp": 1613763955910, + "version": "3.10.1" + }, + "pycryptodomex-3.10.1-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "9004e1281aca5ec1e6fdee60fdffcc05", + "name": "pycryptodomex", + "sha256": "7b442f7d955c6b1b36f9a1a15908dfd0d3105aa1076a68f9bad5662d710e7a5f", + "size": 1337468, + "subdir": "linux-64", + "timestamp": 1613764704747, + "version": "3.10.1" + }, + "pycryptodomex-3.15.0-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "d2c6d8f949a64283233fc32607b01230", + "name": "pycryptodomex", + "sha256": "7857cb08022aca7576a05c4a72dff5b2012436fa2783efa37f2b9a5c36517a8f", + "size": 1677390, + "subdir": "linux-64", + "timestamp": 1661450313401, + "version": "3.15.0" + }, + "pycryptodomex-3.15.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "d802a21c04600a0331e416bbe2806d99", + "name": "pycryptodomex", + "sha256": "5c35b1b98eeb9b92ac68d371c416808cfb4f5b765ae39b3aebf693629eeec385", + "size": 1570007, + "subdir": "linux-64", + "timestamp": 1676845284621, + "version": "3.15.0" + }, + "pycryptodomex-3.15.0-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "fac5d21765a9d3601502fcf881216028", + "name": "pycryptodomex", + "sha256": "bb81783042013f416371d4b70031e2b7fb6a11ecde55b16de99db02431db9735", + "size": 1406097, + "subdir": "linux-64", + "timestamp": 1661450353999, + "version": "3.15.0" + }, + "pycryptodomex-3.15.0-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "468e07fa178c85533de2e5fae6ffeec3", + "name": "pycryptodomex", + "sha256": "71097f52ade7e0f581c187787b272f14ff480911cd8891ab9b0e997dd41868ca", + "size": 1410190, + "subdir": "linux-64", + "timestamp": 1661450396386, + "version": "3.15.0" + }, + "pycryptodomex-3.15.0-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "24d835b2b7b3d8d8c3f6ce02e6f4f889", + "name": "pycryptodomex", + "sha256": "8503990d8177ca73f5d8f7cd4904bb29e790fcc6021b37f7333a78976d7abbf5", + "size": 1407779, + "subdir": "linux-64", + "timestamp": 1661450257217, + "version": "3.15.0" + }, + "pycryptodomex-3.4.7-py27h7bd1586_0.conda": { + "build": "py27h7bd1586_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "697465695d3be572638a8422b18ed95e", + "name": "pycryptodomex", + "sha256": "d42dd80b8c7dbdcb69ea977c61937bb5f8314e6d078f836712b77d4a1779c0de", + "size": 4911616, + "subdir": "linux-64", + "timestamp": 1512920609224, + "version": "3.4.7" + }, + "pycryptodomex-3.4.7-py35h7a9f3d7_0.conda": { + "build": "py35h7a9f3d7_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "50286b98c5560280dbc83bf7a11a3a5f", + "name": "pycryptodomex", + "sha256": "30d02eb3ba4a70ec0fc72cde2f52d48c0fe1752105ed299429bfb1e16961effc", + "size": 4940833, + "subdir": "linux-64", + "timestamp": 1512920707640, + "version": "3.4.7" + }, + "pycryptodomex-3.4.7-py36h7a9f3d7_0.conda": { + "build": "py36h7a9f3d7_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "b488eb15f9d83ec93547285adb4d309c", + "name": "pycryptodomex", + "sha256": "0f3cebc2264757dc9a412cfb5fe09ec47613a799e5b6dcb82bb1386ccf4d764a", + "size": 4880126, + "subdir": "linux-64", + "timestamp": 1512920707964, + "version": "3.4.7" + }, + "pycryptodomex-3.5.1-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "f7c6e1169cf35b78b26f4fb4dd860c24", + "name": "pycryptodomex", + "sha256": "5068f8ae8d3cdf544381ede50cb02ef4365af223d859d69f28b597edcee457b0", + "size": 5042307, + "subdir": "linux-64", + "timestamp": 1521000325396, + "version": "3.5.1" + }, + "pycryptodomex-3.5.1-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "1f6c7f2deb1502baf8e6197499079ac8", + "name": "pycryptodomex", + "sha256": "f77e0642434c05d83313d321d7aab163deb899df6c27f2b2704b9c5e108f9e51", + "size": 4988904, + "subdir": "linux-64", + "timestamp": 1521000363980, + "version": "3.5.1" + }, + "pycryptodomex-3.5.1-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "0bb9febd64384f020ccba8e63b4d079e", + "name": "pycryptodomex", + "sha256": "fa73a1a61b2d95804a99b90fd626983a1005ba8c21164e26633b3ff64ee7f766", + "size": 4935091, + "subdir": "linux-64", + "timestamp": 1521000358680, + "version": "3.5.1" + }, + "pycryptodomex-3.6.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "9f995d8ab4d800ae92252d4272dfc654", + "name": "pycryptodomex", + "sha256": "6ab244c7f196d3f68ce4d1861690046741b1dc406c22af24d998aaeecc8e7a10", + "size": 5050692, + "subdir": "linux-64", + "timestamp": 1523431477372, + "version": "3.6.0" + }, + "pycryptodomex-3.6.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "c06e821de9b08927e478208fe4a7ff56", + "name": "pycryptodomex", + "sha256": "f22202bdf5bb63344d3256810de40b9715677f277b142707e4e028dc2cbbe84a", + "size": 5021787, + "subdir": "linux-64", + "timestamp": 1523431429681, + "version": "3.6.0" + }, + "pycryptodomex-3.6.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "f83cc64397b7d4ba7927c5d0513f797f", + "name": "pycryptodomex", + "sha256": "f647a65b81bd186075d4fa983971e2313d964902f82b4d367a12c3bf03492553", + "size": 4982288, + "subdir": "linux-64", + "timestamp": 1523431420323, + "version": "3.6.0" + }, + "pycryptodomex-3.6.1-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "030b27e770a48302d6899081d82768ae", + "name": "pycryptodomex", + "sha256": "e98034e6673d10a3d9d0a7af4caa7dfc4acadfa0153ee058beb52d5d7107f7ad", + "size": 5317478, + "subdir": "linux-64", + "timestamp": 1524516470678, + "version": "3.6.1" + }, + "pycryptodomex-3.6.1-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "5d2512b9021982c27abbc71e2a82891f", + "name": "pycryptodomex", + "sha256": "c665f42d57e7464f11815170d3e0dd57f2296d0492d404b19e32f8c40761bb91", + "size": 5337292, + "subdir": "linux-64", + "timestamp": 1524516212110, + "version": "3.6.1" + }, + "pycryptodomex-3.6.1-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "5b1b897b0c184f9bccb898d3318bcd07", + "name": "pycryptodomex", + "sha256": "467b3af6d4cca19ae53864e04ba85b4c0da378df930fde1cf0c1c559fa2d6104", + "size": 5286062, + "subdir": "linux-64", + "timestamp": 1524516751806, + "version": "3.6.1" + }, + "pycryptodomex-3.6.3-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "5bc4e0afa9af49e82e488ddb5924d00f", + "name": "pycryptodomex", + "sha256": "eb3623f22479c24d0f59641325958875c45a573c6a870b678b88df5e808c9d42", + "size": 5297552, + "subdir": "linux-64", + "timestamp": 1529956986873, + "version": "3.6.3" + }, + "pycryptodomex-3.6.3-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "67ecdcb915665cd376ac66f4b102adbc", + "name": "pycryptodomex", + "sha256": "5a61785313c5bac3a9ba6974aa2d8637186a4681cb189a9b1cd303490c60eb26", + "size": 5332649, + "subdir": "linux-64", + "timestamp": 1529957011975, + "version": "3.6.3" + }, + "pycryptodomex-3.6.3-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "62b176f2d976460e204f042c1490f77f", + "name": "pycryptodomex", + "sha256": "9c38eae5cd929acf4f54734a955604c75a4427e6914a9cc95c8072597769037f", + "size": 5327097, + "subdir": "linux-64", + "timestamp": 1529957335934, + "version": "3.6.3" + }, + "pycryptodomex-3.6.3-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "32ce97a7853bce705f32ee4d912d0e22", + "name": "pycryptodomex", + "sha256": "674fc1e6830bbf5c4eff712e968b271e94e86a1dd9a6cafa2fcf03689bd4b678", + "size": 5369799, + "subdir": "linux-64", + "timestamp": 1530915946733, + "version": "3.6.3" + }, + "pycryptodomex-3.6.4-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "a0597ded25ce6304f06873c644d314c7", + "name": "pycryptodomex", + "sha256": "fcb22a53949bacd25eacdfdae79d237efacfd7b249866de3297e200507f01a57", + "size": 5332481, + "subdir": "linux-64", + "timestamp": 1535429260814, + "version": "3.6.4" + }, + "pycryptodomex-3.6.4-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "3dfa3427b4a90a0cbb308e07f950a2c6", + "name": "pycryptodomex", + "sha256": "6b1594516bf00fed90b5c4e6a91cb02d9f7f883f75a070ea18eab7a2ff5701aa", + "size": 5351122, + "subdir": "linux-64", + "timestamp": 1535429381750, + "version": "3.6.4" + }, + "pycryptodomex-3.6.4-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "25895956a5c6dfad5cc33587abd9cb3d", + "name": "pycryptodomex", + "sha256": "8770417f09e65c6e8f7f0eaa8a1bdcdb50ee57970c2e469cff4c3ba646aed36e", + "size": 5335748, + "subdir": "linux-64", + "timestamp": 1535429320871, + "version": "3.6.4" + }, + "pycryptodomex-3.6.4-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "a2721e1ca7adffdacdffefa7c258606b", + "name": "pycryptodomex", + "sha256": "3ba687e70d0f2e1489c4a57ef765bc0ed3ae5e35a63db1164679bb602c445007", + "size": 5320543, + "subdir": "linux-64", + "timestamp": 1535429380919, + "version": "3.6.4" + }, + "pycryptodomex-3.6.6-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "188d43dc0712ab8630b34a5ae64e7934", + "name": "pycryptodomex", + "sha256": "93da76ec6363c545428d2a9252c425a8cae78fc9f7b4cc21deff3a8be74397b2", + "size": 5320089, + "subdir": "linux-64", + "timestamp": 1536263990536, + "version": "3.6.6" + }, + "pycryptodomex-3.6.6-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "2f4ebbc1fd718746e1af4399a0d7b1a9", + "name": "pycryptodomex", + "sha256": "3f1b1ffd8ad0d297bafc927df25c860428ded47b8315f66302d43ca0788fee23", + "size": 5325245, + "subdir": "linux-64", + "timestamp": 1536264036449, + "version": "3.6.6" + }, + "pycryptodomex-3.6.6-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "5ff005abbf352d92721e5c04c677f2fb", + "name": "pycryptodomex", + "sha256": "69128b3f6949a7277d01689278612db6143f98ebe0658c74cbb41e039b929bce", + "size": 5336418, + "subdir": "linux-64", + "timestamp": 1536263974173, + "version": "3.6.6" + }, + "pycryptodomex-3.6.6-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "065a682cde8f3e26a6698bc2fe26251d", + "name": "pycryptodomex", + "sha256": "9a7281cb2fc147ab8528e93aed0c6915b3a3c01a5b1e174a368a6c0023b7e89e", + "size": 5319981, + "subdir": "linux-64", + "timestamp": 1536264014294, + "version": "3.6.6" + }, + "pycryptodomex-3.7.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "c79e8d18c749e77056b9d255b28e948c", + "name": "pycryptodomex", + "sha256": "9f599d61e264500988d4e8296010ac042b060bb17aac543c1205174b5056869d", + "size": 5358624, + "subdir": "linux-64", + "timestamp": 1541020448493, + "version": "3.7.0" + }, + "pycryptodomex-3.7.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "edfa66c02c58d651f7229c26fa8372c0", + "name": "pycryptodomex", + "sha256": "4ec3402df4eedf1fc864420fca806cf0abd81af5ed969ffed4a7a7f4313d99f2", + "size": 5370320, + "subdir": "linux-64", + "timestamp": 1541020432219, + "version": "3.7.0" + }, + "pycryptodomex-3.7.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "971d78051e99009ccced894117c5b11f", + "name": "pycryptodomex", + "sha256": "842d04e0123ec33ddecc3a63c613d95b9c8791c4fc09ad873c4f8e046d4a129b", + "size": 5388102, + "subdir": "linux-64", + "timestamp": 1541020406321, + "version": "3.7.0" + }, + "pycryptodomex-3.7.2-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "9ae0d3786f72d864159e286c174ca833", + "name": "pycryptodomex", + "sha256": "8233cff88aeacbcd0fc2903ea6f7c61e07fd4c6c6443c60cfa5f29e371f8b10b", + "size": 5370398, + "subdir": "linux-64", + "timestamp": 1545167269030, + "version": "3.7.2" + }, + "pycryptodomex-3.7.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "90e5949a8aa72ba7271b68e7f3dc83b0", + "name": "pycryptodomex", + "sha256": "fa0a544407a1edfa69f815d83b103cf33d70533e27dd5e199e51281aa559c801", + "size": 5418319, + "subdir": "linux-64", + "timestamp": 1545167221690, + "version": "3.7.2" + }, + "pycryptodomex-3.7.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "a80dbd3a119792f779ca3f70502b09e9", + "name": "pycryptodomex", + "sha256": "f0290dd6085b09693e34a1181e5b5ae92908771a6404dc377851c73c81537bdb", + "size": 5411154, + "subdir": "linux-64", + "timestamp": 1545167318806, + "version": "3.7.2" + }, + "pycryptodomex-3.8.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "7e915f758c47229f4f408877ea7bc710", + "name": "pycryptodomex", + "sha256": "2c04597cc1a4a40880359b0af9a51e8184ef61d50e9d7cb671b8fbc061752299", + "size": 7147714, + "subdir": "linux-64", + "timestamp": 1556085015923, + "version": "3.8.1" + }, + "pycryptodomex-3.8.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "f3e3d7cc0de9f3035777f8308354719b", + "name": "pycryptodomex", + "sha256": "a32b8b3f0c6b11dfeea8c979331b085195f47b16a50304cf98b2374d64a30e4e", + "size": 7123870, + "subdir": "linux-64", + "timestamp": 1556085034629, + "version": "3.8.1" + }, + "pycryptodomex-3.8.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "4aa1f2635014d01a21421c25450ca20f", + "name": "pycryptodomex", + "sha256": "ff130a09e9732507dfe6958abf06c352d2ea76b089e3c682ee1d0caa839255b7", + "size": 7145367, + "subdir": "linux-64", + "timestamp": 1556085012113, + "version": "3.8.1" + }, + "pycryptodomex-3.9.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "4fa984401e2ab69bcee6a3a30bc2e6e9", + "name": "pycryptodomex", + "sha256": "91ecc25e28465614e72a5d7d5b2bf4f4d717dfce2ae071651c13e4a92320804b", + "size": 7231699, + "subdir": "linux-64", + "timestamp": 1569419712299, + "version": "3.9.0" + }, + "pycryptodomex-3.9.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "0d2fa53bf1f6207c263e623a82c20cf3", + "name": "pycryptodomex", + "sha256": "843bc5f8d70448879683efc5a6c9d2e65fd0d4b2bbab4505fffb95b6903239e1", + "size": 7209608, + "subdir": "linux-64", + "timestamp": 1569419712729, + "version": "3.9.0" + }, + "pycryptodomex-3.9.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "053c7bee408bd719924b934c50fd9a54", + "name": "pycryptodomex", + "sha256": "2753671ce50748a6987e491527f776dfc06f8a46347dd525fc4c44bff59c0c3b", + "size": 7229234, + "subdir": "linux-64", + "timestamp": 1569419721576, + "version": "3.9.0" + }, + "pycryptodomex-3.9.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "d57592bc00302db35dc3a6b192ab86ee", + "name": "pycryptodomex", + "sha256": "380491d65bcc84304bcec3a3599db02ffe64ee7c6453ce86e70a7ebbc5949636", + "size": 7205519, + "subdir": "linux-64", + "timestamp": 1573668962729, + "version": "3.9.0" + }, + "pycryptodomex-3.9.3-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "28052d560fd602fe240042a513d95973", + "name": "pycryptodomex", + "sha256": "cc264f4b66d5046d750553cdc91c280e69ae0a54fddd414fe1c1561bb1e0240c", + "size": 7228688, + "subdir": "linux-64", + "timestamp": 1573971277735, + "version": "3.9.3" + }, + "pycryptodomex-3.9.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "8bba5e72a5740bc6d89150687fdc2732", + "name": "pycryptodomex", + "sha256": "6e55f59c6fa4b243f2b9a4ebb953f139cac556d0ad5087991598fee061f2a7ad", + "size": 7169381, + "subdir": "linux-64", + "timestamp": 1573971235113, + "version": "3.9.3" + }, + "pycryptodomex-3.9.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "5161c73064fab7dcf75ceddf98615b83", + "name": "pycryptodomex", + "sha256": "912734f67f9327cbb24f91526a6d3f4ca630512a494dd14ecde6db29775e36a3", + "size": 7216916, + "subdir": "linux-64", + "timestamp": 1573971277624, + "version": "3.9.3" + }, + "pycryptodomex-3.9.3-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "e555355baa5fea2112f57bbad23525d6", + "name": "pycryptodomex", + "sha256": "3d3ee0b2bac9a1161b727cf631136ad2422970da9613bc7a97cad297cf9cb802", + "size": 7187767, + "subdir": "linux-64", + "timestamp": 1573971263795, + "version": "3.9.3" + }, + "pycryptodomex-3.9.4-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "8121927f8f109f591ea09d792bcdcf79", + "name": "pycryptodomex", + "sha256": "c3fc6c2cb71aaf052d81cbe5edf31eeba5aec463cf0f78341f5842a67a6c228f", + "size": 7221030, + "subdir": "linux-64", + "timestamp": 1574369080248, + "version": "3.9.4" + }, + "pycryptodomex-3.9.4-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "db6113a8e75e3b29a0ce22113f081094", + "name": "pycryptodomex", + "sha256": "a641098e4a11ac1e7e117b38a66fdf8b98694b0aff874ad26e066b8bf3d2a4e8", + "size": 7256286, + "subdir": "linux-64", + "timestamp": 1574369026161, + "version": "3.9.4" + }, + "pycryptodomex-3.9.4-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "bd555d601169d1e0bfafdfb38efb18cc", + "name": "pycryptodomex", + "sha256": "f02d1c05198f90e44af962f5e0f615a3e325362a614b06452352f78b528c5a01", + "size": 7240998, + "subdir": "linux-64", + "timestamp": 1574369078578, + "version": "3.9.4" + }, + "pycryptodomex-3.9.4-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "b13cc7a329c0397bbf229661cfab4384", + "name": "pycryptodomex", + "sha256": "732b979969aa26bd0aefdec07a8c6fb2664f3b841195887473d00d4a48cd0c48", + "size": 7147563, + "subdir": "linux-64", + "timestamp": 1574369083751, + "version": "3.9.4" + }, + "pycryptodomex-3.9.7-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "4c26dcbefab89ca687cbb3080682bc61", + "name": "pycryptodomex", + "sha256": "7b1a05272db0b056e1a8debcad6b6940812c8011be7d0cf37f33b14964188290", + "size": 10199902, + "subdir": "linux-64", + "timestamp": 1588595738822, + "version": "3.9.7" + }, + "pycryptodomex-3.9.7-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "5b877ed14f24e0ef6e2148e814ecf306", + "name": "pycryptodomex", + "sha256": "a5da33467c7a96f7594fb0a8ba059d26a5c73e6f4b3d8d50a06cccf712cd82b7", + "size": 10178556, + "subdir": "linux-64", + "timestamp": 1588595716620, + "version": "3.9.7" + }, + "pycryptodomex-3.9.7-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "9adac3d0d565b17f485bae39bcb26611", + "name": "pycryptodomex", + "sha256": "4b5f4b0482a734185ce14a7d1fe6cd3b5ed3c78402a046031bc177fdbbaa7df2", + "size": 10064189, + "subdir": "linux-64", + "timestamp": 1588595739806, + "version": "3.9.7" + }, + "pycryptodomex-3.9.8-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "d7b72d1b63382ba428b4064a15763573", + "name": "pycryptodomex", + "sha256": "3ca77a725d4d9de3d5aff238cec9c99f58e1b80d3d193e568a0d1c19a8f09798", + "size": 10188199, + "subdir": "linux-64", + "timestamp": 1593483503615, + "version": "3.9.8" + }, + "pycryptodomex-3.9.8-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "a4ccd6a9d1c90cc6bea849589113c05b", + "name": "pycryptodomex", + "sha256": "e03a4fad89883fddf89382bfc33ecc4fdac1e1e9acfd5bd156aa0e738a636e8f", + "size": 10098758, + "subdir": "linux-64", + "timestamp": 1593483527021, + "version": "3.9.8" + }, + "pycryptodomex-3.9.8-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "15421abdc0acda8df41026a06ef1a74e", + "name": "pycryptodomex", + "sha256": "69f30485cb5f3f10d33bfbcdae5c5dc5327df84c059c0214ceb621a57d288674", + "size": 10244518, + "subdir": "linux-64", + "timestamp": 1593483505833, + "version": "3.9.8" + }, + "pycryptodomex-3.9.9-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "ad5319d7c417c1baaecebf13cbe965f2", + "name": "pycryptodomex", + "sha256": "2bb2c0d86c0cacb0778c6bff719ddc3a5e38cbe10d629f136c148e99b82e8fec", + "size": 10116002, + "subdir": "linux-64", + "timestamp": 1605123956629, + "version": "3.9.9" + }, + "pycryptodomex-3.9.9-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "cbce25de241aec014d7c5da35a569325", + "name": "pycryptodomex", + "sha256": "f3724333b76742d9a4371929df08eea1a558ca129ec538b903649da6bf259b58", + "size": 10092625, + "subdir": "linux-64", + "timestamp": 1605123932709, + "version": "3.9.9" + }, + "pycryptodomex-3.9.9-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "gmp", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Public Domain/BSD 2-Clause/OCB/MPIR", + "md5": "0281b25eba3e9e60c11329082af44be1", + "name": "pycryptodomex", + "sha256": "1354fbb8505bc3aad017609117d802c7d5a7eb21c66da7499630668a404b922f", + "size": 10296146, + "subdir": "linux-64", + "timestamp": 1605123929892, + "version": "3.9.9" + }, + "pycryptosat-5.6.6-py27h0e08187_0.conda": { + "build": "py27h0e08187_0", + "build_number": 0, + "depends": [ + "libcryptominisat 5.6.6 h0e08187_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "88686f42a30ac308537b0895a7fcd1c9", + "name": "pycryptosat", + "sha256": "daf34bc3c520071f1a1866fc98113ac7f0467c26214168089f2f94c4e1834ffa", + "size": 89921, + "subdir": "linux-64", + "timestamp": 1548446984129, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py310h3826bc1_0.conda": { + "build": "py310h3826bc1_0", + "build_number": 0, + "depends": [ + "libcryptominisat 5.6.6 h3826bc1_0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "zlib" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7add0940b86605c0621b67818675318b", + "name": "pycryptosat", + "sha256": "a78fcd73936f4614df325f419f86243c4021f36c861009089bdd5e4c5dfab8bf", + "size": 83815, + "subdir": "linux-64", + "timestamp": 1641901808399, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py310h9e868ea_1.conda": { + "build": "py310h9e868ea_1", + "build_number": 1, + "depends": [ + "libcryptominisat 5.6.6 h9e868ea_1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "289b6a730557bad6d780201eef0d0131", + "name": "pycryptosat", + "sha256": "56e61c461499b8156deb7753ccba2a4c6519ee4266982c98f2e1c8d01f6487af", + "size": 25929, + "subdir": "linux-64", + "timestamp": 1676726369899, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py310h9e868ea_2.conda": { + "build": "py310h9e868ea_2", + "build_number": 2, + "depends": [ + "libcryptominisat 5.6.6 h9e868ea_2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8454339b30eefe7c0cba3f186065f0df", + "name": "pycryptosat", + "sha256": "d07448bb5477631582e5debc0bbdaab53dabfa459d6fdb9d0d80935a73552788", + "size": 26166, + "subdir": "linux-64", + "timestamp": 1679313547349, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py311h9e868ea_1.conda": { + "build": "py311h9e868ea_1", + "build_number": 1, + "depends": [ + "libcryptominisat 5.6.6 h9e868ea_1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ae43ac0d2ddd73b27cc126600edf56fe", + "name": "pycryptosat", + "sha256": "1b06b9e7360343176d1a3a51177f3d33abb3fe9791c000a3344b46d8c4c72de7", + "size": 24596, + "subdir": "linux-64", + "timestamp": 1676851762487, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py311h9e868ea_2.conda": { + "build": "py311h9e868ea_2", + "build_number": 2, + "depends": [ + "libcryptominisat 5.6.6 h9e868ea_2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f221a986e6296480bf6c8fb9c18de02f", + "name": "pycryptosat", + "sha256": "97efbb4c335bf430968df606029fbcdfb77819a2a02520d39f09166f28037986", + "size": 26207, + "subdir": "linux-64", + "timestamp": 1679313761399, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py36h0e08187_0.conda": { + "build": "py36h0e08187_0", + "build_number": 0, + "depends": [ + "libcryptominisat 5.6.6 h0e08187_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b18b2fdc136fe0daedac20c7ce48080", + "name": "pycryptosat", + "sha256": "b3735f0087d7e73413114d41739892f0e78fafd8d35bec76dba6a073438063c4", + "size": 88317, + "subdir": "linux-64", + "timestamp": 1548447080868, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py36hc0fe6c6_0.conda": { + "build": "py36hc0fe6c6_0", + "build_number": 0, + "depends": [ + "libcryptominisat 5.6.6 hc0fe6c6_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zlib" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "25f47c1cf5c3058604f6e96d3ae45e0d", + "name": "pycryptosat", + "sha256": "6997bb5cb135a1f7a54b40531c42776d15248c544216e0b06b8c19d66e905231", + "size": 89646, + "subdir": "linux-64", + "timestamp": 1611760492942, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py37h0e08187_0.conda": { + "build": "py37h0e08187_0", + "build_number": 0, + "depends": [ + "libcryptominisat 5.6.6 h0e08187_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1dd554657678e21b35335c77bb3520c4", + "name": "pycryptosat", + "sha256": "6afd31e035d4fdb9be0c49ecfe41cf25d40c9ccb5ae0ad9a9517351ca57f2fca", + "size": 89184, + "subdir": "linux-64", + "timestamp": 1548447284391, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py37h9e868ea_1.conda": { + "build": "py37h9e868ea_1", + "build_number": 1, + "depends": [ + "libcryptominisat 5.6.6 h9e868ea_1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8ac88ca7d17201a69f9fe3c94d2a6ad", + "name": "pycryptosat", + "sha256": "82f076541d861d064b94c99a4ce4dfddd8e8551603088b170280514d01d130bd", + "size": 101032, + "subdir": "linux-64", + "timestamp": 1676726271564, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py37hc0fe6c6_0.conda": { + "build": "py37hc0fe6c6_0", + "build_number": 0, + "depends": [ + "libcryptominisat 5.6.6 hc0fe6c6_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zlib" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa2a3a8c68375e5a9c7dd2451b75a05c", + "name": "pycryptosat", + "sha256": "86b8ff01b4a8fbb05648703373be5083f4b6a3ae0179c243375909efd9534ee2", + "size": 90516, + "subdir": "linux-64", + "timestamp": 1611760411725, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py38h9e868ea_1.conda": { + "build": "py38h9e868ea_1", + "build_number": 1, + "depends": [ + "libcryptominisat 5.6.6 h9e868ea_1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6061f790edb440a72da3222158eefb78", + "name": "pycryptosat", + "sha256": "3aba817e79a5abe3f24bf731eaaab7e45ae63bfd25c5253674ef0c6cafa159f1", + "size": 101921, + "subdir": "linux-64", + "timestamp": 1676726173531, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py38h9e868ea_2.conda": { + "build": "py38h9e868ea_2", + "build_number": 2, + "depends": [ + "libcryptominisat 5.6.6 h9e868ea_2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "846c8ee5e9402c2c20d06cf7bbada210", + "name": "pycryptosat", + "sha256": "ae8c51176f8967a69c7c1ef779f2547348dd5f5a5e374677b55249288909ab39", + "size": 102505, + "subdir": "linux-64", + "timestamp": 1679313661138, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py38hc0fe6c6_0.conda": { + "build": "py38hc0fe6c6_0", + "build_number": 0, + "depends": [ + "libcryptominisat 5.6.6 hc0fe6c6_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zlib" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "73b731e868fc8ffe5721ca26a524747d", + "name": "pycryptosat", + "sha256": "9c24c27cad9e17f1d562d1028d5e8e431a752e3cd2a7119d172f3f146ac86a36", + "size": 90939, + "subdir": "linux-64", + "timestamp": 1611760405141, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py39h9e868ea_1.conda": { + "build": "py39h9e868ea_1", + "build_number": 1, + "depends": [ + "libcryptominisat 5.6.6 h9e868ea_1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37a6499a5fb1bc632690107a32a006fe", + "name": "pycryptosat", + "sha256": "a166530a6823d63d52b4a68807d5c4e6d825b657039e86f00bb48be4fd61ea0f", + "size": 101422, + "subdir": "linux-64", + "timestamp": 1676726061171, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py39h9e868ea_2.conda": { + "build": "py39h9e868ea_2", + "build_number": 2, + "depends": [ + "libcryptominisat 5.6.6 h9e868ea_2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a02cb029bbcc6a5c29a6f4356dc96489", + "name": "pycryptosat", + "sha256": "4d0c60cfa725c5fa1753d05edafe11091311a3aa20d95997941414ddcd1239b5", + "size": 102066, + "subdir": "linux-64", + "timestamp": 1679313859841, + "version": "5.6.6" + }, + "pycryptosat-5.6.6-py39hc0fe6c6_0.conda": { + "build": "py39hc0fe6c6_0", + "build_number": 0, + "depends": [ + "libcryptominisat 5.6.6 hc0fe6c6_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "zlib" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a81517062fc7dd22e9c18ae707b91961", + "name": "pycryptosat", + "sha256": "0a30ad26f2402039b66e74a0c2443e4c016a07a796848619383f60d74e4058d8", + "size": 90163, + "subdir": "linux-64", + "timestamp": 1611760486040, + "version": "5.6.6" + }, + "pyct-0.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "dace8b9a151f5833fd93eaee4fab9210", + "name": "pyct", + "sha256": "fb1daf3bff22d4479fc2cfb8efdf68d69468f4d4022cb917c025f0bd3b04d212", + "size": 14812, + "subdir": "linux-64", + "timestamp": 1527635899999, + "version": "0.4.2" + }, + "pyct-0.4.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "5a51750c8b5cba42b1f89150d3f51e3b", + "name": "pyct", + "sha256": "7bc9d9b61ccc459c1a98303e92d2f5a47a205de51bb0f3009fde9d9f5a449af8", + "size": 14961, + "subdir": "linux-64", + "timestamp": 1527635896722, + "version": "0.4.2" + }, + "pyct-0.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3", + "license_family": "BSD", + "md5": "1fdb4a7d5e29a00a4ab403e93c3d8a3c", + "name": "pyct", + "sha256": "44d3f7104c140235f2e1d244a536482bc5ddcb425304c96d7f6ee5c62f345ec6", + "size": 14615, + "subdir": "linux-64", + "timestamp": 1527635820462, + "version": "0.4.2" + }, + "pyct-0.4.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7ae1091095dad250a3e4da97ff9ded98", + "name": "pyct", + "sha256": "88f2268a2a2157f4de635b871a2baaee264a70366cda2470d37d789c8990de13", + "size": 16657, + "subdir": "linux-64", + "timestamp": 1529429092910, + "version": "0.4.3" + }, + "pyct-0.4.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "78e219fab59a95e94cdb39424adf0a6e", + "name": "pyct", + "sha256": "441c1f0d19009834609f2ff969e53cccbf7391c6bcec0f86ced22ddfc3055616", + "size": 16827, + "subdir": "linux-64", + "timestamp": 1529429114475, + "version": "0.4.3" + }, + "pyct-0.4.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ab47021970110a8e0bd74adaaaf054dd", + "name": "pyct", + "sha256": "6248d0297d26979e7a5929673c0656331f571ee30e605730d72580a5478cc463", + "size": 16649, + "subdir": "linux-64", + "timestamp": 1529429071487, + "version": "0.4.3" + }, + "pyct-0.4.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7507b5fa0db9b23e8002d8cdf32a3edb", + "name": "pyct", + "sha256": "08adf58735586869f3067fd54af3a1e79dc93ba24e672f593d6df389b29ce8a6", + "size": 17757, + "subdir": "linux-64", + "timestamp": 1535603264919, + "version": "0.4.5" + }, + "pyct-0.4.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.5,<3.6.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "094fab0c82f93ba3fb5ece1516252958", + "name": "pyct", + "sha256": "1787411b69528f866128071ae9d71fee9a1378d6f1e6eb9a160a295ed8c471c5", + "size": 18029, + "subdir": "linux-64", + "timestamp": 1535603319768, + "version": "0.4.5" + }, + "pyct-0.4.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bfa41b9a09c1b8195db54a87b5915b91", + "name": "pyct", + "sha256": "118794e9f1e6ef21246bda200616539ab0b3435cf2448884a4c214f1ff685d2c", + "size": 17733, + "subdir": "linux-64", + "timestamp": 1535603287506, + "version": "0.4.5" + }, + "pyct-0.4.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bcba2384f9df387fd0241fd7309d8f06", + "name": "pyct", + "sha256": "f1b8524931ccb2ab763a6b4fabe6941877a20298cf16eb040f7bffac73e315d2", + "size": 17815, + "subdir": "linux-64", + "timestamp": 1535603332544, + "version": "0.4.5" + }, + "pyct-0.4.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=2.7,<2.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0de1ad3616eaeca145de66fc67fea2b3", + "name": "pyct", + "sha256": "b3e2929a5e26385502d44a117896aaa970df87d9a9a0654e77288c9b220f68bb", + "size": 24016, + "subdir": "linux-64", + "timestamp": 1545119462828, + "version": "0.4.6" + }, + "pyct-0.4.6-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.10,<3.11.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1c83c976dc8b2ee29bfd38215c3e0e0e", + "name": "pyct", + "sha256": "dad9b54abe54a03b1a51bf3c6558e6b46fdb2cbffc1129af28d6694691061806", + "size": 23694, + "subdir": "linux-64", + "timestamp": 1640810252981, + "version": "0.4.6" + }, + "pyct-0.4.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1b364c6143c3ea84d2cee3d220186c63", + "name": "pyct", + "sha256": "a64699605162f40133c05c19b7b65f07e98d0b882de595f13886ec88fd15439b", + "size": 24062, + "subdir": "linux-64", + "timestamp": 1545119449898, + "version": "0.4.6" + }, + "pyct-0.4.6-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0ff9f9357236ceb28d864ba53e71a731", + "name": "pyct", + "sha256": "c6ecf97c6025abaa7fd4f90e99e0361a6ed2f1f17a0b6837657343f315a3646e", + "size": 24142, + "subdir": "linux-64", + "timestamp": 1613411592459, + "version": "0.4.6" + }, + "pyct-0.4.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "de539e84b47554cb3d2af2f19560d3e3", + "name": "pyct", + "sha256": "798939f8aad850189003d39e0efa8be7ecea6f27291534bb718c4562e613e99c", + "size": 24120, + "subdir": "linux-64", + "timestamp": 1545119486906, + "version": "0.4.6" + }, + "pyct-0.4.6-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2e58e6bab78946620784cbc15dfb9c11", + "name": "pyct", + "sha256": "cfbc9a4aacb646f7e94aef96bcf54b18209f4040d09131d2bb0a427ad9894b0d", + "size": 24134, + "subdir": "linux-64", + "timestamp": 1613410998908, + "version": "0.4.6" + }, + "pyct-0.4.6-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c9dda5e2bc44aed53750423d2fcd1ff2", + "name": "pyct", + "sha256": "1b1094a704d5c5c3ffd7607a670bc8baa89849b2592d45d64d567d559f6be4b2", + "size": 23596, + "subdir": "linux-64", + "timestamp": 1574238730555, + "version": "0.4.6" + }, + "pyct-0.4.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dc8707b9af013f6f939cc7c3c94b743a", + "name": "pyct", + "sha256": "2ec472504fe985d347cd3c3bb4d9af5b3a6cc9e9e77738207d54f9dc64433950", + "size": 24214, + "subdir": "linux-64", + "timestamp": 1613411592966, + "version": "0.4.6" + }, + "pyct-0.4.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7a62dd7d8c2b28953fd9b110cfa656b2", + "name": "pyct", + "sha256": "b07355687fff544c333972aabaade7a31574feddf5636e1560e8be644a38d194", + "size": 24368, + "subdir": "linux-64", + "timestamp": 1613411592963, + "version": "0.4.6" + }, + "pyct-0.4.8-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "param >=1.7.0", + "python >=3.10,<3.11.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e11d9d5dfe14727e0f2419df49bd8a94", + "name": "pyct", + "sha256": "50e7ebc4ad2f06635fe6f8001c472916d724769ebea7e7e3778fe60f5f91f028", + "size": 29810, + "subdir": "linux-64", + "timestamp": 1658500434083, + "version": "0.4.8" + }, + "pyct-0.4.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.6,<3.7.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "47f88339873d54feebc6d1bfa37e929b", + "name": "pyct", + "sha256": "14fe90d6c47253c126b201172d4fce314dac5ba1b9aca1b842530dfba68af899", + "size": 28797, + "subdir": "linux-64", + "timestamp": 1600458321091, + "version": "0.4.8" + }, + "pyct-0.4.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3f1f4ff78b474e7da850dfd92aa63d2e", + "name": "pyct", + "sha256": "b8915485988a709a1c663f1752166b6cf1d42a31caf61ba3901c7543be2a9bee", + "size": 28698, + "subdir": "linux-64", + "timestamp": 1600458312557, + "version": "0.4.8" + }, + "pyct-0.4.8-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "param >=1.7.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1675c95d298e2f3c7d67aa4e661d5019", + "name": "pyct", + "sha256": "1b605476532025438b97bb523d2a489ff69d2d753949ce75aea6849863a42093", + "size": 29544, + "subdir": "linux-64", + "timestamp": 1658500370660, + "version": "0.4.8" + }, + "pyct-0.4.8-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "requests" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6a94f43172baa54f54d83d7ad8ba97cd", + "name": "pyct", + "sha256": "4fa825de724bd6fbe178c053bcec15dcc9c13f38111dd1970d3083049a1bb979", + "size": 28796, + "subdir": "linux-64", + "timestamp": 1600458313779, + "version": "0.4.8" + }, + "pyct-0.4.8-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "param >=1.7.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "99928ebf18440c330589912dfcb59117", + "name": "pyct", + "sha256": "c1b224bdbc6138054adc7f6c454d5049c5ba78b339ad4bc40b3ec9b437e48c2a", + "size": 29639, + "subdir": "linux-64", + "timestamp": 1658500396865, + "version": "0.4.8" + }, + "pyct-0.4.8-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "param >=1.7.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f83ca45d81a6d82b92611b4cd7947e0", + "name": "pyct", + "sha256": "746f0acec2faf4f20cfa749708fecd459e138387aec2a5a6286ffaca41264852", + "size": 29691, + "subdir": "linux-64", + "timestamp": 1658500343635, + "version": "0.4.8" + }, + "pyct-0.5.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.10,<3.11.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "34ea9a1f8686a409fd58c29cdb35d16c", + "name": "pyct", + "sha256": "cf285182937cd0fa3345d75ace92db299fa49115484a213d2065401bd1a664cd", + "size": 31227, + "subdir": "linux-64", + "timestamp": 1675441593109, + "version": "0.5.0" + }, + "pyct-0.5.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.11,<3.12.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aee2f8ef20b9ef53d8d1e90b448de7f2", + "name": "pyct", + "sha256": "a3ae1f00700290dbce7d501ce13b2cd3d4fddc3c8eb75f0840c89bfd774255d5", + "size": 37808, + "subdir": "linux-64", + "timestamp": 1676838557935, + "version": "0.5.0" + }, + "pyct-0.5.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.7,<3.8.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "68491a1c33af186ae5fdd6d2e3269e7b", + "name": "pyct", + "sha256": "5c4030fce8b50fb24e77a2187686130c99708c4f10051159e5dab8e23294c8f5", + "size": 30908, + "subdir": "linux-64", + "timestamp": 1675441538333, + "version": "0.5.0" + }, + "pyct-0.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.8,<3.9.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "87d7bf26ca05d91af1e8569167788a41", + "name": "pyct", + "sha256": "e98587436adbbeb17da127f1ba38bcd923a89751f5eceec74800af4c034b2fd5", + "size": 31018, + "subdir": "linux-64", + "timestamp": 1675441565524, + "version": "0.5.0" + }, + "pyct-0.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "param >=1.7.0", + "python >=3.9,<3.10.0a0", + "pyyaml", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "591a62310f1abde9aef812bcee386178", + "name": "pyct", + "sha256": "2a3b7e110f505b36827158e12b930c746e52118bcd61b5ea3bb3568a60f64fd4", + "size": 31044, + "subdir": "linux-64", + "timestamp": 1675441510984, + "version": "0.5.0" + }, + "pyct-core-0.4.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "constrains": [ + "pyct 0.4.5" + ], + "depends": [ + "param >=1.7.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a7719b36eccd0bad7899f5c1a7d135c4", + "name": "pyct-core", + "sha256": "cbcfa57d85cc8a66eab744686e316683f1c53d5efe2a2a0758d4c7d043b63b08", + "size": 18101, + "subdir": "linux-64", + "timestamp": 1540061215476, + "version": "0.4.5" + }, + "pyct-core-0.4.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pyct 0.4.5" + ], + "depends": [ + "param >=1.7.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b6cfc2de2710191570e29c43f41e60d6", + "name": "pyct-core", + "sha256": "fa7d64ca77e6ac15aad033b3357d7768c51e2426fbfb52cb70ab149799a41e04", + "size": 18201, + "subdir": "linux-64", + "timestamp": 1540061219564, + "version": "0.4.5" + }, + "pyct-core-0.4.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pyct 0.4.5" + ], + "depends": [ + "param >=1.7.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "133ba01e168ce3087f32631b166b9a46", + "name": "pyct-core", + "sha256": "5760eab7fdb52057f4a5f76132d300347b11aad0648ef121bc2a13f6090774fe", + "size": 18082, + "subdir": "linux-64", + "timestamp": 1540061225902, + "version": "0.4.5" + }, + "pycurl-7.43.0-py27hcf8ebea_3.conda": { + "build": "py27hcf8ebea_3", + "build_number": 3, + "depends": [ + "curl 7.55.*", + "libgcc-ng >=7.2.0", + "openssl 1.0.2*", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "104096872340b2a58c1b15bd1748771e", + "name": "pycurl", + "sha256": "a7ab52cf5e982b4bbddd96b976b014ba27f86fb51a1531765779e0decdc19909", + "size": 52875, + "subdir": "linux-64", + "timestamp": 1505751642893, + "version": "7.43.0" + }, + "pycurl-7.43.0-py35h7a9665c_3.conda": { + "build": "py35h7a9665c_3", + "build_number": 3, + "depends": [ + "curl 7.55.*", + "libgcc-ng >=7.2.0", + "openssl 1.0.2*", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "f5a2b8e0c5408d0826f1ff3110d10852", + "name": "pycurl", + "sha256": "2a0f9376d586d441dd39491bdd460ffec24e83ffd394660ca7cd09de8ad29c3f", + "size": 52903, + "subdir": "linux-64", + "timestamp": 1505751661748, + "version": "7.43.0" + }, + "pycurl-7.43.0-py36h5e72054_3.conda": { + "build": "py36h5e72054_3", + "build_number": 3, + "depends": [ + "curl 7.55.*", + "libgcc-ng >=7.2.0", + "openssl 1.0.2*", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "31f3694e7575fcc6e8d9ee8da1dacc5f", + "name": "pycurl", + "sha256": "a9173ac94da2c20653a816be3300cc0abaa1e1f668ff4cc0fffc41db01ded0e2", + "size": 52820, + "subdir": "linux-64", + "timestamp": 1505751681035, + "version": "7.43.0" + }, + "pycurl-7.43.0.1-py27hb7f436b_0.conda": { + "build": "py27hb7f436b_0", + "build_number": 0, + "depends": [ + "curl >=7.55.1,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2n,<1.0.3a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "0ee7a96cc9b97c29429e1be378a674a0", + "name": "pycurl", + "sha256": "cae21e5889cb672083b7e58cd3832f9830de8c51ffa95a1fb252f6099768fdb3", + "size": 54927, + "subdir": "linux-64", + "timestamp": 1515725591739, + "version": "7.43.0.1" + }, + "pycurl-7.43.0.1-py35hb7f436b_0.conda": { + "build": "py35hb7f436b_0", + "build_number": 0, + "depends": [ + "curl >=7.55.1,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2n,<1.0.3a", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "60b621957fb3ad2f52984c6c25513c35", + "name": "pycurl", + "sha256": "02185fada618b091f1e4720887ac056181d11df889b6d052972f747363d5fc6b", + "size": 54909, + "subdir": "linux-64", + "timestamp": 1515725600173, + "version": "7.43.0.1" + }, + "pycurl-7.43.0.1-py36hb7f436b_0.conda": { + "build": "py36hb7f436b_0", + "build_number": 0, + "depends": [ + "curl >=7.55.1,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2n,<1.0.3a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "76f1189504d74f56cc9f95c737629229", + "name": "pycurl", + "sha256": "2cabbf978ee9a0d02c6005971a0cfb8ac277b8b5a33578e909ba7f94c81fc13d", + "size": 54755, + "subdir": "linux-64", + "timestamp": 1515725732105, + "version": "7.43.0.1" + }, + "pycurl-7.43.0.2-py27h1ba5d50_0.conda": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.63.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "cadb8a366a4f1885e1ff88583e1b6312", + "name": "pycurl", + "sha256": "64ece87f31e0d090efe210c68f524a6bd01cadbca2a4b16b0522ecebc6a1e678", + "size": 200598, + "subdir": "linux-64", + "timestamp": 1545162535004, + "version": "7.43.0.2" + }, + "pycurl-7.43.0.2-py27hb7f436b_0.conda": { + "build": "py27hb7f436b_0", + "build_number": 0, + "depends": [ + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "d76c853f6acc377c15c2fd9ca2424dbe", + "name": "pycurl", + "sha256": "442e0f2bce6274e593ed17124ffbb1b091b11115bb43c383b97c0dad3fbfe93c", + "size": 58034, + "subdir": "linux-64", + "timestamp": 1528213398878, + "version": "7.43.0.2" + }, + "pycurl-7.43.0.2-py35hb7f436b_0.conda": { + "build": "py35hb7f436b_0", + "build_number": 0, + "depends": [ + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "55dcb309aa5276d031dd6c481257bf57", + "name": "pycurl", + "sha256": "dea206de51e4e836db654ab7fe426797f9a9fde93eb1033d25b59e6c61e8f27d", + "size": 58207, + "subdir": "linux-64", + "timestamp": 1528213418287, + "version": "7.43.0.2" + }, + "pycurl-7.43.0.2-py36h1ba5d50_0.conda": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.63.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "089f8f6cd11d2727ede97d6b0d5cca73", + "name": "pycurl", + "sha256": "f5e6a6cf9f95e91b04e0e42a9ce1e10d57dd26d334910b782fe88d0e7cb96639", + "size": 201194, + "subdir": "linux-64", + "timestamp": 1545162637336, + "version": "7.43.0.2" + }, + "pycurl-7.43.0.2-py36hb7f436b_0.conda": { + "build": "py36hb7f436b_0", + "build_number": 0, + "depends": [ + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "48c0005a4bf29a6c11a341a4d33de1e2", + "name": "pycurl", + "sha256": "081d88c2895622973dcdce4c22b404c7af922909dc8e5d2b024bf0582a5a79a3", + "size": 58117, + "subdir": "linux-64", + "timestamp": 1528213315569, + "version": "7.43.0.2" + }, + "pycurl-7.43.0.2-py37h1ba5d50_0.conda": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.63.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "cd22d8230b0cada1164977ead0f21453", + "name": "pycurl", + "sha256": "239ed75071212c8441ee8064c634ac7c6de6c32a802ec5cd0d65e13add2eb66e", + "size": 200915, + "subdir": "linux-64", + "timestamp": 1545162939702, + "version": "7.43.0.2" + }, + "pycurl-7.43.0.2-py37hb7f436b_0.conda": { + "build": "py37hb7f436b_0", + "build_number": 0, + "depends": [ + "libcurl >=7.60.0,<8.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "f1b4b00451c94921a9c575cebeac7cb2", + "name": "pycurl", + "sha256": "28637c39ad65e59e24290cd79b548aab0f4358831a3f136f9c3b9793285cb2be", + "size": 58144, + "subdir": "linux-64", + "timestamp": 1530915992695, + "version": "7.43.0.2" + }, + "pycurl-7.43.0.3-py27h1ba5d50_0.conda": { + "build": "py27h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.64.1,<8.0a0", + "openssl >=1.1.1c,<1.1.2a", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "e10ca3871b064b98b437ceb83ccb5426", + "name": "pycurl", + "sha256": "90f3f5a51a52375aa0487de9575590232b5490c42e2f4c16eee584884cc7d6b2", + "size": 67998, + "subdir": "linux-64", + "timestamp": 1562091279544, + "version": "7.43.0.3" + }, + "pycurl-7.43.0.3-py36h1ba5d50_0.conda": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.64.1,<8.0a0", + "openssl >=1.1.1c,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "e82c1e6547f5eccde15e080ad4ac789a", + "name": "pycurl", + "sha256": "af6fe21ecdc41e4c81943d4570a8f00c4fd274f201153079099ce847e5d29ae8", + "size": 68416, + "subdir": "linux-64", + "timestamp": 1562091280074, + "version": "7.43.0.3" + }, + "pycurl-7.43.0.3-py37h1ba5d50_0.conda": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.64.1,<8.0a0", + "openssl >=1.1.1c,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "eca14d26052be5ef8a2cab2457e98253", + "name": "pycurl", + "sha256": "511242332208a0f60fce70c9ea9184c3134ffcb8c772d1f5d43e5aa71cf2da67", + "size": 68441, + "subdir": "linux-64", + "timestamp": 1562091277542, + "version": "7.43.0.3" + }, + "pycurl-7.43.0.3-py38h1ba5d50_0.conda": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.65.3,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "0e3403deffed242634b2ca6a86e24d94", + "name": "pycurl", + "sha256": "214131a18c67a66ceeefca2ca21b8f8bf161df01f9076452614a27c8aa2fdfa6", + "size": 75600, + "subdir": "linux-64", + "timestamp": 1573669040897, + "version": "7.43.0.3" + }, + "pycurl-7.43.0.4-py36h1ba5d50_0.conda": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.67.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "9a3af90ab2f258e860885c18affa967f", + "name": "pycurl", + "sha256": "3e8f41e4b42b68ce01e035d28e053c0426706d477eefe8e7a5cda5a4c2639819", + "size": 69511, + "subdir": "linux-64", + "timestamp": 1580152703579, + "version": "7.43.0.4" + }, + "pycurl-7.43.0.4-py37h1ba5d50_0.conda": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.67.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "af070d437dee3f5615dd72d5c66cd847", + "name": "pycurl", + "sha256": "07005f411ff15808e556233d87f0fe7d20faeff27ede7ccd2762f349a70ed5c5", + "size": 71187, + "subdir": "linux-64", + "timestamp": 1580152789061, + "version": "7.43.0.4" + }, + "pycurl-7.43.0.4-py38h1ba5d50_0.conda": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.67.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "7e12cd7b8524e4fecc2846ace124a36f", + "name": "pycurl", + "sha256": "12b537ff3220e8c2eb98846ffaf81a4789babca4215711fd8d7a404f79b6b2ef", + "size": 71225, + "subdir": "linux-64", + "timestamp": 1580152811239, + "version": "7.43.0.4" + }, + "pycurl-7.43.0.5-py36h1ba5d50_0.conda": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.67.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "358de1f3fbe27bcfd7fb9fad98b473a9", + "name": "pycurl", + "sha256": "b0cd65160fa32749a7dcdbb25e9a4dadd2bcbf8086dc4eadb74a64981edec1c6", + "size": 69927, + "subdir": "linux-64", + "timestamp": 1580835694226, + "version": "7.43.0.5" + }, + "pycurl-7.43.0.5-py37h1ba5d50_0.conda": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.67.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "972e5fa26563744536b2c61307a96000", + "name": "pycurl", + "sha256": "42d89c95ae9793213e4cfdb17a979dce62f2017400a143567f602c4ebd7d9739", + "size": 69909, + "subdir": "linux-64", + "timestamp": 1580835662761, + "version": "7.43.0.5" + }, + "pycurl-7.43.0.5-py38h1ba5d50_0.conda": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.67.0,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1d,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "f27e3b900febf0267b69f3493ba4d08f", + "name": "pycurl", + "sha256": "35aca1a861dc1c4ccd908c61af1678c69e12915c85d3d828ab8dd7b8fd893bc2", + "size": 71531, + "subdir": "linux-64", + "timestamp": 1580835669530, + "version": "7.43.0.5" + }, + "pycurl-7.43.0.6-py36h1ba5d50_0.conda": { + "build": "py36h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "8882601e7620c13874593952f34d45cb", + "name": "pycurl", + "sha256": "adbd166c75a1f3df758bf3b1c2b8dec77c4649afc509f1fe3f2e4e937fee87c4", + "size": 67991, + "subdir": "linux-64", + "timestamp": 1602278726855, + "version": "7.43.0.6" + }, + "pycurl-7.43.0.6-py37h1ba5d50_0.conda": { + "build": "py37h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "4bf744e320d6009e28ecc2a77e78c84c", + "name": "pycurl", + "sha256": "1629a3e7ed50b836adc59b04593ca10f5cc33744a1b97376dcb2258748c66f69", + "size": 69067, + "subdir": "linux-64", + "timestamp": 1602278691793, + "version": "7.43.0.6" + }, + "pycurl-7.43.0.6-py38h1ba5d50_0.conda": { + "build": "py38h1ba5d50_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1h,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "81454275aa594c811a995f93edf46813", + "name": "pycurl", + "sha256": "8d5e0c7c2c8fc5a6ca13f662ffb897aaea5df936c1c69a413256c100ba4fbbf7", + "size": 69643, + "subdir": "linux-64", + "timestamp": 1602278720983, + "version": "7.43.0.6" + }, + "pycurl-7.43.0.6-py39h8b3b800_0.conda": { + "build": "py39h8b3b800_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "edf202ba66fe2e5446f14d826a35f505", + "name": "pycurl", + "sha256": "344d2c778245ceb2cacfe30f09c053e32f886a588b053da29c333073e2ea1632", + "size": 71929, + "subdir": "linux-64", + "timestamp": 1608015764035, + "version": "7.43.0.6" + }, + "pycurl-7.44.0-py37h8f2d780_0.conda": { + "build": "py37h8f2d780_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1k,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "c82bf352a3b319ebd073a802016008e2", + "name": "pycurl", + "sha256": "904c7b8e6713aed6add46812af68b1bbf2b097a3cd6aff9c87c311b8d32cabe9", + "size": 67997, + "subdir": "linux-64", + "timestamp": 1628603911835, + "version": "7.44.0" + }, + "pycurl-7.44.0-py38h8f2d780_0.conda": { + "build": "py38h8f2d780_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1k,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "5925c18417b2be888dd611f616307fc2", + "name": "pycurl", + "sha256": "8969e9b3ceae854b1cd9c7b3a6768b04fa5b5611adac20b86d761fedff10c503", + "size": 69577, + "subdir": "linux-64", + "timestamp": 1628603913317, + "version": "7.44.0" + }, + "pycurl-7.44.0-py39h8f2d780_0.conda": { + "build": "py39h8f2d780_0", + "build_number": 0, + "depends": [ + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1k,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "463a942fd23744170c86aa3787bad06b", + "name": "pycurl", + "sha256": "1c8a37046266734740d62ad71115e43685bc9a7357048ce5e639d64b48c33a17", + "size": 70839, + "subdir": "linux-64", + "timestamp": 1629128040148, + "version": "7.44.0" + }, + "pycurl-7.44.1-py310h8f2d780_1.conda": { + "build": "py310h8f2d780_1", + "build_number": 1, + "depends": [ + "libcurl >=7.80.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "070264d77f563a586e00372c303be77f", + "name": "pycurl", + "sha256": "4862f9d18da282353bf74a83183d21f622e454ac8e39c55adb91a6dab6e2bb58", + "size": 237062, + "subdir": "linux-64", + "timestamp": 1640792988557, + "version": "7.44.1" + }, + "pycurl-7.44.1-py36h8f2d780_1.conda": { + "build": "py36h8f2d780_1", + "build_number": 1, + "depends": [ + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "b74fd0fd0484e8f42551c11a082aa6c7", + "name": "pycurl", + "sha256": "8724f67800d193180b9e23a0e05c8f73752c82466b214bc5c3f3f085917bbc95", + "size": 71228, + "subdir": "linux-64", + "timestamp": 1632849190636, + "version": "7.44.1" + }, + "pycurl-7.44.1-py37h8f2d780_1.conda": { + "build": "py37h8f2d780_1", + "build_number": 1, + "depends": [ + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "59bf74949e1a861760372e6d48fc949e", + "name": "pycurl", + "sha256": "595a2e319105b2ba28030c84ce99043d035d9f548e3ed8337bb7d6f8344f4922", + "size": 70763, + "subdir": "linux-64", + "timestamp": 1632859590278, + "version": "7.44.1" + }, + "pycurl-7.44.1-py38h8f2d780_1.conda": { + "build": "py38h8f2d780_1", + "build_number": 1, + "depends": [ + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "1139ef07055044e8a126a029d4d13733", + "name": "pycurl", + "sha256": "86fe538c2e95eb7d551a9187d7cc33009ef8b2e103aa6ab1cb9284a534b74bb3", + "size": 72312, + "subdir": "linux-64", + "timestamp": 1632859494562, + "version": "7.44.1" + }, + "pycurl-7.44.1-py39h8f2d780_0.conda": { + "build": "py39h8f2d780_0", + "build_number": 0, + "depends": [ + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1k,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "9f56a4553adb5d7aa2d9622ad90293f7", + "name": "pycurl", + "sha256": "f91d0bd95c84060daa2b1b90229e9d46f716c43519ef2376a3f9d7b2e5dfc42b", + "size": 70825, + "subdir": "linux-64", + "timestamp": 1629215444775, + "version": "7.44.1" + }, + "pycurl-7.44.1-py39h8f2d780_1.conda": { + "build": "py39h8f2d780_1", + "build_number": 1, + "depends": [ + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL, MIT", + "license_family": "LGPL", + "md5": "50e4549a6fd32f3afd751da39548f6e4", + "name": "pycurl", + "sha256": "c819b24757eafd1ccbe5842b878cda316f443cf65b865e18a6d14ac17bd08296", + "size": 72255, + "subdir": "linux-64", + "timestamp": 1632859583395, + "version": "7.44.1" + }, + "pycurl-7.45.1-py310h8f2d780_0.conda": { + "build": "py310h8f2d780_0", + "build_number": 0, + "depends": [ + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1o,<1.1.2a", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1-only, MIT", + "license_family": "LGPL", + "md5": "1cd6cfff3c3fc81c06cbc41e95ac5b56", + "name": "pycurl", + "sha256": "2e0b8e09ef64ff6b77d3ef7e8d1bb7233629f4d7430211e0eab1b6171c86cc1d", + "size": 245414, + "subdir": "linux-64", + "timestamp": 1655908752847, + "version": "7.45.1" + }, + "pycurl-7.45.1-py311h37d81fd_0.conda": { + "build": "py311h37d81fd_0", + "build_number": 0, + "depends": [ + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.1-only, MIT", + "license_family": "LGPL", + "md5": "68d5af53070cef41a37e59bf19968651", + "name": "pycurl", + "sha256": "6cce6cdcdf8fa0913215c5671ab3670ebf5a00d99a38e0c6b10ea89270807495", + "size": 71596, + "subdir": "linux-64", + "timestamp": 1676860706354, + "version": "7.45.1" + }, + "pycurl-7.45.1-py37h8f2d780_0.conda": { + "build": "py37h8f2d780_0", + "build_number": 0, + "depends": [ + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1o,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-only, MIT", + "license_family": "LGPL", + "md5": "310e0443ecfa65b06a3f6e2f1920771b", + "name": "pycurl", + "sha256": "122708ec4635f5ab7c196df91768cb4ba1073d06b88beca9f47dc0be4b8478c9", + "size": 125874, + "subdir": "linux-64", + "timestamp": 1655908608678, + "version": "7.45.1" + }, + "pycurl-7.45.1-py38h8f2d780_0.conda": { + "build": "py38h8f2d780_0", + "build_number": 0, + "depends": [ + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1o,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-only, MIT", + "license_family": "LGPL", + "md5": "dbbf1945c10dc1eac36d682488dde598", + "name": "pycurl", + "sha256": "acdf0042a2bce5b28a8aa614ead86f99b0f2c3685497234c868fddf05907e1a0", + "size": 126834, + "subdir": "linux-64", + "timestamp": 1655908795989, + "version": "7.45.1" + }, + "pycurl-7.45.1-py39h8f2d780_0.conda": { + "build": "py39h8f2d780_0", + "build_number": 0, + "depends": [ + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1o,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-only, MIT", + "license_family": "LGPL", + "md5": "2d5cb71e4effba6c5a7c6e5e8051e915", + "name": "pycurl", + "sha256": "5154f35816dc8adb90e7cc72cbf1cc29de637c16e460aa6542389127a708d95f", + "size": 125951, + "subdir": "linux-64", + "timestamp": 1655908671219, + "version": "7.45.1" + }, + "pycurl-7.45.2-py310h37d81fd_0.conda": { + "build": "py310h37d81fd_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1-or-later OR MIT", + "license_family": "LGPL", + "md5": "6b5dabbab402d968c8b5b430d9851de7", + "name": "pycurl", + "sha256": "ce1a85006850c8b27079caf8e068a398eefae311f3c2babde7e8d30850c82014", + "size": 137395, + "subdir": "linux-64", + "timestamp": 1678832660507, + "version": "7.45.2" + }, + "pycurl-7.45.2-py311h37d81fd_0.conda": { + "build": "py311h37d81fd_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.1-or-later OR MIT", + "license_family": "LGPL", + "md5": "2b5112e559755305702f68d18a89663b", + "name": "pycurl", + "sha256": "864f3692a5f3162e5a221c1d7b2f1caa9b4f23dd74b693c9c516157be560cd71", + "size": 135585, + "subdir": "linux-64", + "timestamp": 1679337454892, + "version": "7.45.2" + }, + "pycurl-7.45.2-py38h37d81fd_0.conda": { + "build": "py38h37d81fd_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-or-later OR MIT", + "license_family": "LGPL", + "md5": "fe1cdc19551a8e33114336a6507ed13d", + "name": "pycurl", + "sha256": "0e314efb31cc6ea0b0f873ea68328dc4774499a89fd57ba603aa82defe0e2b73", + "size": 137306, + "subdir": "linux-64", + "timestamp": 1678832627454, + "version": "7.45.2" + }, + "pycurl-7.45.2-py39h37d81fd_0.conda": { + "build": "py39h37d81fd_0", + "build_number": 0, + "depends": [ + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-or-later OR MIT", + "license_family": "LGPL", + "md5": "d6874d5795666c41c5b20ab8dc6d6eeb", + "name": "pycurl", + "sha256": "20b24b16975f9643f50b60cf12818bd99e24e152cbcf3c5efb6c7bd10b74e7d5", + "size": 137609, + "subdir": "linux-64", + "timestamp": 1678832691432, + "version": "7.45.2" + }, + "pydantic-1.10.2-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "constrains": [ + "email-validator >=1.0.3" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "typing-extensions >=4.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "adead346d174b3d796ee6a693915a6ba", + "name": "pydantic", + "sha256": "e77c2e793a3a9e604de43f278bf0b44395a1adea94e54b2728f5bffadd20108d", + "size": 2352462, + "subdir": "linux-64", + "timestamp": 1667416260903, + "version": "1.10.2" + }, + "pydantic-1.10.2-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "constrains": [ + "email-validator >=1.0.3" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "typing-extensions >=4.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95f10c826e00189ce0651e435d788ef4", + "name": "pydantic", + "sha256": "7ad2ea407ca3cbe57b42a7936677a4bb6875b5bac5d8c5e0d170e5798c8276df", + "size": 2193631, + "subdir": "linux-64", + "timestamp": 1676842212759, + "version": "1.10.2" + }, + "pydantic-1.10.2-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "constrains": [ + "email-validator >=1.0.3" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=4.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "faa3ee285b25fe0e16a193028b1deb6a", + "name": "pydantic", + "sha256": "46a42cb0e789ab4a4a8f35b9519ec7f0f992fb6f1d2808f0b4a57900b8eb09bf", + "size": 2271020, + "subdir": "linux-64", + "timestamp": 1667416409878, + "version": "1.10.2" + }, + "pydantic-1.10.2-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "constrains": [ + "email-validator >=1.0.3" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=4.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f9bc4b84a79e44ae3e3e4db815f3374", + "name": "pydantic", + "sha256": "5f317522c47bc57a1d3549c2c1090aeb88578f93c8eb1be37a0acc8b2838eaae", + "size": 2419832, + "subdir": "linux-64", + "timestamp": 1667416679727, + "version": "1.10.2" + }, + "pydantic-1.10.2-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "constrains": [ + "email-validator >=1.0.3" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=4.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "662d6eb2c1606904dbfdbb265fdd722d", + "name": "pydantic", + "sha256": "28f2b19a5bb92eebf078d4fe2bd540f6f3f12284d1f10c8026551085b693728e", + "size": 2377602, + "subdir": "linux-64", + "timestamp": 1667416539819, + "version": "1.10.2" + }, + "pydantic-1.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "dataclasses >=0.6", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4dc39c81e83e6b0b6f7a1575fb27111b", + "name": "pydantic", + "sha256": "5453640b6bb26f6695d46860c8a2959984712b9a86f445cbc09eff3f561533a7", + "size": 1538902, + "subdir": "linux-64", + "timestamp": 1585084118123, + "version": "1.2" + }, + "pydantic-1.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0fa47be1604e0886df163d239b0e6053", + "name": "pydantic", + "sha256": "30dca97dc4a27f5ba9521c651a6542cce98469019f76be4e23e0adceab5ca86c", + "size": 1532561, + "subdir": "linux-64", + "timestamp": 1585084130415, + "version": "1.2" + }, + "pydantic-1.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "655edbeedd07b96779643a8fb88c7ddd", + "name": "pydantic", + "sha256": "68ca0495500fff55f2e0c1edd79750cf6cc9dd3f11726f73630e8a5f717a65e0", + "size": 1618442, + "subdir": "linux-64", + "timestamp": 1585084089957, + "version": "1.2" + }, + "pydantic-1.4-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "dataclasses >=0.6", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3e3f60045df062790fcfd9341910583", + "name": "pydantic", + "sha256": "71935f87ba20d0aac56f19d944e436e3b092c6f6e8f59a47c7c28e97d5d62bae", + "size": 1611137, + "subdir": "linux-64", + "timestamp": 1585074386678, + "version": "1.4" + }, + "pydantic-1.4-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e5181fdd912550051a067c289afed8b", + "name": "pydantic", + "sha256": "6cf1f102392fb0dd2670e190d6ea2ef8804974799d31297075b085e387c78c87", + "size": 1609885, + "subdir": "linux-64", + "timestamp": 1585074328718, + "version": "1.4" + }, + "pydantic-1.4-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c737b50cc7069fd202cf8c4cbbdab1e5", + "name": "pydantic", + "sha256": "f3656dbb412c17dcd947dcb494d6681bd8fd35fada1750b4398f4d4d3d87a092", + "size": 1695732, + "subdir": "linux-64", + "timestamp": 1585074373480, + "version": "1.4" + }, + "pydantic-1.5.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "dataclasses >=0.6", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92f0c5e32106d003e64f34e1dbeb2bc4", + "name": "pydantic", + "sha256": "f2abe21c06816690cbeaf22260eeb87e6922eebf8f20c288cde2a529ddfb38f5", + "size": 1681138, + "subdir": "linux-64", + "timestamp": 1588598361540, + "version": "1.5.1" + }, + "pydantic-1.5.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "584d9377ff539fe32560b95ea4c74803", + "name": "pydantic", + "sha256": "587b7d9c32e136a4ddd351f2fddcb70cc949a3f1647e58363800c610d7186ce5", + "size": 1680510, + "subdir": "linux-64", + "timestamp": 1588598359134, + "version": "1.5.1" + }, + "pydantic-1.5.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "531cd9221c5a87f49594c598e92a1e97", + "name": "pydantic", + "sha256": "7659eddf58260340ec5068a5b05f9ff1c6ecbc85f96176d471c7f1fbb01ca486", + "size": 1771807, + "subdir": "linux-64", + "timestamp": 1588598363544, + "version": "1.5.1" + }, + "pydantic-1.6.1-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8eb8cd5007dc4dcf9422bfe16d7a3235", + "name": "pydantic", + "sha256": "26f7f6fc36bf9472404b1c0326eb9ecbdc619fce93c4475fde6b7b5c51e07e49", + "size": 1495853, + "subdir": "linux-64", + "timestamp": 1596916379757, + "version": "1.6.1" + }, + "pydantic-1.7.1-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "dataclasses >=0.6", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b8c10484207ad15a19bdc794e920d67", + "name": "pydantic", + "sha256": "89cf3acbc77f48b5a5d8363ee033c9b8f22f8deef63b45b8c95e4158a5c2af22", + "size": 1594982, + "subdir": "linux-64", + "timestamp": 1604103145142, + "version": "1.7.1" + }, + "pydantic-1.7.1-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a487b3ae1963c77a423479196db765b7", + "name": "pydantic", + "sha256": "d42253c6daf2e00c8ebb0920aec3b0158ab0216ca3665a7022d10f3e9b7125ae", + "size": 1591529, + "subdir": "linux-64", + "timestamp": 1604103154126, + "version": "1.7.1" + }, + "pydantic-1.7.1-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ac6385c6e4a6ea76a85361d102f8b69", + "name": "pydantic", + "sha256": "b233236b5ec461469bc0691b137951b117e6e38b472faaf1241df5cffcac7ae2", + "size": 1686194, + "subdir": "linux-64", + "timestamp": 1604103149089, + "version": "1.7.1" + }, + "pydantic-1.7.2-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "dataclasses >=0.6", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8fbed1866284c20fb48383f8567d1294", + "name": "pydantic", + "sha256": "f8c4e633eef16ca7bced59a3c159a4df87dcf857310c60fd1b2809ce622428de", + "size": 1597023, + "subdir": "linux-64", + "timestamp": 1604416568501, + "version": "1.7.2" + }, + "pydantic-1.7.2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fca94ca85c10ef4e2aad4c6147ff0786", + "name": "pydantic", + "sha256": "c9695fe3559386c024a8d113b5fb4f6da51ed0747564ebd4272d9545ff8891bf", + "size": 1585722, + "subdir": "linux-64", + "timestamp": 1604416568118, + "version": "1.7.2" + }, + "pydantic-1.7.2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aba2caa5c8d5908350283980deb0c620", + "name": "pydantic", + "sha256": "ec95f9c4a3af61f4ad4a6396f351ee944394890c90ffaf153ce5619cd22aeea3", + "size": 1688809, + "subdir": "linux-64", + "timestamp": 1604416587426, + "version": "1.7.2" + }, + "pydantic-1.7.3-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "dataclasses >=0.6", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad0fc166c0ceb7151386b448645e2642", + "name": "pydantic", + "sha256": "958e2389ee008f7e7afaced0fe921de69ae77ab4880ea97023ae53124ea1cb3d", + "size": 1598215, + "subdir": "linux-64", + "timestamp": 1606863552216, + "version": "1.7.3" + }, + "pydantic-1.7.3-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d0442682259970dc568ec8fb494cf0a", + "name": "pydantic", + "sha256": "1aa7b7ebc847203b8ad42c516ce1594f60667cf617c5400d3579c1e764e677bb", + "size": 1590572, + "subdir": "linux-64", + "timestamp": 1606863517154, + "version": "1.7.3" + }, + "pydantic-1.7.3-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad5cba47e202a88d818f051b7c4a11aa", + "name": "pydantic", + "sha256": "82a893e37977c0bde57160dcb852e1b118fccafa5246d752cfbd55db7e7e7d44", + "size": 1693100, + "subdir": "linux-64", + "timestamp": 1606863499583, + "version": "1.7.3" + }, + "pydantic-1.7.3-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f3147d27474b8a2c37252fe9120c8fe", + "name": "pydantic", + "sha256": "0efd282a1fbdf51c531f23b6d5b03b386e1fc65408b710eb6c24cd1b56cea2dc", + "size": 1690126, + "subdir": "linux-64", + "timestamp": 1606863558234, + "version": "1.7.3" + }, + "pydantic-1.8.1-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "dataclasses >=0.6", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0013f7b630228516e26115427e807b19", + "name": "pydantic", + "sha256": "b8519788802f292442ee300ecf5eb2958d6344caaaef8bca50a9cbc88b358ddd", + "size": 1783357, + "subdir": "linux-64", + "timestamp": 1620662252092, + "version": "1.8.1" + }, + "pydantic-1.8.1-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5af8b7ce37284a675b8ddd99c221abf6", + "name": "pydantic", + "sha256": "a7a2eb89c0ebc7b6bd3e8a8794c37a3954e216edfe1c5c3051a3a8e3a60264ec", + "size": 1775434, + "subdir": "linux-64", + "timestamp": 1620658035448, + "version": "1.8.1" + }, + "pydantic-1.8.1-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "938a9787309d4f428e21d72af77b6bf9", + "name": "pydantic", + "sha256": "c0654477c0e53ac1f6c59fecc687e7be375053c7d7617c0ea7f315c54172e817", + "size": 1882263, + "subdir": "linux-64", + "timestamp": 1620662258973, + "version": "1.8.1" + }, + "pydantic-1.8.1-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "881d76c553a59beff3bcc7357030fcba", + "name": "pydantic", + "sha256": "ed4746819e274624fc7ce5ffbeb02862e75d63a09774e927dfddc0d30625f311", + "size": 1884659, + "subdir": "linux-64", + "timestamp": 1620662264805, + "version": "1.8.1" + }, + "pydantic-1.8.2-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cfc9fac8120a8cb6f120989e1aaeb503", + "name": "pydantic", + "sha256": "361ef9f30cb0a0db8bf65d01f500f5f92f93688786b17cafbd6489c172618283", + "size": 6392841, + "subdir": "linux-64", + "timestamp": 1640793125671, + "version": "1.8.2" + }, + "pydantic-1.8.2-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e2e555aa8dbc82840ccae6ec8c7e12c", + "name": "pydantic", + "sha256": "5bdd3afcd910b3eff4ea6bc87e2429a876d9db8afd8bfa42d0299eb78a43c63f", + "size": 1777218, + "subdir": "linux-64", + "timestamp": 1621547129405, + "version": "1.8.2" + }, + "pydantic-1.8.2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd3cd436b9d1076bf3329e68c4e71ffc", + "name": "pydantic", + "sha256": "241fc9453e9f4b6b07e61860a8708f2fc5cebcf7e42b9b4c195845494da48855", + "size": 1774727, + "subdir": "linux-64", + "timestamp": 1621547110283, + "version": "1.8.2" + }, + "pydantic-1.8.2-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e990c433e44d67b14d5fdec22842d55f", + "name": "pydantic", + "sha256": "7e85a47efc3877e8e8cb15d8f227e87dff72a72bfe8dc1dbe964983cad9d935e", + "size": 1776380, + "subdir": "linux-64", + "timestamp": 1636618185236, + "version": "1.8.2" + }, + "pydantic-1.8.2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7111bf8edb50773960dcf6a3a3c60a03", + "name": "pydantic", + "sha256": "8d74e8c5bad6b8f468cc043c6ee1437f43aaaf5e6dca9e168ec1228036536a55", + "size": 1885762, + "subdir": "linux-64", + "timestamp": 1621546992647, + "version": "1.8.2" + }, + "pydantic-1.8.2-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d7e091641641e8c0d4fdc37caac6c45a", + "name": "pydantic", + "sha256": "20d4b7b6b16099aed106da5bfb5e2fd46806071ec1c59d3308925af1beb510ba", + "size": 1887578, + "subdir": "linux-64", + "timestamp": 1636618051173, + "version": "1.8.2" + }, + "pydantic-1.8.2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "461897c7e2c5bec67378960b15363d2e", + "name": "pydantic", + "sha256": "06383288ec481ef96c3c408a0d3276386c05af99442a7ff24ed0367034a40379", + "size": 1880240, + "subdir": "linux-64", + "timestamp": 1621542418020, + "version": "1.8.2" + }, + "pydantic-1.8.2-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af6ab04691da946c345ed63b6b67252b", + "name": "pydantic", + "sha256": "abf6841177a22db80b7347f31c36cb18df279a8c5f06fde381fd1971b2cce51d", + "size": 1885141, + "subdir": "linux-64", + "timestamp": 1636618317790, + "version": "1.8.2" + }, + "pydantic-1.9.0-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4f62904ffcf903cce49e8d7ef8fed35", + "name": "pydantic", + "sha256": "86b598e02a0476bfb8b2c7c0d1ef6906d209dfd962833afa192eef2a45fc9593", + "size": 6993654, + "subdir": "linux-64", + "timestamp": 1651219097258, + "version": "1.9.0" + }, + "pydantic-1.9.0-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8937a2251783b88b502d499c46e198bf", + "name": "pydantic", + "sha256": "dc1bb5a5d54751d531e3f3479dcebe3b0682518e8c8157a9da30ddd1d485f4d0", + "size": 1930032, + "subdir": "linux-64", + "timestamp": 1643622963313, + "version": "1.9.0" + }, + "pydantic-1.9.0-py37h7f8727e_1.conda": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "901e40867d3e2e3c455b6bc7c477ca3d", + "name": "pydantic", + "sha256": "fee43be6eb477255e2e8a8efc15d3230295c8eb852d2b1b562898cd0cd5fc89d", + "size": 1932623, + "subdir": "linux-64", + "timestamp": 1651219404512, + "version": "1.9.0" + }, + "pydantic-1.9.0-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5c9f648cfd0d9e958cd15b1b0914347", + "name": "pydantic", + "sha256": "b62caf1093dcd7434e4eeb0181ba7a4501f154a434ec67bc2e1d52e0a6337787", + "size": 2050990, + "subdir": "linux-64", + "timestamp": 1643622671619, + "version": "1.9.0" + }, + "pydantic-1.9.0-py38h7f8727e_1.conda": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c196db601cb8353b190b55caaa18da0", + "name": "pydantic", + "sha256": "6bf6b91dd2315498328014eade68d6a9e2afbcdd58384bbfe715c81757596ecb", + "size": 2053738, + "subdir": "linux-64", + "timestamp": 1651219250121, + "version": "1.9.0" + }, + "pydantic-1.9.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da059ea321ea96afb7983b1161f6261d", + "name": "pydantic", + "sha256": "48c76eb1045fc92946e8d6f094f83dfc4b828eeb897c27302cc7cdfcb9f83f61", + "size": 2053747, + "subdir": "linux-64", + "timestamp": 1643622816941, + "version": "1.9.0" + }, + "pydantic-1.9.0-py39h7f8727e_1.conda": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "typing-extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "00293bd3fdc5385ef43d99bfd1dca72d", + "name": "pydantic", + "sha256": "d08de5f2188078487dda2f76ba893742a3c61981c927e06594e80fd766885945", + "size": 2053315, + "subdir": "linux-64", + "timestamp": 1651218896618, + "version": "1.9.0" + }, + "pydeck-0.7.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=5.1.2", + "ipywidgets >=7.0.0", + "jinja2 >=2.10.1", + "numpy", + "python >=3.10,<3.11.0a0", + "traitlets >=4.3.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d36353655d68072f353eddb3f6d1636e", + "name": "pydeck", + "sha256": "9e0f5f104c52f6a4556c87649457b953fad66dfc19cb3477c1bfd1156b0e84e9", + "size": 1657492, + "subdir": "linux-64", + "timestamp": 1657894752269, + "version": "0.7.1" + }, + "pydeck-0.7.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=5.1.2", + "ipywidgets >=7.0.0", + "jinja2 >=2.10.1", + "numpy", + "python >=3.11,<3.12.0a0", + "traitlets >=4.3.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b723ba013ecf3d6115ac579a96520831", + "name": "pydeck", + "sha256": "06e8ee413a5b96a1e3c5a6b51935d32c680d02d9ee5fccaaedd7919c7faa63ec", + "size": 1677080, + "subdir": "linux-64", + "timestamp": 1676845304848, + "version": "0.7.1" + }, + "pydeck-0.7.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=5.1.2", + "ipywidgets >=7.0.0", + "jinja2 >=2.10.1", + "numpy", + "python >=3.7,<3.8.0a0", + "traitlets >=4.3.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f75320eeacdf9908f7a8dc9c0cf7dafa", + "name": "pydeck", + "sha256": "25d0c38adb0d8b7346ccf1d6a800a98731cd93f0f571e1d48f66b66e8638bf53", + "size": 1656271, + "subdir": "linux-64", + "timestamp": 1657894695494, + "version": "0.7.1" + }, + "pydeck-0.7.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=5.1.2", + "ipywidgets >=7.0.0", + "jinja2 >=2.10.1", + "numpy", + "python >=3.8,<3.9.0a0", + "traitlets >=4.3.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3bb91239458ba1d13acc249b5fea03ba", + "name": "pydeck", + "sha256": "6bc40dcaff17f3e6c0644fa57f9d31904618a411f43347a6ddd3fb09f7b80ab7", + "size": 1657532, + "subdir": "linux-64", + "timestamp": 1657894648482, + "version": "0.7.1" + }, + "pydeck-0.7.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=5.1.2", + "ipywidgets >=7.0.0", + "jinja2 >=2.10.1", + "numpy", + "python >=3.9,<3.10.0a0", + "traitlets >=4.3.2" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ae910fb34982f428989f10d732eceefa", + "name": "pydeck", + "sha256": "cf9c63108cfcc9a5367ce4f9ee19672ab0c98b704af15e789cede7e55d19d41f", + "size": 1657300, + "subdir": "linux-64", + "timestamp": 1657894602244, + "version": "0.7.1" + }, + "pydispatcher-2.0.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0b0b2aeb27acefde29d103db47f8c182", + "name": "pydispatcher", + "sha256": "a9bf5d4be9419bb48888ce7dff1d1818caf78cd7474d83df15394e6b4430d6b3", + "size": 19278, + "subdir": "linux-64", + "timestamp": 1530959784466, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "87179ce8826f98bbb0f8bceccdc7e32e", + "name": "pydispatcher", + "sha256": "faabe023374ccb1ba9473ec5e932359c144cab7fd68b7a7cfc9a93770ce4601e", + "size": 19282, + "subdir": "linux-64", + "timestamp": 1537810516037, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "684f5452bdc7a6d441e82de493c8cf28", + "name": "pydispatcher", + "sha256": "992f4b23302d9bafc03c5804780bb1de69579b0a4f2e88b18fbd38d6a0f95c21", + "size": 19558, + "subdir": "linux-64", + "timestamp": 1640793148678, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "043c94104383c4433f5ce511e60a202e", + "name": "pydispatcher", + "sha256": "cc927c109aca0434b52a411ff6c6b9cb8dc55adb12f5eb3cb91c4d0ec52450e0", + "size": 20262, + "subdir": "linux-64", + "timestamp": 1646654909576, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py311h06a4308_2.conda": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9182f6b41dc8aac3193114a6dc750048", + "name": "pydispatcher", + "sha256": "6bb8c5357e048c95550a183c1e85eed26aa9b5e2561aa199544952720326cc98", + "size": 24423, + "subdir": "linux-64", + "timestamp": 1676845322535, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aeb4d3b00baace2176ebb806aea9224d", + "name": "pydispatcher", + "sha256": "22d57d9f9f3bb0151413f87c9e18d953a49e033c5c0892db2211465ac726c617", + "size": 19574, + "subdir": "linux-64", + "timestamp": 1537810814144, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e2de0e205ec63dd1c6f32f9f6e8bbe14", + "name": "pydispatcher", + "sha256": "97a7b790144a287cb2c06515934e68a0dce0fec811c05b402b350746e35d7aef", + "size": 19384, + "subdir": "linux-64", + "timestamp": 1530959814780, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2104bcc4bebe369933b7bc7470c1f2a4", + "name": "pydispatcher", + "sha256": "4169ddfa363e7a1bad0dfff9c53e19b8d34c81a986ce1fb5e83b69655dbd58c8", + "size": 19429, + "subdir": "linux-64", + "timestamp": 1537810506376, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0526b1eab490acbff5eba74ee96fcc75", + "name": "pydispatcher", + "sha256": "624f248fea96d183794e6aa2da15303f635179438a5b340733badf52c23a8f0a", + "size": 20390, + "subdir": "linux-64", + "timestamp": 1613165924319, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b58ef020b679be666b22a7b2178f5925", + "name": "pydispatcher", + "sha256": "7c15f8fefb231bcef2303f8a7b266041ec0ed2d980b371ebfc65db3013c3bbe7", + "size": 19321, + "subdir": "linux-64", + "timestamp": 1530959845272, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d7b209b63a79d50f81ea917e3d9bf5e8", + "name": "pydispatcher", + "sha256": "0b588df7c8ae39f21189a0ec85ace91fd97267d6efd0aa61cd315ebdfb6c86f4", + "size": 19546, + "subdir": "linux-64", + "timestamp": 1537810490559, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ff7d82b2c93a992fecfa0821541d3192", + "name": "pydispatcher", + "sha256": "6ddd701c33eadefd3b7a0dcc6c42b8d131ed5bd6813812961d33362924fec3fc", + "size": 20306, + "subdir": "linux-64", + "timestamp": 1613164147110, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a2c2b26168ab0028781001fd1e282ff", + "name": "pydispatcher", + "sha256": "98a3c6504ef0d492b46c095bbcf5983712aa1a7db79b1ccb67da062d92e6e1b7", + "size": 20188, + "subdir": "linux-64", + "timestamp": 1646654894329, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "809d6297cbce0616263b767d1f92b788", + "name": "pydispatcher", + "sha256": "e34a8d53c56dd89da0e9456fd0b86b776daef303b997f06278366ad35bf16c12", + "size": 19781, + "subdir": "linux-64", + "timestamp": 1573669058188, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b49bc1f395887b9c0dacf9799ad8eabe", + "name": "pydispatcher", + "sha256": "5f50cfa7e50de3eb792aa69027f5dd7e337fb5106736b7211b8571826c51ac70", + "size": 20297, + "subdir": "linux-64", + "timestamp": 1613165800610, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "34987da7b1e0bccf7503a5343bb5d62d", + "name": "pydispatcher", + "sha256": "6063113d5deb9a78865e773776b4b4c7fd225518a4f632bff3eff7bf35ad3095", + "size": 20222, + "subdir": "linux-64", + "timestamp": 1646654892433, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8a702e1b77f95cb1e7fb7c48c39f562a", + "name": "pydispatcher", + "sha256": "ac81a664b2ac463990b02f6f3bfc33da766215b9beb9d8446208b09dbb627de1", + "size": 20311, + "subdir": "linux-64", + "timestamp": 1613164150745, + "version": "2.0.5" + }, + "pydispatcher-2.0.5-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e3f82c88da067476490f5823a0c1bd8b", + "name": "pydispatcher", + "sha256": "2019963cbfe6d4dc6aa369fc004c8adf4aa77c3e3579ee1cec41b70a54d1972a", + "size": 20097, + "subdir": "linux-64", + "timestamp": 1646636769245, + "version": "2.0.5" + }, + "pydocstyle-2.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser", + "python >=2.7,<2.8.0a0", + "six", + "snowballstemmer" + ], + "license": "MIT", + "md5": "b362c0ad3f36a0a76ad931881e609425", + "name": "pydocstyle", + "sha256": "5590a44a5da6250e473c4722e2c94820c311ded929a4b5fb444b983123d4b837", + "size": 53167, + "subdir": "linux-64", + "timestamp": 1536861200466, + "version": "2.1.1" + }, + "pydocstyle-2.1.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six", + "snowballstemmer" + ], + "license": "MIT", + "md5": "c040d9e19416af21c46d60c01d3cdfce", + "name": "pydocstyle", + "sha256": "a4db1044a691b3701f4aba17407d2091dfe59a9be43ab8d9fdb0f0dde989b3a7", + "size": 54950, + "subdir": "linux-64", + "timestamp": 1536861363898, + "version": "2.1.1" + }, + "pydocstyle-2.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six", + "snowballstemmer" + ], + "license": "MIT", + "md5": "69df97dbd25eab613cec61cab93e9eb0", + "name": "pydocstyle", + "sha256": "b1e5b8130b0ed6d30624c91c9d9be8f957d3ccee24d8a4e7d201624fd3a28725", + "size": 54333, + "subdir": "linux-64", + "timestamp": 1536861369802, + "version": "2.1.1" + }, + "pydocstyle-2.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six", + "snowballstemmer" + ], + "license": "MIT", + "md5": "1c4e0dab2bd0def98358e413a58e5155", + "name": "pydocstyle", + "sha256": "7e028b9187b8721de7841007b7d4b342f79cfc9d2c6cc77b1c354fd87cdaa4e1", + "size": 53351, + "subdir": "linux-64", + "timestamp": 1536861138849, + "version": "2.1.1" + }, + "pydocstyle-3.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "configparser", + "python >=2.7,<2.8.0a0", + "six", + "snowballstemmer" + ], + "license": "MIT", + "md5": "2d263d0d45959d2e78e0fcc90a6fd80a", + "name": "pydocstyle", + "sha256": "9852d3a7b5288a39c9d63a979d1ea587e262a4bc494c5fcf72c9b63b86f3d70d", + "size": 54588, + "subdir": "linux-64", + "timestamp": 1539658355026, + "version": "3.0.0" + }, + "pydocstyle-3.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six", + "snowballstemmer" + ], + "license": "MIT", + "md5": "216511f7f6da8c14955c5f9b0df22e53", + "name": "pydocstyle", + "sha256": "fb32f70d83cd51e9114f716e9694fe0617f3aa3464b6292137fc133d6575882a", + "size": 54901, + "subdir": "linux-64", + "timestamp": 1539658370582, + "version": "3.0.0" + }, + "pydocstyle-3.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six", + "snowballstemmer" + ], + "license": "MIT", + "md5": "9b7c04c79606934d2e06913819def2ab", + "name": "pydocstyle", + "sha256": "e2839a6d7ff073e00289f663b3651baa44b937b605cc856ed2e5a86370498bb5", + "size": 55879, + "subdir": "linux-64", + "timestamp": 1539658375336, + "version": "3.0.0" + }, + "pydocstyle-6.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "snowballstemmer >=2.2.0", + "tomli >=1.2.3" + ], + "license": "MIT", + "md5": "cda9aeb76bcc0f51e6bdc23afe2c00fe", + "name": "pydocstyle", + "sha256": "5c34b0f37481a55540c742c20db3334680ba8b186382b42014c9890ae37e0b93", + "size": 73182, + "subdir": "linux-64", + "timestamp": 1675221698919, + "version": "6.3.0" + }, + "pydocstyle-6.3.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "snowballstemmer >=2.2.0" + ], + "license": "MIT", + "md5": "a8f4e1e7926ce7481c40796a687e8d42", + "name": "pydocstyle", + "sha256": "af3ce470de43a8868a06e9523652af622ec67a54c29434e6d9a38b3c4d9348fe", + "size": 89874, + "subdir": "linux-64", + "timestamp": 1677708733025, + "version": "6.3.0" + }, + "pydocstyle-6.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata >=2.0.0,<5.0.0", + "python >=3.7,<3.8.0a0", + "snowballstemmer >=2.2.0", + "tomli >=1.2.3" + ], + "license": "MIT", + "md5": "8b57c557bde7aa5475482904e88872a3", + "name": "pydocstyle", + "sha256": "b15dd8de4b3a4f19f16d2fb51bbf8511d1ec8b5611b6c88f52d41ab965f771f5", + "size": 72227, + "subdir": "linux-64", + "timestamp": 1675221752043, + "version": "6.3.0" + }, + "pydocstyle-6.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "snowballstemmer >=2.2.0", + "tomli >=1.2.3" + ], + "license": "MIT", + "md5": "5117eed09aee2d1f870c6b5e3b502f1a", + "name": "pydocstyle", + "sha256": "47aeef482d529f072e4a59e84d3a5c12a6bfd1b0920cc44bf7d579a0fdb080d8", + "size": 72619, + "subdir": "linux-64", + "timestamp": 1675221725015, + "version": "6.3.0" + }, + "pydocstyle-6.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "snowballstemmer >=2.2.0", + "tomli >=1.2.3" + ], + "license": "MIT", + "md5": "ddca9d386de4c85d1ba8a3f32705bedd", + "name": "pydocstyle", + "sha256": "fc6275827d4ce0aab46214d4e7ede33dc0da3847b99051b8b1c838d072edae8c", + "size": 72416, + "subdir": "linux-64", + "timestamp": 1675221778227, + "version": "6.3.0" + }, + "pydot-1.2.3-py27h55c791f_0.conda": { + "build": "py27h55c791f_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ac570ca57b3184c999f6551ccaa221bc", + "name": "pydot", + "sha256": "832057b3be7bbf5abdc70f5d00484a014d35f663ea365fef53e6e2a1b7324c30", + "size": 37327, + "subdir": "linux-64", + "timestamp": 1512149128346, + "version": "1.2.3" + }, + "pydot-1.2.3-py35hf778598_0.conda": { + "build": "py35hf778598_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "01ba661bbcb26e58b1116db8e2a9988d", + "name": "pydot", + "sha256": "b2fad4af9512a0cb376bd46f0ca458858f8ec3ee156cc65544e6d8a883a4fb8b", + "size": 38032, + "subdir": "linux-64", + "timestamp": 1512149133814, + "version": "1.2.3" + }, + "pydot-1.2.3-py36h2c9da84_0.conda": { + "build": "py36h2c9da84_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "39c3546c535c694e0f646c6dfde78681", + "name": "pydot", + "sha256": "6f2eefb94d3f86921720cd0bd1f7d25c625ba01bbba71e97752fa44836c96e3f", + "size": 37363, + "subdir": "linux-64", + "timestamp": 1512149078464, + "version": "1.2.3" + }, + "pydot-1.2.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "66b071c46d3d89f1a12cd1f4e1ccec0d", + "name": "pydot", + "sha256": "5a6595311af49ab1fe752f79c90d27ad464cf9ac2f5ea40b00abf833c80f42d8", + "size": 38408, + "subdir": "linux-64", + "timestamp": 1519832679748, + "version": "1.2.4" + }, + "pydot-1.2.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "05a28dd95625db003520ee5c189c8fc8", + "name": "pydot", + "sha256": "833d6abe0189167b5a2e33cf34110efca52099ca19000bf881d9c465aef0a139", + "size": 38649, + "subdir": "linux-64", + "timestamp": 1519832693397, + "version": "1.2.4" + }, + "pydot-1.2.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d6e4bd6c5e9cf5c0aca2fbc8d9563322", + "name": "pydot", + "sha256": "5422bd99f6f212c31653dd4027dcb737554cc0b8615c13afb44bc348c256e48a", + "size": 38468, + "subdir": "linux-64", + "timestamp": 1519832666979, + "version": "1.2.4" + }, + "pydot-1.2.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "aeeb0346fcd60a659a4bd4f544c684d7", + "name": "pydot", + "sha256": "fd95af881e538bb4c6bcfe7fcdda2c04878243f3132c3df8a78ca508d6ede8d5", + "size": 38388, + "subdir": "linux-64", + "timestamp": 1530916025811, + "version": "1.2.4" + }, + "pydot-1.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "773236330ca8d1f38985b9ec7a0b3a17", + "name": "pydot", + "sha256": "06a9e4e0891001d52e2f938eb61f45cb6dda67cac19d47330d0edf35bc18c9df", + "size": 38237, + "subdir": "linux-64", + "timestamp": 1542641557279, + "version": "1.3.0" + }, + "pydot-1.3.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5ceca8de2c0f6077f428a6aada52370c", + "name": "pydot", + "sha256": "d622cebf71ace2435f3fe0c7270e4ea38fbfb88a00144df29d1b5f2a62e9ee9b", + "size": 40337, + "subdir": "linux-64", + "timestamp": 1543604291650, + "version": "1.3.0" + }, + "pydot-1.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ad4a1621c5c24fbb74b3e4988913d1aa", + "name": "pydot", + "sha256": "0b16e8c733c8db9ff76270edddf416c5cc48999ba53c475e3f8b72d0f0cf6915", + "size": 38608, + "subdir": "linux-64", + "timestamp": 1542641565443, + "version": "1.3.0" + }, + "pydot-1.3.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "942a1e56f0a2868483f72d9ef5b90bd8", + "name": "pydot", + "sha256": "ec698095307593ea10de31a503b7978dd94ce13715001ad83a833fd53ea7c3c3", + "size": 40695, + "subdir": "linux-64", + "timestamp": 1543604333423, + "version": "1.3.0" + }, + "pydot-1.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyparsing >=2.1.4", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "78cf8676597953b8b8117e6d510b85fd", + "name": "pydot", + "sha256": "d46a1dc7b1e289076fef966c4990743da3ce92b489f6a520a55c1c65defe382a", + "size": 38634, + "subdir": "linux-64", + "timestamp": 1542641542956, + "version": "1.3.0" + }, + "pydot-1.3.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c49fe8d574980b22ccd9d35cf0bd8aee", + "name": "pydot", + "sha256": "557caca4b61c4948a88c3baf46d2cbb4e8d893827e974108715015194c4ec16f", + "size": 40524, + "subdir": "linux-64", + "timestamp": 1543604276682, + "version": "1.3.0" + }, + "pydot-1.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "883fba6309c478d92ba0159a99dfac01", + "name": "pydot", + "sha256": "5d215d187bfc348742fc097f2baba1fc5db6c0ee370276e9f2a26a97a2b6fabc", + "size": 43295, + "subdir": "linux-64", + "timestamp": 1556070495453, + "version": "1.4.1" + }, + "pydot-1.4.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "3b3809c6f524be588854955e241c3ee7", + "name": "pydot", + "sha256": "44f7c6629fa44b365d428891b3276ac6d3a15b5a72a115a5e7a4d7f98cf34ad4", + "size": 41260, + "subdir": "linux-64", + "timestamp": 1640793166772, + "version": "1.4.1" + }, + "pydot-1.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "edde15803ad0ceeaf5120c0d954a0756", + "name": "pydot", + "sha256": "bbc76ab78257d1ec14c60683dd098ffd70169bbd8a92b667f8b33fc5c865b88d", + "size": 43725, + "subdir": "linux-64", + "timestamp": 1556070381872, + "version": "1.4.1" + }, + "pydot-1.4.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "352dfd9667d56f6236cd0775d9032e4c", + "name": "pydot", + "sha256": "9df818414216ca8cbadadfe9dbbcbf7232fadf9b31b9f093371d2b73f3992f5c", + "size": 43472, + "subdir": "linux-64", + "timestamp": 1615393420568, + "version": "1.4.1" + }, + "pydot-1.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e36b4c4976fcd8809b90aa64d657ab8e", + "name": "pydot", + "sha256": "9bc165d29c3d1f18270dccc3944cc7105e4a0b5d8987a75d4810949e947ef7ac", + "size": 43736, + "subdir": "linux-64", + "timestamp": 1556070479672, + "version": "1.4.1" + }, + "pydot-1.4.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2b9920a9f0f8ea38ff60148649410ba2", + "name": "pydot", + "sha256": "24c083d747224f67237ff74695770abd2439bac87fc714eb8a1d67cf88ee75ec", + "size": 43269, + "subdir": "linux-64", + "timestamp": 1615394995867, + "version": "1.4.1" + }, + "pydot-1.4.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "7deb6e374dca809044c05d5bcf9a4f5d", + "name": "pydot", + "sha256": "d6eadbf270ea182737fb727ec56213cfdcb8a65da9b39ec0236ea567337f1e72", + "size": 41245, + "subdir": "linux-64", + "timestamp": 1573469717589, + "version": "1.4.1" + }, + "pydot-1.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "494835385a852e046b3c5605968027b7", + "name": "pydot", + "sha256": "0835ccdd2b21d44460ea533e3767755d96341e686e4f078bdda35d493e7fc564", + "size": 43670, + "subdir": "linux-64", + "timestamp": 1615395011326, + "version": "1.4.1" + }, + "pydot-1.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz", + "pyparsing >=2.1.4", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "2710d8c59578e1ed06e6e933e2fc1bfa", + "name": "pydot", + "sha256": "c89714cc0d8dd0a952ea3a12fafdeac541a1dd5c683917714611fd8d24b419b5", + "size": 43295, + "subdir": "linux-64", + "timestamp": 1615393420123, + "version": "1.4.1" + }, + "pydot-1.4.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3", + "pyparsing >=2.1.4,<3", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2536b004589d3cdc52ec10e7e612f9e1", + "name": "pydot", + "sha256": "a5d4633bb6604cce4ec5164deec09dd6a0242cdf98dd505db51bfb4dc5e677e7", + "size": 46390, + "subdir": "linux-64", + "timestamp": 1671046303576, + "version": "1.4.2" + }, + "pydot-1.4.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3", + "pyparsing >=2.1.4,<3", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34a8e230d20a6a25a57bc8dbf1861077", + "name": "pydot", + "sha256": "ba67f06119a6ad4f157c33a7dc4e5c848411a8b58d32642594ee0fd21444d695", + "size": 56960, + "subdir": "linux-64", + "timestamp": 1676860722094, + "version": "1.4.2" + }, + "pydot-1.4.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3", + "pyparsing >=2.1.4,<3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd097c3a1ce103b84f269a5eb056fb95", + "name": "pydot", + "sha256": "bf80a747063f88ead3ca5450205b3243bdeab0e3d661a19647c6fe76b188e7b3", + "size": 46316, + "subdir": "linux-64", + "timestamp": 1671046366524, + "version": "1.4.2" + }, + "pydot-1.4.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3", + "pyparsing >=2.1.4,<3", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3159b04665a869f0de3409af6a43dc67", + "name": "pydot", + "sha256": "2007f14e58b4b4d6266261a8f84699c2005ae7fc8a58ff3bea1af5191182eda7", + "size": 46620, + "subdir": "linux-64", + "timestamp": 1671046396655, + "version": "1.4.2" + }, + "pydot-1.4.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3", + "pyparsing >=2.1.4,<3", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db5170fe8146714fca348452aa33b46d", + "name": "pydot", + "sha256": "e867d5e2ca778dc9ffc5f01538c8874d64a925ef746f9bd94ca3fb24c0e7c8c7", + "size": 46272, + "subdir": "linux-64", + "timestamp": 1671046335981, + "version": "1.4.2" + }, + "pydotplus-2.0.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pyparsing >=2.0.1", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "26a4b5b8d2deffc120896ce86cb128af", + "name": "pydotplus", + "sha256": "dc3fab29853dcb662a5cf48436bc5eec8ffac8fedb9f77778febb3e50cd78d66", + "size": 42703, + "subdir": "linux-64", + "timestamp": 1539183187884, + "version": "2.0.2" + }, + "pydotplus-2.0.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pyparsing >=2.0.1", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b0e7d444b7eb71a08f577ac080622478", + "name": "pydotplus", + "sha256": "d407381ef300365bf4d039f7f42176fc720c4de89d878c8d8ccf8207ae821b88", + "size": 43054, + "subdir": "linux-64", + "timestamp": 1539183193318, + "version": "2.0.2" + }, + "pydotplus-2.0.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pyparsing >=2.0.1", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a7131ce8cbd045c66600b07a4d98488", + "name": "pydotplus", + "sha256": "388bac824c58d652ffbdbf60317dc53c6305ae166b317cd2c26fd78ee4bfe540", + "size": 43058, + "subdir": "linux-64", + "timestamp": 1539183206663, + "version": "2.0.2" + }, + "pyee-8.2.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e789139218b64aac2c3e33377323252d", + "name": "pyee", + "sha256": "df49d2699e505a1d599d13de5a260a724af2c2b8ef3f4cc873cb8e02dfc06627", + "size": 22963, + "subdir": "linux-64", + "timestamp": 1679385311004, + "version": "8.2.2" + }, + "pyee-8.2.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80c5531afcfbe80de796f1d0c86e72a7", + "name": "pyee", + "sha256": "8021736bd74386e2d41fa5fd8a413d9d110b21a127bc9e1233bb789bb8c042f1", + "size": 26661, + "subdir": "linux-64", + "timestamp": 1679385385567, + "version": "8.2.2" + }, + "pyee-8.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6599ea5822245cf977e6e50412ad734", + "name": "pyee", + "sha256": "a83a73b899abf888605cd4b59b357375989b0c0753c1dbbd8785fcea0663c75b", + "size": 22704, + "subdir": "linux-64", + "timestamp": 1679385336025, + "version": "8.2.2" + }, + "pyee-8.2.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "99d457cd265adaadadcdd11c7f9c3352", + "name": "pyee", + "sha256": "9bffc708d0e0dc9975b0532c05e0562a087b28f83481eec833e184441f50ccde", + "size": 22746, + "subdir": "linux-64", + "timestamp": 1679385360078, + "version": "8.2.2" + }, + "pyee-9.0.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cdfd786c1044c0757c3e03b5fb82e0a5", + "name": "pyee", + "sha256": "9b3c9c760da0ea3e1f77acd8d3ef50000690b2ee4c7aed2878ef9fb66a8c089f", + "size": 27859, + "subdir": "linux-64", + "timestamp": 1679327051640, + "version": "9.0.4" + }, + "pyee-9.0.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7a8f2f1060830b9977661d3035702704", + "name": "pyee", + "sha256": "c1a6821637e958cbe968d3b0eb1acbd6ed593ce96cfba6a87e9ee1663c077883", + "size": 33415, + "subdir": "linux-64", + "timestamp": 1679327130229, + "version": "9.0.4" + }, + "pyee-9.0.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6040271e6c10a354fe3157d5cf10398", + "name": "pyee", + "sha256": "b5814d068e1fb7ff19969c59672729b81cbf1587c8f528b6da5ddbcf7aab6c67", + "size": 27485, + "subdir": "linux-64", + "timestamp": 1679327103085, + "version": "9.0.4" + }, + "pyee-9.0.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "typing_extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f7d691840ba7f0222b554030c60a54a", + "name": "pyee", + "sha256": "18af0160b91d3fdb65bd72fa4ce8a2e572a94bf8be5b38aa63ef45898c4ec0f6", + "size": 27492, + "subdir": "linux-64", + "timestamp": 1679327076640, + "version": "9.0.4" + }, + "pyemd-0.4.4-py27h8619c78_0.conda": { + "build": "py27h8619c78_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "af2248008d5edb2d0b0de45f1e359cb1", + "name": "pyemd", + "sha256": "f951dfc1aaf83bbb43f58d2f885c77be54b5fb9b249ff0243efbc56d0229c332", + "size": 57515, + "subdir": "linux-64", + "timestamp": 1519494938565, + "version": "0.4.4" + }, + "pyemd-0.4.4-py27hb35e8e7_0.conda": { + "build": "py27hb35e8e7_0", + "build_number": 0, + "depends": [ + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "a58f009db4b79420e618f86453b83e97", + "name": "pyemd", + "sha256": "41514e1c0eeadf766d9e3be5cf32fb59c3a8d64ad24fc47b65b3dc0b34a10a85", + "size": 57679, + "subdir": "linux-64", + "timestamp": 1508795089466, + "version": "0.4.4" + }, + "pyemd-0.4.4-py35h8619c78_0.conda": { + "build": "py35h8619c78_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "adfb5bc0f07736ec835e013ef1283d63", + "name": "pyemd", + "sha256": "9d00d733bacfa686e4a4834f4ea171681ba632e4c1c4431640410abf1b91b6f0", + "size": 52241, + "subdir": "linux-64", + "timestamp": 1519495229755, + "version": "0.4.4" + }, + "pyemd-0.4.4-py35h94a5058_0.conda": { + "build": "py35h94a5058_0", + "build_number": 0, + "depends": [ + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "71af3ca70734ccd154785701eb63a45e", + "name": "pyemd", + "sha256": "311b23ab3d08c12c9f78f67f09dac690c6397da3ea0ca2cc011506841d2111b7", + "size": 52576, + "subdir": "linux-64", + "timestamp": 1508795014676, + "version": "0.4.4" + }, + "pyemd-0.4.4-py36h6632698_0.conda": { + "build": "py36h6632698_0", + "build_number": 0, + "depends": [ + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "da0d3264080e1f4a296d3ffa918d618d", + "name": "pyemd", + "sha256": "b54d84b21de32b541e900cb75e6d83f60946577cd7f5dd936e3944746781d663", + "size": 52097, + "subdir": "linux-64", + "timestamp": 1508795139309, + "version": "0.4.4" + }, + "pyemd-0.4.4-py36h8619c78_0.conda": { + "build": "py36h8619c78_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c04104e1f8c5e1ba5bf342853f8bf910", + "name": "pyemd", + "sha256": "4a889b36a887c1f7908fefb31bd39e1fb45da5333467c043e44e8c89f18f3f6d", + "size": 51924, + "subdir": "linux-64", + "timestamp": 1519495482135, + "version": "0.4.4" + }, + "pyemd-0.5.1-py27h8619c78_0.conda": { + "build": "py27h8619c78_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "62e3d70ccac3041d6fc5a0772b01d449", + "name": "pyemd", + "sha256": "fa6772ce87f9eff5ead74b940eee8ad4386bcf4e1b5006d6ee4464267f934760", + "size": 74764, + "subdir": "linux-64", + "timestamp": 1522807723274, + "version": "0.5.1" + }, + "pyemd-0.5.1-py27ha8d69ae_0.conda": { + "build": "py27ha8d69ae_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "50e6d0f61b362d776f4a47c90ccf4c26", + "name": "pyemd", + "sha256": "45013511e94eaf5bb9657b016b3a6b1726ece252d116057f3737c4331d3d695c", + "size": 74670, + "subdir": "linux-64", + "timestamp": 1530879574399, + "version": "0.5.1" + }, + "pyemd-0.5.1-py310h2571103_0.conda": { + "build": "py310h2571103_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "5786ad1af6a9bc12f05f6025391a50c3", + "name": "pyemd", + "sha256": "e88c905d82b854767d201e9822d5af841727822e0714557d57da61a321029d77", + "size": 335261, + "subdir": "linux-64", + "timestamp": 1640793197104, + "version": "0.5.1" + }, + "pyemd-0.5.1-py310hdb19cb5_1.conda": { + "build": "py310hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9c93739a5c005468536481baa6e7eb1", + "name": "pyemd", + "sha256": "1dd1de080f6203db40aa1fae9bc60ee0feb1852ad1e941ffa52fb1a96c023482", + "size": 81886, + "subdir": "linux-64", + "timestamp": 1676993835693, + "version": "0.5.1" + }, + "pyemd-0.5.1-py311hdb19cb5_1.conda": { + "build": "py311hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "72574ec18a6443efcaea176a982115cd", + "name": "pyemd", + "sha256": "9fd74fb6ee8714a95a51fc7253ed44f2ff69bfed9562fd44107257d0a90981f4", + "size": 69335, + "subdir": "linux-64", + "timestamp": 1677014527464, + "version": "0.5.1" + }, + "pyemd-0.5.1-py35h8619c78_0.conda": { + "build": "py35h8619c78_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "97a6a3222a4dbee550e8130d7bccb6d0", + "name": "pyemd", + "sha256": "b07d6e9a94b323adb000b87cde8745c558d249c7a86be7aa028d3c41d09ddb0a", + "size": 69266, + "subdir": "linux-64", + "timestamp": 1522807727333, + "version": "0.5.1" + }, + "pyemd-0.5.1-py36h3b6f4ec_0.conda": { + "build": "py36h3b6f4ec_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "cca1076772151659e4e8f5db1424b41e", + "name": "pyemd", + "sha256": "d6f93943c7d3c1559d4903f6ad21af53b249b4e48d1defd0f00572139d71eea6", + "size": 72987, + "subdir": "linux-64", + "timestamp": 1592382034223, + "version": "0.5.1" + }, + "pyemd-0.5.1-py36h8619c78_0.conda": { + "build": "py36h8619c78_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "829fe8920ea21eb7c5d924823cba7d9f", + "name": "pyemd", + "sha256": "f7e701d801ae98906fde16f737c9773721a11e34ee3b2ba04a3810fd058b2240", + "size": 71322, + "subdir": "linux-64", + "timestamp": 1522807722975, + "version": "0.5.1" + }, + "pyemd-0.5.1-py36h9a67853_0.conda": { + "build": "py36h9a67853_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3515dacdedcc7a48ce66b6d199e4d79b", + "name": "pyemd", + "sha256": "e6505d3404e65d239d767dda8b13f5662a261979d025218701348f6bde5ec76f", + "size": 72148, + "subdir": "linux-64", + "timestamp": 1613411038471, + "version": "0.5.1" + }, + "pyemd-0.5.1-py36ha8d69ae_0.conda": { + "build": "py36ha8d69ae_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "704ecdbefce5a0881fee6d32aa961da7", + "name": "pyemd", + "sha256": "a096c479c16fa4d8cf5a2ae68addc3a79c7f808b3d8961a75c8862ebe9d3fe5d", + "size": 70529, + "subdir": "linux-64", + "timestamp": 1530879533567, + "version": "0.5.1" + }, + "pyemd-0.5.1-py37h3b6f4ec_0.conda": { + "build": "py37h3b6f4ec_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8b5ed7da9e6972d7feae4dc124cc02dc", + "name": "pyemd", + "sha256": "599e5b642e7b0d39150ff9b6f80500857854e05d3a7d085f33b3c1ae43856feb", + "size": 73030, + "subdir": "linux-64", + "timestamp": 1592382029711, + "version": "0.5.1" + }, + "pyemd-0.5.1-py37h9a67853_0.conda": { + "build": "py37h9a67853_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "34bb484a8b56786ddf1b71154ef254cd", + "name": "pyemd", + "sha256": "24ddff3af81e0c6c19fe7ab351285e888035bf9640f4327acc7e155363d424e5", + "size": 72440, + "subdir": "linux-64", + "timestamp": 1613411261832, + "version": "0.5.1" + }, + "pyemd-0.5.1-py37ha8d69ae_0.conda": { + "build": "py37ha8d69ae_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ede804a52b37f82f1b913319b777c504", + "name": "pyemd", + "sha256": "0f96a27ef6c94b45ad8c86df5422fc98f215bacb97635dcbda70652eb937c4d8", + "size": 70636, + "subdir": "linux-64", + "timestamp": 1530879489501, + "version": "0.5.1" + }, + "pyemd-0.5.1-py37hdb19cb5_1.conda": { + "build": "py37hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b11843425a91e87a2a23af79c27318e1", + "name": "pyemd", + "sha256": "def9dea45abcf9299992a53f3e1afcdb694a32a692f50c8eab87b917becc874f", + "size": 80983, + "subdir": "linux-64", + "timestamp": 1676993921765, + "version": "0.5.1" + }, + "pyemd-0.5.1-py38h3b6f4ec_0.conda": { + "build": "py38h3b6f4ec_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "c33e3a116b12fa1872c5193c4e290290", + "name": "pyemd", + "sha256": "10ffb3fdec8ea4745459540392770e68b0d61cae3dacca59c100736ca152d2d6", + "size": 74033, + "subdir": "linux-64", + "timestamp": 1592382036163, + "version": "0.5.1" + }, + "pyemd-0.5.1-py38h9a67853_0.conda": { + "build": "py38h9a67853_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "46e6aac15b635bb358cb791341fc1222", + "name": "pyemd", + "sha256": "c215d37f5eb566b6aca79a3f88cdd6007c597268ff497efdcbed31d889ee965a", + "size": 73969, + "subdir": "linux-64", + "timestamp": 1613411627749, + "version": "0.5.1" + }, + "pyemd-0.5.1-py38ha516724_0.conda": { + "build": "py38ha516724_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "7fdf3076997bd754fbaecf1b87f435dd", + "name": "pyemd", + "sha256": "048eaa0d29f3cf426337462f15434e68e1f0e90e8665deb69dbf0284d08fbd05", + "size": 80245, + "subdir": "linux-64", + "timestamp": 1573469787358, + "version": "0.5.1" + }, + "pyemd-0.5.1-py38hdb19cb5_1.conda": { + "build": "py38hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4c1ef2c8d4e1a5d064ab3c98d9f84a9f", + "name": "pyemd", + "sha256": "6d1243b68c75c8f36cb54d12f1dd3cbf8a8010e628a391dbd200efe1c4baea06", + "size": 83677, + "subdir": "linux-64", + "timestamp": 1676993878194, + "version": "0.5.1" + }, + "pyemd-0.5.1-py39h9a67853_0.conda": { + "build": "py39h9a67853_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "04f546efaa24b18a2f99aa0d55b49926", + "name": "pyemd", + "sha256": "0fdc9cf1922083034f1897d1efabed6054cb66e9b597fa86c36a182ba407d663", + "size": 74069, + "subdir": "linux-64", + "timestamp": 1613411634996, + "version": "0.5.1" + }, + "pyemd-0.5.1-py39hdb19cb5_1.conda": { + "build": "py39hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f3fb57a4816f5736882b417999d614e", + "name": "pyemd", + "sha256": "7ddccdb24966d9d479db843ced0ee798fd012ffdb852dc4ffed53192d085e7c4", + "size": 81085, + "subdir": "linux-64", + "timestamp": 1676993965009, + "version": "0.5.1" + }, + "pyepsg-0.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "5f9c6ff52ce2b8a6409da949b176fa7b", + "name": "pyepsg", + "sha256": "fca884aa054bfb5dfd41b4c29af66fb553a5130590d7aa2d106211fee2f6cb03", + "size": 12650, + "subdir": "linux-64", + "timestamp": 1530811395708, + "version": "0.3.2" + }, + "pyepsg-0.3.2-py27h7a8771c_0.conda": { + "build": "py27h7a8771c_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "8b4d02ea1de1bd130f1bd388317af114", + "name": "pyepsg", + "sha256": "34662d7fb89218a11b103d0e7fbeb580f8a1d3a7fb2cd1e10f3a76880eac5924", + "size": 12874, + "subdir": "linux-64", + "timestamp": 1511990043501, + "version": "0.3.2" + }, + "pyepsg-0.3.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "0b9269db3e14e2cb7314ae03b4d75102", + "name": "pyepsg", + "sha256": "8235f0e38670246a52a603e74f4b092c9da3c5a3532d26c90bad437477f0bcce", + "size": 12807, + "subdir": "linux-64", + "timestamp": 1535129662321, + "version": "0.3.2" + }, + "pyepsg-0.3.2-py35h026859c_0.conda": { + "build": "py35h026859c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "edffaa09a9278da37c4939e7207ab6af", + "name": "pyepsg", + "sha256": "ffed74d738fd247d559e581a6e046cf9fd0342c8cfcd990b9e7805d0bdca210d", + "size": 13139, + "subdir": "linux-64", + "timestamp": 1511990132954, + "version": "0.3.2" + }, + "pyepsg-0.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "1ab8bc0827ba293287281ea5a2d1d141", + "name": "pyepsg", + "sha256": "ef4a1e299133c6b08c23cf5de10113106a1917561fde976eb31187a15f45333b", + "size": 12724, + "subdir": "linux-64", + "timestamp": 1530811445075, + "version": "0.3.2" + }, + "pyepsg-0.3.2-py36h1c26317_0.conda": { + "build": "py36h1c26317_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "10d809c30f5fdb088a6719dbb5bcabbd", + "name": "pyepsg", + "sha256": "108aba9b527b4bc9fe27f96aeae2f35cd18af7d04e910fd6da121a6cc7fbc33c", + "size": 13027, + "subdir": "linux-64", + "timestamp": 1511990191126, + "version": "0.3.2" + }, + "pyepsg-0.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "e0b092d13305c3821bfb1f08d7a152fc", + "name": "pyepsg", + "sha256": "847c44b840849d3c5ba8611ce6495b369475110c1eef7f54ecac591cca7e95fd", + "size": 12771, + "subdir": "linux-64", + "timestamp": 1530811420284, + "version": "0.3.2" + }, + "pyepsg-0.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "65fd95022b43c92d66b0f68ba1108f0b", + "name": "pyepsg", + "sha256": "e3d60c01c76740a10b683714252e60baacf35ac83eb5485517977947edc4dba4", + "size": 26605, + "subdir": "linux-64", + "timestamp": 1545146972739, + "version": "0.4.0" + }, + "pyepsg-0.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "a78a7fd74535ea47b8e7d9ba9d99a7bd", + "name": "pyepsg", + "sha256": "3ad4c615ff5e3a5e676d4b9936fbf205bb2fc86f9c8574115d426831be654c8e", + "size": 26778, + "subdir": "linux-64", + "timestamp": 1545147063759, + "version": "0.4.0" + }, + "pyepsg-0.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "LGPL-3.0", + "md5": "9a411ea460d288f715d4ad20c846efa7", + "name": "pyepsg", + "sha256": "7eedb7c335fd5c6bd4eb8a87d5f5af05ecddaf9415ac48e576455d1f1835b381", + "size": 26902, + "subdir": "linux-64", + "timestamp": 1545125278184, + "version": "0.4.0" + }, + "pyerfa-1.7.1.1-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7c062efc84521c3e330bdb856c81fc41", + "name": "pyerfa", + "sha256": "5a337f5a31a1006509f7b42f4661ef903dd920ad27b4e38f32d94750498684ea", + "size": 291410, + "subdir": "linux-64", + "timestamp": 1606860306790, + "version": "1.7.1.1" + }, + "pyerfa-1.7.1.1-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "67d27a302d88644d68c83a8432cd347e", + "name": "pyerfa", + "sha256": "28dd01634a1936d61032dc5e823698c116c2f1f9ff8af96c68c8d77cabcc1ae9", + "size": 290547, + "subdir": "linux-64", + "timestamp": 1606860306313, + "version": "1.7.1.1" + }, + "pyerfa-1.7.1.1-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d229457097c7ee42aac84c6c5eb2556d", + "name": "pyerfa", + "sha256": "0165ef5ac7e38652c4376c17be6f5b0b0b6cb92e69555e7399f0d76f9cf61257", + "size": 292688, + "subdir": "linux-64", + "timestamp": 1606860302981, + "version": "1.7.1.1" + }, + "pyerfa-1.7.1.1-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "efe1286137d8867e833a4c953ae571a3", + "name": "pyerfa", + "sha256": "b80a71f6d55424e258a57bbf8ed68c61d9eed0b8c9c857be69c64afc17517b3c", + "size": 290686, + "subdir": "linux-64", + "timestamp": 1607623045221, + "version": "1.7.1.1" + }, + "pyerfa-1.7.2-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "49a4269f37aef147aeb30732ee49ba11", + "name": "pyerfa", + "sha256": "2f7da0c816c2f2568a42e9d427e08c032f60b48ee42a7b7ba988da9743643fe9", + "size": 291284, + "subdir": "linux-64", + "timestamp": 1613849612675, + "version": "1.7.2" + }, + "pyerfa-1.7.2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1befd9ff5c1c0adf54f1bbe8238e0c3e", + "name": "pyerfa", + "sha256": "5c2142d329d2395182e1f020aa80b0611f110951b1111763a2f36b384e72f6d8", + "size": 288661, + "subdir": "linux-64", + "timestamp": 1613848803610, + "version": "1.7.2" + }, + "pyerfa-1.7.2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e0ed388501d79a3d180debb89b045c1f", + "name": "pyerfa", + "sha256": "40c9defb011ddc2d8bddb95081469c34082198b455f462514663b2e024434c51", + "size": 293026, + "subdir": "linux-64", + "timestamp": 1613849144833, + "version": "1.7.2" + }, + "pyerfa-1.7.2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a7b280ff368ca8dd19388102c705b6f4", + "name": "pyerfa", + "sha256": "7c8b95dc986224fe15b480c369a1edacf4e2d02cd323ae90dc687502b2978c2a", + "size": 292190, + "subdir": "linux-64", + "timestamp": 1613849616241, + "version": "1.7.2" + }, + "pyerfa-1.7.3-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "012de6e91af73fc09143e3c0a0904bd1", + "name": "pyerfa", + "sha256": "1d954f76f4a1c368b60c92375d65f0a75b9192fd69589bccd096751e68c1741c", + "size": 291871, + "subdir": "linux-64", + "timestamp": 1619390728193, + "version": "1.7.3" + }, + "pyerfa-1.7.3-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "da495f13238fe1fb831d2cf0412e4095", + "name": "pyerfa", + "sha256": "6d5aea3e79b9a9d88f39cdf6fda4b91e54f3f6bc03909adfcbd8478f1f534e7e", + "size": 289336, + "subdir": "linux-64", + "timestamp": 1619390992038, + "version": "1.7.3" + }, + "pyerfa-1.7.3-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.20.1,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "70b23d78f68c4f08d41d57b7400c48a9", + "name": "pyerfa", + "sha256": "5e3b546c88adc49935583d769829c2282012f923d86093771aea581085175773", + "size": 292814, + "subdir": "linux-64", + "timestamp": 1619390988215, + "version": "1.7.3" + }, + "pyerfa-1.7.3-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.20.1,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22ca32595f1c9185bf2c9a0794941bcb", + "name": "pyerfa", + "sha256": "73c742655b6e3250f516ec1c55d07862fe404a208f99d9929408f27c238e02b9", + "size": 292309, + "subdir": "linux-64", + "timestamp": 1619390989810, + "version": "1.7.3" + }, + "pyerfa-2.0.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.20.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "42f4bee23953b3b630029297ec1ce811", + "name": "pyerfa", + "sha256": "9d814dab44708bb4fd003f39f57bb56d778b01b21d862d0ead5d91909705acd1", + "size": 591788, + "subdir": "linux-64", + "timestamp": 1640793251993, + "version": "2.0.0" + }, + "pyerfa-2.0.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.20.2,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4dda03274fce50e2417ed26d22ad9ce0", + "name": "pyerfa", + "sha256": "839cfadf921c2f6d3379957a2b17575feaac0303d2aec0d2b1b1fa594f025fdb", + "size": 374906, + "subdir": "linux-64", + "timestamp": 1676838599904, + "version": "2.0.0" + }, + "pyerfa-2.0.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.20.2,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4242f7c5923bf250918aa6eb34ba6967", + "name": "pyerfa", + "sha256": "da217d012d20b055d7bcb0e55e946348fcb675b85e450f3306b1602777642908", + "size": 350498, + "subdir": "linux-64", + "timestamp": 1621560271233, + "version": "2.0.0" + }, + "pyerfa-2.0.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.20.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9e5719f970bbcb6f651532307b920b91", + "name": "pyerfa", + "sha256": "f12e4f094603273af65303d0e8dfa5e79330b3398c33e8d46de4590db7bbd35b", + "size": 352840, + "subdir": "linux-64", + "timestamp": 1621560894490, + "version": "2.0.0" + }, + "pyerfa-2.0.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.20.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "970b4a295929d02d6d33c0ba5221c553", + "name": "pyerfa", + "sha256": "00708943e358733ffb978baa62a4aeeff3eb0536bdc83edf72672fedd55faec3", + "size": 350826, + "subdir": "linux-64", + "timestamp": 1621556205918, + "version": "2.0.0" + }, + "pyface-6.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "81b3c5046c4e3bb71c23f072c05b203d", + "name": "pyface", + "sha256": "0c7ced3956d0759aa8b966db1034e116cf74bc41d3dbfd09ae2bec5b49cf07cc", + "size": 930124, + "subdir": "linux-64", + "timestamp": 1524522519182, + "version": "6.0.0" + }, + "pyface-6.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.5,<3.6.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8639909c977e48a1e275f358875f3e12", + "name": "pyface", + "sha256": "2474b1e1935d8590ab9e62239e0fe0b45383c3e32b455819405fd1dc58331fc8", + "size": 939084, + "subdir": "linux-64", + "timestamp": 1524522591572, + "version": "6.0.0" + }, + "pyface-6.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3b52d3be5d635a75ee530f85b996e847", + "name": "pyface", + "sha256": "477db35112d6ab8b3ce58ca8ef3dfd04eaa63cbbcae8fcf2e49219e633c10e40", + "size": 933369, + "subdir": "linux-64", + "timestamp": 1524522607459, + "version": "6.0.0" + }, + "pyface-6.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9bfc15cf0d86f009e8952b9fbe0058e2", + "name": "pyface", + "sha256": "be4cd23805e0ff697432d9a797d45943d89aa71bcd62b104b9c76d4add7ca376", + "size": 962097, + "subdir": "linux-64", + "timestamp": 1530874038957, + "version": "6.0.0" + }, + "pyface-6.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=2.7,<2.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dfd2534ac102a6bca390fef87c0784c3", + "name": "pyface", + "sha256": "89d4bae39a9b3c53adbbc2ada0e1a37fcb0b9c3b5ab489c565fee3910232859f", + "size": 1002078, + "subdir": "linux-64", + "timestamp": 1564703480825, + "version": "6.1.2" + }, + "pyface-6.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2fa4fdad0a5e4bb53f68c00b1ca159da", + "name": "pyface", + "sha256": "fed69a816c2e11cbdc89d09c94e275bab158ec9d38cb70c9ecea4ea9a232e9fa", + "size": 1020836, + "subdir": "linux-64", + "timestamp": 1564703478324, + "version": "6.1.2" + }, + "pyface-6.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b91429a22bc0dea0bb97a8c7029ba2c5", + "name": "pyface", + "sha256": "3f62488e20f1b601fadae6d51c69527be09bb642c4d1a0e2a461affcbcdfeb95", + "size": 1022846, + "subdir": "linux-64", + "timestamp": 1564753572173, + "version": "6.1.2" + }, + "pyface-6.1.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pygments", + "python >=3.8,<3.9.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5eb4892cb892d22f302ea4f104cc4bda", + "name": "pyface", + "sha256": "89a3fc576f8586f9a329c51831176df39756cf0b1c515f09d513679eeae8e174", + "size": 1023100, + "subdir": "linux-64", + "timestamp": 1574170435158, + "version": "6.1.2" + }, + "pyface-7.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "pyqt", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a8f751f1f03d279ff3d426566d562ae6", + "name": "pyface", + "sha256": "2959befd618defc69c207122e091f594fcc526f741ed3919eec61ccf62464de7", + "size": 1074611, + "subdir": "linux-64", + "timestamp": 1595348035327, + "version": "7.0.1" + }, + "pyface-7.0.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "99861745c5c3669a8daae54e9af7ce05", + "name": "pyface", + "sha256": "84c490d33d6635162d28d5ecbae0b9c1ad7cd1aed67e027ce9d4f4670d24e6b6", + "size": 1081676, + "subdir": "linux-64", + "timestamp": 1595438021361, + "version": "7.0.1" + }, + "pyface-7.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5d12aee3e4a0f87cb368585b977e7a2e", + "name": "pyface", + "sha256": "421785697926e567ae80c856937418296a53146d70e82e440006eb86182505a0", + "size": 1080236, + "subdir": "linux-64", + "timestamp": 1595348048518, + "version": "7.0.1" + }, + "pyface-7.0.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "28d1902ffff61ee0ee44b4454a4e8982", + "name": "pyface", + "sha256": "920db57f79bcef9f89c9c3f81af8edfb79005acebf0de982aca91dbded988c62", + "size": 1089918, + "subdir": "linux-64", + "timestamp": 1595438016341, + "version": "7.0.1" + }, + "pyface-7.0.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pygments", + "pyqt", + "python >=3.8,<3.9.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "27895b6a2c5bff1bdb2e5b9c2d3873a2", + "name": "pyface", + "sha256": "3f78d328e75a9064bfecafb5d3189266252de573217c9312fad55271f315b7ba", + "size": 1083756, + "subdir": "linux-64", + "timestamp": 1595347440939, + "version": "7.0.1" + }, + "pyface-7.0.1-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.8,<3.9.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c04b4fdb2dc7524bb56d531237c706eb", + "name": "pyface", + "sha256": "4b4bcda099f892ea3f8ffc9775317d720eaea7877e9f7042c9b3e35c38240cf7", + "size": 1081563, + "subdir": "linux-64", + "timestamp": 1595438028979, + "version": "7.0.1" + }, + "pyface-7.1.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f7337c34973f8e68d6cd2172d519d8e8", + "name": "pyface", + "sha256": "9db010c0e8a114fbdde11536af9a808438ab98515be40c6962e284c53515f62c", + "size": 1178839, + "subdir": "linux-64", + "timestamp": 1603218562121, + "version": "7.1.0" + }, + "pyface-7.1.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6f580e46a6235bd561be1e19db92c331", + "name": "pyface", + "sha256": "3e041cd2bc9d0aee36c525b583de24a9348614cb1950ca4f1328983b229e3233", + "size": 1186276, + "subdir": "linux-64", + "timestamp": 1603218558298, + "version": "7.1.0" + }, + "pyface-7.1.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.8,<3.9.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f4a4a858117475437a15eb42f23b2842", + "name": "pyface", + "sha256": "9d3bf9838436ddfe0ece0bb2227f2e8d016731223e77fcec1cad4e1752c6b7d7", + "size": 1189674, + "subdir": "linux-64", + "timestamp": 1603218516554, + "version": "7.1.0" + }, + "pyface-7.2.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7b78f6d63c8a3773b63366e45a72b689", + "name": "pyface", + "sha256": "5ecf7cecf01ca4c45ec736da844f66dad83415a9ad7eb0e51735bcd8fe89f80e", + "size": 1198208, + "subdir": "linux-64", + "timestamp": 1607623408971, + "version": "7.2.0" + }, + "pyface-7.2.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "395f54fa8fe9079f5bc12d20974bc6d0", + "name": "pyface", + "sha256": "74b175d63c1544d1b360464282b77c8b7f77eca025fcf585a8b9bde2919c8a22", + "size": 1200348, + "subdir": "linux-64", + "timestamp": 1607623406599, + "version": "7.2.0" + }, + "pyface-7.2.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.8,<3.9.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a61d821d499e9d336752b82fb52380ca", + "name": "pyface", + "sha256": "1b184581a05d832dca2fd9c01c63ea0e06879e2f474953d3e1ebe062813b543c", + "size": 1214209, + "subdir": "linux-64", + "timestamp": 1607623382991, + "version": "7.2.0" + }, + "pyface-7.3.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.10,<3.11.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f4ff5dbb08c2e5fa534b14919df3dab0", + "name": "pyface", + "sha256": "bab6f7ef640df0c239f02b490f94ffcf1b2ae43faf8b53565607659f7c55ec1c", + "size": 1218352, + "subdir": "linux-64", + "timestamp": 1640810281106, + "version": "7.3.0" + }, + "pyface-7.3.0-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.11,<3.12.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f3365ae49a1f49cd085e9dcb5c0316e5", + "name": "pyface", + "sha256": "3a26bd03d2011d1cffaabca7915c8d3475e24d94d906c86564b62432d1fab3f8", + "size": 1518927, + "subdir": "linux-64", + "timestamp": 1676860764724, + "version": "7.3.0" + }, + "pyface-7.3.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b95aea5dd3f8da4735cedd70ee37912e", + "name": "pyface", + "sha256": "dc86d2c33a9804bb38895a2a5b517e91e2525bfb8a24526579da265153405392", + "size": 1200721, + "subdir": "linux-64", + "timestamp": 1614365830516, + "version": "7.3.0" + }, + "pyface-7.3.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "45896e2880c8acfdefd67433b06b11b2", + "name": "pyface", + "sha256": "2ea608637f6c1560d5fbd0ce4d58c31f389ef51fc9a22c674ef5081b5aeff651", + "size": 1198333, + "subdir": "linux-64", + "timestamp": 1614365893514, + "version": "7.3.0" + }, + "pyface-7.3.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.8,<3.9.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "bb1267d0c985065dfc1838eceb5fad5d", + "name": "pyface", + "sha256": "eaf8fe703b587f971f407358337732da1354ea31a05cdb40253437c7592bb8cd", + "size": 1214346, + "subdir": "linux-64", + "timestamp": 1614364756846, + "version": "7.3.0" + }, + "pyface-7.3.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "pygments", + "pyqt", + "python >=3.9,<3.10.0a0", + "traits" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1f28b26b55423fe98d66ba0429dd2cac", + "name": "pyface", + "sha256": "df443fef394f35933cb87de6b90a8134b176e5d48325be874c4555ac55617e12", + "size": 1207946, + "subdir": "linux-64", + "timestamp": 1614365897950, + "version": "7.3.0" + }, + "pyflakes-1.5.0-py27hfba2528_1.conda": { + "build": "py27hfba2528_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "534634d2c995af2d0412134920fcc28e", + "name": "pyflakes", + "sha256": "a32a292c13560df62a2b07e1f2df66654ca51a2d34228273736ff71bc4f76e02", + "size": 84979, + "subdir": "linux-64", + "timestamp": 1505743071531, + "version": "1.5.0" + }, + "pyflakes-1.5.0-py35h06f3f26_1.conda": { + "build": "py35h06f3f26_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4c8c84df926e5977b32501d57a04217a", + "name": "pyflakes", + "sha256": "593173241dfc109e418bb195c14c55f9e7f97884be638dab37590c4d23980199", + "size": 87591, + "subdir": "linux-64", + "timestamp": 1505743084876, + "version": "1.5.0" + }, + "pyflakes-1.5.0-py36h5510808_1.conda": { + "build": "py36h5510808_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a28c024c0ea2f7c1af9ba7c19e9da491", + "name": "pyflakes", + "sha256": "ed89e4ceeff20b9d3eca61ac23285485f9765911bebf57556d8b238121c2c19e", + "size": 87266, + "subdir": "linux-64", + "timestamp": 1505743098324, + "version": "1.5.0" + }, + "pyflakes-1.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c6c673df400cbb6c645262c25bb902a3", + "name": "pyflakes", + "sha256": "0ea64c82b3d6d29010084a9500344b774b9745938e9bdee0bbac3719b5d3ee1b", + "size": 87047, + "subdir": "linux-64", + "timestamp": 1530812569534, + "version": "1.6.0" + }, + "pyflakes-1.6.0-py27h904a57d_0.conda": { + "build": "py27h904a57d_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c899d62def90eed32f5532f3316499b", + "name": "pyflakes", + "sha256": "4af51a4045dafb879523c9fafe1233f1c5b3a46748aa253f6743c3ca128a848f", + "size": 86394, + "subdir": "linux-64", + "timestamp": 1506627173930, + "version": "1.6.0" + }, + "pyflakes-1.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "533001bbb38559f7735b0e4f477cc066", + "name": "pyflakes", + "sha256": "5498f04ddce296230b169bc16ee38a59aa5b11e6a7e8e49b23b2e4b39366c60a", + "size": 92118, + "subdir": "linux-64", + "timestamp": 1535130133437, + "version": "1.6.0" + }, + "pyflakes-1.6.0-py35hd1da72e_0.conda": { + "build": "py35hd1da72e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "507bea928bcaa87555d124d6377080f3", + "name": "pyflakes", + "sha256": "95978bd4d830aa542aa1ba2642a4f650a4d4108930d0d7bebc4d3cfba23efc06", + "size": 91361, + "subdir": "linux-64", + "timestamp": 1506627178847, + "version": "1.6.0" + }, + "pyflakes-1.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0ac1d4cee2a82e64a6d3fd0b9f842c1d", + "name": "pyflakes", + "sha256": "e263b2a031e64acf8450d39e7b7497e169f736fe6e5a1703af90db6a2ddadd36", + "size": 91081, + "subdir": "linux-64", + "timestamp": 1530812620265, + "version": "1.6.0" + }, + "pyflakes-1.6.0-py36h7bd6a15_0.conda": { + "build": "py36h7bd6a15_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9969261f496e05faf6eefee475167443", + "name": "pyflakes", + "sha256": "9604b224a79cd95e3cf93116562f2846f510701854669a7fa1826e6bc4845db2", + "size": 88384, + "subdir": "linux-64", + "timestamp": 1506627156746, + "version": "1.6.0" + }, + "pyflakes-1.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51924fad386e9c11c0f305e392ed9120", + "name": "pyflakes", + "sha256": "8bd27cd838894e87d58d9f3c594020b6d55a06d4fbc2c23e9dec458180c3358a", + "size": 90890, + "subdir": "linux-64", + "timestamp": 1530812594652, + "version": "1.6.0" + }, + "pyflakes-2.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "295073ba3658fb00ec9464e35a54c89a", + "name": "pyflakes", + "sha256": "9a0849d29c4a79fbf3d2bb028153e2085711538c0ba26a6112a2c12ee74642ed", + "size": 88833, + "subdir": "linux-64", + "timestamp": 1527827562346, + "version": "2.0.0" + }, + "pyflakes-2.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0333b6061fd3fece39367a5f8e711dce", + "name": "pyflakes", + "sha256": "2a5ff005bdee2efbe4f21421ba52bf24d253215e16f7e2d072a6fbb52d213828", + "size": 92126, + "subdir": "linux-64", + "timestamp": 1527828787448, + "version": "2.0.0" + }, + "pyflakes-2.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3cf3bc64a6e4b7dcdaf2022909c5b94b", + "name": "pyflakes", + "sha256": "baa79b64dc40620f3d288d92751ecee89d909047b6b65a1cf14ff9ac9b7ef41f", + "size": 90677, + "subdir": "linux-64", + "timestamp": 1527827506545, + "version": "2.0.0" + }, + "pyflakes-2.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "70bc9b122ed9d8281234f3c1e2efb2a4", + "name": "pyflakes", + "sha256": "1ea6db8efcf0995c672fb5253c1c366e72dbcc875010ffddca2f670de68ce487", + "size": 90508, + "subdir": "linux-64", + "timestamp": 1530812646407, + "version": "2.0.0" + }, + "pyflakes-2.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bfb51d16c0984939660f67ed23d4519d", + "name": "pyflakes", + "sha256": "28786a851ea33b729189207925653a9512bd414e23aa777ec2f163985656fb26", + "size": 102866, + "subdir": "linux-64", + "timestamp": 1549329839774, + "version": "2.1.0" + }, + "pyflakes-2.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ad786d296820fe067ec7cf8cf7d08c5", + "name": "pyflakes", + "sha256": "6462b9da867f1f61934780ee0ea7e881417d41ba4c8e68a1aa05a625b0457daa", + "size": 107850, + "subdir": "linux-64", + "timestamp": 1549329871095, + "version": "2.1.0" + }, + "pyflakes-2.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4eab2b4fcfde6512da06dac9e5ff41e6", + "name": "pyflakes", + "sha256": "706adbd8c67d70b603be562a7a43f311208a6ace45b81a3ab77370a5257e79dd", + "size": 105031, + "subdir": "linux-64", + "timestamp": 1549337980776, + "version": "2.1.0" + }, + "pyflakes-2.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e44491d963c2ecb3775261d7817f0fb1", + "name": "pyflakes", + "sha256": "22b4a4c7a61337a6e9bea189e83a5a78ea669bc75d96188bb7caf66eddffd631", + "size": 106299, + "subdir": "linux-64", + "timestamp": 1552332345499, + "version": "2.1.1" + }, + "pyflakes-2.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d901a69ae94431e9edd325fd6524efb", + "name": "pyflakes", + "sha256": "2ef4af6b229f8fb3791a25aae4254d9b7b754120c3e897d9aba983612a4802df", + "size": 111181, + "subdir": "linux-64", + "timestamp": 1552332426907, + "version": "2.1.1" + }, + "pyflakes-2.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8449a0bf2b9f58555643ee823d049bec", + "name": "pyflakes", + "sha256": "e27601cea1c04c7e6ae5e822d5518de7c27b742e6889842494b7f70127cd84cf", + "size": 108451, + "subdir": "linux-64", + "timestamp": 1552332355490, + "version": "2.1.1" + }, + "pyflakes-2.1.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13a95221f289470c169c1d3aa5a7dcec", + "name": "pyflakes", + "sha256": "cc0ca036574bae49218e13ad1416e0ba0b707adcbb25f71744c4e95887eaf3c6", + "size": 108102, + "subdir": "linux-64", + "timestamp": 1573669072299, + "version": "2.1.1" + }, + "pyflakes-3.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74d876935508c87beeb2143f4e9b5316", + "name": "pyflakes", + "sha256": "e76a5b4f34acc8f80887df84d8529af8067f6ea84952fe4dd15b1cb5fa71a7fb", + "size": 123914, + "subdir": "linux-64", + "timestamp": 1674165233355, + "version": "3.0.1" + }, + "pyflakes-3.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c865764af1712fcd229692747fbe2a0", + "name": "pyflakes", + "sha256": "2a9b01ab258fb54d47ac0c845654448e75a052f4ae79958fd3b37da5096ae90d", + "size": 144003, + "subdir": "linux-64", + "timestamp": 1677708674088, + "version": "3.0.1" + }, + "pyflakes-3.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "136ba2eeea2012bd0895a77c665c534b", + "name": "pyflakes", + "sha256": "2ee143889079b21248c4a079bfd67889e2b0af2a40f4561ef7fcf48da7a2f8f8", + "size": 121323, + "subdir": "linux-64", + "timestamp": 1674165158153, + "version": "3.0.1" + }, + "pyflakes-3.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5883a03f732ce821bc71744a3e265a84", + "name": "pyflakes", + "sha256": "b69840018eeb08cc3fd2a9ca30f5824d3f3c78435c5c6d68af5ebe34f99b3f80", + "size": 122336, + "subdir": "linux-64", + "timestamp": 1674165208299, + "version": "3.0.1" + }, + "pyflakes-3.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "420a35dae4c5cd913fb3d8f9181dff9a", + "name": "pyflakes", + "sha256": "6406ddf35983b6c6488839317d423abd15f0e155636bae6603c7da6229b8d367", + "size": 122163, + "subdir": "linux-64", + "timestamp": 1674165183337, + "version": "3.0.1" + }, + "pygments-2.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "94460d490d3801fcf16c00fd6785dac2", + "name": "pygments", + "sha256": "d49a4ebd28ca8848339cf226376c9fa861fb31face6bec3da75ac1d6f266428b", + "size": 1233584, + "subdir": "linux-64", + "timestamp": 1530695559113, + "version": "2.2.0" + }, + "pygments-2.2.0-py27h4a8b6f5_0.conda": { + "build": "py27h4a8b6f5_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "1479fe8b3d6b1d5592357659325e8cb9", + "name": "pygments", + "sha256": "1e2b003c7f3b378f87a14a3199ba1052aae946c305fc041bf356ca138823bc2c", + "size": 1239200, + "subdir": "linux-64", + "timestamp": 1505688802373, + "version": "2.2.0" + }, + "pygments-2.2.0-py35h0f41973_0.conda": { + "build": "py35h0f41973_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "ce8060a9a4627a7129ce2eaa3c0c2dbd", + "name": "pygments", + "sha256": "f003f6881a81736c596eaa8dcebd3a2b6332652649e1326a2637333a67cbfd62", + "size": 1229139, + "subdir": "linux-64", + "timestamp": 1505688828032, + "version": "2.2.0" + }, + "pygments-2.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "781855390b9abf61af4b827107953db4", + "name": "pygments", + "sha256": "0c5f824deb923da54ca32b30cc9fd285ea1eba09323987a7406ec016b589f36d", + "size": 1213025, + "subdir": "linux-64", + "timestamp": 1530695494450, + "version": "2.2.0" + }, + "pygments-2.2.0-py36h0d3125c_0.conda": { + "build": "py36h0d3125c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "904158ff697ddc8000513a310c644a37", + "name": "pygments", + "sha256": "6d36fb6e0d8c16efcd98df96453881b404852aa40bc9c070c5280e049acdb96f", + "size": 1212590, + "subdir": "linux-64", + "timestamp": 1505688854125, + "version": "2.2.0" + }, + "pygments-2.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "fc7b806822f0f37dc25b28f7dbe5ef6a", + "name": "pygments", + "sha256": "09d01515fa28856486b3815fee00be9efc25c4c95081b7bb8fc45c96b27f153d", + "size": 1180068, + "subdir": "linux-64", + "timestamp": 1530695529344, + "version": "2.2.0" + }, + "pygments-2.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "cd16ef4b2a8b4b2a7859ddb89b96c991", + "name": "pygments", + "sha256": "e83a94e68c91bfc3c8fedb58e45068eccd7ccb0377bf108472a6bcb6589c695e", + "size": 1236563, + "subdir": "linux-64", + "timestamp": 1545073717958, + "version": "2.3.1" + }, + "pygments-2.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "8f4f5b48331abfaa0260f21976e58b07", + "name": "pygments", + "sha256": "69b399550846e809e8bffaa5db9734b476186ea770e4acae1a7027717590d54f", + "size": 1228087, + "subdir": "linux-64", + "timestamp": 1545073748583, + "version": "2.3.1" + }, + "pygments-2.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "059f1ea028f05c10961206a364ac1d28", + "name": "pygments", + "sha256": "1231867de38125ed7688dc69a62dfdffe7e45a62cac82cc481092065b4d9c789", + "size": 1196464, + "subdir": "linux-64", + "timestamp": 1545073730168, + "version": "2.3.1" + }, + "pygpu-0.7.5-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpuarray 0.7.5", + "mako", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "ISC", + "md5": "b34b3ac707e9a237bbce9d8a473f7d89", + "name": "pygpu", + "sha256": "ffc95619f693338db08744a0eb5ff90b02cd9abede83fab44a008d0aa6afb2f9", + "size": 537318, + "subdir": "linux-64", + "timestamp": 1515142640972, + "version": "0.7.5" + }, + "pygpu-0.7.5-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpuarray 0.7.5", + "mako", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "ISC", + "md5": "729eaadc009695bca2f8db6c4f9ae669", + "name": "pygpu", + "sha256": "30e36787243c01368d9c58ddff79ece940fbd824e65a7e4c8c81f280566b5f97", + "size": 536972, + "subdir": "linux-64", + "timestamp": 1515142921842, + "version": "0.7.5" + }, + "pygpu-0.7.5-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpuarray 0.7.5", + "mako", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "ISC", + "md5": "bd5e54d925f4a9ef17350e794461a8bb", + "name": "pygpu", + "sha256": "530fd591ec7fce2e032e5da13b73d536dcbc5a793bb70861b7f0db3ae31d0648", + "size": 539600, + "subdir": "linux-64", + "timestamp": 1515142916990, + "version": "0.7.5" + }, + "pygpu-0.7.6-py27h035aef0_0.conda": { + "build": "py27h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "ISC", + "md5": "b0c3ce9fb7b08c9ca39af0612717a99b", + "name": "pygpu", + "sha256": "621fa0346836908d16b6c5ad33f25d0e34ce4f4902981d1c3485ccec5efb19d5", + "size": 543156, + "subdir": "linux-64", + "timestamp": 1530916147912, + "version": "0.7.6" + }, + "pygpu-0.7.6-py27h3010b51_0.conda": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "ISC", + "md5": "1535dbefa0a758b38d9cbb78bf4d82b8", + "name": "pygpu", + "sha256": "92ad2ba54c5728ecd238e41d216f38a20fb29decaca47567c3089aa6c9bca7d0", + "size": 542769, + "subdir": "linux-64", + "timestamp": 1526496744742, + "version": "0.7.6" + }, + "pygpu-0.7.6-py310h9102076_0.conda": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "ISC", + "md5": "936381bd852db7298107564636a847ec", + "name": "pygpu", + "sha256": "4d02f0222d4d6c40943b2e70db1b2a07b269920f079669ec13ce70ffe6cffdd8", + "size": 1152199, + "subdir": "linux-64", + "timestamp": 1640793295140, + "version": "0.7.6" + }, + "pygpu-0.7.6-py311hbed6279_1.conda": { + "build": "py311hbed6279_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libgpuarray 0.7.6", + "mako >=0.7", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "ISC", + "md5": "ba2952cefe7158b61f57c6d245a45166", + "name": "pygpu", + "sha256": "843bc1469d2f5f0ca3b67016e5487df8389966a2fc66358fecc0d9dfb5e0ef07", + "size": 530256, + "subdir": "linux-64", + "timestamp": 1676860799985, + "version": "0.7.6" + }, + "pygpu-0.7.6-py35h3010b51_0.conda": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "ISC", + "md5": "bbf285dd8df218878900f106b62bc369", + "name": "pygpu", + "sha256": "4b7f9511ffe92d512d2ff0935563c8a17b3457e99387c6315bc1a153292f457a", + "size": 541387, + "subdir": "linux-64", + "timestamp": 1526495951693, + "version": "0.7.6" + }, + "pygpu-0.7.6-py36h035aef0_0.conda": { + "build": "py36h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "ISC", + "md5": "3c0fcd4e680089c5e21dba3c04238416", + "name": "pygpu", + "sha256": "88aae9ae070da7d9a63e0316aa5dc7453db74e911697eceb892f99b027f4537a", + "size": 542254, + "subdir": "linux-64", + "timestamp": 1530916206065, + "version": "0.7.6" + }, + "pygpu-0.7.6-py36h3010b51_0.conda": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "ISC", + "md5": "5459b872e5782c0715da34dcea775d38", + "name": "pygpu", + "sha256": "c0393b1a87afa731d14a486008cebad285fb6449ac67e7bd62e00c99dd17b015", + "size": 542496, + "subdir": "linux-64", + "timestamp": 1526495734174, + "version": "0.7.6" + }, + "pygpu-0.7.6-py36heb32a55_0.conda": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "ISC", + "md5": "80ebe9095542cb1b0b89cfe991e53047", + "name": "pygpu", + "sha256": "e4094d6098b425fcf14c16b2f627ba3efaecef4a604777a94fa41802a7ecf9b1", + "size": 513295, + "subdir": "linux-64", + "timestamp": 1592405454504, + "version": "0.7.6" + }, + "pygpu-0.7.6-py37h035aef0_0.conda": { + "build": "py37h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "ISC", + "md5": "2e8588cf17c427cd5ba01f82cbe0da05", + "name": "pygpu", + "sha256": "19803a012c11eade2205f5bc6adac5faa8717c17ca619eec51da28c5204ddca0", + "size": 540530, + "subdir": "linux-64", + "timestamp": 1530916087910, + "version": "0.7.6" + }, + "pygpu-0.7.6-py37hce1f21e_1.conda": { + "build": "py37hce1f21e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libgpuarray 0.7.6", + "mako >=0.7", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "ISC", + "md5": "1d8a83bbb4254458ce625db658834611", + "name": "pygpu", + "sha256": "52051df4f4a456f5d2fb912f4ab41951cffcf7e9e8e77de38bf2899f08c6c6d8", + "size": 511349, + "subdir": "linux-64", + "timestamp": 1643631298338, + "version": "0.7.6" + }, + "pygpu-0.7.6-py37heb32a55_0.conda": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "ISC", + "md5": "bdf869a47472d18e950025606446c3cd", + "name": "pygpu", + "sha256": "69a44f8a16f2e3f02d6ce0ae7a25896a3c22c0d53a4c6da83660f55a987434fb", + "size": 512964, + "subdir": "linux-64", + "timestamp": 1592405457398, + "version": "0.7.6" + }, + "pygpu-0.7.6-py38hce1f21e_1.conda": { + "build": "py38hce1f21e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libgpuarray 0.7.6", + "mako >=0.7", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "ISC", + "md5": "a3deeb904ed990679295103d185a2de7", + "name": "pygpu", + "sha256": "0f52d32063de37312c7d092e85280f7cfdab89254a5289137fdce1568848049c", + "size": 522535, + "subdir": "linux-64", + "timestamp": 1643631399188, + "version": "0.7.6" + }, + "pygpu-0.7.6-py38heb32a55_0.conda": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libgpuarray 0.7.6", + "mako", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "ISC", + "md5": "94f18eaf97d97cfa454221fd8f9175ca", + "name": "pygpu", + "sha256": "daca37aad7a2e033e57e23e96ce7c0324f12b878ab419a223d3bad5883b90ba4", + "size": 521367, + "subdir": "linux-64", + "timestamp": 1592405465875, + "version": "0.7.6" + }, + "pygpu-0.7.6-py39hce1f21e_1.conda": { + "build": "py39hce1f21e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libgpuarray 0.7.6", + "mako >=0.7", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "ISC", + "md5": "72015da0cf6e17ab05ed02eac8f0205d", + "name": "pygpu", + "sha256": "268913a148ece3c41215550b315bdf93be7794464122cf2f47ce693b38e640b3", + "size": 521893, + "subdir": "linux-64", + "timestamp": 1643631351357, + "version": "0.7.6" + }, + "pygraphviz-1.3-py27h14c3975_1.conda": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "graphviz", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0d82ab440b1b9f5eaeaa0031c975339e", + "name": "pygraphviz", + "sha256": "95cfbf72dab9d9d9a579ce2bea3c07661f04b15b6b1897fbb31c96cc7fbf6f05", + "size": 113504, + "subdir": "linux-64", + "timestamp": 1530916807132, + "version": "1.3" + }, + "pygraphviz-1.3-py27hac024dc_0.conda": { + "build": "py27hac024dc_0", + "build_number": 0, + "depends": [ + "graphviz 2.38.*", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "81d43f12bdf3b75b4e0279da2a072e18", + "name": "pygraphviz", + "sha256": "f5e3009cd08e9b01219c47e1ae7589ca9f0d988579c82b47330934353c17f907", + "size": 114080, + "subdir": "linux-64", + "timestamp": 1513663608768, + "version": "1.3" + }, + "pygraphviz-1.3-py35hd6187a3_0.conda": { + "build": "py35hd6187a3_0", + "build_number": 0, + "depends": [ + "graphviz 2.38.*", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9bbc7c6c9be28b9acb3f7880e19f67c5", + "name": "pygraphviz", + "sha256": "5958505b22b788b2fe8ebabd930dd94abf2966bfbe138630822840432645c385", + "size": 114544, + "subdir": "linux-64", + "timestamp": 1513663683695, + "version": "1.3" + }, + "pygraphviz-1.3-py36h14c3975_1.conda": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "graphviz", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bfd2ad7062c065ab5898569d82cb6943", + "name": "pygraphviz", + "sha256": "be19c1c267bad863d6c54eafc49448d5fcbf32ccf02ef39d82e3b908c5324af6", + "size": 114018, + "subdir": "linux-64", + "timestamp": 1530916508026, + "version": "1.3" + }, + "pygraphviz-1.3-py36hd547939_0.conda": { + "build": "py36hd547939_0", + "build_number": 0, + "depends": [ + "graphviz 2.38.*", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "05faf47afd2c1402a86cad44e9604648", + "name": "pygraphviz", + "sha256": "495a679a41203f574c3c5bbaef57f70d40d4c93977c88611ea65261f4a412ae7", + "size": 114528, + "subdir": "linux-64", + "timestamp": 1513663573715, + "version": "1.3" + }, + "pygraphviz-1.3-py37h14c3975_1.conda": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "graphviz", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9aebca71410b8833fc30fa598747b558", + "name": "pygraphviz", + "sha256": "86afd7684572c20df2335c27844253399ba812f89464291f72328f87f6830f95", + "size": 114226, + "subdir": "linux-64", + "timestamp": 1530916246327, + "version": "1.3" + }, + "pygraphviz-1.7-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "graphviz", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "519897d99e2abcedfba06d588db49344", + "name": "pygraphviz", + "sha256": "27054ba5132db8474ceb19f44b0435a946a49eb893274df755cafa7dba45d7f9", + "size": 185679, + "subdir": "linux-64", + "timestamp": 1640793328084, + "version": "1.7" + }, + "pygraphviz-1.9-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "graphviz >=2.42", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1eef2ab0917481457764d73bf64617e7", + "name": "pygraphviz", + "sha256": "a160591fe0290cdcb81fca78781eb9eebe22ab22560a4b75553c9402b30341b9", + "size": 191126, + "subdir": "linux-64", + "timestamp": 1657200609677, + "version": "1.9" + }, + "pygraphviz-1.9-py310h5eee18b_1.conda": { + "build": "py310h5eee18b_1", + "build_number": 1, + "depends": [ + "graphviz >=2.42,<3", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "110c35bfce37e94763a93746c8f64c3e", + "name": "pygraphviz", + "sha256": "7bba13960e6bd56bc09da9494d41cdba724dd5e624d2cada36812f4df91f0405", + "size": 139090, + "subdir": "linux-64", + "timestamp": 1671045723983, + "version": "1.9" + }, + "pygraphviz-1.9-py311h5eee18b_1.conda": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "graphviz >=2.42,<3", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d20aaa0ae76fc014188fe5cf681bd4b", + "name": "pygraphviz", + "sha256": "62d579b7e7ef6dc9d163ca9835f52ca75a867d820fc4b7eb2900192c7381f24a", + "size": 151194, + "subdir": "linux-64", + "timestamp": 1676860826409, + "version": "1.9" + }, + "pygraphviz-1.9-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "graphviz >=2.42", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38fbdeb088007e3a2735c5e9116519b7", + "name": "pygraphviz", + "sha256": "ad4bd054a40622720124be5cb446bded08bdac35f855c0a32ab909faa9591894", + "size": 131082, + "subdir": "linux-64", + "timestamp": 1657200653651, + "version": "1.9" + }, + "pygraphviz-1.9-py38h5eee18b_1.conda": { + "build": "py38h5eee18b_1", + "build_number": 1, + "depends": [ + "graphviz >=2.42,<3", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bd56a82ac0345599af547a112b632549", + "name": "pygraphviz", + "sha256": "c1f6d0e3d3fddfd109f4a36b8a0f81ccd5ad0829ca57e1249c227129235e553b", + "size": 139088, + "subdir": "linux-64", + "timestamp": 1671045630216, + "version": "1.9" + }, + "pygraphviz-1.9-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "graphviz >=2.42", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4f5f21d1dc775754046bff2eb601ca0d", + "name": "pygraphviz", + "sha256": "875ae8ca7a672c29582cd576f604420dcfc06f024395a25840f1d4b0c217b8cf", + "size": 130187, + "subdir": "linux-64", + "timestamp": 1657200699161, + "version": "1.9" + }, + "pygraphviz-1.9-py39h5eee18b_1.conda": { + "build": "py39h5eee18b_1", + "build_number": 1, + "depends": [ + "graphviz >=2.42,<3", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "95da71c46f69ed93df8d8f5ee6e737be", + "name": "pygraphviz", + "sha256": "36b872bddec11256c617f90ecffb42e02596eae961d3c49486ec1fbdf733ecc9", + "size": 138548, + "subdir": "linux-64", + "timestamp": 1671045677169, + "version": "1.9" + }, + "pyhamcrest-1.9.0-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "f6dbe1fa0ad6f555a13703a03e3d53e7", + "name": "pyhamcrest", + "sha256": "30d3fcc94d9590c497adaa429c3ad481bdd0393fc2bb821ff2aef87ff95fb7ae", + "size": 49307, + "subdir": "linux-64", + "timestamp": 1539712622614, + "version": "1.9.0" + }, + "pyhamcrest-1.9.0-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "5500a6f82f387f4c8cc954ca0bc9fa7b", + "name": "pyhamcrest", + "sha256": "b9dfcf3a6505b391ca09eb6c97354bef660d094c8e52f7f0639d522d42f64815", + "size": 49313, + "subdir": "linux-64", + "timestamp": 1539712643753, + "version": "1.9.0" + }, + "pyhamcrest-1.9.0-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "md5": "9d1ea285c1dd5c9ba71830cd844b4347", + "name": "pyhamcrest", + "sha256": "527597a2f5cdeea0b2b99fcf142b1fcfd6c412efe1f87cec983fb8526e1a26bc", + "size": 49738, + "subdir": "linux-64", + "timestamp": 1539712625005, + "version": "1.9.0" + }, + "pyhive-0.5.0-py27h9f55a9b_0.conda": { + "build": "py27h9f55a9b_0", + "build_number": 0, + "depends": [ + "future", + "python >=2.7,<2.8.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "452aac79c44fa28007b1d61670c71157", + "name": "pyhive", + "sha256": "ce240dee29525b0b8bb02bb278e3a187155e55e3600e0e7183ce75e61fe45902", + "size": 76076, + "subdir": "linux-64", + "timestamp": 1512160066928, + "version": "0.5.0" + }, + "pyhive-0.5.0-py35hc170076_0.conda": { + "build": "py35hc170076_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.5,<3.6.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "36d7b3bd7a8f9f5bd34cf6d82731ff04", + "name": "pyhive", + "sha256": "406d83b46cdaa639766561d362a7d15b6d2c384d0c13a90122b2496e3c6130a5", + "size": 82040, + "subdir": "linux-64", + "timestamp": 1512160072569, + "version": "0.5.0" + }, + "pyhive-0.5.0-py36h4c6b8b4_0.conda": { + "build": "py36h4c6b8b4_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.6,<3.7.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "5b0becf6296517a411fa292237706750", + "name": "pyhive", + "sha256": "71ab9bf779e5bf2dfc90b2d093ff78595e2b451004693c094b6eb2015b71f7cf", + "size": 82244, + "subdir": "linux-64", + "timestamp": 1512160090214, + "version": "0.5.0" + }, + "pyhive-0.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "future", + "python >=2.7,<2.8.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "9a0706ea0d08e04afd7374e51cec25ae", + "name": "pyhive", + "sha256": "35e40d5ffedcc85c156abbf229cacaba9eb2c198c9e4959af0142e10931d672b", + "size": 75964, + "subdir": "linux-64", + "timestamp": 1520832370605, + "version": "0.5.1" + }, + "pyhive-0.5.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.5,<3.6.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "5e32ae7bed296d1bb3677562fb86186b", + "name": "pyhive", + "sha256": "9daa2c759e7f7ddac46c78b2ca8fdf71ea2149a86eaf75301f2f90a35a8eddaf", + "size": 82565, + "subdir": "linux-64", + "timestamp": 1520832382616, + "version": "0.5.1" + }, + "pyhive-0.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.6,<3.7.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "952a47e4ae6d38bea6f0d722835b6c22", + "name": "pyhive", + "sha256": "56a47aa43c88b9da81f25a20a5a747327dc57e012ec3367e9c8f4a0e0ee070e4", + "size": 82345, + "subdir": "linux-64", + "timestamp": 1520832354286, + "version": "0.5.1" + }, + "pyhive-0.5.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "future", + "python >=2.7,<2.8.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "475cdde2c2ec4b0bffb478e16bc232e3", + "name": "pyhive", + "sha256": "72a792be299c09fa6b1ccc4411cfa35ec19e6d337b61af5f7ba98c6252cddfad", + "size": 75649, + "subdir": "linux-64", + "timestamp": 1527698739954, + "version": "0.5.2" + }, + "pyhive-0.5.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.5,<3.6.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "716cbb38bf344441d6093a802c672a81", + "name": "pyhive", + "sha256": "74366e234105d2f52d2784b457187bde5dab4943a297928e3b2985f84fe7ea21", + "size": 82889, + "subdir": "linux-64", + "timestamp": 1527698770783, + "version": "0.5.2" + }, + "pyhive-0.5.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.6,<3.7.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "04a4daf0459e8129812a1202f1d1393e", + "name": "pyhive", + "sha256": "859297745c58ea9afd27762b41bb52307788fb4a8f9548e66436036c70d34d11", + "size": 81278, + "subdir": "linux-64", + "timestamp": 1527698723507, + "version": "0.5.2" + }, + "pyhive-0.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "future", + "python >=2.7,<2.8.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "66f722f47fc1e23d471f89b415f8f729", + "name": "pyhive", + "sha256": "31ac949c91f920b3413160c2eb0ac5d323e632761c833a614dac797396913419", + "size": 77740, + "subdir": "linux-64", + "timestamp": 1529423848643, + "version": "0.6.0" + }, + "pyhive-0.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.5,<3.6.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "135107dfe6523a4f55af2eaca9484868", + "name": "pyhive", + "sha256": "861003fc5f3e79de5a3607b9e9cf43eff7673f9f2d01ee1151a031359932bc8e", + "size": 83821, + "subdir": "linux-64", + "timestamp": 1529423843029, + "version": "0.6.0" + }, + "pyhive-0.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.6,<3.7.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "7a5859ab64bdad079988f22c97b84d08", + "name": "pyhive", + "sha256": "a4bd60decee35e550e6dcd2ab67694d2268ae6dd8786e680d3debb0f7cbbac7b", + "size": 84237, + "subdir": "linux-64", + "timestamp": 1529423836660, + "version": "0.6.0" + }, + "pyhive-0.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.7,<3.8.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "7db99a0a700d87a0003ee0209cb1a7cf", + "name": "pyhive", + "sha256": "137206ad788c14fd48320fe1dd76eb8f8e0c07825f2728ea5904f29931bf097c", + "size": 83395, + "subdir": "linux-64", + "timestamp": 1530917075591, + "version": "0.6.0" + }, + "pyhive-0.6.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "future", + "python >=2.7,<2.8.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "3f6456bdbbc2f457ca41345d58cb249e", + "name": "pyhive", + "sha256": "1e7eb618608b3461f9c6d355a56820e8b96ec8178b0d8cca0079aecfb2d30d45", + "size": 77918, + "subdir": "linux-64", + "timestamp": 1539724861765, + "version": "0.6.1" + }, + "pyhive-0.6.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.10,<3.11.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "743eac33e294e49cd698facc2a5a19ac", + "name": "pyhive", + "sha256": "96026e66435470403833958d2a0ada7ff9eec54b0ff691e820836c671b270328", + "size": 85097, + "subdir": "linux-64", + "timestamp": 1640812694771, + "version": "0.6.1" + }, + "pyhive-0.6.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.11,<3.12.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "073c538f3ca40d75df5c7c6e046cee50", + "name": "pyhive", + "sha256": "ff82f41cfa8e5c8b895ddd6bef3b1a1f44075aebbeab72ca81871d6333235d3a", + "size": 113153, + "subdir": "linux-64", + "timestamp": 1676907553271, + "version": "0.6.1" + }, + "pyhive-0.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.6,<3.7.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "3b4d4568eee6379011c805396e8281b2", + "name": "pyhive", + "sha256": "e72708fe4b8be836f055deec0fd6a59c11353fec11f17cde3678d893b37fe159", + "size": 84106, + "subdir": "linux-64", + "timestamp": 1539724890724, + "version": "0.6.1" + }, + "pyhive-0.6.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.6,<3.7.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "cbcfdec7565a8c8c872ba2c3393269da", + "name": "pyhive", + "sha256": "9baca45ae26f192572cb08fbed50467a3e7057d4708f9125bee23d9f7b3f970c", + "size": 376258, + "subdir": "linux-64", + "timestamp": 1632742520028, + "version": "0.6.1" + }, + "pyhive-0.6.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.7,<3.8.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "20c2ef2daf91f1cf8686badcbfaef78f", + "name": "pyhive", + "sha256": "008b2b832ba4b85bf7b277361b7623bda679004b20bbaa13c10d55661ace7973", + "size": 83272, + "subdir": "linux-64", + "timestamp": 1539724883143, + "version": "0.6.1" + }, + "pyhive-0.6.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.7,<3.8.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "d36380db32c1b571f3a3a341c0ba567a", + "name": "pyhive", + "sha256": "6c56acd3479b8464a21b57fe192564b5b2f5c2b521cb09199497d87a5936632d", + "size": 375735, + "subdir": "linux-64", + "timestamp": 1632742518478, + "version": "0.6.1" + }, + "pyhive-0.6.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.8,<3.9.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "b3510a480728c01dc5a76aec873f709a", + "name": "pyhive", + "sha256": "e62879d77774f66333e084713c41feb9847abf1cb123ed5710fec8c3168712f8", + "size": 275397, + "subdir": "linux-64", + "timestamp": 1592405415768, + "version": "0.6.1" + }, + "pyhive-0.6.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.8,<3.9.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "b92a0fd508baa3cc4e3ef3b1a1fe88b2", + "name": "pyhive", + "sha256": "0400c17f60515f848a79094475064afa4afc0023d8a0ddfec6a3a78cb41dd06a", + "size": 376429, + "subdir": "linux-64", + "timestamp": 1632732149701, + "version": "0.6.1" + }, + "pyhive-0.6.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "python >=3.9,<3.10.0a0", + "requests >=1.0.0", + "sqlalchemy >=0.8.7", + "thrift >=0.10.0", + "thrift_sasl >0.2.1" + ], + "license": "Apache License, Version 2.0", + "license_family": "Apache", + "md5": "9cf53a9781495c28426c1e1b3d163a73", + "name": "pyhive", + "sha256": "d47c6d81405042db0c3b74d01995117afe0da4ac921cd50fdb7e529c89853007", + "size": 376865, + "subdir": "linux-64", + "timestamp": 1632732148932, + "version": "0.6.1" + }, + "pyicu-2.7.4-py310h83be7ef_0.conda": { + "build": "py310h83be7ef_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef1ff686c67c96c79e8ab9e06bba5d94", + "name": "pyicu", + "sha256": "e01ff634eb2a1c5a468a3686f778cf48b382a82abb4b048d749b10467734f143", + "size": 955033, + "subdir": "linux-64", + "timestamp": 1640793375383, + "version": "2.7.4" + }, + "pyicu-2.7.4-py311h94c2ce2_0.conda": { + "build": "py311h94c2ce2_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fcce6166c5c188c5627711bc8c3cf706", + "name": "pyicu", + "sha256": "e74598b9e79569dac12b1fce7951db7815962db34a6bddf6518033e7247b3167", + "size": 303086, + "subdir": "linux-64", + "timestamp": 1676860867778, + "version": "2.7.4" + }, + "pyicu-2.7.4-py37h83be7ef_0.conda": { + "build": "py37h83be7ef_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a242df6a4ae68700f6e51350b2121bba", + "name": "pyicu", + "sha256": "022cca3bd65030972cac0ec704a4ea071f69a9909a12182bc675e852bc271c4c", + "size": 288157, + "subdir": "linux-64", + "timestamp": 1634899235056, + "version": "2.7.4" + }, + "pyicu-2.7.4-py38h83be7ef_0.conda": { + "build": "py38h83be7ef_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d3ae2178e6946a3c9e0ce9ecc8a43ba", + "name": "pyicu", + "sha256": "3e16ff14bd383a2aa287f1ef0d184dedd141dec0d8cc48838198e31ff7acf72f", + "size": 291392, + "subdir": "linux-64", + "timestamp": 1634899226943, + "version": "2.7.4" + }, + "pyicu-2.7.4-py39h83be7ef_0.conda": { + "build": "py39h83be7ef_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "629a161a9875573ff1cdac22459edefc", + "name": "pyicu", + "sha256": "5fa2520321c2670804d9b70c78bd1dc9e7e2a930f142a92c208cccef184ce835", + "size": 292923, + "subdir": "linux-64", + "timestamp": 1634899238604, + "version": "2.7.4" + }, + "pyinotify-0.9.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8fd3a386379a04fc01e60418cbdb9b2c", + "name": "pyinotify", + "sha256": "8a9e86e19d34f7e8a260e6d535b7d8a980d7bd87f5ef64da457676a316aa41e9", + "size": 42937, + "subdir": "linux-64", + "timestamp": 1523040264589, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "59a096d7dfc79f12d6b021375ff0a1b4", + "name": "pyinotify", + "sha256": "fa24faf2d822cca90c70ba690e1e195e9af4129d6c1e9ff02e110966ad47c02a", + "size": 44255, + "subdir": "linux-64", + "timestamp": 1640793393897, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "24c594877d5d010f5afdca760523572e", + "name": "pyinotify", + "sha256": "f6b2f9065d11a578fc6ec8ed835a21accf0d77a7d97034c2155153772713e338", + "size": 55264, + "subdir": "linux-64", + "timestamp": 1676845337584, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "28b5c4fa06fb009a4bc1575527b705fd", + "name": "pyinotify", + "sha256": "22326a6ff969302146c6c83bafbb7c73cfb06cfa9862c937af36294a12d49d1e", + "size": 44019, + "subdir": "linux-64", + "timestamp": 1523040276809, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bdf8c59607b8f23a81861b0205c3c50c", + "name": "pyinotify", + "sha256": "677a528486df08677512dc081438fc09b78f5a1ff30e57592ea8f7137ad446ca", + "size": 43073, + "subdir": "linux-64", + "timestamp": 1523040349406, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a486027b38b8d6bfa4ebc038c0310f66", + "name": "pyinotify", + "sha256": "58b3482405b0562ca6b7301f50676e748f0fa6a6a0535475b3835ea8dd5c29e6", + "size": 45248, + "subdir": "linux-64", + "timestamp": 1613485535399, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc378940a462d631324e87e6d0858098", + "name": "pyinotify", + "sha256": "e0d0601bb7bae3fb1308a71246f0ac6795bdb0bcbe1c427d6c3cafa8dafb8cfb", + "size": 43755, + "subdir": "linux-64", + "timestamp": 1530873473229, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e16632e7a72a9623b4bf41a1c40740b9", + "name": "pyinotify", + "sha256": "af0b97efe6a9532437a2b07a8c8a055fc452d2b0d61c805c65f788f4d5747b7b", + "size": 44518, + "subdir": "linux-64", + "timestamp": 1613484912899, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21be2f2c2512fda4173b90dbba10a845", + "name": "pyinotify", + "sha256": "0e57b14b14795e6bb37c58a6e3331deb5867086e523cc0d038694e7dd64692c3", + "size": 44126, + "subdir": "linux-64", + "timestamp": 1573669085013, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39e8261d236f48fd421ddeae05b80bee", + "name": "pyinotify", + "sha256": "b95ddd2f94b9045cef081dc87d7544f2f7b9c1e0a31966d34968a935d1896150", + "size": 44761, + "subdir": "linux-64", + "timestamp": 1613485551409, + "version": "0.9.6" + }, + "pyinotify-0.9.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "09f8e54a1542c0238e9edb891b6c4df0", + "name": "pyinotify", + "sha256": "4755a30633bbe623d2fdaf06bf46112ae96dc488fd13c5b9de05c72dae330479", + "size": 45297, + "subdir": "linux-64", + "timestamp": 1613485157752, + "version": "0.9.6" + }, + "pyinstaller-3.4-py36hbc83047_1.conda": { + "build": "py36hbc83047_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycrypto", + "python >=3.6,<3.7.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 2", + "md5": "35ca74767a0c05c94f8a503f594db040", + "name": "pyinstaller", + "sha256": "a2677609c42e867b91236128359e1d8723ee84a053444a9a1a53118aeca9d354", + "size": 1691743, + "subdir": "linux-64", + "timestamp": 1561613279064, + "version": "3.4" + }, + "pyinstaller-3.4-py37hbc83047_1.conda": { + "build": "py37hbc83047_1", + "build_number": 1, + "depends": [ + "macholib >=1.8", + "pycrypto", + "python >=3.7,<3.8.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 2", + "md5": "e70887d61fd7f198bdd8888404cee84f", + "name": "pyinstaller", + "sha256": "b8a3314e35af079ae3e180c181e67b20e7baca502ba8d220089e6ddb94eadf67", + "size": 1687272, + "subdir": "linux-64", + "timestamp": 1561614320718, + "version": "3.4" + }, + "pyinstaller-3.5-py27hbc83047_0.conda": { + "build": "py27hbc83047_0", + "build_number": 0, + "depends": [ + "dis3", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycrypto", + "python >=2.7,<2.8.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 2", + "md5": "30c46cd273a5d6ed7be62b55e86b612d", + "name": "pyinstaller", + "sha256": "8f190fa0903f4a9a74888d9c97f7d816d8cd07624dee805402030dfc4721bd80", + "size": 1703646, + "subdir": "linux-64", + "timestamp": 1568127081858, + "version": "3.5" + }, + "pyinstaller-3.5-py36hbc83047_0.conda": { + "build": "py36hbc83047_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycrypto", + "python >=3.6,<3.7.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 2", + "md5": "36621bc0aac18e16d55a5345102603c9", + "name": "pyinstaller", + "sha256": "c74a9ccbff88ed80e4fe3841ed7630e6231f19bdad0301dbb18dd14e2f9fb436", + "size": 1704412, + "subdir": "linux-64", + "timestamp": 1568127094368, + "version": "3.5" + }, + "pyinstaller-3.5-py37hbc83047_0.conda": { + "build": "py37hbc83047_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycrypto", + "python >=3.7,<3.8.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 2", + "md5": "56d5c50409f7078195a5a0d628ece55a", + "name": "pyinstaller", + "sha256": "a8f3a8d403148e648855ae92bac8c7daf159b876b75975edbed01878152a11e6", + "size": 1704594, + "subdir": "linux-64", + "timestamp": 1568127093309, + "version": "3.5" + }, + "pyinstaller-3.6-py310h1ccaba5_6.conda": { + "build": "py310h1ccaba5_6", + "build_number": 6, + "depends": [ + "altgraph", + "libgcc-ng >=7.5.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.10,<3.11.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "ec4aaa28fc04c2395a11c8e113b8d28c", + "name": "pyinstaller", + "sha256": "2c143faac23f9e8a1602ba5d0399965d335137f3ba323307ed797e0d73c78934", + "size": 1373366, + "subdir": "linux-64", + "timestamp": 1640810317195, + "version": "3.6" + }, + "pyinstaller-3.6-py36h8f29fe8_6.conda": { + "build": "py36h8f29fe8_6", + "build_number": 6, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.6,<3.7.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "9b1003370addd28c02e1fb295b5fb52b", + "name": "pyinstaller", + "sha256": "ca8e1295422fc545f8b0b6ddb2f53f65aae607d4202c051d9358b1e5125f4e11", + "size": 1381139, + "subdir": "linux-64", + "timestamp": 1615968551485, + "version": "3.6" + }, + "pyinstaller-3.6-py36hbc83047_1.conda": { + "build": "py36hbc83047_1", + "build_number": 1, + "constrains": [ + "setuptools <45.0" + ], + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 2", + "md5": "2af148f21d10cf9f993e139ca3805a8d", + "name": "pyinstaller", + "sha256": "b73062e02236c3938b849df4a7c831c13f5adc167e32c9553916d638956c6eb3", + "size": 1719572, + "subdir": "linux-64", + "timestamp": 1580758834141, + "version": "3.6" + }, + "pyinstaller-3.6-py36hbc83047_2.conda": { + "build": "py36hbc83047_2", + "build_number": 2, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "0d5eff6c7ca0d80b5c467680cb6c5ccf", + "name": "pyinstaller", + "sha256": "e34a7b52e95c26abe005fb6acb304318a9477ad366a21b2d8843fd1acb0df556", + "size": 1367054, + "subdir": "linux-64", + "timestamp": 1589194500353, + "version": "3.6" + }, + "pyinstaller-3.6-py36hbc83047_4.conda": { + "build": "py36hbc83047_4", + "build_number": 4, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "90da74303aafda9d6adc1805fe3ebbf1", + "name": "pyinstaller", + "sha256": "fbb17791f148be9dc18737e7d77a1238cb73659996f149f9efc68633f81345e9", + "size": 1379150, + "subdir": "linux-64", + "timestamp": 1589376275508, + "version": "3.6" + }, + "pyinstaller-3.6-py36hbc83047_5.conda": { + "build": "py36hbc83047_5", + "build_number": 5, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.6,<3.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "f5714fa8ceb446a368747cd10ef14ca8", + "name": "pyinstaller", + "sha256": "9b1b4b985781097556fbd942c8aa477a0e1139f80ed8322d7637790a6bd3c3d3", + "size": 1378085, + "subdir": "linux-64", + "timestamp": 1589567799109, + "version": "3.6" + }, + "pyinstaller-3.6-py37h8f29fe8_6.conda": { + "build": "py37h8f29fe8_6", + "build_number": 6, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.7,<3.8.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "5b1575d621a75918a078bb7b30acde44", + "name": "pyinstaller", + "sha256": "d555180063a06aba4ea8c85a80e336c61918fec9d463f67be8b3df89ec7ffdd4", + "size": 1382609, + "subdir": "linux-64", + "timestamp": 1615968558482, + "version": "3.6" + }, + "pyinstaller-3.6-py37hbc83047_1.conda": { + "build": "py37hbc83047_1", + "build_number": 1, + "constrains": [ + "setuptools <45.0" + ], + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 2", + "md5": "fd0ee05ac68c9ebcb51579fe4f6e134d", + "name": "pyinstaller", + "sha256": "fb4f74b1c78f3abfe46ca5803fa7bde0c122eb181efefdbb63a50e0ecf66cd52", + "size": 1720418, + "subdir": "linux-64", + "timestamp": 1580758840903, + "version": "3.6" + }, + "pyinstaller-3.6-py37hbc83047_2.conda": { + "build": "py37hbc83047_2", + "build_number": 2, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "e92022246059843b4bd35e01a2198d82", + "name": "pyinstaller", + "sha256": "441d1de66a8d99ef895d43b5514fc64c4acf55f38f67184401a17c7b723bd13b", + "size": 1378469, + "subdir": "linux-64", + "timestamp": 1589194453042, + "version": "3.6" + }, + "pyinstaller-3.6-py37hbc83047_4.conda": { + "build": "py37hbc83047_4", + "build_number": 4, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "f906ba1fa9400b748e826fa0c29dd30a", + "name": "pyinstaller", + "sha256": "66f5185282a591f8bc43508637edfd36ee5829df5a998aab22bd2bec62171f6e", + "size": 1380147, + "subdir": "linux-64", + "timestamp": 1589376295588, + "version": "3.6" + }, + "pyinstaller-3.6-py37hbc83047_5.conda": { + "build": "py37hbc83047_5", + "build_number": 5, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.7,<3.8.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "5b6102579559cf455df77f5f2fdab6a1", + "name": "pyinstaller", + "sha256": "a15062b12c105cff2fc821be60aacc32d501ba461bd9f8c9f4ab7bccc6bbcb74", + "size": 1380672, + "subdir": "linux-64", + "timestamp": 1589567799154, + "version": "3.6" + }, + "pyinstaller-3.6-py38h8f29fe8_6.conda": { + "build": "py38h8f29fe8_6", + "build_number": 6, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.8,<3.9.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "19c6ffbd1c801460b2cc65560ef70812", + "name": "pyinstaller", + "sha256": "27a86ccf79208ab16c88402fd3b2b313c5729abd7d632d723cbfe4945aaf35cb", + "size": 1375716, + "subdir": "linux-64", + "timestamp": 1615966688592, + "version": "3.6" + }, + "pyinstaller-3.6-py38hbc83047_1.conda": { + "build": "py38hbc83047_1", + "build_number": 1, + "constrains": [ + "setuptools <45.0" + ], + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL 2", + "md5": "15feb5cf5245381fce5a3635b616b5e9", + "name": "pyinstaller", + "sha256": "1f2edba2e3e70940c4a678bd02bf82ffeb6b575eab1f0363b901638797745604", + "size": 1712232, + "subdir": "linux-64", + "timestamp": 1580758837000, + "version": "3.6" + }, + "pyinstaller-3.6-py38hbc83047_2.conda": { + "build": "py38hbc83047_2", + "build_number": 2, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "94cd1590b45d68a10ca44cdac745824e", + "name": "pyinstaller", + "sha256": "642e60e1931db2c30df4f1796e5cbdc0a6cc0dacb7afd39e9a6a223110122297", + "size": 1378159, + "subdir": "linux-64", + "timestamp": 1589194505863, + "version": "3.6" + }, + "pyinstaller-3.6-py38hbc83047_4.conda": { + "build": "py38hbc83047_4", + "build_number": 4, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "fa3212307d6bb4dbc9129e5cb123f8f9", + "name": "pyinstaller", + "sha256": "d2efd52da0aa7b679596688e875ecabc91cd3bd2dfc903f97986945742c94ee4", + "size": 1381183, + "subdir": "linux-64", + "timestamp": 1589376281329, + "version": "3.6" + }, + "pyinstaller-3.6-py38hbc83047_5.conda": { + "build": "py38hbc83047_5", + "build_number": 5, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.8,<3.9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "d0f0f37d87e24c9bf07cd34616af9a9d", + "name": "pyinstaller", + "sha256": "65cf66124c79d8fc95d513be3ccd58d5a825969e7980fd0bf0b541086bb1b3a8", + "size": 1381517, + "subdir": "linux-64", + "timestamp": 1589567814026, + "version": "3.6" + }, + "pyinstaller-3.6-py39h8f29fe8_6.conda": { + "build": "py39h8f29fe8_6", + "build_number": 6, + "depends": [ + "altgraph", + "libgcc-ng >=7.3.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.9,<3.10.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "f914b5252e061e114b019cbf434641c3", + "name": "pyinstaller", + "sha256": "90b1523389397daa9421c47faacf5e67de00845db6528a426d3b5d8b879086b8", + "size": 1371643, + "subdir": "linux-64", + "timestamp": 1615968540512, + "version": "3.6" + }, + "pyinstaller-4.8-py37h1ccaba5_0.conda": { + "build": "py37h1ccaba5_0", + "build_number": 0, + "depends": [ + "altgraph", + "importlib-metadata >=0.8", + "libgcc-ng >=7.5.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.7,<3.8.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "d141ee18f63cb911d4e6d0941f1d4399", + "name": "pyinstaller", + "sha256": "8d11ec907e508ff0c641f77f1bee5c720b04415c9b0956fa4cf3a7a0a2d45ec8", + "size": 1370444, + "subdir": "linux-64", + "timestamp": 1643735863060, + "version": "4.8" + }, + "pyinstaller-4.8-py38h1ccaba5_0.conda": { + "build": "py38h1ccaba5_0", + "build_number": 0, + "depends": [ + "altgraph", + "libgcc-ng >=7.5.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.8,<3.9.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "023b0fa80c54352b1700e016f24ba401", + "name": "pyinstaller", + "sha256": "274f9422f8550156da5bc6c73c8751d5e5298b383b598cf28a97afbe1134073a", + "size": 1370101, + "subdir": "linux-64", + "timestamp": 1643735789299, + "version": "4.8" + }, + "pyinstaller-4.8-py39h1ccaba5_0.conda": { + "build": "py39h1ccaba5_0", + "build_number": 0, + "depends": [ + "altgraph", + "libgcc-ng >=7.5.0", + "macholib >=1.8", + "pycryptodome", + "python >=3.9,<3.10.0a0", + "setuptools", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "f13f65f259a8b6deb1e8117f16fcd99e", + "name": "pyinstaller", + "sha256": "1f32596a92b63672bd1e974125d5b6bc97e2aba86ccf95ab6a3e1519af20a9d6", + "size": 1369406, + "subdir": "linux-64", + "timestamp": 1643735686533, + "version": "4.8" + }, + "pyinstaller-5.6.2-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "altgraph", + "libgcc-ng >=11.2.0", + "pyinstaller-hooks-contrib >=2021.4", + "python >=3.10,<3.11.0a0", + "setuptools >=42.0.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "8036f8ce7effb3624f1683fd2a056601", + "name": "pyinstaller", + "sha256": "83d5ef66cf7bf542288caf59ef61f6d6e20493607888229d6b529e3b309f215d", + "size": 1045831, + "subdir": "linux-64", + "timestamp": 1670881215226, + "version": "5.6.2" + }, + "pyinstaller-5.6.2-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "altgraph", + "libgcc-ng >=11.2.0", + "pyinstaller-hooks-contrib >=2021.4", + "python >=3.11,<3.12.0a0", + "setuptools >=42.0.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "985bd37d5af3d3c08014fbb07d410ae3", + "name": "pyinstaller", + "sha256": "be7c39dc72709c09e33ae10f74d21c6db6c6bcf0ca1fc3d0e95969e6c11cde9c", + "size": 1202782, + "subdir": "linux-64", + "timestamp": 1676842243683, + "version": "5.6.2" + }, + "pyinstaller-5.6.2-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "altgraph", + "importlib-metadata >=0.8", + "libgcc-ng >=11.2.0", + "pyinstaller-hooks-contrib >=2021.4", + "python >=3.7,<3.8.0a0", + "setuptools >=42.0.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "69d20a1ce032fdf6ac21a12082bb0a30", + "name": "pyinstaller", + "sha256": "886eac397f6ffc1aac4799bb1ff96ae80099243f4414590384daf23e77112ea2", + "size": 1039661, + "subdir": "linux-64", + "timestamp": 1670881104102, + "version": "5.6.2" + }, + "pyinstaller-5.6.2-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "altgraph", + "libgcc-ng >=11.2.0", + "pyinstaller-hooks-contrib >=2021.4", + "python >=3.8,<3.9.0a0", + "setuptools >=42.0.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "1adf884be0364350084836804458ff9c", + "name": "pyinstaller", + "sha256": "f9aa5fd2f73abbca81c8429a1b5175f3439e5ac0241e8a237273ef6bdb41b25a", + "size": 1040776, + "subdir": "linux-64", + "timestamp": 1670881159577, + "version": "5.6.2" + }, + "pyinstaller-5.6.2-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "altgraph", + "libgcc-ng >=11.2.0", + "pyinstaller-hooks-contrib >=2021.4", + "python >=3.9,<3.10.0a0", + "setuptools >=42.0.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "1b51f88231d368ea6b38903c50aa72fa", + "name": "pyinstaller", + "sha256": "a909243a3e9f74ae58475c0b5f9b6c85cb5d9ef541c0738588a221ae5f0f5d52", + "size": 1038667, + "subdir": "linux-64", + "timestamp": 1670881270699, + "version": "5.6.2" + }, + "pyinstaller-hooks-contrib-2022.14-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 OR GPL-2.0-or-later", + "license_family": "Other", + "md5": "e3927236b527acbc967c365e02f844ee", + "name": "pyinstaller-hooks-contrib", + "sha256": "45912675834652c2446d104697a79885b923222bf4a66028c82d9c0475e84e5a", + "size": 166559, + "subdir": "linux-64", + "timestamp": 1670877378809, + "version": "2022.14" + }, + "pyinstaller-hooks-contrib-2022.14-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0 OR GPL-2.0-or-later", + "license_family": "Other", + "md5": "d6a3822085bfb3750ddf81a27b6d9ab2", + "name": "pyinstaller-hooks-contrib", + "sha256": "ba861af5bc9733090946faacbc1a0dec007c4fae29a54ba055898b057ba01abc", + "size": 180989, + "subdir": "linux-64", + "timestamp": 1676838616985, + "version": "2022.14" + }, + "pyinstaller-hooks-contrib-2022.14-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 OR GPL-2.0-or-later", + "license_family": "Other", + "md5": "d120f05cedc2e2a130a705af4b4cf0e3", + "name": "pyinstaller-hooks-contrib", + "sha256": "137d4a7fc5bf83ff6dcb6fc6307fd4d81bd0b8eaeb5cd8195bdc7ffc24bc88be", + "size": 166151, + "subdir": "linux-64", + "timestamp": 1670877444911, + "version": "2022.14" + }, + "pyinstaller-hooks-contrib-2022.14-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 OR GPL-2.0-or-later", + "license_family": "Other", + "md5": "ef9b80c9ed3939299deee8dc760d7631", + "name": "pyinstaller-hooks-contrib", + "sha256": "ab4832a237baac6d9c5938699ff553f6d4f614337e1b4b0e01c7076e2ed70724", + "size": 165931, + "subdir": "linux-64", + "timestamp": 1670877411581, + "version": "2022.14" + }, + "pyinstaller-hooks-contrib-2022.14-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 OR GPL-2.0-or-later", + "license_family": "Other", + "md5": "48df839a505b92df7517d7a8886169f5", + "name": "pyinstaller-hooks-contrib", + "sha256": "5400d32c67cf3adc9c338e68c294c5b780263309f8c7ab024fefc09dce2ca847", + "size": 165547, + "subdir": "linux-64", + "timestamp": 1670877345283, + "version": "2022.14" + }, + "pyjsparser-2.7.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef07f740acfbe1a139e59c476c03dc8c", + "name": "pyjsparser", + "sha256": "2f8ba599ba06c6fac46269823e7cb1f68fe60766b8362b42c8743038d15807c9", + "size": 54247, + "subdir": "linux-64", + "timestamp": 1663891697787, + "version": "2.7.1" + }, + "pyjsparser-2.7.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "099d9ffc3d3df066de1d640e2dc5fa79", + "name": "pyjsparser", + "sha256": "f01c0ab564e8905a65c4778b7ce543aaa9587b9973cad52a52db136cce71ed3a", + "size": 73946, + "subdir": "linux-64", + "timestamp": 1679339576401, + "version": "2.7.1" + }, + "pyjsparser-2.7.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "26375132b1632fee2359985c593c5d3f", + "name": "pyjsparser", + "sha256": "cc78c7032617ec7ccba11bf3c0a10b58034e66c231cb0effed8fc1d250f053db", + "size": 53711, + "subdir": "linux-64", + "timestamp": 1663891747107, + "version": "2.7.1" + }, + "pyjsparser-2.7.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a045acf80e9d92d028eb2ce84b6430e5", + "name": "pyjsparser", + "sha256": "2caf3d3609a67bdc9c511bda9e58fcdc7b16f75bd37b1360211859e258f33912", + "size": 54017, + "subdir": "linux-64", + "timestamp": 1663891722286, + "version": "2.7.1" + }, + "pyjsparser-2.7.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1af416044c0622d5d51dee5ab06de98d", + "name": "pyjsparser", + "sha256": "90526319174430afe15735806667a76bcf736ad071eff9638a3ef9e8e10e5407", + "size": 53870, + "subdir": "linux-64", + "timestamp": 1663891660130, + "version": "2.7.1" + }, + "pyjwt-1.5.2-py27h95ba21f_0.conda": { + "build": "py27h95ba21f_0", + "build_number": 0, + "depends": [ + "cryptography >=1.0", + "flake8", + "flake8-import-order", + "pep8-naming", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "406b0cc012d3266a6b75acf32aa0bd4c", + "name": "pyjwt", + "sha256": "1dfbdb90ad02fd6c0e30d36895b5b8dfcecf065d37d4b038048f960c8173ed34", + "size": 29593, + "subdir": "linux-64", + "timestamp": 1505751694920, + "version": "1.5.2" + }, + "pyjwt-1.5.2-py35he0f1d84_0.conda": { + "build": "py35he0f1d84_0", + "build_number": 0, + "depends": [ + "cryptography >=1.0", + "flake8", + "flake8-import-order", + "pep8-naming", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a354a18cea3fa48559addbe9a6c32005", + "name": "pyjwt", + "sha256": "0b5874273236617145c0c7ae906d5f34e525735734be3898432488616c074a13", + "size": 30076, + "subdir": "linux-64", + "timestamp": 1505751708204, + "version": "1.5.2" + }, + "pyjwt-1.5.2-py36h0aab684_0.conda": { + "build": "py36h0aab684_0", + "build_number": 0, + "depends": [ + "cryptography >=1.0", + "flake8", + "flake8-import-order", + "pep8-naming", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1deb5568b8bf2c7e2e70cd77da836476", + "name": "pyjwt", + "sha256": "7644694a0aa06478bb57ca09046d7386465476971206ef2f7b6825d6fdcf393e", + "size": 29756, + "subdir": "linux-64", + "timestamp": 1505751721336, + "version": "1.5.2" + }, + "pyjwt-1.5.3-py27h579140f_0.conda": { + "build": "py27h579140f_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d5b1dd17bcc9d0155fde58917c2a2239", + "name": "pyjwt", + "sha256": "332a98523c9c0558bb989489c3503bf5fcba54bc02407db03a7a5ed04694e981", + "size": 29701, + "subdir": "linux-64", + "timestamp": 1506866376243, + "version": "1.5.3" + }, + "pyjwt-1.5.3-py35h3a18609_0.conda": { + "build": "py35h3a18609_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd09a8ec194474220870830ac8e478f4", + "name": "pyjwt", + "sha256": "6b11802d06ccddd67dfa2b7a0bd1e840a66cda132509461092c372c7377df8b1", + "size": 30230, + "subdir": "linux-64", + "timestamp": 1506866352183, + "version": "1.5.3" + }, + "pyjwt-1.5.3-py36h7b51858_0.conda": { + "build": "py36h7b51858_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "022041ac5c41b88e0fa5d28ae1d28aa0", + "name": "pyjwt", + "sha256": "26f933cd9328f1062629b0421ad17e47a288cb37f5ff4810e0ac6d4565371104", + "size": 30064, + "subdir": "linux-64", + "timestamp": 1506866395193, + "version": "1.5.3" + }, + "pyjwt-1.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3548cfb623988b4f0f8036b7f8ee2020", + "name": "pyjwt", + "sha256": "484e44ae05309d6585b4828e4b7f72fdcf4e055708793bd8df0566e140e86034", + "size": 30037, + "subdir": "linux-64", + "timestamp": 1520836872514, + "version": "1.6.0" + }, + "pyjwt-1.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b2f220580febdc8d231566c30eccd51", + "name": "pyjwt", + "sha256": "848bd279a4bb869c657765cd208d758e5494277c90edc7595b99c7ba5dd78540", + "size": 30316, + "subdir": "linux-64", + "timestamp": 1520836887530, + "version": "1.6.0" + }, + "pyjwt-1.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8af2942d27b37a2d30d025259c4b98f", + "name": "pyjwt", + "sha256": "dbcb20382d120a18b5c5a40d21fce05bdf84336a8e186cc9a2886d339c9471d6", + "size": 29971, + "subdir": "linux-64", + "timestamp": 1520836858463, + "version": "1.6.0" + }, + "pyjwt-1.6.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "afb9172edc475e19d1b3175a4ff0dd3d", + "name": "pyjwt", + "sha256": "fc8a4466fa2ecbf67ae2444a4f76f8584e6161308aac77c66685a793746a8972", + "size": 30099, + "subdir": "linux-64", + "timestamp": 1522714757846, + "version": "1.6.1" + }, + "pyjwt-1.6.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f41ae2c7b18b979faef53af393deb3cc", + "name": "pyjwt", + "sha256": "f84e9bffb1d2d3b4dd55d79f646ff754b15444679cd3994a05a1a47a6ce12b52", + "size": 30382, + "subdir": "linux-64", + "timestamp": 1522723142251, + "version": "1.6.1" + }, + "pyjwt-1.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a6286eb5f9b37bb4784107f130f19d7a", + "name": "pyjwt", + "sha256": "5e11eea3969636200991f2a1642dece251aef4e7e6cebee89906a37d709205dd", + "size": 30289, + "subdir": "linux-64", + "timestamp": 1522714813172, + "version": "1.6.1" + }, + "pyjwt-1.6.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f7d533fd57740ca076267ea8d2afe3a5", + "name": "pyjwt", + "sha256": "f698b7a5ef2d791141a245798d83f0333df41d7bb7b4a179d3c4832f2ca980e1", + "size": 31821, + "subdir": "linux-64", + "timestamp": 1526927868865, + "version": "1.6.3" + }, + "pyjwt-1.6.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd0e9c7f1e8d0859adc7e2a724732a92", + "name": "pyjwt", + "sha256": "36522f48c58ca0c3a49e1bbf52e0185cad07cf0a70b569f6ca117c0b4c8efe29", + "size": 32418, + "subdir": "linux-64", + "timestamp": 1526927891742, + "version": "1.6.3" + }, + "pyjwt-1.6.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34dee1a4ebd03d3e24801e1f20fa15ae", + "name": "pyjwt", + "sha256": "23b4b0024d2a3f173e8183315d21a7b1db3b98960de7f7648516a904015e44ed", + "size": 31965, + "subdir": "linux-64", + "timestamp": 1526927848547, + "version": "1.6.3" + }, + "pyjwt-1.6.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e56b98fd8f567ae0f83fd226e9781df", + "name": "pyjwt", + "sha256": "44d59719ffcd3334a4d6c568f65e55c082d16e6d4937dab507487e4c5bdac50b", + "size": 31805, + "subdir": "linux-64", + "timestamp": 1527642725964, + "version": "1.6.4" + }, + "pyjwt-1.6.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa6cbaaf6f7a55ca6ba4f6c3ebf58dc8", + "name": "pyjwt", + "sha256": "302a315cb939d06201e9b26d2614e3f586397dfb3f0805a3fed97fae8076b924", + "size": 32605, + "subdir": "linux-64", + "timestamp": 1527642743726, + "version": "1.6.4" + }, + "pyjwt-1.6.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4fe9f095bbed02a1b42a001e7df7f20b", + "name": "pyjwt", + "sha256": "a4024e72e9e0c6641e03ce69b39e2a9f78dc23ef4b61cfd1e7ee84e239f3d060", + "size": 32269, + "subdir": "linux-64", + "timestamp": 1527642686915, + "version": "1.6.4" + }, + "pyjwt-1.6.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cdc3153ed003d3304cbeeb25fa89e180", + "name": "pyjwt", + "sha256": "644967b19867109b2c828af00ffc59ddef5a4cb6c7cc0501e7ab77bdb7e945c0", + "size": 32366, + "subdir": "linux-64", + "timestamp": 1530917110889, + "version": "1.6.4" + }, + "pyjwt-1.7.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "976e219c25e70b84e3e48616abc826e7", + "name": "pyjwt", + "sha256": "788aa545aac8d070a8721de98d2ba06c93d78cd0926309d6fbe69d217ae9eadc", + "size": 33545, + "subdir": "linux-64", + "timestamp": 1545102533870, + "version": "1.7.1" + }, + "pyjwt-1.7.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e3021455f63d682866ab0d608f2bdcf0", + "name": "pyjwt", + "sha256": "e7a1f0beb39ecc45ef4bbc9c2ec64075421e48d4bae6421ee34af669c41844da", + "size": 33600, + "subdir": "linux-64", + "timestamp": 1545102590602, + "version": "1.7.1" + }, + "pyjwt-1.7.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "798fae27b68fe4b237c9b40fda7f3496", + "name": "pyjwt", + "sha256": "9031fef43a95acce78da9e1d6767095600ea988b5505e9cd8e82c1803355b5a5", + "size": 33738, + "subdir": "linux-64", + "timestamp": 1545102590311, + "version": "1.7.1" + }, + "pyjwt-1.7.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cryptography >=1.4", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c7a931894d7a5e1bf8cd8175fe0ead9", + "name": "pyjwt", + "sha256": "83dd287b6f63e831f31509c0de0448a8704580b9ddfb41bf21e7d98e8c8095ce", + "size": 33389, + "subdir": "linux-64", + "timestamp": 1574170452617, + "version": "1.7.1" + }, + "pyjwt-2.0.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6,<3.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db5f662d37532c1fa884ba7e3bbcc48e", + "name": "pyjwt", + "sha256": "0d141e6bd1d7de1b9423c3f27e5dcbf76a7ebaaa312c8160bc7033f262cf2a4e", + "size": 30818, + "subdir": "linux-64", + "timestamp": 1608676281259, + "version": "2.0.0" + }, + "pyjwt-2.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6,<3.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e9d442e5e84c4e0cd01bc6a1f47ebf8", + "name": "pyjwt", + "sha256": "39ac4168b215abbd06b41110b89d26186906543111ecf6c247f74a37dc356c38", + "size": 30823, + "subdir": "linux-64", + "timestamp": 1608676264124, + "version": "2.0.0" + }, + "pyjwt-2.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6,<3.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22df0e0c0b657d859a83d1db3fa2bf35", + "name": "pyjwt", + "sha256": "c80cd7e4f2c209cbc1f6f8c5d54835b76dee650c825f9ff7877f286ececcdc03", + "size": 31035, + "subdir": "linux-64", + "timestamp": 1608676277488, + "version": "2.0.0" + }, + "pyjwt-2.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6,<3.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c11b658295bcf648dd13e415d0cc8d1f", + "name": "pyjwt", + "sha256": "b6ed88f9461e123332ec2f86a09753a25603a0208fad287094b03465846e17cb", + "size": 31127, + "subdir": "linux-64", + "timestamp": 1608676270571, + "version": "2.0.0" + }, + "pyjwt-2.0.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6,<3.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58a1eb6b714414cea871b2d088f69627", + "name": "pyjwt", + "sha256": "77e05a23d4fc96703a4678e36f893ba6ec595742cf70638833a727eacdfce79c", + "size": 30653, + "subdir": "linux-64", + "timestamp": 1610910662777, + "version": "2.0.1" + }, + "pyjwt-2.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6,<3.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a1fe0671d42368fda511949f91ff7593", + "name": "pyjwt", + "sha256": "fbcf6b69bcffa7e80894ec356c8ac0646a7d2e06b3ab7ee06e2c4cd7c38cf5a4", + "size": 30703, + "subdir": "linux-64", + "timestamp": 1610911346466, + "version": "2.0.1" + }, + "pyjwt-2.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6,<3.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "132847a5f4ddfb1cde24e2f92795b56b", + "name": "pyjwt", + "sha256": "088ff04a23a75a6c916dc5d0acaacf564f6684122a5a97d77e8a392a67d04591", + "size": 30820, + "subdir": "linux-64", + "timestamp": 1610911342467, + "version": "2.0.1" + }, + "pyjwt-2.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.6,<3.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e4a86f3a0f8126b8c789576662c32f5", + "name": "pyjwt", + "sha256": "1b2a681999e0f9a8f2a1e596a837f9982e2a232434fd926ea03cf299a2a6b701", + "size": 30833, + "subdir": "linux-64", + "timestamp": 1610911346742, + "version": "2.0.1" + }, + "pyjwt-2.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1,<4.0.0" + ], + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "88670afeb4384f0881e66ac8dbd9b955", + "name": "pyjwt", + "sha256": "d99da10020d7695f899980fb441252127b4e1c182636cd4b55924cc86774c94c", + "size": 32564, + "subdir": "linux-64", + "timestamp": 1640812719524, + "version": "2.1.0" + }, + "pyjwt-2.1.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1,<4.0.0" + ], + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "40c940221f797ddf132dff201c00ffda", + "name": "pyjwt", + "sha256": "5a98faecc1387031e4e39c495787729cd7d9b58b9ce394b9a2d79920363431a2", + "size": 32118, + "subdir": "linux-64", + "timestamp": 1619651662286, + "version": "2.1.0" + }, + "pyjwt-2.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1,<4.0.0" + ], + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "209ed3bc5c762e4dab216efe3e60ed3f", + "name": "pyjwt", + "sha256": "416a845bea79c3efa6146aab8f08508a99fde9133320b0252fac7099e7c42b11", + "size": 32323, + "subdir": "linux-64", + "timestamp": 1619651659552, + "version": "2.1.0" + }, + "pyjwt-2.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1,<4.0.0" + ], + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e44de471b6089edb26a783dd793eeecc", + "name": "pyjwt", + "sha256": "0a3723060a4d3a78525f5e35eb69cbcef9496fef1e57ec99b0f72bba4989fa4c", + "size": 32316, + "subdir": "linux-64", + "timestamp": 1619651677344, + "version": "2.1.0" + }, + "pyjwt-2.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1,<4.0.0" + ], + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49727616122154af75768f3967aeecd7", + "name": "pyjwt", + "sha256": "ac0360d84e2e637b8b32d7f092a6ff851033907f0d74519711077725f427b854", + "size": 32518, + "subdir": "linux-64", + "timestamp": 1619682520712, + "version": "2.1.0" + }, + "pyjwt-2.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1" + ], + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df36af5bbfb5f11d18cd97d332afe934", + "name": "pyjwt", + "sha256": "04d1c0fe26669ceb5de844a8370ef2e7aa1fcb6f2f3030b59bd27f10a281f182", + "size": 35581, + "subdir": "linux-64", + "timestamp": 1657544749938, + "version": "2.4.0" + }, + "pyjwt-2.4.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1" + ], + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "05147f048db6dca123f017184c98c04c", + "name": "pyjwt", + "sha256": "028c2f078c1e33291545f4e2d311127227404a08d441fee0aa0cdf6dda438998", + "size": 45083, + "subdir": "linux-64", + "timestamp": 1676827398906, + "version": "2.4.0" + }, + "pyjwt-2.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1" + ], + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dfa0e2f18b3c1d97ac07caacbf94396a", + "name": "pyjwt", + "sha256": "48123d0b2bda00b08d4be41f0a1497d16ebb625cba750e65e446d54f97e2b34f", + "size": 35153, + "subdir": "linux-64", + "timestamp": 1657544710378, + "version": "2.4.0" + }, + "pyjwt-2.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1" + ], + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "40ba7ca86b2c5bc7be7b3e82de9ecb22", + "name": "pyjwt", + "sha256": "97c08d36c0581d14ea25191bb611438725027effc4ab08530d7584b77940d96c", + "size": 35266, + "subdir": "linux-64", + "timestamp": 1657544683058, + "version": "2.4.0" + }, + "pyjwt-2.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "cryptography >=3.3.1" + ], + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4bb6ecf0c197d68edf10f6e2b9bc220", + "name": "pyjwt", + "sha256": "26bdd64249741d39d6d82f8684d7c9105daac45af0669dbe820b80a3ea2aae70", + "size": 35308, + "subdir": "linux-64", + "timestamp": 1657544645989, + "version": "2.4.0" + }, + "pykdtree-1.3.1-py27hdd07704_2.conda": { + "build": "py27hdd07704_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "md5": "c4735787030978755ddb89da1f41e61d", + "name": "pykdtree", + "sha256": "a771f7ef1e26d32a7f36fda7349f8dc83a3f62d954d4714dee4d7b30893eeb0f", + "size": 67389, + "subdir": "linux-64", + "timestamp": 1545159138956, + "version": "1.3.1" + }, + "pykdtree-1.3.1-py36hdd07704_2.conda": { + "build": "py36hdd07704_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "md5": "45de80181f1d8d53278931049ebc8a6e", + "name": "pykdtree", + "sha256": "7e4688fca32aa99cb7de8999cfa086a3eba83371895219295a95403cb0519f0b", + "size": 62790, + "subdir": "linux-64", + "timestamp": 1545159060411, + "version": "1.3.1" + }, + "pykdtree-1.3.1-py37hdd07704_2.conda": { + "build": "py37hdd07704_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "md5": "3b194ab407f1b718c262be15c59fdd07", + "name": "pykdtree", + "sha256": "1049b012c075a88ca6f94d267a54c1ef4601eaf4729cfc1d5354c36ffee6a6b0", + "size": 62668, + "subdir": "linux-64", + "timestamp": 1545159926249, + "version": "1.3.1" + }, + "pykdtree-1.3.1-py38hdd07704_1002.conda": { + "build": "py38hdd07704_1002", + "build_number": 1002, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0", + "md5": "538d88cfaba324ad08dfc8ec69b4c85d", + "name": "pykdtree", + "sha256": "62d3cdeffdd7e974e8c1dc84fd169aea88a7e071824854a6595483e2644431b4", + "size": 70797, + "subdir": "linux-64", + "timestamp": 1573469878062, + "version": "1.3.1" + }, + "pykdtree-1.3.4-py310h9102076_1002.conda": { + "build": "py310h9102076_1002", + "build_number": 1002, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0", + "md5": "a6f7c9373f9ae09bb61e30fefb50ce8c", + "name": "pykdtree", + "sha256": "9dd17b4e6782217baab1a0c6594efe6bf2bb5b46f2c9b23d101692fc72043b6a", + "size": 177157, + "subdir": "linux-64", + "timestamp": 1640793423364, + "version": "1.3.4" + }, + "pykdtree-1.3.4-py36h6323ea4_1002.conda": { + "build": "py36h6323ea4_1002", + "build_number": 1002, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "md5": "f1d5e33c012d89abdbeb041de68f8155", + "name": "pykdtree", + "sha256": "71b243a089012055ae8f65c589a4bdb798567564979bb33c83b1c0fbdf362dec", + "size": 65576, + "subdir": "linux-64", + "timestamp": 1612299341729, + "version": "1.3.4" + }, + "pykdtree-1.3.4-py37h6323ea4_1002.conda": { + "build": "py37h6323ea4_1002", + "build_number": 1002, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "md5": "9ec79e8a6dbc8a5f3bad20359b24a721", + "name": "pykdtree", + "sha256": "26e0a516f67dcfd8547aba3ae948cbec3bd63c16581b15af974a7737c3ec417c", + "size": 64864, + "subdir": "linux-64", + "timestamp": 1612298828810, + "version": "1.3.4" + }, + "pykdtree-1.3.4-py38h6323ea4_1002.conda": { + "build": "py38h6323ea4_1002", + "build_number": 1002, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0", + "md5": "90da514be650ea1011f97819c3af612b", + "name": "pykdtree", + "sha256": "7747cbf014f027b992a59010ea246e0bd575bc02059eefd294d5297549fe7ed8", + "size": 67538, + "subdir": "linux-64", + "timestamp": 1612299363469, + "version": "1.3.4" + }, + "pykdtree-1.3.4-py39h6323ea4_1002.conda": { + "build": "py39h6323ea4_1002", + "build_number": 1002, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0", + "md5": "993258e6c21e6d2bf7066ada77b690a7", + "name": "pykdtree", + "sha256": "27e290f3f55f27fff8538acc953cb20fceb30a53cc2144ce72c5c845e9556925", + "size": 66133, + "subdir": "linux-64", + "timestamp": 1612299361438, + "version": "1.3.4" + }, + "pykdtree-1.3.6-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "c3fb68a6d7077972139e8ac95a689fc9", + "name": "pykdtree", + "sha256": "a1bae6223e980fd15c166cc479e4861ba222f5757239f173a702b272bd4f89b5", + "size": 73056, + "subdir": "linux-64", + "timestamp": 1676300839216, + "version": "1.3.6" + }, + "pykdtree-1.3.6-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "libgcc-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "0387376d44865dd3b3fe927a8f05fe71", + "name": "pykdtree", + "sha256": "f3f8f06140a5c32f1fdb3ce8f0c05d47f39ede632e77121e2271f0cb9369f59e", + "size": 67232, + "subdir": "linux-64", + "timestamp": 1676860890675, + "version": "1.3.6" + }, + "pykdtree-1.3.6-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "libgcc-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "402925ed9a71e50a35546ab365ab16b4", + "name": "pykdtree", + "sha256": "abb6da34a59f24eb277909ff7c37252bd0a83f190da61d75d2908d82b7ad0d0e", + "size": 73954, + "subdir": "linux-64", + "timestamp": 1676300722726, + "version": "1.3.6" + }, + "pykdtree-1.3.6-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "libgcc-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "1c6d6239b75243cddd028f68c89fd155", + "name": "pykdtree", + "sha256": "6b046b98852f8adb1dadd737e243ff7c3ed2b62a1019b112aa15965cd150bc82", + "size": 76920, + "subdir": "linux-64", + "timestamp": 1676300800300, + "version": "1.3.6" + }, + "pykdtree-1.3.6-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "_openmp_mutex >=5.1", + "libgcc-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "e9aeff35bf44d56a517dbbcca00bcc7e", + "name": "pykdtree", + "sha256": "c55b31d5a0ca170ea6896dfb57b306a699d57f8c5dbdd23c9387d22bf4c8e248", + "size": 73869, + "subdir": "linux-64", + "timestamp": 1676300761443, + "version": "1.3.6" + }, + "pykerberos-1.1.14-py27h2de3caf_2.conda": { + "build": "py27h2de3caf_2", + "build_number": 2, + "depends": [ + "krb5", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache", + "md5": "c7a7e6a4460e7c532115d8cbc9bec910", + "name": "pykerberos", + "sha256": "869c74bb9ca066bc35c0b15265a29d9b477048aac70bba5278eb3c9d8bb9a8c7", + "size": 21816, + "subdir": "linux-64", + "timestamp": 1505851501450, + "version": "1.1.14" + }, + "pykerberos-1.1.14-py35h589a6a4_2.conda": { + "build": "py35h589a6a4_2", + "build_number": 2, + "depends": [ + "krb5", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache", + "md5": "4b0359cf9228ce7d722c04285ef138f9", + "name": "pykerberos", + "sha256": "0d1c7973969e20cff50440067ef47e32e748a4f033b2d5cec0f3830b23514b49", + "size": 22299, + "subdir": "linux-64", + "timestamp": 1505851515587, + "version": "1.1.14" + }, + "pykerberos-1.1.14-py36h84109d8_2.conda": { + "build": "py36h84109d8_2", + "build_number": 2, + "depends": [ + "krb5", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache", + "md5": "908c5ebc4c9ee7e23c25b9ddde9b73bf", + "name": "pykerberos", + "sha256": "b18263da96ffdf11db831cefcbf34be66d648621929783dc45911cffc732d460", + "size": 21943, + "subdir": "linux-64", + "timestamp": 1505851529775, + "version": "1.1.14" + }, + "pykerberos-1.2.1-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "krb5", + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache", + "md5": "cf80ad9586c9d298cfa285df56de5922", + "name": "pykerberos", + "sha256": "428f7bc917828ac06294f6eb82736ac74c986f8ae2a8ee2a283ca384d64a04ee", + "size": 25217, + "subdir": "linux-64", + "timestamp": 1519491544901, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py310h7f8727e_3.conda": { + "build": "py310h7f8727e_3", + "build_number": 3, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "49ed18362f83ddc781c1d6c7b98f158a", + "name": "pykerberos", + "sha256": "d2ec5298c4f1140d23de71124bf82791ced0631664de8198b8839469dd656707", + "size": 62827, + "subdir": "linux-64", + "timestamp": 1640793448595, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py311h5eee18b_3.conda": { + "build": "py311h5eee18b_3", + "build_number": 3, + "depends": [ + "krb5 >=1.19.4,<1.20.0a0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "53784d6a429172549354a39cd2d4fb58", + "name": "pykerberos", + "sha256": "ed9b50f0f2580bc70112521c48cdce469d7c994c7aad757cdee28c70ddb3d554", + "size": 24979, + "subdir": "linux-64", + "timestamp": 1676838635814, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "krb5", + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache", + "md5": "503caa4561a9f9465117546d204dde8d", + "name": "pykerberos", + "sha256": "b5fd03abbc92fda2190c00cb0132aa2d47baaa407b249ffa8d17dc44ec426264", + "size": 24694, + "subdir": "linux-64", + "timestamp": 1519491558272, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "krb5", + "krb5 >=1.14.2,<1.15.0a0", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache", + "md5": "728cf5ea90d71e82d42e075f7029e4bb", + "name": "pykerberos", + "sha256": "9e484ebe87b0eb4c88f1d032bc32db818c0d89c854e65a2d3e4ba44638e909be", + "size": 24678, + "subdir": "linux-64", + "timestamp": 1519491543474, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py36h27cfd23_2.conda": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache", + "md5": "504ef0a68f811c2829a76fe43a83d960", + "name": "pykerberos", + "sha256": "1fe4128fd2b26505da14f2664cb86d902599bdf0d5e8b7bef7a87443a689ee37", + "size": 263994, + "subdir": "linux-64", + "timestamp": 1613408386672, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py36h680d80a_2.conda": { + "build": "py36h680d80a_2", + "build_number": 2, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache", + "md5": "e008e2a8d976209d176809c45b518666", + "name": "pykerberos", + "sha256": "77f14c65716c789fee77197e6f48eed4b9e097a5c3ac05f6f2fc56205135b565", + "size": 218858, + "subdir": "linux-64", + "timestamp": 1594997421098, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py36ha6b2b2b_1.conda": { + "build": "py36ha6b2b2b_1", + "build_number": 1, + "depends": [ + "krb5 >=1.17.1,<1.18.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache", + "md5": "11186cc65229cacd2d895220f3e91e3b", + "name": "pykerberos", + "sha256": "41be1f8963bd320081df5dc88e979f3f48cbaf4debee9437e8f54497e87236dc", + "size": 218672, + "subdir": "linux-64", + "timestamp": 1595000249188, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache", + "md5": "69b9f414497e151170baf134c193070f", + "name": "pykerberos", + "sha256": "1685756a454f0eb317652fe806e54199147af8026fbd3aaf45dff64c1d0564d1", + "size": 24794, + "subdir": "linux-64", + "timestamp": 1530917144269, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py37h27cfd23_2.conda": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache", + "md5": "85d10fde87739d5463f39dcc8f3eab88", + "name": "pykerberos", + "sha256": "65ed2a763f5cc93aec6775e316abd94f97a6f22403adf038b75d810e48b92af5", + "size": 266079, + "subdir": "linux-64", + "timestamp": 1613408374671, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py37h680d80a_2.conda": { + "build": "py37h680d80a_2", + "build_number": 2, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache", + "md5": "c2fb6e34e0f4213bffc4ff06a06c65d9", + "name": "pykerberos", + "sha256": "83b53fccb759d48b29680bf63fc38f2af786c8e65bf89a772f4e40110ab359a7", + "size": 218949, + "subdir": "linux-64", + "timestamp": 1595000390949, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py37h7f8727e_3.conda": { + "build": "py37h7f8727e_3", + "build_number": 3, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "de0965d185d95ad287bd99a3eaff7cc9", + "name": "pykerberos", + "sha256": "3f492adfeb60fe523a6e4dacaf84af52e5361dd50141d7096b12ebc8cfd3f46d", + "size": 27357, + "subdir": "linux-64", + "timestamp": 1634868615941, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py37ha6b2b2b_1.conda": { + "build": "py37ha6b2b2b_1", + "build_number": 1, + "depends": [ + "krb5 >=1.17.1,<1.18.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache", + "md5": "75c9e5713a8f69d5478cf46a4ecda432", + "name": "pykerberos", + "sha256": "b841248a8c6cd81229cfbfce453bf6286c3c1a21f4c01dd25476fc97e61753eb", + "size": 218776, + "subdir": "linux-64", + "timestamp": 1595000249296, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py38h27cfd23_2.conda": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache", + "md5": "22c7eed7a2259ff5dce9f2d6e830a9d2", + "name": "pykerberos", + "sha256": "ff7c151c97584e5af5560eb7bdcebe9ce217ac5487748f36cbca6c624551e45e", + "size": 265230, + "subdir": "linux-64", + "timestamp": 1613407791392, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py38h680d80a_2.conda": { + "build": "py38h680d80a_2", + "build_number": 2, + "depends": [ + "krb5 >=1.18.2,<1.19.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache", + "md5": "260f7630ff6bda7bf0b0cf5f610ac245", + "name": "pykerberos", + "sha256": "4a031a6c99bb755967bf1890f2032fc0355d568da4260e9f79b608cbf8677129", + "size": 219415, + "subdir": "linux-64", + "timestamp": 1595000777311, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "krb5 >=1.16.1,<1.17.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache", + "md5": "7807e6e8ca56575e5a3bc1033761e337", + "name": "pykerberos", + "sha256": "bb0fea51350378be89df793e21ee53c644fc10133e34f41a673bf06d2d1301f0", + "size": 32131, + "subdir": "linux-64", + "timestamp": 1573670007122, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py38h7f8727e_3.conda": { + "build": "py38h7f8727e_3", + "build_number": 3, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e720161336af2302918664f3e27b44b9", + "name": "pykerberos", + "sha256": "2d9a3c481bcdda20088faee270ef51961c82cc811f0f05110dd698bdae2b4606", + "size": 27369, + "subdir": "linux-64", + "timestamp": 1634880050512, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py38ha6b2b2b_1.conda": { + "build": "py38ha6b2b2b_1", + "build_number": 1, + "depends": [ + "krb5 >=1.17.1,<1.18.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache", + "md5": "164838015f0d3f1b7956084cf6c4392f", + "name": "pykerberos", + "sha256": "ffc85ea13d0def7bb3c7de73c2d595e251e6fb122b44e63babd59fb2553242a4", + "size": 219385, + "subdir": "linux-64", + "timestamp": 1594996891602, + "version": "1.2.1" + }, + "pykerberos-1.2.1-py39h7f8727e_3.conda": { + "build": "py39h7f8727e_3", + "build_number": 3, + "depends": [ + "krb5 >=1.19.2,<1.20.0a0", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fc2429722087824fec190b1619590bfd", + "name": "pykerberos", + "sha256": "90b4b50f28074bf75b8c0fb74dfaadaf285fe2386486b066d5b6cfa42ccf1350", + "size": 27355, + "subdir": "linux-64", + "timestamp": 1634880044425, + "version": "1.2.1" + }, + "pylint-1.7.2-py27h77e98c6_0.conda": { + "build": "py27h77e98c6_0", + "build_number": 0, + "depends": [ + "astroid >=1.5.1", + "backports.functools_lru_cache", + "configparser", + "isort >=4.2.5", + "mccabe", + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "GPL", + "md5": "257c6ce85aaff661a4585de7aeca83eb", + "name": "pylint", + "sha256": "9564a7b6638e10049ba966cf09af300885c93334169dca51c28925d87f4f9b47", + "size": 677211, + "subdir": "linux-64", + "timestamp": 1505751756145, + "version": "1.7.2" + }, + "pylint-1.7.2-py35hc802fb1_0.conda": { + "build": "py35hc802fb1_0", + "build_number": 0, + "depends": [ + "astroid >=1.5.1", + "isort >=4.2.5", + "mccabe", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "GPL", + "md5": "cb2d55352e57b4a43accdbb2a989d1e4", + "name": "pylint", + "sha256": "0a12b6c909c9ffe9c09bf6cceffdf9652c20344fcd8e31d63834f843fe1ae249", + "size": 696520, + "subdir": "linux-64", + "timestamp": 1505751808379, + "version": "1.7.2" + }, + "pylint-1.7.2-py36h484ab97_0.conda": { + "build": "py36h484ab97_0", + "build_number": 0, + "depends": [ + "astroid >=1.5.1", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "GPL", + "md5": "4e45f9153bafe2799b1809ed8795d17d", + "name": "pylint", + "sha256": "39755070096ea1b899dd418d58f036d87410bbc40fc191e12ea4e738537525c4", + "size": 694602, + "subdir": "linux-64", + "timestamp": 1505751861090, + "version": "1.7.2" + }, + "pylint-1.7.4-py27h6bc7935_0.conda": { + "build": "py27h6bc7935_0", + "build_number": 0, + "depends": [ + "astroid >=1.5.1", + "backports.functools_lru_cache", + "configparser", + "isort >=4.2.5", + "mccabe", + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "GPL", + "md5": "3e64ec2dd8f5166a7b8ede0f6617bfc8", + "name": "pylint", + "sha256": "c8c15344646ed992ff03c6a2437bae428b01fb081e7db65686a539de4ec05aee", + "size": 676269, + "subdir": "linux-64", + "timestamp": 1507663897432, + "version": "1.7.4" + }, + "pylint-1.7.4-py35h319e60b_0.conda": { + "build": "py35h319e60b_0", + "build_number": 0, + "depends": [ + "astroid >=1.5.1", + "isort >=4.2.5", + "mccabe", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "GPL", + "md5": "dc2f7054fcff6fa4ae8df57a62ad050a", + "name": "pylint", + "sha256": "8c0f9c014a7618040335a53539740f67ecf103d77bef377f05d7a045bdb7160d", + "size": 695867, + "subdir": "linux-64", + "timestamp": 1507663919382, + "version": "1.7.4" + }, + "pylint-1.7.4-py36hb9d4533_0.conda": { + "build": "py36hb9d4533_0", + "build_number": 0, + "depends": [ + "astroid >=1.5.1", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "GPL", + "md5": "dab35dd2acc9cfaca17b3539a1091412", + "name": "pylint", + "sha256": "0ce5f08bc5e5f7520007b91f6cf62bef31100cc94af0e8b37e5fac59ac5d6f8f", + "size": 702347, + "subdir": "linux-64", + "timestamp": 1507663921338, + "version": "1.7.4" + }, + "pylint-1.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astroid >=1.5.1", + "backports.functools_lru_cache", + "configparser", + "isort >=4.2.5", + "mccabe", + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "GPL", + "md5": "f8740a4f304b1955a12f9a95a652058d", + "name": "pylint", + "sha256": "4e48a1c85c09ce9ac9c37ec675ac6ef6945e0519fa8c905937e74c6ced5613c6", + "size": 716668, + "subdir": "linux-64", + "timestamp": 1515723916529, + "version": "1.8.1" + }, + "pylint-1.8.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astroid >=1.5.1", + "isort >=4.2.5", + "mccabe", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "GPL", + "md5": "3d1e7ff998d29e87e558ea409836220b", + "name": "pylint", + "sha256": "6421529443521a9b00f0ed9657aa90ba915f017acd0e41644368d9664e1f10f1", + "size": 737734, + "subdir": "linux-64", + "timestamp": 1515723971117, + "version": "1.8.1" + }, + "pylint-1.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=1.5.1", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "GPL", + "md5": "e97dfde8fb4f6e18b43d67932daaa8e3", + "name": "pylint", + "sha256": "c404092da35818aa861b204c50c066ca14bff821d6e6aadd815530e0add24acb", + "size": 736648, + "subdir": "linux-64", + "timestamp": 1515723848359, + "version": "1.8.1" + }, + "pylint-1.8.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "backports.functools_lru_cache", + "configparser", + "isort >=4.2.5", + "mccabe", + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "GPL", + "md5": "85ad643c6ba4fd76015e8e6e73773ddb", + "name": "pylint", + "sha256": "227a8816ec79e06d5dbda03dcc26186596d4eabd10d88c7df5912f326322d48d", + "size": 712638, + "subdir": "linux-64", + "timestamp": 1517330103090, + "version": "1.8.2" + }, + "pylint-1.8.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "GPL", + "md5": "87b4c2fe2e1a56739a6c3a0b2f5a4c22", + "name": "pylint", + "sha256": "740bc3f4d7240bb298863ef111c0c944b89841a2b547df274ad8d825818744a3", + "size": 731129, + "subdir": "linux-64", + "timestamp": 1517330169459, + "version": "1.8.2" + }, + "pylint-1.8.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "GPL", + "md5": "b8fde467432ad6b5ef2a7b4ad227c549", + "name": "pylint", + "sha256": "7988e6f865beb6a7f488cc63c67cc31871f326f4e524788d38c5fa61255e3673", + "size": 737867, + "subdir": "linux-64", + "timestamp": 1517330143745, + "version": "1.8.2" + }, + "pylint-1.8.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "backports.functools_lru_cache", + "configparser", + "isort >=4.2.5", + "mccabe", + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "GPL", + "md5": "3ac9ced2acacfca554fa4ef086a81a00", + "name": "pylint", + "sha256": "3d2e6908bb6b8eed491b780f6a8ba1c4920c79c836da250eca85bbda4e139645", + "size": 719571, + "subdir": "linux-64", + "timestamp": 1521493909572, + "version": "1.8.3" + }, + "pylint-1.8.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "GPL", + "md5": "b38d1f51e7388fd386df475fb8743523", + "name": "pylint", + "sha256": "771b2576a3155ac40706186109173e653a6b9fe2c98a1df942ee88ca5d35d95c", + "size": 732271, + "subdir": "linux-64", + "timestamp": 1521493932816, + "version": "1.8.3" + }, + "pylint-1.8.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "GPL", + "md5": "67b32b6acb3dbc4b027f996371badfef", + "name": "pylint", + "sha256": "4981dcfebac358aafec806ee4c004627c8efae38c438130ed6ba1c82031e1f45", + "size": 747142, + "subdir": "linux-64", + "timestamp": 1521493865068, + "version": "1.8.3" + }, + "pylint-1.8.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "backports.functools_lru_cache", + "configparser", + "isort >=4.2.5", + "mccabe", + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "GPL", + "md5": "a621eb6aefa7b043659dab6cb579e407", + "name": "pylint", + "sha256": "5d6d14dc0f1fedf047c54d307c6c72110cc4e9e8038bb310f41b52fca8bbafb6", + "size": 721141, + "subdir": "linux-64", + "timestamp": 1523130513382, + "version": "1.8.4" + }, + "pylint-1.8.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "GPL", + "md5": "0d5c4cf2097579273c769f9cca826c3b", + "name": "pylint", + "sha256": "0e9d01dbddcadaac648baaa5b39a7c081043d92de37b6b11f46077196d2e9d22", + "size": 742290, + "subdir": "linux-64", + "timestamp": 1523130537727, + "version": "1.8.4" + }, + "pylint-1.8.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "GPL", + "md5": "1f547cbc52408a1afd889d24aefdbc57", + "name": "pylint", + "sha256": "55acbd8007784953fb1238b35e3d92a4a050df322f1b050599909fbafd6f993e", + "size": 748380, + "subdir": "linux-64", + "timestamp": 1523130537502, + "version": "1.8.4" + }, + "pylint-1.9.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "backports.functools_lru_cache", + "configparser", + "isort >=4.2.5", + "mccabe", + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "GPL", + "md5": "2a029a9e91af2b00948bb4d67ed96875", + "name": "pylint", + "sha256": "6350bcd822850465dd3eb26702f9a27ed20712225500f20b99c6f0594b2735f7", + "size": 758589, + "subdir": "linux-64", + "timestamp": 1527828666463, + "version": "1.9.1" + }, + "pylint-1.9.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "GPL", + "md5": "2874a7b7ad1c4ca51fe247a231a9aa8a", + "name": "pylint", + "sha256": "6989601b6b2dd28fc26675eaa3fd3280cf55be6e0451b8d65b4a0efe4f9bb65a", + "size": 771737, + "subdir": "linux-64", + "timestamp": 1527828748833, + "version": "1.9.1" + }, + "pylint-1.9.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "GPL", + "md5": "4cdb33bc64e981504f57795c54304e76", + "name": "pylint", + "sha256": "454e7e71e9bac2ff8e5f3a86587055372aef25ad0883981ec8e041d15fe45e06", + "size": 774902, + "subdir": "linux-64", + "timestamp": 1527828712319, + "version": "1.9.1" + }, + "pylint-1.9.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "backports.functools_lru_cache", + "configparser", + "isort >=4.2.5", + "mccabe", + "python >=2.7,<2.8.0a0", + "singledispatch", + "six" + ], + "license": "GPL", + "md5": "643b10cc5e25b5ae7912233056e26868", + "name": "pylint", + "sha256": "f31c3c8488f1a14e5df4a5cf32cb1dd96472b96ce479a2c72f268b577dab1f99", + "size": 752501, + "subdir": "linux-64", + "timestamp": 1528899388109, + "version": "1.9.2" + }, + "pylint-1.9.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "GPL", + "md5": "5719ed2d1db9dbfa45e9efc5b20774b8", + "name": "pylint", + "sha256": "c31a12250840a493daed8cf9cd5e5641bb1b88b6cbc5d547637fca2312a745ea", + "size": 782051, + "subdir": "linux-64", + "timestamp": 1528899766814, + "version": "1.9.2" + }, + "pylint-1.9.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "GPL", + "md5": "9c55c973ce3f1527aeded6975e34fbc3", + "name": "pylint", + "sha256": "3462fded42ee60d465ea38aeb7458e53544055c55aceac5804e8580720bcb01f", + "size": 770864, + "subdir": "linux-64", + "timestamp": 1528899663538, + "version": "1.9.2" + }, + "pylint-1.9.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=1.6,<2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "GPL", + "md5": "c973109efd2212711d9ea34339282ebb", + "name": "pylint", + "sha256": "5d75d1957811b186882484bdbd8d6b5b8ebe5e952d978f20a06f69c352b38fa5", + "size": 769466, + "subdir": "linux-64", + "timestamp": 1530917214191, + "version": "1.9.2" + }, + "pylint-2.1.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "astroid >=2.0.0", + "isort >=4.2.5", + "mccabe", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL", + "md5": "cf8aeebf5491249061e0bd96803b303b", + "name": "pylint", + "sha256": "25e9a8aaf0ca59693abfe7cd150a22a75f50fa1e55e8cf208e955e5f664ccd32", + "size": 791256, + "subdir": "linux-64", + "timestamp": 1533749855454, + "version": "2.1.1" + }, + "pylint-2.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.0.0", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL", + "md5": "e1f2e2c59c01c2b1a1d7e725f42c21bc", + "name": "pylint", + "sha256": "1998aaf39d70c67756c5e1d7eb6bd2b761212bdfb2298a1757acf4fb2a07c131", + "size": 777321, + "subdir": "linux-64", + "timestamp": 1533749781258, + "version": "2.1.1" + }, + "pylint-2.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.0.0", + "isort >=4.2.5", + "mccabe", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL", + "md5": "161a846dbf7290d488564be1a45f95c9", + "name": "pylint", + "sha256": "f47b9a5fabfcca84ac9e74498723b729efc9b77febc79b56e45a8eb57c807f82", + "size": 781396, + "subdir": "linux-64", + "timestamp": 1533749926549, + "version": "2.1.1" + }, + "pylint-2.12.2-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.9.0,<2.10", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.10,<3.11.0a0", + "toml >=0.9.2", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "cc6b964eabe2f68598f872ecf391ad3a", + "name": "pylint", + "sha256": "a9da4bb6f6933a8f851f7f281793f4050b1f1b45e391ab60dd3b09feef54e693", + "size": 565501, + "subdir": "linux-64", + "timestamp": 1647959929255, + "version": "2.12.2" + }, + "pylint-2.12.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.9.0,<2.10", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "platformdirs >=2.2.0", + "python >=3.7,<3.8.0a0", + "toml >=0.9.2", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "d480a0dde50ea392e6e8b8742cef289c", + "name": "pylint", + "sha256": "7552fa96f43d2ab8310a54c99776acecb3cb7517d5c3252cbad6ffcb6a8a59db", + "size": 555616, + "subdir": "linux-64", + "timestamp": 1639632506335, + "version": "2.12.2" + }, + "pylint-2.12.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.9.0,<2.10", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.7,<3.8.0a0", + "toml >=0.9.2", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "9554ee8a6c603169d598651bf275d686", + "name": "pylint", + "sha256": "3b40f822db0f89300797fef0b3df6ddc20008d754e44a0eacc51ffa9e5710540", + "size": 550965, + "subdir": "linux-64", + "timestamp": 1647942053245, + "version": "2.12.2" + }, + "pylint-2.12.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.9.0,<2.10", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "platformdirs >=2.2.0", + "python >=3.8,<3.9.0a0", + "toml >=0.9.2", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "71d70a528a6f5aff9b30eac5aaa98d54", + "name": "pylint", + "sha256": "0514d7ad5123117b079b156af609fbff741b7237ff3296e919082c0f2b623c05", + "size": 558556, + "subdir": "linux-64", + "timestamp": 1639650628766, + "version": "2.12.2" + }, + "pylint-2.12.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.9.0,<2.10", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.8,<3.9.0a0", + "toml >=0.9.2", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "ea105e33373be71bce2fcdfdc3a5d833", + "name": "pylint", + "sha256": "51fd75d3d12f92142e9145ef0e8e9f9fd7dba55dcba6e3f80a599fa39d04f544", + "size": 553263, + "subdir": "linux-64", + "timestamp": 1647941783970, + "version": "2.12.2" + }, + "pylint-2.12.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.9.0,<2.10", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "platformdirs >=2.2.0", + "python >=3.9,<3.10.0a0", + "toml >=0.9.2", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "38ab4144ff27a978af5441bc620b4f55", + "name": "pylint", + "sha256": "d8d408c7251930d2e4de430e0aa74c81e5e10b6c251e7dba0d31c50c320540ce", + "size": 552669, + "subdir": "linux-64", + "timestamp": 1639650625612, + "version": "2.12.2" + }, + "pylint-2.12.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.9.0,<2.10", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.9,<3.10.0a0", + "toml >=0.9.2", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "bcfca6cbea23fd325c5c2c953d89e355", + "name": "pylint", + "sha256": "0f285857b38a56348e3b9dc79b116875c6e21e1c6ee6a4597263de8c653a418c", + "size": 551954, + "subdir": "linux-64", + "timestamp": 1647941882980, + "version": "2.12.2" + }, + "pylint-2.14.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.11.6,<2.12.0", + "dill >=0.2", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.10,<3.11.0a0", + "tomli >=1.1.0", + "tomlkit >=0.10.1", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "810d7cf2f878662fc6b80908752ee7fc", + "name": "pylint", + "sha256": "51173902277f2b33a771b4aaf15bbb8cc80723571c9e329a8c368f18a4e31ed3", + "size": 661982, + "subdir": "linux-64", + "timestamp": 1659110529816, + "version": "2.14.5" + }, + "pylint-2.14.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.11.6,<2.12.0", + "dill >=0.2", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.7,<3.8.0a0", + "tomli >=1.1.0", + "tomlkit >=0.10.1", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "9c7cb3ca23d3d12595e03ba7a04cfe5e", + "name": "pylint", + "sha256": "e7c21cda072c975d06557c238d8848f7367cd7aea38ecd0f88349d15eb68bbd1", + "size": 648248, + "subdir": "linux-64", + "timestamp": 1659110436108, + "version": "2.14.5" + }, + "pylint-2.14.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.11.6,<2.12.0", + "dill >=0.2", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.8,<3.9.0a0", + "tomli >=1.1.0", + "tomlkit >=0.10.1", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "143bf870193b4e3ca32ae13b2048fa85", + "name": "pylint", + "sha256": "d4d252dc39af5838ce16b4630fe868cc37c5872d0d75b71fd8f87720ab2fd788", + "size": 651879, + "subdir": "linux-64", + "timestamp": 1659110476157, + "version": "2.14.5" + }, + "pylint-2.14.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.11.6,<2.12.0", + "dill >=0.2", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.9,<3.10.0a0", + "tomli >=1.1.0", + "tomlkit >=0.10.1", + "typing_extensions >=3.10" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "675e90a220c596a06d94ff3e3c3b6806", + "name": "pylint", + "sha256": "3110aa3c8138c5b7a20c19509159e341a6cd3a252d2993fcc66f699be493b003", + "size": 651126, + "subdir": "linux-64", + "timestamp": 1659110390260, + "version": "2.14.5" + }, + "pylint-2.16.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.14.2,<=2.16.0", + "colorama >=0.4.5", + "dill >=0.2", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.10,<3.11.0a0", + "tomli >=1.1.0", + "tomlkit >=0.10.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "b7e305a8ffeb1dc9c6ab9a84b3c4041e", + "name": "pylint", + "sha256": "94322c6b15f0e527daab6ad08eb09ede7be0147cef42c346a0c0d72794828049", + "size": 756276, + "subdir": "linux-64", + "timestamp": 1676919962719, + "version": "2.16.2" + }, + "pylint-2.16.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.14.2,<=2.16.0", + "colorama >=0.4.5", + "dill >=0.3.6", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.11,<3.12.0a0", + "tomlkit >=0.10.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "bb400616073862d19e30b5f092811313", + "name": "pylint", + "sha256": "c7aa44bd2389e35ec22a759136b8ef84ea2df957b25ebaa5dfceefab995ae25e", + "size": 932953, + "subdir": "linux-64", + "timestamp": 1676921014466, + "version": "2.16.2" + }, + "pylint-2.16.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.14.2,<=2.16.0", + "colorama >=0.4.5", + "dill >=0.2", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.7,<3.8.0a0", + "tomli >=1.1.0", + "tomlkit >=0.10.1", + "typing_extensions >=3.10.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "13e7f5f82fd45f2f08833f95ba9f5915", + "name": "pylint", + "sha256": "64255ae28952cdd4e62a8bc3d01e8e32677cabefdeb4e105f01bf1ebd10963fa", + "size": 740977, + "subdir": "linux-64", + "timestamp": 1676919929651, + "version": "2.16.2" + }, + "pylint-2.16.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.14.2,<=2.16.0", + "colorama >=0.4.5", + "dill >=0.2", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.8,<3.9.0a0", + "tomli >=1.1.0", + "tomlkit >=0.10.1", + "typing_extensions >=3.10.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "db6c9b0139fcf52e1af50c01f3055771", + "name": "pylint", + "sha256": "a8848af9be1ed09df4aa833cd5505b4822d1ef1fe2fae5a8c5e72bd286313218", + "size": 743784, + "subdir": "linux-64", + "timestamp": 1676919995638, + "version": "2.16.2" + }, + "pylint-2.16.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.14.2,<=2.16.0", + "colorama >=0.4.5", + "dill >=0.2", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.8", + "platformdirs >=2.2.0", + "python >=3.9,<3.10.0a0", + "tomli >=1.1.0", + "tomlkit >=0.10.1", + "typing_extensions >=3.10.0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "78a79f34bcfc786a05e058b5d18d2cc4", + "name": "pylint", + "sha256": "b86a59d23cdc9bfbf7fccd8d19d150914d603a536f704b88e3effd54507e0f59", + "size": 744058, + "subdir": "linux-64", + "timestamp": 1676920028979, + "version": "2.16.2" + }, + "pylint-2.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.0.0", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL", + "md5": "cc926eca20a633c4324c510018983c5f", + "name": "pylint", + "sha256": "1a9a22b979dc24a90f01e2bee03d714c9d3a7a200c04adaca5c819019ef1edf3", + "size": 794967, + "subdir": "linux-64", + "timestamp": 1543609106263, + "version": "2.2.2" + }, + "pylint-2.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.0.0", + "isort >=4.2.5", + "mccabe", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL", + "md5": "a39e21d6e8be613e2e5fba33f90463de", + "name": "pylint", + "sha256": "9d3bd2014558054d234b4c8f26c689b77a33f2c4841504a18a0108a699ddaf70", + "size": 790810, + "subdir": "linux-64", + "timestamp": 1543609087125, + "version": "2.2.2" + }, + "pylint-2.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL", + "md5": "cc55dd289a89004ea248e57e443104d8", + "name": "pylint", + "sha256": "a6c29910cd35ee915d7364a1aa71dfc45187715232c38a7a420c54a948b3f68d", + "size": 816557, + "subdir": "linux-64", + "timestamp": 1552332067523, + "version": "2.3.1" + }, + "pylint-2.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.2.0", + "isort >=4.2.5", + "mccabe", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL", + "md5": "07078662eed63245b73c2feb6902214e", + "name": "pylint", + "sha256": "df8d865afcedcf1fde77719dfa3ee466188ca2e6acd3f8199a856e86d405310d", + "size": 812948, + "subdir": "linux-64", + "timestamp": 1552331990252, + "version": "2.3.1" + }, + "pylint-2.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.3.0,<2.4", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2", + "md5": "1b274e90f86c00de44ef765d60cb97ee", + "name": "pylint", + "sha256": "a8ca55951cc1738f3f64ef513d7caf447561ac3ae1254e6738daa00d99f38bc3", + "size": 431322, + "subdir": "linux-64", + "timestamp": 1569854754247, + "version": "2.4.2" + }, + "pylint-2.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.3.0,<2.4", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL 2", + "md5": "d94f64f2d77b6edd92e9150d9e86a461", + "name": "pylint", + "sha256": "ed3d63886ba8fe3f652a61de07ad324c2df92c84c775d633831141280e450f62", + "size": 429252, + "subdir": "linux-64", + "timestamp": 1569854782103, + "version": "2.4.2" + }, + "pylint-2.4.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.3.0,<2.4", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2", + "md5": "00216fb388c2ef5adaee6bc150ef6804", + "name": "pylint", + "sha256": "dadfcba4ffe4803d82e413e0fadc558e3153db656c56d20086ac97baf9b5439f", + "size": 432060, + "subdir": "linux-64", + "timestamp": 1571761133950, + "version": "2.4.3" + }, + "pylint-2.4.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.3.0,<2.4", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL 2", + "md5": "a51ff34c3a9c56dd5ab34cac07f1672c", + "name": "pylint", + "sha256": "42bc6a00f20d3d4c1204da1a0c8ec566d086a69bfd53cf4c7173b12b1c374f2a", + "size": 429311, + "subdir": "linux-64", + "timestamp": 1571761125724, + "version": "2.4.3" + }, + "pylint-2.4.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.3.0,<2.4", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2", + "md5": "6fb69e0254e05853a8985acce9f55a8d", + "name": "pylint", + "sha256": "c87700a2c28da74fd1f4d2fe6ee0a43570de0caea1284f0029391b5431c7afa8", + "size": 431971, + "subdir": "linux-64", + "timestamp": 1573939943157, + "version": "2.4.4" + }, + "pylint-2.4.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.3.0,<2.4", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL 2", + "md5": "1c632e12b239a69f073606d69961fb6b", + "name": "pylint", + "sha256": "5db077eba37dd6b806c7002b720d43c5f4f262ca08268f1062556fd45989d247", + "size": 429668, + "subdir": "linux-64", + "timestamp": 1573939898588, + "version": "2.4.4" + }, + "pylint-2.4.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "astroid >=2.3.0,<2.4", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL 2", + "md5": "0412f2fc809386dd3e62d61de7c9c74d", + "name": "pylint", + "sha256": "a85e2edc9b746d144ffff08213eadc0a92d71603f3eec254027f750d48753a42", + "size": 426771, + "subdir": "linux-64", + "timestamp": 1574169745448, + "version": "2.4.4" + }, + "pylint-2.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL 2", + "md5": "8e90cf640f5f47799bc60525046cdd29", + "name": "pylint", + "sha256": "0aead3c4ecdfb4d6b0e8e0c4f7e817c3bfef4cc8dcb524d99a691be97acea6e5", + "size": 451370, + "subdir": "linux-64", + "timestamp": 1588207489708, + "version": "2.5.0" + }, + "pylint-2.5.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "7b4dd987683a154fbfc7bfa54a4e2c09", + "name": "pylint", + "sha256": "1905d1e4cf28d5a276b92ab232619ea6e2e2d25a300675356fd5ca9c80baaf6f", + "size": 457352, + "subdir": "linux-64", + "timestamp": 1588624073175, + "version": "2.5.0" + }, + "pylint-2.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL 2", + "md5": "ba389bea3b918474aee9a9f3cad1a842", + "name": "pylint", + "sha256": "4593d22cd0050f0d274ba2327c77e6ae4a0c89b9d0991f0764bd96778afc02cd", + "size": 453327, + "subdir": "linux-64", + "timestamp": 1588207475925, + "version": "2.5.0" + }, + "pylint-2.5.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "e120f40f360d0fc96580ad04391c5d2b", + "name": "pylint", + "sha256": "2db26dcd0578ed68cee8e1a2f107c9e1e5c48007a128befd303fc24af1d4de46", + "size": 453564, + "subdir": "linux-64", + "timestamp": 1588624065036, + "version": "2.5.0" + }, + "pylint-2.5.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL 2", + "md5": "c015a06b2fd9dabbceccc23d3220dec0", + "name": "pylint", + "sha256": "d8e65633a350334fefc88b624f029f85908ed52600f1b7da3e3ceaa2b756ee12", + "size": 455114, + "subdir": "linux-64", + "timestamp": 1588207489491, + "version": "2.5.0" + }, + "pylint-2.5.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "a5d0dcb9dc274cf5a40121ff7d66deb1", + "name": "pylint", + "sha256": "d2974ed2510048407b133296598922f5851745b732e534ababdfab9dd12a4f6b", + "size": 451772, + "subdir": "linux-64", + "timestamp": 1588624042023, + "version": "2.5.0" + }, + "pylint-2.5.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "6d46ec4eb760a250c6d3464684dcc918", + "name": "pylint", + "sha256": "b657e8f9a174e73dfca841fd78156f3806d92446d17273b6920af1132d575ae3", + "size": 456895, + "subdir": "linux-64", + "timestamp": 1590117501935, + "version": "2.5.2" + }, + "pylint-2.5.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "8adb6d22da1d92c19dc27009b0d696fd", + "name": "pylint", + "sha256": "a0c38739814420fff5edd443e90e77a23dd03aa65fcf0fdf5055601ef03d2912", + "size": 449186, + "subdir": "linux-64", + "timestamp": 1590117496267, + "version": "2.5.2" + }, + "pylint-2.5.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "440fa025a670d24ffb7b38bd9199508b", + "name": "pylint", + "sha256": "3a6671d92ea86b30f1c26a1caa8ec957f6841fbbbf7984cf36e55f772419d844", + "size": 451221, + "subdir": "linux-64", + "timestamp": 1590117502799, + "version": "2.5.2" + }, + "pylint-2.5.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "78e5b9f0fcd0dc8b1e1db44cbf2f6164", + "name": "pylint", + "sha256": "7ed8ae777ef52dad25269f6341b890926f4d49beb63d625d78a93a10bbe0c5fb", + "size": 453885, + "subdir": "linux-64", + "timestamp": 1592496051938, + "version": "2.5.3" + }, + "pylint-2.5.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "d69732b3d9c261658d15682699df26bb", + "name": "pylint", + "sha256": "f8d83b0b160b925effae49709fa7dc9b371aa9af6a77b884e4380f90b2ce830b", + "size": 451164, + "subdir": "linux-64", + "timestamp": 1592496075781, + "version": "2.5.3" + }, + "pylint-2.5.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<2.5", + "isort >=4.2.5,<5", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "42069d733431c2f976c37372de1a3b6b", + "name": "pylint", + "sha256": "f6557cec356c2eb73c7314ce16e65abf30467a68f1745d6db92b8cc34475d7ed", + "size": 457384, + "subdir": "linux-64", + "timestamp": 1592496086842, + "version": "2.5.3" + }, + "pylint-2.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "25a9f209cc4787ea047dafb96c697e69", + "name": "pylint", + "sha256": "ea1f9228d0339fef9ab733de46df831107cf86dd4d6e70fcbdfb89df163cf45c", + "size": 453419, + "subdir": "linux-64", + "timestamp": 1598624067394, + "version": "2.6.0" + }, + "pylint-2.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "b96fb54849c245436246d2d69e623566", + "name": "pylint", + "sha256": "483efe5ad822f1d74f597b8c5591c1be35f8627c96412658011bba0055e99e93", + "size": 446569, + "subdir": "linux-64", + "timestamp": 1598624077301, + "version": "2.6.0" + }, + "pylint-2.6.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "85974ae8bf04be6f6b952864b592d354", + "name": "pylint", + "sha256": "993c0f3dbd0c8552966c814f66680b1d3d6ec0a7088dd890444b60b306305c81", + "size": 447675, + "subdir": "linux-64", + "timestamp": 1598624027873, + "version": "2.6.0" + }, + "pylint-2.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "cff4a4555052805bab9d094f9d9bdd8d", + "name": "pylint", + "sha256": "4c2573823ee7dc0868c2c1450d0ff0ecc11ab941132ceb91d1c58f480e2ba759", + "size": 451320, + "subdir": "linux-64", + "timestamp": 1607716724505, + "version": "2.6.0" + }, + "pylint-2.7.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "61ee0175968fbbf3e665906e481fe8a4", + "name": "pylint", + "sha256": "1bdb9adaa4c417ca62c9b9a2a607c6b327eb6e32966eacaa7681ce4622447ca8", + "size": 460452, + "subdir": "linux-64", + "timestamp": 1614008056902, + "version": "2.7.0" + }, + "pylint-2.7.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "0e7ed87fbc6f5adf785792069c150da7", + "name": "pylint", + "sha256": "9b664a094efdbad9c73d8e61cc01370ec5ca0a63e3008098c33d34c5aa019764", + "size": 458107, + "subdir": "linux-64", + "timestamp": 1614008048588, + "version": "2.7.0" + }, + "pylint-2.7.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "a56edba4ce4797d8980cf12dfcbbe165", + "name": "pylint", + "sha256": "07b4c6df5179dabd8d6a61c2529a81d66296b6edb0696ef6543be6650f1932e6", + "size": 461354, + "subdir": "linux-64", + "timestamp": 1614008038301, + "version": "2.7.0" + }, + "pylint-2.7.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "fc3ba7f6a158a09089d519a4e99cdc7a", + "name": "pylint", + "sha256": "48263f4a99902218f8dba75fa72b223f26a6b5e5f6b6e30324311e4aed52b2f4", + "size": 464172, + "subdir": "linux-64", + "timestamp": 1614008042816, + "version": "2.7.0" + }, + "pylint-2.7.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "0e5f8d09a157e45cc8fc3235c917dd2a", + "name": "pylint", + "sha256": "f070f910eb69f9105e3d0390081915c2273598ee19d2d82a515aef13eca11647", + "size": 462472, + "subdir": "linux-64", + "timestamp": 1614365900828, + "version": "2.7.1" + }, + "pylint-2.7.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "4caa763ed0e8bfc1105213b9fd21cb21", + "name": "pylint", + "sha256": "7ae91371aef8c7f035cb160b67d0017ec446b4f4a856ee21c5ec43bc8b611dd6", + "size": 458102, + "subdir": "linux-64", + "timestamp": 1614365898788, + "version": "2.7.1" + }, + "pylint-2.7.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "c5d273523cda02331c815741c1a61ea0", + "name": "pylint", + "sha256": "456a4c3e21eac075088ef03c47e3fc3c1867c2c447cdcec8474fe4a9c06fc66b", + "size": 466056, + "subdir": "linux-64", + "timestamp": 1614365403469, + "version": "2.7.1" + }, + "pylint-2.7.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "9a8ee15130cfcc5ad03045bd48c88d86", + "name": "pylint", + "sha256": "02e4b833bd9826a42ebd04d43186c4052055a97fb440e497a336be8d06f274d1", + "size": 460442, + "subdir": "linux-64", + "timestamp": 1614365887942, + "version": "2.7.1" + }, + "pylint-2.7.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "68c230148d8b2c95a5c72734ff9bb07d", + "name": "pylint", + "sha256": "c3af76361b88d1b6decb1a856a93b22500c937f870326d2f94c623f8e906b306", + "size": 466336, + "subdir": "linux-64", + "timestamp": 1614971293918, + "version": "2.7.2" + }, + "pylint-2.7.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "1a29b9a0412d27462ee59d75431e0248", + "name": "pylint", + "sha256": "668955d2b44e31ff3dee9d1880f48fbb64216d3fc37a16982212a25f0ea847b6", + "size": 458358, + "subdir": "linux-64", + "timestamp": 1614971274936, + "version": "2.7.2" + }, + "pylint-2.7.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "f993fa1ad237d859fd30bfba555b5414", + "name": "pylint", + "sha256": "aab8d5434b6f4a53acea3db611a949695e2016c86943628746c3dbe562b4d779", + "size": 460269, + "subdir": "linux-64", + "timestamp": 1614971281878, + "version": "2.7.2" + }, + "pylint-2.7.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "6970432b6fde35b48cbe5ca3db4e8688", + "name": "pylint", + "sha256": "adea34858c5e1c696c286785768cc5dbf391432275b7a40876d592bbfb988f57", + "size": 464312, + "subdir": "linux-64", + "timestamp": 1614969898406, + "version": "2.7.2" + }, + "pylint-2.7.4-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "5760e5028f2a783b7254c3b2e38ea985", + "name": "pylint", + "sha256": "30c551981569fb0bb534fa4de6a6800f785017fef81f3a987875f1e7b3b43fc4", + "size": 470324, + "subdir": "linux-64", + "timestamp": 1617133411642, + "version": "2.7.4" + }, + "pylint-2.7.4-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "fc9edef9ef9f70dd97ec22c849b53c68", + "name": "pylint", + "sha256": "f6831efcbb73bd7bfca3f10b8e8294874a5fe39e3e52c15680ec8d5e8aacf6e5", + "size": 462340, + "subdir": "linux-64", + "timestamp": 1617135870198, + "version": "2.7.4" + }, + "pylint-2.7.4-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "f20a596c4ffa546340097dbf0a3d88f0", + "name": "pylint", + "sha256": "01973b7151b568e7108f9fc20b013f6a1531b4cfbfc3470e8755c0fc39c1e2db", + "size": 464869, + "subdir": "linux-64", + "timestamp": 1617135871877, + "version": "2.7.4" + }, + "pylint-2.7.4-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.4.0,<=2.5", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-only", + "md5": "8b1bd37375477d4ccb6e23276ebba83c", + "name": "pylint", + "sha256": "c856ad7d72db0a748cbfd9fe8672fc8c3dcd25f9c8e7b5349a011b22c87daf6c", + "size": 468679, + "subdir": "linux-64", + "timestamp": 1617135873586, + "version": "2.7.4" + }, + "pylint-2.8.3-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.5.8,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "ff4dea46845e97e3349ca5e9a7843309", + "name": "pylint", + "sha256": "bb39b74c7930486c64c42183a544892dc3ff85850ba6ed1735d433ae5ade712c", + "size": 479907, + "subdir": "linux-64", + "timestamp": 1623400266820, + "version": "2.8.3" + }, + "pylint-2.8.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.5.8,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "fbadc67f319b4e90868a971e5c568b66", + "name": "pylint", + "sha256": "0ee5a6677b894190a6f406558124d90e60f858bf481aec5315c0ea8ade20cee2", + "size": 480346, + "subdir": "linux-64", + "timestamp": 1623399641046, + "version": "2.8.3" + }, + "pylint-2.8.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.5.8,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "2f1e21f0267ba48c81a98a9b540f8aba", + "name": "pylint", + "sha256": "e2f4dde198e05d00c41b52af992d49bae7d06339eadcef7efb7552deec045141", + "size": 478055, + "subdir": "linux-64", + "timestamp": 1623394621614, + "version": "2.8.3" + }, + "pylint-2.8.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.5.8,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "acd509b6078a1dab0a29c0748699abe6", + "name": "pylint", + "sha256": "740b980a5e81ae97c834e0a0e70a4b48fe9d71881de85e9635a6d9713a782a32", + "size": 477860, + "subdir": "linux-64", + "timestamp": 1623400260239, + "version": "2.8.3" + }, + "pylint-2.9.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.2,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "73159bf8372a00255d82e492f2e52c4b", + "name": "pylint", + "sha256": "3d6b4c0aecbb0c40a699f934eef8048bb6ee87193e2d4cf779c889f2b82007f0", + "size": 495455, + "subdir": "linux-64", + "timestamp": 1625158570052, + "version": "2.9.1" + }, + "pylint-2.9.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.2,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "5dbcac393c886bca7613c590d631b9c6", + "name": "pylint", + "sha256": "c42bbf9c7649ba81a80705693779b0410431f35f3006d1ef0b54855fb33359d5", + "size": 496995, + "subdir": "linux-64", + "timestamp": 1625158854767, + "version": "2.9.1" + }, + "pylint-2.9.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.2,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "8ded90daf0c9552f9d110daa64f0e0cd", + "name": "pylint", + "sha256": "b9e21b37a360629b566cc06f35e981b45b7a985e8d83939c66ae0ad16663f09c", + "size": 500288, + "subdir": "linux-64", + "timestamp": 1625158856007, + "version": "2.9.1" + }, + "pylint-2.9.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.2,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "bf7725db007f578bd9954e34d64a8a1f", + "name": "pylint", + "sha256": "ca58219a3098f5655e84392a861855855eefd1f1681966ea43d349b107648ee6", + "size": 499219, + "subdir": "linux-64", + "timestamp": 1625152351393, + "version": "2.9.1" + }, + "pylint-2.9.3-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.2,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "ef62fe9f359bd962d553cd42c6e9d07a", + "name": "pylint", + "sha256": "c610e0ed2058dd72895af2c4f8c230c667c43c8fb0e1ad50d0cf27fbbd44a3ab", + "size": 501190, + "subdir": "linux-64", + "timestamp": 1625467737702, + "version": "2.9.3" + }, + "pylint-2.9.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.2,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "428f3f59447f5b51792fd10e7e46f716", + "name": "pylint", + "sha256": "674325ddf693dc29c864426ea46976c3636edc98455b895cbb61b6e451d484e6", + "size": 498246, + "subdir": "linux-64", + "timestamp": 1625467017728, + "version": "2.9.3" + }, + "pylint-2.9.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.2,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "de7da90976a9bbdd77972b7b52236a8f", + "name": "pylint", + "sha256": "8c55e142c13b24b9f1b7d7b4002fb7099d7e78f642d8b6088b1f1459da9ecfa6", + "size": 499956, + "subdir": "linux-64", + "timestamp": 1625461048864, + "version": "2.9.3" + }, + "pylint-2.9.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.2,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "a8c52ee6622430e03968b7caf540589d", + "name": "pylint", + "sha256": "605aa980aa043346309b3cdf0757c790b921cff18602b7d6c747e0a517ff65e5", + "size": 495484, + "subdir": "linux-64", + "timestamp": 1625467035211, + "version": "2.9.3" + }, + "pylint-2.9.5-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.5,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "2404961c51754f5fe6833bb06abbcb02", + "name": "pylint", + "sha256": "7cf3ea6b33cac096a51de725e34a04f6bf01bfb22a804ae9cc7fb5df3400cdd8", + "size": 500121, + "subdir": "linux-64", + "timestamp": 1627038111569, + "version": "2.9.5" + }, + "pylint-2.9.5-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.5,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "5c5765c7e9f09bb438d98b40cb305b25", + "name": "pylint", + "sha256": "ec4cc8f9ea6cf765666728a9f8865399244a02cc31ee6b43c12df637d9bb902c", + "size": 501968, + "subdir": "linux-64", + "timestamp": 1627038009067, + "version": "2.9.5" + }, + "pylint-2.9.5-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.5,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "d2eff409a277c3761e7e124512d40373", + "name": "pylint", + "sha256": "38699d1f9f6cf1ad6e84d948e5d946e4a1d08ebea274ee446e9cb14dda8a1ac5", + "size": 498772, + "subdir": "linux-64", + "timestamp": 1627030626845, + "version": "2.9.5" + }, + "pylint-2.9.5-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.5,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "222b09922620a94decb1be7204c8330b", + "name": "pylint", + "sha256": "dc8c3da21864ad16990a7541cf01db4c903be3e36dbed70ee3afc0820473ffe4", + "size": 503512, + "subdir": "linux-64", + "timestamp": 1627038111350, + "version": "2.9.5" + }, + "pylint-2.9.6-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.5,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.10,<3.11.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "e8b531fa821d2b70c21971591599c610", + "name": "pylint", + "sha256": "de98221c4f160a5cb19eaf9a4a24353eb41f54b8910416e99e0c1c5a6be000e7", + "size": 509428, + "subdir": "linux-64", + "timestamp": 1640812743292, + "version": "2.9.6" + }, + "pylint-2.9.6-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.5,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.6,<3.7.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "4eb223adb80eb8729868a691b0d263af", + "name": "pylint", + "sha256": "0b47cb570dd7e681ad659fdfde49b8990d45bc5c8b0c54f8d513febf61c346f7", + "size": 505343, + "subdir": "linux-64", + "timestamp": 1627536556719, + "version": "2.9.6" + }, + "pylint-2.9.6-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.5,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.7,<3.8.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "e20ceab5d95f4086ad52d53999d077bd", + "name": "pylint", + "sha256": "e166fa2f59ad9b73dea992a8cfb2f9c335cdc3b05d11d2a82264bf932792b3eb", + "size": 496950, + "subdir": "linux-64", + "timestamp": 1627529101991, + "version": "2.9.6" + }, + "pylint-2.9.6-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.5,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.8,<3.9.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "c800f701d6cd463eb862baaac3df8c36", + "name": "pylint", + "sha256": "c4320f8fea11e89465d333e39eca871baa01ac883307e4723d670ec90b7f2fa5", + "size": 499937, + "subdir": "linux-64", + "timestamp": 1627536822859, + "version": "2.9.6" + }, + "pylint-2.9.6-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "astroid >=2.6.5,<=2.7", + "isort >=4.2.5,<6", + "mccabe >=0.6,<0.7", + "python >=3.9,<3.10.0a0", + "toml >=0.7.1" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "65d0b8ce85cc59d03ede45e15c9e718e", + "name": "pylint", + "sha256": "122520e903c2191cb0333eb10ba02e29f83f8579f0b835cf091ce8503e40c2bd", + "size": 503240, + "subdir": "linux-64", + "timestamp": 1627536836894, + "version": "2.9.6" + }, + "pylint-venv-2.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d12aea82db60215aef2808ad3f6d77bc", + "name": "pylint-venv", + "sha256": "6bc996243458bf7371d6c893d2486311272c5eb427ae4def3c47d07fe0aea910", + "size": 11134, + "subdir": "linux-64", + "timestamp": 1673990208620, + "version": "2.3.0" + }, + "pylint-venv-2.3.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e3418adf2269b7c86f891060706a417e", + "name": "pylint-venv", + "sha256": "a6e378bdbdb2709817871047a398a0c0e96be09c7f386c631026341939dc1bcc", + "size": 11692, + "subdir": "linux-64", + "timestamp": 1677706419368, + "version": "2.3.0" + }, + "pylint-venv-2.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c9c4786cb6251da14e91aef700277966", + "name": "pylint-venv", + "sha256": "ad1864383d320ec4e6faf7a0dc076860783f8a66a9ef1a8156c114a547440bbd", + "size": 11078, + "subdir": "linux-64", + "timestamp": 1673990235298, + "version": "2.3.0" + }, + "pylint-venv-2.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0cda4de5093201186956063ca543b8d0", + "name": "pylint-venv", + "sha256": "1b810cec0557f3523480293a74e5b8329a599dc14e68bda2f99a3a5ffaa616b0", + "size": 11048, + "subdir": "linux-64", + "timestamp": 1673990182936, + "version": "2.3.0" + }, + "pylint-venv-2.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "998a9e9cdac5cd2060a75bf4b6073244", + "name": "pylint-venv", + "sha256": "6d2cd7abe9166f997e099295645708a350151f7800fdb11de6caefd16dc717e2", + "size": 11041, + "subdir": "linux-64", + "timestamp": 1673990157512, + "version": "2.3.0" + }, + "pymc-2.3.7-py27h2761b3c_0.conda": { + "build": "py27h2761b3c_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "matplotlib", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "AFL-3.0", + "license_family": "OTHER", + "md5": "4d3478d9eba33d4bea89114899333049", + "name": "pymc", + "sha256": "1a6b14f70e69aab469b883ef0647913fd48047d56fd0087bdb168a06892fe9c5", + "size": 834327, + "subdir": "linux-64", + "timestamp": 1555694755698, + "version": "2.3.7" + }, + "pymc-2.3.7-py36h2761b3c_0.conda": { + "build": "py36h2761b3c_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "matplotlib", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "AFL-3.0", + "license_family": "OTHER", + "md5": "8ef30894c6175bb075776e577d169bad", + "name": "pymc", + "sha256": "ee1df1a000f5eb9cc3da486cb09886f3862b76ec2bdc98db387bc6dfb2ed5f6f", + "size": 842047, + "subdir": "linux-64", + "timestamp": 1555694756724, + "version": "2.3.7" + }, + "pymc-2.3.8-py36h13841d7_0.conda": { + "build": "py36h13841d7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "numpy-devel 1.14.*", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "AFL-3.0", + "license_family": "OTHER", + "md5": "08eaf13c295a9f1b917e5ea0e90594d8", + "name": "pymc", + "sha256": "e104f13eff2e0562f9f511d9917dcba31a5ea1f5bec3321bc0a2792b4bf5a754", + "size": 837030, + "subdir": "linux-64", + "timestamp": 1598647536727, + "version": "2.3.8" + }, + "pymc-2.3.8-py37h13841d7_0.conda": { + "build": "py37h13841d7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "numpy-devel 1.14.*", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "AFL-3.0", + "license_family": "OTHER", + "md5": "9d9290732f62730899fad6d8b7246fb2", + "name": "pymc", + "sha256": "d32a16634d4ad4c6eca0d78bb39d091ff0c55205cf4643dbba9b851a71bf8339", + "size": 836315, + "subdir": "linux-64", + "timestamp": 1598647470643, + "version": "2.3.8" + }, + "pymc-2.3.8-py38h13841d7_0.conda": { + "build": "py38h13841d7_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "numpy-devel 1.14.*", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "AFL-3.0", + "license_family": "OTHER", + "md5": "09aa0bd53f348d401a739c4e109da16a", + "name": "pymc", + "sha256": "bf957a86de255bfa6578b1bda87a36ee1c0d70f6ceff26c546c8ccfc836e47b0", + "size": 848174, + "subdir": "linux-64", + "timestamp": 1598647514572, + "version": "2.3.8" + }, + "pymc3-3.11.4-py310hd09550d_0.conda": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "arviz >=0.11.0", + "cachetools >=4.2.1", + "dill", + "fastprogress >=0.2.0", + "gxx_linux-64 7.5.0.*", + "mkl-service", + "numpy >=1.15.0", + "pandas >=0.24.0", + "patsy >=0.5.1", + "python >=3.10,<3.11.0a0", + "scipy >=1.2.0", + "semver", + "theano-pymc 1.1.2", + "typing-extensions >=3.7.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1d167f6f6143b0f801a2892d50c3917f", + "name": "pymc3", + "sha256": "a791cfb9c5c6967041f3a3820bddad64b9fdb3b9412cefd96a1cb43a0ba56309", + "size": 1040748, + "subdir": "linux-64", + "timestamp": 1642513113095, + "version": "3.11.4" + }, + "pymc3-3.11.4-py37hb070fc8_0.conda": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "arviz >=0.11.0", + "cachetools >=4.2.1", + "dill", + "fastprogress >=0.2.0", + "numpy >=1.16.6,<2.0a0", + "pandas >=0.24.0", + "patsy >=0.5.1", + "python >=3.7,<3.8.0a0", + "scipy >=1.2.0", + "semver >=2.13.0", + "theano-pymc 1.1.2", + "typing-extensions >=3.7.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "52e6d1c79e2de2a561a03fb5613b15f3", + "name": "pymc3", + "sha256": "c76571172c484ac5fdfdb126bc95a990698ada71d74d48c0c25d06a27af22222", + "size": 1032528, + "subdir": "linux-64", + "timestamp": 1634803319665, + "version": "3.11.4" + }, + "pymc3-3.11.4-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "arviz >=0.11.0", + "cachetools >=4.2.1", + "dill", + "fastprogress >=0.2.0", + "numpy >=1.16.6,<2.0a0", + "pandas >=0.24.0", + "patsy >=0.5.1", + "python >=3.8,<3.9.0a0", + "scipy >=1.2.0", + "semver >=2.13.0", + "theano-pymc 1.1.2", + "typing-extensions >=3.7.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "84ae6dd21a22d7ef4c9cdd18ad200f36", + "name": "pymc3", + "sha256": "6fa3c83e0e3526995e5eaaa442503114ce5166e99cd96a2312572d36bab04434", + "size": 1038753, + "subdir": "linux-64", + "timestamp": 1634803317783, + "version": "3.11.4" + }, + "pymc3-3.11.4-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "arviz >=0.11.0", + "cachetools >=4.2.1", + "dill", + "fastprogress >=0.2.0", + "numpy >=1.16.6,<2.0a0", + "pandas >=0.24.0", + "patsy >=0.5.1", + "python >=3.9,<3.10.0a0", + "scipy >=1.2.0", + "semver >=2.13.0", + "theano-pymc 1.1.2", + "typing-extensions >=3.7.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "836989bc2537caf291b3759b8a5eba67", + "name": "pymc3", + "sha256": "b08a33feb9f0fe4f6f8629fa77959260b9afb2132dfeba6fab964b95fa119a92", + "size": 1046396, + "subdir": "linux-64", + "timestamp": 1634803314585, + "version": "3.11.4" + }, + "pymc3-3.2-py27he296173_0.conda": { + "build": "py27he296173_0", + "build_number": 0, + "depends": [ + "enum34 >=1.1.6", + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.11.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=0.9", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "96fd4a582e2c07493df2c4a6d3e0b70a", + "name": "pymc3", + "sha256": "1b454fc40aff050501baeabc2f7d516795378704599bea7a5f52cc8e1224968a", + "size": 1260922, + "subdir": "linux-64", + "timestamp": 1508438259846, + "version": "3.2" + }, + "pymc3-3.2-py35h9f7775c_0.conda": { + "build": "py35h9f7775c_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.11.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.5,<3.6.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=0.9", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0096accbbcb9ea27fa3f77464c17a784", + "name": "pymc3", + "sha256": "3e4c672c0975ee99dcdd0b19b771f0aa88d0d1496db2daef9a0f00850caf3c6f", + "size": 1284287, + "subdir": "linux-64", + "timestamp": 1508438277064, + "version": "3.2" + }, + "pymc3-3.2-py36h89408ba_0.conda": { + "build": "py36h89408ba_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.11.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=0.9", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8aa924d8c9136fbb7d1386c77427824a", + "name": "pymc3", + "sha256": "3eabec7ce767bf38158017d3d2f90d8ccadf7cda24a4907ad1fd7f01fa892379", + "size": 1277710, + "subdir": "linux-64", + "timestamp": 1508438278033, + "version": "3.2" + }, + "pymc3-3.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34 >=1.1.6", + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.11.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4c2b194cc4d62d647fc44bb9430b138e", + "name": "pymc3", + "sha256": "ec11de55316482bf91efed8bb6c437e151d4ff12923ab222df3b0beaa80a67a1", + "size": 1276457, + "subdir": "linux-64", + "timestamp": 1519192499856, + "version": "3.3" + }, + "pymc3-3.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.11.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.5,<3.6.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "49923c6f1a4f1a0ccc92af6caf1d27d2", + "name": "pymc3", + "sha256": "04dde0e55b664da1b9e143fb4845b835c8fcbb2a9e4af704400c4c1aa9e11b5b", + "size": 1298470, + "subdir": "linux-64", + "timestamp": 1519192519543, + "version": "3.3" + }, + "pymc3-3.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.11.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "993cb0996a515a53b939cb43ac24c76d", + "name": "pymc3", + "sha256": "7f79f5606d554a833e18280e8a24ba15cf135d175a378dcd9d437803848b8c51", + "size": 1292769, + "subdir": "linux-64", + "timestamp": 1519192492466, + "version": "3.3" + }, + "pymc3-3.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34 >=1.1.6", + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c1e6c2ee2fcc5ee1130425b19ccb4d54", + "name": "pymc3", + "sha256": "a1e13cb0054aaa796a65eb9b3ebb4037310f4ff89f1c16ab09f80016051cb589", + "size": 1318048, + "subdir": "linux-64", + "timestamp": 1526497921544, + "version": "3.4.1" + }, + "pymc3-3.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.5,<3.6.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2b6ad79a3fa85513b54179375894f678", + "name": "pymc3", + "sha256": "1394a54594f0baae73bb91dc1fe2d102ce51e67896fc729e5e92ecae57e36df3", + "size": 1335478, + "subdir": "linux-64", + "timestamp": 1526498029382, + "version": "3.4.1" + }, + "pymc3-3.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0113346b506668bc9dfdd0391a7ca2da", + "name": "pymc3", + "sha256": "0f6887e483f8b3b03647fa37bcf2374b07668da3fe9baaabcee023339b616754", + "size": 1336671, + "subdir": "linux-64", + "timestamp": 1526497928572, + "version": "3.4.1" + }, + "pymc3-3.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.7,<3.8.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d72d4c48e1ef9dcc755d63e526c21f49", + "name": "pymc3", + "sha256": "9f11e47f29f23d5468b0726d2514e25b98bcdc9b527afb8b879434b65f82be8f", + "size": 1328585, + "subdir": "linux-64", + "timestamp": 1530917837616, + "version": "3.4.1" + }, + "pymc3-3.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34 >=1.1.6", + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "56d109cfcaccc56a4f11e5a2e4df1bea", + "name": "pymc3", + "sha256": "b54609376e039043aa7d4f615f17f524ceb4cb1cedcb164b269475c4cac81225", + "size": 1346025, + "subdir": "linux-64", + "timestamp": 1534608317482, + "version": "3.5" + }, + "pymc3-3.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.5,<3.6.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0fccaf001aa1e6293a6cbb9c60617811", + "name": "pymc3", + "sha256": "4cfb62f515cd208424d2c3cabd5499a0c46a849c3585bee8c1f9ec327ae11278", + "size": 1363081, + "subdir": "linux-64", + "timestamp": 1534609769572, + "version": "3.5" + }, + "pymc3-3.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4bc1413c11abbebf9e6ad9e482fcf275", + "name": "pymc3", + "sha256": "805bf8ecf7d2a70bc1cad90eb716949fdee75b191c83ab4e78ed0fa655c47db7", + "size": 1357759, + "subdir": "linux-64", + "timestamp": 1534608315055, + "version": "3.5" + }, + "pymc3-3.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib >=0.9", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.7,<3.8.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ea6c844e83582f05df303ac08d4f5ec6", + "name": "pymc3", + "sha256": "d9b7048050d0bb82f3e87dbec220b136115431c8da2a7e64afa7c807ba15b9c2", + "size": 1356421, + "subdir": "linux-64", + "timestamp": 1534608479790, + "version": "3.5" + }, + "pymc3-3.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34 >=1.1.6", + "h5py >=2.7.0", + "joblib <0.13.0", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dc27272fcfb2d902caf7771c2aba546e", + "name": "pymc3", + "sha256": "b4314d36e6c6339384ef2314294b51a0c3c5a810934c2a1112c9f55114c5f7a2", + "size": 1003910, + "subdir": "linux-64", + "timestamp": 1546016640783, + "version": "3.6" + }, + "pymc3-3.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib <0.13.0", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9205ddb661fc9837d3d5ee2970e1452c", + "name": "pymc3", + "sha256": "659d24f701392a2dd74aaf39cfe9de692509623596b93106b7a1eafe651dd4f9", + "size": 1014775, + "subdir": "linux-64", + "timestamp": 1546016703527, + "version": "3.6" + }, + "pymc3-3.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "h5py >=2.7.0", + "joblib <0.13.0", + "matplotlib >=1.5.0", + "numpy >=1.13.0", + "pandas >=0.18.0", + "patsy >=0.4.0", + "python >=3.7,<3.8.0a0", + "scipy >=0.12.0", + "six >=1.10.0", + "theano >=1.0.0", + "tqdm >=4.8.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d10609e94d0532ab4f69c87ac822cb55", + "name": "pymc3", + "sha256": "c90b45f399de1f6334547e8b3c6d62001ce3b6e8ab66b4ee0fb013dea42751af", + "size": 1006533, + "subdir": "linux-64", + "timestamp": 1546016622738, + "version": "3.6" + }, + "pymongo-3.10.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "3d29ba989b99cad1f3915cd67d8c8d93", + "name": "pymongo", + "sha256": "deb71a56ebbd072ce9c181a07754d4d13865bcc18a25f20fd6b5d192e9b3194b", + "size": 1114385, + "subdir": "linux-64", + "timestamp": 1597255092548, + "version": "3.10.1" + }, + "pymongo-3.10.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "646539bcffd5995950e80d3e9547e4dc", + "name": "pymongo", + "sha256": "c113e80121ff1a711f1486557897c1c3b4cc778ecc5dff5bc1fd362043fece7f", + "size": 1116510, + "subdir": "linux-64", + "timestamp": 1597250905511, + "version": "3.10.1" + }, + "pymongo-3.10.1-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "fd53f4840a23ccc4c8bb8f7e4c197217", + "name": "pymongo", + "sha256": "99a1dab3731a78c869429f6a31c2ff3f8ccc242e6a22b455b589247c97a5728d", + "size": 1123280, + "subdir": "linux-64", + "timestamp": 1597255383877, + "version": "3.10.1" + }, + "pymongo-3.11.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "1611aa0c081686a6eeed89f4865ced92", + "name": "pymongo", + "sha256": "4050cc535e3690577c28bf2f3a1481f22ab3a9b1553f3f17e54bc37901602e17", + "size": 1204237, + "subdir": "linux-64", + "timestamp": 1597245245922, + "version": "3.11.0" + }, + "pymongo-3.11.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "e9d5fe3213ec2fb531fb3a3ff2cf5a21", + "name": "pymongo", + "sha256": "18858851723ad238ba35b2ca30c599144eaea446bef976a4ef10c98b830e993c", + "size": 1205833, + "subdir": "linux-64", + "timestamp": 1597245192376, + "version": "3.11.0" + }, + "pymongo-3.11.0-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "79427f34765fda2adcb52f870bc010e3", + "name": "pymongo", + "sha256": "db207e25ac11604b06c6ca2586b22a702a14aed80d39605a940d07bd6677adbd", + "size": 1212655, + "subdir": "linux-64", + "timestamp": 1597245229836, + "version": "3.11.0" + }, + "pymongo-3.11.1-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "bb0b171bae5cb1b02302f99b2ad17c4e", + "name": "pymongo", + "sha256": "f5f178dc0c947059e3620ef7e4eb7b71caa93721deee06d58ef9719afc2c6962", + "size": 1228345, + "subdir": "linux-64", + "timestamp": 1606344910198, + "version": "3.11.1" + }, + "pymongo-3.11.1-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "7c8e0e461b6d81bda11f38a0b8e38c93", + "name": "pymongo", + "sha256": "4f7f24c94396d597f049f4d9836bb687833a70918157c9fd59f459bd7c2a4104", + "size": 1225445, + "subdir": "linux-64", + "timestamp": 1606344868991, + "version": "3.11.1" + }, + "pymongo-3.11.1-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "de45ba349e464b45c780eeeb959f0a97", + "name": "pymongo", + "sha256": "61a427180fb19d06ae0a272efe7e2ed7565ac954e853a8b43b4d2f0ff6d24bd4", + "size": 1240971, + "subdir": "linux-64", + "timestamp": 1606344908183, + "version": "3.11.1" + }, + "pymongo-3.11.1-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "86b1d751efc9eb21d663fe2690b809df", + "name": "pymongo", + "sha256": "6fe3d10fb868d8f69eafdecce3b5baef03ed91f43fc90f433f597f3cb002c9f6", + "size": 1229155, + "subdir": "linux-64", + "timestamp": 1606344914953, + "version": "3.11.1" + }, + "pymongo-3.11.2-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "ce11c941dbe77749ef73e958dceb3fe1", + "name": "pymongo", + "sha256": "14fe7d4301aca271eb3494e1eab49e20878bd8051b7d2486de3ea0aa6c68644b", + "size": 1233794, + "subdir": "linux-64", + "timestamp": 1607369066477, + "version": "3.11.2" + }, + "pymongo-3.11.2-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "f9e871d837c0ad050a64c86992baa77d", + "name": "pymongo", + "sha256": "7d353035faa8448da917518c21094963021bfffee4a24dc4c8d62ccc3f7e9426", + "size": 1233289, + "subdir": "linux-64", + "timestamp": 1607369060844, + "version": "3.11.2" + }, + "pymongo-3.11.2-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "a93201d34c13f19508d423dc1141bee5", + "name": "pymongo", + "sha256": "94aca68bfe8715c6428cb1ea294721191eee08fcb925547492c8090f169db746", + "size": 1233927, + "subdir": "linux-64", + "timestamp": 1607369069440, + "version": "3.11.2" + }, + "pymongo-3.11.2-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "37d39d6457d4884e1024532857e7455b", + "name": "pymongo", + "sha256": "13866013191480e5331f1be8baaf7ae57985ad049110bfe5ab2188d2db909e7a", + "size": 1235408, + "subdir": "linux-64", + "timestamp": 1607369108523, + "version": "3.11.2" + }, + "pymongo-3.11.3-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "6c8f0158a20f03bd0698c9ad4674378e", + "name": "pymongo", + "sha256": "57f4e7655c32734ca588b5a2300e8bfae5241e309c9361fc9cb622916c3a6835", + "size": 1227929, + "subdir": "linux-64", + "timestamp": 1613849355565, + "version": "3.11.3" + }, + "pymongo-3.11.3-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "235b1026059f5af485fe19e6618278e7", + "name": "pymongo", + "sha256": "297af6f85e21f1f4aa14a9f0a75416131826252f749f0c3a37a0d03b8ccf2273", + "size": 1237063, + "subdir": "linux-64", + "timestamp": 1613849839138, + "version": "3.11.3" + }, + "pymongo-3.11.3-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "42c7416aa99e01fec7ff8cfc481f726a", + "name": "pymongo", + "sha256": "a4c60ed40d0ea6ffdf6e504639edd4a39e43cce8eaa3d6257c1aaafbf79973b6", + "size": 1245169, + "subdir": "linux-64", + "timestamp": 1613849037215, + "version": "3.11.3" + }, + "pymongo-3.11.3-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "2a3755da9776a195bf8aa9983f24028a", + "name": "pymongo", + "sha256": "9e909709a30e5c1ddf3e4a72ff3c46e3507446be84320cc5f19be82667a8615f", + "size": 1231974, + "subdir": "linux-64", + "timestamp": 1613849834675, + "version": "3.11.3" + }, + "pymongo-3.11.4-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "4276609e40abf23269afc9db8dd5dd79", + "name": "pymongo", + "sha256": "41d788176ded7bb17a05e1323125d384246b72b026f53edc370ce0fab9f25aa5", + "size": 1224912, + "subdir": "linux-64", + "timestamp": 1620214177014, + "version": "3.11.4" + }, + "pymongo-3.11.4-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "bb717cb639044463a2d019c4f523ed2a", + "name": "pymongo", + "sha256": "a89cbc1f302e5204744a1b038754e9203ec3e2b8f00d94cc77657dfebb69fbae", + "size": 1224623, + "subdir": "linux-64", + "timestamp": 1620214172294, + "version": "3.11.4" + }, + "pymongo-3.11.4-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "c62b541bfcb7cc48df12c2803802a47f", + "name": "pymongo", + "sha256": "fb8386c9d07030525178ddd3853309b615e41865cabe1c8c9437753224fd52e5", + "size": 1232996, + "subdir": "linux-64", + "timestamp": 1620214172090, + "version": "3.11.4" + }, + "pymongo-3.11.4-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "d77a2acf98b7025e5f6276c691d57236", + "name": "pymongo", + "sha256": "53a991f742cb04708c8cfe0c12944b32d09818a34ff7701f08477df146bf6e6a", + "size": 1235988, + "subdir": "linux-64", + "timestamp": 1620213543617, + "version": "3.11.4" + }, + "pymongo-3.12.0-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1db2958ea711d20daedc4b12925549ba", + "name": "pymongo", + "sha256": "90eaa9bae113f9bb2f8727c7d6e052d85d74a3a8dd5f852176a6755b2d43a862", + "size": 1592238, + "subdir": "linux-64", + "timestamp": 1640793474521, + "version": "3.12.0" + }, + "pymongo-3.12.0-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "52f0863f1fc1e57e9c89f70dc7580851", + "name": "pymongo", + "sha256": "ef173f9befaa15d75888305b29a03cb77beef09f14fe8e60e18b419a92321727", + "size": 1474404, + "subdir": "linux-64", + "timestamp": 1676860947762, + "version": "3.12.0" + }, + "pymongo-3.12.0-py36h295c915_0.conda": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "6c54fc6860979b1f9fea111ba25cf416", + "name": "pymongo", + "sha256": "89cc62870e8a33101fe166e269763d7a392c80b6f77d57a9d35784abb1a496a5", + "size": 1287121, + "subdir": "linux-64", + "timestamp": 1626240803207, + "version": "3.12.0" + }, + "pymongo-3.12.0-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "87af7b60199468aec950f76216e7bf56", + "name": "pymongo", + "sha256": "86d90b67a88a4345ebe6480fe34e4a27adc4f82d19f50a9b7ee8792cdebaecbd", + "size": 1296492, + "subdir": "linux-64", + "timestamp": 1626234191346, + "version": "3.12.0" + }, + "pymongo-3.12.0-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "c6c976216a8ae803216e8872b79d29a8", + "name": "pymongo", + "sha256": "df1e6e66e6702bfbe9d0d523801207905113ab84045e93f2ab606f43250b564d", + "size": 1292743, + "subdir": "linux-64", + "timestamp": 1626241240358, + "version": "3.12.0" + }, + "pymongo-3.12.0-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c50a2626c71f7e5801a59339a09899f4", + "name": "pymongo", + "sha256": "ea9829c75e05bd907a8965e4fd65130f3ab0c170108fff343794a4170f52dd8d", + "size": 1291498, + "subdir": "linux-64", + "timestamp": 1626309445823, + "version": "3.12.0" + }, + "pymongo-3.7.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "dd932058d79f5893afff8b41d8ac0b65", + "name": "pymongo", + "sha256": "ec10116dbf0bea7a963eb0af6b6668717dbbf58239231f7a8737cd26cb27972b", + "size": 944989, + "subdir": "linux-64", + "timestamp": 1530900432983, + "version": "3.7.0" + }, + "pymongo-3.7.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "a98ebb78eb8412b9618aefd2348f2bec", + "name": "pymongo", + "sha256": "7dcc07b6c6beb8f3e8c7d209a50fa4cc65e0fe6d88fb2f55f06838dc0b0fae35", + "size": 948438, + "subdir": "linux-64", + "timestamp": 1530900366926, + "version": "3.7.0" + }, + "pymongo-3.7.0-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "b9a1fa552f72356833bcfcdb52a79a77", + "name": "pymongo", + "sha256": "ec11e1cbaf7caa3d3a710300b546ae306d860b5898692489aab7e727d2984be5", + "size": 948026, + "subdir": "linux-64", + "timestamp": 1530900297485, + "version": "3.7.0" + }, + "pymongo-3.7.1-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "d79151c9f0431a99d7f132a9c29ed409", + "name": "pymongo", + "sha256": "d4692e05ad5fc55cb661c19825acf27ca318a98427b1ba075ca686243d7ffbf4", + "size": 951797, + "subdir": "linux-64", + "timestamp": 1535891529137, + "version": "3.7.1" + }, + "pymongo-3.7.1-py35he6710b0_0.conda": { + "build": "py35he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "9a7b29c59ad420e5766e6f0ec5f53bec", + "name": "pymongo", + "sha256": "61e633d7ad9441e2ca09282b50ac4bbabc20c593ae1d77fa4e9f8de58b79f608", + "size": 953646, + "subdir": "linux-64", + "timestamp": 1535891525536, + "version": "3.7.1" + }, + "pymongo-3.7.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "730b6717c4f6c7320ae4080836ec4117", + "name": "pymongo", + "sha256": "0be3702bb449f28ce640745becf83497a9bb91f5e8ab638610f3d81c9a5f28f0", + "size": 950530, + "subdir": "linux-64", + "timestamp": 1535891476344, + "version": "3.7.1" + }, + "pymongo-3.7.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "8baf0383e2f09bed2b848f7626769dc9", + "name": "pymongo", + "sha256": "d7b4838b5860cc193aa8705f15c4a97150b2481f720680ce92823a9457c28024", + "size": 950099, + "subdir": "linux-64", + "timestamp": 1535891518427, + "version": "3.7.1" + }, + "pymongo-3.7.2-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "bc4fafb6c5c5e80c0f907f57f1b09566", + "name": "pymongo", + "sha256": "784d29fa924ef73818f2bb99a6eaa7dceb274483b0f75d52115a1ff527ad2014", + "size": 946721, + "subdir": "linux-64", + "timestamp": 1539729988104, + "version": "3.7.2" + }, + "pymongo-3.7.2-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "17c50733b6f3ba8e00c603767305a1b8", + "name": "pymongo", + "sha256": "187a2cf004d9b7069106ff003c1be969ce748de845ea42478df316611117e589", + "size": 955692, + "subdir": "linux-64", + "timestamp": 1539729997572, + "version": "3.7.2" + }, + "pymongo-3.7.2-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "1644efd81733a7be1a601d14302d43c1", + "name": "pymongo", + "sha256": "e2da3f045e6dbca334593399fd30ba7d9b2a22ea928fbd38c0286cf7db3898af", + "size": 950595, + "subdir": "linux-64", + "timestamp": 1539729997652, + "version": "3.7.2" + }, + "pymongo-3.8.0-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "08e4db4433029c2fdda5cacbdbd13796", + "name": "pymongo", + "sha256": "c1dc954e020dc41f5b62defd72c740190e020a1dbf445ca461bc12533baf00cb", + "size": 980657, + "subdir": "linux-64", + "timestamp": 1559921910825, + "version": "3.8.0" + }, + "pymongo-3.8.0-py27he6710b0_1.conda": { + "build": "py27he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "7055216d67ab7408d36ab44fe509e0b5", + "name": "pymongo", + "sha256": "2f9f1618a763c2098b7d9e01fc8bbc3f8adb17045423468d34bb31a4b9707a2a", + "size": 981129, + "subdir": "linux-64", + "timestamp": 1561563817442, + "version": "3.8.0" + }, + "pymongo-3.8.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "2d87bd89d8c983d4845e3e5a3c70b9f9", + "name": "pymongo", + "sha256": "78d0d6194ad7bbefd8abda4598771b441809a0895f0d9e0aa5686793bea1232f", + "size": 984028, + "subdir": "linux-64", + "timestamp": 1559921922455, + "version": "3.8.0" + }, + "pymongo-3.8.0-py36he6710b0_1.conda": { + "build": "py36he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "99fa51897ac931c9147fb85481ca207c", + "name": "pymongo", + "sha256": "491fdf74cca14abc760af219823d564705164bb670f8906e3aa342a9556898d5", + "size": 984550, + "subdir": "linux-64", + "timestamp": 1561563826449, + "version": "3.8.0" + }, + "pymongo-3.8.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "767c63b33fcbf970a3c8258bf103a13b", + "name": "pymongo", + "sha256": "0d48327dd26689abea85968db892d0eac6208a76f111efcc3f3643335cb93cd8", + "size": 983665, + "subdir": "linux-64", + "timestamp": 1559921890468, + "version": "3.8.0" + }, + "pymongo-3.8.0-py37he6710b0_1.conda": { + "build": "py37he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "17154663605fdc09c5498d835c4b639f", + "name": "pymongo", + "sha256": "e2603063c37b527500a344fb25d66080be8973f229618f1e492872fdf44ae657", + "size": 983799, + "subdir": "linux-64", + "timestamp": 1561563823452, + "version": "3.8.0" + }, + "pymongo-3.9.0-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "f0f05839fa99043e6557813d5e7b5158", + "name": "pymongo", + "sha256": "8f8f1550b8ab456105e160a763d4ff65dcaff308685b43a38661f057137a4947", + "size": 1110278, + "subdir": "linux-64", + "timestamp": 1569345366070, + "version": "3.9.0" + }, + "pymongo-3.9.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "dc00fc8dba9d5435eecdbc4057b341bc", + "name": "pymongo", + "sha256": "d17549d20ddf099a7d20a20896ddff32c48a7a6ab00113730425b3846e0dce27", + "size": 1116124, + "subdir": "linux-64", + "timestamp": 1569345402666, + "version": "3.9.0" + }, + "pymongo-3.9.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "0d664c2ff1c1f0e8b7cc37ffe8770fd0", + "name": "pymongo", + "sha256": "c7689649acce129b1925aff4f298d316531442b2530456d799876dd631fc0967", + "size": 1115832, + "subdir": "linux-64", + "timestamp": 1569345394987, + "version": "3.9.0" + }, + "pymongo-3.9.0-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "7c09d07b6d16719c53ededb0ef74c342", + "name": "pymongo", + "sha256": "bf1db043c416bf98fb4f3fd2df5a9113be8c2b1116859bc799d278bda9796cbd", + "size": 1125335, + "subdir": "linux-64", + "timestamp": 1573670045504, + "version": "3.9.0" + }, + "pympler-0.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "5552613021911546e7ab7682792ea672", + "name": "pympler", + "sha256": "bb5eeeb1adb6ad6039c96157e74905ed7f3e821b00d780d1a8f8567b7029c8b9", + "size": 244477, + "subdir": "linux-64", + "timestamp": 1530917880276, + "version": "0.5" + }, + "pympler-0.5-py27h8aa4898_0.conda": { + "build": "py27h8aa4898_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "72074432c7a879eac39ae2a8b3567b7e", + "name": "pympler", + "sha256": "8a2d426edc35c09f645395615435a40faa5666bd7d032e425abc26daba9e2364", + "size": 247195, + "subdir": "linux-64", + "timestamp": 1507743720855, + "version": "0.5" + }, + "pympler-0.5-py35hc09b5c8_0.conda": { + "build": "py35hc09b5c8_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "b1b27ae5fbde591eb31509faa95f58a4", + "name": "pympler", + "sha256": "b7ab08e5e8c8ca78008fd396dacefb3cbcc58bdf6ea86a77892554d54da6517d", + "size": 247699, + "subdir": "linux-64", + "timestamp": 1507743728477, + "version": "0.5" + }, + "pympler-0.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "c183729fb7975546dee41554d90d8e07", + "name": "pympler", + "sha256": "c65e12b622070fda269f1cf95648073b75f38c74f7cf1999417a0db4a77b3885", + "size": 248208, + "subdir": "linux-64", + "timestamp": 1530917937882, + "version": "0.5" + }, + "pympler-0.5-py36h6b12e4d_0.conda": { + "build": "py36h6b12e4d_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "dadf5bf12f9a4329aa38545d338145c1", + "name": "pympler", + "sha256": "02bfa6fcaaf312eb2868c4a6136636a0a497cd7c2f3a8743d7a999e84a5a4139", + "size": 245094, + "subdir": "linux-64", + "timestamp": 1507743724941, + "version": "0.5" + }, + "pympler-0.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "3a91a9d2b0158692c646fc2dc4c5ac95", + "name": "pympler", + "sha256": "f8c99f70bede7770ce7dfa152e06806dedf9e0a93b220df3d76cb4edec1d0ea9", + "size": 248399, + "subdir": "linux-64", + "timestamp": 1530917997694, + "version": "0.5" + }, + "pymssql-2.1.4-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "freetds >=1.0.91,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "4702bc09d848def020ed606528cfa46e", + "name": "pymssql", + "sha256": "75cb0adab9f23f3d333ad2b8e6d8845485ebc378032a2e92c3b3cea0caaeaac9", + "size": 227363, + "subdir": "linux-64", + "timestamp": 1535519287587, + "version": "2.1.4" + }, + "pymssql-2.1.4-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "2dda5d387124fa01fb42f5497a0c4c75", + "name": "pymssql", + "sha256": "3ae5e46b582d8c22c816a8e21681b8be8d863a724a404178421e7363436ed001", + "size": 809700, + "subdir": "linux-64", + "timestamp": 1640793515944, + "version": "2.1.4" + }, + "pymssql-2.1.4-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "freetds >=1.0.91,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "14214244409b87e56cc235d52a446ee4", + "name": "pymssql", + "sha256": "d79cf4bff04a931dd6c759c58fb1713f35efa27cf280ec80badca7677ff63e13", + "size": 229325, + "subdir": "linux-64", + "timestamp": 1535519338919, + "version": "2.1.4" + }, + "pymssql-2.1.4-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "freetds >=1.0.91,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "8943c4bfd5b1fb504a675edc78f95005", + "name": "pymssql", + "sha256": "026de750cf3d769fe41a8cbaa34c26eb65d0f9699d5fe4d6495848b939e565fc", + "size": 232192, + "subdir": "linux-64", + "timestamp": 1535519235632, + "version": "2.1.4" + }, + "pymssql-2.1.4-py36h7f8727e_0.conda": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "freetds >=1.3,<2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "b4d6296dae321be4cb5172fb2490e85b", + "name": "pymssql", + "sha256": "2f764e41c7afea8b9ba7242b84e52615920a38c284de6dc6b60687a62987162a", + "size": 213325, + "subdir": "linux-64", + "timestamp": 1632894728011, + "version": "2.1.4" + }, + "pymssql-2.1.4-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "freetds >=1.0.91,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "c5765c4f0e2c4cc5d15544a436186aeb", + "name": "pymssql", + "sha256": "5931d6ee4bde6525105e94fff39fa50e2e66eda0970f71dc1afcff3af085d763", + "size": 232025, + "subdir": "linux-64", + "timestamp": 1535519339861, + "version": "2.1.4" + }, + "pymssql-2.1.4-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "freetds >=1.3,<2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "6ec88403e285d968462d035254b92d0c", + "name": "pymssql", + "sha256": "93872c41114fcf4f9d5756e0109d1fc5d704b47fb754c42c272b057c0a20f3c1", + "size": 213174, + "subdir": "linux-64", + "timestamp": 1632894694278, + "version": "2.1.4" + }, + "pymssql-2.1.4-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "freetds >=1.0.97,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "b7c6366f199c439ab99121c97ae18357", + "name": "pymssql", + "sha256": "7a003f816f46cd1f5a1a1babc1127af2e5b3ee67ce5a180073da7a0af036748c", + "size": 257066, + "subdir": "linux-64", + "timestamp": 1592330817634, + "version": "2.1.4" + }, + "pymssql-2.1.4-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "freetds >=1.3,<2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "12b1ed69063ed4164e9b8bfded654536", + "name": "pymssql", + "sha256": "9fe23269e1662e816994a9ccace14b249576732185987289dfc4bf6188ea7007", + "size": 225393, + "subdir": "linux-64", + "timestamp": 1632894699185, + "version": "2.1.4" + }, + "pymssql-2.1.4-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "freetds >=1.3,<2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "b46e2de0a4e66b4f0e3cd4eaf3eabb2f", + "name": "pymssql", + "sha256": "99c3974ce63958ca2a9c7ef7abafba3ff03b9cc3e16ace94b15615478f59c29f", + "size": 227079, + "subdir": "linux-64", + "timestamp": 1632893961373, + "version": "2.1.4" + }, + "pymssql-2.1.5-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "freetds >=1.0.97,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "5ecda7e51d3467c08bdcea50e03cce34", + "name": "pymssql", + "sha256": "c21d8ad3ac87679ff3f376814f166c8a422ce139744f2cb1c0c61f82bd04c77e", + "size": 217001, + "subdir": "linux-64", + "timestamp": 1602602757831, + "version": "2.1.5" + }, + "pymssql-2.1.5-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "freetds >=1.0.97,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "55477f1141bd5c61f620fdbf124b4e95", + "name": "pymssql", + "sha256": "a7508d6c348acde584dcb253794200ff8748a26f89f61a5f43aecb1095e2b5ff", + "size": 216859, + "subdir": "linux-64", + "timestamp": 1602604632556, + "version": "2.1.5" + }, + "pymssql-2.1.5-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "freetds >=1.0.97,<2.0a0", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "2ee6a4942d1a0ab4951436ad023de255", + "name": "pymssql", + "sha256": "7242aa82bcbe23e7dc0d0be6f71a2eae55496803a0b4ae1eef6ef6752e73a234", + "size": 228874, + "subdir": "linux-64", + "timestamp": 1602602726091, + "version": "2.1.5" + }, + "pymssql-2.2.3-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "3aad9e7dec97faa23a446eb41c267662", + "name": "pymssql", + "sha256": "852ca76c09ac22061093fd23369dce6304bc3dfa71b9bc1b2a0fa923286ddca8", + "size": 232365, + "subdir": "linux-64", + "timestamp": 1676860982198, + "version": "2.2.3" + }, + "pymssql-2.2.3-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "83e02d3c8bfeed5ddbd5241781427ae0", + "name": "pymssql", + "sha256": "3272ae8669d10259f954e7f8ac6081fd7af9e06a9f8ef5d94fa11dd0fc90e01c", + "size": 224441, + "subdir": "linux-64", + "timestamp": 1642624768445, + "version": "2.2.3" + }, + "pymssql-2.2.3-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "797f5a4536a9253947d32d6c80af03b4", + "name": "pymssql", + "sha256": "8d063ec15b0cdf09e3b49b06d3ef1cec2ccafa05746d75aeaafa82152ba1cbf1", + "size": 239600, + "subdir": "linux-64", + "timestamp": 1642624770107, + "version": "2.2.3" + }, + "pymssql-2.2.3-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL", + "license_family": "LGPL", + "md5": "53936439592c4f4eef996134553a05b3", + "name": "pymssql", + "sha256": "1e244ef32c9b75ef1b635a2b828cb23309e5a9d44b0cc51218432a9d8f019943", + "size": 240196, + "subdir": "linux-64", + "timestamp": 1642624766267, + "version": "2.2.3" + }, + "pymssql-2.2.5-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "a4af6bb326e824e2638d35848d70a96a", + "name": "pymssql", + "sha256": "8a2db3cf8b64545ecf2ed074da1ee6dace9740955bc57a135b1422f051ce3c10", + "size": 1033632, + "subdir": "linux-64", + "timestamp": 1663178763835, + "version": "2.2.5" + }, + "pymssql-2.2.5-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "b3fbf410a30afa45ab95fdd575c05486", + "name": "pymssql", + "sha256": "b7ffaf741bcbdad3fe69961867bb008c306c51ca829260439548be4662e8cafc", + "size": 231206, + "subdir": "linux-64", + "timestamp": 1679337497397, + "version": "2.2.5" + }, + "pymssql-2.2.5-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "846e3029f316e67284d89027116bffd4", + "name": "pymssql", + "sha256": "47cd733870be9f0baabefb178be8c15c43c73d709cd9e9e8891f71b78a42405f", + "size": 230494, + "subdir": "linux-64", + "timestamp": 1663178705608, + "version": "2.2.5" + }, + "pymssql-2.2.5-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "f7992976e7e012aa0f6458ec993f40b1", + "name": "pymssql", + "sha256": "0b4b4f63dc2c227d34f48fdf720ad0994068f6f31ddfe85fa37c98aa072c9278", + "size": 245136, + "subdir": "linux-64", + "timestamp": 1663178619527, + "version": "2.2.5" + }, + "pymssql-2.2.5-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "freetds >=1.3.3,<2.0a0", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1-only", + "license_family": "LGPL", + "md5": "cd0b0d10818b758eb56f1676898980b6", + "name": "pymssql", + "sha256": "8190e712bde4d54d313078efa0822f4eab2cc1a184daff81cb4d551f4e02f335", + "size": 240752, + "subdir": "linux-64", + "timestamp": 1663178661586, + "version": "2.2.5" + }, + "pymysql-0.10.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dad2a4792c452bd501a50f5983f77229", + "name": "pymysql", + "sha256": "f0f6d8e3eeed297a857b2d1229e1014af60f747c642f94b8f157456979d62c83", + "size": 83532, + "subdir": "linux-64", + "timestamp": 1601588912775, + "version": "0.10.1" + }, + "pymysql-0.10.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b1ae76fd2b23db8bc6c7b05b63b6321", + "name": "pymysql", + "sha256": "cdc198b940c94bc9b471c03d1bb73ecb1b9d37f4d83de6a221c5d5380d879278", + "size": 84684, + "subdir": "linux-64", + "timestamp": 1601588882616, + "version": "0.10.1" + }, + "pymysql-0.10.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e088ad462b388a2f07d1ee4858c87705", + "name": "pymysql", + "sha256": "44a813e38f82dbb14267c3614f4d34d431d6232c84c8d8e77bda60e565457366", + "size": 85251, + "subdir": "linux-64", + "timestamp": 1601588874444, + "version": "0.10.1" + }, + "pymysql-0.7.11-py27ha7233d9_0.conda": { + "build": "py27ha7233d9_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f4925e298b11e6bbf1b654c746110196", + "name": "pymysql", + "sha256": "e68ff614ff17e1c8f3e26ed15b91acf0e002434a4766bd9dcfb83f48580f1fa6", + "size": 133435, + "subdir": "linux-64", + "timestamp": 1507787387247, + "version": "0.7.11" + }, + "pymysql-0.7.11-py35h9a3333c_0.conda": { + "build": "py35h9a3333c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "b21456456b0e8c8bb49c9b1b2fa332a3", + "name": "pymysql", + "sha256": "11f456195598b3955f64db0b08fee69305ab067539b3558d530be5ee71658cbc", + "size": 134120, + "subdir": "linux-64", + "timestamp": 1507787391378, + "version": "0.7.11" + }, + "pymysql-0.7.11-py36he04d08f_0.conda": { + "build": "py36he04d08f_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9e2abaac3ed06467d39a563f2cc4048b", + "name": "pymysql", + "sha256": "da5bf498e99e2f174f880ad87091156ee3a62ca4103c3837bf4f0a5c09e5fa0b", + "size": 134884, + "subdir": "linux-64", + "timestamp": 1507787392933, + "version": "0.7.11" + }, + "pymysql-0.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "10214ff2834a0d0c5f3ebc5f58196702", + "name": "pymysql", + "sha256": "ccc62d92dc2606c6d128f675ed64eaa27b9521fa8128b1663b66e584cca7fbb8", + "size": 135281, + "subdir": "linux-64", + "timestamp": 1519674086704, + "version": "0.8.0" + }, + "pymysql-0.8.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "510b606fca0363e3790ae10226c2c384", + "name": "pymysql", + "sha256": "01ab19aebcaca87ca181c48d43ad14d3a0eda50dea841a2ca66999902a1089f2", + "size": 136037, + "subdir": "linux-64", + "timestamp": 1519674124830, + "version": "0.8.0" + }, + "pymysql-0.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49a6131afcea4433a1044043a59b9d80", + "name": "pymysql", + "sha256": "1b2b9e8926c5d07541ec0ccd6a96eeaf7a6d9755174744f6e06c0094dd6d57e4", + "size": 134960, + "subdir": "linux-64", + "timestamp": 1519674221314, + "version": "0.8.0" + }, + "pymysql-0.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "75ac922dc0c28afee548c71cf5c33406", + "name": "pymysql", + "sha256": "f95468deda00b596174ba41598803168ca0ce7a4f11b52ae1457a570749ceb40", + "size": 137222, + "subdir": "linux-64", + "timestamp": 1526497804582, + "version": "0.8.1" + }, + "pymysql-0.8.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f50ea31f06db3d26cec66f03ed138b68", + "name": "pymysql", + "sha256": "4e0a88f306ef843f4fa35037e720594e49ae87408cc01c8c1a03ee0e3934490e", + "size": 139583, + "subdir": "linux-64", + "timestamp": 1526498615704, + "version": "0.8.1" + }, + "pymysql-0.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e50ad5815e3e77b256a52c1c2ce60fb", + "name": "pymysql", + "sha256": "263371940f30137476065d97e773104774bbdc9e89ffe5e3c648e10b676ea417", + "size": 138334, + "subdir": "linux-64", + "timestamp": 1526497767336, + "version": "0.8.1" + }, + "pymysql-0.9.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d94117f3778561c9691f6b2965c0db08", + "name": "pymysql", + "sha256": "08eb4c9684bcd5f2afef9124ba62655417bb9af8fed662fe40f0f905032c8fe5", + "size": 143481, + "subdir": "linux-64", + "timestamp": 1530556629619, + "version": "0.9.1" + }, + "pymysql-0.9.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2232b72479140700d9a4c64411ffabfb", + "name": "pymysql", + "sha256": "bad8931e61f3fdf01e1fbf513b9b50d0d39e0de28ae0bda2ca1bad4545f0ef6f", + "size": 144600, + "subdir": "linux-64", + "timestamp": 1530556646574, + "version": "0.9.1" + }, + "pymysql-0.9.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02fd33a57028d4eea14dee38a05e21d4", + "name": "pymysql", + "sha256": "0820e48515fafcc991bdd2cf2e99a6195c2882a9657dbed001baef9d3dcf0863", + "size": 144814, + "subdir": "linux-64", + "timestamp": 1530556658873, + "version": "0.9.1" + }, + "pymysql-0.9.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "342434c3db48f5053bec30d7742c7a94", + "name": "pymysql", + "sha256": "249b19d4a63054bf7e9c8188fc3b48f5aed02ebfff79928adc3fafa6004b2cab", + "size": 144673, + "subdir": "linux-64", + "timestamp": 1530918060354, + "version": "0.9.1" + }, + "pymysql-0.9.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e79587a9727a8e7ceb6d67eb424d61a1", + "name": "pymysql", + "sha256": "baf58a5b6f23b5510ca20ffdf11d06e8e0c786afa2994176a7606de0f4c979b0", + "size": 84166, + "subdir": "linux-64", + "timestamp": 1532541532285, + "version": "0.9.2" + }, + "pymysql-0.9.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9825ef11d6f4849f149d4d77722cff89", + "name": "pymysql", + "sha256": "e76835c5c2e45c6616782518d4515993328f6a3193316b67bdf4678523fb5582", + "size": 86819, + "subdir": "linux-64", + "timestamp": 1532541570744, + "version": "0.9.2" + }, + "pymysql-0.9.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0ceff897e8ab29249effe3ebba151ac", + "name": "pymysql", + "sha256": "d9b4f4f7dbed7556f4a7cc8acc08ed190939a27aac34c0e95771bee071e05927", + "size": 85426, + "subdir": "linux-64", + "timestamp": 1532541455716, + "version": "0.9.2" + }, + "pymysql-0.9.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9db2bc3ae97e1677404a7673d25902e1", + "name": "pymysql", + "sha256": "22f4c1f739ce0085bc39426c96feea370c1bcf4cd7cddde060493ed682002322", + "size": 85516, + "subdir": "linux-64", + "timestamp": 1532541551289, + "version": "0.9.2" + }, + "pymysql-0.9.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "171c40514a72829198b4195299251663", + "name": "pymysql", + "sha256": "84e48a05596b6ae17fee2260e2520987a597733bb86ad377c1aca1bc71d77e5c", + "size": 85859, + "subdir": "linux-64", + "timestamp": 1574169767301, + "version": "0.9.2" + }, + "pymysql-0.9.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6aeab70914818d4ddf293e39a51d6930", + "name": "pymysql", + "sha256": "c1e430aba3902f565a8cf01a9b9d3cd3a9fa35881b7538dc923c7620597a9002", + "size": 86360, + "subdir": "linux-64", + "timestamp": 1547248960631, + "version": "0.9.3" + }, + "pymysql-0.9.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1da10e46a899b75f361eb7343ceb6ade", + "name": "pymysql", + "sha256": "cc1242ed202ccdbfbaf14aa4390ee05868fef4edf23987c3efe088e23aae3289", + "size": 86227, + "subdir": "linux-64", + "timestamp": 1547249018189, + "version": "0.9.3" + }, + "pymysql-0.9.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "804e59353940048377cc91d6c9269286", + "name": "pymysql", + "sha256": "9be4a81cc208e57ab7f6b10fa2405ea7fc865059995ccaf841d04a01104888d3", + "size": 85010, + "subdir": "linux-64", + "timestamp": 1547249015300, + "version": "0.9.3" + }, + "pymysql-1.0.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "59208c1a624795a730e4f7e442eed85c", + "name": "pymysql", + "sha256": "96272438e883715b57827851fe7217fd09cfc606ff2fcea126855b9b82a47c65", + "size": 78398, + "subdir": "linux-64", + "timestamp": 1610132832731, + "version": "1.0.1" + }, + "pymysql-1.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2bc70171e057d3ce5413cf210e304833", + "name": "pymysql", + "sha256": "f3306622db497c8041dbfeed3aa55768f5491c9b155e4aad1bbe01fe0fc62125", + "size": 78383, + "subdir": "linux-64", + "timestamp": 1610133121297, + "version": "1.0.1" + }, + "pymysql-1.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2471e0b080179235870b2499648d2de", + "name": "pymysql", + "sha256": "d8030e37ef360b156347218885f5e84f12c604f8c44e4b7f7f5185543c746312", + "size": 78352, + "subdir": "linux-64", + "timestamp": 1610133123949, + "version": "1.0.1" + }, + "pymysql-1.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9eb3c8f5cc599197c7f06de698736ce2", + "name": "pymysql", + "sha256": "ca6fce2469567f4a171629a6c02246e95ed65ed18168625615d533bf2c014b6d", + "size": 78385, + "subdir": "linux-64", + "timestamp": 1610133131750, + "version": "1.0.1" + }, + "pymysql-1.0.2-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b05d054dd8c8f2b9cadb5fe9e10c70fd", + "name": "pymysql", + "sha256": "bea1da16c73669bdfa200717af441968370482a38b99f40c6fd9a6fc9e99944e", + "size": 78745, + "subdir": "linux-64", + "timestamp": 1640812762632, + "version": "1.0.2" + }, + "pymysql-1.0.2-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "794211bebcb13b3a5f2a2adb678bc399", + "name": "pymysql", + "sha256": "276e210ee084a88e45d2cc305ae4e48ef79912ae84685ee3df097e0d38ef0f0e", + "size": 100135, + "subdir": "linux-64", + "timestamp": 1676845352174, + "version": "1.0.2" + }, + "pymysql-1.0.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6ccd0977fe15995c19f1f9e948e58d2", + "name": "pymysql", + "sha256": "f5f8ebf10a1ea338bbb98839377c9bf3e1ad258655056da7f5ed68f4490f92a3", + "size": 77175, + "subdir": "linux-64", + "timestamp": 1610306260268, + "version": "1.0.2" + }, + "pymysql-1.0.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ab83440c75f8961d25933501c2fe90b", + "name": "pymysql", + "sha256": "9e7df68ee6abd1cc27d7f4c0d097053d6e6fc55688df957d9033073da187e3fe", + "size": 78565, + "subdir": "linux-64", + "timestamp": 1610482444959, + "version": "1.0.2" + }, + "pymysql-1.0.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc2ffdfcf68e2faaa6aaf13558ab258b", + "name": "pymysql", + "sha256": "e8f5174d155a728ad0f517b1e4b77f7d5b24638a2908d953abfcc4d7d23ba1d4", + "size": 77185, + "subdir": "linux-64", + "timestamp": 1610306267643, + "version": "1.0.2" + }, + "pymysql-1.0.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "faa2f963ef299981ba2cb85c6baed942", + "name": "pymysql", + "sha256": "55a543fae17b6f6c479e7b754795eb6dcb3faba71c43b73d35b9877f858adc17", + "size": 79095, + "subdir": "linux-64", + "timestamp": 1610482930069, + "version": "1.0.2" + }, + "pymysql-1.0.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7949b16b88b6e8e1fdad4fa2640f6513", + "name": "pymysql", + "sha256": "c6074b819eb802eaa5f0225c4fa1e1391ed16570aadbfa88585d77a46209caa7", + "size": 77502, + "subdir": "linux-64", + "timestamp": 1610306270755, + "version": "1.0.2" + }, + "pymysql-1.0.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2c43265ef749ebc47753a2730330eb5", + "name": "pymysql", + "sha256": "079b74c84e6ca7f3dad8a86d0efe9c83c08c1d1355e120b2fb123cc4531832e8", + "size": 80151, + "subdir": "linux-64", + "timestamp": 1610482902483, + "version": "1.0.2" + }, + "pymysql-1.0.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "797f83e2c051d31b308a665a3aa8ad8b", + "name": "pymysql", + "sha256": "f12f72128cbdfc8b4d18a779e331e435eb411fa5725385d8096d0720861a608a", + "size": 77497, + "subdir": "linux-64", + "timestamp": 1610306236904, + "version": "1.0.2" + }, + "pymysql-1.0.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51cec52a5acc77fc0eb7b883711d8d5b", + "name": "pymysql", + "sha256": "dba97dabe1bb6dd54db00ba68cc75db99d5859781c01edfdeae59f540b374609", + "size": 79462, + "subdir": "linux-64", + "timestamp": 1610482941194, + "version": "1.0.2" + }, + "pynacl-1.2.0-py27hefb0b17_0.conda": { + "build": "py27hefb0b17_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "93e68126eb2242f984524faa397777a0", + "name": "pynacl", + "sha256": "cd58ca9696a169f1a737a17bc49d075e26485592dfba0bfdbce92619baa92618", + "size": 1175435, + "subdir": "linux-64", + "timestamp": 1511037349389, + "version": "1.2.0" + }, + "pynacl-1.2.0-py35h9037bf7_0.conda": { + "build": "py35h9037bf7_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d09a80190795cccbcec061b045b01f40", + "name": "pynacl", + "sha256": "d423886493ba423b714557ea0216c800efdcf41fee9cb7e244444bc74786294f", + "size": 1177542, + "subdir": "linux-64", + "timestamp": 1511037323666, + "version": "1.2.0" + }, + "pynacl-1.2.0-py36hb6d7a8d_0.conda": { + "build": "py36hb6d7a8d_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a878fd21d98517792e03dbe4193f0860", + "name": "pynacl", + "sha256": "2c9b2bf121f263b4f1d8f206c2b989974c55c9b662944efe1920ba5201ca2d13", + "size": 1176205, + "subdir": "linux-64", + "timestamp": 1511037348956, + "version": "1.2.0" + }, + "pynacl-1.2.1-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "06d36bdafa6f9f00787feedd526fe0b2", + "name": "pynacl", + "sha256": "177e5a2f32a651382dff45219095d2c9d0545eb81258c13177649048c14870fb", + "size": 1050673, + "subdir": "linux-64", + "timestamp": 1522217633325, + "version": "1.2.1" + }, + "pynacl-1.2.1-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "af4032cb165b16edc54e97eca3c56353", + "name": "pynacl", + "sha256": "b5d6aced4a5196b37279799188cc73337fcd1b4422a606ee85aae46c7c82deb5", + "size": 1039600, + "subdir": "linux-64", + "timestamp": 1522217729246, + "version": "1.2.1" + }, + "pynacl-1.2.1-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a0dc04b0acc8feea7ecd08dfb160b72b", + "name": "pynacl", + "sha256": "9b7b1879f278c6ece2a55c431649926d62653bb93f69b166199a6b3995dc97b9", + "size": 1038206, + "subdir": "linux-64", + "timestamp": 1522217793044, + "version": "1.2.1" + }, + "pynacl-1.2.1-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "76b61472de2a52df7c69fa86e1eb4a7e", + "name": "pynacl", + "sha256": "2787d0a58c0583d7efaf8f5c1c5072315e4f3fb531d83d8281a4b460a4104891", + "size": 1037823, + "subdir": "linux-64", + "timestamp": 1530876018049, + "version": "1.2.1" + }, + "pynacl-1.3.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d7dddf682b578087c512cb0f212dade7", + "name": "pynacl", + "sha256": "89be864f8a06625032b48cfbf6512394da045fec846da70b5319f6a1c9138db7", + "size": 1101853, + "subdir": "linux-64", + "timestamp": 1539896370365, + "version": "1.3.0" + }, + "pynacl-1.3.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4aea48d512d9150770292669015224f5", + "name": "pynacl", + "sha256": "9668e484351af771473df6209ac7fecf6461d009037da61567b7285f7db785cf", + "size": 1103899, + "subdir": "linux-64", + "timestamp": 1539896395373, + "version": "1.3.0" + }, + "pynacl-1.3.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1a04fd87638909afbb8de29ae5e2cdb3", + "name": "pynacl", + "sha256": "d1b25b0c8e10d8c82e8f2b176b8689ee93c85d7fd3e025345055e0de445db37f", + "size": 1103095, + "subdir": "linux-64", + "timestamp": 1539896397775, + "version": "1.3.0" + }, + "pynacl-1.3.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "395f29606198d77991e8dfb4440755ce", + "name": "pynacl", + "sha256": "92ed01c74431fc2ef8034eb1118f97ba1c4ed94e9696997b118b585b28e27015", + "size": 1104563, + "subdir": "linux-64", + "timestamp": 1574273734485, + "version": "1.3.0" + }, + "pynacl-1.4.0-py310h5eee18b_2.conda": { + "build": "py310h5eee18b_2", + "build_number": 2, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=11.2.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "531a35b9496c15432739eebd5cfdc270", + "name": "pynacl", + "sha256": "aab4bf79bf8cacb8b648bd26455f1351599aa0923b6a1809bf4975153ff38e82", + "size": 1161884, + "subdir": "linux-64", + "timestamp": 1659594701141, + "version": "1.4.0" + }, + "pynacl-1.4.0-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.5.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ca908a998678bd58fd21b42be5f67bce", + "name": "pynacl", + "sha256": "e3e3c6cb8b66560adf1ca0c1a547ce17f6ecdc2ac0d074bc1bd5aae1bbbcc66a", + "size": 1165952, + "subdir": "linux-64", + "timestamp": 1640810354945, + "version": "1.4.0" + }, + "pynacl-1.4.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b9177749bb14a30042c2c9e85102ca87", + "name": "pynacl", + "sha256": "228537983f9efcec074e824cf8968d9721b40f72284aa431527647c5b3e00b82", + "size": 1110866, + "subdir": "linux-64", + "timestamp": 1593121752975, + "version": "1.4.0" + }, + "pynacl-1.4.0-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5e2f83dc523f3e1b8e99fd03e7428fc0", + "name": "pynacl", + "sha256": "0995ace47759f7687f39e10eb1cb4708c804c3faa1180c52e4eb2c19bd4bfa93", + "size": 1108528, + "subdir": "linux-64", + "timestamp": 1595009154590, + "version": "1.4.0" + }, + "pynacl-1.4.0-py37h5eee18b_2.conda": { + "build": "py37h5eee18b_2", + "build_number": 2, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=11.2.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "abdc9096f1cb504458ac0b7e3f50ab7d", + "name": "pynacl", + "sha256": "6932fadf224559809ca10f250ccf575fe97c07a225759f1ab94905d85515fac0", + "size": 1105738, + "subdir": "linux-64", + "timestamp": 1659594745934, + "version": "1.4.0" + }, + "pynacl-1.4.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ca433bc8697082ff975ca21452839def", + "name": "pynacl", + "sha256": "3252a8a19d5f9a4fb44f9afb0082cde50c739c302e1af1f89a54eb75e97afc4f", + "size": 1109715, + "subdir": "linux-64", + "timestamp": 1593121740259, + "version": "1.4.0" + }, + "pynacl-1.4.0-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b23c0e4cc1066e86d3494a4c3d54de97", + "name": "pynacl", + "sha256": "dea9af491a7e51c1032863ab114b1f8991b790b56a32f1548f47b664e1442feb", + "size": 1110911, + "subdir": "linux-64", + "timestamp": 1595009192922, + "version": "1.4.0" + }, + "pynacl-1.4.0-py38h5eee18b_2.conda": { + "build": "py38h5eee18b_2", + "build_number": 2, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=11.2.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "97af046ee0d42338214985f1c5e28ff5", + "name": "pynacl", + "sha256": "0740226bb2a59e57b66a440d5148dc6b93e5636f4f14bf46cafe7338c7a0545a", + "size": 1105525, + "subdir": "linux-64", + "timestamp": 1659594790707, + "version": "1.4.0" + }, + "pynacl-1.4.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "92222085955d8263cd6cf563aa45852f", + "name": "pynacl", + "sha256": "953c5ac8121e082e0307daaeaa2b13f59bcbe723949a238f967fd66760e66eab", + "size": 1109868, + "subdir": "linux-64", + "timestamp": 1593121760320, + "version": "1.4.0" + }, + "pynacl-1.4.0-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4d91ce64c07b0ee74c6ec83db91e3a17", + "name": "pynacl", + "sha256": "3bba9196ff8491c6e4d307e7694458d18ffce682cc5182d9db18d367d22822fa", + "size": 1110467, + "subdir": "linux-64", + "timestamp": 1595009178996, + "version": "1.4.0" + }, + "pynacl-1.4.0-py39h5eee18b_2.conda": { + "build": "py39h5eee18b_2", + "build_number": 2, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=11.2.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8e5cdf992093464e2449cd50ee33ad11", + "name": "pynacl", + "sha256": "172e7b91309c25fb3b38df0e92272ab1879801d2f973848feae86ca4580dbae4", + "size": 1104698, + "subdir": "linux-64", + "timestamp": 1659594646221, + "version": "1.4.0" + }, + "pynacl-1.4.0-py39he8ac12f_1.conda": { + "build": "py39he8ac12f_1", + "build_number": 1, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b7d1d3fbe068ec1920e9d62e99c91405", + "name": "pynacl", + "sha256": "ce6c015c586402c824198915eba4d1465e91ada02bc4c47ada3c8721bf34de8d", + "size": 1111341, + "subdir": "linux-64", + "timestamp": 1607611518057, + "version": "1.4.0" + }, + "pynacl-1.5.0-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=11.2.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a714b7047612e14d8931ca096e6d94ab", + "name": "pynacl", + "sha256": "9ac2623ba8a46f21fd81001ed59d0e3902b64299cfaf2bd19ca82a9604af4ac8", + "size": 1170922, + "subdir": "linux-64", + "timestamp": 1659620748265, + "version": "1.5.0" + }, + "pynacl-1.5.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=11.2.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "36aa082de922a6ff2f282274ea643e43", + "name": "pynacl", + "sha256": "717c6227a2701636e5cbd06ce992e2fd9695b88b25b56ca8539288fe14f93725", + "size": 1172363, + "subdir": "linux-64", + "timestamp": 1676842280496, + "version": "1.5.0" + }, + "pynacl-1.5.0-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=11.2.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d108d7f9833d4ecfc61cc1877d99b374", + "name": "pynacl", + "sha256": "2ad10ba518cc62a7a4a87182b79b991244e77ea4f3ce6ec794010bad4e062587", + "size": 1118251, + "subdir": "linux-64", + "timestamp": 1659620841208, + "version": "1.5.0" + }, + "pynacl-1.5.0-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=11.2.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c5c01075a5e02cb8e6687b753be9a70c", + "name": "pynacl", + "sha256": "d44af77c58317fa5a7f1c50f672576ccb7c24ea999c172df1b9283112e71bb87", + "size": 1120467, + "subdir": "linux-64", + "timestamp": 1659620793306, + "version": "1.5.0" + }, + "pynacl-1.5.0-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.4.1", + "libgcc-ng >=11.2.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2005cdcb1481860dea6d21609b106c9e", + "name": "pynacl", + "sha256": "f51c7b410e4345148a1b0c0b21a2fcb026c328144c54e7144f16bd5b28a0e874", + "size": 1119660, + "subdir": "linux-64", + "timestamp": 1659620690810, + "version": "1.5.0" + }, + "pynio-1.5.0-py27h34504d7_1.conda": { + "build": "py27h34504d7_1", + "build_number": 1, + "depends": [ + "g2clib >=1.6.0,<1.7.0a0", + "jasper >=1.900.1,<2.0a0", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libnetcdf >=4.4.1.1,<4.4.2.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "proj4 >=4.9.3,<4.9.4.0a0", + "python >=2.7,<2.8.0a0", + "util-linux" + ], + "license": "BSD 3-clause", + "md5": "3f5fe359428cd48ffa417c1abb15640d", + "name": "pynio", + "sha256": "ab5dc4a366d13a5d9289f8fa6d62a3e0e9330535ba0484daf91418711d95f1c9", + "size": 2402555, + "subdir": "linux-64", + "timestamp": 1512149490790, + "version": "1.5.0" + }, + "pynio-1.5.0-py27h546be6d_1.conda": { + "build": "py27h546be6d_1", + "build_number": 1, + "depends": [ + "g2clib >=1.6.0,<1.7.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jasper >=2.0.14,<3.0a0", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "fd98358616a406c5381c39ccb23dea23", + "name": "pynio", + "sha256": "a9cfdad97e6236fb6b75a6def711def1339b59fb7348d82e24ee4cd9f5fb4f83", + "size": 2406379, + "subdir": "linux-64", + "timestamp": 1531092851178, + "version": "1.5.0" + }, + "pynio-1.5.0-py27hce281da_1.conda": { + "build": "py27hce281da_1", + "build_number": 1, + "depends": [ + "g2clib >=1.6.0,<1.7.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jasper >=1.900.1,<2.0a0", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "47834fa70fa87e6c2404759163c18017", + "name": "pynio", + "sha256": "c8f04e2771ba94a2ee43e62e210284e55d30950d3e235fa7673d1b14d0e91940", + "size": 2408025, + "subdir": "linux-64", + "timestamp": 1530918727542, + "version": "1.5.0" + }, + "pynio-1.5.0-py27hd0d9455_1.conda": { + "build": "py27hd0d9455_1", + "build_number": 1, + "depends": [ + "g2clib >=1.6.0,<1.7.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=2.0.14,<3.0a0", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "7a2028f65a111ee3f6420dfd15df0a73", + "name": "pynio", + "sha256": "d44bd9b43c11f2229816111efd8f5598b948fa0c4ed3a645c26b13303517d070", + "size": 2406684, + "subdir": "linux-64", + "timestamp": 1531093005190, + "version": "1.5.0" + }, + "pynio-1.5.0-py27hd2b2c5b_1.conda": { + "build": "py27hd2b2c5b_1", + "build_number": 1, + "depends": [ + "g2clib >=1.6.0,<1.7.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "jasper >=2.0.14,<3.0a0", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libgfortran-ng >=7,<8.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.35,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "proj4 >=5.2.0,<5.2.1.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "1c4fe9d9381f47d80dc2053992fe0f8d", + "name": "pynio", + "sha256": "0f55244179820f3127c37492a316326073a0280d34341101a4de6f759eb27636", + "size": 2427453, + "subdir": "linux-64", + "timestamp": 1545418834633, + "version": "1.5.0" + }, + "pynio-1.5.0-py27hf712402_1.conda": { + "build": "py27hf712402_1", + "build_number": 1, + "depends": [ + "g2clib >=1.6.0,<1.7.0a0", + "hdf4 >=4.2.13,<4.2.14.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jasper >=1.900.1,<2.0a0", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libgfortran-ng >=7,<8.0a0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "proj4 >=5.0.1,<5.0.2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "b586041916d57c91bdc3f415a393538d", + "name": "pynio", + "sha256": "4374ffcd1b23670aaa9fa03440ac9392eae0d6cc382656577bf1edb6e19caec1", + "size": 2408192, + "subdir": "linux-64", + "timestamp": 1530918578369, + "version": "1.5.0" + }, + "pyo3-pack-0.3.6-h04498ad_0.conda": { + "build": "h04498ad_0", + "build_number": 0, + "depends": [], + "md5": "db85d31142dbeab4e2e04135c6213ba1", + "name": "pyo3-pack", + "sha256": "8858879a5e3b0614971916a0d557c0c9b687caf860e1ca335fb2f1607c2fa2db", + "size": 2880898, + "subdir": "linux-64", + "timestamp": 1538425971869, + "version": "0.3.6" + }, + "pyodbc-4.0.17-py27h7f7627d_0.conda": { + "build": "py27h7f7627d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "unixodbc 2.3.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de3501f325de4d5d1cd34664a3cd22f0", + "name": "pyodbc", + "sha256": "445468aa03ac7371e5235274844c88d69693d4ae3ff8178bab8cc131effbf2ea", + "size": 58647, + "subdir": "linux-64", + "timestamp": 1505751926066, + "version": "4.0.17" + }, + "pyodbc-4.0.17-py35h89a430b_0.conda": { + "build": "py35h89a430b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "unixodbc 2.3.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "354e1e2a7e243fb75bbcdd306940a2d5", + "name": "pyodbc", + "sha256": "cfe6cd1efdec98bc38a34ce3e35d9dc62935251fb6425de226891c51007e1133", + "size": 57553, + "subdir": "linux-64", + "timestamp": 1505751946791, + "version": "4.0.17" + }, + "pyodbc-4.0.17-py36h999153c_0.conda": { + "build": "py36h999153c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "unixodbc 2.3.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3fc8caec6d4cbe1bec86d0d5a386c390", + "name": "pyodbc", + "sha256": "d066661b7ce04de69f9a1e2ce34a469e43ea5f81abe20f3d49fc25d8e2fb34b1", + "size": 57719, + "subdir": "linux-64", + "timestamp": 1505751967657, + "version": "4.0.17" + }, + "pyodbc-4.0.21-py27h5bedd64_0.conda": { + "build": "py27h5bedd64_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "unixodbc 2.3.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec79a57c0b3badeaf368ecd33cfb03de", + "name": "pyodbc", + "sha256": "f167d2f8922d4e6ccbb132d4795f87fa586819ac2cbf223dc20764f7cec96d34", + "size": 64567, + "subdir": "linux-64", + "timestamp": 1511322366620, + "version": "4.0.21" + }, + "pyodbc-4.0.21-py35hc2e132f_0.conda": { + "build": "py35hc2e132f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "unixodbc 2.3.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "41c30a6e8e9e999297f9f5abcd50342a", + "name": "pyodbc", + "sha256": "fbc2106d77b2b357d4fbc9dcc4be37e7104dc57b3aa4302f713e041ec6119ee5", + "size": 63424, + "subdir": "linux-64", + "timestamp": 1511322447523, + "version": "4.0.21" + }, + "pyodbc-4.0.21-py36h083aac6_0.conda": { + "build": "py36h083aac6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "unixodbc 2.3.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d32289076f92073f96c37da8b97da97e", + "name": "pyodbc", + "sha256": "be85240159e336f7434592d7cc99152ef2ad08fe095acf70b92a063b24c572ca", + "size": 62853, + "subdir": "linux-64", + "timestamp": 1511322447204, + "version": "4.0.21" + }, + "pyodbc-4.0.22-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "unixodbc 2.3.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e809ad37e0dcd63d0b3fd46bfbfeb90", + "name": "pyodbc", + "sha256": "3909004c3a4d8a744507fdd30e2ea6df3431151c824e5637c301fca65a441b36", + "size": 65040, + "subdir": "linux-64", + "timestamp": 1516746939740, + "version": "4.0.22" + }, + "pyodbc-4.0.22-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "unixodbc 2.3.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d92ea1a4be2ba5890b8ee68abff02c68", + "name": "pyodbc", + "sha256": "6d62ad20a825808d58cd1ca91871cc40b6ebfe7bd57f2a8c35ac1656de7ec556", + "size": 63438, + "subdir": "linux-64", + "timestamp": 1516746963512, + "version": "4.0.22" + }, + "pyodbc-4.0.22-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "unixodbc 2.3.4.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df80ef7302a1411d526028496baf36f0", + "name": "pyodbc", + "sha256": "6a1c8d2f1a13e830a8c3b8d1da8a00180c2151e1c588026370d74162e8c470aa", + "size": 64636, + "subdir": "linux-64", + "timestamp": 1516746980450, + "version": "4.0.22" + }, + "pyodbc-4.0.23-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b85f5fc8b1b0b2c2677fa37ff4cd692f", + "name": "pyodbc", + "sha256": "ca24720b252658e86194cd004263b04bce91846eb556f65ec6729d8a245c46ed", + "size": 65500, + "subdir": "linux-64", + "timestamp": 1522880522569, + "version": "4.0.23" + }, + "pyodbc-4.0.23-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "32ca53f894efa3e41053517d014c190c", + "name": "pyodbc", + "sha256": "e6c8281a29062464917ac8a858efe356241c51a3cdbdd0c0bdfe1f3b7e2553b6", + "size": 62662, + "subdir": "linux-64", + "timestamp": 1522880536387, + "version": "4.0.23" + }, + "pyodbc-4.0.23-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "515936f058e39f646086cdfa98d29955", + "name": "pyodbc", + "sha256": "f5671e22e59c66d7f3fe1f31f2e547f7b9bc3c6ba9a562a53ce066d88ff95683", + "size": 62716, + "subdir": "linux-64", + "timestamp": 1522880574533, + "version": "4.0.23" + }, + "pyodbc-4.0.23-py37hf484d3e_0.conda": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11fc6913827328cf29e4dcafd33bdb2d", + "name": "pyodbc", + "sha256": "6e36426ae770a441dfe1274f6fdd20a34908eb27aca49cdbaee06032b5c78d31", + "size": 64527, + "subdir": "linux-64", + "timestamp": 1530918779123, + "version": "4.0.23" + }, + "pyodbc-4.0.24-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b84a35eae2fc58f1ea83bb22e5aa71e", + "name": "pyodbc", + "sha256": "d422d45bad0cb14fc2c79269ca58c6224e380708dc1451284a07bf208d044a4c", + "size": 67488, + "subdir": "linux-64", + "timestamp": 1534951088153, + "version": "4.0.24" + }, + "pyodbc-4.0.24-py35he6710b0_0.conda": { + "build": "py35he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fce0655cdfdad7ab4cdd408733b9822c", + "name": "pyodbc", + "sha256": "d15e9e189632a06325212c201cb1f8f0723bf2659da28f34066ae863e5787438", + "size": 65351, + "subdir": "linux-64", + "timestamp": 1534954938387, + "version": "4.0.24" + }, + "pyodbc-4.0.24-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62afc336726b499574cfde2495be0447", + "name": "pyodbc", + "sha256": "fd6fb0e53fd2fefe5a5e015ced9c7c46cea9ce2a582ef65526354f1bbce5d680", + "size": 65422, + "subdir": "linux-64", + "timestamp": 1534951070979, + "version": "4.0.24" + }, + "pyodbc-4.0.24-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.6,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "038568efb3b1eb1f608d80c0769b2fe0", + "name": "pyodbc", + "sha256": "e6b5b780326f0d687d34868b2dad96b9aa40d61f58b243ea469bedadae3d7477", + "size": 65306, + "subdir": "linux-64", + "timestamp": 1534951057444, + "version": "4.0.24" + }, + "pyodbc-4.0.25-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c341605f847b32cc1f276fb80d7dcc2", + "name": "pyodbc", + "sha256": "9f1a8851f27fe8288162f7b58ee726a4a114ae6046c8b9d04a3f2ee9bb72e68f", + "size": 70399, + "subdir": "linux-64", + "timestamp": 1545077265517, + "version": "4.0.25" + }, + "pyodbc-4.0.25-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fedd3c5c24ff3b53d25a150b13119734", + "name": "pyodbc", + "sha256": "92f083dff73bc494f4a25651ece40465c4c6556dc6ce6d0e4ea5fed7e40193af", + "size": 68360, + "subdir": "linux-64", + "timestamp": 1545077297172, + "version": "4.0.25" + }, + "pyodbc-4.0.25-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60ccc1be24cc3ad211f6fa03ade464b9", + "name": "pyodbc", + "sha256": "ae2b9fb5b738b09191992c83d6ccd5ce0132c7043699bd3d9a4cbf570b613b49", + "size": 68333, + "subdir": "linux-64", + "timestamp": 1545077307772, + "version": "4.0.25" + }, + "pyodbc-4.0.26-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2fedd9b2c64b321f9d92c5bc7dce21d3", + "name": "pyodbc", + "sha256": "3b7e5014353234c6b234748ee4526edb3dc98b27bb56c393064824b7b3f3191c", + "size": 71136, + "subdir": "linux-64", + "timestamp": 1551146584867, + "version": "4.0.26" + }, + "pyodbc-4.0.26-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e012fade44fa9af28a5b8ac993b711be", + "name": "pyodbc", + "sha256": "12b3571128bcaccbf7cba0f2c7101a12f1d2a1b7e519c06f7552c787627924e1", + "size": 69026, + "subdir": "linux-64", + "timestamp": 1551146600830, + "version": "4.0.26" + }, + "pyodbc-4.0.26-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "05d9a6de43fd7dad4003f00ccd2b7759", + "name": "pyodbc", + "sha256": "a386ce3b7cd91f49b469c2475ce960cb4a2151101037bb3da0dfb853de7e7a38", + "size": 69042, + "subdir": "linux-64", + "timestamp": 1551146564456, + "version": "4.0.26" + }, + "pyodbc-4.0.27-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d7d32c800765d3ae574ce0ebe971fc4", + "name": "pyodbc", + "sha256": "5f8dbcc2e09a181b1cc7941df046e7f7d17df3d578c0776cc8a9611141a5f65e", + "size": 71600, + "subdir": "linux-64", + "timestamp": 1565963835447, + "version": "4.0.27" + }, + "pyodbc-4.0.27-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a859762d30bcde7544b8e358d62e009", + "name": "pyodbc", + "sha256": "8c4b8ee5dccd8e9d070e3f8d7aa05c23bd5599db684a1436f7e3d3cd042344f1", + "size": 70576, + "subdir": "linux-64", + "timestamp": 1565963989813, + "version": "4.0.27" + }, + "pyodbc-4.0.27-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4747b36ca1a658f3b1ab24c36e4041e4", + "name": "pyodbc", + "sha256": "fee04446db8a44e6dd278b4613b0a3419b7f5e16e831d3d81c0abadd4e361a69", + "size": 69561, + "subdir": "linux-64", + "timestamp": 1565963985104, + "version": "4.0.27" + }, + "pyodbc-4.0.27-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c8ded65fe42530698ef6efd44f07c103", + "name": "pyodbc", + "sha256": "13059d473726af978c3d19a33453908e8f59c1422b488fe4e59375303ef1bdca", + "size": 76179, + "subdir": "linux-64", + "timestamp": 1573670109815, + "version": "4.0.27" + }, + "pyodbc-4.0.28-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a0bbbe0db84291253ea328fe05c4e7a", + "name": "pyodbc", + "sha256": "92b95de79cc20f371d8ca055b124a369e3e2a726212119035ac168e6659e2378", + "size": 70915, + "subdir": "linux-64", + "timestamp": 1580401127207, + "version": "4.0.28" + }, + "pyodbc-4.0.28-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f15cde95673678a38f6d3b00d38ee34", + "name": "pyodbc", + "sha256": "666a40102115f60d3444eadbe542ffd46c0cf3b361df1a2016c7ed2db1940b42", + "size": 71959, + "subdir": "linux-64", + "timestamp": 1580401107573, + "version": "4.0.28" + }, + "pyodbc-4.0.28-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8540b0ed162fe7420b47435fb2dc4bb5", + "name": "pyodbc", + "sha256": "4b4383338c7ace429210f543153ceaa063004465b0bcabbf133d7fe09653a8db", + "size": 71646, + "subdir": "linux-64", + "timestamp": 1580401183672, + "version": "4.0.28" + }, + "pyodbc-4.0.30-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1bfc4679e39582633bc5aef4c3bc137a", + "name": "pyodbc", + "sha256": "d060a4bd1cf049930eb99b805e76f122fa337a646fcce8b1a028a1e324ac85d1", + "size": 72651, + "subdir": "linux-64", + "timestamp": 1581353547221, + "version": "4.0.30" + }, + "pyodbc-4.0.30-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec8c6a9fccb08311cc2176379bff0211", + "name": "pyodbc", + "sha256": "87495d7c1eb5587a454cacf16600dc71ba82d23ca1a3ea47091d47ca5f89b67a", + "size": 71574, + "subdir": "linux-64", + "timestamp": 1581353584710, + "version": "4.0.30" + }, + "pyodbc-4.0.30-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "unixodbc >=2.3.7,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5515784f98df4ad12ac173fa8d3a7d37", + "name": "pyodbc", + "sha256": "554030ae5c9d95930dbd20e362076e6084920005d9348e4eebcbd8a67eedaf28", + "size": 73427, + "subdir": "linux-64", + "timestamp": 1581353596961, + "version": "4.0.30" + }, + "pyodbc-4.0.30-py39h66f3464_0.conda": { + "build": "py39h66f3464_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4eb92bb797a71f0ddb929c8869c80299", + "name": "pyodbc", + "sha256": "07f1f3ebb7b43a1a6aaaf615161720ff93c161d415556e8762aee8ab298461cc", + "size": 72489, + "subdir": "linux-64", + "timestamp": 1607570751918, + "version": "4.0.30" + }, + "pyodbc-4.0.31-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef61e49fc2d832f2c384758c8cc6545e", + "name": "pyodbc", + "sha256": "2261fd9b721a91dcf759023a1a993632422bf52b01d0fb022857f71e52aae1a8", + "size": 234058, + "subdir": "linux-64", + "timestamp": 1640793550702, + "version": "4.0.31" + }, + "pyodbc-4.0.31-py36h295c915_0.conda": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "91653d04c17e7d181b395a8e2395794d", + "name": "pyodbc", + "sha256": "731acb09005a8aa98c7f07858bc7a729717f3ebf3cd19e149467c4f46ac590a5", + "size": 72200, + "subdir": "linux-64", + "timestamp": 1625471279763, + "version": "4.0.31" + }, + "pyodbc-4.0.31-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c19239fdca36a36763aed6b5fc1a63e", + "name": "pyodbc", + "sha256": "71959139b88264574c146e804bdf75480bec562594c37978f2cac6846fb58d3e", + "size": 72249, + "subdir": "linux-64", + "timestamp": 1625471294263, + "version": "4.0.31" + }, + "pyodbc-4.0.31-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2382b5ad66453cf836c7f9e95cf3bc63", + "name": "pyodbc", + "sha256": "075e857ec2229d3941227d527d2767cc675026846959c2ac3df90af94e100f1e", + "size": 73144, + "subdir": "linux-64", + "timestamp": 1625471297274, + "version": "4.0.31" + }, + "pyodbc-4.0.31-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f687cbab27606e604993784a66e8c07", + "name": "pyodbc", + "sha256": "29c3748aac3941b81edc98366b2596ebcc67af5e2124a64f17731222d3eb955c", + "size": 73010, + "subdir": "linux-64", + "timestamp": 1625464635434, + "version": "4.0.31" + }, + "pyodbc-4.0.32-py310h295c915_1.conda": { + "build": "py310h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca25e26b4cf7aeba0d3b44606263d431", + "name": "pyodbc", + "sha256": "57609477266d2582399885756db86c2620935661660518f31def6ec28b792e0a", + "size": 237185, + "subdir": "linux-64", + "timestamp": 1647425958247, + "version": "4.0.32" + }, + "pyodbc-4.0.32-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d6bfb0b7b6b9161c556267917aaa9db9", + "name": "pyodbc", + "sha256": "66d49191503d59264f1e13f9a5dbe50d245a5b41ce8f678fab6378b9e4800234", + "size": 73069, + "subdir": "linux-64", + "timestamp": 1639688264356, + "version": "4.0.32" + }, + "pyodbc-4.0.32-py37h295c915_1.conda": { + "build": "py37h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "97e3257e216b048a842a8b62730c0a5d", + "name": "pyodbc", + "sha256": "24d34ca0d8d30973c94320b24a3b5fe4d9f96d9d36c3a9cf17ad42eef5f0600f", + "size": 76984, + "subdir": "linux-64", + "timestamp": 1647425941458, + "version": "4.0.32" + }, + "pyodbc-4.0.32-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5604f4a123f09b744bf49f857e8fd6d5", + "name": "pyodbc", + "sha256": "e8cb0db3e33fe715b5e5f1a045f233fd76fd58b666134d153a21eedf9caaea95", + "size": 73993, + "subdir": "linux-64", + "timestamp": 1639688294913, + "version": "4.0.32" + }, + "pyodbc-4.0.32-py38h295c915_1.conda": { + "build": "py38h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51a1d89d13732b93ea3369e1caa9f9b8", + "name": "pyodbc", + "sha256": "bd67cd75d4b80ed282fa497b095e8c4cd236ba28e5d15a86f0ce3e26ac5a55c3", + "size": 77961, + "subdir": "linux-64", + "timestamp": 1647408164471, + "version": "4.0.32" + }, + "pyodbc-4.0.32-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2a4f52bc7dfa13cde05c2756494d9fc", + "name": "pyodbc", + "sha256": "aab4cbf01b38e10069dfc759974936bb19a562f8dcde66ec0df5ba07a5ce7837", + "size": 73783, + "subdir": "linux-64", + "timestamp": 1639688233271, + "version": "4.0.32" + }, + "pyodbc-4.0.32-py39h295c915_1.conda": { + "build": "py39h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d06c7cc96e5736edc693e42a029a342f", + "name": "pyodbc", + "sha256": "f6e197eee4a7c95a854688020567010476737e897352e129644702df788c6857", + "size": 78503, + "subdir": "linux-64", + "timestamp": 1647425941244, + "version": "4.0.32" + }, + "pyodbc-4.0.34-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT-0", + "license_family": "MIT", + "md5": "15da087c1e2e423dd82f3f7cc2234d83", + "name": "pyodbc", + "sha256": "78afcbf1c0429228b78ba1558d1f02032a94afcc4954238422d18e4194cab94d", + "size": 265077, + "subdir": "linux-64", + "timestamp": 1659513877591, + "version": "4.0.34" + }, + "pyodbc-4.0.34-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "unixodbc >=2.3.11,<2.4.0a0" + ], + "license": "MIT-0", + "license_family": "MIT", + "md5": "ce4b0158f6aaa11364e3ffc65089542d", + "name": "pyodbc", + "sha256": "6b1aaf079a96788a1abee0dc5213f5abb0ba9b6aac40e6236d41ce4a7f91023d", + "size": 74464, + "subdir": "linux-64", + "timestamp": 1676861009230, + "version": "4.0.34" + }, + "pyodbc-4.0.34-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT-0", + "license_family": "MIT", + "md5": "8a474806ed150cde680ae3b941df0e10", + "name": "pyodbc", + "sha256": "a430162a31d5cba46b57c5d5a0231dfe975d80a3cfbab7ecbd305d3c2431f5aa", + "size": 75558, + "subdir": "linux-64", + "timestamp": 1659514004441, + "version": "4.0.34" + }, + "pyodbc-4.0.34-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT-0", + "license_family": "MIT", + "md5": "c648c33f2d9c08fcdf0b783af66557f7", + "name": "pyodbc", + "sha256": "c12e1c23661dae6e9cac479d641b5d74ccdbef9fef09e5b90058324034826e19", + "size": 76418, + "subdir": "linux-64", + "timestamp": 1659513919352, + "version": "4.0.34" + }, + "pyodbc-4.0.34-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "unixodbc >=2.3.9,<2.4.0a0" + ], + "license": "MIT-0", + "license_family": "MIT", + "md5": "8507fac62c8cd5b22448d2101dd13da2", + "name": "pyodbc", + "sha256": "8296a2b1e3961e6562fbac0543bd483b6812cdddad560ce19d4b0a5dee978b0b", + "size": 76539, + "subdir": "linux-64", + "timestamp": 1659513961362, + "version": "4.0.34" + }, + "pyomniscidb-5.6.2-py36hbca4264_0.conda": { + "build": "py36hbca4264_0", + "build_number": 0, + "depends": [ + "numpy >=1.16,<2.0a0", + "packaging >=20.0", + "python >=3.6,<3.7.0a0", + "rbc >=0.2.2", + "requests", + "setuptools", + "sqlalchemy >=1.3", + "thrift 0.13.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1b2b3870407ec1588bf8bb857030325b", + "name": "pyomniscidb", + "sha256": "0eff9799e672f66b5fe41c3044747c6b7f9bbb45efafef087ca1ffb777a7eca5", + "size": 490052, + "subdir": "linux-64", + "timestamp": 1626374470731, + "version": "5.6.2" + }, + "pyomniscidb-5.6.2-py37hbca4264_0.conda": { + "build": "py37hbca4264_0", + "build_number": 0, + "depends": [ + "numpy >=1.16,<2.0a0", + "packaging >=20.0", + "python >=3.7,<3.8.0a0", + "rbc >=0.2.2", + "requests", + "setuptools", + "sqlalchemy >=1.3", + "thrift 0.13.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aa7f14adfe749346c08c41347a97ef12", + "name": "pyomniscidb", + "sha256": "34023b387561f91cf42956db845eb079f837005c256b35d1195b69fd0901a229", + "size": 489978, + "subdir": "linux-64", + "timestamp": 1626374454149, + "version": "5.6.2" + }, + "pyomniscidb-5.6.2-py38hbca4264_0.conda": { + "build": "py38hbca4264_0", + "build_number": 0, + "depends": [ + "numpy >=1.16,<2.0a0", + "packaging >=20.0", + "python >=3.8,<3.9.0a0", + "rbc >=0.2.2", + "requests", + "setuptools", + "sqlalchemy >=1.3", + "thrift 0.13.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7593d125fdf3f0be7b83a7a9b65a43f9", + "name": "pyomniscidb", + "sha256": "00ebc75d806ee9c3d0c30db3fb6a1e294f44e6bd7bd06d316c93f52a7f3cb368", + "size": 491043, + "subdir": "linux-64", + "timestamp": 1626374505936, + "version": "5.6.2" + }, + "pyomniscidb-5.6.2-py39hbca4264_0.conda": { + "build": "py39hbca4264_0", + "build_number": 0, + "depends": [ + "numpy >=1.16,<2.0a0", + "packaging >=20.0", + "python >=3.9,<3.10.0a0", + "rbc >=0.2.2", + "requests", + "setuptools", + "sqlalchemy >=1.3", + "thrift 0.13.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e706d68bfee5078f791f5486744c069b", + "name": "pyomniscidb", + "sha256": "e59a10169f236a68dd96da6333daca9d90acc6cb48c84fb225815447b756cea1", + "size": 491076, + "subdir": "linux-64", + "timestamp": 1626374490939, + "version": "5.6.2" + }, + "pyomniscidb-5.7.0-py36hbca4264_0.conda": { + "build": "py36hbca4264_0", + "build_number": 0, + "depends": [ + "numpy >=1.16,<2.0a0", + "packaging >=20.0", + "python >=3.6,<3.7.0a0", + "requests", + "setuptools", + "sqlalchemy >=1.3", + "thrift 0.13.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d3d0d4698f5af8da512985f1662939ef", + "name": "pyomniscidb", + "sha256": "0364bdd16d7976673433d08be65bd94e97b6126061159bc7a1907dc494119d70", + "size": 147801, + "subdir": "linux-64", + "timestamp": 1630620428317, + "version": "5.7.0" + }, + "pyomniscidb-5.7.0-py37hbca4264_0.conda": { + "build": "py37hbca4264_0", + "build_number": 0, + "depends": [ + "numpy >=1.16,<2.0a0", + "packaging >=20.0", + "python >=3.7,<3.8.0a0", + "requests", + "setuptools", + "sqlalchemy >=1.3", + "thrift 0.13.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1d92a37eb7dcd6564eca2b4faee8c032", + "name": "pyomniscidb", + "sha256": "1c7f23edd9621f0265ee1bf2c2a21d15f53ea78170ff121198cb1c223e37627a", + "size": 147746, + "subdir": "linux-64", + "timestamp": 1630620436375, + "version": "5.7.0" + }, + "pyomniscidb-5.7.0-py38hbca4264_0.conda": { + "build": "py38hbca4264_0", + "build_number": 0, + "depends": [ + "numpy >=1.16,<2.0a0", + "packaging >=20.0", + "python >=3.8,<3.9.0a0", + "requests", + "setuptools", + "sqlalchemy >=1.3", + "thrift 0.13.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "26e30eea188a89f5c6597c7805778915", + "name": "pyomniscidb", + "sha256": "ee1fbd8ed65ced382607a88db9a8ab5ba4d1971482ac5c60b5ca2f5c6aaaecdc", + "size": 148917, + "subdir": "linux-64", + "timestamp": 1630620452790, + "version": "5.7.0" + }, + "pyomniscidb-5.7.0-py39hbca4264_0.conda": { + "build": "py39hbca4264_0", + "build_number": 0, + "depends": [ + "numpy >=1.16,<2.0a0", + "packaging >=20.0", + "python >=3.9,<3.10.0a0", + "requests", + "setuptools", + "sqlalchemy >=1.3", + "thrift 0.13.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5974c4e352ab440ed4a620ee0469c1df", + "name": "pyomniscidb", + "sha256": "6d46b8002c7db35c7408d4b4873f3a887ade044fb07a719d75fdb032fc374acd", + "size": 148831, + "subdir": "linux-64", + "timestamp": 1630620444594, + "version": "5.7.0" + }, + "pyomniscidbe-5.10.1-py310h65c4a83_0.conda": { + "build": "py310h65c4a83_0", + "build_number": 0, + "constrains": [ + "pyarrow ==6.0.1" + ], + "depends": [ + "gflags >=2.2.2,<2.3.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.4.0", + "numpy >=1.16,<2.0a0", + "omniscidbe 5.10.1 py310h65c4a83_0", + "python >=3.10,<3.11.0a0", + "tbb4py", + "utf8proc" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "77eded6290a9de258e7f6575a4988e0d", + "name": "pyomniscidbe", + "sha256": "d01398b122d71c5cb85a33448e97bcb1423ee15f0cae141ff0274a01ab6d994f", + "size": 7166698, + "subdir": "linux-64", + "timestamp": 1658970383490, + "version": "5.10.1" + }, + "pyomniscidbe-5.10.1-py37h7744c1e_0.conda": { + "build": "py37h7744c1e_0", + "build_number": 0, + "constrains": [ + "pyarrow ==6.0.1" + ], + "depends": [ + "gflags >=2.2.2,<2.3.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.4.0", + "numpy >=1.16,<2.0a0", + "omniscidbe 5.10.1 py37h7744c1e_0", + "python >=3.7,<3.8.0a0", + "tbb4py", + "utf8proc" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9b717cd40d8aa83104a78959f2a95060", + "name": "pyomniscidbe", + "sha256": "dc5e8fa4eff9acd2a8dd9e635346d1eea984ff281e15c9934e4de5677e37e9e3", + "size": 7135253, + "subdir": "linux-64", + "timestamp": 1658970258957, + "version": "5.10.1" + }, + "pyomniscidbe-5.10.1-py38h7744c1e_0.conda": { + "build": "py38h7744c1e_0", + "build_number": 0, + "constrains": [ + "pyarrow ==6.0.1" + ], + "depends": [ + "gflags >=2.2.2,<2.3.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.4.0", + "numpy >=1.16,<2.0a0", + "omniscidbe 5.10.1 py38h7744c1e_0", + "python >=3.8,<3.9.0a0", + "tbb4py", + "utf8proc" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "915b3dcdfc22cdaaf9121981febcf3a4", + "name": "pyomniscidbe", + "sha256": "c6dfbc111146e448afe4752fa1577c558dd680f43be3805df9c36a0004975500", + "size": 7215228, + "subdir": "linux-64", + "timestamp": 1658970322214, + "version": "5.10.1" + }, + "pyomniscidbe-5.10.1-py39h7744c1e_0.conda": { + "build": "py39h7744c1e_0", + "build_number": 0, + "constrains": [ + "pyarrow ==6.0.1" + ], + "depends": [ + "gflags >=2.2.2,<2.3.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.4.0", + "numpy >=1.16,<2.0a0", + "omniscidbe 5.10.1 py39h7744c1e_0", + "python >=3.9,<3.10.0a0", + "tbb4py", + "utf8proc" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "704a4e858874684618863a47e130ca50", + "name": "pyomniscidbe", + "sha256": "53e3c4d0d8d3afc663af494f8db79981fd7ac215f1a3e33d7ff0a25f9e233e8a", + "size": 7218874, + "subdir": "linux-64", + "timestamp": 1658970197374, + "version": "5.10.1" + }, + "pyomniscidbe-5.7.0-py36h14b4db5_0_cpu.conda": { + "build": "py36h14b4db5_0_cpu", + "build_number": 0, + "depends": [ + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "omniscidbe 5.7.0 h7185ff3_0_cpu", + "pyarrow 2.*", + "python >=3.6,<3.7.0a0", + "tbb >=2021.3.0", + "tbb4py" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "04045cf6dddb86536e721a468f2e2d5f", + "name": "pyomniscidbe", + "sha256": "9e2dbe397e9d2d12f678f589f88ed7f4e9c41c514782ee01551a26e15e62fe77", + "size": 1836817, + "subdir": "linux-64", + "timestamp": 1630620897528, + "version": "5.7.0" + }, + "pyomniscidbe-5.7.0-py37h14b4db5_0_cpu.conda": { + "build": "py37h14b4db5_0_cpu", + "build_number": 0, + "depends": [ + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "omniscidbe 5.7.0 h7185ff3_0_cpu", + "pyarrow 2.*", + "python >=3.7,<3.8.0a0", + "tbb >=2021.3.0", + "tbb4py" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "72fbfe77525509bdb7d0c780265a76ae", + "name": "pyomniscidbe", + "sha256": "f5241374c688dc2bd909495ced896e108472bcd9b43fd38efdcb0f727aeefe3d", + "size": 1835118, + "subdir": "linux-64", + "timestamp": 1630620961153, + "version": "5.7.0" + }, + "pyomniscidbe-5.7.0-py38h14b4db5_0_cpu.conda": { + "build": "py38h14b4db5_0_cpu", + "build_number": 0, + "depends": [ + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "omniscidbe 5.7.0 h7185ff3_0_cpu", + "pyarrow 2.*", + "python >=3.8,<3.9.0a0", + "tbb >=2021.3.0", + "tbb4py" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "4e6e5b12f3487af5472ec62145113030", + "name": "pyomniscidbe", + "sha256": "272a312514854e40d47347dc146611a22308c6c32c5090b13a5459fa6075a262", + "size": 1863812, + "subdir": "linux-64", + "timestamp": 1630621089097, + "version": "5.7.0" + }, + "pyomniscidbe-5.7.0-py39h14b4db5_0_cpu.conda": { + "build": "py39h14b4db5_0_cpu", + "build_number": 0, + "depends": [ + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "omniscidbe 5.7.0 h7185ff3_0_cpu", + "pyarrow 2.*", + "python >=3.9,<3.10.0a0", + "tbb >=2021.3.0", + "tbb4py" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "0653def33f3928cf099223fc79c021e7", + "name": "pyomniscidbe", + "sha256": "48db8a63d09a770855aeaf9588e15a4442ea911868b23031911aae2f58c9d3ee", + "size": 1852213, + "subdir": "linux-64", + "timestamp": 1630621025165, + "version": "5.7.0" + }, + "pyomniscidbe-5.7.1-py36h14b4db5_0_cpu.conda": { + "build": "py36h14b4db5_0_cpu", + "build_number": 0, + "depends": [ + "fmt >=7.1.3,<8.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "omniscidbe 5.7.1 h7185ff3_0_cpu", + "pyarrow 3.*", + "python >=3.6,<3.7.0a0", + "tbb >=2021.3.0", + "tbb4py" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "47afd79ecae283c5d93ccf3d5baee719", + "name": "pyomniscidbe", + "sha256": "9666f9b963445935ddd7f3171657f65ae699865f622af41a799e57ea8b6089fe", + "size": 1841393, + "subdir": "linux-64", + "timestamp": 1632952967572, + "version": "5.7.1" + }, + "pyomniscidbe-5.7.1-py37h14b4db5_0_cpu.conda": { + "build": "py37h14b4db5_0_cpu", + "build_number": 0, + "depends": [ + "fmt >=7.1.3,<8.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "omniscidbe 5.7.1 h7185ff3_0_cpu", + "pyarrow 3.*", + "python >=3.7,<3.8.0a0", + "tbb >=2021.3.0", + "tbb4py" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b2a649f3c221c8eee6e1468b65244f4d", + "name": "pyomniscidbe", + "sha256": "eed20a2fec9cf3a320141efa9b933d3425f45e569989101a48ed41932db38694", + "size": 1839795, + "subdir": "linux-64", + "timestamp": 1632953094578, + "version": "5.7.1" + }, + "pyomniscidbe-5.7.1-py38h14b4db5_0_cpu.conda": { + "build": "py38h14b4db5_0_cpu", + "build_number": 0, + "depends": [ + "fmt >=7.1.3,<8.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "omniscidbe 5.7.1 h7185ff3_0_cpu", + "pyarrow 3.*", + "python >=3.8,<3.9.0a0", + "tbb >=2021.3.0", + "tbb4py" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9837ac630c0313450c2fe6d70df9cfeb", + "name": "pyomniscidbe", + "sha256": "1c9177a4c02d8752ee680765725b5922d08d7eb18ccee0a8da3035d17bd02306", + "size": 1865572, + "subdir": "linux-64", + "timestamp": 1632952904217, + "version": "5.7.1" + }, + "pyomniscidbe-5.7.1-py39h14b4db5_0_cpu.conda": { + "build": "py39h14b4db5_0_cpu", + "build_number": 0, + "depends": [ + "fmt >=7.1.3,<8.0a0", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "omniscidbe 5.7.1 h7185ff3_0_cpu", + "pyarrow 3.*", + "python >=3.9,<3.10.0a0", + "tbb >=2021.3.0", + "tbb4py" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "559b44e5b4b8e13fcc8a5db4d80e6d18", + "name": "pyomniscidbe", + "sha256": "eed24a420de96fe689f18d0bafae8c8e1a185b227f171ae36bcf912517c39bdf", + "size": 1855953, + "subdir": "linux-64", + "timestamp": 1632953031135, + "version": "5.7.1" + }, + "pyopengl-3.1.1a1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-like", + "md5": "b63a061697f8afcd3ba4df44d765fda0", + "name": "pyopengl", + "sha256": "29cce05e914a05db6f1421db62d7878322b84ec94335a0886ca98dd713005b36", + "size": 1093760, + "subdir": "linux-64", + "timestamp": 1530892135745, + "version": "3.1.1a1" + }, + "pyopengl-3.1.1a1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-like", + "md5": "d0532ac99479b446fd021aaf9d6580b8", + "name": "pyopengl", + "sha256": "af9d2c580b124eefa4b6f9897f847cd71098132465e05656f7d3a3cb02f49a62", + "size": 1102405, + "subdir": "linux-64", + "timestamp": 1640793582866, + "version": "3.1.1a1" + }, + "pyopengl-3.1.1a1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-like", + "md5": "f4d03d11c6022f8783fd1df3443062dd", + "name": "pyopengl", + "sha256": "0c1a1083d1b971fc118223cfaae008fbc8234dc0d6394ed2dba66142534a6ffe", + "size": 1490629, + "subdir": "linux-64", + "timestamp": 1676845382000, + "version": "3.1.1a1" + }, + "pyopengl-3.1.1a1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-like", + "md5": "4d4b0ab069bb9c7da676c51137310ef7", + "name": "pyopengl", + "sha256": "10bc3b3931d2385d3f52ebdb9740679214b27724b892bf1dcc3edeea924baf2a", + "size": 1089302, + "subdir": "linux-64", + "timestamp": 1530892009190, + "version": "3.1.1a1" + }, + "pyopengl-3.1.1a1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-like", + "md5": "d9790a70727e6255324a9167f9c8231d", + "name": "pyopengl", + "sha256": "0766be455b140aa8b34ed33bbf4812506e32e2e141d0861a158ccc93b6e38f36", + "size": 1087069, + "subdir": "linux-64", + "timestamp": 1614326562182, + "version": "3.1.1a1" + }, + "pyopengl-3.1.1a1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-like", + "md5": "72e2b0df47df7b692df15c7cccc01d76", + "name": "pyopengl", + "sha256": "a8e2afd4e663424cba22d4087ff9063756ea2d9be9e1f40dc8fba165ab6ff88c", + "size": 1086397, + "subdir": "linux-64", + "timestamp": 1530891820241, + "version": "3.1.1a1" + }, + "pyopengl-3.1.1a1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-like", + "md5": "610a691bb6b852e02210be9db74a2c66", + "name": "pyopengl", + "sha256": "ced85d22deb0dab94023388114fe249f24f833144fd797385f946d2580390469", + "size": 1091533, + "subdir": "linux-64", + "timestamp": 1614326544799, + "version": "3.1.1a1" + }, + "pyopengl-3.1.1a1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-like", + "md5": "8146200faeaa6350a0179f5639ac35f0", + "name": "pyopengl", + "sha256": "ac31410b58db755df3a237cef69b0872ec6916a8823bba6b973c5e3a7c566c8f", + "size": 1101211, + "subdir": "linux-64", + "timestamp": 1573670156130, + "version": "3.1.1a1" + }, + "pyopengl-3.1.1a1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-like", + "md5": "15027a130f16d7715e02c73af1132186", + "name": "pyopengl", + "sha256": "dc69b194d2931da8dfecff60b8862ff5aa651aeee262f8d6f40542aacc87ecf3", + "size": 1098623, + "subdir": "linux-64", + "timestamp": 1614325984758, + "version": "3.1.1a1" + }, + "pyopengl-3.1.1a1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-like", + "md5": "4200449c625f87f975a3dd4a5515bb83", + "name": "pyopengl", + "sha256": "3a499b912e0732edbfb2dce7893135f4c7ae306f060769a52b436f9e1eef6936", + "size": 1095075, + "subdir": "linux-64", + "timestamp": 1614325982261, + "version": "3.1.1a1" + }, + "pyopengl-accelerate-3.1.3b1-py27hdd07704_0.conda": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "freeglut", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pyopengl", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "38c4637475b0c8bd46faaced49e4793d", + "name": "pyopengl-accelerate", + "sha256": "bd6602815b7ec473ea7bb31ad37124f9e8ab7a427cab6a65dee2d34cc85b1827", + "size": 315239, + "subdir": "linux-64", + "timestamp": 1539301235180, + "version": "3.1.3b1" + }, + "pyopengl-accelerate-3.1.3b1-py36hdd07704_0.conda": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "freeglut", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pyopengl", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "10a6db0c94b5523fafaeb0fa723d32d5", + "name": "pyopengl-accelerate", + "sha256": "e283fbb34e0235882772fb139f545c00d7895c9c212c96cbd6598489e18894c0", + "size": 329214, + "subdir": "linux-64", + "timestamp": 1539301216807, + "version": "3.1.3b1" + }, + "pyopengl-accelerate-3.1.3b1-py37hdd07704_0.conda": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "freeglut", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pyopengl", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "f49de441ae3d190eefc0f3c031c7bb1f", + "name": "pyopengl-accelerate", + "sha256": "b559c9fbd0af8736bc19b4795e81e523cb7b9f5dfe0705c1171ea1a33cfc270d", + "size": 329488, + "subdir": "linux-64", + "timestamp": 1539301215501, + "version": "3.1.3b1" + }, + "pyopengl-accelerate-3.1.3b1-py38hdd07704_0.conda": { + "build": "py38hdd07704_0", + "build_number": 0, + "depends": [ + "freeglut", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pyopengl", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "1c178de7958e19d4647bf399c0113cd9", + "name": "pyopengl-accelerate", + "sha256": "e6d470b3a12a2095f57f2e025597db9915eeaa924f981d48141b5412737eedfd", + "size": 354809, + "subdir": "linux-64", + "timestamp": 1574094218622, + "version": "3.1.3b1" + }, + "pyopenssl-17.2.0-py27h189ff3b_0.conda": { + "build": "py27h189ff3b_0", + "build_number": 0, + "depends": [ + "cryptography >=1.9", + "python >=2.7,<2.8.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "67aa232b6c0fd44f6235715f96e9e762", + "name": "pyopenssl", + "sha256": "6c8a2c8b9b0deee9c36f8975bcb7aa7952e68113f390e5b6ce03730c1435fb19", + "size": 79552, + "subdir": "linux-64", + "timestamp": 1505692953929, + "version": "17.2.0" + }, + "pyopenssl-17.2.0-py35h1d2a76c_0.conda": { + "build": "py35h1d2a76c_0", + "build_number": 0, + "depends": [ + "cryptography >=1.9", + "python >=3.5,<3.6.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3010c0ecd8bb943a148b15b5e2911e1a", + "name": "pyopenssl", + "sha256": "5639d5d7c311f06bbcf09c4a1ae0642bbe891d714bc26b486cb006740417726e", + "size": 80728, + "subdir": "linux-64", + "timestamp": 1505692966094, + "version": "17.2.0" + }, + "pyopenssl-17.2.0-py36h5cc804b_0.conda": { + "build": "py36h5cc804b_0", + "build_number": 0, + "depends": [ + "cryptography >=1.9", + "python >=3.6,<3.7.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "46a675d72d0708a902d3e64760914481", + "name": "pyopenssl", + "sha256": "16a0772bc89033b153c9bd0a07cc68598db91a7002c850d5c4a8ca3f40a59f95", + "size": 80194, + "subdir": "linux-64", + "timestamp": 1505692978201, + "version": "17.2.0" + }, + "pyopenssl-17.4.0-py27h3149609_0.conda": { + "build": "py27h3149609_0", + "build_number": 0, + "depends": [ + "cryptography >=1.9", + "python >=2.7,<2.8.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7208cf6510fff24cc8d47975f817c337", + "name": "pyopenssl", + "sha256": "cd552548a994eacfdd778684dab780545895739ebf2a43a20b084704ecb6c2f2", + "size": 81136, + "subdir": "linux-64", + "timestamp": 1512039538759, + "version": "17.4.0" + }, + "pyopenssl-17.4.0-py35hb50ab36_0.conda": { + "build": "py35hb50ab36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.9", + "python >=3.5,<3.6.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3f48ea1272ba0cfb38993079c66c05d9", + "name": "pyopenssl", + "sha256": "eff1464abd2646484e24008ec36fda1cd8a8e248c2190a5f202d1a753f6c312e", + "size": 82503, + "subdir": "linux-64", + "timestamp": 1512039539051, + "version": "17.4.0" + }, + "pyopenssl-17.4.0-py36ha353062_0.conda": { + "build": "py36ha353062_0", + "build_number": 0, + "depends": [ + "cryptography >=1.9", + "python >=3.6,<3.7.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bb2f73222706dd45632a395d344cacd8", + "name": "pyopenssl", + "sha256": "1201c086825413736231dda7bcc30f4283e5c86e4563d4660f9cfdc0a7f34ec5", + "size": 80123, + "subdir": "linux-64", + "timestamp": 1512039577326, + "version": "17.4.0" + }, + "pyopenssl-17.5.0-py27hcee3be0_0.conda": { + "build": "py27hcee3be0_0", + "build_number": 0, + "depends": [ + "cryptography >=2.1.4", + "python >=2.7,<2.8.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4fa9214fb783c6f635dca085bd78c6b3", + "name": "pyopenssl", + "sha256": "c4e9f869a6db1c699fca63192bdaa5961d70808e77ef7258bdf5c8a2155e26f8", + "size": 82541, + "subdir": "linux-64", + "timestamp": 1512209094217, + "version": "17.5.0" + }, + "pyopenssl-17.5.0-py35h4f8b8c8_0.conda": { + "build": "py35h4f8b8c8_0", + "build_number": 0, + "depends": [ + "cryptography >=2.1.4", + "python >=3.5,<3.6.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c771807b76da926d62097af6e6b799a1", + "name": "pyopenssl", + "sha256": "ef394bb86ae9b3f710b6191344b8cfb253c324994eac2161a564a0ed73407176", + "size": 84015, + "subdir": "linux-64", + "timestamp": 1512209100107, + "version": "17.5.0" + }, + "pyopenssl-17.5.0-py36h20ba746_0.conda": { + "build": "py36h20ba746_0", + "build_number": 0, + "depends": [ + "cryptography >=2.1.4", + "python >=3.6,<3.7.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7ef79624c1d4f2f4c263f21fc8071def", + "name": "pyopenssl", + "sha256": "eb9b517c51176773613ee1f4681da5d25e9888d9457ec53f52ad5ab6c11cf6ba", + "size": 83233, + "subdir": "linux-64", + "timestamp": 1512209109137, + "version": "17.5.0" + }, + "pyopenssl-18.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=2.2.1", + "python >=2.7,<2.8.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "141bff671ae5c9296e20ea3f53ead966", + "name": "pyopenssl", + "sha256": "ce1b03cba849ec169f174928cf769117095eae85f823dcb18e2585ca33013630", + "size": 86397, + "subdir": "linux-64", + "timestamp": 1526617759133, + "version": "18.0.0" + }, + "pyopenssl-18.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography >=2.2.1", + "python >=3.5,<3.6.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "811568d10eb0c4a7aee3938ef9ec7a48", + "name": "pyopenssl", + "sha256": "797b21f2eb1bd74a598dac292c4148fb087f4f93e175ffa007a9bb5ee2a2b2e4", + "size": 87659, + "subdir": "linux-64", + "timestamp": 1526617799379, + "version": "18.0.0" + }, + "pyopenssl-18.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=2.2.1", + "python >=3.6,<3.7.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bfe8174e4e2c225c049c16de55c940a2", + "name": "pyopenssl", + "sha256": "603c645573e9daa128a6c5ea70a726d28459e1a1e998956f56c223fbd117eec0", + "size": 87161, + "subdir": "linux-64", + "timestamp": 1526617732222, + "version": "18.0.0" + }, + "pyopenssl-18.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=2.2.1", + "python >=3.7,<3.8.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "55dcbf3623f49de0c77d3fc9523154ae", + "name": "pyopenssl", + "sha256": "b3e2ea72e39f9b2435b6af7492127d99140b52e07289b50bcf43307ca7d65b9c", + "size": 87181, + "subdir": "linux-64", + "timestamp": 1530733418334, + "version": "18.0.0" + }, + "pyopenssl-19.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=2.2.1", + "python >=2.7,<2.8.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "45bc765713499489f09139637df846ed", + "name": "pyopenssl", + "sha256": "8165ee47ee29e281eb0452994e504a8c46156050a5ab610498faa8a082b29465", + "size": 83426, + "subdir": "linux-64", + "timestamp": 1549324484847, + "version": "19.0.0" + }, + "pyopenssl-19.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=2.2.1", + "python >=3.6,<3.7.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8337189d9fa1dd71d21c13505c4d1dea", + "name": "pyopenssl", + "sha256": "09c5c5f8fc08137a08d16bc41214dfcf0484b37ba7cfe69930d4a8cb798b1d3c", + "size": 84089, + "subdir": "linux-64", + "timestamp": 1549320612156, + "version": "19.0.0" + }, + "pyopenssl-19.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=2.2.1", + "python >=3.7,<3.8.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2b0ad8783e2cf6420bca2c4a6e1005b2", + "name": "pyopenssl", + "sha256": "78d6e9c8837585e6dc74f0592a10171c6d446db7b39cfebb8e33b2d69b2e551c", + "size": 85925, + "subdir": "linux-64", + "timestamp": 1549320564648, + "version": "19.0.0" + }, + "pyopenssl-19.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cryptography >=2.2.1", + "python >=3.8,<3.9.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "320d50c0b3451c6e3916b0df8f71eeea", + "name": "pyopenssl", + "sha256": "0ad96782619b82058f8c4dc476a9c40586dba5833d6ac97f3e7b03c2b55bdaf2", + "size": 86390, + "subdir": "linux-64", + "timestamp": 1572857247102, + "version": "19.0.0" + }, + "pyopenssl-19.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=2.8", + "python >=2.7,<2.8.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a84c2cc112936696e18e6b1194e61687", + "name": "pyopenssl", + "sha256": "896a015bf5df98050d42737b252cf042884e81c54da34a58574c0815736ea98b", + "size": 88137, + "subdir": "linux-64", + "timestamp": 1574266649282, + "version": "19.1.0" + }, + "pyopenssl-19.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=2.8", + "python >=3.6,<3.7.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a9c212e8a6b99ce1be7631bc6602ba12", + "name": "pyopenssl", + "sha256": "8a129f47d079022c0b74e1b82c40fd63f75cb57a173fccd5a78f2fde8c0c3ea4", + "size": 89002, + "subdir": "linux-64", + "timestamp": 1574266587937, + "version": "19.1.0" + }, + "pyopenssl-19.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=2.8", + "python >=3.7,<3.8.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "455efe809b48a9d1afd9891564351c0c", + "name": "pyopenssl", + "sha256": "f15e9d4bd6eaf039492ba96dd839b09531dac9b377d82ffc2515be8b20abbd68", + "size": 89149, + "subdir": "linux-64", + "timestamp": 1574266655259, + "version": "19.1.0" + }, + "pyopenssl-19.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cryptography >=2.8", + "python >=3.8,<3.9.0a0", + "six >=1.5.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c6d2e2b7f5bdb5516e92e4da5e0b4fbe", + "name": "pyopenssl", + "sha256": "5dd6877dc389245dfd27a61972f35e254981553f42718114908db776801b8619", + "size": 89699, + "subdir": "linux-64", + "timestamp": 1574266592248, + "version": "19.1.0" + }, + "pyopenssl-23.0.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=38.0.0,<40", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "be4c8fd04572aabe5c4cf6f80cfcb1b8", + "name": "pyopenssl", + "sha256": "954ff44b911699dc63ffb5ab94ee4f53306161b0b86a6ec23d744bcf5a3cb0d6", + "size": 99137, + "subdir": "linux-64", + "timestamp": 1677607766376, + "version": "23.0.0" + }, + "pyopenssl-23.0.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=38.0.0,<40", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3ba9d6d2f74e89aa80e5bae3966f3a43", + "name": "pyopenssl", + "sha256": "8a6259e4fd9573aad3d763c8bf9c8f3319f7fc7cc3297ec613f02be41261ed27", + "size": 124725, + "subdir": "linux-64", + "timestamp": 1678965327040, + "version": "23.0.0" + }, + "pyopenssl-23.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=38.0.0,<40", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7fb230aa1a02eb78bc26283d5c3215db", + "name": "pyopenssl", + "sha256": "e6d94969b1305a96bb159541c755066946be5c17dad2fcee40ece58c58a8d2e6", + "size": 98042, + "subdir": "linux-64", + "timestamp": 1677607715479, + "version": "23.0.0" + }, + "pyopenssl-23.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=38.0.0,<40", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3f667b964a242e8c4463935ea3a3331e", + "name": "pyopenssl", + "sha256": "61be10e7ce0b3425dbbb0b51c7e80f920788ce42f4c586698db0235338855a1c", + "size": 98553, + "subdir": "linux-64", + "timestamp": 1677607791388, + "version": "23.0.0" + }, + "pyopenssl-23.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=38.0.0,<40", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9043b6369acf9a81d7156404c0b38806", + "name": "pyopenssl", + "sha256": "94eea95dbce0cbae6897d4a2bd51694c75963d0387a9506f5cdbe713bf9c1f47", + "size": 98329, + "subdir": "linux-64", + "timestamp": 1677607740909, + "version": "23.0.0" + }, + "pypandoc-1.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pandoc", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "55acc6e8514d900a017b2e6c27d59a09", + "name": "pypandoc", + "sha256": "fd661bdd79cc7c70ab1ed2b00d03879b9e24a3b0e8a926cb6a6063afd8c9c9b0", + "size": 24097, + "subdir": "linux-64", + "timestamp": 1530919978851, + "version": "1.4" + }, + "pypandoc-1.4-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pandoc", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5baad3f8efa3438a10c17d55fdfedef1", + "name": "pypandoc", + "sha256": "86ffba8f90b7a63cb949390a6095c1619a2d031ed3ca57783a25886b64a43e60", + "size": 27631, + "subdir": "linux-64", + "timestamp": 1539183960017, + "version": "1.4" + }, + "pypandoc-1.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pandoc", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d9ce28a0b4a8b62dc28881b3b6b9bc8e", + "name": "pypandoc", + "sha256": "c1c6646572f78ed53635e14152f80d3381507a86db6111ae6b23a0d5b50b0628", + "size": 23881, + "subdir": "linux-64", + "timestamp": 1530919921131, + "version": "1.4" + }, + "pypandoc-1.4-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pandoc", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e2204af3548361d140a274462750c8cb", + "name": "pypandoc", + "sha256": "5037726be1395e759030e53cc98a180d698d43548e7f8b6bbf25c32ab9822de6", + "size": 27559, + "subdir": "linux-64", + "timestamp": 1539183989457, + "version": "1.4" + }, + "pypandoc-1.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pandoc", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "82ac40199fb9bac87953e52d3114ad09", + "name": "pypandoc", + "sha256": "4b8e2bca275da7f399dd239858164aaabb398bf242b6fbc83c5d8f535d351015", + "size": 24096, + "subdir": "linux-64", + "timestamp": 1530919950280, + "version": "1.4" + }, + "pypandoc-1.4-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pandoc", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "75747a2629a53616ecfc44e4837c3cc0", + "name": "pypandoc", + "sha256": "a06d243fe26c30dda9633d4e20cff57af137d5556d44ff7b6f59c7d3f269cb40", + "size": 27663, + "subdir": "linux-64", + "timestamp": 1539183982358, + "version": "1.4" + }, + "pyparsing-2.2.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f339ab2577b397932657affb33a271a0", + "name": "pyparsing", + "sha256": "23a89a333ceb361a59ff49f736b6bd7ad951780b178718e5d53ffef7d8d99708", + "size": 97945, + "subdir": "linux-64", + "timestamp": 1530694938918, + "version": "2.2.0" + }, + "pyparsing-2.2.0-py27hf1513f8_1.conda": { + "build": "py27hf1513f8_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e718416e60ded459cd0770f2ec8d2ef1", + "name": "pyparsing", + "sha256": "a79e59fdb400836cc983523810d36fa0548d1a0e8ffadce87060040c248c8373", + "size": 97704, + "subdir": "linux-64", + "timestamp": 1505733480948, + "version": "2.2.0" + }, + "pyparsing-2.2.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "b399fa3574f38f1603cf9e6cee57a6ac", + "name": "pyparsing", + "sha256": "70a550a88692fce495c597e8c9a09f7ece936fcfc27e14df04d7b35d5f97cc1b", + "size": 100174, + "subdir": "linux-64", + "timestamp": 1534345458213, + "version": "2.2.0" + }, + "pyparsing-2.2.0-py35h041ed72_1.conda": { + "build": "py35h041ed72_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "a3e614feddebd442be15a9f4e67c9e24", + "name": "pyparsing", + "sha256": "f1a8e5d076908cef959c232e9ef104a0070ee96969f9de8ea981322960d56760", + "size": 95905, + "subdir": "linux-64", + "timestamp": 1505733492733, + "version": "2.2.0" + }, + "pyparsing-2.2.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6d8761eac93688f2f97c36f546f82568", + "name": "pyparsing", + "sha256": "787ecbd141adb5c39b85276b2032372cc901ba755acc21d9f6fd06f15eb02066", + "size": 99456, + "subdir": "linux-64", + "timestamp": 1530694901316, + "version": "2.2.0" + }, + "pyparsing-2.2.0-py36hee85983_1.conda": { + "build": "py36hee85983_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4d88c138367d50fd64a4f91002e04e8c", + "name": "pyparsing", + "sha256": "184082c4b1d8b37855b09038812676d29c2875d160b252428ffc117008394181", + "size": 95372, + "subdir": "linux-64", + "timestamp": 1505733504669, + "version": "2.2.0" + }, + "pyparsing-2.2.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3136edc1e87808539e4255ace2839205", + "name": "pyparsing", + "sha256": "6088612b9d2ab04f8b7988519556fa8962b344ee462f169b0db84842f64cfc93", + "size": 99730, + "subdir": "linux-64", + "timestamp": 1530694920560, + "version": "2.2.0" + }, + "pyparsing-2.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "931eed5bce06e1e84a1395e7926635d7", + "name": "pyparsing", + "sha256": "db8111359572f530eb1f2530e8d19798a8de0d79bbe3adf3fb5793635df44847", + "size": 96834, + "subdir": "linux-64", + "timestamp": 1538231886832, + "version": "2.2.1" + }, + "pyparsing-2.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "b580d46915faebcc236539de86987633", + "name": "pyparsing", + "sha256": "f55da95a13edee18009dab4d84892c0e986c851ebec9835723b813e2edaeb285", + "size": 95136, + "subdir": "linux-64", + "timestamp": 1538231896327, + "version": "2.2.1" + }, + "pyparsing-2.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "af7563ec91bb8a2d3b30996109c0abfa", + "name": "pyparsing", + "sha256": "3424e2b13c675212ac49adb4f0ce0c437708762e01424459899b96e38f39ab4e", + "size": 94236, + "subdir": "linux-64", + "timestamp": 1538231882848, + "version": "2.2.1" + }, + "pyparsing-2.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d2de8493a48219e7aa44de04f0209e7e", + "name": "pyparsing", + "sha256": "89db256cf1a1f21718c749049113afa0ee8397117cf97bd19267926dd45c9a8c", + "size": 94360, + "subdir": "linux-64", + "timestamp": 1538231849801, + "version": "2.2.1" + }, + "pyparsing-2.2.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "16c2f93979cd920728ee6f7575b2be04", + "name": "pyparsing", + "sha256": "359568bc223c2c1ffdb32dc5215519fd6328a1f884da685b96c2e04f658ec7fa", + "size": 99193, + "subdir": "linux-64", + "timestamp": 1539023711959, + "version": "2.2.2" + }, + "pyparsing-2.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "177eccf18f8613d06d0d507e1163b30c", + "name": "pyparsing", + "sha256": "58f2930f625d51bc69f8a171cd45cbe17af2c3833863b4c5a3a497d0f2fd6a16", + "size": 100611, + "subdir": "linux-64", + "timestamp": 1539023732310, + "version": "2.2.2" + }, + "pyparsing-2.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ab9cf8d9d824e6774d9e221170242eed", + "name": "pyparsing", + "sha256": "8640bd8e7b2c39cfa3ea6e6039e5e407c3e985950edd89daecf5010a7df28e58", + "size": 96637, + "subdir": "linux-64", + "timestamp": 1539023673569, + "version": "2.2.2" + }, + "pyparsing-2.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "2bbda4b7c36318e9dfb9a7d77c0c9062", + "name": "pyparsing", + "sha256": "29c4742bc678e8c2e56e7f81524b92489d27d4819a5842cf80af9d2d1869697d", + "size": 102637, + "subdir": "linux-64", + "timestamp": 1541449664875, + "version": "2.3.0" + }, + "pyparsing-2.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "debeb0be5e61b1063a4971d4e9a4f6c1", + "name": "pyparsing", + "sha256": "d0fb3645cf91e3ad4c278c3c60a3d1f8793f22f3affe26eaf795cd87f83dcbf6", + "size": 104035, + "subdir": "linux-64", + "timestamp": 1541449692701, + "version": "2.3.0" + }, + "pyparsing-2.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f6c8122ec4f5bc0b8583be4b6b6e444e", + "name": "pyparsing", + "sha256": "6982ceb85ca8689c8740b07986e87780beff174880c9763c1156ae0429eadcd4", + "size": 100279, + "subdir": "linux-64", + "timestamp": 1541449615610, + "version": "2.3.0" + }, + "pyparsing-2.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "eeb28484652666cfdcb8787bc806a70d", + "name": "pyparsing", + "sha256": "16489400c4930d0a9ec3dc54e05065459c767c46a535e0a6000a2b57ec8af37e", + "size": 100756, + "subdir": "linux-64", + "timestamp": 1547905235180, + "version": "2.3.1" + }, + "pyparsing-2.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2757374e5b02fcc515568afd5a2349d3", + "name": "pyparsing", + "sha256": "4b05f7d2f2605893129958e306d07fd3db265c8034815ff398b30f582695dee9", + "size": 104226, + "subdir": "linux-64", + "timestamp": 1547905283848, + "version": "2.3.1" + }, + "pyparsing-2.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3e06910852d37127b5fe3cf04112aa47", + "name": "pyparsing", + "sha256": "848bc993a8db0a4733cf2a3f8db0512b977dae2e9110579fd9bf5460be30a079", + "size": 102091, + "subdir": "linux-64", + "timestamp": 1547905315034, + "version": "2.3.1" + }, + "pyparsing-3.0.9-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9fe9a752c6c332f482b3a7ea5bfdad3", + "name": "pyparsing", + "sha256": "51d91572177b29deb88a0ffa070a2fe34151d41a91d747833fd988cdf1d446e5", + "size": 156462, + "subdir": "linux-64", + "timestamp": 1661452647484, + "version": "3.0.9" + }, + "pyparsing-3.0.9-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0226abf73d27eb89e3bea74f1cf3123f", + "name": "pyparsing", + "sha256": "365aef544a37bdcf3a80f6ae4b613e67cc54aa5e8fceae80534d333fe5be2883", + "size": 208735, + "subdir": "linux-64", + "timestamp": 1677811584327, + "version": "3.0.9" + }, + "pyparsing-3.0.9-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "853104fc62713a3c01eeef2b1c276264", + "name": "pyparsing", + "sha256": "d16a1817782e60cf906a6921ad4c4f804734fa21cb821e337622cbfbb4e2b7ef", + "size": 153528, + "subdir": "linux-64", + "timestamp": 1661452674259, + "version": "3.0.9" + }, + "pyparsing-3.0.9-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "becbbf51d2b05de228eed968e20f963d", + "name": "pyparsing", + "sha256": "64cb7d0d826fd399fdfc1a41fa04df6e99681f60e4cc4e821dd83e4ffa7f43db", + "size": 155148, + "subdir": "linux-64", + "timestamp": 1661452605147, + "version": "3.0.9" + }, + "pyparsing-3.0.9-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a0537468e59760404f63b4f04369828", + "name": "pyparsing", + "sha256": "9423621a998a5b3760ec86c6fd9c4bd7335bedc244d89aea5803ceaf154e1e83", + "size": 154490, + "subdir": "linux-64", + "timestamp": 1661452578573, + "version": "3.0.9" + }, + "pypdf2-2.10.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "411d9c1e537632077f7e3e2ed6581fce", + "name": "pypdf2", + "sha256": "834ec61a9a5e83ffecdefad0c24873a2f22d35ae84693afc06d694048e839e7f", + "size": 450608, + "subdir": "linux-64", + "timestamp": 1662469771462, + "version": "2.10.5" + }, + "pypdf2-2.10.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3bc4435b573f874336cab79e45d08ad6", + "name": "pypdf2", + "sha256": "544070162dcbfb6c31897f9be5306d044c5de1434e9e84e8cb026dfc9a97c27a", + "size": 510622, + "subdir": "linux-64", + "timestamp": 1679340434145, + "version": "2.10.5" + }, + "pypdf2-2.10.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.10" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7254bac842f64374c04862342dce32e0", + "name": "pypdf2", + "sha256": "d7073ccc3fbb91c8fae28138970848274dd08e21f8251a73b76c3a29e03f80d8", + "size": 364937, + "subdir": "linux-64", + "timestamp": 1662469834085, + "version": "2.10.5" + }, + "pypdf2-2.10.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "typing_extensions >=3.10" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2716a0040b97f80382b3f26293171e17", + "name": "pypdf2", + "sha256": "b172997510308642a1b46c8b504fc296a551d5066c588bfd48bfc795f50de276", + "size": 366196, + "subdir": "linux-64", + "timestamp": 1662469719719, + "version": "2.10.5" + }, + "pypdf2-2.10.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "typing_extensions >=3.10" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5dedd9128b64fa44e85a8d23113b5b30", + "name": "pypdf2", + "sha256": "bee8c484cda1b16d4fc9676a4ad2f945992e48e628f9a1e600b367203454884a", + "size": 366140, + "subdir": "linux-64", + "timestamp": 1662469803867, + "version": "2.10.5" + }, + "pyppmd-0.16.1-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "6800d366a8ef09d54cd06a32ff97a439", + "name": "pyppmd", + "sha256": "a6df2e4b5dcc796292f993df8b93312c5eabbd0d11390abb0aea0ce0c64e39a5", + "size": 100230, + "subdir": "linux-64", + "timestamp": 1640810432412, + "version": "0.16.1" + }, + "pyppmd-0.16.1-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "77c30b3401e9c38538711f3725fa8cd2", + "name": "pyppmd", + "sha256": "d89c51a12b77cad9fce7d15f67a16f38f12400ec00c69833b31eb1b801f097ea", + "size": 43171, + "subdir": "linux-64", + "timestamp": 1676861044874, + "version": "0.16.1" + }, + "pyppmd-0.16.1-py36h295c915_0.conda": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d2b7321d1fd48163c086c6d5f02508de", + "name": "pyppmd", + "sha256": "92d8708958f886a4d6c508c790086034f12b199371e3018bd2ee4189b4bf50bc", + "size": 42174, + "subdir": "linux-64", + "timestamp": 1633095397290, + "version": "0.16.1" + }, + "pyppmd-0.16.1-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "4873784776dd0a8526f6e32eb5ce5da6", + "name": "pyppmd", + "sha256": "8466f1a6b6a7b850bbe222b6b9e1992e6c5681c4775ca64ad144bb0084feccc8", + "size": 42221, + "subdir": "linux-64", + "timestamp": 1633084854596, + "version": "0.16.1" + }, + "pyppmd-0.16.1-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "0cc2dbde6c746f0fb3fb0985a3093ba4", + "name": "pyppmd", + "sha256": "e434f900cd554cafe2bd08fdb3d4fa19af678fca37729f64f538bf39b4fc6180", + "size": 42467, + "subdir": "linux-64", + "timestamp": 1633095378665, + "version": "0.16.1" + }, + "pyppmd-0.16.1-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "72d243bb3d174c9d451c878319f757bf", + "name": "pyppmd", + "sha256": "f9969a924a539b6c45014591fa5b702921afdf4e3405b0806fc3e2db1c91269b", + "size": 42388, + "subdir": "linux-64", + "timestamp": 1633095372072, + "version": "0.16.1" + }, + "pyprof2calltree-1.4.3-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "qcachegrind" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e6b6fce0c60648208fc5cdcda341634", + "name": "pyprof2calltree", + "sha256": "47a914e8eba19df24cae80bddb277207d62f4e8b423b85e22e3d39918eaae19b", + "size": 15602, + "subdir": "linux-64", + "timestamp": 1539290058904, + "version": "1.4.3" + }, + "pyprof2calltree-1.4.3-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "qcachegrind" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d255d32d74f16efe28405a35b0afd16", + "name": "pyprof2calltree", + "sha256": "e779994a68047bd7af9826b1313611db791204b663752e4ab41804b3d7898845", + "size": 15395, + "subdir": "linux-64", + "timestamp": 1539290066597, + "version": "1.4.3" + }, + "pyprof2calltree-1.4.3-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "qcachegrind" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9755fcdcda930f5350c73c718828a68", + "name": "pyprof2calltree", + "sha256": "ce6c2032251768b5a4188582ba68175bae1fa912dc6b9572239c895b9ebe7030", + "size": 15552, + "subdir": "linux-64", + "timestamp": 1539290064193, + "version": "1.4.3" + }, + "pyprof2calltree-1.4.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "qcachegrind" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "30cccfeb2b1f07b153073907ca42ff9c", + "name": "pyprof2calltree", + "sha256": "8c3b00ecdd36686f45c4d2c41bdbb7689593bc7f79c221c73351c310a0434015", + "size": 15982, + "subdir": "linux-64", + "timestamp": 1541026740920, + "version": "1.4.4" + }, + "pyprof2calltree-1.4.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "qcachegrind" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d15b56f81641dc25eb5b152357edde5b", + "name": "pyprof2calltree", + "sha256": "b05cb5055a75348b24c36f80daf6f5a7b540a7839140b2d7c5eae42798214ce8", + "size": 16253, + "subdir": "linux-64", + "timestamp": 1640793604784, + "version": "1.4.4" + }, + "pyprof2calltree-1.4.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "qcachegrind" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a921d3a2c63ed63cac4b363efce8895a", + "name": "pyprof2calltree", + "sha256": "15e5c36815d2e64187c1a54105fd06194557cdc82d92a149b55b1ec90e7308b6", + "size": 19779, + "subdir": "linux-64", + "timestamp": 1676907569065, + "version": "1.4.4" + }, + "pyprof2calltree-1.4.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "qcachegrind" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "19f3a377a10071e9a6bd307eb4a5e7f2", + "name": "pyprof2calltree", + "sha256": "a3372b5b243270a6b73e5d263f3c2654b3d29e6bd05f9e074ca8569bc42de61c", + "size": 15840, + "subdir": "linux-64", + "timestamp": 1541026717011, + "version": "1.4.4" + }, + "pyprof2calltree-1.4.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "qcachegrind" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e82d14506a01a5226f697c1be2f2f31", + "name": "pyprof2calltree", + "sha256": "e2745937e74fbae2a4b91dcff31f625c0351e65aed24097ad349315e6fc3e3a3", + "size": 15849, + "subdir": "linux-64", + "timestamp": 1541026734883, + "version": "1.4.4" + }, + "pyprof2calltree-1.4.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "qcachegrind" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d29e9b987a73f13e6d4bbe7c6196b53", + "name": "pyprof2calltree", + "sha256": "31c279f0eef433ffd96bb1bf7626e16cd3a3f00588d587d10e4996a276d58f81", + "size": 16121, + "subdir": "linux-64", + "timestamp": 1573200338885, + "version": "1.4.4" + }, + "pyproj-1.9.5.1-py27h14380d9_1.conda": { + "build": "py27h14380d9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "proj4 >=5.2.0,<5.2.1.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "OSI", + "md5": "62330d584a0cf1bbb04a46a0c5eeb8a2", + "name": "pyproj", + "sha256": "bac6600ce145548876fdea02e663b42c88f61e2bcfd0d1173559edd4aa58095a", + "size": 58843, + "subdir": "linux-64", + "timestamp": 1545264719413, + "version": "1.9.5.1" + }, + "pyproj-1.9.5.1-py27h7b21b82_1.conda": { + "build": "py27h7b21b82_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy", + "proj4 >=5.0.1,<5.0.2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "OSI", + "md5": "28a0561f104ce126bfdecf7dd884db99", + "name": "pyproj", + "sha256": "f0b9ca360739c2234d64fd378ea67a527b197a533c3f2b866161b9f48f588ec8", + "size": 59000, + "subdir": "linux-64", + "timestamp": 1530811272907, + "version": "1.9.5.1" + }, + "pyproj-1.9.5.1-py35h7b21b82_1.conda": { + "build": "py35h7b21b82_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "proj4 >=5.1.0,<5.1.1.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "OSI", + "md5": "62f6d4d7f21330212d45e74c1ee480e5", + "name": "pyproj", + "sha256": "997fae288c05f394f8296179a40b1c28c252aadd542a76b4b1c88993c93dcee6", + "size": 59937, + "subdir": "linux-64", + "timestamp": 1535129635135, + "version": "1.9.5.1" + }, + "pyproj-1.9.5.1-py35h9d585cc_1.conda": { + "build": "py35h9d585cc_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "proj4 >=5.1.0,<5.1.1.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "OSI", + "md5": "2ee6afc7e45e3a22042bb926fe88b3c0", + "name": "pyproj", + "sha256": "806f04cb76b2387f28b7cd6a75254be8e6e5771b60c93e9c6908f77288d67ffe", + "size": 59929, + "subdir": "linux-64", + "timestamp": 1536267996442, + "version": "1.9.5.1" + }, + "pyproj-1.9.5.1-py36h14380d9_1.conda": { + "build": "py36h14380d9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "proj4 >=5.2.0,<5.2.1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "OSI", + "md5": "239a014ec18bc61f904f1a98230115c6", + "name": "pyproj", + "sha256": "bd37272fe1247681dd1135e37d55b3f7070426144656a3fb89d967a273d65dc9", + "size": 60621, + "subdir": "linux-64", + "timestamp": 1545264826743, + "version": "1.9.5.1" + }, + "pyproj-1.9.5.1-py36h7b21b82_1.conda": { + "build": "py36h7b21b82_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy", + "proj4 >=5.0.1,<5.0.2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "OSI", + "md5": "0d31fff72c6687ac9237d84f818d9d0c", + "name": "pyproj", + "sha256": "39e07a3be91a01fef5bd5e36b90843c269abfc3ea518b2d80726eeebaf687f4e", + "size": 60955, + "subdir": "linux-64", + "timestamp": 1530811336911, + "version": "1.9.5.1" + }, + "pyproj-1.9.5.1-py37h14380d9_1.conda": { + "build": "py37h14380d9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "proj4 >=5.2.0,<5.2.1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "OSI", + "md5": "44f8cbaaebee60c9c94a4b6558186e03", + "name": "pyproj", + "sha256": "0664e52a7ce876bde33120aee57589ef51009da90840f6066ba772c68d40a08a", + "size": 60588, + "subdir": "linux-64", + "timestamp": 1545264825228, + "version": "1.9.5.1" + }, + "pyproj-1.9.5.1-py37h7b21b82_1.conda": { + "build": "py37h7b21b82_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy", + "proj4 >=5.0.1,<5.0.2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "OSI", + "md5": "7b30b1d3d5b8e95bfb782ecde9239737", + "name": "pyproj", + "sha256": "3dc3f816e72414e2aaab1b8378dc19733b95f68c096b5c30d6a7b1493696742e", + "size": 59749, + "subdir": "linux-64", + "timestamp": 1530811304720, + "version": "1.9.5.1" + }, + "pyproj-1.9.6-py27h14380d9_0.conda": { + "build": "py27h14380d9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "proj4 >=5.2.0,<5.2.1.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "OSI", + "md5": "36002d955cd51af1d9a36bce234fe1a6", + "name": "pyproj", + "sha256": "66c8b5e00cd6fc481d2ae4c4389b57650b6bc86c9f438b014896420c5cfee191", + "size": 70760, + "subdir": "linux-64", + "timestamp": 1547929493227, + "version": "1.9.6" + }, + "pyproj-1.9.6-py36h14380d9_0.conda": { + "build": "py36h14380d9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "proj4 >=5.2.0,<5.2.1.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "OSI", + "md5": "8838431d78872dcdcd464e653a772344", + "name": "pyproj", + "sha256": "63734b1d0bae0ec1676bf91cf7f905dcf4bb84a75c31beb6634123db90d20678", + "size": 71293, + "subdir": "linux-64", + "timestamp": 1547929495830, + "version": "1.9.6" + }, + "pyproj-1.9.6-py37h14380d9_0.conda": { + "build": "py37h14380d9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "proj4 >=5.2.0,<5.2.1.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "OSI", + "md5": "79e6da7fde7a89225cc8c76ceadbef10", + "name": "pyproj", + "sha256": "4e3e4214c049ea6d5ec9196a07f2654ee3ada9dafe3308afe611afbbc028c290", + "size": 70990, + "subdir": "linux-64", + "timestamp": 1547929489831, + "version": "1.9.6" + }, + "pyproj-1.9.6-py38h14380d9_0.conda": { + "build": "py38h14380d9_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy", + "proj4 >=5.2.0,<5.2.1.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "OSI", + "md5": "ae7b2cc5c21b8ff7d23dd460efe7e4e4", + "name": "pyproj", + "sha256": "5c660f68e72f995cc9513af2816e3c61ce3cff6152675b7cf18888a075b7f844", + "size": 73364, + "subdir": "linux-64", + "timestamp": 1574094254122, + "version": "1.9.6" + }, + "pyproj-2.4.1-py36h2ea87da_0.conda": { + "build": "py36h2ea87da_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "OSI", + "md5": "c3d710109b1a0ab6495e5dadbf558243", + "name": "pyproj", + "sha256": "86b0ee5113217096bb3a8cc07153e8953ad21ba2aa0c2c09d908d96e222942b7", + "size": 323498, + "subdir": "linux-64", + "timestamp": 1573751373007, + "version": "2.4.1" + }, + "pyproj-2.4.1-py37h2ea87da_0.conda": { + "build": "py37h2ea87da_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "OSI", + "md5": "ae368f732009908059d8558b8242f6a6", + "name": "pyproj", + "sha256": "c112d78399b3386771c07690a706e3ecaf51548a0d782a7b050713e69d40ac91", + "size": 321399, + "subdir": "linux-64", + "timestamp": 1573751237144, + "version": "2.4.1" + }, + "pyproj-2.4.1-py38h2ea87da_0.conda": { + "build": "py38h2ea87da_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "OSI", + "md5": "ce7f6e7b4601667097645b766669e53e", + "name": "pyproj", + "sha256": "534b0e1bfbf773ce73fa70b6e0bfcd0516a5bb051d823b80d690fa6c49354882", + "size": 335909, + "subdir": "linux-64", + "timestamp": 1573751370019, + "version": "2.4.1" + }, + "pyproj-2.6.0-py36hd003209_1.conda": { + "build": "py36hd003209_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "OSI", + "md5": "3ba7a97ec979b48736d02e9c64b7e4bf", + "name": "pyproj", + "sha256": "e0f950ac25cd5cb794dae0a0ab2eba2b43fd749362f7c2be96781d4447ba2b12", + "size": 383602, + "subdir": "linux-64", + "timestamp": 1587483323404, + "version": "2.6.0" + }, + "pyproj-2.6.0-py37hd003209_1.conda": { + "build": "py37hd003209_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "OSI", + "md5": "b956be6b8a1b38f31f5bfcee3e1a3500", + "name": "pyproj", + "sha256": "890577ccf71661c43fd07672e9be76cfc4db57aec9a3e3de9d82dac79702aae2", + "size": 381955, + "subdir": "linux-64", + "timestamp": 1587483302569, + "version": "2.6.0" + }, + "pyproj-2.6.0-py38hd003209_1.conda": { + "build": "py38hd003209_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "OSI", + "md5": "479dd50cd72b40009c80c432e31fb6d9", + "name": "pyproj", + "sha256": "33c86fafcc803513af47218414b69ce307ab79c93047dfc966f0887f51ac22a5", + "size": 402110, + "subdir": "linux-64", + "timestamp": 1587483784616, + "version": "2.6.0" + }, + "pyproj-2.6.1.post1-py36h61f852b_1.conda": { + "build": "py36h61f852b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=7.0.1,<7.0.2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f02e259663470cc1268dc16f1783fdbd", + "name": "pyproj", + "sha256": "59ed81a7a6a3d096d098d7f7d8caae5dbafab6d164a43dc7d59f5e1c8b503a37", + "size": 398253, + "subdir": "linux-64", + "timestamp": 1590593838575, + "version": "2.6.1.post1" + }, + "pyproj-2.6.1.post1-py36hb3025e9_1.conda": { + "build": "py36hb3025e9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "70736e4418a82df852fc61c2ca144f72", + "name": "pyproj", + "sha256": "411a81de628b994b2c9242ef9600b0976f1c58d3c846c8bbe6407d24a82ea849", + "size": 399718, + "subdir": "linux-64", + "timestamp": 1614278005995, + "version": "2.6.1.post1" + }, + "pyproj-2.6.1.post1-py36hd003209_1.conda": { + "build": "py36hd003209_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "298a27fd76d8d467181f6c80e3a31319", + "name": "pyproj", + "sha256": "8c5741129c0068725de7a97560f0b2753120c6b34ae266536e4889d3ae526dff", + "size": 399032, + "subdir": "linux-64", + "timestamp": 1590593860486, + "version": "2.6.1.post1" + }, + "pyproj-2.6.1.post1-py37h61f852b_1.conda": { + "build": "py37h61f852b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=7.0.1,<7.0.2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5964564d85b77850fe949b99f47f456a", + "name": "pyproj", + "sha256": "c92b44492a43cf64c37f08bad31b5a9156454a007dac89b693d4737529d6ca40", + "size": 400353, + "subdir": "linux-64", + "timestamp": 1590593830850, + "version": "2.6.1.post1" + }, + "pyproj-2.6.1.post1-py37hb3025e9_1.conda": { + "build": "py37hb3025e9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4466eac8c0adce15fba137a953e07740", + "name": "pyproj", + "sha256": "0f4d50481bdb044f46da4ddbfef98c194a05e6c6b99775086a56de8887d844a5", + "size": 399525, + "subdir": "linux-64", + "timestamp": 1614277992716, + "version": "2.6.1.post1" + }, + "pyproj-2.6.1.post1-py37hd003209_1.conda": { + "build": "py37hd003209_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ab8e83f60a9724efc63f3d7e4585e24a", + "name": "pyproj", + "sha256": "dd6b01759d534b8832bf542654c5edb5f14a905f3ed8636e0bf17e324d5556eb", + "size": 399519, + "subdir": "linux-64", + "timestamp": 1590593829647, + "version": "2.6.1.post1" + }, + "pyproj-2.6.1.post1-py38h61f852b_1.conda": { + "build": "py38h61f852b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=7.0.1,<7.0.2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "fa7928253f8564243d5d70cf3ca1e461", + "name": "pyproj", + "sha256": "02687d35ce3f2e74f77ec1530968dfad04c6e7ed6671731800dbf7856a6ea302", + "size": 418718, + "subdir": "linux-64", + "timestamp": 1590593829569, + "version": "2.6.1.post1" + }, + "pyproj-2.6.1.post1-py38hb3025e9_1.conda": { + "build": "py38hb3025e9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "0482ba63325fb3f69c0e77f60e36b9ae", + "name": "pyproj", + "sha256": "1dae1bdbdf04b7a6580a978a8ecfae40d7807d41d590370ac659f4ba354e35e9", + "size": 418868, + "subdir": "linux-64", + "timestamp": 1614278003311, + "version": "2.6.1.post1" + }, + "pyproj-2.6.1.post1-py38hd003209_1.conda": { + "build": "py38hd003209_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "1884842597bf4b3be799f2c9cc89390e", + "name": "pyproj", + "sha256": "cf6d46bdfb46839b9a81fff6dfdb44d5124ccbfa56227c3c72e29754a6e1be8e", + "size": 415929, + "subdir": "linux-64", + "timestamp": 1590593825586, + "version": "2.6.1.post1" + }, + "pyproj-2.6.1.post1-py39hb3025e9_1.conda": { + "build": "py39hb3025e9_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "8c3bf53a4c5f3877cd646b93e3ce712c", + "name": "pyproj", + "sha256": "014e25245a0834bccc4a58e916f54868e157f1b930c75bc132f994d86c20aef5", + "size": 416850, + "subdir": "linux-64", + "timestamp": 1614276971595, + "version": "2.6.1.post1" + }, + "pyproj-3.1.0-py310he0da13a_4.conda": { + "build": "py310he0da13a_4", + "build_number": 4, + "depends": [ + "certifi", + "libgcc-ng >=7.5.0", + "proj >=7.2.0,<7.2.1.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "08e98c9e4c108b1f4eaffbfcff28c7e2", + "name": "pyproj", + "sha256": "0ad0b02889c3a93d81b48aa902598500114642bbda9d425befc2db6af6a98529", + "size": 1381193, + "subdir": "linux-64", + "timestamp": 1643015537854, + "version": "3.1.0" + }, + "pyproj-3.3.0-py310h162314d_0.conda": { + "build": "py310h162314d_0", + "build_number": 0, + "depends": [ + "certifi", + "libgcc-ng >=7.5.0", + "proj >=8.2.1", + "proj >=8.2.1,<8.2.2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d93b9433f1a5b415228d748c34c839bc", + "name": "pyproj", + "sha256": "35441de42841e8e9276c17d9f1c9f1d037499c1f9b5ae57be753d3d5747167d3", + "size": 1333266, + "subdir": "linux-64", + "timestamp": 1644492078711, + "version": "3.3.0" + }, + "pyproj-3.3.0-py38h6de3afc_0.conda": { + "build": "py38h6de3afc_0", + "build_number": 0, + "depends": [ + "certifi", + "libgcc-ng >=7.5.0", + "proj >=8.2.1", + "proj >=8.2.1,<8.2.2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1f143181ba2590b6013ad908fc28c86", + "name": "pyproj", + "sha256": "15cf8303aed8a36a6bcecb5baf5c4a85e6762b5ca5a120dd1e556304744cbb5b", + "size": 464474, + "subdir": "linux-64", + "timestamp": 1644493881126, + "version": "3.3.0" + }, + "pyproj-3.3.0-py39h6de3afc_0.conda": { + "build": "py39h6de3afc_0", + "build_number": 0, + "depends": [ + "certifi", + "libgcc-ng >=7.5.0", + "proj >=8.2.1", + "proj >=8.2.1,<8.2.2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "578f7704e622664ebf96525fb198bfd4", + "name": "pyproj", + "sha256": "863955054ff68e3273e8fbc612cd1f205d3220d61e0bd7a3e260fc949b24840b", + "size": 465053, + "subdir": "linux-64", + "timestamp": 1644510184590, + "version": "3.3.0" + }, + "pyproj-3.4.1-py310h49a4818_0.conda": { + "build": "py310h49a4818_0", + "build_number": 0, + "depends": [ + "certifi", + "libgcc-ng >=11.2.0", + "proj >=8.2.1", + "proj >=8.2.1,<8.2.2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dce8715ab2ee434bba34ed824d6cfd12", + "name": "pyproj", + "sha256": "e134a6824eb6af14aa817a974dd82e8489fb112737633bfbc2c498d6ebe0a721", + "size": 482004, + "subdir": "linux-64", + "timestamp": 1675244305076, + "version": "3.4.1" + }, + "pyproj-3.4.1-py311h93e2b2c_0.conda": { + "build": "py311h93e2b2c_0", + "build_number": 0, + "depends": [ + "certifi", + "libgcc-ng >=11.2.0", + "proj >=8.2.1", + "proj >=8.2.1,<8.2.2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e20f4b4ae1fde3c0262f4828faef6d6d", + "name": "pyproj", + "sha256": "dc9e8b600da226cde110e6e03658ab1ceba9f59623703d5146062fcab4709ab4", + "size": 458465, + "subdir": "linux-64", + "timestamp": 1676842317633, + "version": "3.4.1" + }, + "pyproj-3.4.1-py38hb83c990_0.conda": { + "build": "py38hb83c990_0", + "build_number": 0, + "depends": [ + "certifi", + "libgcc-ng >=11.2.0", + "proj >=8.2.1", + "proj >=8.2.1,<8.2.2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2fb283c4e661c7f13d02e821fda567cb", + "name": "pyproj", + "sha256": "cae7f12821f11af2fcb5f3199fceeaed7bc77ad2fdd6684fc8af0872d6a87fc9", + "size": 480850, + "subdir": "linux-64", + "timestamp": 1675244384710, + "version": "3.4.1" + }, + "pyproj-3.4.1-py39hb83c990_0.conda": { + "build": "py39hb83c990_0", + "build_number": 0, + "depends": [ + "certifi", + "libgcc-ng >=11.2.0", + "proj >=8.2.1", + "proj >=8.2.1,<8.2.2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0226918f7df9d0ad0be6a3479bb0ff96", + "name": "pyproj", + "sha256": "ff5970c820d91304865337ceab73bc2d7071cb4263bec9854f9aa55b91a1d5da", + "size": 476655, + "subdir": "linux-64", + "timestamp": 1675244222905, + "version": "3.4.1" + }, + "pyproject-metadata-0.6.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6df4ccae285fa8b40a926774fd9923c3", + "name": "pyproject-metadata", + "sha256": "0da877601eb170b8cb5ab49e0a7dca67ce45ae577c4038991ac864b3b63c87e1", + "size": 17388, + "subdir": "linux-64", + "timestamp": 1660078336813, + "version": "0.6.1" + }, + "pyproject-metadata-0.6.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43fc95bfd55db4ebfa3866203fd672b9", + "name": "pyproject-metadata", + "sha256": "400d04daed5001c26462eb9ffff92de6f106e01a6f75070b9820ac77f6369430", + "size": 22184, + "subdir": "linux-64", + "timestamp": 1676845404472, + "version": "0.6.1" + }, + "pyproject-metadata-0.6.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56bdcc68bda27bd132c481078e08181e", + "name": "pyproject-metadata", + "sha256": "2b1212b72fbc0d76ff901eda9f70ff1759c98a6991d6221e5912199f2fecfea8", + "size": 17212, + "subdir": "linux-64", + "timestamp": 1660078235935, + "version": "0.6.1" + }, + "pyproject-metadata-0.6.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3bba6c6e253ee005bbf294033893403c", + "name": "pyproject-metadata", + "sha256": "25c7955068b117894f64ddcf647c1aefaea1124bfc967ccfab9f7c905c045923", + "size": 17268, + "subdir": "linux-64", + "timestamp": 1660078295748, + "version": "0.6.1" + }, + "pyproject-metadata-0.6.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2765eac7d2c845979e109f411cddd20a", + "name": "pyproject-metadata", + "sha256": "19e7fc9cc20433b94bdcd6c2c00ea4cb34f5b032059a7b23eeb965c77f48755b", + "size": 17261, + "subdir": "linux-64", + "timestamp": 1660078268117, + "version": "0.6.1" + }, + "pyproject-metadata-0.7.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "203b6902067dd0681393d749db243e14", + "name": "pyproject-metadata", + "sha256": "9e97bbd25da89bd1ef745d0fc708cb998548e978cf0166be179634deebabbcb2", + "size": 23582, + "subdir": "linux-64", + "timestamp": 1679672900904, + "version": "0.7.1" + }, + "pyproject-metadata-0.7.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f78fd50f370fd83ade8aa74a737ea51f", + "name": "pyproject-metadata", + "sha256": "f9e5c3b6b7fcfb3ecf07bb9e3ea57087ab1d015a7981e6c61e9c1a359a80790f", + "size": 28370, + "subdir": "linux-64", + "timestamp": 1679672847301, + "version": "0.7.1" + }, + "pyproject-metadata-0.7.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15b91dbca677ed3c31378a08e8969a59", + "name": "pyproject-metadata", + "sha256": "b5cf0cc5892d5012ab37c488cbeb8bb2bdfc0a76346fa51183d49299c84e587c", + "size": 23462, + "subdir": "linux-64", + "timestamp": 1679672873858, + "version": "0.7.1" + }, + "pyproject-metadata-0.7.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ca4dde06b6dd2489ef1170e98b49c89", + "name": "pyproject-metadata", + "sha256": "7e78d751bc636e495d7c262bf83bf48476e4ec567f030caac2fe925618f08841", + "size": 23458, + "subdir": "linux-64", + "timestamp": 1679672820354, + "version": "0.7.1" + }, + "pyproject_hooks-1.0.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56a9caf8474b40aa2949ff4923787afe", + "name": "pyproject_hooks", + "sha256": "77633e1160659a7c8ead530178bd5e9c9091824fe6c593c176b222716fa8d932", + "size": 20310, + "subdir": "linux-64", + "timestamp": 1679584441968, + "version": "1.0.0" + }, + "pyproject_hooks-1.0.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49010ef9c649547373a24be2dd99d083", + "name": "pyproject_hooks", + "sha256": "e01885439266a8cd3fc7eaf1a1ab6cd1f6bdad0b4c65bc4c6db259c30165fa02", + "size": 24553, + "subdir": "linux-64", + "timestamp": 1679584514958, + "version": "1.0.0" + }, + "pyproject_hooks-1.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66b091e4235922c81e10df756a786dd3", + "name": "pyproject_hooks", + "sha256": "98199cb067e638350eca85f2fb16b72b2192f2867baf8083ce1a28dc5d3ca23b", + "size": 20089, + "subdir": "linux-64", + "timestamp": 1679584466547, + "version": "1.0.0" + }, + "pyproject_hooks-1.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f2ad92f502c3605a948d7ea049a0be2", + "name": "pyproject_hooks", + "sha256": "42d45168cb18fb4a4fc1e5120dcc2f66d5edd07de8d0d229c8c7eef993c452b4", + "size": 20084, + "subdir": "linux-64", + "timestamp": 1679584490005, + "version": "1.0.0" + }, + "pyqt-5.15.7-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt5-sip 12.11.0 py310h6a678d5_0", + "python >=3.10,<3.11.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "d91f78a1efcdb7dfd7e2e0c1110be844", + "name": "pyqt", + "sha256": "dbd856731e5323b081af39641b91dceedce787a67fbaacfe6536a51088f3e40b", + "size": 5288439, + "subdir": "linux-64", + "timestamp": 1659277022459, + "version": "5.15.7" + }, + "pyqt-5.15.7-py310h6a678d5_1.conda": { + "build": "py310h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt5-sip 12.11.0 py310h6a678d5_1", + "python >=3.10,<3.11.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "2084350b18db696c9bfa61401c3c62a6", + "name": "pyqt", + "sha256": "95ce2d4487a8aa186fcad00d0cd856898e446e865de6d5aa7e1932cc89de3806", + "size": 5317308, + "subdir": "linux-64", + "timestamp": 1659387924109, + "version": "5.15.7" + }, + "pyqt-5.15.7-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt5-sip 12.11.0 py311h6a678d5_0", + "python >=3.11,<3.12.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "2e5cda13f98e221a9c30e99cc8af3587", + "name": "pyqt", + "sha256": "9819f4fb626fb6315bc1134256bf2e7a0c8fefa0f92d62dbe93da16d629d893c", + "size": 5245183, + "subdir": "linux-64", + "timestamp": 1676826744474, + "version": "5.15.7" + }, + "pyqt-5.15.7-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt5-sip 12.11.0 py37h6a678d5_0", + "python >=3.7,<3.8.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "a936414ad37636d7a17e68777c14cec2", + "name": "pyqt", + "sha256": "016a4a174cdccdbcf056d6cf46739603fb444d1162e2ed6e73e6c51cf3278dfa", + "size": 5285753, + "subdir": "linux-64", + "timestamp": 1659280679415, + "version": "5.15.7" + }, + "pyqt-5.15.7-py37h6a678d5_1.conda": { + "build": "py37h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt5-sip 12.11.0 py37h6a678d5_1", + "python >=3.7,<3.8.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "b2442e2952894608e71737dfcfd03ad7", + "name": "pyqt", + "sha256": "06f3f1e56b14b248539387ed514c2cb91458aca0c199be1b0f953948d5efde1f", + "size": 5306241, + "subdir": "linux-64", + "timestamp": 1659389270968, + "version": "5.15.7" + }, + "pyqt-5.15.7-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt5-sip 12.11.0 py38h6a678d5_0", + "python >=3.8,<3.9.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "37b2af2bebdfdc7d49152d9eeba3fb53", + "name": "pyqt", + "sha256": "ae3b99478e5ff9d3868f6427d05349ab32feda44465ed279615294fa3f51a675", + "size": 5290828, + "subdir": "linux-64", + "timestamp": 1659275209198, + "version": "5.15.7" + }, + "pyqt-5.15.7-py38h6a678d5_1.conda": { + "build": "py38h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt5-sip 12.11.0 py38h6a678d5_1", + "python >=3.8,<3.9.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "62232dc285be8e7e85ae9596d89b3b95", + "name": "pyqt", + "sha256": "e93cae5c107318c095767c110514ed577192206bc8ad97d1652263fac4131062", + "size": 5303684, + "subdir": "linux-64", + "timestamp": 1659388597307, + "version": "5.15.7" + }, + "pyqt-5.15.7-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt5-sip 12.11.0 py39h6a678d5_0", + "python >=3.9,<3.10.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "404e10c2742e081c28a0167eac46ee26", + "name": "pyqt", + "sha256": "0f2fa414ea76dc26e16590f17b13995b4357c04c0bd01152bbc795f0b081defe", + "size": 5284501, + "subdir": "linux-64", + "timestamp": 1659278848931, + "version": "5.15.7" + }, + "pyqt-5.15.7-py39h6a678d5_1.conda": { + "build": "py39h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt5-sip 12.11.0 py39h6a678d5_1", + "python >=3.9,<3.10.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "f4ae6b7b39077f9c3e62c8eda0ea5859", + "name": "pyqt", + "sha256": "0bce6a6c4dfc79d0376bc768791131e9772cdf043db6a92f9d0145950e5f88cd", + "size": 5298651, + "subdir": "linux-64", + "timestamp": 1659389943675, + "version": "5.15.7" + }, + "pyqt-5.6.0-py27h22d08a2_6.conda": { + "build": "py27h22d08a2_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "qt 5.6.*", + "sip 4.18.*" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "ea70b46c53ba87cee388ed0267a00211", + "name": "pyqt", + "sha256": "c46d77244be2e39356c3ecb1d93c11ba90f4c68ccee6d5c6b6aa9783a9f9c5bb", + "size": 4446659, + "subdir": "linux-64", + "timestamp": 1530796317530, + "version": "5.6.0" + }, + "pyqt-5.6.0-py27h4b1e83c_5.conda": { + "build": "py27h4b1e83c_5", + "build_number": 5, + "depends": [ + "dbus >=1.10.22,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "qt 5.6.*", + "sip 4.18.*" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "6857b9d9d763891c77d68ff30e4a6049", + "name": "pyqt", + "sha256": "4da642d6c7dab0601427db8b64161abc40494fe5e1c27fd9a716068f9bbbce0f", + "size": 4444026, + "subdir": "linux-64", + "timestamp": 1505738242615, + "version": "5.6.0" + }, + "pyqt-5.6.0-py35h0e41ada_5.conda": { + "build": "py35h0e41ada_5", + "build_number": 5, + "depends": [ + "dbus >=1.10.22,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "qt 5.6.*", + "sip 4.18.*" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "a04ca101d3a00bed74c4f390a880b7b6", + "name": "pyqt", + "sha256": "cd3867fa1f5ec1a387eeb553506e9ce05f090ad8fec317f5fefe54dedff624b7", + "size": 4595720, + "subdir": "linux-64", + "timestamp": 1505738707849, + "version": "5.6.0" + }, + "pyqt-5.6.0-py35h22d08a2_6.conda": { + "build": "py35h22d08a2_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "qt 5.6.*", + "qt >=5.6.3,<5.7.0a0", + "sip 4.18.*" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "21f9726c1bd529f1d86f0360e63c46e2", + "name": "pyqt", + "sha256": "b01c93242a7cb6c7a446fe616bcb18d49a67d3fc36a86edd61eb21a89eddc243", + "size": 4588126, + "subdir": "linux-64", + "timestamp": 1535129366886, + "version": "5.6.0" + }, + "pyqt-5.6.0-py36h0386399_5.conda": { + "build": "py36h0386399_5", + "build_number": 5, + "depends": [ + "dbus >=1.10.22,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "qt 5.6.*", + "sip 4.18.*" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "577ecfb83d482badfd86a4a0c904a569", + "name": "pyqt", + "sha256": "cb789b59025700bc2f05269c3d05b264caf10c9e17ccd21a8678bdcf788c6ed4", + "size": 4619642, + "subdir": "linux-64", + "timestamp": 1505739175210, + "version": "5.6.0" + }, + "pyqt-5.6.0-py36h22d08a2_6.conda": { + "build": "py36h22d08a2_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "qt 5.6.*", + "sip 4.18.*" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "f9f72a91a8e982918406599c790feb3b", + "name": "pyqt", + "sha256": "f80128b514d4b554d3d5645ee05a3f2eb4e9ba1a757b1386acd15048dbcc7e0d", + "size": 4590555, + "subdir": "linux-64", + "timestamp": 1530796931852, + "version": "5.6.0" + }, + "pyqt-5.6.0-py37h22d08a2_6.conda": { + "build": "py37h22d08a2_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "qt 5.6.*", + "sip 4.18.*" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "8343095748bbd032fa76e4826144df0c", + "name": "pyqt", + "sha256": "d2f6ab5e084268c295792e4cc5cdc976e82ee946b2cb55a51ad2cf3f3057483c", + "size": 4595116, + "subdir": "linux-64", + "timestamp": 1530797543010, + "version": "5.6.0" + }, + "pyqt-5.9.2-py27h05f1152_2.conda": { + "build": "py27h05f1152_2", + "build_number": 2, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "99bf8c1c6f27907f4874953b5006b34d", + "name": "pyqt", + "sha256": "7549343d278b11b839af08d957ab8801c7ed3d50331bf3250d5310b0fc18fbbb", + "size": 4554435, + "subdir": "linux-64", + "timestamp": 1537388927459, + "version": "5.9.2" + }, + "pyqt-5.9.2-py27h22d08a2_0.conda": { + "build": "py27h22d08a2_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "63404f5c973bfa550c7683d4f3d22c5c", + "name": "pyqt", + "sha256": "c5e19edac44f37334cc826ebccf3852d11a2bff42a65bb7352c6f4060012f631", + "size": 4796180, + "subdir": "linux-64", + "timestamp": 1530794131757, + "version": "5.9.2" + }, + "pyqt-5.9.2-py27h22d08a2_1.conda": { + "build": "py27h22d08a2_1", + "build_number": 1, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "0c839fa11b1a8a647fa7953755903b62", + "name": "pyqt", + "sha256": "ed911a14b2f5551d9d0370bb6e4b8ecb76408a10bd1aeace26a764db1fe311d6", + "size": 4554798, + "subdir": "linux-64", + "timestamp": 1535101431715, + "version": "5.9.2" + }, + "pyqt-5.9.2-py27h751905a_0.conda": { + "build": "py27h751905a_0", + "build_number": 0, + "depends": [ + "dbus >=1.12.2,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "qt 5.9.*", + "qt >=5.9.4,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "785bbddec44c16bb511ce72d57608aa6", + "name": "pyqt", + "sha256": "a1432f5d16309743995818db9c93bd9e25b74d892dab97c4801f000cfefcef9b", + "size": 4796050, + "subdir": "linux-64", + "timestamp": 1521807306718, + "version": "5.9.2" + }, + "pyqt-5.9.2-py310h295c915_6.conda": { + "build": "py310h295c915_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "qt 5.9.*", + "qt >=5.9.7,<5.10.0a0", + "sip 4.19.13.*" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "34cf8095d456b8fe565d8a645f8c6483", + "name": "pyqt", + "sha256": "43a925d5b1d8a35f05a4d76889a4e05dc3bb0f27766ba9dd4081133871a73646", + "size": 4885701, + "subdir": "linux-64", + "timestamp": 1643115118542, + "version": "5.9.2" + }, + "pyqt-5.9.2-py35h05f1152_2.conda": { + "build": "py35h05f1152_2", + "build_number": 2, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "b72cf3da84ef8e99bce1f266387a153f", + "name": "pyqt", + "sha256": "58777fd2d8080c5aa0b6090329810c953036ddd4d2cc8837388eca5a985ce4f8", + "size": 4733050, + "subdir": "linux-64", + "timestamp": 1537389093699, + "version": "5.9.2" + }, + "pyqt-5.9.2-py35h22d08a2_1.conda": { + "build": "py35h22d08a2_1", + "build_number": 1, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "77719016bd9aa812fbc477b9ef9d6043", + "name": "pyqt", + "sha256": "eb7600033e4125f21cd074a38a0006302df99c8b6b80666b05a2fb4133281d3d", + "size": 4737044, + "subdir": "linux-64", + "timestamp": 1535102766048, + "version": "5.9.2" + }, + "pyqt-5.9.2-py35h751905a_0.conda": { + "build": "py35h751905a_0", + "build_number": 0, + "depends": [ + "dbus >=1.12.2,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "qt 5.9.*", + "qt >=5.9.4,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "9bdf683e0c4f314137104abba4a87402", + "name": "pyqt", + "sha256": "4e3563074bd581f4483530a16f74af53468b00d2102731e8a08a5d48c4dfcb74", + "size": 4972434, + "subdir": "linux-64", + "timestamp": 1521807900545, + "version": "5.9.2" + }, + "pyqt-5.9.2-py36h05f1152_2.conda": { + "build": "py36h05f1152_2", + "build_number": 2, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "208e27c21eeec7bb78d77c91816ad3a8", + "name": "pyqt", + "sha256": "933f913c4c18b488740bdac6f18468f904b16fd52b8bcfae153607bf8dd2862c", + "size": 4733014, + "subdir": "linux-64", + "timestamp": 1537389093760, + "version": "5.9.2" + }, + "pyqt-5.9.2-py36h22d08a2_0.conda": { + "build": "py36h22d08a2_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "65b38d8065bd9c577f4443db45c92f3a", + "name": "pyqt", + "sha256": "eb90f4f7ca76a4a25a16e66802f35f67aa8fb698dca163693b0a7cf28a855f8a", + "size": 4965198, + "subdir": "linux-64", + "timestamp": 1530794852052, + "version": "5.9.2" + }, + "pyqt-5.9.2-py36h22d08a2_1.conda": { + "build": "py36h22d08a2_1", + "build_number": 1, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "450339d71cabdd24cbbc8c5cb9a561f8", + "name": "pyqt", + "sha256": "709a51eaccb7cc77c34b7f55dc598ba7e77dbe114a6852c7366278814f37ee52", + "size": 4732343, + "subdir": "linux-64", + "timestamp": 1535102100281, + "version": "5.9.2" + }, + "pyqt-5.9.2-py36h751905a_0.conda": { + "build": "py36h751905a_0", + "build_number": 0, + "depends": [ + "dbus >=1.12.2,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "qt 5.9.*", + "qt >=5.9.4,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "9a5dadef31311a797f3e3f39209f7c5e", + "name": "pyqt", + "sha256": "c72936db15074f3ae1d131ae6c2f328e447573a92dc0b167c91c1a180dc05395", + "size": 4965291, + "subdir": "linux-64", + "timestamp": 1521808500120, + "version": "5.9.2" + }, + "pyqt-5.9.2-py37h05f1152_2.conda": { + "build": "py37h05f1152_2", + "build_number": 2, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "22e969c53ead5594414fdd72194df83b", + "name": "pyqt", + "sha256": "37b184bd98afa3c56bddcb96cfc93204bc573b93b29f6b06e46de20ef8acd196", + "size": 4733047, + "subdir": "linux-64", + "timestamp": 1537384246300, + "version": "5.9.2" + }, + "pyqt-5.9.2-py37h22d08a2_0.conda": { + "build": "py37h22d08a2_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "5bd8a1303637acde9562b0360bfc856c", + "name": "pyqt", + "sha256": "ceab6b05fac7b5ad5b20903f7262fc1f0e4d802a4b9a3b900ca9db307c18064a", + "size": 4965420, + "subdir": "linux-64", + "timestamp": 1530795563644, + "version": "5.9.2" + }, + "pyqt-5.9.2-py37h22d08a2_1.conda": { + "build": "py37h22d08a2_1", + "build_number": 1, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "qt 5.9.*", + "qt >=5.9.6,<5.10.0a0", + "sip >=4.19.4,<=4.19.8" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "11f577d4a156e58af785e5090026e798", + "name": "pyqt", + "sha256": "05c288a3d142c743aff1eaaae413968daa5f2a885b815ab40fd3f0768f8a469a", + "size": 4730141, + "subdir": "linux-64", + "timestamp": 1535112124759, + "version": "5.9.2" + }, + "pyqt-5.9.2-py38h05f1152_4.conda": { + "build": "py38h05f1152_4", + "build_number": 4, + "depends": [ + "dbus >=1.13.12,<2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "qt 5.9.*", + "qt >=5.9.7,<5.10.0a0", + "sip >=4.19.13,<=4.19.14" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "d3e6b8e1a634125414f87f231c755dae", + "name": "pyqt", + "sha256": "b8bfbb8e6b5057222716e5e5d1a29156b6ab83d69d934365b1fabd8b6f84b560", + "size": 4753354, + "subdir": "linux-64", + "timestamp": 1574449202654, + "version": "5.9.2" + }, + "pyqt-5.9.2-py39h2531618_6.conda": { + "build": "py39h2531618_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "qt 5.9.*", + "qt >=5.9.7,<5.10.0a0", + "sip 4.19.13.*" + ], + "license": "Commercial, GPL-2.0, GPL-3.0", + "license_family": "GPL", + "md5": "77b1f6263939dd4c554bfde93f2217bc", + "name": "pyqt", + "sha256": "314afeb04e7ba1bc861fb422142897ba3e5fe03c88b8f1e4edb9b7fc533723cc", + "size": 4899285, + "subdir": "linux-64", + "timestamp": 1607697278482, + "version": "5.9.2" + }, + "pyqt-builder-1.13.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "packaging", + "python >=3.10,<3.11.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "7b1a7518e1d6e6a117f366704405dec8", + "name": "pyqt-builder", + "sha256": "2b824f951dc127b4d730c15ac68c804269d5fe1a05c764b87e99595d5985b03b", + "size": 3009380, + "subdir": "linux-64", + "timestamp": 1659018142373, + "version": "1.13.0" + }, + "pyqt-builder-1.13.0-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "packaging", + "python >=3.11,<3.12.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "cd5fb022160bd2033c4bc65e56963345", + "name": "pyqt-builder", + "sha256": "7a88ef7cf6ce53f1b568b8862d09e98fc5aa63f388aeac5bb67849ba9bfb445a", + "size": 2998105, + "subdir": "linux-64", + "timestamp": 1676825437931, + "version": "1.13.0" + }, + "pyqt-builder-1.13.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "packaging", + "python >=3.7,<3.8.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "c80d33938f6403b03a7ee1eb0dd45271", + "name": "pyqt-builder", + "sha256": "b895cab267271553e814e932d969620dfa055c6844d3ce2bdec6e5637b6a23d5", + "size": 3008221, + "subdir": "linux-64", + "timestamp": 1659018081877, + "version": "1.13.0" + }, + "pyqt-builder-1.13.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "packaging", + "python >=3.8,<3.9.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "3791444a8e286b91b49f3ac43303a33f", + "name": "pyqt-builder", + "sha256": "18959a8b240304aef6d6f820edfd3f5cdf5cbfc95c6ab6b50f32e8c4db0aca57", + "size": 3012748, + "subdir": "linux-64", + "timestamp": 1659018234237, + "version": "1.13.0" + }, + "pyqt-builder-1.13.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "packaging", + "python >=3.9,<3.10.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "559b6c95643fba2e9c5e9f9f07d651f4", + "name": "pyqt-builder", + "sha256": "e2666085595b40aa2ef6b050223ea2abc10aff75512f8612b30c8cef887d6acd", + "size": 3012798, + "subdir": "linux-64", + "timestamp": 1659018189435, + "version": "1.13.0" + }, + "pyqt5-sip-12.11.0-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.10,<3.11.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "d003e83e23fa40bc6bf2658b81dabaa7", + "name": "pyqt5-sip", + "sha256": "430aed41b76745f40a563f1deb5c5b2432e4a8623bfc41e3c973365c189a31b6", + "size": 281175, + "subdir": "linux-64", + "timestamp": 1659273332169, + "version": "12.11.0" + }, + "pyqt5-sip-12.11.0-py310h6a678d5_1.conda": { + "build": "py310h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.10,<3.11.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "b82aa11de791880fef887aba52fb1235", + "name": "pyqt5-sip", + "sha256": "9a5b58a8892f0f07696a8bdd855893c5f6557dc33479420e7a565e7607d87007", + "size": 283888, + "subdir": "linux-64", + "timestamp": 1659387165573, + "version": "12.11.0" + }, + "pyqt5-sip-12.11.0-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.11,<3.12.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "c5f544eb5fe54ea9ec602acf4ae98fb2", + "name": "pyqt5-sip", + "sha256": "d25e7987c45e0fe5c22a4007e5bf19a9eecedb27da7dfe134f3993b916124557", + "size": 84356, + "subdir": "linux-64", + "timestamp": 1676825504497, + "version": "12.11.0" + }, + "pyqt5-sip-12.11.0-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.7,<3.8.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "73aef1faf654a551da06ea8b56e0e15a", + "name": "pyqt5-sip", + "sha256": "3db8daf4c5ad7ee3af9c983f4f1c8aa70e31c744b29fbc70f3807041a100689a", + "size": 85533, + "subdir": "linux-64", + "timestamp": 1659273385307, + "version": "12.11.0" + }, + "pyqt5-sip-12.11.0-py37h6a678d5_1.conda": { + "build": "py37h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.7,<3.8.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "78978a8c041ae6199629b0d1c33b805a", + "name": "pyqt5-sip", + "sha256": "5735932e821d0765734d6a209a6761dd8ec49acb5c59153cc40df8094ad56cd4", + "size": 88752, + "subdir": "linux-64", + "timestamp": 1659387229000, + "version": "12.11.0" + }, + "pyqt5-sip-12.11.0-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.8,<3.9.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "a10673733474a3254359e7f54a914f85", + "name": "pyqt5-sip", + "sha256": "81dffae409dfb92dfd1fecdeeeb2d0f7ed977a188a14ff1fd9c09dbded16e0f7", + "size": 86323, + "subdir": "linux-64", + "timestamp": 1659273304812, + "version": "12.11.0" + }, + "pyqt5-sip-12.11.0-py38h6a678d5_1.conda": { + "build": "py38h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.8,<3.9.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "7bc403c7d55f1465e922964d293d2186", + "name": "pyqt5-sip", + "sha256": "8359511828c7ee92d9b703eba85bc104de5b8544fe32adddc8a2dce1c4c9520b", + "size": 89424, + "subdir": "linux-64", + "timestamp": 1659387197256, + "version": "12.11.0" + }, + "pyqt5-sip-12.11.0-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.9,<3.10.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "06e582765a84fc3e6716855a7afbb559", + "name": "pyqt5-sip", + "sha256": "4ff191836e0392cbcbebbe3fbd3177a2a5a6c8efe1e372179c72fca0efed38b7", + "size": 86308, + "subdir": "linux-64", + "timestamp": 1659273358985, + "version": "12.11.0" + }, + "pyqt5-sip-12.11.0-py39h6a678d5_1.conda": { + "build": "py39h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "python >=3.9,<3.10.0a0", + "sip", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "654cd7b8bee83539bb1b51f91e30601e", + "name": "pyqt5-sip", + "sha256": "f1a8da5d8b8bd66a9b19b6dc1fa4dbf968eedc39fa440fa3580ac00cbee840c3", + "size": 89428, + "subdir": "linux-64", + "timestamp": 1659387261071, + "version": "12.11.0" + }, + "pyqtchart-5.15.7-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.10,<3.11.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "535cbd9e7a4f7cb6cc09eb5e740eb60e", + "name": "pyqtchart", + "sha256": "c76f4d65f72f3f43ec6c160ecc94c54e32de0ba7711f76f11a69d8e3a80cff18", + "size": 221599, + "subdir": "linux-64", + "timestamp": 1659280910728, + "version": "5.15.7" + }, + "pyqtchart-5.15.7-py310h6a678d5_1.conda": { + "build": "py310h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.10,<3.11.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "be0c77ca6c3acef8cc6a4ae7b72f75c8", + "name": "pyqtchart", + "sha256": "bae4443720d4dd7fc6bbdd4a5cf7eb07519ee4f6450735f4d9d5d5502b5b2d60", + "size": 225069, + "subdir": "linux-64", + "timestamp": 1659390012217, + "version": "5.15.7" + }, + "pyqtchart-5.15.7-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.11,<3.12.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "bec96e5776ed24f6300926b3cc039025", + "name": "pyqtchart", + "sha256": "0d05aa303b8928af6a45d033b1dff3d53639a987adb8fa064091cd98a2723b51", + "size": 212399, + "subdir": "linux-64", + "timestamp": 1676826830390, + "version": "5.15.7" + }, + "pyqtchart-5.15.7-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.7,<3.8.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "d5021fb83f63268913421d1f8c1f1a3c", + "name": "pyqtchart", + "sha256": "b4c436df80cd03a07dd45b67b33b7f27d6d162f62d2b3461bec4bcd1ea586932", + "size": 220922, + "subdir": "linux-64", + "timestamp": 1659281130174, + "version": "5.15.7" + }, + "pyqtchart-5.15.7-py37h6a678d5_1.conda": { + "build": "py37h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.7,<3.8.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "87e092daf243cf5b06bbc487f5b56169", + "name": "pyqtchart", + "sha256": "db3e4de1271f3e678daf02fe1855aa0633cc84891e326098ce355e8fa8fef1ca", + "size": 224634, + "subdir": "linux-64", + "timestamp": 1659390137294, + "version": "5.15.7" + }, + "pyqtchart-5.15.7-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.8,<3.9.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "ce2c72469b29a03e5f3b095bf91a8ee6", + "name": "pyqtchart", + "sha256": "db2b8f66f534599cf1d286a08e3219caa0ef8b078e6433ab026c63cdce2693bd", + "size": 221446, + "subdir": "linux-64", + "timestamp": 1659280797999, + "version": "5.15.7" + }, + "pyqtchart-5.15.7-py38h6a678d5_1.conda": { + "build": "py38h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.8,<3.9.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "53e79e681778bd5c92866fd55362c2c9", + "name": "pyqtchart", + "sha256": "36c3331ec8154a854c59cb2f4be3d94cd1903f1cb6f7ef15b88802ae9091dd98", + "size": 225384, + "subdir": "linux-64", + "timestamp": 1659390075005, + "version": "5.15.7" + }, + "pyqtchart-5.15.7-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.9,<3.10.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "c7ce344d61d3e35610d0f6e802a038d7", + "name": "pyqtchart", + "sha256": "34f5fad081ead718b56df687628bd340a90a001895789227b7364b6144fb41d8", + "size": 221557, + "subdir": "linux-64", + "timestamp": 1659281019588, + "version": "5.15.7" + }, + "pyqtchart-5.15.7-py39h6a678d5_1.conda": { + "build": "py39h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.9,<3.10.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "f234153aa8c3d82d070d9730dfb62a47", + "name": "pyqtchart", + "sha256": "88e0d68f61e319abe01cf72c064902e039ac66bc9891ec123669eab1d6aba410", + "size": 224934, + "subdir": "linux-64", + "timestamp": 1659390200578, + "version": "5.15.7" + }, + "pyqtgraph-0.10.0-py27h28b3542_3.conda": { + "build": "py27h28b3542_3", + "build_number": 3, + "depends": [ + "numpy", + "pyqt", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "65345c9458dc2e09954ebdafbdc190ef", + "name": "pyqtgraph", + "sha256": "2acbb4632f6bec6b194b4834e6628d0fd8652a78b4dbba712743f0397fec0976", + "size": 943458, + "subdir": "linux-64", + "timestamp": 1530902770761, + "version": "0.10.0" + }, + "pyqtgraph-0.10.0-py35h28b3542_3.conda": { + "build": "py35h28b3542_3", + "build_number": 3, + "depends": [ + "numpy", + "pyqt", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14b8abc0694f459630a33a4ffa691936", + "name": "pyqtgraph", + "sha256": "1263569bdffe190d225db9b1dd0398d5ad8910ab8f405d120dfca2a6fcc22e99", + "size": 960088, + "subdir": "linux-64", + "timestamp": 1537851461118, + "version": "0.10.0" + }, + "pyqtgraph-0.10.0-py36h28b3542_3.conda": { + "build": "py36h28b3542_3", + "build_number": 3, + "depends": [ + "numpy", + "pyqt", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bcc38a43a1698d96f5656da830e689fb", + "name": "pyqtgraph", + "sha256": "a27a786ce80c89ca56ef8f8707261277014be8a9996f73d78c4247248d22bca3", + "size": 940133, + "subdir": "linux-64", + "timestamp": 1530902720268, + "version": "0.10.0" + }, + "pyqtgraph-0.10.0-py37h28b3542_3.conda": { + "build": "py37h28b3542_3", + "build_number": 3, + "depends": [ + "numpy", + "pyqt", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "03258df51e934621905f9713c0c2f6aa", + "name": "pyqtgraph", + "sha256": "3736b5cbef459cf91648ec99e6848b65cd91b4b9295f89e0f3cc52e8ae80c6ec", + "size": 942332, + "subdir": "linux-64", + "timestamp": 1530902661230, + "version": "0.10.0" + }, + "pyqtgraph-0.12.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "pyside2 >=5.12", + "pyqt >=5.12" + ], + "depends": [ + "numpy", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b778e121ba971f330c038c2228d07a82", + "name": "pyqtgraph", + "sha256": "0195c3d64e21f0937281e5b61a0f4b7feccacd61cc8a41accfd994398dfc9311", + "size": 1198442, + "subdir": "linux-64", + "timestamp": 1659341271623, + "version": "0.12.3" + }, + "pyqtgraph-0.12.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pyside2 >=5.12", + "pyqt >=5.12" + ], + "depends": [ + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "00c76d058097868bd7db6ac5ce607df2", + "name": "pyqtgraph", + "sha256": "d90e05bd6a436f3c9c9eb517891083960faa9119741c6e3797cd21c2e4dd7c97", + "size": 1189009, + "subdir": "linux-64", + "timestamp": 1659341228606, + "version": "0.12.3" + }, + "pyqtgraph-0.12.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyside2 >=5.12", + "pyqt >=5.12" + ], + "depends": [ + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ab378df0be9174a153bc9a7f712ee0c", + "name": "pyqtgraph", + "sha256": "3ceccc7b39a8b504b979119e605288d5beba149bbfbd0ed0a34863f1bb62a2cf", + "size": 1190126, + "subdir": "linux-64", + "timestamp": 1659341167268, + "version": "0.12.3" + }, + "pyqtgraph-0.12.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyside2 >=5.12", + "pyqt >=5.12" + ], + "depends": [ + "numpy", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7dc66bb5bbdb950108788e9e1157bfed", + "name": "pyqtgraph", + "sha256": "60aec043278a402a4f37c2d3262077654cce1df7820bb879f4238febcd88e890", + "size": 1184741, + "subdir": "linux-64", + "timestamp": 1659341197417, + "version": "0.12.3" + }, + "pyqtgraph-0.13.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "pyside2 >=5.15", + "pyqt >=5.15" + ], + "depends": [ + "numpy >=1.20.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8b9d890bd7fc160d68e39d12383330a", + "name": "pyqtgraph", + "sha256": "caf41e5179637ad875ba93171d85ae8204d4f2b61e96bf9e10937c1c6d506ecd", + "size": 1316698, + "subdir": "linux-64", + "timestamp": 1673550109315, + "version": "0.13.1" + }, + "pyqtgraph-0.13.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "pyside2 >=5.15", + "pyqt >=5.15" + ], + "depends": [ + "numpy >=1.20.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96965f469f8eeae32cd3c832f7f5871c", + "name": "pyqtgraph", + "sha256": "a80a9852d66eab3e75b01d3fdd26887c4ac1e250c92713578ec73053c9e2ab63", + "size": 1583194, + "subdir": "linux-64", + "timestamp": 1676845423774, + "version": "0.13.1" + }, + "pyqtgraph-0.13.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pyside2 >=5.15", + "pyqt >=5.15" + ], + "depends": [ + "numpy >=1.20.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0cd0a7f022288469eef879a842b0e4bb", + "name": "pyqtgraph", + "sha256": "ce43dcc16882d0ca62f6be3dae0af0de1782b9e5867a72795b8752cea0c4e931", + "size": 1305115, + "subdir": "linux-64", + "timestamp": 1673550071795, + "version": "0.13.1" + }, + "pyqtgraph-0.13.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pyside2 >=5.15", + "pyqt >=5.15" + ], + "depends": [ + "numpy >=1.20.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4960496ed792185b4ca2ef44bd5e1f85", + "name": "pyqtgraph", + "sha256": "576b689b99fc972f4df0c25f75e5d7bd01658d896919c7dcad54694c6c10c2e1", + "size": 1307031, + "subdir": "linux-64", + "timestamp": 1673550144493, + "version": "0.13.1" + }, + "pyqtwebengine-5.15.7-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.10,<3.11.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "957438073825eb045592923b2cd2c2a3", + "name": "pyqtwebengine", + "sha256": "48d1ce2e8d0b147df1da9fd578271fda26931b032252ffe727126503c78e0ab4", + "size": 158731, + "subdir": "linux-64", + "timestamp": 1659281353779, + "version": "5.15.7" + }, + "pyqtwebengine-5.15.7-py310h6a678d5_1.conda": { + "build": "py310h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.10,<3.11.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "cc3bcd11282b42e4cccf5423ff5c4e57", + "name": "pyqtwebengine", + "sha256": "bcbac78ac66b0ca69ef68856cede325fab51c2404343dd251a954d05ecf8b1f1", + "size": 162921, + "subdir": "linux-64", + "timestamp": 1659390278283, + "version": "5.15.7" + }, + "pyqtwebengine-5.15.7-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.11,<3.12.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "7fbc25884a2e3c898be6bea05a6e0d9c", + "name": "pyqtwebengine", + "sha256": "13adcbf0b30c9ce4222423f59ba7458741aed01bb2917cf0624b40c16cff98bf", + "size": 153668, + "subdir": "linux-64", + "timestamp": 1676826911618, + "version": "5.15.7" + }, + "pyqtwebengine-5.15.7-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.7,<3.8.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "4f8b3b35ea1b5e86f74b4b65ffce854d", + "name": "pyqtwebengine", + "sha256": "89110484dbb67cce747d85dcef1e4639f04f69e61e0b1e390e7e9399e728544c", + "size": 158546, + "subdir": "linux-64", + "timestamp": 1659281578609, + "version": "5.15.7" + }, + "pyqtwebengine-5.15.7-py37h6a678d5_1.conda": { + "build": "py37h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.7,<3.8.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "9ba84842df718d2b8fd220998171895d", + "name": "pyqtwebengine", + "sha256": "82fd2e477672ddb8bf49875d2de56b701d4f5e86047b4878a0f66fedcc2984d8", + "size": 161954, + "subdir": "linux-64", + "timestamp": 1659390432594, + "version": "5.15.7" + }, + "pyqtwebengine-5.15.7-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.8,<3.9.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "cb8f539c0b2bc490b5b42b1604b716bf", + "name": "pyqtwebengine", + "sha256": "f07d2393d18acbc8eb744d335078a061106f88c999ffd6689953bf1cf0af183e", + "size": 158616, + "subdir": "linux-64", + "timestamp": 1659281243424, + "version": "5.15.7" + }, + "pyqtwebengine-5.15.7-py38h6a678d5_1.conda": { + "build": "py38h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.8,<3.9.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "1f4d10a4892cde0a4df9144c61264f65", + "name": "pyqtwebengine", + "sha256": "59c91b5e16b4e40f14021fca2a1e440d147d9590aaa60ae786fd9194870c50a4", + "size": 162849, + "subdir": "linux-64", + "timestamp": 1659390354179, + "version": "5.15.7" + }, + "pyqtwebengine-5.15.7-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.9,<3.10.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "fd1f2e5daa82faa8e6dd9341e0b63202", + "name": "pyqtwebengine", + "sha256": "01499d1fd08056d0e2b42181bb3ae92c790bf9d8e4393f18dd36350df324f5a9", + "size": 158639, + "subdir": "linux-64", + "timestamp": 1659281466545, + "version": "5.15.7" + }, + "pyqtwebengine-5.15.7-py39h6a678d5_1.conda": { + "build": "py39h6a678d5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "pyqt >=5.15.7,<5.16.0a0", + "python >=3.9,<3.10.0a0", + "qt-main 5.15.*", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine 5.15.*", + "qt-webengine >=5.15.9,<5.16.0a0", + "qtwebkit 5.*", + "sip >=6.6.2,<6.7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "335d9ac6c32d6a70ff994f1597de4592", + "name": "pyqtwebengine", + "sha256": "b49423a412eaacfdd3aef0b557835ffe16afe32022ee346d09009c6475b94b96", + "size": 163278, + "subdir": "linux-64", + "timestamp": 1659390511115, + "version": "5.15.7" + }, + "pyquery-1.2.17-py27h0ca9866_0.conda": { + "build": "py27h0ca9866_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ca67ab1ed5c02da44768766405769122", + "name": "pyquery", + "sha256": "95b1d567f301d6f9bfa21e12ee624f3171d7517e2e12cdde2a36bca27cef3491", + "size": 37592, + "subdir": "linux-64", + "timestamp": 1506925342346, + "version": "1.2.17" + }, + "pyquery-1.2.17-py35hdc30f01_0.conda": { + "build": "py35hdc30f01_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "45b3343f473c47a6989739a4ebf2e0ce", + "name": "pyquery", + "sha256": "da1f1a6c19135138d99e17e2a22083566f30d08661b10dc3370246126ffc9749", + "size": 38760, + "subdir": "linux-64", + "timestamp": 1506925350251, + "version": "1.2.17" + }, + "pyquery-1.2.17-py36h44e87f9_0.conda": { + "build": "py36h44e87f9_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b97b143a5fd4698ee6dd946097bdf95b", + "name": "pyquery", + "sha256": "93981be5a11dacb181c207ce747093d6e153749030e7e840f9cd2defcfbf1fa0", + "size": 38331, + "subdir": "linux-64", + "timestamp": 1506925363209, + "version": "1.2.17" + }, + "pyquery-1.3.0-py27hc741669_0.conda": { + "build": "py27hc741669_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "27b28f4084735e479d30ec35927e324d", + "name": "pyquery", + "sha256": "38616319b14a2b368cb0ddcf0ec94b7da28c4e348e1ae9a105b6e7945d0f8735", + "size": 35237, + "subdir": "linux-64", + "timestamp": 1511321967730, + "version": "1.3.0" + }, + "pyquery-1.3.0-py35h19d6a88_0.conda": { + "build": "py35h19d6a88_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8a4c0a05a0014a0f792b1a49beb0e683", + "name": "pyquery", + "sha256": "af7d66e59401827b74d93199d08eae0f370522cf7b12a702e301804284d94765", + "size": 36377, + "subdir": "linux-64", + "timestamp": 1511321976521, + "version": "1.3.0" + }, + "pyquery-1.3.0-py36h459d551_0.conda": { + "build": "py36h459d551_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4fb54f9d5630162b2903387d9af0df44", + "name": "pyquery", + "sha256": "4e6245fb81bfe59076fd60257144ea538420831254ca4cedea99417d5a85bbb9", + "size": 36310, + "subdir": "linux-64", + "timestamp": 1511321977746, + "version": "1.3.0" + }, + "pyquery-1.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ea449540ada0815040ca4a267968a319", + "name": "pyquery", + "sha256": "fae735349b8ef15a5799a48791404a1f92ffc655addfd587c36d3e5001d23f7d", + "size": 37724, + "subdir": "linux-64", + "timestamp": 1519365710199, + "version": "1.4.0" + }, + "pyquery-1.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3780ad38c82670a762e66a8ce9b7be27", + "name": "pyquery", + "sha256": "94546488ad1b70ae9521f14acd9c05a00e0f3c1d016e1e00563d5481a03816b6", + "size": 39160, + "subdir": "linux-64", + "timestamp": 1519365763444, + "version": "1.4.0" + }, + "pyquery-1.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "18f995fafb50114e132139805f4e32fb", + "name": "pyquery", + "sha256": "ea49e30b46fb171b159ab597b810b8a97c64ab87ae2d306f946600f2d48892e8", + "size": 38710, + "subdir": "linux-64", + "timestamp": 1519365669956, + "version": "1.4.0" + }, + "pyquery-1.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ec61fd78f5f302fe7fd1ed30c19d616e", + "name": "pyquery", + "sha256": "3ef95d72309215e08faf7035a0962340b1d1095e1cfa126c6ea738c9572d12e5", + "size": 38211, + "subdir": "linux-64", + "timestamp": 1530875640864, + "version": "1.4.0" + }, + "pyquery-1.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "850f5679ebcb263d93932db8f4c8061d", + "name": "pyquery", + "sha256": "210adf9c5479150282e6d6f41573669daab565036a28e4806e8a7542707fc67b", + "size": 39123, + "subdir": "linux-64", + "timestamp": 1574094323298, + "version": "1.4.0" + }, + "pyquery-1.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b777024b4c9bf2ae4ac16797468feadf", + "name": "pyquery", + "sha256": "0fd856af91b9c8dfcd764622266849f5e377ad91c4071a00dfb0d806effad12d", + "size": 42132, + "subdir": "linux-64", + "timestamp": 1601589135216, + "version": "1.4.1" + }, + "pyquery-1.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e747a27334d0c99aa3c8de91b8efab80", + "name": "pyquery", + "sha256": "6b27ab7d844b4570144855bb8fd381ddb9d992f8f1c80aac72e4403e24282237", + "size": 41833, + "subdir": "linux-64", + "timestamp": 1601589150135, + "version": "1.4.1" + }, + "pyquery-1.4.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0065cf30ce4453574ebc34786b8ca614", + "name": "pyquery", + "sha256": "10f9f1e0c1d1901d66dcd9c684cb8d9d863316d67563831926aec7fe782d99cd", + "size": 42331, + "subdir": "linux-64", + "timestamp": 1601589161808, + "version": "1.4.1" + }, + "pyquery-1.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e9f7cb92a4683f57e7e470c7ef006b63", + "name": "pyquery", + "sha256": "a5b5f77dbf8952538103e7f8290ab7e331c060248fc03e0b2fb56429405154c1", + "size": 41598, + "subdir": "linux-64", + "timestamp": 1640810456791, + "version": "1.4.3" + }, + "pyquery-1.4.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "61ccc83d2e6cb16d041162862c072dbd", + "name": "pyquery", + "sha256": "02b8e635e848ad6b3af11d3094aafa257c86822e80c5d67075b33538c16c4625", + "size": 54188, + "subdir": "linux-64", + "timestamp": 1676861060126, + "version": "1.4.3" + }, + "pyquery-1.4.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2fa4b9854f62af63419577d06aa7c2fb", + "name": "pyquery", + "sha256": "a6590d0abd66edff346494222f82d9a953dc62c370873ca0c18edf430f88cba1", + "size": 40869, + "subdir": "linux-64", + "timestamp": 1606843690457, + "version": "1.4.3" + }, + "pyquery-1.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "64dfc2f2db0d50c27a8c5ba42b901b43", + "name": "pyquery", + "sha256": "2d4fee93c5050f32d0d5dfe7d06a268b5b0eb0da4d77b98bd22e75f447f841c0", + "size": 41456, + "subdir": "linux-64", + "timestamp": 1606431079440, + "version": "1.4.3" + }, + "pyquery-1.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7f637c59a60d82b2ad208b24bd1fe564", + "name": "pyquery", + "sha256": "4a968ce9c435dab5fd1e090a5c69a3ab3e871e593c5bc1e365c33d1d9d0a319d", + "size": 41136, + "subdir": "linux-64", + "timestamp": 1606431106291, + "version": "1.4.3" + }, + "pyquery-1.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >0.7.9", + "lxml >=2.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "82a9adde64c45821672ba1ca95df56cd", + "name": "pyquery", + "sha256": "f0b6867fd99770ed2d769a1ab2b4f8a360b0560c3464c36623fc1c023ce3c7e5", + "size": 42142, + "subdir": "linux-64", + "timestamp": 1613162206143, + "version": "1.4.3" + }, + "pyramid-1.10.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=2.7,<2.8.0a0", + "repoze.lru >=0.4", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "d6207ee86791c810352919deeafeaa8c", + "name": "pyramid", + "sha256": "1318cd118251e977928a9082347cf68cbb02b2c0296ec4ff741c7c6bba380e98", + "size": 349004, + "subdir": "linux-64", + "timestamp": 1545149801318, + "version": "1.10.1" + }, + "pyramid-1.10.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.6,<3.7.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "bbb741677cfda7c3431c6f7329309a44", + "name": "pyramid", + "sha256": "65dbc8ee4c7990a013253a76c4c51f9e3793ddd7bb8ff43bc36e655b288123e8", + "size": 351332, + "subdir": "linux-64", + "timestamp": 1545149813317, + "version": "1.10.1" + }, + "pyramid-1.10.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.7,<3.8.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "70b02a1469d6dc62e087b3a1afc3b73b", + "name": "pyramid", + "sha256": "3120f1bffd5eb775d25066a0f6e453ec96c7c81174201b03dca6c275108a9b80", + "size": 346119, + "subdir": "linux-64", + "timestamp": 1545149814864, + "version": "1.10.1" + }, + "pyramid-1.10.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=2.7,<2.8.0a0", + "repoze.lru >=0.4", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "6327671859f047fa14ff6bf55be3afb6", + "name": "pyramid", + "sha256": "7f274492b70d768370e3b368f629c99db67d681bd30c6945540da8ae8a8837e0", + "size": 496023, + "subdir": "linux-64", + "timestamp": 1552446158397, + "version": "1.10.2" + }, + "pyramid-1.10.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.6,<3.7.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "62381c96cb840c14278862fe294756df", + "name": "pyramid", + "sha256": "f44b2f42b895da334ed2cf959779113363fe5b72bf11c975e0a1cf2c7a3bc488", + "size": 503206, + "subdir": "linux-64", + "timestamp": 1552446139221, + "version": "1.10.2" + }, + "pyramid-1.10.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.7,<3.8.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "446df18ad5d53c9d660d7c2bbf39567b", + "name": "pyramid", + "sha256": "b29c9fd1b0f833a69990a3e008711edff21a209f0c23ce5d94bb3ed8c72f3fdf", + "size": 498454, + "subdir": "linux-64", + "timestamp": 1552446140514, + "version": "1.10.2" + }, + "pyramid-1.10.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=2.7,<2.8.0a0", + "repoze.lru >=0.4", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "053f4ab064dd8c3071dbd1ff07465c3e", + "name": "pyramid", + "sha256": "550289ef362964d5838261df6446e6ef925fac6293cb4aba647d633514627492", + "size": 509166, + "subdir": "linux-64", + "timestamp": 1564680354695, + "version": "1.10.4" + }, + "pyramid-1.10.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.10,<3.11.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "793fc85c4b1482d84cdaa65f80bfb01f", + "name": "pyramid", + "sha256": "9eb9dee20cd5e0024d76d5ff7597eea55a3bf1f50df12b89cbb668363827f1a0", + "size": 349518, + "subdir": "linux-64", + "timestamp": 1642513151488, + "version": "1.10.4" + }, + "pyramid-1.10.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.11,<3.12.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "9aaeb39feab0260c605419a4ca1b5b56", + "name": "pyramid", + "sha256": "a8ae59254a5595a39d4c2e13730fbaa43ed2185f86cd2ba73029e5561e0b0c0b", + "size": 433661, + "subdir": "linux-64", + "timestamp": 1676905972623, + "version": "1.10.4" + }, + "pyramid-1.10.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.6,<3.7.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "28470392eee7910bcfed5df94460e814", + "name": "pyramid", + "sha256": "40997ec3049bce9edb1ba0e634d7c1c108ab52abc957c30bd07c1585fe3b2b54", + "size": 511261, + "subdir": "linux-64", + "timestamp": 1564680023283, + "version": "1.10.4" + }, + "pyramid-1.10.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.6,<3.7.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "ca58388afc08a45a4d05dd4dba34c4da", + "name": "pyramid", + "sha256": "de51a231f6611a0ed09a2b58f4cf49d530fae698759df1a93ffeabd210f38cdd", + "size": 592947, + "subdir": "linux-64", + "timestamp": 1614249814028, + "version": "1.10.4" + }, + "pyramid-1.10.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.7,<3.8.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "0f54771e488b6aa7f2a1a3d4853ea7ce", + "name": "pyramid", + "sha256": "d22b2e6f9b94abc3de25e7062b22fb88f0c6574d3789c6c63dcbc98dc427ef9b", + "size": 511534, + "subdir": "linux-64", + "timestamp": 1564679935359, + "version": "1.10.4" + }, + "pyramid-1.10.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.7,<3.8.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "291b68f6a1fbac9cf356d4c5007dd2db", + "name": "pyramid", + "sha256": "895a4cd425974d8a98b926167e0f14fcfc8ace7da0919f982ba44fc646b38a00", + "size": 594493, + "subdir": "linux-64", + "timestamp": 1614249742382, + "version": "1.10.4" + }, + "pyramid-1.10.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.8,<3.9.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "985843ea4891e57048dbb7da50d9023b", + "name": "pyramid", + "sha256": "a8c0dd30b7b03cc54c1b734aab5e11cc63f22892195b682c4a4f1eced2db4604", + "size": 353110, + "subdir": "linux-64", + "timestamp": 1574177665640, + "version": "1.10.4" + }, + "pyramid-1.10.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.8,<3.9.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "b15337aaddced9aaf28348a603a07e9a", + "name": "pyramid", + "sha256": "4c4a3c0912741d7959ff7b36ff0febe29e2dba8add4bcb3e18463b1ae44416b9", + "size": 588743, + "subdir": "linux-64", + "timestamp": 1614249829973, + "version": "1.10.4" + }, + "pyramid-1.10.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "hupper", + "plaster", + "plaster_pastedeploy", + "python >=3.9,<3.10.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "f1b5058b62f718bf2ccd796ec551eb35", + "name": "pyramid", + "sha256": "7f793af929a037ec864a4d3d3ed3439a3884850c369cef77cd1ddbf39c06d22f", + "size": 595389, + "subdir": "linux-64", + "timestamp": 1614249827472, + "version": "1.10.4" + }, + "pyramid-1.9.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "hupper", + "pastedeploy >=1.5.0", + "plaster", + "plaster_pastedeploy", + "python >=2.7,<2.8.0a0", + "repoze.lru >=0.4", + "translationstring >=0.4", + "venusian >=1.0a3", + "webob >=1.7.0", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "0923ae918a47ccbf687a796699fd1e89", + "name": "pyramid", + "sha256": "0e1d1ff49d832cf65242896d1579479e8a755f3d02ff2077f3e5f3a393b497ed", + "size": 745449, + "subdir": "linux-64", + "timestamp": 1530028472643, + "version": "1.9.2" + }, + "pyramid-1.9.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "hupper", + "pastedeploy >=1.5.0", + "plaster", + "plaster_pastedeploy", + "python >=3.5,<3.6.0a0", + "repoze.lru >=0.4", + "translationstring >=0.4", + "venusian >=1.0a3", + "webob >=1.7.0", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "bf1b8418158dcf9e2aa89f4ed66a968e", + "name": "pyramid", + "sha256": "f4eb95cc807a730e2fdd5c1b681b83e809c77d2b6245fa641087f68ee0ba6d50", + "size": 771214, + "subdir": "linux-64", + "timestamp": 1530028077955, + "version": "1.9.2" + }, + "pyramid-1.9.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "hupper", + "pastedeploy >=1.5.0", + "plaster", + "plaster_pastedeploy", + "python >=3.6,<3.7.0a0", + "repoze.lru >=0.4", + "translationstring >=0.4", + "venusian >=1.0a3", + "webob >=1.7.0", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "dfe27a25ed565d82d654738e0ddbee12", + "name": "pyramid", + "sha256": "2632604b8336950201663b469821c69d711c0e50fdcac9c534acae5a2b8cdbff", + "size": 766030, + "subdir": "linux-64", + "timestamp": 1530027991580, + "version": "1.9.2" + }, + "pyramid-1.9.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "hupper", + "pastedeploy >=1.5.0", + "plaster", + "plaster_pastedeploy", + "python >=3.7,<3.8.0a0", + "repoze.lru >=0.4", + "translationstring >=0.4", + "venusian >=1.0a3", + "webob >=1.7.0", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "BSD", + "md5": "33a44f3e7d3087dc85044253d50b1208", + "name": "pyramid", + "sha256": "841b0e5e2d8d6ea2a55e521170598c2be24535ccb63af09372d1187f19f97edc", + "size": 766794, + "subdir": "linux-64", + "timestamp": 1530875797499, + "version": "1.9.2" + }, + "pyramid-2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "hupper >=1.5", + "plaster", + "plaster_pastedeploy", + "python >=3.9,<3.10.0a0", + "translationstring >=0.4", + "venusian >=1.0", + "webob >=1.8.3", + "zope.deprecation >=3.5.0", + "zope.interface >=3.8.0" + ], + "license": "LicenseRef-Pylons", + "license_family": "BSD", + "md5": "d27f4d0ebaa0a371e45cf290a54a4668", + "name": "pyramid", + "sha256": "f3731cb068aa4b82078fc0a7c427d726416b77910472509037476f4b3dc6b497", + "size": 306354, + "subdir": "linux-64", + "timestamp": 1619444200052, + "version": "2.0" + }, + "pyramid_debugtoolbar-4.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "pygments", + "pyramid >=1.4", + "pyramid_mako >=0.3.1", + "python >=2.7,<2.8.0a0", + "repoze.lru" + ], + "license": "BSD", + "md5": "ac3497415abf553ed4da6a41f21f4115", + "name": "pyramid_debugtoolbar", + "sha256": "7f2643632cfb5c7e58467b42962c6e43b326ac36ce303626ee1fc0b5d6d8077d", + "size": 327573, + "subdir": "linux-64", + "timestamp": 1530035442856, + "version": "4.4" + }, + "pyramid_debugtoolbar-4.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pygments", + "pyramid >=1.4", + "pyramid_mako >=0.3.1", + "python >=3.5,<3.6.0a0", + "repoze.lru" + ], + "license": "BSD", + "md5": "219b2465908df0b411e099dcdbdb483d", + "name": "pyramid_debugtoolbar", + "sha256": "7933d615ce6a086f841a42f896b34735ff217810243ff3ea391e7fd3824a9380", + "size": 327484, + "subdir": "linux-64", + "timestamp": 1530035470572, + "version": "4.4" + }, + "pyramid_debugtoolbar-4.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "pyramid >=1.4", + "pyramid_mako >=0.3.1", + "python >=3.6,<3.7.0a0", + "repoze.lru" + ], + "license": "BSD", + "md5": "004b289bf52d6060161815d0a9641055", + "name": "pyramid_debugtoolbar", + "sha256": "5c83699fa316f9309d4b29faa317ea1263b27d0e398fa656cdcb25d9f7fdb92a", + "size": 327062, + "subdir": "linux-64", + "timestamp": 1530035415820, + "version": "4.4" + }, + "pyramid_debugtoolbar-4.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipaddress", + "pygments", + "pyramid >=1.4", + "pyramid_mako >=0.3.1", + "python >=2.7,<2.8.0a0", + "repoze.lru" + ], + "license": "BSD", + "md5": "f9f65fce5a3b455a293a93ba04e85cfc", + "name": "pyramid_debugtoolbar", + "sha256": "70bf4cb48a957634a183e72f037090a0e558127647f6064244a4f0edbe03ac5e", + "size": 496277, + "subdir": "linux-64", + "timestamp": 1569442543331, + "version": "4.5" + }, + "pyramid_debugtoolbar-4.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pygments", + "pyramid >=1.4", + "pyramid_mako >=0.3.1", + "python >=3.10,<3.11.0a0", + "repoze.lru" + ], + "license": "BSD", + "md5": "107c18149fc7cee7134b7f4f9a09094f", + "name": "pyramid_debugtoolbar", + "sha256": "f807148e199c0008a4007e077abbc00347d2d8fe577a8f2773aaca83e5cdefc8", + "size": 333805, + "subdir": "linux-64", + "timestamp": 1640810475403, + "version": "4.5" + }, + "pyramid_debugtoolbar-4.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pygments", + "pyramid >=1.4", + "pyramid_mako >=0.3.1", + "python >=3.6,<3.7.0a0", + "repoze.lru" + ], + "license": "BSD", + "md5": "eaea7e006548305b891e6a41b1fe1197", + "name": "pyramid_debugtoolbar", + "sha256": "ecae57b0624b014c9e55b598498df4f4857b7ab2b3627c9a65e2d64c6bf0e1f8", + "size": 498925, + "subdir": "linux-64", + "timestamp": 1569442546230, + "version": "4.5" + }, + "pyramid_debugtoolbar-4.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pygments", + "pyramid >=1.4", + "pyramid_mako >=0.3.1", + "python >=3.7,<3.8.0a0", + "repoze.lru" + ], + "license": "BSD", + "md5": "8b0dbfeae3dc9a966aa4f25a9554c4a2", + "name": "pyramid_debugtoolbar", + "sha256": "7384eef6b2948ad3eae2dfe4e24cef66ecb0d3037fc866ea2de829163e4bf4bf", + "size": 497989, + "subdir": "linux-64", + "timestamp": 1569442598839, + "version": "4.5" + }, + "pyramid_debugtoolbar-4.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pygments", + "pyramid >=1.4", + "pyramid_mako >=0.3.1", + "python >=3.8,<3.9.0a0", + "repoze.lru" + ], + "license": "BSD", + "md5": "0bf2d50afab1458ed0111bb79f79acaf", + "name": "pyramid_debugtoolbar", + "sha256": "ee9b2ae68700579c9d204c2b76aed1eb3bb58d81ec7264c0a70419f9523298f8", + "size": 332016, + "subdir": "linux-64", + "timestamp": 1574238067583, + "version": "4.5" + }, + "pyramid_jinja2-2.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.5.0", + "markupsafe", + "pyramid >=1.3.0", + "python >=2.7,<2.8.0a0", + "zope.deprecation" + ], + "license": "BSD", + "md5": "4f1db44bff55699df6fc4ff6f69ad824", + "name": "pyramid_jinja2", + "sha256": "82bde827d3e6d94954f9967c693988f9a98e3185614c69e1db9f76e93f7f9b19", + "size": 70716, + "subdir": "linux-64", + "timestamp": 1530034886508, + "version": "2.7" + }, + "pyramid_jinja2-2.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.5.0", + "markupsafe", + "pyramid >=1.3.0", + "python >=3.5,<3.6.0a0", + "zope.deprecation" + ], + "license": "BSD", + "md5": "6b6a9ff3af51e2e57566f06f02df6bbe", + "name": "pyramid_jinja2", + "sha256": "3555147f76c61ff5d25b83498b766d9ca6999c377258e8fcd2cfd4b15f3abe87", + "size": 71708, + "subdir": "linux-64", + "timestamp": 1530034913805, + "version": "2.7" + }, + "pyramid_jinja2-2.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.5.0", + "markupsafe", + "pyramid >=1.3.0", + "python >=3.6,<3.7.0a0", + "zope.deprecation" + ], + "license": "BSD", + "md5": "d363400018fb2fae458ccfd944912a96", + "name": "pyramid_jinja2", + "sha256": "5bf9205c0ee128d6e3a75fd93255d37e02f8111c4473040224f573bd2a6ac739", + "size": 71922, + "subdir": "linux-64", + "timestamp": 1530034862322, + "version": "2.7" + }, + "pyramid_mako-1.0.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "mako >=0.8", + "pyramid", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "b77151b66d1b99cbda8439feb3a806f9", + "name": "pyramid_mako", + "sha256": "e0e8786dbee55b9224b55443faea8f14ea93e40be688631f70acdd96d93ed868", + "size": 22410, + "subdir": "linux-64", + "timestamp": 1530035132147, + "version": "1.0.2" + }, + "pyramid_mako-1.0.2-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "mako >=0.8", + "pyramid", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "48cf45a9e9f04775fb28267cbdcb1245", + "name": "pyramid_mako", + "sha256": "4793e89d0967e9a7fbe3f07e3da0ee49294d4d090d3e40ba192e29fcfeda7da2", + "size": 22847, + "subdir": "linux-64", + "timestamp": 1530035147948, + "version": "1.0.2" + }, + "pyramid_mako-1.0.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "mako >=0.8", + "pyramid", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "691611bfb4d87c5e9f9b2ccba5218dc4", + "name": "pyramid_mako", + "sha256": "1798afbafeaf3e9aefa1ca51a1ad2b0f78f2aea1e19c13999ce91d578bd22fbb", + "size": 22741, + "subdir": "linux-64", + "timestamp": 1530035100315, + "version": "1.0.2" + }, + "pyramid_mako-1.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mako >=1.1.0", + "pyramid", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "010c91303e6553867609513dd0c406e1", + "name": "pyramid_mako", + "sha256": "00083d6a3ccbae248f15b76d24270fa54c61c3e251b6050a47a4cb84b0e5a92d", + "size": 191272, + "subdir": "linux-64", + "timestamp": 1569442388991, + "version": "1.1.0" + }, + "pyramid_mako-1.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "mako >=1.1.0", + "pyramid", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "a536950e3462ba4031b5f4887acba0f7", + "name": "pyramid_mako", + "sha256": "36ac94817e37bbc26f8b7a5b78f1b4c8c2ef616f96e8b882c6736a09b6b2cd86", + "size": 26960, + "subdir": "linux-64", + "timestamp": 1640793629612, + "version": "1.1.0" + }, + "pyramid_mako-1.1.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "mako >=1.1.0", + "pyramid", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "md5": "3112411a857dc56a08b30051c1ff70df", + "name": "pyramid_mako", + "sha256": "5a3a3dba98fe50de37571b54572045f37bef809418926315c7d75eafc06ba323", + "size": 33220, + "subdir": "linux-64", + "timestamp": 1676906158023, + "version": "1.1.0" + }, + "pyramid_mako-1.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "mako >=1.1.0", + "pyramid", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "b617a6745e04fb6341be4f6bd2352f31", + "name": "pyramid_mako", + "sha256": "9f4db2ad9ac078de7b6eee12a0565a947c14328c1f298eaca990d434314e032d", + "size": 191751, + "subdir": "linux-64", + "timestamp": 1569442391086, + "version": "1.1.0" + }, + "pyramid_mako-1.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "mako >=1.1.0", + "pyramid", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "2087178bc520ccb73d14215ce8daa6bb", + "name": "pyramid_mako", + "sha256": "0c3cc4d93573a1f4375647fcf340cb2d10d25614fed0ece64a08d6844d34f915", + "size": 190781, + "subdir": "linux-64", + "timestamp": 1569442384259, + "version": "1.1.0" + }, + "pyramid_mako-1.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "mako >=1.1.0", + "pyramid", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "f080fb4e3f1ba410df564fc06054471e", + "name": "pyramid_mako", + "sha256": "4d371f0bdd1737e493e189248d91dab51b8ca9318c2a3ec21067bfc0774dd802", + "size": 26560, + "subdir": "linux-64", + "timestamp": 1574183905707, + "version": "1.1.0" + }, + "pyramid_tm-2.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyramid >=1.5", + "python >=2.7,<2.8.0a0", + "transaction >=2.0" + ], + "license": "BSD", + "md5": "7823c86d0a87042c2f8380841f5a5280", + "name": "pyramid_tm", + "sha256": "9a55d77ced7f29ccb937e7f3dd00f7a396d5be0dd0c7b878a7a56b308d7d842b", + "size": 28030, + "subdir": "linux-64", + "timestamp": 1530036153619, + "version": "2.2" + }, + "pyramid_tm-2.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyramid >=1.5", + "python >=3.5,<3.6.0a0", + "transaction >=2.0" + ], + "license": "BSD", + "md5": "8a02bf66de721da1bf5ce09d3fde5443", + "name": "pyramid_tm", + "sha256": "ecca669e229cb5b2c4dd1ff88655b72b89af1cea7ce71197bb258d9683fce133", + "size": 28851, + "subdir": "linux-64", + "timestamp": 1530036167802, + "version": "2.2" + }, + "pyramid_tm-2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyramid >=1.5", + "python >=3.6,<3.7.0a0", + "transaction >=2.0" + ], + "license": "BSD", + "md5": "eeda8d6d8f0152ac9148a8075803b188", + "name": "pyramid_tm", + "sha256": "6977854f9eb5bf77ff9d31c424bf32bb9cdccb73073739aa3bea2d9ad539ac68", + "size": 28624, + "subdir": "linux-64", + "timestamp": 1530036132802, + "version": "2.2" + }, + "pyramid_tm-2.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyramid >=1.5", + "python >=2.7,<2.8.0a0", + "transaction >=2.0" + ], + "license": "BSD", + "md5": "c7ecdafcd416961d43736d7c5ae9de86", + "name": "pyramid_tm", + "sha256": "5b6220f6fdee6047a9e607c0aa9a0a48fc617bad3fd5014655a23046b57eaf89", + "size": 28403, + "subdir": "linux-64", + "timestamp": 1541033398016, + "version": "2.2.1" + }, + "pyramid_tm-2.2.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pyramid >=1.5", + "python >=3.10,<3.11.0a0", + "transaction >=2.0" + ], + "license": "BSD", + "md5": "6f92aad66842369e74a6707bc6e79a70", + "name": "pyramid_tm", + "sha256": "949b68f344c8136f033b4544d2c14a64fff5a0e7974155f70fb406186d3af923", + "size": 29634, + "subdir": "linux-64", + "timestamp": 1640813612815, + "version": "2.2.1" + }, + "pyramid_tm-2.2.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pyramid >=1.5", + "python >=3.11,<3.12.0a0", + "transaction >=2.0" + ], + "license": "BSD", + "md5": "533fc705fdfba48451b85eb244830c1f", + "name": "pyramid_tm", + "sha256": "beb9f15e6a5711642b56b9f4a23c5ac8c4026e6aa3f1b720f663dae407bc532d", + "size": 36099, + "subdir": "linux-64", + "timestamp": 1676907600136, + "version": "2.2.1" + }, + "pyramid_tm-2.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyramid >=1.5", + "python >=3.6,<3.7.0a0", + "transaction >=2.0" + ], + "license": "BSD", + "md5": "8f30a3262e932ada6c4777cd59ec1b01", + "name": "pyramid_tm", + "sha256": "c012e4161fc24d9bd5d9036b8a5968357c7de17ca7b5f8bb446892a780b6084b", + "size": 29161, + "subdir": "linux-64", + "timestamp": 1541033429031, + "version": "2.2.1" + }, + "pyramid_tm-2.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyramid >=1.5", + "python >=3.7,<3.8.0a0", + "transaction >=2.0" + ], + "license": "BSD", + "md5": "6d3afb713c22d1556eac8aa8410e8338", + "name": "pyramid_tm", + "sha256": "8fec80c3ab2acdcceee6c7cbb78906df3d5dd3860811f2ad21116a1dba5a45ac", + "size": 29205, + "subdir": "linux-64", + "timestamp": 1541033382358, + "version": "2.2.1" + }, + "pyramid_tm-2.2.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pyramid >=1.5", + "python >=3.8,<3.9.0a0", + "transaction >=2.0" + ], + "license": "BSD", + "md5": "719490fe7f3752c99d7242515eaab9b8", + "name": "pyramid_tm", + "sha256": "8c6574d9522b38d1d201befb68f792bc45f43a0edd931d77398f4653d3f44f0a", + "size": 29776, + "subdir": "linux-64", + "timestamp": 1574235860908, + "version": "2.2.1" + }, + "pyrsistent-0.14.11-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7321856a4e1545f167a4f1f4b4893742", + "name": "pyrsistent", + "sha256": "3e0c6bcc5f44d5266dddf8fc25608ba92156f6e863237cf46ec8ee64b159bc60", + "size": 90928, + "subdir": "linux-64", + "timestamp": 1552335705303, + "version": "0.14.11" + }, + "pyrsistent-0.14.11-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a7040c11e5171b6cf53e2d5c3a620723", + "name": "pyrsistent", + "sha256": "fff091dffab27b7651b7c1cf77432582d989ee976f8048e0d246251e37362d26", + "size": 95353, + "subdir": "linux-64", + "timestamp": 1615492147738, + "version": "0.14.11" + }, + "pyrsistent-0.14.11-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c66c4257c0381a8d87076e9d1a9db7cf", + "name": "pyrsistent", + "sha256": "eb4cb02bcf220e244981905adf267e9a0f29beefaca1465f92e366866745d4a6", + "size": 92825, + "subdir": "linux-64", + "timestamp": 1552335753747, + "version": "0.14.11" + }, + "pyrsistent-0.14.11-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f38031485f28f7c068b2fdb6f741284", + "name": "pyrsistent", + "sha256": "be984e5c24be0e0a17f26657aad85f61dff30e512c5e1488896cda84daef27a4", + "size": 93741, + "subdir": "linux-64", + "timestamp": 1615493771112, + "version": "0.14.11" + }, + "pyrsistent-0.14.11-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4675599106691bf5c63dbef182a5874", + "name": "pyrsistent", + "sha256": "fb40a661e650ae2371508f9e3bf7a45aec9134a5747acd697f4def39f6ff49b2", + "size": 93125, + "subdir": "linux-64", + "timestamp": 1552335694793, + "version": "0.14.11" + }, + "pyrsistent-0.14.11-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6541dbd91b9620523ebe5bdf482e89b", + "name": "pyrsistent", + "sha256": "898976c249e4e8a8508d1938cc1a5d727acf0b353ead58ac2e37f70cbf9aedd9", + "size": 95168, + "subdir": "linux-64", + "timestamp": 1615493775819, + "version": "0.14.11" + }, + "pyrsistent-0.14.11-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2232faf7e24d1aad0eca85004b884c31", + "name": "pyrsistent", + "sha256": "071347f72905d61050f65c0430f0c98dfd2a6b7bb270aac6182c389bbca0072c", + "size": 91911, + "subdir": "linux-64", + "timestamp": 1594843798058, + "version": "0.14.11" + }, + "pyrsistent-0.14.11-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2be65cfbd8c33ec8052a1421aa64dd93", + "name": "pyrsistent", + "sha256": "1d7f9581203f24b7b9a14e24b9b7cf5eb5af7b5bc1367bac4a0f175d1b9c9d0f", + "size": 94366, + "subdir": "linux-64", + "timestamp": 1615493772411, + "version": "0.14.11" + }, + "pyrsistent-0.15.4-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0ea877efb91fe6229125c8e059d8757a", + "name": "pyrsistent", + "sha256": "125f1f7cb0271570a77e8cb994691e1302154e80e758a6a4509dfe24f949a3a9", + "size": 93365, + "subdir": "linux-64", + "timestamp": 1569427177560, + "version": "0.15.4" + }, + "pyrsistent-0.15.4-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d8023392d9cb1a26328c94239a31ab2", + "name": "pyrsistent", + "sha256": "dc029029f8650fb35e3d295107155b34e33b3bbdc85f23ec84dff64485f2918a", + "size": 94849, + "subdir": "linux-64", + "timestamp": 1569427169167, + "version": "0.15.4" + }, + "pyrsistent-0.15.4-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3223c8d73d3e30d82ccc74da8bc62e12", + "name": "pyrsistent", + "sha256": "1645ab3a640ef50782e05d5dea154c6f85988671d4dd8ebc02103a66ad900c8a", + "size": 94817, + "subdir": "linux-64", + "timestamp": 1569427193644, + "version": "0.15.4" + }, + "pyrsistent-0.15.4-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b61af035fc4e8c021d94899cff6c694", + "name": "pyrsistent", + "sha256": "cfb37e7832dd0f3a52963e1ccb240cad380fcccf7bcc3c28c9b2d83a9c3a6b55", + "size": 99807, + "subdir": "linux-64", + "timestamp": 1574092704931, + "version": "0.15.4" + }, + "pyrsistent-0.15.5-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "44a123766f0bb3a62c5f04271cd4f3a0", + "name": "pyrsistent", + "sha256": "c23ced4dfee7737e2860789b2be0dc006038c5c64535bf9eb61a70c3cafc32d3", + "size": 93439, + "subdir": "linux-64", + "timestamp": 1573940662796, + "version": "0.15.5" + }, + "pyrsistent-0.15.5-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dcbe095c03558e8424a03541ea64e171", + "name": "pyrsistent", + "sha256": "c4d8916c23df3c7e7dd91aabf5a59fe45e7ebdb0595f1d05661567bce0c5b8dc", + "size": 95035, + "subdir": "linux-64", + "timestamp": 1573940684003, + "version": "0.15.5" + }, + "pyrsistent-0.15.5-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f5c3e1bf9c36102640044aac0c60662f", + "name": "pyrsistent", + "sha256": "b6fb14cbdeb87a2b74337afd50f7f48cdd262db2ba367055c7591648eedc31c2", + "size": 95277, + "subdir": "linux-64", + "timestamp": 1573940670837, + "version": "0.15.5" + }, + "pyrsistent-0.15.5-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a84e274643e666468bd96dfdeceb1f5d", + "name": "pyrsistent", + "sha256": "58797cf58aed1a16dad53c6076f3d42904999e1fff8cf32a976eedf69acb6dc6", + "size": 102529, + "subdir": "linux-64", + "timestamp": 1573940647946, + "version": "0.15.5" + }, + "pyrsistent-0.15.6-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "40e376e1fa5bbf998cb5813c821bd9e3", + "name": "pyrsistent", + "sha256": "55ff5de2e87fcc63a83ca8a7f3bed7caac2774ac329dc0084d98b6a12bacb782", + "size": 93873, + "subdir": "linux-64", + "timestamp": 1574700015614, + "version": "0.15.6" + }, + "pyrsistent-0.15.6-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc73f2300aa57a93c959344a7fa86b3a", + "name": "pyrsistent", + "sha256": "641e1d5f60bf1b4d871f3a9cbcd334b769a4be4518bafba5b9a1d61217702307", + "size": 95407, + "subdir": "linux-64", + "timestamp": 1574700013653, + "version": "0.15.6" + }, + "pyrsistent-0.15.6-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e68f578b23d1085b90304f67429c15cb", + "name": "pyrsistent", + "sha256": "b1b2ca71cc511496192d08c88c19218317e69598a8cc737fcc854ecb418f10ca", + "size": 95346, + "subdir": "linux-64", + "timestamp": 1574699995091, + "version": "0.15.6" + }, + "pyrsistent-0.15.6-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8157344d96e7e7af4b9eb943f59fdf5d", + "name": "pyrsistent", + "sha256": "98e1d711c01161414486246e6813daf1d08ee7b56ce908ab1bb1e4d4f13828e2", + "size": 102663, + "subdir": "linux-64", + "timestamp": 1574700028216, + "version": "0.15.6" + }, + "pyrsistent-0.15.7-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd57e812dc1b83216647eee5ecafee44", + "name": "pyrsistent", + "sha256": "05bd25741560d4be111984f32bde23de52fbd135bfb08c5ab706f904aae876ee", + "size": 95513, + "subdir": "linux-64", + "timestamp": 1580153830865, + "version": "0.15.7" + }, + "pyrsistent-0.15.7-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "53abba6386af619caf2b121299907f41", + "name": "pyrsistent", + "sha256": "cdf41b7fc235cd18874a67842a585c63a4f0508d18201e3df44a5320af9040a8", + "size": 95598, + "subdir": "linux-64", + "timestamp": 1580153809946, + "version": "0.15.7" + }, + "pyrsistent-0.15.7-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18f77f3d59000bf5032a72f163380e0d", + "name": "pyrsistent", + "sha256": "83c13fba74db2b51060a57d413895491b73a61735bef3bd74ef06c9e85dad6ff", + "size": 96780, + "subdir": "linux-64", + "timestamp": 1580153876832, + "version": "0.15.7" + }, + "pyrsistent-0.16.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11ac54080ca8c09419200828788a989f", + "name": "pyrsistent", + "sha256": "c59dd4d059dc5f6d4fcd8454b3c1bdc1b193629ffbc0a2fed9d130e4b4761189", + "size": 96346, + "subdir": "linux-64", + "timestamp": 1585588106217, + "version": "0.16.0" + }, + "pyrsistent-0.16.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c0664b33051d22380e6fc2b8652a3fa", + "name": "pyrsistent", + "sha256": "5fc6446dc760b2d5ce9fcca8eb62568a2da32e43187c86fab0d2397fcb434877", + "size": 96284, + "subdir": "linux-64", + "timestamp": 1585588063894, + "version": "0.16.0" + }, + "pyrsistent-0.16.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2780009faf426865f22a25e7e691f98", + "name": "pyrsistent", + "sha256": "34048104d8c1e1c2643c479e0d9f07a0a5d4794cda705ed9f5a01089f244e3fe", + "size": 97118, + "subdir": "linux-64", + "timestamp": 1585588114895, + "version": "0.16.0" + }, + "pyrsistent-0.17.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ac4c577e88bf7e3aa1f0c3ba108a2b2", + "name": "pyrsistent", + "sha256": "6da3f14447eeabebba0b985ef98d6755437598fa5cf9c70a0d6a0db06aa08bda", + "size": 90763, + "subdir": "linux-64", + "timestamp": 1600141762698, + "version": "0.17.3" + }, + "pyrsistent-0.17.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e094114fc1d2cbd2ce2f49248781790", + "name": "pyrsistent", + "sha256": "171f43fdae74d0ce82892cfbcbc2f4b30186e0a152f22e0b65ee90093eb2774f", + "size": 91271, + "subdir": "linux-64", + "timestamp": 1600141741298, + "version": "0.17.3" + }, + "pyrsistent-0.17.3-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba41d756b401b9e76f94d8d44526ec9a", + "name": "pyrsistent", + "sha256": "7639bc045df9676ac95bb3f5b6a654a548a43f3f228eb138ee2d813c32b2fdf2", + "size": 92094, + "subdir": "linux-64", + "timestamp": 1600141756807, + "version": "0.17.3" + }, + "pyrsistent-0.17.3-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5337060ad49233b6eff29d8f8bdfd2ce", + "name": "pyrsistent", + "sha256": "603527e24d46ff599bd83eb7b50b1e91b93224fd1a3cf8cf838eccf1fea07ae3", + "size": 95655, + "subdir": "linux-64", + "timestamp": 1607365214229, + "version": "0.17.3" + }, + "pyrsistent-0.18.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "395c25d26c6da52a083e3ad9d54daf3d", + "name": "pyrsistent", + "sha256": "b483798bf271cf332da9db1cdb458096d03a30add7ae1c63b18969e154c58389", + "size": 119641, + "subdir": "linux-64", + "timestamp": 1640807221148, + "version": "0.18.0" + }, + "pyrsistent-0.18.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0278475d4fafe91d5334705af30796ab", + "name": "pyrsistent", + "sha256": "1e73d03e784fa1da42dd3e16d6e483674484385c16b6f225202acc90c9f29210", + "size": 119432, + "subdir": "linux-64", + "timestamp": 1676823106025, + "version": "0.18.0" + }, + "pyrsistent-0.18.0-py37heee7806_0.conda": { + "build": "py37heee7806_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "827f40764d912374672d6e609efe7fff", + "name": "pyrsistent", + "sha256": "7cbcef50d5e97bd3cf88fa98d71079c7adbed4d4d473dc1a8d53449afc7fbb2c", + "size": 97036, + "subdir": "linux-64", + "timestamp": 1636098940720, + "version": "0.18.0" + }, + "pyrsistent-0.18.0-py38heee7806_0.conda": { + "build": "py38heee7806_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d350240d35e34c9e250cbb1b9aa6460b", + "name": "pyrsistent", + "sha256": "9681fb4b3b26dda8ccbddf81c5a88ea8d1c7be51541590e801d7acae849eb16d", + "size": 95985, + "subdir": "linux-64", + "timestamp": 1636110987189, + "version": "0.18.0" + }, + "pyrsistent-0.18.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "53b7073a38eb592c5c7fadbddda9e106", + "name": "pyrsistent", + "sha256": "d47846f80a68bf3048be0639330ec2bee2ae7b2a890d745412c15a4d4f3bb1ee", + "size": 91735, + "subdir": "linux-64", + "timestamp": 1625052376849, + "version": "0.18.0" + }, + "pyrsistent-0.18.0-py39heee7806_0.conda": { + "build": "py39heee7806_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7be624ae84b3f39f6ff0db5b968109a3", + "name": "pyrsistent", + "sha256": "70655019c79fff8edec9eb8e0a1b084e1820f76d8ce9223d60f8cff1ba4c6b22", + "size": 96649, + "subdir": "linux-64", + "timestamp": 1636110999719, + "version": "0.18.0" + }, + "pysal-1.14.2-py27heb65aa2_1.conda": { + "build": "py27heb65aa2_1", + "build_number": 1, + "depends": [ + "numpy >=1.3", + "python >=2.7,<2.8.0a0", + "scipy >=0.11" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "63fdc4ad61a5f73499bafaaf0de98856", + "name": "pysal", + "sha256": "1cfcc20ea743b6b78aaae2fb9ff046b1d0cc56c2ef384f32c3bb0474408ec938", + "size": 11092451, + "subdir": "linux-64", + "timestamp": 1507871246955, + "version": "1.14.2" + }, + "pysal-1.14.2-py35hb2d4b38_1.conda": { + "build": "py35hb2d4b38_1", + "build_number": 1, + "depends": [ + "numpy >=1.3", + "python >=3.5,<3.6.0a0", + "scipy >=0.11" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e8729f8855b84085abf19e6ef3acf23e", + "name": "pysal", + "sha256": "0facfff3bca80e549084a219d8a3a9fdd73701dd56409cf7e467d4ba87d690e6", + "size": 11109608, + "subdir": "linux-64", + "timestamp": 1507871293238, + "version": "1.14.2" + }, + "pysal-1.14.2-py36h29f3eb4_1.conda": { + "build": "py36h29f3eb4_1", + "build_number": 1, + "depends": [ + "numpy >=1.3", + "python >=3.6,<3.7.0a0", + "scipy >=0.11" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4994edb8507ac9ec0f6d5476bf0d33e3", + "name": "pysal", + "sha256": "fbdfa6d1a5a11e81bb98694d6d1356766cd55d2e3896242ccacaa1beb8b25b3b", + "size": 11102762, + "subdir": "linux-64", + "timestamp": 1507871301139, + "version": "1.14.2" + }, + "pysal-1.14.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.3", + "python >=2.7,<2.8.0a0", + "scipy >=0.11" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4e8076a8c962820bd9a117dc73a4a3e3", + "name": "pysal", + "sha256": "efa1d8d036badb41aadac0c8f5226bb683c08bb1fa8be5a73a3259c7637c90dc", + "size": 11132813, + "subdir": "linux-64", + "timestamp": 1520778670048, + "version": "1.14.3" + }, + "pysal-1.14.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.3", + "python >=3.5,<3.6.0a0", + "scipy >=0.11" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1f2792bc973614977ba44a0d32627e97", + "name": "pysal", + "sha256": "dc7ff98ef6535c58a1a8cd55fd6aa19d8472c7ed404b7e4205ffb08b04f6722b", + "size": 11139769, + "subdir": "linux-64", + "timestamp": 1520778749189, + "version": "1.14.3" + }, + "pysal-1.14.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.3", + "python >=3.6,<3.7.0a0", + "scipy >=0.11" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ac847efb4b16259a19e2a3cf6efe3b8c", + "name": "pysal", + "sha256": "5a7ac51077cd63b73d97a8b2ca5901c10760a8cc6607606e6e2951292c5359b7", + "size": 11122356, + "subdir": "linux-64", + "timestamp": 1520778732027, + "version": "1.14.3" + }, + "pysal-1.14.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.3", + "python >=3.7,<3.8.0a0", + "scipy >=0.11" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a7b2ea1de280ddb16e00d34482acab78", + "name": "pysal", + "sha256": "593ed26508267b168a2df4ace78eefadf944ff6dfb5aaebc4197149a0f889154", + "size": 11116694, + "subdir": "linux-64", + "timestamp": 1530890282570, + "version": "1.14.3" + }, + "pysal-1.14.4.post1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "numpy", + "python >=2.7,<2.8.0a0", + "scipy >=0.11" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6ad5783d36379113241d94acc9e632bf", + "name": "pysal", + "sha256": "af6e4ee18d462a9fd24938683572e2627edee8761bfae2b95793a3731e81b0d7", + "size": 11139142, + "subdir": "linux-64", + "timestamp": 1533000138479, + "version": "1.14.4.post1" + }, + "pysal-1.14.4.post1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "numpy", + "python >=3.5,<3.6.0a0", + "scipy >=0.11" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dc78fe719343dad37a6e851ad18f9497", + "name": "pysal", + "sha256": "332f4650d9d4293ec9db2528f66ce7d97e2faabe1d3c754aff42ea36c0b6d6ef", + "size": 11145387, + "subdir": "linux-64", + "timestamp": 1533000211011, + "version": "1.14.4.post1" + }, + "pysal-1.14.4.post1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "numpy", + "python >=3.6,<3.7.0a0", + "scipy >=0.11" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bbe17a7271567c171354191b78b675cd", + "name": "pysal", + "sha256": "90a1aae95522ec313648658d17d336100c26a28d8715099ef7f4c9a17cf5dab4", + "size": 11151421, + "subdir": "linux-64", + "timestamp": 1533000154874, + "version": "1.14.4.post1" + }, + "pysal-1.14.4.post1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "numpy", + "python >=3.7,<3.8.0a0", + "scipy >=0.11" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20d661d201c47594451901e36ce7ae0e", + "name": "pysal", + "sha256": "a04aff58d7d2949c4d8af1ff44374baa9d938d32b9360b394c5f4434f0e409bf", + "size": 11180155, + "subdir": "linux-64", + "timestamp": 1533000198490, + "version": "1.14.4.post1" + }, + "pyserial-3.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "560b7edd371ac4497e8abd9dfce241aa", + "name": "pyserial", + "sha256": "4cffaa3b64ea3a57e41063938186f73187fa573c2e52d01220c7cae683591b6d", + "size": 120016, + "subdir": "linux-64", + "timestamp": 1530918871110, + "version": "3.4" + }, + "pyserial-3.4-py27h0de3e6d_0.conda": { + "build": "py27h0de3e6d_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b9a17d3ef3da5e997f9a1c2b76d427df", + "name": "pyserial", + "sha256": "ea62160a192ebb2febe4c63cc6e35d40816b00dd19170d84c9ff4ecb9137a008", + "size": 120244, + "subdir": "linux-64", + "timestamp": 1507875888715, + "version": "3.4" + }, + "pyserial-3.4-py35h84edd1e_0.conda": { + "build": "py35h84edd1e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "md5": "0b9393759890d3f7a1c15c171ef6734c", + "name": "pyserial", + "sha256": "723a2adbf5824618d60b3b783cf211ccd4e7dc74d46e236e23b47ab0d89b1946", + "size": 120547, + "subdir": "linux-64", + "timestamp": 1507875917663, + "version": "3.4" + }, + "pyserial-3.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "dd46e4e3e8da50b148d9207edf2d694d", + "name": "pyserial", + "sha256": "973b3b7ffe7be676334b27c9036915c4c15ba3f1b45d547e363a3b24fd00e1d1", + "size": 119181, + "subdir": "linux-64", + "timestamp": 1530918812709, + "version": "3.4" + }, + "pyserial-3.4-py36h08da44b_0.conda": { + "build": "py36h08da44b_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "5c462513d17c990b800ade95c8050c4e", + "name": "pyserial", + "sha256": "68dceb79b930468a464e958c1310ec1d58b93b0e3823227bc7757c3042e2cc10", + "size": 120914, + "subdir": "linux-64", + "timestamp": 1507875923447, + "version": "3.4" + }, + "pyserial-3.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "b7f8292243922c88d09a4c796c527ba0", + "name": "pyserial", + "sha256": "42725c636c893b4f21d54cde6b268d758f0af5deb84f3c25f8418f950d1658c6", + "size": 120732, + "subdir": "linux-64", + "timestamp": 1530918842525, + "version": "3.4" + }, + "pyserial-3.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "a2bfc6390e5bbd43c1a080d205f419ea", + "name": "pyserial", + "sha256": "af9e8c92fb09149eadc5252717909c0e48498b93cae4cc134730f28598523113", + "size": 121211, + "subdir": "linux-64", + "timestamp": 1573200358996, + "version": "3.4" + }, + "pyserial-3.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "187dd062d2aae06207001ef370b6a55e", + "name": "pyserial", + "sha256": "2b9808caa6331eee7b10b22587bf5d8fc7b365a25f529c340c389701df6f77c0", + "size": 131453, + "subdir": "linux-64", + "timestamp": 1642499906645, + "version": "3.5" + }, + "pyserial-3.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "4063da7c4da6dc3d0a7fe83dda9450bf", + "name": "pyserial", + "sha256": "46b8d10f8425a1c352aeef27ed2ac693cf7ee6b436f64cdf06fef20c0108c217", + "size": 175196, + "subdir": "linux-64", + "timestamp": 1676861074301, + "version": "3.5" + }, + "pyserial-3.5-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d74b3062a3a5cdcc63662e0b6faa525c", + "name": "pyserial", + "sha256": "efe73b98acf67ab12373c9bb61c94c48094634013731e7d817545f2dd77d9126", + "size": 128298, + "subdir": "linux-64", + "timestamp": 1606431141801, + "version": "3.5" + }, + "pyserial-3.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "17cf3ea166f3c3096ccbba3337045664", + "name": "pyserial", + "sha256": "507cd809d8fd92f985901897b87b9f514e8e11bae1dd9648379237af91af529c", + "size": 128196, + "subdir": "linux-64", + "timestamp": 1606431150386, + "version": "3.5" + }, + "pyserial-3.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "5bcda41e922583d6fa8c7c811a5048c2", + "name": "pyserial", + "sha256": "65e87f698a56eb3b0f25bea07344c76acb3eba4601a944547ea0a21bd46f9a27", + "size": 130300, + "subdir": "linux-64", + "timestamp": 1606431151118, + "version": "3.5" + }, + "pyserial-3.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "788d5c98ef5ad3ac8062d6615fb22d66", + "name": "pyserial", + "sha256": "5f2c3613cac5993c8002ffbe29abc3389728a4f1e5eee3ba7159f15645f87e85", + "size": 128678, + "subdir": "linux-64", + "timestamp": 1606431149231, + "version": "3.5" + }, + "pyshp-1.2.12-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7ef7e2be3f7e0a9a56d5509d140e10f8", + "name": "pyshp", + "sha256": "c7325b546a2da9fc675f9945b9bd41ce9288b2c7f1e6eba061d390bb1d736829", + "size": 36883, + "subdir": "linux-64", + "timestamp": 1530811614612, + "version": "1.2.12" + }, + "pyshp-1.2.12-py27h4b1cd21_0.conda": { + "build": "py27h4b1cd21_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "66989953a2e6a088ac32a512daa47ff7", + "name": "pyshp", + "sha256": "cbaf83178a5ea16f322294aec5806f4d0f51426c8cbe1c6474f0b9c7866cf303", + "size": 37101, + "subdir": "linux-64", + "timestamp": 1511990085595, + "version": "1.2.12" + }, + "pyshp-1.2.12-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "d417a1b990c5b1aaeef636bc8621b483", + "name": "pyshp", + "sha256": "8aadd93b811d06cd4c3fd966801af767de313e381b2fce7c751ccab7b538ad3d", + "size": 37164, + "subdir": "linux-64", + "timestamp": 1535129740912, + "version": "1.2.12" + }, + "pyshp-1.2.12-py35h9dba027_0.conda": { + "build": "py35h9dba027_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "ec9e75eed4b3e8880efdf607c597ad0c", + "name": "pyshp", + "sha256": "2817b22cc0dca81abf3075d86d8c189fdd9aca986da7d96d5cdf14c4107ec2bb", + "size": 37795, + "subdir": "linux-64", + "timestamp": 1511990061213, + "version": "1.2.12" + }, + "pyshp-1.2.12-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2d50cbcfa28f04bdb78d3f1eaafc350d", + "name": "pyshp", + "sha256": "8f1a7b8d5ba48f562f17a50d8114bacc05609dcd6346f8ddfba662da4b0eff22", + "size": 36947, + "subdir": "linux-64", + "timestamp": 1530811663159, + "version": "1.2.12" + }, + "pyshp-1.2.12-py36h04d6e4e_0.conda": { + "build": "py36h04d6e4e_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "211f5a9e92112ad64f1db1ff3315747a", + "name": "pyshp", + "sha256": "cfa5a043d721abcbf69fcefe9797ea8ae562419b8102483c65365679df90c031", + "size": 37478, + "subdir": "linux-64", + "timestamp": 1511990129354, + "version": "1.2.12" + }, + "pyshp-1.2.12-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4baaf2166c945682574fdae244cb3929", + "name": "pyshp", + "sha256": "79ea39935d8843c652218e13875b58b319d9a6d5066c548d6e84df6b2aa2d60b", + "size": 37402, + "subdir": "linux-64", + "timestamp": 1530811638463, + "version": "1.2.12" + }, + "pyshp-2.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "0a74bb73ec5d9151ecc6aa3e45d370c9", + "name": "pyshp", + "sha256": "bd0cb21bfe0485546a06d7703c225eaedb37124b209fbea6c1ec40a2c50714b7", + "size": 49535, + "subdir": "linux-64", + "timestamp": 1545102059800, + "version": "2.0.1" + }, + "pyshp-2.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "713510b0489931ae15aa90e6dd25c146", + "name": "pyshp", + "sha256": "bb04825119bf00ff7bdf366dbaaf5c7c60e7a2853bdaee9fe07e3d68dce7eb4f", + "size": 49862, + "subdir": "linux-64", + "timestamp": 1545102080194, + "version": "2.0.1" + }, + "pyshp-2.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "86036b50f7d6593ec88d73a7f55f42d8", + "name": "pyshp", + "sha256": "e9fc56b5d2725c7b20f601afe3c1ea5f9d26cd4e61727b74d3a54ef8c5978056", + "size": 48263, + "subdir": "linux-64", + "timestamp": 1545102069150, + "version": "2.0.1" + }, + "pysmi-0.1.4-py27h12e9649_0.conda": { + "build": "py27h12e9649_0", + "build_number": 0, + "depends": [ + "ply", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "abb2b87221de4b7f708ed5a788db95f0", + "name": "pysmi", + "sha256": "bd0e0199a6b9a9dbbde5cf1df413efb305d5e56fee3f9d698d5b83da8048e75d", + "size": 102319, + "subdir": "linux-64", + "timestamp": 1509140584942, + "version": "0.1.4" + }, + "pysmi-0.1.4-py35h9877fdf_0.conda": { + "build": "py35h9877fdf_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "97af3d7681cdb53adb8190a08fd805f8", + "name": "pysmi", + "sha256": "8c71c94c05ba94bd7f2df100fb9df98702805a920a83eb6819dd029d6d42f60c", + "size": 103675, + "subdir": "linux-64", + "timestamp": 1509140602351, + "version": "0.1.4" + }, + "pysmi-0.1.4-py36ha4c3b21_0.conda": { + "build": "py36ha4c3b21_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f36849814870a0e577c62ff86232b585", + "name": "pysmi", + "sha256": "bad2a612b69ecc60d0901aa15b242dbd48a956597c0f2707b48d6cb6be97852c", + "size": 102242, + "subdir": "linux-64", + "timestamp": 1509140601495, + "version": "0.1.4" + }, + "pysmi-0.2.2-py27hefb46da_0.conda": { + "build": "py27hefb46da_0", + "build_number": 0, + "depends": [ + "ply", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c3d1730057d608a41eb0bdd3bda9b668", + "name": "pysmi", + "sha256": "5a3ab0b13261ca6c537c8da4347a6a11109c868437c2f7370690273d64cbe3a3", + "size": 103415, + "subdir": "linux-64", + "timestamp": 1511322143254, + "version": "0.2.2" + }, + "pysmi-0.2.2-py35hfe9e08f_0.conda": { + "build": "py35hfe9e08f_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "94e0e6aa62c16263b1ba474950b09b77", + "name": "pysmi", + "sha256": "99599841938ddfc6a5a7d0631763af787c227e604657424f169394091fcd61bf", + "size": 104742, + "subdir": "linux-64", + "timestamp": 1511322146247, + "version": "0.2.2" + }, + "pysmi-0.2.2-py36h46a7435_0.conda": { + "build": "py36h46a7435_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9d3bfa7e66a6ae1fce060490619b4bec", + "name": "pysmi", + "sha256": "adb95ca79da7df92b2327233705c5b62a6e8a13254dfe7e36b2bee64ce94f822", + "size": 103308, + "subdir": "linux-64", + "timestamp": 1511322151645, + "version": "0.2.2" + }, + "pysmi-0.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ply", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "447e052f4dfbf75eb27b7d9ccb867a3e", + "name": "pysmi", + "sha256": "458161fd0a48c250175b360aeb25afbf15eae779228eaac495857a36c78528be", + "size": 106491, + "subdir": "linux-64", + "timestamp": 1526122923843, + "version": "0.3.0" + }, + "pysmi-0.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e3545ad942482d4f752995489824e774", + "name": "pysmi", + "sha256": "0992a406cf273da4bd4ea79cc131d79b0d218e048e9c334b21a354543c0c8dde", + "size": 110722, + "subdir": "linux-64", + "timestamp": 1526121861955, + "version": "0.3.0" + }, + "pysmi-0.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f1444aa8564b8ffad2e0822c3f314d2b", + "name": "pysmi", + "sha256": "e92d2e84d4ae826b73a129d434dc7bc46c318111eabaf085167eb72dffc2a493", + "size": 109065, + "subdir": "linux-64", + "timestamp": 1526121778316, + "version": "0.3.0" + }, + "pysmi-0.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ply", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "fbe2f699b03effdfe0ba74cbd5c269bd", + "name": "pysmi", + "sha256": "fef2cb97f4da210078d4df284dce65cd5c3a695caddf631c171db961b836fc84", + "size": 106515, + "subdir": "linux-64", + "timestamp": 1529425826596, + "version": "0.3.1" + }, + "pysmi-0.3.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "e7ce2f10c5b55ab8a1a7f640527368eb", + "name": "pysmi", + "sha256": "3085506fb128c7406093b9150b357a6b2eb800d72dd1873367b3bf77f0e484fd", + "size": 109123, + "subdir": "linux-64", + "timestamp": 1529425840327, + "version": "0.3.1" + }, + "pysmi-0.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f1ca5b0717d0049f51df3b9a0dd69ec8", + "name": "pysmi", + "sha256": "603f96a8fd0445f16a0124c24e9bbb0b733c2046c16d00335ab825515693db89", + "size": 109079, + "subdir": "linux-64", + "timestamp": 1529425809027, + "version": "0.3.1" + }, + "pysmi-0.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b1bb6f5fcb046f1abacc26e8cbea42ad", + "name": "pysmi", + "sha256": "d90abed040f4ce0484b3e9510ce011da7bc10730dc3162a1304aee058f14ee31", + "size": 108410, + "subdir": "linux-64", + "timestamp": 1530918904316, + "version": "0.3.1" + }, + "pysmi-0.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ply", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a71c3eb3a18e46caa648368f8997b46f", + "name": "pysmi", + "sha256": "d65e280235f967adbfc2be582a0c9ef7f802d2cd3b81cf494f8d3f8a9b8c3fd3", + "size": 108016, + "subdir": "linux-64", + "timestamp": 1541034462136, + "version": "0.3.2" + }, + "pysmi-0.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "16e83e8f56efd46a3d8a4c1c314a7ea8", + "name": "pysmi", + "sha256": "e68df61e239e27c06d934cd0b3f17c8b2812baae6feca6f59994c604f9e23a71", + "size": 109411, + "subdir": "linux-64", + "timestamp": 1541034512076, + "version": "0.3.2" + }, + "pysmi-0.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4ba6774a43dc72f8993f21de64f2f488", + "name": "pysmi", + "sha256": "503d465c8ecde8d30f436efe42faca52e52068ada7af3b6b6651760a4a5fe77f", + "size": 108553, + "subdir": "linux-64", + "timestamp": 1541034468938, + "version": "0.3.2" + }, + "pysmi-0.3.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ply", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9cd5e9bdfaa3a07440c198556235a2a5", + "name": "pysmi", + "sha256": "c96dc914d653674b9740a32b3e14b159e77b4858eb47fbfd5e2b40c2ed9f699f", + "size": 108044, + "subdir": "linux-64", + "timestamp": 1547249575167, + "version": "0.3.3" + }, + "pysmi-0.3.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9fc0c6f5e10bd48a7cd6307822685fe2", + "name": "pysmi", + "sha256": "58364d879807705746195996de8c08a4e9fda3999075387e57950f3a12c49b1d", + "size": 110588, + "subdir": "linux-64", + "timestamp": 1547249610575, + "version": "0.3.3" + }, + "pysmi-0.3.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ply", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "98f29814bccd562ede0cd30492ac4f2a", + "name": "pysmi", + "sha256": "0800400c72b796451002e69879349eb08fdc43a9f1b4212c68ce594a131f4ca1", + "size": 110091, + "subdir": "linux-64", + "timestamp": 1547249586293, + "version": "0.3.3" + }, + "pysnmp-4.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=2.7,<2.8.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9919e7eacdc3d00bc7f37a5f50065bcf", + "name": "pysnmp", + "sha256": "bb9a31b1dd23e82f1095517d9d959c05e5f42be5c9173fa590069d1fb699fdca", + "size": 322402, + "subdir": "linux-64", + "timestamp": 1513015784351, + "version": "4.4.2" + }, + "pysnmp-4.4.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.5,<3.6.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "6cf111e0accf536ebe048c3501faf82e", + "name": "pysnmp", + "sha256": "ac203de94203150098e65568094f332b67587e3bad83b54eb624bb96c6c8a5f9", + "size": 333351, + "subdir": "linux-64", + "timestamp": 1513015793253, + "version": "4.4.2" + }, + "pysnmp-4.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.6,<3.7.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "4ceb281b2b7f66d4a62362c240ecdc34", + "name": "pysnmp", + "sha256": "c71ed829e3baacc28bbb894f4e500f7f1ddf54590305fe9104638e6ed604501c", + "size": 329377, + "subdir": "linux-64", + "timestamp": 1513015818325, + "version": "4.4.2" + }, + "pysnmp-4.4.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=2.7,<2.8.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "94056bc6c0bd1c5fab45cf11873e8ce6", + "name": "pysnmp", + "sha256": "1a470b67ac46ad3e3bdecf656f8e7f1ade4730bfaabf58036661000bf5a98618", + "size": 322121, + "subdir": "linux-64", + "timestamp": 1520835671081, + "version": "4.4.4" + }, + "pysnmp-4.4.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.5,<3.6.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "47fcf56c28b7a9bc6ac6d4c6ae7f5347", + "name": "pysnmp", + "sha256": "fc478ddb2ac6a1cb7f845ec51215b9f16421735a97b6f305d385bdb6bb142f93", + "size": 328395, + "subdir": "linux-64", + "timestamp": 1520835691668, + "version": "4.4.4" + }, + "pysnmp-4.4.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.6,<3.7.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "3c0f4b4b05b8ee8e448c53b432b3ac9b", + "name": "pysnmp", + "sha256": "285e443da7ce815ae6aeaa2c107a17e7556222f3865f4814d64c985612784ff5", + "size": 328896, + "subdir": "linux-64", + "timestamp": 1520835665029, + "version": "4.4.4" + }, + "pysnmp-4.4.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.7,<3.8.0a0", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f77b940d430e7193aceca04ee5de0565", + "name": "pysnmp", + "sha256": "b1121a371f54c032f72eeec77ce73fcb4c9b9859c3929097ee7cb85514b2066d", + "size": 323511, + "subdir": "linux-64", + "timestamp": 1530919886810, + "version": "4.4.4" + }, + "pysnmp-4.4.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=2.7,<2.8.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f9b61dcc1b23ccb1488889b29375aeb1", + "name": "pysnmp", + "sha256": "49c24725bd4e1c40d9cd90d42cdadd65f1c8d59e4fb4463fb599d03ea9c64584", + "size": 327505, + "subdir": "linux-64", + "timestamp": 1536257734590, + "version": "4.4.5" + }, + "pysnmp-4.4.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.5,<3.6.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "13e2f20665df91d05993cf43a274c2ad", + "name": "pysnmp", + "sha256": "501ccd8a8156900bea6b44ad4cfc82127291f8b7e2eb3ada7c077b52420188b3", + "size": 330393, + "subdir": "linux-64", + "timestamp": 1536260831814, + "version": "4.4.5" + }, + "pysnmp-4.4.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.6,<3.7.0a0", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c77fe5218e1fe8c7e910cbbabde69143", + "name": "pysnmp", + "sha256": "40074532661f757ea08a6f12b1e90a44eb06da746b0b7785f885707a1a63c6c9", + "size": 327315, + "subdir": "linux-64", + "timestamp": 1536257673672, + "version": "4.4.5" + }, + "pysnmp-4.4.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.7,<3.8.0a0", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "487fc5083f0a0656dabb321a90f45284", + "name": "pysnmp", + "sha256": "c4c24bb90672c7632fcc25d0239f78f7e21b916c5329a4045243faa8a1e2be26", + "size": 327033, + "subdir": "linux-64", + "timestamp": 1536257775851, + "version": "4.4.5" + }, + "pysnmp-4.4.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=2.7,<2.8.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "722665cea82ea0882eb69b035d42d109", + "name": "pysnmp", + "sha256": "d7acf0409770b4a9da8519e4b11a7a22c5021ef410be79a078b883d6aa8d5ee5", + "size": 327593, + "subdir": "linux-64", + "timestamp": 1539646975908, + "version": "4.4.6" + }, + "pysnmp-4.4.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.6,<3.7.0a0", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c9d1687470bcb51ee4057bfbd8a05f29", + "name": "pysnmp", + "sha256": "0289053a285948300e8ae269144c8d9d3e6b9f553066708eb91bdfd4dcd8ad9f", + "size": 331514, + "subdir": "linux-64", + "timestamp": 1539646987285, + "version": "4.4.6" + }, + "pysnmp-4.4.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.7,<3.8.0a0", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "20e6efe874833769d2e6ec00fa4b4aa5", + "name": "pysnmp", + "sha256": "961bf4eb756d3f7419cf3326bc998f00899c79e7b959a06b209e26292599c860", + "size": 330767, + "subdir": "linux-64", + "timestamp": 1539646971182, + "version": "4.4.6" + }, + "pysnmp-4.4.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=2.7,<2.8.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c4e526075c9d29c2a660349b633e5ad0", + "name": "pysnmp", + "sha256": "df5967b19c8a42ed3878a3beed8c0c2604f564002171bf1d00bc40de48678dba", + "size": 329431, + "subdir": "linux-64", + "timestamp": 1547250137082, + "version": "4.4.8" + }, + "pysnmp-4.4.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.6,<3.7.0a0", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c700c99635cf2cfd6561048e495a9fee", + "name": "pysnmp", + "sha256": "61ab9c8d5efcbb2c4541919d017142ed7bf0c47678029b9f415da9d5733b86ca", + "size": 328961, + "subdir": "linux-64", + "timestamp": 1547250107947, + "version": "4.4.8" + }, + "pysnmp-4.4.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.7,<3.8.0a0", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "230b43236a0a689281dd9ca438d559bb", + "name": "pysnmp", + "sha256": "f36102aec7e0e654de2080c059f4a0ae61a9077d84f4b78a3db6c33ddc735819", + "size": 328908, + "subdir": "linux-64", + "timestamp": 1547250146119, + "version": "4.4.8" + }, + "pysnmp-4.4.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=2.7,<2.8.0a0", + "trollius", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b59e931e0f45d807e509da0c0efe9151", + "name": "pysnmp", + "sha256": "4b4d18928d7bf4e9c1980ca9c7b330d9d3e36cd2193ef5ea7913cd31a7b1c7ed", + "size": 329860, + "subdir": "linux-64", + "timestamp": 1550352757382, + "version": "4.4.9" + }, + "pysnmp-4.4.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.6,<3.7.0a0", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ba8da1e6d58fbeae4e550bc436ea5934", + "name": "pysnmp", + "sha256": "c6081f2cac4d1645701f0b4c07a52876e71c92348e559f20382ab8d300645dc9", + "size": 333388, + "subdir": "linux-64", + "timestamp": 1550352803771, + "version": "4.4.9" + }, + "pysnmp-4.4.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pyasn1 >=0.2.3", + "pycryptodomex", + "pysmi", + "python >=3.7,<3.8.0a0", + "twisted" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "587aead0ca4dea4437b747914e8d42ac", + "name": "pysnmp", + "sha256": "dce09245f11ba2a959005aae9f9c5a9c27f2307faeb85a30b14072fe3001367f", + "size": 329290, + "subdir": "linux-64", + "timestamp": 1550352737723, + "version": "4.4.9" + }, + "pysocks-1.6.7-py27he2db6d2_1.conda": { + "build": "py27he2db6d2_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b11ade425972b8e0ed7dc2a0ec9ac9b3", + "name": "pysocks", + "sha256": "ee3856e2228789f377c62bf7c59e86ff9173914ed801346f1f819f540ed35f8d", + "size": 23459, + "subdir": "linux-64", + "timestamp": 1505692990681, + "version": "1.6.7" + }, + "pysocks-1.6.7-py35h6aefbb0_1.conda": { + "build": "py35h6aefbb0_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "949c515a66104036b8e554ac7ac35231", + "name": "pysocks", + "sha256": "14ded15529a8fdb4e7feac0fbb3c74b65788cb0898693b5cdc94ed89a8b8deec", + "size": 23705, + "subdir": "linux-64", + "timestamp": 1505693001886, + "version": "1.6.7" + }, + "pysocks-1.6.7-py36hd97a5b1_1.conda": { + "build": "py36hd97a5b1_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bd56da0f6cf2b05d17a6ce207363ba77", + "name": "pysocks", + "sha256": "fed77650b9224827d556356d5f90560018f23198966cfb0638680a31ab560df4", + "size": 23306, + "subdir": "linux-64", + "timestamp": 1505693013263, + "version": "1.6.7" + }, + "pysocks-1.6.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3f5e14d5a3da5733f236a1420e29dd99", + "name": "pysocks", + "sha256": "11e21d86e258bf99f5d97354d7ebf9d78803d4d564027989445fb0efa560dd7d", + "size": 23902, + "subdir": "linux-64", + "timestamp": 1519749372651, + "version": "1.6.8" + }, + "pysocks-1.6.8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "218e1ded5631bb269fbc1a6342328a63", + "name": "pysocks", + "sha256": "0f7b4bedbfd96db4297421db21f865c4638a576ec8a80c4eab50458c5ac5ba4c", + "size": 24010, + "subdir": "linux-64", + "timestamp": 1519749383502, + "version": "1.6.8" + }, + "pysocks-1.6.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a92f29eec42c31de10b9cd5d6f7cc9c7", + "name": "pysocks", + "sha256": "bc5e8b836d1fc797b21a0eef6164217148ead5dab5d8485b9bfc5b3d0b7126b0", + "size": 23742, + "subdir": "linux-64", + "timestamp": 1519749335733, + "version": "1.6.8" + }, + "pysocks-1.6.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4c088f91f3aedc63a124f4601ba03ac9", + "name": "pysocks", + "sha256": "faf0b1d37610d3b0f4598c01ec5e26ac5cab0457de774a1a1f78e5ffd30c8dd5", + "size": 23663, + "subdir": "linux-64", + "timestamp": 1530733440464, + "version": "1.6.8" + }, + "pysocks-1.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d2c7f865f03f7a7a36a87c0bbd2b2ebe", + "name": "pysocks", + "sha256": "c6b6fe344e1001778a28f0e8c7f039477596536334587dd3f0516bbba4539554", + "size": 31164, + "subdir": "linux-64", + "timestamp": 1557856220196, + "version": "1.7.0" + }, + "pysocks-1.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "319d347e1032fe398ec3fe9cc5ea4310", + "name": "pysocks", + "sha256": "f3ce06c77f34962a310bec6744bf0d4b47bc9d8ecbdf648e0c3d234b58b9e6ab", + "size": 31290, + "subdir": "linux-64", + "timestamp": 1557856250917, + "version": "1.7.0" + }, + "pysocks-1.7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8333fff58092305dbb90463e8d76a1c8", + "name": "pysocks", + "sha256": "934b72c2b4243f2eb903fa22f01f27eff0f1921697f3cc1f820e2c48a9b25f90", + "size": 31384, + "subdir": "linux-64", + "timestamp": 1557856209609, + "version": "1.7.0" + }, + "pysocks-1.7.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c6101950bf47cfd22b7b633b7aff7f27", + "name": "pysocks", + "sha256": "23fcc2726d47ba675e1439d8c7f6c89f1c09ceab4191817cbc42e2f3a0a3be6c", + "size": 31266, + "subdir": "linux-64", + "timestamp": 1569264607885, + "version": "1.7.1" + }, + "pysocks-1.7.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b0753810caadcd4a550c833f87fb3866", + "name": "pysocks", + "sha256": "4ae4c13a181087485244bfdfe3cee8d3e69ca53d87f3f3fe30f2874b833359b3", + "size": 28895, + "subdir": "linux-64", + "timestamp": 1640793693853, + "version": "1.7.1" + }, + "pysocks-1.7.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0c6bf55446eb174d2c749fd9499ca181", + "name": "pysocks", + "sha256": "90d1f144eaf1ef0b9bc9a97a5639fb51805f9da77046458b4a8295ea25c19c5b", + "size": 36232, + "subdir": "linux-64", + "timestamp": 1676822725516, + "version": "1.7.1" + }, + "pysocks-1.7.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4236fb1bb19f41112b7d5274b906912e", + "name": "pysocks", + "sha256": "7335eda104ee8de9866719e89adc2ae6afbf167c10bc559d89fd459056776a55", + "size": 31133, + "subdir": "linux-64", + "timestamp": 1569264610669, + "version": "1.7.1" + }, + "pysocks-1.7.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9a5889932015679353567c013434ea3e", + "name": "pysocks", + "sha256": "9b9326e2a59dde79bd387f935f98bd6607bdfc097a3c2f2b0f1d8454a27ab60f", + "size": 31365, + "subdir": "linux-64", + "timestamp": 1605305791334, + "version": "1.7.1" + }, + "pysocks-1.7.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "89737ce4b1f1270da0cf2545bb65eb5a", + "name": "pysocks", + "sha256": "0bdfdaeec873176cbe07186dc3cdb580d6d56a222dbbedb1d729f07414fc9ce8", + "size": 31312, + "subdir": "linux-64", + "timestamp": 1569264610199, + "version": "1.7.1" + }, + "pysocks-1.7.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d68cfce2ae084a8184ccf8f0209230b5", + "name": "pysocks", + "sha256": "406c289bfc7628c0470e9e58fe62a28f536b98a2c3df556e97ccea28a0f72c85", + "size": 28052, + "subdir": "linux-64", + "timestamp": 1594394604963, + "version": "1.7.1" + }, + "pysocks-1.7.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "43a6974533ca2d2f9cf3960f5699b401", + "name": "pysocks", + "sha256": "1bd340fd600874001c978be7a273fffc4b92d1dec02a61236737182de6b1f54a", + "size": 31544, + "subdir": "linux-64", + "timestamp": 1605305820900, + "version": "1.7.1" + }, + "pysocks-1.7.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "148079353d446b5a99b5082682b975af", + "name": "pysocks", + "sha256": "c5f293f3e5c3bfc2cd647d652725955541a484057d5f482c8d414dabd3daddfd", + "size": 28607, + "subdir": "linux-64", + "timestamp": 1573200379215, + "version": "1.7.1" + }, + "pysocks-1.7.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "21c67581f3a81ffbb02728eb2178d693", + "name": "pysocks", + "sha256": "59e37131acb2f5125e0942bc0f28c8ee58d034a078ab136d3f4ede64ef7bbc21", + "size": 31771, + "subdir": "linux-64", + "timestamp": 1605305807726, + "version": "1.7.1" + }, + "pysocks-1.7.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0a2dc6c521fd674b11a99dea461c2d84", + "name": "pysocks", + "sha256": "ead83f9ff403c95124f8f7bd88a3af1d195139a316cf53d881430cad7d09d870", + "size": 31752, + "subdir": "linux-64", + "timestamp": 1605305847037, + "version": "1.7.1" + }, + "pyspark-2.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.6.*", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "ea64f2e7722395a754ff3104b72af9ec", + "name": "pyspark", + "sha256": "3331a1c253efd81c4337f428b87d94372321a5d0e20bcc22178e72760dc2b9bd", + "size": 203368524, + "subdir": "linux-64", + "timestamp": 1520534061360, + "version": "2.3.0" + }, + "pyspark-2.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.6.*", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "568e39ebf023488a659003be46db6d0a", + "name": "pyspark", + "sha256": "d52e1a1ba1190462700c5bf75cc0c2b988f947a0353a0f9d7dfec291afae3d5d", + "size": 203372327, + "subdir": "linux-64", + "timestamp": 1520534149093, + "version": "2.3.0" + }, + "pyspark-2.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.6.*", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "343a023dd5417f41258ff4e40dd3390e", + "name": "pyspark", + "sha256": "32ee83e9b630c8a9a593bd6cbab5cd9b7a75e97ea7b9643a5a6a4eacde79846a", + "size": 203383795, + "subdir": "linux-64", + "timestamp": 1520534057073, + "version": "2.3.0" + }, + "pyspark-2.3.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "d5e00b88d7e44c643557f350a2ceeec2", + "name": "pyspark", + "sha256": "68909bca1d9009ee1a042e814f0ae45d437f02ff67d4f4d10fd04d95d3f26c9f", + "size": 203420020, + "subdir": "linux-64", + "timestamp": 1528748498889, + "version": "2.3.1" + }, + "pyspark-2.3.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "be0f3c87b5b59bc0471d64aecba03d33", + "name": "pyspark", + "sha256": "3274b046a9b24bca82240848f7e98fee8158474a7a314e48c9e9010011d2b363", + "size": 203426633, + "subdir": "linux-64", + "timestamp": 1528748969511, + "version": "2.3.1" + }, + "pyspark-2.3.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "ab856513e813dbe7cd1f6a209da137b3", + "name": "pyspark", + "sha256": "9f91b194c8e58c47e1b6fa93ed30e6af1e9df22b81cf3b0d614813b2e634eca0", + "size": 203459574, + "subdir": "linux-64", + "timestamp": 1528748992153, + "version": "2.3.1" + }, + "pyspark-2.3.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "4b3857cde07a7f7ab121db23ffa031e8", + "name": "pyspark", + "sha256": "a8fdef1a30707b3ae01e844f8acc394988a9973cf5775b3a4b829b669d4883d8", + "size": 203437999, + "subdir": "linux-64", + "timestamp": 1530920030907, + "version": "2.3.1" + }, + "pyspark-2.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "ae84e8ca50b5ec94ddd9c837602af3b4", + "name": "pyspark", + "sha256": "4915a0c00c6f8156b4ccf25464f3dcb221c691a194b03ed98a4a992ab13362ca", + "size": 203525089, + "subdir": "linux-64", + "timestamp": 1539639191754, + "version": "2.3.2" + }, + "pyspark-2.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "0b748e221868c79254136ab9d66f7775", + "name": "pyspark", + "sha256": "665ae770cb2b521e8280bdeb72b8d6f25df4ede895e031ff73d274a0af7ebc8e", + "size": 203524440, + "subdir": "linux-64", + "timestamp": 1539639169744, + "version": "2.3.2" + }, + "pyspark-2.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "cee04501b293cdddfa9886938e9f4aad", + "name": "pyspark", + "sha256": "f0752bfce08e07b575609900d47ce341fe7f33975fc9caa1eeaaf6152762e53f", + "size": 203543522, + "subdir": "linux-64", + "timestamp": 1539639241181, + "version": "2.3.2" + }, + "pyspark-2.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "9cc988f6ca0c95aa669de6f7d9b3e39c", + "name": "pyspark", + "sha256": "551e41b78a26c7004e26dc73bacc4e833a76d7241493e4fb2172cc79aab6c3a4", + "size": 204770953, + "subdir": "linux-64", + "timestamp": 1541442097023, + "version": "2.4.0" + }, + "pyspark-2.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "9db6a40386e4c414f619734f0361fc2d", + "name": "pyspark", + "sha256": "d46031891ca51228ae8d6863f3dfda04bf0975950ede8457259a7a752d84e270", + "size": 204793703, + "subdir": "linux-64", + "timestamp": 1541442157442, + "version": "2.4.0" + }, + "pyspark-2.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.7", + "pandas >=0.13.0", + "py4j 0.10.7.*", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "610aef45512ec2c2cedce42b82996f03", + "name": "pyspark", + "sha256": "cafa85def2643bcd9346f476a9b093df160e9088a2da1b7b16e29e4d4b13183f", + "size": 204809557, + "subdir": "linux-64", + "timestamp": 1541442130621, + "version": "2.4.0" + }, + "pyspark-3.2.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14", + "pandas >=0.23.2", + "py4j 0.10.9.3", + "pyarrow >=1.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "971c494b60cb2e889b527a21ece983c3", + "name": "pyspark", + "sha256": "37214d1a1b7af85ac64b8e5b7c1c7d635b10f6ea5247465db304b45387b98a44", + "size": 276686833, + "subdir": "linux-64", + "timestamp": 1670256414556, + "version": "3.2.1" + }, + "pyspark-3.2.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14", + "pandas >=0.23.2", + "py4j 0.10.9.3", + "pyarrow >=1.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "39f8906d45a6b93f209802fa5a83d07c", + "name": "pyspark", + "sha256": "db4470d1b06ee6660b1e0041b77412a2ebfc0ad2868c2f2b56cdadd39704f200", + "size": 275007678, + "subdir": "linux-64", + "timestamp": 1676861111197, + "version": "3.2.1" + }, + "pyspark-3.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14", + "pandas >=0.23.2", + "py4j 0.10.9.3", + "pyarrow >=1.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6f526449d0099e874c6b255e06414894", + "name": "pyspark", + "sha256": "923835fbfd740ff78c7a3ccea3449cc1d496ebf963a922b4a014dc03edd5e9e1", + "size": 276664047, + "subdir": "linux-64", + "timestamp": 1670256198845, + "version": "3.2.1" + }, + "pyspark-3.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14", + "pandas >=0.23.2", + "py4j 0.10.9.3", + "pyarrow >=1.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "143bedc5505a26e778ad35e09f76839c", + "name": "pyspark", + "sha256": "7846a3b962a78bddc09a8456150815d8b7252d8f9c8db5ce0573a04674c849e1", + "size": 276684276, + "subdir": "linux-64", + "timestamp": 1670256832687, + "version": "3.2.1" + }, + "pyspark-3.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.14", + "pandas >=0.23.2", + "py4j 0.10.9.3", + "pyarrow >=1.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a5955983893bbe70767bbf8032dc9ad2", + "name": "pyspark", + "sha256": "454cce0a00b313f2f0a9f433e9f0197a10e0c07292761dedb635464d3083d121", + "size": 276693280, + "subdir": "linux-64", + "timestamp": 1670256622608, + "version": "3.2.1" + }, + "pyspnego-0.3.1-py310h5eee18b_2.conda": { + "build": "py310h5eee18b_2", + "build_number": 2, + "depends": [ + "cryptography", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e81517ce210e5f5d9f429c1d84b4c8e7", + "name": "pyspnego", + "sha256": "16e6b19a8379c3c3704929892494d89a3ae01771797b2b49d1502154298c2629", + "size": 166252, + "subdir": "linux-64", + "timestamp": 1662368652256, + "version": "0.3.1" + }, + "pyspnego-0.3.1-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "constrains": [ + "python-gssapi >=1.5.0" + ], + "depends": [ + "cryptography", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "md5": "1b4af4a9de06b125e3e39dac2c77d33c", + "name": "pyspnego", + "sha256": "4633df078c792cef2c5e7827cf99700e03af930e9c4690083140f0938a99ab7d", + "size": 165914, + "subdir": "linux-64", + "timestamp": 1641550961076, + "version": "0.3.1" + }, + "pyspnego-0.3.1-py311h5eee18b_2.conda": { + "build": "py311h5eee18b_2", + "build_number": 2, + "depends": [ + "cryptography", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "67e261e559543eba5fa77d5a1b204306", + "name": "pyspnego", + "sha256": "26ca8b2e670ce931cb89381ec2baebc4104750dbc054596495a1460071c196e9", + "size": 220211, + "subdir": "linux-64", + "timestamp": 1676861257231, + "version": "0.3.1" + }, + "pyspnego-0.3.1-py37h5eee18b_2.conda": { + "build": "py37h5eee18b_2", + "build_number": 2, + "depends": [ + "cryptography", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33ce429355dd2e27339f35faffc32f6b", + "name": "pyspnego", + "sha256": "c79abec6776eb425a7c6b92a1560cd7631a2240592a33ff90e14bc20b8ed40c0", + "size": 163579, + "subdir": "linux-64", + "timestamp": 1662368752557, + "version": "0.3.1" + }, + "pyspnego-0.3.1-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "cryptography", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6cbe29b946efaabba9063a0baf830b92", + "name": "pyspnego", + "sha256": "25a98de2ed59bee7c7af21a024b12fca12547dba12986d6e99b2c16f8505a6f1", + "size": 163802, + "subdir": "linux-64", + "timestamp": 1640321105778, + "version": "0.3.1" + }, + "pyspnego-0.3.1-py38h5eee18b_2.conda": { + "build": "py38h5eee18b_2", + "build_number": 2, + "depends": [ + "cryptography", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8610eee6899263da4f8ef93d90a1157", + "name": "pyspnego", + "sha256": "d7a786d45f23847a22fb476fffc4639862aa5ab4d721bcab28845874aad31340", + "size": 164590, + "subdir": "linux-64", + "timestamp": 1662368684787, + "version": "0.3.1" + }, + "pyspnego-0.3.1-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "cryptography", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49cab75a89f335ead4d52254e76f0980", + "name": "pyspnego", + "sha256": "0dc7e6d7df691a18584a5795075aacd5af499155066386d5cbf2419c254e2cb4", + "size": 164709, + "subdir": "linux-64", + "timestamp": 1640339582941, + "version": "0.3.1" + }, + "pyspnego-0.3.1-py39h5eee18b_2.conda": { + "build": "py39h5eee18b_2", + "build_number": 2, + "depends": [ + "cryptography", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e1cf8a3a59ff40d794074ed7b06f3dc", + "name": "pyspnego", + "sha256": "e15568f0d7eee5d48beea92cc5406a3dc4094dc06f84887b51a03d5b653cb9c3", + "size": 164571, + "subdir": "linux-64", + "timestamp": 1662368718996, + "version": "0.3.1" + }, + "pyspnego-0.3.1-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "cryptography", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "42ba9dd0a6c7b35dab1b02f51505b27b", + "name": "pyspnego", + "sha256": "00718af4fd9330b4e4f4db3e0d75752e0291dc7cc45238de04973ccd16255c26", + "size": 167095, + "subdir": "linux-64", + "timestamp": 1640325019333, + "version": "0.3.1" + }, + "pyspnego-0.3.1-py39h7f8727e_1.conda": { + "build": "py39h7f8727e_1", + "build_number": 1, + "constrains": [ + "python-gssapi >=1.5.0" + ], + "depends": [ + "cryptography", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "md5": "2f6d77c9044ffdb2d63180621308f7d9", + "name": "pyspnego", + "sha256": "7f62f287dde1c14bfe9a2c8c18aa4bfd06f3428b15bd016c77ceebd9e5a6db1f", + "size": 164177, + "subdir": "linux-64", + "timestamp": 1642516252903, + "version": "0.3.1" + }, + "pyspnego-0.8.0-py310h5eee18b_2.conda": { + "build": "py310h5eee18b_2", + "build_number": 2, + "depends": [ + "cryptography", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "469db7bb58ce80268eefc85874d76c34", + "name": "pyspnego", + "sha256": "2219d3a4d03d0bda063d63c80b9ddc75a02edc805bbcc639c5effa8fcade9e64", + "size": 211553, + "subdir": "linux-64", + "timestamp": 1678831714668, + "version": "0.8.0" + }, + "pyspnego-0.8.0-py311h5eee18b_2.conda": { + "build": "py311h5eee18b_2", + "build_number": 2, + "depends": [ + "cryptography", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64dae55f5f3c81bbdfa8aa32ac0f346b", + "name": "pyspnego", + "sha256": "64cbcd6e23abd4c762c8388fb5fac33236aff6367fa24f19d8653d8b37749bc5", + "size": 255687, + "subdir": "linux-64", + "timestamp": 1679337612765, + "version": "0.8.0" + }, + "pyspnego-0.8.0-py38h5eee18b_2.conda": { + "build": "py38h5eee18b_2", + "build_number": 2, + "depends": [ + "cryptography", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3046efbc86e481c442ffa4124212447", + "name": "pyspnego", + "sha256": "cc4ab8b0f96aef59affa7bb320e8d4d09683d677cd1c42a45e3509ec21934fd4", + "size": 209667, + "subdir": "linux-64", + "timestamp": 1678831680382, + "version": "0.8.0" + }, + "pyspnego-0.8.0-py39h5eee18b_2.conda": { + "build": "py39h5eee18b_2", + "build_number": 2, + "depends": [ + "cryptography", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "ruamel.yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d6ed4e23481c5afa370a7b8a83eccc9", + "name": "pyspnego", + "sha256": "14d36548c6fb402dc40b1191aeeca78fec97b8d06a0de2ff54e73ea0f051c5e5", + "size": 209540, + "subdir": "linux-64", + "timestamp": 1678831748032, + "version": "0.8.0" + }, + "pystan-2.17.0.0-py27hb25f4fb_0.conda": { + "build": "py27hb25f4fb_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64", + "gxx_linux-64", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPLv3", + "md5": "10c27afb146972b6e072de232316c743", + "name": "pystan", + "sha256": "5d2b1eac6b7002c6536c47a59f15ad84e6eb56b18a4dd193c13f171b866facc7", + "size": 10598400, + "subdir": "linux-64", + "timestamp": 1510950482174, + "version": "2.17.0.0" + }, + "pystan-2.17.0.0-py35h541c666_0.conda": { + "build": "py35h541c666_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64", + "gxx_linux-64", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPLv3", + "md5": "df3dcb53d106a132261435c544d6e6a8", + "name": "pystan", + "sha256": "43dc6a256afafe750422659511551315f90c54df5af3ad99ea90d1af37d7ad6f", + "size": 10589959, + "subdir": "linux-64", + "timestamp": 1510950683017, + "version": "2.17.0.0" + }, + "pystan-2.17.0.0-py36hec2f369_0.conda": { + "build": "py36hec2f369_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64", + "gxx_linux-64", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPLv3", + "md5": "80259f8091e180b48adbcc47f4251b17", + "name": "pystan", + "sha256": "15c1f7d0302bf76ab7f9ee796a0eb79a38d753bf029f4ad804a7c038dccccd70", + "size": 10590323, + "subdir": "linux-64", + "timestamp": 1510950696285, + "version": "2.17.0.0" + }, + "pystan-2.17.1.0-py27h04863e7_0.conda": { + "build": "py27h04863e7_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64", + "gxx_linux-64", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPLv3", + "md5": "9f34720ec6b94665efdb8af853fec204", + "name": "pystan", + "sha256": "ecb09708f31a569a01f2943702cfb3f408ed15314f46b75f3645d59f1803dbdd", + "size": 10663552, + "subdir": "linux-64", + "timestamp": 1530921989010, + "version": "2.17.1.0" + }, + "pystan-2.17.1.0-py27h637b7d7_0.conda": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64", + "gxx_linux-64", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPLv3", + "md5": "c36b5815048dc236fcbf4eef18360c65", + "name": "pystan", + "sha256": "44c7a2e7c370012318f0a9fdc7952ca40e90ce111c2d95897438e7ec56452576", + "size": 10653994, + "subdir": "linux-64", + "timestamp": 1520787936395, + "version": "2.17.1.0" + }, + "pystan-2.17.1.0-py35h637b7d7_0.conda": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64", + "gxx_linux-64", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPLv3", + "md5": "7f5ccf6dba8c0a879a021eacba505297", + "name": "pystan", + "sha256": "f61545b3ac0d080c991299243a6d90e90cf5c3d21444673d062248cee781d7ac", + "size": 10665737, + "subdir": "linux-64", + "timestamp": 1520787923676, + "version": "2.17.1.0" + }, + "pystan-2.17.1.0-py36h04863e7_0.conda": { + "build": "py36h04863e7_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64", + "gxx_linux-64", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPLv3", + "md5": "3068d0f6350644de366df561bda2324b", + "name": "pystan", + "sha256": "25c3ce3c2d2b07debaaded082a61ae10aee99ad7f776df9380c063ec1bac4997", + "size": 10664566, + "subdir": "linux-64", + "timestamp": 1530920693619, + "version": "2.17.1.0" + }, + "pystan-2.17.1.0-py36h637b7d7_0.conda": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64", + "gxx_linux-64", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPLv3", + "md5": "73ac38dea9dadbec73a50cec366f81a2", + "name": "pystan", + "sha256": "cc0374d1fd5328adf532d9c5aa0876ce3d7b81cf5a7cb5a1866e86c408c681ed", + "size": 10659848, + "subdir": "linux-64", + "timestamp": 1520787898231, + "version": "2.17.1.0" + }, + "pystan-2.17.1.0-py37h04863e7_0.conda": { + "build": "py37h04863e7_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64", + "gxx_linux-64", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPLv3", + "md5": "04a7a68d122002fc7bb0865721c5dc34", + "name": "pystan", + "sha256": "af428fd4f19c3f73e7834d446e5dc5a0ab5e0aea3ba23b1f17479e09b14a4cae", + "size": 10661121, + "subdir": "linux-64", + "timestamp": 1530921346882, + "version": "2.17.1.0" + }, + "pystan-2.18.0.0-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPLv3", + "md5": "390bedab359e79552774b1af44de413b", + "name": "pystan", + "sha256": "efa3d302cbadfacbc945a33dba26b6adcaabfb9589ca0481d15489e51df21b62", + "size": 13470224, + "subdir": "linux-64", + "timestamp": 1536530356974, + "version": "2.18.0.0" + }, + "pystan-2.18.0.0-py35h962f231_0.conda": { + "build": "py35h962f231_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPLv3", + "md5": "0e2b5808978fa0ff6ed5625599569cd6", + "name": "pystan", + "sha256": "e73d6717e68e8b81cde125643278411291ef8bf5246b96735f9b9e4b7a84d211", + "size": 13495911, + "subdir": "linux-64", + "timestamp": 1536530333787, + "version": "2.18.0.0" + }, + "pystan-2.18.0.0-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPLv3", + "md5": "cd85aec670b22f4c74f9a10df34dd86d", + "name": "pystan", + "sha256": "293ceaf75d1e33b27339a7ae13f3ba2c42f0d1fc2b9954b659c4539dac8d1799", + "size": 13409413, + "subdir": "linux-64", + "timestamp": 1536530636626, + "version": "2.18.0.0" + }, + "pystan-2.18.0.0-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPLv3", + "md5": "f5597fef3f49c464de521587d392ebe1", + "name": "pystan", + "sha256": "e3aa3e1a7904b38d35d153b5dd1cac064e403617eefa2675ae6c8eb8dd39ee5f", + "size": 13491058, + "subdir": "linux-64", + "timestamp": 1536530650394, + "version": "2.18.0.0" + }, + "pystan-2.18.0.0-py38h962f231_0.conda": { + "build": "py38h962f231_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPLv3", + "md5": "59cd9fe22cbc2265173d8ad924c08c3c", + "name": "pystan", + "sha256": "63f0ce6d1fdf627f71631d15efb499c737424e7fa5b3d7ac050c4737fe5f7618", + "size": 13423437, + "subdir": "linux-64", + "timestamp": 1574170748158, + "version": "2.18.0.0" + }, + "pystan-2.19.0.0-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPLv3", + "md5": "e08f420ca005aae7b9b078b3416312c1", + "name": "pystan", + "sha256": "f5a3021b4116ddb22d1f3e31c702d4c05ed4cea9c2e85503b0df30436458674e", + "size": 12636799, + "subdir": "linux-64", + "timestamp": 1563481289833, + "version": "2.19.0.0" + }, + "pystan-2.19.0.0-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPLv3", + "md5": "6e25713e27d776eee3a9146ee217e6fa", + "name": "pystan", + "sha256": "e723dba525bd32ba479a5005f879894215eb51ec999691e1fe53cf8523fb4fd5", + "size": 12648779, + "subdir": "linux-64", + "timestamp": 1563481285038, + "version": "2.19.0.0" + }, + "pystan-2.19.0.0-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPLv3", + "md5": "fc058879d0169f848b99b322b62e8cdc", + "name": "pystan", + "sha256": "1a7846c5abbdf58511e368ce16f5e0efc81c971ea2f333a6e5f2b7acc0ab28ff", + "size": 12674188, + "subdir": "linux-64", + "timestamp": 1563481463955, + "version": "2.19.0.0" + }, + "pystan-2.19.1.1-py36ha9443f7_0.conda": { + "build": "py36ha9443f7_0", + "build_number": 0, + "depends": [ + "arviz", + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy", + "setuptools" + ], + "license": "GPLv3", + "md5": "533638e68828a8f2cda63046308f5588", + "name": "pystan", + "sha256": "d3572a4bb720987de5d71d098896ae21ab38908511f0c516523901fa83486d79", + "size": 13348006, + "subdir": "linux-64", + "timestamp": 1613565599192, + "version": "2.19.1.1" + }, + "pystan-2.19.1.1-py37ha9443f7_0.conda": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "arviz", + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy", + "setuptools" + ], + "license": "GPLv3", + "md5": "6df0531cb1a7484438d2392ed1f1f4a1", + "name": "pystan", + "sha256": "28fe43cb68bd41a40119c68dd0d5266826b1a0338d73a89374d2f962c771b370", + "size": 13383420, + "subdir": "linux-64", + "timestamp": 1613565512910, + "version": "2.19.1.1" + }, + "pystan-2.19.1.1-py38ha9443f7_0.conda": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "arviz", + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy", + "setuptools" + ], + "license": "GPLv3", + "md5": "bf553d1b4abb019a462efdd688cb6961", + "name": "pystan", + "sha256": "390768afb3f0f6c3949df5fbc0e2ea240ea8c7acfefc2bc13b91b9bbd1fc74ba", + "size": 13369469, + "subdir": "linux-64", + "timestamp": 1613565517517, + "version": "2.19.1.1" + }, + "pystan-2.19.1.1-py39ha9443f7_0.conda": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "arviz", + "cython >=0.22,!=0.25.1", + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy", + "setuptools" + ], + "license": "GPLv3", + "md5": "f4eb20540e9c59fcff09db3de4974822", + "name": "pystan", + "sha256": "20b91ed196b914b0e04698050b04b3be704dfe708177548545b00acc087ff787", + "size": 13313488, + "subdir": "linux-64", + "timestamp": 1613639972578, + "version": "2.19.1.1" + }, + "pytables-3.4.2-py27h1f7bffc_2.conda": { + "build": "py27h1f7bffc_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0c2d4c1651f40b52effadd4f3678add6", + "name": "pytables", + "sha256": "dd1e7155715cbd0a0c9c8ceea85271a74dc014f056b1993858ac46e8a6f9cf02", + "size": 1584351, + "subdir": "linux-64", + "timestamp": 1506562047979, + "version": "3.4.2" + }, + "pytables-3.4.2-py27h62dd165_2.conda": { + "build": "py27h62dd165_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b7811977ded496fe69c6425b1a517484", + "name": "pytables", + "sha256": "394a69c0d47a26a73018d84480d5b72c5a8ebc3fde0b74a50fc9a29d5624796a", + "size": 1584321, + "subdir": "linux-64", + "timestamp": 1506561784688, + "version": "3.4.2" + }, + "pytables-3.4.2-py27ha79ee23_1.conda": { + "build": "py27ha79ee23_1", + "build_number": 1, + "depends": [ + "hdf5", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo 2.*", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7a32d44e7b01bbf04bbe43f513b9fcdd", + "name": "pytables", + "sha256": "0f6eee67c67e0912334c048d86d4fb37fd52dba52ea1a5f55822e5efe01e2432", + "size": 1583288, + "subdir": "linux-64", + "timestamp": 1505731220939, + "version": "3.4.2" + }, + "pytables-3.4.2-py35h68a732d_2.conda": { + "build": "py35h68a732d_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bc559804017f3515db488df2b786f572", + "name": "pytables", + "sha256": "fd8883992b5284dce500315a55c8760e96d8b10250c9d39fbe0689db8b89ddf2", + "size": 1610526, + "subdir": "linux-64", + "timestamp": 1506561857022, + "version": "3.4.2" + }, + "pytables-3.4.2-py35hc74b6c3_1.conda": { + "build": "py35hc74b6c3_1", + "build_number": 1, + "depends": [ + "hdf5", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo 2.*", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e29c7e196c4056dc5a9654e02cc71121", + "name": "pytables", + "sha256": "4d9a243abc99ef1d22ea0e712fd1584372a789349e9ab81bc13d50371156003a", + "size": 1603753, + "subdir": "linux-64", + "timestamp": 1505731580458, + "version": "3.4.2" + }, + "pytables-3.4.2-py35hfa98db7_2.conda": { + "build": "py35hfa98db7_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e855ff0ed356d715976e4234b1719239", + "name": "pytables", + "sha256": "cbfe4f016f999c1584d2333c95275fb1fad350fb237e03b5a862544c36b2a507", + "size": 1605507, + "subdir": "linux-64", + "timestamp": 1506561893204, + "version": "3.4.2" + }, + "pytables-3.4.2-py36h3b5282a_2.conda": { + "build": "py36h3b5282a_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9e6ae976ec5cfe3d2922ca76ec45db2b", + "name": "pytables", + "sha256": "eb4a73217be85e1968d12cc10a78ca491fd92749bfd944b2effe138e0ce60307", + "size": 1612160, + "subdir": "linux-64", + "timestamp": 1506562218012, + "version": "3.4.2" + }, + "pytables-3.4.2-py36hc5f0ea4_2.conda": { + "build": "py36hc5f0ea4_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "81b10f3e7daa648d6b47f43497fb8a27", + "name": "pytables", + "sha256": "052d51109dc1631598c504fc80a898bc3ec5a03c042b8329aa5f5be6973bfdb1", + "size": 1614428, + "subdir": "linux-64", + "timestamp": 1506562220717, + "version": "3.4.2" + }, + "pytables-3.4.2-py36hdce54c9_1.conda": { + "build": "py36hdce54c9_1", + "build_number": 1, + "depends": [ + "hdf5", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo 2.*", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e45376b6dfd8f4c1d761d6ee2e5c6a24", + "name": "pytables", + "sha256": "f13ad6a0295ea1b0e3c5ef491848ee791db3122d93f0dcf8b9912f0cc33d1640", + "size": 1601583, + "subdir": "linux-64", + "timestamp": 1505731929302, + "version": "3.4.2" + }, + "pytables-3.4.3-py27h02b9ad4_0.conda": { + "build": "py27h02b9ad4_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0d1f944fa4db157461461a125f8a800d", + "name": "pytables", + "sha256": "2a0f4d289f268a8943188bb961e9efcee5f1ed62cd0079d56c42b70f44e8df22", + "size": 1262918, + "subdir": "linux-64", + "timestamp": 1524593507590, + "version": "3.4.3" + }, + "pytables-3.4.3-py27h02b9ad4_2.conda": { + "build": "py27h02b9ad4_2", + "build_number": 2, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fb94079351480d249709ffb715582c7f", + "name": "pytables", + "sha256": "3ba12d21f1b524a4b2eb8b3fd5f7ced2562c05ba68d9eff0ad89c32bb2ebd4ec", + "size": 1263652, + "subdir": "linux-64", + "timestamp": 1527021667141, + "version": "3.4.3" + }, + "pytables-3.4.3-py27h68a8fdc_0.conda": { + "build": "py27h68a8fdc_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f7ae3cad256fb17c7996b3c273beabb9", + "name": "pytables", + "sha256": "6d87850d8e3049ec6447aacb177d482c2a7be8756dec8677690621a8bec1470c", + "size": 1256236, + "subdir": "linux-64", + "timestamp": 1524594308960, + "version": "3.4.3" + }, + "pytables-3.4.3-py27h68a8fdc_2.conda": { + "build": "py27h68a8fdc_2", + "build_number": 2, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "aa2b3cf2843f0f36b0cc26fdd29fb911", + "name": "pytables", + "sha256": "559bb7ad5246164009c507958525dd8d3d3945d33964e574f5279f18e8850fee", + "size": 1256978, + "subdir": "linux-64", + "timestamp": 1527021669571, + "version": "3.4.3" + }, + "pytables-3.4.3-py35h02b9ad4_0.conda": { + "build": "py35h02b9ad4_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "593183eda6ec9b1357bfb9a7579e9812", + "name": "pytables", + "sha256": "a9517da0176c1f847bc1cf2e27a15eb4b884c0018ccdbeea15dc13cb6709767a", + "size": 1275106, + "subdir": "linux-64", + "timestamp": 1524594287356, + "version": "3.4.3" + }, + "pytables-3.4.3-py35h02b9ad4_2.conda": { + "build": "py35h02b9ad4_2", + "build_number": 2, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e737dff3fbc0de3897fe8f3d7705f690", + "name": "pytables", + "sha256": "97c6e7444da9a08f953a08fadd3142a35038b77665218c9f7fdf6c392e6f0b39", + "size": 1275902, + "subdir": "linux-64", + "timestamp": 1527021670655, + "version": "3.4.3" + }, + "pytables-3.4.3-py35h68a8fdc_0.conda": { + "build": "py35h68a8fdc_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fcf1e07070677ac955570bb2a503a104", + "name": "pytables", + "sha256": "35594f5232bc50998db577e9297cad363e04c8ac861fd48426ac04ffcfbc6f77", + "size": 1285386, + "subdir": "linux-64", + "timestamp": 1524594480403, + "version": "3.4.3" + }, + "pytables-3.4.3-py35h68a8fdc_2.conda": { + "build": "py35h68a8fdc_2", + "build_number": 2, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4fdcff9228c8112a7a1506ebb9d7d588", + "name": "pytables", + "sha256": "a6a7967965f14b9f3601403d3e43e482a124ac3160d2492a6eb6cdc947afacf3", + "size": 1285946, + "subdir": "linux-64", + "timestamp": 1527021096123, + "version": "3.4.3" + }, + "pytables-3.4.3-py36h02b9ad4_0.conda": { + "build": "py36h02b9ad4_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.1,<1.10.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "866884dfa622c543e47647249d36c762", + "name": "pytables", + "sha256": "c92de775f22528843f0388ee45adf893775a6ee233c59a833f03f447212235bb", + "size": 1289662, + "subdir": "linux-64", + "timestamp": 1524594472050, + "version": "3.4.3" + }, + "pytables-3.4.3-py36h02b9ad4_2.conda": { + "build": "py36h02b9ad4_2", + "build_number": 2, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6add50ea89f4572c7266e17ef89a9a4c", + "name": "pytables", + "sha256": "098f621ff3e67d1556aeb5a90e24a54c50baafb448fa4dd753dd74a2843f6dc1", + "size": 1281641, + "subdir": "linux-64", + "timestamp": 1527021664907, + "version": "3.4.3" + }, + "pytables-3.4.3-py36h68a8fdc_0.conda": { + "build": "py36h68a8fdc_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "20db32095dd54bf61212ba991d603afa", + "name": "pytables", + "sha256": "d248bc3aaef7568550a1e6f6314a9ce9d36a7246e53f1902742dc385fdea54a3", + "size": 1291303, + "subdir": "linux-64", + "timestamp": 1524593536342, + "version": "3.4.3" + }, + "pytables-3.4.3-py36h68a8fdc_2.conda": { + "build": "py36h68a8fdc_2", + "build_number": 2, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d94d7a11f074802f74bab5e1c76398dd", + "name": "pytables", + "sha256": "63b10ecf6b41c4eb9a12510854346f4a4566a5a3af871e431bc2e911c5536972", + "size": 1291765, + "subdir": "linux-64", + "timestamp": 1527021080930, + "version": "3.4.3" + }, + "pytables-3.4.4-py27h02b9ad4_0.conda": { + "build": "py27h02b9ad4_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0623f2e087de5c491ca45cf452c6c221", + "name": "pytables", + "sha256": "22e56d078f5d34fded8dde4595f9d8cf7de64b360b604af4586806ae82c05912", + "size": 1263176, + "subdir": "linux-64", + "timestamp": 1529061949337, + "version": "3.4.4" + }, + "pytables-3.4.4-py27h68a8fdc_0.conda": { + "build": "py27h68a8fdc_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "51a1972988a562ef4d07af5453940136", + "name": "pytables", + "sha256": "d6eb4da77d4b95c5b685a744ca1cac92e7b752e4f770b56312486f539c7a96af", + "size": 1256604, + "subdir": "linux-64", + "timestamp": 1529061956406, + "version": "3.4.4" + }, + "pytables-3.4.4-py27h71ec239_0.conda": { + "build": "py27h71ec239_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.4,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "09a54eb55941f380b320db04146ef478", + "name": "pytables", + "sha256": "7e705b06065cd197e1e3154af6b37ec2a3e21fdd6f4a090606d1bbd136d5fe49", + "size": 1253810, + "subdir": "linux-64", + "timestamp": 1545405733588, + "version": "3.4.4" + }, + "pytables-3.4.4-py27ha205bf6_0.conda": { + "build": "py27ha205bf6_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "47608d8776b0127ee426b08063797beb", + "name": "pytables", + "sha256": "6bf9b06413a4c3fd1f971c3d900819c7832f0d7069625eec42de87cd663ba98c", + "size": 1255614, + "subdir": "linux-64", + "timestamp": 1530740309087, + "version": "3.4.4" + }, + "pytables-3.4.4-py27he1c29e1_0.conda": { + "build": "py27he1c29e1_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6cb597545326afebfff605c5d326628c", + "name": "pytables", + "sha256": "ea0a7dfbedeb87d6b5d8a0f53f46bf8ca29151480ba775e661d764f1dba41c73", + "size": 1262109, + "subdir": "linux-64", + "timestamp": 1530740009204, + "version": "3.4.4" + }, + "pytables-3.4.4-py35h02b9ad4_0.conda": { + "build": "py35h02b9ad4_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0c1cfaa84842003365fbb6f60ea60961", + "name": "pytables", + "sha256": "5604aff42fda9e7f7fada8294c031c9962f4a68b44f06beb2baf33fd5a46c42d", + "size": 1283914, + "subdir": "linux-64", + "timestamp": 1529062099025, + "version": "3.4.4" + }, + "pytables-3.4.4-py35h68a8fdc_0.conda": { + "build": "py35h68a8fdc_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0fbe06ec56a182359eef5be4f95ebf19", + "name": "pytables", + "sha256": "7180dc1f4d0353e1fa6be2f890aa79eb1ee51c5ab59d6c542258a34521d96691", + "size": 1285442, + "subdir": "linux-64", + "timestamp": 1529062072704, + "version": "3.4.4" + }, + "pytables-3.4.4-py35ha205bf6_0.conda": { + "build": "py35ha205bf6_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "acea0e4b2c25ac127e84899872f22b6e", + "name": "pytables", + "sha256": "21fceba974fccc59565856836d5adb12143f0bf42c8104c804a4f20c48286939", + "size": 1272818, + "subdir": "linux-64", + "timestamp": 1534356246555, + "version": "3.4.4" + }, + "pytables-3.4.4-py35he1c29e1_0.conda": { + "build": "py35he1c29e1_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.20,<1.9.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8364775d8a2f8fe884f38964ae54ce5a", + "name": "pytables", + "sha256": "b2f5dd14e55d7ead70b68fba097c71b1cd93d131bd5251a137b1d7298e0b11a0", + "size": 1282536, + "subdir": "linux-64", + "timestamp": 1534355938771, + "version": "3.4.4" + }, + "pytables-3.4.4-py36h02b9ad4_0.conda": { + "build": "py36h02b9ad4_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7e79c3ca2a875210a679ae2f049bb087", + "name": "pytables", + "sha256": "e9f94776f0bea6fee5f144099046f4e7c70a4f86ee61d37b92ec915ecc333717", + "size": 1288980, + "subdir": "linux-64", + "timestamp": 1529061582603, + "version": "3.4.4" + }, + "pytables-3.4.4-py36h68a8fdc_0.conda": { + "build": "py36h68a8fdc_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "89448473cbd3a197de7ac893760322a4", + "name": "pytables", + "sha256": "1ca2e1a1eb85393dcec00f33fd743db089ec768802dd45d91533d5c500afe834", + "size": 1290929, + "subdir": "linux-64", + "timestamp": 1529061754009, + "version": "3.4.4" + }, + "pytables-3.4.4-py36h71ec239_0.conda": { + "build": "py36h71ec239_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.4,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "34bb79ecd3c8d58d2202fdd2c8d2a917", + "name": "pytables", + "sha256": "6a9a8e1d88ca17cb3198ff52e0c005c4933a91af679e17b5c9a4a1ca440a5ca0", + "size": 1296139, + "subdir": "linux-64", + "timestamp": 1545405839121, + "version": "3.4.4" + }, + "pytables-3.4.4-py36ha205bf6_0.conda": { + "build": "py36ha205bf6_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "10dda7e3ce69af38e5995b98a0ad7055", + "name": "pytables", + "sha256": "affe56499f9e06da99b2a2d14d3b04e0511fa766b7f985885eb7e0e0b9f085b3", + "size": 1289161, + "subdir": "linux-64", + "timestamp": 1530739700858, + "version": "3.4.4" + }, + "pytables-3.4.4-py36he1c29e1_0.conda": { + "build": "py36he1c29e1_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "383dd5c17d05872859bc733d71a95f7b", + "name": "pytables", + "sha256": "7cbb421c4d45dd7a04649ab587ff60579d11207642cee3ab1ca968713856017b", + "size": 1281695, + "subdir": "linux-64", + "timestamp": 1530739419495, + "version": "3.4.4" + }, + "pytables-3.4.4-py37h71ec239_0.conda": { + "build": "py37h71ec239_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.4,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1f61f8747b65122f12058aefe725ff92", + "name": "pytables", + "sha256": "dfebffbfd4b0afb77f653c039d0cdb0003157f626c1f13e470748bddac147773", + "size": 1279155, + "subdir": "linux-64", + "timestamp": 1545405839969, + "version": "3.4.4" + }, + "pytables-3.4.4-py37ha205bf6_0.conda": { + "build": "py37ha205bf6_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.2,<1.10.3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ca1b80baa311f1d3d4c731a18d36fbbb", + "name": "pytables", + "sha256": "ce1b95bfc80fd8e4657d753e5de1100f61d420a0202d6eef70dffd087dbd4cd6", + "size": 1274279, + "subdir": "linux-64", + "timestamp": 1530740912745, + "version": "3.4.4" + }, + "pytables-3.4.4-py37he1c29e1_0.conda": { + "build": "py37he1c29e1_0", + "build_number": 0, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.8.18,<1.8.19.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "baea25fa5633b1be33f0bab3d80e73a6", + "name": "pytables", + "sha256": "710839ad225c42ed13c90820d1f6dcd57580926bc491da0c16e215c8035cff17", + "size": 1283337, + "subdir": "linux-64", + "timestamp": 1530740643663, + "version": "3.4.4" + }, + "pytables-3.5.1-py27h71ec239_0.conda": { + "build": "py27h71ec239_0", + "build_number": 0, + "depends": [ + "blosc >=1.15.0,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cd8f00f8438a215ca985e3768bda12ae", + "name": "pytables", + "sha256": "b9fd0bc2db933467f04fee4a904c3783f71747128e91b9f4b5013b268636130d", + "size": 1261190, + "subdir": "linux-64", + "timestamp": 1552930186620, + "version": "3.5.1" + }, + "pytables-3.5.1-py36h71ec239_0.conda": { + "build": "py36h71ec239_0", + "build_number": 0, + "depends": [ + "blosc >=1.15.0,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "48bd66467c7256ac4207ae8bc4539194", + "name": "pytables", + "sha256": "0136cd3da2bac670a6777434bafaec983f4e5197f53618a8cd22fd5eb33c917d", + "size": 1302017, + "subdir": "linux-64", + "timestamp": 1552930182748, + "version": "3.5.1" + }, + "pytables-3.5.1-py37h71ec239_0.conda": { + "build": "py37h71ec239_0", + "build_number": 0, + "depends": [ + "blosc >=1.15.0,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f970b614a2970bb30202706aea98f032", + "name": "pytables", + "sha256": "1253fc70ee8e42402a34a4f8bc11036b4696322e160ae9cd4e65324a2812698d", + "size": 1294835, + "subdir": "linux-64", + "timestamp": 1552930030908, + "version": "3.5.1" + }, + "pytables-3.5.2-py27h71ec239_1.conda": { + "build": "py27h71ec239_1", + "build_number": 1, + "depends": [ + "blosc >=1.16.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e2db37fdbfbf07f9a6e37d78e7490d07", + "name": "pytables", + "sha256": "2deefacdc2d922e200b14eb15bc7ad0a2fc56e475d5abc4c93c20b5f69d6abbf", + "size": 1270151, + "subdir": "linux-64", + "timestamp": 1559922805225, + "version": "3.5.2" + }, + "pytables-3.5.2-py36h71ec239_1.conda": { + "build": "py36h71ec239_1", + "build_number": 1, + "depends": [ + "blosc >=1.16.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "82fca87b2eb80a572861e24a30674983", + "name": "pytables", + "sha256": "c01426f4ecb05d7662b74f34eb30ee12a3c539c1ff3fda16f15f35ff0f44b190", + "size": 1312321, + "subdir": "linux-64", + "timestamp": 1559922810996, + "version": "3.5.2" + }, + "pytables-3.5.2-py37h71ec239_1.conda": { + "build": "py37h71ec239_1", + "build_number": 1, + "depends": [ + "blosc >=1.16.3,<2.0a0", + "bzip2 >=1.0.6,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f5df0d6af96bdf363dc0d50f0e80c99c", + "name": "pytables", + "sha256": "d469eea8f6843f9eb452cc55666fcd61c4ddaf4d70a2f125a1035dcd9421925b", + "size": 1306029, + "subdir": "linux-64", + "timestamp": 1559922653201, + "version": "3.5.2" + }, + "pytables-3.6.1-py310hadd16c1_1.conda": { + "build": "py310hadd16c1_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr", + "python >=3.10,<3.11.0a0", + "six", + "zlib" + ], + "license": "BSD 3-Clause", + "md5": "bfad8123173f844f3bce961eb6dd3342", + "name": "pytables", + "sha256": "bdf30fdcef90d2f925e8ae32924248c0acf62e5d69b4520790debac7b542af63", + "size": 2699252, + "subdir": "linux-64", + "timestamp": 1641403702071, + "version": "3.6.1" + }, + "pytables-3.6.1-py36h71ec239_0.conda": { + "build": "py36h71ec239_0", + "build_number": 0, + "depends": [ + "blosc >=1.16.3,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8dbdcbfe1a754f21d56948baf6550fa0", + "name": "pytables", + "sha256": "5e1d8b9cbffe4d51247810f719dbbdc260f24ebd012023db570469a7629568f7", + "size": 1311175, + "subdir": "linux-64", + "timestamp": 1573080058184, + "version": "3.6.1" + }, + "pytables-3.6.1-py37h71ec239_0.conda": { + "build": "py37h71ec239_0", + "build_number": 0, + "depends": [ + "blosc >=1.16.3,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fff651ffc7c368e497a93a7b7eceabd0", + "name": "pytables", + "sha256": "59eabd17ac7c2c1b22fdeb23f204aa3e08e37e3df8cab8450af1376cdfe368aa", + "size": 1303076, + "subdir": "linux-64", + "timestamp": 1573080078715, + "version": "3.6.1" + }, + "pytables-3.6.1-py38h9fd0a39_0.conda": { + "build": "py38h9fd0a39_0", + "build_number": 0, + "depends": [ + "blosc >=1.16.3,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.4,<1.10.5.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "six", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6068f0d0fc65512488c626e5990d91c9", + "name": "pytables", + "sha256": "8bd75807b2c37dadf3ab5b7995678ea2f90e497ee638a8d714f5da10cb0b3381", + "size": 1331064, + "subdir": "linux-64", + "timestamp": 1580255489176, + "version": "3.6.1" + }, + "pytables-3.6.1-py39h77479fe_1.conda": { + "build": "py39h77479fe_1", + "build_number": 1, + "depends": [ + "blosc >=1.20.1,<2.0a0", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "six", + "zlib" + ], + "license": "BSD 3-Clause", + "md5": "57e994665ba4a1f79d79af4efa71ebc1", + "name": "pytables", + "sha256": "d0131bb40288cbc311bcd60e632732910e140c51ba46db4325bd488e587d1ee3", + "size": 1340838, + "subdir": "linux-64", + "timestamp": 1607975491140, + "version": "3.6.1" + }, + "pytables-3.7.0-py310h9da3b7f_0.conda": { + "build": "py310h9da3b7f_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "blosc >=1.4.1", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.12.1,<1.12.2.0a0", + "hdf5 >=1.8.15", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr >=2.6.2", + "numpy >=1.21.2,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0", + "zlib" + ], + "license": "BSD-3-Clause", + "md5": "b0c40f1bcdb26fd560f07e50edd828d9", + "name": "pytables", + "sha256": "910344fd6cad5dffb674c221f267963a2525032e74b13677e6286ef42ccd15e7", + "size": 2997746, + "subdir": "linux-64", + "timestamp": 1647579641224, + "version": "3.7.0" + }, + "pytables-3.7.0-py310hf19a122_1.conda": { + "build": "py310hf19a122_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "blosc >=1.4.1", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "hdf5 >=1.8.15", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr >=2.6.2", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0", + "zlib" + ], + "license": "BSD-3-Clause", + "md5": "a834d7916faab4c91982b2d945b34eef", + "name": "pytables", + "sha256": "4d4b9c133f06da01acb9c81c7a06a8992b4fdc2d25633e55387d9a5f96732d2a", + "size": 1719234, + "subdir": "linux-64", + "timestamp": 1673968099316, + "version": "3.7.0" + }, + "pytables-3.7.0-py311hf19a122_1.conda": { + "build": "py311hf19a122_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "blosc >=1.4.1", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "hdf5 >=1.8.15", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr >=2.6.2", + "numpy >=1.23.5,<2.0a0", + "packaging", + "python >=3.11,<3.12.0a0", + "zlib" + ], + "license": "BSD-3-Clause", + "md5": "d8b5c344c0668e70cd287f4789c4eeb1", + "name": "pytables", + "sha256": "17bc24ec6b92ba130fb9146ce4a6a5b9110f076849496ec7a060bb46e4167ed6", + "size": 1807604, + "subdir": "linux-64", + "timestamp": 1676845476062, + "version": "3.7.0" + }, + "pytables-3.7.0-py37h9da3b7f_0.conda": { + "build": "py37h9da3b7f_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "blosc >=1.4.1", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.12.1,<1.12.2.0a0", + "hdf5 >=1.8.15", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr >=2.6.2", + "numpy >=1.19.2,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0", + "zlib" + ], + "license": "BSD-3-Clause", + "md5": "6cf13ba04dd2e68f4ef14da79abaa45f", + "name": "pytables", + "sha256": "d50cf871d4e19f7fadfc1833ba79f358c39511201d2fdc5fee32a39c11e70964", + "size": 1534854, + "subdir": "linux-64", + "timestamp": 1647597739850, + "version": "3.7.0" + }, + "pytables-3.7.0-py37hf19a122_1.conda": { + "build": "py37hf19a122_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "blosc >=1.4.1", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "hdf5 >=1.8.15", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr >=2.6.2", + "numpy >=1.19.2,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0", + "zlib" + ], + "license": "BSD-3-Clause", + "md5": "e71db74426f4303e24803ecb344b8c5a", + "name": "pytables", + "sha256": "d04742a5642d4470136c6dc28b01d9f21a1945eebd11287d6e873c64b3d89e9d", + "size": 1704515, + "subdir": "linux-64", + "timestamp": 1673968292560, + "version": "3.7.0" + }, + "pytables-3.7.0-py38h9da3b7f_0.conda": { + "build": "py38h9da3b7f_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "blosc >=1.4.1", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.12.1,<1.12.2.0a0", + "hdf5 >=1.8.15", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr >=2.6.2", + "numpy >=1.19.2,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0", + "zlib" + ], + "license": "BSD-3-Clause", + "md5": "9fddf077db95b84df2709b8ddf5b44d7", + "name": "pytables", + "sha256": "642a1278ab0659fab0c4b6d2ada84ed6f7485bd016a98201c0f17a6f71c95c0d", + "size": 1569896, + "subdir": "linux-64", + "timestamp": 1647579872277, + "version": "3.7.0" + }, + "pytables-3.7.0-py38hf19a122_1.conda": { + "build": "py38hf19a122_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "blosc >=1.4.1", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "hdf5 >=1.8.15", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr >=2.6.2", + "numpy >=1.19.2,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0", + "zlib" + ], + "license": "BSD-3-Clause", + "md5": "d65ffe4610a9965608de5f30af995328", + "name": "pytables", + "sha256": "14c779fd5738986a1fb5ae4bdfb03fdf867dc30e6414f0b54b87e57e1ff72ce1", + "size": 1741482, + "subdir": "linux-64", + "timestamp": 1673967913201, + "version": "3.7.0" + }, + "pytables-3.7.0-py39h9da3b7f_0.conda": { + "build": "py39h9da3b7f_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "blosc >=1.4.1", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.12.1,<1.12.2.0a0", + "hdf5 >=1.8.15", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr >=2.6.2", + "numpy >=1.19.2,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0", + "zlib" + ], + "license": "BSD-3-Clause", + "md5": "beb8f684a4aae5071e039721ec1b1860", + "name": "pytables", + "sha256": "a899ae4dfd91adfa442633d693ea342640f0f141d9169bf06c26748f9ef763a4", + "size": 1565854, + "subdir": "linux-64", + "timestamp": 1647597737936, + "version": "3.7.0" + }, + "pytables-3.7.0-py39hf19a122_1.conda": { + "build": "py39hf19a122_1", + "build_number": 1, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "blosc >=1.4.1", + "bzip2 >=1.0.8,<2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "hdf5 >=1.8.15", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "lzo >=2.10,<3.0a0", + "mock", + "numexpr >=2.6.2", + "numpy >=1.19.2,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0", + "zlib" + ], + "license": "BSD-3-Clause", + "md5": "9b696b08e12a8c895003da64a57c70a7", + "name": "pytables", + "sha256": "471308d94317b671a15bb7ff3e406d957377df375e5966928100498bb1791a48", + "size": 1719655, + "subdir": "linux-64", + "timestamp": 1673967724543, + "version": "3.7.0" + }, + "pytesseract-0.3.10-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=21.3", + "pillow >=8.0.0", + "python >=3.10,<3.11.0a0", + "tesseract" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "01e9cfebb0cf6362351fd0991af31e03", + "name": "pytesseract", + "sha256": "9ca3f3bf8fc6d97c39f464aefdb74ec3cc9cc7e943cc11461e558020fcc1552d", + "size": 38705, + "subdir": "linux-64", + "timestamp": 1666335192153, + "version": "0.3.10" + }, + "pytesseract-0.3.10-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=21.3", + "pillow >=8.0.0", + "python >=3.11,<3.12.0a0", + "tesseract" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7cb4f3119e86d97d5b8eaccc35c3be65", + "name": "pytesseract", + "sha256": "d026543458a4421dd1e11b8e62eb3b57e96fbb803bc205e6c1da9e70794579f3", + "size": 43016, + "subdir": "linux-64", + "timestamp": 1676861272572, + "version": "0.3.10" + }, + "pytesseract-0.3.10-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=21.3", + "pillow >=8.0.0", + "python >=3.7,<3.8.0a0", + "tesseract" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "088eca77e98c7c8eb8f4ceb40a1ed540", + "name": "pytesseract", + "sha256": "97fdd10e821e197d3354392dbe4a1d97e9ac707857842ceafaa10c2e2b7f031c", + "size": 38279, + "subdir": "linux-64", + "timestamp": 1666335230865, + "version": "0.3.10" + }, + "pytesseract-0.3.10-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=21.3", + "pillow >=8.0.0", + "python >=3.8,<3.9.0a0", + "tesseract" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "415ef52c66a9df550012a7b0b681d8dd", + "name": "pytesseract", + "sha256": "976f189353f56a4fe3c658b9ae7fbb9afb57469f18f32bddbea27af97394d6dd", + "size": 38397, + "subdir": "linux-64", + "timestamp": 1666335102088, + "version": "0.3.10" + }, + "pytesseract-0.3.10-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=21.3", + "pillow >=8.0.0", + "python >=3.9,<3.10.0a0", + "tesseract" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9ff80fc3d15f19119c38d180449880e6", + "name": "pytesseract", + "sha256": "8bcfd9f0b2946c0f4750b27f42541020e75973e4e1ac40b9089e540a6e495946", + "size": 38483, + "subdir": "linux-64", + "timestamp": 1666335154214, + "version": "0.3.10" + }, + "pytest-3.10.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "746c1ba0d05f85ae864b30d37498f113", + "name": "pytest", + "sha256": "25cf9342e18575d05863c4e90a9b26c0de879940f0bb2e808ae2a7210be2039c", + "size": 337533, + "subdir": "linux-64", + "timestamp": 1541443244078, + "version": "3.10.0" + }, + "pytest-3.10.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "010648ec06e5758f73a8d6a74730acec", + "name": "pytest", + "sha256": "c23069429524f805ff6e534b691967f537bd9ffa49540664ec01a54578448990", + "size": 334272, + "subdir": "linux-64", + "timestamp": 1541443287912, + "version": "3.10.0" + }, + "pytest-3.10.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "633ae509ab0f395cc8bc07e0a0fc7944", + "name": "pytest", + "sha256": "144cdca4a5670e908b004e22abb3a6128c487344d00582508145920593f158f8", + "size": 334925, + "subdir": "linux-64", + "timestamp": 1541443241820, + "version": "3.10.0" + }, + "pytest-3.10.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "89254db289849a3e3ab781477ad1c67f", + "name": "pytest", + "sha256": "a634d38efd079f0ae778607d28da554bdc1b2085a7a2ff5b0db784f679ab894d", + "size": 333494, + "subdir": "linux-64", + "timestamp": 1542086576311, + "version": "3.10.1" + }, + "pytest-3.10.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "ed6139541fe5976c72dc5f88a6366842", + "name": "pytest", + "sha256": "419b43b4e511003746cbecf47a3030c20a72ffda98adfe706bcd4b74f313ea8b", + "size": 334407, + "subdir": "linux-64", + "timestamp": 1542086561902, + "version": "3.10.1" + }, + "pytest-3.10.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "1a98bdba3b28b9524bb94dbf792cf099", + "name": "pytest", + "sha256": "261e9343e06f547cdf8ebe1fb1b45e46a80321b93fb4df34b0e406e9d85c3d8a", + "size": 339692, + "subdir": "linux-64", + "timestamp": 1542086558384, + "version": "3.10.1" + }, + "pytest-3.2.1-py27h98000ae_1.conda": { + "build": "py27h98000ae_1", + "build_number": 1, + "depends": [ + "py >=1.4.33", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "6528f9ffe22f43b6bd70d0f689e70e76", + "name": "pytest", + "sha256": "a47afc37e45e5a43c2f329d02bc4e5f06319f80736f52fdd2fcd1aa96126b372", + "size": 289766, + "subdir": "linux-64", + "timestamp": 1505688259990, + "version": "3.2.1" + }, + "pytest-3.2.1-py35hc97c719_1.conda": { + "build": "py35hc97c719_1", + "build_number": 1, + "depends": [ + "py >=1.4.33", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "9058311094a517a2969c09b1ce731143", + "name": "pytest", + "sha256": "e87fbd7e7a195f340a3b753fd913004bb6e1566bbcf6953e83b37cf1b214262c", + "size": 293952, + "subdir": "linux-64", + "timestamp": 1505688274722, + "version": "3.2.1" + }, + "pytest-3.2.1-py36h11ad3bb_1.conda": { + "build": "py36h11ad3bb_1", + "build_number": 1, + "depends": [ + "py >=1.4.33", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "91966974de4e66f2f3e4136131f26ce1", + "name": "pytest", + "sha256": "cde5255fd7a1cfe4f8fda6c72f99e9004a2b198ec04b94ed44e0239b441ae757", + "size": 294776, + "subdir": "linux-64", + "timestamp": 1505688289543, + "version": "3.2.1" + }, + "pytest-3.2.5-py27hfc7e320_0.conda": { + "build": "py27hfc7e320_0", + "build_number": 0, + "depends": [ + "py >=1.4.33", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "3eb838af3aa3c2ad0018bc09a9856d48", + "name": "pytest", + "sha256": "96d38d58b8c8e67ba5fc9efe0f85a2a03369ed785b2f7e1dd5b250f949b60320", + "size": 295846, + "subdir": "linux-64", + "timestamp": 1511321610858, + "version": "3.2.5" + }, + "pytest-3.2.5-py35h18d855a_0.conda": { + "build": "py35h18d855a_0", + "build_number": 0, + "depends": [ + "py >=1.4.33", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "c3c45bdb6a4674afe9345554a76302e5", + "name": "pytest", + "sha256": "90c2e91ef8052ad21d2843e0ae80dd7ec5331be26853654b57e8b7c1898211e1", + "size": 300258, + "subdir": "linux-64", + "timestamp": 1511321622171, + "version": "3.2.5" + }, + "pytest-3.2.5-py36h288962d_0.conda": { + "build": "py36h288962d_0", + "build_number": 0, + "depends": [ + "py >=1.4.33", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "c4d695494cadd16e7f20e734f7bc888b", + "name": "pytest", + "sha256": "459e00d23128ea5d30d6d590c980e19f6d0fcd45f3e0aa5622fb25560e7515db", + "size": 292814, + "subdir": "linux-64", + "timestamp": 1511321627683, + "version": "3.2.5" + }, + "pytest-3.3.0-py27h0742b9d_0.conda": { + "build": "py27h0742b9d_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "funcsigs", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "cbbef52d90bfd5ef920090d0080b0488", + "name": "pytest", + "sha256": "565c39ad2b47a08c23405a3090baad55db963a382e439ddb5d87ad82a1113bfc", + "size": 289985, + "subdir": "linux-64", + "timestamp": 1511931424928, + "version": "3.3.0" + }, + "pytest-3.3.0-py35h5c08cda_0.conda": { + "build": "py35h5c08cda_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "71ed33bd00b937f38525422fa6c7743f", + "name": "pytest", + "sha256": "c3869dec8ffa383cfab2264e85410c1f71048c31e5cab407e8f6b1bd3d60f7fa", + "size": 294629, + "subdir": "linux-64", + "timestamp": 1511931423972, + "version": "3.3.0" + }, + "pytest-3.3.0-py36h23ce9bc_0.conda": { + "build": "py36h23ce9bc_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "adcf6642b199f67c2a1e439a8e6282d0", + "name": "pytest", + "sha256": "b9ae583e612f81c388e1f0d47731993fdf0b5c51cceab71ccc5a1eb057824c7e", + "size": 291482, + "subdir": "linux-64", + "timestamp": 1511931484525, + "version": "3.3.0" + }, + "pytest-3.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs", + "funcsigs", + "pluggy", + "py >=1.4.33", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "151c0ad7e2d426675a608379f48104fc", + "name": "pytest", + "sha256": "66583aaee5d096f5cbde3bcfb4b1418d9f7d3632c29d9df122dd9d2b8ab1dd78", + "size": 290931, + "subdir": "linux-64", + "timestamp": 1515725591680, + "version": "3.3.2" + }, + "pytest-3.3.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs", + "pluggy", + "py >=1.4.33", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "58c4457953f5c4e5cbf28bb7949e526a", + "name": "pytest", + "sha256": "cf35d7f737a25d42b1bc1b286cf7600450160fe8fa69accb78894c87fc6f9eac", + "size": 295639, + "subdir": "linux-64", + "timestamp": 1515725240611, + "version": "3.3.2" + }, + "pytest-3.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs", + "pluggy", + "py >=1.4.33", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "MIT", + "md5": "be776e6c5b58ed98a3ba37a8d735fc91", + "name": "pytest", + "sha256": "ec9db0985c0c34e167b77a128bde520d0b74e4dfd850091c954a515dd5048e83", + "size": 292397, + "subdir": "linux-64", + "timestamp": 1515725594020, + "version": "3.3.2" + }, + "pytest-3.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "funcsigs", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "56df651a4b32e9b81b3089ddfd8fd43f", + "name": "pytest", + "sha256": "0d02165a2199b0013688f258604d413ffd6daa963b058338306d8a1ee3dd5e19", + "size": 295969, + "subdir": "linux-64", + "timestamp": 1519112337973, + "version": "3.4.0" + }, + "pytest-3.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "199a830cdb1d5ee6cbb797a288c080b4", + "name": "pytest", + "sha256": "4c128188e3f7d52060ad50ec13fefb8adb7511c2e19db44cb497e65bb158e40d", + "size": 300568, + "subdir": "linux-64", + "timestamp": 1519112352201, + "version": "3.4.0" + }, + "pytest-3.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "459cd33ca1a85e235af5c440072b538f", + "name": "pytest", + "sha256": "7ab491ded7248098a2baab8983e44c61b252ee07fd71f85d463cbb245e96813d", + "size": 292902, + "subdir": "linux-64", + "timestamp": 1519112348471, + "version": "3.4.0" + }, + "pytest-3.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "funcsigs", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "1fec6dadcc41a77be2f90c5f1d4758d7", + "name": "pytest", + "sha256": "9c8d7e98a5cae4452b20224038abd8f8311984e786b68fa15c658af8697e133d", + "size": 292346, + "subdir": "linux-64", + "timestamp": 1519747428626, + "version": "3.4.1" + }, + "pytest-3.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "69f2408080a1a7c7a776cd028ec066dc", + "name": "pytest", + "sha256": "34f7550e57e7d6793e13653161e39df0a74b1fd1c92fd1e7180bfc4ed124bbf6", + "size": 296914, + "subdir": "linux-64", + "timestamp": 1519747449115, + "version": "3.4.1" + }, + "pytest-3.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "889f7b1798415ccdf2cc6d130f265ca3", + "name": "pytest", + "sha256": "d3c9eef7a1a28f621a6ba752214962b560470378a138adb7dd4c323430801e1e", + "size": 293759, + "subdir": "linux-64", + "timestamp": 1519747418396, + "version": "3.4.1" + }, + "pytest-3.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "funcsigs", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "077daaa20e5aa81f48f59c12c62adc4e", + "name": "pytest", + "sha256": "9851e7fac1a5d11f28add2b61fa618230b83c7007ac1597db6451d31f336030b", + "size": 296925, + "subdir": "linux-64", + "timestamp": 1520367036018, + "version": "3.4.2" + }, + "pytest-3.4.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "60a8678c5b69ed567aa6488f0ce4099a", + "name": "pytest", + "sha256": "19bd65b82c616ad8790974739fa1708eca0d31b4d510fc906630fe6bc14755bd", + "size": 301556, + "subdir": "linux-64", + "timestamp": 1520367267083, + "version": "3.4.2" + }, + "pytest-3.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "17680deaaaab9c5241889c72aaaf37ee", + "name": "pytest", + "sha256": "48bc3166bd062ba53eded67e7a16c9cf14ceca151498b18ba414d27f056bf222", + "size": 298490, + "subdir": "linux-64", + "timestamp": 1520367292349, + "version": "3.4.2" + }, + "pytest-3.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "5b032c71c4ebb1699f5e6b15f1cf7bfc", + "name": "pytest", + "sha256": "c4d0cf99ab68e250fbb078926f6a6e0696dc6dbb0ee1530bffc8398bd8a3aaa2", + "size": 303914, + "subdir": "linux-64", + "timestamp": 1522186564622, + "version": "3.5.0" + }, + "pytest-3.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "b623ef796a8bd2a450d0a14a24c3b8c2", + "name": "pytest", + "sha256": "3deba1246430e3af33c431be3af8065ab0b132d430bfde79d9f783e0086353bd", + "size": 308140, + "subdir": "linux-64", + "timestamp": 1522186596454, + "version": "3.5.0" + }, + "pytest-3.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "4af70cd2dc94b933952cc9627f996a44", + "name": "pytest", + "sha256": "95f219a0659691113dab6cd45636ebf68acfd9097c230e1b9b549569fe19a180", + "size": 301042, + "subdir": "linux-64", + "timestamp": 1522186590067, + "version": "3.5.0" + }, + "pytest-3.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "02858d7856c8c05171af3da635892a35", + "name": "pytest", + "sha256": "13b5950cc346217f0e4af1ca371d27b5f1ae4cc5c2a9a3b556f6b70c10b20a08", + "size": 304320, + "subdir": "linux-64", + "timestamp": 1525118540346, + "version": "3.5.1" + }, + "pytest-3.5.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "7737b2b1901c5b9653a97c9d0f089bec", + "name": "pytest", + "sha256": "04eadae8b7f8331cb786a25d86e1dcfbe46670d16d31b85d199a0f06c73375c0", + "size": 308679, + "subdir": "linux-64", + "timestamp": 1525118559288, + "version": "3.5.1" + }, + "pytest-3.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "d596a83ce47e04116cb47da93b08c403", + "name": "pytest", + "sha256": "9b7e5fbff18b06e71a91a4dcbac01375e03487e06961c3f31f373af05a7b9e63", + "size": 305455, + "subdir": "linux-64", + "timestamp": 1525118596150, + "version": "3.5.1" + }, + "pytest-3.6.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "bd89facdcbd464c5e5d6fbba4a12b250", + "name": "pytest", + "sha256": "6f7e5ad3389f4e43a1a8337080901d85978f75076164afb4878c5c34b0780c69", + "size": 308533, + "subdir": "linux-64", + "timestamp": 1527822410451, + "version": "3.6.0" + }, + "pytest-3.6.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "c5f177fb605e5c7dc48dac50d349ac32", + "name": "pytest", + "sha256": "c7870a4203fdb1c5fa19c134b55f95e7c7cbdc8d3347af343897e0f7c1e1e8a9", + "size": 313042, + "subdir": "linux-64", + "timestamp": 1527822430538, + "version": "3.6.0" + }, + "pytest-3.6.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "49ad34a1c0f16e5444ae9e0188486303", + "name": "pytest", + "sha256": "e09be6c84edb48785418b7b2d639d054631eb55557f0d4d3fd03dbed1d154509", + "size": 309571, + "subdir": "linux-64", + "timestamp": 1527822362732, + "version": "3.6.0" + }, + "pytest-3.6.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "a053addce95e6fb69c8a9c8d6ede5a4e", + "name": "pytest", + "sha256": "68f4f1887e61a8d12c3509a2c80e3c9ffe557f6dc04b359ff796322aa0ebf8be", + "size": 308428, + "subdir": "linux-64", + "timestamp": 1528894537985, + "version": "3.6.1" + }, + "pytest-3.6.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "928410e51a1cd50fe283edd541ac2b7d", + "name": "pytest", + "sha256": "69e88085d67690e527c0696fc8427d2dfba82a82d7412797cc047fb27dc3b652", + "size": 308600, + "subdir": "linux-64", + "timestamp": 1528894567230, + "version": "3.6.1" + }, + "pytest-3.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "adcd18f4b69758e2195ebf8c447bb993", + "name": "pytest", + "sha256": "eb45e4ace1a5f201c5ad464729d3d80a27bb828c303b93e276e6d685d1d2af98", + "size": 305450, + "subdir": "linux-64", + "timestamp": 1528894501498, + "version": "3.6.1" + }, + "pytest-3.6.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "9ca62eb9698117e93336a7f379a3adce", + "name": "pytest", + "sha256": "d81acdca74b09e8a6c00aadeccd7bc6d895e4c674990966a91ce2c2d2d2bc1a1", + "size": 305988, + "subdir": "linux-64", + "timestamp": 1529939484773, + "version": "3.6.2" + }, + "pytest-3.6.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "5935064aaa4191c544017b36aa601d47", + "name": "pytest", + "sha256": "7ca7dfe190b41a55d28738067305f0201eae6b65d855d020439dcc9fcc801087", + "size": 313986, + "subdir": "linux-64", + "timestamp": 1529939524499, + "version": "3.6.2" + }, + "pytest-3.6.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "ddd39408813b674f7665ba71768f12bc", + "name": "pytest", + "sha256": "e8fd3e90065e071db64d6534422300f2a208686dc40d4601f27a3d416b1eef48", + "size": 307499, + "subdir": "linux-64", + "timestamp": 1529939465457, + "version": "3.6.2" + }, + "pytest-3.6.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "41126fb0cdd43d7f70a1c89eb0e40772", + "name": "pytest", + "sha256": "332bcfa877e7a91903b822a1a372e982e4578b889c1d684a75cdc67ecc9f7b06", + "size": 311360, + "subdir": "linux-64", + "timestamp": 1530212797676, + "version": "3.6.2" + }, + "pytest-3.6.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "8ab37d679faae89e5531cc84a51983bd", + "name": "pytest", + "sha256": "76a573d473157a24d5d146ab4465d4b6e808d0d48492dce634792bcf812ab448", + "size": 309847, + "subdir": "linux-64", + "timestamp": 1531850289641, + "version": "3.6.3" + }, + "pytest-3.6.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "0dcbb7e3d7d9d58519c22e0883e0e2a5", + "name": "pytest", + "sha256": "563b74ccae78e723329a9411fddcad4946e8c41ccc643e566fc565ea80bc326e", + "size": 314741, + "subdir": "linux-64", + "timestamp": 1531850227949, + "version": "3.6.3" + }, + "pytest-3.6.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "f3e07c0cdb692da53743c4eae892ee73", + "name": "pytest", + "sha256": "f46d8e0e9027cbd35fe0fb4be36b0311c4ce394d3f9739ef7ba21e5002c39b8c", + "size": 307769, + "subdir": "linux-64", + "timestamp": 1531850324222, + "version": "3.6.3" + }, + "pytest-3.6.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "adde1588b60db22a83be4e51b5acf18c", + "name": "pytest", + "sha256": "1f99e8a3a9ccf8b8e79d063be78306fd4eb9a79e3e57b0e9b791a37f1a0d52c1", + "size": 311806, + "subdir": "linux-64", + "timestamp": 1531850327263, + "version": "3.6.3" + }, + "pytest-3.6.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "78fb16459fd57007a8919c59940627cf", + "name": "pytest", + "sha256": "f4f0e9560c2dd89bef6b874c117c6903e49c104232e966c884accdad0e06913b", + "size": 306834, + "subdir": "linux-64", + "timestamp": 1532972930230, + "version": "3.6.4" + }, + "pytest-3.6.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "3a79a47a984985e79189c9276efda268", + "name": "pytest", + "sha256": "63b933d9f2894aa9ebe3afcad1761b25f66fd31809117342e811f4b626139b9a", + "size": 310715, + "subdir": "linux-64", + "timestamp": 1532972947170, + "version": "3.6.4" + }, + "pytest-3.6.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "29e845b23dbd50a8fa0e4d59fad67f07", + "name": "pytest", + "sha256": "078b670e8f54e1a0265aea340125ad32d70124086ae243698e16ca2ab89586fa", + "size": 311597, + "subdir": "linux-64", + "timestamp": 1532972878266, + "version": "3.6.4" + }, + "pytest-3.6.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.5,<0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "a5e4babf0b4e280fc6cb1934fe733bb2", + "name": "pytest", + "sha256": "d9547bc03d2a5e8037a9a0f85262768d63b9645c3ecc1beb7711d6f4be0d9280", + "size": 308103, + "subdir": "linux-64", + "timestamp": 1532973008669, + "version": "3.6.4" + }, + "pytest-3.7.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "57e3192c0467d35e8a35778fd27f3a54", + "name": "pytest", + "sha256": "19f616e23561dfb57e1a4d25bfbfe9ccd5de2e9a101ef0f17696e96a53ee44de", + "size": 314511, + "subdir": "linux-64", + "timestamp": 1533738856946, + "version": "3.7.1" + }, + "pytest-3.7.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "21cc6ad1b7fc4622831970d15f133988", + "name": "pytest", + "sha256": "ff6445ea5fa45e12fd7ef290a10d7170b84b927ecc93dbded544dbc2d3c71205", + "size": 318663, + "subdir": "linux-64", + "timestamp": 1533738867703, + "version": "3.7.1" + }, + "pytest-3.7.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "984873b4be2676e808491c6ff18f9763", + "name": "pytest", + "sha256": "65d08bfcdfd5df480c29c12635aee96a9bd21eb8204c3a67de30a972ad8ba93c", + "size": 319187, + "subdir": "linux-64", + "timestamp": 1533738821583, + "version": "3.7.1" + }, + "pytest-3.7.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "b6071fdc8afa0e4c2d016b5693dab917", + "name": "pytest", + "sha256": "914c0d08c77aa55b3de945d7cc0fbe65819b24cf90596cd82649e55afb5cfce3", + "size": 316049, + "subdir": "linux-64", + "timestamp": 1533738872911, + "version": "3.7.1" + }, + "pytest-3.7.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "8439824ad6dc96e796bb0247357b834d", + "name": "pytest", + "sha256": "c9776c65c9c8dc1b96f47b985cb5718c44f8f78dd88950a13956a5d4380792c7", + "size": 318708, + "subdir": "linux-64", + "timestamp": 1534944828655, + "version": "3.7.2" + }, + "pytest-3.7.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "a0ac809e903dc17335cc2a2908f2f623", + "name": "pytest", + "sha256": "fc2cc92a20e153d8799c847ab37404793554a24bfae62b9dd1e141ad4da1f8f9", + "size": 323673, + "subdir": "linux-64", + "timestamp": 1534944923565, + "version": "3.7.2" + }, + "pytest-3.7.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "f5d998039ed7a4a41b3f48aba4679045", + "name": "pytest", + "sha256": "91265fab6138168092f1bca9f49370f0804731243877e8999dcaab7078c3a20f", + "size": 316220, + "subdir": "linux-64", + "timestamp": 1534944783317, + "version": "3.7.2" + }, + "pytest-3.7.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "ed704c9367264ddaf492d01cda34a7d2", + "name": "pytest", + "sha256": "2d53a93b3d8d2c2a16186e77aec03263d2463e23c3c50d6094241424366cdacd", + "size": 320407, + "subdir": "linux-64", + "timestamp": 1534944833064, + "version": "3.7.2" + }, + "pytest-3.7.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "324aeebd20fde389cc9f8871819243c6", + "name": "pytest", + "sha256": "0ba749f762cf051e6321e9de3c9dc788b400f1d5074b9a4054621e02f90cbb3a", + "size": 315899, + "subdir": "linux-64", + "timestamp": 1535377167673, + "version": "3.7.3" + }, + "pytest-3.7.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "e54444c36274d48a3d4fc1cc4ea0653f", + "name": "pytest", + "sha256": "cbf2dace293724afe6a2e675b21862c6d2a50a931ea421f760507a8efc62f2d5", + "size": 320299, + "subdir": "linux-64", + "timestamp": 1535377234016, + "version": "3.7.3" + }, + "pytest-3.7.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "14fa8221784892ef03a57e52974cf784", + "name": "pytest", + "sha256": "98146c9fa45506c7884d120b034eb119ad61987b30f8e1079a15b797eb0b50a2", + "size": 320887, + "subdir": "linux-64", + "timestamp": 1535377136395, + "version": "3.7.3" + }, + "pytest-3.7.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "9f37ba27e3c8304bf77912ee27e5dbaf", + "name": "pytest", + "sha256": "98036c1b1274c65ad06c2b39036d9fb30ad9fb5b70ee0a03dc244be92bc498c1", + "size": 317570, + "subdir": "linux-64", + "timestamp": 1535377175267, + "version": "3.7.3" + }, + "pytest-3.7.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "52d5004e07012420934a820bdeaf42fe", + "name": "pytest", + "sha256": "643d26cc32c822b30d8b109179afcf2b84ca46aeb8c1cbbacabdfca50b55d708", + "size": 319889, + "subdir": "linux-64", + "timestamp": 1536072443344, + "version": "3.7.4" + }, + "pytest-3.7.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "6d52912cad2337416d3f2201c2d3265b", + "name": "pytest", + "sha256": "82dc4bfbf1c9bd98ce31d42ef6d03fce6698999c66640100f6dd0cf94a4c7d8f", + "size": 324884, + "subdir": "linux-64", + "timestamp": 1536072518913, + "version": "3.7.4" + }, + "pytest-3.7.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "cb70f71e220bed20df1f3100e5de7de4", + "name": "pytest", + "sha256": "a6e2daa36f6632d0051cef35995adacfc31a28aaebd27d04b91d3f48fdbc6f00", + "size": 317146, + "subdir": "linux-64", + "timestamp": 1536072422223, + "version": "3.7.4" + }, + "pytest-3.7.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "8e7de406f652262467f72f9faca4d8eb", + "name": "pytest", + "sha256": "3100e9705a6402e7a19c7118d37c43e8c1c550de7817adda8500f0242b1420ab", + "size": 317697, + "subdir": "linux-64", + "timestamp": 1536072535242, + "version": "3.7.4" + }, + "pytest-3.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "3c899a1803adbac201509660d5c6759b", + "name": "pytest", + "sha256": "5c02876b4d2daa6965fca864553a9b57c77efdc77454866a5145a1909e4b74df", + "size": 322226, + "subdir": "linux-64", + "timestamp": 1536696876208, + "version": "3.8.0" + }, + "pytest-3.8.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "fdd99f98d276233dc5270e350548812c", + "name": "pytest", + "sha256": "d33a5aa669941b20fa0edafc3f351edbe7e378983b7b5fc25836c76d2ba436a8", + "size": 330695, + "subdir": "linux-64", + "timestamp": 1536696896481, + "version": "3.8.0" + }, + "pytest-3.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "f237a55b5cbbd0adfa62de586aef40e1", + "name": "pytest", + "sha256": "368cdde00a49a35b2e82bae460835bd7f3e409ff3ca189a672b150b9145be04a", + "size": 323012, + "subdir": "linux-64", + "timestamp": 1536696926927, + "version": "3.8.0" + }, + "pytest-3.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "47bda65760831d18c12552f9983fe97e", + "name": "pytest", + "sha256": "99632a171e0c0f8b16fc75098d76843556082037dda51b4de702f5f925e86e74", + "size": 323819, + "subdir": "linux-64", + "timestamp": 1536696852762, + "version": "3.8.0" + }, + "pytest-3.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "343debb79d64853dd2ea26167321d072", + "name": "pytest", + "sha256": "c17a5105825aff4e9e51440917b0f2ca9045b8367b9e0cfd3a4c71f42b1f92eb", + "size": 326761, + "subdir": "linux-64", + "timestamp": 1538151932806, + "version": "3.8.1" + }, + "pytest-3.8.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "859765c3d3ba6753786d8f2495f96619", + "name": "pytest", + "sha256": "4cd7301d6963797bb95106eea04f3b974616d201e508e0d39e4fefd50fedd9d7", + "size": 327271, + "subdir": "linux-64", + "timestamp": 1538151994761, + "version": "3.8.1" + }, + "pytest-3.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "6fc20d88c9c20ee61fc8f9198281315d", + "name": "pytest", + "sha256": "764e6533202111286b81cff3d7e69e0bc475484a44ee5e204aef480a9b07b1c2", + "size": 327854, + "subdir": "linux-64", + "timestamp": 1538151975780, + "version": "3.8.1" + }, + "pytest-3.8.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "8a8a090f15a5eae4646bbbe7722add26", + "name": "pytest", + "sha256": "bf9c3d3f356155c15570b56e9de06cd82b21b0f26497b036abce1d5a2d91f08b", + "size": 328525, + "subdir": "linux-64", + "timestamp": 1538151934307, + "version": "3.8.1" + }, + "pytest-3.8.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "29e390585d9ab9323c9dfb7bd5243415", + "name": "pytest", + "sha256": "56178641f7527a540fe6a65b9dd2bd9e45ebeac70575e28e8d0804039667a882", + "size": 323534, + "subdir": "linux-64", + "timestamp": 1538866921966, + "version": "3.8.2" + }, + "pytest-3.8.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "0079cf42a7fc231459d83f376e75ca0c", + "name": "pytest", + "sha256": "0f2860715f51d504b6add15b759e17f9178d0c7c0a869deb49ca86179adad41f", + "size": 328474, + "subdir": "linux-64", + "timestamp": 1538866948616, + "version": "3.8.2" + }, + "pytest-3.8.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "4edf3fabdf5937070a0dcdf05668cfd4", + "name": "pytest", + "sha256": "ac4d0c33ea734311a2e773092ed1e8c275bebf5eff4e6ff35b285099ffdc3dbb", + "size": 329062, + "subdir": "linux-64", + "timestamp": 1538866924297, + "version": "3.8.2" + }, + "pytest-3.9.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "2886e129d5fff81ea975f62623bbdff9", + "name": "pytest", + "sha256": "2063dfbaeb9453836c389ad3d3a4aa65788733e46ce0c5f4e29538dac331f750", + "size": 329325, + "subdir": "linux-64", + "timestamp": 1540230084517, + "version": "3.9.1" + }, + "pytest-3.9.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "b5cecee9f928010b50934198ba4f736a", + "name": "pytest", + "sha256": "3c09994b44f55fe4cf25988ffecf1cd2fa97a7cc1f98a298b0da6daadee34313", + "size": 334400, + "subdir": "linux-64", + "timestamp": 1540230111741, + "version": "3.9.1" + }, + "pytest-3.9.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "3931e9b695129ba7bf7518900228c43c", + "name": "pytest", + "sha256": "ab88a5615e7b1123b44b6766503f6cde23059a3df0360155595effb7707d199e", + "size": 330992, + "subdir": "linux-64", + "timestamp": 1540230099639, + "version": "3.9.1" + }, + "pytest-3.9.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "a2ac81da360f11ef5c535da730ae8c05", + "name": "pytest", + "sha256": "c27ce506c799b7c536f30dac8b6c9dce878ce129c96e8c2fde2ace30e7a8f2c5", + "size": 333956, + "subdir": "linux-64", + "timestamp": 1541035610840, + "version": "3.9.3" + }, + "pytest-3.9.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "224f28ec80bec57e09c2000c273cc30f", + "name": "pytest", + "sha256": "5255262e2275f0995ce910e1b83a86f48352addceff81c3efbe7218a6f0f3dca", + "size": 335514, + "subdir": "linux-64", + "timestamp": 1541035593432, + "version": "3.9.3" + }, + "pytest-3.9.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "7543010eaa9b790b5bf29acf83158eae", + "name": "pytest", + "sha256": "38a5810ced99f05593ee59290293869be7c93c78ef1a13656e8afa08ef8f37df", + "size": 335998, + "subdir": "linux-64", + "timestamp": 1541035600527, + "version": "3.9.3" + }, + "pytest-4.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "761986dd4992badf8d13359bf1cb1d61", + "name": "pytest", + "sha256": "4d42e694710b34fc786c8c67b5c957061fb8c4a4758cf25bc9567fd8d5d6f8b6", + "size": 334100, + "subdir": "linux-64", + "timestamp": 1542390848128, + "version": "4.0.0" + }, + "pytest-4.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "87d7a5b418ecfb3aca1f556d0bf15a14", + "name": "pytest", + "sha256": "bd78d8bf10eb4318b51676b31db19fc5dc0cb42e8f9f8bff1381ad892563b500", + "size": 335071, + "subdir": "linux-64", + "timestamp": 1542390851335, + "version": "4.0.0" + }, + "pytest-4.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "ffd5d7d6ee3f997de1ea37b95010d47a", + "name": "pytest", + "sha256": "50b95bbe4d2842ebef947d6576dbee0429be472b0033a335dccad2125071bdb0", + "size": 335429, + "subdir": "linux-64", + "timestamp": 1542390843554, + "version": "4.0.0" + }, + "pytest-4.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "1a953eff83e18cc77e4950c678f3ce63", + "name": "pytest", + "sha256": "2b32ca843ef7b35c5e4d6db223ad830a66ec2207786bd0619dba1aebcd2e6d00", + "size": 346369, + "subdir": "linux-64", + "timestamp": 1543609539562, + "version": "4.0.1" + }, + "pytest-4.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "ce8c176b013fbda464f781755114b387", + "name": "pytest", + "sha256": "7c831da612ec28ff250f9ac2b772408f4e975183420ce45f527e1b79a65ad565", + "size": 347382, + "subdir": "linux-64", + "timestamp": 1543609509343, + "version": "4.0.1" + }, + "pytest-4.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "cb63043ca7e74e0844901248a38dc0b1", + "name": "pytest", + "sha256": "f67cc67de909a23bd85dffd8f58aa29cc9ee8bb93511b417d7f33066d0b250d8", + "size": 348115, + "subdir": "linux-64", + "timestamp": 1543609469952, + "version": "4.0.1" + }, + "pytest-4.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "0b60dbca3d95d70ebb21466fc40f0ef8", + "name": "pytest", + "sha256": "51616a342b2596e87936920c998193514478937d1f6971616442504f1659277c", + "size": 338733, + "subdir": "linux-64", + "timestamp": 1545073220251, + "version": "4.0.2" + }, + "pytest-4.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "8d49924951382ece4473f636488d9206", + "name": "pytest", + "sha256": "17e332eb5200eaf696818d62ec05134a2d51512c082e505a973c0d856120f5fa", + "size": 339835, + "subdir": "linux-64", + "timestamp": 1545073252648, + "version": "4.0.2" + }, + "pytest-4.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "c839acf683501cdcf0eb1b5219172c35", + "name": "pytest", + "sha256": "667e508aee44dc71012c472c4231f694207e1f2441cd84b04ac2775c7e384762", + "size": 336031, + "subdir": "linux-64", + "timestamp": 1545073238987, + "version": "4.0.2" + }, + "pytest-4.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "72277223431b3f855d65c34b2773ae25", + "name": "pytest", + "sha256": "c89f3e134a2c7e7543986a8e8b00cd8a8d1b0a7e33847f516f276252d4417a95", + "size": 342900, + "subdir": "linux-64", + "timestamp": 1547476469341, + "version": "4.1.0" + }, + "pytest-4.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "0db71d65097a06c34294acb155d52c6c", + "name": "pytest", + "sha256": "46d0f76f238ef68e1cb2e5940dea538bfb43736ba6a836b94406bc95968e5f33", + "size": 344066, + "subdir": "linux-64", + "timestamp": 1547476512018, + "version": "4.1.0" + }, + "pytest-4.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "8414b9c5654ab37207f585193f17a1e3", + "name": "pytest", + "sha256": "9fe171e066f34e37381fc942a43c72a99143b423a967ee29ae8926157d67d39c", + "size": 344629, + "subdir": "linux-64", + "timestamp": 1547476491586, + "version": "4.1.0" + }, + "pytest-4.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "a1ffa79a720d49ecaf8d7b09cc48893b", + "name": "pytest", + "sha256": "d0e65912d7cbdc577cf59d8220de84d17c96146d9352e3e06ba31c5b0cac2df1", + "size": 343910, + "subdir": "linux-64", + "timestamp": 1547905255484, + "version": "4.1.1" + }, + "pytest-4.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "c3af45701bbd22418f24d945fca4989c", + "name": "pytest", + "sha256": "5db23cb5c6918b69e387c6db91522cf7aed5be4ecd5af0309e8332a0d60dfb1b", + "size": 340909, + "subdir": "linux-64", + "timestamp": 1547905304389, + "version": "4.1.1" + }, + "pytest-4.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "b5ca92c6aab4cd05a37cea0c83766103", + "name": "pytest", + "sha256": "16c845ed974add0201a6966e4254e83293c648d991fe48810101746d503278f7", + "size": 341519, + "subdir": "linux-64", + "timestamp": 1547904824482, + "version": "4.1.1" + }, + "pytest-4.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "a7a6cf5b4c8170a7ff2f6567469a7499", + "name": "pytest", + "sha256": "100aed0c331ad6cc1f618ecd93114d3c5294dc215dffc036cace9541cf0e0012", + "size": 340079, + "subdir": "linux-64", + "timestamp": 1549322996784, + "version": "4.2.0" + }, + "pytest-4.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "7e44bc3b92dcce6a02923f21337c88a1", + "name": "pytest", + "sha256": "6e4e1ef147b80272379b0b0b6e63e40e673f850586c128252627e22a3a4d90bc", + "size": 341233, + "subdir": "linux-64", + "timestamp": 1549323037194, + "version": "4.2.0" + }, + "pytest-4.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "82dc1fc8a7016bf6a69a42d9161299ae", + "name": "pytest", + "sha256": "e2aa34c0fd331befc447275d5729e8e16791d7143fd28be7f9684cb7e1aaeef4", + "size": 336992, + "subdir": "linux-64", + "timestamp": 1549322981019, + "version": "4.2.0" + }, + "pytest-4.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "185403ccf07c83d80ddb4b0edeac9b1a", + "name": "pytest", + "sha256": "6fb41ecffaec32a76f6e85a45b8fd1955a066429dcaf5c36e0834b1ca4dd7e79", + "size": 348084, + "subdir": "linux-64", + "timestamp": 1550354944773, + "version": "4.2.1" + }, + "pytest-4.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "61db887a09044a78084c51bfef99dbe0", + "name": "pytest", + "sha256": "23e4e48d0318f3a4e700740d6a0d2ab5796d95f3950fb1eb4ad9e3ffc7f46700", + "size": 349329, + "subdir": "linux-64", + "timestamp": 1550354969951, + "version": "4.2.1" + }, + "pytest-4.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "ef61a0199db210b0bd72a27a9cfd3208", + "name": "pytest", + "sha256": "3760031208de47ee29217a005560fd3dd04cad427c4f28cb726be5997be33125", + "size": 345234, + "subdir": "linux-64", + "timestamp": 1550354892131, + "version": "4.2.1" + }, + "pytest-4.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "more-itertools >=4.0,<6.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "273fa404c56217617b48936156af645f", + "name": "pytest", + "sha256": "22e760da4bf4b1a64003b1d648d700f7733fbaab26911cc0fd9bc31091ea67bf", + "size": 349621, + "subdir": "linux-64", + "timestamp": 1551146952503, + "version": "4.3.0" + }, + "pytest-4.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "7723d8ca65b0bc8bfc82eceadf053bdc", + "name": "pytest", + "sha256": "928076016ccc382e257838a9abb70e1e176a8437a9e26db65ff43cc23e5e203c", + "size": 350881, + "subdir": "linux-64", + "timestamp": 1551146972362, + "version": "4.3.0" + }, + "pytest-4.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "3c948c8c5abde39252627dd1490d9cb2", + "name": "pytest", + "sha256": "325f3a97eded052dde6c36604e4ffb070ab3d3407b6a56f15a69e26cebbdc58c", + "size": 346672, + "subdir": "linux-64", + "timestamp": 1551146946468, + "version": "4.3.0" + }, + "pytest-4.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs", + "more-itertools >=4.0", + "more-itertools >=4.0,<6.0", + "pathlib2 >=2.2.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "9a4a889bbd2cde408575cca801ed69ba", + "name": "pytest", + "sha256": "9aef211827204bcc8cafa51b7580fb0838a0d9dc7e95ff73b6a593fa5c5e789a", + "size": 350207, + "subdir": "linux-64", + "timestamp": 1552926736533, + "version": "4.3.1" + }, + "pytest-4.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "1ad8bff0d9893116a6b18e81997d8a5e", + "name": "pytest", + "sha256": "47a77644541274163065eba3982f14cca02738f566f59273bb8cb9b77607e313", + "size": 350996, + "subdir": "linux-64", + "timestamp": 1552926773068, + "version": "4.3.1" + }, + "pytest-4.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.7", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "990fbf15d7f2fe2660b313bb6ac939c4", + "name": "pytest", + "sha256": "a61fe7e0248f6bcec17bada8d1281791511177c8faf9aa7276164c4e1963971a", + "size": 351720, + "subdir": "linux-64", + "timestamp": 1552926652317, + "version": "4.3.1" + }, + "pytest-4.4.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs >=1.0", + "more-itertools >=4.0", + "more-itertools >=4.0,<6.0", + "pathlib2 >=2.2.0", + "pluggy >=0.9", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "067e3da92e93078297ef2c1890ffec25", + "name": "pytest", + "sha256": "4e40d602f95fae8556e1abebe9f62b8e94f562c9390a22c3d2d9c5a3171ea765", + "size": 351558, + "subdir": "linux-64", + "timestamp": 1555084777159, + "version": "4.4.0" + }, + "pytest-4.4.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.9", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "22c283cac36855ac23bd312603580f60", + "name": "pytest", + "sha256": "f55f280d5092536692df403d8734dcfe0757d9fcc40ce3a470dc741f0ff4d886", + "size": 352454, + "subdir": "linux-64", + "timestamp": 1555084787120, + "version": "4.4.0" + }, + "pytest-4.4.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.9", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "3455f1618c659fe5ae1bd218ec0163c2", + "name": "pytest", + "sha256": "b8dbe6b4b22b5af9845e06896e79795f0a454e08de60f697c16e13432eeaaece", + "size": 353210, + "subdir": "linux-64", + "timestamp": 1555084762668, + "version": "4.4.0" + }, + "pytest-4.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs >=1.0", + "more-itertools >=4.0", + "more-itertools >=4.0,<6.0", + "pathlib2 >=2.2.0", + "pluggy >=0.9", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "20f51135748f7d462a8a06c86cf082d6", + "name": "pytest", + "sha256": "0f0e7e783908ded3c533364236805f628939c4ad21510683ac5a4cf1c59e50ce", + "size": 356408, + "subdir": "linux-64", + "timestamp": 1555950341360, + "version": "4.4.1" + }, + "pytest-4.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.9", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "8bda2ee253ae8dcfdf98a78eadf55536", + "name": "pytest", + "sha256": "0b654e01efae3d04b208cac75b2161647a7db5f0734306017a4dba4ba5bf2f2c", + "size": 352927, + "subdir": "linux-64", + "timestamp": 1555950343429, + "version": "4.4.1" + }, + "pytest-4.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.9", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "6c04a45b74a0aae2557631f480e6c261", + "name": "pytest", + "sha256": "3d65c43995d8d22c9b69585c9ebe11d4b6614d7b5499afcf88a046796356404c", + "size": 353690, + "subdir": "linux-64", + "timestamp": 1555950329949, + "version": "4.4.1" + }, + "pytest-4.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs >=1.0", + "more-itertools >=4.0", + "more-itertools >=4.0,<6.0", + "pathlib2 >=2.2.0", + "pluggy >=0.9", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "b43b7771e88dc48d8c432bafc6e1191c", + "name": "pytest", + "sha256": "056ce360739c36c44d865e38588501885618f208aad05751c6e8d0ffd68c0f71", + "size": 356413, + "subdir": "linux-64", + "timestamp": 1557502971221, + "version": "4.4.2" + }, + "pytest-4.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.9", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "024c973938e318fcb1f34d92b9256455", + "name": "pytest", + "sha256": "2ce059b2e078eccfefd7e0b2cf0e619806aaa20e2d42be64f048cc56d9162e8a", + "size": 357633, + "subdir": "linux-64", + "timestamp": 1557502983700, + "version": "4.4.2" + }, + "pytest-4.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.9", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0" + ], + "license": "MIT", + "md5": "bbc2caed4447c7f19145554c62c7f65f", + "name": "pytest", + "sha256": "b08b17b90df0f6f6fe4b0d661d61d20ac90a34f2e2ed11b14bcd40b857b897e6", + "size": 358308, + "subdir": "linux-64", + "timestamp": 1557502917168, + "version": "4.4.2" + }, + "pytest-4.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs >=1.0", + "more-itertools >=4.0", + "more-itertools >=4.0,<6.0", + "pathlib2 >=2.2.0", + "pluggy >=0.9,!=0.10,<1.0", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0", + "wcwidth" + ], + "license": "MIT", + "md5": "cb3fd56ed947f68b255bccb580122128", + "name": "pytest", + "sha256": "09fc22322a34152670cb72b077f7997c1d048e3b6bd52598d9c70e5567776cf0", + "size": 357370, + "subdir": "linux-64", + "timestamp": 1557856610358, + "version": "4.5.0" + }, + "pytest-4.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.9,!=0.10,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0", + "wcwidth" + ], + "license": "MIT", + "md5": "325db3a37072466b2f95f2b2b7767aa7", + "name": "pytest", + "sha256": "cb69eced2dc8fb862a8810375a4436b32f4445eed25fcf2db2a867ec37af2f17", + "size": 362809, + "subdir": "linux-64", + "timestamp": 1557856674188, + "version": "4.5.0" + }, + "pytest-4.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "pluggy >=0.9,!=0.10,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0", + "wcwidth" + ], + "license": "MIT", + "md5": "6395c338e795510d199be8bc1626457c", + "name": "pytest", + "sha256": "aa8c2ced4242e7bcdd165f8e64f793e26f725f1e491f18406e1afa9a4ee5090f", + "size": 363583, + "subdir": "linux-64", + "timestamp": 1557856645702, + "version": "4.5.0" + }, + "pytest-4.6.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0", + "wcwidth" + ], + "license": "MIT", + "md5": "37a02d23e35d182c331aabdb7691a270", + "name": "pytest", + "sha256": "fbdc34543f80f63ea9d4ddb5cf8f5f8d17db7e630097fda8f04052751c9e1da2", + "size": 367729, + "subdir": "linux-64", + "timestamp": 1594257241668, + "version": "4.6.11" + }, + "pytest-4.6.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0", + "wcwidth" + ], + "license": "MIT", + "md5": "e09344c51f2e32672638b9d7ba223075", + "name": "pytest", + "sha256": "13cafa8c388f60aaed2d8b592da9719c9d7f16efe825f5c1169cba26b921b4e2", + "size": 364100, + "subdir": "linux-64", + "timestamp": 1594257270739, + "version": "4.6.11" + }, + "pytest-4.6.11-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "six >=1.10.0", + "wcwidth" + ], + "license": "MIT", + "md5": "72cea087b653e45287d8186eea38146c", + "name": "pytest", + "sha256": "cf39e277f3d1fb16aad7a13356e82f99c94993aa152673db09b35fba95be5f78", + "size": 365492, + "subdir": "linux-64", + "timestamp": 1594257244479, + "version": "4.6.11" + }, + "pytest-4.6.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "funcsigs >=1.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "more-itertools >=4.0,<6.0", + "packaging", + "pathlib2 >=2.2.0", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=2.7,<2.8.0a0", + "setuptools >=40.0", + "six >=1.10.0", + "wcwidth" + ], + "license": "MIT", + "md5": "9cd34338794244bcf87681b84e797faa", + "name": "pytest", + "sha256": "fbd25a3e3c5f3530ef96cb05b40688f523c77dc6df9b825992eb7ca3a32b7f83", + "size": 363765, + "subdir": "linux-64", + "timestamp": 1559660004887, + "version": "4.6.2" + }, + "pytest-4.6.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "six >=1.10.0", + "wcwidth" + ], + "license": "MIT", + "md5": "782926047a81e06e405dbca0d234f65d", + "name": "pytest", + "sha256": "053bd139571086ea737bdb907f314111aff6f5eb26e8fbefa5c392b25bf97d0c", + "size": 365000, + "subdir": "linux-64", + "timestamp": 1559660037414, + "version": "4.6.2" + }, + "pytest-4.6.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "six >=1.10.0", + "wcwidth" + ], + "license": "MIT", + "md5": "e01a4ecf24f2285156405fa623b3760b", + "name": "pytest", + "sha256": "7619ec5068df16652f8aab2a29b32c77bf3eae2a69121d0a4da8be8944edb468", + "size": 365713, + "subdir": "linux-64", + "timestamp": 1559660016271, + "version": "4.6.2" + }, + "pytest-5.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "016ade302ec247258d979c0cab5eaf80", + "name": "pytest", + "sha256": "1e46906f8e1d8c62b7205188d68e747920903756608fe6a248589dac437ee351", + "size": 352624, + "subdir": "linux-64", + "timestamp": 1562078849023, + "version": "5.0.0" + }, + "pytest-5.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "5744c89b3d8c501d826bf143c950ede0", + "name": "pytest", + "sha256": "adf95c7b60e7e745273220c47ae74c6828c72ef754c3a8dbc0277a983b346390", + "size": 352769, + "subdir": "linux-64", + "timestamp": 1562078540913, + "version": "5.0.0" + }, + "pytest-5.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "ac832c6a842f91f76efc23a5fa3c0b0e", + "name": "pytest", + "sha256": "cb1e703b986c4d997bacd6b54044772095cc7bca194962567ae5b4f9ed08697c", + "size": 354293, + "subdir": "linux-64", + "timestamp": 1594255673564, + "version": "5.0.0" + }, + "pytest-5.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "343f6c231a08cd2ac9c0567c6cc47211", + "name": "pytest", + "sha256": "94348c7eed7803f54af2f8b288c45805e03c97c79463000bf792bcdc881e9721", + "size": 356966, + "subdir": "linux-64", + "timestamp": 1563206731269, + "version": "5.0.1" + }, + "pytest-5.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "ec74cdf07135ad6363467db6e2c36933", + "name": "pytest", + "sha256": "fbe2bb6517ae04463234374ad15d1498c4a91d22dc8bcdb346efaa806ace5ee7", + "size": 352723, + "subdir": "linux-64", + "timestamp": 1563206730572, + "version": "5.0.1" + }, + "pytest-5.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "bb39052b137f9c707fe3fe38a4350da8", + "name": "pytest", + "sha256": "eb0e522b4f6fbcd07b6fa2e5aa406fd56e712b0f0ce84569ee9918c98dc8b82d", + "size": 361244, + "subdir": "linux-64", + "timestamp": 1569264129454, + "version": "5.1.2" + }, + "pytest-5.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "1d785d255b3418fa498a4db424526c95", + "name": "pytest", + "sha256": "49013dc847d88ad138434a42d8b70c804daf2f3aa5e56d13e9d3a81655f28ef1", + "size": 361755, + "subdir": "linux-64", + "timestamp": 1569264120783, + "version": "5.1.2" + }, + "pytest-5.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "5dca581c39e9a62e627255637fd00905", + "name": "pytest", + "sha256": "4becf50d2c65595e5b1f8f8f1a8e07d95f917db03c1e9774f04d9809ac60191a", + "size": 364283, + "subdir": "linux-64", + "timestamp": 1569854916207, + "version": "5.2.0" + }, + "pytest-5.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "85610c2feca5222568b69275dc4fe3c0", + "name": "pytest", + "sha256": "c4f3e0135a603e9131adccdcbc08de89a895ac56499c3790c4b8759d3bc144c8", + "size": 364844, + "subdir": "linux-64", + "timestamp": 1569854920216, + "version": "5.2.0" + }, + "pytest-5.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "effc6f7e8f76291d1893e09406bddc25", + "name": "pytest", + "sha256": "670c2dd839e2344e12106919c50f76abbd948fe62d130301761f9ac8d3a69958", + "size": 364487, + "subdir": "linux-64", + "timestamp": 1570463198594, + "version": "5.2.1" + }, + "pytest-5.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "846b08bbe515499c31ecc3f50ba10674", + "name": "pytest", + "sha256": "1b4b3d0cc7653d6d361e8604a58e149278acdeb64cad8acf0e17eaf78d36db7a", + "size": 365200, + "subdir": "linux-64", + "timestamp": 1570463211692, + "version": "5.2.1" + }, + "pytest-5.2.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "080f0e6ed49fe214feb630e40a547ef0", + "name": "pytest", + "sha256": "36e6b9fe2a536d8da810f5ea63766d44b23b7222c00afcb508edd040676049ce", + "size": 356997, + "subdir": "linux-64", + "timestamp": 1572609251263, + "version": "5.2.1" + }, + "pytest-5.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "62df961b6a422857c432948b01224ea1", + "name": "pytest", + "sha256": "f116e35618f5f9049ec4724f1099a5546e3e383077fa860d7dccc1071f4eff83", + "size": 364997, + "subdir": "linux-64", + "timestamp": 1572457266932, + "version": "5.2.2" + }, + "pytest-5.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "160915598f0a8936bb6afd2359aa7d55", + "name": "pytest", + "sha256": "ad56cccfecbb23e8164e16555522082f79575b06afb40fac5967a19ad8a409c9", + "size": 365526, + "subdir": "linux-64", + "timestamp": 1572457239063, + "version": "5.2.2" + }, + "pytest-5.2.4-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pathlib2 >=2.2.0", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "22202901b7b66fe653f1e88413e943a8", + "name": "pytest", + "sha256": "aba9ec7c50d617d8349fab3d97af9713072d1d348bed78592126a6c5bed6634d", + "size": 365780, + "subdir": "linux-64", + "timestamp": 1573941489484, + "version": "5.2.4" + }, + "pytest-5.2.4-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pathlib2 >=2.2.0", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "4cc7ad3306813483c2db0ca16bc2093b", + "name": "pytest", + "sha256": "4d822fd168a01fd2354c9b77086ea36651972b5de0c5cb402d9d12fa8d7a830d", + "size": 366410, + "subdir": "linux-64", + "timestamp": 1573941474066, + "version": "5.2.4" + }, + "pytest-5.2.4-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "atomicwrites >=1.0", + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "071e2be3f4e7766d176268b91ac77775", + "name": "pytest", + "sha256": "5a2fc53671b77769b2eb2d903f33111558c47985000ccb839092b46411812c22", + "size": 368035, + "subdir": "linux-64", + "timestamp": 1573941483335, + "version": "5.2.4" + }, + "pytest-5.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "dacde3e951e82b95292d5e5c39fa5ce7", + "name": "pytest", + "sha256": "06853c46cd6e0e8f4e2ca5d92440adb39d49827585dda4fec254091cfa5b9a9a", + "size": 377266, + "subdir": "linux-64", + "timestamp": 1574699106650, + "version": "5.3.0" + }, + "pytest-5.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "723e1db68b2266320781bc6b09154071", + "name": "pytest", + "sha256": "3d70e4dd3881e30ea07f65e8f1ff216f557527c20cac4fc93215acbf6d6722b6", + "size": 377834, + "subdir": "linux-64", + "timestamp": 1574699079802, + "version": "5.3.0" + }, + "pytest-5.3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "258aeaf1bb914d8eacdab238e2517ff2", + "name": "pytest", + "sha256": "09eb07dfcb3d7a514788614d3af0a5d01ec215ab68591dfb1e660b14ea245e43", + "size": 379892, + "subdir": "linux-64", + "timestamp": 1574699169471, + "version": "5.3.0" + }, + "pytest-5.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "a279860bfd34723474b164cabf199b63", + "name": "pytest", + "sha256": "10f69cd432e598cf92f453becca6da3059b8e8c9300b18f7d4a954a7787ee48d", + "size": 377626, + "subdir": "linux-64", + "timestamp": 1575390373668, + "version": "5.3.1" + }, + "pytest-5.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "9d344924f765fc0c46a3fec360ddd6c7", + "name": "pytest", + "sha256": "f87e3938bfc04c60b7d9e153d471cfa705696f778076d05372383f3f6882e2da", + "size": 378034, + "subdir": "linux-64", + "timestamp": 1575390318722, + "version": "5.3.1" + }, + "pytest-5.3.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "8cc86f1dbbda67ce99329895f7cfeb41", + "name": "pytest", + "sha256": "dd3e4f605841973d0327454a9f771f2f7cd33a5b3ebc08fb0445f40d50f5ab51", + "size": 380217, + "subdir": "linux-64", + "timestamp": 1575390410985, + "version": "5.3.1" + }, + "pytest-5.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "d501e730fac81ecdf20b4165b4085246", + "name": "pytest", + "sha256": "e73d56b3004243515cd2f49c4405945ba0ce7d053ad3f1b8bccfbccf5e1c900c", + "size": 374048, + "subdir": "linux-64", + "timestamp": 1576512420466, + "version": "5.3.2" + }, + "pytest-5.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "fbf45278a57f2aed154cb4cbe8dbce04", + "name": "pytest", + "sha256": "9107451678425708c073974ad989a559fc5f72a79f73e5480d998f79be9c389a", + "size": 378872, + "subdir": "linux-64", + "timestamp": 1576512367394, + "version": "5.3.2" + }, + "pytest-5.3.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "1842054755baf3a1113e6cf5a7c6fd91", + "name": "pytest", + "sha256": "1320c00400fef93d0dd59416fe6a7fe7fcf27362ea5b307d49f1f8241ac559dc", + "size": 380775, + "subdir": "linux-64", + "timestamp": 1576512422153, + "version": "5.3.2" + }, + "pytest-5.3.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "de2a569da2875954d89727e51ae96c6b", + "name": "pytest", + "sha256": "ef5b23ec0bd2170230e5d74b69e5236e614d655a7b5e24016b87b81b10367558", + "size": 375993, + "subdir": "linux-64", + "timestamp": 1580150799644, + "version": "5.3.4" + }, + "pytest-5.3.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "c759cb0e3a5d71ee3b94bbe45a74ed2d", + "name": "pytest", + "sha256": "70b148a3d81b389031707421f70945e8f4ed91d0276d7d60425b670ff0cdf784", + "size": 381136, + "subdir": "linux-64", + "timestamp": 1580150781443, + "version": "5.3.4" + }, + "pytest-5.3.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "13f77465319febb6424fcb9a6c6255c3", + "name": "pytest", + "sha256": "eb6ee6208f01a9f5370a50ee7c1652af0c8e99017dbe6a2619bdfd1058296c3c", + "size": 378605, + "subdir": "linux-64", + "timestamp": 1580150782961, + "version": "5.3.4" + }, + "pytest-5.3.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "044696f35ee46ed1b98020f5329d71ea", + "name": "pytest", + "sha256": "72daad799c6733e44642c200bded0dff94e48a31ff43a83c422f51be72e68826", + "size": 380503, + "subdir": "linux-64", + "timestamp": 1580834472108, + "version": "5.3.5" + }, + "pytest-5.3.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "0ebbc4516e6c0e1a8d348c1396372e4b", + "name": "pytest", + "sha256": "771195fc20deeb438932e887df011efb3d3ecd0e0b8cf820593f340acf9e8ab5", + "size": 376531, + "subdir": "linux-64", + "timestamp": 1580834436620, + "version": "5.3.5" + }, + "pytest-5.3.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthanlder >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "3319010222493cac24593d09a00b7fdc", + "name": "pytest", + "sha256": "fbc1235acf317fd41ec3e2fa3e794c6b220c516688c54bd0a4f1bd9735303326", + "size": 379161, + "subdir": "linux-64", + "timestamp": 1580834469399, + "version": "5.3.5" + }, + "pytest-5.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "038c2e007523707ff3f181a572105bb5", + "name": "pytest", + "sha256": "0011c963a17d4f9ffa82a396bf9dc5e9793e63860d5e8bba4d298293944c63be", + "size": 394363, + "subdir": "linux-64", + "timestamp": 1584457062473, + "version": "5.4.1" + }, + "pytest-5.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "2826c66542c17e8bd193710193d142ce", + "name": "pytest", + "sha256": "0ac70ebedc2473e8c69135f8d4462a16f44fb4dc63bdf14992ba79cb291aa696", + "size": 394919, + "subdir": "linux-64", + "timestamp": 1584457006510, + "version": "5.4.1" + }, + "pytest-5.4.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "7922788b89efb3534829ef385526cbaf", + "name": "pytest", + "sha256": "fc14429e8335b1c6e334d4a7eacce9530796a6f4afd6e85848404480b54a9bb1", + "size": 393016, + "subdir": "linux-64", + "timestamp": 1584457083580, + "version": "5.4.1" + }, + "pytest-5.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "6a0e967c9548147b5094df3e774e6a03", + "name": "pytest", + "sha256": "2f4191dd75c38f59d6d652ba9af8853b4ebdce3f7f765d8faf3a5f7b8e6ed6d5", + "size": 395149, + "subdir": "linux-64", + "timestamp": 1589495632781, + "version": "5.4.2" + }, + "pytest-5.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "aeb1e7d4572017f33490ebee794a2f60", + "name": "pytest", + "sha256": "4c063c81222732969b158ad880ba1f2835f3555ad0a7262d2c8bd58b2b0af053", + "size": 391501, + "subdir": "linux-64", + "timestamp": 1589495589496, + "version": "5.4.2" + }, + "pytest-5.4.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "e9c18c3d88063269d38d8dcf9ff0b23f", + "name": "pytest", + "sha256": "7a227c1ae7535a9d12221e7276b58cd9dbef863e2c31033b8ab5c22a1f0cbfc5", + "size": 397973, + "subdir": "linux-64", + "timestamp": 1589495594123, + "version": "5.4.2" + }, + "pytest-5.4.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "56e6175ff0b4b0daa800f42a8bf025ef", + "name": "pytest", + "sha256": "92d4f535e88ce0ab700abad16fc47a14141ad4a848fbc3b94acaa01540a8eff2", + "size": 396402, + "subdir": "linux-64", + "timestamp": 1592322954043, + "version": "5.4.3" + }, + "pytest-5.4.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.6,<3.7.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "a14fc31e85e99e5355ef95132cfaa98b", + "name": "pytest", + "sha256": "4d444d098181e06473252d68bfd00618ea72db5c63e794665ab40007c7a08e83", + "size": 396578, + "subdir": "linux-64", + "timestamp": 1605213691860, + "version": "5.4.3" + }, + "pytest-5.4.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "0b262aa5ff04629e7ad5a2674d093e68", + "name": "pytest", + "sha256": "98069b315ef399c7b93c26817701f35cd3b004631afe6514b9ae9898831d0529", + "size": 396966, + "subdir": "linux-64", + "timestamp": 1592322984624, + "version": "5.4.3" + }, + "pytest-5.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib_metadata >=0.12", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.7,<3.8.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "7b5b161cc0e8529243289a4ed8a84b24", + "name": "pytest", + "sha256": "accc68142e7cac5434464e40fad7fe145392956e5ce880898c08365e79803618", + "size": 397032, + "subdir": "linux-64", + "timestamp": 1605213677706, + "version": "5.4.3" + }, + "pytest-5.4.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "c089f18aa6d8b6635f417f5456bc3f1d", + "name": "pytest", + "sha256": "6a7dc1b81240a547c8e61bd738dafa5fc4a45f47f30fc92078f63de52698605f", + "size": 398996, + "subdir": "linux-64", + "timestamp": 1592322958800, + "version": "5.4.3" + }, + "pytest-5.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.8,<3.9.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "edb62e3ded5a1783de7a01ec6e9ab1ac", + "name": "pytest", + "sha256": "a02ff006a4892ff3fd4d3ba032e3a40d090f792c95844a7e9f1a9a8916dc252e", + "size": 394930, + "subdir": "linux-64", + "timestamp": 1605213719053, + "version": "5.4.3" + }, + "pytest-5.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "more-itertools >=4.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.5.0", + "python >=3.9,<3.10.0a0", + "setuptools >=40.0", + "wcwidth" + ], + "license": "MIT", + "md5": "f95973f2e5a61cf5e673d5d9b249a937", + "name": "pytest", + "sha256": "c0d55f08e1a722d5fa14fe0484b3f22dccb4923389a61c4b62f393ed528cddb4", + "size": 394278, + "subdir": "linux-64", + "timestamp": 1605213693526, + "version": "5.4.3" + }, + "pytest-6.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "57cb987a7879bd612ecd116469bcfcc8", + "name": "pytest", + "sha256": "bb284b8e03f3a24b93487d5f84f9077f3c9ed5c213eca7fe746cd63cf9bd3f4f", + "size": 433769, + "subdir": "linux-64", + "timestamp": 1596838663879, + "version": "6.0.1" + }, + "pytest-6.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "733c6ca195c5fa9fe35896d625500adb", + "name": "pytest", + "sha256": "646ec8eef90922f8280162964e78015c16c1735e5c567f05c9f05b262d5300cd", + "size": 434166, + "subdir": "linux-64", + "timestamp": 1596838660986, + "version": "6.0.1" + }, + "pytest-6.0.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "4949979db6f1f58fbe04c723ba292304", + "name": "pytest", + "sha256": "92e3c54c5365c9440b3dba322c3a28288a7684f7e24429630fabc30e16cba980", + "size": 432244, + "subdir": "linux-64", + "timestamp": 1596838638788, + "version": "6.0.1" + }, + "pytest-6.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "205cb1aa0465b5e88c9de99b2d010ef1", + "name": "pytest", + "sha256": "1534f56ff823ead1bd35aa1a3e3af4903e1f0445cbf2af240762fcef8f841c11", + "size": 416814, + "subdir": "linux-64", + "timestamp": 1600278297253, + "version": "6.0.2" + }, + "pytest-6.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "9c0b9301adbf36bed9cd62bc07cb0987", + "name": "pytest", + "sha256": "45654b6cea03383edf7f92e290edb487ec64414b2f4c4f297ee63118f3ca83e0", + "size": 416478, + "subdir": "linux-64", + "timestamp": 1600278332198, + "version": "6.0.2" + }, + "pytest-6.0.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "b197c81618fd66704452946e6dd26ddd", + "name": "pytest", + "sha256": "2aa2b8a3dca94beff84c85e3ef047938024f52c88c573aadbc961150a18120bf", + "size": 424742, + "subdir": "linux-64", + "timestamp": 1600278301742, + "version": "6.0.2" + }, + "pytest-6.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "011f74eaf8718935ef5bc40b6462b70e", + "name": "pytest", + "sha256": "ec7620a187ddfffa9c841b21732748ef6e6abfa0da503c6dbb1b7ac77811979e", + "size": 422748, + "subdir": "linux-64", + "timestamp": 1601657664463, + "version": "6.1.0" + }, + "pytest-6.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "8590e6d30679802d3c7acb3faaee19cc", + "name": "pytest", + "sha256": "950a995894a82e19a5b10edd8d568fd224043cd4cd0be20157298646172770d4", + "size": 418419, + "subdir": "linux-64", + "timestamp": 1601657635000, + "version": "6.1.0" + }, + "pytest-6.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "848e01b68c960702496104f7e3e8f2d8", + "name": "pytest", + "sha256": "f6e2a376d7f5f8808936a947150888f4cc566ca958f1541597f8be387df0f910", + "size": 421213, + "subdir": "linux-64", + "timestamp": 1601657687093, + "version": "6.1.0" + }, + "pytest-6.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "9671f92cda1611caacde3685155c3d48", + "name": "pytest", + "sha256": "32ae66fe891618408ea99b1ecbb6f8450ed6fe81d1135f45cfa47163937572dd", + "size": 418029, + "subdir": "linux-64", + "timestamp": 1602184471504, + "version": "6.1.1" + }, + "pytest-6.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "58201a8fbd27d3fa38ee86748830f656", + "name": "pytest", + "sha256": "2bae73074b3306daa4f5eba95e3732136435fec18ae5802c45f6578c8261087a", + "size": 423302, + "subdir": "linux-64", + "timestamp": 1602184471388, + "version": "6.1.1" + }, + "pytest-6.1.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "26158fdb875ba747ac71425a11b13e45", + "name": "pytest", + "sha256": "4dc7921d1abe5ce628fe92c980c8befb17fa83f64d8ceb500d3f371a86f37329", + "size": 425916, + "subdir": "linux-64", + "timestamp": 1602184471487, + "version": "6.1.1" + }, + "pytest-6.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "md5": "d56ea8490efc2709896e64da5e7b2d80", + "name": "pytest", + "sha256": "e3bb866ac00a6507eda9be6cfabc54519f2a2f4c4083aac9ce1715f23344cd1e", + "size": 438822, + "subdir": "linux-64", + "timestamp": 1606832201488, + "version": "6.1.1" + }, + "pytest-6.1.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "c29a305ad4b681624ebc0a337d6ac9a9", + "name": "pytest", + "sha256": "9604f04ce732160aa08299bf1d73f2048cdba553d8734c1f762a31033ef87170", + "size": 418095, + "subdir": "linux-64", + "timestamp": 1606846768924, + "version": "6.1.2" + }, + "pytest-6.1.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "1ef689bec24f0aa7b6031fc19f845c47", + "name": "pytest", + "sha256": "64ac1e009ce09a0ecebf3fc779c3b1af9b30eeab8c54be37fd9ea34b104adb8a", + "size": 423847, + "subdir": "linux-64", + "timestamp": 1606846760187, + "version": "6.1.2" + }, + "pytest-6.1.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "151d0b41ce3f18cf7c7d7fa8ca76f818", + "name": "pytest", + "sha256": "3037e69c013628e006ce27d4bda42040460ce435448b401a0d335c8521e4f5e5", + "size": 421479, + "subdir": "linux-64", + "timestamp": 1606846742497, + "version": "6.1.2" + }, + "pytest-6.1.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=17.4.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "md5": "ee37d29fdd04728353d9805374636411", + "name": "pytest", + "sha256": "a204f601839da0c2597dbe2118ab8fec7ab0d8e04bd040668f060a1e1435faa8", + "size": 420533, + "subdir": "linux-64", + "timestamp": 1606846771925, + "version": "6.1.2" + }, + "pytest-6.2.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "e30055d4bd70f29e2bcd92c60abff2fe", + "name": "pytest", + "sha256": "00ea72a79f474592a0925568a34e00c9f39268a4b0260f2bef2413197e441bd3", + "size": 434201, + "subdir": "linux-64", + "timestamp": 1607972301538, + "version": "6.2.0" + }, + "pytest-6.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "ddd6bccedacdd47e42d87d9668aed608", + "name": "pytest", + "sha256": "7f127407590b0d0d1daecb004f4e7fa5a2671573d5e3ef32ab3b0c6f3244a1b6", + "size": 429813, + "subdir": "linux-64", + "timestamp": 1607972290045, + "version": "6.2.0" + }, + "pytest-6.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "cbcf1a43cc6ed133d068b51f8195bcfb", + "name": "pytest", + "sha256": "c456c48baecbe7ddc289deca67dd6c1777e46eea445996510bdd4948872534d8", + "size": 437531, + "subdir": "linux-64", + "timestamp": 1607972302272, + "version": "6.2.0" + }, + "pytest-6.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "md5": "ce7dfc685b448e55765df326f03a5d0d", + "name": "pytest", + "sha256": "89732fd47b718ffc7a15384c56e8e375a20e558772717d2e5fbb2b8dd9a51c84", + "size": 431481, + "subdir": "linux-64", + "timestamp": 1607972305013, + "version": "6.2.0" + }, + "pytest-6.2.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "2bb41352137bdfc51bdd6a19705fc490", + "name": "pytest", + "sha256": "cd93ff1a24355ad36f6fdea0fff0196bdd5e7ba649d5e7a46b5566cab379d08b", + "size": 434556, + "subdir": "linux-64", + "timestamp": 1608058132032, + "version": "6.2.1" + }, + "pytest-6.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "b65da63f86d91fce6c879e7f7c65910d", + "name": "pytest", + "sha256": "3bbe2512d9bd84f11bc2f17b2180b663f89e3497cbe03a7c54cb73f4a1d66b94", + "size": 435498, + "subdir": "linux-64", + "timestamp": 1608058112351, + "version": "6.2.1" + }, + "pytest-6.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "df79ebc6fb76d200c605ad33b4599973", + "name": "pytest", + "sha256": "8e2d211ac35fbdf217513a96d3bc6f2dcdd3b49278b20f6ed85dbb6bdb6f8844", + "size": 433218, + "subdir": "linux-64", + "timestamp": 1608058148767, + "version": "6.2.1" + }, + "pytest-6.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "md5": "b9e11a5e39c52dacf72d8a5ac7b93fbb", + "name": "pytest", + "sha256": "07ab2d6b9a6c7474e02311f5542ee83cac4238abe255cba8908f2e00a992c2fe", + "size": 437724, + "subdir": "linux-64", + "timestamp": 1608058134120, + "version": "6.2.1" + }, + "pytest-6.2.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "f78dac7c4aac4fec074b42a8d48582b2", + "name": "pytest", + "sha256": "a545647561502ca191bb4f6d1b7d79661bd20cf38b785dfb3e13ff376f36ba32", + "size": 434951, + "subdir": "linux-64", + "timestamp": 1611693854222, + "version": "6.2.2" + }, + "pytest-6.2.2-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "91fcbe1b42d6d3a787e48da5c653aeaf", + "name": "pytest", + "sha256": "c2bfb2e47f687d5642761397cebf5a40848c7f0500fd8d23bec1de2ee93f5f18", + "size": 443854, + "subdir": "linux-64", + "timestamp": 1611855270543, + "version": "6.2.2" + }, + "pytest-6.2.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "68011c18bf3a1df505c3eb28321d1cea", + "name": "pytest", + "sha256": "3fb54788ccf498510588c4149a061837a0253878e12df910d52d34097015d482", + "size": 430257, + "subdir": "linux-64", + "timestamp": 1611693844208, + "version": "6.2.2" + }, + "pytest-6.2.2-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "84b4d5693f95e3682993c18d390b4273", + "name": "pytest", + "sha256": "b4d6c57f8a534a46d3e2c37cfb5f8c05f4eb46dab809aef416906cb88b864851", + "size": 449852, + "subdir": "linux-64", + "timestamp": 1611855304175, + "version": "6.2.2" + }, + "pytest-6.2.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "c3f3adf7d9b19b60fd3c005c3b0d75ac", + "name": "pytest", + "sha256": "a1bf4b873fc923535fb33a04b6d132f0ec7d1fa208a6aad88923e59d0e38b6c9", + "size": 432750, + "subdir": "linux-64", + "timestamp": 1611693819667, + "version": "6.2.2" + }, + "pytest-6.2.2-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "09b98067400665edaf6daa189df5aa95", + "name": "pytest", + "sha256": "f1fabd49829b1944ecb40ae0cc12e5d6944986f757a2de1b20cfe27864921ebb", + "size": 452714, + "subdir": "linux-64", + "timestamp": 1611855301733, + "version": "6.2.2" + }, + "pytest-6.2.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "md5": "90102aad074235ffed6f1bfcf7fd715b", + "name": "pytest", + "sha256": "b217086383b519b6c22d7ba12973e9b8a4d615ca7ea2f734fb7f7b033961daa8", + "size": 432386, + "subdir": "linux-64", + "timestamp": 1611693840337, + "version": "6.2.2" + }, + "pytest-6.2.2-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "md5": "2c22d4a8e7acee2a31492e8d3648970e", + "name": "pytest", + "sha256": "92db25dae82bca768ac4d091d082738846573473f054ac92b73c42de6ae5ea13", + "size": 452100, + "subdir": "linux-64", + "timestamp": 1611855303310, + "version": "6.2.2" + }, + "pytest-6.2.3-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "md5": "cfe6a83b48d5598370e36febee4b98cc", + "name": "pytest", + "sha256": "cdb100f7f92227728774400d7069e45ab613ee1a8c3de2551d867ab534bf82df", + "size": 429830, + "subdir": "linux-64", + "timestamp": 1617569117137, + "version": "6.2.3" + }, + "pytest-6.2.3-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "md5": "8aefbf0c90bc7d47dd5430707dd39bbf", + "name": "pytest", + "sha256": "8ce1b588c2020cfb1006b7ea90bb6d217654b3d90358303277bb27e2f6746a6c", + "size": 430410, + "subdir": "linux-64", + "timestamp": 1617569617604, + "version": "6.2.3" + }, + "pytest-6.2.3-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "md5": "95f358e260c25946c07a943e18cbb58d", + "name": "pytest", + "sha256": "306a61cbeb83dc13c4cde8f94126684a5ebdf6f90668153530c7d7d7e54d2fd0", + "size": 433750, + "subdir": "linux-64", + "timestamp": 1617569614994, + "version": "6.2.3" + }, + "pytest-6.2.3-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "md5": "6c0881018097652bd87d33c9d9e2fb35", + "name": "pytest", + "sha256": "8821eccf9d94ba3a7bc63f078a1c2dcb33d5b8e5d535cffe849fe41a894a68cd", + "size": 432614, + "subdir": "linux-64", + "timestamp": 1617569616744, + "version": "6.2.3" + }, + "pytest-6.2.4-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.10,<3.11.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "375f6a005780f77d24db64d64e7215ee", + "name": "pytest", + "sha256": "fa7bfe99ff8da4f748c529e02a366d4b91251895c9df62b496471302c76deb0f", + "size": 443586, + "subdir": "linux-64", + "timestamp": 1640793712353, + "version": "6.2.4" + }, + "pytest-6.2.4-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.6,<3.7.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cbaf3048f2b25ed2b63eb890e0403fdf", + "name": "pytest", + "sha256": "1f36d02983fe766192137b4b295570456f57543bf1e8b45048968ee1cab9721e", + "size": 434910, + "subdir": "linux-64", + "timestamp": 1623322016547, + "version": "6.2.4" + }, + "pytest-6.2.4-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dcac0d26067c596115776d4b0b57d179", + "name": "pytest", + "sha256": "77ead778e988bec98c623ad392dc8cd6924904cb0964247eee8fce3ba5f8851e", + "size": 430204, + "subdir": "linux-64", + "timestamp": 1623321968159, + "version": "6.2.4" + }, + "pytest-6.2.4-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62967f3cfdf22d8f7fc89826cc72f312", + "name": "pytest", + "sha256": "37ca2e1c9cae6116c6cf5dad969627254a483a14633dc6c5c36d0d1c1c3ddeee", + "size": 432867, + "subdir": "linux-64", + "timestamp": 1623321995693, + "version": "6.2.4" + }, + "pytest-6.2.4-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "more-itertools >=4.0.0", + "packaging", + "pluggy >=0.12,<1.0.0a1", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "286b8f4423d9b0f7441cbecabf99bdf3", + "name": "pytest", + "sha256": "2fb4bd104284b6cd7bbc29ce95837479281fd3fcf440c153708ac91b35eed48d", + "size": 432140, + "subdir": "linux-64", + "timestamp": 1623322006098, + "version": "6.2.4" + }, + "pytest-6.2.5-py311h06a4308_3.conda": { + "build": "py311h06a4308_3", + "build_number": 3, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.11,<3.12.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "05e64fa7b82b18ae2e3e8d46b5c517f3", + "name": "pytest", + "sha256": "03e09bd0b7db68d40495e0288edbd7fc4ba78888e68ceef081c0aa851b419c36", + "size": 596683, + "subdir": "linux-64", + "timestamp": 1676822891783, + "version": "6.2.5" + }, + "pytest-6.2.5-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6e8552085ec40fbe8fe4711166454d5", + "name": "pytest", + "sha256": "c7b2234f4a13a2a9ad0e3e3b03ed8631370b618870d9ce3bbc346b068e35c5dc", + "size": 435420, + "subdir": "linux-64", + "timestamp": 1637677152135, + "version": "6.2.5" + }, + "pytest-6.2.5-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52a6739ba472ddd5aeaf0fd495827c38", + "name": "pytest", + "sha256": "0c028502553959f5fc9b199cfdb1dcf27d7fd38a7832d7df021db3e919e9cf47", + "size": 438172, + "subdir": "linux-64", + "timestamp": 1637677204411, + "version": "6.2.5" + }, + "pytest-6.2.5-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "686cccd58281097a962175da7d774e52", + "name": "pytest", + "sha256": "ba6a7f9f1ff5263eb6377cf4676d2325d10b35e302b040036bd28dc290d1496f", + "size": 437586, + "subdir": "linux-64", + "timestamp": 1637677180596, + "version": "6.2.5" + }, + "pytest-7.1.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "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" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2520bcb26366e663a9b9729f095bde9", + "name": "pytest", + "sha256": "b1f36f5adf2f2d9235618057661b699fcc330d428a67a41c49ad63fc03104bb9", + "size": 478044, + "subdir": "linux-64", + "timestamp": 1649048810463, + "version": "7.1.1" + }, + "pytest-7.1.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "tomli >=1.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd52c781e65ffbc71a5284670e81a16d", + "name": "pytest", + "sha256": "2c5c9cf114c6a7af31bea2846d9df1631e43090a1f4fded393c6f3c4e5b5d73a", + "size": 464752, + "subdir": "linux-64", + "timestamp": 1649066920070, + "version": "7.1.1" + }, + "pytest-7.1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "tomli >=1.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "630c0a0aff5f50ea71e2bf33389e1d5c", + "name": "pytest", + "sha256": "daf1718fefcaa5704dad49cab74813f1e4879b3a6d3d3cfb1032a35d506eb321", + "size": 473237, + "subdir": "linux-64", + "timestamp": 1649049057963, + "version": "7.1.1" + }, + "pytest-7.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "tomli >=1.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60a212efd469873088bfa2c6318c8e77", + "name": "pytest", + "sha256": "3453b6f1b197f49502001a6a3fff084c25937c4dc2ea330dad84a9d5b5ce8cab", + "size": 467523, + "subdir": "linux-64", + "timestamp": 1649066921124, + "version": "7.1.1" + }, + "pytest-7.1.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "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" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b3ed8e2b45b6c17ff8fc74a6ba0c51aa", + "name": "pytest", + "sha256": "166f1cd70cfd16e95cf73b97a8ec49ea1fdaf88e9bfbb4b6aa0062b79707e785", + "size": 463166, + "subdir": "linux-64", + "timestamp": 1654685073860, + "version": "7.1.2" + }, + "pytest-7.1.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.11,<3.12.0a0", + "tomli >=1.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb21a22c91d2aecb48d24610e537bd18", + "name": "pytest", + "sha256": "33f51ffb1dd3604bc7f3e7f075b643c14c5e5dfd023650fcc9fc3b1e4d0a3ef1", + "size": 621919, + "subdir": "linux-64", + "timestamp": 1676822875677, + "version": "7.1.2" + }, + "pytest-7.1.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "importlib-metadata >=0.12", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.7,<3.8.0a0", + "tomli >=1.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eef8709bae7a2c326e7cf907082f0ebc", + "name": "pytest", + "sha256": "91de033bfb81545e9cf68cc9301d6455d463fc5c4c186e1c9a75097473db8d40", + "size": 455464, + "subdir": "linux-64", + "timestamp": 1654685034307, + "version": "7.1.2" + }, + "pytest-7.1.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.8,<3.9.0a0", + "tomli >=1.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d7f526a3d29273e06957d302f515755", + "name": "pytest", + "sha256": "b53b30fada49efbd95cc01d79f215ff8ee6e61c0532b762c002d63c9fcfdd4d8", + "size": 458410, + "subdir": "linux-64", + "timestamp": 1654685099260, + "version": "7.1.2" + }, + "pytest-7.1.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.9,<3.10.0a0", + "tomli >=1.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95b4d59a681c06f7653360e3b62c0741", + "name": "pytest", + "sha256": "7ed84ff57302bed407406cc4ffc05ce734710c14398645926a4be20d08f97245", + "size": 457865, + "subdir": "linux-64", + "timestamp": 1654685005949, + "version": "7.1.2" + }, + "pytest-arraydiff-0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "3367a26aec0ba4b9e2ec520d707990e5", + "name": "pytest-arraydiff", + "sha256": "9d32899575d260aa1730a9f49c07eecf29fbb66371476e0a703e1778da7025b7", + "size": 14928, + "subdir": "linux-64", + "timestamp": 1518731542120, + "version": "0.2" + }, + "pytest-arraydiff-0.2-py27h39e3cac_0.conda": { + "build": "py27h39e3cac_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "e135cc74f8a1349c7c4a43dad51c62a9", + "name": "pytest-arraydiff", + "sha256": "d7bd0ffa8e25183e4fad11e1cd42fbf8e62a1467d8b0473a10463376dd633028", + "size": 14903, + "subdir": "linux-64", + "timestamp": 1530738101761, + "version": "0.2" + }, + "pytest-arraydiff-0.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD", + "md5": "f6400b923ed3e6e618a8031d6fbb2471", + "name": "pytest-arraydiff", + "sha256": "2eccd96a7d4116cd0a30d6230f76ba4d7831700f81c176604e1677c98e196cf0", + "size": 14965, + "subdir": "linux-64", + "timestamp": 1518731622023, + "version": "0.2" + }, + "pytest-arraydiff-0.2-py35h39e3cac_0.conda": { + "build": "py35h39e3cac_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD", + "md5": "bcef2873a8b414e35f3bf98bcf88d9e1", + "name": "pytest-arraydiff", + "sha256": "f7c4598fd54f2ea55f1375a9700a70f480644a68d867057da1a3fa1d72f2a535", + "size": 14931, + "subdir": "linux-64", + "timestamp": 1534352902159, + "version": "0.2" + }, + "pytest-arraydiff-0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "519f4246a1d53b40c68416dd0a2858c0", + "name": "pytest-arraydiff", + "sha256": "f10d2d0a8b995b02406506d254ee155044a9b21731f44654d8f821b1b312795a", + "size": 14769, + "subdir": "linux-64", + "timestamp": 1518731452843, + "version": "0.2" + }, + "pytest-arraydiff-0.2-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "0995b3e836d4e86d253ed4bac5466a77", + "name": "pytest-arraydiff", + "sha256": "1b2f14c89e058f397debf3a95050dbe9d11e7e223589452085d60a589791801c", + "size": 14740, + "subdir": "linux-64", + "timestamp": 1530738076573, + "version": "0.2" + }, + "pytest-arraydiff-0.2-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD", + "md5": "6da63c3904bbee5df74e597c77d95a2b", + "name": "pytest-arraydiff", + "sha256": "24eedfcfa5989f0936523b9468c84f0a3aa0a4d0f50df6494371785d9dc37912", + "size": 14756, + "subdir": "linux-64", + "timestamp": 1530738127892, + "version": "0.2" + }, + "pytest-arraydiff-0.2-py38h39e3cac_0.conda": { + "build": "py38h39e3cac_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD", + "md5": "04d73f7bbe3e007cf15071fd92d53996", + "name": "pytest-arraydiff", + "sha256": "14d50893b9d1d2607d9719009833e8380c6afc58282af6ad5c6f3774831ebc31", + "size": 15685, + "subdir": "linux-64", + "timestamp": 1574170812302, + "version": "0.2" + }, + "pytest-arraydiff-0.3-py27h39e3cac_0.conda": { + "build": "py27h39e3cac_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "3e3bcaf311f640ef62e82dcf0d492b98", + "name": "pytest-arraydiff", + "sha256": "93b17438918e5fdc8c843372de11bba83894c2d5fbf87aa235b6a2f5d70f316a", + "size": 15425, + "subdir": "linux-64", + "timestamp": 1545232325236, + "version": "0.3" + }, + "pytest-arraydiff-0.3-py310h2f386ee_0.conda": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD", + "md5": "7e22a8e783c99bc72f0dfd0a427edc05", + "name": "pytest-arraydiff", + "sha256": "c01685bf9d2a96b94c41264f336d03501e24999228bb2a2860f88c1057be6d35", + "size": 15921, + "subdir": "linux-64", + "timestamp": 1640810503536, + "version": "0.3" + }, + "pytest-arraydiff-0.3-py311h6410fe4_0.conda": { + "build": "py311h6410fe4_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "BSD", + "md5": "79b34b6b3755830611331dffe1338416", + "name": "pytest-arraydiff", + "sha256": "3faa083ca7459382abdaf2d0837432dffd88c221fad21c30b44ace6a0947820d", + "size": 19017, + "subdir": "linux-64", + "timestamp": 1676845496139, + "version": "0.3" + }, + "pytest-arraydiff-0.3-py36h39e3cac_0.conda": { + "build": "py36h39e3cac_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "f7a162b76d2d02551bae3f138072b664", + "name": "pytest-arraydiff", + "sha256": "db48417f5e35abb5b7e3cf31944691a75395497b2bce07339f718176d1d1323a", + "size": 15469, + "subdir": "linux-64", + "timestamp": 1545232348769, + "version": "0.3" + }, + "pytest-arraydiff-0.3-py37h39e3cac_0.conda": { + "build": "py37h39e3cac_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD", + "md5": "bf2f326f1eb7be73dab2c087ff6400af", + "name": "pytest-arraydiff", + "sha256": "ff96b6b6cc57e49079f36a8543cefbf611f5cd4b747d0929f1a7fa26db134f6e", + "size": 15613, + "subdir": "linux-64", + "timestamp": 1545232142851, + "version": "0.3" + }, + "pytest-arraydiff-0.3-py37hb070fc8_0.conda": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD", + "md5": "0f62adb56b7ff5be8c6589aeea78dda9", + "name": "pytest-arraydiff", + "sha256": "2711c9e9cfa84667845bbe202914da51bf631dfd80ade157688aedd6c5837501", + "size": 16497, + "subdir": "linux-64", + "timestamp": 1636110895721, + "version": "0.3" + }, + "pytest-arraydiff-0.3-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD", + "md5": "69054869f3d994f85fe17e3a3f3f803f", + "name": "pytest-arraydiff", + "sha256": "3c9f9b1a88bd25890b4329ea1ee21bf2d6f0e96b84f2ce928441dbaacb0ed8ce", + "size": 16414, + "subdir": "linux-64", + "timestamp": 1636110882228, + "version": "0.3" + }, + "pytest-arraydiff-0.3-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy", + "pytest", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD", + "md5": "8479de2e4cb1db172ccd75842ddc24ba", + "name": "pytest-arraydiff", + "sha256": "93c25ed909a74bb9da587a7251f4650d417d3eb38db1c6bdfb0565bebc8aa2ee", + "size": 16770, + "subdir": "linux-64", + "timestamp": 1607625837100, + "version": "0.3" + }, + "pytest-astropy-0.10.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "hypothesis >=5.1", + "pytest >=4.6", + "pytest-arraydiff >=0.1", + "pytest-astropy-header >=0.1.2", + "pytest-cov >=2.3.1", + "pytest-doctestplus >=0.11.0", + "pytest-filter-subpackage >=0.1", + "pytest-mock >=2.0", + "pytest-openfiles >=0.3.1", + "pytest-remotedata >=0.3.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "979ab3a9776d9bd30e91a9b70016d7ff", + "name": "pytest-astropy", + "sha256": "b4250f68acdf5577b48e627eaf21dedf0e71e2560f6b8ab3165b7b93212911ed", + "size": 10246, + "subdir": "linux-64", + "timestamp": 1657529889875, + "version": "0.10.0" + }, + "pytest-astropy-0.10.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "hypothesis >=5.1", + "pytest >=4.6", + "pytest-arraydiff >=0.1", + "pytest-astropy-header >=0.1.2", + "pytest-cov >=2.3.1", + "pytest-doctestplus >=0.11.0", + "pytest-filter-subpackage >=0.1", + "pytest-mock >=2.0", + "pytest-openfiles >=0.3.1", + "pytest-remotedata >=0.3.1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2eba69553875a98bb88b6cef2e61384b", + "name": "pytest-astropy", + "sha256": "718adc34b57b4f8bcc90410541b3011e1acd1d04397f4ae7fbc173cbc543df15", + "size": 11085, + "subdir": "linux-64", + "timestamp": 1676861289068, + "version": "0.10.0" + }, + "pytest-astropy-0.10.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "hypothesis >=5.1", + "pytest >=4.6", + "pytest-arraydiff >=0.1", + "pytest-astropy-header >=0.1.2", + "pytest-cov >=2.3.1", + "pytest-doctestplus >=0.11.0", + "pytest-filter-subpackage >=0.1", + "pytest-mock >=2.0", + "pytest-openfiles >=0.3.1", + "pytest-remotedata >=0.3.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bc2d43d38c12153483e793a3e7009cf6", + "name": "pytest-astropy", + "sha256": "4c66ffd40b52ab353c87b34b1bdebd268192e72ff2767d3a3534a3647b433d5d", + "size": 10206, + "subdir": "linux-64", + "timestamp": 1657529837637, + "version": "0.10.0" + }, + "pytest-astropy-0.10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "hypothesis >=5.1", + "pytest >=4.6", + "pytest-arraydiff >=0.1", + "pytest-astropy-header >=0.1.2", + "pytest-cov >=2.3.1", + "pytest-doctestplus >=0.11.0", + "pytest-filter-subpackage >=0.1", + "pytest-mock >=2.0", + "pytest-openfiles >=0.3.1", + "pytest-remotedata >=0.3.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0df0462572d195ff29d693a094484255", + "name": "pytest-astropy", + "sha256": "a421599ca61dc221e2e48be23609dc09650d4febd91548bd185dab7715558f73", + "size": 10197, + "subdir": "linux-64", + "timestamp": 1657529962430, + "version": "0.10.0" + }, + "pytest-astropy-0.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.2.0", + "hypothesis >=5.1", + "pytest >=4.6", + "pytest-arraydiff >=0.1", + "pytest-astropy-header >=0.1.2", + "pytest-cov >=2.3.1", + "pytest-doctestplus >=0.11.0", + "pytest-filter-subpackage >=0.1", + "pytest-mock >=2.0", + "pytest-openfiles >=0.3.1", + "pytest-remotedata >=0.3.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "451ae35a70bc2db7e77f5129edd926ad", + "name": "pytest-astropy", + "sha256": "e58737dacf4b03dff7f4abfcad51dc0bcd057ad38d33f87fd584ce211ba5e569", + "size": 10203, + "subdir": "linux-64", + "timestamp": 1657529926198, + "version": "0.10.0" + }, + "pytest-astropy-0.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.2", + "pytest-openfiles >=0.2", + "pytest-remotedata >=0.2", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "e658ec2dc78957b96c7e8cf0b84cc13d", + "name": "pytest-astropy", + "sha256": "094cc3d8877a3400745ce2b2c925c95f265f66f70860378c0659fce1ec4563ae", + "size": 6092, + "subdir": "linux-64", + "timestamp": 1518797675599, + "version": "0.2.1" + }, + "pytest-astropy-0.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.2", + "pytest-openfiles >=0.2", + "pytest-remotedata >=0.2", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "5c87a0882c623327a8ed071c144768cf", + "name": "pytest-astropy", + "sha256": "40f11e079e0626fc9a3779642a16a2045e3d7250b2cf454b7543f37c967269d2", + "size": 6091, + "subdir": "linux-64", + "timestamp": 1518797835181, + "version": "0.2.1" + }, + "pytest-astropy-0.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.2", + "pytest-openfiles >=0.2", + "pytest-remotedata >=0.2", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "3c5c2f2074583ce889648e60ce81e7d9", + "name": "pytest-astropy", + "sha256": "25874476002085a52b9d0bde007fe8ad262d546ace4358b814db684f9979b24c", + "size": 6061, + "subdir": "linux-64", + "timestamp": 1518797843724, + "version": "0.2.1" + }, + "pytest-astropy-0.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.1.0", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.3", + "pytest-openfiles >=0.3.0", + "pytest-remotedata >=0.2.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "5cc8efb4a8f964df92698287ec302ddd", + "name": "pytest-astropy", + "sha256": "a37e004e145dadf055ed452feabf54b215dd842e400fd17b2d48c5a2a32ecfe7", + "size": 5914, + "subdir": "linux-64", + "timestamp": 1524580704177, + "version": "0.3.0" + }, + "pytest-astropy-0.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.1.0", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.3", + "pytest-openfiles >=0.3.0", + "pytest-remotedata >=0.2.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "f078a0d7dc272fa0d670c9e41d5cc0d7", + "name": "pytest-astropy", + "sha256": "b011314ba7973aa4c8f47efe81e8043453b8131ff892b7861ae1e665b2c88b5d", + "size": 5908, + "subdir": "linux-64", + "timestamp": 1524580751965, + "version": "0.3.0" + }, + "pytest-astropy-0.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.1.0", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.3", + "pytest-openfiles >=0.3.0", + "pytest-remotedata >=0.2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "19d8d62584e412b0b6254ecb2cf68615", + "name": "pytest-astropy", + "sha256": "f3dfc81aacbf7ba683b2faffba8e3024d97b66874b4a53064bc65a0118630e2f", + "size": 5907, + "subdir": "linux-64", + "timestamp": 1524580734459, + "version": "0.3.0" + }, + "pytest-astropy-0.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.3", + "pytest-openfiles >=0.3", + "pytest-remotedata >=0.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "037e8c7afe51cfa299fda7a77c136494", + "name": "pytest-astropy", + "sha256": "1913e2bc744c1cb0182f23b05d9acfa6d5960717173e3b9ade1347555b91963c", + "size": 5855, + "subdir": "linux-64", + "timestamp": 1528150063921, + "version": "0.4.0" + }, + "pytest-astropy-0.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.3", + "pytest-openfiles >=0.3", + "pytest-remotedata >=0.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "18093666ca5f0c4306d22500ee0754fa", + "name": "pytest-astropy", + "sha256": "2780cf774c4b69f119e09a575d4adf9d0b3feeb8bbed1621b8e4304dbc47b467", + "size": 5854, + "subdir": "linux-64", + "timestamp": 1528150041100, + "version": "0.4.0" + }, + "pytest-astropy-0.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.3", + "pytest-openfiles >=0.3", + "pytest-remotedata >=0.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "8cfaebd4685eeac883819ac874aa6a41", + "name": "pytest-astropy", + "sha256": "be51fcd57fb39e4675e5f77c7105f4872f62230727fb0d4171ce66763d2bb42f", + "size": 5827, + "subdir": "linux-64", + "timestamp": 1528149979261, + "version": "0.4.0" + }, + "pytest-astropy-0.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.1.3", + "pytest-openfiles >=0.3", + "pytest-remotedata >=0.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "f917e28fbc37f9b81df9019a831747bc", + "name": "pytest-astropy", + "sha256": "97c2fb5fde1213fcf8a916b0380dc948ece915cff0bdfcdded4110b0fc4525e3", + "size": 5791, + "subdir": "linux-64", + "timestamp": 1530738179260, + "version": "0.4.0" + }, + "pytest-astropy-0.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.2.0", + "pytest-openfiles >=0.3.1", + "pytest-remotedata >=0.3.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "10012bce2a4aea4524b1a5b89a92f75c", + "name": "pytest-astropy", + "sha256": "04be4b68bf3e4b8da646c23ee64e71f46ce8b0f076e59167fa7b6549b4eee2ed", + "size": 6962, + "subdir": "linux-64", + "timestamp": 1545121425923, + "version": "0.5.0" + }, + "pytest-astropy-0.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.2.0", + "pytest-openfiles >=0.3.1", + "pytest-remotedata >=0.3.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "e7b54adc960e3f76ff390f938214677f", + "name": "pytest-astropy", + "sha256": "6e3c316e0a34ec72256b7fecfe4762915da154b8a77b4ebb69f36448c53d50a6", + "size": 6969, + "subdir": "linux-64", + "timestamp": 1545121457649, + "version": "0.5.0" + }, + "pytest-astropy-0.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.2.0", + "pytest-openfiles >=0.3.1", + "pytest-remotedata >=0.3.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "fc56b05d28669bfa809fef2cc92cbd03", + "name": "pytest-astropy", + "sha256": "719a483df37d1581cec9bbbddc3ba3c7267631688cabecdf9a63eed3c8f7988f", + "size": 6986, + "subdir": "linux-64", + "timestamp": 1545121456286, + "version": "0.5.0" + }, + "pytest-astropy-0.5.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "pytest-arraydiff >=0.1", + "pytest-doctestplus >=0.2.0", + "pytest-openfiles >=0.3.1", + "pytest-remotedata >=0.3.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "550693dec7f27beaf069855113c72283", + "name": "pytest-astropy", + "sha256": "952d54a7bc8a3c1ba6811f39f264194ae4c44104c87ff786bea53690b784b5ad", + "size": 7126, + "subdir": "linux-64", + "timestamp": 1574087049100, + "version": "0.5.0" + }, + "pytest-asyncio-0.10.0-py36_1000.conda": { + "build": "py36_1000", + "build_number": 1000, + "depends": [ + "pytest >=3.0.6", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "50405cfe0ba2310c79fdb98c1fe1330e", + "name": "pytest-asyncio", + "sha256": "1bdd1f976b973fddd43335cdfd27c9eb26f879e1de78f2b561c5053771a962ac", + "size": 18959, + "subdir": "linux-64", + "timestamp": 1552446372252, + "version": "0.10.0" + }, + "pytest-asyncio-0.10.0-py36h06a4308_1000.conda": { + "build": "py36h06a4308_1000", + "build_number": 1000, + "depends": [ + "pytest >=3.0.6", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "bacea1129af599e6b1603e25df6b3e1e", + "name": "pytest-asyncio", + "sha256": "a614d2205994351f5cb17f5aff35783be3e380c6320bd9107db89dd222847e86", + "size": 19441, + "subdir": "linux-64", + "timestamp": 1611771733694, + "version": "0.10.0" + }, + "pytest-asyncio-0.10.0-py37_1000.conda": { + "build": "py37_1000", + "build_number": 1000, + "depends": [ + "pytest >=3.0.6", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "27e73d050d55bc4c27e83c7b1565976d", + "name": "pytest-asyncio", + "sha256": "38429661769d0eb2e5eb4764f25a6adaed7dad81d00386555927a54f1c22b198", + "size": 19028, + "subdir": "linux-64", + "timestamp": 1552484109533, + "version": "0.10.0" + }, + "pytest-asyncio-0.10.0-py37h06a4308_1000.conda": { + "build": "py37h06a4308_1000", + "build_number": 1000, + "depends": [ + "pytest >=3.0.6", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "5b168e2000455d3c50d70c074d71ea30", + "name": "pytest-asyncio", + "sha256": "3aa09a1a800dcf713e7b86139bfd61de484ab3d34d7913f0a7a830691edb00c3", + "size": 19367, + "subdir": "linux-64", + "timestamp": 1611771728641, + "version": "0.10.0" + }, + "pytest-asyncio-0.10.0-py38_1000.conda": { + "build": "py38_1000", + "build_number": 1000, + "depends": [ + "pytest >=3.0.6", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "69a44e321d6a260212413474c0a90ee2", + "name": "pytest-asyncio", + "sha256": "bf619421950a17d96ad629c20c5175a096cf26d4568d7097056916471ad014a6", + "size": 17664, + "subdir": "linux-64", + "timestamp": 1574170824176, + "version": "0.10.0" + }, + "pytest-asyncio-0.10.0-py38h06a4308_1000.conda": { + "build": "py38h06a4308_1000", + "build_number": 1000, + "depends": [ + "pytest >=3.0.6", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "8f4ae5a6327de1146208716f11740491", + "name": "pytest-asyncio", + "sha256": "717722fdaa5ff90f1dda48d42769dc3b5fb1a602b7dd2cb12906a10b3ec7b212", + "size": 19603, + "subdir": "linux-64", + "timestamp": 1611771714438, + "version": "0.10.0" + }, + "pytest-asyncio-0.10.0-py39h06a4308_1000.conda": { + "build": "py39h06a4308_1000", + "build_number": 1000, + "depends": [ + "pytest >=3.0.6", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "md5": "c9cb0d93658dcaf602d718793a9aebfd", + "name": "pytest-asyncio", + "sha256": "e6e6222e702139ae116af4479878cf8c9c7ee3354377abd22a6bc1e595e062a2", + "size": 19436, + "subdir": "linux-64", + "timestamp": 1611771712435, + "version": "0.10.0" + }, + "pytest-asyncio-0.12.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "bea08d77a97accded5f03b8457d265ed", + "name": "pytest-asyncio", + "sha256": "eb020cfb2b6127199efc6466ae1bb2b47276bb6ce74d9818e4ab8d61a998a37e", + "size": 16994, + "subdir": "linux-64", + "timestamp": 1594394999758, + "version": "0.12.0" + }, + "pytest-asyncio-0.14.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "847e6cba828d7b940ec9b2c25d34d716", + "name": "pytest-asyncio", + "sha256": "e7fac3c7390dfc9b8ff976c4bbfe8d3aa57d01189fbb9ec452bc41066414674d", + "size": 18295, + "subdir": "linux-64", + "timestamp": 1600459011187, + "version": "0.14.0" + }, + "pytest-asyncio-0.14.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "4b1b970a7659f294a4f6e0b19af3bbda", + "name": "pytest-asyncio", + "sha256": "007f4f5ee4b741ddbf9b52cdbb9296ada69af04e8ae2fda1175e471ab08830c7", + "size": 21049, + "subdir": "linux-64", + "timestamp": 1615906731302, + "version": "0.14.0" + }, + "pytest-asyncio-0.14.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "f8c2162ba6dece35d8ebc295cbb360d1", + "name": "pytest-asyncio", + "sha256": "a688b2b9060645b279c5d496c12d05ce2df3d0c2d61474ffba3c61f96982b319", + "size": 18189, + "subdir": "linux-64", + "timestamp": 1600459003842, + "version": "0.14.0" + }, + "pytest-asyncio-0.14.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "35616bf9850f3d6d3d9e932192cc1dd2", + "name": "pytest-asyncio", + "sha256": "87a97d43703735373e97b45d77a6ceb3dc80142ece0ce057fe7d88d23a2c8774", + "size": 21106, + "subdir": "linux-64", + "timestamp": 1615907356691, + "version": "0.14.0" + }, + "pytest-asyncio-0.14.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "37607029f68a4b97bcd6e4d73354b1fa", + "name": "pytest-asyncio", + "sha256": "fac547a3d10c319d35818d39931c7c2d09739cde3e0252eb30689d788f7f780d", + "size": 18295, + "subdir": "linux-64", + "timestamp": 1600459020586, + "version": "0.14.0" + }, + "pytest-asyncio-0.14.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "8b9284582f7b6394caeccb7984fe70b6", + "name": "pytest-asyncio", + "sha256": "58941ea1e2df13218dbcbb78038d96ab966df8b9d5a5ca3995fccea267a76e1c", + "size": 21123, + "subdir": "linux-64", + "timestamp": 1615907374660, + "version": "0.14.0" + }, + "pytest-asyncio-0.14.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "449f74efac4bcc440311c2f1d22da9d9", + "name": "pytest-asyncio", + "sha256": "b75c44f2cd8cab9f99f96fe7ba6f5451464fc7d7e302651fb5fcf0bfd53acbfb", + "size": 21097, + "subdir": "linux-64", + "timestamp": 1615907361396, + "version": "0.14.0" + }, + "pytest-asyncio-0.15.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "c44bb4bb9d4fc6ddf47dacff482be357", + "name": "pytest-asyncio", + "sha256": "72a74900c1f5c8c96f99f65f95d264282f2ca12652ce60fc1cb5be4c6c9831b6", + "size": 18493, + "subdir": "linux-64", + "timestamp": 1618866151102, + "version": "0.15.0" + }, + "pytest-asyncio-0.15.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "4c86d04a71b781921257c4b2ddb66708", + "name": "pytest-asyncio", + "sha256": "5fb9704a8edfddbe18621259f18bb4541bb1fff80bf37c84ddf937177bab7787", + "size": 18506, + "subdir": "linux-64", + "timestamp": 1618869493987, + "version": "0.15.0" + }, + "pytest-asyncio-0.15.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "dbc04c934ef9a2c30c29b2abd6e01c3d", + "name": "pytest-asyncio", + "sha256": "66423548f6b85a63e096634bb1937fad17935770100f3a4faab1d9e2c72e5052", + "size": 18488, + "subdir": "linux-64", + "timestamp": 1618869495577, + "version": "0.15.0" + }, + "pytest-asyncio-0.15.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "0429d485644331a8a1378dd3a3c382b7", + "name": "pytest-asyncio", + "sha256": "8481c239dabe4f2016c9b70ca65de9f910673389e7b7d05f47bd60f60a77efaf", + "size": 18547, + "subdir": "linux-64", + "timestamp": 1618906077120, + "version": "0.15.0" + }, + "pytest-asyncio-0.15.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "7d387b4d3f6220c2a1715221b12dcda6", + "name": "pytest-asyncio", + "sha256": "1a60175e5a500ef062ceaaf7c72933a07c5f83f916d384a0424b1e357e08677a", + "size": 21172, + "subdir": "linux-64", + "timestamp": 1636022743624, + "version": "0.15.1" + }, + "pytest-asyncio-0.15.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "cb7a17665091ae4e8b4d21f1d7dbf755", + "name": "pytest-asyncio", + "sha256": "9dfa24bccf077d0cc6367620ea4bf94020e604141a640a682f29939d8d6f68d6", + "size": 21314, + "subdir": "linux-64", + "timestamp": 1636034750396, + "version": "0.15.1" + }, + "pytest-asyncio-0.15.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "512ebb4e6c46c5d14ccc909dcc42725a", + "name": "pytest-asyncio", + "sha256": "3639fa78f2e3451e20f5cb2cbc6527f1ae0f9438c99f9f079bc7b6e72b109b65", + "size": 18590, + "subdir": "linux-64", + "timestamp": 1619450354361, + "version": "0.15.1" + }, + "pytest-asyncio-0.15.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "pytest >=5.4", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "bc711cc0c44e2226cb6df06bce32cec7", + "name": "pytest-asyncio", + "sha256": "94b6e5d01795c3d44950ad577becf2e0df4aca3fa9d47bc25fe7f74c0116895d", + "size": 18559, + "subdir": "linux-64", + "timestamp": 1619305790747, + "version": "0.15.1" + }, + "pytest-asyncio-0.16.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.4.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "98065e6408caceef395bc3545c8120c4", + "name": "pytest-asyncio", + "sha256": "ed0ff9b80123c605f5fd79b0f06369572451ca2e76805fb2888f0e99de97f064", + "size": 18666, + "subdir": "linux-64", + "timestamp": 1640810521926, + "version": "0.16.0" + }, + "pytest-asyncio-0.16.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "25b0b447a993b476bb0a6c7338fae196", + "name": "pytest-asyncio", + "sha256": "e91fdfad4f9b4dc5978132748ac4dbf2d17453a9038c41de86aec97a2b3b6eef", + "size": 18162, + "subdir": "linux-64", + "timestamp": 1639142045279, + "version": "0.16.0" + }, + "pytest-asyncio-0.16.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "856d80d37349230b730c6c0739b87a27", + "name": "pytest-asyncio", + "sha256": "9af39cd6527ac5788ffbc1fcbbb5181ad57b67eacec1059d4e27d63cc47cb9b6", + "size": 18393, + "subdir": "linux-64", + "timestamp": 1639128465875, + "version": "0.16.0" + }, + "pytest-asyncio-0.16.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d8f4351c1b8d2e20a748060f83354f0d", + "name": "pytest-asyncio", + "sha256": "bd79471ac6adce532e12c529ef574f7ba9fe95ac372889e2907e3668a62e3171", + "size": 18333, + "subdir": "linux-64", + "timestamp": 1639142045175, + "version": "0.16.0" + }, + "pytest-asyncio-0.20.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=6.1.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2e6327a42da69a913eaf6b197e7ffe4c", + "name": "pytest-asyncio", + "sha256": "7bf5796c7b054119c796e7162b0bcf3c16fb023918eead30c303ba1658a81149", + "size": 31694, + "subdir": "linux-64", + "timestamp": 1678971540265, + "version": "0.20.3" + }, + "pytest-asyncio-0.20.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=6.1.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "af227183ff340a79f5b24badbcff3ad2", + "name": "pytest-asyncio", + "sha256": "23af1949ff9f8636ec18e2172d7197d1c8c2893a62037e4be3b422317b6a34ff", + "size": 36250, + "subdir": "linux-64", + "timestamp": 1678971465456, + "version": "0.20.3" + }, + "pytest-asyncio-0.20.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=6.1.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "56303541f37a982eb23722e462233dd5", + "name": "pytest-asyncio", + "sha256": "4815f6f37f291c6fe1f5077a2e45ed61dd906e79ef0ac404c4f67cded4aa1be5", + "size": 31480, + "subdir": "linux-64", + "timestamp": 1678971574105, + "version": "0.20.3" + }, + "pytest-asyncio-0.20.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=6.1.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e3edbd8ee0f13b97bf5880ee3391ef57", + "name": "pytest-asyncio", + "sha256": "8f7bfdd3b10de8507aeef8942e9e71f3d73496e7621b9d9737c65ebfd1cacb05", + "size": 31474, + "subdir": "linux-64", + "timestamp": 1678971506328, + "version": "0.20.3" + }, + "pytest-asyncio-0.8.0-py35hf603743_0.conda": { + "build": "py35hf603743_0", + "build_number": 0, + "depends": [ + "pytest >=3.0.2", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "0452ea88ff40e43d5ec8804c97820c02", + "name": "pytest-asyncio", + "sha256": "94226467546806fe6413cda74143fb010ba51d6554618dd693249c316be77db2", + "size": 12841, + "subdir": "linux-64", + "timestamp": 1511935956324, + "version": "0.8.0" + }, + "pytest-asyncio-0.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "67a4fe1845771a06ad1bd07bb6ff75b5", + "name": "pytest-asyncio", + "sha256": "45078599973e3959c0b0cc67758b9193a468fed5ae90e2eeb749bbb167c9b4bb", + "size": 12444, + "subdir": "linux-64", + "timestamp": 1530922150927, + "version": "0.8.0" + }, + "pytest-asyncio-0.8.0-py36h0795122_0.conda": { + "build": "py36h0795122_0", + "build_number": 0, + "depends": [ + "pytest >=3.0.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "b9b78f002e2822153b884a55d9844733", + "name": "pytest-asyncio", + "sha256": "e339aa58554b29c662eb56103cb5ec4fdf2ed78bf25569e8e4a0bf42279a3a48", + "size": 12682, + "subdir": "linux-64", + "timestamp": 1511935966543, + "version": "0.8.0" + }, + "pytest-asyncio-0.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.0.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "e8ab44544263bbd90193c057e47e86e5", + "name": "pytest-asyncio", + "sha256": "fe2f9ecf378c4142ed2ef61b9aeb86be2bdf286a8fd22f63375eea5c7e28a678", + "size": 12368, + "subdir": "linux-64", + "timestamp": 1530922185325, + "version": "0.8.0" + }, + "pytest-asyncio-0.9.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0.2", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "0cd4289e16d914e0e3dd2ae7f8c4bf85", + "name": "pytest-asyncio", + "sha256": "1357bfeb2136fcbf15c81fff7190284512c64ec5895cb1eb6057445ee8b411d6", + "size": 12389, + "subdir": "linux-64", + "timestamp": 1535420686082, + "version": "0.9.0" + }, + "pytest-asyncio-0.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "c97597831fe8dd9400671f8b8023896b", + "name": "pytest-asyncio", + "sha256": "d3fa4d0ee00e8a1bed37e89d0353677808bc29d4a27223ac8a4677542e660edc", + "size": 12413, + "subdir": "linux-64", + "timestamp": 1535420548813, + "version": "0.9.0" + }, + "pytest-asyncio-0.9.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.0.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "6b10501cbe29f0a0efedc20510b3059d", + "name": "pytest-asyncio", + "sha256": "1274571daf2f802339400e12e11a023dff50ae684d8d564708cc7c65344381b3", + "size": 12352, + "subdir": "linux-64", + "timestamp": 1535420687113, + "version": "0.9.0" + }, + "pytest-base-url-1.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=2.7,<2.8.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "660f32e75cfc1a6cc5fa9c809bcd6eda", + "name": "pytest-base-url", + "sha256": "7f47e4fb5579b1129ed6a5acbbb244b22a3947855a3a9bfc6b04647d04246fb0", + "size": 8855, + "subdir": "linux-64", + "timestamp": 1518721311536, + "version": "1.4.1" + }, + "pytest-base-url-1.4.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.10,<3.11.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "ef4f172553d65dcb3bccd571e9174e8f", + "name": "pytest-base-url", + "sha256": "2490b52731fa7b4d22e604f14e6288b540e9afa12f48a8148af34c4706a09254", + "size": 8826, + "subdir": "linux-64", + "timestamp": 1640810544887, + "version": "1.4.1" + }, + "pytest-base-url-1.4.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.11,<3.12.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "3190de71b84c83891b6e09ff8c2621dc", + "name": "pytest-base-url", + "sha256": "7b2ac506d767a6b631e895735a6fb76222bb6164b46c5d9ec05729c80c1bcf9b", + "size": 9848, + "subdir": "linux-64", + "timestamp": 1676861320804, + "version": "1.4.1" + }, + "pytest-base-url-1.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.5,<3.6.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "7cc3017d042be55ebba3ed7486849ccd", + "name": "pytest-base-url", + "sha256": "12a24ca0a2d2761f4914647acee7ad03514c8e47075726bdf22ec8612d460ba1", + "size": 8844, + "subdir": "linux-64", + "timestamp": 1518721383768, + "version": "1.4.1" + }, + "pytest-base-url-1.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.6,<3.7.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "ffe1bbee846833271ad8a303340c3618", + "name": "pytest-base-url", + "sha256": "568478a8af8e5987a0090d1facd953d9cc04c41ebd822f4e7189ee77e8af367d", + "size": 8772, + "subdir": "linux-64", + "timestamp": 1518721354470, + "version": "1.4.1" + }, + "pytest-base-url-1.4.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.6,<3.7.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "e89e97dc5561c2899ca3e044e26670c0", + "name": "pytest-base-url", + "sha256": "a0ec082bf61e58f9d96fcdf9b054497372d32ee742b3f0352d843a58d7f6b4f1", + "size": 9616, + "subdir": "linux-64", + "timestamp": 1611771713539, + "version": "1.4.1" + }, + "pytest-base-url-1.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.7,<3.8.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "0e66a3ecfc9d0182c38aae716b3f7b62", + "name": "pytest-base-url", + "sha256": "63ff1808aef1938076d2f88cb9a6c9e97eedd8fc018239b93be1de5373f5bc4a", + "size": 8672, + "subdir": "linux-64", + "timestamp": 1530922225036, + "version": "1.4.1" + }, + "pytest-base-url-1.4.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.7,<3.8.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "6f2e43abbb93cfceec948e78e9a40689", + "name": "pytest-base-url", + "sha256": "6f3d19d72cfc8cf3ba30d1eb89b48853e7e3cbcebc1e2adee3df363327df7675", + "size": 9585, + "subdir": "linux-64", + "timestamp": 1611771691013, + "version": "1.4.1" + }, + "pytest-base-url-1.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.8,<3.9.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "f04ed01189d4002545f24b0d04980452", + "name": "pytest-base-url", + "sha256": "a6d2ce3ab99d7205ad8b5e66133c3dfc9cc7a728dd32beb1e147c587b6e0446d", + "size": 9569, + "subdir": "linux-64", + "timestamp": 1611771698083, + "version": "1.4.1" + }, + "pytest-base-url-1.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.9,<3.10.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "e4965bd3d3a2c46e9ea6c99ec50a0d4a", + "name": "pytest-base-url", + "sha256": "8d7095945565bb10417cc72d902f8892b55caf47bc0a1fd32601cf2f59e0c562", + "size": 9642, + "subdir": "linux-64", + "timestamp": 1611771516002, + "version": "1.4.1" + }, + "pytest-base-url-1.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.6,<3.7.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "f1a6710111a117acad686daf6a1eba90", + "name": "pytest-base-url", + "sha256": "b12096ee8d98011ca976b9d68fb109bab5226a126e3fa88dfdca2e134db92863", + "size": 9109, + "subdir": "linux-64", + "timestamp": 1600459068054, + "version": "1.4.2" + }, + "pytest-base-url-1.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.7,<3.8.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "c115826d6a3478787bcd206310f98508", + "name": "pytest-base-url", + "sha256": "4914bc1dc3f3bf2aa30a24c12b6181db9f6f199db1b2c57d50fc899094489262", + "size": 9030, + "subdir": "linux-64", + "timestamp": 1600459088608, + "version": "1.4.2" + }, + "pytest-base-url-1.4.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=2.7.3", + "python >=3.8,<3.9.0a0", + "requests >=2.9", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "2c92c5f2e482e635eb3654ba369c9868", + "name": "pytest-base-url", + "sha256": "8c890bbe83eddf89e109b1a0986f551573e2b60a97dd847c3c790db132252e18", + "size": 9057, + "subdir": "linux-64", + "timestamp": 1600459086650, + "version": "1.4.2" + }, + "pytest-benchmark-3.0.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pytest >=2.6", + "python >=2.7,<2.8.0a0", + "setuptools", + "statistics" + ], + "license": "BSD 2-clause", + "md5": "6dfc4026ba8010ba7e9dd2ec5a3c82eb", + "name": "pytest-benchmark", + "sha256": "c23e05386edf77a8a7603491d3ac19ec1b053610be6a240ba209f3f847e6db6d", + "size": 56326, + "subdir": "linux-64", + "timestamp": 1520379176944, + "version": "3.0.0" + }, + "pytest-benchmark-3.0.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "pytest >=2.6", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "fe1e85972066689bf40c8e9439aa3e77", + "name": "pytest-benchmark", + "sha256": "bf28c5b77eb6779444c786986a3cdb11d88e32b1ec382b52ca5749ce08c01fbc", + "size": 56772, + "subdir": "linux-64", + "timestamp": 1520379062555, + "version": "3.0.0" + }, + "pytest-benchmark-3.0.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pytest >=2.6", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 2-clause", + "md5": "0649c2eaeb6854757cb9b63ff043e1f8", + "name": "pytest-benchmark", + "sha256": "2dd428c15e41070f1b85177e1f0b15dc38f1ed6c4875aeb95618be55a79b5f10", + "size": 55997, + "subdir": "linux-64", + "timestamp": 1520379009424, + "version": "3.0.0" + }, + "pytest-benchmark-3.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pathlib", + "py-cpuinfo", + "pytest >=2.8", + "python >=2.7,<2.8.0a0", + "statistics" + ], + "license": "BSD 2-clause", + "md5": "cf817c8df06e7738cb9af8d4f95ccb44", + "name": "pytest-benchmark", + "sha256": "4cc6e656b58eaa26f48c3c7ba5ad9fc6685568e7fe5cfdc49bde6d8a7e9790fa", + "size": 82485, + "subdir": "linux-64", + "timestamp": 1529239379383, + "version": "3.1.1" + }, + "pytest-benchmark-3.1.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pathlib2", + "py-cpuinfo", + "pytest >=2.8", + "python >=2.7,<2.8.0a0", + "statistics" + ], + "license": "BSD 2-clause", + "md5": "3920e17c14a8cd0b9ab67c40ec50877d", + "name": "pytest-benchmark", + "sha256": "0b09b2e285f11501e4b3128f277ea7f6b772b1a097cd1a7f811ba820ded87dfb", + "size": 81026, + "subdir": "linux-64", + "timestamp": 1530872939605, + "version": "3.1.1" + }, + "pytest-benchmark-3.1.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=2.8", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-clause", + "md5": "5b75bea0a54dda59e3471d3ddd7c07c2", + "name": "pytest-benchmark", + "sha256": "f7f42c6483f7442c9a096995d32f0a03766a305f502062fa3918ab28d5135507", + "size": 82661, + "subdir": "linux-64", + "timestamp": 1529239336385, + "version": "3.1.1" + }, + "pytest-benchmark-3.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=2.8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "md5": "7803dacdf44e1b719e05084e832bc750", + "name": "pytest-benchmark", + "sha256": "9aaf951f129ec4095061a3470a7bf3e06e3cee7ff56b0eff3ceed36db566dc08", + "size": 81683, + "subdir": "linux-64", + "timestamp": 1529238997287, + "version": "3.1.1" + }, + "pytest-benchmark-3.1.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "py-cpuinfo", + "pytest >=2.8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "md5": "fa91a8f226ddbed31225669026b3d6b5", + "name": "pytest-benchmark", + "sha256": "dfa7695a20c0cd41f1f2482e6a8adfc7974ce3cfc792372e97a2fd4da9500690", + "size": 81827, + "subdir": "linux-64", + "timestamp": 1530872995515, + "version": "3.1.1" + }, + "pytest-benchmark-3.1.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "py-cpuinfo", + "pytest >=2.8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "md5": "273ac905073a69dfb6207d979fe97276", + "name": "pytest-benchmark", + "sha256": "f4980bc03158d9f58af4e6f9ee6923c78902cb604eebe8afff1e0477c2901042", + "size": 80990, + "subdir": "linux-64", + "timestamp": 1530872968150, + "version": "3.1.1" + }, + "pytest-benchmark-3.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pathlib2", + "py-cpuinfo", + "pytest >=2.8", + "python >=2.7,<2.8.0a0", + "statistics" + ], + "license": "BSD 2-clause", + "md5": "63546ace4708e6288da61009a6f27e1b", + "name": "pytest-benchmark", + "sha256": "1e7dbc466445179e000ff0e0d6d22bb3caf48be927647fa6677cd2741323da81", + "size": 84267, + "subdir": "linux-64", + "timestamp": 1547477048996, + "version": "3.2.0" + }, + "pytest-benchmark-3.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=2.8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "md5": "955e54d1f25847913a45815d919585ae", + "name": "pytest-benchmark", + "sha256": "7ebfbb0d15993aa47c3214956c9afad2e0cd7dd91566d660d00371fe125cefc7", + "size": 84031, + "subdir": "linux-64", + "timestamp": 1547477111459, + "version": "3.2.0" + }, + "pytest-benchmark-3.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=2.8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "md5": "59a3a2bf80e914d2d5f546f1204c9723", + "name": "pytest-benchmark", + "sha256": "ed472ea20ab5a8f4ba8fb69d9a342e5f3a2dd2de1f16917ca1575263ba6b2e54", + "size": 83357, + "subdir": "linux-64", + "timestamp": 1547477101955, + "version": "3.2.0" + }, + "pytest-benchmark-3.2.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pathlib2", + "py-cpuinfo", + "pytest >=3.8", + "python >=2.7,<2.8.0a0", + "statistics" + ], + "license": "BSD 2-clause", + "md5": "e9eae7e199e5ba1915bc6a4127f6d780", + "name": "pytest-benchmark", + "sha256": "be453de38f332ed59f3176a1ce61621da5bd4a40d073a46bc38dad292424dc18", + "size": 84048, + "subdir": "linux-64", + "timestamp": 1552446310136, + "version": "3.2.2" + }, + "pytest-benchmark-3.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "md5": "d88f7a47a5f94bb91a8969faf51e0fa0", + "name": "pytest-benchmark", + "sha256": "5b12177fde744826f55ffbbc68331a7e14265e5fd8bcf342072dbed5b06db54d", + "size": 84053, + "subdir": "linux-64", + "timestamp": 1552447020204, + "version": "3.2.2" + }, + "pytest-benchmark-3.2.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "md5": "36629125356d192e14af136d0afc2f57", + "name": "pytest-benchmark", + "sha256": "3aa356d9aedb37302af0894ffeb7af2b8e4576396bcf6ed9a93628d48be222e9", + "size": 84278, + "subdir": "linux-64", + "timestamp": 1613163826741, + "version": "3.2.2" + }, + "pytest-benchmark-3.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "md5": "4cd36a1faaa3f0956d2e22f10d4ee8c7", + "name": "pytest-benchmark", + "sha256": "d60ab05748acacd0a18418456eca8fb025379019b2bb487b5d30014a57d9b0e1", + "size": 84052, + "subdir": "linux-64", + "timestamp": 1552446952890, + "version": "3.2.2" + }, + "pytest-benchmark-3.2.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "md5": "deb62df3266d5767bd5cc004efd59587", + "name": "pytest-benchmark", + "sha256": "61a8ac3ad1607f031f03a5e40aaf3456cf832e962bd730e6546138e3fa294609", + "size": 84853, + "subdir": "linux-64", + "timestamp": 1613164612005, + "version": "3.2.2" + }, + "pytest-benchmark-3.2.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-clause", + "md5": "1632e8825b4865e39d717a807f82611e", + "name": "pytest-benchmark", + "sha256": "f3f6c87ee3f069bcae13d1c261cb8189a0c66b53e9a7cd22e55288201c96997b", + "size": 84335, + "subdir": "linux-64", + "timestamp": 1574170838070, + "version": "3.2.2" + }, + "pytest-benchmark-3.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-clause", + "md5": "737bb49152b30cd9e5c8a53349b96f23", + "name": "pytest-benchmark", + "sha256": "12519dd4d27b8b62386b6f03008484853d38d0ffdfd4f7dc5bb58d27de72d766", + "size": 84753, + "subdir": "linux-64", + "timestamp": 1613163829403, + "version": "3.2.2" + }, + "pytest-benchmark-3.2.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-clause", + "md5": "05f10cdabf505244ba5331c65d984e32", + "name": "pytest-benchmark", + "sha256": "2ffc66bb6d0aabdafa6c28aa13671024de868ebd91231b84dada4ecf5ca663ce", + "size": 84576, + "subdir": "linux-64", + "timestamp": 1613164615523, + "version": "3.2.2" + }, + "pytest-benchmark-3.2.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "md5": "551ad65c0be170e3a12d9f37a51c31a4", + "name": "pytest-benchmark", + "sha256": "66c272569accfc5cc709e45a874f590f9fab49cb928dde4d27498b5aa632a61f", + "size": 83454, + "subdir": "linux-64", + "timestamp": 1600459127589, + "version": "3.2.3" + }, + "pytest-benchmark-3.2.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "md5": "5435a0f677d57ae821f2e98a5bf75b4e", + "name": "pytest-benchmark", + "sha256": "109b72ccca2fb8ed177e3728c13b89d04b2143157dd3b778a11e8064333f6c22", + "size": 83364, + "subdir": "linux-64", + "timestamp": 1600459121140, + "version": "3.2.3" + }, + "pytest-benchmark-3.2.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-clause", + "md5": "019ed5f6e2f3a2a5bc858f9b99243f8b", + "name": "pytest-benchmark", + "sha256": "0dc99b25ebce848a912635c8a10fb80c743e9e9d7dcdc6a3d2bb7cc448d1b28e", + "size": 84940, + "subdir": "linux-64", + "timestamp": 1600459127947, + "version": "3.2.3" + }, + "pytest-benchmark-3.4.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 2-clause", + "md5": "1fbbcb38c53a7057b3e406f6fcd1a021", + "name": "pytest-benchmark", + "sha256": "a9a5be22db09cc8f6baae4f21ec9e10b6bc4f5c407118682c53047c69d9802d2", + "size": 86269, + "subdir": "linux-64", + "timestamp": 1640810563931, + "version": "3.4.1" + }, + "pytest-benchmark-3.4.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "03311b0a4ec8c407b4b76b9daff02546", + "name": "pytest-benchmark", + "sha256": "75d0ffa460ab9fb412fd8ffacfff92f452ef7fe870459963dae6c981789e978f", + "size": 87526, + "subdir": "linux-64", + "timestamp": 1651851675841, + "version": "3.4.1" + }, + "pytest-benchmark-3.4.1-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "508415664e9695ad9f5979769f5d330e", + "name": "pytest-benchmark", + "sha256": "dda3f0b53701e010433b8af2be14a3c1e0554dc1a246b756d9895e9d9e5c5a76", + "size": 117070, + "subdir": "linux-64", + "timestamp": 1676861334935, + "version": "3.4.1" + }, + "pytest-benchmark-3.4.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-clause", + "md5": "8afa803ca844bd50a198a8dac42db490", + "name": "pytest-benchmark", + "sha256": "07c293c9374a194d3f13a41a5da29e9e368072891de88797c7a23fd2200eb59c", + "size": 85481, + "subdir": "linux-64", + "timestamp": 1618692374755, + "version": "3.4.1" + }, + "pytest-benchmark-3.4.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-clause", + "md5": "be5f1f37ec5c2ee5b3e0633a979e3b52", + "name": "pytest-benchmark", + "sha256": "f76d1eaa0832be4f3f314f2db8162667af4a92591d7deaf1ed5caa9aede91a2d", + "size": 85450, + "subdir": "linux-64", + "timestamp": 1618695618616, + "version": "3.4.1" + }, + "pytest-benchmark-3.4.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "caf4c1250c80687de82bd59660aedd8d", + "name": "pytest-benchmark", + "sha256": "da6121e1103f34365fa4d0370959ca4d005ad99311dd2c6d5993dc4befc18c02", + "size": 86980, + "subdir": "linux-64", + "timestamp": 1651851663674, + "version": "3.4.1" + }, + "pytest-benchmark-3.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-clause", + "md5": "5560bb98ee64ebcbb885ca456c71eb5b", + "name": "pytest-benchmark", + "sha256": "a1b6c1270319bb820d7759dcdaa43db72bdabcd2d8f03c1b068082095e19e33b", + "size": 85135, + "subdir": "linux-64", + "timestamp": 1618695628820, + "version": "3.4.1" + }, + "pytest-benchmark-3.4.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "3d34796a979d733c23237b6491c5d710", + "name": "pytest-benchmark", + "sha256": "ff49896b44f25846d57ac1713da9d33b9d095f36b1178f0d11443f96cd0ef9b0", + "size": 87611, + "subdir": "linux-64", + "timestamp": 1651833815272, + "version": "3.4.1" + }, + "pytest-benchmark-3.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-clause", + "md5": "9ad85aeca8ac65a989dcad9e04a3906f", + "name": "pytest-benchmark", + "sha256": "74011f31af489123e3b95d39b90e2f203e8f6d2e8447790f46116961922f46b8", + "size": 85101, + "subdir": "linux-64", + "timestamp": 1618798834629, + "version": "3.4.1" + }, + "pytest-benchmark-3.4.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "py-cpuinfo", + "pytest >=3.8", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d8be4f64e1128336ea0a5db31c1e03a0", + "name": "pytest-benchmark", + "sha256": "0585aaa96b176493e77c16d6ba6b4168147bcd42cf00aee2aad36de7a239403c", + "size": 87348, + "subdir": "linux-64", + "timestamp": 1651851663504, + "version": "3.4.1" + }, + "pytest-cache-1.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "execnet >=1.1.dev1", + "pytest >=2.2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "963c7c5ea0e7251361d23c211ac964dc", + "name": "pytest-cache", + "sha256": "1e41b103fb1321ec0c6a73bdabc4a1844bf94774a91345b26324ac373868aa34", + "size": 13514, + "subdir": "linux-64", + "timestamp": 1537811930920, + "version": "1.0" + }, + "pytest-cache-1.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "execnet >=1.1.dev1", + "pytest >=2.2", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "1cfb2a8ddaefd05b1e97f9fa2b7cc45f", + "name": "pytest-cache", + "sha256": "815e2029c259731ea017aef561d942ba235f79595391b957e1cb96ad66f42a0f", + "size": 13809, + "subdir": "linux-64", + "timestamp": 1537811954796, + "version": "1.0" + }, + "pytest-cache-1.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "execnet >=1.1.dev1", + "pytest >=2.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "259f88d7ca07c9af08d28357e13a8ee2", + "name": "pytest-cache", + "sha256": "18e06c2ac5b07691c2bdb30e7258b2b3ea45fbc4cb46d1f617af66a78a231888", + "size": 13591, + "subdir": "linux-64", + "timestamp": 1537811978772, + "version": "1.0" + }, + "pytest-cache-1.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "execnet >=1.1.dev1", + "pytest >=2.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "21a5d545d08df7524c7b9387d3aa8f27", + "name": "pytest-cache", + "sha256": "ba879d4bfff68ae32df6052e514312cf9f4a9b327bc6530c2482ec535823fbbd", + "size": 13622, + "subdir": "linux-64", + "timestamp": 1537811889325, + "version": "1.0" + }, + "pytest-cov-2.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "03d99247be4572ab401c780954e165fd", + "name": "pytest-cov", + "sha256": "485c91d12418f0b191b93cc2177c8815ee7fb26e816b96cf18fd77b6f05bd253", + "size": 26016, + "subdir": "linux-64", + "timestamp": 1530694080682, + "version": "2.5.1" + }, + "pytest-cov-2.5.1-py27hc4181bb_0.conda": { + "build": "py27hc4181bb_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15600e32c0b9c939f3d040a3a51a58f1", + "name": "pytest-cov", + "sha256": "319f0a6d003b252dd0a92c67fc55de636bec3dfe718050974dac18a3e8cce367", + "size": 25753, + "subdir": "linux-64", + "timestamp": 1505752481977, + "version": "2.5.1" + }, + "pytest-cov-2.5.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e429cc290c74809614290b1cf467c6cd", + "name": "pytest-cov", + "sha256": "6f686ed5c64d8c7a645b80177a2f6f7335c4476954947a824a65a3c2ca8ce89d", + "size": 26352, + "subdir": "linux-64", + "timestamp": 1534345098490, + "version": "2.5.1" + }, + "pytest-cov-2.5.1-py35h9d7ae03_0.conda": { + "build": "py35h9d7ae03_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1108b231107caed724ed6517cb09cda0", + "name": "pytest-cov", + "sha256": "a262101e9a27e2153795629270ea88a899db4dcba2e1146e10327e19bfb6acdb", + "size": 26069, + "subdir": "linux-64", + "timestamp": 1505752495777, + "version": "2.5.1" + }, + "pytest-cov-2.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "865e337ec47ee9a775aed4682410fca5", + "name": "pytest-cov", + "sha256": "4b393b1d6e5f8e5cea2a02eb1e7b5c1d952a5f8e5c81f479005e721b48a60f14", + "size": 26158, + "subdir": "linux-64", + "timestamp": 1530694040525, + "version": "2.5.1" + }, + "pytest-cov-2.5.1-py36hd4733f3_0.conda": { + "build": "py36hd4733f3_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e85a9188a6a5e51f96d8d3c2a18d3a56", + "name": "pytest-cov", + "sha256": "7a8326deca23973d6b6f5fc0af9421766f9a5f1de7f100b8c8816420969d7b27", + "size": 25786, + "subdir": "linux-64", + "timestamp": 1505752509617, + "version": "2.5.1" + }, + "pytest-cov-2.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0bcbac451728114059cac1dde3b2771c", + "name": "pytest-cov", + "sha256": "cd4da565f2d173239d22ee95e01568e79f30610e9a89801070ec26e0df8e3686", + "size": 26084, + "subdir": "linux-64", + "timestamp": 1530694060426, + "version": "2.5.1" + }, + "pytest-cov-2.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2cce4ae25406a74268e7db2b4783dcce", + "name": "pytest-cov", + "sha256": "d71ed04a1f575adf9de2f196d1e202c0de4c7c36f41541bd993c69849be60529", + "size": 25683, + "subdir": "linux-64", + "timestamp": 1536102753293, + "version": "2.6.0" + }, + "pytest-cov-2.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63dda1032ec507271da28f4a657c3ab9", + "name": "pytest-cov", + "sha256": "934197ae550a3e4a96c0c06f33000bf2911114882874ea829ed478d76a09e3de", + "size": 26234, + "subdir": "linux-64", + "timestamp": 1536102780247, + "version": "2.6.0" + }, + "pytest-cov-2.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc0924bbee68563088692724b6b7ff76", + "name": "pytest-cov", + "sha256": "826399eadd1fa27515248b5475bd4a7d14a01dea7740e9910e0269f29f4bc90c", + "size": 25906, + "subdir": "linux-64", + "timestamp": 1536102703276, + "version": "2.6.0" + }, + "pytest-cov-2.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "011802235cf39917f4bdf38b915abcd1", + "name": "pytest-cov", + "sha256": "ff6c13fdaec9d911d83eb6678d7c43f7fd7dde590ad6c180c2ef66bfa512c5a2", + "size": 25851, + "subdir": "linux-64", + "timestamp": 1536102787775, + "version": "2.6.0" + }, + "pytest-cov-2.6.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "20064a165c8efd468c8c92e1a2a523cf", + "name": "pytest-cov", + "sha256": "e42ce00bb3a2d7c8295718d95154052dfd6c36124c884a1637bae0b7d439869b", + "size": 30357, + "subdir": "linux-64", + "timestamp": 1547477633871, + "version": "2.6.1" + }, + "pytest-cov-2.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eab28009f41a0c949b936e936ff74e13", + "name": "pytest-cov", + "sha256": "00e3acfaf7f35aebf8f59f07c2b17b8326237471fea170d1c87fab4da2906497", + "size": 30306, + "subdir": "linux-64", + "timestamp": 1547477636508, + "version": "2.6.1" + }, + "pytest-cov-2.6.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "coverage", + "pytest", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bee025c734a2a3a70af219f3b01b5d0e", + "name": "pytest-cov", + "sha256": "190012ffaff4319949f02afdc8f0169c9fb77bdec9fb39214fb352fd3b222994", + "size": 30229, + "subdir": "linux-64", + "timestamp": 1547477674715, + "version": "2.6.1" + }, + "pytest-cov-4.0.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "coverage >=5.2.1", + "pytest >=4.6", + "python >=3.10,<3.11.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f575a4d25c8cb6437ce2dcc1c71835b", + "name": "pytest-cov", + "sha256": "c1329c5a34c97ab664dd5697cc891515a43ee78bf3880aed5e0f3b3c5137669b", + "size": 36714, + "subdir": "linux-64", + "timestamp": 1680092847221, + "version": "4.0.0" + }, + "pytest-cov-4.0.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "coverage >=5.2.1", + "pytest >=4.6", + "python >=3.11,<3.12.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2babbfc80f23f5c920bc6113997a3626", + "name": "pytest-cov", + "sha256": "6e7d4641058d813dc985d1e88414fd5e8a04768eda38f48f5f976b38795bfc25", + "size": 44454, + "subdir": "linux-64", + "timestamp": 1680092789858, + "version": "4.0.0" + }, + "pytest-cov-4.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "coverage >=5.2.1", + "pytest >=4.6", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "54035e39255f285f98ca1141b7f098e7", + "name": "pytest-cov", + "sha256": "4b70bda354c31bd405625f00eb94c831c96530ac8e4bff3ef3c589cf9d684973", + "size": 36575, + "subdir": "linux-64", + "timestamp": 1680092760933, + "version": "4.0.0" + }, + "pytest-cov-4.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "coverage >=5.2.1", + "pytest >=4.6", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a865bb1ddf63d022f68aeaa9773d0296", + "name": "pytest-cov", + "sha256": "730e6f41c2ac10cb8675a936241953fc06371a7e5fb260fa5144d175484844d3", + "size": 36570, + "subdir": "linux-64", + "timestamp": 1680092818162, + "version": "4.0.0" + }, + "pytest-describe-2.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=4.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5cb9bbd8bf5dd947f07848495836f8e2", + "name": "pytest-describe", + "sha256": "2d98283725ed97a269204531cc984b3125cc942d77b1e8b4ec9a51ac6c8429ad", + "size": 15368, + "subdir": "linux-64", + "timestamp": 1669142581329, + "version": "2.0.1" + }, + "pytest-describe-2.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=4.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9cbf0067a840d18e66bd4b6e878b7860", + "name": "pytest-describe", + "sha256": "b84eb804a03eadc11a287db2e97a0a2b897d4484a7adc893abefafabf8003820", + "size": 16476, + "subdir": "linux-64", + "timestamp": 1676861351275, + "version": "2.0.1" + }, + "pytest-describe-2.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e3dda79e0d4b1e922853e7f1cbab872", + "name": "pytest-describe", + "sha256": "a984bedd9057909cc9599e376fa9b02b9ae655929b7b203517dc0ad1b4ceb453", + "size": 15219, + "subdir": "linux-64", + "timestamp": 1669142636846, + "version": "2.0.1" + }, + "pytest-describe-2.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e22f4360fd907c79d7c4049723ca06f", + "name": "pytest-describe", + "sha256": "223f7867fb9e32e1a95e79ce0446a70359290312d94f54e943476be59d7b4552", + "size": 15295, + "subdir": "linux-64", + "timestamp": 1669142609023, + "version": "2.0.1" + }, + "pytest-describe-2.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=4.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e9b229cd955973c9eba8755cf9301be", + "name": "pytest-describe", + "sha256": "7188f70ac80135647232b79ed3d6210fecc75e3292c9c043bf1e23b8399538a1", + "size": 15292, + "subdir": "linux-64", + "timestamp": 1669142664717, + "version": "2.0.1" + }, + "pytest-doctestplus-0.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.8", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "8ae823b126287c739fb0a6acd41ca400", + "name": "pytest-doctestplus", + "sha256": "bf408c136f7ae997e6a0341161fbc72b1c38a2e5fe9d5669db807ceaab99e7f4", + "size": 20123, + "subdir": "linux-64", + "timestamp": 1518731379551, + "version": "0.1.2" + }, + "pytest-doctestplus-0.1.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.8", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD", + "md5": "fcdfaec071b854aaef485d46d2086a34", + "name": "pytest-doctestplus", + "sha256": "32ed3b632c7c56bbcafeb8fa03b3bb7fdd3e32556b5ea81a3a204c099a3e8f22", + "size": 20425, + "subdir": "linux-64", + "timestamp": 1518731403282, + "version": "0.1.2" + }, + "pytest-doctestplus-0.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.8", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "cfa80bcc56c13fe58f32442a1e90e38a", + "name": "pytest-doctestplus", + "sha256": "faf54d835b73065a859b71c484da37631ae713b55705b72511f7495224f620a5", + "size": 20109, + "subdir": "linux-64", + "timestamp": 1518731401037, + "version": "0.1.2" + }, + "pytest-doctestplus-0.1.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "e957c2d88bddcb2506d581cca45ff658", + "name": "pytest-doctestplus", + "sha256": "c192ae1f6f3aecf7bcbc638c0c2520f42db2b0799cca09980910f9a8cacaf643", + "size": 20301, + "subdir": "linux-64", + "timestamp": 1524577919992, + "version": "0.1.3" + }, + "pytest-doctestplus-0.1.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD", + "md5": "8539141590ecc0650ce8592fec31815b", + "name": "pytest-doctestplus", + "sha256": "324729517a4b201a1d3bd431d349f08eabb326996d9517230ae2c8ce58dd939b", + "size": 20325, + "subdir": "linux-64", + "timestamp": 1524577975550, + "version": "0.1.3" + }, + "pytest-doctestplus-0.1.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "832bb3631ec47aca7756f9055f5d6e92", + "name": "pytest-doctestplus", + "sha256": "b502b260db866fcc4dfbb320344efa3a00c002e21b32a877529e0aeadff8aaaf", + "size": 20305, + "subdir": "linux-64", + "timestamp": 1524577923044, + "version": "0.1.3" + }, + "pytest-doctestplus-0.1.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD", + "md5": "d1f7139316a0af5a0ea14935a5789930", + "name": "pytest-doctestplus", + "sha256": "9433e18ef758cccdd1a0aa8bb56f0104777c3426ff56aafb16ab3a14d01d66e3", + "size": 20087, + "subdir": "linux-64", + "timestamp": 1530738047938, + "version": "0.1.3" + }, + "pytest-doctestplus-0.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "ac943c8d357540caa05ae8ab70c9feb7", + "name": "pytest-doctestplus", + "sha256": "854e426c72e2a521a664f1588b1775b198625310504931e6f0c9a8a98c07a4d6", + "size": 21908, + "subdir": "linux-64", + "timestamp": 1542391318146, + "version": "0.2.0" + }, + "pytest-doctestplus-0.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "d1f13188535c951b90753c92131c7be5", + "name": "pytest-doctestplus", + "sha256": "338f13ba115373785343cc63b7d7499a3be7bfe4d0af06bddf2d3c4551851619", + "size": 21991, + "subdir": "linux-64", + "timestamp": 1542391312634, + "version": "0.2.0" + }, + "pytest-doctestplus-0.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD", + "md5": "59aff5c5accb38194742a96db1a6669d", + "name": "pytest-doctestplus", + "sha256": "3a86d1c4e8c0c2c411e4a3044fcf810e256ca1a7f4273d9d6480a4aa06426cbc", + "size": 21879, + "subdir": "linux-64", + "timestamp": 1542391281847, + "version": "0.2.0" + }, + "pytest-doctestplus-0.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "3131ae31821279d5288c94dfdd5590a5", + "name": "pytest-doctestplus", + "sha256": "377892818fc03260c7d285a1e659ef1aab6246feb87e2e5993555f86f63a5125", + "size": 23845, + "subdir": "linux-64", + "timestamp": 1552446376918, + "version": "0.3.0" + }, + "pytest-doctestplus-0.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "50c2e6af90aa70cb531330478c1ab523", + "name": "pytest-doctestplus", + "sha256": "13fd1d1c152185ab254fe8507cac582e1ec88aec59e13b366b282c2e9eb1c7fe", + "size": 24288, + "subdir": "linux-64", + "timestamp": 1552446330592, + "version": "0.3.0" + }, + "pytest-doctestplus-0.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.10", + "pytest >=2.8", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD", + "md5": "074171f6802ce15c05ee2b2405a52ca8", + "name": "pytest-doctestplus", + "sha256": "f214f07484647ae12e805fbeed4811783325093407ece772a478a2583bdb8d63", + "size": 24207, + "subdir": "linux-64", + "timestamp": 1552446829802, + "version": "0.3.0" + }, + "pytest-forked-0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "0401f9a3e7d566c15638fa2ab68acd38", + "name": "pytest-forked", + "sha256": "ede030a3ed2c182bdc6e58085651be24c2f5fdf2cb909945c9a8f8927e7cc24e", + "size": 8854, + "subdir": "linux-64", + "timestamp": 1530727774984, + "version": "0.2" + }, + "pytest-forked-0.2-py27h9339617_0.conda": { + "build": "py27h9339617_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "272641ee401e2e74a27efe6f997d2d9e", + "name": "pytest-forked", + "sha256": "d2adb2c1cdd0a7caf52c6a3ea5ac92356a23d2766836bd654c805c22c423a9a9", + "size": 9382, + "subdir": "linux-64", + "timestamp": 1511987650545, + "version": "0.2" + }, + "pytest-forked-0.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "8e3492cdaefc4be860cb7182beda7654", + "name": "pytest-forked", + "sha256": "9c3361bcde81be3b1aac2fabc96a5a97d8a83ba8258919f880b92ba34d7a647a", + "size": 8933, + "subdir": "linux-64", + "timestamp": 1534347509642, + "version": "0.2" + }, + "pytest-forked-0.2-py35hc748f2f_0.conda": { + "build": "py35hc748f2f_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "82ced4242f83eee3e3b24c4aef42933b", + "name": "pytest-forked", + "sha256": "7b84a9b96bbb8c0c138f8453f980a6947e6afbbcfcf9545428157b07901152e9", + "size": 9459, + "subdir": "linux-64", + "timestamp": 1511987644628, + "version": "0.2" + }, + "pytest-forked-0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "384faf56a4b784043fdaeb1bfa0deb5b", + "name": "pytest-forked", + "sha256": "aaab73caa9e9f650e7088d38d2118b735eb7bd4b4ed3bd07e8e6092a42ed4ae0", + "size": 8905, + "subdir": "linux-64", + "timestamp": 1530727817342, + "version": "0.2" + }, + "pytest-forked-0.2-py36h09594ab_0.conda": { + "build": "py36h09594ab_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "309101cb1dadcdf44493f403d890d47b", + "name": "pytest-forked", + "sha256": "8f55fe386e90724424d83274aca90054ebab038d90d3bac9d53917c61d80d2e3", + "size": 9387, + "subdir": "linux-64", + "timestamp": 1511987666358, + "version": "0.2" + }, + "pytest-forked-0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2bb66ab6fd0ec6431031b72284f0e675", + "name": "pytest-forked", + "sha256": "cac55cf70b9660fa897d86f05ac68eebc7255261be7d4013536f08cb87184b64", + "size": 8897, + "subdir": "linux-64", + "timestamp": 1530727795784, + "version": "0.2" + }, + "pytest-forked-1.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "1df73d8848aea854ead46fce1bcec129", + "name": "pytest-forked", + "sha256": "5eb91921f416915ef950ce002f92bd372b36c6b950fc92bf54833f5304bfbbc3", + "size": 10702, + "subdir": "linux-64", + "timestamp": 1550355075044, + "version": "1.0.2" + }, + "pytest-forked-1.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6a1d0bde5e8e264b0136da655da3c078", + "name": "pytest-forked", + "sha256": "9caad95e028da05b759b70a1efbf5bffc89baacc7f4b720b24f39e7caca69309", + "size": 10682, + "subdir": "linux-64", + "timestamp": 1550355066607, + "version": "1.0.2" + }, + "pytest-forked-1.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.6.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c5e9063c0291d848276ccba69aa66baf", + "name": "pytest-forked", + "sha256": "00a131092e0df96ad5e0c5587138ca89d342990ca422518492b9b4760d85a448", + "size": 10666, + "subdir": "linux-64", + "timestamp": 1550355022471, + "version": "1.0.2" + }, + "pytest-html-1.16.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "aecf6617d3bf6768aab19d810dd5f03b", + "name": "pytest-html", + "sha256": "c424785354f75a10ba9afef718f8b2cf9d4072f44860a5aa65e968d34f40ba73", + "size": 23059, + "subdir": "linux-64", + "timestamp": 1518721499130, + "version": "1.16.0" + }, + "pytest-html-1.16.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "e5c3eefbf0149a28c437653cd2bbe01b", + "name": "pytest-html", + "sha256": "71b338af40dcdc61d19c7e6e5cd01d763e3894f9ffd2168a4aee233473496aeb", + "size": 23335, + "subdir": "linux-64", + "timestamp": 1518721704476, + "version": "1.16.0" + }, + "pytest-html-1.16.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "79a0babfa3b8282fcc2e4516aab64e87", + "name": "pytest-html", + "sha256": "692bbeca343e74850b13b5a48792aec9be1eb4320062ea06edee83af40271908", + "size": 23151, + "subdir": "linux-64", + "timestamp": 1518721478800, + "version": "1.16.0" + }, + "pytest-html-1.16.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "171d8dc42c4eef3db039e74c012081ab", + "name": "pytest-html", + "sha256": "26615e3720d69590ff13c9f84e41ef654f79b5d7e953ae4cfeda1be7165b528a", + "size": 23301, + "subdir": "linux-64", + "timestamp": 1522194660182, + "version": "1.16.1" + }, + "pytest-html-1.16.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "65dad023933d3f128e8b970e23161f6e", + "name": "pytest-html", + "sha256": "b8f4b82211cafa311c8e6a1ac1f8b004f7fef2ffe66e589d350966b2a4e964bc", + "size": 23475, + "subdir": "linux-64", + "timestamp": 1522194662618, + "version": "1.16.1" + }, + "pytest-html-1.16.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "baa3157ca99d508b5cf8afbbd68ceeab", + "name": "pytest-html", + "sha256": "a6f480d6ce459dc501806fbff9e02cac89d6253125fd10ef5741b01dfc41a705", + "size": 23352, + "subdir": "linux-64", + "timestamp": 1522194662861, + "version": "1.16.1" + }, + "pytest-html-1.17.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "6edc8169fb02e4d86b837e18b4712fff", + "name": "pytest-html", + "sha256": "e41874a417e64f2c0078cb01845e756e51c57dacc64f762ced2e4a2fb2ea60da", + "size": 24169, + "subdir": "linux-64", + "timestamp": 1524086590598, + "version": "1.17.0" + }, + "pytest-html-1.17.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "21e65ff4a7fc21e0e1ee1657aed8e83c", + "name": "pytest-html", + "sha256": "31cc6b48f3f2cc40243e8f41eff230d7d4ee6ac32984eddf600c314238791215", + "size": 24422, + "subdir": "linux-64", + "timestamp": 1524086610474, + "version": "1.17.0" + }, + "pytest-html-1.17.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "858678f566a31d548137ed617c5f4a97", + "name": "pytest-html", + "sha256": "f1646fd7c9463f43faa382b1eb7f4af9ddbcf28a581d7198f2c83af25b7f300d", + "size": 24332, + "subdir": "linux-64", + "timestamp": 1524086530808, + "version": "1.17.0" + }, + "pytest-html-1.18.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "7b80696c38ad29c14e2faac91209cf19", + "name": "pytest-html", + "sha256": "f460b0c3882a5da07e9f7f34fd75c93225ea7d227c0b71de958162f9a72240e0", + "size": 24431, + "subdir": "linux-64", + "timestamp": 1527702082988, + "version": "1.18.0" + }, + "pytest-html-1.18.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "99d0560b85afbbaf960c5497264d4e5b", + "name": "pytest-html", + "sha256": "c29adb8337685c24e600f8352ee3aa341458e58e6ca7b59235f3ec6496b84665", + "size": 24807, + "subdir": "linux-64", + "timestamp": 1527702114061, + "version": "1.18.0" + }, + "pytest-html-1.18.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "f5d11405dd78b891fc1a61e093fba88d", + "name": "pytest-html", + "sha256": "c156db4ff65466a9d2c43003aa607a650af4989d797d5e793c80f289aa04fced", + "size": 24568, + "subdir": "linux-64", + "timestamp": 1527702060977, + "version": "1.18.0" + }, + "pytest-html-1.19.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "4f507342832898bcda8ddb71c16e54ad", + "name": "pytest-html", + "sha256": "53c2e59b5665b0bd02d75ce687fcdf0eb6177f5ee577f6c5c4ee98def4aa7c94", + "size": 24850, + "subdir": "linux-64", + "timestamp": 1528148538647, + "version": "1.19.0" + }, + "pytest-html-1.19.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.5,<3.6.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "934e8e79df18dc1f3aab7f87bd153357", + "name": "pytest-html", + "sha256": "80fab69d1588fa5e0cb8a7e08e53e8bd5a00afbbbe2b5b98e923ec52b437914e", + "size": 25002, + "subdir": "linux-64", + "timestamp": 1528148619742, + "version": "1.19.0" + }, + "pytest-html-1.19.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "6fe6d6b5e1cb5037e8c85897dac6e4c8", + "name": "pytest-html", + "sha256": "3d26b9efb7708d60ecf6f8e3851f6748685b4e53ef983d190e29756fe7b8290b", + "size": 24959, + "subdir": "linux-64", + "timestamp": 1528148563447, + "version": "1.19.0" + }, + "pytest-html-1.19.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "a507023c9459c9e3e8802f13aa61ecea", + "name": "pytest-html", + "sha256": "aef1b7ebf71aea09db4475823b4bd8bd820de3ffde2b7dd81e594bb7db887170", + "size": 24923, + "subdir": "linux-64", + "timestamp": 1530922303764, + "version": "1.19.0" + }, + "pytest-html-1.20.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=2.7,<2.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "97e34adae7935b0c3a3aa53c93c672a3", + "name": "pytest-html", + "sha256": "128249691762ab8c9baf0a98631c71085e717fbd5cd0406eb8423ea6b79130f2", + "size": 27136, + "subdir": "linux-64", + "timestamp": 1552447406739, + "version": "1.20.0" + }, + "pytest-html-1.20.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.6,<3.7.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "a25d72551c85b4614be0f054a16d8beb", + "name": "pytest-html", + "sha256": "6384a5a80c105f4ab600884565e4637108eb024657be385e51565b9331dce672", + "size": 27263, + "subdir": "linux-64", + "timestamp": 1552447260263, + "version": "1.20.0" + }, + "pytest-html-1.20.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-metadata", + "python >=3.7,<3.8.0a0" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "cba241a59c0e75820654d462ad73b9a6", + "name": "pytest-html", + "sha256": "a0eb3543b7c31d8ecebee3eb45b5e7c20dbbce11f36a5ca373ac8659587572fc", + "size": 27412, + "subdir": "linux-64", + "timestamp": 1552446806409, + "version": "1.20.0" + }, + "pytest-json-0.4.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pytest >=2.3", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7033832fc960362304463ebe1d864a1a", + "name": "pytest-json", + "sha256": "79201693931fba12befe2282132c9a99913e55d1a96576b67fb1352bcb61d25b", + "size": 12466, + "subdir": "linux-64", + "timestamp": 1536866441633, + "version": "0.4.0" + }, + "pytest-json-0.4.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "pytest >=2.3", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8bf2c613d0f3170aea05bd0b8dac426", + "name": "pytest-json", + "sha256": "cbdb19aa9ecc2b2b3bce592f48f4e7b675be460785890a43c2b9e3884d0b60a6", + "size": 12639, + "subdir": "linux-64", + "timestamp": 1536866501808, + "version": "0.4.0" + }, + "pytest-json-0.4.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pytest >=2.3", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dde3da4874c2937a4f3095b9b41b6f61", + "name": "pytest-json", + "sha256": "4d89988e5cc51ccd93777dac8d9009e673f266fee364877ede69215cb0cf0940", + "size": 12577, + "subdir": "linux-64", + "timestamp": 1536866499032, + "version": "0.4.0" + }, + "pytest-json-0.4.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pytest >=2.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f65e6bc0400be2d7ad9b3dc40a0e2e61", + "name": "pytest-json", + "sha256": "5db7f08e111a9514e50d732fde8c4989fed5879dcb85734469948ba8412c78f8", + "size": 12692, + "subdir": "linux-64", + "timestamp": 1536866441111, + "version": "0.4.0" + }, + "pytest-jupyter-0.6.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "ipykernel >=6.14", + "jupyter_client >=7.4.0", + "jupyter_server >=1.21", + "nbformat >=5.3" + ], + "depends": [ + "jupyter_core", + "pytest", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8236c6505d44dad7c3fe221b5882fc60", + "name": "pytest-jupyter", + "sha256": "81213a77b1f91c3f1236c7ddb8fafd9c2014a2bd4b9872919489804fee51bd30", + "size": 30302, + "subdir": "linux-64", + "timestamp": 1680012155002, + "version": "0.6.2" + }, + "pytest-jupyter-0.6.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "ipykernel >=6.14", + "jupyter_client >=7.4.0", + "jupyter_server >=1.21", + "nbformat >=5.3" + ], + "depends": [ + "jupyter_core", + "pytest", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38737118becbf04335dd85cbb3076261", + "name": "pytest-jupyter", + "sha256": "835a7cd77c35de9ef4c284c2a5b142894e2ee22db2e34253787196363cd277e1", + "size": 36226, + "subdir": "linux-64", + "timestamp": 1680011992860, + "version": "0.6.2" + }, + "pytest-jupyter-0.6.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "ipykernel >=6.14", + "jupyter_client >=7.4.0", + "jupyter_server >=1.21", + "nbformat >=5.3" + ], + "depends": [ + "jupyter_core", + "pytest", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d3c28debae14df19145a735661da769d", + "name": "pytest-jupyter", + "sha256": "5712dc733bc6e5d0be5e813d6d6f6cdf3d1cb3faf948802023b571ea7ac67e39", + "size": 29992, + "subdir": "linux-64", + "timestamp": 1680012072100, + "version": "0.6.2" + }, + "pytest-jupyter-0.6.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "ipykernel >=6.14", + "jupyter_client >=7.4.0", + "jupyter_server >=1.21", + "nbformat >=5.3" + ], + "depends": [ + "jupyter_core", + "pytest", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5518b2f2c91a258c50f6f0e7ba90a79c", + "name": "pytest-jupyter", + "sha256": "ce0a66c400c957f8249bc3558f73d04aea37046a5e8d6ea66d9eea2454defc69", + "size": 29990, + "subdir": "linux-64", + "timestamp": 1680011910846, + "version": "0.6.2" + }, + "pytest-jupyter-client-0.6.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "jupyter_client >=7.4.0", + "pytest-jupyter >=0.6.2,<0.6.3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "254540f1b480c9ccea11619dad48ccc1", + "name": "pytest-jupyter-client", + "sha256": "aaeb9fe89067717f5d33940c6f27e8c581dbefbe05c5bb3b5b7ab8b5158e60eb", + "size": 6614, + "subdir": "linux-64", + "timestamp": 1680012161729, + "version": "0.6.2" + }, + "pytest-jupyter-client-0.6.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "jupyter_client >=7.4.0", + "pytest-jupyter >=0.6.2,<0.6.3.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "84800e1da60efbbdd423bee389dcd4b7", + "name": "pytest-jupyter-client", + "sha256": "468a74c2b73884948e0e800046a502195f9fffc5980db01cf933a44787ba1cfb", + "size": 6615, + "subdir": "linux-64", + "timestamp": 1680011999786, + "version": "0.6.2" + }, + "pytest-jupyter-client-0.6.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "jupyter_client >=7.4.0", + "pytest-jupyter >=0.6.2,<0.6.3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "11dad57d47a9abb90ad9b52a3ec294f3", + "name": "pytest-jupyter-client", + "sha256": "f9a1c336e6be99d3d0d96a12931839385040b7c98e66954b928dd465dffb12c7", + "size": 6586, + "subdir": "linux-64", + "timestamp": 1680012078416, + "version": "0.6.2" + }, + "pytest-jupyter-client-0.6.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=6.14", + "jupyter_client >=7.4.0", + "pytest-jupyter >=0.6.2,<0.6.3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "80858d12e786f77c40a08655a6471537", + "name": "pytest-jupyter-client", + "sha256": "4f97e2d68d3982e3193be48b498c9a939b8bbbd343edc38f8e8dfb0c78bb9136", + "size": 6569, + "subdir": "linux-64", + "timestamp": 1680011917415, + "version": "0.6.2" + }, + "pytest-jupyter-server-0.6.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_server >=1.21", + "nbformat >=5.3", + "pytest-jupyter-client >=0.6.2,<0.6.3.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "58053b94bc69f7f050f9b26b02368398", + "name": "pytest-jupyter-server", + "sha256": "5258b75644cad4a3c56a01d8d1170a8c418574f105570f2f9f19077326bdc640", + "size": 7844, + "subdir": "linux-64", + "timestamp": 1680012168386, + "version": "0.6.2" + }, + "pytest-jupyter-server-0.6.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_server >=1.21", + "nbformat >=5.3", + "pytest-jupyter-client >=0.6.2,<0.6.3.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5efd98fb85ec6b679a5635af27e881f9", + "name": "pytest-jupyter-server", + "sha256": "7203a82ebffa68c22ca75495084214925b54e1dcab079866bcff2dbe0959ec3f", + "size": 7840, + "subdir": "linux-64", + "timestamp": 1680012006602, + "version": "0.6.2" + }, + "pytest-jupyter-server-0.6.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_server >=1.21", + "nbformat >=5.3", + "pytest-jupyter-client >=0.6.2,<0.6.3.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7d9c3ed7aa6258c5eae4543ddba93891", + "name": "pytest-jupyter-server", + "sha256": "0e878fc6bc9e460d7a8c9bcb207d74e2adac852afc6438ca146927dcf771fe28", + "size": 7807, + "subdir": "linux-64", + "timestamp": 1680012084612, + "version": "0.6.2" + }, + "pytest-jupyter-server-0.6.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jupyter_server >=1.21", + "nbformat >=5.3", + "pytest-jupyter-client >=0.6.2,<0.6.3.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ea66014eeb8b38e65d62d9b2c77df3f5", + "name": "pytest-jupyter-server", + "sha256": "7e4239199e299a073d8b5d4c6f9ad28cdcefe25a1368799c954eb7a6431c39b8", + "size": 7804, + "subdir": "linux-64", + "timestamp": 1680011923653, + "version": "0.6.2" + }, + "pytest-metadata-1.10.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "d54abdceb2212ca1f00ea830b3d8ec23", + "name": "pytest-metadata", + "sha256": "77431ceccb2ad80eb803fd7f210ce346b456754226a9a84d975e33bea6d82f8e", + "size": 14551, + "subdir": "linux-64", + "timestamp": 1593444339680, + "version": "1.10.0" + }, + "pytest-metadata-1.10.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "d2f5f550c9de42749355b677a9e8bb85", + "name": "pytest-metadata", + "sha256": "518d67f0bd39cc869ecba31e424b89e69d4f425090da12e9e1fec52843ae1102", + "size": 14528, + "subdir": "linux-64", + "timestamp": 1593444348742, + "version": "1.10.0" + }, + "pytest-metadata-1.10.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "1f687b802e85989bca8ea28e9a79bbf3", + "name": "pytest-metadata", + "sha256": "5678e2677c177b3d35328fbc76e461d94aff078f09950fed9457fec28b72b7b4", + "size": 14581, + "subdir": "linux-64", + "timestamp": 1593444328796, + "version": "1.10.0" + }, + "pytest-metadata-1.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "bbfc313b097b18da358c2b8679a868ee", + "name": "pytest-metadata", + "sha256": "90d8aed2046c508592e3e09503b2ae2b81590cdb9972c9e8f1143bc632e657ae", + "size": 13804, + "subdir": "linux-64", + "timestamp": 1640810584664, + "version": "1.11.0" + }, + "pytest-metadata-1.11.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "d1e79833267076fa3b06e55b48b57c9a", + "name": "pytest-metadata", + "sha256": "80537b462ec7af11e451ca973ca1c2a907148c2070331f52c5488fbb9e7e6b3a", + "size": 15413, + "subdir": "linux-64", + "timestamp": 1676861366412, + "version": "1.11.0" + }, + "pytest-metadata-1.11.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "a1e04efbc13c95dfe1d77d2de6aaa486", + "name": "pytest-metadata", + "sha256": "978dcd77e46a45e531fe637577d9a120d9389f2a7a8239f4fd1f2a527638a1d6", + "size": 14105, + "subdir": "linux-64", + "timestamp": 1606518013213, + "version": "1.11.0" + }, + "pytest-metadata-1.11.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "5d49ea9e269035fb75adb3a06351e9cd", + "name": "pytest-metadata", + "sha256": "9c36ce1ba41bc8185e2eada7a5a59374a0cef03fd6d0887c5e25ea8548667187", + "size": 14086, + "subdir": "linux-64", + "timestamp": 1606517992092, + "version": "1.11.0" + }, + "pytest-metadata-1.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "4764f835829a214bee150d124508539a", + "name": "pytest-metadata", + "sha256": "4866db63c036415e29e70377465aa1c9aaf8e68fca174691cb5b087e04aa5e85", + "size": 14045, + "subdir": "linux-64", + "timestamp": 1606518038858, + "version": "1.11.0" + }, + "pytest-metadata-1.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "677e82aaab4f487e87814e1ac7466356", + "name": "pytest-metadata", + "sha256": "b0fc7276d32c9ace8546ea37eb21d42ec8c4168a53a79c291977d6f85b7cdc41", + "size": 13950, + "subdir": "linux-64", + "timestamp": 1606518029640, + "version": "1.11.0" + }, + "pytest-metadata-1.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "0766460c4651a1c902d7ca1e545905cf", + "name": "pytest-metadata", + "sha256": "1996ff2bf6959271ee5008c5d6469d08a2e7b6fc566f12597c4e24576d874871", + "size": 12031, + "subdir": "linux-64", + "timestamp": 1518721209565, + "version": "1.5.1" + }, + "pytest-metadata-1.5.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "a33d271e14c8102b70ac9317ae425035", + "name": "pytest-metadata", + "sha256": "310cfd4025fb03115c1e3933bfb596a1dcce9874f035bc7766e545b29ab91c00", + "size": 12141, + "subdir": "linux-64", + "timestamp": 1518721361019, + "version": "1.5.1" + }, + "pytest-metadata-1.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "06a7dae5188b024b5d086eeb483b5910", + "name": "pytest-metadata", + "sha256": "b527a52bc2cbba98e0d9fdd592f5c62e90129d04544664e6e9709999c09feabd", + "size": 12051, + "subdir": "linux-64", + "timestamp": 1518721284902, + "version": "1.5.1" + }, + "pytest-metadata-1.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "966785a7e562ace6129fc8b8c36c1f17", + "name": "pytest-metadata", + "sha256": "32ebc15b76b2d5420b512fd688720575d0a7471d5fedabb4b3d5c7384ff99c4c", + "size": 12248, + "subdir": "linux-64", + "timestamp": 1519482810078, + "version": "1.6.0" + }, + "pytest-metadata-1.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "806d12ebc3fa461bcfa54e8bca8ecd7b", + "name": "pytest-metadata", + "sha256": "66e1c777615fc9de211b4187e1391d05a180210214df69bbc855617f9e73aa58", + "size": 12341, + "subdir": "linux-64", + "timestamp": 1519482837012, + "version": "1.6.0" + }, + "pytest-metadata-1.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "c4365a32bda32a197bc05c7c1be44471", + "name": "pytest-metadata", + "sha256": "743d21dc71f450de1b2dec16ff87144fcbd7eabf2072d3a24a524ab4b1d79771", + "size": 12284, + "subdir": "linux-64", + "timestamp": 1519482768516, + "version": "1.6.0" + }, + "pytest-metadata-1.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "d0b2ec19617be8225612f0f9c708cda5", + "name": "pytest-metadata", + "sha256": "7ef04f97598043d64ac5144ddf5b279809c235b4dab9719262eeb37c2f84207c", + "size": 12750, + "subdir": "linux-64", + "timestamp": 1524086416406, + "version": "1.7.0" + }, + "pytest-metadata-1.7.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "0dd66576ee15db22985e1d7507fc3207", + "name": "pytest-metadata", + "sha256": "659c3438b3b09d9c30809c6d756b0df04f0550412f6498dc86587b88e1742b72", + "size": 12900, + "subdir": "linux-64", + "timestamp": 1524086441748, + "version": "1.7.0" + }, + "pytest-metadata-1.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "daa726cbede55154b1eeeac2bee4a412", + "name": "pytest-metadata", + "sha256": "176caf3254406e81ebeaae75e205a52481d77ec333cbc042504e68207f1044ab", + "size": 12779, + "subdir": "linux-64", + "timestamp": 1524086368315, + "version": "1.7.0" + }, + "pytest-metadata-1.7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "9fdf5944627720b578dec8c6bc0c158a", + "name": "pytest-metadata", + "sha256": "1f3b4b10146eae6cb00abdde98f1d6758586671d12a6aa5a09792766ce153612", + "size": 12658, + "subdir": "linux-64", + "timestamp": 1530922264829, + "version": "1.7.0" + }, + "pytest-metadata-1.7.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "a10b163b5b3f5644dc29cd62deb9af94", + "name": "pytest-metadata", + "sha256": "9faa3366808b89dd509baadbbeb30d1cd5576468fe62d4578606964a0526535c", + "size": 13033, + "subdir": "linux-64", + "timestamp": 1574169740680, + "version": "1.7.0" + }, + "pytest-metadata-1.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "172143c08d25102f5b3e550e313c1d07", + "name": "pytest-metadata", + "sha256": "10b308d6a502942d02c071b0249eca5b686ee222374b38da4c1d4b93869ecae9", + "size": 14563, + "subdir": "linux-64", + "timestamp": 1547478090243, + "version": "1.8.0" + }, + "pytest-metadata-1.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "c865edf1384c41207ba5e512be477c8a", + "name": "pytest-metadata", + "sha256": "2374b3cf3cc834283242e3f4964f01ed777076ffd69d9a6236e7983e4e84ce94", + "size": 14648, + "subdir": "linux-64", + "timestamp": 1547478161945, + "version": "1.8.0" + }, + "pytest-metadata-1.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.9.0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "425b75b20bf45c3968a87dbe853f32f2", + "name": "pytest-metadata", + "sha256": "f09e936385f3bf8010ea5e6af1c9471c5ddc2412204f08aca211e3bc5cdd3996", + "size": 14650, + "subdir": "linux-64", + "timestamp": 1547478159235, + "version": "1.8.0" + }, + "pytest-mock-1.10.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mock", + "pytest >=2.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9a8a80c7b461c06be89ffc1c96568ba8", + "name": "pytest-mock", + "sha256": "08b18b1975b7f53e015aa10733c2865244676a39d262db155a4c269e3eebefea", + "size": 19287, + "subdir": "linux-64", + "timestamp": 1526919160559, + "version": "1.10.0" + }, + "pytest-mock-1.10.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "8d73caac4612e5f3932dbb132bf90ad0", + "name": "pytest-mock", + "sha256": "603db304a164dafcd6edd4db0af93c7bcc269d9373e13b4d1ec203b5166eb839", + "size": 19565, + "subdir": "linux-64", + "timestamp": 1526919208136, + "version": "1.10.0" + }, + "pytest-mock-1.10.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "28e78fc15fce824e07e0b17d9a0ccabe", + "name": "pytest-mock", + "sha256": "636467fe7a83c765722c51e5f9871f909ef5c901b2f01a7b03a31536623f52ff", + "size": 19450, + "subdir": "linux-64", + "timestamp": 1526919132331, + "version": "1.10.0" + }, + "pytest-mock-1.10.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "aac3ad73a17b5dd58ad2b4f94658ce17", + "name": "pytest-mock", + "sha256": "e707ac874e022cec97186b71637963389edc6cb04a0d55d5a53c4a7349a7169a", + "size": 19445, + "subdir": "linux-64", + "timestamp": 1530922343673, + "version": "1.10.0" + }, + "pytest-mock-1.10.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mock", + "pytest >=2.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f0761af581c0f84a0de2b51d28fbeafe", + "name": "pytest-mock", + "sha256": "59550d67476fc2a103ff7c2b0a5be969d11cab654334b0357285e7d94424d1d9", + "size": 23916, + "subdir": "linux-64", + "timestamp": 1552364878001, + "version": "1.10.1" + }, + "pytest-mock-1.10.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ef0c2ea9c560d31f60b0b9fd08e05459", + "name": "pytest-mock", + "sha256": "04ea60c05116803a765c7ec95c4fb56ce94a45e0fcf23626681b12f22d7271c7", + "size": 23918, + "subdir": "linux-64", + "timestamp": 1552364905673, + "version": "1.10.1" + }, + "pytest-mock-1.10.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8e5f2ccd71ddf177deae1f0ad3388633", + "name": "pytest-mock", + "sha256": "f029204a0ba2ea371fc208a8aae94263d05ad757ed76deb580fb471909c80dea", + "size": 23953, + "subdir": "linux-64", + "timestamp": 1552364808991, + "version": "1.10.1" + }, + "pytest-mock-1.10.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mock", + "pytest >=2.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ba97d34843fa7da98a230e2b2bcca576", + "name": "pytest-mock", + "sha256": "5fc52c44261f4041e40c7737a6b7c6c583fa1c2da0d56e3b8a306518ea893a26", + "size": 24985, + "subdir": "linux-64", + "timestamp": 1556071736194, + "version": "1.10.4" + }, + "pytest-mock-1.10.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c2aceb07546233b6e83cff6d24cbccf7", + "name": "pytest-mock", + "sha256": "af430995c8f65f0cc5b272fd6f32a2233c80e92614f28f83cfc5da418a3c541c", + "size": 25146, + "subdir": "linux-64", + "timestamp": 1556071612830, + "version": "1.10.4" + }, + "pytest-mock-1.10.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a3e8380d53030dcef196a4113cceea9d", + "name": "pytest-mock", + "sha256": "c298277d61896974f133166f23af792ddcec51f2a2a643d7c47311d806e34a15", + "size": 25130, + "subdir": "linux-64", + "timestamp": 1556071576206, + "version": "1.10.4" + }, + "pytest-mock-1.11.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mock", + "pytest >=2.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "dda909ca6d455706bc015b69402b6c76", + "name": "pytest-mock", + "sha256": "bc558cea7167f3929385cc8d8ccfd620e4830681ec007d189f39a2ccc333bb09", + "size": 26716, + "subdir": "linux-64", + "timestamp": 1573237710161, + "version": "1.11.2" + }, + "pytest-mock-1.11.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4c2f021c1f8ab9e7a50e25a73c36b0ec", + "name": "pytest-mock", + "sha256": "0db5fc85738cd5be387308f88099302efcaf46ad93a0081b49aed3bb1dbabe74", + "size": 26776, + "subdir": "linux-64", + "timestamp": 1573237712757, + "version": "1.11.2" + }, + "pytest-mock-1.11.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f1a5924f5a29c02a2de8d4ec4abb912b", + "name": "pytest-mock", + "sha256": "7d70775c8ec9abe0c53e75a21c7fedd8e77b5db5aced34efbf31f97ea5449f41", + "size": 26798, + "subdir": "linux-64", + "timestamp": 1573237706976, + "version": "1.11.2" + }, + "pytest-mock-1.11.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "7354e50ff18ad2e8a59b8397f8c30ddd", + "name": "pytest-mock", + "sha256": "93c9e8df26289fc569d2ddf6b56ebe73722345c7fc92de72838b4a445433afa6", + "size": 26732, + "subdir": "linux-64", + "timestamp": 1573237699231, + "version": "1.11.2" + }, + "pytest-mock-1.13.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mock", + "pytest >=2.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b62ced026fed5f50c8859d1b840106ea", + "name": "pytest-mock", + "sha256": "b073993be87da87454468fa6d136ac0d16ff6429cce01dd88c558328bcf025c4", + "size": 27500, + "subdir": "linux-64", + "timestamp": 1576541116259, + "version": "1.13.0" + }, + "pytest-mock-1.13.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b5aa49afcb93876c29f7a44f19446e62", + "name": "pytest-mock", + "sha256": "699e68d8d817c75aae50f7617dd837bc2d87c04c52ecb9b120753424e0d6d64c", + "size": 27531, + "subdir": "linux-64", + "timestamp": 1576541121168, + "version": "1.13.0" + }, + "pytest-mock-1.13.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3afb7d9c5130e629b9e8e67e3ed6a46a", + "name": "pytest-mock", + "sha256": "b9ba6e834961334ec9d26b2e8961980b8f4b56a106688ae9942dde9e2105fe44", + "size": 27567, + "subdir": "linux-64", + "timestamp": 1576541173968, + "version": "1.13.0" + }, + "pytest-mock-1.13.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "f418cd926a9fe683ab1a3c2ceac6ca08", + "name": "pytest-mock", + "sha256": "5f93b432adeba14b07a6762300a58304ba0b2c74fb23173b1eaeefff49e88728", + "size": 27566, + "subdir": "linux-64", + "timestamp": 1576541211079, + "version": "1.13.0" + }, + "pytest-mock-1.6.3-py27hb287f53_1.conda": { + "build": "py27hb287f53_1", + "build_number": 1, + "depends": [ + "mock", + "pytest", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "2357136e24a56c449fb8a71d24db817d", + "name": "pytest-mock", + "sha256": "10997b8d29f457a0163e1a64d2d22e02612325497801a7ba4d355b517842e490", + "size": 19013, + "subdir": "linux-64", + "timestamp": 1508969114054, + "version": "1.6.3" + }, + "pytest-mock-1.6.3-py35hc252d58_1.conda": { + "build": "py35hc252d58_1", + "build_number": 1, + "depends": [ + "pytest", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "6467313d482b1d8c24e09a0ccd0153d4", + "name": "pytest-mock", + "sha256": "fcaacbfcf9c99071fdbac68ec03014f4c076e4097fb16d823c893dd076a9b45e", + "size": 19203, + "subdir": "linux-64", + "timestamp": 1508969111246, + "version": "1.6.3" + }, + "pytest-mock-1.6.3-py36h4eecd68_1.conda": { + "build": "py36h4eecd68_1", + "build_number": 1, + "depends": [ + "pytest", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "04941ae5772f43b0f230d6d8194bd78d", + "name": "pytest-mock", + "sha256": "44cc029f1c609340ca45c615aef55075bcb28188414451ee1a78bac5025b074a", + "size": 18993, + "subdir": "linux-64", + "timestamp": 1508969113418, + "version": "1.6.3" + }, + "pytest-mock-1.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mock", + "pytest >=2.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "bafb49dc620eeb300a79b0e53c6b7fe6", + "name": "pytest-mock", + "sha256": "e43105885cfb343a4f1b4ae8fb578f4636ab339166be91b7e8772632ae56a859", + "size": 19328, + "subdir": "linux-64", + "timestamp": 1519150651584, + "version": "1.7.0" + }, + "pytest-mock-1.7.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "22392c613df0ee52cb64c1040ee32f3c", + "name": "pytest-mock", + "sha256": "67de5ef779da33703267d90c683ccc728e83d051a491d76ea162fd571f3d11b0", + "size": 19435, + "subdir": "linux-64", + "timestamp": 1519150664000, + "version": "1.7.0" + }, + "pytest-mock-1.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "bcf93e5409ab2800f97e0a6eea51e426", + "name": "pytest-mock", + "sha256": "3eaf14f7f2c0366a4891419421e89bde83cfe36a99d52d09daf6879c7b2f34aa", + "size": 19409, + "subdir": "linux-64", + "timestamp": 1519150667300, + "version": "1.7.0" + }, + "pytest-mock-1.7.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mock", + "pytest >=2.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d8937c462c34b08613ad678fbaa3b29e", + "name": "pytest-mock", + "sha256": "bdbfdacb4af52708c73bbd11a0dd1e5b41f1975d27ea18f3f09743043327ce52", + "size": 19316, + "subdir": "linux-64", + "timestamp": 1522194209704, + "version": "1.7.1" + }, + "pytest-mock-1.7.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "4680795edc1170e83f6e920c394c7549", + "name": "pytest-mock", + "sha256": "5e3804bedf689c70fda2f40fbbd0afca5a10ef4cfef2d9cfe581bec4aef8af7f", + "size": 19565, + "subdir": "linux-64", + "timestamp": 1522194380280, + "version": "1.7.1" + }, + "pytest-mock-1.7.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3e7901d323d60b3bc6dc223d44ce1b4d", + "name": "pytest-mock", + "sha256": "bad741775bf985f95ca62846cb50ad4e465ef1e9205bb0258480409e3f07e228", + "size": 19374, + "subdir": "linux-64", + "timestamp": 1522193935843, + "version": "1.7.1" + }, + "pytest-mock-1.9.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "mock", + "pytest >=2.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "958aaef4ebfd82255e87f909c973f147", + "name": "pytest-mock", + "sha256": "d89a16602992a2eff57ac532015608cc40f2e29979e0adfe4dd3e00ddd7b6883", + "size": 19557, + "subdir": "linux-64", + "timestamp": 1524012068144, + "version": "1.9.0" + }, + "pytest-mock-1.9.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "118777c80688b62824bd09bdc737404c", + "name": "pytest-mock", + "sha256": "ba6fd5520a46cf085cf0cc9fcf73536f6fd21eecad8d7b298f21e9e306ddf6c8", + "size": 19608, + "subdir": "linux-64", + "timestamp": 1524012029003, + "version": "1.9.0" + }, + "pytest-mock-1.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "5382887907719c5685501520dcb89e66", + "name": "pytest-mock", + "sha256": "e205756c6794c60c36e4e4c00d699c648172b3b3917783c8cc576758ff349298", + "size": 19483, + "subdir": "linux-64", + "timestamp": 1524012080246, + "version": "1.9.0" + }, + "pytest-mock-3.10.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ea301b6d27e0f621bfe0186a2319555", + "name": "pytest-mock", + "sha256": "1533d2a7c2b1aa69ca39f2007e27d0eefdc87ded58e890ca98b3944b8d1af58f", + "size": 26691, + "subdir": "linux-64", + "timestamp": 1674590368197, + "version": "3.10.0" + }, + "pytest-mock-3.10.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "54b86a6bf8f28b7196fcda5f710d8d98", + "name": "pytest-mock", + "sha256": "3d77ac7044bfed1fad44c53057ff1161eaf6afd73ebc65fe2841fb0767cd9cd7", + "size": 29417, + "subdir": "linux-64", + "timestamp": 1676845510709, + "version": "3.10.0" + }, + "pytest-mock-3.10.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d5cc99d2b52f7a3173c38783ed5b6e7", + "name": "pytest-mock", + "sha256": "3787e7fbf91896fddab5282672c047e3d2587617c5103a562dd3e26ec86039b5", + "size": 26406, + "subdir": "linux-64", + "timestamp": 1674590338970, + "version": "3.10.0" + }, + "pytest-mock-3.10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc58e0c5784783a7317a870852fcc57f", + "name": "pytest-mock", + "sha256": "e528015323b38d75f36d6758142242a3975b030e35673e1014b4cdc3546ec525", + "size": 26451, + "subdir": "linux-64", + "timestamp": 1674590397128, + "version": "3.10.0" + }, + "pytest-mock-3.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ac4d701e92391bb3dd37501df5b2bd5", + "name": "pytest-mock", + "sha256": "d47d6a61877c7fe6eeb0d54f6fb28b66257a78ee463bc4719ee5b308b25ceb19", + "size": 26497, + "subdir": "linux-64", + "timestamp": 1674590426547, + "version": "3.10.0" + }, + "pytest-mock-3.7.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "273780dda10218e59efb8533aff79dd3", + "name": "pytest-mock", + "sha256": "f5a5f6ad67dc408b1e7b5dcc352f86778cf81fe57a5b7e14bf2522498b9cec22", + "size": 27929, + "subdir": "linux-64", + "timestamp": 1655844737252, + "version": "3.7.0" + }, + "pytest-mock-3.7.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa829b91b38dadb2f713bd97bf2fdbb8", + "name": "pytest-mock", + "sha256": "30e34cc98f0c2f0dffaf95fc59498bf13758eac81dd5a7e3981d918e99d629aa", + "size": 27748, + "subdir": "linux-64", + "timestamp": 1655844832806, + "version": "3.7.0" + }, + "pytest-mock-3.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ddb9ee64f013908d352b813d05944a76", + "name": "pytest-mock", + "sha256": "fe83be218814ba417d99a9426137e8079f659676fc146d4f3ffdbd4912598189", + "size": 27848, + "subdir": "linux-64", + "timestamp": 1655844767760, + "version": "3.7.0" + }, + "pytest-mock-3.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ef6d3d2e51cdc20d1b3f5b7d61c4b46", + "name": "pytest-mock", + "sha256": "1a4b1f705d940b2880611cf19f94ad063f715d8c7bf9e9c28b695f85db5e319a", + "size": 27862, + "subdir": "linux-64", + "timestamp": 1655844799740, + "version": "3.7.0" + }, + "pytest-openfiles-0.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=3.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "575ffa04968880490ab63e67fa222b23", + "name": "pytest-openfiles", + "sha256": "551db3b98b390a48913a9092fda9fcd66ab7db28853c9a20c6a0a0a776d170ae", + "size": 9792, + "subdir": "linux-64", + "timestamp": 1518731273336, + "version": "0.2.0" + }, + "pytest-openfiles-0.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=3.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "f6574487beb6ef27d6bfc23d6601c194", + "name": "pytest-openfiles", + "sha256": "ba8b5cc3ace93797daa96020409809cbf213cc7c8439b018d85393c43bd63386", + "size": 9872, + "subdir": "linux-64", + "timestamp": 1518731316263, + "version": "0.2.0" + }, + "pytest-openfiles-0.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=3.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "7c80a6ea6f86f33f76fbc6dadf08a79b", + "name": "pytest-openfiles", + "sha256": "ea7d2569ea4e918931d048f57e145946bb1a6ff2ed2e867f56c3020109eb7f34", + "size": 9840, + "subdir": "linux-64", + "timestamp": 1518731314377, + "version": "0.2.0" + }, + "pytest-openfiles-0.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "3c23c21752e11a5cc266870a819bdad0", + "name": "pytest-openfiles", + "sha256": "502f1575dd929bfad8ed410d79ef55dd336061ca920c7c28f223a34426719fa4", + "size": 9538, + "subdir": "linux-64", + "timestamp": 1524578577612, + "version": "0.3.0" + }, + "pytest-openfiles-0.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "5f6230b84dadc61d9311dbbf8b6c6ccd", + "name": "pytest-openfiles", + "sha256": "e465cc6eb7cb782fbd006f0bf5ea7fec8233c1d06f7616f8cd1648c248138ca1", + "size": 9585, + "subdir": "linux-64", + "timestamp": 1524578504000, + "version": "0.3.0" + }, + "pytest-openfiles-0.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "590380e802d5fb3e795baa76814a1949", + "name": "pytest-openfiles", + "sha256": "818529a305262e4d572b4ccc323014b2c2077e26fd32e8f38deff7c9da1701f3", + "size": 9501, + "subdir": "linux-64", + "timestamp": 1524578579487, + "version": "0.3.0" + }, + "pytest-openfiles-0.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "6cf69380c4e62b98b77c192c5bdaf03d", + "name": "pytest-openfiles", + "sha256": "9b881661a6655f34e453c24999d19ed215e166f409251a9406d2d0f4dd2012c9", + "size": 9491, + "subdir": "linux-64", + "timestamp": 1530738153150, + "version": "0.3.0" + }, + "pytest-openfiles-0.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "363d2da5301510b5f6cd841333db0e68", + "name": "pytest-openfiles", + "sha256": "db191283a6a0daa77e83b45fed3e8578ed6df004d64119c13140a3c9677413be", + "size": 11563, + "subdir": "linux-64", + "timestamp": 1543610637984, + "version": "0.3.1" + }, + "pytest-openfiles-0.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "ba8783d6aef2a3a549334c9c59090732", + "name": "pytest-openfiles", + "sha256": "c61eac7225eb7dcf1dc1157254f53ff554dc432bfb296aa5249ca06f077717fb", + "size": 11686, + "subdir": "linux-64", + "timestamp": 1543610615341, + "version": "0.3.1" + }, + "pytest-openfiles-0.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "00d4853abd049fdd40d91f0dac2d3b11", + "name": "pytest-openfiles", + "sha256": "c574c02b2a2734920af83a1f24883a28055362784f56416ec3ea6678131ea504", + "size": 11727, + "subdir": "linux-64", + "timestamp": 1543610620090, + "version": "0.3.1" + }, + "pytest-openfiles-0.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "f8ce2742c04eda21a89f463a1429bf70", + "name": "pytest-openfiles", + "sha256": "d5c08fff48fc9e563eecac3214175b7eb5746667bf9b30815555b1b16a7a5481", + "size": 11821, + "subdir": "linux-64", + "timestamp": 1547478674386, + "version": "0.3.2" + }, + "pytest-openfiles-0.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "9dce35cbb546cb3b2eb19e684df97283", + "name": "pytest-openfiles", + "sha256": "f896c414c6088ecdf7146189f393cb30e58e55a0b3e2c081e207e40c256f683f", + "size": 11894, + "subdir": "linux-64", + "timestamp": 1547478650418, + "version": "0.3.2" + }, + "pytest-openfiles-0.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "psutil", + "pytest >=2.8.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "8741a35e655583af3d8e36c3cc645c8a", + "name": "pytest-openfiles", + "sha256": "f2ec4afd7cd99387570ae7860f4b510f29c4c882f6892a9fe43069661cbc9593", + "size": 11879, + "subdir": "linux-64", + "timestamp": 1547478684510, + "version": "0.3.2" + }, + "pytest-pep8-1.0.6-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pep8 >=1.3", + "pytest >=2.4.2", + "pytest-cache", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "37065504a3bb754f633b98bf3807a7a9", + "name": "pytest-pep8", + "sha256": "cee9b9fd2f12fea1b13a5b59e42c1adc6626708cac07e2cce3e0e52307edb050", + "size": 11038, + "subdir": "linux-64", + "timestamp": 1537826902517, + "version": "1.0.6" + }, + "pytest-pep8-1.0.6-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "pep8 >=1.3", + "pytest >=2.4.2", + "pytest-cache", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "4ff98ab8e1b9126802fe9eac834128ae", + "name": "pytest-pep8", + "sha256": "cd892b4884bca7b0d68f82fed3c87100c88df19525611b4725cde3b30dac569c", + "size": 11166, + "subdir": "linux-64", + "timestamp": 1537826940133, + "version": "1.0.6" + }, + "pytest-pep8-1.0.6-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pep8 >=1.3", + "pytest >=2.4.2", + "pytest-cache", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1e62d4048e19339741ee0e7bdeb109ca", + "name": "pytest-pep8", + "sha256": "23fd5785cb4af743c373ee163de8984e53891d2a4a7417ce58593681b7840635", + "size": 11131, + "subdir": "linux-64", + "timestamp": 1537826939028, + "version": "1.0.6" + }, + "pytest-pep8-1.0.6-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pep8 >=1.3", + "pytest >=2.4.2", + "pytest-cache", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e3eb877373dc596c9c1ffe68e70cb67d", + "name": "pytest-pep8", + "sha256": "1ff6a18b53486731a71f8056922cb14857c08285506f678a4be6066a8b86f21a", + "size": 11238, + "subdir": "linux-64", + "timestamp": 1537826858325, + "version": "1.0.6" + }, + "pytest-remotedata-0.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "bc8bcd32173afbf83de1201f28f3dc00", + "name": "pytest-remotedata", + "sha256": "8ee64a253bcdc58b8f4e2b0f379c8112d6a1590076777ca15569b756c122cd41", + "size": 16970, + "subdir": "linux-64", + "timestamp": 1518731322957, + "version": "0.2.0" + }, + "pytest-remotedata-0.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD", + "md5": "b6945ea733759da612cbdf9cc658ec4f", + "name": "pytest-remotedata", + "sha256": "59f37437cb2b3d48c4ddb7119d837095b86a31301e2abd6fba6b10fd1a189ce4", + "size": 17294, + "subdir": "linux-64", + "timestamp": 1518731311711, + "version": "0.2.0" + }, + "pytest-remotedata-0.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "16c607aa0c9bbbd064db8282841b1a79", + "name": "pytest-remotedata", + "sha256": "b6cdbb220643812ffb3e64ec22ef52a2dcfb14d99ff23a568ec8e2aeddda26a8", + "size": 17172, + "subdir": "linux-64", + "timestamp": 1518731308750, + "version": "0.2.0" + }, + "pytest-remotedata-0.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "1672bd8e2f9f85ccf4c0cfb46362c0c3", + "name": "pytest-remotedata", + "sha256": "6d46ea3aae2f29ac6b73a816307bd788eec724fb2e615923b2534adcef9578c3", + "size": 12058, + "subdir": "linux-64", + "timestamp": 1524578574776, + "version": "0.2.1" + }, + "pytest-remotedata-0.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD", + "md5": "e6d081cc5c6f413200e4e91c15b53511", + "name": "pytest-remotedata", + "sha256": "0cc1b34bd62e88787bb660407e7117a64fe248b40b35329b12b50c9adb41c293", + "size": 12041, + "subdir": "linux-64", + "timestamp": 1524578501340, + "version": "0.2.1" + }, + "pytest-remotedata-0.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "7c827ab68ad3552e86de0a21cb9c45fb", + "name": "pytest-remotedata", + "sha256": "9f144f80f2ba0f6861f9a840b47287e6f5449eb6d3d57800af797cc98737ab71", + "size": 11980, + "subdir": "linux-64", + "timestamp": 1524578580243, + "version": "0.2.1" + }, + "pytest-remotedata-0.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "bac1331e703ea38956de445f31c8de03", + "name": "pytest-remotedata", + "sha256": "80524b4345849034528aa934cd41e4513908c56980c41316c11bd0a89263dda9", + "size": 12838, + "subdir": "linux-64", + "timestamp": 1528149810466, + "version": "0.3.0" + }, + "pytest-remotedata-0.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD", + "md5": "8d20545716d3f84969ac61d716e52b45", + "name": "pytest-remotedata", + "sha256": "7e5786653a150adf22cdb5ac47637d3d70568b21c72f13cc3764871d6a3a4db1", + "size": 12851, + "subdir": "linux-64", + "timestamp": 1528149822373, + "version": "0.3.0" + }, + "pytest-remotedata-0.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "0ae91f93299af9c6105b2d247197d9a4", + "name": "pytest-remotedata", + "sha256": "1fb133700590f1d319d43981a1538be3828b58887c6b0fa97c5b44efacf0939c", + "size": 12837, + "subdir": "linux-64", + "timestamp": 1528149769942, + "version": "0.3.0" + }, + "pytest-remotedata-0.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD", + "md5": "bdda39791ac14d1efb7b02f3db5cf5b2", + "name": "pytest-remotedata", + "sha256": "73d765b543a0016835ea16d9923c94ca4b7f50bf8f4b59c62152ccd4a27dd638", + "size": 12755, + "subdir": "linux-64", + "timestamp": 1530738022655, + "version": "0.3.0" + }, + "pytest-remotedata-0.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "169b367e418f7eab82dbef0a7126dbe0", + "name": "pytest-remotedata", + "sha256": "f2ac5d081d92772abeeadc334318a9241b0591a18ac6dc91085c886a801b8d63", + "size": 14113, + "subdir": "linux-64", + "timestamp": 1541036694238, + "version": "0.3.1" + }, + "pytest-remotedata-0.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "eab177b2e094ea49349ed99bbce06e54", + "name": "pytest-remotedata", + "sha256": "ebe0d4490d82f73416570dd1e9708bd327a4624f6bf4fc5e0f6b868aba697a2d", + "size": 13979, + "subdir": "linux-64", + "timestamp": 1541036708622, + "version": "0.3.1" + }, + "pytest-remotedata-0.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD", + "md5": "b09726e5e903adc809be57fc79c553e3", + "name": "pytest-remotedata", + "sha256": "3be2051bae2cae5419522984ea1bdf7b98a7cd0b7fb9e2055908d9f41e007779", + "size": 13996, + "subdir": "linux-64", + "timestamp": 1541036669142, + "version": "0.3.1" + }, + "pytest-remotedata-0.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD", + "md5": "7ca139a5f3bf6e3fb6babb100a7b1df3", + "name": "pytest-remotedata", + "sha256": "509dd678857aa5c65152a9cf6225ca86e343230d7e9e3f404332f4ec08ba1f23", + "size": 15251, + "subdir": "linux-64", + "timestamp": 1564704264904, + "version": "0.3.2" + }, + "pytest-remotedata-0.3.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD", + "md5": "f5e71639fe1b9e3ad9b8ae84a4e197b9", + "name": "pytest-remotedata", + "sha256": "8b36a42add865f886368c0d966a07790cbed74a5afbd398aa78bdb5e415ba1e3", + "size": 14443, + "subdir": "linux-64", + "timestamp": 1640810602845, + "version": "0.3.2" + }, + "pytest-remotedata-0.3.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "BSD", + "md5": "18093b6b4322d4420a6f53f43bfaa087", + "name": "pytest-remotedata", + "sha256": "0c4a4b611ff0594b289e2e242aa5aa1e02579a3f0641ff3f0d2491721cd0e154", + "size": 16595, + "subdir": "linux-64", + "timestamp": 1676845526578, + "version": "0.3.2" + }, + "pytest-remotedata-0.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD", + "md5": "9a44e1926529ddc4b7a9f527ef52d7b7", + "name": "pytest-remotedata", + "sha256": "69b6a67033f92f82af67b693bd32e06849f13ec3fe91074fe935c36b10d2e637", + "size": 15280, + "subdir": "linux-64", + "timestamp": 1564704312589, + "version": "0.3.2" + }, + "pytest-remotedata-0.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD", + "md5": "b7ffb21301fe889148b431b9b4d66c0b", + "name": "pytest-remotedata", + "sha256": "fd4abedfb9ded9f9db554774c807f57ed8fe01cee394552328d062a070d58e55", + "size": 15404, + "subdir": "linux-64", + "timestamp": 1564704282978, + "version": "0.3.2" + }, + "pytest-remotedata-0.3.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD", + "md5": "433a61c189fc5cacc82d7468892b0ad9", + "name": "pytest-remotedata", + "sha256": "7b44b1a93f29e4e826d0b88f3e754904f032e89a36fb89697405afd2a8afae69", + "size": 14295, + "subdir": "linux-64", + "timestamp": 1574169784282, + "version": "0.3.2" + }, + "pytest-remotedata-0.3.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=3.1", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD", + "md5": "834f5cd963e207a4fda3bb434391caf4", + "name": "pytest-remotedata", + "sha256": "f0aec0ae4f5795f7c2d08fd6ac11389986fdcc0d9131bf46a39477784b140ca7", + "size": 15967, + "subdir": "linux-64", + "timestamp": 1607625798550, + "version": "0.3.2" + }, + "pytest-runner-2.11.1-py27he057ec9_0.conda": { + "build": "py27he057ec9_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fae92e1b4c2d937465f0acaa3725c1fe", + "name": "pytest-runner", + "sha256": "5f7185397039aa553ed0ee644954a3e27cbfe5cae38397f534a87ffcf065a709", + "size": 11511, + "subdir": "linux-64", + "timestamp": 1505691537032, + "version": "2.11.1" + }, + "pytest-runner-2.11.1-py35hed12c2c_0.conda": { + "build": "py35hed12c2c_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1589bfb3baee6c543fe83071a3cb1b16", + "name": "pytest-runner", + "sha256": "5036a208f333a9d3a1cb46602262d65594462b488b7c1a1c8af4f4fa01ae6be0", + "size": 11757, + "subdir": "linux-64", + "timestamp": 1505691548081, + "version": "2.11.1" + }, + "pytest-runner-2.11.1-py36h66b2b85_0.conda": { + "build": "py36h66b2b85_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "770295764eb8e409c7d97d579785fe42", + "name": "pytest-runner", + "sha256": "8c2531419aacbfaca5c8a677f930fd68353d6c78a32ddf8449bb3d7c0c023947", + "size": 11560, + "subdir": "linux-64", + "timestamp": 1505691559188, + "version": "2.11.1" + }, + "pytest-runner-3.0-py27h9dcb770_0.conda": { + "build": "py27h9dcb770_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2423eac9c7280c4ce65e2fab4b47c748", + "name": "pytest-runner", + "sha256": "501d5c7a67a6493a3e6d7f655b061463c9d480ef2252d8a4c1d9fda428a0f8e5", + "size": 12339, + "subdir": "linux-64", + "timestamp": 1509208000887, + "version": "3.0" + }, + "pytest-runner-3.0-py35h57e6dd6_0.conda": { + "build": "py35h57e6dd6_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d735a356f9ae431d0c69f1e0f89b542d", + "name": "pytest-runner", + "sha256": "441f12a246f778d1193a093cf0e661d44c87af5667234eb981df495ef1dcd443", + "size": 12351, + "subdir": "linux-64", + "timestamp": 1509207983729, + "version": "3.0" + }, + "pytest-runner-3.0-py36hd5415d6_0.conda": { + "build": "py36hd5415d6_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77046ccf1eec51b5fa88fa7694558034", + "name": "pytest-runner", + "sha256": "36d3bd699555a55e5a1311f02569f7beb85e79d8b06b180543883132c20dd930", + "size": 12238, + "subdir": "linux-64", + "timestamp": 1509207983855, + "version": "3.0" + }, + "pytest-runner-4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "25a7aab1f6290ea5c538d98bfe36bdf1", + "name": "pytest-runner", + "sha256": "fe8c309e91dca24a3361c7c2825f772e74e99f14d001c99e8ff823c5cc1742d0", + "size": 11706, + "subdir": "linux-64", + "timestamp": 1519071844523, + "version": "4.0" + }, + "pytest-runner-4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fda26bb227a3c0cc061b614ea601eb61", + "name": "pytest-runner", + "sha256": "ddab02dc00daa366442c39d18c8f3037032b6b5379ffb164b304253c76d7ae58", + "size": 11758, + "subdir": "linux-64", + "timestamp": 1519071856587, + "version": "4.0" + }, + "pytest-runner-4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3fb276c42a84450ad88b83d421db705a", + "name": "pytest-runner", + "sha256": "759553fe73f1fb03a59ec58c8226c312883ce0640d663edf1632b23771a09f5a", + "size": 11652, + "subdir": "linux-64", + "timestamp": 1519071858643, + "version": "4.0" + }, + "pytest-runner-4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a61cca851ce8b397e457788f30b11071", + "name": "pytest-runner", + "sha256": "a7637babceee90238f11803191707e0d4043920336b6b5bcfa2c8b09ef7e7589", + "size": 11918, + "subdir": "linux-64", + "timestamp": 1522194025006, + "version": "4.2" + }, + "pytest-runner-4.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "30bd11074fbbcabecd06c826f67887ee", + "name": "pytest-runner", + "sha256": "b386ef6353bde2743037b8f640bf3f1003d366011edcf4b748d19921912fe34e", + "size": 12054, + "subdir": "linux-64", + "timestamp": 1522194394243, + "version": "4.2" + }, + "pytest-runner-4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15e4decb6043e9f4487778196f4ff3e7", + "name": "pytest-runner", + "sha256": "30ac691b5b67fd660806902e8e7bec7b8eafaff4406f0514037a8b43abc5ea8c", + "size": 12008, + "subdir": "linux-64", + "timestamp": 1522194029097, + "version": "4.2" + }, + "pytest-runner-4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3aa025d0a7fd4e1c39a19013220c2b4", + "name": "pytest-runner", + "sha256": "9ea8fc41782e83291fc7ff47793bf0a09b1e1fbb21e8e16ad68e7259bf3092ab", + "size": 11765, + "subdir": "linux-64", + "timestamp": 1530733488016, + "version": "4.2" + }, + "pytest-runner-6.0.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.10,<3.11.0a0", + "setuptools >=56" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6956994b797742c656973ac05c7a6b49", + "name": "pytest-runner", + "sha256": "03ebed5992cfeb91ba1a0df81bb75342ce91ac77e170e9ad0ff3de1c143b1ef2", + "size": 14458, + "subdir": "linux-64", + "timestamp": 1668612112060, + "version": "6.0.0" + }, + "pytest-runner-6.0.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.11,<3.12.0a0", + "setuptools >=56" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "50274fd196b1ca8ee79394deece87c77", + "name": "pytest-runner", + "sha256": "39cf6b9bc122eefe87c62d6b5f4aca3801bb1e4294778352dd56c0474d978179", + "size": 16062, + "subdir": "linux-64", + "timestamp": 1676823008358, + "version": "6.0.0" + }, + "pytest-runner-6.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.7,<3.8.0a0", + "setuptools >=56" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "40d6cbf475e84d8399cf6d4284b22239", + "name": "pytest-runner", + "sha256": "e3b8dd21f20271cfe3407ec6a5effe039df28b61c3589b7330be1a44098e834d", + "size": 14363, + "subdir": "linux-64", + "timestamp": 1668612025028, + "version": "6.0.0" + }, + "pytest-runner-6.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.8,<3.9.0a0", + "setuptools >=56" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb73060fe1aeae0fe146c5f2444c5a34", + "name": "pytest-runner", + "sha256": "98c4ccfcc316713dc7a717815df6fe9241981e8d3cc49d1e20faaab48f3b40f9", + "size": 14372, + "subdir": "linux-64", + "timestamp": 1668612054270, + "version": "6.0.0" + }, + "pytest-runner-6.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.9,<3.10.0a0", + "setuptools >=56" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ab6e62bdac999223217b8424558103a", + "name": "pytest-runner", + "sha256": "8bfc57b10e7aa8fd8b3c69d03d4c6cfc7e3a10e4c4031ca9fe549bc60230cbc9", + "size": 14412, + "subdir": "linux-64", + "timestamp": 1668612083172, + "version": "6.0.0" + }, + "pytest-selenium-1.11.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=2.7,<2.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "8fee9798708c3b910a2b1c2bac0d4747", + "name": "pytest-selenium", + "sha256": "106c75e909a810c6e1b190abe76ee89f8617582b613fe036cba71c7e92c1e17d", + "size": 28249, + "subdir": "linux-64", + "timestamp": 1518721768978, + "version": "1.11.1" + }, + "pytest-selenium-1.11.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.5,<3.6.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "c26fa340336db365d1bb05b4386e0d70", + "name": "pytest-selenium", + "sha256": "914643bc77c20663d801f5366b6faeecf8a0ecbc487585c25f6a10eb47ad5e01", + "size": 28790, + "subdir": "linux-64", + "timestamp": 1518721955524, + "version": "1.11.1" + }, + "pytest-selenium-1.11.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.6,<3.7.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "1c78387abd6b0f1ed30c9601137c42bf", + "name": "pytest-selenium", + "sha256": "7fa3e0954dae9fc84078e3928d84b59b5efce4f87e13dbb2d561d76333882dd5", + "size": 28542, + "subdir": "linux-64", + "timestamp": 1518721819976, + "version": "1.11.1" + }, + "pytest-selenium-1.12.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=2.7,<2.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "e992f26bb766b99bffbe2373a9d6c83d", + "name": "pytest-selenium", + "sha256": "4f5f4e0842ddad7b8eae9b8987bee76c235e05175913c7e7070a9226976a3aff", + "size": 29331, + "subdir": "linux-64", + "timestamp": 1522194675628, + "version": "1.12.0" + }, + "pytest-selenium-1.12.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.5,<3.6.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "61997755580d5d342ac3e0121b9522c6", + "name": "pytest-selenium", + "sha256": "b772a1e556e7a2885b22bdd995806b9f376895728c4b1b4fadebcfaa983f53f6", + "size": 29499, + "subdir": "linux-64", + "timestamp": 1522194670181, + "version": "1.12.0" + }, + "pytest-selenium-1.12.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.6,<3.7.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "4e5ecf1a5e86290c0ef3fa9cf960caa6", + "name": "pytest-selenium", + "sha256": "5e551dc6ef37b9ebb69e60325fe123da6e05008e188305883f2fe225b02bad20", + "size": 29197, + "subdir": "linux-64", + "timestamp": 1522194681223, + "version": "1.12.0" + }, + "pytest-selenium-1.13.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=2.7,<2.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "91349edb4799df14b9e0c91c9a74a7ac", + "name": "pytest-selenium", + "sha256": "3871b5596c529a370d0e697a1c6583e7fcc1bfe180651118d53a7dcb7cf70540", + "size": 31162, + "subdir": "linux-64", + "timestamp": 1527875963888, + "version": "1.13.0" + }, + "pytest-selenium-1.13.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.5,<3.6.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "2af72898760b87fad90b4f5af1486c6c", + "name": "pytest-selenium", + "sha256": "9c67bcbde9213ef20403877b265902b8c7b4bdbf436f4a5f5468e97117d3a8db", + "size": 31574, + "subdir": "linux-64", + "timestamp": 1527876007287, + "version": "1.13.0" + }, + "pytest-selenium-1.13.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.6,<3.7.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "e565d544c158b2c17e66c87b0efdaaca", + "name": "pytest-selenium", + "sha256": "c58e39cb4f1db5f5bdaca05ed96e83f9bb1f114b8af4b0ddb51cfe5c24c516df", + "size": 31315, + "subdir": "linux-64", + "timestamp": 1527875939070, + "version": "1.13.0" + }, + "pytest-selenium-1.13.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.7,<3.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "25ef28a5d6a856cf09b60f9daefdc017", + "name": "pytest-selenium", + "sha256": "98f0c79a68c4bd4717fc6ca083d7767ef87426a24a2b86689065ddded6003b99", + "size": 31458, + "subdir": "linux-64", + "timestamp": 1530922469547, + "version": "1.13.0" + }, + "pytest-selenium-1.14.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=2.7,<2.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "f29efc8a5c46f557e73d38fa7d73de19", + "name": "pytest-selenium", + "sha256": "c61490b711cc078e441b7e49cf20ee754a6041d8c51c026ef4af0ca7ba160bc8", + "size": 31373, + "subdir": "linux-64", + "timestamp": 1535420662637, + "version": "1.14.0" + }, + "pytest-selenium-1.14.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.5,<3.6.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "166f900014ff09af4c8f3610e4792688", + "name": "pytest-selenium", + "sha256": "baae06e2ad06ad61d5326af1d62323f52374769e130998c201363d083374b213", + "size": 31832, + "subdir": "linux-64", + "timestamp": 1535420795795, + "version": "1.14.0" + }, + "pytest-selenium-1.14.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.6,<3.7.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "84f6de8692b115c46fa57da6faa00820", + "name": "pytest-selenium", + "sha256": "041f312941df64c78f6b62c340804cccf48309456f3def794f226af6e7c7f01b", + "size": 31531, + "subdir": "linux-64", + "timestamp": 1535420759890, + "version": "1.14.0" + }, + "pytest-selenium-1.14.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.7,<3.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "5e4610c24ff843882d2a7222b1b3bae0", + "name": "pytest-selenium", + "sha256": "afb60e3308127ce4eff1460254ea3300691ebeda195f01019db8fe147de03dd7", + "size": 31584, + "subdir": "linux-64", + "timestamp": 1535420665891, + "version": "1.14.0" + }, + "pytest-selenium-1.15.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=2.7,<2.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "9ac2dfde19332226a4a0d72c82bca308", + "name": "pytest-selenium", + "sha256": "b7e9567003ef8502405e0ff658f336632d7438e5ef9fb7151d110a3dc753dadc", + "size": 34473, + "subdir": "linux-64", + "timestamp": 1547479297350, + "version": "1.15.1" + }, + "pytest-selenium-1.15.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.6,<3.7.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "086bf74f3f353ee3c3cf4b4ea6436a5b", + "name": "pytest-selenium", + "sha256": "e63c386569cd61459c4fcc5ce7d89b609f56d51d049df50d623675018e93c8f1", + "size": 35046, + "subdir": "linux-64", + "timestamp": 1547479293374, + "version": "1.15.1" + }, + "pytest-selenium-1.15.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.7,<3.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "5f8913ce50cd79ddad78644bdec894b0", + "name": "pytest-selenium", + "sha256": "a429762f494fc4507301ea1ce14aba3d825cb6679f13213e39ae2bd63a006851", + "size": 34873, + "subdir": "linux-64", + "timestamp": 1547479288329, + "version": "1.15.1" + }, + "pytest-selenium-1.16.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=2.7,<2.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "15aecb9f04a9328915f4f1e0110d631b", + "name": "pytest-selenium", + "sha256": "cd3213956c03487e60a566b7c3e8a3b1d959d2875f6ef10ae2d85188153354df", + "size": 34158, + "subdir": "linux-64", + "timestamp": 1550355248170, + "version": "1.16.0" + }, + "pytest-selenium-1.16.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.6,<3.7.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "4fa636afc609731feb400115f0f31a45", + "name": "pytest-selenium", + "sha256": "65aebd04e54a5705247783d8220af3cd5338ef675bebdb96f7c5026abb54984c", + "size": 34308, + "subdir": "linux-64", + "timestamp": 1550355278921, + "version": "1.16.0" + }, + "pytest-selenium-1.16.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.0", + "pytest-base-url", + "pytest-html >=1.14.0", + "pytest-variables >=1.5.0", + "python >=3.7,<3.8.0a0", + "requests", + "selenium >=3.0.0" + ], + "license": "MPL 2.0", + "md5": "2f3f61b1a3ecbf732038a7b63437107f", + "name": "pytest-selenium", + "sha256": "ebe1e59bf784dfa3d5d8e86342acb11365f937421a88442a750658ee2cbc53a8", + "size": 34338, + "subdir": "linux-64", + "timestamp": 1550355177564, + "version": "1.16.0" + }, + "pytest-timeout-1.2.0-py27h5d547cd_0.conda": { + "build": "py27h5d547cd_0", + "build_number": 0, + "depends": [ + "pytest >=2.8.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "3495abd7706479a65ca05a1823b09430", + "name": "pytest-timeout", + "sha256": "c70e51b704bf45f5a9fbc76a6c54804a25a1523bc11828ef854e5a770f8a0755", + "size": 15414, + "subdir": "linux-64", + "timestamp": 1508215980964, + "version": "1.2.0" + }, + "pytest-timeout-1.2.0-py35h96a0e9c_0.conda": { + "build": "py35h96a0e9c_0", + "build_number": 0, + "depends": [ + "pytest >=2.8.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "7a1c4f400d39eedf000e2d1ce24a7402", + "name": "pytest-timeout", + "sha256": "d2786b6b4b7c8b370cb71fcb7a5b00a8d726bae28d518a5a69c523b7acfd12d8", + "size": 15311, + "subdir": "linux-64", + "timestamp": 1508215899467, + "version": "1.2.0" + }, + "pytest-timeout-1.2.0-py36h0fa9b50_0.conda": { + "build": "py36h0fa9b50_0", + "build_number": 0, + "depends": [ + "pytest >=2.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "684b5efdd57ecf15c377a9caf3725b0b", + "name": "pytest-timeout", + "sha256": "60485a0bece3d43cb7094afc8d5bdef4a1ee128f5134163897bfa5fe6c1e0048", + "size": 15255, + "subdir": "linux-64", + "timestamp": 1508215552917, + "version": "1.2.0" + }, + "pytest-timeout-1.2.1-py27h0aba353_0.conda": { + "build": "py27h0aba353_0", + "build_number": 0, + "depends": [ + "pytest >=2.8.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "653db538ebc36c9fdd59ea8da1d24434", + "name": "pytest-timeout", + "sha256": "d07004b491d1ad0fe5fe0955872da29e3df01e793800893435c81f5a11baa1e4", + "size": 15703, + "subdir": "linux-64", + "timestamp": 1512066331468, + "version": "1.2.1" + }, + "pytest-timeout-1.2.1-py35h6d119eb_0.conda": { + "build": "py35h6d119eb_0", + "build_number": 0, + "depends": [ + "pytest >=2.8.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "f4dbf0515d574fc6fc98d80ec5a5b436", + "name": "pytest-timeout", + "sha256": "cc8901730b5c2992b08e577d425e9aac060c64d1942cc4740f9ed398e5b7e8ea", + "size": 15770, + "subdir": "linux-64", + "timestamp": 1512066337113, + "version": "1.2.1" + }, + "pytest-timeout-1.2.1-py36hf4a559a_0.conda": { + "build": "py36hf4a559a_0", + "build_number": 0, + "depends": [ + "pytest >=2.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "03784aa2815cbbd52d0a82c39a839e98", + "name": "pytest-timeout", + "sha256": "a4bfb9c5f8c0674ef184ab8297338abe8161588a73489969388eb04af5fabdff", + "size": 15535, + "subdir": "linux-64", + "timestamp": 1512066342649, + "version": "1.2.1" + }, + "pytest-timeout-1.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "a3c72418bf47eb2b9a595b7dfb182842", + "name": "pytest-timeout", + "sha256": "a407ca2fa41d6abe15798f6ff18546a204f9fb5228e24b870de74099a20dbd00", + "size": 16638, + "subdir": "linux-64", + "timestamp": 1529422873605, + "version": "1.3.0" + }, + "pytest-timeout-1.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "ab97897ab6e2bb1523ae107f457d667a", + "name": "pytest-timeout", + "sha256": "c912a61a8452f6f3e7d3a97c0d5c06f65c4ba0f00ebd643bec63f3de70a142b4", + "size": 16512, + "subdir": "linux-64", + "timestamp": 1529422873964, + "version": "1.3.0" + }, + "pytest-timeout-1.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d6fe86b82d2d85cdea9461a0839bb563", + "name": "pytest-timeout", + "sha256": "c450c753ee89c6a5ea7bece9715617a078eea00e3901170825555cbacc2a9248", + "size": 16381, + "subdir": "linux-64", + "timestamp": 1529422848580, + "version": "1.3.0" + }, + "pytest-timeout-1.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5991bf73a51655fa76e9b7df0ae8cd89", + "name": "pytest-timeout", + "sha256": "a31e9a0e08c27b6065218213235b92846f87a3dea8ccd1487fc9c7b1e81dc5c6", + "size": 16421, + "subdir": "linux-64", + "timestamp": 1530922507213, + "version": "1.3.0" + }, + "pytest-timeout-1.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9e5e0c8b41a6a3ebc33ed76c79f2d7cc", + "name": "pytest-timeout", + "sha256": "4510faca52d20d4f0646246802d037c8f5514bcdefe2f7e9f1d3ec2a0518ea6c", + "size": 16757, + "subdir": "linux-64", + "timestamp": 1535421046530, + "version": "1.3.2" + }, + "pytest-timeout-1.3.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "7b2a62b0f144949d286a67a1c9bb4bdf", + "name": "pytest-timeout", + "sha256": "fed16738bcd10f1f774f50c94c7dfaaff758c650054aba459d21ca65728a0dd6", + "size": 16678, + "subdir": "linux-64", + "timestamp": 1535420986044, + "version": "1.3.2" + }, + "pytest-timeout-1.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "959b34ce622f9724957ab5dab75fdc17", + "name": "pytest-timeout", + "sha256": "a51efa9d070c5bbce664ba6ee93cdc7b95d582cbf0eb20541b9aaebb88ba671c", + "size": 16616, + "subdir": "linux-64", + "timestamp": 1535421033730, + "version": "1.3.2" + }, + "pytest-timeout-1.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "31e6e5b039b8e6944dc1fb5e6c8526d9", + "name": "pytest-timeout", + "sha256": "fe3cb2191feade70e4d49fef74b6218fbca283dbe2b43adcb743aef11c797472", + "size": 16621, + "subdir": "linux-64", + "timestamp": 1535421051104, + "version": "1.3.2" + }, + "pytest-timeout-1.3.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ae17d52c94a2f7b8306a9671e691f179", + "name": "pytest-timeout", + "sha256": "b51a1648b25697c0e0b77a93d01181aaf1403b695443d9e13c79cdb3c86e8466", + "size": 17944, + "subdir": "linux-64", + "timestamp": 1542408590606, + "version": "1.3.3" + }, + "pytest-timeout-1.3.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0e366f1337d6147f93d70a9163f53792", + "name": "pytest-timeout", + "sha256": "d6a54b711a0086e561be3c0124dcbde0eebde14914fc003cf949299d7056014d", + "size": 17665, + "subdir": "linux-64", + "timestamp": 1542408614791, + "version": "1.3.3" + }, + "pytest-timeout-1.3.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "55fd152a5369bf618075df81353ef82b", + "name": "pytest-timeout", + "sha256": "cfe4bfb10f4d00fdc01f884a3ed52e0d1a55777d9955bccf5fe209529382d74c", + "size": 17715, + "subdir": "linux-64", + "timestamp": 1542408561305, + "version": "1.3.3" + }, + "pytest-timeout-1.3.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=3.6.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "470cf2038603172b0520065b705d8118", + "name": "pytest-timeout", + "sha256": "ba1f8d177078f0993c35eff454a9bba68aa6c486e98a70ce29ea40d44e5cd590", + "size": 17447, + "subdir": "linux-64", + "timestamp": 1574169799097, + "version": "1.3.3" + }, + "pytest-tornado-0.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=2.7,<2.8.0a0", + "tornado >=4" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "76c8b9e5c22f5dc49eb3782860605ae2", + "name": "pytest-tornado", + "sha256": "9f735bd6ac825e98331653c215ea26c2d8b1f78126492ee977cff75168089f7e", + "size": 14480, + "subdir": "linux-64", + "timestamp": 1536857589244, + "version": "0.5.0" + }, + "pytest-tornado-0.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.5,<3.6.0a0", + "tornado >=4" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9762087c5fc890553396d2963e7f82c7", + "name": "pytest-tornado", + "sha256": "a47d8618b786470cf82620d40f19f90eeec01760e5a1dbe314ab3772497aff71", + "size": 14706, + "subdir": "linux-64", + "timestamp": 1536857688719, + "version": "0.5.0" + }, + "pytest-tornado-0.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "08ceb4cdc7c432b512a674f29e029c1c", + "name": "pytest-tornado", + "sha256": "06f89d2d88f1688229481e2238d0770e1998cb339cd5e3d3c7180a18dfb58afa", + "size": 14507, + "subdir": "linux-64", + "timestamp": 1536857706114, + "version": "0.5.0" + }, + "pytest-tornado-0.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest", + "python >=3.7,<3.8.0a0", + "tornado >=4" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2b51d380929301d667e08f55253c7ecf", + "name": "pytest-tornado", + "sha256": "7c310a6216109c583b94a2418cc9e66367b16369aff313f5d28aa0adc90596cb", + "size": 14607, + "subdir": "linux-64", + "timestamp": 1536857564438, + "version": "0.5.0" + }, + "pytest-variables-1.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "eb9fd2cea0a956ff37c5cf81f238bb64", + "name": "pytest-variables", + "sha256": "8395189bb117b0568d6c10a62982ec8cea8d703f0e4b88ad3f1a062803d88c42", + "size": 9611, + "subdir": "linux-64", + "timestamp": 1518721219631, + "version": "1.7.0" + }, + "pytest-variables-1.7.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "fadd050dcae4ecfcd90aed8a3616103c", + "name": "pytest-variables", + "sha256": "a5ea11f02b990a15eec6084c1d7e4aea61278d1ca2f12de3dce2cc1d52247d08", + "size": 9664, + "subdir": "linux-64", + "timestamp": 1518721293798, + "version": "1.7.0" + }, + "pytest-variables-1.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "5cc172540a49c45178eeed6d73aa8db5", + "name": "pytest-variables", + "sha256": "8222c8c8d76d0cd30b11bfef59ccfab3943d7d602f3c702e3487cc53ec3450d0", + "size": 9610, + "subdir": "linux-64", + "timestamp": 1518721293301, + "version": "1.7.0" + }, + "pytest-variables-1.7.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "90bb76db79bccff8b1909161b51e60a3", + "name": "pytest-variables", + "sha256": "060f85cabe04917f0397f6bbc154aae8c78de6f614b6b3b5265db85b285f1938", + "size": 9506, + "subdir": "linux-64", + "timestamp": 1522790830613, + "version": "1.7.1" + }, + "pytest-variables-1.7.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "e7d06033a92ca0a052b4a8e43c0318d1", + "name": "pytest-variables", + "sha256": "49c7fdf24a265ca6c0d1c5b7123c5cf6e20ecafd0e5bbc6c4ea33517ffaef8f8", + "size": 9527, + "subdir": "linux-64", + "timestamp": 1522790876113, + "version": "1.7.1" + }, + "pytest-variables-1.7.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "e25d6d0218782f0837b5029a302cf8a6", + "name": "pytest-variables", + "sha256": "efd6b296bf6dd886529f4b88ef29144f9010e9d9649f9f3df25a6dd5f5ba1845", + "size": 9459, + "subdir": "linux-64", + "timestamp": 1522790879252, + "version": "1.7.1" + }, + "pytest-variables-1.7.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "8889ea29ca7cccaeb7e292693a18174e", + "name": "pytest-variables", + "sha256": "a1e6de2f9f2fbdb885aaa1db87a8ec99ae4ba4015fb83a69ce699bf9db638136", + "size": 9351, + "subdir": "linux-64", + "timestamp": 1530922384762, + "version": "1.7.1" + }, + "pytest-variables-1.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "4d3095811a9be5ee61bc498872628436", + "name": "pytest-variables", + "sha256": "2e66b025fb9170570cf8f2e40a4553dff696c9a3d54c346da3622989397b7f03", + "size": 10895, + "subdir": "linux-64", + "timestamp": 1569375948230, + "version": "1.8.0" + }, + "pytest-variables-1.8.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "238674f921fa3a20836d83cf65135b47", + "name": "pytest-variables", + "sha256": "9b9db8d0dbbeb4208e6fdf33c110f763828a46e89a94e333119efe09ea5512a1", + "size": 9991, + "subdir": "linux-64", + "timestamp": 1640810623505, + "version": "1.8.0" + }, + "pytest-variables-1.8.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "6de149155083f7fda8dc17535c6c3fdf", + "name": "pytest-variables", + "sha256": "ee186f373373dac3b16cfa4f1a819fba0b7871ef069f31d68149e315516a9b53", + "size": 11737, + "subdir": "linux-64", + "timestamp": 1676861382639, + "version": "1.8.0" + }, + "pytest-variables-1.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "1eb0202246b1bd4e1bae95c9cf201124", + "name": "pytest-variables", + "sha256": "3c576c9ec56e2dbaecd5bf86f15b0326764cb5e80af3b6cb0b993fca32a5400c", + "size": 10895, + "subdir": "linux-64", + "timestamp": 1569375959473, + "version": "1.8.0" + }, + "pytest-variables-1.8.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "16b9993870ea51020ec54b94e6fea4f1", + "name": "pytest-variables", + "sha256": "75f4de9253724156adb39a9cd921715f683765e56b1891cc1bed06156123d2da", + "size": 10932, + "subdir": "linux-64", + "timestamp": 1611764499306, + "version": "1.8.0" + }, + "pytest-variables-1.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "8244e924838f2a0eabffac9e19656c5f", + "name": "pytest-variables", + "sha256": "b3bc1f9060f3be41e8be33296442479551883809e248402ffc3159205be4bbe9", + "size": 10884, + "subdir": "linux-64", + "timestamp": 1569375958422, + "version": "1.8.0" + }, + "pytest-variables-1.8.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "b6bdc141b7debb286cdc56e91a36045c", + "name": "pytest-variables", + "sha256": "17c8f133be9ee69f4ca6c0264d46514b849f236fa9b051a0ed49002c243d02e6", + "size": 10907, + "subdir": "linux-64", + "timestamp": 1611763155049, + "version": "1.8.0" + }, + "pytest-variables-1.8.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "45a71daf7b898a6e701f0b201a8b220e", + "name": "pytest-variables", + "sha256": "0560dcd7d609a59e0877f0b11bc388b5756bcfc67c5d7d7c07665330264b3926", + "size": 10302, + "subdir": "linux-64", + "timestamp": 1574169813212, + "version": "1.8.0" + }, + "pytest-variables-1.8.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "cfec6f63adab3a163f81b990a8560ba8", + "name": "pytest-variables", + "sha256": "96ab08f9385e29260f6fa4e75d76d738d96597a6d7539c6e3056f6b7e62e94d4", + "size": 10923, + "subdir": "linux-64", + "timestamp": 1611764482593, + "version": "1.8.0" + }, + "pytest-variables-1.8.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "529f16c48a235ff8beeac0ed7f94d400", + "name": "pytest-variables", + "sha256": "a170fb444fa56c0d5cb964c0d8662dd088ec62285788beb10066ef5bda5d457e", + "size": 10944, + "subdir": "linux-64", + "timestamp": 1611764052599, + "version": "1.8.0" + }, + "pytest-variables-1.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "8b660d52421756d285a723977d6f9e5e", + "name": "pytest-variables", + "sha256": "ab33987e82bed5439b5c6b18c4af986bffa405d9098f6b992fd7aa60daa6a170", + "size": 10261, + "subdir": "linux-64", + "timestamp": 1600459505531, + "version": "1.9.0" + }, + "pytest-variables-1.9.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "d153a006d5082e7ffb4062639190ad2c", + "name": "pytest-variables", + "sha256": "d0627fdce11de90f68980a4116e41c7868491d93137397fc130cd8540c567cb4", + "size": 10242, + "subdir": "linux-64", + "timestamp": 1600459526919, + "version": "1.9.0" + }, + "pytest-variables-1.9.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pytest >=2.4.2", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MPL 2.0", + "license_family": "OTHER", + "md5": "e90638be133ba6f58ed491f7dfc897ed", + "name": "pytest-variables", + "sha256": "913aa8fd9ce6c66c749e93c8387eadb39fcfc6bb717dd3594d8150630d311b82", + "size": 10274, + "subdir": "linux-64", + "timestamp": 1600459512644, + "version": "1.9.0" + }, + "pytest-xdist-1.20.1-py27h6b1c668_0.conda": { + "build": "py27h6b1c668_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9089cd39c972dc5b5aa75b54f5926b90", + "name": "pytest-xdist", + "sha256": "395720effed02552f6475724f89910f22b3919b4c21bb23a5ef61064668236c8", + "size": 50951, + "subdir": "linux-64", + "timestamp": 1511990092900, + "version": "1.20.1" + }, + "pytest-xdist-1.20.1-py35h5ef5961_0.conda": { + "build": "py35h5ef5961_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "b387b3c7cd4bb55ac153168f96c01ffe", + "name": "pytest-xdist", + "sha256": "dec68a820921672d0e8343d8fa2f22bba9251d7f3090ceabd2a18c217ce076ae", + "size": 51567, + "subdir": "linux-64", + "timestamp": 1511990142725, + "version": "1.20.1" + }, + "pytest-xdist-1.20.1-py36hd594dc5_0.conda": { + "build": "py36hd594dc5_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9a361c5f8c1052c5433036d6ec3c5d27", + "name": "pytest-xdist", + "sha256": "1b96cd54c8d807414f3577be0dfd600b7db604601b7be4c4d11cc866c13b2790", + "size": 51130, + "subdir": "linux-64", + "timestamp": 1511990142638, + "version": "1.20.1" + }, + "pytest-xdist-1.22.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "3b68054d9282f94a947873d7f2bd8fa6", + "name": "pytest-xdist", + "sha256": "4c9f16b26144b5f072dba69b9533615b34eaab83d0c6aa5573cd8bd7ba1ea27c", + "size": 50489, + "subdir": "linux-64", + "timestamp": 1519364616378, + "version": "1.22.1" + }, + "pytest-xdist-1.22.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "582316ac2b064f8a6be7597e28148424", + "name": "pytest-xdist", + "sha256": "ff427fe31f6f21dc63e54f06ffba5a99ac4ee897a35bf3466e441be87e3d6a3d", + "size": 51954, + "subdir": "linux-64", + "timestamp": 1519364647680, + "version": "1.22.1" + }, + "pytest-xdist-1.22.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b5bc0a921c066760744b08efc48b999f", + "name": "pytest-xdist", + "sha256": "508eff7018e0623951c9f248bcc787d5cb3b86b9ff20840159dc257fb6622e79", + "size": 50763, + "subdir": "linux-64", + "timestamp": 1519364534914, + "version": "1.22.1" + }, + "pytest-xdist-1.22.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "cd69859e3cfb4db3c4029c5858c8894f", + "name": "pytest-xdist", + "sha256": "0cd2be3210855902ec1aaf1e73dee8fed5ec229289c43ec8aeb206f9fc71fefb", + "size": 50691, + "subdir": "linux-64", + "timestamp": 1522363252424, + "version": "1.22.2" + }, + "pytest-xdist-1.22.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "0ed29ea3661e42e5bbeb8d46b9280679", + "name": "pytest-xdist", + "sha256": "9b40529f2bc97a087fcbfebe29f0f4bbe5d68143eced0b01608b2ea9a75fd30d", + "size": 51406, + "subdir": "linux-64", + "timestamp": 1522363271774, + "version": "1.22.2" + }, + "pytest-xdist-1.22.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "72e5f7c3fb312c59ca3c6e9af3de087d", + "name": "pytest-xdist", + "sha256": "df0c3f966d5826f14b20ba400c3df6ce41639adebae4fea7f8f5f618f389d74a", + "size": 50868, + "subdir": "linux-64", + "timestamp": 1522363284373, + "version": "1.22.2" + }, + "pytest-xdist-1.22.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7dc35783b9efdc28f23a61be7e8d830c", + "name": "pytest-xdist", + "sha256": "c84801c2596a0039bd81da2dff44f83901e1cb60c362297fab9d933dc8b88318", + "size": 51957, + "subdir": "linux-64", + "timestamp": 1530727964475, + "version": "1.22.2" + }, + "pytest-xdist-1.22.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "01bb9742b89bc8f8e7a822192d3304c0", + "name": "pytest-xdist", + "sha256": "a66e72ec2344a24c7cb6cf4c7cc757487b90e3ed0ea95ef9d1f3c87a93f3264e", + "size": 52557, + "subdir": "linux-64", + "timestamp": 1532998023214, + "version": "1.22.5" + }, + "pytest-xdist-1.22.5-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "498459bfb439b7f5624df2200f8bd359", + "name": "pytest-xdist", + "sha256": "2f6b870cd275e02aabd989277c4921d32f5f82e1ff96b11d937c62ce51cfcb3b", + "size": 51866, + "subdir": "linux-64", + "timestamp": 1534347591326, + "version": "1.22.5" + }, + "pytest-xdist-1.22.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "d69d161aea543f9951a0c542893d0a7c", + "name": "pytest-xdist", + "sha256": "d3d6edfa3742444c2e5c08970bf963c6cfc5aa0500bde6b5bd82ca03338d7c54", + "size": 53146, + "subdir": "linux-64", + "timestamp": 1532998156271, + "version": "1.22.5" + }, + "pytest-xdist-1.22.5-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "53f2899cff3630a7f0d0ab170e9df5b5", + "name": "pytest-xdist", + "sha256": "b0abcdded7a91fff8112d9530444a947f85e1b2388f7f14a78eb42f72d6b69ff", + "size": 53130, + "subdir": "linux-64", + "timestamp": 1534347649123, + "version": "1.22.5" + }, + "pytest-xdist-1.22.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "3286e33a1fbadec5808b939296fd6928", + "name": "pytest-xdist", + "sha256": "da6d54d69e6f5feddf132d2d96068956815cacdb72882facf9aa62f85db2ff62", + "size": 52824, + "subdir": "linux-64", + "timestamp": 1532997966102, + "version": "1.22.5" + }, + "pytest-xdist-1.22.5-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "f4630465ba7b9031ad9dfac5d1e6ad4c", + "name": "pytest-xdist", + "sha256": "e7668301a6635c73f8f9a36dd93664bc66e0135370f5cd56d694fe4c81692887", + "size": 52807, + "subdir": "linux-64", + "timestamp": 1534347620440, + "version": "1.22.5" + }, + "pytest-xdist-1.22.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "84ad47815cc0046dbf605c0cb9ee6afe", + "name": "pytest-xdist", + "sha256": "4b2eb001978272487cb9678ab9e9223cffcf903876125805e55624d84c3db7aa", + "size": 53075, + "subdir": "linux-64", + "timestamp": 1532998108711, + "version": "1.22.5" + }, + "pytest-xdist-1.22.5-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "0e15dc343192d8c990317a681f28c4d5", + "name": "pytest-xdist", + "sha256": "513520fd23c9aa488278d5d6d2a3b3b4b592116b633285f17baf2ce28fcb6af1", + "size": 53064, + "subdir": "linux-64", + "timestamp": 1534347677005, + "version": "1.22.5" + }, + "pytest-xdist-1.23.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "80b538dc19182dd05345f10800fc071f", + "name": "pytest-xdist", + "sha256": "a69b78d84e4041b234100315b204e5f09e57db6945610dcb020c496c1c41561d", + "size": 50927, + "subdir": "linux-64", + "timestamp": 1535421334390, + "version": "1.23.0" + }, + "pytest-xdist-1.23.0-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "80fba3ee0a39b35f83340ed0beb249bc", + "name": "pytest-xdist", + "sha256": "bbb274712afcd049fed6090fca710932afa79b9a16c125130c52ec521d74cc05", + "size": 51588, + "subdir": "linux-64", + "timestamp": 1535421381978, + "version": "1.23.0" + }, + "pytest-xdist-1.23.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "020d785204f26cb28eeca3b80afbe446", + "name": "pytest-xdist", + "sha256": "a312d693d222fbd434d2aaf4d03f8c9ed314ae81cfb2dcdfafe3499c7001205a", + "size": 51228, + "subdir": "linux-64", + "timestamp": 1535421317912, + "version": "1.23.0" + }, + "pytest-xdist-1.23.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "f2a19866b6814dafcb07199e72e6ff51", + "name": "pytest-xdist", + "sha256": "bf8ac1e4b7dcd2808cea7e4a38de5981b6cabe1d7767d069376310e69677c799", + "size": 51306, + "subdir": "linux-64", + "timestamp": 1535421354053, + "version": "1.23.0" + }, + "pytest-xdist-1.23.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "97fd157495ae0aaa302561d847a79426", + "name": "pytest-xdist", + "sha256": "11c21f256e125739a2d3b8f1ff7e52d51af53b1fa6045233e4470b7d0d1d4e44", + "size": 53138, + "subdir": "linux-64", + "timestamp": 1539638012664, + "version": "1.23.2" + }, + "pytest-xdist-1.23.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "47f509396cb5916a5547b60c6859799b", + "name": "pytest-xdist", + "sha256": "3a9e454f8215e6cabd4bb675ce4e89b3fa923e34ce49e1c69c43f0bd60f783ee", + "size": 53702, + "subdir": "linux-64", + "timestamp": 1539638034493, + "version": "1.23.2" + }, + "pytest-xdist-1.23.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "11fa36c54dc3842935108a54a9a1ced0", + "name": "pytest-xdist", + "sha256": "281c1cab2b3394f34c550a896a477382b1f64a65b36b07ad38a24d079799cf3a", + "size": 52908, + "subdir": "linux-64", + "timestamp": 1539638028335, + "version": "1.23.2" + }, + "pytest-xdist-1.24.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "056823b9fc74a0a6efaf3dbe16b80ca4", + "name": "pytest-xdist", + "sha256": "c7c7ad9b5f6a8ac8cbf5130b50dadce29a5b03ecdecaab3ae2aa965317e6cfa5", + "size": 53285, + "subdir": "linux-64", + "timestamp": 1541037732425, + "version": "1.24.0" + }, + "pytest-xdist-1.24.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "8b0610ccd7436ec7de3bc7a6b2f90ea8", + "name": "pytest-xdist", + "sha256": "f87734fde6ce2fb2d490053b342fd4826bea3ef30bb8a52091f06fa4bb892790", + "size": 52801, + "subdir": "linux-64", + "timestamp": 1541037787307, + "version": "1.24.0" + }, + "pytest-xdist-1.24.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "ecb42995dd22cf6cd0ffdfdd36a42c17", + "name": "pytest-xdist", + "sha256": "9482be73358f70c0e949b57b49a2c378670ab38b25d68f6634619d061578ee2b", + "size": 52887, + "subdir": "linux-64", + "timestamp": 1541037749977, + "version": "1.24.0" + }, + "pytest-xdist-1.24.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "4be25c350f0b28421e289130d090c41d", + "name": "pytest-xdist", + "sha256": "90f8740b12f00faacae5096aba2fe9eb8bc5fdec9d92c6d8c2a5b221f56661f6", + "size": 53389, + "subdir": "linux-64", + "timestamp": 1542087052314, + "version": "1.24.1" + }, + "pytest-xdist-1.24.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "76ece926e0ad0f19f547aef84725dafd", + "name": "pytest-xdist", + "sha256": "8826ad7bad79e647f1538733863a8e6760b5e9f56caab09acf3180c954fd3f1a", + "size": 52995, + "subdir": "linux-64", + "timestamp": 1542087035766, + "version": "1.24.1" + }, + "pytest-xdist-1.24.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "635a3123586c684b12323f1846fa5536", + "name": "pytest-xdist", + "sha256": "2448abecb160093fe624baa0c11ed12bf979445b91c009e7801a261942df09dd", + "size": 53101, + "subdir": "linux-64", + "timestamp": 1542087036347, + "version": "1.24.1" + }, + "pytest-xdist-1.25.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "32418f85aefe831eb1dc585e0d4fec42", + "name": "pytest-xdist", + "sha256": "b32bceb0ed6986bc628ec22e321e3d05e41d35aa39957b7d0eb7feda6d13fb0d", + "size": 53056, + "subdir": "linux-64", + "timestamp": 1545092750408, + "version": "1.25.0" + }, + "pytest-xdist-1.25.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "b6cfa635513c46864c97d7d2cf0e185a", + "name": "pytest-xdist", + "sha256": "f683f31455a3439ada7b0502a7ebf67122eeb29aee499b9343fb6cac8f0be90b", + "size": 53167, + "subdir": "linux-64", + "timestamp": 1545092778715, + "version": "1.25.0" + }, + "pytest-xdist-1.25.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "fae952987c6565df81a89575b62ce1fa", + "name": "pytest-xdist", + "sha256": "88e0be2e5b98fa7653002e13fe5d1a52d77449e7a486d28308eaf85adc22a1f3", + "size": 53233, + "subdir": "linux-64", + "timestamp": 1545092754408, + "version": "1.25.0" + }, + "pytest-xdist-1.26.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "eb17229a74be9f5d52dac6cb56deda15", + "name": "pytest-xdist", + "sha256": "8b0e3a46f9f680ad16927d2626d2130d05feb72c498f23df2aeda400cbdd607e", + "size": 57394, + "subdir": "linux-64", + "timestamp": 1547924969933, + "version": "1.26.0" + }, + "pytest-xdist-1.26.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "ff0870ac573a443b9e67157ab0ee3283", + "name": "pytest-xdist", + "sha256": "dab4664630946a8079466135b8817a503d5d9d3e7fa94be515854e800d490140", + "size": 58257, + "subdir": "linux-64", + "timestamp": 1547925027301, + "version": "1.26.0" + }, + "pytest-xdist-1.26.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "ac1e5260ad7aebe14b5afafd315535d1", + "name": "pytest-xdist", + "sha256": "a659cc432e92a66267bd3d7a686a6cf66f2b7d45314ca10aef1f5fcb2c56e110", + "size": 58592, + "subdir": "linux-64", + "timestamp": 1547925028577, + "version": "1.26.0" + }, + "pytest-xdist-1.26.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "760200b97558e6dcba1637ad97900a33", + "name": "pytest-xdist", + "sha256": "65e8c3114d0ca28735b5b23efeb822832ba34d016e4667467152a44111a986fb", + "size": 58234, + "subdir": "linux-64", + "timestamp": 1550355388445, + "version": "1.26.1" + }, + "pytest-xdist-1.26.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "ac7f7a2315ce744f2cbb083e8e08fbab", + "name": "pytest-xdist", + "sha256": "4f604853d812966a3da1fa951d0ca018973d271d31b1c01efe9802e672034aec", + "size": 58645, + "subdir": "linux-64", + "timestamp": 1550355391969, + "version": "1.26.1" + }, + "pytest-xdist-1.26.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "execnet >=1.1", + "pytest >=3.0.0", + "pytest-forked", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "c32526be3fe5d1c1a29cc843cdb8910e", + "name": "pytest-xdist", + "sha256": "f36cd300d38ada5f724ed77b1d60d5d55428385e4fa3700ab0406262faa836f6", + "size": 58768, + "subdir": "linux-64", + "timestamp": 1550355335375, + "version": "1.26.1" + }, + "python-2.7.13-hac47a24_15.conda": { + "build": "hac47a24_15", + "build_number": 15, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "a02741602abc8c7f26b1887189fdabd8", + "name": "python", + "sha256": "c672992093d96eb902256b8ac643cc320a0fba642a18ac5e1f836f19924a411c", + "size": 7956070, + "subdir": "linux-64", + "timestamp": 1506704236597, + "version": "2.7.13" + }, + "python-2.7.13-heccc3f1_16.conda": { + "build": "heccc3f1_16", + "build_number": 16, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "76de5e05be3d244c0640fb804e17e611", + "name": "python", + "sha256": "e95ced719a25592584fa634226275adec3a778865b288e72f1f7111896f22dfb", + "size": 7951016, + "subdir": "linux-64", + "timestamp": 1506795306306, + "version": "2.7.13" + }, + "python-2.7.13-hfff3488_13.conda": { + "build": "hfff3488_13", + "build_number": 13, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "1c2a99aa09e580f4d9d310dc85664b81", + "name": "python", + "sha256": "a7a002d04b445bd237c4eb8075ae4c3eef8f8ddaaa9c47ada193303bcc1588eb", + "size": 7408333, + "subdir": "linux-64", + "timestamp": 1506041363459, + "version": "2.7.13" + }, + "python-2.7.14-h1571d57_29.conda": { + "build": "h1571d57_29", + "build_number": 29, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2n,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "ce5bc4252f0d56b5e415b6d05739dd2a", + "name": "python", + "sha256": "83a956d024dda00d740d8502d3739598195a1e15b993f0e535baed8159de1088", + "size": 9532689, + "subdir": "linux-64", + "timestamp": 1512666438450, + "version": "2.7.14" + }, + "python-2.7.14-h1571d57_30.conda": { + "build": "h1571d57_30", + "build_number": 30, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2n,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.22.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "39103b3f86d2386a8b6c28934d6cab85", + "name": "python", + "sha256": "38c43f72f5e559c32825e6aa90e3128231979a70bbce9af538ff4c8b625b42d7", + "size": 9536714, + "subdir": "linux-64", + "timestamp": 1520858379596, + "version": "2.7.14" + }, + "python-2.7.14-h1571d57_31.conda": { + "build": "h1571d57_31", + "build_number": 31, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.22.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "0d4200d936422497e33a2f5c5b9497ce", + "name": "python", + "sha256": "5433690240fe018c791cb6950845b3d6ba62f52d9ae8666e2e7e0f751ec59275", + "size": 9555754, + "subdir": "linux-64", + "timestamp": 1522171961654, + "version": "2.7.14" + }, + "python-2.7.14-h1aa7481_19.conda": { + "build": "h1aa7481_19", + "build_number": 19, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "b84d6b3c46e621723251cb2eee7c8b23", + "name": "python", + "sha256": "2eb0e700bdea47ba6adfe0c0f264faddb7e78848032c6894aaf6c34aef9e80c9", + "size": 7951306, + "subdir": "linux-64", + "timestamp": 1507188548940, + "version": "2.7.14" + }, + "python-2.7.14-h435b27a_18.conda": { + "build": "h435b27a_18", + "build_number": 18, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "192b7f99a6143a0e79c286484dee7e6e", + "name": "python", + "sha256": "0eba5bce8495e640e368d8bb81455690bd847d18b6e49ce2fe8e874c71710228", + "size": 7952726, + "subdir": "linux-64", + "timestamp": 1507137677248, + "version": "2.7.14" + }, + "python-2.7.14-h89e7a4a_22.conda": { + "build": "h89e7a4a_22", + "build_number": 22, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "openssl >=1.0.2l,<1.0.3a", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "64bbd32ce803fb8327a40b98b058bcfc", + "name": "python", + "sha256": "06cd2600c7dc8f8175a24f73f81b4a3a074abad028ba17338d17b0f0559bdfc9", + "size": 9527170, + "subdir": "linux-64", + "timestamp": 1509128586269, + "version": "2.7.14" + }, + "python-2.7.14-h91f54f5_26.conda": { + "build": "h91f54f5_26", + "build_number": 26, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "db29de7837569dc9f4218a6fc97c6be9", + "name": "python", + "sha256": "56ad0acb71c0504cef59426ec76c0d847a5a7b81f609244ff09c28ae8949c16c", + "size": 9548849, + "subdir": "linux-64", + "timestamp": 1512430790165, + "version": "2.7.14" + }, + "python-2.7.14-h931c8b0_15.conda": { + "build": "h931c8b0_15", + "build_number": 15, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "3b50f9530a71a8426d09ccd0857c6783", + "name": "python", + "sha256": "4bd3260840a69272c45e0defe277114827bcde82e0bfdb438fd6da0ef67320b0", + "size": 7951595, + "subdir": "linux-64", + "timestamp": 1506702652145, + "version": "2.7.14" + }, + "python-2.7.14-h9b67528_20.conda": { + "build": "h9b67528_20", + "build_number": 20, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "0528ea6638b09325001bbf28a099a9b1", + "name": "python", + "sha256": "90f9fbdd75af3097c1405b46fe62531cdec6520ce9f16a1f04c2e8eb94aa7e0d", + "size": 7947406, + "subdir": "linux-64", + "timestamp": 1507891744641, + "version": "2.7.14" + }, + "python-2.7.14-ha6fc286_23.conda": { + "build": "ha6fc286_23", + "build_number": 23, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "2fc4b5d551488869925f401ba0db9c78", + "name": "python", + "sha256": "0c5878cf3e3031f93918fb86215191511ca9d8cabb11445b86210248785a5f36", + "size": 9525555, + "subdir": "linux-64", + "timestamp": 1510181182550, + "version": "2.7.14" + }, + "python-2.7.14-hc2b0042_21.conda": { + "build": "hc2b0042_21", + "build_number": 21, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "openssl >=1.0.2l,<1.0.3a", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "85d67e1a417a5aede8d7ade91d62f58b", + "name": "python", + "sha256": "c9b2fbd534d01a6991e29c68bd2eb526f45bea17c5dff2b7d7af5d11ec315b4b", + "size": 7947479, + "subdir": "linux-64", + "timestamp": 1508175073462, + "version": "2.7.14" + }, + "python-2.7.14-hdd48546_24.conda": { + "build": "hdd48546_24", + "build_number": 24, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "9453b4c60819bc45320e91770b528467", + "name": "python", + "sha256": "6207990300422b5119fe1365aa2a3107c034e5f8d6d0164211876b5e4873b36e", + "size": 9541013, + "subdir": "linux-64", + "timestamp": 1511201179756, + "version": "2.7.14" + }, + "python-2.7.14-hf918d8d_16.conda": { + "build": "hf918d8d_16", + "build_number": 16, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "6c5ec99addb32f1c779fcdcc4348db6d", + "name": "python", + "sha256": "f6f2111353ad9ff32dcba142d939be6e8d1998b3d5a94b2c7c2406fbf60ad744", + "size": 7949943, + "subdir": "linux-64", + "timestamp": 1506795597446, + "version": "2.7.14" + }, + "python-2.7.15-h1571d57_0.conda": { + "build": "h1571d57_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.23.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "362d9e1f30548e4b52806f362acb1e50", + "name": "python", + "sha256": "83329c08e6742f51384c55be174245154dd1032411af76cc970e48a76e0403c3", + "size": 9585408, + "subdir": "linux-64", + "timestamp": 1525217741641, + "version": "2.7.15" + }, + "python-2.7.15-h77bded6_1.conda": { + "build": "h77bded6_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.0.2p,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "cdcc175a86ae8a0956dbbf67ada0a232", + "name": "python", + "sha256": "6bfb579f27f7a14230e0ea108ab1942ca35fc4962bcbf2933387ae726645de7a", + "size": 9656960, + "subdir": "linux-64", + "timestamp": 1539099171800, + "version": "2.7.15" + }, + "python-2.7.15-h77bded6_2.conda": { + "build": "h77bded6_2", + "build_number": 2, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.0.2p,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "5cbbefa5a7e1570545b2403b4c8b56d9", + "name": "python", + "sha256": "e00078d3e7d985c4d2d967914d97690e8b6584da6d3a642a1b9b37eac5b022f3", + "size": 9670262, + "subdir": "linux-64", + "timestamp": 1539207228950, + "version": "2.7.15" + }, + "python-2.7.15-h9bab390_2.conda": { + "build": "h9bab390_2", + "build_number": 2, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "73fe906d42963b938f96db6911832841", + "name": "python", + "sha256": "4b6a816568e8dda1206456672e7893a36be3047bbb20d297ff6e3ad6950277f1", + "size": 10150391, + "subdir": "linux-64", + "timestamp": 1540319579377, + "version": "2.7.15" + }, + "python-2.7.15-h9bab390_4.conda": { + "build": "h9bab390_4", + "build_number": 4, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "ceffec6f717cafe6dcda884e431d06a3", + "name": "python", + "sha256": "f4e7c62d5d4cfa7b46baabd734360fe650b9292196e5020804b688b2029a0021", + "size": 10135370, + "subdir": "linux-64", + "timestamp": 1542150485045, + "version": "2.7.15" + }, + "python-2.7.15-h9bab390_6.conda": { + "build": "h9bab390_6", + "build_number": 6, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.3,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "403b788436cc076cdc834ee6c96407a6", + "name": "python", + "sha256": "da5ae7f189fb8e942fc3c09309ca94a1e1fe66c47cb9f66a1001aaa9c7a14baa", + "size": 10147766, + "subdir": "linux-64", + "timestamp": 1544814391379, + "version": "2.7.15" + }, + "python-2.7.16-h8b3fad2_1.conda": { + "build": "h8b3fad2_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1c,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "e09d1c52bb51acf7a46dfc4ab919c9a8", + "name": "python", + "sha256": "0bb87097c36ccf2066d167611470ea7519c9d3d997c34c0e2f8f4fa0832dece3", + "size": 10268956, + "subdir": "linux-64", + "timestamp": 1565562890512, + "version": "2.7.16" + }, + "python-2.7.16-h8b3fad2_2.conda": { + "build": "h8b3fad2_2", + "build_number": 2, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1c,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "c93ac87824fcd8312cc364882b66c94c", + "name": "python", + "sha256": "1704f156ed1e3fb368f42d93261cc865d598a8cf3c310a83cc71d2f34e3bc434", + "size": 10208592, + "subdir": "linux-64", + "timestamp": 1565715580622, + "version": "2.7.16" + }, + "python-2.7.16-h8b3fad2_3.conda": { + "build": "h8b3fad2_3", + "build_number": 3, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1c,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "acf6ea43ea7ce89c39b6da33f9b78ccc", + "name": "python", + "sha256": "441f3ef9f28016cc8465ca987ff13c3372ce014ed9d5c65a91573755f99aa20b", + "size": 10211562, + "subdir": "linux-64", + "timestamp": 1565911177341, + "version": "2.7.16" + }, + "python-2.7.16-h8b3fad2_4.conda": { + "build": "h8b3fad2_4", + "build_number": 4, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1c,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "4f7cd51b0a22985149fc4d4065359b3f", + "name": "python", + "sha256": "09ad0db28822fe0f5ae9778832e27785a53e54eea23b6d0cad18b07edd366bcc", + "size": 10234312, + "subdir": "linux-64", + "timestamp": 1566258829079, + "version": "2.7.16" + }, + "python-2.7.16-h8b3fad2_5.conda": { + "build": "h8b3fad2_5", + "build_number": 5, + "depends": [ + "ca-certificates", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1c,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "1ddb3b44bca344b5dadb751b4b97954c", + "name": "python", + "sha256": "d37bd602e3f48ff07a9fc3ebb03943d71db35b19161a92cd85d74dc6fd765d47", + "size": 10267329, + "subdir": "linux-64", + "timestamp": 1566489773327, + "version": "2.7.16" + }, + "python-2.7.16-h9bab390_0.conda": { + "build": "h9bab390_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1b,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.27.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "35f73da09158b10569d464a597cc8b90", + "name": "python", + "sha256": "9b4d93403d2090554dd3e3277e1678a3f0199fb7fb9c8774687efed70ca794a3", + "size": 10314470, + "subdir": "linux-64", + "timestamp": 1552597353705, + "version": "2.7.16" + }, + "python-2.7.16-h9bab390_6.conda": { + "build": "h9bab390_6", + "build_number": 6, + "depends": [ + "ca-certificates", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "9c076ca91df617d45207f9da2a9a4c66", + "name": "python", + "sha256": "c6b988219a28a52239574b5258698275e445535166280845b176aac4a1776348", + "size": 10177634, + "subdir": "linux-64", + "timestamp": 1569342486929, + "version": "2.7.16" + }, + "python-2.7.16-h9bab390_7.conda": { + "build": "h9bab390_7", + "build_number": 7, + "depends": [ + "ca-certificates", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "18abe2d8f2f09f46c491f5f3c86813d5", + "name": "python", + "sha256": "6c2dbfb6e4e6fb09c5d76a769c772bb3618aecb37254771a930c9790672dcb0a", + "size": 10178123, + "subdir": "linux-64", + "timestamp": 1569361971965, + "version": "2.7.16" + }, + "python-2.7.17-h9bab390_0.conda": { + "build": "h9bab390_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.30.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "673e7c57e69dbd298db4e17c5adc2e98", + "name": "python", + "sha256": "7c8b75d78676c94f39963609cb876735ccfef9c23b3fe78e73c9e72f31bef0e2", + "size": 10235282, + "subdir": "linux-64", + "timestamp": 1571685442704, + "version": "2.7.17" + }, + "python-2.7.18-h02575d3_0.conda": { + "build": "h02575d3_0", + "build_number": 0, + "depends": [ + "ca-certificates", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "342e492bfc9f8e8462871cf843c82b43", + "name": "python", + "sha256": "9a8ea5d0acec48237a704c2c81638240505ae3fa62605579ad3772752e028385", + "size": 10321932, + "subdir": "linux-64", + "timestamp": 1587680414901, + "version": "2.7.18" + }, + "python-2.7.18-h15b4118_1.conda": { + "build": "h15b4118_1", + "build_number": 1, + "depends": [ + "ca-certificates", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "e80c864d381471d926471233ec60e650", + "name": "python", + "sha256": "20d725d845dba5567b9a42022fd61f037cb2e2f571766f8d3b708eac5e459df2", + "size": 10331804, + "subdir": "linux-64", + "timestamp": 1587681905468, + "version": "2.7.18" + }, + "python-2.7.18-h42bf7aa_3.conda": { + "build": "h42bf7aa_3", + "build_number": 3, + "depends": [ + "ca-certificates", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.0,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "2ecf389ff019d88fa17f3921cb267599", + "name": "python", + "sha256": "0f1787b7e4b8a9f826a15a5d3d5a20d7645dd7767e7faedace7fc5050cd941f3", + "size": 11822041, + "subdir": "linux-64", + "timestamp": 1669357703766, + "version": "2.7.18" + }, + "python-2.7.18-ha1903f6_2.conda": { + "build": "ha1903f6_2", + "build_number": 2, + "depends": [ + "ca-certificates", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "readline >=8.0,<9.0a0", + "sqlite >=3.35.4,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "566d4319b53e68019d955d350b206507", + "name": "python", + "sha256": "c22d31cbdbdc7ee7cb2ed48d40c6ce47fc2b76f56c7a755a52667abc2e87eda1", + "size": 10298686, + "subdir": "linux-64", + "timestamp": 1622818147285, + "version": "2.7.18" + }, + "python-3.10.10-h7a1cb2a_2.conda": { + "build": "h7a1cb2a_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "ncurses >=6.4,<7.0a0", + "openssl >=1.1.1t,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.41.1,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "33b75cd36e9d1aea1e26585334a6bd6d", + "name": "python", + "sha256": "e22da02f338b9aa42e3aac2042de57cc2b6ecb9581516e0fecccd602fbe90805", + "size": 28197605, + "subdir": "linux-64", + "timestamp": 1679425028925, + "version": "3.10.10" + }, + "python-3.10.6-haa1d7c7_0.conda": { + "build": "haa1d7c7_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.0.3,<2.0a0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1q,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.39.3,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "d5eaf65278f602db55270384da849259", + "name": "python", + "sha256": "bcc73da772045fdfc7fb4a79c8827d821a2d1db815b11ce906c1b442f2b5f180", + "size": 22960395, + "subdir": "linux-64", + "timestamp": 1665174682954, + "version": "3.10.6" + }, + "python-3.10.6-haa1d7c7_1.conda": { + "build": "haa1d7c7_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.0.3,<2.0a0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1q,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.39.3,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "8658e64e301dfbca4a9ff0440584377f", + "name": "python", + "sha256": "e7fb69f14f570425ab3d7bce1a943d29f058c0c5bc9daad09a977b83bffb52f0", + "size": 22973872, + "subdir": "linux-64", + "timestamp": 1666628368918, + "version": "3.10.6" + }, + "python-3.10.8-h7a1cb2a_1.conda": { + "build": "h7a1cb2a_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.0,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "c50aebbb632aea22b13bd654dfe80a5b", + "name": "python", + "sha256": "2573a9550c5dee662ed7865ca99211d0de3b10b8e936cfb976a2339206702fe5", + "size": 28120513, + "subdir": "linux-64", + "timestamp": 1669299911491, + "version": "3.10.8" + }, + "python-3.10.8-haa1d7c7_0.conda": { + "build": "haa1d7c7_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.0.3,<2.0a0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1q,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.39.3,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "f94e0ff0addc80d8746e04c6d9367012", + "name": "python", + "sha256": "59c7a205e5e7cbc20a7b2e56c854bed4abb2ee5fc29837a9669eff4a1468f22f", + "size": 28135683, + "subdir": "linux-64", + "timestamp": 1667570391768, + "version": "3.10.8" + }, + "python-3.10.9-h7a1cb2a_0.conda": { + "build": "h7a1cb2a_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.1,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.8,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "614dc725b161d7ccfa20c2c039f9850f", + "name": "python", + "sha256": "e7a704afcf5349fdda8deb96d85100639f4521b349b7e6fa033c4b468f72ee27", + "size": 28088073, + "subdir": "linux-64", + "timestamp": 1673451212565, + "version": "3.10.9" + }, + "python-3.10.9-h7a1cb2a_1.conda": { + "build": "h7a1cb2a_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "ncurses >=6.4,<7.0a0", + "openssl >=1.1.1t,<1.1.2a", + "readline >=8.0,<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" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "d5eeee07c2c7f61e9294fa10c6f76fea", + "name": "python", + "sha256": "35c16236215e40c8b3c156d83d1f0ea1221521ce8c8f6ce59d3d966987e9e588", + "size": 28103838, + "subdir": "linux-64", + "timestamp": 1677695690580, + "version": "3.10.9" + }, + "python-3.10.9-h7a1cb2a_2.conda": { + "build": "h7a1cb2a_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "ncurses >=6.4,<7.0a0", + "openssl >=1.1.1t,<1.1.2a", + "readline >=8.0,<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" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "6f7b15ceb8bbfbadbd8574ceb3912328", + "name": "python", + "sha256": "d47db010aa1663ccb6e665c0514d5d08e06be7dd6aeacdfd84cb75656e053daa", + "size": 28104863, + "subdir": "linux-64", + "timestamp": 1678273132220, + "version": "3.10.9" + }, + "python-3.11.0-h7a1cb2a_2.conda": { + "build": "h7a1cb2a_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.1,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.8,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "07f94082f7fcc22089d77432df5031d9", + "name": "python", + "sha256": "dd183f20fe7f9b6d047442f2552b57ef655b68d3f15b553aa2161da80f148b86", + "size": 34217683, + "subdir": "linux-64", + "timestamp": 1673879759715, + "version": "3.11.0" + }, + "python-3.11.0-h7a1cb2a_3.conda": { + "build": "h7a1cb2a_3", + "build_number": 3, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "ncurses >=6.4,<7.0a0", + "openssl >=1.1.1t,<1.1.2a", + "readline >=8.0,<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" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "a2b9a7050d4dc13bc51eadbf557b3f6a", + "name": "python", + "sha256": "8611139f10c81c01123cd6cee278af9f4f4119d5013b6ffd0bcd5dc7b07f1680", + "size": 34195703, + "subdir": "linux-64", + "timestamp": 1677696154057, + "version": "3.11.0" + }, + "python-3.11.2-h7a1cb2a_0.conda": { + "build": "h7a1cb2a_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "ld_impl_linux-64 >=2.36.1", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libuuid >=1.41.5,<2.0a0", + "ncurses >=6.4,<7.0a0", + "openssl >=1.1.1t,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.41.1,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "2db25c8eade68d4f19ae583518e84eaf", + "name": "python", + "sha256": "83bd391e9908247e0d052655d98b7e044647786cffa600814f5509abd5ecd88f", + "size": 34341161, + "subdir": "linux-64", + "timestamp": 1679961522693, + "version": "3.11.2" + }, + "python-3.5.4-h00c01ad_19.conda": { + "build": "h00c01ad_19", + "build_number": 19, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "57b9a5692c46d546b64c930c41d00444", + "name": "python", + "sha256": "ec8bd11325fa7039d5a04200d383693dd7be65722d04e5685891fb20cd433e9d", + "size": 24161468, + "subdir": "linux-64", + "timestamp": 1507190766612, + "version": "3.5.4" + }, + "python-3.5.4-h0b4c808_22.conda": { + "build": "h0b4c808_22", + "build_number": 22, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "openssl >=1.0.2l,<1.0.3a", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "ffb92a3c1109bf45bfafac6bd35a3505", + "name": "python", + "sha256": "4193c328b0714dcf501c5bb6ed4cf85df9e24e22ce8a9542ca1a114b7b3f7971", + "size": 25756122, + "subdir": "linux-64", + "timestamp": 1509739610720, + "version": "3.5.4" + }, + "python-3.5.4-h2170f06_12.conda": { + "build": "h2170f06_12", + "build_number": 12, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "be831731b0337cf87c2eec7803060817", + "name": "python", + "sha256": "6d5df14f24e5a463f634777313277cd672c78e29002e366817996a6449dd8651", + "size": 23592351, + "subdir": "linux-64", + "timestamp": 1506043755839, + "version": "3.5.4" + }, + "python-3.5.4-h3075507_18.conda": { + "build": "h3075507_18", + "build_number": 18, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "638d416024c2384c7bc117884e8fc2c1", + "name": "python", + "sha256": "1f0f97a27e523397d93f5a197e973cb02fcf23bed238492c2769203a416dbe48", + "size": 24173445, + "subdir": "linux-64", + "timestamp": 1507151058414, + "version": "3.5.4" + }, + "python-3.5.4-h417fded_24.conda": { + "build": "h417fded_24", + "build_number": 24, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "8fa9e0dc00358ef14bfbca90ab0c33d4", + "name": "python", + "sha256": "9ff68f0402b29a279d38153262f5bd57a075900c3c23bb1f5279fc504a465682", + "size": 25945105, + "subdir": "linux-64", + "timestamp": 1511203805545, + "version": "3.5.4" + }, + "python-3.5.4-h56e0582_23.conda": { + "build": "h56e0582_23", + "build_number": 23, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "ca48ed587ba3ce94c77b0b5114637506", + "name": "python", + "sha256": "e1c64fc5ffd49c9fb8c75a1b8dc427bffc4cc51d80c7d0b532aedc9d4d842877", + "size": 25734342, + "subdir": "linux-64", + "timestamp": 1510188259673, + "version": "3.5.4" + }, + "python-3.5.4-h72f0b78_15.conda": { + "build": "h72f0b78_15", + "build_number": 15, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "a13f6793abdd9ea981e55e561a724710", + "name": "python", + "sha256": "e93702e15f9b7413cbf70bd0db17912ce57fecd9f4a3e31bc3be8c292507a666", + "size": 24167590, + "subdir": "linux-64", + "timestamp": 1506797197209, + "version": "3.5.4" + }, + "python-3.5.4-hb43c6bb_21.conda": { + "build": "hb43c6bb_21", + "build_number": 21, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "openssl >=1.0.2l,<1.0.3a", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "d2ffdf78b8346a2b55dc2acdd1844348", + "name": "python", + "sha256": "25356633c3761dab85e3732cbbd0456ad94a4bfe20c03d37d4b4453c3aeb5530", + "size": 25748857, + "subdir": "linux-64", + "timestamp": 1509131065647, + "version": "3.5.4" + }, + "python-3.5.4-hc053d89_14.conda": { + "build": "hc053d89_14", + "build_number": 14, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "66bb2fbfd4c00eddccc94104bdd08bd0", + "name": "python", + "sha256": "8aeb9a30f19d8423c21a9699888a51613545ad2da672167de986f61b98e24700", + "size": 24160456, + "subdir": "linux-64", + "timestamp": 1506726125431, + "version": "3.5.4" + }, + "python-3.5.4-hc3d631a_27.conda": { + "build": "hc3d631a_27", + "build_number": 27, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2n,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.22.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "9715db314b8b7179bdbe86ee6f978429", + "name": "python", + "sha256": "d91774d5b2f050be0282d03b259fb6d3db4ca408e16715f2891bc6858f46a614", + "size": 25975499, + "subdir": "linux-64", + "timestamp": 1519038264770, + "version": "3.5.4" + }, + "python-3.5.4-he2c66cf_20.conda": { + "build": "he2c66cf_20", + "build_number": 20, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "a3f55345375c15d4eb2a8c3079a4817b", + "name": "python", + "sha256": "345a5038a62cfa0a15bb4351c4b7a3307b6c2ad171a428a0a0237d9fd6331342", + "size": 24155663, + "subdir": "linux-64", + "timestamp": 1507894095668, + "version": "3.5.4" + }, + "python-3.5.5-hc3d631a_0.conda": { + "build": "hc3d631a_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2n,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.22.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "ea682ff945916668e176565b479b52f9", + "name": "python", + "sha256": "708b5f079f02ae2e5e247c60d1085942af66237a88e626020eca7f2edcc1148b", + "size": 26047878, + "subdir": "linux-64", + "timestamp": 1520625443196, + "version": "3.5.5" + }, + "python-3.5.5-hc3d631a_1.conda": { + "build": "hc3d631a_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2n,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.22.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "94b4818e08e9573a5fa6cecda07c6a5d", + "name": "python", + "sha256": "18b2c7ae00a92ac337bdcf4e05ea9d987813b6a9398799559f61a473a737dd65", + "size": 26051878, + "subdir": "linux-64", + "timestamp": 1520896715488, + "version": "3.5.5" + }, + "python-3.5.5-hc3d631a_3.conda": { + "build": "hc3d631a_3", + "build_number": 3, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.23.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "0edf6fbbc16cbe645727945a8d4eaf57", + "name": "python", + "sha256": "a03b29a20a1f768f5a305c003385c3b0212ecbf310feb287e1e9adf9c1bb6459", + "size": 25994618, + "subdir": "linux-64", + "timestamp": 1524750804737, + "version": "3.5.5" + }, + "python-3.5.5-hc3d631a_4.conda": { + "build": "hc3d631a_4", + "build_number": 4, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.23.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "25b86098bec08dc838547b2953de18e1", + "name": "python", + "sha256": "a95916736aeefae20dca619a88aab4ce8c6f229a8f520d85882ae5e6fb6a4506", + "size": 26056656, + "subdir": "linux-64", + "timestamp": 1526246306539, + "version": "3.5.5" + }, + "python-3.5.6-h12debd9_1.conda": { + "build": "h12debd9_1", + "build_number": 1, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.35.4,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "7da6bd08a4dde20449cf2e234c0c0f46", + "name": "python", + "sha256": "7b2c9a36e0e8a39eac758975a1d4ade488ffbb85a8bf1054b63d7f0e52346785", + "size": 26114997, + "subdir": "linux-64", + "timestamp": 1622833206425, + "version": "3.5.6" + }, + "python-3.5.6-hc3d631a_0.conda": { + "build": "hc3d631a_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.0.2p,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.24.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "6fb2a8d1d424dc8bb8215a0173d694ce", + "name": "python", + "sha256": "96e6d639ece3e6ad95cd1493cee975e0b7a6c5606f2bd79fcc77345ae76a86b1", + "size": 26074247, + "subdir": "linux-64", + "timestamp": 1535320076551, + "version": "3.5.6" + }, + "python-3.6.10-h0371630_0.conda": { + "build": "h0371630_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.30.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "15b449de39638320694d8e5043bc40a2", + "name": "python", + "sha256": "fa500ee4d8abafd24d653eda1a6df77ad8761f74108a7d14bae91711219f8ad5", + "size": 31191798, + "subdir": "linux-64", + "timestamp": 1578431905715, + "version": "3.6.10" + }, + "python-3.6.10-h191fe78_1.conda": { + "build": "h191fe78_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1e,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "bb620c6f94031b72de412709a9e7a974", + "name": "python", + "sha256": "7bbd9f056bca7475a8af3b68b4dc2b24208a1b8b7e9ae2750507a9e2a7fd13bc", + "size": 31151955, + "subdir": "linux-64", + "timestamp": 1585005552723, + "version": "3.6.10" + }, + "python-3.6.10-h7579374_2.conda": { + "build": "h7579374_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "6b7bc235a2c6200fb1c29d1dc667fd84", + "name": "python", + "sha256": "661c43061e29184c16ff5663fd9d3a8c19fc284c33c07056bba797559a43fde8", + "size": 31189181, + "subdir": "linux-64", + "timestamp": 1588906830006, + "version": "3.6.10" + }, + "python-3.6.10-hcf32534_1.conda": { + "build": "hcf32534_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1e,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "51489df5a79a9412d98dcc878b795755", + "name": "python", + "sha256": "a88221e2b1b3e734e03dba6c9b142e3a06adf34fb4ebcdfa6f6cde0aa82ab00a", + "size": 31185861, + "subdir": "linux-64", + "timestamp": 1585180542090, + "version": "3.6.10" + }, + "python-3.6.12-hcff3b4d_2.conda": { + "build": "hcff3b4d_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "5a6b4f2bf00e5f83ff0aa7365e4618fb", + "name": "python", + "sha256": "9da2f8c0dbd14efb6e23d1d1ff734099415f3d8bd5a6c5ea41b591f46cdffb5b", + "size": 31180403, + "subdir": "linux-64", + "timestamp": 1599606857668, + "version": "3.6.12" + }, + "python-3.6.13-hdb3f193_0.conda": { + "build": "hdb3f193_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1j,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "1795f4ef34cff6d861e5116f91453fb2", + "name": "python", + "sha256": "ffe2293385ef073fa11fdd479c8e0430cfed30a228e5aca52797cda245c2c6d9", + "size": 31177953, + "subdir": "linux-64", + "timestamp": 1614115100251, + "version": "3.6.13" + }, + "python-3.6.2-h02fb82a_12.conda": { + "build": "h02fb82a_12", + "build_number": 12, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "9dc168ef1666463eb6d473b41738c92f", + "name": "python", + "sha256": "b2ee3ba0d01138918a9dc596cc05f5c8a80a2f09d575eb5b3b945207382bdf9e", + "size": 24197246, + "subdir": "linux-64", + "timestamp": 1506046126344, + "version": "3.6.2" + }, + "python-3.6.2-h0b30769_14.conda": { + "build": "h0b30769_14", + "build_number": 14, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "aae66757b833b2a09a9ffe6336dcdcb9", + "name": "python", + "sha256": "7ad1304d5cc74ebde5acc4fdaf18f9e2676efc87b7e9d7a3485b8c19e954aa14", + "size": 24768561, + "subdir": "linux-64", + "timestamp": 1506708228841, + "version": "3.6.2" + }, + "python-3.6.2-h33255ae_18.conda": { + "build": "h33255ae_18", + "build_number": 18, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "3c1ecfae97e8d5bbe993733b90bc922f", + "name": "python", + "sha256": "a4a0808b3d99fb402e7349fd1b3ff7c0048e0ae2e8cff13d2c39970447aab7d7", + "size": 24732625, + "subdir": "linux-64", + "timestamp": 1507146137504, + "version": "3.6.2" + }, + "python-3.6.2-hca45abc_19.conda": { + "build": "hca45abc_19", + "build_number": 19, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "4c9afb05e81bdbd8c3f356045a0f8be9", + "name": "python", + "sha256": "3b1b505d1c499b72c42b653b7c4a0d1037573261af6445e3f3e507fb45f4a0a3", + "size": 24732860, + "subdir": "linux-64", + "timestamp": 1507190714034, + "version": "3.6.2" + }, + "python-3.6.2-hdfe5801_15.conda": { + "build": "hdfe5801_15", + "build_number": 15, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "0099962df3720908632dc620809b4938", + "name": "python", + "sha256": "bde52e81d31e0f290d883ee47b9731b14dd9772eb0f4f3a047f4a92b5da3a954", + "size": 24789357, + "subdir": "linux-64", + "timestamp": 1506797324550, + "version": "3.6.2" + }, + "python-3.6.3-h0ef2715_3.conda": { + "build": "h0ef2715_3", + "build_number": 3, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "openssl >=1.0.2l,<1.0.3a", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "5e78350b226480025a35a5681a9d5883", + "name": "python", + "sha256": "66738aff7754bf0bbcd51f12ac8ffe4daa475b50fbbd3fecb7bfdff64f1d91e2", + "size": 26702465, + "subdir": "linux-64", + "timestamp": 1509737092796, + "version": "3.6.3" + }, + "python-3.6.3-h1284df2_4.conda": { + "build": "h1284df2_4", + "build_number": 4, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "5e99efd44cac4f8b77dd4f3c69a4762c", + "name": "python", + "sha256": "36139fcc1eb6778617c182b915328319534f07c67f239fe05cfe74dd87e70a22", + "size": 26694672, + "subdir": "linux-64", + "timestamp": 1510187069024, + "version": "3.6.3" + }, + "python-3.6.3-h6c0c0dc_5.conda": { + "build": "h6c0c0dc_5", + "build_number": 5, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "2d720157acc98ac418bb0bf30ae8ce69", + "name": "python", + "sha256": "c3fa671feff75f33143f5cc1e62de2f621272d1cbe09ab6639ca83b476ef6046", + "size": 26706418, + "subdir": "linux-64", + "timestamp": 1511210831882, + "version": "3.6.3" + }, + "python-3.6.3-hc9025b9_1.conda": { + "build": "hc9025b9_1", + "build_number": 1, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "8f28ea6a2f77009d39da185e406b117c", + "name": "python", + "sha256": "aac52216a0986f0207e6db3cd981fd8318c3428317aadbd5b66dc8cdf8828ee8", + "size": 24810251, + "subdir": "linux-64", + "timestamp": 1507896496429, + "version": "3.6.3" + }, + "python-3.6.3-hcad60d5_0.conda": { + "build": "hcad60d5_0", + "build_number": 0, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "e8f4c57b4d28052b410f0b712cb27076", + "name": "python", + "sha256": "90e9d76274546d2bf5a2a0611d565c45b7c4e1acfd396fb59907897a9b19531c", + "size": 24866019, + "subdir": "linux-64", + "timestamp": 1507310424228, + "version": "3.6.3" + }, + "python-3.6.3-hefd0734_2.conda": { + "build": "hefd0734_2", + "build_number": 2, + "depends": [ + "libffi 3.2.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses 6.0.*", + "openssl 1.0.*", + "openssl >=1.0.2l,<1.0.3a", + "readline 7.*", + "sqlite >=3.20.1,<4.0a0", + "tk 8.6.*", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "85449ce283670211c1866ddc79dc2d0b", + "name": "python", + "sha256": "9d9d37aa80f1d7e72de1a400b881c1116e3088f37fb9ae88d32a7c5b3085e0fd", + "size": 26398048, + "subdir": "linux-64", + "timestamp": 1509133600291, + "version": "3.6.3" + }, + "python-3.6.4-hc3d631a_0.conda": { + "build": "hc3d631a_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2n,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "bb1c0473adce66bd673850058ecdcdb3", + "name": "python", + "sha256": "82d1de480995ac2be9292aeffbd5cdda084f0c952583fb67920990bcc4d818d6", + "size": 26696047, + "subdir": "linux-64", + "timestamp": 1513892816662, + "version": "3.6.4" + }, + "python-3.6.4-hc3d631a_1.conda": { + "build": "hc3d631a_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2n,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.20.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "3afc1d1efa01dd2fddd6cd6e899949e2", + "name": "python", + "sha256": "9241d0a92c74dcaba2d9acc1e1aec57d733e1f6551907161227b2f0ffe43baf7", + "size": 26759041, + "subdir": "linux-64", + "timestamp": 1516126521222, + "version": "3.6.4" + }, + "python-3.6.4-hc3d631a_3.conda": { + "build": "hc3d631a_3", + "build_number": 3, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2n,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.22.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "5881fd734e6be03447777e1ac64ef8b1", + "name": "python", + "sha256": "64d6ed34487be79c878950a6049d767cf905e0c234252254fd47fead5b9b7e31", + "size": 26757629, + "subdir": "linux-64", + "timestamp": 1520904128584, + "version": "3.6.4" + }, + "python-3.6.5-hc3d631a_0.conda": { + "build": "hc3d631a_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.22.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "80796335fea938ba4d7d754688ca34cf", + "name": "python", + "sha256": "93362ed98220d3ec4dc8f09013a5999cf0946bf91c03baf2eebb93daa0c83d5b", + "size": 26762181, + "subdir": "linux-64", + "timestamp": 1522348060704, + "version": "3.6.5" + }, + "python-3.6.5-hc3d631a_1.conda": { + "build": "hc3d631a_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.23.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "dcfea6276f4dceb9162a6440e2ec5c1f", + "name": "python", + "sha256": "a98a0400dfb78dd7e1ec8c27292a5256b40a6321dba2e0dfe8467a4361e559dd", + "size": 26779578, + "subdir": "linux-64", + "timestamp": 1524750765703, + "version": "3.6.5" + }, + "python-3.6.5-hc3d631a_2.conda": { + "build": "hc3d631a_2", + "build_number": 2, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.0,<7.0a0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.23.1,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "5b70aba33e218f438f7982cbd6e6b98a", + "name": "python", + "sha256": "cd213e2c52022c465bc1c4ef6b5cf24786fb69b5df15d1c1055bdd61253fc900", + "size": 26770536, + "subdir": "linux-64", + "timestamp": 1525018835206, + "version": "3.6.5" + }, + "python-3.6.6-h6e4f718_2.conda": { + "build": "h6e4f718_2", + "build_number": 2, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.0.2p,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "23c7010f718154f7d08013cf00e33710", + "name": "python", + "sha256": "4d22155d375f3afc9b8d5cc27d96b98bc5a29ef978d8056909a674e22b462aca", + "size": 26932895, + "subdir": "linux-64", + "timestamp": 1539088676561, + "version": "3.6.6" + }, + "python-3.6.6-hc3d631a_0.conda": { + "build": "hc3d631a_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.24.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "36d320f77ba3566ca08fd525affe4300", + "name": "python", + "sha256": "a36e58f7055e1af96e72f19b4002a7bfba892b2484cb20b125243820ac65e4de", + "size": 26903943, + "subdir": "linux-64", + "timestamp": 1530206464179, + "version": "3.6.6" + }, + "python-3.6.7-h0371630_0.conda": { + "build": "h0371630_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "15fd3f72ad5ca7c8dbb632eb12b22b39", + "name": "python", + "sha256": "3999d8011eed79112d7dd67f1a0f4afd75023f79bbc0744bfc171ace0dc0b407", + "size": 31541632, + "subdir": "linux-64", + "timestamp": 1540322594538, + "version": "3.6.7" + }, + "python-3.6.8-h0371630_0.conda": { + "build": "h0371630_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.26.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "4f717c0053e4c7c2645dc08bbb8cdd22", + "name": "python", + "sha256": "756b6fa94aae5599b93d8cbfef079677f13e27d9527d5dcfca1273f7ce042a2a", + "size": 31550467, + "subdir": "linux-64", + "timestamp": 1546133334399, + "version": "3.6.8" + }, + "python-3.6.9-h265db76_0.conda": { + "build": "h265db76_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1c,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "aad1c770074132ca1953dc79757a1a4a", + "name": "python", + "sha256": "604efe73575ea4df68136f32c9cdc544958607181f70d93076c2fe75d82958ef", + "size": 31677613, + "subdir": "linux-64", + "timestamp": 1564514018352, + "version": "3.6.9" + }, + "python-3.7.0-h6e4f718_3.conda": { + "build": "h6e4f718_3", + "build_number": 3, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.0.2p,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "7b5451caee9b77da89d6d473c69efb89", + "name": "python", + "sha256": "89d978ce684fc12f205c219ba6a5e69d8fc6f3b6c7029d4e35740e326f52cd2a", + "size": 28540722, + "subdir": "linux-64", + "timestamp": 1539081483538, + "version": "3.7.0" + }, + "python-3.7.0-hc3d631a_0.conda": { + "build": "hc3d631a_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "sqlite >=3.24.0,<4.0a0", + "tk >=8.6.7,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "271a6748ce2d0fe50ac8895411784000", + "name": "python", + "sha256": "1199dfefed901bbb0b672436aee19f4e30a14c5c7d8112b7eb032d041a9a32f1", + "size": 29206630, + "subdir": "linux-64", + "timestamp": 1530192595411, + "version": "3.7.0" + }, + "python-3.7.1-h0371630_3.conda": { + "build": "h0371630_3", + "build_number": 3, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "1608d20e3981040c9990ff616746dd65", + "name": "python", + "sha256": "87f8677d3432985c24e9b3d323bfdc0a26a930d148124577e92bba401ff0a83b", + "size": 33496899, + "subdir": "linux-64", + "timestamp": 1540322940495, + "version": "3.7.1" + }, + "python-3.7.1-h0371630_7.conda": { + "build": "h0371630_7", + "build_number": 7, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.25.3,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "709a74997b78eec2835b398952545de5", + "name": "python", + "sha256": "fee25304736d0d306ce0dc32b3d11e013e692734435ee7773dee43f37c7cb704", + "size": 33480868, + "subdir": "linux-64", + "timestamp": 1544816275665, + "version": "3.7.1" + }, + "python-3.7.10-h12debd9_4.conda": { + "build": "h12debd9_4", + "build_number": 4, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.35.4,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "eaed72e26b098ddb68924873f3894555", + "name": "python", + "sha256": "ebd987f235e7122eb4b602ca6640a7f9e038741830d60bde9c4e375ea331ac76", + "size": 46101231, + "subdir": "linux-64", + "timestamp": 1622836409615, + "version": "3.7.10" + }, + "python-3.7.10-hdb3f193_0.conda": { + "build": "hdb3f193_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1j,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "b2703194d82ca4804911c494acfb4811", + "name": "python", + "sha256": "0b887dbffc7e180e7da25bd0284e3dec300cd38b1c4f04079bce049b62e95efe", + "size": 47380106, + "subdir": "linux-64", + "timestamp": 1614365716095, + "version": "3.7.10" + }, + "python-3.7.11-h12debd9_0.conda": { + "build": "h12debd9_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.36.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "68fa595344519f64c9753c245246c178", + "name": "python", + "sha256": "0e4682f9ccdff2e142ce05c2da501b2c02962ccae303bc63b758b5b33f5aea65", + "size": 47544392, + "subdir": "linux-64", + "timestamp": 1627396740863, + "version": "3.7.11" + }, + "python-3.7.13-h12debd9_0.conda": { + "build": "h12debd9_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1n,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.38.0,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "390222c32c4bf21b9d636623d24725b5", + "name": "python", + "sha256": "0de1972f577ac1e62152fe1b429cdcc428ee9d40c0302fa7fab27d9aa618233e", + "size": 48459878, + "subdir": "linux-64", + "timestamp": 1648538617113, + "version": "3.7.13" + }, + "python-3.7.13-haa1d7c7_1.conda": { + "build": "haa1d7c7_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1q,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.39.3,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "8b402639a46c487e81f06be05b615f11", + "name": "python", + "sha256": "31e3490c3f8092bdbc649d712586024338ccb863dc6e2e41e1308cc5109d96a6", + "size": 42635444, + "subdir": "linux-64", + "timestamp": 1666119764107, + "version": "3.7.13" + }, + "python-3.7.15-h7a1cb2a_1.conda": { + "build": "h7a1cb2a_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.0,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "904d044649041b6ad772a3b1612f97fa", + "name": "python", + "sha256": "7bd11c61d6c88d675285b62a4c7e2a8bb4e679158a3739bc2efad68763965359", + "size": 42635082, + "subdir": "linux-64", + "timestamp": 1669324854204, + "version": "3.7.15" + }, + "python-3.7.15-haa1d7c7_0.conda": { + "build": "haa1d7c7_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.39.3,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "8876d785e73b4707755e916d4ce3906e", + "name": "python", + "sha256": "4e2dc9eb6b8b823579ec259acf58ec6ec470b2e48eb5c8c40cfd442d009c599b", + "size": 42811308, + "subdir": "linux-64", + "timestamp": 1667858896956, + "version": "3.7.15" + }, + "python-3.7.16-h7a1cb2a_0.conda": { + "build": "h7a1cb2a_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.1,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "74fc6c57e82f6a6e350c5956ec89c086", + "name": "python", + "sha256": "79f45b76a261d3ae776172af07c7d22d30369813d7d8ae2a7236362c906405a3", + "size": 47021233, + "subdir": "linux-64", + "timestamp": 1673994356396, + "version": "3.7.16" + }, + "python-3.7.2-h0371630_0.conda": { + "build": "h0371630_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.26.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "7895e4a38f7a6ca34498fbcdff7a603d", + "name": "python", + "sha256": "eca7cdcf26270c499516aa278fff2f685ba007c69ad8edfb1ae4db89235b710e", + "size": 33498466, + "subdir": "linux-64", + "timestamp": 1546065063536, + "version": "3.7.2" + }, + "python-3.7.3-h0371630_0.conda": { + "build": "h0371630_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1b,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.27.2,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "3af31eb91c306dccb90a06b7203fc4f9", + "name": "python", + "sha256": "a2777bab37420f334b9bee0cfff4d13bb235163462568493903acaeb73c7d222", + "size": 33683505, + "subdir": "linux-64", + "timestamp": 1553725190732, + "version": "3.7.3" + }, + "python-3.7.4-h265db76_0.conda": { + "build": "h265db76_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1c,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "3b04cb6efe72bb5541d941298c22a6ad", + "name": "python", + "sha256": "39f65bac121a28f8ae9a7f9e74f71ef2fe42320c68b7b427ff19560600b8991c", + "size": 33147929, + "subdir": "linux-64", + "timestamp": 1565378393884, + "version": "3.7.4" + }, + "python-3.7.4-h265db76_1.conda": { + "build": "h265db76_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1c,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.29.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "05f5f232f6c0193b775f10fd9e5fe4b1", + "name": "python", + "sha256": "6379d7d15ab22ee1f052c182e1c2817585b5a59026824527afa2535d5e74ff8c", + "size": 33657382, + "subdir": "linux-64", + "timestamp": 1565729005546, + "version": "3.7.4" + }, + "python-3.7.5-h0371630_0.conda": { + "build": "h0371630_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.30.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "4c514ec42a8309789504aca386045b46", + "name": "python", + "sha256": "f7fc54455b445bfed4d5138fbe4d70870cee764212a5e348261bb0267b719861", + "size": 33729039, + "subdir": "linux-64", + "timestamp": 1572019430090, + "version": "3.7.5" + }, + "python-3.7.6-h0371630_2.conda": { + "build": "h0371630_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.30.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "dd58091b9580c94b09c05fa0b11d5285", + "name": "python", + "sha256": "da874e69ed754d08420db4c08132e756f170362e0aaf7f4eea8852518a41f8ca", + "size": 47034807, + "subdir": "linux-64", + "timestamp": 1578514009503, + "version": "3.7.6" + }, + "python-3.7.7-h191fe78_0_cpython.conda": { + "build": "h191fe78_0_cpython", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1e,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "dd0076eea3daec85c00f8cd1ad04b74b", + "name": "python", + "sha256": "1ee25029c345494f5e8a33b38529eea433ef42c662dbc543e4bfe8965e38e4ca", + "size": 47281543, + "subdir": "linux-64", + "timestamp": 1585003409864, + "version": "3.7.7" + }, + "python-3.7.7-hcf32534_0_cpython.conda": { + "build": "hcf32534_0_cpython", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1e,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "a07f1efe966443589c4311a2619cdb59", + "name": "python", + "sha256": "0aa3ea7eaed61b2d09c02d15e8a6e28355769a73c32a133e0520cf879c506e24", + "size": 47230338, + "subdir": "linux-64", + "timestamp": 1585238182589, + "version": "3.7.7" + }, + "python-3.7.7-hcff3b4d_4.conda": { + "build": "hcff3b4d_4", + "build_number": 4, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "89cb2fc50c0c4b871fc733b30f7d695a", + "name": "python", + "sha256": "778111f301be6c980574f19b3fae45203159e893b98d627507059e5c9914e432", + "size": 47310365, + "subdir": "linux-64", + "timestamp": 1588761071659, + "version": "3.7.7" + }, + "python-3.7.7-hcff3b4d_5.conda": { + "build": "hcff3b4d_5", + "build_number": 5, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "c5ae8ebfd690edb055f6dafdfa0c9aff", + "name": "python", + "sha256": "b6096bdcc86abf5e2c564614d0b5fdd5a432f321869e3e56f7ccae37b2eb0156", + "size": 47315212, + "subdir": "linux-64", + "timestamp": 1588887403215, + "version": "3.7.7" + }, + "python-3.7.9-h7579374_0.conda": { + "build": "h7579374_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "e8871e5a420f47397833fd2f3f0dac7a", + "name": "python", + "sha256": "eedacc1185477049247bafa38f991e800f0c6bd8345b3edeca2815547318af90", + "size": 47544406, + "subdir": "linux-64", + "timestamp": 1598878258314, + "version": "3.7.9" + }, + "python-3.8.0-h0371630_0.conda": { + "build": "h0371630_0", + "build_number": 0, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.30.0,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "7099f1318bb11097d43d7ae1c1f350c0", + "name": "python", + "sha256": "fab5fdac4c80aa1dbb8d3e89906de5ae2758f82d82b69f7e72602042741fe393", + "size": 42779707, + "subdir": "linux-64", + "timestamp": 1571930141605, + "version": "3.8.0" + }, + "python-3.8.0-h0371630_1.conda": { + "build": "h0371630_1", + "build_number": 1, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.30.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "5d1ff7fb25a1532341776ae48d9b8770", + "name": "python", + "sha256": "eca3e58ce4ed16dd6fa542ed3d36aa2271fbee1906adb029e1681c51fa05a6cd", + "size": 42750161, + "subdir": "linux-64", + "timestamp": 1572633250137, + "version": "3.8.0" + }, + "python-3.8.0-h0371630_2.conda": { + "build": "h0371630_2", + "build_number": 2, + "depends": [ + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.30.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "1962fc0b9973a105d4a228985b6a4760", + "name": "python", + "sha256": "35dd088ae9506e7cb54bc51a53bc0c22a9be049e197dd8df2088a5c4024493a4", + "size": 36600676, + "subdir": "linux-64", + "timestamp": 1573077459493, + "version": "3.8.0" + }, + "python-3.8.1-h0371630_1.conda": { + "build": "h0371630_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.1,<7.0a0", + "openssl >=1.1.1d,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.30.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "0c28abedfd6a6d572758bc19557e048f", + "name": "python", + "sha256": "2b4d35933319f05f89a13700fad564e407e66ad6ffed90a6badfa26dce1db712", + "size": 51866359, + "subdir": "linux-64", + "timestamp": 1578522827542, + "version": "3.8.1" + }, + "python-3.8.10-hdb3f193_7.conda": { + "build": "hdb3f193_7", + "build_number": 7, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.35.4,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "bd905abdbe90e032dac40db1a759f679", + "name": "python", + "sha256": "bf6346dad6d22d79d4d2192d141dec53bc26557904c3e1763e3692ca1e259d9a", + "size": 52527561, + "subdir": "linux-64", + "timestamp": 1621447816581, + "version": "3.8.10" + }, + "python-3.8.11-h12debd9_0_cpython.conda": { + "build": "h12debd9_0_cpython", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.36.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "911cb94a4015b7159ba40e317cd251df", + "name": "python", + "sha256": "39600e896597849f2959bfc03cfa5c84d314cfe291b8d13a1086b866405890c2", + "size": 19134591, + "subdir": "linux-64", + "timestamp": 1628004030042, + "version": "3.8.11" + }, + "python-3.8.12-h12debd9_0.conda": { + "build": "h12debd9_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1l,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.36.0,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "c5916b4ce33701bc6fe8ce66adc88ce1", + "name": "python", + "sha256": "a109ec4af2a316bbb53a34d5938476c6c94244805513c1f5efb917c5e64c9e92", + "size": 19150003, + "subdir": "linux-64", + "timestamp": 1634047242806, + "version": "3.8.12" + }, + "python-3.8.13-h12debd9_0.conda": { + "build": "h12debd9_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1n,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.38.0,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "edc17980bae484b711e090f0a0cbbaef", + "name": "python", + "sha256": "cd1517bcec4137ceff1441221ace858266b33189c56115538c097a6c87e5b03c", + "size": 19718183, + "subdir": "linux-64", + "timestamp": 1648468088026, + "version": "3.8.13" + }, + "python-3.8.13-haa1d7c7_1.conda": { + "build": "haa1d7c7_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1q,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.39.3,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "43a2c043262c004b0ad1b77fca992639", + "name": "python", + "sha256": "92f875dc3515f05e21487003fcbea960f50c4e0a4f970213aeb5d0dc8bc1be72", + "size": 21130825, + "subdir": "linux-64", + "timestamp": 1666396970498, + "version": "3.8.13" + }, + "python-3.8.15-h3fd9d12_0.conda": { + "build": "h3fd9d12_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.2,<9.0a0", + "sqlite >=3.39.3,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "081da8b9b3e753b934c40cfddcf17dbb", + "name": "python", + "sha256": "87adcd478210e24c77d61d51244d39cacedeb676e70ab96ae77a2dfc2ab45865", + "size": 21041666, + "subdir": "linux-64", + "timestamp": 1667596292234, + "version": "3.8.15" + }, + "python-3.8.15-h7a1cb2a_2.conda": { + "build": "h7a1cb2a_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.0,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "9252075f5f42bf4bc633fe348bbbb3a4", + "name": "python", + "sha256": "3a722b0757eef911c076b322f5315ca6be66dbc7383dea7a910ac86d12bf0d5a", + "size": 21078894, + "subdir": "linux-64", + "timestamp": 1669303847922, + "version": "3.8.15" + }, + "python-3.8.16-h7a1cb2a_2.conda": { + "build": "h7a1cb2a_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.1,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "8c261ee7e2c541b8b93898e4a1ebdc83", + "name": "python", + "sha256": "2433a84144832d1e976a69aa73fa6a849a3dda8ecbff1638c4b90cdf01f99056", + "size": 25030115, + "subdir": "linux-64", + "timestamp": 1673997772390, + "version": "3.8.16" + }, + "python-3.8.16-h7a1cb2a_3.conda": { + "build": "h7a1cb2a_3", + "build_number": 3, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.4,<7.0a0", + "openssl >=1.1.1t,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.1,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "c11c0992727585f5f991760f5b18c968", + "name": "python", + "sha256": "1c8f021e160f81b2d65aed8ff165643c16681c1312abdf2e94eddddc63b49bd5", + "size": 24824869, + "subdir": "linux-64", + "timestamp": 1677727904099, + "version": "3.8.16" + }, + "python-3.8.2-h191fe78_0.conda": { + "build": "h191fe78_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1e,<1.1.2a", + "readline >=7.0,<8.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "9f33140535cb7413443ffaa19dbc2318", + "name": "python", + "sha256": "f4c22f425f09f5007837d4642686802777f0dcc51490c01f22a3f7b927d8fed3", + "size": 52017954, + "subdir": "linux-64", + "timestamp": 1585156155228, + "version": "3.8.2" + }, + "python-3.8.2-hcf32534_0.conda": { + "build": "hcf32534_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.2.1,<3.3a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1e,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "63612f84e3a0f1605d9d53421e8aa36b", + "name": "python", + "sha256": "0a414f4891b85f537504ea2dae58a01915cd451dc2d20f9c4c803071b74c12b8", + "size": 51965963, + "subdir": "linux-64", + "timestamp": 1585238239959, + "version": "3.8.2" + }, + "python-3.8.2-hcff3b4d_13.conda": { + "build": "hcff3b4d_13", + "build_number": 13, + "depends": [ + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "e78819c97ba9fd0425fdbff00ab31274", + "name": "python", + "sha256": "142c4a8e17fce36eb49f3fb0fefa3a58b8e38f53da7be312afcc7ef882c190d1", + "size": 51461091, + "subdir": "linux-64", + "timestamp": 1588751930438, + "version": "3.8.2" + }, + "python-3.8.2-hcff3b4d_14.conda": { + "build": "hcff3b4d_14", + "build_number": 14, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "5939f16e977a753d77d768b6ff964f5a", + "name": "python", + "sha256": "8a68ef7c7b0f995c131d115cc66b120686d0c2fbb159f49cfcf7f94ccd787aed", + "size": 51583242, + "subdir": "linux-64", + "timestamp": 1588882023313, + "version": "3.8.2" + }, + "python-3.8.3-hcff3b4d_0.conda": { + "build": "hcff3b4d_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.31.1,<4.0a0", + "tk >=8.6.8,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "360698b201c960100325e00b0e42c4cb", + "name": "python", + "sha256": "dd6338cddfec95d8bdd1fe3f6a85a7c4ceaedc710b173ca2e43eb894aadf3b86", + "size": 51470325, + "subdir": "linux-64", + "timestamp": 1589914298793, + "version": "3.8.3" + }, + "python-3.8.3-hcff3b4d_2.conda": { + "build": "hcff3b4d_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.32.3,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "7238b50ec691c384673c12868d73f3e3", + "name": "python", + "sha256": "d5c13cdc1f87f2c555bc37206304fa5bfb6af6f14ec0467d0f7fc756a97762eb", + "size": 51455126, + "subdir": "linux-64", + "timestamp": 1593707215190, + "version": "3.8.3" + }, + "python-3.8.5-h7579374_1.conda": { + "build": "h7579374_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "fa19bb6876427f0aadd3e2c2804fbb61", + "name": "python", + "sha256": "85c7f9fa371140fa4a6e4d5d818ebe687a564884b0705e72b5729f6fd217b813", + "size": 51673600, + "subdir": "linux-64", + "timestamp": 1599204963050, + "version": "3.8.5" + }, + "python-3.8.5-hcff3b4d_0.conda": { + "build": "hcff3b4d_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1g,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.32.3,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF", + "md5": "1d3c3020a8c5a2c76472d37fa6b36c9f", + "name": "python", + "sha256": "164ef611122c99892eded2c33172274cd63da03b436f7b2eaf557fb0965dd4ef", + "size": 51746284, + "subdir": "linux-64", + "timestamp": 1596616980258, + "version": "3.8.5" + }, + "python-3.8.8-hdb3f193_4.conda": { + "build": "hdb3f193_4", + "build_number": 4, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1j,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "4f1e16654a9e471666e87d5b06684bbb", + "name": "python", + "sha256": "672de44a93509b1541ac12b10f91d55c7f5b1cfc921c207b3fe40989cbd1d81d", + "size": 52442949, + "subdir": "linux-64", + "timestamp": 1614203523008, + "version": "3.8.8" + }, + "python-3.8.8-hdb3f193_5.conda": { + "build": "hdb3f193_5", + "build_number": 5, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.35.4,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "266058a081e3164d6966e89e379177e6", + "name": "python", + "sha256": "0e2a7f1b0ec672f86e93651d6604f612c3fa536d0ba32ab07c9bfa5820ea56b2", + "size": 52424215, + "subdir": "linux-64", + "timestamp": 1618344138833, + "version": "3.8.8" + }, + "python-3.9.0-hcff3b4d_1.conda": { + "build": "hcff3b4d_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1h,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "0ef1fec81386548143f060f0ddc5430c", + "name": "python", + "sha256": "e18efd24cfa1b932da20db04f8ad3a63902f8a69f2fbe736767a4a6fa5b76f96", + "size": 19009984, + "subdir": "linux-64", + "timestamp": 1603370132569, + "version": "3.9.0" + }, + "python-3.9.0-hdb3f193_2.conda": { + "build": "hdb3f193_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1h,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "2e5ef015c2140b6cf635abfcbb3b526d", + "name": "python", + "sha256": "88ee0f492a2cefdaeb6c0d573cd3d984eb8547961a93edb449a290659014d90d", + "size": 19015005, + "subdir": "linux-64", + "timestamp": 1605451274209, + "version": "3.9.0" + }, + "python-3.9.1-hdb3f193_2.conda": { + "build": "hdb3f193_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1i,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "8f2361a19f04fc496ab841afcd7120b5", + "name": "python", + "sha256": "d604344ebf042bd69a083985ee1eb0d0f53c09c6018e5d70b1d2e58b8edba712", + "size": 18977517, + "subdir": "linux-64", + "timestamp": 1607697715126, + "version": "3.9.1" + }, + "python-3.9.11-h12debd9_1.conda": { + "build": "h12debd9_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1n,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.38.0,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "fb992d485c5f836b77e8fcdcda09c21f", + "name": "python", + "sha256": "7114da5d041e5b274bf36cd091e9c3dfacd03bfe8e03c5ba47bb5666c5098fcd", + "size": 20105060, + "subdir": "linux-64", + "timestamp": 1648462858132, + "version": "3.9.11" + }, + "python-3.9.11-h12debd9_2.conda": { + "build": "h12debd9_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1n,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.38.0,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "4d19ce8cf50a8083d2ce3ce0a4d7e847", + "name": "python", + "sha256": "78f51ea5ed3c68d6d2f561ae236f762829b3f9626beb07731ec2903fa495fe69", + "size": 20136359, + "subdir": "linux-64", + "timestamp": 1648581530575, + "version": "3.9.11" + }, + "python-3.9.12-h12debd9_0.conda": { + "build": "h12debd9_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1n,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.38.2,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "24e7b6490961f6e3dd7fa3ba24c9302f", + "name": "python", + "sha256": "c18b392689f70b642f033d81da958fcf23442bbe802784d39220ca9181820026", + "size": 20074700, + "subdir": "linux-64", + "timestamp": 1649142442563, + "version": "3.9.12" + }, + "python-3.9.12-h12debd9_1.conda": { + "build": "h12debd9_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1o,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.38.3,<4.0a0", + "tk >=8.6.11,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "8fdbad0e044d2b7057698d7f14643e21", + "name": "python", + "sha256": "1c42009f85749ef79a4cbd282d253a48d9c891f797014cd0c720c621e5ff75ae", + "size": 20086219, + "subdir": "linux-64", + "timestamp": 1654084160832, + "version": "3.9.12" + }, + "python-3.9.13-haa1d7c7_1.conda": { + "build": "haa1d7c7_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1q,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.39.2,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "cddc61ff7dc45a9e62e9539a34ff5ea1", + "name": "python", + "sha256": "e7e04697736b1183a26103cd570e5af58b5c3be05be32ded8ad349e916944713", + "size": 21814320, + "subdir": "linux-64", + "timestamp": 1661470658566, + "version": "3.9.13" + }, + "python-3.9.13-haa1d7c7_2.conda": { + "build": "haa1d7c7_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1q,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.39.3,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "bc96fed6f371bc742ef340921fe90139", + "name": "python", + "sha256": "ce3646b743aaea21e94ba0faab59cde317cf76c7dc7398d3f3e0d6b0960019f5", + "size": 21870628, + "subdir": "linux-64", + "timestamp": 1665696352828, + "version": "3.9.13" + }, + "python-3.9.15-h7a1cb2a_2.conda": { + "build": "h7a1cb2a_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.0,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "11aaa2155e45d001f854b7edb84bca39", + "name": "python", + "sha256": "2e074bc3e5255df345f4762793a9f168b1a6c4590769da54507bbbf835c0f007", + "size": 26237883, + "subdir": "linux-64", + "timestamp": 1669300943987, + "version": "3.9.15" + }, + "python-3.9.15-haa1d7c7_0.conda": { + "build": "haa1d7c7_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1q,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.39.3,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "dacae2189e4ec6083804b07b44f1a342", + "name": "python", + "sha256": "1f5bd4c2013195a0fb000bdf2b05f23933f028545883cba6ceaa819aadbfbbb6", + "size": 26237566, + "subdir": "linux-64", + "timestamp": 1667579086368, + "version": "3.9.15" + }, + "python-3.9.16-h7a1cb2a_0.conda": { + "build": "h7a1cb2a_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.40.1,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.8,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "96bf57511e8c12045397dbef70b31adb", + "name": "python", + "sha256": "c687e91cf0eacd45185d24d694da5a633ce1f429e2fe968fbaa703c8701cf247", + "size": 26256513, + "subdir": "linux-64", + "timestamp": 1673453819331, + "version": "3.9.16" + }, + "python-3.9.16-h7a1cb2a_1.conda": { + "build": "h7a1cb2a_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.4,<7.0a0", + "openssl >=1.1.1t,<1.1.2a", + "readline >=8.0,<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" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "a433fba272187ee7fe9b3c26f468dd52", + "name": "python", + "sha256": "e1e0d3ef7ed5b1a200a12feabb990e60b2c6dc4bd27ecc59cb432f75e5c662e8", + "size": 26298770, + "subdir": "linux-64", + "timestamp": 1677695587313, + "version": "3.9.16" + }, + "python-3.9.16-h7a1cb2a_2.conda": { + "build": "h7a1cb2a_2", + "build_number": 2, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "ncurses >=6.4,<7.0a0", + "openssl >=1.1.1t,<1.1.2a", + "readline >=8.0,<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" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "6b4f255f11b3facb3fa17061757b8cc2", + "name": "python", + "sha256": "b6936b8c9a0ad9f0c847666cd93b1f71a94dd336175df99b153b65733f9386b3", + "size": 26291113, + "subdir": "linux-64", + "timestamp": 1678284637555, + "version": "3.9.16" + }, + "python-3.9.2-hdb3f193_0.conda": { + "build": "hdb3f193_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1j,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.33.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "aecaa2507c1df9aaac5717baafb34adb", + "name": "python", + "sha256": "a065b3884ffabce8c0081c2721e45811125547b3474af3a8084c4c7017f0e5fa", + "size": 19077280, + "subdir": "linux-64", + "timestamp": 1614802478495, + "version": "3.9.2" + }, + "python-3.9.4-hdb3f193_0.conda": { + "build": "hdb3f193_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.35.4,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "378eea638cda4833b304f2d51da0076a", + "name": "python", + "sha256": "f1828d4427600f650e4897eaa517d33d26991faec21843acfb199bdcf338424a", + "size": 19084112, + "subdir": "linux-64", + "timestamp": 1617986779944, + "version": "3.9.4" + }, + "python-3.9.5-hdb3f193_3.conda": { + "build": "hdb3f193_3", + "build_number": 3, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.35.4,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "9165a5c5112ebaa60d9a589f5c7c83cb", + "name": "python", + "sha256": "305011328c7722d7ca071c5a12eae2633114b546c2196ed7608f50e93891c4d9", + "size": 19000608, + "subdir": "linux-64", + "timestamp": 1621367201947, + "version": "3.9.5" + }, + "python-3.9.6-h12debd9_0.conda": { + "build": "h12debd9_0", + "build_number": 0, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.36.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "823a9917957e2e2f935630f28803e7e7", + "name": "python", + "sha256": "83ff4c51f052465cb5ee7731e17338bb0e570d33e80b9fd860859f0e76ff4cb1", + "size": 19340988, + "subdir": "linux-64", + "timestamp": 1627663625551, + "version": "3.9.6" + }, + "python-3.9.6-h12debd9_1.conda": { + "build": "h12debd9_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1k,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.36.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "f982bc2ff8b764e0b47922e8ae85e206", + "name": "python", + "sha256": "5e7fa390d614a0093db25337b2772928708be3af6387fa57a6c0c4facc59b7ab", + "size": 19318315, + "subdir": "linux-64", + "timestamp": 1629316126728, + "version": "3.9.6" + }, + "python-3.9.7-h12debd9_1.conda": { + "build": "h12debd9_1", + "build_number": 1, + "depends": [ + "ld_impl_linux-64", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "openssl >=1.1.1l,<1.1.2a", + "readline >=8.0,<9.0a0", + "sqlite >=3.36.0,<4.0a0", + "tk >=8.6.10,<8.7.0a0", + "tzdata", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Python-2.0", + "md5": "b3b5f154aca62e01eff1f12522090495", + "name": "python", + "sha256": "accb987a8d60d569e705e6947e814dfca162bc98e1b8d5384b8e7545c61d9e57", + "size": 19468747, + "subdir": "linux-64", + "timestamp": 1631798518713, + "version": "3.9.7" + }, + "python-bidi-0.4.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "ef10c9ef55381d009fb1b574f3226a49", + "name": "python-bidi", + "sha256": "3fa050c34f8209806c0c058427defe3b98056314b9a53c276e01b04c3c7db67d", + "size": 39875, + "subdir": "linux-64", + "timestamp": 1664435164885, + "version": "0.4.2" + }, + "python-bidi-0.4.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "d11652c386d18c5b192aa1cd49074e76", + "name": "python-bidi", + "sha256": "8e9bdb866e9d166fd36608cf7239f48ba482c87ee39df74b46d16cb1c6e9e8db", + "size": 43654, + "subdir": "linux-64", + "timestamp": 1676861397484, + "version": "0.4.2" + }, + "python-bidi-0.4.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "ef4af94eea0d8727ed318b28642e8948", + "name": "python-bidi", + "sha256": "a0d93d459ad25bc0fdc7333f514cea9431c2a6a877064074e4054e3035e191f1", + "size": 38222, + "subdir": "linux-64", + "timestamp": 1664435213318, + "version": "0.4.2" + }, + "python-bidi-0.4.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "cae05114d4ba0f7a19689df41471d2be", + "name": "python-bidi", + "sha256": "3a60f0d8090914b853d36c3ddf64edfcfd251b29e00ec966c6a42e20e26d1767", + "size": 38451, + "subdir": "linux-64", + "timestamp": 1664435188957, + "version": "0.4.2" + }, + "python-bidi-0.4.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "42fcb2c1b399f7ce33719ead8a240c61", + "name": "python-bidi", + "sha256": "9099e130082f085f2192dacccd42c504306889e924f2b2cf7d9acc345dba529e", + "size": 39191, + "subdir": "linux-64", + "timestamp": 1664435127790, + "version": "0.4.2" + }, + "python-blosc-1.10.6-py310h00e6091_0.conda": { + "build": "py310h00e6091_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e59a75a4847d158b04b92b31d5888e11", + "name": "python-blosc", + "sha256": "245940218d45f8c89cbbebdd64c0a3b24e3aef66f096074d2b07a7db693a30f8", + "size": 48486, + "subdir": "linux-64", + "timestamp": 1640818545906, + "version": "1.10.6" + }, + "python-blosc-1.10.6-py311hba01205_0.conda": { + "build": "py311hba01205_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.3,<2.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "65e90208ff8f55782d5ecf3301fffd6b", + "name": "python-blosc", + "sha256": "95fc274466f1fa04c18db25d58f9e0261aa75b82354a46b84c37cb958eec0891", + "size": 53624, + "subdir": "linux-64", + "timestamp": 1676861425299, + "version": "1.10.6" + }, + "python-blosc-1.10.6-py37h51133e4_0.conda": { + "build": "py37h51133e4_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38512818b94086361d7b403ad3bb1453", + "name": "python-blosc", + "sha256": "37e184ede57e0741a7dc116984221df05abb67df160d6b8b63b59708f0c13196", + "size": 50169, + "subdir": "linux-64", + "timestamp": 1638539227297, + "version": "1.10.6" + }, + "python-blosc-1.10.6-py38h51133e4_0.conda": { + "build": "py38h51133e4_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b46d9321abf90d20079ba8506c790c33", + "name": "python-blosc", + "sha256": "8fa4bdd91581d40d9d10c49b352479c0c1397f5679b917efa8cda078b1649c94", + "size": 49415, + "subdir": "linux-64", + "timestamp": 1638539873444, + "version": "1.10.6" + }, + "python-blosc-1.10.6-py39h51133e4_0.conda": { + "build": "py39h51133e4_0", + "build_number": 0, + "depends": [ + "blosc >=1.21.0,<2.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "471fdceba4e9f18b63b4c0f29cd1c566", + "name": "python-blosc", + "sha256": "8b5ebecfb64c9f32b2340a3dff92ad8fb54342141c4f0b3de0f0f2b0cf4a3826", + "size": 47805, + "subdir": "linux-64", + "timestamp": 1638539872894, + "version": "1.10.6" + }, + "python-blosc-1.4.4-py27hf341b41_0.conda": { + "build": "py27hf341b41_0", + "build_number": 0, + "depends": [ + "blosc >=1.12.0,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7ce5107e358489356f51c0a5540339e0", + "name": "python-blosc", + "sha256": "276a9ae984e1abd4e1dd3b5aa95055d9b6e3edf9f291fdc5b1059be632136d36", + "size": 26401, + "subdir": "linux-64", + "timestamp": 1511806526501, + "version": "1.4.4" + }, + "python-blosc-1.4.4-py35he4ae7a7_0.conda": { + "build": "py35he4ae7a7_0", + "build_number": 0, + "depends": [ + "blosc >=1.12.0,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4e2ff0258a1888c7ed1d99549e743177", + "name": "python-blosc", + "sha256": "fc206ddac58cef08528e03bca716869281ecf94c3ba9601f63fa71e1b726d08c", + "size": 26724, + "subdir": "linux-64", + "timestamp": 1511806525453, + "version": "1.4.4" + }, + "python-blosc-1.4.4-py36hff4f6c4_0.conda": { + "build": "py36hff4f6c4_0", + "build_number": 0, + "depends": [ + "blosc >=1.12.0,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3095cb47893179eb798c456e27f1d22c", + "name": "python-blosc", + "sha256": "62aa2a60a409b4cc5074d157271fc214d6c60ad724294f933a8bea63cb97e5d8", + "size": 26339, + "subdir": "linux-64", + "timestamp": 1511806528449, + "version": "1.4.4" + }, + "python-blosc-1.5.1-py27h14c3975_1.conda": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "be0a6e75550ec3dc4c064ee3643b7104", + "name": "python-blosc", + "sha256": "958f7963aa553ba102a13c53b20282fab577a3acda3e2a51766eb0e7d0d2899b", + "size": 27433, + "subdir": "linux-64", + "timestamp": 1530922617004, + "version": "1.5.1" + }, + "python-blosc-1.5.1-py27h14c3975_2.conda": { + "build": "py27h14c3975_2", + "build_number": 2, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "440ebf14f757567db0663739dfb23fab", + "name": "python-blosc", + "sha256": "07e6310b2f72c05c117224c87e27a5a0aebbde20f7607f06cbfc4f08d1b5f735", + "size": 39003, + "subdir": "linux-64", + "timestamp": 1531093145165, + "version": "1.5.1" + }, + "python-blosc-1.5.1-py27h3872d65_1.conda": { + "build": "py27h3872d65_1", + "build_number": 1, + "depends": [ + "blosc >=1.12.0,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e853aadc18c3eda4e9b38a4f10d7715b", + "name": "python-blosc", + "sha256": "94ae2e665c6902afb23103dffe3f5f7e60ce1a6308555c266b6842cee20a0faf", + "size": 27621, + "subdir": "linux-64", + "timestamp": 1511879559473, + "version": "1.5.1" + }, + "python-blosc-1.5.1-py35h995797e_1.conda": { + "build": "py35h995797e_1", + "build_number": 1, + "depends": [ + "blosc >=1.12.0,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "57e10c550ec3ea7e8fb72093a6e33195", + "name": "python-blosc", + "sha256": "f177f2cee8209bddcd9faa2716527fb79ffbff823d9740f3ee73e84e87492a06", + "size": 27974, + "subdir": "linux-64", + "timestamp": 1511879717585, + "version": "1.5.1" + }, + "python-blosc-1.5.1-py36h14c3975_1.conda": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b0c002565829e8deabb817ea7a893f11", + "name": "python-blosc", + "sha256": "b1c96a1e1879cf4212327cf569329882082944cb468cdf1fe2d21c5f6b7cf526", + "size": 27448, + "subdir": "linux-64", + "timestamp": 1530922546268, + "version": "1.5.1" + }, + "python-blosc-1.5.1-py36h14c3975_2.conda": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "93790637332a7c319268bb8db41a3966", + "name": "python-blosc", + "sha256": "da6f98235587f592533605f909793cddc35bf629a50d4e1b7aba49b31252bc41", + "size": 39003, + "subdir": "linux-64", + "timestamp": 1531093109587, + "version": "1.5.1" + }, + "python-blosc-1.5.1-py36h2adc113_1.conda": { + "build": "py36h2adc113_1", + "build_number": 1, + "depends": [ + "blosc >=1.12.0,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "30e227c3d71a0425c82715316f8717ed", + "name": "python-blosc", + "sha256": "3c6cfaf6a1b5be01577690a5bd82c77cb5da650d0a5432815eec6426a6703032", + "size": 27626, + "subdir": "linux-64", + "timestamp": 1511879718010, + "version": "1.5.1" + }, + "python-blosc-1.5.1-py37h14c3975_1.conda": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "293936fa90ee6f1028dd89db615b6834", + "name": "python-blosc", + "sha256": "8e1be722e5cc9361373dab579da95ae86b6edccc388ba38a69510f07b43d3d18", + "size": 27555, + "subdir": "linux-64", + "timestamp": 1530922580916, + "version": "1.5.1" + }, + "python-blosc-1.5.1-py37h14c3975_2.conda": { + "build": "py37h14c3975_2", + "build_number": 2, + "depends": [ + "blosc >=1.14.3,<2.0a0", + "libgcc-ng >=7.2.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e70dc78ea1752ff74445d7229ed25bc3", + "name": "python-blosc", + "sha256": "2983fd8143387efe6a5e5dcbd1b90d0d76f41beb221444c7e0fc057710ea3b47", + "size": 39065, + "subdir": "linux-64", + "timestamp": 1531093179693, + "version": "1.5.1" + }, + "python-blosc-1.7.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "blosc >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a9cf29a34b180f64efaa52aeb98c15d1", + "name": "python-blosc", + "sha256": "4cc1c8382a7077a8476346f3820f4e225095bbee9bc069df0c9dae667eb56537", + "size": 42697, + "subdir": "linux-64", + "timestamp": 1548005833998, + "version": "1.7.0" + }, + "python-blosc-1.7.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "blosc >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "54fc1b69cca4be28cee5aceca2f957f6", + "name": "python-blosc", + "sha256": "759a3d801da3b75827b49f9c407812030155085f44a0948063c40195bcfac36c", + "size": 42923, + "subdir": "linux-64", + "timestamp": 1548005112958, + "version": "1.7.0" + }, + "python-blosc-1.7.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "blosc >=1.15.0,<2.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ce7f110567c18bff511a81ed0c4a1cbe", + "name": "python-blosc", + "sha256": "6f0cc7f6fb198fc2963d6781ed93685b56a012d86bc692c7358d3d7eac59faf5", + "size": 42963, + "subdir": "linux-64", + "timestamp": 1548005113501, + "version": "1.7.0" + }, + "python-blosc-1.7.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "blosc >=1.16.3,<2.0a0", + "libgcc-ng >=7.3.0", + "numpy", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c2c77def6531a7de4ca3f94b7f2acb37", + "name": "python-blosc", + "sha256": "95a0a3bf55c3af24d9de1f82c6f23d7f89b1b863a62c7f2253a8990b3d9dce2e", + "size": 48746, + "subdir": "linux-64", + "timestamp": 1574094348814, + "version": "1.7.0" + }, + "python-build-0.10.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "pyproject_hooks", + "python >=3.10,<3.11.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2547f3b704da42ab17585bdb48d2d259", + "name": "python-build", + "sha256": "b883e963582608d2b7f48d01879489220c4810b3c166e69223fd374ab41347d4", + "size": 38138, + "subdir": "linux-64", + "timestamp": 1679596564108, + "version": "0.10.0" + }, + "python-build-0.10.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "pyproject_hooks", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "704c8724117a5d34981fb62aaf53f909", + "name": "python-build", + "sha256": "c08543a7be7343f841b2eb2fd26210a34e533b627aefdf3f2e8c622dc087e830", + "size": 47526, + "subdir": "linux-64", + "timestamp": 1679596590511, + "version": "0.10.0" + }, + "python-build-0.10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "pyproject_hooks", + "python >=3.8,<3.9.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ecd15b86b45aa9abc9f4c64f4d2bfd8", + "name": "python-build", + "sha256": "3ec5b258ffa05a6a08befc1babd22e0f5fc373d3277f5c121eb7550f95a98623", + "size": 37837, + "subdir": "linux-64", + "timestamp": 1679596616428, + "version": "0.10.0" + }, + "python-build-0.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=19.0", + "pyproject_hooks", + "python >=3.9,<3.10.0a0", + "tomli >=1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2669bf5fefc63aa8709d167192ae2b79", + "name": "python-build", + "sha256": "6e93412756410bcd7748fcf17a90c13e923f357a77206a98ae4789a585aba52c", + "size": 37874, + "subdir": "linux-64", + "timestamp": 1679596537656, + "version": "0.10.0" + }, + "python-chromedriver-binary-2.38.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "chromedriver-binary 2.38 0", + "python >=2.7,<2.8.0a0" + ], + "license": "3-Clause BSD", + "license_family": "BSD", + "md5": "36e8b204247a176a2e812f076d673aec", + "name": "python-chromedriver-binary", + "sha256": "97ee12ef50d99184f45e4f0af7f25005d31e60ccc6e9469455ac7dd1e57dceaf", + "size": 11066, + "subdir": "linux-64", + "timestamp": 1527560012431, + "version": "2.38.0" + }, + "python-chromedriver-binary-2.38.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "chromedriver-binary 2.38 0", + "python >=3.5,<3.6.0a0" + ], + "license": "3-Clause BSD", + "license_family": "BSD", + "md5": "e8e6d04bcefb4319cad4d373e7b19e52", + "name": "python-chromedriver-binary", + "sha256": "08a38a49d58df9173e1214fc0193c8e127b15d0f1d810f7ba2350d28e7dbd60f", + "size": 11142, + "subdir": "linux-64", + "timestamp": 1527560001190, + "version": "2.38.0" + }, + "python-chromedriver-binary-2.38.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "chromedriver-binary 2.38 0", + "python >=3.6,<3.7.0a0" + ], + "license": "3-Clause BSD", + "license_family": "BSD", + "md5": "70c0681b31b143c9d06e4acefcbf72bc", + "name": "python-chromedriver-binary", + "sha256": "02f0935294c5f67e570a05d67af513f893fdf357d11d695ed7f2e7304c155031", + "size": 11088, + "subdir": "linux-64", + "timestamp": 1527559989242, + "version": "2.38.0" + }, + "python-clang-14.0.6-default_py310h261c368_0.conda": { + "build": "default_py310h261c368_0", + "build_number": 0, + "depends": [ + "libclang 14.0.6", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "d5a77545b31d3195f8562adf5647bf0c", + "name": "python-clang", + "sha256": "cd44f653c082801c0d06e3b5563bfb7282d3f5a8c0bab744319b0be3b7234185", + "size": 199431, + "subdir": "linux-64", + "timestamp": 1661930439227, + "version": "14.0.6" + }, + "python-clang-14.0.6-default_py311h261c368_0.conda": { + "build": "default_py311h261c368_0", + "build_number": 0, + "depends": [ + "libclang 14.0.6", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "6a378fe6b1c0b0f09d1cc72a9edebc68", + "name": "python-clang", + "sha256": "4d105b6367b95caa2d7d557d0d2d285bc20248f2cfc0cdf287abed9c86a407d9", + "size": 213958, + "subdir": "linux-64", + "timestamp": 1676851081917, + "version": "14.0.6" + }, + "python-clang-14.0.6-default_py37h261c368_0.conda": { + "build": "default_py37h261c368_0", + "build_number": 0, + "depends": [ + "libclang 14.0.6", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "74509b13247f5a9dd151d1962d8257c5", + "name": "python-clang", + "sha256": "5c73efa2aba3da2376101669af4ce52c0f5aa8f7268102a0a628851886634965", + "size": 197723, + "subdir": "linux-64", + "timestamp": 1661930467636, + "version": "14.0.6" + }, + "python-clang-14.0.6-default_py38h261c368_0.conda": { + "build": "default_py38h261c368_0", + "build_number": 0, + "depends": [ + "libclang 14.0.6", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "cb731529bbea55842f4e086a20c96c0b", + "name": "python-clang", + "sha256": "c2ce216229b6d0e7a0b77cdbc3fa62b07c9bd530196072dd285c18781edf402b", + "size": 198130, + "subdir": "linux-64", + "timestamp": 1661930447752, + "version": "14.0.6" + }, + "python-clang-14.0.6-default_py39h261c368_0.conda": { + "build": "default_py39h261c368_0", + "build_number": 0, + "depends": [ + "libclang 14.0.6", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 WITH LLVM-exception", + "license_family": "Apache", + "md5": "a0c0a9cc84e105cdbfb10d468ccf349c", + "name": "python-clang", + "sha256": "28133272ed4f0a715bb195bf5de1c2067b4e109c8faf354536e511e4ea40da88", + "size": 198039, + "subdir": "linux-64", + "timestamp": 1661930459169, + "version": "14.0.6" + }, + "python-crfsuite-0.9.5-py27h6bb024c_0.conda": { + "build": "py27h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14803c8e70bfa91a87baa222b9497459", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "7fe69f89072beebe40aa7bbbda19e3bdd1d6087fa2a329485be534b59a6cdc23", + "size": 173284, + "subdir": "linux-64", + "timestamp": 1525817318438, + "version": "0.9.5" + }, + "python-crfsuite-0.9.5-py35h6bb024c_0.conda": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "670d1b10be37335d9c69daa731e5ff99", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "c1bca93c20039cc2ba1d10dacb3daea575934cf145d31dd0c54ea8b3e6d05db4", + "size": 174941, + "subdir": "linux-64", + "timestamp": 1525817410998, + "version": "0.9.5" + }, + "python-crfsuite-0.9.5-py36h6bb024c_0.conda": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b4f9ca57d19550f4d3748d40c2d7083", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "4b6c973c127326ee35ca85acabffebe54f74c78b88be095041c1c446a870b853", + "size": 176647, + "subdir": "linux-64", + "timestamp": 1525817413420, + "version": "0.9.5" + }, + "python-crfsuite-0.9.6-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1aad9acf7de9d47db8f4303f162eeab5", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "30c6e7e8acc82f39041152c0bf5bd021e0cecab2196beeb4c5431f37721f6e2b", + "size": 177459, + "subdir": "linux-64", + "timestamp": 1535179386778, + "version": "0.9.6" + }, + "python-crfsuite-0.9.6-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "615d6a46e42177f3510a4d3fd24ee578", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "8a90a607fb552c28c7ee4caeb1d8082a39db6c7581e110be55e71464d1ee4b00", + "size": 178380, + "subdir": "linux-64", + "timestamp": 1535179449847, + "version": "0.9.6" + }, + "python-crfsuite-0.9.6-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0adfa0dd01dcbcec7fc9df18f9bc262e", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "c1fa23708df927efa90084a53876c3aee15698ede38c3889caafa07d668af4eb", + "size": 186301, + "subdir": "linux-64", + "timestamp": 1613553302328, + "version": "0.9.6" + }, + "python-crfsuite-0.9.6-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23197f72d8c9b66765678311dbff7f0c", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "befde7d3876f3452035c4ff27c59fdd8931e7a85eb6e2cbb26834a759ac63d5a", + "size": 182790, + "subdir": "linux-64", + "timestamp": 1535179444454, + "version": "0.9.6" + }, + "python-crfsuite-0.9.6-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f5b6569c997ae48b2210275ecee2377", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "0fb87a99bdc1d5280b1076775667f481e95d24047f2b1c4cebee9dd53ed7551a", + "size": 184031, + "subdir": "linux-64", + "timestamp": 1613553952450, + "version": "0.9.6" + }, + "python-crfsuite-0.9.6-py37hf484d3e_0.conda": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ebbd58be106d02cf98c9cd7457a55b4", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "1c544015f7e467a52f13de4c896b625806b05a9c279a6a028d7bba244b9c0f03", + "size": 181809, + "subdir": "linux-64", + "timestamp": 1535179380200, + "version": "0.9.6" + }, + "python-crfsuite-0.9.6-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b26f1225e12749bbd5a8e6229da17d1", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "1f84e1c5eae402a3dfa12de5d7a439bff046246244149f4fe7600ef1957d6823", + "size": 189207, + "subdir": "linux-64", + "timestamp": 1613553325362, + "version": "0.9.6" + }, + "python-crfsuite-0.9.6-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d675bc1bcd5ad367e78f947d60e7b2d3", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "3d733a162a59c000ca9f18e7b1a0872eb5ce851fab1f0bfe9920413b4896db28", + "size": 192013, + "subdir": "linux-64", + "timestamp": 1573200441300, + "version": "0.9.6" + }, + "python-crfsuite-0.9.7-py310h295c915_1.conda": { + "build": "py310h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d92c41c9798f11b9c2f327b269994e69", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "eaa8e78a0a0527096335d5819583b95ce86f0144070ce236846e32f68876de90", + "size": 644868, + "subdir": "linux-64", + "timestamp": 1643101022033, + "version": "0.9.7" + }, + "python-crfsuite-0.9.7-py36h2531618_1.conda": { + "build": "py36h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a388f0f18d6b703a66d30f5c3f8c8057", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "6061325bf55ee4137dae80e7b2d93996019c6205947c93cb7df4c418b473fcf2", + "size": 183075, + "subdir": "linux-64", + "timestamp": 1613555035975, + "version": "0.9.7" + }, + "python-crfsuite-0.9.7-py37h2531618_1.conda": { + "build": "py37h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15375dc7ca9d09f64508a305dca691c2", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "29af97062fe371e1444e0c05017733387184cb99605ade16c944a33766e3aba6", + "size": 182099, + "subdir": "linux-64", + "timestamp": 1613555027704, + "version": "0.9.7" + }, + "python-crfsuite-0.9.7-py38h2531618_1.conda": { + "build": "py38h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "36762e72ef5ad88403f8b7a68f6be50e", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "317840b0004f85d425587baf6ad5dbdc8fc185350211a712426739af044f5a5c", + "size": 185278, + "subdir": "linux-64", + "timestamp": 1613554293146, + "version": "0.9.7" + }, + "python-crfsuite-0.9.7-py39h2531618_1.conda": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a83142d7c763628f950e05e9f16122b", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "ac07051b6588f40927ae280ed6f68b26e7685113db9013fd84b19fc7df417307", + "size": 186986, + "subdir": "linux-64", + "timestamp": 1613555034219, + "version": "0.9.7" + }, + "python-crfsuite-0.9.9-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d59e7a703d3c5e32e02b3ee7da2f8298", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "0f997dbb2210439d1767abbfd8bf7c5cbcde5588fc9361232d17123314bafff2", + "size": 193274, + "subdir": "linux-64", + "timestamp": 1676300687729, + "version": "0.9.9" + }, + "python-crfsuite-0.9.9-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e90807b5c601c98d0277b0b7699c09c4", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "dda0fe50c2b366e28998790194d633bd0c48a555927ce08c6bc3f9ef8cd1818d", + "size": 175065, + "subdir": "linux-64", + "timestamp": 1676861452432, + "version": "0.9.9" + }, + "python-crfsuite-0.9.9-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4fe64445bef79960c44e7cd53e00b78", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "14171f431273f253210e754f395fb2d290eaa4298859283850ab00a7a042e241", + "size": 194511, + "subdir": "linux-64", + "timestamp": 1676300641857, + "version": "0.9.9" + }, + "python-crfsuite-0.9.9-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c93eadd4176552d407aac2316ac3c85", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "134a4c955a75ccfe7646190af19be0e78364498a024caefd47b061c5ce6e547c", + "size": 196569, + "subdir": "linux-64", + "timestamp": 1676300738025, + "version": "0.9.9" + }, + "python-crfsuite-0.9.9-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "696ea6d850fe06a019fddcd4fb5944db", + "name": "python-crfsuite", + "namespace_in_name": true, + "sha256": "e785fc165d224f4501c3f11bd058267c5060f80c91754bc5b295480548a063ef", + "size": 194714, + "subdir": "linux-64", + "timestamp": 1676300782809, + "version": "0.9.9" + }, + "python-daemon-2.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "b6bdec9a1f51c5d58afe4dd024e5e54f", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "7d21bcf8d23272c49d5d5f6f7283c30f72c23fb15c5de10d3f2b56f7b80a73c0", + "size": 26127, + "subdir": "linux-64", + "timestamp": 1530898967985, + "version": "2.1.2" + }, + "python-daemon-2.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "dec76c2fa664e18c5988befac984d7e0", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "0adc50e69818c588e7d586c296e373ffb7182596c9b351d3d7de619290d3cfb4", + "size": 26401, + "subdir": "linux-64", + "timestamp": 1530899029202, + "version": "2.1.2" + }, + "python-daemon-2.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "c9d08ff808616979c0456f52bc5d89d1", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "25d9a55a432098cbe6def553460a385a9076f96eabc6a4ed27f7afed5c872a5b", + "size": 26511, + "subdir": "linux-64", + "timestamp": 1530898998526, + "version": "2.1.2" + }, + "python-daemon-2.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "9644adf97d39924aab2820d3acd94c31", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "30b7782c3e8db6df200421dac8876b64e0e7c15ab719c4943da27dd277597c0a", + "size": 27752, + "subdir": "linux-64", + "timestamp": 1535521584709, + "version": "2.2.0" + }, + "python-daemon-2.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "2e9d85a8862247a947846bfdd92031b5", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "de83b37b19c0a618537eba8813cf7f1737387ebc874e3369a4cba4c7f28e3694", + "size": 28179, + "subdir": "linux-64", + "timestamp": 1535523335104, + "version": "2.2.0" + }, + "python-daemon-2.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "15d0b316b43a4cd0e6b8b51a67c7eff0", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "2358c30e028bdf4523895ad3d077ce13b1fa2a1515ca83040b4abc626533769b", + "size": 27771, + "subdir": "linux-64", + "timestamp": 1535521562744, + "version": "2.2.0" + }, + "python-daemon-2.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "f91002d71fdbe27fc43076f419c04a8a", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "a662b5aadee66594247e1f70ead83adc70421acb3fa97655e3bb39decb3e7714", + "size": 27831, + "subdir": "linux-64", + "timestamp": 1535521609612, + "version": "2.2.0" + }, + "python-daemon-2.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "2582fd793c1667f535840c0555c3c2d2", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "643b99825bcdda3c21dc06cebefc48d73aa384c2c72e9b81b200569af75731d5", + "size": 170828, + "subdir": "linux-64", + "timestamp": 1547983359673, + "version": "2.2.1" + }, + "python-daemon-2.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "41874b9e8bfdf23ab9e8e05c3bc57bfb", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "f888bd336b70e30fe0d8310e482b74368b999fbc400c5b043641972f2af67ba9", + "size": 171134, + "subdir": "linux-64", + "timestamp": 1547983450012, + "version": "2.2.1" + }, + "python-daemon-2.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "2995b148c8b08313dd206f2067427b3f", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "bc5cd861c44ac966fd0ad870f6a75f305d17ea5b65bb1ae4c2c28f99076b0794", + "size": 171116, + "subdir": "linux-64", + "timestamp": 1547983496291, + "version": "2.2.1" + }, + "python-daemon-2.2.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "5f5cac3d3382509946de15199dbe3725", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "be7c8e19c43578f0e85510de8a7378f216e0d2aa5a9aa4aba2f410978678bfad", + "size": 179624, + "subdir": "linux-64", + "timestamp": 1552365999787, + "version": "2.2.3" + }, + "python-daemon-2.2.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "6e8bf169bc1fdea74eecad53496700cf", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "66933e4359572f5089076ffe0854e2a0d2fc7ad0df9c476b2b99daa78ae608ec", + "size": 180137, + "subdir": "linux-64", + "timestamp": 1552366037977, + "version": "2.2.3" + }, + "python-daemon-2.2.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "b30ad367ce4da3412ed5f053668ff94a", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "9a859d1926f1aced191df250e01e8973ee65c08dd7a96865463f4bf0ce990712", + "size": 180745, + "subdir": "linux-64", + "timestamp": 1552365998704, + "version": "2.2.3" + }, + "python-daemon-2.2.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "8d126c0c38fb245b399a00c2a4fbd45c", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "d53a83c1d2fa5c0b5f961edcf9671ffb4b9a9114bf3a36d2a5d79b964ede5ade", + "size": 328486, + "subdir": "linux-64", + "timestamp": 1636034744906, + "version": "2.2.3" + }, + "python-daemon-2.2.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "47caefbd5de92755f5e0bd350f1a37e1", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "323a781653194829f22e5fb76fe04d238935b746fd13c1c6ce3e2493d01ac216", + "size": 28583, + "subdir": "linux-64", + "timestamp": 1574273943275, + "version": "2.2.3" + }, + "python-daemon-2.2.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "642e3a9a61544f024cafcc0e72817d9a", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "0d4bb0c6b2694fcb5c7f770c19d276b00631e4a707de33f8caa587272326e403", + "size": 328497, + "subdir": "linux-64", + "timestamp": 1636034747174, + "version": "2.2.3" + }, + "python-daemon-2.2.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "Apache Software License", + "license_family": "APACHE", + "md5": "3a4aa642cf514c47c8b0526473a1d661", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "35dc9035523feea27431798c6e1221d7e085b69c00d23080f3e97039dc9c4761", + "size": 328604, + "subdir": "linux-64", + "timestamp": 1636034221575, + "version": "2.2.3" + }, + "python-daemon-2.2.4-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b03bc8ed7b206c41feeaa1f6f9a93ca1", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "faf5521b744c6a2cca67ac46f0d3c6138aa498dabfb220ebbfc727efb8772c98", + "size": 44447, + "subdir": "linux-64", + "timestamp": 1600290951291, + "version": "2.2.4" + }, + "python-daemon-2.2.4-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "963a7981a5d2ba4ac80e0bde7e045ebd", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "7fa943d58d2864a75330260ef95538c14cffc0d52f2ed75fa7dc657de1ed5b1c", + "size": 44715, + "subdir": "linux-64", + "timestamp": 1613484938753, + "version": "2.2.4" + }, + "python-daemon-2.2.4-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f5742e8b18cea302ed876aa77bf01a63", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "3777411545d262a100fed5bb03069ccba04be51f5417b1aa6525ad5a904ba6e0", + "size": 44620, + "subdir": "linux-64", + "timestamp": 1600290969032, + "version": "2.2.4" + }, + "python-daemon-2.2.4-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5bdcb449d4d4c6f4124ac09b61b7967b", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "a3e3e1fef1a908d296cc65f3b7fbac88944c6839f2f12c0f555e84019bdb40dd", + "size": 44422, + "subdir": "linux-64", + "timestamp": 1613485566042, + "version": "2.2.4" + }, + "python-daemon-2.2.4-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "eaa3004c409f2547cd88143163250491", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "61ed6c291f0800706c28f069379bb07f2327e586e7e2087680c7ed9a63245dd6", + "size": 44590, + "subdir": "linux-64", + "timestamp": 1600290945293, + "version": "2.2.4" + }, + "python-daemon-2.2.4-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "35a9fb3e49f30ef80e1d1f688da924c4", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "03bc2ed3ef836163a857438a70e9381c5a696836372dd022ca121e5abd57f71d", + "size": 44791, + "subdir": "linux-64", + "timestamp": 1613485564040, + "version": "2.2.4" + }, + "python-daemon-2.2.4-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "0744c2c29a000381af050a89d40b8e73", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "6a605c39a4d212aafa1fa83f010c08ad82c49222756b5ceb0ab2b20a82a1096d", + "size": 44673, + "subdir": "linux-64", + "timestamp": 1613553305396, + "version": "2.2.4" + }, + "python-daemon-2.3.0-py310h06a4308_3.conda": { + "build": "py310h06a4308_3", + "build_number": 3, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f54ee83be1c2f583c2dd40eb76416c02", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "62d0db36e4173bad66d7842356263086806a0c6055d72a3c69644cab689babb1", + "size": 43559, + "subdir": "linux-64", + "timestamp": 1640829124107, + "version": "2.3.0" + }, + "python-daemon-2.3.0-py36h06a4308_3.conda": { + "build": "py36h06a4308_3", + "build_number": 3, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "4a330924d82dc5c57ae148ab1861e23d", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "29d4c820625238a319f6f10b21ed3d43d82c786ccdfc1bfdd73d8e199ba5e0e3", + "size": 43121, + "subdir": "linux-64", + "timestamp": 1613936318494, + "version": "2.3.0" + }, + "python-daemon-2.3.0-py37h06a4308_3.conda": { + "build": "py37h06a4308_3", + "build_number": 3, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f767129afa6256fd456e9a29be91f24b", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "59570f84aaea49c39075feac9600661e2147de8b5c9aca4e98f97defb728358d", + "size": 43247, + "subdir": "linux-64", + "timestamp": 1613936304725, + "version": "2.3.0" + }, + "python-daemon-2.3.0-py38h06a4308_3.conda": { + "build": "py38h06a4308_3", + "build_number": 3, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5810abe32f106fcf4ffc4a9c05386450", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "b16dc30cb68bb4694934b09dc7ad329305f8776d8544eaccd74597e90d094964", + "size": 43242, + "subdir": "linux-64", + "timestamp": 1613936318905, + "version": "2.3.0" + }, + "python-daemon-2.3.0-py39h06a4308_3.conda": { + "build": "py39h06a4308_3", + "build_number": 3, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "05f589f47315336201baaf50a13b617e", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "1acb89202efcc4bcd97b8668c6d9a630da0c0d705c8571c988c4c571ce8ee861", + "size": 43215, + "subdir": "linux-64", + "timestamp": 1613935857631, + "version": "2.3.0" + }, + "python-daemon-2.3.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "3ac720eaf207fb16c6efb6149d703f8d", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "2dafe931a87e42de70b129b22f19357ee2fa872a95ab59838abdddab192d0cbd", + "size": 42591, + "subdir": "linux-64", + "timestamp": 1659602443416, + "version": "2.3.1" + }, + "python-daemon-2.3.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "64612d798d5ec4fa0cae24e81573063f", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "373b1014692cb9d8311227ff9dc0b304769f4d9e568fe286c5c44556b7bd4bb8", + "size": 47232, + "subdir": "linux-64", + "timestamp": 1676904157786, + "version": "2.3.1" + }, + "python-daemon-2.3.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "39cc5758b104a010e5816461a62956e5", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "44bf7b0682d38b32de29f47d86b8f2e67381425c8c8de7bc16a65755a4c1c821", + "size": 42298, + "subdir": "linux-64", + "timestamp": 1659602406105, + "version": "2.3.1" + }, + "python-daemon-2.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b6841596a7e20a8920bf4727d53df4e6", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "8218c64fbc0ddf14679b3f0556a1c039e6bcee504dd262859454451dfeb9a7ec", + "size": 42300, + "subdir": "linux-64", + "timestamp": 1659602470122, + "version": "2.3.1" + }, + "python-daemon-2.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "docutils", + "lockfile >=0.10", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "e27bca588d413169eaad265449c32232", + "name": "python-daemon", + "namespace_in_name": true, + "sha256": "ee7b5bdd890c5697449b37c224babd5ceb8194229ca6c4f4dc9c5fa0d7e51288", + "size": 42329, + "subdir": "linux-64", + "timestamp": 1659602496757, + "version": "2.3.1" + }, + "python-dateutil-2.6.1-py27h4ca5741_1.conda": { + "build": "py27h4ca5741_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-clause", + "md5": "20052fa4202f0c1fc1b9ffcf98d911e2", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "51a62f303b8447ab2fe65ac02cd8e7a50bd900d98570d901d1ebfdeff7e43aec", + "size": 231816, + "subdir": "linux-64", + "timestamp": 1505688441572, + "version": "2.6.1" + }, + "python-dateutil-2.6.1-py35h90d5b31_1.conda": { + "build": "py35h90d5b31_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-clause", + "md5": "62af07ef62492be909c201725389a18e", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "13e13e41ea56bd8ed80d88e56fd0a696dde744e1de19f9c888ff9e737c37932a", + "size": 230356, + "subdir": "linux-64", + "timestamp": 1505688453376, + "version": "2.6.1" + }, + "python-dateutil-2.6.1-py36h88d3b88_1.conda": { + "build": "py36h88d3b88_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-clause", + "md5": "b732eab2f8d1654ed1963ffa68a6d976", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "cd5fea5bc916158f75d59e71a91c9fb5c6105965009f02c9f8b35ebb0de9276e", + "size": 229219, + "subdir": "linux-64", + "timestamp": 1505688465343, + "version": "2.6.1" + }, + "python-dateutil-2.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.5" + ], + "license": "BSD 3-clause", + "md5": "d55ae4aa9c670d337faeaf7bc618106a", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "eb2cc85226e248a6ca5b5299d833b2ab89cf64e436628787405ca6293ca2f590", + "size": 245794, + "subdir": "linux-64", + "timestamp": 1520876415656, + "version": "2.7.0" + }, + "python-dateutil-2.7.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.5" + ], + "license": "BSD 3-clause", + "md5": "07a5ca2fba97fa717fd1d610c981e7ce", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "fce2cba5dc79ef03c47331044a99267bccd8d4ca8aa4fbd74e63374a548c3788", + "size": 246910, + "subdir": "linux-64", + "timestamp": 1520876436142, + "version": "2.7.0" + }, + "python-dateutil-2.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.5" + ], + "license": "BSD 3-clause", + "md5": "2061a339e361d647c394df234e342643", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "a4154077b25b2dcab89f4b3dd924eda8aea72c3020947b43aa6d2a66db77759b", + "size": 248647, + "subdir": "linux-64", + "timestamp": 1520876390377, + "version": "2.7.0" + }, + "python-dateutil-2.7.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "c0a2ce075fcb116bccd038ce1ae89ac7", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "793c851bef6473d54c69198fb7c20371213e2773a8e8eee13830c1fd2ee7b437", + "size": 248990, + "subdir": "linux-64", + "timestamp": 1522167512810, + "version": "2.7.2" + }, + "python-dateutil-2.7.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "6a5956ca4b310eca091e54cc7cbb3cc2", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "724f9b74774ddb5700a29da5ce06ef865f9c653ef8cf8854d9dc7a4630cb4ab3", + "size": 252650, + "subdir": "linux-64", + "timestamp": 1522167551095, + "version": "2.7.2" + }, + "python-dateutil-2.7.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "f67ae6862d5bab845bdf6d03f9e85d3f", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "ecf723cfb48e4410775bed60da1310bb70d8253812fddde9bfcbb9d22731341a", + "size": 248884, + "subdir": "linux-64", + "timestamp": 1522167510208, + "version": "2.7.2" + }, + "python-dateutil-2.7.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "48b2f99c68974ecccec17ba4ccac503f", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "c9fe51d692d7b78f5b04b5d7157ee46c2c0e2fac35f45d7596c5d5a3167d8067", + "size": 254737, + "subdir": "linux-64", + "timestamp": 1526402969967, + "version": "2.7.3" + }, + "python-dateutil-2.7.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "6ba0bc65201239675c37e653abcaaa1f", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "a4a3512f4219b4467aceebf31c1f04cc2271008c3e297202e025ce974f6107d2", + "size": 254692, + "subdir": "linux-64", + "timestamp": 1526402994044, + "version": "2.7.3" + }, + "python-dateutil-2.7.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "5c4df3f369fbf5b62158659ae0ad8e51", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "e008b24cda702e39d610c71718a4ff5bc29d2eb8e70dcba75f7674ddc78251c6", + "size": 256159, + "subdir": "linux-64", + "timestamp": 1526402950261, + "version": "2.7.3" + }, + "python-dateutil-2.7.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "2c22b1daafb162e267c6552c0ca5b6f1", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "91e8d2bec9313965e48b081d826497c8847c96987f8b91bcf68eb2b6b221358a", + "size": 255691, + "subdir": "linux-64", + "timestamp": 1530694486059, + "version": "2.7.3" + }, + "python-dateutil-2.7.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "802845aa0c18c4557d690d0317b6c6d4", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "b78feb902e4302edf93cbb0848c5fe383c80ac9954e4d3adaac10b01f8019078", + "size": 268012, + "subdir": "linux-64", + "timestamp": 1541039148658, + "version": "2.7.5" + }, + "python-dateutil-2.7.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "7f96571d433acd30011082023ac0cae0", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "64044eae7c3e3e6ae96dab265db609b10f290b8f88536b2f727884b657bc8c0b", + "size": 270023, + "subdir": "linux-64", + "timestamp": 1541039132957, + "version": "2.7.5" + }, + "python-dateutil-2.7.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "ff8b30feee32e904051588fc0eb32004", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "373938abd742e115591ef2cbce30bd01a0da0fb90355fe95dc41c0c6499bd38a", + "size": 269741, + "subdir": "linux-64", + "timestamp": 1541039126810, + "version": "2.7.5" + }, + "python-dateutil-2.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "51f34b736b6b4b65eb1eb1425e8a1408", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "09b55bc594c5ddb777e8b3a44388ea70c84f9d5e39ded2462932fb19a7267b93", + "size": 272467, + "subdir": "linux-64", + "timestamp": 1551147427054, + "version": "2.8.0" + }, + "python-dateutil-2.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "d9a8110af330f3617138792a68b3aad0", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "cd66ad6955f1754684727ceb21dccb39c178deef1443c64b5dfb4bbe8f4bf74e", + "size": 274451, + "subdir": "linux-64", + "timestamp": 1551147445881, + "version": "2.8.0" + }, + "python-dateutil-2.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.5" + ], + "license": "BSD 3 Clause", + "md5": "fd462bec08b1909f3c5a38ba276a9a16", + "name": "python-dateutil", + "namespace_in_name": true, + "sha256": "49fd4ef7b58e9f5e7d9443c197cb16ca36082daea6a23a6d787c75e174ff14d4", + "size": 272236, + "subdir": "linux-64", + "timestamp": 1551196304636, + "version": "2.8.0" + }, + "python-dotenv-0.21.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click >=5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c923721de10b212c285e4addc52df5a6", + "name": "python-dotenv", + "sha256": "1910320a6afc1f5b5bfc1cbf47098e70bddabe273b8acabd9f4cc1b2b9484aaf", + "size": 34193, + "subdir": "linux-64", + "timestamp": 1669132662720, + "version": "0.21.0" + }, + "python-dotenv-0.21.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "click >=5.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6b0ead854c54dd99774c4359073997fc", + "name": "python-dotenv", + "sha256": "6bbecbc67fe83e1ddaa8c9a68579fa674ca4cf4a5bd54a8f5d837dbfa65fce0a", + "size": 40028, + "subdir": "linux-64", + "timestamp": 1676842333818, + "version": "0.21.0" + }, + "python-dotenv-0.21.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click >=5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8bedd81d06656ce8cc9500b656f58ca7", + "name": "python-dotenv", + "sha256": "6596dc545a544fdfba6ecf5218080e87725089b9c14cc21f6996f24d42f4994e", + "size": 33705, + "subdir": "linux-64", + "timestamp": 1669132637138, + "version": "0.21.0" + }, + "python-dotenv-0.21.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "29d969781dd26e1715eab4f998aabdca", + "name": "python-dotenv", + "sha256": "ce8cc8e54461b3213bb3b04b5c690424425aa9c6ccf59b2199287043774c45f5", + "size": 33891, + "subdir": "linux-64", + "timestamp": 1669132586501, + "version": "0.21.0" + }, + "python-dotenv-0.21.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aed1f1d3926e34e06e527bcac35b6581", + "name": "python-dotenv", + "sha256": "64e17a35eaed2e7f15a7f58c172c4e4763c40ff8601653fc66f701c838079766", + "size": 33889, + "subdir": "linux-64", + "timestamp": 1669132611768, + "version": "0.21.0" + }, + "python-editor-1.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d02692bf5bd432d285720a5626aaf322", + "name": "python-editor", + "namespace_in_name": true, + "sha256": "03ce64cce1db9b1218ebca232de663f1de9953dc5eb4ebd19ffe8e66cdf7cccd", + "size": 11178, + "subdir": "linux-64", + "timestamp": 1530737096632, + "version": "1.0.3" + }, + "python-editor-1.0.3-py27hef54e72_0.conda": { + "build": "py27hef54e72_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b299a165390fcf2672fc11c63c2ca08f", + "name": "python-editor", + "namespace_in_name": true, + "sha256": "af57bec1f035c3e2d1b71bf58e13b28bcf89e20813aa0362064e890cee0c7c50", + "size": 10944, + "subdir": "linux-64", + "timestamp": 1505691430872, + "version": "1.0.3" + }, + "python-editor-1.0.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ddc3cdcf4c90a66a450136a0e204db13", + "name": "python-editor", + "namespace_in_name": true, + "sha256": "adc9f8854aef836bb23f20d3efde9bb67d13c321db4ccb1f36bc0aa00237bd23", + "size": 11134, + "subdir": "linux-64", + "timestamp": 1534352640879, + "version": "1.0.3" + }, + "python-editor-1.0.3-py35he568942_0.conda": { + "build": "py35he568942_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e4803ea99c403aa4f1fd068ead5c0474", + "name": "python-editor", + "namespace_in_name": true, + "sha256": "c160524ecef0f2f330069165f6b3a2c47108c465f039d66fed373a203342c980", + "size": 10968, + "subdir": "linux-64", + "timestamp": 1505691441939, + "version": "1.0.3" + }, + "python-editor-1.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0279f5e0dc002e58c87d62722b0bde35", + "name": "python-editor", + "namespace_in_name": true, + "sha256": "accad7d12ef238cc2214f1f97916827470dec1b966f40158d2b04e51f39c1ede", + "size": 11073, + "subdir": "linux-64", + "timestamp": 1530737076246, + "version": "1.0.3" + }, + "python-editor-1.0.3-py36h928c527_0.conda": { + "build": "py36h928c527_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "74c937a8b0973fa7f270c6fe8690f331", + "name": "python-editor", + "namespace_in_name": true, + "sha256": "25594ee36dbab144eb8b209bed8522b2c44f079a0953259f3b0a748598946095", + "size": 10871, + "subdir": "linux-64", + "timestamp": 1505691453079, + "version": "1.0.3" + }, + "python-editor-1.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b32dac947e505d8e74ffdf0830e91d07", + "name": "python-editor", + "namespace_in_name": true, + "sha256": "05350f7c5e67fafcdcff09dd6cec632e9239a1612f0279c15310a27e86a683e5", + "size": 11065, + "subdir": "linux-64", + "timestamp": 1530737117551, + "version": "1.0.3" + }, + "python-engineio-2.0.1-py27h6f79896_0.conda": { + "build": "py27h6f79896_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bca625ad501b927ee025eefef77d2c5a", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "3896d02da2b2f5d31f51d48808735374047be39a71c9e1ce95ca8cd2f368f799", + "size": 33702, + "subdir": "linux-64", + "timestamp": 1511706674225, + "version": "2.0.1" + }, + "python-engineio-2.0.1-py35hcb26707_0.conda": { + "build": "py35hcb26707_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b31b23fff36f5df13b0340dbc31ac2d6", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "f3a45ab69ada49e776d09945ace9d6e82f353ef53d0ba71e9790da1cd1d76b4d", + "size": 39733, + "subdir": "linux-64", + "timestamp": 1511706669158, + "version": "2.0.1" + }, + "python-engineio-2.0.1-py36he21bd9a_0.conda": { + "build": "py36he21bd9a_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a035994f8cb7098487d327c33a3362be", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "f6a781d78a677456c0336df70ea17974fe5ff352f3791027ef2e17672de2509c", + "size": 39242, + "subdir": "linux-64", + "timestamp": 1511706673736, + "version": "2.0.1" + }, + "python-engineio-2.0.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ee46361caa4e56f6b33a8f43e319ae1", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "106e954420400e8aa3f7d19acedaa04f175ffb65cf115e8ed0c638d8b216807d", + "size": 33783, + "subdir": "linux-64", + "timestamp": 1522084408746, + "version": "2.0.4" + }, + "python-engineio-2.0.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80414129a1e6b7cac11b164cd07f043d", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "3c6e2efa72c07f896760ffe5e35e25d4b46419a6b9794920b794b3bc553dab72", + "size": 39880, + "subdir": "linux-64", + "timestamp": 1522084421085, + "version": "2.0.4" + }, + "python-engineio-2.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc9c48e2cb621045c4b0b37446201956", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "6423488fc1d1a14785bef43cb3ed743175da0507d749b278eeff0d6d32028298", + "size": 39713, + "subdir": "linux-64", + "timestamp": 1522084325679, + "version": "2.0.4" + }, + "python-engineio-2.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e7ae09406ab4aca478b4799d0c504c67", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "368945bfc8780852ce2726114701dab59d3d8575560dc52f6593c2d28f7164d7", + "size": 34891, + "subdir": "linux-64", + "timestamp": 1526938732611, + "version": "2.1.1" + }, + "python-engineio-2.1.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "50522d160c777e3caa006a9a6777e48e", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "933482f6d40e30bc9dbe66b2da67c7646e7340d7eca2305de91be7852715e7cf", + "size": 40595, + "subdir": "linux-64", + "timestamp": 1526938735210, + "version": "2.1.1" + }, + "python-engineio-2.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "73b6b1b0dd3ec3d710df7498911ffb68", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "fe21a0b696ea98a0b4233956c18bf8de51b748a8e405fabb5f1711509293f91d", + "size": 40461, + "subdir": "linux-64", + "timestamp": 1526938712249, + "version": "2.1.1" + }, + "python-engineio-2.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "294c9eb00d1b31d5373d8f635b93c337", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "07daa020338641fc7e77b45741c015c3b5a421ea4658eef38802bff801eab012", + "size": 40244, + "subdir": "linux-64", + "timestamp": 1530877512351, + "version": "2.1.1" + }, + "python-engineio-2.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f368d5310abb0ca612d15c3d2e37f31", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "6f5ec5a43861e70709b11a1fd983abe0ca9560af7ac552ddc62a20f10a55e3be", + "size": 34956, + "subdir": "linux-64", + "timestamp": 1535510750704, + "version": "2.2.0" + }, + "python-engineio-2.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cbac6ab367384be98ee0559172e1665b", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "13a76931e0d68ff6b282087c1a233956a7584bb96d2ce85734a4a02395748305", + "size": 41894, + "subdir": "linux-64", + "timestamp": 1535510784757, + "version": "2.2.0" + }, + "python-engineio-2.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cdba027943f765d4b0bc0a6bb1884215", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "a5187a40ca94aaa1034fbc63169ef4721d2236ac669b694656a895b3522810fb", + "size": 41336, + "subdir": "linux-64", + "timestamp": 1535510706797, + "version": "2.2.0" + }, + "python-engineio-2.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe4e4fe03f5aca168285c898eb02235e", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "1c0f875f3cc4d61ef24dccbbc98ccf464dad1dc38c2334f88c4859574da5376b", + "size": 41828, + "subdir": "linux-64", + "timestamp": 1535510785608, + "version": "2.2.0" + }, + "python-engineio-2.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d961c20e76b5a1c3206db8c387ee912", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "80ff426de76769833af6b38c9077b7da456bfa9a671083054d5e5eb2ccf72eb9", + "size": 37051, + "subdir": "linux-64", + "timestamp": 1539657032384, + "version": "2.3.2" + }, + "python-engineio-2.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e05fe7d37c4745e9f4f98ae79cf5698", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "77f490588bbbd6b4198b186347da817921ecac2fb98834b05d617790421ca20f", + "size": 44392, + "subdir": "linux-64", + "timestamp": 1539657048364, + "version": "2.3.2" + }, + "python-engineio-2.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d6a7f8bdc9543e7f773f88b1972a82bb", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "0f005ea46790e97f80579dffb72a9de4bd6f7c611a0025a1d2677933e6ca3591", + "size": 44538, + "subdir": "linux-64", + "timestamp": 1539657048544, + "version": "2.3.2" + }, + "python-engineio-3.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cca1a5de6a1213b56cfff7fa03950eb6", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "440074d9ce43200e912d7d270ff5319cac938435e61513e40081b82fb5827799", + "size": 41884, + "subdir": "linux-64", + "timestamp": 1543611071615, + "version": "3.0.0" + }, + "python-engineio-3.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "40388e58d48430239730ad57d365fab4", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "4627af1787fd0242b114efc1b8e99df803971586af971f8db957bd14c0eb045d", + "size": 50658, + "subdir": "linux-64", + "timestamp": 1543611081526, + "version": "3.0.0" + }, + "python-engineio-3.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2340b0534f9e7628da16f0cba9e5aeb9", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "e37cd0a9f8269ebae8fb89e8ad5b26eaf9e981f8ffae9845c1a1bf259a97e433", + "size": 50636, + "subdir": "linux-64", + "timestamp": 1543611053624, + "version": "3.0.0" + }, + "python-engineio-3.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "480aa27160a1074cf1ec2320f010fa91", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "e1085dcba2213ed60f6692d7789864491975a1010fc00e41565adc90bd86bbbe", + "size": 100711, + "subdir": "linux-64", + "timestamp": 1545166635419, + "version": "3.1.0" + }, + "python-engineio-3.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f59f9aa22da9bc3d3b803bb8f22b660e", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "bced055044d9e4eab917ad2a4657f59fff21ca8f896821bc5edf588904795d35", + "size": 113052, + "subdir": "linux-64", + "timestamp": 1545166652068, + "version": "3.1.0" + }, + "python-engineio-3.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51be47fee83b992138739f6a3b565fa2", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "c6c58f90cd516d150bb75a74d787bf1955ebfe73f4ebfba36958abecd28d73f6", + "size": 113095, + "subdir": "linux-64", + "timestamp": 1545166635953, + "version": "3.1.0" + }, + "python-engineio-3.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "75d571f220310cb75bcae0487c2897ae", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "9dfe4df6e16adb139db3733ecc12e80dc49896eb3a1836a9255ea8f0d59d40ac", + "size": 88741, + "subdir": "linux-64", + "timestamp": 1550355545612, + "version": "3.3.2" + }, + "python-engineio-3.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18154ba2ad8d627149409b51890a7228", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "c9012fbe0d7f5c201c6df98a69ee581bbacd7c95e566e0799c0e2304cd9041e2", + "size": 117424, + "subdir": "linux-64", + "timestamp": 1550355522732, + "version": "3.3.2" + }, + "python-engineio-3.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f97d506e20f9b0e298426f7e56e49146", + "name": "python-engineio", + "namespace_in_name": true, + "sha256": "f243d56379a11ddc9afd65bea4c3a8a3fb0e7311ad321b2df8217126d75d8ea4", + "size": 118906, + "subdir": "linux-64", + "timestamp": 1550355489933, + "version": "3.3.2" + }, + "python-fastjsonschema-2.16.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "747b43bf00c8f43d747e052c8e0c6be8", + "name": "python-fastjsonschema", + "sha256": "880d013dbc49a59080388275e84299201aef91ac0079b6b75f3c2dc143b70a1d", + "size": 236563, + "subdir": "linux-64", + "timestamp": 1661371188626, + "version": "2.16.2" + }, + "python-fastjsonschema-2.16.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "799ea490027044667ec190bfdcb20698", + "name": "python-fastjsonschema", + "sha256": "82af85fb47ef995a5686e0c343cbe66c36b281fd86cd0ee30729d52aa6f94c34", + "size": 252647, + "subdir": "linux-64", + "timestamp": 1679340144625, + "version": "2.16.2" + }, + "python-fastjsonschema-2.16.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b41bf40537d388ce98c69f461b339191", + "name": "python-fastjsonschema", + "sha256": "de7139a91dc5acdddde1f5b02fb28de6e6f27b57a294db88760c8a86887ebfab", + "size": 235702, + "subdir": "linux-64", + "timestamp": 1661371244169, + "version": "2.16.2" + }, + "python-fastjsonschema-2.16.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ccba88861fd11b4b8492997d1a4f1b7d", + "name": "python-fastjsonschema", + "sha256": "6f6b9a8c93c691bfd11cade31289f4680eebb8f75468935673cd7d8c0ba975c5", + "size": 235798, + "subdir": "linux-64", + "timestamp": 1661371299911, + "version": "2.16.2" + }, + "python-fastjsonschema-2.16.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2c1d7d8d672bf39a190892b9702519e4", + "name": "python-fastjsonschema", + "sha256": "03967f9b11690098195e7f060e73a8e325ffabda85e363f442733781d175ab3b", + "size": 236249, + "subdir": "linux-64", + "timestamp": 1661371117920, + "version": "2.16.2" + }, + "python-gflags-3.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "da8ae98eb2e4909272d3a8c04c891baf", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "aaacc126f7b92077da7c81dcc74688bec002b78154a5b1f68526878a2b4359ad", + "size": 70160, + "subdir": "linux-64", + "timestamp": 1512750499699, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "997d60b1d968344922e7cb9931f10b6f", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "ea7c07e398c9509a5a0f15e6397202c36ef877d9e37ee5a052ffad8512e5923a", + "size": 72185, + "subdir": "linux-64", + "timestamp": 1640793811090, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "024f806b32de336943bbdac0c1c33325", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "467abad661651ec7b6456197813606233732a430a0aed217208e247ee7371943", + "size": 91986, + "subdir": "linux-64", + "timestamp": 1676861466484, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1cfe1df8448b44fbbede5b310e45a762", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "7677f54114aef96e12e2384ea6fbbf2f08947ddaf8568a3d3eb6f3584be537a5", + "size": 71620, + "subdir": "linux-64", + "timestamp": 1512750502785, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e45014157df39b2dbb0fbfe80babeec7", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "cbbea05a63a0c7cc98a2247080d334dc4869641002ea77b81102f28ecb235fbe", + "size": 72059, + "subdir": "linux-64", + "timestamp": 1512750504243, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9959016668e9fc66aeb195601cd203dc", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "92992307a4f136337beff772e46df4b33f3f716b367b496d04fa1009ad4debc0", + "size": 71396, + "subdir": "linux-64", + "timestamp": 1613492904961, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e4f9d81c711b867729feeed5609396d8", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "c29202f7860384466145a6e3d2dfbaf50cbd585165ea16913235ae07085b8c15", + "size": 71986, + "subdir": "linux-64", + "timestamp": 1530792963779, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "11da11c2d806df78653945d7e600dca0", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "661e651befedde1c81003d0b9850bda507fe5c567ea6cecc860fed385225ebfc", + "size": 72518, + "subdir": "linux-64", + "timestamp": 1613493335961, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c3defd9bcc8561d742b2d5d086d25031", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "4dbb514ff88b58e3c6fd75a0a505a94a893ffb753baf83dc13e60d16499835b0", + "size": 72047, + "subdir": "linux-64", + "timestamp": 1574094360736, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cd72df76faa3a458f27833fc0defb4b1", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "d5b466e826c494c8b96717074839d1d60cc23a649d03084beac62df3e8a0b895", + "size": 71772, + "subdir": "linux-64", + "timestamp": 1613493350999, + "version": "3.1.2" + }, + "python-gflags-3.1.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "79613778bbf331eefa0a9057f4bd70be", + "name": "python-gflags", + "namespace_in_name": true, + "sha256": "0a3d14999933a3de34e4c27249bee6e6bd6f0ffc34c490d6e3e1beae8fe653bb", + "size": 72820, + "subdir": "linux-64", + "timestamp": 1613493341839, + "version": "3.1.2" + }, + "python-graphviz-0.20.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca85e050bd53b700a7db4e3553b8dfba", + "name": "python-graphviz", + "sha256": "5fda9318222aeea3b205f27f41cd66f98132506724b0e787492733825173946a", + "size": 65026, + "subdir": "linux-64", + "timestamp": 1660063340906, + "version": "0.20.1" + }, + "python-graphviz-0.20.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7cb6e4b438d9ed83c83732f957960784", + "name": "python-graphviz", + "sha256": "efbe7aeae51de919bfa916c0e5c1c52b88cccbfe4102071ef2982012b54b59fb", + "size": 80834, + "subdir": "linux-64", + "timestamp": 1676838677129, + "version": "0.20.1" + }, + "python-graphviz-0.20.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87339ed21dbd90b7e026c182a7f6cdb3", + "name": "python-graphviz", + "sha256": "9c6829f9db6c533c57363be56c198bd237d73759b1711e4da956514fdac3b3f6", + "size": 63582, + "subdir": "linux-64", + "timestamp": 1660063389156, + "version": "0.20.1" + }, + "python-graphviz-0.20.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2d67777ff388b7b69173d6b893a613a", + "name": "python-graphviz", + "sha256": "b064724eb4d3d1be2cdd5c9847e3e693c814f966631d158b6d8b36c0ae6a5f61", + "size": 64110, + "subdir": "linux-64", + "timestamp": 1660063283264, + "version": "0.20.1" + }, + "python-graphviz-0.20.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "graphviz <3.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ede3cdb6fd19f58c4fdd472148c68e9", + "name": "python-graphviz", + "sha256": "61fa03486c609b7c7920237cfa09fc2dd2de403c74d684459fafe3fb7f593684", + "size": 64213, + "subdir": "linux-64", + "timestamp": 1660063229820, + "version": "0.20.1" + }, + "python-graphviz-0.8.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "graphviz", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1018693d75de9d14beec9de6227a430d", + "name": "python-graphviz", + "sha256": "7c145edfa1f17f28024047123a4c1bfa6fa76b173a7bc99495bce7e96678b070", + "size": 27622, + "subdir": "linux-64", + "timestamp": 1516927208755, + "version": "0.8.2" + }, + "python-graphviz-0.8.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "graphviz", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "423c1ab175dd890a77a978918edbf19d", + "name": "python-graphviz", + "sha256": "5701dce5cc63dbf1ce30f70811a4d9550d9bd425b7d7afbe30ef91a0463a2312", + "size": 28043, + "subdir": "linux-64", + "timestamp": 1516927227890, + "version": "0.8.2" + }, + "python-graphviz-0.8.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "graphviz", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df0226ab3bc247d58d11e3ef3c44a6b3", + "name": "python-graphviz", + "sha256": "c98c56aabc3759d4e72cb2e3c5557ec1092f7b3dcd16b0699543d8d27cd778fa", + "size": 27851, + "subdir": "linux-64", + "timestamp": 1516927236295, + "version": "0.8.2" + }, + "python-graphviz-0.8.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "graphviz", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7224fdfac098eaa7ac4ae8440c25905b", + "name": "python-graphviz", + "sha256": "e1cc5e49fbdc7a2a0c495aa605123ce0493970f4721acf50c4c17bdbd92c12ca", + "size": 27529, + "subdir": "linux-64", + "timestamp": 1527694927688, + "version": "0.8.3" + }, + "python-graphviz-0.8.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "graphviz", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb02c6df4ae2f36aede41b5439250c0c", + "name": "python-graphviz", + "sha256": "93cffe17298527e9cf1ce078da48a1d43e5f30fdbbb1d513c5976a7c024553cf", + "size": 27895, + "subdir": "linux-64", + "timestamp": 1527694929825, + "version": "0.8.3" + }, + "python-graphviz-0.8.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "graphviz", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7fb042ad7e093263c7e29647bab791b9", + "name": "python-graphviz", + "sha256": "855ffc23bf321c65d46c2ff892978215ca27e4544504853e6a1089ec73f39770", + "size": 27687, + "subdir": "linux-64", + "timestamp": 1527694909729, + "version": "0.8.3" + }, + "python-graphviz-0.8.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "graphviz", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ee2f8d76144be04127429f01dfca3d8", + "name": "python-graphviz", + "sha256": "6ca58ec779cc04dc800f55115035dba10c8fcabd15a61d254db0cf0d0377c3ec", + "size": 28199, + "subdir": "linux-64", + "timestamp": 1531092324130, + "version": "0.8.3" + }, + "python-graphviz-0.8.4-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "graphviz", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba7fbf10bcaa9b23030bae5489823650", + "name": "python-graphviz", + "sha256": "966c3135682434b203992dd0014c2b1c87be409c693bc7260d143ab7cc7afb64", + "size": 28762, + "subdir": "linux-64", + "timestamp": 1533000958051, + "version": "0.8.4" + }, + "python-graphviz-0.8.4-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "graphviz", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e7d1a3aa911ae57dae7bca23a9e0e28", + "name": "python-graphviz", + "sha256": "0c00532ecf464f31f1b024b136efda459df18c7cc35edd0d6d9db97f31989d6d", + "size": 29136, + "subdir": "linux-64", + "timestamp": 1533000966948, + "version": "0.8.4" + }, + "python-graphviz-0.8.4-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "graphviz", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c45aa60d14285e1c87c9992dbb65ee6", + "name": "python-graphviz", + "sha256": "e720fcf5495a5b580f21b6547be6de0e64003a650fb46733bf2fbe2c507863b7", + "size": 28957, + "subdir": "linux-64", + "timestamp": 1533000925057, + "version": "0.8.4" + }, + "python-graphviz-0.8.4-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "graphviz", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f970496c4ec67ef0520c7368030c3c9", + "name": "python-graphviz", + "sha256": "b54972ae2a783f5770b8e4cb017e311021f0df003013d677d0b069eaa1a70ac0", + "size": 29344, + "subdir": "linux-64", + "timestamp": 1533000972352, + "version": "0.8.4" + }, + "python-graphviz-0.8.4-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "graphviz", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebcbb0c1cf4f2774c7bdb16d01727fc4", + "name": "python-graphviz", + "sha256": "6c88464e812f58bfa5d70de6fa30a05782a6f61c6f8e9a4339224266c2e339fe", + "size": 29324, + "subdir": "linux-64", + "timestamp": 1572855320178, + "version": "0.8.4" + }, + "python-hdfs-2.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=2.7,<2.8.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "01e78012d68334515cb17f0cc898e402", + "name": "python-hdfs", + "sha256": "ea3c731d8858372746c139ff87547e930aa761db770fbf2b8d83ac54c0c1df71", + "size": 48838, + "subdir": "linux-64", + "timestamp": 1516906175241, + "version": "2.1.0" + }, + "python-hdfs-2.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=3.5,<3.6.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "983061830a004665d348366f00a12cae", + "name": "python-hdfs", + "sha256": "b47314e0934dc6cf8ea64de3bb407161603ea61a4609e2ad076b457f0be77571", + "size": 49748, + "subdir": "linux-64", + "timestamp": 1516906174925, + "version": "2.1.0" + }, + "python-hdfs-2.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=3.6,<3.7.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "82cbf64466e6bd443136128a29499742", + "name": "python-hdfs", + "sha256": "2615a29c5d702fc4c8db395aa3b5ee12fa65339920f0612e8a7fbca064d3b09c", + "size": 48924, + "subdir": "linux-64", + "timestamp": 1516906201046, + "version": "2.1.0" + }, + "python-hdfs-2.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=3.7,<3.8.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "0266c958cd1be0c51dabd8b36cc688ef", + "name": "python-hdfs", + "sha256": "4a5377bb1f55e20b2189eff83ecf699a9f5084b55eadc8e4724a568734b3fb0e", + "size": 49212, + "subdir": "linux-64", + "timestamp": 1530922727335, + "version": "2.1.0" + }, + "python-hdfs-2.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=2.7,<2.8.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "7a7ae033bd3da746a79d5ceef56fa86e", + "name": "python-hdfs", + "sha256": "acda68e8373c0b4cd3e902ec61ee9340f96558fe24d4cb4e8ac7feda3a1d9d23", + "size": 50365, + "subdir": "linux-64", + "timestamp": 1543611696765, + "version": "2.2.1" + }, + "python-hdfs-2.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=3.6,<3.7.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "e29cd014b557175550ad818870714d72", + "name": "python-hdfs", + "sha256": "1a98b6bc4caa9636049bace9df925fbd7d511e7ccc6498fb068080a9efb1acdd", + "size": 51268, + "subdir": "linux-64", + "timestamp": 1543611722348, + "version": "2.2.1" + }, + "python-hdfs-2.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=3.7,<3.8.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "592f119291974caa73d0c80cd5d5e866", + "name": "python-hdfs", + "sha256": "4d5bd6fea9ea1dc36f3421e34ebd5718ce71b5f4fef939a52815d9efda20b997", + "size": 50872, + "subdir": "linux-64", + "timestamp": 1543611676791, + "version": "2.2.1" + }, + "python-hdfs-2.2.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=2.7,<2.8.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "e17f0da2fbc3496148d29780eabd894a", + "name": "python-hdfs", + "sha256": "e97c843437c395116db7c61df394e307854bf437f5c8c71709849998b0c59bd2", + "size": 49328, + "subdir": "linux-64", + "timestamp": 1545130797180, + "version": "2.2.2" + }, + "python-hdfs-2.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=3.6,<3.7.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "b6447e9672368f4d6e3ea25bfb315655", + "name": "python-hdfs", + "sha256": "f651befcd7f05e1f2051bc55830a18200db1b8361006a8e09a2ced12beb3292d", + "size": 49795, + "subdir": "linux-64", + "timestamp": 1545130736454, + "version": "2.2.2" + }, + "python-hdfs-2.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.9.6", + "pandas >=0.14.1", + "python >=3.7,<3.8.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "md5": "3014fbae2c2d167046fa4d40bcca2d52", + "name": "python-hdfs", + "sha256": "eac399250f4b4a062b2bb9779a736060d4c35aaaa034bac8840b245a6260a5eb", + "size": 49323, + "subdir": "linux-64", + "timestamp": 1545130825618, + "version": "2.2.2" + }, + "python-hdfs-2.7.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.21.19", + "pandas >=0.14.1", + "python >=3.10,<3.11.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d72c3e550e933a1111d6008a1c3c811", + "name": "python-hdfs", + "sha256": "4ab9aee537b4c49b91c585f4e5cadb910e329d80b648e04de18abfc3b29d9226", + "size": 57279, + "subdir": "linux-64", + "timestamp": 1670952411626, + "version": "2.7.0" + }, + "python-hdfs-2.7.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.21.19", + "pandas >=0.14.1", + "python >=3.11,<3.12.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e6c283fdc21d267038139a657b5d773", + "name": "python-hdfs", + "sha256": "6f8e7ac8c61914a763704237fe9e4dca84a19cf093bef68b3c39c6747e832636", + "size": 69439, + "subdir": "linux-64", + "timestamp": 1679340273350, + "version": "2.7.0" + }, + "python-hdfs-2.7.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.21.19", + "pandas >=0.14.1", + "python >=3.7,<3.8.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "419fed91adb387ae29ab478c44de7674", + "name": "python-hdfs", + "sha256": "b0013a6235823650bcc1942024b44e29bf6dd5600d4945c32c39785de31fd4db", + "size": 55697, + "subdir": "linux-64", + "timestamp": 1670952372953, + "version": "2.7.0" + }, + "python-hdfs-2.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.21.19", + "pandas >=0.14.1", + "python >=3.8,<3.9.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52b454ecfe3a2ab6df37f22a65b721e2", + "name": "python-hdfs", + "sha256": "24829fdead0e485e754490951c14a4248f7c326f44cafba13dcbbe97cafa9dc5", + "size": 55791, + "subdir": "linux-64", + "timestamp": 1670952485308, + "version": "2.7.0" + }, + "python-hdfs-2.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "docopt", + "fastavro >=0.21.19", + "pandas >=0.14.1", + "python >=3.9,<3.10.0a0", + "requests >=2.7.0", + "requests-kerberos >=0.7.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fafd883d54914b3aa23be4941c9e2133", + "name": "python-hdfs", + "sha256": "081c5c29b24f4c0bc2981ed54f585484fa42382e5c9abb0f5b1f359eb0e99f93", + "size": 56712, + "subdir": "linux-64", + "timestamp": 1670952447677, + "version": "2.7.0" + }, + "python-installer-0.5.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f40c41a86ea7720988d4aab6fdead171", + "name": "python-installer", + "sha256": "76daf9e7b7ca9f37b4607d89ca618ee723ac69c5be029df0874b2c1ff0c12790", + "size": 269610, + "subdir": "linux-64", + "timestamp": 1669064503492, + "version": "0.5.1" + }, + "python-installer-0.5.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e16718d4f38bc5262c0f4cf48b2ade7", + "name": "python-installer", + "sha256": "5f5238858ad588877814efcf0642d7ed0203f4a20e3aa4c306021f21b725db95", + "size": 250538, + "subdir": "linux-64", + "timestamp": 1676842348095, + "version": "0.5.1" + }, + "python-installer-0.5.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d1a40f8065a864a9577730ff26ee7910", + "name": "python-installer", + "sha256": "88cee961d08811170d144d6a2564d7636090dfcec166d1d4496645facd976252", + "size": 269248, + "subdir": "linux-64", + "timestamp": 1669064447944, + "version": "0.5.1" + }, + "python-installer-0.5.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34d503b526e5a343eb0162b59216ddd0", + "name": "python-installer", + "sha256": "6aa2630504d399b3842b53697092693e0c62d11e3edd7535d311338701933169", + "size": 269351, + "subdir": "linux-64", + "timestamp": 1669064530945, + "version": "0.5.1" + }, + "python-installer-0.5.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c4aa092de943daf9ffcf92b0545edc5", + "name": "python-installer", + "sha256": "4151441b298d51668c2924782472ec25d4a882ae579fadb3632061dfa65bb2a6", + "size": 269360, + "subdir": "linux-64", + "timestamp": 1669064475701, + "version": "0.5.1" + }, + "python-installer-0.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "78e920bdd5e6611d43588f8948180270", + "name": "python-installer", + "sha256": "5f20892e0a80431191888c09c29d47e63d960661c7d389b6f2a5e48653c88db1", + "size": 268898, + "subdir": "linux-64", + "timestamp": 1679433053237, + "version": "0.6.0" + }, + "python-installer-0.6.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f6f83239a225115891ff862a0516781", + "name": "python-installer", + "sha256": "898ea21bed01259be4872c1962609de47a0786aa415bc177f7dca47f2ce914c4", + "size": 276795, + "subdir": "linux-64", + "timestamp": 1679433028089, + "version": "0.6.0" + }, + "python-installer-0.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab2cb8ae2243fd0c3dba699498aea1e7", + "name": "python-installer", + "sha256": "1186828f63894a07d794dbb5faa08a278e22349677f5492ed1654942ce685ea1", + "size": 268509, + "subdir": "linux-64", + "timestamp": 1679433078265, + "version": "0.6.0" + }, + "python-installer-0.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c29552989b436f7837255e5f3bc3a07", + "name": "python-installer", + "sha256": "7c1eb23bbf4def044e02ee21af8fe43d24485c5a8e114a5063ec60640749c1e1", + "size": 268508, + "subdir": "linux-64", + "timestamp": 1679433101949, + "version": "0.6.0" + }, + "python-jose-2.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ecdsa <1.0", + "future <1.0", + "pycryptodome >=3.3.1", + "python >=2.7,<2.8.0a0", + "six <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db0117dbd78de75c773189923a6559d4", + "name": "python-jose", + "sha256": "7e77c713d45187ea67beb12c6ed660efb2fa71467253b6f99f2177b3db6cacdc", + "size": 33048, + "subdir": "linux-64", + "timestamp": 1543384660144, + "version": "2.0.2" + }, + "python-jose-2.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ecdsa <1.0", + "future <1.0", + "pycryptodome >=3.3.1", + "python >=3.6,<3.7.0a0", + "six <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71b523131d0a32182c43324061f1be5d", + "name": "python-jose", + "sha256": "1ab77f31d1ab4af78fa4813e1fac50e60a428a0829e04411bf7a768be07827d0", + "size": 33184, + "subdir": "linux-64", + "timestamp": 1543384721720, + "version": "2.0.2" + }, + "python-jose-2.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ecdsa <1.0", + "future <1.0", + "pycryptodome >=3.3.1", + "python >=3.7,<3.8.0a0", + "six <2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "841a826af1656f702067b0ad2e7b615f", + "name": "python-jose", + "sha256": "6ebefac5f79e3816c2c4aca91d16e0ad3b9f6767a3a96c1eaeac7c796f712835", + "size": 33423, + "subdir": "linux-64", + "timestamp": 1543384642587, + "version": "2.0.2" + }, + "python-kubernetes-18.20.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "cfb1eefc646b8fca3899a6c582ff19d9", + "name": "python-kubernetes", + "sha256": "264a8888dcc0b20d1261a20838e4b1548a38d4cd59f7e1e9f4824cafb7cb3f98", + "size": 938228, + "subdir": "linux-64", + "timestamp": 1667228498941, + "version": "18.20.0" + }, + "python-kubernetes-18.20.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "1395b108ebf3b3982e76ce4c3caf8f5c", + "name": "python-kubernetes", + "sha256": "a52035e90240b5ab4f84a02dfa6d5c1737f7054d5143173538e50986695bcb81", + "size": 930181, + "subdir": "linux-64", + "timestamp": 1667228456627, + "version": "18.20.0" + }, + "python-kubernetes-18.20.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "3bfbd53b57b3a069e5e1ecb04c16bc5d", + "name": "python-kubernetes", + "sha256": "5fd73f940310efe0537b08a4a3f4b29376cc45118e74527ebcc881452014dfa5", + "size": 932163, + "subdir": "linux-64", + "timestamp": 1667228414790, + "version": "18.20.0" + }, + "python-kubernetes-18.20.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "70ff0356222735cccbe3905cdf6667b2", + "name": "python-kubernetes", + "sha256": "0ac9fbb71b2087303ae142e7484efb949a2a57d55314b04eb54cc5f18fbe3dd3", + "size": 931922, + "subdir": "linux-64", + "timestamp": 1667228373263, + "version": "18.20.0" + }, + "python-kubernetes-19.15.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a56c5800a690ba1ca78b59e894c83ed3", + "name": "python-kubernetes", + "sha256": "89fe5da38a6a585bc437d08797f3e9b5b9bde53a1a2ff7f83dcf381e4c650dbf", + "size": 780566, + "subdir": "linux-64", + "timestamp": 1666105109159, + "version": "19.15.0" + }, + "python-kubernetes-19.15.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9531b8275da33f8a4ce241073b0fc472", + "name": "python-kubernetes", + "sha256": "3189595035462b7b34f1e74774506ffdbaa031a31235dcc508d3019bb2c84eef", + "size": 769644, + "subdir": "linux-64", + "timestamp": 1666104986120, + "version": "19.15.0" + }, + "python-kubernetes-19.15.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f31d7211ac457af8f8c802c226d6824b", + "name": "python-kubernetes", + "sha256": "7c5c7aeb9298c9f5cb8345e699d097bc18867df795c19acec453d2c6ea0855b9", + "size": 771242, + "subdir": "linux-64", + "timestamp": 1666105046190, + "version": "19.15.0" + }, + "python-kubernetes-19.15.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "c4e862ea9ace2a4d460fd39ab8279f95", + "name": "python-kubernetes", + "sha256": "f43ec6e28acc028e78958323c53e8693c47810368db0bf988bc63e22af5d0f37", + "size": 771170, + "subdir": "linux-64", + "timestamp": 1666104923405, + "version": "19.15.0" + }, + "python-kubernetes-20.13.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b1f58e85e4f33f665544a2be48928453", + "name": "python-kubernetes", + "sha256": "9cb58c8a3f405a2b8fb9f97806d3cadeefd1cb43854813901128dbcc955711c7", + "size": 997564, + "subdir": "linux-64", + "timestamp": 1667228396389, + "version": "20.13.0" + }, + "python-kubernetes-20.13.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "cfb1e7eb7da0a5ddb98f23194b55113a", + "name": "python-kubernetes", + "sha256": "2de276500d863d3b338c9ede58ba9ade7df865c4064c0d59eb072710041afdb5", + "size": 985822, + "subdir": "linux-64", + "timestamp": 1667228525965, + "version": "20.13.0" + }, + "python-kubernetes-20.13.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "57e713e8bfad5bcf4d79adf8a730687c", + "name": "python-kubernetes", + "sha256": "9ddb42cff4e8c5210dfe08de007a16e306954d9927e445a56ca9e832666f4eda", + "size": 987880, + "subdir": "linux-64", + "timestamp": 1667228439530, + "version": "20.13.0" + }, + "python-kubernetes-20.13.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "73ca0243549ee66e4de194ca4d312539", + "name": "python-kubernetes", + "sha256": "365aa59ed67bf82b1d77dfe351ed25af3570c0e89ac4e8acec5cd9349a8cbe16", + "size": 987926, + "subdir": "linux-64", + "timestamp": 1667228482437, + "version": "20.13.0" + }, + "python-kubernetes-21.7.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "29c8521a4ccb763c53e87178d82c554d", + "name": "python-kubernetes", + "sha256": "a029020c2caa98fb6a355e795467a1cc45a67f20f303849c29e390380b73a252", + "size": 1013064, + "subdir": "linux-64", + "timestamp": 1667228367125, + "version": "21.7.0" + }, + "python-kubernetes-21.7.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ebbd476f404d9d61d181b9c93400fb96", + "name": "python-kubernetes", + "sha256": "22590b2237c14fa88ede787e926556d0fa9e5cd941096081c6a80e972feae144", + "size": 1000261, + "subdir": "linux-64", + "timestamp": 1667228497279, + "version": "21.7.0" + }, + "python-kubernetes-21.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "39280b2cd4b77ce5dd320db58c26a78d", + "name": "python-kubernetes", + "sha256": "79baf7fb6d4316f793968f9aaa269c9e6ab50c5151a00bdda34001e6de2df74b", + "size": 1000723, + "subdir": "linux-64", + "timestamp": 1667228453196, + "version": "21.7.0" + }, + "python-kubernetes-21.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "bcd93607ab1ae1a03054240bc26a74b9", + "name": "python-kubernetes", + "sha256": "1fe8b450af6b05a1c515a11a2baf0af9d1b93a0adbcebe02848763adba97ae56", + "size": 1002414, + "subdir": "linux-64", + "timestamp": 1667228410183, + "version": "21.7.0" + }, + "python-kubernetes-23.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "setuptools >=21.0.0", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "74387a34722af4cfa4555b383e320689", + "name": "python-kubernetes", + "sha256": "febf5743c96fb98f16c9834c4ce1d34dd9215157be4aa1e93f763b2edf03db53", + "size": 745415, + "subdir": "linux-64", + "timestamp": 1659724899640, + "version": "23.6.0" + }, + "python-kubernetes-23.6.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "setuptools >=21.0.0", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "2d5e80bdcfc8a3aaf8b44c8376e1c9ff", + "name": "python-kubernetes", + "sha256": "f79828503b0056086739b2a1af9fc1d6ea131a68b7df93e7d0d91855ec5317fd", + "size": 1003736, + "subdir": "linux-64", + "timestamp": 1676861490524, + "version": "23.6.0" + }, + "python-kubernetes-23.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "setuptools >=21.0.0", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "4b11aa10cadd470d03ac73f389bf82b6", + "name": "python-kubernetes", + "sha256": "5e3442d2dcfc2e71439e1cd4e90f851b83115f09281369b99494bddf3477877f", + "size": 735481, + "subdir": "linux-64", + "timestamp": 1659724843806, + "version": "23.6.0" + }, + "python-kubernetes-23.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "setuptools >=21.0.0", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "17f939fa49ed09e7fcd121e0c3ccbc88", + "name": "python-kubernetes", + "sha256": "4ca92de05eda96eb918e48d3d857030208628bb8f807aeb515f978072bef407d", + "size": 737229, + "subdir": "linux-64", + "timestamp": 1659724800581, + "version": "23.6.0" + }, + "python-kubernetes-23.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=14.05.14", + "google-auth >=1.0.1", + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.5.3", + "pyyaml >=5.4.1", + "requests", + "requests-oauthlib", + "setuptools >=21.0.0", + "six >=1.9.0", + "urllib3 >=1.24.2", + "websocket-client >=0.32.0,!=0.40.0,!=0.41.*,!=0.42.*" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7276943eef9a08a81519b612c3c4aba3", + "name": "python-kubernetes", + "sha256": "ea12e02f7c4a727906de1f5ceae633b9e8d859565de6ae4b474bf07eac2dc4c3", + "size": 737824, + "subdir": "linux-64", + "timestamp": 1659724757374, + "version": "23.6.0" + }, + "python-language-server-0.31.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16.0a0", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0,<2.2.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ca94dd54a248e052ce72e385825e3b7", + "name": "python-language-server", + "sha256": "69cb9a7b0ccb7698213429b4eb8b898789a1c07c5c69faf4360cf37d1f147a7a", + "size": 79367, + "subdir": "linux-64", + "timestamp": 1587400181204, + "version": "0.31.10" + }, + "python-language-server-0.31.10-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16.0a0", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0,<2.2.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d94b5e2f275c7b7abcf54193414830a4", + "name": "python-language-server", + "sha256": "9d07a4f11667edf7b47c74abb14151269cdea86f4a56235c6b38440fe4656ab6", + "size": 79503, + "subdir": "linux-64", + "timestamp": 1587400107196, + "version": "0.31.10" + }, + "python-language-server-0.31.10-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16.0a0", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0,<2.2.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c23734b537bcdb2ada167dac441c83cf", + "name": "python-language-server", + "sha256": "6d1a2c03daafa189aed0d36f0ebd1521b425eb7f20d923c86f1990499db7137b", + "size": 79383, + "subdir": "linux-64", + "timestamp": 1587400180440, + "version": "0.31.10" + }, + "python-language-server-0.31.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "autopep8", + "backports.functools_lru_cache", + "configparser", + "flake8", + "future >=0.14", + "jedi >=0.14.1,<0.16", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=2.7,<2.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f0bb6562df66ecbf834f2c2fd180311", + "name": "python-language-server", + "sha256": "e02dc00c522086221d9c6a33eccc800250bb55e0f8971060bc4492a5e5fdc388", + "size": 76302, + "subdir": "linux-64", + "timestamp": 1575415663473, + "version": "0.31.2" + }, + "python-language-server-0.31.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a1c428d3228a9c972957868ae2f6d652", + "name": "python-language-server", + "sha256": "741edd8d859b48dd21396888db7a781a0f3978303ea2a99ad73809b98135786e", + "size": 76720, + "subdir": "linux-64", + "timestamp": 1575415685368, + "version": "0.31.2" + }, + "python-language-server-0.31.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebb4004b5732e00d0c6d79d8a8045e0e", + "name": "python-language-server", + "sha256": "9a4da8d6e3a131c5ce03a6e1e3a1e2e33ed9224f06c87a9618b3ed43ed138f8a", + "size": 76472, + "subdir": "linux-64", + "timestamp": 1575415806439, + "version": "0.31.2" + }, + "python-language-server-0.31.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "26c99ecc1bfdc1c33d074458553d10cf", + "name": "python-language-server", + "sha256": "3962415931dacdda48664811baca6646f0b6232c01342d73dabe8a1cfc92ec4b", + "size": 76781, + "subdir": "linux-64", + "timestamp": 1575415690903, + "version": "0.31.2" + }, + "python-language-server-0.31.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6985928eeb7b9bf1f1288a87d0921dc", + "name": "python-language-server", + "sha256": "18f951df0d7f08bc3315660203283cd4dc1d86bfc3ef6e593adea79ebe9f481c", + "size": 77479, + "subdir": "linux-64", + "timestamp": 1580400448641, + "version": "0.31.7" + }, + "python-language-server-0.31.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "907bb627e9be8a217ce833bad404c848", + "name": "python-language-server", + "sha256": "e18d2c5e06e9afd376e86d2e92def692b642cad889e27e6c02736ad717203708", + "size": 77449, + "subdir": "linux-64", + "timestamp": 1580400348100, + "version": "0.31.7" + }, + "python-language-server-0.31.7-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2d1c0f7576b26b7b9ffe8212ff98ec0", + "name": "python-language-server", + "sha256": "8ffa50fdaa8341460d95d01a30d204636eb983b1aa4939d24a6bcb53ffc073ea", + "size": 77881, + "subdir": "linux-64", + "timestamp": 1580400485793, + "version": "0.31.7" + }, + "python-language-server-0.31.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16.0a0", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9414f90d989bb236cd2844cff887a0a3", + "name": "python-language-server", + "sha256": "cabfdb9a897f2b5d1b6084c53169347a8b2d5e8e5e36432693fe6807d8a21c67", + "size": 77686, + "subdir": "linux-64", + "timestamp": 1584458111164, + "version": "0.31.8" + }, + "python-language-server-0.31.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16.0a0", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e1012ace98122b78a00ffed60e9fc2ba", + "name": "python-language-server", + "sha256": "d89ef2581d3bba88352745d042131e5923d9684b4043ba8276f5d38e96aa3497", + "size": 78152, + "subdir": "linux-64", + "timestamp": 1584457993863, + "version": "0.31.8" + }, + "python-language-server-0.31.8-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16.0a0", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce4aa4da02def7f8520a7183dcc98832", + "name": "python-language-server", + "sha256": "0f7b60cca046c8c5c6e44fb73baf38fdcb46b4256fe1022ef01102da4eec8cc4", + "size": 78844, + "subdir": "linux-64", + "timestamp": 1584458011864, + "version": "0.31.8" + }, + "python-language-server-0.31.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16.0a0", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "54f305e91472471bbd507374ef4b2556", + "name": "python-language-server", + "sha256": "0468d1ec72ccda77970084adefd2630662f3cbb65092944163a91c572ffa3da2", + "size": 77869, + "subdir": "linux-64", + "timestamp": 1584638156164, + "version": "0.31.9" + }, + "python-language-server-0.31.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16.0a0", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3b78886c14aea2fe73549d4548e0d8e", + "name": "python-language-server", + "sha256": "8d50c7dd2be0875b6a8ee630d6aed706fd929e43b087558a3c2bc295b192d266", + "size": 78714, + "subdir": "linux-64", + "timestamp": 1584638148969, + "version": "0.31.9" + }, + "python-language-server-0.31.9-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8", + "jedi >=0.14.1,<0.16.0a0", + "mccabe", + "pluggy", + "pycodestyle", + "pydocstyle >=2.0.0", + "pyflakes >=1.6.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31b4b5a4bde54cfa02219044cb03bd04", + "name": "python-language-server", + "sha256": "d4f8f8a5aa800547839dc611ca5810be5bcd887c94cd9ebfaf8c2e5776d81e6a", + "size": 79087, + "subdir": "linux-64", + "timestamp": 1584638167098, + "version": "0.31.9" + }, + "python-language-server-0.33.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aafcd952455bac50eb28726a81d75caf", + "name": "python-language-server", + "sha256": "cfc79aca062fdb1bf551ba40b685a175d5a2a4ba0186c170715991daadd20e1f", + "size": 81684, + "subdir": "linux-64", + "timestamp": 1590516711530, + "version": "0.33.0" + }, + "python-language-server-0.33.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "efd294dde66ede480b5e539cf345c120", + "name": "python-language-server", + "sha256": "25b7ae07fce50e331cc0f5bd74e5f6c7b0c6f3fa7830e165fe021c1d67c7e61d", + "size": 81808, + "subdir": "linux-64", + "timestamp": 1590516687784, + "version": "0.33.0" + }, + "python-language-server-0.33.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb24965e25666473fe388bc61f212120", + "name": "python-language-server", + "sha256": "5f6b2f52c5b7773474831d13b7fccf420263526706f53de0d39dd43713e1db30", + "size": 82528, + "subdir": "linux-64", + "timestamp": 1590516710257, + "version": "0.33.0" + }, + "python-language-server-0.33.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f63d3b6bb3ec0527649b792a4a5acbb", + "name": "python-language-server", + "sha256": "4917038ddab7cfc4fb3826056ebcd7c7b779e1347e868788f5a0468b55090b21", + "size": 82364, + "subdir": "linux-64", + "timestamp": 1592348658434, + "version": "0.33.1" + }, + "python-language-server-0.33.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6aeec9ba9521a6a8c82f558e5ec99429", + "name": "python-language-server", + "sha256": "7e0d3c6da221dbf0bead1640e4898ad181f6aa119aa9094031d94cbc4cd36140", + "size": 82529, + "subdir": "linux-64", + "timestamp": 1592348658461, + "version": "0.33.1" + }, + "python-language-server-0.33.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "813af69e5241c1375a89fa14759652cc", + "name": "python-language-server", + "sha256": "44b162b32829b9f2688122a4a390f3c02842a407435837ae2e5f7bc7699af06b", + "size": 81728, + "subdir": "linux-64", + "timestamp": 1592348659677, + "version": "0.33.1" + }, + "python-language-server-0.33.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c33d7804f97091bcd9c561e056cd924", + "name": "python-language-server", + "sha256": "b4e30018ac54e8c5b44e53f191338be074a2666c0e10c60ec494f032756a545d", + "size": 82077, + "subdir": "linux-64", + "timestamp": 1592846461076, + "version": "0.33.2" + }, + "python-language-server-0.33.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea6c189f18a5ea703b6cf38aa87ed3a0", + "name": "python-language-server", + "sha256": "57148e6d694bf96728270128442935c56205a4beb1879fe26388a817bcf1b7d5", + "size": 81994, + "subdir": "linux-64", + "timestamp": 1592846450262, + "version": "0.33.2" + }, + "python-language-server-0.33.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cbb45a39e4c629e75e189c7e141c1e5b", + "name": "python-language-server", + "sha256": "e680018e41733e37fb79b9ceb71cf960c4aee3787a5d55856796fc2dde5a6a7c", + "size": 81679, + "subdir": "linux-64", + "timestamp": 1592846461245, + "version": "0.33.2" + }, + "python-language-server-0.33.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a59ee5304d3775be6558d60cc4280454", + "name": "python-language-server", + "sha256": "cf689e85a6fd7f9b3c3f89ad55e3c7dc2ef6331efa4a346a7ba61ed321de0c09", + "size": 81699, + "subdir": "linux-64", + "timestamp": 1593447333360, + "version": "0.33.3" + }, + "python-language-server-0.33.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5bc68dd78fc6f9c790b548d3cce00580", + "name": "python-language-server", + "sha256": "b1c8293201183d5260b87b982de51a59ecb5dea959d58e58a010465e5e808ecc", + "size": 82696, + "subdir": "linux-64", + "timestamp": 1593447317050, + "version": "0.33.3" + }, + "python-language-server-0.33.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1f16ca437cc0c5825abf06ddc0e560e", + "name": "python-language-server", + "sha256": "3a5bed45e2dc4235a49c4e8df740f45db15ad546ec8ed8dbde41430608e69342", + "size": 82400, + "subdir": "linux-64", + "timestamp": 1593447319513, + "version": "0.33.3" + }, + "python-language-server-0.34.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.6,<3.7.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01f9206be6177b78ad38eb8c9e6e2f62", + "name": "python-language-server", + "sha256": "691642693f6e7d7f612280f832fc9707dda5e9127cd91f3e994cb0d580aae142", + "size": 82697, + "subdir": "linux-64", + "timestamp": 1594161901855, + "version": "0.34.1" + }, + "python-language-server-0.34.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.7,<3.8.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8dc8c51346cd7a4ba495b72aad2e4a3c", + "name": "python-language-server", + "sha256": "41e753943e54a7dbb85ff2d15fb721a8fd63059e0cd3f4b91480518b82bbf5ae", + "size": 82809, + "subdir": "linux-64", + "timestamp": 1594161936391, + "version": "0.34.1" + }, + "python-language-server-0.34.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "autopep8", + "flake8 >=3.8.0", + "jedi >=0.17.0,<0.18.0a0", + "mccabe >=0.6.0,<0.7.0", + "pluggy", + "pycodestyle >=2.6.0,<2.7.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.2.0,<2.3.0", + "pylint", + "python >=3.8,<3.9.0a0", + "python-jsonrpc-server >=0.3.2", + "rope >=0.10.5", + "setuptools", + "ujson <=1.35", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "619bd5d4b5f2de9906edf8b673e37594", + "name": "python-language-server", + "sha256": "d5686ad989802db65a881a3e9a686c22f088ae0003b8e96a0eb4399f51cb8c82", + "size": 83096, + "subdir": "linux-64", + "timestamp": 1594161939648, + "version": "0.34.1" + }, + "python-ldap-3.4.0-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "openldap >=2.4.11,<2.5", + "openldap >=2.4.58,<2.5.0a0", + "pyasn1", + "pyasn1-modules", + "python >=3.10,<3.11.0a0" + ], + "license": "Python Software Foundation", + "license_family": "OTHER", + "md5": "a844bdbec5e4af92e497c79467d13b26", + "name": "python-ldap", + "namespace_in_name": true, + "sha256": "23286fbd1a23aafe48be25b9b86c25a1f6119b29d564639a08eed63402778fe1", + "size": 227645, + "subdir": "linux-64", + "timestamp": 1659722265640, + "version": "3.4.0" + }, + "python-ldap-3.4.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "openldap >=2.4.11,<2.5", + "openldap >=2.4.58,<2.5.0a0", + "pyasn1", + "pyasn1-modules", + "python >=3.11,<3.12.0a0" + ], + "license": "Python Software Foundation", + "license_family": "OTHER", + "md5": "63b7aed683f1085ed2b7cf810423a133", + "name": "python-ldap", + "namespace_in_name": true, + "sha256": "7e895f8a9f31418a71cc12fc402e3e82b58af288471ca8929f375a32def0ddb2", + "size": 199742, + "subdir": "linux-64", + "timestamp": 1676861517258, + "version": "3.4.0" + }, + "python-ldap-3.4.0-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "openldap >=2.4.11,<2.5", + "openldap >=2.4.58,<2.5.0a0", + "pyasn1", + "pyasn1-modules", + "python >=3.7,<3.8.0a0" + ], + "license": "Python Software Foundation", + "license_family": "OTHER", + "md5": "d4faa642c99b63f86c2f6a07adf101d8", + "name": "python-ldap", + "namespace_in_name": true, + "sha256": "daff00448fdfb429db2177e20d55a98d70a91612b5276b48ede760f845975bd2", + "size": 157497, + "subdir": "linux-64", + "timestamp": 1659722219570, + "version": "3.4.0" + }, + "python-ldap-3.4.0-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "openldap >=2.4.11,<2.5", + "openldap >=2.4.58,<2.5.0a0", + "pyasn1", + "pyasn1-modules", + "python >=3.8,<3.9.0a0" + ], + "license": "Python Software Foundation", + "license_family": "OTHER", + "md5": "a5a3cd14e90d0a382c921e79bd7b1456", + "name": "python-ldap", + "namespace_in_name": true, + "sha256": "be0b170a78b3a6851ad2760ca386b6e971daca62645905bc0078e810e433a2b9", + "size": 158745, + "subdir": "linux-64", + "timestamp": 1659722332962, + "version": "3.4.0" + }, + "python-ldap-3.4.0-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "openldap >=2.4.11,<2.5", + "openldap >=2.4.58,<2.5.0a0", + "pyasn1", + "pyasn1-modules", + "python >=3.9,<3.10.0a0" + ], + "license": "Python Software Foundation", + "license_family": "OTHER", + "md5": "6af6d96af2fdee559fa8054f5c53c489", + "name": "python-ldap", + "namespace_in_name": true, + "sha256": "6338a5806878035c401828bcd15b33b761c1dfed5d11cd5e9ad468b37304b95b", + "size": 158918, + "subdir": "linux-64", + "timestamp": 1659722300992, + "version": "3.4.0" + }, + "python-leveldb-0.20-py27hf484d3e_1.conda": { + "build": "py27hf484d3e_1", + "build_number": 1, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "474e07dcb65ddc64835e6eb73d9534dd", + "name": "python-leveldb", + "sha256": "eb8ae6f385844dae70462dd1631588ede12249c5e3b1779dd5f964cbe06ea8ed", + "size": 24747, + "subdir": "linux-64", + "timestamp": 1512805102043, + "version": "0.20" + }, + "python-leveldb-0.20-py35hf484d3e_1.conda": { + "build": "py35hf484d3e_1", + "build_number": 1, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "347c097b55f8dabf6eaf571c7715bfb6", + "name": "python-leveldb", + "sha256": "2c53a2ea8a0ef46b332c4cf6770934675af92c72074a19c94e4954216541daf5", + "size": 24849, + "subdir": "linux-64", + "timestamp": 1512805041846, + "version": "0.20" + }, + "python-leveldb-0.20-py36hf484d3e_1.conda": { + "build": "py36hf484d3e_1", + "build_number": 1, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "de91e2d4c5b17d2285a194d2a82836ac", + "name": "python-leveldb", + "sha256": "f722baa4eae8c97ca6d88ff85bfc208981c8dcea94d18c2d33f13ec06d9057e4", + "size": 24809, + "subdir": "linux-64", + "timestamp": 1512805238226, + "version": "0.20" + }, + "python-leveldb-0.20-py37hf484d3e_1.conda": { + "build": "py37hf484d3e_1", + "build_number": 1, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "64d2a2f96f28c146f5658924c02f909e", + "name": "python-leveldb", + "sha256": "19e313c80dec044b02c71445c1922764efe359f216d243a8421f54db35b4e73f", + "size": 24913, + "subdir": "linux-64", + "timestamp": 1530792937990, + "version": "0.20" + }, + "python-leveldb-0.20-py38he6710b0_1.conda": { + "build": "py38he6710b0_1", + "build_number": 1, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "42637cc56e48f49d617282259644396e", + "name": "python-leveldb", + "sha256": "75a4bc0ae8781813182b665702422b002d2288f099fce166152276bba4b64565", + "size": 32527, + "subdir": "linux-64", + "timestamp": 1573200469890, + "version": "0.20" + }, + "python-leveldb-0.201-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "leveldb >=1.23,<1.24.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "194171e6fa9a621c45676fb3d9106613", + "name": "python-leveldb", + "sha256": "ea5289010f41a430dfcb27a0a34a41044287bb278a6e9ca469a75923a85c6d3c", + "size": 102149, + "subdir": "linux-64", + "timestamp": 1640793837358, + "version": "0.201" + }, + "python-leveldb-0.201-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "664db0e19929cc4e3a3f1a953deb632f", + "name": "python-leveldb", + "sha256": "6a2ee8e347a5c8ee1191141b10b5d220cf44752ea3d7da4e77d5cd092ee0b9ef", + "size": 26076, + "subdir": "linux-64", + "timestamp": 1676861536965, + "version": "0.201" + }, + "python-leveldb-0.201-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e24d32064a7a152bf1319c2155501ea5", + "name": "python-leveldb", + "sha256": "534f57e4b6c88c425864473618f208d8ab4d008612c4f6a8b2d97fcb65991cce", + "size": 26473, + "subdir": "linux-64", + "timestamp": 1613553945503, + "version": "0.201" + }, + "python-leveldb-0.201-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "336aeee590f65fe5149bea958eb2a5af", + "name": "python-leveldb", + "sha256": "56b8973c4ef47262fd373a58f3960b366155391ea6c9eebd6e95d565d3ff6c12", + "size": 26556, + "subdir": "linux-64", + "timestamp": 1580311448503, + "version": "0.201" + }, + "python-leveldb-0.201-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1d4fd3dacb16eecf727f46136497fb85", + "name": "python-leveldb", + "sha256": "a22f216d9d6d9fcd8b33cd2bad568b26814d8be677aba8439e0de01550012c3b", + "size": 26496, + "subdir": "linux-64", + "timestamp": 1613553279129, + "version": "0.201" + }, + "python-leveldb-0.201-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "82f74f42ba3ee351c8f76486875cea17", + "name": "python-leveldb", + "sha256": "676fa33facde9396714a5a8b0ef7941c1710661f779b70385531c02b486e413d", + "size": 26538, + "subdir": "linux-64", + "timestamp": 1580311438318, + "version": "0.201" + }, + "python-leveldb-0.201-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "57907b8b0d632f12d9fb474946dbfba3", + "name": "python-leveldb", + "sha256": "336217667c228aacde93c090ed005912790ab2d79dfa44496e623beb535c9b3b", + "size": 27337, + "subdir": "linux-64", + "timestamp": 1613553950772, + "version": "0.201" + }, + "python-leveldb-0.201-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3174c0b71b06ce5a833c6765334d4bf3", + "name": "python-leveldb", + "sha256": "f247da046764c75532ee34f5ff8bca37c6e8c31809b0ff45c55dba98418c25af", + "size": 27076, + "subdir": "linux-64", + "timestamp": 1580311443433, + "version": "0.201" + }, + "python-leveldb-0.201-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "leveldb >=1.20,<1.21.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b0becc1f286cb21d2a722180566599d7", + "name": "python-leveldb", + "sha256": "4b6b9a22f3b6bba7608dff94f2acccf784172f4abbf6fd3e0bc8cfc0b9f78d04", + "size": 27045, + "subdir": "linux-64", + "timestamp": 1613553947976, + "version": "0.201" + }, + "python-levenshtein-0.12.0-py27h7b6447c_1001.conda": { + "build": "py27h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "3126a88eb79839ba58fc96b865999419", + "name": "python-levenshtein", + "sha256": "8717e1059e1f7cba04b7f055fdda45a793595f83ba047bb8221c4baf7d37d11a", + "size": 75708, + "subdir": "linux-64", + "timestamp": 1569336193856, + "version": "0.12.0" + }, + "python-levenshtein-0.12.0-py36h7b6447c_1001.conda": { + "build": "py36h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "35b7796580fc70df8de5e4272ca3170b", + "name": "python-levenshtein", + "sha256": "53d49d3128ee39cddd3abd4e64f82dd6a05905b1d000170a03b394d88ef803df", + "size": 76981, + "subdir": "linux-64", + "timestamp": 1569336198573, + "version": "0.12.0" + }, + "python-levenshtein-0.12.0-py37h7b6447c_1001.conda": { + "build": "py37h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "license_family": "GPL", + "md5": "1a7036a23ea10ca1f94640c66f782c1d", + "name": "python-levenshtein", + "sha256": "a3c3c97bc23c301707dc976c8f633ecf49ac6cc4052434226c9cc1e637e30fcb", + "size": 76651, + "subdir": "linux-64", + "timestamp": 1569336189485, + "version": "0.12.0" + }, + "python-levenshtein-0.12.2-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "1854eed0f8fbd347051bd5b63645a4db", + "name": "python-levenshtein", + "sha256": "4d3afbe2d2b6c2baa105a583bd05345bf2569159b3608d6beb7d0af6d36e9b98", + "size": 139170, + "subdir": "linux-64", + "timestamp": 1640793861939, + "version": "0.12.2" + }, + "python-levenshtein-0.12.2-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "f3414cf98b51af085f37a3b2b2b3967b", + "name": "python-levenshtein", + "sha256": "8d33a46dd54cdd99aac3d59cf3ee41bbe08c7ad1e20874579b5f51b0f90d2a34", + "size": 75754, + "subdir": "linux-64", + "timestamp": 1676845559787, + "version": "0.12.2" + }, + "python-levenshtein-0.12.2-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "3aa0c42c86b005fdaa1415a414b7e0a2", + "name": "python-levenshtein", + "sha256": "9503275776502129bd2818bb35f25d820e1194ee92500b226c88aa92357ba39a", + "size": 78855, + "subdir": "linux-64", + "timestamp": 1613984391327, + "version": "0.12.2" + }, + "python-levenshtein-0.12.2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "8586618405e4eb924dc3328a1cc5882d", + "name": "python-levenshtein", + "sha256": "d0db2eda1b348781589ff976093fac58daec1acfac06c93dade5895ef9ceea0b", + "size": 78638, + "subdir": "linux-64", + "timestamp": 1613985269759, + "version": "0.12.2" + }, + "python-levenshtein-0.12.2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "8a7dcb31aef158df87eda9f3f510d743", + "name": "python-levenshtein", + "sha256": "36883d29e719aba17c574dfa109c70ab09544b2f27058d701f8027cb18388cca", + "size": 78165, + "subdir": "linux-64", + "timestamp": 1613985276279, + "version": "0.12.2" + }, + "python-levenshtein-0.12.2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "414a02dd28305c5a1b725c877c310517", + "name": "python-levenshtein", + "sha256": "71c925e77931e321b89883339a507ecc70b073bd1dbf9f679584a90eaf3ca436", + "size": 78608, + "subdir": "linux-64", + "timestamp": 1613985249163, + "version": "0.12.2" + }, + "python-libarchive-c-2.7-py27_3.conda": { + "build": "py27_3", + "build_number": 3, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "5917e15d51f17ebcb5dbce02b844649f", + "name": "python-libarchive-c", + "sha256": "b771c3c9311a890c147bb071f1f9d90e8eec415c5b30a2e07d6f8ec4abdbd751", + "size": 30275, + "subdir": "linux-64", + "timestamp": 1527551636972, + "version": "2.7" + }, + "python-libarchive-c-2.7-py27ha516919_0.conda": { + "build": "py27ha516919_0", + "build_number": 0, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "6f13adc766e81e44e94b0aec8ea0671e", + "name": "python-libarchive-c", + "sha256": "6b91467592c5d4de20c4574dda651ef280a561b17e21dfad8b12dfdfb3823073", + "size": 18683, + "subdir": "linux-64", + "timestamp": 1509635398174, + "version": "2.7" + }, + "python-libarchive-c-2.7-py27hc39dc16_0.conda": { + "build": "py27hc39dc16_0", + "build_number": 0, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "65f39189885cf1173c5052d4b3c8d145", + "name": "python-libarchive-c", + "sha256": "0e1d7e6a62f1c3909309d614d1dde5af0fa1416f6710fb0b65ed169795fa3726", + "size": 19037, + "subdir": "linux-64", + "timestamp": 1510141974996, + "version": "2.7" + }, + "python-libarchive-c-2.7-py35_3.conda": { + "build": "py35_3", + "build_number": 3, + "depends": [ + "libarchive", + "python >=3.5,<3.6.0a0" + ], + "license": "CC0-1.0", + "md5": "1e87ae3e56393f88a80221fe8a1ae3bc", + "name": "python-libarchive-c", + "sha256": "35b4712231b90e41a11150f2de083f245a633ea26e2c0ec68fa0867493a5e691", + "size": 30529, + "subdir": "linux-64", + "timestamp": 1527551658879, + "version": "2.7" + }, + "python-libarchive-c-2.7-py35h47bb897_0.conda": { + "build": "py35h47bb897_0", + "build_number": 0, + "depends": [ + "libarchive", + "python >=3.5,<3.6.0a0" + ], + "license": "CC0-1.0", + "md5": "9f7b0284bf1b42b7da2dfe4f7556349d", + "name": "python-libarchive-c", + "sha256": "608da09bb3a44a126a8860f633321810f50145400e8f247bc5c3420155f07c1b", + "size": 19000, + "subdir": "linux-64", + "timestamp": 1509635419277, + "version": "2.7" + }, + "python-libarchive-c-2.7-py35he097adb_0.conda": { + "build": "py35he097adb_0", + "build_number": 0, + "depends": [ + "libarchive", + "python >=3.5,<3.6.0a0" + ], + "license": "CC0-1.0", + "md5": "cc6c02599e1d6693c765134777849fad", + "name": "python-libarchive-c", + "sha256": "ff260138c477802276b83aeeda7c4f9bd79ac37756c653702db45f84154bfb22", + "size": 19247, + "subdir": "linux-64", + "timestamp": 1510141990010, + "version": "2.7" + }, + "python-libarchive-c-2.7-py36_3.conda": { + "build": "py36_3", + "build_number": 3, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "fabfa53994cfec58244bc572a4c00780", + "name": "python-libarchive-c", + "sha256": "083a5e4f89e2ec4e58976264b77e40dc62efaef540de4cf03cbdafe97f0659d7", + "size": 30328, + "subdir": "linux-64", + "timestamp": 1527551632637, + "version": "2.7" + }, + "python-libarchive-c-2.7-py36h2a28448_0.conda": { + "build": "py36h2a28448_0", + "build_number": 0, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "f657b4b349ebf160a6d62f6680c5b475", + "name": "python-libarchive-c", + "sha256": "0ed12244f5e59c43f7e4785071a2f3a0ef83f45005c89d4f37ea675dafc93048", + "size": 18769, + "subdir": "linux-64", + "timestamp": 1509635440694, + "version": "2.7" + }, + "python-libarchive-c-2.7-py36h34ba79f_0.conda": { + "build": "py36h34ba79f_0", + "build_number": 0, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "54077bf1ba9b3c3cb81ce49b07a52535", + "name": "python-libarchive-c", + "sha256": "12a69ce786b6fa78aa1b1d1a2f832fca751c642f86537cc98fca05f2e72836d3", + "size": 19010, + "subdir": "linux-64", + "timestamp": 1510142004761, + "version": "2.7" + }, + "python-libarchive-c-2.8-py27_10.conda": { + "build": "py27_10", + "build_number": 10, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "696cd12d170b74156278f6f8f42596a4", + "name": "python-libarchive-c", + "sha256": "d04a578c26d4e2567ce2e05d763743e2e162cd9d2e75d675d52b27ed191c0fe7", + "size": 23715, + "subdir": "linux-64", + "timestamp": 1562637158950, + "version": "2.8" + }, + "python-libarchive-c-2.8-py27_11.conda": { + "build": "py27_11", + "build_number": 11, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "7a5ba1d102cf18b877cb7f583f4fe66f", + "name": "python-libarchive-c", + "sha256": "d2a1dce9955385cecdcfa34545b4e80aaacfe2abf88090fb8d8b96e2f519a836", + "size": 24034, + "subdir": "linux-64", + "timestamp": 1563379126980, + "version": "2.8" + }, + "python-libarchive-c-2.8-py27_12.conda": { + "build": "py27_12", + "build_number": 12, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "55808cc3966127a4a84c2ed485593d48", + "name": "python-libarchive-c", + "sha256": "8979dc2188a7f61a1e096320c4bb0f0f9447aad2b20a64128da1f5711662d3a1", + "size": 24515, + "subdir": "linux-64", + "timestamp": 1565094958470, + "version": "2.8" + }, + "python-libarchive-c-2.8-py27_13.conda": { + "build": "py27_13", + "build_number": 13, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "0bf33fc7542d83b0c9cd2112d6483b80", + "name": "python-libarchive-c", + "sha256": "ff44909e843fc4711582f4e91b2e9ac1641362955e31c96c8cba2876fb3e8e8e", + "size": 24830, + "subdir": "linux-64", + "timestamp": 1565112859003, + "version": "2.8" + }, + "python-libarchive-c-2.8-py27_3.conda": { + "build": "py27_3", + "build_number": 3, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "9c5c8a8207383e9a8de522776f33048c", + "name": "python-libarchive-c", + "sha256": "2b00c68a3f9b27ed6a1239514b0f08cb01d698ea9c088f5d6ff05d92d480f620", + "size": 20464, + "subdir": "linux-64", + "timestamp": 1528670501438, + "version": "2.8" + }, + "python-libarchive-c-2.8-py27_4.conda": { + "build": "py27_4", + "build_number": 4, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "e856c549f836419d8679675c08580d70", + "name": "python-libarchive-c", + "sha256": "2c1f39f96a75b4d8ead28d4843708e88035705b997d1479b0b2136294b7cabb7", + "size": 20839, + "subdir": "linux-64", + "timestamp": 1537561698266, + "version": "2.8" + }, + "python-libarchive-c-2.8-py27_5.conda": { + "build": "py27_5", + "build_number": 5, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "83d42f1cd1276f48e1cc8ed77d8c0764", + "name": "python-libarchive-c", + "sha256": "dba235a71accd3f4740b0c0f0732d7de2ee81c1230b83870c316444b974f3ba7", + "size": 21050, + "subdir": "linux-64", + "timestamp": 1537657609137, + "version": "2.8" + }, + "python-libarchive-c-2.8-py27_6.conda": { + "build": "py27_6", + "build_number": 6, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "a2067bff5a7d5ac1df3dc6a631ea9f9f", + "name": "python-libarchive-c", + "sha256": "9d91bb7070e22182de13d8dcd639743f1718678d83901a415bdba99dc22edc2e", + "size": 21114, + "subdir": "linux-64", + "timestamp": 1538304544227, + "version": "2.8" + }, + "python-libarchive-c-2.8-py27_8.conda": { + "build": "py27_8", + "build_number": 8, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "fc498971b35c6f3c67eca2bf1c4c089c", + "name": "python-libarchive-c", + "sha256": "836f39e04248f1026bad033d53f5baa26c0cbd938ef0822dee129f03cb17475e", + "size": 23283, + "subdir": "linux-64", + "timestamp": 1562099804534, + "version": "2.8" + }, + "python-libarchive-c-2.8-py27_9.conda": { + "build": "py27_9", + "build_number": 9, + "depends": [ + "libarchive", + "python >=2.7,<2.8.0a0" + ], + "license": "CC0-1.0", + "md5": "8618c4180a5a9ebb86a02afb0b546ca9", + "name": "python-libarchive-c", + "sha256": "4f855daa0a6a2d795913556cb635080e36e5ecca3cb72fa04cef2fade7914adc", + "size": 23378, + "subdir": "linux-64", + "timestamp": 1562445650897, + "version": "2.8" + }, + "python-libarchive-c-2.8-py35_3.conda": { + "build": "py35_3", + "build_number": 3, + "depends": [ + "libarchive", + "python >=3.5,<3.6.0a0" + ], + "license": "CC0-1.0", + "md5": "dda61179ad2be8ea843ff22b42ddc0c8", + "name": "python-libarchive-c", + "sha256": "9b2d1ef6bbf97110fbd7b9c2940ad182dcc6677b0e8254fe4500405821acaff2", + "size": 20972, + "subdir": "linux-64", + "timestamp": 1528670552417, + "version": "2.8" + }, + "python-libarchive-c-2.8-py35_4.conda": { + "build": "py35_4", + "build_number": 4, + "depends": [ + "libarchive", + "python >=3.5,<3.6.0a0" + ], + "license": "CC0-1.0", + "md5": "b9b8c10827381e3aacee7c91f09386b8", + "name": "python-libarchive-c", + "sha256": "a2f0cd3c8775c440c744cd7debd81a66b59456603466d2febe926f39766be08a", + "size": 21179, + "subdir": "linux-64", + "timestamp": 1537561529759, + "version": "2.8" + }, + "python-libarchive-c-2.8-py35_5.conda": { + "build": "py35_5", + "build_number": 5, + "depends": [ + "libarchive", + "python >=3.5,<3.6.0a0" + ], + "license": "CC0-1.0", + "md5": "d8d5e72d9db34ac2130ab1219ba89ccd", + "name": "python-libarchive-c", + "sha256": "63c3c34367612707976d3c6d2a414918c5d79390d1cdc98bbbafa1cbe418861a", + "size": 21219, + "subdir": "linux-64", + "timestamp": 1537657732991, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_10.conda": { + "build": "py36_10", + "build_number": 10, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "d16fe5fe03231609426a3b1947624cdf", + "name": "python-libarchive-c", + "sha256": "cdb11f545dbf3e2cf6e707ddf6e139f60c1f5ded349629643394ab49dac7412c", + "size": 23668, + "subdir": "linux-64", + "timestamp": 1562637162314, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_11.conda": { + "build": "py36_11", + "build_number": 11, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "ea78e927f6e29fa4cc4adc0effaab703", + "name": "python-libarchive-c", + "sha256": "9d997c46f38351c12e62594a0c2113edc49464222aa5a430fa29e451765779e5", + "size": 23906, + "subdir": "linux-64", + "timestamp": 1563379115093, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_12.conda": { + "build": "py36_12", + "build_number": 12, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "3dbf9f2f51d87bf31b9fed04097a1774", + "name": "python-libarchive-c", + "sha256": "9278c598a41556ccd50a36694cf96b3f9f3f552c582b46fb6164b1e0bf1103c2", + "size": 24675, + "subdir": "linux-64", + "timestamp": 1565095021240, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_13.conda": { + "build": "py36_13", + "build_number": 13, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "7cc28ca5992153545d5bb2d6f3640fb1", + "name": "python-libarchive-c", + "sha256": "a6e3d192976e03f9f6dc583c19ce8ff1b54e14c556d5b3f6ba454b50599dc53a", + "size": 24772, + "subdir": "linux-64", + "timestamp": 1565112920393, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_3.conda": { + "build": "py36_3", + "build_number": 3, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "04c397a4e68442c4ee1a896bde236daa", + "name": "python-libarchive-c", + "sha256": "b23e486e5517cd90cafda1ca587a816e76558378dd101f7c4babde36a6e37071", + "size": 20566, + "subdir": "linux-64", + "timestamp": 1528670528832, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_4.conda": { + "build": "py36_4", + "build_number": 4, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "e15c9587772e91c2d1fd575863b60463", + "name": "python-libarchive-c", + "sha256": "d7641f8e38c881fbe3abc540fe875a38273305499ef04157194418d29eb2dae0", + "size": 20937, + "subdir": "linux-64", + "timestamp": 1537561759185, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_5.conda": { + "build": "py36_5", + "build_number": 5, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "a29b0dbdf7a2da15978235f8f2011cea", + "name": "python-libarchive-c", + "sha256": "b5096d3950cf69928d3bb01063d473f153728db317de4cbe24744400c78e7abf", + "size": 21135, + "subdir": "linux-64", + "timestamp": 1537657954901, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_6.conda": { + "build": "py36_6", + "build_number": 6, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "308b232dd428829f7f012fd5289238e6", + "name": "python-libarchive-c", + "sha256": "74a75a6a43d7f5e93afd09de3c5b6a03670dcfa4e39da21b72b7d44656ff4100", + "size": 21390, + "subdir": "linux-64", + "timestamp": 1538304557337, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_8.conda": { + "build": "py36_8", + "build_number": 8, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "41e8bd1bc23506f162ff11f115494e39", + "name": "python-libarchive-c", + "sha256": "0451bbb2e327f52f10b2ca7ec5db1f34e362b7d786ea9d7209f428b3d306c829", + "size": 23375, + "subdir": "linux-64", + "timestamp": 1562099814444, + "version": "2.8" + }, + "python-libarchive-c-2.8-py36_9.conda": { + "build": "py36_9", + "build_number": 9, + "depends": [ + "libarchive", + "python >=3.6,<3.7.0a0" + ], + "license": "CC0-1.0", + "md5": "2e1cacf88825a4898eab553608b86327", + "name": "python-libarchive-c", + "sha256": "c9d348e1ea45af3fc98b54bd95fd39d284616a6fd9046ae34acaaf0384038f1f", + "size": 23468, + "subdir": "linux-64", + "timestamp": 1562445658204, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_10.conda": { + "build": "py37_10", + "build_number": 10, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "8236189afefd58670f8d8f1a24b534da", + "name": "python-libarchive-c", + "sha256": "7bc848f6fb48b126853e578481ca7822560e838b69a95f9991eaa042df3fa0ee", + "size": 23494, + "subdir": "linux-64", + "timestamp": 1562637147425, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_11.conda": { + "build": "py37_11", + "build_number": 11, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "a4538c2670c4d669e0d988ce468fdac2", + "name": "python-libarchive-c", + "sha256": "8894d3de834b7f36b25046c49e6562287e8633a9b2bf7b359bf07d19f43cf124", + "size": 24012, + "subdir": "linux-64", + "timestamp": 1563379109593, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_12.conda": { + "build": "py37_12", + "build_number": 12, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "0515a489977a1e2791f235195e3b91ed", + "name": "python-libarchive-c", + "sha256": "9cd193acb5df2233b19caecf49c57e3548996c7c3d198b871a30e13daac33d7a", + "size": 24517, + "subdir": "linux-64", + "timestamp": 1565094922619, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_13.conda": { + "build": "py37_13", + "build_number": 13, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "958730010c39cc6a0a3212cdb444c140", + "name": "python-libarchive-c", + "sha256": "cd9cb3927cb23e633ea71bee3f5bbfe34057ff016fc90a6b237b9ad8c882e4ea", + "size": 24598, + "subdir": "linux-64", + "timestamp": 1565112746113, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_3.conda": { + "build": "py37_3", + "build_number": 3, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "c7eb67f469fddc3a62f8d2292e831dc8", + "name": "python-libarchive-c", + "sha256": "17e04515d53fdea01bf4c739cf33a4d92a40aa0a4f48e57290e65070c4e49765", + "size": 20616, + "subdir": "linux-64", + "timestamp": 1530922766626, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_4.conda": { + "build": "py37_4", + "build_number": 4, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "84c6108c671b2c047c41306da55a48a7", + "name": "python-libarchive-c", + "sha256": "494fb9daf21a7b822fd25121ed7255a542c783e3cdf11c5f3d8d3fe4ea5df77b", + "size": 20906, + "subdir": "linux-64", + "timestamp": 1537561435967, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_5.conda": { + "build": "py37_5", + "build_number": 5, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "3e0f5cab7828849b7c356c970242f002", + "name": "python-libarchive-c", + "sha256": "dd3b6e139e5deb131ca231d3018dbe2d1091f6bd47e4881f713e7048a6e8ed07", + "size": 21106, + "subdir": "linux-64", + "timestamp": 1537657341519, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_6.conda": { + "build": "py37_6", + "build_number": 6, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "672525b7c4fda7b1d30022c82383b7a7", + "name": "python-libarchive-c", + "sha256": "3314f4e2881a6503b76a54b0de616e7e91c3022a18518c6eb13845082a365ec4", + "size": 21179, + "subdir": "linux-64", + "timestamp": 1538304523663, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_8.conda": { + "build": "py37_8", + "build_number": 8, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "526d6f9c5dd70e0370e769d0842b790b", + "name": "python-libarchive-c", + "sha256": "8ff05110d2ba281995528dee59d8d46195706950b65e760983219d0c20479caf", + "size": 23335, + "subdir": "linux-64", + "timestamp": 1562099785109, + "version": "2.8" + }, + "python-libarchive-c-2.8-py37_9.conda": { + "build": "py37_9", + "build_number": 9, + "depends": [ + "libarchive", + "python >=3.7,<3.8.0a0" + ], + "license": "CC0-1.0", + "md5": "f240e33779ee6bd40be44a3ef883a97a", + "name": "python-libarchive-c", + "sha256": "07b41a8653fa4709e1b1f750b7d5aeb28bc75d7fac0ba985f1c533eb99ce9936", + "size": 23398, + "subdir": "linux-64", + "timestamp": 1562445646708, + "version": "2.8" + }, + "python-libarchive-c-2.8-py38_7.conda": { + "build": "py38_7", + "build_number": 7, + "depends": [ + "libarchive", + "python >=3.8,<3.9.0a0" + ], + "license": "CC0-1.0", + "md5": "60f10592e315b80aee8039e842b7f787", + "name": "python-libarchive-c", + "sha256": "17bd9ff7498e7c720eae41a540d7976f8783b849f86901e425cf4ada5a155eee", + "size": 21469, + "subdir": "linux-64", + "timestamp": 1573200481551, + "version": "2.8" + }, + "python-libarchive-c-2.9-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "libarchive", + "python >=3.9,<3.10.0a0" + ], + "license": "CC0-1.0", + "md5": "2ad1673b1cd5020f6068a3f26396046d", + "name": "python-libarchive-c", + "sha256": "7cea42ba14546005c0a0eb62f77e04ffcbba3b18f24ffba618f5ed8e69c1ea47", + "size": 32407, + "subdir": "linux-64", + "timestamp": 1605468802267, + "version": "2.9" + }, + "python-lmdb-0.93-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "e69108e4b26db3af041710f2a1311e1e", + "name": "python-lmdb", + "sha256": "d54eb81da915929597124ee2d47900b8f66a5fd438ab192f5282c7027fee40ef", + "size": 122628, + "subdir": "linux-64", + "timestamp": 1522882457657, + "version": "0.93" + }, + "python-lmdb-0.93-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "d0ee0ae6602496672c98a8125c974c1d", + "name": "python-lmdb", + "sha256": "59bb956a3b9f0dc6a8230a9399a074a7e9a60b253740505a6e94ba722f58aa86", + "size": 122952, + "subdir": "linux-64", + "timestamp": 1522882518263, + "version": "0.93" + }, + "python-lmdb-0.93-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "2490ba526ae2b285ad031a5772fcfedb", + "name": "python-lmdb", + "sha256": "adb2ae3f60c64bc81f842f6352cae1fc1949b58056c5d8b9fc721f48b638ef51", + "size": 122539, + "subdir": "linux-64", + "timestamp": 1522882517608, + "version": "0.93" + }, + "python-lmdb-0.94-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "bdbe09d886b5a53a14c83b5a2d0beea3", + "name": "python-lmdb", + "sha256": "f33efb726768fe4787e44027fb1d5f200af39ff9682ea56d47e08f19b8b84957", + "size": 123557, + "subdir": "linux-64", + "timestamp": 1524094866968, + "version": "0.94" + }, + "python-lmdb-0.94-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "3b8d43ac7d92a853ccd64e313d80736b", + "name": "python-lmdb", + "sha256": "0c3c1d4a4555e7948602beb287167a86f948b7a44e36a7a0fcf1f754dfa97fc8", + "size": 123843, + "subdir": "linux-64", + "timestamp": 1524094899078, + "version": "0.94" + }, + "python-lmdb-0.94-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "f4ff0d130c45dc291c0856d2fa1c8e18", + "name": "python-lmdb", + "sha256": "45ce3de0e2db96a615e122ba018d1ea480878b07c48871133197650cb48e9af1", + "size": 123520, + "subdir": "linux-64", + "timestamp": 1524094904574, + "version": "0.94" + }, + "python-lmdb-0.94-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "a5efc52bc2eb604400545ab48c9fc642", + "name": "python-lmdb", + "sha256": "0d8a4049c619a3bd5b8cea1e0b255124ea82bbe1e71a4fa655e7082f5556a378", + "size": 123632, + "subdir": "linux-64", + "timestamp": 1530922808789, + "version": "0.94" + }, + "python-lmdb-0.97-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "22b4e3a9e0356d70ab25b498298557e8", + "name": "python-lmdb", + "sha256": "2d9aee534339d44ea0f7737321acaab50ee481b18c9e53bfe7ef1c063cb1efca", + "size": 126558, + "subdir": "linux-64", + "timestamp": 1569420583853, + "version": "0.97" + }, + "python-lmdb-0.97-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "053346a93214f9d29f259c591143b859", + "name": "python-lmdb", + "sha256": "e7cce960f615f6def0c2e42100eaefb1b6d1fba366b165fa353c887be3106d41", + "size": 126978, + "subdir": "linux-64", + "timestamp": 1569420589456, + "version": "0.97" + }, + "python-lmdb-0.97-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "8b70ca134b4457c6073f6cd720c88163", + "name": "python-lmdb", + "sha256": "66f869501c89c0fd41c52cfe2a3fae8fd0054b975e4f4583095cf13143b15483", + "size": 127405, + "subdir": "linux-64", + "timestamp": 1569420593949, + "version": "0.97" + }, + "python-lmdb-0.97-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "48ef56083316a4d251c676c39aefde76", + "name": "python-lmdb", + "sha256": "1332427e74fee878e71a64137aced686e1522541a767ca057004181100155037", + "size": 133024, + "subdir": "linux-64", + "timestamp": 1573200506334, + "version": "0.97" + }, + "python-lmdb-0.98-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "7cdbf35ae743dee5fa344fe57482ff56", + "name": "python-lmdb", + "sha256": "e208dcac5d94f3bc1c506449ec30cf645666b195227b6b284351ac9a331e6c56", + "size": 126470, + "subdir": "linux-64", + "timestamp": 1574369782412, + "version": "0.98" + }, + "python-lmdb-0.98-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "044aaa825f8d88823968446825bee2a0", + "name": "python-lmdb", + "sha256": "cbc6c9205f38c0d354bd2a83b21527b9a810f826e25966d3610f20be5b39d9aa", + "size": 127839, + "subdir": "linux-64", + "timestamp": 1574369789696, + "version": "0.98" + }, + "python-lmdb-0.98-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "da90617769350da964a03b5c98ef64f7", + "name": "python-lmdb", + "sha256": "742f470a02b00d3aa33a142f8ac026c36cbf98c0f888e57b957685b6784538bf", + "size": 127948, + "subdir": "linux-64", + "timestamp": 1574369773730, + "version": "0.98" + }, + "python-lmdb-0.98-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "496a0a85dba69bc65ccdb7f811b8f528", + "name": "python-lmdb", + "sha256": "eb45ff2d744a17fdcf4c44721686fa6576cbfae59b026a9a351c6debb997da46", + "size": 135152, + "subdir": "linux-64", + "timestamp": 1574369840669, + "version": "0.98" + }, + "python-lmdb-1.0.0-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "df8500b5e8175317aa1d3c7c070b1671", + "name": "python-lmdb", + "sha256": "77b6dcc57624d08e0b3a3bc2864d3d86afb0fa3530c97cbd19d2e0659fd974d6", + "size": 129110, + "subdir": "linux-64", + "timestamp": 1613553142968, + "version": "1.0.0" + }, + "python-lmdb-1.0.0-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "b6a802cc32c8acfd6c87ff145a06c9bc", + "name": "python-lmdb", + "sha256": "15c35d22f5e859c1b5dceb42ce794a7ac9a8938767be0f54715efedd3f175670", + "size": 130301, + "subdir": "linux-64", + "timestamp": 1613553139120, + "version": "1.0.0" + }, + "python-lmdb-1.0.0-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "96ac09eec3439fe8b44632ec5dfe0550", + "name": "python-lmdb", + "sha256": "ed9fd0cb4d0ae0a8f6dcc6b2ecaf7d32f9f42fdf59256744cbcb44a7b0c7f883", + "size": 132497, + "subdir": "linux-64", + "timestamp": 1613552485308, + "version": "1.0.0" + }, + "python-lmdb-1.0.0-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "a14f3c257aa828be06b27b8485911f53", + "name": "python-lmdb", + "sha256": "c6d6a83fdbea01aac2a029662e8ccb3415aa1e0f79e4a9917579ab110e107e3d", + "size": 131203, + "subdir": "linux-64", + "timestamp": 1613553130499, + "version": "1.0.0" + }, + "python-lmdb-1.1.1-py36h2531618_1.conda": { + "build": "py36h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "b3797a4f6941447983d7a2b5292cc925", + "name": "python-lmdb", + "sha256": "27c12f76bae6c893f1b4ed422465cf36b28f446b9bc5fba8b17287cb65890580", + "size": 133071, + "subdir": "linux-64", + "timestamp": 1613936429961, + "version": "1.1.1" + }, + "python-lmdb-1.1.1-py37h2531618_1.conda": { + "build": "py37h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "d7df6065d5fd5d4ca088d588bb9d202a", + "name": "python-lmdb", + "sha256": "b86bc014feb5390cf9cf745279d936691d4e4aa2a9374a1e41659c4cf39ed65f", + "size": 131484, + "subdir": "linux-64", + "timestamp": 1613935953661, + "version": "1.1.1" + }, + "python-lmdb-1.1.1-py38h2531618_1.conda": { + "build": "py38h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "434e8f1b7d41c993f8a07b890a2d43bc", + "name": "python-lmdb", + "sha256": "bdf86d8298b82c628f54cf5a8fb7b2e3b2c9475efc315a96b6af2ae6657fe58d", + "size": 132681, + "subdir": "linux-64", + "timestamp": 1613936431695, + "version": "1.1.1" + }, + "python-lmdb-1.1.1-py39h2531618_1.conda": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "2386b7ae35da232a2d6a31776e8dc197", + "name": "python-lmdb", + "sha256": "e2cb6ef88a2cb9189fe568bf3f54582a0c5900965af698c57b5d480fed447d29", + "size": 131578, + "subdir": "linux-64", + "timestamp": 1613936417951, + "version": "1.1.1" + }, + "python-lmdb-1.2.1-py310h295c915_1.conda": { + "build": "py310h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "deb3c0dcb828d2588d1ecd0d1ca5ac11", + "name": "python-lmdb", + "sha256": "e6c6c4c5475b7469dc9ac52ef8b06467f4db29e9a39714c7ea72651cc0c1a911", + "size": 251248, + "subdir": "linux-64", + "timestamp": 1640793890808, + "version": "1.2.1" + }, + "python-lmdb-1.2.1-py36h2531618_1.conda": { + "build": "py36h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "f2d2f29b3610fab6e73a955066c00f8d", + "name": "python-lmdb", + "sha256": "4f449297518366a4979316e5547ba9265c970165253d48b8a2d6c9dfd3439400", + "size": 133725, + "subdir": "linux-64", + "timestamp": 1619704435284, + "version": "1.2.1" + }, + "python-lmdb-1.2.1-py37h2531618_1.conda": { + "build": "py37h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "4dd03109468b345d4dc4eca0c53d681f", + "name": "python-lmdb", + "sha256": "e1c4ede005fc1240f4880646134b8c0cee646076b02308bbf2956a33c3c66c2c", + "size": 135585, + "subdir": "linux-64", + "timestamp": 1619708194728, + "version": "1.2.1" + }, + "python-lmdb-1.2.1-py38h2531618_1.conda": { + "build": "py38h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "b75d1de614e0279a8a2d8688abf642b2", + "name": "python-lmdb", + "sha256": "36ed78c9ceea2b23dc89eda307252e8009269d2ae93790107b77fe2e7094d980", + "size": 132877, + "subdir": "linux-64", + "timestamp": 1619708194484, + "version": "1.2.1" + }, + "python-lmdb-1.2.1-py39h2531618_1.conda": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "OpenLDAP", + "license_family": "Other", + "md5": "4b05a1053d9b331bec5abac61181c13d", + "name": "python-lmdb", + "sha256": "d487b7045e6c212a55f72164dfe1f74b177b01f782eee43d7264b2ad14343021", + "size": 134043, + "subdir": "linux-64", + "timestamp": 1619707719895, + "version": "1.2.1" + }, + "python-lmdb-1.4.0-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "OLDAP-2.8", + "license_family": "Other", + "md5": "535c562c72213acdb11dbb3f87cda070", + "name": "python-lmdb", + "sha256": "d1c2e315eb8b25462c8eb1767acda406d084f746607363b23f06e4e64843278b", + "size": 144386, + "subdir": "linux-64", + "timestamp": 1677273782973, + "version": "1.4.0" + }, + "python-lmdb-1.4.0-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "OLDAP-2.8", + "license_family": "Other", + "md5": "58e56157ce03f57c7fe622dd5bbff53d", + "name": "python-lmdb", + "sha256": "d67e51e03fe647afedab0837f29467c27d332398db439f6a6d9993a002532981", + "size": 145839, + "subdir": "linux-64", + "timestamp": 1677271680687, + "version": "1.4.0" + }, + "python-lmdb-1.4.0-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "OLDAP-2.8", + "license_family": "Other", + "md5": "bcb078ec0a7cd9bc8a1d394a31ead896", + "name": "python-lmdb", + "sha256": "cbff1d2eedc6c08dac953ce462251689d905da82d5915df77cbc3f6d3540ec20", + "size": 143026, + "subdir": "linux-64", + "timestamp": 1677273886282, + "version": "1.4.0" + }, + "python-lmdb-1.4.0-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "OLDAP-2.8", + "license_family": "Other", + "md5": "d4e4618e3c95ce10904ba6ee8ca8cf63", + "name": "python-lmdb", + "sha256": "e4e99b1e8257f613c82676eabddeffdf71cae9ccd5007579466bb0302ed9e28e", + "size": 143427, + "subdir": "linux-64", + "timestamp": 1677273817065, + "version": "1.4.0" + }, + "python-lmdb-1.4.0-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "OLDAP-2.8", + "license_family": "Other", + "md5": "13c478094f69a9e830698bb65527f366", + "name": "python-lmdb", + "sha256": "7280c46245283c806a3bfc1306c1557888a1f474fa96a7e827c433a49a6648f3", + "size": 143453, + "subdir": "linux-64", + "timestamp": 1677273851431, + "version": "1.4.0" + }, + "python-louvain-0.11-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "networkx", + "python >=2.7,<2.8.0a0" + ], + "license": "None", + "md5": "50faaca3aec2058997f6948cc65af24b", + "name": "python-louvain", + "sha256": "0523e15b96e8f9a1631ec8f210cd37949427de6795f8c5578647ab4aa89b1d7b", + "size": 14813, + "subdir": "linux-64", + "timestamp": 1534680531690, + "version": "0.11" + }, + "python-louvain-0.11-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "networkx", + "python >=3.5,<3.6.0a0" + ], + "license": "None", + "md5": "265c459bace869e0dccee25255835b0a", + "name": "python-louvain", + "sha256": "1e6c2b8df4d1355f2228c9318679f574e0ddbbc0925cea56cee9172af6ac059c", + "size": 14920, + "subdir": "linux-64", + "timestamp": 1534680540532, + "version": "0.11" + }, + "python-louvain-0.11-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "networkx", + "python >=3.6,<3.7.0a0" + ], + "license": "None", + "md5": "c00fbd2b78e380e8955be375b4f4f6ac", + "name": "python-louvain", + "sha256": "cfc3ff11a2d5ad7383b915212d3fee5e981e38ea94805687312039c1a8b5d4fd", + "size": 14868, + "subdir": "linux-64", + "timestamp": 1534680503010, + "version": "0.11" + }, + "python-louvain-0.11-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "networkx", + "python >=3.7,<3.8.0a0" + ], + "license": "None", + "md5": "51ecab35aeb91fd1e7a141626eae6f6a", + "name": "python-louvain", + "sha256": "e555e18207e5094ee8fc128df7266995527972f1f8e5ad570637ffd4998ec232", + "size": 14891, + "subdir": "linux-64", + "timestamp": 1534680545931, + "version": "0.11" + }, + "python-lsp-black-1.2.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "black >=22.3.0", + "python >=3.10,<3.11.0a0", + "python-lsp-server >=1.4.0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "78796ca06b734e1ff05598dde7ff69d8", + "name": "python-lsp-black", + "sha256": "159cbd8cee36614912a9a1c8b9538a1c883cfd67654fd850c2407760def174b5", + "size": 13290, + "subdir": "linux-64", + "timestamp": 1661852138917, + "version": "1.2.1" + }, + "python-lsp-black-1.2.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "black >=22.3.0", + "python >=3.11,<3.12.0a0", + "python-lsp-server >=1.4.0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c351c6399ad54bd321695299767d1180", + "name": "python-lsp-black", + "sha256": "4efaed42e25e14d76c2780615c502ffcbb0190c71391dacc0fd26355027fb950", + "size": 15643, + "subdir": "linux-64", + "timestamp": 1676845574234, + "version": "1.2.1" + }, + "python-lsp-black-1.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "black >=22.3.0", + "python >=3.7,<3.8.0a0", + "python-lsp-server >=1.4.0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8eaa82c745b7aba0ba041b77a6beec36", + "name": "python-lsp-black", + "sha256": "86aaa14469966ec319a539cffec28c5ef4c7006f72fd910823ef7a02738be0b7", + "size": 13190, + "subdir": "linux-64", + "timestamp": 1661852167529, + "version": "1.2.1" + }, + "python-lsp-black-1.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "black >=22.3.0", + "python >=3.8,<3.9.0a0", + "python-lsp-server >=1.4.0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6114f6f0ce4e6e7db8ad319ca3cf3b6d", + "name": "python-lsp-black", + "sha256": "02a7efa7b1a1564e5358458784ff3c1400ef667086d75e8ceb5c66e5e51c6778", + "size": 13261, + "subdir": "linux-64", + "timestamp": 1661852064094, + "version": "1.2.1" + }, + "python-lsp-black-1.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "black >=22.3.0", + "python >=3.9,<3.10.0a0", + "python-lsp-server >=1.4.0", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f84d26a43e7d6699b9611fc5a6cce887", + "name": "python-lsp-black", + "sha256": "4bc753baaf98e2e202357221a7e40def17ca56fd9a88a70bfd63cd7c296d3de8", + "size": 13272, + "subdir": "linux-64", + "timestamp": 1661852096891, + "version": "1.2.1" + }, + "python-lsp-server-1.5.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "autopep8 >=1.6.0,<1.7.0", + "flake8 >=4.0.0,<4.1.0", + "jedi >=0.17.2,<0.19.0", + "mccabe >=0.6.0,<0.8.0", + "pluggy >=1.0.0", + "pycodestyle >=2.8.0,<2.9.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.4.0,<2.5.0", + "pylint >=2.5.0", + "python >=3.10,<3.11.0a0", + "python-lsp-jsonrpc >=1.0.0", + "rope >=0.10.5", + "setuptools >=39.0.0", + "ujson >=3.0.0", + "whatthepatch", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f749ecadc0df45e40de04f9ede97ff7", + "name": "python-lsp-server", + "sha256": "78794ac39bb669e52f822b105c3d13cfa25fc77362b13680569847ca8fe3e305", + "size": 92056, + "subdir": "linux-64", + "timestamp": 1661813924993, + "version": "1.5.0" + }, + "python-lsp-server-1.5.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "autopep8 >=1.6.0,<1.7.0", + "flake8 >=4.0.0,<4.1.0", + "jedi >=0.17.2,<0.19.0", + "mccabe >=0.6.0,<0.8.0", + "pluggy >=1.0.0", + "pycodestyle >=2.8.0,<2.9.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.4.0,<2.5.0", + "pylint >=2.5.0", + "python >=3.11,<3.12.0a0", + "python-lsp-jsonrpc >=1.0.0", + "rope >=0.10.5", + "setuptools >=39.0.0", + "ujson >=3.0.0", + "whatthepatch", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd4e6adf448da2baf6d511d287d82c60", + "name": "python-lsp-server", + "sha256": "4a3b57e80bb76bfed8d678c4066cad96d9015e39af3a175006edcedb3726e327", + "size": 121089, + "subdir": "linux-64", + "timestamp": 1676842362907, + "version": "1.5.0" + }, + "python-lsp-server-1.5.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "autopep8 >=1.6.0,<1.7.0", + "flake8 >=4.0.0,<4.1.0", + "jedi >=0.17.2,<0.19.0", + "mccabe >=0.6.0,<0.8.0", + "pluggy >=1.0.0", + "pycodestyle >=2.8.0,<2.9.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.4.0,<2.5.0", + "pylint >=2.5.0", + "python >=3.7,<3.8.0a0", + "python-lsp-jsonrpc >=1.0.0", + "rope >=0.10.5", + "setuptools >=39.0.0", + "ujson >=3.0.0", + "whatthepatch", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4761e2ce6498a9dd1390108be51b63db", + "name": "python-lsp-server", + "sha256": "44c682f2c4108a6e29b5e9463f78c8851b3c6e97ceabe70c8aa5eeb9b55e546d", + "size": 90951, + "subdir": "linux-64", + "timestamp": 1661813881671, + "version": "1.5.0" + }, + "python-lsp-server-1.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "autopep8 >=1.6.0,<1.7.0", + "flake8 >=4.0.0,<4.1.0", + "jedi >=0.17.2,<0.19.0", + "mccabe >=0.6.0,<0.8.0", + "pluggy >=1.0.0", + "pycodestyle >=2.8.0,<2.9.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.4.0,<2.5.0", + "pylint >=2.5.0", + "python >=3.8,<3.9.0a0", + "python-lsp-jsonrpc >=1.0.0", + "rope >=0.10.5", + "setuptools >=39.0.0", + "ujson >=3.0.0", + "whatthepatch", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d443d63ca0f4ee4ce4fa5a4965a2fb1", + "name": "python-lsp-server", + "sha256": "52abfeb512971fe189e8b016c8c4d888e78b797544a1c9ee9c34a9b6b4d10246", + "size": 91245, + "subdir": "linux-64", + "timestamp": 1661813849412, + "version": "1.5.0" + }, + "python-lsp-server-1.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "autopep8 >=1.6.0,<1.7.0", + "flake8 >=4.0.0,<4.1.0", + "jedi >=0.17.2,<0.19.0", + "mccabe >=0.6.0,<0.8.0", + "pluggy >=1.0.0", + "pycodestyle >=2.8.0,<2.9.0", + "pydocstyle >=2.0.0", + "pyflakes >=2.4.0,<2.5.0", + "pylint >=2.5.0", + "python >=3.9,<3.10.0a0", + "python-lsp-jsonrpc >=1.0.0", + "rope >=0.10.5", + "setuptools >=39.0.0", + "ujson >=3.0.0", + "whatthepatch", + "yapf" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "70533f948d709ceb1ae6fdf5cd29ff5b", + "name": "python-lsp-server", + "sha256": "b7e3a543ece04359d7d749176651f2a6509ace32e6aa5fed46308eb1778ddc57", + "size": 91098, + "subdir": "linux-64", + "timestamp": 1661813957114, + "version": "1.5.0" + }, + "python-lsp-server-1.7.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "autopep8 >=1.6.0,<1.7.0", + "docstring-to-markdown", + "flake8 >=5.0.0,<7.0.0", + "jedi >=0.17.2,<0.19.0", + "mccabe >=0.7.0,<0.8.0", + "pluggy >=1.0.0", + "pycodestyle 2.10.0.*", + "pydocstyle >=6.3.0,<6.4.0", + "pyflakes >=2.5.0,<3.1.0", + "pylint >=2.5.0,<3.0.0", + "python >=3.10,<3.11.0a0", + "python-lsp-jsonrpc >=1.0.0", + "rope >=1.2.0", + "setuptools >=39.0.0", + "toml", + "ujson >=3.0.0", + "whatthepatch >=1.0.2,<2.0.0", + "yapf <=0.32.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a7e593a93d843ba5f06d78a65612c8fa", + "name": "python-lsp-server", + "sha256": "e3a0c7070f2331c473beff78d314c12d0ef4f67f971d1dfb91de2f3367aafa1d", + "size": 108363, + "subdir": "linux-64", + "timestamp": 1677296853634, + "version": "1.7.1" + }, + "python-lsp-server-1.7.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "autopep8 >=1.6.0,<1.7.0", + "docstring-to-markdown", + "flake8 >=5.0.0,<7.0.0", + "jedi >=0.17.2,<0.19.0", + "mccabe >=0.7.0,<0.8.0", + "pluggy >=1.0.0", + "pycodestyle 2.10.0.*", + "pydocstyle >=6.3.0,<6.4.0", + "pyflakes >=2.5.0,<3.1.0", + "pylint >=2.5.0,<3.0.0", + "python >=3.11,<3.12.0a0", + "python-lsp-jsonrpc >=1.0.0", + "rope >=1.2.0", + "setuptools >=39.0.0", + "toml", + "ujson >=3.0.0", + "whatthepatch >=1.0.2,<2.0.0", + "yapf <=0.32.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0b5cd8d2e1d741f69466e61a0cad601", + "name": "python-lsp-server", + "sha256": "c7baa001f2fd032096dc5b0017a42169c2940b9ea158b65dac0639dbe18bc6fd", + "size": 136764, + "subdir": "linux-64", + "timestamp": 1677706546359, + "version": "1.7.1" + }, + "python-lsp-server-1.7.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "autopep8 >=1.6.0,<1.7.0", + "docstring-to-markdown", + "flake8 >=5.0.0,<7.0.0", + "jedi >=0.17.2,<0.19.0", + "mccabe >=0.7.0,<0.8.0", + "pluggy >=1.0.0", + "pycodestyle 2.10.0.*", + "pydocstyle >=6.3.0,<6.4.0", + "pyflakes >=2.5.0,<3.1.0", + "pylint >=2.5.0,<3.0.0", + "python >=3.8,<3.9.0a0", + "python-lsp-jsonrpc >=1.0.0", + "rope >=1.2.0", + "setuptools >=39.0.0", + "toml", + "ujson >=3.0.0", + "whatthepatch >=1.0.2,<2.0.0", + "yapf <=0.32.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ff21791a9835e04bce556d8570cfa74", + "name": "python-lsp-server", + "sha256": "b444a15e57b04815fc0d30a9a90ccb01734a4434611415831c56e69930fdf4e6", + "size": 107066, + "subdir": "linux-64", + "timestamp": 1677296793266, + "version": "1.7.1" + }, + "python-lsp-server-1.7.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "autopep8 >=1.6.0,<1.7.0", + "docstring-to-markdown", + "flake8 >=5.0.0,<7.0.0", + "jedi >=0.17.2,<0.19.0", + "mccabe >=0.7.0,<0.8.0", + "pluggy >=1.0.0", + "pycodestyle 2.10.0.*", + "pydocstyle >=6.3.0,<6.4.0", + "pyflakes >=2.5.0,<3.1.0", + "pylint >=2.5.0,<3.0.0", + "python >=3.9,<3.10.0a0", + "python-lsp-jsonrpc >=1.0.0", + "rope >=1.2.0", + "setuptools >=39.0.0", + "toml", + "ujson >=3.0.0", + "whatthepatch >=1.0.2,<2.0.0", + "yapf <=0.32.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33d16454630110a29ab0a7f42d667c38", + "name": "python-lsp-server", + "sha256": "43607e023aef6da747dd16edb2c6f7aa91d67840250cd3e9cacb3c0b97485e86", + "size": 107580, + "subdir": "linux-64", + "timestamp": 1677296823871, + "version": "1.7.1" + }, + "python-memcached-1.59-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "a6360b3abfaef734090d22431ad86db8", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "3fcbe4f5f8bcdbad126d7b382d55af615f1ee8b78dae96fe331ab9f98ddd6c78", + "size": 33865, + "subdir": "linux-64", + "timestamp": 1519492008298, + "version": "1.59" + }, + "python-memcached-1.59-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "f9335976887ea1239f0f123a97144a82", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "77238d770284f2a7baf3bd92976f506758dd66c19ccf617f35c07d90e0a2d3af", + "size": 40589, + "subdir": "linux-64", + "timestamp": 1640793909123, + "version": "1.59" + }, + "python-memcached-1.59-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "3afea0c4bdeddc9c28d3e673940b3fb5", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "4427343268ae843483a2b270b1206ca3c5bb0205b721127bbf32662949c04336", + "size": 47939, + "subdir": "linux-64", + "timestamp": 1676861567375, + "version": "1.59" + }, + "python-memcached-1.59-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "3edfa8a01b51422f126fb1b382711d1d", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "82520d480beda63d18dcb772152923ef83d6130f6a4005d1823c57d295ce1647", + "size": 34282, + "subdir": "linux-64", + "timestamp": 1519491984600, + "version": "1.59" + }, + "python-memcached-1.59-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "feb9fc8e252e56f8c07eeb1f4598d0c4", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "d262d1f9f6d899057dddafb0d65512da09d458788727ec1b06e7a45ca9c8e708", + "size": 34076, + "subdir": "linux-64", + "timestamp": 1519492017996, + "version": "1.59" + }, + "python-memcached-1.59-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "d615a4dfe2d4261a73aeadb88bdf4467", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "352aaae1c8711ff38d719989312d08c1ad372108fdeb0e2d0548ce27fe179217", + "size": 41485, + "subdir": "linux-64", + "timestamp": 1614172820502, + "version": "1.59" + }, + "python-memcached-1.59-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "718953001c0c8fc4462b5afb84b3638e", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "fb73abecf6689843e1f439137e0d5385b3bfcb1ac011900bcb980ef656186fb4", + "size": 34084, + "subdir": "linux-64", + "timestamp": 1530922844348, + "version": "1.59" + }, + "python-memcached-1.59-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "71ecfa17629c36dc55c352de3fd5d34f", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "514a076873441499a2f88548174ae177b5285ce3e2a439afab97141e2baf82bc", + "size": 41639, + "subdir": "linux-64", + "timestamp": 1614172806987, + "version": "1.59" + }, + "python-memcached-1.59-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "7143c70f05c6fe92b64906fdf2654222", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "d0b80ca63639c23d9b301853ca47a21301d7495d51ab3d19306089e557012811", + "size": 40799, + "subdir": "linux-64", + "timestamp": 1574094372838, + "version": "1.59" + }, + "python-memcached-1.59-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "994689ee4d22f27a89f7f3fee4adc954", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "fa01907df4dd67c693969a89b084b2f6494269dc490587965447c66601dff668", + "size": 41864, + "subdir": "linux-64", + "timestamp": 1614172820124, + "version": "1.59" + }, + "python-memcached-1.59-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six >=1.4.0" + ], + "license": "PSF 2.0", + "license_family": "PSF", + "md5": "01760925700e69ca9f5f0f13a258ed0a", + "name": "python-memcached", + "namespace_in_name": true, + "sha256": "86567a1afac67a3ab03e62b86e647d9f0773bdbfcfef569be04dcaac63d60ff8", + "size": 41749, + "subdir": "linux-64", + "timestamp": 1614172811184, + "version": "1.59" + }, + "python-ntlm-1.1.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL", + "md5": "fc83c01e3a8aa6ab48d401930fef1784", + "name": "python-ntlm", + "namespace_in_name": true, + "sha256": "671f730feb5a6465c26cf68ed3f7ed37a5f6013e6dbce0f42c8ae50e72f5d992", + "size": 39967, + "subdir": "linux-64", + "timestamp": 1540317059729, + "version": "1.1.0" + }, + "python-oauth2-1.1.0-py27h28b3542_1.conda": { + "build": "py27h28b3542_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f09fdf9420a8f6732ffc958859d94c20", + "name": "python-oauth2", + "sha256": "4f05e7309b70ec0773265790e22a26dbd3c35b0ddb0e68f0f3c72d7c87ffb788", + "size": 93450, + "subdir": "linux-64", + "timestamp": 1540510693698, + "version": "1.1.0" + }, + "python-oauth2-1.1.0-py36h28b3542_1.conda": { + "build": "py36h28b3542_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95cf710456cd736f02cec9f72d0eb07b", + "name": "python-oauth2", + "sha256": "89be0421da46b67801abd379923d32a6f751a7b4bfffad6a06e427bd15c16fcd", + "size": 93143, + "subdir": "linux-64", + "timestamp": 1540510753021, + "version": "1.1.0" + }, + "python-oauth2-1.1.0-py37h28b3542_1.conda": { + "build": "py37h28b3542_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d006a98b6e4ae484f72d8ab640b1011", + "name": "python-oauth2", + "sha256": "8250d20359221863120fa6ca2b1655e29ec3dcbd8e4c5dfffeabedee378d0592", + "size": 92993, + "subdir": "linux-64", + "timestamp": 1540510700792, + "version": "1.1.0" + }, + "python-openid-2.2.5-py27_1000.conda": { + "build": "py27_1000", + "build_number": 1000, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8b9da8b31f03d70cac92303570c2749a", + "name": "python-openid", + "sha256": "d1a7d01ce995528d1f2c63e2fc185360a43837cc68606e18c2034f62a6465d0c", + "size": 179954, + "subdir": "linux-64", + "timestamp": 1579614954702, + "version": "2.2.5" + }, + "python-rapidjson-0.4.3-py35h6bb024c_0.conda": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ba1f8e1d19cb99995b582634a6750f4", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "dfad98ec524f0ee39d7fd892cf87badc2b053836ec8aa9e7697fdd005226c0a4", + "size": 131747, + "subdir": "linux-64", + "timestamp": 1519470350026, + "version": "0.4.3" + }, + "python-rapidjson-0.4.3-py36h6bb024c_0.conda": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff0cece8bfa473b8966e51824a2e24cc", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "d4c1ee43ce080f57748f8a0c5f0a1658818a39e0162926f2ced29b1859f80bdc", + "size": 132717, + "subdir": "linux-64", + "timestamp": 1519470335326, + "version": "0.4.3" + }, + "python-rapidjson-0.5.2-py35h6bb024c_0.conda": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "55865b019f7b6668aadf15a5a784e154", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "bd623b4170799fd29cb80d93356e7271d342a256f74ed2e20c757901b5099686", + "size": 133588, + "subdir": "linux-64", + "timestamp": 1522790911850, + "version": "0.5.2" + }, + "python-rapidjson-0.5.2-py36h6bb024c_0.conda": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "241faccbc6cfe7b511e22b7cf44b34e4", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "fad03fd639a28f5a39eafb9dfb2135ec350b9e8ae0821c76df64d4bbb8679f5d", + "size": 133845, + "subdir": "linux-64", + "timestamp": 1522790356705, + "version": "0.5.2" + }, + "python-rapidjson-0.6.2-py35h6bb024c_0.conda": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2891beec5965835ea5576fba59fd5f9", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "76db02efe6ba28bfd313a125bfddf0154563e5c0f90fadfe131d0f5cc6b23ac5", + "size": 132882, + "subdir": "linux-64", + "timestamp": 1529446008729, + "version": "0.6.2" + }, + "python-rapidjson-0.6.2-py36h6bb024c_0.conda": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "40e76296dde8f4292608a812268c21c2", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "9982f2455581ad0000da41a060bf9459c049b1bb83dadaa5542d3137cf0c03b0", + "size": 131201, + "subdir": "linux-64", + "timestamp": 1529445970778, + "version": "0.6.2" + }, + "python-rapidjson-0.6.2-py37h6bb024c_0.conda": { + "build": "py37h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ffe7c7488af0c8308bf6c4614c49971d", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "28bfaac35521da22a180ff75f3291ef392a795d6f509d52c841e59511d1022a9", + "size": 132010, + "subdir": "linux-64", + "timestamp": 1530922901611, + "version": "0.6.2" + }, + "python-rapidjson-0.6.3-py35he6710b0_0.conda": { + "build": "py35he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eaa45ae6024f06b7d73017ed9b7a4608", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "6db736ca850e7b98014bfd6584d0f3e57e202a01a99f393403297b8b6ce0b625", + "size": 154118, + "subdir": "linux-64", + "timestamp": 1535511515075, + "version": "0.6.3" + }, + "python-rapidjson-0.6.3-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02fdfcb6089de402d9382bdff8279dfb", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "1abe94bca02413f7ead70a33205ba5a58d7bfc0f54b414627db60e0bf118b27f", + "size": 152653, + "subdir": "linux-64", + "timestamp": 1535511482958, + "version": "0.6.3" + }, + "python-rapidjson-0.6.3-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18a97553a0d0af81b798969024e98a0d", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "17a853eba4a3f344366221af993ee4c9cf18cf620eaab530bdf248047992b4ff", + "size": 152667, + "subdir": "linux-64", + "timestamp": 1535511587661, + "version": "0.6.3" + }, + "python-rapidjson-0.6.3-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b3503273c6a4ec2c0dc6d63e7ae13f7d", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "a36084378869974542462058a3961e54a262fcc35bef280292a8574c19b8dde4", + "size": 161870, + "subdir": "linux-64", + "timestamp": 1573200597231, + "version": "0.6.3" + }, + "python-rapidjson-0.9.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b562107d7c27890643af39913cf35675", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "46c5a430d6e8f71b31cd4fb2d17e534565fb9af072c3fe903cdb346766442428", + "size": 155058, + "subdir": "linux-64", + "timestamp": 1600460017636, + "version": "0.9.1" + }, + "python-rapidjson-0.9.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "156d688d49f15a99f4fa66d1e23f4bea", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "3f19371358781e9455a55eb8b5cc16aa420676c2812f7f9fd8f1f0233644d715", + "size": 155034, + "subdir": "linux-64", + "timestamp": 1600460000785, + "version": "0.9.1" + }, + "python-rapidjson-0.9.1-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "57641e165e5b084d2abc9336139467a1", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "193db0491437defdcd110ab2ed8ce2f72be9c898a58e085e9c0279862d502e21", + "size": 155362, + "subdir": "linux-64", + "timestamp": 1600460009469, + "version": "0.9.1" + }, + "python-rapidjson-0.9.4-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "25d07a23bc2bb40f7afad1d83b93355a", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "b0c93c604531915a6378bf820da35dfb232683400eb077dd1a639f7c2ee3ccf5", + "size": 154797, + "subdir": "linux-64", + "timestamp": 1606518291523, + "version": "0.9.4" + }, + "python-rapidjson-0.9.4-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "30073b4a4c38eac726d82990f33777c7", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "d7ba8ca5aed7c83f20d5de589ad5a6317f3e17f64b18c99f0a1d53399b68c79a", + "size": 154775, + "subdir": "linux-64", + "timestamp": 1606518282119, + "version": "0.9.4" + }, + "python-rapidjson-0.9.4-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "acee2f8bead4b739c83cf1260cd936aa", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "1bd44c83f297cdb17145dccae6aab5edb1e7218445a20fc9d1c75cf70c8c124a", + "size": 156889, + "subdir": "linux-64", + "timestamp": 1606518331986, + "version": "0.9.4" + }, + "python-rapidjson-0.9.4-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1793d7b07e0993e87e00bcf41904064f", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "0c40a8a68cf092aac291094d45318d535a1768a4d82a41fd221fcb3a69da2e07", + "size": 155238, + "subdir": "linux-64", + "timestamp": 1606518334832, + "version": "0.9.4" + }, + "python-rapidjson-1.0-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "271afdc3521110ba211c74cb4bb73bb7", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "1d1adbc8fbd259c66dfc7d6c2e98b06909cf9ce9230ad0a0302733b471ec77be", + "size": 159883, + "subdir": "linux-64", + "timestamp": 1607972583600, + "version": "1.0" + }, + "python-rapidjson-1.0-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e18b8cf2309339e91cf250b28dbee248", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "4bbb758695e30683064bcc8daff884ea0407c5b30ed31d5a25f2b7c9fc099dc8", + "size": 159602, + "subdir": "linux-64", + "timestamp": 1607972614192, + "version": "1.0" + }, + "python-rapidjson-1.0-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4b4c19924b717774461a0f50d14c64d0", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "2f7a761c237bbcc3493c1f79f284261da4e9e431566385051bccc99d69639637", + "size": 159348, + "subdir": "linux-64", + "timestamp": 1607972176217, + "version": "1.0" + }, + "python-rapidjson-1.0-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f3982abf1b079acaafadf7803dcbf2f", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "c0da845a6ca15ad920e5d72019f2cd2244b24035dd3e3d7870109626db861817", + "size": 156979, + "subdir": "linux-64", + "timestamp": 1607972609915, + "version": "1.0" + }, + "python-rapidjson-1.4-py36h295c915_0.conda": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca0ad724c2da1d353e8ba1ad4ff95daa", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "fa23e0916b0f07f64f7bde2ceb76e4a30c6f633ac4994ae8b514d1f5cc5553f6", + "size": 159318, + "subdir": "linux-64", + "timestamp": 1626241375304, + "version": "1.4" + }, + "python-rapidjson-1.4-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3e73bab17d9e56ad762cfcd41bb355f", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "02aacec440ad1eab8456fb3febd172185020cec5e46d2bffefefc38c1b9bd9e0", + "size": 159519, + "subdir": "linux-64", + "timestamp": 1626284223383, + "version": "1.4" + }, + "python-rapidjson-1.4-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4699b952862b6070418873c075b7242f", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "75c6ba4ff8c9f435f435c56748223db2606181928d3f7d2e0ffd65487d663d15", + "size": 158055, + "subdir": "linux-64", + "timestamp": 1626291205489, + "version": "1.4" + }, + "python-rapidjson-1.4-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "70dc8171c1406f014ca3b215b7ea78e1", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "c10172519dae97a844a2d2634159db0b9372f54524ecec21060c51f87f1d052a", + "size": 157343, + "subdir": "linux-64", + "timestamp": 1626291332326, + "version": "1.4" + }, + "python-rapidjson-1.5-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7148cb995811dbf2bb23b564c21995aa", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "f784782c987dc8ce1e5e3820971ed64d8f5c06e3231dcfd3dde9d52c1b21a597", + "size": 830306, + "subdir": "linux-64", + "timestamp": 1640793946792, + "version": "1.5" + }, + "python-rapidjson-1.5-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ecd71c88b175ba5f84464e346955182", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "b03d0b45d6e42a7ec860d3db97bfbdd1b8701d13a5cbda8e8bafde8d01a2d41d", + "size": 165372, + "subdir": "linux-64", + "timestamp": 1676861598862, + "version": "1.5" + }, + "python-rapidjson-1.5-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af3cca0d08ce7d064ef0eb34d8ca0e18", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "78a3e03ebca8b9c8872294dea1eede09d4c1b486075ea4fe0d36b5e55e348c3e", + "size": 158569, + "subdir": "linux-64", + "timestamp": 1639132380745, + "version": "1.5" + }, + "python-rapidjson-1.5-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "25ad7b1115e51ff6f0320d5e69a1bc8a", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "1fa80f316050e2536a6865b295212ead15e6c64e5319f5ee289e3bb7ce377510", + "size": 159855, + "subdir": "linux-64", + "timestamp": 1639132384476, + "version": "1.5" + }, + "python-rapidjson-1.5-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aee425c38e9a8610e2cdd2527a6ce9f6", + "name": "python-rapidjson", + "namespace_in_name": true, + "sha256": "244ce11e01dea5e90d7d7d79c6928f86f8912a6cc3542c1a57a6ebc0f6868213", + "size": 157593, + "subdir": "linux-64", + "timestamp": 1639132383679, + "version": "1.5" + }, + "python-regr-testsuite-3.9.1-h06a4308_2.conda": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [], + "license": "Python-2.0", + "md5": "b446a1a14fe4509030a8b386f451940e", + "name": "python-regr-testsuite", + "sha256": "d5810e07e03602c863f1b77023699e41914d0d4b19e55d714b8b133c30b35e1a", + "size": 6431994, + "subdir": "linux-64", + "timestamp": 1607697801769, + "version": "3.9.1" + }, + "python-regr-testsuite-3.9.11-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "f03b39b5e721c6268d0fd27c5f5330f4", + "name": "python-regr-testsuite", + "sha256": "6f42d13aae71198f81a2cd0959e52694c314733cb6b83d37b3197bf72f5f1494", + "size": 6499109, + "subdir": "linux-64", + "timestamp": 1648462921511, + "version": "3.9.11" + }, + "python-regr-testsuite-3.9.11-h06a4308_2.conda": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "e124cf93ee2e2582508fcf770d8310ec", + "name": "python-regr-testsuite", + "sha256": "24c7dc18560d656721e2bb5bf1fab5a95bf1b1884a4b88738bbe23362e397612", + "size": 6493679, + "subdir": "linux-64", + "timestamp": 1648581594295, + "version": "3.9.11" + }, + "python-regr-testsuite-3.9.12-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "91e57aed3d1a79aaae00ff91d768ecaf", + "name": "python-regr-testsuite", + "sha256": "d3ea82cb95211b1fa743b2e3aced92080e41973c6e2b3ab73e022449eea930b0", + "size": 6456745, + "subdir": "linux-64", + "timestamp": 1649142504571, + "version": "3.9.12" + }, + "python-regr-testsuite-3.9.12-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "44f6be72497be2644ec14f74f7f4436e", + "name": "python-regr-testsuite", + "sha256": "6db855f7f7fe2d5481847780deea83778a80d1a8bbeb1655fcaefa5ce6e45670", + "size": 6460406, + "subdir": "linux-64", + "timestamp": 1654084228189, + "version": "3.9.12" + }, + "python-regr-testsuite-3.9.13-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "b6ca65621101fd086cf2e8eb1d3f74dc", + "name": "python-regr-testsuite", + "sha256": "efd12e2265195720e302d101234a76fa2d7a6fa77783c9344156974198ca6458", + "size": 6513452, + "subdir": "linux-64", + "timestamp": 1661470728854, + "version": "3.9.13" + }, + "python-regr-testsuite-3.9.13-h06a4308_2.conda": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "c04e1a5c81197e22e743f0c4f752a1ed", + "name": "python-regr-testsuite", + "sha256": "01342fa7a0404d56d9cb0603f2ddb8bbbdba067cd70fc6092b7c3b0198d70d03", + "size": 6512013, + "subdir": "linux-64", + "timestamp": 1665696414530, + "version": "3.9.13" + }, + "python-regr-testsuite-3.9.15-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "6b9d428d4a4f9903a55d63d71a04fb0e", + "name": "python-regr-testsuite", + "sha256": "e539aea69c6fab4d08db94de9167ab8f21c16441e3ad0a19f2d02cdc1ebac1f7", + "size": 7510766, + "subdir": "linux-64", + "timestamp": 1667579149388, + "version": "3.9.15" + }, + "python-regr-testsuite-3.9.15-h06a4308_2.conda": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "7c30fa454660e63173a4e4ef5a2e90d7", + "name": "python-regr-testsuite", + "sha256": "926edaf8caccb1d67a0eb50efe815de7e85e1bbb1518b36c610f004288ea913f", + "size": 7507839, + "subdir": "linux-64", + "timestamp": 1669301010492, + "version": "3.9.15" + }, + "python-regr-testsuite-3.9.16-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "ec6fabd815cf623f80ad49c70eaa1fe2", + "name": "python-regr-testsuite", + "sha256": "bc48f360be3404bb0b70dc2bcdebbcaf5f67d0c167a7a710a827ec8aaf8609c2", + "size": 7530073, + "subdir": "linux-64", + "timestamp": 1673453882123, + "version": "3.9.16" + }, + "python-regr-testsuite-3.9.16-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "09ed2c91a0a66ba7980403b0c5a01188", + "name": "python-regr-testsuite", + "sha256": "6e8cf03e001065a39720f844b4c6f2a30235f605b3e2b6537ae7f8fd1f244e9c", + "size": 7527173, + "subdir": "linux-64", + "timestamp": 1677695652272, + "version": "3.9.16" + }, + "python-regr-testsuite-3.9.16-h06a4308_2.conda": { + "build": "h06a4308_2", + "build_number": 2, + "depends": [], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "2cbd98be8e8e78c75b87c67e3470007f", + "name": "python-regr-testsuite", + "sha256": "d2f05698dbf52df463828738c1ec1fcd339ee2189bb5f12930a4a5e0f2a76c06", + "size": 7539546, + "subdir": "linux-64", + "timestamp": 1678284700225, + "version": "3.9.16" + }, + "python-regr-testsuite-3.9.2-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "Python-2.0", + "md5": "14acdf3e15fc7e382a99a1e812462c95", + "name": "python-regr-testsuite", + "sha256": "b4f985d3268f46ccd5fb41ac1a97a5e5d4b98268e1abb36dfafa1df72d8b4590", + "size": 6463956, + "subdir": "linux-64", + "timestamp": 1614802551636, + "version": "3.9.2" + }, + "python-regr-testsuite-3.9.4-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "Python-2.0", + "md5": "f30f43e0177ad6bfca5651c4fd9d9e6f", + "name": "python-regr-testsuite", + "sha256": "82a83aa8152bfe4721b9195323fa6015c08b5d811b1b2e8565a0ef6d4eef4281", + "size": 6478656, + "subdir": "linux-64", + "timestamp": 1617986855753, + "version": "3.9.4" + }, + "python-regr-testsuite-3.9.5-h06a4308_3.conda": { + "build": "h06a4308_3", + "build_number": 3, + "depends": [], + "license": "Python-2.0", + "md5": "6efcdb425308f2b1dcb786e3f0b1dd06", + "name": "python-regr-testsuite", + "sha256": "53284890d10e673bdbc8218c163415c5b0020ffe8e65ae5554f1812343ee40eb", + "size": 6434176, + "subdir": "linux-64", + "timestamp": 1621367274458, + "version": "3.9.5" + }, + "python-regr-testsuite-3.9.5-h06a4308_4.conda": { + "build": "h06a4308_4", + "build_number": 4, + "depends": [], + "license": "Python-2.0", + "md5": "1e4344cd9cd4cfec76256c5b01b32c23", + "name": "python-regr-testsuite", + "sha256": "ae42f48e3cd674d5b9e7a6fadc1bd8a617832281ade3ea9e9dd4ec3a1cff9adb", + "size": 6450938, + "subdir": "linux-64", + "timestamp": 1622828276396, + "version": "3.9.5" + }, + "python-regr-testsuite-3.9.6-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "Python-2.0", + "md5": "dbd30069f2e71f0052dffb881f628dd3", + "name": "python-regr-testsuite", + "sha256": "3933640c4bd80ca0528fe181daa16991cf8391ef46aaa59d9149a29642765798", + "size": 6440397, + "subdir": "linux-64", + "timestamp": 1627663696372, + "version": "3.9.6" + }, + "python-regr-testsuite-3.9.6-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "Python-2.0", + "md5": "96c07eb2a328845f62dd0e0725b8aa17", + "name": "python-regr-testsuite", + "sha256": "1574cdabdabd28fc4736380370d9978ebb9c39d37df0aab61b6af37e1b5b1ea4", + "size": 6443778, + "subdir": "linux-64", + "timestamp": 1629316191355, + "version": "3.9.6" + }, + "python-regr-testsuite-3.9.7-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "Python-2.0", + "md5": "2d49c90e441c910c5cda6b2b7128fd11", + "name": "python-regr-testsuite", + "sha256": "9d7cacd3bd773e1dfb9f681b645cebbcdbbcca1d4ef42ca7d977dcc87763c6cd", + "size": 6507676, + "subdir": "linux-64", + "timestamp": 1631798589983, + "version": "3.9.7" + }, + "python-slugify-1.2.4-py27h51716b4_1.conda": { + "build": "py27h51716b4_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cf283d772f94fb89530a87e521230a98", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "749f75e96be1fd844109cb99457f5dbcb15c7bc40252c71744c8d7bfd28d3785", + "size": 9668, + "subdir": "linux-64", + "timestamp": 1508622624184, + "version": "1.2.4" + }, + "python-slugify-1.2.4-py35hcb49adb_1.conda": { + "build": "py35hcb49adb_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8e911e30ef022db1267caef77775651", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "345b64ae67a6ae720fe016ca079afc1a611fdf34e8009443ade8f3402d84b4d9", + "size": 9871, + "subdir": "linux-64", + "timestamp": 1508622636926, + "version": "1.2.4" + }, + "python-slugify-1.2.4-py36hc9c72ca_1.conda": { + "build": "py36hc9c72ca_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3279d9c475a9570436ac4c4931ddef8", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "9f26550a26584b537fc545751ba22c81df92ba296f7ff268a34033478ae038a2", + "size": 9736, + "subdir": "linux-64", + "timestamp": 1508622643571, + "version": "1.2.4" + }, + "python-slugify-1.2.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd07746919b5d81d1c94f95fbdb79b90", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "f350fb6ecce4774b379e7de24f311d87200271b51c00fafeb32b74297a1101af", + "size": 9653, + "subdir": "linux-64", + "timestamp": 1522084408325, + "version": "1.2.5" + }, + "python-slugify-1.2.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec051106228511a155e59b24586134ae", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "2678352c93ccdebc878c130f0172e9fb5191016c332e4dbac96fa0b1c4d4ae1e", + "size": 9857, + "subdir": "linux-64", + "timestamp": 1522084459601, + "version": "1.2.5" + }, + "python-slugify-1.2.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea4aa93c53db116f7b2a5d0b06ed10b7", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "1f8b479172ce25d5e0f400152b3905b2be60a21c57526298c3a3c3d80a106212", + "size": 9793, + "subdir": "linux-64", + "timestamp": 1522084321742, + "version": "1.2.5" + }, + "python-slugify-1.2.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9845609d02aaf52e424bdecff6fcbf9", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "4d4e671f26b50c3fb642f0c39e20cfbd9ee5af35b9d381420602358f57ef93d7", + "size": 9569, + "subdir": "linux-64", + "timestamp": 1530735609690, + "version": "1.2.5" + }, + "python-slugify-1.2.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "acd6d4960f445ce63cd6eac2f68ec128", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "461c0496e88719190c387d3108baf50d60b290adae79707c1dc11afced1cf4b3", + "size": 10252, + "subdir": "linux-64", + "timestamp": 1536264300956, + "version": "1.2.6" + }, + "python-slugify-1.2.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7d3727951b59f61170c4d68e4281f7ef", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "c611b0d0a23be279f241af353b406c39e29f3fe129419e57bae67f2c69682781", + "size": 10434, + "subdir": "linux-64", + "timestamp": 1536264301132, + "version": "1.2.6" + }, + "python-slugify-1.2.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3dba536d9cecbff31863ae0af5eca3f6", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "e13dbca646e02ef6771e9eadf94c34c19837d57b35160f97e87e3a9f40f439a1", + "size": 10312, + "subdir": "linux-64", + "timestamp": 1536264270140, + "version": "1.2.6" + }, + "python-slugify-1.2.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6dfa901979c42df1a3246a0a708b51f", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "69111dba5bed1c202210dbe0e294a464f0ca9ace1312cd8be31c34b38b9af770", + "size": 10370, + "subdir": "linux-64", + "timestamp": 1536264339163, + "version": "1.2.6" + }, + "python-slugify-2.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66ec174758afd707793c5229b521dda1", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "12b86023d89069aa9ddad910bbb4ed1ec78fcf0d082646c4cc0b71dc9c1531e5", + "size": 13465, + "subdir": "linux-64", + "timestamp": 1547487015759, + "version": "2.0.1" + }, + "python-slugify-2.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aebb40fb2d212a7635666de7b08ca8bc", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "0c08e45d0ce6d59009ea3f087e29d7da2d493f25ec1beb2cb86b21732999b279", + "size": 13576, + "subdir": "linux-64", + "timestamp": 1547487039979, + "version": "2.0.1" + }, + "python-slugify-2.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "unidecode >=0.04.16" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9bffa853617b3ad9637639ebcd273e3c", + "name": "python-slugify", + "namespace_in_name": true, + "sha256": "4f636d736134d189af42d6fdcbf25b8955b6b5c8a5f2ca610f7a673ce64abe26", + "size": 13662, + "subdir": "linux-64", + "timestamp": 1547487037877, + "version": "2.0.1" + }, + "python-snappy-0.5.2-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0524c110e51104daf579da8f146f8fe6", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "55f95f5f669fa019002e6f7145cde8e8961fb9c6fd57c1b0b5deb0987676c51c", + "size": 27634, + "subdir": "linux-64", + "timestamp": 1522882012151, + "version": "0.5.2" + }, + "python-snappy-0.5.2-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ea5c3851fca5062eec5e8d57b730648", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "53409aac283b55f2095862e4d0e3593222bfb421af526d855da595744f19252d", + "size": 28068, + "subdir": "linux-64", + "timestamp": 1522882123697, + "version": "0.5.2" + }, + "python-snappy-0.5.2-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ab144658d4a7bd25c061459d1b60b156", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "7d0ff8320a8fbd057c95d229957a024b1099cf0865836b77ec263de0601d6724", + "size": 27886, + "subdir": "linux-64", + "timestamp": 1522882123337, + "version": "0.5.2" + }, + "python-snappy-0.5.2-py37hf484d3e_0.conda": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3785044648433004e37413e8436d2a7d", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "b8452daa8227cc757493ef3112fe6b22bb69a8929f0ab91de84c83a46ce50d9e", + "size": 27819, + "subdir": "linux-64", + "timestamp": 1530922939354, + "version": "0.5.2" + }, + "python-snappy-0.5.3-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3c9384857ad07324d619ef3e901540ab", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "f32dc9b8d3671651ffafaff11c78a06da18d9b507ccce36cdaee9cde2688c1bd", + "size": 28199, + "subdir": "linux-64", + "timestamp": 1535508140854, + "version": "0.5.3" + }, + "python-snappy-0.5.3-py35he6710b0_0.conda": { + "build": "py35he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "046f7d49cf546a3eda6b9d29b4748000", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "c0738e7c2f9d59819f22a0fcda9f008bbab5ae11f270e060f3e405d9970cf428", + "size": 28541, + "subdir": "linux-64", + "timestamp": 1535508168582, + "version": "0.5.3" + }, + "python-snappy-0.5.3-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f7eaf6d46359f8097bc4ed718cf942de", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "efb8311a8a162c5988ce558c78e657e42c0fc7c6549d7cf9befd09c4c932cb8d", + "size": 28380, + "subdir": "linux-64", + "timestamp": 1535508135728, + "version": "0.5.3" + }, + "python-snappy-0.5.3-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c60783c725fc32e4afde14b8017c7eb7", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "749cf48f99acb3832712b742bf0026e6da115849a269ef69b9c2591f54f73f14", + "size": 28398, + "subdir": "linux-64", + "timestamp": 1535508162045, + "version": "0.5.3" + }, + "python-snappy-0.5.4-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1729f4154bcb98517fe99aca9e7634ba", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "e9dd66cc20a15dadd31edb4c96f20d818ff55819158d81b96fd004a7e87ad01f", + "size": 31503, + "subdir": "linux-64", + "timestamp": 1556117556068, + "version": "0.5.4" + }, + "python-snappy-0.5.4-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3e5e587e893e865cdf493d359208014d", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "933f4b0735c891db5fcfe87297f7235e25c8d16fb8bdf4ed9b3b62be6ed0420a", + "size": 31743, + "subdir": "linux-64", + "timestamp": 1556117600039, + "version": "0.5.4" + }, + "python-snappy-0.5.4-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "898152ebf7b45de2f009e496d4daaf49", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "a7bb2cb899971bc38ddf20064a6c5b16a5ccacaf3e78f903a6b8c9cf70057b06", + "size": 31784, + "subdir": "linux-64", + "timestamp": 1556117551549, + "version": "0.5.4" + }, + "python-snappy-0.5.4-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.7,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "259edba133b129e69bb9858d06211966", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "4579019666a7e00f8608d307a1a8a7c55b833b8fcf070432a496a31b1e85bdea", + "size": 35039, + "subdir": "linux-64", + "timestamp": 1573200621110, + "version": "0.5.4" + }, + "python-snappy-0.6.0-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b3af20f366047bde7ade2a81ca3d490b", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "bb643cf401b5f50570b753516a3068578326146cb037dbbdcda9f924386e2bd1", + "size": 47293, + "subdir": "linux-64", + "timestamp": 1640793972833, + "version": "0.6.0" + }, + "python-snappy-0.6.0-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a3e6f3f52c1005ed4af44d7c087ce782", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "44dd3af8c3f51e8099f27459fe5103ea671afe7e802f9a4fbc2d77ef6168afb8", + "size": 29819, + "subdir": "linux-64", + "timestamp": 1610134379524, + "version": "0.6.0" + }, + "python-snappy-0.6.0-py36h2531618_3.conda": { + "build": "py36h2531618_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "62cc647374a81a8a2f38c20dfcd7a646", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "df31846a71957226587e3aa1024cffce095615c354f3225f4b55820be6bdbef9", + "size": 30078, + "subdir": "linux-64", + "timestamp": 1610133406468, + "version": "0.6.0" + }, + "python-snappy-0.6.0-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "661cbc3059f5a8ac40accc67a6a4c51e", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "0ceec095ee866b90ccc93bfa8127a389c66cbcfdef732578b52aaec45902aacb", + "size": 30048, + "subdir": "linux-64", + "timestamp": 1610134378270, + "version": "0.6.0" + }, + "python-snappy-0.6.0-py37h2531618_3.conda": { + "build": "py37h2531618_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "855d942984539862e70b419389b281da", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "320eb0bb024bdf80a94a55e3ceaa249f1536221d34356b2706e76993b3d830a0", + "size": 30096, + "subdir": "linux-64", + "timestamp": 1610133399147, + "version": "0.6.0" + }, + "python-snappy-0.6.0-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "25aebc3535e10373d6e7d12af3d3c0d9", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "8191181edc2cc81135bb73067abefee4c7c71b1eaa64bb12648d9bd0c054471e", + "size": 29862, + "subdir": "linux-64", + "timestamp": 1610134394930, + "version": "0.6.0" + }, + "python-snappy-0.6.0-py38h2531618_3.conda": { + "build": "py38h2531618_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "069fd320eb9f6c56ff426fce5d9ce842", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "2f4aa73afe33b59fe597225cb28fd382086f7a799f99cf212ec48e08711ff3bb", + "size": 29893, + "subdir": "linux-64", + "timestamp": 1610133362748, + "version": "0.6.0" + }, + "python-snappy-0.6.0-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "734a2e9603f0936c6495494229e0c94c", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "0c5f859389e141193a1e2f40e4e7945c38ac41d57c564d990f874fc9e56d3ae6", + "size": 29981, + "subdir": "linux-64", + "timestamp": 1610134359111, + "version": "0.6.0" + }, + "python-snappy-0.6.0-py39h2531618_3.conda": { + "build": "py39h2531618_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.8,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f201e84a76036d9a5fb94f81957e5dda", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "2470570838c06442ebb704f819f6741b6f3ae7014ccbbc5194fe18adae420a49", + "size": 29867, + "subdir": "linux-64", + "timestamp": 1610133082486, + "version": "0.6.0" + }, + "python-snappy-0.6.1-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "snappy >=1.1.9,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "05d5f448fe2ee189d9ae1482a548bf32", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "12ad0d5f59cf77e9df5fd8652439a598bb86f38f72b774049c2846619cc66dac", + "size": 31759, + "subdir": "linux-64", + "timestamp": 1670944042197, + "version": "0.6.1" + }, + "python-snappy-0.6.1-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "snappy >=1.1.9,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38f51cd56c6faabaed0a5a8f12e06c16", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "5c19b8bf7930ac615845cf77dce840fe98b1b394d4204148059d79dea8c1e62c", + "size": 33947, + "subdir": "linux-64", + "timestamp": 1676842382142, + "version": "0.6.1" + }, + "python-snappy-0.6.1-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "snappy >=1.1.9,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee5754fc9807dcfe15f018cee36eccc1", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "db3903be48b1d1c2537628a34e24ce29343db9efe9ba90f2d27ca9f1ed22ee03", + "size": 31602, + "subdir": "linux-64", + "timestamp": 1670944012549, + "version": "0.6.1" + }, + "python-snappy-0.6.1-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "snappy >=1.1.9,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1dd48342856a89ebd781dde6cf8f19c8", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "30b1bae237db99c3d75fac86568075e2fc3466039a0c63c1ffebb7862855b68c", + "size": 31650, + "subdir": "linux-64", + "timestamp": 1670943981941, + "version": "0.6.1" + }, + "python-snappy-0.6.1-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "snappy >=1.1.9,<2.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bdf3e7f0277989c50e427014d8c932e2", + "name": "python-snappy", + "namespace_in_name": true, + "sha256": "3f72464c33bb636b0e35f4fd3003803e83749d6142f93135d1a52b613698ac7f", + "size": 31639, + "subdir": "linux-64", + "timestamp": 1670943952283, + "version": "0.6.1" + }, + "python-socketio-1.8.3-py27hb405ee9_0.conda": { + "build": "py27hb405ee9_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-engineio >=1.2.1", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea20594c21ab6dd39115c67f6d98b123", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "c026687b5a93bc4b447b33e2751230db74010ce1d9a8333226720b00e6e69825", + "size": 34471, + "subdir": "linux-64", + "timestamp": 1512038764476, + "version": "1.8.3" + }, + "python-socketio-1.8.3-py35h0598352_0.conda": { + "build": "py35h0598352_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-engineio >=1.2.1", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d91fd131c55adf6864913019f694080", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "24f6052dda6f04d134a1759b2910c175d6c152c67b7e704ee8e4a91686b12f7f", + "size": 39566, + "subdir": "linux-64", + "timestamp": 1512038770718, + "version": "1.8.3" + }, + "python-socketio-1.8.3-py36hc4454f7_0.conda": { + "build": "py36hc4454f7_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-engineio >=1.2.1", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a076fe7bfe7bc39edbab6947d9a28a0c", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "a9ad2b77f99dae014ae9f09f0710610547f236213f916cbe5d95078210ab6f27", + "size": 38674, + "subdir": "linux-64", + "timestamp": 1512038777288, + "version": "1.8.3" + }, + "python-socketio-1.9.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-engineio >=1.2.1", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0082e5c50760de8ae4251d16ff50c36a", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "55d3e7e7cce7c607b24e598d0729ef59797c99878aca66ea73957c3dae463f4e", + "size": 35454, + "subdir": "linux-64", + "timestamp": 1522084613208, + "version": "1.9.0" + }, + "python-socketio-1.9.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-engineio >=1.2.1", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb577d90a9000d19e744285834bdc7b4", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "d7514d57e0bd47c8aa93d6b124e1407fbe27c220e1b38026b86af9d20e9bfb91", + "size": 39710, + "subdir": "linux-64", + "timestamp": 1522084623143, + "version": "1.9.0" + }, + "python-socketio-1.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-engineio >=1.2.1", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9be5f614966c795b16306d6e6a98b450", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "bf4c9ac80b3b57582737c45375922e79f96d15b85c8f2d10c20438972da67a47", + "size": 39358, + "subdir": "linux-64", + "timestamp": 1522084555867, + "version": "1.9.0" + }, + "python-socketio-1.9.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-engineio >=1.2.1", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a212dd800504454eac4a905beefce9b", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "605129050561681b41fd200165f09d5adc915a00776d143cfd7841c7cee9aedb", + "size": 39223, + "subdir": "linux-64", + "timestamp": 1530877540139, + "version": "1.9.0" + }, + "python-socketio-2.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-engineio >=2.2.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd9e81c51eb6719e4c930e26c82378ad", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "271afd9efd16049622ab688590b0a8295dfd884cdd6d63c6aa5330c38ece4f4f", + "size": 35651, + "subdir": "linux-64", + "timestamp": 1535510951176, + "version": "2.0.0" + }, + "python-socketio-2.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-engineio >=2.2.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "836cda0bb3b923a39c9f6435f3cb9e83", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "bfca1386b3c4c507d7a434e98f813ac81cdb7880f46d42ef3cad7bcf0d9ec92d", + "size": 40378, + "subdir": "linux-64", + "timestamp": 1535510978416, + "version": "2.0.0" + }, + "python-socketio-2.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-engineio >=2.2.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "814db884ffba8ec08ea52c0cd2f60593", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "7cadf7bdcda164474e4dcc2efabf8511451145690346a7019f9f663fe1960e5b", + "size": 39394, + "subdir": "linux-64", + "timestamp": 1535510845940, + "version": "2.0.0" + }, + "python-socketio-2.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-engineio >=2.2.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c9f752bceacebdc6e3d91e26e1534cfb", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "1b8208941cf24cd031c22580d5bf9bd1394dbcc1132cdc945c05822a81a320d2", + "size": 39451, + "subdir": "linux-64", + "timestamp": 1535510959150, + "version": "2.0.0" + }, + "python-socketio-2.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-engineio >=3.0.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "36617a9e64ddfde352d06145eec10bfa", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "dfa4e728b75f2b1426da752f540422ae3356dc6e7a12fbdaaf2584ab81408f10", + "size": 36225, + "subdir": "linux-64", + "timestamp": 1545166822178, + "version": "2.1.2" + }, + "python-socketio-2.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-engineio >=3.0.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f638bf8a9c210bc583cb9307fe229146", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "d2630bd88a1bc9f964fdf5a87bbfb600a500d34f47d7c41a13f89b0b2d0c051b", + "size": 41204, + "subdir": "linux-64", + "timestamp": 1545166857603, + "version": "2.1.2" + }, + "python-socketio-2.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-engineio >=3.0.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a27293a892aafdf8ae34966a3b2f131", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "20de95ee0482c2cf769ac96159dd4dc12f6c22b0642f69acaeba47ca19c09a36", + "size": 41349, + "subdir": "linux-64", + "timestamp": 1545166832095, + "version": "2.1.2" + }, + "python-socketio-3.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-engineio >=3.0.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f114f4ff1753a5fbed05d08f469003c", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "db596f76ef87be2b7dcb084cf6ae25b03a2619dac1dd2ac555ad3118294d9bef", + "size": 45040, + "subdir": "linux-64", + "timestamp": 1550355787625, + "version": "3.1.2" + }, + "python-socketio-3.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-engineio >=3.0.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "46c7d631062c51190ec389b2b5c99176", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "fefb399dfdd8d7952364ed1b4526f2bb39a9b26d3535f371883cde152111c8a8", + "size": 51918, + "subdir": "linux-64", + "timestamp": 1550355759248, + "version": "3.1.2" + }, + "python-socketio-3.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-engineio >=3.0.0", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a383f83fad4339f477121af538765caa", + "name": "python-socketio", + "namespace_in_name": true, + "sha256": "db43aa6cee43e44c991f59d71e410190b1e47a949b6321a92c987fad6a46a934", + "size": 51873, + "subdir": "linux-64", + "timestamp": 1550355711083, + "version": "3.1.2" + }, + "python-utils-2.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6de6d460127b957507c99d9dc2e29abf", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "e37b5da4faf7ca2fd3130114b19f3240ffd2bbe76f8111ea9d46693c7284fa63", + "size": 18261, + "subdir": "linux-64", + "timestamp": 1519674036340, + "version": "2.3.0" + }, + "python-utils-2.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5c1a442ba03118d051a8e2c5e73946d5", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "dcfb7dd0ef17b6412c920d0d5e23d8d1a564f99bbd7f7f71f10004b2fa692665", + "size": 18524, + "subdir": "linux-64", + "timestamp": 1519674131624, + "version": "2.3.0" + }, + "python-utils-2.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f88987037703ff0b2985feaf0f7ac936", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "386a2f19d3167daf2f85dc3d64be95fcaae08d0dc7926a1000047477700bc99e", + "size": 18423, + "subdir": "linux-64", + "timestamp": 1519674213034, + "version": "2.3.0" + }, + "python-utils-2.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "837299c654f8f4cafb70223bca2994e9", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "24f95913016654c3788668a3e9384fe79afcbfaa7345aaf7d86dd47c1c95af0d", + "size": 18290, + "subdir": "linux-64", + "timestamp": 1530906136002, + "version": "2.3.0" + }, + "python-utils-2.3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c75c8773290204cfec4254d1d46bb3fb", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "a88e308f83f18486058fd68a20dcd4ec9838826fc6e8f8d44ae6b122270b4bac", + "size": 18843, + "subdir": "linux-64", + "timestamp": 1574094393986, + "version": "2.3.0" + }, + "python-utils-2.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "91dfbaede9d43c247479558db4e3940e", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "a953157637c1482e519ff75442d66461beb3d063980a926aac2abbc7c918661c", + "size": 19291, + "subdir": "linux-64", + "timestamp": 1600460189741, + "version": "2.4.0" + }, + "python-utils-2.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "50ab55299917ee70e98cdaf611bb1972", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "8186f9750ddd74ee1eb1b117b0ce956074fb5a55bcce654426d5bf74e76a92a1", + "size": 19353, + "subdir": "linux-64", + "timestamp": 1600460175295, + "version": "2.4.0" + }, + "python-utils-2.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0d6cbf78193214c1a7e0d243d9455d62", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "aa1ac22eae407fc1dd4d6892a4748ddf79977c6f45ff13317ad7cd5cf4e86c41", + "size": 19387, + "subdir": "linux-64", + "timestamp": 1600460182288, + "version": "2.4.0" + }, + "python-utils-2.5.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "92dcb0345e5042e8f4b67149fa9b328b", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "631ec580e49867fa0e69083909a28bbafcf2b28c24f97c04011389d0451973aa", + "size": 20383, + "subdir": "linux-64", + "timestamp": 1610739125263, + "version": "2.5.1" + }, + "python-utils-2.5.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a3fe40eb2c0f9b371146912b5a30ced4", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "a5434b31b220d834bbe7223655388d7272c037a766387ea04e23ba3f82f9fe52", + "size": 20280, + "subdir": "linux-64", + "timestamp": 1610739102681, + "version": "2.5.1" + }, + "python-utils-2.5.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "04ebaf47997bfeacb91674e5d6110d96", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "7e08680d4d2a66b68485f52546e3cde120c14f40cccc1e46428e835e55671d8b", + "size": 20311, + "subdir": "linux-64", + "timestamp": 1610739110579, + "version": "2.5.1" + }, + "python-utils-2.5.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dafd7461a13b38cc913b50e306eb00fb", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "9e86a9026e95747def213820e6cd1969e34c09f346fe06e278d5aa757fe18d9a", + "size": 20376, + "subdir": "linux-64", + "timestamp": 1610739068042, + "version": "2.5.1" + }, + "python-utils-2.5.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a5e714747734d42759c032e90ff87833", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "e2e5ebbfc9caadb809dab9a6e17fb3131f57f3fb70aeff7c6bc00e9494f1335c", + "size": 21396, + "subdir": "linux-64", + "timestamp": 1611258352679, + "version": "2.5.2" + }, + "python-utils-2.5.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "994cb4bb32cb893a222a82678295f54a", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "54ca9311429b580fa63e15016cc27aad5f39377a59277ccdc3468239f5b6a674", + "size": 21341, + "subdir": "linux-64", + "timestamp": 1611258312859, + "version": "2.5.2" + }, + "python-utils-2.5.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e15d265c8835fccf3e594ded4dfdd0a5", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "a40df7ca7614ca80e7b7ff9fcfae2acd5279001822ce33cc499bcc38453f1c14", + "size": 21302, + "subdir": "linux-64", + "timestamp": 1611258206579, + "version": "2.5.2" + }, + "python-utils-2.5.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d07738c316ffbc14e0bd4a9edaa8a5b", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "9cb267fad04d6581e9ac8790b6688503129dacd414e9d2cc1452932771493737", + "size": 21464, + "subdir": "linux-64", + "timestamp": 1611258348727, + "version": "2.5.2" + }, + "python-utils-2.5.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e0f63e1bdad801c847a956f50118a2a6", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "1d073f074199de3acc8c03647ea5324d442c1715c909d06d5cab11eba54bdc6b", + "size": 19842, + "subdir": "linux-64", + "timestamp": 1640793993822, + "version": "2.5.5" + }, + "python-utils-2.5.5-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0839fc56b40aa96dd7a037b863421176", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "657dd3e8c49436bfbde46d8967ca0397cb65b0fbf9abcc2f176a41febd0699f4", + "size": 19794, + "subdir": "linux-64", + "timestamp": 1611693997942, + "version": "2.5.5" + }, + "python-utils-2.5.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8837942b642d712a942faf79c8f504fa", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "9e8eefb36d60e0c6d6bd5f0b2a074a1a26063bd8671e3e409cdf7bdc06908b50", + "size": 19774, + "subdir": "linux-64", + "timestamp": 1611694021742, + "version": "2.5.5" + }, + "python-utils-2.5.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7b0c8ce7eb2a081e6596f7dc48ca898b", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "475dcb805eff86bbf88d487a70637cccdffc62f40d4af43c8966a9487afd4b57", + "size": 19824, + "subdir": "linux-64", + "timestamp": 1611694043032, + "version": "2.5.5" + }, + "python-utils-2.5.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "96d455626786e0d1c3334be7c4c24f98", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "0154865e44e1636f6e38856ce6cdf0129cb46fdb4e4b55c20aa649271813f6c4", + "size": 19992, + "subdir": "linux-64", + "timestamp": 1611694044013, + "version": "2.5.5" + }, + "python-utils-2.5.6-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "69c831bfab8ca75b7c3ab7542178edb4", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "bba42a04d53574ed8d4e449d42bf511a50e9d91440293a12764ad70bc76e136f", + "size": 19849, + "subdir": "linux-64", + "timestamp": 1613936468429, + "version": "2.5.6" + }, + "python-utils-2.5.6-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff0d0340ee733c7d842c1adc8cde3064", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "d16a4bc16f5d8d4b32f48dd9516c79dc44a5a0c9c22e7c75f9958c6f7f7384b4", + "size": 19902, + "subdir": "linux-64", + "timestamp": 1613935622384, + "version": "2.5.6" + }, + "python-utils-2.5.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "abb506470db1d4b2ff9cf8d61250119e", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "6b2d2400e87dee5de12086473a499118b3e971ea10b83882180969ae8b24e27a", + "size": 19960, + "subdir": "linux-64", + "timestamp": 1613935620846, + "version": "2.5.6" + }, + "python-utils-2.5.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1808be0d6b5305de6973b9ecb7489f45", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "fd485dc47b9054dc46043a9740b239890adc2726ea1395e28662e97a286cfee8", + "size": 19912, + "subdir": "linux-64", + "timestamp": 1613936472192, + "version": "2.5.6" + }, + "python-utils-3.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "03187c5b3b2d814aa0bfb69e62572e66", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "73e1fdfada4c7aa92ceaac282d621a57568b5561597d9072ac0335680834f01b", + "size": 36513, + "subdir": "linux-64", + "timestamp": 1663332347125, + "version": "3.3.3" + }, + "python-utils-3.3.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3885964c1be64173b9ed42b2e96a2d23", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "4037bfd1e73253006f9dc197720de30a6b2b29510bc11850e4a3993ebb1f9d9c", + "size": 44650, + "subdir": "linux-64", + "timestamp": 1676845588613, + "version": "3.3.3" + }, + "python-utils-3.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "27ae0cec477441b28733bddb3aae1747", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "ca02bd6e8923056300331f454158ea43dedac1ede00399475744785f88f58693", + "size": 36113, + "subdir": "linux-64", + "timestamp": 1663332308184, + "version": "3.3.3" + }, + "python-utils-3.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "12e9794dfbff33d41a155a0613e9f6e1", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "ecd0e52f97873021b70cf3673d21dcfde2b4f2d395284700c22f272acaf2a4da", + "size": 36360, + "subdir": "linux-64", + "timestamp": 1663332282771, + "version": "3.3.3" + }, + "python-utils-3.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2adada5f082f4280690a094f5f47d340", + "name": "python-utils", + "namespace_in_name": true, + "sha256": "f2542f0e175e51a386744d45ed0dbebc71cb730eb66b4e3958c44528bac98d37", + "size": 36179, + "subdir": "linux-64", + "timestamp": 1663332373124, + "version": "3.3.3" + }, + "python-xxhash-2.0.2-py310h5eee18b_1.conda": { + "build": "py310h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e4e3318d9ce76b22f315488f3417107a", + "name": "python-xxhash", + "sha256": "95e035c9165f8ac95057ad7cc699ebb4032dd5f5e188ae0fb2d84ee734581184", + "size": 21950, + "subdir": "linux-64", + "timestamp": 1667919649210, + "version": "2.0.2" + }, + "python-xxhash-2.0.2-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d4319ac0b850fe90a5174d8659e91071", + "name": "python-xxhash", + "sha256": "344f63e0b7890149bdb712ae7e493d25a5443d3366475774eb161f62e4c05c62", + "size": 40051, + "subdir": "linux-64", + "timestamp": 1640794019259, + "version": "2.0.2" + }, + "python-xxhash-2.0.2-py311h5eee18b_1.conda": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b8fde23a4b5ddc9a7437782cff416ae5", + "name": "python-xxhash", + "sha256": "23837cb09bf399499aff6106dc914f3ea2266022c9f59dafca030f78140be130", + "size": 20687, + "subdir": "linux-64", + "timestamp": 1676842401281, + "version": "2.0.2" + }, + "python-xxhash-2.0.2-py36h7f8727e_0.conda": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "175a698f388e4ef877880c4c7b079bdb", + "name": "python-xxhash", + "sha256": "b99c49cf6daea51bb8620a543bc208ab7a62027ceeac9b617f9d73a0ceca0a6e", + "size": 23926, + "subdir": "linux-64", + "timestamp": 1633101754365, + "version": "2.0.2" + }, + "python-xxhash-2.0.2-py37h5eee18b_1.conda": { + "build": "py37h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "46e84710e38fe03ead95af4a60217fbb", + "name": "python-xxhash", + "sha256": "14f5f3b03d2dfa7dd229100775a249f3effd3531aef5849b51558a9460622cae", + "size": 22034, + "subdir": "linux-64", + "timestamp": 1667919590476, + "version": "2.0.2" + }, + "python-xxhash-2.0.2-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "191f9b82dc19ed981be5c5e74a321d49", + "name": "python-xxhash", + "sha256": "10d81e422acad5687497c9febd7160f11db5efa7a07acba17f3986158fa90da0", + "size": 23851, + "subdir": "linux-64", + "timestamp": 1633091212106, + "version": "2.0.2" + }, + "python-xxhash-2.0.2-py38h5eee18b_1.conda": { + "build": "py38h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "fe3115f92f5b377a593ee7c7dd83ccb0", + "name": "python-xxhash", + "sha256": "e5054bf206e3901560112b33281abf755efaf07dc60c8ea500052f5e7312a5ae", + "size": 21956, + "subdir": "linux-64", + "timestamp": 1667919620016, + "version": "2.0.2" + }, + "python-xxhash-2.0.2-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9fd50551d3169c2c95bbe0399c5949c4", + "name": "python-xxhash", + "sha256": "0dcc9b2617a6cea143d79e468694d2f2ffa0f2103aac394727bad2fb9c76bc7a", + "size": 24203, + "subdir": "linux-64", + "timestamp": 1633101742347, + "version": "2.0.2" + }, + "python-xxhash-2.0.2-py39h5eee18b_1.conda": { + "build": "py39h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "7568d5417ab617e376dc1d7b25c30d74", + "name": "python-xxhash", + "sha256": "219fc38b26082f0ab02891ad3a4697865ecb39469f1c0acc0234f11cb96016f8", + "size": 21962, + "subdir": "linux-64", + "timestamp": 1667919560481, + "version": "2.0.2" + }, + "python-xxhash-2.0.2-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "xxhash >=0.8.0,<0.8.1.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5fc575f83c2810e053a145933aee65be", + "name": "python-xxhash", + "sha256": "ef2c00dfe192a14b9f0fdcefdeb851ece5d1957d83b41b470f5e2787dd9dfa00", + "size": 23749, + "subdir": "linux-64", + "timestamp": 1633101725566, + "version": "2.0.2" + }, + "python3-openid-3.1.0-py310h06a4308_1001.conda": { + "build": "py310h06a4308_1001", + "build_number": 1001, + "depends": [ + "defusedxml", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5531a630d0f2bd147f69edc0effc631f", + "name": "python3-openid", + "sha256": "cc20ae0e1c7e9342eac0bc326eb6c7c81da8d4f3db04f6b45a1fa9df6296eecb", + "size": 180282, + "subdir": "linux-64", + "timestamp": 1642510894814, + "version": "3.1.0" + }, + "python3-openid-3.1.0-py311h06a4308_1001.conda": { + "build": "py311h06a4308_1001", + "build_number": 1001, + "depends": [ + "defusedxml", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c4013050a26c982ca55569e125e40b80", + "name": "python3-openid", + "sha256": "80ecc51cdcaa863555b9f90a1d6d1cc7da71ed06ce7b41b8f17affdabd164e16", + "size": 230235, + "subdir": "linux-64", + "timestamp": 1676845603315, + "version": "3.1.0" + }, + "python3-openid-3.1.0-py36_1001.conda": { + "build": "py36_1001", + "build_number": 1001, + "depends": [ + "defusedxml", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e5547f26a9fada3943e13d67a30eb20a", + "name": "python3-openid", + "sha256": "13bd9d74b4e667424fe50f90d2df65c45ba51d9cd69674c3b1a9048e025b60d0", + "size": 183859, + "subdir": "linux-64", + "timestamp": 1579615028389, + "version": "3.1.0" + }, + "python3-openid-3.1.0-py36h06a4308_1001.conda": { + "build": "py36h06a4308_1001", + "build_number": 1001, + "depends": [ + "defusedxml", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3865a04e254f61a13bc01c2cea6b860c", + "name": "python3-openid", + "sha256": "fd6f2d6009c4f26e39c5f8adf1e38ca7c071a1d612af8ec0fe46b1a80cf139fd", + "size": 183954, + "subdir": "linux-64", + "timestamp": 1614085650533, + "version": "3.1.0" + }, + "python3-openid-3.1.0-py37_1001.conda": { + "build": "py37_1001", + "build_number": 1001, + "depends": [ + "defusedxml", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7f9d87c525f32692c6da5d75b0bf8cdb", + "name": "python3-openid", + "sha256": "8b6863cfc294d848036ea0fc311c126da75c29d134a794d5e6cebfc9cccf848d", + "size": 183696, + "subdir": "linux-64", + "timestamp": 1579614933544, + "version": "3.1.0" + }, + "python3-openid-3.1.0-py37h06a4308_1001.conda": { + "build": "py37h06a4308_1001", + "build_number": 1001, + "depends": [ + "defusedxml", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6a2fc30fff8382a62dbcc1f0c19b9b97", + "name": "python3-openid", + "sha256": "05aa973ac63298f22b8b4d8b10a421a78c14a954fea4aed0d21d36638274929a", + "size": 181486, + "subdir": "linux-64", + "timestamp": 1614085642676, + "version": "3.1.0" + }, + "python3-openid-3.1.0-py38_1001.conda": { + "build": "py38_1001", + "build_number": 1001, + "depends": [ + "defusedxml", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f54c0ea94adc53db0fda253f1fafa67d", + "name": "python3-openid", + "sha256": "9316317498f4a3fca1b9337cfc7285530fa06a5132159b7cff418eabb3cc50b7", + "size": 184296, + "subdir": "linux-64", + "timestamp": 1579615021014, + "version": "3.1.0" + }, + "python3-openid-3.1.0-py38h06a4308_1001.conda": { + "build": "py38h06a4308_1001", + "build_number": 1001, + "depends": [ + "defusedxml", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9847d80fdf5e07e32ba280874de94053", + "name": "python3-openid", + "sha256": "4dfde36a8bfa0bc4fd32a1838b8ef19cf88a854928b7f126426d2a097614cbe5", + "size": 184726, + "subdir": "linux-64", + "timestamp": 1614085645213, + "version": "3.1.0" + }, + "python3-openid-3.1.0-py39h06a4308_1001.conda": { + "build": "py39h06a4308_1001", + "build_number": 1001, + "depends": [ + "defusedxml", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "73ad43073388d2a27654b6d8d46e2698", + "name": "python3-openid", + "sha256": "99e98a3fdcf35f6375c7f9ecebb3b2cd6534327f41b6fcec72e46de44ba9ac0d", + "size": 181361, + "subdir": "linux-64", + "timestamp": 1614085654360, + "version": "3.1.0" + }, + "pythonanywhere-0.10.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "docopt", + "packaging", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "requests", + "schema", + "tabulate", + "typer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "94b60fc3d8a775f6deb1022fd10bab39", + "name": "pythonanywhere", + "sha256": "bda8c14461d52cc4953f4a976ca2aec79714d90379111453abbaf5d62abeec05", + "size": 56001, + "subdir": "linux-64", + "timestamp": 1663667621304, + "version": "0.10.2" + }, + "pythonanywhere-0.10.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "docopt", + "packaging", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests", + "schema", + "tabulate", + "typer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3eb557e6f47cf34924cd4fec9057c01", + "name": "pythonanywhere", + "sha256": "708485cb3d8b1a9145cf93b3913eb5d694cd00a425e3b0b24c8996f1002a1b56", + "size": 55217, + "subdir": "linux-64", + "timestamp": 1663667649105, + "version": "0.10.2" + }, + "pythonanywhere-0.10.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "docopt", + "packaging", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests", + "schema", + "tabulate", + "typer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f4d52bff887160a74ada457df409987f", + "name": "pythonanywhere", + "sha256": "2cf9657f3f50b029c55c5c8b466a6771641c30d6f7ec536179010afdfe74fcfe", + "size": 55634, + "subdir": "linux-64", + "timestamp": 1663667705233, + "version": "0.10.2" + }, + "pythonanywhere-0.10.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "docopt", + "packaging", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests", + "schema", + "tabulate", + "typer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3ec837649bada4fcf1e27dbca43e7c0f", + "name": "pythonanywhere", + "sha256": "fdf5e63765bca63f21348e6c9fac9f57152e87ef8d3944db98797a91bef85a97", + "size": 55624, + "subdir": "linux-64", + "timestamp": 1663667677848, + "version": "0.10.2" + }, + "pythonnet-3.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "clr_loader >=0.2.2,<0.3.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "309059d1f47ec820a0bf7c5c72fdbac7", + "name": "pythonnet", + "sha256": "b9428004fb178a9aea9373a3874435911adff507973bec81a20d9c6e27d23b69", + "size": 289241, + "subdir": "linux-64", + "timestamp": 1675453856094, + "version": "3.0.1" + }, + "pythonnet-3.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "clr_loader >=0.2.2,<0.3.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8eb07cf8390bb24c50aa90962959e07b", + "name": "pythonnet", + "sha256": "d04143787038d58d725595a3cad3f92537bd0ab1955c7bf6299bb44ed57a88a9", + "size": 254720, + "subdir": "linux-64", + "timestamp": 1676861628170, + "version": "3.0.1" + }, + "pythonnet-3.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "clr_loader >=0.2.2,<0.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1586b646dab5bae901dd1a547b30a473", + "name": "pythonnet", + "sha256": "2985006c3f11d81d375f8d1d76b8782af6457dc5b71c4ba3fe6d1b3a9b6b6b3d", + "size": 289243, + "subdir": "linux-64", + "timestamp": 1675453779577, + "version": "3.0.1" + }, + "pythonnet-3.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "clr_loader >=0.2.2,<0.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bdd75eb52507c6f9a79d381e624ae855", + "name": "pythonnet", + "sha256": "a8a7e84c51db475406cf20f25549820af6cffbe0382e1a8db93845e4e6ce404d", + "size": 289352, + "subdir": "linux-64", + "timestamp": 1675453742835, + "version": "3.0.1" + }, + "pythonnet-3.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "clr_loader >=0.2.2,<0.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "646c128a989b97ad9db80b32fee2b6a9", + "name": "pythonnet", + "sha256": "01f8df415a7e4949adcbc2c0a8d08c094c29121f9c3d7b0726773113b2d31da7", + "size": 289346, + "subdir": "linux-64", + "timestamp": 1675453817807, + "version": "3.0.1" + }, + "pythran-0.10.0-py310h3c18c91_0.conda": { + "build": "py310h3c18c91_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "ply >=3.4", + "python >=3.10,<3.11.0a0", + "xsimd >=7.6,<7.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6f3e0b2268c36451ad0907171286c2aa", + "name": "pythran", + "sha256": "283ac0cb8b240effb081ddc207fff60e70d11c40a5b3da97f75472085bf34fd4", + "size": 1790417, + "subdir": "linux-64", + "timestamp": 1656068424659, + "version": "0.10.0" + }, + "pythran-0.10.0-py37h79cecc1_0.conda": { + "build": "py37h79cecc1_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.7,<3.8.0a0", + "xsimd >=7.6,<7.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f03a40eb942fd9eee2d618cb57e76e64", + "name": "pythran", + "sha256": "06eecf5e3de12032b694e7c20923e18afc2f662925b0a2464617efcaa5675a90", + "size": 1778034, + "subdir": "linux-64", + "timestamp": 1656068596248, + "version": "0.10.0" + }, + "pythran-0.10.0-py38h79cecc1_0.conda": { + "build": "py38h79cecc1_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.8,<3.9.0a0", + "xsimd >=7.6,<7.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8d42e24109107a3ec3dc3f8c7ed2b258", + "name": "pythran", + "sha256": "7371316e6ccfc389127e3860a7b7b145838aca082357e11a7a68d0d36cedb00c", + "size": 1781915, + "subdir": "linux-64", + "timestamp": 1656068510082, + "version": "0.10.0" + }, + "pythran-0.10.0-py39h79cecc1_0.conda": { + "build": "py39h79cecc1_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.9,<3.10.0a0", + "xsimd >=7.6,<7.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ec0dc686c7c7d3c61eb166f9959bb2cf", + "name": "pythran", + "sha256": "e526517a322eb4a6a5b7909d478265bf76ebaa2de85c054727ae6de464e802cb", + "size": 1781320, + "subdir": "linux-64", + "timestamp": 1656068682172, + "version": "0.10.0" + }, + "pythran-0.11.0-py310h3c18c91_0.conda": { + "build": "py310h3c18c91_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "ply >=3.4", + "python >=3.10,<3.11.0a0", + "xsimd >=8.0.5,<8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b563391339996064cbce59b0b92f043b", + "name": "pythran", + "sha256": "3743033c5149b8e890d72b811ea4762bd05b809f266eff6c402a53187e544866", + "size": 1797208, + "subdir": "linux-64", + "timestamp": 1660004908043, + "version": "0.11.0" + }, + "pythran-0.11.0-py37h79cecc1_0.conda": { + "build": "py37h79cecc1_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.7,<3.8.0a0", + "xsimd >=8.0.5,<8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "66f3123d35769631dccef183efcc386a", + "name": "pythran", + "sha256": "bda130b122447b3e5499e674bc45d2eb8298f3c35132e86b822def55706466f9", + "size": 1784334, + "subdir": "linux-64", + "timestamp": 1660005066864, + "version": "0.11.0" + }, + "pythran-0.11.0-py38h79cecc1_0.conda": { + "build": "py38h79cecc1_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.8,<3.9.0a0", + "xsimd >=8.0.5,<8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "66d1a0be1d98a0fd70a49b91acb98549", + "name": "pythran", + "sha256": "dd3bac4835e4535480684dcc5a556cda6b529e361eb7547a5e5f413d8698df15", + "size": 1786537, + "subdir": "linux-64", + "timestamp": 1660004818257, + "version": "0.11.0" + }, + "pythran-0.11.0-py39h79cecc1_0.conda": { + "build": "py39h79cecc1_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.9,<3.10.0a0", + "xsimd >=8.0.5,<8.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6585682333026973fb98ea139250b156", + "name": "pythran", + "sha256": "44774d697fb2542cf3bf1b347e74c34ac48aa3478b1c8edc5bc28bcd9750b7a0", + "size": 1786778, + "subdir": "linux-64", + "timestamp": 1660004987459, + "version": "0.11.0" + }, + "pythran-0.12.1-py310h3c18c91_0.conda": { + "build": "py310h3c18c91_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "ply >=3.4", + "python >=3.10,<3.11.0a0", + "xsimd 10.0.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ba471f08a8fd2dbbe7987f7116407477", + "name": "pythran", + "sha256": "8f3dfc6e266c19be6ce921f25f37d6b62cdde7fb580bf878e95709281067604b", + "size": 1999624, + "subdir": "linux-64", + "timestamp": 1674515381218, + "version": "0.12.1" + }, + "pythran-0.12.1-py311heed92f4_0.conda": { + "build": "py311heed92f4_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "ply >=3.4", + "python >=3.11,<3.12.0a0", + "xsimd 10.0.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a3eea63468b4d81dbf8e2711b7e913c", + "name": "pythran", + "sha256": "93c9aa89c6ed017210cf29d671d2208a50fa6b7010a60381c7ecb60839b92a0e", + "size": 2016288, + "subdir": "linux-64", + "timestamp": 1676827434153, + "version": "0.12.1" + }, + "pythran-0.12.1-py37h79cecc1_0.conda": { + "build": "py37h79cecc1_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.7,<3.8.0a0", + "xsimd 10.0.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3608b18aea56b788800d869f70d39d37", + "name": "pythran", + "sha256": "3c8b043e255ad3900578753df400d21f174330cd5af2e27b6fa0ea0874623bfe", + "size": 1985961, + "subdir": "linux-64", + "timestamp": 1674515310326, + "version": "0.12.1" + }, + "pythran-0.12.1-py38h79cecc1_0.conda": { + "build": "py38h79cecc1_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.8,<3.9.0a0", + "xsimd 10.0.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "73aca74d394749eb63d7338f03e63827", + "name": "pythran", + "sha256": "6a022dc9d9260ba81f2466ca507cef44399e1fceab62cabe7d378ebb0f2dfe9d", + "size": 1990320, + "subdir": "linux-64", + "timestamp": 1674515237338, + "version": "0.12.1" + }, + "pythran-0.12.1-py39h79cecc1_0.conda": { + "build": "py39h79cecc1_0", + "build_number": 0, + "depends": [ + "beniget >=0.4.0,<0.5.0", + "gast >=0.5.0,<0.6.0", + "gxx_linux-64 11.2.0.*", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.9,<3.10.0a0", + "xsimd 10.0.0.*" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ff6e711a090fe35dd8b58258c6370cb7", + "name": "pythran", + "sha256": "0e6ca8fef4a2ba8ed7c3098e8e00c62d4918b9f61b051379bf0c486a7b792b80", + "size": 1988702, + "subdir": "linux-64", + "timestamp": 1674515453818, + "version": "0.12.1" + }, + "pythran-0.9.11-py310h2571103_3.conda": { + "build": "py310h2571103_3", + "build_number": 3, + "depends": [ + "beniget 0.3.*", + "decorator", + "gast 0.4.*", + "gxx_linux-64 7.5.0.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2", + "numpy >=1.21.2,<2.0a0", + "ply >=3.4", + "python >=3.10,<3.11.0a0", + "six", + "xsimd" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b00c91c4a523cb3d07410e8075fb0759", + "name": "pythran", + "sha256": "236484c9f991b5bc4459394977aa1fb19096ddc41ce3cbd54e37d729e538c5de", + "size": 1762740, + "subdir": "linux-64", + "timestamp": 1640810710328, + "version": "0.9.11" + }, + "pythran-0.9.11-py310h2571103_4.conda": { + "build": "py310h2571103_4", + "build_number": 4, + "depends": [ + "beniget 0.3.*", + "decorator", + "gast 0.4.*", + "gxx_linux-64 7.5.0.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2", + "numpy >=1.21.2,<2.0a0", + "ply >=3.4", + "python >=3.10,<3.11.0a0", + "six", + "xsimd" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee1c8f5e493aec704273b8858febe711", + "name": "pythran", + "sha256": "3a98099325dd5c1455ab527ffea5082bd59eb617eaeb07df01006b2f41ea4112", + "size": 1760124, + "subdir": "linux-64", + "timestamp": 1647959282379, + "version": "0.9.11" + }, + "pythran-0.9.11-py36hae6d005_3.conda": { + "build": "py36hae6d005_3", + "build_number": 3, + "depends": [ + "beniget 0.3.*", + "decorator", + "gast 0.4.*", + "gxx_linux-64 7.5.0.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.6,<3.7.0a0", + "six", + "xsimd" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "379444e8c570d361a067d67d7e955f4b", + "name": "pythran", + "sha256": "267f2ede56a227c993eedcfa74e216130614806642f09c26eb14253e20fd849a", + "size": 1755612, + "subdir": "linux-64", + "timestamp": 1630332122172, + "version": "0.9.11" + }, + "pythran-0.9.11-py37hae6d005_3.conda": { + "build": "py37hae6d005_3", + "build_number": 3, + "depends": [ + "beniget 0.3.*", + "decorator", + "gast 0.4.*", + "gxx_linux-64 7.5.0.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.7,<3.8.0a0", + "six", + "xsimd" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b0aaf407705da2b4ded9284696983f14", + "name": "pythran", + "sha256": "941f6f2b36a751a676993ce2807862cdfb41fb9409036297804b71175161a615", + "size": 1761650, + "subdir": "linux-64", + "timestamp": 1630331740555, + "version": "0.9.11" + }, + "pythran-0.9.11-py37hae6d005_4.conda": { + "build": "py37hae6d005_4", + "build_number": 4, + "depends": [ + "beniget 0.3.*", + "decorator", + "gast 0.4.*", + "gxx_linux-64 7.5.0.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.7,<3.8.0a0", + "six", + "xsimd" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "037b4903ddcb470cc90fe6093328f1cb", + "name": "pythran", + "sha256": "05533839b8c51b58a720b836a7146304e43c439ccbe33fc1c7fe89835b083559", + "size": 1750817, + "subdir": "linux-64", + "timestamp": 1647959102679, + "version": "0.9.11" + }, + "pythran-0.9.11-py38hae6d005_3.conda": { + "build": "py38hae6d005_3", + "build_number": 3, + "depends": [ + "beniget 0.3.*", + "decorator", + "gast 0.4.*", + "gxx_linux-64 7.5.0.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.8,<3.9.0a0", + "six", + "xsimd" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "52a8456a298a30d11a241f4537abf9a7", + "name": "pythran", + "sha256": "7be7b4da54e108caab3cd1bb78f91af343017c92d4b19b4debba2ec09f184c51", + "size": 1763123, + "subdir": "linux-64", + "timestamp": 1630331732290, + "version": "0.9.11" + }, + "pythran-0.9.11-py38hae6d005_4.conda": { + "build": "py38hae6d005_4", + "build_number": 4, + "depends": [ + "beniget 0.3.*", + "decorator", + "gast 0.4.*", + "gxx_linux-64 7.5.0.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.8,<3.9.0a0", + "six", + "xsimd" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9b6227dddf3cc1be941f7ca44a1a2a02", + "name": "pythran", + "sha256": "48bc06710c37bb76e377ec94e49b36017b893b940d32e2a4973bc473418118de", + "size": 1753081, + "subdir": "linux-64", + "timestamp": 1647959019353, + "version": "0.9.11" + }, + "pythran-0.9.11-py39hae6d005_3.conda": { + "build": "py39hae6d005_3", + "build_number": 3, + "depends": [ + "beniget 0.3.*", + "decorator", + "gast 0.4.*", + "gxx_linux-64 7.5.0.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.9,<3.10.0a0", + "six", + "xsimd" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b288dba4f481d60a389454abb31448a5", + "name": "pythran", + "sha256": "3251b08f00fefd6946af3a291b0433be46391fa04b36711b8ba547da0b478c0c", + "size": 1761122, + "subdir": "linux-64", + "timestamp": 1630322601915, + "version": "0.9.11" + }, + "pythran-0.9.11-py39hae6d005_4.conda": { + "build": "py39hae6d005_4", + "build_number": 4, + "depends": [ + "beniget 0.3.*", + "decorator", + "gast 0.4.*", + "gxx_linux-64 7.5.0.*", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2", + "numpy >=1.16.6,<2.0a0", + "ply >=3.4", + "python >=3.9,<3.10.0a0", + "six", + "xsimd" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f233181a2e5bfd2940a21b39852a3277", + "name": "pythran", + "sha256": "605f9b4120aa1390f051c42198030b4aba95a83a49f3593ea20485832ffbbfa4", + "size": 1749098, + "subdir": "linux-64", + "timestamp": 1647959192540, + "version": "0.9.11" + }, + "pytimeparse-1.1.7-py27h14c5330_0.conda": { + "build": "py27h14c5330_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "192a0f4cc1714b6a7d5f8bd7b681ce37", + "name": "pytimeparse", + "sha256": "2495135e2bfe5d3cc35af68bb2a4070c75887bb3fde846825ae069b83b610c07", + "size": 17635, + "subdir": "linux-64", + "timestamp": 1508621586039, + "version": "1.1.7" + }, + "pytimeparse-1.1.7-py35h492fd5f_0.conda": { + "build": "py35h492fd5f_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37cb1a5e156f8ac9c34cc647de91684d", + "name": "pytimeparse", + "sha256": "4b042513d35f06c0ef82c964c1dc9ecf65d120e4fe4c1f8a69ccfe2022447a8f", + "size": 18010, + "subdir": "linux-64", + "timestamp": 1508621607462, + "version": "1.1.7" + }, + "pytimeparse-1.1.7-py36ha42143c_0.conda": { + "build": "py36ha42143c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "88f3f91bcd63e154a76ea78526832f17", + "name": "pytimeparse", + "sha256": "9c5ecb8f019ef6ba0a938cdb5e115768a71da72b0e1e9e7cb0a6be2769caaf18", + "size": 17874, + "subdir": "linux-64", + "timestamp": 1508621604611, + "version": "1.1.7" + }, + "pytimeparse-1.1.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58373f5069283865153c3f16b53eac97", + "name": "pytimeparse", + "sha256": "42a0130af3fc2afae580cf00bb80393aa71f4d4643420c20b1990a0a2f160722", + "size": 15874, + "subdir": "linux-64", + "timestamp": 1526938387452, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee09a202a12c3a8117cf0376defb2eb7", + "name": "pytimeparse", + "sha256": "cdc0d3404ce2bffce21b0082f8bcd39fae67e8af3dfa1c96f03ff7df04adf4ee", + "size": 16355, + "subdir": "linux-64", + "timestamp": 1640794037320, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d48b6fef4429bbff666178be4e25878", + "name": "pytimeparse", + "sha256": "53b671580f7d60d5e2e3a9c33eb5cc63465927475052a5c38eab891c9edc62fa", + "size": 19624, + "subdir": "linux-64", + "timestamp": 1676838691263, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77cf993032a47835b29647f15e870a40", + "name": "pytimeparse", + "sha256": "b2d7801acdfcf4d609634763c552c06f4042de07c2a9e8305bbe3abef2d0298a", + "size": 16429, + "subdir": "linux-64", + "timestamp": 1526938398724, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "395664b416e407530421619c74379654", + "name": "pytimeparse", + "sha256": "ab0979fdd8bb09dbd4862825026a13cb8fce20964c8f9dbe3134707fa363abec", + "size": 16170, + "subdir": "linux-64", + "timestamp": 1526938361548, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2ad184e9487259023c0cca967c24616", + "name": "pytimeparse", + "sha256": "604a81f9ca62c0cba9d5f528ad991dd30880db042a8b3940c08fd2bee7100960", + "size": 17838, + "subdir": "linux-64", + "timestamp": 1613409188073, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e18790ee262c7217350616113345021a", + "name": "pytimeparse", + "sha256": "9c2128299c17d2f46428c607ad2f49dc25d7ce16eba6e1defad2977db8e15c90", + "size": 16066, + "subdir": "linux-64", + "timestamp": 1530735485424, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "213a26c4fdc54e544926eae3b3140b55", + "name": "pytimeparse", + "sha256": "620727e985346baef688f82cb9895cd57afe3de94797724ef78dacfff8b367bd", + "size": 17580, + "subdir": "linux-64", + "timestamp": 1613409777538, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "465dc6143fc2a62f438478031aed6576", + "name": "pytimeparse", + "sha256": "df092c84bd9490c557fa7060ef690819892bb1e8835c926b574a0ccf9a6a16af", + "size": 16316, + "subdir": "linux-64", + "timestamp": 1573200304871, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "84930f0e77dae981e8e2c8ce1163f872", + "name": "pytimeparse", + "sha256": "6550765a0b53fd2bd883c2cea09d583b45f20391e2fb1acdf0395f279ee3ec89", + "size": 17850, + "subdir": "linux-64", + "timestamp": 1613409780745, + "version": "1.1.8" + }, + "pytimeparse-1.1.8-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49e21bec8907ba43d6c1129189177a09", + "name": "pytimeparse", + "sha256": "fa5b8f33384b62fc93ce9579398f1629cc4d12fc1957d2c77a65c45861b4021e", + "size": 17863, + "subdir": "linux-64", + "timestamp": 1613409780053, + "version": "1.1.8" + }, + "pytoml-0.1.15-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e34e81416df69c3050113b371029299a", + "name": "pytoml", + "sha256": "24f4f6af293653058a635790004dca84a054527c800a7bbe07ccae4ad667c4e9", + "size": 16640, + "subdir": "linux-64", + "timestamp": 1529945214202, + "version": "0.1.15" + }, + "pytoml-0.1.15-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "267ec21cd6ffe7c68a782ec7fbdb2a09", + "name": "pytoml", + "sha256": "56883046bdba6bebb014061daad93a0111a094fd18370a213ddb6b603d2c612c", + "size": 16897, + "subdir": "linux-64", + "timestamp": 1529945275298, + "version": "0.1.15" + }, + "pytoml-0.1.15-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "54a95383ddd5f5b9c255d69152de45a8", + "name": "pytoml", + "sha256": "8836dd0f6aa88bcd1d56a3d0dfcc86b911bd1f43003099439fca6e4dc2ccc96e", + "size": 16761, + "subdir": "linux-64", + "timestamp": 1529945134744, + "version": "0.1.15" + }, + "pytoml-0.1.15-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "949948a32b939fa746be024f62ac4713", + "name": "pytoml", + "sha256": "c8af7472122d15cb94e59b85ce341bd903a6a25c1a61169d4fb0c342b4f9cf91", + "size": 16794, + "subdir": "linux-64", + "timestamp": 1530898053690, + "version": "0.1.15" + }, + "pytoml-0.1.18-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e2a3d9e2d3e8ca84f58f51221552103f", + "name": "pytoml", + "sha256": "304d5c5f834cf2d64cd97b98fd19edb2532bc54f3f2e332e65a5038ef8fd5540", + "size": 17363, + "subdir": "linux-64", + "timestamp": 1535512688983, + "version": "0.1.18" + }, + "pytoml-0.1.18-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "944479e9fdc2f5054b0a00aadf51e3c3", + "name": "pytoml", + "sha256": "47a48d503f3967ad15580bb70a44171f7d0b2d60f84a92704570dcdc27643af7", + "size": 17486, + "subdir": "linux-64", + "timestamp": 1535512717658, + "version": "0.1.18" + }, + "pytoml-0.1.18-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7f4a019f6cb4fc22e6f408c156221d16", + "name": "pytoml", + "sha256": "7d788bdc6446cd9ef3c64d31e3d8c17692b7ca73ab5edf7e2ba160691e543ea7", + "size": 17237, + "subdir": "linux-64", + "timestamp": 1535512643914, + "version": "0.1.18" + }, + "pytoml-0.1.18-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3e2111962bf444d5b62e12dcecc580f6", + "name": "pytoml", + "sha256": "f895877645de43b928887f411929cdc0d798546e659c06e15ece8448b75654bc", + "size": 17425, + "subdir": "linux-64", + "timestamp": 1535512750201, + "version": "0.1.18" + }, + "pytoml-0.1.19-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "8f938a26039a9ad61dcf5ccd9dead1db", + "name": "pytoml", + "sha256": "13c9a3128bd8bb653b24985f4801d77f0f26326b4e95d68d36976d843d12ad4d", + "size": 17296, + "subdir": "linux-64", + "timestamp": 1538358752740, + "version": "0.1.19" + }, + "pytoml-0.1.19-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "91157bc74c0ff1167f8d5ebcc3c73078", + "name": "pytoml", + "sha256": "703c5f494d1a251c098e121ecbd54b8e3244ae0b88fbf60acfff038c7cb1d094", + "size": 17349, + "subdir": "linux-64", + "timestamp": 1538358779741, + "version": "0.1.19" + }, + "pytoml-0.1.19-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "587d0005a536fa1e2f13da37d52c6867", + "name": "pytoml", + "sha256": "ffe4378821d8b3f06bcac2388e77ea6d676cba763843657f63ab26f581564bf9", + "size": 17482, + "subdir": "linux-64", + "timestamp": 1538358686240, + "version": "0.1.19" + }, + "pytoml-0.1.20-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "17367bbcdeebd734490ab7ca10c64135", + "name": "pytoml", + "sha256": "6591f751ac813e73692c025c95db26973da76b04f689383b12f3fd5008bf8525", + "size": 18627, + "subdir": "linux-64", + "timestamp": 1541040846321, + "version": "0.1.20" + }, + "pytoml-0.1.20-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b77705e46994215d7dfcacd48ccf7965", + "name": "pytoml", + "sha256": "d022ff0af1ab7c8d069d5b9e4448244399dea5b51ebd6a3dcb5c62a04a8e98f4", + "size": 18776, + "subdir": "linux-64", + "timestamp": 1541040880326, + "version": "0.1.20" + }, + "pytoml-0.1.20-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "636c445c85abf22fddf96b1b3cf7b47d", + "name": "pytoml", + "sha256": "1ae41d4715c0ebb4a7a4cca71beb8f5b3987ae51b42b8e3e6591e3310a2ede6e", + "size": 18706, + "subdir": "linux-64", + "timestamp": 1541040785940, + "version": "0.1.20" + }, + "pytoolconfig-1.2.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=22.0", + "python >=3.10,<3.11.0a0", + "tomli >=2.0.1" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "69d06d3ef5297cbabea38ab268dae6d3", + "name": "pytoolconfig", + "sha256": "1fd93a9f0659e8c2c3b03f40e51c46f2bebcab27c44d2d00e4ab5fdd0cf5cdaf", + "size": 31934, + "subdir": "linux-64", + "timestamp": 1675309504680, + "version": "1.2.5" + }, + "pytoolconfig-1.2.5-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "packaging >=22.0", + "platformdirs", + "python >=3.10,<3.11.0a0", + "tomli >=2.0.1" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "6d04dde34eb8e0437f5c6770fbb6f72c", + "name": "pytoolconfig", + "sha256": "f340743e4ce4d8a35f7236c6f5b7a3ebd4b098017c970583864ad04be7d75bc0", + "size": 32185, + "subdir": "linux-64", + "timestamp": 1676315102999, + "version": "1.2.5" + }, + "pytoolconfig-1.2.5-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "packaging >=22.0", + "platformdirs", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "668717a0e693683ebb627be956de65c8", + "name": "pytoolconfig", + "sha256": "641ce0bc549dc87012a040bdfd1e4bf04c7a8e3103a3948e2f279f2681aafe2f", + "size": 35418, + "subdir": "linux-64", + "timestamp": 1677709034188, + "version": "1.2.5" + }, + "pytoolconfig-1.2.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=22.0", + "python >=3.7,<3.8.0a0", + "tomli >=2.0.1", + "typing-extensions >=4.4.0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "04be9559ff4813eae69a5cc20f14739c", + "name": "pytoolconfig", + "sha256": "1d25ea65fef582a4f82d7753fd0e6f1e17cbc715373c93e1477c7eb86591f348", + "size": 31709, + "subdir": "linux-64", + "timestamp": 1675309540567, + "version": "1.2.5" + }, + "pytoolconfig-1.2.5-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "packaging >=22.0", + "platformdirs", + "python >=3.7,<3.8.0a0", + "tomli >=2.0.1", + "typing-extensions >=4.4.0" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "d786fd3abae8186fb6039ea01c3847e4", + "name": "pytoolconfig", + "sha256": "399cd45da0c27faa7daa9019a930a1a2a3c4848a6555919f799141dcb3e6a991", + "size": 31941, + "subdir": "linux-64", + "timestamp": 1676315175903, + "version": "1.2.5" + }, + "pytoolconfig-1.2.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=22.0", + "python >=3.8,<3.9.0a0", + "tomli >=2.0.1" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "c89e127b08ecca80752e15f6faef69e6", + "name": "pytoolconfig", + "sha256": "bddc6ada2ca689586e7f106b4ccb8b4b775e7ef29ee9c539a08f3dea4a4a0285", + "size": 31732, + "subdir": "linux-64", + "timestamp": 1675309575590, + "version": "1.2.5" + }, + "pytoolconfig-1.2.5-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "packaging >=22.0", + "platformdirs", + "python >=3.8,<3.9.0a0", + "tomli >=2.0.1" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "7016fbbf054f463ca435c295bcb8d030", + "name": "pytoolconfig", + "sha256": "86246b0429516f4b23aa0a2edc7fc6e860e043137b4bce8a70e2a4e4117a1002", + "size": 31957, + "subdir": "linux-64", + "timestamp": 1676315067791, + "version": "1.2.5" + }, + "pytoolconfig-1.2.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=22.0", + "python >=3.9,<3.10.0a0", + "tomli >=2.0.1" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "4ae40a1bb265c476d5f7a65595ff6262", + "name": "pytoolconfig", + "sha256": "61ab37cf18876cecbca59c9b18f3f8629344cade315a3f49866c81b346a4f54e", + "size": 31669, + "subdir": "linux-64", + "timestamp": 1675309469484, + "version": "1.2.5" + }, + "pytoolconfig-1.2.5-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "packaging >=22.0", + "platformdirs", + "python >=3.9,<3.10.0a0", + "tomli >=2.0.1" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "dc243d556c906d3a427716a229d614eb", + "name": "pytoolconfig", + "sha256": "6c0b6aada632e54d39ddca56354b1b55d5bc0327959e718e75b193d10c795b49", + "size": 31917, + "subdir": "linux-64", + "timestamp": 1676315138782, + "version": "1.2.5" + }, + "pytorch-0.2.0-py27cuda7.5cudnn5.1_0.conda": { + "build": "py27cuda7.5cudnn5.1_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 7.5*", + "cudnn 5.1*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f4a77efccea7fd1803d2584861703a4c", + "name": "pytorch", + "sha256": "6fda796b1821c35aaf945f6162d22661f6ff8ffc3d51cb887fc664ff9e43cccd", + "size": 111075448, + "subdir": "linux-64", + "timestamp": 1511317602199, + "version": "0.2.0" + }, + "pytorch-0.2.0-py27cuda7.5cudnn6.0_0.conda": { + "build": "py27cuda7.5cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 7.5*", + "cudnn 6.0*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c6d6ff7055702109b970521f62052735", + "name": "pytorch", + "sha256": "155157a34c7e7cabbf1f26e5b668f0158b45149cd887605b618417a7d8dd1d32", + "size": 111060434, + "subdir": "linux-64", + "timestamp": 1511315381620, + "version": "0.2.0" + }, + "pytorch-0.2.0-py27cuda8.0cudnn5.1_0.conda": { + "build": "py27cuda8.0cudnn5.1_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn 5.1*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d30f6a0d38509bdf2de50cd91308e26e", + "name": "pytorch", + "sha256": "9271b7465ad5e2d13006b910dce5071f5b89b057fd9220eb88e0373c9bd54886", + "size": 111653476, + "subdir": "linux-64", + "timestamp": 1511304294817, + "version": "0.2.0" + }, + "pytorch-0.2.0-py27cuda8.0cudnn6.0_0.conda": { + "build": "py27cuda8.0cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn 6.0*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2c81339f56ad417fda001720ffd63dce", + "name": "pytorch", + "sha256": "263778ec63e044f1def8d1910cde631344032121499459a2a0b64b9deb961a01", + "size": 111439487, + "subdir": "linux-64", + "timestamp": 1511305977597, + "version": "0.2.0" + }, + "pytorch-0.2.0-py35cuda7.5cudnn5.1_0.conda": { + "build": "py35cuda7.5cudnn5.1_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 7.5*", + "cudnn 5.1*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1430bdb1eab9ea9129fc0ac2ae4f8a17", + "name": "pytorch", + "sha256": "3560ecf554f2759a6c816454ba85811053cac14e77d334a8058fca1c93771a77", + "size": 111085156, + "subdir": "linux-64", + "timestamp": 1511320505720, + "version": "0.2.0" + }, + "pytorch-0.2.0-py35cuda7.5cudnn6.0_0.conda": { + "build": "py35cuda7.5cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 7.5*", + "cudnn 6.0*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "62339fcade5f3d3d951bb5c37d2a540c", + "name": "pytorch", + "sha256": "db231cefeea0b2ed12af93a251dfc765278be5fd8b1227deee412d50a3684ee6", + "size": 110988743, + "subdir": "linux-64", + "timestamp": 1511313202518, + "version": "0.2.0" + }, + "pytorch-0.2.0-py35cuda8.0cudnn5.1_0.conda": { + "build": "py35cuda8.0cudnn5.1_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn 5.1*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6bb03d975995007eabf6ce66fb6e7ada", + "name": "pytorch", + "sha256": "e82ca44b2e722a593893dc07844aad21605de05376abc4c9a517b47b3201f804", + "size": 111633365, + "subdir": "linux-64", + "timestamp": 1511296338105, + "version": "0.2.0" + }, + "pytorch-0.2.0-py35cuda8.0cudnn6.0_0.conda": { + "build": "py35cuda8.0cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn 6.0*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4381e7af7ea6e848ccea7e1af726795a", + "name": "pytorch", + "sha256": "b3697bf8da8b265e49c41b740bf5dfd52ab818202a4fd8b8f077159d4bd1206f", + "size": 111670171, + "subdir": "linux-64", + "timestamp": 1511291935214, + "version": "0.2.0" + }, + "pytorch-0.2.0-py36cuda7.5cudnn5.1_0.conda": { + "build": "py36cuda7.5cudnn5.1_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 7.5*", + "cudnn 5.1*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "374747b25987ffd70f4ee54e8fe9f4cb", + "name": "pytorch", + "sha256": "53b4650aecf4841f7300f239f0c3ceb34f39f78e5ba42252f879c904268a9ff0", + "size": 111090320, + "subdir": "linux-64", + "timestamp": 1511322585474, + "version": "0.2.0" + }, + "pytorch-0.2.0-py36cuda7.5cudnn6.0_0.conda": { + "build": "py36cuda7.5cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 7.5*", + "cudnn 6.0*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dd0960b7c52705b3d8b4700369fa0c59", + "name": "pytorch", + "sha256": "9d52ca85459b837f8c4e34f54ebde912320a79dda63d3979c20873a2b550d72f", + "size": 111118134, + "subdir": "linux-64", + "timestamp": 1511310551802, + "version": "0.2.0" + }, + "pytorch-0.2.0-py36cuda8.0cudnn5.1_0.conda": { + "build": "py36cuda8.0cudnn5.1_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn 5.1*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "029f81493b4425be246b8522e8ff3128", + "name": "pytorch", + "sha256": "1982c306c98b66cbe397d26fdb75fe747fe5fad2772a5db8a9683f7fd78c5c1a", + "size": 111640091, + "subdir": "linux-64", + "timestamp": 1511297966997, + "version": "0.2.0" + }, + "pytorch-0.2.0-py36cuda8.0cudnn6.0_0.conda": { + "build": "py36cuda8.0cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn 6.0*", + "libgcc", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.11", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "018ca07e27d20ee26d6466202f1057c4", + "name": "pytorch", + "sha256": "1904945a3939752254ad511ae925a11459c25489594a0d615b549acd41c0e19c", + "size": 111603108, + "subdir": "linux-64", + "timestamp": 1511288343327, + "version": "0.2.0" + }, + "pytorch-0.3.0-py27cuda7.5cudnn6.0_0.conda": { + "build": "py27cuda7.5cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 7.5*", + "cudnn 6.0*", + "libgcc-ng", + "libstdcxx-ng", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.9", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8976c620e79bc2b324eb4b7ac2af8db0", + "name": "pytorch", + "sha256": "f3a1cb2de76bd62aa980d2d04604d02eb4d1b7e75dc6ba98a8b3889ba66ea464", + "size": 136793414, + "subdir": "linux-64", + "timestamp": 1512938590533, + "version": "0.3.0" + }, + "pytorch-0.3.0-py27cuda8.0cudnn6.0_0.conda": { + "build": "py27cuda8.0cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn 6.0*", + "libgcc-ng", + "libstdcxx-ng", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.9", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "445ccfb7d1848d87ee43c497743e6899", + "name": "pytorch", + "sha256": "746df1f948e6c923cecc2943dc24474f9497c2ec2a6bbf44382519a3b1160b78", + "size": 137937525, + "subdir": "linux-64", + "timestamp": 1512948516539, + "version": "0.3.0" + }, + "pytorch-0.3.0-py27cuda8.0cudnn7.0_0.conda": { + "build": "py27cuda8.0cudnn7.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn >=7.0.0,<=8.0a0", + "libgcc-ng", + "libstdcxx-ng", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.9", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c06b7d633eb419bf109f342748109257", + "name": "pytorch", + "sha256": "032b38fb678f4628c9aa33f6f6c06419e6534eb085fd6fc4d350fea0b13799c3", + "size": 138060861, + "subdir": "linux-64", + "timestamp": 1513364911738, + "version": "0.3.0" + }, + "pytorch-0.3.0-py35cuda7.5cudnn6.0_0.conda": { + "build": "py35cuda7.5cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 7.5*", + "cudnn 6.0*", + "libgcc-ng", + "libstdcxx-ng", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.9", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3557d56622c3ccc72a829ea88d3cca32", + "name": "pytorch", + "sha256": "f8d6c13edf03de588e9278e3b5a2a4572c3a93f294ded0d840e92ba9e89fd53f", + "size": 137045776, + "subdir": "linux-64", + "timestamp": 1512940969339, + "version": "0.3.0" + }, + "pytorch-0.3.0-py35cuda8.0cudnn6.0_0.conda": { + "build": "py35cuda8.0cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn 6.0*", + "libgcc-ng", + "libstdcxx-ng", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.9", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8d71b44ed98c835696654ac9064786b7", + "name": "pytorch", + "sha256": "207a6703c5272bd3f10d1434b4bec2620ec31ee2991e6bb5f2f01da9ce87cf8d", + "size": 138335133, + "subdir": "linux-64", + "timestamp": 1512955613753, + "version": "0.3.0" + }, + "pytorch-0.3.0-py35cuda8.0cudnn7.0_0.conda": { + "build": "py35cuda8.0cudnn7.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn >=7.0.0,<=8.0a0", + "libgcc-ng", + "libstdcxx-ng", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.9", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "09247c15096942c8896714710cfba20a", + "name": "pytorch", + "sha256": "8952e888304d1439ec4aee87f2a69038e63d22460ecb86acffc63e24027af538", + "size": 138290226, + "subdir": "linux-64", + "timestamp": 1513368308617, + "version": "0.3.0" + }, + "pytorch-0.3.0-py36cuda7.5cudnn6.0_0.conda": { + "build": "py36cuda7.5cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 7.5*", + "cudnn 6.0*", + "libgcc-ng", + "libstdcxx-ng", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.9", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "277300c54bd007a55400834b4742253c", + "name": "pytorch", + "sha256": "69b47a72125c55f483164fb433986cfc542a2afb0e7f618e21819e2a11d3d1b9", + "size": 137052521, + "subdir": "linux-64", + "timestamp": 1512945556833, + "version": "0.3.0" + }, + "pytorch-0.3.0-py36cuda8.0cudnn6.0_0.conda": { + "build": "py36cuda8.0cudnn6.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn 6.0*", + "libgcc-ng", + "libstdcxx-ng", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.9", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a4c295929737007aef9ebe9f01a284b1", + "name": "pytorch", + "sha256": "ab98f354ca3a5325503135be8f5908fa16cfdf97944e8f7fdbf59b0f1d68d0c8", + "size": 138329357, + "subdir": "linux-64", + "timestamp": 1512958673174, + "version": "0.3.0" + }, + "pytorch-0.3.0-py36cuda8.0cudnn7.0_0.conda": { + "build": "py36cuda8.0cudnn7.0_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn >=7.0.0,<=8.0a0", + "libgcc-ng", + "libstdcxx-ng", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "numpy >=1.9", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5ade8541c556fcfb55082dcd53935135", + "name": "pytorch", + "sha256": "0a65e915bd36ced71c137ddb88f180a90211984e734e194884a94631db0f2b6c", + "size": 138330616, + "subdir": "linux-64", + "timestamp": 1513370481640, + "version": "0.3.0" + }, + "pytorch-0.3.1-py27had95abb_0.conda": { + "build": "py27had95abb_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "87a8f26a42270a5f0bbe66da93038bee", + "name": "pytorch", + "sha256": "cc31e4030e6992997623d6283bc1be440a00bea7e273af3bed206cb75594f6e8", + "size": 117855598, + "subdir": "linux-64", + "timestamp": 1522184003162, + "version": "0.3.1" + }, + "pytorch-0.3.1-py27hfbe7015_1.conda": { + "build": "py27hfbe7015_1", + "build_number": 1, + "depends": [ + "cffi", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aec69e38fae6b5d299764b7a47fdcf1d", + "name": "pytorch", + "sha256": "b9961dc05c6f81b0005c590f75ecbb6a94f7c7b62e0a8a46021a366c32b6cffb", + "size": 117924384, + "subdir": "linux-64", + "timestamp": 1525803263998, + "version": "0.3.1" + }, + "pytorch-0.3.1-py35had95abb_0.conda": { + "build": "py35had95abb_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "818de3f1d7660ef1a69672182551ed14", + "name": "pytorch", + "sha256": "0e7f93607e59617c5e26230c54073b590db065134f7c421990dd84b8fbf8e1b1", + "size": 117923342, + "subdir": "linux-64", + "timestamp": 1522184941712, + "version": "0.3.1" + }, + "pytorch-0.3.1-py35hfbe7015_1.conda": { + "build": "py35hfbe7015_1", + "build_number": 1, + "depends": [ + "cffi", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c0fd6492a95a7a56319c8aba01e9d26e", + "name": "pytorch", + "sha256": "1516f329800dc90fe1be301cb7c9d53195696b39449f792ed1a978d0c7ef9b66", + "size": 117976494, + "subdir": "linux-64", + "timestamp": 1525798856325, + "version": "0.3.1" + }, + "pytorch-0.3.1-py36had95abb_0.conda": { + "build": "py36had95abb_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4db6f31ab6374b9038cbf31d52e9c1cf", + "name": "pytorch", + "sha256": "64e087e4df9ee365c68131b5121d83889d8041c22da8394dd5511de4f66cca03", + "size": 117956426, + "subdir": "linux-64", + "timestamp": 1522185207380, + "version": "0.3.1" + }, + "pytorch-0.3.1-py36hfbe7015_1.conda": { + "build": "py36hfbe7015_1", + "build_number": 1, + "depends": [ + "cffi", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "62b2764a09793b37835ae96f2b5cf395", + "name": "pytorch", + "sha256": "87ab81f5d48c92468b8c2d7ec1ead4ad88e8dd1cea03e39b4b2bc78448b8b688", + "size": 117818357, + "subdir": "linux-64", + "timestamp": 1525801057965, + "version": "0.3.1" + }, + "pytorch-0.4.0-py27hd73e86b_0.conda": { + "build": "py27hd73e86b_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "02a6fb1fac1c5733bd095b39fcf10770", + "name": "pytorch", + "sha256": "b486f4ceb167a202fa60e299cc0950d7d3a777e4c42c483bbdf39c5dfe5311c0", + "size": 127341702, + "subdir": "linux-64", + "timestamp": 1525818215514, + "version": "0.4.0" + }, + "pytorch-0.4.0-py27hdf912b8_0.conda": { + "build": "py27hdf912b8_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e88233a186591974447b32034a0737e1", + "name": "pytorch", + "sha256": "6606545eb15138258a904d88c3427d7adad205c20bc8eb6a258a3faa08853d24", + "size": 123402031, + "subdir": "linux-64", + "timestamp": 1525916432634, + "version": "0.4.0" + }, + "pytorch-0.4.0-py35hd73e86b_0.conda": { + "build": "py35hd73e86b_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b9ac948f4f1b3a76f80a31321ac18cc8", + "name": "pytorch", + "sha256": "d9213ae3b2a5eda00eb590015c3d2e580ac5da6f72bfcecf7bbafd8e886a921e", + "size": 127378472, + "subdir": "linux-64", + "timestamp": 1525815882232, + "version": "0.4.0" + }, + "pytorch-0.4.0-py35hdf912b8_0.conda": { + "build": "py35hdf912b8_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bc36bcdb6f1b961e91b5f7a295448197", + "name": "pytorch", + "sha256": "47053a63c7b91433351c9f94d956f7232f7ff9714764df35b5ed370484b7ab83", + "size": 123435111, + "subdir": "linux-64", + "timestamp": 1525911768205, + "version": "0.4.0" + }, + "pytorch-0.4.0-py36hd73e86b_0.conda": { + "build": "py36hd73e86b_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "716defb720f8dcffa925204c32864267", + "name": "pytorch", + "sha256": "ebb456db95936d1222e7b85ff7606c8b32602a9870967555b676107784085f80", + "size": 127316222, + "subdir": "linux-64", + "timestamp": 1525813784282, + "version": "0.4.0" + }, + "pytorch-0.4.0-py36hdf912b8_0.conda": { + "build": "py36hdf912b8_0", + "build_number": 0, + "depends": [ + "cffi", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ed8b430d5313dc89ae8b1d9ee5994aaf", + "name": "pytorch", + "sha256": "d2b27f9d715dbb6b4c8bd368c0a003bb376e8def10ebbcaa29eaa1e4e4080fa9", + "size": 123484892, + "subdir": "linux-64", + "timestamp": 1525914087750, + "version": "0.4.0" + }, + "pytorch-0.4.1-py27ha74772b_0.conda": { + "build": "py27ha74772b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "48def85a215971f6843a8d7377072313", + "name": "pytorch", + "sha256": "e54b9fe753d499720137820efbc5396837f9d3fab24e41ca52d0bcadb177806a", + "size": 124849430, + "subdir": "linux-64", + "timestamp": 1533676010655, + "version": "0.4.1" + }, + "pytorch-0.4.1-py35ha74772b_0.conda": { + "build": "py35ha74772b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a36572cfd9087d5683938554e92318a9", + "name": "pytorch", + "sha256": "9b307f28d62d3f00545be07b9af6264700b09421f864ccfbde403c2eb38368d1", + "size": 124872868, + "subdir": "linux-64", + "timestamp": 1533677581501, + "version": "0.4.1" + }, + "pytorch-0.4.1-py36ha74772b_0.conda": { + "build": "py36ha74772b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "35d5f735845043c3db8a5ec1b89b3b3b", + "name": "pytorch", + "sha256": "252f605d84c58e4a321a1ee5183eb4038ae9a6841abaa06758b3a35ccac69007", + "size": 124845548, + "subdir": "linux-64", + "timestamp": 1533673696390, + "version": "0.4.1" + }, + "pytorch-0.4.1-py37ha74772b_0.conda": { + "build": "py37ha74772b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.3,<2019.0a0", + "nccl <2", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "013e4b19dfa45e1937db55d1c9ac2a26", + "name": "pytorch", + "sha256": "7345619c689a316eaf1ea8fb8de94ee3e4b0cb24cce800ab4adb3e4a0f2052c6", + "size": 124984526, + "subdir": "linux-64", + "timestamp": 1533741208857, + "version": "0.4.1" + }, + "pytorch-1.0.1-cuda100py27he554f03_0.conda": { + "build": "cuda100py27he554f03_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d95eeb52ce23170c8288d473cfd9ae1e", + "name": "pytorch", + "sha256": "28b5a487f932da447d679b286feefc1abe3bca06c4f480d6f0c4767981861e60", + "size": 188579644, + "subdir": "linux-64", + "timestamp": 1550805483195, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda100py36he554f03_0.conda": { + "build": "cuda100py36he554f03_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "30c045908a165b0fe82852ed34f358c7", + "name": "pytorch", + "sha256": "8d278e5f4cc101b2035c80287a954ba18597705893e61edd4e33dadf954a93af", + "size": 185630020, + "subdir": "linux-64", + "timestamp": 1550809114539, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda100py37he554f03_0.conda": { + "build": "cuda100py37he554f03_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dd9086ad8355e8cb74f2fc5bf814485f", + "name": "pytorch", + "sha256": "289d5387b0dbcbbb226edf01715c116fc168cd76e1c40ab1b82c8bc578ea3398", + "size": 188620269, + "subdir": "linux-64", + "timestamp": 1550799600670, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda80py27ha8650f8_0.conda": { + "build": "cuda80py27ha8650f8_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=8.0,<8.1.0a0", + "cudnn >=7.1.3,<8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9a7cd219e8135b16b8f7631eaf232072", + "name": "pytorch", + "sha256": "af0544be5b145a9b29454a7e76fe4673d8dfaafc01477e425f721139b033d39e", + "size": 165776394, + "subdir": "linux-64", + "timestamp": 1550815748825, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda80py36ha8650f8_0.conda": { + "build": "cuda80py36ha8650f8_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=8.0,<8.1.0a0", + "cudnn >=7.1.3,<8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d42ed1651318d99bde9a7b84f3010eed", + "name": "pytorch", + "sha256": "79ece22d5e1d7bdf2a49a8abf99484f6e4a4dc18bf5ffebd1fb7da40a958d5b5", + "size": 162799498, + "subdir": "linux-64", + "timestamp": 1550821306010, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda80py37ha8650f8_0.conda": { + "build": "cuda80py37ha8650f8_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=8.0,<8.1.0a0", + "cudnn >=7.1.3,<8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "254ad6f2c0ca48dcada1a6d1715846b2", + "name": "pytorch", + "sha256": "7b9c7396b238f92241665666dd0fa407a5ab93b29ecf97f7b0149e29ac9a17ef", + "size": 165824692, + "subdir": "linux-64", + "timestamp": 1550818498974, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda90py27h8b0c50b_0.conda": { + "build": "cuda90py27h8b0c50b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f9235d56671532b9915236bccbe4c582", + "name": "pytorch", + "sha256": "117edaaf00a42636ca11f8238162f0dc2e6ab8c8498b9d8310bd2a3332c0ac05", + "size": 178419510, + "subdir": "linux-64", + "timestamp": 1550789930353, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda90py36h8b0c50b_0.conda": { + "build": "cuda90py36h8b0c50b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f60cd48921605b8209bd0f55b32d4b02", + "name": "pytorch", + "sha256": "7050d6247a98aa84457d7288880d3ca7fb20dbfce7d9fcaffe9486bcd6b51ebe", + "size": 181440013, + "subdir": "linux-64", + "timestamp": 1550783418468, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda90py37h8b0c50b_0.conda": { + "build": "cuda90py37h8b0c50b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ee305f213d608ccac87f9b3507bc72cd", + "name": "pytorch", + "sha256": "a0585d832554912bf48c83deb88bf385d2445b405caffcdd2c888a795960bf3c", + "size": 178385614, + "subdir": "linux-64", + "timestamp": 1550786846140, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda92py27h65efead_0.conda": { + "build": "cuda92py27h65efead_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fc83987b044c4bfa449bd0ae56e83027", + "name": "pytorch", + "sha256": "9f99090975c77c51829eadd964134ccd07fd588b47cec99389d1c430ff0a46fd", + "size": 169718258, + "subdir": "linux-64", + "timestamp": 1550854900948, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda92py36h65efead_0.conda": { + "build": "cuda92py36h65efead_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "20305c1a036e45f231e25ae3cf0a7a79", + "name": "pytorch", + "sha256": "69d95211c03aace7744851ca88656aaf258ebffadd27913d602a4e428cc3c442", + "size": 169743673, + "subdir": "linux-64", + "timestamp": 1550858153151, + "version": "1.0.1" + }, + "pytorch-1.0.1-cuda92py37h65efead_0.conda": { + "build": "cuda92py37h65efead_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "669c3a2f96536ccefb669268161287c1", + "name": "pytorch", + "sha256": "7d28cea58bb7b955461a29945e0f97b2d149d2deb8bc9f9e4301693ad97277e3", + "size": 169797282, + "subdir": "linux-64", + "timestamp": 1550851566912, + "version": "1.0.1" + }, + "pytorch-1.1.0-cuda100py27he554f03_0.conda": { + "build": "cuda100py27he554f03_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8e3048c6e1c1ece2abfb0fbfd01dc41e", + "name": "pytorch", + "sha256": "4eb85620d0e06828c20634bf97bbcda130b18d47b6698815df759679e66f7801", + "size": 205741192, + "subdir": "linux-64", + "timestamp": 1565118943587, + "version": "1.1.0" + }, + "pytorch-1.1.0-cuda100py36he554f03_0.conda": { + "build": "cuda100py36he554f03_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f1047a689eebbcbc772774a931840133", + "name": "pytorch", + "sha256": "8df4830ba37f8ee43d4fab249bc7b11bec2a4db305f02826f27b9d4eeb8fb355", + "size": 205736412, + "subdir": "linux-64", + "timestamp": 1565123236053, + "version": "1.1.0" + }, + "pytorch-1.1.0-cuda100py37he554f03_0.conda": { + "build": "cuda100py37he554f03_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1cfa456a584a20e042592824f1945661", + "name": "pytorch", + "sha256": "2974601582474d63e6d3aa0645fbc98070316000ed479f39732d92e023ad0395", + "size": 205835209, + "subdir": "linux-64", + "timestamp": 1565127161473, + "version": "1.1.0" + }, + "pytorch-1.1.0-cuda90py27h8b0c50b_0.conda": { + "build": "cuda90py27h8b0c50b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "future", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a6f796e112e83d55600608cdf0535a58", + "name": "pytorch", + "sha256": "741a5e93d810467f384f28aff90f4e6c9377746495e3db29a5409d13639ca4e4", + "size": 194420322, + "subdir": "linux-64", + "timestamp": 1565132813553, + "version": "1.1.0" + }, + "pytorch-1.1.0-cuda90py36h8b0c50b_0.conda": { + "build": "cuda90py36h8b0c50b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0558f7b7d3c4fb88d9f03d53bf3d517b", + "name": "pytorch", + "sha256": "28f6c91227b900e010125003818fd926dc079943b3792ddea39c31474003f8de", + "size": 194667604, + "subdir": "linux-64", + "timestamp": 1565138062664, + "version": "1.1.0" + }, + "pytorch-1.1.0-cuda90py37h8b0c50b_0.conda": { + "build": "cuda90py37h8b0c50b_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f1d9539631b10b594d45648d62119b21", + "name": "pytorch", + "sha256": "d93167d704089e99ed5f5eeab2aad09baf56ecf084974d84b5418908ba06a476", + "size": 198835770, + "subdir": "linux-64", + "timestamp": 1565142965522, + "version": "1.1.0" + }, + "pytorch-1.1.0-cuda92py27h65efead_0.conda": { + "build": "cuda92py27h65efead_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1196f5c72b394c49e6770bca53c06744", + "name": "pytorch", + "sha256": "a89020b6b5599372090726f763d1c1fbaf6a0ae2f6997d8c90197aa36ca22460", + "size": 189677071, + "subdir": "linux-64", + "timestamp": 1565159440373, + "version": "1.1.0" + }, + "pytorch-1.1.0-cuda92py36h65efead_0.conda": { + "build": "cuda92py36h65efead_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f50a4fb9ac517d23fe8c02454d56951e", + "name": "pytorch", + "sha256": "d26cf73b82137ad2bdd615b769df5f02d5936b477d782b0c1f9dbc6acda95b47", + "size": 185540026, + "subdir": "linux-64", + "timestamp": 1565155249591, + "version": "1.1.0" + }, + "pytorch-1.1.0-cuda92py37h65efead_0.conda": { + "build": "cuda92py37h65efead_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bc04baf998e65ab1b5b2edd29d39334c", + "name": "pytorch", + "sha256": "a529df3f68edb24f44eb108ca1761dce48022e300add2f54223062f826987ee8", + "size": 189724777, + "subdir": "linux-64", + "timestamp": 1565150977158, + "version": "1.1.0" + }, + "pytorch-1.10.2-cpu_py310h6894f24_0.conda": { + "build": "cpu_py310h6894f24_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "mkl 2021.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "46095aae54014b94ba4306574f0863f6", + "name": "pytorch", + "sha256": "b3229139c43ae8a236620f1895890e26b05aadc3895c9c5804dd9b62d0e2f0f6", + "size": 46069099, + "subdir": "linux-64", + "timestamp": 1648025297995, + "version": "1.10.2" + }, + "pytorch-1.10.2-cpu_py37hfa7516b_0.conda": { + "build": "cpu_py37hfa7516b_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "mkl 2021.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.21.2,<2.0a0", + "python >=3.7,<3.8.0a0", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "307bbf88df22863d89862df282b41e36", + "name": "pytorch", + "sha256": "0c64e9b5ca5d79ec45bbd680a776eea1d7906914154733297cbfe0aedab25104", + "size": 46021627, + "subdir": "linux-64", + "timestamp": 1648020263123, + "version": "1.10.2" + }, + "pytorch-1.10.2-cpu_py38hfa7516b_0.conda": { + "build": "cpu_py38hfa7516b_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "mkl 2021.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.21.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7c3a4a74a1432f5c4664cd48bd026cef", + "name": "pytorch", + "sha256": "0399628fbffda4de3d6b0e66698d0cb9f3e2322b685709d56cb87092b0286347", + "size": 46073324, + "subdir": "linux-64", + "timestamp": 1648030298116, + "version": "1.10.2" + }, + "pytorch-1.10.2-cpu_py39hfa7516b_0.conda": { + "build": "cpu_py39hfa7516b_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "mkl 2021.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.21.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3141be837e5eb1925bfb2012d39d1fe5", + "name": "pytorch", + "sha256": "7c4bbe134c688ec31686b7c0d47b387be8adf689f2daa2bc949d3e939e33afa3", + "size": 46213125, + "subdir": "linux-64", + "timestamp": 1648035490691, + "version": "1.10.2" + }, + "pytorch-1.12.1-cpu_py310h9dbd814_1.conda": { + "build": "cpu_py310h9dbd814_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "cffi", + "future", + "libgcc-ng >=11.2.0", + "libopenblas", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "ninja", + "numpy >=1.21,<2", + "python >=3.10,<3.11.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f4330a217dc9b1a587412cc7b5433b4b", + "name": "pytorch", + "sha256": "77340e31a9cafa7a03e07e8b04be7000abb8371796fff824a8fcfc98ff89aaae", + "size": 51681100, + "subdir": "linux-64", + "timestamp": 1675220680853, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py310hb1f1ab4_1.conda": { + "build": "cpu_py310hb1f1ab4_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.21,<2", + "python >=3.10,<3.11.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d90332b322fd6dae6992d4eb22286e8d", + "name": "pytorch", + "sha256": "1de4d791a64958f5c1ae6dcfd504a6e17781ebb2305ea72e7b0ac5cb4bd707c5", + "size": 59784803, + "subdir": "linux-64", + "timestamp": 1675194110885, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py310he8d8e81_0.conda": { + "build": "cpu_py310he8d8e81_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.21.2,<2", + "python >=3.10,<3.11.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bc53f63e37fbc5b92f8bae87ab64440a", + "name": "pytorch", + "sha256": "93fe3ccd6b8a433aaca4a2e78498841b361afd4cf4c9934b30735da75408afd0", + "size": 63895472, + "subdir": "linux-64", + "timestamp": 1669264507374, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py37h9dbd814_1.conda": { + "build": "cpu_py37h9dbd814_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "cffi", + "future", + "libgcc-ng >=11.2.0", + "libopenblas", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "ninja", + "numpy >=1.19,<2", + "python >=3.7,<3.8.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "579a623c05745a1315625acb6f978702", + "name": "pytorch", + "sha256": "0239678ae01f5be1bbdc6b671fc4edd267ad1cf5e8f5e73ff07b0fae21463111", + "size": 51569155, + "subdir": "linux-64", + "timestamp": 1675239278886, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py37hb1f1ab4_1.conda": { + "build": "cpu_py37hb1f1ab4_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.19,<2", + "python >=3.7,<3.8.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "58be25233ee764029ae1857a08814cfe", + "name": "pytorch", + "sha256": "769881e5f17aea483bb2356e9204e7f94d926eb477a3f69efce3fd70902e133b", + "size": 59678030, + "subdir": "linux-64", + "timestamp": 1675214459220, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py37he8d8e81_0.conda": { + "build": "cpu_py37he8d8e81_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.19.2,<2", + "python >=3.7,<3.8.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ac9c36b887a8ab7479c1d976760e50b4", + "name": "pytorch", + "sha256": "9cb137ce70f7408acfc375d6b029daadb4f69ab44e2f7311039a76047032f2ad", + "size": 63789626, + "subdir": "linux-64", + "timestamp": 1669257900992, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py38h9dbd814_1.conda": { + "build": "cpu_py38h9dbd814_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "cffi", + "future", + "libgcc-ng >=11.2.0", + "libopenblas", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "ninja", + "numpy >=1.19,<2", + "python >=3.8,<3.9.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1123bb4529cd75115b9b6bc6a6e6c105", + "name": "pytorch", + "sha256": "d0d6a4bf6c53ec6ef6d582bf7edbceab71e1c1c6d5bb93ec9106fd1e231043bc", + "size": 51587889, + "subdir": "linux-64", + "timestamp": 1675233061380, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py38hb1f1ab4_1.conda": { + "build": "cpu_py38hb1f1ab4_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.19,<2", + "python >=3.8,<3.9.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "11be7574c0df3bceffdf443d9acf1680", + "name": "pytorch", + "sha256": "fe9e12fb96a7969a1b38a45a7ee509ef43a5b9d442ec59965dbbfa574b70efc8", + "size": 59689975, + "subdir": "linux-64", + "timestamp": 1675207653332, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py38he8d8e81_0.conda": { + "build": "cpu_py38he8d8e81_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.19.2,<2", + "python >=3.8,<3.9.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7a90b9c9f0feebb789ba9ca38d5f5860", + "name": "pytorch", + "sha256": "394609541096e43a46fb10a5f9e8087556c840e6cc65e90938a6b89ad7ecb5e8", + "size": 63805351, + "subdir": "linux-64", + "timestamp": 1669277685026, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py39h9dbd814_1.conda": { + "build": "cpu_py39h9dbd814_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "cffi", + "future", + "libgcc-ng >=11.2.0", + "libopenblas", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "ninja", + "numpy >=1.19,<2", + "python >=3.9,<3.10.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "83c3fdffa8517fe1bbdd4b54f39153ea", + "name": "pytorch", + "sha256": "655c0592cde97fd1379adbebbddc7421e625a83030a3fabae0109197256f2c93", + "size": 51574073, + "subdir": "linux-64", + "timestamp": 1675226890806, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py39hb1f1ab4_1.conda": { + "build": "cpu_py39hb1f1ab4_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.19,<2", + "python >=3.9,<3.10.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a02b52e438c65807db8f4b70d34da0ec", + "name": "pytorch", + "sha256": "779165637967a185f33ac96682589fdf72c60d6c14414072742e51ab6437754d", + "size": 59678104, + "subdir": "linux-64", + "timestamp": 1675200894815, + "version": "1.12.1" + }, + "pytorch-1.12.1-cpu_py39he8d8e81_0.conda": { + "build": "cpu_py39he8d8e81_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=9.3.0", + "libstdcxx-ng >=9.3.0", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.19.2,<2", + "python >=3.9,<3.10.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "706234d28b901bda4c540d36da8293d4", + "name": "pytorch", + "sha256": "d1790c29dfa4f5e9446a59d857dcb78e001832fc177ace416fc9ce37fefddbfa", + "size": 63771713, + "subdir": "linux-64", + "timestamp": 1669271105174, + "version": "1.12.1" + }, + "pytorch-1.12.1-gpu_cuda113py310h19ae3d8_1.conda": { + "build": "gpu_cuda113py310h19ae3d8_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=11.3.1,<11.4.0a0", + "cudnn >=8.2,<9.0a0", + "cudnn >=8.2.1,<9.0a0", + "cupti", + "future", + "libgcc-ng >=9.3.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "magma", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.21,<2", + "python >=3.10,<3.11.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "922c725c50e0192cd7176b15e62f117b", + "name": "pytorch", + "sha256": "e9964a1cbf46db64c798dc56d39e5f1cf2e392956b570fa2585c00d90f63ee25", + "size": 417722697, + "subdir": "linux-64", + "timestamp": 1673635168015, + "version": "1.12.1" + }, + "pytorch-1.12.1-gpu_cuda113py37h19ae3d8_1.conda": { + "build": "gpu_cuda113py37h19ae3d8_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=11.3.1,<11.4.0a0", + "cudnn >=8.2,<9.0a0", + "cudnn >=8.2.1,<9.0a0", + "cupti", + "future", + "libgcc-ng >=9.3.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "magma", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.19,<2", + "python >=3.7,<3.8.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07e548c8aa0eb5acf4d80fcfd318d75a", + "name": "pytorch", + "sha256": "b31b14dfe6bdac0685deb0b699a8a3859d1cc30756465181b4a312fa44964067", + "size": 417633794, + "subdir": "linux-64", + "timestamp": 1673677585762, + "version": "1.12.1" + }, + "pytorch-1.12.1-gpu_cuda113py38h19ae3d8_1.conda": { + "build": "gpu_cuda113py38h19ae3d8_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=11.3.1,<11.4.0a0", + "cudnn >=8.2,<9.0a0", + "cudnn >=8.2.1,<9.0a0", + "cupti", + "future", + "libgcc-ng >=9.3.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "magma", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.19,<2", + "python >=3.8,<3.9.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1fb875ecd850653dad4cab5be98d28ec", + "name": "pytorch", + "sha256": "c216cf5bb7d76e53d0bc40407506456856886320237466f8bfcb0a20a53d4c0e", + "size": 417635968, + "subdir": "linux-64", + "timestamp": 1673656407835, + "version": "1.12.1" + }, + "pytorch-1.12.1-gpu_cuda113py39h19ae3d8_1.conda": { + "build": "gpu_cuda113py39h19ae3d8_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=11.3.1,<11.4.0a0", + "cudnn >=8.2,<9.0a0", + "cudnn >=8.2.1,<9.0a0", + "cupti", + "future", + "libgcc-ng >=9.3.0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "magma", + "mkl 2021.*.*", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "ninja", + "numpy >=1.19,<2", + "python >=3.9,<3.10.0a0", + "pyyaml", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fe8f457f67d7cd84d78442544deefc27", + "name": "pytorch", + "sha256": "5610472c79fab490287c5012224133a2b552dcf016ffa6e71c677b805a2ebef1", + "size": 417713040, + "subdir": "linux-64", + "timestamp": 1673613939222, + "version": "1.12.1" + }, + "pytorch-1.2.0-cpu_py27h00be3c6_0.conda": { + "build": "cpu_py27h00be3c6_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6ad3c11508b186d1438e2889f989f0d5", + "name": "pytorch", + "sha256": "0c9648ff4febd7a59520b5014703c6e06c6a5ffdbfa1bfc47c5a2cc8e207230a", + "size": 23314574, + "subdir": "linux-64", + "timestamp": 1566785162389, + "version": "1.2.0" + }, + "pytorch-1.2.0-cpu_py36h00be3c6_0.conda": { + "build": "cpu_py36h00be3c6_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e9ddd92a5a6242189a7637d376d72635", + "name": "pytorch", + "sha256": "a488427d13dd8e3861940ab34da71c8ef13c38ff63d2550af49ec11e09d18e43", + "size": 23308483, + "subdir": "linux-64", + "timestamp": 1566788476310, + "version": "1.2.0" + }, + "pytorch-1.2.0-cpu_py37h00be3c6_0.conda": { + "build": "cpu_py37h00be3c6_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "889e32c0be5558c0ec95e521a2680ee7", + "name": "pytorch", + "sha256": "7184342af451b9835e1dd60c32d603847351b770f8a269836a79d65e41511e27", + "size": 23332356, + "subdir": "linux-64", + "timestamp": 1566769146059, + "version": "1.2.0" + }, + "pytorch-1.2.0-cuda100py27h938c94c_0.conda": { + "build": "cuda100py27h938c94c_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit 10.0.*", + "cudnn >=7.3.0,<=8.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a82ce9a2c4a32ae401be70141e02acba", + "name": "pytorch", + "sha256": "465152ca006a7840580cf87b2a7be16732a1d04ca361471d4c444150fb53a213", + "size": 178897759, + "subdir": "linux-64", + "timestamp": 1566798165213, + "version": "1.2.0" + }, + "pytorch-1.2.0-cuda100py36h938c94c_0.conda": { + "build": "cuda100py36h938c94c_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit 10.0.*", + "cudnn >=7.3.0,<=8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "74a0d954a0cce3679fe3b725e7255e26", + "name": "pytorch", + "sha256": "45c98188fb1d235efae2b8ec700d8b61bdd8c7dc31ec2083cc84ec391a3dc312", + "size": 179143421, + "subdir": "linux-64", + "timestamp": 1566807239409, + "version": "1.2.0" + }, + "pytorch-1.2.0-cuda100py37h938c94c_0.conda": { + "build": "cuda100py37h938c94c_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit 10.0.*", + "cudnn >=7.3.0,<=8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fd06e2f034412b8be9acb98d9fe674cd", + "name": "pytorch", + "sha256": "ad4d7f21fe3eb609fd562a08fc67b0b203bc970003339c089b00d7c5c6b7b8e7", + "size": 179088855, + "subdir": "linux-64", + "timestamp": 1566816157725, + "version": "1.2.0" + }, + "pytorch-1.2.0-cuda92py27hd3e106c_0.conda": { + "build": "cuda92py27hd3e106c_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit 9.2.*", + "cudnn >=7.3.0,<=8.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dd71aad1d238c6f45bff31d25ca6d03d", + "name": "pytorch", + "sha256": "c19df135f14e1882763466145f0d83857af5004b7432e52e469f6bb15b60181b", + "size": 161855301, + "subdir": "linux-64", + "timestamp": 1566783471689, + "version": "1.2.0" + }, + "pytorch-1.2.0-cuda92py36hd3e106c_0.conda": { + "build": "cuda92py36hd3e106c_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit 9.2.*", + "cudnn >=7.3.0,<=8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f20167acd007950aa0680bfbad0a4725", + "name": "pytorch", + "sha256": "b5556055c98c7988278747ba25bb3ee154de2cbee382dce07991f25da73fbd2e", + "size": 162011623, + "subdir": "linux-64", + "timestamp": 1566775235615, + "version": "1.2.0" + }, + "pytorch-1.2.0-cuda92py37hd3e106c_0.conda": { + "build": "cuda92py37hd3e106c_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit 9.2.*", + "cudnn >=7.3.0,<=8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8cf13491eda8c22c36215972e76886ae", + "name": "pytorch", + "sha256": "3dfe900bac3ecb9258403942f496b87ad99d4ee6b6e44194d3ef4bac9a50fcc6", + "size": 162070414, + "subdir": "linux-64", + "timestamp": 1566766137261, + "version": "1.2.0" + }, + "pytorch-1.3.1-cpu_py27h62f834f_0.conda": { + "build": "cpu_py27h62f834f_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "typing" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "480728e2159e473dcbec98b9de415bf3", + "name": "pytorch", + "sha256": "0318d476f507b89b0dc18570224c0a3ab83bf6effd2fa10d8b843dac5ef37474", + "size": 26144850, + "subdir": "linux-64", + "timestamp": 1574373434802, + "version": "1.3.1" + }, + "pytorch-1.3.1-cpu_py36h62f834f_0.conda": { + "build": "cpu_py36h62f834f_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1be2eaa003b29f134db3d6172cdfe681", + "name": "pytorch", + "sha256": "c865fbf449863c9ea347b94d4df2f64c7253984d9cd66dbcce0795d100a91fe3", + "size": 26158897, + "subdir": "linux-64", + "timestamp": 1574378445624, + "version": "1.3.1" + }, + "pytorch-1.3.1-cpu_py37h62f834f_0.conda": { + "build": "cpu_py37h62f834f_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "770ecd020eae20a3809ec6683a1c0b9a", + "name": "pytorch", + "sha256": "e0102707de5bb6f39ea4f1302ead1c73b802717a8d082367d08cdc996829a783", + "size": 26161265, + "subdir": "linux-64", + "timestamp": 1574376307663, + "version": "1.3.1" + }, + "pytorch-1.3.1-cuda100py27h53c1284_0.conda": { + "build": "cuda100py27h53c1284_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.4,<8.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "typing" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8251724665fc02c11c7db8a75ba1b8b1", + "name": "pytorch", + "sha256": "79842caeefa07ed6e700f6d89436b371c9e7420a189dd4efff6bfa5e570183af", + "size": 177183546, + "subdir": "linux-64", + "timestamp": 1574410757057, + "version": "1.3.1" + }, + "pytorch-1.3.1-cuda100py36h53c1284_0.conda": { + "build": "cuda100py36h53c1284_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.4,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2c8b5264360a7bf45f13e0bbcb2245a3", + "name": "pytorch", + "sha256": "55408fc9e0504b74d58a6ac77211ede8451d91bbe3cb3a21f69f02508ca6c999", + "size": 177182516, + "subdir": "linux-64", + "timestamp": 1574400501705, + "version": "1.3.1" + }, + "pytorch-1.3.1-cuda100py37h53c1284_0.conda": { + "build": "cuda100py37h53c1284_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.4,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ceb5521d8eb7d28a2d85bff757d8ebb4", + "name": "pytorch", + "sha256": "33dabf350e41a50cb157898982e05358c839c6bec3c52438273e248d894c7a1c", + "size": 177181984, + "subdir": "linux-64", + "timestamp": 1574390294838, + "version": "1.3.1" + }, + "pytorch-1.3.1-cuda92py27hb0ba70e_0.conda": { + "build": "cuda92py27hb0ba70e_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.4,<8.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "typing" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a8a1c48689d2ffec355f1a852ebb281b", + "name": "pytorch", + "sha256": "2bcdde7c931869bbdb678ab85ac576d4b54bbba5482848df783e4d70f69489c6", + "size": 160800729, + "subdir": "linux-64", + "timestamp": 1574478507115, + "version": "1.3.1" + }, + "pytorch-1.3.1-cuda92py36hb0ba70e_0.conda": { + "build": "cuda92py36hb0ba70e_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.4,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ba8f1496d1605798acab7a2f5b708b7f", + "name": "pytorch", + "sha256": "e2483080ddc3bea5b4ba152e2c11b4df81510a577bc6764058e2aa4cfab35cd5", + "size": 160894652, + "subdir": "linux-64", + "timestamp": 1574469543370, + "version": "1.3.1" + }, + "pytorch-1.3.1-cuda92py37hb0ba70e_0.conda": { + "build": "cuda92py37hb0ba70e_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.4,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9db70ab72a7ad67e18f64ecc380cc0fa", + "name": "pytorch", + "sha256": "01f21592fc7b5350fec04b7f0154563ee7978bd5fd2b61c1ed8c6317dfff7eac", + "size": 160903174, + "subdir": "linux-64", + "timestamp": 1574459959105, + "version": "1.3.1" + }, + "pytorch-1.4.0-cpu_py36h7e40bad_0.conda": { + "build": "cpu_py36h7e40bad_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1fd8632fe5ccdf42ed8657a8105892ef", + "name": "pytorch", + "sha256": "6d81400cba5535c932c72f91d503cb1632e95965aecfd13a0d6b8c2b90665f6c", + "size": 28440004, + "subdir": "linux-64", + "timestamp": 1584029167192, + "version": "1.4.0" + }, + "pytorch-1.4.0-cpu_py37h7e40bad_0.conda": { + "build": "cpu_py37h7e40bad_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "052f69ba640b59b68399aa26901c983b", + "name": "pytorch", + "sha256": "cf5b223916f382466e5e98db7143c9b6401805a29ad9391033cc3c468af83a92", + "size": 28350577, + "subdir": "linux-64", + "timestamp": 1584031123580, + "version": "1.4.0" + }, + "pytorch-1.4.0-cpu_py38h7e40bad_0.conda": { + "build": "cpu_py38h7e40bad_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5ff949141d6e671269793157a4848f9b", + "name": "pytorch", + "sha256": "09073daced809210f59c89d4704158750d552e3394eb0d157a5004491f7f83bb", + "size": 28450102, + "subdir": "linux-64", + "timestamp": 1584054103142, + "version": "1.4.0" + }, + "pytorch-1.4.0-cuda100py36h75a84eb_0.conda": { + "build": "cuda100py36h75a84eb_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c6e4c8abdd050343fde07fe3444ab7c8", + "name": "pytorch", + "sha256": "d0e436e441c98d00c9591e969dac1529dc15dd7d6ee480d68670c158a558d20e", + "size": 177499270, + "subdir": "linux-64", + "timestamp": 1584374430194, + "version": "1.4.0" + }, + "pytorch-1.4.0-cuda100py37h75a84eb_0.conda": { + "build": "cuda100py37h75a84eb_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1207e50a2d4f2106962776ab7d20bed6", + "name": "pytorch", + "sha256": "f8dc34b0b335b251df648976c657724880685a3fedcce31a1b9685ccd2f7dd6d", + "size": 177579707, + "subdir": "linux-64", + "timestamp": 1584394896014, + "version": "1.4.0" + }, + "pytorch-1.4.0-cuda100py38h75a84eb_0.conda": { + "build": "cuda100py38h75a84eb_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a73929c9ac7ebb8ff6fe221c56c42412", + "name": "pytorch", + "sha256": "82cd0ea3a072b9f8d7f00dc30531da9b3b092cd8e34ba3de6e3c933c7a3716e0", + "size": 177578357, + "subdir": "linux-64", + "timestamp": 1584384608285, + "version": "1.4.0" + }, + "pytorch-1.4.0-cuda101py36h02f0884_0.conda": { + "build": "cuda101py36h02f0884_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6d4e1a3e949e2f186e1acd49ba9f930a", + "name": "pytorch", + "sha256": "802a3c397742343990f2742299264fc8c7d9304561602483c0d8992fec55820b", + "size": 175545245, + "subdir": "linux-64", + "timestamp": 1584552362205, + "version": "1.4.0" + }, + "pytorch-1.4.0-cuda101py37h02f0884_0.conda": { + "build": "cuda101py37h02f0884_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "11860871f65184719d33625bf3fe9ce8", + "name": "pytorch", + "sha256": "f1e2891c410d08e90b6b045362f39d85fd5b7cb03cb24ca732e710d5f68b7e38", + "size": 175582584, + "subdir": "linux-64", + "timestamp": 1584562373020, + "version": "1.4.0" + }, + "pytorch-1.4.0-cuda101py38h02f0884_0.conda": { + "build": "cuda101py38h02f0884_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5d5a60baf0283c61c9a7718602321c1b", + "name": "pytorch", + "sha256": "7447262f81926bcaf0d2dce901f132246f294294bc79d363700cde688b1e8a56", + "size": 175573491, + "subdir": "linux-64", + "timestamp": 1584572523873, + "version": "1.4.0" + }, + "pytorch-1.4.0-cuda92py36h488537e_0.conda": { + "build": "cuda92py36h488537e_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e55a847fabbe472ed288571302abb927", + "name": "pytorch", + "sha256": "7c8b1c1002175fb7481f573c27a3950e48c54123cb036f321ba3938ccf77d309", + "size": 161893574, + "subdir": "linux-64", + "timestamp": 1584481879061, + "version": "1.4.0" + }, + "pytorch-1.4.0-cuda92py37h488537e_0.conda": { + "build": "cuda92py37h488537e_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "151dab3c0317b024aca2a32cd4d836a6", + "name": "pytorch", + "sha256": "04d9b97a3f378f3afec9e9bbc0bdf57ba0b174fc0575245e6c54601aaea40321", + "size": 161874409, + "subdir": "linux-64", + "timestamp": 1584500966232, + "version": "1.4.0" + }, + "pytorch-1.4.0-cuda92py38h488537e_0.conda": { + "build": "cuda92py38h488537e_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "blas 1.0 mkl", + "cffi", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e55310e81e68b2b70357ad2657d2b0b2", + "name": "pytorch", + "sha256": "9bae30908b38e1e55ec1d3e0209e12de5ca63af381cdb826d39d526cd65fd18d", + "size": 161941595, + "subdir": "linux-64", + "timestamp": 1584491284483, + "version": "1.4.0" + }, + "pytorch-1.5.0-cpu_py37hd91cbb3_0.conda": { + "build": "cpu_py37hd91cbb3_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl 2019.*", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "ninja", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "17c6f859c87805feba25ce423c594fdb", + "name": "pytorch", + "sha256": "c52b12e0f9987f477df56e1a95572810c43d68404caca170281f4f2de7d88f83", + "size": 27883965, + "subdir": "linux-64", + "timestamp": 1591292143826, + "version": "1.5.0" + }, + "pytorch-1.7.1-cpu_py37h6a09485_0.conda": { + "build": "cpu_py37h6a09485_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libmklml", + "libstdcxx-ng >=7.3.0", + "mkl 2020.*", + "mkl >=2020.2,<2021.0a0", + "ninja", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "typing-extensions" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "183eb65cb54dc16ab271b6ec6db22f28", + "name": "pytorch", + "sha256": "884e61b882ed4112679346eaa5f95a36dd0058bbab59d0d6365fdf6b49806c13", + "size": 33131576, + "subdir": "linux-64", + "timestamp": 1614406266099, + "version": "1.7.1" + }, + "pytorch-1.7.1-cpu_py38h6a09485_0.conda": { + "build": "cpu_py38h6a09485_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libmklml", + "libstdcxx-ng >=7.3.0", + "mkl 2020.*", + "mkl >=2020.2,<2021.0a0", + "ninja", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "typing-extensions" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c01bb024acf2717ea07ceb973c4cb269", + "name": "pytorch", + "sha256": "32d8df61368afeeaf5fd4be31fe89e5fb73f49f0f65056c90c70bf9719ed34d9", + "size": 33259384, + "subdir": "linux-64", + "timestamp": 1614406246397, + "version": "1.7.1" + }, + "pytorch-1.7.1-cpu_py39h6a09485_0.conda": { + "build": "cpu_py39h6a09485_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.3.0", + "libmklml", + "libstdcxx-ng >=7.3.0", + "mkl 2020.*", + "mkl >=2020.2,<2021.0a0", + "ninja", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "typing-extensions" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "03c008fd54bdc7f79d2f4209bc0c5a21", + "name": "pytorch", + "sha256": "6bf5bb02c07ee2ffe892dfc069a7c71a99fd40619c745173e898ec31a5661164", + "size": 33260706, + "subdir": "linux-64", + "timestamp": 1622205443762, + "version": "1.7.1" + }, + "pytorch-1.8.1-cpu_py37h60491be_0.conda": { + "build": "cpu_py37h60491be_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.5.0", + "libmklml", + "libstdcxx-ng >=7.5.0", + "mkl 2020.*", + "mkl >=2020.2,<2021.0a0", + "ninja", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "44ee4c4363f955ebf4c9e38f5cc6c513", + "name": "pytorch", + "sha256": "c883a91e93062c9f9f49e51e0226d9fc757d386afa075968239f3d39acedc8a7", + "size": 36887850, + "subdir": "linux-64", + "timestamp": 1625261980653, + "version": "1.8.1" + }, + "pytorch-1.8.1-cpu_py38h60491be_0.conda": { + "build": "cpu_py38h60491be_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.5.0", + "libmklml", + "libstdcxx-ng >=7.5.0", + "mkl 2020.*", + "mkl >=2020.2,<2021.0a0", + "ninja", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "32853c0693d969f2d04f7174bbaa97d8", + "name": "pytorch", + "sha256": "ad4497bbd7cd18c8db8d252f6dd1ac08d6b62bc5c848cf6702883f5da0050c54", + "size": 37351535, + "subdir": "linux-64", + "timestamp": 1625255587986, + "version": "1.8.1" + }, + "pytorch-1.8.1-cpu_py39h60491be_0.conda": { + "build": "cpu_py39h60491be_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "_pytorch_select 0.1", + "blas 1.0 mkl", + "cffi", + "libgcc-ng >=7.5.0", + "libmklml", + "libstdcxx-ng >=7.5.0", + "mkl 2020.*", + "mkl >=2020.2,<2021.0a0", + "ninja", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "typing-extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ef242ed63051653a57b023a6458fa68c", + "name": "pytorch", + "sha256": "08acb8ac6848da4775d6cdb1faea5c103eb066f3bceabe5a048e0203fd08ccc6", + "size": 37968944, + "subdir": "linux-64", + "timestamp": 1625262053780, + "version": "1.8.1" + }, + "pytorch-cpu-1.2.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1.*", + "pytorch 1.2.0.*" + ], + "md5": "281f1a3a29d7292e3c505c7d438210d0", + "name": "pytorch-cpu", + "sha256": "f1ff49602d23e95e52fa1522cb2905ff7c05aedcda72876d493da78f537a8571", + "size": 2509, + "subdir": "linux-64", + "timestamp": 1566852987556, + "version": "1.2.0" + }, + "pytorch-cpu-1.3.1-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1.*", + "pytorch 1.3.1.*" + ], + "md5": "227990db479f54553c74f695ed9c448f", + "name": "pytorch-cpu", + "sha256": "591562ec6598cb66e408229121fec939ab02ba984099df0a6fb0a554649ba546", + "size": 2499, + "subdir": "linux-64", + "timestamp": 1574724994845, + "version": "1.3.1" + }, + "pytorch-gpu-1.2.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2.*", + "pytorch 1.2.0.*" + ], + "md5": "48567bb09500c8a81a3fa11f4cbf2d86", + "name": "pytorch-gpu", + "sha256": "8e1dec62016a9e43520772d898cd1ca64b87d5cc72017a4eb4afca3c72221ebd", + "size": 2510, + "subdir": "linux-64", + "timestamp": 1566853075104, + "version": "1.2.0" + }, + "pytorch-gpu-1.3.1-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2.*", + "pytorch 1.3.1.*" + ], + "md5": "fdd2fbd97ebd671afd4ea4b5ea7f5f4d", + "name": "pytorch-gpu", + "sha256": "e023ed8f0f4e08cca1228a1cec636258f79f0bb5e6b76e04d4fccb30280fcf16", + "size": 2506, + "subdir": "linux-64", + "timestamp": 1574725110836, + "version": "1.3.1" + }, + "pytorch-lightning-1.9.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec >2021.06.0", + "lightning-utilities >=0.6.0.post0", + "numpy >=1.17.2", + "packaging >=17.1", + "python >=3.10,<3.11.0a0", + "pytorch >=1.10.0", + "pyyaml >=5.4", + "torchmetrics >=0.7.0", + "tqdm >=4.57.0", + "typing-extensions >=4.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4ee74e07dd98d1e8b05707314ff9f07a", + "name": "pytorch-lightning", + "sha256": "59e8ae4e9f0bdf218b8aca354264b2804e115dc7582a04d2cbd2a6a0ffd825b4", + "size": 907238, + "subdir": "linux-64", + "timestamp": 1677759602127, + "version": "1.9.3" + }, + "pytorch-lightning-1.9.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec >2021.06.0", + "lightning-utilities >=0.6.0.post0", + "numpy >=1.17.2", + "packaging >=17.1", + "python >=3.8,<3.9.0a0", + "pytorch >=1.10.0", + "pyyaml >=5.4", + "torchmetrics >=0.7.0", + "tqdm >=4.57.0", + "typing-extensions >=4.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "87ca5be66c5665eb9a1d776d08e5977c", + "name": "pytorch-lightning", + "sha256": "a28ba7fc522e2a243ec84da9a2a7467f0bb403390b9c018053ae764f5f031719", + "size": 895868, + "subdir": "linux-64", + "timestamp": 1677759642965, + "version": "1.9.3" + }, + "pytorch-lightning-1.9.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec >2021.06.0", + "lightning-utilities >=0.6.0.post0", + "numpy >=1.17.2", + "packaging >=17.1", + "python >=3.9,<3.10.0a0", + "pytorch >=1.10.0", + "pyyaml >=5.4", + "torchmetrics >=0.7.0", + "tqdm >=4.57.0", + "typing-extensions >=4.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "70ab2f3515a00e5d0226c97b687d94b4", + "name": "pytorch-lightning", + "sha256": "e1c0870f45eccf8c19d9f65fedf8c748fcad71a42a61179ed94a04adb741205e", + "size": 895277, + "subdir": "linux-64", + "timestamp": 1677759556664, + "version": "1.9.3" + }, + "pytz-2017.2-py27hcac29fa_1.conda": { + "build": "py27hcac29fa_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "11d307081f9be7409c47ff29cdf1bba7", + "name": "pytz", + "sha256": "f21038aaae86da2564728e320307e8cd9d1d0258168772a6fded045eaccdfd00", + "size": 158059, + "subdir": "linux-64", + "timestamp": 1505691848966, + "version": "2017.2" + }, + "pytz-2017.2-py35h9225bff_1.conda": { + "build": "py35h9225bff_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "fec321d89f49d0d3658605b56fbec98a", + "name": "pytz", + "sha256": "6b4904ee31970982beff4475b44d70b0bba9dcaf199c412b1e5330e21480b481", + "size": 157891, + "subdir": "linux-64", + "timestamp": 1505691865400, + "version": "2017.2" + }, + "pytz-2017.2-py36hc2ccc2a_1.conda": { + "build": "py36hc2ccc2a_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0904fe6030ed3b7f984215833759edf1", + "name": "pytz", + "sha256": "5e12447f9a7f0a361ff1d1d9263d15f8e2539b594c4a1a6d3c7280928f217a68", + "size": 157418, + "subdir": "linux-64", + "timestamp": 1505691881888, + "version": "2017.2" + }, + "pytz-2017.3-py27h001bace_0.conda": { + "build": "py27h001bace_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "054fcc4d597667c105f9b763ce452d6f", + "name": "pytz", + "sha256": "219d941a51fb32cdce6706ca960ef9504302e5b215e7c05964381f971e9f5471", + "size": 181339, + "subdir": "linux-64", + "timestamp": 1511286615302, + "version": "2017.3" + }, + "pytz-2017.3-py35hb13c558_0.conda": { + "build": "py35hb13c558_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "628e80f0c4ea1dc2f8dab83c0f413ff3", + "name": "pytz", + "sha256": "d122f20ae5f6a894ad3f44d892a9e8fdff65ef0164f342dbabaae103987a566b", + "size": 183540, + "subdir": "linux-64", + "timestamp": 1511286623846, + "version": "2017.3" + }, + "pytz-2017.3-py36h63b9c63_0.conda": { + "build": "py36h63b9c63_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "5c65ba26126d800e2f2ed294fda31b60", + "name": "pytz", + "sha256": "aecb3ce502a23d3344036cda0e3ec7e078f250f56481cf16b2b6fe9d5ba8aad0", + "size": 180615, + "subdir": "linux-64", + "timestamp": 1511286626382, + "version": "2017.3" + }, + "pytz-2018.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "2f72d12ea318b0b2253aba86a383862b", + "name": "pytz", + "sha256": "29b8751092766f532c5f3c161d0c91766f384d5b32c241bd1e987f3f471eb7c1", + "size": 184824, + "subdir": "linux-64", + "timestamp": 1519020831186, + "version": "2018.3" + }, + "pytz-2018.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "850e93614525d0de5527154af9779d69", + "name": "pytz", + "sha256": "73fc650ebcc4543c1103d3f503554fa95e3c2cb0025a47b344d1c7f5317fbe0f", + "size": 184869, + "subdir": "linux-64", + "timestamp": 1519020846010, + "version": "2018.3" + }, + "pytz-2018.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "24eba5a77766438829f6c45d9949d03b", + "name": "pytz", + "sha256": "8ae57cb573937353bb404d45ce973c822c2599dd9b090d860f16a632442e665d", + "size": 181441, + "subdir": "linux-64", + "timestamp": 1519020847506, + "version": "2018.3" + }, + "pytz-2018.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "a8737e1c80d67a1df12683cbcaad8fae", + "name": "pytz", + "sha256": "97d954ec31ab66c1a467472fd5bb6f82558c9fe978e05b7fdd0b76350b7d88d0", + "size": 184029, + "subdir": "linux-64", + "timestamp": 1523903064639, + "version": "2018.4" + }, + "pytz-2018.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "c0abf8393fc059e129bb875c488469fb", + "name": "pytz", + "sha256": "7c49c7d365897121b35ee20e07b3a2d2704469bd08a7236e3faea31fdc039e4f", + "size": 183509, + "subdir": "linux-64", + "timestamp": 1523903064885, + "version": "2018.4" + }, + "pytz-2018.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "065720cd44384f144dbd7b9bdb25f962", + "name": "pytz", + "sha256": "26f4df55b0ef9dc5b06d37e7f4cc5e5bffa1d2ede183fe418fffc58f5ae424a7", + "size": 182738, + "subdir": "linux-64", + "timestamp": 1523903027075, + "version": "2018.4" + }, + "pytz-2018.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "0bb4de5de3ad0372807332d7c85511a3", + "name": "pytz", + "sha256": "48e61390df13a9b3d72623b1aae789e2fbbfb980903c789323d890154f729cee", + "size": 196842, + "subdir": "linux-64", + "timestamp": 1530592186578, + "version": "2018.5" + }, + "pytz-2018.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "df7f86095d327c50dee6f581980b5479", + "name": "pytz", + "sha256": "063cc8ce5402527245c879b66e3f34262f73af72da84f5fbf2bbe86fedd5a996", + "size": 201232, + "subdir": "linux-64", + "timestamp": 1530592198244, + "version": "2018.5" + }, + "pytz-2018.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "530b54c8a5fa31fd019a97f289a24853", + "name": "pytz", + "sha256": "49e7830ac3d54e5adf381cfeb1a57a8f1cb6132b8346e0b7961531897caddcfa", + "size": 197806, + "subdir": "linux-64", + "timestamp": 1530592209803, + "version": "2018.5" + }, + "pytz-2018.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4d06f527054221278b183d8ff721c3db", + "name": "pytz", + "sha256": "2e26e3fedf32ed2489797fa12abb38e2a7a8a32ce94111ddbc68706796f68eb9", + "size": 197992, + "subdir": "linux-64", + "timestamp": 1530695271270, + "version": "2018.5" + }, + "pytz-2018.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7c52583d98c940a2ba82ada9cacd5729", + "name": "pytz", + "sha256": "0f35bcb3b2e4329a67d6f57f27e99e612fe9cb363eb2378a5afa9d8bfa3b3f30", + "size": 195615, + "subdir": "linux-64", + "timestamp": 1541041402776, + "version": "2018.7" + }, + "pytz-2018.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "391867c2cce98c9ef1de0c17461ebd89", + "name": "pytz", + "sha256": "87740eea597063f9f1e147f4f838a65ab73b01c196f8edb830df588721f6c2eb", + "size": 197346, + "subdir": "linux-64", + "timestamp": 1541041469121, + "version": "2018.7" + }, + "pytz-2018.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4372029d1fd97cdd27a7d5d54640dac8", + "name": "pytz", + "sha256": "f3190f4f4c706524c651779df514d98690d00554e37a85131a3c279e06605705", + "size": 197333, + "subdir": "linux-64", + "timestamp": 1541041384966, + "version": "2018.7" + }, + "pytz-2018.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b3debc72896096b1b9c42f8797962f02", + "name": "pytz", + "sha256": "f5fc75a01b4d870e3dfaf7eb80d6d5f305bd55dcff1c72ab87900d7a323431e9", + "size": 201958, + "subdir": "linux-64", + "timestamp": 1547905268417, + "version": "2018.9" + }, + "pytz-2018.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e181f14fd7a2caa88dc2debe59802a7d", + "name": "pytz", + "sha256": "c20ffe6c134045e88be1b96349f4d7803b860b8776dc8852f0b85f8bc6dda265", + "size": 202587, + "subdir": "linux-64", + "timestamp": 1547905321991, + "version": "2018.9" + }, + "pytz-2018.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "dfda38654054a11b4973c1a5e763ad99", + "name": "pytz", + "sha256": "440746e199040f63da4751d133eee2a061ac395190a4ce3dff04dd4fc3e89647", + "size": 203550, + "subdir": "linux-64", + "timestamp": 1547905317162, + "version": "2018.9" + }, + "pytz-2022.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "fe274cb50d173dd987bed53af47f97bf", + "name": "pytz", + "sha256": "9743b8e6a710464c5dee046763735caf5cecdd75355b2dc9ec41c9cd416df066", + "size": 200388, + "subdir": "linux-64", + "timestamp": 1654762780409, + "version": "2022.1" + }, + "pytz-2022.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1091f291e7017a57e65819fc9dd048eb", + "name": "pytz", + "sha256": "b5d10ebdedaabdc51a7af08bcc307cbe4e4e39a96873b9e53af4e0b4a5ef36e6", + "size": 200845, + "subdir": "linux-64", + "timestamp": 1654762674993, + "version": "2022.1" + }, + "pytz-2022.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "d9e022584b586338e235e41a76ccc657", + "name": "pytz", + "sha256": "1459c7ac56cbe05c1a52ee61cd30650c42150940ed621fc9f5e10358112d6296", + "size": 200372, + "subdir": "linux-64", + "timestamp": 1654762737905, + "version": "2022.1" + }, + "pytz-2022.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "22e3e21898719bcf72d9b9a3490477b4", + "name": "pytz", + "sha256": "fe85dab72ba670fc9fc1aefce81e355b976b3ec33b387fcc4f45621a307d4cf4", + "size": 198609, + "subdir": "linux-64", + "timestamp": 1654762707763, + "version": "2022.1" + }, + "pytz-2022.7-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9fa82907692334494d14d7751ca0190", + "name": "pytz", + "sha256": "90736f2257bea1c0269d5382a25b9f081b3b36293df1d4c1d9957678298bb4bc", + "size": 213011, + "subdir": "linux-64", + "timestamp": 1671697464600, + "version": "2022.7" + }, + "pytz-2022.7-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "97637c3925dc85ac3cb42cd561f82f31", + "name": "pytz", + "sha256": "98a7ebcb5567620ec9184ff447d6c59d79ea2545ea401ac4c84b174185affefd", + "size": 200906, + "subdir": "linux-64", + "timestamp": 1676825017820, + "version": "2022.7" + }, + "pytz-2022.7-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "36f0f56591c619474740299e08bd0e87", + "name": "pytz", + "sha256": "0676048605c253ac7f9378ff5be890912ccd349e9b86022e82f450ba04c04c31", + "size": 211815, + "subdir": "linux-64", + "timestamp": 1671697523831, + "version": "2022.7" + }, + "pytz-2022.7-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "19c9f6a24d5c6f779c645d00f646666b", + "name": "pytz", + "sha256": "10d8a16a1d997c93ceb9dc94195c091dffcc32ec03186507b1faf443a7934c24", + "size": 214525, + "subdir": "linux-64", + "timestamp": 1671697494082, + "version": "2022.7" + }, + "pytz-2022.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "42b322e3f6795196a42b1c3ddbb7807b", + "name": "pytz", + "sha256": "b48d8763a8cc2042bde9891c1eb6ee5c332ab49b1ea375e1d057577fb982e7d4", + "size": 214805, + "subdir": "linux-64", + "timestamp": 1671697553820, + "version": "2022.7" + }, + "pyutilib-5.6-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "nose", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "e235049b0fba6083a6d29b4940d6a80a", + "name": "pyutilib", + "sha256": "70312a04f304544ac84b142839684164922fc95fb75d443201557a7a9cf07dad", + "size": 336061, + "subdir": "linux-64", + "timestamp": 1519484567143, + "version": "5.6" + }, + "pyutilib-5.6-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "nose", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "225f9185cd9dde1aaca42ad5c76b4567", + "name": "pyutilib", + "sha256": "fe229f00a6beaf242603ddfb695b0c8c3d712b5685059735af2c476ef4a90c0c", + "size": 339781, + "subdir": "linux-64", + "timestamp": 1519484609836, + "version": "5.6" + }, + "pyutilib-5.6-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "nose", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "503654ccbfb8b63d0f1762c98093921e", + "name": "pyutilib", + "sha256": "e9c51f1fc0739ce4c592bccf0e9c6d27e91be7ae204d4023a758d135dfa5b675", + "size": 338912, + "subdir": "linux-64", + "timestamp": 1519484556562, + "version": "5.6" + }, + "pyutilib-5.6.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "nose", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "a410174be36ca3f86171e87378fa2079", + "name": "pyutilib", + "sha256": "22f94413934cc7e13f8fcdaf5dd905b575e8ded022d94cbd327475a6f847679b", + "size": 340241, + "subdir": "linux-64", + "timestamp": 1522194699522, + "version": "5.6.2" + }, + "pyutilib-5.6.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "608e3a12aee5c37eed8f4dccfeb0f8a3", + "name": "pyutilib", + "sha256": "4e84a946e8760b71c6f79c82c7450ea2be5e8fd2db69fa215f7faeec0d8f95c2", + "size": 347215, + "subdir": "linux-64", + "timestamp": 1522194704423, + "version": "5.6.2" + }, + "pyutilib-5.6.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "66bf25f391bef4da18d0ecab5f68df87", + "name": "pyutilib", + "sha256": "dcec85083b16d1f56f00989c9c5a49fb287960a87e5ca6b053234b5f3c6c6ace", + "size": 342896, + "subdir": "linux-64", + "timestamp": 1522194710328, + "version": "5.6.2" + }, + "pyutilib-5.6.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "nose", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "39a6648dab901d4686322b32f87fd828", + "name": "pyutilib", + "sha256": "f963c52e0a3bdd25fa28f963a003df25fdc484af0364cf8980145276a2ad4557", + "size": 341029, + "subdir": "linux-64", + "timestamp": 1524087403245, + "version": "5.6.3" + }, + "pyutilib-5.6.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.5,<3.6.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "333857b0448f5b092f5d14e618f70d1e", + "name": "pyutilib", + "sha256": "201403e853957948fa925d82086be1a6bc175d0933bad8e3cdacbc9c3019a3c9", + "size": 348128, + "subdir": "linux-64", + "timestamp": 1524087410808, + "version": "5.6.3" + }, + "pyutilib-5.6.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "3b30b09903fd24b0c74e80ae572bd247", + "name": "pyutilib", + "sha256": "c8b11407abf9471a54a2ff9ee11d623bc60e9a996e733aa8d27ccf2e8d905c67", + "size": 340573, + "subdir": "linux-64", + "timestamp": 1524087404833, + "version": "5.6.3" + }, + "pyutilib-5.6.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "e9be29bf84f9098c4acefeecfbec6833", + "name": "pyutilib", + "sha256": "45050e37f377ccdba88eaac1ece2da0aa5e9de151c152c1cfc2daf7db45ab411", + "size": 340508, + "subdir": "linux-64", + "timestamp": 1530922988831, + "version": "5.6.3" + }, + "pyutilib-5.6.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "nose", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "4cda33d6a19ea2754ba52b6706697b48", + "name": "pyutilib", + "sha256": "28c53d2e21a25348c8733584c9627235736862511c8f46331b66ce110f6ce9dd", + "size": 350162, + "subdir": "linux-64", + "timestamp": 1547487930532, + "version": "5.6.4" + }, + "pyutilib-5.6.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "daffca9a819374452a53a5259c01bf42", + "name": "pyutilib", + "sha256": "09bb9936a24b1c24a365fa6dd1f014022323bffb5b8e500aa590490ddda7803b", + "size": 349580, + "subdir": "linux-64", + "timestamp": 1547487937754, + "version": "5.6.4" + }, + "pyutilib-5.6.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "db74e65cfe51c6db08b5d3e2d5c38a11", + "name": "pyutilib", + "sha256": "ba305b3c010902e28277553d9199f0a4fd593b7a06e734013614e36dc026bd0f", + "size": 353113, + "subdir": "linux-64", + "timestamp": 1547487954144, + "version": "5.6.4" + }, + "pyutilib-5.6.5-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "nose", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "370c3c0f5bde54aa4614d4ab73500d4b", + "name": "pyutilib", + "sha256": "02c3bade591ed7c3435c6b011c9670d0fcce3d22f59047542633026ffebef2bd", + "size": 350694, + "subdir": "linux-64", + "timestamp": 1550356024658, + "version": "5.6.5" + }, + "pyutilib-5.6.5-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "nose", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "cb16049d3a8fb77d40550dc1aec0dc41", + "name": "pyutilib", + "sha256": "cba4bbd5d15e01c72add417c353819a93cd0cbb1416fd750157f99526ea4cab1", + "size": 350078, + "subdir": "linux-64", + "timestamp": 1550356036272, + "version": "5.6.5" + }, + "pyutilib-5.6.5-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "nose", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "4f79bc949f48215a61378c5806aa1436", + "name": "pyutilib", + "sha256": "d9d84b25633258f40bd173a3da66022e83a90b7339d1398157a5962cad60152e", + "size": 353386, + "subdir": "linux-64", + "timestamp": 1550356017560, + "version": "5.6.5" + }, + "pyutilib-5.7.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "nose", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "cb856811516fc03203daf77ff302db40", + "name": "pyutilib", + "sha256": "b696b834b3139448e712f9257ed6036c30636b20ef5ed6626abac4d912469429", + "size": 352188, + "subdir": "linux-64", + "timestamp": 1569420560608, + "version": "5.7.1" + }, + "pyutilib-5.7.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "50ccacfaabc1a4be02f2e43cf21b7a7e", + "name": "pyutilib", + "sha256": "8b87aed406ff456c09819d9d083eab9b4c9bc50649b88450e7264ea11b1a69de", + "size": 354677, + "subdir": "linux-64", + "timestamp": 1569420564870, + "version": "5.7.1" + }, + "pyutilib-5.7.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "7490a1767850380945001a986f1d1c58", + "name": "pyutilib", + "sha256": "9453620fe5cbdf851d63e4c634b889702d786413536cccadbb5d06ebcc413f46", + "size": 354840, + "subdir": "linux-64", + "timestamp": 1569420564813, + "version": "5.7.1" + }, + "pyutilib-5.7.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "nose", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "7850ab35106bbecba0e9e45e7ba8b262", + "name": "pyutilib", + "sha256": "1e4107ec05a7c93d92efa925e202370c150886dec5b96a12c3847eca5508290c", + "size": 353587, + "subdir": "linux-64", + "timestamp": 1573972039900, + "version": "5.7.2" + }, + "pyutilib-5.7.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "33b94fdb8b7c0673229b9f60f9fa61d8", + "name": "pyutilib", + "sha256": "8cdd05adf26920bfb8c08c20785cc5c86aa9b97715b600bed498e0c0bb11c50b", + "size": 356098, + "subdir": "linux-64", + "timestamp": 1573972060745, + "version": "5.7.2" + }, + "pyutilib-5.7.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "9dfbf6f4448e5dce7f49a3e2b2ea9203", + "name": "pyutilib", + "sha256": "b6a4365f14e9aed293ff7b3bd0f0d4fda49d9571f0ebf7097404fee8cc067458", + "size": 356150, + "subdir": "linux-64", + "timestamp": 1573971993168, + "version": "5.7.2" + }, + "pyutilib-5.7.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "nose", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "BSD Clause", + "license_family": "BSD", + "md5": "8c55ad52cc7be4986358e214dfccce1d", + "name": "pyutilib", + "sha256": "f40fea6c09ffc1e5c3b8787b0b4dcc493516517747b7bce37564b4501e661cfc", + "size": 358582, + "subdir": "linux-64", + "timestamp": 1573972089061, + "version": "5.7.2" + }, + "pyviz_comms-0.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "param", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d07755aef7b63f395110c7ccad02278b", + "name": "pyviz_comms", + "sha256": "62f1d69a2828f2974c75496fa7ab59a11a77090d1410355e2ec80a6402379587", + "size": 12636, + "subdir": "linux-64", + "timestamp": 1527629242054, + "version": "0.1.1" + }, + "pyviz_comms-0.1.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "param", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "53a326126aafae8c29f3daf4e9e9d26a", + "name": "pyviz_comms", + "sha256": "2f6a969711c13dfe755bc0c5603d50018cedbe9100380409b432cdde3794306f", + "size": 12781, + "subdir": "linux-64", + "timestamp": 1527629288383, + "version": "0.1.1" + }, + "pyviz_comms-0.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "681723d75be3e4797a7cffac857d4124", + "name": "pyviz_comms", + "sha256": "1b3819b6ff2853bb9732c5f2117baff43d918e379dd25db5f4159e68eb50b356", + "size": 12695, + "subdir": "linux-64", + "timestamp": 1527629233185, + "version": "0.1.1" + }, + "pyviz_comms-0.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "param", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "06bba92faf93194f381bd3954f706c43", + "name": "pyviz_comms", + "sha256": "5fe354543722de77f10e1a7715b690ee37596485fe6f818f9e9e620b07fdb52a", + "size": 12795, + "subdir": "linux-64", + "timestamp": 1530892975365, + "version": "0.1.1" + }, + "pyviz_comms-0.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "param", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e4b124f18d2f60a371af26d89f811efd", + "name": "pyviz_comms", + "sha256": "fa04211bed1bc24f54341c1be117561c30300abc852fcf070b11efd15be928b0", + "size": 14672, + "subdir": "linux-64", + "timestamp": 1536114443354, + "version": "0.6.0" + }, + "pyviz_comms-0.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "param", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "442477e64920d4477a207890af36b42c", + "name": "pyviz_comms", + "sha256": "ed0399a99a99ff7ef5889e1c1240c89bd811e615023064406e04a24ab335b8ed", + "size": 14825, + "subdir": "linux-64", + "timestamp": 1536114260176, + "version": "0.6.0" + }, + "pyviz_comms-0.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4ce601ff34467b2f4a044f66d82a06fd", + "name": "pyviz_comms", + "sha256": "d1daa2f5878e22e88a6c2f1c87b28356ae6dcb81a6ef2b3ba4bbe057668033bd", + "size": 14794, + "subdir": "linux-64", + "timestamp": 1536114420857, + "version": "0.6.0" + }, + "pyviz_comms-0.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "param", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7722a82d6c8799e7c8990ffd928909a8", + "name": "pyviz_comms", + "sha256": "faf9f88f0b56a49c9d207902b6491f59702d42578b639baa56a9e0fcb96a39a8", + "size": 14847, + "subdir": "linux-64", + "timestamp": 1536114273293, + "version": "0.6.0" + }, + "pyviz_comms-0.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "param", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4ed4abd9d5dd18824154ae923b59e305", + "name": "pyviz_comms", + "sha256": "07669d4ad95310c427e6cb43d7b826b748666bc848165f4e5285c88c538caf46", + "size": 17854, + "subdir": "linux-64", + "timestamp": 1547983400551, + "version": "0.7.0" + }, + "pyviz_comms-0.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "param", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "afad6e2467357043d2939c599e3ebfc2", + "name": "pyviz_comms", + "sha256": "9728cd98b230e6c3825b4f5806a806d38c5e137e02142563e1f51a168c04bb24", + "size": 17941, + "subdir": "linux-64", + "timestamp": 1547983558521, + "version": "0.7.0" + }, + "pyviz_comms-0.7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "param", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4ee317a1f4dd3ec750dbfd8539a927ab", + "name": "pyviz_comms", + "sha256": "11adf200c387f4b03e97bb3f26740c66a2499f4eebaec813bc15e281e3a5e448", + "size": 17981, + "subdir": "linux-64", + "timestamp": 1547983480829, + "version": "0.7.0" + }, + "pywavelets-0.5.2-py27h035aef0_2.conda": { + "build": "py27h035aef0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f7350d2349981913ac998772fc4f9a4a", + "name": "pywavelets", + "sha256": "bd5a84d6aa6efaab10f20089c15371ca5ad724cef7899add3d5140af4e061ff9", + "size": 3236231, + "subdir": "linux-64", + "timestamp": 1530810053198, + "version": "0.5.2" + }, + "pywavelets-0.5.2-py27hecda097_0.conda": { + "build": "py27hecda097_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9b763804eb5901e6d49589f48b01acdf", + "name": "pywavelets", + "sha256": "fb9ac50b1e5bcd47c892681c2a044b2470d1183e8179985057720288a7048a6c", + "size": 3251449, + "subdir": "linux-64", + "timestamp": 1505863575761, + "version": "0.5.2" + }, + "pywavelets-0.5.2-py35h035aef0_2.conda": { + "build": "py35h035aef0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "d3d717665c1c811fa1fc657bb67ea7ed", + "name": "pywavelets", + "sha256": "db8f369d0ea58efdc5f9bca7494952d9b5696efc4af1757809684c45563f6d2f", + "size": 3231264, + "subdir": "linux-64", + "timestamp": 1535129508969, + "version": "0.5.2" + }, + "pywavelets-0.5.2-py35h53ec731_0.conda": { + "build": "py35h53ec731_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "9f7c6a5237ad078e0126f716570f349c", + "name": "pywavelets", + "sha256": "bd06e7b74d769e31e445464979e7ad5db3a1df795f939aa1f2ae24b46033debb", + "size": 3240061, + "subdir": "linux-64", + "timestamp": 1505863675983, + "version": "0.5.2" + }, + "pywavelets-0.5.2-py36h035aef0_2.conda": { + "build": "py36h035aef0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ab163c6e158017625e54b77416a587fc", + "name": "pywavelets", + "sha256": "cbcb0633ddccd52dd30aec85be49dbbcf5d9eea8aa26cdb080429ddbbbfd242d", + "size": 3235131, + "subdir": "linux-64", + "timestamp": 1530810927307, + "version": "0.5.2" + }, + "pywavelets-0.5.2-py36he602eb0_0.conda": { + "build": "py36he602eb0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b187deb210c8684f1b26d153b22b8335", + "name": "pywavelets", + "sha256": "9f89ea16cc4c77e3394cbbc15ead4101840e31ecbfb1a2ac71e7625b1ead3558", + "size": 3245054, + "subdir": "linux-64", + "timestamp": 1505863779794, + "version": "0.5.2" + }, + "pywavelets-0.5.2-py37h035aef0_2.conda": { + "build": "py37h035aef0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "543866ec6f2e7457d029a64f2e6dcebb", + "name": "pywavelets", + "sha256": "8112d45dd66112696105177a19e0eecf5476815664090a75d97733d3db58fb78", + "size": 3237965, + "subdir": "linux-64", + "timestamp": 1530810802825, + "version": "0.5.2" + }, + "pywavelets-1.0.0-py27hdd07704_0.conda": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "62ab0d3ba2df1b150980067cc6b2fa6a", + "name": "pywavelets", + "sha256": "598fcc647c51ceefc9c043bf382c0e4ca3b4f5cb0348ee0f3e3c89f0057ec0fd", + "size": 3653475, + "subdir": "linux-64", + "timestamp": 1536084725785, + "version": "1.0.0" + }, + "pywavelets-1.0.0-py35hdd07704_0.conda": { + "build": "py35hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "3ad6b93a73ec034730832396c044f9a9", + "name": "pywavelets", + "sha256": "b0be6dcdf20901723a48a853e2321ae73ad20c892c27fa6f3462d4503e6a2bb0", + "size": 3652467, + "subdir": "linux-64", + "timestamp": 1536084725614, + "version": "1.0.0" + }, + "pywavelets-1.0.0-py36hdd07704_0.conda": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "791ba352cc519184ff5037918e99d397", + "name": "pywavelets", + "sha256": "69f99cadd34a9e7b600690a7d0eb36b7a2771e870fbe75986ab5fc579e2844df", + "size": 3649934, + "subdir": "linux-64", + "timestamp": 1536085396231, + "version": "1.0.0" + }, + "pywavelets-1.0.0-py37hdd07704_0.conda": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "0b664e0dd222a5c24716f097020ae9ac", + "name": "pywavelets", + "sha256": "f0281b1ebdb7375d1e5c72773d47a850df3f034bd0123c0c6f582856afc7bdba", + "size": 3649695, + "subdir": "linux-64", + "timestamp": 1536084578647, + "version": "1.0.0" + }, + "pywavelets-1.0.1-py27hdd07704_0.conda": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "dca08d169a6cb69468358e415af6ed15", + "name": "pywavelets", + "sha256": "fe096ce98bd771c8ecb6b2e05be2c042a527334772d3a640707061cd6984545e", + "size": 3656102, + "subdir": "linux-64", + "timestamp": 1538600658619, + "version": "1.0.1" + }, + "pywavelets-1.0.1-py36hdd07704_0.conda": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "8fbaa73035a1656d52203263a83c6051", + "name": "pywavelets", + "sha256": "01153bc1a07268b0ce8bc336c5aad526bf9610344aa75c83787a6ec3ca0c4826", + "size": 3660140, + "subdir": "linux-64", + "timestamp": 1538600640316, + "version": "1.0.1" + }, + "pywavelets-1.0.1-py37hdd07704_0.conda": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a50f601e7bb5c71a1622148ed817dcf4", + "name": "pywavelets", + "sha256": "6ea5f783d25fcb3bc42c054a4c2c09c80335944e83d53a3785c54be785ee82a4", + "size": 3661420, + "subdir": "linux-64", + "timestamp": 1538600635929, + "version": "1.0.1" + }, + "pywavelets-1.0.2-py27hdd07704_0.conda": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d2d12920b269d386a17f68492d830f7c", + "name": "pywavelets", + "sha256": "11f8575a239f9760a7272c26b0ac2e838e5a4750f07b4494f5c5bca2f783fa86", + "size": 3655197, + "subdir": "linux-64", + "timestamp": 1552335592357, + "version": "1.0.2" + }, + "pywavelets-1.0.2-py36hdd07704_0.conda": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3f8bf0e0b6c57d83c1f8472f8c7299ec", + "name": "pywavelets", + "sha256": "b799e60501c8f47744a0d058c0ea33ddf12fd83eeaf7d19a58e67917d285963b", + "size": 3674009, + "subdir": "linux-64", + "timestamp": 1552335560172, + "version": "1.0.2" + }, + "pywavelets-1.0.2-py37hdd07704_0.conda": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "cd860f604b7a07bfe2f3928bd820cbda", + "name": "pywavelets", + "sha256": "ddb731b315f1aa0d7b3dff3fe7263344d6ba0b87aba9e743646ddf94e7971f3d", + "size": 3671450, + "subdir": "linux-64", + "timestamp": 1552335588610, + "version": "1.0.2" + }, + "pywavelets-1.0.3-py27hdd07704_1.conda": { + "build": "py27hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c587083afae5395eec8b50ed5dc30f66", + "name": "pywavelets", + "sha256": "dcbc8d2562e70eede15fecfcd9066bde4031b5008ee3a698a1a78995746a8594", + "size": 3659508, + "subdir": "linux-64", + "timestamp": 1555432028425, + "version": "1.0.3" + }, + "pywavelets-1.0.3-py36hdd07704_1.conda": { + "build": "py36hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "09dc39ef03e035af93387b39602a73ca", + "name": "pywavelets", + "sha256": "43084865b1abb62696c8bfcba569487584988f2188254118e1851c1efb8120fc", + "size": 3675339, + "subdir": "linux-64", + "timestamp": 1555432087576, + "version": "1.0.3" + }, + "pywavelets-1.0.3-py37hdd07704_1.conda": { + "build": "py37hdd07704_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "9e395549a9133d44ef0a628bc52df8d2", + "name": "pywavelets", + "sha256": "d2cb17160a204751c1488e314fe2add02a253aa38bc2a8e05f3155d1437d4e01", + "size": 3663928, + "subdir": "linux-64", + "timestamp": 1555431923468, + "version": "1.0.3" + }, + "pywavelets-1.1.1-py310h9102076_4.conda": { + "build": "py310h9102076_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "222b4878a3a526959c3d30c519839989", + "name": "pywavelets", + "sha256": "928dfb91bea6459108fe4fea9d037507290f61e149d8d5c31e163648e971f81c", + "size": 4887096, + "subdir": "linux-64", + "timestamp": 1641402918394, + "version": "1.1.1" + }, + "pywavelets-1.1.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "974bb5ed62e8d4477a9eb1883a7d85e3", + "name": "pywavelets", + "sha256": "c62bd094f589f209782f7049b667bb7efb33202ff01481dbbd50af87e8954e1f", + "size": 3696536, + "subdir": "linux-64", + "timestamp": 1571765103922, + "version": "1.1.1" + }, + "pywavelets-1.1.1-py36h7b6447c_2.conda": { + "build": "py36h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "01e69eadf186d1300629d448afc328d2", + "name": "pywavelets", + "sha256": "ed6be489153c9259393a2582be217222bb94aba3e7a71d922457c31bbddb856f", + "size": 3626006, + "subdir": "linux-64", + "timestamp": 1601658449178, + "version": "1.1.1" + }, + "pywavelets-1.1.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "eef0d97c745eb051250332fa11db050f", + "name": "pywavelets", + "sha256": "87ddbc7ecdb9aa808c292fd300040e5e58a89675a6a3cb9b9c95a62410dd0c39", + "size": 3688025, + "subdir": "linux-64", + "timestamp": 1571765137860, + "version": "1.1.1" + }, + "pywavelets-1.1.1-py37h7b6447c_2.conda": { + "build": "py37h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "719485435a01d0d5335d323d7b62fe00", + "name": "pywavelets", + "sha256": "e07606860e86218203cd61f4861a5163785fcef6e42e3505845bb8cdb8b741e7", + "size": 3622105, + "subdir": "linux-64", + "timestamp": 1601658464940, + "version": "1.1.1" + }, + "pywavelets-1.1.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "082cb69cfbf78c0819a826699bb42010", + "name": "pywavelets", + "sha256": "34c7e654ee5caf13fe05882ca5c8cf1f63a9971a9b0646b557d78e3e4ca97acb", + "size": 3708466, + "subdir": "linux-64", + "timestamp": 1574081646167, + "version": "1.1.1" + }, + "pywavelets-1.1.1-py38h7b6447c_2.conda": { + "build": "py38h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "b81b77842f5305cc880459cc095d9374", + "name": "pywavelets", + "sha256": "5202595e71886ccf849a08b110ae1e416767e3bd76f14049d6754d3c46ab10a4", + "size": 3648679, + "subdir": "linux-64", + "timestamp": 1601658411352, + "version": "1.1.1" + }, + "pywavelets-1.1.1-py39h6323ea4_4.conda": { + "build": "py39h6323ea4_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "c49286df5aedb5ebce59011540481af2", + "name": "pywavelets", + "sha256": "3e1a63498a97a182d8446f3a68958d8229c9e183c487968ffdf711b4bd83eda4", + "size": 3662438, + "subdir": "linux-64", + "timestamp": 1607645549721, + "version": "1.1.1" + }, + "pywavelets-1.3.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7793dc01a29939b71f0c3a72b12f942d", + "name": "pywavelets", + "sha256": "ff4ffb9ce323464062def948689356df4498c949948759c9af376d8602813707", + "size": 4921715, + "subdir": "linux-64", + "timestamp": 1648728001975, + "version": "1.3.0" + }, + "pywavelets-1.3.0-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.18.5,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3615442e23f3eceb724d0ec322c1361f", + "name": "pywavelets", + "sha256": "0ac4b6ee0c498711ab1978088bafaba6dc42547c9390d583314d5ca252c3c3b3", + "size": 3655312, + "subdir": "linux-64", + "timestamp": 1648727979242, + "version": "1.3.0" + }, + "pywavelets-1.3.0-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.18.5,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e82c8fa9f3829ecd054bf24a35932d1d", + "name": "pywavelets", + "sha256": "11933bdd2cdfa44455beb1d9f4dfccf32cc07d1e1132cba8b2c5b533290b2ee9", + "size": 3670014, + "subdir": "linux-64", + "timestamp": 1648710217877, + "version": "1.3.0" + }, + "pywavelets-1.3.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "082776699488ee757ca163e43c2839d5", + "name": "pywavelets", + "sha256": "e30b0e54cad127e0bb0662eafe85b2194e30c4454ef6bcf534b7195ca685a3cb", + "size": 3672292, + "subdir": "linux-64", + "timestamp": 1648710116430, + "version": "1.3.0" + }, + "pywavelets-1.4.1-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7bc7d9e665fa85d9e555c0973ef6428b", + "name": "pywavelets", + "sha256": "72a2adef2834a58e54687c642eb898e15f36bb0c8d5c7f8c41ba6f58565e9b1f", + "size": 3805268, + "subdir": "linux-64", + "timestamp": 1670425632673, + "version": "1.4.1" + }, + "pywavelets-1.4.1-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d240da321d53fb4a6eee8a018d0fba22", + "name": "pywavelets", + "sha256": "f481649b6d05824f27f33355900b9c1bf8c22ab4f940b7187f6f9f7d20080f08", + "size": 3703241, + "subdir": "linux-64", + "timestamp": 1676838743968, + "version": "1.4.1" + }, + "pywavelets-1.4.1-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.18.5,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca7d90c2f7294af74c5aa04147aba380", + "name": "pywavelets", + "sha256": "add22c3b9514e7025297579466da8dd4b214dd90efc8827457eaef431063c418", + "size": 3824538, + "subdir": "linux-64", + "timestamp": 1670425446417, + "version": "1.4.1" + }, + "pywavelets-1.4.1-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "715ba9d5b9299d0874aa1e8b6359f806", + "name": "pywavelets", + "sha256": "4a1911c5d52721dda520aa96de259df26e16c6582a623e4b00410d35046a33ff", + "size": 3816946, + "subdir": "linux-64", + "timestamp": 1670425256409, + "version": "1.4.1" + }, + "pywget-3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Public-Domain", + "md5": "92a7feb835caa622d3df4d7fc96f237b", + "name": "pywget", + "sha256": "66545ac3a800de98c142382ed8949a6328aa176e017f29bd28cf0580c8b376dd", + "size": 18302, + "subdir": "linux-64", + "timestamp": 1524522443759, + "version": "3.2" + }, + "pywget-3.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Public-Domain", + "md5": "369cd6c1dfd1e27d3d37ad4d258e4a9c", + "name": "pywget", + "sha256": "e38d56761bd329d0ecaee7c66fe5ceb573b38387637e8b769906ca85cd0babc5", + "size": 18438, + "subdir": "linux-64", + "timestamp": 1640794060827, + "version": "3.2" + }, + "pywget-3.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Public-Domain", + "md5": "c54720b09bc3c25263d493d8a2d6fd3c", + "name": "pywget", + "sha256": "c819183d6b38e398999b7257941b7e491d4f4007d20699c4024b2801607d12f1", + "size": 23559, + "subdir": "linux-64", + "timestamp": 1676907629642, + "version": "3.2" + }, + "pywget-3.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Public-Domain", + "md5": "5e61c2d79690bbeb06cf5980d5644e10", + "name": "pywget", + "sha256": "a22994c46f79d7d333e5c4cf4a9d75f27164b00b2dd5b3d28cd97c62cca1972d", + "size": 18608, + "subdir": "linux-64", + "timestamp": 1524522447749, + "version": "3.2" + }, + "pywget-3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public-Domain", + "md5": "0843a3edec0c7e9d94c69a939459c6ce", + "name": "pywget", + "sha256": "fa34bf0dbc66889719a3a3200f636e993402622c7a2575d06f890d9041622d99", + "size": 18273, + "subdir": "linux-64", + "timestamp": 1524522281107, + "version": "3.2" + }, + "pywget-3.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Public-Domain", + "md5": "f33a28ea6f51b07307640e44d7b33a5b", + "name": "pywget", + "sha256": "b5022c9e4baedbb64c3f9c243f19a700a3161c1ebaacf8a09a88b0fcfd54ad77", + "size": 260800, + "subdir": "linux-64", + "timestamp": 1614082665246, + "version": "3.2" + }, + "pywget-3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public-Domain", + "md5": "8cd68d0d0533afbab3a907808d67cf89", + "name": "pywget", + "sha256": "74a6697ac07758898841bccb35dbc73cf54a52747c1b5244eb013cd6ae53644d", + "size": 18238, + "subdir": "linux-64", + "timestamp": 1530923026564, + "version": "3.2" + }, + "pywget-3.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Public-Domain", + "md5": "614ef07c7410131ed6100d80da24ca63", + "name": "pywget", + "sha256": "2a3089a3b0168f6a6b4b55b39d49489390bfe9a22814051d6a5f8c9897dea495", + "size": 260951, + "subdir": "linux-64", + "timestamp": 1614082672214, + "version": "3.2" + }, + "pywget-3.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Public-Domain", + "md5": "f4ff6c56086601e8ac7e14b7cd05cc8b", + "name": "pywget", + "sha256": "c572b9dc320778629f749ebadba82d1f993775eba12d0d2943209927d63661e6", + "size": 18696, + "subdir": "linux-64", + "timestamp": 1573200322104, + "version": "3.2" + }, + "pywget-3.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Public-Domain", + "md5": "acfe812542d7c4616c698fff23352e1e", + "name": "pywget", + "sha256": "d0761d05c405ffa8716bc61144183b5b752e261363242c7185897913fbe1cff4", + "size": 262293, + "subdir": "linux-64", + "timestamp": 1614081743260, + "version": "3.2" + }, + "pyyaml-3.12-py27h14c3975_1.conda": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6a4b799b54f55f20b2910aca85f93e7", + "name": "pyyaml", + "sha256": "47e8c6a33b762e6af7d0fdea163f1d9129049b6a62cbcef014d2aaa4e23e8ffe", + "size": 169432, + "subdir": "linux-64", + "timestamp": 1530737233725, + "version": "3.12" + }, + "pyyaml-3.12-py27h2d70dd7_1.conda": { + "build": "py27h2d70dd7_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f345aacb0559f86eda913d7177238eb", + "name": "pyyaml", + "sha256": "c189c92dacc172ddd31f44ac9cc9ebdfd2eb56547c3d40ed1b11e95e6e632803", + "size": 156197, + "subdir": "linux-64", + "timestamp": 1505739670245, + "version": "3.12" + }, + "pyyaml-3.12-py35h46ef4ae_1.conda": { + "build": "py35h46ef4ae_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff727ca4ad2a45b0c4ab497f0b0620ef", + "name": "pyyaml", + "sha256": "f9ececdc979a370c05ae8dc149ab27ddea33dad69804094494cc3d9689dd419a", + "size": 156105, + "subdir": "linux-64", + "timestamp": 1505739698606, + "version": "3.12" + }, + "pyyaml-3.12-py36h14c3975_1.conda": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "255d2f4eebf9441ed23843197aab5046", + "name": "pyyaml", + "sha256": "e95c2009294e49530bbaa207a502460a1099dda5b795ee7b6e6df401a5631757", + "size": 173384, + "subdir": "linux-64", + "timestamp": 1530737192771, + "version": "3.12" + }, + "pyyaml-3.12-py36hafb9ca4_1.conda": { + "build": "py36hafb9ca4_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bf410dd2ac28ffc1492dd614fc13d29b", + "name": "pyyaml", + "sha256": "b5fb38c5ccca5d6242a88e8e13db8f7c92ad95468859d8c716b774a649849ed0", + "size": 154975, + "subdir": "linux-64", + "timestamp": 1505739726977, + "version": "3.12" + }, + "pyyaml-3.12-py37h14c3975_1.conda": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f414ba7d2d736f52757f1e53b6dfae63", + "name": "pyyaml", + "sha256": "ff3e18935c035cb563c25ffd491f5b1351a2756f67db75a4d7ea4b9593088b7b", + "size": 172117, + "subdir": "linux-64", + "timestamp": 1530737275158, + "version": "3.12" + }, + "pyyaml-3.13-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "24593c51fd2fdc9ef6a0a2aa70fa4fe2", + "name": "pyyaml", + "sha256": "14c713eb3df6c10c3c53ab57af36d8d07c047715cc7dcd32d46f7754372b9c1c", + "size": 169361, + "subdir": "linux-64", + "timestamp": 1532442760271, + "version": "3.13" + }, + "pyyaml-3.13-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74b65b80ee831cd10e7db6103793ad36", + "name": "pyyaml", + "sha256": "9d61ffb7ea4b8f292ff703897e26cc7c0cc8ecd3335ceb8d816463b8904fb972", + "size": 169760, + "subdir": "linux-64", + "timestamp": 1532442618167, + "version": "3.13" + }, + "pyyaml-3.13-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "208d71d3eed7126a3ffc43d5134ab1b5", + "name": "pyyaml", + "sha256": "de64e2daae2a6cd675395ab8b4c10d90e58b8e3cc6d26b80380f3fe6beaeaefd", + "size": 172792, + "subdir": "linux-64", + "timestamp": 1532442758558, + "version": "3.13" + }, + "pyyaml-3.13-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "69060f16ec7648cec405e9e147ed085f", + "name": "pyyaml", + "sha256": "88fc7e4dd25fd91a10287338f595a84772100eec75e2d4248f60cbd36ff10133", + "size": 172026, + "subdir": "linux-64", + "timestamp": 1532442799049, + "version": "3.13" + }, + "pyyaml-5.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a710c1b239f7f231041623218e00be3f", + "name": "pyyaml", + "sha256": "4c430f0fdc97d50fdd5664125cb2e395442721a31d4917e41ec49c081e6c3f6a", + "size": 173092, + "subdir": "linux-64", + "timestamp": 1552926804381, + "version": "5.1" + }, + "pyyaml-5.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "447dcc8e188c5792d1f8fd95fcfe4f1b", + "name": "pyyaml", + "sha256": "d004b700a736e9da3a9e6c6af232c5fab11acb6ab6f21451f6eb3dd44f297d10", + "size": 182214, + "subdir": "linux-64", + "timestamp": 1552926815925, + "version": "5.1" + }, + "pyyaml-5.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db2013a18e83974a0d59cc01fec0c03c", + "name": "pyyaml", + "sha256": "5af7f0354565f0ab31d84255399e4089b461d98f63ab9f8539f297e10c773ea1", + "size": 181702, + "subdir": "linux-64", + "timestamp": 1552926817790, + "version": "5.1" + }, + "pyyaml-5.1.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "65c8caa3f7d79651d5ebf91d09e7abfe", + "name": "pyyaml", + "sha256": "6862288d7c0cd63e80e55c17ebf02e41453f4a70bdf5ef24ec84826fb84cb106", + "size": 172935, + "subdir": "linux-64", + "timestamp": 1562081350407, + "version": "5.1.1" + }, + "pyyaml-5.1.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2af283ea36208c4ef8ec8f3c7f3b2aec", + "name": "pyyaml", + "sha256": "c94715dd1fd260e367808be197e3b8377394d246eaed89c0dfec80d4593c37e5", + "size": 182100, + "subdir": "linux-64", + "timestamp": 1562081352963, + "version": "5.1.1" + }, + "pyyaml-5.1.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b90a9fc4b13e12052f54c188d6769a75", + "name": "pyyaml", + "sha256": "9b05cf04dc8c6d08069185fadbcd38bd244eea3e4eca6fd25594c1edb44017f6", + "size": 181702, + "subdir": "linux-64", + "timestamp": 1562081337303, + "version": "5.1.1" + }, + "pyyaml-5.1.2-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e806b4de078ae88613a4e89b9b167bc0", + "name": "pyyaml", + "sha256": "25177a83797891177c3d09f33c36ab31e05dfd332cb738b2c8b0bbc624103498", + "size": 172993, + "subdir": "linux-64", + "timestamp": 1565957135920, + "version": "5.1.2" + }, + "pyyaml-5.1.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "04d21a1ca59a7ccccd819e0dfa34953c", + "name": "pyyaml", + "sha256": "9af2f40a425c8703ac67e96a2482baad8783c3cc1d66f776abf4f82ed8b7f8be", + "size": 183750, + "subdir": "linux-64", + "timestamp": 1565957466529, + "version": "5.1.2" + }, + "pyyaml-5.1.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c66a26d96220483df19541c3bcb6793", + "name": "pyyaml", + "sha256": "8071f6295b628a7df045260c3686450119e6814629252f7103b9c5e3dd46c2b6", + "size": 183472, + "subdir": "linux-64", + "timestamp": 1565957415311, + "version": "5.1.2" + }, + "pyyaml-5.1.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "20803e6e26dabb67afb486ad79d8debe", + "name": "pyyaml", + "sha256": "6a827263c079fb4095b4840463456aee49b7773a4030e4a9a59be8e557b57196", + "size": 183933, + "subdir": "linux-64", + "timestamp": 1573200443086, + "version": "5.1.2" + }, + "pyyaml-5.2-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4b18ff499b453fd69eff2cef15ae722a", + "name": "pyyaml", + "sha256": "cdf9d44cd5ae0d087a629cbf76694f2d557e62dff5b315f587174feb7b0c0445", + "size": 174656, + "subdir": "linux-64", + "timestamp": 1576512808904, + "version": "5.2" + }, + "pyyaml-5.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "639385d90462778767f8fca9e77fe046", + "name": "pyyaml", + "sha256": "f4ea6352b566e0e1f42edbf61df867015510bd91d05bb029fb01ad5f552334d1", + "size": 184555, + "subdir": "linux-64", + "timestamp": 1576512804269, + "version": "5.2" + }, + "pyyaml-5.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0ce2f88b5127adb33b4e80c68bb30a4b", + "name": "pyyaml", + "sha256": "f335f14f29cfd9967eaed29f4605053ae14b13d383c763393f20ea2a3098e548", + "size": 184873, + "subdir": "linux-64", + "timestamp": 1576512808141, + "version": "5.2" + }, + "pyyaml-5.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8afb18eba0d5d06ee389515a0b12b9af", + "name": "pyyaml", + "sha256": "6cf4370c695189746fb2c0320f11520cb4f30d7864deec6e9fbdb32f27701d31", + "size": 188468, + "subdir": "linux-64", + "timestamp": 1576512816056, + "version": "5.2" + }, + "pyyaml-5.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bcef85ccf24c9a7343fbfe66c0099a22", + "name": "pyyaml", + "sha256": "e55f07221acc84abe0490a0e9dd753e851aaad9402846f14a03102a6e670bad8", + "size": 184466, + "subdir": "linux-64", + "timestamp": 1580834727945, + "version": "5.3" + }, + "pyyaml-5.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d318147ab8041fde56544bb265e1f7b", + "name": "pyyaml", + "sha256": "5cc431829854f5f2fdb8bd7c368d1cafcac75ff458ebb72c1db65209a4145b48", + "size": 184003, + "subdir": "linux-64", + "timestamp": 1580834750049, + "version": "5.3" + }, + "pyyaml-5.3-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef8ba73639a49e918dcf02f8b76afea0", + "name": "pyyaml", + "sha256": "edaaf7041d634d438694025a017e67a3c65c3d756a73b70edaa3ab289d60b996", + "size": 189480, + "subdir": "linux-64", + "timestamp": 1580834719606, + "version": "5.3" + }, + "pyyaml-5.3.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d060c5fc63d2a533370729f37b1a62fe", + "name": "pyyaml", + "sha256": "240c644a27af21a3d84b7fe65aeca1b00c30cae6c0855f5778b6b0b515d96419", + "size": 184479, + "subdir": "linux-64", + "timestamp": 1584979028015, + "version": "5.3.1" + }, + "pyyaml-5.3.1-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da6df49aa601d7f20e31bc8b82cd880c", + "name": "pyyaml", + "sha256": "e36113d387f8eb9dac747cb0a9f6af1119126bd428154f316e60bcb71e4e0310", + "size": 184297, + "subdir": "linux-64", + "timestamp": 1593124650570, + "version": "5.3.1" + }, + "pyyaml-5.3.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "79d8aeb2e849b51498a7e711362ee36e", + "name": "pyyaml", + "sha256": "35e63c7fd64c934e65f49c038fc3eb085200a250e148174ec7902f831c6e7001", + "size": 185830, + "subdir": "linux-64", + "timestamp": 1584979030736, + "version": "5.3.1" + }, + "pyyaml-5.3.1-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6551377a35638e39b5c9cf92c870de27", + "name": "pyyaml", + "sha256": "bf726398e9aa44013e73698a9241ad99c8a14362af2effcd5c370e489c079a68", + "size": 184792, + "subdir": "linux-64", + "timestamp": 1593124652283, + "version": "5.3.1" + }, + "pyyaml-5.3.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1486cc443690e1b3934be89fa8378fc6", + "name": "pyyaml", + "sha256": "8ad7ce67e572459e0b78946174c788ccdaf6ccf1d2bb2bc3069e6ac368fd439e", + "size": 189559, + "subdir": "linux-64", + "timestamp": 1584979033384, + "version": "5.3.1" + }, + "pyyaml-5.3.1-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13572270cd3f42590968ce4885dc2e04", + "name": "pyyaml", + "sha256": "3e1c3364d36706c4b789b96b8ebfabd588623d642d80dd259805af5bab798b53", + "size": 189573, + "subdir": "linux-64", + "timestamp": 1593124661521, + "version": "5.3.1" + }, + "pyyaml-5.3.1-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "57c46b97e4c035f311ad576be95078db", + "name": "pyyaml", + "sha256": "6c473802280e73fea734cc217e1f748b55d35f8349afa5163541740750f48f03", + "size": 189133, + "subdir": "linux-64", + "timestamp": 1607027947333, + "version": "5.3.1" + }, + "pyyaml-5.4-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cba87fc91d3df7a1eda20a0e3f3f91ce", + "name": "pyyaml", + "sha256": "5d4f4c202ea2fb11a268e89ba706ebed9d0a7d271f776b342d024b7c2d92569c", + "size": 173785, + "subdir": "linux-64", + "timestamp": 1611172339259, + "version": "5.4" + }, + "pyyaml-5.4-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1487dc9d1858e7672c90f633078de634", + "name": "pyyaml", + "sha256": "5d6d85e97b522a80a8b421af39d70587cf3a05b66b19bcdb0bcd7c05242365b6", + "size": 172517, + "subdir": "linux-64", + "timestamp": 1611172365409, + "version": "5.4" + }, + "pyyaml-5.4-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bf662a0f0c217ca20a74dc83bff01791", + "name": "pyyaml", + "sha256": "31bf550e2c63f63ba72c2f60ebc617308d918b4c30f27d6fcf7fd1b403d312ab", + "size": 176418, + "subdir": "linux-64", + "timestamp": 1611172275378, + "version": "5.4" + }, + "pyyaml-5.4-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dcce600be20ae47fc41c03f729c22519", + "name": "pyyaml", + "sha256": "03c6455f52e8594489cf8655af00dcf63cf273266064485cea5103ce8a8ea3da", + "size": 179319, + "subdir": "linux-64", + "timestamp": 1611172361382, + "version": "5.4" + }, + "pyyaml-5.4.1-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d502fe9b4b9157f8d0502f476d17d1e9", + "name": "pyyaml", + "sha256": "ecf74ae78a4b00bca99e1ab676ec4b511ff39f414416773855465ebb9e1b2bbb", + "size": 173711, + "subdir": "linux-64", + "timestamp": 1611258435880, + "version": "5.4.1" + }, + "pyyaml-5.4.1-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0817a039f959290ce939735cd14dd0ac", + "name": "pyyaml", + "sha256": "6281f702fdf6092330d0d0a49d786e9e31185c4aab1551f4037505fba65b529a", + "size": 172521, + "subdir": "linux-64", + "timestamp": 1611258452869, + "version": "5.4.1" + }, + "pyyaml-5.4.1-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15a40db13c8d4ce97939fe256c6c50bf", + "name": "pyyaml", + "sha256": "9d3c901280e6e6fa33d90f94669cee9c0463a176b1c4dc0c6bb7cf76dbbfee2d", + "size": 177687, + "subdir": "linux-64", + "timestamp": 1611258452844, + "version": "5.4.1" + }, + "pyyaml-5.4.1-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "297bee4ea49b1a2d7db389d806ff6388", + "name": "pyyaml", + "sha256": "c0c26a211eb3f3f8524bbd831e227096e71b3746f07a028438bae163d99db20a", + "size": 178149, + "subdir": "linux-64", + "timestamp": 1611258452686, + "version": "5.4.1" + }, + "pyyaml-6.0-py310h5eee18b_1.conda": { + "build": "py310h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4d797290de5d8ef04abfe38d2d6f0ab", + "name": "pyyaml", + "sha256": "6e558d45b805c3031933a372ec802449b7ed595a04b1feebe32364fde60ad5c9", + "size": 181780, + "subdir": "linux-64", + "timestamp": 1670514836081, + "version": "6.0" + }, + "pyyaml-6.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc942acfc314f9beb5103d9d75e2fff5", + "name": "pyyaml", + "sha256": "a62380f5b97127be2bcbf66b693ae9f4633bf9bee80d8aa772f36cbd03813168", + "size": 420456, + "subdir": "linux-64", + "timestamp": 1640794093967, + "version": "6.0" + }, + "pyyaml-6.0-py311h5eee18b_1.conda": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a2cbf2541c56a0137de865e71f342b6", + "name": "pyyaml", + "sha256": "3ae2be8a754764ab1529091f8eece8b3109af37c7da99a2d010c7718fe7ecb83", + "size": 196959, + "subdir": "linux-64", + "timestamp": 1676827465689, + "version": "6.0" + }, + "pyyaml-6.0-py37h5eee18b_1.conda": { + "build": "py37h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "70081b0147fd1824474ffff89afd83b9", + "name": "pyyaml", + "sha256": "d946dbaf2c325b1330b5c60520acd57b03d9f2cb977188b0c932bcd7bd0f1df9", + "size": 189027, + "subdir": "linux-64", + "timestamp": 1670514869797, + "version": "6.0" + }, + "pyyaml-6.0-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "75df9a38e4a7e0a5a8e3c7cacd23fd57", + "name": "pyyaml", + "sha256": "61f76ec6a24000ee333a80560e48b4b3420a2ea13d4019ebc050276e7d59f404", + "size": 171696, + "subdir": "linux-64", + "timestamp": 1635856578229, + "version": "6.0" + }, + "pyyaml-6.0-py37h7f8727e_1.conda": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9e5eacbcce0ee4179c6376cddac85d4b", + "name": "pyyaml", + "sha256": "79ae2797f2709c4afbbd0172a99de566d32dbf3788cb584785eb72e765e8696d", + "size": 171626, + "subdir": "linux-64", + "timestamp": 1635775765870, + "version": "6.0" + }, + "pyyaml-6.0-py38h5eee18b_1.conda": { + "build": "py38h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bdf63377f7d39202734d4454e1732c34", + "name": "pyyaml", + "sha256": "1eabbeb23c1bc5b1718978435d3986370bab4c09f5a5d1d59406db5f94c13c64", + "size": 193619, + "subdir": "linux-64", + "timestamp": 1670514804684, + "version": "6.0" + }, + "pyyaml-6.0-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "448b5bccfcdc43af8e0ced8bdc9534de", + "name": "pyyaml", + "sha256": "65653aeab42f5008ad2a4261c311db36dc23a0f8cd4176c9db7340f9a9234205", + "size": 177460, + "subdir": "linux-64", + "timestamp": 1635856578205, + "version": "6.0" + }, + "pyyaml-6.0-py38h7f8727e_1.conda": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2bd06f71e7a66ee11a748fd2f3a49aa9", + "name": "pyyaml", + "sha256": "4002258b9fcb9c295d227a4f869bc2afad1d7620ab00070f4024119993bee76b", + "size": 176440, + "subdir": "linux-64", + "timestamp": 1635763881638, + "version": "6.0" + }, + "pyyaml-6.0-py39h5eee18b_1.conda": { + "build": "py39h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e076426a8cc21241c025d690fad4ccba", + "name": "pyyaml", + "sha256": "b62e41d62a9301e08d6479465d7580aa818ae28e5d02b9eeb7c27009e4d8cc44", + "size": 189805, + "subdir": "linux-64", + "timestamp": 1670514771163, + "version": "6.0" + }, + "pyyaml-6.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a3edbde0bcb902eba20414fde719ca1", + "name": "pyyaml", + "sha256": "b459aa3aa203284d21d44da148e2f42c9e429dd36aa83d031bc00546d35c5254", + "size": 177413, + "subdir": "linux-64", + "timestamp": 1635856161227, + "version": "6.0" + }, + "pyyaml-6.0-py39h7f8727e_1.conda": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e72b8f67f58927372cc2fbdbac851b9", + "name": "pyyaml", + "sha256": "6b9dd7c0c913c6d0aa8285664df60acbdb455ee25e96f674b9c7cf147338a1c5", + "size": 177472, + "subdir": "linux-64", + "timestamp": 1635775763162, + "version": "6.0" + }, + "pyzmq-16.0.2-py27h297844f_2.conda": { + "build": "py27h297844f_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "python >=2.7,<2.8.0a0", + "zeromq 4.2*" + ], + "license": "BSD 3-clause", + "md5": "f132f24bb75b639c78501da727a338d8", + "name": "pyzmq", + "sha256": "a712ff9fbc342a2aa0a9369570f3756c5c1fc18a53446058dc8a1a164d20a58e", + "size": 388040, + "subdir": "linux-64", + "timestamp": 1505688320277, + "version": "16.0.2" + }, + "pyzmq-16.0.2-py35h4be1f71_2.conda": { + "build": "py35h4be1f71_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "python >=3.5,<3.6.0a0", + "zeromq 4.2*" + ], + "license": "BSD 3-clause", + "md5": "fe94a8d3df21ae9a336f7115f07405ba", + "name": "pyzmq", + "sha256": "d12b7e2b1c816b8eb7dd53786915eddb6178dd35f63312d3cfd2a89f69ee1e23", + "size": 401123, + "subdir": "linux-64", + "timestamp": 1505688373594, + "version": "16.0.2" + }, + "pyzmq-16.0.2-py36h3b0cf96_2.conda": { + "build": "py36h3b0cf96_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "python >=3.6,<3.7.0a0", + "zeromq 4.2*" + ], + "license": "BSD 3-clause", + "md5": "6bbf544a635e765523a6f82ab949bdf3", + "name": "pyzmq", + "sha256": "47c18e8058c0e3fece6ec7a63192d69d5e1bd0453c9635bdc75e592aa63657e0", + "size": 402615, + "subdir": "linux-64", + "timestamp": 1505688421122, + "version": "16.0.2" + }, + "pyzmq-16.0.3-py27hc579512_0.conda": { + "build": "py27hc579512_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "python >=2.7,<2.8.0a0", + "zeromq 4.2*" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "577f28cc89e971beee6cf592107964dd", + "name": "pyzmq", + "sha256": "7b7fd72ed84e71cc7a684298fae4c4289ee621c5985882c5ea384dad5e0e37ca", + "size": 396821, + "subdir": "linux-64", + "timestamp": 1511321235661, + "version": "16.0.3" + }, + "pyzmq-16.0.3-py35ha889422_0.conda": { + "build": "py35ha889422_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "python >=3.5,<3.6.0a0", + "zeromq 4.2*" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e1282bf311692c7e90be08b5df1a6e15", + "name": "pyzmq", + "sha256": "120aadbddadfb927e371f4a43168367f510e0f765bcd91e83d59bbad73db7cba", + "size": 411618, + "subdir": "linux-64", + "timestamp": 1511321187415, + "version": "16.0.3" + }, + "pyzmq-16.0.3-py36he2533c7_0.conda": { + "build": "py36he2533c7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "python >=3.6,<3.7.0a0", + "zeromq 4.2*" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d6fadcccbb88f79810849c80997bcfd4", + "name": "pyzmq", + "sha256": "88749a5bff5f2617abb2156c5cc183deb42dbb169e862997a4ee624258f6bd73", + "size": 410641, + "subdir": "linux-64", + "timestamp": 1511321239718, + "version": "16.0.3" + }, + "pyzmq-17.0.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "python >=2.7,<2.8.0a0", + "zeromq >=4.2.3,<4.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e75153960705b7f25a9975347ad21e76", + "name": "pyzmq", + "sha256": "117cb289666e508e2889d820a3ff1931f4a07bc476242f02e1b30e76f435c8a9", + "size": 415061, + "subdir": "linux-64", + "timestamp": 1520450582407, + "version": "17.0.0" + }, + "pyzmq-17.0.0-py27h14c3975_1.conda": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=2.7,<2.8.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b59cbcfa5b497bb6633d92f9d8db3a20", + "name": "pyzmq", + "sha256": "eab37b5b743558286f9bd3ef6e659e9d9c71412e8bcbacdb0cadc8c7242a45aa", + "size": 418250, + "subdir": "linux-64", + "timestamp": 1523651175989, + "version": "17.0.0" + }, + "pyzmq-17.0.0-py27h14c3975_3.conda": { + "build": "py27h14c3975_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=2.7,<2.8.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e44c10f96822ab1b1f7231671d4e9cec", + "name": "pyzmq", + "sha256": "9f896b5aca326b11ceb23ce1b54490caa23229481b189ec82abebf8eafae3359", + "size": 414772, + "subdir": "linux-64", + "timestamp": 1530694672902, + "version": "17.0.0" + }, + "pyzmq-17.0.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "python >=3.5,<3.6.0a0", + "zeromq >=4.2.3,<4.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6b3ed783abd16bdb2ac86fb2615de33e", + "name": "pyzmq", + "sha256": "70ba8105a40ed2ec4b57964651643bce620bb2a34bc74fbaec2a70c4e2e99148", + "size": 428982, + "subdir": "linux-64", + "timestamp": 1520450436971, + "version": "17.0.0" + }, + "pyzmq-17.0.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "python >=3.6,<3.7.0a0", + "zeromq >=4.2.3,<4.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c7512b22aad2116ee4bcd29f2ac4782f", + "name": "pyzmq", + "sha256": "0feda62b66bcf19bf2867c133887c0aa24ec13fa100c0ee632dbbd894b10bcb2", + "size": 430440, + "subdir": "linux-64", + "timestamp": 1520450438285, + "version": "17.0.0" + }, + "pyzmq-17.0.0-py36h14c3975_3.conda": { + "build": "py36h14c3975_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5550d1640973d675d2264211e2ec7e7c", + "name": "pyzmq", + "sha256": "3c66ad28288b7d845bd5895888c4bbfcb386b8f5bb946a6fbb0491b44f5accae", + "size": 430211, + "subdir": "linux-64", + "timestamp": 1530694536138, + "version": "17.0.0" + }, + "pyzmq-17.0.0-py37h14c3975_3.conda": { + "build": "py37h14c3975_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5e33349ac51619b05c0b1392bbdabbf1", + "name": "pyzmq", + "sha256": "8d95bdcf766b83d7d4796e6fa301fa61e5fd3922675c17a597c07c84a82de4e0", + "size": 428621, + "subdir": "linux-64", + "timestamp": 1530694607839, + "version": "17.0.0" + }, + "pyzmq-17.1.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=2.7,<2.8.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6b5fe993e44b29cda67d89dee19427a4", + "name": "pyzmq", + "sha256": "180be0390235a420b01e4ef277d5a793219f6e2eebab62bce53b1654921963ff", + "size": 419644, + "subdir": "linux-64", + "timestamp": 1533656247387, + "version": "17.1.0" + }, + "pyzmq-17.1.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.5,<3.6.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "75bb6a70b2c4068217d20b657479abed", + "name": "pyzmq", + "sha256": "abf2b7973c1506be05fad9b443b6e767e4f334801cf02feea0d2a25b38b9a958", + "size": 434714, + "subdir": "linux-64", + "timestamp": 1533656271273, + "version": "17.1.0" + }, + "pyzmq-17.1.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2be35f1395b84ffa9b237b18def6807a", + "name": "pyzmq", + "sha256": "2fdcdd140c133c1f25cabe8a47f5e2a581f40817841c4ff59216d17791388388", + "size": 435733, + "subdir": "linux-64", + "timestamp": 1533656172182, + "version": "17.1.0" + }, + "pyzmq-17.1.0-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "aa6a0231f1aa9b91b319a646c22538b1", + "name": "pyzmq", + "sha256": "7d77631256c6f9976f80f74e9aeeceed00fff2f63baef25752501954f9550258", + "size": 435909, + "subdir": "linux-64", + "timestamp": 1533656264988, + "version": "17.1.0" + }, + "pyzmq-17.1.2-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=2.7,<2.8.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c472502cb3dba88820180f91294e19af", + "name": "pyzmq", + "sha256": "f6d917d4a5f94eb4122ae0d92371cbae117052dc1920cb5db73738a91473f7d9", + "size": 416322, + "subdir": "linux-64", + "timestamp": 1534270187020, + "version": "17.1.2" + }, + "pyzmq-17.1.2-py27he6710b0_2.conda": { + "build": "py27he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "992944276e622bfb613da87558bd72ab", + "name": "pyzmq", + "sha256": "805e1bcf5002693e2a9aed44e0c266f2316223979d1d81f1ae5384ab1dea9266", + "size": 418682, + "subdir": "linux-64", + "timestamp": 1549069267640, + "version": "17.1.2" + }, + "pyzmq-17.1.2-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.5,<3.6.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f45eb7cac96046cd10082e8d7972d9a5", + "name": "pyzmq", + "sha256": "e8be820dcb98aef7df7c11999eb786dba83bccf524eef64911f26e1a98feed6d", + "size": 429669, + "subdir": "linux-64", + "timestamp": 1534270303140, + "version": "17.1.2" + }, + "pyzmq-17.1.2-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1bbd0c546d3c625e395830754bd34e12", + "name": "pyzmq", + "sha256": "724c2555f4df62cdf915166b985de744364f18d0ed0f212ddcba07ed012765f4", + "size": 431756, + "subdir": "linux-64", + "timestamp": 1534270165340, + "version": "17.1.2" + }, + "pyzmq-17.1.2-py36he6710b0_2.conda": { + "build": "py36he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "99fdcbb7414287038653ad8e57b25af7", + "name": "pyzmq", + "sha256": "3c9787a679cb7d4324ee098d5d46033bb36173545c8b9d4ec54a12b1a14b0f20", + "size": 434383, + "subdir": "linux-64", + "timestamp": 1549069328561, + "version": "17.1.2" + }, + "pyzmq-17.1.2-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.2.5,<4.2.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "99203d4cef9630cdfa6332de0b214ac7", + "name": "pyzmq", + "sha256": "7aa4ada64bd664a119ef8f7d35981d7d8781ee4de967983b2a5f9fc959801fde", + "size": 429054, + "subdir": "linux-64", + "timestamp": 1534270221172, + "version": "17.1.2" + }, + "pyzmq-17.1.2-py37he6710b0_2.conda": { + "build": "py37he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8f7dbcc0a95916797c0ec24687c734a5", + "name": "pyzmq", + "sha256": "1f6073c0d047da81c7795ddeed78110388107618edd3ae2a98aeb06772f95175", + "size": 434239, + "subdir": "linux-64", + "timestamp": 1549069299194, + "version": "17.1.2" + }, + "pyzmq-18.0.0-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e20c7adfd02c9ca6e5a1875dc6619bb6", + "name": "pyzmq", + "sha256": "ceb9d10a55396e2d89fc9e937d6500167cba8891b4b57ba0b44bd8cf83f7d958", + "size": 443120, + "subdir": "linux-64", + "timestamp": 1551148183095, + "version": "18.0.0" + }, + "pyzmq-18.0.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d486dbc9125e76d7ad21b4e426d66a46", + "name": "pyzmq", + "sha256": "7521da9ea72a8300e9717cdc16de9ca1cd2d4dc02afa627d8c7b5bdb48dd3c76", + "size": 461401, + "subdir": "linux-64", + "timestamp": 1551148222885, + "version": "18.0.0" + }, + "pyzmq-18.0.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8775e1c74fef0e28176d6c1c984f33ee", + "name": "pyzmq", + "sha256": "0de9916e2a0168f010f8c8a76f1a9f9d9ebb5a82a39767ecc627e2c3d351a89a", + "size": 462245, + "subdir": "linux-64", + "timestamp": 1551148167486, + "version": "18.0.0" + }, + "pyzmq-18.1.0-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2268d908f3a1a580e7648f94679b1641", + "name": "pyzmq", + "sha256": "5b9129bc0173f177b28e3959d17e2d01ad0ea9221bed3c99f904a57d23a4e419", + "size": 444966, + "subdir": "linux-64", + "timestamp": 1565899590740, + "version": "18.1.0" + }, + "pyzmq-18.1.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "630a3f4d3565ff57ef5551b02353eea2", + "name": "pyzmq", + "sha256": "efe6b38e7ae2eac48d500e69fee2405c47ebab5056f8d0cbdbffb66c234639da", + "size": 464158, + "subdir": "linux-64", + "timestamp": 1565899652077, + "version": "18.1.0" + }, + "pyzmq-18.1.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "27ce41da834f5b52dc8cb6c956278fd8", + "name": "pyzmq", + "sha256": "465a11b3a1ecffc90ed91249ea58697030feb1f10247373c2e44e39af9f26b0b", + "size": 466387, + "subdir": "linux-64", + "timestamp": 1565899639474, + "version": "18.1.0" + }, + "pyzmq-18.1.0-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "287d84ea689e023826eacc9fef49b5a6", + "name": "pyzmq", + "sha256": "23df96fad5e3b9e09eeb23cbf96c9a77d00403415a7d10161213732b03bbc068", + "size": 477914, + "subdir": "linux-64", + "timestamp": 1573200514620, + "version": "18.1.0" + }, + "pyzmq-18.1.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3851c5c82391252562361e1d50259630", + "name": "pyzmq", + "sha256": "26323b065ac33f187e9f2c2fd42def7e5d153e5190a57ce5534e818ca3629285", + "size": 465175, + "subdir": "linux-64", + "timestamp": 1580845541202, + "version": "18.1.1" + }, + "pyzmq-18.1.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2501e55283e438deb188c1faa0f0c229", + "name": "pyzmq", + "sha256": "3c4ac19a76a590acfa6d18330e32d77871a4b96fac96094e55b297d483448a69", + "size": 462867, + "subdir": "linux-64", + "timestamp": 1580845541401, + "version": "18.1.1" + }, + "pyzmq-18.1.1-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zeromq >=4.3.1,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8901edd9839beeb1c1c4be2908b36701", + "name": "pyzmq", + "sha256": "2254fe8fd72b9d09eae57b2b8521ab779467ec80732c286c4ccb6e867f78c80f", + "size": 476140, + "subdir": "linux-64", + "timestamp": 1580845531549, + "version": "18.1.1" + }, + "pyzmq-19.0.1-py36he6710b0_1.conda": { + "build": "py36he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.3.2,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "948c0a7dfa463e4af1fae30ea79a0e4d", + "name": "pyzmq", + "sha256": "8ff135f496de228b0dc78ab963f9130371c041b1ad2f0c39fe1fcba7a8a9213e", + "size": 471092, + "subdir": "linux-64", + "timestamp": 1593033318498, + "version": "19.0.1" + }, + "pyzmq-19.0.1-py37he6710b0_1.conda": { + "build": "py37he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.2,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ea74c3b1898e03084c2e35417cadf2f6", + "name": "pyzmq", + "sha256": "237615fa78ce7bf71f6d3ee3c5323586520cb3cd7b2d0ad8ed2bf1f606028e67", + "size": 469806, + "subdir": "linux-64", + "timestamp": 1593033313628, + "version": "19.0.1" + }, + "pyzmq-19.0.1-py38he6710b0_1.conda": { + "build": "py38he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zeromq >=4.3.2,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ac0aed53bcf6c4e2d30c78e28ae451d1", + "name": "pyzmq", + "sha256": "1a033d5f22f189ccac25783c905ad215d47a5a3c02ffaaef269f790c77953bd6", + "size": 483835, + "subdir": "linux-64", + "timestamp": 1593033315584, + "version": "19.0.1" + }, + "pyzmq-19.0.2-py36he6710b0_1.conda": { + "build": "py36he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.3.2,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4eaebcff339f44ee2f25da687ed3e1f5", + "name": "pyzmq", + "sha256": "e1dc3f3e6c49f671f4b448cbf02333ac61b99baa2e0f92dcaed18799f3170b98", + "size": 444163, + "subdir": "linux-64", + "timestamp": 1600460611142, + "version": "19.0.2" + }, + "pyzmq-19.0.2-py37he6710b0_1.conda": { + "build": "py37he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.2,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "12b1caaf90a229983e316dec056fbc66", + "name": "pyzmq", + "sha256": "98cd289b2d47f4dd255d39e49bf293459ed53f3f5561b0b24cd810ac8ed378a5", + "size": 448916, + "subdir": "linux-64", + "timestamp": 1600460610477, + "version": "19.0.2" + }, + "pyzmq-19.0.2-py38he6710b0_1.conda": { + "build": "py38he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zeromq >=4.3.2,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e1354d758ba1799631b4ceddf9d288fb", + "name": "pyzmq", + "sha256": "b025a332cccf57406e8139a8849d0c0825cde6a57f794d69e3c115c58edf6743", + "size": 455985, + "subdir": "linux-64", + "timestamp": 1600460603061, + "version": "19.0.2" + }, + "pyzmq-20.0.0-py36h2531618_1.conda": { + "build": "py36h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.3.3,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dae1b2d7b131fbe16b78903fd6be67af", + "name": "pyzmq", + "sha256": "978833a45920331571250d7c38425f4c82bdfc340d10f1b276ae6398357647e1", + "size": 448969, + "subdir": "linux-64", + "timestamp": 1606690982209, + "version": "20.0.0" + }, + "pyzmq-20.0.0-py37h2531618_1.conda": { + "build": "py37h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.3,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1915c047de2a607992eb394d270b3ff4", + "name": "pyzmq", + "sha256": "2ce27990c41d4ffcd9f41cd4ac696f2da085bc40b4f48a88d701bd3e3ecd36ac", + "size": 449397, + "subdir": "linux-64", + "timestamp": 1606690966744, + "version": "20.0.0" + }, + "pyzmq-20.0.0-py38h2531618_1.conda": { + "build": "py38h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zeromq >=4.3.3,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a0ac3590a0c1256df17ea9bc449455b3", + "name": "pyzmq", + "sha256": "b8ca353f3a8c7efc75ca3548fbd641ff2077d1f191fc598fba3e4aa9f8a00853", + "size": 457955, + "subdir": "linux-64", + "timestamp": 1606690975269, + "version": "20.0.0" + }, + "pyzmq-20.0.0-py39h2531618_1.conda": { + "build": "py39h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "zeromq >=4.3.3,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9770f0513ae5016d415f610ac7a40c6a", + "name": "pyzmq", + "sha256": "9fd027d83c6f3eb5ed7f7392fa2b001a5b24cd00fecdf270426fc495555192f4", + "size": 459463, + "subdir": "linux-64", + "timestamp": 1606690980826, + "version": "20.0.0" + }, + "pyzmq-22.2.1-py36h295c915_1.conda": { + "build": "py36h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7ad9795f733342cc7192924d9a8bf3ed", + "name": "pyzmq", + "sha256": "07504475bc76301234d932a69393b22d899c0902cd0ffda0a7481e3523255dff", + "size": 465082, + "subdir": "linux-64", + "timestamp": 1628268483717, + "version": "22.2.1" + }, + "pyzmq-22.2.1-py37h295c915_1.conda": { + "build": "py37h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "dc91d5e53c6f2c3c32883c3b9d5c768a", + "name": "pyzmq", + "sha256": "21374b0c2732849cdcd15b1e75efb5a474e5a2ddaf175f5110f6e55506f20342", + "size": 465638, + "subdir": "linux-64", + "timestamp": 1628267986245, + "version": "22.2.1" + }, + "pyzmq-22.2.1-py38h295c915_1.conda": { + "build": "py38h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6e10403c129f531d9d7ef0e9f88dbb13", + "name": "pyzmq", + "sha256": "5e77b7e5f845bc4775b2ec1a6f78b5bc07186a732caae23390fcbfddeb193c96", + "size": 476481, + "subdir": "linux-64", + "timestamp": 1628276077821, + "version": "22.2.1" + }, + "pyzmq-22.2.1-py39h295c915_1.conda": { + "build": "py39h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "df75583f3dc53d0485126b7b2ac965a4", + "name": "pyzmq", + "sha256": "4c44605df36c6a535c1d99bc41b3f7b1ea4c44bd0f5a27fbf7b4d83409df89af", + "size": 476007, + "subdir": "linux-64", + "timestamp": 1628275446063, + "version": "22.2.1" + }, + "pyzmq-22.3.0-py310h295c915_2.conda": { + "build": "py310h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "b3ce5b025005dbf5edeab8e0d47c6b0f", + "name": "pyzmq", + "sha256": "e0ea019223150833094147cef1c685b7cbd3486e55a9b268e08f74706c5c74fc", + "size": 1043224, + "subdir": "linux-64", + "timestamp": 1640794137148, + "version": "22.3.0" + }, + "pyzmq-22.3.0-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "09c6732dd480cc9f8ba797a822ada8df", + "name": "pyzmq", + "sha256": "69845f3c040425b296b768932b8a160b665730da3a1ede0342b54f65bcf42be4", + "size": 467987, + "subdir": "linux-64", + "timestamp": 1638366340622, + "version": "22.3.0" + }, + "pyzmq-22.3.0-py37h295c915_1.conda": { + "build": "py37h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "84a628eebdd694e403109dbfea80202f", + "name": "pyzmq", + "sha256": "b976de7f91aae793247ce8a10a5dc762b9f74f301ee38f6455daa404b46baf7b", + "size": 466465, + "subdir": "linux-64", + "timestamp": 1638358416642, + "version": "22.3.0" + }, + "pyzmq-22.3.0-py37h295c915_2.conda": { + "build": "py37h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "eaa3c47436b2637fda64adcc3bbd93fd", + "name": "pyzmq", + "sha256": "14d084e04525afcd9bce8ea1703ca51b9781535f383c251e03e7847a30fd3152", + "size": 476347, + "subdir": "linux-64", + "timestamp": 1638434984801, + "version": "22.3.0" + }, + "pyzmq-22.3.0-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "94534d6097513b0f9aeed6d038675fb9", + "name": "pyzmq", + "sha256": "f0e0de0a1972b26d7f27d709b89744c96b93ab5d8ff7ff3ad2d4dd67e0ca7262", + "size": 478478, + "subdir": "linux-64", + "timestamp": 1638366339926, + "version": "22.3.0" + }, + "pyzmq-22.3.0-py38h295c915_2.conda": { + "build": "py38h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "4b7508c58d9552487e5730f55c5cd5ac", + "name": "pyzmq", + "sha256": "8b7355e07f5bf5adcb9e49859fc83033a4e6cd92951e39c09aea7997d5d5477c", + "size": 487386, + "subdir": "linux-64", + "timestamp": 1638436432728, + "version": "22.3.0" + }, + "pyzmq-22.3.0-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "1b3843b8a2791046c955f4cc0525c594", + "name": "pyzmq", + "sha256": "fb37aff6dbd2cea2eb8896a59b19386ccb27db6be536ff68c056ec69d69b38b3", + "size": 472082, + "subdir": "linux-64", + "timestamp": 1638366868850, + "version": "22.3.0" + }, + "pyzmq-22.3.0-py39h295c915_2.conda": { + "build": "py39h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-clause", + "license_family": "BSD", + "md5": "173f8b2b58318d3c1e298628126672f8", + "name": "pyzmq", + "sha256": "49b4c9c8b99251a7975ec320693d58226718149d8f21bc1c5a8a64bae35de211", + "size": 480951, + "subdir": "linux-64", + "timestamp": 1638435042256, + "version": "22.3.0" + }, + "pyzmq-23.2.0-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-Clause AND LGPL-3.0-or-later", + "license_family": "BSD", + "md5": "0f8309425684be2e15d1460326bc41dc", + "name": "pyzmq", + "sha256": "c9bc9c5c9002438d17c3ef725cbdb10a8c12dde43355a979ba5eb3563cd8e479", + "size": 1041410, + "subdir": "linux-64", + "timestamp": 1657724267998, + "version": "23.2.0" + }, + "pyzmq-23.2.0-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-Clause AND LGPL-3.0-or-later", + "license_family": "BSD", + "md5": "03fcf37e48d58c4be888ff0862fa1568", + "name": "pyzmq", + "sha256": "d5b4b48c9b7b054e4cd8bcbd5c60d9d0875a6baebc50f277e63d04b3fffe0c66", + "size": 539167, + "subdir": "linux-64", + "timestamp": 1676918919898, + "version": "23.2.0" + }, + "pyzmq-23.2.0-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-Clause AND LGPL-3.0-or-later", + "license_family": "BSD", + "md5": "6cfc959099b2aefd7684b47c41848366", + "name": "pyzmq", + "sha256": "962a8cbaff05b429646623f147deeb13f49196f6884f57a5d2857efea6793e53", + "size": 448106, + "subdir": "linux-64", + "timestamp": 1657724324840, + "version": "23.2.0" + }, + "pyzmq-23.2.0-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-Clause AND LGPL-3.0-or-later", + "license_family": "BSD", + "md5": "90d75862c3bc20e09f56c8e8e3426990", + "name": "pyzmq", + "sha256": "2f7d404e718ce08437b3ce9e2a4b8086ae342b26fbcd2eb5f7b33fb25787f04d", + "size": 458313, + "subdir": "linux-64", + "timestamp": 1657724378233, + "version": "23.2.0" + }, + "pyzmq-23.2.0-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "zeromq >=4.3.4,<4.4.0a0" + ], + "license": "BSD-3-Clause AND LGPL-3.0-or-later", + "license_family": "BSD", + "md5": "2c3f9f342f5f7d7b2cfd31ab99da4dad", + "name": "pyzmq", + "sha256": "b318d042ea90d441e95468eb4838fba5919c7f725be7dcf2ed45a7dc9d5b2636", + "size": 455605, + "subdir": "linux-64", + "timestamp": 1657724431309, + "version": "23.2.0" + }, + "pyzstd-0.14.4-py36h7f8727e_3.conda": { + "build": "py36h7f8727e_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1219ba0aecd5d9919fb86c91fc83393d", + "name": "pyzstd", + "sha256": "226fbb22405a8ec5332c6c256763767fd7c405e2e1612e6e2b8af09bd2d28351", + "size": 91822, + "subdir": "linux-64", + "timestamp": 1633097303780, + "version": "0.14.4" + }, + "pyzstd-0.14.4-py37h7f8727e_3.conda": { + "build": "py37h7f8727e_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8782d77e994ea7875cf474a2e9008cd1", + "name": "pyzstd", + "sha256": "d85e4a6d7aca9bc2231e030e44fbc836c45023d313951c316164bca5ec765672", + "size": 92260, + "subdir": "linux-64", + "timestamp": 1633097119958, + "version": "0.14.4" + }, + "pyzstd-0.14.4-py38h7f8727e_3.conda": { + "build": "py38h7f8727e_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b5ff5e81bd4c1d97fcdd8362ff7db14a", + "name": "pyzstd", + "sha256": "d33eb8bb2d67bddc862aa45050624b59b8a3945c485ad54ddbd1c4e47c2482cc", + "size": 92856, + "subdir": "linux-64", + "timestamp": 1633086757270, + "version": "0.14.4" + }, + "pyzstd-0.14.4-py39h7f8727e_3.conda": { + "build": "py39h7f8727e_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "227bcc20788486ec233a2dfed4a9ef04", + "name": "pyzstd", + "sha256": "02113604b7a1906a905ef0fc1fe4e8409ef4bb9caf926ce9641fb8af11b20ee4", + "size": 92683, + "subdir": "linux-64", + "timestamp": 1633097291179, + "version": "0.14.4" + }, + "pyzstd-0.15.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "zstd >=1.5.0,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "496c5d3f3f1857c84c17a7b942f23e61", + "name": "pyzstd", + "sha256": "0239edca14488167aa3ba0b3b37f241cff16a06c4aaf504df204eb0212caf4d1", + "size": 142914, + "subdir": "linux-64", + "timestamp": 1640794163271, + "version": "0.15.0" + }, + "pyzstd-0.15.0-py311h2c38b39_0.conda": { + "build": "py311h2c38b39_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2250ab365b5bfe7818bb6750d7c2b9df", + "name": "pyzstd", + "sha256": "c13f6a3ef0cbcc4d70750b05f25c460f131b64113d33ed60be07dca06cefd5ca", + "size": 97684, + "subdir": "linux-64", + "timestamp": 1676861667488, + "version": "0.15.0" + }, + "pyzstd-0.15.0-py36h7f8727e_0.conda": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9722fc5143c110aa239ca3d6a44af5bb", + "name": "pyzstd", + "sha256": "e79f3c0ca662f91cb991dbba9ccd24af615cd365b3b89f869065526874b78bc6", + "size": 96538, + "subdir": "linux-64", + "timestamp": 1633081810925, + "version": "0.15.0" + }, + "pyzstd-0.15.0-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d9447787591fb7c07e3ba38d748682f1", + "name": "pyzstd", + "sha256": "93fe2cfe67a7e837c313cfe80cbb4f9a5125b7c17aac2df796f291538d5a67f2", + "size": 96718, + "subdir": "linux-64", + "timestamp": 1633092318325, + "version": "0.15.0" + }, + "pyzstd-0.15.0-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6aa02bd5c9c72ef028d1546edfa136af", + "name": "pyzstd", + "sha256": "17ad41b0cfb73541748906733969f7542cd59d4d4f074b31b15bc7b065f212e3", + "size": 97211, + "subdir": "linux-64", + "timestamp": 1633092029033, + "version": "0.15.0" + }, + "pyzstd-0.15.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "02930d5dc79bec57d58f4dd31793fce7", + "name": "pyzstd", + "sha256": "5a06802d5fe2c2eb32e99ee7ef876818de3ca5ed0dc6ddfac08de9fd1715381d", + "size": 97271, + "subdir": "linux-64", + "timestamp": 1633092319889, + "version": "0.15.0" + }, + "qasync-0.23.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "7d3ca451dc2df85cc134b7052b33eeda", + "name": "qasync", + "sha256": "1f045c19b401d6f6b4007d30122590adc017f7d8f3bf94844779537d50e61fd8", + "size": 30199, + "subdir": "linux-64", + "timestamp": 1659335808139, + "version": "0.23.0" + }, + "qasync-0.23.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "6800585ff0668edfeb0658ddb4c4a9c5", + "name": "qasync", + "sha256": "8bdb8cd60d2374fbd6a01996738df88dabfbd757b3a61112703acaba942e55b8", + "size": 38050, + "subdir": "linux-64", + "timestamp": 1676842415853, + "version": "0.23.0" + }, + "qasync-0.23.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ad1c27a474a471335aad5e40e3b14036", + "name": "qasync", + "sha256": "5d10bac75967d5addb8b31937c86245b5723ee0c290eb861089b04940fb6e47c", + "size": 29716, + "subdir": "linux-64", + "timestamp": 1659335768493, + "version": "0.23.0" + }, + "qasync-0.23.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "fba20677a6b4737741707497e7b6f9e2", + "name": "qasync", + "sha256": "3db7fcec937da9fafc6474430e0b60e252605d6f68561aac410cf4533fde8cc3", + "size": 29853, + "subdir": "linux-64", + "timestamp": 1659335783046, + "version": "0.23.0" + }, + "qasync-0.23.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f956e061d1e2f69e77bc1e375490d482", + "name": "qasync", + "sha256": "908969ea283ef442b6c270e4122f2814032df76af3483555ee793685f90f9a11", + "size": 29833, + "subdir": "linux-64", + "timestamp": 1659335822945, + "version": "0.23.0" + }, + "qcachegrind-0.7.4-he6710b0_1.conda": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "qt >=5.9.6,<5.10.0a0" + ], + "license": "GPLv2", + "license_family": "GPL2", + "md5": "b39807d0f2b941bf210431931d93bb18", + "name": "qcachegrind", + "sha256": "f9df776f5e1faa8e1d0c8af04d57b011ea767b07f0d6f5e864ee01d01db64697", + "size": 500343, + "subdir": "linux-64", + "timestamp": 1539289966075, + "version": "0.7.4" + }, + "qgrid-1.0.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b489a0e920d62621d261d31794f7e531", + "name": "qgrid", + "sha256": "a23f681ce9aa7a7eda5392a62708773e6ca1fade3d49ac8595896a6142760ba3", + "size": 497513, + "subdir": "linux-64", + "timestamp": 1519244094863, + "version": "1.0.1" + }, + "qgrid-1.0.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b6b2954622bca4619fdef72d8d45de14", + "name": "qgrid", + "sha256": "121c161bfe95083a69aa2ba93ca3dcef51112151e878f4ba5bfe59289a17b250", + "size": 501711, + "subdir": "linux-64", + "timestamp": 1519244112558, + "version": "1.0.1" + }, + "qgrid-1.0.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "878b8ca9fb6f502c69c6ca6938ec94aa", + "name": "qgrid", + "sha256": "9cbb12912eff8ec8f25fb1ecb00175bde2b05dc587d7ad42eeda882c30a6391e", + "size": 497485, + "subdir": "linux-64", + "timestamp": 1519244073031, + "version": "1.0.1" + }, + "qgrid-1.0.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b4b62ec9d0b21e7f97e4b26733633e01", + "name": "qgrid", + "sha256": "3303a562e40788c4b4e029dad96c168469ecc72e6cdde4001cea2c57991edeba", + "size": 501670, + "subdir": "linux-64", + "timestamp": 1522195822260, + "version": "1.0.2" + }, + "qgrid-1.0.2-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2d707db8278ac8c72dc40b424dee7cd7", + "name": "qgrid", + "sha256": "1796371e2214fe1d88fa68b66d14f4af6a252948f417b4094fad7cae3c605636", + "size": 502044, + "subdir": "linux-64", + "timestamp": 1522195137429, + "version": "1.0.2" + }, + "qgrid-1.0.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7628a97716d3cbe51109fd0a10d19a20", + "name": "qgrid", + "sha256": "f118bfa36d39bada45fc34772cc5951412df8f5dc6d52ec5a90b04215a0bec0d", + "size": 500680, + "subdir": "linux-64", + "timestamp": 1522195105408, + "version": "1.0.2" + }, + "qgrid-1.0.5-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c4f5d2efadb46d12dea357bd7b9d686d", + "name": "qgrid", + "sha256": "b4730470e2a4896bef58cef26bc8241ac236c823e79c0eb0a4f789d69ada377a", + "size": 517724, + "subdir": "linux-64", + "timestamp": 1528148018503, + "version": "1.0.5" + }, + "qgrid-1.0.5-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9d3dee17bb1e3d7a53b94cbe98843bba", + "name": "qgrid", + "sha256": "02ab2d163a6c18133b85bcae67c511dc172034e8951498f9465ccd7da47710dc", + "size": 517669, + "subdir": "linux-64", + "timestamp": 1528148038012, + "version": "1.0.5" + }, + "qgrid-1.0.5-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8d62c482a09fc9847839df33a8654b4f", + "name": "qgrid", + "sha256": "bbffe3ee828e8f8ca98029cd1e9e0257a4b052908e37e1ddbc1030692e9d0aca", + "size": 517798, + "subdir": "linux-64", + "timestamp": 1528148002672, + "version": "1.0.5" + }, + "qgrid-1.0.5-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "139e5f71135d89525431d855ce081a5e", + "name": "qgrid", + "sha256": "d2ee9ab64ab324fc68bcf3b0bb405103a9209e585dcda9fe3773e47a33d7feb3", + "size": 519382, + "subdir": "linux-64", + "timestamp": 1530923072757, + "version": "1.0.5" + }, + "qgrid-1.1.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a29e530533754756c1237d33e6c739f9", + "name": "qgrid", + "sha256": "6f29c2a7202fa1fabb52ac581bdb31d873a58001746e4832d43c6b201a964723", + "size": 528755, + "subdir": "linux-64", + "timestamp": 1535430583157, + "version": "1.1.1" + }, + "qgrid-1.1.1-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "66da04b706d9a35517ed5433f5ac8587", + "name": "qgrid", + "sha256": "cb1b7858623a9159e3685b69bd8463537442edecae4fcddaa34149def9ce5270", + "size": 534312, + "subdir": "linux-64", + "timestamp": 1549994197635, + "version": "1.1.1" + }, + "qgrid-1.1.1-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4a5de38f0c835214c33157e11a5ac759", + "name": "qgrid", + "sha256": "3aba5871278598668a7d64e7c99e6e440fd0a0ed5e6acb99c8168fedc77a8a9a", + "size": 549059, + "subdir": "linux-64", + "timestamp": 1642760550795, + "version": "1.1.1" + }, + "qgrid-1.1.1-py311h06a4308_2.conda": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2e4b087fd8b5b14ed2baef3228196371", + "name": "qgrid", + "sha256": "6e9dfb72cda0b075b882ddafb715163cf79821b638ced1ca2589519ef1c8c9e2", + "size": 553725, + "subdir": "linux-64", + "timestamp": 1676922559703, + "version": "1.1.1" + }, + "qgrid-1.1.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c1b3dc4af5cb15835749cc8fcd6623e7", + "name": "qgrid", + "sha256": "419e9c54223f81276b35fe4eb650a2c2a9c9f3d70d26f2d2dc834eb3f4ac0fe5", + "size": 526295, + "subdir": "linux-64", + "timestamp": 1535430580922, + "version": "1.1.1" + }, + "qgrid-1.1.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "40538f22c025fcaac9a76899943e67e5", + "name": "qgrid", + "sha256": "3a0150e4e0572059d92bb3de3f4fd653374b97e2911a99462e2c3c7925146df8", + "size": 525260, + "subdir": "linux-64", + "timestamp": 1535430580054, + "version": "1.1.1" + }, + "qgrid-1.1.1-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1f8cc8b3d96fbee3606b3d0d5df08683", + "name": "qgrid", + "sha256": "dd5c5a04197145b177d981ec06928d4bf2705d57910fb76049cca48b44a4eacf", + "size": 538901, + "subdir": "linux-64", + "timestamp": 1549994225633, + "version": "1.1.1" + }, + "qgrid-1.1.1-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "afa81c31c4ea42dba008de20a74617a1", + "name": "qgrid", + "sha256": "8c0d30be9e210b0e0f04350dc254f89edf3d8bc2940acad87bdf7edab3e5a8a5", + "size": 533105, + "subdir": "linux-64", + "timestamp": 1614090104207, + "version": "1.1.1" + }, + "qgrid-1.1.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6899fb1ca62f1acedbc18659a3ccbeb4", + "name": "qgrid", + "sha256": "452e1b8ffad57510b11ea1254b32d65cdcaf90548082cd858ac0a03aa683950c", + "size": 531486, + "subdir": "linux-64", + "timestamp": 1535430638314, + "version": "1.1.1" + }, + "qgrid-1.1.1-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d2f80600608e67d0387a405bd32cb629", + "name": "qgrid", + "sha256": "a6a247782d5a1dc2f54f7f8eefbcffd2effdaa33527f23b263140af67ef04ca2", + "size": 538946, + "subdir": "linux-64", + "timestamp": 1549994180592, + "version": "1.1.1" + }, + "qgrid-1.1.1-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2e6e2a985cbc1bb86b5a69995d4f9b4e", + "name": "qgrid", + "sha256": "6ec6fb33470cc3b754548d60eecc89fab07c07bcd3227cd8e194534523ef74b5", + "size": 547009, + "subdir": "linux-64", + "timestamp": 1614090717117, + "version": "1.1.1" + }, + "qgrid-1.1.1-py38_2.conda": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d73264baed94349d61080cb217e1b4a0", + "name": "qgrid", + "sha256": "2ad9baf285fcf8e2d46eeb5747577be743a40693ec013d2b9df91c7de2926b5c", + "size": 547982, + "subdir": "linux-64", + "timestamp": 1592485517341, + "version": "1.1.1" + }, + "qgrid-1.1.1-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5dc93735d85c2edbd4fa8bbceef44505", + "name": "qgrid", + "sha256": "0dccf68116b80e38ebd880590b0e1aa9354198499cfdca23c58c0f3f1b0ddefb", + "size": 548081, + "subdir": "linux-64", + "timestamp": 1614091010018, + "version": "1.1.1" + }, + "qgrid-1.1.1-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3bb68c6b05aafbe67a90117651ed69c4", + "name": "qgrid", + "sha256": "d136618fe80e939e4f95c1e0325a0e79418025186996678d5c6dacc94db72af8", + "size": 536229, + "subdir": "linux-64", + "timestamp": 1614090045872, + "version": "1.1.1" + }, + "qgrid-1.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a46e158abb41f19d7917d4fce212729b", + "name": "qgrid", + "sha256": "01e3ed25440e3fc2e50491bcd4ffe3c91d8d15a6b36bd58852423089f131e3e0", + "size": 749865, + "subdir": "linux-64", + "timestamp": 1599278599966, + "version": "1.3.1" + }, + "qgrid-1.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ed08031dba5f845701a15d3d773099e4", + "name": "qgrid", + "sha256": "531668f73770bebac5133f704197ed0203ff03a003c220ad2961ab146515e83c", + "size": 749654, + "subdir": "linux-64", + "timestamp": 1599278584151, + "version": "1.3.1" + }, + "qgrid-1.3.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipywidgets >=7.0.0", + "notebook >=4.0.0", + "pandas >=0.18.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "01862f09c7e6eb3ef8d2d284b403aab7", + "name": "qgrid", + "sha256": "1854ac5b1c5f9fa5b13d064e538823dd747ff36eb9e70b8c3a800ce33eddca7e", + "size": 746548, + "subdir": "linux-64", + "timestamp": 1599278555573, + "version": "1.3.1" + }, + "qhull-2020.2-hdb19cb5_2.conda": { + "build": "hdb19cb5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Qhull", + "license_family": "Other", + "md5": "f24ea027e3d07ac46e4f4b635635fedc", + "name": "qhull", + "sha256": "9511841684e7cdf488738ef1edad812a1c860ec9b85cefcaa9e9290318cb2037", + "size": 1106088, + "subdir": "linux-64", + "timestamp": 1670915839713, + "version": "2020.2" + }, + "qstylizer-0.2.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >0.3.0,<1.0", + "python >=3.10,<3.11.0a0", + "tinycss2 >=1.1.0,<2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc5689b6a05abd3b10e99905fc643817", + "name": "qstylizer", + "sha256": "a4fb4d64d3154a4e59925b1b9f6c9c0d5abeaf835c3f3f6094ac0f15d0233137", + "size": 30122, + "subdir": "linux-64", + "timestamp": 1674008552815, + "version": "0.2.2" + }, + "qstylizer-0.2.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >0.3.0,<1.0", + "python >=3.11,<3.12.0a0", + "tinycss2 >=1.1.0,<2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc49f3ac38a059633d88037f8398ac78", + "name": "qstylizer", + "sha256": "37d85c0faefd5da41271524f0933ee9f5a9840b8a2c1255e84f755935f5ac6a9", + "size": 34287, + "subdir": "linux-64", + "timestamp": 1677706179029, + "version": "0.2.2" + }, + "qstylizer-0.2.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >0.3.0,<1.0", + "python >=3.7,<3.8.0a0", + "tinycss2 >=1.1.0,<2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3af610f8777ab27bf054ca93bdfdfe4", + "name": "qstylizer", + "sha256": "6c2f96c002743cb389ffae2d72028b5e7dd8b23674f12f46a3ed1b0a5fc0007a", + "size": 29950, + "subdir": "linux-64", + "timestamp": 1674008578632, + "version": "0.2.2" + }, + "qstylizer-0.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >0.3.0,<1.0", + "python >=3.8,<3.9.0a0", + "tinycss2 >=1.1.0,<2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "36a6bcb8b877ca7d84160eb3d6b5a6d2", + "name": "qstylizer", + "sha256": "c9e385c8a5dab07a0b737d7a6ac2fa5f7cd438e6b39f14e46afa54494797f29c", + "size": 30077, + "subdir": "linux-64", + "timestamp": 1674008629691, + "version": "0.2.2" + }, + "qstylizer-0.2.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >0.3.0,<1.0", + "python >=3.9,<3.10.0a0", + "tinycss2 >=1.1.0,<2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e25538d1f38695b11d2006772c958eb", + "name": "qstylizer", + "sha256": "0a3449a792d155cdf75ff49f3ff0f22cf704a76be06e2c70fcca16b77f83a19e", + "size": 29921, + "subdir": "linux-64", + "timestamp": 1674008604525, + "version": "0.2.2" + }, + "qt-5.15.7-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "qt-main >=5.15,<6", + "qt-webengine >=5.15,<6" + ], + "license": "LGPL-3.0-only", + "md5": "c3814756191b30ef7aa8a514d87db092", + "name": "qt", + "sha256": "634527e036ef3899dc1af7d82185026982c6e8607a48f23ffea6be60b5a44446", + "size": 8961, + "subdir": "linux-64", + "timestamp": 1660110239225, + "version": "5.15.7" + }, + "qt-5.15.9-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "qt-main >=5.15,<6", + "qt-webengine >=5.15,<6" + ], + "license": "LGPL-3.0-only", + "md5": "c782150d07786541c4a3207f93cc7fb2", + "name": "qt", + "sha256": "0173238ab13319dfa355648a0fdc1d6cb1e9cbec186a339e76fcf6bf26f463d5", + "size": 8940, + "subdir": "linux-64", + "timestamp": 1660117585891, + "version": "5.15.9" + }, + "qt-5.6.2-h974d657_12.conda": { + "build": "h974d657_12", + "build_number": 12, + "depends": [ + "dbus >=1.10.22,<2.0a0", + "fontconfig >=2.12.4,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "gst-plugins-base >=1.12.2,<1.13.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb", + "openssl 1.0.*", + "sqlite >=3.20.1,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "0733e97cca33532b482272f1cade718c", + "name": "qt", + "sha256": "c0e311e581e8ea49e31ccac1d68f44766cb463a5670f6ae9c7d4aec3e252ae35", + "size": 36495389, + "subdir": "linux-64", + "timestamp": 1505737498619, + "version": "5.6.2" + }, + "qt-5.6.2-hd25b39d_14.conda": { + "build": "hd25b39d_14", + "build_number": 14, + "depends": [ + "dbus >=1.12.2,<2.0a0", + "fontconfig >=2.12.4,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "gst-plugins-base >=1.12.4,<1.13.0a0", + "gstreamer >=1.12.4,<1.13.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb", + "libxcb >=1.12,<2.0a0", + "libxml2 >=2.9.7,<2.10.0a0", + "openssl 1.0.*", + "openssl >=1.0.2n,<1.0.3a", + "sqlite >=3.22.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "d7b05ac23bdc46b6f324d485a7ad1e58", + "name": "qt", + "sha256": "239b40f6fd6b7133effcb575681fc73e7fc1c1afccbf07e23bb06f03eda04441", + "size": 36496858, + "subdir": "linux-64", + "timestamp": 1518460178064, + "version": "5.6.2" + }, + "qt-5.6.3-h39df351_0.conda": { + "build": "h39df351_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openssl 1.0.*", + "openssl >=1.0.2o,<1.0.3a", + "sqlite >=3.24.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "e0ed539744c59d927787995d09bfd1be", + "name": "qt", + "sha256": "72b0ae810e2ca8b0a6525a02404d847dfe15044250808703a7568181fd2c4443", + "size": 36728585, + "subdir": "linux-64", + "timestamp": 1532424040899, + "version": "5.6.3" + }, + "qt-5.6.3-h39df351_1.conda": { + "build": "h39df351_1", + "build_number": 1, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libxcb >=1.13,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openssl 1.0.*", + "openssl >=1.0.2p,<1.0.3a", + "sqlite >=3.24.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "b83fbb22f9b657ce0bd6cdeecfc8ccb5", + "name": "qt", + "sha256": "c2720b22f26de32ed65f41b14646a1d57bc67f842532f9197a7b1828e6d3663c", + "size": 36958329, + "subdir": "linux-64", + "timestamp": 1535128668623, + "version": "5.6.3" + }, + "qt-5.6.3-h8bf5577_3.conda": { + "build": "h8bf5577_3", + "build_number": 3, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.2,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.35,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libxcb >=1.13,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "sqlite >=3.25.3,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "568460272c01505b277db72345982817", + "name": "qt", + "sha256": "26ca8655fcf9be6d464370d5e4aeb06f7001214825617e5598db8b102594aab3", + "size": 38128599, + "subdir": "linux-64", + "timestamp": 1543476509689, + "version": "5.6.3" + }, + "qt-5.9.4-h4e5bff0_0.conda": { + "build": "h4e5bff0_0", + "build_number": 0, + "depends": [ + "dbus >=1.12.2,<2.0a0", + "expat >=2.2.5,<3.0a0", + "fontconfig >=2.12.6,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.53.6,<3.0a0", + "gst-plugins-base >=1.12.4,<1.13.0a0", + "gstreamer >=1.12.4,<1.13.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb", + "libxcb >=1.12,<2.0a0", + "libxml2 >=2.9.7,<2.10.0a0", + "openssl 1.0.*", + "sqlite >=3.22.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "863bc8cd26d62f9ff67dafcfadf82e3b", + "name": "qt", + "sha256": "f9dec22556eaca3800ff92805e6f802d2a0720ce32b638d93d232446bd365416", + "size": 70697717, + "subdir": "linux-64", + "timestamp": 1521774952636, + "version": "5.9.4" + }, + "qt-5.9.5-h7e424d6_0.conda": { + "build": "h7e424d6_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "expat >=2.2.5,<3.0a0", + "fontconfig >=2.12.6,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb", + "libxcb >=1.13,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openssl 1.0.*", + "sqlite >=3.22.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "ca4ba1f4af8332e2b3c5fdbaa49677ae", + "name": "qt", + "sha256": "7ce2e810a8a39e4ef52056713058f7a525a2f8051ed2723d2ea1fef322cecc89", + "size": 70861123, + "subdir": "linux-64", + "timestamp": 1523721496651, + "version": "5.9.5" + }, + "qt-5.9.6-h52aff34_0.conda": { + "build": "h52aff34_0", + "build_number": 0, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "expat >=2.2.5,<3.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxcb >=1.13,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openssl 1.0.*", + "sqlite >=3.23.1,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "68e3fe859bc1418a482769b5d6f1e224", + "name": "qt", + "sha256": "3f8c0fb8f109f999955d5ddf653b4c1dbac6ae31bc7c85921eeb0e7bae248ec3", + "size": 70596818, + "subdir": "linux-64", + "timestamp": 1529023870444, + "version": "5.9.6" + }, + "qt-5.9.6-h8703b6f_2.conda": { + "build": "h8703b6f_2", + "build_number": 2, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "expat >=2.2.5,<3.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libxcb >=1.13,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openssl 1.0.*", + "sqlite >=3.24.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "6a70af309ac373f3b2275110623d27a7", + "name": "qt", + "sha256": "65b9cb8d0e4ccf6f98cf47a02c2c22f42a15d40f75ea1700cdaf13cfba26fcd5", + "size": 71093485, + "subdir": "linux-64", + "timestamp": 1535100214597, + "version": "5.9.6" + }, + "qt-5.9.7-h5867ecd_1.conda": { + "build": "h5867ecd_1", + "build_number": 1, + "depends": [ + "dbus >=1.13.2,<2.0a0", + "expat >=2.2.6,<3.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "glib >=2.56.2,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.35,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libxcb >=1.13,<2.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "openssl 1.1.*", + "sqlite >=3.25.3,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "LGPL-3.0", + "md5": "05507dbc35c46ac5a7066fc860a62341", + "name": "qt", + "sha256": "5085610d80131ae721bd206af12857acaa4bc1b7b0eda6bc07c52f2277e9db25", + "size": 71813912, + "subdir": "linux-64", + "timestamp": 1544604609235, + "version": "5.9.7" + }, + "qt-main-5.15.2-h327a75a_4.conda": { + "build": "h327a75a_4", + "build_number": 4, + "constrains": [ + "qt 5.15.2" + ], + "depends": [ + "__glibc >=2.17,<3.0.a0", + "dbus >=1.13.18,<2.0a0", + "expat >=2.2.10,<3.0a0", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "libclang >=10.0.1,<11.0a0", + "libevent >=2.1.12,<2.1.13.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libstdcxx-ng >=11.2.0", + "libxcb >=1.15,<2.0a0", + "libxkbcommon >=1.0.1,<2.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "nspr >=4.33,<5.0a0", + "nss >=3.74,<4.0a0", + "sqlite >=3.38.5,<4.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "LGPL-3.0-only", + "md5": "125ee4272ab9e044f2f75c5186387422", + "name": "qt-main", + "sha256": "f8c764a479ee3cda99534a532e8ba45cea90871e555226fdcc9e2c6741b11326", + "size": 47022947, + "subdir": "linux-64", + "timestamp": 1658662615444, + "version": "5.15.2" + }, + "qt-main-5.15.2-h327a75a_6.conda": { + "build": "h327a75a_6", + "build_number": 6, + "constrains": [ + "qt 5.15.2" + ], + "depends": [ + "__glibc >=2.17,<3.0.a0", + "dbus >=1.13.18,<2.0a0", + "expat >=2.2.10,<3.0a0", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "libclang >=10.0.1,<11.0a0", + "libevent >=2.1.12,<2.1.13.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libstdcxx-ng >=11.2.0", + "libxcb >=1.15,<2.0a0", + "libxkbcommon >=1.0.1,<2.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "nspr >=4.33,<5.0a0", + "nss >=3.74,<4.0a0", + "sqlite >=3.38.5,<4.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "LGPL-3.0-only", + "md5": "c4bd60f8d5b941cfafe73458eb55ea79", + "name": "qt-main", + "sha256": "6159a4351d6ea0283e8e296e0504ff5e29ce62e1b518a4f99ade4677abf7d2ec", + "size": 47563524, + "subdir": "linux-64", + "timestamp": 1659430105371, + "version": "5.15.2" + }, + "qt-main-5.15.2-h327a75a_7.conda": { + "build": "h327a75a_7", + "build_number": 7, + "constrains": [ + "qt >=5.15.2,<6" + ], + "depends": [ + "__glibc >=2.17,<3.0.a0", + "dbus >=1.13.18,<2.0a0", + "expat >=2.2.10,<3.0a0", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "libclang >=10.0.1,<11.0a0", + "libevent >=2.1.12,<2.1.13.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libstdcxx-ng >=11.2.0", + "libxcb >=1.15,<2.0a0", + "libxkbcommon >=1.0.1,<2.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "nspr >=4.33,<5.0a0", + "nss >=3.74,<4.0a0", + "sqlite >=3.39.2,<4.0a0", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "LGPL-3.0-only", + "md5": "1868b206ade356f1812a723804e1cc31", + "name": "qt-main", + "sha256": "b2452758d0c3a5292c6cff71f24d3e1120c280e71222da12c46f8813620e4e3e", + "size": 47260771, + "subdir": "linux-64", + "timestamp": 1660127804289, + "version": "5.15.2" + }, + "qt-main-5.15.2-h8373d8f_8.conda": { + "build": "h8373d8f_8", + "build_number": 8, + "constrains": [ + "qt >=5.15.2,<6" + ], + "depends": [ + "__glibc >=2.17,<3.0.a0", + "dbus >=1.13.18,<2.0a0", + "expat >=2.4.9,<3.0a0", + "fontconfig >=2.14.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "gst-plugins-base >=1.14.1,<1.15.0a0", + "gstreamer >=1.14.1,<1.15.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "krb5 >=1.19.4,<1.20.0a0", + "libclang >=14.0.6,<15.0a0", + "libclang13 >=14.0.6", + "libevent >=2.1.12,<2.1.13.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.39,<1.7.0a0", + "libpq >=12.9,<13.0a0", + "libstdcxx-ng >=11.2.0", + "libxcb >=1.15,<2.0a0", + "libxkbcommon >=1.0.1,<2.0a0", + "libxml2 >=2.10.3,<2.11.0a0", + "nspr >=4.33,<5.0a0", + "nss >=3.74,<4.0a0", + "openssl >=1.1.1t,<1.1.2a", + "sqlite >=3.41.1,<4.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "LGPL-3.0-only", + "license_family": "LGPL", + "md5": "fd275fd09d648f31bfdb27aebb239eeb", + "name": "qt-main", + "sha256": "3bce5fdacaddf0fe3373ff13bb377f2c280eca243d1a66479951bee75ac81b46", + "size": 56317233, + "subdir": "linux-64", + "timestamp": 1680303411260, + "version": "5.15.2" + }, + "qt-webengine-5.15.9-hbbf29b9_6.conda": { + "build": "hbbf29b9_6", + "build_number": 6, + "constrains": [ + "qt >=5.15.2,<6" + ], + "depends": [ + "__glibc >=2.17,<3.0.a0", + "dbus >=1.13.18,<2.0a0", + "expat >=2.4.9,<3.0a0", + "fontconfig >=2.14.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "libevent >=2.1.12,<2.1.13.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxcb >=1.15,<2.0a0", + "libxkbcommon >=1.0.1,<2.0a0", + "libxml2 >=2.10.3,<2.11.0a0", + "qt-main >=5.15,<6.0a0", + "qt-main >=5.15.2,<5.16.0a0" + ], + "license": "LGPL-3.0-only", + "license_family": "LGPL", + "md5": "9f2b3a9673e955f7ecc9e814d9afc9f5", + "name": "qt-webengine", + "sha256": "5ef67f46ca0d7911178843da80cdcab6dd556286da74525fc10c1ddfd74bdb85", + "size": 51625963, + "subdir": "linux-64", + "timestamp": 1680703011635, + "version": "5.15.9" + }, + "qt-webengine-5.15.9-hd2b0992_4.conda": { + "build": "hd2b0992_4", + "build_number": 4, + "constrains": [ + "qt 5.15.9" + ], + "depends": [ + "__glibc >=2.17,<3.0.a0", + "dbus >=1.13.18,<2.0a0", + "expat >=2.2.10,<3.0a0", + "fontconfig >=2.13.1,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "glib >=2.69.1,<3.0a0", + "libevent >=2.1.12,<2.1.13.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxcb >=1.15,<2.0a0", + "libxkbcommon >=1.0.1,<2.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "qt-main >=5.15,<6.0a0", + "qt-main >=5.15.2,<5.16.0a0" + ], + "license": "LGPL-3.0-only", + "md5": "ed674e212597b93fffa1afc90a3e100c", + "name": "qt-webengine", + "sha256": "ae1c3953ae2cfdf73752c38e0a78d3ee41d74a8689ee897a24f9250067af91db", + "size": 49372478, + "subdir": "linux-64", + "timestamp": 1658760764896, + "version": "5.15.9" + }, + "qtawesome-0.4.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "f53aaed9f6d5015a3747eaebbbe1d739", + "name": "qtawesome", + "sha256": "12b1cc4f5c32db6ef5fb72ff90fc1871c2c41f9f1b1db3ea78309c5f370efb6f", + "size": 151492, + "subdir": "linux-64", + "timestamp": 1530923195100, + "version": "0.4.4" + }, + "qtawesome-0.4.4-py27hd7914c3_0.conda": { + "build": "py27hd7914c3_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "5059c2310a4b2133d6665afa17208a5a", + "name": "qtawesome", + "sha256": "cd9bfa28d5e3d9e361e105c221d87a4879f292ea441792ff0394f61238e1e21d", + "size": 150446, + "subdir": "linux-64", + "timestamp": 1505752901983, + "version": "0.4.4" + }, + "qtawesome-0.4.4-py35hd68ff89_0.conda": { + "build": "py35hd68ff89_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "b997d0c9cabfa089b002793c8ef7cee2", + "name": "qtawesome", + "sha256": "316b434bcd4db07cb02476e7d30114ccfb4ed93be7a6feb236de84867af31bdd", + "size": 150548, + "subdir": "linux-64", + "timestamp": 1505752919276, + "version": "0.4.4" + }, + "qtawesome-0.4.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "9393fa8b8897454914485b514a0636d3", + "name": "qtawesome", + "sha256": "cfa3cfc3fd7822bb6a596d96374f140fafd5a238d120a70cd955c4db1416cb54", + "size": 151481, + "subdir": "linux-64", + "timestamp": 1530923119056, + "version": "0.4.4" + }, + "qtawesome-0.4.4-py36h609ed8c_0.conda": { + "build": "py36h609ed8c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "22320d99c2ae4c058d4875c8cd9efc84", + "name": "qtawesome", + "sha256": "d8f99385cf31f4c129fa487cf4bc10bc3c5f7a872788a20df1e5af6e1e043ee5", + "size": 150504, + "subdir": "linux-64", + "timestamp": 1505752936543, + "version": "0.4.4" + }, + "qtawesome-0.4.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "61a8aa4868433ba365075723bb6ad9df", + "name": "qtawesome", + "sha256": "9e42f322852e205f194abe8aeac54ef5724a8c31fb8f8728c6bf9a2bdb5ace4d", + "size": 151518, + "subdir": "linux-64", + "timestamp": 1530923157442, + "version": "0.4.4" + }, + "qtawesome-0.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "4a6f0d3ca25b9f1d9a0ae71afe932201", + "name": "qtawesome", + "sha256": "54a7b98201cb838a4325cded7cc608929babf30fd905f84ce0f2816049ec6c8a", + "size": 536342, + "subdir": "linux-64", + "timestamp": 1538159521601, + "version": "0.5.0" + }, + "qtawesome-0.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "14307c9844c12577e971483556c8071c", + "name": "qtawesome", + "sha256": "cdf5c3d29752dc5ac19254704b0f74641ead7812878cb722ecdbad687d9c4f3c", + "size": 535003, + "subdir": "linux-64", + "timestamp": 1538159555044, + "version": "0.5.0" + }, + "qtawesome-0.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "ac639528e96a8cb6394ad92382c7119a", + "name": "qtawesome", + "sha256": "6e3d0bf83a71b8886ce8fd9014d316f64f8a7de833861bf22f30162e4bc92536", + "size": 536312, + "subdir": "linux-64", + "timestamp": 1538159507312, + "version": "0.5.0" + }, + "qtawesome-0.5.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "60d3e7d1c57e66e876014173ddc09d17", + "name": "qtawesome", + "sha256": "b7035035a58bb76e5c2250c7717ba12316757ae20388e12e42b474ecaa8d93d6", + "size": 535260, + "subdir": "linux-64", + "timestamp": 1539024955563, + "version": "0.5.1" + }, + "qtawesome-0.5.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "af3d1c33cd5f78b804d54e662c8bf781", + "name": "qtawesome", + "sha256": "96eb29674a61d71dfc8c9d8c6f6bb27ad782b41f3c51b16e460da0abebaf4893", + "size": 535254, + "subdir": "linux-64", + "timestamp": 1539024985100, + "version": "0.5.1" + }, + "qtawesome-0.5.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "be29bb6f30134ed6a7790b269be68a95", + "name": "qtawesome", + "sha256": "e81293aa909a645181d4dbd998df72a45b122e00577b4468c76c3bc6eb77d305", + "size": 536635, + "subdir": "linux-64", + "timestamp": 1539024943485, + "version": "0.5.1" + }, + "qtawesome-0.5.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "ddb77cfe2ac85062d25d9c1ac0c13da9", + "name": "qtawesome", + "sha256": "6c6695c8f9672738e8e2817cc24e284969c4207313e331180c90b668de71a33d", + "size": 552453, + "subdir": "linux-64", + "timestamp": 1541042640535, + "version": "0.5.2" + }, + "qtawesome-0.5.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "471cb1026d86fd5bcf647be3e98f87d4", + "name": "qtawesome", + "sha256": "028a71501cc0206962570c1f05db3bbd158a738855f9e68811576d806d47f055", + "size": 552588, + "subdir": "linux-64", + "timestamp": 1541042681460, + "version": "0.5.2" + }, + "qtawesome-0.5.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "3bdeb8910f2f55fdbc857697c457b5f2", + "name": "qtawesome", + "sha256": "80eacb141b9be5467effcb9ecfaa5d5633e6136a4bece2f09c625246567477f4", + "size": 552586, + "subdir": "linux-64", + "timestamp": 1541042640788, + "version": "0.5.2" + }, + "qtawesome-0.5.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "874c90a9bedc68ab8732f3952e193f46", + "name": "qtawesome", + "sha256": "f98611fcb858807d5ba67916b76e7d3cbe678e56a7d169027e88bfdf5c3bb8b8", + "size": 562545, + "subdir": "linux-64", + "timestamp": 1542391817989, + "version": "0.5.3" + }, + "qtawesome-0.5.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "01af3285802a4223afa513e1b6340e14", + "name": "qtawesome", + "sha256": "661f3eb58fa482f745f4c55bdcda9b7191763e1fdca30db94e8374cd8d25762a", + "size": 562664, + "subdir": "linux-64", + "timestamp": 1542391817875, + "version": "0.5.3" + }, + "qtawesome-0.5.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "7fb98d7eaf8a3105801ce17776167f35", + "name": "qtawesome", + "sha256": "732a4da724122812a34a0aa2103a3beef423a3d402d3d2206180d4408a50238a", + "size": 564387, + "subdir": "linux-64", + "timestamp": 1542391791766, + "version": "0.5.3" + }, + "qtawesome-0.5.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "e9b2f87a61c7d222859b32b73f607d18", + "name": "qtawesome", + "sha256": "58d7c6384c6f3112250c1bba8ac786298c8f3a2e3d9430a275e530b11667a2f2", + "size": 581320, + "subdir": "linux-64", + "timestamp": 1547489021888, + "version": "0.5.5" + }, + "qtawesome-0.5.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "fbc58c7dfb0ef7200ccb396e6d338a98", + "name": "qtawesome", + "sha256": "f595067eed836311fe6f7a6a70d79849d38fbdcf84e6c325937d72a52b7f494e", + "size": 581423, + "subdir": "linux-64", + "timestamp": 1547488978796, + "version": "0.5.5" + }, + "qtawesome-0.5.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "06a66b4b76ae80555411247b39255df8", + "name": "qtawesome", + "sha256": "b93153ffea3873137c5c6ffab0813bb65cb6f7c8e1daf05e98a54995ccd39dfd", + "size": 579334, + "subdir": "linux-64", + "timestamp": 1547488990374, + "version": "0.5.5" + }, + "qtawesome-0.5.7-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "37eeb281447648341f8d96ba61827290", + "name": "qtawesome", + "sha256": "a6521bcc068e5f2c063252f408ba53f2ebf04bcc40c44be37eb5a0a8f569a669", + "size": 582683, + "subdir": "linux-64", + "timestamp": 1553303685041, + "version": "0.5.7" + }, + "qtawesome-0.5.7-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "185faec6d393dbf7ce08c656926eef27", + "name": "qtawesome", + "sha256": "6d3ee0452ad591c0fa3f9a21a75d956d2bf44be44c410971f5de63ae406d08e0", + "size": 580500, + "subdir": "linux-64", + "timestamp": 1553303696199, + "version": "0.5.7" + }, + "qtawesome-0.5.7-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "qtpy", + "six" + ], + "license": "MIT", + "md5": "fc7bdda7bd79b47c31481a1fb5a808f2", + "name": "qtawesome", + "sha256": "a805796303995dbf243ddb577fb871dc2de28ca995dff729f54cc6bafd0adabf", + "size": 580531, + "subdir": "linux-64", + "timestamp": 1553303673872, + "version": "0.5.7" + }, + "qtawesome-1.2.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "qtpy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62ed6421c0ab731b87e9416f19b53def", + "name": "qtawesome", + "sha256": "d324e535ffe3ef835b3646cb78d1c23468721d43c53f0039c7038f653639e70b", + "size": 1631320, + "subdir": "linux-64", + "timestamp": 1674008751573, + "version": "1.2.2" + }, + "qtawesome-1.2.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "qtpy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77e73abb5a3fc051a97603b600a85632", + "name": "qtawesome", + "sha256": "566d858169480f99f5eaad042fa5bbb4fb1a250107ad1944d29da490bbb32639", + "size": 1533328, + "subdir": "linux-64", + "timestamp": 1677705185029, + "version": "1.2.2" + }, + "qtawesome-1.2.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "qtpy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f7bd9329572474d554b6933ff7d0b94f", + "name": "qtawesome", + "sha256": "3e18fc389b5c1a2f506ed1a05e5ffb0009793e78df5e6c862cebd8398fd654a5", + "size": 1630585, + "subdir": "linux-64", + "timestamp": 1674008818893, + "version": "1.2.2" + }, + "qtawesome-1.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "qtpy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0045bb95860b2bf86b1e9a35a3b59d4f", + "name": "qtawesome", + "sha256": "e3b8eae40b20b3b6e2b8c1896e3e20ddbfded1cf66cb16a8b452b3351c5da390", + "size": 1631281, + "subdir": "linux-64", + "timestamp": 1674008714109, + "version": "1.2.2" + }, + "qtawesome-1.2.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "qtpy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "27e6c75986060f4051e64b1860085341", + "name": "qtawesome", + "sha256": "1259a3ca870a45e31872928835d54d3801a9ae4b017e90546eda00e822724fad", + "size": 1630572, + "subdir": "linux-64", + "timestamp": 1674008785572, + "version": "1.2.2" + }, + "qtconsole-4.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "1255e0b0733060bb7d86d3f5ff2595a4", + "name": "qtconsole", + "sha256": "ca284d6611d6d93bc04a6d8cbe062a6136972cf3ce76dfd29fe05efbeb16b1db", + "size": 155418, + "subdir": "linux-64", + "timestamp": 1530890864903, + "version": "4.3.1" + }, + "qtconsole-4.3.1-py27hc444b0d_0.conda": { + "build": "py27hc444b0d_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "ed28e3aecb20a5d88daab928236e272f", + "name": "qtconsole", + "sha256": "ad0f88d22a8eb69e53af4c1394bd33e0b20d4f601bbde12374f4bce34ec01be0", + "size": 155188, + "subdir": "linux-64", + "timestamp": 1505863849178, + "version": "4.3.1" + }, + "qtconsole-4.3.1-py35h4626a06_0.conda": { + "build": "py35h4626a06_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.5,<3.6.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "4f2482502c9d1a6efa6fb9e3de66c927", + "name": "qtconsole", + "sha256": "f5482d02441b019de46495c1654605410fe8bfb2152bd7a380cd58e1c3319cf0", + "size": 160384, + "subdir": "linux-64", + "timestamp": 1505869780631, + "version": "4.3.1" + }, + "qtconsole-4.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "dc8632774bdb9782a0b84b4a290d23d2", + "name": "qtconsole", + "sha256": "03f2a031bbc96e63a7f8fe93cb3f7ed527ecfd9fd80729d4175b18af7b147bc4", + "size": 156414, + "subdir": "linux-64", + "timestamp": 1530890814821, + "version": "4.3.1" + }, + "qtconsole-4.3.1-py36h8f73b5b_0.conda": { + "build": "py36h8f73b5b_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "a9cb650082ab933623cd2d4ae4f29dc9", + "name": "qtconsole", + "sha256": "e62bd277ba7eb0cc533538d4aab2b7f3ee5b774af38f7312136ce66fa3d808ef", + "size": 158996, + "subdir": "linux-64", + "timestamp": 1505869807905, + "version": "4.3.1" + }, + "qtconsole-4.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "3103e88d94f7667351b93cd0bb846b1b", + "name": "qtconsole", + "sha256": "8e0cad50e0897bb38fd153d96d3373f82d3c956a037b0182aa5744c426010389", + "size": 156612, + "subdir": "linux-64", + "timestamp": 1530890763957, + "version": "4.3.1" + }, + "qtconsole-4.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt >=5.9.2,<5.10.0a0", + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "a51e358a503f4a113f421aa832c69fb6", + "name": "qtconsole", + "sha256": "4b2096214fd361aa1cb91b2209f373cc2d3a5cdf6dac711fcba87ed2020698fc", + "size": 161280, + "subdir": "linux-64", + "timestamp": 1534428395196, + "version": "4.4.0" + }, + "qtconsole-4.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.5,<3.6.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "184987a2db605e89116389074782d588", + "name": "qtconsole", + "sha256": "5957f40238709ea5293045a46f1d45c78e995c132c2d14e3fbf4bea0e23670cf", + "size": 163720, + "subdir": "linux-64", + "timestamp": 1534428752589, + "version": "4.4.0" + }, + "qtconsole-4.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "bd7df1332d909edf4a87c9682d162b6c", + "name": "qtconsole", + "sha256": "4d3c549b610accc3dd4ec1b75d17c79e87430f9425ed2dd907f051eb1f39f31e", + "size": 162444, + "subdir": "linux-64", + "timestamp": 1534428682274, + "version": "4.4.0" + }, + "qtconsole-4.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "c43da20e29e95bef52993797577a9809", + "name": "qtconsole", + "sha256": "2ffbc93803d778d1fd182ea3b81ab8c74ad3c548863be9bf7c787e13fc127ca7", + "size": 165089, + "subdir": "linux-64", + "timestamp": 1534428759313, + "version": "4.4.0" + }, + "qtconsole-4.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt >=5.9.2,<5.10.0a0", + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "66036d5067a89e94633726f77b6e3e37", + "name": "qtconsole", + "sha256": "0416f13b75260955e12ce6cb787a42d1d8a09cb7ad695496c1ef54980c0f55ce", + "size": 161454, + "subdir": "linux-64", + "timestamp": 1535391617506, + "version": "4.4.1" + }, + "qtconsole-4.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.5,<3.6.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "b9e591391041b514089924dcd1d47378", + "name": "qtconsole", + "sha256": "cd8f1b108ccb29a8e8f785558f2ccb289f45a4164a9929c46f58b93f541d3b88", + "size": 166524, + "subdir": "linux-64", + "timestamp": 1535391645238, + "version": "4.4.1" + }, + "qtconsole-4.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "4442af72a04ccac210d893276913641d", + "name": "qtconsole", + "sha256": "31723edb4db6aaa9e001a3b7bbdca7305b56c14ac75f084cdebfb302254e3660", + "size": 165127, + "subdir": "linux-64", + "timestamp": 1535391479393, + "version": "4.4.1" + }, + "qtconsole-4.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt >=5.9.2,<5.10.0a0", + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "7e98f56c249048120050959a3770916e", + "name": "qtconsole", + "sha256": "3bf2a23cfc1e2fee00b9e7abc30cbce8c4fe99056ca162cb2c5921c6df2bebb1", + "size": 162799, + "subdir": "linux-64", + "timestamp": 1535391243261, + "version": "4.4.1" + }, + "qtconsole-4.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "be6162b84e5bffd6173f402cc0021cfc", + "name": "qtconsole", + "sha256": "b9e824c85a2f8ce58dfbc0744926299d902a4c64ce9646970ec45c812c323e68", + "size": 162533, + "subdir": "linux-64", + "timestamp": 1539885085751, + "version": "4.4.2" + }, + "qtconsole-4.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "8e47cb9c361756639b0f03183bfd5b5d", + "name": "qtconsole", + "sha256": "8bb945d51831786a36feba5ebcfd19d2e8390c5e73f47e51655b5b44435dfae7", + "size": 166389, + "subdir": "linux-64", + "timestamp": 1539885115390, + "version": "4.4.2" + }, + "qtconsole-4.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "8f0da6a54ebe812c25a0ced1761aae4a", + "name": "qtconsole", + "sha256": "82c8d72077bbcbc6e24cca10f1941c541425a21fe714c365b41fcc239a23bb97", + "size": 166572, + "subdir": "linux-64", + "timestamp": 1539885132840, + "version": "4.4.2" + }, + "qtconsole-4.4.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=2.7,<2.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "7ec2874712797b670a60468e569fc6a2", + "name": "qtconsole", + "sha256": "9e97f7a8a9e3ccf9c578ba3f28eaacdf4f417010b5c59905a24a6789cac5d88a", + "size": 165609, + "subdir": "linux-64", + "timestamp": 1544549603973, + "version": "4.4.3" + }, + "qtconsole-4.4.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.6,<3.7.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "3b0570fdae3dee3493c66af5dadb4017", + "name": "qtconsole", + "sha256": "9f876bc16e9531b8af0c0ef0502d9099ff69129c0fa4ae39c89d2afae5b238ff", + "size": 164732, + "subdir": "linux-64", + "timestamp": 1544549523764, + "version": "4.4.3" + }, + "qtconsole-4.4.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "traitlets" + ], + "license": "BSD 3-Clause", + "md5": "0a07a421facd1608a9537402ed8168bf", + "name": "qtconsole", + "sha256": "4b3e4c0719a39f1798a3df8877bae70db6631320beb207ba2d3634cb0729299c", + "size": 167456, + "subdir": "linux-64", + "timestamp": 1544549364180, + "version": "4.4.3" + }, + "qtconsole-5.3.1-py310h06a4308_0.conda": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.10,<3.11.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c6930511706c22655e4f964f93eb47f3", + "name": "qtconsole", + "sha256": "5a8c9451f22c81c3fbed6db7152a0c16dfd5d211bd9e8faf8c5905f949c56197", + "size": 181445, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1657544165033, + "type": "app", + "version": "5.3.1" + }, + "qtconsole-5.3.1-py310h06a4308_1.conda": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.10,<3.11.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7d2fe27635df8f22d5efb225397c2840", + "name": "qtconsole", + "sha256": "9db678c3ff01a9d2febaa3d2b9ffad373c70464f8bcca7bf7544b92e7f6a1000", + "size": 184888, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1659510321714, + "type": "app", + "version": "5.3.1" + }, + "qtconsole-5.3.1-py37h06a4308_0.conda": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "11734dbdba16f71c3f3bcf8c359b8b7b", + "name": "qtconsole", + "sha256": "4f74b988bdb71c74c3014b4e7e4cebde0a7744f0feb793f8676740b328fdd54e", + "size": 179615, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1657544102623, + "type": "app", + "version": "5.3.1" + }, + "qtconsole-5.3.1-py37h06a4308_1.conda": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b10d2f6c8ecbc604598cff74b4393e48", + "name": "qtconsole", + "sha256": "24304c800df6efa50a5f82f35a2645c96a9f895f949c5c22d22e11c0a75fac2d", + "size": 182976, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1659510354881, + "type": "app", + "version": "5.3.1" + }, + "qtconsole-5.3.1-py38h06a4308_0.conda": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.8,<3.9.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "150495ff1faa19ca22efeef106d7a66e", + "name": "qtconsole", + "sha256": "60264767a7d3ec31b12006b9dea3b136c5a87bdcae95373c820c9fe2b506bd2f", + "size": 180223, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1657544208200, + "type": "app", + "version": "5.3.1" + }, + "qtconsole-5.3.1-py38h06a4308_1.conda": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.8,<3.9.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6a049074332272a0cd604484efaed379", + "name": "qtconsole", + "sha256": "11b183762fb04ba98dd246ee4d929659032ae325d2d7fa570243a605d59e691b", + "size": 183663, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1659510412603, + "type": "app", + "version": "5.3.1" + }, + "qtconsole-5.3.1-py39h06a4308_0.conda": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.9,<3.10.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b6d497ad912670eb1087fae6cfb49c3c", + "name": "qtconsole", + "sha256": "5eaee31b5360d09ce46ca457ed1e2b04bae3a525b3e2260f3e60397502942538", + "size": 180126, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1657544251357, + "type": "app", + "version": "5.3.1" + }, + "qtconsole-5.3.1-py39h06a4308_1.conda": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.9,<3.10.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e6480db1f4211b7e6362e26a7eb294fb", + "name": "qtconsole", + "sha256": "bfcd6eaa81a59560b3f13bc4d1bc0330fa1f2b1f4c6e72fd9c76443c1606c53a", + "size": 183470, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1659510384519, + "type": "app", + "version": "5.3.1" + }, + "qtconsole-5.3.2-py310h06a4308_0.conda": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.10,<3.11.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3511f9533d99acbf8dd6d19687e8b4a9", + "name": "qtconsole", + "sha256": "683612f89c2a231841244b4051de0ac77217dbadac683edee4342c061efdec82", + "size": 181207, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1662018353317, + "type": "app", + "version": "5.3.2" + }, + "qtconsole-5.3.2-py311h06a4308_0.conda": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.11,<3.12.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0f9ba53f83bb2a660a709ddc83496bec", + "name": "qtconsole", + "sha256": "034e3c9c84764e802dc0d6cb0355443f066e2e153b0f69ea133a1813ea5f2967", + "size": 244497, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1676828772946, + "type": "app", + "version": "5.3.2" + }, + "qtconsole-5.3.2-py37h06a4308_0.conda": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0f2a6b24b708ba9e1e7292e9fa151706", + "name": "qtconsole", + "sha256": "837568e79b173a8c6dfe2073fca8699d2faefdcd82993aab141772b453387c15", + "size": 179332, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1662018427158, + "type": "app", + "version": "5.3.2" + }, + "qtconsole-5.3.2-py38h06a4308_0.conda": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.8,<3.9.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e55e3e134fa228b429da8ff6a2918245", + "name": "qtconsole", + "sha256": "ce9df6deba5a53f08d98c195b447065060d0e1e9f0bf874094597fee27a3889a", + "size": 179989, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1662018389762, + "type": "app", + "version": "5.3.2" + }, + "qtconsole-5.3.2-py39h06a4308_0.conda": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.9,<3.10.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "81e16b742b8ee6f16955ce8a8060288c", + "name": "qtconsole", + "sha256": "f56746b8cf635aed7c073ddca709bb4f189c46d0323b4a0c5b8bb54bcde89014", + "size": 179874, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1662018292640, + "type": "app", + "version": "5.3.2" + }, + "qtconsole-5.4.0-py310h06a4308_0.conda": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.10,<3.11.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0034b589b9c665b0252733b05ee159b8", + "name": "qtconsole", + "sha256": "a7920169a451ee0a95b113b3d89a89fa293a9b8e86ec1337a75f33eed3409f49", + "size": 195875, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1674008573146, + "type": "app", + "version": "5.4.0" + }, + "qtconsole-5.4.0-py311h06a4308_0.conda": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.11,<3.12.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "059a3943642e40e3c676770c999e2f6c", + "name": "qtconsole", + "sha256": "6191b28f2b9b816c25d67f7dfddc6d765ac473f22518eb31087f46fa4b9d098d", + "size": 243384, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1677705044600, + "type": "app", + "version": "5.4.0" + }, + "qtconsole-5.4.0-py37h06a4308_0.conda": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.7,<3.8.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8ce64efd9ae3dd3ae8ecb86687cb2768", + "name": "qtconsole", + "sha256": "63d0d2bf47f559278c838ed63ca08c433a2d38e04cad0bd33570a74e87defd7a", + "size": 193972, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1674008459719, + "type": "app", + "version": "5.4.0" + }, + "qtconsole-5.4.0-py38h06a4308_0.conda": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.8,<3.9.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b108f8245738ae5dcf4fdee23db79ad4", + "name": "qtconsole", + "sha256": "c8e9fd37d4e72c41598ff19143c8df1d6acc905f00b1415ee81079715146573a", + "size": 194472, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1674008537457, + "type": "app", + "version": "5.4.0" + }, + "qtconsole-5.4.0-py39h06a4308_0.conda": { + "app_entry": "jupyter-qtconsole", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.1", + "ipython_genutils", + "jupyter_client >=4.1", + "jupyter_core", + "pygments", + "pyqt", + "python >=3.9,<3.10.0a0", + "pyzmq >=17.1", + "qtpy >=2.0.1", + "traitlets !=5.2.1,!=5.2.2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "20f78ecc33e8ff63fb387df36e09836e", + "name": "qtconsole", + "sha256": "41c9b210acf3f1c0bccdef4be57c07330421c8e82c71be0a8cd99a1efb089280", + "size": 194305, + "subdir": "linux-64", + "summary": "Jupyter Qt Console", + "timestamp": 1674008501012, + "type": "app", + "version": "5.4.0" + }, + "qtpy-1.3.1-py27h63d3751_0.conda": { + "build": "py27h63d3751_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f6b87447585901460d6263a7aa8b35e6", + "name": "qtpy", + "sha256": "ca5ce3a768ff1b1acead1edcc97703ab006eee2e887bec6798f54675c40f1d9b", + "size": 41373, + "subdir": "linux-64", + "timestamp": 1505752850057, + "version": "1.3.1" + }, + "qtpy-1.3.1-py35h881af26_0.conda": { + "build": "py35h881af26_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "83e33f20f31a6b165f6e6f1e427d05c6", + "name": "qtpy", + "sha256": "dd3c66fd0891cbbebae21a2f95e188c90f474656a89dfe52648f5d1d3029d3fa", + "size": 41349, + "subdir": "linux-64", + "timestamp": 1505752867082, + "version": "1.3.1" + }, + "qtpy-1.3.1-py36h3691cc8_0.conda": { + "build": "py36h3691cc8_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d228dcff30be6b0eb7af7fba9471dffc", + "name": "qtpy", + "sha256": "571d94024935e17559e7a53b1f937709fb4004099eb2e928e9541fc6277cf715", + "size": 40899, + "subdir": "linux-64", + "timestamp": 1505752884339, + "version": "1.3.1" + }, + "qtpy-1.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ce0b5db03c408d3658e2ef6cf7462418", + "name": "qtpy", + "sha256": "e6900b4b04919ff01acdd45dbe6577ada03c0eac35fd682b141e721925ebb7c9", + "size": 44431, + "subdir": "linux-64", + "timestamp": 1520877362921, + "version": "1.4.0" + }, + "qtpy-1.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "0f2486666b89351ebd37e5f16ba9e9bc", + "name": "qtpy", + "sha256": "eab392025f0ba82fe63ba5f2d3976a53530ad82863519789fb4d25b5fb8de687", + "size": 45102, + "subdir": "linux-64", + "timestamp": 1520877388930, + "version": "1.4.0" + }, + "qtpy-1.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1a2c59bc29ffd7587be8f88157cfc1ec", + "name": "qtpy", + "sha256": "de7f734b9a041f2f68318d506ef03d3d8c7b52a426247dd4103877425eaabfea", + "size": 44680, + "subdir": "linux-64", + "timestamp": 1520877346488, + "version": "1.4.0" + }, + "qtpy-1.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ec13ad8c1655278499f7e1e052b624e6", + "name": "qtpy", + "sha256": "bac1afedfa664c0c85524a7b0f97622b191fa4fb109a1190936572a65f9539c8", + "size": 44688, + "subdir": "linux-64", + "timestamp": 1525206911220, + "version": "1.4.1" + }, + "qtpy-1.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "ae1202a69adb13ebb24311fe884f8562", + "name": "qtpy", + "sha256": "5d2e62771c863b68bb6a31bda87aef2567ec67c86179b48a37c41c6becaf9604", + "size": 45330, + "subdir": "linux-64", + "timestamp": 1525206926280, + "version": "1.4.1" + }, + "qtpy-1.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "32d34ca2ac1eea718736ab8c45c67318", + "name": "qtpy", + "sha256": "7d0ca4f28a7067703a400a31e3fc1bf14f3b2da7dc842a771a1b75de0e9a1c17", + "size": 44068, + "subdir": "linux-64", + "timestamp": 1525206926633, + "version": "1.4.1" + }, + "qtpy-1.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "0e760f6f297058f3be7a22aa5b136904", + "name": "qtpy", + "sha256": "0681765bdd2048d61239a3ba3bcae33d94c3a1f062af004291f2d2675ddfd0ac", + "size": 44189, + "subdir": "linux-64", + "timestamp": 1527829361076, + "version": "1.4.2" + }, + "qtpy-1.4.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "a7cdcdde509ab7b2ca84736c0d2edafa", + "name": "qtpy", + "sha256": "336e5a84811edb0833eb50ccaba510b1099b3e13f30c497948574ce04b4a0f70", + "size": 44163, + "subdir": "linux-64", + "timestamp": 1530873620151, + "version": "1.4.2" + }, + "qtpy-1.4.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "59fd132c88f06ed35c93c7c94e5e0fbb", + "name": "qtpy", + "sha256": "23b55165a25ee35abcb3b89a0d294c6c573fb2aebc3e852fd18df2f6b487ece1", + "size": 44872, + "subdir": "linux-64", + "timestamp": 1527829404053, + "version": "1.4.2" + }, + "qtpy-1.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a7dd1ec2d64e597cdb117751e677241f", + "name": "qtpy", + "sha256": "42d03746227881e2b08017fb4aff3b6582c8df9c5aba5181ede74ef718185a12", + "size": 43539, + "subdir": "linux-64", + "timestamp": 1527829337632, + "version": "1.4.2" + }, + "qtpy-1.4.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "184ae467f32207822b537a9432cd8f94", + "name": "qtpy", + "sha256": "a1f045033e7899ca602d00302b433082915f39bdaef2a50604cfdef72160d706", + "size": 43506, + "subdir": "linux-64", + "timestamp": 1530873664852, + "version": "1.4.2" + }, + "qtpy-1.4.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ab5535964658cb45fbe5754f69e99d23", + "name": "qtpy", + "sha256": "00c91c048b82f883cb0549a98630267bc3798a897449300e79df473a7a19911b", + "size": 44408, + "subdir": "linux-64", + "timestamp": 1530873642226, + "version": "1.4.2" + }, + "qtpy-1.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "0f8c98f41f5c6fc3875eeed855234528", + "name": "qtpy", + "sha256": "38031118b50847efd69caff9791c40721776407f9d918778cbcc936e5eb28db0", + "size": 50997, + "subdir": "linux-64", + "timestamp": 1535390836118, + "version": "1.5.0" + }, + "qtpy-1.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "abb959f765dbd039db941956b75700bb", + "name": "qtpy", + "sha256": "8bf429722f732b0958354aa663f875852af37638d8301158cfa5b9accca2d130", + "size": 51489, + "subdir": "linux-64", + "timestamp": 1535390856279, + "version": "1.5.0" + }, + "qtpy-1.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "224184537dad7c2e2ad702e018be7564", + "name": "qtpy", + "sha256": "3178467006287528cc98b57d524cd578371dbec9fbcdb6bdfe8648172f8c1c7e", + "size": 51670, + "subdir": "linux-64", + "timestamp": 1535390822106, + "version": "1.5.0" + }, + "qtpy-1.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e49f9c98dbec726cf4850fe9e394dffe", + "name": "qtpy", + "sha256": "6e33be68b44d3b5fb3efd6da96e9a539b6dd06d597bb62fda3513b6b6a0e255c", + "size": 50949, + "subdir": "linux-64", + "timestamp": 1535390863061, + "version": "1.5.0" + }, + "qtpy-1.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "3384dc0679fbc40d93acb2d59038d9c4", + "name": "qtpy", + "sha256": "56ef6e034b4aa4379c84ee2c31e38b0c304314a78b83d4f3f3ad68accd3823b8", + "size": 53026, + "subdir": "linux-64", + "timestamp": 1538157583409, + "version": "1.5.1" + }, + "qtpy-1.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "362301ee3bef18f9fe0c44b8f6734310", + "name": "qtpy", + "sha256": "f85e2bc2628bfaf9eaf438edd51257acf92e9bb2c9aa635d1276547b824d1f51", + "size": 53842, + "subdir": "linux-64", + "timestamp": 1538157570747, + "version": "1.5.1" + }, + "qtpy-1.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "00a15e5e171e951024672362653e8c1c", + "name": "qtpy", + "sha256": "a4e3bcb4f20aed3b0548c0557a87cfbe5c730652032f62c3e1db43cd94de6682", + "size": 52907, + "subdir": "linux-64", + "timestamp": 1538157536478, + "version": "1.5.1" + }, + "qtpy-1.5.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "564c868ac510e3b5e3b40203dad84652", + "name": "qtpy", + "sha256": "cf39b7a5e79d41a15d853c299671dd2a7f71ca010c834a47b1a55a464ebd5b41", + "size": 54087, + "subdir": "linux-64", + "timestamp": 1540232847240, + "version": "1.5.2" + }, + "qtpy-1.5.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "350aa71f0cd418e05863c9f5f3425498", + "name": "qtpy", + "sha256": "091d29dff66a52e078007453dcd79cc833fe53691e06ff015d94bf533b356c49", + "size": 53772, + "subdir": "linux-64", + "timestamp": 1540232846123, + "version": "1.5.2" + }, + "qtpy-1.5.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1dfb8a28b96acbabaca219b6e1c1b1b3", + "name": "qtpy", + "sha256": "32345f751891a9ae44af4bf7ae922ccc2b076cb12f28c818b6f38e8390b5aeb6", + "size": 53752, + "subdir": "linux-64", + "timestamp": 1540232851641, + "version": "1.5.2" + }, + "qtpy-1.7.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "89d4e1112f7a72e0defa54a2d401b36e", + "name": "qtpy", + "sha256": "1a12c379f909858b7543b1509ca42c1152cb26b74e7e5446de7185a8a3a65da8", + "size": 59730, + "subdir": "linux-64", + "timestamp": 1553291168405, + "version": "1.7.0" + }, + "qtpy-1.7.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f6808ef39660effcb092c8148caabf39", + "name": "qtpy", + "sha256": "6db7ceaa8b778aedd041cfa03ce8fa7223d1c53c3ec30ad98eddcbfcc305cfca", + "size": 59591, + "subdir": "linux-64", + "timestamp": 1553291277029, + "version": "1.7.0" + }, + "qtpy-1.7.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "338a52706b864c273c05d1891e548401", + "name": "qtpy", + "sha256": "0d894014dfcb661b8c5b90c95713c7d2d2adc45cd520b18034225f0673d49d49", + "size": 59704, + "subdir": "linux-64", + "timestamp": 1553291142692, + "version": "1.7.0" + }, + "qtpy-2.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08e26118976dcb18a1b46c99a72ce8d4", + "name": "qtpy", + "sha256": "d8c361ba304df3af2f4054fdbed5b864f7978d4d108d666bfe141e5318b339bc", + "size": 86409, + "subdir": "linux-64", + "timestamp": 1662015017414, + "version": "2.2.0" + }, + "qtpy-2.2.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "656ad386a1e30b6cc11918b0d76bdc88", + "name": "qtpy", + "sha256": "473e3261563d27b1ed758709860dfbdb0f9c0f336ec1e38f05da397cf13b7614", + "size": 103579, + "subdir": "linux-64", + "timestamp": 1676827480570, + "version": "2.2.0" + }, + "qtpy-2.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22358439315e3cd41555ba5106d43c9b", + "name": "qtpy", + "sha256": "8ec2bf70236a9fbe08d532df02cb9e1d1d211211f8cb56221cea7fd6d6f50456", + "size": 85943, + "subdir": "linux-64", + "timestamp": 1662014967125, + "version": "2.2.0" + }, + "qtpy-2.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "29c79e2df1d4c5be93550035ad55a25d", + "name": "qtpy", + "sha256": "a56abac54f801633c0382298e1819ab129dd74d79c0c77c2b2c35cb9532e3954", + "size": 86159, + "subdir": "linux-64", + "timestamp": 1662014927600, + "version": "2.2.0" + }, + "qtpy-2.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b031f9d3f0fcece455014d38397601a7", + "name": "qtpy", + "sha256": "6af7fda645d6972655274e2ae2cbab6f83815081dd9da8b5b4da833451d47917", + "size": 85839, + "subdir": "linux-64", + "timestamp": 1662015052924, + "version": "2.2.0" + }, + "qtwebkit-5.212-h4eab89a_4.conda": { + "build": "h4eab89a_4", + "build_number": 4, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "glib >=2.69.1,<3.0a0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libwebp >=1.2.0,<1.3.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "libxslt >=1.1.35,<2.0a0", + "qt-main >=5.15.2,<5.16.0a0", + "qt-webengine >=5.15.9,<5.16.0a0", + "sqlite >=3.38.5,<4.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "LGPL-2.1-only", + "md5": "7317bbf3f3e66a0a02b07b860783ecff", + "name": "qtwebkit", + "sha256": "6a14e6710e9ffe26ce7019ce9713fc12ac14ae051b522a17606595fb5316761c", + "size": 14978320, + "subdir": "linux-64", + "timestamp": 1659010531169, + "version": "5.212" + }, + "quandl-3.2.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "ndg-httpsclient", + "numpy >=1.8", + "pandas >=0.14", + "pyasn1", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "d239ecdd2e892c73c24e5914378d984b", + "name": "quandl", + "sha256": "a8b192d8f463ae365fcd0bdd57b0df2d85c25e1ae88b19c5fb3cb1b147f5c23b", + "size": 41901, + "subdir": "linux-64", + "timestamp": 1530958977342, + "version": "3.2.0" + }, + "quandl-3.2.0-py27hd2b0aea_0.conda": { + "build": "py27hd2b0aea_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "ndg-httpsclient", + "numpy >=1.8", + "pandas >=0.14", + "pyasn1", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests >=2.7.0,<2.18", + "six" + ], + "license": "MIT", + "md5": "ecde4ad71df920c66e57bbc647d28f41", + "name": "quandl", + "sha256": "7f1e837da4249ac776b1566a94c17dd24fed1b0ed24fda304a13e02c6c1096c6", + "size": 42298, + "subdir": "linux-64", + "timestamp": 1509567384116, + "version": "3.2.0" + }, + "quandl-3.2.0-py35h61fbbd2_0.conda": { + "build": "py35h61fbbd2_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "requests >=2.7.0,<2.18", + "six" + ], + "license": "MIT", + "md5": "cacb0faff4162c5af91a7a3f8fd2a1ec", + "name": "quandl", + "sha256": "d1bbccb89e6816403a217c43a960a86686fae7a6bd9cfce7563ea37d3a322a9d", + "size": 43391, + "subdir": "linux-64", + "timestamp": 1509567386622, + "version": "3.2.0" + }, + "quandl-3.2.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "e3417fda9a62cef3df7e5684c05d63b4", + "name": "quandl", + "sha256": "c759a5b3dbc841de98a81053376ec4b7a7aea3e84879a089f791db458bd161d6", + "size": 42686, + "subdir": "linux-64", + "timestamp": 1530923341713, + "version": "3.2.0" + }, + "quandl-3.2.0-py36h3624063_0.conda": { + "build": "py36h3624063_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0,<2.18", + "six" + ], + "license": "MIT", + "md5": "e7330fdbeb299bb01f1fb6867c7b5b4b", + "name": "quandl", + "sha256": "699fb689bd3fe144794a4c400fd12791a8308cdc245335a315fce79bdd255372", + "size": 42960, + "subdir": "linux-64", + "timestamp": 1509567355946, + "version": "3.2.0" + }, + "quandl-3.2.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "3cae18dcb396f3c20634781aa1145afd", + "name": "quandl", + "sha256": "6f83695a0e50fc624e5e7a424fc3794722d0bda5ad4fbb3edf3e0e0794109089", + "size": 42753, + "subdir": "linux-64", + "timestamp": 1530923619403, + "version": "3.2.0" + }, + "quandl-3.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "ndg-httpsclient", + "numpy >=1.8", + "pandas >=0.14", + "pyasn1", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "04a48bdfeb5a2cb421f967e6a24edb05", + "name": "quandl", + "sha256": "2ff5704bf1dd6becce7ea0e49f2435c2cec2c843f6e1ed6d61c420a448aa003b", + "size": 42025, + "subdir": "linux-64", + "timestamp": 1519241886248, + "version": "3.3.0" + }, + "quandl-3.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "275f2c90e845e5318d7db5462623d7df", + "name": "quandl", + "sha256": "c684a5948c8531d18c8132cf108dfc47fd78ff26a0e671dc28649f779107b633", + "size": 43234, + "subdir": "linux-64", + "timestamp": 1519241916684, + "version": "3.3.0" + }, + "quandl-3.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "1e73758f2c5613c7f87dc4efc42f7b37", + "name": "quandl", + "sha256": "a290da51fac10735f0fe5630796231dd0de62a3ee8b06386d9f70fd8a2daac04", + "size": 42804, + "subdir": "linux-64", + "timestamp": 1519241774918, + "version": "3.3.0" + }, + "quandl-3.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "ndg-httpsclient", + "numpy >=1.8", + "pandas >=0.14", + "pyasn1", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "2b2e7574241694622a59bb3cbffe0361", + "name": "quandl", + "sha256": "a2db29de576f397733a2d38a74f171a67760e74c5ef5521993f1749cb7626013", + "size": 42597, + "subdir": "linux-64", + "timestamp": 1534610166107, + "version": "3.4.0" + }, + "quandl-3.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "c1870673fc219eaa7d201e57403669c7", + "name": "quandl", + "sha256": "0c0513c22d09bd47e307b626a2951bcdaf6aea0cdef9e7b4a5072fe017f03ba8", + "size": 43588, + "subdir": "linux-64", + "timestamp": 1534610232289, + "version": "3.4.0" + }, + "quandl-3.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "4ce8131a5cb864b88a2d74e124aff409", + "name": "quandl", + "sha256": "42797874c69427907eb06763c48ea68a3b41867ad46a978af69a7cacceeb4bb3", + "size": 43270, + "subdir": "linux-64", + "timestamp": 1534610105634, + "version": "3.4.0" + }, + "quandl-3.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "1ea0a82fce3d91f3c16bb72212f6ebdd", + "name": "quandl", + "sha256": "d0713f1bd6d93b3d92b56b6183ffdd7a12d9e0878afe01425e32d0484ba7b00c", + "size": 43397, + "subdir": "linux-64", + "timestamp": 1534610235851, + "version": "3.4.0" + }, + "quandl-3.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "ndg-httpsclient", + "numpy >=1.8", + "pandas >=0.14", + "pyasn1", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "e17e8ac443fe03d1cb580ea141b81bcb", + "name": "quandl", + "sha256": "aeadc660bf367673ce31c9cc8b817492b6b9ad7dbaf59f614919b1f481a65ffb", + "size": 42706, + "subdir": "linux-64", + "timestamp": 1535723484031, + "version": "3.4.2" + }, + "quandl-3.4.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "0aaed7a083808c0040c3e4c2e4618f13", + "name": "quandl", + "sha256": "67d2323593f28221a828332eb31b60236f7b109fbe39a11b3adf94f5d9f631fd", + "size": 43760, + "subdir": "linux-64", + "timestamp": 1536250854444, + "version": "3.4.2" + }, + "quandl-3.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "8e2a2da86a0e89d8f8238a33cb7a2acd", + "name": "quandl", + "sha256": "c8bc672f651324af466deb96650612fc37f2254378a55b84ce0ad09471793404", + "size": 43491, + "subdir": "linux-64", + "timestamp": 1535723487661, + "version": "3.4.2" + }, + "quandl-3.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "f984f5690547f4b96a5c916105f7da06", + "name": "quandl", + "sha256": "52308ba9428f56578f22757a242fc97f0e436c3ac5b0a780c1d24b52758bea84", + "size": 43611, + "subdir": "linux-64", + "timestamp": 1535723532555, + "version": "3.4.2" + }, + "quandl-3.4.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "ndg-httpsclient", + "numpy >=1.8", + "pandas >=0.14", + "pyasn1", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "61c9b134ca6d8c3a43471263c3f9b807", + "name": "quandl", + "sha256": "0ac975c2b85ee66d01a6552274b070b28771cee5971100a2ab7bd4da36d9c74e", + "size": 46332, + "subdir": "linux-64", + "timestamp": 1541043492214, + "version": "3.4.4" + }, + "quandl-3.4.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "bc407aabc45aeacdf264fcea2678bb8c", + "name": "quandl", + "sha256": "4a0776f3f71d00e90b61b05e366d091f5275e4b2be2443e0c0890aa428d4e1c3", + "size": 47114, + "subdir": "linux-64", + "timestamp": 1541043529913, + "version": "3.4.4" + }, + "quandl-3.4.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "ac71f3ea1cd0bb84dddb278ee39b56a4", + "name": "quandl", + "sha256": "150744818be0f2df089af4acfbbc246f0568e1942cba77a7445e47bbaea288f7", + "size": 47148, + "subdir": "linux-64", + "timestamp": 1541043474931, + "version": "3.4.4" + }, + "quandl-3.4.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "ndg-httpsclient", + "numpy >=1.8", + "pandas >=0.14", + "pyasn1", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "d407b5fbd9684202002715d808997bdf", + "name": "quandl", + "sha256": "12bf910015a3f9079ddddaa0f9388153cb53e7053223b500946f11a934ef5580", + "size": 48169, + "subdir": "linux-64", + "timestamp": 1545156882517, + "version": "3.4.5" + }, + "quandl-3.4.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "9c3ea49cddd75bc5fe71862ac3eb726c", + "name": "quandl", + "sha256": "f0bb03a03b7a17d0e35364619a4719057f1717b4b497dd19e83712f87bce4052", + "size": 49110, + "subdir": "linux-64", + "timestamp": 1545156811689, + "version": "3.4.5" + }, + "quandl-3.4.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "md5": "ff29d849e623d57b566e522e8c8ebc96", + "name": "quandl", + "sha256": "c15c6042e27b59b8a01713991435ab6217d64015d20a850bed15c0cffdbade9a", + "size": 49231, + "subdir": "linux-64", + "timestamp": 1545156901487, + "version": "3.4.5" + }, + "quandl-3.4.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "ndg-httpsclient", + "numpy >=1.8", + "pandas >=0.14", + "pyasn1", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c47a4df20a4d1226901aeba5be7ab79c", + "name": "quandl", + "sha256": "90312c97d9739c7ddb0c7a63d49130fe3b83d5527a12331c3828c433cc2dfd3c", + "size": 51760, + "subdir": "linux-64", + "timestamp": 1569432138781, + "version": "3.4.8" + }, + "quandl-3.4.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "884c563285ef7fc73168111336c79024", + "name": "quandl", + "sha256": "bf3e91a390e2b5fe2fb9c6614e12a926bcf08844ce7e59feca3bf6be131bd110", + "size": 52506, + "subdir": "linux-64", + "timestamp": 1569432143856, + "version": "3.4.8" + }, + "quandl-3.4.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "57c4e579f507de90594bfa23e6695d2d", + "name": "quandl", + "sha256": "06808c96ac190a9f16a752a7f6c385cb427796a684863965e69726d4512cceab", + "size": 52605, + "subdir": "linux-64", + "timestamp": 1569432147582, + "version": "3.4.8" + }, + "quandl-3.4.8-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e826406c9c658659cb8497dde0f986f", + "name": "quandl", + "sha256": "a51a534346f12312bba7c9b3a36f965b1ad85b3f01a3721e1a4fe9b9838761c7", + "size": 53271, + "subdir": "linux-64", + "timestamp": 1588562785698, + "version": "3.4.8" + }, + "quandl-3.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d86a9153fb90571e8dafe8fe080702f", + "name": "quandl", + "sha256": "3d48cf9ca954b4cd811fd4689976b4ee9cda97e976a036b20c877100b8e34e17", + "size": 52993, + "subdir": "linux-64", + "timestamp": 1588565508184, + "version": "3.5.0" + }, + "quandl-3.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d6ff48423596999a8b6219b30be44ff8", + "name": "quandl", + "sha256": "5b211393f882e5bc6bfad1d36a16ead0bd56bb23a86830657fe88e1a28bfd136", + "size": 52877, + "subdir": "linux-64", + "timestamp": 1588565498703, + "version": "3.5.0" + }, + "quandl-3.5.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb476a71d4e70707b0a2f36cd2a6e554", + "name": "quandl", + "sha256": "62a556e1162536a192bf9d5175f893c774037aa3e44a7f3acf78c75cc9bcc936", + "size": 53290, + "subdir": "linux-64", + "timestamp": 1588565659844, + "version": "3.5.0" + }, + "quandl-3.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1260e5f3462256c0451cc81eb67b295a", + "name": "quandl", + "sha256": "688dba04b736cc2ecb5c7a94aa8d0e93ce0a58b49f46fd204f7fcac4db281cf5", + "size": 53596, + "subdir": "linux-64", + "timestamp": 1599889876040, + "version": "3.5.1" + }, + "quandl-3.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa7041e8770c7714eb94a09871738753", + "name": "quandl", + "sha256": "bb8847aceacfbbfedbc77e63fbbf7ac9a0c2a5c8c1352acf191144c20642137a", + "size": 53617, + "subdir": "linux-64", + "timestamp": 1599889890023, + "version": "3.5.1" + }, + "quandl-3.5.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2649b5179fa825938f094b6745009d4", + "name": "quandl", + "sha256": "c0c2100f70075b5bf18e2590a929f0f2374d29fd6b2f471229c01ba2e3ff19c5", + "size": 53788, + "subdir": "linux-64", + "timestamp": 1599889871982, + "version": "3.5.1" + }, + "quandl-3.5.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b87c72e28473f1b01f126de7b630a95", + "name": "quandl", + "sha256": "efbaa4dece56818064c75bd104cd85b5e0d26eca361bf42d352257c5b217fb2e", + "size": 53484, + "subdir": "linux-64", + "timestamp": 1599890413766, + "version": "3.5.2" + }, + "quandl-3.5.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "307f64d7657558d667f5bc09a52043b5", + "name": "quandl", + "sha256": "3b1f710491231ec516268f5ad73d7941d8f231becd33fd4618eb8c8f8688bdd6", + "size": 53836, + "subdir": "linux-64", + "timestamp": 1599890450009, + "version": "3.5.2" + }, + "quandl-3.5.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9afd49d2a53252437afa3bb305ebb44", + "name": "quandl", + "sha256": "8458534abb47d13ef657442456a4fc098529e3fa0479bc03c7393aac6eae8410", + "size": 53539, + "subdir": "linux-64", + "timestamp": 1599890453664, + "version": "3.5.2" + }, + "quandl-3.5.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f87fd3acc38a14c5757eb0d621782a5", + "name": "quandl", + "sha256": "8fddc11f61cb9796b3f0f917cadfa17176eeb2b69a83458e0c1deeaa91bfd9b5", + "size": 51442, + "subdir": "linux-64", + "timestamp": 1602786570829, + "version": "3.5.3" + }, + "quandl-3.5.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc94080fd313cfd61b20e753528931ec", + "name": "quandl", + "sha256": "ba9816ab462a3c1902621f36f20d783e8cd4004383091172c519eca7f96267a5", + "size": 51629, + "subdir": "linux-64", + "timestamp": 1602786609496, + "version": "3.5.3" + }, + "quandl-3.5.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bf6417f9a0ed8a5eb5ed065d0f6ea522", + "name": "quandl", + "sha256": "54b8b6df0edae8aaac427ce5710ba69fd844a6b84226d03ee6651b4556d897ed", + "size": 51821, + "subdir": "linux-64", + "timestamp": 1602786610589, + "version": "3.5.3" + }, + "quandl-3.6.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d89ae05222e9679acfc36e5bb839a725", + "name": "quandl", + "sha256": "620d889d31219bcc26a1a9076a2bacc4f2f6b39a9fbb0670a85342dd0a678764", + "size": 53836, + "subdir": "linux-64", + "timestamp": 1610404538068, + "version": "3.6.0" + }, + "quandl-3.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "58f7e94e11041c0028a8f713857b495b", + "name": "quandl", + "sha256": "544b09eeba6a547f34de86bd538294de9050b9c241e0af02e14e4fcb14ba8af8", + "size": 53606, + "subdir": "linux-64", + "timestamp": 1610404103367, + "version": "3.6.0" + }, + "quandl-3.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e2137db85dd5498409fa084ebdb734ed", + "name": "quandl", + "sha256": "f9c81de1bbe8c3964a233826bba2bf55f54439fe9da62e86adf544f972a297d3", + "size": 54005, + "subdir": "linux-64", + "timestamp": 1610404538397, + "version": "3.6.0" + }, + "quandl-3.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b417cf4ee2f931098bec4a8a11882379", + "name": "quandl", + "sha256": "4a0322f5a66b8628161f64b2e9d524c5f6ce13eb50b255612fa6350fd996aa54", + "size": 56331, + "subdir": "linux-64", + "timestamp": 1614075794994, + "version": "3.6.0" + }, + "quandl-3.6.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ed7d7ee495fadc1a3477841b1ecce2f5", + "name": "quandl", + "sha256": "843897f8a317c780cc38c06152f897f50018d9dcaf615bc04978719eeba36698", + "size": 54266, + "subdir": "linux-64", + "timestamp": 1640810735979, + "version": "3.6.1" + }, + "quandl-3.6.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.11,<3.12.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5c97345bf7820778b0f0167407bf0f1", + "name": "quandl", + "sha256": "bc8c0ec7af1169f9adc7291be164e3cfc13b03a97fc2292427eda8a2332653b1", + "size": 66593, + "subdir": "linux-64", + "timestamp": 1676861692071, + "version": "3.6.1" + }, + "quandl-3.6.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef83e1e7625610485eae658ed17eb1a7", + "name": "quandl", + "sha256": "3925d855271fe440d394d416033d3ed6ead5bf050084ee031363d4b5850cce59", + "size": 54000, + "subdir": "linux-64", + "timestamp": 1614799186397, + "version": "3.6.1" + }, + "quandl-3.6.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "737a759e2c0df6a49432b29e41dd8f3d", + "name": "quandl", + "sha256": "e666bbaeaac111e2c4a8f732d3d12a9684049f2e99ed2df6a6818adc95fe8468", + "size": 54023, + "subdir": "linux-64", + "timestamp": 1614799176000, + "version": "3.6.1" + }, + "quandl-3.6.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f41717302af367ecaf9f680921a8d29c", + "name": "quandl", + "sha256": "4ce1c0c1ae9ac5d8cde19662c6231aa2e0bb4da3d5bdc948a7c2bf88114d131e", + "size": 54261, + "subdir": "linux-64", + "timestamp": 1614797897220, + "version": "3.6.1" + }, + "quandl-3.6.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "inflection >=0.3.1", + "more-itertools", + "numpy >=1.8", + "pandas >=0.14", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests >=2.7.0", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01e7d2af61f47e34895fafd6dc8d550d", + "name": "quandl", + "sha256": "bb3cd73568d3afef137d1201a17209449193ae6b6fbe4d491debc4a27671df3c", + "size": 53889, + "subdir": "linux-64", + "timestamp": 1614799172026, + "version": "3.6.1" + }, + "quantecon-0.4.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "matplotlib", + "nose", + "numba", + "numpy", + "pandas", + "pytables", + "python >=3.6,<3.7.0a0", + "requests", + "scipy", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "ee7a951d320a6bbfaa1726f565400b9b", + "name": "quantecon", + "sha256": "768bad695467677fea959de3d8d6edc94492a876758c858b425c8af1968eebce", + "size": 219388, + "subdir": "linux-64", + "timestamp": 1582040386892, + "version": "0.4.5" + }, + "quantecon-0.4.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "matplotlib", + "nose", + "numba", + "numpy", + "pandas", + "pytables", + "python >=3.7,<3.8.0a0", + "requests", + "scipy", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "7327d6119aa68a16b3ab8b168534f569", + "name": "quantecon", + "sha256": "e541ae4fe911d22549d1e26fa7e62c9b84521b7abc2d5348dfbd40de12f00d37", + "size": 219399, + "subdir": "linux-64", + "timestamp": 1582040394160, + "version": "0.4.5" + }, + "quantecon-0.4.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "matplotlib", + "nose", + "numba", + "numpy", + "pandas", + "pytables", + "python >=3.8,<3.9.0a0", + "requests", + "scipy", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "43a303d8dc707897f65af928f483c269", + "name": "quantecon", + "sha256": "a1662e6e22ff892150c3bd8746a4acf2b3473b67c9e9b2f112debb9ede067ca8", + "size": 219864, + "subdir": "linux-64", + "timestamp": 1582040392701, + "version": "0.4.5" + }, + "quantecon-0.4.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba", + "numpy", + "pandas", + "pytables", + "python >=3.6,<3.7.0a0", + "requests", + "scipy", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "a3c20f1f4b40588f115cf3cf970ee813", + "name": "quantecon", + "sha256": "47d2bd29eb6f7aad35cc5654727c79909b0830425f2f7821fc760335475e95bd", + "size": 296443, + "subdir": "linux-64", + "timestamp": 1591257704407, + "version": "0.4.7" + }, + "quantecon-0.4.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba", + "numpy", + "pandas", + "pytables", + "python >=3.7,<3.8.0a0", + "requests", + "scipy", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "50a2f7fba5817f5d3117643383f8e04d", + "name": "quantecon", + "sha256": "88b0222154d043e5f8c6f45309a05996efd7fdd60c702fd62f641b6514c14bc9", + "size": 297589, + "subdir": "linux-64", + "timestamp": 1591257725285, + "version": "0.4.7" + }, + "quantecon-0.4.7-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba", + "numpy", + "pandas", + "pytables", + "python >=3.8,<3.9.0a0", + "requests", + "scipy", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "9a7e642fcebaa433517307f7656e94b7", + "name": "quantecon", + "sha256": "2f254e4063ee0a7ff658d2260622c4182cbb03f92946d281cd7fb09e0cc27c1d", + "size": 298166, + "subdir": "linux-64", + "timestamp": 1591257730381, + "version": "0.4.7" + }, + "quantecon-0.4.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba", + "numpy", + "pandas", + "pytables", + "python >=3.6,<3.7.0a0", + "requests", + "scipy", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "8b3c493040e0faef5b591c0ea003c8c6", + "name": "quantecon", + "sha256": "0d8e38944849750d7ce28823fb375b95f684e3deb2d065f422750a3f47d84c45", + "size": 296348, + "subdir": "linux-64", + "timestamp": 1602265596406, + "version": "0.4.8" + }, + "quantecon-0.4.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba", + "numpy", + "pandas", + "pytables", + "python >=3.7,<3.8.0a0", + "requests", + "scipy", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "8b462b8cc6f1076d2c99d436f4ab83a5", + "name": "quantecon", + "sha256": "22256b4cef30cac49da0df8e1ee4951c7600bc928880487f0218bb53165c0cb8", + "size": 292802, + "subdir": "linux-64", + "timestamp": 1594400148672, + "version": "0.4.8" + }, + "quantecon-0.4.8-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba", + "numpy", + "pandas", + "pytables", + "python >=3.8,<3.9.0a0", + "requests", + "scipy", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "72cef7daf8e85ee7023af35f8c9aeb34", + "name": "quantecon", + "sha256": "57d894d62441701f7e2ef6f19ad833015b05e6df1645fa091688e74999fc6b75", + "size": 291345, + "subdir": "linux-64", + "timestamp": 1602265621255, + "version": "0.4.8" + }, + "quantecon-0.5.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba >=0.38", + "numpy", + "pandas", + "pytables", + "python >=3.10,<3.11.0a0", + "requests", + "scipy >=1.0.0", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "a04987bbd3f8139049a97a1c46bd8cda", + "name": "quantecon", + "sha256": "62333cf3209bfa226aca13f52062bc566689b9711da3b673a79ffec21498a5ee", + "size": 291053, + "subdir": "linux-64", + "timestamp": 1641903910656, + "version": "0.5.0" + }, + "quantecon-0.5.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba >=0.38", + "numpy", + "pandas", + "pytables", + "python >=3.6,<3.7.0a0", + "requests", + "scipy >=1.0.0", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "6680ad0058d5ca72ada201ffe9cab1a6", + "name": "quantecon", + "sha256": "152da45bc0820d0a8b43d118e182d5ec040c2a9f10490d45b285e1aee99d5a97", + "size": 290619, + "subdir": "linux-64", + "timestamp": 1619455578632, + "version": "0.5.0" + }, + "quantecon-0.5.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba >=0.38", + "numpy", + "pandas", + "pytables", + "python >=3.7,<3.8.0a0", + "requests", + "scipy >=1.0.0", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "354b9f4385f005982e8c3ad4cd33e7c0", + "name": "quantecon", + "sha256": "e1d8f154331d2ba015b39dd44d2f0f4e83c1d1f02edf50e073a3a2c2064bdb73", + "size": 290452, + "subdir": "linux-64", + "timestamp": 1619455012407, + "version": "0.5.0" + }, + "quantecon-0.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba >=0.38", + "numpy", + "pandas", + "pytables", + "python >=3.8,<3.9.0a0", + "requests", + "scipy >=1.0.0", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "5187f1f78cd11a24577c2a950137457e", + "name": "quantecon", + "sha256": "c5d1c12ed74c0a6c236fb4ce2f0ba0994825eddff772f2c65d1f765ea53ad165", + "size": 295279, + "subdir": "linux-64", + "timestamp": 1619455585822, + "version": "0.5.0" + }, + "quantecon-0.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "nose", + "numba >=0.38", + "numpy", + "pandas", + "pytables", + "python >=3.9,<3.10.0a0", + "requests", + "scipy >=1.0.0", + "sympy" + ], + "license": "BSD-3-Clause", + "md5": "3d1a6bc2a899f6a3b5e357e2e5f0b9b5", + "name": "quantecon", + "sha256": "8f6f7c224f609f316f60c31427989de20241ebb74dfb875f863b0578ef9161fd", + "size": 292061, + "subdir": "linux-64", + "timestamp": 1619455580034, + "version": "0.5.0" + }, + "queuelib-1.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "66fc403b70d996a0ed47e9515f154f5c", + "name": "queuelib", + "sha256": "94d4c44b6c8295eefe8e97cd82f4a240819d420b35334b9a134eea54b0fd572a", + "size": 21382, + "subdir": "linux-64", + "timestamp": 1524148029122, + "version": "1.5.0" + }, + "queuelib-1.5.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "7f95254782e68182f70615e8400ef30a", + "name": "queuelib", + "sha256": "96c4135f142f198913e11b02dc40a3b7defde21e477d6ee458ca963a5c68ce13", + "size": 22248, + "subdir": "linux-64", + "timestamp": 1640794181600, + "version": "1.5.0" + }, + "queuelib-1.5.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "376c4a057110a3833152841e8108b213", + "name": "queuelib", + "sha256": "a7c3643707c77fbc8abce9d71b949664488a125c1ede90e2ff0d2a534dbea178", + "size": 28183, + "subdir": "linux-64", + "timestamp": 1676906174798, + "version": "1.5.0" + }, + "queuelib-1.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "b36d98ec74e5f98c2efa0f7cbbe3745a", + "name": "queuelib", + "sha256": "cc257868724269e293b1db6fd006d13f95f165eb6c09aafddd2a787b69fb1f8f", + "size": 21986, + "subdir": "linux-64", + "timestamp": 1524146811674, + "version": "1.5.0" + }, + "queuelib-1.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "227a7004e0d735fdada09650b2d5f044", + "name": "queuelib", + "sha256": "c777f0988f28b49f18a27ec72950a0f4c0d49ae1efa08de24691735db8ed740e", + "size": 21809, + "subdir": "linux-64", + "timestamp": 1524146805133, + "version": "1.5.0" + }, + "queuelib-1.5.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "5062cf152c7d492eb5887b3bcefb3cd5", + "name": "queuelib", + "sha256": "8cfce2e60b00d35d929865430c66d9b8c7914143c3d3d4d5301666237e93da3a", + "size": 263987, + "subdir": "linux-64", + "timestamp": 1614090983296, + "version": "1.5.0" + }, + "queuelib-1.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "24bd348abeabe26ee6b2f6779703cd3f", + "name": "queuelib", + "sha256": "c2877eb71ffbb7b3c255f3b024deefb8f01123e2fd86977181d1e6e82d2ca3b3", + "size": 21739, + "subdir": "linux-64", + "timestamp": 1530959136518, + "version": "1.5.0" + }, + "queuelib-1.5.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "ed17d4a428784659f47938bb1b71d56f", + "name": "queuelib", + "sha256": "6138bb7e15d97daeb00a1d8a8f7aca5f4e668b4c8f8d317004b9ec7d8c35c572", + "size": 264402, + "subdir": "linux-64", + "timestamp": 1614090965383, + "version": "1.5.0" + }, + "queuelib-1.5.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "5dd566863f9d36c9e4fba5f66b8ccc32", + "name": "queuelib", + "sha256": "4db1d261d3c04d04bb7e5f6d347db386b4ffeaf3029354ce21bc872683339531", + "size": 22348, + "subdir": "linux-64", + "timestamp": 1573200535002, + "version": "1.5.0" + }, + "queuelib-1.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "4ab379f6d0ee5f07429bccc842318992", + "name": "queuelib", + "sha256": "55e18e866c84ed065eefa60fa8dc85e91d20e01d6a281da4853e142682bfd914", + "size": 264259, + "subdir": "linux-64", + "timestamp": 1614090980318, + "version": "1.5.0" + }, + "queuelib-1.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "ac114829ed25dbd02fb98d44c356ed9b", + "name": "queuelib", + "sha256": "effd73513fa233f23441070e80e94d6808167ed021151f8dac2b3f1332c198ee", + "size": 264267, + "subdir": "linux-64", + "timestamp": 1614090975464, + "version": "1.5.0" + }, + "quilt3-3.1.10-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.0", + "aws-requests-auth >=0.4.2", + "boto3 >=1.8.0", + "dnspython >=1.16.0", + "flask", + "flask_cors", + "flask_json", + "jsonlines 1.2.0.*", + "packaging >=16.8", + "pandas >=0.19.2", + "pyarrow >=0.14.1", + "python >=3.10,<3.11.0a0", + "python-dateutil <=2.8.0", + "requests >=2.12.4", + "requests-futures 1.0.0", + "ruamel.yaml >=0.15.78", + "tqdm >=4.26.0", + "urllib3 1.24.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dd410d4c459304d2beea4b75b9a5b2a1", + "name": "quilt3", + "sha256": "c58e277c9ba5367a44332507c8645a802e3e06a1582c734c1fb070f89a003fb3", + "size": 148418, + "subdir": "linux-64", + "timestamp": 1643103425229, + "version": "3.1.10" + }, + "quilt3-3.1.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.0", + "aws-requests-auth >=0.4.2", + "boto3 >=1.8.0", + "dnspython >=1.16.0", + "flask", + "flask-cors", + "flask-json", + "jsonlines 1.2.0.*", + "packaging >=16.8", + "pandas >=0.19.2", + "pyarrow >=0.14.1", + "python >=3.6,<3.7.0a0", + "python-dateutil <=2.8.0", + "requests >=2.12.4", + "requests-futures 1.0.0", + "ruamel.yaml >=0.15.78", + "tqdm >=4.26.0", + "urllib3 1.24.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7326dd36d2f058cb4a5c3f4851c8e56a", + "name": "quilt3", + "sha256": "e87d95cb935cba9bdbe2e3130363da17761b8dc59a6014023b1f6fb1bfefe413", + "size": 145695, + "subdir": "linux-64", + "timestamp": 1582211094571, + "version": "3.1.10" + }, + "quilt3-3.1.10-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.0", + "aws-requests-auth >=0.4.2", + "boto3 >=1.8.0", + "dnspython >=1.16.0", + "flask", + "flask-cors", + "flask-json", + "jsonlines 1.2.0.*", + "packaging >=16.8", + "pandas >=0.19.2", + "pyarrow >=0.14.1", + "python >=3.7,<3.8.0a0", + "python-dateutil <=2.8.0", + "requests >=2.12.4", + "requests-futures 1.0.0", + "ruamel.yaml >=0.15.78", + "tqdm >=4.26.0", + "urllib3 1.24.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0a775ad0a92f614cb0217059a2a9e461", + "name": "quilt3", + "sha256": "32eb7950a809a175d791017d20897e9ff6d52c6592fa5cde4506c6fa2ca61c5b", + "size": 145779, + "subdir": "linux-64", + "timestamp": 1582211034591, + "version": "3.1.10" + }, + "quiver_engine-0.1.4.1.4-py27h8e5b075_0.conda": { + "build": "py27h8e5b075_0", + "build_number": 0, + "depends": [ + "flask", + "flask-cors", + "gevent", + "keras", + "numpy", + "pillow", + "python >=2.7,<2.8.0a0", + "tensorflow" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bbc07975a9ead5c878e50eab2a013ed5", + "name": "quiver_engine", + "sha256": "ce15762b3f80f8a184fad7dc28c69d6d82baf2e080e03575a039c09518cee366", + "size": 357329, + "subdir": "linux-64", + "timestamp": 1509400196829, + "version": "0.1.4.1.4" + }, + "quiver_engine-0.1.4.1.4-py35hf46ac68_0.conda": { + "build": "py35hf46ac68_0", + "build_number": 0, + "depends": [ + "flask", + "flask-cors", + "gevent", + "keras", + "numpy", + "pillow", + "python >=3.5,<3.6.0a0", + "tensorflow" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34807ab4e1d9a960fc0fadccacf625e4", + "name": "quiver_engine", + "sha256": "ecc85deb33e217fbcdc91fe612759ca4867d1043ceca255d824e7cad0131f029", + "size": 357630, + "subdir": "linux-64", + "timestamp": 1509400194047, + "version": "0.1.4.1.4" + }, + "quiver_engine-0.1.4.1.4-py36h1714ad7_0.conda": { + "build": "py36h1714ad7_0", + "build_number": 0, + "depends": [ + "flask", + "flask-cors", + "gevent", + "keras", + "numpy", + "pillow", + "python >=3.6,<3.7.0a0", + "tensorflow" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1437a4d057b8ec256bb67cf018b23c2", + "name": "quiver_engine", + "sha256": "15ef250995110368e6b8c0c713bd5fc2834700d4bee394410b834c4449fb5086", + "size": 357552, + "subdir": "linux-64", + "timestamp": 1509400201488, + "version": "0.1.4.1.4" + }, + "r-sf-1.0_7-r42h6a678d5_2.conda": { + "build": "r42h6a678d5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "libgdal >=3.6.0,<3.7.0a0", + "libstdcxx-ng >=11.2.0", + "r-base >=4.2,<4.3.0a0", + "r-classint >=0.4_1", + "r-dbi >=0.8", + "r-magrittr", + "r-rcpp >=0.12.18", + "r-s2 >=1.0.7", + "r-units >=0.7_0" + ], + "license": "GPL-2 | MIT", + "license_family": "GPL2", + "md5": "9db959607f59ce3fd2ab5cfce0f75039", + "name": "r-sf", + "sha256": "74bee26dc0d64f146a312b300eda1a1a5c034034e5686abf831551d79f8b6def", + "size": 3196146, + "subdir": "linux-64", + "timestamp": 1677598002275, + "version": "1.0_7" + }, + "r-xgboost-0.90-r35h295c915_1.conda": { + "build": "r35h295c915_1", + "build_number": 1, + "depends": [ + "_r-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libxgboost 0.90 h295c915_1", + "r-base >=3.5,<3.6.0a0", + "r-data.table", + "r-magrittr", + "r-matrix", + "r-stringi" + ], + "md5": "dd8cdcba9efedd697addbb98a6d56ca5", + "name": "r-xgboost", + "sha256": "9e962e59083f51d57ac85ac13ca2439f4f14018bee1c6e709b09690c7fce2a03", + "size": 1003215, + "subdir": "linux-64", + "timestamp": 1642675558667, + "version": "0.90" + }, + "r-xgboost-0.90-r35he6710b0_0.conda": { + "build": "r35he6710b0_0", + "build_number": 0, + "depends": [ + "_r-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libxgboost 0.90 he6710b0_0", + "r-base >=3.5,<3.6.0a0", + "r-data.table", + "r-magrittr", + "r-matrix", + "r-stringi" + ], + "md5": "8833be1bce345f8dddb1681bdf4b34b6", + "name": "r-xgboost", + "sha256": "bfe8f2f7060cfe58acda04de8a910ba498cc31707fb01fd1efe2e60b2d586c78", + "size": 1006544, + "subdir": "linux-64", + "timestamp": 1592297744294, + "version": "0.90" + }, + "r-xgboost-1.5.0-r35h2c33d7e_2.conda": { + "build": "r35h2c33d7e_2", + "build_number": 2, + "depends": [ + "_openmp_mutex", + "_r-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxgboost 1.5.0 h6a678d5_2", + "r-base >=3.5,<3.6.0a0", + "r-data.table", + "r-jsonlite", + "r-magrittr", + "r-matrix" + ], + "license": "Apache-2.0", + "md5": "13dbff1ccd403d6fe592ce18ee9b5dba", + "name": "r-xgboost", + "sha256": "8bd3efa9be18d23ea25b3baf018079c525646d8b4a092dd8c9e88235ad276184", + "size": 1436592, + "subdir": "linux-64", + "timestamp": 1659549472616, + "version": "1.5.0" + }, + "r-xgboost-1.5.0-r35hd872225_1.conda": { + "build": "r35hd872225_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "_r-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libxgboost 1.5.0 h295c915_1", + "r-base >=3.5,<3.6.0a0", + "r-data.table", + "r-jsonlite", + "r-magrittr", + "r-matrix" + ], + "license": "Apache-2.0", + "md5": "6972305ed8c09aa35118e5b0e38a3657", + "name": "r-xgboost", + "sha256": "005da2201abb410e6e8bb5676e5a2c4dadc1672c1daedb93be186cb6c2a49f98", + "size": 1438907, + "subdir": "linux-64", + "timestamp": 1642516719683, + "version": "1.5.0" + }, + "r-xgboost-1.5.1-r35h2a55022_0.conda": { + "build": "r35h2a55022_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "_r-xgboost-mutex 2.0 cpu_0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libxgboost 1.5.1 h6a678d5_0", + "r-base >=3.5,<3.6.0a0", + "r-data.table", + "r-jsonlite", + "r-magrittr", + "r-matrix" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "658c5d45ed629a04b5d44bd2d830cdd7", + "name": "r-xgboost", + "sha256": "15861655dda56d9e86acb58d69c9e91eb6229f278d96c53bed718e22119686e7", + "size": 1528487, + "subdir": "linux-64", + "timestamp": 1675120125000, + "version": "1.5.1" + }, + "r-xgboost-1.7.3-r35h2c33d7e_0.conda": { + "build": "r35h2c33d7e_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "_r-xgboost-mutex 2.0 cpu_0", + "libxgboost 1.7.3 h6a678d5_0", + "r-base >=3.5,<3.6.0a0", + "r-data.table", + "r-jsonlite", + "r-magrittr", + "r-matrix" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a77f3c596ebf7c9768296d28ac4d8273", + "name": "r-xgboost", + "sha256": "ec15380b7ec174cd284893b993c2af4bbc57f0da62a7274352cbf6720198a058", + "size": 1929508, + "subdir": "linux-64", + "timestamp": 1675458299455, + "version": "1.7.3" + }, + "r-xgboost-cpu-0.90-r35_0.conda": { + "build": "r35_0", + "build_number": 0, + "depends": [ + "r-base >=3.5,<3.6.0a0", + "r-xgboost 0.90 r35he6710b0_0" + ], + "md5": "6d97e4a6286779eaaa117d818a7edcd4", + "name": "r-xgboost-cpu", + "sha256": "699e3ba3be7dbd84ffd3208f7e8a335e5582b7e71748041ff52f82037f9df823", + "size": 11862, + "subdir": "linux-64", + "timestamp": 1592297757691, + "version": "0.90" + }, + "r-xgboost-cpu-0.90-r35h06a4308_1.conda": { + "build": "r35h06a4308_1", + "build_number": 1, + "depends": [ + "r-base >=3.5,<3.6.0a0", + "r-xgboost 0.90 r35h295c915_1" + ], + "md5": "534bced9c4b24386482b91b84b6fd908", + "name": "r-xgboost-cpu", + "sha256": "a01a3090ddf0822a76893e17a7667cc71f7fe49e8d1c3c8e30ff8104b1be6943", + "size": 12437, + "subdir": "linux-64", + "timestamp": 1642675577480, + "version": "0.90" + }, + "r-xgboost-cpu-1.5.0-r35h06a4308_1.conda": { + "build": "r35h06a4308_1", + "build_number": 1, + "depends": [ + "r-base >=3.5,<3.6.0a0", + "r-xgboost 1.5.0 r35hd872225_1" + ], + "license": "Apache-2.0", + "md5": "eabbf63d9f03d4f41e978322ced11599", + "name": "r-xgboost-cpu", + "sha256": "bfa43b0d88ca1c6c980a5d7d9fba0b0011ca33dfa537905388f99ee5226f1e67", + "size": 14835, + "subdir": "linux-64", + "timestamp": 1642516732707, + "version": "1.5.0" + }, + "r-xgboost-cpu-1.5.0-r35h06a4308_2.conda": { + "build": "r35h06a4308_2", + "build_number": 2, + "depends": [ + "r-base >=3.5,<3.6.0a0", + "r-xgboost 1.5.0 r35h2c33d7e_2" + ], + "license": "Apache-2.0", + "md5": "510a96692131196a34c55cd8dcab8986", + "name": "r-xgboost-cpu", + "sha256": "a2d3378fe47de7dc020421e036ffe86da3b79e1173b81277e7c01795d5204f8e", + "size": 15475, + "subdir": "linux-64", + "timestamp": 1659549549730, + "version": "1.5.0" + }, + "r-xgboost-cpu-1.5.1-r35h06a4308_0.conda": { + "build": "r35h06a4308_0", + "build_number": 0, + "depends": [ + "r-base >=3.5,<3.6.0a0", + "r-xgboost 1.5.1 r35h2a55022_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1cf96af078d17f8002246350f3b5e415", + "name": "r-xgboost-cpu", + "sha256": "0a3f68d4765c379aa61d5974267ba6d9acf480ad3fc6d7e89403a069715b1d69", + "size": 14873, + "subdir": "linux-64", + "timestamp": 1675120198168, + "version": "1.5.1" + }, + "r-xgboost-cpu-1.7.3-r35h06a4308_0.conda": { + "build": "r35h06a4308_0", + "build_number": 0, + "depends": [ + "r-base >=3.5,<3.6.0a0", + "r-xgboost 1.7.3 r35h2c33d7e_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "516813634bcd945f9312016ed8d918d0", + "name": "r-xgboost-cpu", + "sha256": "5b4fcf84dda337dc45a74883d6133747f1d82cbaec93a128093027d08909362a", + "size": 12672, + "subdir": "linux-64", + "timestamp": 1675458328210, + "version": "1.7.3" + }, + "rapidfuzz-1.9.1-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "981d6c51c15b8a465f324885068e3e05", + "name": "rapidfuzz", + "sha256": "f61fbd447e543c478d47cdf39f0173989ba8db266d5657d564f9a184a4dc4076", + "size": 616180, + "subdir": "linux-64", + "timestamp": 1676968639207, + "version": "1.9.1" + }, + "rapidfuzz-1.9.1-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "518acc2af980d43c0feaed78c44217f0", + "name": "rapidfuzz", + "sha256": "b2b5a1034a6cf974a13135129027f3b9e048325eb1507d589f0f49ed6718e8c2", + "size": 608489, + "subdir": "linux-64", + "timestamp": 1676968548904, + "version": "1.9.1" + }, + "rapidfuzz-1.9.1-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df87a458da8c5b1069277dd0ad4dcd3a", + "name": "rapidfuzz", + "sha256": "9c308f28cbc38650bf4d1da8469df01af0a5b8fb06c0564f5ae7efbd507fa771", + "size": 618407, + "subdir": "linux-64", + "timestamp": 1676968729381, + "version": "1.9.1" + }, + "rapidfuzz-1.9.1-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "790271b9355444df5da5de92c79f39a3", + "name": "rapidfuzz", + "sha256": "6cfda0e5ec3ab23e7bba11593877002875f974f837937541bdd99e110772d930", + "size": 619057, + "subdir": "linux-64", + "timestamp": 1676968457760, + "version": "1.9.1" + }, + "rapidfuzz-2.13.7-py310h1128e8f_0.conda": { + "build": "py310h1128e8f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "946f29cf670f76c7d552346292beb546", + "name": "rapidfuzz", + "sha256": "f0d173824f93968b6b6bd45d232ec89c98932550379e5be1df323da78c1c075c", + "size": 1624326, + "subdir": "linux-64", + "timestamp": 1679594238371, + "version": "2.13.7" + }, + "rapidfuzz-2.13.7-py311ha02d727_0.conda": { + "build": "py311ha02d727_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "209432afe26a55b1eeffe8e392186f23", + "name": "rapidfuzz", + "sha256": "407d072e0e2a06e724a8fa333a3e83785ece8b3d9df96445aecc3863835c8688", + "size": 1605398, + "subdir": "linux-64", + "timestamp": 1679594487718, + "version": "2.13.7" + }, + "rapidfuzz-2.13.7-py38h417a72b_0.conda": { + "build": "py38h417a72b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "27a1825b28a5f15a0a00ad7c6cf4f5c6", + "name": "rapidfuzz", + "sha256": "62b0415b06af330f4382ed1be067469164669e90cabac1f666ddb93b22b2a5bb", + "size": 1622909, + "subdir": "linux-64", + "timestamp": 1679593986069, + "version": "2.13.7" + }, + "rapidfuzz-2.13.7-py39h417a72b_0.conda": { + "build": "py39h417a72b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d60a532874562be604e703eab8d5dba6", + "name": "rapidfuzz", + "sha256": "d63fb49d767e888eb269d4c83384aa4eb807fcdabbda38d621744d36230b85d0", + "size": 1619930, + "subdir": "linux-64", + "timestamp": 1679593732079, + "version": "2.13.7" + }, + "rapidjson-1.1.0-h6bb024c_0.conda": { + "build": "h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c7cb0a50f3dc93754f7d545a604bc680", + "name": "rapidjson", + "sha256": "9e44dd5dc7a2443a13c4cf261c582440da4caaf184e4d631f90ca6883475d972", + "size": 109897, + "subdir": "linux-64", + "timestamp": 1519467232429, + "version": "1.1.0" + }, + "rasterio-0.36.0-py27h3f37509_2.conda": { + "build": "py27h3f37509_2", + "build_number": 2, + "depends": [ + "affine >=1.3.0", + "attrs", + "boto3 >=1.2.4", + "click-plugins", + "cligj", + "enum34", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "6abf62860aaabe5fa7c889710e6bfe54", + "name": "rasterio", + "sha256": "79031a937b0afd8970cef702a35ff6ba1b840d81c832bf61d9f9bd2a7a64bc49", + "size": 868941, + "subdir": "linux-64", + "timestamp": 1530872454421, + "version": "0.36.0" + }, + "rasterio-0.36.0-py27h453aca2_1.conda": { + "build": "py27h453aca2_1", + "build_number": 1, + "depends": [ + "affine >=1.3.0", + "attrs", + "boto3 >=1.2.4", + "click-plugins", + "cligj", + "enum34", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "e5fd2145f4f4d72c41d05240084045af", + "name": "rasterio", + "sha256": "e40e08224ef84a73aeab25e8f11eb1c87e4168f6119f81d37a53396db27e016e", + "size": 799612, + "subdir": "linux-64", + "timestamp": 1511884045780, + "version": "0.36.0" + }, + "rasterio-0.36.0-py35h94a1d1c_1.conda": { + "build": "py35h94a1d1c_1", + "build_number": 1, + "depends": [ + "affine >=1.3.0", + "attrs", + "boto3 >=1.2.4", + "click-plugins", + "cligj", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "05f1749baee88e2bf0b7ddd48c78fac2", + "name": "rasterio", + "sha256": "fe9ae39de8426899f442e05e28057553654d355efe1d530dcdef4422a5fff49d", + "size": 783809, + "subdir": "linux-64", + "timestamp": 1511884589439, + "version": "0.36.0" + }, + "rasterio-0.36.0-py36h3f37509_2.conda": { + "build": "py36h3f37509_2", + "build_number": 2, + "depends": [ + "affine >=1.3.0", + "attrs", + "boto3 >=1.2.4", + "click-plugins", + "cligj", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "a17ebaeb949043a6b0bcd94702aaf19a", + "name": "rasterio", + "sha256": "b22d595c55310abd5f4cdda7050c4477673f3f46fa86a475d6d77bab92c39dd4", + "size": 862430, + "subdir": "linux-64", + "timestamp": 1530872753714, + "version": "0.36.0" + }, + "rasterio-0.36.0-py36hd410cfe_1.conda": { + "build": "py36hd410cfe_1", + "build_number": 1, + "depends": [ + "affine >=1.3.0", + "attrs", + "boto3 >=1.2.4", + "click-plugins", + "cligj", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.2,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "b2825a775486d276bda669b6897a1fec", + "name": "rasterio", + "sha256": "e97039d2f9ae09e1abc01dba720b891b64cbf815d28ec241b72818c7b84cce84", + "size": 781368, + "subdir": "linux-64", + "timestamp": 1511884589598, + "version": "0.36.0" + }, + "rasterio-0.36.0-py37h3f37509_2.conda": { + "build": "py37h3f37509_2", + "build_number": 2, + "depends": [ + "affine >=1.3.0", + "attrs", + "boto3 >=1.2.4", + "click-plugins", + "cligj", + "libgcc-ng >=7.2.0", + "libgdal >=2.2.4,<2.3.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "6e008ab80f33b844b211fca0e3c08c30", + "name": "rasterio", + "sha256": "8afb02478a1faa5670b966c2a2209b09a037d88bdde4606eb6bd55cfa255dbe0", + "size": 860966, + "subdir": "linux-64", + "timestamp": 1530872606329, + "version": "0.36.0" + }, + "rasterio-1.0.13-py27hc38cc03_0.conda": { + "build": "py27hc38cc03_0", + "build_number": 0, + "depends": [ + "affine >=1.3.0", + "attrs >=16.0.0", + "boto3 >=1.2.4", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "enum34", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "383309aada644605c0ae5458eb009a50", + "name": "rasterio", + "sha256": "0b59d875bda0a20b8921dc28add999c10690a400d82ce62ef0ab26052171523a", + "size": 6926714, + "subdir": "linux-64", + "timestamp": 1545417313952, + "version": "1.0.13" + }, + "rasterio-1.0.13-py36hc38cc03_0.conda": { + "build": "py36hc38cc03_0", + "build_number": 0, + "depends": [ + "affine >=1.3.0", + "attrs >=16.0.0", + "boto3 >=1.2.4", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "1b4a67aac112a158a7bde517d1a281f9", + "name": "rasterio", + "sha256": "8d208ac4f47b3a84ea38e56a6170274e9f13c631a1a7fb5433169450075455d6", + "size": 6961087, + "subdir": "linux-64", + "timestamp": 1545417239715, + "version": "1.0.13" + }, + "rasterio-1.0.13-py37hc38cc03_0.conda": { + "build": "py37hc38cc03_0", + "build_number": 0, + "depends": [ + "affine >=1.3.0", + "attrs >=16.0.0", + "boto3 >=1.2.4", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "3415d0a471e50abc0a5a315fab4e439a", + "name": "rasterio", + "sha256": "513da7a71d3eb5a254da6e5dfa9388585dda7e1ee41f49703514f965e8e40c73", + "size": 6960702, + "subdir": "linux-64", + "timestamp": 1545417269332, + "version": "1.0.13" + }, + "rasterio-1.0.18-py27hc38cc03_0.conda": { + "build": "py27hc38cc03_0", + "build_number": 0, + "depends": [ + "affine >=1.3.0", + "attrs >=16.0.0", + "boto3 >=1.2.4", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "enum34", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "1a2682f5ab896fd022438a30b79d7cfe", + "name": "rasterio", + "sha256": "45bb907b722d9ccd1ab8626d3bd69244063eb8766c7b056144a08366ff0016bf", + "size": 6939433, + "subdir": "linux-64", + "timestamp": 1550357369862, + "version": "1.0.18" + }, + "rasterio-1.0.18-py36hc38cc03_0.conda": { + "build": "py36hc38cc03_0", + "build_number": 0, + "depends": [ + "affine >=1.3.0", + "attrs >=16.0.0", + "boto3 >=1.2.4", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "ae0a8f59dac67643c7604d05d6adaed4", + "name": "rasterio", + "sha256": "ac4d55cfaab101296e55505586f49b0d5f7d6e8de0ceda1b8dadcc0fb2b9e94b", + "size": 6974912, + "subdir": "linux-64", + "timestamp": 1550357296583, + "version": "1.0.18" + }, + "rasterio-1.0.18-py37hc38cc03_0.conda": { + "build": "py37hc38cc03_0", + "build_number": 0, + "depends": [ + "affine >=1.3.0", + "attrs >=16.0.0", + "boto3 >=1.2.4", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "d0f73ee2b2fdd51f746acfa35501f92b", + "name": "rasterio", + "sha256": "b649666c2170a35b000d53298f6442c6c1a1b6b74fea15ada98101e7a39e49d4", + "size": 6972203, + "subdir": "linux-64", + "timestamp": 1550357366766, + "version": "1.0.18" + }, + "rasterio-1.0.21-py27hc38cc03_0.conda": { + "build": "py27hc38cc03_0", + "build_number": 0, + "depends": [ + "affine >=1.3.0", + "attrs >=16.0.0", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "enum34", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "4c79e21d7927ae8e1941e8ca36154e88", + "name": "rasterio", + "sha256": "ec1730233e15f268f7e442930ec182fa360bbdc13dac52ad96733eb0c1c5d0a8", + "size": 6949537, + "subdir": "linux-64", + "timestamp": 1552367489476, + "version": "1.0.21" + }, + "rasterio-1.0.21-py36hc38cc03_0.conda": { + "build": "py36hc38cc03_0", + "build_number": 0, + "depends": [ + "affine >=1.3.0", + "attrs >=16.0.0", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "e0b2c838e15ba4059738e1050c996ebf", + "name": "rasterio", + "sha256": "7eec45843c3a8e1e013af198e96dcb13234e281567d39bd991b13ac8bcdd9ea1", + "size": 6982278, + "subdir": "linux-64", + "timestamp": 1552367666419, + "version": "1.0.21" + }, + "rasterio-1.0.21-py37hc38cc03_0.conda": { + "build": "py37hc38cc03_0", + "build_number": 0, + "depends": [ + "affine >=1.3.0", + "attrs >=16.0.0", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.3.0", + "libgdal >=2.3.3,<2.4.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD 3-Clause", + "md5": "d7f3044d60e6795d6706c31bee14f7a1", + "name": "rasterio", + "sha256": "78cf38df12e83408c9495c03f57de73f058ca39304714a12486a49082c645832", + "size": 6980510, + "subdir": "linux-64", + "timestamp": 1552367624856, + "version": "1.0.21" + }, + "rasterio-1.1.0-py27h41e4f33_0.conda": { + "build": "py27h41e4f33_0", + "build_number": 0, + "depends": [ + "affine", + "attrs", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "enum34", + "libgcc-ng >=7.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD-3-Clause", + "md5": "e873b328a7d98f368455db7004dbbf20", + "name": "rasterio", + "sha256": "41e5a7a4414b0c3e426c527ade3e34760fd4d39abe1a43785cd9db5149efb792", + "size": 7011898, + "subdir": "linux-64", + "timestamp": 1573765134461, + "version": "1.1.0" + }, + "rasterio-1.1.0-py310ha4a3290_0.conda": { + "build": "py310ha4a3290_0", + "build_number": 0, + "depends": [ + "affine", + "attrs", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.5.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD-3-Clause", + "md5": "d49daa00f8b0d06520b2d2187c94cf97", + "name": "rasterio", + "sha256": "8b1a4b4b7dde81fb36454b4e3bced3404542cc5879d914c9475d4f24188bc543", + "size": 9619985, + "subdir": "linux-64", + "timestamp": 1640794292373, + "version": "1.1.0" + }, + "rasterio-1.1.0-py36h41e4f33_0.conda": { + "build": "py36h41e4f33_0", + "build_number": 0, + "depends": [ + "affine", + "attrs", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD-3-Clause", + "md5": "49aef691943d4ba8d5a6982ac9e48d52", + "name": "rasterio", + "sha256": "e661a074f58ee7c02fc26ac317260590d3380530231b23cb1ae99ef9397bbbf2", + "size": 7049563, + "subdir": "linux-64", + "timestamp": 1573764087721, + "version": "1.1.0" + }, + "rasterio-1.1.0-py37h41e4f33_0.conda": { + "build": "py37h41e4f33_0", + "build_number": 0, + "depends": [ + "affine", + "attrs", + "click >=4,<8", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.3.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools >=0.9.8", + "snuggs >=1.4.1" + ], + "license": "BSD-3-Clause", + "md5": "047fc87de21c6bed633a873bdf24cb48", + "name": "rasterio", + "sha256": "af0ea5b638f21d67fff4a8d5393667e5a6fb3dca251d76673be90225dfa16097", + "size": 7046224, + "subdir": "linux-64", + "timestamp": 1573765806388, + "version": "1.1.0" + }, + "rasterio-1.2.10-py310ha4a3290_0.conda": { + "build": "py310ha4a3290_0", + "build_number": 0, + "depends": [ + "affine", + "attrs", + "certifi", + "click >=4.0", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.5.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5db2947404f972417f429f917884f5ed", + "name": "rasterio", + "sha256": "2b8f4e81b049ac7744d97d78ded5b7b17b5fec91c2b913aec44b5e47c478ab88", + "size": 9971334, + "subdir": "linux-64", + "timestamp": 1650637382630, + "version": "1.2.10" + }, + "rasterio-1.2.10-py311h5ab40d8_0.conda": { + "build": "py311h5ab40d8_0", + "build_number": 0, + "depends": [ + "affine", + "attrs", + "certifi", + "click >=4.0", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=11.2.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9b9a22384cdb0844a44d46ef10f4a868", + "name": "rasterio", + "sha256": "4a6a40a5743db52f987484774c3e4ca2d5021a02cd9874ec4451251752906209", + "size": 7084993, + "subdir": "linux-64", + "timestamp": 1676861787335, + "version": "1.2.10" + }, + "rasterio-1.2.10-py37h9a6c7ee_0.conda": { + "build": "py37h9a6c7ee_0", + "build_number": 0, + "depends": [ + "affine", + "attrs", + "certifi", + "click >=4.0", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.5.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7464ac033aed7429b5ac2412d377eb72", + "name": "rasterio", + "sha256": "41c64d0a8326b25dd986a17124278eaffbbfe560526cd47bda5e6bc97fdef32f", + "size": 7000860, + "subdir": "linux-64", + "timestamp": 1650638208465, + "version": "1.2.10" + }, + "rasterio-1.2.10-py38h9a6c7ee_0.conda": { + "build": "py38h9a6c7ee_0", + "build_number": 0, + "depends": [ + "affine", + "attrs", + "certifi", + "click >=4.0", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.5.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "360985b77f87760685c4baf8b610710f", + "name": "rasterio", + "sha256": "8ea85eb25140649a37d37d66e849d80e19bf785437ac272331bc6b523153c7d5", + "size": 7068747, + "subdir": "linux-64", + "timestamp": 1650637656283, + "version": "1.2.10" + }, + "rasterio-1.2.10-py39h9a6c7ee_0.conda": { + "build": "py39h9a6c7ee_0", + "build_number": 0, + "depends": [ + "affine", + "attrs", + "certifi", + "click >=4.0", + "click-plugins", + "cligj >=0.5", + "libgcc-ng >=7.5.0", + "libgdal >=3.0.2,<3.1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "setuptools", + "snuggs >=1.4.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b88f038fdee86b98eedd6a58443172d1", + "name": "rasterio", + "sha256": "df3272542cd14e21a3d40495076dd4a7e75930a9c52fcd3d8031180c7af71b4f", + "size": 7070191, + "subdir": "linux-64", + "timestamp": 1650637932328, + "version": "1.2.10" + }, + "ray-core-1.4.0-py36h295c915_1.conda": { + "build": "py36h295c915_1", + "build_number": 1, + "depends": [ + "aiohttp", + "aiohttp-cors", + "aioredis", + "click >=7.0", + "colorama", + "colorful", + "dataclasses", + "filelock", + "gpustat", + "grpcio >=1.28.1", + "jsonschema", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "opencensus", + "pickle5", + "prometheus_client >=0.7.1", + "protobuf >=3.15.3", + "psutil", + "pydantic >=1.8", + "python >=3.6,<3.7.0a0", + "pyyaml", + "redis-py >=3.5.0", + "requests", + "setproctitle 1.1.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9735bf4f0b3ba381434ae06867493666", + "name": "ray-core", + "sha256": "d49df9a6678910310e67dbac41780ed588c5a27e7b99cdeb24a7fa90f35cb217", + "size": 14337515, + "subdir": "linux-64", + "timestamp": 1627060887488, + "version": "1.4.0" + }, + "ray-core-1.4.0-py37h295c915_1.conda": { + "build": "py37h295c915_1", + "build_number": 1, + "depends": [ + "aiohttp", + "aiohttp-cors", + "aioredis", + "click >=7.0", + "colorama", + "colorful", + "filelock", + "gpustat", + "grpcio >=1.28.1", + "jsonschema", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "opencensus", + "pickle5", + "prometheus_client >=0.7.1", + "protobuf >=3.15.3", + "psutil", + "pydantic >=1.8", + "python >=3.7,<3.8.0a0", + "pyyaml", + "redis-py >=3.5.0", + "requests", + "setproctitle 1.1.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2c3b83463058d779a1e3d8a81c6f64d9", + "name": "ray-core", + "sha256": "3333e56348cfa85f7606997bba3bf2fc8ce2a2c6401994796781c90b531bc03a", + "size": 14249515, + "subdir": "linux-64", + "timestamp": 1627060386456, + "version": "1.4.0" + }, + "ray-core-1.4.0-py38h295c915_1.conda": { + "build": "py38h295c915_1", + "build_number": 1, + "depends": [ + "aiohttp", + "aiohttp-cors", + "aioredis", + "click >=7.0", + "colorama", + "colorful", + "filelock", + "gpustat", + "grpcio >=1.28.1", + "jsonschema", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "opencensus", + "prometheus_client >=0.7.1", + "protobuf >=3.15.3", + "psutil", + "pydantic >=1.8", + "python >=3.8,<3.9.0a0", + "pyyaml", + "redis-py >=3.5.0", + "requests", + "setproctitle 1.1.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f50caeb2d811d1e2d40e39e7d6b2a4a2", + "name": "ray-core", + "sha256": "29fd8cce588590970115105b3a6c635a78081406ecb319cc95fc05673595db07", + "size": 14103692, + "subdir": "linux-64", + "timestamp": 1627059869595, + "version": "1.4.0" + }, + "ray-core-1.4.0-py39h295c915_1.conda": { + "build": "py39h295c915_1", + "build_number": 1, + "depends": [ + "aiohttp", + "aiohttp-cors", + "aioredis", + "click >=7.0", + "colorama", + "colorful", + "filelock", + "gpustat", + "grpcio >=1.28.1", + "jsonschema", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "opencensus", + "prometheus_client >=0.7.1", + "protobuf >=3.15.3", + "psutil", + "pydantic >=1.8", + "python >=3.9,<3.10.0a0", + "pyyaml", + "redis-py >=3.5.0", + "requests", + "setproctitle 1.1.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "958c921365ac713b424608e74ae90295", + "name": "ray-core", + "sha256": "06c1732a727dfc1679c32f0ce5ccd814e9c3fad4883f09b231b5b696bee6ff9c", + "size": 13679694, + "subdir": "linux-64", + "timestamp": 1627061396722, + "version": "1.4.0" + }, + "ray-core-1.6.0-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "attrs", + "click >=7.0", + "colorama", + "filelock", + "grpcio >=1.28.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "pickle5", + "protobuf >=3.15.3", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "redis-py >=3.5.0", + "setproctitle 1.1.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "317cd0999e64c453a7a9d3e485cf9e44", + "name": "ray-core", + "sha256": "f0fd61bb5aa4beafc0c20529afae2f1f44ac6933d66f48841b581ec0b40eae03", + "size": 17423011, + "subdir": "linux-64", + "timestamp": 1640797633844, + "version": "1.6.0" + }, + "ray-core-1.6.0-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "attrs", + "click >=7.0", + "colorama", + "filelock", + "grpcio >=1.28.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "protobuf >=3.15.3", + "psutil", + "python >=3.8,<3.9.0a0", + "pyyaml", + "redis-py >=3.5.0", + "setproctitle 1.1.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6d5f693689a9f59a95856f278a141133", + "name": "ray-core", + "sha256": "bcd0d7e9089f5f07ae7105ec96bb9d39214fde80b50ed5169b4fd2eea29767d1", + "size": 17266096, + "subdir": "linux-64", + "timestamp": 1640798729195, + "version": "1.6.0" + }, + "ray-core-1.6.0-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "attrs", + "click >=7.0", + "colorama", + "filelock", + "grpcio >=1.28.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "protobuf >=3.15.3", + "psutil", + "python >=3.9,<3.10.0a0", + "pyyaml", + "redis-py >=3.5.0", + "setproctitle 1.1.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d409761b5943b4e85a8fb30b15ce0089", + "name": "ray-core", + "sha256": "f3e3081ff9db6b6ffe7526ce192d3c6d31152cc90b400c0111d31c3b6a875381", + "size": 16826880, + "subdir": "linux-64", + "timestamp": 1640798192129, + "version": "1.6.0" + }, + "ray-core-1.9.2-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "attrs", + "click >=7.0", + "colorama", + "filelock", + "grpcio >=1.28.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "pickle5", + "protobuf >=3.15.3", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "redis-py >=3.5.0", + "setproctitle 1.2.2.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "13fbd6e795f285550eb046c4256d3e99", + "name": "ray-core", + "sha256": "5b6a364eff528f427db48767accc179d3f2db019d43c3b8da0c21b9b09733843", + "size": 22900902, + "subdir": "linux-64", + "timestamp": 1659006375240, + "version": "1.9.2" + }, + "ray-core-1.9.2-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "attrs", + "click >=7.0", + "colorama", + "filelock", + "grpcio >=1.28.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "protobuf >=3.15.3", + "psutil", + "python >=3.8,<3.9.0a0", + "pyyaml", + "redis-py >=3.5.0", + "setproctitle 1.2.2.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ea4b7b73f8a4b7fe3c6d350aff88f5a1", + "name": "ray-core", + "sha256": "71b7b1a571f867c29d5042e0891d6db55a535f68c593f306a1671aca3e940413", + "size": 22913874, + "subdir": "linux-64", + "timestamp": 1659005675747, + "version": "1.9.2" + }, + "ray-core-1.9.2-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "attrs", + "click >=7.0", + "colorama", + "filelock", + "grpcio >=1.28.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.19.3", + "protobuf >=3.15.3", + "psutil", + "python >=3.9,<3.10.0a0", + "pyyaml", + "redis-py >=3.5.0", + "setproctitle 1.2.2.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1e09bfafd9969cfd92af32d2bca1d5e4", + "name": "ray-core", + "sha256": "3c7d923db4334d76020b9167c86dee28b803f93079b259647d9dce8977b1693b", + "size": 22868917, + "subdir": "linux-64", + "timestamp": 1659004976267, + "version": "1.9.2" + }, + "ray-core-2.0.1-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "aiosignal", + "attrs", + "click >=7.0,<=8.0.4", + "colorama", + "filelock", + "frozenlist", + "grpcio >=1.28.1,<1.48", + "jsonschema", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.19.3", + "protobuf >=3.15.3,<4.0.0", + "psutil", + "python >=3.10,<3.11.0a0", + "pyyaml", + "requests", + "setproctitle 1.2.2.*", + "virtualenv" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4f70cb9b424c14e488b7dfd5565b0c8f", + "name": "ray-core", + "sha256": "10f79ebc648e636a5645b0367a4a34217c570c382066d0edbdb34e6fe0460a54", + "size": 23049121, + "subdir": "linux-64", + "timestamp": 1668105883974, + "version": "2.0.1" + }, + "ray-core-2.0.1-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "aiosignal", + "attrs", + "click >=7.0,<=8.0.4", + "colorama", + "filelock", + "frozenlist", + "grpcio >=1.28.1,<1.48", + "jsonschema", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "pickle5", + "protobuf >=3.15.3,<4.0.0", + "psutil", + "python >=3.7,<3.8.0a0", + "pyyaml", + "requests", + "setproctitle 1.2.2.*", + "typing_extensions", + "virtualenv" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b72eb209962182d1c9803331eb0146ff", + "name": "ray-core", + "sha256": "2f298d38fb8f4a06038ed48250ddca84d76eb4051887cfc6779d2eb4c85b4f0d", + "size": 22869038, + "subdir": "linux-64", + "timestamp": 1668106330940, + "version": "2.0.1" + }, + "ray-core-2.0.1-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "aiosignal", + "attrs", + "click >=7.0,<=8.0.4", + "colorama", + "filelock", + "frozenlist", + "grpcio >=1.28.1,<1.48", + "jsonschema", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "protobuf >=3.15.3,<4.0.0", + "psutil", + "python >=3.8,<3.9.0a0", + "pyyaml", + "requests", + "setproctitle 1.2.2.*", + "virtualenv" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cbbf70c314c4d3d88cb8700ffedf9e91", + "name": "ray-core", + "sha256": "13a46df9db569d42a854a7090ebf58542c7942894b76a7cbc05c145a6af4a7a3", + "size": 22890499, + "subdir": "linux-64", + "timestamp": 1668107219594, + "version": "2.0.1" + }, + "ray-core-2.0.1-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "aiosignal", + "attrs", + "click >=7.0,<=8.0.4", + "colorama", + "filelock", + "frozenlist", + "grpcio >=1.28.1,<1.48", + "jsonschema", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.19.3", + "protobuf >=3.15.3,<4.0.0", + "psutil", + "python >=3.9,<3.10.0a0", + "pyyaml", + "requests", + "setproctitle 1.2.2.*", + "virtualenv" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1600e543500bf96042d021be7145eced", + "name": "ray-core", + "sha256": "e9918a18312def458d524bd7ce1a8c64ae86a8f6a00dedbeec8b25d4b2f5754b", + "size": 22977031, + "subdir": "linux-64", + "timestamp": 1668106775708, + "version": "2.0.1" + }, + "ray-core-2.3.0-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "aiosignal", + "attrs", + "click >=7.0,<=8.0.4", + "colorama", + "filelock", + "frozenlist", + "grpcio >=1.42,<1.49", + "jsonschema", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.19.3", + "packaging", + "protobuf >=3.15.3,!=3.19.5,<4.0.0", + "psutil", + "python >=3.10,<3.11.0a0", + "pyyaml", + "requests", + "setproctitle 1.2.2.*", + "virtualenv >=20.0.24" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "10fa205be7a6f434c32a2b5edec970eb", + "name": "ray-core", + "sha256": "a71d44c28e2154c3773b37e82dbfbd8f47f5a272d4891bd137101b44276797e0", + "size": 34360776, + "subdir": "linux-64", + "timestamp": 1678437485443, + "version": "2.3.0" + }, + "ray-core-2.3.0-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "aiosignal", + "attrs", + "click >=7.0,<=8.0.4", + "colorama", + "filelock", + "frozenlist", + "grpcio >=1.42,<1.49", + "jsonschema", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.16", + "protobuf >=3.15.3,!=3.19.5,<4.0.0", + "psutil", + "python >=3.8,<3.9.0a0", + "pyyaml", + "requests", + "setproctitle 1.2.2.*", + "virtualenv >=20.0.24" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b593c263406de00d0d1015386f1e6656", + "name": "ray-core", + "sha256": "ab25c341e2ef31e298b581ee0ae250b1971d124b1cdf5f06d3d7c4a34f065327", + "size": 34325811, + "subdir": "linux-64", + "timestamp": 1678432273991, + "version": "2.3.0" + }, + "ray-core-2.3.0-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "aiosignal", + "attrs", + "click >=7.0,<=8.0.4", + "colorama", + "filelock", + "frozenlist", + "grpcio >=1.42,<1.49", + "jsonschema", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "msgpack-python >=1.0.0,<2.0.0", + "numpy >=1.19.3", + "protobuf >=3.15.3,!=3.19.5,<4.0.0", + "psutil", + "python >=3.9,<3.10.0a0", + "pyyaml", + "requests", + "setproctitle 1.2.2.*", + "virtualenv >=20.0.24" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f043949a7bc270bc1d341ca96d8ed8f0", + "name": "ray-core", + "sha256": "8b5a0fed581ef2a99dff2b34855781882f60a230f1397ad505ee0622783be387", + "size": 34292720, + "subdir": "linux-64", + "timestamp": 1678434914744, + "version": "2.3.0" + }, + "ray-dashboard-1.4.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "ray-core 1.4.0 py36h295c915_1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b0bb3d7708fb752102cb99458ee8b9ee", + "name": "ray-dashboard", + "sha256": "6e3c1d386a781ecc9f20a0e0c5e43e6121c3f0761ee192019647346f58c8e58c", + "size": 2001288, + "subdir": "linux-64", + "timestamp": 1627061721368, + "version": "1.4.0" + }, + "ray-dashboard-1.4.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "ray-core 1.4.0 py37h295c915_1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c5d7b0ee2c62ad8450f8e5c52c84f088", + "name": "ray-dashboard", + "sha256": "87007c2261aa5cf3d4b6aa00826b14be60b09e4395c562cfda72e60565080f2b", + "size": 2001325, + "subdir": "linux-64", + "timestamp": 1627061638043, + "version": "1.4.0" + }, + "ray-dashboard-1.4.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "ray-core 1.4.0 py38h295c915_1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c45cb224564dc302efd76c15a4b84377", + "name": "ray-dashboard", + "sha256": "1fdf2098b6fc4adbd8720e6840bdfa6d5530c04e7fc8364bc0aa9664fe50b013", + "size": 2001403, + "subdir": "linux-64", + "timestamp": 1627061554334, + "version": "1.4.0" + }, + "ray-dashboard-1.4.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "ray-core 1.4.0 py39h295c915_1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e656579e583a3e7c61fed73a98623007", + "name": "ray-dashboard", + "sha256": "dd01e33a632c682344b0db5c3e98269ab867a96a064b45e175885972a4cd08c8", + "size": 2001773, + "subdir": "linux-64", + "timestamp": 1627061802247, + "version": "1.4.0" + }, + "ray-dashboard-1.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "ray-default 1.6.0 py37h06a4308_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4b4f4fd5ee8660e08a231a5c5e221b93", + "name": "ray-dashboard", + "sha256": "be853e20d5095623eae143ba2caecf1111b45b1b0dcfa8acf2228fd95825be84", + "size": 2003915, + "subdir": "linux-64", + "timestamp": 1640798967413, + "version": "1.6.0" + }, + "ray-dashboard-1.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "ray-default 1.6.0 py38h06a4308_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8e2c614e2e29b35ede0d6ce792f77140", + "name": "ray-dashboard", + "sha256": "1bb33fe2cedaf20e12bc2f4515c6533ede7b33b4ec362bae1fde7302009f3dde", + "size": 2003624, + "subdir": "linux-64", + "timestamp": 1640799212028, + "version": "1.6.0" + }, + "ray-dashboard-1.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "ray-default 1.6.0 py39h06a4308_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "512ab899e775564b411186f44ad23ded", + "name": "ray-dashboard", + "sha256": "5a411b01616c4a7f3b576f67251538c095c77a9e109b9a0c8c9a3da41f8d565a", + "size": 2003845, + "subdir": "linux-64", + "timestamp": 1640799088297, + "version": "1.6.0" + }, + "ray-dashboard-2.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "ray-default 2.3.0 py310h06a4308_0", + "typing-extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "851828be86d50a77d6b687ebbffb5335", + "name": "ray-dashboard", + "sha256": "c2313e2a0b6fadc28604ee9d5ced8f1ce85567de0d71026ec8f94f8efb0d83a6", + "size": 2402671, + "subdir": "linux-64", + "timestamp": 1678437642408, + "version": "2.3.0" + }, + "ray-dashboard-2.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "ray-default 2.3.0 py38h06a4308_0", + "typing-extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "998163b2c3b868c75523350cc77d7c8b", + "name": "ray-dashboard", + "sha256": "aad908ae11e64309420b3c6a88f344b7a3048807bdbf192370a0961904cc3dfb", + "size": 2402616, + "subdir": "linux-64", + "timestamp": 1678432433639, + "version": "2.3.0" + }, + "ray-dashboard-2.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "ray-default 2.3.0 py39h06a4308_0", + "typing-extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "121e1e91afd72c847df57579a561fd22", + "name": "ray-dashboard", + "sha256": "a963e1154a2068b4a088e840127fddca0a9f3e9a7dce7c7a7a48246a9dce8759", + "size": 2402610, + "subdir": "linux-64", + "timestamp": 1678435066946, + "version": "2.3.0" + }, + "ray-data-2.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec", + "numpy >=1.20", + "pandas >=1.3", + "pyarrow >=6.0.1", + "python >=3.10,<3.11.0a0", + "ray-core 2.3.0 py310h6a678d5_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7f58fda81314bbbd744d67c65b40a46e", + "name": "ray-data", + "sha256": "570a3b2a6187fc3880cd5e76e4593cb706b8d44968c130e359e3d3300b6f601a", + "size": 47394, + "subdir": "linux-64", + "timestamp": 1678437517430, + "version": "2.3.0" + }, + "ray-data-2.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec", + "numpy >=1.20", + "pandas >=1.3", + "pyarrow >=6.0.1", + "python >=3.8,<3.9.0a0", + "ray-core 2.3.0 py38h6a678d5_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a7bcc8293abd254b4505de366f63ad63", + "name": "ray-data", + "sha256": "5ea983d61943056307680f77bdda267034c5ce2eabfccad00c6cd4415649277f", + "size": 47351, + "subdir": "linux-64", + "timestamp": 1678432304346, + "version": "2.3.0" + }, + "ray-data-2.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "fsspec", + "numpy >=1.20", + "pandas >=1.3", + "pyarrow >=6.0.1", + "python >=3.9,<3.10.0a0", + "ray-core 2.3.0 py39h6a678d5_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "07e7bb89820ad049feb64693e3b4ae91", + "name": "ray-data", + "sha256": "32946d260e16a43c1d668fbb89aa0deb168ba99d15ef7b60157f111cc307d828", + "size": 47353, + "subdir": "linux-64", + "timestamp": 1678434946325, + "version": "2.3.0" + }, + "ray-debug-2.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "py-spy >=0.2.0", + "python >=3.10,<3.11.0a0", + "ray-core 2.3.0 py310h6a678d5_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "91989ccb2cb42a7575e64880ed77529c", + "name": "ray-debug", + "sha256": "009008044c617cb70c2aa5c81bca7a0900a5d56cd6b763eeddc0b512bf8d4cb4", + "size": 47285, + "subdir": "linux-64", + "timestamp": 1678437523572, + "version": "2.3.0" + }, + "ray-debug-2.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py-spy >=0.2.0", + "python >=3.8,<3.9.0a0", + "ray-core 2.3.0 py38h6a678d5_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0c3aedf0b60d66cec3eebb7d57357969", + "name": "ray-debug", + "sha256": "1943c8b3479f57a8d9b3ac5fff2dec35c1456b8a3ca202b98408c7aab82f315d", + "size": 47249, + "subdir": "linux-64", + "timestamp": 1678432310215, + "version": "2.3.0" + }, + "ray-debug-2.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py-spy >=0.2.0", + "python >=3.9,<3.10.0a0", + "ray-core 2.3.0 py39h6a678d5_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "221e754efb108b93a3c24cd9f72982f4", + "name": "ray-debug", + "sha256": "b9b99dd5a4cd78991a9bc880421e6279a925f99cae2576220e4184b993a0288a", + "size": 47253, + "subdir": "linux-64", + "timestamp": 1678434952315, + "version": "2.3.0" + }, + "ray-default-1.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp 3.7.*", + "aiohttp-cors", + "aioredis <2", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1", + "py-spy >=0.2.0", + "python >=3.7,<3.8.0a0", + "ray-core 1.6.0 py37h295c915_0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "425699ce4d13600ceef53494b31e081f", + "name": "ray-default", + "sha256": "adb03f2e946a9c67ca2be87fae6379f16ccc077debc5540399182701cd9a37a7", + "size": 52630, + "subdir": "linux-64", + "timestamp": 1640798760608, + "version": "1.6.0" + }, + "ray-default-1.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp 3.7.*", + "aiohttp-cors", + "aioredis <2", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1", + "py-spy >=0.2.0", + "python >=3.8,<3.9.0a0", + "ray-core 1.6.0 py38h295c915_0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a69eedc2eb449c2f2421f8efe08dc2e7", + "name": "ray-default", + "sha256": "129fad772d45b807c85b6dc6b6526eb33d1899b065e597a2d43f06c40097ecc2", + "size": 52625, + "subdir": "linux-64", + "timestamp": 1640798773585, + "version": "1.6.0" + }, + "ray-default-1.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp 3.7.*", + "aiohttp-cors", + "aioredis <2", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1", + "py-spy >=0.2.0", + "python >=3.9,<3.10.0a0", + "ray-core 1.6.0 py39h295c915_0", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "79283a735a3bcb470946b89a6a124969", + "name": "ray-default", + "sha256": "45d584082c74c2aa0333d418390ee666e2f485876d57b6b498b10bfce8697d77", + "size": 52606, + "subdir": "linux-64", + "timestamp": 1640798767354, + "version": "1.6.0" + }, + "ray-default-1.9.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "aioredis <2", + "aiosignal", + "colorful", + "frozenlist", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1", + "py-spy >=0.2.0", + "python >=3.7,<3.8.0a0", + "ray-core 1.9.2 py37h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8f453f5ca600f2ba50a2503bee1d605b", + "name": "ray-default", + "sha256": "a7a076f7e83e57bc860739247f8f489b631f52ea843cdbcab37cd59fa13f3a7c", + "size": 53622, + "subdir": "linux-64", + "timestamp": 1659006427086, + "version": "1.9.2" + }, + "ray-default-1.9.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "aioredis <2", + "aiosignal", + "colorful", + "frozenlist", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1", + "py-spy >=0.2.0", + "python >=3.8,<3.9.0a0", + "ray-core 1.9.2 py38h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "45eaebd39ce191d2ac466f548e2c5a47", + "name": "ray-default", + "sha256": "67c2c436a59e60629cf9123b01efb101de478618be7ea4e17cc0b9d62583ce0c", + "size": 53628, + "subdir": "linux-64", + "timestamp": 1659006419411, + "version": "1.9.2" + }, + "ray-default-1.9.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "aioredis <2", + "aiosignal", + "colorful", + "frozenlist", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1", + "py-spy >=0.2.0", + "python >=3.9,<3.10.0a0", + "ray-core 1.9.2 py39h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fcb2a1f51f9341cf39fd17d5f9b43297", + "name": "ray-default", + "sha256": "1c31b4290131d9d24db7f5e643c93d1f219fdfb6fea9d729a16a0d620a482fcf", + "size": 53637, + "subdir": "linux-64", + "timestamp": 1659006411976, + "version": "1.9.2" + }, + "ray-default-2.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1,<0.14.0", + "py-spy >=0.2.0", + "pydantic", + "python >=3.10,<3.11.0a0", + "ray-core 2.0.1 py310h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "05fa771c24c655c31f4951683889df70", + "name": "ray-default", + "sha256": "376360f934228d8a640b39e06129ed3846603873e7e117e4f54b61d904d5a071", + "size": 43984, + "subdir": "linux-64", + "timestamp": 1668107247485, + "version": "2.0.1" + }, + "ray-default-2.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1,<0.14.0", + "py-spy >=0.2.0", + "pydantic", + "python >=3.7,<3.8.0a0", + "ray-core 2.0.1 py37h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ff7e3bd78fd249575b6693164c12bcbc", + "name": "ray-default", + "sha256": "581c19c1de9d1188c2617cac1c08aa91f55c1abda2885353a2db5a9bf69d9633", + "size": 44035, + "subdir": "linux-64", + "timestamp": 1668107254135, + "version": "2.0.1" + }, + "ray-default-2.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1,<0.14.0", + "py-spy >=0.2.0", + "pydantic", + "python >=3.8,<3.9.0a0", + "ray-core 2.0.1 py38h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f6a60b7d73ad478272431f83ecb82a78", + "name": "ray-default", + "sha256": "89e4e4dbee0ae5ea354545c28a3f3bd99f84520fc2a70f6e4bf211e87beed382", + "size": 43932, + "subdir": "linux-64", + "timestamp": 1668107267901, + "version": "2.0.1" + }, + "ray-default-2.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1,<0.14.0", + "py-spy >=0.2.0", + "pydantic", + "python >=3.9,<3.10.0a0", + "ray-core 2.0.1 py39h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "68803bb4188f82781259711ed0eb453c", + "name": "ray-default", + "sha256": "a27c8d8d1b34f669e827610026429493378b804588bb9c58b196b2358565a4c9", + "size": 43936, + "subdir": "linux-64", + "timestamp": 1668107261176, + "version": "2.0.1" + }, + "ray-default-2.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1,<0.14.0", + "py-spy >=0.2.0", + "pydantic", + "python >=3.10,<3.11.0a0", + "ray-core 2.3.0 py310h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "90eef5a76eef9f5a6c9dbdaa4f8b97d5", + "name": "ray-default", + "sha256": "7c17eaab409ad860314fa2686ae094a6b4e0878fc9dbaf296c164f6bd1a6a94e", + "size": 47416, + "subdir": "linux-64", + "timestamp": 1678437529762, + "version": "2.3.0" + }, + "ray-default-2.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1,<0.14.0", + "py-spy >=0.2.0", + "pydantic", + "python >=3.8,<3.9.0a0", + "ray-core 2.3.0 py38h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0561c90c37a1ed1e282d7c226974b7f4", + "name": "ray-default", + "sha256": "51dfc9d904d90761a3dce693405147ea0f5ab710292be3362fc1fa759d7f963f", + "size": 47373, + "subdir": "linux-64", + "timestamp": 1678432316051, + "version": "2.3.0" + }, + "ray-default-2.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.7", + "aiohttp-cors", + "colorful", + "gpustat", + "jsonschema", + "opencensus", + "prometheus_client >=0.7.1,<0.14.0", + "py-spy >=0.2.0", + "pydantic", + "python >=3.9,<3.10.0a0", + "ray-core 2.3.0 py39h6a678d5_0", + "requests", + "smart_open" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "81521682454bc7721123cebef5f01bdd", + "name": "ray-default", + "sha256": "7554ce4e4b8e5e4236bd32a3ddb38c0320e1b77f4d172fc95ed4bf5713b056d9", + "size": 47372, + "subdir": "linux-64", + "timestamp": 1678434958308, + "version": "2.3.0" + }, + "ray-rllib-2.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "dm-tree", + "gymnasium 0.26.3", + "lz4", + "python >=3.10,<3.11.0a0", + "pyyaml", + "ray-tune 2.3.0 py310h06a4308_0", + "rich", + "scikit-image", + "scipy", + "typer" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "44867d3412fe24401b152b1ba9fc6fbf", + "name": "ray-rllib", + "sha256": "943c3761f7dfbea37fabb5ae2b80d76d2bccde59c1c9b23b359fe9a987cc631a", + "size": 47857, + "subdir": "linux-64", + "timestamp": 1678437656771, + "version": "2.3.0" + }, + "ray-rllib-2.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "dm-tree", + "gymnasium 0.26.3", + "lz4", + "python >=3.8,<3.9.0a0", + "pyyaml", + "ray-tune 2.3.0 py38h06a4308_0", + "rich", + "scikit-image", + "scipy", + "typer" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e92ed33e111d995f21b1f27efdeb501e", + "name": "ray-rllib", + "sha256": "613adedffcd7a4c9bb25aab34ab40f60c0929e8db595028a691f76b872846cdd", + "size": 47824, + "subdir": "linux-64", + "timestamp": 1678432447290, + "version": "2.3.0" + }, + "ray-rllib-2.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "dm-tree", + "gymnasium 0.26.3", + "lz4", + "python >=3.9,<3.10.0a0", + "pyyaml", + "ray-tune 2.3.0 py39h06a4308_0", + "rich", + "scikit-image", + "scipy", + "typer" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e20023f0f3fd40c2bdd2cf6dcee45c7c", + "name": "ray-rllib", + "sha256": "df5e2bd7227ac9d7ac368ba0c48213b1967945871cc133b5935c71ae7b9121db", + "size": 47840, + "subdir": "linux-64", + "timestamp": 1678435080968, + "version": "2.3.0" + }, + "ray-train-2.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "ray-tune 2.3.0 py310h06a4308_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "24f172479fe53e73bc19551a974963fd", + "name": "ray-train", + "sha256": "b8bfdf4c089010e59da982856a5890c593fcb34cf94bd36ad5e0dff692234729", + "size": 47283, + "subdir": "linux-64", + "timestamp": 1678437662863, + "version": "2.3.0" + }, + "ray-train-2.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "ray-tune 2.3.0 py38h06a4308_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5430f1280f700c006d3fff9259fa3223", + "name": "ray-train", + "sha256": "9c96ba405027c5e72f9357a8d6d8d7a53001fba0dde6c5d51b4584e3b8cc19c9", + "size": 47243, + "subdir": "linux-64", + "timestamp": 1678432453070, + "version": "2.3.0" + }, + "ray-train-2.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "ray-tune 2.3.0 py39h06a4308_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c04928eb7c0a3b5045dda24a0b1b484c", + "name": "ray-train", + "sha256": "c3fc1b967d5504ce1c8e8189de6f5a1deedaea2243c336d124d84406b55dc4a5", + "size": 47254, + "subdir": "linux-64", + "timestamp": 1678435087104, + "version": "2.3.0" + }, + "ray-tune-1.4.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "pandas", + "python >=3.6,<3.7.0a0", + "ray-core 1.4.0 py36h295c915_1", + "tabulate", + "tensorboardx" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "47408e9f4cf74732ab1becbef3dca920", + "name": "ray-tune", + "sha256": "2768257f06c6142d1fa8a428cce48a24a1d2d0abc9c333bb87ea2dc6b4c0cce2", + "size": 50721, + "subdir": "linux-64", + "timestamp": 1627061821230, + "version": "1.4.0" + }, + "ray-tune-1.4.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "pandas", + "python >=3.7,<3.8.0a0", + "ray-core 1.4.0 py37h295c915_1", + "tabulate", + "tensorboardx" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "42da97a816b9be0b7aa8f15c1170fac5", + "name": "ray-tune", + "sha256": "485729bbf8e8831d61a887d4a2c3d41ebbbb1ccde506720023af66eb06bffa37", + "size": 50728, + "subdir": "linux-64", + "timestamp": 1627061815627, + "version": "1.4.0" + }, + "ray-tune-1.4.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "pandas", + "python >=3.8,<3.9.0a0", + "ray-core 1.4.0 py38h295c915_1", + "tabulate", + "tensorboardx" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "98c15fdb1b38d8041c23206b42dbc757", + "name": "ray-tune", + "sha256": "2b6f17f194707d1f75600e2a5229ed5b4c3845f6377a01624e9f72183db78e66", + "size": 50731, + "subdir": "linux-64", + "timestamp": 1627061809809, + "version": "1.4.0" + }, + "ray-tune-1.4.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "pandas", + "python >=3.9,<3.10.0a0", + "ray-core 1.4.0 py39h295c915_1", + "tabulate", + "tensorboardx" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "546d2a4611dd540426ab85ba56b7a1b5", + "name": "ray-tune", + "sha256": "b5522482044b20783115bb621c21d9993bc860c813245a8b09ca004508787b85", + "size": 50751, + "subdir": "linux-64", + "timestamp": 1627061827351, + "version": "1.4.0" + }, + "ray-tune-1.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pandas", + "python >=3.7,<3.8.0a0", + "ray-core 1.6.0 py37h295c915_0", + "requests", + "tabulate", + "tensorboardx >=1.9" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "327e9b2587b183eb35cd4baee19b9fa5", + "name": "ray-tune", + "sha256": "28ac375350c27b3c061ae288bd93de689c9f549a62c284ff365808d861bc0b59", + "size": 52972, + "subdir": "linux-64", + "timestamp": 1640798779581, + "version": "1.6.0" + }, + "ray-tune-1.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pandas", + "python >=3.8,<3.9.0a0", + "ray-core 1.6.0 py38h295c915_0", + "requests", + "tabulate", + "tensorboardx >=1.9" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3bf0cb8b8a21e0509642eacbe662106c", + "name": "ray-tune", + "sha256": "61a356d5a1527769fd05b691f289e04d531b8b2ef0b9d44ca58433863b96c039", + "size": 52959, + "subdir": "linux-64", + "timestamp": 1640798792336, + "version": "1.6.0" + }, + "ray-tune-1.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pandas", + "python >=3.9,<3.10.0a0", + "ray-core 1.6.0 py39h295c915_0", + "requests", + "tabulate", + "tensorboardx >=1.9" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4d5f09d36866257c0fa06a6effb011af", + "name": "ray-tune", + "sha256": "f412c2199fc80f8eadf92a143819e93929bacd1e85f3aece1d246c753ccfafa0", + "size": 52954, + "subdir": "linux-64", + "timestamp": 1640798786062, + "version": "1.6.0" + }, + "ray-tune-2.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pandas", + "python >=3.10,<3.11.0a0", + "ray-default 2.3.0 py310h06a4308_0", + "requests", + "tabulate", + "tensorboardx >=1.9" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "abc1874126fa6846d38a9c5433327a8d", + "name": "ray-tune", + "sha256": "6a78c02a3b1e9e9004f175eabd88bda57b2aea56602bd0dac7bfe6aec6db7841", + "size": 47769, + "subdir": "linux-64", + "timestamp": 1678437650539, + "version": "2.3.0" + }, + "ray-tune-2.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pandas", + "python >=3.8,<3.9.0a0", + "ray-default 2.3.0 py38h06a4308_0", + "requests", + "tabulate", + "tensorboardx >=1.9" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fc59fdc4da12aa3cf8f321116a894060", + "name": "ray-tune", + "sha256": "078a6eee37c38a2f5fec1ab66c52f41206c9df7092b85542613026db7a5fec95", + "size": 47734, + "subdir": "linux-64", + "timestamp": 1678432441380, + "version": "2.3.0" + }, + "ray-tune-2.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pandas", + "python >=3.9,<3.10.0a0", + "ray-default 2.3.0 py39h06a4308_0", + "requests", + "tabulate", + "tensorboardx >=1.9" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "936586e5cc3c56e896e9b5eab60e5984", + "name": "ray-tune", + "sha256": "4032d7044f936b7d0817c463c50c1518c7eb995408670ddcab2936908b9c34bc", + "size": 47750, + "subdir": "linux-64", + "timestamp": 1678435074866, + "version": "2.3.0" + }, + "rbc-0.5.1-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "llvmlite >=0.29", + "netifaces", + "numba", + "python >=3.10,<3.11.0a0", + "six", + "tblib", + "thriftpy2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b720162fbcee4b0957f10584429d7757", + "name": "rbc", + "sha256": "7620bb7f4321436b15b34d87e91620e73ddebf8e38ec2d37827778955cae8841", + "size": 211810, + "subdir": "linux-64", + "timestamp": 1642514675945, + "version": "0.5.1" + }, + "rbc-0.5.1-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "llvmlite >=0.29", + "netifaces", + "numba", + "python >=3.6,<3.7.0a0", + "six", + "tblib", + "thriftpy2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "34e9c996f4b90d159ba1a988de5ec22b", + "name": "rbc", + "sha256": "77e6b27552f03c342a6073c2d9e0ffd0b142efd9d397d428df82497e1e620b2d", + "size": 212340, + "subdir": "linux-64", + "timestamp": 1622236063043, + "version": "0.5.1" + }, + "rbc-0.5.1-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "llvmlite >=0.29", + "netifaces", + "numba", + "python >=3.7,<3.8.0a0", + "six", + "tblib", + "thriftpy2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f04ee54d1d17d553e30d856eca1031a", + "name": "rbc", + "sha256": "876b189c1dd54dcae5ff42389a910ee5463bd6fb4f9a88c54e61a273d06e4797", + "size": 211601, + "subdir": "linux-64", + "timestamp": 1622235581483, + "version": "0.5.1" + }, + "rbc-0.5.1-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "llvmlite >=0.29", + "netifaces", + "numba", + "python >=3.8,<3.9.0a0", + "six", + "tblib", + "thriftpy2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "29fe6e25703572917d36fbaac02d8414", + "name": "rbc", + "sha256": "803c167925b669a4aa770a7b1572da58f44323c31d10a7af50d0c345bc4471f6", + "size": 213056, + "subdir": "linux-64", + "timestamp": 1622236063280, + "version": "0.5.1" + }, + "rbc-0.5.1-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "llvmlite >=0.29", + "netifaces", + "numba", + "python >=3.9,<3.10.0a0", + "six", + "tblib", + "thriftpy2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4c6948cb1bc22b5f956032b99bfb40c8", + "name": "rbc", + "sha256": "be2f251f73305e5e0c313e10604db61edd0225981e99158661915b2002ad2194", + "size": 212050, + "subdir": "linux-64", + "timestamp": 1622231011140, + "version": "0.5.1" + }, + "re2-2019.08.01-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-clause", + "md5": "84e7513d3368eb8486b0a408fcd51445", + "name": "re2", + "sha256": "7e3311966e1424e34113ed86fe64363d9058078fbc3651564203b5083dd6e916", + "size": 466968, + "subdir": "linux-64", + "timestamp": 1567108263232, + "version": "2019.08.01" + }, + "re2-2020.11.01-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "md5": "d513962f1f549ae2b8cac9f47fde50fc", + "name": "re2", + "sha256": "3947652c6a4febf24632e5fc90c4ed3a091e6cd50812a76f67fe28ca3124661a", + "size": 214756, + "subdir": "linux-64", + "timestamp": 1607097668203, + "version": "2020.11.01" + }, + "re2-2020.11.01-h2531618_1.conda": { + "build": "h2531618_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "md5": "19d3a013a32bc4cffe922e7d13c4984c", + "name": "re2", + "sha256": "293951407250e690362f2223d7ed0176e230673b02d6cf3c200fc80d87d2a913", + "size": 322126, + "subdir": "linux-64", + "timestamp": 1607099328471, + "version": "2020.11.01" + }, + "re2-2022.04.01-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "md5": "6f53e88722a9419d9dcf43b18eab57b2", + "name": "re2", + "sha256": "d2022fcd682abea9b6c78d7e663a05a183be53b2f71c239294de51d78d761e54", + "size": 214979, + "subdir": "linux-64", + "timestamp": 1652449537852, + "version": "2022.04.01" + }, + "readline-7.0-h7b6447c_5.conda": { + "build": "h7b6447c_5", + "build_number": 5, + "depends": [ + "libgcc-ng >=7.3.0", + "ncurses >=6.1,<7.0a0" + ], + "license": "GPL-3.0", + "md5": "a710317bab8ee910a028ddf6da64158b", + "name": "readline", + "sha256": "76c957b9bcb9ab5aa2bd999ff66eaa35981386cf9a5c409fffd545d18c76b440", + "size": 331873, + "subdir": "linux-64", + "timestamp": 1535475436442, + "version": "7.0" + }, + "readline-7.0-ha6073c6_4.conda": { + "build": "ha6073c6_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0", + "ncurses >=6.0,<7.0a0" + ], + "license": "GPL3", + "md5": "8bd4c833d1158591a8f98a054a824447", + "name": "readline", + "sha256": "e80ba32a9eebae2b2e1fd2bc1d602de1c6a667f6106de199a9ea68791905b26b", + "size": 868315, + "subdir": "linux-64", + "timestamp": 1510351119846, + "version": "7.0" + }, + "readline-7.0-hac23ff0_3.conda": { + "build": "hac23ff0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "ncurses 6.0*" + ], + "license": "GPL3", + "md5": "d35b72b1fad417234b04b02b725b61bf", + "name": "readline", + "sha256": "096c08646caf8df54f370cd745d17aaf6f9f872ed15b9b38e6e264a5d2e9b7c4", + "size": 328533, + "subdir": "linux-64", + "timestamp": 1505667005716, + "version": "7.0" + }, + "readline-7.0-hb321a52_4.conda": { + "build": "hb321a52_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "GPL3", + "md5": "a0460f92d777d75f8ef7666dd128c8f1", + "name": "readline", + "sha256": "dc40c06dacca3894da2018c8687dd0370fcbb4cceb2795256bb9b61847141227", + "size": 326619, + "subdir": "linux-64", + "timestamp": 1510178605778, + "version": "7.0" + }, + "readline-8.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ncurses >=6.1,<7.0a0" + ], + "license": "GPL-3.0", + "md5": "a0872d6b7b037b1e073c962140ae72aa", + "name": "readline", + "sha256": "4a572db4157df35b75b3b72963856f7ae7a6d86fb8818daeb001ca494066e225", + "size": 364611, + "subdir": "linux-64", + "timestamp": 1581612239956, + "version": "8.0" + }, + "readline-8.1-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0" + ], + "license": "GPL-3.0", + "md5": "715789a38d447bc0cccc936209ac78c0", + "name": "readline", + "sha256": "5fe35471214d5fc544fa4c37808a6ffbd294d8f6d3ef5c484f2f72d7493e8d1d", + "size": 371059, + "subdir": "linux-64", + "timestamp": 1611868595060, + "version": "8.1" + }, + "readline-8.1.2-h7f8727e_1.conda": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "ncurses >=6.3,<7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "ea33f478fea12406f394944e7e4f3d20", + "name": "readline", + "sha256": "ab74641903ecb92f45c392cffe5bbb712208854c6ea20ab86b65dd4dfc1b1beb", + "size": 362247, + "subdir": "linux-64", + "timestamp": 1642022402894, + "version": "8.1.2" + }, + "readline-8.2-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "be42180685cce6e6b0329201d9f48efb", + "name": "readline", + "sha256": "3bf83c138bf0843b2fdacc5fe6b0956813b11107540d0233c148b97682e894fb", + "size": 365188, + "subdir": "linux-64", + "timestamp": 1666648052561, + "version": "8.2" + }, + "readme_renderer-22.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "d2a0691d96ba68c8bb3083c05ab1f6c6", + "name": "readme_renderer", + "sha256": "a6162c6702f470b2f80cbc396607cccba44ccb99f5dd29ab3582f179b8293ffb", + "size": 22011, + "subdir": "linux-64", + "timestamp": 1539901660758, + "version": "22.0" + }, + "readme_renderer-22.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "1d6a263c9eda4d830bbb2fdf8bce2172", + "name": "readme_renderer", + "sha256": "0a2c59831109fe7804fb44329f70bd0afe8f2a19dffe68434f9de84361c08e2d", + "size": 22111, + "subdir": "linux-64", + "timestamp": 1539901680431, + "version": "22.0" + }, + "readme_renderer-22.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "eec810c50a75c452f54922ab1c245831", + "name": "readme_renderer", + "sha256": "429ddd9710ad4546f20e22fd07e9b3e6588acf0acabce6b2eecc37aeea68c5d1", + "size": 21927, + "subdir": "linux-64", + "timestamp": 1539901692185, + "version": "22.0" + }, + "readme_renderer-24.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=2.7,<2.8.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "0baaaf2c3a68cf5cd0564a8653b2b838", + "name": "readme_renderer", + "sha256": "c33e9aa99f16df5193b8a33acb89e98b559517c4d5660fba76607a7fa47bb0b8", + "size": 23284, + "subdir": "linux-64", + "timestamp": 1541044403627, + "version": "24.0" + }, + "readme_renderer-24.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.10,<3.11.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "fd3098fa68a8a6e7a76a0bab81d9253a", + "name": "readme_renderer", + "sha256": "578176d9e0b7c0474af6fdbb854f22adc4780e0e4859657eaaaa94eb83e22bec", + "size": 19869, + "subdir": "linux-64", + "timestamp": 1640812834904, + "version": "24.0" + }, + "readme_renderer-24.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.11,<3.12.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "c4b7833e03ca793f73cfe54284fd1b2d", + "name": "readme_renderer", + "sha256": "21ec503a46fd78c85e1d5d4d08ddd4ea4ad9edc9c52f287f6018b52c02440e7e", + "size": 22869, + "subdir": "linux-64", + "timestamp": 1676903944285, + "version": "24.0" + }, + "readme_renderer-24.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "6bc033f9fdb587983c79aef93ba48459", + "name": "readme_renderer", + "sha256": "5dadaa1f7a38b93e2f33f8db764cb00221d04d47c8dd04061e9c7f549546ac53", + "size": 23196, + "subdir": "linux-64", + "timestamp": 1541044438399, + "version": "24.0" + }, + "readme_renderer-24.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.6,<3.7.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "af019c34faf95107435405ecfcb666d9", + "name": "readme_renderer", + "sha256": "723b3cd9754165034ac8586a4057539641c3a70d020992e9a3418727c6c8b807", + "size": 259314, + "subdir": "linux-64", + "timestamp": 1613501455737, + "version": "24.0" + }, + "readme_renderer-24.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "43a9d0ad3695d00a16ca7d475834f9ce", + "name": "readme_renderer", + "sha256": "e6fe06c303f797ef39cf74866f69e132cc1d2f3a9b9daa290c432074f90c6c69", + "size": 23220, + "subdir": "linux-64", + "timestamp": 1541044400577, + "version": "24.0" + }, + "readme_renderer-24.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.7,<3.8.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "97196fa2100693fd0302fc4c73027baf", + "name": "readme_renderer", + "sha256": "833f242083523b314baa5505820ea3847dc1f036ed1bb901d5ee11bac0c956c1", + "size": 261230, + "subdir": "linux-64", + "timestamp": 1613502086975, + "version": "24.0" + }, + "readme_renderer-24.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "bc1913b3bc07b0adaad4092ee1def47a", + "name": "readme_renderer", + "sha256": "69190e05611c12b3066ba3c98fb4baa23623812db78b75e6b5aaf35664304a51", + "size": 20030, + "subdir": "linux-64", + "timestamp": 1574169864533, + "version": "24.0" + }, + "readme_renderer-24.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.8,<3.9.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "11b65a86e36a45f6d19dbe385025da46", + "name": "readme_renderer", + "sha256": "133bfdddcce1b716c422d53f4c2c9be2d331883e10612bfc825badb07475ddd1", + "size": 262606, + "subdir": "linux-64", + "timestamp": 1613502095130, + "version": "24.0" + }, + "readme_renderer-24.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "bleach >=2.1.0", + "cmarkgfm >=0.2.0", + "docutils >=0.13.1", + "future", + "pygments", + "python >=3.9,<3.10.0a0", + "setuptools", + "six" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "a51c631fc3cf48e98bd8adf265f88f63", + "name": "readme_renderer", + "sha256": "d94ae971fd8617cfff2ef47b9ef09e545d19a5065f67d30d2e2ce85e15b40a37", + "size": 260063, + "subdir": "linux-64", + "timestamp": 1613502484904, + "version": "24.0" + }, + "redis-4.0.10-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "b54733a8bef522124c4716e494d240ca", + "name": "redis", + "sha256": "48f118c2861aeb6019e551b0d7254fd605d43a0444848072e6ffddff0814ea50", + "size": 2114818, + "subdir": "linux-64", + "timestamp": 1529963725548, + "version": "4.0.10" + }, + "redis-4.0.11-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "4dd4076cc1640cc4ffee104591363a76", + "name": "redis", + "sha256": "0864bbb008d83245822e0843472a052a2af24d5997b0f7b375faab63e920fa67", + "size": 2115049, + "subdir": "linux-64", + "timestamp": 1534830079345, + "version": "4.0.11" + }, + "redis-4.0.2-h6805cf8_0.conda": { + "build": "h6805cf8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "3607b3dd7b673be87286a37d91f83e07", + "name": "redis", + "sha256": "dada3c0d932fd51dbe29afc213ce099f918741607fb7a2cf648f26781046675a", + "size": 2096624, + "subdir": "linux-64", + "timestamp": 1508783877827, + "version": "4.0.2" + }, + "redis-4.0.8-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "a20adeaedfc3727727085bee56c46ef2", + "name": "redis", + "sha256": "d333e804a2ddf9272e5bdf7b785493363b946ebedb717e950e1a21e33c6dd559", + "size": 2108610, + "subdir": "linux-64", + "timestamp": 1520833693819, + "version": "4.0.8" + }, + "redis-4.0.9-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "20ad48cd58224eeec3fb71f44866ff46", + "name": "redis", + "sha256": "9f646c39e92344f39b9ff01bb848845df3052767f465e17b73dd5d1b87609bb1", + "size": 2112655, + "subdir": "linux-64", + "timestamp": 1524133004440, + "version": "4.0.9" + }, + "redis-5.0.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "d100c8cf69438feb5ad4697a1f94afe4", + "name": "redis", + "sha256": "e92addde1e42edc2857ec4a7036185143918a75db8cb4d7e9cbada05ea862752", + "size": 3007747, + "subdir": "linux-64", + "timestamp": 1540449545000, + "version": "5.0.0" + }, + "redis-5.0.3-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "d3ebf032815d45f18b1a56d2ad578715", + "name": "redis", + "sha256": "f1a363d0dc1d57ad8c1d1757fea007de133f048986ac581c80f665557b11407d", + "size": 3547793, + "subdir": "linux-64", + "timestamp": 1548291499252, + "version": "5.0.3" + }, + "redis-py-2.10.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "224bd94aa7ea0a4fc7f168c7b0b3dab0", + "name": "redis-py", + "sha256": "d07a8563862007380bec1d0899863078b8836c5512603f230b183a13c548161d", + "size": 87352, + "subdir": "linux-64", + "timestamp": 1530959167902, + "version": "2.10.6" + }, + "redis-py-2.10.6-py27hd31c425_0.conda": { + "build": "py27hd31c425_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a7e9f7d95735528f414313209e1cf906", + "name": "redis-py", + "sha256": "21a704fec787818192305651065022daeaef05d5f64af02cff1661bff1d65099", + "size": 86258, + "subdir": "linux-64", + "timestamp": 1508916824759, + "version": "2.10.6" + }, + "redis-py-2.10.6-py35h242a0b0_0.conda": { + "build": "py35h242a0b0_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5411cdf1d21fc96b51f7cf842cfda581", + "name": "redis-py", + "sha256": "ae0733ddd1429854ad6163f7f9ce02500b14f1b1ce1394b7e4b796e54088cc9f", + "size": 88251, + "subdir": "linux-64", + "timestamp": 1508916823878, + "version": "2.10.6" + }, + "redis-py-2.10.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef1baf22edd51273a488bbc3ff00dbc6", + "name": "redis-py", + "sha256": "72e79434be0ef433db8416b25b47e763339581b2479b95268569f5c90169ff91", + "size": 88800, + "subdir": "linux-64", + "timestamp": 1530959199213, + "version": "2.10.6" + }, + "redis-py-2.10.6-py36hf9ffb6b_0.conda": { + "build": "py36hf9ffb6b_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62941e7237fbd184984f6a0e3424bc17", + "name": "redis-py", + "sha256": "2a1b860ea89615a23e997c0869945bf38ed304a72138a6667a7a8000b8fcecb9", + "size": 89020, + "subdir": "linux-64", + "timestamp": 1508916843153, + "version": "2.10.6" + }, + "redis-py-2.10.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "99e89d03bd261a03e521f9539ca50ec8", + "name": "redis-py", + "sha256": "2866362161945df6af1b3abcad5c257108b5f49b23f78c6e1405f8cb151f5c95", + "size": 88793, + "subdir": "linux-64", + "timestamp": 1530959230537, + "version": "2.10.6" + }, + "redis-py-3.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce64d69d951abdfb3985fc2aed3e3840", + "name": "redis-py", + "sha256": "4d68092c0203fce2022c35286e71c474e2eb8c3857e32c2a662828c893d2bc72", + "size": 96140, + "subdir": "linux-64", + "timestamp": 1542392415414, + "version": "3.0.0" + }, + "redis-py-3.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a5e40432839bf401aa8445ee0eef077", + "name": "redis-py", + "sha256": "7df69f0c5761547de3615a469c7214c80fef3e9b7fae6c400cd571749198ba42", + "size": 99094, + "subdir": "linux-64", + "timestamp": 1542392421799, + "version": "3.0.0" + }, + "redis-py-3.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0858e22344d51c37381013b6312da32b", + "name": "redis-py", + "sha256": "429fbc4867a8aaed6bc64765c7c915dcc0ad88abfde25ed4d1a058a061903470", + "size": 98993, + "subdir": "linux-64", + "timestamp": 1542392410217, + "version": "3.0.0" + }, + "redis-py-3.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e1edbf2d81a817c37dfb2bd07f21b087", + "name": "redis-py", + "sha256": "107960a7833063ac12474a535b77021e3f6e369a40a713e10ba893a21cc040d6", + "size": 96220, + "subdir": "linux-64", + "timestamp": 1545097498750, + "version": "3.0.1" + }, + "redis-py-3.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2903d52d633aa4204821717a9f132760", + "name": "redis-py", + "sha256": "b2fbe1c96c1960041d304419045aa02adf9b53887ed8a275ede81e408a9346ce", + "size": 99149, + "subdir": "linux-64", + "timestamp": 1545097508274, + "version": "3.0.1" + }, + "redis-py-3.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22f85a8ea4b6db0ebc66a92c24deb4eb", + "name": "redis-py", + "sha256": "51ff85deb208cd32e84913efbc16ba9b12e4eb048ad1ee0f41a32c0ca7ff5dac", + "size": 96865, + "subdir": "linux-64", + "timestamp": 1545097518706, + "version": "3.0.1" + }, + "redis-py-4.3.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=4.0.2", + "deprecated >=1.2.3", + "packaging >=20.4", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4228cbe02fb598527a3e14bd1c3ec369", + "name": "redis-py", + "sha256": "aa8ea48af47f57e792369ebe4f5a973ed9811a8c67c70cc2c918362e4b39cae4", + "size": 343639, + "subdir": "linux-64", + "timestamp": 1664990713733, + "version": "4.3.4" + }, + "redis-py-4.3.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=4.0.2", + "deprecated >=1.2.3", + "packaging >=20.4", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6ca72de55b6586f37f78a72cec08c09", + "name": "redis-py", + "sha256": "8b8b84a6855d59aa1157bf081c6c1798459221578aba8466ad96840211a4167d", + "size": 440339, + "subdir": "linux-64", + "timestamp": 1676861810092, + "version": "4.3.4" + }, + "redis-py-4.3.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=4.0.2", + "deprecated >=1.2.3", + "importlib-metadata >=1.0", + "packaging >=20.4", + "python >=3.7,<3.8.0a0", + "typing-extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "40a6841e5b1037cf9385880a04304ac5", + "name": "redis-py", + "sha256": "de98c3d251afbb80d336c00c518fbc0b9f590ad03d4f9ad51b511e1f232f3492", + "size": 335795, + "subdir": "linux-64", + "timestamp": 1664990769067, + "version": "4.3.4" + }, + "redis-py-4.3.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=4.0.2", + "deprecated >=1.2.3", + "packaging >=20.4", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad43b4045ef19143fb59ada23350a473", + "name": "redis-py", + "sha256": "95f1c49f66b91f1d0f0dfabeb4d3afac9774575d1b8a67011d6338251189add6", + "size": 338387, + "subdir": "linux-64", + "timestamp": 1664990673380, + "version": "4.3.4" + }, + "redis-py-4.3.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "async-timeout >=4.0.2", + "deprecated >=1.2.3", + "packaging >=20.4", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6fa4b8f8955524a8a378c8a1ddb0da12", + "name": "redis-py", + "sha256": "0004ffae3c35a540b60c8af36add876b96cb1372b537fb72938bfc27d4b9944c", + "size": 338223, + "subdir": "linux-64", + "timestamp": 1664990742698, + "version": "4.3.4" + }, + "regex-2017.09.23-py27hecd67f1_0.conda": { + "build": "py27hecd67f1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "md5": "4b8abcd865274a06d43e27d3f5bef3b2", + "name": "regex", + "sha256": "bcd8aadafc4b89abec796755bca7352acec44da2676f893661160868140eeaf5", + "size": 301497, + "subdir": "linux-64", + "timestamp": 1508444399710, + "version": "2017.09.23" + }, + "regex-2017.09.23-py35hb1b125d_0.conda": { + "build": "py35hb1b125d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "md5": "913bedd635ca73bfdff028fcbf6fc975", + "name": "regex", + "sha256": "f846f84d38125473dc0b5977aa25ee9b772b6719c5723c80b1aacd305855f890", + "size": 312471, + "subdir": "linux-64", + "timestamp": 1508444370613, + "version": "2017.09.23" + }, + "regex-2017.09.23-py36h2527052_0.conda": { + "build": "py36h2527052_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "md5": "b31e4af0c20a436d713d0369e0a45fc7", + "name": "regex", + "sha256": "8c3910f82c7c76547376ee4a734972c460cdfe22517c8fafc05e50d2cc958982", + "size": 310904, + "subdir": "linux-64", + "timestamp": 1508444394647, + "version": "2017.09.23" + }, + "regex-2017.11.09-py27h2a269fe_0.conda": { + "build": "py27h2a269fe_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "482f7e1a314bf8ed2f51b21d8daf6b19", + "name": "regex", + "sha256": "1055f7c2cc503f95ba2827bb3f7bae69bf952b4a146ef9c947e47b8bac4da885", + "size": 301411, + "subdir": "linux-64", + "timestamp": 1511320891351, + "version": "2017.11.09" + }, + "regex-2017.11.09-py35h982ee26_0.conda": { + "build": "py35h982ee26_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "4dc19bd17a9b6ea8eacea281ef12ad24", + "name": "regex", + "sha256": "dfb62aa8b6147565432fe47f6e2ce69c9fd84bcb7a5f6e60a48da95621d9c1bb", + "size": 314062, + "subdir": "linux-64", + "timestamp": 1511320847997, + "version": "2017.11.09" + }, + "regex-2017.11.09-py36had819a5_0.conda": { + "build": "py36had819a5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "c75607fc131435c8ce2ae21aedb2e421", + "name": "regex", + "sha256": "d15a93eb3ffa219effb25b96c6e37423cdd11ecb36eeda517b234851320c16b1", + "size": 309338, + "subdir": "linux-64", + "timestamp": 1511320916116, + "version": "2017.11.09" + }, + "regex-2018.02.21-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "ca8c2aaf730fbbc17fe342e729f4a14a", + "name": "regex", + "sha256": "c20515f330a6a9e533f7bb2e8663ebd84b4c523d6a203093ac123cf512d301e4", + "size": 306216, + "subdir": "linux-64", + "timestamp": 1519763915164, + "version": "2018.02.21" + }, + "regex-2018.02.21-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "7b94efe1cfb7236cc6693b2450d90138", + "name": "regex", + "sha256": "ad5f04aeacfdef45e2a55b67eab2b6b74dff3703c85150cfe844117d8a430564", + "size": 317528, + "subdir": "linux-64", + "timestamp": 1519763936359, + "version": "2018.02.21" + }, + "regex-2018.02.21-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "78e16352d2adce7dfb9f63d1509ce2f0", + "name": "regex", + "sha256": "3f7f1ef4e5d49c0fe68f324e0a26f51b098a638080bc9dbefadeb9a74c9e953d", + "size": 316293, + "subdir": "linux-64", + "timestamp": 1519763898683, + "version": "2018.02.21" + }, + "regex-2018.06.09-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "391a0a12992609a3f195fa335affcbc7", + "name": "regex", + "sha256": "449b70698aab4586f2b5bc22857ec528e0f3a5aefbacf57b1436a9d324edd150", + "size": 307497, + "subdir": "linux-64", + "timestamp": 1528984042318, + "version": "2018.06.09" + }, + "regex-2018.06.09-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "7d09849ae2509f0e64f91e36cb3f67e8", + "name": "regex", + "sha256": "61fc22f1fc2d66616851aea9590c6c7e76e5979a4d8db98b426e35bdafc66313", + "size": 321986, + "subdir": "linux-64", + "timestamp": 1528984118763, + "version": "2018.06.09" + }, + "regex-2018.06.09-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "770e7a12c35cfab2e80df260e656e06e", + "name": "regex", + "sha256": "7743a5a01cf2eb46c8b2af03786afcf5edae0ca2a316575862bf2f7b048a684b", + "size": 321049, + "subdir": "linux-64", + "timestamp": 1528984052910, + "version": "2018.06.09" + }, + "regex-2018.06.21-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "b3b97829df2a227dd8fd0a4f7e6eaa2d", + "name": "regex", + "sha256": "90904c47108a1a804f662394f738c86d55e9e4d7ca6f5dab087278ccf04189f2", + "size": 306502, + "subdir": "linux-64", + "timestamp": 1529950239747, + "version": "2018.06.21" + }, + "regex-2018.06.21-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "959b7bf317be483050739da1412eda83", + "name": "regex", + "sha256": "2e758a4b80a08bc091dec05f592c25ab899ceb2ab55e2eec54075c8bb3d239b9", + "size": 321239, + "subdir": "linux-64", + "timestamp": 1529950290787, + "version": "2018.06.21" + }, + "regex-2018.06.21-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "fa5fcd434b9449f12ca64d8e09562912", + "name": "regex", + "sha256": "1692a6ba4b0c66b6803b247e3ebd7d77992ef3e0aa59a193b22c8c0cbe49125b", + "size": 319699, + "subdir": "linux-64", + "timestamp": 1529950194253, + "version": "2018.06.21" + }, + "regex-2018.06.21-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "1a0fc247fa4a2273351278a5a53ef077", + "name": "regex", + "sha256": "fbb76e0787f63e95acd246951274d1eaea82ea1a0c1c4df1789ab6429ac8c76f", + "size": 318746, + "subdir": "linux-64", + "timestamp": 1530959277771, + "version": "2018.06.21" + }, + "regex-2018.07.11-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "386f4049011d05ca68502690a4dfad8a", + "name": "regex", + "sha256": "24c2ccf682f39f70a1597c12d47f619cdbfc1866b19c7f11dd7dfe0baa47932f", + "size": 308320, + "subdir": "linux-64", + "timestamp": 1532628151310, + "version": "2018.07.11" + }, + "regex-2018.07.11-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "929f582b2cac4bcf234baf40f571aec0", + "name": "regex", + "sha256": "a97c3253e1599223569646f4b1f46f0f8198388e2dfd6810ed12332ec90e85eb", + "size": 321663, + "subdir": "linux-64", + "timestamp": 1532628126017, + "version": "2018.07.11" + }, + "regex-2018.07.11-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "094232edf9ccdf2b0711a89c7ac9df77", + "name": "regex", + "sha256": "98713d2ec0c723fa1ab1131cc43c498e4532c121a87c5d3fcb5ebcaf62804f34", + "size": 319518, + "subdir": "linux-64", + "timestamp": 1532628099551, + "version": "2018.07.11" + }, + "regex-2018.07.11-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "597df864e43b6c2f7f8efc59b6b01fea", + "name": "regex", + "sha256": "63cd470420c6b69ac26bd5cf4d5c9a8ddf5e4defc2b2a84fd95ffd683bf3d7c6", + "size": 317118, + "subdir": "linux-64", + "timestamp": 1532628145168, + "version": "2018.07.11" + }, + "regex-2018.08.17-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "b5efbacfe0f1fd421a3dad3ebfdddb7f", + "name": "regex", + "sha256": "40e45d497e804f864a443043dc17e0c3e4aa2b6b81c45fa5f53e31653c97d782", + "size": 312674, + "subdir": "linux-64", + "timestamp": 1535431420606, + "version": "2018.08.17" + }, + "regex-2018.08.17-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "bd053f9f44162732fdd84963d61cae01", + "name": "regex", + "sha256": "a6310dc0756c29c23755e87eb0844285f373c8a973e15b28aee75e42f543e89e", + "size": 325007, + "subdir": "linux-64", + "timestamp": 1535431579261, + "version": "2018.08.17" + }, + "regex-2018.08.17-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "3ae30d46d78666575676e97934920a14", + "name": "regex", + "sha256": "4a92214459b67d7fb4b4fdb74c108b0459733320b0576bd84cf05486b9e214a9", + "size": 323130, + "subdir": "linux-64", + "timestamp": 1535431503446, + "version": "2018.08.17" + }, + "regex-2018.08.17-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "e8af15d4ecc875778f3be39844280582", + "name": "regex", + "sha256": "a9c77cfcf1d55369dbac7e6df0388776706e76988ff923be36d0c671486cf70a", + "size": 322828, + "subdir": "linux-64", + "timestamp": 1535431538667, + "version": "2018.08.17" + }, + "regex-2018.08.29-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "fe2499296335fffa6973ea8f52284e3f", + "name": "regex", + "sha256": "b194f46c4da520e1c545624a24f0b3ccae51c0bbed9c1d86f2d54ad7990b9d7f", + "size": 312549, + "subdir": "linux-64", + "timestamp": 1537471001688, + "version": "2018.08.29" + }, + "regex-2018.08.29-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "5c570848e29951250615a629b48b7d8d", + "name": "regex", + "sha256": "1d570fe854658f0abcd49f57ace7b632314e2ed5ad85cd39bdcfb02125dfe4b1", + "size": 325340, + "subdir": "linux-64", + "timestamp": 1537471043906, + "version": "2018.08.29" + }, + "regex-2018.08.29-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "2aec2a3ebaf5ef8f102549d06d4d8b49", + "name": "regex", + "sha256": "f3ea53b643a1ca45d6c9965c87abd78fb17a0cc6a40eccec8945e7d6c8c13023", + "size": 324041, + "subdir": "linux-64", + "timestamp": 1537471001134, + "version": "2018.08.29" + }, + "regex-2018.08.29-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "9e159863e65682d1dfb88ad83db6d22f", + "name": "regex", + "sha256": "1daaf7c4761330054da1b36e6ab2be77710856d0dfc12b95e0b0f1dcaad47e02", + "size": 323333, + "subdir": "linux-64", + "timestamp": 1537470986100, + "version": "2018.08.29" + }, + "regex-2018.11.02-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "042eae884cfcca7ce45bdb346f0c618f", + "name": "regex", + "sha256": "954d8fb834901d842c336aec326b88025095b6f8b2717d038b2e144f89f3f12f", + "size": 313502, + "subdir": "linux-64", + "timestamp": 1541176233945, + "version": "2018.11.02" + }, + "regex-2018.11.02-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "0788a2b74226fc26a07728ddf07c1be7", + "name": "regex", + "sha256": "a62b117a721247b80ba2d12cc180d4b75fb35fac2c54bd843d39ed621a81d8a3", + "size": 324717, + "subdir": "linux-64", + "timestamp": 1541176255214, + "version": "2018.11.02" + }, + "regex-2018.11.02-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "b755412c0ca080336a3b655c77fcb71e", + "name": "regex", + "sha256": "5a6235792fa7c980d2c205ce3e59e4ef66837bed3d5fd36647e0e848a9810d74", + "size": 323514, + "subdir": "linux-64", + "timestamp": 1541176164692, + "version": "2018.11.02" + }, + "regex-2018.11.07-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "72b510e8254bcdb1d1eb34195aacacf2", + "name": "regex", + "sha256": "1aeca5d9799673ab1bcaa704554fdbc43264a2356329d5673ba4208f827a60bc", + "size": 315126, + "subdir": "linux-64", + "timestamp": 1542088505453, + "version": "2018.11.07" + }, + "regex-2018.11.07-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "75728a0714f87c35c7e63b701419dd96", + "name": "regex", + "sha256": "c6a1abd4849795ed10e5e07a4cd47b42a8e909ca619cf6799a3aa4208e38505f", + "size": 325846, + "subdir": "linux-64", + "timestamp": 1542088497265, + "version": "2018.11.07" + }, + "regex-2018.11.07-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "05ada05417a711798047a3c07fbccdc2", + "name": "regex", + "sha256": "fc46de055e0305affff94ad07a4ee8e90913c1ba316304c0236a83b547ae91e3", + "size": 324722, + "subdir": "linux-64", + "timestamp": 1542088488381, + "version": "2018.11.07" + }, + "regex-2018.11.22-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "9628d0af873d3efcfbcf0678165044a8", + "name": "regex", + "sha256": "7273d4c6204b8bd6a823deee5e2e30fd7f752c42ff6e5cf704363b09aea74d89", + "size": 314660, + "subdir": "linux-64", + "timestamp": 1545098547644, + "version": "2018.11.22" + }, + "regex-2018.11.22-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "4d6812988a8b705caed8bc496f367718", + "name": "regex", + "sha256": "739752c3d1da35b27aaaf34abcee2ee329bb01ba071c99b8831fb94d68214fdb", + "size": 327091, + "subdir": "linux-64", + "timestamp": 1545098565609, + "version": "2018.11.22" + }, + "regex-2018.11.22-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "3830c80a9cf60fc59a901f6af8ddd89a", + "name": "regex", + "sha256": "77c073bb44d808900f1eba6972a49e78479ec2aa5698e4e4f0f6dd697bb54353", + "size": 325458, + "subdir": "linux-64", + "timestamp": 1545098541750, + "version": "2018.11.22" + }, + "regex-2019.03.09-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "e007a1729750b4e219826e0856955189", + "name": "regex", + "sha256": "074ccedbb10aa79c51b530b272fd3abfb8f2270ff801650874980ff045e990e7", + "size": 320779, + "subdir": "linux-64", + "timestamp": 1552369253825, + "version": "2019.03.09" + }, + "regex-2019.03.09-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "bab818dcf13a03979b258644b6f31750", + "name": "regex", + "sha256": "66bc17fd56863c7d7a145782423700d4d192e7a6490faba2ef896d60234a722f", + "size": 332508, + "subdir": "linux-64", + "timestamp": 1552369327293, + "version": "2019.03.09" + }, + "regex-2019.03.09-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "2dcf4f8d9eb812b3ecac4b827d14d251", + "name": "regex", + "sha256": "43b05e5be7789d17091b0356d70328732f95a0fa5467dcf48dc5f6cd215ac821", + "size": 331547, + "subdir": "linux-64", + "timestamp": 1552369286636, + "version": "2019.03.09" + }, + "regex-2019.04.14-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "472b88a210b652948cb2926c72d0fca6", + "name": "regex", + "sha256": "e4b56b11f5a3de58ec50395d673f010cf9a5d214d1ce82c10923106cfb4bc4b8", + "size": 321513, + "subdir": "linux-64", + "timestamp": 1556073868659, + "version": "2019.04.14" + }, + "regex-2019.04.14-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "f5b6ae15dc3ea9a422bec9a54b07f90d", + "name": "regex", + "sha256": "98875280d8c6d4702f1e25af8afcebcf8c9611cc72fd8295d977b45125c3104c", + "size": 334955, + "subdir": "linux-64", + "timestamp": 1556073902322, + "version": "2019.04.14" + }, + "regex-2019.04.14-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "5528ce8f57b6698e92dafb636f6e7350", + "name": "regex", + "sha256": "27fd884c0c169df387df44fa15ab88b122c568445ec59a419166a874325b8372", + "size": 332854, + "subdir": "linux-64", + "timestamp": 1556073861244, + "version": "2019.04.14" + }, + "regex-2019.06.05-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "a33baf20ff3fa74106c125c76b2775e3", + "name": "regex", + "sha256": "ae20cf34c9dcf1af36c4513a26b64fd1e399779a5e7cc19c0c6969a99cb50589", + "size": 324734, + "subdir": "linux-64", + "timestamp": 1559923666783, + "version": "2019.06.05" + }, + "regex-2019.06.05-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "6e55d39b3acbf89f399173bd4f0e16a8", + "name": "regex", + "sha256": "b00266a2f72a7b76145a4d94ad1dbde84b6985145aab1a7e830508fe7d1ddb34", + "size": 337570, + "subdir": "linux-64", + "timestamp": 1559923666305, + "version": "2019.06.05" + }, + "regex-2019.06.05-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "89f84074dfa032339ce3639089d8c7f1", + "name": "regex", + "sha256": "c589bfb3cfe340e1c796e2046b2b7f3113167a7b9dc2d99b054c08881a3886ee", + "size": 335880, + "subdir": "linux-64", + "timestamp": 1559923649516, + "version": "2019.06.05" + }, + "regex-2019.08.19-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "abf6a4602fbf0194b1fbb6b7648691ce", + "name": "regex", + "sha256": "6cd198e2fde812131451acfa8fddfe6b50d67ad0328c5c6409db505c9ae14bd6", + "size": 326861, + "subdir": "linux-64", + "timestamp": 1569350637837, + "version": "2019.08.19" + }, + "regex-2019.08.19-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "194e7fc0a108716b7c0a1bd3085310b3", + "name": "regex", + "sha256": "9f823d49477433265804edf3db484701842de3e9ede1a60a7328efb0b25bb979", + "size": 339730, + "subdir": "linux-64", + "timestamp": 1569350630733, + "version": "2019.08.19" + }, + "regex-2019.08.19-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "76f464ee51d22a731a8233c21e830ced", + "name": "regex", + "sha256": "fef5c50d9131405e8a7258115cf3f40006811ab2825a1a3dd093cd473d361c3e", + "size": 338821, + "subdir": "linux-64", + "timestamp": 1569350652932, + "version": "2019.08.19" + }, + "regex-2019.08.19-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "9cf446b0916d1dcd956ab1321ee84ff2", + "name": "regex", + "sha256": "1acf6f50e02bf6ffc190853af176c8222399fd2a8053207016889fbb02f18bf6", + "size": 339162, + "subdir": "linux-64", + "timestamp": 1573200568150, + "version": "2019.08.19" + }, + "regex-2019.11.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "9522efe7a6d6d420445b9656cfdba954", + "name": "regex", + "sha256": "61cc6f21e895698917e8076a724e1da00215da298dab30949f6962dbe260ad6e", + "size": 326592, + "subdir": "linux-64", + "timestamp": 1573972588164, + "version": "2019.11.1" + }, + "regex-2019.11.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "ec7cab6ad10723db03ea7472ad133fa6", + "name": "regex", + "sha256": "a439422cd34f502e61612282b4e38922afa9255861ec7da6787e9ab27863607a", + "size": 340219, + "subdir": "linux-64", + "timestamp": 1573972592905, + "version": "2019.11.1" + }, + "regex-2019.11.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "2c61cab78178f50dc6fbef7981160373", + "name": "regex", + "sha256": "5bf40d71729ada10961547c34dcb302c01516647c90eb88c4d3035ed855e5fb6", + "size": 339040, + "subdir": "linux-64", + "timestamp": 1573972581617, + "version": "2019.11.1" + }, + "regex-2019.11.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "9476a7786bd738e8b1d3fe9fef14c0b0", + "name": "regex", + "sha256": "853e253bd349c747acfc1adc5414f9f0f84889943192d35f9ec5aa948290cea6", + "size": 347815, + "subdir": "linux-64", + "timestamp": 1573972618287, + "version": "2019.11.1" + }, + "regex-2019.12.9-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "34accd948d8f2e264f9943bafb02572e", + "name": "regex", + "sha256": "0a625251a11b243c05c59094fb5449d998d54ee2d0f3ac0aaabc9ad25544185a", + "size": 326365, + "subdir": "linux-64", + "timestamp": 1576541903699, + "version": "2019.12.9" + }, + "regex-2019.12.9-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "46d788d541b250671923801e78bc2958", + "name": "regex", + "sha256": "ce21e57b35d7d576b0ce1688785d0e4add15bbbe1cb1377d4d944b568453dbb2", + "size": 341468, + "subdir": "linux-64", + "timestamp": 1576541907480, + "version": "2019.12.9" + }, + "regex-2019.12.9-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "5a2ebfb67186e936eae004982d19a60b", + "name": "regex", + "sha256": "c302efa93889d9be9bc0b6b79501c955a29830e622e09b769abf8b600acf7fe9", + "size": 338873, + "subdir": "linux-64", + "timestamp": 1576541899950, + "version": "2019.12.9" + }, + "regex-2019.12.9-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "fbd21b90c56b6df2cfdb12cb45e18104", + "name": "regex", + "sha256": "18ca2efe666d65070d0af98416dc8551d93080e2f4d4290a65bc15529d18e433", + "size": 346098, + "subdir": "linux-64", + "timestamp": 1576541958299, + "version": "2019.12.9" + }, + "regex-2020.1.8-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "d399c675863d09954bb5485a4b2dda8c", + "name": "regex", + "sha256": "bb8fa001d4f8909866d3d464e7f834ec4012428036bc5b85a8a06fe66300bc93", + "size": 341099, + "subdir": "linux-64", + "timestamp": 1581718133048, + "version": "2020.1.8" + }, + "regex-2020.1.8-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "ccfc4fe0fc72c38d08e253c87300abae", + "name": "regex", + "sha256": "2f851b38f725c3bc0f7b2d016dc86ddd28cefc023caf9b57900552c8831c9f25", + "size": 342674, + "subdir": "linux-64", + "timestamp": 1581718140333, + "version": "2020.1.8" + }, + "regex-2020.1.8-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "8fcc895b8698c6341c2a68742c5d72fb", + "name": "regex", + "sha256": "c42be5ce287001b60e0c89948a981f75e59bb3f4473df3734afde3808b32e466", + "size": 342104, + "subdir": "linux-64", + "timestamp": 1581946164335, + "version": "2020.1.8" + }, + "regex-2020.10.11-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "c5e27ac6cc0f741bced7638d5b54c1d7", + "name": "regex", + "sha256": "537e3519a81d2ba013bf2a2b22891d0acef05af519fd961724c0bae3fed951ef", + "size": 333568, + "subdir": "linux-64", + "timestamp": 1602685128110, + "version": "2020.10.11" + }, + "regex-2020.10.11-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "a273df402ae4ffdfd08e09cb1b0a2ad2", + "name": "regex", + "sha256": "469c15e44454432fbfdec30a4686dfb5019bf22cfb9e7d24eb43488283f4b0b2", + "size": 333784, + "subdir": "linux-64", + "timestamp": 1602685123993, + "version": "2020.10.11" + }, + "regex-2020.10.11-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "3756ac2febc3c7a384209ae998bd24a5", + "name": "regex", + "sha256": "ca2ecbdcf91368eabbe35edaa2e795a1eedb4f662976940a5cb0cc0e40f31cc9", + "size": 334570, + "subdir": "linux-64", + "timestamp": 1602685105657, + "version": "2020.10.11" + }, + "regex-2020.10.15-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "8f13ef788cc1d4071fd91089bfe0ed61", + "name": "regex", + "sha256": "6ed228945c95bde527027cffa11dbf12506fa1a7de18171643031307d7811054", + "size": 320542, + "subdir": "linux-64", + "timestamp": 1602786718933, + "version": "2020.10.15" + }, + "regex-2020.10.15-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "7c4868451050cc55cea9b809ab84fb77", + "name": "regex", + "sha256": "1675987ebb09db1107b92817da4b5ffb596398882e0e54d8812b5270b7b94d27", + "size": 322697, + "subdir": "linux-64", + "timestamp": 1602786711918, + "version": "2020.10.15" + }, + "regex-2020.10.15-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "286ba26c0e536a5b92dfbb61c447a7cf", + "name": "regex", + "sha256": "f939a8e97dfbef9762d5eaf39f07d646ae77a5366aec5d53888e440080f6322e", + "size": 324234, + "subdir": "linux-64", + "timestamp": 1602786725849, + "version": "2020.10.15" + }, + "regex-2020.11.13-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "5a2320223fa8b25cd27031f48270b0e4", + "name": "regex", + "sha256": "374f8c5b3232ad8b85f8365182ad9f44b34e5fa450638a00ac1f16c3979e5d12", + "size": 325449, + "subdir": "linux-64", + "timestamp": 1606772765743, + "version": "2020.11.13" + }, + "regex-2020.11.13-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "e2dec06c2f05d69d2f84ddf0090e2649", + "name": "regex", + "sha256": "9f6d0f61a0d0281fe376e9068f0a8c567e543f44b6414684ce1b6ec59f06cb3a", + "size": 326483, + "subdir": "linux-64", + "timestamp": 1606772757964, + "version": "2020.11.13" + }, + "regex-2020.11.13-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "35de8109b4f9a1bb27b7843c03fc1f31", + "name": "regex", + "sha256": "6fe2dcafcf2bfe02ff16cc24ee7dd1a7ac3c578ba31f92dffeab33a618115f78", + "size": 328587, + "subdir": "linux-64", + "timestamp": 1606772779619, + "version": "2020.11.13" + }, + "regex-2020.11.13-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "596f6ec3d3a19e58503686f9eaca27a7", + "name": "regex", + "sha256": "78c77f6a0056bbacfde64fe3e5a796b329d370319f60b570388e6e0a844efdc2", + "size": 326905, + "subdir": "linux-64", + "timestamp": 1606772737788, + "version": "2020.11.13" + }, + "regex-2020.2.20-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "d5bd03f12ea6f9d8583225f75d07a5b6", + "name": "regex", + "sha256": "a0825e10691c813b8f67ca9df70e9010c62876f41ccf0e39af0a954553dfafe8", + "size": 344203, + "subdir": "linux-64", + "timestamp": 1583248538898, + "version": "2020.2.20" + }, + "regex-2020.2.20-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "bf174a1f05a6ff5e028b979a1d9e2c7e", + "name": "regex", + "sha256": "0753fe10f34497bb5ab6b70bdbd70f2063c9c6febc2fe6a9370bd6a83d5a06c0", + "size": 342754, + "subdir": "linux-64", + "timestamp": 1583248528541, + "version": "2020.2.20" + }, + "regex-2020.2.20-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "69f1679f3b0c8334ad2bd2c93bce458e", + "name": "regex", + "sha256": "5cf52a343d776e88472360de445b395ed50491949e0f8883282dd7bb780ff24c", + "size": 342880, + "subdir": "linux-64", + "timestamp": 1583248489259, + "version": "2020.2.20" + }, + "regex-2020.4.4-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "0de2db9a0d32fcaaaeab6fdc422d1dce", + "name": "regex", + "sha256": "bf33e42ffdf29514fe978bc351603d109db3357ba7b13b105f41ccfa659998b1", + "size": 334605, + "subdir": "linux-64", + "timestamp": 1586534611301, + "version": "2020.4.4" + }, + "regex-2020.4.4-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "54414c658d2e95d274362b870d35cfc3", + "name": "regex", + "sha256": "c7eb1fbc0ec621a1cce5858ca6a7d4d9004456a79eca59f83c2f58e34ef533c6", + "size": 334366, + "subdir": "linux-64", + "timestamp": 1586534646762, + "version": "2020.4.4" + }, + "regex-2020.4.4-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "810e365a6b15bb56778aec493275a24e", + "name": "regex", + "sha256": "69e2362fbbafc9336cc213eb5946ec255c4ee899f1a74bbc7db1a7f61f3dbc12", + "size": 336383, + "subdir": "linux-64", + "timestamp": 1586534694964, + "version": "2020.4.4" + }, + "regex-2020.5.14-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "be8980517640fa1796664beb46c5337a", + "name": "regex", + "sha256": "be85bce84e26c64f2a0826c82d635680eb028e4c48503371d0c695127deb0c9a", + "size": 337734, + "subdir": "linux-64", + "timestamp": 1590084197678, + "version": "2020.5.14" + }, + "regex-2020.5.14-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "6e026bbb914988cfcf16da873f055d9c", + "name": "regex", + "sha256": "7c5360c02171ddbb6786d350736f86febee009825a63f1b319ebbdb5bb72af65", + "size": 337253, + "subdir": "linux-64", + "timestamp": 1590084178720, + "version": "2020.5.14" + }, + "regex-2020.5.14-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "ec99d11102da16cc8044e699231c1744", + "name": "regex", + "sha256": "29919a5891d5782b0c0299803eeadcece8d782475bf46a7b651a89245a6a8659", + "size": 337079, + "subdir": "linux-64", + "timestamp": 1590084205286, + "version": "2020.5.14" + }, + "regex-2020.6.8-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "5358c89b5fc6b4dddba0c975be5793ad", + "name": "regex", + "sha256": "0cf489d52520b6d54e7f7823a2602c81c4fe77bbe59d741e5caca22076e34556", + "size": 333899, + "subdir": "linux-64", + "timestamp": 1593435622386, + "version": "2020.6.8" + }, + "regex-2020.6.8-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "e253ec5e0ca37ec22c49eb54c4dab988", + "name": "regex", + "sha256": "17a9ad2ebef3a46b8012e62c76e4ee05826b033cff7bc12ab9ed5e17b3165e4d", + "size": 331463, + "subdir": "linux-64", + "timestamp": 1593435586318, + "version": "2020.6.8" + }, + "regex-2020.6.8-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "df54e2f3a78cd57086f0abfd8b9396a5", + "name": "regex", + "sha256": "8dc5cf8f01db4d102ab2afcc82364f77f9e54bdb3bacc29382aa1194a7c747cc", + "size": 333760, + "subdir": "linux-64", + "timestamp": 1593435597536, + "version": "2020.6.8" + }, + "regex-2020.7.14-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "b91c159944bb59395aa259d41f30f0f8", + "name": "regex", + "sha256": "2e80e91dd617ae9df1344aa68f06999567f5b3b3581a25cc1cc59b55cb58441e", + "size": 330746, + "subdir": "linux-64", + "timestamp": 1596829761188, + "version": "2020.7.14" + }, + "regex-2020.7.14-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "818a8fcc5698e51426caed0b582dd958", + "name": "regex", + "sha256": "be170112b354567ca4712b63d5517a24c191f8982ac98d705cea8b7a69556f8e", + "size": 331934, + "subdir": "linux-64", + "timestamp": 1596829737235, + "version": "2020.7.14" + }, + "regex-2020.7.14-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "30d596eecf2fd0d92326e82fe201b808", + "name": "regex", + "sha256": "d37a89e264fdb9bb68c1a1d5bdf64332623e4bbe900685cda8c37228b640d09b", + "size": 335917, + "subdir": "linux-64", + "timestamp": 1596829732008, + "version": "2020.7.14" + }, + "regex-2020.9.27-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "2f7fbf57762f9dc37a14110245fa4f4f", + "name": "regex", + "sha256": "e518bfca806c78e2e71e4bb9af73f684bd03b90a72f05f133a906045645d7a50", + "size": 322948, + "subdir": "linux-64", + "timestamp": 1602266187709, + "version": "2020.9.27" + }, + "regex-2020.9.27-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "a7df12815ae027137a7041742e9a55d3", + "name": "regex", + "sha256": "79c41effb5f7b779a7fd387880652eb613e31b8f619f34772a326802a08346fb", + "size": 320363, + "subdir": "linux-64", + "timestamp": 1602266204987, + "version": "2020.9.27" + }, + "regex-2020.9.27-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "49a85701d5fdb761717fd0b9a666ae0a", + "name": "regex", + "sha256": "1f9ed34fe3e36bdc3a0388b6119b56d599589733dcd13bd3d45117b4ff0da60e", + "size": 322324, + "subdir": "linux-64", + "timestamp": 1602266207814, + "version": "2020.9.27" + }, + "regex-2021.11.2-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2f25ef66a4c08e841de7f1498135b778", + "name": "regex", + "sha256": "c01ba34bb39998b302a8e962ddceaf1f200bf5782f301506476c7b0822a7510e", + "size": 329767, + "subdir": "linux-64", + "timestamp": 1642021403056, + "version": "2021.11.2" + }, + "regex-2021.11.2-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "49441433c289bab62722b1a8e9cac613", + "name": "regex", + "sha256": "05dbef5bb0d6e3462ea6dd407e9bcb93b9ac672dbf07a6fc7ef524af07396ab5", + "size": 331038, + "subdir": "linux-64", + "timestamp": 1642021434669, + "version": "2021.11.2" + }, + "regex-2021.11.2-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "65d947433e16a4476be4042f5ea91013", + "name": "regex", + "sha256": "56d2ce3f46d711b6e7be2baa3371a96a136a166535b2ebc4ec213d3f91eb3649", + "size": 330895, + "subdir": "linux-64", + "timestamp": 1642021370656, + "version": "2021.11.2" + }, + "regex-2021.3.17-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "33bff5c4e19a7e0e9b6d3faade178cbc", + "name": "regex", + "sha256": "4a948e5408b8b09271abeee367058924fc443882359351c6e4faaf10065e6f6b", + "size": 327660, + "subdir": "linux-64", + "timestamp": 1616096024847, + "version": "2021.3.17" + }, + "regex-2021.3.17-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "f6f7c354ba34110d1a7bff6d0dbf3448", + "name": "regex", + "sha256": "e23164a6e846bafdbfd021e27286b0a8848e043522575e39abb88e285bf27c0f", + "size": 323010, + "subdir": "linux-64", + "timestamp": 1616094083867, + "version": "2021.3.17" + }, + "regex-2021.3.17-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "612719545748524099379babe1d30989", + "name": "regex", + "sha256": "8784ff3baad7e9faad269a3ca7d93d3a41785a3ea7636520d1c68f1720a11ec5", + "size": 327224, + "subdir": "linux-64", + "timestamp": 1616096033205, + "version": "2021.3.17" + }, + "regex-2021.3.17-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "64e2e10999d82e87a1e991a3dd0ff489", + "name": "regex", + "sha256": "5e06e340e4fcfe32b76d108cb782f0a3e963b9489d8c06af5cd7bcc2626500b3", + "size": 325728, + "subdir": "linux-64", + "timestamp": 1616095867497, + "version": "2021.3.17" + }, + "regex-2021.4.4-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "662d872720dcb6428e7c9d50d85cb225", + "name": "regex", + "sha256": "3b55610257a24a89f6299bc5154f467544e55bed0739270747ea2f64a883f51f", + "size": 327031, + "subdir": "linux-64", + "timestamp": 1617569763909, + "version": "2021.4.4" + }, + "regex-2021.4.4-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "275ffc931e32bd707822d07aff7c0afe", + "name": "regex", + "sha256": "94763d2dce597a7fd3bd8fb8c0019aaa004a868ecde109e8949cff73d01c5af9", + "size": 324368, + "subdir": "linux-64", + "timestamp": 1617569767001, + "version": "2021.4.4" + }, + "regex-2021.4.4-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "96385ad1650339994d741b5a39542db5", + "name": "regex", + "sha256": "cd64cc9e8b84cfeabb3e1cf9f4b190b4e0d5b2e76ab874da74ab979327fda780", + "size": 329994, + "subdir": "linux-64", + "timestamp": 1617569251269, + "version": "2021.4.4" + }, + "regex-2021.4.4-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Python-2.0", + "license_family": "PSF", + "md5": "9e6ea23c237a78235baf95971b345ca3", + "name": "regex", + "sha256": "45b07ec1867dbe24ca5471f126ef36620c4ad1a53491bd863dc25edc66e14452", + "size": 327851, + "subdir": "linux-64", + "timestamp": 1617569769303, + "version": "2021.4.4" + }, + "regex-2021.7.6-py36h7f8727e_0.conda": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ce209f7db848215f6a6a1e5847313e51", + "name": "regex", + "sha256": "f9eb60dd8b3ab287fd8ce56e5804357dcfc593c58638102a34700de4a128f6af", + "size": 329952, + "subdir": "linux-64", + "timestamp": 1625610157805, + "version": "2021.7.6" + }, + "regex-2021.7.6-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4e6ab6da6eba29770e2e56e8a0e38ca7", + "name": "regex", + "sha256": "c40e77ede4fae9a413efccfc7f4d6c7234ea6cc46f964d37f8dc4eadee834322", + "size": 325937, + "subdir": "linux-64", + "timestamp": 1625610144933, + "version": "2021.7.6" + }, + "regex-2021.7.6-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "db6de1fefff4ba34ac453c76c2893287", + "name": "regex", + "sha256": "7877d58ad4f575bfc9e39e626e57498210d2732afc477c8b48e62fb09ef602a4", + "size": 326662, + "subdir": "linux-64", + "timestamp": 1625603394959, + "version": "2021.7.6" + }, + "regex-2021.7.6-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0222b433e613d7ad04c7b682cd24de1a", + "name": "regex", + "sha256": "17c52e09871c118571d24878934c44740ebcc0d56e98d35d7976936319ca41a4", + "size": 326858, + "subdir": "linux-64", + "timestamp": 1625603751280, + "version": "2021.7.6" + }, + "regex-2021.8.3-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "93c46120fb6183271dcea8b3a5ee8933", + "name": "regex", + "sha256": "de32412b259c677d26764a181d9a0fe75c5e1b01178ce435a090d219b648e4d6", + "size": 597413, + "subdir": "linux-64", + "timestamp": 1640794332474, + "version": "2021.8.3" + }, + "regex-2021.8.3-py36h7f8727e_0.conda": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f78fee0cc4c28034f4f5aa8fc630edfa", + "name": "regex", + "sha256": "7dd6b8d2ae7b3cae875764a326147e9c85cd0aaa8154f5c806cb178e3d6a4578", + "size": 329045, + "subdir": "linux-64", + "timestamp": 1629293558795, + "version": "2021.8.3" + }, + "regex-2021.8.3-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "21f0535b4865abdd6325d18a2a47880d", + "name": "regex", + "sha256": "74adde439155f4818db17a47766318f634c2fb5b48de3ac8da01cbc842e3c898", + "size": 323230, + "subdir": "linux-64", + "timestamp": 1629293544885, + "version": "2021.8.3" + }, + "regex-2021.8.3-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3fc1190d5e73d9a3b4f811eb9d1ef86a", + "name": "regex", + "sha256": "4a5feb975183132b2fd80a3fe44beff0951b4c86d33a289f9dfd526f096ff151", + "size": 326894, + "subdir": "linux-64", + "timestamp": 1629301384984, + "version": "2021.8.3" + }, + "regex-2021.8.3-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "46138970c364fa10b61c2775c8333485", + "name": "regex", + "sha256": "8cbcf8207f4084ffe030d2b8fec2eb50dda26da95a951a225897d5637b25a44a", + "size": 327838, + "subdir": "linux-64", + "timestamp": 1628063409172, + "version": "2021.8.3" + }, + "regex-2022.3.15-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ba9f5fee94f62e3caa5cb8775ae93955", + "name": "regex", + "sha256": "23080051792b2d3a4c7611ee695513dbea5bb2a89c90e8b467bfa39f5bb5b1f8", + "size": 614565, + "subdir": "linux-64", + "timestamp": 1648429646491, + "version": "2022.3.15" + }, + "regex-2022.3.15-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4c73f2b716b0f28878e99463ec075ce5", + "name": "regex", + "sha256": "b28156c915f7600d1c1b376ba979b4dfa9c157dbdb2d7e21ee246b63f74e6bcb", + "size": 395622, + "subdir": "linux-64", + "timestamp": 1676845661095, + "version": "2022.3.15" + }, + "regex-2022.3.15-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "63a864f8f78ff76b67f4e3bf508fb952", + "name": "regex", + "sha256": "92a700580fcec213a92a2f03d7499ad7b1a6c70f101a33e3e5c3de0cbe3a1e7a", + "size": 340833, + "subdir": "linux-64", + "timestamp": 1648447762836, + "version": "2022.3.15" + }, + "regex-2022.3.15-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "79954d720b1ef30dd38045c81576e6f0", + "name": "regex", + "sha256": "fd6e5ed39814fcbba2b4c64c5a09a89da09eb941a6387f73c6cbf64803aff64a", + "size": 345282, + "subdir": "linux-64", + "timestamp": 1648447758312, + "version": "2022.3.15" + }, + "regex-2022.3.15-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c4a388cdc85957ccefc1c07c9dd09bf8", + "name": "regex", + "sha256": "ad6acdd4a3a6895136fbe2d742dab5bc5c7a90b53d50d36d77e15920c1ca10b2", + "size": 345288, + "subdir": "linux-64", + "timestamp": 1648447756521, + "version": "2022.3.15" + }, + "regex-2022.7.9-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "af8e8f78174fe7ef8349a34ff7c9bd37", + "name": "regex", + "sha256": "7bfa9c5ba05c50a221cc9f70b37bba2ce2ed1148a19987adb467f4bb65954bdf", + "size": 714469, + "subdir": "linux-64", + "timestamp": 1658257279037, + "version": "2022.7.9" + }, + "regex-2022.7.9-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7578d3f7a2a3676c54292e9ce023a147", + "name": "regex", + "sha256": "5dd7448c6e9dac8c46e61cc12339a131378d40ba19ffc91c152ce75b263ce77b", + "size": 394172, + "subdir": "linux-64", + "timestamp": 1677086850954, + "version": "2022.7.9" + }, + "regex-2022.7.9-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8afbc7efca41bd9555cb13745a71e545", + "name": "regex", + "sha256": "e1a61ad2eb074a0fc057fa6937d5a1a4990f50e74e67cc941202818b3880a5e9", + "size": 339880, + "subdir": "linux-64", + "timestamp": 1658257229770, + "version": "2022.7.9" + }, + "regex-2022.7.9-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "777521acbb98b278c310a4147c6e8959", + "name": "regex", + "sha256": "ef31783d4a6de87a4d2c7f72fc8491e750f7f54f25e00eb2705a4b0268ee9f52", + "size": 341909, + "subdir": "linux-64", + "timestamp": 1658257314892, + "version": "2022.7.9" + }, + "regex-2022.7.9-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0d2ababc85fd45159654da8dbc5f9408", + "name": "regex", + "sha256": "b9bb744e57230d6f6043f43febfb1930ac36aa0b5c8c500fe1f8785124d0a70c", + "size": 340230, + "subdir": "linux-64", + "timestamp": 1658257350962, + "version": "2022.7.9" + }, + "reportlab-3.5.10-py27he686d34_0.conda": { + "build": "py27he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5d6a0e0d886c4f6846e491163a1958c1", + "name": "reportlab", + "sha256": "78bb85288fe8bc42e434dfccd73ccc5c28c68a9dac40e83a445215799aef1d2a", + "size": 2304224, + "subdir": "linux-64", + "timestamp": 1542392866359, + "version": "3.5.10" + }, + "reportlab-3.5.10-py36he686d34_0.conda": { + "build": "py36he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "316ea3c07ad41ec116efb04e4f55e1c1", + "name": "reportlab", + "sha256": "59af2595301f6de3e5e0d30f4c3cba679801b1eef27d0827c0c76650dc98858d", + "size": 2291659, + "subdir": "linux-64", + "timestamp": 1542392898831, + "version": "3.5.10" + }, + "reportlab-3.5.10-py37he686d34_0.conda": { + "build": "py37he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2a3706c198de4ae3f9a0f063006d0441", + "name": "reportlab", + "sha256": "7cf69783476d3d0f9ce371bc3ec2bfab56d7ee593b31bbd7e2c40dae4ddeb8f0", + "size": 2288538, + "subdir": "linux-64", + "timestamp": 1542392868576, + "version": "3.5.10" + }, + "reportlab-3.5.12-py27he686d34_0.conda": { + "build": "py27he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "913159ec5eb5f8ae47185d6338b448a8", + "name": "reportlab", + "sha256": "c8f75668296563fad6d6c3aa32362feab87f937b1d669c08de874020af2dc944", + "size": 2321608, + "subdir": "linux-64", + "timestamp": 1545101559629, + "version": "3.5.12" + }, + "reportlab-3.5.12-py36he686d34_0.conda": { + "build": "py36he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b50035d2e2c49323184ae75166460940", + "name": "reportlab", + "sha256": "dbfa7373476bc4dc950f3e4f4e30c3c72f5a9ea5dd0ade0ee1dbcb7396cd736b", + "size": 2279261, + "subdir": "linux-64", + "timestamp": 1545101515334, + "version": "3.5.12" + }, + "reportlab-3.5.12-py37he686d34_0.conda": { + "build": "py37he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ef673e2adaf8b4fba90b6d7438883f91", + "name": "reportlab", + "sha256": "b215bf144e52b2e74d5fb1f1aaf7f0e0da3b5ac091ae1c72756295e3127f73b9", + "size": 2289281, + "subdir": "linux-64", + "timestamp": 1545101598676, + "version": "3.5.12" + }, + "reportlab-3.5.13-py27he686d34_0.conda": { + "build": "py27he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5b17fd7297977a156015cf2fdf1745a5", + "name": "reportlab", + "sha256": "cc44b95d48fcb4e4d6fa72920f7f46c054674db04f8b0a90634cf7897ae18a18", + "size": 2323571, + "subdir": "linux-64", + "timestamp": 1547931430998, + "version": "3.5.13" + }, + "reportlab-3.5.13-py36he686d34_0.conda": { + "build": "py36he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "df5fd40c47803c713e4c67632eaa9656", + "name": "reportlab", + "sha256": "04690d5d3f71307e90a780bd1134281bdc26e541f68bb2e0d3f4ab9d146f24f1", + "size": 2281068, + "subdir": "linux-64", + "timestamp": 1547931476651, + "version": "3.5.13" + }, + "reportlab-3.5.13-py37he686d34_0.conda": { + "build": "py37he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ccddc7f4523d9c450471952820ff286b", + "name": "reportlab", + "sha256": "01138ce6a965e00b3833c948d9dffacebf0b9ec2c5ff8f1e1a326658563a2fa5", + "size": 2291372, + "subdir": "linux-64", + "timestamp": 1547931457178, + "version": "3.5.13" + }, + "reportlab-3.5.19-py27he686d34_0.conda": { + "build": "py27he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "daa2aa69ce2395922261042df27c0ffe", + "name": "reportlab", + "sha256": "39b2257c3918f3bad55b3b71d00e8eefe6a68d364e9e8597ade9becb8ba23c1a", + "size": 2311462, + "subdir": "linux-64", + "timestamp": 1556074465018, + "version": "3.5.19" + }, + "reportlab-3.5.19-py36he686d34_0.conda": { + "build": "py36he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b4a2740ac018f3fe5c402eeeac6f900c", + "name": "reportlab", + "sha256": "6f3a0f44e5f7c88b4e682fe932ea6f0f7ae6ac13acb7017450a8ad11e4cb5006", + "size": 2284988, + "subdir": "linux-64", + "timestamp": 1556074338977, + "version": "3.5.19" + }, + "reportlab-3.5.19-py37he686d34_0.conda": { + "build": "py37he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1fe5ebb86756ffed0146bd02c58d5835", + "name": "reportlab", + "sha256": "3ecae9863378d4bf9a74b22e8a800f1c0c6bf41f5bf3f37f120e7c6b5bcd0af4", + "size": 2280860, + "subdir": "linux-64", + "timestamp": 1556074296862, + "version": "3.5.19" + }, + "reportlab-3.5.2-py27h5871c9b_0.conda": { + "build": "py27h5871c9b_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.2.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c8b1638c0086b13270a4b05765b4daf1", + "name": "reportlab", + "sha256": "dde6a7bf2aa1a6f9c5a88582c8f93ce37e97ecafcf5fad2c9bff252bfcaf88df", + "size": 2278686, + "subdir": "linux-64", + "timestamp": 1532781525958, + "version": "3.5.2" + }, + "reportlab-3.5.2-py35h5871c9b_0.conda": { + "build": "py35h5871c9b_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.2.0", + "pillow >=2.4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9f05099223ff40d1f822e61858965bab", + "name": "reportlab", + "sha256": "a733ad3e14e3bc354d2163ecb2ed562281088785fa495e01e9732c122f9ee01b", + "size": 2285203, + "subdir": "linux-64", + "timestamp": 1532781652866, + "version": "3.5.2" + }, + "reportlab-3.5.2-py36h5871c9b_0.conda": { + "build": "py36h5871c9b_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.2.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dc5952f5e1fc3f3e663051e10fb77d94", + "name": "reportlab", + "sha256": "e9b4550a00331287a7670de2168e6afb087f0989e16f2d90f7fbdb5f746a3b35", + "size": 2257146, + "subdir": "linux-64", + "timestamp": 1532781516557, + "version": "3.5.2" + }, + "reportlab-3.5.2-py37h5871c9b_0.conda": { + "build": "py37h5871c9b_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.2.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "417027ebb60eb4bdb60be5c83d987297", + "name": "reportlab", + "sha256": "7c3a154309d7f666a2b1b7a19faad3d8fadd649b98f17744b22c3e9967cfe181", + "size": 2237937, + "subdir": "linux-64", + "timestamp": 1532781610113, + "version": "3.5.2" + }, + "reportlab-3.5.23-py27he686d34_0.conda": { + "build": "py27he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5fb6843cafea85cfe93cfd2bbc10d581", + "name": "reportlab", + "sha256": "fd668741dc5e07d0d71d2b503e21d8ce4424a84a8cecd535225cf837f57b45fa", + "size": 2321210, + "subdir": "linux-64", + "timestamp": 1559924051972, + "version": "3.5.23" + }, + "reportlab-3.5.23-py36he686d34_0.conda": { + "build": "py36he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "39ada43e730530af0dd142d3225c0d7d", + "name": "reportlab", + "sha256": "1d6145b7599e89e4ca73876485d1ae2d1170c4fd6a4f65d23a4972124b697ac0", + "size": 2286217, + "subdir": "linux-64", + "timestamp": 1559924065117, + "version": "3.5.23" + }, + "reportlab-3.5.23-py37he686d34_0.conda": { + "build": "py37he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ab4a005408dbcd8578eb7534e7326a86", + "name": "reportlab", + "sha256": "824215ce915d3c08c121dd825df5ad9532a5dba2c6bfb527c42e5d4b5a4abab2", + "size": 2283593, + "subdir": "linux-64", + "timestamp": 1559924006739, + "version": "3.5.23" + }, + "reportlab-3.5.26-py27he686d34_0.conda": { + "build": "py27he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b711d803e32ece9854f3e2b845d09d9c", + "name": "reportlab", + "sha256": "5973a8ad097b2078543e9938199adbfc4864fa7f28f64466b92e525f87774106", + "size": 2320265, + "subdir": "linux-64", + "timestamp": 1569350888160, + "version": "3.5.26" + }, + "reportlab-3.5.26-py36he686d34_0.conda": { + "build": "py36he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "29c9415ab0ef6db3bd3ae51633b0c211", + "name": "reportlab", + "sha256": "5757725abc68903037e195a7a4eca471301fd9e619561ac9a9f4526695a28fa0", + "size": 2293603, + "subdir": "linux-64", + "timestamp": 1569350890433, + "version": "3.5.26" + }, + "reportlab-3.5.26-py37he686d34_0.conda": { + "build": "py37he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2da8c86152db81e79264fe6bf371b7b0", + "name": "reportlab", + "sha256": "56503b329e16b9f1accf8f063971ad089eaa989fd62aa96b49c42ad7ec11a432", + "size": 2288877, + "subdir": "linux-64", + "timestamp": 1569350916841, + "version": "3.5.26" + }, + "reportlab-3.5.26-py38he686d34_0.conda": { + "build": "py38he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "70784cf5f67461f716ecb4448ee5d9bc", + "name": "reportlab", + "sha256": "fff373d35e4d0ac54c5edb0bd398aac60f22619f1ffa96b79445bcb5a06f7af9", + "size": 2289895, + "subdir": "linux-64", + "timestamp": 1574274112580, + "version": "3.5.26" + }, + "reportlab-3.5.45-py36hd14fb90_0.conda": { + "build": "py36hd14fb90_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.2,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "66856cb649354e8db9a890c2044f9b5b", + "name": "reportlab", + "sha256": "1c4df016f3378805ab03bd41cc8a85034dbf11c51835ea4ad9f658a178dd72e5", + "size": 2330225, + "subdir": "linux-64", + "timestamp": 1595336969933, + "version": "3.5.45" + }, + "reportlab-3.5.45-py37hd14fb90_0.conda": { + "build": "py37hd14fb90_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.2,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1a22015a7906a2fbb42acfaf3076440b", + "name": "reportlab", + "sha256": "15012f5c09114309677b0a6e460877596991e0f6fc72a5ddd38aa3a346195356", + "size": 2327128, + "subdir": "linux-64", + "timestamp": 1595342241165, + "version": "3.5.45" + }, + "reportlab-3.5.45-py38hd14fb90_0.conda": { + "build": "py38hd14fb90_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.2,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8958cee35f40a3f0d5e169f776f8b8d0", + "name": "reportlab", + "sha256": "1f56f9df1cc24461defffff4f0f95de2d02a11e9a61349c3b1b9ef4da46cf8f2", + "size": 2332441, + "subdir": "linux-64", + "timestamp": 1595336962395, + "version": "3.5.45" + }, + "reportlab-3.5.51-py36h8e67044_0.conda": { + "build": "py36h8e67044_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.2,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ba6819638fe4f938b76354db53b08c24", + "name": "reportlab", + "sha256": "7878ab5fcf8ec10283b752bf4e10443a6ee59262404b9b88af1369955fae43ac", + "size": 2339831, + "subdir": "linux-64", + "timestamp": 1601054408985, + "version": "3.5.51" + }, + "reportlab-3.5.51-py36hd14fb90_0.conda": { + "build": "py36hd14fb90_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.2,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a84f8d41b3ab0dc53d2fd40d2f5b51da", + "name": "reportlab", + "sha256": "f4f81c7cbee3baa0132003abb8b7b3c7485a9454510994f7e99d3f75f111686b", + "size": 2333072, + "subdir": "linux-64", + "timestamp": 1601054731361, + "version": "3.5.51" + }, + "reportlab-3.5.51-py37h8e67044_0.conda": { + "build": "py37h8e67044_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.2,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6dbc693bb66b06152a2fa5bda05f7510", + "name": "reportlab", + "sha256": "9fe427f1ebd1925008844d508183e9ea676b73818a37361985432e27c3a0d6af", + "size": 2324310, + "subdir": "linux-64", + "timestamp": 1601054378727, + "version": "3.5.51" + }, + "reportlab-3.5.51-py37hd14fb90_0.conda": { + "build": "py37hd14fb90_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.2,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "73359f83925b1af00dafd388667841d9", + "name": "reportlab", + "sha256": "671a5b4167b42f6e0398ae3d68b1a2a090260fdc20adb1086968ab21df99f179", + "size": 2324068, + "subdir": "linux-64", + "timestamp": 1601054735922, + "version": "3.5.51" + }, + "reportlab-3.5.51-py38h8e67044_0.conda": { + "build": "py38h8e67044_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.2,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e7e7d7675fe26119fba181dacb52a2da", + "name": "reportlab", + "sha256": "321a0cb83a0952c3b77222a663ba4500fa766139d9a715cf8e3ff5ea09285ad5", + "size": 2341306, + "subdir": "linux-64", + "timestamp": 1601054407364, + "version": "3.5.51" + }, + "reportlab-3.5.51-py38hd14fb90_0.conda": { + "build": "py38hd14fb90_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.2,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "30733f7955668814da05cbf644a81f4e", + "name": "reportlab", + "sha256": "3e2240c5997976944a7dc9abed13f16510d6d37f7b19ae1134c2538f49c7cf69", + "size": 2328676, + "subdir": "linux-64", + "timestamp": 1601054722393, + "version": "3.5.51" + }, + "reportlab-3.5.59-py36hfdd840d_0.conda": { + "build": "py36hfdd840d_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "39987d7a9f6d2c8d8f2c976582aac61e", + "name": "reportlab", + "sha256": "ac55fc0c553a329ef0b259a6a2de44448fdb04ef33ebe3415b0c3f34f48aea25", + "size": 2346865, + "subdir": "linux-64", + "timestamp": 1610393160112, + "version": "3.5.59" + }, + "reportlab-3.5.59-py36hfdd840d_1.conda": { + "build": "py36hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2c1980947ae12cf97a95f35a45ff64ec", + "name": "reportlab", + "sha256": "223ffce28ae1463df23020462b49c0565428684ddc3796dc7b02dbac9353bced", + "size": 2351152, + "subdir": "linux-64", + "timestamp": 1610483364609, + "version": "3.5.59" + }, + "reportlab-3.5.59-py37hfdd840d_0.conda": { + "build": "py37hfdd840d_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dcdb76d5b81dbc3edbd1075c64e306b8", + "name": "reportlab", + "sha256": "f45972e07bf2d6709fb486bbb1e5837e88bd6516ba9284cfa7f904eb0aa04c6d", + "size": 2345266, + "subdir": "linux-64", + "timestamp": 1610393129766, + "version": "3.5.59" + }, + "reportlab-3.5.59-py37hfdd840d_1.conda": { + "build": "py37hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1d3c0b8aba63b7ff6e512592d3765516", + "name": "reportlab", + "sha256": "bb5a986485f82439eda71a849ec0ada57ec02d33bb4af49c8c87177d3326db4e", + "size": 2347061, + "subdir": "linux-64", + "timestamp": 1610483322191, + "version": "3.5.59" + }, + "reportlab-3.5.59-py38hfdd840d_0.conda": { + "build": "py38hfdd840d_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9ea030dcdfc4152c34685302bfb6c296", + "name": "reportlab", + "sha256": "2885bbd588174f05bdf9888d949f45bcd558366a229830e11d58b3c0aefa1839", + "size": 2347599, + "subdir": "linux-64", + "timestamp": 1610392706915, + "version": "3.5.59" + }, + "reportlab-3.5.59-py38hfdd840d_1.conda": { + "build": "py38hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b0c278a435db88e58b43ce881930d50a", + "name": "reportlab", + "sha256": "2b4effd5726d024f03b4dca16250067729f7ef09eb71559a98643d90bb31c179", + "size": 2343747, + "subdir": "linux-64", + "timestamp": 1610483359179, + "version": "3.5.59" + }, + "reportlab-3.5.59-py39hfdd840d_0.conda": { + "build": "py39hfdd840d_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2b29d0f5d5a1b809c8b38e26872f07cb", + "name": "reportlab", + "sha256": "2535fc1bfd9d513d7ce6fc167b33c5888ec65957636ab905fc482aad7906028d", + "size": 2338130, + "subdir": "linux-64", + "timestamp": 1610393112739, + "version": "3.5.59" + }, + "reportlab-3.5.59-py39hfdd840d_1.conda": { + "build": "py39hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a389904bd7fce7d805b2484c04de14b4", + "name": "reportlab", + "sha256": "c6d72fba78e90318a165681e3597f4d515f271c7c42244aacb107496fe9d6b6c", + "size": 2346556, + "subdir": "linux-64", + "timestamp": 1610483355920, + "version": "3.5.59" + }, + "reportlab-3.5.6-py27he686d34_0.conda": { + "build": "py27he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bd5d51393d2908e493bd858f6190342a", + "name": "reportlab", + "sha256": "cc2be2fa243b1720c9d97a4768610f7bb3f6987f9e58b7e82533366f5b5328c2", + "size": 2302348, + "subdir": "linux-64", + "timestamp": 1535497214075, + "version": "3.5.6" + }, + "reportlab-3.5.6-py35he686d34_0.conda": { + "build": "py35he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cbed44f30c7b038f596eb3a13ce91ced", + "name": "reportlab", + "sha256": "6325ccfd5e082ed7f29fc6bb617bb2f085952a757bce2eb3817341827366c384", + "size": 2322220, + "subdir": "linux-64", + "timestamp": 1535497147040, + "version": "3.5.6" + }, + "reportlab-3.5.6-py36he686d34_0.conda": { + "build": "py36he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "da7eaf8a00597309bff6f252a4fa6e2f", + "name": "reportlab", + "sha256": "1f69ce74a3c3b58a621e484736f3410123366d8ea8f2cfdc24a2a1d3abf97a28", + "size": 2277174, + "subdir": "linux-64", + "timestamp": 1535497077158, + "version": "3.5.6" + }, + "reportlab-3.5.6-py37he686d34_0.conda": { + "build": "py37he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "592e6d70a7d2dc5a0802293bf6d857a2", + "name": "reportlab", + "sha256": "19d50d0a686a87a8be56048474ccaa4c57868dc6c38a5dcf7ef5174bb5e40687", + "size": 2287143, + "subdir": "linux-64", + "timestamp": 1535497192061, + "version": "3.5.6" + }, + "reportlab-3.5.60-py36hfdd840d_1.conda": { + "build": "py36hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7664afc9914f3224ba38f7fbe00c1e17", + "name": "reportlab", + "sha256": "99a42634892dbd724ae90e3dd3f4143568dd335c09ac68721c0e04fa5bc55a8b", + "size": 2342269, + "subdir": "linux-64", + "timestamp": 1611344752053, + "version": "3.5.60" + }, + "reportlab-3.5.60-py37hfdd840d_1.conda": { + "build": "py37hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cdfac6e72772d0cf4b72a7d520a7f814", + "name": "reportlab", + "sha256": "604482631c0e68df177c66fb03777fc60eb19ae64e099ddc2295e3dc6c34a034", + "size": 2339652, + "subdir": "linux-64", + "timestamp": 1611343968529, + "version": "3.5.60" + }, + "reportlab-3.5.60-py38hfdd840d_1.conda": { + "build": "py38hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eac8cfc8d6ce6b8e2358027aee409f05", + "name": "reportlab", + "sha256": "a6741ca2c4731d3b61a48ee7d8eb3b0c4fb3c8947ba040121ee5198a1869bb14", + "size": 2338238, + "subdir": "linux-64", + "timestamp": 1611344746318, + "version": "3.5.60" + }, + "reportlab-3.5.60-py39hfdd840d_1.conda": { + "build": "py39hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "23b78298e85768dcfce435cadf9f55d9", + "name": "reportlab", + "sha256": "21dc9d8127e7ba8c537f8bbc26eb3dbe00017be8786d2fa860b4631681850e1a", + "size": 2338906, + "subdir": "linux-64", + "timestamp": 1611344724025, + "version": "3.5.60" + }, + "reportlab-3.5.64-py36hfdd840d_0.conda": { + "build": "py36hfdd840d_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a13bbfd0985803d03389f67136afa27c", + "name": "reportlab", + "sha256": "8dd3d620d6dcb7b38836f8db5fcf880ac2957f6f254607da82ae511a2411f12b", + "size": 2335236, + "subdir": "linux-64", + "timestamp": 1615457339008, + "version": "3.5.64" + }, + "reportlab-3.5.64-py36hfdd840d_1.conda": { + "build": "py36hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "107ec8f238436f151be64a5befc04204", + "name": "reportlab", + "sha256": "8cfcb730c2cbdb629d4315223e83f02110d22e802860cb2f9afd1287b6ed49aa", + "size": 2330752, + "subdir": "linux-64", + "timestamp": 1615545717179, + "version": "3.5.64" + }, + "reportlab-3.5.64-py37hfdd840d_0.conda": { + "build": "py37hfdd840d_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b5034409658e577bc61a93e216ee728e", + "name": "reportlab", + "sha256": "7be5db357ec3835b1794ad9b714567a42b5b3f7247b7f7705550e14e42b03073", + "size": 2320093, + "subdir": "linux-64", + "timestamp": 1615455734436, + "version": "3.5.64" + }, + "reportlab-3.5.64-py37hfdd840d_1.conda": { + "build": "py37hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "556b69c67b5aab81defa566331884b08", + "name": "reportlab", + "sha256": "46d837a0fa0cd733bf5fcbe7a2292b42df36a9e4c3cd9c51f62ca65d3aa53e40", + "size": 2325733, + "subdir": "linux-64", + "timestamp": 1615547360600, + "version": "3.5.64" + }, + "reportlab-3.5.64-py38hfdd840d_0.conda": { + "build": "py38hfdd840d_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "db6456fa275a08e1952af0010d26458a", + "name": "reportlab", + "sha256": "6a17cd9ad6a025eda9c05a9595ff1e2bbf120e0e2d5b58d00f4292fb1fc7ff70", + "size": 2324838, + "subdir": "linux-64", + "timestamp": 1615457333370, + "version": "3.5.64" + }, + "reportlab-3.5.64-py38hfdd840d_1.conda": { + "build": "py38hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f10f87fa414e3a6b4eda086d2f0c8480", + "name": "reportlab", + "sha256": "9de2526dff51350dfac253ac4e88f5da52b8594d20ebc2ca3727f1671887f9b7", + "size": 2334908, + "subdir": "linux-64", + "timestamp": 1615547381171, + "version": "3.5.64" + }, + "reportlab-3.5.64-py39hfdd840d_0.conda": { + "build": "py39hfdd840d_0", + "build_number": 0, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c0ee64be0603e55d53d5d2b069004ec0", + "name": "reportlab", + "sha256": "2a99709d6db19dd4ff6f2d0fd01153618a3442fe443def493633ce18e089f16d", + "size": 2323563, + "subdir": "linux-64", + "timestamp": 1615457330771, + "version": "3.5.64" + }, + "reportlab-3.5.64-py39hfdd840d_1.conda": { + "build": "py39hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c5612c5a04dfd8adc72a8ce8b0fefeba", + "name": "reportlab", + "sha256": "d20d3e2378684f4cc1079e215a3c687b3cfa71c231f0339e3f02465a1694109f", + "size": 2328824, + "subdir": "linux-64", + "timestamp": 1615547361742, + "version": "3.5.64" + }, + "reportlab-3.5.65-py36hfdd840d_1.conda": { + "build": "py36hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "028a8feda1a6442632cb2e696530af16", + "name": "reportlab", + "sha256": "4efd50ea70913347a2ff382fd748f8d840c7c63dbb25c80f91b427eacb7ea2ac", + "size": 2336395, + "subdir": "linux-64", + "timestamp": 1615546851765, + "version": "3.5.65" + }, + "reportlab-3.5.65-py37hfdd840d_1.conda": { + "build": "py37hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0a3a7b6d50fcd1b46b26beedf3bfd8e5", + "name": "reportlab", + "sha256": "78e1c0f40bf7108482a05420159401c2f3edb1ce1263a1344338e1d6c05ec992", + "size": 2322014, + "subdir": "linux-64", + "timestamp": 1615548508021, + "version": "3.5.65" + }, + "reportlab-3.5.65-py38hfdd840d_1.conda": { + "build": "py38hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f51dc78ff7819fe67656bad970a41cfa", + "name": "reportlab", + "sha256": "350c6568a9662f506b6cad4fdf845727ddf912e9ebabc5b12d537a224591f107", + "size": 2330695, + "subdir": "linux-64", + "timestamp": 1615548513733, + "version": "3.5.65" + }, + "reportlab-3.5.65-py39hfdd840d_1.conda": { + "build": "py39hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e8d3cb263aef3c706ceaf012b7e3e2f3", + "name": "reportlab", + "sha256": "c95910b3a104b698aba4797ac847ce9890199753406090f4b534fc5cb3e8aef0", + "size": 2337056, + "subdir": "linux-64", + "timestamp": 1615548500043, + "version": "3.5.65" + }, + "reportlab-3.5.66-py36hfdd840d_1.conda": { + "build": "py36hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0df4801e5f811ef35fabce1ac95b4f4d", + "name": "reportlab", + "sha256": "75eb27e705c82363b14ce2c706a039705ce91f6db67048d1c1d95270b13935bc", + "size": 2335711, + "subdir": "linux-64", + "timestamp": 1616183176821, + "version": "3.5.66" + }, + "reportlab-3.5.66-py37hfdd840d_1.conda": { + "build": "py37hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aac60b3fb58bdb8acd5f1c26a4d94c77", + "name": "reportlab", + "sha256": "11056780bf9e7d695a1df6c0b8303408a7935ff8df63ee5f960916f79d5ced11", + "size": 2334218, + "subdir": "linux-64", + "timestamp": 1616182393368, + "version": "3.5.66" + }, + "reportlab-3.5.66-py38hfdd840d_1.conda": { + "build": "py38hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "07a30b86b247f2b79e5ba445f7ee6af2", + "name": "reportlab", + "sha256": "ef13ee61d15438f9d6350227a28fa12bd08cd61b6330635c90cb037eab206d0f", + "size": 2337377, + "subdir": "linux-64", + "timestamp": 1616183185061, + "version": "3.5.66" + }, + "reportlab-3.5.66-py39hfdd840d_1.conda": { + "build": "py39hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2207b24311e1f5644fc56ddc071d74e7", + "name": "reportlab", + "sha256": "e8122fde2041d8063256c8de994b875efa8417a35fdb70c6beeee46a9c1e3828", + "size": 2333179, + "subdir": "linux-64", + "timestamp": 1616183171887, + "version": "3.5.66" + }, + "reportlab-3.5.67-py310h0edfc0f_1.conda": { + "build": "py310h0edfc0f_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.5.0", + "pillow >=4.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "37ce8bd54624a24703a005eb05cd122d", + "name": "reportlab", + "sha256": "a0e9eed8abdd71908dc64ab545c978d8f24d10c0d358deca0a87448d36690547", + "size": 2533299, + "subdir": "linux-64", + "timestamp": 1643116904246, + "version": "3.5.67" + }, + "reportlab-3.5.67-py36hfdd840d_1.conda": { + "build": "py36hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1563660ea195174518b5d64b8c29e86b", + "name": "reportlab", + "sha256": "b3ff515c8fd70867f7dbd4a604e6659252b7d9c658da3d546b79fa1fbe981186", + "size": 2329680, + "subdir": "linux-64", + "timestamp": 1618696020047, + "version": "3.5.67" + }, + "reportlab-3.5.67-py37hfdd840d_1.conda": { + "build": "py37hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fc01b2f8dccd33029dea3146ba7498b3", + "name": "reportlab", + "sha256": "71828b68cb682a1c3c2ba6f12785abd0f60ac82f32ba055b7fabec452f5c69c4", + "size": 2329151, + "subdir": "linux-64", + "timestamp": 1618695999497, + "version": "3.5.67" + }, + "reportlab-3.5.67-py38hfdd840d_1.conda": { + "build": "py38hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8a3ec693e99c2a6c70dc0511e0ac2bea", + "name": "reportlab", + "sha256": "be54bb00db3e284025c979fbb324dce9b70e89b9c4133804a4a60f0e4f1d01e0", + "size": 2337505, + "subdir": "linux-64", + "timestamp": 1618695996154, + "version": "3.5.67" + }, + "reportlab-3.5.67-py39hfdd840d_1.conda": { + "build": "py39hfdd840d_1", + "build_number": 1, + "depends": [ + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=4.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "96ad16815a97e513afc7ff0c86bc3f2e", + "name": "reportlab", + "sha256": "955ef3539d4f2fc434d470b1ec96a63fc116c02d13e64265c31aab6907f15ef8", + "size": 2340987, + "subdir": "linux-64", + "timestamp": 1618849751728, + "version": "3.5.67" + }, + "reportlab-3.5.8-py27he686d34_0.conda": { + "build": "py27he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "68513a4daee0a63f809c980ea45d35aa", + "name": "reportlab", + "sha256": "53e1d05db0e90b9cb6567042a2f60c72561d35b520b36cf9cd198ccb10bf9156", + "size": 2318924, + "subdir": "linux-64", + "timestamp": 1538182431074, + "version": "3.5.8" + }, + "reportlab-3.5.8-py36he686d34_0.conda": { + "build": "py36he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "84c16d6427525e10ebaca5a395129588", + "name": "reportlab", + "sha256": "7d782a1ef101e3613eceeedeb48f0fd132a2732a8d19babf6f290562080786b8", + "size": 2290896, + "subdir": "linux-64", + "timestamp": 1538182493217, + "version": "3.5.8" + }, + "reportlab-3.5.8-py37he686d34_0.conda": { + "build": "py37he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "77ef3f83ce6c4b1989ffc2693c403b30", + "name": "reportlab", + "sha256": "141222a5d0db2a0cc4889ceccbca0ec898902b72d61946bd46289f771a858bf5", + "size": 2286862, + "subdir": "linux-64", + "timestamp": 1538182433884, + "version": "3.5.8" + }, + "reportlab-3.5.9-py27he686d34_0.conda": { + "build": "py27he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "882082327c37e2a769264176dc06341d", + "name": "reportlab", + "sha256": "1b5df5b0e1b7b2fbc10c25d82f4b294d3911c52713bd0006bc59c3d0f9c73cfc", + "size": 2303456, + "subdir": "linux-64", + "timestamp": 1538866441606, + "version": "3.5.9" + }, + "reportlab-3.5.9-py36he686d34_0.conda": { + "build": "py36he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5c1fb67c630c1addf3b6c8bc84c1337a", + "name": "reportlab", + "sha256": "896604a6817aa047a8f490c41e4bd1091e0a06bace353e9d72e367f15f36abe1", + "size": 2291310, + "subdir": "linux-64", + "timestamp": 1538866459752, + "version": "3.5.9" + }, + "reportlab-3.5.9-py37he686d34_0.conda": { + "build": "py37he686d34_0", + "build_number": 0, + "depends": [ + "freetype >=2.9.1,<3.0a0", + "libgcc-ng >=7.3.0", + "pillow >=2.4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4f4816d31692f70ccbaa1f06579db1fc", + "name": "reportlab", + "sha256": "c0931d51f0e056119c084520239c0956211b6bddd5e995c0561bb5cf9fa392a4", + "size": 2273252, + "subdir": "linux-64", + "timestamp": 1538866350412, + "version": "3.5.9" + }, + "reportlab-3.6.12-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "freetype 2.10.4,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=11.2.0", + "pillow >=9.0.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "46f9bae8c2142ca6e197c96163b490b8", + "name": "reportlab", + "sha256": "74cb0ca2e1de3e6bcfea9e1389e5d0a64d3a2c62c6eb7f450644ce45b0d49870", + "size": 2607617, + "subdir": "linux-64", + "timestamp": 1676301061491, + "version": "3.6.12" + }, + "reportlab-3.6.12-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "freetype 2.10.4,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=11.2.0", + "pillow >=9.0.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "60eb27e2f0f046f84050cfc1b0f5e880", + "name": "reportlab", + "sha256": "da9f9a360998a1efb27fbf16fe0ab025bf6b5f324a3876bfe180892303ba1b89", + "size": 2801665, + "subdir": "linux-64", + "timestamp": 1676861836208, + "version": "3.6.12" + }, + "reportlab-3.6.12-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "freetype 2.10.4,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=11.2.0", + "pillow >=9.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "387ec26bb249e29f67f2fb22a18d0f8c", + "name": "reportlab", + "sha256": "59605e874eb7182a75c79e719daac3137380fa79c7b2b577aa6320228b25be4f", + "size": 2548626, + "subdir": "linux-64", + "timestamp": 1676301100049, + "version": "3.6.12" + }, + "reportlab-3.6.12-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "freetype 2.10.4,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=11.2.0", + "pillow >=9.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "86b4c3c12fd73442a45c2cb97e724cab", + "name": "reportlab", + "sha256": "158e2a338c394e26eb8dbb34258ccab43d1b274031317500f3aa94ce9c7cdeb5", + "size": 2554104, + "subdir": "linux-64", + "timestamp": 1676301019737, + "version": "3.6.12" + }, + "reportlab-3.6.12-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "freetype 2.10.4,<3.0a0", + "freetype >=2.10.4,<3.0a0", + "libgcc-ng >=11.2.0", + "pillow >=9.0.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "260a3b48d1326beb070fdb8f9de0a053", + "name": "reportlab", + "sha256": "7a484052377a830fe54afa219214c5691c4c8939395a537b6973a60e48845689", + "size": 2551549, + "subdir": "linux-64", + "timestamp": 1676301138644, + "version": "3.6.12" + }, + "repoze.lru-0.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "886bbefad18d3f5435d6849bd11c8e84", + "name": "repoze.lru", + "sha256": "35bb300dec0a37f7687394eacad0dae475c55e0d5b810e823edc752cc9e033cb", + "size": 22675, + "subdir": "linux-64", + "timestamp": 1530875535385, + "version": "0.7" + }, + "repoze.lru-0.7-py27h62c147e_0.conda": { + "build": "py27h62c147e_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "8cde39a6c3a19d588a6c7b77f451ce75", + "name": "repoze.lru", + "sha256": "ce7a10abb91565ae87c58f69dc1f4f4f2a210ff7c5c0aa2041bbfd85be5e27e8", + "size": 23020, + "subdir": "linux-64", + "timestamp": 1509044644111, + "version": "0.7" + }, + "repoze.lru-0.7-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "0878f40a90851169e677211786e7bab1", + "name": "repoze.lru", + "sha256": "ab56765e3b0e1190714c503d6754190ba7a9648f578c2c5ad4abbade9c873770", + "size": 23471, + "subdir": "linux-64", + "timestamp": 1640794351628, + "version": "0.7" + }, + "repoze.lru-0.7-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "md5": "6f82fc8d524e798ea3e84269f45daecb", + "name": "repoze.lru", + "sha256": "3d450673c1243bf6ec7f4937639f7599918ffb5535004de42e1d8ba2889a4813", + "size": 30112, + "subdir": "linux-64", + "timestamp": 1676905989911, + "version": "0.7" + }, + "repoze.lru-0.7-py35h65eef69_0.conda": { + "build": "py35h65eef69_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "9ae58d703ff9a132e87857b184c0f5f5", + "name": "repoze.lru", + "sha256": "8a865837bd529c34dceb84498fafc327e7acf4711159acd2d24b13ed012135cc", + "size": 23374, + "subdir": "linux-64", + "timestamp": 1509044644803, + "version": "0.7" + }, + "repoze.lru-0.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "e47e639465d5e899898f82509501d6cb", + "name": "repoze.lru", + "sha256": "b9be95cc35c2df7b4818d837bf2b750ea351b61e96649dfd3e55d5460d5f0df4", + "size": 23068, + "subdir": "linux-64", + "timestamp": 1530875485318, + "version": "0.7" + }, + "repoze.lru-0.7-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "922277a0e96bf70ef17165346167385e", + "name": "repoze.lru", + "sha256": "58ff3e2067d241dc8ebf9da064fc64790a05d5fef48c595396a063d856400a80", + "size": 315778, + "subdir": "linux-64", + "timestamp": 1632756999155, + "version": "0.7" + }, + "repoze.lru-0.7-py36h5d7ca38_0.conda": { + "build": "py36h5d7ca38_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "16efe92e00101d632a4b2bc8ab93b343", + "name": "repoze.lru", + "sha256": "f9061ce749f9e6369299bbd7ddfb143b137bd156a0ebdeac8b06b4fda9c93436", + "size": 23311, + "subdir": "linux-64", + "timestamp": 1509044655994, + "version": "0.7" + }, + "repoze.lru-0.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "a5f36b148ef3cdc1a99b366118e60962", + "name": "repoze.lru", + "sha256": "c5ede932e86b15438ed640d277866396fd5c33f65f6471774dea02f5762174f6", + "size": 23124, + "subdir": "linux-64", + "timestamp": 1530875510813, + "version": "0.7" + }, + "repoze.lru-0.7-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "8f768b165268fe1ed70f567985c2161c", + "name": "repoze.lru", + "sha256": "3ce561cb3a0b01bbe86ec27eae882bcda0175eff28b9d3e74ae5806f454a1f07", + "size": 315972, + "subdir": "linux-64", + "timestamp": 1632746595225, + "version": "0.7" + }, + "repoze.lru-0.7-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "77acb77d8273e4a519c47fc4202e6b05", + "name": "repoze.lru", + "sha256": "03b29c3f50baf508ec21f4ab042e1129e96a7ea3dac185e1f78343dc63c538f2", + "size": 23560, + "subdir": "linux-64", + "timestamp": 1573200580286, + "version": "0.7" + }, + "repoze.lru-0.7-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "6d6715d83756189fd63b7ecde529cf83", + "name": "repoze.lru", + "sha256": "076080a7580d65ee742f2883fd2530fb632da5db8f2e45aa348d7256078060cc", + "size": 315916, + "subdir": "linux-64", + "timestamp": 1632756981195, + "version": "0.7" + }, + "repoze.lru-0.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "f82a2dd08f4fff808bc6ae1ce0b9b6a5", + "name": "repoze.lru", + "sha256": "68b0759fa5179153f54e5e2197988f885d7a5ca8115c4f7b31475619e55dc50b", + "size": 315946, + "subdir": "linux-64", + "timestamp": 1632750933078, + "version": "0.7" + }, + "reproc-14.2.4-h295c915_1.conda": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d37ab699a3061cca9958f0a10399019f", + "name": "reproc", + "sha256": "8824afb4a01f3e3f190fb7c146aec57ca68379337557aae23d5521245392d1d9", + "size": 31119, + "subdir": "linux-64", + "timestamp": 1647441819202, + "version": "14.2.4" + }, + "reproc-cpp-14.2.4-h295c915_1.conda": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "reproc 14.2.4 h295c915_1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "740e5ba0474526bb866d44b66bb9243b", + "name": "reproc-cpp", + "sha256": "27322d2d14c7f0597cffda71c7359c4907268a4ab3fa92ddaacdc980c54fb8ff", + "size": 22682, + "subdir": "linux-64", + "timestamp": 1647441839399, + "version": "14.2.4" + }, + "reproc-cpp-static-14.2.4-h295c915_1.conda": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dfc0276a32518228a7e1bef1e714ba3d", + "name": "reproc-cpp-static", + "sha256": "b9674d29e0012b477dfd08c16f0d466a61eeef40e4884c8d868bb54f43c576db", + "size": 12407, + "subdir": "linux-64", + "timestamp": 1647441867159, + "version": "14.2.4" + }, + "reproc-static-14.2.4-h7f8727e_1.conda": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "513c26c2dd1378a14579a3547ee85bce", + "name": "reproc-static", + "sha256": "379ec51ada8ff6bdbdb2aeade16f8637b60577a5f82aa32ae716c101e9ba45e1", + "size": 21686, + "subdir": "linux-64", + "timestamp": 1647441853117, + "version": "14.2.4" + }, + "requests-2.18.4-py27hc5b0589_1.conda": { + "build": "py27hc5b0589_1", + "build_number": 1, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.7", + "python >=2.7,<2.8.0a0", + "urllib3 >=1.21.1,<1.23" + ], + "license": "Apache 2.0", + "md5": "be62c7485eeb4b1d4e2d0ea67b3faa40", + "name": "requests", + "sha256": "bacf65af768cef067e159d5dbf547cc878dcb320d6aeb7c1c902bbc4c83c16e5", + "size": 97697, + "subdir": "linux-64", + "timestamp": 1505693067766, + "version": "2.18.4" + }, + "requests-2.18.4-py35hb9e6ad1_1.conda": { + "build": "py35hb9e6ad1_1", + "build_number": 1, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.7", + "python >=3.5,<3.6.0a0", + "urllib3 >=1.21.1,<1.23" + ], + "license": "Apache 2.0", + "md5": "4b0fe882fed8e652e2a82cad4e0f3b66", + "name": "requests", + "sha256": "249bf761a30a58756ed86e5c9bb66c328bae0d29ad83b7ac3b20bb21603aa57c", + "size": 97182, + "subdir": "linux-64", + "timestamp": 1505693080499, + "version": "2.18.4" + }, + "requests-2.18.4-py36he2e5f8d_1.conda": { + "build": "py36he2e5f8d_1", + "build_number": 1, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.7", + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.23" + ], + "license": "Apache 2.0", + "md5": "258bd02f5a6023f647cdf86562de25f4", + "name": "requests", + "sha256": "5e93db9a2da15a22ea6401ebd01a0637a348d27c3fa02e0e4a994d84080799d8", + "size": 96052, + "subdir": "linux-64", + "timestamp": 1505693093401, + "version": "2.18.4" + }, + "requests-2.19.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=2.7,<2.8.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "2b60d0307c7d947cc2593b46bdcbddd8", + "name": "requests", + "sha256": "6c079dc401ff064cbbb254a160f351cd70fd3cf35b85932bbac1c6ac268abdab", + "size": 101940, + "subdir": "linux-64", + "timestamp": 1529357373170, + "version": "2.19.1" + }, + "requests-2.19.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=3.5,<3.6.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "eb8cd558c581748dae82d2d0d7e6bc7b", + "name": "requests", + "sha256": "91cf9b9bc539b143ebd3636ccb7a98a03c6844754bb02e048e83e35ef33cf29f", + "size": 102805, + "subdir": "linux-64", + "timestamp": 1529357386857, + "version": "2.19.1" + }, + "requests-2.19.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "ad5ad3a15188fac9925d0dea5a285dc5", + "name": "requests", + "sha256": "55a120bc839ce5b0a5a336712d77f3cc944a5f72e546f522abbd7b6bd9018449", + "size": 101649, + "subdir": "linux-64", + "timestamp": 1529357353596, + "version": "2.19.1" + }, + "requests-2.19.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "e8c4ec0739ebf7dfddf959a9c666345a", + "name": "requests", + "sha256": "d299fc51ab074ae194e2230d1e08962ff2346ac297b042b7f814a8bca8e1e442", + "size": 100000, + "subdir": "linux-64", + "timestamp": 1530733584270, + "version": "2.19.1" + }, + "requests-2.20.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=2.7,<2.8.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "0e1ebe8113e02c5c1aa78e19d399c922", + "name": "requests", + "sha256": "81d75c40a6acfed61338a24f4d763ee4914db8d797772911b494cd4aa75fa35c", + "size": 89228, + "subdir": "linux-64", + "timestamp": 1540229658467, + "version": "2.20.0" + }, + "requests-2.20.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "b1519dab08edb29a44a48a621403ac94", + "name": "requests", + "sha256": "58d77ddad82ed6f19e44d7b0ca41c101cb497f870cca86c161a0da1ae2667b08", + "size": 87762, + "subdir": "linux-64", + "timestamp": 1540229688940, + "version": "2.20.0" + }, + "requests-2.20.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "1c58ea8951c02bc5ca2a164341cb4861", + "name": "requests", + "sha256": "816bf5c4a1bd9b7743e217fa4bbbb6a1fdce4965aa6818fe8e9707c661a5d1e1", + "size": 87773, + "subdir": "linux-64", + "timestamp": 1540229690297, + "version": "2.20.0" + }, + "requests-2.20.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=2.7,<2.8.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "3e56e510845811aaad17dedc0efc7b58", + "name": "requests", + "sha256": "e23d42d1fee2317588a11edb805201aafacaf2ea691fed7a83170a04fc315799", + "size": 87955, + "subdir": "linux-64", + "timestamp": 1542089094363, + "version": "2.20.1" + }, + "requests-2.20.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "79a505ca793047e4fd8567052f1a61c4", + "name": "requests", + "sha256": "25756c00b3cb5b8081e3352ebe79c24074ef2d3632f7f518f4ddbd923acb5747", + "size": 87838, + "subdir": "linux-64", + "timestamp": 1542089131734, + "version": "2.20.1" + }, + "requests-2.20.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.8", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.21.1,<1.24" + ], + "license": "Apache 2.0", + "md5": "1185845f085a810558033e7a44da1aa9", + "name": "requests", + "sha256": "0aed2268f61487893becc6844087cfac3393eefada88bebc24568402af6f1095", + "size": 87657, + "subdir": "linux-64", + "timestamp": 1542089074976, + "version": "2.20.1" + }, + "requests-2.21.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=2.7,<2.8.0a0", + "urllib3 >=1.21.1,<1.25" + ], + "license": "Apache 2.0", + "md5": "a0a0a89605f5fe94b653a5baf9e67210", + "name": "requests", + "sha256": "71cd2658120f988fc200d0244552ada21f34cda073009c1b9e6462b95d7f4dd4", + "size": 89412, + "subdir": "linux-64", + "timestamp": 1545070280718, + "version": "2.21.0" + }, + "requests-2.21.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.25" + ], + "license": "Apache 2.0", + "md5": "6760ea73ec8ef01ec54d26afde3d82fb", + "name": "requests", + "sha256": "21f10c5d3c07e2f097f93863cdff93e9dea019f74e9dd79128e439456e78a830", + "size": 88172, + "subdir": "linux-64", + "timestamp": 1545070298365, + "version": "2.21.0" + }, + "requests-2.21.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.21.1,<1.25" + ], + "license": "Apache 2.0", + "md5": "a1116178762a4cc5bff524a86f60b86f", + "name": "requests", + "sha256": "625881e0a7fa579c141d63d1f00559000f3ec65dff45f8be5aac3dfcd853b050", + "size": 87763, + "subdir": "linux-64", + "timestamp": 1545070316135, + "version": "2.21.0" + }, + "requests-2.22.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=2.7,<2.8.0a0", + "urllib3 >=1.21.1,<1.25" + ], + "license": "Apache 2.0", + "md5": "e42f668b11da7a21cc9420b95a4b484b", + "name": "requests", + "sha256": "6d6eb14f50d24552a927120a256e57b945045bfe36b1ade0acb7c885bd8a9104", + "size": 93745, + "subdir": "linux-64", + "timestamp": 1559573536683, + "version": "2.22.0" + }, + "requests-2.22.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=2.7,<2.8.0a0", + "urllib3 >=1.21.1,<1.26,!=1.25.0,!=1.25.1" + ], + "license": "Apache 2.0", + "md5": "873706fc3945d091c50f2a8aa9a5a981", + "name": "requests", + "sha256": "b414ea44f0e344e24fa6b14031298d516074d5cb2baea1170f6f5ce03f25cbe8", + "size": 93979, + "subdir": "linux-64", + "timestamp": 1575481880655, + "version": "2.22.0" + }, + "requests-2.22.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.25" + ], + "license": "Apache 2.0", + "md5": "7c34eb74f1521d5e6e4d9fd8ddd85821", + "name": "requests", + "sha256": "7b69c17eae5f23eee38339b47dd24a4bcc9cf6dfc9d45bd392b71657d842c460", + "size": 93676, + "subdir": "linux-64", + "timestamp": 1559573573080, + "version": "2.22.0" + }, + "requests-2.22.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.26,!=1.25.0,!=1.25.1" + ], + "license": "Apache 2.0", + "md5": "82e5046f32909220d780e7d2652dc0c9", + "name": "requests", + "sha256": "29603210c5496989487e66f248bef71a61c167916d2dc2b79f0418a860bb1ff3", + "size": 93836, + "subdir": "linux-64", + "timestamp": 1575481888101, + "version": "2.22.0" + }, + "requests-2.22.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.21.1,<1.25" + ], + "license": "Apache 2.0", + "md5": "addd9198dae5b6cea102006257eb8d67", + "name": "requests", + "sha256": "e38e92ad0d92ffd2a201664486dc855cace0deddbafaaa61e7c6400518bf885f", + "size": 92334, + "subdir": "linux-64", + "timestamp": 1559573536076, + "version": "2.22.0" + }, + "requests-2.22.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.21.1,<1.26,!=1.25.0,!=1.25.1" + ], + "license": "Apache 2.0", + "md5": "6f7321d89be6ceb43a2a3d8964b4c2e4", + "name": "requests", + "sha256": "69f3c1eb15f919f330cc7453ad2f0901ea68c78831edfa80124e04ec23e9dcf9", + "size": 93742, + "subdir": "linux-64", + "timestamp": 1575481897731, + "version": "2.22.0" + }, + "requests-2.22.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=3.8,<3.9.0a0", + "urllib3 >=1.21.1,<1.25" + ], + "license": "Apache 2.0", + "md5": "d31606d1e6541dcd3dc36355a070f506", + "name": "requests", + "sha256": "862774ca6c02214eba698ec7ab36e280a9069000b60851beefc8d064d1f8f25f", + "size": 89250, + "subdir": "linux-64", + "timestamp": 1574235876389, + "version": "2.22.0" + }, + "requests-2.22.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<3.1.0", + "idna >=2.5,<2.9", + "python >=3.8,<3.9.0a0", + "urllib3 >=1.21.1,<1.26,!=1.25.0,!=1.25.1" + ], + "license": "Apache 2.0", + "md5": "2df53e5c61e54b9cb1c61efcb9933c4f", + "name": "requests", + "sha256": "91ea54ad08c719b0a3234260f121f7bfc8409429b474e957c99f24243fb704bf", + "size": 94087, + "subdir": "linux-64", + "timestamp": 1575481895953, + "version": "2.22.0" + }, + "requests-2.23.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<4", + "idna >=2.5,<3", + "python >=3.6,<3.7.0a0", + "urllib3 >=1.21.1,<1.26,!=1.25.0,!=1.25.1" + ], + "license": "Apache-2.0", + "md5": "0bd6745b134ef3d06e04f7e3989f96fb", + "name": "requests", + "sha256": "ff1ed6d5f48bd3b9684cd2c7336795a4f3cfea523d55b63e7f6fe418c62e7ee9", + "size": 93322, + "subdir": "linux-64", + "timestamp": 1584021700667, + "version": "2.23.0" + }, + "requests-2.23.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<4", + "idna >=2.5,<3", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.21.1,<1.26,!=1.25.0,!=1.25.1" + ], + "license": "Apache-2.0", + "md5": "93b8b0d21100ff646066331f59ba346b", + "name": "requests", + "sha256": "89dc1c3fd1e4495a5a9d6ec75b357df99e6dff75a0724fec89b1154f551ca948", + "size": 94544, + "subdir": "linux-64", + "timestamp": 1584021638562, + "version": "2.23.0" + }, + "requests-2.23.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "chardet >=3.0.2,<4", + "idna >=2.5,<3", + "python >=3.8,<3.9.0a0", + "urllib3 >=1.21.1,<1.26,!=1.25.0,!=1.25.1" + ], + "license": "Apache-2.0", + "md5": "e9d2bb2832a5aa7e93edba4a53f5b094", + "name": "requests", + "sha256": "2594cbd4b8f5b843c694093791dfcdb9f19d2052d38c654424c531af08a41b77", + "size": 94967, + "subdir": "linux-64", + "timestamp": 1584021688433, + "version": "2.23.0" + }, + "requests-2.28.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2.0.0,<2.1.0", + "idna >=2.5,<4", + "python >=3.10,<3.11.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e2759f03c6cd7119f24923ef6bcfddd5", + "name": "requests", + "sha256": "51688b856648e64a2768cd107a7a539edbcdffd19a036723bf05dccb77dda799", + "size": 96116, + "subdir": "linux-64", + "timestamp": 1656438196490, + "version": "2.28.0" + }, + "requests-2.28.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2.0.0,<2.1.0", + "idna >=2.5,<4", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "255dd61283d4bdf96843aad9f45c1cbd", + "name": "requests", + "sha256": "e708284be1b0cbd7a6b146ef6a1c071363a932e5cf547e93134e706526cdd3df", + "size": 94776, + "subdir": "linux-64", + "timestamp": 1656438308386, + "version": "2.28.0" + }, + "requests-2.28.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2.0.0,<2.1.0", + "idna >=2.5,<4", + "python >=3.8,<3.9.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f74586ba486c96064b82fe6c5847f721", + "name": "requests", + "sha256": "64d7faaa79d67c588200a4bdbe04ce69df91cc38ad631dbc928f3b2476eb20ba", + "size": 95082, + "subdir": "linux-64", + "timestamp": 1656438270721, + "version": "2.28.0" + }, + "requests-2.28.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2.0.0,<2.1.0", + "idna >=2.5,<4", + "python >=3.9,<3.10.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c1a5d5735cff5876119f80ab6f193bd1", + "name": "requests", + "sha256": "7660020c9eea2adb24709f7d5c6d96175f334b0660b5356db05d01634b41ce39", + "size": 95095, + "subdir": "linux-64", + "timestamp": 1656438234302, + "version": "2.28.0" + }, + "requests-2.28.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2.0.0,<3", + "idna >=2.5,<4", + "python >=3.10,<3.11.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "40bbc3476dde7f941c78c2b10fd73166", + "name": "requests", + "sha256": "ca4c09b84a1b9cd2f26fac79d1a8911c6d793a7dbcb6721848a9aaf934c9ff62", + "size": 95199, + "subdir": "linux-64", + "timestamp": 1657734711809, + "version": "2.28.1" + }, + "requests-2.28.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "constrains": [ + "chardet >=3.0.2,<6" + ], + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2,<3", + "idna >=2.5,<4", + "python >=3.10,<3.11.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "65a9f765635f12679cbfff91d8ebed8e", + "name": "requests", + "sha256": "0210563010b7758038f4643f1a9613ed7111039ddbee2960a5f4eb89aa52aa09", + "size": 102500, + "subdir": "linux-64", + "timestamp": 1678709752617, + "version": "2.28.1" + }, + "requests-2.28.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2.0.0,<3", + "idna >=2.5,<4", + "python >=3.11,<3.12.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cb7be2752ad61f1049f3eff471218ed5", + "name": "requests", + "sha256": "792a61eab47b2617a4ed810b8c317ecdf6dc1756612bcb75e5eab54cd667a8b3", + "size": 120408, + "subdir": "linux-64", + "timestamp": 1676822846829, + "version": "2.28.1" + }, + "requests-2.28.1-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "constrains": [ + "chardet >=3.0.2,<6" + ], + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2,<3", + "idna >=2.5,<4", + "python >=3.11,<3.12.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "deca44a599adac76faf50691fd19ec5d", + "name": "requests", + "sha256": "ff97300a1dc802500c0da6e34e43cf0768e47fab6c4227c5e3e613285c3ab82f", + "size": 120381, + "subdir": "linux-64", + "timestamp": 1679337635736, + "version": "2.28.1" + }, + "requests-2.28.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2.0.0,<3", + "idna >=2.5,<4", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2e136441b737ae15e1a38c54ec85afdf", + "name": "requests", + "sha256": "546f5a6a74f676de5f51d280b749a6bc1251f60c464eef80a59b90296aef34f6", + "size": 93890, + "subdir": "linux-64", + "timestamp": 1657734749243, + "version": "2.28.1" + }, + "requests-2.28.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2.0.0,<3", + "idna >=2.5,<4", + "python >=3.8,<3.9.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "04d482ea4a1e190d688dee2e4048e49f", + "name": "requests", + "sha256": "e62d27bb85271804c813ea2d43f23ab1b3e60645b4a8507cf1ba7fddf65c2e5d", + "size": 94224, + "subdir": "linux-64", + "timestamp": 1657734786612, + "version": "2.28.1" + }, + "requests-2.28.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "chardet >=3.0.2,<6" + ], + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2,<3", + "idna >=2.5,<4", + "python >=3.8,<3.9.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "657ef918b2c2ee58064feb167e451dc6", + "name": "requests", + "sha256": "48304f91e51850bbec32be78f846dc695042194c9277089639d16989a9ce2b47", + "size": 101543, + "subdir": "linux-64", + "timestamp": 1678709785469, + "version": "2.28.1" + }, + "requests-2.28.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2.0.0,<3", + "idna >=2.5,<4", + "python >=3.9,<3.10.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5ae2a5b6b791e0a8f5b0129b59e5e793", + "name": "requests", + "sha256": "c46ceac00accafe9838c9b61f966d6145fe923eb3f14f050b3ec000c51a62906", + "size": 94213, + "subdir": "linux-64", + "timestamp": 1657734663449, + "version": "2.28.1" + }, + "requests-2.28.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "chardet >=3.0.2,<6" + ], + "depends": [ + "certifi >=2017.4.17", + "charset-normalizer >=2,<3", + "idna >=2.5,<4", + "python >=3.9,<3.10.0a0", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "90e023425c3be3a4b905278703984fbc", + "name": "requests", + "sha256": "a433fdcdd7ba08319ceabf404860a322b3299b46c4eabc86a6366443b121ab00", + "size": 101423, + "subdir": "linux-64", + "timestamp": 1678709817498, + "version": "2.28.1" + }, + "requests-file-1.4.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=1.0.0", + "six" + ], + "license": "Apache", + "md5": "d1efbd4d35b04442336328c7716d2dba", + "name": "requests-file", + "sha256": "5d5e5cb7b3201129744f2b645e66ffe48cc3347eb19e23aae7819812ccf15cf4", + "size": 8243, + "subdir": "linux-64", + "timestamp": 1524232664942, + "version": "1.4.3" + }, + "requests-file-1.4.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=1.0.0", + "six" + ], + "license": "Apache", + "md5": "9a2fbaa378461a1a4477f9ede008581b", + "name": "requests-file", + "sha256": "ea530f5306738f2219628eeb9d0dc005b6fd8a69801a06a29f4ea98cbdd5cc29", + "size": 8348, + "subdir": "linux-64", + "timestamp": 1524232174328, + "version": "1.4.3" + }, + "requests-file-1.4.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=1.0.0", + "six" + ], + "license": "Apache", + "md5": "43c93e87d542d87c04e226ca9ebb3450", + "name": "requests-file", + "sha256": "b68be72b8a39877925790d933f4478650e36d78ff84e31cf0e56204bf7222d32", + "size": 8239, + "subdir": "linux-64", + "timestamp": 1524232800769, + "version": "1.4.3" + }, + "requests-file-1.4.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=1.0.0", + "six" + ], + "license": "Apache", + "md5": "fdc398420f90a4934cdb744b85d2b678", + "name": "requests-file", + "sha256": "7a4126e9b913f5a25fe8b5deab441bdecd243e4c265e364665bf9d1f6c93e671", + "size": 8118, + "subdir": "linux-64", + "timestamp": 1530903210978, + "version": "1.4.3" + }, + "requests-ftp-0.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.3.0", + "wsgiref" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "b86489aa87d8ed6e4f119845eb634103", + "name": "requests-ftp", + "sha256": "2ac92d5f88ed22e9193f233f5abb9e67f41743818cce8d054692a750089a2037", + "size": 14607, + "subdir": "linux-64", + "timestamp": 1530904659486, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "c2856578485d60ab0992d8193ec14f21", + "name": "requests-ftp", + "sha256": "8b4349408b9aa70b0c6538ce970c566a9019340f4b99f6d3a116a8755b9093ef", + "size": 14770, + "subdir": "linux-64", + "timestamp": 1539188983907, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "c382b9e3d92f94fa56390ccbf56902e8", + "name": "requests-ftp", + "sha256": "243dfe279e5298c6ec03f3f8e96601a03fe9cc3b2a67c8a94267f57f8bec4b2b", + "size": 14802, + "subdir": "linux-64", + "timestamp": 1640794369740, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "d4e47dcdd0b2955b78c71a2f2dea9417", + "name": "requests-ftp", + "sha256": "025a66091567f38c417ec75b91357dac5b6a1ed370fd13c42be8ae338a412478", + "size": 17539, + "subdir": "linux-64", + "timestamp": 1676861853795, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "17eb267f84952534f550b42beaead6fa", + "name": "requests-ftp", + "sha256": "78e54e94b979a29190db82ce49449df044cd7d628f209efbde087700fa710770", + "size": 14628, + "subdir": "linux-64", + "timestamp": 1530903266153, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "23d861070fe44a8e64725a5f7e0b3e99", + "name": "requests-ftp", + "sha256": "7b8ead2c52339a36cca1023bfed3c7cc3074f5c4b450c9e96e217f9e9f626a3e", + "size": 14890, + "subdir": "linux-64", + "timestamp": 1539189030636, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "9d051322fed2433bec6e26d4f00f252a", + "name": "requests-ftp", + "sha256": "da1444289783ecd765a4e209e8a6ef326a16ebc97ebeae08715627c7832ba9f3", + "size": 15689, + "subdir": "linux-64", + "timestamp": 1613470645527, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "a81e3350037b04af1e183bd3dd015ff0", + "name": "requests-ftp", + "sha256": "ab8b6e992eee77008fe5309f1156912152fe9584260b92db8f600012c4c5b53c", + "size": 14721, + "subdir": "linux-64", + "timestamp": 1530903237367, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "faf4d8e7b5e60df508610819a588bcd4", + "name": "requests-ftp", + "sha256": "12ea3ad1db2dfb222e35ea163ff42ed79a2f44cc3e1e0c2df606d22679634796", + "size": 14899, + "subdir": "linux-64", + "timestamp": 1539189018758, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "ca2a200c6abd4b3ea8ba9574cc07a33e", + "name": "requests-ftp", + "sha256": "7c4283346e48b9a4259bc2521518033e3e46f75c7fc51d6e6cc985492ebf77b8", + "size": 15700, + "subdir": "linux-64", + "timestamp": 1613470017963, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "02d53a01b3537005b93af136b071a442", + "name": "requests-ftp", + "sha256": "01a6bd453d098ee4f91e30411f77ea1c81c3d9629cbe69bdad30bdd098f0a42f", + "size": 15667, + "subdir": "linux-64", + "timestamp": 1613470635453, + "version": "0.3.1" + }, + "requests-ftp-0.3.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.3.0" + ], + "license": "Apache-2", + "license_family": "Apache", + "md5": "8c2a5e8ce5a2857df873f6700288eba4", + "name": "requests-ftp", + "sha256": "68ea4e8cb8cbe75a098074b3e746977fef12c722a89b266a9c68d0ff884fd816", + "size": 15687, + "subdir": "linux-64", + "timestamp": 1613470636061, + "version": "0.3.1" + }, + "requests-futures-1.0.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "1d0a8df3e782e072032b4bfed49126c6", + "name": "requests-futures", + "sha256": "6ae8395394ee7748228531a90ad2dc02bbfdffcf2ac53fdf44fda40bc04cb9aa", + "size": 12417, + "subdir": "linux-64", + "timestamp": 1642519750190, + "version": "1.0.0" + }, + "requests-futures-1.0.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "6f8f2ea9b40ebffdd3f808b774d92033", + "name": "requests-futures", + "sha256": "456727f7839001a3f39cbe4e2447918f827e3e73e824f862dcc8fdedf20ffc5c", + "size": 13954, + "subdir": "linux-64", + "timestamp": 1676845677203, + "version": "1.0.0" + }, + "requests-futures-1.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "96d483f1d4944a9d9feedb570ec7340a", + "name": "requests-futures", + "sha256": "acb3bc58de4a3741bac3aed0be8dea56fb91fd3020cec0ba9c105801fdd51ef5", + "size": 14377, + "subdir": "linux-64", + "timestamp": 1582139047619, + "version": "1.0.0" + }, + "requests-futures-1.0.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "0857786200a519ae9719f4e75b45b120", + "name": "requests-futures", + "sha256": "126618c66cb1fb8562ba28bc8a07a6400c499384d7a42a6af63eedc2a3cf9527", + "size": 14596, + "subdir": "linux-64", + "timestamp": 1632756981716, + "version": "1.0.0" + }, + "requests-futures-1.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "ec7be9681bb9b93286a00e6549414ee7", + "name": "requests-futures", + "sha256": "f2ba43847f997fe26daca6d9b74ce06aeb44e2ebf4c330f195a73ba629640d4d", + "size": 14395, + "subdir": "linux-64", + "timestamp": 1582139037997, + "version": "1.0.0" + }, + "requests-futures-1.0.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "bc4cb8e937f5ac1462583461a0bb309e", + "name": "requests-futures", + "sha256": "e8b099fb2e2278dc16e5fa0fd0c18f89a5f16f96a75735bc343565dfbbc4fd51", + "size": 11591, + "subdir": "linux-64", + "timestamp": 1594401712301, + "version": "1.0.0" + }, + "requests-futures-1.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "172c66b9541e8df03f617d72ca9ef2b6", + "name": "requests-futures", + "sha256": "b540b03dc9cbf6183bb6e03e849efc0db0eb74f46d736e674532e4f86548d0d4", + "size": 14496, + "subdir": "linux-64", + "timestamp": 1632756972536, + "version": "1.0.0" + }, + "requests-futures-1.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "a4a56d46e74c5dc9d38bbc066f1e8020", + "name": "requests-futures", + "sha256": "79c369ec3fb6b1c9250d0b4c98a7b90416549ec0a9015e22178d176d9f4de623", + "size": 14437, + "subdir": "linux-64", + "timestamp": 1582139120118, + "version": "1.0.0" + }, + "requests-futures-1.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "701957e036398951bda4406029d9a0b7", + "name": "requests-futures", + "sha256": "7553b8e5b46f3c863059dc88be50d9afe98f61222e95d04a6274ee9607b148b8", + "size": 14532, + "subdir": "linux-64", + "timestamp": 1632756923358, + "version": "1.0.0" + }, + "requests-futures-1.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=1.2.0" + ], + "license": "Apache 2.0", + "md5": "223793cc56440927e56dffcde663a0b4", + "name": "requests-futures", + "sha256": "b2b82af4e393acb3f98caa4bd20797c76a9c654c030e6ea373f0102db8cc91e2", + "size": 14642, + "subdir": "linux-64", + "timestamp": 1632746602114, + "version": "1.0.0" + }, + "requests-kerberos-0.11.0-py27hd0065c0_1.conda": { + "build": "py27hd0065c0_1", + "build_number": 1, + "depends": [ + "pykerberos >=1.1.8,<2.0.0", + "python >=2.7,<2.8.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "9957ad33889325b3a68219ab88f174ed", + "name": "requests-kerberos", + "sha256": "e991dcb7b45cb7afa2a4192f401d9da6dfba6f3b9561c0272f036e1adc7a0da0", + "size": 15371, + "subdir": "linux-64", + "timestamp": 1505851542021, + "version": "0.11.0" + }, + "requests-kerberos-0.11.0-py35hf52cdc7_1.conda": { + "build": "py35hf52cdc7_1", + "build_number": 1, + "depends": [ + "pykerberos >=1.1.8,<2.0.0", + "python >=3.5,<3.6.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "859fcdf8d4c98608272cb70309fbdbfb", + "name": "requests-kerberos", + "sha256": "70252f9396c9a1eadd194419ea6847372e20d105d16c061b3375bdf18a470cd2", + "size": 15669, + "subdir": "linux-64", + "timestamp": 1505851554146, + "version": "0.11.0" + }, + "requests-kerberos-0.11.0-py36h333c0e5_1.conda": { + "build": "py36h333c0e5_1", + "build_number": 1, + "depends": [ + "pykerberos >=1.1.8,<2.0.0", + "python >=3.6,<3.7.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "531cdd536f27f651757567f5c483c76b", + "name": "requests-kerberos", + "sha256": "4aa0ca0a8e30f2d24d30812353a82ab2b18ccd27565334863b80fa85e0cd3dc5", + "size": 15430, + "subdir": "linux-64", + "timestamp": 1505851566335, + "version": "0.11.0" + }, + "requests-kerberos-0.12.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=2.7,<2.8.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "fe953ea4591051c6a7e2a982987b4c90", + "name": "requests-kerberos", + "sha256": "95064670be89fef7c118486e15ccfea01afa34b1c3b90f69c134784564740096", + "size": 18544, + "subdir": "linux-64", + "timestamp": 1519482809012, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py310h06a4308_3.conda": { + "build": "py310h06a4308_3", + "build_number": 3, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.10,<3.11.0a0", + "requests >=1.1.0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "ad5d221d5e1f1725cc57c28f4969b494", + "name": "requests-kerberos", + "sha256": "50ea7f9036f7dca6275dd700141cb9fcf16eda51528f46e90c013c8ddff09e60", + "size": 19997, + "subdir": "linux-64", + "timestamp": 1642519767844, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py311h06a4308_3.conda": { + "build": "py311h06a4308_3", + "build_number": 3, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.11,<3.12.0a0", + "requests >=1.1.0" + ], + "license": "ISC", + "license_family": "MIT", + "md5": "ff64cc3d43243b73698366e234a287d9", + "name": "requests-kerberos", + "sha256": "f9a17f836487f343c062dd11c909bd54c7c5c650df4c832de906530054fdf41a", + "size": 23745, + "subdir": "linux-64", + "timestamp": 1676842430193, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.5,<3.6.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "0016c6f1f6534573e458d0d778207ecb", + "name": "requests-kerberos", + "sha256": "bd6c58d75b5a449c094753c608b05810e1d96e878fc6f6fe18e20a85d7146684", + "size": 18872, + "subdir": "linux-64", + "timestamp": 1519482817427, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.6,<3.7.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "dd7b64c844798b6d277ab04fcd9298c6", + "name": "requests-kerberos", + "sha256": "79b0ab649bcb83a3aca10d0eb31a24dc857cde0df98eca20399591845ee6e052", + "size": 18789, + "subdir": "linux-64", + "timestamp": 1519482778492, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.6,<3.7.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "65f28dea83d6fdcf0852e54e3bf137ea", + "name": "requests-kerberos", + "sha256": "b628d5b504cc1fe8367ce2c61bcb93b12b61082e4897544311a2fa226d09a3bb", + "size": 258450, + "subdir": "linux-64", + "timestamp": 1613393670364, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.7,<3.8.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "68967b4d03bd881c39c8bd2b30fb1ecb", + "name": "requests-kerberos", + "sha256": "f9300619bc2dee9f2de40de7c37eadfbd6e3c0214919f3620c0bdce6813a2722", + "size": 18466, + "subdir": "linux-64", + "timestamp": 1530922653289, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.7,<3.8.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "81aa758cea509bb93add1a3660dc3ec6", + "name": "requests-kerberos", + "sha256": "b7f9e4d32a623ffbe4c3a30c3ed909d0362321eb7b398a43c93e030647454200", + "size": 260400, + "subdir": "linux-64", + "timestamp": 1613393556462, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.8,<3.9.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "dae988e59cb9a40137efb42a7fecc906", + "name": "requests-kerberos", + "sha256": "55c0bc9baff029373d159f53f7dca91150c59f39ed739f20fe21b70ce37375e1", + "size": 212362, + "subdir": "linux-64", + "timestamp": 1594937565615, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.8,<3.9.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "f5bd87b1e09721fa118aeff7f41b962f", + "name": "requests-kerberos", + "sha256": "341769cff84595abb1e179661c2b28f2c30b3dbee9f6e4dee1d26bd89481f24b", + "size": 257551, + "subdir": "linux-64", + "timestamp": 1613393664975, + "version": "0.12.0" + }, + "requests-kerberos-0.12.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=1.3", + "pykerberos >=1.1.8,<2.0.0", + "python >=3.9,<3.10.0a0", + "requests >=1.1.0" + ], + "license": "Other", + "md5": "0b9b1bb5af7a652f0bd6e3c20b942ab2", + "name": "requests-kerberos", + "sha256": "2ea6914e33892685fdd3faa01f83dbf59b4bcfbd9dc6f317d1d04bdc094145ee", + "size": 260131, + "subdir": "linux-64", + "timestamp": 1613393668408, + "version": "0.12.0" + }, + "requests-oauthlib-0.8.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "oauthlib >=0.6.2", + "python >=2.7,<2.8.0a0", + "requests >=2.0.0" + ], + "license": "ISC", + "md5": "4d2d73386b50e0950a2ed1add0e098ab", + "name": "requests-oauthlib", + "sha256": "de4d0038bb0c6ccd023e2e64436ccb25cd3ad74c457454a908aad2210e1d745f", + "size": 28706, + "subdir": "linux-64", + "timestamp": 1525813672924, + "version": "0.8.0" + }, + "requests-oauthlib-0.8.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "oauthlib >=0.6.2", + "python >=3.5,<3.6.0a0", + "requests >=2.0.0" + ], + "license": "ISC", + "md5": "05136af2af8325b7dc0cf776ac6b01ed", + "name": "requests-oauthlib", + "sha256": "92c3eb4697128fc3150718f3695de0abf4a439561f215e45e1804e0a2946fb92", + "size": 29017, + "subdir": "linux-64", + "timestamp": 1525813844004, + "version": "0.8.0" + }, + "requests-oauthlib-0.8.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "oauthlib >=0.6.2", + "python >=3.6,<3.7.0a0", + "requests >=2.0.0" + ], + "license": "ISC", + "md5": "a6c4cc29e55b0b2c6514c179ec6d6811", + "name": "requests-oauthlib", + "sha256": "7def2435788141d59fac406ce87c214eb517c655894ee6316cfe84ef53c7cdf1", + "size": 28737, + "subdir": "linux-64", + "timestamp": 1525813820387, + "version": "0.8.0" + }, + "requests-oauthlib-1.0.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "oauthlib >=0.6.2", + "python >=2.7,<2.8.0a0", + "requests >=2.0.0" + ], + "license": "ISC", + "md5": "61772324a6c2246910938bc86c58734a", + "name": "requests-oauthlib", + "sha256": "9f43daaa9d9d46ec99df91f2c43db7ce33056ebcd2ed82fe542a917e6cac4768", + "size": 29221, + "subdir": "linux-64", + "timestamp": 1529438939624, + "version": "1.0.0" + }, + "requests-oauthlib-1.0.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "oauthlib >=0.6.2", + "python >=3.5,<3.6.0a0", + "requests >=2.0.0" + ], + "license": "ISC", + "md5": "aa95c357f97288361054c7f43cf80548", + "name": "requests-oauthlib", + "sha256": "a4ac81454ea6a228af769810fc68b4d61b83043b1538b540418c6678696c4fef", + "size": 29567, + "subdir": "linux-64", + "timestamp": 1529438940530, + "version": "1.0.0" + }, + "requests-oauthlib-1.0.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "oauthlib >=0.6.2", + "python >=3.6,<3.7.0a0", + "requests >=2.0.0" + ], + "license": "ISC", + "md5": "e9fe1f7a939629c19f3d676b3114fd39", + "name": "requests-oauthlib", + "sha256": "0a4b0b336d6600eb7485c4a2abe34cb95b2e6cd0ed5ae4f8a3356653f96c61dd", + "size": 29302, + "subdir": "linux-64", + "timestamp": 1529439148555, + "version": "1.0.0" + }, + "requests-oauthlib-1.0.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "oauthlib >=0.6.2", + "python >=3.7,<3.8.0a0", + "requests >=2.0.0" + ], + "license": "ISC", + "md5": "575d7bee95b04567442185002eb04b29", + "name": "requests-oauthlib", + "sha256": "90790a1a9b4e7daad9d1f0a5190be7974bcbbd61fc208aa89d2fd21733693202", + "size": 29413, + "subdir": "linux-64", + "timestamp": 1545089337022, + "version": "1.0.0" + }, + "requests-toolbelt-0.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.0.1,<3.0.0" + ], + "license": "Apache-2.0", + "md5": "21f2c142f3ca9312d94b62bbf90fe1d4", + "name": "requests-toolbelt", + "sha256": "830945ef47b9755168dd140a9f9a8f1af16655e8810a65a119fe16d33d2b4a9d", + "size": 62809, + "subdir": "linux-64", + "timestamp": 1522177800202, + "version": "0.8.0" + }, + "requests-toolbelt-0.8.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.0.1,<3.0.0" + ], + "license": "Apache-2.0", + "md5": "59bed06d5193f7c13680f984cb98dfdb", + "name": "requests-toolbelt", + "sha256": "94f5ce164d2c570a3af16d13411342485089bba98a19c7c3f7c68255200ce8f0", + "size": 65232, + "subdir": "linux-64", + "timestamp": 1522178108833, + "version": "0.8.0" + }, + "requests-toolbelt-0.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.0.1,<3.0.0" + ], + "license": "Apache-2.0", + "md5": "fc5c38e663e003adffac267466a709c1", + "name": "requests-toolbelt", + "sha256": "df6852a6831326ab64a5d057ef942c9a787e7ff6e1685d6eee70aaa06e2c421c", + "size": 64752, + "subdir": "linux-64", + "timestamp": 1522177537700, + "version": "0.8.0" + }, + "requests-toolbelt-0.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.0.1,<3.0.0" + ], + "license": "Apache-2.0", + "md5": "91862f4378382c0d66b95870f199f2e7", + "name": "requests-toolbelt", + "sha256": "0a842abbb75a26d428a60390b3fbf099d80f38dca7e8f2138cf08521c8dc3c71", + "size": 64632, + "subdir": "linux-64", + "timestamp": 1530959315562, + "version": "0.8.0" + }, + "requests-wsgi-adapter-0.4.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "requests >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "839f7b20aad7c538a330d4610ef3e8b6", + "name": "requests-wsgi-adapter", + "sha256": "e215dc72f48c258db76e5c0c114f8583e9a14ff8e9e15e4223d37f38b28a955d", + "size": 12876, + "subdir": "linux-64", + "timestamp": 1669051478499, + "version": "0.4.1" + }, + "requests-wsgi-adapter-0.4.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "requests >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ddd64abdf4181fe24f414721b2d6a07", + "name": "requests-wsgi-adapter", + "sha256": "c902ca249d2db2e862d6d16de6a3a0d5a9c498cedf1386b6b3297416e8cda245", + "size": 14360, + "subdir": "linux-64", + "timestamp": 1676861868700, + "version": "0.4.1" + }, + "requests-wsgi-adapter-0.4.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "177a04335b632c550c8673a1eff84693", + "name": "requests-wsgi-adapter", + "sha256": "ea679edebdf50b750e93bbfb3f336a2b5b3f8ed4df7034b48a193e8ac4e9f6e7", + "size": 12672, + "subdir": "linux-64", + "timestamp": 1669051504796, + "version": "0.4.1" + }, + "requests-wsgi-adapter-0.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "93fe1176f455522983006a7c0aecd47f", + "name": "requests-wsgi-adapter", + "sha256": "dac3f7fcbdc73c3e2c6ccc0006666cfd45209059a9f42f0cac9c1a6feaa31d03", + "size": 12703, + "subdir": "linux-64", + "timestamp": 1669051426276, + "version": "0.4.1" + }, + "requests-wsgi-adapter-0.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f79634dfe8322ee3e6612204752c28ac", + "name": "requests-wsgi-adapter", + "sha256": "5c6696aa612dfd3ff6dc87ba2e75c3245755fc19bef90e53b3c5a1c6a353a51a", + "size": 12693, + "subdir": "linux-64", + "timestamp": 1669051452519, + "version": "0.4.1" + }, + "requests_download-0.1.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "requests" + ], + "license": "MIT", + "md5": "15fd451860c1ac7fe53bd40538bcf9e0", + "name": "requests_download", + "sha256": "ed6240978890d19fd603d37f2b5d1da9696f78fb83b171af3e871a024a389b76", + "size": 8511, + "subdir": "linux-64", + "timestamp": 1642519836455, + "version": "0.1.2" + }, + "requests_download-0.1.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "MIT", + "md5": "2ed41ba0b36aa6b55890d57563097674", + "name": "requests_download", + "sha256": "4271c5e3e42d36539d94001fdbc8a2f789a53defea215abeb021a27d11890533", + "size": 7942, + "subdir": "linux-64", + "timestamp": 1529945288293, + "version": "0.1.2" + }, + "requests_download-0.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "MIT", + "md5": "da9637486d1ab223f35affc79b4b261c", + "name": "requests_download", + "sha256": "45b428d844891b9de80a29cb057d28430c25fca9e6b444df475743fffed791ee", + "size": 7845, + "subdir": "linux-64", + "timestamp": 1529945142061, + "version": "0.1.2" + }, + "requests_download-0.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "MIT", + "md5": "a702cab16fec2627afbdda7e44d6a933", + "name": "requests_download", + "sha256": "7d9fb125fbad926141c1aa9b0bc694c09234068db60bad0d72a8c9eddd0d4184", + "size": 7881, + "subdir": "linux-64", + "timestamp": 1530898082505, + "version": "0.1.2" + }, + "requests_download-0.1.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "MIT", + "md5": "0a1b5f3ad1efee864478fa61c05ee1fc", + "name": "requests_download", + "sha256": "9eee65f9f806eb73569369c77e2b574f4a4c0a8a0a7bab44427e0b0a79d8be59", + "size": 8925, + "subdir": "linux-64", + "timestamp": 1636044918662, + "version": "0.1.2" + }, + "requests_download-0.1.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests" + ], + "license": "MIT", + "md5": "68da4d3c6c45c8056049daee58c25f91", + "name": "requests_download", + "sha256": "b9ba569c3f1b019bdbbbc480bc32cdff5eb4620140455fd12a6a9c490995d0a2", + "size": 8912, + "subdir": "linux-64", + "timestamp": 1636044844762, + "version": "0.1.2" + }, + "requests_download-0.1.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests" + ], + "license": "MIT", + "md5": "8877bc6e8ad9539a33ef9d597cdaed18", + "name": "requests_download", + "sha256": "a79372436e05043beba2e4a7fa72575bd5642c3fbab43bed9b5aff739e5fd931", + "size": 8917, + "subdir": "linux-64", + "timestamp": 1636044841201, + "version": "0.1.2" + }, + "resolvelib-0.8.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "38f7fd071df132e8e9e0c66252bbc1b5", + "name": "resolvelib", + "sha256": "4a82379410e4de1575656e7cb2f6648b3298d378a30b51e1eed47478b9eef415", + "size": 27078, + "subdir": "linux-64", + "timestamp": 1670273526705, + "version": "0.8.1" + }, + "resolvelib-0.8.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "6dea91965d1a26b4268a70e7111b0193", + "name": "resolvelib", + "sha256": "4a33ee4465f8b4086e5ad4896d51f3c27e2a7b8c2fadf2b910e13138d0275eee", + "size": 30938, + "subdir": "linux-64", + "timestamp": 1676842445250, + "version": "0.8.1" + }, + "resolvelib-0.8.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "01d3875cbced81e3750f74452e02bba2", + "name": "resolvelib", + "sha256": "4c345e9bf91c54d521715973c83e97a2e552f7d4c876e089e6ed385c9e530856", + "size": 26674, + "subdir": "linux-64", + "timestamp": 1670273501910, + "version": "0.8.1" + }, + "resolvelib-0.8.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "804a705bdece07764fcc91a4cd56ebfd", + "name": "resolvelib", + "sha256": "182e74aaf81ed390194f99bb43c9f2d2a0d8c03cfdef8f312ae51c21f4077ce4", + "size": 26795, + "subdir": "linux-64", + "timestamp": 1670273452045, + "version": "0.8.1" + }, + "resolvelib-0.8.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "bdc32db800ea580c84d2bec7400607b6", + "name": "resolvelib", + "sha256": "eec092419cfabc2cba2416c7da77c54d08aa2791067ffdf9b1aa0a4c289aed0c", + "size": 26759, + "subdir": "linux-64", + "timestamp": 1670273476820, + "version": "0.8.1" + }, + "responses-0.10.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cookies", + "mock", + "python >=2.7,<2.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "07361ed4535e63cbc9a85d1e67eb23bc", + "name": "responses", + "sha256": "2b0b6c979126f41b2331a495bce911aab1ece22f727bd8b6499042b4c8b06867", + "size": 32112, + "subdir": "linux-64", + "timestamp": 1542089601861, + "version": "0.10.3" + }, + "responses-0.10.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9c8666f3f0d16aa8232ab028dc09bd1b", + "name": "responses", + "sha256": "dff896657bfe9ce322134b4c2125d3595c416859c7a7179ed06e72346289c3c1", + "size": 32576, + "subdir": "linux-64", + "timestamp": 1542089611131, + "version": "0.10.3" + }, + "responses-0.10.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "45069fe8fda7627e2e8043e2c1e81ba4", + "name": "responses", + "sha256": "4fca5d8578c6c4287b1197171a16a54b1eb2ef483ed82cee197b3c57711414d0", + "size": 32631, + "subdir": "linux-64", + "timestamp": 1542089567396, + "version": "0.10.3" + }, + "responses-0.10.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cookies", + "mock", + "python >=2.7,<2.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "aa98517d6ee93ba56643f954c83ef75c", + "name": "responses", + "sha256": "a35e4d877933314018943b391da32cb74ad7845c51e9f0f15244d445c0663e5b", + "size": 32981, + "subdir": "linux-64", + "timestamp": 1542393510441, + "version": "0.10.4" + }, + "responses-0.10.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5ce1cb47e8ba6ea10d33f691a5e18acd", + "name": "responses", + "sha256": "b0db91ff25ca600e77534fb133880179321698c4dc13baf5ed74e80ff67e03c5", + "size": 33428, + "subdir": "linux-64", + "timestamp": 1542393540077, + "version": "0.10.4" + }, + "responses-0.10.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d0cb9f7ddcfba97a0bbd6154f704957f", + "name": "responses", + "sha256": "d9cc3e4d9b3fc42fa1653ee6951acff99995e572aa1baa9afbb6fa01a1a2591d", + "size": 33426, + "subdir": "linux-64", + "timestamp": 1542393494367, + "version": "0.10.4" + }, + "responses-0.10.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cookies", + "mock", + "python >=2.7,<2.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fe21f54f488d82eaef11be3799d28671", + "name": "responses", + "sha256": "7b29591a349c4b4496c83df1ccf63e1702503977795e854d58803736f023ff15", + "size": 177173, + "subdir": "linux-64", + "timestamp": 1547490137563, + "version": "0.10.5" + }, + "responses-0.10.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3e8ef7565bf1028527e6f7244ceb7fa4", + "name": "responses", + "sha256": "2fbb2cabe32b8d9a8cef22b6b09ef9a299a40e1c676ebc8124f55130df3cefc3", + "size": 177833, + "subdir": "linux-64", + "timestamp": 1547490151041, + "version": "0.10.5" + }, + "responses-0.10.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0de56a0576b0217ed90ebd48e358d132", + "name": "responses", + "sha256": "4f67924dccce9f5fa1d30845fcb309d6420108934f4682c1aad6ac5c6ae84583", + "size": 178519, + "subdir": "linux-64", + "timestamp": 1547490093522, + "version": "0.10.5" + }, + "responses-0.10.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cookies", + "mock", + "python >=2.7,<2.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0eec031c7103909110d81fa13f13ff19", + "name": "responses", + "sha256": "75dc6efb727b4daaeced449da8100a3e028398ad45a3f94f86a49b44661f616a", + "size": 185492, + "subdir": "linux-64", + "timestamp": 1564705554470, + "version": "0.10.6" + }, + "responses-0.10.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dc6b3a5daf687e7c4f584d772bfe648d", + "name": "responses", + "sha256": "609e0009e9ff2eb62ddc0066edd7ee4be4413cc4ea73f7f253ab7bdd840126c2", + "size": 185233, + "subdir": "linux-64", + "timestamp": 1564705518553, + "version": "0.10.6" + }, + "responses-0.10.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6c8e033ad44556028477107e153dc2a9", + "name": "responses", + "sha256": "2ce24347097951e05eddac4f6d1a875e4a58cd6151b993824bc3da6d120e83b2", + "size": 185075, + "subdir": "linux-64", + "timestamp": 1564705546992, + "version": "0.10.6" + }, + "responses-0.10.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cookies", + "mock", + "python >=2.7,<2.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0bc2af74655b4e0680799783e1b4d598", + "name": "responses", + "sha256": "96a5b22e5351699da1a65886a21961306ebb8d58116865afb05a6fce899cbfbe", + "size": 192704, + "subdir": "linux-64", + "timestamp": 1576248619047, + "version": "0.10.8" + }, + "responses-0.10.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f6d5e8cbef067230460a1acd5fbde5d6", + "name": "responses", + "sha256": "373246e3bfeb1528f001396c481fc241212d2192f61ec62aed56fda3d90399a5", + "size": 192567, + "subdir": "linux-64", + "timestamp": 1576248662209, + "version": "0.10.8" + }, + "responses-0.10.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8f1e7a1b6b12c6398c753892d8fc48a3", + "name": "responses", + "sha256": "3a8bffa39a3356d88e79cd9b2e7ad608d326e961652e02e99181322442cf9e3d", + "size": 194158, + "subdir": "linux-64", + "timestamp": 1576248651316, + "version": "0.10.8" + }, + "responses-0.10.8-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f219946df11845608627725a03b7cb20", + "name": "responses", + "sha256": "8255e502f1458210e1f7b9863eed4fa0d32cd0a3639813c3be4c8af4a70d9531", + "size": 193181, + "subdir": "linux-64", + "timestamp": 1576248668397, + "version": "0.10.8" + }, + "responses-0.8.1-py27h451b312_0.conda": { + "build": "py27h451b312_0", + "build_number": 0, + "depends": [ + "cookies", + "python >=2.7,<2.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1bc998b4dbdc92d40a892da2145de52a", + "name": "responses", + "sha256": "e6012e3c00648baae5426eb31ae8b3419b736b4ce477bce3e68f0198c8046aa9", + "size": 29598, + "subdir": "linux-64", + "timestamp": 1508217886814, + "version": "0.8.1" + }, + "responses-0.8.1-py35h08f2ab4_0.conda": { + "build": "py35h08f2ab4_0", + "build_number": 0, + "depends": [ + "cookies", + "python >=3.5,<3.6.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "40845a66430e0c51ec8967d49597aa54", + "name": "responses", + "sha256": "9e5cea8ca392d8de39654bc8106451db2e37155b1c56c959768559ddce1ee8b8", + "size": 30325, + "subdir": "linux-64", + "timestamp": 1508217772715, + "version": "0.8.1" + }, + "responses-0.8.1-py36hcf147cc_0.conda": { + "build": "py36hcf147cc_0", + "build_number": 0, + "depends": [ + "cookies", + "python >=3.6,<3.7.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2876dc5266b7f616c175e0d9bb5f88fb", + "name": "responses", + "sha256": "fbc2e7d695b6ff7c4603a2c78fef34625f95d2d68f8f2d019744db3d70d5354c", + "size": 30022, + "subdir": "linux-64", + "timestamp": 1508217932387, + "version": "0.8.1" + }, + "responses-0.9.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cookies", + "mock", + "python >=2.7,<2.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0882362d39d6b6c468a63198688fe804", + "name": "responses", + "sha256": "3b6c51968353815753037c1c9334d79b46d86fd5a2a362b4e8e58a320edf2c8f", + "size": 31427, + "subdir": "linux-64", + "timestamp": 1523945115641, + "version": "0.9.0" + }, + "responses-0.9.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cookies", + "python >=3.5,<3.6.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "aa4c59aaaffe2b5c1ccda853922d4b07", + "name": "responses", + "sha256": "d49b653a2d188d4022000d03dd76248ec97c52d9f0631016d6638574fe1da706", + "size": 32252, + "subdir": "linux-64", + "timestamp": 1523945144331, + "version": "0.9.0" + }, + "responses-0.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cookies", + "python >=3.6,<3.7.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "749e594f7cc0604abf19aba7a7c34b31", + "name": "responses", + "sha256": "f8523e8b93e8d71165a0200c293a713a0cb32f5940a3f52947a942d05fed6366", + "size": 31906, + "subdir": "linux-64", + "timestamp": 1523945144291, + "version": "0.9.0" + }, + "responses-0.9.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cookies", + "python >=3.7,<3.8.0a0", + "requests >=2.0", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a92239f010ad4ffe072e0c43153a9b04", + "name": "responses", + "sha256": "f22660080ffaf140f1fbc57187653113c1184a57499303e5f1af395c24d4c22f", + "size": 31327, + "subdir": "linux-64", + "timestamp": 1530812919601, + "version": "0.9.0" + }, + "retrying-1.3.3-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5a55f6f6275461b48678f9b068354e63", + "name": "retrying", + "sha256": "1ace90877b063e0f7eb4932ab762d79fd774d209109ab63b3806e4c1ac74642b", + "size": 16056, + "subdir": "linux-64", + "timestamp": 1532535254708, + "version": "1.3.3" + }, + "retrying-1.3.3-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0feb4b8c600fba86aeefea06bce185bd", + "name": "retrying", + "sha256": "14df543bcd35d4531db308c03f451a35e6860d979a4a1bd12a920e836e405981", + "size": 16294, + "subdir": "linux-64", + "timestamp": 1532535317114, + "version": "1.3.3" + }, + "retrying-1.3.3-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "83ed849cfb0632d9980b847574d94533", + "name": "retrying", + "sha256": "d96d25dd073f98c8e19a990bde0d35c8d2eede7042501920d24100f8456338bd", + "size": 16172, + "subdir": "linux-64", + "timestamp": 1532536448231, + "version": "1.3.3" + }, + "retrying-1.3.3-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "627629261fd7cd4571adae4cf46e2e02", + "name": "retrying", + "sha256": "1df17b004ea7aa80873e1904d8f766a0fafbea512d7237bb6dc67e0fa3ea8399", + "size": 16332, + "subdir": "linux-64", + "timestamp": 1532535323749, + "version": "1.3.3" + }, + "rhash-1.3.5-hbf7ad62_1.conda": { + "build": "hbf7ad62_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d035f10eb784ffb2a1b11e872a29a40", + "name": "rhash", + "sha256": "69bbbf53d1da9bae3417125ef5474b48b333cdc436b94e456bb1e87dd9683f41", + "size": 147644, + "subdir": "linux-64", + "timestamp": 1505687951686, + "version": "1.3.5" + }, + "rhash-1.3.6-h1ba5d50_0.conda": { + "build": "h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de3decdb26f1beb8c31403f68740dd22", + "name": "rhash", + "sha256": "7bf8dbf30495d446db3099aeff38e89ec2442adaf2ce829b23efc06d4a2abe64", + "size": 153429, + "subdir": "linux-64", + "timestamp": 1540225177390, + "version": "1.3.6" + }, + "rhash-1.3.6-hb7f436b_0.conda": { + "build": "hb7f436b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "35b0e6a387c107b7e9adc0421e0cd2dd", + "name": "rhash", + "sha256": "56a67bafc99fb69ee873238ebd76a0821f48f1bd03dd538e9f38c161090e8a02", + "size": 152596, + "subdir": "linux-64", + "timestamp": 1528058022109, + "version": "1.3.6" + }, + "rhash-1.3.7-h1ba5d50_0.conda": { + "build": "h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d7225c404851ef9e7a5cb340511101f4", + "name": "rhash", + "sha256": "2f3f3204ce5e02fbc19d639116830a25ee5b9fe8eafa1feadaa9008426b722eb", + "size": 173010, + "subdir": "linux-64", + "timestamp": 1547490558933, + "version": "1.3.7" + }, + "rhash-1.3.8-h1ba5d50_0.conda": { + "build": "h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1b,<1.1.2a" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d62d32763dd0d1ea8d4ec61eeb617117", + "name": "rhash", + "sha256": "d5dd96aa01ae1074fc9c32f53198d4dc299661798117e2e6201d1ca834c33798", + "size": 192525, + "subdir": "linux-64", + "timestamp": 1552511572321, + "version": "1.3.8" + }, + "rhash-1.4.0-h1ba5d50_0.conda": { + "build": "h1ba5d50_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cf7b567eadd2c5868abd252c263ff336", + "name": "rhash", + "sha256": "da64c3608524f2fb4c08a416cd328270dfcc218dc59513b55f7709177dc2ee2e", + "size": 197384, + "subdir": "linux-64", + "timestamp": 1600432316227, + "version": "1.4.0" + }, + "rhash-1.4.1-h3c74f83_0.conda": { + "build": "h3c74f83_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "479276793acc5b1d24bafec3d61a0bed", + "name": "rhash", + "sha256": "e73a5dedd9b4648dd85df1e9f24239473b5337242473edb3d201f9ca11b4addf", + "size": 201667, + "subdir": "linux-64", + "timestamp": 1610133444516, + "version": "1.4.1" + }, + "rhash-1.4.1-h3c74f83_1.conda": { + "build": "h3c74f83_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1i,<1.1.2a" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0832063e946440ef5b5d7963c562ade4", + "name": "rhash", + "sha256": "4084461195316024271426b99d098c7bf1ecb6a66b03d5809ba9c7fbcf41092a", + "size": 207902, + "subdir": "linux-64", + "timestamp": 1611089602014, + "version": "1.4.1" + }, + "rich-12.5.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "commonmark >=0.9.0,<0.10.0", + "dataclasses >=0.7,<0.9", + "pygments >=2.6.0,<3.0.0", + "python >=3.10,<3.11.0a0", + "typing_extensions >=4.0.0,<5.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f829835ccf3b0bfbb9e2feb80701ab6", + "name": "rich", + "sha256": "ff27beaa2d0d2736569f31e9f0e617c115e9d55e4626017b7ef53878510dc481", + "size": 405933, + "subdir": "linux-64", + "timestamp": 1659708387121, + "version": "12.5.1" + }, + "rich-12.5.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "commonmark >=0.9.0,<0.10.0", + "dataclasses >=0.7,<0.9", + "pygments >=2.6.0,<3.0.0", + "python >=3.11,<3.12.0a0", + "typing_extensions >=4.0.0,<5.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a1eeb02cf89b4c22327aea9cd9d118e6", + "name": "rich", + "sha256": "c118b809c06249ec98c4aec82c6eced61cd1dfc511d4327a6cd024d12ab1235a", + "size": 522164, + "subdir": "linux-64", + "timestamp": 1676904177084, + "version": "12.5.1" + }, + "rich-12.5.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "commonmark >=0.9.0,<0.10.0", + "dataclasses >=0.7,<0.9", + "pygments >=2.6.0,<3.0.0", + "python >=3.7,<3.8.0a0", + "typing_extensions >=4.0.0,<5.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "844cceaf0bad8b0b6d6edf35ead94ef4", + "name": "rich", + "sha256": "7a43e4506f43105a3c4eb609a2d9b8a9b05e83f92e45204011e1afb2c75cefc3", + "size": 373215, + "subdir": "linux-64", + "timestamp": 1659708348772, + "version": "12.5.1" + }, + "rich-12.5.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "commonmark >=0.9.0,<0.10.0", + "dataclasses >=0.7,<0.9", + "pygments >=2.6.0,<3.0.0", + "python >=3.8,<3.9.0a0", + "typing_extensions >=4.0.0,<5.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "779e27b82fc4bc334c219e943ae9a244", + "name": "rich", + "sha256": "0863b47fc1a86c62f2c166bd0e8b421e26fc768770eed54019d2269af38f8a28", + "size": 375713, + "subdir": "linux-64", + "timestamp": 1659708319523, + "version": "12.5.1" + }, + "rich-12.5.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "commonmark >=0.9.0,<0.10.0", + "dataclasses >=0.7,<0.9", + "pygments >=2.6.0,<3.0.0", + "python >=3.9,<3.10.0a0", + "typing_extensions >=4.0.0,<5.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9efb6a7fc0767f411062ec76f5ae973e", + "name": "rich", + "sha256": "bfb81521fa2d8e19ac1e79f057550a0145248b96438cf68002471eedd37b71b4", + "size": 376159, + "subdir": "linux-64", + "timestamp": 1659708415289, + "version": "12.5.1" + }, + "ripgrep-0.10.0-hc07d326_0.conda": { + "build": "hc07d326_0", + "build_number": 0, + "depends": [], + "md5": "f8e56f69880755adb82c97ab9ea02351", + "name": "ripgrep", + "sha256": "57ae67d5a7c8d1bef40da9069c27d28880909ee34c5fdc2e005225865136e05e", + "size": 1206893, + "subdir": "linux-64", + "timestamp": 1538175793905, + "version": "0.10.0" + }, + "ripgrep-11.0.2-h0ccce12_0.conda": { + "build": "h0ccce12_0", + "build_number": 0, + "depends": [], + "md5": "74170feb7c9bb1f76fee354bf654825f", + "name": "ripgrep", + "sha256": "99fa6b4f98f2110b2f83222af0a2f6010f1cc2d3512c8334db8c9d999f0e7240", + "size": 1373509, + "subdir": "linux-64", + "timestamp": 1578413933392, + "version": "11.0.2" + }, + "ripgrep-11.0.2-he32d670_0.conda": { + "build": "he32d670_0", + "build_number": 0, + "depends": [], + "md5": "fdb35c67fd289edd668932f7e279f4dc", + "name": "ripgrep", + "sha256": "c9983e691a07265ae52cdab9ec9e33552fa69be31686f75c3c6d8616dd91de0c", + "size": 1353347, + "subdir": "linux-64", + "timestamp": 1578438697374, + "version": "11.0.2" + }, + "ripgrep-12.1.1-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "md5": "fb7a5cc01742dcf093a43edae37b1ea1", + "name": "ripgrep", + "sha256": "361b26d5ab71bf29dfeede4f26cea164ff3125a67e1d31fbc741b4648ddb284e", + "size": 1418663, + "subdir": "linux-64", + "timestamp": 1601295780529, + "version": "12.1.1" + }, + "ripgrep-12.1.1-h007679d_0.conda": { + "build": "h007679d_0", + "build_number": 0, + "depends": [], + "md5": "538ff45deacf2e646ca4c8439f6ee046", + "name": "ripgrep", + "sha256": "e98e655ecda61a14ff8f66c95da46ee152ccc535945de37dbb7249b59f608770", + "size": 1413530, + "subdir": "linux-64", + "timestamp": 1601295718673, + "version": "12.1.1" + }, + "ripgrep-13.0.0-hbdeaff8_0.conda": { + "build": "hbdeaff8_0", + "build_number": 0, + "depends": [], + "license": "MIT AND Unlicense", + "license_family": "Other", + "md5": "84bcb22256029a3497ff713616d4fd2a", + "name": "ripgrep", + "sha256": "4a7e02d8728a00e51f4419ca4fe90f40b87b87407001623a0b978708f8153264", + "size": 1197369, + "subdir": "linux-64", + "timestamp": 1659635547888, + "version": "13.0.0" + }, + "rise-5.4.1-py27_1000.conda": { + "build": "py27_1000", + "build_number": 1000, + "depends": [ + "jupyter", + "notebook >=5.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e5aae72d842194758d231e5296138260", + "name": "rise", + "sha256": "26d20a83dc50141645c80b433cc5a247992c6649004f0f033775838a03f5b32b", + "size": 1544008, + "subdir": "linux-64", + "timestamp": 1546450877011, + "version": "5.4.1" + }, + "rise-5.4.1-py36_1000.conda": { + "build": "py36_1000", + "build_number": 1000, + "depends": [ + "jupyter", + "notebook >=5.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "89c007452b10971f92a6c63c39bf0801", + "name": "rise", + "sha256": "15ce35416cd168d4d26c345b461434bc77deee88c702023479eb75dfef7235b9", + "size": 1542854, + "subdir": "linux-64", + "timestamp": 1546450942712, + "version": "5.4.1" + }, + "rise-5.4.1-py37_1000.conda": { + "build": "py37_1000", + "build_number": 1000, + "depends": [ + "jupyter", + "notebook >=5.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "52bb52eac549adc188664c5040efa49f", + "name": "rise", + "sha256": "08eaf9e12610235e6feb024b495bdb4711de64834450a27159d7a74dccdc8a3a", + "size": 1542452, + "subdir": "linux-64", + "timestamp": 1546450877893, + "version": "5.4.1" + }, + "rise-5.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jupyter", + "notebook >=5.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3ccca27063aecb16eaa378a8976659cf", + "name": "rise", + "sha256": "8f6ba47147c93dd9703c13759546b6dd8ad04a16b85845ed7a77b644dd0d6968", + "size": 1551615, + "subdir": "linux-64", + "timestamp": 1569435742009, + "version": "5.5.1" + }, + "rise-5.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jupyter", + "notebook >=5.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c3df7b0d309033b672414bcc8c469258", + "name": "rise", + "sha256": "1070dbd3f46dde94c2d14b1d8233a1ee649e329e38f413751c43d888ab3d045a", + "size": 1551313, + "subdir": "linux-64", + "timestamp": 1569435748338, + "version": "5.5.1" + }, + "rise-5.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jupyter", + "notebook >=5.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b8e9834777391023cf6c47803b6e90e3", + "name": "rise", + "sha256": "8ca71d8a3195f9a94d95c5b25a09aabc98557aee82ec2cb282c37b3132e40f91", + "size": 1549945, + "subdir": "linux-64", + "timestamp": 1569435742207, + "version": "5.5.1" + }, + "rise-5.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cf8b3d1b70cf03dfe5c50f759d8cac6f", + "name": "rise", + "sha256": "720708b93d7ab00cd8b9ce6dd0855a300d525161c81fe97d9e1d0c62dddebc1f", + "size": 1659232, + "subdir": "linux-64", + "timestamp": 1573950239179, + "version": "5.6.0" + }, + "rise-5.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b48f4707a5f605ec17bc08c801bb6d5e", + "name": "rise", + "sha256": "0085e2be21653984e6ea982eff717f6417465e7876bacf5df63f7688ff89b2cf", + "size": 1661204, + "subdir": "linux-64", + "timestamp": 1573950266794, + "version": "5.6.0" + }, + "rise-5.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bdf5597775f18db2a2e670160153e9b4", + "name": "rise", + "sha256": "20d6723fa3351bdc4ee610d8f21ff9ab007bfcbf8a5b8a2180334664ce0ddcb2", + "size": 1659192, + "subdir": "linux-64", + "timestamp": 1573950213415, + "version": "5.6.0" + }, + "rise-5.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a612fa3162a64bfd2ec6fe55fc183424", + "name": "rise", + "sha256": "ef45b57d6bc53309429f40c4aa85d2fd3769aaac03cac5ee0eb3e1972ec84a62", + "size": 1659540, + "subdir": "linux-64", + "timestamp": 1582562268519, + "version": "5.6.1" + }, + "rise-5.6.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "59ea0eadf7ade6d1a54fd6338892b313", + "name": "rise", + "sha256": "349a18f6d6fa557209df158587f39bdf721500bee743ce1cbe9add76e5ea0556", + "size": 1660655, + "subdir": "linux-64", + "timestamp": 1582562223001, + "version": "5.6.1" + }, + "rise-5.6.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "notebook >=5.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "59a187f255ea8230e501409ed61900e6", + "name": "rise", + "sha256": "fdc8a1eef91857060efd1c08c4c08f0694bd2d7996fb1aedc1da8efe8fa96be7", + "size": 1657228, + "subdir": "linux-64", + "timestamp": 1594419379691, + "version": "5.6.1" + }, + "rise-5.6.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7de77d9f879bf49ee7cac4ff0af581c2", + "name": "rise", + "sha256": "77f78a04fcc0e1d1519f413540c9e66c718a59c1bc3a27af29bf34ecda7d9ac0", + "size": 1658562, + "subdir": "linux-64", + "timestamp": 1582562241970, + "version": "5.6.1" + }, + "rise-5.7.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2d72f7b24c7e9e4939028b2b7ba023c6", + "name": "rise", + "sha256": "36fd43219d1584ccf03bdc0dc7f6e530216bf88452c8daedab81c8eb40cd46d5", + "size": 1751372, + "subdir": "linux-64", + "timestamp": 1641919428246, + "version": "5.7.1" + }, + "rise-5.7.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "43507771c0ada5585a0a50a41ef8553a", + "name": "rise", + "sha256": "ddf8c3f35105a6b17c1ae1ecdefc66244b0c8d284a6ab8ba1d764b5a2cfac745", + "size": 1750276, + "subdir": "linux-64", + "timestamp": 1676922586317, + "version": "5.7.1" + }, + "rise-5.7.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "63474144893d9f0a6ce6a542a4f00f8d", + "name": "rise", + "sha256": "76a4835319fec775b8414bb0d9bcd09ebebf8772521087df155903e7dfce2c2c", + "size": 1749987, + "subdir": "linux-64", + "timestamp": 1612306967275, + "version": "5.7.1" + }, + "rise-5.7.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c16b6849259db78fed22c8d3a4ceeaef", + "name": "rise", + "sha256": "30bc9e7f029b906daff605450039e4e7aacbba5c55ccaccf415e3d999bc0abeb", + "size": 1750827, + "subdir": "linux-64", + "timestamp": 1612307386536, + "version": "5.7.1" + }, + "rise-5.7.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "510f23f9d1d79b4667fa203d9de6a86b", + "name": "rise", + "sha256": "4114674acab1fa6d040432008769c4093519ab3c4cfec831d1aa507a96ac916b", + "size": 1750174, + "subdir": "linux-64", + "timestamp": 1612307288438, + "version": "5.7.1" + }, + "rise-5.7.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=5.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8b20c466198f2ea02128cdec421c9822", + "name": "rise", + "sha256": "dd0af8995b62fc8318f022c832549432ce4e39867ed58adfef6a311f4c4bfd3d", + "size": 1749570, + "subdir": "linux-64", + "timestamp": 1612307383339, + "version": "5.7.1" + }, + "rope-0.10.5-py27hcb0a616_0.conda": { + "build": "py27hcb0a616_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "GPL 2.0", + "md5": "0dace92aba2360ead8f1b6a4fe63ced4", + "name": "rope", + "sha256": "8431de1fa3cad2001d073713dbfc33134814cf32ffaeb9d3c30c632c70fda605", + "size": 295362, + "subdir": "linux-64", + "timestamp": 1505752956811, + "version": "0.10.5" + }, + "rope-0.10.5-py35h31d6b7c_0.conda": { + "build": "py35h31d6b7c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "GPL 2.0", + "md5": "fcfa3047130383b2b68795d555279acd", + "name": "rope", + "sha256": "bead7850f013cd30813209d976aaac73d26aa0623dee9a789720e2d3adb81da5", + "size": 307064, + "subdir": "linux-64", + "timestamp": 1505752977045, + "version": "0.10.5" + }, + "rope-0.10.5-py36h1f8c17e_0.conda": { + "build": "py36h1f8c17e_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2.0", + "md5": "88e71a7a3a53782e68e5bb4801b3742b", + "name": "rope", + "sha256": "69b429c4ab7a2ea54f4f926a4ce0c9434f4ce7fcc8a3d7d1cc6a0c18a3d7f564", + "size": 303723, + "subdir": "linux-64", + "timestamp": 1505752997714, + "version": "0.10.5" + }, + "rope-0.10.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "b144376ced9f2be8b82df5c2d54460b4", + "name": "rope", + "sha256": "5ecedb6312bac2f6282818191e36604266d074169a7eaf688f267317500d1a7b", + "size": 295631, + "subdir": "linux-64", + "timestamp": 1530959349618, + "version": "0.10.7" + }, + "rope-0.10.7-py27hfe459b0_0.conda": { + "build": "py27hfe459b0_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "de3e564615e092a8d0dc2610992ab68e", + "name": "rope", + "sha256": "e3eccb994c8c94e4918fae44091e5ddf8b1a68e23743075d85f49d8ad1897ba4", + "size": 295876, + "subdir": "linux-64", + "timestamp": 1511320463743, + "version": "0.10.7" + }, + "rope-0.10.7-py35h986144c_0.conda": { + "build": "py35h986144c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "1d68a61d5759ed6a3f77df8bb5696afe", + "name": "rope", + "sha256": "f494d25519c93d8c82fa48b858a5de1fbecf5eef513b1ac0dea2d7de3e65789e", + "size": 307706, + "subdir": "linux-64", + "timestamp": 1511320468569, + "version": "0.10.7" + }, + "rope-0.10.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "ee72d696bce010340ec2d55d314307f6", + "name": "rope", + "sha256": "7344fd6d858a6bf876b4dc9372c66cc6b1153f34196141906bf5cadfe1173d02", + "size": 301605, + "subdir": "linux-64", + "timestamp": 1530959385452, + "version": "0.10.7" + }, + "rope-0.10.7-py36h147e2ec_0.conda": { + "build": "py36h147e2ec_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "587388742cf2c143efff50b581b5866d", + "name": "rope", + "sha256": "cdf9d5fd9185af45aa598c355962aa527354b326bd06b6e237389eb9539ccece", + "size": 304204, + "subdir": "linux-64", + "timestamp": 1511320469165, + "version": "0.10.7" + }, + "rope-0.10.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "b2a817658fa22d0b22a17f44c3e8caa1", + "name": "rope", + "sha256": "af8ed90c6403f3c6a1cae7797b06a1b425a58002b840a7da3e737f8c3120bf4e", + "size": 304696, + "subdir": "linux-64", + "timestamp": 1530959421720, + "version": "0.10.7" + }, + "rope-0.11.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "54d3866f81e3c01f8123907c73154e89", + "name": "rope", + "sha256": "3449b4ef9f80b5ed07d95844a57b3d23e4041a0d72512ccbf78e79e5bd5e4cd8", + "size": 298664, + "subdir": "linux-64", + "timestamp": 1534176845722, + "version": "0.11.0" + }, + "rope-0.11.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "2747ff39c1980a0f0651bcce0346c135", + "name": "rope", + "sha256": "c80a8d2ea0140a8988b80c520b39aac899422f95ec842418cbbd7adc91bf2666", + "size": 308302, + "subdir": "linux-64", + "timestamp": 1534176860903, + "version": "0.11.0" + }, + "rope-0.11.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "9d1fec319071fad51a8cf325fabf4542", + "name": "rope", + "sha256": "b271fe5dd013b24884e5e6d7fe35544d72387f774b999b6ccf85b59d5f0a2c22", + "size": 304797, + "subdir": "linux-64", + "timestamp": 1534176834141, + "version": "0.11.0" + }, + "rope-0.11.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "082ced026794e94a98536b7d5215f50f", + "name": "rope", + "sha256": "e0c1da77e2d08a295c5d2d593a6c8ce3e9691a1b4cced02b1b2ab3fb03cebe69", + "size": 308550, + "subdir": "linux-64", + "timestamp": 1534176877995, + "version": "0.11.0" + }, + "rope-0.12.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "d9a33f6b2ffabcb8010fb56bf4ecafd4", + "name": "rope", + "sha256": "dc9cc1284032cb63eb5d810076d0a44d4ace90843e03498b6b83f6c883488caa", + "size": 302171, + "subdir": "linux-64", + "timestamp": 1551148691745, + "version": "0.12.0" + }, + "rope-0.12.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "b5967e8899d8a980e180ae21a9c9457e", + "name": "rope", + "sha256": "3ee7d225775659832c629d1a098f684e021eb2ab7b93279d0481462574651af8", + "size": 305823, + "subdir": "linux-64", + "timestamp": 1551148725504, + "version": "0.12.0" + }, + "rope-0.12.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "GPL 2.0", + "license_family": "GPL2", + "md5": "af56df7e4baf9b2c791447194ec1841c", + "name": "rope", + "sha256": "4f9b8c059624e5c458b04bfd99e1e94aab8483600eb371f2b4d9b0b929db0c46", + "size": 306716, + "subdir": "linux-64", + "timestamp": 1551148677353, + "version": "0.12.0" + }, + "rope-1.7.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytoolconfig >=1.2.2" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "f8b0a3539c622382b16192883422c2eb", + "name": "rope", + "sha256": "951298875c27e45ee91f29cb42caf2fea1d4adec77e00e78a4176d962d4f9af2", + "size": 456914, + "subdir": "linux-64", + "timestamp": 1676675078828, + "version": "1.7.0" + }, + "rope-1.7.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "pytoolconfig >=1.2.2" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "201fded17faac3590c2878573c44e64d", + "name": "rope", + "sha256": "12aba058241d8baaf3247e5971deee32df2485d4e6d1aa309fa6dc7bb483da9a", + "size": 558751, + "subdir": "linux-64", + "timestamp": 1677708561099, + "version": "1.7.0" + }, + "rope-1.7.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytoolconfig >=1.2.2" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "3e0c11dcbdd8ff90ba24c5b022cd126e", + "name": "rope", + "sha256": "ba3caa9510a0923535cd4f8c1e7d33a31670042c15adcd19c157c49235c8909d", + "size": 449030, + "subdir": "linux-64", + "timestamp": 1676675108915, + "version": "1.7.0" + }, + "rope-1.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytoolconfig >=1.2.2" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "bf9c17a8614156655fa0e714554b6183", + "name": "rope", + "sha256": "a064a40bca1b2dcb65994394b886363df99fcbd6b4bf906eb3e019848cb28b31", + "size": 451447, + "subdir": "linux-64", + "timestamp": 1676675139307, + "version": "1.7.0" + }, + "rope-1.7.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytoolconfig >=1.2.2" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "2163cb545eebf2fea66efa9b5f4476e5", + "name": "rope", + "sha256": "141cac67d8ee9d87de2515f4d4e89c05023d830357fb753726a60ba0671cd66e", + "size": 451207, + "subdir": "linux-64", + "timestamp": 1676675048475, + "version": "1.7.0" + }, + "routes-2.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "32a7272d4814280ceac6d1870695ceec", + "name": "routes", + "sha256": "48b536856805717c89543392c3d5aa40c5acfa449fdfebdeceec903da9d9ac27", + "size": 57648, + "subdir": "linux-64", + "timestamp": 1530959452899, + "version": "2.4.1" + }, + "routes-2.4.1-py27hd2a40da_0.conda": { + "build": "py27hd2a40da_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff3729db10f20c108e66ee85c831df7d", + "name": "routes", + "sha256": "94a7cf6aa7f9ab67b10b7a732123831f58deebbbc40d028d2df33bb8b066b4b0", + "size": 57880, + "subdir": "linux-64", + "timestamp": 1508007487053, + "version": "2.4.1" + }, + "routes-2.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f33b04b287f7631056e56b26140d25fb", + "name": "routes", + "sha256": "a141b597691c22a0f374628578337503829e571c70433f1526876b215f642e3a", + "size": 57257, + "subdir": "linux-64", + "timestamp": 1535297883076, + "version": "2.4.1" + }, + "routes-2.4.1-py35hb61f5ad_0.conda": { + "build": "py35hb61f5ad_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34c10ccf2b771641faa86a56fe517194", + "name": "routes", + "sha256": "0a047ffcd42e5f0a24a3c1583bf84700d3b7261e92af862195bd7f47d385d479", + "size": 57405, + "subdir": "linux-64", + "timestamp": 1508007464597, + "version": "2.4.1" + }, + "routes-2.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d3e11e5a03c97082e8dc708059b2932f", + "name": "routes", + "sha256": "92de9c33b149d03dcf84ae3711923d4d4b146e0875dd1485682a783bc12dc393", + "size": 57459, + "subdir": "linux-64", + "timestamp": 1530959484254, + "version": "2.4.1" + }, + "routes-2.4.1-py36h38f819d_0.conda": { + "build": "py36h38f819d_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f85641a3f46a8e3d9c861874bd5f8af0", + "name": "routes", + "sha256": "443a1db11ebfb0c9725604285a6c2ffe4fea6548bdeb3cc64cf0a91d801c177c", + "size": 57682, + "subdir": "linux-64", + "timestamp": 1508007492087, + "version": "2.4.1" + }, + "routes-2.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7faa33589d409834724c469cda3c4923", + "name": "routes", + "sha256": "e5df175cfa005a2f434e35e585215620767549707e913dd0d775a09d85c91e1f", + "size": 57485, + "subdir": "linux-64", + "timestamp": 1530959514965, + "version": "2.4.1" + }, + "routes-2.4.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0786d9eef89e10e2685493165ddeddcd", + "name": "routes", + "sha256": "fa59bbe90f622fe7d2b822c822b5e6394e85b96a24f03d7031058ba7bf317cc6", + "size": 58085, + "subdir": "linux-64", + "timestamp": 1573554677388, + "version": "2.4.1" + }, + "routes-2.5.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9dba0f2efc83ae25c27eb06a4c50cea0", + "name": "routes", + "sha256": "8409911ab7836abb22cf043ba9adde8bf1d7c0932dbe29b7f7d64d3d9231a57c", + "size": 58091, + "subdir": "linux-64", + "timestamp": 1642510975038, + "version": "2.5.1" + }, + "routes-2.5.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a4fea798ece30b828de6684a36115c60", + "name": "routes", + "sha256": "826f2d6000493ef27bfde79191c80fa70d7136bb651e283a6e49cf95f11c9ede", + "size": 76595, + "subdir": "linux-64", + "timestamp": 1676845690573, + "version": "2.5.1" + }, + "routes-2.5.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6df37881828aee6a06e29959983e1abf", + "name": "routes", + "sha256": "060db7b5aa29e35dcb79436d4a8acada1b89f7888898d789646df38c9c676413", + "size": 59123, + "subdir": "linux-64", + "timestamp": 1606864044128, + "version": "2.5.1" + }, + "routes-2.5.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "195122bac058f297fa0aa3edaa3c148c", + "name": "routes", + "sha256": "947d5d3d6c2a16cc7cfc3abdf9095628fade241642db11c3fa9426f3fff79b5c", + "size": 58723, + "subdir": "linux-64", + "timestamp": 1606864038848, + "version": "2.5.1" + }, + "routes-2.5.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63059c42003213d340a03d56b33fa63c", + "name": "routes", + "sha256": "7a54ee0317d61a462524a48399b2bb5165b6ba271aff6ba34467c2e0642ff7ea", + "size": 58216, + "subdir": "linux-64", + "timestamp": 1606863992884, + "version": "2.5.1" + }, + "routes-2.5.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "repoze.lru >=0.3", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea6303b2b6d073ed0a1dded310ee1d6b", + "name": "routes", + "sha256": "d15765b8b1c4e45ec36f4c908bfcaf789949f74fa3215dfb6227159179416880", + "size": 59406, + "subdir": "linux-64", + "timestamp": 1632762343482, + "version": "2.5.1" + }, + "rtree-0.8.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "libspatialindex", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-2.1", + "md5": "d5e481b5f38a9d2b11ee9ece747feb41", + "name": "rtree", + "sha256": "d5700a412fa57ae96dd4aac792d39efddf4401073401f80553133ee6ef5a27ca", + "size": 45478, + "subdir": "linux-64", + "timestamp": 1530890221011, + "version": "0.8.3" + }, + "rtree-0.8.3-py27h5233db4_0.conda": { + "build": "py27h5233db4_0", + "build_number": 0, + "depends": [ + "libspatialindex", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-2.1", + "md5": "2fc5d5c163096572e71485b194507b4d", + "name": "rtree", + "sha256": "08f0483327c3aad3ba4f347f4cfcb8e15b7344875120fb3faf7d3242bca1656f", + "size": 45683, + "subdir": "linux-64", + "timestamp": 1513269254494, + "version": "0.8.3" + }, + "rtree-0.8.3-py35h2f9c1c0_0.conda": { + "build": "py35h2f9c1c0_0", + "build_number": 0, + "depends": [ + "libspatialindex", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-2.1", + "md5": "16cdf76a0408fb2d597a722f87f6a27d", + "name": "rtree", + "sha256": "956c196adf5fca9b7038153fb99fba6c29f0ef616bf3024120fb7c3f16996f26", + "size": 46923, + "subdir": "linux-64", + "timestamp": 1513269276808, + "version": "0.8.3" + }, + "rtree-0.8.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libspatialindex", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "432c56e02f9533014cc72d98d8e3b56e", + "name": "rtree", + "sha256": "215ac1ec90321a9a4bd9148356538346e26afc855b2b6a396a6d7c0636c4739f", + "size": 46246, + "subdir": "linux-64", + "timestamp": 1530890195595, + "version": "0.8.3" + }, + "rtree-0.8.3-py36h2f9c1c0_0.conda": { + "build": "py36h2f9c1c0_0", + "build_number": 0, + "depends": [ + "libspatialindex", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "a2d108b5aef230e794728f6e0a50f8fa", + "name": "rtree", + "sha256": "872b8d9e1d397fbce1b8aeeb2302c6f1fb2a7c0a6099dde240f826bce373dd5a", + "size": 46505, + "subdir": "linux-64", + "timestamp": 1513269328925, + "version": "0.8.3" + }, + "rtree-0.8.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libspatialindex", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1", + "md5": "6d808b152b22fd8b46e7adf04b9d91dc", + "name": "rtree", + "sha256": "1305d46d9faafdfe18c46fab7235683ebe4631bfbd2c900a0a0b3dbc42cfc664", + "size": 46300, + "subdir": "linux-64", + "timestamp": 1530890169001, + "version": "0.8.3" + }, + "rtree-0.8.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "libspatialindex", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1", + "md5": "c69a66f0fd1e4b1542113720aa0ed4df", + "name": "rtree", + "sha256": "e0b1e7b45bc3bad0b094245594b499c7fb5666110be7ff3857101a71f8221fa1", + "size": 46686, + "subdir": "linux-64", + "timestamp": 1573200598481, + "version": "0.8.3" + }, + "rtree-0.9.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "43034cd7c07effb9d23b9c34982f6214", + "name": "rtree", + "sha256": "f961e5515bf12243fd5179c60216cbc1b6ea084369832dbaf8684c14e6b6af91", + "size": 45996, + "subdir": "linux-64", + "timestamp": 1580336055735, + "version": "0.9.3" + }, + "rtree-0.9.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8a54d1adeedf7283119d8a2193ab66b2", + "name": "rtree", + "sha256": "ee03a23549355f4f038088027d8d97d936a39dcf0d1802867804b88c8c07edf5", + "size": 46247, + "subdir": "linux-64", + "timestamp": 1580336019124, + "version": "0.9.3" + }, + "rtree-0.9.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "15d77c5dbca15eaa47d12ebbb3636182", + "name": "rtree", + "sha256": "c884c1f33be97ef807e21e622ecf6baedf5846d6a6a1f7c4abf1af8871e9b292", + "size": 46429, + "subdir": "linux-64", + "timestamp": 1580336066836, + "version": "0.9.3" + }, + "rtree-0.9.4-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "5e977e2aa80491c43a6ac7caf83bd070", + "name": "rtree", + "sha256": "d5ec1b149f4d4d1d089f4a7fcdd324e7d061cefdc51d74ed22ac0d7718545d0f", + "size": 48558, + "subdir": "linux-64", + "timestamp": 1588548917738, + "version": "0.9.4" + }, + "rtree-0.9.4-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "961298a0a4d6cc56990d3ed20f9fa34b", + "name": "rtree", + "sha256": "57a9bffa84c92f0b6b1bed5ff78239160e05d9f1a31580aeede5ed18a624efed", + "size": 48065, + "subdir": "linux-64", + "timestamp": 1588548908039, + "version": "0.9.4" + }, + "rtree-0.9.4-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "4cea7158b44ee940c20358bb8c46d59d", + "name": "rtree", + "sha256": "7c90283114fd0b55cfaaa8d29315ca2cb19a528d17354ecc9bbd0545eb5379f0", + "size": 47928, + "subdir": "linux-64", + "timestamp": 1588548912744, + "version": "0.9.4" + }, + "rtree-0.9.4-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "e838804fe08bb9f639c83de101a61d0f", + "name": "rtree", + "sha256": "70900fa68ca0cee44f70214e85e3bf8df3ade43b587e36912a98bf5c82385a0c", + "size": 49445, + "subdir": "linux-64", + "timestamp": 1607977239723, + "version": "0.9.4" + }, + "rtree-0.9.7-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "b1319e5b1a9a2954d2fafe96fb252deb", + "name": "rtree", + "sha256": "788727f40ffd8a7df7f57d6c465bd420a63028eb4f027cc8b0ec2526ba6ab943", + "size": 45710, + "subdir": "linux-64", + "timestamp": 1640794395179, + "version": "0.9.7" + }, + "rtree-0.9.7-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "474633d41c5758e28a64a5b6c6ecd63f", + "name": "rtree", + "sha256": "b2c5c3543153e62853b8dbce7e4dd97e242facc753809ef5daf0e070b8eeea24", + "size": 49334, + "subdir": "linux-64", + "timestamp": 1618420411821, + "version": "0.9.7" + }, + "rtree-0.9.7-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2c2ae56df71cd253d24af6a738d9baaa", + "name": "rtree", + "sha256": "2fe6be274dfd81a6f2c9a7347da4bdfcaf8cf6872aa62fc6e97dcc10935c69d9", + "size": 48477, + "subdir": "linux-64", + "timestamp": 1618420875733, + "version": "0.9.7" + }, + "rtree-0.9.7-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "df32a3ca36e3faa3f0079af0e0504012", + "name": "rtree", + "sha256": "8fdf413c7862c3e98b430eb9208c7ca811431c415a723932d2f7ac1b934a1cf9", + "size": 49477, + "subdir": "linux-64", + "timestamp": 1618420880478, + "version": "0.9.7" + }, + "rtree-0.9.7-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "1582bd98f2bdd3b00eb1f4c1012fd501", + "name": "rtree", + "sha256": "35bc7ae425f2006da04133b8bff90e75e2e5f5c0e586a9774e3ebe49b3fd7227", + "size": 49683, + "subdir": "linux-64", + "timestamp": 1618420877038, + "version": "0.9.7" + }, + "rtree-1.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "libspatialindex >=1.8.5", + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e62d67408e13176d2b259ee70d6368e", + "name": "rtree", + "sha256": "f02e46b94f1d4daeae0fb5d4a99763241df4fea464f48a356231f816c9c269fa", + "size": 50664, + "subdir": "linux-64", + "timestamp": 1675157932145, + "version": "1.0.1" + }, + "rtree-1.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "libspatialindex >=1.8.5", + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee24dafe72ad544878aab6be8ccf6368", + "name": "rtree", + "sha256": "a7e60f75a34bf650caf3524cc08fe7d607dba7a3be7da3029eb9c191ba1b7f14", + "size": 61533, + "subdir": "linux-64", + "timestamp": 1676845705413, + "version": "1.0.1" + }, + "rtree-1.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "libspatialindex >=1.8.5", + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.7,<3.8.0a0", + "typing_extensions >=3.7" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "84281841d3038538690d780b6e12eeb9", + "name": "rtree", + "sha256": "77de139ad689c736c8ed7cce028ed79a2b732ac167f2541c9b47f6462e6c732e", + "size": 50017, + "subdir": "linux-64", + "timestamp": 1675157881160, + "version": "1.0.1" + }, + "rtree-1.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "libspatialindex >=1.8.5", + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "72b9cbc459c98cb07ea6bcacadcbf8ed", + "name": "rtree", + "sha256": "050bd0dc551dd57b7d4ff4bb0e8592996221540c9ffdba89585afa9be6b3f322", + "size": 50244, + "subdir": "linux-64", + "timestamp": 1675157906591, + "version": "1.0.1" + }, + "rtree-1.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "libspatialindex >=1.8.5", + "libspatialindex >=1.9.3,<1.9.4.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "735a8644faab1c299f4fdf30d967d291", + "name": "rtree", + "sha256": "d6756ce7fc22409c0a57ca2bd91dc3690d3689d43c2694b3c314790b93b0e52d", + "size": 50247, + "subdir": "linux-64", + "timestamp": 1675157957600, + "version": "1.0.1" + }, + "ruamel-1.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "890ef500f9f06f40abadc2a3b7622fad", + "name": "ruamel", + "sha256": "9a06e56e604cc250e92fd64766f1eb12cf44ff1574afdcbeaf7e93d1e99dc8b6", + "size": 6681, + "subdir": "linux-64", + "timestamp": 1574354806654, + "version": "1.0" + }, + "ruamel-1.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "269322d4e0e2a8e974e264a21d48740c", + "name": "ruamel", + "sha256": "843a817a327eefb5b4b5794137aa7118c12606a067446fde760d08cffcca28f4", + "size": 5673, + "subdir": "linux-64", + "timestamp": 1641551100460, + "version": "1.0" + }, + "ruamel-1.0-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6d9e8a165c92103c87ff4491ed7d383c", + "name": "ruamel", + "sha256": "a0abc438e3777faf39da1a319b4c434eff6e132c3f7aa627d9b744dd4b273488", + "size": 5618, + "subdir": "linux-64", + "timestamp": 1664919733685, + "version": "1.0" + }, + "ruamel-1.0-py311h06a4308_2.conda": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "da66082d74bb29dc9fbd1a4be2fc3233", + "name": "ruamel", + "sha256": "e4e275da29bc24e617efdbc3e2703f327fc1e62acd86f1647361186757ab5cbf", + "size": 6100, + "subdir": "linux-64", + "timestamp": 1676828785739, + "version": "1.0" + }, + "ruamel-1.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "91585b2700b3aee8871895f6d1579660", + "name": "ruamel", + "sha256": "4b6d9f78a935083f454a69b9407b2c25e7e4f9d08305e43c291ed849f61d8241", + "size": 6724, + "subdir": "linux-64", + "timestamp": 1574354824330, + "version": "1.0" + }, + "ruamel-1.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "79be8b3e713538a173e356b8681ad148", + "name": "ruamel", + "sha256": "b46d8f127871000c42d1072adff414d93eae7788dc7aa74197fae17e73df727f", + "size": 6717, + "subdir": "linux-64", + "timestamp": 1613648902368, + "version": "1.0" + }, + "ruamel-1.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fb491e99a5896d708970608a0d60a0c9", + "name": "ruamel", + "sha256": "ae007024f099061af3fe57e8526efeb74ab8604cc5fb4da72114091f5c8de28b", + "size": 6740, + "subdir": "linux-64", + "timestamp": 1574354738667, + "version": "1.0" + }, + "ruamel-1.0-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b88eb03b07529c22028063dbd390d5a5", + "name": "ruamel", + "sha256": "11d04e60679ba26995da0a3a8063c2402cd82c89221a97bc3ea2e316afd9878f", + "size": 5114, + "subdir": "linux-64", + "timestamp": 1594403307685, + "version": "1.0" + }, + "ruamel-1.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7fa7d338d694d2f0ca390dfbe1157bfb", + "name": "ruamel", + "sha256": "2d0e03d1a3dd3a66f7d2e31839210bd0dde05caa7012e3e439acfe4d8dfa269e", + "size": 6721, + "subdir": "linux-64", + "timestamp": 1613648177542, + "version": "1.0" + }, + "ruamel-1.0-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9a112d7ed7a3fffc39acd9f2fb82fa85", + "name": "ruamel", + "sha256": "0efe3b11d7a0a83ddbfdf1ab4f66b9ddcd1238d38a0e9c10c026dc6b112c68c6", + "size": 5586, + "subdir": "linux-64", + "timestamp": 1664919798159, + "version": "1.0" + }, + "ruamel-1.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "27e7c008f5bf7862540bae0394de58a2", + "name": "ruamel", + "sha256": "fee72a2c922652b68521706a9acd7e0c19c55726d92f296e0f2e2023baf7db83", + "size": 6710, + "subdir": "linux-64", + "timestamp": 1574354862410, + "version": "1.0" + }, + "ruamel-1.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "96a7559a88a33e5d95c5581adda47139", + "name": "ruamel", + "sha256": "9f7a09a3075d5668d2382373a00915cf4ac7c0a4226761cda65e21fde215158e", + "size": 6731, + "subdir": "linux-64", + "timestamp": 1613648893938, + "version": "1.0" + }, + "ruamel-1.0-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3504b93af196fe7e38222c291ec50748", + "name": "ruamel", + "sha256": "ff4a7f20bba5e6655050661e0222d98a2782bdf26496d43e06b1edb3a36b4acf", + "size": 5601, + "subdir": "linux-64", + "timestamp": 1664919777240, + "version": "1.0" + }, + "ruamel-1.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f75cc17d1ca59a04a6647534ee016613", + "name": "ruamel", + "sha256": "38c9308c6d7d68348824414451ebd196ebd3e034764e7f7cb73befc79d77618d", + "size": 6748, + "subdir": "linux-64", + "timestamp": 1613648884764, + "version": "1.0" + }, + "ruamel-1.0-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "62df0f22a1df4ab45484801993c96b8c", + "name": "ruamel", + "sha256": "8ce9a2513efec788e8f1c1a6555347a4606f2942b4b12f5084d422f24b19410c", + "size": 5599, + "subdir": "linux-64", + "timestamp": 1664919756701, + "version": "1.0" + }, + "ruamel.yaml-0.16.10-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "9d0167ba3cce1956a044a2b6e2c3fc51", + "name": "ruamel.yaml", + "sha256": "552196648a4594bcafb6a86f57cdd477de06fd7828da7ae28cbc17ccf90d3a7b", + "size": 179177, + "subdir": "linux-64", + "timestamp": 1641550815121, + "version": "0.16.10" + }, + "ruamel.yaml-0.16.10-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "93d8cfee9d8254499b99c3d4547a03c2", + "name": "ruamel.yaml", + "sha256": "86c6235b7e374c7497142cb8602cba656ceddd32479e1ea068c56d7947188be8", + "size": 188174, + "subdir": "linux-64", + "timestamp": 1587579182889, + "version": "0.16.10" + }, + "ruamel.yaml-0.16.10-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "c27e004e1a6d84b601a9986d452f284e", + "name": "ruamel.yaml", + "sha256": "69e03826972c7646f5306d78adea55fd2adee34ca73f84945346238b23afe87e", + "size": 187662, + "subdir": "linux-64", + "timestamp": 1587579400621, + "version": "0.16.10" + }, + "ruamel.yaml-0.16.10-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "6c901ea3e49d283cb20294de080b31fc", + "name": "ruamel.yaml", + "sha256": "07f0046ebe24da5d20da48960fb6ad9ab399549d8586fff21d1a6b594e43a20d", + "size": 188793, + "subdir": "linux-64", + "timestamp": 1587580012640, + "version": "0.16.10" + }, + "ruamel.yaml-0.16.12-py310h5eee18b_2.conda": { + "build": "py310h5eee18b_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd48ab567ca5ffc5f91ac9090fb1fcbb", + "name": "ruamel.yaml", + "sha256": "785aa560a588d1f1ce277cda8c71ca3aa637fd14b2301dc2912bdc2ba1e3606e", + "size": 179199, + "subdir": "linux-64", + "timestamp": 1663675885496, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py310h5eee18b_3.conda": { + "build": "py310h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f5500ff4c696547f9f9b8c19d0521ac3", + "name": "ruamel.yaml", + "sha256": "9ec65c828687d306d4c872cf7233d3b812f97f91c9b0d6d9626f27c23e59f1be", + "size": 179285, + "subdir": "linux-64", + "timestamp": 1664988612691, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "d145661568b8ab0613f37e913f7f7c3d", + "name": "ruamel.yaml", + "sha256": "6d135ed42857759d0549a03e981c354a5ca0a7327ae8d0e044864400e889df39", + "size": 176331, + "subdir": "linux-64", + "timestamp": 1600552856560, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py37h5eee18b_2.conda": { + "build": "py37h5eee18b_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0e4e3aefcd204e2e22af792b63b0247", + "name": "ruamel.yaml", + "sha256": "6cf939e03e8ef86d8c7ad64f0c4850eaab63ce39af0c6fa3b856e099a52566b4", + "size": 175511, + "subdir": "linux-64", + "timestamp": 1663675912972, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py37h5eee18b_3.conda": { + "build": "py37h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9647426073edf9e5115e836746ee576", + "name": "ruamel.yaml", + "sha256": "f3fb2c548a603a426023ba7723ea6effa4264fb851f19389825b57825df6007b", + "size": 174839, + "subdir": "linux-64", + "timestamp": 1664988667145, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "3b49b507d314a42e655f8ac170fe6a3a", + "name": "ruamel.yaml", + "sha256": "2f48c74d748923411fdc856743849efdea9b0050b5b9429240b8754740d6a806", + "size": 176755, + "subdir": "linux-64", + "timestamp": 1600552862969, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py38h5eee18b_2.conda": { + "build": "py38h5eee18b_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9241978092e6298323d44960aea68f3", + "name": "ruamel.yaml", + "sha256": "81f5c70ca6387f3dc6fda649e58f4c8e03037c9777acda44374c50f521238c97", + "size": 177030, + "subdir": "linux-64", + "timestamp": 1663675817592, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py38h5eee18b_3.conda": { + "build": "py38h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f7b05ceb02ea5e6f2f440798e18f35e", + "name": "ruamel.yaml", + "sha256": "803491a606dae970dce232b9e555912103345dc3af6e66597eac1bece2952964", + "size": 175964, + "subdir": "linux-64", + "timestamp": 1664988639723, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "89ec21fbde8af63335c1045565fddbf5", + "name": "ruamel.yaml", + "sha256": "4d9a781b9111fd35136e40b9dbdfcc0d90a9221047eca18f7bf828d159f6c6bc", + "size": 178040, + "subdir": "linux-64", + "timestamp": 1600552889950, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "e48cc02d2122467534bc6da956cc497f", + "name": "ruamel.yaml", + "sha256": "d6dec7b576a2b1f60824b6a3f03174860e4f48406b25e96613e5780d220052ba", + "size": 188742, + "subdir": "linux-64", + "timestamp": 1613650318760, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py39h5eee18b_2.conda": { + "build": "py39h5eee18b_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4cda96bcc65ba89a8a7eb010014f71d", + "name": "ruamel.yaml", + "sha256": "1690ef6e6e3c39017856851f68f33c8066329a0e9e96b2f2b99487941370130d", + "size": 177086, + "subdir": "linux-64", + "timestamp": 1663675845888, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.12-py39h5eee18b_3.conda": { + "build": "py39h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80efc62d8d3e24e83ef4fad12a719292", + "name": "ruamel.yaml", + "sha256": "b2b158e5a9841f20782b44de1ecc51b89443571ccfbc4b14d435661574e5181f", + "size": 175959, + "subdir": "linux-64", + "timestamp": 1664988572430, + "version": "0.16.12" + }, + "ruamel.yaml-0.16.5-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "c1019b1e7e1836b0783eb9d8c9779664", + "name": "ruamel.yaml", + "sha256": "1afd3dd6388f52115911f8f955ff99785e50737451cc6c5f82f7f0942ac7e8e8", + "size": 186873, + "subdir": "linux-64", + "timestamp": 1574355162600, + "version": "0.16.5" + }, + "ruamel.yaml-0.16.5-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "086b15ed8cadacdf9058e7f72b5c1b7e", + "name": "ruamel.yaml", + "sha256": "2abf3cb43944ba63130c2aa77d99dd787861497ef8e6a80e16288f3c4d3fd64d", + "size": 187297, + "subdir": "linux-64", + "timestamp": 1574355109296, + "version": "0.16.5" + }, + "ruamel.yaml-0.16.5-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "d4c861003478f98b97287b28357107a9", + "name": "ruamel.yaml", + "sha256": "6555fedc59c0c69ba95fae7c72a8f167272857cf6990d44ae4b58cbac012034e", + "size": 195643, + "subdir": "linux-64", + "timestamp": 1574355135320, + "version": "0.16.5" + }, + "ruamel.yaml-0.16.6-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "a21e329099e0ef46377253cdada61685", + "name": "ruamel.yaml", + "sha256": "e611bde654c36c69380f0ff9b594e54fe48fc6d9d1bf3f8a66079ea552ff14be", + "size": 187922, + "subdir": "linux-64", + "timestamp": 1587400176782, + "version": "0.16.6" + }, + "ruamel.yaml-0.16.6-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "ba3b7e9655ef604017256eb0c9c58c06", + "name": "ruamel.yaml", + "sha256": "fb449cc43cca289ae1733f11bdd5462bedff66a09b7f8185083f091a3f156412", + "size": 187116, + "subdir": "linux-64", + "timestamp": 1587400147840, + "version": "0.16.6" + }, + "ruamel.yaml-0.16.6-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "79161074760323805426f904b824aa7d", + "name": "ruamel.yaml", + "sha256": "d07db8569e8887bdd5686e67fd44b6502105b4d8caab58fb5d35dd3d17ae803a", + "size": 189215, + "subdir": "linux-64", + "timestamp": 1587400170339, + "version": "0.16.6" + }, + "ruamel.yaml-0.16.7-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "5b45c48a018a7c6fd8471644bce91b7a", + "name": "ruamel.yaml", + "sha256": "d568b13ddbb1e3c58d25f44b9b5bfd7efb3173063fe112cb4f357501b4d2b1c3", + "size": 187452, + "subdir": "linux-64", + "timestamp": 1587568109040, + "version": "0.16.7" + }, + "ruamel.yaml-0.16.7-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "be639282d40581b1a1b249b0caf2aa32", + "name": "ruamel.yaml", + "sha256": "a08a45b21e20e624c7bdf8b2a4d0fb7ea9366844d40487858356cd5b37073f58", + "size": 188357, + "subdir": "linux-64", + "timestamp": 1587568116475, + "version": "0.16.7" + }, + "ruamel.yaml-0.16.7-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml.clib >=0.1.2", + "setuptools" + ], + "license": "MIT", + "md5": "90baa35b215f746428738a130782dc0a", + "name": "ruamel.yaml", + "sha256": "51ac3d745b8f73183fb0cf1f54dbdffc5766477122b7755bc4aa48966a33c0d3", + "size": 189605, + "subdir": "linux-64", + "timestamp": 1587568122325, + "version": "0.16.7" + }, + "ruamel.yaml-0.17.21-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "ruamel.yaml.clib >=0.2.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a54e321078e043b72b6f68d10472b62", + "name": "ruamel.yaml", + "sha256": "8f0df5b62f89a90d664976df8b9b27280c5ea3b4e1605cce46fe2968fa41c7be", + "size": 184809, + "subdir": "linux-64", + "timestamp": 1666304642204, + "version": "0.17.21" + }, + "ruamel.yaml-0.17.21-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f1ac43629c820a4e7e59a169c497bb8", + "name": "ruamel.yaml", + "sha256": "5f389165708a185bf2a5a01cd9432c482cc7d78cf27b43017d2920b2e138b111", + "size": 254982, + "subdir": "linux-64", + "timestamp": 1676838786578, + "version": "0.17.21" + }, + "ruamel.yaml-0.17.21-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml.clib >=0.2.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39c39ea617216eed3bbf76f1c633d10e", + "name": "ruamel.yaml", + "sha256": "e8636af8dede4f69e039108544d1a62398ef932f6f3ee5a3a07bb661fdb8e042", + "size": 181146, + "subdir": "linux-64", + "timestamp": 1666304586743, + "version": "0.17.21" + }, + "ruamel.yaml-0.17.21-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml.clib >=0.2.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1fc2f22ba1f414242e58226583e48711", + "name": "ruamel.yaml", + "sha256": "e3240e0ff6c687b3bc330d03007e4cacf91c9519b3e87e6e6679c130ef5938f2", + "size": 182522, + "subdir": "linux-64", + "timestamp": 1666304614235, + "version": "0.17.21" + }, + "ruamel.yaml-0.17.21-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "ruamel.yaml.clib >=0.2.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98318e952aa1f128c2cfa9529d1a3a43", + "name": "ruamel.yaml", + "sha256": "0540abfcda635b6125f44e1265570ef374a337027ade8e3f1ec2ed120880ce4b", + "size": 182115, + "subdir": "linux-64", + "timestamp": 1666304669344, + "version": "0.17.21" + }, + "ruamel.yaml.clib-0.2.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "69d1bf9431b010e86891e572d67a732e", + "name": "ruamel.yaml.clib", + "sha256": "f8ac5aa97f7d9bc2ee1ccbaa61d12441f290c1d03ff6a82f9c8d2a33add8b501", + "size": 142076, + "subdir": "linux-64", + "timestamp": 1574354836402, + "version": "0.2.0" + }, + "ruamel.yaml.clib-0.2.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b316440251c2c1732c573dc6d348a27f", + "name": "ruamel.yaml.clib", + "sha256": "ca8aa3910a73f621188d6ec16eb512a59acc13ddec287b8a40bf432fadaf980c", + "size": 150399, + "subdir": "linux-64", + "timestamp": 1574354873041, + "version": "0.2.0" + }, + "ruamel.yaml.clib-0.2.0-py37h14c3975_1.conda": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c38fbb63911be7aa226c2c7331135ca0", + "name": "ruamel.yaml.clib", + "sha256": "6dbe6261069f4110b6dfb41f3d9e19ae232c70bbedc3747715785145650b37f1", + "size": 147788, + "subdir": "linux-64", + "timestamp": 1594403756479, + "version": "0.2.0" + }, + "ruamel.yaml.clib-0.2.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f04a2db734f7cb7753fc02060f45f4e5", + "name": "ruamel.yaml.clib", + "sha256": "37bf51c4935c52d4afb8a19b821a20ce1da60ca069e54749e80078ed72e69910", + "size": 148436, + "subdir": "linux-64", + "timestamp": 1574354844823, + "version": "0.2.0" + }, + "ruamel.yaml.clib-0.2.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a688e8d10ab03cd92e1a5149e93b6bc5", + "name": "ruamel.yaml.clib", + "sha256": "216c300df192d20908a33877f21f8d312aa70235c3960d60d85f4538d0f7db6a", + "size": 160115, + "subdir": "linux-64", + "timestamp": 1574354874294, + "version": "0.2.0" + }, + "ruamel.yaml.clib-0.2.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c6e959ade9a1c5234c21cacf4c675fc0", + "name": "ruamel.yaml.clib", + "sha256": "76c750efd6863733df30ba10f1ec8132b89be02c9539e442742a4fd6b920c541", + "size": 153015, + "subdir": "linux-64", + "timestamp": 1613646261113, + "version": "0.2.0" + }, + "ruamel.yaml.clib-0.2.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31ae2218d87dfe2f02d66ce333e583cc", + "name": "ruamel.yaml.clib", + "sha256": "8b6ab7bfe9845c5f2b0845314f65b50acc0ec9c5da9974ca380092efb182859e", + "size": 148390, + "subdir": "linux-64", + "timestamp": 1601999154935, + "version": "0.2.2" + }, + "ruamel.yaml.clib-0.2.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0e069cfb7f111b0d92a1af1ca3839749", + "name": "ruamel.yaml.clib", + "sha256": "29c7a1ee5a9bbc95bf7c9f4f084da67726cee557462d8f2802d7e841dc6b7e75", + "size": 147657, + "subdir": "linux-64", + "timestamp": 1601999142642, + "version": "0.2.2" + }, + "ruamel.yaml.clib-0.2.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80abc008c6dddc412ee8d19cfd042dca", + "name": "ruamel.yaml.clib", + "sha256": "258da9f639e8599d12ac562f9cb4588bd5ef9881bd184a347751e15981967aa3", + "size": 151627, + "subdir": "linux-64", + "timestamp": 1601999138846, + "version": "0.2.2" + }, + "ruamel.yaml.clib-0.2.6-py310h5eee18b_1.conda": { + "build": "py310h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49a45b52b0edcddab287912fc9cf5304", + "name": "ruamel.yaml.clib", + "sha256": "568f3fc62d9ea7eb1919be02d1bd5fc962c6209dc4f8eb395f7fd2481e63d5a8", + "size": 142672, + "subdir": "linux-64", + "timestamp": 1666302324054, + "version": "0.2.6" + }, + "ruamel.yaml.clib-0.2.6-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2074c24c2f6b46643d732c5a574ff4a8", + "name": "ruamel.yaml.clib", + "sha256": "eb196d4002cd04e672bae864127d1f15326cd4861047875226dd30c0e054aa6d", + "size": 458351, + "subdir": "linux-64", + "timestamp": 1641550444427, + "version": "0.2.6" + }, + "ruamel.yaml.clib-0.2.6-py37h5eee18b_1.conda": { + "build": "py37h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47343cd52699b3125c44b9a6248f166b", + "name": "ruamel.yaml.clib", + "sha256": "360fedc410fdd3aed7c5c89491d88cbef44fd3ccd1434304d7f11ec58a9edbb2", + "size": 143565, + "subdir": "linux-64", + "timestamp": 1666302392782, + "version": "0.2.6" + }, + "ruamel.yaml.clib-0.2.6-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b2ce1a1fb6f7ae4cb397508fc298a38", + "name": "ruamel.yaml.clib", + "sha256": "312953859715eb9284af8c10d258020864ebab40423a39324d387c4c90b3667e", + "size": 135934, + "subdir": "linux-64", + "timestamp": 1641552593723, + "version": "0.2.6" + }, + "ruamel.yaml.clib-0.2.6-py38h5eee18b_1.conda": { + "build": "py38h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3a567712a46a1be282217ce1cff080b", + "name": "ruamel.yaml.clib", + "sha256": "cdb1525d2b512fa940a115ceec403fdc6a900d9ac2e08d0a0089e5b9b02f947d", + "size": 146727, + "subdir": "linux-64", + "timestamp": 1666302290504, + "version": "0.2.6" + }, + "ruamel.yaml.clib-0.2.6-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dad274145a186582232b153a27fad82f", + "name": "ruamel.yaml.clib", + "sha256": "c6407a511aca43bed52de049c3b90bfd7b3392e8f859e855fa1aff1820e3860c", + "size": 140122, + "subdir": "linux-64", + "timestamp": 1641552644147, + "version": "0.2.6" + }, + "ruamel.yaml.clib-0.2.6-py39h5eee18b_1.conda": { + "build": "py39h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "053331f14af6a45965971a4500d8a1e8", + "name": "ruamel.yaml.clib", + "sha256": "7e9f50dc49d2befd64bb23d5aafc58bebd6909314b99d853fb63c29697b73389", + "size": 143367, + "subdir": "linux-64", + "timestamp": 1666302357107, + "version": "0.2.6" + }, + "ruamel.yaml.clib-0.2.6-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e77842bc2bbcbe94bc9004aeb85e383", + "name": "ruamel.yaml.clib", + "sha256": "8a7bd1bcc008c1bd10d1ae2ac73d774c8efe8aebe0ac696d2ff540cd2f1bbeb1", + "size": 140419, + "subdir": "linux-64", + "timestamp": 1641552620724, + "version": "0.2.6" + }, + "ruamel.yaml.clib-0.2.7-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "741fca66e4a3129e262d51e209b494e7", + "name": "ruamel.yaml.clib", + "sha256": "4f338268f5b8557de8a33536e9139fe71c2e6eaee5803044e9f179ca427e0f60", + "size": 133390, + "subdir": "linux-64", + "timestamp": 1676828808066, + "version": "0.2.7" + }, + "ruamel.yaml.jinja2-0.2.7-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "ruamel.yaml >=0.15.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23390c5e0e8d8a545918078d8d9fe6b8", + "name": "ruamel.yaml.jinja2", + "sha256": "76524d2fbe82c954cfb68a1030b3eb5045fb732dcecaeb174daf68e86d83f804", + "size": 12123, + "subdir": "linux-64", + "timestamp": 1676902992827, + "version": "0.2.7" + }, + "ruamel.yaml.jinja2-0.2.7-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "ruamel.yaml >=0.15.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9eb2d05f8bf5871eb631ff0ace3b3e54", + "name": "ruamel.yaml.jinja2", + "sha256": "59a6a04c08ec3bb4208e0978bb868810992a2fc1e3fdd26c62827de01eb2ade2", + "size": 12022, + "subdir": "linux-64", + "timestamp": 1676902967971, + "version": "0.2.7" + }, + "ruamel.yaml.jinja2-0.2.7-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "ruamel.yaml >=0.15.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a6c5d47663501e6162b1160c908cf14d", + "name": "ruamel.yaml.jinja2", + "sha256": "8e9c577b32b14a8742289b0a5be1635852d0d1f8416d7d37a17dd6af689e5c85", + "size": 12005, + "subdir": "linux-64", + "timestamp": 1676902919551, + "version": "0.2.7" + }, + "ruamel.yaml.jinja2-0.2.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "ruamel.yaml >=0.15.10" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dcdeee3320c29cda5609aa2469f60b0e", + "name": "ruamel.yaml.jinja2", + "sha256": "e9c3b86e09d6e00078705753915df4b8602ee771b0794809f8160ccd567c1cb4", + "size": 12036, + "subdir": "linux-64", + "timestamp": 1676902943666, + "version": "0.2.7" + }, + "ruamel_yaml-0.11.14-py27h672d447_2.conda": { + "build": "py27h672d447_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0dfce8f8d7911afc8674a98bd0638fb", + "name": "ruamel_yaml", + "sha256": "9561da0f2a2ba93c723dcc3a37665bc742d2d32ca1295ff77261d573e70e27ef", + "size": 202774, + "subdir": "linux-64", + "timestamp": 1505693600028, + "version": "0.11.14" + }, + "ruamel_yaml-0.11.14-py35h8e2c16b_2.conda": { + "build": "py35h8e2c16b_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7896725cec3815c6b4b5119975f464ec", + "name": "ruamel_yaml", + "sha256": "5169330924e210d3d29075494a075e5cfbf8cb1978033e29f446b2ff021ec187", + "size": 203858, + "subdir": "linux-64", + "timestamp": 1505693623828, + "version": "0.11.14" + }, + "ruamel_yaml-0.11.14-py36ha2fb22d_2.conda": { + "build": "py36ha2fb22d_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "30a76bc318c55864391f2a0d1ecf4ce3", + "name": "ruamel_yaml", + "sha256": "f701632ac34fba4801e1b4f7499356b155207944623964cba67fe23e8b56728a", + "size": 206147, + "subdir": "linux-64", + "timestamp": 1505693648310, + "version": "0.11.14" + }, + "ruamel_yaml-0.15.100-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2eb7fe64858ceaa6fce4e416a1ddb93b", + "name": "ruamel_yaml", + "sha256": "b4f525237005ebb2dab137925bb17f86dc341ba37a55648d15c8f92b5a5e68dc", + "size": 501598, + "subdir": "linux-64", + "timestamp": 1640794466215, + "version": "0.15.100" + }, + "ruamel_yaml-0.15.100-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "acad67bf590fac32c286a96e001e904d", + "name": "ruamel_yaml", + "sha256": "70e8e51c530d1ddb9ef2de5cb3b79e13c56cd0a4e771b0a62fa1919d418d411d", + "size": 259102, + "subdir": "linux-64", + "timestamp": 1616016338933, + "version": "0.15.100" + }, + "ruamel_yaml-0.15.100-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f6854795013ad115c8130f21260adb47", + "name": "ruamel_yaml", + "sha256": "d7a574a3fabcf4e117b782fd7ebc0e3f617733d69acc28db98b873c9787c14bb", + "size": 258892, + "subdir": "linux-64", + "timestamp": 1616016757254, + "version": "0.15.100" + }, + "ruamel_yaml-0.15.100-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c730d152d02992fd6c82a5dffee98f3", + "name": "ruamel_yaml", + "sha256": "d4457afbea7bfb34189d5f7c0b24680ae1ee3a3b39e698c96d0a083cdca22d84", + "size": 263785, + "subdir": "linux-64", + "timestamp": 1616016764495, + "version": "0.15.100" + }, + "ruamel_yaml-0.15.100-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ba3d94b0c7b349f0170c3bb62300f58", + "name": "ruamel_yaml", + "sha256": "35bbe6519e5a31f1511bcde077f91eb9ad082e3fdd193395fce6a4d06a45d50e", + "size": 266294, + "subdir": "linux-64", + "timestamp": 1616016777781, + "version": "0.15.100" + }, + "ruamel_yaml-0.15.35-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "50751841df41b59167afbca1ebfafdb5", + "name": "ruamel_yaml", + "sha256": "af8dad00cb37bf2826c01311fb913cef713f8b90ca6578642840b5086586d065", + "size": 238254, + "subdir": "linux-64", + "timestamp": 1516376506124, + "version": "0.15.35" + }, + "ruamel_yaml-0.15.35-py27h14c3975_1.conda": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ecdf709a67b79c8e4bca0778f456186f", + "name": "ruamel_yaml", + "sha256": "a969216a1720a9cc6ed4e07c2e3a38aa2dbe67fe78d3520a9c02ffc9b3ab7cef", + "size": 238499, + "subdir": "linux-64", + "timestamp": 1516390673535, + "version": "0.15.35" + }, + "ruamel_yaml-0.15.35-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "yaml", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f71a55dbb8909f6b74aba8c93dca9939", + "name": "ruamel_yaml", + "sha256": "ac93ea3c2d9b7ab02e17a4a2bdcd4a72022c09d63c8b1e9d3e687016c1e7a4a5", + "size": 239911, + "subdir": "linux-64", + "timestamp": 1516376768265, + "version": "0.15.35" + }, + "ruamel_yaml-0.15.35-py35h14c3975_1.conda": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "yaml", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f52a0db4da205833ee8b9e3da797e5f2", + "name": "ruamel_yaml", + "sha256": "4cb2e27afa6fcbc616e78545854674e1d18a58b3721351d7b0a982accb803f7d", + "size": 240823, + "subdir": "linux-64", + "timestamp": 1516390727612, + "version": "0.15.35" + }, + "ruamel_yaml-0.15.35-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "88e6bac15d2203963411d4254df35275", + "name": "ruamel_yaml", + "sha256": "6e0f9b963c3db7897958089e2b875335f734dd7c7a3c90151719044f6320d8b8", + "size": 242427, + "subdir": "linux-64", + "timestamp": 1516376763405, + "version": "0.15.35" + }, + "ruamel_yaml-0.15.35-py36h14c3975_1.conda": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da453b980e36b278a0c03d7bd86d1ee5", + "name": "ruamel_yaml", + "sha256": "e786913187102d59697f4e4d49410f5c9dfbdd09acf1eccc9b8b481676907e6a", + "size": 241824, + "subdir": "linux-64", + "timestamp": 1516390695669, + "version": "0.15.35" + }, + "ruamel_yaml-0.15.37-py27h14c3975_2.conda": { + "build": "py27h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d28d95ff25118c7445b16937bf2ac71d", + "name": "ruamel_yaml", + "sha256": "21215773f2bfd2992d5073e7bb2c3a788f04a3f68e2575c3e2bc2386141d76cf", + "size": 238046, + "subdir": "linux-64", + "timestamp": 1528212215481, + "version": "0.15.37" + }, + "ruamel_yaml-0.15.37-py35h14c3975_2.conda": { + "build": "py35h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cec45f310dd8febd00f97c78bd8c0b49", + "name": "ruamel_yaml", + "sha256": "52ec112328cd9c8e7de248bd6201f9eba67835e5b99e340d1e5efbe4b9450158", + "size": 239271, + "subdir": "linux-64", + "timestamp": 1528212332576, + "version": "0.15.37" + }, + "ruamel_yaml-0.15.37-py36h14c3975_2.conda": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c89e5b1f1ff3f207a5164b2b246877b", + "name": "ruamel_yaml", + "sha256": "8764c12c68e7f3e464d8a4c91c0b3c2138cd7f7e1e77e0bf87b41abb68e66fba", + "size": 242252, + "subdir": "linux-64", + "timestamp": 1528212301550, + "version": "0.15.37" + }, + "ruamel_yaml-0.15.40-py27h14c3975_2.conda": { + "build": "py27h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95a0dd94ad26aea82be9cec39b5ed26a", + "name": "ruamel_yaml", + "sha256": "9530afd0761b78bc3f7d8c3d2fa4693bbae7963b424ea44920b89199f2b4b1ac", + "size": 239699, + "subdir": "linux-64", + "timestamp": 1529355959657, + "version": "0.15.40" + }, + "ruamel_yaml-0.15.40-py35h14c3975_2.conda": { + "build": "py35h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4fac1d9c217d79f4142f9b6314c1ab0d", + "name": "ruamel_yaml", + "sha256": "d5d00b7a657df095000c56042c448bc1d6c45845a5aa1ecf168fe232c93cf8af", + "size": 241176, + "subdir": "linux-64", + "timestamp": 1529355936234, + "version": "0.15.40" + }, + "ruamel_yaml-0.15.40-py36h14c3975_2.conda": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a16fdd5b90b5c09c3a3926414d7a8403", + "name": "ruamel_yaml", + "sha256": "9674a2b5ca8ad6a1ef0e2e574539b5dda99fdfab835ac5ca428302d810a9dccf", + "size": 243177, + "subdir": "linux-64", + "timestamp": 1529355882967, + "version": "0.15.40" + }, + "ruamel_yaml-0.15.42-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c8af5cc42d882561100cd9a22a7f0cff", + "name": "ruamel_yaml", + "sha256": "302445f27bbd2bc4bc9ca85826a717626e79a792eb657acb71b8f2ef7713d7f5", + "size": 239637, + "subdir": "linux-64", + "timestamp": 1530548930123, + "version": "0.15.42" + }, + "ruamel_yaml-0.15.42-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52633e3e6545ba380fd7f5c197708e4a", + "name": "ruamel_yaml", + "sha256": "c48ec4434e7276fd952f0c49fa309e49838b95a93e49c159c21c1f6e8f422dab", + "size": 240519, + "subdir": "linux-64", + "timestamp": 1530548846675, + "version": "0.15.42" + }, + "ruamel_yaml-0.15.42-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d92095b5b80ebb09208eaef5bd44cde4", + "name": "ruamel_yaml", + "sha256": "aeb858912bb9772533da862f468b325dfc6ecbbe4af20acc9d171d9a5daa61cf", + "size": 243654, + "subdir": "linux-64", + "timestamp": 1530548857867, + "version": "0.15.42" + }, + "ruamel_yaml-0.15.42-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a80ccb23dd30427ea8d82d70301fb925", + "name": "ruamel_yaml", + "sha256": "24f6a6c7e4c599d1711b7f9978228a4a99649c911af1ab2068a0be018580f922", + "size": 242033, + "subdir": "linux-64", + "timestamp": 1530737412735, + "version": "0.15.42" + }, + "ruamel_yaml-0.15.46-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "142f69f6f5d77005faedf450d4248fe4", + "name": "ruamel_yaml", + "sha256": "2fb0c9b46652747c4f1633253ea8e271d02d1b551fddaa13493a406d45bd5d5a", + "size": 239515, + "subdir": "linux-64", + "timestamp": 1532968689673, + "version": "0.15.46" + }, + "ruamel_yaml-0.15.46-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc890314c1b025b6408d84af02cc7432", + "name": "ruamel_yaml", + "sha256": "40962ece25ef505d138e0ed129ede7e078691e48c76e9ca44a2469d7746ce74f", + "size": 241310, + "subdir": "linux-64", + "timestamp": 1532968917187, + "version": "0.15.46" + }, + "ruamel_yaml-0.15.46-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa35814f004f7d6602916222b371cf90", + "name": "ruamel_yaml", + "sha256": "80893ee2980ef72833eac601e7d0039c068834214a15913eee227d3734888f1c", + "size": 243402, + "subdir": "linux-64", + "timestamp": 1532968829687, + "version": "0.15.46" + }, + "ruamel_yaml-0.15.46-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1c2c52f33f5a1ab8e66ebb3a1916ea5", + "name": "ruamel_yaml", + "sha256": "916082c64658f0ac402d21af2a855fe631ded27671a564f16b3e999181db3d2e", + "size": 242441, + "subdir": "linux-64", + "timestamp": 1532968916601, + "version": "0.15.46" + }, + "ruamel_yaml-0.15.80-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8ff431e87704896bfeb19df2cf83923f", + "name": "ruamel_yaml", + "sha256": "74d744ad5fcb5beb56fed4159f483cc00e1081dfcafef10e9e4769f2dc9e5124", + "size": 257040, + "subdir": "linux-64", + "timestamp": 1605527280571, + "version": "0.15.80" + }, + "ruamel_yaml-0.15.80-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cfab7ebfcca957334023e18a85f73815", + "name": "ruamel_yaml", + "sha256": "1c4995789b19f8a4f8ce942662ea0391e2109f18239bc49a9b12436044fd3dee", + "size": 255934, + "subdir": "linux-64", + "timestamp": 1605527318938, + "version": "0.15.80" + }, + "ruamel_yaml-0.15.80-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fceefb250d0e59289783e9f1e921f8b7", + "name": "ruamel_yaml", + "sha256": "faf816a04ddd8008346cb51a82fcefc70b730b77fd776ba9deecca69d2ec60af", + "size": 262165, + "subdir": "linux-64", + "timestamp": 1605527348218, + "version": "0.15.80" + }, + "ruamel_yaml-0.15.80-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ee8eec6ec7e22c2b86b6ba197bf7f97", + "name": "ruamel_yaml", + "sha256": "d037687791b98d963ff0d4bbd8cc5b021a76009d45ae55a0ad79f06327301ef9", + "size": 262128, + "subdir": "linux-64", + "timestamp": 1605527334248, + "version": "0.15.80" + }, + "ruamel_yaml-0.15.87-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c8eced3002d899a3f1738106273e561", + "name": "ruamel_yaml", + "sha256": "324db5e2569447380852613cf131a004187c807a4842eb561b3ec2f8f5ee2969", + "size": 254778, + "subdir": "linux-64", + "timestamp": 1576853131498, + "version": "0.15.87" + }, + "ruamel_yaml-0.15.87-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f4aad52c2bfacc842c94dc9d8c8fd4f", + "name": "ruamel_yaml", + "sha256": "d09aeca8fdf6bbd46363c47248487b12263676394e8da9317d8572044600c096", + "size": 263470, + "subdir": "linux-64", + "timestamp": 1576853114123, + "version": "0.15.87" + }, + "ruamel_yaml-0.15.87-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80453bafaba5c2a803e49309ac1ca0b8", + "name": "ruamel_yaml", + "sha256": "f623b71b5b7cc6da2933929269ea51a00804d4e37b30bdc20ac6e9c1d7d0c077", + "size": 249841, + "subdir": "linux-64", + "timestamp": 1593122477432, + "version": "0.15.87" + }, + "ruamel_yaml-0.15.87-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec84cc25993d5411ca6437049f83986b", + "name": "ruamel_yaml", + "sha256": "8e90ff8ea312e3807aad044170fa5aedfb05929b5a23f8182153211a50333943", + "size": 262250, + "subdir": "linux-64", + "timestamp": 1576853112471, + "version": "0.15.87" + }, + "ruamel_yaml-0.15.87-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9cbb160fc171c8cb14b410fb64bb23eb", + "name": "ruamel_yaml", + "sha256": "68f14c77c31eb32d7e88f21e5ed62fd8cceb6e6b077d772e3fb8311c3f12a67d", + "size": 251236, + "subdir": "linux-64", + "timestamp": 1593122487619, + "version": "0.15.87" + }, + "ruamel_yaml-0.15.87-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.1.7,<0.2.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cfd8f5ab644fd959e5b2a0cb02ca5af5", + "name": "ruamel_yaml", + "sha256": "e9ae26b2e3a541d802508713905acdbc9dbb756bcfcb596be850afadd7493a46", + "size": 265525, + "subdir": "linux-64", + "timestamp": 1573200629718, + "version": "0.15.87" + }, + "ruamel_yaml-0.15.87-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "yaml >=0.2.5,<0.3.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1f64f06dc6186274acab564d3c59b9c", + "name": "ruamel_yaml", + "sha256": "f9c15c4158c6ddf25c13cd1da7f235c74865e6c2082268659fe334ba37bb2741", + "size": 255264, + "subdir": "linux-64", + "timestamp": 1593122490615, + "version": "0.15.87" + }, + "ruamel_yaml-0.17.21-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "ruamel.yaml.clib >=0.2.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0816607db60c22f3a086c6e916b07139", + "name": "ruamel_yaml", + "sha256": "1706afe40b00134aa03816c36b7838b78d8e95ff730727f8229a1d788be9b59d", + "size": 193828, + "subdir": "linux-64", + "timestamp": 1667489766326, + "version": "0.17.21" + }, + "ruamel_yaml-0.17.21-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "82cefb7e1675a2664cad7a4a71c535ff", + "name": "ruamel_yaml", + "sha256": "9a397bd2db5d5ffcd5417c29f03a297ca9b4e6ac7a8743e9ec0fc0de7d1eb89a", + "size": 251928, + "subdir": "linux-64", + "timestamp": 1676845723933, + "version": "0.17.21" + }, + "ruamel_yaml-0.17.21-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "ruamel.yaml.clib >=0.2.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f983803fa674e489c92febaa919bbab", + "name": "ruamel_yaml", + "sha256": "697278d3396354cf584a03a84d8293bd0ca0153d5ec35924fce0a4736be4b367", + "size": 189859, + "subdir": "linux-64", + "timestamp": 1667489829091, + "version": "0.17.21" + }, + "ruamel_yaml-0.17.21-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "ruamel.yaml.clib >=0.2.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d5134844793f0310ce1eb02d71640f4", + "name": "ruamel_yaml", + "sha256": "a90713b5ebb308109e93ff88c7c3d707eb1500dd341979b49a74909027b9a00b", + "size": 191048, + "subdir": "linux-64", + "timestamp": 1667489860744, + "version": "0.17.21" + }, + "ruamel_yaml-0.17.21-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "ruamel.yaml.clib >=0.2.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e8842c64d5d4904d85051f7524f4dae", + "name": "ruamel_yaml", + "sha256": "4ae9b7868dfb7c068a875b8c59e0937c6ca0000d099b9e9cd8830c6122b239cf", + "size": 191108, + "subdir": "linux-64", + "timestamp": 1667489797680, + "version": "0.17.21" + }, + "ruby-2.4.1-h8a22fef_0.conda": { + "build": "h8a22fef_0", + "build_number": 0, + "depends": [ + "gmp 6.1.*", + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "readline 7.*", + "tk 8.6.*", + "yaml", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2", + "license_family": "GPL", + "md5": "e39dc48a5933295f9029d569f2280366", + "name": "ruby", + "sha256": "8cbd243044a991327de594ea67a5a105b4557103a836b3d03a11c0a8e0069661", + "size": 4404703, + "subdir": "linux-64", + "timestamp": 1505734357389, + "track_features": "", + "version": "2.4.1" + }, + "ruby-2.4.1-hd4a244d_0.conda": { + "build": "hd4a244d_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2m,<1.0.3a", + "readline >=7.0,<8.0a0", + "tk >=8.6.7,<8.7.0a0", + "yaml >=0.1.7,<0.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2", + "license_family": "GPL", + "md5": "82526a9dec4916bbc498dd0aa15a7624", + "name": "ruby", + "sha256": "f14d43c031580c111914f11796944c19dacd5f4239847030a00a5d7a518f01c9", + "size": 4392138, + "subdir": "linux-64", + "timestamp": 1510610977001, + "track_features": "", + "version": "2.4.1" + }, + "ruby-2.4.4-hdc09616_0.conda": { + "build": "hdc09616_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "tk >=8.6.7,<8.7.0a0", + "yaml >=0.1.7,<0.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2", + "license_family": "GPL", + "md5": "f5c1fa7e59e38e7e4759bde2d177a613", + "name": "ruby", + "sha256": "f342b15f19394690adee8903da31aab31bbebf51f9300757063c588e408b4243", + "size": 4403028, + "subdir": "linux-64", + "timestamp": 1527866494571, + "track_features": "", + "version": "2.4.4" + }, + "ruby-2.5.1-h070849d_0.conda": { + "build": "h070849d_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "readline >=7.0,<8.0a0", + "tk >=8.6.7,<8.7.0a0", + "yaml >=0.1.7,<0.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2", + "license_family": "GPL", + "md5": "3d427f8f7cb2eec73f3a05ff1d8a184c", + "name": "ruby", + "sha256": "4ddae7d8cc21a71489f636888d533be4715c04ab13579119f9cfeb80fbf0e05a", + "size": 4492359, + "subdir": "linux-64", + "timestamp": 1532875288807, + "track_features": "", + "version": "2.5.1" + }, + "ruby-2.5.1-h7fb2391_0.conda": { + "build": "h7fb2391_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "readline >=7.0,<8.0a0", + "tk >=8.6.8,<8.7.0a0", + "yaml >=0.1.7,<0.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2", + "license_family": "GPL", + "md5": "90650f11fc48c62be57c0966bdb3b20d", + "name": "ruby", + "sha256": "317f9d99a90ea478f8d9b9ae026a4f7145962b0caf2db2852687710389e1fc16", + "size": 4499279, + "subdir": "linux-64", + "timestamp": 1540331435939, + "track_features": "", + "version": "2.5.1" + }, + "ruby-2.5.1-haf1161a_0.conda": { + "build": "haf1161a_0", + "build_number": 0, + "depends": [ + "gmp >=6.1.2", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1e,<1.1.2a", + "readline >=8.0,<9.0a0", + "tk >=8.6.8,<8.7.0a0", + "yaml >=0.1.7,<0.2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL v2", + "license_family": "GPL", + "md5": "e35469b8be6e2254ef2acc3c74abbe36", + "name": "ruby", + "sha256": "b91d7faf26022f2649cb2b035fd35b29cf8c5d05175751852442ed7c3b09f154", + "size": 4495613, + "subdir": "linux-64", + "timestamp": 1585235786205, + "track_features": "", + "version": "2.5.1" + }, + "ruby-3.1.2-h006b21b_1.conda": { + "build": "h006b21b_1", + "build_number": 1, + "depends": [ + "gdbm >=1.18,<1.19.0a0", + "gmp >=6.1.2", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1s,<1.1.2a", + "readline >=8.0,<9.0a0", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "2e0bc5c668b1574e28e9efa2d50d7058", + "name": "ruby", + "sha256": "be7e577d0c30063d673c625ad3f9f2bad7ea64dd8ae7c46cdb84725b8942e662", + "size": 8428448, + "subdir": "linux-64", + "timestamp": 1669296053447, + "track_features": "rb31", + "version": "3.1.2" + }, + "ruby-3.1.2-h437172d_0.conda": { + "build": "h437172d_0", + "build_number": 0, + "depends": [ + "gdbm >=1.18,<1.19.0a0", + "gmp >=6.1.2", + "libffi >=3.3,<3.4.0a0", + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0", + "openssl >=1.1.1q,<1.1.2a", + "readline >=8.0,<9.0a0", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c0fafec813b551b338d941ae28cf2b56", + "name": "ruby", + "sha256": "6632de20dd2a228fb3c853306e8836710426ffb9c6d0282faf71edfa5a283a48", + "size": 7544841, + "subdir": "linux-64", + "timestamp": 1658957971397, + "track_features": "rb31", + "version": "3.1.2" + }, + "runipy-0.1.5-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=2.7,<2.8.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d4978f5aa6dad6f57838ed57cf8d708f", + "name": "runipy", + "sha256": "da03eafc4c7065b47b1de54aa408d50b045be4b71b7f9c88dc6ada7648c4a238", + "size": 17871, + "subdir": "linux-64", + "timestamp": 1537812399290, + "version": "0.1.5" + }, + "runipy-0.1.5-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=3.10,<3.11.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "2cb485eb335be4246756297dbb709ac6", + "name": "runipy", + "sha256": "1a7ae6482aaba6e9d6dd4e5cfcceba117d5c2a22db280bf95dcef0488c644b94", + "size": 17945, + "subdir": "linux-64", + "timestamp": 1641917394809, + "version": "0.1.5" + }, + "runipy-0.1.5-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=3.5,<3.6.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ba94dbe2808f72b2b8ca598640f2d4f9", + "name": "runipy", + "sha256": "01e97f5295e78c4b349858775d79c046cb52915ac6ea0b3eac783854140ad3fd", + "size": 17844, + "subdir": "linux-64", + "timestamp": 1537812437565, + "version": "0.1.5" + }, + "runipy-0.1.5-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=3.6,<3.7.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "441a7b0fb0e082e0fb9b43b0f7c3ffbf", + "name": "runipy", + "sha256": "2260ac37f56cede98cf5ab41dfd6a4c031bcb730191295a1ec1b70fd525707ae", + "size": 17716, + "subdir": "linux-64", + "timestamp": 1537812443378, + "version": "0.1.5" + }, + "runipy-0.1.5-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=3.6,<3.7.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "f7ca79a568922b65fd1b32829bb9e8c6", + "name": "runipy", + "sha256": "1d7bc2ce365dd9b411c66296fea26fb1489ab6995dca90f10e1db482b7ad7e4d", + "size": 19687, + "subdir": "linux-64", + "timestamp": 1613492723567, + "version": "0.1.5" + }, + "runipy-0.1.5-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=3.7,<3.8.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a6a92a1fe5af84f0a1bc8dd547946990", + "name": "runipy", + "sha256": "7bbb16151a62c1a5105dfbbfc66b469d74f0a5431ebcdc9aa5a8c2a28df10797", + "size": 17753, + "subdir": "linux-64", + "timestamp": 1537812377945, + "version": "0.1.5" + }, + "runipy-0.1.5-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=3.7,<3.8.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "60e46d6a871f60542a89f02526996609", + "name": "runipy", + "sha256": "5d649f384e5e926ae094d5095a25534d313b5969c66272ab229d7391925b8299", + "size": 19563, + "subdir": "linux-64", + "timestamp": 1613493343205, + "version": "0.1.5" + }, + "runipy-0.1.5-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=3.8,<3.9.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "810dd2659c03dd3b63c13bccfa8da4f2", + "name": "runipy", + "sha256": "d55783afa633318ca10cfa69960020b57f92bb7aa62dd1c22a64794edad24415", + "size": 19600, + "subdir": "linux-64", + "timestamp": 1592494391084, + "version": "0.1.5" + }, + "runipy-0.1.5-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=3.8,<3.9.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3e72a7fe32ff591cf86fcf623ce84ab8", + "name": "runipy", + "sha256": "c85a632dff3dcd5b4ffc6cfc2d15ccf718c783a0ef9eb97fd0b6d78936aff83c", + "size": 19666, + "subdir": "linux-64", + "timestamp": 1613493338897, + "version": "0.1.5" + }, + "runipy-0.1.5-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "ipykernel >=4.0.0", + "ipython >=2.3.1", + "jinja2 >=2.7.2", + "nbconvert >=4.0.0", + "nbformat >=4.0.0", + "pygments >=1.6", + "python >=3.9,<3.10.0a0", + "pyzmq >=14.1.0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "347eeb34098af4565d139243ce713056", + "name": "runipy", + "sha256": "29ffb9cfa3afb977e01ac5a304188b079f58eb74cae2f67a6dcf56eb05b66c66", + "size": 19642, + "subdir": "linux-64", + "timestamp": 1613492901270, + "version": "0.1.5" + }, + "rust-1.29.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MIT", + "md5": "dbb8fdc51822985e6cd9789c00539529", + "name": "rust", + "sha256": "2fc3232500b1de3d80e42865be638c5a61eef7d895ca5a439efecb69f5404e10", + "size": 117732050, + "subdir": "linux-64", + "timestamp": 1538132159927, + "version": "1.29.0" + }, + "rust-1.38.0-1.conda": { + "build": "1", + "build_number": 1, + "depends": [], + "license": "MIT", + "md5": "c6bd4e317b7bdbd10e3ecfb1dfc1889b", + "name": "rust", + "sha256": "651afb70325ce01d23843a55b70c42bc0ea7c435a64b634f572c1c4b6cb91b72", + "size": 239508082, + "subdir": "linux-64", + "timestamp": 1578326684608, + "version": "1.38.0" + }, + "rust-1.40.0-1.conda": { + "build": "1", + "build_number": 1, + "depends": [], + "license": "MIT", + "md5": "92800037e3a0c05d9b4fe7f71cfcfc0e", + "name": "rust", + "sha256": "99f603bee5f4df8fb9a9fbdd9533e394e5446191fb86d336b2c29312dad32c4f", + "size": 82821240, + "subdir": "linux-64", + "timestamp": 1578437392548, + "version": "1.40.0" + }, + "rust-1.46.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MIT", + "md5": "e559205c01fc48fc66eb73734ba94ea6", + "name": "rust", + "sha256": "478866474b8d4c70085bc07dc77477bbaa5433f272d6c787784e68450a7de026", + "size": 98816090, + "subdir": "linux-64", + "timestamp": 1601251303126, + "version": "1.46.0" + }, + "rust-1.54.0-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MIT", + "md5": "c853884bcdfec1ccb7a55c08a1c3da6a", + "name": "rust", + "sha256": "dffe2208ddd5e85b0a497346eacdbc14b2bb1b4723a067166cfd25a153ce341a", + "size": 111284343, + "subdir": "linux-64", + "timestamp": 1628283936659, + "version": "1.54.0" + }, + "rust-1.56.0-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MIT", + "md5": "5ec7d2b7fe8ebc563287f288a7dc15ed", + "name": "rust", + "sha256": "0830aa75a6993250411f7dc50623a4143f8b09bd85a627ae4efd8982368e3eb2", + "size": 112288158, + "subdir": "linux-64", + "timestamp": 1644236472385, + "version": "1.56.0" + }, + "rust-1.64.0-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "MIT AND Apache-2.0", + "license_family": "OTHER", + "md5": "b797c2456012631c979bffae6157d62d", + "name": "rust", + "sha256": "f8dda30ae1ea9355d7ff76201034e74c6e39723118101be9354d28034fbf90d1", + "size": 197418964, + "subdir": "linux-64", + "timestamp": 1667949550954, + "version": "1.64.0" + }, + "rust-nightly-1.30.0_2018_09_30-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MIT", + "md5": "50ef4f179c902768d67b4b41dad6d1bd", + "name": "rust-nightly", + "sha256": "1e89a12aa7390d3791bb7ac3f978fc12c0e2c31ccbf2047e9d98cd0bffd60655", + "size": 115676919, + "subdir": "linux-64", + "timestamp": 1538392465570, + "version": "1.30.0_2018_09_30" + }, + "rust-nightly_linux-64-1.30.0_2018_09_30-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "rust-nightly 1.30.0_2018_09_30.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa239597c742f74b9961dafe705ff3e6", + "name": "rust-nightly_linux-64", + "sha256": "e502b19e73993922165271b1b19c2039eff7db02106e5c1d92310efe2574e204", + "size": 5305, + "subdir": "linux-64", + "timestamp": 1538405867619, + "version": "1.30.0_2018_09_30" + }, + "rust_linux-64-1.29.0-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "rust" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85500ae595bfba960512a9fc8ece8f8b", + "name": "rust_linux-64", + "sha256": "11056ee89387dbca9a2e5545ddd764b54aa2a02fb2cf071c23c19aa110e5e16e", + "size": 8356, + "subdir": "linux-64", + "timestamp": 1538173510721, + "version": "1.29.0" + }, + "rust_linux-64-1.38.0-he6710b0_1.conda": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "rust >=1.38.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f3ba0efc930731b54466b410a054f83", + "name": "rust_linux-64", + "sha256": "2b3f831ee994e98840a3706e206a6ae19d96d1d6f0bd8b99eb98cfd7e5741969", + "size": 179323, + "subdir": "linux-64", + "timestamp": 1578413385278, + "version": "1.38.0" + }, + "rust_linux-64-1.40.0-he6710b0_1.conda": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "rust >=1.40.0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "4ed7053aec36bd8ca08aa17322b5a0d7", + "name": "rust_linux-64", + "sha256": "06c41ce318ccc1f6b2fe9dfd08f3c6efe3a8ee79b1193d779346b78395378594", + "size": 180166, + "subdir": "linux-64", + "timestamp": 1578438200996, + "version": "1.40.0" + }, + "rust_linux-64-1.46.0-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 7.3.0.*", + "gxx_linux-64 7.3.0.*", + "rust >=1.46.0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "fde7652a22f2b3280d8268e01e6b110a", + "name": "rust_linux-64", + "sha256": "6efaa1ec5255a4c240c634589c09052a7949f2341fd4a911d454c50d36846065", + "size": 211931, + "subdir": "linux-64", + "timestamp": 1601256610346, + "version": "1.46.0" + }, + "rust_linux-64-1.46.0-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "gcc_linux-64", + "gxx_linux-64", + "rust >=1.46.0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "0c71305a38684322a05f3a8ff08b50de", + "name": "rust_linux-64", + "sha256": "c75c4c0baa58d115e3c9a724fa204ab2a3cc032d2b9e8a34d7b2d73b0b191745", + "size": 210688, + "subdir": "linux-64", + "timestamp": 1601256699279, + "version": "1.46.0" + }, + "rust_linux-64-1.56.0-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 7.5.0.*", + "gxx_linux-64 7.5.0.*", + "rust >=1.56.0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "99349ba3920ce27f8bbc587b0e23c5f3", + "name": "rust_linux-64", + "sha256": "8807324f6cc7eb70674603e1c1ade05f3731c4c11c0754d9cadafd373f2ccdc9", + "size": 10797, + "subdir": "linux-64", + "timestamp": 1644236898618, + "version": "1.56.0" + }, + "rust_linux-64-1.64.0-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 11.2.0.*", + "gxx_linux-64 11.2.0.*", + "rust >=1.64.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "509ed69c1dbb06a653931daf3bea3974", + "name": "rust_linux-64", + "sha256": "e5bafe6f96571d7c13a189c9bc14d44c90458f2ec36e02be082d75a685e5f782", + "size": 8479, + "subdir": "linux-64", + "timestamp": 1667954527423, + "version": "1.64.0" + }, + "rust_linux-64-1.64.0-h6a678d5_1.conda": { + "build": "h6a678d5_1", + "build_number": 1, + "depends": [ + "gcc_linux-64 11.2.0.*", + "gxx_linux-64 11.2.0.*", + "rust >=1.64.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "35aa8ca975570a6f135919fe28daa134", + "name": "rust_linux-64", + "sha256": "fa948c56c9f92d60becd29036eb6a83b5d77a04561e9d2bf4c4afbe9b66f921f", + "size": 8491, + "subdir": "linux-64", + "timestamp": 1670833656584, + "version": "1.64.0" + }, + "s3fs-0.1.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5d245c6ee776c95a68bfb6d3683120db", + "name": "s3fs", + "sha256": "d3acab8af6319e2e35ef5ddca143f821a0594546511fde59273a485d411df82a", + "size": 32562, + "subdir": "linux-64", + "timestamp": 1519757907827, + "version": "0.1.3" + }, + "s3fs-0.1.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "04100a277e60780387a81bab659301e2", + "name": "s3fs", + "sha256": "745274d6871217b2f8931a6a7f6a813526931651480fbbb62286579ffd199d93", + "size": 33412, + "subdir": "linux-64", + "timestamp": 1519757955228, + "version": "0.1.3" + }, + "s3fs-0.1.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cac6afa89120907d1f6df2ab80511681", + "name": "s3fs", + "sha256": "af4319f9786ac411cfc93a84f197d12fa06c723ff62b4844455d55f1c308f502", + "size": 32976, + "subdir": "linux-64", + "timestamp": 1519757890218, + "version": "0.1.3" + }, + "s3fs-0.1.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7e73fba2af448a2382919af27ab45b1d", + "name": "s3fs", + "sha256": "14fe9d69eee849da50183250942cce1381ba42576c8bd5df87cd1995c5be3296", + "size": 32990, + "subdir": "linux-64", + "timestamp": 1522194993255, + "version": "0.1.4" + }, + "s3fs-0.1.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "973dccc7d40e0277980bd0df3b82fdca", + "name": "s3fs", + "sha256": "a8007dcc2f2822f7935eb4235da9c3d40e24781c5d1c316d9b3f2ffefdcce963", + "size": 33535, + "subdir": "linux-64", + "timestamp": 1522195066409, + "version": "0.1.4" + }, + "s3fs-0.1.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "453948c0404ce14a540ad077c9770bda", + "name": "s3fs", + "sha256": "d1e85ad796081b3b5b4b4da30d5cd22054179583ba145d73b1002ebdc4a8f85d", + "size": 33379, + "subdir": "linux-64", + "timestamp": 1522195069085, + "version": "0.1.4" + }, + "s3fs-0.1.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4a576d6ce1657d844b163ed64942af8a", + "name": "s3fs", + "sha256": "410515589599b71d9744e788461205cd315073413a5c4199c610b543d7fc17a1", + "size": 34764, + "subdir": "linux-64", + "timestamp": 1526916496593, + "version": "0.1.5" + }, + "s3fs-0.1.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "503b0dd3a2606691aa287f2f6a63bbbe", + "name": "s3fs", + "sha256": "5d6faa90550bba180ae98b82b08f62684b1156eadc54d038accecdfb3d90c7f2", + "size": 35420, + "subdir": "linux-64", + "timestamp": 1526916471919, + "version": "0.1.5" + }, + "s3fs-0.1.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e231dead32575f6ce1957247ee3e072d", + "name": "s3fs", + "sha256": "ee6fc15c582a2f6e77271676178f5a94d1ae21813de8b5c10e24e408603c3cdc", + "size": 34896, + "subdir": "linux-64", + "timestamp": 1526916383911, + "version": "0.1.5" + }, + "s3fs-0.1.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cccb2c112248f67a1f041245b9a1a202", + "name": "s3fs", + "sha256": "b550b557ff3e879c754686cfc4f9af1a64b56cdf6805a6ea51eb13c468dc622d", + "size": 35100, + "subdir": "linux-64", + "timestamp": 1530959551376, + "version": "0.1.5" + }, + "s3fs-0.1.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5e6b9fade52bf82ecd330d97ee48af87", + "name": "s3fs", + "sha256": "c8ba6a09be8613e6a3e60f0197654eec49dba82a41aeb29d8768a6cad0ca2318", + "size": 35844, + "subdir": "linux-64", + "timestamp": 1535116751546, + "version": "0.1.6" + }, + "s3fs-0.1.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4fb2f1e68a78ed3e9956f17f425d2040", + "name": "s3fs", + "sha256": "af938666c6871e7f49fab548398b0c2e796fd1c504d4cb9a8e2f9858484fdae3", + "size": 36704, + "subdir": "linux-64", + "timestamp": 1535116756880, + "version": "0.1.6" + }, + "s3fs-0.1.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "975bd03ec330110893009eee2d692c95", + "name": "s3fs", + "sha256": "99234444327b298b54a0d568dfa2d738b3220cd7b8df163cd99e5ad73cf07df1", + "size": 36051, + "subdir": "linux-64", + "timestamp": 1535116687696, + "version": "0.1.6" + }, + "s3fs-0.1.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b4e5229cc720961e7761a9ccbb16624f", + "name": "s3fs", + "sha256": "7995e5fc72355536c8f51ce682f7e01e548e6012f32459b603ac3e6bc054e417", + "size": 36092, + "subdir": "linux-64", + "timestamp": 1535116611470, + "version": "0.1.6" + }, + "s3fs-0.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4b037156ae14a6afe0c28bcaae8d7b86", + "name": "s3fs", + "sha256": "d0123acfa7a6a6ae057be90d123d5704c6b11ccade629639c1c9e9107320f7a3", + "size": 40647, + "subdir": "linux-64", + "timestamp": 1543615026693, + "version": "0.2.0" + }, + "s3fs-0.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "306be4c503598b3dc3147b015470b505", + "name": "s3fs", + "sha256": "777ba4d0fa7e12678e9216ccddcd0019de622ce57092dacf8e376abf54337a6a", + "size": 40859, + "subdir": "linux-64", + "timestamp": 1543615045657, + "version": "0.2.0" + }, + "s3fs-0.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "boto3", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cf1adc35207d9e2c7ef143caedcf926e", + "name": "s3fs", + "sha256": "fdc14c5e9fc12e35d51ced1b3f6511f9f15a4a30067f35735e97069c25b00ff1", + "size": 41062, + "subdir": "linux-64", + "timestamp": 1543614984206, + "version": "0.2.0" + }, + "s3fs-2022.10.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore 2.4.0", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2022.10.0.*", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fdabf872fafd4f1ce341de6f97867f90", + "name": "s3fs", + "sha256": "9419eea9a5746dacfcf4ab0d90d7a5578a8172da7e1c33a0f4d4c9c3e86f4eaa", + "size": 56890, + "subdir": "linux-64", + "timestamp": 1667506066697, + "version": "2022.10.0" + }, + "s3fs-2022.10.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore 2.4.0", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2022.10.0.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0f72e3ed36b47840517affaf0e1524c6", + "name": "s3fs", + "sha256": "d58b9695ddee8c1c69189e5cee2662c790afb6a0104cb18b74a7c0468c81186c", + "size": 55520, + "subdir": "linux-64", + "timestamp": 1667506038588, + "version": "2022.10.0" + }, + "s3fs-2022.10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore 2.4.0", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2022.10.0.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e16eec450d76e941e083acb80bb02ea0", + "name": "s3fs", + "sha256": "d415d835b206855c338222fece1254dd6ee3764f80958c713b26c466de9f23e9", + "size": 55929, + "subdir": "linux-64", + "timestamp": 1667505981886, + "version": "2022.10.0" + }, + "s3fs-2022.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore 2.4.0", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2022.10.0.*", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d27941310f2f160481910d309c70a153", + "name": "s3fs", + "sha256": "da0286db08a01f3c7d56f50dfb4d1b608a73689e1cf49bc12f401a596d0c2198", + "size": 55928, + "subdir": "linux-64", + "timestamp": 1667506010139, + "version": "2022.10.0" + }, + "s3fs-2022.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore 2.4.*", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2022.11.0.*", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "45aa4b0882a705ab9e7fb829caa5622e", + "name": "s3fs", + "sha256": "309a773dd8fed23d7bf188d8db4c461c87391c01d626a3e036181914d3609c76", + "size": 56177, + "subdir": "linux-64", + "timestamp": 1670361805728, + "version": "2022.11.0" + }, + "s3fs-2022.11.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore 2.4.*", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2022.11.0.*", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1c47a0ccd3d5864aeedd5cb9477c8a27", + "name": "s3fs", + "sha256": "09bde61ea20a4255d6d4af8f17c4300e4137823c463765f9cfbab714bba7e5a3", + "size": 71945, + "subdir": "linux-64", + "timestamp": 1676861922701, + "version": "2022.11.0" + }, + "s3fs-2022.11.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore 2.4.*", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2022.11.0.*", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5465985391f502619bbac9b564392b6f", + "name": "s3fs", + "sha256": "8c11a69245844e92d3aa8639d4b7e9a85e11df69409dc0567e4627f09ea622ab", + "size": 54777, + "subdir": "linux-64", + "timestamp": 1670361722473, + "version": "2022.11.0" + }, + "s3fs-2022.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore 2.4.*", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2022.11.0.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4e3bea2df6ae5a4889eec9ccee11d94f", + "name": "s3fs", + "sha256": "1f81ee958046f0022df6a2752e0b8c2bc36a01be296d762276188d7ff02f3bf2", + "size": 55643, + "subdir": "linux-64", + "timestamp": 1670361750517, + "version": "2022.11.0" + }, + "s3fs-2022.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore 2.4.*", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2022.11.0.*", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1fec6ba6a26d269a35929363bbb75364", + "name": "s3fs", + "sha256": "48704721894ea56d540e81774edad1974107199d5399d2176d947c31c5d43bcc", + "size": 55128, + "subdir": "linux-64", + "timestamp": 1670361777881, + "version": "2022.11.0" + }, + "s3fs-2023.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore >=2.4.2,<2.5", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2023.3.0.*", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "582faec50f43f10feabf1c155181b66d", + "name": "s3fs", + "sha256": "682ba801bc865681ac1e12912a6c13dba8632c0c1a095095619e19c4ee5f2a3a", + "size": 57934, + "subdir": "linux-64", + "timestamp": 1680018559041, + "version": "2023.3.0" + }, + "s3fs-2023.3.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore >=2.4.2,<2.5", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2023.3.0.*", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c1bebd95ff466e3a593c7eaa0478afcf", + "name": "s3fs", + "sha256": "73cc46bbd0627e53c703a831047f5f1a92ce87096b97e871a454aca947c8fc03", + "size": 77513, + "subdir": "linux-64", + "timestamp": 1680018531075, + "version": "2023.3.0" + }, + "s3fs-2023.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore >=2.4.2,<2.5", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2023.3.0.*", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "121caef3d58eae6b3d3b1e2e164f3417", + "name": "s3fs", + "sha256": "b42bd16723465112500bf6c62635e30b805187fa97d12eb050a99322955d9c21", + "size": 57136, + "subdir": "linux-64", + "timestamp": 1680018503416, + "version": "2023.3.0" + }, + "s3fs-2023.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiobotocore >=2.4.2,<2.5", + "aiohttp !=4.0.0a0,!=4.0.0a1", + "fsspec 2023.3.0.*", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fcdce04623097353d08656190b32f333", + "name": "s3fs", + "sha256": "40cb790f6e2726b299b7463df7de41d51ae020f71b018f491154a41ea0849489", + "size": 57078, + "subdir": "linux-64", + "timestamp": 1680018585493, + "version": "2023.3.0" + }, + "s3transfer-0.1.10-py27h9fb3302_1.conda": { + "build": "py27h9fb3302_1", + "build_number": 1, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "futures >=2.2.0,<4.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0f4e52d0d98150380d40fad1c97bf366", + "name": "s3transfer", + "sha256": "886da3cdd43f100c36f10ecd4b6dc9b3c51cdad638763414cd24bd2efb2bdc09", + "size": 73075, + "subdir": "linux-64", + "timestamp": 1505741285250, + "version": "0.1.10" + }, + "s3transfer-0.1.10-py35h0bc0b65_1.conda": { + "build": "py35h0bc0b65_1", + "build_number": 1, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "277a2555d4c5962e2a9a0393540a402f", + "name": "s3transfer", + "sha256": "11aea6c3331f3cbb05b208f9fb68a97bf6aba3212e45825882547f65853db13b", + "size": 75977, + "subdir": "linux-64", + "timestamp": 1505741298472, + "version": "0.1.10" + }, + "s3transfer-0.1.10-py36h0257dcc_1.conda": { + "build": "py36h0257dcc_1", + "build_number": 1, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "26cef8eae1e0cc73de965451a6d727a3", + "name": "s3transfer", + "sha256": "cbb6d9b6df2af2e574735db36b379d30352eeef37ca64871f4bf1296ddeed304", + "size": 75386, + "subdir": "linux-64", + "timestamp": 1505741311941, + "version": "0.1.10" + }, + "s3transfer-0.1.11-py27h83d00de_1.conda": { + "build": "py27h83d00de_1", + "build_number": 1, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "futures >=2.2.0,<4.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "eef915385492d064f74454289217809e", + "name": "s3transfer", + "sha256": "7776d27744db6094dd848a4b40c5ae1e6ed66a6b7a0f21ee0e88762ec4be4ca1", + "size": 74982, + "subdir": "linux-64", + "timestamp": 1511320230052, + "version": "0.1.11" + }, + "s3transfer-0.1.11-py35hb3b1e1f_1.conda": { + "build": "py35hb3b1e1f_1", + "build_number": 1, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3f6e423b7bc6fb2881365ba5503cf786", + "name": "s3transfer", + "sha256": "93297ac5ea50b231c94def23dcf1f31b9883b462dcef8ce1f71d97e6bbd7918d", + "size": 75229, + "subdir": "linux-64", + "timestamp": 1511320229352, + "version": "0.1.11" + }, + "s3transfer-0.1.11-py36haba1813_1.conda": { + "build": "py36haba1813_1", + "build_number": 1, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d485768a4a2d2fb7da10748e776dc95d", + "name": "s3transfer", + "sha256": "d13d76c3eb93edcb09d94a668848b3e77ec5429489c340a56419e41612f26732", + "size": 74725, + "subdir": "linux-64", + "timestamp": 1511320232919, + "version": "0.1.11" + }, + "s3transfer-0.1.13-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "futures >=2.2.0,<4.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "52058c000b86c7ba8afceac568adefd0", + "name": "s3transfer", + "sha256": "28de82c821c6dc3c2692ad16db870a7dce3f13b4226744e64da012566fcbf79e", + "size": 79679, + "subdir": "linux-64", + "timestamp": 1519832449290, + "version": "0.1.13" + }, + "s3transfer-0.1.13-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7d49512e50363d42fa43a29cce3c76e4", + "name": "s3transfer", + "sha256": "5935165ae86b984aa005d0328f82bc0bfb92f36da81876740e19729ece0c371d", + "size": 81565, + "subdir": "linux-64", + "timestamp": 1519832478048, + "version": "0.1.13" + }, + "s3transfer-0.1.13-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fc817d71c947c0d33cc8ad459fe4bad8", + "name": "s3transfer", + "sha256": "2423e5deff58f93cff6c6c0e592ed4da6a05ba548f9143f29c076b2487af7b79", + "size": 80821, + "subdir": "linux-64", + "timestamp": 1519832430360, + "version": "0.1.13" + }, + "s3transfer-0.1.13-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.3.0,<2.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bf2667267f534828924ca435e07a55e8", + "name": "s3transfer", + "sha256": "e7cdb1d116a5c0dc8fc41d9b6ef29e9c4f8ed523af6bd782d2dbc351ce9e344b", + "size": 82418, + "subdir": "linux-64", + "timestamp": 1530781291609, + "version": "0.1.13" + }, + "s3transfer-0.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "futures >=2.2.0,<4.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3ee59843779439d18a15adacbf622aa0", + "name": "s3transfer", + "sha256": "d57b53920ecdc286988d7789c5707580876e042acce69c7b13f6d82e70574bd2", + "size": 96201, + "subdir": "linux-64", + "timestamp": 1552343395520, + "version": "0.2.0" + }, + "s3transfer-0.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0d24be908b50937ce99b985a4f33ce0b", + "name": "s3transfer", + "sha256": "bf6b2a3ba72aa2fcea26ccea701c385d54900f915095e8924f797da505db2c3f", + "size": 97398, + "subdir": "linux-64", + "timestamp": 1552343432569, + "version": "0.2.0" + }, + "s3transfer-0.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b6c225773c46ce9075cb6cb23f51f64e", + "name": "s3transfer", + "sha256": "7d3a09960477ecfbf8871ed96d6200041ce027da85f6e6cc19f9380ce966e57d", + "size": 97608, + "subdir": "linux-64", + "timestamp": 1552343372125, + "version": "0.2.0" + }, + "s3transfer-0.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "futures >=2.2.0,<4.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ba3bac3585cbdd8e3c84900911b7faa2", + "name": "s3transfer", + "sha256": "bf5516866b44e4e90eeae13fbfdfba8b8432d7f59173eed64b364b4cb05e2153", + "size": 96957, + "subdir": "linux-64", + "timestamp": 1564755070934, + "version": "0.2.1" + }, + "s3transfer-0.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d2ddb15f0607d2722dd018762a58b28d", + "name": "s3transfer", + "sha256": "2142ab55450a30aa2d4ca5e9b8685ac4f859e3d484686f8a092bf927bd99bbfa", + "size": 100450, + "subdir": "linux-64", + "timestamp": 1564754856743, + "version": "0.2.1" + }, + "s3transfer-0.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bd729f476f42de30875acc0d2ae3272a", + "name": "s3transfer", + "sha256": "550a3d5448df9fcc25f21c21cd6a4993b00799913d6dbbcea9a25d2da6f23ff8", + "size": 100465, + "subdir": "linux-64", + "timestamp": 1564755055293, + "version": "0.2.1" + }, + "s3transfer-0.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "futures >=2.2.0,<4.0.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6e8bb4e39beb67e614d7c105698302bc", + "name": "s3transfer", + "sha256": "2fda17df95ceb8bce602dc5354baffc35de87cf375f3c546e46b7cf5a4e9c891", + "size": 97754, + "subdir": "linux-64", + "timestamp": 1578947872520, + "version": "0.3.0" + }, + "s3transfer-0.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "db80e3f1d579c517ae793a55d4afc3ae", + "name": "s3transfer", + "sha256": "a613d6132e95cc92fa2e88b1ac8ed64374fdfac0fcbcc1c7386bb301e0bb2bf8", + "size": 99132, + "subdir": "linux-64", + "timestamp": 1578947875813, + "version": "0.3.0" + }, + "s3transfer-0.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ce8cce8997c5cc8ac9e0522839bb38f6", + "name": "s3transfer", + "sha256": "2b2d919d30c00d01149bc170be1da258615889a11a391614ca0dec31a4dddb26", + "size": 97606, + "subdir": "linux-64", + "timestamp": 1578947838462, + "version": "0.3.0" + }, + "s3transfer-0.3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c166941cccc12520dbc74cba1a453fc7", + "name": "s3transfer", + "sha256": "a85b72e429de680de2b7d894dae2460401cda819efea3c3fb3e909e8d4ba8049", + "size": 98574, + "subdir": "linux-64", + "timestamp": 1578947878080, + "version": "0.3.0" + }, + "s3transfer-0.3.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b972607da7fa162d4c2a64305cbb67bb", + "name": "s3transfer", + "sha256": "8bdd7522372e60e0db6d5d0c0267f00a87cb16a7d0ddf5b13048f41afbe279db", + "size": 99605, + "subdir": "linux-64", + "timestamp": 1581606261276, + "version": "0.3.3" + }, + "s3transfer-0.3.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ee0cf6f467ef57c57a583bc607253fd6", + "name": "s3transfer", + "sha256": "79c5333757aaee4d837c2388bd293ca7a6de608431db50cc4467cc5b2004ed9b", + "size": 97999, + "subdir": "linux-64", + "timestamp": 1581606263299, + "version": "0.3.3" + }, + "s3transfer-0.3.3-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4d1cbf6f8f22ad39f82e3dbb9438acb0", + "name": "s3transfer", + "sha256": "a1545f07364362c25a1e2b3506e4e725aee48e779de2d07d270b11d5b41a4c7a", + "size": 93789, + "subdir": "linux-64", + "timestamp": 1594420395099, + "version": "0.3.3" + }, + "s3transfer-0.3.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "76b9f045ebe8026e79ac802c88187e57", + "name": "s3transfer", + "sha256": "b6fc496efa6a359998ad597adb11b6ce819425481cc69b7368582c2b7cc22309", + "size": 100619, + "subdir": "linux-64", + "timestamp": 1581606286012, + "version": "0.3.3" + }, + "s3transfer-0.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0a.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "39844887404acefb5cbaf4feed2f9185", + "name": "s3transfer", + "sha256": "d4cd4ed65a8509626ce7aefa657bd372ab3a27a796eefdcf80f0faf939716e9b", + "size": 108589, + "subdir": "linux-64", + "timestamp": 1654524325680, + "version": "0.6.0" + }, + "s3transfer-0.6.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0a.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "785ed92025714e4c0215d08922e39f8f", + "name": "s3transfer", + "sha256": "c1b7187575d532c3c019b461fd4757e7041d1543b18b1b27b3df98bcacdc190c", + "size": 134409, + "subdir": "linux-64", + "timestamp": 1676828822039, + "version": "0.6.0" + }, + "s3transfer-0.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0a.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ae936c3f13f19d93a61e8f59657e1e68", + "name": "s3transfer", + "sha256": "870c5f3716b7b651f3d00bcf18370caf049c85b0572a7c0ba2446f9ca4edf207", + "size": 106297, + "subdir": "linux-64", + "timestamp": 1654524286531, + "version": "0.6.0" + }, + "s3transfer-0.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0a.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "718bc65055dfbc314e007eb446f297ff", + "name": "s3transfer", + "sha256": "c72e6fc2b7230a434d5b3618c94131e9f5664c188df287889db51fc99400f779", + "size": 107102, + "subdir": "linux-64", + "timestamp": 1654524228409, + "version": "0.6.0" + }, + "s3transfer-0.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "botocore >=1.12.36,<2.0a.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dae51ff4af8b4208932538a0f2c29c14", + "name": "s3transfer", + "sha256": "b91876cc9fc9e9a31c3dde30a22d4fd8959308fd26874d70060a525ec40f3375", + "size": 107072, + "subdir": "linux-64", + "timestamp": 1654524258248, + "version": "0.6.0" + }, + "safeint-3.0.26-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01747b1485ced0ce0fdcbfbf41fbf7c8", + "name": "safeint", + "sha256": "10f537fffc1caee56eb4e3ec82a71d85838071ac5d40d6eebdfda08431572ed9", + "size": 36491, + "subdir": "linux-64", + "timestamp": 1659021372274, + "version": "3.0.26" + }, + "sas7bdat-2.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "57dcc0131bb47c185babb8769e1cbe7f", + "name": "sas7bdat", + "sha256": "d4430119597721fd2fc9b7d65b99267df9db16a8675b2ab9d40441f0b1003d62", + "size": 31518, + "subdir": "linux-64", + "timestamp": 1529984027153, + "version": "2.1.1" + }, + "sas7bdat-2.1.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "e8f855545d528182c3d0c40cccb1df33", + "name": "sas7bdat", + "sha256": "8c6a75f156b291fb712322f31c8530d0cf09e15b81e3c736f0f5da01f66e1007", + "size": 31853, + "subdir": "linux-64", + "timestamp": 1529984049144, + "version": "2.1.1" + }, + "sas7bdat-2.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "85de24e6ce9caec568e5a97368b81233", + "name": "sas7bdat", + "sha256": "a05d9181fa2b3e9d4088372832fee11e0a6f67dc74a765d92b6fcde717c7f15f", + "size": 31562, + "subdir": "linux-64", + "timestamp": 1529984000289, + "version": "2.1.1" + }, + "sas7bdat-2.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "98d14ffb353cdd2eb0611900e263619b", + "name": "sas7bdat", + "sha256": "5ef6cb5546498c97e87bffee7e70ff2bb12833984eca58f2806d1545507481c6", + "size": 31810, + "subdir": "linux-64", + "timestamp": 1541048261281, + "version": "2.1.2" + }, + "sas7bdat-2.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "f94e710b7c91f736787384d59b103699", + "name": "sas7bdat", + "sha256": "e77c684586801ea95e8f8244d3f57523a82b58f37f743e15414fc3a287273b88", + "size": 31853, + "subdir": "linux-64", + "timestamp": 1541048279048, + "version": "2.1.2" + }, + "sas7bdat-2.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "e3572ebb953069245b89f0fcc6205821", + "name": "sas7bdat", + "sha256": "dc3bf874a42bb501f7e15f095b7123029a10a4d366a198cafcfa4a27cbd95455", + "size": 31922, + "subdir": "linux-64", + "timestamp": 1541048247873, + "version": "2.1.2" + }, + "sas7bdat-2.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "878ced081f6f87ebb06602af16278411", + "name": "sas7bdat", + "sha256": "ddb5073ec6dfde1dceb093054ce32571455b90e2470d22b10fbf4a4d5ceab50f", + "size": 30296, + "subdir": "linux-64", + "timestamp": 1541443740669, + "version": "2.2.1" + }, + "sas7bdat-2.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "454ee6fcaa2b2ad5cb3ecd1e993502c1", + "name": "sas7bdat", + "sha256": "63621a4699ce88072359e35aa4f15d71900d0d446b882473a4e37300e9212b75", + "size": 30282, + "subdir": "linux-64", + "timestamp": 1541443758255, + "version": "2.2.1" + }, + "sas7bdat-2.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "746e9d029d2e17d085b4c9aa3c484daf", + "name": "sas7bdat", + "sha256": "88b93d8e32c792905420b3de1a98286f913b1a102e9ae7783be97fcc9b1eef4e", + "size": 30344, + "subdir": "linux-64", + "timestamp": 1541443729505, + "version": "2.2.1" + }, + "sas7bdat-2.2.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "f47266a9621c9f58599b9748b873472d", + "name": "sas7bdat", + "sha256": "dfbb21e0f790f66d577926d54f39610009130ab86404d53764d2d04784e31ba8", + "size": 173345, + "subdir": "linux-64", + "timestamp": 1547491110181, + "version": "2.2.2" + }, + "sas7bdat-2.2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "ca7e55cbf963a35d408041e7a760aafd", + "name": "sas7bdat", + "sha256": "64e572c17a8a548e0d442805f022db9594a9766f0e073d8fefa0a1c1583e9278", + "size": 173281, + "subdir": "linux-64", + "timestamp": 1547491191502, + "version": "2.2.2" + }, + "sas7bdat-2.2.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.8.0" + ], + "license": "MIT", + "md5": "63d6b749d1fee92b607f0fe4d2d78fa5", + "name": "sas7bdat", + "sha256": "509971fbe8ce105234c3040cb07176e5fe56f97a1dd76e95f4dda0f65f1a7181", + "size": 173781, + "subdir": "linux-64", + "timestamp": 1547491143249, + "version": "2.2.2" + }, + "sas_kernel-2.1.7-py35h00c0a0d_0.conda": { + "build": "py35h00c0a0d_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "jupyter_client >=4.4.0", + "metakernel >=0.18.0", + "pygments", + "python >=3.5,<3.6.0a0", + "saspy >=1.2.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f78cc380140d9a82aadcc2f3a19c4ecd", + "name": "sas_kernel", + "sha256": "246a80f1f7dcbe667fd4b8b034d3622622c8b8b515c222a62c5b83b34d21c0b6", + "size": 60625, + "subdir": "linux-64", + "timestamp": 1506850596047, + "version": "2.1.7" + }, + "sas_kernel-2.1.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "jupyter_client >=4.4.0", + "metakernel >=0.18.0", + "pygments", + "python >=3.6,<3.7.0a0", + "saspy >=1.2.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "504feb53c2bbe472ac033aac66f1834b", + "name": "sas_kernel", + "sha256": "b1d48f7114bee1ad3b3b51a2ae9995ad99817793415889da4858db666e040c57", + "size": 59978, + "subdir": "linux-64", + "timestamp": 1530959628481, + "version": "2.1.7" + }, + "sas_kernel-2.1.7-py36he3a6759_0.conda": { + "build": "py36he3a6759_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "jupyter_client >=4.4.0", + "metakernel >=0.18.0", + "pygments", + "python >=3.6,<3.7.0a0", + "saspy >=1.2.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9985d303f49ce9d762a63168b45936c1", + "name": "sas_kernel", + "sha256": "1a6491282163637d5a6babe1182dd8199e1e947973f79dfd6ffb7666c5445bac", + "size": 60377, + "subdir": "linux-64", + "timestamp": 1506850606970, + "version": "2.1.7" + }, + "sas_kernel-2.1.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "jupyter_client >=4.4.0", + "metakernel >=0.18.0", + "pygments", + "python >=3.7,<3.8.0a0", + "saspy >=1.2.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "457e5501f2d77d0082aaaed809666b7c", + "name": "sas_kernel", + "sha256": "d9c452b6b51d6f47e10de8b9bdcaf1c0a0729de3903cf97747df271a8f7ae028", + "size": 60061, + "subdir": "linux-64", + "timestamp": 1530959668926, + "version": "2.1.7" + }, + "sas_kernel-2.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "jupyter_client >=4.4.0", + "metakernel >=0.18.0", + "pygments", + "python >=3.6,<3.7.0a0", + "saspy >=1.2.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5dae6bf4bfad936cb33bd8537c30acb0", + "name": "sas_kernel", + "sha256": "e50ff0314a0963cadd98ca54d7a042ede1f52aa9687dae4d68c406eb35efc12b", + "size": 61391, + "subdir": "linux-64", + "timestamp": 1541048865990, + "version": "2.2.0" + }, + "sas_kernel-2.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "jupyter_client >=4.4.0", + "metakernel >=0.18.0", + "pygments", + "python >=3.7,<3.8.0a0", + "saspy >=1.2.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9df3673a3317620a4c335038c0ff8603", + "name": "sas_kernel", + "sha256": "5191d8ffcb5d2be18d9558446eabc1795b36c0316b14138b88f9ab1921d37426", + "size": 61374, + "subdir": "linux-64", + "timestamp": 1541048833774, + "version": "2.2.0" + }, + "sas_kernel-2.3.1-py36_1000.conda": { + "build": "py36_1000", + "build_number": 1000, + "depends": [ + "ipython >=4", + "jupyter_client >=4.4.0", + "metakernel >=0.18.0", + "pygments", + "python >=3.6,<3.7.0a0", + "saspy >=1.2.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4da0da354a3dfa34cb8d5dcb98b3d78e", + "name": "sas_kernel", + "sha256": "f76f31a9102cff8266bc3a9b5e8da903c5131bf8006d33e66297cb07c0daa57d", + "size": 61748, + "subdir": "linux-64", + "timestamp": 1600553258702, + "version": "2.3.1" + }, + "sas_kernel-2.3.1-py37_1000.conda": { + "build": "py37_1000", + "build_number": 1000, + "depends": [ + "ipython >=4", + "jupyter_client >=4.4.0", + "metakernel >=0.18.0", + "pygments", + "python >=3.7,<3.8.0a0", + "saspy >=1.2.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9162817439af8efe8e9f08d72831c1f8", + "name": "sas_kernel", + "sha256": "5200f9af3e311adc7ec9aba6b64155dac707727f32c923dd5bde19be370a2eb0", + "size": 62016, + "subdir": "linux-64", + "timestamp": 1600553297560, + "version": "2.3.1" + }, + "sas_kernel-2.3.1-py38_1000.conda": { + "build": "py38_1000", + "build_number": 1000, + "depends": [ + "ipython >=4", + "jupyter_client >=4.4.0", + "metakernel >=0.18.0", + "pygments", + "python >=3.8,<3.9.0a0", + "saspy >=1.2.2" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0a8d5bdfe6cfbd1588383f178dd6b426", + "name": "sas_kernel", + "sha256": "57588bd3e7a7620ef71f1149b80cb6788694e7eeb663e96be3d287af24bdd744", + "size": 61806, + "subdir": "linux-64", + "timestamp": 1600553274285, + "version": "2.3.1" + }, + "sas_kernel-2.4.10-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.6,<3.7.0a0", + "saspy >=3.6" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e53c5710e05cdf5d9fd8ffaa2b58b731", + "name": "sas_kernel", + "sha256": "8ea10684c5ca398f295c426a7bfd49bbded761c287a9adbd9c75deea5eb05aa6", + "size": 62747, + "subdir": "linux-64", + "timestamp": 1623881406578, + "version": "2.4.10" + }, + "sas_kernel-2.4.10-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.7,<3.8.0a0", + "saspy >=3.6" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "17eb3f49eb70bb7c44c89beac5bb99ec", + "name": "sas_kernel", + "sha256": "3ec69c76a772ebaf662ad34e5b0164f636d486a8b89ea883ed751319afc0d629", + "size": 62942, + "subdir": "linux-64", + "timestamp": 1623881411508, + "version": "2.4.10" + }, + "sas_kernel-2.4.10-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.8,<3.9.0a0", + "saspy >=3.6" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "45234beb6d995369b0871b7b1841ffb7", + "name": "sas_kernel", + "sha256": "5bf0d4274c74805cad9f39019f83b2b1cea466b9fec9d5b413d87375c886d74d", + "size": 61641, + "subdir": "linux-64", + "timestamp": 1623881380953, + "version": "2.4.10" + }, + "sas_kernel-2.4.10-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.9,<3.10.0a0", + "saspy >=3.6" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "958a0572c20ab143f63f1d740af88361", + "name": "sas_kernel", + "sha256": "456a78a3d5b260c75a3551585923e19c91ba95e1b771873d14b20f88ccafcbd7", + "size": 62280, + "subdir": "linux-64", + "timestamp": 1623881375824, + "version": "2.4.10" + }, + "sas_kernel-2.4.11-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.6,<3.7.0a0", + "saspy >=3.6" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cda5607daa55c138b7a3a15d7931dc90", + "name": "sas_kernel", + "sha256": "37d3d4d54b3717d9b00c7899dd70ee56dd05c81128fd888275f3d3510d72ec15", + "size": 62762, + "subdir": "linux-64", + "timestamp": 1626326698966, + "version": "2.4.11" + }, + "sas_kernel-2.4.11-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.7,<3.8.0a0", + "saspy >=3.6" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a8fe9ffea63266c1318c87a49aca05b1", + "name": "sas_kernel", + "sha256": "d89c6d770b65f5472cce3997710d17c4cb9dde7b4c7725ab06d6066aae1c1238", + "size": 62057, + "subdir": "linux-64", + "timestamp": 1626327481956, + "version": "2.4.11" + }, + "sas_kernel-2.4.11-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.8,<3.9.0a0", + "saspy >=3.6" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9c9b8b77996e10d4a1527592bf73b9b5", + "name": "sas_kernel", + "sha256": "c8949f5d8c97c62cafdd19617cc16829c517db39234917c01e4d14fddf7e79c9", + "size": 62203, + "subdir": "linux-64", + "timestamp": 1626320368475, + "version": "2.4.11" + }, + "sas_kernel-2.4.11-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.9,<3.10.0a0", + "saspy >=3.6" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3a9c575ee2477dad35417ba1d96c2111", + "name": "sas_kernel", + "sha256": "991f13811974d75a8b2fc1bf463d761f20e6983bf6fd54730e2c66b35ea2f3c1", + "size": 61912, + "subdir": "linux-64", + "timestamp": 1626327490597, + "version": "2.4.11" + }, + "sas_kernel-2.4.9-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "34b5e182e68246afe7accce29c1f1682", + "name": "sas_kernel", + "sha256": "8f57157f7c1c12450b63d727e96b42a2adbc4da61830c3890cbe880d35a64767", + "size": 58299, + "subdir": "linux-64", + "timestamp": 1620734908029, + "version": "2.4.9" + }, + "sas_kernel-2.4.9-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "977db317d11500a4f6da8011e2a70a4c", + "name": "sas_kernel", + "sha256": "e2fd039fa439abdeb1be33defedb4d28e807ecb82ea78a088d8ff97ed384c9bd", + "size": 58593, + "subdir": "linux-64", + "timestamp": 1620734903100, + "version": "2.4.9" + }, + "sas_kernel-2.4.9-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6e293ce8d30e7cd03380847ea2ef64da", + "name": "sas_kernel", + "sha256": "f433a18e11d980142fc8e1a87723ea3b9611f3d58f51af02eea7b39220cf657d", + "size": 58193, + "subdir": "linux-64", + "timestamp": 1620734716255, + "version": "2.4.9" + }, + "sas_kernel-2.4.9-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ipython >=7.*", + "jupyter_client >=6.*", + "metakernel >=0.27.5", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "78dba06d20fdee7cf1460ab51b79ffd0", + "name": "sas_kernel", + "sha256": "b615799f37fba11c8d51ba0c1ee2245539678fd2e1fd42a7552178a47fce7985", + "size": 58610, + "subdir": "linux-64", + "timestamp": 1620734910969, + "version": "2.4.9" + }, + "sasl-0.2.1-py27h4575015_0.conda": { + "build": "py27h4575015_0", + "build_number": 0, + "depends": [ + "cyrus-sasl 2.1.26.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "151399a8901a33cf52ea3e5ed9f58bbe", + "name": "sasl", + "sha256": "e21a61ae96a83cfa7f18f93c8bc582ace79a0f9e08e2e6b31c8eb2cc6fd9a3b6", + "size": 56253, + "subdir": "linux-64", + "timestamp": 1512156847634, + "version": "0.2.1" + }, + "sasl-0.2.1-py27h779454e_1.conda": { + "build": "py27h779454e_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "34f4b61bc4c69183ab1d6f892ef14c3d", + "name": "sasl", + "sha256": "18f1a73c8b45f00ba84be25bc1e4462991d6940378cda46ba5e74a9c2b0eabed", + "size": 56835, + "subdir": "linux-64", + "timestamp": 1537825554438, + "version": "0.2.1" + }, + "sasl-0.2.1-py27hf484d3e_1.conda": { + "build": "py27hf484d3e_1", + "build_number": 1, + "depends": [ + "cyrus-sasl 2.1.26.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1b95a3b26509a7b6bbc121ca21ce94e7", + "name": "sasl", + "sha256": "86621eacaa5dd3afcc1425c0e523bc79ce8ab84d744fb3ce7c3f6c3cfe643f7f", + "size": 55985, + "subdir": "linux-64", + "timestamp": 1518809283823, + "version": "0.2.1" + }, + "sasl-0.2.1-py310h42fbc30_2.conda": { + "build": "py310h42fbc30_2", + "build_number": 2, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6a85ff081fc26a18833482599e4dedc6", + "name": "sasl", + "sha256": "05264fc8f3989f38806f67fd4335a01ee872e245e3b28db0a5efdd5fa4e142fc", + "size": 206460, + "subdir": "linux-64", + "timestamp": 1656584551767, + "version": "0.2.1" + }, + "sasl-0.2.1-py310h48830cd_1.conda": { + "build": "py310h48830cd_1", + "build_number": 1, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7ddb4d69fc49eb2b7a78422ca458901a", + "name": "sasl", + "sha256": "cc6f386aadf5ff4a60e68b39e2ae8f831a3f84f6d4c406efad313a3c00bb3172", + "size": 161379, + "subdir": "linux-64", + "timestamp": 1640794496551, + "version": "0.2.1" + }, + "sasl-0.2.1-py35h779454e_1.conda": { + "build": "py35h779454e_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "556b9dee9450aabf89ced6e64b68c4e6", + "name": "sasl", + "sha256": "f185bbb1aa8a8b2738bf6b3b044501bdde8aaed8e8f3592e3eca9c8bdb54a931", + "size": 57385, + "subdir": "linux-64", + "timestamp": 1537825306152, + "version": "0.2.1" + }, + "sasl-0.2.1-py35h7983f5e_0.conda": { + "build": "py35h7983f5e_0", + "build_number": 0, + "depends": [ + "cyrus-sasl 2.1.26.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f89ec4f8ddbb50fd50ad6f73495e13e6", + "name": "sasl", + "sha256": "0c7e06b11ab93f9f9adcb9a128fcf0f64f15aa6a1da0cc881701dfdb135ad6e0", + "size": 56885, + "subdir": "linux-64", + "timestamp": 1512156896809, + "version": "0.2.1" + }, + "sasl-0.2.1-py35hf484d3e_1.conda": { + "build": "py35hf484d3e_1", + "build_number": 1, + "depends": [ + "cyrus-sasl 2.1.26.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d5146856dac5c764e4c6a4d8140e5004", + "name": "sasl", + "sha256": "20c5d360e9ba226c16cef7660c5caf594f9b158a5eb0a56c6a67d5b8d926200b", + "size": 56631, + "subdir": "linux-64", + "timestamp": 1518809294048, + "version": "0.2.1" + }, + "sasl-0.2.1-py36h48830cd_1.conda": { + "build": "py36h48830cd_1", + "build_number": 1, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "39de049460498758f9b1817426ad007f", + "name": "sasl", + "sha256": "5424e455baee44413e960d31284a39d17f21598abacf38cfc509e1846c7133f1", + "size": 59522, + "subdir": "linux-64", + "timestamp": 1632736772553, + "version": "0.2.1" + }, + "sasl-0.2.1-py36h696bdec_0.conda": { + "build": "py36h696bdec_0", + "build_number": 0, + "depends": [ + "cyrus-sasl 2.1.26.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d456c9b30da00c0706b425a792e16aca", + "name": "sasl", + "sha256": "df25b83ca83c731bda391b80ae5c7f12b7290730fc57e31418cb38c06237d417", + "size": 56850, + "subdir": "linux-64", + "timestamp": 1512156839155, + "version": "0.2.1" + }, + "sasl-0.2.1-py36h779454e_1.conda": { + "build": "py36h779454e_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "929c154d9f68e09c979fc7dd33f990c8", + "name": "sasl", + "sha256": "862f33c15b65bfe899c92e8776260e416544a86d63d9e5308e4b2e3300dd7b48", + "size": 57496, + "subdir": "linux-64", + "timestamp": 1537825230836, + "version": "0.2.1" + }, + "sasl-0.2.1-py36hf484d3e_1.conda": { + "build": "py36hf484d3e_1", + "build_number": 1, + "depends": [ + "cyrus-sasl 2.1.26.*", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1b119cf401a0f164ea9a86bda6cfd4fd", + "name": "sasl", + "sha256": "01bde01c76912e70bb1aa82a47016bca7ca3d97e18add6ad7aa55a2741305530", + "size": 56543, + "subdir": "linux-64", + "timestamp": 1518809266495, + "version": "0.2.1" + }, + "sasl-0.2.1-py37h42fbc30_2.conda": { + "build": "py37h42fbc30_2", + "build_number": 2, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "973f74b302a136b66ff5801fd3053f84", + "name": "sasl", + "sha256": "e57b2521e7a605624ac81cb935800242b50b6507898c53ec0bc70b0f378c41e1", + "size": 59038, + "subdir": "linux-64", + "timestamp": 1656584636954, + "version": "0.2.1" + }, + "sasl-0.2.1-py37h48830cd_1.conda": { + "build": "py37h48830cd_1", + "build_number": 1, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "df1056f21708ad2872686e7b9a023273", + "name": "sasl", + "sha256": "9386df318987b34f811838428e264e2181417d1c15cf866592ae8919c2400809", + "size": 59667, + "subdir": "linux-64", + "timestamp": 1632736749512, + "version": "0.2.1" + }, + "sasl-0.2.1-py37h779454e_1.conda": { + "build": "py37h779454e_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "582ff593389def03d67feaf24917d208", + "name": "sasl", + "sha256": "37c257f3baaf63ea412657fb5d00983a6128043098af2426e5379fa80ed434cc", + "size": 57505, + "subdir": "linux-64", + "timestamp": 1537825122257, + "version": "0.2.1" + }, + "sasl-0.2.1-py37hf484d3e_1.conda": { + "build": "py37hf484d3e_1", + "build_number": 1, + "depends": [ + "cyrus-sasl 2.1.26.*", + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0559dbf86e4332b86de8c14dba5ee737", + "name": "sasl", + "sha256": "90c572305439a887f075e216692458a5accc00f283a9ab4139fd7109040ba5b1", + "size": 56464, + "subdir": "linux-64", + "timestamp": 1530916955507, + "version": "0.2.1" + }, + "sasl-0.2.1-py38h42fbc30_2.conda": { + "build": "py38h42fbc30_2", + "build_number": 2, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2de53534a1c047a96986694cbdb0e507", + "name": "sasl", + "sha256": "315305d274c46bfdc41d4137fc7e9c1b4d3863c513cb2f67909b2fe77ca5afee", + "size": 59584, + "subdir": "linux-64", + "timestamp": 1656584608458, + "version": "0.2.1" + }, + "sasl-0.2.1-py38h48830cd_1.conda": { + "build": "py38h48830cd_1", + "build_number": 1, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f28ffc5b6afeb31e0ea2496e3ecf9b50", + "name": "sasl", + "sha256": "f505035d77ae78c92e96d17b4225775634bdab4b91e1fa91fe7b4c9a14d77ff8", + "size": 60416, + "subdir": "linux-64", + "timestamp": 1632736752021, + "version": "0.2.1" + }, + "sasl-0.2.1-py38h779454e_1.conda": { + "build": "py38h779454e_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8d567c9aaa68357e03be788d9ee453ad", + "name": "sasl", + "sha256": "b7dbb0578244d64d687ba82221ef57e9a1ad854bea96fc6ab6bab8e11a4ecc6b", + "size": 59016, + "subdir": "linux-64", + "timestamp": 1573554747551, + "version": "0.2.1" + }, + "sasl-0.2.1-py39h42fbc30_2.conda": { + "build": "py39h42fbc30_2", + "build_number": 2, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ecde45d5db1df29f763d60515f22b22d", + "name": "sasl", + "sha256": "d235c56e36adb40c6b135b4fdb648bcf244bce903ffb354e7b41a30fa1db0215", + "size": 58793, + "subdir": "linux-64", + "timestamp": 1656584580177, + "version": "0.2.1" + }, + "sasl-0.2.1-py39h48830cd_1.conda": { + "build": "py39h48830cd_1", + "build_number": 1, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "10f30ccf3fc6a2963d19a1c72621e395", + "name": "sasl", + "sha256": "9659983852321dc0c7655bf43c785443629d0fb60753f1057ae29fc9503abb78", + "size": 59530, + "subdir": "linux-64", + "timestamp": 1632735881197, + "version": "0.2.1" + }, + "sasl-0.3.1-py310h42fbc30_0.conda": { + "build": "py310h42fbc30_0", + "build_number": 0, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a17441430215a620b2f7a7d54d7ca56d", + "name": "sasl", + "sha256": "f246b47c95a839bc1a695623ebeae4d3137275b9bade5ef04f14902faa9ee75a", + "size": 114992, + "subdir": "linux-64", + "timestamp": 1671027524305, + "version": "0.3.1" + }, + "sasl-0.3.1-py310h42fbc30_1.conda": { + "build": "py310h42fbc30_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7a0717b39647a24ad9b32c9c96411052", + "name": "sasl", + "sha256": "b9708a14d685fd0eca50593d880b7b9059152d6318b79a3e05a337920f35f5f7", + "size": 114623, + "subdir": "linux-64", + "timestamp": 1679031603778, + "version": "0.3.1" + }, + "sasl-0.3.1-py311h42fbc30_0.conda": { + "build": "py311h42fbc30_0", + "build_number": 0, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "038b4383ed1e157e36379158157e1a38", + "name": "sasl", + "sha256": "adc70ffadc55b8881092e16029ea5f22e0e262c182a6cc08478a770974a5ceaf", + "size": 105521, + "subdir": "linux-64", + "timestamp": 1676845744659, + "version": "0.3.1" + }, + "sasl-0.3.1-py311h42fbc30_1.conda": { + "build": "py311h42fbc30_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d40df5256ccb2757986eacb8cd93d0e0", + "name": "sasl", + "sha256": "6c79ddfb7585c892bd22e3569130bfa737e406ec3572f5cf60b3e1a97cd823e0", + "size": 114003, + "subdir": "linux-64", + "timestamp": 1679031570277, + "version": "0.3.1" + }, + "sasl-0.3.1-py37h42fbc30_0.conda": { + "build": "py37h42fbc30_0", + "build_number": 0, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "359ef8bc08f96cb4bb66757fb301b3d9", + "name": "sasl", + "sha256": "ad5d2ed68cd3e30741ef6e4eadcf315154f98780f4bb951b1af1ef49b2c7ebc2", + "size": 115264, + "subdir": "linux-64", + "timestamp": 1671027490603, + "version": "0.3.1" + }, + "sasl-0.3.1-py38h42fbc30_0.conda": { + "build": "py38h42fbc30_0", + "build_number": 0, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3a8b72120df3a00704c981e58f08f57c", + "name": "sasl", + "sha256": "c84c3f2a25dcba79c172f5f8d5e70e9c727fd29ec223df7597bd92ed786d1acc", + "size": 115901, + "subdir": "linux-64", + "timestamp": 1671027456034, + "version": "0.3.1" + }, + "sasl-0.3.1-py38h42fbc30_1.conda": { + "build": "py38h42fbc30_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a0eafbba2c389251aa82b16800cfd4c4", + "name": "sasl", + "sha256": "6770d1da722c6cb36446d04d8f98013a8cfc727c8dc194ab3ff4972f3dc64eea", + "size": 115485, + "subdir": "linux-64", + "timestamp": 1679031637191, + "version": "0.3.1" + }, + "sasl-0.3.1-py39h42fbc30_0.conda": { + "build": "py39h42fbc30_0", + "build_number": 0, + "depends": [ + "cyrus-sasl", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "77b4efe25e026db1a87f9ed3194d1aef", + "name": "sasl", + "sha256": "0958b80058a81cb418b4e17a1d8d2bdf1b02faca2fe64bf6dc09b98e3a183659", + "size": 115635, + "subdir": "linux-64", + "timestamp": 1671027424401, + "version": "0.3.1" + }, + "sasl-0.3.1-py39h42fbc30_1.conda": { + "build": "py39h42fbc30_1", + "build_number": 1, + "depends": [ + "cyrus-sasl >=2.1.26,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "43d7d425c7359f0bd613b209e258ee55", + "name": "sasl", + "sha256": "380db551914de8beab3c0f26310885facfd9b78f95d41823cd38ed2b46a3853f", + "size": 115233, + "subdir": "linux-64", + "timestamp": 1679031536013, + "version": "0.3.1" + }, + "saspy-2.1.7-py35hcba938c_0.conda": { + "build": "py35hcba938c_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pygments", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "47f0110e3ecc8bafb660dbe2f3824037", + "name": "saspy", + "sha256": "33aa0b17a3c80f9f670e0c0a44e0ebec760864dbdb6a00e4c2f45952bb133f5a", + "size": 111919, + "subdir": "linux-64", + "timestamp": 1506850506747, + "version": "2.1.7" + }, + "saspy-2.1.7-py36h8cad3b6_0.conda": { + "build": "py36h8cad3b6_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5513f639ec4250f8d1011a2acfde2c32", + "name": "saspy", + "sha256": "68d272add057f96e083bbbbd6bec60f7d0f93b073cc0c0191247aa3f6078aace", + "size": 111417, + "subdir": "linux-64", + "timestamp": 1506850515797, + "version": "2.1.7" + }, + "saspy-2.1.8-py35he3b0357_0.conda": { + "build": "py35he3b0357_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pygments", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4cb8116674018b0606c172d4ebfcbe18", + "name": "saspy", + "sha256": "4d7ab01272a251c000d5b6b8aa5d6b21bcbac963acbb23712ccab2221d0697cb", + "size": 117568, + "subdir": "linux-64", + "timestamp": 1511320079927, + "version": "2.1.8" + }, + "saspy-2.1.8-py36h511ab8a_0.conda": { + "build": "py36h511ab8a_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e559aaf0dceae03a8b974e6917b95f99", + "name": "saspy", + "sha256": "a95aa65318f604e8ea62bef44e99f17dbd37bb5d1652cdeb311d09cea65cf550", + "size": 116973, + "subdir": "linux-64", + "timestamp": 1511320082900, + "version": "2.1.8" + }, + "saspy-2.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pygments", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7f14a5c87ca17e27856a22a2ab25b8b3", + "name": "saspy", + "sha256": "309aa645958a22aa6bea98d93b3f81596844b37b50b9138289ce188445f27372", + "size": 117411, + "subdir": "linux-64", + "timestamp": 1519479973650, + "version": "2.2.1" + }, + "saspy-2.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dbb3e60fdce3f66a7e2b79fae23f049f", + "name": "saspy", + "sha256": "1d447fdfb9d28b5d3d285e0467f91910b7128754ebc9a57391835b14b938feb7", + "size": 117989, + "subdir": "linux-64", + "timestamp": 1519479959006, + "version": "2.2.1" + }, + "saspy-2.2.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pygments", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "100e1c55c6da5087d7e2c09742542362", + "name": "saspy", + "sha256": "7837d8970d2485b48d5494a0416c6467ccc1efe94f74f5808b07288029d2796b", + "size": 127680, + "subdir": "linux-64", + "timestamp": 1522716625921, + "version": "2.2.4" + }, + "saspy-2.2.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "49f99073820daa22e1911f866968869a", + "name": "saspy", + "sha256": "35e98e9e2193261cb9a3310e4cd4447d8a107a99a4527e63f6d3d9f2b0875d5f", + "size": 128485, + "subdir": "linux-64", + "timestamp": 1522723273209, + "version": "2.2.4" + }, + "saspy-2.2.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6fdb8f63acc9584ed12060f7de57003b", + "name": "saspy", + "sha256": "01a3d30126e3a9ce183fb0051eb068ec778dca3539da03daf4fae71a9de2e429", + "size": 138556, + "subdir": "linux-64", + "timestamp": 1529957226273, + "version": "2.2.5" + }, + "saspy-2.2.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cdb9c24ffd179a0b0ec4321a755544f4", + "name": "saspy", + "sha256": "b9425c59a14533a6805adfe2aa933fc55637f96e6ca0fdc94fb6b824368d7ac1", + "size": 137766, + "subdir": "linux-64", + "timestamp": 1529957195603, + "version": "2.2.5" + }, + "saspy-2.2.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "062bfc78dfc30b917f4f040f55c02689", + "name": "saspy", + "sha256": "0a149c3e2bb328f8a12db2df5da327433e46ce571bc5f77cd2a7a3dc350fb86c", + "size": 137315, + "subdir": "linux-64", + "timestamp": 1530959588084, + "version": "2.2.5" + }, + "saspy-2.2.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "11f6777e3ce7796fda1ba5aa323ed40c", + "name": "saspy", + "sha256": "a555b6a72ad930c34b034c72b37a3ac40205e7a7580da10da439798ec34337d4", + "size": 137895, + "subdir": "linux-64", + "timestamp": 1535500719501, + "version": "2.2.7" + }, + "saspy-2.2.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9fd788fa2e4b983e1153f09685e86a21", + "name": "saspy", + "sha256": "992d0192dd174417b4060489fe2adab1bbcf4aa7fcbd7e6cd14a610230db1639", + "size": 136346, + "subdir": "linux-64", + "timestamp": 1535500687138, + "version": "2.2.7" + }, + "saspy-2.2.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3ef3a375fa43f32cc0718bafe77bbf2a", + "name": "saspy", + "sha256": "b649a5766a9bd6aaafb37fa7aca8b34eb665a2fc81b8b8920c51cd9ef3bcd7b9", + "size": 136129, + "subdir": "linux-64", + "timestamp": 1535500721940, + "version": "2.2.7" + }, + "saspy-2.2.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9eb57202cdb58509396f8f10adea9239", + "name": "saspy", + "sha256": "60d14a89b2d99eda5a6de76b25c51321b0b57c0cacfe08b1a3c54f8df49c98f5", + "size": 137391, + "subdir": "linux-64", + "timestamp": 1538172506169, + "version": "2.2.8" + }, + "saspy-2.2.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "68b1ce683d80923e4694a34980a21917", + "name": "saspy", + "sha256": "06c61d7e9c8b1cbbf42f469ac8e3059f1104da6459b95c0b7e7c3e3fd3b695db", + "size": 138864, + "subdir": "linux-64", + "timestamp": 1538172499467, + "version": "2.2.8" + }, + "saspy-2.2.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4d515ddca611ca95745f17c09281c615", + "name": "saspy", + "sha256": "d69cf284cfb67df2b8da3cb53ee44748af4b4baec62829277bd554328403fc27", + "size": 141995, + "subdir": "linux-64", + "timestamp": 1539649811515, + "version": "2.2.9" + }, + "saspy-2.2.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "455f4797702233fff76c1761f63cc9e3", + "name": "saspy", + "sha256": "527fb8f318a963341a10596c5f07783fa13b34c512156bd1fb85f072b60e0db7", + "size": 141712, + "subdir": "linux-64", + "timestamp": 1539649811995, + "version": "2.2.9" + }, + "saspy-2.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0cdf2731d308fdef7e6e6b0961e06e5a", + "name": "saspy", + "sha256": "b68c53b89e1095c8d2d49fd75a676bdec276006ade157d0ab26c0acde9d02a9c", + "size": 147782, + "subdir": "linux-64", + "timestamp": 1543615641752, + "version": "2.3.0" + }, + "saspy-2.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d63a4e884a05c3ad1f2a1a7e19a6774b", + "name": "saspy", + "sha256": "6cb9c154d800739c49e25ccdd1f78ec73bc9f40097c36f54aab3f09cc99cd350", + "size": 147287, + "subdir": "linux-64", + "timestamp": 1543615609416, + "version": "2.3.0" + }, + "saspy-2.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "65a5c9aad690d3c2d0478fe3ed08fd76", + "name": "saspy", + "sha256": "4e6e9948a80ae6fcad9744ac2393e7cee36e5e5f529ca8243f061e24c0b31e61", + "size": 154516, + "subdir": "linux-64", + "timestamp": 1545118459304, + "version": "2.4.1" + }, + "saspy-2.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "569e0d9fcf7af945f7a860025413d0e0", + "name": "saspy", + "sha256": "237ed4e2fcbbc65133c11a05e93d89295292a4ecf6b8a8b7f970f90e53ea69bd", + "size": 152840, + "subdir": "linux-64", + "timestamp": 1545118445154, + "version": "2.4.1" + }, + "saspy-2.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ce9a2a569b76982f500b52104471c3da", + "name": "saspy", + "sha256": "08ca6b27a5a52121e55772ccd85a831dfc9283bc6188e0638f6926185bb4cf7d", + "size": 167254, + "subdir": "linux-64", + "timestamp": 1550358965440, + "version": "2.4.2" + }, + "saspy-2.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ipython >=4", + "pandas", + "pygments", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b02e4bed149543248a152642ed2f201c", + "name": "saspy", + "sha256": "2eb2609e4966a6fe514c61d8a4e1030ff09a23e71ddb2784e5d0f85f5b13de4c", + "size": 164954, + "subdir": "linux-64", + "timestamp": 1550358887146, + "version": "2.4.2" + }, + "scandir-1.10.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e21b0e2857ba5f3e6525c8eff1f3ec28", + "name": "scandir", + "sha256": "dc47b6bfddc75205cb0d381d46df5543fddca27cd2fa6c4646e5076c4e8bcf3a", + "size": 32722, + "subdir": "linux-64", + "timestamp": 1552335425295, + "version": "1.10.0" + }, + "scandir-1.5-py27h1c9e1f8_1.conda": { + "build": "py27h1c9e1f8_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bf5455a5728ad069fb1f70577408a867", + "name": "scandir", + "sha256": "2919ec1712ebc4f46390372202ef26da9ed9d8dd927a8f32cbee8450540e68a0", + "size": 26480, + "subdir": "linux-64", + "timestamp": 1505863926960, + "version": "1.5" + }, + "scandir-1.6-py27hf7388dc_0.conda": { + "build": "py27hf7388dc_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f0121bb32eb242d5df819301926fc4fa", + "name": "scandir", + "sha256": "bfb67e10fde04fdd3c3e45284a1a046f63d65882daae8c703a213960a3278de7", + "size": 27374, + "subdir": "linux-64", + "timestamp": 1507669492470, + "version": "1.6" + }, + "scandir-1.7-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1abd450ed37cd888d8d666d8a3eede9f", + "name": "scandir", + "sha256": "b72bd1493dedc80e8cc034ded24a94001e82e5c0fdfe1f418b5a72c630870657", + "size": 27432, + "subdir": "linux-64", + "timestamp": 1519147128248, + "version": "1.7" + }, + "scandir-1.8-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "bbad7195ff415a9c34e7b7291c8ad2fd", + "name": "scandir", + "sha256": "ad8b29a14ead13cac1848cb2b2e0a8c7b1507b880512daeca6429d7ba3f16963", + "size": 27750, + "subdir": "linux-64", + "timestamp": 1533673087667, + "version": "1.8" + }, + "scandir-1.9.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "97b860bb83ececb27e1f928d4ad26a36", + "name": "scandir", + "sha256": "929951fbd0eebe6f9f44fabccbec350f2796bcc02ff45372cc5dc485bd6284e6", + "size": 27934, + "subdir": "linux-64", + "timestamp": 1534177940126, + "version": "1.9.0" + }, + "schema-0.7.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "contextlib2 >=0.5.5", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebc4ef32bc04ef09dd358bfa3e9e6ace", + "name": "schema", + "sha256": "ad1ca7dbaf37a12bea741f8cc903324c8b4f6e4f365215c211f324c154266653", + "size": 39144, + "subdir": "linux-64", + "timestamp": 1663666459273, + "version": "0.7.5" + }, + "schema-0.7.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "contextlib2 >=0.5.5", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f9921e60cf3af463115de389db5330e", + "name": "schema", + "sha256": "d60417098d9f93b34d49b0a2e0380855e0ba7295f03e8ff4cd4bf907054df054", + "size": 46513, + "subdir": "linux-64", + "timestamp": 1679340658247, + "version": "0.7.5" + }, + "schema-0.7.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "contextlib2 >=0.5.5", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e6ed450cade53fdf6cd016b2e7c4631", + "name": "schema", + "sha256": "1e7512fd84b0363f743137fba15c30bcd1a4b146e59fd9a3f6c9f0518b6f3cd3", + "size": 38837, + "subdir": "linux-64", + "timestamp": 1663666420253, + "version": "0.7.5" + }, + "schema-0.7.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "contextlib2 >=0.5.5", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5277dbc24d5f43a23baebabd7ed73759", + "name": "schema", + "sha256": "c391b3291f756df8b0c5ecadb2dd3b227f6c67c9635e58d86ac70fef96b2ef53", + "size": 38945, + "subdir": "linux-64", + "timestamp": 1663666393983, + "version": "0.7.5" + }, + "schema-0.7.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "contextlib2 >=0.5.5", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2ac0de85fbbc4e7c2c41452f07ae813", + "name": "schema", + "sha256": "17e1d18816fa1bd595653860ad91240f337b6de7b318d4d3f54f5d6331016d57", + "size": 38956, + "subdir": "linux-64", + "timestamp": 1663666485933, + "version": "0.7.5" + }, + "scikit-bio-0.5.2-py35h3010b51_0.conda": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.11.5", + "decorator >=3.4.2", + "ipython >=3.2.0", + "libgcc-ng >=7.2.0", + "lockfile >=0.10.2", + "matplotlib >=1.4.3", + "natsort >=4.0.3", + "nose >=1.3.7", + "numpy >=1.9.3,<2.0a0", + "pandas >=0.19.2", + "python >=3.5,<3.6.0a0", + "scikit-learn >=0.19.1", + "scipy >=0.15.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e81b16d8c7c4ee1aa6f9f6370087e3d1", + "name": "scikit-bio", + "sha256": "73605362453e9fc96e45063a0d1ec16283f993e61c13f552d30d3524434ab44f", + "size": 1042985, + "subdir": "linux-64", + "timestamp": 1524608963860, + "version": "0.5.2" + }, + "scikit-bio-0.5.2-py36h3010b51_0.conda": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.11.5", + "decorator >=3.4.2", + "ipython >=3.2.0", + "libgcc-ng >=7.2.0", + "lockfile >=0.10.2", + "matplotlib >=1.4.3", + "natsort >=4.0.3", + "nose >=1.3.7", + "numpy >=1.9.3,<2.0a0", + "pandas >=0.19.2", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.19.1", + "scipy >=0.15.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0257495865a3fbc4fe91afa2d284f374", + "name": "scikit-bio", + "sha256": "30a69326d83eedfc89d6d3c91ce9146f8d0d3848a11877a01ed501b3122a4f12", + "size": 1026710, + "subdir": "linux-64", + "timestamp": 1524608964349, + "version": "0.5.2" + }, + "scikit-bio-0.5.4-py35hdd07704_0.conda": { + "build": "py35hdd07704_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.11.5", + "decorator >=3.4.2", + "hdmedians >=0.13", + "ipython >=3.2.0", + "libgcc-ng >=7.3.0", + "lockfile >=0.10.2", + "matplotlib >=1.4.3", + "natsort >=4.0.3", + "nose >=1.3.7", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19.2,<0.23.0", + "python >=3.5,<3.6.0a0", + "scikit-learn >=0.19.1", + "scipy >=0.15.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "996497c603848fb5da20ae3e6f5e4c23", + "name": "scikit-bio", + "sha256": "01bbf11041b8058083d0be931cbadc723485527c4dc38b5be423981fd4aceb84", + "size": 1071158, + "subdir": "linux-64", + "timestamp": 1535811868574, + "version": "0.5.4" + }, + "scikit-bio-0.5.4-py36hdd07704_0.conda": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.11.5", + "decorator >=3.4.2", + "hdmedians >=0.13", + "ipython >=3.2.0", + "libgcc-ng >=7.3.0", + "lockfile >=0.10.2", + "matplotlib >=1.4.3", + "natsort >=4.0.3", + "nose >=1.3.7", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.19.2,<0.23.0", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.19.1", + "scipy >=0.15.1" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2f0b65406000457f2eb30e27c628e1fa", + "name": "scikit-bio", + "sha256": "48e987898153a3a8fd6d84112fb6d3911b1856321735b8bc4f117de9cebb305e", + "size": 1063823, + "subdir": "linux-64", + "timestamp": 1535812011165, + "version": "0.5.4" + }, + "scikit-bio-0.5.6-py36h6323ea4_0.conda": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.11.5", + "decorator >=3.4.2", + "hdmedians >=0.13", + "ipython >=3.2.0", + "libgcc-ng >=7.3.0", + "lockfile >=0.10.2", + "matplotlib-base >=1.4.3", + "natsort >=4.0.3", + "numpy >=1.16.6,<2.0a0", + "pandas >=1.0.0", + "pytest", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.19.1", + "scipy >=1.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "096db4546fb85fc9695be552b708b87d", + "name": "scikit-bio", + "sha256": "f3e49f55813a4ad597361967a9203d84d7a82cd487884ae9c2d4f6a257cf339f", + "size": 1107054, + "subdir": "linux-64", + "timestamp": 1614415892343, + "version": "0.5.6" + }, + "scikit-bio-0.5.6-py37h6323ea4_0.conda": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.11.5", + "decorator >=3.4.2", + "hdmedians >=0.13", + "ipython >=3.2.0", + "libgcc-ng >=7.3.0", + "lockfile >=0.10.2", + "matplotlib-base >=1.4.3", + "natsort >=4.0.3", + "numpy >=1.16.6,<2.0a0", + "pandas >=1.0.0", + "pytest", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.19.1", + "scipy >=1.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1176b232b3f25479c9143a394bafb8b7", + "name": "scikit-bio", + "sha256": "63dc040e2de0cef713e8084db0be29c437fda10896a1541f0f5cededecf1b9a2", + "size": 1104607, + "subdir": "linux-64", + "timestamp": 1614416003478, + "version": "0.5.6" + }, + "scikit-bio-0.5.6-py38h6323ea4_0.conda": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.11.5", + "decorator >=3.4.2", + "hdmedians >=0.13", + "ipython >=3.2.0", + "libgcc-ng >=7.3.0", + "lockfile >=0.10.2", + "matplotlib-base >=1.4.3", + "natsort >=4.0.3", + "numpy >=1.16.6,<2.0a0", + "pandas >=1.0.0", + "pytest", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.19.1", + "scipy >=1.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1791162b84c5767cc02c961f91ca183f", + "name": "scikit-bio", + "sha256": "e5777a0445a214e417eec346dd43d88dfd031a331c5f0c7fc09264c4071c1158", + "size": 1114261, + "subdir": "linux-64", + "timestamp": 1614414896878, + "version": "0.5.6" + }, + "scikit-bio-0.5.6-py39h6323ea4_0.conda": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "cachecontrol >=0.11.5", + "decorator >=3.4.2", + "hdmedians >=0.13", + "ipython >=3.2.0", + "libgcc-ng >=7.3.0", + "lockfile >=0.10.2", + "matplotlib-base >=1.4.3", + "natsort >=4.0.3", + "numpy >=1.16.6,<2.0a0", + "pandas >=1.0.0", + "pytest", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.19.1", + "scipy >=1.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "baae2514b1355843f869f02216976abf", + "name": "scikit-bio", + "sha256": "70a82233c72714ac0c35481ee97d2eb9988f1915f4390f63ac269b8e8151a250", + "size": 1116841, + "subdir": "linux-64", + "timestamp": 1614415977956, + "version": "0.5.6" + }, + "scikit-build-0.11.1-py310h295c915_2.conda": { + "build": "py310h295c915_2", + "build_number": 2, + "depends": [ + "cmake", + "distro", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "ninja", + "packaging", + "python >=3.10,<3.11.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ab4aaa66085f8b92dd50b919d98566c", + "name": "scikit-build", + "sha256": "1b6514daab64f3a6ef227a13dd55d6bcf5fdd4a5291005a7eb12b25d1900856d", + "size": 114042, + "subdir": "linux-64", + "timestamp": 1640810837954, + "version": "0.11.1" + }, + "scikit-build-0.11.1-py36h2531618_2.conda": { + "build": "py36h2531618_2", + "build_number": 2, + "depends": [ + "cmake", + "distro", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ninja", + "packaging", + "python >=3.6,<3.7.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3cf4ba4b21505b1417836cb8dc706817", + "name": "scikit-build", + "sha256": "ff37cdedc35b64830972bfbed4281bd1687f2aa0b13dfb0acf5b1de5b7f1792e", + "size": 131596, + "subdir": "linux-64", + "timestamp": 1610399352691, + "version": "0.11.1" + }, + "scikit-build-0.11.1-py37h2531618_2.conda": { + "build": "py37h2531618_2", + "build_number": 2, + "depends": [ + "cmake", + "distro", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ninja", + "packaging", + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db762c4d5d6605d5aa27ca3c1c39943f", + "name": "scikit-build", + "sha256": "a0f34483aaa09f63b97104fd97bd9940826ceb46fc0764999940e11f7596967d", + "size": 128604, + "subdir": "linux-64", + "timestamp": 1610399372313, + "version": "0.11.1" + }, + "scikit-build-0.11.1-py38h2531618_2.conda": { + "build": "py38h2531618_2", + "build_number": 2, + "depends": [ + "cmake", + "distro", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ninja", + "packaging", + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c1510563b31291ac72f4861a479e2b5", + "name": "scikit-build", + "sha256": "ca213c81254548c2968c0b7c465ff94c04a8a4cb08c040776dcafb063a72de93", + "size": 124771, + "subdir": "linux-64", + "timestamp": 1610399354330, + "version": "0.11.1" + }, + "scikit-build-0.11.1-py39h2531618_2.conda": { + "build": "py39h2531618_2", + "build_number": 2, + "depends": [ + "cmake", + "distro", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "ninja", + "packaging", + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3956ae64aa2efccde2094931fc213c6", + "name": "scikit-build", + "sha256": "0e8d2e491624b8fbebabdad07342e422bb646b315bb06f9ce319e21257ba7119", + "size": 118103, + "subdir": "linux-64", + "timestamp": 1610398926547, + "version": "0.11.1" + }, + "scikit-build-0.15.0-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "cmake", + "distro", + "make", + "packaging", + "python >=3.10,<3.11.0a0", + "setuptools >=42.0.0", + "wheel >=0.32.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f120759e18044ac566fa39d8c0ee3d4", + "name": "scikit-build", + "sha256": "102d03a4270aeb5046e4abaa7130da3414dd2a1c956730b140c534b4be11581c", + "size": 123146, + "subdir": "linux-64", + "timestamp": 1664437609321, + "version": "0.15.0" + }, + "scikit-build-0.15.0-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "cmake", + "distro", + "make", + "packaging", + "python >=3.11,<3.12.0a0", + "setuptools >=42.0.0", + "wheel >=0.32.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "93c87911d899689689b0e224c179ee47", + "name": "scikit-build", + "sha256": "181e03424e43d595d2270a4707634689aa90e900f7b2e72d6c0baf6f20133cf1", + "size": 148848, + "subdir": "linux-64", + "timestamp": 1676842460227, + "version": "0.15.0" + }, + "scikit-build-0.15.0-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "cmake", + "distro", + "make", + "packaging", + "python >=3.7,<3.8.0a0", + "setuptools >=42.0.0", + "wheel >=0.32.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a80199aca8c86d981f1648fdb4b187f0", + "name": "scikit-build", + "sha256": "68e6223228ae5294760a5d71c6e9c2476ddbc9e45775be7e93c5b0be3a3fcf87", + "size": 122248, + "subdir": "linux-64", + "timestamp": 1664437757333, + "version": "0.15.0" + }, + "scikit-build-0.15.0-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "cmake", + "distro", + "make", + "packaging", + "python >=3.8,<3.9.0a0", + "setuptools >=42.0.0", + "wheel >=0.32.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d4b4095411d56349359cb7975847899", + "name": "scikit-build", + "sha256": "ad85aa92f2bd2c61181051bb338083a477930895a604394138034226a71223a1", + "size": 122676, + "subdir": "linux-64", + "timestamp": 1664437687156, + "version": "0.15.0" + }, + "scikit-build-0.15.0-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "cmake", + "distro", + "make", + "packaging", + "python >=3.9,<3.10.0a0", + "setuptools >=42.0.0", + "wheel >=0.32.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ff44546e0d5990f8de3694857c22d17", + "name": "scikit-build", + "sha256": "23671a1a5dc8bfdb04011def4278e1469d20c6ad026ccd8cc23cda1e309c68ef", + "size": 122819, + "subdir": "linux-64", + "timestamp": 1664437830346, + "version": "0.15.0" + }, + "scikit-image-0.13.0-py27h06cb35d_1.conda": { + "build": "py27h06cb35d_1", + "build_number": 1, + "depends": [ + "dask >=0.5", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "matplotlib >=1.3.1", + "networkx >=1.8", + "numpy >=1.9.3,<2.0a0", + "pillow >=2.1.0", + "python >=2.7,<2.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3" + ], + "license": "BSD 3-Clause", + "md5": "32af532da2f7608bdbfda31a98f85e62", + "name": "scikit-image", + "sha256": "fa3e204eb2c50b7847ac85859f0bc34710931c51e1f6ec0b2215daa548fb63e3", + "size": 22493269, + "subdir": "linux-64", + "timestamp": 1505753288797, + "version": "0.13.0" + }, + "scikit-image-0.13.0-py35h3573165_1.conda": { + "build": "py35h3573165_1", + "build_number": 1, + "depends": [ + "dask >=0.5", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "matplotlib >=1.3.1", + "networkx >=1.8", + "numpy >=1.9.3,<2.0a0", + "pillow >=2.1.0", + "python >=3.5,<3.6.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3" + ], + "license": "BSD 3-Clause", + "md5": "77dd89d6f6bf6e5834a49f65aa99ea1e", + "name": "scikit-image", + "sha256": "5da47f2f7b347d057710d84d8a43c468c3bba151cec34bb7792689fcc2f7023b", + "size": 22399172, + "subdir": "linux-64", + "timestamp": 1505753587092, + "version": "0.13.0" + }, + "scikit-image-0.13.0-py36had3c07a_1.conda": { + "build": "py36had3c07a_1", + "build_number": 1, + "depends": [ + "dask >=0.5", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "matplotlib >=1.3.1", + "networkx >=1.8", + "numpy >=1.9.3,<2.0a0", + "pillow >=2.1.0", + "python >=3.6,<3.7.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3" + ], + "license": "BSD 3-Clause", + "md5": "2a02d3e86abede8c777c974b345f11d1", + "name": "scikit-image", + "sha256": "c0bfc1f575b67bd1fd1aefe4580f2fc9983d6e8e6e2c13768f6677bd7128658b", + "size": 22410915, + "subdir": "linux-64", + "timestamp": 1505753876364, + "version": "0.13.0" + }, + "scikit-image-0.13.1-py27h14c3975_1.conda": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "dask >=0.5", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "matplotlib >=1.3.1", + "networkx >=1.8", + "numpy >=1.9.3,<2.0a0", + "pillow >=2.1.0", + "python >=2.7,<2.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dbfa1db5c1d412c180c8ff6966e00de5", + "name": "scikit-image", + "sha256": "d5870c0cf91b9765e11fcd3acce4bb0afb3969ceb1549287acb9ec6e05001477", + "size": 22514357, + "subdir": "linux-64", + "timestamp": 1515176081384, + "version": "0.13.1" + }, + "scikit-image-0.13.1-py27h44232b9_0.conda": { + "build": "py27h44232b9_0", + "build_number": 0, + "depends": [ + "dask >=0.5", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "matplotlib >=1.3.1", + "networkx >=1.8,<2.0", + "numpy >=1.9.3,<2.0a0", + "pillow >=2.1.0", + "python >=2.7,<2.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "610a6dcdc64fdd1a007d7824f529f0bb", + "name": "scikit-image", + "sha256": "9a4028ecd2ffd0df2ea1d448465c4a84ffab72d6560c0bc575e8915e8eabeadc", + "size": 22513326, + "subdir": "linux-64", + "timestamp": 1511318425015, + "version": "0.13.1" + }, + "scikit-image-0.13.1-py35h14c3975_1.conda": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "dask >=0.5", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "matplotlib >=1.3.1", + "networkx >=1.8", + "numpy >=1.13.3,<2.0a0", + "pillow >=2.1.0", + "python >=3.5,<3.6.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "08cc423ca6a6a58589751fda275021e9", + "name": "scikit-image", + "sha256": "423a3917eb2e3b1bd4ce05ead89838c2ea76e302bf9b760e0e502d6fbc2464f1", + "size": 22436444, + "subdir": "linux-64", + "timestamp": 1515176107505, + "version": "0.13.1" + }, + "scikit-image-0.13.1-py35h7a281a6_0.conda": { + "build": "py35h7a281a6_0", + "build_number": 0, + "depends": [ + "dask >=0.5", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "matplotlib >=1.3.1", + "networkx >=1.8,<2.0", + "numpy >=1.9.3,<2.0a0", + "pillow >=2.1.0", + "python >=3.5,<3.6.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4e0d011c2a30db61b0ac71958d203095", + "name": "scikit-image", + "sha256": "4e0f32a616d5f34e0c1ab1f8abf7b4ecf1e1ad7cf37db938687631915d93c404", + "size": 22426793, + "subdir": "linux-64", + "timestamp": 1511318497980, + "version": "0.13.1" + }, + "scikit-image-0.13.1-py36h14c3975_1.conda": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "dask >=0.5", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "matplotlib >=1.3.1", + "networkx >=1.8", + "numpy >=1.9.3,<2.0a0", + "pillow >=2.1.0", + "python >=3.6,<3.7.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5a943155099b16e600bd7bd52cc54162", + "name": "scikit-image", + "sha256": "5ff58e190bfeb3167aa64547575ea3e382b2187480b128f76874c55f7b2fe342", + "size": 22430911, + "subdir": "linux-64", + "timestamp": 1515176428169, + "version": "0.13.1" + }, + "scikit-image-0.13.1-py36ha4a0841_0.conda": { + "build": "py36ha4a0841_0", + "build_number": 0, + "depends": [ + "dask >=0.5", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "matplotlib >=1.3.1", + "networkx >=1.8,<2.0", + "numpy >=1.9.3,<2.0a0", + "pillow >=2.1.0", + "python >=3.6,<3.7.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d6c7cd9a13995f581d1a0fd1f4ab6ddf", + "name": "scikit-image", + "sha256": "027238c3cefe6ceb020b3ffd51564fb597ebfb0445564e369bb6dc2bb83e4d72", + "size": 22431746, + "subdir": "linux-64", + "timestamp": 1511318497467, + "version": "0.13.1" + }, + "scikit-image-0.14.0-py27hf484d3e_1.conda": { + "build": "py27hf484d3e_1", + "build_number": 1, + "depends": [ + "cloudpickle >=0.2.1", + "dask-core >=0.15", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=2.7,<2.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d2d0325279e5362dc059741bd4f2a85b", + "name": "scikit-image", + "sha256": "5d870b80e0a768425655c67c25155e990bbc3dcfc7dc96d3c26cb6ebc2eaf70f", + "size": 23286306, + "subdir": "linux-64", + "timestamp": 1529963088659, + "version": "0.14.0" + }, + "scikit-image-0.14.0-py35hf484d3e_1.conda": { + "build": "py35hf484d3e_1", + "build_number": 1, + "depends": [ + "cloudpickle >=0.2.1", + "dask-core >=0.15", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.5,<3.6.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "390fcf6b23bcd2288c1490725fc9fd8c", + "name": "scikit-image", + "sha256": "c74c8c78c66832c53ec99601ef106b29b7cc7fc5e7a315ba930400adac9839e2", + "size": 23205377, + "subdir": "linux-64", + "timestamp": 1529963061998, + "version": "0.14.0" + }, + "scikit-image-0.14.0-py36hf484d3e_1.conda": { + "build": "py36hf484d3e_1", + "build_number": 1, + "depends": [ + "cloudpickle >=0.2.1", + "dask-core >=0.15", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.6,<3.7.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6c5083c104912ce9061bc90c1d0b16f8", + "name": "scikit-image", + "sha256": "89105e79bde594a2b12385156a8ba1124365a65e0a98a77403ddf260f5cca5fe", + "size": 23229186, + "subdir": "linux-64", + "timestamp": 1529963019144, + "version": "0.14.0" + }, + "scikit-image-0.14.0-py37hf484d3e_1.conda": { + "build": "py37hf484d3e_1", + "build_number": 1, + "depends": [ + "cloudpickle >=0.2.1", + "dask-core >=0.15", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "288a2c2cc2884a4ae4a7b4c64aa81564", + "name": "scikit-image", + "sha256": "8e7ad447e36ea1acaa845a68fc4986e837c021e1bcd2ef5e5580e611d7358472", + "size": 23222590, + "subdir": "linux-64", + "timestamp": 1530891536248, + "version": "0.14.0" + }, + "scikit-image-0.14.1-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=2.7,<2.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c4f61fadd6bd7214246ec4d9fdf6d9bd", + "name": "scikit-image", + "sha256": "f0cb94aef64bcfede631e4bd7d5a8300be3108c0b4274efd498684eb316a728d", + "size": 23261503, + "subdir": "linux-64", + "timestamp": 1544595427967, + "version": "0.14.1" + }, + "scikit-image-0.14.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.6,<3.7.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ad659c3feff5c0a551afa1797cac5503", + "name": "scikit-image", + "sha256": "b1ab5bfdaa8a9b3141478bb5ec4ea81547119bb1b302734f748a916aa7850f6e", + "size": 23227826, + "subdir": "linux-64", + "timestamp": 1544592061964, + "version": "0.14.1" + }, + "scikit-image-0.14.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "05fbb0c8757dd54cc0c77e23bfff5658", + "name": "scikit-image", + "sha256": "6e4c15cf581a6048753f3cb4545e79513374d4daf6378ffad633e21bf03e1379", + "size": 23214793, + "subdir": "linux-64", + "timestamp": 1544595266739, + "version": "0.14.1" + }, + "scikit-image-0.14.2-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=2.7,<2.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ece886e3a5f8ddf995b6aa80c6784b5f", + "name": "scikit-image", + "sha256": "b830c6f2ea7fc86b07903987b9a5736137bc604a1f1eadb7147e57412110a10f", + "size": 23328626, + "subdir": "linux-64", + "timestamp": 1552488626464, + "version": "0.14.2" + }, + "scikit-image-0.14.2-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.6,<3.7.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8f260031381f398b141a1242240e4af4", + "name": "scikit-image", + "sha256": "27bff9cb80655c84bc8aaf73a1c3265e09942ba47630db4c6dec8ae460d76c99", + "size": 23296604, + "subdir": "linux-64", + "timestamp": 1552488598184, + "version": "0.14.2" + }, + "scikit-image-0.14.2-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8ad5c3559492e58164580c9d2e2d6883", + "name": "scikit-image", + "sha256": "4b8e7f3f8765bc4accbc687ced3e148d5abe18630d0a762f48e80d072e30b3b8", + "size": 23297469, + "subdir": "linux-64", + "timestamp": 1552488652882, + "version": "0.14.2" + }, + "scikit-image-0.15.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.6,<3.7.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "12ff0d6f0c4e652488e7f73966bc5875", + "name": "scikit-image", + "sha256": "6f169ae781db097e022b376c80d7fa8af4228baa1428bc8fb36eae620ad1ecca", + "size": 25971637, + "subdir": "linux-64", + "timestamp": 1556030482335, + "version": "0.15.0" + }, + "scikit-image-0.15.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4ea9aac46ad982366121817375ea2bca", + "name": "scikit-image", + "sha256": "575dfa91ca810b851de3d581a0f53cf593da768ad4cfc3e7157602166fb72985", + "size": 25965867, + "subdir": "linux-64", + "timestamp": 1556030636786, + "version": "0.15.0" + }, + "scikit-image-0.15.0-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.9.0", + "imageio >=2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=1.8", + "numpy >=1.11.3,<2.0a0", + "pillow >=4.3.0", + "python >=3.8,<3.9.0a0", + "pywavelets >=0.4.0", + "scipy >=0.17", + "six >=1.7.3", + "toolz >=0.7.4" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "13a4f2857373d1264812aafbea273a01", + "name": "scikit-image", + "sha256": "458429285e620038bdf5b20aa491e9851de9c3574d54ddc4b83fd2fe55245eb1", + "size": 26107596, + "subdir": "linux-64", + "timestamp": 1574170576225, + "version": "0.15.0" + }, + "scikit-image-0.16.2-py310h6a678d5_1.conda": { + "build": "py310h6a678d5_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.3.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib >=2.0.0", + "networkx >=2.2", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pillow >=4.3.0", + "python >=3.10,<3.11.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "718232159e2196c1b257e895c4d295d2", + "name": "scikit-image", + "sha256": "a11095781230b9838b7acae2a5ba9de4a9a67c0ac2a5a024e0fa085cc5000ecb", + "size": 23819955, + "subdir": "linux-64", + "timestamp": 1665663289990, + "version": "0.16.2" + }, + "scikit-image-0.16.2-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=2.0", + "numpy >=1.14.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.6,<3.7.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "1c8e8cdbf56ab9ffe02dffc6f3a184e5", + "name": "scikit-image", + "sha256": "9bcc2456b605f4dce207403875e58c98b84b10d53fb12e66e875c9113dcda08b", + "size": 24229785, + "subdir": "linux-64", + "timestamp": 1580330411985, + "version": "0.16.2" + }, + "scikit-image-0.16.2-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=2.0", + "numpy >=1.14.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "6c611018549421770a426c390c7c2dfe", + "name": "scikit-image", + "sha256": "f6567284a1a14a62a5f418c77310f6362da59637c165b4b3eef23203fb7216e3", + "size": 24222352, + "subdir": "linux-64", + "timestamp": 1580330407879, + "version": "0.16.2" + }, + "scikit-image-0.16.2-py37h6a678d5_1.conda": { + "build": "py37h6a678d5_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.3.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib >=2.0.0", + "networkx >=2.2,<2.7", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=4.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4bfbd1ad403616c96eb50102558328b6", + "name": "scikit-image", + "sha256": "a89d1bbed4dfde5b5f393899fea4e6912876aa094265aaa1fad56aaa0a221aec", + "size": 23732569, + "subdir": "linux-64", + "timestamp": 1665662380116, + "version": "0.16.2" + }, + "scikit-image-0.16.2-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=2.0", + "numpy >=1.14.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.8,<3.9.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "toolz >=0.7.3" + ], + "license": "BSD 3-Clause", + "md5": "ae4a7dde7ee47030310c8ee1acc82821", + "name": "scikit-image", + "sha256": "bfe08a9a4533a503ab445715319889019582240c823669ec24ef3dfd0162e2d8", + "size": 24352016, + "subdir": "linux-64", + "timestamp": 1580496064495, + "version": "0.16.2" + }, + "scikit-image-0.16.2-py38h6a678d5_1.conda": { + "build": "py38h6a678d5_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.3.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib >=2.0.0", + "networkx >=2.2", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=4.3.0", + "python >=3.8,<3.9.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "198c357406abed252d3ad2fd330fd93e", + "name": "scikit-image", + "sha256": "afa1548df5a9ec5141741b78383b58d28bab761672065cd3078d3f41e2ef6715", + "size": 23844090, + "subdir": "linux-64", + "timestamp": 1665662843051, + "version": "0.16.2" + }, + "scikit-image-0.16.2-py39h6a678d5_1.conda": { + "build": "py39h6a678d5_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.3.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "matplotlib >=2.0.0", + "networkx >=2.2", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=4.3.0", + "python >=3.9,<3.10.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fdc4ee5df1cb343bb67ada83301313f3", + "name": "scikit-image", + "sha256": "04d4956a6cfdc5786f55d211fd3cd0b4ab948f02b9b45e312e635f7240462f15", + "size": 23812333, + "subdir": "linux-64", + "timestamp": 1665661902883, + "version": "0.16.2" + }, + "scikit-image-0.16.2-py39ha9443f7_0.conda": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib >=2.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.9,<3.10.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "md5": "e19772c6289b089d3771633d2a0c19f4", + "name": "scikit-image", + "sha256": "e31cc50c3a46f93de987e4730317c0dcdf3fb6db6c3d48417b8ec2e3a5ec688b", + "size": 23893546, + "subdir": "linux-64", + "timestamp": 1608148347464, + "version": "0.16.2" + }, + "scikit-image-0.17.2-py36hdf5156a_0.conda": { + "build": "py36hdf5156a_0", + "build_number": 0, + "constrains": [ + "pooch >=0.5.2" + ], + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=2.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.6,<3.7.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "md5": "3308bc96f5aee8d607362a592574f60c", + "name": "scikit-image", + "sha256": "c8b9789ba9dab798ee28661503cac0feae7dec33a855146ba7dce7983330d1a5", + "size": 9631516, + "subdir": "linux-64", + "timestamp": 1603274774341, + "version": "0.17.2" + }, + "scikit-image-0.17.2-py37hdf5156a_0.conda": { + "build": "py37hdf5156a_0", + "build_number": 0, + "constrains": [ + "pooch >=0.5.2" + ], + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=2.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "md5": "10053a6025a3f3495cab31d3d85137b6", + "name": "scikit-image", + "sha256": "6812b9e30767eb3baccecc6903be9811322f96624e120b55965b22b47593c29d", + "size": 9617508, + "subdir": "linux-64", + "timestamp": 1603274774292, + "version": "0.17.2" + }, + "scikit-image-0.17.2-py38hdf5156a_0.conda": { + "build": "py38hdf5156a_0", + "build_number": 0, + "constrains": [ + "pooch >=0.5.2" + ], + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=2.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.8,<3.9.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "md5": "3b1d23107ec873aa49c1e4a60f11eb9f", + "name": "scikit-image", + "sha256": "26c2e503759392fe6aa0aa40e92a026db426cb4977c0db6790fcb1defcdbcebd", + "size": 9749542, + "subdir": "linux-64", + "timestamp": 1603274757507, + "version": "0.17.2" + }, + "scikit-image-0.17.2-py39ha9443f7_0.conda": { + "build": "py39ha9443f7_0", + "build_number": 0, + "constrains": [ + "pooch >=0.5.2" + ], + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=2.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.9,<3.10.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "md5": "917f516013e0def6e780cc2768f00ec6", + "name": "scikit-image", + "sha256": "380b2418f927d8f4c64bc30f900403f523e15b27de4b57bf5b3144e940ecd9a7", + "size": 9771496, + "subdir": "linux-64", + "timestamp": 1608067335701, + "version": "0.17.2" + }, + "scikit-image-0.18.1-py37ha9443f7_0.conda": { + "build": "py37ha9443f7_0", + "build_number": 0, + "constrains": [ + "pooch >=1.3.0" + ], + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=2.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "md5": "8b43361fafbe3ae7e38b021ed199dac7", + "name": "scikit-image", + "sha256": "286b8da1c5a2f2a43826d71bba7647845193086910ff06de39bdb01f0605359e", + "size": 9861964, + "subdir": "linux-64", + "timestamp": 1617914863263, + "version": "0.18.1" + }, + "scikit-image-0.18.1-py38ha9443f7_0.conda": { + "build": "py38ha9443f7_0", + "build_number": 0, + "constrains": [ + "pooch >=1.3.0" + ], + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=2.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.8,<3.9.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "md5": "f5cfe0f4abd6b67e37278aa3394d1e28", + "name": "scikit-image", + "sha256": "8840a64725c7e0dd65e20be8f5704cd76fd8a2b0c3211931bfb5783835dc487e", + "size": 10006965, + "subdir": "linux-64", + "timestamp": 1617915337155, + "version": "0.18.1" + }, + "scikit-image-0.18.1-py39ha9443f7_0.conda": { + "build": "py39ha9443f7_0", + "build_number": 0, + "constrains": [ + "pooch >=1.3.0" + ], + "depends": [ + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "matplotlib-base >=2.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0", + "python >=3.9,<3.10.0a0", + "pywavelets >=0.4.0", + "scipy >=0.19", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "md5": "ec7c49e99d05ebb30c57da9036514242", + "name": "scikit-image", + "sha256": "e48960559c6d1fb4062729302592ad04621ebf8e8762b53e643063e598339af1", + "size": 10020059, + "subdir": "linux-64", + "timestamp": 1617915380109, + "version": "0.18.1" + }, + "scikit-image-0.18.3-py310h00e6091_0.conda": { + "build": "py310h00e6091_0", + "build_number": 0, + "constrains": [ + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=2.0.0,!=3.0.0", + "networkx >=2.0", + "numpy >=1.21.2,<2.0a0", + "pillow >=4.3.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.10,<3.11.0a0", + "pywavelets >=1.1.1", + "scipy >=1.0.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2b27c5ee0dfbc5f3c8e4c875b58f2131", + "name": "scikit-image", + "sha256": "5cafc2c46e64062c03e398076c671a91afe6c1194952bd7afdabeaf44e7cde68", + "size": 21534709, + "subdir": "linux-64", + "timestamp": 1640814004541, + "version": "0.18.3" + }, + "scikit-image-0.18.3-py37h51133e4_0.conda": { + "build": "py37h51133e4_0", + "build_number": 0, + "constrains": [ + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=2.0.0,!=3.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=1.1.1", + "scipy >=1.0.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dc7c8462e90b7764ff33c733b9aafda1", + "name": "scikit-image", + "sha256": "4a4d860c82840e57a88271b6a968bc360d6236cc7dda9c3a554fb1e12eac0b5b", + "size": 9829092, + "subdir": "linux-64", + "timestamp": 1635997998156, + "version": "0.18.3" + }, + "scikit-image-0.18.3-py38h51133e4_0.conda": { + "build": "py38h51133e4_0", + "build_number": 0, + "constrains": [ + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=2.0.0,!=3.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.8,<3.9.0a0", + "pywavelets >=1.1.1", + "scipy >=1.0.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "44aea2f0f33f43711ff2ed03ca9cbe37", + "name": "scikit-image", + "sha256": "bdcd59c67c4eaf94df3a0a6af2d7a1c098507e5b8f6841b11a6fc26f2a5a3507", + "size": 9988075, + "subdir": "linux-64", + "timestamp": 1636009727119, + "version": "0.18.3" + }, + "scikit-image-0.18.3-py39h51133e4_0.conda": { + "build": "py39h51133e4_0", + "build_number": 0, + "constrains": [ + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=0.15.0", + "imageio >=2.3.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "matplotlib-base >=2.0.0,!=3.0.0", + "networkx >=2.0", + "numpy >=1.16.6,<2.0a0", + "pillow >=4.3.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.9,<3.10.0a0", + "pywavelets >=1.1.1", + "scipy >=1.0.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6fedc823e65bfff25a466b59cd61be90", + "name": "scikit-image", + "sha256": "850ce049bfd3231d4fe9ca14634c0434115f8a29e578940f0a2af7cb0b463c24", + "size": 9988148, + "subdir": "linux-64", + "timestamp": 1636009968070, + "version": "0.18.3" + }, + "scikit-image-0.19.2-py310h00e6091_0.conda": { + "build": "py310h00e6091_0", + "build_number": 0, + "constrains": [ + "matplotlib-base >=3.0.3", + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.4.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2.2", + "numpy >=1.21.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.1.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.10,<3.11.0a0", + "pywavelets >=1.1.1", + "scipy >=1.4.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "79051c524188387e27937a5cfdc50c1b", + "name": "scikit-image", + "sha256": "0883099d6b4889bf6397d57acd26930487c34c3c092ec405a8fc4ace64c6e7db", + "size": 22196975, + "subdir": "linux-64", + "timestamp": 1648214809138, + "version": "0.19.2" + }, + "scikit-image-0.19.2-py37h51133e4_0.conda": { + "build": "py37h51133e4_0", + "build_number": 0, + "constrains": [ + "pooch >=1.3.0", + "matplotlib-base >=3.0.3" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.4.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2.2", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pillow >=6.1.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=1.1.1", + "scipy >=1.4.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "21e12d2dcc27c0cf2f9dcb8b4f63bda0", + "name": "scikit-image", + "sha256": "f4156947b66582b4ecaafcfc7ffc546938db2769a396a6171d4388b6a492751f", + "size": 10208006, + "subdir": "linux-64", + "timestamp": 1648196607535, + "version": "0.19.2" + }, + "scikit-image-0.19.2-py38h51133e4_0.conda": { + "build": "py38h51133e4_0", + "build_number": 0, + "constrains": [ + "matplotlib-base >=3.0.3", + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.4.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2.2", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pillow >=6.1.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.8,<3.9.0a0", + "pywavelets >=1.1.1", + "scipy >=1.4.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cbe42091efd07c1dbdd5f14031a03ea7", + "name": "scikit-image", + "sha256": "9fb4b05b8dcd107422a8a7748e4906bff168a2ab13a28e548e3c7dafb1a5ec6e", + "size": 10362808, + "subdir": "linux-64", + "timestamp": 1648196840181, + "version": "0.19.2" + }, + "scikit-image-0.19.2-py39h51133e4_0.conda": { + "build": "py39h51133e4_0", + "build_number": 0, + "constrains": [ + "matplotlib-base >=3.0.3", + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.4.1", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "networkx >=2.2", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pillow >=6.1.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.9,<3.10.0a0", + "pywavelets >=1.1.1", + "scipy >=1.4.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f02c42acbfdf6c6593c38afdb2335f8b", + "name": "scikit-image", + "sha256": "a407e1e3ced5234ced66d93775542e5915aa8c595101f2b6bb58dfc9cf467603", + "size": 10392045, + "subdir": "linux-64", + "timestamp": 1648214708343, + "version": "0.19.2" + }, + "scikit-image-0.19.3-py310h6a678d5_1.conda": { + "build": "py310h6a678d5_1", + "build_number": 1, + "constrains": [ + "matplotlib-base >=3.0.3", + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.16.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "networkx >=2.2", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pillow >=6.1.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.10,<3.11.0a0", + "pywavelets >=1.1.1", + "scipy >=1.4.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a5b7168d5c4f6bb7c261689ab24478be", + "name": "scikit-image", + "sha256": "d373f58faa632a838d0b624d4e640e630f1e2329e6351319e713b64425b7fe14", + "size": 10992515, + "subdir": "linux-64", + "timestamp": 1669242126844, + "version": "0.19.3" + }, + "scikit-image-0.19.3-py311h6a678d5_2.conda": { + "build": "py311h6a678d5_2", + "build_number": 2, + "constrains": [ + "matplotlib-base >=3.0.3", + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.16.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "networkx >=2.2", + "numpy >=1.23.5,<2.0a0", + "packaging >=20.0", + "pillow >=6.1.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.11,<3.12.0a0", + "pywavelets >=1.1.1", + "scipy >=1.4.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "87f4df182a7e5c89868b1a94a82d5ab5", + "name": "scikit-image", + "sha256": "17f44f3f4f387bc4d126b141f1771e7d0c2ea1ef8e91bc13babb8aefd984c374", + "size": 10602262, + "subdir": "linux-64", + "timestamp": 1677696607005, + "version": "0.19.3" + }, + "scikit-image-0.19.3-py37h6a678d5_1.conda": { + "build": "py37h6a678d5_1", + "build_number": 1, + "constrains": [ + "matplotlib-base >=3.0.3", + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.16.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "networkx >=2.2,<2.7", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.1.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.7,<3.8.0a0", + "pywavelets >=1.1.1", + "scipy >=1.4.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "af023ff23df606b0e57e073d7503be3a", + "name": "scikit-image", + "sha256": "8bda8372bcf2258dab8f9940fd7870f1d8de8320fb9e2002e1b8e82cbb9022d3", + "size": 10867029, + "subdir": "linux-64", + "timestamp": 1669242736443, + "version": "0.19.3" + }, + "scikit-image-0.19.3-py38h6a678d5_1.conda": { + "build": "py38h6a678d5_1", + "build_number": 1, + "constrains": [ + "matplotlib-base >=3.0.3", + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.16.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "networkx >=2.2", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.1.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.8,<3.9.0a0", + "pywavelets >=1.1.1", + "scipy >=1.4.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f2cb0ce2c102de65bffda5848343576a", + "name": "scikit-image", + "sha256": "7d70f1615cd0eb2bbee243127d9c492c944a738c96d6afd63bcaa2fa7e828a2b", + "size": 11035764, + "subdir": "linux-64", + "timestamp": 1669243310658, + "version": "0.19.3" + }, + "scikit-image-0.19.3-py39h6a678d5_1.conda": { + "build": "py39h6a678d5_1", + "build_number": 1, + "constrains": [ + "matplotlib-base >=3.0.3", + "pooch >=1.3.0" + ], + "depends": [ + "_openmp_mutex", + "cloudpickle >=0.2.1", + "cytoolz >=0.7.3", + "dask-core >=1.0.0,!=2.17.0", + "imageio >=2.16.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "networkx >=2.2", + "numpy >=1.19.2,<2.0a0", + "packaging >=20.0", + "pillow >=6.1.0,!=7.1.0,!=7.1.1,!=8.3.0", + "python >=3.9,<3.10.0a0", + "pywavelets >=1.1.1", + "scipy >=1.4.1", + "tifffile >=2019.7.26", + "toolz >=0.7.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "348f8fad5592eb33567a1c8f5dfac004", + "name": "scikit-image", + "sha256": "9c6c860d47f462861e69bc8776f94a511db77a03a59f512447288f22fa9e712a", + "size": 10995871, + "subdir": "linux-64", + "timestamp": 1669243871552, + "version": "0.19.3" + }, + "scikit-learn-0.19.0-py27_nomklh0ffebdf_2.conda": { + "build": "py27_nomklh0ffebdf_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "74716bd90c0e8d4695c2665d4149607c", + "name": "scikit-learn", + "sha256": "2a3187a4f9c95a6d15f25fd7252bdcfe03cd2abb2c9efb32b2ffcf686664cbd7", + "size": 4196119, + "subdir": "linux-64", + "timestamp": 1509734370393, + "version": "0.19.0" + }, + "scikit-learn-0.19.0-py27hd893acb_2.conda": { + "build": "py27hd893acb_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "22cd30864789fdd5dcc2969b8b67d78d", + "name": "scikit-learn", + "sha256": "e8bcaf95a27f9ccce84a5a33d26ee43d2da5c753e24794e60699b2da5fb5dab1", + "size": 4217443, + "subdir": "linux-64", + "timestamp": 1505754160505, + "version": "0.19.0" + }, + "scikit-learn-0.19.0-py35_nomklh375dd1d_2.conda": { + "build": "py35_nomklh375dd1d_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "12f716a772f3e2b8950d1de5ec71fc02", + "name": "scikit-learn", + "sha256": "f14955438354d67ab96a96a1a3c3d19894d1b4e95ef3c0983025f627248220ba", + "size": 4109084, + "subdir": "linux-64", + "timestamp": 1509734440155, + "version": "0.19.0" + }, + "scikit-learn-0.19.0-py35h25e8076_2.conda": { + "build": "py35h25e8076_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "906d97f3f2379b8f02c6729f4b2d84e6", + "name": "scikit-learn", + "sha256": "8d0cd17fc551d3c6c7f6fbfdb8c8519ad1f70fc6b3c18bd23812762cf65b0e4c", + "size": 4107368, + "subdir": "linux-64", + "timestamp": 1505754719651, + "version": "0.19.0" + }, + "scikit-learn-0.19.0-py36_nomklh41feb14_2.conda": { + "build": "py36_nomklh41feb14_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "134d170f8f5e6466aac3c8f5e5d73b4b", + "name": "scikit-learn", + "sha256": "1b3010fb35a1959296f1eb47bcd092d14cfa9509b82c3cacc96d9b5ecce725bb", + "size": 4114781, + "subdir": "linux-64", + "timestamp": 1509734565763, + "version": "0.19.0" + }, + "scikit-learn-0.19.0-py36h97ac459_2.conda": { + "build": "py36h97ac459_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "908455b30f6480af01f84bf79cb3f2a2", + "name": "scikit-learn", + "sha256": "f8c10370826ac144f1adeefbf0d903f1d3ba6404132d40409924f57966d4181f", + "size": 4134591, + "subdir": "linux-64", + "timestamp": 1505755249949, + "version": "0.19.0" + }, + "scikit-learn-0.19.1-py27_nomklh6479e79_0.conda": { + "build": "py27_nomklh6479e79_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "9f9bcada1c872673b706427bfad9ef08", + "name": "scikit-learn", + "sha256": "d1d110efe2b0d14ca70a07ba279d955202df86d0626c056f7433b73c68d1e55a", + "size": 4225658, + "subdir": "linux-64", + "timestamp": 1509990070121, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py27_nomklh6cfcb94_0.conda": { + "build": "py27_nomklh6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "695fa4f400e9cde4aed524cdf8e9b155", + "name": "scikit-learn", + "sha256": "540a8d0c67dc132444ad546d94cea5c1fd1c2cf22b0e26c1fb8b67196069c029", + "size": 4197150, + "subdir": "linux-64", + "timestamp": 1530840278665, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py27h445a80a_0.conda": { + "build": "py27h445a80a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "1e984ce227027245c0aaacfea81c1a9d", + "name": "scikit-learn", + "sha256": "5255e7611d22b531ec5d8ff4bcaa0c54e7e6858ed5bdc7d1e8d242da4538767f", + "size": 4225987, + "subdir": "linux-64", + "timestamp": 1508764313894, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py27hedc7406_0.conda": { + "build": "py27hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "894e3ba3d35ac84d4ec82903e36dc603", + "name": "scikit-learn", + "sha256": "f260feaa3cfb2a0b7d608856be72609fd416876cf9bf6f360cdecb9b7e7f0bc8", + "size": 4197341, + "subdir": "linux-64", + "timestamp": 1530839068002, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py35_nomklh26d41a3_0.conda": { + "build": "py35_nomklh26d41a3_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "fb829dd7a940d21ad0ddbd2e2cb85039", + "name": "scikit-learn", + "sha256": "add382db32372cd9c642acdf773530d3229ece95aed1795c8a600ad58eec51ed", + "size": 4112756, + "subdir": "linux-64", + "timestamp": 1509990074280, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py35hbf1f462_0.conda": { + "build": "py35hbf1f462_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "f1496c67bb7f51ec8ae8c4cf9be813be", + "name": "scikit-learn", + "sha256": "add55da2ab00eb7ca5b294c677e7225f1f3a9c80b0848a8f794639f1851229f7", + "size": 4114571, + "subdir": "linux-64", + "timestamp": 1508764275439, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py36_nomklh27f7947_0.conda": { + "build": "py36_nomklh27f7947_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "c34909b9ffde3640255fbe9351329c9b", + "name": "scikit-learn", + "sha256": "5700fa0fc691fea864f42b93cc437f95e68868e88c37b5ddf9606f8448609ef6", + "size": 4118715, + "subdir": "linux-64", + "timestamp": 1509989934790, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py36_nomklh6cfcb94_0.conda": { + "build": "py36_nomklh6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "cd774d15d71cda7c90bcfb322f6ba79b", + "name": "scikit-learn", + "sha256": "def2af7f7c23d20589e33e2ce535b07bc760989ab2c5defe58a9f0da0c11cbd3", + "size": 4108846, + "subdir": "linux-64", + "timestamp": 1530842082052, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py36h7aa7ec6_0.conda": { + "build": "py36h7aa7ec6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "2cf6d405fa573cd8076983a7c96a1606", + "name": "scikit-learn", + "sha256": "1e1439dbf13c2f15f6e4eeab28dbb7a88e27616df331e5c01f8b8e0330b4a58b", + "size": 4120628, + "subdir": "linux-64", + "timestamp": 1508764315710, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py36hedc7406_0.conda": { + "build": "py36hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "79ed55920c5b70005adf82402a97320f", + "name": "scikit-learn", + "sha256": "d88ea273c51cd400c49e15a3ee47ed5a55aa384996a292ff4efd944a8d4b9099", + "size": 4133445, + "subdir": "linux-64", + "timestamp": 1530841220566, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py37_nomklh6cfcb94_0.conda": { + "build": "py37_nomklh6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "18ac39e1f4c863bee96cdccdaa1b092a", + "name": "scikit-learn", + "sha256": "6d87d2b069b779c178b80845f93ef621c3b6eaa3a6ac0d224425449c681eda8b", + "size": 4132706, + "subdir": "linux-64", + "timestamp": 1530838232533, + "version": "0.19.1" + }, + "scikit-learn-0.19.1-py37hedc7406_0.conda": { + "build": "py37hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "1c3e2af2d67043cb973f6490f6917be5", + "name": "scikit-learn", + "sha256": "f5f4911744ea7c34e2df745cac18efdb69304cfa5cb23ad9c6c78d5f3bba39f0", + "size": 4109490, + "subdir": "linux-64", + "timestamp": 1530837380199, + "version": "0.19.1" + }, + "scikit-learn-0.19.2-py27h22eb022_0.conda": { + "build": "py27h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "62e08e31a6a6f509c8d8c6f5c9dfb42a", + "name": "scikit-learn", + "sha256": "7736b81c2ded046bea2331945e1808e54e93a4ca9055127446df052e5fdb585b", + "size": 4201745, + "subdir": "linux-64", + "timestamp": 1537478138014, + "version": "0.19.2" + }, + "scikit-learn-0.19.2-py27h4989274_0.conda": { + "build": "py27h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "6080210a0a0a89aab1f1ba9491d9e647", + "name": "scikit-learn", + "sha256": "66b4952ccdbf057caf05eeff75810238d78ee3b1287c00b42fd3634d66dd1348", + "size": 4179002, + "subdir": "linux-64", + "timestamp": 1537478715232, + "version": "0.19.2" + }, + "scikit-learn-0.19.2-py35h22eb022_0.conda": { + "build": "py35h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "cd55ffe30f645ddcc55510351dd67aaf", + "name": "scikit-learn", + "sha256": "71eeb5275502b334c9f9d89c8128cd0bf16bcd8d8005c1eada1eab4fd6e7a822", + "size": 4138504, + "subdir": "linux-64", + "timestamp": 1537478083323, + "version": "0.19.2" + }, + "scikit-learn-0.19.2-py35h4989274_0.conda": { + "build": "py35h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "7e5be81fd7ce5715b499b74c96f0f5a2", + "name": "scikit-learn", + "sha256": "98d00e578d7897a53a4eade1b1055a69a5437d9b65409b3dcf82a506c59626b3", + "size": 4117661, + "subdir": "linux-64", + "timestamp": 1537478466829, + "version": "0.19.2" + }, + "scikit-learn-0.19.2-py36h22eb022_0.conda": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "aad845b12710085e80919a37a2d8cb0b", + "name": "scikit-learn", + "sha256": "0781c46b1fbd72aa2069b92c1da3ae9d5a2339c60f287ad11bc3dcb56628ead8", + "size": 4112791, + "subdir": "linux-64", + "timestamp": 1537478215105, + "version": "0.19.2" + }, + "scikit-learn-0.19.2-py36h4989274_0.conda": { + "build": "py36h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "07742ec1e580914fe34837d559970756", + "name": "scikit-learn", + "sha256": "86ee10ef083826c7eb092af233361ad5d0d2d16df35f06b905998f1c7aafb120", + "size": 4114298, + "subdir": "linux-64", + "timestamp": 1537478778054, + "version": "0.19.2" + }, + "scikit-learn-0.19.2-py37h22eb022_0.conda": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "122eca860f63f7dac1a33e6320c9f506", + "name": "scikit-learn", + "sha256": "4ea50609dc2adcda7aa01b8c68d807f0264272602e185603ee6908f2b68291e6", + "size": 4101011, + "subdir": "linux-64", + "timestamp": 1537478089554, + "version": "0.19.2" + }, + "scikit-learn-0.19.2-py37h4989274_0.conda": { + "build": "py37h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "948fd2b279af31d08a80a61bd061a589", + "name": "scikit-learn", + "sha256": "670410e6973d5855ae9fdf45ef729f67bbae69119cb21f98f00ed70017cbaaf4", + "size": 4126446, + "subdir": "linux-64", + "timestamp": 1537478439400, + "version": "0.19.2" + }, + "scikit-learn-0.20.0-py27h22eb022_0.conda": { + "build": "py27h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "e718cb1533b4b1c2b79dff51e7fc5c61", + "name": "scikit-learn", + "sha256": "74914ec3e71a12267e607e7d92506bb5546a2e9a5bfb0687a820f5c1c8c465d1", + "size": 4623129, + "subdir": "linux-64", + "timestamp": 1537975606170, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py27h22eb022_1.conda": { + "build": "py27h22eb022_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "e01990effb66c410385bdfc5cd1cb22b", + "name": "scikit-learn", + "sha256": "51bbdd669d2487d03e38bb0df179c4a2e565d226eb9f45744c4e13ee6232efde", + "size": 4597634, + "subdir": "linux-64", + "timestamp": 1538056845417, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py27h4989274_0.conda": { + "build": "py27h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "7e79307e6828ff9cd133a0e95d3d7011", + "name": "scikit-learn", + "sha256": "94f93be8641fca39781aa6576e39655dafb3d024e56d2bac4ad229d9413b35b8", + "size": 4623203, + "subdir": "linux-64", + "timestamp": 1537975691271, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py27h4989274_1.conda": { + "build": "py27h4989274_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "b7817a108e6cb31d174e923e73aac092", + "name": "scikit-learn", + "sha256": "279d2ad759361d47742f6c3ff1b9b8a5d4bb5ecdc93cd87e410fba512912ad36", + "size": 4624521, + "subdir": "linux-64", + "timestamp": 1538057234496, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py35h22eb022_0.conda": { + "build": "py35h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "4d47a682b3efa3b61531d1f6251f6d60", + "name": "scikit-learn", + "sha256": "05a78f93e139dd1722b97de74efb6823833d1cf60f51a7d76d29023f6b077398", + "size": 4565898, + "subdir": "linux-64", + "timestamp": 1537975695314, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py35h22eb022_1.conda": { + "build": "py35h22eb022_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "afd9d91426b1f91998c8fa2b82ff3c18", + "name": "scikit-learn", + "sha256": "ed86e47ebaac4d0629deae4b17a648b8b048f88a7fb3a37789ad1f35dab1aad6", + "size": 4535834, + "subdir": "linux-64", + "timestamp": 1538056894882, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py35h4989274_0.conda": { + "build": "py35h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "bb6807cefcfcf3b14a235d6ddbeb1267", + "name": "scikit-learn", + "sha256": "9a19494bc618f738a57d566538833372e49e8b66b6bf0a1eac579bb1ae256372", + "size": 4537381, + "subdir": "linux-64", + "timestamp": 1537975674618, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py35h4989274_1.conda": { + "build": "py35h4989274_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "e24fefe1a760dc498c781a0663e893f7", + "name": "scikit-learn", + "sha256": "4e40d58dba71de1c6beef1f46e8a95b92b5123617045a089bee3eb048aceeae7", + "size": 4566879, + "subdir": "linux-64", + "timestamp": 1538057428755, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py36h22eb022_0.conda": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "5cc4577b47e086eb98110311d44c5c9f", + "name": "scikit-learn", + "sha256": "3e9aeefeb89b4177f0b6de49defcb7a4901bd00684f8e923950a8be6831ac2b7", + "size": 4556189, + "subdir": "linux-64", + "timestamp": 1537977081536, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py36h22eb022_1.conda": { + "build": "py36h22eb022_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "04d2d74baac5bed3e77b7d2b814cb3f6", + "name": "scikit-learn", + "sha256": "9e11e708bb8444febbddaa1e4dcefb0d98cda642db81d37666b003c8db4f7d1b", + "size": 4532276, + "subdir": "linux-64", + "timestamp": 1538056878726, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py36h4989274_0.conda": { + "build": "py36h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "866cf0eb5d0d5d40cc59a58a38ab1841", + "name": "scikit-learn", + "sha256": "0a7ba6037f1deb4b03be9f3468e72715181c55c33f86ac614e2127866643abe6", + "size": 4530813, + "subdir": "linux-64", + "timestamp": 1537975682954, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py36h4989274_1.conda": { + "build": "py36h4989274_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "5256a74378958c3567aa4096a2beeef8", + "name": "scikit-learn", + "sha256": "a08daa2a89ca3a4b02afdf1155d27714b0fd64f9b3238c9491d6d67346ad6393", + "size": 4532155, + "subdir": "linux-64", + "timestamp": 1538057463166, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py37h22eb022_0.conda": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "236ad1622774240ccf2e3e28e779e8a1", + "name": "scikit-learn", + "sha256": "5bf31bf0ff86d4347840cdf95e4fe4bd51b97c142301468a135ebd9038f05d98", + "size": 4523074, + "subdir": "linux-64", + "timestamp": 1537975548225, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py37h22eb022_1.conda": { + "build": "py37h22eb022_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "038c746bbd08256b8874ca9071e0da60", + "name": "scikit-learn", + "sha256": "a900f79f53f68b3bc27c74905c6ae3accef5fb2272dc12ff4530ace030d38714", + "size": 4548340, + "subdir": "linux-64", + "timestamp": 1538064324996, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py37h4989274_0.conda": { + "build": "py37h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "ae0f674006de18e2d30cbb8f123ffa1c", + "name": "scikit-learn", + "sha256": "7ee0412e08a345b1501c7a1846ba8206a29357d7fff3078cf29a2ba93ca542c0", + "size": 4524398, + "subdir": "linux-64", + "timestamp": 1537975667418, + "version": "0.20.0" + }, + "scikit-learn-0.20.0-py37h4989274_1.conda": { + "build": "py37h4989274_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "ec48e89a40b85d9ffe8fb47e0a2b588e", + "name": "scikit-learn", + "sha256": "44e0ed9a547f16e62820a81bf1e289005afe68089b70a08a2b794669191185a8", + "size": 4525761, + "subdir": "linux-64", + "timestamp": 1538057132864, + "version": "0.20.0" + }, + "scikit-learn-0.20.1-py27h22eb022_0.conda": { + "build": "py27h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "c08d22a68db66557cd93dd6a0259ee04", + "name": "scikit-learn", + "sha256": "ad380125301ef121be85a012ca632e6b6dcf294e53987caacc04e08c30c62f61", + "size": 4638939, + "subdir": "linux-64", + "timestamp": 1542950750557, + "version": "0.20.1" + }, + "scikit-learn-0.20.1-py27h4989274_0.conda": { + "build": "py27h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "8bbde45abbd5fff1e84dff73bbc8fd58", + "name": "scikit-learn", + "sha256": "a76b7cead61e616fdc485c98be5f9605e14c19ab9934b26bf215da399917bd48", + "size": 4639076, + "subdir": "linux-64", + "timestamp": 1543000867296, + "version": "0.20.1" + }, + "scikit-learn-0.20.1-py27hd81dba3_0.conda": { + "build": "py27hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "4ee34c844a47061c3f0433bc9695873c", + "name": "scikit-learn", + "sha256": "e7cf4b65d11a105cdb8b582ccc736fe327d7303a32d8077a4303b02933c3e626", + "size": 4639471, + "subdir": "linux-64", + "timestamp": 1544817272383, + "version": "0.20.1" + }, + "scikit-learn-0.20.1-py36h22eb022_0.conda": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "07f7cefdc8ea67b24c4688e3dbbce50d", + "name": "scikit-learn", + "sha256": "13b996dfecfc01aadaf981a7513312705555e7455c4da57fcb24a896cb28f67f", + "size": 4634588, + "subdir": "linux-64", + "timestamp": 1542950685408, + "version": "0.20.1" + }, + "scikit-learn-0.20.1-py36h4989274_0.conda": { + "build": "py36h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "ddcc6f6a23aa9ad259f16178e18bec4c", + "name": "scikit-learn", + "sha256": "83a45275601e3c4d0616dae9fb6f6d5a3f4d0f3aca2dc0472605bf7e580de83e", + "size": 4609429, + "subdir": "linux-64", + "timestamp": 1542950851573, + "version": "0.20.1" + }, + "scikit-learn-0.20.1-py36hd81dba3_0.conda": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "3fd3f791856cb4b971378117753fdacb", + "name": "scikit-learn", + "sha256": "69bd6a0fd1bdf95a8a3c3ada7bb2adb9e8aa83508f67d6059d5af0b65ed49ea0", + "size": 4636013, + "subdir": "linux-64", + "timestamp": 1544817327740, + "version": "0.20.1" + }, + "scikit-learn-0.20.1-py37h22eb022_0.conda": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "c476f711fbe1d2856d156b73401da562", + "name": "scikit-learn", + "sha256": "2731780b86b590cbe929cce0544e5065446f7d5cc294a64b0a169f5c2eb87182", + "size": 4603958, + "subdir": "linux-64", + "timestamp": 1542950687073, + "version": "0.20.1" + }, + "scikit-learn-0.20.1-py37h4989274_0.conda": { + "build": "py37h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "7dd96d53e3a236ad657e297a15c65aba", + "name": "scikit-learn", + "sha256": "e1489b362ac321d24e6d18511ecebfcfa99c7fc215a011ed5590b796e599688a", + "size": 4605122, + "subdir": "linux-64", + "timestamp": 1543029701541, + "version": "0.20.1" + }, + "scikit-learn-0.20.1-py37hd81dba3_0.conda": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "2a7ebf1b55b15c5af63081aecd8193a7", + "name": "scikit-learn", + "sha256": "53e4fdbc9c7d30c6acb73081982a75324e09fa5584ba24b5838276627b9fe062", + "size": 4628780, + "subdir": "linux-64", + "timestamp": 1544817320148, + "version": "0.20.1" + }, + "scikit-learn-0.20.2-py27h22eb022_0.conda": { + "build": "py27h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "244218f86634490eb88da8cbc1be4ab1", + "name": "scikit-learn", + "sha256": "3af2e8fc59da3cedaa731337005b40ed94c09be7efbae7f914a227ba109440d7", + "size": 4664551, + "subdir": "linux-64", + "timestamp": 1545937696099, + "version": "0.20.2" + }, + "scikit-learn-0.20.2-py27hd81dba3_0.conda": { + "build": "py27hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "892d34519f435d6d2e599623ca3517bc", + "name": "scikit-learn", + "sha256": "5a02d38f18c1197296ab1c7ec2b76ff7471def386b6b6c4f7b0be09091f18050", + "size": 4641804, + "subdir": "linux-64", + "timestamp": 1545937860581, + "version": "0.20.2" + }, + "scikit-learn-0.20.2-py36h22eb022_0.conda": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "98666219784a6541cc667a3b174b2fbf", + "name": "scikit-learn", + "sha256": "d19b383af119ca0167a85de37a3e5e67dfb87b08062b8d08447dd5e75d1385e7", + "size": 4638238, + "subdir": "linux-64", + "timestamp": 1545937719956, + "version": "0.20.2" + }, + "scikit-learn-0.20.2-py36hd81dba3_0.conda": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "4ed13bcbe70a8fefe6be0e3cb647b7fe", + "name": "scikit-learn", + "sha256": "33d286a53bcfa5672d6a7aecd7ae01d6939c8a23878c711aa8420a4e7736bf81", + "size": 4610793, + "subdir": "linux-64", + "timestamp": 1545937635812, + "version": "0.20.2" + }, + "scikit-learn-0.20.2-py37h22eb022_0.conda": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "3051f34d5667827d506f3e40d6873728", + "name": "scikit-learn", + "sha256": "1732c5bffe7c1bbd1bca878aa902af7852c791a333015b86e63accd336143a93", + "size": 4630113, + "subdir": "linux-64", + "timestamp": 1545937690744, + "version": "0.20.2" + }, + "scikit-learn-0.20.2-py37hd81dba3_0.conda": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "198ca76110e59fd4f33d7b02b3e5e612", + "name": "scikit-learn", + "sha256": "3d96e76ec8417dc1ab205e6678c1690948ea115f4c393595b2b46a0021d9f210", + "size": 4606621, + "subdir": "linux-64", + "timestamp": 1545937715117, + "version": "0.20.2" + }, + "scikit-learn-0.20.3-py27h22eb022_0.conda": { + "build": "py27h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "ee6757c98842dd8e3374a1a50df46073", + "name": "scikit-learn", + "sha256": "ae12fe270fcf174b9987c7431d39b42890ca4f4615a9a41050a56fbb99a63a91", + "size": 4678677, + "subdir": "linux-64", + "timestamp": 1552419142299, + "version": "0.20.3" + }, + "scikit-learn-0.20.3-py27hd81dba3_0.conda": { + "build": "py27hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "ebadc4bb0a094eefada9986c1d1ccc7b", + "name": "scikit-learn", + "sha256": "85d9e606c653e6f7720b85b3c4f24e2994867fb7bac890c2fc2d04b3ec2beadf", + "size": 4679519, + "subdir": "linux-64", + "timestamp": 1552417963365, + "version": "0.20.3" + }, + "scikit-learn-0.20.3-py36h22eb022_0.conda": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "c38a86e6476753c68d618862772dd42a", + "name": "scikit-learn", + "sha256": "44b22c830378112fcc3a054e3dbcfa476043e0cc5ac0aff892192acf92836e60", + "size": 4646717, + "subdir": "linux-64", + "timestamp": 1552417845471, + "version": "0.20.3" + }, + "scikit-learn-0.20.3-py36hd81dba3_0.conda": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "2ee5c8453e1a3d03fc1b39282f6dc006", + "name": "scikit-learn", + "sha256": "cf45734127c2058901d2cce6741fadc2f09f879960dbb0174b23abdcc3a0db2b", + "size": 4648163, + "subdir": "linux-64", + "timestamp": 1552419333259, + "version": "0.20.3" + }, + "scikit-learn-0.20.3-py37h22eb022_0.conda": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "3f8c61d3693a2e24356e53f85a22ffbf", + "name": "scikit-learn", + "sha256": "0b7316aa0cc574567eb29016f3a148940b39a2ece02d8dafe0f6ea483e76cb93", + "size": 4667091, + "subdir": "linux-64", + "timestamp": 1552419025243, + "version": "0.20.3" + }, + "scikit-learn-0.20.3-py37hd81dba3_0.conda": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "284361ed921dfd8986e1a2b46b580b05", + "name": "scikit-learn", + "sha256": "3d44b20f327102bfdd8ce014e024649d208435dbfa8f7c989dd1610c0fb976db", + "size": 4668731, + "subdir": "linux-64", + "timestamp": 1552419338884, + "version": "0.20.3" + }, + "scikit-learn-0.21.1-py36h22eb022_0.conda": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "9cdd00aea87223f347e56a2a59263798", + "name": "scikit-learn", + "sha256": "95a04f284de63958fd4b4af4aabc3ddcbdc30af3333090ee8081182dda907a3a", + "size": 5170292, + "subdir": "linux-64", + "timestamp": 1558144091572, + "version": "0.21.1" + }, + "scikit-learn-0.21.1-py36hd81dba3_0.conda": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "b3691cde9633aa91ba65a2e31e98cdf1", + "name": "scikit-learn", + "sha256": "1351c894a02cbf2fd2d0f5bdc62b2ca5bcad5b264de21b26e4cae68397e3150f", + "size": 5200439, + "subdir": "linux-64", + "timestamp": 1558144207485, + "version": "0.21.1" + }, + "scikit-learn-0.21.1-py37h22eb022_0.conda": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "710e2fdad301d10f0449f11e52b08e56", + "name": "scikit-learn", + "sha256": "dd440aefc80d75efb834ace12c2c6474546e41eb51c61c5f2383607266eb8fe7", + "size": 5183658, + "subdir": "linux-64", + "timestamp": 1558143679327, + "version": "0.21.1" + }, + "scikit-learn-0.21.1-py37hd81dba3_0.conda": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.3,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "3d0e7ead93a24e7eabf075d951cc0c90", + "name": "scikit-learn", + "sha256": "fdfdb9417af5c54f23ba28af932a4b54437845437d4242763d1863e9ac209557", + "size": 5183621, + "subdir": "linux-64", + "timestamp": 1558143803579, + "version": "0.21.1" + }, + "scikit-learn-0.21.1-py38h22eb022_0.conda": { + "build": "py38h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "5980b30eb071cbb39bdb5d64489d2d09", + "name": "scikit-learn", + "sha256": "06cc73219459d614e0fed93ba3afb936eb248f480d969613c999ead721287851", + "size": 5332842, + "subdir": "linux-64", + "timestamp": 1574275317479, + "version": "0.21.1" + }, + "scikit-learn-0.21.1-py38hd81dba3_0.conda": { + "build": "py38hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "0b92b94a2726c745592bd1177a13722e", + "name": "scikit-learn", + "sha256": "fea37f6b5881ee3e752ccac9f18d054b263304bf9736fe01fe441c0e32ce05a7", + "size": 5333112, + "subdir": "linux-64", + "timestamp": 1574274746174, + "version": "0.21.1" + }, + "scikit-learn-0.21.2-py36h22eb022_0.conda": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "ceb402d677c873dc68e054898cf98866", + "name": "scikit-learn", + "sha256": "6e83968c366b301dbb45d1afb05977dd62d67a0468532708ada78780b0092741", + "size": 5194404, + "subdir": "linux-64", + "timestamp": 1559646310151, + "version": "0.21.2" + }, + "scikit-learn-0.21.2-py36hd81dba3_0.conda": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "13a8cf4e4f0c525241a401a7c2a28416", + "name": "scikit-learn", + "sha256": "1ad68090f18ae73c203a71bc352d5b9401d5000d12361d87c1edfe8af6a19a95", + "size": 5194768, + "subdir": "linux-64", + "timestamp": 1559646374541, + "version": "0.21.2" + }, + "scikit-learn-0.21.2-py37h22eb022_0.conda": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "94d3ea3835a79b1e35ca3b3753a18980", + "name": "scikit-learn", + "sha256": "4af5eb21f73f815799605c7f37aa6adf2b5beb28d00eb3bc744140c75bbaebe3", + "size": 5054772, + "subdir": "linux-64", + "timestamp": 1559646259594, + "version": "0.21.2" + }, + "scikit-learn-0.21.2-py37hd81dba3_0.conda": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "7b0a28383a19e930bddf976a45895b06", + "name": "scikit-learn", + "sha256": "d57d1d14e8fc6d47e60571c085ac5669e2321a80184c9f27bca0c4322bcca9f0", + "size": 5186852, + "subdir": "linux-64", + "timestamp": 1559646192009, + "version": "0.21.2" + }, + "scikit-learn-0.21.3-py36h22eb022_0.conda": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "1ef907a0a7a07e4effa861843ea1b4f9", + "name": "scikit-learn", + "sha256": "8a47828ef84ab708eef1319815a95cc04a626084bfcc5ee383d5cf21adbd1048", + "size": 5196200, + "subdir": "linux-64", + "timestamp": 1569370060386, + "version": "0.21.3" + }, + "scikit-learn-0.21.3-py36hd81dba3_0.conda": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "14dde7895cfe7fd9ae7662d4a97575b3", + "name": "scikit-learn", + "sha256": "134959719a017efd18b49e3aea47e59bf2549baf615721f91f889f6d16647ac8", + "size": 5210890, + "subdir": "linux-64", + "timestamp": 1569369885554, + "version": "0.21.3" + }, + "scikit-learn-0.21.3-py37h22eb022_0.conda": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "095d932e2a5f510ae9192449839c1c4e", + "name": "scikit-learn", + "sha256": "fbbcda0aca0a757fb6066a9de97fa1f03e34da7c8a61835753f0f65c2ccdf262", + "size": 5181034, + "subdir": "linux-64", + "timestamp": 1569370009384, + "version": "0.21.3" + }, + "scikit-learn-0.21.3-py37hd81dba3_0.conda": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "05dbfc8f01c286fc4133573402a6921a", + "name": "scikit-learn", + "sha256": "24bb74e97e993bb01d4e4ecca1a84bacf7151337a941d4551b94e57ed5d7f5ed", + "size": 5180602, + "subdir": "linux-64", + "timestamp": 1569370043587, + "version": "0.21.3" + }, + "scikit-learn-0.22-py36h22eb022_0.conda": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "4bcc26336e181c1c0782e6e1ad011495", + "name": "scikit-learn", + "sha256": "c2bc52b203707bd613c8c865d0acf1195cadab2d7a60d57e1f909a14c3cf617f", + "size": 5527676, + "subdir": "linux-64", + "timestamp": 1576601111313, + "version": "0.22" + }, + "scikit-learn-0.22-py36hd81dba3_0.conda": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "07ce8a234fb585643b36919289742340", + "name": "scikit-learn", + "sha256": "de680330e643489c3cd1ef478c14b27c0bd950bce0d2358d79cac56a1969e94b", + "size": 5519668, + "subdir": "linux-64", + "timestamp": 1576601224046, + "version": "0.22" + }, + "scikit-learn-0.22-py37h22eb022_0.conda": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "209d730e8b197ac65fb53bb28aaf418f", + "name": "scikit-learn", + "sha256": "6c551e4090b3985824a459968ec889e0ecc855efea6bb45edecc7c7d2bc146b4", + "size": 5486965, + "subdir": "linux-64", + "timestamp": 1576601090329, + "version": "0.22" + }, + "scikit-learn-0.22-py37hd81dba3_0.conda": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "936dba2dda750a7732c74c91e2cea7c5", + "name": "scikit-learn", + "sha256": "88383b0773d49149dc1a808f4be3ad47ab147d7a83dcd0cb9777d48283eb8f7a", + "size": 5518172, + "subdir": "linux-64", + "timestamp": 1576601112653, + "version": "0.22" + }, + "scikit-learn-0.22-py38h22eb022_0.conda": { + "build": "py38h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "ea363dfec5617dd13301f96cf504e3fd", + "name": "scikit-learn", + "sha256": "eb3b2781e8f5d76edfa84331aa035e94c66c9997053330db073ab918b715227e", + "size": 5650544, + "subdir": "linux-64", + "timestamp": 1576601088192, + "version": "0.22" + }, + "scikit-learn-0.22-py38hd81dba3_0.conda": { + "build": "py38hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "e63996f3840f2a39e426703c4864ec9f", + "name": "scikit-learn", + "sha256": "a0bc00085432b91d63f95cb5edbaf4b65d0cfc136b887480b2eee789c4a28aa8", + "size": 5630311, + "subdir": "linux-64", + "timestamp": 1576601213204, + "version": "0.22" + }, + "scikit-learn-0.22.1-py36h22eb022_0.conda": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "3fd67308f893455ec77224b50989d041", + "name": "scikit-learn", + "sha256": "8f2a39fb4d622977fed2cc8ad8628bbab9f9e1f39050828bab322498a5cf8835", + "size": 5529022, + "subdir": "linux-64", + "timestamp": 1578509975908, + "version": "0.22.1" + }, + "scikit-learn-0.22.1-py36hd81dba3_0.conda": { + "build": "py36hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "b89012b3d5baabc536e1a3b62541c1d3", + "name": "scikit-learn", + "sha256": "9b543b53fb6af36056b2fdaeff43da7f650df50ea99eac4758547cc3dbe25762", + "size": 5508907, + "subdir": "linux-64", + "timestamp": 1578509987373, + "version": "0.22.1" + }, + "scikit-learn-0.22.1-py37h22eb022_0.conda": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "3238cf7567d7f647f21f4a4e1755a90e", + "name": "scikit-learn", + "sha256": "09cd1d4bea50f8f9d61d3b8730afc14c0246341d93bb5fbc1783c2765d1dbd50", + "size": 5520100, + "subdir": "linux-64", + "timestamp": 1578509859744, + "version": "0.22.1" + }, + "scikit-learn-0.22.1-py37hd81dba3_0.conda": { + "build": "py37hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "1b8dfcaab1933790762a70d0b7d02bec", + "name": "scikit-learn", + "sha256": "28cde69537ce150f5d215baee3783b55d9059af24ec285b876ac500284ff3e10", + "size": 5503203, + "subdir": "linux-64", + "timestamp": 1578511515842, + "version": "0.22.1" + }, + "scikit-learn-0.22.1-py38h22eb022_0.conda": { + "build": "py38h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "9ee7e3b28f99d0f835ac6b9b50a89026", + "name": "scikit-learn", + "sha256": "c2a05163e7ac935ef5fcbd8943b6db8bd2303662e0a9863d86b095727cb05e22", + "size": 5643438, + "subdir": "linux-64", + "timestamp": 1578509841107, + "version": "0.22.1" + }, + "scikit-learn-0.22.1-py38hd81dba3_0.conda": { + "build": "py38hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "md5": "6f6a8f6e093e765faec766ce571c6cd3", + "name": "scikit-learn", + "sha256": "b87830c604e6dcb17fe1a5976c74947ee3dd5e2bb7ebdb6ee37b65554c16defe", + "size": 5639598, + "subdir": "linux-64", + "timestamp": 1578509838414, + "version": "0.22.1" + }, + "scikit-learn-0.23.1-py36h423224d_0.conda": { + "build": "py36h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "2a4677759451b7ba3df4d5e5150340a4", + "name": "scikit-learn", + "sha256": "54923aced9451632f5e8fe1c5b4750cf863f324f002f471eca935b28ca74f8f2", + "size": 5305639, + "subdir": "linux-64", + "timestamp": 1592503220041, + "version": "0.23.1" + }, + "scikit-learn-0.23.1-py36h7ea95a0_0.conda": { + "build": "py36h7ea95a0_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "aa25fdd338fbceab47a480306eea593f", + "name": "scikit-learn", + "sha256": "773261d7839947609a63cca9548a57d7fec95585783ae908ef515c8af8d57459", + "size": 5273711, + "subdir": "linux-64", + "timestamp": 1592503234780, + "version": "0.23.1" + }, + "scikit-learn-0.23.1-py37h423224d_0.conda": { + "build": "py37h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "c989ff87c061175fd66f5e92e9d86ef7", + "name": "scikit-learn", + "sha256": "d233de6dfba4adb61919d236243e9d6c99d82636d7deba6cf5a677e888cf8e26", + "size": 5277856, + "subdir": "linux-64", + "timestamp": 1592503229047, + "version": "0.23.1" + }, + "scikit-learn-0.23.1-py37h7ea95a0_0.conda": { + "build": "py37h7ea95a0_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "f92dc6fffdb98b11182cdb2b4c7e59d4", + "name": "scikit-learn", + "sha256": "270ad11ec4414f6eb3d52e53002d27dfd3be0a58faa834701f19c4142cf676a5", + "size": 5298546, + "subdir": "linux-64", + "timestamp": 1592503213409, + "version": "0.23.1" + }, + "scikit-learn-0.23.1-py38h423224d_0.conda": { + "build": "py38h423224d_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "d8094805b447aa040b1aeecf6fc76126", + "name": "scikit-learn", + "sha256": "7d7f9b92ba6c8d1c9a6a6126aa91b2e0ad7b7f4c0d2deb95b38d846145a8ee8a", + "size": 5436807, + "subdir": "linux-64", + "timestamp": 1592503225359, + "version": "0.23.1" + }, + "scikit-learn-0.23.1-py38h7ea95a0_0.conda": { + "build": "py38h7ea95a0_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "31e3088957e5c5ab41c3f16489e1bcc2", + "name": "scikit-learn", + "sha256": "b0c9de008f9f9abc762ce1d3b2b3365754ad6b77e1a94356dbbe5c387c7839fb", + "size": 5406340, + "subdir": "linux-64", + "timestamp": 1592503198929, + "version": "0.23.1" + }, + "scikit-learn-0.23.2-py36h0573a6f_0.conda": { + "build": "py36h0573a6f_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "82896322b5848d52579f6a3c7ff3656e", + "name": "scikit-learn", + "sha256": "7e7a25c34c47886ab0ee2bb09f05db0eaeb45360e9afae87111667b10d8539ae", + "size": 5275853, + "subdir": "linux-64", + "timestamp": 1598380080330, + "version": "0.23.2" + }, + "scikit-learn-0.23.2-py37h0573a6f_0.conda": { + "build": "py37h0573a6f_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "5957e70b23114740c9fe80d7b87a8cd4", + "name": "scikit-learn", + "sha256": "a9b97dd69075f46fa84d5135f4ce41aafed5ead5f5270277eb5c314f5b9ebe88", + "size": 5260918, + "subdir": "linux-64", + "timestamp": 1598377271102, + "version": "0.23.2" + }, + "scikit-learn-0.23.2-py38h0573a6f_0.conda": { + "build": "py38h0573a6f_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "5fa780eb296c4e8c34fc554afeb808c5", + "name": "scikit-learn", + "sha256": "a8806cb6c8dec0bad913abfbb54dbdad6e480eafed12fa2445f022018f828686", + "size": 5413454, + "subdir": "linux-64", + "timestamp": 1598377263181, + "version": "0.23.2" + }, + "scikit-learn-0.23.2-py39ha9443f7_0.conda": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "11480e40db7d8112176b4834d973034c", + "name": "scikit-learn", + "sha256": "609b725e89d7f03d833410581273b9e84835a4415e0de999b173d26cafd7f9b1", + "size": 5407843, + "subdir": "linux-64", + "timestamp": 1607712709370, + "version": "0.23.2" + }, + "scikit-learn-0.24.1-py36ha9443f7_0.conda": { + "build": "py36ha9443f7_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "5eaf76ebc1f0c4df7fb8a9405f84c38e", + "name": "scikit-learn", + "sha256": "8c5904ebadbbd16c7ab2382847e17de1d3c50408b2b7c9b7dde915228db05614", + "size": 5475332, + "subdir": "linux-64", + "timestamp": 1614447042003, + "version": "0.24.1" + }, + "scikit-learn-0.24.1-py37ha9443f7_0.conda": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "db7225282aed8e97ee1da7fa6bb610f5", + "name": "scikit-learn", + "sha256": "d8f5d89db1d689c056840bdee9adf5d923751f16aaf85702d1629aa8f8587b48", + "size": 5426949, + "subdir": "linux-64", + "timestamp": 1614445927466, + "version": "0.24.1" + }, + "scikit-learn-0.24.1-py38ha9443f7_0.conda": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "0dcfd6b950aa48db01e0aa14dcba6a7c", + "name": "scikit-learn", + "sha256": "94595d3aa57f50b76942521c1cace27e8751662eb0583ff3da41a134736397f6", + "size": 5629977, + "subdir": "linux-64", + "timestamp": 1614447013267, + "version": "0.24.1" + }, + "scikit-learn-0.24.1-py39ha9443f7_0.conda": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy", + "threadpoolctl" + ], + "license": "BSD-3-Clause", + "md5": "b2de680373b64e6ea5131d2ce88d19cb", + "name": "scikit-learn", + "sha256": "15e376d38ea6409ecc94ef39571e6a537101aad852a6458a2624b6c68cdbd3f7", + "size": 5629427, + "subdir": "linux-64", + "timestamp": 1614446989989, + "version": "0.24.1" + }, + "scikit-learn-0.24.2-py36ha9443f7_0.conda": { + "build": "py36ha9443f7_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.19.1", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "md5": "c7367df502f308653ed1d6c87a940f20", + "name": "scikit-learn", + "sha256": "92c0408c11cd7797b7287b6d05a8d8e5c41138e005c6f8cbca0efdd8c155c099", + "size": 5476451, + "subdir": "linux-64", + "timestamp": 1621366138175, + "version": "0.24.2" + }, + "scikit-learn-0.24.2-py37ha9443f7_0.conda": { + "build": "py37ha9443f7_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.19.1", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "md5": "bbee569a3327898f86458eb89f44ff5c", + "name": "scikit-learn", + "sha256": "440273dafc4685726ff7df736bc054651f71c1c2586fc3426ee5c248cc8d0275", + "size": 5456712, + "subdir": "linux-64", + "timestamp": 1621370641737, + "version": "0.24.2" + }, + "scikit-learn-0.24.2-py38ha9443f7_0.conda": { + "build": "py38ha9443f7_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.19.1", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "md5": "0afaea75ccd4254c7683c0813579c9f4", + "name": "scikit-learn", + "sha256": "12c17cbbbd9287db2e83788378c231aa6eb75f290bad026be1e9a5a3df6ed4ea", + "size": 5616201, + "subdir": "linux-64", + "timestamp": 1621370723805, + "version": "0.24.2" + }, + "scikit-learn-0.24.2-py39ha9443f7_0.conda": { + "build": "py39ha9443f7_0", + "build_number": 0, + "depends": [ + "joblib >=0.11", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.19.1", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "md5": "c599a6006e02a5fe01ead33c32594243", + "name": "scikit-learn", + "sha256": "3aeef0af9e4353251ec1e79e683ac006da5ac9d8802462ee715e7723c202ea8e", + "size": 5617228, + "subdir": "linux-64", + "timestamp": 1621370712570, + "version": "0.24.2" + }, + "scikit-learn-1.0.1-py310h00e6091_0.conda": { + "build": "py310h00e6091_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a4f566c430aba3dd692d2b49b6951849", + "name": "scikit-learn", + "sha256": "8c6bd0b64a170b377bf7aaa6de4063f1fb5c597e80f93de4aff7bc49cf5e2798", + "size": 14987020, + "subdir": "linux-64", + "timestamp": 1641557641362, + "version": "1.0.1" + }, + "scikit-learn-1.0.1-py37h51133e4_0.conda": { + "build": "py37h51133e4_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "96d4fe5cad894371b340b6935cfdb931", + "name": "scikit-learn", + "sha256": "64f16377304f3ef32e3bda165a9143713ae514d505f8478ba5076b71a52ccf93", + "size": 5723361, + "subdir": "linux-64", + "timestamp": 1635187368971, + "version": "1.0.1" + }, + "scikit-learn-1.0.1-py38h51133e4_0.conda": { + "build": "py38h51133e4_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bcdd7c2bae0a42e48474c30937023a54", + "name": "scikit-learn", + "sha256": "5ff9106520c7e123b7a3cc7a640d5f6366e4d095e1eaade28f37cba100fd89f8", + "size": 5844426, + "subdir": "linux-64", + "timestamp": 1635175786243, + "version": "1.0.1" + }, + "scikit-learn-1.0.1-py39h51133e4_0.conda": { + "build": "py39h51133e4_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "646d5f7d7f5793506916c87e144a811d", + "name": "scikit-learn", + "sha256": "35c10317e4ee72b853b92ab912f44df2a13108e2e8bfc0d18ce213b8c978317d", + "size": 5847365, + "subdir": "linux-64", + "timestamp": 1635187368893, + "version": "1.0.1" + }, + "scikit-learn-1.0.2-py37h51133e4_0.conda": { + "build": "py37h51133e4_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4279f83d74a8a48087fa98825a0eb5c7", + "name": "scikit-learn", + "sha256": "7b1e16fc3d1e1c4effae41bd68091ede46fd1e44b413a5105dcc34fdf6f1c850", + "size": 5683578, + "subdir": "linux-64", + "timestamp": 1641891306932, + "version": "1.0.2" + }, + "scikit-learn-1.0.2-py37h51133e4_1.conda": { + "build": "py37h51133e4_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d772c30017e91436c9fe85413b79613f", + "name": "scikit-learn", + "sha256": "5d135f72a0552e8f3d979527818f30a3511885fad74cf7190a4f1660ccbf99f0", + "size": 5719183, + "subdir": "linux-64", + "timestamp": 1642602084840, + "version": "1.0.2" + }, + "scikit-learn-1.0.2-py38h51133e4_0.conda": { + "build": "py38h51133e4_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "daebcbd8867c4b45c8e1891c3a98fe5c", + "name": "scikit-learn", + "sha256": "6a97b0b2ed61c7e6dceabc31ca522814a2495a4dc4cd335fa5c2f17943e4f138", + "size": 5812804, + "subdir": "linux-64", + "timestamp": 1641891291979, + "version": "1.0.2" + }, + "scikit-learn-1.0.2-py38h51133e4_1.conda": { + "build": "py38h51133e4_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7b77e6b64608ce271d09a48e4b4126a9", + "name": "scikit-learn", + "sha256": "dd53fc3a1b3917e41ffbca05788523ac6c063da9e9991425f8105625938e786d", + "size": 5849589, + "subdir": "linux-64", + "timestamp": 1642617422064, + "version": "1.0.2" + }, + "scikit-learn-1.0.2-py39h51133e4_0.conda": { + "build": "py39h51133e4_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cf75c6babdcd13c7c3ae51ccc51255d7", + "name": "scikit-learn", + "sha256": "67add99b3a1310c11bc87555049e5ebaf0e08dd97450d33156bfe675d489e5e9", + "size": 5828751, + "subdir": "linux-64", + "timestamp": 1641876325807, + "version": "1.0.2" + }, + "scikit-learn-1.0.2-py39h51133e4_1.conda": { + "build": "py39h51133e4_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "joblib >=0.11", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.1.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bc35449b70bc678d4d1216e73bdb5232", + "name": "scikit-learn", + "sha256": "911384ecebb9e8573440b03bdd3503367f5331e680b3cf6527bcd2e7372bff87", + "size": 5858105, + "subdir": "linux-64", + "timestamp": 1642617419111, + "version": "1.0.2" + }, + "scikit-learn-1.1.1-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f8fd97d5d42b619a8e4bc0391c7d35b0", + "name": "scikit-learn", + "sha256": "54521df32fb0a9819d79583038ade61effb7af8efcfb78661003c5cb09bba0d6", + "size": 17574663, + "subdir": "linux-64", + "timestamp": 1658421488391, + "version": "1.1.1" + }, + "scikit-learn-1.1.1-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e0f2657aa8fa1748c73c58e65dfe88e5", + "name": "scikit-learn", + "sha256": "2aca38635e2edd9da558ca2a69d5070d8a449add37451c11c7c76acb77948dd4", + "size": 6434049, + "subdir": "linux-64", + "timestamp": 1658420573509, + "version": "1.1.1" + }, + "scikit-learn-1.1.1-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "697fcd77ca6a3f3c43de07f08c8a8550", + "name": "scikit-learn", + "sha256": "21a97a8650d6ef11d1bf6759370d21bb53f44a1fdecea7eec22b96c2aa31fd38", + "size": 6392152, + "subdir": "linux-64", + "timestamp": 1658419721830, + "version": "1.1.1" + }, + "scikit-learn-1.1.2-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6b2a68077e402cc730902d262f070ff4", + "name": "scikit-learn", + "sha256": "939e6d02a69d134b71ceeb62354945453de02ae9d9d45925a1cfba60b68eefaf", + "size": 6383952, + "subdir": "linux-64", + "timestamp": 1665482300806, + "version": "1.1.2" + }, + "scikit-learn-1.1.2-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d62bb99994123825872da38027c4f17", + "name": "scikit-learn", + "sha256": "36eaa9fb6d39ccb4dc11efd1aece2760a9e47ea1544835a302f2c9dd0d76918b", + "size": 6413666, + "subdir": "linux-64", + "timestamp": 1665483087407, + "version": "1.1.2" + }, + "scikit-learn-1.1.2-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eb9f6188ce383b4e04613da69277bb76", + "name": "scikit-learn", + "sha256": "5e33aa460db03c4c75e9eb59c7093dd6ce113db99930ebf492bd72963255aaee", + "size": 6361492, + "subdir": "linux-64", + "timestamp": 1665483865138, + "version": "1.1.2" + }, + "scikit-learn-1.1.3-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "153d5c34574f5a0a90ab80e108da4d20", + "name": "scikit-learn", + "sha256": "eb20925d0178d4a6f0e8846508514b6bd245e9b8315c6debfb336548582b1a61", + "size": 7410321, + "subdir": "linux-64", + "timestamp": 1667589422649, + "version": "1.1.3" + }, + "scikit-learn-1.1.3-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c6e5e79e1438ec000b7179711dd74e1c", + "name": "scikit-learn", + "sha256": "3cf48037b943b0bad69790552654910a2528b7ee7801c826c0f7a400ea890448", + "size": 7434570, + "subdir": "linux-64", + "timestamp": 1667588617358, + "version": "1.1.3" + }, + "scikit-learn-1.1.3-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4cb33cd897250b2e59c385215ddc54d2", + "name": "scikit-learn", + "sha256": "90bed4e0e5222538185d789a117a00ec7f62843b404b51b50d6a09fb1fe2a516", + "size": 7383173, + "subdir": "linux-64", + "timestamp": 1667587828324, + "version": "1.1.3" + }, + "scikit-learn-1.2.0-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3dce4fc903a1d4ed9df62587581a05dc", + "name": "scikit-learn", + "sha256": "bb84747b6314c4331fa4424abc0c8226f736e297c740e99a91acb0887d8d4ed9", + "size": 7935009, + "subdir": "linux-64", + "timestamp": 1673957557583, + "version": "1.2.0" + }, + "scikit-learn-1.2.0-py310h6a678d5_1.conda": { + "build": "py310h6a678d5_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=1.3.2,<1.10.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e9f41792b5337a30d2ea11d6a619a79b", + "name": "scikit-learn", + "sha256": "02fef773ad23c04dd622f49caa14f317b8c405306fe27c58c174f4353703033c", + "size": 7915945, + "subdir": "linux-64", + "timestamp": 1675445278397, + "version": "1.2.0" + }, + "scikit-learn-1.2.0-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "93faacdbfcf9cf95b87650fb0bf9c84d", + "name": "scikit-learn", + "sha256": "54ed665545a9f2b0c9de3017b9898a7569073c1d187b4ac995b7bd041a672740", + "size": 7966826, + "subdir": "linux-64", + "timestamp": 1673958540155, + "version": "1.2.0" + }, + "scikit-learn-1.2.0-py38h6a678d5_1.conda": { + "build": "py38h6a678d5_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.3.2,<1.10.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "13704bde2198d1f66e3a53f219a4a258", + "name": "scikit-learn", + "sha256": "9c5e6a96f95e29f7f8415ac448e3d9a9ce26ac34e0dc9b905bedbc6e8934b3ed", + "size": 7961572, + "subdir": "linux-64", + "timestamp": 1675446363833, + "version": "1.2.0" + }, + "scikit-learn-1.2.0-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "496bc92ae87db99c73d704c85aacbc16", + "name": "scikit-learn", + "sha256": "c7e49642d4dd33edd2c31860af54dba2b6e8cd8ccb1583f2de5a86fd562daf69", + "size": 7891789, + "subdir": "linux-64", + "timestamp": 1673959525458, + "version": "1.2.0" + }, + "scikit-learn-1.2.0-py39h6a678d5_1.conda": { + "build": "py39h6a678d5_1", + "build_number": 1, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.3.2,<1.10.0", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "58fb77499d2f97d26ae8c663c8d7030a", + "name": "scikit-learn", + "sha256": "4d850642959d4d66688bdbbbca3e3a10883c0f26504b7bac691b2e95bdc9e0fe", + "size": 7884772, + "subdir": "linux-64", + "timestamp": 1675447373915, + "version": "1.2.0" + }, + "scikit-learn-1.2.1-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d65344b6b54a4ad63925a8d5e639d02c", + "name": "scikit-learn", + "sha256": "b5be83dcb49d0197d8f4d8625f773b23c7a9465df19844cf90f89512e817f763", + "size": 8045655, + "subdir": "linux-64", + "timestamp": 1676912908717, + "version": "1.2.1" + }, + "scikit-learn-1.2.1-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "python >=3.11,<3.12.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "403f252a314902afdc64b949480f5921", + "name": "scikit-learn", + "sha256": "438cb0741e1fe168489cbe92bf72f4a76a24f6dea9848a5efc527299703c81f3", + "size": 8287465, + "subdir": "linux-64", + "timestamp": 1676919469968, + "version": "1.2.1" + }, + "scikit-learn-1.2.1-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "17ad5775904ff0c60db5bfea15784b0c", + "name": "scikit-learn", + "sha256": "f3968bd0ac75bb256405e0dc7eb726eafab0e2cf318a530a4010797b7c31dfb6", + "size": 8071170, + "subdir": "linux-64", + "timestamp": 1676913845682, + "version": "1.2.1" + }, + "scikit-learn-1.2.1-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e852521a4b8d58f613e2b86b15856254", + "name": "scikit-learn", + "sha256": "14d7032811b9278a81604e48423729fdcebc293f861f352a131458456edc2b42", + "size": 8008209, + "subdir": "linux-64", + "timestamp": 1676911985237, + "version": "1.2.1" + }, + "scikit-learn-1.2.2-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1f675f137ae437495634a51b5f6221de", + "name": "scikit-learn", + "sha256": "9d1cda7cfd35160f6d5c19cff01939a9a8eb3accbbbc59fff739c4161f7a5b8c", + "size": 8062171, + "subdir": "linux-64", + "timestamp": 1680199960717, + "version": "1.2.2" + }, + "scikit-learn-1.2.2-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "python >=3.11,<3.12.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1b9540f9fcfe6d70259e52c117384ad4", + "name": "scikit-learn", + "sha256": "e5d9753b250c035bb1119ff570d9cdbc10e1133659758134d592fff971c4aaf4", + "size": 9195593, + "subdir": "linux-64", + "timestamp": 1680199084767, + "version": "1.2.2" + }, + "scikit-learn-1.2.2-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.5,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d749c9a854a5e6d4ce952379ca8e9a8d", + "name": "scikit-learn", + "sha256": "82d1a5bd80a1728e28d324f3a5f48a50f22e282923614626247c03024f297810", + "size": 8103765, + "subdir": "linux-64", + "timestamp": 1680201795024, + "version": "1.2.2" + }, + "scikit-learn-1.2.2-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "joblib >=1.1.1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.5,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=1.3.2", + "threadpoolctl >=2.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6b4929847ec9c1896eea33a47fd560ef", + "name": "scikit-learn", + "sha256": "ea9938abc79d09f213cede22213b298db3a9a91656e581a25cd26373ccca81d6", + "size": 8042807, + "subdir": "linux-64", + "timestamp": 1680200882292, + "version": "1.2.2" + }, + "scikit-learn-intelex-2021.2.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.2.2.*", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.21" + ], + "license": "Apache-2.0", + "md5": "0211d1496c439048eb28d6612f54529e", + "name": "scikit-learn-intelex", + "sha256": "6f6ac60a07155d2f7273c9749bbb30992124bb2c96f4e8ad71954668120c9836", + "size": 22080, + "subdir": "linux-64", + "timestamp": 1620147735682, + "version": "2021.2.2" + }, + "scikit-learn-intelex-2021.2.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.2.2.*", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.21" + ], + "license": "Apache-2.0", + "md5": "485a899c1dcaf2c6ace0531137254ab6", + "name": "scikit-learn-intelex", + "sha256": "4783eed3d34627e9c263189068ec3f9bcb3e81d73637885cfda36cfc0cc79eaf", + "size": 22049, + "subdir": "linux-64", + "timestamp": 1620151720165, + "version": "2021.2.2" + }, + "scikit-learn-intelex-2021.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.2.2.*", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.21" + ], + "license": "Apache-2.0", + "md5": "ed8b3b46f443f07e382a323e23cc9929", + "name": "scikit-learn-intelex", + "sha256": "7e93886fd53c002c206e9b0fb8a7b63c0ae6eedcd83371ea2cbe847cdd880252", + "size": 22183, + "subdir": "linux-64", + "timestamp": 1620150918112, + "version": "2021.2.2" + }, + "scikit-learn-intelex-2021.2.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.2.2.*", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.21" + ], + "license": "Apache-2.0", + "md5": "dbab7332ae277fa5ff8bfdf50b213e92", + "name": "scikit-learn-intelex", + "sha256": "9405d2b3a461147622fc90c6ea1de950083b15ea6ee0dff1c67b6a20cd198090", + "size": 22105, + "subdir": "linux-64", + "timestamp": 1620151722573, + "version": "2021.2.2" + }, + "scikit-learn-intelex-2021.3.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.3.0.*", + "python >=3.6,<3.7.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "abb496f0aada0dddca5c1c45bd16fadb", + "name": "scikit-learn-intelex", + "sha256": "a922018c1aa9263a4fd1f49fcdd9a38c33f69b5a2dfc3b2eff8bc093a4c50da3", + "size": 38408, + "subdir": "linux-64", + "timestamp": 1626282224437, + "version": "2021.3.0" + }, + "scikit-learn-intelex-2021.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.3.0.*", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "eda9a6d43db29a9a7f8d40754b5afa81", + "name": "scikit-learn-intelex", + "sha256": "4a92f2f0957e5f9a79f6e28d89a6a7365dc8ca5c4673cf64e7709715269ec4bf", + "size": 38844, + "subdir": "linux-64", + "timestamp": 1626275191037, + "version": "2021.3.0" + }, + "scikit-learn-intelex-2021.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.3.0.*", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "3cf03b8151736adb2afc8d4125e19205", + "name": "scikit-learn-intelex", + "sha256": "6affbf1366fd4de46999a43805eb9fc5433e85482d11123bdba49127e161a5fd", + "size": 39033, + "subdir": "linux-64", + "timestamp": 1626282273775, + "version": "2021.3.0" + }, + "scikit-learn-intelex-2021.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.3.0.*", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "2f37a4f82af142910bd548c65ebd5a37", + "name": "scikit-learn-intelex", + "sha256": "b7f69ba89c75a3af892be7bfd47f3c367b0a1031446111da4db3436c04a25ad3", + "size": 38768, + "subdir": "linux-64", + "timestamp": 1626282286129, + "version": "2021.3.0" + }, + "scikit-learn-intelex-2021.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.4.0.*", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "9f5a7b20ac1d65f683dac5d815173c2d", + "name": "scikit-learn-intelex", + "sha256": "8f97b46c5a7353b552dd8430585b57feaa3e4446f459eec3f8a9a0267b3a16ce", + "size": 66368, + "subdir": "linux-64", + "timestamp": 1640812901023, + "version": "2021.4.0" + }, + "scikit-learn-intelex-2021.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.4.0.*", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "3823465a2e28988a305a8d55e655e1f6", + "name": "scikit-learn-intelex", + "sha256": "576281b215fe94ea0bb761e7a21c8b7d10f9a9e49885874c3941ba8f21c26d8a", + "size": 67279, + "subdir": "linux-64", + "timestamp": 1638380740985, + "version": "2021.4.0" + }, + "scikit-learn-intelex-2021.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.4.0.*", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "ff5b86f481b4447c5fb7de617ebdcd34", + "name": "scikit-learn-intelex", + "sha256": "6f3c54405c3154e6f17a1407978eff9e1100790a931f84f5ff1a886f165fcaa9", + "size": 67321, + "subdir": "linux-64", + "timestamp": 1638380740482, + "version": "2021.4.0" + }, + "scikit-learn-intelex-2021.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.4.0.*", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "9d6dde0f4bf4ca141894f035383db555", + "name": "scikit-learn-intelex", + "sha256": "61290ad7f001301723e97a2a566a7936caa257aae815b36d3a3ce9c9ef225d93", + "size": 67660, + "subdir": "linux-64", + "timestamp": 1638380737744, + "version": "2021.4.0" + }, + "scikit-learn-intelex-2021.5.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.5.0.*", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "1b984c88f3d016a3c188fe7957c6ad27", + "name": "scikit-learn-intelex", + "sha256": "0d4f059d2dcb5eb3812d859c3590784f6800998bfb8b18469e927a9543fd5ad8", + "size": 70011, + "subdir": "linux-64", + "timestamp": 1644942314493, + "version": "2021.5.0" + }, + "scikit-learn-intelex-2021.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.5.0.*", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "cc0e5a4752020c12ca760ebe1183526e", + "name": "scikit-learn-intelex", + "sha256": "2a43c4f79804ea1ad1cc9ae44a154d632decc32d87a877bc1bd1b6516a42d272", + "size": 69501, + "subdir": "linux-64", + "timestamp": 1644960436708, + "version": "2021.5.0" + }, + "scikit-learn-intelex-2021.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.5.0.*", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.22" + ], + "license": "Apache-2.0", + "md5": "985754cb2b69405f6eabab84f450f5d2", + "name": "scikit-learn-intelex", + "sha256": "0f599e12c660ff431e977bce9083f84ab7dfb341dbd43ee28d29b1af6279a344", + "size": 69759, + "subdir": "linux-64", + "timestamp": 1644960437696, + "version": "2021.5.0" + }, + "scikit-learn-intelex-2021.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.6.0.*", + "python >=3.10,<3.11.0a0", + "scikit-learn <1.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9f1547351654dac106a7ac73fa589640", + "name": "scikit-learn-intelex", + "sha256": "13b903dd94a921029aed252a444660c7673a9135a3b8a3d9854d29858e5a4e58", + "size": 76346, + "subdir": "linux-64", + "timestamp": 1664903708808, + "version": "2021.6.0" + }, + "scikit-learn-intelex-2021.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.6.0.*", + "python >=3.7,<3.8.0a0", + "scikit-learn <1.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3ead0536376f9bc7b566ed200cc72f61", + "name": "scikit-learn-intelex", + "sha256": "339597ff5ac8471e38459a1feba682c2505ec9449d4151483d918ebe48c429ae", + "size": 75548, + "subdir": "linux-64", + "timestamp": 1664903603645, + "version": "2021.6.0" + }, + "scikit-learn-intelex-2021.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.6.0.*", + "python >=3.8,<3.9.0a0", + "scikit-learn <1.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "90582f3f5b2b1cd5464d4ec8d3871f9d", + "name": "scikit-learn-intelex", + "sha256": "07327fd953fef988f94dd2c10d1f78e5875a185ffe19e9824a866f75b548b987", + "size": 75760, + "subdir": "linux-64", + "timestamp": 1664903799836, + "version": "2021.6.0" + }, + "scikit-learn-intelex-2021.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2021.6.0.*", + "python >=3.9,<3.10.0a0", + "scikit-learn <1.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d9353999ec7c5bcd486b92f6c20834e9", + "name": "scikit-learn-intelex", + "sha256": "84d904f90d154c65cb37ff37580216ff17180ff6e1284fae29ecbe83ed631f95", + "size": 75631, + "subdir": "linux-64", + "timestamp": 1664903888931, + "version": "2021.6.0" + }, + "scikit-learn-intelex-2023.0.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2023.0.2.*", + "python >=3.10,<3.11.0a0", + "scikit-learn" + ], + "license": "Apache-2.0 AND BSD-2-Clause AND BSD-3-Clause AND MIT", + "license_family": "Apache", + "md5": "2f4040de1bf92cbda1a6e7a8d0dff659", + "name": "scikit-learn-intelex", + "sha256": "f1e664c22b7619eac666747b4d20d2da56f5e348b53be1d8bf3f464b69a369f5", + "size": 84181, + "subdir": "linux-64", + "timestamp": 1677620564590, + "version": "2023.0.2" + }, + "scikit-learn-intelex-2023.0.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2023.0.2.*", + "python >=3.11,<3.12.0a0", + "scikit-learn" + ], + "license": "Apache-2.0 AND BSD-2-Clause AND BSD-3-Clause AND MIT", + "license_family": "Apache", + "md5": "9cd37431ec29b399462f8236a16132f4", + "name": "scikit-learn-intelex", + "sha256": "362f52efd2883fb1ce2a05893727b81bb8423c1ea776d155623da5f492b0f2c9", + "size": 97300, + "subdir": "linux-64", + "timestamp": 1677685583252, + "version": "2023.0.2" + }, + "scikit-learn-intelex-2023.0.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2023.0.2.*", + "python >=3.8,<3.9.0a0", + "scikit-learn" + ], + "license": "Apache-2.0 AND BSD-2-Clause AND BSD-3-Clause AND MIT", + "license_family": "Apache", + "md5": "f856be6475686a500f6a43c2ad3e815c", + "name": "scikit-learn-intelex", + "sha256": "bc5d971c9745ce2a9b7d26d2b65826e5e98d2c2e6b30350785de9af32d041e6a", + "size": 83556, + "subdir": "linux-64", + "timestamp": 1677620655632, + "version": "2023.0.2" + }, + "scikit-learn-intelex-2023.0.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "daal4py 2023.0.2.*", + "python >=3.9,<3.10.0a0", + "scikit-learn" + ], + "license": "Apache-2.0 AND BSD-2-Clause AND BSD-3-Clause AND MIT", + "license_family": "Apache", + "md5": "78031463dd1b4bc31d3273e49f2ffe79", + "name": "scikit-learn-intelex", + "sha256": "5bdb917ac50dc33d57025d3b4ca26f7a631519d41ffa988b7c63bea2bdd44275", + "size": 83700, + "subdir": "linux-64", + "timestamp": 1677620470349, + "version": "2023.0.2" + }, + "scikit-rf-0.14.5-py27h6f8029f_0.conda": { + "build": "py27h6f8029f_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "7ff5e51afcd1169b09789afb6e943a8c", + "name": "scikit-rf", + "sha256": "fb301364d5b1e52358581d469ac9ec3b537b8ee2f07b8b4b5af4a7a6264f7f5f", + "size": 622716, + "subdir": "linux-64", + "timestamp": 1509056523562, + "version": "0.14.5" + }, + "scikit-rf-0.14.5-py35hc292ca9_0.conda": { + "build": "py35hc292ca9_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.5,<3.6.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "6e6cd1182494d82038dd5edfa2937642", + "name": "scikit-rf", + "sha256": "c7d32bcd31227264d5497657d22eb974697494a70308066b71a7d2eac045a632", + "size": 634813, + "subdir": "linux-64", + "timestamp": 1509056527765, + "version": "0.14.5" + }, + "scikit-rf-0.14.5-py36h9a41a6d_0.conda": { + "build": "py36h9a41a6d_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "e4cd8599488355a02ca5e117e073abeb", + "name": "scikit-rf", + "sha256": "de23f120066e5265760e862dbc72db1befb6521efaa61e25cdc91e74e777382a", + "size": 629128, + "subdir": "linux-64", + "timestamp": 1509056513875, + "version": "0.14.5" + }, + "scikit-rf-0.14.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "605ff5b1690ce01aae1c8ffd1ad9fbc4", + "name": "scikit-rf", + "sha256": "e2fa12ec8686c127a21b61660404408e3b430773e6789470d09a8dbacee48130", + "size": 1470112, + "subdir": "linux-64", + "timestamp": 1520880239988, + "version": "0.14.8" + }, + "scikit-rf-0.14.8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.5,<3.6.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "92003496f525524d2465e4b505524def", + "name": "scikit-rf", + "sha256": "193ac8917f2e6866153a3fabb5a3dcc59a66a059fa93d00b933e92ac176253fe", + "size": 1477858, + "subdir": "linux-64", + "timestamp": 1520880270316, + "version": "0.14.8" + }, + "scikit-rf-0.14.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "0cd1613dcdf76c73b1911f6a477cb8d9", + "name": "scikit-rf", + "sha256": "d31337d5aedc66a0d4139193ebc37752e2b9af3e819b08cd565f9de81204ef28", + "size": 1480410, + "subdir": "linux-64", + "timestamp": 1520880236665, + "version": "0.14.8" + }, + "scikit-rf-0.14.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "36c63a2e0f91e5fd8ac6905f962b3907", + "name": "scikit-rf", + "sha256": "aad6932e6a824f76aa1508c65d3a1c3d6fb12620442f785a010426017178bccc", + "size": 1470196, + "subdir": "linux-64", + "timestamp": 1522715537979, + "version": "0.14.9" + }, + "scikit-rf-0.14.9-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.5,<3.6.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "d04598aaee51c84669ff70d50a29c298", + "name": "scikit-rf", + "sha256": "3d673e530df535d9ceb04647385a8a7ca204caef9c3e07cf1e2b875ff3af0785", + "size": 1481145, + "subdir": "linux-64", + "timestamp": 1522715537948, + "version": "0.14.9" + }, + "scikit-rf-0.14.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "58732a8eda375fcd02c33dfd870d09d8", + "name": "scikit-rf", + "sha256": "b3ecab120f4255821bb93ea67fdceb99c940c4fcdf6c9436c2dbd7d20823a432", + "size": 1475231, + "subdir": "linux-64", + "timestamp": 1522715598714, + "version": "0.14.9" + }, + "scikit-rf-0.15.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "a45c414303765d58c14d745ca3e0a2cf", + "name": "scikit-rf", + "sha256": "a27213547aaf406ec55b095bdfbc19c5ef84ac6677b622cc24e4f25becebb0bf", + "size": 1602643, + "subdir": "linux-64", + "timestamp": 1600553245545, + "version": "0.15.4" + }, + "scikit-rf-0.15.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "f655818c8439d3d7d38789c3253f336f", + "name": "scikit-rf", + "sha256": "4845367e14f90803af4d758337ecf799b0ce890d0862a6a40b4df6f65be70291", + "size": 1595377, + "subdir": "linux-64", + "timestamp": 1600553257839, + "version": "0.15.4" + }, + "scikit-rf-0.15.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.8,<3.9.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "13917e6d8a6b3fdc53af6202ece02cf2", + "name": "scikit-rf", + "sha256": "0f385becfd4eb52b0d5da9c8bd3525e1d8915e7370e1fa5edd6572d5e4e8ea07", + "size": 1604246, + "subdir": "linux-64", + "timestamp": 1600553276234, + "version": "0.15.4" + }, + "scikit-rf-0.16.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "5eb769020b7d095a47713eef5094dff2", + "name": "scikit-rf", + "sha256": "e56ec11c09187a5824e097df6191258822eb7c3d6531b3bb7f9cb6429e3085da", + "size": 1626944, + "subdir": "linux-64", + "timestamp": 1611082325182, + "version": "0.16.0" + }, + "scikit-rf-0.16.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "b6f6ec0a32111cdce5bb4bdfef338533", + "name": "scikit-rf", + "sha256": "dd67c56bc1e7415513b64cb35eedb29bd6b9706573ad2519960945f01ad34eb1", + "size": 1624248, + "subdir": "linux-64", + "timestamp": 1611081675660, + "version": "0.16.0" + }, + "scikit-rf-0.16.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.8,<3.9.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "eda79049af42d807006dbbac862d0c6a", + "name": "scikit-rf", + "sha256": "f59169c3ac2e7f6004d93331812fe2df04126a2947d7f4f969399ff4c6b83c17", + "size": 1622916, + "subdir": "linux-64", + "timestamp": 1611082469681, + "version": "0.16.0" + }, + "scikit-rf-0.16.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "future", + "ipython", + "matplotlib", + "numpy", + "pandas", + "python >=3.9,<3.10.0a0", + "scipy", + "six" + ], + "license": "BSD 3-Clause", + "md5": "33b49bfaa21425635d322de9c020f4af", + "name": "scikit-rf", + "sha256": "bac409f2cc7f94a8686b00776f7414c55d6dfb28c0f8220a1959ce138e8c0be7", + "size": 1620830, + "subdir": "linux-64", + "timestamp": 1611082464851, + "version": "0.16.0" + }, + "scipy-0.19.1-py27_nomklhda24f63_3.conda": { + "build": "py27_nomklhda24f63_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "58b593d01563ecf5a68563ab991f714d", + "name": "scipy", + "sha256": "fdc7c942547da07f8c2ab956e5f8ca6f9e3c66d0080e72c6bf5b496f4b51ed46", + "size": 13296412, + "subdir": "linux-64", + "timestamp": 1509733353797, + "version": "0.19.1" + }, + "scipy-0.19.1-py27h1edc525_3.conda": { + "build": "py27h1edc525_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "e5b3647dd9ad172ba6c75162df08b6b6", + "name": "scipy", + "sha256": "fd742cf8a441ecebef1486e1c4120928d6b7744032019c4e934b076f2a2408e5", + "size": 13301310, + "subdir": "linux-64", + "timestamp": 1506017697639, + "version": "0.19.1" + }, + "scipy-0.19.1-py35_nomklh614202b_3.conda": { + "build": "py35_nomklh614202b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "d1ffd5c0f8ac2c317a710881b53e52ee", + "name": "scipy", + "sha256": "0cc035f762f5e82ed57278128a08bb36a568d874f5847e200c8e85833e6e0940", + "size": 13257540, + "subdir": "linux-64", + "timestamp": 1509733318874, + "version": "0.19.1" + }, + "scipy-0.19.1-py35ha8f041b_3.conda": { + "build": "py35ha8f041b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "dad5c6f8057e2016dad396b2389ef954", + "name": "scipy", + "sha256": "a9fb4d6875c5abac37b3aea48b9602a7c75b80a1ddef10264dd89c2258983eb3", + "size": 13290442, + "subdir": "linux-64", + "timestamp": 1506017721703, + "version": "0.19.1" + }, + "scipy-0.19.1-py36_nomklh59deb5f_3.conda": { + "build": "py36_nomklh59deb5f_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "a89dda78bb4ecf4b1afc11c202f43047", + "name": "scipy", + "sha256": "8c143215260fbb65d5aa01318f52f4bb97c0fe9cb352823755fec5109d439adb", + "size": 13287273, + "subdir": "linux-64", + "timestamp": 1509733524208, + "version": "0.19.1" + }, + "scipy-0.19.1-py36h9976243_3.conda": { + "build": "py36h9976243_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "1f6087b43dc442a4b220b87913e6dd6b", + "name": "scipy", + "sha256": "46ae99776e195958f6dbaef8e1331bdfdb217e20d97655c41c0a953b6d4e642f", + "size": 13288289, + "subdir": "linux-64", + "timestamp": 1506017647024, + "version": "0.19.1" + }, + "scipy-1.0.0-py27_nomklhc4f40eb_0.conda": { + "build": "py27_nomklhc4f40eb_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "6840c566efabd6e4c1bcfda050965845", + "name": "scipy", + "sha256": "d8959fd9802c1873254bed3bd8bbc0cfd730e5ace7250aa50029c1d3ca4e2ec4", + "size": 13649891, + "subdir": "linux-64", + "timestamp": 1510078238571, + "version": "1.0.0" + }, + "scipy-1.0.0-py27hf5f0f52_0.conda": { + "build": "py27hf5f0f52_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "094a7d86e5f8eb7885eed2caf80ab981", + "name": "scipy", + "sha256": "584b9c5a49f2365bee82f625b04309fb29f56fb480ac7ce2927fada60d9a7b22", + "size": 13652788, + "subdir": "linux-64", + "timestamp": 1510078459686, + "version": "1.0.0" + }, + "scipy-1.0.0-py35_nomklhb72a26a_0.conda": { + "build": "py35_nomklhb72a26a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "ed9338364a8c552c081751c8b19be235", + "name": "scipy", + "sha256": "20a926dd5874ff52c0372cac848317e42fb27aebbbcfa7374570df2c917a7b85", + "size": 13626725, + "subdir": "linux-64", + "timestamp": 1510078252167, + "version": "1.0.0" + }, + "scipy-1.0.0-py35hcbbe4a2_0.conda": { + "build": "py35hcbbe4a2_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "879fcc741894774b6d68b1b011e9efdc", + "name": "scipy", + "sha256": "b90108a29e33730b6e1825e665f053f705b7f335589b6776c5bc8cf9fb69dacb", + "size": 13633448, + "subdir": "linux-64", + "timestamp": 1510078527168, + "version": "1.0.0" + }, + "scipy-1.0.0-py36_nomklh9d91e6a_0.conda": { + "build": "py36_nomklh9d91e6a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "7bb529d9305d2686f68e1c45907d995a", + "name": "scipy", + "sha256": "7398f4ddac93cda7fc172bf5cab364d9f7196b54e54137c54ccd4732adeb7932", + "size": 13649330, + "subdir": "linux-64", + "timestamp": 1510078541594, + "version": "1.0.0" + }, + "scipy-1.0.0-py36hbf646e7_0.conda": { + "build": "py36hbf646e7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7.2.0,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.0,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "b24a2bcf4ff1f1fac1b16faec1dc21f9", + "name": "scipy", + "sha256": "a74ab6e6bcc752223cee529d83af5390b59edede13575b4d9f1920bbe607d299", + "size": 13622847, + "subdir": "linux-64", + "timestamp": 1510078530461, + "version": "1.0.0" + }, + "scipy-1.0.1-py27_nomklh9d22d0a_0.conda": { + "build": "py27_nomklh9d22d0a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "ad5558e0550f3c8fa9576a622bd85ea6", + "name": "scipy", + "sha256": "6f3698cc362dbacb14382a8c90af91f54b2bc9108f85f73e1725ad05e71581a2", + "size": 13642153, + "subdir": "linux-64", + "timestamp": 1522431943110, + "version": "1.0.1" + }, + "scipy-1.0.1-py27hfc37229_0.conda": { + "build": "py27hfc37229_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "06051a77ee84636fcc721f89675f8bc9", + "name": "scipy", + "sha256": "2824d2ec0caf7b888bd4a4a7907c8e6078490b42bbc59f7880db8741eb7c952f", + "size": 13622687, + "subdir": "linux-64", + "timestamp": 1522432596622, + "version": "1.0.1" + }, + "scipy-1.0.1-py35_nomklh9d22d0a_0.conda": { + "build": "py35_nomklh9d22d0a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "a3cb1255f804e98b96b79d2b2951e288", + "name": "scipy", + "sha256": "0c585914118c35efa7a670a8db52eca0af7601041614851ad8811c340320ffb9", + "size": 13620263, + "subdir": "linux-64", + "timestamp": 1522432435226, + "version": "1.0.1" + }, + "scipy-1.0.1-py35hfc37229_0.conda": { + "build": "py35hfc37229_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "aab35f749c513b4b28d52405697a252a", + "name": "scipy", + "sha256": "702ccb298b7195f35936fdcd1ca098697250886c1e62a13be2aa731e2cbab46c", + "size": 13624974, + "subdir": "linux-64", + "timestamp": 1522432603785, + "version": "1.0.1" + }, + "scipy-1.0.1-py36_nomklh9d22d0a_0.conda": { + "build": "py36_nomklh9d22d0a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "40c2eea10a2526888dd5dbb51ce0b8c7", + "name": "scipy", + "sha256": "056419484dcf4115df80358a2f9c8d07172cb83268bb41bb957fb302224a2ac0", + "size": 13622736, + "subdir": "linux-64", + "timestamp": 1522432446621, + "version": "1.0.1" + }, + "scipy-1.0.1-py36hfc37229_0.conda": { + "build": "py36hfc37229_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "8151369090bbfdd84ddb059c065eabfe", + "name": "scipy", + "sha256": "40c0ee8f6cb9273ef7e91f1794bd3bc5d4cacbf5109791f681cd77cd22732805", + "size": 13626111, + "subdir": "linux-64", + "timestamp": 1522432028926, + "version": "1.0.1" + }, + "scipy-1.1.0-py27_nomklh9c1e066_0.conda": { + "build": "py27_nomklh9c1e066_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b5047c3a7bfb7ef81dd8a910cf9e0ae3", + "name": "scipy", + "sha256": "9bed51f66330ac1fd558d6c68c0a935d6eee9d11c334f0dfc83128170ddf39d9", + "size": 13883056, + "subdir": "linux-64", + "timestamp": 1530776927045, + "version": "1.1.0" + }, + "scipy-1.1.0-py27_nomklh9d22d0a_0.conda": { + "build": "py27_nomklh9d22d0a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "1920cd4b92387cf843306e34f454fca5", + "name": "scipy", + "sha256": "d697433f055c177317ea6b4be02f63f1bc4ff1985fdf79383268e41096076163", + "size": 13861587, + "subdir": "linux-64", + "timestamp": 1525904152858, + "version": "1.1.0" + }, + "scipy-1.1.0-py27_nomklhb74e8f7_0.conda": { + "build": "py27_nomklhb74e8f7_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "69b1efdce09a93b7bb0c5294d5c1f574", + "name": "scipy", + "sha256": "dc173e59fe691862fec54b686efa75b4ca857305fc9fc334fdfb84ee2587eedd", + "size": 13820494, + "subdir": "linux-64", + "timestamp": 1534805161044, + "version": "1.1.0" + }, + "scipy-1.1.0-py27h7c811a0_2.conda": { + "build": "py27h7c811a0_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "88b72945fda74ea9cfb9c0a272629daa", + "name": "scipy", + "sha256": "400a96daf52a991a4358d326039aef4b350760236d24e3dcaedd6190ab6a3425", + "size": 13786080, + "subdir": "linux-64", + "timestamp": 1544811276215, + "version": "1.1.0" + }, + "scipy-1.1.0-py27h9b217d5_1.conda": { + "build": "py27h9b217d5_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.1,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9cea0fccdb327b74065385bfb63d001f", + "name": "scipy", + "sha256": "d9adffb45272a9a0ea311f1abfdb1bcaa2563da2aea30135811709eb1140d40e", + "size": 13837043, + "subdir": "linux-64", + "timestamp": 1535416374272, + "version": "1.1.0" + }, + "scipy-1.1.0-py27hc49cb51_0.conda": { + "build": "py27hc49cb51_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "56d25c84c694cc7ca4feb0034981e4d8", + "name": "scipy", + "sha256": "35e02e5089b50e197b2bfb9f03042fbfb85ae743568ca7a822df34a65393cafc", + "size": 13883751, + "subdir": "linux-64", + "timestamp": 1530775639634, + "version": "1.1.0" + }, + "scipy-1.1.0-py27hd20e5f9_0.conda": { + "build": "py27hd20e5f9_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a72931f666239163410fb83b75e8404f", + "name": "scipy", + "sha256": "df37c6bc460b151018a312ecfc02670c98317d4df3ff11729bca9bc81b718c13", + "size": 13837090, + "subdir": "linux-64", + "timestamp": 1534806504477, + "version": "1.1.0" + }, + "scipy-1.1.0-py27he2b7bc3_1.conda": { + "build": "py27he2b7bc3_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "eb9e11b5f4fbcecc782787fb91545478", + "name": "scipy", + "sha256": "e94320727972e928932b81775df737127109257cb7fb2c8e74b8c3371e526417", + "size": 13832128, + "subdir": "linux-64", + "timestamp": 1536898885749, + "version": "1.1.0" + }, + "scipy-1.1.0-py27he2b7bc3_2.conda": { + "build": "py27he2b7bc3_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9fdb55aa4c87eed7586c646612928667", + "name": "scipy", + "sha256": "71c55915836f0d94b909fd06d0d4610ec42e7f4eaaebf4127db36b9770dd6926", + "size": 13766988, + "subdir": "linux-64", + "timestamp": 1544810775929, + "version": "1.1.0" + }, + "scipy-1.1.0-py27hfa4b5c9_1.conda": { + "build": "py27hfa4b5c9_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.15.1,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7cb8058ffc6597b3ff86eab13be42c47", + "name": "scipy", + "sha256": "282a250b23adabba81e7d66718bcb241bfe3eaa0ce7b4c19583c5afe7797dee6", + "size": 13840436, + "subdir": "linux-64", + "timestamp": 1535416595082, + "version": "1.1.0" + }, + "scipy-1.1.0-py27hfc37229_0.conda": { + "build": "py27hfc37229_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "e03bbd9f8c877e7b10c7fb7ef124dfc2", + "name": "scipy", + "sha256": "4cd17375a3c29715ebb1629a2a3aa04ce6f0bf8deda9c9fdf5677dde23f4340e", + "size": 13832472, + "subdir": "linux-64", + "timestamp": 1525904280351, + "version": "1.1.0" + }, + "scipy-1.1.0-py35_nomklh9d22d0a_0.conda": { + "build": "py35_nomklh9d22d0a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "15e56990b0e0680871547ee93b6bd269", + "name": "scipy", + "sha256": "7ff08135028d0523cc1cd278104fe45331d29bcd5ffe725838fc0a1299b4cb87", + "size": 13891364, + "subdir": "linux-64", + "timestamp": 1525904159535, + "version": "1.1.0" + }, + "scipy-1.1.0-py35h9b217d5_1.conda": { + "build": "py35h9b217d5_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.1,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1bd643479744c1fcce07135969a9b2b5", + "name": "scipy", + "sha256": "7289446602b1672b77f23d37ea45d67e6b3cc7b99a2fda027526b1e01e1dcccd", + "size": 13884997, + "subdir": "linux-64", + "timestamp": 1535414960760, + "version": "1.1.0" + }, + "scipy-1.1.0-py35hd20e5f9_0.conda": { + "build": "py35hd20e5f9_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a5cee5af6cb3882d06e05647686dfda1", + "name": "scipy", + "sha256": "e271241d2977d81b735c39c82f971e77b1582fa08c5a1bdf272c3c43fa258177", + "size": 13920417, + "subdir": "linux-64", + "timestamp": 1534837742752, + "version": "1.1.0" + }, + "scipy-1.1.0-py35he2b7bc3_1.conda": { + "build": "py35he2b7bc3_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1a6de23944dd4906ef34f24732bef9cd", + "name": "scipy", + "sha256": "30dc56d6c2b34837f54f1de8cdfd0da030e24c7903e6ad307721a03201a99cb8", + "size": 13883030, + "subdir": "linux-64", + "timestamp": 1536898891741, + "version": "1.1.0" + }, + "scipy-1.1.0-py35hfa4b5c9_1.conda": { + "build": "py35hfa4b5c9_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.15.1,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1c9a256056a9a7a65b462645a24bb535", + "name": "scipy", + "sha256": "13b1548f88411282e7945e9182ac64faf32b923df88bfd13c50918e955de5112", + "size": 13893503, + "subdir": "linux-64", + "timestamp": 1535416611850, + "version": "1.1.0" + }, + "scipy-1.1.0-py35hfc37229_0.conda": { + "build": "py35hfc37229_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "b0aa15bfc030040ca4ba81c8ccf03777", + "name": "scipy", + "sha256": "36e1e06583d15f35c41da50c38b43a63dac500e1b720ee000488d1872d7e1081", + "size": 13865878, + "subdir": "linux-64", + "timestamp": 1525905132618, + "version": "1.1.0" + }, + "scipy-1.1.0-py36_nomklh9c1e066_0.conda": { + "build": "py36_nomklh9c1e066_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "327e49ac0a128ab02de4cf4b50b9786f", + "name": "scipy", + "sha256": "3c4b7c086c8d3430effdba38289977bf877b26f1f0c4805a55de80b49f404041", + "size": 13843190, + "subdir": "linux-64", + "timestamp": 1530779548309, + "version": "1.1.0" + }, + "scipy-1.1.0-py36_nomklh9d22d0a_0.conda": { + "build": "py36_nomklh9d22d0a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * openblas" + ], + "license": "BSD 3-Clause", + "md5": "781c1de1664b4044beff8580411fa243", + "name": "scipy", + "sha256": "83692e1e0f71ff950b9d66423891ef2e21d580d1f654aa1c98fcae61a393f4bf", + "size": 13867038, + "subdir": "linux-64", + "timestamp": 1525904179926, + "version": "1.1.0" + }, + "scipy-1.1.0-py36h7c811a0_2.conda": { + "build": "py36h7c811a0_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "07fc29a6c7dca6efa51e2c46cf67cb5d", + "name": "scipy", + "sha256": "fa978be9cc30c8b547aeced4c5e75b2bb56343c6b0af32265fa8fcb9366734d1", + "size": 13822288, + "subdir": "linux-64", + "timestamp": 1544811268237, + "version": "1.1.0" + }, + "scipy-1.1.0-py36h9b217d5_1.conda": { + "build": "py36h9b217d5_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.1,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6408d760787dcd59883aef83a7729a84", + "name": "scipy", + "sha256": "3b5bf94a04791b99f9b10bd1b031a0ee3a4696dba6f47bd9ee6357ee3a4540da", + "size": 13827346, + "subdir": "linux-64", + "timestamp": 1535416418378, + "version": "1.1.0" + }, + "scipy-1.1.0-py36hc49cb51_0.conda": { + "build": "py36hc49cb51_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e6b9563cbe7a8de4bfe19246a6bb783b", + "name": "scipy", + "sha256": "c7b3ae049026768a54e9bb5f93da93da4d0fa053da8d5cba59b852b15dab6226", + "size": 13863901, + "subdir": "linux-64", + "timestamp": 1530778224000, + "version": "1.1.0" + }, + "scipy-1.1.0-py36hd20e5f9_0.conda": { + "build": "py36hd20e5f9_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "612ccffe7873cd314eeddd321c0b4f9d", + "name": "scipy", + "sha256": "9bf7c3d1ee55b7bb5c1e01fa549f03a7c7934d70aefdef99e4c5d3e059ed97d3", + "size": 13830616, + "subdir": "linux-64", + "timestamp": 1534846433876, + "version": "1.1.0" + }, + "scipy-1.1.0-py36he2b7bc3_1.conda": { + "build": "py36he2b7bc3_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1bc253220ccf3c1f84cf4b1997b7be84", + "name": "scipy", + "sha256": "8d1fa30afb7644aa0ca63e3156374219d6a993adfa512350c86688cf9647eafc", + "size": 13797437, + "subdir": "linux-64", + "timestamp": 1536898898743, + "version": "1.1.0" + }, + "scipy-1.1.0-py36he2b7bc3_2.conda": { + "build": "py36he2b7bc3_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d83d84a5f3a55f71168db1cb274e3a36", + "name": "scipy", + "sha256": "256d64975fd031904fbc51176aa41eee2e48d23e1d7660f47c2c5fd58deafca7", + "size": 13823363, + "subdir": "linux-64", + "timestamp": 1544810770288, + "version": "1.1.0" + }, + "scipy-1.1.0-py36hfa4b5c9_1.conda": { + "build": "py36hfa4b5c9_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.15.1,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d77f4860758603c2e38d7502bb04288e", + "name": "scipy", + "sha256": "5df80289a840c31e21de0467b8e61c5a8694cbe34ca1c79b8629418022d72c4e", + "size": 13830225, + "subdir": "linux-64", + "timestamp": 1535416623744, + "version": "1.1.0" + }, + "scipy-1.1.0-py36hfc37229_0.conda": { + "build": "py36hfc37229_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "blas * mkl" + ], + "license": "BSD 3-Clause", + "md5": "67f77f153864992dd4820d3187c02190", + "name": "scipy", + "sha256": "e4dc85665f65ac3a71b7a97afdca66eadc5c7b25a37e20b02364eb9f833babcc", + "size": 13865993, + "subdir": "linux-64", + "timestamp": 1525905155031, + "version": "1.1.0" + }, + "scipy-1.1.0-py37_nomklh9c1e066_0.conda": { + "build": "py37_nomklh9c1e066_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fdd59751b12e7082644b83e13777b897", + "name": "scipy", + "sha256": "9db00c300340cf9752e4d8b0d3c78dd37f18c825f34c294fc591a277729e63d1", + "size": 13809846, + "subdir": "linux-64", + "timestamp": 1530774357854, + "version": "1.1.0" + }, + "scipy-1.1.0-py37h7c811a0_2.conda": { + "build": "py37h7c811a0_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e94da674165302d0be58011d2d8712e2", + "name": "scipy", + "sha256": "cbb9ad994ed6bc35f4260da13eaabafc6b2ca39a32a4cd626096451f7191dea0", + "size": 13764083, + "subdir": "linux-64", + "timestamp": 1544811210836, + "version": "1.1.0" + }, + "scipy-1.1.0-py37h9b217d5_1.conda": { + "build": "py37h9b217d5_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.2,<0.3.3.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.15.1,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9e9da392df74962b582539cf767391c8", + "name": "scipy", + "sha256": "ea3cccdbd586bf684a3a41298ca3e8c4db67dfdb0bfa39b2b0567bce37a664cd", + "size": 13798028, + "subdir": "linux-64", + "timestamp": 1535414924058, + "version": "1.1.0" + }, + "scipy-1.1.0-py37hc49cb51_0.conda": { + "build": "py37hc49cb51_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dac15e0a04295b366a5ec349ca383739", + "name": "scipy", + "sha256": "ca24456924fcf4628155f5ad8bb998255947416e61270403a66c5b4f5e2c2821", + "size": 13811286, + "subdir": "linux-64", + "timestamp": 1530773056068, + "version": "1.1.0" + }, + "scipy-1.1.0-py37he2b7bc3_1.conda": { + "build": "py37he2b7bc3_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "589299c5e7fb455fbfeccff6077c2011", + "name": "scipy", + "sha256": "af8633913098efe046bb8597cc5850b916c494c0d39807e85721de4216f0dc12", + "size": 13803728, + "subdir": "linux-64", + "timestamp": 1536899089778, + "version": "1.1.0" + }, + "scipy-1.1.0-py37he2b7bc3_2.conda": { + "build": "py37he2b7bc3_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fafd8ef8e31033e3613a45c2bbb779a8", + "name": "scipy", + "sha256": "5ded0823478aea2d8e71f3281930310439b0974df1d483f6c0f4b72c39ccdf41", + "size": 13783457, + "subdir": "linux-64", + "timestamp": 1544811127776, + "version": "1.1.0" + }, + "scipy-1.1.0-py37hfa4b5c9_1.conda": { + "build": "py37hfa4b5c9_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "numpy >=1.15.1,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cc2ed996edbe7cb61796540e7eec9226", + "name": "scipy", + "sha256": "f9286d0ac32febec1db7f714f15c4713cf8c3f6a03372554bbb5bbc72f16be8c", + "size": 13772366, + "subdir": "linux-64", + "timestamp": 1535416612069, + "version": "1.1.0" + }, + "scipy-1.10.0-py310hd5efca6_0.conda": { + "build": "py310hd5efca6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<1.27.0", + "pooch", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9d41ea340b6354c191c5631a5f4ab8d7", + "name": "scipy", + "sha256": "4e6d58f5cfad4501d7f3c2fa0cf981d016948b67c52f34f20c9ae03875afdfe2", + "size": 25045024, + "subdir": "linux-64", + "timestamp": 1675465530503, + "version": "1.10.0" + }, + "scipy-1.10.0-py310hd5efca6_1.conda": { + "build": "py310hd5efca6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<1.27.0", + "pooch", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3c2c717455af761a40ff2d47773136e0", + "name": "scipy", + "sha256": "864bfe8780081244f3c92588e9a41a5e7b041951d599407ec9b923356853f2fa", + "size": 25029174, + "subdir": "linux-64", + "timestamp": 1677600249593, + "version": "1.10.0" + }, + "scipy-1.10.0-py310heeff2f4_0.conda": { + "build": "py310heeff2f4_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<1.27.0", + "pooch", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "44cb4e61e0858ea7e8ca08fe8cd9798a", + "name": "scipy", + "sha256": "9c5deacc9af064beb027931a74f46bc2c4e418c3ab35fb91abd09905b05cf875", + "size": 25043869, + "subdir": "linux-64", + "timestamp": 1675461306731, + "version": "1.10.0" + }, + "scipy-1.10.0-py310heeff2f4_1.conda": { + "build": "py310heeff2f4_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<1.27.0", + "pooch", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0db1f03b6c6c6575b9787e4cfa0c28ec", + "name": "scipy", + "sha256": "5a41cb97630d56161e1bab353bd074c64c61124f64b8c6158865bc8df670a5c8", + "size": 25032303, + "subdir": "linux-64", + "timestamp": 1677603924913, + "version": "1.10.0" + }, + "scipy-1.10.0-py311h75bd12f_0.conda": { + "build": "py311h75bd12f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.23,<1.27.0", + "pooch", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "93a7edd2bbb59820b18fb5673aaa6b6a", + "name": "scipy", + "sha256": "505d7be83dbc02012fd940cffba45f09e1564010fa2d890a788f34f63d95b597", + "size": 23706483, + "subdir": "linux-64", + "timestamp": 1676905140821, + "version": "1.10.0" + }, + "scipy-1.10.0-py311h75bd12f_1.conda": { + "build": "py311h75bd12f_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.23,<1.27.0", + "pooch", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "901f49037c1c37a73ba9a8cce78d8541", + "name": "scipy", + "sha256": "227c4708fe53fd0ae3aeda6e15e5fcc15cb37c3cfbf900d01af7cdeeb887fa95", + "size": 23705294, + "subdir": "linux-64", + "timestamp": 1679339029875, + "version": "1.10.0" + }, + "scipy-1.10.0-py311hefedb09_0.conda": { + "build": "py311hefedb09_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23,<1.27.0", + "pooch", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "855c6fb5a5a2b96f47bb47972f18713a", + "name": "scipy", + "sha256": "05cb5e4aa8a93918db65adf4e2f4437f43b53815dd672a4c6baa3fee2d38914f", + "size": 23703964, + "subdir": "linux-64", + "timestamp": 1676905818814, + "version": "1.10.0" + }, + "scipy-1.10.0-py311hefedb09_1.conda": { + "build": "py311hefedb09_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23,<1.27.0", + "pooch", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9c2442b002c8b9084aa68d55144cb6c6", + "name": "scipy", + "sha256": "1d0f62ea15ce9b2191a276dbe8d95c5711dff6cb72a834a2532e647ed623b4a0", + "size": 23705357, + "subdir": "linux-64", + "timestamp": 1679338330804, + "version": "1.10.0" + }, + "scipy-1.10.0-py38h14f4228_0.conda": { + "build": "py38h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d9b5b84c7680a20278eb68100438b5f1", + "name": "scipy", + "sha256": "dae428120f10ca046ce317d1a256834ffc505eb0e2b394d67031ab219ebd3c54", + "size": 24275933, + "subdir": "linux-64", + "timestamp": 1675466982008, + "version": "1.10.0" + }, + "scipy-1.10.0-py38h14f4228_1.conda": { + "build": "py38h14f4228_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9ceb00d736d308427b00ab8528adc61d", + "name": "scipy", + "sha256": "870ff557e136476167e1d6992a8d4a5faaa011fc673755622fb387d74ae14dcc", + "size": 23501776, + "subdir": "linux-64", + "timestamp": 1677599029212, + "version": "1.10.0" + }, + "scipy-1.10.0-py38h32ae08f_0.conda": { + "build": "py38h32ae08f_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "91b46b489ee6d5c8382aad2da4425a36", + "name": "scipy", + "sha256": "943a282d84453bc75d6bdb8e3c3e890ea1d8bbbdcbec29a7e0e643c7243b2699", + "size": 24277929, + "subdir": "linux-64", + "timestamp": 1675462721512, + "version": "1.10.0" + }, + "scipy-1.10.0-py38h32ae08f_1.conda": { + "build": "py38h32ae08f_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "282637b1272e9de34faa2aba559945c4", + "name": "scipy", + "sha256": "f6f38087b7ead71edecbe040cba507ffa9c6156d3012ea659e48f32ff3eceb4d", + "size": 23502837, + "subdir": "linux-64", + "timestamp": 1677602706081, + "version": "1.10.0" + }, + "scipy-1.10.0-py39h14f4228_0.conda": { + "build": "py39h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fec3f1470f726222a8915ce8eb5450a5", + "name": "scipy", + "sha256": "2525ed094afe3bff372d5d41ceb2d1298319ec0e5b7d113c70535ac35ac81e52", + "size": 24215795, + "subdir": "linux-64", + "timestamp": 1675464138267, + "version": "1.10.0" + }, + "scipy-1.10.0-py39h14f4228_1.conda": { + "build": "py39h14f4228_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "095478dec2ad3fca52b1743d740cead3", + "name": "scipy", + "sha256": "e7e53c1a9d6ccd13da735e7abcad3df3fc53f4214f7edc84d2d8c9d26f5bc24b", + "size": 24217340, + "subdir": "linux-64", + "timestamp": 1677597800149, + "version": "1.10.0" + }, + "scipy-1.10.0-py39h32ae08f_0.conda": { + "build": "py39h32ae08f_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b3d4e8cc2cafa672c820b05ca11b8816", + "name": "scipy", + "sha256": "502f070ee9abf1b3cacee8cfcd5fb93495095c5b057416b8719cd0cf0f9fed12", + "size": 24215306, + "subdir": "linux-64", + "timestamp": 1675459897666, + "version": "1.10.0" + }, + "scipy-1.10.0-py39h32ae08f_1.conda": { + "build": "py39h32ae08f_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b66fa726653750c5b3a9af04f911692d", + "name": "scipy", + "sha256": "f518f95645212ace5f619ac39cf0188eacd7f0cf9a0ec29012f1d84c949ab99a", + "size": 24218071, + "subdir": "linux-64", + "timestamp": 1677601482008, + "version": "1.10.0" + }, + "scipy-1.10.1-py310hd5efca6_0.conda": { + "build": "py310hd5efca6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<1.27.0", + "pooch", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3b98f940b81af92eb337e2a6c0522b02", + "name": "scipy", + "sha256": "5a26ade0fa636ab69b614e91eb3b637e4f7f552526b9856f5a86a9dfc6a20b41", + "size": 25075538, + "subdir": "linux-64", + "timestamp": 1680710349594, + "version": "1.10.1" + }, + "scipy-1.10.1-py310heeff2f4_0.conda": { + "build": "py310heeff2f4_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<1.27.0", + "pooch", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "520aefada795438406d2868554faacdf", + "name": "scipy", + "sha256": "905a29ba96be78ed79c1e2e833c47b74e69c1a91a947888d23565ad7796df211", + "size": 25076568, + "subdir": "linux-64", + "timestamp": 1680704370237, + "version": "1.10.1" + }, + "scipy-1.10.1-py311h24aa872_0.conda": { + "build": "py311h24aa872_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23,<1.27.0", + "pooch", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "15b7207e8cfd5d345b60cdab1c7daf90", + "name": "scipy", + "sha256": "75be95d604696d6a9a096a00f86ab8c2297a0e8a3304564025ac174b24f7f3c2", + "size": 26694122, + "subdir": "linux-64", + "timestamp": 1680703116708, + "version": "1.10.1" + }, + "scipy-1.10.1-py311hc206e33_0.conda": { + "build": "py311hc206e33_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.23,<1.27.0", + "pooch", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9acb8d6c7e426ca2d2688f0504355c14", + "name": "scipy", + "sha256": "7bd9ae4d1555963570867d34a6984ff2bab05c403ef02ce4a4c240e01cda6fec", + "size": 26696862, + "subdir": "linux-64", + "timestamp": 1680708837315, + "version": "1.10.1" + }, + "scipy-1.10.1-py38h14f4228_0.conda": { + "build": "py38h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "03e935c4bb47d85a80348ae3c7766712", + "name": "scipy", + "sha256": "3f991951714a1950220913a4bfd9141585f6756d5d2e964898ffc80f526bff7c", + "size": 23485368, + "subdir": "linux-64", + "timestamp": 1680713186408, + "version": "1.10.1" + }, + "scipy-1.10.1-py38h32ae08f_0.conda": { + "build": "py38h32ae08f_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2debd28bcbc683ecbf4e4b1a490db13b", + "name": "scipy", + "sha256": "96069dcaf77450831ebfd234a67fa3b129b8a6387b2dabb3093263149c8dad33", + "size": 23485412, + "subdir": "linux-64", + "timestamp": 1680707158867, + "version": "1.10.1" + }, + "scipy-1.10.1-py39h14f4228_0.conda": { + "build": "py39h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ea9d0f7342e5b1077f8754516c79feab", + "name": "scipy", + "sha256": "73fc0ff3cb1916253bb3833cf5e30de03213b742c94f9311bc5c430ab4aab67f", + "size": 24256560, + "subdir": "linux-64", + "timestamp": 1680711776977, + "version": "1.10.1" + }, + "scipy-1.10.1-py39h32ae08f_0.conda": { + "build": "py39h32ae08f_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.5,<1.27.0", + "pooch", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a1bfa4b8b370d3531d7847414cfb5b2f", + "name": "scipy", + "sha256": "00a2bd5225466e52d5a8a2ad9a1dc0632ea0210790faae4a280f4c22386d1b55", + "size": 24256923, + "subdir": "linux-64", + "timestamp": 1680705712214, + "version": "1.10.1" + }, + "scipy-1.2.0-py27h7c811a0_0.conda": { + "build": "py27h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "efcf34008d526e2c91923c8dccde7f94", + "name": "scipy", + "sha256": "b4eab13f692649ca50dc3c1acb9a894ff4c38a1e6e34b3c59cf657794b4499c7", + "size": 14370581, + "subdir": "linux-64", + "timestamp": 1547757181526, + "version": "1.2.0" + }, + "scipy-1.2.0-py27he2b7bc3_0.conda": { + "build": "py27he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b3c5af1b617f397869fd4d9779f3cbba", + "name": "scipy", + "sha256": "59d308592ea0448c6723cb04b1d5205b288534b1161ec791b4501e184e6b6e21", + "size": 14375832, + "subdir": "linux-64", + "timestamp": 1547757138532, + "version": "1.2.0" + }, + "scipy-1.2.0-py36h7c811a0_0.conda": { + "build": "py36h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "eda9d18e7c5274e743d25f9b74699bfc", + "name": "scipy", + "sha256": "f62b3db47dff1ab8ed2388cda24d2601e6a88117e0733d41578bf0118a76d59e", + "size": 14413893, + "subdir": "linux-64", + "timestamp": 1547755997992, + "version": "1.2.0" + }, + "scipy-1.2.0-py36he2b7bc3_0.conda": { + "build": "py36he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8fb41d5f28618a98ac59d507fc7eeae3", + "name": "scipy", + "sha256": "07ff02506c574f4d3991a3eb602fbb0b2d384123c869cea9754316fea96e89b1", + "size": 14406865, + "subdir": "linux-64", + "timestamp": 1548258660720, + "version": "1.2.0" + }, + "scipy-1.2.0-py37h7c811a0_0.conda": { + "build": "py37h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "15bb313bbbcb949f19a986503d3a3d2f", + "name": "scipy", + "sha256": "61cf1ac5e0aa9c92214c9c9735d58c758d9eb040f1d1db4aa1cfd504a9a69050", + "size": 14377430, + "subdir": "linux-64", + "timestamp": 1547756281558, + "version": "1.2.0" + }, + "scipy-1.2.0-py37he2b7bc3_0.conda": { + "build": "py37he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f19858fb5b9713e92a8f484236ccd669", + "name": "scipy", + "sha256": "e168a576ddd42f1ead252f2db04cc8672ac4717a2efc495ed130de93f126543d", + "size": 14357767, + "subdir": "linux-64", + "timestamp": 1547757119071, + "version": "1.2.0" + }, + "scipy-1.2.1-py27h7c811a0_0.conda": { + "build": "py27h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8b84b441ba9184716d8b262961ea3f51", + "name": "scipy", + "sha256": "8450e485cb63309b51111b730219a5a4a81dbe23f27230e9b6ce6395e383c525", + "size": 14373068, + "subdir": "linux-64", + "timestamp": 1550683921676, + "version": "1.2.1" + }, + "scipy-1.2.1-py27he2b7bc3_0.conda": { + "build": "py27he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "725cc0291cc3bb3fa08e63203d861774", + "name": "scipy", + "sha256": "6d909c51d5343b9c4be3f81cf3385d61c873694072d854d4a7872775fee7055b", + "size": 14376357, + "subdir": "linux-64", + "timestamp": 1550683333767, + "version": "1.2.1" + }, + "scipy-1.2.1-py36h7c811a0_0.conda": { + "build": "py36h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c6f3855aea2e6fba6ca6454b3e39b1ea", + "name": "scipy", + "sha256": "f2fb770cded329348cdd0b0b946534cf064bf674a121a7ef0e971f6b5012e39b", + "size": 14407340, + "subdir": "linux-64", + "timestamp": 1550683926183, + "version": "1.2.1" + }, + "scipy-1.2.1-py36he2b7bc3_0.conda": { + "build": "py36he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "430c12a9c5d3b4027a2902e130e86b9b", + "name": "scipy", + "sha256": "340fe0d203b5b5917661d72f3bd99869ab49c402ebf562fcaacee6595ebdf728", + "size": 14386641, + "subdir": "linux-64", + "timestamp": 1550683761187, + "version": "1.2.1" + }, + "scipy-1.2.1-py37h7c811a0_0.conda": { + "build": "py37h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.1,<2021.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5952f237e46faca6b836db26c5a6a1be", + "name": "scipy", + "sha256": "68a8a9165257520b316f5413cd016947df01a4b35ee8d464aa87002ef152d85f", + "size": 14381229, + "subdir": "linux-64", + "timestamp": 1550688446386, + "version": "1.2.1" + }, + "scipy-1.2.1-py37he2b7bc3_0.conda": { + "build": "py37he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "41b25bde4ea358859be9293baaaf8ac6", + "name": "scipy", + "sha256": "e0fb3d3329a625c06fb9952575f735d553d7805c0c19c85ba2b7538ae537b773", + "size": 14379113, + "subdir": "linux-64", + "timestamp": 1550686564363, + "version": "1.2.1" + }, + "scipy-1.3.0-py36h7c811a0_0.conda": { + "build": "py36h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1b3021be620c03b8e192cd95e8465158", + "name": "scipy", + "sha256": "640a34d5b3d32541f2a60a4c76965562409b0eb2fafeb04f88f8c8ae6f44a477", + "size": 14695333, + "subdir": "linux-64", + "timestamp": 1563477150845, + "version": "1.3.0" + }, + "scipy-1.3.0-py36he2b7bc3_0.conda": { + "build": "py36he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4aeaec6afcefc2d2a72cb75d45285bfa", + "name": "scipy", + "sha256": "1e981de039e09cba9ff0997ee8dc8a262bd2e25c1e9b5933bb1b126b02150848", + "size": 14685073, + "subdir": "linux-64", + "timestamp": 1563476867388, + "version": "1.3.0" + }, + "scipy-1.3.0-py37h7c811a0_0.conda": { + "build": "py37h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b8949c21956b6e5d43f0038125151e59", + "name": "scipy", + "sha256": "5c1d5371f6954c50e11e1efb2180a710f5443b8c0e82e2b2bc488aa709d82d3a", + "size": 14670437, + "subdir": "linux-64", + "timestamp": 1563476829236, + "version": "1.3.0" + }, + "scipy-1.3.0-py37he2b7bc3_0.conda": { + "build": "py37he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "37f79dfa9ac87511e937ac1a43587921", + "name": "scipy", + "sha256": "8d971a9d6789b3851e61929a81f85285e04f7eebaeb0c1622de5f84b150b0132", + "size": 14662266, + "subdir": "linux-64", + "timestamp": 1563476855151, + "version": "1.3.0" + }, + "scipy-1.3.1-py36h7c811a0_0.conda": { + "build": "py36h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "723d9f42488cd9895e7f6131f05c2789", + "name": "scipy", + "sha256": "febe1d6befc45b4111632500a9389914be2c9c4ad4a2d06798d39624952d8837", + "size": 14639714, + "subdir": "linux-64", + "timestamp": 1565900320909, + "version": "1.3.1" + }, + "scipy-1.3.1-py36he2b7bc3_0.conda": { + "build": "py36he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fe597220d701994b2364e3aae4b8fa8b", + "name": "scipy", + "sha256": "08811e5c698373daa2bc551afe271d7cfe8da2a9c7d80d0e5e293c147101113f", + "size": 14636180, + "subdir": "linux-64", + "timestamp": 1565900339586, + "version": "1.3.1" + }, + "scipy-1.3.1-py37h7c811a0_0.conda": { + "build": "py37h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "375242227cbf7bc8089f271b4a21952a", + "name": "scipy", + "sha256": "8bc5a4b00797ad7ce05b51cb81d6fb371f7f50cb908b301490d1d4a233af671f", + "size": 14666866, + "subdir": "linux-64", + "timestamp": 1565900737884, + "version": "1.3.1" + }, + "scipy-1.3.1-py37he2b7bc3_0.conda": { + "build": "py37he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0a85ef6218c5b746e4d4c7009fea1eba", + "name": "scipy", + "sha256": "ddd43f2763ef0aef40e1cbf4ba9da12ea3279393df933b3a6025ef2945a320e0", + "size": 14666432, + "subdir": "linux-64", + "timestamp": 1565900332909, + "version": "1.3.1" + }, + "scipy-1.3.1-py38h7c811a0_0.conda": { + "build": "py38h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "28dc07da2324a437a9eef3c221271d22", + "name": "scipy", + "sha256": "f9368c0b1c92b886b6db0e611346b1f4038eb01fa9a1a401e919bd1115088ee5", + "size": 14790241, + "subdir": "linux-64", + "timestamp": 1573555909468, + "version": "1.3.1" + }, + "scipy-1.3.1-py38he2b7bc3_0.conda": { + "build": "py38he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "badc2f3243e82b733ad759ce0a4fdaa1", + "name": "scipy", + "sha256": "f547f0b400ec20f792db400c6ef187c26bf7f5050201e456a136fa157694b2c9", + "size": 14777078, + "subdir": "linux-64", + "timestamp": 1573557040546, + "version": "1.3.1" + }, + "scipy-1.3.2-py36h7c811a0_0.conda": { + "build": "py36h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1ea01579d700aa8e286a3be503526873", + "name": "scipy", + "sha256": "8262c7b81e1a3c8a33b284236f27047092f3d431ec346ad4e2599fd44baf1f63", + "size": 14666171, + "subdir": "linux-64", + "timestamp": 1575911689942, + "version": "1.3.2" + }, + "scipy-1.3.2-py36he2b7bc3_0.conda": { + "build": "py36he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f2da468c53bb533bf40685bdd38b52ea", + "name": "scipy", + "sha256": "51624c088ab5c0f24df11359adf1cd1ddf41b8dd2d8ba3c49c6a964147888933", + "size": 14671683, + "subdir": "linux-64", + "timestamp": 1575911688276, + "version": "1.3.2" + }, + "scipy-1.3.2-py37h7c811a0_0.conda": { + "build": "py37h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "52150669acd91dc197a16f9e43ecbc3a", + "name": "scipy", + "sha256": "010eb5cc2ef0602128e4ab0c34018aa15e3c5b5559490b72282043099dbf9b5f", + "size": 14610569, + "subdir": "linux-64", + "timestamp": 1575911684031, + "version": "1.3.2" + }, + "scipy-1.3.2-py37he2b7bc3_0.conda": { + "build": "py37he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "69302f5cdb386980a3b56a2d132b11fc", + "name": "scipy", + "sha256": "0ed85c1db75df8b4d7223f4aedfbfc50fc384a5663e9e1392c46096644d7549d", + "size": 14599290, + "subdir": "linux-64", + "timestamp": 1575911668813, + "version": "1.3.2" + }, + "scipy-1.3.2-py38h7c811a0_0.conda": { + "build": "py38h7c811a0_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c148ce31f588904f608f2e3a2c21d597", + "name": "scipy", + "sha256": "2c2c0d319ae7db1e51dd91ceccebf33881f610e9d6ac754a1b0bb94f013949f0", + "size": 14728771, + "subdir": "linux-64", + "timestamp": 1575915578443, + "version": "1.3.2" + }, + "scipy-1.3.2-py38he2b7bc3_0.conda": { + "build": "py38he2b7bc3_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a9df91d5a41c1f39524fc8a53c56bc29", + "name": "scipy", + "sha256": "b30b563ed0170f426e530519ec59698d152d774ad3dde94021d3da74b7bd0583", + "size": 14774901, + "subdir": "linux-64", + "timestamp": 1575915152031, + "version": "1.3.2" + }, + "scipy-1.4.1-py36h0b6359f_0.conda": { + "build": "py36h0b6359f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3b6821dfb234a9f93a5be7e158886fb3", + "name": "scipy", + "sha256": "557eb35875e705f9c8cdabc9cf1201b1215f8d954c4c524289a0a82a6ff8e6ae", + "size": 15321923, + "subdir": "linux-64", + "timestamp": 1580841337662, + "version": "1.4.1" + }, + "scipy-1.4.1-py36habc2bb6_0.conda": { + "build": "py36habc2bb6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "42628acd44c7c798948cbd8f34b8ae12", + "name": "scipy", + "sha256": "ccb0f4e0f3bdab9a195086b1552a279a931b9671f4d73470371e826847aecb18", + "size": 15357802, + "subdir": "linux-64", + "timestamp": 1580841718015, + "version": "1.4.1" + }, + "scipy-1.4.1-py37h0b6359f_0.conda": { + "build": "py37h0b6359f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7ef1c5706780496a98f6bd076935de68", + "name": "scipy", + "sha256": "0b26d671a53a7d25c84066768ca2d8b021bce4354b99ad71b3df1cc763a6e86b", + "size": 15242541, + "subdir": "linux-64", + "timestamp": 1580841730240, + "version": "1.4.1" + }, + "scipy-1.4.1-py37habc2bb6_0.conda": { + "build": "py37habc2bb6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0e79deac127f35e28114c14f26d1697a", + "name": "scipy", + "sha256": "86c8b76e31605c1fd200ff25f4697bf5004d7c9c136278dfa94af1c1a24e6c33", + "size": 15283156, + "subdir": "linux-64", + "timestamp": 1580841334620, + "version": "1.4.1" + }, + "scipy-1.4.1-py38h0b6359f_0.conda": { + "build": "py38h0b6359f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "68db692f2a8caa6932b9298edeb770cc", + "name": "scipy", + "sha256": "db24c3c8ed4791394c903cdaa44d1d09588f4dcc4839d1c4e604041e6be79e01", + "size": 15524369, + "subdir": "linux-64", + "timestamp": 1580841357296, + "version": "1.4.1" + }, + "scipy-1.4.1-py38habc2bb6_0.conda": { + "build": "py38habc2bb6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7da657c222fd5da5962bd5adc6c2452c", + "name": "scipy", + "sha256": "e4278cb3edd1d0b8109d4652677da37cb30a066e7fd7160fd1d6349d9fa5782b", + "size": 15479603, + "subdir": "linux-64", + "timestamp": 1580841334279, + "version": "1.4.1" + }, + "scipy-1.5.0-py36h0b6359f_0.conda": { + "build": "py36h0b6359f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "552381a20cd9324911486313c910ef7f", + "name": "scipy", + "sha256": "b89aa74b8f8a9162f185412cb2d1fbd1f54df51966add01877ceb9de6544f8c1", + "size": 15067392, + "subdir": "linux-64", + "timestamp": 1592931440731, + "version": "1.5.0" + }, + "scipy-1.5.0-py36habc2bb6_0.conda": { + "build": "py36habc2bb6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b37019685f9c5a28a9810ff85dbbf408", + "name": "scipy", + "sha256": "beb4d264e23b9904ac44391ccea4c5c1f962838740531367ba07c51bcd1e71e6", + "size": 15053031, + "subdir": "linux-64", + "timestamp": 1592931401557, + "version": "1.5.0" + }, + "scipy-1.5.0-py37h0b6359f_0.conda": { + "build": "py37h0b6359f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c4721cbb0712c0d4ee2e8a5f5f3b3515", + "name": "scipy", + "sha256": "63ec17f6fe69d362dc28ae48ff6fbd1a9019b492509a6bf8e5d383ba67589e02", + "size": 15085071, + "subdir": "linux-64", + "timestamp": 1592931396034, + "version": "1.5.0" + }, + "scipy-1.5.0-py37habc2bb6_0.conda": { + "build": "py37habc2bb6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "af348ff0d62f8a5d35f8f432b586fbc1", + "name": "scipy", + "sha256": "64b663b38d805ec3b9e5213c7c791c580bd872d7b65de287f3821c51e668f25c", + "size": 15025587, + "subdir": "linux-64", + "timestamp": 1592931394056, + "version": "1.5.0" + }, + "scipy-1.5.0-py38h0b6359f_0.conda": { + "build": "py38h0b6359f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "89915c93ce7a9bc06c902a35927e17b7", + "name": "scipy", + "sha256": "ecf2cb65807ba3afd7459a1ad44971b52d0cae4a73774868c1f08224a509fe6c", + "size": 15221124, + "subdir": "linux-64", + "timestamp": 1592931398288, + "version": "1.5.0" + }, + "scipy-1.5.0-py38habc2bb6_0.conda": { + "build": "py38habc2bb6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a27a97fc2377ab74cbd33ce22d3c3353", + "name": "scipy", + "sha256": "af5a12436bb7124a926876755a50930ff6a500f844f365bad9aa0113f3349361", + "size": 15224690, + "subdir": "linux-64", + "timestamp": 1592931391464, + "version": "1.5.0" + }, + "scipy-1.5.2-py36h0b6359f_0.conda": { + "build": "py36h0b6359f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3ea0fcd4023c4ee316c5ae2cbaab2e5d", + "name": "scipy", + "sha256": "945489f24dcad5556f66e813efe26e95b491058aa53088b3aad12683ac2566be", + "size": 15137008, + "subdir": "linux-64", + "timestamp": 1597687692176, + "version": "1.5.2" + }, + "scipy-1.5.2-py36habc2bb6_0.conda": { + "build": "py36habc2bb6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1968a01845f409c63ca5f1d1383bd959", + "name": "scipy", + "sha256": "c84a3dde2c3959169aa1401f5c26cd752dcdf7d4451cc48df10c9b91aa4d7585", + "size": 15042204, + "subdir": "linux-64", + "timestamp": 1597687522153, + "version": "1.5.2" + }, + "scipy-1.5.2-py37h0b6359f_0.conda": { + "build": "py37h0b6359f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "234d7a928935399e865f9bd1c6c90c4a", + "name": "scipy", + "sha256": "3e457afb46fcccaf896b4dc3cf22c35450cec2d1c7f6b24d424755d66c36e0f7", + "size": 15003646, + "subdir": "linux-64", + "timestamp": 1597687691036, + "version": "1.5.2" + }, + "scipy-1.5.2-py37habc2bb6_0.conda": { + "build": "py37habc2bb6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7c1d7058c27f0fd79caf6ca4c73b07d4", + "name": "scipy", + "sha256": "162ad7e02fd206972fce6a8a106b56a36191b203aec551cc643792c7097bcd17", + "size": 15023868, + "subdir": "linux-64", + "timestamp": 1597687530575, + "version": "1.5.2" + }, + "scipy-1.5.2-py38h0b6359f_0.conda": { + "build": "py38h0b6359f_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "49be8a458f3e7fd1f475ffe04faf9415", + "name": "scipy", + "sha256": "de23e57d18d1a0ef46300c93b139915a4f20f3ba2dfadff6c13ea037f22fcb79", + "size": 15184959, + "subdir": "linux-64", + "timestamp": 1597687522148, + "version": "1.5.2" + }, + "scipy-1.5.2-py38habc2bb6_0.conda": { + "build": "py38habc2bb6_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "96b8cddc7b5deca44e50a9d6f023c810", + "name": "scipy", + "sha256": "bf430e06b8e8c30afca500fa1e9406df05edd27a3d8acb3358d527bc7d633a19", + "size": 15251817, + "subdir": "linux-64", + "timestamp": 1597687517445, + "version": "1.5.2" + }, + "scipy-1.5.2-py39h91f5cce_0.conda": { + "build": "py39h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f2b0f6a999e981a3ea02a2a83053b196", + "name": "scipy", + "sha256": "b37b18a8d70682fb52ff7887bcad32e219b9e9c9714401f80cce5631e36fff47", + "size": 15408446, + "subdir": "linux-64", + "timestamp": 1607617852399, + "version": "1.5.2" + }, + "scipy-1.5.2-py39hf56f3a7_0.conda": { + "build": "py39hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f6dc5e88dfd4f4e0b2b88a77e9103e97", + "name": "scipy", + "sha256": "a244694affb5b660c0e3e6975a2b875883384b5f8a68cc0d2533caffa2d1bd4c", + "size": 15408771, + "subdir": "linux-64", + "timestamp": 1607617812978, + "version": "1.5.2" + }, + "scipy-1.6.0-py37h91f5cce_0.conda": { + "build": "py37h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a15995a0b9a4271a7c732c757bbb7c05", + "name": "scipy", + "sha256": "11dc2f9fabb0fdd72046e908c15a782909ac3700d60c00967839a0b94b09fcb0", + "size": 16162433, + "subdir": "linux-64", + "timestamp": 1612470255644, + "version": "1.6.0" + }, + "scipy-1.6.0-py37hf56f3a7_0.conda": { + "build": "py37hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "db9b78a8846cb68894d8a610730876a0", + "name": "scipy", + "sha256": "8163282092f1f2397f55c247474adea8f35ff30c7c6ca5aa85cc27d32cba0adf", + "size": 16129179, + "subdir": "linux-64", + "timestamp": 1612470239301, + "version": "1.6.0" + }, + "scipy-1.6.0-py38h91f5cce_0.conda": { + "build": "py38h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5498ed2279aadc40583635d065550268", + "name": "scipy", + "sha256": "e3478564554dc007d447019c65ba7ddefa364664923614dbf8b48fdcb9f24b94", + "size": 16299910, + "subdir": "linux-64", + "timestamp": 1612470249448, + "version": "1.6.0" + }, + "scipy-1.6.0-py38hf56f3a7_0.conda": { + "build": "py38hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "00bb391a19384acc955c207371d8212e", + "name": "scipy", + "sha256": "1102f0b1fba5b8000fc210ab7c82103d428667e868004e26daa78e67b6e73fba", + "size": 16317240, + "subdir": "linux-64", + "timestamp": 1612470105252, + "version": "1.6.0" + }, + "scipy-1.6.0-py39h91f5cce_0.conda": { + "build": "py39h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ed39014124c07bc5e92bd635f0169fd0", + "name": "scipy", + "sha256": "fc22503586971e970c1293bb0e064a1db5429bd40a254b86dae86099ae07f80b", + "size": 16673076, + "subdir": "linux-64", + "timestamp": 1612469676204, + "version": "1.6.0" + }, + "scipy-1.6.0-py39hf56f3a7_0.conda": { + "build": "py39hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "855bba3eaada3c13595b1c780738b8ee", + "name": "scipy", + "sha256": "dfa654a2963aca2afb725f57b568513e93984b7c865cc6ce5e28ccf0b7d7e785", + "size": 16707894, + "subdir": "linux-64", + "timestamp": 1612470238887, + "version": "1.6.0" + }, + "scipy-1.6.1-py37h91f5cce_0.conda": { + "build": "py37h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2d65d89da7be3be45093a973b5f7d184", + "name": "scipy", + "sha256": "d3c5787de15e51f855dcad9ea559b5d7681ad2f955a1e13918cd3469f993e036", + "size": 16178727, + "subdir": "linux-64", + "timestamp": 1614023481445, + "version": "1.6.1" + }, + "scipy-1.6.1-py37hf56f3a7_0.conda": { + "build": "py37hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "307cc5b254d67e02ef73797fa0fbe98e", + "name": "scipy", + "sha256": "a1556bf5835824aa917214f19a30d9a7dbc6cf9758b8250c6a3440230a34dd06", + "size": 16162147, + "subdir": "linux-64", + "timestamp": 1614022582963, + "version": "1.6.1" + }, + "scipy-1.6.1-py38h91f5cce_0.conda": { + "build": "py38h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9ab8a3c24e9ab8303c793911ebd75d0f", + "name": "scipy", + "sha256": "afe365acf29a694ded7f88c2d3193a1b81605970680ed822c6d6f8ca8b5c1b57", + "size": 16336515, + "subdir": "linux-64", + "timestamp": 1614023385675, + "version": "1.6.1" + }, + "scipy-1.6.1-py38hf56f3a7_0.conda": { + "build": "py38hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0fc979237296073e922e4b897afe9b97", + "name": "scipy", + "sha256": "cabfaf1ec6a1c0a740a654bc7b062ba11df715cc46842db6280c4b769053f6c2", + "size": 16305753, + "subdir": "linux-64", + "timestamp": 1614022572299, + "version": "1.6.1" + }, + "scipy-1.6.1-py39h91f5cce_0.conda": { + "build": "py39h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2a5adbba2eaeadb1a368192c92bd8eda", + "name": "scipy", + "sha256": "f520f34814ae4b99e4a2dd79e1943c7c9f9ff04c55d02ad5f15fd178d82f86b1", + "size": 16704745, + "subdir": "linux-64", + "timestamp": 1614029302594, + "version": "1.6.1" + }, + "scipy-1.6.1-py39hf56f3a7_0.conda": { + "build": "py39hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9904fb8d93aaa8734de205eb158a5472", + "name": "scipy", + "sha256": "e4bfb27e7bb71ae0028b9ca037f4f4977a3b0c99b600030d7ce8a42d77663ddb", + "size": 16742430, + "subdir": "linux-64", + "timestamp": 1614023456391, + "version": "1.6.1" + }, + "scipy-1.6.2-py37h91f5cce_0.conda": { + "build": "py37h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c10a9cbe368f7db402d2e0d0b9e4d135", + "name": "scipy", + "sha256": "5b784af3e35bf48cf3d194ee623c3121491737a835c200423edcbaf128f49928", + "size": 16175370, + "subdir": "linux-64", + "timestamp": 1616701667008, + "version": "1.6.2" + }, + "scipy-1.6.2-py37had2a1c9_1.conda": { + "build": "py37had2a1c9_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c22f512ef3f27344a5a6328460a31256", + "name": "scipy", + "sha256": "dd08367971897952dda0ea77e7e947d50e03d0a7009631b560c3dc8a2f6e2477", + "size": 16202611, + "subdir": "linux-64", + "timestamp": 1618853339446, + "version": "1.6.2" + }, + "scipy-1.6.2-py37hf56f3a7_0.conda": { + "build": "py37hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f0e07ce3e6d833c3a683cb2154d1a766", + "name": "scipy", + "sha256": "7608ae4534d1b9604feb8259028d4c838423cb07c886df8d44dbe41de7cbd7fe", + "size": 16134015, + "subdir": "linux-64", + "timestamp": 1616703856349, + "version": "1.6.2" + }, + "scipy-1.6.2-py37hf56f3a7_1.conda": { + "build": "py37hf56f3a7_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2f177d935c56763b8a36023cb3da3d5b", + "name": "scipy", + "sha256": "df8d5cee47d184fdc2fc4a15d088bcf3c35f07f29acc231dc60e803582ead54c", + "size": 16170004, + "subdir": "linux-64", + "timestamp": 1618856628572, + "version": "1.6.2" + }, + "scipy-1.6.2-py38h91f5cce_0.conda": { + "build": "py38h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a1aa8fe30b9b93b0a7fd22c5452773f0", + "name": "scipy", + "sha256": "8b88d7dff5b3e004717b7dad5d70a77231777afd6b14580e1d7a2301b56a5b5a", + "size": 16375653, + "subdir": "linux-64", + "timestamp": 1616703866142, + "version": "1.6.2" + }, + "scipy-1.6.2-py38had2a1c9_1.conda": { + "build": "py38had2a1c9_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e6c2e8a210cbd7d6a361d3bf6c70093a", + "name": "scipy", + "sha256": "a404bff196d155a2b88fa51c0b86f34d5ef7ab82ca9d2095c9143adb5f5a3698", + "size": 16366014, + "subdir": "linux-64", + "timestamp": 1618856307974, + "version": "1.6.2" + }, + "scipy-1.6.2-py38hf56f3a7_0.conda": { + "build": "py38hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "49f89307b1410fcfae5c79bcb7ad7c00", + "name": "scipy", + "sha256": "566d9688cb97f4498b94996a6ee18854c70373db8bb2ca90e4482ac5865f81c4", + "size": 16353444, + "subdir": "linux-64", + "timestamp": 1616703964476, + "version": "1.6.2" + }, + "scipy-1.6.2-py38hf56f3a7_1.conda": { + "build": "py38hf56f3a7_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7f0684a6423a91950f0cb018218ba50e", + "name": "scipy", + "sha256": "bbeb89c46353e49ffe84430f28a28a75a4b7acd2c7274c18c27f2b447be76294", + "size": 16415298, + "subdir": "linux-64", + "timestamp": 1618856588916, + "version": "1.6.2" + }, + "scipy-1.6.2-py39h91f5cce_0.conda": { + "build": "py39h91f5cce_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c7a9a6001b3fbb3e4ad04d2f6e19dbce", + "name": "scipy", + "sha256": "78cb13224f75b60f650a85c31d4ce959f952632b14ebc2c209d697dfe0519e0a", + "size": 16720208, + "subdir": "linux-64", + "timestamp": 1616703992384, + "version": "1.6.2" + }, + "scipy-1.6.2-py39had2a1c9_1.conda": { + "build": "py39had2a1c9_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libstdcxx-ng >=7.3.0", + "mkl >=2021.2.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dc22ca911cedf8128bb40dd34cdec75a", + "name": "scipy", + "sha256": "cc1f63a404e80e119d73e325102195fa9dbdea12802afcb6b810035c9b4b0af4", + "size": 16711973, + "subdir": "linux-64", + "timestamp": 1618856702227, + "version": "1.6.2" + }, + "scipy-1.6.2-py39hf56f3a7_0.conda": { + "build": "py39hf56f3a7_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "09d637ef0cdddac4b6e7ea6f9380b562", + "name": "scipy", + "sha256": "811e1aefc1ff6c8ad3978a4dba23a61c000f4b80c8ca4c603de085e23607fa91", + "size": 16686442, + "subdir": "linux-64", + "timestamp": 1616703859670, + "version": "1.6.2" + }, + "scipy-1.6.2-py39hf56f3a7_1.conda": { + "build": "py39hf56f3a7_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libgfortran-ng >=7,<8.0a0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "22d4fc6d6927667bcf235f37a633727c", + "name": "scipy", + "sha256": "db30a6532f3830c15476e5eb167f6adc84f4d4e0aedcf0ac40398dcb7079ee85", + "size": 16690847, + "subdir": "linux-64", + "timestamp": 1618856563865, + "version": "1.6.2" + }, + "scipy-1.7.1-py37h292c36d_2.conda": { + "build": "py37h292c36d_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "73417d127524c283c68a5defbf211f0b", + "name": "scipy", + "sha256": "5784819655c78d7e80da8ecdcb47a2d43c9c20c82109252b0b67f14e92ed959b", + "size": 17170385, + "subdir": "linux-64", + "timestamp": 1630607544553, + "version": "1.7.1" + }, + "scipy-1.7.1-py37hc65b3f8_2.conda": { + "build": "py37hc65b3f8_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6c7ee398fa7f4369505514ab29043c4e", + "name": "scipy", + "sha256": "a9a1349a9196fc4365f166b08e78f63f20c971b37c8a98b6bb640e082b6037d5", + "size": 17128852, + "subdir": "linux-64", + "timestamp": 1630607275359, + "version": "1.7.1" + }, + "scipy-1.7.1-py38h292c36d_2.conda": { + "build": "py38h292c36d_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4a1b8d9d73491e2c245dae2790357a35", + "name": "scipy", + "sha256": "5fd42b57f7148191effd3beb845d14d244cb9f566b2f9c79df2344e53fc9bdab", + "size": 17366597, + "subdir": "linux-64", + "timestamp": 1630607582275, + "version": "1.7.1" + }, + "scipy-1.7.1-py38hc65b3f8_2.conda": { + "build": "py38hc65b3f8_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cda197cdf35e11aa72fc67b8259b5d20", + "name": "scipy", + "sha256": "55c806382465c264f7f9a5e680fba1685b1186e4a954499b36e35fd51ee4ee8d", + "size": 17362402, + "subdir": "linux-64", + "timestamp": 1630607576146, + "version": "1.7.1" + }, + "scipy-1.7.1-py39h292c36d_2.conda": { + "build": "py39h292c36d_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.3.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c00826e317e8e2aa013fc1d1dd50cc8b", + "name": "scipy", + "sha256": "1bd5d43cc1a1681dc094b62c4cb9da4437b3f90989c81e506f0f0040988233bc", + "size": 17762392, + "subdir": "linux-64", + "timestamp": 1630607582611, + "version": "1.7.1" + }, + "scipy-1.7.1-py39hc65b3f8_2.conda": { + "build": "py39hc65b3f8_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5e17a2c7e24306a2ecbe2187a34816e1", + "name": "scipy", + "sha256": "5b4b004c926143f326763d43822e8236d8d26d72e76cc60c3c53fdb4de3feaee", + "size": 17742390, + "subdir": "linux-64", + "timestamp": 1630607571741, + "version": "1.7.1" + }, + "scipy-1.7.3-py310h1794996_2.conda": { + "build": "py310h1794996_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<1.23", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "1cf7a2f8e5594980b2a89bdf219efc64", + "name": "scipy", + "sha256": "674f116285adfaac0011397041e89dcc3ec0b701504bc348c6e3826d71b1dfd0", + "size": 52206518, + "subdir": "linux-64", + "timestamp": 1661398526183, + "version": "1.7.3" + }, + "scipy-1.7.3-py310h4f1e569_0.conda": { + "build": "py310h4f1e569_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<1.23.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "787af47f973828e0b631cb35bc28429b", + "name": "scipy", + "sha256": "fb661c55d875b2d7ab510dd2ed017956d013a479a7915d97035c9b134696b189", + "size": 44948794, + "subdir": "linux-64", + "timestamp": 1641392138022, + "version": "1.7.3" + }, + "scipy-1.7.3-py310hac523dd_2.conda": { + "build": "py310hac523dd_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<1.23", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "eef7b7effa5a9499101a2712aa2b0546", + "name": "scipy", + "sha256": "5be4063c4d10eb8dd58d3b71e569f3270a969e27f2df35603ecc110e9ceade32", + "size": 51454165, + "subdir": "linux-64", + "timestamp": 1661391221927, + "version": "1.7.3" + }, + "scipy-1.7.3-py310hfa59a62_0.conda": { + "build": "py310hfa59a62_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21.2,<1.23.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "094aece1a833e077cb06ec4246b42c5b", + "name": "scipy", + "sha256": "8e62e4daaf1b4d4aa9a2e53dd74c018d59a5d2ffa2dec4c614b38cb877e93cd4", + "size": 45703551, + "subdir": "linux-64", + "timestamp": 1641390522722, + "version": "1.7.3" + }, + "scipy-1.7.3-py37h492baa0_0.conda": { + "build": "py37h492baa0_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<1.23.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "211e2087a96031804c0adfb64f35cfda", + "name": "scipy", + "sha256": "fa595d20ab264240fb195a237be78835714d733760fa5c0fb571b21dbe8237d6", + "size": 17188750, + "subdir": "linux-64", + "timestamp": 1641555797758, + "version": "1.7.3" + }, + "scipy-1.7.3-py37h6c91a56_2.conda": { + "build": "py37h6c91a56_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<1.23", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "59c808465b8b3b130aae7324da45740e", + "name": "scipy", + "sha256": "33aaadff605e95a01ed2c5d21a81f567f4c6abb3798006b0bfd14a76ef64a4d3", + "size": 17353140, + "subdir": "linux-64", + "timestamp": 1661402022788, + "version": "1.7.3" + }, + "scipy-1.7.3-py37hc147768_0.conda": { + "build": "py37hc147768_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<1.23.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e65bf9f5c1608c758217dc1db4f82d74", + "name": "scipy", + "sha256": "c1a86850bd03d6aa452197d9273033492569993af259a31c799e74e2030fb9dc", + "size": 17161303, + "subdir": "linux-64", + "timestamp": 1641537668818, + "version": "1.7.3" + }, + "scipy-1.7.3-py37hf838250_2.conda": { + "build": "py37hf838250_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16,<1.23", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e47aef53cca16864a9f9ffde81699fae", + "name": "scipy", + "sha256": "20dac7568bcc90ad21fddb0d15de390bae2ef4d773366714f6331dfa4c38921c", + "size": 17349855, + "subdir": "linux-64", + "timestamp": 1661394804902, + "version": "1.7.3" + }, + "scipy-1.7.3-py38h492baa0_0.conda": { + "build": "py38h492baa0_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<1.23.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "40d47c74d4de28bfff076bda6459a441", + "name": "scipy", + "sha256": "71e2160019f97e46fede8a2b7d53b4ccaefeab8e2cb8954f6d15e00ee232a2fe", + "size": 17385925, + "subdir": "linux-64", + "timestamp": 1641540904802, + "version": "1.7.3" + }, + "scipy-1.7.3-py38h6c91a56_2.conda": { + "build": "py38h6c91a56_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<1.23", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7bf98ce3f7b6c5ab7dd5b272edb4914f", + "name": "scipy", + "sha256": "d95586a0ea4a611c6e536ccb92a0ffa0175909df502455c324456d289bc2876d", + "size": 17576727, + "subdir": "linux-64", + "timestamp": 1661400308502, + "version": "1.7.3" + }, + "scipy-1.7.3-py38hc147768_0.conda": { + "build": "py38hc147768_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<1.23.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "3822cf4fb66ede852afd4084ac10cfa6", + "name": "scipy", + "sha256": "5493bb124c101e3a51f8606c7470b621cf4137008dfe82831f3b49efb61f5234", + "size": 17411291, + "subdir": "linux-64", + "timestamp": 1641555781306, + "version": "1.7.3" + }, + "scipy-1.7.3-py38hf838250_2.conda": { + "build": "py38hf838250_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16,<1.23", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "4c0558b2eebcf0dca0c4a4a2793da0f5", + "name": "scipy", + "sha256": "33c79ff37581c3820c96f47d10f7b9d4fd5956c14ed4fb32097269bb494abf1b", + "size": 17512179, + "subdir": "linux-64", + "timestamp": 1661393055149, + "version": "1.7.3" + }, + "scipy-1.7.3-py39h492baa0_0.conda": { + "build": "py39h492baa0_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<1.23.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1dfbf48c5afbbf5e0ef15db3fd5a6edd", + "name": "scipy", + "sha256": "8aed9a68af57011910111ef9c4d9edd44fe263a71ff8da34c5cae93ca24f4adb", + "size": 17807541, + "subdir": "linux-64", + "timestamp": 1641555756355, + "version": "1.7.3" + }, + "scipy-1.7.3-py39h6c91a56_2.conda": { + "build": "py39h6c91a56_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16,<1.23", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "1319d935cda4898cc3bc6c33a167cac6", + "name": "scipy", + "sha256": "6b3eb791858fd80de7754b744af18f77d004a19e2f9cc5be1fa7e9707d2af8db", + "size": 17777879, + "subdir": "linux-64", + "timestamp": 1661403721366, + "version": "1.7.3" + }, + "scipy-1.7.3-py39hc147768_0.conda": { + "build": "py39hc147768_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libgfortran-ng", + "libgfortran4 >=7.5.0", + "libstdcxx-ng >=7.5.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.16.6,<1.23.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a029b120ab27b810d48a331fbc333b2f", + "name": "scipy", + "sha256": "6d36687f55a0c040376b9b316a2761b83a504b2e65708b86deb3e5e991979db8", + "size": 17742947, + "subdir": "linux-64", + "timestamp": 1641555794105, + "version": "1.7.3" + }, + "scipy-1.7.3-py39hf838250_2.conda": { + "build": "py39hf838250_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.16,<1.23", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "0667ea5ac14d35e26da19a0f068739da", + "name": "scipy", + "sha256": "7b986d12eeceb93529e8bddd2032f0511be2af05fc69a87f8c35e8166da69b7c", + "size": 17846689, + "subdir": "linux-64", + "timestamp": 1661396602754, + "version": "1.7.3" + }, + "scipy-1.9.1-py310hd5efca6_0.conda": { + "build": "py310hd5efca6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<1.25.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "92d14554e3ca7c3142fab6150133ff61", + "name": "scipy", + "sha256": "2362b9dc8f24a1242827d389472a0e48a2fb5db190180bf27ed88887b1610b20", + "size": 70920809, + "subdir": "linux-64", + "timestamp": 1664919631870, + "version": "1.9.1" + }, + "scipy-1.9.1-py310heeff2f4_0.conda": { + "build": "py310heeff2f4_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<1.25.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "877dfc95721fb7d3dd50337cf9d6dcbe", + "name": "scipy", + "sha256": "8a88a67e8dfb0d6b3f03ae1e9b7e547d2be18c13507ec55abcfd8d04b338b6d5", + "size": 70078242, + "subdir": "linux-64", + "timestamp": 1664915705242, + "version": "1.9.1" + }, + "scipy-1.9.1-py38h14f4228_0.conda": { + "build": "py38h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19,<1.25.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3f636d2e9acfeb0b88a51217fe0b62cb", + "name": "scipy", + "sha256": "9b4b8a2c245811db1932800060440c7582ec1a49bc5fd3eace3b06189220c70d", + "size": 19710570, + "subdir": "linux-64", + "timestamp": 1664922122274, + "version": "1.9.1" + }, + "scipy-1.9.1-py38h32ae08f_0.conda": { + "build": "py38h32ae08f_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19,<1.25.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5d69d9b01bcc3bf7afeddc0b8b6ba8da", + "name": "scipy", + "sha256": "163a3ac8fd9d7e3abb424605e92b8f94e8ebd704882f33e31dcda410c764f489", + "size": 19710346, + "subdir": "linux-64", + "timestamp": 1664918235130, + "version": "1.9.1" + }, + "scipy-1.9.1-py39h14f4228_0.conda": { + "build": "py39h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19,<1.25.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f6a1be4898d50431f5c1a13a9c57dd31", + "name": "scipy", + "sha256": "ae62adddd6909e327f72c58d19835265fdd0ae6569db38e039e24bad36efd2ff", + "size": 20292374, + "subdir": "linux-64", + "timestamp": 1664920941588, + "version": "1.9.1" + }, + "scipy-1.9.1-py39h32ae08f_0.conda": { + "build": "py39h32ae08f_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19,<1.25.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "11db118e2d43666d649141af65e346e1", + "name": "scipy", + "sha256": "bb71754b67ff862a7a407889e86f11f67bb2ccf3af7701b2a5a836b48ca05e09", + "size": 20292379, + "subdir": "linux-64", + "timestamp": 1664917001244, + "version": "1.9.1" + }, + "scipy-1.9.3-py310hd5efca6_0.conda": { + "build": "py310hd5efca6_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<1.26.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "45c23e6a65a1de011668cc9ec102e285", + "name": "scipy", + "sha256": "37c3fb51e3a99f57b41c3f51658135ef67c97c6d13472e7164c6d0c6cf640a48", + "size": 24240695, + "subdir": "linux-64", + "timestamp": 1667581115246, + "version": "1.9.3" + }, + "scipy-1.9.3-py310hd5efca6_1.conda": { + "build": "py310hd5efca6_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.21,<1.26.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8ba6d91034cbaa9d763c448e930ba20b", + "name": "scipy", + "sha256": "9149154dd1641054feb43b14476aece3ea22c9b27528745c4ea8932b897b14d9", + "size": 24342738, + "subdir": "linux-64", + "timestamp": 1680103659543, + "version": "1.9.3" + }, + "scipy-1.9.3-py310heeff2f4_0.conda": { + "build": "py310heeff2f4_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<1.26.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "279194824c5b00dbdf1d418b792e34c5", + "name": "scipy", + "sha256": "09c6a548ad3e497c2d4bd6c1fad42ac770572d56030f9bd4537c1e01af64365b", + "size": 24237031, + "subdir": "linux-64", + "timestamp": 1667577274953, + "version": "1.9.3" + }, + "scipy-1.9.3-py310heeff2f4_1.conda": { + "build": "py310heeff2f4_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21,<1.26.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22573e952b51098e24e972d4786dff0c", + "name": "scipy", + "sha256": "5aca230334d05247c2585bc0ba2c41806ab8c8771a149d8efb53516dd2ff804c", + "size": 24342573, + "subdir": "linux-64", + "timestamp": 1680098737244, + "version": "1.9.3" + }, + "scipy-1.9.3-py311h24aa872_1.conda": { + "build": "py311h24aa872_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23,<1.26.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "827978280b91de5857a1002795b3d6bb", + "name": "scipy", + "sha256": "af9f7efc5f662777b48b2e7669fcd72ddb411d621a8e827575119d9f1794f9ea", + "size": 25843491, + "subdir": "linux-64", + "timestamp": 1680099907294, + "version": "1.9.3" + }, + "scipy-1.9.3-py311hc206e33_1.conda": { + "build": "py311hc206e33_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.23,<1.26.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bef1c2d13eedaaeabfbab5fdade6eae1", + "name": "scipy", + "sha256": "55d9465c68326e1cb517fca33b62fd12c163af77069fddbc6d6f86df05eb28e2", + "size": 25843484, + "subdir": "linux-64", + "timestamp": 1680104912340, + "version": "1.9.3" + }, + "scipy-1.9.3-py38h14f4228_0.conda": { + "build": "py38h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19,<1.26.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "269bb677abc14fd49f2e2f3c97d901a1", + "name": "scipy", + "sha256": "22f788876a4daec61f07618172698c234176af3d10716ad21ede0dc3696f81a5", + "size": 23365178, + "subdir": "linux-64", + "timestamp": 1667582373473, + "version": "1.9.3" + }, + "scipy-1.9.3-py38h14f4228_1.conda": { + "build": "py38h14f4228_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19,<1.26.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dd80735548141a3fec65a74ab469d5c1", + "name": "scipy", + "sha256": "acc21c79f59ecbb8f868987b93368c8b4e64823e9ad11cb0cda17317efc1ac64", + "size": 22805421, + "subdir": "linux-64", + "timestamp": 1680107329367, + "version": "1.9.3" + }, + "scipy-1.9.3-py38h32ae08f_0.conda": { + "build": "py38h32ae08f_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19,<1.26.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "200ba04331763e4d1b4535fd96734749", + "name": "scipy", + "sha256": "81f56f9ca9c27d9e3c1dd0a6244f13b8d88fcb1aa027b5899c795056d6abfa84", + "size": 23367940, + "subdir": "linux-64", + "timestamp": 1667578552544, + "version": "1.9.3" + }, + "scipy-1.9.3-py38h32ae08f_1.conda": { + "build": "py38h32ae08f_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19,<1.26.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "23f8052bb2b46631da6476a66a97b6b3", + "name": "scipy", + "sha256": "6df42d37ff143e8436213c243f7ca0709de3edf31dce297ed00f8c1cfc2d09b6", + "size": 22806515, + "subdir": "linux-64", + "timestamp": 1680102453549, + "version": "1.9.3" + }, + "scipy-1.9.3-py39h14f4228_0.conda": { + "build": "py39h14f4228_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "fftw >=3.3.9,<4.0a0", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19,<1.26.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aad1fdad8894881ac3789be7a63eaba8", + "name": "scipy", + "sha256": "65e8517cae995c79ba3a54f93a293153e2e42dcdb9109b23ea77eda023e8f20b", + "size": 23297949, + "subdir": "linux-64", + "timestamp": 1667583589796, + "version": "1.9.3" + }, + "scipy-1.9.3-py39h14f4228_1.conda": { + "build": "py39h14f4228_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "intel-openmp >=2021.4.0,<2022.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libstdcxx-ng >=11.2.0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "numpy >=1.19,<1.26.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9ea752e6be3367ff484d22d69f633430", + "name": "scipy", + "sha256": "628f5c837aeaca8513cacbba4c98d17a0e6cf54c62568f6504587f72fe7282b1", + "size": 23388658, + "subdir": "linux-64", + "timestamp": 1680106091435, + "version": "1.9.3" + }, + "scipy-1.9.3-py39h32ae08f_0.conda": { + "build": "py39h32ae08f_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "fftw >=3.3.9,<4.0a0", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19,<1.26.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a04cf30601f0f5000bf14a340964bc0f", + "name": "scipy", + "sha256": "290ec183c54ba5c8a84b00eab7a9fbac7cd6406d4ea637625eec111f07223c1a", + "size": 23298903, + "subdir": "linux-64", + "timestamp": 1667579805371, + "version": "1.9.3" + }, + "scipy-1.9.3-py39h32ae08f_1.conda": { + "build": "py39h32ae08f_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "libgcc-ng >=11.2.0", + "libgfortran-ng", + "libgfortran5 >=11.2.0", + "libopenblas >=0.3.21,<1.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19,<1.26.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "96439af1e8f6f8968d92796f84ef7a3f", + "name": "scipy", + "sha256": "3d86cd5146129d4909128ea89991e99585537c0747c000ddc63f2d4afb50c234", + "size": 23389205, + "subdir": "linux-64", + "timestamp": 1680101265678, + "version": "1.9.3" + }, + "scons-3.0.0-py27h8a56064_0.conda": { + "build": "py27h8a56064_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b851ecc93a4ad179243f23e848a0e872", + "name": "scons", + "sha256": "ee1aa9edb9aa8b4b17c94065fae7fefbafc3ff46d2a5940abdee11072dbf924a", + "size": 748380, + "subdir": "linux-64", + "timestamp": 1508602954444, + "version": "3.0.0" + }, + "scons-3.0.0-py35h10c8eaf_0.conda": { + "build": "py35h10c8eaf_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0e1b1e5c8bea5b3c1496ef14e6c1e789", + "name": "scons", + "sha256": "4f4853c717e1cb095acce9209aea7376ef1fd9ed761f8c58568373bc0998697f", + "size": 746767, + "subdir": "linux-64", + "timestamp": 1508602961596, + "version": "3.0.0" + }, + "scons-3.0.0-py36h799cc36_0.conda": { + "build": "py36h799cc36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "097ca7498f30db56b9edeebb129760db", + "name": "scons", + "sha256": "5bca4a742e3ad10c1f8634453c6a19075ee286269b7509f1d934ca85ace93406", + "size": 748951, + "subdir": "linux-64", + "timestamp": 1508602934846, + "version": "3.0.0" + }, + "scons-3.0.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0825465b8c4a2018720adbed3d487c06", + "name": "scons", + "sha256": "5fbfebf1a7bc8f4fc584d1192d309db2e7896991c9f9414230814b9fd7450a96", + "size": 744569, + "subdir": "linux-64", + "timestamp": 1522714682009, + "version": "3.0.1" + }, + "scons-3.0.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "629a4623b14f1a17c657b4c6b2f0f41d", + "name": "scons", + "sha256": "df67df94d37e4af21f61cf37798852582fab5ba8960803730af7c248b5da959f", + "size": 750738, + "subdir": "linux-64", + "timestamp": 1522714704350, + "version": "3.0.1" + }, + "scons-3.0.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0583ffce2f8ff300de5130db28af176a", + "name": "scons", + "sha256": "eec88f57dd8d1d275ecb93e0710a605fd5e2bb577f1c54673926aa031dfd49bb", + "size": 744070, + "subdir": "linux-64", + "timestamp": 1522715200427, + "version": "3.0.1" + }, + "scons-3.0.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f553b06f4a153ffa5cb0eede0ea0f414", + "name": "scons", + "sha256": "e7c04af4123f0e414d09f7ae8213056159d9cfa342edf8ed38b1b82e61b52879", + "size": 753369, + "subdir": "linux-64", + "timestamp": 1530959716146, + "version": "3.0.1" + }, + "scons-3.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d4e6a9ade401b001d59f390a62e38e3", + "name": "scons", + "sha256": "42627d4435383471266c55556f5c1af2841afeb239c638cd9197720a70af4ef3", + "size": 769912, + "subdir": "linux-64", + "timestamp": 1548005750817, + "version": "3.0.3" + }, + "scons-3.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0afe5c7741c66cf19224cd4bb175d5ab", + "name": "scons", + "sha256": "08c49b3f6f6bb49b07a03989f867b71ca45e911969a5ad887b8e9f4c565b6d9d", + "size": 761085, + "subdir": "linux-64", + "timestamp": 1548005769329, + "version": "3.0.3" + }, + "scons-3.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6fef6fbdd3017c93cd80ca69022dbd2", + "name": "scons", + "sha256": "b0d4d34cc91ce6d427d72b06d75e7e11aea2318a1b7e0e35a49cb8b180e3a320", + "size": 770377, + "subdir": "linux-64", + "timestamp": 1548005779480, + "version": "3.0.3" + }, + "scons-3.0.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b4da10ee04e6f68d39990e38afe8cab", + "name": "scons", + "sha256": "ca0e5ead20377ea7e600334a68611ae233209d95c23242b3035c4ecb3dad1af7", + "size": 773126, + "subdir": "linux-64", + "timestamp": 1550361122110, + "version": "3.0.4" + }, + "scons-3.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dfc58523a047a476310ee2f4e27065de", + "name": "scons", + "sha256": "3f90149b616fe0bd93cb6062d3daedad4580b22fa89227dd7fb588a8b5ccd661", + "size": 764196, + "subdir": "linux-64", + "timestamp": 1550361160508, + "version": "3.0.4" + }, + "scons-3.0.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d17d8517875dc4766723e1c60effa451", + "name": "scons", + "sha256": "0a595ad41aea4d14eda0700ca03e35317368b73b1d90e5e7f2903d7407f9f83a", + "size": 764408, + "subdir": "linux-64", + "timestamp": 1550361116456, + "version": "3.0.4" + }, + "scons-3.0.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4c02c3fa91cf51293a69291b3b705019", + "name": "scons", + "sha256": "366ef6beeaece2f5fe50cd68b6c2c2d2a4e37eaf1254748f9b8714a3eb861c12", + "size": 767625, + "subdir": "linux-64", + "timestamp": 1556075299305, + "version": "3.0.5" + }, + "scons-3.0.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ae7ba87adf29f3ed745232a8333d3fcc", + "name": "scons", + "sha256": "3e80f98ed07ab93b196114139fbcff04b73777c97536eb4eebf37bcf5a2b9a29", + "size": 766756, + "subdir": "linux-64", + "timestamp": 1556075486154, + "version": "3.0.5" + }, + "scons-3.0.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba9152ca41c531a3a0e56c3ddd0839bd", + "name": "scons", + "sha256": "01faaf6f809ad231b554acef4cbca4ed937e692c82d9aa0aa5387fdbbf249c97", + "size": 766820, + "subdir": "linux-64", + "timestamp": 1556075469066, + "version": "3.0.5" + }, + "scons-3.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a07581d9e9a280d4874c26bb696c040c", + "name": "scons", + "sha256": "0697f4b83c4a2c6ba3a83f5589b901b5f300d89282624d368cbb7d24855afaed", + "size": 778493, + "subdir": "linux-64", + "timestamp": 1564706802896, + "version": "3.1.0" + }, + "scons-3.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62292190b1ad9dc1a7a1070495232ee3", + "name": "scons", + "sha256": "c9c25b775a978722d12028f3909f9c2a6deb2107c4af0d7d1632065c3c90ab77", + "size": 778202, + "subdir": "linux-64", + "timestamp": 1564706822152, + "version": "3.1.0" + }, + "scons-3.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0b62cb5d8aafa0c4a3bc778127b60c5", + "name": "scons", + "sha256": "f3f2eac497da585ed2b5c77091503233de42b7c6036889e29ddfad1d0b04111d", + "size": 778141, + "subdir": "linux-64", + "timestamp": 1564706790233, + "version": "3.1.0" + }, + "scons-3.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d58297377564944404241a7526cd1a1d", + "name": "scons", + "sha256": "0cd7b250b2fa34288ac238a4626bf7dc516d31ca0713c20de9be3e2d9c353f3b", + "size": 780380, + "subdir": "linux-64", + "timestamp": 1569367347720, + "version": "3.1.1" + }, + "scons-3.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "55d0dbfcd24f1a728192f4761a3a7d18", + "name": "scons", + "sha256": "c9dd8359deda2df6ed13f41b8883b3c756b56d5cf2139914da6f0b91105476f4", + "size": 780125, + "subdir": "linux-64", + "timestamp": 1569367409635, + "version": "3.1.1" + }, + "scons-3.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66f39b6247502fd55e96a6cbbbe15d6e", + "name": "scons", + "sha256": "9e7114ec02e5385cc2c595f2c8dae5afb3f1b2ac7b79c3e7dc5b56eacfa5addc", + "size": 780255, + "subdir": "linux-64", + "timestamp": 1569367370565, + "version": "3.1.1" + }, + "scons-3.1.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "809b5b120257bd8e23d764170ec31c3f", + "name": "scons", + "sha256": "fd62ed0a422f38ee536fe3a9013271f6153fdaee6f3f9223356447686fe19b1a", + "size": 779276, + "subdir": "linux-64", + "timestamp": 1573200646342, + "version": "3.1.1" + }, + "scons-3.1.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a9a5e562b4f43e1c316c64ad46d7e664", + "name": "scons", + "sha256": "566494e87a27df517c10ed223a2ded0015aa391445247446a58971a185f1e50e", + "size": 778967, + "subdir": "linux-64", + "timestamp": 1640794521828, + "version": "3.1.2" + }, + "scons-3.1.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "99f0b0c6b269f955db8da58e278e8d9e", + "name": "scons", + "sha256": "4bcf510283d5ff1ad8351fb125da9dda465e789ad27c4fa4206edc50ed97fc99", + "size": 1003499, + "subdir": "linux-64", + "timestamp": 1676861991354, + "version": "3.1.2" + }, + "scons-3.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff1b7ba6de19cdaae94ddc1463dfccb6", + "name": "scons", + "sha256": "c78c509e6667d1c494d70a9ac5960bcd2328a486691aa8d9da33b5afb94f6761", + "size": 772864, + "subdir": "linux-64", + "timestamp": 1593489751499, + "version": "3.1.2" + }, + "scons-3.1.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b2d0c9d24bf14c57358e7bc84b1d6a9", + "name": "scons", + "sha256": "e1da8137b9d3f60dfa0e0754c57a2622976cdaa4d1e0b00544fbf7d7ea732b25", + "size": 772573, + "subdir": "linux-64", + "timestamp": 1632761494618, + "version": "3.1.2" + }, + "scons-3.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "99cec556034c71dfe2673bc9b3b454ad", + "name": "scons", + "sha256": "7629df887e97a1d1f68d40525244d1ab782cee4802c650f5ed4cc5352c54efd7", + "size": 772467, + "subdir": "linux-64", + "timestamp": 1593489747042, + "version": "3.1.2" + }, + "scons-3.1.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "abc9f1c8fa4c987c2e6d1f70e90b4204", + "name": "scons", + "sha256": "1f80c0ae62eef7a5c6e2fad3df7b72ee29b556a2e79ea2978aa0acd3423b874f", + "size": 780937, + "subdir": "linux-64", + "timestamp": 1632746532007, + "version": "3.1.2" + }, + "scons-3.1.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab3d0086058346701e8ef9d580b8b17d", + "name": "scons", + "sha256": "3ba3a13337c052bb370c70f84667c82aa18a0ab93155af567015447b5c5b7506", + "size": 775829, + "subdir": "linux-64", + "timestamp": 1593489748340, + "version": "3.1.2" + }, + "scons-3.1.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b78e6867a9285ba8e7f439761eefdbe7", + "name": "scons", + "sha256": "1db91770a49b0c4dde51019da19cf17525b97a5cad764e7d98dd5eb9e2730cbd", + "size": 784703, + "subdir": "linux-64", + "timestamp": 1632756973648, + "version": "3.1.2" + }, + "scons-3.1.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "688e907cbcc928f84a944f65650a9dde", + "name": "scons", + "sha256": "b08b3b9f1999b459b47b8ac4b1e73f7a6ec0018f2f7eabc9c517611267b0aa32", + "size": 783191, + "subdir": "linux-64", + "timestamp": 1632756976402, + "version": "3.1.2" + }, + "scons-4.1.0.post1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17d3d5470428aab4e5f192a1cee99974", + "name": "scons", + "sha256": "86a70ddb0f5e1714fbe25efe0712658e67a72fd3cc08547be9e974de7be4d82e", + "size": 1900366, + "subdir": "linux-64", + "timestamp": 1614713840040, + "version": "4.1.0.post1" + }, + "scons-4.1.0.post1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "acc27577c0d5b71ba44e3270b5da8ca9", + "name": "scons", + "sha256": "4a88fa2d9a6f62b7c8505e2cbe758bcb04d21ebff831b0b65b748a8c2a6f761d", + "size": 1898762, + "subdir": "linux-64", + "timestamp": 1614713820101, + "version": "4.1.0.post1" + }, + "scons-4.1.0.post1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1cc7417ce2c0d4bd2424854e476f9cb", + "name": "scons", + "sha256": "f46fccecca3f5aaf3aecd8878dec6573fdba6b628c8e9fc3eb3efb8c3bf1ae0c", + "size": 1894397, + "subdir": "linux-64", + "timestamp": 1614713754556, + "version": "4.1.0.post1" + }, + "scons-4.1.0.post1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe77c82fa14b02d5a3c9f8ffbb07a48c", + "name": "scons", + "sha256": "f98644a97556b3bc229900469aa8c8ce3c8e5d38064c5dc54b266a77d1c3fe23", + "size": 1895658, + "subdir": "linux-64", + "timestamp": 1614713817628, + "version": "4.1.0.post1" + }, + "scp-0.10.2-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "paramiko", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "22e9f4578d860cc056ad5066bcacbb3a", + "name": "scp", + "sha256": "5b6b144ce2bc9ae28e0c287dc3b9b989f87f2dfb1274e976b59b58c6faab206f", + "size": 14457, + "subdir": "linux-64", + "timestamp": 1522421060070, + "version": "0.10.2" + }, + "scp-0.10.2-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "paramiko", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "5aeb7d92bace5f7bd1ce9f443aa15bc7", + "name": "scp", + "sha256": "8fb7cdc3f84890d4ab90bd74ba935b65bfa56235b2bfba27eb86b53ae3108c90", + "size": 14672, + "subdir": "linux-64", + "timestamp": 1522421140884, + "version": "0.10.2" + }, + "scp-0.10.2-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "paramiko", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "520b9b249aaa362d30e0413bd5f3c950", + "name": "scp", + "sha256": "fa0564c8d49fc21766f439a06c575fd9a941d1cfd24eea403adeb716e592b7a8", + "size": 14462, + "subdir": "linux-64", + "timestamp": 1522421139265, + "version": "0.10.2" + }, + "scp-0.11.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "f9f41bfc662d3e0328c00f272bc5d0d7", + "name": "scp", + "sha256": "07af8da7805396fcff0247df939869055257ae61b99ae80ab26b75793571ab8a", + "size": 15743, + "subdir": "linux-64", + "timestamp": 1526944289932, + "version": "0.11.0" + }, + "scp-0.11.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "90fc1aeefdea2fab8799bac46be4c737", + "name": "scp", + "sha256": "1f8d3583c8b236ac9e7da55cfa81ef9178e4208ffc7700f7ae02c6d67b1214c5", + "size": 15981, + "subdir": "linux-64", + "timestamp": 1526944309258, + "version": "0.11.0" + }, + "scp-0.11.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "bb00d25b3e4ffc3043d2a42928786b37", + "name": "scp", + "sha256": "796aafed79dfc57836b91c52af59174d23b2856cd07526656e3850d2c92205ec", + "size": 15701, + "subdir": "linux-64", + "timestamp": 1526944281088, + "version": "0.11.0" + }, + "scp-0.11.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "070384567b13d4a5e501e28335061955", + "name": "scp", + "sha256": "91696734c54be2b4950a804a04d78198d1ad6250ebfe9abf903633ea850a57a3", + "size": 15824, + "subdir": "linux-64", + "timestamp": 1530959753376, + "version": "0.11.0" + }, + "scp-0.12.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "d5325f654cbee48869ca32ad754d2c40", + "name": "scp", + "sha256": "296df607e747920a26685453ff7df37ca04a7f76c1bae3049422e364c3baba4e", + "size": 16956, + "subdir": "linux-64", + "timestamp": 1539657258870, + "version": "0.12.1" + }, + "scp-0.12.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "611e954878f528aa8a0cf781f6a07f7b", + "name": "scp", + "sha256": "1d133d4917a53a2fd2198748b8759626907348c9241c4938bf8c917164d15533", + "size": 17232, + "subdir": "linux-64", + "timestamp": 1539657277414, + "version": "0.12.1" + }, + "scp-0.12.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "f3344eea48d58177cc3b6c71e9310e28", + "name": "scp", + "sha256": "0f81c564afb88d320212470ec4ff9ba925520d229ae50317defb6fb957792bb3", + "size": 17339, + "subdir": "linux-64", + "timestamp": 1539657279235, + "version": "0.12.1" + }, + "scp-0.13.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "3b031198ff2a5d2d7f1e4392ac3e0d0d", + "name": "scp", + "sha256": "6eab2bff355ed77536f0ac762de648081796ced5e91529f171670a76e4e86571", + "size": 16996, + "subdir": "linux-64", + "timestamp": 1542394390256, + "version": "0.13.0" + }, + "scp-0.13.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "db61c14d50c412b66cf1d266c211d1af", + "name": "scp", + "sha256": "a4ecf658b732d765333868b3c66ca75aa4d92521a22cc646d40daf74e3a8e7ed", + "size": 17133, + "subdir": "linux-64", + "timestamp": 1542394417962, + "version": "0.13.0" + }, + "scp-0.13.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "paramiko", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "65bbd0543679e008c4a35a8d3bf6310c", + "name": "scp", + "sha256": "94a809ad3d9f0999ecff50e3273dbe621c3eee36e9061370092ea9ff58cb1645", + "size": 17126, + "subdir": "linux-64", + "timestamp": 1542394344050, + "version": "0.13.0" + }, + "scrapy-1.4.0-py27h060f748_1.conda": { + "build": "py27h060f748_1", + "build_number": 1, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.1.0", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "570e07d3083ef237445c825709a8bb11", + "name": "scrapy", + "sha256": "f6380a759fa97a3649791c21dcf01b1fd4637456933e205340c05ea116d02539", + "size": 314974, + "subdir": "linux-64", + "timestamp": 1507838520990, + "version": "1.4.0" + }, + "scrapy-1.4.0-py35h03cf01c_1.conda": { + "build": "py35h03cf01c_1", + "build_number": 1, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.1.0", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.5,<3.6.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "0c5d010fc4dae1696b0f354453af975c", + "name": "scrapy", + "sha256": "6c860ee4aee24d22bf22a9317e8c50f71964edef6a3a6041916810ddc1bd0486", + "size": 321285, + "subdir": "linux-64", + "timestamp": 1507838530765, + "version": "1.4.0" + }, + "scrapy-1.4.0-py36h5dd8a1d_1.conda": { + "build": "py36h5dd8a1d_1", + "build_number": 1, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.1.0", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "87c5aa545a64089c153207e40a340a6f", + "name": "scrapy", + "sha256": "a5a7c6ce198db4b45587c03171d1bd92fd82f78c11336a2b40d8a26f1d9677fb", + "size": 321681, + "subdir": "linux-64", + "timestamp": 1507838581981, + "version": "1.4.0" + }, + "scrapy-1.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.1.0", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "b8ca93c594eef227ae8a29bb07394d39", + "name": "scrapy", + "sha256": "ac24836cc397701b22eb283316349d29819fd6ca78e5a0404311f5cc2e75ee7b", + "size": 318568, + "subdir": "linux-64", + "timestamp": 1519674106062, + "version": "1.5.0" + }, + "scrapy-1.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.1.0", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.5,<3.6.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "487ed7284c07dcda4e99da5cb8f8924f", + "name": "scrapy", + "sha256": "0cf94f604c053554168eeda1c05e1816ca93b4137ba3ba401f45164be74d3eab", + "size": 325029, + "subdir": "linux-64", + "timestamp": 1519674133232, + "version": "1.5.0" + }, + "scrapy-1.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.1.0", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "bfe7aef130d5c172f1cdbde3ddd6bc66", + "name": "scrapy", + "sha256": "227274778d0a2abd2dc6780385bc6c66d6eebe1ff5f12f49313ad89b4a1d8516", + "size": 325677, + "subdir": "linux-64", + "timestamp": 1519674245331, + "version": "1.5.0" + }, + "scrapy-1.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.1.0", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "baf28e0806bb86fe7064429c271fcf9c", + "name": "scrapy", + "sha256": "61b699d49df956b28764a7f82427839dc22eb20963d451028a966b94e4f8a3c8", + "size": 322850, + "subdir": "linux-64", + "timestamp": 1530959890591, + "version": "1.5.0" + }, + "scrapy-1.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.4", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "093672460a54d394a1211fbdcf01b6a3", + "name": "scrapy", + "sha256": "cf843d5e2960fb41aaf81bc758b6083e07c941dea8c2efbaae79caec6e9e5bc3", + "size": 318868, + "subdir": "linux-64", + "timestamp": 1533482047847, + "version": "1.5.1" + }, + "scrapy-1.5.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.4", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.5,<3.6.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "2fe95466de23b9d20e40284a3a86d123", + "name": "scrapy", + "sha256": "191ca4feaf95945210e5e43f1db7038ed3d4d371a3472f46529a8180c6d72999", + "size": 328671, + "subdir": "linux-64", + "timestamp": 1533482204643, + "version": "1.5.1" + }, + "scrapy-1.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.4", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "f9e56fb5a2bb05e076660b71d9d62844", + "name": "scrapy", + "sha256": "1a58680e782059ef42c0c09325362943c7cd11bcc77784bb41a18c609eda2698", + "size": 325804, + "subdir": "linux-64", + "timestamp": 1533482176530, + "version": "1.5.1" + }, + "scrapy-1.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.4", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "e10af9f2fc04d0875b7e834c6f78a828", + "name": "scrapy", + "sha256": "3d95c9f89afc594e86821ecfb92d0f9b7c498cca32ed6c753b9510531a94105e", + "size": 326321, + "subdir": "linux-64", + "timestamp": 1533482241443, + "version": "1.5.1" + }, + "scrapy-1.5.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "7b1ea7e715c0edda1695467a76be8da5", + "name": "scrapy", + "sha256": "2293a560b125e29e45d24d40169327157916f8b69ea0caf10b3628b0891d3c62", + "size": 323022, + "subdir": "linux-64", + "timestamp": 1552370610598, + "version": "1.5.2" + }, + "scrapy-1.5.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "ee89001f412d543d8a935192ff989a8b", + "name": "scrapy", + "sha256": "10ab8fbe53227afff8652b42df5f5100387a51108a829a4e5bbe8e52233ccbfa", + "size": 329689, + "subdir": "linux-64", + "timestamp": 1552370645552, + "version": "1.5.2" + }, + "scrapy-1.5.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "9d5229681f055745049b499e99aabc34", + "name": "scrapy", + "sha256": "41985e752dca8c8eec99884647c8f7482f567b0fac72cf931fe61ae3d412135c", + "size": 327138, + "subdir": "linux-64", + "timestamp": 1552370605060, + "version": "1.5.2" + }, + "scrapy-1.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=2.7,<2.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "b8abc67d71e08fa015f87ed633e8b6e7", + "name": "scrapy", + "sha256": "a4cfa263e1a7cd7bba82f56cd994db8357624be83db0e03a043753e68d2ed182", + "size": 323355, + "subdir": "linux-64", + "timestamp": 1556075703779, + "version": "1.6.0" + }, + "scrapy-1.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "226c42ea400d2b6f23ece2dfce138b1c", + "name": "scrapy", + "sha256": "1d6c2eb9acecd526d4d45f9e81cf3ca4867713045771ecb631be21f2ac826517", + "size": 326067, + "subdir": "linux-64", + "timestamp": 1556075871158, + "version": "1.6.0" + }, + "scrapy-1.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "fa51078ddc36931622c5076a0cd778ae", + "name": "scrapy", + "sha256": "5619670fdfa3ba38dcb208e46b451047e9893a8fc1cc359e51e816a6139d850b", + "size": 330409, + "subdir": "linux-64", + "timestamp": 1556075683807, + "version": "1.6.0" + }, + "scrapy-1.6.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "e74554068031550f105e17f82e14bcb3", + "name": "scrapy", + "sha256": "3712a7292f20ddbb02bdb94a90d16a40945a37130a33fea29c486e16afb3837b", + "size": 328049, + "subdir": "linux-64", + "timestamp": 1574237396384, + "version": "1.6.0" + }, + "scrapy-2.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.6,<3.7.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD 3-Clauses", + "md5": "80c7f97de8ebda2d536cc5c4b57570bc", + "name": "scrapy", + "sha256": "7ace0132ff3044e7f41e623a1857148b4fe4ba3b1adca6bd5616e1f76c04e629", + "size": 672452, + "subdir": "linux-64", + "timestamp": 1598667952785, + "version": "2.3.0" + }, + "scrapy-2.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD 3-Clauses", + "md5": "295385ce5e78281f5938563bba36d6ac", + "name": "scrapy", + "sha256": "b801df4d49c353070a9e44917f34624e39711b49cac2009fe5adcaa9e27d7797", + "size": 672476, + "subdir": "linux-64", + "timestamp": 1598667992392, + "version": "2.3.0" + }, + "scrapy-2.3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD 3-Clauses", + "md5": "c8fded39564e20b94c07f20b9899ff25", + "name": "scrapy", + "sha256": "27ed468aeb136bbb8b64c361da6278a0fa159bc26a3c84dbcffd0f241de4ed24", + "size": 679153, + "subdir": "linux-64", + "timestamp": 1598667942501, + "version": "2.3.0" + }, + "scrapy-2.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "itemadapter", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "c105c5d5074528e4425d0e6b1df01c45", + "name": "scrapy", + "sha256": "0fa270626e59df4b354d784aff712cdb3f74b99e67f87c11f9931cb7e4d55e79", + "size": 339260, + "subdir": "linux-64", + "timestamp": 1602522202086, + "version": "2.4.0" + }, + "scrapy-2.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "itemadapter", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "bd3dd3f67beb357e7dadbb5a60558f18", + "name": "scrapy", + "sha256": "f02206445c9484a3a409400fd5b10a5fc4e29e97eb3805a180626f67f222275a", + "size": 335729, + "subdir": "linux-64", + "timestamp": 1602522208802, + "version": "2.4.0" + }, + "scrapy-2.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "itemadapter", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "16d3a259845fea74647cffe59867ac28", + "name": "scrapy", + "sha256": "be4092c99f8b917fa49673aa0c3f9276ead68fcbad988f4df6ba4e76d238f1ca", + "size": 338997, + "subdir": "linux-64", + "timestamp": 1602522183183, + "version": "2.4.0" + }, + "scrapy-2.4.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "itemadapter", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.10,<3.11.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "b4ebf7e0eec60680174017b6d1d53e95", + "name": "scrapy", + "sha256": "c4879bbf0abb6bef74c992b1813c14478ee46f1ee72d6ba5f413fda8c1234cbb", + "size": 340541, + "subdir": "linux-64", + "timestamp": 1640814040733, + "version": "2.4.1" + }, + "scrapy-2.4.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "itemadapter", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.6,<3.7.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "b655d2f06bf9529b9239372c61c09463", + "name": "scrapy", + "sha256": "63fd2f71ffb73e2b19ce07ec9617f60fe1ac4ed4a79ae909ecd787395fe65ef2", + "size": 339386, + "subdir": "linux-64", + "timestamp": 1606864741202, + "version": "2.4.1" + }, + "scrapy-2.4.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "itemadapter", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.7,<3.8.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "c167db8ba968fddad2fed7163dfed0d1", + "name": "scrapy", + "sha256": "a8564ebf1312ce862d99b5bdde4f6becdab05f1daaf6fdd1b09b006ae6d4617a", + "size": 336943, + "subdir": "linux-64", + "timestamp": 1606864724261, + "version": "2.4.1" + }, + "scrapy-2.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "itemadapter", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.8,<3.9.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "8014449d6b5bd75675d8e8f11a99516e", + "name": "scrapy", + "sha256": "534283c045bca3056bc0e42b8d94e67802e1071ea3e1fdf38be4e24f939fb78e", + "size": 338152, + "subdir": "linux-64", + "timestamp": 1606864717256, + "version": "2.4.1" + }, + "scrapy-2.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cssselect >=0.9", + "itemadapter", + "lxml", + "parsel >=1.5", + "pydispatcher >=2.0.5", + "pyopenssl", + "python >=3.9,<3.10.0a0", + "queuelib", + "service_identity", + "setuptools", + "six >=1.5.2", + "twisted >=13.1.0", + "w3lib >=1.17.0" + ], + "license": "BSD 3-Clauses", + "md5": "14cbb06c0228d0957c55126fb0b3e89e", + "name": "scrapy", + "sha256": "4d0a11d778395d5e59677bc25ccb5b4508465b14b9b4c93984b5efe886369381", + "size": 344555, + "subdir": "linux-64", + "timestamp": 1632767717261, + "version": "2.4.1" + }, + "scrapy-2.6.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.10,<3.11.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "tldextract", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD-3-Clause-Clear", + "md5": "60a20525e7b7a529e03a1d334114219f", + "name": "scrapy", + "sha256": "4a3bfa1f81487ef60135e226212260f62cb9782982596bd811af57390b919fef", + "size": 385506, + "subdir": "linux-64", + "timestamp": 1646837818919, + "version": "2.6.1" + }, + "scrapy-2.6.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.11,<3.12.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "tldextract", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD-3-Clause-Clear", + "md5": "9c03e0216b1a48d9ee869629db96e953", + "name": "scrapy", + "sha256": "4d169910e8258eb1b5ebbd5f9365c4ff30c603fa998e1bd0741f49a4ecb0a3a1", + "size": 506375, + "subdir": "linux-64", + "timestamp": 1676862009215, + "version": "2.6.1" + }, + "scrapy-2.6.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "tldextract", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD-3-Clause-Clear", + "md5": "8ed4296351501cefd955c172ea9097c1", + "name": "scrapy", + "sha256": "bd1925e616ddb0a716a34b54b3ac880438084fca6a3fefbe8c6ad21f7d90fce7", + "size": 379250, + "subdir": "linux-64", + "timestamp": 1646837806315, + "version": "2.6.1" + }, + "scrapy-2.6.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "tldextract", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD-3-Clause-Clear", + "md5": "722e7fab166d511426554cea3b5c90a4", + "name": "scrapy", + "sha256": "9b34eca59b601aa52e77be450d3a6fe85bd0f3fbd042d5538d9224fe6d40932e", + "size": 382649, + "subdir": "linux-64", + "timestamp": 1646820325242, + "version": "2.6.1" + }, + "scrapy-2.6.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "tldextract", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD-3-Clause-Clear", + "md5": "c488a8be8c49e0522b589c35f6df162b", + "name": "scrapy", + "sha256": "776eb9ddcfb8ed304e82a2261d991fd38081885113454789ba1bbc549db997f9", + "size": 376609, + "subdir": "linux-64", + "timestamp": 1646837803867, + "version": "2.6.1" + }, + "scrapy-2.6.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.10,<3.11.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "tldextract", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "39980339a52fc90fada7eb7d4f6ea10f", + "name": "scrapy", + "sha256": "38215609968f81bb5071dc29e708260f7e8ff985084aff270f52482d17676976", + "size": 378857, + "subdir": "linux-64", + "timestamp": 1659598772609, + "version": "2.6.2" + }, + "scrapy-2.6.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.7,<3.8.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "tldextract", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "480373ab88b5e0eeab2d5a1547f3ea2c", + "name": "scrapy", + "sha256": "03aba744c79d03b99a376d78505a5f90ba113acc5256e90fc50d408e32fe9441", + "size": 372742, + "subdir": "linux-64", + "timestamp": 1659598850021, + "version": "2.6.2" + }, + "scrapy-2.6.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.8,<3.9.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "tldextract", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "13ccfd065b3aa9aaa5a8cc6bcc60940f", + "name": "scrapy", + "sha256": "cc69a30e19c936cc5051e7e1ec2e0d343456854da5a17da3044831b5b9b3d050", + "size": 374793, + "subdir": "linux-64", + "timestamp": 1659598810993, + "version": "2.6.2" + }, + "scrapy-2.6.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=2.0", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "lxml >=3.5.0", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=16.2.0", + "python >=3.9,<3.10.0a0", + "queuelib >=1.4.2", + "service_identity >=16.0.0", + "setuptools", + "tldextract", + "twisted >=17.9.0", + "w3lib >=1.17.0", + "zope.interface >=4.1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bfde4ec421622144e720fb89d63c745f", + "name": "scrapy", + "sha256": "418d234ab741bc28265a7c53bf272647014a72d3e0a6fc41a73962bf56f458a8", + "size": 375040, + "subdir": "linux-64", + "timestamp": 1659598723052, + "version": "2.6.2" + }, + "scrapy-2.8.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.4.6", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "lxml >=4.3.0", + "packaging", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=21.0.0", + "python >=3.10,<3.11.0a0", + "queuelib >=1.4.2", + "service_identity >=18.1.0", + "setuptools", + "tldextract", + "twisted >=18.9.0", + "w3lib >=1.17.0", + "zope.interface >=5.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa8734ba69425c383ac88a1e28d9aa39", + "name": "scrapy", + "sha256": "28a1a1dfbca3526357165763a52f6814afcf06ce06aca101b849759aef369283", + "size": 417985, + "subdir": "linux-64", + "timestamp": 1677738262394, + "version": "2.8.0" + }, + "scrapy-2.8.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.4.6", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "lxml >=4.3.0", + "packaging", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=21.0.0", + "python >=3.11,<3.12.0a0", + "queuelib >=1.4.2", + "service_identity >=18.1.0", + "setuptools", + "tldextract", + "twisted >=18.9.0", + "w3lib >=1.17.0", + "zope.interface >=5.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0e90378ba2515a4abe9461a9fcdc9c27", + "name": "scrapy", + "sha256": "625ad37ea7fbbdfab32e4a822e1c7f456ce7cf5bef925b7d16a8a1dc016735ae", + "size": 516283, + "subdir": "linux-64", + "timestamp": 1677770292922, + "version": "2.8.0" + }, + "scrapy-2.8.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.4.6", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "lxml >=4.3.0", + "packaging", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=21.0.0", + "python >=3.8,<3.9.0a0", + "queuelib >=1.4.2", + "service_identity >=18.1.0", + "setuptools", + "tldextract", + "twisted >=18.9.0", + "w3lib >=1.17.0", + "zope.interface >=5.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a3ccf553b3e3f481e451cda26fdfeb92", + "name": "scrapy", + "sha256": "2bd25e5aa17e5864d9d33c34416064012813cd51c91216eaf4b392918ea73e67", + "size": 414021, + "subdir": "linux-64", + "timestamp": 1677738215627, + "version": "2.8.0" + }, + "scrapy-2.8.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography >=3.4.6", + "cssselect >=0.9.1", + "itemadapter >=0.1.0", + "itemloaders >=1.0.1", + "libxml2 >=2.9.2,!=2.9.11,!=2.9.12", + "lxml >=4.3.0", + "packaging", + "parsel >=1.5.0", + "protego >=0.1.15", + "pydispatcher >=2.0.5", + "pyopenssl >=21.0.0", + "python >=3.9,<3.10.0a0", + "queuelib >=1.4.2", + "service_identity >=18.1.0", + "setuptools", + "tldextract", + "twisted >=18.9.0", + "w3lib >=1.17.0", + "zope.interface >=5.1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ab2e608507b123b32a11f464d24446a5", + "name": "scrapy", + "sha256": "d4b9e5744fb1c4283242b6a2f05b0090e1c91cb1a23eda808c70490153b41b02", + "size": 413960, + "subdir": "linux-64", + "timestamp": 1677738308082, + "version": "2.8.0" + }, + "seaborn-0.12.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "statsmodels >=0.10", + "scipy >=1.3" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17", + "pandas >=0.25", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "913852a45e1938e78ebe93e73384048b", + "name": "seaborn", + "sha256": "d439477a286f22520ce182bdfcd4b16b2bf779972352dad8d97fc747cc27a99e", + "size": 447668, + "subdir": "linux-64", + "timestamp": 1666299239280, + "version": "0.12.0" + }, + "seaborn-0.12.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "statsmodels >=0.10", + "scipy >=1.3" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17", + "pandas >=0.25", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e7394bc9df73863ecd7b52cfdcbf7f5b", + "name": "seaborn", + "sha256": "b1fa16121a512ed05085aea7e68ce070b0258b0e3f84a0085a3a88c53b21e6f7", + "size": 440243, + "subdir": "linux-64", + "timestamp": 1666299272918, + "version": "0.12.0" + }, + "seaborn-0.12.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "statsmodels >=0.10", + "scipy >=1.3" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17", + "pandas >=0.25", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c2250bbbed10dbb53051039517c21dc1", + "name": "seaborn", + "sha256": "67e924fa6ac9a1f3d5f632fa50c79e08e0d9d49e32714c2d04761ef54c52e926", + "size": 441800, + "subdir": "linux-64", + "timestamp": 1666299206213, + "version": "0.12.0" + }, + "seaborn-0.12.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "statsmodels >=0.10", + "scipy >=1.3" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17", + "pandas >=0.25", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c913c957d1324b4e83947423fcad701f", + "name": "seaborn", + "sha256": "a7599e7b2ee4f453962260a5969e2215e1d3452f24dc975d7d583fa39136faa4", + "size": 438295, + "subdir": "linux-64", + "timestamp": 1666299166245, + "version": "0.12.0" + }, + "seaborn-0.12.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "scipy >=1.3", + "statsmodels >=0.10" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17", + "pandas >=0.25", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6eb09e8f87376f8b2d1bbb914273694b", + "name": "seaborn", + "sha256": "d09e232dc7069d735c2c06bdac613c3500f21ef33b4b0b16f8aea6acc8de6360", + "size": 488003, + "subdir": "linux-64", + "timestamp": 1669627850490, + "version": "0.12.1" + }, + "seaborn-0.12.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "scipy >=1.3", + "statsmodels >=0.10" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17", + "pandas >=0.25", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f15728d6442f6d1f569a429c3219eacd", + "name": "seaborn", + "sha256": "b84452ae4eee68215bfabf0dbd6a308ad315423fe415c3d99dc51d8775e7a10e", + "size": 484815, + "subdir": "linux-64", + "timestamp": 1669627887279, + "version": "0.12.1" + }, + "seaborn-0.12.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "scipy >=1.3", + "statsmodels >=0.10" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17", + "pandas >=0.25", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1a80414c1dc556b052b79d557f749d59", + "name": "seaborn", + "sha256": "0d68402f8f7e0e9dee055fa097379c445d9d473a6fa285187b2543bce9a963a6", + "size": 486209, + "subdir": "linux-64", + "timestamp": 1669627957592, + "version": "0.12.1" + }, + "seaborn-0.12.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "scipy >=1.3", + "statsmodels >=0.10" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17", + "pandas >=0.25", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ae83f20f4ed77db0c871c2ef47e67c8b", + "name": "seaborn", + "sha256": "d9e6bf975390e91a7fba9af696d2cbff39c255f679a19e9063d1141a6681aed6", + "size": 478047, + "subdir": "linux-64", + "timestamp": 1669627922048, + "version": "0.12.1" + }, + "seaborn-0.12.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "statsmodels >=0.10", + "scipy >=1.3" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17,!=1.24.0", + "pandas >=0.25", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "64a10b5fd2e49446cf6d633b9871bd6f", + "name": "seaborn", + "sha256": "d2782fcfd4d06bfc2e427fea4a92d94ad557fe350d99da65cbbce23d4d1d216e", + "size": 503270, + "subdir": "linux-64", + "timestamp": 1673479293631, + "version": "0.12.2" + }, + "seaborn-0.12.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "statsmodels >=0.10", + "scipy >=1.3" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17,!=1.24.0", + "pandas >=0.25", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "74dd2e849c3281d297f7860522b09d7a", + "name": "seaborn", + "sha256": "8e573dedc939bb195cd364c51f0de01837667928995785116746cdff56f3bf31", + "size": 583576, + "subdir": "linux-64", + "timestamp": 1676845760936, + "version": "0.12.2" + }, + "seaborn-0.12.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "statsmodels >=0.10", + "scipy >=1.3" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17,!=1.24.0", + "pandas >=0.25", + "python >=3.7,<3.8.0a0", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2d75b88e321bc7f80b04eff8b951802f", + "name": "seaborn", + "sha256": "228a9000dc49b6a2a356f05373902e7d9a60d9f72a6897a8ceb5878e14402d3d", + "size": 500152, + "subdir": "linux-64", + "timestamp": 1673479258559, + "version": "0.12.2" + }, + "seaborn-0.12.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "statsmodels >=0.10", + "scipy >=1.3" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17,!=1.24.0", + "pandas >=0.25", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cc3198f0ea6e982b895d847abf206018", + "name": "seaborn", + "sha256": "348cef1dde5ea076e25875c769cfb86c69cb228b9f56b9270438aade8eadcda3", + "size": 502311, + "subdir": "linux-64", + "timestamp": 1673479218547, + "version": "0.12.2" + }, + "seaborn-0.12.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "statsmodels >=0.10", + "scipy >=1.3" + ], + "depends": [ + "matplotlib-base >=3.1,!=3.6.1", + "numpy >=1.17,!=1.24.0", + "pandas >=0.25", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c2b38663403d9cb0075355b8f10a0a25", + "name": "seaborn", + "sha256": "354e90095843a9a47ee7f641a7d2a472a95aaaaccd86cc18faaa087adb2ab5cc", + "size": 493438, + "subdir": "linux-64", + "timestamp": 1673479330048, + "version": "0.12.2" + }, + "seaborn-0.8.0-py27h9d2aaa1_0.conda": { + "build": "py27h9d2aaa1_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "pandas", + "patsy", + "python >=2.7,<2.8.0a0", + "scipy", + "statsmodels" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3a6e8daf9b95d46954ea8645f96ec547", + "name": "seaborn", + "sha256": "eadee4c9d00cb15d3b106663ec2fb40feb4b4631a0caa31c68283840436d3182", + "size": 322575, + "subdir": "linux-64", + "timestamp": 1505755899070, + "version": "0.8.0" + }, + "seaborn-0.8.0-py35h15a2772_0.conda": { + "build": "py35h15a2772_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "pandas", + "patsy", + "python >=3.5,<3.6.0a0", + "scipy", + "statsmodels" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cb51c1828372ca75daa4d461f86e76f7", + "name": "seaborn", + "sha256": "5051a80686d477e167cfe79eb7dbf2a6c2da2945a6e38a08c61096fc564d60fb", + "size": 326320, + "subdir": "linux-64", + "timestamp": 1505755921101, + "version": "0.8.0" + }, + "seaborn-0.8.0-py36h197244f_0.conda": { + "build": "py36h197244f_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "pandas", + "patsy", + "python >=3.6,<3.7.0a0", + "scipy", + "statsmodels" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6566818233a84be12d793c752b6e2f98", + "name": "seaborn", + "sha256": "f3472f55b1dc2f8d5f6a2748ab1c15bb80b67ad19283a0717e93bd68123782df", + "size": 326555, + "subdir": "linux-64", + "timestamp": 1505755942820, + "version": "0.8.0" + }, + "seaborn-0.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "pandas", + "patsy", + "python >=2.7,<2.8.0a0", + "scipy", + "statsmodels" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "17aa69f3e98922a520585085af2f4771", + "name": "seaborn", + "sha256": "825393b328bffcc33ca918cf8fb2925c360d8fc0dd3b26593939d45bf74c961c", + "size": 330233, + "subdir": "linux-64", + "timestamp": 1530960883609, + "version": "0.8.1" + }, + "seaborn-0.8.1-py27h633ea1e_0.conda": { + "build": "py27h633ea1e_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "pandas", + "patsy", + "python >=2.7,<2.8.0a0", + "scipy", + "statsmodels" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a5be92763919837c3219d44e94909ef4", + "name": "seaborn", + "sha256": "7bcd9f8cb70c50a0216f2fb719496d020c80d31bcf5dfc7f1b25c2d165352dbf", + "size": 330499, + "subdir": "linux-64", + "timestamp": 1511297743219, + "version": "0.8.1" + }, + "seaborn-0.8.1-py35h04cba02_0.conda": { + "build": "py35h04cba02_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "pandas", + "patsy", + "python >=3.5,<3.6.0a0", + "scipy", + "statsmodels" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aaf845b4a13e06ac25615fd47eaeba88", + "name": "seaborn", + "sha256": "092c1f9eea3206e37e50dd434f4510dee7c559884068507d94b9c91c5cb60a3f", + "size": 333757, + "subdir": "linux-64", + "timestamp": 1511297747194, + "version": "0.8.1" + }, + "seaborn-0.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "pandas", + "patsy", + "python >=3.6,<3.7.0a0", + "scipy", + "statsmodels" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7b9e5762354042af669ca6047fc1081f", + "name": "seaborn", + "sha256": "aa1cca7e62640311fd8500668303882388fe87fec68c59cbebffdefcfd7bcead", + "size": 327982, + "subdir": "linux-64", + "timestamp": 1530960924478, + "version": "0.8.1" + }, + "seaborn-0.8.1-py36hfad7ec4_0.conda": { + "build": "py36hfad7ec4_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "pandas", + "patsy", + "python >=3.6,<3.7.0a0", + "scipy", + "statsmodels" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "15bdfebeee1c5c8310a1a5515182611d", + "name": "seaborn", + "sha256": "7932804d95ce154eb4270e75b2ed82a233d3f072a723020276e2feef850f8405", + "size": 328243, + "subdir": "linux-64", + "timestamp": 1511297745632, + "version": "0.8.1" + }, + "seaborn-0.8.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "pandas", + "patsy", + "python >=3.7,<3.8.0a0", + "scipy", + "statsmodels" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "16b489b2302294e9e3c40de6bdc6d5e1", + "name": "seaborn", + "sha256": "83cdee1e08f6e6cc96f6e17b4bd0a58dcb5caf79c5729860f9dd5ba4246d41b8", + "size": 328367, + "subdir": "linux-64", + "timestamp": 1530960965199, + "version": "0.8.1" + }, + "seaborn-0.9.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "matplotlib >=1.4.3", + "numpy >=1.9.3", + "pandas >=0.14.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.15.2", + "statsmodels >=0.5.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4c23fa1ae729b4f6f63e44fbbe0fb394", + "name": "seaborn", + "sha256": "8c418acccc9d9ed3502d353a08f12453c14f264b78fe1e0919ff7bbf07a30552", + "size": 368296, + "subdir": "linux-64", + "timestamp": 1532466972052, + "version": "0.9.0" + }, + "seaborn-0.9.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "matplotlib >=1.4.3", + "numpy >=1.9.3", + "pandas >=0.14.0", + "python >=3.5,<3.6.0a0", + "scipy >=0.15.2", + "statsmodels >=0.5.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "03bb7f06f759f88899d95ed1ca1d1e53", + "name": "seaborn", + "sha256": "a6c66f1ae00c14000efdaca503a38772fcc5a8b3d57fefbc5250f3da78e19fdf", + "size": 367743, + "subdir": "linux-64", + "timestamp": 1532467027243, + "version": "0.9.0" + }, + "seaborn-0.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "matplotlib >=1.4.3", + "numpy >=1.9.3", + "pandas >=0.14.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.15.2", + "statsmodels >=0.5.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "77ea35b916ffc80308001690475786cc", + "name": "seaborn", + "sha256": "84ae64c0cc95e8c3e650714f7de5bf01fd4ec5bdf8919f17fe52a496d0b59acc", + "size": 360590, + "subdir": "linux-64", + "timestamp": 1532466917942, + "version": "0.9.0" + }, + "seaborn-0.9.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "matplotlib >=1.4.3", + "numpy >=1.9.3", + "pandas >=0.14.0", + "python >=3.7,<3.8.0a0", + "scipy >=0.15.2", + "statsmodels >=0.5.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b3b6720505b4a00544db2d6f4e31e19b", + "name": "seaborn", + "sha256": "c9a4aa05740ca849ae51190443c011332acacd6d21c7a9ea796e077146db12c6", + "size": 363130, + "subdir": "linux-64", + "timestamp": 1532467027042, + "version": "0.9.0" + }, + "secretstorage-3.0.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "522467a2a288e253c90b1843855bf561", + "name": "secretstorage", + "sha256": "5ecb065f216cd3d4610825e2814fff2d10eb645815286bbca0cbe1d3966fc0f8", + "size": 21940, + "subdir": "linux-64", + "timestamp": 1529953333389, + "version": "3.0.1" + }, + "secretstorage-3.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3c856d6cd4a6b71dc29cad1a6ec8642a", + "name": "secretstorage", + "sha256": "3b00a346bce143d1968f458d477261041476b8538c0acd7b1b7d89740b6ad921", + "size": 22081, + "subdir": "linux-64", + "timestamp": 1529953271948, + "version": "3.0.1" + }, + "secretstorage-3.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e5a2aa38a9733eaf563bc591054dda71", + "name": "secretstorage", + "sha256": "362dbabb910dbffb4890a69c3c09bd6df42e8e5168783172011c028e56e3e7a1", + "size": 21850, + "subdir": "linux-64", + "timestamp": 1530898181154, + "version": "3.0.1" + }, + "secretstorage-3.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5f3610170f91686232c48174280f8ee4", + "name": "secretstorage", + "sha256": "5103d7ddb2bfc1146376efd699d53f54b3e87928f08b0f45f362856de9f770d0", + "size": 23738, + "subdir": "linux-64", + "timestamp": 1536264577924, + "version": "3.1.0" + }, + "secretstorage-3.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07bddb0f2302825dd373ed4c970f09f5", + "name": "secretstorage", + "sha256": "7875ffd4952327097ae08b740d4ccc4046b1ea6c96fe5fc14996243fac3f1451", + "size": 23558, + "subdir": "linux-64", + "timestamp": 1536264609469, + "version": "3.1.0" + }, + "secretstorage-3.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fafb6ec34548cc148e92df880fdc0091", + "name": "secretstorage", + "sha256": "e457fd13e1a4cd722e660bf07aae1bec2073355d4aa96565fe258e6b319266ec", + "size": 23371, + "subdir": "linux-64", + "timestamp": 1536264579621, + "version": "3.1.0" + }, + "secretstorage-3.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6f79e5c0cbb721817c25d6c92226dada", + "name": "secretstorage", + "sha256": "8fc105203c8f1631811afe3b491e6056c9a549d89320ddb7e6a2dcc5addf33e8", + "size": 24662, + "subdir": "linux-64", + "timestamp": 1552404413918, + "version": "3.1.1" + }, + "secretstorage-3.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "733613623df0eb67c460fc9c445a0940", + "name": "secretstorage", + "sha256": "5925467ca22b56f1041fcf7847f75665c599bf03931184fbac910558b4b55f16", + "size": 24578, + "subdir": "linux-64", + "timestamp": 1552402583062, + "version": "3.1.1" + }, + "secretstorage-3.1.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "53f2f62ffc656092a508557eb92c5b96", + "name": "secretstorage", + "sha256": "b92d06ff25153820b2dc3134b1f9c7951168673e08e285ffa84a682f12c94a03", + "size": 23963, + "subdir": "linux-64", + "timestamp": 1574170608854, + "version": "3.1.1" + }, + "secretstorage-3.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8eec8aed5512199417caf83435457019", + "name": "secretstorage", + "sha256": "f5e6e455dad8cee4d2b9ac9bef58622ba5f6cce5b3694787fd9e78ea2401fde9", + "size": 25996, + "subdir": "linux-64", + "timestamp": 1580153967434, + "version": "3.1.2" + }, + "secretstorage-3.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "051698a6df5ef631e553b7947149b10b", + "name": "secretstorage", + "sha256": "74e7f6c9bc5403e4d05a61a7bd6be45210de1fff88c6d923be68c286dc4969e9", + "size": 25692, + "subdir": "linux-64", + "timestamp": 1580153874668, + "version": "3.1.2" + }, + "secretstorage-3.1.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7021d83adbd374bdfefe92a2c312967d", + "name": "secretstorage", + "sha256": "bb493c0bf9d0c525b9cbec41bc8094acd13bcc53a1a5ed0d2510f24dc46e3b4a", + "size": 23573, + "subdir": "linux-64", + "timestamp": 1594419247329, + "version": "3.1.2" + }, + "secretstorage-3.1.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "712d1592574ca2740b7b98a669bcfda4", + "name": "secretstorage", + "sha256": "e9376076cc7cb20109120b611594bc0fa8774f54fddd857bf38001796fa11a62", + "size": 25968, + "subdir": "linux-64", + "timestamp": 1580153979066, + "version": "3.1.2" + }, + "secretstorage-3.3.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a34c6a6a2832ee74219d58d92431612e", + "name": "secretstorage", + "sha256": "665fc33242f61b79acd4f40667688f6bcecbb65c7985c24b6e9bc94484198e62", + "size": 24947, + "subdir": "linux-64", + "timestamp": 1606864791817, + "version": "3.3.0" + }, + "secretstorage-3.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "44b2c0a3004f923aae4dd6b297cb4449", + "name": "secretstorage", + "sha256": "a593698b80ca5c1c482478669af4a469fcdc87fdb60c6e7882fb45edff46afc8", + "size": 24738, + "subdir": "linux-64", + "timestamp": 1606864786861, + "version": "3.3.0" + }, + "secretstorage-3.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d6418cfad8b211177e47a9cea5b04645", + "name": "secretstorage", + "sha256": "8a0af26b0fa678d5786a09806e6a54f1a18f1aa8878fab8091ed6ebee3829c11", + "size": 24709, + "subdir": "linux-64", + "timestamp": 1606864767477, + "version": "3.3.0" + }, + "secretstorage-3.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0e9a49a9da801dd2487e2da86c41b440", + "name": "secretstorage", + "sha256": "1a36b56534973fb53cd7f151424abbeb79ae16f68f3eef870388ec50def9efe5", + "size": 24655, + "subdir": "linux-64", + "timestamp": 1606864781423, + "version": "3.3.0" + }, + "secretstorage-3.3.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "de466b5dbfd8ad10cf3edca5a9faadbf", + "name": "secretstorage", + "sha256": "253109c7a052df2acd3b4fa5bf932b9975517cb32bb5ec882f83c6140ac5ec43", + "size": 24659, + "subdir": "linux-64", + "timestamp": 1640812919863, + "version": "3.3.1" + }, + "secretstorage-3.3.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography >=2.0", + "dbus >=1.13.18,<2.0a0", + "jeepney >=0.6", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c2180530067e077ecaff4d488fa3e0dc", + "name": "secretstorage", + "sha256": "177b225e726a54fc9d791be63d4afe0913fc526693d71aa57c7c388e604b6790", + "size": 26713, + "subdir": "linux-64", + "timestamp": 1678709520804, + "version": "3.3.1" + }, + "secretstorage-3.3.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "063a14cd78c20792032f811168372a04", + "name": "secretstorage", + "sha256": "e4b7727e43c1f5fa1a395e0ca408f047ef9c11efb4054e314515c4ec7d8d3b42", + "size": 29398, + "subdir": "linux-64", + "timestamp": 1676823120339, + "version": "3.3.1" + }, + "secretstorage-3.3.1-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography >=2.0", + "dbus >=1.13.18,<2.0a0", + "jeepney >=0.6", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a60c8f2b1575a0f163f12079be3f5537", + "name": "secretstorage", + "sha256": "542d4793c65535bf27f067e311defdd5a77c4065df1d55f61d31bb0d9949b090", + "size": 29370, + "subdir": "linux-64", + "timestamp": 1679339081474, + "version": "3.3.1" + }, + "secretstorage-3.3.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "171fb405c81cd96b7ea20918237e6f8c", + "name": "secretstorage", + "sha256": "63c57d0caa49f060cccc05e3386dc96e7157ad729158efb720c7c37d13db900c", + "size": 24706, + "subdir": "linux-64", + "timestamp": 1614022923362, + "version": "3.3.1" + }, + "secretstorage-3.3.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5e8f905b4223055cded90046d2ec959e", + "name": "secretstorage", + "sha256": "70690b9240d6bde02de2237dd413b1835be86df3a31efa0768df13b9fd49231d", + "size": 24526, + "subdir": "linux-64", + "timestamp": 1614022922365, + "version": "3.3.1" + }, + "secretstorage-3.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4c32593be1d928303450fa819826d768", + "name": "secretstorage", + "sha256": "eb130e3ad78ea92234b7099411ed7ed3ea7a01a46e96512523a8323a363c351d", + "size": 24950, + "subdir": "linux-64", + "timestamp": 1614022820453, + "version": "3.3.1" + }, + "secretstorage-3.3.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography >=2.0", + "dbus >=1.13.18,<2.0a0", + "jeepney >=0.6", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "524a7bd2c2ddcb3ab0caa2ba025835d1", + "name": "secretstorage", + "sha256": "b77ca2c4755b11176767205e2079fd548e784c14bfb18cb3c8e974a8d0ac2cec", + "size": 26671, + "subdir": "linux-64", + "timestamp": 1678709547289, + "version": "3.3.1" + }, + "secretstorage-3.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "dbus", + "jeepney >=0.6", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3636931857a4693b04fd4bcc96164fe6", + "name": "secretstorage", + "sha256": "a3982b8dd1902977eb1630eaf919274c98ac286567796036b0dadd76e7c542ac", + "size": 24946, + "subdir": "linux-64", + "timestamp": 1614022815930, + "version": "3.3.1" + }, + "secretstorage-3.3.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "cryptography >=2.0", + "dbus >=1.13.18,<2.0a0", + "jeepney >=0.6", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a36fafa7c4d44a91b031fbf743710082", + "name": "secretstorage", + "sha256": "9754ec4e9e8a305d26c7f3a8e0095bbe169f63d24b309d3643a000013ec39e9f", + "size": 26589, + "subdir": "linux-64", + "timestamp": 1678709572644, + "version": "3.3.1" + }, + "sed-4.4-h7b6447c_2.conda": { + "build": "h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-3", + "md5": "c99d473abbe784de0d58fb3b56c6468e", + "name": "sed", + "sha256": "e45e2985c4d383b9d8291e495bfc9cc27b6796604ccceca1c9dd20bee11c3c88", + "size": 190350, + "subdir": "linux-64", + "timestamp": 1597346946296, + "version": "4.4" + }, + "sed-4.8-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.2", + "libgcc-ng >=7.3.0" + ], + "license": "GPL-3", + "md5": "1d65223e7e8ea672d0e398cadebb109f", + "name": "sed", + "sha256": "d326272a678f1cd43030780baf468813092e608329551cfe1872b4b2e219c0b7", + "size": 244128, + "subdir": "linux-64", + "timestamp": 1600482712427, + "version": "4.8" + }, + "selenium-3.11.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d1b3410325328dc404f44887261f14c9", + "name": "selenium", + "sha256": "bbadf307eb5b53099325152bad4e164f21e2c0f311d411f1bcd91fcf861a04be", + "size": 822103, + "subdir": "linux-64", + "timestamp": 1522790886570, + "version": "3.11.0" + }, + "selenium-3.11.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1f3eaa111e82d5403ff670869c6f6707", + "name": "selenium", + "sha256": "e1b8a829f0fa9ae97857f18bd3c2c3ba214e56c8f9d73f50d053cbc74a9b0e82", + "size": 825294, + "subdir": "linux-64", + "timestamp": 1522790515045, + "version": "3.11.0" + }, + "selenium-3.11.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e4a4433a34f2889dd860ad57f5f911af", + "name": "selenium", + "sha256": "eb8385c36ce9638083fd6ae0f926b7dcfc8f262060198cc1c4a9749da658d6aa", + "size": 824132, + "subdir": "linux-64", + "timestamp": 1522790897177, + "version": "3.11.0" + }, + "selenium-3.12.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0723ec572e243fbe375375b3032cbb14", + "name": "selenium", + "sha256": "39c3276d76aad45abfdb156e638fe039220537105b041c30e106ee64afdca08d", + "size": 827820, + "subdir": "linux-64", + "timestamp": 1529217366559, + "version": "3.12.0" + }, + "selenium-3.12.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b461939a261e70b82d914787c39c8b0f", + "name": "selenium", + "sha256": "77daaf9ae64e42eaeb5474b3dce8742612aa48da27d5829f705132ba7afc9a32", + "size": 828015, + "subdir": "linux-64", + "timestamp": 1529217408168, + "version": "3.12.0" + }, + "selenium-3.12.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b208d186a786ecc85b002f5e8de1fa61", + "name": "selenium", + "sha256": "3cd228136a8a3194ae14e769571c00f524c59ce68b9068070852845d1fed1f1f", + "size": 825972, + "subdir": "linux-64", + "timestamp": 1529217345693, + "version": "3.12.0" + }, + "selenium-3.12.0-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e93a9864399358eb1fdc3d8379e96846", + "name": "selenium", + "sha256": "129294d3de54eebece7987ac057c0a044fe65220c5d42e2b028309171534e1a0", + "size": 827125, + "subdir": "linux-64", + "timestamp": 1530922430870, + "version": "3.12.0" + }, + "selenium-3.13.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "07272ffcba0c229711e8bfcbab0a431f", + "name": "selenium", + "sha256": "0e74874e14f65c51653eac7f498814c8a2fc9c1a7fc5b2a7d1155e22ad2ac832", + "size": 829776, + "subdir": "linux-64", + "timestamp": 1532881792230, + "version": "3.13.0" + }, + "selenium-3.13.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b20745d76b2df565ec2cf33882175434", + "name": "selenium", + "sha256": "af921334699b06bf9bd593582eaff94533e6a33ef5cd73dfe2c41b6f8f10bd80", + "size": 830347, + "subdir": "linux-64", + "timestamp": 1532881886959, + "version": "3.13.0" + }, + "selenium-3.13.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "65c64eb8bf0625486f7449cdf7e7853b", + "name": "selenium", + "sha256": "0cb5dc4ed07f8a46b387618b0405bb23544326a2dccbb21cf797a3e211dbe8da", + "size": 828315, + "subdir": "linux-64", + "timestamp": 1532881741900, + "version": "3.13.0" + }, + "selenium-3.13.0-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2a53bf303122d162a327d34e818d752a", + "name": "selenium", + "sha256": "6add5da8a3700f9d4986c9d8a4fa7cf593de24a2db2ae5a7c80db65030543a42", + "size": 827820, + "subdir": "linux-64", + "timestamp": 1532881891427, + "version": "3.13.0" + }, + "selenium-3.14.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a7b17033ce11a6dbf7bf2569d1239d4d", + "name": "selenium", + "sha256": "a1f3ea37b3fff45ed5ccf8f5b816880ea4fab49a5ae59d23196a6c4963ff2345", + "size": 823513, + "subdir": "linux-64", + "timestamp": 1534396881379, + "version": "3.14.0" + }, + "selenium-3.14.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cd50875acc04b23829e36713db30b9f9", + "name": "selenium", + "sha256": "cb951df5dd06e74a181e066fc0790c13dc5a667146e18c3f406726af0b10be0e", + "size": 823938, + "subdir": "linux-64", + "timestamp": 1534396928028, + "version": "3.14.0" + }, + "selenium-3.14.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cbeffdae393731cc7aabbb485b5b6e23", + "name": "selenium", + "sha256": "99e2de11541292bec0d7e47bfc4311261adc39f8e7e93f2377b5b9561a74cc8e", + "size": 825522, + "subdir": "linux-64", + "timestamp": 1534804134783, + "version": "3.14.0" + }, + "selenium-3.14.0-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "113b60864fc7ea92f6244c93ab421582", + "name": "selenium", + "sha256": "4270c378a8886aaf20430db8760e67cb6150fa462992a50c9f97d56a3cfd7874", + "size": 825386, + "subdir": "linux-64", + "timestamp": 1534396959146, + "version": "3.14.0" + }, + "selenium-3.14.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b71c56c38ecc0eebe43c1b6ed7a3f463", + "name": "selenium", + "sha256": "6376e88b291ffeb2207e1aadecbc3d6ec92aeccab341736d88a165deb94daaf9", + "size": 825086, + "subdir": "linux-64", + "timestamp": 1539652839505, + "version": "3.14.1" + }, + "selenium-3.14.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fa5273c124dc22ecee95de5ae0e61ce4", + "name": "selenium", + "sha256": "b929ea65735e84a06e1a0e34ff86a3df337982a99afb9370638b5258f6f2f2ce", + "size": 828144, + "subdir": "linux-64", + "timestamp": 1539652867608, + "version": "3.14.1" + }, + "selenium-3.14.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0e40bc27dae098862d2d92319183ac6c", + "name": "selenium", + "sha256": "67142eca100ea2025203224d14d1cb5e1e7b01adc464ee828c6d3b7204937bcc", + "size": 823894, + "subdir": "linux-64", + "timestamp": 1539652859554, + "version": "3.14.1" + }, + "selenium-3.141.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cd73a42265393f5989cfbd25effb7422", + "name": "selenium", + "sha256": "1780b2d049a2f29a69ede25c320aedc157e493b2b6cfb39398296243800a022c", + "size": 824545, + "subdir": "linux-64", + "timestamp": 1545122415273, + "version": "3.141.0" + }, + "selenium-3.141.0-py310h7f8727e_1000.conda": { + "build": "py310h7f8727e_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8440ec4d53d3df0dd1c4eb7553defc13", + "name": "selenium", + "sha256": "aa892618c9246c48302af7425c3bb9564900a599610a40c91d61eceb8cbf0f2c", + "size": 833458, + "subdir": "linux-64", + "timestamp": 1640794547696, + "version": "3.141.0" + }, + "selenium-3.141.0-py311h5eee18b_1000.conda": { + "build": "py311h5eee18b_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2df5923a154a827b2be8eacc67ba1af7", + "name": "selenium", + "sha256": "c18f51289ba2e3bf7ad0e9245616c4129eb099c5ee139120e957f4171d65bcea", + "size": 874633, + "subdir": "linux-64", + "timestamp": 1676862029614, + "version": "3.141.0" + }, + "selenium-3.141.0-py36h27cfd23_1000.conda": { + "build": "py36h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "07eba912624e6cb1f6fb67a0bfd046c6", + "name": "selenium", + "sha256": "402b301c8ed7e77226ebb46984edaa8a3aab116919f2d2bab1c3d190fa6aa090", + "size": 835590, + "subdir": "linux-64", + "timestamp": 1614267825447, + "version": "3.141.0" + }, + "selenium-3.141.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cd040f86c4b806bfd4fe9a3dd9cb7249", + "name": "selenium", + "sha256": "fb93d644e99386a227fba8f622dc838db0176b0c429916e67ebd549027e44a96", + "size": 823515, + "subdir": "linux-64", + "timestamp": 1545122413191, + "version": "3.141.0" + }, + "selenium-3.141.0-py37h14c3975_1001.conda": { + "build": "py37h14c3975_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "240348c0ae792b64714de3a0f98f3a82", + "name": "selenium", + "sha256": "f5da08c4ebb8db36a4cbc44ad6b0598d74077c991eadc8163060294032b6838a", + "size": 830623, + "subdir": "linux-64", + "timestamp": 1594420493940, + "version": "3.141.0" + }, + "selenium-3.141.0-py37h27cfd23_1000.conda": { + "build": "py37h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cb32abf753a28bc076fbd629eb00ddcb", + "name": "selenium", + "sha256": "a08b9731ee2e4f336d2c69ae41b349b487b0ee762f9420ebc1e231c274f71a98", + "size": 833592, + "subdir": "linux-64", + "timestamp": 1614267829152, + "version": "3.141.0" + }, + "selenium-3.141.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "42ec1ec232f2e74fb2fc2481d2603c6d", + "name": "selenium", + "sha256": "ddb6c6454584ba3172760908c31eae1a3c436f389eee2685d8d36e0b5fd2b87a", + "size": 826001, + "subdir": "linux-64", + "timestamp": 1545122411143, + "version": "3.141.0" + }, + "selenium-3.141.0-py38h27cfd23_1000.conda": { + "build": "py38h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f8a102b99b38ca4f5efdf85656d40035", + "name": "selenium", + "sha256": "7a6303c6dce172c6e809044e8ef91eae7f9be0f14b2b81a4f082c5b103acdad0", + "size": 834048, + "subdir": "linux-64", + "timestamp": 1614267845315, + "version": "3.141.0" + }, + "selenium-3.141.0-py38h7b6447c_1000.conda": { + "build": "py38h7b6447c_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3d0ab8d9bc7bfb939fb7afbbe217b75b", + "name": "selenium", + "sha256": "da9f4a5ae9057a2b52af67f7a48bc4832427aaea02d6b9373dc917f93572229e", + "size": 839703, + "subdir": "linux-64", + "timestamp": 1573200367505, + "version": "3.141.0" + }, + "selenium-3.141.0-py39h27cfd23_1000.conda": { + "build": "py39h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "urllib3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "11eb7893fad1c674a47a4ea50672eb22", + "name": "selenium", + "sha256": "942098adb0c38a696108bf05b4cad0269b215346558f47a2052fbf08b99bc50d", + "size": 837741, + "subdir": "linux-64", + "timestamp": 1614267848839, + "version": "3.141.0" + }, + "selenium-3.8.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d7a2bdb9394b40ab1d9f8e30804ef20b", + "name": "selenium", + "sha256": "20fca1d792797be28dae4e872ee1e972f45924facf279155ee8c9cc8b7fdf36d", + "size": 823454, + "subdir": "linux-64", + "timestamp": 1532968094879, + "version": "3.8.0" + }, + "selenium-3.8.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cc6a55842c262a0367971562db5e9572", + "name": "selenium", + "sha256": "312fe3dea749e5250ecd9d38685f5cb77cbeb26a623eb17332ecede8001932ef", + "size": 826874, + "subdir": "linux-64", + "timestamp": 1532968112552, + "version": "3.8.0" + }, + "selenium-3.8.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ff4e0e977bd1a6ab4bd0629b53d7ae40", + "name": "selenium", + "sha256": "9ca637c3ab3a8f47e4622569cdcb48e87ebc43b7bbc82f8be2dbe689dc5becdc", + "size": 826510, + "subdir": "linux-64", + "timestamp": 1532968029435, + "version": "3.8.0" + }, + "selenium-3.8.0-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1977258b230b2b1d2e9a13195d1fcf42", + "name": "selenium", + "sha256": "a15a9b42a77e256ef18df863b4440cbaab3b0102d2d9cfa0675f6884937c91f3", + "size": 824229, + "subdir": "linux-64", + "timestamp": 1532968111439, + "version": "3.8.0" + }, + "selenium-3.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c2e3f1394b38696756c982a0c529955b", + "name": "selenium", + "sha256": "a82619bcc89385038ed9b695fe142fba6a8e6cd65ba2bc1d6a9a3ab4e92330cc", + "size": 822399, + "subdir": "linux-64", + "timestamp": 1517949476920, + "version": "3.8.1" + }, + "selenium-3.8.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3db9627c3e5470de006b7ea71a96f525", + "name": "selenium", + "sha256": "61309c931479322a2af000650606c75ffd85552beb040fe8e3f9bb7d462fc2c7", + "size": 824898, + "subdir": "linux-64", + "timestamp": 1517949491066, + "version": "3.8.1" + }, + "selenium-3.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "713a218fa598ae6a3213de3864c4ee8c", + "name": "selenium", + "sha256": "4119b883d1d055d6153c675c03f9ddcf1821eb44beae773598ba430e34235aec", + "size": 820608, + "subdir": "linux-64", + "timestamp": 1517949506646, + "version": "3.8.1" + }, + "selenium-3.9.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8be4f08aba0ee6db5a8ad96e447afcf0", + "name": "selenium", + "sha256": "7950f006581dca7a19bf74abaa5399b68b6380e622847105e8e5c4c73640123c", + "size": 819967, + "subdir": "linux-64", + "timestamp": 1519238886803, + "version": "3.9.0" + }, + "selenium-3.9.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b03afc74946122931e31b4a3d70324dd", + "name": "selenium", + "sha256": "5aceced8c3a8a7dab07d497d7d3767d4966a80a9166e6fbd5457424355fd1700", + "size": 821753, + "subdir": "linux-64", + "timestamp": 1519238898923, + "version": "3.9.0" + }, + "selenium-3.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d2362c8f8f5292a9c398e1c0350f134f", + "name": "selenium", + "sha256": "0a38a188368218649a5196ffa7ca2f284abb1685c00c008fb9ddf44009cbd70e", + "size": 820730, + "subdir": "linux-64", + "timestamp": 1519238878234, + "version": "3.9.0" + }, + "semantic_version-2.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "d71cf3b2f9cd441c7257c9d948a2861f", + "name": "semantic_version", + "sha256": "86066d7ae5eaa1567571577fae32904c8b5364499ba4f66a3a79998f95802c8d", + "size": 19801, + "subdir": "linux-64", + "timestamp": 1538441950287, + "version": "2.6.0" + }, + "semver-2.7.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "c93023eeee1189e10d17b67d603d5747", + "name": "semver", + "sha256": "0bcdd3889dfecf8dcc6d7b98b1f69abaf3fa041d88293a9214d66c8037f215df", + "size": 11150, + "subdir": "linux-64", + "timestamp": 1522880852724, + "version": "2.7.9" + }, + "semver-2.7.9-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "e8b9c9b39433f803227bcbddde0addbf", + "name": "semver", + "sha256": "45c1a1d5af9527f6960a7484996286b7ee1ab25e48cb3e082082a4cb4d2c8509", + "size": 11219, + "subdir": "linux-64", + "timestamp": 1522880870801, + "version": "2.7.9" + }, + "semver-2.7.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "8dfea8a3d06f57172e2a045457b8b77d", + "name": "semver", + "sha256": "11aff1e0f6626e9df6e4102c84df7789a3fb1fc9e2649dbd4e03f60288b48511", + "size": 11132, + "subdir": "linux-64", + "timestamp": 1522880870752, + "version": "2.7.9" + }, + "semver-2.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "042c312310858bd83d17a78a75143bb6", + "name": "semver", + "sha256": "b4570b69fc0c1c851fbeec78ce2ba241fc08bb73ed08e378fd68fa329dc1e57f", + "size": 10910, + "subdir": "linux-64", + "timestamp": 1526937618653, + "version": "2.8.0" + }, + "semver-2.8.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "d667fb136f44588d466f6c7929d198c0", + "name": "semver", + "sha256": "1eb2bb6eb5301f310963abfdbc59c34fa45bfca260a0b67539785e01a8f32d0e", + "size": 11095, + "subdir": "linux-64", + "timestamp": 1526937633433, + "version": "2.8.0" + }, + "semver-2.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "c5ff070b5a159953c47b0921b1b0979b", + "name": "semver", + "sha256": "b65974fedb20c28a7356c6e4a3443ab997b6ef7b802cf00275c497b1a03489e2", + "size": 11020, + "subdir": "linux-64", + "timestamp": 1526937602725, + "version": "2.8.0" + }, + "semver-2.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "decf727b0172f26b154a94fe08f1d30a", + "name": "semver", + "sha256": "4a0a78b76854f65d42083c5905c96a1798d1db2a683487909e265ff94c363a71", + "size": 11059, + "subdir": "linux-64", + "timestamp": 1530961004896, + "version": "2.8.0" + }, + "semver-2.8.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "d4eba88dc8e1efb852d241bea0410cbb", + "name": "semver", + "sha256": "74532837ea568fe77730c5c61546bd0e2ab0688383e56c7a0706225d12b4cbaf", + "size": 11661, + "subdir": "linux-64", + "timestamp": 1535508682869, + "version": "2.8.1" + }, + "semver-2.8.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "48e4e443593145b0aa5973f1f4927246", + "name": "semver", + "sha256": "e514a79a68b0a65843e2182a6752efc49dbb30edd16bcece561f2cef92eb5b34", + "size": 11975, + "subdir": "linux-64", + "timestamp": 1535508810960, + "version": "2.8.1" + }, + "semver-2.8.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "38eb60d556a8e11112c894e541ba860a", + "name": "semver", + "sha256": "64ea7c024d54fd2a112e4dddc473dcee15630e289d443486d514323aff620c1d", + "size": 11797, + "subdir": "linux-64", + "timestamp": 1535508741256, + "version": "2.8.1" + }, + "semver-2.8.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "dbea47159eec919fc635e1ae2b651326", + "name": "semver", + "sha256": "9192472c05f45c424055f0fb3e2c196c30dbb7bc85cc778c8cc1308f7c4373c8", + "size": 11838, + "subdir": "linux-64", + "timestamp": 1535508822121, + "version": "2.8.1" + }, + "send2trash-1.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d770fb231be805493903f4922a0af4e2", + "name": "send2trash", + "sha256": "ee59859f18d873d42194ad6a8bba80458f9c62f1b4dfc25b0818eb8c6b013e7f", + "size": 15267, + "subdir": "linux-64", + "timestamp": 1516378680161, + "version": "1.4.2" + }, + "send2trash-1.4.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fc954808b501e695ed0e156f750187ec", + "name": "send2trash", + "sha256": "ba54ed53d982350eb145da568e9e4cde2d60495fe71e7e2b493cdf464c84ad75", + "size": 15305, + "subdir": "linux-64", + "timestamp": 1516378701364, + "version": "1.4.2" + }, + "send2trash-1.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "544778c551478db86a6ff88f17561958", + "name": "send2trash", + "sha256": "87513e446b1cddb83a454e677e9e8647cf924a855c5c6e4860ff0fc058ce26db", + "size": 15179, + "subdir": "linux-64", + "timestamp": 1516378759342, + "version": "1.4.2" + }, + "send2trash-1.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "69530da6856992bb2b7891be77e53292", + "name": "send2trash", + "sha256": "8c61ebb3ce3a66675b37ab289a70e15ae1fcf28cf43604ce115fb20a474bfafc", + "size": 16784, + "subdir": "linux-64", + "timestamp": 1519146799026, + "version": "1.5.0" + }, + "send2trash-1.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fb99e83ae7b922ba47346c709faa2db8", + "name": "send2trash", + "sha256": "d9ca640a30f2d95d7f162bbe1285ab164bc447eb5b2dd00ed2da92266454f0de", + "size": 16774, + "subdir": "linux-64", + "timestamp": 1519146807677, + "version": "1.5.0" + }, + "send2trash-1.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "38061df1f4dc381013539f6580cc62b4", + "name": "send2trash", + "sha256": "074525f4240655c08e544cce2786df1e8e03cbe585044ec18ae63e0fc93ef95b", + "size": 16614, + "subdir": "linux-64", + "timestamp": 1519146845083, + "version": "1.5.0" + }, + "send2trash-1.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fd80940ee7254cd0144d2d9ff9c12baa", + "name": "send2trash", + "sha256": "70305f0657e8747fce28bce6c4c021767c6f4da3f8d27bb7396856330dc4a487", + "size": 16622, + "subdir": "linux-64", + "timestamp": 1530734626903, + "version": "1.5.0" + }, + "send2trash-1.5.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5ffaadbd3a68593a34f76617fc3fe17f", + "name": "send2trash", + "sha256": "e9f9788d892862557bf995338886c5dccebbd99d308253ddc0a8c824de3eadce", + "size": 17807, + "subdir": "linux-64", + "timestamp": 1573200396559, + "version": "1.5.0" + }, + "sentencepiece-0.1.95-py310hd09550d_0.conda": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6b98678138daae9737cd891b3756c16b", + "name": "sentencepiece", + "sha256": "c01cb9cfc6ba9aa30f1ceadb66e2ccee103b613ffef15217d8ed1d58c7b87eb0", + "size": 2845525, + "subdir": "linux-64", + "timestamp": 1640794599235, + "version": "0.1.95" + }, + "sentencepiece-0.1.95-py311hdb19cb5_0.conda": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ba1eda76a95defecc2b2dcd61fc0d7a4", + "name": "sentencepiece", + "sha256": "fa4625c9e0d06604ff4262c485f8bd87e908a7be96bb7e29e71156e4aa7a4b48", + "size": 3371255, + "subdir": "linux-64", + "timestamp": 1676862110603, + "version": "0.1.95" + }, + "sentencepiece-0.1.95-py37hd09550d_0.conda": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2bb9c6b8172be668b31aa06bd087c535", + "name": "sentencepiece", + "sha256": "6633a9aebf9062a56e9cd36194f8b7164df6480232e5e84d318334cbe1bba745", + "size": 2676172, + "subdir": "linux-64", + "timestamp": 1635181253483, + "version": "0.1.95" + }, + "sentencepiece-0.1.95-py38hd09550d_0.conda": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b514e8dec5299e6ccdfd61c14c1a274b", + "name": "sentencepiece", + "sha256": "0c8790721cc275d2395192136ada299f12a573e319108ff540c24ca03a7f7ebc", + "size": 2739068, + "subdir": "linux-64", + "timestamp": 1635169662536, + "version": "0.1.95" + }, + "sentencepiece-0.1.95-py39hd09550d_0.conda": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "54d65074e36f5e0f66fdbc28b6924800", + "name": "sentencepiece", + "sha256": "6e3fae5b9153c5ae91a4b7778dc74a460b0af6ea5456889002aa4ff0a294eaa2", + "size": 2693190, + "subdir": "linux-64", + "timestamp": 1635181246668, + "version": "0.1.95" + }, + "sentry-sdk-1.9.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.10,<3.11.0a0", + "urllib3 >=1.10" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "db5b3f206a12da4ab2d152aef22e60c7", + "name": "sentry-sdk", + "sha256": "fa0623d9540ded168be4055aa63176e50a30433ea376a343ff2b91e37af137ac", + "size": 216933, + "subdir": "linux-64", + "timestamp": 1659784625912, + "version": "1.9.0" + }, + "sentry-sdk-1.9.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.11,<3.12.0a0", + "urllib3 >=1.10" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b86fffc23ec64dc4735e2f8c36865400", + "name": "sentry-sdk", + "sha256": "632cd7b5f03b8067d39b57b2aa6bf802a04834028f7bab3661a9385a7ca6fbbe", + "size": 293830, + "subdir": "linux-64", + "timestamp": 1676862135483, + "version": "1.9.0" + }, + "sentry-sdk-1.9.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.7,<3.8.0a0", + "urllib3 >=1.10" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "98bac7b4469bfe2a645649663cb494c6", + "name": "sentry-sdk", + "sha256": "211468a1408f0bf5a0b0ba3dfecf12c7dd965380a3bbf53453c59d5599d2c5f9", + "size": 212317, + "subdir": "linux-64", + "timestamp": 1659784654720, + "version": "1.9.0" + }, + "sentry-sdk-1.9.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.8,<3.9.0a0", + "urllib3 >=1.10" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "09b11914dedc20d6c0d43801a335c131", + "name": "sentry-sdk", + "sha256": "faead086393f757336e895dc1b230c69bb75ef593e963b8ef39fe3d1ad62b8d7", + "size": 213376, + "subdir": "linux-64", + "timestamp": 1659784683453, + "version": "1.9.0" + }, + "sentry-sdk-1.9.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.9,<3.10.0a0", + "urllib3 >=1.10" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "f7ce80baf3493310c1bfa57e3015b0f4", + "name": "sentry-sdk", + "sha256": "9a7edaf44ead0f98d355fc23ff9be14fd32826470a4228838e43dcb498ee5753", + "size": 214494, + "subdir": "linux-64", + "timestamp": 1659784583793, + "version": "1.9.0" + }, + "serf-1.3.9-h1c830df_0.conda": { + "build": "h1c830df_0", + "build_number": 0, + "depends": [ + "apr >=1.6.3,<2.0a0", + "expat >=2.2.6,<3.0a0", + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "8a1891d5d5519b6b23d1748c9b9971e5", + "name": "serf", + "sha256": "e00627720636cdb7a9073bc6aee262da7c43df9104ff847567d108a2c5bbbbc7", + "size": 91665, + "subdir": "linux-64", + "timestamp": 1540387751933, + "version": "1.3.9" + }, + "serf-1.3.9-ha066f01_0.conda": { + "build": "ha066f01_0", + "build_number": 0, + "depends": [ + "apr >=1.6.3,<2.0a0", + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "a7b017174dbff1cc5bdaa6bec542a6b6", + "name": "serf", + "sha256": "8ca64296604d17324c53bb5b7efbbb657d3cc04d0fbf6aafb33022ca43e487f3", + "size": 388222, + "subdir": "linux-64", + "timestamp": 1631803150008, + "version": "1.3.9" + }, + "serf-1.3.9-hb3b5fc1_0.conda": { + "build": "hb3b5fc1_0", + "build_number": 0, + "depends": [ + "apr >=1.6.3,<2.0a0", + "expat >=2.2.5,<3.0a0", + "libgcc-ng >=7.2.0", + "openssl >=1.0.2n,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache License 2.0", + "license_family": "Apache", + "md5": "b978e9cc1793e973fcd4cadc9893ebd5", + "name": "serf", + "sha256": "95b17dbd99e9e86a9fc42293f3bf0ac1a7acec1f1b1199f554d9d88b69cd7bf8", + "size": 89129, + "subdir": "linux-64", + "timestamp": 1513186030045, + "version": "1.3.9" + }, + "serverfiles-0.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "98b9beb2685d9f33822ce6de234afcd9", + "name": "serverfiles", + "sha256": "12763062bf105c0a3ab1158a4eb0192fedc9a2f98bbd9c7a16dd4ef2ee1307c7", + "size": 15254, + "subdir": "linux-64", + "timestamp": 1530902505940, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py27hb306768_0.conda": { + "build": "py27hb306768_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "a5951ce4871b29dded761d14a8befd44", + "name": "serverfiles", + "sha256": "8052a85fd76defdefe6580a263cdebf940ef701022d4aec4fb71d8812798f641", + "size": 15509, + "subdir": "linux-64", + "timestamp": 1509226997442, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "efe17f3ca3d464be7167c204736d1f85", + "name": "serverfiles", + "sha256": "621f91e1f9b40e3935db1705e9dc3d8ad486b4c65d24b173dc3ae7adc619087e", + "size": 15773, + "subdir": "linux-64", + "timestamp": 1640794623379, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "64c8684c168408463cba9f9eb05b5fe7", + "name": "serverfiles", + "sha256": "a2c538e2229f48c12a5e6736bf626276f5951666845a3e67d01b2e093877ffd9", + "size": 20465, + "subdir": "linux-64", + "timestamp": 1676862149846, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py35h616d9ea_0.conda": { + "build": "py35h616d9ea_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "49afd7425a00ddc2c5faa65f7ef4ec48", + "name": "serverfiles", + "sha256": "71ab78204f60c44e5534813f73c7524d7e4a6fbbdefad1367c41b46d489deb56", + "size": 15835, + "subdir": "linux-64", + "timestamp": 1509226997031, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "30f94ef419ccf4363161468d82bbaea0", + "name": "serverfiles", + "sha256": "e466426bbba5c9de0d451848ca903fa056a97c92ac08df51f9d1424a9da084e4", + "size": 15414, + "subdir": "linux-64", + "timestamp": 1530902478374, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "773b3976ad74834726288b25858898d7", + "name": "serverfiles", + "sha256": "e182333cab2b4664adaf2d3e04f15b04a5e2b814bcd1d1d463b0f6daee4a6ad2", + "size": 16028, + "subdir": "linux-64", + "timestamp": 1632829164564, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py36h79d4018_0.conda": { + "build": "py36h79d4018_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "df501afd7bd1a5c83088f3f481c463ec", + "name": "serverfiles", + "sha256": "eba49b5cc6d71056da23c6ee8a9ccb6833b6f0247d1c70fa2e6143dfb03898bd", + "size": 15747, + "subdir": "linux-64", + "timestamp": 1509226998187, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "ae508c9bb7ac57f898c6c3989e813c0c", + "name": "serverfiles", + "sha256": "cd9947bca990ab786104573b15ab9641ff0d5b49164d6d9c523922c5f955da89", + "size": 15416, + "subdir": "linux-64", + "timestamp": 1530902449443, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "be2dbd30fe696a11080e71678c2cef02", + "name": "serverfiles", + "sha256": "b68f5606609e0f9cfc1f5617d8992ce3995f4ba251a74f1ee7ee69e624828065", + "size": 15979, + "subdir": "linux-64", + "timestamp": 1632838818180, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "f04a656f084e2d221c064d52b953cb82", + "name": "serverfiles", + "sha256": "3dd41939cf375707f995e85fb499c42f8933d01d02aacf01dd520d78857c4025", + "size": 15940, + "subdir": "linux-64", + "timestamp": 1574237417834, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "5a65493a5ef8a79cd7dec982110c3651", + "name": "serverfiles", + "sha256": "a459740164d7b608f10c5183bbf58e113a31a2afbcdf56c3c8467053ec999e9d", + "size": 16110, + "subdir": "linux-64", + "timestamp": 1632839542130, + "version": "0.2.1" + }, + "serverfiles-0.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "5a002264cc428cdc3ce2c84d0ac9ec83", + "name": "serverfiles", + "sha256": "c470640ad794e8dfdea4f690690b726f7aea68c0f1afca9475da2e039153efc3", + "size": 16147, + "subdir": "linux-64", + "timestamp": 1632839543777, + "version": "0.2.1" + }, + "serverfiles-0.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "778befef7d75a1851d4a8d2bd441bd8b", + "name": "serverfiles", + "sha256": "bbe379adfb282f59eaaec4eeefc8db766441eafff8459791b199496008e574e9", + "size": 15679, + "subdir": "linux-64", + "timestamp": 1545124347538, + "version": "0.3.0" + }, + "serverfiles-0.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "49d499decb695bae530740f85d78b864", + "name": "serverfiles", + "sha256": "edf1dae49b427feb47287f427fae17486812751fed113fc53f56790c0cd1baa8", + "size": 15817, + "subdir": "linux-64", + "timestamp": 1545124409226, + "version": "0.3.0" + }, + "serverfiles-0.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "be2e653081cde4feba2b3322bd8a9fa7", + "name": "serverfiles", + "sha256": "c3ca429b81c5e2e5570a5ee05c5d386cc25feccf916af1765cfddf7b90bda19e", + "size": 15792, + "subdir": "linux-64", + "timestamp": 1545124388389, + "version": "0.3.0" + }, + "serverfiles-0.3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "434fc1f1dee42c33d3db78f4d9b25532", + "name": "serverfiles", + "sha256": "e33d3cc30918287dc4b7ed3c36cf8e96153f22fc4ca5dc2746a2176b0b3c565d", + "size": 16241, + "subdir": "linux-64", + "timestamp": 1596700983108, + "version": "0.3.0" + }, + "serverfiles-0.3.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "a4b08a6432404862bbc9a28781322666", + "name": "serverfiles", + "sha256": "7bfb2d6a0ba524b2a98fc70ce08275e7e6b69f201372ce2a785eb19f34e4c64e", + "size": 15951, + "subdir": "linux-64", + "timestamp": 1611344892867, + "version": "0.3.1" + }, + "serverfiles-0.3.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "2ea9a9450d41c5fa6bbee3b312047ff9", + "name": "serverfiles", + "sha256": "f69dfc44b8daa7fb3f3e6b9c25601b460bf5a4706696699da5c370070be983df", + "size": 15920, + "subdir": "linux-64", + "timestamp": 1611344875775, + "version": "0.3.1" + }, + "serverfiles-0.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "b6ac9203a76daa2c91b1f00a844cce28", + "name": "serverfiles", + "sha256": "836030fba43ccab17bf5ce5b26182c4e1737a885dea9a7b337c528c7929eafdb", + "size": 15933, + "subdir": "linux-64", + "timestamp": 1611344886688, + "version": "0.3.1" + }, + "serverfiles-0.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.11.1" + ], + "license": "GPL-3", + "license_family": "GPL", + "md5": "a16b09a51dc4e2ef193ebe22db02ae99", + "name": "serverfiles", + "sha256": "56dfe6de4c5898a672912b9a429d92b1295aad311aa64f24c199fc4f6b13efc9", + "size": 15997, + "subdir": "linux-64", + "timestamp": 1611344877689, + "version": "0.3.1" + }, + "service_identity-17.0.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "pyasn1", + "pyasn1-modules", + "pyopenssl >=0.12", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "99fbe999ccd7b4414f761dc25346b240", + "name": "service_identity", + "sha256": "f050fbfda4d9fbdf1002cda08112f8c5b29f3fc3b6defd507a1760134788ee57", + "size": 18520, + "subdir": "linux-64", + "timestamp": 1530919658746, + "version": "17.0.0" + }, + "service_identity-17.0.0-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "pyasn1", + "pyasn1-modules", + "pyopenssl >=0.12", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea617d52b9bf373852657b27b56c5264", + "name": "service_identity", + "sha256": "3ce373790f1b541a74957726cabfb3474b2ab5ee5e883e63a5d152c328bc9ced", + "size": 18660, + "subdir": "linux-64", + "timestamp": 1534351123401, + "version": "17.0.0" + }, + "service_identity-17.0.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "pyasn1", + "pyasn1-modules", + "pyopenssl >=0.12", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f299d56534e26f15b12f56e175d2e9b", + "name": "service_identity", + "sha256": "027541bfaf1aa6aa4cb5a5e894c209d069205ba49620231d0ffb303cca28b456", + "size": 18804, + "subdir": "linux-64", + "timestamp": 1530919597863, + "version": "17.0.0" + }, + "service_identity-17.0.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "pyasn1", + "pyasn1-modules", + "pyopenssl >=0.12", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f2e6fd4c0f4c930ea5701272c21edb0", + "name": "service_identity", + "sha256": "5139cbe9844990f491667a15eb6f6d10b89619dccfc97c11acaf6070835e2369", + "size": 18773, + "subdir": "linux-64", + "timestamp": 1530919628643, + "version": "17.0.0" + }, + "service_identity-18.1.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "cryptography", + "ipaddress", + "pyasn1", + "pyasn1-modules", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e23e5f2a5a886f0f295b3dc71f3ea65e", + "name": "service_identity", + "sha256": "ddeb88460cc110070c004fa5b66f6c17832eb385f95da9034bfe63d0dcee36f0", + "size": 20394, + "subdir": "linux-64", + "timestamp": 1545105300765, + "version": "18.1.0" + }, + "service_identity-18.1.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "cryptography", + "pyasn1", + "pyasn1-modules", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c4f9400d4252581243112f2bd9ca90f", + "name": "service_identity", + "sha256": "e56b132a8067251d639fbab2d3f66f0da30787f4a42bcd26244ed020ef6aa929", + "size": 20544, + "subdir": "linux-64", + "timestamp": 1545105324139, + "version": "18.1.0" + }, + "service_identity-18.1.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "attrs >=16.0.0", + "cryptography", + "pyasn1", + "pyasn1-modules", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "05ee00ab1e68ab8afdfa7cd9c085f7a9", + "name": "service_identity", + "sha256": "97c2d18d2a7896aee8e99af099f63771bd5008a7e05773ee52ecda81dd493699", + "size": 20471, + "subdir": "linux-64", + "timestamp": 1545105324968, + "version": "18.1.0" + }, + "setproctitle-1.1.10-py27h7b6447c_1001.conda": { + "build": "py27h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "cc24947906f55f902c1f46d119fcb328", + "name": "setproctitle", + "sha256": "28a8723d911806948f0c450d69852d91ff587ce51f510e0cacdbe7d120e3340d", + "size": 17040, + "subdir": "linux-64", + "timestamp": 1579609786682, + "version": "1.1.10" + }, + "setproctitle-1.1.10-py36h7b6447c_1001.conda": { + "build": "py36h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "49b3bbaf65f02d6f39862d5204f31810", + "name": "setproctitle", + "sha256": "9f35bbc4e0e23e2ce7180543e8b833fb1694080ff91ccebdd0221dc230be1a67", + "size": 17268, + "subdir": "linux-64", + "timestamp": 1579609683224, + "version": "1.1.10" + }, + "setproctitle-1.1.10-py37h7b6447c_1001.conda": { + "build": "py37h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2cad655e7d66c088451b9ca483e1d8c2", + "name": "setproctitle", + "sha256": "7d82d82e5b3230f7202229b698a964704794d240269cb058f6b2395dced26119", + "size": 17171, + "subdir": "linux-64", + "timestamp": 1579609803973, + "version": "1.1.10" + }, + "setproctitle-1.1.10-py38h7b6447c_1001.conda": { + "build": "py38h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c7ccda64a4398d82a248f61c61d76fb4", + "name": "setproctitle", + "sha256": "0715ce557ea93ada66065a263bbbc0e13cbd5cee4c19874071ec5171c3255472", + "size": 17565, + "subdir": "linux-64", + "timestamp": 1579609813106, + "version": "1.1.10" + }, + "setproctitle-1.1.10-py39h7f8727e_1001.conda": { + "build": "py39h7f8727e_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9f800d66d71ac755589ff7396caa937e", + "name": "setproctitle", + "sha256": "d0e1db68221fa08b4d239e69b02a731b809cd18945d4d99d6ccbe53774398bcd", + "size": 17376, + "subdir": "linux-64", + "timestamp": 1626467259393, + "version": "1.1.10" + }, + "setproctitle-1.2.2-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7d44ecd8c47b2c89bab98b60fe365a40", + "name": "setproctitle", + "sha256": "b0c0e29946fbd227cea982e2baf416e879badf4744094c9ade8528ef0c2f2014", + "size": 37078, + "subdir": "linux-64", + "timestamp": 1640794647775, + "version": "1.2.2" + }, + "setproctitle-1.2.2-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ce308b5955818a3af846afc0ce9f17ee", + "name": "setproctitle", + "sha256": "e2923a75e27fe6c446f1f763d1b6a2fd64d0e28b24e07791fda25324fd001d60", + "size": 16707, + "subdir": "linux-64", + "timestamp": 1676838805411, + "version": "1.2.2" + }, + "setproctitle-1.2.2-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "636518df3ee5a4af63f936f28b4bb0f0", + "name": "setproctitle", + "sha256": "7bda009cb799bc6a1380b4cd1c46f1b6ecec81b0fc9f5e4f22c3039997b9d36d", + "size": 16355, + "subdir": "linux-64", + "timestamp": 1611599935088, + "version": "1.2.2" + }, + "setproctitle-1.2.2-py36h27cfd23_1004.conda": { + "build": "py36h27cfd23_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "895df5a41caa0fb94aa44d8c7a08c4f4", + "name": "setproctitle", + "sha256": "629d3bab7edd6a78d94a24b462dc87b214de66bd68870313de5c53f469dcc655", + "size": 16360, + "subdir": "linux-64", + "timestamp": 1611517605869, + "version": "1.2.2" + }, + "setproctitle-1.2.2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "af2cdfab942ae0e08d032456a0750c71", + "name": "setproctitle", + "sha256": "9e26e52a58c45c8d4e67e04fda64d080ed7054b1e9adb5c395a1d8c61d2f89c2", + "size": 16319, + "subdir": "linux-64", + "timestamp": 1611599964185, + "version": "1.2.2" + }, + "setproctitle-1.2.2-py37h27cfd23_1004.conda": { + "build": "py37h27cfd23_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c561c27cf54cab2662a38d95b2929e76", + "name": "setproctitle", + "sha256": "964cebf8934e61d9087b3c699e9354b30b9d9dccb4e3e2c660611bb93a8a1492", + "size": 16625, + "subdir": "linux-64", + "timestamp": 1611517603046, + "version": "1.2.2" + }, + "setproctitle-1.2.2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c3ad50e6af04c2a64ce28b74882bef73", + "name": "setproctitle", + "sha256": "c46869501eae9d9d828c975f63b4cbc8249f5ef9f157952023b23b4c6aaf3b8b", + "size": 16514, + "subdir": "linux-64", + "timestamp": 1611599962239, + "version": "1.2.2" + }, + "setproctitle-1.2.2-py38h27cfd23_1004.conda": { + "build": "py38h27cfd23_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c29c3a4375d50519c559332f6afaee37", + "name": "setproctitle", + "sha256": "5fb709f082e75a089cfa1587506e76f821ca1165fa69be271d776b0d298bd496", + "size": 16527, + "subdir": "linux-64", + "timestamp": 1611517605173, + "version": "1.2.2" + }, + "setproctitle-1.2.2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1cbd3b6fff4a78557fcf017dfe247c2f", + "name": "setproctitle", + "sha256": "7c6bb332b5ca3b241883e8be1392984159e6c47f699fb903a81b53249f184069", + "size": 16442, + "subdir": "linux-64", + "timestamp": 1611599925694, + "version": "1.2.2" + }, + "setproctitle-1.2.2-py39h27cfd23_1004.conda": { + "build": "py39h27cfd23_1004", + "build_number": 1004, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "42f1e20e0591ca72eaa1b35d45209ef1", + "name": "setproctitle", + "sha256": "8fb210894e6c634f67290b1f0345049404ce898bde19ab784bcd8745e4ee405b", + "size": 16781, + "subdir": "linux-64", + "timestamp": 1611517581520, + "version": "1.2.2" + }, + "setuptools-36.5.0-py27h68b189e_0.conda": { + "build": "py27h68b189e_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "42a3b27a7db05468e55cbeb70ee87df3", + "name": "setuptools", + "sha256": "9cc13b943d2566654ed834959881d338b91c279d91e75e9dfd6e9fa952857ddd", + "size": 475053, + "subdir": "linux-64", + "timestamp": 1505957364946, + "version": "36.5.0" + }, + "setuptools-36.5.0-py35ha8c1747_0.conda": { + "build": "py35ha8c1747_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "142ca26fdd22ac73063d091623b7573f", + "name": "setuptools", + "sha256": "29c51c35717d1bcebca92814899f895f834eeba46db53937e79fe4fa2b6bddf2", + "size": 474053, + "subdir": "linux-64", + "timestamp": 1505957384298, + "version": "36.5.0" + }, + "setuptools-36.5.0-py36he42e2e1_0.conda": { + "build": "py36he42e2e1_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1ee8010987ea27d140f0d1a8e333301", + "name": "setuptools", + "sha256": "e76e224b3a60f7b24c89ce2b0b1ec963ba17b8aba921530a9ee29a672322dba7", + "size": 477627, + "subdir": "linux-64", + "timestamp": 1505957403818, + "version": "36.5.0" + }, + "setuptools-38.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb2b441c711df90fc0116a00b01e4f26", + "name": "setuptools", + "sha256": "a8e903218b57bb5b7908f3a6d964f2aa1e693dd45036e0736cdd63ba77d0dbc9", + "size": 482762, + "subdir": "linux-64", + "timestamp": 1515791186148, + "version": "38.4.0" + }, + "setuptools-38.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "36bc0063dc7da1e7a02f2b33dab91070", + "name": "setuptools", + "sha256": "40feca8f6b1608492e7c4b6e61ea63fa31ad26e0df9c4466b34b12d2924424ae", + "size": 488195, + "subdir": "linux-64", + "timestamp": 1515791215210, + "version": "38.4.0" + }, + "setuptools-38.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a84e4a69f8a399acc746020d1fa74f3e", + "name": "setuptools", + "sha256": "a22d6c5b0c517ba7e97af1f556e7c939f64f0911f25469fdca0481feb92d2b86", + "size": 492239, + "subdir": "linux-64", + "timestamp": 1515791165259, + "version": "38.4.0" + }, + "setuptools-38.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14155286440d3016c5572d07d973070c", + "name": "setuptools", + "sha256": "ae408e13b6f7c2a9ee17675752f52d2fe5e81af6b0193f3a6721cc1338a0d89b", + "size": 489426, + "subdir": "linux-64", + "timestamp": 1519147905075, + "version": "38.5.1" + }, + "setuptools-38.5.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "adcbe14add43ac0159fc3595c4255a7e", + "name": "setuptools", + "sha256": "e6d28ee7e7bc16800fac967be51ba6dfe84358fa70c1a01b4c5986bd78e1ff46", + "size": 488331, + "subdir": "linux-64", + "timestamp": 1519147859232, + "version": "38.5.1" + }, + "setuptools-38.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ed27265f8f8084a38a332def563db42", + "name": "setuptools", + "sha256": "bd74c4da4537c119c2c6d0c6e19010b2d7862d4fab9d36d93235cec5e30d9988", + "size": 484037, + "subdir": "linux-64", + "timestamp": 1519147922362, + "version": "38.5.1" + }, + "setuptools-39.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1fe144d02e0ce3b3d542a80f88e4b771", + "name": "setuptools", + "sha256": "3b6a6814584f54b7b859cacc288af5adcbac6c46ebd1c9dc17c558faf084c8fe", + "size": 496520, + "subdir": "linux-64", + "timestamp": 1522338171542, + "version": "39.0.1" + }, + "setuptools-39.0.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad28bc9e9dff3a80b9b6bf98081d830b", + "name": "setuptools", + "sha256": "4da165d109c393ff4f54c3a3c03e8d9a9dfa3ac8b78391993ce8065501da03ab", + "size": 498614, + "subdir": "linux-64", + "timestamp": 1522338176081, + "version": "39.0.1" + }, + "setuptools-39.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "202d2a4510d98d2d3d04d2bdd4a6fcfd", + "name": "setuptools", + "sha256": "90340cd4feb6edb003530f8f6de7c2cd23e008bedaf446c5f15b4afbe8076d90", + "size": 493331, + "subdir": "linux-64", + "timestamp": 1522338148760, + "version": "39.0.1" + }, + "setuptools-39.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f791283d54800b7a9d16e9609933c96", + "name": "setuptools", + "sha256": "ca5675facc2eec426074780e798fe1a992c491682a833e93021e12b36ca03cf6", + "size": 496577, + "subdir": "linux-64", + "timestamp": 1525118802038, + "version": "39.1.0" + }, + "setuptools-39.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3d53b690e4cc746dfb2d1f2df67599b", + "name": "setuptools", + "sha256": "31411e91137552150ffbe9c272895517357aaf2de0a423dbd21c20fd909dac9f", + "size": 499142, + "subdir": "linux-64", + "timestamp": 1525118828146, + "version": "39.1.0" + }, + "setuptools-39.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc9195a9482022e425931f1c4b7ebff7", + "name": "setuptools", + "sha256": "d0bb0c41e98c2b2ed42d5e956a32574de7bf06cd53396bcb890f492f42381d87", + "size": 493120, + "subdir": "linux-64", + "timestamp": 1525118829126, + "version": "39.1.0" + }, + "setuptools-39.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4096cc479bbcd77cb2987d68560e1d66", + "name": "setuptools", + "sha256": "b4103b3a38aa3cf6adf52cdcd2b7f8c1122b74a5adc2cc6421ee230666ae0c6d", + "size": 493060, + "subdir": "linux-64", + "timestamp": 1534955777535, + "version": "39.1.0" + }, + "setuptools-39.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "94a7457547ffc3f4e96cf6f75a3a397a", + "name": "setuptools", + "sha256": "fbf585b7b27c2c5edd151c6cee36c28be853f4507ba8c3fb2ebdc51cce1edafd", + "size": 490664, + "subdir": "linux-64", + "timestamp": 1527793493920, + "version": "39.2.0" + }, + "setuptools-39.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebe940cfc46c3c325da181b7d2b7c08f", + "name": "setuptools", + "sha256": "a82c2cfdab6efeb889cf51126360dc1ba15fcb2a81ca4574d951787920412391", + "size": 492170, + "subdir": "linux-64", + "timestamp": 1527793518181, + "version": "39.2.0" + }, + "setuptools-39.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5846e9fec571e22f0510ce15f7126fb6", + "name": "setuptools", + "sha256": "fe38973d7148abcb293f4f5c7a85ba75e8c9b5931086bf12edeb2ca9e071cbf3", + "size": 487635, + "subdir": "linux-64", + "timestamp": 1527793474251, + "version": "39.2.0" + }, + "setuptools-39.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6da9c166f585c927c9421364fe2402f2", + "name": "setuptools", + "sha256": "aa8b69e18e78231626fc960a786306dfabda0f6f467c1e880c75e2a2a3cb8eef", + "size": 487556, + "subdir": "linux-64", + "timestamp": 1530212487933, + "version": "39.2.0" + }, + "setuptools-40.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb4310323b73aef5c7022ffd3bd937ae", + "name": "setuptools", + "sha256": "7d6caada50949fed5344edb14fc5c3c27af456462b78bbdb7c78fc5d620fb6c0", + "size": 490924, + "subdir": "linux-64", + "timestamp": 1532987077156, + "version": "40.0.0" + }, + "setuptools-40.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c6fc19e6b7958c4cf3ccd03ab6b6d197", + "name": "setuptools", + "sha256": "61578d09691d553e3ce3d95b2c6128f87dc254fa50b424ad086d15f17e6a6e9e", + "size": 492492, + "subdir": "linux-64", + "timestamp": 1532987103363, + "version": "40.0.0" + }, + "setuptools-40.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b3a2e55516b2a01e41acd7ee5895d70", + "name": "setuptools", + "sha256": "e50fc3ebfff95c615beeb2ab57cd83e74ccd2fdbce987fff0f98ac87f5abedac", + "size": 487905, + "subdir": "linux-64", + "timestamp": 1532987061652, + "version": "40.0.0" + }, + "setuptools-40.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8084e55ed07738ca696e948721f35cd6", + "name": "setuptools", + "sha256": "9c4d45eea689d232eafaddeb146b44c8610f99561a3afee84ad6ffffc6a76fa4", + "size": 487805, + "subdir": "linux-64", + "timestamp": 1532987108030, + "version": "40.0.0" + }, + "setuptools-40.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0eb8b57d1a865d5520f8a748c134241c", + "name": "setuptools", + "sha256": "a341b4f4b1d49a3615af93b39fbec85cecb23a878f266b6f937695c1ded11509", + "size": 492666, + "subdir": "linux-64", + "timestamp": 1535392051767, + "version": "40.2.0" + }, + "setuptools-40.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c92b00f4ec70dd5ba04862a12bd104d0", + "name": "setuptools", + "sha256": "b0a759e61e806f11ff5fc06dd3d4cf6b0816a148ee9dd36abf7d902e49a7f62f", + "size": 501281, + "subdir": "linux-64", + "timestamp": 1535391599974, + "version": "40.2.0" + }, + "setuptools-40.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e065171aa4c1b22a50db5aa828b615d6", + "name": "setuptools", + "sha256": "3039154364ee5d7d4981fd97201c9825876ed996254503d516b5903bc9576f33", + "size": 489213, + "subdir": "linux-64", + "timestamp": 1535391583771, + "version": "40.2.0" + }, + "setuptools-40.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca86e31008c50783c606167fca97ebb4", + "name": "setuptools", + "sha256": "711dbc70c0e08a28b3970692561f800ecc987aa36145e19f95dd095b5e2844fc", + "size": 489101, + "subdir": "linux-64", + "timestamp": 1535392084778, + "version": "40.2.0" + }, + "setuptools-40.4.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "687f0ff79abf18fcf20708291c9a8c35", + "name": "setuptools", + "sha256": "f7db0edc3669d9b439dd7648211f99019309144927fad74740b829cf827c0d36", + "size": 492698, + "subdir": "linux-64", + "timestamp": 1538579451439, + "version": "40.4.3" + }, + "setuptools-40.4.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e66b2d769f14a24685451422bdc3a283", + "name": "setuptools", + "sha256": "b5eb7f920cf162867e43ac6327b4bfcab179c3abe72247903fcc037f3cbe7baf", + "size": 497767, + "subdir": "linux-64", + "timestamp": 1538579460039, + "version": "40.4.3" + }, + "setuptools-40.4.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f8a72ca1e3b3b4820a9ab582931e1bc", + "name": "setuptools", + "sha256": "37d4c07cd00f8e086fad69fcf38535d170f64afe059e92ca5491d5deab439e44", + "size": 489850, + "subdir": "linux-64", + "timestamp": 1538579510203, + "version": "40.4.3" + }, + "setuptools-40.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc5c38b641f1746c91e2d3da53af41e4", + "name": "setuptools", + "sha256": "869d5c310f8665fdeac8dcbce02e5c33c3ed7ffc01306fa621606eaf308dce76", + "size": 500029, + "subdir": "linux-64", + "timestamp": 1541049267742, + "version": "40.5.0" + }, + "setuptools-40.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc12ff6e3bd4d967682f2c9d2051d644", + "name": "setuptools", + "sha256": "ef61232271aabec786b216646562f91cab7b3e65b67a22444ef570eb70f8ebcc", + "size": 490069, + "subdir": "linux-64", + "timestamp": 1541049265355, + "version": "40.5.0" + }, + "setuptools-40.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8e25d1d0eeb6e5e91cad2fe5ce082d3", + "name": "setuptools", + "sha256": "5800ccba171f65c18eec0ec322051a9fa0e2249c024ec8aea6cbbe831d100053", + "size": 490119, + "subdir": "linux-64", + "timestamp": 1541049254033, + "version": "40.5.0" + }, + "setuptools-40.6.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4284d8f76182fe7c94af738abe510581", + "name": "setuptools", + "sha256": "b04edc497b09e4a48b89424f4f36c7c358325794981dce58e83e12c4e22965f4", + "size": 497565, + "subdir": "linux-64", + "timestamp": 1542394743281, + "version": "40.6.2" + }, + "setuptools-40.6.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "59a1c7cef8e9060294af2209e061d657", + "name": "setuptools", + "sha256": "12e1eb0a17e1970bd37b9df58c9d90f0d5c5e7b204e8aed8ae10ea2c23cafbfe", + "size": 494392, + "subdir": "linux-64", + "timestamp": 1542394753122, + "version": "40.6.2" + }, + "setuptools-40.6.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0af7b585122e991fad8911ba9466e5a7", + "name": "setuptools", + "sha256": "4f0e43f73b2908524684a9a747aefc18732d8fcd3caae4eb694e7764f52a2987", + "size": 494193, + "subdir": "linux-64", + "timestamp": 1542394739111, + "version": "40.6.2" + }, + "setuptools-40.6.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "50741329c6d4f5471f8d2513af9993d8", + "name": "setuptools", + "sha256": "2c9283694670112ff0ccf54282c355aad1f2bcb7496dd15ed3102d026ec54ed4", + "size": 497441, + "subdir": "linux-64", + "timestamp": 1545069686566, + "version": "40.6.3" + }, + "setuptools-40.6.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33b6c430c7cf16754a9714a03b5e5615", + "name": "setuptools", + "sha256": "f672affd631079845197bdf5588f70dc4b863fdb054db94144f9b1e367079af8", + "size": 494344, + "subdir": "linux-64", + "timestamp": 1545069709853, + "version": "40.6.3" + }, + "setuptools-40.6.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1fbbc980520cd300deacb07f045cbc8", + "name": "setuptools", + "sha256": "4f3220089d88c3e78bf06add9fcdfea96fbb1394d9247f1707bc0a06a96611fc", + "size": 502119, + "subdir": "linux-64", + "timestamp": 1545069728450, + "version": "40.6.3" + }, + "setuptools-40.7.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1cc610bab8c80483319b43253074f817", + "name": "setuptools", + "sha256": "5f50857e737de0f481b12bdd0d047a507fa0b64fbc3b037de7cd8af0c73c3434", + "size": 499547, + "subdir": "linux-64", + "timestamp": 1549298261163, + "version": "40.7.3" + }, + "setuptools-40.7.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e26584a4db65e31cbfbae08605a2f365", + "name": "setuptools", + "sha256": "538e64cf05d3d38cb35b1fd172d5ead373764ebbe50b92d06ba507014afe4cd6", + "size": 496657, + "subdir": "linux-64", + "timestamp": 1549298266722, + "version": "40.7.3" + }, + "setuptools-40.7.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce18e32a2ec6df0a0d194008ff7b9e30", + "name": "setuptools", + "sha256": "c10d36c58a893286d46143218d6d6dcb59c8238bff041c17b2f39eb5526a1ee0", + "size": 505334, + "subdir": "linux-64", + "timestamp": 1549298344485, + "version": "40.7.3" + }, + "setuptools-40.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3d7b808ce959118d0cb4bedd212ad79", + "name": "setuptools", + "sha256": "97b7d0efb26159cace3aa0afb0d3e77b54693edad9d5ab0b0ed17a0bb5da1dfd", + "size": 511273, + "subdir": "linux-64", + "timestamp": 1550362270428, + "version": "40.8.0" + }, + "setuptools-40.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "126297baab248dede9a214f3b66c8bc8", + "name": "setuptools", + "sha256": "32d4af9210fc0cd53133e81baf10d820b577e240b250e4766b2eea95717e9f46", + "size": 508311, + "subdir": "linux-64", + "timestamp": 1550362287175, + "version": "40.8.0" + }, + "setuptools-40.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e664e4aeb6a1704875c5d0bb86adbfb2", + "name": "setuptools", + "sha256": "0915eeb0210143600a35ccb414bf030df2bda002335edd29b1ce0f381d5fde92", + "size": 508086, + "subdir": "linux-64", + "timestamp": 1550362226771, + "version": "40.8.0" + }, + "setuptools-41.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f94ce131e3c58e3555c3b21f5e03016", + "name": "setuptools", + "sha256": "e2803b1ebc2929ffd6d04f0ae4aa76185d10722a379b629538658747cbccae5c", + "size": 511695, + "subdir": "linux-64", + "timestamp": 1555084258583, + "version": "41.0.0" + }, + "setuptools-41.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18163384dbb2204e91d671fbe2195e27", + "name": "setuptools", + "sha256": "82bf28bf82775c13b961217affe994cbd62798ea858cd7166955637f452b9971", + "size": 508772, + "subdir": "linux-64", + "timestamp": 1555084373475, + "version": "41.0.0" + }, + "setuptools-41.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1e32389311ab7381327e58ab8b25dab", + "name": "setuptools", + "sha256": "43235ce1d0ee8f4fb0e4e3894bcd11fb3b5c6cd43eb29dfb0876c2475b8aa07d", + "size": 509052, + "subdir": "linux-64", + "timestamp": 1555084364723, + "version": "41.0.0" + }, + "setuptools-41.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "59640487e622dc426e8ee58e4807e061", + "name": "setuptools", + "sha256": "cc3ee3308e8cb0928fc7fe7707ef08b321b098172b27aefb04248217072b6a06", + "size": 519121, + "subdir": "linux-64", + "timestamp": 1556550457755, + "version": "41.0.1" + }, + "setuptools-41.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "705f3a5f98b5226c03f02e944f4a40b0", + "name": "setuptools", + "sha256": "a4c5843983dc83cf68a97f787c196b32f31d825a0cec97e4e64140b8198cfc51", + "size": 517612, + "subdir": "linux-64", + "timestamp": 1556550471822, + "version": "41.0.1" + }, + "setuptools-41.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd242343c60220af9911e65d34725d7d", + "name": "setuptools", + "sha256": "4d370314572e33fba5e74fb2f1c7a93dac4c4d85b19db0e427f7344fb7460503", + "size": 517824, + "subdir": "linux-64", + "timestamp": 1556550435060, + "version": "41.0.1" + }, + "setuptools-41.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be32197d969f71afdf5a7fb295523b2c", + "name": "setuptools", + "sha256": "0dd455b9036e47f96d5f82e026d518dd43f0afd6ab0fa030848795e49cb82cf2", + "size": 519040, + "subdir": "linux-64", + "timestamp": 1569259074776, + "version": "41.2.0" + }, + "setuptools-41.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "206c31fba70c0ec17d505ff0c9f7bc8f", + "name": "setuptools", + "sha256": "b9e1d44202ed88466e6938ff55b4bdd495400101d4bee12377462b2612f82b3f", + "size": 517724, + "subdir": "linux-64", + "timestamp": 1569259077454, + "version": "41.2.0" + }, + "setuptools-41.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d345815c15d2adce15d78929d6f85cc3", + "name": "setuptools", + "sha256": "750d4f0a5d175a65a523afb6a536257ec1f7277a2d3fde43f0705c4b9ad69f0b", + "size": 517867, + "subdir": "linux-64", + "timestamp": 1569259084274, + "version": "41.2.0" + }, + "setuptools-41.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31b13974f5897153f3a43ec7b250f0e8", + "name": "setuptools", + "sha256": "05e585d711b69ec7a0fb44e8394efe804323310e4c86a30e0a935f1469370352", + "size": 525019, + "subdir": "linux-64", + "timestamp": 1570459478731, + "version": "41.4.0" + }, + "setuptools-41.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d17b77ec7c91f1b9a55d0b76da59fba6", + "name": "setuptools", + "sha256": "11e8611b58a050d2a5b009543411f04735d01e81ba01c978df6ef79aef893b40", + "size": 522388, + "subdir": "linux-64", + "timestamp": 1570459504167, + "version": "41.4.0" + }, + "setuptools-41.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c1455fcfb162c18e95053a5b20d6593", + "name": "setuptools", + "sha256": "b466dbf2c32ca5dc4f7ed9e9ce5b460799d4b366a3d4437e9d0abb36fbf29940", + "size": 522505, + "subdir": "linux-64", + "timestamp": 1570459517903, + "version": "41.4.0" + }, + "setuptools-41.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.09", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "871e8439eb8f7856436beb82829c3b8c", + "name": "setuptools", + "sha256": "3c416a9d43c280809f85f3b1574c12b2a57ee48b0884054d746d434349422040", + "size": 524951, + "subdir": "linux-64", + "timestamp": 1571953697213, + "version": "41.4.0" + }, + "setuptools-41.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee3e937f535b408fce18c8153b863552", + "name": "setuptools", + "sha256": "c733457ed4fc0cfdc835bcb082147dd6f6b533d7c3b566cf3575926358302a8a", + "size": 529016, + "subdir": "linux-64", + "timestamp": 1572451092195, + "version": "41.6.0" + }, + "setuptools-41.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e6650bfaeb89f8fc9d0d9ea4e6fea12", + "name": "setuptools", + "sha256": "ca7d339dfabee3b8b6db8d6f4fbe769c1b3914f7a7a14f9ac866af0709d8b7b1", + "size": 526336, + "subdir": "linux-64", + "timestamp": 1572451095063, + "version": "41.6.0" + }, + "setuptools-41.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "830ce614732ae038e3e1ed384512d513", + "name": "setuptools", + "sha256": "b4e59de4882406272349168e254acfe2067427a37c33d4b5693c22e90605343e", + "size": 525984, + "subdir": "linux-64", + "timestamp": 1572451089793, + "version": "41.6.0" + }, + "setuptools-41.6.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a93fd5f8a1e23c2a5d9687c1e13c45c9", + "name": "setuptools", + "sha256": "5c57a56dd4e9eefc3b576900a618b28c6f8e7970e5c2409b169c14c5059d7169", + "size": 528480, + "subdir": "linux-64", + "timestamp": 1572451110150, + "version": "41.6.0" + }, + "setuptools-42.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3f4ce6d3326fc7a6b3bd2a37a570ee9b", + "name": "setuptools", + "sha256": "1a3664b7423ec062055a2af370a165d031d76e06371c55f04506b0424f61cc94", + "size": 532020, + "subdir": "linux-64", + "timestamp": 1574698489664, + "version": "42.0.1" + }, + "setuptools-42.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "753b332f91f976770e9e778c8e10d432", + "name": "setuptools", + "sha256": "c3a843afda6187bf527831fe387c8f1476302478eaea22ae2124a0ab0baf3f5a", + "size": 529902, + "subdir": "linux-64", + "timestamp": 1574698503305, + "version": "42.0.1" + }, + "setuptools-42.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85e709c6c893309e2a0bd8bcd3eb5ef0", + "name": "setuptools", + "sha256": "a6e7486e39e5739f5218ed6000f7e5a1a0f27a58ee741c73be5780a9b11189bf", + "size": 529616, + "subdir": "linux-64", + "timestamp": 1574698486777, + "version": "42.0.1" + }, + "setuptools-42.0.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66cfb15f62e2e527ebe228e2d9e0287f", + "name": "setuptools", + "sha256": "7d6b49a6eed8dca55a232411e8ddbc914781dfa6cff055430f5566160c50bbd4", + "size": 531998, + "subdir": "linux-64", + "timestamp": 1574698502202, + "version": "42.0.1" + }, + "setuptools-42.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e93430843c1fb8ae4d410f14c3db98ed", + "name": "setuptools", + "sha256": "5d76d707c8bd7c226b4ed28be1aded6d31ccba9e960be0445290ecddeb1cc890", + "size": 532720, + "subdir": "linux-64", + "timestamp": 1575390306348, + "version": "42.0.2" + }, + "setuptools-42.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1fe2938484824c6461a64108a917a8ba", + "name": "setuptools", + "sha256": "c0d28dd059afcd83f64324475b7c6e8ae018bc118da89ebeeeb6b3933e0967fb", + "size": 530008, + "subdir": "linux-64", + "timestamp": 1575390319470, + "version": "42.0.2" + }, + "setuptools-42.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "818a00be55fd97d98b610a0b02a958af", + "name": "setuptools", + "sha256": "c180c0f11a66b105b23eb8c4b4b579af2a88e2309474f51d5f94735d99b74c33", + "size": 530143, + "subdir": "linux-64", + "timestamp": 1575390237105, + "version": "42.0.2" + }, + "setuptools-42.0.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "44cc5f6e267d1112b9f6626272e8bc59", + "name": "setuptools", + "sha256": "692a513ca17044d4272100688ea915347b422af5ce04f2e4a76631a7ea734606", + "size": 532600, + "subdir": "linux-64", + "timestamp": 1575390389282, + "version": "42.0.2" + }, + "setuptools-44.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e13744cd21153081b14d57ab174ee572", + "name": "setuptools", + "sha256": "749a01518b03da55fee37d648c77d15463e365be375f48a25e4ac389cf45677e", + "size": 524173, + "subdir": "linux-64", + "timestamp": 1578326214617, + "version": "44.0.0" + }, + "setuptools-44.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f286f2a3745e73154b66ea3464012a4", + "name": "setuptools", + "sha256": "2845a375a2741b6cbd368aca4226fcfdfa074389b377f98d7c759819dbc5e0ab", + "size": 522516, + "subdir": "linux-64", + "timestamp": 1578326203881, + "version": "44.0.0" + }, + "setuptools-44.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aaf296d06c63f62146b7ef0308716571", + "name": "setuptools", + "sha256": "2ed74878e3172c9106b8d14ec522320114324dab7356fec8c42fee8a4db12e07", + "size": 532634, + "subdir": "linux-64", + "timestamp": 1578326219825, + "version": "44.0.0" + }, + "setuptools-44.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4737c7841aeb305d87952011993a4aca", + "name": "setuptools", + "sha256": "64fbc224e1e0f5683b050d2faa1a7c7369a3a467e88e055a02d6e1a4e391e5af", + "size": 534501, + "subdir": "linux-64", + "timestamp": 1578326231060, + "version": "44.0.0" + }, + "setuptools-45.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d0b3c979174008149c3870752d0a9562", + "name": "setuptools", + "sha256": "2f0f2b709f8045f5fa446b1226dfe6d426067174686c92b738a8f76487dee547", + "size": 523419, + "subdir": "linux-64", + "timestamp": 1580148259372, + "version": "45.1.0" + }, + "setuptools-45.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08d2a8f393c538cc83b587c8bc4dc70c", + "name": "setuptools", + "sha256": "070f32de65d15b812d0d824fd890394badca72bf7cc06e573d962bbf08bb01df", + "size": 523374, + "subdir": "linux-64", + "timestamp": 1580148280188, + "version": "45.1.0" + }, + "setuptools-45.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f6bfb9966514e782674147e3deb141f", + "name": "setuptools", + "sha256": "955fdbc828b6b6889ada60c71bf80d87a27b5b2e739b2505178725f8986d5a71", + "size": 534277, + "subdir": "linux-64", + "timestamp": 1580148305308, + "version": "45.1.0" + }, + "setuptools-45.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df473701ce1777d262d147af8caf0cba", + "name": "setuptools", + "sha256": "2569ef8b65fa4fcfc997a22bd48715dc636750e579615ce49b7a378505ddf826", + "size": 532254, + "subdir": "linux-64", + "timestamp": 1581351382956, + "version": "45.2.0" + }, + "setuptools-45.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "167f9e97c2b2d6f701dde06dced6a405", + "name": "setuptools", + "sha256": "242b6738625bb73a8867baa70018586abc360f9117b2d5f5e2d3b6d0961120b0", + "size": 523224, + "subdir": "linux-64", + "timestamp": 1581351356158, + "version": "45.2.0" + }, + "setuptools-45.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e721b69b0a9c142dfe32d750f6d7c417", + "name": "setuptools", + "sha256": "12bd7de50511537f87e5accf0b7cb2d7f33c001ab5abcaabfb00f02ba1c3c2af", + "size": 536078, + "subdir": "linux-64", + "timestamp": 1581351338853, + "version": "45.2.0" + }, + "setuptools-46.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5317f9d558c7c8e3d18bbacbb1e263f2", + "name": "setuptools", + "sha256": "751898d90795ef8b9d30fbef5c8813d10b3d4d236af66249e543226fbbb82443", + "size": 531459, + "subdir": "linux-64", + "timestamp": 1583787623845, + "version": "46.0.0" + }, + "setuptools-46.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db758eabe59cb096d5f186a70b9cfd6c", + "name": "setuptools", + "sha256": "b4162a0e2d79dfe3d1011b2fabecc6ebb4480506fefbf97f44270eef96755897", + "size": 522257, + "subdir": "linux-64", + "timestamp": 1583787643307, + "version": "46.0.0" + }, + "setuptools-46.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f1376b0bf5b9d205091cdf36d32638d", + "name": "setuptools", + "sha256": "3b9de414e24122495f55d27d77ec96991fc697dbb86c901b244c630e1dab1c22", + "size": 534790, + "subdir": "linux-64", + "timestamp": 1583787646819, + "version": "46.0.0" + }, + "setuptools-46.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2951de59936a966462fb26fa9c539645", + "name": "setuptools", + "sha256": "bce30978fca80a748a104b2cbb1a0ff1ab041f1995208b42240ae52e696e354d", + "size": 522777, + "subdir": "linux-64", + "timestamp": 1584975638013, + "version": "46.1.1" + }, + "setuptools-46.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ac3fe5ccd4c23345f5e065e7de578329", + "name": "setuptools", + "sha256": "fe1f1c49fb10142104bd9a95ced89f91d973ab93619cf2dd9a991025d07fe264", + "size": 524749, + "subdir": "linux-64", + "timestamp": 1584975601264, + "version": "46.1.1" + }, + "setuptools-46.1.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c60235faad0aeee367beac2466a89585", + "name": "setuptools", + "sha256": "fce0e92fd13c543376fe63528a85d661c7cbad41893aba3fb43dc9689326c0f2", + "size": 524941, + "subdir": "linux-64", + "timestamp": 1584975626711, + "version": "46.1.1" + }, + "setuptools-46.1.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7810d46f6d96fdb83cec479a198c1312", + "name": "setuptools", + "sha256": "5f92d060139a667de4af2241e5876bee8b88a1a60bb5ac094b99508ba979ddb8", + "size": 525014, + "subdir": "linux-64", + "timestamp": 1585585310849, + "version": "46.1.3" + }, + "setuptools-46.1.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a5fc750efc57333a48ebc4b42e771715", + "name": "setuptools", + "sha256": "57a1c0ad91974ce0ff9905aeb09f0f96af27bd46b495ee9b05af970dd5c14b16", + "size": 533330, + "subdir": "linux-64", + "timestamp": 1585584428629, + "version": "46.1.3" + }, + "setuptools-46.1.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6dd809961c45647e4de4bd40e523f298", + "name": "setuptools", + "sha256": "8bbd8729471b918ac6dd1ca27c150f122ee230f1a71994912cc951c6201459ec", + "size": 535706, + "subdir": "linux-64", + "timestamp": 1585585315568, + "version": "46.1.3" + }, + "setuptools-46.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab33e91f32d165ec036e9e3daca86b9d", + "name": "setuptools", + "sha256": "53b820f04474c31542b92fe5b7d5a267951cad7cb2a92afc8c7db1acefeb203d", + "size": 532608, + "subdir": "linux-64", + "timestamp": 1589214143715, + "version": "46.2.0" + }, + "setuptools-46.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "856e760b8695bab8cc2f267c4a9dfcb6", + "name": "setuptools", + "sha256": "7a7b579d757e4d745a1e94072752d87f319137080f7821d9f3db60139a1f690b", + "size": 525273, + "subdir": "linux-64", + "timestamp": 1589214140866, + "version": "46.2.0" + }, + "setuptools-46.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9fd4567e63a0bae62a644ee426f311b4", + "name": "setuptools", + "sha256": "34648729a2ab4fa3a7fe16468ae7444e112331628edce2f83c51c6952bb6e13d", + "size": 525653, + "subdir": "linux-64", + "timestamp": 1589214182646, + "version": "46.2.0" + }, + "setuptools-46.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2eac211da362ceb1764bf14041503b2c", + "name": "setuptools", + "sha256": "7f8f9acf52ba92c041953d1b1fb89ae0b62e4292cf346e63399b48778f4ec5b7", + "size": 534632, + "subdir": "linux-64", + "timestamp": 1589822052556, + "version": "46.4.0" + }, + "setuptools-46.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d9bb2234298146bd86f5abffa617543", + "name": "setuptools", + "sha256": "b1760ef34c1c384e2c044adcefe1914ddc1c993a83fabf72286b2e5ead5567c0", + "size": 526549, + "subdir": "linux-64", + "timestamp": 1589822077802, + "version": "46.4.0" + }, + "setuptools-46.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a707839c337a17feedd30218e105b1e4", + "name": "setuptools", + "sha256": "03d2651e3a5324d94646938b371ef34c2aed7b708869b1d8b877b6b3d889c420", + "size": 527227, + "subdir": "linux-64", + "timestamp": 1589822068892, + "version": "46.4.0" + }, + "setuptools-47.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb5c5b5c84d857c3599cdcbd5f138233", + "name": "setuptools", + "sha256": "fbf8c8e17d4d73500c3f4513ad597b7baba16705d03ef842dab3bc645ed738b0", + "size": 526331, + "subdir": "linux-64", + "timestamp": 1591295691196, + "version": "47.1.1" + }, + "setuptools-47.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f80f57b2a7423affad455cc100852c3", + "name": "setuptools", + "sha256": "26dc586464e8861c73121201f1719af4fec4b1f04a9156fae12b12048fe6aa87", + "size": 535085, + "subdir": "linux-64", + "timestamp": 1591295685422, + "version": "47.1.1" + }, + "setuptools-47.1.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8db37d4bd4eba0201ddcd22e914e7d24", + "name": "setuptools", + "sha256": "e2a1da5a8c887566410b21a11cc1f1798016cde2f0253e68c04e7406dde49436", + "size": 529255, + "subdir": "linux-64", + "timestamp": 1591295688613, + "version": "47.1.1" + }, + "setuptools-47.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d5510c336f168ee27f3ad16606bfc0a5", + "name": "setuptools", + "sha256": "c388713be47d64264d599082a97d6f6d5a8942c3d3c1c059e846d583c4845307", + "size": 525181, + "subdir": "linux-64", + "timestamp": 1592319647923, + "version": "47.3.0" + }, + "setuptools-47.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c358ec7d3f13c98d24a6639b0c00f110", + "name": "setuptools", + "sha256": "255887dae5524675e90bd9bdb81550b1d6f9caa14fab642287c8bbbbfda0a928", + "size": 534819, + "subdir": "linux-64", + "timestamp": 1592319622423, + "version": "47.3.0" + }, + "setuptools-47.3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f62f5eb1370ab4dd46696009faf9feb9", + "name": "setuptools", + "sha256": "44ad3a7f1c97800fdd0ab2418fe7fc339e089c65968f66c336742c8f2526cd1c", + "size": 529643, + "subdir": "linux-64", + "timestamp": 1592319648560, + "version": "47.3.0" + }, + "setuptools-47.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ebb79277b102b7ef2b3dc35516ea16b", + "name": "setuptools", + "sha256": "2486e2439eb857f9f17db346347c6b0bf059a2753d6b0b85f0f01782f2708b91", + "size": 526013, + "subdir": "linux-64", + "timestamp": 1592841462394, + "version": "47.3.1" + }, + "setuptools-47.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5d5613b9188e1276a40d117e543f873", + "name": "setuptools", + "sha256": "22f81ebf39c89636be417ddb9f235812e7b16800fb509e635233064bab72f3fc", + "size": 526357, + "subdir": "linux-64", + "timestamp": 1592841505038, + "version": "47.3.1" + }, + "setuptools-47.3.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c6cc6ceb5200d51515ce00d0965f3fe3", + "name": "setuptools", + "sha256": "9bd20de548e69ab686b4e0e762f11404ae34b67a95a7d169e3ba51d6c4f5ecdd", + "size": 527480, + "subdir": "linux-64", + "timestamp": 1592841462324, + "version": "47.3.1" + }, + "setuptools-49.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "73d9456bcb784f3d1ab9ccba753720cb", + "name": "setuptools", + "sha256": "54b902c50bf3cbcc8090600ec39895741626d90284f31f314b54fade46145a45", + "size": 750895, + "subdir": "linux-64", + "timestamp": 1601835816638, + "version": "49.1.0" + }, + "setuptools-49.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "411e1ce6ab14eb487c5e0b98859420c8", + "name": "setuptools", + "sha256": "64b32c3b719a9adcca236ebeca215f1ffc42ad37b4c065dc394b77008a5ebca2", + "size": 746111, + "subdir": "linux-64", + "timestamp": 1594419325502, + "version": "49.1.0" + }, + "setuptools-49.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f913b9fc4c2793049fc168af56feb93e", + "name": "setuptools", + "sha256": "7e32706452e802de669df8d6a444a3c75c666eb650c0561850b10e04b5276cfe", + "size": 754347, + "subdir": "linux-64", + "timestamp": 1601835794430, + "version": "49.1.0" + }, + "setuptools-49.1.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0870a1b7e5116ec55e62833fb37d995d", + "name": "setuptools", + "sha256": "89afe9b3aea467c9f4c291d022b40bf72d81d6749393ae321cb6dda6ff6e8960", + "size": 801518, + "subdir": "linux-64", + "timestamp": 1677521830182, + "version": "49.1.3" + }, + "setuptools-49.1.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b8a7c9e4a5640ba41fb38405b587a5d", + "name": "setuptools", + "sha256": "217d363f4818389e6b3f28518e0a801acc1ddabab7df2bb477d1f834499586da", + "size": 792868, + "subdir": "linux-64", + "timestamp": 1677521880923, + "version": "49.1.3" + }, + "setuptools-49.1.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d08e78c9aa35853259a9319bd3b1f25", + "name": "setuptools", + "sha256": "3678d607021ca2a3ad24e58173443dad1c2c14d42cdaa080fdd3713d87484298", + "size": 795658, + "subdir": "linux-64", + "timestamp": 1677521906991, + "version": "49.1.3" + }, + "setuptools-49.1.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a615f4363ab2161b2b2bbc0fb8519394", + "name": "setuptools", + "sha256": "99f4b66eabbfe47435a3a7cbbeae00e42b099cb0a2a1b2876e6eb3ccf00b3c9a", + "size": 795268, + "subdir": "linux-64", + "timestamp": 1677521855387, + "version": "49.1.3" + }, + "setuptools-49.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e37c208fe49fc2bb7ea076f3fc999648", + "name": "setuptools", + "sha256": "6f6691796ed8edb93e31821ead37ea25f2f328afacb48d9fe1474700f9232522", + "size": 765839, + "subdir": "linux-64", + "timestamp": 1594753701233, + "version": "49.2.0" + }, + "setuptools-49.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22c309884255f930483c7a4120e3024a", + "name": "setuptools", + "sha256": "3d1f31c292ff2f6e9c87843a48f8b9b48e15a8cd51f5f89e073259e5d4bd5dfe", + "size": 761121, + "subdir": "linux-64", + "timestamp": 1594753978524, + "version": "49.2.0" + }, + "setuptools-49.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbb591064aa723529d1e2b728e7f7b59", + "name": "setuptools", + "sha256": "c0f6b5ca373e8cf2a518ddaca460b0d621c3c00a4f6233284b2201e86ccd0a3e", + "size": 754634, + "subdir": "linux-64", + "timestamp": 1594753991493, + "version": "49.2.0" + }, + "setuptools-49.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3877cbff27355e82de9666378f6f69fb", + "name": "setuptools", + "sha256": "ab5e93227c410ac4fd7e0354b8b8a68c69a88c2a6490bfca09a99d17a398df38", + "size": 753637, + "subdir": "linux-64", + "timestamp": 1596809662578, + "version": "49.2.1" + }, + "setuptools-49.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8cecfc55f9119295b2a098a409208f76", + "name": "setuptools", + "sha256": "b03dd4e054ad06e7fc0644b5fa86191307d0ff2809545a5b93b0dc40b599e584", + "size": 760594, + "subdir": "linux-64", + "timestamp": 1596809649875, + "version": "49.2.1" + }, + "setuptools-49.2.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7266fe55121019cd2c3c2f1a94a86aa3", + "name": "setuptools", + "sha256": "d6f6dd1f76ab23b65c03bf88ce4349881133340fdac1aae8afaf3ec4201a8078", + "size": 753301, + "subdir": "linux-64", + "timestamp": 1596809662114, + "version": "49.2.1" + }, + "setuptools-49.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "61c2afe0e2fdf62b75e2f7044e2abc9d", + "name": "setuptools", + "sha256": "bd3166a98b508b74af145c9825cd47ba7933e83e99e4edbeabab17d393fb8dc9", + "size": 754034, + "subdir": "linux-64", + "timestamp": 1601836218380, + "version": "49.3.1" + }, + "setuptools-49.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a3d5f62a53917a787c55d9f7d3424ee", + "name": "setuptools", + "sha256": "751aadce05aff3606c306abed591a7f64c3d6186c3182cf8d9a107d14985f8ca", + "size": 746256, + "subdir": "linux-64", + "timestamp": 1597080840170, + "version": "49.3.1" + }, + "setuptools-49.3.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63595ce218b3d373f100c45bb58a38cb", + "name": "setuptools", + "sha256": "61c75256a011721a0a760249f3adf1f470520c75121c9bb3b2e596467f601170", + "size": 755143, + "subdir": "linux-64", + "timestamp": 1601836251422, + "version": "49.3.1" + }, + "setuptools-49.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c526cfa948520c5a18b0fa7dd64aae2", + "name": "setuptools", + "sha256": "a78e04aa2dc28a28f14a678930cdb07549ab1fc5aa8237f81a91830a76b18c09", + "size": 772717, + "subdir": "linux-64", + "timestamp": 1601836425542, + "version": "49.4.0" + }, + "setuptools-49.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f10a5bf209da23c31eb6269750dc0c14", + "name": "setuptools", + "sha256": "d1eeeb50e7cd61b34a2c6670a3fc45ef9ce306a0a871506d45be3be52a375380", + "size": 744669, + "subdir": "linux-64", + "timestamp": 1597340532535, + "version": "49.4.0" + }, + "setuptools-49.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e3439894ff2714907a382138dcafce82", + "name": "setuptools", + "sha256": "0a74cf021fcd76a1b52682cd0dcf4f2b0baf76d0da1b1cf86c7d2bc00114f967", + "size": 764494, + "subdir": "linux-64", + "timestamp": 1601836409226, + "version": "49.4.0" + }, + "setuptools-49.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b03d2ffd0fa8be5b417a6b6eeeb419f3", + "name": "setuptools", + "sha256": "f34523fc9fe785fdcc2e9065c1657af15e0d729f14efb679670578e9216d5a71", + "size": 774824, + "subdir": "linux-64", + "timestamp": 1597423242432, + "version": "49.6.0" + }, + "setuptools-49.6.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d2796358960878e90d5459d270d33ba", + "name": "setuptools", + "sha256": "0a69b5f6c8b61fff0b0e3830cd85a9346ea2916a6e208211b62b2ab835cdbfae", + "size": 745715, + "subdir": "linux-64", + "timestamp": 1601053517740, + "version": "49.6.0" + }, + "setuptools-49.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49f1d32762e73ff61748865363459ed1", + "name": "setuptools", + "sha256": "80169bfe05afe49b8f39dcd8953f7e3c556a300910ce5b8bc8bb4527f3337035", + "size": 772297, + "subdir": "linux-64", + "timestamp": 1597423218629, + "version": "49.6.0" + }, + "setuptools-49.6.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "505e225a35d450be719f0e1855888afc", + "name": "setuptools", + "sha256": "6a9228330adf4baa8b9ef7c18e6cfe3f8deb3fb373a76460537d7cc9131c5b24", + "size": 746341, + "subdir": "linux-64", + "timestamp": 1601053512842, + "version": "49.6.0" + }, + "setuptools-49.6.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63e562de6af837707e866516aa275b89", + "name": "setuptools", + "sha256": "753f7c75d2174c28842fd218d93a21c4c99b9d3d97cb07c300417af10e587eb7", + "size": 765820, + "subdir": "linux-64", + "timestamp": 1597423237528, + "version": "49.6.0" + }, + "setuptools-49.6.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c9165c654618a182ef14ab9ffdde545", + "name": "setuptools", + "sha256": "a13e685690d5c5014fe2752049f4d57da646b8c9d37f6cc9857c2cc97c970bb5", + "size": 759635, + "subdir": "linux-64", + "timestamp": 1601053518124, + "version": "49.6.0" + }, + "setuptools-50.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a717c3741be0becea72981bc180ffc65", + "name": "setuptools", + "sha256": "698e1f7bc7b138923947532d28fe33ac62d28a8e28df2f9680ee69acd9e95f6f", + "size": 743676, + "subdir": "linux-64", + "timestamp": 1601923339615, + "version": "50.3.0" + }, + "setuptools-50.3.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "397a08e9c455a902ad286562610eea92", + "name": "setuptools", + "sha256": "db5c00cec121a663ba98e2fc81a5db9ac0668637c12af1e268de1464995c3bfb", + "size": 758373, + "subdir": "linux-64", + "timestamp": 1604430396059, + "version": "50.3.0" + }, + "setuptools-50.3.0-py36hb0f4dca_1.conda": { + "build": "py36hb0f4dca_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ac59d36f095bcac5f275f9de07d6371", + "name": "setuptools", + "sha256": "ee9dda41b46c319266f16ec9c5c792792c7b3705485702b97d4352afe90b3e71", + "size": 730218, + "subdir": "linux-64", + "timestamp": 1601999692654, + "version": "50.3.0" + }, + "setuptools-50.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ce1988f2d77f4c717da15549dd7bfbd", + "name": "setuptools", + "sha256": "896c80392e0d8b0d00a989a7aa4163931fc9cd7c8742d7a670727dfd12ab0d77", + "size": 743500, + "subdir": "linux-64", + "timestamp": 1601923379258, + "version": "50.3.0" + }, + "setuptools-50.3.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "89192a8eff2f98d868c04677e6117e4d", + "name": "setuptools", + "sha256": "fbc34fd978ac011876712828eed31d35d03c4b0d2c2f5c19cefc7ec07a5bfd7d", + "size": 756084, + "subdir": "linux-64", + "timestamp": 1604430397881, + "version": "50.3.0" + }, + "setuptools-50.3.0-py37hb0f4dca_1.conda": { + "build": "py37hb0f4dca_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b894fcdc116614453a2230d49c054090", + "name": "setuptools", + "sha256": "69d3a6fc83338aae1e0f9e35cb69450cf52f2d14c3f26d2591dcfbc009f7b740", + "size": 727163, + "subdir": "linux-64", + "timestamp": 1601999673601, + "version": "50.3.0" + }, + "setuptools-50.3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83480d3f423d45f53126e2c5a050fd69", + "name": "setuptools", + "sha256": "9e0d4d1ff7c3da70ced17ad21cc9754a1f14ba19585821a805bd2a5de9372178", + "size": 746898, + "subdir": "linux-64", + "timestamp": 1601923348935, + "version": "50.3.0" + }, + "setuptools-50.3.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d57fe1fd6a1742aa21a757592107bdcf", + "name": "setuptools", + "sha256": "80116b53cf45511024daa7d555447143fd29761be45e8f8cb04bf1ae02cddc53", + "size": 759425, + "subdir": "linux-64", + "timestamp": 1604430379798, + "version": "50.3.0" + }, + "setuptools-50.3.0-py38hb0f4dca_1.conda": { + "build": "py38hb0f4dca_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f68eb8c42ed9d59f9de77a051229ea03", + "name": "setuptools", + "sha256": "f33f5672554fa85eeb3223f927fca1dab820cb6e87caaf52dfad7f186cef9bd3", + "size": 730672, + "subdir": "linux-64", + "timestamp": 1601999690434, + "version": "50.3.0" + }, + "setuptools-50.3.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8b6b73599bb9ae2b2a3f55c72661194", + "name": "setuptools", + "sha256": "56af32804e2e5b2e31f7f363bbe1730194af83b3b3f00197ba2d4011530f2fa5", + "size": 759025, + "subdir": "linux-64", + "timestamp": 1604430385928, + "version": "50.3.0" + }, + "setuptools-50.3.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48bbcbe2a45b7aeabc7b9db4b9feea9c", + "name": "setuptools", + "sha256": "dc9b57479841f466d1b2bc81b40d936ce93e49a27de98cf1f121de8fb7db4f03", + "size": 740498, + "subdir": "linux-64", + "timestamp": 1604771431454, + "version": "50.3.1" + }, + "setuptools-50.3.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45e4b6df4451d98a2db9faa35261f0fa", + "name": "setuptools", + "sha256": "1f576f3a283afc787d0f4eb8e083746e17ac5c5d38ba6e9cc848e4090a910589", + "size": 728518, + "subdir": "linux-64", + "timestamp": 1604771413481, + "version": "50.3.1" + }, + "setuptools-50.3.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a431198a90246f0754e5065df05ce449", + "name": "setuptools", + "sha256": "654b534fe67e4a95f882a757380a5943a5911dc50056ff01187f8833765079f2", + "size": 730961, + "subdir": "linux-64", + "timestamp": 1604771442322, + "version": "50.3.1" + }, + "setuptools-50.3.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee91acfce12eda6f7762afac9cef02d9", + "name": "setuptools", + "sha256": "6ba2fd06818b696f3394f13109f8b44082bac7d7b60ed352df855bab0b518c68", + "size": 731293, + "subdir": "linux-64", + "timestamp": 1604771428645, + "version": "50.3.1" + }, + "setuptools-50.3.2-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4de37ea98727b8e5e281077028c2fac", + "name": "setuptools", + "sha256": "12e399c6f98cc68b1beb16182af195f6425bfa2a53326fd729d856f734af8d1d", + "size": 740325, + "subdir": "linux-64", + "timestamp": 1606864963541, + "version": "50.3.2" + }, + "setuptools-50.3.2-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "133ea7fe3ee42ec5de7f577a93ad0941", + "name": "setuptools", + "sha256": "01e797589996f685b27085b5fae76696c5668d8ec594997142ca32a2955751d2", + "size": 740544, + "subdir": "linux-64", + "timestamp": 1606864934630, + "version": "50.3.2" + }, + "setuptools-50.3.2-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa53322dbc7ea4511981c669ba502243", + "name": "setuptools", + "sha256": "4d7b0b4aaef2c6ac2eb622ee1acde8f8330495427d21e5d219f5176bb5f12b7d", + "size": 731033, + "subdir": "linux-64", + "timestamp": 1606864944390, + "version": "50.3.2" + }, + "setuptools-50.3.2-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d1781f07e861b43d6fb3b2ff08ff0d5d", + "name": "setuptools", + "sha256": "50db254647f25b02a5edb6de1dd3b682be10bf7f60b7c9a81e50d9a3533ac650", + "size": 741476, + "subdir": "linux-64", + "timestamp": 1606864954496, + "version": "50.3.2" + }, + "setuptools-51.0.0-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "91a5eea306a9735c3bb0a5af9cafffd4", + "name": "setuptools", + "sha256": "6ea4db0a35490d7323065dd066847e6786493e892e1a6cdb30618a71431527a2", + "size": 729085, + "subdir": "linux-64", + "timestamp": 1607369636540, + "version": "51.0.0" + }, + "setuptools-51.0.0-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c274bcb658fbb0da845f61de27d34486", + "name": "setuptools", + "sha256": "1ce650ecada3cd37b958836fd2c63557716ec2f58610c3de0e77465cb986d782", + "size": 728051, + "subdir": "linux-64", + "timestamp": 1607369661209, + "version": "51.0.0" + }, + "setuptools-51.0.0-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f3b357dd23cb903cc1c2cc1fa0438f0", + "name": "setuptools", + "sha256": "c656421eb20bc73c97ea042429d46931f934694a569ff0a0b8fa2947ed2d505f", + "size": 743707, + "subdir": "linux-64", + "timestamp": 1607369648803, + "version": "51.0.0" + }, + "setuptools-51.0.0-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db69543d3f459b0a0c74280e855aa367", + "name": "setuptools", + "sha256": "92d6392d50766f89ce212ba11b7d796dcfcd63504829c61a0a81ad9c1983dadc", + "size": 743535, + "subdir": "linux-64", + "timestamp": 1607369654728, + "version": "51.0.0" + }, + "setuptools-51.1.2-py36h06a4308_3.conda": { + "build": "py36h06a4308_3", + "build_number": 3, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80dbea90e7d93159bfc0beac0e1574f4", + "name": "setuptools", + "sha256": "2e053d80f7136ac5427a635e13893cf27c2335c1b5b26a4d36d3a7463e546a07", + "size": 740909, + "subdir": "linux-64", + "timestamp": 1610306790252, + "version": "51.1.2" + }, + "setuptools-51.1.2-py36h06a4308_4.conda": { + "build": "py36h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5cc8df891336eda8c2cc06f2bb8b2a0e", + "name": "setuptools", + "sha256": "8e6bfcf3626388bff5f6e8f5f8f8c7d3e18e84ef341294eee842de2b3ee0d85e", + "size": 747763, + "subdir": "linux-64", + "timestamp": 1610483757154, + "version": "51.1.2" + }, + "setuptools-51.1.2-py37h06a4308_3.conda": { + "build": "py37h06a4308_3", + "build_number": 3, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff6f2180d640f9be0e8c881416baa1a4", + "name": "setuptools", + "sha256": "b783cb49cfed66ee97b037e12e623ba93af9d94ac52540d93834afdaee9f2bbd", + "size": 728760, + "subdir": "linux-64", + "timestamp": 1610306788999, + "version": "51.1.2" + }, + "setuptools-51.1.2-py37h06a4308_4.conda": { + "build": "py37h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "523bf99e1869121bd64530860e1b1d72", + "name": "setuptools", + "sha256": "cb0c6212b7d02cab47f90e3d99bced790887147e61c30680f217fe700529f880", + "size": 756392, + "subdir": "linux-64", + "timestamp": 1610483791480, + "version": "51.1.2" + }, + "setuptools-51.1.2-py38h06a4308_3.conda": { + "build": "py38h06a4308_3", + "build_number": 3, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "310679ed7fe149aeace37c75acbf77f0", + "name": "setuptools", + "sha256": "573a96802984a21936ee2504ffe5b01c7dd814b2287af0ab7ced02259d605993", + "size": 743687, + "subdir": "linux-64", + "timestamp": 1610306770701, + "version": "51.1.2" + }, + "setuptools-51.1.2-py38h06a4308_4.conda": { + "build": "py38h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ecad3e17b745284d939e2c991da6c4cb", + "name": "setuptools", + "sha256": "77cc76e91a4c1d3f1e5b5e87070025e0a943dc23ee89f70244fa2f689aadf383", + "size": 760017, + "subdir": "linux-64", + "timestamp": 1610483304026, + "version": "51.1.2" + }, + "setuptools-51.1.2-py39h06a4308_3.conda": { + "build": "py39h06a4308_3", + "build_number": 3, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a10d5aca113424ea22ae709b0449b40f", + "name": "setuptools", + "sha256": "0843c5e22bb84eb50003137738cc44489fa283f4f5125385bd81350ffd263e5a", + "size": 742616, + "subdir": "linux-64", + "timestamp": 1610306764051, + "version": "51.1.2" + }, + "setuptools-51.1.2-py39h06a4308_4.conda": { + "build": "py39h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0eee50edcc225e82aaae4891aa523726", + "name": "setuptools", + "sha256": "316d175d60899f8ad67831fec3e83708bc4012bb737b8f8d0a0bb36898ef1516", + "size": 760796, + "subdir": "linux-64", + "timestamp": 1610483764376, + "version": "51.1.2" + }, + "setuptools-51.3.2-py36h06a4308_4.conda": { + "build": "py36h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "61042820533963ed4d497424a5d17d82", + "name": "setuptools", + "sha256": "0f7a3832a3b27a65c8f15f6e48eab55e2486cc84b507f087678e662dd0c40e7a", + "size": 745000, + "subdir": "linux-64", + "timestamp": 1610911431821, + "version": "51.3.2" + }, + "setuptools-51.3.2-py37h06a4308_4.conda": { + "build": "py37h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a0be56725b8b83efae0b104427c70b4", + "name": "setuptools", + "sha256": "87100bba56ba20182461d77f5ef879c89602bba29a62be7d48ecdeb34bc0d804", + "size": 740435, + "subdir": "linux-64", + "timestamp": 1610912128151, + "version": "51.3.2" + }, + "setuptools-51.3.2-py38h06a4308_4.conda": { + "build": "py38h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8ca7e30ffbfd9d003a00bb990f4f942", + "name": "setuptools", + "sha256": "5a8e29ece62d125ffe237fe64456bbdcfd029801b4b47509cda5539df063d291", + "size": 745890, + "subdir": "linux-64", + "timestamp": 1610912110756, + "version": "51.3.2" + }, + "setuptools-51.3.2-py39h06a4308_4.conda": { + "build": "py39h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4b04ff94170259bc70c925836e8abc33", + "name": "setuptools", + "sha256": "bc47a89f85a858c1624463620bd38d8e7cdbeffe0687e7bf76896e5fa301037c", + "size": 745190, + "subdir": "linux-64", + "timestamp": 1610912132122, + "version": "51.3.2" + }, + "setuptools-51.3.3-py36h06a4308_4.conda": { + "build": "py36h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8b6629bdfedc8a8ceb81b8c9e63eab6", + "name": "setuptools", + "sha256": "9227edfadcd76626a64fde214534ccb62bff92dd0fff8b355bb4f75ae27aa8f2", + "size": 730555, + "subdir": "linux-64", + "timestamp": 1610998818402, + "version": "51.3.3" + }, + "setuptools-51.3.3-py37h06a4308_4.conda": { + "build": "py37h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "057e421774a5b1a7493b973227b751f0", + "name": "setuptools", + "sha256": "3d9e6db06fb28c7a4eee0cc78badd46dbb03becb98325f5dacc2b110e00d3c30", + "size": 729834, + "subdir": "linux-64", + "timestamp": 1610998797189, + "version": "51.3.3" + }, + "setuptools-51.3.3-py38h06a4308_4.conda": { + "build": "py38h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "25cfcfc7a1502800a190432ee5bb38dd", + "name": "setuptools", + "sha256": "7dcc6324d238eb47b0c3c398b81c77d15381853b0d02671e97997d1aa115e7be", + "size": 744780, + "subdir": "linux-64", + "timestamp": 1610998819683, + "version": "51.3.3" + }, + "setuptools-51.3.3-py39h06a4308_4.conda": { + "build": "py39h06a4308_4", + "build_number": 4, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c489d82bb6af80c60f0d120761224a62", + "name": "setuptools", + "sha256": "68277b0ee833954ad69a750ef61e5b19729e31b12b521a27f0ee87b958a064ec", + "size": 745444, + "subdir": "linux-64", + "timestamp": 1610998065635, + "version": "51.3.3" + }, + "setuptools-52.0.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "94ddbc55ad8d41c1613dd00bae9a9ea6", + "name": "setuptools", + "sha256": "83b317c1e7baf493b7c7783edd4c7c28de92b5634caa18fbf6eb23f91d0903d8", + "size": 764443, + "subdir": "linux-64", + "timestamp": 1633501367301, + "version": "52.0.0" + }, + "setuptools-52.0.0-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c9c6148cdfc4706850d08791daceeb32", + "name": "setuptools", + "sha256": "3d73e00bbba292d5900057128e014aabd7db754b69f4ad8658de1e8990dd8594", + "size": 949475, + "subdir": "linux-64", + "timestamp": 1676822488587, + "version": "52.0.0" + }, + "setuptools-52.0.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e737f08f4cd00523432a047b1941288", + "name": "setuptools", + "sha256": "d9006bce2d14b5c65cc0ac126256f327f0e8de55f8f789f498d0300245e03f82", + "size": 741023, + "subdir": "linux-64", + "timestamp": 1611605149443, + "version": "52.0.0" + }, + "setuptools-52.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f260cb75ead478f373e5b91a9102042", + "name": "setuptools", + "sha256": "93516c6f005cc74bbff7c196b5a37b7c2651cb163927f0e4f2cde168a13c3e0a", + "size": 727266, + "subdir": "linux-64", + "timestamp": 1611605118613, + "version": "52.0.0" + }, + "setuptools-52.0.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea0563b16f86ef2125ad88c960b9d3be", + "name": "setuptools", + "sha256": "7ee57dfb54f9fae384a9e37858631e3049558af3bfa27473c849d6db19b960cb", + "size": 755409, + "subdir": "linux-64", + "timestamp": 1633512114593, + "version": "52.0.0" + }, + "setuptools-52.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "28b5368307cefee1c0940ff14064ed9c", + "name": "setuptools", + "sha256": "d5eab0eea7ad4de66f6f85fd9292a5714b2727eb3a94a31972df5685c96ffe9b", + "size": 731157, + "subdir": "linux-64", + "timestamp": 1611605169910, + "version": "52.0.0" + }, + "setuptools-52.0.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23c9aff459ee13b5550256903df0cab5", + "name": "setuptools", + "sha256": "ac46d3a0f897e331b5bed15e774c2bf5c052b0164eb74d5a94b08c00abc86ae9", + "size": 758031, + "subdir": "linux-64", + "timestamp": 1633512123282, + "version": "52.0.0" + }, + "setuptools-52.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c235a32d503ee9f6dd1b84141632f9e8", + "name": "setuptools", + "sha256": "0132896a89b2ac02486aca2ad981367567646282397b06015d169667f84b743f", + "size": 741670, + "subdir": "linux-64", + "timestamp": 1611605161621, + "version": "52.0.0" + }, + "setuptools-52.0.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "81de48ae7ac02e7881d665a343bbd636", + "name": "setuptools", + "sha256": "70c5ca786ca1d5c63d32f6d7539ca6bdd6404dc5554268b06038bec34096583f", + "size": 757840, + "subdir": "linux-64", + "timestamp": 1633511313893, + "version": "52.0.0" + }, + "setuptools-58.0.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c9e9b034eb0f7cf00c72fb5dd9949298", + "name": "setuptools", + "sha256": "de5a663c6c535adbef8bf87ceb9628002ba721ef824490285dd9ee48c270ed99", + "size": 800847, + "subdir": "linux-64", + "timestamp": 1633608016133, + "version": "58.0.4" + }, + "setuptools-58.0.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "009cc294d0e21c0e3c38338b4136aabc", + "name": "setuptools", + "sha256": "99c687f5bb402c108dcb4b800d010488626fad41ad1b301da2751e477ee298e0", + "size": 806993, + "subdir": "linux-64", + "timestamp": 1631833152691, + "version": "58.0.4" + }, + "setuptools-58.0.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a029dd9ed7a3181ac029df236106348a", + "name": "setuptools", + "sha256": "65cd68a57bbf658c32372572fbf9abddcb285fc147da09fed3010a6ab1b13a53", + "size": 793141, + "subdir": "linux-64", + "timestamp": 1631832983661, + "version": "58.0.4" + }, + "setuptools-58.0.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8936e58b5955a1a22ac24362e1c9a76f", + "name": "setuptools", + "sha256": "1d97e236326d80a0de8ace3daa054e3349c200e1343cb75f06bfac8424ae3da3", + "size": 809344, + "subdir": "linux-64", + "timestamp": 1631823241040, + "version": "58.0.4" + }, + "setuptools-58.0.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e17b9788eb5bf407d8eadc888ffe6a9", + "name": "setuptools", + "sha256": "b7e3ad9dce08de8ebc474a239da5db370b89067b8977ee3587fd298882c5a577", + "size": 808829, + "subdir": "linux-64", + "timestamp": 1631833131205, + "version": "58.0.4" + }, + "setuptools-61.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f43427d7c045e63786e0bb79084cf70", + "name": "setuptools", + "sha256": "46d93578afe46775f9ceaee40f2781ca24ebb4df95079f33a0d562d2571594eb", + "size": 1043745, + "subdir": "linux-64", + "timestamp": 1649230548784, + "version": "61.2.0" + }, + "setuptools-61.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6260346a87ce352708d3f6647db87188", + "name": "setuptools", + "sha256": "bfa46a49f290ca59614e31e3e137dd8cd6f11e04c1a572183d2de4ac08970f41", + "size": 1031376, + "subdir": "linux-64", + "timestamp": 1649230484203, + "version": "61.2.0" + }, + "setuptools-61.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5e94bc1e8e443ae6d53b191a351591e", + "name": "setuptools", + "sha256": "2deed396c8102c6c9400b0efec4505ec45bdaf813906f5867285dd8f8bb92b10", + "size": 1035848, + "subdir": "linux-64", + "timestamp": 1649230510263, + "version": "61.2.0" + }, + "setuptools-61.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "720869dc83cf20f2167fb12e7a54ebaa", + "name": "setuptools", + "sha256": "9209dec345c5ca90aa5337000dee6b919590bcc5d9b3ce0821130ffbe83cf354", + "size": 1034868, + "subdir": "linux-64", + "timestamp": 1649230457664, + "version": "61.2.0" + }, + "setuptools-63.4.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "338d7c61510134b81ef69ebcbff5dec4", + "name": "setuptools", + "sha256": "d9ca66ebdcafcd177c1e686d31a715e5d50e9c0bb3bdf2b462a8652ed9df78c2", + "size": 1118476, + "subdir": "linux-64", + "timestamp": 1661182494050, + "version": "63.4.1" + }, + "setuptools-63.4.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1493fff8fb1dc5480a019480cd1bb62e", + "name": "setuptools", + "sha256": "140c2291e12fbd469fadf979e98694b84579ed8d17c37755dd40206e73caa1b7", + "size": 1104150, + "subdir": "linux-64", + "timestamp": 1661182525679, + "version": "63.4.1" + }, + "setuptools-63.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "307186073689cfd6ece38172333659e8", + "name": "setuptools", + "sha256": "36a09b546220cfbaa7c3f162d768e57ae92f85490aa8a874741a30d90dddc2fb", + "size": 1110304, + "subdir": "linux-64", + "timestamp": 1661182439561, + "version": "63.4.1" + }, + "setuptools-63.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "442f22b6e70de4e5aad26dd637c36f7c", + "name": "setuptools", + "sha256": "64cb4c1cd8cb18bbccfcb7eac336b0ff58f5a99521f6b4d74e7ee18c51434513", + "size": 1109266, + "subdir": "linux-64", + "timestamp": 1661182561012, + "version": "63.4.1" + }, + "setuptools-65.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0a062799373234c10b575a1c85c10f3", + "name": "setuptools", + "sha256": "bb191042ae6e112294cac76e260869581c0abf1782bee23ff61b3d3198cf2b4c", + "size": 1125310, + "subdir": "linux-64", + "timestamp": 1666983185782, + "version": "65.4.0" + }, + "setuptools-65.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0c17b08e6896441401d63e67da3e1e9", + "name": "setuptools", + "sha256": "c5270edd98620770ff83975630ce7a7d0a1d1015e8a64d6f82f9e2c0ffc46e20", + "size": 1109953, + "subdir": "linux-64", + "timestamp": 1666983106932, + "version": "65.4.0" + }, + "setuptools-65.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "05f705fa0d9ce4e6c5f85e8332a907d6", + "name": "setuptools", + "sha256": "dc5108ebbcdf7d70b754b9e42f1c38fd236fe5cc068dddd3c490deb46211d06b", + "size": 1116935, + "subdir": "linux-64", + "timestamp": 1666983157909, + "version": "65.4.0" + }, + "setuptools-65.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de2f2daf99bb57886197a04dfc445529", + "name": "setuptools", + "sha256": "9c2af26f7416ff0453c6dc2002f9d50928a68db34c9f3bd408bc53c1a1c28ca5", + "size": 1115116, + "subdir": "linux-64", + "timestamp": 1666983132523, + "version": "65.4.0" + }, + "setuptools-65.5.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "776ce9588114e5a9e2b7298bd538c231", + "name": "setuptools", + "sha256": "f33bb6959aed6323317e8d5ef17e3fcc5f9e744f825ecd2b6e1471f122d6ebd4", + "size": 1208323, + "subdir": "linux-64", + "timestamp": 1667236179914, + "version": "65.5.0" + }, + "setuptools-65.5.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64fe3e2957dfdb50f32450a9aa6e5346", + "name": "setuptools", + "sha256": "62060cb0b7b1b1471f38b204b809263874442f34a8e9a232b672792408c3a39c", + "size": 1464866, + "subdir": "linux-64", + "timestamp": 1669773298100, + "version": "65.5.0" + }, + "setuptools-65.5.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "05dd72113f3227e00bb911f486645d5e", + "name": "setuptools", + "sha256": "556de0b74f3c14e5b7d954f873a72add036fbf8f431cc31b223c6b47e8be2040", + "size": 1193390, + "subdir": "linux-64", + "timestamp": 1667236125184, + "version": "65.5.0" + }, + "setuptools-65.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39a83921f08b25897e9e4d07f4d41179", + "name": "setuptools", + "sha256": "52810ca1e79fbcba8adbfe9a1242bfd5111e0bd0067050e9abc464edbed4792f", + "size": 1198888, + "subdir": "linux-64", + "timestamp": 1667236207481, + "version": "65.5.0" + }, + "setuptools-65.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3af37a56c2d135aff97e1e76120e3539", + "name": "setuptools", + "sha256": "d3ae5b02aac5ab63688035c3b122e5ef41d373d633fcf3fdca440ddd2ff1e95e", + "size": 1197773, + "subdir": "linux-64", + "timestamp": 1667236151454, + "version": "65.5.0" + }, + "setuptools-65.6.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8331a85881df5712194edf67638cf08", + "name": "setuptools", + "sha256": "e346700262cb500b058fc418fa3b64c3058fb24f98d67067cd5cb4d61c2d0296", + "size": 1208143, + "subdir": "linux-64", + "timestamp": 1672940228423, + "version": "65.6.3" + }, + "setuptools-65.6.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8c4e794496c77ff7f0e53c23db9c3a6", + "name": "setuptools", + "sha256": "7cc34d91b057a979af3e2a121ae7916e9fd647c490b3a079180ae38177860f3f", + "size": 1468940, + "subdir": "linux-64", + "timestamp": 1679339109425, + "version": "65.6.3" + }, + "setuptools-65.6.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1039493adf22eff152d28326000c1f93", + "name": "setuptools", + "sha256": "0f025aade1fa0dcdfd837e522e1e67be5cf0f33dd27cfb9f491ad221339b09b0", + "size": 1193523, + "subdir": "linux-64", + "timestamp": 1672940142881, + "version": "65.6.3" + }, + "setuptools-65.6.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7676b836ec3f9cb1b0f8661d5863d1a4", + "name": "setuptools", + "sha256": "447a98341ba96d36bbcd11ab5360530d6772e6cb0d87c74d3cb6f48693559802", + "size": 1199007, + "subdir": "linux-64", + "timestamp": 1672940171796, + "version": "65.6.3" + }, + "setuptools-65.6.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "certifi >=2016.9.26", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c45480250c7a422ae327df494aced180", + "name": "setuptools", + "sha256": "956a2953ca020959e69ac50730bef380c337a2120dd2f62392f21d2cba9e61dc", + "size": 1199035, + "subdir": "linux-64", + "timestamp": 1672940199006, + "version": "65.6.3" + }, + "setuptools-git-1.2-py27h28b3542_1.conda": { + "build": "py27h28b3542_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "17e263b3f0486e8c9bc3711bab3d297e", + "name": "setuptools-git", + "sha256": "9a966abc47bd741943c2fc329efcc28e171977cedde932d48cc73c86e9adfc79", + "size": 15948, + "subdir": "linux-64", + "timestamp": 1535492431196, + "version": "1.2" + }, + "setuptools-git-1.2-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "58d333a0eff872199f2a6c24197db8ac", + "name": "setuptools-git", + "sha256": "f7e72db52bc0c3e02685bd3b283bfcdb7c917c8cc8095357ceb76466e2cf68c1", + "size": 18400, + "subdir": "linux-64", + "timestamp": 1642501110109, + "version": "1.2" + }, + "setuptools-git-1.2-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2d18f5e575183fa347473f46dee9ea8a", + "name": "setuptools-git", + "sha256": "160f9a3af20dedb50f0a421f38ec43b7b6e8a35813a1a9d97e29cb580ca9eacd", + "size": 22874, + "subdir": "linux-64", + "timestamp": 1676845777477, + "version": "1.2" + }, + "setuptools-git-1.2-py35h28b3542_1.conda": { + "build": "py35h28b3542_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "24103771ab4c93ae4115751c25c0eec6", + "name": "setuptools-git", + "sha256": "eab7727a118c254f5dae8c0d895360fabaf5dde100e144ed50101ac9d625ceac", + "size": 16354, + "subdir": "linux-64", + "timestamp": 1535492446015, + "version": "1.2" + }, + "setuptools-git-1.2-py36h28b3542_1.conda": { + "build": "py36h28b3542_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fccc3f2c67b18274471e5687fc0fab07", + "name": "setuptools-git", + "sha256": "4b685c14fb6116c9c5001b61a0038dd7a7e9c2ce5ea365b2d897a2eecbaf0c3f", + "size": 16336, + "subdir": "linux-64", + "timestamp": 1535492415754, + "version": "1.2" + }, + "setuptools-git-1.2-py37h28b3542_1.conda": { + "build": "py37h28b3542_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6fbdf7de35657700fa3fea64844434f4", + "name": "setuptools-git", + "sha256": "6a421231a452cb0220a9d64186d57875db948153664ae9aa50b6ea38272a2027", + "size": 16294, + "subdir": "linux-64", + "timestamp": 1535492424775, + "version": "1.2" + }, + "setuptools-git-versioning-1.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "deprecated", + "packaging", + "python >=3.10,<3.11.0a0", + "setuptools", + "toml >=0.10.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8723eeb194e8b51a828244399b8e2d7", + "name": "setuptools-git-versioning", + "sha256": "6ee93902bd372677b785c10b08355e797d994a80036f91046d76dd531faf6d5a", + "size": 22270, + "subdir": "linux-64", + "timestamp": 1667894881747, + "version": "1.11.0" + }, + "setuptools-git-versioning-1.11.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "deprecated", + "packaging", + "python >=3.7,<3.8.0a0", + "setuptools", + "toml >=0.10.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a87f301e977a82102f5bb957ee6cac62", + "name": "setuptools-git-versioning", + "sha256": "374d9d57b7d20304616e036e650b014255a7b57e9d40501e303cc0ac64b0005c", + "size": 21968, + "subdir": "linux-64", + "timestamp": 1667894933902, + "version": "1.11.0" + }, + "setuptools-git-versioning-1.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "deprecated", + "packaging", + "python >=3.8,<3.9.0a0", + "setuptools", + "toml >=0.10.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3aa3c805c8a55e5804c1702e46f34244", + "name": "setuptools-git-versioning", + "sha256": "333634e26eea807e26a68ab0b4b3a9b77f0eaf2c849d6c85d50a4049c8f75325", + "size": 22055, + "subdir": "linux-64", + "timestamp": 1667894959828, + "version": "1.11.0" + }, + "setuptools-git-versioning-1.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "deprecated", + "packaging", + "python >=3.9,<3.10.0a0", + "setuptools", + "toml >=0.10.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b79aaee6e30b3d1822755f7ff31091f", + "name": "setuptools-git-versioning", + "sha256": "92b2ff37100d73fe3e4f950a3faa75f6734a22877c313c499a5d735020dcb869", + "size": 22119, + "subdir": "linux-64", + "timestamp": 1667894907696, + "version": "1.11.0" + }, + "setuptools-git-versioning-1.13.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.10,<3.11.0a0", + "setuptools", + "toml >=0.10.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62dbfdabbab3a77f211e4cbd7ce69b4d", + "name": "setuptools-git-versioning", + "sha256": "a4d33fc84a0ecea8d5883a55764419153dce281344ed2f0cba58c0ac6f8ce438", + "size": 23377, + "subdir": "linux-64", + "timestamp": 1670426115539, + "version": "1.13.1" + }, + "setuptools-git-versioning-1.13.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eae27e9bfd506cb9a077862d411debbd", + "name": "setuptools-git-versioning", + "sha256": "67de5b407cb2fa6a9181d46c505f310748475338526560e89bfc371e797967d1", + "size": 27185, + "subdir": "linux-64", + "timestamp": 1676828843768, + "version": "1.13.1" + }, + "setuptools-git-versioning-1.13.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.7,<3.8.0a0", + "setuptools", + "toml >=0.10.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb9ec0ec6913f324c9add608f731ed82", + "name": "setuptools-git-versioning", + "sha256": "390308ae04eeddd9b1d6dcabd062c5aec511144157c1f7c9134aaa59eb24a939", + "size": 23045, + "subdir": "linux-64", + "timestamp": 1670426089828, + "version": "1.13.1" + }, + "setuptools-git-versioning-1.13.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.8,<3.9.0a0", + "setuptools", + "toml >=0.10.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0ac0afa266648b7bed5be6d5bf308fd", + "name": "setuptools-git-versioning", + "sha256": "b82dda5c75ebd3833b51f973c0bcf894423b598a1bc8742829305b17c77bc76f", + "size": 23133, + "subdir": "linux-64", + "timestamp": 1670426140671, + "version": "1.13.1" + }, + "setuptools-git-versioning-1.13.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.9,<3.10.0a0", + "setuptools", + "toml >=0.10.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f0004c641df458b7e6bbbf242ac98857", + "name": "setuptools-git-versioning", + "sha256": "872851fe019fa6cf3e3369ecec070cbbdb30f2a5e62e4a8b7724d54853f7510f", + "size": 23169, + "subdir": "linux-64", + "timestamp": 1670426165984, + "version": "1.13.1" + }, + "setuptools-rust-1.5.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "semantic_version >=2.8.2,<3", + "setuptools >=62.4", + "typing_extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b72da2498db0332a11af4e8e178d0bc3", + "name": "setuptools-rust", + "sha256": "3e4e6c04a101ecf72a2921350261a1846d08d21fe97df81b21ee08da0b4f2855", + "size": 43370, + "subdir": "linux-64", + "timestamp": 1667503220856, + "version": "1.5.2" + }, + "setuptools-rust-1.5.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "semantic_version >=2.8.2,<3", + "setuptools >=62.4", + "typing_extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa2ba90e2d0ee3e90fbce2b878773882", + "name": "setuptools-rust", + "sha256": "2599f4baafe49457837dd5771e6d3d36239c375e131940ec8505e63386429e91", + "size": 53237, + "subdir": "linux-64", + "timestamp": 1676822566303, + "version": "1.5.2" + }, + "setuptools-rust-1.5.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "semantic_version >=2.8.2,<3", + "setuptools >=62.4", + "typing_extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3a1df07c545b0ea69a30ea031785cb1", + "name": "setuptools-rust", + "sha256": "661621ed57c0ac26d8b02dd094b047dd3f199656cee2ca6aa2cc641b27e82eb0", + "size": 43148, + "subdir": "linux-64", + "timestamp": 1667503272934, + "version": "1.5.2" + }, + "setuptools-rust-1.5.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "semantic_version >=2.8.2,<3", + "setuptools >=62.4", + "typing_extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c53a3ade9f10fa78651e9459ffaee91f", + "name": "setuptools-rust", + "sha256": "f66574daf1f072e52ce44c4ccebe15a97d0c3147c509b1c076bdc8959ac5ac84", + "size": 43096, + "subdir": "linux-64", + "timestamp": 1667503195248, + "version": "1.5.2" + }, + "setuptools-rust-1.5.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "semantic_version >=2.8.2,<3", + "setuptools >=62.4", + "typing_extensions >=3.7.4.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c2ec8a3c2c10cf6c9ffdd269526bbb7", + "name": "setuptools-rust", + "sha256": "e5379ef87a119634ae65c3afaa0e78f850f5a7e48bb5a345c29f2175c2c716fe", + "size": 43070, + "subdir": "linux-64", + "timestamp": 1667503246636, + "version": "1.5.2" + }, + "setuptools-scm-7.0.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20.0", + "python >=3.10,<3.11.0a0", + "setuptools >=45", + "tomli >=1.0.0", + "typing-extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e38d5075a28ea6683b93c35ff819f3c7", + "name": "setuptools-scm", + "sha256": "b7f127f24ae339947aa5e48ec9704bccb5996accc9da083de055fb9f8866edaa", + "size": 65706, + "subdir": "linux-64", + "timestamp": 1657093026935, + "version": "7.0.4" + }, + "setuptools-scm-7.0.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20.0", + "python >=3.11,<3.12.0a0", + "setuptools >=45", + "tomli >=1.0.0", + "typing-extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d49cb726571c762d198412379be11fd", + "name": "setuptools-scm", + "sha256": "75f85f7086cdaa6f4580059dbdceda98de6b0fbf9a3bf1281cd6fe8c298a50c2", + "size": 82437, + "subdir": "linux-64", + "timestamp": 1676822741030, + "version": "7.0.4" + }, + "setuptools-scm-7.0.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "packaging >=20.0", + "python >=3.7,<3.8.0a0", + "setuptools >=45", + "tomli >=1.0.0", + "typing-extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "764d94394d275397ea01b0c3ed0671ee", + "name": "setuptools-scm", + "sha256": "4fc51cbf0de5287bb3f8b104ef4c2f4d7f3f8ebd53e006bb5bd249ce56f414d0", + "size": 64737, + "subdir": "linux-64", + "timestamp": 1657093054354, + "version": "7.0.4" + }, + "setuptools-scm-7.0.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20.0", + "python >=3.8,<3.9.0a0", + "setuptools >=45", + "tomli >=1.0.0", + "typing-extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa0729a63ce29c9bf002bbc82b23f555", + "name": "setuptools-scm", + "sha256": "a017e95c38a8a17cbfeee03ff3b7e7f3443256adbef20e29101501839f47b8a4", + "size": 65033, + "subdir": "linux-64", + "timestamp": 1657093066967, + "version": "7.0.4" + }, + "setuptools-scm-7.0.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20.0", + "python >=3.9,<3.10.0a0", + "setuptools >=45", + "tomli >=1.0.0", + "typing-extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e812ce3d4a0783b922019f1e758e734", + "name": "setuptools-scm", + "sha256": "3eb88bb795fab1c8b54ad91cb7314ff88f5e4b4bad756231699949b6a60845b5", + "size": 65050, + "subdir": "linux-64", + "timestamp": 1657093041642, + "version": "7.0.4" + }, + "setuptools_scm-1.15.6-py27h3d0bb11_0.conda": { + "build": "py27h3d0bb11_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "959a3d96d375851e17c4b2fe43e6f8e4", + "name": "setuptools_scm", + "sha256": "beeb58b2f412bf75ad33313ac22ed6b5ea8f323ecb6f6ed5d09d09dd6468d71f", + "size": 23835, + "subdir": "linux-64", + "timestamp": 1505688222827, + "version": "1.15.6" + }, + "setuptools_scm-1.15.6-py35ha940eae_0.conda": { + "build": "py35ha940eae_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "8124b12cb6e405ae9798a9078892e729", + "name": "setuptools_scm", + "sha256": "01091d07b3a7d99b29aeff818772cd9c993ad18ff56aab5f6744788924f163dd", + "size": 23961, + "subdir": "linux-64", + "timestamp": 1505688234290, + "version": "1.15.6" + }, + "setuptools_scm-1.15.6-py36h9817af8_0.conda": { + "build": "py36h9817af8_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "b01260d968a4805a75aece54cb913201", + "name": "setuptools_scm", + "sha256": "700f16a199df16f78c7d10c8833a8fa0f7ef25a8ab1c629f3271f86b9f46dcea", + "size": 23595, + "subdir": "linux-64", + "timestamp": 1505688245892, + "version": "1.15.6" + }, + "setuptools_scm-1.15.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "491c955f0446f7247b408ad5f4630b5a", + "name": "setuptools_scm", + "sha256": "85c8b4202da8836129b474a51b393a1a56a275f4182d7f77cfd04ac9ea65eb3d", + "size": 26948, + "subdir": "linux-64", + "timestamp": 1520780231849, + "version": "1.15.7" + }, + "setuptools_scm-1.15.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "fdab2aaa6503ace6da623450238e1305", + "name": "setuptools_scm", + "sha256": "ca7748427592a6fca13cef617e1b7133ef8cc6409fb8bef37726f2ae5bc5d161", + "size": 27115, + "subdir": "linux-64", + "timestamp": 1520780241763, + "version": "1.15.7" + }, + "setuptools_scm-1.15.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "a16d8f77485074c55b1d22cf0f6e9358", + "name": "setuptools_scm", + "sha256": "2a5c2b07c05cc2aea43c506416e3b98be03f8be9ca5d0188b5deba07c16762bb", + "size": 27028, + "subdir": "linux-64", + "timestamp": 1520780218096, + "version": "1.15.7" + }, + "setuptools_scm-1.17.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "d1d460492beb1736d6a35e066a004194", + "name": "setuptools_scm", + "sha256": "d91abf706476e2cf9e3c96d3504136ebc1c37064c6d932b76e5a1e37c1fe3973", + "size": 27780, + "subdir": "linux-64", + "timestamp": 1522195423605, + "version": "1.17.0" + }, + "setuptools_scm-1.17.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "75685545afd988eb886f24070079fe08", + "name": "setuptools_scm", + "sha256": "e62effa4050e1ecc2c16e57308a11c90f4a43034c7296b7504ff70c9a48b9333", + "size": 28164, + "subdir": "linux-64", + "timestamp": 1522195431529, + "version": "1.17.0" + }, + "setuptools_scm-1.17.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "e1a3547b8aa7b145ccc0eae8d98dcb99", + "name": "setuptools_scm", + "sha256": "578da631b4c18873cfa6d30f7aba7f6d6a8b62784d9238b68df4fa6afdc29700", + "size": 27826, + "subdir": "linux-64", + "timestamp": 1522195435738, + "version": "1.17.0" + }, + "setuptools_scm-2.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "7e0dd7c67c053a712bfa9701355d94ec", + "name": "setuptools_scm", + "sha256": "e5f3051620f3f6327d1df94db2f07274b9fab592eb3b85b3a29f3adeaa956144", + "size": 28986, + "subdir": "linux-64", + "timestamp": 1524070005092, + "version": "2.0.0" + }, + "setuptools_scm-2.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "7e0a85d998359168c811d8b5c29eaf50", + "name": "setuptools_scm", + "sha256": "a5193a4d1f2f2d230b18dcce3545d9c2284d2ba624f1a0918379843082cfcce8", + "size": 29381, + "subdir": "linux-64", + "timestamp": 1524070042453, + "version": "2.0.0" + }, + "setuptools_scm-2.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "2dd8db5120511a11d981030e2f64270f", + "name": "setuptools_scm", + "sha256": "4a2df460f9c691281ad0d3a0336bdc66d9fe7c828d2b951c25b0f5fc509ba40b", + "size": 28970, + "subdir": "linux-64", + "timestamp": 1524070047452, + "version": "2.0.0" + }, + "setuptools_scm-2.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "bfa59d43b5f2d63a826a1d6a52cc4be5", + "name": "setuptools_scm", + "sha256": "7159e6edb0736cd06efa5932ce7c8d302d8a367e9a9849bc454930fa444d9771", + "size": 31403, + "subdir": "linux-64", + "timestamp": 1526922682844, + "version": "2.1.0" + }, + "setuptools_scm-2.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "ee79917510dc19b4a30067ab3d311f0b", + "name": "setuptools_scm", + "sha256": "87bca8f75b02fd11856430fab9ed56d126428423f7f1ec8b5e144a059f8b2a3c", + "size": 31716, + "subdir": "linux-64", + "timestamp": 1526922703095, + "version": "2.1.0" + }, + "setuptools_scm-2.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "ecec68cc12acb6476c90db88e94d3045", + "name": "setuptools_scm", + "sha256": "722d64def71b33711e037ce26560d562e8feb82cc7f47d39c18c7465849d3c65", + "size": 31322, + "subdir": "linux-64", + "timestamp": 1526922659732, + "version": "2.1.0" + }, + "setuptools_scm-2.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "9dedcf4391201e7beb298528324f7185", + "name": "setuptools_scm", + "sha256": "c659d6034063fa584572f719141fddf76850e45a178db792bc2944ba531da658", + "size": 31634, + "subdir": "linux-64", + "timestamp": 1530693798333, + "version": "2.1.0" + }, + "setuptools_scm-3.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "d001e48f54dcb525dd88d9571e085994", + "name": "setuptools_scm", + "sha256": "18cdef550cddbde5465bc2fe93a0b22a0f32dad12f3bcd8953154a1f9768c54d", + "size": 36522, + "subdir": "linux-64", + "timestamp": 1532631783712, + "version": "3.0.2" + }, + "setuptools_scm-3.0.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "21cab92da1f58af8031b5265641f9611", + "name": "setuptools_scm", + "sha256": "765974a2095efea7805b31e42ad8781e7cb98a99a1b9fc109ed6cf1096418499", + "size": 36768, + "subdir": "linux-64", + "timestamp": 1532631862288, + "version": "3.0.2" + }, + "setuptools_scm-3.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "daabc3a0e10e033a100bff54ab7af904", + "name": "setuptools_scm", + "sha256": "cb86d7c1c4f3711cf89ca95303be55e8e4f43de7d4c43169afbc7d0bae4ac588", + "size": 36469, + "subdir": "linux-64", + "timestamp": 1532631758666, + "version": "3.0.2" + }, + "setuptools_scm-3.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "efaf44a998d3f9196b1d085659dd1675", + "name": "setuptools_scm", + "sha256": "e8b4553091711954dc8cde133c0530abacba8e250c6dde9c80cac05d9d137993", + "size": 36384, + "subdir": "linux-64", + "timestamp": 1532631870109, + "version": "3.0.2" + }, + "setuptools_scm-3.0.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "0786b1690782e274f205755f8d11466f", + "name": "setuptools_scm", + "sha256": "5330d378f159d56885b07c5cd2b8cc07faa1bee4b1778d54a3bbd376c0711fc8", + "size": 34975, + "subdir": "linux-64", + "timestamp": 1533683305329, + "version": "3.0.6" + }, + "setuptools_scm-3.0.6-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "9d4ec56ec8c858deea70d6f526424c8f", + "name": "setuptools_scm", + "sha256": "b78d178b6275a31e1f200409714a9c27e45fcd2908ed9e851ef1c2abe4040e96", + "size": 36281, + "subdir": "linux-64", + "timestamp": 1534344985211, + "version": "3.0.6" + }, + "setuptools_scm-3.0.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "ce7115aa493f5a6521307e7911c94dbc", + "name": "setuptools_scm", + "sha256": "b5dfbe5587e6140f79866a70975429c45e48c345d061a5e881fba962741cd14d", + "size": 35280, + "subdir": "linux-64", + "timestamp": 1533683334354, + "version": "3.0.6" + }, + "setuptools_scm-3.0.6-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "26fc972829c7f83786e1a3a8245b662c", + "name": "setuptools_scm", + "sha256": "bc3e7bb9e1b9a69870777c0caeefd41557d64977141132f74315d250918094bc", + "size": 36612, + "subdir": "linux-64", + "timestamp": 1534345032470, + "version": "3.0.6" + }, + "setuptools_scm-3.0.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "54067cbe284f2695bab5f15e49d925ea", + "name": "setuptools_scm", + "sha256": "5ed1dee49cc95e88a985399e110a0879fe36b3218b57c1d29a88fa5013fc1f77", + "size": 35163, + "subdir": "linux-64", + "timestamp": 1533683283345, + "version": "3.0.6" + }, + "setuptools_scm-3.0.6-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "6b7df39597e72ba4d6a25030bd0f3964", + "name": "setuptools_scm", + "sha256": "063014afab849e08f4d96b9041765f5c81ac5335d61152b26045f950cd8a379d", + "size": 36177, + "subdir": "linux-64", + "timestamp": 1534345008599, + "version": "3.0.6" + }, + "setuptools_scm-3.0.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "857b8ba18717f40b3fce4925128929b6", + "name": "setuptools_scm", + "sha256": "fd1349742480b67b46922c4885faadb55032c558cda31dcd5cd7db711b01ee7a", + "size": 34868, + "subdir": "linux-64", + "timestamp": 1533686183948, + "version": "3.0.6" + }, + "setuptools_scm-3.0.6-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "90e6d19c83a34bdcd85ab94ffac84f48", + "name": "setuptools_scm", + "sha256": "6ecbd0c6ccc732cfa0d8107fc949dff46f2a78f662092ae85111c94c4748b045", + "size": 36685, + "subdir": "linux-64", + "timestamp": 1534345056207, + "version": "3.0.6" + }, + "setuptools_scm-3.1.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "65a68cf8c90761e8484a60108a7524b2", + "name": "setuptools_scm", + "sha256": "1fb84914131d38bb3a3cd54890ab3f6ac46bfc44287bd8af966067a2bcf968e4", + "size": 35811, + "subdir": "linux-64", + "timestamp": 1534667423567, + "version": "3.1.0" + }, + "setuptools_scm-3.1.0-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "4097ca706f8c16c63464708b240ed6a5", + "name": "setuptools_scm", + "sha256": "0affafc2006e54eb9e733f2c6920a4bfccd5650a402b078ab5ae41262b9dd217", + "size": 36018, + "subdir": "linux-64", + "timestamp": 1534667501889, + "version": "3.1.0" + }, + "setuptools_scm-3.1.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "32c1a18bbde4e858b627fb9f710e60de", + "name": "setuptools_scm", + "sha256": "d51fc0b4f9e111afa580223bc6477627e8ca572ed24261234f0af0fd658d72cd", + "size": 35610, + "subdir": "linux-64", + "timestamp": 1534667413425, + "version": "3.1.0" + }, + "setuptools_scm-3.1.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "2bcf7811887ae1e8b8bb5c87809616cf", + "name": "setuptools_scm", + "sha256": "acc2deaf47346331bcaa47f544ea2b60322212124e70e6a6019f55faee54085c", + "size": 35666, + "subdir": "linux-64", + "timestamp": 1534667503034, + "version": "3.1.0" + }, + "setuptools_scm_git_archive-1.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "35afd8a4c1c66cb4ac70bdce281d3282", + "name": "setuptools_scm_git_archive", + "sha256": "7f8f85b94a3b4adf65e8f27d00827e806735c93ec1598a1be82c2a6baadb3a3d", + "size": 6946, + "subdir": "linux-64", + "timestamp": 1519015425578, + "version": "1.0" + }, + "setuptools_scm_git_archive-1.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b67ff24cbc8609a261d777fb544d8d11", + "name": "setuptools_scm_git_archive", + "sha256": "455261ea808777bbadf4148894496fe877bf4f750144a0f4e544aa58c876cdaf", + "size": 6977, + "subdir": "linux-64", + "timestamp": 1519015436430, + "version": "1.0" + }, + "setuptools_scm_git_archive-1.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "61aeb5b3ffa46650413a0c0c8dcf40bf", + "name": "setuptools_scm_git_archive", + "sha256": "79baa59b1bd7be6d57e9a877f01c9c50440dc0492d1329eda1df47b2b713b1a5", + "size": 6939, + "subdir": "linux-64", + "timestamp": 1519015439921, + "version": "1.0" + }, + "setuptools_scm_git_archive-1.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da734aeb358ae53a3810fde2f3ebf473", + "name": "setuptools_scm_git_archive", + "sha256": "818959c4a9706b619d6dea4eb3c205dac2f3399a9b5b80fb112da31e814e550c", + "size": 6802, + "subdir": "linux-64", + "timestamp": 1530812003098, + "version": "1.0" + }, + "setuptools_scm_git_archive-1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e508c95ac6ec8389136ac7357ebf43e", + "name": "setuptools_scm_git_archive", + "sha256": "e4e33535418ad2456dbe9edfff8845d8e5a94cc5e2023b108cdbc8077671a797", + "size": 7927, + "subdir": "linux-64", + "timestamp": 1564707041898, + "version": "1.1" + }, + "setuptools_scm_git_archive-1.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d205908b6497a9d10a39cf28e0cc85c", + "name": "setuptools_scm_git_archive", + "sha256": "972629d61ddae1d5c1225e28ffe922d4732394abecdeaf20527b3a341eba35eb", + "size": 7120, + "subdir": "linux-64", + "timestamp": 1640794666184, + "version": "1.1" + }, + "setuptools_scm_git_archive-1.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "027ac23895680daf77bb3be5927e6a0b", + "name": "setuptools_scm_git_archive", + "sha256": "ccc796b523287c9d70751821b5a729d08df2c947761bde8689fc13748417befe", + "size": 7932, + "subdir": "linux-64", + "timestamp": 1676827496702, + "version": "1.1" + }, + "setuptools_scm_git_archive-1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc1e0b53c2dbe350f250ba4041b7f7af", + "name": "setuptools_scm_git_archive", + "sha256": "2a7971f005376ad9e5fef8d4464299cbf0ceb92f661a588bc8d1dad885999ed5", + "size": 7917, + "subdir": "linux-64", + "timestamp": 1564707066977, + "version": "1.1" + }, + "setuptools_scm_git_archive-1.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ebe5a024ca50d2ccce1352aa4d1420c7", + "name": "setuptools_scm_git_archive", + "sha256": "b6ef741a7bf2da740792f17fbd165331dffe45b1c104dde923eb2661f233e1e3", + "size": 8015, + "subdir": "linux-64", + "timestamp": 1611753627837, + "version": "1.1" + }, + "setuptools_scm_git_archive-1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5236877a8857a3a08bb79643122bf923", + "name": "setuptools_scm_git_archive", + "sha256": "3b03838c24d29d3138a4a8f27fc208e41788beab99eb2e96d538615864a4b261", + "size": 7933, + "subdir": "linux-64", + "timestamp": 1564706744935, + "version": "1.1" + }, + "setuptools_scm_git_archive-1.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "042a61d3671e5c4432dd83c14fe1f869", + "name": "setuptools_scm_git_archive", + "sha256": "a5fdf41356ee3ca20d9a98d6b33cd2ecf579526ac5baf8f16c91cee0773fdee0", + "size": 8000, + "subdir": "linux-64", + "timestamp": 1611753504787, + "version": "1.1" + }, + "setuptools_scm_git_archive-1.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "93cb503ce4018236d0e8b6c01727df3a", + "name": "setuptools_scm_git_archive", + "sha256": "92fef8880aff8cb0725156ad6df85f1a52ce887f46fbbfd1d997458ee4664ce4", + "size": 7333, + "subdir": "linux-64", + "timestamp": 1574170623313, + "version": "1.1" + }, + "setuptools_scm_git_archive-1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56f2d0a74e9f981215996bb2b7e9a20d", + "name": "setuptools_scm_git_archive", + "sha256": "5762bfcade33513e920a4b27fd935fcb0c1c83ff27befc0acb988f4940ff07cf", + "size": 8002, + "subdir": "linux-64", + "timestamp": 1611753615975, + "version": "1.1" + }, + "setuptools_scm_git_archive-1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools_scm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d4066d7bf2cbf5b94e25df51a07a7bfb", + "name": "setuptools_scm_git_archive", + "sha256": "3fc1c5eae70923d49279ae7ffae6bcee0acd5b4ae07fa6019ab3325bd0ed6db4", + "size": 8041, + "subdir": "linux-64", + "timestamp": 1611753613887, + "version": "1.1" + }, + "sh-1.12.14-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b04c74e27ca1bb54de541f0e6d48c1c", + "name": "sh", + "sha256": "47bc698648f364f796d05969aea29ca7296e3846a3196bd8976bdb8b89ff29a1", + "size": 61512, + "subdir": "linux-64", + "timestamp": 1530961035359, + "version": "1.12.14" + }, + "sh-1.12.14-py27h3066367_0.conda": { + "build": "py27h3066367_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4a0528c7fdc3c6362858dd2ca3f6e85c", + "name": "sh", + "sha256": "995dc50d0aec6aa9fc9f99f18835c4a479beb54d4aa7b7d72bf495c7cc09006f", + "size": 63057, + "subdir": "linux-64", + "timestamp": 1508445817559, + "version": "1.12.14" + }, + "sh-1.12.14-py35h291aafe_0.conda": { + "build": "py35h291aafe_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5c940d2c288131989900ddb541e9c455", + "name": "sh", + "sha256": "f726d5decdc92c6528175760da16d1e1cb0f7b088d2c95623dcde95ecbd52091", + "size": 62508, + "subdir": "linux-64", + "timestamp": 1508445825366, + "version": "1.12.14" + }, + "sh-1.12.14-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "41c8eccff858f98f57cc6fe6d6991025", + "name": "sh", + "sha256": "349780a5f68db0f58a377a08f72357d3ef201681c2ba2a60a917f401926b28c3", + "size": 61427, + "subdir": "linux-64", + "timestamp": 1530961064821, + "version": "1.12.14" + }, + "sh-1.12.14-py36h4f86635_0.conda": { + "build": "py36h4f86635_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9a78a8851b6d6868b0bb5485a419aafc", + "name": "sh", + "sha256": "1378efe095b5c2d230c34c4a42276406fdcb53fe353d341b0ecba8c2bb1d3e38", + "size": 61696, + "subdir": "linux-64", + "timestamp": 1508445814948, + "version": "1.12.14" + }, + "sh-1.12.14-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48da6ff8a21c48d6ba01993f4f2510c4", + "name": "sh", + "sha256": "1ff30566415d36b8b91dbc6b7e18d50c50c206dcf57475a2b51ab15f82baae41", + "size": 63454, + "subdir": "linux-64", + "timestamp": 1530961095174, + "version": "1.12.14" + }, + "sh-1.12.14-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0278f2b0ef35af676720ab847821638b", + "name": "sh", + "sha256": "ddb65eb40905486ac1d294edf60281fa3342f140c1bee753f4837393684c1550", + "size": 62988, + "subdir": "linux-64", + "timestamp": 1573200407347, + "version": "1.12.14" + }, + "sh-1.14.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a9e501b188cfc18c18c3d92d253b5743", + "name": "sh", + "sha256": "b105217d952fcc10164131a7c0f991f80a4a5ad548a6e56876784e08b561f629", + "size": 66660, + "subdir": "linux-64", + "timestamp": 1600553817491, + "version": "1.14.0" + }, + "sh-1.14.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8bf42f968cef1764bab312924213c2b3", + "name": "sh", + "sha256": "b2c2c8400cc0c23519cb0c8488952ff1e162226d7dc4963bc7b719134d20740e", + "size": 68440, + "subdir": "linux-64", + "timestamp": 1600553840676, + "version": "1.14.0" + }, + "sh-1.14.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0831d34fda8614ee1c0831fe04ca4bd", + "name": "sh", + "sha256": "8637c26307e006edd17d535b690aa6425019d1a7a4373746ea9c7db4f661829b", + "size": 66852, + "subdir": "linux-64", + "timestamp": 1600553824937, + "version": "1.14.0" + }, + "sh-1.14.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9374f7b73ae825aa87bd66995dfee454", + "name": "sh", + "sha256": "0aaa69ca401198cd1f0ab9109b76e336457dcab091b40e754c3578569b3ed585", + "size": 66657, + "subdir": "linux-64", + "timestamp": 1606865054357, + "version": "1.14.1" + }, + "sh-1.14.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "324ae2b59a00b8406637ce21c7f2565b", + "name": "sh", + "sha256": "44730124f2ee7d22b0355ed67b02cb94e9d4f923a1f4172711b8d98a135229c8", + "size": 66703, + "subdir": "linux-64", + "timestamp": 1606865051688, + "version": "1.14.1" + }, + "sh-1.14.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12ec741935183878db665b148734fe61", + "name": "sh", + "sha256": "bcd4dfda5f5e4bc869e0ea08d3e18edeea36171244fd9e9057fe2f242c23918a", + "size": 66930, + "subdir": "linux-64", + "timestamp": 1606865084569, + "version": "1.14.1" + }, + "sh-1.14.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6dd010343bfa37dd1d76845138f95e88", + "name": "sh", + "sha256": "cf33c42f29a881e8ca5495b963e49d24c18647c89c2c4a2c2c3b876171d7db16", + "size": 67941, + "subdir": "linux-64", + "timestamp": 1640794683896, + "version": "1.14.2" + }, + "sh-1.14.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ee7b6b96f189b78cfc458343a2c8557", + "name": "sh", + "sha256": "8f1e93bdccc686e58432f6e2367a080308311793796c77fcdca456340ae0a091", + "size": 91493, + "subdir": "linux-64", + "timestamp": 1676862166219, + "version": "1.14.2" + }, + "sh-1.14.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "761691f68489935fd81307c0a5e3dc65", + "name": "sh", + "sha256": "b325a836b3be5a0d04d6e44df18589444a3f279bb743a60c5d7638fc44db9f9a", + "size": 101893, + "subdir": "linux-64", + "timestamp": 1623833503141, + "version": "1.14.2" + }, + "sh-1.14.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ca71fe5fd31d6fdbb44834dd0894d32", + "name": "sh", + "sha256": "5e2d7e85a19ab42aee78460a04d076830e69d4c7101f7057c3e929a0e8b98f08", + "size": 100626, + "subdir": "linux-64", + "timestamp": 1623827651744, + "version": "1.14.2" + }, + "sh-1.14.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eaea1d86e0a38a2a27789fdcf5715802", + "name": "sh", + "sha256": "2e00ee0e0945c71f3d9d925587f82b43fefac45cb19916e7e33253401c4afa3c", + "size": 101967, + "subdir": "linux-64", + "timestamp": 1623833484415, + "version": "1.14.2" + }, + "sh-1.14.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3dbfec22f1741c37eb00452632678b9b", + "name": "sh", + "sha256": "8b7a74a0a01446fc48e6a5d443b08578d6f4cfc61f4b05087afc79ad735ebba0", + "size": 100829, + "subdir": "linux-64", + "timestamp": 1623832784929, + "version": "1.14.2" + }, + "shap-0.39.0-py310h00e6091_0.conda": { + "build": "py310h00e6091_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "colorama", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numba", + "numpy", + "pandas", + "python >=3.10,<3.11.0a0", + "scikit-learn", + "scipy", + "slicer 0.0.7.*", + "tqdm >4.25.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "27bbb0a5c9d12e44c97b6d4d5dcf8d0a", + "name": "shap", + "sha256": "c82c157fdff304d81c0f9c363249a97e1af55e8be13e549eea9653b059429749", + "size": 581282, + "subdir": "linux-64", + "timestamp": 1640812964445, + "version": "0.39.0" + }, + "shap-0.39.0-py36h51133e4_0.conda": { + "build": "py36h51133e4_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "colorama", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numba", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "scikit-learn", + "scipy", + "slicer 0.0.7.*", + "tqdm >4.25.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8dab63bbbf5a873d9c8b1fd6d001ae43", + "name": "shap", + "sha256": "470df1f2edc867ab013f80c38cc469a2072693f9b7107df2dd40f20e089695a8", + "size": 510280, + "subdir": "linux-64", + "timestamp": 1633430506939, + "version": "0.39.0" + }, + "shap-0.39.0-py37h51133e4_0.conda": { + "build": "py37h51133e4_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "colorama", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numba", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy", + "slicer 0.0.7.*", + "tqdm >4.25.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d438c1f7c7b832c0fda60df7f23538d", + "name": "shap", + "sha256": "a29b65cae78e756071794a50217288f873a930586237db7d7070660e205260f8", + "size": 514342, + "subdir": "linux-64", + "timestamp": 1633430482668, + "version": "0.39.0" + }, + "shap-0.39.0-py38h51133e4_0.conda": { + "build": "py38h51133e4_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "colorama", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numba", + "numpy", + "pandas", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy", + "slicer 0.0.7.*", + "tqdm >4.25.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f4c6db798166fac40512e204dd31ad9c", + "name": "shap", + "sha256": "087a9eb861a88982135bac18fb44bfd95047858184fab90d117f578922f25e1e", + "size": 515900, + "subdir": "linux-64", + "timestamp": 1633419792978, + "version": "0.39.0" + }, + "shap-0.39.0-py39h51133e4_0.conda": { + "build": "py39h51133e4_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "colorama", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numba", + "numpy", + "pandas", + "python >=3.9,<3.10.0a0", + "scikit-learn", + "scipy", + "slicer 0.0.7.*", + "tqdm >4.25.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4bb25fc00ac28eed0f7c725b015808ef", + "name": "shap", + "sha256": "3bac38cbf0d748249e4869a1b88199448e70efa4c3929737e1ebf1c9b4f6bf46", + "size": 512372, + "subdir": "linux-64", + "timestamp": 1633430478958, + "version": "0.39.0" + }, + "shap-0.41.0-py310h1128e8f_0.conda": { + "build": "py310h1128e8f_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numba", + "numpy", + "packaging >20.9", + "pandas", + "python >=3.10,<3.11.0a0", + "scikit-learn", + "scipy", + "slicer 0.0.7.*", + "tqdm >4.25.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d24161987dbcaf8710fe2af9de696c6d", + "name": "shap", + "sha256": "0c48daf59c691307b330b8ba4f4a4e517af46d8bcd4824b9c6163e935e9ffe49", + "size": 566761, + "subdir": "linux-64", + "timestamp": 1668715327960, + "version": "0.41.0" + }, + "shap-0.41.0-py37h417a72b_0.conda": { + "build": "py37h417a72b_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numba", + "numpy", + "packaging >20.9", + "pandas", + "python >=3.7,<3.8.0a0", + "scikit-learn", + "scipy", + "slicer 0.0.7.*", + "tqdm >4.25.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb9785ec5fbd2473afedffd8679714db", + "name": "shap", + "sha256": "a5b7049f06afad25ccd929d0a580e62c64405c5866685b495ca93ed894679559", + "size": 564445, + "subdir": "linux-64", + "timestamp": 1668715537994, + "version": "0.41.0" + }, + "shap-0.41.0-py38h417a72b_0.conda": { + "build": "py38h417a72b_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numba", + "numpy", + "packaging >20.9", + "pandas", + "python >=3.8,<3.9.0a0", + "scikit-learn", + "scipy", + "slicer 0.0.7.*", + "tqdm >4.25.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca7d832198791e4f0a33495af425f670", + "name": "shap", + "sha256": "e511a0edfb8553af0a8cc678dd22b65c09b30d92867d4c30cdd6ee77ed589cc9", + "size": 564751, + "subdir": "linux-64", + "timestamp": 1668715466551, + "version": "0.41.0" + }, + "shap-0.41.0-py39h417a72b_0.conda": { + "build": "py39h417a72b_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numba", + "numpy", + "packaging >20.9", + "pandas", + "python >=3.9,<3.10.0a0", + "scikit-learn", + "scipy", + "slicer 0.0.7.*", + "tqdm >4.25.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "564c87b18f21b865e05282d8c41b4dc9", + "name": "shap", + "sha256": "21fa161b8a15ca62927c3b3fda636de0e5e1d7e83377d3fcb7abfcd6a6c4b330", + "size": 565033, + "subdir": "linux-64", + "timestamp": 1668715399579, + "version": "0.41.0" + }, + "shapely-1.6.2-py27hd647e55_0.conda": { + "build": "py27hd647e55_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2031378c7c5a602772a2ae7b595d2b76", + "name": "shapely", + "sha256": "e45d4964303b653458ba324a0e20ef7d0fd9cb73591709a65957e4a3a9294df9", + "size": 317459, + "subdir": "linux-64", + "timestamp": 1511290504550, + "version": "1.6.2" + }, + "shapely-1.6.2-py35h7e54424_0.conda": { + "build": "py35h7e54424_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2d999fe9c484ae60bd80d031d99313d9", + "name": "shapely", + "sha256": "b3a599769a4c98f042a8f8c25555c6b44f267cba289d3b1661f2985b82694e4d", + "size": 314535, + "subdir": "linux-64", + "timestamp": 1511291063135, + "version": "1.6.2" + }, + "shapely-1.6.2-py36hfae5896_0.conda": { + "build": "py36hfae5896_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "36b77f29e3fb80a0a1eee32f228c4193", + "name": "shapely", + "sha256": "03f0f42428146e83aa3eed01b113b0ee8e71414b26c6a23c837f94f49f0034a1", + "size": 314771, + "subdir": "linux-64", + "timestamp": 1511290992700, + "version": "1.6.2" + }, + "shapely-1.6.4-py27h0c48222_0.conda": { + "build": "py27h0c48222_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9b1c3ae63c74c82fb7611f28a2f263c2", + "name": "shapely", + "sha256": "9ff80f046c8b27c361b4a56b6a73b4b02c22ef11655317c4c3f1d4303b8da42a", + "size": 318909, + "subdir": "linux-64", + "timestamp": 1519758569150, + "version": "1.6.4" + }, + "shapely-1.6.4-py27h7ef4460_0.conda": { + "build": "py27h7ef4460_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b8ca9538faccbd71df093d240eb90fe4", + "name": "shapely", + "sha256": "88a762234e59566e66786e348b0d86c812765f365353836c85f3640130caa114", + "size": 320167, + "subdir": "linux-64", + "timestamp": 1530811488245, + "version": "1.6.4" + }, + "shapely-1.6.4-py27h86c5351_0.conda": { + "build": "py27h86c5351_0", + "build_number": 0, + "depends": [ + "geos >=3.7.1,<3.7.2.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "fc944dbdb1301e906682ed0d56a269c3", + "name": "shapely", + "sha256": "1359fd9fc0885e9ba4b8196381381e6d40cf71ae3467ef8feb790b2469360005", + "size": 317571, + "subdir": "linux-64", + "timestamp": 1545319545019, + "version": "1.6.4" + }, + "shapely-1.6.4-py27hc5e8c75_0.conda": { + "build": "py27hc5e8c75_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "8c172c9b87f1838f72ee081e83e72133", + "name": "shapely", + "sha256": "f0b5db2190489833d0c4a45bd6099971a0331540ba42f1880f617eef31548ad3", + "size": 323647, + "subdir": "linux-64", + "timestamp": 1573751108962, + "version": "1.6.4" + }, + "shapely-1.6.4-py35h0c48222_0.conda": { + "build": "py35h0c48222_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "28c38cae91df3c2fe68b61a60139afaa", + "name": "shapely", + "sha256": "cf8a26e714a99fb5ac23d9ee038deb80e76596a0757184af40f63d8fdb4d4d7b", + "size": 314275, + "subdir": "linux-64", + "timestamp": 1519758488223, + "version": "1.6.4" + }, + "shapely-1.6.4-py35h7ef4460_0.conda": { + "build": "py35h7ef4460_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "514fb22cc651b4810da8771f8cbf0eda", + "name": "shapely", + "sha256": "e917d21e7c25e6381888e73f136559884be20c0a81e6c9c8b0d69151d8071f80", + "size": 314342, + "subdir": "linux-64", + "timestamp": 1535129710774, + "version": "1.6.4" + }, + "shapely-1.6.4-py36h0c48222_0.conda": { + "build": "py36h0c48222_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "95ee993f6013c39e4c0dbf486b03d937", + "name": "shapely", + "sha256": "7555170b8395a12c7d99fc9858f9b047a91ca678c78c9de1962ad0cfa1407ba0", + "size": 315125, + "subdir": "linux-64", + "timestamp": 1519758572723, + "version": "1.6.4" + }, + "shapely-1.6.4-py36h7ef4460_0.conda": { + "build": "py36h7ef4460_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1cf2b3ab5c197be0d710bde20b4722a8", + "name": "shapely", + "sha256": "b52582158966453c1ed408cdab892ded2fbc038669827be752dba2eb1cf3bcde", + "size": 316333, + "subdir": "linux-64", + "timestamp": 1530811585163, + "version": "1.6.4" + }, + "shapely-1.6.4-py36h86c5351_0.conda": { + "build": "py36h86c5351_0", + "build_number": 0, + "depends": [ + "geos >=3.7.1,<3.7.2.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "de28ab284629a5deb08807466f2d1cfc", + "name": "shapely", + "sha256": "15b30dfe37848809e43b43e6809bf810f524ec1b8be5214db139c2351e025817", + "size": 315734, + "subdir": "linux-64", + "timestamp": 1545319580634, + "version": "1.6.4" + }, + "shapely-1.6.4-py36hc5e8c75_0.conda": { + "build": "py36hc5e8c75_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "5b0d7f98a901257a5e8fa8fbf75ae344", + "name": "shapely", + "sha256": "bf052d093206641b3a8a9d3a277c6a51f27eddcf37051bcd64c47f754f885e68", + "size": 324464, + "subdir": "linux-64", + "timestamp": 1573751085706, + "version": "1.6.4" + }, + "shapely-1.6.4-py37h7ef4460_0.conda": { + "build": "py37h7ef4460_0", + "build_number": 0, + "depends": [ + "geos >=3.6.2,<3.6.3.0a0", + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c603030a86cdc00bd20a965a0bad5396", + "name": "shapely", + "sha256": "850b5f539cb5c3ef383e99805b57c7023f9ffca33aa432c95e51ef31561aac47", + "size": 315619, + "subdir": "linux-64", + "timestamp": 1530811536166, + "version": "1.6.4" + }, + "shapely-1.6.4-py37h86c5351_0.conda": { + "build": "py37h86c5351_0", + "build_number": 0, + "depends": [ + "geos >=3.7.1,<3.7.2.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e9fb5546384b67d115b9fd6a5f76c2c8", + "name": "shapely", + "sha256": "93a21db9407bd4c8e71892487d23d80f7afbb3f8cae20bf9930fc52de7c41cba", + "size": 315316, + "subdir": "linux-64", + "timestamp": 1545319594142, + "version": "1.6.4" + }, + "shapely-1.6.4-py37hc5e8c75_0.conda": { + "build": "py37hc5e8c75_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c67fa21d858d8a44175ac149d1f6d3e3", + "name": "shapely", + "sha256": "a73251d9620e87669b3dbbb828be830396241e41e4f99ff7a4e3f17ba5b2884b", + "size": 324327, + "subdir": "linux-64", + "timestamp": 1573751074361, + "version": "1.6.4" + }, + "shapely-1.6.4-py38h86c5351_0.conda": { + "build": "py38h86c5351_0", + "build_number": 0, + "depends": [ + "geos >=3.7.1,<3.7.2.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d4dc9bd645680ec1b6d02bf7340c23b7", + "name": "shapely", + "sha256": "2e9f737937547f629fcd997c35305fb08a4234a99157b3e5bb11489989b4563e", + "size": 321999, + "subdir": "linux-64", + "timestamp": 1573557135513, + "version": "1.6.4" + }, + "shapely-1.6.4-py38hc5e8c75_0.conda": { + "build": "py38hc5e8c75_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ea9f272bc586314a858b72f8d3296cfc", + "name": "shapely", + "sha256": "6310c95639c9aa6d96bee85f4f68261afcf40163dfe0d343f6c6cc936d514749", + "size": 330726, + "subdir": "linux-64", + "timestamp": 1573751118184, + "version": "1.6.4" + }, + "shapely-1.7.0-py310h21a7e75_0.conda": { + "build": "py310h21a7e75_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f3738ede3b67707f1de687f56d583ca0", + "name": "shapely", + "sha256": "08ecb22a77ca0a44aa072633c5bf5a2def8dfb4e5dda94f5620c81d53dcc9f7c", + "size": 700709, + "subdir": "linux-64", + "timestamp": 1640794718579, + "version": "1.7.0" + }, + "shapely-1.7.0-py311h438bf8d_0.conda": { + "build": "py311h438bf8d_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "083705eaa096a46fee6e1b57c5036160", + "name": "shapely", + "sha256": "5201db5876e7c00451e5333fd07ea26d31bd81a7143a0e02a4fafc2c646e805e", + "size": 422945, + "subdir": "linux-64", + "timestamp": 1676842845239, + "version": "1.7.0" + }, + "shapely-1.7.0-py36h7c4d384_0.conda": { + "build": "py36h7c4d384_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "0ca714468d78d0618f77c4b8f313810b", + "name": "shapely", + "sha256": "68c4cf7f5c9e06c96193d2640e9efc4c7b291fd9f7d7ea54d2be3f2e4805dce4", + "size": 391244, + "subdir": "linux-64", + "timestamp": 1613149341140, + "version": "1.7.0" + }, + "shapely-1.7.0-py36h98ec03d_0.conda": { + "build": "py36h98ec03d_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2ec31e39d0c2ce143a6c23b45697239b", + "name": "shapely", + "sha256": "dbadbc772d7d2e0ea27aad49d8c8c46919c5479d6c30ea3c7c083358888b9cb0", + "size": 403803, + "subdir": "linux-64", + "timestamp": 1588545419811, + "version": "1.7.0" + }, + "shapely-1.7.0-py37h7c4d384_0.conda": { + "build": "py37h7c4d384_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "24a20ab0ac354b3815e6c81f91092817", + "name": "shapely", + "sha256": "e47fbba5d2d12febef45dc1ffbfb553fb4457ed7d0dc20b2b5f7135165205ea7", + "size": 391610, + "subdir": "linux-64", + "timestamp": 1613149331506, + "version": "1.7.0" + }, + "shapely-1.7.0-py37h98ec03d_0.conda": { + "build": "py37h98ec03d_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "85dd25f1b7afe9d385fb9963a3366e8a", + "name": "shapely", + "sha256": "71e18c4dacb4904c57edf610c585e49f10b85c829b33e513d915703597d08189", + "size": 402090, + "subdir": "linux-64", + "timestamp": 1588545398700, + "version": "1.7.0" + }, + "shapely-1.7.0-py38h7c4d384_0.conda": { + "build": "py38h7c4d384_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f65f6fd7108cc699f36b50774b7fd7c7", + "name": "shapely", + "sha256": "449d31b70f07334e1e65725250e958baf9a2261378de39883362c57605c790af", + "size": 396695, + "subdir": "linux-64", + "timestamp": 1613148987657, + "version": "1.7.0" + }, + "shapely-1.7.0-py38h98ec03d_0.conda": { + "build": "py38h98ec03d_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "62c27038b6ea58419b6c5ce7ab7ff972", + "name": "shapely", + "sha256": "ac1add7d9d4f8228d8c407c0d4357190bdbbe5ab12844d5b633a4a790bd55a07", + "size": 408052, + "subdir": "linux-64", + "timestamp": 1588545378804, + "version": "1.7.0" + }, + "shapely-1.7.0-py39h7c4d384_0.conda": { + "build": "py39h7c4d384_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "eae85041e1339d3ee5089be9ff85a935", + "name": "shapely", + "sha256": "5bc21ab2648e01d2b835632968ef50acbe71a0ac29053feb44cfbbe0bdf10243", + "size": 398353, + "subdir": "linux-64", + "timestamp": 1613149330693, + "version": "1.7.0" + }, + "shapely-1.7.1-py36h1728cc4_0.conda": { + "build": "py36h1728cc4_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "da7ed4954db967e5d295b507a6a0bf1b", + "name": "shapely", + "sha256": "264c9ba003dad80eb7564670e8dcdb58eff76506d4be0a0602f72a0c632e8833", + "size": 401223, + "subdir": "linux-64", + "timestamp": 1632813589910, + "version": "1.7.1" + }, + "shapely-1.7.1-py36h98ec03d_0.conda": { + "build": "py36h98ec03d_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d36b6183790b93ef64b54d6cd81df9e6", + "name": "shapely", + "sha256": "022d6543c758cc27c32ad11333d7bb75c6de28779f38d936285d12c8ea51d1dd", + "size": 401033, + "subdir": "linux-64", + "timestamp": 1599817156351, + "version": "1.7.1" + }, + "shapely-1.7.1-py37h1728cc4_0.conda": { + "build": "py37h1728cc4_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "5204028d35bea80a97ce10aff1a484e6", + "name": "shapely", + "sha256": "569ac34d9cd6dfff03a917a13c36148261100461b3a7d4d8bfe1f19de1ad4182", + "size": 400245, + "subdir": "linux-64", + "timestamp": 1632813578715, + "version": "1.7.1" + }, + "shapely-1.7.1-py37h98ec03d_0.conda": { + "build": "py37h98ec03d_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d4bc4f2fd2d55b048db5d6766c28f33a", + "name": "shapely", + "sha256": "820758d48c4e6a6873b5dcf54e7a26dd5862ac79309c37293aa4501dd420a1b4", + "size": 399788, + "subdir": "linux-64", + "timestamp": 1599817155661, + "version": "1.7.1" + }, + "shapely-1.7.1-py38h1728cc4_0.conda": { + "build": "py38h1728cc4_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "15417f4150db2a63accfd05fa6cb1a9b", + "name": "shapely", + "sha256": "0dee600637ddad1eff2fdd53a9cf63142d22d7f6d775ac9522c516e4e7f76f38", + "size": 406752, + "subdir": "linux-64", + "timestamp": 1632813570956, + "version": "1.7.1" + }, + "shapely-1.7.1-py38h98ec03d_0.conda": { + "build": "py38h98ec03d_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "016442fc2e83c632128a49c2d1440fea", + "name": "shapely", + "sha256": "66f9f7a75694716be16f3ee6345911318384251e42c2046bf0028af1a401c6a3", + "size": 407406, + "subdir": "linux-64", + "timestamp": 1599817161138, + "version": "1.7.1" + }, + "shapely-1.7.1-py39h1728cc4_0.conda": { + "build": "py39h1728cc4_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2740b5a8895046f1e0c1c808786a1cf2", + "name": "shapely", + "sha256": "cec0ed859abf516ddff25f0eb1b8fa9505afcb99526ef74a8f9fc2d22362d24c", + "size": 406649, + "subdir": "linux-64", + "timestamp": 1632813578598, + "version": "1.7.1" + }, + "shapely-1.8.4-py310h81ba7c5_0.conda": { + "build": "py310h81ba7c5_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5a07911fed8d3ec0a7d89ed81dde8e04", + "name": "shapely", + "sha256": "5e8b3289ce40bb9b68a9df9cfb0e60f8279139fd959cb119d27a4f7326eab5bd", + "size": 779622, + "subdir": "linux-64", + "timestamp": 1664521670000, + "version": "1.8.4" + }, + "shapely-1.8.4-py37h81ba7c5_0.conda": { + "build": "py37h81ba7c5_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6c71badc0d91b922b58655d1c889c080", + "name": "shapely", + "sha256": "d8f05f92adf58b0381d226b948f4e7f895ecf0dc70c302b0a49b4b64752e079b", + "size": 347465, + "subdir": "linux-64", + "timestamp": 1664521829763, + "version": "1.8.4" + }, + "shapely-1.8.4-py38h81ba7c5_0.conda": { + "build": "py38h81ba7c5_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "26f6868a7c3aa4e5477829b9cd06fba3", + "name": "shapely", + "sha256": "f3b2160f50f9ac209c570525a664733be1540344b42a62bebd022740bf507390", + "size": 354444, + "subdir": "linux-64", + "timestamp": 1664521722260, + "version": "1.8.4" + }, + "shapely-1.8.4-py39h81ba7c5_0.conda": { + "build": "py39h81ba7c5_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "acdb47dcadff59cf076ee39b2a0f4696", + "name": "shapely", + "sha256": "8d6f5af39f78e9bc2b4fac8edf026c604500d3f2e7856c14abad36f23afd382d", + "size": 353392, + "subdir": "linux-64", + "timestamp": 1664521776613, + "version": "1.8.4" + }, + "shapely-2.0.1-py310h006c72b_0.conda": { + "build": "py310h006c72b_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "21acbbf27fead974edb8932a249a7f6d", + "name": "shapely", + "sha256": "76a8e6e974d159021a3c38ea88ba0aa53c70989f618a583433e5cfc6065784b7", + "size": 443755, + "subdir": "linux-64", + "timestamp": 1680636339258, + "version": "2.0.1" + }, + "shapely-2.0.1-py311h24a2a10_0.conda": { + "build": "py311h24a2a10_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5dc72cdfdd92302f1e045e4a90042a46", + "name": "shapely", + "sha256": "4c8455a58ecf9990e42386b466b1a5d4153537186de336623840ef5e80883979", + "size": 517436, + "subdir": "linux-64", + "timestamp": 1680636507282, + "version": "2.0.1" + }, + "shapely-2.0.1-py38h0fbb895_0.conda": { + "build": "py38h0fbb895_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d2264bd2eb517ca6f504d871912593b5", + "name": "shapely", + "sha256": "d6635cd53bcfc0fad609048e31e02d7441632a91b60f4ddb09ca9cd9108a1aaf", + "size": 447387, + "subdir": "linux-64", + "timestamp": 1680636395435, + "version": "2.0.1" + }, + "shapely-2.0.1-py39h0fbb895_0.conda": { + "build": "py39h0fbb895_0", + "build_number": 0, + "depends": [ + "geos >=3.8.0,<3.8.1.0a0", + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "572a080c862b523277218b7f301de9b1", + "name": "shapely", + "sha256": "7697d284d689392f2bfc1dc69eaa66de18dea6516fbe436a7fb88788768882cb", + "size": 443772, + "subdir": "linux-64", + "timestamp": 1680636451813, + "version": "2.0.1" + }, + "shellcheck-0.7.1-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "90411aa97656171f738b9f7a2522a598", + "name": "shellcheck", + "sha256": "6f78749fbebc7d062566a58ce4d42ddbdb3776559a49bd07ba421368449da848", + "size": 1574065, + "subdir": "linux-64", + "timestamp": 1598387406337, + "version": "0.7.1" + }, + "shellcheck-0.7.2-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "871817e1bfcf3a322f24459a9e3f8dec", + "name": "shellcheck", + "sha256": "8576ec351ebe856b82e1eef485f1545cddb2126c3f349bb74a3afe7c4963f449", + "size": 1506544, + "subdir": "linux-64", + "timestamp": 1619436827733, + "version": "0.7.2" + }, + "shellcheck-0.7.2-h06a4308_1.conda": { + "build": "h06a4308_1", + "build_number": 1, + "depends": [], + "license": "GPL-3.0", + "license_family": "GPL", + "md5": "774eabfeafeca6fc10644687323d8875", + "name": "shellcheck", + "sha256": "31bc19aa320b00b98851d0af45f03896cdf349e155ea27c5d376d1bb5c4abb29", + "size": 1505117, + "subdir": "linux-64", + "timestamp": 1619439978714, + "version": "0.7.2" + }, + "shellingham-1.5.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "bc1ee3249086c74f8e57dad73557005a", + "name": "shellingham", + "sha256": "81a36ebc4f92d3b93a21babc38d84f825a0493abd21a232bc429809cf74b0f2e", + "size": 18197, + "subdir": "linux-64", + "timestamp": 1669142272317, + "version": "1.5.0" + }, + "shellingham-1.5.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "6f99eb98e3fb627309344cb4dfc2eb68", + "name": "shellingham", + "sha256": "acd4a4047b7495d3451a8d1e47cc6e533db6573564ba165cda4b5c5e56a7a34e", + "size": 21283, + "subdir": "linux-64", + "timestamp": 1676823217089, + "version": "1.5.0" + }, + "shellingham-1.5.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "8a26d3f9213686b0876e39e2ed493954", + "name": "shellingham", + "sha256": "65bca72495b116fac96f225a28bc99d1ada6fbeb3f043e68a420c00738490591", + "size": 18036, + "subdir": "linux-64", + "timestamp": 1669142247741, + "version": "1.5.0" + }, + "shellingham-1.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "14bcfba0d920e8a90521da7854a0d39c", + "name": "shellingham", + "sha256": "b689299d9875abd7a5e71d143ddc7e78351276d4f673041293bd54660bdb9aa4", + "size": 18096, + "subdir": "linux-64", + "timestamp": 1669142222916, + "version": "1.5.0" + }, + "shellingham-1.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "3042055ac0996142ed51ff25ce5163ba", + "name": "shellingham", + "sha256": "7ec6d1e76a9a775bc79586179d94fc11b9863c9d3040899ea9c48c01a9d9cfd4", + "size": 18084, + "subdir": "linux-64", + "timestamp": 1669142198319, + "version": "1.5.0" + }, + "simpervisor-0.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "45b1d9123d5acf5aa9dfbb38fb7d3f47", + "name": "simpervisor", + "sha256": "92ca582b5d982477271ffc4b04381978bbcb47729fdcca3d71f1cae46d5d1c47", + "size": 14203, + "subdir": "linux-64", + "timestamp": 1678869242138, + "version": "0.4" + }, + "simpervisor-0.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5645536278b7354bff6ca7916131043d", + "name": "simpervisor", + "sha256": "c0afc99af989a233ba56190f4bd0b4ca2d9812eb09c233f435a3e8c6c67539ef", + "size": 15934, + "subdir": "linux-64", + "timestamp": 1678959786878, + "version": "0.4" + }, + "simpervisor-0.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "58f4ed30e089b1a2a6b9cc635ab91505", + "name": "simpervisor", + "sha256": "6c604ce08595630ecc1f72f39b4e75832d6e9fd045216554c1f06cff6d8e38bf", + "size": 14078, + "subdir": "linux-64", + "timestamp": 1678869289761, + "version": "0.4" + }, + "simpervisor-0.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "756fe6f99ba01e9f96114f50ba8d09e8", + "name": "simpervisor", + "sha256": "6ab3a9465e726dbb5707b43a7fc0d144010b559b42a784741d5d36a7d6df0a84", + "size": 14111, + "subdir": "linux-64", + "timestamp": 1678869265376, + "version": "0.4" + }, + "simplegeneric-0.8.1-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Zope Public", + "md5": "1abc05ab14c01db8405836bc36050884", + "name": "simplegeneric", + "sha256": "8346f26d996a6061635ff7641e5f66b218dca3b1c49246ec660f8e9399312dfa", + "size": 9822, + "subdir": "linux-64", + "timestamp": 1518031044737, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py27h19e43cd_0.conda": { + "build": "py27h19e43cd_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Zope Public", + "md5": "b339e5d022379957caa9b9b09dee4aaa", + "name": "simplegeneric", + "sha256": "a7e5d015abb86528800f762ea7a2bd160782534892aebf1c048fa481412e381b", + "size": 9466, + "subdir": "linux-64", + "timestamp": 1505690370417, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Zope Public", + "md5": "743f15ff4f853de0a9bb3e843486bd72", + "name": "simplegeneric", + "sha256": "e03432030ab43ffb610f142342bdd951e578bdba1a9d0d3e03d692b065cfc92e", + "size": 9907, + "subdir": "linux-64", + "timestamp": 1640794737413, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py311h06a4308_2.conda": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Zope Public", + "md5": "c8abd578d350336116227733bf754942", + "name": "simplegeneric", + "sha256": "b3c5b7b6bccd2108374bd9fa0430a8a7b4052558b9b1db86f59abc939163446d", + "size": 11266, + "subdir": "linux-64", + "timestamp": 1676862180253, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Zope Public", + "md5": "5f16e02db788b8109481768673da7447", + "name": "simplegeneric", + "sha256": "64ea772b6fbb1b617abecbdc24cc210bd27215514501d1fe4647e9c23d40732f", + "size": 9944, + "subdir": "linux-64", + "timestamp": 1518030856175, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py35h2ec4104_0.conda": { + "build": "py35h2ec4104_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Zope Public", + "md5": "8160cdf7695214698c31ae141039a9dd", + "name": "simplegeneric", + "sha256": "a515c9051a58663391f5700880a4245aba1b8d7781a762032c1ba79c2aff383e", + "size": 9541, + "subdir": "linux-64", + "timestamp": 1505690381203, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Zope Public", + "md5": "0fea1ddc3263f576150246ee68c842b2", + "name": "simplegeneric", + "sha256": "deb51e03bbcc03bcadfc0d83697762b8d05ebc51fcac71260f9d71c7eb7f7415", + "size": 9851, + "subdir": "linux-64", + "timestamp": 1518031419901, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py36h2cb9092_0.conda": { + "build": "py36h2cb9092_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Zope Public", + "md5": "b90ec69ec152abb3862cb3af268d8531", + "name": "simplegeneric", + "sha256": "b495db7a3d88dc5f048d777cd7ae8d22952c6686c3d70076162309406acd66f7", + "size": 9497, + "subdir": "linux-64", + "timestamp": 1505690392176, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Zope Public", + "md5": "a4362900daca3e89305b5a1f4b25a52e", + "name": "simplegeneric", + "sha256": "2b8ca639b5a237875ae93580356959007726e4d672ab5ff84497dab5e6860c91", + "size": 9736, + "subdir": "linux-64", + "timestamp": 1530694779790, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py38_2.conda": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Zope Public", + "md5": "da9542bf401604cfec6c4d14757b45a8", + "name": "simplegeneric", + "sha256": "a8954a6a0b595122e96f638dae520960063d014725b8ab7842938fe299f7486c", + "size": 10182, + "subdir": "linux-64", + "timestamp": 1573200417114, + "version": "0.8.1" + }, + "simplegeneric-0.8.1-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Zope Public", + "md5": "d6f98c4a9963a71fb20a214aef740bb8", + "name": "simplegeneric", + "sha256": "9cfd59dd03651228c8d404688fd6fb17418ea988ef85366a0ec5bffe95850eaa", + "size": 11284, + "subdir": "linux-64", + "timestamp": 1607570616595, + "version": "0.8.1" + }, + "simplejson-3.12.0-py27h264bab0_0.conda": { + "build": "py27h264bab0_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a3c60d956ef5481ea427e08894b7943", + "name": "simplejson", + "sha256": "6b74af9066931dfd13428e9b6d68a936577197dd0848f9b19bc4d592e8f6bc6e", + "size": 78205, + "subdir": "linux-64", + "timestamp": 1511319909117, + "version": "3.12.0" + }, + "simplejson-3.12.0-py35h592e862_0.conda": { + "build": "py35h592e862_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "82e71b7cc35b6ae2a93cd369e3529912", + "name": "simplejson", + "sha256": "c036a1fbf6ea3d605dcd4f9c841b035136a1211a78b295a19023dc4591888b80", + "size": 79227, + "subdir": "linux-64", + "timestamp": 1511319909627, + "version": "3.12.0" + }, + "simplejson-3.12.0-py36h5dd3b74_0.conda": { + "build": "py36h5dd3b74_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e1fa7d94839ebae1d107c97048ede40c", + "name": "simplejson", + "sha256": "bbe3052a0567e56a56fcb8beb80dac2d534d33bb5778241add3adc2fa2d3b216", + "size": 77465, + "subdir": "linux-64", + "timestamp": 1511319912613, + "version": "3.12.0" + }, + "simplejson-3.13.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e393791986fbede0e224756134feda5b", + "name": "simplejson", + "sha256": "cde988fc3856115cf15d810011f3e5327342e825bdd7e8bef55cd059f3c4fd22", + "size": 78725, + "subdir": "linux-64", + "timestamp": 1519674022769, + "version": "3.13.2" + }, + "simplejson-3.13.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b22d5c0bdb2094606f32961c673d0859", + "name": "simplejson", + "sha256": "7b16da0cfe189ce3a15d0530edef483ed320a758320f7380572022f6a35df329", + "size": 79752, + "subdir": "linux-64", + "timestamp": 1519673718107, + "version": "3.13.2" + }, + "simplejson-3.13.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d5273866f30f09a2936215c5024c00b", + "name": "simplejson", + "sha256": "076599b7139b6746abd333a4d4cd5a49816e62da73ac9e97d9145572cba4d0f3", + "size": 78880, + "subdir": "linux-64", + "timestamp": 1519674220038, + "version": "3.13.2" + }, + "simplejson-3.14.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b3a73e5f92ee55854b602bfcd0b624a2", + "name": "simplejson", + "sha256": "74d4a1a1cabda01671af5060e520297f094fe61bf7ff1988ef76e8de27271a28", + "size": 98049, + "subdir": "linux-64", + "timestamp": 1524509480628, + "version": "3.14.0" + }, + "simplejson-3.14.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "393eb0ae64e27033f344be9bd5fd8006", + "name": "simplejson", + "sha256": "604e2e1b42bb6689703e4ae004ab479ea52606293f7d023df6e85b1cfa22d84c", + "size": 97878, + "subdir": "linux-64", + "timestamp": 1524509497258, + "version": "3.14.0" + }, + "simplejson-3.14.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "91920901311a3b3bfd9ed881fef87d01", + "name": "simplejson", + "sha256": "e938d116696fc461df028dbd36a19406b88d746224a36d0502d6fa99ac7e742f", + "size": 96778, + "subdir": "linux-64", + "timestamp": 1524509503266, + "version": "3.14.0" + }, + "simplejson-3.15.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6445ff54487a279a998622d827e8740b", + "name": "simplejson", + "sha256": "01d34956846802b5d5bdce7f55b36d684bfe020c8942f9edceed95e892dcf609", + "size": 101096, + "subdir": "linux-64", + "timestamp": 1526918311724, + "version": "3.15.0" + }, + "simplejson-3.15.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7ed22fa6682104e6343f186e15e7c2a", + "name": "simplejson", + "sha256": "f12d1c51ca6bfa2fdc27c1fbe4f0f391b9bcff8f0c3fb96a96e5be48c02d83e8", + "size": 100940, + "subdir": "linux-64", + "timestamp": 1526917989203, + "version": "3.15.0" + }, + "simplejson-3.15.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4999f88eaec79d09ef39c06ef06497a", + "name": "simplejson", + "sha256": "34d5726a3d40050d18f8a49dc5b91e387a91bb7273a2bab6a574cc3175b702cf", + "size": 100318, + "subdir": "linux-64", + "timestamp": 1526918327960, + "version": "3.15.0" + }, + "simplejson-3.15.0-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dfa94a8a255e648b2e376f6699639e48", + "name": "simplejson", + "sha256": "779ae3cfb68d48249e7378705522d48de78e5db1ebaa923494801ca8f35349da", + "size": 99774, + "subdir": "linux-64", + "timestamp": 1530737668876, + "version": "3.15.0" + }, + "simplejson-3.16.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c6f35fa33276e3141d4956217622a374", + "name": "simplejson", + "sha256": "0257ca11a48a700d4f7c6df57d7b69bc25aac5496684b6940d724928f6b85a2b", + "size": 101261, + "subdir": "linux-64", + "timestamp": 1532619211603, + "version": "3.16.0" + }, + "simplejson-3.16.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52ff1e66971ef19bdffc459b018a5558", + "name": "simplejson", + "sha256": "f444291351e29a5f081190688d5aab608ad356e3fb9c07a761b0fca9a3db417b", + "size": 101054, + "subdir": "linux-64", + "timestamp": 1532619223837, + "version": "3.16.0" + }, + "simplejson-3.16.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ae41dea6ef155d4c5a18b18a04e890f", + "name": "simplejson", + "sha256": "6ec4a6b1bd1feb2400efa5b7225a5fff410cf8b0c6cddfbaf45accd4bffe6c1b", + "size": 100650, + "subdir": "linux-64", + "timestamp": 1532619152649, + "version": "3.16.0" + }, + "simplejson-3.16.0-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ffd245cc6f2eb4369f4b298f528c5cde", + "name": "simplejson", + "sha256": "39ca79e668a916890a2ef838f67bbaad0b218967717f08845a460db53025c6a6", + "size": 100382, + "subdir": "linux-64", + "timestamp": 1532619230308, + "version": "3.16.0" + }, + "simplejson-3.16.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14d74ed0fced537839b6a90d3d25554a", + "name": "simplejson", + "sha256": "0a50f92076c2f19f0f17a3330ced99f6659b8452895db308e66dac03997b3d0e", + "size": 108774, + "subdir": "linux-64", + "timestamp": 1573200435027, + "version": "3.16.0" + }, + "simplejson-3.17.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b68e46bb82000429c7f4c900f37c1fc7", + "name": "simplejson", + "sha256": "a46c218d31e9b2db16786e289c71ba5019081f974968433dbf1d4f9074eb20be", + "size": 104747, + "subdir": "linux-64", + "timestamp": 1574364779896, + "version": "3.17.0" + }, + "simplejson-3.17.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f641c5f924d375a00ce22466bf1d2306", + "name": "simplejson", + "sha256": "398fd75db605e0688663b3749aa9efd3311ffb35fab44f955671369341bd9de5", + "size": 101869, + "subdir": "linux-64", + "timestamp": 1613470862278, + "version": "3.17.0" + }, + "simplejson-3.17.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f113490caf739e1a7b138f4aeec1e71", + "name": "simplejson", + "sha256": "eaa44ba351f810b5614ad87ca83a2e78dd9c764149d854739556513e70e92caf", + "size": 103091, + "subdir": "linux-64", + "timestamp": 1574364800212, + "version": "3.17.0" + }, + "simplejson-3.17.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "425eae511151d550b281000adb5944a2", + "name": "simplejson", + "sha256": "2dd401bed091717f1567524c9fb799474d71b458aeb724f195075cca488145a0", + "size": 102947, + "subdir": "linux-64", + "timestamp": 1613470713727, + "version": "3.17.0" + }, + "simplejson-3.17.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "543bfea4f90a9c97b18c3d1bd07a0d14", + "name": "simplejson", + "sha256": "6370c2676c83c4e6e29d23b4976d4a8176c942c4dda6232f16870a045b0c79c6", + "size": 103049, + "subdir": "linux-64", + "timestamp": 1574364765619, + "version": "3.17.0" + }, + "simplejson-3.17.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a5be7eca8458183805fc48515d9917c6", + "name": "simplejson", + "sha256": "25cad9dc5a97cfc066507c22ad0a008e193f48be44899ae230ee40b97fbf3692", + "size": 104144, + "subdir": "linux-64", + "timestamp": 1613470867577, + "version": "3.17.0" + }, + "simplejson-3.17.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f7c0f4427da1a30c3c10c8ab8d440fb", + "name": "simplejson", + "sha256": "f7c2d4b23c09c511a24a8fa087ad777b932829ed8a7a5175cf8664b27fd6a2d6", + "size": 111121, + "subdir": "linux-64", + "timestamp": 1574364823453, + "version": "3.17.0" + }, + "simplejson-3.17.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0393a4d8381c364b66bce7bceb19edb", + "name": "simplejson", + "sha256": "5e99c4789907364a29df7ac362daa9d46f54dbff9ba8f7dc8c201f0421be4891", + "size": 104191, + "subdir": "linux-64", + "timestamp": 1613470859863, + "version": "3.17.0" + }, + "simplejson-3.17.2-py36h27cfd23_2.conda": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48571b7368b694a6226982c368d1f0b0", + "name": "simplejson", + "sha256": "14a6b67f569974fc68aa075183ae5cb5fe85de98a0e59b0e276e4141b379e1f7", + "size": 105228, + "subdir": "linux-64", + "timestamp": 1614003837317, + "version": "3.17.2" + }, + "simplejson-3.17.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7da61b7fa09148a86e7f5e1c5599816b", + "name": "simplejson", + "sha256": "1cb3c86c59e7954b5902cedfcd01e0bd062debe109f19662eb34cefb468ee88f", + "size": 104652, + "subdir": "linux-64", + "timestamp": 1598626002450, + "version": "3.17.2" + }, + "simplejson-3.17.2-py37h27cfd23_2.conda": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "449cb79576c76dc2199ab1c9247510c0", + "name": "simplejson", + "sha256": "fcee961782f0cf87a5945a06b2208a8e680cfa1fa615d731712944077f5f2a7b", + "size": 104779, + "subdir": "linux-64", + "timestamp": 1614003832999, + "version": "3.17.2" + }, + "simplejson-3.17.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0b61f0f50c18f68e95c274716885e15", + "name": "simplejson", + "sha256": "f04a19de3bb70592be1bc4bae6e0902952cbbf629b2be73aa8a505d11baaf27a", + "size": 103934, + "subdir": "linux-64", + "timestamp": 1598625992173, + "version": "3.17.2" + }, + "simplejson-3.17.2-py38h27cfd23_2.conda": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5a525b1d9580bca773f0e80fb8757ef8", + "name": "simplejson", + "sha256": "489aed1fc22ede8cd02d140571971f8777f917cc8ae76dfc45ea2b2eeedc21eb", + "size": 105884, + "subdir": "linux-64", + "timestamp": 1614003833056, + "version": "3.17.2" + }, + "simplejson-3.17.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5cb69f83be5f3ad4ddf495cc11cafbed", + "name": "simplejson", + "sha256": "88b42cad06a8af969fc41d5e42d377940a288186fbfabf1b74f572dd9b986f33", + "size": 105075, + "subdir": "linux-64", + "timestamp": 1598625997853, + "version": "3.17.2" + }, + "simplejson-3.17.2-py39h27cfd23_2.conda": { + "build": "py39h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df847019638309a2183ec88b48e7e97b", + "name": "simplejson", + "sha256": "98e61cef38a03726f5123e29c22afedb064ce08a9d053761b1044b965247339d", + "size": 106238, + "subdir": "linux-64", + "timestamp": 1614003843305, + "version": "3.17.2" + }, + "simplejson-3.17.3-py36h7f8727e_2.conda": { + "build": "py36h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "908d20d12cac7ca1f2ca61242fe8176f", + "name": "simplejson", + "sha256": "fec5bef6623f453133f8af64bf24efb50c77c017f4c046b0dc94ec5983691d8a", + "size": 101297, + "subdir": "linux-64", + "timestamp": 1626446578448, + "version": "3.17.3" + }, + "simplejson-3.17.3-py37h7f8727e_2.conda": { + "build": "py37h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0829fd09eb44e67ace723a858a8be65", + "name": "simplejson", + "sha256": "4d65ce574e8ded1e4afbaa153f0e1e0c82b06137f2ef7daad2b7a7da01f8ed42", + "size": 100331, + "subdir": "linux-64", + "timestamp": 1626446560312, + "version": "3.17.3" + }, + "simplejson-3.17.3-py38h7f8727e_2.conda": { + "build": "py38h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b685bbff1f09e76f42b33a4478e6b84", + "name": "simplejson", + "sha256": "618ca6c4b2cc8be25d866b6e4f05f40fe0594239a062a87ac702f82cea8cf540", + "size": 102219, + "subdir": "linux-64", + "timestamp": 1626446362815, + "version": "3.17.3" + }, + "simplejson-3.17.3-py39h7f8727e_2.conda": { + "build": "py39h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b99b6020b46158abbd7f916bab0d300", + "name": "simplejson", + "sha256": "08aca440584ca691b531385a11a00b79a6adc129f3487ff0a5c88e41cb98acc2", + "size": 101872, + "subdir": "linux-64", + "timestamp": 1626446570452, + "version": "3.17.3" + }, + "simplejson-3.17.6-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11132cc87cc37366961f597681d8dc67", + "name": "simplejson", + "sha256": "07d6c0295283f45d3cb8aa2d7d34849ab91a6e86ebcbf3824b05ef29bb501b48", + "size": 140604, + "subdir": "linux-64", + "timestamp": 1640794762209, + "version": "3.17.6" + }, + "simplejson-3.17.6-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "10c8c880d996575b41513ed25107868d", + "name": "simplejson", + "sha256": "502649cc072a1222d98728c4ea928cd8ca02f7938950cce82d59568fcd2f96e7", + "size": 130783, + "subdir": "linux-64", + "timestamp": 1676845797385, + "version": "3.17.6" + }, + "simplejson-3.17.6-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a03e087c58c4385f2d89e0a9584e64f7", + "name": "simplejson", + "sha256": "9ba81efe708028cf4ae54eafe74378ccc9bc95e256b15c8d64f3431cdc7cf214", + "size": 105565, + "subdir": "linux-64", + "timestamp": 1639127229059, + "version": "3.17.6" + }, + "simplejson-3.17.6-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48a5696e94f143fb7c2598d470704f27", + "name": "simplejson", + "sha256": "1e9c951625f1c7bcd1209c36b2e6aadee5e52b2f0b9f5cf7ff3d881130b4609c", + "size": 107355, + "subdir": "linux-64", + "timestamp": 1639140815978, + "version": "3.17.6" + }, + "simplejson-3.17.6-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a61d9a6d0b32afdcc1e183e45199b50", + "name": "simplejson", + "sha256": "4a2b470ca3bbaf0951a49e62d2ae9987cedf3a0117483e6f9432efccdaeb6894", + "size": 106344, + "subdir": "linux-64", + "timestamp": 1639122697806, + "version": "3.17.6" + }, + "singledispatch-3.4.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "ded707de50536d378860530d501b2074", + "name": "singledispatch", + "sha256": "5cb5632b7fd206d649919bff5bfe8029f789e9547ceed114800543ddd9592f25", + "size": 15832, + "subdir": "linux-64", + "timestamp": 1530735230353, + "version": "3.4.0.3" + }, + "singledispatch-3.4.0.3-py27h9bcb476_0.conda": { + "build": "py27h9bcb476_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "439ae043d6e73636f647a091b8b6b072", + "name": "singledispatch", + "sha256": "05abd195f7c371808941cab03a89427662be07fa2c5319491dcf26e5f4582688", + "size": 15612, + "subdir": "linux-64", + "timestamp": 1505690466797, + "version": "3.4.0.3" + }, + "singledispatch-3.4.0.3-py35h0cd4ec3_0.conda": { + "build": "py35h0cd4ec3_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "ba44cdb6ffd4dcaa517b776ac66e43c9", + "name": "singledispatch", + "sha256": "df5e86ce1cff7b956e54032097968fe8c3476f41d8b88771dcb0526dcacbca94", + "size": 15839, + "subdir": "linux-64", + "timestamp": 1505690477844, + "version": "3.4.0.3" + }, + "singledispatch-3.4.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "4ba5817eb284d97eb73fdaceead33415", + "name": "singledispatch", + "sha256": "57590d6346c2feb51d17c0b1424ca1e8e3c9110a7b69928b8b474bb6d3384d98", + "size": 15895, + "subdir": "linux-64", + "timestamp": 1530735209967, + "version": "3.4.0.3" + }, + "singledispatch-3.4.0.3-py36h7a266c3_0.conda": { + "build": "py36h7a266c3_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "8026e4b10a33ae1075160c25273dd9eb", + "name": "singledispatch", + "sha256": "4b9198db3ea1400aee890a1057e7230c37bc83ec62a70381b9fab466bcd0a38b", + "size": 15707, + "subdir": "linux-64", + "timestamp": 1505690488981, + "version": "3.4.0.3" + }, + "singledispatch-3.4.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "a3791c28e0d23cfc7b392f9517ea05c9", + "name": "singledispatch", + "sha256": "3a6f6437712623ff36ea7dc76abec17f7a63f558428f8c20faaa9b4c24a3fd3a", + "size": 15985, + "subdir": "linux-64", + "timestamp": 1530735251011, + "version": "3.4.0.3" + }, + "singledispatch-3.4.0.3-py37_1000.conda": { + "build": "py37_1000", + "build_number": 1000, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "dafb29b3a95c677f19b4ddf8c8fe6053", + "name": "singledispatch", + "sha256": "2735fb8d11e22b169bda4b3a1b5b1ace1a2f9590fed5974be7572f4e560fb2a3", + "size": 15628, + "subdir": "linux-64", + "timestamp": 1597002549088, + "version": "3.4.0.3" + }, + "singledispatch-3.4.0.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "md5": "8940b3861b8107668b847b7c147e6384", + "name": "singledispatch", + "sha256": "245441622580ecdc66c0dcd022ff4c997756821a3d0a976bf198a2bf444432be", + "size": 16468, + "subdir": "linux-64", + "timestamp": 1573557156486, + "version": "3.4.0.3" + }, + "sip-4.18.1-py27he9ba0ab_2.conda": { + "build": "py27he9ba0ab_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-3.0", + "md5": "7cd2e5c8eeb65c7950d8cd9d18ec0d42", + "name": "sip", + "sha256": "b73de3d15b92368235bced35420652c2762a639f102cf49607f810528c62cef6", + "size": 269139, + "subdir": "linux-64", + "timestamp": 1505733898462, + "version": "4.18.1" + }, + "sip-4.18.1-py27hf484d3e_2.conda": { + "build": "py27hf484d3e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-3.0", + "md5": "fddc440962f6868a80ea04c15b6bd29e", + "name": "sip", + "sha256": "a9d90a3f3ef8253e8e6aee525c774a3b3913467e1db5fea1e17043310e43390d", + "size": 269488, + "subdir": "linux-64", + "timestamp": 1530795626475, + "version": "4.18.1" + }, + "sip-4.18.1-py35h9eaea60_2.conda": { + "build": "py35h9eaea60_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL-3.0", + "md5": "0a84f49e55560d02afd280347ad7bd95", + "name": "sip", + "sha256": "7924d791483dd7a5f495b27f01c32126d992e2b27a4f94dcf98e645b1e8e773b", + "size": 267907, + "subdir": "linux-64", + "timestamp": 1505733924941, + "version": "4.18.1" + }, + "sip-4.18.1-py35hf484d3e_2.conda": { + "build": "py35hf484d3e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL-3.0", + "md5": "b4e4dd8ed5e3671f0b5159f986c2d4fe", + "name": "sip", + "sha256": "4d8b29d082877516e841cf83e61b70361a773dd8f1ebdf8deba809b4ab33b015", + "size": 268969, + "subdir": "linux-64", + "timestamp": 1535112189392, + "version": "4.18.1" + }, + "sip-4.18.1-py36h295c915_2.conda": { + "build": "py36h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "89b6bfc476094b6968e8029199866f61", + "name": "sip", + "sha256": "4c4f1835f50126dfaa9bf83c02aeb07253324d457c82f2675f64b48ddda4f48c", + "size": 268714, + "subdir": "linux-64", + "timestamp": 1632839605028, + "version": "4.18.1" + }, + "sip-4.18.1-py36h51ed4ed_2.conda": { + "build": "py36h51ed4ed_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "8517b11feab06ba2f93750b17fb6282a", + "name": "sip", + "sha256": "35e97b01692176e39bbf3bf9e4c8b39a55c65982bcfc783cfc187c3ed45cec1b", + "size": 267127, + "subdir": "linux-64", + "timestamp": 1505733951555, + "version": "4.18.1" + }, + "sip-4.18.1-py36hf484d3e_2.conda": { + "build": "py36hf484d3e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "b319045dab54e31252dcaed16128a53b", + "name": "sip", + "sha256": "761ad89f05d6c45056b8b68950b5698f70c074f1cc5e56b81375162c9adbeaca", + "size": 267418, + "subdir": "linux-64", + "timestamp": 1530795665443, + "version": "4.18.1" + }, + "sip-4.18.1-py37h295c915_2.conda": { + "build": "py37h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "1d00290636591097a2bd98e8908ac649", + "name": "sip", + "sha256": "41abc3bb227e0bb3c323e9c40deb751728513bb2748d45f7224695771b93bfca", + "size": 267327, + "subdir": "linux-64", + "timestamp": 1632839575871, + "version": "4.18.1" + }, + "sip-4.18.1-py37hf484d3e_2.conda": { + "build": "py37hf484d3e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "623c3814c5c9d1c076b3098a937e2240", + "name": "sip", + "sha256": "766aa7e4509732db07235038399e05b231a7ed0e981c931cf4ca560f020822f0", + "size": 267303, + "subdir": "linux-64", + "timestamp": 1530795704476, + "version": "4.18.1" + }, + "sip-4.18.1-py38h295c915_2.conda": { + "build": "py38h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "md5": "20d4a825b9b27cc36a518351bc15c1cc", + "name": "sip", + "sha256": "6bcd978c5dae83eab8741ef6f1387bb07082b361446adbf09eef60bfe7c83989", + "size": 268993, + "subdir": "linux-64", + "timestamp": 1632839848372, + "version": "4.18.1" + }, + "sip-4.18.1-py39h295c915_2.conda": { + "build": "py39h295c915_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-3.0", + "md5": "427e93659db44c20eddcf2b07725db2e", + "name": "sip", + "sha256": "189bc81993819750542c5bffe9d7d80c130ba757f367cfb1a0a1749175b0829e", + "size": 267446, + "subdir": "linux-64", + "timestamp": 1632829187507, + "version": "4.18.1" + }, + "sip-4.19.12-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-3.0", + "md5": "7d1369c586a8d2d4673f81232bbe74a4", + "name": "sip", + "sha256": "7ac54a1c956b0829589a5e61983eda307d1123b6817d2a215decc386018e4ae0", + "size": 283597, + "subdir": "linux-64", + "timestamp": 1535397440107, + "version": "4.19.12" + }, + "sip-4.19.12-py35he6710b0_0.conda": { + "build": "py35he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL-3.0", + "md5": "832186a27628ee2b7adffeceb2acdfa0", + "name": "sip", + "sha256": "24f5211f32cfb0e85d76e4c299f7872d0f511fa0ff139b6a17f00c99df11e492", + "size": 283407, + "subdir": "linux-64", + "timestamp": 1535414006059, + "version": "4.19.12" + }, + "sip-4.19.12-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "4c7130925fdd7d6d67d6c66322be4da8", + "name": "sip", + "sha256": "fb734a6b9337bc7307209f139c4175bd2e693bb38c83b3603845b66261ae7faa", + "size": 282575, + "subdir": "linux-64", + "timestamp": 1535397341716, + "version": "4.19.12" + }, + "sip-4.19.12-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "21ce5e84ad68a6b6e74b31253582eb86", + "name": "sip", + "sha256": "85cb53818373e42844a488dec20890657252f3d83c9aaa3a065ae4e528991918", + "size": 282295, + "subdir": "linux-64", + "timestamp": 1535397021786, + "version": "4.19.12" + }, + "sip-4.19.13-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-3.0", + "md5": "60956fdd73a816bc8cdfdb319c756379", + "name": "sip", + "sha256": "51ffd943c15e1315986de7a9ff88ee8860a300d1f28f8b040b2b855c620c43f9", + "size": 284491, + "subdir": "linux-64", + "timestamp": 1541049907618, + "version": "4.19.13" + }, + "sip-4.19.13-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "GPL-3.0", + "md5": "1bbb776fdee549e8dfabc1ce0b9c757c", + "name": "sip", + "sha256": "aea01b05d2a709345f7838046dcedc47f26efd3eabed1d1296093da21e7751d8", + "size": 285402, + "subdir": "linux-64", + "timestamp": 1643114613076, + "version": "4.19.13" + }, + "sip-4.19.13-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "e54b6ae6a9aeae23277a8791c1b6a4e6", + "name": "sip", + "sha256": "da56bdb8e8507b5574cb444563e4a5788995ecb02b2ae33c1a081bb3b64360d0", + "size": 283285, + "subdir": "linux-64", + "timestamp": 1541049928464, + "version": "4.19.13" + }, + "sip-4.19.13-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "d7ffebb4dc93434c90dbe8d69cd217ee", + "name": "sip", + "sha256": "323734441dfbde09f2cee6c69c3e52dced00ec1bb461b0a7e21815c9c27a1df4", + "size": 283212, + "subdir": "linux-64", + "timestamp": 1643114666959, + "version": "4.19.13" + }, + "sip-4.19.13-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "05b9635d6d776760cdec7c19e66c8bd7", + "name": "sip", + "sha256": "8014300b70c9c9ffcb047790160076e00e8a552190e4c2003c285303a691c7b6", + "size": 283192, + "subdir": "linux-64", + "timestamp": 1541049854131, + "version": "4.19.13" + }, + "sip-4.19.13-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "md5": "2046e66b7d12f7c0cda5687e4c27b692", + "name": "sip", + "sha256": "5d5a0cbf127295a717ef24b3bcecff6c1485909fa7c72afc66e27885c4ab878e", + "size": 285265, + "subdir": "linux-64", + "timestamp": 1643114697081, + "version": "4.19.13" + }, + "sip-4.19.13-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "md5": "47810340069a33face31cc56e48d746e", + "name": "sip", + "sha256": "2a0affc13ad28dbf10a0c79fec3a04ab12d26f3b0cc4fd3d66927f85419a3c7b", + "size": 283579, + "subdir": "linux-64", + "timestamp": 1573200494589, + "version": "4.19.13" + }, + "sip-4.19.13-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-3.0", + "md5": "7792606e843566227e5aa2be184dd170", + "name": "sip", + "sha256": "3443d7fb9f10e4b7ee5094952531d80e7b8249c1136f25af176f911da7db6a7f", + "size": 285970, + "subdir": "linux-64", + "timestamp": 1607550718266, + "version": "4.19.13" + }, + "sip-4.19.13-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-3.0", + "md5": "4ddd6575b16490d3856d973fd10b511f", + "name": "sip", + "sha256": "db7ef2b14fe44ce97e1bbadaf00a8c6140c7cf8177367bc29eccce6803fb9c66", + "size": 284852, + "subdir": "linux-64", + "timestamp": 1643114723175, + "version": "4.19.13" + }, + "sip-4.19.22-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "d445c4cb38ff1b99dd04423a2715fb27", + "name": "sip", + "sha256": "c87a1a2f3852f95637b77bbd41d01c683650ad4a2ae4163858c77e2452f5c07b", + "size": 288604, + "subdir": "linux-64", + "timestamp": 1592441747638, + "version": "4.19.22" + }, + "sip-4.19.22-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "e916cc96631927d9e23675d0cc85d19b", + "name": "sip", + "sha256": "7b3df7a016336054217254df8f9e2815ef92ea7f35b20d09dc15332c3bec13ff", + "size": 288192, + "subdir": "linux-64", + "timestamp": 1592441771763, + "version": "4.19.22" + }, + "sip-4.19.22-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "md5": "1a1aa10ef4c6503eb9f3558af5e9b8fd", + "name": "sip", + "sha256": "aaea58cd5d9c8421021367ed42db0c70a315d7ad6741af6f85de6e872b8d5808", + "size": 288781, + "subdir": "linux-64", + "timestamp": 1592441773931, + "version": "4.19.22" + }, + "sip-4.19.23-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "d337967cd6b9c99dfbdd4cec8efa1e50", + "name": "sip", + "sha256": "04de64709ace25d1dadf7b2d6ca35f10b33792ebd24240666dae99647782cdcb", + "size": 288487, + "subdir": "linux-64", + "timestamp": 1593109914249, + "version": "4.19.23" + }, + "sip-4.19.23-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "8278d39263c94b363a275f37af68ce89", + "name": "sip", + "sha256": "fbdc4d835f13e96a41af9ec58fed4cfec155b480285ab92e006305a7d773c755", + "size": 287686, + "subdir": "linux-64", + "timestamp": 1593109930590, + "version": "4.19.23" + }, + "sip-4.19.23-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "md5": "51d2d462415d2b569bffb95e29dd49b2", + "name": "sip", + "sha256": "fa6066ebc78380b826ee4291c7e9c56c35c42f62a7001cafabfed1c3acbfe355", + "size": 289409, + "subdir": "linux-64", + "timestamp": 1593109923723, + "version": "4.19.23" + }, + "sip-4.19.24-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "02e865c063ce3121ad8c65b5edfe6e93", + "name": "sip", + "sha256": "98da16dadfb695679a2e640e204d2e6f2ca035f402dcd113510d520c043fe732", + "size": 285199, + "subdir": "linux-64", + "timestamp": 1597341671915, + "version": "4.19.24" + }, + "sip-4.19.24-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "cf250a9673aedb60d0c61f1b15e1df2a", + "name": "sip", + "sha256": "b2d53ca83780d3a982d0743fa8ed753876c17562d2662a0cfc92164d3c215b5b", + "size": 285388, + "subdir": "linux-64", + "timestamp": 1597341682248, + "version": "4.19.24" + }, + "sip-4.19.24-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "md5": "9d5af3173810617d967707f9ac7cdedf", + "name": "sip", + "sha256": "c00f25bf6ef0de0773095433f2c226d19be8ef90f89bfbf81be3e7f2f7cdf468", + "size": 287535, + "subdir": "linux-64", + "timestamp": 1597341699538, + "version": "4.19.24" + }, + "sip-4.19.24-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-3.0", + "md5": "9f2158cab99a747a459b35163742134a", + "name": "sip", + "sha256": "960c6592cff659aa57001ef1f65693e34e2e422f3feb692c9952ee8a8cd82e4d", + "size": 289594, + "subdir": "linux-64", + "timestamp": 1607102353831, + "version": "4.19.24" + }, + "sip-4.19.25-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "GPL-3.0", + "md5": "1b615e90145f95dc6e39a2d850bb8d27", + "name": "sip", + "sha256": "3d266646fa5590c7987f27bb91a54168ed5467e154b8108f91421c416788f22a", + "size": 285955, + "subdir": "linux-64", + "timestamp": 1640794796998, + "version": "4.19.25" + }, + "sip-4.19.25-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "328ed789677d0e758247eeb00dfd76a2", + "name": "sip", + "sha256": "eadf95179c6d56e4f8d2d17d1cc80e08faf5f10bad5f0ba97d9fd3ab33856ccf", + "size": 284584, + "subdir": "linux-64", + "timestamp": 1614366670720, + "version": "4.19.25" + }, + "sip-4.19.25-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "e32afbf7e4e799f3572b4476e528f17a", + "name": "sip", + "sha256": "9c8fe23a9040055f9436b7f811f3b28d096e9539ab0c3b586d33946aebd125b8", + "size": 285686, + "subdir": "linux-64", + "timestamp": 1614366663078, + "version": "4.19.25" + }, + "sip-4.19.25-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "md5": "f945af958c54005affdf82813fc836f2", + "name": "sip", + "sha256": "3efd5d651be0b73200bd9aed3e2f213dd6c29a26f206b4d8df0401ffe4e85064", + "size": 286094, + "subdir": "linux-64", + "timestamp": 1614366675321, + "version": "4.19.25" + }, + "sip-4.19.25-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "GPL-3.0", + "md5": "99c58f33d9fa5c1cce971daf0a5c23da", + "name": "sip", + "sha256": "398c3f228a789319051105470feb70e7a1461c56537f5f2ff0d464d72589be8f", + "size": 286804, + "subdir": "linux-64", + "timestamp": 1614365616335, + "version": "4.19.25" + }, + "sip-4.19.8-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-3.0", + "md5": "433c4dad1573e46cb326601962b3008f", + "name": "sip", + "sha256": "fe02fc79748d151627a5fa646cc823cb080d83c100d79652e5cab5fa76b7ba0d", + "size": 281513, + "subdir": "linux-64", + "timestamp": 1521796117814, + "version": "4.19.8" + }, + "sip-4.19.8-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "GPL-3.0", + "md5": "c41443c02b84cac4dfe7140eadf1367b", + "name": "sip", + "sha256": "c52115ca6e421771ccfab87eefe37b0c69e79431a69c4c83817edcb21233d78f", + "size": 281359, + "subdir": "linux-64", + "timestamp": 1521796149321, + "version": "4.19.8" + }, + "sip-4.19.8-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-3.0", + "md5": "750ca208c29e93fe5f37c67ad075e1e0", + "name": "sip", + "sha256": "a8f5ae3d09911f88b3e6ba987c1586bea8f55ea782747157cae329e61c85fd04", + "size": 280550, + "subdir": "linux-64", + "timestamp": 1521796180404, + "version": "4.19.8" + }, + "sip-4.19.8-py37hf484d3e_0.conda": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-3.0", + "md5": "a41603290a87146546d40828e3a3848d", + "name": "sip", + "sha256": "755426c442fd2f6a0cbf6f37dfe480d67552ce92c90b9f2c7614123704d99363", + "size": 280402, + "subdir": "linux-64", + "timestamp": 1530793400234, + "version": "4.19.8" + }, + "sip-4.19.8-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "GPL-3.0", + "md5": "509ebbfab29c6f572ba3dc2e8f239fdb", + "name": "sip", + "sha256": "0636417202d113c5bcd3be25c13ec0139905c9a14c6cd4db27e91db8200568f0", + "size": 283873, + "subdir": "linux-64", + "timestamp": 1579625560000, + "version": "4.19.8" + }, + "sip-6.5.1-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "packaging", + "python >=3.10,<3.11.0a0", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "54f31558adb182e377de264cb37daff9", + "name": "sip", + "sha256": "78d7c07d5671e50bb095ed8632e173f381daa2802cd0183c14e802953b58a933", + "size": 565708, + "subdir": "linux-64", + "timestamp": 1651046326934, + "version": "6.5.1" + }, + "sip-6.5.1-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "packaging", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "0c0dc7d4f728eaa9f7ece843d121706f", + "name": "sip", + "sha256": "8a7693de46ed11729d134a29a7eb6a70e6a9841c842a5be1cf3e1da6d0e66e1f", + "size": 334166, + "subdir": "linux-64", + "timestamp": 1651046410867, + "version": "6.5.1" + }, + "sip-6.5.1-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "packaging", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "34bcd8c52c331ce1649b5df5d502c815", + "name": "sip", + "sha256": "e5245c503568e3f1d95214a8872ad816f4ef76840df05a243d021b42c9d3218c", + "size": 335523, + "subdir": "linux-64", + "timestamp": 1651046275372, + "version": "6.5.1" + }, + "sip-6.5.1-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "packaging", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "6e0cdb5431a7919d14dbbe1de4d3ce2f", + "name": "sip", + "sha256": "cbf53920e47342662faa2e6b548b0dc9bba6af0e7cc17043e66dc784f68eba50", + "size": 333605, + "subdir": "linux-64", + "timestamp": 1651046370285, + "version": "6.5.1" + }, + "sip-6.6.2-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "ply", + "python >=3.10,<3.11.0a0", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "28f9d07c459f080064a83f9ff84274e3", + "name": "sip", + "sha256": "997fc77d43b0fc649b2b8fa76dd6e30d70384d4022a66cddaee03c2546cfedc5", + "size": 708469, + "subdir": "linux-64", + "timestamp": 1659012503474, + "version": "6.6.2" + }, + "sip-6.6.2-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "ply", + "python >=3.11,<3.12.0a0", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "5126d41adacf0e25094ad530988b3ad9", + "name": "sip", + "sha256": "03f2a0cd99fe3aa4f67ecf9073893f00e3dc0b49c4bf3aaead9a42b195f314de", + "size": 499054, + "subdir": "linux-64", + "timestamp": 1676825141789, + "version": "6.6.2" + }, + "sip-6.6.2-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "ply", + "python >=3.7,<3.8.0a0", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "f8633f00c5e6162e3cf79884e31ae025", + "name": "sip", + "sha256": "ee83ae2d3d24414a523f00872dec005c2d9f1d5f43f298ea750c0a7ccf4cacff", + "size": 435009, + "subdir": "linux-64", + "timestamp": 1659012560366, + "version": "6.6.2" + }, + "sip-6.6.2-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "ply", + "python >=3.8,<3.9.0a0", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "cb3f0d10f7f79870945f4dbbe0000f92", + "name": "sip", + "sha256": "505982fe5bd52f243ae7727b94ab48bbb970a3279dea30d6481e5e218eb0ada4", + "size": 435188, + "subdir": "linux-64", + "timestamp": 1659012616068, + "version": "6.6.2" + }, + "sip-6.6.2-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "packaging", + "ply", + "python >=3.9,<3.10.0a0", + "toml" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "56c596cbe26e3f54c20011c7814a95df", + "name": "sip", + "sha256": "05d49acdc7e2380190434bf8bf3d65140c0ed30b660177aadfa38cdd872f102a", + "size": 433586, + "subdir": "linux-64", + "timestamp": 1659012429830, + "version": "6.6.2" + }, + "six-1.10.0-py27hdcd7534_1.conda": { + "build": "py27hdcd7534_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0173021d71ff2cb66a00c94bc5a2b2c2", + "name": "six", + "sha256": "cd4c1313cacf863d84dbab1df04e6917d0e9c4348619f64d541c4c5526fd9985", + "size": 21362, + "subdir": "linux-64", + "timestamp": 1505672067944, + "version": "1.10.0" + }, + "six-1.10.0-py35h5312c1b_1.conda": { + "build": "py35h5312c1b_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "529823028b0b19dffd7658d9fbd09f36", + "name": "six", + "sha256": "cdbfaf8b605e6d7ac491553f4b55f7085c07ac5f3e09b4c5b64eb113769a6e66", + "size": 21722, + "subdir": "linux-64", + "timestamp": 1505672078657, + "version": "1.10.0" + }, + "six-1.10.0-py36hcac75e4_1.conda": { + "build": "py36hcac75e4_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f57fb5a28b627ee3e583c111d276aced", + "name": "six", + "sha256": "d1e6f19643414e267af407e6e10b7908e28645cffc3629a6c837f8ee6607a52e", + "size": 21418, + "subdir": "linux-64", + "timestamp": 1505672089464, + "version": "1.10.0" + }, + "six-1.11.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb8c59f22809f619db60b6f1ab7a283b", + "name": "six", + "sha256": "e57ee3569fcf85906995784c90da733fd7d594b95dc3dec6224d8409343fabca", + "size": 22019, + "subdir": "linux-64", + "timestamp": 1530693756133, + "version": "1.11.0" + }, + "six-1.11.0-py27h5f960f1_1.conda": { + "build": "py27h5f960f1_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c665f9c53aeca752cb8d8c5455671594", + "name": "six", + "sha256": "10de2d625760e400d09e8498d3a396aac5d3de44133d4dc80aef9a010a293f9a", + "size": 22282, + "subdir": "linux-64", + "timestamp": 1508610494828, + "version": "1.11.0" + }, + "six-1.11.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6089c91a01771c1f1c364f8795c01e33", + "name": "six", + "sha256": "2689efd681c1f8a005e905644afcdb763b2c97b5b6fed314b73302da5e638226", + "size": 22218, + "subdir": "linux-64", + "timestamp": 1534344959297, + "version": "1.11.0" + }, + "six-1.11.0-py35h423b573_1.conda": { + "build": "py35h423b573_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "460b524ba3bd6f4c2c0535299520f8e3", + "name": "six", + "sha256": "dd7cc6662327280ebd9b6ab1b9ee5c21718ba92572c33d4d75da8b331a4f41ba", + "size": 22624, + "subdir": "linux-64", + "timestamp": 1508610522504, + "version": "1.11.0" + }, + "six-1.11.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43e13bfc77eeaa5c11bab1f355a5b4a5", + "name": "six", + "sha256": "f7fb5c4c717fd51815c63c1fe90da80433b6feb805e5d40f7db1e4f69a400eb7", + "size": 22448, + "subdir": "linux-64", + "timestamp": 1530693718665, + "version": "1.11.0" + }, + "six-1.11.0-py36h372c433_1.conda": { + "build": "py36h372c433_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "69587f90939a69eb80cd4746c089845e", + "name": "six", + "sha256": "d934b687838fb33ca4e6308ef5aace206a3f0ef1dbd869cdaf693877dcddbaa2", + "size": 22696, + "subdir": "linux-64", + "timestamp": 1508610520093, + "version": "1.11.0" + }, + "six-1.11.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "711f0d225c23375f85888e18fac25892", + "name": "six", + "sha256": "ed214e82d865d4834749fb260aab20a9cd4f876b45cdfe67678fb7f6726051ef", + "size": 22044, + "subdir": "linux-64", + "timestamp": 1530693737763, + "version": "1.11.0" + }, + "six-1.12.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eae2efac9bbd2b01eca30d3764f96f67", + "name": "six", + "sha256": "41c48308819e3a2eb6527b71cdda676e31ed9017344784f204497571c5886d15", + "size": 23173, + "subdir": "linux-64", + "timestamp": 1544542935561, + "version": "1.12.0" + }, + "six-1.12.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe652d77913d3378f62eb825dd0c6545", + "name": "six", + "sha256": "1920cc614a3a352345041aca7881195220312ba41cadb550c03da8e2515b72a9", + "size": 23169, + "subdir": "linux-64", + "timestamp": 1544542969635, + "version": "1.12.0" + }, + "six-1.12.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d407aa3de9814089d1dacee4e818fa19", + "name": "six", + "sha256": "6f3d8b80f1b94032753b27fa5ab4540a82733245914db54285f089287eeff406", + "size": 23164, + "subdir": "linux-64", + "timestamp": 1544542931768, + "version": "1.12.0" + }, + "six-1.12.0-py38_1000.conda": { + "build": "py38_1000", + "build_number": 1000, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "803e0e2119f0ca481d38c1a61432918c", + "name": "six", + "sha256": "3b698beb0247462317de398f42006cc5dd3edd9b2eca0e2ba5b3808377d1f3ba", + "size": 23438, + "subdir": "linux-64", + "timestamp": 1572609182813, + "version": "1.12.0" + }, + "six-1.13.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0c93eefa234c8606e067f73b3b15d398", + "name": "six", + "sha256": "3c482efb958005f66bc7eeca42c4ac210d004ce1b0b29d74a11f6948dc5e4314", + "size": 26730, + "subdir": "linux-64", + "timestamp": 1573251215503, + "version": "1.13.0" + }, + "six-1.13.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2f314ae4421748bc956d961d3507abb3", + "name": "six", + "sha256": "024ee099ccfa9bcfc32f4441d34cf21f76a4b5e53ff819666e3391fd7f3bafbd", + "size": 26925, + "subdir": "linux-64", + "timestamp": 1573251221722, + "version": "1.13.0" + }, + "six-1.13.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f863356c0a1f4d53e125905a9b40257c", + "name": "six", + "sha256": "ea1f78dd0f78f49135ee086ca2b1d929840c48087606dc20a82a3c45405c1f39", + "size": 26901, + "subdir": "linux-64", + "timestamp": 1573251210326, + "version": "1.13.0" + }, + "six-1.13.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b8e96be3e1424b9a829beeffa00fbdc", + "name": "six", + "sha256": "7046cb1b76b7981501a686b02a0100d9ff3f27d192928331b4cc47e8ff4d6943", + "size": 26780, + "subdir": "linux-64", + "timestamp": 1573251253148, + "version": "1.13.0" + }, + "six-1.14.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6306bc79a1d46167f1dc80eb6d05f739", + "name": "six", + "sha256": "fa1fa2dd41b8ab7cd5b0a374912a8e50d8d6d8843f44a7c1f54a447b393ceae5", + "size": 27421, + "subdir": "linux-64", + "timestamp": 1580149944409, + "version": "1.14.0" + }, + "six-1.14.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fe1b4a22d7ae2ee0a4e8cd7d3b2db71a", + "name": "six", + "sha256": "e9ab84bf4e984f33a09ff4de113dfd2d086bb29330c371b7f9391a2de9d9ebee", + "size": 27661, + "subdir": "linux-64", + "timestamp": 1605201619625, + "version": "1.14.0" + }, + "six-1.14.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dab70d0de57e545e56d7f3622fa61ccb", + "name": "six", + "sha256": "e14e198af02998c700ab0fe8d3b790be03592829bf25f14c8a21171299472e0e", + "size": 27152, + "subdir": "linux-64", + "timestamp": 1580149912348, + "version": "1.14.0" + }, + "six-1.14.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "880b9a67afbe6e7d0459fc23156240be", + "name": "six", + "sha256": "83dcfaade04e6d3da3ac87b54d590ddff3c7fc5174a575af74174e1a5d5e1df2", + "size": 27400, + "subdir": "linux-64", + "timestamp": 1605201645932, + "version": "1.14.0" + }, + "six-1.14.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de7e61d45e321e663f5ec9492a02a56f", + "name": "six", + "sha256": "8c251031fd1ab002bbb46db92f1ff8ff1945034a21d83c6fa0af6d4be39c39b9", + "size": 27433, + "subdir": "linux-64", + "timestamp": 1580149919050, + "version": "1.14.0" + }, + "six-1.14.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c7b5fb94c46da34680b90ac7ca09f443", + "name": "six", + "sha256": "f0d15e0cee6b8f9c55b0cd2161232f01f82ecfe34a6b6afe0e125fb57b30a5c8", + "size": 27582, + "subdir": "linux-64", + "timestamp": 1605201641536, + "version": "1.14.0" + }, + "six-1.14.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd90a7b8921bcf2cfc4b98e3635e532a", + "name": "six", + "sha256": "19b72c3dd45bccbe51a1e395572b420631b7394e78d445a42208c453faec1c3b", + "size": 27475, + "subdir": "linux-64", + "timestamp": 1605201648065, + "version": "1.14.0" + }, + "six-1.15.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec98935785a5b45f36819d529bb5c177", + "name": "six", + "sha256": "bc00a6d91f9387827e256363622e4720ebf51c5ca1dc43e8330380be6e1e9fe4", + "size": 27464, + "subdir": "linux-64", + "timestamp": 1605205370543, + "version": "1.15.0" + }, + "six-1.15.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14ad9b343e0f4b95dc341a17aa7a8adc", + "name": "six", + "sha256": "1f1311b9fb876d2214f4df72729447990aa953373229525073c39e5a2f07a0fd", + "size": 27613, + "subdir": "linux-64", + "timestamp": 1605205343469, + "version": "1.15.0" + }, + "six-1.15.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9748417d78b853a64a71fbc0e969fffc", + "name": "six", + "sha256": "4d309f1b46b2587d0bdfe8090fe9ce24b19dd29c67cef4fab05a6e7f8f0e9f1b", + "size": 27599, + "subdir": "linux-64", + "timestamp": 1605205355842, + "version": "1.15.0" + }, + "six-1.15.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e5023c97cb81022bd0da30f1ceb0057", + "name": "six", + "sha256": "5a4fe767ecfbdcc9bcb4bd4b79d038e0eb54edf9460527610344cec229b9cdd5", + "size": 27686, + "subdir": "linux-64", + "timestamp": 1605205336128, + "version": "1.15.0" + }, + "skl2onnx-1.13-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.15", + "onnx >=1.2.1", + "onnxconverter-common >=1.7.0", + "packaging", + "protobuf", + "python >=3.10,<3.11.0a0", + "scikit-learn >=0.19,<=1.1.1", + "scipy >=1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d87747eaf4adb5511f2f48a72c300b72", + "name": "skl2onnx", + "sha256": "7123304b3588fd9d9c9642b4566da57e936cba4c81b82d0f51ca6b2fef13932c", + "size": 426617, + "subdir": "linux-64", + "timestamp": 1671654320198, + "version": "1.13" + }, + "skl2onnx-1.13-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.15", + "onnx >=1.2.1", + "onnxconverter-common >=1.7.0", + "packaging", + "protobuf", + "python >=3.7,<3.8.0a0", + "scikit-learn >=0.19,<=1.1.1", + "scipy >=1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5f79e6e19b63b4dceed2a75941f01f87", + "name": "skl2onnx", + "sha256": "6cd9953c6002336cd7ab9c193435142fe7c3e2bd1476fbd13d923a933086b030", + "size": 414281, + "subdir": "linux-64", + "timestamp": 1671654259659, + "version": "1.13" + }, + "skl2onnx-1.13-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.15", + "onnx >=1.2.1", + "onnxconverter-common >=1.7.0", + "packaging", + "protobuf", + "python >=3.8,<3.9.0a0", + "scikit-learn >=0.19,<=1.1.1", + "scipy >=1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "03648cb8ba933f8a67ee022a761ab088", + "name": "skl2onnx", + "sha256": "a8d4d824175afe96b95c5274fc8d68ec2a25e0a9d55193e124fc5c5835c3b8c9", + "size": 419155, + "subdir": "linux-64", + "timestamp": 1671654290376, + "version": "1.13" + }, + "skl2onnx-1.13-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.15", + "onnx >=1.2.1", + "onnxconverter-common >=1.7.0", + "packaging", + "protobuf", + "python >=3.9,<3.10.0a0", + "scikit-learn >=0.19,<=1.1.1", + "scipy >=1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ccf478ada977f016508ee2571316d9d9", + "name": "skl2onnx", + "sha256": "c5d5dbb0f6bad1ce4123c7c98f23e365db8b8815ba078a5882e01c2f85e00b4f", + "size": 416783, + "subdir": "linux-64", + "timestamp": 1671654227364, + "version": "1.13" + }, + "slack-sdk-3.19.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8b9c39bd53e9e79479b1ab918c942a62", + "name": "slack-sdk", + "sha256": "eed554387285c64e7aa8afca7d84ba5dc6032ac57af2234c8acdedb8181031a0", + "size": 330057, + "subdir": "linux-64", + "timestamp": 1675353525242, + "version": "3.19.5" + }, + "slack-sdk-3.19.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4b97b2e3d2d07a5967e6d20bc955b2d8", + "name": "slack-sdk", + "sha256": "22ec9cd16ac0717079764b53400b2286e4d1dfc0ff8ee194b0c2759af4cdf50c", + "size": 414584, + "subdir": "linux-64", + "timestamp": 1676862199113, + "version": "3.19.5" + }, + "slack-sdk-3.19.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b6a2d5456035a47cf8f22ef36864304", + "name": "slack-sdk", + "sha256": "e22c85669fac9a4880a67fc9a6f863866610eda4f63454bd5f77c879785741c0", + "size": 319312, + "subdir": "linux-64", + "timestamp": 1675353497598, + "version": "3.19.5" + }, + "slack-sdk-3.19.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ff18d6b8f7b6da74c2b4ff738eca744", + "name": "slack-sdk", + "sha256": "0325293320c514876ab93ec93116e4a04d612d03313ab262821a67b193fef5f9", + "size": 323429, + "subdir": "linux-64", + "timestamp": 1675353430270, + "version": "3.19.5" + }, + "slack-sdk-3.19.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f30043cc75fa7f2b48eaf5a556d124eb", + "name": "slack-sdk", + "sha256": "bdea5e12decc12c23ef5be7ede4488cb12ec5a946ab56573e4b58e5e34219a50", + "size": 323968, + "subdir": "linux-64", + "timestamp": 1675353466690, + "version": "3.19.5" + }, + "slack-sdk-3.2.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02d63a675ca0c810f530526065e74946", + "name": "slack-sdk", + "sha256": "3047200dc087741c1a1676a10266fe1967fbf349b03098eeb1f6d54b576977d9", + "size": 211324, + "subdir": "linux-64", + "timestamp": 1612478124311, + "version": "3.2.1" + }, + "slack-sdk-3.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f5f6c489a034a0c0c36e796a720fe9b", + "name": "slack-sdk", + "sha256": "d00f308c6b3ebfbe5d56d91ad5ad05d85a4e4479e930cb6492ac1350deb79855", + "size": 211669, + "subdir": "linux-64", + "timestamp": 1612478586024, + "version": "3.2.1" + }, + "slack-sdk-3.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56c3daeed6d1b470b08e479429caf7f6", + "name": "slack-sdk", + "sha256": "c974467956b252290c97c643904c9d6aa73bb3fc1a6beb7844f1c65118c1d0ef", + "size": 211953, + "subdir": "linux-64", + "timestamp": 1612478593196, + "version": "3.2.1" + }, + "slackclient-2.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9604c9aec8331df3d43774214d10bf74", + "name": "slackclient", + "sha256": "d0ace94d6e82a134b31822b6d32f846de0072306c197bedb360a232b83565aff", + "size": 124644, + "subdir": "linux-64", + "timestamp": 1597067100478, + "version": "2.8.0" + }, + "slackclient-2.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee8ba458255121528b60ede0bf4d584f", + "name": "slackclient", + "sha256": "0b207e5f1fa4ce501322784e79fe0fa008e7982650c114c27342b8536099715e", + "size": 128540, + "subdir": "linux-64", + "timestamp": 1600554234625, + "version": "2.9.0" + }, + "slackclient-2.9.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e695afeb26eb5aab970d842bc036c76", + "name": "slackclient", + "sha256": "eb46198debff29290b6d53ff51e419584d2aadbe4c7c639684c156db04fdf861", + "size": 127099, + "subdir": "linux-64", + "timestamp": 1600554234115, + "version": "2.9.0" + }, + "slackclient-2.9.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "79ebbc8b6a7ac69e4ec51f34fc14676d", + "name": "slackclient", + "sha256": "2bf802d838cac624a7921f82794a57b434bd5ba19ba2841bd2a192f13482d837", + "size": 130095, + "subdir": "linux-64", + "timestamp": 1600554222222, + "version": "2.9.0" + }, + "slackclient-2.9.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1fe9fc0e7882d804691daf4acdf2ed94", + "name": "slackclient", + "sha256": "8f0441cfaed7f42cde14292d3e29718e65e55ec74e25849f029007f23e39a910", + "size": 127001, + "subdir": "linux-64", + "timestamp": 1600885313560, + "version": "2.9.1" + }, + "slackclient-2.9.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8bf70a92ffba921d19c62e0405c9c08", + "name": "slackclient", + "sha256": "33ea86c40919395d5759384fd80007bb1c1be20d0578a714b73d3d7e77f1a281", + "size": 128826, + "subdir": "linux-64", + "timestamp": 1600881137963, + "version": "2.9.1" + }, + "slackclient-2.9.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4847e49b076cdb86ebb89eaff3e2a256", + "name": "slackclient", + "sha256": "be545efdbe0438bac7aefffb52c0ecc6de7292f30033945f1c5695d6b1acd0cd", + "size": 130379, + "subdir": "linux-64", + "timestamp": 1600885283322, + "version": "2.9.1" + }, + "slackclient-2.9.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8191beaf7ebc82f904cde7ca63648ea5", + "name": "slackclient", + "sha256": "d4f3909b0d54422ac054326c426636f5854b12504cccaba9225fcd7ca813b299", + "size": 129887, + "subdir": "linux-64", + "timestamp": 1602525307560, + "version": "2.9.2" + }, + "slackclient-2.9.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d58254b91ca838d64b7a147ede712998", + "name": "slackclient", + "sha256": "2870524da3e9bcfc3ef864ecb2773dcabfde61142dcc50f0bc27e5154a8d981a", + "size": 129919, + "subdir": "linux-64", + "timestamp": 1602525304074, + "version": "2.9.2" + }, + "slackclient-2.9.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "669b4bd04075290f8b2106cd07faa537", + "name": "slackclient", + "sha256": "2f4c38371c5acfa8ab11d93132183b9e093a564ea91fa85dc57aa17d186f346c", + "size": 131445, + "subdir": "linux-64", + "timestamp": 1602525286981, + "version": "2.9.2" + }, + "slackclient-2.9.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1fd0d2f707674454b348cc9795c652d9", + "name": "slackclient", + "sha256": "529e6687b24a46ca6d5cc493185c7e2721fd5a2190c90b4fde4517588e213165", + "size": 131305, + "subdir": "linux-64", + "timestamp": 1641904219706, + "version": "2.9.3" + }, + "slackclient-2.9.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a65f369e72122129aafe96871be1a9bb", + "name": "slackclient", + "sha256": "72f1807286ded647cef0b297787cd2b2f349963540d41c22924814c40e41a584", + "size": 171722, + "subdir": "linux-64", + "timestamp": 1676862221062, + "version": "2.9.3" + }, + "slackclient-2.9.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f347ce1a960b3383b46b08938cb55a1d", + "name": "slackclient", + "sha256": "bdf1dd0e03644df8c97201a5c9fe9d312622c1d181b1a4466d87a33e268dae6c", + "size": 129645, + "subdir": "linux-64", + "timestamp": 1603479088289, + "version": "2.9.3" + }, + "slackclient-2.9.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d7693f6a30e0e2c19ebd18e11ca1371c", + "name": "slackclient", + "sha256": "207defea3c158237c590b7acf0746b3d80d9c2ec4e725f03a761c224ff4095fa", + "size": 128172, + "subdir": "linux-64", + "timestamp": 1603816112200, + "version": "2.9.3" + }, + "slackclient-2.9.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23530af239a508c1b67069822d59ccfb", + "name": "slackclient", + "sha256": "88b493acc00416b1257400a8019f5f05c099d9155fea53b1a105cb0a2112993d", + "size": 127834, + "subdir": "linux-64", + "timestamp": 1603479081137, + "version": "2.9.3" + }, + "slackclient-2.9.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f1b59b8da25d1fff2fad1e2dbcc3daf", + "name": "slackclient", + "sha256": "663063d7125508861afb051ca535e102cdc9afda222e2fe48aa66c3c2855c350", + "size": 129760, + "subdir": "linux-64", + "timestamp": 1603816097766, + "version": "2.9.3" + }, + "slackclient-2.9.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8b7317049d824ca1283c9cee7d3ad168", + "name": "slackclient", + "sha256": "04d3db07250dee7422369a176f69fcfd8e8bff747e654245360988c2ae43bd4e", + "size": 129753, + "subdir": "linux-64", + "timestamp": 1603479056056, + "version": "2.9.3" + }, + "slackclient-2.9.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "53c547841f4ba4c26344ba72653dd489", + "name": "slackclient", + "sha256": "ff01886128d62113d671d05a6c6f8c4aa06ff88dfb90a2134bd2e8ff6aa5ea74", + "size": 131476, + "subdir": "linux-64", + "timestamp": 1603816111042, + "version": "2.9.3" + }, + "slackclient-2.9.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "aiodns >1.0", + "aiohttp >3.5.2", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fdc1c2aa5bcd244855217a1e8f141cc7", + "name": "slackclient", + "sha256": "ad1cbdbd04ddf3e6217f7e3bf7643975501c221b61bde2ea0010036b9fc28ea7", + "size": 135925, + "subdir": "linux-64", + "timestamp": 1613481541420, + "version": "2.9.3" + }, + "smart_open-1.5.6-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "boto >=2.32", + "boto3", + "bz2file", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0fb1daa43f86f78f052e389de01f58c2", + "name": "smart_open", + "sha256": "6cee4258a6ddf015ce9eb233a6ce6c82028b56d765e04ca3f185b9e9b5eda144", + "size": 58230, + "subdir": "linux-64", + "timestamp": 1519838656086, + "version": "1.5.6" + }, + "smart_open-1.5.6-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "boto >=2.32", + "boto3", + "bz2file", + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7a95246eced5165c64c697b9dfb561a7", + "name": "smart_open", + "sha256": "256e1e23b30462f20b1e3fc6bd3c71edf184ccc81a0ae0141da4b2f60f671679", + "size": 59606, + "subdir": "linux-64", + "timestamp": 1519838697304, + "version": "1.5.6" + }, + "smart_open-1.5.6-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "boto >=2.32", + "boto3", + "bz2file", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "175c7c251d72f169b7f1f6b6d1be8522", + "name": "smart_open", + "sha256": "f862d98a11295161b6418d2c93dd51a024d5d58e840dbdcb784296758306cf6d", + "size": 59128, + "subdir": "linux-64", + "timestamp": 1519838629764, + "version": "1.5.6" + }, + "smart_open-1.5.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "bz2file", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1bc55d7c4dc9d13ea90612c3e8e85e48", + "name": "smart_open", + "sha256": "b6abd4e5f0fdd1b761fc64e7db7bb671ce69663d78f4aabd29c75c2d4dc012a0", + "size": 58543, + "subdir": "linux-64", + "timestamp": 1522195592417, + "version": "1.5.7" + }, + "smart_open-1.5.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "bz2file", + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d5d2149d42ee3b9d260b936dfca45900", + "name": "smart_open", + "sha256": "faf789d2648ce11ce530089a530f2f860f59b737a88e1babd1c8693e24ac1ee0", + "size": 59571, + "subdir": "linux-64", + "timestamp": 1522195623993, + "version": "1.5.7" + }, + "smart_open-1.5.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "bz2file", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "61dac88c0e9c72233efa46c6657c255f", + "name": "smart_open", + "sha256": "9efe06ff8feb2fea686a8c2d05ab5fd1de5baa6aee4cb20cf265dd92f4a07dba", + "size": 59203, + "subdir": "linux-64", + "timestamp": 1522195628590, + "version": "1.5.7" + }, + "smart_open-1.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "bz2file", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "81968f40ff4bde31627f8ae5e46c6ad3", + "name": "smart_open", + "sha256": "0992bb0f7841783f7af0f364c0776c68a7b173f61173f23952bfc0ce22b4b724", + "size": 64166, + "subdir": "linux-64", + "timestamp": 1530556756233, + "version": "1.6.0" + }, + "smart_open-1.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "python >=3.5,<3.6.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "88f4e5195f5fb714373956aa02d10e75", + "name": "smart_open", + "sha256": "1d12e89779ea2eec8217fd16107726d02e6a508a35ee54da5fc707f02ca60b95", + "size": 65072, + "subdir": "linux-64", + "timestamp": 1530556775910, + "version": "1.6.0" + }, + "smart_open-1.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0dcd0712576774334483d246ab954f03", + "name": "smart_open", + "sha256": "cc860ab6cc6feb078893a0bceb06eed50637cb27ddc558b122023184cd79cc7f", + "size": 65499, + "subdir": "linux-64", + "timestamp": 1530556774803, + "version": "1.6.0" + }, + "smart_open-1.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8703a5f8e3f4e216233d2261fc4b135d", + "name": "smart_open", + "sha256": "4fad536f3b43fa9b0cb20409fcce3fc280b57061e9ae61138c4b15ac026e7c8b", + "size": 65502, + "subdir": "linux-64", + "timestamp": 1530889256326, + "version": "1.6.0" + }, + "smart_open-1.7.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "bz2file", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34fef2fcb3ddcf6494eb5111da6e995b", + "name": "smart_open", + "sha256": "1ce185935d13941507efdd9dfeabf11fa83b25a2d1398a7c9a69c629a5d42286", + "size": 68582, + "subdir": "linux-64", + "timestamp": 1539638619092, + "version": "1.7.1" + }, + "smart_open-1.7.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3623b32e9187b28650f22545a76bfe3", + "name": "smart_open", + "sha256": "a3073036530a5dd9060ea73bb4887059c499f330a2be917c0079c06af0b8d2e0", + "size": 69161, + "subdir": "linux-64", + "timestamp": 1539638635611, + "version": "1.7.1" + }, + "smart_open-1.7.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dfa56953694483ee7bdb45b1e33edf32", + "name": "smart_open", + "sha256": "86d5260d73416c4fdeab2c101d587f9c51ac2da93393645924e1521ca50b94b8", + "size": 68283, + "subdir": "linux-64", + "timestamp": 1539638637622, + "version": "1.7.1" + }, + "smart_open-1.8.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "bz2file", + "python >=2.7,<2.8.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a67020156db09c4fa028f400e84bf922", + "name": "smart_open", + "sha256": "d4841d53de26f54dc89f56bb3d0237f8d6c292a9266d33f30faed44acda2417a", + "size": 70456, + "subdir": "linux-64", + "timestamp": 1547925279513, + "version": "1.8.0" + }, + "smart_open-1.8.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "python >=3.6,<3.7.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a164c41601b87d96695f3b77350c0d1", + "name": "smart_open", + "sha256": "38e78a6cbe164fc4bb3c007ff292075770503e510f8cbe9a2f3c86cf89c44688", + "size": 71213, + "subdir": "linux-64", + "timestamp": 1547925320069, + "version": "1.8.0" + }, + "smart_open-1.8.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "boto >=2.32", + "boto3", + "python >=3.7,<3.8.0a0", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f27fb20eb840ed4bb6e4a3347b45f6ac", + "name": "smart_open", + "sha256": "bef0fffbfaa3233d9ee03b8b30c9f73ad329e019b05ad6d6fa231fababbbc696", + "size": 71870, + "subdir": "linux-64", + "timestamp": 1547925302849, + "version": "1.8.0" + }, + "smart_open-5.2.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b055be65b8e9470f0db5537c27231db2", + "name": "smart_open", + "sha256": "0c29628c70ac2318c20f300ea26f7afe77543bed61456f16cfc72d99b9fedcc8", + "size": 77555, + "subdir": "linux-64", + "timestamp": 1651563590365, + "version": "5.2.1" + }, + "smart_open-5.2.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "941fb3ec9e0a51013ccb592d72eac946", + "name": "smart_open", + "sha256": "10df1f064f0c0f0418ba8ebdc5a419fe3d8e37f6d32ad878ec0c545e9a84884b", + "size": 97794, + "subdir": "linux-64", + "timestamp": 1676842861655, + "version": "5.2.1" + }, + "smart_open-5.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd2ee785f4eac86dbc8637e653d9d7c4", + "name": "smart_open", + "sha256": "5c52168ff65bc3cf04a510bd2aa4e6a91d2d0f48e62d23db3e7da799688dc9a4", + "size": 76512, + "subdir": "linux-64", + "timestamp": 1651563646788, + "version": "5.2.1" + }, + "smart_open-5.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6140d39e572a5643ea5fcdf1d31707a9", + "name": "smart_open", + "sha256": "5cbffcb2f1fe9758fc5becdd4300e97b47e0759a951028882f6c79470b0059cd", + "size": 76763, + "subdir": "linux-64", + "timestamp": 1651563673017, + "version": "5.2.1" + }, + "smart_open-5.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16ed83ded913cc9c9a4ead873b37abbf", + "name": "smart_open", + "sha256": "f536de2e1c42b46b211715e258a41265ef6ff542417800d2e0ad265ecfa25c64", + "size": 76995, + "subdir": "linux-64", + "timestamp": 1651563617958, + "version": "5.2.1" + }, + "smartypants-2.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "acb37d0c6b75ab6eff3e0b406998e289", + "name": "smartypants", + "sha256": "57e5066ed840f37bed519579b89ddfc55067349c7202261157a7ab48b5b99ace", + "size": 18804, + "subdir": "linux-64", + "timestamp": 1651243004692, + "version": "2.0.1" + }, + "smartypants-2.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d5e40b1efcb63db1366918b56c90096c", + "name": "smartypants", + "sha256": "c589f1167a5dfd90852b199dff8ac54ea15d8ea6db51894671aae0ef629288e7", + "size": 18820, + "subdir": "linux-64", + "timestamp": 1676862236933, + "version": "2.0.1" + }, + "smartypants-2.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a025ce49b6fa4b1b7884a0107fffc3e2", + "name": "smartypants", + "sha256": "ff12a99e0bf1e4b3e72cb6e4d17bf8e4b1900308777d6e7b6ffa647590831073", + "size": 18685, + "subdir": "linux-64", + "timestamp": 1651242984418, + "version": "2.0.1" + }, + "smartypants-2.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "292787a3193d58182a60c1d838708e41", + "name": "smartypants", + "sha256": "ab86010c88469e4ef9555a5474027e920ab639cd3093d97121c1a4323e39f584", + "size": 18755, + "subdir": "linux-64", + "timestamp": 1651242981997, + "version": "2.0.1" + }, + "smartypants-2.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e0b7cddbc8ffa44af7bbb67f886e6d33", + "name": "smartypants", + "sha256": "c3d11d888fd96a4e8563e47f27185c295e6026412a874e4156ee74119afb2cac", + "size": 18763, + "subdir": "linux-64", + "timestamp": 1651225127299, + "version": "2.0.1" + }, + "smmap2-2.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6190a1a305acbd168a0d2c1a33e40786", + "name": "smmap2", + "sha256": "c92bdfbe2877d9ad4c09aa7f2099a5405f26173b935b732f25217ec5c918aeee", + "size": 35985, + "subdir": "linux-64", + "timestamp": 1522774771921, + "version": "2.0.3" + }, + "smmap2-2.0.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "34e823b8ceb42e943c85491e09569e59", + "name": "smmap2", + "sha256": "9bf9f61033f8d52043a21152c9ae272e2097c242b487d7a44d4cb81f7eed3555", + "size": 36828, + "subdir": "linux-64", + "timestamp": 1522774836326, + "version": "2.0.3" + }, + "smmap2-2.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1993b26e6467659875cd9670f900106c", + "name": "smmap2", + "sha256": "933dc9aec495c1b6ceb8c449fc0427ee2fca77415ca0941f8c274d1e2d2a9a2c", + "size": 36410, + "subdir": "linux-64", + "timestamp": 1522774811364, + "version": "2.0.3" + }, + "smmap2-2.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "28c4f80f96b1c0086b38dc4ac15c0049", + "name": "smmap2", + "sha256": "267ee38a9cc4b55f25299253fdd28c889e91ea33f3c8df2b7cd27aeade0df9ce", + "size": 36235, + "subdir": "linux-64", + "timestamp": 1530890653505, + "version": "2.0.3" + }, + "smmap2-2.0.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a36b388a4d0c6e2d46a0b1eb346d2687", + "name": "smmap2", + "sha256": "6b88b5c5e7c4dbcdc97e70ad861cf7b92503f4d9782e0e972c39333557c6058d", + "size": 37780, + "subdir": "linux-64", + "timestamp": 1535498311332, + "version": "2.0.4" + }, + "smmap2-2.0.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "69a8e2af1b5848637ec84b2097a7e789", + "name": "smmap2", + "sha256": "f9b7a1d931b900a2416d9229aa294fa5259adb24da93fed28930034fe8499569", + "size": 38298, + "subdir": "linux-64", + "timestamp": 1535498390762, + "version": "2.0.4" + }, + "smmap2-2.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "060aeab29de0f6b7293e0e19e3d8dbb2", + "name": "smmap2", + "sha256": "57fec044bb3e79eaaa582f92dd70035af9ec854597fb23d7c2e83bd605173ef3", + "size": 37948, + "subdir": "linux-64", + "timestamp": 1535498274007, + "version": "2.0.4" + }, + "smmap2-2.0.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c722597a2d1d219fbdea6039dd9076d4", + "name": "smmap2", + "sha256": "ae70412dd31492037660d550da0e42835bd3ba8443dd9e4ee9d1996f63e6a317", + "size": 38168, + "subdir": "linux-64", + "timestamp": 1535498330349, + "version": "2.0.4" + }, + "smmap2-2.0.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "189fa07f17f40bea2d67a7242da25d63", + "name": "smmap2", + "sha256": "d0c99af4a9fe4c576e1016205717bc07f70cdc2994d8df7eb56e0b190c8938ad", + "size": 38553, + "subdir": "linux-64", + "timestamp": 1539644976482, + "version": "2.0.5" + }, + "smmap2-2.0.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2c098d324dfbd49dc8fb71b56d768a5e", + "name": "smmap2", + "sha256": "eb3205fa6a3780d105a3285f39177e87bd70701ea431ca1e9c95c0376cc1f295", + "size": 38964, + "subdir": "linux-64", + "timestamp": 1539644996467, + "version": "2.0.5" + }, + "smmap2-2.0.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a3df0c8494add023a3ba6fcf8c6c9324", + "name": "smmap2", + "sha256": "18ca4a18ee3f8547db5220088e9f606058b2aea343d558370a7da806352088a3", + "size": 38955, + "subdir": "linux-64", + "timestamp": 1539644988489, + "version": "2.0.5" + }, + "snakebite-2.11.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "protobuf >2.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5975d60f633916411641500c0306ffa2", + "name": "snakebite", + "sha256": "26c781d7c480aff851e4e4a51e687618825e50e9bb256943068ab070577f97f2", + "size": 138710, + "subdir": "linux-64", + "timestamp": 1522776065542, + "version": "2.11.0" + }, + "snakebite-py3-3.0.5-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "protobuf >2.4.1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2424d81e50670141e3a69f4132f6ea44", + "name": "snakebite-py3", + "sha256": "afbd35dc146f030bf21fc2369811fdd209a7eecdf70a6f14fb8eb20dcb7a953f", + "size": 143753, + "subdir": "linux-64", + "timestamp": 1659787093381, + "version": "3.0.5" + }, + "snakebite-py3-3.0.5-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "protobuf >2.4.1", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "04c44ad0399c53c823ba55217bf9e0fe", + "name": "snakebite-py3", + "sha256": "e081d22ee0755d755cfb84dd181fd3293b52e924f998c1a9093fc56a2439ce6c", + "size": 186284, + "subdir": "linux-64", + "timestamp": 1676845832471, + "version": "3.0.5" + }, + "snakebite-py3-3.0.5-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "protobuf >2.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e9a22bc75c79c6502fc673e6f508b9c9", + "name": "snakebite-py3", + "sha256": "1fb93648fae9c621e85c6deeb21cb18614bff4c13c1929b08f68b4a9407d13d6", + "size": 141099, + "subdir": "linux-64", + "timestamp": 1659787151786, + "version": "3.0.5" + }, + "snakebite-py3-3.0.5-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "protobuf >2.4.1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "00f26ac60a0f02c06a87a07a7b9543f1", + "name": "snakebite-py3", + "sha256": "d49337531a320da8abc7fc549c30c8360b01dbc526094c453c88bb530d54bc20", + "size": 141690, + "subdir": "linux-64", + "timestamp": 1659787051861, + "version": "3.0.5" + }, + "snakebite-py3-3.0.5-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "protobuf >2.4.1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "91bf0762f528783df6d567ed8ec8798b", + "name": "snakebite-py3", + "sha256": "4bafe40cb982382a6853cddbfa3c966444d215ee1b140ad09e4cb0f9749e4729", + "size": 141613, + "subdir": "linux-64", + "timestamp": 1659787124007, + "version": "3.0.5" + }, + "snakeviz-0.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "586bb13bfddbb4c5256de010c332283f", + "name": "snakeviz", + "sha256": "28f64edfe9a38d505ee2910a543283c1615071f1190ebc283bfbaa2ed489ef0c", + "size": 167854, + "subdir": "linux-64", + "timestamp": 1530961128249, + "version": "0.4.2" + }, + "snakeviz-0.4.2-py27hf4b41a6_0.conda": { + "build": "py27hf4b41a6_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "51f9b1f110d75d312b47b4030d1ba2fc", + "name": "snakeviz", + "sha256": "f78083dbad9b46cd23309613de4ab53ffa960376a51b15117a50761e920a2ba1", + "size": 167996, + "subdir": "linux-64", + "timestamp": 1509050080501, + "version": "0.4.2" + }, + "snakeviz-0.4.2-py35h5e3ed1c_0.conda": { + "build": "py35h5e3ed1c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "d265a406e97501fcd979177ed5d04e15", + "name": "snakeviz", + "sha256": "e64416c1f190b1a3ab988dae264e2b24e46bc3c86cd06f4bc5c89604d0d532fd", + "size": 168111, + "subdir": "linux-64", + "timestamp": 1509050132838, + "version": "0.4.2" + }, + "snakeviz-0.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "96ed6dae662142628773c7b009c7b37d", + "name": "snakeviz", + "sha256": "df12fe5406af106c7a6bcd61584608fde073c7aabfd0ec19886c3d7c6cac25a2", + "size": 167867, + "subdir": "linux-64", + "timestamp": 1530961159882, + "version": "0.4.2" + }, + "snakeviz-0.4.2-py36h8fadade_0.conda": { + "build": "py36h8fadade_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "2a8047ed0f9702581586fa494f0e041c", + "name": "snakeviz", + "sha256": "8c670bac2a8e7c202cc19a554fb04fd0f2701f69deb3217f3fbf01ff150a2394", + "size": 167978, + "subdir": "linux-64", + "timestamp": 1509050130945, + "version": "0.4.2" + }, + "snakeviz-0.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "aa3b9590778756990eac7b650b376f61", + "name": "snakeviz", + "sha256": "a7f85884ad82794502f08ebcd911d20a54ed54cce64aa95af42b67468571834f", + "size": 167897, + "subdir": "linux-64", + "timestamp": 1530961191637, + "version": "0.4.2" + }, + "snakeviz-1.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "5420e389736f5b05aeb6e35e9136d931", + "name": "snakeviz", + "sha256": "c98ec036e94d5c97700c4fce10303cc6299ae54c03be125078a837a489c0b553", + "size": 169650, + "subdir": "linux-64", + "timestamp": 1536109662221, + "version": "1.0.0" + }, + "snakeviz-1.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "f52df144ce4827f44ec6b70bba83471d", + "name": "snakeviz", + "sha256": "2e056d0b24c7bf54d32eb04ed0f9d26e1fd5e17f244412d55dbc01a7e0c2b8d4", + "size": 169854, + "subdir": "linux-64", + "timestamp": 1536109721452, + "version": "1.0.0" + }, + "snakeviz-1.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "4cbed73c7b16a77f71b7adb93e8b7da6", + "name": "snakeviz", + "sha256": "a92d33f067256bf12a7b0cf085219096dc9bcf4fa0d93b2e114a01bf1a3af147", + "size": 169647, + "subdir": "linux-64", + "timestamp": 1536109623410, + "version": "1.0.0" + }, + "snakeviz-1.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "43374216503878a727449e4e825fe806", + "name": "snakeviz", + "sha256": "db4a922ae4e76494784701bfa19388cc8837eb1a52a4cf63703b0f23f4c72381", + "size": 169693, + "subdir": "linux-64", + "timestamp": 1536109735701, + "version": "1.0.0" + }, + "snakeviz-2.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "c0617c129dd09f0460711ade2d7fe8c8", + "name": "snakeviz", + "sha256": "c59360b4e5ccaf4372d76742451a6b1a42b4e567514f4fa43c3986d6ccbe192f", + "size": 332470, + "subdir": "linux-64", + "timestamp": 1564707340907, + "version": "2.0.1" + }, + "snakeviz-2.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "1817fd7ddb14257fe0b9d8b6216c9971", + "name": "snakeviz", + "sha256": "370896bc5b330f5d329d54dff84deddfa90c4b0d08307f8cb34aad68cf68056b", + "size": 172121, + "subdir": "linux-64", + "timestamp": 1640810912686, + "version": "2.0.1" + }, + "snakeviz-2.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "03d8edf6051d2bbcb434e52342c4852a", + "name": "snakeviz", + "sha256": "9b81bb80db919bcb6b2cce2e312f8ddd777c9513a4b390a461eba802fbef53e1", + "size": 176694, + "subdir": "linux-64", + "timestamp": 1676907678308, + "version": "2.0.1" + }, + "snakeviz-2.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "eaecf33559f9778f6826aeab15d587d5", + "name": "snakeviz", + "sha256": "46de62332461da80bfb96f61c7bcfac98df9b96e2d14027f450edb8e7a100357", + "size": 333040, + "subdir": "linux-64", + "timestamp": 1564707373123, + "version": "2.0.1" + }, + "snakeviz-2.0.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "e4906d1a081c06fe0fd2f27cf08171d4", + "name": "snakeviz", + "sha256": "e98e04931000d8b9d7848cb7fd1108b7716d4a76130d65e901c91b245996d179", + "size": 464747, + "subdir": "linux-64", + "timestamp": 1632756936391, + "version": "2.0.1" + }, + "snakeviz-2.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "5ff59cc53d6656bbd2394c960b778963", + "name": "snakeviz", + "sha256": "6b6a09c1bce738f0ca96eb1e415fb094292c6d576bd124ef793a61193cdf9626", + "size": 331996, + "subdir": "linux-64", + "timestamp": 1564707332811, + "version": "2.0.1" + }, + "snakeviz-2.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "2b2a9b7f58fc686ab0d0d248c9f88892", + "name": "snakeviz", + "sha256": "9811debf6c7fda6b8fb0ca7abeb318e19a9839046f72eb036f0d8a2566dd685d", + "size": 464709, + "subdir": "linux-64", + "timestamp": 1632746603985, + "version": "2.0.1" + }, + "snakeviz-2.0.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "70c13a73dc817e2cf0a5590f3606745d", + "name": "snakeviz", + "sha256": "bc169a2e62e393a05191735bc5426a0fc88c08245ca1a02f6a1f7db1b2c12ccf", + "size": 172398, + "subdir": "linux-64", + "timestamp": 1573557179354, + "version": "2.0.1" + }, + "snakeviz-2.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "106357aab51b20535ac3a59a48035875", + "name": "snakeviz", + "sha256": "95aad4a4ab4b1cb88a4a4c154d5903e759593c91a6e84fdb80ca5b0aa9a2c17d", + "size": 464905, + "subdir": "linux-64", + "timestamp": 1632756959537, + "version": "2.0.1" + }, + "snakeviz-2.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "tornado >=2.0" + ], + "license": "BSD", + "md5": "16a831397201a56f2c5c870eff07edb1", + "name": "snakeviz", + "sha256": "7e9e4d64be15010f0795326c53d6a1a270e193a129f4d82700fed2e177227873", + "size": 464651, + "subdir": "linux-64", + "timestamp": 1632756962813, + "version": "2.0.1" + }, + "snappy-1.1.6-h4f0f562_2.conda": { + "build": "h4f0f562_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "552b4b32c8793f12ea5374e10129d25f", + "name": "snappy", + "sha256": "5719c6e60f48447cb57df5824f684e48e3f16f89868cb5482b8653690d421e06", + "size": 35360, + "subdir": "linux-64", + "timestamp": 1505740623562, + "version": "1.1.6" + }, + "snappy-1.1.7-h493ac5f_1.conda": { + "build": "h493ac5f_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "968da7bcd67f720432cee99f449030b3", + "name": "snappy", + "sha256": "62433c46ad3ed8e11aada7957b8f5cecfcf37cca5d0accc9b12cee5cf9133646", + "size": 36099, + "subdir": "linux-64", + "timestamp": 1508782495126, + "version": "1.1.7" + }, + "snappy-1.1.7-h88f177e_2.conda": { + "build": "h88f177e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d792b634a257e325fa701c0777ad9fe7", + "name": "snappy", + "sha256": "a502e164cd98c3587d7de6aeb7c50d267b034e0ed0c630c461938303bf09a414", + "size": 36227, + "subdir": "linux-64", + "timestamp": 1510171715979, + "version": "1.1.7" + }, + "snappy-1.1.7-hbae5bb6_3.conda": { + "build": "hbae5bb6_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "68f42b610823a4f0cdc86d5bee6e8e04", + "name": "snappy", + "sha256": "35e393c9df2304e7f23cd01a53af623e350f4b2641abb29f34cfbe4ec00161b5", + "size": 36286, + "subdir": "linux-64", + "timestamp": 1511805960762, + "version": "1.1.7" + }, + "snappy-1.1.8-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ae25e5e0fe1cc047fff7314df6bc1368", + "name": "snappy", + "sha256": "098136c7994f758ca60b006e19001452933bf08073f9b93544e4740a895254a8", + "size": 40894, + "subdir": "linux-64", + "timestamp": 1592866364308, + "version": "1.1.8" + }, + "snappy-1.1.9-h295c915_0.conda": { + "build": "h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-clause AND CC-BY-3.0 AND MIT AND CC-BY AND Public Domain", + "license_family": "BSD", + "md5": "807eab3ad2fe697e8013dd6b9ea830f2", + "name": "snappy", + "sha256": "d073a1e9f4cb5d86aae341338aee24b5dd4e7ea658892f28dfab4c05766aa6d2", + "size": 651558, + "subdir": "linux-64", + "timestamp": 1649923859475, + "version": "1.1.9" + }, + "sniffio-1.1.0-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "contextvars >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "APACHE", + "license_family": "APACHE", + "md5": "92497e360edf114edaa5c7bfdfb29ccf", + "name": "sniffio", + "sha256": "c8d5934327ae9eea70bf594f6d16b3a04971a1588f0af8d39092242c4a1c115c", + "size": 16408, + "subdir": "linux-64", + "timestamp": 1594058998790, + "version": "1.1.0" + }, + "sniffio-1.1.0-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "APACHE", + "license_family": "APACHE", + "md5": "b2c99a3eb6732323692ab6d814a61c5e", + "name": "sniffio", + "sha256": "3ba6c4ea2adbb9fb385f59e3b0dc7a98c7ac728f3df16b2b588835ed2678249b", + "size": 16442, + "subdir": "linux-64", + "timestamp": 1594058994037, + "version": "1.1.0" + }, + "sniffio-1.1.0-py38_2.conda": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "APACHE", + "license_family": "APACHE", + "md5": "5273f224dce5a059b54a148dc42d902d", + "name": "sniffio", + "sha256": "cde8f95776d0ba413746ae2fd192ddda06e7b43a23be8bf0650772ddd8dcffd9", + "size": 16459, + "subdir": "linux-64", + "timestamp": 1594058990221, + "version": "1.1.0" + }, + "sniffio-1.2.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e96512dfcf7ce766b5b5d1fffd3fb3d6", + "name": "sniffio", + "sha256": "da0df26b8dfc41404748b9504bed4e6fa8eb544f7fd8351274aad90da3767c98", + "size": 14927, + "subdir": "linux-64", + "timestamp": 1640794815222, + "version": "1.2.0" + }, + "sniffio-1.2.0-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dc25b16f59a3b54ac2e33f3dac5209d2", + "name": "sniffio", + "sha256": "3b6f4ad5871418c779809a40c20a560082e9e04cb65bd70e8cee24b2dbbb05c8", + "size": 16172, + "subdir": "linux-64", + "timestamp": 1676823755808, + "version": "1.2.0" + }, + "sniffio-1.2.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "contextvars >=2.1", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c22a68883aaecfcdb3fb8d0dc83ee70e", + "name": "sniffio", + "sha256": "2228cf6ca94fecb9050edc9dd02d5970b470a1a93ad100a0c90fcc113e737ccb", + "size": 14970, + "subdir": "linux-64", + "timestamp": 1614030506826, + "version": "1.2.0" + }, + "sniffio-1.2.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "00edda373ff5f7eb3c6c303ec1e484ee", + "name": "sniffio", + "sha256": "d51172ab1286cab82a8f097d0037f1b9787c81929a2259d1a93ad4f47705438f", + "size": 14938, + "subdir": "linux-64", + "timestamp": 1614030514952, + "version": "1.2.0" + }, + "sniffio-1.2.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "95d3411f0f78c324a6655a2b370df2c5", + "name": "sniffio", + "sha256": "32718ccaffe34f63aa69ec1343ed5f992a16f510feed9223b0784c898643b527", + "size": 14959, + "subdir": "linux-64", + "timestamp": 1614030513783, + "version": "1.2.0" + }, + "sniffio-1.2.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "19afe6aee9d5ce1af860eb5734813fbd", + "name": "sniffio", + "sha256": "a169448a6dd8cae312b1dcc1422c274c60aa7911a1c6720db369f7db372ad96a", + "size": 14959, + "subdir": "linux-64", + "timestamp": 1614030498860, + "version": "1.2.0" + }, + "snowballstemmer-1.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "02729c028a36a0e6cab393fc85327e00", + "name": "snowballstemmer", + "sha256": "c349c20b50f0ea283cc887ae2b2b3653f5101c9cbe6e541272e8dd87225e5a9a", + "size": 85497, + "subdir": "linux-64", + "timestamp": 1530695042365, + "version": "1.2.1" + }, + "snowballstemmer-1.2.1-py27h44e2768_0.conda": { + "build": "py27h44e2768_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "f96ea75dddea2aa89426dd838ca34ab5", + "name": "snowballstemmer", + "sha256": "4b9f5f0721ca22888945b62882ec2b9d72e844da930e19a0eb60157c628ccb96", + "size": 85347, + "subdir": "linux-64", + "timestamp": 1505746914693, + "version": "1.2.1" + }, + "snowballstemmer-1.2.1-py35h5435977_0.conda": { + "build": "py35h5435977_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD-2-Clause", + "md5": "6db01e6b0fbfe1ea246183171d804384", + "name": "snowballstemmer", + "sha256": "2e0aef49ae4f3d93d4964480755dfa44f804fcb76fa256ea9285630c64535e47", + "size": 90391, + "subdir": "linux-64", + "timestamp": 1505746928425, + "version": "1.2.1" + }, + "snowballstemmer-1.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "d21419bd07a17179061f851c4e8c371a", + "name": "snowballstemmer", + "sha256": "28f108354f8c9cd516592d93d9905e2c6c3be2f4b0b5fdcc712ba48ed6c37ad2", + "size": 91178, + "subdir": "linux-64", + "timestamp": 1530695002582, + "version": "1.2.1" + }, + "snowballstemmer-1.2.1-py36h6febd40_0.conda": { + "build": "py36h6febd40_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-2-Clause", + "md5": "5bbbcf5385028c41ba81443da16c9b96", + "name": "snowballstemmer", + "sha256": "99b2a1fcd4e94048d8f96cf3da2e33df495481fff82eb5ac9ef1e76c401f8aac", + "size": 90897, + "subdir": "linux-64", + "timestamp": 1505746942144, + "version": "1.2.1" + }, + "snowballstemmer-1.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "md5": "0d3969aef263e41684a285eea85ba1e9", + "name": "snowballstemmer", + "sha256": "8244de08c4c3f21f56ed8ee7add075eddcfb24628904e289d2e1ab541173326f", + "size": 87754, + "subdir": "linux-64", + "timestamp": 1530695023049, + "version": "1.2.1" + }, + "snowflake-connector-python-2.6.2-py36h51133e4_0.conda": { + "build": "py36h51133e4_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "azure-common <2", + "azure-storage-blob >=12.0.0,<13.0.0", + "boto3 >=1.4.4,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=2.5.0,<4.0.0", + "dataclasses <1", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<21.0.0", + "python >=3.6,<3.7.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bc58741f890a3b8a0e732de1cdda95e9", + "name": "snowflake-connector-python", + "sha256": "ee660e59612e56a7210f769db01c31d484ea8f0e27a0f4ef13784883b4ddd87a", + "size": 657965, + "subdir": "linux-64", + "timestamp": 1633352413795, + "version": "2.6.2" + }, + "snowflake-connector-python-2.6.2-py37h51133e4_0.conda": { + "build": "py37h51133e4_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "azure-common <2", + "azure-storage-blob >=12.0.0,<13.0.0", + "boto3 >=1.4.4,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=2.5.0,<4.0.0", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<21.0.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ee95b0fe60f610737f00a38bb41edc30", + "name": "snowflake-connector-python", + "sha256": "b0b9372a570672ccf111de079f4deaa1f0e630fcb36ce9c7f6b1dcca348ecc0b", + "size": 658241, + "subdir": "linux-64", + "timestamp": 1633363051996, + "version": "2.6.2" + }, + "snowflake-connector-python-2.6.2-py37h51133e4_1.conda": { + "build": "py37h51133e4_1", + "build_number": 1, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "azure-common <2", + "azure-storage-blob >=12.0.0,<13.0.0", + "boto3 >=1.4.4,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=2.5.0,<4.0.0", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<21.0.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "79e4b782bd7e7bdab90d62cd95b45ad0", + "name": "snowflake-connector-python", + "sha256": "9904f0ac1a95aa259ddb8119eee4a28de9a30ac8aacf69571f3a91723e3b993d", + "size": 654359, + "subdir": "linux-64", + "timestamp": 1653636153057, + "version": "2.6.2" + }, + "snowflake-connector-python-2.6.2-py38h51133e4_0.conda": { + "build": "py38h51133e4_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "azure-common <2", + "azure-storage-blob >=12.0.0,<13.0.0", + "boto3 >=1.4.4,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=2.5.0,<4.0.0", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<21.0.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1a2b3d71647fc81e4bb447177807278d", + "name": "snowflake-connector-python", + "sha256": "41227bd4aa8048e8aa7520df395faf066237021947fd43be1cb303285dfdad77", + "size": 671046, + "subdir": "linux-64", + "timestamp": 1633362976858, + "version": "2.6.2" + }, + "snowflake-connector-python-2.6.2-py38h51133e4_1.conda": { + "build": "py38h51133e4_1", + "build_number": 1, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "azure-common <2", + "azure-storage-blob >=12.0.0,<13.0.0", + "boto3 >=1.4.4,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=2.5.0,<4.0.0", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<21.0.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6d1567821bd35335f13de44a0b75dc8d", + "name": "snowflake-connector-python", + "sha256": "90c8f6812877d758677f12332281924b538d7feb2f58c838d793ffc0d4301f2c", + "size": 660365, + "subdir": "linux-64", + "timestamp": 1653636382224, + "version": "2.6.2" + }, + "snowflake-connector-python-2.6.2-py39h51133e4_0.conda": { + "build": "py39h51133e4_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "azure-common <2", + "azure-storage-blob >=12.0.0,<13.0.0", + "boto3 >=1.4.4,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=2.5.0,<4.0.0", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<21.0.0", + "python >=3.9,<3.10.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a68f85dcedb800251bdb2e1efb7bc214", + "name": "snowflake-connector-python", + "sha256": "0b8788eedbd4022351f279adcb6ba3967aa8e051cfa6f02ccb3fb498ee8f5b69", + "size": 665160, + "subdir": "linux-64", + "timestamp": 1633363031184, + "version": "2.6.2" + }, + "snowflake-connector-python-2.6.2-py39h51133e4_1.conda": { + "build": "py39h51133e4_1", + "build_number": 1, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "azure-common <2", + "azure-storage-blob >=12.0.0,<13.0.0", + "boto3 >=1.4.4,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=2.5.0,<4.0.0", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<21.0.0", + "python >=3.9,<3.10.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "090f1391800b5707d789304606a68260", + "name": "snowflake-connector-python", + "sha256": "d2007a7b2de85798e72d623e39043bf0230dca3c7e2f55d26cdcbc3c21fbe0be", + "size": 660715, + "subdir": "linux-64", + "timestamp": 1653636269273, + "version": "2.6.2" + }, + "snowflake-connector-python-2.7.11-py310h1128e8f_0.conda": { + "build": "py310h1128e8f_0", + "build_number": 0, + "constrains": [ + "keyring !=16.1.0,<24.0.0", + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=8.0.0,<9.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer >=2,<3", + "cryptography >=3.1.0,<37.0.0", + "idna >=2.5,<4", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "oscrypto <2.0.0", + "pyarrow", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.10,<3.11.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0", + "typing-extensions >=4.3.0,<5", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3315763cadbd2fe01eca404f179bbd43", + "name": "snowflake-connector-python", + "sha256": "90fe846af2ed8409ae1368ce7f6a2b2552bc97b5d5375532092827deb4f67a53", + "size": 2553652, + "subdir": "linux-64", + "timestamp": 1659699368534, + "version": "2.7.11" + }, + "snowflake-connector-python-2.7.11-py37h417a72b_0.conda": { + "build": "py37h417a72b_0", + "build_number": 0, + "constrains": [ + "keyring !=16.1.0,<24.0.0", + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=8.0.0,<9.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer >=2,<3", + "cryptography >=3.1.0,<37.0.0", + "idna >=2.5,<4", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "oscrypto <2.0.0", + "pyarrow", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0", + "typing-extensions >=4.3.0,<5", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9c2046ebb7eb7ffb10968147b782fdbb", + "name": "snowflake-connector-python", + "sha256": "c12637c5121e9b8fd84e9465510d8bfff883f31bd85d01e670efb4f58b3aa48a", + "size": 669558, + "subdir": "linux-64", + "timestamp": 1659699186894, + "version": "2.7.11" + }, + "snowflake-connector-python-2.7.11-py38h417a72b_0.conda": { + "build": "py38h417a72b_0", + "build_number": 0, + "constrains": [ + "keyring !=16.1.0,<24.0.0", + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=8.0.0,<9.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer >=2,<3", + "cryptography >=3.1.0,<37.0.0", + "idna >=2.5,<4", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "oscrypto <2.0.0", + "pyarrow", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0", + "typing-extensions >=4.3.0,<5", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d488fa7c86534904addb61876813ca57", + "name": "snowflake-connector-python", + "sha256": "f1481fdadc5ba6fcf106d9c764b81880e571cafd050d39dcabe0cee29e71bf12", + "size": 675830, + "subdir": "linux-64", + "timestamp": 1659699268980, + "version": "2.7.11" + }, + "snowflake-connector-python-2.7.11-py39h417a72b_0.conda": { + "build": "py39h417a72b_0", + "build_number": 0, + "constrains": [ + "keyring !=16.1.0,<24.0.0", + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=8.0.0,<9.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer >=2,<3", + "cryptography >=3.1.0,<37.0.0", + "idna >=2.5,<4", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "oscrypto <2.0.0", + "pyarrow", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.9,<3.10.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0", + "typing-extensions >=4.3.0,<5", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4c2d9c9d3a5fe97a56d6c5739da101b3", + "name": "snowflake-connector-python", + "sha256": "6b0afed820b5b92d6c64c297768faf677329624cb25dd86b9e09446db3839694", + "size": 676499, + "subdir": "linux-64", + "timestamp": 1659699453921, + "version": "2.7.11" + }, + "snowflake-connector-python-2.7.12-py310h1128e8f_0.conda": { + "build": "py310h1128e8f_0", + "build_number": 0, + "constrains": [ + "keyring !=16.1.0,<24.0.0", + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=8.0.0,<9.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer >=2,<3", + "cryptography >=3.1.0,<37.0.0", + "filelock >=3.5,<4", + "idna >=2.5,<4", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "oscrypto <2.0.0", + "pyarrow", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.10,<3.11.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0", + "typing-extensions >=4.3.0,<5", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a2c02d40f74f1d5b841953c6c2b04397", + "name": "snowflake-connector-python", + "sha256": "94e0a9d57179e61603823a06513bae435aa8b0a6d29a8b1f77a3c153473017c8", + "size": 2563447, + "subdir": "linux-64", + "timestamp": 1662316833462, + "version": "2.7.12" + }, + "snowflake-connector-python-2.7.12-py37h417a72b_0.conda": { + "build": "py37h417a72b_0", + "build_number": 0, + "constrains": [ + "keyring !=16.1.0,<24.0.0", + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=8.0.0,<9.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer >=2,<3", + "cryptography >=3.1.0,<37.0.0", + "filelock >=3.5,<4", + "idna >=2.5,<4", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "oscrypto <2.0.0", + "pyarrow", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0", + "typing-extensions >=4.3.0,<5", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0fa788532c9e6f0a83cf3b454cc7385d", + "name": "snowflake-connector-python", + "sha256": "b07031581c9aff25220a3f2a80cab3d3fc8d5b8ed32e4221ffd3ccd4bdeedbed", + "size": 677757, + "subdir": "linux-64", + "timestamp": 1662316953786, + "version": "2.7.12" + }, + "snowflake-connector-python-2.7.12-py38h417a72b_0.conda": { + "build": "py38h417a72b_0", + "build_number": 0, + "constrains": [ + "keyring !=16.1.0,<24.0.0", + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=8.0.0,<9.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer >=2,<3", + "cryptography >=3.1.0,<37.0.0", + "filelock >=3.5,<4", + "idna >=2.5,<4", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "oscrypto <2.0.0", + "pyarrow", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0", + "typing-extensions >=4.3.0,<5", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d9646ece4a13c1edd86b1c58d988be0a", + "name": "snowflake-connector-python", + "sha256": "e3b86c33fa8f862858e72c958ed4ccef831c01f2f2b0c7eb10fde068a241a94b", + "size": 683475, + "subdir": "linux-64", + "timestamp": 1662317070343, + "version": "2.7.12" + }, + "snowflake-connector-python-2.7.12-py39h417a72b_0.conda": { + "build": "py39h417a72b_0", + "build_number": 0, + "constrains": [ + "keyring !=16.1.0,<24.0.0", + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=8.0.0,<9.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer >=2,<3", + "cryptography >=3.1.0,<37.0.0", + "filelock >=3.5,<4", + "idna >=2.5,<4", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "oscrypto <2.0.0", + "pyarrow", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.9,<3.10.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0", + "typing-extensions >=4.3.0,<5", + "urllib3 >=1.21.1,<1.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "982169f82e97882808a4d99e3c623381", + "name": "snowflake-connector-python", + "sha256": "426b1b47b2aec526662915d330a321eb0b251c42c6bf4307d45b848448c3d500", + "size": 681962, + "subdir": "linux-64", + "timestamp": 1662316687300, + "version": "2.7.12" + }, + "snowflake-connector-python-2.7.8-py37h51133e4_0.conda": { + "build": "py37h51133e4_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=3.1.0,<37.0.0", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "106a20d6b0c172f97f9909e555cfe643", + "name": "snowflake-connector-python", + "sha256": "8cda3bf817ff7a2d260bb4731a27183cf662371905aefde7d885f2c3046d1e9a", + "size": 645119, + "subdir": "linux-64", + "timestamp": 1653663697152, + "version": "2.7.8" + }, + "snowflake-connector-python-2.7.8-py38h51133e4_0.conda": { + "build": "py38h51133e4_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=3.1.0,<37.0.0", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9e71d6e23f23f39981af82186ed2b5bb", + "name": "snowflake-connector-python", + "sha256": "b636277e9f12dc9b5808bda7c493eb44a8b841a7dfcad350d2b9fa45d868f483", + "size": 650292, + "subdir": "linux-64", + "timestamp": 1653663807909, + "version": "2.7.8" + }, + "snowflake-connector-python-2.7.8-py39h51133e4_0.conda": { + "build": "py39h51133e4_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.5" + ], + "depends": [ + "arrow-cpp >=4.0.1,<4.0.2.0a0", + "asn1crypto >0.24.0,<2.0.0", + "certifi >=2017.4.17", + "cffi >=1.9,<2.0.0", + "charset-normalizer ~=2.0.0", + "cryptography >=3.1.0,<37.0.0", + "idna >=2.5,<4", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "oscrypto <2.0.0", + "pyarrow >=4.0.1,<5.0a0", + "pycryptodomex >=3.2,!=3.5.0,<4.0.0", + "pyjwt <3.0.0", + "pyopenssl >=16.2.0,<23.0.0", + "python >=3.9,<3.10.0a0", + "pytz", + "requests <3.0.0", + "setuptools >34.0.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "191f5c2095657576b943659af2124f19", + "name": "snowflake-connector-python", + "sha256": "33d5ded44774e07d58b9636d76eb71f155e2f542f8d63b4782f4045656b62308", + "size": 649481, + "subdir": "linux-64", + "timestamp": 1653663918064, + "version": "2.7.8" + }, + "snowflake-snowpark-python-0.10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python >=2.7.12", + "typing-extensions >=4.1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bbb2302262bf89a30284eb13ea8c64f4", + "name": "snowflake-snowpark-python", + "sha256": "bdaec09c3fa7f3aa93c112e1be0d0fb0c2466bdc05b43e10e491665f7e74efe4", + "size": 315734, + "subdir": "linux-64", + "timestamp": 1663585453092, + "version": "0.10.0" + }, + "snowflake-snowpark-python-0.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python >=2.7.12", + "typing-extensions >=4.1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "174924bf0db9822d10f7bdea702083e7", + "name": "snowflake-snowpark-python", + "sha256": "e3f0375f3e9856ada32bcdd50a59bebb7477457f7e0411ae52065481c883999e", + "size": 331476, + "subdir": "linux-64", + "timestamp": 1664478363951, + "version": "0.11.0" + }, + "snowflake-snowpark-python-0.12.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python >=2.7.12", + "typing-extensions >=4.1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c80900ae111d93e6f29b8e7666bcf9f9", + "name": "snowflake-snowpark-python", + "sha256": "fa2d0a2943767084c9c0fda01378b7f626ac2135b462adcc83f220e76f1c69c6", + "size": 343427, + "subdir": "linux-64", + "timestamp": 1666196826087, + "version": "0.12.0" + }, + "snowflake-snowpark-python-0.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python", + "typing-extensions >=4.1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a53ec2c9778bca5bfadea6b17f0edd52", + "name": "snowflake-snowpark-python", + "sha256": "1a2aaf765e46ef55f3632200daef0b834462530a50f86380aaffc6e49e95216f", + "size": 261462, + "subdir": "linux-64", + "timestamp": 1654500874046, + "version": "0.6.0" + }, + "snowflake-snowpark-python-0.7.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python", + "typing-extensions >=4.1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "62e709d426c7c98f438c1f7b99338e02", + "name": "snowflake-snowpark-python", + "sha256": "133c673e4b48718ebe409e6142b491ff20eee3b13fc078ff0648f8b7682d9de3", + "size": 278984, + "subdir": "linux-64", + "timestamp": 1653639955548, + "version": "0.7.0" + }, + "snowflake-snowpark-python-0.8.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python >=2.7.4", + "typing-extensions >=4.1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0be770eee294ba36f177178cc682cfd4", + "name": "snowflake-snowpark-python", + "sha256": "bb43e87cca689cefcfd6fb04e5c333dd243fd0b5e2b101b299bfbdc1f82cf78e", + "size": 286621, + "subdir": "linux-64", + "timestamp": 1659013123391, + "version": "0.8.0" + }, + "snowflake-snowpark-python-0.9.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "pandas >1,<1.4" + ], + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python >=2.7.11", + "typing-extensions >=4.1.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ffa41f40f4b3be068619b1ce078582f5", + "name": "snowflake-snowpark-python", + "sha256": "46d731b46afa272b07ce2f5b41290f57dfea351455e48c18fad2163bce01c09c", + "size": 305206, + "subdir": "linux-64", + "timestamp": 1662314403374, + "version": "0.9.0" + }, + "snowflake-snowpark-python-1.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python >=2.7.12,<3.0.0a0", + "typing-extensions >=4.1.0,<5.0.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "57d64a00257b774aeb81e8c57c79a07d", + "name": "snowflake-snowpark-python", + "sha256": "fde020099d4a9f95d0b232e6f505f302448883b839d6822fd065dc35bd6a4915", + "size": 362119, + "subdir": "linux-64", + "timestamp": 1667400753220, + "version": "1.0.0" + }, + "snowflake-snowpark-python-1.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python >=2.7.12,<4.0.0a0", + "typing-extensions >=4.1.0,<5.0.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "627ac703926e165cf95675e29498b9e1", + "name": "snowflake-snowpark-python", + "sha256": "5391068720b2430fec58c89051794dcc5bd479156b4841e729471aad2b35bd36", + "size": 364812, + "subdir": "linux-64", + "timestamp": 1674852942768, + "version": "1.1.0" + }, + "snowflake-snowpark-python-1.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python >=2.7.12,<4.0.0a0", + "typing-extensions >=4.1.0,<5.0.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e6a175dc1adaf9fbb330e0cb5edfc867", + "name": "snowflake-snowpark-python", + "sha256": "ae99fb214b779076a2fc9c7b11eda9acdfb32a989ff3f41789f04191fd23a194", + "size": 373797, + "subdir": "linux-64", + "timestamp": 1677874608165, + "version": "1.2.0" + }, + "snowflake-snowpark-python-1.3.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle >=1.6.0,<=2.0.0", + "python >=3.8,<3.9.0a0", + "snowflake-connector-python >=2.7.12,<4.0.0a0", + "typing-extensions >=4.1.0,<5.0.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "206af71d7f5dbc0339e069320ff7aa18", + "name": "snowflake-snowpark-python", + "sha256": "538ae474c752db0218eba241d0769c5caf1d25101b6cd81351b1e2e0fd1bf701", + "size": 385134, + "subdir": "linux-64", + "timestamp": 1680276482053, + "version": "1.3.0" + }, + "snuggs-1.4.1-py27h9686676_0.conda": { + "build": "py27h9686676_0", + "build_number": 0, + "depends": [ + "click", + "numpy", + "pyparsing", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d31003ffd3f7450962faec0822d9e4b2", + "name": "snuggs", + "sha256": "1d4229e9143b112f87b88cd63bc871057e71cad0a5ee2f7c9172709ff3f633d5", + "size": 10607, + "subdir": "linux-64", + "timestamp": 1506702432874, + "version": "1.4.1" + }, + "snuggs-1.4.1-py35h9ebd86a_0.conda": { + "build": "py35h9ebd86a_0", + "build_number": 0, + "depends": [ + "click", + "numpy", + "pyparsing", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "a5704d325ad704c8be05f28e3af64a84", + "name": "snuggs", + "sha256": "54f85daa874cda7ccacdf469e9e56f0bce1f47439b15b5b408f8d37142a287e2", + "size": 10683, + "subdir": "linux-64", + "timestamp": 1506702447402, + "version": "1.4.1" + }, + "snuggs-1.4.1-py36h2e8bf8d_0.conda": { + "build": "py36h2e8bf8d_0", + "build_number": 0, + "depends": [ + "click", + "numpy", + "pyparsing", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "437c411eb138afe81daca35e9c71780e", + "name": "snuggs", + "sha256": "fa7f4ef78df194d3af7f3f2a8efdf83d0916ae7b132fee5c6b430958ba3045ed", + "size": 10633, + "subdir": "linux-64", + "timestamp": 1506702491027, + "version": "1.4.1" + }, + "snuggs-1.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "click", + "numpy", + "pyparsing", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b3a6be3dda25b344ab982ca46ea5bf84", + "name": "snuggs", + "sha256": "29d80333fdc46571817d4aa560ac831564c4f01522cf89ac3a69f613ca3d6048", + "size": 10474, + "subdir": "linux-64", + "timestamp": 1529417072740, + "version": "1.4.2" + }, + "snuggs-1.4.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "click", + "numpy", + "pyparsing", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "628f62f6de5cc15618cad190a97c1c09", + "name": "snuggs", + "sha256": "53dcd33913baa219863d2e18123c43ef862a5b591cfd4769769941c9b3859935", + "size": 10646, + "subdir": "linux-64", + "timestamp": 1529417091224, + "version": "1.4.2" + }, + "snuggs-1.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "click", + "numpy", + "pyparsing", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "cc6b6764fd2d4c349714e65e3e3edd48", + "name": "snuggs", + "sha256": "f0e13572508bd69ec20bd8e08869f90d88b279c4b6a93d8fae19260a1a83032a", + "size": 10597, + "subdir": "linux-64", + "timestamp": 1529417042679, + "version": "1.4.2" + }, + "snuggs-1.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "click", + "numpy", + "pyparsing", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2cd6237df2f9999f5e8a16fa38871313", + "name": "snuggs", + "sha256": "6b3a128b74b7c73d33d75d43cbd98ba3320d0374380dfb558aedf10b90e2f029", + "size": 10588, + "subdir": "linux-64", + "timestamp": 1530872277449, + "version": "1.4.2" + }, + "soappy-0.12.22-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "defusedxml", + "python >=2.7,<2.8.0a0", + "wstools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5e90e58df1f80571dddb33b01a5c0813", + "name": "soappy", + "sha256": "38f672d9119afce6fff3c2606a4d3de1c324f14f4e2e61d8caa1b7f324d4e700", + "size": 91757, + "subdir": "linux-64", + "timestamp": 1530919312849, + "version": "0.12.22" + }, + "sockjs-tornado-1.0.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "tornado >=2.1.1" + ], + "license": "MIT", + "md5": "e2a0674e6977e94246f54d011f2c0aa9", + "name": "sockjs-tornado", + "sha256": "8af03d0f226300f8fef3331d659aa2b4749fe2317a72cae01494f490e0bb796d", + "size": 42994, + "subdir": "linux-64", + "timestamp": 1537832021447, + "version": "1.0.5" + }, + "sockjs-tornado-1.0.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "tornado >=2.1.1" + ], + "license": "MIT", + "md5": "08308b108b756d0fef60b102b6de3651", + "name": "sockjs-tornado", + "sha256": "113c96389b40af9a2ff813a9329ad4b9c817e9ac9b94426f349a32133cf22898", + "size": 43906, + "subdir": "linux-64", + "timestamp": 1537832107079, + "version": "1.0.5" + }, + "sockjs-tornado-1.0.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "tornado >=2.1.1" + ], + "license": "MIT", + "md5": "0db25df0a5cd5fcd48aea5a2cdd2719a", + "name": "sockjs-tornado", + "sha256": "4a5582df02b3eab3cece4d778bd8435e414aa064af81a0d174d10b79fc7f576b", + "size": 43163, + "subdir": "linux-64", + "timestamp": 1537832095277, + "version": "1.0.5" + }, + "sockjs-tornado-1.0.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "tornado >=2.1.1" + ], + "license": "MIT", + "md5": "17284b841010f7f24b7f4a865139404b", + "name": "sockjs-tornado", + "sha256": "c9ba4e46c56d2171db2c438b2ef406222aa36b23eaf28acd26e6b1e693b530e1", + "size": 43739, + "subdir": "linux-64", + "timestamp": 1537831986525, + "version": "1.0.5" + }, + "sockjs-tornado-1.0.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "tornado >=2.1.1" + ], + "license": "MIT", + "md5": "2e743fdfb39e83c36ffc4558d5a6c363", + "name": "sockjs-tornado", + "sha256": "8931e799a9acf2f2abab84e3df55e8f7c49d4d4d33da85fd0aaa1e4bbf395390", + "size": 42687, + "subdir": "linux-64", + "timestamp": 1541050647794, + "version": "1.0.6" + }, + "sockjs-tornado-1.0.6-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "tornado >=2.1.1" + ], + "license": "MIT", + "md5": "53eb89e7b479fb2cbf6057e3a0ea40f9", + "name": "sockjs-tornado", + "sha256": "7af1db07cb035eb1c0e5df083cc7e18ea0727d9fd4419ce77954465ee877a271", + "size": 44198, + "subdir": "linux-64", + "timestamp": 1640810931370, + "version": "1.0.6" + }, + "sockjs-tornado-1.0.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "tornado >=2.1.1" + ], + "license": "MIT", + "md5": "1d5101b094e055206e1c293b0b583a8b", + "name": "sockjs-tornado", + "sha256": "05c005e50410ca6657d8701b83c427f788939cf7528cdba15a7eeba35c5422df", + "size": 43493, + "subdir": "linux-64", + "timestamp": 1541050676725, + "version": "1.0.6" + }, + "sockjs-tornado-1.0.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "tornado >=2.1.1" + ], + "license": "MIT", + "md5": "125523e83f5186f49dec492212a83c2e", + "name": "sockjs-tornado", + "sha256": "865068308763fbdf71eb0b1007d8c8eea7ebe03279d26179db3d6714aa2f87cb", + "size": 44078, + "subdir": "linux-64", + "timestamp": 1541050625264, + "version": "1.0.6" + }, + "sockjs-tornado-1.0.6-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "tornado >=2.1.1" + ], + "license": "MIT", + "md5": "dd59619ebaffda6b6aa7f13ea167365c", + "name": "sockjs-tornado", + "sha256": "907fbf1e3e5e5bcb874be7f98386c3e39d51356056c8ce49742c6d65de22ecd0", + "size": 43657, + "subdir": "linux-64", + "timestamp": 1573557195925, + "version": "1.0.6" + }, + "sortedcollections-0.5.3-py27h135218e_0.conda": { + "build": "py27h135218e_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "sortedcontainers" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d25a85545ef5af702026873242b378ff", + "name": "sortedcollections", + "sha256": "3aaefc87c8e9e3776d005718fee9f159d75706ed52def274937d0f80983ebe86", + "size": 14775, + "subdir": "linux-64", + "timestamp": 1505755963383, + "version": "0.5.3" + }, + "sortedcollections-0.5.3-py35hb2f60ff_0.conda": { + "build": "py35hb2f60ff_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "sortedcontainers" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7bf1ebe396c762171dfdbe0439d342f3", + "name": "sortedcollections", + "sha256": "4e5e70d883c55b9da373308e3a2a025cfe9d67b2dd53ea26ead57473267d75f4", + "size": 15300, + "subdir": "linux-64", + "timestamp": 1505755976982, + "version": "0.5.3" + }, + "sortedcollections-0.5.3-py36h3c761f9_0.conda": { + "build": "py36h3c761f9_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "sortedcontainers" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d1114f3b172e99c51c55449b529e0459", + "name": "sortedcollections", + "sha256": "2b01d4f05171d0fade776eaba7f616361da8d8eb11a6f043aae5086bc19390b8", + "size": 15022, + "subdir": "linux-64", + "timestamp": 1505755990462, + "version": "0.5.3" + }, + "sortedcollections-0.6.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "sortedcontainers" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7f0ed92d1968de2d3fcbc7db1adab6d9", + "name": "sortedcollections", + "sha256": "664170b28f8fd20b0f9fbc422c9e052491cd2534896a60bb31b7c50a09d6862e", + "size": 15042, + "subdir": "linux-64", + "timestamp": 1521483866268, + "version": "0.6.1" + }, + "sortedcollections-0.6.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "sortedcontainers" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cd45b42f679096f98a770cf02477e163", + "name": "sortedcollections", + "sha256": "7bf596d6c42bfdd1b3484412c5e5074b916f7c2d391ed0a0483cb85eac257a31", + "size": 15469, + "subdir": "linux-64", + "timestamp": 1521483817774, + "version": "0.6.1" + }, + "sortedcollections-0.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "sortedcontainers" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3718e0a67ff31c686f71f0bfc86ae9bd", + "name": "sortedcollections", + "sha256": "18593503bdd3c5df8b5815d7a476e74d5df6b38885b587647e560cecdc791226", + "size": 15498, + "subdir": "linux-64", + "timestamp": 1521483866978, + "version": "0.6.1" + }, + "sortedcollections-1.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "sortedcontainers >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "68fd10fd021105409e96b8c817dc1c96", + "name": "sortedcollections", + "sha256": "c2997d2c0685a757cfd2cfc05f2acc78dbd17102cba98d92944e90534d14d00b", + "size": 15369, + "subdir": "linux-64", + "timestamp": 1527851464280, + "version": "1.0.1" + }, + "sortedcollections-1.0.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "sortedcontainers >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d7dd03f4074276dd04dd6bc4fff9b525", + "name": "sortedcollections", + "sha256": "c88d7f81a810c4bd12a2697e507e51531bd49aca6347b2b4e18d61653d8ef776", + "size": 15896, + "subdir": "linux-64", + "timestamp": 1527851588104, + "version": "1.0.1" + }, + "sortedcollections-1.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "sortedcontainers >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6311fcedb9ada3cb0ed0b68282b420aa", + "name": "sortedcollections", + "sha256": "abe63eda58a235cb4cb4a8fd270c3526ba9532e4ecfb28ba011bdfd16e135b02", + "size": 15727, + "subdir": "linux-64", + "timestamp": 1527851596197, + "version": "1.0.1" + }, + "sortedcollections-1.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "sortedcontainers >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9f8e8e5a7c4ba54221b18be066a9b6f3", + "name": "sortedcollections", + "sha256": "faae63eb6bbc0c0849cdc0d34e9986651eb68041c48c0cbfd15db6517df97519", + "size": 15672, + "subdir": "linux-64", + "timestamp": 1530961224113, + "version": "1.0.1" + }, + "sortedcollections-1.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "sortedcontainers >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ca046e6b40436d884dff70ec00ae2f59", + "name": "sortedcollections", + "sha256": "b1b1e70cd15449dfcae095f4aac8a57c2519073dc96188aee284b43a23f24934", + "size": 18314, + "subdir": "linux-64", + "timestamp": 1547909196220, + "version": "1.1.2" + }, + "sortedcollections-1.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "sortedcontainers >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "db1b41f252b8524ffbd178d9f599e4ef", + "name": "sortedcollections", + "sha256": "1558fe211ccf68883f7bb3d3b5075daedf984ea91e4650f14a62d8e809a3dd1f", + "size": 18455, + "subdir": "linux-64", + "timestamp": 1547909301258, + "version": "1.1.2" + }, + "sortedcollections-1.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "sortedcontainers >=2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "96921b3ecb0be3470fbf35872020a27d", + "name": "sortedcollections", + "sha256": "136d93ac6f6efa6b4dd51a6b9e5eb5272475a62724e9a25064757e05b407592b", + "size": 18533, + "subdir": "linux-64", + "timestamp": 1547909326676, + "version": "1.1.2" + }, + "sortedcontainers-1.5.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "5a794a4d1383a0a326bff269118cfd56", + "name": "sortedcontainers", + "sha256": "ae3c44d694a3a4fbbde289139d41623d04f1bbe3ef1ca5ce8133a6791adf17cb", + "size": 45734, + "subdir": "linux-64", + "timestamp": 1524496433055, + "version": "1.5.10" + }, + "sortedcontainers-1.5.10-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "8391367dcde6dc87d06d1b8fa0541bea", + "name": "sortedcontainers", + "sha256": "1cb7e37b398f237c3cd94f01a749d29d53b1b4bc2db468a377f9b58ffae8b56c", + "size": 46595, + "subdir": "linux-64", + "timestamp": 1524496432554, + "version": "1.5.10" + }, + "sortedcontainers-1.5.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "f7ac2b65dee0a78de6328b27f4aec9ba", + "name": "sortedcontainers", + "sha256": "1dcc507e5625d8c0edecf4243a06d05f14f3b1c5347f63c660dadb7cfd2fb9c7", + "size": 46024, + "subdir": "linux-64", + "timestamp": 1524496442850, + "version": "1.5.10" + }, + "sortedcontainers-1.5.7-py27he59936f_0.conda": { + "build": "py27he59936f_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "f447c8b362e7e63d313016efd5be2e87", + "name": "sortedcontainers", + "sha256": "0a0813136f5db7cbcab861a80234e603ed578587b15d671dbd8a977edae613e1", + "size": 45978, + "subdir": "linux-64", + "timestamp": 1505863970372, + "version": "1.5.7" + }, + "sortedcontainers-1.5.7-py35h683703c_0.conda": { + "build": "py35h683703c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "c3934382a677362399a56939eb153843", + "name": "sortedcontainers", + "sha256": "758796df82d01aa38bdb5aa53f95a03d39541341ec20fae6ebff4488d4ac65b8", + "size": 46781, + "subdir": "linux-64", + "timestamp": 1505863982813, + "version": "1.5.7" + }, + "sortedcontainers-1.5.7-py36hdf89491_0.conda": { + "build": "py36hdf89491_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "d14f7664fa992fd65b459061737d2e09", + "name": "sortedcontainers", + "sha256": "563ded6cf685a47b4420a1e34bcdd6d4ed549ed9c57833d1330d6872a38ce96f", + "size": 46344, + "subdir": "linux-64", + "timestamp": 1505863995502, + "version": "1.5.7" + }, + "sortedcontainers-1.5.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "2fbe75085a47ea08f337e34bf978ac69", + "name": "sortedcontainers", + "sha256": "162b1b8edb488f8dfaa0f6a82b5a24b87083fac89827cb31c5a119c0989ff919", + "size": 46386, + "subdir": "linux-64", + "timestamp": 1515725233323, + "version": "1.5.9" + }, + "sortedcontainers-1.5.9-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "4f40b4a41afa8fbf7e08c558f544d101", + "name": "sortedcontainers", + "sha256": "ed3df83912429a310338b83c848f4f8204c234ec2b8462557203a9b8af79d29d", + "size": 47321, + "subdir": "linux-64", + "timestamp": 1515725064891, + "version": "1.5.9" + }, + "sortedcontainers-1.5.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "b27796f3774153543f4c9d32008f4253", + "name": "sortedcontainers", + "sha256": "56060879de31f8fbeb6587199fd8de3a723ddde82e602f5bed2046108749bde4", + "size": 46718, + "subdir": "linux-64", + "timestamp": 1515724977674, + "version": "1.5.9" + }, + "sortedcontainers-2.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "57451fe912e1511c3503d308468ae4d6", + "name": "sortedcontainers", + "sha256": "42088d87863015f44d62925b5166b4251d34c99e22ffb4e69a796dffecf1a01d", + "size": 42371, + "subdir": "linux-64", + "timestamp": 1527832467708, + "version": "2.0.2" + }, + "sortedcontainers-2.0.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "a88d737c1160f82ce162df7223c1319a", + "name": "sortedcontainers", + "sha256": "17d800285d2ff2062a64f135e29806b57368f2cae8bf1e217bbf1ff5ea054a20", + "size": 43048, + "subdir": "linux-64", + "timestamp": 1527832478837, + "version": "2.0.2" + }, + "sortedcontainers-2.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "70c18195e232ee8fea5b525efb39205b", + "name": "sortedcontainers", + "sha256": "e3cfa1c040478c37f5db46e1117429cb8eee844b5c5492ef6e290b00266e1371", + "size": 42702, + "subdir": "linux-64", + "timestamp": 1527832434429, + "version": "2.0.2" + }, + "sortedcontainers-2.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "e7cf6d0efd825b9e8b9f7b065ca46339", + "name": "sortedcontainers", + "sha256": "66a6d5c8952ead746a5b3cd9ac69ce8f0ca2f4c4d01a6bb4a76891093fc8d569", + "size": 40539, + "subdir": "linux-64", + "timestamp": 1527856511748, + "version": "2.0.3" + }, + "sortedcontainers-2.0.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "12e9b4547d144343a2816e9eb2475c4a", + "name": "sortedcontainers", + "sha256": "90011bfbf60e16de904c94815edd912e50478a6703ffc1d0d4b43b00b77b7134", + "size": 41299, + "subdir": "linux-64", + "timestamp": 1527856576167, + "version": "2.0.3" + }, + "sortedcontainers-2.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "b8d40a2dd524885a53dee2b8ea38e287", + "name": "sortedcontainers", + "sha256": "71d4c52f7acbbfd3ae90c4a63a72896b75133c2a461a8682fda41e5d0db86b2c", + "size": 40904, + "subdir": "linux-64", + "timestamp": 1527856461758, + "version": "2.0.3" + }, + "sortedcontainers-2.0.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "e459b54ca9825524d461d6c9255ece0c", + "name": "sortedcontainers", + "sha256": "fb1dbb1d4a26401bb7e0c5b3e79703ea59a02840eeae6640b3ca13167b03a066", + "size": 41071, + "subdir": "linux-64", + "timestamp": 1528895860248, + "version": "2.0.4" + }, + "sortedcontainers-2.0.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "4ce970ea99c25ffd4e030015b3c3f0fd", + "name": "sortedcontainers", + "sha256": "df1a3b0d5d5d0220704de93ee7116b4cfc186200be0ae69715b46c60c851ecfc", + "size": 42911, + "subdir": "linux-64", + "timestamp": 1528895986983, + "version": "2.0.4" + }, + "sortedcontainers-2.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "9bf2742161e4799e6c829e692b28d787", + "name": "sortedcontainers", + "sha256": "b6e9d88ceb1cd2cb33d63ee774bcc284fd9585f47a19fcf6877a8785f3aa55bb", + "size": 41429, + "subdir": "linux-64", + "timestamp": 1528895795796, + "version": "2.0.4" + }, + "sortedcontainers-2.0.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "551680a275f9a3c2636c195d0f6a795d", + "name": "sortedcontainers", + "sha256": "f580b58fcbec0314ada753b1e2b29dc57c9853d641013951c42788f8f6f167b1", + "size": 42594, + "subdir": "linux-64", + "timestamp": 1530741443182, + "version": "2.0.4" + }, + "sortedcontainers-2.0.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "89f2f42304a3abbc2b8bef7eb4fb804f", + "name": "sortedcontainers", + "sha256": "d06dfbe89a7e1b1d3711d3e61dd3d60a5ccee024629c972291eb817d0a0074ed", + "size": 41657, + "subdir": "linux-64", + "timestamp": 1536077278427, + "version": "2.0.5" + }, + "sortedcontainers-2.0.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "a04748e0363224ddf6026b76b52b9332", + "name": "sortedcontainers", + "sha256": "cd2a3f778de5869f455d8230c7aad0ae138e7f858510f44fc98117a4bd2bca5b", + "size": 43064, + "subdir": "linux-64", + "timestamp": 1536077295315, + "version": "2.0.5" + }, + "sortedcontainers-2.0.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "5b7a564abceab34087b7bd728cf92ec2", + "name": "sortedcontainers", + "sha256": "99c2e622610dd7fe1a1ec1f45eae805c3c3ece5a9f40ce9b12d137a61cddc2d5", + "size": 41830, + "subdir": "linux-64", + "timestamp": 1536077255432, + "version": "2.0.5" + }, + "sortedcontainers-2.0.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "2cfa0fc5b0a98226c08c93b919165540", + "name": "sortedcontainers", + "sha256": "342ce14e81134fd6de336a65b92a38c2c1b5c9d999d9808db1a13650c746d2c2", + "size": 41885, + "subdir": "linux-64", + "timestamp": 1536077316897, + "version": "2.0.5" + }, + "sortedcontainers-2.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "60b97bb5ac59833848b1a00e44f45083", + "name": "sortedcontainers", + "sha256": "a4abbb9aebff6ad592884e8b97e795715543a2aa7339204091bd5cb741baec76", + "size": 44688, + "subdir": "linux-64", + "timestamp": 1543617821716, + "version": "2.1.0" + }, + "sortedcontainers-2.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "2e339f47639f2c10949bd17acde4d15a", + "name": "sortedcontainers", + "sha256": "d72979c0b12f8815cab5095276ee1cdc8655696c2580c844ed36851704632765", + "size": 43849, + "subdir": "linux-64", + "timestamp": 1543617857085, + "version": "2.1.0" + }, + "sortedcontainers-2.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "7e41955f7324cda4c705c1d94df786eb", + "name": "sortedcontainers", + "sha256": "596640228e7b4fb55fc15cb5f7e799a155a25debe34594bb119e45cdcd9b9a29", + "size": 43965, + "subdir": "linux-64", + "timestamp": 1543617804238, + "version": "2.1.0" + }, + "sortedcontainers-2.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "md5": "8e29595766e8e1a53995814069296855", + "name": "sortedcontainers", + "sha256": "e017f9760f55f96153ed811e04bd66d9d0ab278a5ad3fd0e79f3d3b48c0af90e", + "size": 43254, + "subdir": "linux-64", + "timestamp": 1573200529092, + "version": "2.1.0" + }, + "soupsieve-1.7.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "624157b326d56bdf6842124a4df472bc", + "name": "soupsieve", + "sha256": "d36b6f98a8adeaa1d19e13993c3bd1e33e699a47f447dd8499c28a75972cd019", + "size": 51887, + "subdir": "linux-64", + "timestamp": 1547908442057, + "version": "1.7.1" + }, + "soupsieve-1.7.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e34bb6be69e3bd90d83da8c39162a554", + "name": "soupsieve", + "sha256": "9ab9b9603d1c0d7626c19efc61b8fb86ab00494c613a30402855b5c38c0cf770", + "size": 51935, + "subdir": "linux-64", + "timestamp": 1547908289769, + "version": "1.7.1" + }, + "soupsieve-1.7.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ccb166ed2a705fc6286a84494d078122", + "name": "soupsieve", + "sha256": "cc8a460e28a3bb647a314660eb9d9655899390c48f2d97dfb925c303e4b8d274", + "size": 51805, + "subdir": "linux-64", + "timestamp": 1547908396667, + "version": "1.7.1" + }, + "soupsieve-1.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "6eae618c3d7f3fb735faf75f6f870967", + "name": "soupsieve", + "sha256": "640eed41ccdfc4afc00d81288b496f3f318a9f2d2107ca6835a68e1558d8090e", + "size": 107521, + "subdir": "linux-64", + "timestamp": 1552448023914, + "version": "1.8" + }, + "soupsieve-1.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "913a136e4a6b9940b47cdf89e281e2e9", + "name": "soupsieve", + "sha256": "1d3c85bc1de82eea26f6a89088c7635c9de08988ef0885e921f74bc74d4c7fd9", + "size": 107465, + "subdir": "linux-64", + "timestamp": 1552446532182, + "version": "1.8" + }, + "soupsieve-1.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5c1994342b6fa1f93b6c6bc6b556bbf4", + "name": "soupsieve", + "sha256": "4681ba92482903908054df411018e9f908a4571f12c8e8deed4befd9a91ffcb7", + "size": 108498, + "subdir": "linux-64", + "timestamp": 1552446415126, + "version": "1.8" + }, + "soupsieve-1.9.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "8188c087f8c06da5727a86116e53df19", + "name": "soupsieve", + "sha256": "15b0419a4067fa9d41611d856a33071958f8376cfb2c5263529ae1a00b4fed0b", + "size": 62581, + "subdir": "linux-64", + "timestamp": 1564707750770, + "version": "1.9.2" + }, + "soupsieve-1.9.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "cf7828a0fe3f469a2cfb325dca547833", + "name": "soupsieve", + "sha256": "aad08b230b870ac613c614d73a903423e9cac78b7aa6a29f6ea1837ba5dd09a3", + "size": 62921, + "subdir": "linux-64", + "timestamp": 1564707762977, + "version": "1.9.2" + }, + "soupsieve-1.9.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1ada98bf2c418e7cd9b05070ef86bff9", + "name": "soupsieve", + "sha256": "fdcc9219835134722c0b65a59d77400a11bd927cbc935c252cc7b3301bbab4cc", + "size": 61918, + "subdir": "linux-64", + "timestamp": 1564707728882, + "version": "1.9.2" + }, + "soupsieve-1.9.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "373fc1e53842a8b177ac056e229618ae", + "name": "soupsieve", + "sha256": "ea6fc32eeaafbd96eb90f50947f313fcb0ba093fcbfe69ee8e1bc119825bfc6f", + "size": 61381, + "subdir": "linux-64", + "timestamp": 1569427176861, + "version": "1.9.3" + }, + "soupsieve-1.9.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "59cbeaa128865e0858f8c64130d6e068", + "name": "soupsieve", + "sha256": "f8b5a680aace72ff183541fc1c507ce0dd6af646da1a2dc1c836b1f870cf8af7", + "size": 61933, + "subdir": "linux-64", + "timestamp": 1569427193875, + "version": "1.9.3" + }, + "soupsieve-1.9.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a76b2ce302ee4fdc9cae56ea0b5f176c", + "name": "soupsieve", + "sha256": "19e9e73be62cfe409c5b489106bf15324d96be2ee15a87a376737625d4021eea", + "size": 61820, + "subdir": "linux-64", + "timestamp": 1569427172706, + "version": "1.9.3" + }, + "soupsieve-1.9.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "8e700914fdd393f5c13a101fee1e6fed", + "name": "soupsieve", + "sha256": "78858b1db9a438b37d747ddea6c094885614bb2ea3abde19612a1dba7eaaaf60", + "size": 60202, + "subdir": "linux-64", + "timestamp": 1572608982925, + "version": "1.9.3" + }, + "soupsieve-1.9.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "515f0ac9503aa81512127f05dddeee95", + "name": "soupsieve", + "sha256": "f8fceae8581f154d8e2b9ee94086c689d8cd2030d2010ab8f385991179158a73", + "size": 62266, + "subdir": "linux-64", + "timestamp": 1573941977344, + "version": "1.9.4" + }, + "soupsieve-1.9.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9ccf099ae788e76af3c412437a6f7468", + "name": "soupsieve", + "sha256": "acd930ef320d644f86318252c3ce0936ded1aeeb2a1cf4296da5ac088ead49fe", + "size": 62572, + "subdir": "linux-64", + "timestamp": 1573941903578, + "version": "1.9.4" + }, + "soupsieve-1.9.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6d1c327f933845c2572399fbc3460f0e", + "name": "soupsieve", + "sha256": "cc07ee5d057e143176bf7db0be101131f4aa5a905b18b7430efc4574e7783d3f", + "size": 62233, + "subdir": "linux-64", + "timestamp": 1573941946599, + "version": "1.9.4" + }, + "soupsieve-1.9.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "e07f94747a20d83f58598e30d41484f6", + "name": "soupsieve", + "sha256": "99cd1236b35d263fb50bdabb5200b7656432f970aef648b9efa358ea93246fe6", + "size": 62703, + "subdir": "linux-64", + "timestamp": 1573941984426, + "version": "1.9.4" + }, + "soupsieve-1.9.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports.functools_lru_cache", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "dd8f28c99a43d85bb9914d98fb94ae3f", + "name": "soupsieve", + "sha256": "1f245778aa42271ca8164298a51398abc8644ee7d9f25c26fa9a82ffba354d8a", + "size": 62692, + "subdir": "linux-64", + "timestamp": 1574269065867, + "version": "1.9.5" + }, + "soupsieve-1.9.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "787985cebb5e07029bb03ac7931e814f", + "name": "soupsieve", + "sha256": "8db04b215d33659558ad540eab2683dd7c59179482637f3e77bcc90f795ef6e5", + "size": 62962, + "subdir": "linux-64", + "timestamp": 1574269090439, + "version": "1.9.5" + }, + "soupsieve-1.9.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e874b2eb72d0dd4031beebb2865d1aeb", + "name": "soupsieve", + "sha256": "764935d4e4f0c5fcaffdab920484254cd350f44f4d0dc1210a59b2ecf493cf65", + "size": 62682, + "subdir": "linux-64", + "timestamp": 1574269088786, + "version": "1.9.5" + }, + "soupsieve-1.9.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "1891e7b4b0e16c106143b3dac0309603", + "name": "soupsieve", + "sha256": "5d3caa885695e779a7460fcff7abffc8bbb20c4c079426aa2132a0bbf445a13f", + "size": 63110, + "subdir": "linux-64", + "timestamp": 1574269142277, + "version": "1.9.5" + }, + "soupsieve-2.3.2.post1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b944d3134722d37695706b8bef7d9631", + "name": "soupsieve", + "sha256": "36886e41c36cb14a8d5b3afde173d639e3cdbfeb3b62942fce4669da206e02e4", + "size": 66950, + "subdir": "linux-64", + "timestamp": 1666296424215, + "version": "2.3.2.post1" + }, + "soupsieve-2.3.2.post1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4caf29f1a6e0ee35f8161d0609720ef3", + "name": "soupsieve", + "sha256": "967d12c4b9436f73531c836018dde2c95c5a8d1089f62902f5b25ba21195630d", + "size": 93084, + "subdir": "linux-64", + "timestamp": 1676823551313, + "version": "2.3.2.post1" + }, + "soupsieve-2.3.2.post1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc867f14537ba923d51bbd394e5a3409", + "name": "soupsieve", + "sha256": "dccc40b0ea43dccc51797417188843ec6eb4febe7c35d7123c97241f88b61a24", + "size": 66060, + "subdir": "linux-64", + "timestamp": 1666296506095, + "version": "2.3.2.post1" + }, + "soupsieve-2.3.2.post1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e18af07bc8fcff2966432f9fabd96cff", + "name": "soupsieve", + "sha256": "fc1c06276ec6db805c18e7219d91ef7a23fe99a94c5262745ceea9041f51b43e", + "size": 66465, + "subdir": "linux-64", + "timestamp": 1666296477717, + "version": "2.3.2.post1" + }, + "soupsieve-2.3.2.post1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "411453f84b747b01514c89f2829af4a4", + "name": "soupsieve", + "sha256": "d3a883d85e8b3539d8ae746101d67625167286f57a88f58be39ad553d036a864", + "size": 66375, + "subdir": "linux-64", + "timestamp": 1666296451145, + "version": "2.3.2.post1" + }, + "soupsieve-2.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "978cdc12f39c6f1b50320fe9e2327210", + "name": "soupsieve", + "sha256": "a4ae8d35c4533fe2ea8ec5713ea20f76c09b461e857598f4730a7f33a7fb0927", + "size": 71246, + "subdir": "linux-64", + "timestamp": 1680518587357, + "version": "2.4" + }, + "soupsieve-2.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "48c622545905937101a1ef534fb63e26", + "name": "soupsieve", + "sha256": "2d5f5ba8d20f4a9c9272ae68eee6d16de3af70894f20b5cf50f2188dc0c6065f", + "size": 95119, + "subdir": "linux-64", + "timestamp": 1680518535885, + "version": "2.4" + }, + "soupsieve-2.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5f49d1264df9a42718cc433422dbf7a", + "name": "soupsieve", + "sha256": "3fc8f3dfb71ff544fb1be37a7effc9053bb3c5bb5bb6c6edd0b1026dd81abac2", + "size": 70780, + "subdir": "linux-64", + "timestamp": 1680518509942, + "version": "2.4" + }, + "soupsieve-2.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95f3c38dc4e9937bcf39cc001d4b902c", + "name": "soupsieve", + "sha256": "6af24a2facef2ab333c11209e1d2f6d74b931a522d0af6c90a1459afa1d8eb3a", + "size": 70683, + "subdir": "linux-64", + "timestamp": 1680518561058, + "version": "2.4" + }, + "spacy-1.9.0-py27h2a2a31f_1.conda": { + "build": "py27h2a2a31f_1", + "build_number": 1, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "murmurhash >=0.26,<0.27", + "numpy >=1.9.3,<2.0a0", + "pathlib", + "pip >=9.0.0,<10.0.0", + "plac <1.0.0,>=0.9.6", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "regex >=2017.4.1,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.5.0,<6.6.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "4a7d220d20d1c32d576fad57d584d5a7", + "name": "spacy", + "sha256": "1a667dffb312d93a041d1f5e7d37f9f3d4bad7b3213f9da510fcce369be48c21", + "size": 2155118, + "subdir": "linux-64", + "timestamp": 1509399455367, + "version": "1.9.0" + }, + "spacy-1.9.0-py35h56fe5f8_1.conda": { + "build": "py35h56fe5f8_1", + "build_number": 1, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "murmurhash >=0.26,<0.27", + "numpy >=1.9.3,<2.0a0", + "pathlib", + "pip >=9.0.0,<10.0.0", + "plac <1.0.0,>=0.9.6", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "regex >=2017.4.1,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.5.0,<6.6.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "0a99474ee2edfe8a21b5aa7f31ef0fb3", + "name": "spacy", + "sha256": "6b37fbbba249ecbde51e62cc256b10a33b12e2e944e2e1184176b1dc353d03b6", + "size": 2143050, + "subdir": "linux-64", + "timestamp": 1509399486629, + "version": "1.9.0" + }, + "spacy-1.9.0-py36hc78c2e1_1.conda": { + "build": "py36hc78c2e1_1", + "build_number": 1, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "murmurhash >=0.26,<0.27", + "numpy >=1.9.3,<2.0a0", + "pathlib", + "pip >=9.0.0,<10.0.0", + "plac <1.0.0,>=0.9.6", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "regex >=2017.4.1,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.5.0,<6.6.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "685d10953a0a8b03825125c3fd2d591c", + "name": "spacy", + "sha256": "66e40689fd3e94bfd145ec57ef90badb7d7cd0b3e96dabd729897c574e67bd42", + "size": 2092695, + "subdir": "linux-64", + "timestamp": 1509399660930, + "version": "1.9.0" + }, + "spacy-2.0.10-py27h637b7d7_0.conda": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "regex >=2017.4.0,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "b5e4feec432b0f4bec45b3a58df51694", + "name": "spacy", + "sha256": "3722a9fed164e73f9090582681a6d3bd3300439ce148a73478ebe10a6d1c81c9", + "size": 31931746, + "subdir": "linux-64", + "timestamp": 1522706163040, + "version": "2.0.10" + }, + "spacy-2.0.10-py35h637b7d7_0.conda": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "regex >=2017.4.0,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "893376832d9fce4360e0eece6b642fd6", + "name": "spacy", + "sha256": "7d0d5775d406e9a93b9e25c99beda023a1be1ac67630026f8e214be7629abdc8", + "size": 31908588, + "subdir": "linux-64", + "timestamp": 1522706165278, + "version": "2.0.10" + }, + "spacy-2.0.10-py36h637b7d7_0.conda": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "regex >=2017.4.0,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "d38323bf0f15be6a9a897942cafc1087", + "name": "spacy", + "sha256": "47f4c03ec40537e6b110e7ce310e14c9f28bb0334df8724667583f7f31b6799c", + "size": 27732117, + "subdir": "linux-64", + "timestamp": 1522706152138, + "version": "2.0.10" + }, + "spacy-2.0.11-py27h04863e7_1.conda": { + "build": "py27h04863e7_1", + "build_number": 1, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.4.2", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "pathlib2", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "regex >=2017.4.0,<=2018.6.21", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.12.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "aa004f8e63439b3036e44e049c89225f", + "name": "spacy", + "sha256": "1d3ea35824e48d58f66ff5026f4f49ce1d7a27ccd11e95c6d723065a9edc151b", + "size": 32774296, + "subdir": "linux-64", + "timestamp": 1530962401650, + "version": "2.0.11" + }, + "spacy-2.0.11-py27h04863e7_2.conda": { + "build": "py27h04863e7_2", + "build_number": 2, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "pathlib2", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "regex >=2017.4.0,<=2018.6.21", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.12.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "07ec01f733e3889a18462b225c6448c1", + "name": "spacy", + "sha256": "413f1ae4b1eb34b281107626db298d444d9ed73991b1ce05cb0504172f9369d2", + "size": 32802819, + "subdir": "linux-64", + "timestamp": 1531058476777, + "version": "2.0.11" + }, + "spacy-2.0.11-py27h637b7d7_0.conda": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "regex >=2017.4.0,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "39e811a6e76c0ea344564ed8efd86d37", + "name": "spacy", + "sha256": "e4b9f5d278285a41904b07c8e53216e00f9c24cac9967b7a213e13022a8f9269", + "size": 32728801, + "subdir": "linux-64", + "timestamp": 1524074943948, + "version": "2.0.11" + }, + "spacy-2.0.11-py35h637b7d7_0.conda": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "regex >=2017.4.0,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "b94ed4ac01d79d5faa13e8c15de7e65d", + "name": "spacy", + "sha256": "8bcc6b6d32807ae8b8f700886ea8f15395ef5b6f4faa4673649e5c2e9b9f6252", + "size": 32008284, + "subdir": "linux-64", + "timestamp": 1524074607692, + "version": "2.0.11" + }, + "spacy-2.0.11-py36h04863e7_1.conda": { + "build": "py36h04863e7_1", + "build_number": 1, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.4.2", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "regex >=2017.4.0,<=2018.6.21", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.12.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "aba696d58359854e4f295a6c0b3e205d", + "name": "spacy", + "sha256": "31af9c611c998fe1c19ee6e7ccf148609f85a2132b5f6384f12d215eb39dc868", + "size": 28146638, + "subdir": "linux-64", + "timestamp": 1531049437511, + "version": "2.0.11" + }, + "spacy-2.0.11-py36h04863e7_2.conda": { + "build": "py36h04863e7_2", + "build_number": 2, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "regex >=2017.4.0,<=2018.6.21", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.12.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "398204ce5234d3346c325e1168dbe231", + "name": "spacy", + "sha256": "64e360917454c166e1fbbbca7d95c30cd441d7b53f042d8d92d496542c758a98", + "size": 27786507, + "subdir": "linux-64", + "timestamp": 1531056748504, + "version": "2.0.11" + }, + "spacy-2.0.11-py36h637b7d7_0.conda": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "regex >=2017.4.0,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "8ea21318701d26f3b8085f7ddb34845a", + "name": "spacy", + "sha256": "72546e413444209c6f37cce2c04ba5578545e23a6a21f18fecccad4b7fc71943", + "size": 28148663, + "subdir": "linux-64", + "timestamp": 1524074935540, + "version": "2.0.11" + }, + "spacy-2.0.11-py37h04863e7_1.conda": { + "build": "py37h04863e7_1", + "build_number": 1, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.4.2", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.7,<3.8.0a0", + "regex >=2017.4.0,<=2018.6.21", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.12.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "8394859bb46e0c8f35ce5dc2ba70e681", + "name": "spacy", + "sha256": "63b9e4b836f4e0bcca1d74a2683c8df20d735b79090dbbf50fed870bb8940618", + "size": 27787401, + "subdir": "linux-64", + "timestamp": 1530963714745, + "version": "2.0.11" + }, + "spacy-2.0.11-py37h04863e7_2.conda": { + "build": "py37h04863e7_2", + "build_number": 2, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.7,<3.8.0a0", + "regex >=2017.4.0,<=2018.6.21", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.12.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "251920d6d1bdac28bb0c336543f702fa", + "name": "spacy", + "sha256": "c255ad83874f72b11f6ecb5e78662ef20474cc76a2d3bd4f208ac67b0d853d5f", + "size": 27796220, + "subdir": "linux-64", + "timestamp": 1531056139760, + "version": "2.0.11" + }, + "spacy-2.0.12-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "pathlib2", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "regex >=2017.4.0,<=2018.7.11", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.3,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "c454c27e362896976a1eb3bdbe1c6859", + "name": "spacy", + "sha256": "315c957887ac13a69eb9b6b901b0026338504abd504b6abd858ec38148a14601", + "size": 41577051, + "subdir": "linux-64", + "timestamp": 1535689673437, + "version": "2.0.12" + }, + "spacy-2.0.12-py35h962f231_0.conda": { + "build": "py35h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "regex >=2017.4.0,<=2018.7.11", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.3,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "31599cad5865ada6b4653770e08b0c93", + "name": "spacy", + "sha256": "4351c2869174e52c2e098a531972166e4009c318b212366400e6eabf378df824", + "size": 41117792, + "subdir": "linux-64", + "timestamp": 1535690630839, + "version": "2.0.12" + }, + "spacy-2.0.12-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "regex >=2017.4.0,<=2018.7.11", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.3,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "6aecc4513251516a578c2d2b1ac344a0", + "name": "spacy", + "sha256": "4061073e8f9645d1d024917d9a58103a0b8c96c3a0aae5a7acc967a0f2abb1ae", + "size": 37028215, + "subdir": "linux-64", + "timestamp": 1535689694093, + "version": "2.0.12" + }, + "spacy-2.0.12-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.7", + "murmurhash >=0.28,<0.29", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.7,<3.8.0a0", + "regex >=2017.4.0,<=2018.7.11", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.3,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "54605c5480e0bb7235a9a7081af9ee3f", + "name": "spacy", + "sha256": "64fd3b266f5321d4d8eacadd22765b3ae0e15dd407a0ec03d478a3699bea257b", + "size": 36880845, + "subdir": "linux-64", + "timestamp": 1535689675404, + "version": "2.0.12" + }, + "spacy-2.0.16-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "pathlib2", + "plac >=0.9.6,<1.0.0", + "preshed >=2.0.1,<2.1.0", + "python >=2.7,<2.8.0a0", + "regex >=2018.01.10", + "requests >=2.13.0,<3.0.0", + "thinc >=6.12.0,<6.13.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "87d4c42499572d162e8572b511e9f39d", + "name": "spacy", + "sha256": "e9c0f3397ae34c6c38f733ee3c19effc625a55788c8c7e99a4fc85d63f1e631f", + "size": 43104104, + "subdir": "linux-64", + "timestamp": 1539885820475, + "version": "2.0.16" + }, + "spacy-2.0.16-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=2.0.1,<2.1.0", + "python >=3.6,<3.7.0a0", + "regex >=2018.01.10", + "requests >=2.13.0,<3.0.0", + "thinc >=6.12.0,<6.13.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "1ff305eac333e3bc9b4463c6a25ec236", + "name": "spacy", + "sha256": "ef39a210a44517274e3bd375150dd9b4808c7e5a547965c736c4d78e6f757d4c", + "size": 38756207, + "subdir": "linux-64", + "timestamp": 1539885802540, + "version": "2.0.16" + }, + "spacy-2.0.16-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=2.0.1,<2.1.0", + "python >=3.7,<3.8.0a0", + "regex >=2018.01.10", + "requests >=2.13.0,<3.0.0", + "thinc >=6.12.0,<6.13.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "af6646a38da753372dcd3d812b47ac0f", + "name": "spacy", + "sha256": "da13f052d5f9a471eb1ca1fb6b4ef253270d9df4285919be15d9f1c7e177e331", + "size": 38559160, + "subdir": "linux-64", + "timestamp": 1539885665864, + "version": "2.0.16" + }, + "spacy-2.0.16-py38h962f231_0.conda": { + "build": "py38h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=2.0.2,<2.1.0", + "dill >=0.2,<0.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=2.0.1,<2.1.0", + "python >=3.8,<3.9.0a0", + "regex >=2018.01.10", + "requests >=2.13.0,<3.0.0", + "thinc >=6.12.0,<6.13.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "453c340a4b3a27dd39e61dbfe2f99124", + "name": "spacy", + "sha256": "51654e453fc0233440c39a5005e5bb59585be19ff717e6470a43344545898360", + "size": 38899430, + "subdir": "linux-64", + "timestamp": 1574237877975, + "version": "2.0.16" + }, + "spacy-2.0.5-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy 0.4.1", + "msgpack-python", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "regex 2017.4.5", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "58602bf3aab1bcb53e708a32a333d123", + "name": "spacy", + "sha256": "fa07f1c33d6baeced28e42a3b6c495b3b7f6bf20a9cdeade121f48329fc55904", + "size": 22440493, + "subdir": "linux-64", + "timestamp": 1515522994066, + "version": "2.0.5" + }, + "spacy-2.0.5-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy 0.4.1", + "msgpack-python", + "murmurhash >=0.28,<0.29", + "numpy >=1.14.0,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "regex 2017.4.5", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "c0965151707c300cb43e1e99ba72f1b8", + "name": "spacy", + "sha256": "951f4a9d47cbea7b80ff668fa32463188d8e10e481528cdd5aa5fecbc775e3f6", + "size": 22126108, + "subdir": "linux-64", + "timestamp": 1515523062910, + "version": "2.0.5" + }, + "spacy-2.0.5-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy 0.4.1", + "msgpack-python", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "regex 2017.4.5", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "3c5717e93540eea0eab14e52a96f205e", + "name": "spacy", + "sha256": "751f3893a75b2a44d07c86c32c5d9a09eb1a8fb3bacd13adfe609948ec92bc81", + "size": 19529659, + "subdir": "linux-64", + "timestamp": 1515522992593, + "version": "2.0.5" + }, + "spacy-2.0.9-py27h637b7d7_0.conda": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "regex >=2017.4.0,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "7ac799e74eb44b46b7a0114083a12012", + "name": "spacy", + "sha256": "548659a5869a9f8db49b805f23a839cf637585dda2b35bbf6c6c28f042e72469", + "size": 32140732, + "subdir": "linux-64", + "timestamp": 1520539508800, + "version": "2.0.9" + }, + "spacy-2.0.9-py35h637b7d7_0.conda": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "regex >=2017.4.0,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "4dafefeda484a6e8e9d60a75ad982350", + "name": "spacy", + "sha256": "4c597652df9d1befa88ea93755146934fbc07230e635c07be6b317252d4766db", + "size": 31875606, + "subdir": "linux-64", + "timestamp": 1520539588005, + "version": "2.0.9" + }, + "spacy-2.0.9-py36h637b7d7_0.conda": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32.0", + "dill >=0.2,<0.3", + "ftfy >=4.4.2,<5.0.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1,<0.5.0", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "regex >=2017.4.0,<2017.12.1", + "requests >=2.13.0,<3.0.0", + "six", + "thinc >=6.10.1,<6.11.0", + "ujson >=1.35" + ], + "license": "MIT", + "md5": "e01a9db49a0d8c156e068dbf05907d88", + "name": "spacy", + "sha256": "5e4e78b83f14905ef2ce164a714192a31c6de24f1f96bb0cf745fa9724ffceaa", + "size": 28098263, + "subdir": "linux-64", + "timestamp": 1520539039528, + "version": "2.0.9" + }, + "spacy-2.3.1-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.6,<3.7.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc 7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "3d077123e4c8bea62c649f7617bad6c6", + "name": "spacy", + "sha256": "30c00e225bd008f31207ac74ee51aeefb340721e34fabd0f824d5809b6b2a738", + "size": 4830625, + "subdir": "linux-64", + "timestamp": 1594303659124, + "version": "2.3.1" + }, + "spacy-2.3.1-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.7,<3.8.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc 7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "aac1fc6b9a358af86d35fd1e99e83141", + "name": "spacy", + "sha256": "253c3fe533479b6ff60004336053466f5719a5dd53023083722e31192b1f4287", + "size": 4832572, + "subdir": "linux-64", + "timestamp": 1594303621898, + "version": "2.3.1" + }, + "spacy-2.3.1-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.8,<3.9.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc 7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "554eb4577f38570ea997e058315c9a4b", + "name": "spacy", + "sha256": "da6bcf4da3c7f026df33fff2a6ba85030d54899076f292796e3ac07f1c941fa9", + "size": 5014496, + "subdir": "linux-64", + "timestamp": 1594305462266, + "version": "2.3.1" + }, + "spacy-2.3.2-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.6,<3.7.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc 7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "d1c23b85cd14dba594979f3e89458aae", + "name": "spacy", + "sha256": "f1a82e6c2df7db41a4918da8233d20cd5eebdea3af57f4ac98f115dda2048740", + "size": 4845426, + "subdir": "linux-64", + "timestamp": 1600554551239, + "version": "2.3.2" + }, + "spacy-2.3.2-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.7,<3.8.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc 7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "86330f6f3eb5a3a07bc8c711ec609134", + "name": "spacy", + "sha256": "65df25c7d2af43c11400c88f42d41865adaa5850e75fd6538b18ecf51eac450f", + "size": 4826674, + "subdir": "linux-64", + "timestamp": 1600554549421, + "version": "2.3.2" + }, + "spacy-2.3.2-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.8,<3.9.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc 7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "2fe0e3b785e350475f12720aacb37c42", + "name": "spacy", + "sha256": "40830e1017bc25320f3cb3a14452198f524c494adfefc1e1e79d15ddbe0ba1dd", + "size": 5001603, + "subdir": "linux-64", + "timestamp": 1600554543147, + "version": "2.3.2" + }, + "spacy-2.3.5-py36hff7bd54_0.conda": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.6,<3.7.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc >=7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "cd6216838a46b404690a1a80b121725f", + "name": "spacy", + "sha256": "04c4a56484aabb65eab9daf19eb9d526f3f7795ffb63a2495eeb81a6d3c033ad", + "size": 4948926, + "subdir": "linux-64", + "timestamp": 1608321420980, + "version": "2.3.5" + }, + "spacy-2.3.5-py37hff7bd54_0.conda": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.7,<3.8.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc >=7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "076be057564e2c399ec28b5a03916a0a", + "name": "spacy", + "sha256": "0e557ed909810fc2e36f569b6687e15f47c27831e8be2a9e8e640c3cc2586106", + "size": 4944138, + "subdir": "linux-64", + "timestamp": 1608321377365, + "version": "2.3.5" + }, + "spacy-2.3.5-py38hff7bd54_0.conda": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.8,<3.9.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc >=7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "ef6ca95ecdd8767588afea10b284d3ce", + "name": "spacy", + "sha256": "f6481a2eb712a85b066df7f378776f643e6eaa46c02ea0da73d055c790ce9362", + "size": 5125454, + "subdir": "linux-64", + "timestamp": 1608321435733, + "version": "2.3.5" + }, + "spacy-2.3.5-py39hff7bd54_0.conda": { + "build": "py39hff7bd54_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "jsonschema >=2.6.0,<3.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.9,<3.10.0a0", + "requests >=2.13.0,<3.0.0", + "srsly >=1.0.2,<1.1.0", + "thinc >=7.4.1", + "tqdm >=4.38.0,<5.0.0", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "7b808d65a43f28c7fac2458bc41ea8cf", + "name": "spacy", + "sha256": "08a74b7b195e38f854a8b364b97d69d088922419ce3535f7d9d999f1c6d46a21", + "size": 5116148, + "subdir": "linux-64", + "timestamp": 1608323278083, + "version": "2.3.5" + }, + "spacy-3.2.1-py37hae6d005_0.conda": { + "build": "py37hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1,<1.9.0", + "python >=3.7,<3.8.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.8,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.1,<3.0.0", + "thinc >=8.0.12,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.2,<0.5.0", + "typing_extensions >=3.7.4,<4.0.0.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "md5": "f6e60eaf943c61aae2ec7762742833b4", + "name": "spacy", + "sha256": "6381a6ad1a5ecc74bd6308b682cdbcf2471302b576ceb30ea37fb64f1757df96", + "size": 4385591, + "subdir": "linux-64", + "timestamp": 1643539074553, + "version": "3.2.1" + }, + "spacy-3.2.1-py38hae6d005_0.conda": { + "build": "py38hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1,<1.9.0", + "python >=3.8,<3.9.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.8,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.1,<3.0.0", + "thinc >=8.0.12,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.2,<0.5.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "md5": "d985afd77174d794fff3c7216a511a31", + "name": "spacy", + "sha256": "dea997c17209e44bd10fb0bdab0f500fe46cb1abbd6a0a2b0ff084c4531e4055", + "size": 4609852, + "subdir": "linux-64", + "timestamp": 1643539855978, + "version": "3.2.1" + }, + "spacy-3.2.1-py39hae6d005_0.conda": { + "build": "py39hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1,<1.9.0", + "python >=3.9,<3.10.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.8,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.1,<3.0.0", + "thinc >=8.0.12,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.2,<0.5.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "md5": "988265aac8459bc6a10b44a3db0e06dc", + "name": "spacy", + "sha256": "cbf8ba6458b746512c9704c589e66dd30a67013d5df183da7ec083524b2df529", + "size": 4589671, + "subdir": "linux-64", + "timestamp": 1643538275130, + "version": "3.2.1" + }, + "spacy-3.3.0-py310h2571103_0.conda": { + "build": "py310h2571103_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "click <8.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.10,<3.11.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.9,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.3,<3.0.0", + "thinc >=8.0.14,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.0,<0.5.0", + "wasabi >=0.9.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bbdb9befc76815549764748053a55395", + "name": "spacy", + "sha256": "36d512c95998db1ae8f3cffd22494cc97fa63eac2dc916755efcf9a330928f58", + "size": 17376387, + "subdir": "linux-64", + "timestamp": 1651736794228, + "version": "3.3.0" + }, + "spacy-3.3.0-py37hae6d005_0.conda": { + "build": "py37hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "click <8.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.7,<3.8.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.9,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.3,<3.0.0", + "thinc >=8.0.14,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.0,<0.5.0", + "typing_extensions >=3.7.4,<4.0.0.0", + "wasabi >=0.9.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de4cc64fad931c8ebe3e594c36d76522", + "name": "spacy", + "sha256": "4b179c452b050e368254e064510bf0f912b53e969dc22276b2b3713a684498a4", + "size": 4597743, + "subdir": "linux-64", + "timestamp": 1651736119378, + "version": "3.3.0" + }, + "spacy-3.3.0-py38hae6d005_0.conda": { + "build": "py38hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "click <8.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.8,<3.9.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.9,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.3,<3.0.0", + "thinc >=8.0.14,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.0,<0.5.0", + "wasabi >=0.9.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74055ee9ed1db2986777301936622097", + "name": "spacy", + "sha256": "a1a94773c0bae6d7e5d62480b7e95471eac0776815d889ca2ca97d35300652cc", + "size": 4815446, + "subdir": "linux-64", + "timestamp": 1651734909183, + "version": "3.3.0" + }, + "spacy-3.3.0-py39hae6d005_0.conda": { + "build": "py39hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "click <8.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.9,<3.10.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.9,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.3,<3.0.0", + "thinc >=8.0.14,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.0,<0.5.0", + "wasabi >=0.9.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "24898f6ced9073fe5f4f3dcf53fc844b", + "name": "spacy", + "sha256": "75337d263b7ec53446c91bf50bdba1da53443343011e89e311d939a5674808bc", + "size": 4793632, + "subdir": "linux-64", + "timestamp": 1651735508132, + "version": "3.3.0" + }, + "spacy-3.3.1-py310h3c18c91_0.conda": { + "build": "py310h3c18c91_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "click <8.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.10,<3.11.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.9,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.3,<3.0.0", + "thinc >=8.0.14,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.0,<0.5.0", + "wasabi >=0.9.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ccfa5247850a1393352dd28d13b35479", + "name": "spacy", + "sha256": "357144492a8dbc6be4c01616968a74e82017fef9a422443d9b1096885459a80c", + "size": 18965800, + "subdir": "linux-64", + "timestamp": 1656601812398, + "version": "3.3.1" + }, + "spacy-3.3.1-py311heed92f4_0.conda": { + "build": "py311heed92f4_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "click <8.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.22.3,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.11,<3.12.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.9,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.3,<3.0.0", + "thinc >=8.0.14,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.0,<0.5.0", + "wasabi >=0.9.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fad4661e0a325fe6a479a7447924adfa", + "name": "spacy", + "sha256": "7015627570e73a243cf40c92338b2c033ff05153d094743ac1672bbaaf62b6d3", + "size": 5086110, + "subdir": "linux-64", + "timestamp": 1677697535262, + "version": "3.3.1" + }, + "spacy-3.3.1-py37h79cecc1_0.conda": { + "build": "py37h79cecc1_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "click <8.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.7,<3.8.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.9,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.3,<3.0.0", + "thinc >=8.0.14,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.0,<0.5.0", + "typing_extensions >=3.7.4.1,<4.2.0", + "wasabi >=0.9.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "455a26cd8fabcc2fe34e4430119c5983", + "name": "spacy", + "sha256": "e31ac27e818a1f2894b25e7b7fb6f93801089edb68cd3c3ee356c3f01a1fa982", + "size": 4604872, + "subdir": "linux-64", + "timestamp": 1656603793657, + "version": "3.3.1" + }, + "spacy-3.3.1-py38h79cecc1_0.conda": { + "build": "py38h79cecc1_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "click <8.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.8,<3.9.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.9,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.3,<3.0.0", + "thinc >=8.0.14,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.0,<0.5.0", + "wasabi >=0.9.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7544727a248390c9faea7a34bc7545d1", + "name": "spacy", + "sha256": "5fa5d04ad97abfbf7b32f8ca772a9ff815e8d854d8f5e2985e3e452438868ec2", + "size": 4867526, + "subdir": "linux-64", + "timestamp": 1656603123670, + "version": "3.3.1" + }, + "spacy-3.3.1-py39h79cecc1_0.conda": { + "build": "py39h79cecc1_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.6,<2.1.0", + "click <8.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "jinja2", + "langcodes >=3.2.0,<4.0.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=20.0", + "pathy >=0.3.5", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.9,<3.10.0a0", + "requests >=2.13.0,<3.0.0", + "setuptools", + "spacy-legacy >=3.0.9,<3.1.0", + "spacy-loggers >=1.0.0,<2.0.0", + "srsly >=2.4.3,<3.0.0", + "thinc >=8.0.14,<8.1.0", + "tqdm >=4.38.0,<5.0.0", + "typer >=0.3.0,<0.5.0", + "wasabi >=0.9.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5cffb17ddba87e945f2ba8399e59f846", + "name": "spacy", + "sha256": "1fc91be0eeb7cd31c1b71aad9effac753a652b03ebf08d6cec8a5c0f1592245c", + "size": 4768586, + "subdir": "linux-64", + "timestamp": 1656602482185, + "version": "3.3.1" + }, + "spacy-alignments-0.8.5-py310hd24b679_0.conda": { + "build": "py310hd24b679_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c4aedf7740540cc34eb4c4269e03d0c", + "name": "spacy-alignments", + "sha256": "b55340fd7f19c3976c14a62f0778d19d3a3c91d7dfc57fb3e5a8289e4185a086", + "size": 884004, + "subdir": "linux-64", + "timestamp": 1651063840816, + "version": "0.8.5" + }, + "spacy-alignments-0.8.5-py37hd24b679_0.conda": { + "build": "py37hd24b679_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "300041655fc3dc038ab67ea615a58380", + "name": "spacy-alignments", + "sha256": "cb876cdf3bf22b4698d4eaa117997cd91c5c99d1f25c25ed52866ec381edb11d", + "size": 883940, + "subdir": "linux-64", + "timestamp": 1651063466686, + "version": "0.8.5" + }, + "spacy-alignments-0.8.5-py38hd24b679_0.conda": { + "build": "py38hd24b679_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "93d83b473365b21b34a57a26f6a752af", + "name": "spacy-alignments", + "sha256": "291c1e85c33b537636fd4d2481c4730b815bb2b0f51250ec93edde833c6453db", + "size": 884117, + "subdir": "linux-64", + "timestamp": 1651063586868, + "version": "0.8.5" + }, + "spacy-alignments-0.8.5-py39hd24b679_0.conda": { + "build": "py39hd24b679_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1e229a4f8b44e957ce0786d48c69d03", + "name": "spacy-alignments", + "sha256": "9dbc023e56ebf43ead0a5e92060d34bb531755e032a6cde8f4b424f8eac3a1fb", + "size": 886823, + "subdir": "linux-64", + "timestamp": 1651063710307, + "version": "0.8.5" + }, + "spacy-alignments-0.9.0-py310hbdeaff8_0.conda": { + "build": "py310hbdeaff8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d57d22d3f2630d6ec6b34ae9c8bec87b", + "name": "spacy-alignments", + "sha256": "49518611162cd4bd6d771ba23849a0a63824cf9905f87fc9936150733b5b4c38", + "size": 1003775, + "subdir": "linux-64", + "timestamp": 1674249608743, + "version": "0.9.0" + }, + "spacy-alignments-0.9.0-py311hbdeaff8_0.conda": { + "build": "py311hbdeaff8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "59ab2dbf66fd0cb7adc85e69e5768408", + "name": "spacy-alignments", + "sha256": "f7b59fed587bc8012384b7c884d02ee6988589c0bb1ff6d98c86fbf9606a3f81", + "size": 917466, + "subdir": "linux-64", + "timestamp": 1676862429543, + "version": "0.9.0" + }, + "spacy-alignments-0.9.0-py37hbdeaff8_0.conda": { + "build": "py37hbdeaff8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b15473e503b8d7b4911833ea4c2a101c", + "name": "spacy-alignments", + "sha256": "b019c6b4a0ceda3cc315325ad856c9ca55c0fe0bbdc0c79548954534f1a22ec0", + "size": 1003323, + "subdir": "linux-64", + "timestamp": 1674249833433, + "version": "0.9.0" + }, + "spacy-alignments-0.9.0-py38hbdeaff8_0.conda": { + "build": "py38hbdeaff8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ccab457aebb8fbd98e80d8f6211073e8", + "name": "spacy-alignments", + "sha256": "4d9f7bdf5a90c6bd4bfac155f579759f5289589446dbce7fc4dc9a5d8a2f0b87", + "size": 1003308, + "subdir": "linux-64", + "timestamp": 1674249484745, + "version": "0.9.0" + }, + "spacy-alignments-0.9.0-py39hbdeaff8_0.conda": { + "build": "py39hbdeaff8_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5c6cfec37123414d89bd9094f7c4fc0", + "name": "spacy-alignments", + "sha256": "f5b15072ef57e2a0bf76d14a81ef01b2fd25abdb75e3cdf83072721ccdb352da", + "size": 1003611, + "subdir": "linux-64", + "timestamp": 1674249720838, + "version": "0.9.0" + }, + "spacy-legacy-3.0.9-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e1e5a9b965182a0229d2a57b066094f6", + "name": "spacy-legacy", + "sha256": "22a3742aa7ba99a79fdd1ca9411146e21b5201c03f692fedaafbb86acb988946", + "size": 31844, + "subdir": "linux-64", + "timestamp": 1651648793241, + "version": "3.0.9" + }, + "spacy-legacy-3.0.9-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a10ec7181b14fb0be1b854cb5a1d88c1", + "name": "spacy-legacy", + "sha256": "a4fd5926685bb81888897278b6d62b8cfa056ae96ee9239f2267e3e959313702", + "size": 39947, + "subdir": "linux-64", + "timestamp": 1676845848879, + "version": "3.0.9" + }, + "spacy-legacy-3.0.9-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66e80193a5f1600a5e2b8807358a4a5d", + "name": "spacy-legacy", + "sha256": "f253fb12d8dd3d074194d65ca4b1b7607ceccfdbdcbc99623e66e875365bdadf", + "size": 31363, + "subdir": "linux-64", + "timestamp": 1651648843731, + "version": "3.0.9" + }, + "spacy-legacy-3.0.9-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0cd647fba8c5f0f43bd2d549ede85ba6", + "name": "spacy-legacy", + "sha256": "ff95af3666eba3e23137f896cde7d9afb742614394d05a14709de55dad15a61b", + "size": 31594, + "subdir": "linux-64", + "timestamp": 1651648868032, + "version": "3.0.9" + }, + "spacy-legacy-3.0.9-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "458658a0d395a2c9c961879026b77c8a", + "name": "spacy-legacy", + "sha256": "cff48bd966d5d6ba89cd72314c84686d719003db7c3ccf5eff4cdd98cc289468", + "size": 31636, + "subdir": "linux-64", + "timestamp": 1651648819081, + "version": "3.0.9" + }, + "spacy-transformers-1.1.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytorch >=1.6.0", + "spacy >=3.1.3,<4.0.0", + "spacy-alignments >=0.7.2,<1.0.0", + "srsly >=2.4.0,<3.0.0", + "transformers >=3.4.0,<4.19.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "07a9b18e0ec438d3b1ca7ae36669c658", + "name": "spacy-transformers", + "sha256": "360d88a2596ddb44c906000d9da7d2db0243953d431c9b5257d885b6c4696757", + "size": 79029, + "subdir": "linux-64", + "timestamp": 1651845980317, + "version": "1.1.5" + }, + "spacy-transformers-1.1.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytorch >=1.6.0", + "spacy >=3.1.3,<4.0.0", + "spacy-alignments >=0.7.2,<1.0.0", + "srsly >=2.4.0,<3.0.0", + "transformers >=3.4.0,<4.19.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74939b540b0be805e96d81556c05973e", + "name": "spacy-transformers", + "sha256": "054a71f2ba1574a9c4cce4a9eada95aa190cac4fe0560b405171d09ece49fa21", + "size": 78191, + "subdir": "linux-64", + "timestamp": 1651845804193, + "version": "1.1.5" + }, + "spacy-transformers-1.1.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytorch >=1.6.0", + "spacy >=3.1.3,<4.0.0", + "spacy-alignments >=0.7.2,<1.0.0", + "srsly >=2.4.0,<3.0.0", + "transformers >=3.4.0,<4.19.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a947706cbec25dbccefadff3ea076504", + "name": "spacy-transformers", + "sha256": "b8a31c1e99a4a090d69931043dea3657eddb357681b25a842727e1fa3eca774e", + "size": 78541, + "subdir": "linux-64", + "timestamp": 1651845646477, + "version": "1.1.5" + }, + "spacy-transformers-1.1.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytorch >=1.6.0", + "spacy >=3.1.3,<4.0.0", + "spacy-alignments >=0.7.2,<1.0.0", + "srsly >=2.4.0,<3.0.0", + "transformers >=3.4.0,<4.19.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "692c5311ae5b0f94032a3ccd9c5b5422", + "name": "spacy-transformers", + "sha256": "6ffbd88fbb43c755c739d0d415611d3a990341201bf4025d55a8f5558981f091", + "size": 78692, + "subdir": "linux-64", + "timestamp": 1651845447887, + "version": "1.1.5" + }, + "sparkmagic-0.12.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "8a289999acfae979ded2e96e4d617c72", + "name": "sparkmagic", + "sha256": "0727fa6f1f75c9fd4325494c4ea674ab5072841104aaf846bd1d03433d4f20bd", + "size": 68296, + "subdir": "linux-64", + "timestamp": 1531059496452, + "version": "0.12.5" + }, + "sparkmagic-0.12.5-py27h0acb2c8_0.conda": { + "build": "py27h0acb2c8_0", + "build_number": 0, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9be2544f6fb54051e288565e5f16fd25", + "name": "sparkmagic", + "sha256": "1deff90c863047a2d092154ad45c335482b6cc3acaeaed88b57fb967d2cd5435", + "size": 68651, + "subdir": "linux-64", + "timestamp": 1511317363484, + "version": "0.12.5" + }, + "sparkmagic-0.12.5-py35hb9a971e_0.conda": { + "build": "py35hb9a971e_0", + "build_number": 0, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.5,<3.6.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3032c8c78426cb464cd25badd82f9b94", + "name": "sparkmagic", + "sha256": "10fd0ee77f13f92c4e94ec4ff7cfe4bb769fea3aa1fa317ff72867d8e13a9aae", + "size": 70526, + "subdir": "linux-64", + "timestamp": 1511317374325, + "version": "0.12.5" + }, + "sparkmagic-0.12.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c8fc32f9f9ab7407e4f0f560acbf7d80", + "name": "sparkmagic", + "sha256": "363ff139c5dc4837c8ca9165c83d0e8d1eafb4cd084240c9efa6d9fb381fa0e2", + "size": 69547, + "subdir": "linux-64", + "timestamp": 1531059399433, + "version": "0.12.5" + }, + "sparkmagic-0.12.5-py36h8c657a7_0.conda": { + "build": "py36h8c657a7_0", + "build_number": 0, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "04a7f64f8d97c1cbfeb63d8de095ea2c", + "name": "sparkmagic", + "sha256": "7efae25556e25ba9b19a76d7062287f91ac6e681ba945bab8cf91d11f09f5430", + "size": 70842, + "subdir": "linux-64", + "timestamp": 1511317363166, + "version": "0.12.5" + }, + "sparkmagic-0.12.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "2e0aa85c04c3c800a2941d83752baee1", + "name": "sparkmagic", + "sha256": "479f09fed05f9962d739a1f053113f9b1e422cc11be463006eea249f4bc22d25", + "size": 70616, + "subdir": "linux-64", + "timestamp": 1531059450065, + "version": "0.12.5" + }, + "sparkmagic-0.12.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "md5": "3d338704d0a85de3eb39c7b1160e5a3d", + "name": "sparkmagic", + "sha256": "a730aef4d0c4b8d67445e6b9d9745f9659461a1a04dcc138f662341dbadd265a", + "size": 69387, + "subdir": "linux-64", + "timestamp": 1539647665816, + "version": "0.12.6" + }, + "sparkmagic-0.12.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "md5": "0f1e380536cabbd1b4c138d999edcf24", + "name": "sparkmagic", + "sha256": "0e3192f3febc6d354082f15246130708182dd52e9d5cbf92366314207a2b144e", + "size": 70791, + "subdir": "linux-64", + "timestamp": 1539647688828, + "version": "0.12.6" + }, + "sparkmagic-0.12.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "md5": "b8a63f4bec848b9c6c2a256f5e0402e8", + "name": "sparkmagic", + "sha256": "85752d359fa63d9dc247845b90bbc3fa95d41f3617ed2c171b86ae20a466706d", + "size": 70979, + "subdir": "linux-64", + "timestamp": 1539647688563, + "version": "0.12.6" + }, + "sparkmagic-0.12.7-py27_1001.conda": { + "build": "py27_1001", + "build_number": 1001, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "md5": "288559ab4a00033e996f1f6e2779cd7d", + "name": "sparkmagic", + "sha256": "0579407cd49ef39479e85aec04c183a58dcb5089f541180363b5328c935afac5", + "size": 96063, + "subdir": "linux-64", + "timestamp": 1551473623651, + "version": "0.12.7" + }, + "sparkmagic-0.12.7-py27_1002.conda": { + "build": "py27_1002", + "build_number": 1002, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=2.7,<2.8.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "md5": "411fc43686832a4e4c4a9f7d47c4b97d", + "name": "sparkmagic", + "sha256": "28bb452256205c13e854b82affa9b91776f9f0560990ad7415083df3513abf11", + "size": 96204, + "subdir": "linux-64", + "timestamp": 1561070014501, + "version": "0.12.7" + }, + "sparkmagic-0.12.7-py36_1001.conda": { + "build": "py36_1001", + "build_number": 1001, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "md5": "f01b3e78538c0d2bbb473b5c67e704d6", + "name": "sparkmagic", + "sha256": "e5c1aed16439620b595621913410b3ba50757c57ad14f155c24f4654779ecb03", + "size": 96672, + "subdir": "linux-64", + "timestamp": 1551473616699, + "version": "0.12.7" + }, + "sparkmagic-0.12.7-py36_1002.conda": { + "build": "py36_1002", + "build_number": 1002, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.6,<3.7.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "md5": "aa1c0dd2924948c7f5b9d4668fa8d315", + "name": "sparkmagic", + "sha256": "9482170169c5c7e7a5cf7d111d9e9a4f34321df3b4a20206525e90422bf12797", + "size": 97624, + "subdir": "linux-64", + "timestamp": 1561070101808, + "version": "0.12.7" + }, + "sparkmagic-0.12.7-py37_1001.conda": { + "build": "py37_1001", + "build_number": 1001, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "md5": "57c7d49e9483677e6f95df4f3dc48952", + "name": "sparkmagic", + "sha256": "1be3cb31b76b0c2a9651de4847b85b2e516b86ff6ab931bd25f373a0323d51fe", + "size": 97686, + "subdir": "linux-64", + "timestamp": 1551473557092, + "version": "0.12.7" + }, + "sparkmagic-0.12.7-py37_1002.conda": { + "build": "py37_1002", + "build_number": 1002, + "depends": [ + "autovizwidget", + "hdijupyterutils", + "ipykernel >=4.2.2,<4.10.0", + "ipython", + "ipywidgets >=5.0.0", + "notebook >=4.2", + "numpy", + "pandas", + "python >=3.7,<3.8.0a0", + "requests", + "requests-kerberos", + "widgetsnbextension" + ], + "license": "BSD 3-clause", + "md5": "6481762a8156c0077abac1903d740089", + "name": "sparkmagic", + "sha256": "fc95c7a4f0f6df33923502c8b707a731e5de361692f8cad47b67f7366e0c680e", + "size": 97842, + "subdir": "linux-64", + "timestamp": 1561070018387, + "version": "0.12.7" + }, + "sparkmagic-0.20.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.10,<3.11.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a4913da24762a61ffd2db5deca3e1241", + "name": "sparkmagic", + "sha256": "eb33aee0a6152aedd99cc0defc50cc59e6eb7ac1f91a6e477c97c3d1af99be74", + "size": 120476, + "subdir": "linux-64", + "timestamp": 1663060889039, + "version": "0.20.0" + }, + "sparkmagic-0.20.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.10,<3.11.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c3e5961a4b868de85b9c2c0eedc4a2ba", + "name": "sparkmagic", + "sha256": "d7077904c03f35bac718ef611e1ecccde9e740af3597a7408cf8776dbc8b5044", + "size": 120989, + "subdir": "linux-64", + "timestamp": 1663085254477, + "version": "0.20.0" + }, + "sparkmagic-0.20.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.11,<3.12.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d30c6eced4176765fa6e7531a8c633be", + "name": "sparkmagic", + "sha256": "131e570633e8563efdb6a0e274d382954515b3408578fc4f153197510e6b840e", + "size": 149786, + "subdir": "linux-64", + "timestamp": 1677697569939, + "version": "0.20.0" + }, + "sparkmagic-0.20.0-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.11,<3.12.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b47820348a95e346f462e39851e1c882", + "name": "sparkmagic", + "sha256": "78039c5e319852f234239cead918f293dbfb002ebf2348b2a4159c70d338a46d", + "size": 151002, + "subdir": "linux-64", + "timestamp": 1679339203925, + "version": "0.20.0" + }, + "sparkmagic-0.20.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.7,<3.8.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6062daccabc30cd81387fc8ebcac8aed", + "name": "sparkmagic", + "sha256": "379cf745eaaf25e1226c18e2c7cd09968488274c73662f519cf635204266e09d", + "size": 118903, + "subdir": "linux-64", + "timestamp": 1663060957546, + "version": "0.20.0" + }, + "sparkmagic-0.20.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.7,<3.8.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6f4642df75bb1d09fec7736faa2bab8f", + "name": "sparkmagic", + "sha256": "8eaffaebb35a4125460a1195ceac9fbf291154119319993665346d319120f4cc", + "size": 118855, + "subdir": "linux-64", + "timestamp": 1663085493331, + "version": "0.20.0" + }, + "sparkmagic-0.20.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.8,<3.9.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2871f214dc0c7c359060dec6f7522fcf", + "name": "sparkmagic", + "sha256": "19983d97b84c398e0914993cacb16a730bd8c2e950310399f299a1b6f7ff423b", + "size": 119783, + "subdir": "linux-64", + "timestamp": 1663060802652, + "version": "0.20.0" + }, + "sparkmagic-0.20.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.8,<3.9.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8d199adc1f1795f5e88ad0cb3055ef2f", + "name": "sparkmagic", + "sha256": "0e3afa50840af117bc5a7f2787e377b35f1287e039c476c02070d56f6977e7cf", + "size": 119673, + "subdir": "linux-64", + "timestamp": 1663085348601, + "version": "0.20.0" + }, + "sparkmagic-0.20.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.9,<3.10.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9d23b9c042250c9b8d0ff8e27fb73b15", + "name": "sparkmagic", + "sha256": "af8cb789150fb51857fed31c17c50ebe5b5f0fb5f1b2269ad5b2eade44fe7abe", + "size": 119639, + "subdir": "linux-64", + "timestamp": 1663061027908, + "version": "0.20.0" + }, + "sparkmagic-0.20.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "autovizwidget >=0.6", + "hdijupyterutils >=0.6", + "ipykernel >=4.2.2", + "ipython >=5", + "ipywidgets >5.0.0", + "mock", + "nest-asyncio 1.5.5.*", + "nose", + "notebook >=4.2", + "numpy", + "pandas >=0.17.1", + "python >=3.9,<3.10.0a0", + "requests", + "requests-kerberos >=0.8.0", + "tornado >=4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5e6d42817b85eb7f7fcf625b51e98fc5", + "name": "sparkmagic", + "sha256": "bffeb2da5c9ac6e755a102a43b9c6106c023562fcf9659f722ad31dc14062230", + "size": 120289, + "subdir": "linux-64", + "timestamp": 1663085419122, + "version": "0.20.0" + }, + "spdlog-1.11.0-hdb19cb5_0.conda": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "fmt >=9.1.0,<10.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "023cfe6341f1d90dee2016e608538537", + "name": "spdlog", + "sha256": "bac82a4382c60aa28455305fd2ead3b687dcaa35ebd15a6ac42190e6e32e65df", + "size": 239450, + "subdir": "linux-64", + "timestamp": 1676361400180, + "version": "1.11.0" + }, + "spdlog-1.8.0-hfd86e86_1.conda": { + "build": "hfd86e86_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "91580d32e51c28895601345872e0e797", + "name": "spdlog", + "sha256": "2895b1b5e4551329ee2449a0fd86d3e186eb0ef8da87831890e887d59cb1edf5", + "size": 1507430, + "subdir": "linux-64", + "timestamp": 1600695090058, + "version": "1.8.0" + }, + "spdlog-1.8.1-h7739ffd_0.conda": { + "build": "h7739ffd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7faccc9bce7ccf7c7e50e5889c065077", + "name": "spdlog", + "sha256": "6efdc04a0753348b614079afee05a0c1cdf99783d24eb6c77029a19241489951", + "size": 293492, + "subdir": "linux-64", + "timestamp": 1603921386766, + "version": "1.8.1" + }, + "spdlog-1.8.2-hff7bd54_0.conda": { + "build": "hff7bd54_0", + "build_number": 0, + "depends": [ + "fmt >=7.1.3,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "04e06ad61c8253dbf82e3e3482309561", + "name": "spdlog", + "sha256": "94cb0c255c6825ada1025cd48d851fbf5239e1393a562e0425e5c1f88a2fde7f", + "size": 163616, + "subdir": "linux-64", + "timestamp": 1608225075884, + "version": "1.8.2" + }, + "spdlog-1.9.0-hd09550d_0.conda": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "fmt >=7.1.3,<8.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1acf8617267a64d66a3e3237eaea09e0", + "name": "spdlog", + "sha256": "ed3d21ecc24b81ff50ecd2ad395d0b0cc5a13ae1fe57744e2f49fc5ca64edd3a", + "size": 169275, + "subdir": "linux-64", + "timestamp": 1626867794353, + "version": "1.9.0" + }, + "spdlog-1.9.2-hd09550d_0.conda": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "fmt >=8.1.1,<9.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "603260670a954e284e3d642b35896042", + "name": "spdlog", + "sha256": "a2589af6a377a3047e7bd292d24f84116b2746eecd9726dc52a36eb1314cb0b1", + "size": 203674, + "subdir": "linux-64", + "timestamp": 1646908211737, + "version": "1.9.2" + }, + "spdlog-fmt-embed-1.11.0-hdb19cb5_0.conda": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "93af3bfe6bf7e595b29d69fbdcfdec26", + "name": "spdlog-fmt-embed", + "sha256": "00b75c138020d096d186d43cd7d2c7d6445d265561e1cef699b675b834ed7c62", + "size": 368249, + "subdir": "linux-64", + "timestamp": 1676361466975, + "version": "1.11.0" + }, + "spdlog-fmt-embed-1.9.2-hd09550d_0.conda": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "68f707026265d8696c253f2e1ed14bfc", + "name": "spdlog-fmt-embed", + "sha256": "35440c99d3754dee981e6def1928e45ab10a890a19773b12d07aceb3a21705b9", + "size": 325269, + "subdir": "linux-64", + "timestamp": 1646908251183, + "version": "1.9.2" + }, + "sphinx-1.6.3-py27hf9b1778_0.conda": { + "build": "py27hf9b1778_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "pygments", + "python >=2.7,<2.8.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "b271e48fb113d1a6316d90fb2eb5d096", + "name": "sphinx", + "sha256": "88733774ec26549d6689d18d97531778d4a7c7f72d599fa29141c52492b655b2", + "size": 1357469, + "subdir": "linux-64", + "timestamp": 1505746965605, + "version": "1.6.3" + }, + "sphinx-1.6.3-py35hea25a1c_0.conda": { + "build": "py35hea25a1c_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "pygments", + "python >=3.5,<3.6.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "edcc5fd39d5f3188a2af208f02d82daa", + "name": "sphinx", + "sha256": "e76eb4cba142700e0fa393aa545d0a9e3982c6fea89e88cfb490ce16e0359bbc", + "size": 1356542, + "subdir": "linux-64", + "timestamp": 1505746998826, + "version": "1.6.3" + }, + "sphinx-1.6.3-py36he5f0bdb_0.conda": { + "build": "py36he5f0bdb_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "f6747709fcb33d2ecda75329917aeb00", + "name": "sphinx", + "sha256": "d1940965fe9204e12c4ba87e7449d58547f8b83f2854a5bed34bf86a8f034ef2", + "size": 1353436, + "subdir": "linux-64", + "timestamp": 1505747033382, + "version": "1.6.3" + }, + "sphinx-1.6.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "pygments", + "python >=2.7,<2.8.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "bdb3e5389d4caa0f542d1767519e4071", + "name": "sphinx", + "sha256": "08eddd5c67dc58731d52d9d71476c3e12d67856c2a7e6d980e428742e782abd6", + "size": 1357640, + "subdir": "linux-64", + "timestamp": 1515725005345, + "version": "1.6.6" + }, + "sphinx-1.6.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "pygments", + "python >=3.5,<3.6.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "d0d1cfc749a1c79fe7461ef1a7a4c40d", + "name": "sphinx", + "sha256": "2bd201af9ce27ea23f0e877faaa9c2780943f6f25bdd6ab0aa36c02371d0f8e7", + "size": 1362424, + "subdir": "linux-64", + "timestamp": 1515725279669, + "version": "1.6.6" + }, + "sphinx-1.6.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "971ab92234ad838ec3f8c84950fc67a4", + "name": "sphinx", + "sha256": "0e01f6c5dcefb5bdc53ee70c9a762ed9d868da84a7febab599de5d9c465afa57", + "size": 1350493, + "subdir": "linux-64", + "timestamp": 1515725330989, + "version": "1.6.6" + }, + "sphinx-1.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=2.7,<2.8.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "9f4e77ab8fa9dba792e3fb3a81d6d37e", + "name": "sphinx", + "sha256": "86ccec5541b1f94f639f8e98b3a602bc6476b9782d1e481e12920b604ffdd0d9", + "size": 1335622, + "subdir": "linux-64", + "timestamp": 1519140274911, + "version": "1.7.0" + }, + "sphinx-1.7.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.5,<3.6.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "efb262ef9a04f802d61b59df9421ae53", + "name": "sphinx", + "sha256": "563c5edbc2f841ccb6600a9835069b9535fc06788225dba376bda4ee4dd61153", + "size": 1341864, + "subdir": "linux-64", + "timestamp": 1519140322607, + "version": "1.7.0" + }, + "sphinx-1.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "6783ccdbee729ec72b423c08e26cbdbc", + "name": "sphinx", + "sha256": "25d56ad4feecf867247944660f99e19442c486b8ecd2e641583c212c1232aa71", + "size": 1330478, + "subdir": "linux-64", + "timestamp": 1519140322167, + "version": "1.7.0" + }, + "sphinx-1.7.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=2.7,<2.8.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "90fa99f3e2273fb96c4c70b9b0c1ccdf", + "name": "sphinx", + "sha256": "f3118d396d1fa61272030fa91303b645b7cd65d4bc2e8c6a09b76b2531da2655", + "size": 1345319, + "subdir": "linux-64", + "timestamp": 1519747892013, + "version": "1.7.1" + }, + "sphinx-1.7.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.5,<3.6.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "5438cf44b9d9615a1c7a02f78d678b38", + "name": "sphinx", + "sha256": "9435be555eb0faa1448b715b1d2a57567ce4ed0749f0f81689d210bd0faf8f9d", + "size": 1350790, + "subdir": "linux-64", + "timestamp": 1519747909735, + "version": "1.7.1" + }, + "sphinx-1.7.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "22029420dccf10cda6343b9cf08f93b3", + "name": "sphinx", + "sha256": "b1df96170cbf08055c1f2de0e6c1abd5859b34d17c6624273e2f6680141041ae", + "size": 1339375, + "subdir": "linux-64", + "timestamp": 1519747903846, + "version": "1.7.1" + }, + "sphinx-1.7.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=2.7,<2.8.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "5b45c6bae49b74b300b8249fe548e40e", + "name": "sphinx", + "sha256": "594667ec6805e48ee359b21cc3048b46d2cb610aacd254d53d3043b0d9eb21f0", + "size": 1338399, + "subdir": "linux-64", + "timestamp": 1522187132173, + "version": "1.7.2" + }, + "sphinx-1.7.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.5,<3.6.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "ea4fb81dae3896cab380fa49bc1b9064", + "name": "sphinx", + "sha256": "3e25f75a26e4b750b2f84b93fe53c4ce76e00a8a0a8c1c6b5499457c78f691df", + "size": 1349122, + "subdir": "linux-64", + "timestamp": 1522187154415, + "version": "1.7.2" + }, + "sphinx-1.7.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "71bd87f72dc01a5ddbc11005aae55ae5", + "name": "sphinx", + "sha256": "892b02e2162b396a64fde6fe587618a717808b5902d2ca99818c3f3bec06ef1d", + "size": 1333709, + "subdir": "linux-64", + "timestamp": 1522187115767, + "version": "1.7.2" + }, + "sphinx-1.7.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=2.7,<2.8.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "184dd926c2d9106cb8dfe203b3e76aba", + "name": "sphinx", + "sha256": "8504bc8e16c8dedcc6232dbb6f363ebb09a91d23a01684d77417f5c3a7033b03", + "size": 1341624, + "subdir": "linux-64", + "timestamp": 1524496963197, + "version": "1.7.3" + }, + "sphinx-1.7.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.5,<3.6.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "c4a0202dad140972448b3cf710bf010a", + "name": "sphinx", + "sha256": "408f7734f4a5449a4f3aadce676c64bb5aae51df3d389208f579ac68d52d9333", + "size": 1346764, + "subdir": "linux-64", + "timestamp": 1524496969376, + "version": "1.7.3" + }, + "sphinx-1.7.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "84c9057e838967e3c37fd6f3f0885ea0", + "name": "sphinx", + "sha256": "7ac01539059d080725337b327947c92f521f7d2f1c42594c964173c49ad5fc78", + "size": 1335469, + "subdir": "linux-64", + "timestamp": 1524496984919, + "version": "1.7.3" + }, + "sphinx-1.7.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=2.7,<2.8.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "2eeba46a26cd6bf546f0a032c508d516", + "name": "sphinx", + "sha256": "0c7105252152e90e15094e62c4028e3b988a8603cf17cd0da80bb46d632544f2", + "size": 1342014, + "subdir": "linux-64", + "timestamp": 1525119308004, + "version": "1.7.4" + }, + "sphinx-1.7.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.5,<3.6.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "8392c99817aa3eb3f1f6ba02488e5dfd", + "name": "sphinx", + "sha256": "1c63303bfa36be2ee106021af8cde84b33e866a12fb2816da0383ae2c8bd9b65", + "size": 1352205, + "subdir": "linux-64", + "timestamp": 1525119324042, + "version": "1.7.4" + }, + "sphinx-1.7.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster", + "babel", + "docutils", + "imagesize", + "jinja2", + "packaging", + "pygments", + "python >=3.6,<3.7.0a0", + "requests", + "six", + "snowballstemmer", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "e8c395744945227aa38d493a4110dc5f", + "name": "sphinx", + "sha256": "0005db977ef7dd94b3ec71734798f3bca5cb4de981dbd64781c28f66f6dbd7a5", + "size": 1340013, + "subdir": "linux-64", + "timestamp": 1525119213042, + "version": "1.7.4" + }, + "sphinx-1.7.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >2.0", + "python >=2.7,<2.8.0a0", + "requests >2.0.0", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "b3c67b1aa36cfa33f6c66382fe8945fe", + "name": "sphinx", + "sha256": "876a122965ca3c2d424ff39434741bcbec17b4f0b146bbf95b5fe0093bdacd87", + "size": 1342965, + "subdir": "linux-64", + "timestamp": 1527875800407, + "version": "1.7.5" + }, + "sphinx-1.7.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >2.0", + "python >=3.5,<3.6.0a0", + "requests >2.0.0", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "0257decb4cf586ea1373537628b63f2d", + "name": "sphinx", + "sha256": "3d4afa8b5f2da35acbd8201f6a27a88655dafc7ab399f880ea3ad25796d132a6", + "size": 1348311, + "subdir": "linux-64", + "timestamp": 1527875805729, + "version": "1.7.5" + }, + "sphinx-1.7.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >2.0", + "python >=3.6,<3.7.0a0", + "requests >2.0.0", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "fa33bf1e592a5c29e5343c5192c2dbc4", + "name": "sphinx", + "sha256": "2c095cc7b664392dfd3e44fe7c40644ee71b2d355e23f8bf0113d913ac4a2f8a", + "size": 1342535, + "subdir": "linux-64", + "timestamp": 1527875736544, + "version": "1.7.5" + }, + "sphinx-1.7.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >2.0", + "python >=3.7,<3.8.0a0", + "requests >2.0.0", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "754942924f4041ddb6b80275167dd94f", + "name": "sphinx", + "sha256": "ba46a476f6b9df287d00022731eb539eae72275e873f6eed8048a5ccd1a01f21", + "size": 1334193, + "subdir": "linux-64", + "timestamp": 1530733620621, + "version": "1.7.5" + }, + "sphinx-1.7.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >2.0", + "python >=2.7,<2.8.0a0", + "requests >2.0.0", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "cfedf406f9e01358dbefa356dccb30ba", + "name": "sphinx", + "sha256": "30dd04323412d59582cafb82bf33abb05f9320ac0a5beef691f803626bd9ff0a", + "size": 1344515, + "subdir": "linux-64", + "timestamp": 1532452325113, + "version": "1.7.6" + }, + "sphinx-1.7.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >2.0", + "python >=3.5,<3.6.0a0", + "requests >2.0.0", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "74affd1e610edf9c2c64db70ec2bf103", + "name": "sphinx", + "sha256": "96be39874a2ff87b13dc9b844d605e02bc3d1a71c0a57da1ae4a4e582e002059", + "size": 1349355, + "subdir": "linux-64", + "timestamp": 1532452374809, + "version": "1.7.6" + }, + "sphinx-1.7.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >2.0", + "python >=3.6,<3.7.0a0", + "requests >2.0.0", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "bf48bf60722c5e89cb15c4f0cd7b2c00", + "name": "sphinx", + "sha256": "d192b6a8ec391a9000c44660c2a07212d43e4b5a8a0a3261e3e52ef0c60544dd", + "size": 1344634, + "subdir": "linux-64", + "timestamp": 1532455792792, + "version": "1.7.6" + }, + "sphinx-1.7.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >2.0", + "python >=3.7,<3.8.0a0", + "requests >2.0.0", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "a2ae0d336bb506050ca21a57142b1399", + "name": "sphinx", + "sha256": "e3924da05431a4a63462d41cc413b5bd4a00d7aeb5c1449fdbf604dbf6ef352d", + "size": 1341988, + "subdir": "linux-64", + "timestamp": 1532452263449, + "version": "1.7.6" + }, + "sphinx-1.7.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "a8db79c53febc2cdf3b789ead7bc790c", + "name": "sphinx", + "sha256": "5aeae7d6f2b819e5887f5e3fb598bc554e841eac72803fbe453db8cc8ac8bb14", + "size": 1345707, + "subdir": "linux-64", + "timestamp": 1534947948433, + "version": "1.7.7" + }, + "sphinx-1.7.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "05a8b725db0b0e7218dbe183fd41240e", + "name": "sphinx", + "sha256": "3a9acb1938fdff382db270b5728501fd07089d0e650e34e595b7c40509dc4d95", + "size": 1351248, + "subdir": "linux-64", + "timestamp": 1534947982063, + "version": "1.7.7" + }, + "sphinx-1.7.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "bb8343b85668e1ff18ac2c92dc994910", + "name": "sphinx", + "sha256": "a23cc5f215d5637fda54565f6b57a232ce5587cb894e0aa89a852b6ae8e54794", + "size": 1345532, + "subdir": "linux-64", + "timestamp": 1534947821762, + "version": "1.7.7" + }, + "sphinx-1.7.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "feac9cf93e093916a6d56147b6415d99", + "name": "sphinx", + "sha256": "cd503b968e63f7bf8ba43774409a5b2fef6feb78e1b0b10d5a0316fe34eb7a06", + "size": 1338190, + "subdir": "linux-64", + "timestamp": 1534947867990, + "version": "1.7.7" + }, + "sphinx-1.7.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "ee8f8be6bc3b8d32995df8d1811abe6c", + "name": "sphinx", + "sha256": "5e407b93b3a47a50dc4e78e0d08a304aeebc7bc6a19cd1e5f97374e24b65b5de", + "size": 1350122, + "subdir": "linux-64", + "timestamp": 1536076407539, + "version": "1.7.8" + }, + "sphinx-1.7.8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "1bf545035b1f8d4df66ec40e01bb71d0", + "name": "sphinx", + "sha256": "76fb4c7c2506323ceb82faa40d26b1540a8eff40bf96ade9a9db164acf2d344b", + "size": 1357566, + "subdir": "linux-64", + "timestamp": 1536076407907, + "version": "1.7.8" + }, + "sphinx-1.7.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "dc5e09b226e658d81fe6a90bb02a2894", + "name": "sphinx", + "sha256": "e4ea6d4198aa7615627cde27ac5d6ea502fa2a5e055e743d20b408580bf63e0d", + "size": 1339803, + "subdir": "linux-64", + "timestamp": 1536076424744, + "version": "1.7.8" + }, + "sphinx-1.7.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "d1cde080320e20d2007781940f5d7c53", + "name": "sphinx", + "sha256": "ac202da717c07ce9f450d2a881e39a81cba86bd9ae49b24a776d949843e58a3d", + "size": 1338333, + "subdir": "linux-64", + "timestamp": 1536076413861, + "version": "1.7.8" + }, + "sphinx-1.7.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "b3431df205e8a5e72a1d62c4ce173090", + "name": "sphinx", + "sha256": "7813d2c3e2833f88feac68b097c0a2a07d439d83cb3eae53bb496536f8cffed5", + "size": 1349921, + "subdir": "linux-64", + "timestamp": 1536696742509, + "version": "1.7.9" + }, + "sphinx-1.7.9-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.5,<3.6.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "812d4e209043dbb8522d1b31e47b76dd", + "name": "sphinx", + "sha256": "c084207528cbab2402b1ffa2e293e0af2248ebd7c252a2c0ad8daace26629a34", + "size": 1351321, + "subdir": "linux-64", + "timestamp": 1536696765089, + "version": "1.7.9" + }, + "sphinx-1.7.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "08b069b3bdd541f59b98aa041e5fb82b", + "name": "sphinx", + "sha256": "f5779cc8a809aba9cbefc45f612b73060ae4cbdb4cda321ac9f832d911c6a0bc", + "size": 1346557, + "subdir": "linux-64", + "timestamp": 1536696781157, + "version": "1.7.9" + }, + "sphinx-1.7.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "fda3e17a6f2ce3f61d38ea04a91d6e06", + "name": "sphinx", + "sha256": "02d879aab500c378e7663fc7aec7013dff2d09da412b250ea3a772889b733f18", + "size": 1338261, + "subdir": "linux-64", + "timestamp": 1536696742509, + "version": "1.7.9" + }, + "sphinx-1.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "716aa5d1a449130018700c1bbe06fb33", + "name": "sphinx", + "sha256": "9f70faeb04de5a2862c478200d331f766f416aca67e5e6dce5da49661ef50e1a", + "size": 1474436, + "subdir": "linux-64", + "timestamp": 1538161600697, + "version": "1.8.1" + }, + "sphinx-1.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "e05d48b98b7316d57458b5da6f926421", + "name": "sphinx", + "sha256": "1786895b3a8346b01057cdd3a61ea09b9a685de802730fbbff906bddaa3cea86", + "size": 1470301, + "subdir": "linux-64", + "timestamp": 1538161583212, + "version": "1.8.1" + }, + "sphinx-1.8.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "5fa422c10390226579e0da2ed280244c", + "name": "sphinx", + "sha256": "58f814dcfa772b807ccaa454ab673bd221a5dbb7d0e173bed04abcef484cdf77", + "size": 1466843, + "subdir": "linux-64", + "timestamp": 1538161604812, + "version": "1.8.1" + }, + "sphinx-1.8.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "d3e4616469790ee1def85c2ad5bd48c4", + "name": "sphinx", + "sha256": "a39354a1b2ff6b9491e32412a5db57f8eb5c845cf4076d8e0a10dd237c48aced", + "size": 1473516, + "subdir": "linux-64", + "timestamp": 1542090000010, + "version": "1.8.2" + }, + "sphinx-1.8.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "b65f929b9c3da989601eb21a271b81ea", + "name": "sphinx", + "sha256": "47a5fcf8c74467b3ca90e131810acf68b45439f5635870248a0dde90d85fb4c3", + "size": 1465647, + "subdir": "linux-64", + "timestamp": 1542089993914, + "version": "1.8.2" + }, + "sphinx-1.8.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "033eae2b195f1dc84a809df46bcb2250", + "name": "sphinx", + "sha256": "8f02a0c1c8686a46de142d35edb44dae656c8ccfca700e359f97f4757d0bf3e8", + "size": 1464331, + "subdir": "linux-64", + "timestamp": 1542089955340, + "version": "1.8.2" + }, + "sphinx-1.8.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "ad19b0b7b17a4c009147ec5fdd7062e5", + "name": "sphinx", + "sha256": "6f83d501bf436b559c5039675bd4834012d89041d44f04cea6bab2ffdeaa9f64", + "size": 1474706, + "subdir": "linux-64", + "timestamp": 1549326409676, + "version": "1.8.4" + }, + "sphinx-1.8.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "df43cb2c472e811dcc627acc9bfefe42", + "name": "sphinx", + "sha256": "dece6c7c2088d758f1f885d1b30f62c19e03af67da1e5ef3fd815c5e862224f0", + "size": 1470165, + "subdir": "linux-64", + "timestamp": 1549326464543, + "version": "1.8.4" + }, + "sphinx-1.8.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "78ae8ffce1e8d6ad15f965fe9036fdf0", + "name": "sphinx", + "sha256": "f83e65e5b601b067b5afaf3d4adf7437d3d10c0b567a496f16f03c810ba43287", + "size": 1467866, + "subdir": "linux-64", + "timestamp": 1549326428772, + "version": "1.8.4" + }, + "sphinx-1.8.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=2.7,<2.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport", + "typing" + ], + "license": "BSD 2-clause", + "md5": "6754703fe7604e3429f1bce17f0db760", + "name": "sphinx", + "sha256": "2570f754125e243ee90cfc3b5861c414b45536642271303148c27f8437fc14f6", + "size": 1481055, + "subdir": "linux-64", + "timestamp": 1552326249875, + "version": "1.8.5" + }, + "sphinx-1.8.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.6,<3.7.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "8cbfd7d4c616f703eaec59d7218f6ad0", + "name": "sphinx", + "sha256": "2616ea6d229f19a65a29431bc013d40bd24201567441574872f0e09310f52755", + "size": 1476875, + "subdir": "linux-64", + "timestamp": 1552326302183, + "version": "1.8.5" + }, + "sphinx-1.8.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3,!=2.0", + "docutils >=0.11", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.0.0", + "setuptools", + "six >=1.5", + "snowballstemmer >=1.1", + "sphinxcontrib-websupport" + ], + "license": "BSD 2-clause", + "md5": "7a62d4be48fc411eda2a7a655c14dc28", + "name": "sphinx", + "sha256": "53fc0be8da5e8a93ee0062162350adfa371abd3b171f7db70cf6b8a2d6c25081", + "size": 1479182, + "subdir": "linux-64", + "timestamp": 1552326280923, + "version": "1.8.5" + }, + "sphinx-5.0.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3", + "colorama >=0.3.5", + "docutils >=0.14,<0.19", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.10,<3.11.0a0", + "requests >=2.5.0", + "snowballstemmer >=1.1", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp >=2.0.0", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml >=1.1.5" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "9636e58b351ac5c4cc8367bcc0c29321", + "name": "sphinx", + "sha256": "bcb7da0b7c43327eb4c64fc391f4694b964542e1e86e857fb66a63a981371447", + "size": 1811910, + "subdir": "linux-64", + "timestamp": 1657784175183, + "version": "5.0.2" + }, + "sphinx-5.0.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3", + "colorama >=0.3.5", + "docutils >=0.14,<0.19", + "imagesize", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.11,<3.12.0a0", + "requests >=2.5.0", + "snowballstemmer >=1.1", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp >=2.0.0", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml >=1.1.5" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ed071b775d26745823d958bf3751b044", + "name": "sphinx", + "sha256": "71f6d8b1aa343d431643e50061389549810297d1a29d231f3f03fe28561300ea", + "size": 2389955, + "subdir": "linux-64", + "timestamp": 1676842881763, + "version": "5.0.2" + }, + "sphinx-5.0.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3", + "colorama >=0.3.5", + "docutils >=0.14,<0.19", + "imagesize", + "importlib-metadata >=4.4", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.7,<3.8.0a0", + "requests >=2.5.0", + "snowballstemmer >=1.1", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp >=2.0.0", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml >=1.1.5" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "1a90fca6e65e948444800afc1c93004e", + "name": "sphinx", + "sha256": "c80ac69d0f81af4661e2bf370bc64ec0c655e09035613e70dc8ae186c4dd372a", + "size": 1791431, + "subdir": "linux-64", + "timestamp": 1657784218874, + "version": "5.0.2" + }, + "sphinx-5.0.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3", + "colorama >=0.3.5", + "docutils >=0.14,<0.19", + "imagesize", + "importlib-metadata >=4.4", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.8,<3.9.0a0", + "requests >=2.5.0", + "snowballstemmer >=1.1", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp >=2.0.0", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml >=1.1.5" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e06586fa8582833a73e8c751a71c1ba3", + "name": "sphinx", + "sha256": "c172a64ae204ddb366636175fbe7f7aff1656f43986a9cae8a1bc6f1824994a7", + "size": 1797528, + "subdir": "linux-64", + "timestamp": 1657784304555, + "version": "5.0.2" + }, + "sphinx-5.0.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "alabaster >=0.7,<0.8", + "babel >=1.3", + "colorama >=0.3.5", + "docutils >=0.14,<0.19", + "imagesize", + "importlib-metadata >=4.4", + "jinja2 >=2.3", + "packaging", + "pygments >=2.0", + "python >=3.9,<3.10.0a0", + "requests >=2.5.0", + "snowballstemmer >=1.1", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp >=2.0.0", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml >=1.1.5" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8ea4d14304219bfcb4a67da8b34d76ce", + "name": "sphinx", + "sha256": "1b91d66b4b8d767cd336eea6935de05dbc0f21157a7f416e830431812140d15b", + "size": 1796761, + "subdir": "linux-64", + "timestamp": 1657784262535, + "version": "5.0.2" + }, + "sphinx_rtd_theme-0.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "35ce503c9e004fa19bde84bcc5f37c55", + "name": "sphinx_rtd_theme", + "sha256": "7d6e5e3af9f05b82ffc0ebd3453a73019a6020d6bf08bcb49cf045fbe3119828", + "size": 1497242, + "subdir": "linux-64", + "timestamp": 1523999323417, + "version": "0.3.0" + }, + "sphinx_rtd_theme-0.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "085aef50b5100fe1a8ac9bbb349206c2", + "name": "sphinx_rtd_theme", + "sha256": "4eb074f492be7866ebd6b883bb17f3441c1fe745fe067b091f1ad8e24ff8c5a1", + "size": 1500451, + "subdir": "linux-64", + "timestamp": 1523999330741, + "version": "0.3.0" + }, + "sphinx_rtd_theme-0.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "edf019a140462a4fd857de71fc05f384", + "name": "sphinx_rtd_theme", + "sha256": "66aca089f1aa576d2b60dc0cc4ef7b8f31fd1ab7058e4f46064548cdd4f9ad9e", + "size": 1501415, + "subdir": "linux-64", + "timestamp": 1523999386693, + "version": "0.3.0" + }, + "sphinx_rtd_theme-0.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c24ab21cb6d7f54c8b3bfdd52721a68a", + "name": "sphinx_rtd_theme", + "sha256": "9e70d9f8fc27e24a8ea3522fdab29c6ef7f1bb44fa74724023564c5acdf90f0c", + "size": 1500948, + "subdir": "linux-64", + "timestamp": 1526918172887, + "version": "0.3.1" + }, + "sphinx_rtd_theme-0.3.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "a68e1823205eb4737812de2caa7630d3", + "name": "sphinx_rtd_theme", + "sha256": "139b30da085b2f4620df46b12bcca9a10e15be3f88fdda01b7b4c7858ef5b260", + "size": 1496696, + "subdir": "linux-64", + "timestamp": 1526918163228, + "version": "0.3.1" + }, + "sphinx_rtd_theme-0.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6429fc7971c2a1f24621389a7aae8977", + "name": "sphinx_rtd_theme", + "sha256": "8d6e71fa387a778b222551fbf70d51d80634b8c213b1898392048f6993b14205", + "size": 1496649, + "subdir": "linux-64", + "timestamp": 1526918160693, + "version": "0.3.1" + }, + "sphinx_rtd_theme-0.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "713d75b3dfa1d47a16debb207ef8696e", + "name": "sphinx_rtd_theme", + "sha256": "51735cd44272fb9b8a4baa77a95b07ce6514f54b1e5f1bbaa3932d4381928608", + "size": 4628592, + "subdir": "linux-64", + "timestamp": 1528984088041, + "version": "0.4.0" + }, + "sphinx_rtd_theme-0.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "d5fe285e94a64fbd6ffb666808c7a734", + "name": "sphinx_rtd_theme", + "sha256": "48a5bc73efc64c51675f892e539ddfcda5be92994ebd5fb522daf3e32c5a6fc2", + "size": 4623639, + "subdir": "linux-64", + "timestamp": 1528983901133, + "version": "0.4.0" + }, + "sphinx_rtd_theme-0.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4805768b9c7c4991352c5dbcc67cc6f9", + "name": "sphinx_rtd_theme", + "sha256": "3c3db3d78a7df0a4aa51738124ec32809f4ec0f5a9ee5d568cf2046f75c7ccca", + "size": 4623649, + "subdir": "linux-64", + "timestamp": 1528983869462, + "version": "0.4.0" + }, + "sphinx_rtd_theme-0.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a1bfb435f460b2a4c0fdc57f0dc6f13e", + "name": "sphinx_rtd_theme", + "sha256": "ed3352c73d497bde73c4298eca563a428713ab07d969594396f7f9f68a51ed56", + "size": 4624039, + "subdir": "linux-64", + "timestamp": 1531059543521, + "version": "0.4.0" + }, + "sphinx_rtd_theme-0.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "8e7abbdc535ff1bdf6a586ec0cffb124", + "name": "sphinx_rtd_theme", + "sha256": "12c26241b236b5fed5b6fe15256a5fc3402cb242b55e8307b02cabddf00bbdfa", + "size": 4624521, + "subdir": "linux-64", + "timestamp": 1532998146640, + "version": "0.4.1" + }, + "sphinx_rtd_theme-0.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "7440eb6a7a497c3a0deb78b158e703d7", + "name": "sphinx_rtd_theme", + "sha256": "47ab51fe5969401f7c03743a60673da7221ff80608f07d3d62b7a7487f74b0e1", + "size": 4626657, + "subdir": "linux-64", + "timestamp": 1532998115897, + "version": "0.4.1" + }, + "sphinx_rtd_theme-0.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f4af19e3253918fc27cbd60b00deb24c", + "name": "sphinx_rtd_theme", + "sha256": "98d0a615aa712cf87996532572efd953492ec6a7f65880b8ef753b793ac135ee", + "size": 4624611, + "subdir": "linux-64", + "timestamp": 1532998084872, + "version": "0.4.1" + }, + "sphinx_rtd_theme-0.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "59641db4c723cc7adda0207c7e22d461", + "name": "sphinx_rtd_theme", + "sha256": "0f715e8b7c485654c36675605f4f57466e7881db1ba5fd2935797662d18a34fd", + "size": 4630351, + "subdir": "linux-64", + "timestamp": 1532998158818, + "version": "0.4.1" + }, + "sphinx_rtd_theme-0.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "bf7d0d2d0f6c915417a7f2d0bf065fe0", + "name": "sphinx_rtd_theme", + "sha256": "25c2c5ad9c6bd6a3639d703b66f8c784acdedc32c3b1e28e1e5a70f507a55750", + "size": 4628126, + "subdir": "linux-64", + "timestamp": 1539638374495, + "version": "0.4.2" + }, + "sphinx_rtd_theme-0.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "48eb418e9d5fc84c590a40224178f60e", + "name": "sphinx_rtd_theme", + "sha256": "f5b817167ed4b18cba656e4bdc1b2cdc1a97c815d9610415a76426a221bed9b9", + "size": 4630470, + "subdir": "linux-64", + "timestamp": 1539638390690, + "version": "0.4.2" + }, + "sphinx_rtd_theme-0.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e6a5a06ae248b749e465348b7a1a26d1", + "name": "sphinx_rtd_theme", + "sha256": "2369a026903b6fed3f6bb1db9607ca8385638adabcd27d29a82e3e3bf74e4630", + "size": 4625515, + "subdir": "linux-64", + "timestamp": 1539638396017, + "version": "0.4.2" + }, + "sphinxcontrib-1.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "c28ce2c85676e3c3209063c8acfb2f46", + "name": "sphinxcontrib", + "sha256": "75bfc3566de4007d29fcd9b09bb231ca38511c2e71d0c61cb11eba620f880c00", + "size": 3810, + "subdir": "linux-64", + "timestamp": 1530694859730, + "version": "1.0" + }, + "sphinxcontrib-1.0-py27h1512b58_1.conda": { + "build": "py27h1512b58_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "52e761906fca9f4acbe0b89fc0f8c490", + "name": "sphinxcontrib", + "sha256": "0f87d20c33a838e52fc2facb2c14de551bd28b3808d4f30af073abe8dd2852d3", + "size": 3475, + "subdir": "linux-64", + "timestamp": 1505746837051, + "version": "1.0" + }, + "sphinxcontrib-1.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "e975b06ea9d8e42f8f804a6312bdcfd1", + "name": "sphinxcontrib", + "sha256": "a5366d23cb6959cbb65502dfc263b49e91e2f07c74696ad97864b59c2e2f726a", + "size": 4137, + "subdir": "linux-64", + "timestamp": 1640794832593, + "version": "1.0" + }, + "sphinxcontrib-1.0-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "md5": "25a00280eb7a039b1e5b34cc1686a2a8", + "name": "sphinxcontrib", + "sha256": "0a39441a399d01a2e823c4a40a8a4df480224267d7ab8d88cfbedf0398a00649", + "size": 4554, + "subdir": "linux-64", + "timestamp": 1676907708328, + "version": "1.0" + }, + "sphinxcontrib-1.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "27a8c6436deda1ce03340d3ba8979470", + "name": "sphinxcontrib", + "sha256": "515e2545b1304423c7e559be547b063f221134569adf8f0cc44845dcbeaadc53", + "size": 3816, + "subdir": "linux-64", + "timestamp": 1534345431389, + "version": "1.0" + }, + "sphinxcontrib-1.0-py35hcb7efd2_1.conda": { + "build": "py35hcb7efd2_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "3eb6bccdf5ff9681728d78381a475694", + "name": "sphinxcontrib", + "sha256": "e98673f2b62f0eea7b335e75ff66173d3946a1860513ac031c6792d8d4b7f91c", + "size": 3533, + "subdir": "linux-64", + "timestamp": 1505746848118, + "version": "1.0" + }, + "sphinxcontrib-1.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "f13719602f758d84e02f020265b3efc2", + "name": "sphinxcontrib", + "sha256": "77dae0c1e6068500fd064f226ca79822dade748cd056f2b8d9c06461df234369", + "size": 3864, + "subdir": "linux-64", + "timestamp": 1530694822314, + "version": "1.0" + }, + "sphinxcontrib-1.0-py36h6d0f590_1.conda": { + "build": "py36h6d0f590_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "a5e3fd75644b997008228820347ab425", + "name": "sphinxcontrib", + "sha256": "aaf63739da1291676a29a17f455f4785abb744921c271db0bc2c3b11928646ae", + "size": 3545, + "subdir": "linux-64", + "timestamp": 1505746859621, + "version": "1.0" + }, + "sphinxcontrib-1.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "a392aeff127d7b7bd5e6b071ab2ca28e", + "name": "sphinxcontrib", + "sha256": "d87a8603389d6e4bacd340d3d8fb7838a673b2de80113e36dc6748bc9b3a52fc", + "size": 3870, + "subdir": "linux-64", + "timestamp": 1530694841345, + "version": "1.0" + }, + "sphinxcontrib-1.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "9dbfb31f0e00998fec42bb8236ebb021", + "name": "sphinxcontrib", + "sha256": "9bb997ddeb8d20aed546ed05b1c33f3ad12af488b614d07fa2c16854773ffd01", + "size": 4320, + "subdir": "linux-64", + "timestamp": 1573661755073, + "version": "1.0" + }, + "sphinxcontrib-1.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "33c3be0ff480025741b35f7861f1660e", + "name": "sphinxcontrib", + "sha256": "53e09363dd85b3b7625ce29a4093009a32551f0c6425bc7b3b3f2a803905814b", + "size": 222950, + "subdir": "linux-64", + "timestamp": 1607574925736, + "version": "1.0" + }, + "sphinxcontrib-websupport-1.0.1-py27hf906f22_1.conda": { + "build": "py27hf906f22_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "sphinxcontrib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "d513cb7efd20b2a113f55671515b5495", + "name": "sphinxcontrib-websupport", + "sha256": "16ef5001e0304783afabc1bb42a8d4192d16b48a030d57ededf15e92ab98787b", + "size": 37930, + "subdir": "linux-64", + "timestamp": 1505746873602, + "version": "1.0.1" + }, + "sphinxcontrib-websupport-1.0.1-py35h3537809_1.conda": { + "build": "py35h3537809_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "sphinxcontrib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "92884783c01478349d6e9997389e554e", + "name": "sphinxcontrib-websupport", + "sha256": "66c5e458c731ae827354af6e48b2f7d097643090bc04f0e986fd5d1e5a215595", + "size": 38282, + "subdir": "linux-64", + "timestamp": 1505746887251, + "version": "1.0.1" + }, + "sphinxcontrib-websupport-1.0.1-py36hb5cb234_1.conda": { + "build": "py36hb5cb234_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "sphinxcontrib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "14aa93c7a6f18b58b721b300a6f9bc5b", + "name": "sphinxcontrib-websupport", + "sha256": "49feb2c66f83241a3a01a623915494f46246093e4b8deb118fa05f0108c1df8d", + "size": 37616, + "subdir": "linux-64", + "timestamp": 1505746901013, + "version": "1.0.1" + }, + "sphinxcontrib-websupport-1.1.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "sphinxcontrib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "caadc02a863d73d9f8aadb7fa502a2b2", + "name": "sphinxcontrib-websupport", + "sha256": "e279828fe7d01a64622dd10627de745df0ebf8c495aba06b3f916a5b1cbc7799", + "size": 38245, + "subdir": "linux-64", + "timestamp": 1528907745747, + "version": "1.1.0" + }, + "sphinxcontrib-websupport-1.1.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "sphinxcontrib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "c3096d25d8722757cbb35a50eda17418", + "name": "sphinxcontrib-websupport", + "sha256": "0c721959e00ad65ec1e9eb0381a2ef3302a8325c4200d7005aa425bcedc1f747", + "size": 38635, + "subdir": "linux-64", + "timestamp": 1528907818130, + "version": "1.1.0" + }, + "sphinxcontrib-websupport-1.1.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "sphinxcontrib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "4deeef9c6ac74928a779c8e1c30ccbcc", + "name": "sphinxcontrib-websupport", + "sha256": "1262bbadad94878324f853782149f3358e0d82dde354419d09fa886887bb6d7b", + "size": 38368, + "subdir": "linux-64", + "timestamp": 1528907775813, + "version": "1.1.0" + }, + "sphinxcontrib-websupport-1.1.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "sphinxcontrib" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e9d1a3ad8ec1f4ea8c64a24f8b5ff65f", + "name": "sphinxcontrib-websupport", + "sha256": "3b793ed283d0d5e4e962be17c2b1b2585cceee005a10f7e4bc92ec1679b963a0", + "size": 37992, + "subdir": "linux-64", + "timestamp": 1530694880974, + "version": "1.1.0" + }, + "spirv-tools-2021.4-hd09550d_0.conda": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ff0120f92e49ea31ac1477aa6bb5f536", + "name": "spirv-tools", + "sha256": "c41052cb6deeda7134e9663d972e3e926066d57473f23409bb7bcba02dac1ee5", + "size": 230514150, + "subdir": "linux-64", + "timestamp": 1646152411371, + "version": "2021.4" + }, + "sputnik-0.9.3-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "semver" + ], + "license": "MIT", + "md5": "f1253b1909b683b81399ba9d803dd576", + "name": "sputnik", + "sha256": "56d5a1e9853a86979c9c88b24c2cace625427cdc9fe354dc1bcccf8f7fe0c4a5", + "size": 50106, + "subdir": "linux-64", + "timestamp": 1539186835641, + "version": "0.9.3" + }, + "sputnik-0.9.3-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0", + "semver" + ], + "license": "MIT", + "md5": "ea8413e8c00592446c0832b279fa2e37", + "name": "sputnik", + "sha256": "6db7117980878fb243d6b86a8afdf3dcb93e7d8002c37fcc7ad4105ad8f0e9d4", + "size": 51665, + "subdir": "linux-64", + "timestamp": 1640794851889, + "version": "0.9.3" + }, + "sputnik-0.9.3-py311h06a4308_2.conda": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0", + "semver" + ], + "license": "MIT", + "md5": "6b1c1faf9be653ac5cfc894784d1229d", + "name": "sputnik", + "sha256": "ed2affd38ebf6377176833135182d1edfc58e43744704b7227b832f4620b92c0", + "size": 71763, + "subdir": "linux-64", + "timestamp": 1676862730168, + "version": "0.9.3" + }, + "sputnik-0.9.3-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "semver" + ], + "license": "MIT", + "md5": "1a2d2263d399d39f52f09b6dc5806a9c", + "name": "sputnik", + "sha256": "f885c0f794e831ecc0af0125bf07d66719e8c45da92baacad9d73864e587feb5", + "size": 50669, + "subdir": "linux-64", + "timestamp": 1539186861257, + "version": "0.9.3" + }, + "sputnik-0.9.3-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "semver" + ], + "license": "MIT", + "md5": "de3beb91c012f1de9cc2fe3492cd2865", + "name": "sputnik", + "sha256": "1ed7f192542dbf558aa5b5c3c79f80d401da846313644d66c385219d9c9eefa2", + "size": 51816, + "subdir": "linux-64", + "timestamp": 1614266812147, + "version": "0.9.3" + }, + "sputnik-0.9.3-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "semver" + ], + "license": "MIT", + "md5": "0d99fd0e02457c0592b8bb69dda62d41", + "name": "sputnik", + "sha256": "19baceecbda9d07ab9ab5e5731b6e7c1bb78c89e39909dceee01084dfaac6bca", + "size": 51128, + "subdir": "linux-64", + "timestamp": 1539186860655, + "version": "0.9.3" + }, + "sputnik-0.9.3-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "semver" + ], + "license": "MIT", + "md5": "44da4c14e57e831e1d0fe53c1b08349f", + "name": "sputnik", + "sha256": "46ec54445ec80d146bd28f5ba75044178def0a188c1939043ae06de8b90e1c27", + "size": 52189, + "subdir": "linux-64", + "timestamp": 1614267828706, + "version": "0.9.3" + }, + "sputnik-0.9.3-py38_2.conda": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "semver" + ], + "license": "MIT", + "md5": "e1da9e20210b8392583376a92e0e8508", + "name": "sputnik", + "sha256": "1039156cb45e8fff3bc17a94a6560df4b1c790375576d43b315bbdfd946a8fa7", + "size": 51504, + "subdir": "linux-64", + "timestamp": 1573554600148, + "version": "0.9.3" + }, + "sputnik-0.9.3-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "semver" + ], + "license": "MIT", + "md5": "f04984796c2e5c7cd9b7fdbc3a8c46b4", + "name": "sputnik", + "sha256": "179490874c4ae40f20155e57aa4857b9239a57578106a5b7d5830233e1d6bd8d", + "size": 52554, + "subdir": "linux-64", + "timestamp": 1614267843291, + "version": "0.9.3" + }, + "sputnik-0.9.3-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0", + "semver" + ], + "license": "MIT", + "md5": "2799adaa43067b938262cf41b1674480", + "name": "sputnik", + "sha256": "40e1a66815324980cdc418b3b36fdd62f5dfbeb7f51da8dd1f696bc1a9c11bf6", + "size": 52434, + "subdir": "linux-64", + "timestamp": 1614267827159, + "version": "0.9.3" + }, + "spyder-3.2.3-py27hbf281d3_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27hbf281d3_1", + "build_number": 1, + "depends": [ + "chardet >=2.0", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.1", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "3a4bb2eac2c3637dd5471ce6da502163", + "name": "spyder", + "sha256": "c4d343ed873a97a5abe3fa30f715949707ab1fa33d5c50d2b4a5d38bdeda9c4d", + "size": 2131076, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1506299718174, + "type": "app", + "version": "3.2.3" + }, + "spyder-3.2.3-py35h49e6fe2_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py35h49e6fe2_1", + "build_number": 1, + "depends": [ + "chardet >=2.0", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.5,<3.6.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.1", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "b53040d3ef4df7cd6638a8a0dfed3f8a", + "name": "spyder", + "sha256": "ac02f76da24d211c69665db2a79acff9b424eacc5601a590dda5fd59261e024c", + "size": 2157172, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1506299075782, + "type": "app", + "version": "3.2.3" + }, + "spyder-3.2.3-py36he38cbf7_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36he38cbf7_1", + "build_number": 1, + "depends": [ + "chardet >=2.0", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.1", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "a60e7f76fa4c350fd3fcd9dfbd6b3e85", + "name": "spyder", + "sha256": "89e2f520bdbc6e6fea78d165a1df35b430eecf67134e29625ff483fa92ecaf05", + "size": 2129708, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1506299582729, + "type": "app", + "version": "3.2.3" + }, + "spyder-3.2.4-py27h04a3490_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27h04a3490_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "994c9d29949bf5014d091c63a0d8913f", + "name": "spyder", + "sha256": "f993caa554cc66a552a67a709591aa159f12b41b829bf97d9689835482d8d9aa", + "size": 2141843, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1508356637551, + "type": "app", + "version": "3.2.4" + }, + "spyder-3.2.4-py35h27cea69_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py35h27cea69_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.5,<3.6.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "81135d66d7ed8da8de211516c046c3b6", + "name": "spyder", + "sha256": "1a4d851083f3a732d8831603375ce9fbc72635d5c67913e7725ffa447b743266", + "size": 2145308, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1508356646689, + "type": "app", + "version": "3.2.4" + }, + "spyder-3.2.4-py36hbe6152b_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36hbe6152b_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "74656414fd338d72b3f295d1baacd50c", + "name": "spyder", + "sha256": "eb5269812035ff568fda96df10a35440262cd8ae261e147aef9149fc271168f9", + "size": 2142077, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1508356627088, + "type": "app", + "version": "3.2.4" + }, + "spyder-3.2.5-py27_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "92739b7cf8a59738fa093867cf5bdfa1", + "name": "spyder", + "sha256": "239fa434511b3a96e023fc63e45dab1e23d9ecc9b7232bfb308b1bea0310f7a4", + "size": 2153976, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1514270697514, + "type": "app", + "version": "3.2.5" + }, + "spyder-3.2.5-py35_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.5,<3.6.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "fdee22819cec2b7fe288db80561006b3", + "name": "spyder", + "sha256": "9bbcfed36ebd243c5b61141176161d67618798aa950115ddbafa652999264b82", + "size": 2168319, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1514270799100, + "type": "app", + "version": "3.2.5" + }, + "spyder-3.2.5-py36_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "a67fb31b4f0249d24878238f5144e45c", + "name": "spyder", + "sha256": "d8551ecaa17a54245269254111661a53fed30984a35087768c334021ec81a799", + "size": 2155576, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1514270799495, + "type": "app", + "version": "3.2.5" + }, + "spyder-3.2.6-py27_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "5657818ca7383f2fa7bc0904cff3fdeb", + "name": "spyder", + "sha256": "8c02319d76275d812120e173ad989a97a21136bf210c6181d7df884f649669c2", + "size": 2156665, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1515525227818, + "type": "app", + "version": "3.2.6" + }, + "spyder-3.2.6-py35_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.5,<3.6.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "cc33fe31cff36427b1c5ca9da6da4ac1", + "name": "spyder", + "sha256": "c5e51b0c82c250e8a14961859c077a4c0428b432ed2c53dcba7af7646e1c8ace", + "size": 2167775, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1515525268731, + "type": "app", + "version": "3.2.6" + }, + "spyder-3.2.6-py36_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "c91e8f2c857f67c4fb9ed122ca1dbee7", + "name": "spyder", + "sha256": "8dd15448c22f3d92a424d054253706a6ba30d81ee007a4e003ed430089e67d31", + "size": 2167146, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1515525272849, + "type": "app", + "version": "3.2.6" + }, + "spyder-3.2.7-py27_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "55e115b9d8b980de96f475d7105d6f02", + "name": "spyder", + "sha256": "8c74b1cf2d9f18e7089786df6f1eb82cf5696b1c3c254933cab28543e64d43c8", + "size": 2174627, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1519577319617, + "type": "app", + "version": "3.2.7" + }, + "spyder-3.2.7-py35_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.5,<3.6.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "f07c817eca96dfd889b74681fc9d8682", + "name": "spyder", + "sha256": "2bd9746a556d19e7f2bfe8ddcb7a5055d8f87c98ebe15d710d20e00b7206e051", + "size": 2187160, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1519577637971, + "type": "app", + "version": "3.2.7" + }, + "spyder-3.2.7-py36_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "50283aeb873e2f5de310182065582c4a", + "name": "spyder", + "sha256": "b788d79f4e995ad66d1e5965184481a2b7f7118920aa4186b9543ed2bbbd160b", + "size": 2181589, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1519577356080, + "type": "app", + "version": "3.2.7" + }, + "spyder-3.2.8-py27_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "9dcecdcccd9def19d7b21fc8b91ca6af", + "name": "spyder", + "sha256": "7b35f5ad38740735f5af9917e412f25403992af4d3cda1d66a84d7abc3bede2a", + "size": 2186292, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1521092320462, + "type": "app", + "version": "3.2.8" + }, + "spyder-3.2.8-py35_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py35_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.5,<3.6.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "10c244dd5e47fe8c6e2fccb9df45fc95", + "name": "spyder", + "sha256": "7eecff7d0cd257d79130c666395a08acd4d751e86cf5caa3c5322c06908bed91", + "size": 2210028, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1521092348389, + "type": "app", + "version": "3.2.8" + }, + "spyder-3.2.8-py36_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "f5291eefc5059c237062b0c90e0d52c9", + "name": "spyder", + "sha256": "8b720fa91ed51db4ac8b4b4dc697fa33e50241cd1a9153d29d8455ebdf5ad7a9", + "size": 2191981, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1521092348360, + "type": "app", + "version": "3.2.8" + }, + "spyder-3.3.0-py27_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx", + "spyder-kernels 0.*" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "9f30773ebd71f8c96c05bedfd548b1d6", + "name": "spyder", + "sha256": "8ac60737740b83bf25b0f08265cc113f8ff95197e94891d16198128552eddea7", + "size": 2174500, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1531232105067, + "type": "app", + "version": "3.3.0" + }, + "spyder-3.3.0-py36_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx", + "spyder-kernels 0.*" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "d8d5c3cbe3d34250fa6cb6f463345f84", + "name": "spyder", + "sha256": "41939cd4fdf75c1575d4abd2014da6d970dbe464d6af4922b9d375bf80b8b4d4", + "size": 2172662, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1531232259447, + "type": "app", + "version": "3.3.0" + }, + "spyder-3.3.0-py37_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.7,<3.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx", + "spyder-kernels 0.*" + ], + "icon": "9779607c273dc0786bd972b4cb308b58.png", + "license": "MIT", + "md5": "d4a79422928b98aefc08d8a1ce81ba01", + "name": "spyder", + "sha256": "30c1245747258e3aefafc6e0bdec1432c6e9ea51be2a906a37a8abd3acbb695d", + "size": 2172560, + "subdir": "linux-64", + "summary": "Scientific Python Development Environment", + "timestamp": 1531232183419, + "type": "app", + "version": "3.3.0" + }, + "spyder-3.3.1-py27_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_1", + "build_number": 1, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx", + "spyder-kernels 0.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "79e2e936357d86473ab041fb8283638e", + "name": "spyder", + "sha256": "8f5061827f432fdddf42d9ff5819d666aadbbfeb004a769696362370136cc5bf", + "size": 2173520, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1534262439012, + "type": "app", + "version": "3.3.1" + }, + "spyder-3.3.1-py35_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py35_1", + "build_number": 1, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.5,<3.6.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx", + "spyder-kernels 0.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "eef47ed4613ee62b48ca008d7ea5617a", + "name": "spyder", + "sha256": "fc6bc872eb949d8fcf94d705efe37b8be9f88ee8f051a066f668c7776874df88", + "size": 2193446, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1534262179565, + "type": "app", + "version": "3.3.1" + }, + "spyder-3.3.1-py36_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_1", + "build_number": 1, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx", + "spyder-kernels 0.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "fbae30dd78717073ba3dc4a4e688cff1", + "name": "spyder", + "sha256": "eaa91229384ce1ad43c4f46fe1c328fae786db29155547bc84419a6bcaa12c30", + "size": 2173977, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1534262128089, + "type": "app", + "version": "3.3.1" + }, + "spyder-3.3.1-py37_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_1", + "build_number": 1, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.7,<3.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.2.0", + "rope >=0.9.4", + "sphinx", + "spyder-kernels 0.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "fe2ab33721004278f4ce8157254124c8", + "name": "spyder", + "sha256": "41019eb5ce0dc61bc72476bb02ec36b3ae77874cd466047dd0a5c991812b87c0", + "size": 2178870, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1534263423275, + "type": "app", + "version": "3.3.1" + }, + "spyder-3.3.2-py27_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.1,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "111261d1913e4a7c2eeda7e4531046e7", + "name": "spyder", + "sha256": "1cf244cf651a3d739b5cba1e358cd66613431f688cdc0dcd08ea8bb97096363a", + "size": 2255878, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1543439615431, + "type": "app", + "version": "3.3.2" + }, + "spyder-3.3.2-py36_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.1,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "e78bd90e1dc3fd08c8147ec0ba1bfa1d", + "name": "spyder", + "sha256": "9cf1bed46b46bfd1b79b9f2b2ab41fb50c4a68b73f2c86e79d1367d5f219d4f2", + "size": 2256623, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1543439626393, + "type": "app", + "version": "3.3.2" + }, + "spyder-3.3.2-py37_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.7,<3.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.1,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "638fac4460b52a19394f222af0160b2c", + "name": "spyder", + "sha256": "748b9bda9c8e6e674d21513c79d7e5a8b173d652d98dd1951a62187ae7c659ac", + "size": 2258349, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1543439616720, + "type": "app", + "version": "3.3.2" + }, + "spyder-3.3.3-py27_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.4.2,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "5a21c4adb3ce8fce549aa6734fd6e23b", + "name": "spyder", + "sha256": "e7037ee454762cee5cc457be3e82cf6af4833677e192e05fc5b165cc744b3f4b", + "size": 2255446, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1549989068389, + "type": "app", + "version": "3.3.3" + }, + "spyder-3.3.3-py36_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.4.2,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "e18fcffc6a61bd82122241c75161aae1", + "name": "spyder", + "sha256": "93ed32b5f1ab28368eca1f7fa07a7d49be88d975e2f55d9e4ddaa137a8fcf8a8", + "size": 2258306, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1549989092972, + "type": "app", + "version": "3.3.3" + }, + "spyder-3.3.3-py37_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.7,<3.8.0a0", + "pyzmq", + "qtawesome >=0.4.1", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.4.2,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "a1e62f2228debac52e49888a0c94de78", + "name": "spyder", + "sha256": "6fcd1a51866185fd1941f78d28fbe24d46bf34c31e966d08909e147595423bb1", + "size": 2263637, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1549988991220, + "type": "app", + "version": "3.3.3" + }, + "spyder-3.3.4-py27_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.5.7", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.4.3,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "8d0534dca35be6d967dc3875f65b4b99", + "name": "spyder", + "sha256": "59866f70c12cb655efc51449e5c7dcacf5f5d501f4de8987311cc2579452b52f", + "size": 2260142, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1554942947258, + "type": "app", + "version": "3.3.4" + }, + "spyder-3.3.4-py36_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.5.7", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.4.3,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "6f339cb7250244bec0974a0ae63b6d36", + "name": "spyder", + "sha256": "baee88fb53b569cc007fc897d79f67ddc6e2dbb9b6dfc5b43cb7d002f64d4024", + "size": 2261813, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1554943056859, + "type": "app", + "version": "3.3.4" + }, + "spyder-3.3.4-py37_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.7,<3.8.0a0", + "pyzmq", + "qtawesome >=0.5.7", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.4.3,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "64aa4fa75ed1b042c5ffb05b2b624819", + "name": "spyder", + "sha256": "49dba5a2790827dc981b78945535222d4377c01684b512b07855bb43016735e3", + "size": 2259273, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1554943027516, + "type": "app", + "version": "3.3.4" + }, + "spyder-3.3.5-py27_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.5.7", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.5.0,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "e522711179a68beef280fbb85b2497e7", + "name": "spyder", + "sha256": "83717f68d7fcccec247bc45a5c89c805ea2a799f74da201969b7c1d7da686580", + "size": 2264355, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1562005078329, + "type": "app", + "version": "3.3.5" + }, + "spyder-3.3.5-py36_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.5.7", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.5.0,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "04ae3be803ff5ec1e194cf16f0e1d285", + "name": "spyder", + "sha256": "8a61cde95787d73aa7a0dae3af4287b0e15714f093a066a6ac0931849db2a8ce", + "size": 2261697, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1562005083339, + "type": "app", + "version": "3.3.5" + }, + "spyder-3.3.5-py37_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.7,<3.8.0a0", + "pyzmq", + "qtawesome >=0.5.7", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.5.0,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "9b931dc911e8c94bf42d3342fe877f78", + "name": "spyder", + "sha256": "49bcfcde71775e723b23b12048ccc826313537bc28498d3d54a988ca88433ce8", + "size": 2261599, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1562005074441, + "type": "app", + "version": "3.3.5" + }, + "spyder-3.3.6-py27_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=2.7,<2.8.0a0", + "pyzmq", + "qtawesome >=0.5.7", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.5.0,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "49cdf31ed6decb127e4f273f971257c1", + "name": "spyder", + "sha256": "fe51e67c5edd438f5ca31b447b2c1015c5e26804ebbf7b28c0cc5d34ba90ac44", + "size": 2266114, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1563210388380, + "type": "app", + "version": "3.3.6" + }, + "spyder-3.3.6-py36_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.6,<3.7.0a0", + "pyzmq", + "qtawesome >=0.5.7", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.5.0,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "4da1ebeb787e5b2d6e6aef910cc5628f", + "name": "spyder", + "sha256": "3a9dff9770973e144db27c8354dead39454e45cd019082a8271bde5466948dd1", + "size": 2275003, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1563210387948, + "type": "app", + "version": "3.3.6" + }, + "spyder-3.3.6-py37_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "chardet >=2.0", + "cloudpickle", + "jedi >=0.9", + "keyring", + "nbconvert", + "numpydoc", + "pickleshare", + "psutil", + "pycodestyle", + "pyflakes", + "pygments >=2.0", + "pylint", + "pyqt 5.*", + "python >=3.7,<3.8.0a0", + "pyzmq", + "qtawesome >=0.5.7", + "qtconsole >=4.2", + "qtpy >=1.5.0", + "rope >=0.10.5", + "sphinx", + "spyder-kernels >=0.5.0,<1" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "9eb4895e45a1ba16fd6af63f0cc67c70", + "name": "spyder", + "sha256": "dfb850c89e5c8177e5b15c3ef46f8c61de9f3f3d8564da6d09ceb8c7dc3a943d", + "size": 2261068, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1563210388380, + "type": "app", + "version": "3.3.6" + }, + "spyder-4.0.0-py27_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "chardet >=2.0.0", + "cloudpickle", + "diff-match-patch", + "intervaltree", + "jedi 0.14.1.*", + "nbconvert", + "numpydoc", + "pexpect", + "pickleshare", + "psutil >=5.2", + "pygments >=2.0", + "pylint", + "pympler", + "pyqt >=5.6,<5.13", + "python >=2.7,<2.8.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg", + "pyzmq", + "qdarkstyle >=2.7", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree", + "sphinx", + "spyder-kernels >=1.8.1,<1.9.0", + "watchdog", + "parso 0.5.2.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "b69a66ab268010e2932002431762d313", + "name": "spyder", + "sha256": "6931cb8005de47603f9eb1db62b2bffa71e959fda3bcd5718cd053eba32fe6c1", + "size": 5460620, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1575674837094, + "type": "app", + "version": "4.0.0" + }, + "spyder-4.0.0-py36_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "chardet >=2.0.0", + "cloudpickle", + "diff-match-patch", + "intervaltree", + "jedi 0.14.1.*", + "keyring", + "nbconvert", + "numpydoc", + "pexpect", + "pickleshare", + "psutil >=5.2", + "pygments >=2.0", + "pylint", + "pympler", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg", + "pyzmq", + "qdarkstyle >=2.7", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree", + "sphinx", + "spyder-kernels >=1.8.1,<1.9.0", + "watchdog", + "parso 0.5.2.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "774fb2d70a453f24e988e47f7a5dd672", + "name": "spyder", + "sha256": "3538155e69638e2afffec1df154076d7d0390b2733839d6c9b3718ebaebf56ac", + "size": 5474910, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1575674830756, + "type": "app", + "version": "4.0.0" + }, + "spyder-4.0.0-py37_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "chardet >=2.0.0", + "cloudpickle", + "diff-match-patch", + "intervaltree", + "jedi 0.14.1.*", + "keyring", + "nbconvert", + "numpydoc", + "pexpect", + "pickleshare", + "psutil >=5.2", + "pygments >=2.0", + "pylint", + "pympler", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg", + "pyzmq", + "qdarkstyle >=2.7", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree", + "sphinx", + "spyder-kernels >=1.8.1,<1.9.0", + "watchdog", + "parso 0.5.2.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "f7d00e860a9872ec99ef77333002b095", + "name": "spyder", + "sha256": "4062db7954a71209e864de9273f89a2a1ac629eac187848242664dc3dc87fad5", + "size": 5460390, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1575674830533, + "type": "app", + "version": "4.0.0" + }, + "spyder-4.0.1-py27_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py27_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "chardet >=2.0.0", + "cloudpickle", + "diff-match-patch", + "intervaltree", + "jedi 0.14.1.*", + "nbconvert", + "numpydoc", + "pexpect", + "pickleshare", + "psutil >=5.2", + "pygments >=2.0", + "pylint", + "pyqt >=5.6,<5.13", + "python >=2.7,<2.8.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg", + "pyzmq", + "qdarkstyle >=2.7", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree", + "sphinx", + "spyder-kernels >=1.8.1,<1.9.0", + "watchdog", + "parso 0.5.2.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "5b2dbc54aabd25c1bf4c0cf25061d2ae", + "name": "spyder", + "sha256": "389d645674b6d63ca522006b98d69d82754faf7adcc1054758ad8a3f44cd0a1a", + "size": 5466769, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1578414741184, + "type": "app", + "version": "4.0.1" + }, + "spyder-4.0.1-py36_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "chardet >=2.0.0", + "cloudpickle", + "diff-match-patch", + "intervaltree", + "jedi 0.14.1.*", + "keyring", + "nbconvert", + "numpydoc", + "pexpect", + "pickleshare", + "psutil >=5.2", + "pygments >=2.0", + "pylint", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg", + "pyzmq", + "qdarkstyle >=2.7", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree", + "sphinx", + "spyder-kernels >=1.8.1,<1.9.0", + "watchdog", + "parso 0.5.2.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "8c4b5f718bc04318464f538643cf04a9", + "name": "spyder", + "sha256": "e9ce95eab4aafd882e60e10acd20fc0b00e4d1add580cf76882e70298e1ca942", + "size": 5465598, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1578414750144, + "type": "app", + "version": "4.0.1" + }, + "spyder-4.0.1-py37_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "chardet >=2.0.0", + "cloudpickle", + "diff-match-patch", + "intervaltree", + "jedi 0.14.1.*", + "keyring", + "nbconvert", + "numpydoc", + "pexpect", + "pickleshare", + "psutil >=5.2", + "pygments >=2.0", + "pylint", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg", + "pyzmq", + "qdarkstyle >=2.7", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree", + "sphinx", + "spyder-kernels >=1.8.1,<1.9.0", + "watchdog", + "parso 0.5.2.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "14957993cea3d51bd35eb7ecab9415ab", + "name": "spyder", + "sha256": "0f121d51567f4ab4253cc3a5efa82d8ee3a59ccf18f61eaa2ce8a3a126f42df2", + "size": 5470082, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1578414735139, + "type": "app", + "version": "4.0.1" + }, + "spyder-4.0.1-py38_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38_0", + "build_number": 0, + "depends": [ + "atomicwrites", + "chardet >=2.0.0", + "cloudpickle", + "diff-match-patch", + "intervaltree", + "jedi 0.14.1.*", + "keyring", + "nbconvert", + "numpydoc", + "pexpect", + "pickleshare", + "psutil >=5.2", + "pygments >=2.0", + "pylint", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg", + "pyzmq", + "qdarkstyle >=2.7", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree", + "sphinx", + "spyder-kernels >=1.8.1,<1.9.0", + "watchdog", + "parso 0.5.2.*" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "23b2cc5e5c2c21b45a965abf23e7affe", + "name": "spyder", + "sha256": "dccd54adb4f670532a5eb40a9f3cea98140fda4de6c9c0ec379eea2c0701f366", + "size": 5485287, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1580252845906, + "type": "app", + "version": "4.0.1" + }, + "spyder-4.1.0-py36_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.14.1.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.0,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "029f8697d42b68b67e6c510a1571348d", + "name": "spyder", + "sha256": "c849381161df8995ac17456efd41d33731c48c07aaf8b1a74893021b4520ef25", + "size": 5419874, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1584458108654, + "type": "app", + "version": "4.1.0" + }, + "spyder-4.1.0-py37_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.14.1.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.0,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "1e79df02e5b8dbe9240c9896db7d7b1d", + "name": "spyder", + "sha256": "6159b7fd09fe6905cce5dcb99f9f405c3bee45a191f0498a9e7e92835cb97af9", + "size": 5407830, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1584458076090, + "type": "app", + "version": "4.1.0" + }, + "spyder-4.1.0-py38_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.14.1.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.31.2,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.0,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "196aedb7868e832d795b4052e0366a6e", + "name": "spyder", + "sha256": "17be03e05239a74758befdbd53523b2f6f5ad87ef14e947112714b82f74c489e", + "size": 5437579, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1584458194336, + "type": "app", + "version": "4.1.0" + }, + "spyder-4.1.1-py36_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.15.2.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.31.9,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.0,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "79f007f9cf84da50a3e61851eda7cc47", + "name": "spyder", + "sha256": "c01bf29f28f1322c34b50806d0e630f61255147d3e310feaf42f540d39b62482", + "size": 5814688, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1584645138428, + "type": "app", + "version": "4.1.1" + }, + "spyder-4.1.1-py37_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.15.2.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.31.9,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.0,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "b795fc45a1eaa043abaf604be47c39fb", + "name": "spyder", + "sha256": "ecae8b49f402b053735b71b9398ee4e450915d2f5f9c368455270d5b8bf9a411", + "size": 5794977, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1584645156179, + "type": "app", + "version": "4.1.1" + }, + "spyder-4.1.1-py38_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.15.2.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.31.9,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.0,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "88c9e6e797e2b142655f2502d4d6ac69", + "name": "spyder", + "sha256": "4fcbc273bb394ec87998fd8cdfec6fd5f37c4dccee264bb4e9d93854d6221b8a", + "size": 5812026, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1584645155863, + "type": "app", + "version": "4.1.1" + }, + "spyder-4.1.2-py36_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.15.2.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.31.9,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.0,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "bfbb0dce13f5c699392dfe0fc2e1fd98", + "name": "spyder", + "sha256": "ba3a5e6458fc9da15b82d6116ded1c77eb2cf74e04875601104c546733fbfc4f", + "size": 5815200, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1586199074528, + "type": "app", + "version": "4.1.2" + }, + "spyder-4.1.2-py37_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.15.2.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.31.9,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.0,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "6a705805d892adeeed1a6a0b33702276", + "name": "spyder", + "sha256": "42b9b4d8fddd683e0821f17007befea3ce915a33ead80a88afa6b85c6f40b5fb", + "size": 5806608, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1586199059789, + "type": "app", + "version": "4.1.2" + }, + "spyder-4.1.2-py38_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.15.2.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.31.9,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.0,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "0943fdbd7408dfe93a3b134f5b8cc5c9", + "name": "spyder", + "sha256": "601d9d9491d3e51d5157652bb24d1094c8e70e60d982229b87e2fc5fe56e6ac4", + "size": 5824062, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1586199086537, + "type": "app", + "version": "4.1.2" + }, + "spyder-4.1.3-py36_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.15.2.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.31.9,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.1,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "cc8c003b2ef4469818cc52206efaa26c", + "name": "spyder", + "sha256": "978c0cbac9a305e009e51920a565a0c5b385dc61641772b369024f84e60753c7", + "size": 5842176, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1589207380819, + "type": "app", + "version": "4.1.3" + }, + "spyder-4.1.3-py37_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.15.2.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.31.9,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.1,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "a8dde7be4ee95461ce83fbd52ffa7e9c", + "name": "spyder", + "sha256": "9c702eb0f45e0b0494a751a24ae25b261d4f57f228c70ee56d555f3247ad0535", + "size": 5847030, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1589207374647, + "type": "app", + "version": "4.1.3" + }, + "spyder-4.1.3-py38_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.15.2.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.5.2.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=0.25", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.31.9,<0.32.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.1,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "0b203bf6cb48324c91533c080635379a", + "name": "spyder", + "sha256": "f64758a6356a1f97b36a656f8d718eccba2563d70fd03fa86788d0eca63913dc", + "size": 5850372, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1589207402892, + "type": "app", + "version": "4.1.3" + }, + "spyder-4.1.4-py36_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.17.1.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.34.0,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.2,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "4a0b3ddbed0c2e914b87e48bb110dc0a", + "name": "spyder", + "sha256": "fbc5d04f0ba42d8b90f688d26709d690d4ee3a26ff97666e04e2c3a461c4c8e2", + "size": 5893506, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1594830433349, + "type": "app", + "version": "4.1.4" + }, + "spyder-4.1.4-py37_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.17.1.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.34.0,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.2,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "2923862a6cfc8193c37e3aa644eb1b37", + "name": "spyder", + "sha256": "22052144d9bcb1381aff0d6497a5ca5dba9a8df749097568e234cdc623ebe0b7", + "size": 5887337, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1594830433634, + "type": "app", + "version": "4.1.4" + }, + "spyder-4.1.4-py38_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.17.1.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.34.0,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.2,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "e88ce562ff0db9affed80b5c834c6892", + "name": "spyder", + "sha256": "14fa3c3ab55da9855e1aa16cafcadba7fc5090f2b2be37b4bd6017b3491ac35a", + "size": 5896052, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1594832175527, + "type": "app", + "version": "4.1.4" + }, + "spyder-4.1.5-py36_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.17.1.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.34.0,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.4,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "ddc80088c771d9dd0377c463af0f5752", + "name": "spyder", + "sha256": "6f44610f22e798cdf85d55bad90f645fb64b7fad53f13722190f23c0a68a7338", + "size": 5894280, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1599057070363, + "type": "app", + "version": "4.1.5" + }, + "spyder-4.1.5-py37_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.17.1.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.34.0,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.4,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "12f3822f848cfba6ddd325ef97647a5d", + "name": "spyder", + "sha256": "ef8d32cf6e94d8722da1aac4325ad2914298b8cfebc70b4a33c07f588cebf984", + "size": 5884191, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1599057043183, + "type": "app", + "version": "4.1.5" + }, + "spyder-4.1.5-py38_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree", + "jedi 0.17.1.*", + "keyring", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.34.0,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.6.0", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "sphinx >=0.6.6", + "spyder-kernels >=1.9.4,<1.10.0", + "watchdog" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "59e3e216115bdaa2b6afb8ec7c5c23fb", + "name": "spyder", + "sha256": "38cd7b5af22c34e8e8fbffc28e592d3a94c0e2abdb25dcef5f845505f0d9a84c", + "size": 5904265, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1599057039903, + "type": "app", + "version": "4.1.5" + }, + "spyder-4.2.0-py36h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.1.1", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.1,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.7.7", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.0,<1.11.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "a13eb274435505899f807811ea48480f", + "name": "spyder", + "sha256": "e5c6968010d33cae22b5a2e3f3feb80064dab75a4ede9fd8bca9235df92c0e78", + "size": 5955619, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1607704323990, + "type": "app", + "version": "4.2.0" + }, + "spyder-4.2.0-py37h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.1.1", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.1,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.7.7", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.0,<1.11.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "b1f30fcb034e8bcc903c5f64794f0f6a", + "name": "spyder", + "sha256": "ffe9ddb81e89af785c4293e521ea46bc075c39ab228e717d69bf28c14e9432af", + "size": 5936977, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1607701283274, + "type": "app", + "version": "4.2.0" + }, + "spyder-4.2.0-py38h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.1.1", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.1,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.7.7", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.0,<1.11.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "8cea97043d6d5a1b91246c577e2b2715", + "name": "spyder", + "sha256": "131f879e0f0f48435f933b5a6530259e51d3f34d34e5af2af45060a95b07f196", + "size": 5942386, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1607704323071, + "type": "app", + "version": "4.2.0" + }, + "spyder-4.2.0-py39h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.1.1", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.1,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.7.7", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.0,<1.11.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "f0be5bd538664ccc71b60380344fabcc", + "name": "spyder", + "sha256": "2996e504abe46d357f4337d3eabe908f44455a41bd73b432005730a41bb139cd", + "size": 5957945, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1607982209159, + "type": "app", + "version": "4.2.0" + }, + "spyder-4.2.1-py36h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.1.1", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.1,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.7.7", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.0,<1.11.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "074eb94d7e22b1f64107c482ac8e8183", + "name": "spyder", + "sha256": "05bbe50deda315429f7e702f03dd36dca4ebab561e49fb8be91c5e3dbfea809f", + "size": 5975280, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1612320411495, + "type": "app", + "version": "4.2.1" + }, + "spyder-4.2.1-py36h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.0", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=5.0.1", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.1,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "387f39b6f2f988abd4f4ca4eeeca94fe", + "name": "spyder", + "sha256": "b39a5dc493ff28681db256e42b12c83cabf8baa97dfbdb729cb77f7ccc7358c8", + "size": 5959860, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1612463449415, + "type": "app", + "version": "4.2.1" + }, + "spyder-4.2.1-py37h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.1.1", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.1,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.7.7", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.0,<1.11.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "3595999b61e3c4fefd1c1a85defbc936", + "name": "spyder", + "sha256": "329c495dc38a00ee3e2859c4b8b24c39df56b08ff3db97ada4f635db7dc046d7", + "size": 5943862, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1612318777698, + "type": "app", + "version": "4.2.1" + }, + "spyder-4.2.1-py37h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.0", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=5.0.1", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.1,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "24d06ce7df25017bfe4a72b6e44be566", + "name": "spyder", + "sha256": "561ec999ac142eed59e53ee546c223399f48e9f66ddbf3a327462d760fd6df5c", + "size": 5965620, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1612463538427, + "type": "app", + "version": "4.2.1" + }, + "spyder-4.2.1-py38h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.1.1", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.1,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.7.7", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.0,<1.11.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "b121aa5c9eb0096e352be354857e73cc", + "name": "spyder", + "sha256": "ec42f529b4d296c4ef9fad094ed1e2400c6f8c2d37d8328688f54cf6df8f6c8c", + "size": 5981412, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1612318776121, + "type": "app", + "version": "4.2.1" + }, + "spyder-4.2.1-py38h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.0", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=5.0.1", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.1,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "06f58906a7c6f0deb449e625f36e3a11", + "name": "spyder", + "sha256": "fc83e6fe74fa9cbbf0113a1f9c0f66786e6e87fef0f6b3739c343a83924eeaad", + "size": 5969581, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1612462791035, + "type": "app", + "version": "4.2.1" + }, + "spyder-4.2.1-py39h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.1.1", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.1,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=4.7.7", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.0,<1.11.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "91df28ce0f5e36347dc845a8abe2f8aa", + "name": "spyder", + "sha256": "e61701339fbfb69de748e639bbe804debe85ce56fbba1505d811088788a415a0", + "size": 5973329, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1612320676723, + "type": "app", + "version": "4.2.1" + }, + "spyder-4.2.1-py39h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.0", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=5.0.1", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.1,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "dcacbd21e8157a4e1f8aee54bbee0bda", + "name": "spyder", + "sha256": "ecb97c157abeebc2f6773bf93c79dfcc24782c0fc5eadaef22773848e43f8114", + "size": 5994143, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1612463543652, + "type": "app", + "version": "4.2.1" + }, + "spyder-4.2.3-py36h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=5.0.1", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "c84c6b8b07811037deed114ca0b03fb0", + "name": "spyder", + "sha256": "8ee07914af0786ed509b18c86c3b9448db9fce0e57479adf08bf0ac759737c8b", + "size": 5654659, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1615366389673, + "type": "app", + "version": "4.2.3" + }, + "spyder-4.2.3-py37h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=5.0.1", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "aa2ec86d5efc2b35eb6f6f8b9befa3a2", + "name": "spyder", + "sha256": "5d1a7f650f349b97fdc2368484b083ba7b7132cc3eabd417fa8c1da7a0dcf183", + "size": 5664106, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1615366395453, + "type": "app", + "version": "4.2.3" + }, + "spyder-4.2.3-py38h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=5.0.1", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "1b378ab8601909aca6189b1a20eea327", + "name": "spyder", + "sha256": "0c5b54916b7d334fb48c630d5890e7e143ee3a47dcd13078e4a8d131660d76b2", + "size": 5669605, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1615366387511, + "type": "app", + "version": "4.2.3" + }, + "spyder-4.2.3-py39h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8", + "qtawesome >=0.5.7", + "qtconsole >=5.0.1", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "013c01802374368ff19da22638fd40e1", + "name": "spyder", + "sha256": "a75ea18a7285e64b0b2e05cd4c4625ae86965bbf852e39216d97a9c7c6e97be4", + "size": 5661677, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1615366288552, + "type": "app", + "version": "4.2.3" + }, + "spyder-4.2.4-py36h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8,<3.0", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "5abba60a33d9c57a05e61f073bae3ee1", + "name": "spyder", + "sha256": "e9a05337e35be60b7645a860c7c9dd77376408d8010f03109b799e98546f34ad", + "size": 5663444, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1616685585973, + "type": "app", + "version": "4.2.4" + }, + "spyder-4.2.4-py37h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8,<3.0", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "a2a63a19a16b9d5a19c8cb4a134e6c8a", + "name": "spyder", + "sha256": "4f9719ec43b242b4deeb52e97cc9b26f7e2c2475e4d9bb3445c9a27fee0fc0a5", + "size": 5677198, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1616685571651, + "type": "app", + "version": "4.2.4" + }, + "spyder-4.2.4-py38h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8,<3.0", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "9d1d4c7111878e9e158974275f61349b", + "name": "spyder", + "sha256": "55ace8d07cbdc1448cfe76442ffad010ed8e8ac49338c88a3a121e2bba5ad1e1", + "size": 5686037, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1616685590804, + "type": "app", + "version": "4.2.4" + }, + "spyder-4.2.4-py39h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8,<3.0", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "7788387e2c40e6ab43b4da65e23a7e38", + "name": "spyder", + "sha256": "f9bf6de9a8674cbdceb0e580d50291d8cbdca275aec6f0f273799bb71391a1d1", + "size": 5681640, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1616685598782, + "type": "app", + "version": "4.2.4" + }, + "spyder-4.2.5-py36h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8,<3.0", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "8e8899c71cc830661d993466e1a44b08", + "name": "spyder", + "sha256": "42d30241e92919672b835cdc21aa68b9a9400162ba9af036b065acbf869f7a4b", + "size": 5673442, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1616775687184, + "type": "app", + "version": "4.2.5" + }, + "spyder-4.2.5-py37h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8,<3.0", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "e0ba237ba83186e63db77b9699cc0e64", + "name": "spyder", + "sha256": "410ecc4f6be5813df410109892656ca131805ce32f8e5f214d1b3d6b0a6a9f5c", + "size": 5679541, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1616775672556, + "type": "app", + "version": "4.2.5" + }, + "spyder-4.2.5-py38h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8,<3.0", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "0ad8ab9bf26a3f828c07c0d2df842ca4", + "name": "spyder", + "sha256": "88838a80332776cd7f99b6ed415e487a8c910c5ddda40bae2cbc67d99913e145", + "size": 5683939, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1616775673972, + "type": "app", + "version": "4.2.5" + }, + "spyder-4.2.5-py39h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle >=2.8,<3.0", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=1.10.2,<1.11.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "09b61960272870f1bd51bb70adffbc39", + "name": "spyder", + "sha256": "547e8d91bf9c841f9db23cb49674b30e8d01bf0953154e68407594b535d7d33d", + "size": 5672328, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1616775667679, + "type": "app", + "version": "4.2.5" + }, + "spyder-5.0.0-py36h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.1,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "9852fe8499141088803c4b71f3933fad", + "name": "spyder", + "sha256": "0e70599202eaa01cb73e44853893c811b1f9371c68baeceaa3c7f828f7ac295a", + "size": 5757631, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1617483447153, + "type": "app", + "version": "5.0.0" + }, + "spyder-5.0.0-py36h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qstylizer >=0.1.10", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.1,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "1eacb38d8459d3e77dcd483173ad210b", + "name": "spyder", + "sha256": "f37537ace8a4f5c0039a2d28824410a81281ddeb3c9fbf74cc505dde07ca97c5", + "size": 5780680, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1618327956831, + "type": "app", + "version": "5.0.0" + }, + "spyder-5.0.0-py37h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.1,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "ea8a3ab898ce10628283bdd40cdd6732", + "name": "spyder", + "sha256": "df8198919238fb7f15e9162bdbe5099bb1c14cdad8b86db1e3ce0fc1ba0f15df", + "size": 5781026, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1617483443393, + "type": "app", + "version": "5.0.0" + }, + "spyder-5.0.0-py37h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qstylizer >=0.1.10", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.1,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "9578054db71ad1e8b622477fc1c41d19", + "name": "spyder", + "sha256": "34bb6bbecf690ecec65e3b6ba9b287fa6eb23f27ec3494b99bf8d290188e0a41", + "size": 5788970, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1618327954061, + "type": "app", + "version": "5.0.0" + }, + "spyder-5.0.0-py38h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.1,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "db768aabbce716341374589d4f1e3e2e", + "name": "spyder", + "sha256": "1fcaf23d3ccc9e7f08fa6416674737ebd9f43d98a149cebb661221f55ca36a79", + "size": 5777096, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1617483445359, + "type": "app", + "version": "5.0.0" + }, + "spyder-5.0.0-py38h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qstylizer >=0.1.10", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.1,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "9a2b8e95e4d4464d1b1396305310d73a", + "name": "spyder", + "sha256": "ef3e106d014066015eff217c17418831b72089ffbd45a9508ae6350fdf6130bb", + "size": 5794857, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1618327968816, + "type": "app", + "version": "5.0.0" + }, + "spyder-5.0.0-py39h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.1,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "23142dbf60c3a42a670ac7248cbe6a79", + "name": "spyder", + "sha256": "c2acda46d7b862a64e124873781600d3ed4300c0f36305f3dd78db0605e25a76", + "size": 5769157, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1617483239029, + "type": "app", + "version": "5.0.0" + }, + "spyder-5.0.0-py39h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qstylizer >=0.1.10", + "qtawesome >=0.5.7", + "qtconsole >=5.0.3", + "qtpy >=1.5.0", + "rtree >=0.8.3", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.1,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "8623a1cdaa28a5d6fdf24f138f6c7d28", + "name": "spyder", + "sha256": "9c68d5700a76beca844027ca22580dbb311c4c8b4887aceec8804d437c278e26", + "size": 5804403, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1618327905070, + "type": "app", + "version": "5.0.0" + }, + "spyder-5.0.3-py36h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2,<0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.3,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "2129d8f7c1f7a8d87649d32e46d98488", + "name": "spyder", + "sha256": "59bcb58238dc230f078408fa64eff2b22b79fea3a0456a728de6791fae7b434f", + "size": 5795075, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1623423654728, + "type": "app", + "version": "5.0.3" + }, + "spyder-5.0.3-py37h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2,<0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.3,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "a4b0399d8010927c02794cf92e37aac7", + "name": "spyder", + "sha256": "8a07f5f040ba89de669b6fdd60ca504ee12e2c88f66c8a96fc6cbe6b8bc13ec0", + "size": 5809916, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1623423657737, + "type": "app", + "version": "5.0.3" + }, + "spyder-5.0.3-py38h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2,<0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.3,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "47c50ae80eca8b55d5ca269835eb65ce", + "name": "spyder", + "sha256": "544506a30ceb4e4f659352fb30f76e5ef97ce350e986f5e5534bfb38a0b2d1e3", + "size": 5799830, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1623417988855, + "type": "app", + "version": "5.0.3" + }, + "spyder-5.0.3-py39h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2,<0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.3,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3,<2.0.0" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "md5": "260a25a0e4105d7340b083bd8111e8e0", + "name": "spyder", + "sha256": "ae604896a98c88cb9a585fdcb742f0514ba430661fec7efea2ffb6b8d4d4c841", + "size": 5800165, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1623423651392, + "type": "app", + "version": "5.0.3" + }, + "spyder-5.0.5-py36h06a4308_2.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2,<0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.6,<3.7.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.4,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "e6ea7463a45432543a2da4e4f24b5539", + "name": "spyder", + "sha256": "cd3106207365c62cddad37e1033b71a1d7c0708172f6cd7e02e25397d4a439f4", + "size": 5802005, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1626175111452, + "type": "app", + "version": "5.0.5" + }, + "spyder-5.0.5-py37h06a4308_2.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2,<0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.4,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "b1ae110ff09b54dabfeb8b3e96422cc4", + "name": "spyder", + "sha256": "e5e52fc2a8df49972f92bd1509b4f0dbcc96fc2b703e0a31c110bd6b9f677d74", + "size": 5800140, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1626182119397, + "type": "app", + "version": "5.0.5" + }, + "spyder-5.0.5-py38h06a4308_2.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2,<0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.4,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "83dfb5ab8b5a9d8ca781253dcd350138", + "name": "spyder", + "sha256": "28835d7f087b3fbaa70c78d47dd9926bdfacfaae9a5fb785dd7aa4be7477e42f", + "size": 5789310, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1626182115082, + "type": "app", + "version": "5.0.5" + }, + "spyder-5.0.5-py39h06a4308_2.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi 0.17.2.*", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso 0.7.0.*", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=1.0", + "pyls-black >=0.4.6", + "pyls-spyder >=0.3.2,<0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-language-server >=0.36.2,<1.0.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=39.0.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.0.4,<2.1.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "d1d745afe38b6a5189f6d4b197daefb5", + "name": "spyder", + "sha256": "c2650477dbc69766ab58610282c37324e12b20264b39da21557054ae3a96ae5b", + "size": 5796733, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1625814753091, + "type": "app", + "version": "5.0.5" + }, + "spyder-5.1.5-py310h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi >=0.17.2,<0.19.0", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<2.10.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.10,<3.11.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.2.2,<1.3.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.1.1,<2.2.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "1af80b63ffe91e93ca4234350cd767cc", + "name": "spyder", + "sha256": "b78bc1e1aaed88199e269f872490a4ee18559078d21e04e54d3eeb5c183c72b8", + "size": 9806967, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1642522017263, + "type": "app", + "version": "5.1.5" + }, + "spyder-5.1.5-py37h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi >=0.17.2,<0.19.0", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<2.10.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.2.2,<1.3.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.1.1,<2.2.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "6acf5af2cae7d72ea321dc53bd6b368b", + "name": "spyder", + "sha256": "d0594bc3e41e5240eff9ab4ca1ef65c6b8c9f4837e1f7f7768300ed3c61be50c", + "size": 9785031, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1634576236783, + "type": "app", + "version": "5.1.5" + }, + "spyder-5.1.5-py37h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi >=0.17.2,<0.19.0", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<2.10.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.7,<3.8.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.2.2,<1.3.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.1.1,<2.2.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "6d883855b24ca21060ed1c176a7ff7e1", + "name": "spyder", + "sha256": "7cc11633d7ad64fc59eabc82434741459f03dd91d7244b274c4ffd7382e16450", + "size": 9806501, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1636480287535, + "type": "app", + "version": "5.1.5" + }, + "spyder-5.1.5-py38h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi >=0.17.2,<0.19.0", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<2.10.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.2.2,<1.3.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.1.1,<2.2.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "aff0727b6d9424d3e51e801b89de75ff", + "name": "spyder", + "sha256": "cfaea2e3fd29d209a7999d4e41ddce52c31473748788f98814e7f7a5d096a627", + "size": 9800626, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1634576238602, + "type": "app", + "version": "5.1.5" + }, + "spyder-5.1.5-py38h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi >=0.17.2,<0.19.0", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<2.10.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.8,<3.9.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.2.2,<1.3.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.1.1,<2.2.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "b84db3fd76795de5426a51ca4c80ed59", + "name": "spyder", + "sha256": "6fb9115cfedcd9b2797e3f6d5d72f170580f470c6b6d58c1fe5ee5c6b1505893", + "size": 9795530, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1636480282533, + "type": "app", + "version": "5.1.5" + }, + "spyder-5.1.5-py39h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi >=0.17.2,<0.19.0", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<2.10.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.2.2,<1.3.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.1.1,<2.2.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "a37e0a8e05dff83d34da2f86a3db6117", + "name": "spyder", + "sha256": "9b281065bbda67ea67b4494840a41ac29f8f2f6531e394bfb4fe0d2e4973dc41", + "size": 9786144, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1634576234190, + "type": "app", + "version": "5.1.5" + }, + "spyder-5.1.5-py39h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0", + "jedi >=0.17.2,<0.19.0", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<2.10.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.13", + "python >=3.9,<3.10.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.2.2,<1.3.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.1.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.1.1,<2.2.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "352a2b68f921cf3bd26fd3c530845cb8", + "name": "spyder", + "sha256": "52684c7b8ce4701f403477ef279d3fdb09e97dc149e9f2e006b363a0e370e228", + "size": 9808386, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1636479915366, + "type": "app", + "version": "5.1.5" + }, + "spyder-5.2.2-py310h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py310h06a4308_1", + "build_number": 1, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0,<8.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6", + "python >=3.10,<3.11.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.3.2,<1.4.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.2.1,<5.3.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.2.1,<2.3.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "3cb3e2b944eb94d2fb6aafd748c20421", + "name": "spyder", + "sha256": "8309e6aa6f8f5e6310c10546c1681bf3fed64092db3cfff92fec4be1cc977c46", + "size": 9837655, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1659599927494, + "type": "app", + "version": "5.2.2" + }, + "spyder-5.2.2-py37h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0,<8.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6", + "python >=3.7,<3.8.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.3.2,<1.4.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.2.1,<5.3.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.2.1,<2.3.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "b424e65152d1b1a51de069173cae16ed", + "name": "spyder", + "sha256": "54a103156589598ac41d0054099df5493f662a63715c07004c060dad806fc3dc", + "size": 9816179, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1659599990592, + "type": "app", + "version": "5.2.2" + }, + "spyder-5.2.2-py38h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0,<8.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6", + "python >=3.8,<3.9.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.3.2,<1.4.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.2.1,<5.3.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.2.1,<2.3.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "d0f53d2dd7aa701d65f9d33a90c7fba7", + "name": "spyder", + "sha256": "dea47ab1d715cb214ee1c74d1d49e31b9d003b28f358ac868f59ae92ab96dc25", + "size": 9824843, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1659599847025, + "type": "app", + "version": "5.2.2" + }, + "spyder-5.2.2-py39h06a4308_1.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.6.0,<8.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6", + "python >=3.9,<3.10.0a0", + "python-lsp-black >=1.0.0", + "python-lsp-server >=1.3.2,<1.4.0", + "pyxdg >=0.26", + "pyzmq >=17", + "qdarkstyle 3.0.2.*", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.2.1,<5.3.0", + "qtpy >=1.5.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.2.1,<2.3.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "ff5ed611adac835b00c644b31c766c32", + "name": "spyder", + "sha256": "dd7a71c08542718ff058edc9d098cba9d88da4fd63b510dabb3e467bfc1d8b19", + "size": 9825694, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1659600053485, + "type": "app", + "version": "5.2.2" + }, + "spyder-5.3.3-py310h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<8.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine >=5.15,<5.16", + "python >=3.10,<3.11.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.5.0,<1.6.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.3.2,<5.4.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.3.3,<2.4.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "019f79a6ca95f4a0c972914a2aee3253", + "name": "spyder", + "sha256": "67052fa3917ab9371db9680a464bb849231ac2879192b357b53b3d5022b90399", + "size": 9856811, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1663056975846, + "type": "app", + "version": "5.3.3" + }, + "spyder-5.3.3-py37h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "importlib-metadata <4.3", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<8.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine >=5.15,<5.16", + "python >=3.7,<3.8.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.5.0,<1.6.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.3.2,<5.4.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.3.3,<2.4.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "a1aff3108f83903fb903c85cc0201dae", + "name": "spyder", + "sha256": "89efd4898d7731fc282b67cb9518695498d650ae08d5192028fb491b5cdec2ac", + "size": 9829949, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1663057119750, + "type": "app", + "version": "5.3.3" + }, + "spyder-5.3.3-py38h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<8.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine >=5.15,<5.16", + "python >=3.8,<3.9.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.5.0,<1.6.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.3.2,<5.4.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.3.3,<2.4.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "a032fbde52a545efa498c07416574642", + "name": "spyder", + "sha256": "082bfbf36472d9381be8bcbb7b3ca7e0a11de7c6b0d5d69078f0364f46d1e07b", + "size": 9836500, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1663056885637, + "type": "app", + "version": "5.3.3" + }, + "spyder-5.3.3-py39h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<8.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine >=5.15,<5.16", + "python >=3.9,<3.10.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.5.0,<1.6.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.1.10", + "qtawesome >=1.0.2", + "qtconsole >=5.3.2,<5.4.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.3.3,<2.4.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "e5b918ebae5d13719fd138300f3e9450", + "name": "spyder", + "sha256": "1c1a4db01e9642163e01b07ace1912d232db0853e3fb57a67b86dd009d0365e1", + "size": 9844342, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1663057047137, + "type": "app", + "version": "5.3.3" + }, + "spyder-5.4.1-py310h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<9.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pylint-venv >=2.1.1", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine <5.16", + "python >=3.10,<3.11.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.7.0,<1.8.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.2.2", + "qtawesome >=1.2.1", + "qtconsole >=5.4.0,<5.5.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.4.1,<2.5.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "8d6e2b75c9a7524cb62226f7328f9cd4", + "name": "spyder", + "sha256": "db30fa0673eeb43a7e5b69f3b347ea05f510b9b97a5e365c9eb9566598d01a38", + "size": 10905327, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1677776327978, + "type": "app", + "version": "5.4.1" + }, + "spyder-5.4.1-py311h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<9.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pylint-venv >=2.1.1", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine <5.16", + "python >=3.11,<3.12.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.7.0,<1.8.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.2.2", + "qtawesome >=1.2.1", + "qtconsole >=5.4.0,<5.5.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.4.1,<2.5.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "69f3a26856b58f88076ff0d9d16d62bb", + "name": "spyder", + "sha256": "9e52f318fc008f4089daef74cbac86bc67e75301d2f6ddc3c0e33b70549dfa13", + "size": 10769859, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1677707166789, + "type": "app", + "version": "5.4.1" + }, + "spyder-5.4.1-py38h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<9.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pylint-venv >=2.1.1", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine <5.16", + "python >=3.8,<3.9.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.7.0,<1.8.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.2.2", + "qtawesome >=1.2.1", + "qtconsole >=5.4.0,<5.5.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.4.1,<2.5.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "0fada7f86e324361d1dbbc461d4106b3", + "name": "spyder", + "sha256": "99dec404e3fd718c560fccddeb1ab080283f3196ecf8259387aa95ba19a20e7b", + "size": 10888042, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1677776253408, + "type": "app", + "version": "5.4.1" + }, + "spyder-5.4.1-py39h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<9.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pylint-venv >=2.1.1", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine <5.16", + "python >=3.9,<3.10.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.7.0,<1.8.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.2.2", + "qtawesome >=1.2.1", + "qtconsole >=5.4.0,<5.5.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.4.1,<2.5.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "b78cab4f3dbf9796d4acb28adf194842", + "name": "spyder", + "sha256": "32207c773a7f9a500af46e5020b36144cbdecc6fb5ea4c7c8416b89494806f6b", + "size": 10874231, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1677776170919, + "type": "app", + "version": "5.4.1" + }, + "spyder-5.4.2-py310h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<9.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pylint-venv >=2.1.1", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine <5.16", + "python >=3.10,<3.11.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.7.1,<1.8.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.2.2", + "qtawesome >=1.2.1", + "qtconsole >=5.4.0,<5.5.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.4.2,<2.5.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "3d5337611cfe42df15cc6943a9d6101a", + "name": "spyder", + "sha256": "35b4cb380456109970fc97464917b8e0c171b8ffbff4b2196a035831cbb7966c", + "size": 10872581, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1678296361787, + "type": "app", + "version": "5.4.2" + }, + "spyder-5.4.2-py311h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<9.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pylint-venv >=2.1.1", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine <5.16", + "python >=3.11,<3.12.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.7.1,<1.8.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.2.2", + "qtawesome >=1.2.1", + "qtconsole >=5.4.0,<5.5.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.4.2,<2.5.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "626041d1d3c0f82903ce5b3b12d6576a", + "name": "spyder", + "sha256": "282f00f25aba71a77a214cf82f2b1300faa8273001dbaebceffaa5a7ca739520", + "size": 10745024, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1679339238310, + "type": "app", + "version": "5.4.2" + }, + "spyder-5.4.2-py38h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<9.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pylint-venv >=2.1.1", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine <5.16", + "python >=3.8,<3.9.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.7.1,<1.8.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.2.2", + "qtawesome >=1.2.1", + "qtconsole >=5.4.0,<5.5.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.4.2,<2.5.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "097127ccf6d3573129982e519c24a097", + "name": "spyder", + "sha256": "b5378f133ac9bb7a65f410c022e8bd813e49ab40ec443a1708f56f56b924a411", + "size": 10851315, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1678296286363, + "type": "app", + "version": "5.4.2" + }, + "spyder-5.4.2-py39h06a4308_0.conda": { + "app_entry": "spyder", + "app_type": "desk", + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "menuinst >=1.4.17" + ], + "depends": [ + "atomicwrites >=1.2.0", + "chardet >=2.0.0", + "cloudpickle >=0.5.0", + "cookiecutter >=1.6.0", + "diff-match-patch >=20181111", + "intervaltree >=3.0.2", + "ipython >=7.31.1,<9.0.0", + "jedi >=0.17.2,<0.19.0", + "jellyfish >=0.7", + "jsonschema >=3.2.0", + "keyring >=17.0.0", + "nbconvert >=4.0", + "numpydoc >=0.6.0", + "parso >=0.7.0,<0.9.0", + "pexpect >=4.4.0", + "pickleshare >=0.4", + "psutil >=5.3", + "pygments >=2.0", + "pylint >=2.5.0,<3.0", + "pylint-venv >=2.1.1", + "pyls-spyder >=0.4.0", + "pyqt >=5.6,<5.16", + "pyqtwebengine <5.16", + "python >=3.9,<3.10.0a0", + "python-lsp-black >=1.2.0", + "python-lsp-server >=1.7.1,<1.8.0", + "pyxdg >=0.26", + "pyzmq >=22.1.0", + "qdarkstyle >=3.0.2,<3.1.0", + "qstylizer >=0.2.2", + "qtawesome >=1.2.1", + "qtconsole >=5.4.0,<5.5.0", + "qtpy >=2.1.0", + "rtree >=0.9.7", + "setuptools >=49.6.0", + "sphinx >=0.6.6", + "spyder-kernels >=2.4.2,<2.5.0", + "textdistance >=4.2.0", + "three-merge >=0.1.1", + "watchdog >=0.10.3" + ], + "icon": "e5a62955bb90d3266c483d85e094d3c6.png", + "license": "MIT", + "license_family": "MIT", + "md5": "93a3d803160684fbc9cfaca076ff8fd5", + "name": "spyder", + "sha256": "8445915e28482c8a50a8f43ce61596dedc9bf8ae29d0d4bb4d5948df1e0b15e9", + "size": 10846707, + "subdir": "linux-64", + "summary": "The Scientific Python Development Environment", + "timestamp": 1678296200126, + "type": "app", + "version": "5.4.2" + }, + "spyder-kernels-0.2.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0696aef38efb4e267c3fde8e2e6776e8", + "name": "spyder-kernels", + "sha256": "806cbabcb28352ed0e72f293c8af6b579d7ec0b6a8e5e033fda2b593482f60eb", + "size": 70159, + "subdir": "linux-64", + "timestamp": 1531231973650, + "version": "0.2.4" + }, + "spyder-kernels-0.2.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "20274e04cb335eb455f032845a98f47a", + "name": "spyder-kernels", + "sha256": "1aa9c2f0cde9411180a9822f67bd63fe2b71b512910d4bc22dc500454158b015", + "size": 69585, + "subdir": "linux-64", + "timestamp": 1531232045991, + "version": "0.2.4" + }, + "spyder-kernels-0.2.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "910a69c4d20547a84c42a4418fa0203a", + "name": "spyder-kernels", + "sha256": "3bae5333f140081e3b3a46fa4a64f0431a425f1deb9bb85e9beed56dc64d41dd", + "size": 69682, + "subdir": "linux-64", + "timestamp": 1531232009808, + "version": "0.2.4" + }, + "spyder-kernels-0.2.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=4.8.2", + "jupyter_client >=5.2.3", + "python >=2.7,<2.8.0a0", + "pyzmq >=17" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b98f55fcac9d8ee9d20809da8e10e88", + "name": "spyder-kernels", + "sha256": "c2faa7fca14fc54cb6d1427c91c079a92cb338f1aaa7933b6b622646f50f262d", + "size": 72829, + "subdir": "linux-64", + "timestamp": 1534261967887, + "version": "0.2.6" + }, + "spyder-kernels-0.2.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=4.8.2", + "jupyter_client >=5.2.3", + "python >=3.5,<3.6.0a0", + "pyzmq >=17" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23caedcfb2d885f3f29aa082fbba4f5e", + "name": "spyder-kernels", + "sha256": "e4aa804bfd819ef29e3952a6a8ffd0fabb827bc077c55c856807c4b01d94383a", + "size": 73863, + "subdir": "linux-64", + "timestamp": 1534261847751, + "version": "0.2.6" + }, + "spyder-kernels-0.2.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=4.8.2", + "jupyter_client >=5.2.3", + "python >=3.6,<3.7.0a0", + "pyzmq >=17" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "901142dff32cf284e9f1ce68c280de0a", + "name": "spyder-kernels", + "sha256": "4f909c3658cb8e2d008d091fadfd4aeb0ce945525d296fca3f4369690b5779be", + "size": 72902, + "subdir": "linux-64", + "timestamp": 1534261799320, + "version": "0.2.6" + }, + "spyder-kernels-0.2.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=4.8.2", + "jupyter_client >=5.2.3", + "python >=3.7,<3.8.0a0", + "pyzmq >=17" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "812b8054838bbac49eda2e8007eeb0a0", + "name": "spyder-kernels", + "sha256": "60572068dc9619668413273a95d46f325bfeecd87202ac12e90c051a3a48ccf0", + "size": 73030, + "subdir": "linux-64", + "timestamp": 1534263114934, + "version": "0.2.6" + }, + "spyder-kernels-0.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "94de3fdd03628c8d166cd331249fa871", + "name": "spyder-kernels", + "sha256": "30d61d597940410e0748d5e0635e3eaccaf7016c0561283ab25fabbe5de85601", + "size": 66560, + "subdir": "linux-64", + "timestamp": 1543426999359, + "version": "0.3.0" + }, + "spyder-kernels-0.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7d3f84952a812734412c0a7408c4f4df", + "name": "spyder-kernels", + "sha256": "ec870b68219e31d4b8cc830db8d80c62a6d3921b41c9f5d07f8b971b6a058b51", + "size": 66388, + "subdir": "linux-64", + "timestamp": 1543427074958, + "version": "0.3.0" + }, + "spyder-kernels-0.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9f8f1dcd28f1d66591f9ea150a0a0ce", + "name": "spyder-kernels", + "sha256": "d704a47fb9235cddb2ade192ed693f7f187917d589c97c40b472d5f91732890b", + "size": 66326, + "subdir": "linux-64", + "timestamp": 1543426986791, + "version": "0.3.0" + }, + "spyder-kernels-0.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "37fb04f1000e625ad0bc377d842e3017", + "name": "spyder-kernels", + "sha256": "df39b2d5d0a84a7bb13ac804b0398b7cd385053e75d0e7878a6a0b220621cd71", + "size": 68539, + "subdir": "linux-64", + "timestamp": 1549636462846, + "version": "0.4.2" + }, + "spyder-kernels-0.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f79540f0749f6798641521fd5a53cc4f", + "name": "spyder-kernels", + "sha256": "721786c21a311e920017293ec978415b4eccf271e17a8d4a933ebd95ecac7ad2", + "size": 68486, + "subdir": "linux-64", + "timestamp": 1549636523676, + "version": "0.4.2" + }, + "spyder-kernels-0.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18894829d39a9072112406ddb323efe1", + "name": "spyder-kernels", + "sha256": "38b0e42a915334882ac5a7c9085e26bf788a81beb62ee34d94eade5e07983480", + "size": 68466, + "subdir": "linux-64", + "timestamp": 1549636464706, + "version": "0.4.2" + }, + "spyder-kernels-0.4.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f635eeeb0ec8cb8cc31d34653bbd286d", + "name": "spyder-kernels", + "sha256": "466e68e532b141b7df8ed86845be63ef20c01032a7b15d73fa9357f6e910ec32", + "size": 71885, + "subdir": "linux-64", + "timestamp": 1554934386819, + "version": "0.4.3" + }, + "spyder-kernels-0.4.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23908f60ceba3955633a4798d4217c08", + "name": "spyder-kernels", + "sha256": "6b98b5867966c0c08ee8da543cea4eb999834d07f2045f8420da296345d75194", + "size": 70595, + "subdir": "linux-64", + "timestamp": 1554934403032, + "version": "0.4.3" + }, + "spyder-kernels-0.4.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cdeddb0a9a700d005b7f372a9f1e9e6e", + "name": "spyder-kernels", + "sha256": "69f1cf1b3795a3bc3e2f599a1416521e9ba6b8b97bf689c632bd0b1cfb9f80e3", + "size": 70594, + "subdir": "linux-64", + "timestamp": 1554934254666, + "version": "0.4.3" + }, + "spyder-kernels-0.4.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2bd6933b6aa7a9da6f94f601cbe6cc7d", + "name": "spyder-kernels", + "sha256": "2c501ab38aa0b65650360af315c3496c218db237e62e1cff96d41435fb6a05f4", + "size": 71107, + "subdir": "linux-64", + "timestamp": 1554942265695, + "version": "0.4.4" + }, + "spyder-kernels-0.4.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0bad71572cd325c3b5d9ba80287e7b6e", + "name": "spyder-kernels", + "sha256": "8cd7b11f63d0e369ea5e7412c7b5a4b3ee583a0b6bb578ad69eafb0f17e4a26d", + "size": 71806, + "subdir": "linux-64", + "timestamp": 1554942280104, + "version": "0.4.4" + }, + "spyder-kernels-0.4.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bad3db98f471d2b04f34d4527e9e5d86", + "name": "spyder-kernels", + "sha256": "0e4708c2e41b3da19c3a8e0efc254d52bc833677d907a4bd811d790a5f77679d", + "size": 71672, + "subdir": "linux-64", + "timestamp": 1554942344164, + "version": "0.4.4" + }, + "spyder-kernels-0.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d02797eac10c36d97fec23d1e74f6e62", + "name": "spyder-kernels", + "sha256": "99a15963bd60f5f26bb59410f50faa837d4ca0697c9df01ed55ac42a9d9c9d2b", + "size": 72210, + "subdir": "linux-64", + "timestamp": 1561548550051, + "version": "0.5.0" + }, + "spyder-kernels-0.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f7d73bdfba8dffe5a77703068d63d1a2", + "name": "spyder-kernels", + "sha256": "8a8636c05d1c151da5ee6aee206c66a53d42027eee42cd05e84b0580af89d21d", + "size": 71736, + "subdir": "linux-64", + "timestamp": 1561548348361, + "version": "0.5.0" + }, + "spyder-kernels-0.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a797791d5c69bfe1a520b8d9599798c", + "name": "spyder-kernels", + "sha256": "6176d2157569415a4d32ef64152904487b2f411a44f9dd433f2f28faa3ee2b12", + "size": 71758, + "subdir": "linux-64", + "timestamp": 1561548350809, + "version": "0.5.0" + }, + "spyder-kernels-0.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e64b903837870f1eb4671d9e586f8308", + "name": "spyder-kernels", + "sha256": "541cac3353c5337bae15b3c93f78281cd28024a977985237517ba4ac5ede60ae", + "size": 72954, + "subdir": "linux-64", + "timestamp": 1563205855967, + "version": "0.5.1" + }, + "spyder-kernels-0.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e280e4e3dd7236fe74254c3e22ac7792", + "name": "spyder-kernels", + "sha256": "a069e57fe0ec18bad3aadc44ca1f585e081e75e36055a67ad3130c5e58c6ccb2", + "size": 73059, + "subdir": "linux-64", + "timestamp": 1563205856920, + "version": "0.5.1" + }, + "spyder-kernels-0.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9943eed5e1c7913e76a75e0db48a240d", + "name": "spyder-kernels", + "sha256": "38dba1f1ff06bfdc396e2295c6e34929d69e1f764e4565d9ca5a814ae74c3b4b", + "size": 71975, + "subdir": "linux-64", + "timestamp": 1563205848010, + "version": "0.5.1" + }, + "spyder-kernels-0.5.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "713ebab9e3ab75193c49f4bd9a163ee1", + "name": "spyder-kernels", + "sha256": "cb81cbb36ef94353eeb6f0cb19ba0c46db9a3f0ea56a1848d7015e118988c2e3", + "size": 72334, + "subdir": "linux-64", + "timestamp": 1569377835310, + "version": "0.5.2" + }, + "spyder-kernels-0.5.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "36b71d7ba7f6e3d3b3baf0b74bed4769", + "name": "spyder-kernels", + "sha256": "39268747687aa796260c47c2557a189765c1c2a1e3eb756eaf6f73c6c8b71869", + "size": 72062, + "subdir": "linux-64", + "timestamp": 1569377830155, + "version": "0.5.2" + }, + "spyder-kernels-0.5.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca01e42de22eccd905ee21b3a9e10de3", + "name": "spyder-kernels", + "sha256": "11f70d4f7b45d7519fd607ea975375d639a8bce43a35f2d10b55896b7632ee0b", + "size": 72296, + "subdir": "linux-64", + "timestamp": 1569377835711, + "version": "0.5.2" + }, + "spyder-kernels-0.5.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.2.3", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc10389f6e7cf55c013bcdad631973b2", + "name": "spyder-kernels", + "sha256": "cf3bc79685ff62cf9eec51f5ff1fdb493a71d2d479708c289ff9cd8f631fab2d", + "size": 69532, + "subdir": "linux-64", + "timestamp": 1574237965404, + "version": "0.5.2" + }, + "spyder-kernels-1.10.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee8a6863c285b71c52f3e41ae9e6a752", + "name": "spyder-kernels", + "sha256": "748d4012434c5341933bfbe448df65972788f075b7a01ce230bf321780a08b5e", + "size": 101114, + "subdir": "linux-64", + "timestamp": 1606929328176, + "version": "1.10.0" + }, + "spyder-kernels-1.10.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "91b7f7e8c13f7d02c9e0ac1370bc35e5", + "name": "spyder-kernels", + "sha256": "650ae593c4d852cdac6323de4176f73adcdb6fd43c00f6dcad6aad480b4da26e", + "size": 101230, + "subdir": "linux-64", + "timestamp": 1606929349303, + "version": "1.10.0" + }, + "spyder-kernels-1.10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4f54e475ed87142e091910d38d90c2a", + "name": "spyder-kernels", + "sha256": "b809a3e775abdc97594480b13eb1234a586cadd857470fa3dd57f1c0e5ff7cd6", + "size": 103212, + "subdir": "linux-64", + "timestamp": 1606929338852, + "version": "1.10.0" + }, + "spyder-kernels-1.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "76f6d7bb6b9e7d9cd753a5d9ad06c70d", + "name": "spyder-kernels", + "sha256": "2ef0a30a5e1362180fc7c01debe22b57faca8f8a966ed8d205cb632a83b35f37", + "size": 107208, + "subdir": "linux-64", + "timestamp": 1607457553596, + "version": "1.10.0" + }, + "spyder-kernels-1.10.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a31471dd170b8c76bca420a4c347b1a7", + "name": "spyder-kernels", + "sha256": "5213c0088cf85b3716f5b17ecb8a8de922dee9927c96556df97fc23a0d17daff", + "size": 101563, + "subdir": "linux-64", + "timestamp": 1608578812496, + "version": "1.10.1" + }, + "spyder-kernels-1.10.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b740d2f63c82c167822ca1f9b620bb6", + "name": "spyder-kernels", + "sha256": "93004e8634149e2a0d64ba429ccde01b5830ecfde162fd243bea56fb77398305", + "size": 101688, + "subdir": "linux-64", + "timestamp": 1608578838205, + "version": "1.10.1" + }, + "spyder-kernels-1.10.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4b552d7952ddacd45c7fede43fb037a0", + "name": "spyder-kernels", + "sha256": "ed6709be787825009d1d02c70354cbcc8b9f0bf073cd24e4e55bf8f7d7817a2b", + "size": 103662, + "subdir": "linux-64", + "timestamp": 1608578833289, + "version": "1.10.1" + }, + "spyder-kernels-1.10.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "24eb607e2ca9ccfe956c78a1cedb83f3", + "name": "spyder-kernels", + "sha256": "dcbc472c248220fc789668f7bbf2d26f492eb35c142066a640226f14ba71f20b", + "size": 103829, + "subdir": "linux-64", + "timestamp": 1608578825508, + "version": "1.10.1" + }, + "spyder-kernels-1.10.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f8ff957b46dc79a3e0f9e869a3943952", + "name": "spyder-kernels", + "sha256": "f075f54d9f9decda9e2cd5b02132be4d8f2c244f6b303c1a02414cfef5cdcf88", + "size": 104162, + "subdir": "linux-64", + "timestamp": 1614030621813, + "version": "1.10.2" + }, + "spyder-kernels-1.10.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e36796cd0f9a8f054e41c7a523ee0761", + "name": "spyder-kernels", + "sha256": "61670ddf2e6f3297b2c3786a9f2dfbaaf49817ec1ca4aff94fc04cc65df37cf3", + "size": 102597, + "subdir": "linux-64", + "timestamp": 1614030619140, + "version": "1.10.2" + }, + "spyder-kernels-1.10.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f124461b15bf72f5c915b399995545e", + "name": "spyder-kernels", + "sha256": "334e4d20117e9b0e610c6c178b140c20b626d5d7c54a675cc7b4479a6f6bfcad", + "size": 104830, + "subdir": "linux-64", + "timestamp": 1614030629656, + "version": "1.10.2" + }, + "spyder-kernels-1.10.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7f437f33d66cd1f2d57cf4b0a5baecf", + "name": "spyder-kernels", + "sha256": "ed063deb8e55c411489ed33e69f5c22da623e7b2a70d0ffd39c9029a3e17daf1", + "size": 103148, + "subdir": "linux-64", + "timestamp": 1614029724785, + "version": "1.10.2" + }, + "spyder-kernels-1.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c37100cfdada509ca361389d21bc945e", + "name": "spyder-kernels", + "sha256": "d5ef523dd84a4e89383e8a748380c17a6d2beaabbccba000f569b0789527000d", + "size": 67131, + "subdir": "linux-64", + "timestamp": 1550363810448, + "version": "1.3.2" + }, + "spyder-kernels-1.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "922e52875ea19022d3118632df61ea7a", + "name": "spyder-kernels", + "sha256": "ad6aa6a4b803f34bb931503006fcd66f46b65a10c722b3acfcccf48b86a296c4", + "size": 65872, + "subdir": "linux-64", + "timestamp": 1550363807578, + "version": "1.3.2" + }, + "spyder-kernels-1.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0dd65796d32ba3918ada939e45681dc", + "name": "spyder-kernels", + "sha256": "f549fabaec462b8873c330c9379b7d44fb83c93342afff67ccc6a5fb5da61b1c", + "size": 66962, + "subdir": "linux-64", + "timestamp": 1550363769082, + "version": "1.3.2" + }, + "spyder-kernels-1.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0e38513497b5aaf6377359020e8fd33c", + "name": "spyder-kernels", + "sha256": "6faa16f942d2d1555e20400fc12c2fc2668df74115b2728305b4961ffe776433", + "size": 68748, + "subdir": "linux-64", + "timestamp": 1564708135325, + "version": "1.4.0" + }, + "spyder-kernels-1.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f51c9a7d176681036f768e410c99789", + "name": "spyder-kernels", + "sha256": "16a973ee6b0b86ccf87f8c1ccd5f34b17bb9a30490b5effc4c709f4b959d8a71", + "size": 67525, + "subdir": "linux-64", + "timestamp": 1564708144532, + "version": "1.4.0" + }, + "spyder-kernels-1.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "42b06f71700799e67aa31b138bc91bcc", + "name": "spyder-kernels", + "sha256": "e42076de30de59879ae6f11fa04f72089161c482d2dcd12ae88358037bd739b0", + "size": 67485, + "subdir": "linux-64", + "timestamp": 1564708096411, + "version": "1.4.0" + }, + "spyder-kernels-1.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >4.9.0", + "jupyter_client >=5.3.4", + "python >=2.7,<2.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2c32befb94d3adced188ff43e94707bb", + "name": "spyder-kernels", + "sha256": "5a74cd1e810d8d8feba57a2ab696fb03940814e4c25c1a35d7b351ab5de0bda8", + "size": 95043, + "subdir": "linux-64", + "timestamp": 1575583640403, + "version": "1.8.1" + }, + "spyder-kernels-1.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "86218573303ff6dd2bd0423465783f37", + "name": "spyder-kernels", + "sha256": "06d3350cc21f99b2dc645e6f9d5cc77c5344152960464d6883dbbb1afc5593de", + "size": 94575, + "subdir": "linux-64", + "timestamp": 1575583738871, + "version": "1.8.1" + }, + "spyder-kernels-1.8.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f24b1e8e806557fa7f7b2e0f32e141d", + "name": "spyder-kernels", + "sha256": "0b9da29d17800fbde8bdbf270669c9681c0314830ff1911e66b1fcbf472194d7", + "size": 93843, + "subdir": "linux-64", + "timestamp": 1575583697111, + "version": "1.8.1" + }, + "spyder-kernels-1.8.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "997b00a8369244bc47bdd4556c0d6de6", + "name": "spyder-kernels", + "sha256": "89b0d56219d03999999333dbff27623b42f420d35c6aaf1d40f7d3bc5b2d7b79", + "size": 95247, + "subdir": "linux-64", + "timestamp": 1575583739922, + "version": "1.8.1" + }, + "spyder-kernels-1.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e7928b42619e23242f3fd2f034c27f5", + "name": "spyder-kernels", + "sha256": "3e0cbb658147babdf3c103d49aeab2ddfd30ddad0dba78807f7eeff9eb286e13", + "size": 96991, + "subdir": "linux-64", + "timestamp": 1584457767462, + "version": "1.9.0" + }, + "spyder-kernels-1.9.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d473dc037bfb72c304bf6e4fa01b1cf4", + "name": "spyder-kernels", + "sha256": "8adb9687700ca95da69e566014ddf62bd27a100b7ea11e3014ead4e772827c68", + "size": 97432, + "subdir": "linux-64", + "timestamp": 1584457716747, + "version": "1.9.0" + }, + "spyder-kernels-1.9.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa055929d7239a02334def42a8c06003", + "name": "spyder-kernels", + "sha256": "30db7cac8b586896183d5590ed0ca5f06d5a0b4347b3bbad4bdfe8b5088c3262", + "size": 98648, + "subdir": "linux-64", + "timestamp": 1584457743640, + "version": "1.9.0" + }, + "spyder-kernels-1.9.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f9935ca685414b86aea04d17df99761a", + "name": "spyder-kernels", + "sha256": "e1ce9baa0f2746737875d14412016cc92b63a026c7a67a35ffe46aa28fba1711", + "size": 98135, + "subdir": "linux-64", + "timestamp": 1588949408889, + "version": "1.9.1" + }, + "spyder-kernels-1.9.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d9f55875d62c754037b1bc899c57f1f", + "name": "spyder-kernels", + "sha256": "f09fbbf76d742e91627528057b0444a47c171be18b6568a6a220630d00c5be82", + "size": 97118, + "subdir": "linux-64", + "timestamp": 1588949389765, + "version": "1.9.1" + }, + "spyder-kernels-1.9.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df92743795e77ae9c7e8107d33106046", + "name": "spyder-kernels", + "sha256": "a624a66042176d7cba6f0224e5c7425aa8619db5786b362a3873b0ed40416116", + "size": 97541, + "subdir": "linux-64", + "timestamp": 1588949411507, + "version": "1.9.1" + }, + "spyder-kernels-1.9.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "49440377a2bfbd3b7131f58a7a51aabd", + "name": "spyder-kernels", + "sha256": "33e624257ab6f4b45d088759ec3340212d3e51610097c64445b8750adab7f96e", + "size": 99638, + "subdir": "linux-64", + "timestamp": 1594751579108, + "version": "1.9.2" + }, + "spyder-kernels-1.9.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f42fb12f3a1442eef7cddc7eaf4f0251", + "name": "spyder-kernels", + "sha256": "a4d5e039e42c9ad7f9df9219c19552df32f0a8d6b3c9edeb01d00c225ea2869e", + "size": 99013, + "subdir": "linux-64", + "timestamp": 1594751578336, + "version": "1.9.2" + }, + "spyder-kernels-1.9.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f190e8c327bd8033c4fd3c2270db4557", + "name": "spyder-kernels", + "sha256": "9345e3dfdd44b1c71d698450d6c427d2a53328755a5aba35ddd7a33739bda92a", + "size": 100228, + "subdir": "linux-64", + "timestamp": 1594751579927, + "version": "1.9.2" + }, + "spyder-kernels-1.9.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e405eddd212163a5f4c87a2160a70d3b", + "name": "spyder-kernels", + "sha256": "461c27b9a3e92d93f1f9a5a69ad677e2794e2fbec747e169c42dca6e0b8333df", + "size": 99826, + "subdir": "linux-64", + "timestamp": 1598375156510, + "version": "1.9.3" + }, + "spyder-kernels-1.9.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aad43768d0e26222dd74bacaf709b7a7", + "name": "spyder-kernels", + "sha256": "02bb9e1993e4782c0a5c20d501fad2218277de7f3914df90324d5dc1a2b4903d", + "size": 93021, + "subdir": "linux-64", + "timestamp": 1597005065463, + "version": "1.9.3" + }, + "spyder-kernels-1.9.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fdb1a7fb22d32741f12dde5671a69cf0", + "name": "spyder-kernels", + "sha256": "b746f1a1f36645304d85332e272328d860f6bec65ab9c8dbb9f6e52a7cd78449", + "size": 100432, + "subdir": "linux-64", + "timestamp": 1598375160707, + "version": "1.9.3" + }, + "spyder-kernels-1.9.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6520d9a006820e7a3f21cac1bf7c4f3f", + "name": "spyder-kernels", + "sha256": "05cb973a1905ba43f0786987e0b08a7aa5c6b87644437fc0f9c7bf3068b5596f", + "size": 100477, + "subdir": "linux-64", + "timestamp": 1599056786619, + "version": "1.9.4" + }, + "spyder-kernels-1.9.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71c8cb8fe1a539f55bb9f1e0fbd704fb", + "name": "spyder-kernels", + "sha256": "c634e45795c7b40ce70369d4bc48a66ef7da95108907b542d627c2f9c5ac1fd5", + "size": 100521, + "subdir": "linux-64", + "timestamp": 1599056786619, + "version": "1.9.4" + }, + "spyder-kernels-1.9.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.1.3", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96d9711c3a425b6f3ee8e3358618f373", + "name": "spyder-kernels", + "sha256": "2ce6a86b6977995218d415b4f35dfdd6751b90420fc11ef9e7bc31a84eeddadf", + "size": 99620, + "subdir": "linux-64", + "timestamp": 1599056788633, + "version": "1.9.4" + }, + "spyder-kernels-2.0.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ec3871b3980aab61f130e44e2ed5ef1", + "name": "spyder-kernels", + "sha256": "fc64e2da22bad286d2ebf0ca7be8ef1c6eb55acaf5c590792b5879e315b6fc0b", + "size": 103999, + "subdir": "linux-64", + "timestamp": 1617396614787, + "version": "2.0.1" + }, + "spyder-kernels-2.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ac7e4e14e8d7409d47158cac48bbd179", + "name": "spyder-kernels", + "sha256": "3744e74a6a4b23b266e8914df3944943eeea790116bde7f799dd0c8316b5c6d1", + "size": 102698, + "subdir": "linux-64", + "timestamp": 1617395927915, + "version": "2.0.1" + }, + "spyder-kernels-2.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9444ce01606b3a9f2707df7fc2d83c8d", + "name": "spyder-kernels", + "sha256": "b04682c3b12ba8d9be31fe56e3589e37f31f6144e0433dd10963ec9652c305d3", + "size": 104661, + "subdir": "linux-64", + "timestamp": 1617396603007, + "version": "2.0.1" + }, + "spyder-kernels-2.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1a8389b312209a60f3de9b4bc229abc", + "name": "spyder-kernels", + "sha256": "74456212298527639d893d4c3d9c946a856157124839ed586e3f53376832de44", + "size": 104681, + "subdir": "linux-64", + "timestamp": 1617396596466, + "version": "2.0.1" + }, + "spyder-kernels-2.0.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "decorator <5", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c0fd5760cef7d7c058b5dea5282d9a1", + "name": "spyder-kernels", + "sha256": "01beadd867da23c34e7b483a59ce080301d2ecef2584d58839ee64baed7ab80d", + "size": 110077, + "subdir": "linux-64", + "timestamp": 1623278699300, + "version": "2.0.3" + }, + "spyder-kernels-2.0.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "decorator <5", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "774530c08c3b2bfdbdc29815da52e24b", + "name": "spyder-kernels", + "sha256": "a794dbf8903c19f25a43b704585c400e79ebfa3962c38322feaa941b67fb00a9", + "size": 110446, + "subdir": "linux-64", + "timestamp": 1623273245382, + "version": "2.0.3" + }, + "spyder-kernels-2.0.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "decorator <5", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31ee7c5dd50723aa07ee69809c988749", + "name": "spyder-kernels", + "sha256": "2f0f5c86ba5495715b193418d3885c70df93a70c2d72e134496adc60dd835175", + "size": 110931, + "subdir": "linux-64", + "timestamp": 1623278786555, + "version": "2.0.3" + }, + "spyder-kernels-2.0.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "decorator <5", + "ipykernel >=5.1.3", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "123dc0690f678f030f5e907ce2ad67c3", + "name": "spyder-kernels", + "sha256": "d1c3f9140f552630f8fac82f670e547b822129fbe1fd5df6f36acce1d4a41074", + "size": 109461, + "subdir": "linux-64", + "timestamp": 1623278802738, + "version": "2.0.3" + }, + "spyder-kernels-2.0.5-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7557fdd17728d11efd0eab6231c156a0", + "name": "spyder-kernels", + "sha256": "35402c0e0b4af009196aab8bd21c20b1710699901434d19aa5f7429ce6f362e9", + "size": 101736, + "subdir": "linux-64", + "timestamp": 1625670749102, + "version": "2.0.5" + }, + "spyder-kernels-2.0.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a94cdd37969a37eacff212e02210e88d", + "name": "spyder-kernels", + "sha256": "fa10edcdaae2441f9be85802bf7a29855215f5e445794977d29f9134b09a7e51", + "size": 101286, + "subdir": "linux-64", + "timestamp": 1625671073348, + "version": "2.0.5" + }, + "spyder-kernels-2.0.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "38d0e4ff9c67ebfacae9e3bb7d1a022a", + "name": "spyder-kernels", + "sha256": "b28f5915a7f1cb913a6089a3ad371e029eb6d3c9c330025b4857fabf036a57ce", + "size": 101721, + "subdir": "linux-64", + "timestamp": 1625671065923, + "version": "2.0.5" + }, + "spyder-kernels-2.0.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a561d339a66056a5f3276f5fe31b6877", + "name": "spyder-kernels", + "sha256": "862d72e6b1aa01ed2f273f509fd680c7bea41a2b79ad9bc1398519900a9d4979", + "size": 101714, + "subdir": "linux-64", + "timestamp": 1625671079102, + "version": "2.0.5" + }, + "spyder-kernels-2.1.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4,<7", + "python >=3.6,<3.7.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ccc6bc542334f16e18568116b921018b", + "name": "spyder-kernels", + "sha256": "aca56b27e14a308d027e0354d6ec152b8c033efecc4f4535db2bd8e7a62e16da", + "size": 111265, + "subdir": "linux-64", + "timestamp": 1632249729296, + "version": "2.1.1" + }, + "spyder-kernels-2.1.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4,<7", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d8717cb4a36b76bd15b3d58836ec262", + "name": "spyder-kernels", + "sha256": "41fa85ef709df495bf17de58628f9c92dad53dbfde48afe1885cb1febd5d4349", + "size": 111341, + "subdir": "linux-64", + "timestamp": 1632249720319, + "version": "2.1.1" + }, + "spyder-kernels-2.1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4,<7", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "28d0b2e354ab7f4f58cf5bb13c7b85fe", + "name": "spyder-kernels", + "sha256": "49618b9912f7a5eeded15cf654a0e627ab778cf52ad3d1580c307811fb693955", + "size": 113546, + "subdir": "linux-64", + "timestamp": 1632249714645, + "version": "2.1.1" + }, + "spyder-kernels-2.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4,<7", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3430628a59054a1d0dd58b29c22c0fad", + "name": "spyder-kernels", + "sha256": "113fb40c060bb047516f4dee94d28e473ccdabd13702c3f6419420957d5d15d8", + "size": 113362, + "subdir": "linux-64", + "timestamp": 1632249454109, + "version": "2.1.1" + }, + "spyder-kernels-2.1.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4,<7", + "python >=3.10,<3.11.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cad4d54641068590d1de20fdacc09495", + "name": "spyder-kernels", + "sha256": "a39b554d0967ed30e15fadcce6d462775fcece234323f29c4bc5705301d8a002", + "size": 106630, + "subdir": "linux-64", + "timestamp": 1642518688479, + "version": "2.1.3" + }, + "spyder-kernels-2.1.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4,<7", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de0c13d822a64baf955d12b63c05398b", + "name": "spyder-kernels", + "sha256": "00eb8bc5ef5bbe13d44aff3493eca64e7f7de76a71ce40edcfba89dcdb596eda", + "size": 114621, + "subdir": "linux-64", + "timestamp": 1634236955582, + "version": "2.1.3" + }, + "spyder-kernels-2.1.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4,<7", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d90a313108a0ee6600fcdd3ae14b10b6", + "name": "spyder-kernels", + "sha256": "2b0886e12707e0294819d6ed0abb649b1c0907a1df7533222481d823fb98aa59", + "size": 115227, + "subdir": "linux-64", + "timestamp": 1634236960071, + "version": "2.1.3" + }, + "spyder-kernels-2.1.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4,<7", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "818cbecea3d7ad3c232dd8f6d6593aa4", + "name": "spyder-kernels", + "sha256": "7ccdf277d73c25d1b6bb50b16051f74c76028770dc7093cf5c5a9a8bde5747aa", + "size": 113288, + "subdir": "linux-64", + "timestamp": 1634236950330, + "version": "2.1.3" + }, + "spyder-kernels-2.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.7,<3.8.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "abdbe5b926b549a77c9dc61014fd7469", + "name": "spyder-kernels", + "sha256": "f7e312877c89ae26f3b2fa9eadbc6888a55d28791b98fa8172bd9ee64eddb5fc", + "size": 114953, + "subdir": "linux-64", + "timestamp": 1641393018023, + "version": "2.2.0" + }, + "spyder-kernels-2.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.8,<3.9.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f67b362734ad2335878f346ed5977ab3", + "name": "spyder-kernels", + "sha256": "9c5b362c90b7dd0abef171824f5fd32cd05c3b68e3d18eba021df286446d760e", + "size": 116071, + "subdir": "linux-64", + "timestamp": 1641393021672, + "version": "2.2.0" + }, + "spyder-kernels-2.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=5.3.0", + "ipython >=7.6.0", + "jupyter_client >=5.3.4", + "python >=3.9,<3.10.0a0", + "pyzmq >=17", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f7c4451d90c3bfe5a873c4d14642105", + "name": "spyder-kernels", + "sha256": "7dfd9dadd49a645e5970d064908ec703b8a0501b03c7f3be4edfb660db159ae6", + "size": 117317, + "subdir": "linux-64", + "timestamp": 1641393017589, + "version": "2.2.0" + }, + "spyder-kernels-2.2.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.6.1", + "ipython >=7.6.0,<8.0.0", + "jupyter_client >=7.1.0", + "python >=3.10,<3.11.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f167e4c5fb61870a1ab15da17f6bb781", + "name": "spyder-kernels", + "sha256": "0bb7bfa75c2e99ae677b0f40d1f6d9ed340a99ec3dc4ee730ca8f9bb18e4d0c9", + "size": 117225, + "subdir": "linux-64", + "timestamp": 1647011273819, + "version": "2.2.1" + }, + "spyder-kernels-2.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.6.1", + "ipython >=7.6.0,<8.0.0", + "jupyter_client >=7.1.0", + "python >=3.7,<3.8.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4b7f20f722ea1eb870ee300a44d3ce5f", + "name": "spyder-kernels", + "sha256": "245d94e2d9741eaf3fbe6bc06dadf056d3db78c747d8825a102416d2ed02ea8a", + "size": 117748, + "subdir": "linux-64", + "timestamp": 1646993694832, + "version": "2.2.1" + }, + "spyder-kernels-2.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.6.1", + "ipython >=7.6.0,<8.0.0", + "jupyter_client >=7.1.0", + "python >=3.8,<3.9.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0da03cdc4b64fd881a3c9f5a1c3daef4", + "name": "spyder-kernels", + "sha256": "7be5bfa7c970f2f0185b682183a2b5320edeef8669a062bd68d6885d75caa7b5", + "size": 118267, + "subdir": "linux-64", + "timestamp": 1647011261195, + "version": "2.2.1" + }, + "spyder-kernels-2.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.6.1", + "ipython >=7.6.0,<8.0.0", + "jupyter_client >=7.1.0", + "python >=3.9,<3.10.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a97e3a268f7b646c1186721adec33561", + "name": "spyder-kernels", + "sha256": "bce8dba2e01ad38430225470e1738bc9e1770e1b9dca6be78cdf41fa569185e5", + "size": 118330, + "subdir": "linux-64", + "timestamp": 1647011256326, + "version": "2.2.1" + }, + "spyder-kernels-2.3.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.9.2,<7.0.0", + "ipython >=7.31.1,<8.0.0", + "jupyter_client >=7.3.4,<8.0.0", + "python >=3.10,<3.11.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18eaeb72456e4010bc2adf4ec6a0e594", + "name": "spyder-kernels", + "sha256": "bdcfc0825eef63545e148d7cff4e4a25837bdb28b0516db3d229b4cab3627a15", + "size": 113633, + "subdir": "linux-64", + "timestamp": 1662458042577, + "version": "2.3.3" + }, + "spyder-kernels-2.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.9.2,<7.0.0", + "ipython >=7.31.1,<8.0.0", + "jupyter_client >=7.3.4,<8.0.0", + "python >=3.7,<3.8.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5bdac158ca5d3b5446eb56eab423202f", + "name": "spyder-kernels", + "sha256": "98342122fee21fdcdc84a15626f5b11b27f003a7089b135f31d59d9213e8477d", + "size": 111562, + "subdir": "linux-64", + "timestamp": 1662457919629, + "version": "2.3.3" + }, + "spyder-kernels-2.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.9.2,<7.0.0", + "ipython >=7.31.1,<8.0.0", + "jupyter_client >=7.3.4,<8.0.0", + "python >=3.8,<3.9.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a1e386e5484ccbf70150bcdb49b59025", + "name": "spyder-kernels", + "sha256": "bfdf5690a342291231d6448597e2b75bf78d10e4935d93df03bc844390f8305b", + "size": 111810, + "subdir": "linux-64", + "timestamp": 1662457954084, + "version": "2.3.3" + }, + "spyder-kernels-2.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.9.2,<7.0.0", + "ipython >=7.31.1,<8.0.0", + "jupyter_client >=7.3.4,<8.0.0", + "python >=3.9,<3.10.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d92d933aa217bb3acbeb60ee0cb99354", + "name": "spyder-kernels", + "sha256": "d31fafc342cb8df4121b40c7d8228e4451e3a38caefc9b5d64cf0bc64562e206", + "size": 112658, + "subdir": "linux-64", + "timestamp": 1662457987937, + "version": "2.3.3" + }, + "spyder-kernels-2.4.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.16.1,<7.0.0", + "ipython >=7.31.1,<9.0.0", + "jupyter_client >=7.3.4,<8.0.0", + "packaging", + "python >=3.10,<3.11.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64d68f540ce369a2aa10f2f7079df224", + "name": "spyder-kernels", + "sha256": "e0d05f1af3ba0b157ec4448a20ddd7529c50028b7fe1f2d6cae5b8f7f162d069", + "size": 154968, + "subdir": "linux-64", + "timestamp": 1673292299338, + "version": "2.4.1" + }, + "spyder-kernels-2.4.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.16.1,<7.0.0", + "ipython >=7.31.1,<9.0.0", + "jupyter_client >=7.3.4,<8.0.0", + "packaging", + "python >=3.11,<3.12.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1a2f71f69b2eb7b275a23c189367ee3", + "name": "spyder-kernels", + "sha256": "80cffb8d64ba71820e2a8612ab7f5b9b0a9c3ca0d440dac89b7c59e11ae5dc29", + "size": 197168, + "subdir": "linux-64", + "timestamp": 1677696674388, + "version": "2.4.1" + }, + "spyder-kernels-2.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.16.1,<7.0.0", + "ipython >=7.31.1,<9.0.0", + "jupyter_client >=7.3.4,<8.0.0", + "packaging", + "python >=3.8,<3.9.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c1eedb6de2ed4d78765b5bd9f0ad716", + "name": "spyder-kernels", + "sha256": "e91f86ba8ccda88c78b363a747bc8245033003e3e9f903f10b5715e10192f539", + "size": 153851, + "subdir": "linux-64", + "timestamp": 1673292330376, + "version": "2.4.1" + }, + "spyder-kernels-2.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.16.1,<7.0.0", + "ipython >=7.31.1,<9.0.0", + "jupyter_client >=7.3.4,<8.0.0", + "packaging", + "python >=3.9,<3.10.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e5ea72e2c50ea3546bbf2b971fcf7afb", + "name": "spyder-kernels", + "sha256": "140dc952e663f5c0f7a777428e9a5719c31b1ed82823fa129fb5de6e01ba68fe", + "size": 153766, + "subdir": "linux-64", + "timestamp": 1673292267056, + "version": "2.4.1" + }, + "spyder-kernels-2.4.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.16.1,<7.0.0", + "ipython >=7.31.1,<9.0.0", + "jupyter_client >=7.4.9,<8.0.0", + "python >=3.10,<3.11.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aeff3f343f43a2c3ec71e38e920d4078", + "name": "spyder-kernels", + "sha256": "a1e7fe062dbcb82d6cd16d9f9e7211f6112e4a8b7b340a78a02644b980df4b7b", + "size": 155091, + "subdir": "linux-64", + "timestamp": 1678120626506, + "version": "2.4.2" + }, + "spyder-kernels-2.4.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.16.1,<7.0.0", + "ipython >=7.31.1,<9.0.0", + "jupyter_client >=7.4.9,<8.0.0", + "python >=3.11,<3.12.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90d08b4b01cd1f46754bf2e4e16db853", + "name": "spyder-kernels", + "sha256": "c353c13d5ebc83b6fe714c4fd105b5d9c2b61d1791b74e770b196ae638ab1094", + "size": 195015, + "subdir": "linux-64", + "timestamp": 1679339273338, + "version": "2.4.2" + }, + "spyder-kernels-2.4.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.16.1,<7.0.0", + "ipython >=7.31.1,<9.0.0", + "jupyter_client >=7.4.9,<8.0.0", + "python >=3.8,<3.9.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2c2e5e42796593999ef2927eebc2f48", + "name": "spyder-kernels", + "sha256": "715e0f3188636c8909a4a772af265990b0d87db4a4cffb64c670a09c035b9773", + "size": 153943, + "subdir": "linux-64", + "timestamp": 1678120658923, + "version": "2.4.2" + }, + "spyder-kernels-2.4.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cloudpickle", + "ipykernel >=6.16.1,<7.0.0", + "ipython >=7.31.1,<9.0.0", + "jupyter_client >=7.4.9,<8.0.0", + "python >=3.9,<3.10.0a0", + "pyzmq >=22.1.0", + "wurlitzer >=1.0.3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d3ebc502de1283fa96c977df085c9d2d", + "name": "spyder-kernels", + "sha256": "6d0f82e328d68cfe32d63fe1f0d02a6846ac1844f715db35ef7aa5ac90413d77", + "size": 153276, + "subdir": "linux-64", + "timestamp": 1678120691636, + "version": "2.4.2" + }, + "sqlalchemy-1.1.13-py27hb0a01da_0.conda": { + "build": "py27hb0a01da_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "be0c13af8d36b1b191d43b2488056101", + "name": "sqlalchemy", + "sha256": "90a374ca7be425ce31f25404210a3f60fbc0d27af80380f4a480d260a9adba89", + "size": 1326476, + "subdir": "linux-64", + "timestamp": 1505691314964, + "version": "1.1.13" + }, + "sqlalchemy-1.1.13-py35h4911131_0.conda": { + "build": "py35h4911131_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "0b07c1bc0094ed269d22f44478dcd589", + "name": "sqlalchemy", + "sha256": "d63e9bf8d75c54b806b56766ea2f63f2f53f936e74330cd5cb950cf55090a3ac", + "size": 1356353, + "subdir": "linux-64", + "timestamp": 1505691345949, + "version": "1.1.13" + }, + "sqlalchemy-1.1.13-py36hfb5efd7_0.conda": { + "build": "py36hfb5efd7_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ecdabbb5c4212c1da893fd2cf6d46b0f", + "name": "sqlalchemy", + "sha256": "b11bddf1bed5f39ce4efb1cef500086e1c4352128eb90f93856c8d7f478245cf", + "size": 1328588, + "subdir": "linux-64", + "timestamp": 1505691376985, + "version": "1.1.13" + }, + "sqlalchemy-1.2.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "6cb9fb4b5e863fe66cf6dbd5bfc3f17b", + "name": "sqlalchemy", + "sha256": "7b2b0d2d2e8ca476081bebfc82534cd894631754e874a0419030f23a7eebca6f", + "size": 1361085, + "subdir": "linux-64", + "timestamp": 1515725072899, + "version": "1.2.0" + }, + "sqlalchemy-1.2.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "3a27100abfe4a0dcee862b055c97ad15", + "name": "sqlalchemy", + "sha256": "d75e9e5082f23e52bd34669a3ad260f37814ebd884a96e799a6ecef3e52f3415", + "size": 1390768, + "subdir": "linux-64", + "timestamp": 1515725295800, + "version": "1.2.0" + }, + "sqlalchemy-1.2.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0b4316afe70c60b178770557f304e8b4", + "name": "sqlalchemy", + "sha256": "1f428174baffaa6a5d6e45d7243479e76b45e97698c411a3b8a9f1503f3d554d", + "size": 1381489, + "subdir": "linux-64", + "timestamp": 1515725285325, + "version": "1.2.0" + }, + "sqlalchemy-1.2.1-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e63a62878fc2476be0ddc06d98ba0dc5", + "name": "sqlalchemy", + "sha256": "7c534c5f4eb33309560993f4a48689ed5628e72cbc28fb926dd87a72aaf2d94d", + "size": 1363330, + "subdir": "linux-64", + "timestamp": 1516376497809, + "version": "1.2.1" + }, + "sqlalchemy-1.2.1-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "886fb282e6a6d1d0bbd9143d6195e5a6", + "name": "sqlalchemy", + "sha256": "b8037145b32128c5c0861c6b988d049fd86977853b156ba97515954b2290ae15", + "size": 1408644, + "subdir": "linux-64", + "timestamp": 1516376766835, + "version": "1.2.1" + }, + "sqlalchemy-1.2.1-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "24b59db13b04ebed37f04932a542f34e", + "name": "sqlalchemy", + "sha256": "a2f10c6a514a8f9a0620a98e7f19371398a8b679753f4ff9df5a6ffb9f7de86d", + "size": 1381293, + "subdir": "linux-64", + "timestamp": 1516376758656, + "version": "1.2.1" + }, + "sqlalchemy-1.2.10-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b31bcf5dba865e5c1d5c452154a720a5", + "name": "sqlalchemy", + "sha256": "8978dd039dfb8e6f905ff2aebcc203c04ce63abb45c3d80f1e014351b9c70d7c", + "size": 1384247, + "subdir": "linux-64", + "timestamp": 1532459516475, + "version": "1.2.10" + }, + "sqlalchemy-1.2.10-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "2d01b70fefc35ef2c4e80573bdca24e4", + "name": "sqlalchemy", + "sha256": "c903cc267b9a392ddb232fe34a9b848f407ad1dd90d8c3727d8a33f39bed196a", + "size": 1413585, + "subdir": "linux-64", + "timestamp": 1532459443976, + "version": "1.2.10" + }, + "sqlalchemy-1.2.10-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "d397dfe9f91f9c9ccac000708cd6e527", + "name": "sqlalchemy", + "sha256": "885585778f4f9b38064c950fa5f3ef17a82b22bc8e97e3407b5c463448b4ff3e", + "size": 1403956, + "subdir": "linux-64", + "timestamp": 1532459501808, + "version": "1.2.10" + }, + "sqlalchemy-1.2.10-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e534d24c138a39490ed9306774b5b9d6", + "name": "sqlalchemy", + "sha256": "86412ba7f2d53b49a7b9df058388ecd4b13d28b742b720b969199a179809adf4", + "size": 1422376, + "subdir": "linux-64", + "timestamp": 1532459523301, + "version": "1.2.10" + }, + "sqlalchemy-1.2.11-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "f80fc3dcc55df9682b16d62f5c2a7980", + "name": "sqlalchemy", + "sha256": "e278d0795e9124de507778188725a4082826c80cffcf697d822b36a6b832d527", + "size": 1398509, + "subdir": "linux-64", + "timestamp": 1535379540967, + "version": "1.2.11" + }, + "sqlalchemy-1.2.11-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "d266f71bdc20dd77f6f80cdd5ba3965f", + "name": "sqlalchemy", + "sha256": "98168c94b193be6d78254fc9bedc2bfe70e8ce23cf8df2fb09e3f92b9fd0c74e", + "size": 1429252, + "subdir": "linux-64", + "timestamp": 1535379455276, + "version": "1.2.11" + }, + "sqlalchemy-1.2.11-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ff6cc4abfcd8b00275b5f97440748770", + "name": "sqlalchemy", + "sha256": "48a0d00a1dd7e6e1b9cea47b2dc8b921d9a898e33413eb4eae80ffeacd82db28", + "size": 1417239, + "subdir": "linux-64", + "timestamp": 1535379516283, + "version": "1.2.11" + }, + "sqlalchemy-1.2.11-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e865996ac923b1b7cc5df52958aa3ee2", + "name": "sqlalchemy", + "sha256": "97fed3916a624c1398f9510a4d4f4651a1c8c12cf46736a5f9aec4a3481d1299", + "size": 1418639, + "subdir": "linux-64", + "timestamp": 1535379552993, + "version": "1.2.11" + }, + "sqlalchemy-1.2.12-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e0a793f621fb30e55e9ebb08fb72bf64", + "name": "sqlalchemy", + "sha256": "f8b8309e0b56c880b1d1f9bcc5886a9bdeae042719d30dd53548260c2aa7d965", + "size": 1404690, + "subdir": "linux-64", + "timestamp": 1538157133605, + "version": "1.2.12" + }, + "sqlalchemy-1.2.12-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9e8d73cbeed6eeacba0de80fe7f12e78", + "name": "sqlalchemy", + "sha256": "96cc323ab2d6c80ca270d810415f081a2875af220031a7a2d44f0a1e1251660c", + "size": 1424837, + "subdir": "linux-64", + "timestamp": 1538157141480, + "version": "1.2.12" + }, + "sqlalchemy-1.2.12-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "1b8c8f75f1818ee4bae86c5b091e743a", + "name": "sqlalchemy", + "sha256": "83399bc8abbc4782dfe63527d2767507478c2fc0e132fa85c77c6e2da1bcff08", + "size": 1425119, + "subdir": "linux-64", + "timestamp": 1538157136035, + "version": "1.2.12" + }, + "sqlalchemy-1.2.13-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9d68ffa0293ec0b4eac0ae58dcb1720e", + "name": "sqlalchemy", + "sha256": "c0407519842242609888fc346646a2d9cf4be52b32acf5fa6619a0c9aede5491", + "size": 1405488, + "subdir": "linux-64", + "timestamp": 1541450168066, + "version": "1.2.13" + }, + "sqlalchemy-1.2.13-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e1e1d4d17f3068599ad8428c691d8699", + "name": "sqlalchemy", + "sha256": "6927ced914349801ced80e6120d38f7ef0608cea73605dc5830e0f19fdcd8ddb", + "size": 1408832, + "subdir": "linux-64", + "timestamp": 1541450207931, + "version": "1.2.13" + }, + "sqlalchemy-1.2.13-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7953969c88f19117c6ce454eeed44e57", + "name": "sqlalchemy", + "sha256": "9837e5e70d3fcac2d7933feb655cc3e41a31c5dae840418109271de8def5e885", + "size": 1409893, + "subdir": "linux-64", + "timestamp": 1541450175261, + "version": "1.2.13" + }, + "sqlalchemy-1.2.14-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9dac579b5b47765cc3543002fa9a9d75", + "name": "sqlalchemy", + "sha256": "69a8f49698f328da1aab2edde22175bbad00071d922f40ae6dd24735baed3704", + "size": 1387614, + "subdir": "linux-64", + "timestamp": 1542090471012, + "version": "1.2.14" + }, + "sqlalchemy-1.2.14-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "cbf02daa2bd3a627bb77e95a1aebc428", + "name": "sqlalchemy", + "sha256": "f7bf07167ad9b7e474724171d586f6cf0b4d16df32b296595cbcd7678eb0e80b", + "size": 1408907, + "subdir": "linux-64", + "timestamp": 1542090501750, + "version": "1.2.14" + }, + "sqlalchemy-1.2.14-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "42027395e3bddef8cfa6fcfe4b42f805", + "name": "sqlalchemy", + "sha256": "9422f94b590f8d5bcef7f4f34af5e2f4af8b13bb7f72a71f19bee0cd07d0d790", + "size": 1427741, + "subdir": "linux-64", + "timestamp": 1542090465445, + "version": "1.2.14" + }, + "sqlalchemy-1.2.15-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "def4378ac61b2b971a9844915b1a15f5", + "name": "sqlalchemy", + "sha256": "ca0ac642def92ef255958fa28b10bd0b73b89da0d27a97670fc473663ff601b2", + "size": 1390464, + "subdir": "linux-64", + "timestamp": 1545075325418, + "version": "1.2.15" + }, + "sqlalchemy-1.2.15-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1736f4f251de5d2f8f430b3c504cefdc", + "name": "sqlalchemy", + "sha256": "89cd15af76b311ec9493dc7c289d9eacc66d052c1968c6c365c2ce76aa454bc1", + "size": 1410325, + "subdir": "linux-64", + "timestamp": 1545075328855, + "version": "1.2.15" + }, + "sqlalchemy-1.2.15-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d6db600148f329298bfb80ddf2e54446", + "name": "sqlalchemy", + "sha256": "1a9138d1a09e7a0eec0a38050ddaaae659c311ae92ed59dcf5fcc16c49bcf5b3", + "size": 1428959, + "subdir": "linux-64", + "timestamp": 1545075329713, + "version": "1.2.15" + }, + "sqlalchemy-1.2.16-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "a11eb601a67c15c36cc5bb070f6814b2", + "name": "sqlalchemy", + "sha256": "f165b784b087a725edd890d6ec2f7e6041a6b56c7f78666f4fde429d3cacae82", + "size": 1415965, + "subdir": "linux-64", + "timestamp": 1547907654421, + "version": "1.2.16" + }, + "sqlalchemy-1.2.16-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7ca2a02c75e925de4f5b3ceeea336c5f", + "name": "sqlalchemy", + "sha256": "27bd252d790185ef2405d5ce105aed177dac362b8fc510dfbcbfada0ddd8f6ca", + "size": 1419409, + "subdir": "linux-64", + "timestamp": 1547907652825, + "version": "1.2.16" + }, + "sqlalchemy-1.2.16-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "9c5c58271d0920aadf514ef744867669", + "name": "sqlalchemy", + "sha256": "afeb3d14d1f55d715353963e53074fa69305ee1f4c9dee0f3015572cad0804e2", + "size": 1438038, + "subdir": "linux-64", + "timestamp": 1547907663598, + "version": "1.2.16" + }, + "sqlalchemy-1.2.17-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "e21b42e6b30a7a96f70a1b763ca60676", + "name": "sqlalchemy", + "sha256": "bfdc0bb9338996a7e8f6f50cd62b76e3092bfcec987239d087841cb3a7912761", + "size": 1394088, + "subdir": "linux-64", + "timestamp": 1549338052786, + "version": "1.2.17" + }, + "sqlalchemy-1.2.17-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3f11c7e4ce1b8c688c9681365e65619b", + "name": "sqlalchemy", + "sha256": "7cd2f27ff76ff349e2edcc7ff3f6dfe7b0cc6d9098b36db032eeeb31b32beec6", + "size": 1431792, + "subdir": "linux-64", + "timestamp": 1549328178036, + "version": "1.2.17" + }, + "sqlalchemy-1.2.17-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "08dc5e6af2d74c6e201cc53e6b8c392b", + "name": "sqlalchemy", + "sha256": "be8283693b7b5ae29ce5c27f6910f1c55e39d1d2db948b190cbb88f7d8914b8a", + "size": 1432063, + "subdir": "linux-64", + "timestamp": 1549328131611, + "version": "1.2.17" + }, + "sqlalchemy-1.2.18-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "03fbadaf5677ebe1a8159239a3a24fd4", + "name": "sqlalchemy", + "sha256": "cd14a3d0ff1c7332d68e829131234ab9c465043bdad5b9f7c77651a7e8efef7b", + "size": 1398721, + "subdir": "linux-64", + "timestamp": 1550363081280, + "version": "1.2.18" + }, + "sqlalchemy-1.2.18-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "60e2331bcf42d59034d9384b9cafb2ac", + "name": "sqlalchemy", + "sha256": "706b98aa758d4206f145ff5dbaf26e0feb3eb01b7aa457a3ccc658b279088fbd", + "size": 1436434, + "subdir": "linux-64", + "timestamp": 1550363102085, + "version": "1.2.18" + }, + "sqlalchemy-1.2.18-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4b2985ab956bc43c158d28e03abcb21c", + "name": "sqlalchemy", + "sha256": "1fc4f9be7506268acd981d31118ecf4de367eca00fbd841f1a40f770d18e8197", + "size": 1420281, + "subdir": "linux-64", + "timestamp": 1550363034135, + "version": "1.2.18" + }, + "sqlalchemy-1.2.3-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "9dbf0a2f87a7aad1b894c4919f221d6f", + "name": "sqlalchemy", + "sha256": "5b43f058602a82a364080a6765618fbcaf856abcfbb1219b1bde9abbe494348b", + "size": 1364512, + "subdir": "linux-64", + "timestamp": 1519139748676, + "version": "1.2.3" + }, + "sqlalchemy-1.2.3-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "3672d5d1c9c9e3381b75536dcaaeb67f", + "name": "sqlalchemy", + "sha256": "90ee2a5ee528212b53d5e8b562fccc22be0de6220d7d5d41f4a3fc79cac1f949", + "size": 1394977, + "subdir": "linux-64", + "timestamp": 1519139750951, + "version": "1.2.3" + }, + "sqlalchemy-1.2.3-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6cd3ee4397f43613ec68996d3e84cad4", + "name": "sqlalchemy", + "sha256": "b98b0d4842999bbcd903380ccf71d4636de633aea75f076584bcfa18dedb768b", + "size": 1401716, + "subdir": "linux-64", + "timestamp": 1519139843718, + "version": "1.2.3" + }, + "sqlalchemy-1.2.4-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "7f11e730271852a5a1482c2c80ad6b39", + "name": "sqlalchemy", + "sha256": "9c37166a4b47fb5476628349a65bfd48c1acf4d0ff07e32fb18b9042eaa4761a", + "size": 1382894, + "subdir": "linux-64", + "timestamp": 1519747717932, + "version": "1.2.4" + }, + "sqlalchemy-1.2.4-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "3110ff4830429e859aafc696e286a2af", + "name": "sqlalchemy", + "sha256": "a849bfb7440ca130f266ef2d00e795037e5acdc34cd798a440617969ebdb3326", + "size": 1395062, + "subdir": "linux-64", + "timestamp": 1519747777784, + "version": "1.2.4" + }, + "sqlalchemy-1.2.4-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4f9be3f33241bef918f8ea0232c2afbc", + "name": "sqlalchemy", + "sha256": "1e05963896fe5fa349e64cda9892b6f729993368775bacd4a22286715979862c", + "size": 1384640, + "subdir": "linux-64", + "timestamp": 1519747713828, + "version": "1.2.4" + }, + "sqlalchemy-1.2.5-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "d9cc7e0d48e2d56d671e799ca59749f0", + "name": "sqlalchemy", + "sha256": "78372c1910a73912d6e8ac88df0dfab007466c5251bd6ac0664c89e995218217", + "size": 1385590, + "subdir": "linux-64", + "timestamp": 1520973167440, + "version": "1.2.5" + }, + "sqlalchemy-1.2.5-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "5c2d243e1b369912750ee5e5a0f6c208", + "name": "sqlalchemy", + "sha256": "f25d3513ca9abbe8236c5a53cd21ba7791e10d5d58badc9a969db8687eda809d", + "size": 1396135, + "subdir": "linux-64", + "timestamp": 1520973174842, + "version": "1.2.5" + }, + "sqlalchemy-1.2.5-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "952644e301aa8549372bfb1b04fbc3ac", + "name": "sqlalchemy", + "sha256": "57f860c7920000e38ade4895679db6fc6f5a430d26bf6f37db5df9fcf548c9e8", + "size": 1403661, + "subdir": "linux-64", + "timestamp": 1520972981968, + "version": "1.2.5" + }, + "sqlalchemy-1.2.6-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "232c2f6262ebe8fd04350b72dc2fa729", + "name": "sqlalchemy", + "sha256": "0d9ef25630e268c776179498addc509f02c30f21f8e2204aab4acb751e475d46", + "size": 1384863, + "subdir": "linux-64", + "timestamp": 1522690128088, + "version": "1.2.6" + }, + "sqlalchemy-1.2.6-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "18cad3d844d9d4717ffd58f8c603edbb", + "name": "sqlalchemy", + "sha256": "7c340ca7e7def4ee7f44df5410db005a35fab7031f54ade0bb6fc5825434df37", + "size": 1416112, + "subdir": "linux-64", + "timestamp": 1522690348760, + "version": "1.2.6" + }, + "sqlalchemy-1.2.6-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f59bc74d97807ce2c2625ee71712c91b", + "name": "sqlalchemy", + "sha256": "4d43b3561a6270b626ea7521e08500e48df881513b6c5decd9a5c211290cb9a6", + "size": 1388454, + "subdir": "linux-64", + "timestamp": 1522690342697, + "version": "1.2.6" + }, + "sqlalchemy-1.2.7-py27h6b74fdf_0.conda": { + "build": "py27h6b74fdf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "cb2a2cbcbeeb129022ace6c7400cbe12", + "name": "sqlalchemy", + "sha256": "b88b987aa6fc698ae218880448a3bcc47f8a3024c59bbd181dc27c8a3c35e667", + "size": 1370759, + "subdir": "linux-64", + "timestamp": 1524496109593, + "version": "1.2.7" + }, + "sqlalchemy-1.2.7-py35h6b74fdf_0.conda": { + "build": "py35h6b74fdf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "51a7755aa63240e1884d8a1d96efc8c7", + "name": "sqlalchemy", + "sha256": "f79baa14a2072e8405dae7da5e86f287776e7dd1a6c7070cda471fa9c565f874", + "size": 1399808, + "subdir": "linux-64", + "timestamp": 1524496122699, + "version": "1.2.7" + }, + "sqlalchemy-1.2.7-py36h6b74fdf_0.conda": { + "build": "py36h6b74fdf_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9a3456f23644f22519f02fb1559ba8ae", + "name": "sqlalchemy", + "sha256": "28187bbc33129f5167355fcf4da249f931f82018f5ae4334f0685f97136aa1a6", + "size": 1407797, + "subdir": "linux-64", + "timestamp": 1524496002837, + "version": "1.2.7" + }, + "sqlalchemy-1.2.8-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "3e03d9e6dccd1e25c447e3f365380f25", + "name": "sqlalchemy", + "sha256": "04a6c83424faf61b92706d983094a5f2d308189eae9ff3d0bf97b7f73ccd72b1", + "size": 1394947, + "subdir": "linux-64", + "timestamp": 1527822704163, + "version": "1.2.8" + }, + "sqlalchemy-1.2.8-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "14ad49bf9580cd355f4302187dfcc9e8", + "name": "sqlalchemy", + "sha256": "c0e0f3b6c6a2046fb10b8a3c5fb1dd654790275a02d844e4bd1d9e640a3d18d5", + "size": 1425751, + "subdir": "linux-64", + "timestamp": 1527822729843, + "version": "1.2.8" + }, + "sqlalchemy-1.2.8-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "37bd554a63e807fbf8802875a8335503", + "name": "sqlalchemy", + "sha256": "36e69b2c9156a26c1b67b4b006ee380575f5a63763369298f1d8822b7c6748db", + "size": 1397219, + "subdir": "linux-64", + "timestamp": 1527822696882, + "version": "1.2.8" + }, + "sqlalchemy-1.2.8-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8938373ee98431df760bf2ef6bcd6f1b", + "name": "sqlalchemy", + "sha256": "da5b900ffd3cda8ab3b6acf5626a355ee7f6afa3add7fbdfb42651b9656a0935", + "size": 1399023, + "subdir": "linux-64", + "timestamp": 1530736394573, + "version": "1.2.8" + }, + "sqlalchemy-1.3.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "69b065b45c00eb0aad2dfab5d91ed7f6", + "name": "sqlalchemy", + "sha256": "69b39359541d7f2193a596f019c3e53c410343568d589127b66c7aa6351a5868", + "size": 1450220, + "subdir": "linux-64", + "timestamp": 1552327503886, + "version": "1.3.1" + }, + "sqlalchemy-1.3.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "b6faa36ec81715db11d39bc190eac47e", + "name": "sqlalchemy", + "sha256": "fc46ce975dd25a27fc9058e354858c989605bd605ef3ad8f25995d271eaf79c8", + "size": 1471005, + "subdir": "linux-64", + "timestamp": 1552327487540, + "version": "1.3.1" + }, + "sqlalchemy-1.3.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "67b7225a06d829e4143426709c7a050a", + "name": "sqlalchemy", + "sha256": "123374f25de2c67b86e4e01222a8191a75cf0474e147495513b776c2f2c538c8", + "size": 1454507, + "subdir": "linux-64", + "timestamp": 1552328457626, + "version": "1.3.1" + }, + "sqlalchemy-1.3.10-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "6db5a528badcec5e95e88e8b7ec82170", + "name": "sqlalchemy", + "sha256": "dcdaa2f302e3e30da59f40bdf367f03502438dafc7a75a3be01fa178d935e65e", + "size": 1474191, + "subdir": "linux-64", + "timestamp": 1571758665307, + "version": "1.3.10" + }, + "sqlalchemy-1.3.10-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "00774e7df7957b064930f38c06183977", + "name": "sqlalchemy", + "sha256": "d3bf5bb497d9847f967a4fe1b4a171364f8626fd91a4de9264061171fefc00f5", + "size": 1494053, + "subdir": "linux-64", + "timestamp": 1571758666343, + "version": "1.3.10" + }, + "sqlalchemy-1.3.10-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "63134c2e649cc2037258a86ee13b2802", + "name": "sqlalchemy", + "sha256": "e284547b4e5b43bf4b35cdb3d9f126b591de71dc3cf64ecfdefe9c48c2ac5bc3", + "size": 1495690, + "subdir": "linux-64", + "timestamp": 1571758667493, + "version": "1.3.10" + }, + "sqlalchemy-1.3.10-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "8ab50f557fb3741dac39191e6993154f", + "name": "sqlalchemy", + "sha256": "4ea4e550e5b673962e3305f313a32e898adb09da574f62f3f47e4da0a2de9b54", + "size": 1513117, + "subdir": "linux-64", + "timestamp": 1573661794351, + "version": "1.3.10" + }, + "sqlalchemy-1.3.11-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "ec4eb3e2bcae40f9f908315f90b57747", + "name": "sqlalchemy", + "sha256": "208abd72459c66ae390f4c39a6b71127d94ecb3cb4bb2d99c38126aa9a8408b7", + "size": 1487008, + "subdir": "linux-64", + "timestamp": 1573942441512, + "version": "1.3.11" + }, + "sqlalchemy-1.3.11-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a9368db3a8a3ce55f14a0094a255bbd3", + "name": "sqlalchemy", + "sha256": "aa717b59476058def536e259a22822540db6da685b55aa99a295f17b4bca6085", + "size": 1507264, + "subdir": "linux-64", + "timestamp": 1573942442907, + "version": "1.3.11" + }, + "sqlalchemy-1.3.11-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f760d87af825d8178cf5e9b593f50143", + "name": "sqlalchemy", + "sha256": "9b4c5246ee880ce896bace469b3135bf633e25030b8ddffe2c16edf67d14199b", + "size": 1508729, + "subdir": "linux-64", + "timestamp": 1573942429299, + "version": "1.3.11" + }, + "sqlalchemy-1.3.11-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "61cf6755324a1d86ef3305c9f82b92fe", + "name": "sqlalchemy", + "sha256": "68c4a9ebefd090fe0e5ea16a77c5a1882ecb3e5c867a5e2bd9d9e6cc0eeded18", + "size": 1531497, + "subdir": "linux-64", + "timestamp": 1573942478613, + "version": "1.3.11" + }, + "sqlalchemy-1.3.12-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b1a440449cc2ea0f1289f4eb0a83d69b", + "name": "sqlalchemy", + "sha256": "6e26c1f4f8b424d321b609bfe9af8122db27daec9291c3a18e16b19a1e69c810", + "size": 1491682, + "subdir": "linux-64", + "timestamp": 1578414465311, + "version": "1.3.12" + }, + "sqlalchemy-1.3.12-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "cc06481481e70ba224f6739d173a8777", + "name": "sqlalchemy", + "sha256": "f47dc592fd92fdf508d541cce515f9b44034789cf51e48b69519c84b22a65e44", + "size": 1493665, + "subdir": "linux-64", + "timestamp": 1578414532804, + "version": "1.3.12" + }, + "sqlalchemy-1.3.12-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d9c7e10b46b6b7c581e9e634dc754c76", + "name": "sqlalchemy", + "sha256": "8b74a4e10acc94dd20abc29f4caa986c7e9a4f61c080a81bf589bab43c64c6e8", + "size": 1513667, + "subdir": "linux-64", + "timestamp": 1578414518417, + "version": "1.3.12" + }, + "sqlalchemy-1.3.12-py37heee7806_0.conda": { + "build": "py37heee7806_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f01f7dab387b33843b493ce8766fd690", + "name": "sqlalchemy", + "sha256": "cb8253324c4a3296f89087f75ca519e25287bf77307dbb8191920b2d506bd7d5", + "size": 1513751, + "subdir": "linux-64", + "timestamp": 1635955341942, + "version": "1.3.12" + }, + "sqlalchemy-1.3.12-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "fe8b49edc4fe77ee7e3a3457cfe9c2c4", + "name": "sqlalchemy", + "sha256": "f2f6f0f7cbeb5fd1303d81d916d44fdb7223bc154a5cea954e4d779e96c38d8f", + "size": 1516826, + "subdir": "linux-64", + "timestamp": 1578414518374, + "version": "1.3.12" + }, + "sqlalchemy-1.3.12-py38heee7806_0.conda": { + "build": "py38heee7806_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "2c020abc6389981590abc43dda844a88", + "name": "sqlalchemy", + "sha256": "36e67fb592134bb4e3540894770c2604afc9271b09d6bc00668fb9cd6900c374", + "size": 1529049, + "subdir": "linux-64", + "timestamp": 1635955338708, + "version": "1.3.12" + }, + "sqlalchemy-1.3.12-py39heee7806_0.conda": { + "build": "py39heee7806_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "c7551a7e688644b8cbc1796dea7e0ca2", + "name": "sqlalchemy", + "sha256": "b97f6de811030a9481fba035179a597b29e6ce43173ea91ad5bdd78268877d26", + "size": 1528327, + "subdir": "linux-64", + "timestamp": 1635943365566, + "version": "1.3.12" + }, + "sqlalchemy-1.3.13-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "34506b0919d861f8657a667fdac14921", + "name": "sqlalchemy", + "sha256": "9f2668f381aabc9012e2a987f14394f7c7f8ad68573820df8d322e963d444799", + "size": 1498259, + "subdir": "linux-64", + "timestamp": 1580151909354, + "version": "1.3.13" + }, + "sqlalchemy-1.3.13-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "9e1c66e03b667ac02e78a3b1e2b59443", + "name": "sqlalchemy", + "sha256": "f58a9278527a3e140359d7137f072d56489bdd63e74f6f3658fa114ae726c679", + "size": 1517651, + "subdir": "linux-64", + "timestamp": 1580151858061, + "version": "1.3.13" + }, + "sqlalchemy-1.3.13-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "c5318c4ead35919d01c2aafc6b73fe37", + "name": "sqlalchemy", + "sha256": "b5118cac8355718cb624459ae6967fcb9b2469ef75ed97031466028e29da8554", + "size": 1533150, + "subdir": "linux-64", + "timestamp": 1580151884284, + "version": "1.3.13" + }, + "sqlalchemy-1.3.15-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6476c684a589c65821066db82f362838", + "name": "sqlalchemy", + "sha256": "678f27d156942b0b2511294d57d52a27555b494628a140e40d514fef21e6f1f9", + "size": 1528843, + "subdir": "linux-64", + "timestamp": 1584458815195, + "version": "1.3.15" + }, + "sqlalchemy-1.3.15-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "60c9af0b65b4c50ca7ffc4fcbd9e4b44", + "name": "sqlalchemy", + "sha256": "5767b9886b7a9b4cf27f1f138483cd45b11d513502c6eb65bbd024c25e3c218a", + "size": 1508859, + "subdir": "linux-64", + "timestamp": 1584458812088, + "version": "1.3.15" + }, + "sqlalchemy-1.3.15-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "a9ec61382266d69e8a5fd4748176a89b", + "name": "sqlalchemy", + "sha256": "a55ac3d325f71f20f233dadebd25d01ba6805502dcd6220c79696fc7ea244258", + "size": 1525820, + "subdir": "linux-64", + "timestamp": 1584458812467, + "version": "1.3.15" + }, + "sqlalchemy-1.3.16-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ad4f83f5d612d3c2d2eaf597b2b80894", + "name": "sqlalchemy", + "sha256": "092fb11fe890bb83a8e7381ef9371c9fe4b34c0195dd2b40c27904d937b8d2bc", + "size": 1537862, + "subdir": "linux-64", + "timestamp": 1587134357183, + "version": "1.3.16" + }, + "sqlalchemy-1.3.16-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ef6bfc427df2bea1a7cb0332a0183044", + "name": "sqlalchemy", + "sha256": "2d4e28f5b45980056d7c2000ce24c8dff04f99a621798aded904267094bda49b", + "size": 1539616, + "subdir": "linux-64", + "timestamp": 1587134358854, + "version": "1.3.16" + }, + "sqlalchemy-1.3.16-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "155cb31d2d2e2c572277330568981e50", + "name": "sqlalchemy", + "sha256": "415e2657ce641559e8992e947376e8fe6d1cd28831740a4042b36474caac2fb8", + "size": 1555958, + "subdir": "linux-64", + "timestamp": 1587134379051, + "version": "1.3.16" + }, + "sqlalchemy-1.3.17-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1013c0b1d72de6ad50dd91f403c98ce8", + "name": "sqlalchemy", + "sha256": "1ddc5fb94308e5c66e492741c03d0467e3589fc47f7e16b31ecf6ab4cb567a62", + "size": 1525927, + "subdir": "linux-64", + "timestamp": 1590085091542, + "version": "1.3.17" + }, + "sqlalchemy-1.3.17-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "bee99aa836a606cb05b86e123753a2d8", + "name": "sqlalchemy", + "sha256": "18c1c1e386565bd46c35683d8768d6f0c6c67fa17c47f61988a93931e7d11d91", + "size": 1524259, + "subdir": "linux-64", + "timestamp": 1590085087877, + "version": "1.3.17" + }, + "sqlalchemy-1.3.17-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "0e6019834b7a479cd626677457451009", + "name": "sqlalchemy", + "sha256": "58f7d782c1f26f9f5189b1a8c1c0a5270c45a673fd8ac1730998e7f0fea04b05", + "size": 1561314, + "subdir": "linux-64", + "timestamp": 1590085083608, + "version": "1.3.17" + }, + "sqlalchemy-1.3.18-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "79fd8717e7861010540dca7241ee5715", + "name": "sqlalchemy", + "sha256": "296c7c695c3e6c829e701b03afa06f4a9f10a9ab47b86c2b5b332b00a80c5ffc", + "size": 1528127, + "subdir": "linux-64", + "timestamp": 1593446372810, + "version": "1.3.18" + }, + "sqlalchemy-1.3.18-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8b4f028e450eddc27f94c856d0ef456b", + "name": "sqlalchemy", + "sha256": "603a876b732553312bdd1fbc5ac35565808b6016482d9ea20fbf30717c32df4e", + "size": 1549696, + "subdir": "linux-64", + "timestamp": 1593446339578, + "version": "1.3.18" + }, + "sqlalchemy-1.3.18-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "a12cc45b38b198f3483334531e3c82c1", + "name": "sqlalchemy", + "sha256": "84d2aaf5c34caa82a4a094d7fdff1b2b1b9b7499917b217e3d4f63ca7395e94a", + "size": 1565917, + "subdir": "linux-64", + "timestamp": 1593446341544, + "version": "1.3.18" + }, + "sqlalchemy-1.3.19-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ed48b3b816fe7b9233a7dd0b123aaab6", + "name": "sqlalchemy", + "sha256": "debf547297e683d814a2cf8da1a97c9bf49fb31df35fcb2c792818839f598766", + "size": 1531583, + "subdir": "linux-64", + "timestamp": 1598374812373, + "version": "1.3.19" + }, + "sqlalchemy-1.3.19-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "90ebd0ce8d526eec86af1b7e1219f181", + "name": "sqlalchemy", + "sha256": "33f504b2282cdc853f5a379b647bba5eb2ed92c7657e71e548818e7ad793f004", + "size": 1546008, + "subdir": "linux-64", + "timestamp": 1597768544499, + "version": "1.3.19" + }, + "sqlalchemy-1.3.19-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "ccab699ceb587f60388584f172c46a0d", + "name": "sqlalchemy", + "sha256": "59dd49e06bbb0dac1896ae76e7e4bd220b19f0c228a7b16790cb7eacf21f2203", + "size": 1553572, + "subdir": "linux-64", + "timestamp": 1598374774293, + "version": "1.3.19" + }, + "sqlalchemy-1.3.19-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "ceb51c9a4dc5a08ba5ddb77399715f04", + "name": "sqlalchemy", + "sha256": "f356a1fda5885d9120746bd3592197a0dbccbcb822e3a402d2b60caa1caa0bf8", + "size": 1547963, + "subdir": "linux-64", + "timestamp": 1598374772974, + "version": "1.3.19" + }, + "sqlalchemy-1.3.20-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "158e70869e7544efd0b2e484fcd12ccb", + "name": "sqlalchemy", + "sha256": "5288dd70ada10e25b63fa58fce9b11d8b16081e8ea2ab2e87e75e7416f4cd03c", + "size": 1528748, + "subdir": "linux-64", + "timestamp": 1603398054413, + "version": "1.3.20" + }, + "sqlalchemy-1.3.20-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "6a23eda82e169b2be17c8b8644174c1e", + "name": "sqlalchemy", + "sha256": "23dd96a93b789b8e092ac3069e0242e27b59d10bb8dd88e324636d174558c9d1", + "size": 1530961, + "subdir": "linux-64", + "timestamp": 1603810460502, + "version": "1.3.20" + }, + "sqlalchemy-1.3.20-py37he8ac12f_0.conda": { + "build": "py37he8ac12f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8ee6d1b9ff94273de7a50c12415f902a", + "name": "sqlalchemy", + "sha256": "e9e98a0ded0a5cd908c6a28eb129f8434ffc972b03f3508e2fe1d3bd4b9f0c70", + "size": 1537163, + "subdir": "linux-64", + "timestamp": 1607563742264, + "version": "1.3.20" + }, + "sqlalchemy-1.3.20-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "3bf84f2db7c4263c54b5addf8e05c4cc", + "name": "sqlalchemy", + "sha256": "1e1744de0e3ba1b3c75e9eaba70d074cc4fc8774b6ef0b696e6b24591e8d5d80", + "size": 1545064, + "subdir": "linux-64", + "timestamp": 1603398030368, + "version": "1.3.20" + }, + "sqlalchemy-1.3.20-py39he8ac12f_0.conda": { + "build": "py39he8ac12f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "cfeff2ed2981f0479d467bcd2a775376", + "name": "sqlalchemy", + "sha256": "a30895de6c65ca9a106697b2612cfbe8e3267bb89c0ec73ee64639bb64ed2b54", + "size": 1571365, + "subdir": "linux-64", + "timestamp": 1607563783023, + "version": "1.3.20" + }, + "sqlalchemy-1.3.21-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "30aaa507e71be2f1ef348c9c80a7eda0", + "name": "sqlalchemy", + "sha256": "7db99818b6bc0f765854d8271b23ed2feff7eb89ef0562b317177f88b42c031f", + "size": 1553797, + "subdir": "linux-64", + "timestamp": 1608243777818, + "version": "1.3.21" + }, + "sqlalchemy-1.3.21-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "43dedf078ab5d0879d22236a76bd832a", + "name": "sqlalchemy", + "sha256": "d4d60b08f9d603092c8e2f4efa30952bc103411ef3606da0352f64435c9dc1d2", + "size": 1555220, + "subdir": "linux-64", + "timestamp": 1608243803010, + "version": "1.3.21" + }, + "sqlalchemy-1.3.21-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "b75fe7e208f5a0df01e608c86c4855a7", + "name": "sqlalchemy", + "sha256": "aabc754b2055c1ae397bde39cf1d714d3d35b08e833e3a14a94348a8daa81be9", + "size": 1551542, + "subdir": "linux-64", + "timestamp": 1608243754176, + "version": "1.3.21" + }, + "sqlalchemy-1.3.21-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "083f15afeaa7ee3a83ef4e36a3296aff", + "name": "sqlalchemy", + "sha256": "c4d9bd690da0fa891ee14343aa7f67de3ced1d3c77d1960f96a19f2c55406683", + "size": 1569743, + "subdir": "linux-64", + "timestamp": 1608243785816, + "version": "1.3.21" + }, + "sqlalchemy-1.3.23-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "ff8caed36acf9baa90091bf1ac1b33d4", + "name": "sqlalchemy", + "sha256": "770840b9baf1097a1d5dcd27f83c71ab1a0b9eacb1e0a944ab7d7acf1ad1565f", + "size": 1540588, + "subdir": "linux-64", + "timestamp": 1612467270759, + "version": "1.3.23" + }, + "sqlalchemy-1.3.23-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2735db8ef0248df3e21603ae90840a43", + "name": "sqlalchemy", + "sha256": "7dead4accea49db4e6c1e821b5011d0a2eba43bb16397580ce08a72ca6786521", + "size": 1560071, + "subdir": "linux-64", + "timestamp": 1612467612138, + "version": "1.3.23" + }, + "sqlalchemy-1.3.23-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "a965101eaf54be8411057ed6bf7e95ed", + "name": "sqlalchemy", + "sha256": "cabf4502cfa99146535dc2e186f56e3ed9ce2e5785524dc7762b73095f639a23", + "size": 1574835, + "subdir": "linux-64", + "timestamp": 1612467605260, + "version": "1.3.23" + }, + "sqlalchemy-1.3.23-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "ecc33bbb76eb0a6128c8d8c0cd4019a2", + "name": "sqlalchemy", + "sha256": "c8139ae1785dd3939d316edc16b1704843e98fb50411dcc012fd54fb5c4dab78", + "size": 1574790, + "subdir": "linux-64", + "timestamp": 1612467506459, + "version": "1.3.23" + }, + "sqlalchemy-1.3.3-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "956d26229782baf2baf0bd2a858c19a1", + "name": "sqlalchemy", + "sha256": "c52125e01ceca1c5cc2e7691b29cb7274252bb6ce9040e660e85be72b2554bb9", + "size": 1453820, + "subdir": "linux-64", + "timestamp": 1555429535800, + "version": "1.3.3" + }, + "sqlalchemy-1.3.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f04892ea82318520c45225ade929258e", + "name": "sqlalchemy", + "sha256": "bb4ff5a49ab94e815c6d294daa03e90cadb08751517744f28ade689258ccd02b", + "size": 1473968, + "subdir": "linux-64", + "timestamp": 1555429540095, + "version": "1.3.3" + }, + "sqlalchemy-1.3.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "bb529f5d87140f86e7ba572b21db9264", + "name": "sqlalchemy", + "sha256": "3bc772ed7cb82ec70bf3b83adfaef1675a8628ddb8ecba64b309555094721c46", + "size": 1474202, + "subdir": "linux-64", + "timestamp": 1555429508562, + "version": "1.3.3" + }, + "sqlalchemy-1.3.4-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "29f348b568f426e42c9bbb3ca72d4184", + "name": "sqlalchemy", + "sha256": "5d467ec129dab0681422ab0c4efc939921af9abff3d1a395b996f471d1d08dce", + "size": 1455163, + "subdir": "linux-64", + "timestamp": 1559849469674, + "version": "1.3.4" + }, + "sqlalchemy-1.3.4-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "7276d7f7ef084a806ec063dd0672a2ae", + "name": "sqlalchemy", + "sha256": "0f7d5d49542e1344f2a166b5f1ddbaef1783eac14f0a0f48815dee30e0f400fe", + "size": 1474925, + "subdir": "linux-64", + "timestamp": 1559849505722, + "version": "1.3.4" + }, + "sqlalchemy-1.3.4-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b3cabe4e63956a5ebf5c06ad666c4878", + "name": "sqlalchemy", + "sha256": "7fbdae7470b269600b7eb64b4107c5a98f8c4eadb42245dee0eb1bf36727a27a", + "size": 1456799, + "subdir": "linux-64", + "timestamp": 1559849676478, + "version": "1.3.4" + }, + "sqlalchemy-1.3.5-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "6f22ae896e05f991d255afdcbb01efa8", + "name": "sqlalchemy", + "sha256": "b4acaa023d094fa53cc426a12edaba36d73f0b6531ee13b02c625cb932e590e1", + "size": 1437612, + "subdir": "linux-64", + "timestamp": 1562084763597, + "version": "1.3.5" + }, + "sqlalchemy-1.3.5-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "27a373841a7d9e89853b0bda3e2f862a", + "name": "sqlalchemy", + "sha256": "481f0f2a7e840cb842b2904758b856a7ac8658ef7890e3cfed1908a866e4069e", + "size": 1458402, + "subdir": "linux-64", + "timestamp": 1562084762821, + "version": "1.3.5" + }, + "sqlalchemy-1.3.5-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "5746a5978f554ab9afd2e2530a9cbd85", + "name": "sqlalchemy", + "sha256": "93305424ca37748bf1ec32a17e0b435adc963f6483087560dcfa38cae74ee5ba", + "size": 1460290, + "subdir": "linux-64", + "timestamp": 1562084746961, + "version": "1.3.5" + }, + "sqlalchemy-1.3.7-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "6ac082bbb65e9fc2fc132fdbfc49f49e", + "name": "sqlalchemy", + "sha256": "fddabb8e86b0c8ebea11a5860afc8f5483928c0581e160a6094f82659f1fdb21", + "size": 1445224, + "subdir": "linux-64", + "timestamp": 1565965430356, + "version": "1.3.7" + }, + "sqlalchemy-1.3.7-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3e4292288312cb18616a94ca9f92b65b", + "name": "sqlalchemy", + "sha256": "9e0e12ff35a48410ab3babc9c9d19728de80e2efd9476670ed8a5306bb9b5158", + "size": 1484070, + "subdir": "linux-64", + "timestamp": 1565967084813, + "version": "1.3.7" + }, + "sqlalchemy-1.3.7-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "efb0b6259da9a736cb2042bf7c602f31", + "name": "sqlalchemy", + "sha256": "4651015ed49d2ce894743e0d8e1c3d0bc0dc4cb5bcf968745450b104c5bd1d7c", + "size": 1467098, + "subdir": "linux-64", + "timestamp": 1565965429121, + "version": "1.3.7" + }, + "sqlalchemy-1.3.8-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "97f276e80a02dd2377be1b765191b380", + "name": "sqlalchemy", + "sha256": "8d487275b199d9b0563735f947ea16df36f9730abcce86a00abbc2f3bbe9398e", + "size": 1468758, + "subdir": "linux-64", + "timestamp": 1569332513717, + "version": "1.3.8" + }, + "sqlalchemy-1.3.8-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c7bca7002e8736a12c5251316b7a1a87", + "name": "sqlalchemy", + "sha256": "42a66f3786b4c7f216e773a94b5a09d4374ccb086489dc88457a5a1f615143ec", + "size": 1487529, + "subdir": "linux-64", + "timestamp": 1569332514469, + "version": "1.3.8" + }, + "sqlalchemy-1.3.8-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "02db6baaf21dab6ba91adc1396b453ca", + "name": "sqlalchemy", + "sha256": "1b3107bb7be7c788c2917421b66dc690565c19505e2b07a2eb4fbe3e50545e62", + "size": 1488490, + "subdir": "linux-64", + "timestamp": 1569332484417, + "version": "1.3.8" + }, + "sqlalchemy-1.3.9-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "055d44392f26636a0151f500a5d71c72", + "name": "sqlalchemy", + "sha256": "aea7d3e6ceea50b086f02eb3e260157513ae1b26c5a7b61b7ae82dd90ebebc32", + "size": 1473090, + "subdir": "linux-64", + "timestamp": 1570464452096, + "version": "1.3.9" + }, + "sqlalchemy-1.3.9-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3236f15710fba0a455cdc8ea2e9347bf", + "name": "sqlalchemy", + "sha256": "3aa9952b144101b71f51ca9055083811b4fca809ab0da1fdd7e268ffcd0d5dda", + "size": 1495528, + "subdir": "linux-64", + "timestamp": 1570464452294, + "version": "1.3.9" + }, + "sqlalchemy-1.3.9-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4c32bae74054c0dda98e9ba42b5280b9", + "name": "sqlalchemy", + "sha256": "321798c38542a0ee108f8a0de442b63fc42379992120b5ef35e30812fcd052cd", + "size": 1495221, + "subdir": "linux-64", + "timestamp": 1570464470361, + "version": "1.3.9" + }, + "sqlalchemy-1.4.15-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e55d83b315e69cdd887edd1a3e44427d", + "name": "sqlalchemy", + "sha256": "64d474e69a6535b999689d1ad1b7afb7aba57c7b5e647c2ab94d97405bed8248", + "size": 1894967, + "subdir": "linux-64", + "timestamp": 1620712484790, + "version": "1.4.15" + }, + "sqlalchemy-1.4.15-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "7d5625519fab0fdfb29214db3eb12f9f", + "name": "sqlalchemy", + "sha256": "7845c61d79992a28e8403b2d4ec9f11fcb24ddadfcc02e1ef7051ad1c6c5f28a", + "size": 1897815, + "subdir": "linux-64", + "timestamp": 1620712479152, + "version": "1.4.15" + }, + "sqlalchemy-1.4.15-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "210a28cb08237098f135879be8fdeb2a", + "name": "sqlalchemy", + "sha256": "9f1ff6a4a023f45cdff5590a13c3603f949730a6fdf32b075c1101c376e7ffea", + "size": 1918990, + "subdir": "linux-64", + "timestamp": 1620712486829, + "version": "1.4.15" + }, + "sqlalchemy-1.4.15-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "22f5c3a61be711d88a352322f7f9208e", + "name": "sqlalchemy", + "sha256": "5d0cea73ac26ff32585b120ff21516d1fa20049177ad3224ffd58f80dc39acfb", + "size": 1894561, + "subdir": "linux-64", + "timestamp": 1620708207030, + "version": "1.4.15" + }, + "sqlalchemy-1.4.19-py36h7f8727e_0.conda": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34f8d521c0c13f40aa912c49f24478e3", + "name": "sqlalchemy", + "sha256": "0f0bb03e10ee8db0d2bee6afafed2c03c89fb4095ac9e84a8eb7c4ddbd7318fa", + "size": 2345972, + "subdir": "linux-64", + "timestamp": 1624590501151, + "version": "1.4.19" + }, + "sqlalchemy-1.4.19-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "100bf684d8a37d0476e49bc0b3c5c9e9", + "name": "sqlalchemy", + "sha256": "e7b72724ae6479a5f872995e40223b8444362e2dfdb526686f9aa50aa7d97569", + "size": 2279339, + "subdir": "linux-64", + "timestamp": 1624590509299, + "version": "1.4.19" + }, + "sqlalchemy-1.4.19-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f0d475252780c5afa59375363a56dc3", + "name": "sqlalchemy", + "sha256": "777e169df8eb35cbb63431eef368153579b1f40b29d69807dc0c93b0b8844383", + "size": 2123861, + "subdir": "linux-64", + "timestamp": 1624584251247, + "version": "1.4.19" + }, + "sqlalchemy-1.4.19-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0e7fd519f9cf28e84962007df84c198", + "name": "sqlalchemy", + "sha256": "7ed0c0932bcabe9b4828e2d4edddee9aa8ad9809c1702c3611e9de209ca7f792", + "size": 1924939, + "subdir": "linux-64", + "timestamp": 1624590246090, + "version": "1.4.19" + }, + "sqlalchemy-1.4.21-py36h7f8727e_0.conda": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9976b2660e5781b635d04a6750c87ab7", + "name": "sqlalchemy", + "sha256": "3fa4e5718847270a0443469baecd7427315d74cb0afd98a6d8c7bdd320c650c2", + "size": 2389802, + "subdir": "linux-64", + "timestamp": 1626318175710, + "version": "1.4.21" + }, + "sqlalchemy-1.4.21-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d840488b7794e3566049af6fae841127", + "name": "sqlalchemy", + "sha256": "de1320231ec8767fc5956b2e942fdc3faa56783c5f550af09083d05877c9682f", + "size": 2284929, + "subdir": "linux-64", + "timestamp": 1626325264422, + "version": "1.4.21" + }, + "sqlalchemy-1.4.21-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "04a369ae41157aa3b8e79d937c062c91", + "name": "sqlalchemy", + "sha256": "3fcc2e1a7170f5223bed30f507f91ce6c087a9ad930d5bd9fbea32ed95c6cc6e", + "size": 2173025, + "subdir": "linux-64", + "timestamp": 1626325262436, + "version": "1.4.21" + }, + "sqlalchemy-1.4.21-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c088ce638b95f2be5997cff80cc6b638", + "name": "sqlalchemy", + "sha256": "f1aa67fe88dbc1e65a71f3c874b2c4a129e840b858259282864e7487422694d7", + "size": 1931406, + "subdir": "linux-64", + "timestamp": 1626325269090, + "version": "1.4.21" + }, + "sqlalchemy-1.4.22-py36h7f8727e_0.conda": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d04af6e2af20319dfc615f16cc254b7", + "name": "sqlalchemy", + "sha256": "a227a315dd9779221b02c53b18624f2f9f13ed6da45988bc151b24bbcf558cc3", + "size": 1888514, + "subdir": "linux-64", + "timestamp": 1626948505698, + "version": "1.4.22" + }, + "sqlalchemy-1.4.22-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7984a5dd0766253c48ac0265c9454598", + "name": "sqlalchemy", + "sha256": "b948c2846b66d8492371d4cae458b98c38a3d9b15b6c9498041e5a9ef91c2b65", + "size": 1890610, + "subdir": "linux-64", + "timestamp": 1626948491130, + "version": "1.4.22" + }, + "sqlalchemy-1.4.22-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "081d18f111454ead5652608266141fbf", + "name": "sqlalchemy", + "sha256": "7b66c13b4bb8ebc1ed401d61bf008eb3100fc0fd39681c42a154dcd964bd3ab9", + "size": 1909503, + "subdir": "linux-64", + "timestamp": 1626941069316, + "version": "1.4.22" + }, + "sqlalchemy-1.4.22-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0a2f9ead3c5355022a783fa2c6aa537b", + "name": "sqlalchemy", + "sha256": "f1319629483fd6748915548bf985b08b590062a74c01338fa712de6f62c97836", + "size": 1908864, + "subdir": "linux-64", + "timestamp": 1626947945723, + "version": "1.4.22" + }, + "sqlalchemy-1.4.27-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e6d173224c7cfcf6521601a1236c8489", + "name": "sqlalchemy", + "sha256": "68e3c6b3398c1eef34f5cfee0d186c165f6e2412bbf6d5c6ec63a7b4fdb92c2b", + "size": 2019226, + "subdir": "linux-64", + "timestamp": 1640794881040, + "version": "1.4.27" + }, + "sqlalchemy-1.4.27-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb087bfa7501113d3ad8eba2f7d2b4dd", + "name": "sqlalchemy", + "sha256": "769589aae55736cc921faa8834b4096709de5bfe5e7bb853cc56d9257ee13930", + "size": 1944130, + "subdir": "linux-64", + "timestamp": 1638290712911, + "version": "1.4.27" + }, + "sqlalchemy-1.4.27-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7807d818bca24aa37602a543df4eee3b", + "name": "sqlalchemy", + "sha256": "002e1ef8a3cc7f9562fa70b2691cd5214a0c9581a49205065ee6bdda1f4e5424", + "size": 1965169, + "subdir": "linux-64", + "timestamp": 1638290713486, + "version": "1.4.27" + }, + "sqlalchemy-1.4.27-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "604d31ce15738f1b20e23cbfb04de038", + "name": "sqlalchemy", + "sha256": "6ab2a406eeef4bc4e838eae1ca16cd88c475ae2c10d99f58613c0a86213ca4d1", + "size": 1939054, + "subdir": "linux-64", + "timestamp": 1638277569574, + "version": "1.4.27" + }, + "sqlalchemy-1.4.3-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "6ece8b7f26a4102cbf5daa7d1a028505", + "name": "sqlalchemy", + "sha256": "9b845b025804ee69388c8a4ee5596da2dfa4df3e46e1bca507c338f3b8f8a625", + "size": 1868758, + "subdir": "linux-64", + "timestamp": 1617216991130, + "version": "1.4.3" + }, + "sqlalchemy-1.4.3-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "afbda0196bddcd98ff3a9d0047128488", + "name": "sqlalchemy", + "sha256": "572ae86513e479d129057da3165d5b93d07930f7c8e495bcda20aaa918e16e35", + "size": 1869007, + "subdir": "linux-64", + "timestamp": 1617216217178, + "version": "1.4.3" + }, + "sqlalchemy-1.4.3-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "e80f85512f7102433bbc59538aed6831", + "name": "sqlalchemy", + "sha256": "ee82b389a21685c918f206d3a7dde27bd3bc4b1e8c76f012eb24ecb5f6277fe9", + "size": 1890553, + "subdir": "linux-64", + "timestamp": 1617214486163, + "version": "1.4.3" + }, + "sqlalchemy-1.4.3-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "d586eea028671c207247e560d3aab7db", + "name": "sqlalchemy", + "sha256": "83ec4eeb326ffce680e67d3aec13d55a98cd9d92944ad1023b45246d2770786f", + "size": 1866172, + "subdir": "linux-64", + "timestamp": 1617216990234, + "version": "1.4.3" + }, + "sqlalchemy-1.4.32-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c850a8cf897ac8b840e3442a65a0c94", + "name": "sqlalchemy", + "sha256": "2ab39e06cc6d23e7b6219933dc953ba8284903c45e371d8d036ddcc786442c95", + "size": 2023157, + "subdir": "linux-64", + "timestamp": 1647599869742, + "version": "1.4.32" + }, + "sqlalchemy-1.4.32-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "837f4e4d98ccd516529503a3e0e69b95", + "name": "sqlalchemy", + "sha256": "30dc22bc5692f9310d29f6348e40fe9101177e0ef05decb1a1e248f43181cc37", + "size": 1967930, + "subdir": "linux-64", + "timestamp": 1647581987329, + "version": "1.4.32" + }, + "sqlalchemy-1.4.32-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4206caa9ed7f045bbf1fde92917cce77", + "name": "sqlalchemy", + "sha256": "fabf5aaf18fb8180c8c820c07aa8970821b5d4af0e3886a3d26a85c5006aaf39", + "size": 1990303, + "subdir": "linux-64", + "timestamp": 1647599849849, + "version": "1.4.32" + }, + "sqlalchemy-1.4.32-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2d0704fb4eae9c08375d72b43f1d24fa", + "name": "sqlalchemy", + "sha256": "63fcf2740a79b6e68d53bbe0e06896a6a83565064fb8da0b10f357fc019b7b1a", + "size": 1966292, + "subdir": "linux-64", + "timestamp": 1647581723658, + "version": "1.4.32" + }, + "sqlalchemy-1.4.39-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1ae09f4f063ac2f3b1e037e5102f6bff", + "name": "sqlalchemy", + "sha256": "c114a98ad01a0224b04d811f38cf8129446c2bd3d41999f5aa416bb25bad24d1", + "size": 2019630, + "subdir": "linux-64", + "timestamp": 1657868025937, + "version": "1.4.39" + }, + "sqlalchemy-1.4.39-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9ea6c474202c9c7fb9770a331b68eb4", + "name": "sqlalchemy", + "sha256": "1baf5a94ec0f9c7d02dd4e313367f075011eca03ec03bcb79a4b67e981c4a5aa", + "size": 2546783, + "subdir": "linux-64", + "timestamp": 1676827517442, + "version": "1.4.39" + }, + "sqlalchemy-1.4.39-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f29a6ee9a5a0105a40c2cbd16c72a0aa", + "name": "sqlalchemy", + "sha256": "119a0f7d4e6ecef510e019312385f98251a5105170f388cefc198cb7426d3643", + "size": 1945316, + "subdir": "linux-64", + "timestamp": 1657867906711, + "version": "1.4.39" + }, + "sqlalchemy-1.4.39-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc5cd1dc89e109c0267d1377d00faa67", + "name": "sqlalchemy", + "sha256": "89434ebe7f0351cd2b4a692be0c6d368f7dfe2f72e265eb57d1510cef315706a", + "size": 1968086, + "subdir": "linux-64", + "timestamp": 1657867943530, + "version": "1.4.39" + }, + "sqlalchemy-1.4.39-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f377e48ab953f4f55b96323b06886da", + "name": "sqlalchemy", + "sha256": "46deb409648605e212d76af38776bdba01b7139f91c4874e6722ccb29f367735", + "size": 1965334, + "subdir": "linux-64", + "timestamp": 1657867978380, + "version": "1.4.39" + }, + "sqlalchemy-1.4.4-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "60aa6d2b7cc7e932fd64beef70fcff74", + "name": "sqlalchemy", + "sha256": "c7eba3438427f2aa63d146c9615d489a2ab8aa09bc777fcbef260012b248c3a0", + "size": 1855228, + "subdir": "linux-64", + "timestamp": 1617207807952, + "version": "1.4.4" + }, + "sqlalchemy-1.4.4-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "a9f9e97644a448752afd38a952915521", + "name": "sqlalchemy", + "sha256": "8fb37862a993bed4026bcabf034573332ddff330ebe49087345b77c916933dbc", + "size": 1877538, + "subdir": "linux-64", + "timestamp": 1617208314183, + "version": "1.4.4" + }, + "sqlalchemy-1.4.4-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "e3964afa87cc684c8a40e3d2814b2349", + "name": "sqlalchemy", + "sha256": "f173a350fefa959817e9fc9d33c92140a8da96329da225611046706e11477dbc", + "size": 1877452, + "subdir": "linux-64", + "timestamp": 1617205798923, + "version": "1.4.4" + }, + "sqlalchemy-1.4.4-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "importlib_metadata", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "b51faaf6cb0045cba502bd9f1a456a71", + "name": "sqlalchemy", + "sha256": "dccca1c47ff681dae040321d3f73e889fb3af11b4f2b83f35df64b7a05b6a4da", + "size": 1896382, + "subdir": "linux-64", + "timestamp": 1617208305393, + "version": "1.4.4" + }, + "sqlalchemy-1.4.5-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4f4549bdbd248741c324d87388a7a557", + "name": "sqlalchemy", + "sha256": "5c040fa957c49e5fac892617071cff7dd6a44f34fd35edd672d33a06670d06e0", + "size": 1874389, + "subdir": "linux-64", + "timestamp": 1617395986157, + "version": "1.4.5" + }, + "sqlalchemy-1.4.5-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "258ea9846c578e8053913d27c263b632", + "name": "sqlalchemy", + "sha256": "770756863a9c1b0dd7ba8d75c4d2deb7a461c4bc9d513690d640accc4ee73ce2", + "size": 1874221, + "subdir": "linux-64", + "timestamp": 1617394081460, + "version": "1.4.5" + }, + "sqlalchemy-1.4.5-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "5377d5b5a5a24c7865f08453236d0ef7", + "name": "sqlalchemy", + "sha256": "052bb574a0923e0d27cdd50803d663953dd4c3cbfb53a6bb435d9ef5a26e7d1c", + "size": 1895011, + "subdir": "linux-64", + "timestamp": 1617396670119, + "version": "1.4.5" + }, + "sqlalchemy-1.4.5-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "9abde79fa2bc11e7b995e9a323c035df", + "name": "sqlalchemy", + "sha256": "0906a825c56079ad2cac6ddf627f77dfe39eb49d3a83a6d73072d18585f983b7", + "size": 1867123, + "subdir": "linux-64", + "timestamp": 1617396672405, + "version": "1.4.5" + }, + "sqlalchemy-1.4.7-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "377970784b440c4c704ff9be8628f03d", + "name": "sqlalchemy", + "sha256": "754b749e4c0ecaf8448865959665e43be5be94a3ca592d58cb18f80929f1a011", + "size": 1877629, + "subdir": "linux-64", + "timestamp": 1618089593582, + "version": "1.4.7" + }, + "sqlalchemy-1.4.7-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "importlib-metadata", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8227b4415a50edb5adc2dfa12a55cd6f", + "name": "sqlalchemy", + "sha256": "bd942df085a004f3c197c277861b64241fe578c19afc5a5f91e8ee1940bcdfed", + "size": 1878385, + "subdir": "linux-64", + "timestamp": 1618089605068, + "version": "1.4.7" + }, + "sqlalchemy-1.4.7-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "3a76eebea624d1472feef8b1844bdca6", + "name": "sqlalchemy", + "sha256": "7d7463239c69061cc23550458e0c9887b9edec87d54896b9273a4f1a5a830d7e", + "size": 1898964, + "subdir": "linux-64", + "timestamp": 1618089227156, + "version": "1.4.7" + }, + "sqlalchemy-1.4.7-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "greenlet !=0.4.17", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "d627db8fa4e31c3e31f6ac12bb7d25ad", + "name": "sqlalchemy", + "sha256": "c3ca18de0c1d4f5d76a107c51eca3ced2a2b4328a9712f537725ee9fb88d3d98", + "size": 1875550, + "subdir": "linux-64", + "timestamp": 1618089594284, + "version": "1.4.7" + }, + "sqlalchemy-utils-0.32.14-py27h71c0323_0.conda": { + "build": "py27h71c0323_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "enum34", + "furl >=0.4.1", + "intervals >=0.7.1", + "ipaddr", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "86e791e41fdb4c20b20833988bacbffe", + "name": "sqlalchemy-utils", + "sha256": "8060ceee6845bddd4cd281d86be39e99b5b80e048684893a31d32720aec096fb", + "size": 110557, + "subdir": "linux-64", + "timestamp": 1507402042636, + "version": "0.32.14" + }, + "sqlalchemy-utils-0.32.14-py35he446904_0.conda": { + "build": "py35he446904_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a0768fa4e6891be95b61353f5b8a7cea", + "name": "sqlalchemy-utils", + "sha256": "0202b4ff32d923719c7ab721e22af963d36cd0951d4bd3c9bc6e7d4e3af07e47", + "size": 113068, + "subdir": "linux-64", + "timestamp": 1507402049476, + "version": "0.32.14" + }, + "sqlalchemy-utils-0.32.14-py36h340ff1a_0.conda": { + "build": "py36h340ff1a_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2042662ccdf749903a572b7d2514607a", + "name": "sqlalchemy-utils", + "sha256": "1fb01497000bd07897c802c250fa44931b60504324479d047dc6c02531005753", + "size": 110371, + "subdir": "linux-64", + "timestamp": 1507402052967, + "version": "0.32.14" + }, + "sqlalchemy-utils-0.33.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "enum34", + "furl >=0.4.1", + "intervals >=0.7.1", + "ipaddr", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d5cea04ad46eca041dc2ecb75a821b29", + "name": "sqlalchemy-utils", + "sha256": "431ed1c3deb4c0e74dcc08ff74310b16e43ddc9a8c7cedc76d044a4c3ee4030d", + "size": 113675, + "subdir": "linux-64", + "timestamp": 1519365713928, + "version": "0.33.0" + }, + "sqlalchemy-utils-0.33.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "165f3f2bfb02a6c93ed086852510d380", + "name": "sqlalchemy-utils", + "sha256": "b2f7807787102dab297267a771f30132c3703150c991d6d4a7ce8c949f496299", + "size": 116227, + "subdir": "linux-64", + "timestamp": 1519365781188, + "version": "0.33.0" + }, + "sqlalchemy-utils-0.33.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5c358540f57e912b2fc1807ee211094c", + "name": "sqlalchemy-utils", + "sha256": "2d61c55b16c928f122c14e125ea4af37e07602f589b7bb8301fb646d3259f705", + "size": 115145, + "subdir": "linux-64", + "timestamp": 1519365678624, + "version": "0.33.0" + }, + "sqlalchemy-utils-0.33.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "enum34", + "furl >=0.4.1", + "intervals >=0.7.1", + "ipaddr", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c56530db5dee849d214d7b9150b957d3", + "name": "sqlalchemy-utils", + "sha256": "132f110aeef4882a15e4c7e77941db32b8fa70abf13f38ee42f5de4a1297695d", + "size": 115844, + "subdir": "linux-64", + "timestamp": 1522723263279, + "version": "0.33.1" + }, + "sqlalchemy-utils-0.33.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cff9f43fd70c6a4f8c0ea84db2a582c7", + "name": "sqlalchemy-utils", + "sha256": "03a72515afb512fa2ca89fbdbb2edd7463058c736dbb3352fee436d80505045f", + "size": 118637, + "subdir": "linux-64", + "timestamp": 1522723285547, + "version": "0.33.1" + }, + "sqlalchemy-utils-0.33.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c67d5fc16ae16256c8ffe07096dce132", + "name": "sqlalchemy-utils", + "sha256": "d14b6419351e025aedfa0d932009fc4511a7539a987a4b705088cc50a5dfe5a5", + "size": 117630, + "subdir": "linux-64", + "timestamp": 1522723256709, + "version": "0.33.1" + }, + "sqlalchemy-utils-0.33.11-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "enum34", + "furl >=0.4.1", + "intervals >=0.7.1", + "ipaddr", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "070134a48a01b58aed104721beeea8ab", + "name": "sqlalchemy-utils", + "sha256": "27da383668037fa305e98bbb674a1ad6d35558e8e146ff0a286e6a1b9376d8b9", + "size": 123277, + "subdir": "linux-64", + "timestamp": 1548004273024, + "version": "0.33.11" + }, + "sqlalchemy-utils-0.33.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4217304dbbe5d94a519bc1b4607b2b18", + "name": "sqlalchemy-utils", + "sha256": "aa56fbfe07351aebf41ae766d5632ab83a37c8685c0337f0bf8da12135552b6d", + "size": 123119, + "subdir": "linux-64", + "timestamp": 1548004300834, + "version": "0.33.11" + }, + "sqlalchemy-utils-0.33.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f13aae66d1438dea2d03091fa511aeb7", + "name": "sqlalchemy-utils", + "sha256": "28bc9e1d7a4eabd2709a4e86ab2ad518460e3957bbd84b573a53bffc470ade79", + "size": 123419, + "subdir": "linux-64", + "timestamp": 1548004300136, + "version": "0.33.11" + }, + "sqlalchemy-utils-0.33.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "enum34", + "furl >=0.4.1", + "intervals >=0.7.1", + "ipaddr", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cf10d42a957ac1740dd5eea5c8e9af7c", + "name": "sqlalchemy-utils", + "sha256": "ffc65cbca869f8ae860f6246504e5b8e0db358dd431dc2277cddda3a360067f2", + "size": 115848, + "subdir": "linux-64", + "timestamp": 1524071312868, + "version": "0.33.2" + }, + "sqlalchemy-utils-0.33.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "545c3ece1a731568852bbb55280d150b", + "name": "sqlalchemy-utils", + "sha256": "2e1272f581a02c59a064bc0ed064fcd098bd6f4e122686a968d5baa9cb7d833b", + "size": 118582, + "subdir": "linux-64", + "timestamp": 1524071331933, + "version": "0.33.2" + }, + "sqlalchemy-utils-0.33.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5fb590910d3abab33a2280b7ce34a6e8", + "name": "sqlalchemy-utils", + "sha256": "bae2b482e449c59e2bbbe437ac5ece139a670a550d4e0be268408417bad78784", + "size": 115901, + "subdir": "linux-64", + "timestamp": 1524071334804, + "version": "0.33.2" + }, + "sqlalchemy-utils-0.33.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "enum34", + "furl >=0.4.1", + "intervals >=0.7.1", + "ipaddr", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5da236514e7a7030dd940742db0f690f", + "name": "sqlalchemy-utils", + "sha256": "13450cf9e0ccf16f2d3472ff068e05976bea1eba05a38cb03757503dc8422e5f", + "size": 118473, + "subdir": "linux-64", + "timestamp": 1526929531809, + "version": "0.33.3" + }, + "sqlalchemy-utils-0.33.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3cad9449294a2c095ca728f8bba1af80", + "name": "sqlalchemy-utils", + "sha256": "ca03215c38e2e47a70dcb34bbf494258e7250bd339f81f7f8aaa93c973f49990", + "size": 119307, + "subdir": "linux-64", + "timestamp": 1526929554478, + "version": "0.33.3" + }, + "sqlalchemy-utils-0.33.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dc78c5161185b8cf6b497d025c4a853f", + "name": "sqlalchemy-utils", + "sha256": "255f7b41c487569f933ddccc0490a6cb898865d60166035e950ea0c2c281a25d", + "size": 118816, + "subdir": "linux-64", + "timestamp": 1526929498266, + "version": "0.33.3" + }, + "sqlalchemy-utils-0.33.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "61fe3077b2421d2d8840f2a9bf385efe", + "name": "sqlalchemy-utils", + "sha256": "ce52bc3ee1e41cb2ccb87dccd8ca18099085bb002695fc902f587c487ebaf580", + "size": 120501, + "subdir": "linux-64", + "timestamp": 1531059678963, + "version": "0.33.3" + }, + "sqlalchemy-utils-0.33.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "enum34", + "furl >=0.4.1", + "intervals >=0.7.1", + "ipaddr", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "204167105611c50f2cc8118184ca1ab0", + "name": "sqlalchemy-utils", + "sha256": "a76c5058b8fe40b9e90bbee6b488fc2b9f9021ab9bdcb6d0d8e187081daa081d", + "size": 120312, + "subdir": "linux-64", + "timestamp": 1539645481311, + "version": "0.33.6" + }, + "sqlalchemy-utils-0.33.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ac799d16b6db2643a8965945040baa2a", + "name": "sqlalchemy-utils", + "sha256": "ba44dc0ad7b6e18c793f4120192f8d524f2f95a90254c1e044d8ed2c4ebfe585", + "size": 120223, + "subdir": "linux-64", + "timestamp": 1539645511500, + "version": "0.33.6" + }, + "sqlalchemy-utils-0.33.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3b99b1949eb365d5087ab4fbd1efd814", + "name": "sqlalchemy-utils", + "sha256": "a3d0cf312dbbe78206a244b9a4d49392c6ff74a8587bc0b444a4a5828b51319b", + "size": 120892, + "subdir": "linux-64", + "timestamp": 1539645504309, + "version": "0.33.6" + }, + "sqlalchemy-utils-0.33.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "enum34", + "furl >=0.4.1", + "intervals >=0.7.1", + "ipaddr", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fed43a96c10d75eac46532125f407ced", + "name": "sqlalchemy-utils", + "sha256": "23073cad62cd0b7abf03a2c3ea7472ddc3a1c8825406823b68c56166c9db8a97", + "size": 119179, + "subdir": "linux-64", + "timestamp": 1545112551844, + "version": "0.33.9" + }, + "sqlalchemy-utils-0.33.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a15400795126e6ad5033db6efdbea1a1", + "name": "sqlalchemy-utils", + "sha256": "e3d7c3abff3253f807174ca72a1958d623b691d077ce5dbf7dcf6a9673b1809e", + "size": 120879, + "subdir": "linux-64", + "timestamp": 1545112586826, + "version": "0.33.9" + }, + "sqlalchemy-utils-0.33.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "anyjson >=0.3.3", + "arrow >=0.3.4", + "babel >=1.3", + "colour >=0.0.4", + "cryptography >=0.6", + "furl >=0.4.1", + "intervals >=0.7.1", + "passlib >=1.6,<2.0", + "phonenumbers >=5.9.2", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "six", + "sqlalchemy >=1.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f1eeffebe3cbba6913cd49aacf26cc3e", + "name": "sqlalchemy-utils", + "sha256": "ae7848ed36c755d89ce7bed1fbbda7bd841bb3a9af183d10105ee91e5ebbe929", + "size": 120932, + "subdir": "linux-64", + "timestamp": 1545112609564, + "version": "0.33.9" + }, + "sqlite-3.20.1-h6d8b0f3_1.conda": { + "build": "h6d8b0f3_1", + "build_number": 1, + "depends": [ + "libedit", + "libgcc-ng >=7.2.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "b35fba62fd494092bfb5c6ff4d2ff13f", + "name": "sqlite", + "sha256": "e07d8efbdfdabbe2e17755aecd4fefb19be98ee29f30b0c2e9bd92c43a358fa8", + "size": 791760, + "subdir": "linux-64", + "timestamp": 1505666546842, + "version": "3.20.1" + }, + "sqlite-3.20.1-hb898158_2.conda": { + "build": "hb898158_2", + "build_number": 2, + "depends": [ + "libedit", + "libgcc-ng >=7.2.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "021aae21beb142735b3fe042d3b3de4b", + "name": "sqlite", + "sha256": "1e0f075f491ec18225056ae8d10b585c6d69a46e8072afe3040c3706d4b01100", + "size": 791876, + "subdir": "linux-64", + "timestamp": 1510171800608, + "version": "3.20.1" + }, + "sqlite-3.21.0-h1bed415_0.conda": { + "build": "h1bed415_0", + "build_number": 0, + "depends": [ + "libedit", + "libgcc-ng >=7.2.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "056876a6bd6b050a52ae0bb904b0e475", + "name": "sqlite", + "sha256": "3d4dc4e1951f5397a4719539557dc49dcec2fcbfdcf0a2ccdea7920f193a82f1", + "size": 804809, + "subdir": "linux-64", + "timestamp": 1516736436984, + "version": "3.21.0" + }, + "sqlite-3.21.0-h1bed415_2.conda": { + "build": "h1bed415_2", + "build_number": 2, + "depends": [ + "libedit", + "libgcc-ng >=7.2.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "a535ac80b4fe79b9a81dc4a98265af1b", + "name": "sqlite", + "sha256": "f9460509411a87a3e61b3994d4c0890dc911cbf8bdca3e65a1d247622763983a", + "size": 804643, + "subdir": "linux-64", + "timestamp": 1517236999506, + "version": "3.21.0" + }, + "sqlite-3.22.0-h1bed415_0.conda": { + "build": "h1bed415_0", + "build_number": 0, + "depends": [ + "libedit", + "libgcc-ng >=7.2.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "0955f90080d2620d7b61c18cfcbb0e11", + "name": "sqlite", + "sha256": "87389857725e2af45079c2f29f58e70184d24e5d7d47ed6b222944292259fd08", + "size": 824621, + "subdir": "linux-64", + "timestamp": 1517325921602, + "version": "3.22.0" + }, + "sqlite-3.23.1-he433501_0.conda": { + "build": "he433501_0", + "build_number": 0, + "depends": [ + "libedit", + "libgcc-ng >=7.2.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "1b0ba12365bde505715fbc0fb9eeeedb", + "name": "sqlite", + "sha256": "ad985852490c5112b1c4c78c76e50494dfed046d7ef5b352e0b0cf1ef7acbc5c", + "size": 827688, + "subdir": "linux-64", + "timestamp": 1524193435107, + "version": "3.23.1" + }, + "sqlite-3.24.0-h84994c4_0.conda": { + "build": "h84994c4_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20170329,<3.2.0a0", + "libgcc-ng >=7.2.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "a864bccafc9b2cbbb4395b7731b9787b", + "name": "sqlite", + "sha256": "9a7d819d516445505055d291d7c8c4a27ea9a9da9c1f713a80916f6e39051e7f", + "size": 953298, + "subdir": "linux-64", + "timestamp": 1529358396807, + "version": "3.24.0" + }, + "sqlite-3.25.2-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20170329,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "79eb4afab610dcd1a9ddabeb2c733c5d", + "name": "sqlite", + "sha256": "af463e220ec056b8d24150bebd75e0a9497d5cdc3affb5c39659c28ca8c07d05", + "size": 991153, + "subdir": "linux-64", + "timestamp": 1538082485705, + "version": "3.25.2" + }, + "sqlite-3.25.3-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20170329,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "155a23b5913c7703da3f66cabb0c354c", + "name": "sqlite", + "sha256": "e4a5d3ec2ee6c9abac14f8ab27d767515b149b2715b707d8436a57ded376be22", + "size": 987963, + "subdir": "linux-64", + "timestamp": 1542091115818, + "version": "3.25.3" + }, + "sqlite-3.26.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20170329,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "d114686d555b11fb175f75081265ce34", + "name": "sqlite", + "sha256": "0fdf6f832b429162edc26577a28689a7cf1b262d3ab4af08fa6009df67821b08", + "size": 996675, + "subdir": "linux-64", + "timestamp": 1545057743770, + "version": "3.26.0" + }, + "sqlite-3.27.2-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "deabbf14647f3642c0f8912c7107d72d", + "name": "sqlite", + "sha256": "4ed57ed844f8cd7c521a9ae2784f453f21c67b8ba6c8131348ee6ae1248c2e70", + "size": 1100091, + "subdir": "linux-64", + "timestamp": 1552418002674, + "version": "3.27.2" + }, + "sqlite-3.28.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "85d4ed0c2cb58e2362ce9185f9416adc", + "name": "sqlite", + "sha256": "3f591ffefcb82e02e472608c59ffefd447de559edd38cd7ff711631999bb0b47", + "size": 1093534, + "subdir": "linux-64", + "timestamp": 1555958148895, + "version": "3.28.0" + }, + "sqlite-3.29.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "8a11cacdf8ddec6e2db9a2c12dbe2acb", + "name": "sqlite", + "sha256": "f7507a8894c3fafd07407b5dbf0771c57e99986f54b7091bf8daea9934246f44", + "size": 1111174, + "subdir": "linux-64", + "timestamp": 1563287521477, + "version": "3.29.0" + }, + "sqlite-3.30.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "b4a4dfabe1ad29a457859e64d4ac284f", + "name": "sqlite", + "sha256": "d4fdb3d6302786c353274ba3c237504d4870a968db8405401dc53fc2dfd87d38", + "size": 1118618, + "subdir": "linux-64", + "timestamp": 1570211057213, + "version": "3.30.0" + }, + "sqlite-3.30.1-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "2d7ed6da17e13871c709aa874b80656e", + "name": "sqlite", + "sha256": "b6eebc806bb56d79b008945c5b3089f24f0ab85974cb0690abc09ceeca85badb", + "size": 1121502, + "subdir": "linux-64", + "timestamp": 1572009937171, + "version": "3.30.1" + }, + "sqlite-3.31.1-h62c20be_1.conda": { + "build": "h62c20be_1", + "build_number": 1, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "f327f08e1c135a0313b7b371d5480345", + "name": "sqlite", + "sha256": "729cae4efcc5d9ad0eea361528536a2f6276b386c978ceb5b2179870f502f127", + "size": 1163764, + "subdir": "linux-64", + "timestamp": 1587498181207, + "version": "3.31.1" + }, + "sqlite-3.31.1-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "c2cae59a837775a03aed11469994981c", + "name": "sqlite", + "sha256": "38cfe7b8c9512ef1792acaef347f9ffc241be71b85142f680d9eeb2fbc36ba1f", + "size": 1133244, + "subdir": "linux-64", + "timestamp": 1580838834162, + "version": "3.31.1" + }, + "sqlite-3.32.2-h62c20be_0.conda": { + "build": "h62c20be_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20181209,<3.2.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "9b9490721095a44de5730e04e20a8fa0", + "name": "sqlite", + "sha256": "bfe2f6f05954545edc00bec05ba408650475b26c1e148f9f653a87d842a20414", + "size": 1171924, + "subdir": "linux-64", + "timestamp": 1592511505471, + "version": "3.32.2" + }, + "sqlite-3.32.3-h62c20be_0.conda": { + "build": "h62c20be_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20191231,<3.2.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "6888032ddcee186ef0d5703501a48d3b", + "name": "sqlite", + "sha256": "08d0a6bad46159c69404148847e9cfd33e713a6ed402867de9b218c92bc79ab2", + "size": 1161989, + "subdir": "linux-64", + "timestamp": 1592847543592, + "version": "3.32.3" + }, + "sqlite-3.33.0-h62c20be_0.conda": { + "build": "h62c20be_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20191231,<3.2.0a0", + "libgcc-ng >=7.3.0", + "ncurses >=6.2,<7.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "c4d7dd5cb9eca27fdf96764c1f706cb5", + "name": "sqlite", + "sha256": "c2ae0bd233ddc773d003e9eabd89d9becba941e62c307a6e9870d1b6c53f2129", + "size": 1169786, + "subdir": "linux-64", + "timestamp": 1597935754268, + "version": "3.33.0" + }, + "sqlite-3.35.0-hdfb4753_0.conda": { + "build": "hdfb4753_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "d31da86ed2b3130c45473aa7e9094f2c", + "name": "sqlite", + "sha256": "280eb5196da0074d9ac42c228b8b1d0c6f4051544d2085c38da81d0adadd2fbd", + "size": 1007995, + "subdir": "linux-64", + "timestamp": 1615820103755, + "version": "3.35.0" + }, + "sqlite-3.35.1-hdfb4753_0.conda": { + "build": "hdfb4753_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "1e24feedaeb3764b78957adced5d70fe", + "name": "sqlite", + "sha256": "c94eeb0e1f1ff53324a4e4becfdc84cc8c2cd032ab6b9c296d269c77ee632acc", + "size": 1004715, + "subdir": "linux-64", + "timestamp": 1615836970400, + "version": "3.35.1" + }, + "sqlite-3.35.2-hdfb4753_0.conda": { + "build": "hdfb4753_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "631384d7a1c1313203fc320311a24be0", + "name": "sqlite", + "sha256": "298b30c9a4bb41c5a6cc2084831fb2545640a62b2a6418466399ea9575ee9073", + "size": 1006230, + "subdir": "linux-64", + "timestamp": 1616094242182, + "version": "3.35.2" + }, + "sqlite-3.35.3-hdfb4753_0.conda": { + "build": "hdfb4753_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "fd96cbc3b1355116b6f0d00a47f67b4c", + "name": "sqlite", + "sha256": "bc755e8aec9abd1cf7e73e5570437c252a74de8b64645221cce73a6b435aeb1a", + "size": 1004179, + "subdir": "linux-64", + "timestamp": 1617134175367, + "version": "3.35.3" + }, + "sqlite-3.35.4-hdfb4753_0.conda": { + "build": "hdfb4753_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "390226b113ecaf216cc7a18aa11d7297", + "name": "sqlite", + "sha256": "8bc771ab36bf15127491998ea0108267bd136eb378d59114d103713ed0eec4a8", + "size": 1004674, + "subdir": "linux-64", + "timestamp": 1617396741975, + "version": "3.35.4" + }, + "sqlite-3.36.0-hc218d9a_0.conda": { + "build": "hc218d9a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Public-Domain (http://www.sqlite.org/copyright.html)", + "md5": "f917a337c8ef55f8536d6799af150b5a", + "name": "sqlite", + "sha256": "1be2b3f810979dd43649584be77a4bdf61f4c6cbce79c4e5fe940fc199579561", + "size": 1013919, + "subdir": "linux-64", + "timestamp": 1624470591767, + "version": "3.36.0" + }, + "sqlite-3.37.0-hc218d9a_0.conda": { + "build": "hc218d9a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Unlicense", + "md5": "a1460295556dd9c7228122c860a7ca29", + "name": "sqlite", + "sha256": "b841cf4f8cf66748602790fd664bb6fa142bb2dc31f990f9198c4c78437e3cb5", + "size": 1022540, + "subdir": "linux-64", + "timestamp": 1640179788083, + "version": "3.37.0" + }, + "sqlite-3.37.2-hc218d9a_0.conda": { + "build": "hc218d9a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Unlicense", + "md5": "2fed06925cc467368818d4f8e9f2a768", + "name": "sqlite", + "sha256": "43e4e0b8ea2618ca0e90d49d4e6144e7fb05d4e1de56870c64a88e8c87d175ae", + "size": 1032586, + "subdir": "linux-64", + "timestamp": 1643970309844, + "version": "3.37.2" + }, + "sqlite-3.38.0-hc218d9a_0.conda": { + "build": "hc218d9a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Unlicense", + "md5": "dfc123f873cc0acf02f74b32aeae7688", + "name": "sqlite", + "sha256": "a89871bf65466ff50a34eccff69056ef9d90f459bd12b23a11eba29b91b95520", + "size": 1056941, + "subdir": "linux-64", + "timestamp": 1646926931516, + "version": "3.38.0" + }, + "sqlite-3.38.2-hc218d9a_0.conda": { + "build": "hc218d9a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Unlicense", + "md5": "eb9f2708fc1162d01855c12c8156aecf", + "name": "sqlite", + "sha256": "74822a899fe4b46d8fdbdad19afaf614e4f172b5adeafb6260ed868fdd5c81bc", + "size": 1056400, + "subdir": "linux-64", + "timestamp": 1648718095207, + "version": "3.38.2" + }, + "sqlite-3.38.3-hc218d9a_0.conda": { + "build": "hc218d9a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "blessing", + "license_family": "Other", + "md5": "94e50b233f796aa4e0b7cf38611c0852", + "name": "sqlite", + "sha256": "2778a98881e694c4cc602f14da045feb20d4c3680776935e252732f9ef223852", + "size": 1068537, + "subdir": "linux-64", + "timestamp": 1651697672351, + "version": "3.38.3" + }, + "sqlite-3.38.5-hc218d9a_0.conda": { + "build": "hc218d9a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "blessing", + "license_family": "Other", + "md5": "ed2668e84d5e2730827ad737bc5231a3", + "name": "sqlite", + "sha256": "e1bfea5f8018906f6341af99eabc98e9530f152b53fbaa3ef5450a545055846b", + "size": 1060764, + "subdir": "linux-64", + "timestamp": 1655328608308, + "version": "3.38.5" + }, + "sqlite-3.39.0-h5082296_0.conda": { + "build": "h5082296_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "blessing", + "license_family": "Other", + "md5": "400cafd24fe2fd26577b7f889ba153b7", + "name": "sqlite", + "sha256": "75f30a408e2aa3b423b20b8274e495c39336c9ed291d19daff242adf86fdc8e6", + "size": 1114438, + "subdir": "linux-64", + "timestamp": 1659462267794, + "version": "3.39.0" + }, + "sqlite-3.39.2-h5082296_0.conda": { + "build": "h5082296_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "blessing", + "license_family": "Other", + "md5": "094229a2e1eff038c38f3c34db9c48ce", + "name": "sqlite", + "sha256": "62a4ac40a681d00f6fda2b812796dc7224b8a0d77e5dcf4a9c6e199b805ade6a", + "size": 1116380, + "subdir": "linux-64", + "timestamp": 1659712464546, + "version": "3.39.2" + }, + "sqlite-3.39.3-h5082296_0.conda": { + "build": "h5082296_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "blessing", + "license_family": "Other", + "md5": "1fd3c10003776a5c0ebd14205327f541", + "name": "sqlite", + "sha256": "ecd4068ea760b526db2550da1313195bc6e2ea99960fb769f614836ac9f01382", + "size": 1109727, + "subdir": "linux-64", + "timestamp": 1664326359748, + "version": "3.39.3" + }, + "sqlite-3.40.0-h5082296_0.conda": { + "build": "h5082296_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "blessing", + "license_family": "Other", + "md5": "d1300b056e728ea61a0bf135b035e60d", + "name": "sqlite", + "sha256": "3df5f55bbb941e772bb866bf18bec7b11094f01cc0ac41225705caedd8d0e4a8", + "size": 1223617, + "subdir": "linux-64", + "timestamp": 1669138335049, + "version": "3.40.0" + }, + "sqlite-3.40.1-h5082296_0.conda": { + "build": "h5082296_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "blessing", + "license_family": "Other", + "md5": "7d44bb7460f1b1b0764d63240d7f7f81", + "name": "sqlite", + "sha256": "3171347a39846f613053065a5c949f4aa67bd29884056d8b54dd1021bcc11e81", + "size": 1221920, + "subdir": "linux-64", + "timestamp": 1673293981140, + "version": "3.40.1" + }, + "sqlite-3.41.1-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "ncurses >=6.4,<7.0a0", + "readline >=8.0,<9.0a0", + "zlib >=1.2.13,<1.3.0a0", + "zlib >=1.2.13,<2.0a0" + ], + "license": "blessing", + "license_family": "Other", + "md5": "709601b06aa55f41f299ef6d374a3eef", + "name": "sqlite", + "sha256": "833e392bf6f3350e9dd754d85a9995e19cd5dff2c8aed9f25746ae4c2b9d2960", + "size": 1232384, + "subdir": "linux-64", + "timestamp": 1678878009316, + "version": "3.41.1" + }, + "sqlparse-0.2.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e4d8e0d27e2a6fe204ee2789ec7b2d90", + "name": "sqlparse", + "sha256": "21e161de334346f557e7dec96fea20f47f5d42f654d23cb604650194507c7caa", + "size": 61092, + "subdir": "linux-64", + "timestamp": 1519760497553, + "version": "0.2.4" + }, + "sqlparse-0.2.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3c0fdb7c9f1e42e2e4103fb331e479e4", + "name": "sqlparse", + "sha256": "2a88aa47b5f4ccb4201ac55ff998fdf80a63693e9c0fec19b033a519bb30f018", + "size": 62087, + "subdir": "linux-64", + "timestamp": 1519760511012, + "version": "0.2.4" + }, + "sqlparse-0.2.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "66f112bb57f121e7dec1b9ddbf7862a9", + "name": "sqlparse", + "sha256": "75e3497ae83780a274a70d127b12e6c807e2bfad7efe2214cde4220191c4ed24", + "size": 59165, + "subdir": "linux-64", + "timestamp": 1519760481116, + "version": "0.2.4" + }, + "sqlparse-0.2.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ca24520882ce49745a47040e42e9a920", + "name": "sqlparse", + "sha256": "6cc97d40b8b0964680b0ea3cc7f6e17c6f5f759fc43bc05619f1ec320daaed8d", + "size": 59088, + "subdir": "linux-64", + "timestamp": 1531059717254, + "version": "0.2.4" + }, + "sqlparse-0.4.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b64e83bb61aae26fa442062bba49f0ca", + "name": "sqlparse", + "sha256": "bf323f49945e663d502eb8c549cb519ca3206f2de8bf21193d9f9fbe3d7e96ae", + "size": 76244, + "subdir": "linux-64", + "timestamp": 1668793594692, + "version": "0.4.3" + }, + "sqlparse-0.4.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d97f36afb85a6e493cf9a5eeab374a98", + "name": "sqlparse", + "sha256": "b381e2c7d2832fa9c4cefe2a7646ad410961a4ff3d9e800ec57890ea9b825228", + "size": 93653, + "subdir": "linux-64", + "timestamp": 1676828857752, + "version": "0.4.3" + }, + "sqlparse-0.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d862488514b3b2b7844bd32eb26e8d0", + "name": "sqlparse", + "sha256": "59026caa245bd969bbe178463e9555fc4fdafaf954d447c88ab4b2ffb80d73ff", + "size": 70597, + "subdir": "linux-64", + "timestamp": 1668793517393, + "version": "0.4.3" + }, + "sqlparse-0.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a9a7c249fd054b5ce42698f74fc042c8", + "name": "sqlparse", + "sha256": "a4877ce706c080e1aecfe99119922bfe4403130dc0501e080e50b941e4816fcf", + "size": 71014, + "subdir": "linux-64", + "timestamp": 1668793569016, + "version": "0.4.3" + }, + "sqlparse-0.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aa8a717612152069963dfd1e3b6482e5", + "name": "sqlparse", + "sha256": "c050abc5a9ae6cecf4b5af0d205b7a49d78e5f7387011ec1be9912fe193a7a84", + "size": 70750, + "subdir": "linux-64", + "timestamp": 1668793543264, + "version": "0.4.3" + }, + "srsly-1.0.2-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "148969f027452fe2569163c06da41987", + "name": "srsly", + "sha256": "430e4961e26d1fb7749b11462ba10ad6bfa20a5b56c9c5f7e69b78ead955496c", + "size": 204883, + "subdir": "linux-64", + "timestamp": 1590155061839, + "version": "1.0.2" + }, + "srsly-1.0.2-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d04999d0abddaf58445c810e040bfe91", + "name": "srsly", + "sha256": "2375c356146bc44346ebbacdbc709e04edc44bc8d4513455fb5dbbef8bad49eb", + "size": 204239, + "subdir": "linux-64", + "timestamp": 1590155091742, + "version": "1.0.2" + }, + "srsly-1.0.2-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c298f91b5b87d86bf0e08fb250745add", + "name": "srsly", + "sha256": "e0e834c0f38121469e9266dfc52913f0aecb662e9f108d8fb1d5378525809785", + "size": 209917, + "subdir": "linux-64", + "timestamp": 1590155061725, + "version": "1.0.2" + }, + "srsly-1.0.5-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e8e8299e01467db12c3e2895e18a4cc", + "name": "srsly", + "sha256": "3a0d021821c7786e48a4dc0b50d6e504e64db0e39180a2e2787cdfd445ff50e1", + "size": 200973, + "subdir": "linux-64", + "timestamp": 1607548601131, + "version": "1.0.5" + }, + "srsly-1.0.5-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de072080768d21213dd12e65aa51e0eb", + "name": "srsly", + "sha256": "9ac8aefb1b4e0307978fcc7b6aa52612f3f34a5eb6c65c7829c85d9868d9ac28", + "size": 201644, + "subdir": "linux-64", + "timestamp": 1607548566596, + "version": "1.0.5" + }, + "srsly-1.0.5-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6398e08e98283626fd6da30674906182", + "name": "srsly", + "sha256": "91e8077372ea17b96142910cf60664f54640abbbaf8d2d507a2b51517a23d98f", + "size": 203412, + "subdir": "linux-64", + "timestamp": 1607548595823, + "version": "1.0.5" + }, + "srsly-1.0.5-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ec8b73d679d1200b083e4b9e1a2df42d", + "name": "srsly", + "sha256": "313f9d3fc49f8cedc07492982e569994843d45fae462548bb5bbb0c396c6fcd4", + "size": 202484, + "subdir": "linux-64", + "timestamp": 1607548583937, + "version": "1.0.5" + }, + "srsly-2.2.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "42570d71e8bd20e5a5731aaab1bc2e21", + "name": "srsly", + "sha256": "6cc6b7567ccc77bd095ab6e949551fb183707eafee0e901ad62dd5a26c3ea011", + "size": 491046, + "subdir": "linux-64", + "timestamp": 1594254063821, + "version": "2.2.0" + }, + "srsly-2.2.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8247453b3898062dd70876e5d7fe159f", + "name": "srsly", + "sha256": "2866d1eec3fbb53286be41c991c084ff62ea8461b2648633a4c708f811557640", + "size": 491974, + "subdir": "linux-64", + "timestamp": 1594254065550, + "version": "2.2.0" + }, + "srsly-2.2.0-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "473c82c76eff5cc9107aa6479dccb188", + "name": "srsly", + "sha256": "d73ca0cd89f39c3bd34458b850063d1715a98c21651ff5ad97594e630bf7414f", + "size": 498078, + "subdir": "linux-64", + "timestamp": 1594254040598, + "version": "2.2.0" + }, + "srsly-2.3.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "054d1da535f473b198fa160f60643415", + "name": "srsly", + "sha256": "654d847cd97873e8ae9aa6a2eaaa096f6bdee4a56ac9723beb0981848e6ade5f", + "size": 491675, + "subdir": "linux-64", + "timestamp": 1602000024351, + "version": "2.3.0" + }, + "srsly-2.3.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8462cafe3bb898f57a2a74aea1302737", + "name": "srsly", + "sha256": "4d1a295ff7a2bee2b11a76853ecb4bd7d994c34b57c1159924a7a0c1b5d5c220", + "size": 490235, + "subdir": "linux-64", + "timestamp": 1602000031051, + "version": "2.3.0" + }, + "srsly-2.3.0-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18bd2792c9e629efecb9286a537418ea", + "name": "srsly", + "sha256": "285073ccabcbf2ffd856f9842b1f8bb7d0670972c4736902e9c4215300b2ec72", + "size": 498194, + "subdir": "linux-64", + "timestamp": 1602000032807, + "version": "2.3.0" + }, + "srsly-2.3.2-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "65dcbd2cc7b4049bd5d0118e350a1938", + "name": "srsly", + "sha256": "18ac7b371068f83e5f965a2393fb4ff70afa8e176a9c8678b5eb6f9c661a0228", + "size": 492684, + "subdir": "linux-64", + "timestamp": 1606929412299, + "version": "2.3.2" + }, + "srsly-2.3.2-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e88477f403693e6a5f059cf9124e4378", + "name": "srsly", + "sha256": "81d8aafeadc1ca217e80a2e557b8a1f39b272d5b43c8766d12db3c5569e08e7a", + "size": 492426, + "subdir": "linux-64", + "timestamp": 1606929402732, + "version": "2.3.2" + }, + "srsly-2.3.2-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "79dbee1c2a9a4930666af781af9d2728", + "name": "srsly", + "sha256": "ae30fabe2691815dff7f243272cfaf0a8154399695a6ccddc60fbe6f11969027", + "size": 495941, + "subdir": "linux-64", + "timestamp": 1606929408533, + "version": "2.3.2" + }, + "srsly-2.4.0-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "catalogue", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "00a4a8d029029f3ef9cf89eb1b900031", + "name": "srsly", + "sha256": "0cd5ac0da4b2592164e21b20327c7eb72ba1f5fc21e5de9492484dcc371f58a4", + "size": 490337, + "subdir": "linux-64", + "timestamp": 1612468502424, + "version": "2.4.0" + }, + "srsly-2.4.0-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "catalogue", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0974f4fad7d443ab2eefa54886594ff5", + "name": "srsly", + "sha256": "88655d558de23be18563971143cf5b900cfffe5c20767617e975fdc5ea2e3a19", + "size": 492883, + "subdir": "linux-64", + "timestamp": 1612468950284, + "version": "2.4.0" + }, + "srsly-2.4.0-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "catalogue", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e09af7102d8744a3bd4ae2d31835a81d", + "name": "srsly", + "sha256": "c924055497f562f60cd8ff6351769a42eec7dc04fe0d3ac64d171bffd607c085", + "size": 493957, + "subdir": "linux-64", + "timestamp": 1612468960033, + "version": "2.4.0" + }, + "srsly-2.4.0-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "catalogue", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "953edb41dd25a58641bc8cf9a36618b4", + "name": "srsly", + "sha256": "71998223159cf23d489374f3cc38d73de9a515626a55d81655696281b7d6c87f", + "size": 495016, + "subdir": "linux-64", + "timestamp": 1612468954461, + "version": "2.4.0" + }, + "srsly-2.4.1-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "533cc902dac75a19dd9189121999575f", + "name": "srsly", + "sha256": "b2985bf4f17cab931c606c484ac8071e7eae7863867ed8fae457f1032e3d55d2", + "size": 731554, + "subdir": "linux-64", + "timestamp": 1640794915963, + "version": "2.4.1" + }, + "srsly-2.4.1-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "catalogue", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e98ba947bdfb6bd41986077ba7caa78a", + "name": "srsly", + "sha256": "04c188a43563a12d19e23c7fb11e3e8f22d24d276670cf12050d197166b97597", + "size": 492653, + "subdir": "linux-64", + "timestamp": 1618696336856, + "version": "2.4.1" + }, + "srsly-2.4.1-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "catalogue", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2eda92f8dac37cce2e805ea18018557", + "name": "srsly", + "sha256": "8a798cc85e65c2f1152eb6e972029113307907b223ccc05c2ee39e214994ee4b", + "size": 490200, + "subdir": "linux-64", + "timestamp": 1618693074684, + "version": "2.4.1" + }, + "srsly-2.4.1-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "catalogue", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f230d2438fac802cac7d7523fc833277", + "name": "srsly", + "sha256": "6b2e4b63c76f81e580712870ee3c3a0a3ada398025ee5129ea6b125964aece6b", + "size": 496716, + "subdir": "linux-64", + "timestamp": 1618696232148, + "version": "2.4.1" + }, + "srsly-2.4.1-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85e53034863b4a045a49b23ac428b5df", + "name": "srsly", + "sha256": "f263486839cff6e7fa389be5f06140cf89600d095545519b568882ede780c7ee", + "size": 497612, + "subdir": "linux-64", + "timestamp": 1618836827566, + "version": "2.4.1" + }, + "srsly-2.4.3-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "59801242fe32fadf03b31ae946627663", + "name": "srsly", + "sha256": "ea39c0a7ce4fe1fdfd09919fd6fd06bf6729a63569a16099361459f10f850cd8", + "size": 738543, + "subdir": "linux-64", + "timestamp": 1651584861545, + "version": "2.4.3" + }, + "srsly-2.4.3-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea9a9015b6a5573f345569711ea514a9", + "name": "srsly", + "sha256": "1943dbf94d0670fd45be52290bc8dd9e853335a8bf18bde31347c525c0730146", + "size": 606087, + "subdir": "linux-64", + "timestamp": 1676842911003, + "version": "2.4.3" + }, + "srsly-2.4.3-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02b16dbcc884a99474ea7b368698b03c", + "name": "srsly", + "sha256": "a237e368523d726d60e8124ad9d05d0c36e4cb1bd4ca486457c871ed52f84427", + "size": 496594, + "subdir": "linux-64", + "timestamp": 1651584907652, + "version": "2.4.3" + }, + "srsly-2.4.3-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a187f00400db92b83fa2b0575e9d0297", + "name": "srsly", + "sha256": "b04ec218596e1facc0f10da81fffe9592c3e2110f7d30b4232dda1852c06808d", + "size": 501423, + "subdir": "linux-64", + "timestamp": 1651584953935, + "version": "2.4.3" + }, + "srsly-2.4.3-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e783be9b96e7353c159df65f005011f8", + "name": "srsly", + "sha256": "54a06466fadab465a0c2f5c7bcd137261dcfbc726a8234453cb497641ddeee96", + "size": 500838, + "subdir": "linux-64", + "timestamp": 1651584798383, + "version": "2.4.3" + }, + "srsly-2.4.6-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce84ce0e3c0f658c47d50e881fa855d1", + "name": "srsly", + "sha256": "8f4fac90bbea5790ec885949c35b60be6845cdce5e4e569d3f9f32112fa5054c", + "size": 597808, + "subdir": "linux-64", + "timestamp": 1677855639453, + "version": "2.4.6" + }, + "srsly-2.4.6-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee27b3826deec61cb81a1ff9d894a8d8", + "name": "srsly", + "sha256": "edaab308f50524610d2eabe480ee4efe1afb994ecc7358449c6a451f22c4085f", + "size": 678578, + "subdir": "linux-64", + "timestamp": 1677787954256, + "version": "2.4.6" + }, + "srsly-2.4.6-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "334a6ec8b5b6cab0747603e5c1757376", + "name": "srsly", + "sha256": "8ba539f17498988133d277e088e63148e7eb4d4974a14bc4357c78108f6c3a60", + "size": 594341, + "subdir": "linux-64", + "timestamp": 1677855695428, + "version": "2.4.6" + }, + "srsly-2.4.6-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.3,<2.1.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6cce0609b904a30901534335737c4617", + "name": "srsly", + "sha256": "7ca25b824e1743f40ea5ccdfee5a4205868b252e62d728cc4a8e4a6c40e95ffe", + "size": 592847, + "subdir": "linux-64", + "timestamp": 1677855581573, + "version": "2.4.6" + }, + "ssl_match_hostname-3.5.0.1-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "5bada1ffe487566e9d7a4162fa7b2465", + "name": "ssl_match_hostname", + "sha256": "d6a9867876c330c8206eda89acfa7f0c40a56b36a9727aee06fff22078b04491", + "size": 10313, + "subdir": "linux-64", + "timestamp": 1531059751818, + "version": "3.5.0.1" + }, + "ssl_match_hostname-3.5.0.1-py27h4ec10b9_2.conda": { + "build": "py27h4ec10b9_2", + "build_number": 2, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "85ed3c7528479d6242a9745de668864d", + "name": "ssl_match_hostname", + "sha256": "5aeac41ce3a41c73fac72715b81baa00bcdf3e63ee0c237a49e93821bc3b24f6", + "size": 10048, + "subdir": "linux-64", + "timestamp": 1505690500163, + "version": "3.5.0.1" + }, + "ssl_match_hostname-3.7.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "98e1d5a7e7fecfe7a436140403a7cbab", + "name": "ssl_match_hostname", + "sha256": "e07dba5b3cf1aa46681622ea0930e6c03a4f9c1d66bdeee11d29ccbedf337495", + "size": 13465, + "subdir": "linux-64", + "timestamp": 1547910023909, + "version": "3.7.0.1" + }, + "statistics-1.0.3.5-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "docutils >=0.3", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b565cb6a2b9e32a0cae422d82cc3a9fa", + "name": "statistics", + "sha256": "02353d0697cb22e9b9f75e703fbff379ff00caf564479fd39d8467bc812573b0", + "size": 13795, + "subdir": "linux-64", + "timestamp": 1520379028622, + "version": "1.0.3.5" + }, + "statistics-1.0.3.5-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "docutils >=0.3", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a9aaf14e14f0dfc68e20739e6c7a0fee", + "name": "statistics", + "sha256": "924d6c978b48b6af28074593c0df1ab1e905fa03a11f9693aa944d90d5bb72e9", + "size": 13865, + "subdir": "linux-64", + "timestamp": 1642511084282, + "version": "1.0.3.5" + }, + "statsmodels-0.10.0-py27hdd07704_0.conda": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "numpy >=1.11.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "175c3adfc20fac8349b6cb31ddd29448", + "name": "statsmodels", + "sha256": "d1fda9ec596ff775d70c029903926871d2931a1505d1b453d3a264c8bac1d1ed", + "size": 7757254, + "subdir": "linux-64", + "timestamp": 1562172050455, + "version": "0.10.0" + }, + "statsmodels-0.10.0-py36hdd07704_0.conda": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0b92e95c3e289b121c3d7590e0811802", + "name": "statsmodels", + "sha256": "8ffbc6f848d3458443a7fbfa342f484106f1a51184a819e5ccb72d6b44cb19b5", + "size": 7811533, + "subdir": "linux-64", + "timestamp": 1562171940160, + "version": "0.10.0" + }, + "statsmodels-0.10.0-py37hdd07704_0.conda": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=3.7,<3.8.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9b8dd7436b4995c1268793220f01bffd", + "name": "statsmodels", + "sha256": "5c3c113d5e1e0d21ffdd93e20a5bb3edabcdcfaf5e1015ba4e2e8052e1277556", + "size": 7721330, + "subdir": "linux-64", + "timestamp": 1562171911520, + "version": "0.10.0" + }, + "statsmodels-0.10.1-py27hdd07704_0.conda": { + "build": "py27hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "df8f82acb0a2d9624d1af728c8142fad", + "name": "statsmodels", + "sha256": "b689405129a3004a19ec33999e93725012c512b3dd4900eac30129cc1d53c23b", + "size": 7801609, + "subdir": "linux-64", + "timestamp": 1563914492440, + "version": "0.10.1" + }, + "statsmodels-0.10.1-py36hdd07704_0.conda": { + "build": "py36hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1201a053fcfbb942fdba4a5a1b7b017b", + "name": "statsmodels", + "sha256": "26d6f5a3714faaf8f0f4ea1b314af0162f3d12e058fc73416ab9bd7884356959", + "size": 7804749, + "subdir": "linux-64", + "timestamp": 1563914456317, + "version": "0.10.1" + }, + "statsmodels-0.10.1-py37hdd07704_0.conda": { + "build": "py37hdd07704_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=3.7,<3.8.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4166ed9ac886c21376f90f1ad049c506", + "name": "statsmodels", + "sha256": "0da14a9b3e09fec3a4251060aa992323f7ff3b816812ad9641a5ebd7e58a6bc3", + "size": 7715827, + "subdir": "linux-64", + "timestamp": 1563914439334, + "version": "0.10.1" + }, + "statsmodels-0.11.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.6,<3.7.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ecac2c91b7784ae65a8d153e9401b817", + "name": "statsmodels", + "sha256": "3d78ad8331b6d2b0d3fb0856f91329097f7b75073a61b966557ca9a1447104a3", + "size": 8324307, + "subdir": "linux-64", + "timestamp": 1580251501420, + "version": "0.11.0" + }, + "statsmodels-0.11.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.7,<3.8.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f18d0d575c791c89b9483417b7033977", + "name": "statsmodels", + "sha256": "46af5c56ae9c43b646000486a0a15d4099e030de0418579ce1f9b5b4ec068694", + "size": 8203338, + "subdir": "linux-64", + "timestamp": 1580251499797, + "version": "0.11.0" + }, + "statsmodels-0.11.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.8,<3.9.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cab964473625835c62508fa722b4fa03", + "name": "statsmodels", + "sha256": "b8140de71454dfb52ca8efb2ea590f4235aa461bcb82c42bfc1d63cddda62751", + "size": 8308513, + "subdir": "linux-64", + "timestamp": 1580251495072, + "version": "0.11.0" + }, + "statsmodels-0.11.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.6,<3.7.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4cd045b890581b3a1309f5b0552be974", + "name": "statsmodels", + "sha256": "1072eb82bc28f1589e1afb34f1d62b450ddb2cda8c3cde68f960653c30fada2b", + "size": 8298168, + "subdir": "linux-64", + "timestamp": 1590093152141, + "version": "0.11.1" + }, + "statsmodels-0.11.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.7,<3.8.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fb5d5fe9237c6f39a13c035a847c0d97", + "name": "statsmodels", + "sha256": "ba6b9081da662e5fbd68208a101bdb4a87dfafe73ac55491b699db5f114cce3a", + "size": 8199582, + "subdir": "linux-64", + "timestamp": 1590093064095, + "version": "0.11.1" + }, + "statsmodels-0.11.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.8,<3.9.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ba9cf7728e418ce6e6f63f1ec6d3477c", + "name": "statsmodels", + "sha256": "c0a234cce24ba816b9b4f1218935baa2ec3266198c631b5211742296db410440", + "size": 8299722, + "subdir": "linux-64", + "timestamp": 1590093140223, + "version": "0.11.1" + }, + "statsmodels-0.12.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.6,<3.7.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "208ea2218fb5bf4c3bdffd7d51233382", + "name": "statsmodels", + "sha256": "38e07e90f3c1fea22a014a290e1fa6b5f6f55aa021b4df43b5ae5849ebc202d5", + "size": 8923451, + "subdir": "linux-64", + "timestamp": 1602280461035, + "version": "0.12.0" + }, + "statsmodels-0.12.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.7,<3.8.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "19ca60d80cf889486f16e26a71ea606c", + "name": "statsmodels", + "sha256": "e868f4d2fbec92eae15387e86dc30a85904de9e435cfdc8cedd298c7dc7813a3", + "size": 8837362, + "subdir": "linux-64", + "timestamp": 1602280500702, + "version": "0.12.0" + }, + "statsmodels-0.12.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.19.1,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.8,<3.9.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a9747d016d61e287f6d7adb6a9062c10", + "name": "statsmodels", + "sha256": "a955ef0eb42ec6f76d9393aa2547f887b2226a3ad26d05ccf974576b1c168cc8", + "size": 8954987, + "subdir": "linux-64", + "timestamp": 1602280499888, + "version": "0.12.0" + }, + "statsmodels-0.12.1-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.6,<3.7.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d3d53638cbd11919ebeaf3995f61f463", + "name": "statsmodels", + "sha256": "d7bbbc9385f34561a88bcada39067b780cda1d664a49b30e0db95f19f1f11b30", + "size": 8940935, + "subdir": "linux-64", + "timestamp": 1606925691863, + "version": "0.12.1" + }, + "statsmodels-0.12.1-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.7,<3.8.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f443991ce3eb63691fc2430df88a3d63", + "name": "statsmodels", + "sha256": "d1e95d246753715c2660445c63038820deac0e7d21ea4d5eb6ba6deed2a4a4cf", + "size": 8833452, + "subdir": "linux-64", + "timestamp": 1606925730923, + "version": "0.12.1" + }, + "statsmodels-0.12.1-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.8,<3.9.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "42e8f9082a2447f63801030c9e29168c", + "name": "statsmodels", + "sha256": "4f63119fd92d013da43b89556b3d24ad18239694f17a877b0b4ec029be3463ea", + "size": 8955831, + "subdir": "linux-64", + "timestamp": 1606866011523, + "version": "0.12.1" + }, + "statsmodels-0.12.1-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.9,<3.10.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f812d5aaa9262da76120ed50f96efd29", + "name": "statsmodels", + "sha256": "55c88b2658dda84a7e20f0cd113ecfc59f7c12d1f0365386f447090b56a0b502", + "size": 8917371, + "subdir": "linux-64", + "timestamp": 1607710074650, + "version": "0.12.1" + }, + "statsmodels-0.12.2-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.6,<3.7.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "02bea84d423c5d694b3889fc6f9c0e00", + "name": "statsmodels", + "sha256": "7b43f490ab5f54b4d33a2c7782633c05dae8ae96ffe651f6255c1cd06c7328ad", + "size": 8976748, + "subdir": "linux-64", + "timestamp": 1614024141867, + "version": "0.12.2" + }, + "statsmodels-0.12.2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.17.0,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.7,<3.8.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "710890a7cbe157e50ed3433e9de55ca7", + "name": "statsmodels", + "sha256": "6fc68ba95bbe0e6b55b5abf97507b4bd078ad64bc02a33c446cdea07abacd185", + "size": 8886065, + "subdir": "linux-64", + "timestamp": 1614024088346, + "version": "0.12.2" + }, + "statsmodels-0.12.2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.8,<3.9.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "54140cda25f5270011d4df346497d29a", + "name": "statsmodels", + "sha256": "3291d0f911af6a748a7aa429cbc4b17b0e40b36f6a43148b8437c90d27f95b38", + "size": 8953033, + "subdir": "linux-64", + "timestamp": 1614024129348, + "version": "0.12.2" + }, + "statsmodels-0.12.2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.19.2,<2.0a0", + "pandas >=0.21", + "patsy >=0.5.1", + "python >=3.9,<3.10.0a0", + "scipy >=1.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "605b6dc29db035b4d5d0b3d1303b29ee", + "name": "statsmodels", + "sha256": "b1b996ac63735d3e04f2809e540b53a8cabb5eea09c9c7d6f0144879b2ccf409", + "size": 8918658, + "subdir": "linux-64", + "timestamp": 1614023214335, + "version": "0.12.2" + }, + "statsmodels-0.13.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "pandas >=1.0", + "patsy >=0.5.2", + "python >=3.10,<3.11.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dbf73dd83170517d51a8081116e70949", + "name": "statsmodels", + "sha256": "86cf9c8bd634705bccfd48f6314f79a40ede62b59a0438500697adb2d642b139", + "size": 15358226, + "subdir": "linux-64", + "timestamp": 1642514974483, + "version": "0.13.0" + }, + "statsmodels-0.13.0-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "pandas >=1.0", + "patsy >=0.5.2", + "python >=3.7,<3.8.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0e09b0a26475f02c5d7e65d3d287ee57", + "name": "statsmodels", + "sha256": "17cad41d3e95f8fbe6cdd16137d82118dbd863a591e07fa2325b1cd30efc5071", + "size": 8963837, + "subdir": "linux-64", + "timestamp": 1635163331918, + "version": "0.13.0" + }, + "statsmodels-0.13.0-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "pandas >=1.0", + "patsy >=0.5.2", + "python >=3.8,<3.9.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d4e1fba104a317b9d230f3ce5bbd0dbd", + "name": "statsmodels", + "sha256": "875fb188c4c7992ff23567ec6ae0df0731c3267cc6e648bcbb27e14e58199982", + "size": 9086317, + "subdir": "linux-64", + "timestamp": 1635163326180, + "version": "0.13.0" + }, + "statsmodels-0.13.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "pandas >=1.0", + "patsy >=0.5.2", + "python >=3.9,<3.10.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "43ffc714487eaa0d0536dcfe4e4f1ee5", + "name": "statsmodels", + "sha256": "b96f272b299aeb8e135fc03f3c4cadcc56e76b2d8d2593ec83c7c9ec55d9b378", + "size": 9058517, + "subdir": "linux-64", + "timestamp": 1635151765338, + "version": "0.13.0" + }, + "statsmodels-0.13.2-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=21.3", + "pandas >=1.0", + "patsy >=0.5.2", + "python >=3.10,<3.11.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "322a7254894f09020a62c740fde58ebc", + "name": "statsmodels", + "sha256": "a8be373b0e87b9f5ed8d486cb3093d9a14c687eee187eb2516268c14bb322c01", + "size": 15336241, + "subdir": "linux-64", + "timestamp": 1648015551848, + "version": "0.13.2" + }, + "statsmodels-0.13.2-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=21.3", + "pandas >=1.0", + "patsy >=0.5.2", + "python >=3.7,<3.8.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f048805f07816ef1025170558b3e775d", + "name": "statsmodels", + "sha256": "df179ebd8f98b0eadc72aef2aef443a791ff876b28417f41cef449d12f76e72f", + "size": 8963151, + "subdir": "linux-64", + "timestamp": 1648033627475, + "version": "0.13.2" + }, + "statsmodels-0.13.2-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=21.3", + "pandas >=1.0", + "patsy >=0.5.2", + "python >=3.8,<3.9.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0360cf19345fe154cba3b99fbff304ad", + "name": "statsmodels", + "sha256": "b27dc35dc106a2862755f90f8ef8c51397688fc4bdde6fa1be52fff538a15349", + "size": 9057219, + "subdir": "linux-64", + "timestamp": 1648033614933, + "version": "0.13.2" + }, + "statsmodels-0.13.2-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "packaging >=21.3", + "pandas >=1.0", + "patsy >=0.5.2", + "python >=3.9,<3.10.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa36111cda75819e449a0abe540de3ce", + "name": "statsmodels", + "sha256": "ea0f133e179bfd47be38375708f6b0cb8e6387cef658cf706e7e0d3d7a0b6adf", + "size": 9056343, + "subdir": "linux-64", + "timestamp": 1648015729202, + "version": "0.13.2" + }, + "statsmodels-0.13.5-py310ha9d4c09_0.conda": { + "build": "py310ha9d4c09_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=21.3", + "pandas >=0.25", + "patsy >=0.5.2", + "python >=3.10,<3.11.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a1fd8b84829e27d4cbf4c5b34df8b11a", + "name": "statsmodels", + "sha256": "31bce0b102bd7a8af88c20292894b8d1ae303a977fc6adc934175fbd9da64d36", + "size": 10859367, + "subdir": "linux-64", + "timestamp": 1674589232348, + "version": "0.13.5" + }, + "statsmodels-0.13.5-py310ha9d4c09_1.conda": { + "build": "py310ha9d4c09_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging >=21.3", + "pandas >=0.25", + "patsy >=0.5.2", + "python >=3.10,<3.11.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "aa010af98abeb0872dad383f0a99c953", + "name": "statsmodels", + "sha256": "a23506a3162b1cbf49ef280509a60088c611aa1699621a63fc287456c8a3c2da", + "size": 10794080, + "subdir": "linux-64", + "timestamp": 1676644038055, + "version": "0.13.5" + }, + "statsmodels-0.13.5-py311h5eee18b_1.conda": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.23.5,<2.0a0", + "packaging >=21.3", + "pandas >=0.25", + "patsy >=0.5.2", + "python >=3.11,<3.12.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee7ea0c0f5b212946f056c3df9056410", + "name": "statsmodels", + "sha256": "cc7a4259835191338d002bb03d5444de4a96d0838a28fe38c6ef7c7430689b1b", + "size": 10837309, + "subdir": "linux-64", + "timestamp": 1676906395241, + "version": "0.13.5" + }, + "statsmodels-0.13.5-py37h7deecbd_0.conda": { + "build": "py37h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=21.3", + "pandas >=0.25", + "patsy >=0.5.2", + "python >=3.7,<3.8.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e53b2ba809010e048049bf77f57673f7", + "name": "statsmodels", + "sha256": "d4c1aeb23b60911b1eb662d0e75e0812bf02a2381ba955b2e8e8a05c0735dc2c", + "size": 10661273, + "subdir": "linux-64", + "timestamp": 1674589440619, + "version": "0.13.5" + }, + "statsmodels-0.13.5-py37h7deecbd_1.conda": { + "build": "py37h7deecbd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=21.3", + "pandas >=0.25", + "patsy >=0.5.2", + "python >=3.7,<3.8.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d0ea39be1fc766aa417130e765da62e9", + "name": "statsmodels", + "sha256": "1848ddf8c58daf636228e2b5a6abec518559d63b5fd319559675007984bfeeb0", + "size": 10536517, + "subdir": "linux-64", + "timestamp": 1676644563073, + "version": "0.13.5" + }, + "statsmodels-0.13.5-py38h7deecbd_0.conda": { + "build": "py38h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=21.3", + "pandas >=0.25", + "patsy >=0.5.2", + "python >=3.8,<3.9.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "73a21255d4b32b74747b9eebf1a308bc", + "name": "statsmodels", + "sha256": "d77a2e0017793378557823c00e4d1874d6b24c71914744dbcbc43dc4e90e948b", + "size": 10804393, + "subdir": "linux-64", + "timestamp": 1674589639258, + "version": "0.13.5" + }, + "statsmodels-0.13.5-py38h7deecbd_1.conda": { + "build": "py38h7deecbd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=21.3", + "pandas >=0.25", + "patsy >=0.5.2", + "python >=3.8,<3.9.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "beb4872f21ed4f34d70e188a97777f0f", + "name": "statsmodels", + "sha256": "d2252a391bcb50788db2fda1c5eebfd881845748ddf52bd1addc91d4d29e207a", + "size": 10674180, + "subdir": "linux-64", + "timestamp": 1676644293948, + "version": "0.13.5" + }, + "statsmodels-0.13.5-py39h7deecbd_0.conda": { + "build": "py39h7deecbd_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=21.3", + "pandas >=0.25", + "patsy >=0.5.2", + "python >=3.9,<3.10.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "71a9b08b46e48efab707d132852bb0d8", + "name": "statsmodels", + "sha256": "16f12f7757acae1a658450865352ca5f99a5d4ed1984a3c81a8cbccb611bdeca", + "size": 10680091, + "subdir": "linux-64", + "timestamp": 1674589002083, + "version": "0.13.5" + }, + "statsmodels-0.13.5-py39h7deecbd_1.conda": { + "build": "py39h7deecbd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging >=21.3", + "pandas >=0.25", + "patsy >=0.5.2", + "python >=3.9,<3.10.0a0", + "scipy >=1.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f883c610adde89be26b38770bc5bcef7", + "name": "statsmodels", + "sha256": "aa9145e8e25578f651607645ae9eee293a372814dfffee4c86da488eb91d8ee1", + "size": 10546864, + "subdir": "linux-64", + "timestamp": 1676644812694, + "version": "0.13.5" + }, + "statsmodels-0.8.0-py27hc87d62d_0.conda": { + "build": "py27hc87d62d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas", + "patsy", + "python >=2.7,<2.8.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7f009b442e3c11fbc56ab39c53145aca", + "name": "statsmodels", + "sha256": "d3a3b472a9ed2c14dda1098c81ac91f4c110cbc6882c17780791c7b645a7f089", + "size": 5481217, + "subdir": "linux-64", + "timestamp": 1505755624968, + "version": "0.8.0" + }, + "statsmodels-0.8.0-py35haa9d50b_0.conda": { + "build": "py35haa9d50b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas", + "patsy", + "python >=3.5,<3.6.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "36a806fae586c5b4847435c8fa379a7c", + "name": "statsmodels", + "sha256": "91975a6f79f018cb7f313115e7018c0450c955cf7ef746a695e6eb7d948bf605", + "size": 5635552, + "subdir": "linux-64", + "timestamp": 1505755744915, + "version": "0.8.0" + }, + "statsmodels-0.8.0-py36h8533d0b_0.conda": { + "build": "py36h8533d0b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas", + "patsy", + "python >=3.6,<3.7.0a0", + "scipy" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "750cf06b7a027e1692b7a3ccda83d4ae", + "name": "statsmodels", + "sha256": "944818dc15c5b561a5a39dec51dad00abd70275201d8f89b4a18bc308fcf62c4", + "size": 5513291, + "subdir": "linux-64", + "timestamp": 1505755867538, + "version": "0.8.0" + }, + "statsmodels-0.9.0-py27h035aef0_0.conda": { + "build": "py27h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "dad28d4092edae1ac574b8aeb35a7555", + "name": "statsmodels", + "sha256": "cbf5fcbcb74c5037aed32415016d18c0fcbc969ab8f553a0648beb2f31673121", + "size": 7313410, + "subdir": "linux-64", + "timestamp": 1530960275773, + "version": "0.9.0" + }, + "statsmodels-0.9.0-py27h3010b51_0.conda": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=2.7,<2.8.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d37c91d67e605c6d16c70f6f9594e8f9", + "name": "statsmodels", + "sha256": "fdb6c267d0d11584ae0416cae6ac6d51045b61768e78602def8f6d7f33382504", + "size": 7268624, + "subdir": "linux-64", + "timestamp": 1526405628041, + "version": "0.9.0" + }, + "statsmodels-0.9.0-py35h3010b51_0.conda": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=3.5,<3.6.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4a47d47efe5a3ed395ca21600c8df4d9", + "name": "statsmodels", + "sha256": "4a28d37b7a9093fb7cbb650217b394da311868c6fa8b970f819b1218b6dd2301", + "size": 7310313, + "subdir": "linux-64", + "timestamp": 1526405659636, + "version": "0.9.0" + }, + "statsmodels-0.9.0-py36h035aef0_0.conda": { + "build": "py36h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9ac5cc882322587f7d00f13c2d91dfd1", + "name": "statsmodels", + "sha256": "fa3c6d10ff0a5c6731ff4cac8678610a2b06313437b15e35a22e51f8e6099e6b", + "size": 7263275, + "subdir": "linux-64", + "timestamp": 1530960556340, + "version": "0.9.0" + }, + "statsmodels-0.9.0-py36h3010b51_0.conda": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=3.6,<3.7.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4e1114bf5f5c8818c662630ec45f1400", + "name": "statsmodels", + "sha256": "65339622ac666ce792a97a8b4427f248a0328bf5fdebe0497b7f08dcc8b63128", + "size": 7207385, + "subdir": "linux-64", + "timestamp": 1526405577681, + "version": "0.9.0" + }, + "statsmodels-0.9.0-py37h035aef0_0.conda": { + "build": "py37h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "pandas >=0.14", + "patsy >=0.4.0", + "python >=3.7,<3.8.0a0", + "scipy >=0.14" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "7a06ac71a62a8d824bbbee39d8b32569", + "name": "statsmodels", + "sha256": "8dfb1afcf555108ef2819fa7445a1dd695f4b50284b7dcfcecfcc4b859e50b2f", + "size": 7275907, + "subdir": "linux-64", + "timestamp": 1530960832276, + "version": "0.9.0" + }, + "stdlib-list-0.8.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d684f9e5a161eeaee7d03b563b9a5377", + "name": "stdlib-list", + "sha256": "ab62fd3751575c61ba557d1e126a09ae61261ceed9352c549e64e1c1de3b76a9", + "size": 27215, + "subdir": "linux-64", + "timestamp": 1676903032671, + "version": "0.8.0" + }, + "stdlib-list-0.8.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a58f636475ce50a5899bb1b4148a5c05", + "name": "stdlib-list", + "sha256": "8e40227f175042acd32f3da8500c132966b69cad52e431bce6dd891d46b7c57f", + "size": 27129, + "subdir": "linux-64", + "timestamp": 1676902970477, + "version": "0.8.0" + }, + "stdlib-list-0.8.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3fbd7f3760fbd9ac71f90e97bb56bf00", + "name": "stdlib-list", + "sha256": "bc3eee2677b8840540c0886474ea360f3f50935328bbdc840bfdd2759df9b8e2", + "size": 27147, + "subdir": "linux-64", + "timestamp": 1676903012038, + "version": "0.8.0" + }, + "stdlib-list-0.8.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e593173d8a42b590f308652490a6b908", + "name": "stdlib-list", + "sha256": "0fa2e43e277b1e44c297285f32ce6b280d2b7f3cefb792ac23f4e3e9ffc9a64a", + "size": 27127, + "subdir": "linux-64", + "timestamp": 1676902991307, + "version": "0.8.0" + }, + "strace_linux-64-11.2.0-h1234567_0.conda": { + "build": "h1234567_0", + "build_number": 0, + "depends": [], + "license": "GPL", + "md5": "77969dee38b8f70c2b2a764150e6c8db", + "name": "strace_linux-64", + "sha256": "175b595a5195bc9c943c9716bf97d426bcf6e48f6278a13fc56a33e6e7973da5", + "size": 459548, + "subdir": "linux-64", + "timestamp": 1652859728530, + "version": "11.2.0" + }, + "strace_linux-64-11.2.0-h1234567_1.conda": { + "build": "h1234567_1", + "build_number": 1, + "depends": [], + "license": "GPL", + "md5": "23f769f21b3037942348adae32455de5", + "name": "strace_linux-64", + "sha256": "05e97cc53c2a12da3891bd89fe1256d6c216649d837f8b5925cb3f34473d06f7", + "size": 460558, + "subdir": "linux-64", + "timestamp": 1654090813833, + "version": "11.2.0" + }, + "streamlit-1.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "attrs >=16.0.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0,<8.1", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "db50eb425fece01f1496379c0f1f233f", + "name": "streamlit", + "sha256": "4d5e599d05d7ca273d595d2baf53cb69cdb77fb51a54fcd1debf1d1157e2c2fd", + "size": 6910744, + "subdir": "linux-64", + "timestamp": 1657914812046, + "version": "1.11.0" + }, + "streamlit-1.11.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "attrs >=16.0.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0,<8.1", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.11,<3.12.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1bdfb23ab301bb80dae74e21199bb53c", + "name": "streamlit", + "sha256": "6c71a45bdc325d9c4c036d1236fb5d0d3879310a7e1cb6e6ce4bcad19ba7dda7", + "size": 7057507, + "subdir": "linux-64", + "timestamp": 1676862799204, + "version": "1.11.0" + }, + "streamlit-1.11.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "attrs >=16.0.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0,<8.1", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ba504932f3f88cbabfd74a1a979e22f5", + "name": "streamlit", + "sha256": "29c4f20bd2de0f49a67a7d1605cdf0bb067013487ba4bce7678e23231beeaa52", + "size": 6895631, + "subdir": "linux-64", + "timestamp": 1657914947994, + "version": "1.11.0" + }, + "streamlit-1.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "attrs >=16.0.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0,<8.1", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fcb0f0e6fb5723e4379630cd5ccee640", + "name": "streamlit", + "sha256": "e503eccb831380b4d79bccaee1d02ece5896ff4fd6083e4777bec63fba7fff41", + "size": 6900000, + "subdir": "linux-64", + "timestamp": 1657914883288, + "version": "1.11.0" + }, + "streamlit-1.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "attrs >=16.0.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0,<8.1", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d46a3e1cf1dbbf9e6b49056dc97b4df3", + "name": "streamlit", + "sha256": "5bbe67abde33abddf7fda84b45a631bc9f02a98cfa40a63a541c45b039851440", + "size": 6905689, + "subdir": "linux-64", + "timestamp": 1657915014540, + "version": "1.11.0" + }, + "streamlit-1.16.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5b6acee88a5bc3157f8cebc3fb319e92", + "name": "streamlit", + "sha256": "6d787cf1e5b593b3bd0761a16b437103534e3b38a3d9287aeb6028e5c8f1e339", + "size": 7698971, + "subdir": "linux-64", + "timestamp": 1673469728176, + "version": "1.16.0" + }, + "streamlit-1.16.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.11,<3.12.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b60a4727c225504315ccf73556109e61", + "name": "streamlit", + "sha256": "a2fcfbb44066ed48c0ab724d58abedc0ed9eaccae5c797371cbc72354963a907", + "size": 7206967, + "subdir": "linux-64", + "timestamp": 1679339302736, + "version": "1.16.0" + }, + "streamlit-1.16.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e22857a4df9bc34bfe1e9368c08c1772", + "name": "streamlit", + "sha256": "29c776e89119084fb295d1281980b61275a985113f2267d20aa98eff99c54602", + "size": 7694130, + "subdir": "linux-64", + "timestamp": 1673469655575, + "version": "1.16.0" + }, + "streamlit-1.16.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "72b8e653dace6e66f7f5d61df54a6e97", + "name": "streamlit", + "sha256": "5b8a6e3eb0b281b0e919b46998963cd1ec893635e3f349470da131e954b46a34", + "size": 7697678, + "subdir": "linux-64", + "timestamp": 1673469800923, + "version": "1.16.0" + }, + "streamlit-1.16.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "altair >=3.2.0", + "blinker >=1.0.0", + "cachetools >=4.0", + "click >=7.0", + "gitpython !=3.1.19", + "importlib-metadata >=1.4", + "numpy", + "packaging >=14.1", + "pandas >=0.21.0", + "pillow >=6.2.0", + "protobuf >=3.12,<4", + "pyarrow >=4.0", + "pydeck >=0.1.dev5", + "pympler >=0.9", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests >=2.4", + "rich >=10.11.0", + "semver", + "toml", + "tornado >=5.0", + "typing_extensions >=3.10.0.0", + "tzlocal >=1.1", + "validators >=0.2", + "watchdog" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "602c125d46011cda3bac92bbd51ff85d", + "name": "streamlit", + "sha256": "80f5f1e3b124631f1b8e78334d2c55c0768f71294bd8cc92d1997dbe54397a8c", + "size": 7695826, + "subdir": "linux-64", + "timestamp": 1673469571036, + "version": "1.16.0" + }, + "streamz-0.2.0-py27h9c708c3_0.conda": { + "build": "py27h9c708c3_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d19beffdcbf14d2c8d763fd9763eb6f9", + "name": "streamz", + "sha256": "35420962b6e921c627d6366d78de1091acdc23946b36ffeaedaef08ddbb95971", + "size": 46720, + "subdir": "linux-64", + "timestamp": 1509178897145, + "version": "0.2.0" + }, + "streamz-0.2.0-py35h3e04ef2_0.conda": { + "build": "py35h3e04ef2_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d95adc30f8b320d4d4fadc2203210743", + "name": "streamz", + "sha256": "cb6f70081c45a5f91969aeae06d029e4ad88e3cfa816beba9c5525c26c6371c5", + "size": 48603, + "subdir": "linux-64", + "timestamp": 1509178917651, + "version": "0.2.0" + }, + "streamz-0.2.0-py36hbb54d36_0.conda": { + "build": "py36hbb54d36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b0399a30df17acd56faf5e73a3c80937", + "name": "streamz", + "sha256": "82c130b9ca08731517368173f338f374578a05dcb2a694e8221b44c78fb35dc3", + "size": 47837, + "subdir": "linux-64", + "timestamp": 1509178925958, + "version": "0.2.0" + }, + "streamz-0.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4d9f4d55ce48a59dcce74eea2bc61bab", + "name": "streamz", + "sha256": "0cd4043823c3c13a725efe64c927ebbd5f4259828e0cb02d09fd03896a766d2d", + "size": 59813, + "subdir": "linux-64", + "timestamp": 1519481559225, + "version": "0.3.0" + }, + "streamz-0.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "499c7f3e666e65e36a1a4c1f09c40117", + "name": "streamz", + "sha256": "27f859c586b63d8f9abe8733cccbc69a0c6d31758f9f0c969f38d7ac32c4a3e7", + "size": 60131, + "subdir": "linux-64", + "timestamp": 1519481577041, + "version": "0.3.0" + }, + "streamz-0.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22aae1a98e5239772c444affcee6ca55", + "name": "streamz", + "sha256": "6675d4f7e02b593bd24b6f55277bf7197ea30af40ae1e621931cf2175270d9d5", + "size": 59702, + "subdir": "linux-64", + "timestamp": 1519481607156, + "version": "0.3.0" + }, + "streamz-0.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3127a48a4ce233a0fa5517c991c203b9", + "name": "streamz", + "sha256": "080aed4d80ddceb745f61f76eea896f0802015a203378b33ff9d483f946ffb5d", + "size": 59969, + "subdir": "linux-64", + "timestamp": 1531059785764, + "version": "0.3.0" + }, + "streamz-0.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "84add3dbd2fe7b2304230a547a25a3f5", + "name": "streamz", + "sha256": "b1df044e1b8936c1ba51d7a2cc543f1254392bce03168f777e238ace00b47c69", + "size": 93393, + "subdir": "linux-64", + "timestamp": 1538171189556, + "version": "0.4.0" + }, + "streamz-0.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7220736a5e5655e434ef14f1c16f12ac", + "name": "streamz", + "sha256": "968e11c4dbaa729cf4504a9f7f2aca131318fbba250d6a2b39e9aea5581f8737", + "size": 96328, + "subdir": "linux-64", + "timestamp": 1538171202061, + "version": "0.4.0" + }, + "streamz-0.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d8005a3496a96f44299b1f834c4e4662", + "name": "streamz", + "sha256": "61a37eb98be9626580ef5e43a95b00fb795af98e6a82eb241fa094781472e905", + "size": 95530, + "subdir": "linux-64", + "timestamp": 1538171196536, + "version": "0.4.0" + }, + "streamz-0.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c2398f7af37538886484d820abb0f2cc", + "name": "streamz", + "sha256": "1d5c2eb92dbd54880c924fe77ac3b00690e4cd892f022ad653775bb2382feb19", + "size": 94783, + "subdir": "linux-64", + "timestamp": 1539648032780, + "version": "0.5.0" + }, + "streamz-0.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "27ca5bb64933c5a4ed94b1ef63585924", + "name": "streamz", + "sha256": "595b811a2d9baaa87980c72edfcfc0819dedf693dec1d2f7ab87cd6dfc1ec8c2", + "size": 95530, + "subdir": "linux-64", + "timestamp": 1539648048974, + "version": "0.5.0" + }, + "streamz-0.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six", + "toolz", + "tornado", + "zict" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d89baa9c4aee8a2fa092648ee509cbbd", + "name": "streamz", + "sha256": "cf814c8af18d83c76cd4949f67517b09bd77ada666b7578577834d10a9d6ac6a", + "size": 95765, + "subdir": "linux-64", + "timestamp": 1539648063751, + "version": "0.5.0" + }, + "stripe-1.68.0-py27hf392dbc_0.conda": { + "build": "py27hf392dbc_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "bd950aac6eea5fc1253fd52fc7e27ecc", + "name": "stripe", + "sha256": "7c699eccfbbbc4cd88a58abfbd3d384ff1f1859febfe5f01fb4ab5eaa4aa1dcd", + "size": 242331, + "subdir": "linux-64", + "timestamp": 1508447844494, + "version": "1.68.0" + }, + "stripe-1.68.0-py35hda75455_0.conda": { + "build": "py35hda75455_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "69be573532261e4d5911be28713ea417", + "name": "stripe", + "sha256": "e531c7bafcae9cb35611ba0d953c5f5ee8ecb39eb92173ba443af0cadcfde98d", + "size": 247490, + "subdir": "linux-64", + "timestamp": 1508447851503, + "version": "1.68.0" + }, + "stripe-1.68.0-py36hf796cb2_0.conda": { + "build": "py36hf796cb2_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "115ffab97b394889ffa0979f05df34c1", + "name": "stripe", + "sha256": "b0c907f8dcb9c41a535849392484d6978ca85c929ad49475ee0bb1b768eda246", + "size": 245407, + "subdir": "linux-64", + "timestamp": 1508447858413, + "version": "1.68.0" + }, + "stripe-1.75.0-py27h5c86c07_0.conda": { + "build": "py27h5c86c07_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "998c4523d6ccdd58c686081ff9befab4", + "name": "stripe", + "sha256": "cefcb8c67053391cedbb327455845d491c3a0db827d73119d53fe5ff42aaad93", + "size": 213145, + "subdir": "linux-64", + "timestamp": 1511834396279, + "version": "1.75.0" + }, + "stripe-1.75.0-py35h03a9acd_0.conda": { + "build": "py35h03a9acd_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "9bf56a2b8aadc9298c0aa8e1aaba09ab", + "name": "stripe", + "sha256": "60e604cba17bb372c75de7691d3d9bdfac797021eaa6ac5563de78f8a8e9bd5b", + "size": 216117, + "subdir": "linux-64", + "timestamp": 1511834412100, + "version": "1.75.0" + }, + "stripe-1.75.0-py36h1abf1ca_0.conda": { + "build": "py36h1abf1ca_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "14377d9afd6ef437d2077ecea0d3a8e0", + "name": "stripe", + "sha256": "ed4da55c7afe95a57a06ba3e8aabfa3433225465459b185328a3a289c488d1be", + "size": 216124, + "subdir": "linux-64", + "timestamp": 1511834412989, + "version": "1.75.0" + }, + "stripe-1.79.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "8db98a7b9d3ce9ddadeeac9c31b29e8d", + "name": "stripe", + "sha256": "4d29887f9f4674f99a78651bacfc0db4576b204932301ee1a85755dade5d30be", + "size": 214645, + "subdir": "linux-64", + "timestamp": 1519674090106, + "version": "1.79.0" + }, + "stripe-1.79.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "df83baa0df9ab241874a719433d44c81", + "name": "stripe", + "sha256": "f64c4f8112690bd8d479534049aa924eba43cef027e3f842da2f24210b376194", + "size": 217665, + "subdir": "linux-64", + "timestamp": 1519674111899, + "version": "1.79.0" + }, + "stripe-1.79.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "b8d4a7162cd7c527f559791c67b6c0c3", + "name": "stripe", + "sha256": "8325527e6c76dd4b4a2378978caf86a0c0235957053280becc43cb41dcde1abb", + "size": 217313, + "subdir": "linux-64", + "timestamp": 1519674226898, + "version": "1.79.0" + }, + "stripe-1.79.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "0baadbbdda52e32f14277eaab0369499", + "name": "stripe", + "sha256": "4d867a6a479311c5ba37a1c1f133f6b5581953262c4bd5dc7bdd27d918a6d30e", + "size": 214807, + "subdir": "linux-64", + "timestamp": 1524070741550, + "version": "1.79.1" + }, + "stripe-1.79.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "8240774216c72671f90b0a80ddb8b51c", + "name": "stripe", + "sha256": "e4f55db7cbb553f5c66ea19967f74d227bea302d17f97ff15b6440780e2c4e78", + "size": 216737, + "subdir": "linux-64", + "timestamp": 1524070743961, + "version": "1.79.1" + }, + "stripe-1.79.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "79a135b7a6c7e78383f68a3ddae05ec3", + "name": "stripe", + "sha256": "efc031804a18bee9e3c9b142beb4bf3f62e5ad7b4501a9c9203be63d26be53b6", + "size": 216180, + "subdir": "linux-64", + "timestamp": 1524070751579, + "version": "1.79.1" + }, + "stripe-1.82.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "0e34fdda195ee821bca04a2bde82d8af", + "name": "stripe", + "sha256": "1fd0a8ca7adf3d9bf9a6ee15b7071f3fc4eee5e2a974550c89b6be73dff800e1", + "size": 216047, + "subdir": "linux-64", + "timestamp": 1526922900959, + "version": "1.82.1" + }, + "stripe-1.82.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "907a828b09b0a352d2f1c896e55670c6", + "name": "stripe", + "sha256": "34c7451a7a9339e8f8e0f7498fa9045b27c8f3bd74e296ff74115daf5dc6f772", + "size": 217710, + "subdir": "linux-64", + "timestamp": 1526922923711, + "version": "1.82.1" + }, + "stripe-1.82.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "d8f1f1b547d14c8d38b6bf2389cbf4c2", + "name": "stripe", + "sha256": "c0bf763e7bdd48310aef4f7139cccf35faa176ef177254b0d2ca3bcdc6d4c6e8", + "size": 218440, + "subdir": "linux-64", + "timestamp": 1526922874337, + "version": "1.82.1" + }, + "stripe-1.82.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "e7ef1778821c5dcca403025b296f518e", + "name": "stripe", + "sha256": "830beb3e9b54faa4d773db34ae994072f26048e4169b24d4d37b1dff7a168d3b", + "size": 216213, + "subdir": "linux-64", + "timestamp": 1529951156151, + "version": "1.82.2" + }, + "stripe-1.82.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "6ae2d958e1b5615b0a651505b1561dc5", + "name": "stripe", + "sha256": "9b61dc4f33284d02019b1772d9dbb8fe787092d9c1b47b8aa9e9587030af5c13", + "size": 219393, + "subdir": "linux-64", + "timestamp": 1529951164692, + "version": "1.82.2" + }, + "stripe-1.82.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "154723505806a0a3a42eb45d3d4a3e71", + "name": "stripe", + "sha256": "1ebabff17feef186f748f59d951281e521693ade8260fd83978257d9ca6c7af8", + "size": 217141, + "subdir": "linux-64", + "timestamp": 1529951111637, + "version": "1.82.2" + }, + "stripe-1.82.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=0.8.8" + ], + "license": "MIT", + "md5": "a54ac9de40704987ec668dc519a90c92", + "name": "stripe", + "sha256": "cd9fe9c57df803307775e552e3ce055988a4225f805a7522c7db6a3527fcb0cb", + "size": 218696, + "subdir": "linux-64", + "timestamp": 1531059827273, + "version": "1.82.2" + }, + "stripe-2.10.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "1f726128041c04c6c168b45d030bde0a", + "name": "stripe", + "sha256": "911678c091c65be05aa9fb7af371495826cb70065bf446cdbf76000ff8f7cb2e", + "size": 216849, + "subdir": "linux-64", + "timestamp": 1539644511049, + "version": "2.10.1" + }, + "stripe-2.10.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "2b211655e56a06ec52f98ce0238931a9", + "name": "stripe", + "sha256": "606e3ef6d4e159d1ca039abfcb51f8ab489055db0aa6d74a6a5249c8b647dcf0", + "size": 220447, + "subdir": "linux-64", + "timestamp": 1539644519644, + "version": "2.10.1" + }, + "stripe-2.10.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "1ac7c0e01ef12076d0fc77681d5e9990", + "name": "stripe", + "sha256": "a57e6ab80f797a66337c09a40d58407bf66044e20cbaaefa1eb096c0f04a6b46", + "size": 219207, + "subdir": "linux-64", + "timestamp": 1539644522073, + "version": "2.10.1" + }, + "stripe-2.11.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "71c640f0b9b377ffc23cd78183afba5f", + "name": "stripe", + "sha256": "e01d7165564e546d6164c5e23111ec71a455a7a983c89f3dbd6fcf74319ab93e", + "size": 218562, + "subdir": "linux-64", + "timestamp": 1541053519899, + "version": "2.11.0" + }, + "stripe-2.11.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "875be4376a838c9464058cafef2f5acb", + "name": "stripe", + "sha256": "e39a0577a679ce58979e45201da1c26f918228490858f37c4b82bb5e54ff8ed1", + "size": 219627, + "subdir": "linux-64", + "timestamp": 1541053539846, + "version": "2.11.0" + }, + "stripe-2.11.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "80977bd8495d54136e7e5b627a7c759d", + "name": "stripe", + "sha256": "74a278f36f629e92b89ae842d7b733fbe47b4393770ad3a03de1de39d061270a", + "size": 220050, + "subdir": "linux-64", + "timestamp": 1541053513448, + "version": "2.11.0" + }, + "stripe-2.12.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "dc422be0240505292262a70a43feb40e", + "name": "stripe", + "sha256": "ccf27ba9d67604ad9a286466edb97479fd02bd20d8f7f8aa9cc30008ff70ca6e", + "size": 218691, + "subdir": "linux-64", + "timestamp": 1542091330033, + "version": "2.12.0" + }, + "stripe-2.12.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "c05be27d3a2ecc32f55a9a5dd5606af7", + "name": "stripe", + "sha256": "fb2b05505a0ba7f8096aadb12a753b86f4fd66e024b78cf3e9289d53722fdc39", + "size": 220196, + "subdir": "linux-64", + "timestamp": 1542091387358, + "version": "2.12.0" + }, + "stripe-2.12.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "df6ff65d33ceea551ce6b61a113c9292", + "name": "stripe", + "sha256": "64aaebe7099c69c9897fb13a696ff07a3ba2f15ca1a8ef7cf2d207b5684515f8", + "size": 220044, + "subdir": "linux-64", + "timestamp": 1542091350897, + "version": "2.12.0" + }, + "stripe-2.16.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "343f01ccd0e9cbe6194530ddd409d83f", + "name": "stripe", + "sha256": "69237317d0e09859afafc0473113e54b736f5b15e1df709f34346f4bde63c2de", + "size": 197807, + "subdir": "linux-64", + "timestamp": 1545109337355, + "version": "2.16.0" + }, + "stripe-2.16.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "0ad6f953c4283f182e989c8f8e28e37e", + "name": "stripe", + "sha256": "c50dfa998154c048c49aeb6641fffe134c2c495643727098eda26919030465c2", + "size": 199462, + "subdir": "linux-64", + "timestamp": 1545109348757, + "version": "2.16.0" + }, + "stripe-2.16.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "582d8010ccd87c704e1193cbc0265ccb", + "name": "stripe", + "sha256": "627b1fe8b6a68d071d6632faf89422104ebb66ca243256acb3529e56ba7b9fa6", + "size": 199111, + "subdir": "linux-64", + "timestamp": 1545109380389, + "version": "2.16.0" + }, + "stripe-2.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "72f6bd94ddac6dd6435e629c8ac90083", + "name": "stripe", + "sha256": "ddeab8c22dcebd0af50b916a8b97121e3cb39f61fd278271860c83b69d79ad21", + "size": 213767, + "subdir": "linux-64", + "timestamp": 1532631504987, + "version": "2.2.0" + }, + "stripe-2.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "66c8f74a42e67c0e01fb24c165beeb56", + "name": "stripe", + "sha256": "a104694e3530987e2a26bd2a04ed63714106d6f10dbe19d094564f9041c174d5", + "size": 215983, + "subdir": "linux-64", + "timestamp": 1532631537503, + "version": "2.2.0" + }, + "stripe-2.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "4c252285b920aa811e925e803ee290c4", + "name": "stripe", + "sha256": "74d457b87a628e04a7d78c2778c5ba57d24f1b7d1140b39856a4bc4b982febee", + "size": 215142, + "subdir": "linux-64", + "timestamp": 1532631485544, + "version": "2.2.0" + }, + "stripe-2.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "0b1342d6d6d1b6a63492b2e3510ad2b3", + "name": "stripe", + "sha256": "0f2fbf8d0510b4246058d0b81260ecc204c75a9e69fb6238ba0382dcac814ff1", + "size": 215196, + "subdir": "linux-64", + "timestamp": 1532631545668, + "version": "2.2.0" + }, + "stripe-2.21.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "1379362344a3e3a1af829e101ecf5cc6", + "name": "stripe", + "sha256": "20986d6c338f443a92be337051c11964e762ab89b8e48f78358aa7c15086f82a", + "size": 348780, + "subdir": "linux-64", + "timestamp": 1550363342554, + "version": "2.21.0" + }, + "stripe-2.21.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "3680990c9f9ebd477f552bfa5db17652", + "name": "stripe", + "sha256": "e4898562b06f62aef4129485f5ddbb4e6b520ae66fb14ffa4d2f51534df8c841", + "size": 349593, + "subdir": "linux-64", + "timestamp": 1550363364227, + "version": "2.21.0" + }, + "stripe-2.21.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "ada2fa3fa64d310e55335f504d95b2e7", + "name": "stripe", + "sha256": "9e2e608af9e1d1e7e97e82af2226042208b69ce38c6f421fa6426a86c9965ae6", + "size": 349762, + "subdir": "linux-64", + "timestamp": 1550363325342, + "version": "2.21.0" + }, + "stripe-2.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "d367dc40efdc27a86160cadaddcf889e", + "name": "stripe", + "sha256": "fc3c02f0f43dfa769e7f464a8b4196117611a109dce3541bcf6a0d6511d5f137", + "size": 213782, + "subdir": "linux-64", + "timestamp": 1534661578547, + "version": "2.5.0" + }, + "stripe-2.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "c4c553cbfd4fb9ca22b655661c59b7b8", + "name": "stripe", + "sha256": "d238a9c1cddeb8daec60ad3ea35e266ba6902e195503ee9ee3eacd53f842e248", + "size": 217046, + "subdir": "linux-64", + "timestamp": 1534661101560, + "version": "2.5.0" + }, + "stripe-2.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "e6f8140ec58de00376103e8cbf545564", + "name": "stripe", + "sha256": "35deb5e5e63b2686da53d6486add9086fdc48d98818cae8e58fc6367f8cfc63d", + "size": 217165, + "subdir": "linux-64", + "timestamp": 1534662761057, + "version": "2.5.0" + }, + "stripe-2.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "703bea7b23454950d64f14a118548925", + "name": "stripe", + "sha256": "4b7094ee081e04d1ce614579a7a55d05da7a724e8e5d94cce1f7aad98f883b95", + "size": 215835, + "subdir": "linux-64", + "timestamp": 1534661637889, + "version": "2.5.0" + }, + "stripe-2.6.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "8ad0795a7384a94ee0b8c5b88f16c525", + "name": "stripe", + "sha256": "badcc49046ff7c88d15fb5791f7290233d729caea786b4cb16d7ea317e300a80", + "size": 214902, + "subdir": "linux-64", + "timestamp": 1535497540430, + "version": "2.6.0" + }, + "stripe-2.6.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "3d72671a808bfe14b2ebba2ff101179c", + "name": "stripe", + "sha256": "fd689f46fa546d1364a9625de44c3da76378cca4a161fad38e784b769eb07a4b", + "size": 217180, + "subdir": "linux-64", + "timestamp": 1535497574032, + "version": "2.6.0" + }, + "stripe-2.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "b5603c847ec9e4b555c160b0279f1eb8", + "name": "stripe", + "sha256": "d0ebf55713b23cbb00b140780f9723d7e56d65948b9612496563aaa70ea108f2", + "size": 217332, + "subdir": "linux-64", + "timestamp": 1535497549471, + "version": "2.6.0" + }, + "stripe-2.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2" + ], + "license": "MIT", + "md5": "f1cec944533ac885ba3d053403cde0d3", + "name": "stripe", + "sha256": "2072627a8925dc13acf9aff0c22a9e0819697d4a3c81ce924fe44b9e596bff3c", + "size": 216388, + "subdir": "linux-64", + "timestamp": 1535497572093, + "version": "2.6.0" + }, + "subprocess32-3.2.7-py27h373dbce_0.conda": { + "build": "py27h373dbce_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "5bd4e75f5db98f5c6dd443c745d91827", + "name": "subprocess32", + "sha256": "40eff05233f07e83edc84d1eeefbeb0088cbf6bece899599758fc21c924e2dda", + "size": 39951, + "subdir": "linux-64", + "timestamp": 1505739293719, + "version": "3.2.7" + }, + "subprocess32-3.5.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "c4914a401887ff83392128533c2fde2c", + "name": "subprocess32", + "sha256": "4c58abcccf84dd49a9a3ce63ab31eb7071372ef2a16f221b8867853b25e62611", + "size": 41471, + "subdir": "linux-64", + "timestamp": 1526493434141, + "version": "3.5.0" + }, + "subprocess32-3.5.1-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "cdbb6b36bef4e80807b0cab439e69e44", + "name": "subprocess32", + "sha256": "ee68865a427f7e2c195ed276a85698573167e967f6daf6f8fe693ef308678455", + "size": 41011, + "subdir": "linux-64", + "timestamp": 1527830398885, + "version": "3.5.1" + }, + "subprocess32-3.5.2-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "cb691347b7845f53784a729a2d378046", + "name": "subprocess32", + "sha256": "fde776f4adc836e3b71c9432875cf7cb5c90b564c289345454c8e6de2bd3a473", + "size": 41248, + "subdir": "linux-64", + "timestamp": 1528908524109, + "version": "3.5.2" + }, + "subprocess32-3.5.3-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "PSF 2", + "md5": "39806e7dd97edf8611c05a9a438222c9", + "name": "subprocess32", + "sha256": "997a9678908615e648aa30a6058053673b53311a58c191dd9fb9d6b684b43935", + "size": 45441, + "subdir": "linux-64", + "timestamp": 1539636015303, + "version": "3.5.3" + }, + "subprocess32-3.5.4-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Python-2.0", + "md5": "38f5fbe74afda48bb0e2aae7e6f5ae27", + "name": "subprocess32", + "sha256": "aeaadb26950a88daa8d658d034995c715f26c1feafa660a8a461e85f18e65edc", + "size": 52390, + "subdir": "linux-64", + "timestamp": 1559849640809, + "version": "3.5.4" + }, + "suds-jurko-0.6-py27_3.conda": { + "build": "py27_3", + "build_number": 3, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "efcfc3d80e3d3e26657ed49883ffe6eb", + "name": "suds-jurko", + "sha256": "1ed6498c6d87283912f8cad1c9aaaa73c71e4963bae40f6208a6fad71dba5b19", + "size": 250473, + "subdir": "linux-64", + "timestamp": 1537813327879, + "version": "0.6" + }, + "suds-jurko-0.6-py310h06a4308_3.conda": { + "build": "py310h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "4d1e5d28acd4193b52f0c90c537c7207", + "name": "suds-jurko", + "sha256": "95150acf6306c6440697aca486e4030e4d25047a22bf7eb12386205ae7e3c11a", + "size": 254061, + "subdir": "linux-64", + "timestamp": 1641555152334, + "version": "0.6" + }, + "suds-jurko-0.6-py35_3.conda": { + "build": "py35_3", + "build_number": 3, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "847669c9b12138bf0ce4fb9fba63723e", + "name": "suds-jurko", + "sha256": "f6d8d9a4c565e6645150c4fa6747bcc3cef76d6f5f0d8a9f5a34605748739842", + "size": 252714, + "subdir": "linux-64", + "timestamp": 1537813370401, + "version": "0.6" + }, + "suds-jurko-0.6-py36_3.conda": { + "build": "py36_3", + "build_number": 3, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "55e209eaf007ad3e61754327e94907a7", + "name": "suds-jurko", + "sha256": "bca9b300559aecea21f57d60a0975c3ccbb79cab3bc196242937b7a7c1ff21d8", + "size": 246149, + "subdir": "linux-64", + "timestamp": 1537813396445, + "version": "0.6" + }, + "suds-jurko-0.6-py36h06a4308_3.conda": { + "build": "py36h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "c91ede22027052e1614fd875e95e3cf4", + "name": "suds-jurko", + "sha256": "09aad7bd8006be268f4af40cda4d156f6aa7f95e5cfc6dd8c2142b541339003e", + "size": 251101, + "subdir": "linux-64", + "timestamp": 1614246460290, + "version": "0.6" + }, + "suds-jurko-0.6-py37_3.conda": { + "build": "py37_3", + "build_number": 3, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "3faac88e2d56bdd8f922d68060584418", + "name": "suds-jurko", + "sha256": "49966a26deabe7f2f69d2071e7966f0ef53148af9196970d2aac81dbc403e7b5", + "size": 247936, + "subdir": "linux-64", + "timestamp": 1537813333522, + "version": "0.6" + }, + "suds-jurko-0.6-py37h06a4308_3.conda": { + "build": "py37h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "0f9580203aed1b0a6a1b128effbe02c7", + "name": "suds-jurko", + "sha256": "f47c3240aff939d7c8a91ece3ff756ebec5192eddd0fa745acc2af13a513e11a", + "size": 253233, + "subdir": "linux-64", + "timestamp": 1614247315187, + "version": "0.6" + }, + "suds-jurko-0.6-py38_3.conda": { + "build": "py38_3", + "build_number": 3, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "b2c06e907b15cd3e3562f232d315a839", + "name": "suds-jurko", + "sha256": "5efaa096353d7d4579ecf95957d6ad7607e549532e5147a884c6020fc0227a01", + "size": 252406, + "subdir": "linux-64", + "timestamp": 1573661817788, + "version": "0.6" + }, + "suds-jurko-0.6-py38h06a4308_3.conda": { + "build": "py38h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "90cfd1ae8c1080ba4e1102eebc59e5a1", + "name": "suds-jurko", + "sha256": "52336208e42e9f152cd607ac85404c53d891f07a5dcd25ccbc81bf1e0ecc7e09", + "size": 254280, + "subdir": "linux-64", + "timestamp": 1614247323227, + "version": "0.6" + }, + "suds-jurko-0.6-py39h06a4308_3.conda": { + "build": "py39h06a4308_3", + "build_number": 3, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-3.0", + "license_family": "GPL3", + "md5": "3394cdaf7bab43262dd6dbf5160ff615", + "name": "suds-jurko", + "sha256": "53b99652a2b80f5f1d8e28bf524109b82fc52cc446fbe65a4dbc7e47707ce57d", + "size": 253470, + "subdir": "linux-64", + "timestamp": 1614247317126, + "version": "0.6" + }, + "suitesparse-5.10.1-h17784d6_1.conda": { + "build": "h17784d6_1", + "build_number": 1, + "depends": [ + "blas * openblas", + "gmp >=6.1.2", + "libgcc-ng >=7.5.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.5.0", + "metis >=5.1.0,<6.0a0", + "mpfr >=4.0.2,<5.0a0", + "tbb >=2020.3" + ], + "license": "LGPL v2 (AMD, BTF, etc), BSD 3-clause (UFget), GPL v2 (UMFPACK, RBIO, SPQR, GPUQRENGINE), Apache 2.0 (Metis)", + "md5": "8592f5c0ea86f86eb966103c3bcdce76", + "name": "suitesparse", + "sha256": "7df953c2bc5f3924f390ef681a1747cc62702316eb2185167244b8281444183b", + "size": 1438184, + "subdir": "linux-64", + "timestamp": 1655304810320, + "version": "5.10.1" + }, + "suitesparse-5.10.1-h1fa4727_1.conda": { + "build": "h1fa4727_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "gmp >=6.1.2", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "metis >=5.1.0,<6.0a0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mpfr >=4.0.2,<5.0a0", + "tbb >=2020.3" + ], + "license": "LGPL v2 (AMD, BTF, etc), BSD 3-clause (UFget), GPL v2 (UMFPACK, RBIO, SPQR, GPUQRENGINE), Apache 2.0 (Metis)", + "md5": "87f00f86c5f43e3ccf2ef5274de9004a", + "name": "suitesparse", + "sha256": "8910998290f2d904628ee24dfc76887fec479c3fddad5b4e4ac199c3297e5dcc", + "size": 1438431, + "subdir": "linux-64", + "timestamp": 1655304659525, + "version": "5.10.1" + }, + "suitesparse-5.10.1-h446ee2e_2.conda": { + "build": "h446ee2e_2", + "build_number": 2, + "depends": [ + "blas 1.0 mkl", + "gmp >=6.1.2", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "metis >=5.1.0,<6.0a0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mpfr >=4.0.2,<5.0a0", + "tbb >=2020.3" + ], + "license": "LGPL v2 (AMD, BTF, etc), BSD 3-clause (UFget), GPL v2 (UMFPACK, RBIO, SPQR, GPUQRENGINE), Apache 2.0 (Metis)", + "md5": "ccba0d389b79e8cad86ea5f024f540e4", + "name": "suitesparse", + "sha256": "3384492c5956cfeaa60d919fa04a0675a73224b3aee21d47550eb63dbfae2eab", + "size": 1393457, + "subdir": "linux-64", + "timestamp": 1656059765847, + "version": "5.10.1" + }, + "suitesparse-5.10.1-hccbcb17_0.conda": { + "build": "hccbcb17_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "metis >=5.1.0,<6.0a0", + "mkl >=2021.4.0,<2022.0a0", + "mkl-service >=2.3.0,<3.0a0", + "mpfr >=4.0.2,<5.0a0", + "tbb >=2020.3" + ], + "license": "LGPL v2 (AMD, BTF, etc), BSD 3-clause (UFget), GPL v2 (UMFPACK, RBIO, SPQR, GPUQRENGINE), Apache 2.0 (Metis)", + "md5": "348ec21483da3c249ff59b0157504b52", + "name": "suitesparse", + "sha256": "3a9813450309eb51553bb930300bee025fe167da01da659037a5e8a46b14edb5", + "size": 1436490, + "subdir": "linux-64", + "timestamp": 1641890340953, + "version": "5.10.1" + }, + "suitesparse-5.10.1-he2db622_2.conda": { + "build": "he2db622_2", + "build_number": 2, + "depends": [ + "blas * openblas", + "gmp >=6.1.2", + "libgcc-ng >=11.2.0", + "libopenblas >=0.3.20,<1.0a0", + "libstdcxx-ng >=11.2.0", + "metis >=5.1.0,<6.0a0", + "mpfr >=4.0.2,<5.0a0", + "tbb >=2020.3" + ], + "license": "LGPL v2 (AMD, BTF, etc), BSD 3-clause (UFget), GPL v2 (UMFPACK, RBIO, SPQR, GPUQRENGINE), Apache 2.0 (Metis)", + "md5": "03ad91779f2c3eb057e860bb066c29cc", + "name": "suitesparse", + "sha256": "321340c7129af554162ce31dac7f2d8a3037e5b3d901df86b1ca12143a9635ef", + "size": 1393314, + "subdir": "linux-64", + "timestamp": 1656059595613, + "version": "5.10.1" + }, + "suitesparse-5.2.0-h0253a28_0.conda": { + "build": "h0253a28_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "metis >=5.1.0,<6.0a0", + "tbb >=2018.0.4,<2019.0a0" + ], + "license": "LGPL v2 (AMD, BTF, etc), BSD 3-clause (UFget), GPL v2 (UMFPACK, RBIO, SPQR, GPUQRENGINE), Apache 2.0 (Metis)", + "md5": "2b03024332747557daec0f0c5b746300", + "name": "suitesparse", + "sha256": "e2cb9bbe97aa2dca9da0f207e410b871c31bcd5d27cbdce4017b247a8db2ee61", + "size": 1372946, + "subdir": "linux-64", + "timestamp": 1528940862588, + "version": "5.2.0" + }, + "suitesparse-5.2.0-h171a5a3_0.conda": { + "build": "h171a5a3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "metis >=5.1.0,<6.0a0", + "mkl >=2018.0.3,<2019.0a0", + "tbb >=2018.0.4,<2019.0a0" + ], + "license": "LGPL v2 (AMD, BTF, etc), BSD 3-clause (UFget), GPL v2 (UMFPACK, RBIO, SPQR, GPUQRENGINE), Apache 2.0 (Metis)", + "md5": "e65418c65b9a3ee7a89d67c563448db7", + "name": "suitesparse", + "sha256": "2cbee2c57f8d2a70ea736d5df28a02c6765bfa456f19a7e00ece2b14da125562", + "size": 1372385, + "subdir": "linux-64", + "timestamp": 1528940946760, + "version": "5.2.0" + }, + "suitesparse-5.2.0-h2ffa06c_0.conda": { + "build": "h2ffa06c_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "metis >=5.1.0,<6.0a0", + "tbb >=2019.1" + ], + "license": "LGPL v2 (AMD, BTF, etc), BSD 3-clause (UFget), GPL v2 (UMFPACK, RBIO, SPQR, GPUQRENGINE), Apache 2.0 (Metis)", + "md5": "53854f3a76f7339ab8ffbb69ab609e72", + "name": "suitesparse", + "sha256": "708b086aab535b5ddbb35d9ef6f2ada3cbd86be702f7bd40558f682f39ff86ca", + "size": 1398436, + "subdir": "linux-64", + "timestamp": 1550646422332, + "version": "5.2.0" + }, + "suitesparse-5.2.0-h9e4a6bb_0.conda": { + "build": "h9e4a6bb_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "metis >=5.1.0,<6.0a0", + "mkl >=2019.1,<2021.0a0", + "tbb >=2019.1" + ], + "license": "LGPL v2 (AMD, BTF, etc), BSD 3-clause (UFget), GPL v2 (UMFPACK, RBIO, SPQR, GPUQRENGINE), Apache 2.0 (Metis)", + "md5": "cc2db7dedca71cdde94b5c227109c131", + "name": "suitesparse", + "sha256": "a0b8ae3204beb7806497e051cf94eb2f55fbedfa1f6dac8ddb26f7e3b3b1cf4a", + "size": 1398407, + "subdir": "linux-64", + "timestamp": 1550646469944, + "version": "5.2.0" + }, + "supervisor-3.3.3-py27h9aadb0f_0.conda": { + "build": "py27h9aadb0f_0", + "build_number": 0, + "depends": [ + "meld3 >=0.6.5", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "9116f537e74a6b7e3eb7c64d35fdff40", + "name": "supervisor", + "sha256": "40c90ba11b4d0f10e3d53c737ed9e8734b0b26d8d5585dd9333dedcabe77ae58", + "size": 497867, + "subdir": "linux-64", + "timestamp": 1508999918344, + "version": "3.3.3" + }, + "supervisor-3.3.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=0.6.5", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "4636cd256773e191fd4ce068147c8c75", + "name": "supervisor", + "sha256": "86a32f9ddad3f85dedf61f971459c5409d3eb1cb0194aad46a88c08794f3c0d3", + "size": 502113, + "subdir": "linux-64", + "timestamp": 1520793743501, + "version": "3.3.4" + }, + "supervisor-3.3.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=0.6.5", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "a34515a545a15d41fb6a15053b981412", + "name": "supervisor", + "sha256": "64f70431c86d8510ba9a164bb4612049363e5a4218acb4d38742d836e8d86666", + "size": 505153, + "subdir": "linux-64", + "timestamp": 1548006621221, + "version": "3.3.5" + }, + "supervisor-4.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "2bd917659d9e347ee77e60521a889d9b", + "name": "supervisor", + "sha256": "81aebe33856bac68061e9b113d0893ab0958f9bbd04554b21434593ee919f193", + "size": 530622, + "subdir": "linux-64", + "timestamp": 1556076712610, + "version": "4.0.2" + }, + "supervisor-4.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "f91b0566ee471c64134f7595851761f2", + "name": "supervisor", + "sha256": "d08ee6fb936481a2a2773d0d6ac6fdd1c3de79c2366775ac4ed378328c1a3403", + "size": 542126, + "subdir": "linux-64", + "timestamp": 1556076750652, + "version": "4.0.2" + }, + "supervisor-4.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "7307eef662cb833d22624ea119cbd6ed", + "name": "supervisor", + "sha256": "5c4c1b152812cf10f8f1fc8d832e55cf7bfd4a5a4ec5480cdcc6775bae4dc601", + "size": 539467, + "subdir": "linux-64", + "timestamp": 1556076854283, + "version": "4.0.2" + }, + "supervisor-4.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "cb63076877d3f29d0d6bb6682c6fed0f", + "name": "supervisor", + "sha256": "401349cfa6558800d9d3ebd2447acb164a6134192bda3d1901bb34e4f8b79bb8", + "size": 536338, + "subdir": "linux-64", + "timestamp": 1559925087743, + "version": "4.0.3" + }, + "supervisor-4.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "2e7136f34c6aee7c203e9cdbfff5c9c6", + "name": "supervisor", + "sha256": "1d18ad36711c642db2612953d9afd0b033aee296447d4e77a0eb397197ecfb80", + "size": 545457, + "subdir": "linux-64", + "timestamp": 1559925103215, + "version": "4.0.3" + }, + "supervisor-4.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "bb22be4bfd9d9f3ce3958a067f759ef6", + "name": "supervisor", + "sha256": "5192bd183b14d029622f4c04c56ba448fdba08b4dcff8ff54043f308d8b7350f", + "size": 544914, + "subdir": "linux-64", + "timestamp": 1559925071121, + "version": "4.0.3" + }, + "supervisor-4.0.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "1cf5a453d7e376a3820439dc51dcef9d", + "name": "supervisor", + "sha256": "49b450c7934fd45bffdafd6b871b969b711a7e5af16395429bd9789fb5263fc3", + "size": 536975, + "subdir": "linux-64", + "timestamp": 1564709062002, + "version": "4.0.4" + }, + "supervisor-4.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "f9dfda603f01c559372ebc5e05a03760", + "name": "supervisor", + "sha256": "ca7f6fdfa2a1a9ac57753ecbe79eb57ac48e8f9008e4ff0b02940c0482d78f83", + "size": 545923, + "subdir": "linux-64", + "timestamp": 1564709090787, + "version": "4.0.4" + }, + "supervisor-4.0.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "1fbef5f495c542d0b9eca6c949e432f2", + "name": "supervisor", + "sha256": "aa1d93714593a9d48a8a71da2a457e13bba9d5fa97dfe22d8ec3f4740ee32674", + "size": 545515, + "subdir": "linux-64", + "timestamp": 1564709013545, + "version": "4.0.4" + }, + "supervisor-4.0.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "4f93892bfb2a824be3020eb091f8e78c", + "name": "supervisor", + "sha256": "72b719470a58df82281878f44caf0f41799d9d28ecc75400138aa1f8a4ba9c0e", + "size": 547026, + "subdir": "linux-64", + "timestamp": 1573554618289, + "version": "4.0.4" + }, + "supervisor-4.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "014c90914a81f0dd92c6a392ba4bbf64", + "name": "supervisor", + "sha256": "1663d5a4277d81894446fc07875cb3e28ad507d7c2cc0e222ffbd5adcd51fe15", + "size": 581326, + "subdir": "linux-64", + "timestamp": 1573973797500, + "version": "4.1.0" + }, + "supervisor-4.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "99960230f884eb55c2353491a16b66ee", + "name": "supervisor", + "sha256": "7ef3134f4ec6b4cd701e63319830d7654aa3b54af13f2b13e629efe247f8f700", + "size": 590343, + "subdir": "linux-64", + "timestamp": 1573973795992, + "version": "4.1.0" + }, + "supervisor-4.1.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "meld3 >=1", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "6044229be17eb3b662ac2ecc7942a075", + "name": "supervisor", + "sha256": "fb3ccf040421ae2dd9cd88453398d92d87c0c84a516531b7cc3603d912c0accd", + "size": 586649, + "subdir": "linux-64", + "timestamp": 1614080336814, + "version": "4.1.0" + }, + "supervisor-4.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "de63068c45942fdc97dc36bdaf37aec9", + "name": "supervisor", + "sha256": "e0b3406279c14d64cb6613bd69709496b29929c65540e955403bec92b49a9a34", + "size": 589669, + "subdir": "linux-64", + "timestamp": 1573973757279, + "version": "4.1.0" + }, + "supervisor-4.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "meld3 >=1", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "8b351c100c72bbbb98481e86477abdae", + "name": "supervisor", + "sha256": "fe96b49b397929e1bfa728eca49c16b2dca136edcdc863dae2e71cbaec97d777", + "size": 589723, + "subdir": "linux-64", + "timestamp": 1614081253567, + "version": "4.1.0" + }, + "supervisor-4.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "gettext >=0.19.8.1,<1.0a0", + "meld3 >=1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "cb74bf81451bac10481f7e8cc9e3f214", + "name": "supervisor", + "sha256": "dbcf7375b86f87cc1e28ac4819532bad8f05ed5cf4fad40cf1be2e8ad619809f", + "size": 595533, + "subdir": "linux-64", + "timestamp": 1573973792000, + "version": "4.1.0" + }, + "supervisor-4.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "meld3 >=1", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "62d17936b9e1cf958dc945bdb1f4c89b", + "name": "supervisor", + "sha256": "5e3ce909864b9f81f6d2afa4fa4ec1b2af8f8e3d1b32d0d69c0ffddea1b1e2b8", + "size": 592398, + "subdir": "linux-64", + "timestamp": 1614081255050, + "version": "4.1.0" + }, + "supervisor-4.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "meld3 >=1", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "694906bb4f93e78f9d8d1d5e08f2dd51", + "name": "supervisor", + "sha256": "41385f6912d7444bb28a6dc4377eea090bea22116ad0b32cfd91494300e7b85c", + "size": 595880, + "subdir": "linux-64", + "timestamp": 1614081250986, + "version": "4.1.0" + }, + "supervisor-4.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "5fe7884df2d7629a07382b8396048140", + "name": "supervisor", + "sha256": "9f278703e397b3ff21aea5872b95627886ed0f687593515e1fba4321e12bb54a", + "size": 584275, + "subdir": "linux-64", + "timestamp": 1597083414680, + "version": "4.2.0" + }, + "supervisor-4.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "c7ebecca9b5d7dc759b54b61a03fedbd", + "name": "supervisor", + "sha256": "d4172d55b467298a14033ec21aee10f87bf1bad14eb044ec31e3d80700ebf1c3", + "size": 584398, + "subdir": "linux-64", + "timestamp": 1600554370558, + "version": "4.2.1" + }, + "supervisor-4.2.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "540cb25c41aab67412ceaccde4f91824", + "name": "supervisor", + "sha256": "c51b55ff42d3b378faa10a388c900fff20132138cea91f85a2e7157a957e53bf", + "size": 590743, + "subdir": "linux-64", + "timestamp": 1614081577913, + "version": "4.2.1" + }, + "supervisor-4.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "bcc040bf9b0db56f5343d92dc4198dfa", + "name": "supervisor", + "sha256": "1c4e1850a330dbf7d5bd95a35577801e46acff41484e16b48e526c505053517c", + "size": 582152, + "subdir": "linux-64", + "timestamp": 1600554336770, + "version": "4.2.1" + }, + "supervisor-4.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "1b08cd847ff6d778064467e76bafca28", + "name": "supervisor", + "sha256": "04da19c1b030d2f62e03bdd51a46df4d427582eef30e28bfb5303bf44478bbc5", + "size": 590187, + "subdir": "linux-64", + "timestamp": 1614081586354, + "version": "4.2.1" + }, + "supervisor-4.2.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "f31f53ae7bcf6fbaa14a47ad84ae2a37", + "name": "supervisor", + "sha256": "4bc49d47e29b8ebdb7199c02b2177e1e7eb1d814fe7d9c5f12b67c1795ff81d8", + "size": 590120, + "subdir": "linux-64", + "timestamp": 1600554344378, + "version": "4.2.1" + }, + "supervisor-4.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "68cc17c07c9bb38591304b291cb4d662", + "name": "supervisor", + "sha256": "5d2a0e2e58ab05ba6ce95ea5bea530590f5aeb320ab930331abb5fd22528c87b", + "size": 592022, + "subdir": "linux-64", + "timestamp": 1614081138789, + "version": "4.2.1" + }, + "supervisor-4.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "BSD-derived", + "license_family": "BSD", + "md5": "d5ac00c02faf286009a94f67d0ab140d", + "name": "supervisor", + "sha256": "08ed8fcb71607bcf012f0ad6e080fdac130a1b6ec690404cfb360a0e84369d03", + "size": 594619, + "subdir": "linux-64", + "timestamp": 1614081590729, + "version": "4.2.1" + }, + "supervisor-4.2.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "gettext >=0.21.0,<1.0a0", + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "BSD-derived AND PSF AND Other", + "license_family": "BSD", + "md5": "1450039546f92c472bcac00221077d67", + "name": "supervisor", + "sha256": "12622393d69f7964b95192bcf6656265a6bf2b94a7ffea3dc79173b4453e4bd9", + "size": 599575, + "subdir": "linux-64", + "timestamp": 1640794952224, + "version": "4.2.2" + }, + "supervisor-4.2.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "gettext >=0.21.0,<1.0a0", + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "BSD-derived AND PSF AND Other", + "license_family": "BSD", + "md5": "e45ff62aebc044cafb641e30f1e1dcf7", + "name": "supervisor", + "sha256": "3be10ee5e3511085b007f3b7023d30450b7160a024b76ef716c847dd55150c51", + "size": 760753, + "subdir": "linux-64", + "timestamp": 1676862823899, + "version": "4.2.2" + }, + "supervisor-4.2.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "gettext >=0.21.0,<1.0a0", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-derived AND PSF AND Other", + "license_family": "BSD", + "md5": "7ac60a730e126dc3926b2b0353268141", + "name": "supervisor", + "sha256": "0fbb54d8eafb78c263b596689fb07f9a67704bbe733606ee729d1bada591b3a4", + "size": 586148, + "subdir": "linux-64", + "timestamp": 1624542934833, + "version": "4.2.2" + }, + "supervisor-4.2.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "gettext >=0.21.0,<1.0a0", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-derived AND PSF AND Other", + "license_family": "BSD", + "md5": "808caf8e39da0d92a3ce711a8617a962", + "name": "supervisor", + "sha256": "183211932d8545930e53291557c954cf76926fc1b65c164e16c59ff17215383b", + "size": 589037, + "subdir": "linux-64", + "timestamp": 1624542756479, + "version": "4.2.2" + }, + "supervisor-4.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "gettext >=0.21.0,<1.0a0", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-derived AND PSF AND Other", + "license_family": "BSD", + "md5": "6858e8f43242449d28639190597df317", + "name": "supervisor", + "sha256": "119f7452a46fcb613f75590503444eac8bedaacd300319b5f236cda009b09f76", + "size": 591549, + "subdir": "linux-64", + "timestamp": 1624542922735, + "version": "4.2.2" + }, + "supervisor-4.2.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "gettext >=0.21.0,<1.0a0", + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "BSD-derived AND PSF AND Other", + "license_family": "BSD", + "md5": "5ea117170f888392ec234e846941c7d0", + "name": "supervisor", + "sha256": "221c97fb81d6f6763251d1c17a8094204d3ff3d81a3066f621aa381aafe5d848", + "size": 593796, + "subdir": "linux-64", + "timestamp": 1624542941194, + "version": "4.2.2" + }, + "svn-1.10.0-ha72275e_0.conda": { + "build": "ha72275e_0", + "build_number": 0, + "depends": [ + "apr >=1.6.3,<2.0a0", + "cyrus-sasl >=2.1.26,<3.0a0", + "expat >=2.2.5,<3.0a0", + "libgcc-ng >=7.2.0", + "libutf8proc >=2.1.1,<2.2.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "serf >=1.3.9,<1.4.0a0", + "sqlite >=3.23.1,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache Software License V.2", + "license_family": "Apache", + "md5": "5d37da56dca1813267d857d2f7716c38", + "name": "svn", + "sha256": "19d51f0ed80a35d75fd79aa9e3db66730d96f01c6f42a8eb75e98ca55c2672ab", + "size": 2987651, + "subdir": "linux-64", + "timestamp": 1527951016154, + "version": "1.10.0" + }, + "svn-1.10.2-h52f66ed_0.conda": { + "build": "h52f66ed_0", + "build_number": 0, + "depends": [ + "apr >=1.6.3,<2.0a0", + "cyrus-sasl >=2.1.26,<3.0a0", + "expat >=2.2.5,<3.0a0", + "libgcc-ng >=7.2.0", + "libutf8proc >=2.1.1,<2.2.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "serf >=1.3.9,<1.4.0a0", + "sqlite >=3.24.0,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache Software License V.2", + "license_family": "Apache", + "md5": "922a34e11c6b76620272b0ad72f2a4c6", + "name": "svn", + "sha256": "891ffdc0a1d1cd775efb6af371a0be5213ee470d996b831557e022988171747a", + "size": 2985990, + "subdir": "linux-64", + "timestamp": 1533705671201, + "version": "1.10.2" + }, + "svn-1.9.7-h30a3245_0.conda": { + "build": "h30a3245_0", + "build_number": 0, + "depends": [ + "apr >=1.6.3,<2.0a0", + "libgcc-ng >=7.2.0", + "serf >=1.3.9,<1.4.0a0", + "sqlite >=3.20.1,<4.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache Software License V.2", + "license_family": "Apache", + "md5": "c01586f393d523380e81f3655e2682c6", + "name": "svn", + "sha256": "70c3be1b026ee0983572732ff1f2493a8ee46aab862a4266ea4c0a87b00113cd", + "size": 2217204, + "subdir": "linux-64", + "timestamp": 1513193396587, + "version": "1.9.7" + }, + "swagger-ui-bundle-0.0.9-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a3a8feef70530e2c0770f4d97c296ebc", + "name": "swagger-ui-bundle", + "sha256": "ec14404383231702912aa04734f4e60c548b810d3fc2bbb2a3cf28429e8727e1", + "size": 4158440, + "subdir": "linux-64", + "timestamp": 1667595868886, + "version": "0.0.9" + }, + "swagger-ui-bundle-0.0.9-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "7de220d596ab5322b954715b3e8e4290", + "name": "swagger-ui-bundle", + "sha256": "cbe63a6edcbb9f0732c2e197dece09a051c429b6abab699b1a341a23e6e5f75e", + "size": 2635291, + "subdir": "linux-64", + "timestamp": 1676838823706, + "version": "0.0.9" + }, + "swagger-ui-bundle-0.0.9-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ab8fbe355f19b08d7328f16de61c8b2b", + "name": "swagger-ui-bundle", + "sha256": "bce4495e31c712a03f87a52f677fe1c71a37c89c2877c2268de1964139cff76d", + "size": 4158420, + "subdir": "linux-64", + "timestamp": 1667595794651, + "version": "0.0.9" + }, + "swagger-ui-bundle-0.0.9-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a3bc88643f978d4f3f52bfccc15985c1", + "name": "swagger-ui-bundle", + "sha256": "d90b407116e553852c34278eba367b9b7a17e702f358c86fe999532d738937b4", + "size": 4158216, + "subdir": "linux-64", + "timestamp": 1667595755340, + "version": "0.0.9" + }, + "swagger-ui-bundle-0.0.9-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "jinja2 >=2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9cef00e02cff3728471c78969b1896e5", + "name": "swagger-ui-bundle", + "sha256": "cfa61a5c71bdf7dfb8f1f9315dd38c295b46d6ddc66025a9bae52532518b1056", + "size": 4170417, + "subdir": "linux-64", + "timestamp": 1667595831783, + "version": "0.0.9" + }, + "swig-3.0.12-h38cdd7d_3.conda": { + "build": "h38cdd7d_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "pcre" + ], + "license": "GPL 3", + "license_family": "GPL", + "md5": "3e08b2f812a97ed72d01c4581eccdb4a", + "name": "swig", + "sha256": "26f19c5702fd656be8f29a3c8a61c37adf93bc5b0ba27840a2fe86d47c986747", + "size": 1207927, + "subdir": "linux-64", + "timestamp": 1513182163621, + "version": "3.0.12" + }, + "swig-4.0.2-h2531618_3.conda": { + "build": "h2531618_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "pcre >=8.44,<9.0a0" + ], + "license": "GPL 3", + "license_family": "GPL", + "md5": "d0e8ac1ba562910efde5ecc2436e9e61", + "name": "swig", + "sha256": "e290fe7e054b3e25bb1ec6df6b0106f0a2018ba9dee6ec22240cebcaabf88a56", + "size": 1160971, + "subdir": "linux-64", + "timestamp": 1612469500179, + "version": "4.0.2" + }, + "swig-4.0.2-h295c915_4.conda": { + "build": "h295c915_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "pcre >=8.45,<9.0a0" + ], + "license": "GPL 3", + "license_family": "GPL", + "md5": "d0e9cd66c5e877126cbdd6992119f593", + "name": "swig", + "sha256": "9ee3f6869aac3b6332e6173183427df3feb56024d4f4b5fbeb9b9da3cba09ee1", + "size": 1162787, + "subdir": "linux-64", + "timestamp": 1634714506100, + "version": "4.0.2" + }, + "sympy-1.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=2.7,<2.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "ef7836be1a8e64f0b22c974beb1559d1", + "name": "sympy", + "sha256": "417ac28bd549157e656ef54f8c85934c6cd0c585cb0eeb865cd0253c7582f1bd", + "size": 5852645, + "subdir": "linux-64", + "timestamp": 1531060144343, + "version": "1.1.1" + }, + "sympy-1.1.1-py27hc28188a_0.conda": { + "build": "py27hc28188a_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=2.7,<2.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "ae4305f32ef96825edc248a9ca472fe8", + "name": "sympy", + "sha256": "4ba8e8c107a9c478144f41a3e4e31180b2fddbec210892e2607edb64dff102be", + "size": 5789473, + "subdir": "linux-64", + "timestamp": 1505851806040, + "version": "1.1.1" + }, + "sympy-1.1.1-py35h919b29a_0.conda": { + "build": "py35h919b29a_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.5,<3.6.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "b2c2d64a5854fd7b846d3d766c60235c", + "name": "sympy", + "sha256": "366ec7d48f7068b7c5d2e46a56154e38197533d1f8ed49d92a46f2a368c15370", + "size": 5922198, + "subdir": "linux-64", + "timestamp": 1505851892777, + "version": "1.1.1" + }, + "sympy-1.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "b18f988e8877a11544a3f568fbe48c45", + "name": "sympy", + "sha256": "58205b85f26df08e0be118db2b11967e06830a654241402bcb12462b61950107", + "size": 5816962, + "subdir": "linux-64", + "timestamp": 1531059942045, + "version": "1.1.1" + }, + "sympy-1.1.1-py36hc6d1c1c_0.conda": { + "build": "py36hc6d1c1c_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "f8937f534766090c24a959e7cb6f1bc2", + "name": "sympy", + "sha256": "a7f5a8f9cdbe0fcc6543a69d4ef4d8fc5242a705908718dfaaa6cb791005cabb", + "size": 5866624, + "subdir": "linux-64", + "timestamp": 1505851980578, + "version": "1.1.1" + }, + "sympy-1.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "d55599c0b3993bff228a22657feba406", + "name": "sympy", + "sha256": "1d9938bd89af5b7b3c3d02421d66db687130941507139ddf95f22fb38939c423", + "size": 5794459, + "subdir": "linux-64", + "timestamp": 1531060053633, + "version": "1.1.1" + }, + "sympy-1.10.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause AND MIT", + "license_family": "BSD", + "md5": "0e20343a6797ee06b9c04e9c41569c6e", + "name": "sympy", + "sha256": "5f62b223446445e4be72d17067da9dc637b2ff55665ae04b79abd21c92e8bcaa", + "size": 9931267, + "subdir": "linux-64", + "timestamp": 1647835869549, + "version": "1.10.1" + }, + "sympy-1.10.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause AND MIT", + "license_family": "BSD", + "md5": "29671957191fc96a9171c137fdab699d", + "name": "sympy", + "sha256": "97c664a1772203877cae5dbef410cdca87dea408e2b6795dc97a35518be1b7fc", + "size": 16985078, + "subdir": "linux-64", + "timestamp": 1676845911461, + "version": "1.10.1" + }, + "sympy-1.10.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause AND MIT", + "license_family": "BSD", + "md5": "b715923bfa0a1898dbff4cfd91117c60", + "name": "sympy", + "sha256": "5d7fd07dc7caf34ef5e4b8a5e202ac9ba4bca96e358a369c2608771d2bfcd6ae", + "size": 9784089, + "subdir": "linux-64", + "timestamp": 1647835589018, + "version": "1.10.1" + }, + "sympy-1.10.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause AND MIT", + "license_family": "BSD", + "md5": "13996007536999017425988336090ad5", + "name": "sympy", + "sha256": "6ad47df5bf298fe3298855ffd4da3f4b090839a493e74eab1a477e906243c1f1", + "size": 9944752, + "subdir": "linux-64", + "timestamp": 1647853718110, + "version": "1.10.1" + }, + "sympy-1.10.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause AND MIT", + "license_family": "BSD", + "md5": "d914620f2c9c11490c842dfc50cc53ff", + "name": "sympy", + "sha256": "92475c4e3798dba21f5b42626dd9cc04fafc945c9b8921d32a669be9e994e2e9", + "size": 9830887, + "subdir": "linux-64", + "timestamp": 1647853714323, + "version": "1.10.1" + }, + "sympy-1.11.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause AND MIT", + "license_family": "BSD", + "md5": "6d6db0d1de9a0b1d72c1fc11fb52190b", + "name": "sympy", + "sha256": "1ec55e021bf831b87588eecf601cf9a17b86ed6097ac800a97be2c6bed764ae4", + "size": 12345184, + "subdir": "linux-64", + "timestamp": 1668202452480, + "version": "1.11.1" + }, + "sympy-1.11.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause AND MIT", + "license_family": "BSD", + "md5": "925e80d5142872c5fa77f09f16d6027d", + "name": "sympy", + "sha256": "017085caf8a7d406fdeadd3703fca9d61a264065e70ddeff98457edacc006a6a", + "size": 17177600, + "subdir": "linux-64", + "timestamp": 1679339356417, + "version": "1.11.1" + }, + "sympy-1.11.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause AND MIT", + "license_family": "BSD", + "md5": "f9f3097dd8b4fa70d5cd8963897d62dc", + "name": "sympy", + "sha256": "81fb18b81d1b120dc49f99268e1b136f6e283462553b8b9fd41798f638e4072e", + "size": 12288004, + "subdir": "linux-64", + "timestamp": 1668206322385, + "version": "1.11.1" + }, + "sympy-1.11.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause AND MIT", + "license_family": "BSD", + "md5": "3e33627d3cfc97035ac89ee5d69b9880", + "name": "sympy", + "sha256": "1e76f80567e53f50497c162a5978e8a181d15ae1b4092a5795b017984cca54f3", + "size": 12250569, + "subdir": "linux-64", + "timestamp": 1668204388050, + "version": "1.11.1" + }, + "sympy-1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=2.7,<2.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "04703b31705fd8ca5ed7df2c8e56c3f5", + "name": "sympy", + "sha256": "1817351d5eb3a3d0a280fdcb2a3722709d537b9a052fe79c07e34eb8ea9a3008", + "size": 7608733, + "subdir": "linux-64", + "timestamp": 1532527819078, + "version": "1.2" + }, + "sympy-1.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.5,<3.6.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "189c4d885ef42212cb79ef5a102f5f58", + "name": "sympy", + "sha256": "901315a3f716a4f6b7666c6f805ee7b4261327e990532b1acf7ac4e30bb99050", + "size": 8103706, + "subdir": "linux-64", + "timestamp": 1532528003666, + "version": "1.2" + }, + "sympy-1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "72cc4197de903ff8adf05e3ad7b1676d", + "name": "sympy", + "sha256": "e015c41ec941e8bf87c8dc1d7780bd403160fc0ae830762ae45a04d1331e50d9", + "size": 7403895, + "subdir": "linux-64", + "timestamp": 1532527886314, + "version": "1.2" + }, + "sympy-1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "bca15beed8a7c817a29341222f536f45", + "name": "sympy", + "sha256": "99fb822ef63256e3c88009351f686826adace8ba5ad91f8518c157c3442f38b7", + "size": 7380737, + "subdir": "linux-64", + "timestamp": 1532528024334, + "version": "1.2" + }, + "sympy-1.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=2.7,<2.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "2ad5f1c13a049c441ab9748a8ea2a98f", + "name": "sympy", + "sha256": "6e83f0309b197fab1ef1af5321464cb60d5ae00a7759310413b7cf6cee740b72", + "size": 8106882, + "subdir": "linux-64", + "timestamp": 1538155955148, + "version": "1.3" + }, + "sympy-1.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "f1acfb06218ad9d0b526e5e5f7a66e53", + "name": "sympy", + "sha256": "9caefdad8cfce19c1f6c4b1014e065ca2275ac3d54f111186e1bd937e18b6bf1", + "size": 8018195, + "subdir": "linux-64", + "timestamp": 1538156011318, + "version": "1.3" + }, + "sympy-1.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0" + ], + "license": "3-clause BSD", + "license_family": "BSD", + "md5": "d3cf605059d861a785a1381bcf816724", + "name": "sympy", + "sha256": "761e099ab3c05e22a3ebd5437ef5da07233fa7e3ad8f20c29c77563ceca10d30", + "size": 7990689, + "subdir": "linux-64", + "timestamp": 1538156004630, + "version": "1.3" + }, + "sympy-1.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7e7e4f823bffcdd3c1b98963c2442c43", + "name": "sympy", + "sha256": "7b2c0ccd4c06a608b224ffdc03b2afd7808303fb2dde08d8d199d6680f15dd92", + "size": 8419494, + "subdir": "linux-64", + "timestamp": 1555436749487, + "version": "1.4" + }, + "sympy-1.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a9740d1e0362c419a54d6834c1af6696", + "name": "sympy", + "sha256": "346f71c3f264c758830cb2b228b006ec38933f6ffb40df0d7c21093b1ff41001", + "size": 8267414, + "subdir": "linux-64", + "timestamp": 1555436756746, + "version": "1.4" + }, + "sympy-1.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7763afa4d66249d51a0b78b01855dd72", + "name": "sympy", + "sha256": "c6dacb79314d3b89bda4d295e91469f887d559d5edd026f08ed7cb006c82cbc4", + "size": 8308767, + "subdir": "linux-64", + "timestamp": 1555436621523, + "version": "1.4" + }, + "sympy-1.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "163a9a87211c7a448c9c528689a6a16b", + "name": "sympy", + "sha256": "94b125e19de4d4345b0396dd3714b3d9522458313393616184e106e519b79e50", + "size": 8419755, + "subdir": "linux-64", + "timestamp": 1573554713852, + "version": "1.4" + }, + "sympy-1.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "95bac367777620231217678c53f82318", + "name": "sympy", + "sha256": "71cab0579d5f780b0fb31b52b79fb825c233525dfb15c4e8e7e11aa7f076eb17", + "size": 8786308, + "subdir": "linux-64", + "timestamp": 1576514427454, + "version": "1.5" + }, + "sympy-1.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "23bffe3c46206ed87601199cd312c0cc", + "name": "sympy", + "sha256": "c9cb1f3fe8489b76cd0cef31b17c74822e38f662e894e80037365cd63fb62341", + "size": 8703072, + "subdir": "linux-64", + "timestamp": 1576514425704, + "version": "1.5" + }, + "sympy-1.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bcba92ee17db2946f371476aece3bb80", + "name": "sympy", + "sha256": "1046f865b50286942aa31d8b8dd7ddab42b5a37ddd1f18b28ab07a3b138c6f65", + "size": 8742564, + "subdir": "linux-64", + "timestamp": 1576514428809, + "version": "1.5" + }, + "sympy-1.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5a0f845855d0da5d803c9a2f3c3830cd", + "name": "sympy", + "sha256": "96b7c6c594ed6cb839370b97f7f242aa2efe97ff9943d12a6ae88aaa5d614f4c", + "size": 8736740, + "subdir": "linux-64", + "timestamp": 1576514432676, + "version": "1.5" + }, + "sympy-1.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6f155eaffba47844bf698f223b57e3ef", + "name": "sympy", + "sha256": "e7029ef055c94e76b1a7989ba414b5734a879120b5bfc894b5008e552ba3efb3", + "size": 8795129, + "subdir": "linux-64", + "timestamp": 1578428409491, + "version": "1.5.1" + }, + "sympy-1.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0e36de0982ede29e690361f12d2a2d4e", + "name": "sympy", + "sha256": "b270b9677a16cfc5a0e04d32a7abbf47ef30fc5f1cc8c0c076d8953addc59df8", + "size": 8695766, + "subdir": "linux-64", + "timestamp": 1578428423508, + "version": "1.5.1" + }, + "sympy-1.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "be2c98cdecce3e4713eda5dbcf349f8a", + "name": "sympy", + "sha256": "7ec75d9df8a1589d29a6f14f5548f3eb323dc6bee7c3ae1f5eed9cf72407c370", + "size": 8668195, + "subdir": "linux-64", + "timestamp": 1578428405273, + "version": "1.5.1" + }, + "sympy-1.5.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "88841786e37ce456ffce8f9874b60a0f", + "name": "sympy", + "sha256": "977dacba4897e4d2943b7e0e5555ad3e3c00f03ffc233abdf1a090e4f93b7193", + "size": 8731646, + "subdir": "linux-64", + "timestamp": 1578428427254, + "version": "1.5.1" + }, + "sympy-1.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "mpmath >=0.19", + "python >=3.6,<3.7.0a0", + "fastcache", + "gmpy2 >=2.0.8" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5a25b6c924c696b847810a4da7cceb80", + "name": "sympy", + "sha256": "8f664c5553c1adaa05e0cd114cdbc0c26e5d997b3fcc9336e03935f3f15ac293", + "size": 8950275, + "subdir": "linux-64", + "timestamp": 1592279613271, + "version": "1.6" + }, + "sympy-1.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "mpmath >=0.19", + "python >=3.7,<3.8.0a0", + "fastcache", + "gmpy2 >=2.0.8" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3b4f8e808819c4930a4bd831d11733da", + "name": "sympy", + "sha256": "567efa6f670d7da63ff28c54cbca28972dd07c73ce8230e847371aea8014275b", + "size": 8992179, + "subdir": "linux-64", + "timestamp": 1592279571595, + "version": "1.6" + }, + "sympy-1.6-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "mpmath >=0.19", + "python >=3.8,<3.9.0a0", + "fastcache", + "gmpy2 >=2.0.8" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "44e7f1e8683625b841dbdb35c4a8760e", + "name": "sympy", + "sha256": "89d29cb6cd895f1c46c405c02108350f7d5a176c80a3f80dd1a7b812050d8f07", + "size": 9053167, + "subdir": "linux-64", + "timestamp": 1592279573280, + "version": "1.6" + }, + "sympy-1.6.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "mpmath >=0.19", + "python >=3.6,<3.7.0a0", + "fastcache", + "gmpy2 >=2.0.8" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "261099285dbbce48dff62bd0e7db48f5", + "name": "sympy", + "sha256": "858d39adc1b08613fdb3fc955e0d358a594ed419c935d904c6acaece969e27b2", + "size": 8961512, + "subdir": "linux-64", + "timestamp": 1594236616743, + "version": "1.6.1" + }, + "sympy-1.6.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "mpmath >=0.19", + "python >=3.7,<3.8.0a0", + "fastcache", + "gmpy2 >=2.0.8" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "df6a88e43b203dccd3d244a9eae0a887", + "name": "sympy", + "sha256": "93c4e7776df44564b1cda710badf236d09681b480195f4c1341336516f8afbee", + "size": 8999204, + "subdir": "linux-64", + "timestamp": 1594236601614, + "version": "1.6.1" + }, + "sympy-1.6.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "mpmath >=0.19", + "python >=3.8,<3.9.0a0", + "fastcache", + "gmpy2 >=2.0.8" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a1758bfad32717b6a7782dce60bac463", + "name": "sympy", + "sha256": "648f3836ba3e16222db18eae6b663900c25271fb85701e777bffa04a2f03c2bf", + "size": 8980822, + "subdir": "linux-64", + "timestamp": 1594236604040, + "version": "1.6.1" + }, + "sympy-1.6.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "39b9e3c3aec577f94ec61cf6baf631e0", + "name": "sympy", + "sha256": "06303285b967a07f300bf69e76035a2d3b61f28937de4105f688301bfaf47a38", + "size": 8950502, + "subdir": "linux-64", + "timestamp": 1598376402443, + "version": "1.6.2" + }, + "sympy-1.6.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f3601767785a359afa8a36ac84129ce6", + "name": "sympy", + "sha256": "191fcb2e0124b09fa271867ae16691ba964a6288654e68cf6a1c76437845b6a8", + "size": 9026478, + "subdir": "linux-64", + "timestamp": 1605119629383, + "version": "1.6.2" + }, + "sympy-1.6.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "mpmath >=0.19", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cd15b240e7e4c414179359ec88cdf606", + "name": "sympy", + "sha256": "0ecaa2f8100daed97fccc7fb3391490313e9a90b174d8a7b6e53edcdad1b343c", + "size": 8908584, + "subdir": "linux-64", + "timestamp": 1597083201738, + "version": "1.6.2" + }, + "sympy-1.6.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f09ae2740fe571977f202797ffb99bb1", + "name": "sympy", + "sha256": "d3d3462a9e40d2111cdaf9bc79b4fc376ef91b5a31fba0c3a28751ecc4c46617", + "size": 8994793, + "subdir": "linux-64", + "timestamp": 1605119589194, + "version": "1.6.2" + }, + "sympy-1.6.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "15fb85ca0e95c168b6f22e52340e601f", + "name": "sympy", + "sha256": "8d9ed5b581743d451d0b0d522cbad9b2589ee075ad41f304cc47bbb570ae867e", + "size": 9062255, + "subdir": "linux-64", + "timestamp": 1598376392699, + "version": "1.6.2" + }, + "sympy-1.6.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2c9543a419c5edcb44f10c70b01481d7", + "name": "sympy", + "sha256": "3e54cf7e0279523f0f2e1a7225d0102b109942c4f5b2d2fe4df0f8123d4edfd2", + "size": 9061900, + "subdir": "linux-64", + "timestamp": 1605119603831, + "version": "1.6.2" + }, + "sympy-1.6.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "fastcache", + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7af425aa516fc3487789c274b1f80b65", + "name": "sympy", + "sha256": "70fe8d2940cd572106ca166a21cce3d674ccf92c6ccfefd3a0e5176a4e08128e", + "size": 9034254, + "subdir": "linux-64", + "timestamp": 1607722764172, + "version": "1.6.2" + }, + "sympy-1.7.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b6de7a00a6ed0d8c3b16e01110ba9060", + "name": "sympy", + "sha256": "5a719e1730a380ff83ce65f2f69c2a0e91ac95997968fbe62bf4f88370656009", + "size": 9291207, + "subdir": "linux-64", + "timestamp": 1608137749688, + "version": "1.7.1" + }, + "sympy-1.7.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "59430d402d0a742efd410de81607b009", + "name": "sympy", + "sha256": "34d9c2623c5d16e4e680862472872a770eb445b1d59db3420898169ba5fdfee1", + "size": 9258003, + "subdir": "linux-64", + "timestamp": 1608137712477, + "version": "1.7.1" + }, + "sympy-1.7.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "498ee28a4971b144ca07e076d700f5e1", + "name": "sympy", + "sha256": "f8ef7316f6c891b1866f3c1451916949e813da634128fea008ad4bfbe8ec6005", + "size": 9249396, + "subdir": "linux-64", + "timestamp": 1608137748509, + "version": "1.7.1" + }, + "sympy-1.7.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "068b1a7c91b47578491a2dbaaf0a4ed9", + "name": "sympy", + "sha256": "d7f13361d07e8dd65b84e624e0b89a6892b3d02d71b8b221c0b366ece5eb97d1", + "size": 9217089, + "subdir": "linux-64", + "timestamp": 1608137766028, + "version": "1.7.1" + }, + "sympy-1.8-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9916a63c482c32727119f26cfc4f3a19", + "name": "sympy", + "sha256": "3191967b140cb48f892e33400b9efedd3f77a045af2932df12dc43995b09d8ac", + "size": 9487916, + "subdir": "linux-64", + "timestamp": 1618255389252, + "version": "1.8" + }, + "sympy-1.8-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0dc9eb29419e9874d7ea2b224beb5654", + "name": "sympy", + "sha256": "72bc91a4e449cbe212d88003ae7a90ef0ca610d06418123950851e8cd0306b91", + "size": 9446418, + "subdir": "linux-64", + "timestamp": 1618255380495, + "version": "1.8" + }, + "sympy-1.8-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "49465695861e5f18a6d03cc52bcc23f3", + "name": "sympy", + "sha256": "d7d90903638e8c713bf46644d3e213940e0b088b92f78e7d29584f5d2a2a55e5", + "size": 9519257, + "subdir": "linux-64", + "timestamp": 1618252350546, + "version": "1.8" + }, + "sympy-1.8-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "10fd4e57533e553b55d00e9cd61987eb", + "name": "sympy", + "sha256": "5e2d13840d10ad9b7340b5604e0983035a716c48fc5ba5ab9b26d13360dcf99a", + "size": 9487396, + "subdir": "linux-64", + "timestamp": 1618255386428, + "version": "1.8" + }, + "sympy-1.9-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "713dc03fd7493b406c74ddad4bbc36f7", + "name": "sympy", + "sha256": "8417e7c4890d37b39497b13f5e443ac104cd9880f46a76809c5e8b369e944638", + "size": 9816851, + "subdir": "linux-64", + "timestamp": 1640810972256, + "version": "1.9" + }, + "sympy-1.9-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f06938a2b51f8f665821c536e4dde6b3", + "name": "sympy", + "sha256": "21e6031e3a9a51ec5b2e14236ad46116926658ca172e831dab203f349c8d3df6", + "size": 9601133, + "subdir": "linux-64", + "timestamp": 1635225510424, + "version": "1.9" + }, + "sympy-1.9-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e3fc37c8402a7980b3222a3f4c9876f", + "name": "sympy", + "sha256": "db831b985f744fac805b76120f76303071388264d6dd2bd3b97e1cff69ec921b", + "size": 9665137, + "subdir": "linux-64", + "timestamp": 1635237122353, + "version": "1.9" + }, + "sympy-1.9-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "antlr-python-runtime >=4.7,<4.8" + ], + "depends": [ + "gmpy2 >=2.0.8", + "mpmath >=0.19", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "80897bf5c666f2b7e4c9a3fd1c8c8d85", + "name": "sympy", + "sha256": "c5db46301196a13f062b2777e11f393af0a67174bc20255c3379e88ff582c0c0", + "size": 9631533, + "subdir": "linux-64", + "timestamp": 1635237134113, + "version": "1.9" + }, + "tabpy-client-0.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d0144338faf946ebfceb89456056915", + "name": "tabpy-client", + "sha256": "bbcc647db536edeb9afff5c1428c502f1afb78b3913e5bfdf5802d3ab482076d", + "size": 26635, + "subdir": "linux-64", + "timestamp": 1537832451124, + "version": "0.2" + }, + "tabpy-client-0.2-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fda9949855718398359dd63d77f4464e", + "name": "tabpy-client", + "sha256": "97442451ac9df1a764f446612f0f68c7746e9ce2436c592f771068b76fe02186", + "size": 28144, + "subdir": "linux-64", + "timestamp": 1640811001676, + "version": "0.2" + }, + "tabpy-client-0.2-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "caffc6e4bf9039842d96ac0cab55ecc4", + "name": "tabpy-client", + "sha256": "938eb672092e38f27e5198b5c53225030b2ec75bf0c4fd6b1a9dc3708aa0120a", + "size": 27540, + "subdir": "linux-64", + "timestamp": 1537832464402, + "version": "0.2" + }, + "tabpy-client-0.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "789d996532b8857b97a68389a52425cf", + "name": "tabpy-client", + "sha256": "fb9b0ed67a9a50adc218a4062285ef32b6244cfce571813fb4fd4eb5dab7d3d7", + "size": 27347, + "subdir": "linux-64", + "timestamp": 1537832462617, + "version": "0.2" + }, + "tabpy-client-0.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "818be05d14dff93d203ad48927f4f295", + "name": "tabpy-client", + "sha256": "ff9983d49830abbf16e9d58438c61e2c05cd2600cdc92b31bfc8c50eaf875cdf", + "size": 268830, + "subdir": "linux-64", + "timestamp": 1613651359697, + "version": "0.2" + }, + "tabpy-client-0.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a2fe581f72f1d8d6babc1ab23a5ca564", + "name": "tabpy-client", + "sha256": "2bf0b70cca2d8bd017ac41c0dcabbd9eecc725b0be556d41276f46130df24c02", + "size": 27377, + "subdir": "linux-64", + "timestamp": 1537832426119, + "version": "0.2" + }, + "tabpy-client-0.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4a5d4968087df499ce3368263e00024e", + "name": "tabpy-client", + "sha256": "0562639d1ce27c4559733676d03174db7f250d4637b8999e5be63a2716de40d5", + "size": 268461, + "subdir": "linux-64", + "timestamp": 1613652070497, + "version": "0.2" + }, + "tabpy-client-0.2-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0c266e16ecfc6c0aa0f89645a04cb6b", + "name": "tabpy-client", + "sha256": "133973ae1fe4932e18117e6abdee67e19ac42c11f19e1ca29324c14d62d43f1a", + "size": 27922, + "subdir": "linux-64", + "timestamp": 1574237980346, + "version": "0.2" + }, + "tabpy-client-0.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "164defd656fd3dc69322f407d84004f4", + "name": "tabpy-client", + "sha256": "01355699030d21c370b2116af251ee31b4adc42e8b7b829130d96707fd17ad65", + "size": 268872, + "subdir": "linux-64", + "timestamp": 1613652073607, + "version": "0.2" + }, + "tabpy-client-0.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d72b55f8b8a053629e3a592c0d062d03", + "name": "tabpy-client", + "sha256": "09770fd24d5ba420e8b060143f181f8181da5d155630a87097a75395463c5eb3", + "size": 268956, + "subdir": "linux-64", + "timestamp": 1613651724398, + "version": "0.2" + }, + "tabpy-server-0.2-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "futures", + "genson", + "jsonschema", + "numpy", + "python >=2.7,<2.8.0a0", + "python-dateutil", + "requests", + "simplejson", + "tabpy-client", + "tornado", + "tornado-json" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e162e2dbcb8196b627ee5b67ab4568b6", + "name": "tabpy-server", + "sha256": "5083237dba318e6614a7ee431230e954cd10d525b359304bcf0d693838ccb8e0", + "size": 63168, + "subdir": "linux-64", + "timestamp": 1537888632581, + "version": "0.2" + }, + "tabpy-server-0.2-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "numpy", + "python >=3.10,<3.11.0a0", + "python-dateutil", + "requests", + "simplejson", + "tabpy-client", + "tornado", + "tornado-json" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "46c5332dc026d1894283c0a9d6ab0227", + "name": "tabpy-server", + "sha256": "9b91f3fd448329e819e538881e76a473feeab1564ee0ded92e33bfcf47140295", + "size": 64575, + "subdir": "linux-64", + "timestamp": 1640813035392, + "version": "0.2" + }, + "tabpy-server-0.2-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "numpy", + "python >=3.5,<3.6.0a0", + "python-dateutil", + "requests", + "simplejson", + "tabpy-client", + "tornado", + "tornado-json" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d66441a4c7e6ebe7d6b8690d9489fae", + "name": "tabpy-server", + "sha256": "c39f2133eff63ef05c80c64a3bced9d69d8f69edd5c7fea2c97ad30982599da9", + "size": 63437, + "subdir": "linux-64", + "timestamp": 1537888653936, + "version": "0.2" + }, + "tabpy-server-0.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "numpy", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests", + "simplejson", + "tabpy-client", + "tornado", + "tornado-json" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "abe4904613f10c7e137b04154250a66d", + "name": "tabpy-server", + "sha256": "50603843fe21e41fd76e6ce6a01ad4ee7e55fecfca307a8bab6c34c6452b4d7e", + "size": 63030, + "subdir": "linux-64", + "timestamp": 1537888682096, + "version": "0.2" + }, + "tabpy-server-0.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "numpy", + "python >=3.6,<3.7.0a0", + "python-dateutil", + "requests", + "simplejson", + "tabpy-client", + "tornado", + "tornado-json" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22a90ea080f13f8c32aa8f8dd006cb20", + "name": "tabpy-server", + "sha256": "c0b8962931ae2ffb765f3e672f0259b0c4ea26dc50807ba28254ee0bd2f8aeb0", + "size": 305318, + "subdir": "linux-64", + "timestamp": 1614065506490, + "version": "0.2" + }, + "tabpy-server-0.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "numpy", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests", + "simplejson", + "tabpy-client", + "tornado", + "tornado-json" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea18d07272fc508c165f4ddcc840aa5b", + "name": "tabpy-server", + "sha256": "edf92c8c06c5b6f1eb6d7bb65e2ae2f1fcd0c9a8e624243f18dc010a97ce2e27", + "size": 62922, + "subdir": "linux-64", + "timestamp": 1537888599473, + "version": "0.2" + }, + "tabpy-server-0.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "numpy", + "python >=3.7,<3.8.0a0", + "python-dateutil", + "requests", + "simplejson", + "tabpy-client", + "tornado", + "tornado-json" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "54575d0652e5c05b439821079e82a2a5", + "name": "tabpy-server", + "sha256": "7506029de9dffbd6a115e314434f392f2aa045d29091f2e5b6f4887cf5cba0d6", + "size": 305168, + "subdir": "linux-64", + "timestamp": 1614066107414, + "version": "0.2" + }, + "tabpy-server-0.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "numpy", + "python >=3.8,<3.9.0a0", + "python-dateutil", + "requests", + "simplejson", + "tabpy-client", + "tornado", + "tornado-json" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "170a8e5d19f369775f5588ef5d73aba1", + "name": "tabpy-server", + "sha256": "9fb3615452eae70ba74e42bd4d668dbb13929f3e394c11a127f8d69fa4f7b01e", + "size": 305402, + "subdir": "linux-64", + "timestamp": 1614066111834, + "version": "0.2" + }, + "tabpy-server-0.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "cloudpickle", + "decorator", + "future", + "genson", + "jsonschema", + "numpy", + "python >=3.9,<3.10.0a0", + "python-dateutil", + "requests", + "simplejson", + "tabpy-client", + "tornado", + "tornado-json" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5bcee62e5f56cf72d93d38832561f3be", + "name": "tabpy-server", + "sha256": "d35a3be2876e4d1656bfbb204f7f7e22589ef5ce16e5a2251f95f1e59e80f199", + "size": 306636, + "subdir": "linux-64", + "timestamp": 1614065206782, + "version": "0.2" + }, + "tabula-py-2.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "distro", + "numpy", + "openjdk >=8", + "pandas >=0.25.3", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca8223e0f7ee100c706a31057399bafc", + "name": "tabula-py", + "sha256": "04392ebd9876ee6896a2ff5e4bf5b7be4bbc21644ad2aab1f7caaa8c433b623c", + "size": 11819835, + "subdir": "linux-64", + "timestamp": 1640794975832, + "version": "2.3.0" + }, + "tabula-py-2.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "distro", + "numpy", + "openjdk >=8", + "pandas >=0.25.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4a597ce638fd9308921ec7fd48b7d4d0", + "name": "tabula-py", + "sha256": "716ede910dd618568e66248037cdfbef0a0990aa3883d46040b6c5c9f9c09182", + "size": 11823095, + "subdir": "linux-64", + "timestamp": 1637055835338, + "version": "2.3.0" + }, + "tabula-py-2.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "distro", + "numpy", + "openjdk >=8", + "pandas >=0.25.3", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cdb97de03f0f1b896f49bbf286ea15e4", + "name": "tabula-py", + "sha256": "a0febe4dcd296617df4c7161e4ccfaf34e39fe07030dc0933498c551b42b06f2", + "size": 11823264, + "subdir": "linux-64", + "timestamp": 1637055562985, + "version": "2.3.0" + }, + "tabula-py-2.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "distro", + "numpy", + "openjdk >=8", + "pandas >=0.25.3", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d2e6a514b17f9ac0f6d82704c0ef762", + "name": "tabula-py", + "sha256": "6d6b5793189b93d9186d1b5c3e17d01e0056d716299982db8bf0d2b482f08cb1", + "size": 11823166, + "subdir": "linux-64", + "timestamp": 1637055829916, + "version": "2.3.0" + }, + "tabula-py-2.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "distro", + "numpy", + "openjdk >=8", + "pandas >=0.25.3", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b29534175b2f631ebab1cf73879741cc", + "name": "tabula-py", + "sha256": "f1c33ec78851a6e942c8817ad018a1bb69e8cfba8e2bbbfe8826e5998c73cd2b", + "size": 11910145, + "subdir": "linux-64", + "timestamp": 1676300715941, + "version": "2.6.0" + }, + "tabula-py-2.6.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "distro", + "numpy", + "openjdk >=8", + "pandas >=0.25.3", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0cabbe02da0b041be24d30e4db170c81", + "name": "tabula-py", + "sha256": "6d1e4ae3da32424ecf6659198270bd3f3ea01b424eb2e8aae011b92079b2d49f", + "size": 11850707, + "subdir": "linux-64", + "timestamp": 1676862843214, + "version": "2.6.0" + }, + "tabula-py-2.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "distro", + "numpy", + "openjdk >=8", + "pandas >=0.25.3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d1436ae13efb4c126e968489546a764", + "name": "tabula-py", + "sha256": "e5d239deb7eddeadbadf2cd6f80079ca18a8295a989c5429fc75f004757df4cc", + "size": 11907559, + "subdir": "linux-64", + "timestamp": 1676300659455, + "version": "2.6.0" + }, + "tabula-py-2.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "distro", + "numpy", + "openjdk >=8", + "pandas >=0.25.3", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f4155f5fea656e913140a1ea65578059", + "name": "tabula-py", + "sha256": "57b891c322b2d7f3b652a37a773af385386bf3c34db2ff2cca1678fe17c2661d", + "size": 11907646, + "subdir": "linux-64", + "timestamp": 1676300764980, + "version": "2.6.0" + }, + "tabula-py-2.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "distro", + "numpy", + "openjdk >=8", + "pandas >=0.25.3", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4782ad9f563eb3d6ce68c4d35d99b3ed", + "name": "tabula-py", + "sha256": "4ef392016da80529227839f219a0455219612b3d76692e766ece92e24e65fe31", + "size": 11909818, + "subdir": "linux-64", + "timestamp": 1676300815594, + "version": "2.6.0" + }, + "tabulate-0.8.10-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "001a0f6c8710d887fd61539d4326ee52", + "name": "tabulate", + "sha256": "11301e68cd46423cda17b6c1932499e61ea6d54135124700e69b8b15e834c958", + "size": 46253, + "subdir": "linux-64", + "timestamp": 1657784147376, + "version": "0.8.10" + }, + "tabulate-0.8.10-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cce197d1b546415131072f3041ee3617", + "name": "tabulate", + "sha256": "5ab89f38360ebcd01f6e749c9cd89cf9b9121bf7bbeaf7f4698179bb38b78b57", + "size": 57952, + "subdir": "linux-64", + "timestamp": 1676838842645, + "version": "0.8.10" + }, + "tabulate-0.8.10-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f0971549f3cd6ce9cad49374f7645cec", + "name": "tabulate", + "sha256": "cf395f4ce2c17f165501eda7e5e95236274c0d629e9f0e20a4bd1792bf9c9867", + "size": 45605, + "subdir": "linux-64", + "timestamp": 1657784201643, + "version": "0.8.10" + }, + "tabulate-0.8.10-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b7cbebf61d1f4371b395c517deb701a", + "name": "tabulate", + "sha256": "684d1a9cb46c4e970dea8aac7f80cb93a3943e367e1c6211231af36da17bcb27", + "size": 45907, + "subdir": "linux-64", + "timestamp": 1657784228264, + "version": "0.8.10" + }, + "tabulate-0.8.10-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "924ac83350d9dca019ca8e4da48e72a2", + "name": "tabulate", + "sha256": "6f94e4d428662c86c189543244148ca69fe30df5032d118987b9692b31d0f8e3", + "size": 45851, + "subdir": "linux-64", + "timestamp": 1657784174556, + "version": "0.8.10" + }, + "tabulate-0.8.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56053021b52dc44b882b4ee64c2bf40c", + "name": "tabulate", + "sha256": "c21278b3cf90d7669b0c2a78d0534176af5d0077a812ead3d50c4e3e370e7434", + "size": 37999, + "subdir": "linux-64", + "timestamp": 1519407100818, + "version": "0.8.2" + }, + "tabulate-0.8.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9f0fa7318c46d5176724ab1400cbc488", + "name": "tabulate", + "sha256": "9b35322595497f6a63dfc266d442f9948b12e8841764366e60b16eef2ef57e4f", + "size": 38102, + "subdir": "linux-64", + "timestamp": 1519408332707, + "version": "0.8.2" + }, + "tabulate-0.8.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c1cc8ce065d96f5948f8dfb251149dbe", + "name": "tabulate", + "sha256": "03f13e50393da6b091b5399584459613d5850fe8bf6127ae2947b21eb93ab53f", + "size": 38301, + "subdir": "linux-64", + "timestamp": 1519407047391, + "version": "0.8.2" + }, + "tabulate-0.8.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc364ce56d580e6670895c4807919915", + "name": "tabulate", + "sha256": "eae7cf00b906bf1de74abcd602a48921da251c31b81d49081085354564cead4f", + "size": 37583, + "subdir": "linux-64", + "timestamp": 1531060188132, + "version": "0.8.2" + }, + "tabulate-0.8.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31281e7beed6ec5c1783ed836a847385", + "name": "tabulate", + "sha256": "db49b05da2fa11749df2e02cb1e170f6159d006ec9eb5cad5f0307e3e4a4ea40", + "size": 39256, + "subdir": "linux-64", + "timestamp": 1552401390517, + "version": "0.8.3" + }, + "tabulate-0.8.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b8dcca16b2dc76b4c6c927c4babbed6", + "name": "tabulate", + "sha256": "d9a720766bd9b8a8ce184b0328069d42549e545cd01f686ca8d0c895e8047758", + "size": 40388, + "subdir": "linux-64", + "timestamp": 1552401901875, + "version": "0.8.3" + }, + "tabulate-0.8.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a40b344df2ff97c07474ab919902ca6d", + "name": "tabulate", + "sha256": "a3eebf20c9ca81c4df149a27a81c088c4baa2ae474684581f210e38588d763b5", + "size": 39594, + "subdir": "linux-64", + "timestamp": 1552403483671, + "version": "0.8.3" + }, + "tabulate-0.8.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d60f2bfd2d0c7a7318e3b510ea084a8c", + "name": "tabulate", + "sha256": "2a4f9fbde9748185a4262f8bbfb7f56f1dec84b58bbc28253f62cebc00410706", + "size": 38934, + "subdir": "linux-64", + "timestamp": 1573661828687, + "version": "0.8.3" + }, + "tabulate-0.8.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "defb9410ab3a8f6144c3988759785233", + "name": "tabulate", + "sha256": "af810d31c2243c055787958e258aa2d2b9ace20453fe42508dd6b69076b9567c", + "size": 41370, + "subdir": "linux-64", + "timestamp": 1597430392099, + "version": "0.8.7" + }, + "tabulate-0.8.7-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b91b934c54e1f6196f3b37c56d23fd26", + "name": "tabulate", + "sha256": "02ab3c2c513cb43fadc3b46bcb8af16d8a4f6488af6b304cda122aa32495e0b9", + "size": 41423, + "subdir": "linux-64", + "timestamp": 1613564221131, + "version": "0.8.7" + }, + "tabulate-0.8.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1048e2690996d50c45299b599594a39c", + "name": "tabulate", + "sha256": "1efbf02c52d663199d9db23088923f051901d9cefe69ba0567a472d0f33de156", + "size": 40594, + "subdir": "linux-64", + "timestamp": 1597430386791, + "version": "0.8.7" + }, + "tabulate-0.8.7-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1c9f83240ecdf279b55d3fe1ee1a2a2", + "name": "tabulate", + "sha256": "d1c57d38a0ce5ab9c06a54397fec72537dcc1bd114eb4202a7b9e090e1ab235c", + "size": 40658, + "subdir": "linux-64", + "timestamp": 1613564890570, + "version": "0.8.7" + }, + "tabulate-0.8.7-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3aeaa2189917ef443c2dd96924a39f50", + "name": "tabulate", + "sha256": "24a2248f5ace4b4f991aaf83ab452067687a6b6205e82730d53e50348689133f", + "size": 40875, + "subdir": "linux-64", + "timestamp": 1597430382968, + "version": "0.8.7" + }, + "tabulate-0.8.7-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba340fe5432f8b82dbc60ab2f164f019", + "name": "tabulate", + "sha256": "02525e1e6fd434632a454ea3c84561cae921c51ad42d65a5b50cb2b2e888d459", + "size": 40903, + "subdir": "linux-64", + "timestamp": 1613564889286, + "version": "0.8.7" + }, + "tabulate-0.8.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fbfd3e58323297d71002fd1ff4e414e3", + "name": "tabulate", + "sha256": "43eeee46fa0da3f98d6ac6e514ba1ecbb701d891430e625a563dc75f8dea1cc0", + "size": 40950, + "subdir": "linux-64", + "timestamp": 1613564888697, + "version": "0.8.7" + }, + "tabulate-0.8.9-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb5e3d4aecfe2263680e087f84eaae26", + "name": "tabulate", + "sha256": "fbfd7eb301cc3934002cc3e8d5638979921ef7300e3973b8ffcf958a4734f174", + "size": 40341, + "subdir": "linux-64", + "timestamp": 1640794997450, + "version": "0.8.9" + }, + "tabulate-0.8.9-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b532fc56df05b9c3ab18006aeeb01edf", + "name": "tabulate", + "sha256": "867fcd0ce700e94eef51185733c9a449c46e3d37a3cdcc5022c4de01cdc235ac", + "size": 40292, + "subdir": "linux-64", + "timestamp": 1614028904974, + "version": "0.8.9" + }, + "tabulate-0.8.9-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c32cab843dc3438861fc2a57dec9504f", + "name": "tabulate", + "sha256": "f7acca02335077eb8c8a7cfc3d9d70ec810af9930b98bff26a9498f2565d4e3a", + "size": 40809, + "subdir": "linux-64", + "timestamp": 1614029746441, + "version": "0.8.9" + }, + "tabulate-0.8.9-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1166a697b3acda4ceda09cf51fa523c5", + "name": "tabulate", + "sha256": "32aa777219bfc589704b232ac8e5ee904a24008b9840178ff5e80de33f4e63a2", + "size": 41318, + "subdir": "linux-64", + "timestamp": 1614029801868, + "version": "0.8.9" + }, + "tabulate-0.8.9-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6f3f72a7601ff71bf4df2f7a01073065", + "name": "tabulate", + "sha256": "ca897ce8b88d93acdd1b21536e1ecde19da30557d5b64e42575f50731ed4f30c", + "size": 41058, + "subdir": "linux-64", + "timestamp": 1614029810339, + "version": "0.8.9" + }, + "tangled-up-in-unicode-0.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "492c7310233ee0b721fc569af63bef53", + "name": "tangled-up-in-unicode", + "sha256": "96d8505ecea648cb4e017a3fa0627ac28a74f6f9a6457b04e34bddfe8b15039f", + "size": 15522585, + "subdir": "linux-64", + "timestamp": 1668545409400, + "version": "0.2.0" + }, + "tangled-up-in-unicode-0.2.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "75fc265ef32e72132164c5a598f138a2", + "name": "tangled-up-in-unicode", + "sha256": "784fe87211a4989a4fef7136df90b351312352d56fd59dd470b7137de29932c9", + "size": 5712239, + "subdir": "linux-64", + "timestamp": 1676842938740, + "version": "0.2.0" + }, + "tangled-up-in-unicode-0.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "fa61f38ba473d02b4920eadcf21a5452", + "name": "tangled-up-in-unicode", + "sha256": "c45498873171a30da36fdffaafdfeda97e502d9a05145bcfee95a3b9a247e84a", + "size": 5498807, + "subdir": "linux-64", + "timestamp": 1668546017173, + "version": "0.2.0" + }, + "tangled-up-in-unicode-0.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "8bb2c58639798c0834f0eb2ef5c86302", + "name": "tangled-up-in-unicode", + "sha256": "705d761cff75cee0487604038d253e8214fb4a0d0a401588d5bd961e2814e617", + "size": 5684672, + "subdir": "linux-64", + "timestamp": 1668545273901, + "version": "0.2.0" + }, + "tangled-up-in-unicode-0.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "a4e0310bc0b0bc79cad563185a754b71", + "name": "tangled-up-in-unicode", + "sha256": "6b84204ba21ee648c8f32113da97d136a98b43b962749abe069490349e056189", + "size": 5690331, + "subdir": "linux-64", + "timestamp": 1668545328152, + "version": "0.2.0" + }, + "tapi-1100.0.11-h039ab34_1.conda": { + "build": "h039ab34_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "NCSA", + "license_family": "MIT", + "md5": "7aed9fdd8c88b82bd8bc88ecf61012b5", + "name": "tapi", + "sha256": "a51fad38ddeeb15c96489ddae4a1d2db89ae477c87d731034e93873177fed15f", + "size": 1155614, + "subdir": "linux-64", + "timestamp": 1662380929878, + "version": "1100.0.11" + }, + "tbb-2018.0.2-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "md5": "b2095f378af48d0ed38444fd2a17d6ef", + "name": "tbb", + "sha256": "b447a3f2ad8341a238bb35c40a3a3a5f74a7cee401169218cc3f13b969d67522", + "size": 394964, + "subdir": "linux-64", + "timestamp": 1521147527749, + "version": "2018.0.2" + }, + "tbb-2018.0.4-h6bb024c_1.conda": { + "build": "h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "md5": "87903dc57c5be0778f4824c617215bc9", + "name": "tbb", + "sha256": "56aee1159d9323b23257b699203287ba4cf664782ca885998f2a1c5aef30402a", + "size": 1045723, + "subdir": "linux-64", + "timestamp": 1528735288511, + "version": "2018.0.4" + }, + "tbb-2018.0.5-h6bb024c_0.conda": { + "build": "h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "md5": "ab7814ee402d409520954f7941652c0a", + "name": "tbb", + "sha256": "5760682c942d7053384e23f330023ab24d46cad03083415f020a2201d1333d39", + "size": 1124723, + "subdir": "linux-64", + "timestamp": 1535203813841, + "version": "2018.0.5" + }, + "tbb-2019.0-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "md5": "918bff09491617b8b77bc0d48651615c", + "name": "tbb", + "sha256": "d6e4c0deb3b768c4ea8386b9172eb92ed0767dcbe98a8b234f03226fe696d53c", + "size": 1126990, + "subdir": "linux-64", + "timestamp": 1538483576896, + "version": "2019.0" + }, + "tbb-2019.1-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "md5": "e717cef9de7dcb4d9d759a33020d3bd1", + "name": "tbb", + "sha256": "df6f21919e11cff94e92663557bc19c7936aecf4f63c7ec526616357df5f7754", + "size": 1124577, + "subdir": "linux-64", + "timestamp": 1539116540571, + "version": "2019.1" + }, + "tbb-2019.4-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "md5": "2430ffcde872ac132c960c9c6641601f", + "name": "tbb", + "sha256": "3017d00aa19a91b2ee5572704dfd259d7fde2cd2ef546497cdfcefcfa7310d47", + "size": 1137110, + "subdir": "linux-64", + "timestamp": 1552512268103, + "version": "2019.4" + }, + "tbb-2019.8-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "md5": "2aca18fd6f05714a06249777003ffec3", + "name": "tbb", + "sha256": "4e065b9a8246b356ce93abb711efbd1450d2afc3ba42b4e0320b751288bd072e", + "size": 1138627, + "subdir": "linux-64", + "timestamp": 1570736062888, + "version": "2019.8" + }, + "tbb-2020.0-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "md5": "8a8ad46051a3ac2dfeccf96f9bbb0c94", + "name": "tbb", + "sha256": "ecb35e96a89c32eba90b4b34684a25b71078d7fbef378a6baba58cd26d893b8a", + "size": 1141594, + "subdir": "linux-64", + "timestamp": 1580848349460, + "version": "2020.0" + }, + "tbb-2020.1-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "md5": "d23a72265c1994224bd05a47371114ea", + "name": "tbb", + "sha256": "9af3382144ef25f5fce1381436b16765effec974bb7bb41d67e40322b9eba97b", + "size": 1162587, + "subdir": "linux-64", + "timestamp": 1597700578963, + "version": "2020.1" + }, + "tbb-2020.2-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "md5": "5190d818889aba5f615dca0310b9fc57", + "name": "tbb", + "sha256": "59c855a51284658c82bf52e5b6822c977e1c3e3913fde6f2c5a40d80eb87d7cb", + "size": 1163163, + "subdir": "linux-64", + "timestamp": 1598284735993, + "version": "2020.2" + }, + "tbb-2020.2-hff7bd54_0.conda": { + "build": "hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "md5": "a864a0603a909340ffb6d0441a708cdc", + "name": "tbb", + "sha256": "3eb8237456a36754c6416e5f8dc02170b571db8d582bc5e294f519e76799489a", + "size": 1162817, + "subdir": "linux-64", + "timestamp": 1613159239113, + "version": "2020.2" + }, + "tbb-2020.3-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "md5": "7d06fdc8b4f3e389f26f67311c7ccf5f", + "name": "tbb", + "sha256": "a8985c2c4dd9d08f335eeb2d8de3326b27c68d48d1c8d02025b7f71482f70497", + "size": 1155606, + "subdir": "linux-64", + "timestamp": 1600554924591, + "version": "2020.3" + }, + "tbb-2021.2.0-hff7bd54_0.conda": { + "build": "hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache-2.0", + "md5": "be9bb7ce4357898ed7ee747e9592d303", + "name": "tbb", + "sha256": "a22d4f91a853317950ccfed0c778068975e24ad50bdb32baf0c0e3f5b267908e", + "size": 191514, + "subdir": "linux-64", + "timestamp": 1618504840266, + "version": "2021.2.0" + }, + "tbb-2021.3.0-hd09550d_0.conda": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "md5": "2ab76aa2eb4a80076c874a6c54c34a26", + "name": "tbb", + "sha256": "768340ffbbe720445c07111581cb5bd505a2e6e21721701eb9f463b36f851976", + "size": 195457, + "subdir": "linux-64", + "timestamp": 1626359187729, + "version": "2021.3.0" + }, + "tbb-2021.4.0-hd09550d_0.conda": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "md5": "1264e02b39afedfba4474fa21301f127", + "name": "tbb", + "sha256": "b624bb2b5fb1e1166ece08c08958401a9e1d4f823e9624f6344dbbe7d833906b", + "size": 172765, + "subdir": "linux-64", + "timestamp": 1634724023113, + "version": "2021.4.0" + }, + "tbb-2021.5.0-hd09550d_0.conda": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "Apache-2.0", + "md5": "867ebeca24d797d0de13ed31ee2feef1", + "name": "tbb", + "sha256": "165092ea0c51f712066692dd19bf3f82593bf61fa51a904759bb10fc785924a6", + "size": 160773, + "subdir": "linux-64", + "timestamp": 1641830509786, + "version": "2021.5.0" + }, + "tbb-2021.6.0-hdb19cb5_0.conda": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3cca012bf8dfd39ac2aeabe439e204a5", + "name": "tbb", + "sha256": "2b16b6dabb301f40fe9e08ea71e358b82a9b1a1aed598ea982ff9e72da9ee84e", + "size": 1471776, + "subdir": "linux-64", + "timestamp": 1664812947196, + "version": "2021.6.0" + }, + "tbb-2021.6.0-hdb19cb5_1.conda": { + "build": "hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d8a0a1ec6a0357bec3ef3fd1da753fbd", + "name": "tbb", + "sha256": "0b07a31dafcc07f87104751c18f50b5fc493f4024d1e87588e17ce3128ac9564", + "size": 1725799, + "subdir": "linux-64", + "timestamp": 1673966561702, + "version": "2021.6.0" + }, + "tbb-2021.7.0-hdb19cb5_0.conda": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "074136013ad33576a199a286d603aecb", + "name": "tbb", + "sha256": "11d8c6e1099f6fd2a804e8e385e18c557afd651eb5538cb61b8cbc3e4011763f", + "size": 1728633, + "subdir": "linux-64", + "timestamp": 1676908648515, + "version": "2021.7.0" + }, + "tbb-2021.8.0-hdb19cb5_0.conda": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "869373905a6bfacbb967abc98516dd85", + "name": "tbb", + "sha256": "c4667f31fd0f7ed35796f2f9b4e7f00bf2ec6ccafb67bd8fe1bd9dd488ad8f75", + "size": 1728218, + "subdir": "linux-64", + "timestamp": 1680167274961, + "version": "2021.8.0" + }, + "tbb-devel-2018.0.4-h6bb024c_1.conda": { + "build": "h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "tbb 2018.0.4 h6bb024c_1" + ], + "license": "Apache 2.0", + "md5": "ac89cc8cbedb1f5456e5bde4a9f54bf8", + "name": "tbb-devel", + "sha256": "01cf58c9bdb916a08bd879784f2a626a16d8d9c343be11ef212a61ba191645c9", + "size": 2166651, + "subdir": "linux-64", + "timestamp": 1528735308421, + "version": "2018.0.4" + }, + "tbb-devel-2018.0.5-h6bb024c_0.conda": { + "build": "h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2018.0.5 h6bb024c_0" + ], + "license": "Apache 2.0", + "md5": "bb47faf8c04d63f3437bbe8a526f6bad", + "name": "tbb-devel", + "sha256": "b56dc2c7f0732444ccb82374a99e17f892d311b26d0796b619ac271439590ad9", + "size": 1097030, + "subdir": "linux-64", + "timestamp": 1535203850891, + "version": "2018.0.5" + }, + "tbb-devel-2019.0-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2019.0 hfd86e86_0" + ], + "license": "Apache 2.0", + "md5": "7d103024abd55dab893c17b7bb810495", + "name": "tbb-devel", + "sha256": "8184b0b54470d108825ca41137f3a8e28053d036fdc25774dfd1915ff304e145", + "size": 2476492, + "subdir": "linux-64", + "timestamp": 1538483589455, + "version": "2019.0" + }, + "tbb-devel-2019.1-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2019.1 hfd86e86_0" + ], + "license": "Apache 2.0", + "md5": "19d195e513834443c208302d1838e480", + "name": "tbb-devel", + "sha256": "b81f906b15d6beadce38b95deb02e8b36d30b2e863a970903242e8a220f8c66c", + "size": 2458991, + "subdir": "linux-64", + "timestamp": 1539116559565, + "version": "2019.1" + }, + "tbb-devel-2019.4-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2019.4 hfd86e86_0" + ], + "license": "Apache 2.0", + "md5": "2dc94f987bd83ec1f00dcd69308038ea", + "name": "tbb-devel", + "sha256": "1b43aa8b501e952a974567ecb57d879616cecaad01a53e0b480d87059f613697", + "size": 2689480, + "subdir": "linux-64", + "timestamp": 1552512283866, + "version": "2019.4" + }, + "tbb-devel-2019.8-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2019.8 hfd86e86_0" + ], + "license": "Apache 2.0", + "md5": "9b4baba6f173bc588b0e71e654275972", + "name": "tbb-devel", + "sha256": "0b884b84cd6de9801d1b26f8a9fd995dddec0a37c2f6e07bbd075c523bec1483", + "size": 2695824, + "subdir": "linux-64", + "timestamp": 1570736094081, + "version": "2019.8" + }, + "tbb-devel-2020.0-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2020.0 hfd86e86_0" + ], + "license": "Apache 2.0", + "md5": "3f0c2fad7d5b01cceab679ccdd37468a", + "name": "tbb-devel", + "sha256": "af640a673c46b24419b470d7beee9254e9b08934ec2f9b7e77a764a292b8e641", + "size": 1179279, + "subdir": "linux-64", + "timestamp": 1580848379029, + "version": "2020.0" + }, + "tbb-devel-2020.1-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2020.1 hfd86e86_0" + ], + "license": "Apache-2.0", + "md5": "0983068f0b26e6e31d3d8a3cba54a7b8", + "name": "tbb-devel", + "sha256": "c3c508529b514e6a4259769971cc3a3ffa1b8c90dab83a40f72b4cb2e4dc10a6", + "size": 1195620, + "subdir": "linux-64", + "timestamp": 1597700593910, + "version": "2020.1" + }, + "tbb-devel-2020.2-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2020.2 hfd86e86_0" + ], + "license": "Apache-2.0", + "md5": "6eeb33d330dd308590d9db35e4d941ad", + "name": "tbb-devel", + "sha256": "50d4ba9dd363f2fa1f8a2a8b19892d4c86b33f2f86add1bd3f903de43aa7d14d", + "size": 1195840, + "subdir": "linux-64", + "timestamp": 1598284756020, + "version": "2020.2" + }, + "tbb-devel-2020.2-hff7bd54_0.conda": { + "build": "hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2020.2 hff7bd54_0" + ], + "license": "Apache-2.0", + "md5": "510a62cd84f7fda19cf8ccc04bd8e95e", + "name": "tbb-devel", + "sha256": "175f86f2f94a2e398dbd15db718b0459a7b855fd9fc7547c04f232447d589a2e", + "size": 1196305, + "subdir": "linux-64", + "timestamp": 1613159260245, + "version": "2020.2" + }, + "tbb-devel-2020.3-hfd86e86_0.conda": { + "build": "hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2020.3 hfd86e86_0" + ], + "license": "Apache-2.0", + "md5": "a420da7dc7770dd8ddfb1b159a24c54a", + "name": "tbb-devel", + "sha256": "7bc447945e2399ffa749580b68ea2c54bcc53344184a090f43fd159e0fe7d48b", + "size": 1189994, + "subdir": "linux-64", + "timestamp": 1600554943851, + "version": "2020.3" + }, + "tbb-devel-2021.2.0-hff7bd54_0.conda": { + "build": "hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "tbb 2021.2.0 hff7bd54_0" + ], + "license": "Apache-2.0", + "md5": "52ac990fed877b05ba0f35c3c6337844", + "name": "tbb-devel", + "sha256": "17399c164db5f7eda9faa00785188a9e3ae9348afc64ca3ef79b9cae4e1ed8ae", + "size": 965697, + "subdir": "linux-64", + "timestamp": 1618504851478, + "version": "2021.2.0" + }, + "tbb-devel-2021.3.0-hd09550d_0.conda": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "tbb 2021.3.0 hd09550d_0" + ], + "license": "Apache-2.0", + "md5": "3ec2b4124497f5d76ec966efbab8ca1c", + "name": "tbb-devel", + "sha256": "1e9c1712ce7ba98fa5fa1617e91a3f596284e01a6e1a166c73de3cf54b2906d9", + "size": 999179, + "subdir": "linux-64", + "timestamp": 1626359202242, + "version": "2021.3.0" + }, + "tbb-devel-2021.4.0-hd09550d_0.conda": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "tbb 2021.4.0 hd09550d_0" + ], + "license": "Apache-2.0", + "md5": "41455efba8e6c828afed5060c3c1154a", + "name": "tbb-devel", + "sha256": "4cf7d75214a6e7d95af5db656e7a554976591a020b0e8ba5e0c4a4a059880867", + "size": 1020748, + "subdir": "linux-64", + "timestamp": 1634724038507, + "version": "2021.4.0" + }, + "tbb-devel-2021.5.0-hd09550d_0.conda": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "tbb 2021.5.0 hd09550d_0" + ], + "license": "Apache-2.0", + "md5": "edcbba53544c9a0c2db754d56dd3f9ce", + "name": "tbb-devel", + "sha256": "9b5b7ac25e523b37e05789e9f9f72323c09dc9e415f9dd93f281cfd48b9ba142", + "size": 1010863, + "subdir": "linux-64", + "timestamp": 1641830523313, + "version": "2021.5.0" + }, + "tbb-devel-2021.6.0-hdb19cb5_0.conda": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.6.0 hdb19cb5_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2e84a64e325ef4982599b35f33707ea3", + "name": "tbb-devel", + "sha256": "116db3e10cce9cb348994e01e4bcac4ea32241564acaeca6fca2a6f3c17a81b6", + "size": 1016896, + "subdir": "linux-64", + "timestamp": 1664812960756, + "version": "2021.6.0" + }, + "tbb-devel-2021.6.0-hdb19cb5_1.conda": { + "build": "hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.6.0 hdb19cb5_1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f3d0523040086ffe7cd0b99224355859", + "name": "tbb-devel", + "sha256": "759462e7053bf2a55c87fb480294d158de7bbd0e412d1a5c7cd3cd152201ad07", + "size": 1096955, + "subdir": "linux-64", + "timestamp": 1673966577121, + "version": "2021.6.0" + }, + "tbb-devel-2021.7.0-hdb19cb5_0.conda": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.7.0 hdb19cb5_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b94d46fe4d66e809bab2f223f11e9a8e", + "name": "tbb-devel", + "sha256": "2babadba89106ca5ea6cb0b27eaf54a39b90a9a5f3d4fbcf4e274ecd99ba0be3", + "size": 1099168, + "subdir": "linux-64", + "timestamp": 1676908663814, + "version": "2021.7.0" + }, + "tbb-devel-2021.8.0-hdb19cb5_0.conda": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "tbb 2021.8.0 hdb19cb5_0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7ef8d1a9d1065802fe0a43c6586946e2", + "name": "tbb-devel", + "sha256": "3b378c8807899682038ccc7ca6a163030d2aaf0b3e11f83c5d9de190143cbca4", + "size": 1106493, + "subdir": "linux-64", + "timestamp": 1680167284254, + "version": "2021.8.0" + }, + "tbb4py-2018.0.4-py27h6bb024c_1.conda": { + "build": "py27h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "tbb >=2018.0.4" + ], + "license": "Apache 2.0", + "md5": "772dd2f4e7d7e5fe2e9a1ceb0ff2b020", + "name": "tbb4py", + "sha256": "87c7219fdfbc41d4f0a18707fbc42845a40f5c454b12412285a07c6cb8e5bd39", + "size": 166744, + "subdir": "linux-64", + "timestamp": 1528735449472, + "version": "2018.0.4" + }, + "tbb4py-2018.0.4-py35h6bb024c_1.conda": { + "build": "py35h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "tbb >=2018.0.4" + ], + "license": "Apache 2.0", + "md5": "1d1c465bfc18b5a3c8f1715d932e9937", + "name": "tbb4py", + "sha256": "9787d66746acce5c03f58059ce9d956c9b2ed96755474f240b4f5bad05e788c0", + "size": 166167, + "subdir": "linux-64", + "timestamp": 1528735408095, + "version": "2018.0.4" + }, + "tbb4py-2018.0.4-py36h6bb024c_1.conda": { + "build": "py36h6bb024c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "tbb >=2018.0.4" + ], + "license": "Apache 2.0", + "md5": "115649cdd3c8889aae6a2aad4bc43637", + "name": "tbb4py", + "sha256": "6bccd548b99fe550c9c4242371a78aad2f38c10c5b46f9a8121e0b28d98d53c9", + "size": 165748, + "subdir": "linux-64", + "timestamp": 1528735429374, + "version": "2018.0.4" + }, + "tbb4py-2018.0.5-py27h6bb024c_0.conda": { + "build": "py27h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "tbb >=2018.0.5" + ], + "license": "Apache 2.0", + "md5": "0ee32b4b15d444f10cbb1007dd8550ac", + "name": "tbb4py", + "sha256": "48f2455b5388dfd8b39ffa0e564874a8a0f993eec50a14f4ea7b06f0e1ec9c25", + "size": 206360, + "subdir": "linux-64", + "timestamp": 1535203950052, + "version": "2018.0.5" + }, + "tbb4py-2018.0.5-py35h6bb024c_0.conda": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.5,<3.6.0a0", + "tbb >=2018.0.5" + ], + "license": "Apache 2.0", + "md5": "84908c23e0d95b1a954d0dabc828b188", + "name": "tbb4py", + "sha256": "7d6c9e2e06289f0c6f08f695baa98cea4f5bf95094b30b551ee2f8317accb9c4", + "size": 205391, + "subdir": "linux-64", + "timestamp": 1535203922588, + "version": "2018.0.5" + }, + "tbb4py-2018.0.5-py36h6bb024c_0.conda": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2018.0.5" + ], + "license": "Apache 2.0", + "md5": "0eee8d50837e67485a77f4da57011278", + "name": "tbb4py", + "sha256": "bc43b8f9b59036a22210aa07380f8f8f61da9bb35ac37c2b27d1f5454fcbf182", + "size": 205213, + "subdir": "linux-64", + "timestamp": 1535203979367, + "version": "2018.0.5" + }, + "tbb4py-2018.0.5-py37h6bb024c_0.conda": { + "build": "py37h6bb024c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2018.0.5" + ], + "license": "Apache 2.0", + "md5": "920195e39fb06540ad8495f19704d5a5", + "name": "tbb4py", + "sha256": "3ca86ec8f954d64efcfb6dfc397b23768b0dc9f182600b16b100a1facbc6e2ab", + "size": 205257, + "subdir": "linux-64", + "timestamp": 1535203890293, + "version": "2018.0.5" + }, + "tbb4py-2019.0-py27hfd86e86_0.conda": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "tbb >=2019.0" + ], + "license": "Apache 2.0", + "md5": "25b5661c7fe0ecd9e90231dee3a7d6ad", + "name": "tbb4py", + "sha256": "1e3ca847755da1b5f1666f33e36f403a08f62b092f89ee77364df34ca2b0b4fe", + "size": 206492, + "subdir": "linux-64", + "timestamp": 1538483613853, + "version": "2019.0" + }, + "tbb4py-2019.0-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.0" + ], + "license": "Apache 2.0", + "md5": "87cb496b56454824e62badfecd507a3f", + "name": "tbb4py", + "sha256": "6a2bbb8a97efd67e2178e59c55e0f414c92825ccdb9eb0a88a4d33dcce3be4dc", + "size": 205257, + "subdir": "linux-64", + "timestamp": 1538483628171, + "version": "2019.0" + }, + "tbb4py-2019.0-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.0" + ], + "license": "Apache 2.0", + "md5": "8f8580cda1530a7e341ea26871e54fb8", + "name": "tbb4py", + "sha256": "13876b53d497fdca10cd48ac0c5b16959e083ef4b848cb8b732827e151527554", + "size": 205383, + "subdir": "linux-64", + "timestamp": 1538483642751, + "version": "2019.0" + }, + "tbb4py-2019.1-py27hfd86e86_0.conda": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "tbb >=2019.1" + ], + "license": "Apache 2.0", + "md5": "3e54d22060c5dd0ed5de433933365ec0", + "name": "tbb4py", + "sha256": "fb94c26a7a2621a5f2d43622860d80e9eadaf76a97f18b9d6cc1cef0acd492d5", + "size": 203489, + "subdir": "linux-64", + "timestamp": 1539116594522, + "version": "2019.1" + }, + "tbb4py-2019.1-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.1" + ], + "license": "Apache 2.0", + "md5": "e48368082c52160924914de63fa68811", + "name": "tbb4py", + "sha256": "497a5ae667d2d2ff37a6604d5eae8883f5f913739b605ca7c03d2e9da1cf74e2", + "size": 202445, + "subdir": "linux-64", + "timestamp": 1539116617950, + "version": "2019.1" + }, + "tbb4py-2019.1-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.1" + ], + "license": "Apache 2.0", + "md5": "2b23e81e7e036c3eb2d0ebea1f140a24", + "name": "tbb4py", + "sha256": "091ba6e08cdc32e8c07ab29d43f692525e2a97fac0020f2e3cc070bc14bb7d83", + "size": 202371, + "subdir": "linux-64", + "timestamp": 1539116642564, + "version": "2019.1" + }, + "tbb4py-2019.4-py27hfd86e86_0.conda": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "tbb >=2019.4" + ], + "license": "Apache 2.0", + "md5": "a5c648957b39bf35a823b2e548d824aa", + "name": "tbb4py", + "sha256": "3e08fc0fd7d02febcfa611519de3f21388e1d0f59af1e54b1de95510c1e763f3", + "size": 209859, + "subdir": "linux-64", + "timestamp": 1552512349863, + "version": "2019.4" + }, + "tbb4py-2019.4-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.4" + ], + "license": "Apache 2.0", + "md5": "7499986de8e331eaf9c18961da799371", + "name": "tbb4py", + "sha256": "161df34a4fd039dd361a43579ac660358728edd011010ece3ef56a77c499aa21", + "size": 209327, + "subdir": "linux-64", + "timestamp": 1552512313660, + "version": "2019.4" + }, + "tbb4py-2019.4-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.4" + ], + "license": "Apache 2.0", + "md5": "ff37f7260aaf72a8929ca16f5203d1e3", + "name": "tbb4py", + "sha256": "70d62e7034955da00e9af3c96a6a39bc618ccc7e8623325065e4fd780215391e", + "size": 209693, + "subdir": "linux-64", + "timestamp": 1552512331323, + "version": "2019.4" + }, + "tbb4py-2019.8-py27hfd86e86_0.conda": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "tbb >=2019.8" + ], + "license": "Apache 2.0", + "md5": "6c5bc14ccc70f124c89605e0c7919cf2", + "name": "tbb4py", + "sha256": "b4218d6071c4c8c8b58363893f3430a99c9d1b275ab297c6275388319b6316d4", + "size": 213876, + "subdir": "linux-64", + "timestamp": 1570736126780, + "version": "2019.8" + }, + "tbb4py-2019.8-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.8" + ], + "license": "Apache 2.0", + "md5": "969dca1686539dd07e28ccfd8e70e544", + "name": "tbb4py", + "sha256": "99d2155c0a7a4417dcc84ffc38a66f2287d718ddb9ae1a17b22a30def010fd31", + "size": 212364, + "subdir": "linux-64", + "timestamp": 1570736132962, + "version": "2019.8" + }, + "tbb4py-2019.8-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.8" + ], + "license": "Apache 2.0", + "md5": "9a9cd507f1a15238f8c85da3a8316bab", + "name": "tbb4py", + "sha256": "80850a996d019448294c13b655088d3fb0bac01e2219a5ce246a12fe1063d435", + "size": 213773, + "subdir": "linux-64", + "timestamp": 1570736094008, + "version": "2019.8" + }, + "tbb4py-2020.0-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2020.0" + ], + "license": "Apache 2.0", + "md5": "1cda1259ee20d0a921f02df2508d274d", + "name": "tbb4py", + "sha256": "e37d29195fba4cd0e4437bfe2e9707d2e4c90834cc47218b7ad1265cf3b21cbe", + "size": 214217, + "subdir": "linux-64", + "timestamp": 1580848419855, + "version": "2020.0" + }, + "tbb4py-2020.0-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2020.0" + ], + "license": "Apache 2.0", + "md5": "8106635a0354586e496118700e741fd1", + "name": "tbb4py", + "sha256": "f59421aae502da44c11c8011c1181a7a0cc0c2d716475d2680fec44a963bf2ce", + "size": 214274, + "subdir": "linux-64", + "timestamp": 1580848446323, + "version": "2020.0" + }, + "tbb4py-2020.0-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "tbb >=2020.0" + ], + "license": "Apache 2.0", + "md5": "e37ff68b26d0179c04d8c4b1fe186143", + "name": "tbb4py", + "sha256": "ea977b33960317848778aa42c52452966354e12aeefe10ab3ae2db3f6f88e17f", + "size": 214469, + "subdir": "linux-64", + "timestamp": 1580848473908, + "version": "2020.0" + }, + "tbb4py-2020.1-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2020.1" + ], + "license": "Apache 2.0", + "md5": "cc516ae81b7d5c03c1d36dc8f1c17375", + "name": "tbb4py", + "sha256": "ff79890630df89d2846990ca8e273505eb63e5c3ba3e8949e2af7ad196d2786a", + "size": 213061, + "subdir": "linux-64", + "timestamp": 1597700645893, + "version": "2020.1" + }, + "tbb4py-2020.1-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2020.1" + ], + "license": "Apache 2.0", + "md5": "e58e786881e0ec868439eec0159a81cc", + "name": "tbb4py", + "sha256": "09c78c785b24af70718eb89c03bb0a9bc44de94d9193b95a71db5282697634b7", + "size": 213094, + "subdir": "linux-64", + "timestamp": 1597700617034, + "version": "2020.1" + }, + "tbb4py-2020.1-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "tbb >=2020.1" + ], + "license": "Apache 2.0", + "md5": "21c99702122b4c344ffa88adaff36578", + "name": "tbb4py", + "sha256": "f329d428d83dc4c24bcdb0eddded0f66f03c9be2c5f87ab7397843574e934708", + "size": 213364, + "subdir": "linux-64", + "timestamp": 1597700630436, + "version": "2020.1" + }, + "tbb4py-2020.2-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2020.2" + ], + "license": "Apache 2.0", + "md5": "a7320ea2e8de83ae2fe05ed6de8ac513", + "name": "tbb4py", + "sha256": "680acb7be897349d97588ac0d6336f17430e90ab447fa5df037f8c3b1d5e1946", + "size": 214111, + "subdir": "linux-64", + "timestamp": 1598284782889, + "version": "2020.2" + }, + "tbb4py-2020.2-py36hff7bd54_0.conda": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2020.2" + ], + "license": "Apache 2.0", + "md5": "00e12fc9970b69530085930d7132625f", + "name": "tbb4py", + "sha256": "c3b218c1515cbe3e02a9163bcea759b1469be88babbc975c9c736b0f878a30e2", + "size": 214240, + "subdir": "linux-64", + "timestamp": 1613159289122, + "version": "2020.2" + }, + "tbb4py-2020.2-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2020.2" + ], + "license": "Apache 2.0", + "md5": "08edf235f433b88ae130a3ec9f27d2ca", + "name": "tbb4py", + "sha256": "b764bf5ade0e3e7059d09cbc7aef0fc1d6b88cba92d6fd3d371e70f4ad284bae", + "size": 214175, + "subdir": "linux-64", + "timestamp": 1598284800246, + "version": "2020.2" + }, + "tbb4py-2020.2-py37hff7bd54_0.conda": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2020.2" + ], + "license": "Apache 2.0", + "md5": "a417b80e39e2c3e6910b1c8072a66fc8", + "name": "tbb4py", + "sha256": "23e302f5494a8684a2b97e9d53375291d64616053f66d5d60e02bdba533ae873", + "size": 214286, + "subdir": "linux-64", + "timestamp": 1613159344000, + "version": "2020.2" + }, + "tbb4py-2020.2-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "tbb >=2020.2" + ], + "license": "Apache 2.0", + "md5": "5ac33f68e38539d7145a32ca321307b7", + "name": "tbb4py", + "sha256": "1881f475bcfed9cae2ae5b141facd408956b973844831fc0dd59c615063906e1", + "size": 214382, + "subdir": "linux-64", + "timestamp": 1598284818051, + "version": "2020.2" + }, + "tbb4py-2020.2-py38hff7bd54_0.conda": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "tbb >=2020.2" + ], + "license": "Apache 2.0", + "md5": "156f03f2d9a3a3c8c715b06a4e3ae0d4", + "name": "tbb4py", + "sha256": "cd783fefe53aaafe8240ad3ee3ff7d54a87d8892bb1907fdbc6bddc0ceff1b6e", + "size": 214558, + "subdir": "linux-64", + "timestamp": 1613159326023, + "version": "2020.2" + }, + "tbb4py-2020.2-py39hff7bd54_0.conda": { + "build": "py39hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "tbb >=2020.2" + ], + "license": "Apache 2.0", + "md5": "b74cca6f7c5de2b6ae8cd02e2e452902", + "name": "tbb4py", + "sha256": "cfdce48e4899def100a19e86ce947491afb325c6dca003926828373e4998525e", + "size": 214449, + "subdir": "linux-64", + "timestamp": 1613159307629, + "version": "2020.2" + }, + "tbb4py-2020.3-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2020.3" + ], + "license": "Apache 2.0", + "md5": "dc60722d3825285273952ca0d37095ae", + "name": "tbb4py", + "sha256": "92df558991486a4ca20dc705861c3cc253b9b05bb6ff752dc034a60a08783b3b", + "size": 204625, + "subdir": "linux-64", + "timestamp": 1600555006031, + "version": "2020.3" + }, + "tbb4py-2020.3-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2020.3" + ], + "license": "Apache 2.0", + "md5": "d74ff2a9cc33daaa9b6a9d0d7bc61290", + "name": "tbb4py", + "sha256": "6f25a45a6d787972daa74719c7e7c5bc5b2bcfab3e6363f5bab9ec32536d1dd2", + "size": 204693, + "subdir": "linux-64", + "timestamp": 1600554971585, + "version": "2020.3" + }, + "tbb4py-2020.3-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "tbb >=2020.3" + ], + "license": "Apache 2.0", + "md5": "7b3878f096ccf10d06afc7db19edc55c", + "name": "tbb4py", + "sha256": "d7b7cc2c222403c664a84ef9dbf667901d9dc10900b3bf815c513952736d0d51", + "size": 204924, + "subdir": "linux-64", + "timestamp": 1600554989193, + "version": "2020.3" + }, + "tbb4py-2021.2.0-py36hff7bd54_0.conda": { + "build": "py36hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "tbb >=2021.2.0" + ], + "license": "Apache 2.0", + "md5": "689fdd22e9518b390b153f4109b3ab34", + "name": "tbb4py", + "sha256": "cce4646c9f2f2cb876d2ba7baf3fcdd10427d66b7123a3b68ed3790bf05f15a9", + "size": 85582, + "subdir": "linux-64", + "timestamp": 1618504957377, + "version": "2021.2.0" + }, + "tbb4py-2021.2.0-py37hff7bd54_0.conda": { + "build": "py37hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "tbb >=2021.2.0" + ], + "license": "Apache 2.0", + "md5": "8ccfb10d872092360acd3e99b2ac45b1", + "name": "tbb4py", + "sha256": "aeda70cd4b05d93b83caad6b55f3a2750b74f404495cae068765bbe49958d446", + "size": 85574, + "subdir": "linux-64", + "timestamp": 1618504932051, + "version": "2021.2.0" + }, + "tbb4py-2021.2.0-py38hff7bd54_0.conda": { + "build": "py38hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "tbb >=2021.2.0" + ], + "license": "Apache 2.0", + "md5": "5ba7c0584f257b11a8ba9f4f60764635", + "name": "tbb4py", + "sha256": "301f4055b02f9919829b13d09a82f88e4ef2dc7ed59d029739457bcd3cdf8b2f", + "size": 85772, + "subdir": "linux-64", + "timestamp": 1618504882310, + "version": "2021.2.0" + }, + "tbb4py-2021.2.0-py39hff7bd54_0.conda": { + "build": "py39hff7bd54_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "tbb >=2021.2.0" + ], + "license": "Apache 2.0", + "md5": "3e7e42bfa8531317860e968347419961", + "name": "tbb4py", + "sha256": "ed525d56ba2c218a3980e93f8ab7bddd9f1b74e5de975b335ea9a110f1bd56c9", + "size": 85695, + "subdir": "linux-64", + "timestamp": 1618504907879, + "version": "2021.2.0" + }, + "tbb4py-2021.3.0-py36hd09550d_0.conda": { + "build": "py36hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "tbb >=2021.3.0" + ], + "license": "Apache 2.0", + "md5": "4ff156a3a5b6f31049c2772922a4329d", + "name": "tbb4py", + "sha256": "d265005abe3d3b7f7c08674740e0f3dbe166a442300bb2f2717f114d22b47bac", + "size": 84077, + "subdir": "linux-64", + "timestamp": 1626359298456, + "version": "2021.3.0" + }, + "tbb4py-2021.3.0-py37hd09550d_0.conda": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "tbb >=2021.3.0" + ], + "license": "Apache 2.0", + "md5": "ddaede439d3cd869657b91af67593a19", + "name": "tbb4py", + "sha256": "79a7957787bc7fab4f61823b33c86646de9901edac7af69311cf0b479b7816f7", + "size": 84081, + "subdir": "linux-64", + "timestamp": 1626359230034, + "version": "2021.3.0" + }, + "tbb4py-2021.3.0-py38hd09550d_0.conda": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "tbb >=2021.3.0" + ], + "license": "Apache 2.0", + "md5": "03cd1c92950ccd2bfaad762be790f256", + "name": "tbb4py", + "sha256": "5f4b400607b448b1410a589585c32dec58114ae21f3c33ad642bd4879da62d04", + "size": 84336, + "subdir": "linux-64", + "timestamp": 1626359275676, + "version": "2021.3.0" + }, + "tbb4py-2021.3.0-py39hd09550d_0.conda": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "tbb >=2021.3.0" + ], + "license": "Apache 2.0", + "md5": "a243395506ea174b64f64adf68c601ec", + "name": "tbb4py", + "sha256": "6da3aa70c4953dcf359d9f7edd1c2719206d2b841785fae7f4415ace006bf442", + "size": 84170, + "subdir": "linux-64", + "timestamp": 1626359252778, + "version": "2021.3.0" + }, + "tbb4py-2021.4.0-py37hd09550d_0.conda": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "tbb >=2021.4.0" + ], + "license": "Apache 2.0", + "md5": "8bc189e291e2276036e064944f679d23", + "name": "tbb4py", + "sha256": "3515c9bf58c90bba9d3581deaca3fdc59161c67b4b8b0dcd574f174c074f6f39", + "size": 84534, + "subdir": "linux-64", + "timestamp": 1634724068955, + "version": "2021.4.0" + }, + "tbb4py-2021.4.0-py38hd09550d_0.conda": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "tbb >=2021.4.0" + ], + "license": "Apache 2.0", + "md5": "d3ec82212daf3b7c10357bf0a1299c17", + "name": "tbb4py", + "sha256": "120e88c55feee362a00c4605185086bdf0ac59b618b9f492a2fbaf35fc30cda9", + "size": 84828, + "subdir": "linux-64", + "timestamp": 1634724094301, + "version": "2021.4.0" + }, + "tbb4py-2021.4.0-py39hd09550d_0.conda": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "tbb >=2021.4.0" + ], + "license": "Apache 2.0", + "md5": "ff3f6d4e2fb41d25a57f7cbcbb526c24", + "name": "tbb4py", + "sha256": "f45100fe916101e0c2aa2a16e368c282dbdf455070974bf5d55ca37809d78a23", + "size": 84636, + "subdir": "linux-64", + "timestamp": 1634724119775, + "version": "2021.4.0" + }, + "tbb4py-2021.5.0-py310hd09550d_0.conda": { + "build": "py310hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "tbb >=2021.5.0" + ], + "license": "Apache 2.0", + "md5": "99813a1fe7be0f2243ed546463650f03", + "name": "tbb4py", + "sha256": "9ad8108d42013932a369f940a58b2e4fe7bea0ab46fef51f4bf99ea40a10e54f", + "size": 306078, + "subdir": "linux-64", + "timestamp": 1641834026726, + "version": "2021.5.0" + }, + "tbb4py-2021.5.0-py37hd09550d_0.conda": { + "build": "py37hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "tbb >=2021.5.0" + ], + "license": "Apache-2.0", + "md5": "221e8bc6d8e08d66b729192f64746e01", + "name": "tbb4py", + "sha256": "6c4cc805db33954238ec9799f0139e727736d4ff16df42edffb3bdd02d691f3b", + "size": 215008, + "subdir": "linux-64", + "timestamp": 1642690137520, + "version": "2021.5.0" + }, + "tbb4py-2021.5.0-py38hd09550d_0.conda": { + "build": "py38hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "tbb >=2021.5.0" + ], + "license": "Apache-2.0", + "md5": "3490b0e2ddabe87fb3746fba17982207", + "name": "tbb4py", + "sha256": "66d83fdf47690e542bde220fb0a48f975495d0a80606eba2e9f0ba738bf59110", + "size": 215310, + "subdir": "linux-64", + "timestamp": 1642690166624, + "version": "2021.5.0" + }, + "tbb4py-2021.5.0-py39hd09550d_0.conda": { + "build": "py39hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "tbb >=2021.5.0" + ], + "license": "Apache-2.0", + "md5": "3f55b8705c7aa327fa1cead82a5659a8", + "name": "tbb4py", + "sha256": "29d9e1698e6f4f30cbb22ae2ed3ed410091ca4b358950d695e40c754c00a207b", + "size": 215112, + "subdir": "linux-64", + "timestamp": 1642690196110, + "version": "2021.5.0" + }, + "tbb4py-2021.6.0-py310hdb19cb5_0.conda": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "tbb >=2021.6.0" + ], + "license": "Apache-2.0", + "md5": "45bd388f7e0c333237d925d65a0f5b57", + "name": "tbb4py", + "sha256": "1a0bd81e990577951467f975185c39d5befe7bbccf4092d197e423e23242d4cd", + "size": 346096, + "subdir": "linux-64", + "timestamp": 1664812999990, + "version": "2021.6.0" + }, + "tbb4py-2021.6.0-py310hdb19cb5_1.conda": { + "build": "py310hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "tbb >=2021.6.0" + ], + "license": "Apache-2.0", + "md5": "ad4967d10f4e38034eee9646a3eae277", + "name": "tbb4py", + "sha256": "68df64f8411a2dd26d1b9fbe21159f7e4af24af94d9d0eb131a73fcc68c9f4f6", + "size": 238888, + "subdir": "linux-64", + "timestamp": 1673966619683, + "version": "2021.6.0" + }, + "tbb4py-2021.6.0-py311hdb19cb5_1.conda": { + "build": "py311hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "tbb >=2021.6.0" + ], + "license": "Apache-2.0", + "md5": "0b3d7d72438c46488b25b3b649bb2943", + "name": "tbb4py", + "sha256": "9f545d137d74c9bdf3a7e1e9ae1fdb8b6ffb7e635d88b1833eec1f61d68849eb", + "size": 223079, + "subdir": "linux-64", + "timestamp": 1676862929281, + "version": "2021.6.0" + }, + "tbb4py-2021.6.0-py37hdb19cb5_0.conda": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "tbb >=2021.6.0" + ], + "license": "Apache-2.0", + "md5": "b1c5f5137bafe2dc4897642883ebf5ae", + "name": "tbb4py", + "sha256": "d110c0e2f3e6fc26f41140c7bf77cc65518ca7757d1969a9a2498482f5c25d17", + "size": 218473, + "subdir": "linux-64", + "timestamp": 1664813031916, + "version": "2021.6.0" + }, + "tbb4py-2021.6.0-py37hdb19cb5_1.conda": { + "build": "py37hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "tbb >=2021.6.0" + ], + "license": "Apache-2.0", + "md5": "f185054e84b96e9bc67b0a0a2f60aa85", + "name": "tbb4py", + "sha256": "9139908e532b19462c3e69ace27ed937906d14fd633c342dc1296596029c5014", + "size": 238783, + "subdir": "linux-64", + "timestamp": 1673966652500, + "version": "2021.6.0" + }, + "tbb4py-2021.6.0-py38hdb19cb5_0.conda": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "tbb >=2021.6.0" + ], + "license": "Apache-2.0", + "md5": "1e15682284a786e54afa219930dde70a", + "name": "tbb4py", + "sha256": "7821fe6fda31a06fb46dd6664f711166e5d7f4ae4be2cfd4a1fc67b4533a1542", + "size": 218041, + "subdir": "linux-64", + "timestamp": 1664813099047, + "version": "2021.6.0" + }, + "tbb4py-2021.6.0-py38hdb19cb5_1.conda": { + "build": "py38hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "tbb >=2021.6.0" + ], + "license": "Apache-2.0", + "md5": "b53df2a31f83b4733ace2cb779ac00c6", + "name": "tbb4py", + "sha256": "f7eae9209a2b8b16e24e64eba56fefb68f91fa1218f2f620f20fd8e5e3a6990b", + "size": 238891, + "subdir": "linux-64", + "timestamp": 1673966684724, + "version": "2021.6.0" + }, + "tbb4py-2021.6.0-py39hdb19cb5_0.conda": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "tbb >=2021.6.0" + ], + "license": "Apache-2.0", + "md5": "9af34eabb5f4892c565cfab5ab0af080", + "name": "tbb4py", + "sha256": "de64fb5e21c62825bca201a85265ebffbb127d4e0c64c43130144d16d598759f", + "size": 218260, + "subdir": "linux-64", + "timestamp": 1664813067044, + "version": "2021.6.0" + }, + "tbb4py-2021.6.0-py39hdb19cb5_1.conda": { + "build": "py39hdb19cb5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "tbb >=2021.6.0" + ], + "license": "Apache-2.0", + "md5": "6c48fb5235cf4d70b2f04f9a079c2003", + "name": "tbb4py", + "sha256": "d6e6e4ec22ff0744fa2d242deb4e9d016a0f93ec345fb0676dccc433a7ca9b3e", + "size": 238674, + "subdir": "linux-64", + "timestamp": 1673966719236, + "version": "2021.6.0" + }, + "tbb4py-2021.7.0-py310hdb19cb5_0.conda": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "tbb >=2021.7.0" + ], + "license": "Apache-2.0", + "md5": "ceb9556ac13ba5700d0be94706d57af4", + "name": "tbb4py", + "sha256": "837d2f08eae585b04faae0d003f5a9e926c631fd8e006e2d4bc3d16d77d5864e", + "size": 239488, + "subdir": "linux-64", + "timestamp": 1676908801557, + "version": "2021.7.0" + }, + "tbb4py-2021.7.0-py37hdb19cb5_0.conda": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "tbb >=2021.7.0" + ], + "license": "Apache-2.0", + "md5": "bf872092e2c4e08d0c47830c38754276", + "name": "tbb4py", + "sha256": "4aaabe50a98b51293135b732acdee8c0e099e2da4ae593452097ef2320b3750f", + "size": 239145, + "subdir": "linux-64", + "timestamp": 1676908736014, + "version": "2021.7.0" + }, + "tbb4py-2021.7.0-py38hdb19cb5_0.conda": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "tbb >=2021.7.0" + ], + "license": "Apache-2.0", + "md5": "169dd1755adf9a8e3855a667fa4e80b2", + "name": "tbb4py", + "sha256": "eccb2b3b67b43cec3fae6613de079166ac0c9f3e93b7effbedee11878181b7d0", + "size": 239407, + "subdir": "linux-64", + "timestamp": 1676908768469, + "version": "2021.7.0" + }, + "tbb4py-2021.7.0-py39hdb19cb5_0.conda": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "tbb >=2021.7.0" + ], + "license": "Apache-2.0", + "md5": "aaf14ba9ef50a742931f112b7001ce93", + "name": "tbb4py", + "sha256": "7b1f08ba9e7f549f9d0495e5bf72d665bc155fa87bb5127c4f88a0f3eb0ac0f1", + "size": 239238, + "subdir": "linux-64", + "timestamp": 1676908703243, + "version": "2021.7.0" + }, + "tbb4py-2021.8.0-py310hdb19cb5_0.conda": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "tbb >=2021.8.0" + ], + "license": "Apache-2.0", + "md5": "3290603ad3da00bcc57da6e982d0e367", + "name": "tbb4py", + "sha256": "b0f997ef50ba2c3367f5374c604cbb43ebf9e94b878f58d5cbe096e284d42b2e", + "size": 238488, + "subdir": "linux-64", + "timestamp": 1680167321362, + "version": "2021.8.0" + }, + "tbb4py-2021.8.0-py311hdb19cb5_0.conda": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "tbb >=2021.8.0" + ], + "license": "Apache-2.0", + "md5": "96ef2a2bed38643c7f9b09423389cb1d", + "name": "tbb4py", + "sha256": "ad29c14bf37ac19ba6208ed778b2c398f09413cd03cb40d3d1372090cdef6be1", + "size": 247686, + "subdir": "linux-64", + "timestamp": 1680167352437, + "version": "2021.8.0" + }, + "tbb4py-2021.8.0-py38hdb19cb5_0.conda": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "tbb >=2021.8.0" + ], + "license": "Apache-2.0", + "md5": "9b67c326274f3811e466522f147b8168", + "name": "tbb4py", + "sha256": "f75d76cf4112abfd18f7b750416cb104d695089a82de3e1936c7a266c9225429", + "size": 238411, + "subdir": "linux-64", + "timestamp": 1680167414694, + "version": "2021.8.0" + }, + "tbb4py-2021.8.0-py39hdb19cb5_0.conda": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "tbb >=2021.8.0" + ], + "license": "Apache-2.0", + "md5": "438462d83e58b35179b3f54589d2245c", + "name": "tbb4py", + "sha256": "a67c6f91a1f435e2814f774a662754b6f929aedd5595ba917929c68e25e8b7ba", + "size": 238201, + "subdir": "linux-64", + "timestamp": 1680167383598, + "version": "2021.8.0" + }, + "tblib-1.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a14ccd4416818cb78a12ed4ad550f80f", + "name": "tblib", + "sha256": "dc79b60a5085f4ef15ae3c9f86dc483d623968798420ec1e42ebc83966ebb10d", + "size": 16621, + "subdir": "linux-64", + "timestamp": 1530741307256, + "version": "1.3.2" + }, + "tblib-1.3.2-py27h51fe5ba_0.conda": { + "build": "py27h51fe5ba_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "05e4673115675943027a25e6b602a4be", + "name": "tblib", + "sha256": "1233ec0d54942890d57b480d33fc8eb1684985b6d2786720ca08a52bc26880ad", + "size": 16388, + "subdir": "linux-64", + "timestamp": 1505733062312, + "version": "1.3.2" + }, + "tblib-1.3.2-py35hf1eb0b4_0.conda": { + "build": "py35hf1eb0b4_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "97cfec79d3436e8acc49162a6f8eced8", + "name": "tblib", + "sha256": "376467cccd0ee25d16268457ebb4f283d53afa3529e4cd709ca05809907166fc", + "size": 16752, + "subdir": "linux-64", + "timestamp": 1505733073838, + "version": "1.3.2" + }, + "tblib-1.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3ca019bea28cf3851242d9936dcb7e37", + "name": "tblib", + "sha256": "711e26aae7d1bba86e89a471cc37e62e02f2f01de86ebed1ae448b18b7696bfb", + "size": 16728, + "subdir": "linux-64", + "timestamp": 1530741286127, + "version": "1.3.2" + }, + "tblib-1.3.2-py36h34cf8b6_0.conda": { + "build": "py36h34cf8b6_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b532512a62ea28b98c5b365ac34c11c3", + "name": "tblib", + "sha256": "6d37d61fa66be13236601bf9027c8a2ca5b72860396e83ffcd85bd79720ccbe6", + "size": 16614, + "subdir": "linux-64", + "timestamp": 1505733085518, + "version": "1.3.2" + }, + "tblib-1.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "2743650146dcae78f89288f843b7eca5", + "name": "tblib", + "sha256": "f4d8b969addb8eb5c0db27241b988a19a893d38ac44cb92f2e1cacb74e80d74d", + "size": 16864, + "subdir": "linux-64", + "timestamp": 1530741328742, + "version": "1.3.2" + }, + "tempita-0.5.3dev-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "34675d7893bba04e2f2a72300f2f9454", + "name": "tempita", + "sha256": "a813ce326edcb68a5f7895ea69cdc47141e360b60c3ff3a10433a7afcb04f300", + "size": 28262, + "subdir": "linux-64", + "timestamp": 1537812823319, + "version": "0.5.3dev" + }, + "tempita-0.5.3dev-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "079f0e9b7feb271915159ded903bda30", + "name": "tempita", + "sha256": "a34cfcc4446aa50ac05796b028d92c98bacd81d8ca1e1d79ad271d7d518ee4ac", + "size": 28638, + "subdir": "linux-64", + "timestamp": 1641402768846, + "version": "0.5.3dev" + }, + "tempita-0.5.3dev-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "a223cca078f42dd7c4923af44a5b6e7e", + "name": "tempita", + "sha256": "5ed148e4cada6bbf06141da8b578b98b954e3cef850ece9f27c692fc0bcae9ff", + "size": 28909, + "subdir": "linux-64", + "timestamp": 1537812874706, + "version": "0.5.3dev" + }, + "tempita-0.5.3dev-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "25ac33d8e7ef20d3c0e80ac2681ca517", + "name": "tempita", + "sha256": "65c4839d2de183f48225370d93c404e46d06b23bbfbf713db8887d127e06a588", + "size": 28483, + "subdir": "linux-64", + "timestamp": 1537812860349, + "version": "0.5.3dev" + }, + "tempita-0.5.3dev-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4e3fe5c77247c10701ec784ec89e2c1e", + "name": "tempita", + "sha256": "4d7bd62cb3a4fabe82fef10fe533142e2d76d2c574fdbd8b278e5d3d583ae205", + "size": 29655, + "subdir": "linux-64", + "timestamp": 1614066113903, + "version": "0.5.3dev" + }, + "tempita-0.5.3dev-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e305cbc69bb8016ae84da82b71d00e83", + "name": "tempita", + "sha256": "2af63ebe6e6d76a0317b27e6cca6459779c9cbcdfa0bacde65d9e937f6efe6fa", + "size": 28515, + "subdir": "linux-64", + "timestamp": 1537812783559, + "version": "0.5.3dev" + }, + "tempita-0.5.3dev-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "b46bf73ff0354a68f7bf616f929ee197", + "name": "tempita", + "sha256": "17e9be5483f10d186361ea726628358e0dba878677c15e98872017f625f77b71", + "size": 29639, + "subdir": "linux-64", + "timestamp": 1614066100912, + "version": "0.5.3dev" + }, + "tempita-0.5.3dev-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "a0860e1b1d7f634489f05befe0fc2463", + "name": "tempita", + "sha256": "0aed2f0210c0f86a768b043f9e12d5538b8d7055e5372da84147a64212c25ece", + "size": 28992, + "subdir": "linux-64", + "timestamp": 1573661840692, + "version": "0.5.3dev" + }, + "tempita-0.5.3dev-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "527ea3f4618c2ea55e63ed628e3b5a55", + "name": "tempita", + "sha256": "767b9b65758fe02e219af858c656ec8db61bdd55132c9fe813d02156f3cfea9c", + "size": 30015, + "subdir": "linux-64", + "timestamp": 1614066093665, + "version": "0.5.3dev" + }, + "tempita-0.5.3dev-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "fd4746a8d2ee13f7476fc8696de0f915", + "name": "tempita", + "sha256": "a1e8a3cb07414f8c385c1c96009703665551a83f78df3f83f7bab5de9331731a", + "size": 30016, + "subdir": "linux-64", + "timestamp": 1614065198366, + "version": "0.5.3dev" + }, + "tempora-1.10-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "606c9620c1757632e7ec05c5d3befa05", + "name": "tempora", + "sha256": "3fa37e76e63ad184433aa74d2fcddd5f75ef642b91784cd3c23cfa895255053b", + "size": 22411, + "subdir": "linux-64", + "timestamp": 1520907794440, + "version": "1.10" + }, + "tempora-1.10-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7828d2de919376024506c773b4c485d2", + "name": "tempora", + "sha256": "fdfe99843acd6840171236ad54a6cffca919d0944c2db31a0cafbf5ba728dc88", + "size": 23244, + "subdir": "linux-64", + "timestamp": 1520907799197, + "version": "1.10" + }, + "tempora-1.10-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b1ec0412603adbba43dce318dd8accd", + "name": "tempora", + "sha256": "32d62c75afa190430f86243bda81beb97f5933f76e8d001145c0efbef0eb639e", + "size": 23031, + "subdir": "linux-64", + "timestamp": 1520907759438, + "version": "1.10" + }, + "tempora-1.11-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3551d73ee077677dfe8b7ad3fd060cfb", + "name": "tempora", + "sha256": "1c2c5c759dfbed9b0804368dca15aa2d697bbe737231f3c0f35c2663a9021718", + "size": 23361, + "subdir": "linux-64", + "timestamp": 1522786937328, + "version": "1.11" + }, + "tempora-1.11-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f7ffe5f221a2eb8de6ca6650408c901", + "name": "tempora", + "sha256": "aaba87b27c5df32ed391eadf48c6c0b36c404da62d1d4c1db82b501c4d0dbc49", + "size": 24192, + "subdir": "linux-64", + "timestamp": 1522786986018, + "version": "1.11" + }, + "tempora-1.11-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4cc3a7965edca34ae48d82241b63af1e", + "name": "tempora", + "sha256": "8c791d9d3fdffb7c3e6c57b8a6a18a8b903f3fa23034123b4e8199345ba822b7", + "size": 23958, + "subdir": "linux-64", + "timestamp": 1522787016738, + "version": "1.11" + }, + "tempora-1.11-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39a827d35986fa7845c1f41cb5ae36df", + "name": "tempora", + "sha256": "5dc28a2403d15b7377daa439e514ae3494fca810f7cff3e542218643ba3d6388", + "size": 23842, + "subdir": "linux-64", + "timestamp": 1530812061671, + "version": "1.11" + }, + "tempora-1.13-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "jaraco.functools >=1.20", + "python >=2.7,<2.8.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4d48b6db0837fd359266dd55b1b9dad", + "name": "tempora", + "sha256": "bdd23b0eb81342df57d26ba2972cec0fa27f6e506efd725254752f743280b10b", + "size": 25646, + "subdir": "linux-64", + "timestamp": 1539723491664, + "version": "1.13" + }, + "tempora-1.13-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "jaraco.functools >=1.20", + "python >=3.6,<3.7.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f774a057c0dfb274e3c6d20cc95edb7", + "name": "tempora", + "sha256": "129531c95634f0b02e81f0d541350a79e957152fe4838d5cba0f64a6e665f62a", + "size": 26033, + "subdir": "linux-64", + "timestamp": 1539723522952, + "version": "1.13" + }, + "tempora-1.13-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "jaraco.functools >=1.20", + "python >=3.7,<3.8.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d18aac5d89da5cd08067e8fcc92f3432", + "name": "tempora", + "sha256": "c2150c22ea950f05c03d06073a800b9191cc9b99da58d18cf6ab433546ce9eeb", + "size": 25736, + "subdir": "linux-64", + "timestamp": 1539723501038, + "version": "1.13" + }, + "tempora-1.14-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jaraco.functools >=1.20", + "python >=2.7,<2.8.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2e40e28ff12015b3c4982f11f722d51", + "name": "tempora", + "sha256": "bdc898f1f2d0b344f5fa948cb99252b159018c32a92a6891d1667a2c8950ca50", + "size": 25370, + "subdir": "linux-64", + "timestamp": 1545231817221, + "version": "1.14" + }, + "tempora-1.14-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jaraco.functools >=1.20", + "python >=3.6,<3.7.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f80eaf6f144094ed61452fd31192f6b6", + "name": "tempora", + "sha256": "7498b8fab7055e8127626f142eb9cc1ee83dcd24e705cc8c8d0db230e8243498", + "size": 25714, + "subdir": "linux-64", + "timestamp": 1545232217203, + "version": "1.14" + }, + "tempora-1.14-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jaraco.functools >=1.20", + "python >=3.7,<3.8.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d0b5f2781ea97e2c08b14e69e1304650", + "name": "tempora", + "sha256": "4d65e7bcee5b246602e97c6a7526e5c22e9cffdf270519f54c65d309adfe958e", + "size": 26005, + "subdir": "linux-64", + "timestamp": 1545232206748, + "version": "1.14" + }, + "tempora-1.9-py27hd65d453_0.conda": { + "build": "py27hd65d453_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d0e8d423c0c4e9aff4cbfc2e3353704", + "name": "tempora", + "sha256": "5e1b522c3d75e5a7f9a9d11af10109c4cf2f15cabd286ac3768e8016a1c90524", + "size": 21900, + "subdir": "linux-64", + "timestamp": 1507584184984, + "version": "1.9" + }, + "tempora-1.9-py35h731c0ba_0.conda": { + "build": "py35h731c0ba_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "086dbeb61c9cf0bf3126f37da7228fea", + "name": "tempora", + "sha256": "bd941ef26c3715e0637de3e62d87cbc4b5ff907bf171155a3bbed67a7cae776d", + "size": 22127, + "subdir": "linux-64", + "timestamp": 1507584187355, + "version": "1.9" + }, + "tempora-1.9-py36h3630c69_0.conda": { + "build": "py36h3630c69_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz", + "six" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "857b0dd5ae75a24df71e79d56b608efb", + "name": "tempora", + "sha256": "cca85c052a77e4dd95702cf37bee930cd5f3f5480c2c1a69daff15cc25c4e9cb", + "size": 22178, + "subdir": "linux-64", + "timestamp": 1507584187302, + "version": "1.9" + }, + "tenacity-4.12.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3", + "monotonic >=0.6", + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "e5a7e5f3c7b781b90a9ccef8d8daf9d2", + "name": "tenacity", + "sha256": "e6ce9ae010b21a60a0fecbd7a632e00dc710dc29c8b9493ed09413b325cde308", + "size": 44662, + "subdir": "linux-64", + "timestamp": 1579635965559, + "version": "4.12.0" + }, + "tenacity-4.12.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "ea6a87b2e554f7e0864b025dc8708b45", + "name": "tenacity", + "sha256": "f68d996afa3befeaf59018abdbfa6ece9e5bafa771ab97965f622e032bc356d2", + "size": 47371, + "subdir": "linux-64", + "timestamp": 1579635964604, + "version": "4.12.0" + }, + "tenacity-4.12.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "f965c6e539add864d438ec07816cd701", + "name": "tenacity", + "sha256": "fd41fca40b933215abdca30335f8d5ad34b8e4ffdf771aaa34a49eeec7123718", + "size": 47313, + "subdir": "linux-64", + "timestamp": 1579635973565, + "version": "4.12.0" + }, + "tenacity-4.12.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "e65c033c7f2ce3881a540e49e5f04618", + "name": "tenacity", + "sha256": "4dbac417d8c69f97d98be5d9d2b7fe7eb6e9ba30c84e858a6c15baecbb4cebab", + "size": 46850, + "subdir": "linux-64", + "timestamp": 1579635973302, + "version": "4.12.0" + }, + "tenacity-6.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "futures >=3", + "monotonic >=0.6", + "python >=2.7,<2.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "603782bd4f96c91808a6c3f4a0e72440", + "name": "tenacity", + "sha256": "56102bfeca0942c61903a2df63cdd4a07adf73c352e1a8d02e7c24762ae28870", + "size": 37578, + "subdir": "linux-64", + "timestamp": 1576535711758, + "version": "6.0.0" + }, + "tenacity-6.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "2dfc3d772293919587ab60d8a0b682ce", + "name": "tenacity", + "sha256": "ae16ea0c9716c4129fe30858bdbb23b3222900e36ba8a8294b860448ec459469", + "size": 38722, + "subdir": "linux-64", + "timestamp": 1576535700782, + "version": "6.0.0" + }, + "tenacity-6.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "e40e88032e1461479817f82b091ff5c5", + "name": "tenacity", + "sha256": "aef15d38cc29dbb8c783af719f1a3eaa70214e0c06e5a27210755d9d7ad7dc79", + "size": 39022, + "subdir": "linux-64", + "timestamp": 1576535677600, + "version": "6.0.0" + }, + "tenacity-6.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "c1d34eb6cfcf4e505b4a5e14d7743692", + "name": "tenacity", + "sha256": "d973271564f6dc24f1e555b687948e88a87b0f9159af155c5194cb53c90ab674", + "size": 39192, + "subdir": "linux-64", + "timestamp": 1576535730582, + "version": "6.0.0" + }, + "tenacity-6.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "e2b5f9a7b9a3310a98c88bbc91aa4f54", + "name": "tenacity", + "sha256": "f9cf0c63650c365e5e0550433a3a7bab32581a1c2a7c01021d6e77f1ca1e4718", + "size": 38961, + "subdir": "linux-64", + "timestamp": 1597706171654, + "version": "6.1.0" + }, + "tenacity-6.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "66e4d7ec51a60a8b2867bd2e26c85ad1", + "name": "tenacity", + "sha256": "34559cb272ed638bc6b46d1d413d2af16c30e532c6cd7241caa01093a56e1454", + "size": 39468, + "subdir": "linux-64", + "timestamp": 1597706188024, + "version": "6.1.0" + }, + "tenacity-6.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "7022176114fdbbc5ed7db897cf467ebf", + "name": "tenacity", + "sha256": "08b03e4d873a8bb6a4cfbf106249ffd705ba220c6d83df7e8d2fc8865dc181c1", + "size": 39522, + "subdir": "linux-64", + "timestamp": 1597706194748, + "version": "6.1.0" + }, + "tenacity-6.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "1755a673296f1cf0834819ecbf7bcb7c", + "name": "tenacity", + "sha256": "4d814b6c2a10e3216aebe78dbcffc88c8cc7c52bf65debec5889d9acf8fbc96f", + "size": 40008, + "subdir": "linux-64", + "timestamp": 1597706726857, + "version": "6.2.0" + }, + "tenacity-6.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "e5a8af970f391f432c96b1480f535c43", + "name": "tenacity", + "sha256": "47d6dd01a1cff52af31804bbfffb4341fd8676c75d00d120cc66d9709e78ea7f", + "size": 40072, + "subdir": "linux-64", + "timestamp": 1597706734992, + "version": "6.2.0" + }, + "tenacity-6.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "e6ec58052375bb6c9092760cefd66740", + "name": "tenacity", + "sha256": "9840735b73a1dfefb01ec8bb614b25d58767dc1b283d6b1550034986b11d3b7d", + "size": 40828, + "subdir": "linux-64", + "timestamp": 1597706748033, + "version": "6.2.0" + }, + "tenacity-6.3.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "c0f4f3463f36304dcf184ce6b1db1117", + "name": "tenacity", + "sha256": "6914fd5f58ae0e4d947aed5db48e634d23ab5f652c617bcc0e82074bfe295198", + "size": 37133, + "subdir": "linux-64", + "timestamp": 1608058901554, + "version": "6.3.0" + }, + "tenacity-6.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "ef276eccf8de07b5af96f35fda6977ed", + "name": "tenacity", + "sha256": "93cf13ea6d563e4dcce4796e03e22104bdda2523cbb007c051135882d9ecf842", + "size": 37055, + "subdir": "linux-64", + "timestamp": 1608058835559, + "version": "6.3.0" + }, + "tenacity-6.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "ab24594ed63dd3601c0d1017c6ead69b", + "name": "tenacity", + "sha256": "4a2e7543e930a5dc1b38aefd06b16c8edaf0b9dcd554a51f1b4ff15b2de108c9", + "size": 37656, + "subdir": "linux-64", + "timestamp": 1608058891588, + "version": "6.3.0" + }, + "tenacity-6.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "1e277e14e6415fc96bb7b307617540d5", + "name": "tenacity", + "sha256": "6c10589467969080d8bf3aade8ff079ba7c70b7a4c9605d3682a6539fbd772c4", + "size": 37474, + "subdir": "linux-64", + "timestamp": 1608058889840, + "version": "6.3.0" + }, + "tenacity-6.3.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "acf1aee0004cd09cdb6c977793fbf3f9", + "name": "tenacity", + "sha256": "3e269bd605c75d96865ce0f0d9f197a109e1eebae1f4f6ac60c55f7da37c9941", + "size": 36968, + "subdir": "linux-64", + "timestamp": 1608241858736, + "version": "6.3.1" + }, + "tenacity-6.3.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "6b1bf2bc6df987e0fd4a21c7edd2fa8f", + "name": "tenacity", + "sha256": "febd076f38d13e46bd040780ee3a466128b0014669322b031619ffd5728df866", + "size": 36861, + "subdir": "linux-64", + "timestamp": 1608241858819, + "version": "6.3.1" + }, + "tenacity-6.3.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "b20ea2e033544201d453565d7d916f74", + "name": "tenacity", + "sha256": "5f85150334e09bf8fc672374b5145c07a10c382f82cfedd0666f2fa773fc4412", + "size": 37436, + "subdir": "linux-64", + "timestamp": 1608241856685, + "version": "6.3.1" + }, + "tenacity-6.3.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "525de11c2691231d1e9e7f47229778f5", + "name": "tenacity", + "sha256": "bb31ae59373a00dc94aa1f409fbf090a8230a4707c75c91683cb666215210b05", + "size": 37116, + "subdir": "linux-64", + "timestamp": 1608241837906, + "version": "6.3.1" + }, + "tenacity-7.0.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "1c3780fa9dc386436e17bc5e8e515309", + "name": "tenacity", + "sha256": "f3cda395a37032b0df1d8b22535508ea157cf1d18380e4b675e787406a68797b", + "size": 33180, + "subdir": "linux-64", + "timestamp": 1614798153065, + "version": "7.0.0" + }, + "tenacity-7.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "a3dd3ab731203b1a89b30ab2e0871ec8", + "name": "tenacity", + "sha256": "e5dea80886ed4b91d7bddc1da104153b135edf7f6c7d165360fb69b5a10a6dc7", + "size": 32964, + "subdir": "linux-64", + "timestamp": 1614799429382, + "version": "7.0.0" + }, + "tenacity-7.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "8c1a0cbfd4d35d6eecb01e05836779c8", + "name": "tenacity", + "sha256": "e7c47dae1ba144cd703ef46ec74712fcfd4b99c98de563493e337570dbac24cc", + "size": 33098, + "subdir": "linux-64", + "timestamp": 1614799442940, + "version": "7.0.0" + }, + "tenacity-7.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "01795d73688b01336a3f2aa0d25d01be", + "name": "tenacity", + "sha256": "22db41dc236a4e990c90c66e2e558afa89aa1e4689174f2b5094f8d2a0b55f30", + "size": 33213, + "subdir": "linux-64", + "timestamp": 1614799436456, + "version": "7.0.0" + }, + "tenacity-8.0.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "25d12d939c2260a3fcd6b226e38f7172", + "name": "tenacity", + "sha256": "ffc4a76fa39a41d0a1a6623c3b2a154af80e36cbee8dc38ff19fbc4e28f2f8b6", + "size": 32467, + "subdir": "linux-64", + "timestamp": 1625815756144, + "version": "8.0.0" + }, + "tenacity-8.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "4725bea963f29079b3908aff387fe88a", + "name": "tenacity", + "sha256": "74b2c953a267e10de66b31ed514f0ce4044db54de2cdaad9b300c80c534e7727", + "size": 32690, + "subdir": "linux-64", + "timestamp": 1625808884173, + "version": "8.0.0" + }, + "tenacity-8.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.9.0" + ], + "license": "Apache 2.0", + "md5": "a40b298385545374a2a6e5cad46fb499", + "name": "tenacity", + "sha256": "6c85cf69d187ff3bcafc6c103d004a75a232b6b7769441d754ca41e4fdc38fa1", + "size": 33073, + "subdir": "linux-64", + "timestamp": 1625815736217, + "version": "8.0.0" + }, + "tenacity-8.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "50468e0b068374dbd5da0f60549dbe7a", + "name": "tenacity", + "sha256": "080a576e69a68975aac83926e06a0e51a2a13774ba302e55903b5ff32fbcb286", + "size": 32969, + "subdir": "linux-64", + "timestamp": 1625852859837, + "version": "8.0.0" + }, + "tenacity-8.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9d9c8f49adce47293852b845615e93b6", + "name": "tenacity", + "sha256": "789ae3b8973fee97add5386d6824998a650f60e0057f5c6fdb88e3882c8f68c5", + "size": 34795, + "subdir": "linux-64", + "timestamp": 1642511113490, + "version": "8.0.1" + }, + "tenacity-8.0.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cbd68d00fa1c58bb093bdfdac73ce1a3", + "name": "tenacity", + "sha256": "21e290eda7a4d97c68264f1bf473747571a524eecdd10ff2ea4c47e50037d2d8", + "size": 35629, + "subdir": "linux-64", + "timestamp": 1657899336613, + "version": "8.0.1" + }, + "tenacity-8.0.1-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b07ddb661993b1c65e9ec65e849b86f1", + "name": "tenacity", + "sha256": "6dcbfa8cb5f86a8edf913f5d869877debfce541a414e1177a66d58831d4a97eb", + "size": 43651, + "subdir": "linux-64", + "timestamp": 1676838858272, + "version": "8.0.1" + }, + "tenacity-8.0.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c9703b47c3d7512ec69b42265574dff1", + "name": "tenacity", + "sha256": "b262a1a758d77f85f61208bfd6ac493960c912f7ca207cd156e49982308dce65", + "size": 38615, + "subdir": "linux-64", + "timestamp": 1632756984487, + "version": "8.0.1" + }, + "tenacity-8.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7e2236026b094a635dd626e8335a6d72", + "name": "tenacity", + "sha256": "efd9f01990843e02a8344134d4ff2ebcce6f9c930f15272a20ddffb1b2083f9c", + "size": 38563, + "subdir": "linux-64", + "timestamp": 1632746537969, + "version": "8.0.1" + }, + "tenacity-8.0.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d10d38eda7969473131e8529956913a2", + "name": "tenacity", + "sha256": "eba0e959e651984f21a69f749535f41cb7289f69ac83db5707e5e826c960a175", + "size": 34778, + "subdir": "linux-64", + "timestamp": 1657899401204, + "version": "8.0.1" + }, + "tenacity-8.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fd86e8571245fb07a000cf4a44be4dd7", + "name": "tenacity", + "sha256": "772f0b86e7399439623c63d70525d74b968f441be64a70c7c8a20636cab5addd", + "size": 38972, + "subdir": "linux-64", + "timestamp": 1632756908622, + "version": "8.0.1" + }, + "tenacity-8.0.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bdb99db35e34e7b11216393f0d02f5c2", + "name": "tenacity", + "sha256": "4016966296f4d448070900e28a0d4d02badb17811652f0bd49d2522a3aed9199", + "size": 35012, + "subdir": "linux-64", + "timestamp": 1657899246361, + "version": "8.0.1" + }, + "tenacity-8.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "37fbfb5d32da693f2fd7660d43d59c83", + "name": "tenacity", + "sha256": "d0a794a14413868b0da38c8bb59b668839350e8aa0725c0d2642ec8610c79915", + "size": 34128, + "subdir": "linux-64", + "timestamp": 1626248339181, + "version": "8.0.1" + }, + "tenacity-8.0.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "74a8ace122cec5c875c185c571617b8f", + "name": "tenacity", + "sha256": "319976e84528460d20fe5fba39f1c2a789e6b72ffd323a62e0018a11822af800", + "size": 35079, + "subdir": "linux-64", + "timestamp": 1657899182480, + "version": "8.0.1" + }, + "tensorboard-1.10.0-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "futures >=3.1.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1c00261260aacc53d329378b7d351f49", + "name": "tensorboard", + "sha256": "51310f1869bf8dfac811a955b56bb2ea9291ea6b267128ec2a3c7618bc172667", + "size": 3380828, + "subdir": "linux-64", + "timestamp": 1534870854005, + "version": "1.10.0" + }, + "tensorboard-1.10.0-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6d213aae870e9a0f7e8f12b58902f144", + "name": "tensorboard", + "sha256": "c178fd60b9d7b2c61f07ba5661da9da386e39c22547c860a32535dcb9c417b1a", + "size": 3387418, + "subdir": "linux-64", + "timestamp": 1534870749762, + "version": "1.10.0" + }, + "tensorboard-1.10.0-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "65333ac6ad41343f693ffbd49a68bbae", + "name": "tensorboard", + "sha256": "98bea214b7197c0321a146159cc5f97a1d3c9c6ec01fb8a6d77933369ce56492", + "size": 3376230, + "subdir": "linux-64", + "timestamp": 1534870642904, + "version": "1.10.0" + }, + "tensorboard-1.11.0-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "futures >=3.1.1", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "22459ce23fe72d6de23c22ed4ffe0251", + "name": "tensorboard", + "sha256": "c2f63acf3e841458aef68a7e0370e2b474936749b706106e409914d23e78b774", + "size": 3130452, + "subdir": "linux-64", + "timestamp": 1538591921574, + "version": "1.11.0" + }, + "tensorboard-1.11.0-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ef88d2683381ac3eb3a11b37a8a077d2", + "name": "tensorboard", + "sha256": "ed4ecc5c8ea15df14d3bf9c2b11aba98ed5dc8106ba26446998dbfadd621c9bd", + "size": 3132690, + "subdir": "linux-64", + "timestamp": 1538592106572, + "version": "1.11.0" + }, + "tensorboard-1.12.0-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "futures >=3.1.1", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c07f2a69037a51533c8d04c3c8d1ff95", + "name": "tensorboard", + "sha256": "24da1edd21957b852a68515207d3c956b533c4c27d8e8a1439ba300a5c7a0f9c", + "size": 3157961, + "subdir": "linux-64", + "timestamp": 1542083527370, + "version": "1.12.0" + }, + "tensorboard-1.12.0-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4db2e8633549532eed06b36ce590c991", + "name": "tensorboard", + "sha256": "ec931d213002a9d546ec407bdc375baee3bc77281cce76060aa985a19a0309e3", + "size": 3152731, + "subdir": "linux-64", + "timestamp": 1542077717358, + "version": "1.12.0" + }, + "tensorboard-1.12.1-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "futures >=3.1.1", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "772e179414a4c2338fbbf20a2e2824ec", + "name": "tensorboard", + "sha256": "699afaf2cc0e9c48583581bca6523c3359243a8c04f77909d5e49842dcb0bf5d", + "size": 3159082, + "subdir": "linux-64", + "timestamp": 1545233805240, + "version": "1.12.1" + }, + "tensorboard-1.12.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a55709445263dd36f90382cd84713383", + "name": "tensorboard", + "sha256": "ab930e11c785984f9265544eec154fd640d0a59e4996e75f0802e837101ac29a", + "size": 3149057, + "subdir": "linux-64", + "timestamp": 1545234027966, + "version": "1.12.1" + }, + "tensorboard-1.12.2-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "futures >=3.1.1", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7f9b2a542cb6d5930a2870b2ed68611d", + "name": "tensorboard", + "sha256": "f4334a7575b50ac5229b449bc8121280d98117a43744d80df6016f969d5fb194", + "size": 3158225, + "subdir": "linux-64", + "timestamp": 1546627351628, + "version": "1.12.2" + }, + "tensorboard-1.12.2-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "62070f1a88eeab59b71c0ba211c15064", + "name": "tensorboard", + "sha256": "0bab687eaf2db720d038277c8a344d989d6526d9fa4b33352eda64c9e7508cb5", + "size": 3156185, + "subdir": "linux-64", + "timestamp": 1546627346054, + "version": "1.12.2" + }, + "tensorboard-1.13.1-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "futures >=3.1.1", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.15" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a32b758b0bd19f590a5cdfac2c975b1d", + "name": "tensorboard", + "sha256": "162454007d1877a7c1daea71d15fa13ff9600bc89afabc3f8e319fc26e30272d", + "size": 3296294, + "subdir": "linux-64", + "timestamp": 1554308771240, + "version": "1.13.1" + }, + "tensorboard-1.13.1-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.15" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fbd63989f15ad82553bab7b981c55fc9", + "name": "tensorboard", + "sha256": "03e7a008eccc8f3cb2716ae73847d761643de234ef09379b631eb9329ad429a8", + "size": 3300033, + "subdir": "linux-64", + "timestamp": 1554308442838, + "version": "1.13.1" + }, + "tensorboard-1.13.1-py37hf484d3e_0.conda": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.15" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "164e8378dd492a81f48ec12be1387fac", + "name": "tensorboard", + "sha256": "e0810ac37f8401acdfb2847860af7339ad39b3f8a7af8db6c6a50bb163a714c6", + "size": 3295341, + "subdir": "linux-64", + "timestamp": 1554309009398, + "version": "1.13.1" + }, + "tensorboard-1.14.0-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "futures >=3.1.1", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.15" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "693b457eeed887a3e2170b4810fbdcea", + "name": "tensorboard", + "sha256": "910f77198084638766da357870fb26c81e521b6b5557eb25ef9320bb96341287", + "size": 3261884, + "subdir": "linux-64", + "timestamp": 1561049602139, + "version": "1.14.0" + }, + "tensorboard-1.14.0-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.15" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2d8902d80a85453f4c5678082b90312b", + "name": "tensorboard", + "sha256": "cd5c6afbcad3c3d878b78d22cd98e6b42dbd57d77bc0b2e82f13aae152d447b1", + "size": 3256293, + "subdir": "linux-64", + "timestamp": 1561049354595, + "version": "1.14.0" + }, + "tensorboard-1.14.0-py37hf484d3e_0.conda": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "grpcio >=1.6.3", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.15" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d5976d9d2ba6240b1637ee4855297acf", + "name": "tensorboard", + "sha256": "fd8676eb6cf419b04f9104ef190ab5eb315fac5f33792553b067772cbfe7154a", + "size": 3249014, + "subdir": "linux-64", + "timestamp": 1561049172295, + "version": "1.14.0" + }, + "tensorboard-1.15.0-py27hb230dea_0.conda": { + "build": "py27hb230dea_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7", + "futures >=3.1.1", + "grpcio >=1.14", + "markdown >=2.6.11", + "numpy >=1.16", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.12", + "webencodings", + "werkzeug >=0.14", + "wheel" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "842db7836a53c755cb9d435780335014", + "name": "tensorboard", + "sha256": "75858fd85fdaf1921ebf26aa5d6cb1294ff344289aa6f76ebb36f803f2fe0b92", + "size": 3769657, + "subdir": "linux-64", + "timestamp": 1573244241989, + "version": "1.15.0" + }, + "tensorboard-1.6.0-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach ==1.5.0", + "futures >=3.1.1", + "html5lib ==0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5ca3104dc460b8ddd29058b8c2f7e1aa", + "name": "tensorboard", + "sha256": "f9f3019b21c2da83d7bc7cce7dbdd185ca5d64437ca290670210a569ff20dafb", + "size": 3029341, + "subdir": "linux-64", + "timestamp": 1521223760452, + "version": "1.6.0" + }, + "tensorboard-1.6.0-py27hf484d3e_1.conda": { + "build": "py27hf484d3e_1", + "build_number": 1, + "depends": [ + "bleach >=1.5.0,<1.5.1.0a0", + "futures", + "html5lib >=0.9999999,<0.10000000.0a0", + "libgcc-ng", + "libstdcxx-ng", + "markdown", + "numpy", + "protobuf", + "python >=2.7,<2.8.0a0", + "six", + "werkzeug" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "08a1cc09533bbaa4e12a34422817b820", + "name": "tensorboard", + "sha256": "5873d893aa55cac5c8d4903b075eb125a3e229a3a465d7c4ea86bcfce0247581", + "size": 3029304, + "subdir": "linux-64", + "timestamp": 1524776946656, + "version": "1.6.0" + }, + "tensorboard-1.6.0-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach ==1.5.0", + "html5lib ==0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7c86b39e60b5747ebc279b649b04930f", + "name": "tensorboard", + "sha256": "d81f4ec7d9fd235791f469624c7bfe03384d3db94b2e60a7acaf03aae2e4202a", + "size": 3029291, + "subdir": "linux-64", + "timestamp": 1521223319065, + "version": "1.6.0" + }, + "tensorboard-1.6.0-py35hf484d3e_1.conda": { + "build": "py35hf484d3e_1", + "build_number": 1, + "depends": [ + "bleach >=1.5.0,<1.5.1.0a0", + "html5lib >=0.9999999,<0.10000000.0a0", + "libgcc-ng", + "libstdcxx-ng", + "markdown", + "numpy", + "protobuf", + "python >=3.5,<3.6.0a0", + "six", + "werkzeug" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "185240d67930a05cc7361dfceedebda1", + "name": "tensorboard", + "sha256": "f67b7f58becd739620fd2fd9d28436e8e0836b5fe3e486a355d35855011ebdbc", + "size": 3033431, + "subdir": "linux-64", + "timestamp": 1524776669122, + "version": "1.6.0" + }, + "tensorboard-1.6.0-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach ==1.5.0", + "html5lib ==0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "38a6079b614214dc312a4420d5a898e9", + "name": "tensorboard", + "sha256": "0d1943a6fffbcba455293eea971a89a3e64fee1d056888a2e4cda3178ad5db8a", + "size": 3031727, + "subdir": "linux-64", + "timestamp": 1521223765060, + "version": "1.6.0" + }, + "tensorboard-1.6.0-py36hf484d3e_1.conda": { + "build": "py36hf484d3e_1", + "build_number": 1, + "depends": [ + "bleach >=1.5.0,<1.5.1.0a0", + "html5lib >=0.9999999,<0.10000000.0a0", + "libgcc-ng", + "libstdcxx-ng", + "markdown", + "numpy", + "protobuf", + "python >=3.6,<3.7.0a0", + "six", + "werkzeug" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "331758fa8012f055dc71afa6608c21b8", + "name": "tensorboard", + "sha256": "9d3aed5079b012c6de9c0bc7e8684f0e8c57e223723e3bd7ec3eb38d636a96fa", + "size": 3031599, + "subdir": "linux-64", + "timestamp": 1524776804562, + "version": "1.6.0" + }, + "tensorboard-1.7.0-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach ==1.5.0", + "futures >=3.1.1", + "html5lib ==0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ac072e09a9557a314a46ecae0635c934", + "name": "tensorboard", + "sha256": "ecb87a40c6a707b0058acf942e8fd8d11331ce079cc362c0258aebbc9f9a5d46", + "size": 3090243, + "subdir": "linux-64", + "timestamp": 1524276809302, + "version": "1.7.0" + }, + "tensorboard-1.7.0-py27hf484d3e_1.conda": { + "build": "py27hf484d3e_1", + "build_number": 1, + "depends": [ + "bleach >=1.5.0,<1.5.1.0a0", + "futures", + "html5lib >=0.9999999,<0.10000000.0a0", + "libgcc-ng", + "libstdcxx-ng", + "markdown", + "numpy", + "protobuf", + "python >=2.7,<2.8.0a0", + "six", + "werkzeug" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9b401ed983d873d25789571ac4abc0bf", + "name": "tensorboard", + "sha256": "48778482cb920337f50fd22927c0f73ec2407a80f6391f0f15fc5e3727e87502", + "size": 3090236, + "subdir": "linux-64", + "timestamp": 1524771746239, + "version": "1.7.0" + }, + "tensorboard-1.7.0-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach ==1.5.0", + "html5lib ==0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4d0139ce7a5cebfccb8abe76d756ab18", + "name": "tensorboard", + "sha256": "9394a13c6e4e6af40d499ad24c7c74b5729ae2d3d5095259b0183d8ca4dc0bc7", + "size": 3093991, + "subdir": "linux-64", + "timestamp": 1524276815441, + "version": "1.7.0" + }, + "tensorboard-1.7.0-py35hf484d3e_1.conda": { + "build": "py35hf484d3e_1", + "build_number": 1, + "depends": [ + "bleach >=1.5.0,<1.5.1.0a0", + "html5lib >=0.9999999,<0.10000000.0a0", + "libgcc-ng", + "libstdcxx-ng", + "markdown", + "numpy", + "protobuf", + "python >=3.5,<3.6.0a0", + "six", + "werkzeug" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "602d7577c1e2f3ac8b0abae986e14863", + "name": "tensorboard", + "sha256": "609ef3e854d4cf66c8e8202954bcc1f36cdaf096a2cae8e8b6f7d397c3b849d3", + "size": 3093837, + "subdir": "linux-64", + "timestamp": 1524772030165, + "version": "1.7.0" + }, + "tensorboard-1.7.0-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach ==1.5.0", + "html5lib ==0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "905c071f103132754dc8081c396fc6b5", + "name": "tensorboard", + "sha256": "c779f2f9fa924563828b9a3165a0878e500399e292b6366fbd37b403d2faacf5", + "size": 3092005, + "subdir": "linux-64", + "timestamp": 1524276818492, + "version": "1.7.0" + }, + "tensorboard-1.7.0-py36hf484d3e_1.conda": { + "build": "py36hf484d3e_1", + "build_number": 1, + "depends": [ + "bleach >=1.5.0,<1.5.1.0a0", + "html5lib >=0.9999999,<0.10000000.0a0", + "libgcc-ng", + "libstdcxx-ng", + "markdown", + "numpy", + "protobuf", + "python >=3.6,<3.7.0a0", + "six", + "werkzeug" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3e341212be5e7530cdc7a4d42b910755", + "name": "tensorboard", + "sha256": "3597243a90498e5d833b7f47690b1e4ed31964c996252e60d0002ad3617a473f", + "size": 3091864, + "subdir": "linux-64", + "timestamp": 1524772025091, + "version": "1.7.0" + }, + "tensorboard-1.8.0-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach 1.5.0", + "futures >=3.1.1", + "html5lib 0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8f5691f20f0a0468e49dde0b8a18d540", + "name": "tensorboard", + "sha256": "bcee87b3dcc3911aa0e8bdb4a91f11b41dc8b0bdf14fbb14a036edefd823ef72", + "size": 3134564, + "subdir": "linux-64", + "timestamp": 1527062647677, + "version": "1.8.0" + }, + "tensorboard-1.8.0-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach 1.5.0", + "html5lib 0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6472ebdb5f0d0979a8f879ce79b35c29", + "name": "tensorboard", + "sha256": "1601162f1edae4c90a43ebb17381553c5a500930ec7b7e7f68c9e7e76d008ef2", + "size": 3134689, + "subdir": "linux-64", + "timestamp": 1527062619621, + "version": "1.8.0" + }, + "tensorboard-1.8.0-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach 1.5.0", + "html5lib 0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ea04117b2c356287eb941fdb7c8ed2cd", + "name": "tensorboard", + "sha256": "21291a03e79bec2c259bae827a557f5694db4b1063fae9ef84c44e77830db880", + "size": 3138295, + "subdir": "linux-64", + "timestamp": 1527062652926, + "version": "1.8.0" + }, + "tensorboard-1.9.0-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "futures >=3.1.1", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "797826b8a26f26d9b8e05e1afd7458a4", + "name": "tensorboard", + "sha256": "8f82d90b43768982de77b3e298572f2a9f3cb8381c5b3d17cfe8687af36b5a86", + "size": 3365368, + "subdir": "linux-64", + "timestamp": 1532470025905, + "version": "1.9.0" + }, + "tensorboard-1.9.0-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5b602d02e1f7a8b942d9569fd09ab971", + "name": "tensorboard", + "sha256": "228191f3df1e25e293bb1774afb148fea6af43b66572f709e2cfc4f11cc3090f", + "size": 3374994, + "subdir": "linux-64", + "timestamp": 1532470206291, + "version": "1.9.0" + }, + "tensorboard-1.9.0-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "00d04530a50061287d11b42128bd8025", + "name": "tensorboard", + "sha256": "66a8b4d2502d6b1d6463b3fdb467d51d855c5d9ce7370a68f2d7023410fe6fce", + "size": 3361650, + "subdir": "linux-64", + "timestamp": 1532469907181, + "version": "1.9.0" + }, + "tensorboard-2.0.0-py27hb230dea_0.conda": { + "build": "py27hb230dea_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7", + "futures >=3.1.1", + "grpcio >=1.14", + "markdown >=2.6.11", + "numpy >=1.16", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.12", + "webencodings", + "werkzeug >=0.14", + "wheel", + "setuptools >=41.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1a217c8b5c51a8e74ca46920a6b049fc", + "name": "tensorboard", + "sha256": "6629bdc954485e50b1e201b9e663fd6e997546e73681c079c6760623cfdbe8fa", + "size": 3780766, + "subdir": "linux-64", + "timestamp": 1571761524683, + "version": "2.0.0" + }, + "tensorboard-2.0.0-py27hb38c66f_1.conda": { + "build": "py27hb38c66f_1", + "build_number": 1, + "depends": [ + "absl-py >=0.7", + "futures >=3.1.1", + "grpcio >=1.14", + "markdown >=2.6.11", + "numpy >=1.16", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "setuptools >=41.0.0", + "six >=1.12", + "werkzeug >=0.14", + "wheel" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8518986613d6b6b68c97d3b8a7d363bd", + "name": "tensorboard", + "sha256": "cec17ee8954c615ceb653618e74cbdacfce4792f6b0f0eef53f61e2f6075756f", + "size": 3798439, + "subdir": "linux-64", + "timestamp": 1574447706791, + "version": "2.0.0" + }, + "tensorboard-2.10.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.10,<3.11.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "507dba20ab7b54adcb40768a534a9518", + "name": "tensorboard", + "sha256": "07aee0ff065d5a38d35d939398c9d7e9f1d9fe6aec3312496fd4936361dbf1d6", + "size": 5911564, + "subdir": "linux-64", + "timestamp": 1666889931054, + "version": "2.10.0" + }, + "tensorboard-2.10.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e8b3d6e5c0f43ab21c6cd5535d103efa", + "name": "tensorboard", + "sha256": "56503c20e4df0bac94e89014676ed10656018ba97ce82cc3b0679202e1149c58", + "size": 5880450, + "subdir": "linux-64", + "timestamp": 1666889974691, + "version": "2.10.0" + }, + "tensorboard-2.10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.8,<3.9.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "475d0118c76b45181adc7f47928aebfa", + "name": "tensorboard", + "sha256": "107266c3f3c2c2b397385c92829a86ef33485dcdd7d7a501352fbd9bc02be131", + "size": 5896190, + "subdir": "linux-64", + "timestamp": 1666890020213, + "version": "2.10.0" + }, + "tensorboard-2.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.9,<3.10.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4092c43826e35fc5e3f4a4daf54fc96d", + "name": "tensorboard", + "sha256": "db87c2c4c39a5dd95e6c8fcea0b168398ba44324284c58ca1b0856be454d2825", + "size": 5892300, + "subdir": "linux-64", + "timestamp": 1666889884435, + "version": "2.10.0" + }, + "tensorboard-2.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.10,<3.11.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6d3fd2fd3268318ec4b759195d7206b8", + "name": "tensorboard", + "sha256": "44a4b0ce7177fb401d812bbd8d18d4adcfc75200ee8647e23b07049157bcb52c", + "size": 6031438, + "subdir": "linux-64", + "timestamp": 1678126790241, + "version": "2.11.0" + }, + "tensorboard-2.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.8,<3.9.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "89186cc71311093ac4ca5c3b806c3eb2", + "name": "tensorboard", + "sha256": "2cef6332cf577750896c1a471650baa06403b4b673166dadb30ca2ff4bca0a5c", + "size": 6003074, + "subdir": "linux-64", + "timestamp": 1678126721243, + "version": "2.11.0" + }, + "tensorboard-2.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.9,<3.10.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ed358de9d358d582147549d7d365ddde", + "name": "tensorboard", + "sha256": "3c57202beea386733c52f3851363082aab09233b8446ebdd336960b1b6265709", + "size": 6013424, + "subdir": "linux-64", + "timestamp": 1678126757132, + "version": "2.11.0" + }, + "tensorboard-2.8.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.10,<3.11.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=0.11.15", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "023f80725f55fad0196e768cd60fe21b", + "name": "tensorboard", + "sha256": "d2fa485c636b2417e62adf8245084f31a3810492e404b3d952759239b3e655a3", + "size": 5815292, + "subdir": "linux-64", + "timestamp": 1658918319899, + "version": "2.8.0" + }, + "tensorboard-2.8.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=0.11.15", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "72acc8642d10dc82a5dfd71b6c44c1ef", + "name": "tensorboard", + "sha256": "dd49cd1eaa8bb084746422d00470402d66ffebe5c6c81e16c146b7b7b6f93ad0", + "size": 5782359, + "subdir": "linux-64", + "timestamp": 1658918298776, + "version": "2.8.0" + }, + "tensorboard-2.8.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.8,<3.9.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=0.11.15", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c136f38c152c04c9d67b35278a2f11f4", + "name": "tensorboard", + "sha256": "a4f690a33f6912546e8889a5d9b77e243ec32470881285bb62cad3fdd20c173d", + "size": 5788777, + "subdir": "linux-64", + "timestamp": 1658918340715, + "version": "2.8.0" + }, + "tensorboard-2.8.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.9,<3.10.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=0.11.15", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5c3fbd9332982529364dca8d724ca49a", + "name": "tensorboard", + "sha256": "ff902ee273d7b9d324dd6430c751950bb09f38c1516fa182b2b8abca414f8721", + "size": 5788434, + "subdir": "linux-64", + "timestamp": 1658918277667, + "version": "2.8.0" + }, + "tensorboard-2.9.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.10,<3.11.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "97ecc1e1d342a248c6aecb5dbac20aa6", + "name": "tensorboard", + "sha256": "955f68ae84de4bd3ae78b1deacf48e6be06f257443a300a222e311dc24d161b6", + "size": 5832659, + "subdir": "linux-64", + "timestamp": 1661447998434, + "version": "2.9.0" + }, + "tensorboard-2.9.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "062e85629269307f31a6a7b0d9aefc41", + "name": "tensorboard", + "sha256": "27b30bf8bf65dba36666ac2c17a5056e3a832975ace16d6717c92fb249d477f9", + "size": 5788774, + "subdir": "linux-64", + "timestamp": 1661447952699, + "version": "2.9.0" + }, + "tensorboard-2.9.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.8,<3.9.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e920bf6ce56e3d3ba3709752ae0bfd65", + "name": "tensorboard", + "sha256": "134047a7514b93b0395044c12cf52930941dfed6364e62872bb776e6e7864ed8", + "size": 5807561, + "subdir": "linux-64", + "timestamp": 1661447904703, + "version": "2.9.0" + }, + "tensorboard-2.9.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py >=0.4", + "google-auth-oauthlib >=0.4.1,<0.5", + "grpcio >=1.24.3", + "markdown >=2.6.8", + "numpy >=1.12.0", + "protobuf >=3.6.0", + "python >=3.9,<3.10.0a0", + "requests >=2.21.0,<3", + "setuptools >=41.0.0", + "tensorboard-data-server >=0.6.0,<0.7.0", + "tensorboard-plugin-wit >=1.6.0", + "werkzeug >=1.0.1", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4e425a2164fbe4165c12c99661e1f203", + "name": "tensorboard", + "sha256": "02cca393b677cf40f04066f4e2efbbd17f7323f584bfa9835049fe90f1e50007", + "size": 5804059, + "subdir": "linux-64", + "timestamp": 1661447855329, + "version": "2.9.0" + }, + "tensorboard-data-server-0.6.0-py310hca6d32c_0.conda": { + "build": "py310hca6d32c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "dee1b6b2c265bbf4cc5e5c716ee1e9ac", + "name": "tensorboard-data-server", + "sha256": "4b62777f6888d320744121e3be0f8ae1df127198557ebffe4efc4edb9fe60ea7", + "size": 2804754, + "subdir": "linux-64", + "timestamp": 1640795121638, + "version": "0.6.0" + }, + "tensorboard-data-server-0.6.0-py36hca6d32c_0.conda": { + "build": "py36hca6d32c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "b19de08a2b294f18440474356329c9eb", + "name": "tensorboard-data-server", + "sha256": "a0b22f30fd2a07d427f18fc02c7a17f3fc63a7fa2492e14aa4d5e5e86d0329d3", + "size": 2816368, + "subdir": "linux-64", + "timestamp": 1633035275829, + "version": "0.6.0" + }, + "tensorboard-data-server-0.6.0-py37hca6d32c_0.conda": { + "build": "py37hca6d32c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "8969008aef0b2d44515a033b78653819", + "name": "tensorboard-data-server", + "sha256": "1939d036f35bd39742c86e234e889727e84d477c2ee00a654f104ed55273b3c9", + "size": 2813650, + "subdir": "linux-64", + "timestamp": 1633024748442, + "version": "0.6.0" + }, + "tensorboard-data-server-0.6.0-py38hca6d32c_0.conda": { + "build": "py38hca6d32c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "6826296c8a9e4ce4dd02ab20a583f25a", + "name": "tensorboard-data-server", + "sha256": "a824ca87aba8628deb98ec95a4e2ee5f23df9deb8a2032f378eec177baa685c7", + "size": 2816464, + "subdir": "linux-64", + "timestamp": 1633035238452, + "version": "0.6.0" + }, + "tensorboard-data-server-0.6.0-py39hca6d32c_0.conda": { + "build": "py39hca6d32c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "openssl >=1.1.1l,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "d05d62c8d1eaa6ad506528e0c63908e1", + "name": "tensorboard-data-server", + "sha256": "6f3de523072d72a8a04b528d0faf476cbc32a3d93c9ec3cdfb264ce9a8371035", + "size": 2802387, + "subdir": "linux-64", + "timestamp": 1633034947638, + "version": "0.6.0" + }, + "tensorboard-data-server-0.6.1-py310h52d8a92_0.conda": { + "build": "py310h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "265077b7bf0b7fa78e4d5440001e1de3", + "name": "tensorboard-data-server", + "sha256": "ea6b7d1509b18f4da08241652373fcdf1905363bad2a62bc34494dc16565c5a6", + "size": 4093955, + "subdir": "linux-64", + "timestamp": 1670854556169, + "version": "0.6.1" + }, + "tensorboard-data-server-0.6.1-py37h52d8a92_0.conda": { + "build": "py37h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9c9fd1e8f265fd9d8bdd9b579b1d2dcc", + "name": "tensorboard-data-server", + "sha256": "53b40116754f0300e14992183e9ac99c4cfd2b2fb17aef029cf69c84b1a84ec3", + "size": 4093013, + "subdir": "linux-64", + "timestamp": 1670853835552, + "version": "0.6.1" + }, + "tensorboard-data-server-0.6.1-py38h52d8a92_0.conda": { + "build": "py38h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "04e95e4d60bebae3d301d907b5ae90c8", + "name": "tensorboard-data-server", + "sha256": "4b181e478971db9d6a71ecab2fd2007deef30849f11052301ef466fd9eb06a67", + "size": 4092740, + "subdir": "linux-64", + "timestamp": 1670854075242, + "version": "0.6.1" + }, + "tensorboard-data-server-0.6.1-py39h52d8a92_0.conda": { + "build": "py39h52d8a92_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d1bc657c1447e2093fd889bcd439aacb", + "name": "tensorboard-data-server", + "sha256": "b65178eff3bde398518ed42560632f44e2def82bf2057aaf0e39aba501a0ae4f", + "size": 4094143, + "subdir": "linux-64", + "timestamp": 1670854315363, + "version": "0.6.1" + }, + "tensorboard-plugin-wit-1.8.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d37387a0bfb7ca99d2b2e72bf9e8917b", + "name": "tensorboard-plugin-wit", + "sha256": "52f476eb9dfe01463db4fba78d201af2637cfe0d654913c53d1ca8cbfe6c19ce", + "size": 693163, + "subdir": "linux-64", + "timestamp": 1658918566413, + "version": "1.8.1" + }, + "tensorboard-plugin-wit-1.8.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f725d9414c8af41317895f3fd95e228e", + "name": "tensorboard-plugin-wit", + "sha256": "1601095d86d8a9f164359e57e581a2a40a16aa4b4592ca43fbf10069a6507dd9", + "size": 690601, + "subdir": "linux-64", + "timestamp": 1658918549227, + "version": "1.8.1" + }, + "tensorboard-plugin-wit-1.8.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "557bc808ca5354116bfc5bc048f59f84", + "name": "tensorboard-plugin-wit", + "sha256": "b8f1eba9555006904f5160cbb47246fe79db3139037c0d865953acde21442f59", + "size": 691367, + "subdir": "linux-64", + "timestamp": 1658918515390, + "version": "1.8.1" + }, + "tensorboard-plugin-wit-1.8.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "wheel >=0.26" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c52af4638d2f87af08c37839c9e25de1", + "name": "tensorboard-plugin-wit", + "sha256": "43f4d35b44028c31e54d5de0efae9c855dd76aca175fc5e9d6eced00734e3703", + "size": 691290, + "subdir": "linux-64", + "timestamp": 1658918532558, + "version": "1.8.1" + }, + "tensorflow-1.10.0-eigen_py27ha0ab958_0.conda": { + "build": "eigen_py27ha0ab958_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 2.7.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 eigen_py27h4dcebc2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "17770d170b459e092af28f5938773f06", + "name": "tensorflow", + "namespace": "python", + "sha256": "94a015d9099c27bc6bebc421ea88e1fbbbb995fc6182837b482e6cea954dd346", + "size": 4083, + "subdir": "linux-64", + "timestamp": 1534981075689, + "version": "1.10.0" + }, + "tensorflow-1.10.0-eigen_py35h5ed898b_0.conda": { + "build": "eigen_py35h5ed898b_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.5.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 eigen_py35h4dcebc2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "423b0dadbc16fe957c79f49dc9da8564", + "name": "tensorflow", + "namespace": "python", + "sha256": "c0104fd2402a87753031c546cc83fa7759b9e4ac9fd7471db0b608c182d70ff1", + "size": 4088, + "subdir": "linux-64", + "timestamp": 1534981088346, + "version": "1.10.0" + }, + "tensorflow-1.10.0-eigen_py36hb995bb4_0.conda": { + "build": "eigen_py36hb995bb4_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.6.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 eigen_py36h4dcebc2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "65fd22f8744799156eabd3fd895ae5c4", + "name": "tensorflow", + "namespace": "python", + "sha256": "89437a9cffb61fca27419457bc66efc0fd4f22220061f60a57d3eea8dd982a0b", + "size": 4081, + "subdir": "linux-64", + "timestamp": 1534981044542, + "version": "1.10.0" + }, + "tensorflow-1.10.0-gpu_py27h67ad7fe_0.conda": { + "build": "gpu_py27h67ad7fe_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 gpu_py27had579c0_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5b8253d6d7a3c45c7ca95d2fa5868e76", + "name": "tensorflow", + "namespace": "python", + "sha256": "c1d7c51eb2dcb5046311abf73bbd4985b2c1b985bd07e0ecf817675c9d808741", + "size": 3437, + "subdir": "linux-64", + "timestamp": 1534967611358, + "version": "1.10.0" + }, + "tensorflow-1.10.0-gpu_py27h6f941b3_0.conda": { + "build": "gpu_py27h6f941b3_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 gpu_py27h6ecc378_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3225db353762ceb827f9dd56e68a23ed", + "name": "tensorflow", + "namespace": "python", + "sha256": "e08bdc56ae5457c7bf5f8c008e3b546dff4204bc77feaec66dd627f48e93285a", + "size": 3477, + "subdir": "linux-64", + "timestamp": 1534982459611, + "version": "1.10.0" + }, + "tensorflow-1.10.0-gpu_py27h9580370_0.conda": { + "build": "gpu_py27h9580370_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 gpu_py27h3435052_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e768a3c001fb5ad0bbd9261e07577608", + "name": "tensorflow", + "namespace": "python", + "sha256": "c225dcbaccfeaf69aa2f0b9e6d5b62d7985e36ae847a1f55b1afe8d9d044cc9c", + "size": 3325, + "subdir": "linux-64", + "timestamp": 1534981728080, + "version": "1.10.0" + }, + "tensorflow-1.10.0-gpu_py35h566a776_0.conda": { + "build": "gpu_py35h566a776_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.5.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 gpu_py35h6ecc378_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f3d458c3f220532461b1b64f3bfb565b", + "name": "tensorflow", + "namespace": "python", + "sha256": "bf60c3b5e36eacbd208317925e89b3c5f2d73aff6cb6d332efbd606f23b1b9f0", + "size": 3471, + "subdir": "linux-64", + "timestamp": 1534982229867, + "version": "1.10.0" + }, + "tensorflow-1.10.0-gpu_py35ha6119f3_0.conda": { + "build": "gpu_py35ha6119f3_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.5.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 gpu_py35h3435052_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c7610ce6d8b74cd7e5f7e56775afe316", + "name": "tensorflow", + "namespace": "python", + "sha256": "48c2ef5c6a9837715e6b3a0e20663bf592e88bd74823506b0792c17b2a7951c6", + "size": 3329, + "subdir": "linux-64", + "timestamp": 1534981776295, + "version": "1.10.0" + }, + "tensorflow-1.10.0-gpu_py35hd9c640d_0.conda": { + "build": "gpu_py35hd9c640d_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.5.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 gpu_py35had579c0_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e3adafb12f421f80e31b6c792d65c7ab", + "name": "tensorflow", + "namespace": "python", + "sha256": "ad3f671d410d5d8c8fccb4a6309e5ddfed81e496be6f53c20cb4bd029863f5e4", + "size": 3423, + "subdir": "linux-64", + "timestamp": 1534967634500, + "version": "1.10.0" + }, + "tensorflow-1.10.0-gpu_py36h8dbd23f_0.conda": { + "build": "gpu_py36h8dbd23f_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 gpu_py36h3435052_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a5613e6e025b89095a385b9a0d044a1f", + "name": "tensorflow", + "namespace": "python", + "sha256": "698d1221d75b0db7a230f7b83607a41540c428b374bdbc7fcf8575b19632443d", + "size": 3322, + "subdir": "linux-64", + "timestamp": 1534981800216, + "version": "1.10.0" + }, + "tensorflow-1.10.0-gpu_py36h97a2126_0.conda": { + "build": "gpu_py36h97a2126_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 gpu_py36h6ecc378_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7a95d7b7439f4a1a5cc03865de55b10a", + "name": "tensorflow", + "namespace": "python", + "sha256": "d16d6d510edca472f983ed1d9610251f5b989cc687ee2111207ba7732551cb63", + "size": 3451, + "subdir": "linux-64", + "timestamp": 1534982515526, + "version": "1.10.0" + }, + "tensorflow-1.10.0-gpu_py36hcebf108_0.conda": { + "build": "gpu_py36hcebf108_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 gpu_py36had579c0_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f0f4a2c01776def6cb81b43aa126b7cc", + "name": "tensorflow", + "namespace": "python", + "sha256": "3aad8e037e239692b32d8ae5634911642ede3fc3dd867d353d0babea9f15d5aa", + "size": 3414, + "subdir": "linux-64", + "timestamp": 1534967591531, + "version": "1.10.0" + }, + "tensorflow-1.10.0-mkl_py27h857755f_0.conda": { + "build": "mkl_py27h857755f_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 2.7.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 mkl_py27h3c3e929_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e5797b41a7ceda6e3f071c28b94bdade", + "name": "tensorflow", + "namespace": "python", + "sha256": "a1629f7b1d4342c3710405f3e662f5fb86bd51087527c4b445914b059112d015", + "size": 4071, + "subdir": "linux-64", + "timestamp": 1534981011463, + "version": "1.10.0" + }, + "tensorflow-1.10.0-mkl_py35heddcb22_0.conda": { + "build": "mkl_py35heddcb22_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.5.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 mkl_py35h3c3e929_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "261af61693994a2905ba66810f483602", + "name": "tensorflow", + "namespace": "python", + "sha256": "6bb7297fcd0c44e9b1c2e4392c6b5f70b65379e7de1fb3fd50f386fbdc2ac974", + "size": 4074, + "subdir": "linux-64", + "timestamp": 1534981058901, + "version": "1.10.0" + }, + "tensorflow-1.10.0-mkl_py36hdb377fd_0.conda": { + "build": "mkl_py36hdb377fd_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.6.*", + "tensorboard >=1.10.0,<1.11.0", + "tensorflow-base ==1.10.0 mkl_py36h3c3e929_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d2d8f094bf803d4830143d821238e9d5", + "name": "tensorflow", + "namespace": "python", + "sha256": "c3f2ebc1f0dac9059dd64de373bb13e7ee67ee02c917d9f1f3f3bf64339b1537", + "size": 4073, + "subdir": "linux-64", + "timestamp": 1534981027845, + "version": "1.10.0" + }, + "tensorflow-1.11.0-eigen_py27h06aee4b_0.conda": { + "build": "eigen_py27h06aee4b_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 2.7.*", + "tensorboard >=1.11.0,<1.12.0", + "tensorflow-base ==1.11.0 eigen_py27h4dcebc2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d61d5e3563c1fbc118ba9d79f24d724e", + "name": "tensorflow", + "namespace": "python", + "sha256": "bdb8372ad04aa91c398d3e81730188fdd9cce3043bb729157381e077c821a3cb", + "size": 3883, + "subdir": "linux-64", + "timestamp": 1538592559093, + "version": "1.11.0" + }, + "tensorflow-1.11.0-eigen_py36he3f7ef1_0.conda": { + "build": "eigen_py36he3f7ef1_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.6.*", + "tensorboard >=1.11.0,<1.12.0", + "tensorflow-base ==1.11.0 eigen_py36h4dcebc2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "133a40a5b34660e193ab9ade3c52cdb3", + "name": "tensorflow", + "namespace": "python", + "sha256": "ad558f1c651988298e51e78ca0e554a392029c4a1ba5553f9c974ff58ceb2968", + "size": 3858, + "subdir": "linux-64", + "timestamp": 1538592522142, + "version": "1.11.0" + }, + "tensorflow-1.11.0-gpu_py27h99ab47f_0.conda": { + "build": "gpu_py27h99ab47f_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.11.0,<1.12.0", + "tensorflow-base ==1.11.0 gpu_py27h8e0ae2d_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "271433e9d2c1e913753ce334281f4e2e", + "name": "tensorflow", + "namespace": "python", + "sha256": "9f264af231d5a8ccf5e9484c0f0e648cdbfe280dba50b4316f47c2334da345ed", + "size": 3688, + "subdir": "linux-64", + "timestamp": 1538749320605, + "version": "1.11.0" + }, + "tensorflow-1.11.0-gpu_py27hd8bfc1a_0.conda": { + "build": "gpu_py27hd8bfc1a_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.11.0,<1.12.0", + "tensorflow-base ==1.11.0 gpu_py27had579c0_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6516a1482288e94f089030408cbcda1d", + "name": "tensorflow", + "namespace": "python", + "sha256": "dd4a8ef8363d2c029371853e7363a68043a377a877d5d5d51b01ad2a7d6c100f", + "size": 3637, + "subdir": "linux-64", + "timestamp": 1538749727101, + "version": "1.11.0" + }, + "tensorflow-1.11.0-gpu_py36h4459f94_0.conda": { + "build": "gpu_py36h4459f94_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.11.0,<1.12.0", + "tensorflow-base ==1.11.0 gpu_py36h8e0ae2d_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0e46a43fc79a118b3a0719cb8bce7973", + "name": "tensorflow", + "namespace": "python", + "sha256": "7d4475b51cf553c581b802b87ffcb0f38dd8fb621649084d80355a8ed9a46a66", + "size": 3665, + "subdir": "linux-64", + "timestamp": 1538749080306, + "version": "1.11.0" + }, + "tensorflow-1.11.0-gpu_py36h9c9050a_0.conda": { + "build": "gpu_py36h9c9050a_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.11.0,<1.12.0", + "tensorflow-base ==1.11.0 gpu_py36had579c0_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "578452088ff5ac79a0ae75ab6886d9f1", + "name": "tensorflow", + "namespace": "python", + "sha256": "92285693c1db116e04164c492db765ba141c7ef9f40ac75e898fe7d21863708c", + "size": 3629, + "subdir": "linux-64", + "timestamp": 1538749489335, + "version": "1.11.0" + }, + "tensorflow-1.11.0-mkl_py27h25e0b76_0.conda": { + "build": "mkl_py27h25e0b76_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 2.7.*", + "tensorboard >=1.11.0,<1.12.0", + "tensorflow-base ==1.11.0 mkl_py27h3c3e929_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a198e75555d087a77d53bad0bfe12bbf", + "name": "tensorflow", + "namespace": "python", + "sha256": "c55e4c61b22a3132c225fb10b2526de903824e2838942db26b7f788d56943b56", + "size": 3884, + "subdir": "linux-64", + "timestamp": 1538592540344, + "version": "1.11.0" + }, + "tensorflow-1.11.0-mkl_py36ha6f0bda_0.conda": { + "build": "mkl_py36ha6f0bda_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.6.*", + "tensorboard >=1.11.0,<1.12.0", + "tensorflow-base ==1.11.0 mkl_py36h3c3e929_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7940a0b2b9317361d642e11947b93c43", + "name": "tensorflow", + "namespace": "python", + "sha256": "de047699c0eee73ddae620e952153b1e62e2de5d22cad88f367e62426ca39118", + "size": 3851, + "subdir": "linux-64", + "timestamp": 1538592574420, + "version": "1.11.0" + }, + "tensorflow-1.12.0-eigen_py27hfe19c55_0.conda": { + "build": "eigen_py27hfe19c55_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 2.7.*", + "tensorboard >=1.12.0,<1.13.0", + "tensorflow-base ==1.12.0 eigen_py27h4dcebc2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "963eb2c617b23ee74925ea167f957136", + "name": "tensorflow", + "namespace": "python", + "sha256": "5653e6275daa7b064b372454b391ebacc660f95047692113d8442138b7fc8758", + "size": 3899, + "subdir": "linux-64", + "timestamp": 1542084162567, + "version": "1.12.0" + }, + "tensorflow-1.12.0-eigen_py36hbd5f568_0.conda": { + "build": "eigen_py36hbd5f568_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.6.*", + "tensorboard >=1.12.0,<1.13.0", + "tensorflow-base ==1.12.0 eigen_py36h4dcebc2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7ba6c9b0b652d16019813d7b374ce717", + "name": "tensorflow", + "namespace": "python", + "sha256": "2812cdff1f39eed6ea040cd639d33198d1db29b3290a449045bdf7ab36e33dfe", + "size": 3887, + "subdir": "linux-64", + "timestamp": 1542084115670, + "version": "1.12.0" + }, + "tensorflow-1.12.0-gpu_py27h2a0f108_0.conda": { + "build": "gpu_py27h2a0f108_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.12.0,<1.13.0", + "tensorflow-base ==1.12.0 gpu_py27had579c0_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5ecdd82a492183815a478895e9283804", + "name": "tensorflow", + "namespace": "python", + "sha256": "42096880f7afa3a0871ff54829a096f2c1e9dd782e149da1ead11149c4b1df8f", + "size": 3664, + "subdir": "linux-64", + "timestamp": 1542153436129, + "version": "1.12.0" + }, + "tensorflow-1.12.0-gpu_py27h956c076_0.conda": { + "build": "gpu_py27h956c076_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.12.0,<1.13.0", + "tensorflow-base ==1.12.0 gpu_py27h8e0ae2d_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8da9c5030fc0a4e602c7479fcd827352", + "name": "tensorflow", + "namespace": "python", + "sha256": "e92cfe8c024e30d99bb311c9ff3de3ad8ef1115ef8b3be81bb9e5c4aeaa42fba", + "size": 3722, + "subdir": "linux-64", + "timestamp": 1542144658627, + "version": "1.12.0" + }, + "tensorflow-1.12.0-gpu_py36he68c306_0.conda": { + "build": "gpu_py36he68c306_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.12.0,<1.13.0", + "tensorflow-base ==1.12.0 gpu_py36h8e0ae2d_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8e77fd6e2d26d3c681b73b9957b07b3e", + "name": "tensorflow", + "namespace": "python", + "sha256": "04116d6986e7f36d5f831cee31083ce62c70fc493bec61ab8ad4e65b8213271c", + "size": 3711, + "subdir": "linux-64", + "timestamp": 1542144685899, + "version": "1.12.0" + }, + "tensorflow-1.12.0-gpu_py36he74679b_0.conda": { + "build": "gpu_py36he74679b_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.12.0,<1.13.0", + "tensorflow-base ==1.12.0 gpu_py36had579c0_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "46294acaa0f6c7253a11b172f97c3529", + "name": "tensorflow", + "namespace": "python", + "sha256": "36a9fd258d38b71ccff41e6dc10add769fb4ceda0c4f37111bbf4d9de3484663", + "size": 3656, + "subdir": "linux-64", + "timestamp": 1542153462926, + "version": "1.12.0" + }, + "tensorflow-1.12.0-mkl_py27hc55d17a_0.conda": { + "build": "mkl_py27hc55d17a_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 2.7.*", + "tensorboard >=1.12.0,<1.13.0", + "tensorflow-base ==1.12.0 mkl_py27h3c3e929_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "19cc1a6e9f8c6d73cdb923964dc89dee", + "name": "tensorflow", + "namespace": "python", + "sha256": "e3457818d20321fa4df7fc146ed4423bb77727583244977f62eb4eeae9f21436", + "size": 3883, + "subdir": "linux-64", + "timestamp": 1542084140716, + "version": "1.12.0" + }, + "tensorflow-1.12.0-mkl_py36h69b6ba0_0.conda": { + "build": "mkl_py36h69b6ba0_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.6.*", + "tensorboard >=1.12.0,<1.13.0", + "tensorflow-base ==1.12.0 mkl_py36h3c3e929_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8fcfb591f03733630eb67675ecc425c0", + "name": "tensorflow", + "namespace": "python", + "sha256": "a7ae63ebaf7b25a6730996249b64666a57e03caa2cd93e02284822081edce18b", + "size": 3876, + "subdir": "linux-64", + "timestamp": 1542084181377, + "version": "1.12.0" + }, + "tensorflow-1.13.1-eigen_py27h5e92bea_0.conda": { + "build": "eigen_py27h5e92bea_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 2.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 eigen_py27hf4a566f_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "40db98ede17864a927165842079f3dc7", + "name": "tensorflow", + "namespace": "python", + "sha256": "81eb6aaeb2e175c9120d854905f567a4f399ab4b26927c5b132b54960e8e70b6", + "size": 4034, + "subdir": "linux-64", + "timestamp": 1554327977844, + "version": "1.13.1" + }, + "tensorflow-1.13.1-eigen_py36hc59b85e_0.conda": { + "build": "eigen_py36hc59b85e_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.6.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 eigen_py36hf4a566f_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "741fb1620af72bf63a0c6b2733c54e22", + "name": "tensorflow", + "namespace": "python", + "sha256": "877c2b71409427ad5a3c2f354f8c2388be2fc567fa938a4606a29bf4269e951f", + "size": 4025, + "subdir": "linux-64", + "timestamp": 1554327952616, + "version": "1.13.1" + }, + "tensorflow-1.13.1-eigen_py37h7cb7401_0.conda": { + "build": "eigen_py37h7cb7401_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 eigen_py37hf4a566f_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ff0a1a59326d65682c1b9611f4c1cc63", + "name": "tensorflow", + "namespace": "python", + "sha256": "c45d05fa742f66596cb5de67e35c17ff727f04c4bb18f0eca6c865b101152c45", + "size": 4009, + "subdir": "linux-64", + "timestamp": 1554327902072, + "version": "1.13.1" + }, + "tensorflow-1.13.1-gpu_py27hc5faae7_0.conda": { + "build": "gpu_py27hc5faae7_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 gpu_py27h611c6d2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bd46cbd43d5cbe6d7dce41bb7f885487", + "name": "tensorflow", + "namespace": "python", + "sha256": "a91355383b71badff327866f2515ceb2d894612e1e2d5a2ae2f69c1d66b8b5b9", + "size": 3960, + "subdir": "linux-64", + "timestamp": 1554467552087, + "version": "1.13.1" + }, + "tensorflow-1.13.1-gpu_py27hcb41dfa_0.conda": { + "build": "gpu_py27hcb41dfa_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 gpu_py27h8d69cac_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ee6aefd2a7d09f371cf05fc9f941ae6e", + "name": "tensorflow", + "namespace": "python", + "sha256": "d1548c9bd63feb67d320a892c25656ba16f5d1beb4d791a9b6e7be160fc87603", + "size": 3931, + "subdir": "linux-64", + "timestamp": 1554431543520, + "version": "1.13.1" + }, + "tensorflow-1.13.1-gpu_py27hd3b962e_0.conda": { + "build": "gpu_py27hd3b962e_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 gpu_py27h8f37b9b_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "279f74c7a05ca9a32043263ba82a10be", + "name": "tensorflow", + "namespace": "python", + "sha256": "5f92f34401c256975dbba7b6b0041cc0092aedf34a4bcf71da68f98631d50f5c", + "size": 3922, + "subdir": "linux-64", + "timestamp": 1554491874865, + "version": "1.13.1" + }, + "tensorflow-1.13.1-gpu_py36h26cf82e_0.conda": { + "build": "gpu_py36h26cf82e_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 gpu_py36h8f37b9b_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4e5f1d05a8f4195061a9f2034fcf976f", + "name": "tensorflow", + "namespace": "python", + "sha256": "09f03e4d2f9f6c88a38e73aa37856ce650276e99e9d1440a4409a7054ad53d49", + "size": 3946, + "subdir": "linux-64", + "timestamp": 1554491850327, + "version": "1.13.1" + }, + "tensorflow-1.13.1-gpu_py36h3991807_0.conda": { + "build": "gpu_py36h3991807_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 gpu_py36h8d69cac_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e63d8932df2a51c5380e1775e8f30443", + "name": "tensorflow", + "namespace": "python", + "sha256": "96cab9604edbdb4ee9eafa106a85908495d5087ef5bfad3b6000789522dcd348", + "size": 3956, + "subdir": "linux-64", + "timestamp": 1554431545088, + "version": "1.13.1" + }, + "tensorflow-1.13.1-gpu_py36h9b25d83_0.conda": { + "build": "gpu_py36h9b25d83_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 gpu_py36h611c6d2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6a7a1f0e8317947ba88b58daf86ef275", + "name": "tensorflow", + "namespace": "python", + "sha256": "02f40ec1d68e567a82aafc729f5207fe2374a0fcc37ee350bd64934249e66c31", + "size": 3933, + "subdir": "linux-64", + "timestamp": 1554467577127, + "version": "1.13.1" + }, + "tensorflow-1.13.1-gpu_py37h49933a4_0.conda": { + "build": "gpu_py37h49933a4_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 gpu_py37h611c6d2_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "46efc0139d3018c7a2bfb2212a739c96", + "name": "tensorflow", + "namespace": "python", + "sha256": "68dae3bea0502c6c7c76a986045a2555a80f02f368dcf39ce9cf643b0fec5e5f", + "size": 3959, + "subdir": "linux-64", + "timestamp": 1554467601808, + "version": "1.13.1" + }, + "tensorflow-1.13.1-gpu_py37hc158e3b_0.conda": { + "build": "gpu_py37hc158e3b_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 gpu_py37h8d69cac_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c8cb561c466a7944ff20ed6eea9a3428", + "name": "tensorflow", + "namespace": "python", + "sha256": "582021f29f69fd6a6bb23b4acc9284d11e52958f2993a62438f26183fad45c03", + "size": 3952, + "subdir": "linux-64", + "timestamp": 1554431544323, + "version": "1.13.1" + }, + "tensorflow-1.13.1-gpu_py37hd37c573_0.conda": { + "build": "gpu_py37hd37c573_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 gpu_py37h8f37b9b_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5bd9d7a25c2da26d8881b82091807a5f", + "name": "tensorflow", + "namespace": "python", + "sha256": "48f859631154b6af3990f6ff505f32f75a5e9ce7efdb34e8ea04c4fcf95d8c81", + "size": 3921, + "subdir": "linux-64", + "timestamp": 1554491827785, + "version": "1.13.1" + }, + "tensorflow-1.13.1-mkl_py27h74ee40f_0.conda": { + "build": "mkl_py27h74ee40f_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 2.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 mkl_py27h7ce6ba3_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cb3d75adcebb5862a62d4a68bcb707c2", + "name": "tensorflow", + "namespace": "python", + "sha256": "8526dd693db6783b518e54d2caa51bfc3f31a7c9f5dd3ab81182f6aa5b0bacd7", + "size": 4004, + "subdir": "linux-64", + "timestamp": 1554328027396, + "version": "1.13.1" + }, + "tensorflow-1.13.1-mkl_py36h27d456a_0.conda": { + "build": "mkl_py36h27d456a_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.6.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 mkl_py36h7ce6ba3_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a3b635e4950ba29f51265d9f4c758da0", + "name": "tensorflow", + "namespace": "python", + "sha256": "b96a7a67cba3d4f5ad609b260b1d1a944fedc86f5dabe7b85e62df1a3363c2dc", + "size": 4019, + "subdir": "linux-64", + "timestamp": 1554327927772, + "version": "1.13.1" + }, + "tensorflow-1.13.1-mkl_py37h54b294f_0.conda": { + "build": "mkl_py37h54b294f_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.7.*", + "tensorboard >=1.13.0,<1.14.0", + "tensorflow-base ==1.13.1 mkl_py37h7ce6ba3_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "27b66833716a193aae03cf7483bc51b2", + "name": "tensorflow", + "namespace": "python", + "sha256": "afe2b605285165c0f21878d19884afc3ed8e7c57a9f3e2c647ffbf13bd643ac4", + "size": 4002, + "subdir": "linux-64", + "timestamp": 1554328003023, + "version": "1.13.1" + }, + "tensorflow-1.14.0-eigen_py27h99c1539_0.conda": { + "build": "eigen_py27h99c1539_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 2.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 eigen_py27hf4a566f_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "79242dd23ba11b90eac3f382e6afc8e4", + "name": "tensorflow", + "namespace": "python", + "sha256": "f94fc385c89ef25738d3c0e29bdc7f17c373b72749b9805ac9ca7d2c223043a9", + "size": 3905, + "subdir": "linux-64", + "timestamp": 1561050024368, + "version": "1.14.0" + }, + "tensorflow-1.14.0-eigen_py36hb2cf719_0.conda": { + "build": "eigen_py36hb2cf719_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.6.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 eigen_py36hf4a566f_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ca0ea43b3f8013ae964c5bbb84be5076", + "name": "tensorflow", + "namespace": "python", + "sha256": "6fbbe762da1cf82e32ae59c98fb51633c5846f38e23728814126c6f1ceb26f47", + "size": 3898, + "subdir": "linux-64", + "timestamp": 1561050050421, + "version": "1.14.0" + }, + "tensorflow-1.14.0-eigen_py37h195cb1b_0.conda": { + "build": "eigen_py37h195cb1b_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 eigen_py37hf4a566f_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5ffaf4df878c536b823ab8864f869ce1", + "name": "tensorflow", + "namespace": "python", + "sha256": "570fb5ca8d1384dd098bc3f0565808f4999d0c5df4a8a22cab0a49680ee4728f", + "size": 3900, + "subdir": "linux-64", + "timestamp": 1561049925182, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py27h39f1c70_0.conda": { + "build": "gpu_py27h39f1c70_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py27he45bfe2_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9d213b3033df53bab6813145ad7385d4", + "name": "tensorflow", + "namespace": "python", + "sha256": "8a89367cb800730dc565d1bf3cca2c2116e305ea6e72dac656cc2024d5d763cf", + "size": 4022, + "subdir": "linux-64", + "timestamp": 1561649415809, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py27h48701d4_0.conda": { + "build": "gpu_py27h48701d4_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py27h611c6d2_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5d8284644b0505760f314e61d53741a8", + "name": "tensorflow", + "namespace": "python", + "sha256": "1f007c06b4c4e19eb471863bb86615da34db954bad0383fb0807c994364d0faa", + "size": 3934, + "subdir": "linux-64", + "timestamp": 1561554688858, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py27h84ace93_0.conda": { + "build": "gpu_py27h84ace93_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py27h8f37b9b_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "924eb5b8e728bb341c3b96a4d6cd52ed", + "name": "tensorflow", + "namespace": "python", + "sha256": "dcd4d6e018389fb532568e039e7ac4e5b3b2ea607d693c3bda28a349fcf46920", + "size": 3934, + "subdir": "linux-64", + "timestamp": 1561537496289, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py27he9627f8_0.conda": { + "build": "gpu_py27he9627f8_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py27h8d69cac_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6473665ea0fe85541e7f76aa0de6b0d0", + "name": "tensorflow", + "namespace": "python", + "sha256": "b99c24e88954b447a6c711ad9fb888bfceb5c5daea645d79ee8564f24df7c00c", + "size": 3932, + "subdir": "linux-64", + "timestamp": 1561577155101, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py36h3fb9ad6_0.conda": { + "build": "gpu_py36h3fb9ad6_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py36he45bfe2_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "964b9108a2e941f618b82082a8497545", + "name": "tensorflow", + "namespace": "python", + "sha256": "f4ef26b1559de5a846d9104521cdff26cb85eb9c4ae1ce3586330cbe94810940", + "size": 4017, + "subdir": "linux-64", + "timestamp": 1561649453408, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py36h57aa796_0.conda": { + "build": "gpu_py36h57aa796_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py36h8d69cac_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c06219287b66411f7dce23761cea62cf", + "name": "tensorflow", + "namespace": "python", + "sha256": "96701f80c9a7a227ae24cd7d34291eea5370cb3ca17206e6599883f6efd72503", + "size": 3927, + "subdir": "linux-64", + "timestamp": 1561577125099, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py36hc335bb8_0.conda": { + "build": "gpu_py36hc335bb8_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py36h8f37b9b_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2df0558727a4a450606b21fec5572412", + "name": "tensorflow", + "namespace": "python", + "sha256": "c90e09fe84fd9ea9a4b300c2a439414aa27c39c2f499006a5874a7773b3c743c", + "size": 3939, + "subdir": "linux-64", + "timestamp": 1561537513555, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py36hfc5689a_0.conda": { + "build": "gpu_py36hfc5689a_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py36h611c6d2_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9a4dc1674986400ca01c9da3760cad95", + "name": "tensorflow", + "namespace": "python", + "sha256": "768591660f8d5e7140a31b488b70dbcf65fd11e66cf24152fab8b26203f40f2c", + "size": 3936, + "subdir": "linux-64", + "timestamp": 1561554662946, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py37h4491b45_0.conda": { + "build": "gpu_py37h4491b45_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py37h8d69cac_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5c1b94f54da927d9c3c431a72e647666", + "name": "tensorflow", + "namespace": "python", + "sha256": "b8fac469fc5cddc85db8e8476e679900f9e354ae63dddb9a7a021a4d33b08f5b", + "size": 3929, + "subdir": "linux-64", + "timestamp": 1561577184143, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py37h63f5f00_0.conda": { + "build": "gpu_py37h63f5f00_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py37h611c6d2_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "37e1d90bb31720e3ed268ed765297a96", + "name": "tensorflow", + "namespace": "python", + "sha256": "f20f9a5593076cc674706f48794df517e266f9cf2751ec28a78f14164043a804", + "size": 3925, + "subdir": "linux-64", + "timestamp": 1561554637174, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py37h74c33d7_0.conda": { + "build": "gpu_py37h74c33d7_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py37he45bfe2_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "48ae4c0622da25f0032e6cf71c91f150", + "name": "tensorflow", + "namespace": "python", + "sha256": "cafdc86fbf685d5d3edf47cfe4addb39ffbc93fd878f5692a34369eac552e098", + "size": 4015, + "subdir": "linux-64", + "timestamp": 1561649434543, + "version": "1.14.0" + }, + "tensorflow-1.14.0-gpu_py37hae64822_0.conda": { + "build": "gpu_py37hae64822_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 gpu_py37h8f37b9b_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "71f0f3ae352c69fe9f7962b090773d5c", + "name": "tensorflow", + "namespace": "python", + "sha256": "6f927517a594308d0fb7bd57e0716fdf08b7b2ddde1e117ebdb569ee30910aee", + "size": 3941, + "subdir": "linux-64", + "timestamp": 1561537476135, + "version": "1.14.0" + }, + "tensorflow-1.14.0-mkl_py27h957988d_0.conda": { + "build": "mkl_py27h957988d_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 2.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 mkl_py27h7ce6ba3_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e25880e4f26f171c1d29dc125bb32482", + "name": "tensorflow", + "namespace": "python", + "sha256": "253ca1409bd18eb64a53625aa48cad26c7338676b5240cc117b86e84cfce71d8", + "size": 3906, + "subdir": "linux-64", + "timestamp": 1561049975245, + "version": "1.14.0" + }, + "tensorflow-1.14.0-mkl_py36h2526735_0.conda": { + "build": "mkl_py36h2526735_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.6.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 mkl_py36h7ce6ba3_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f96ae926c4a0ba650766f50e59a3f2ed", + "name": "tensorflow", + "namespace": "python", + "sha256": "67e0f5d296e0ebb09f8fc0c6c909417236dd8166f4589eeefb2686bcf6677418", + "size": 3896, + "subdir": "linux-64", + "timestamp": 1561049951605, + "version": "1.14.0" + }, + "tensorflow-1.14.0-mkl_py37h45c423b_0.conda": { + "build": "mkl_py37h45c423b_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.7.*", + "tensorboard >=1.14.0,<1.15.0", + "tensorflow-base ==1.14.0 mkl_py37h7ce6ba3_0", + "tensorflow-estimator >=1.14.0,<1.15.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0c7a8636abf9272b968fc7157bfa5a8b", + "name": "tensorflow", + "namespace": "python", + "sha256": "34165fcba2d80afd356ddf4022f704703975e17a01deebb1954d6a35cb94c478", + "size": 3893, + "subdir": "linux-64", + "timestamp": 1561050000805, + "version": "1.14.0" + }, + "tensorflow-1.15.0-eigen_py27h7b7505e_0.conda": { + "build": "eigen_py27h7b7505e_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 2.7.*", + "tensorboard 1.15.*", + "tensorflow-base 1.15.0 eigen_py27hd4672e3_0", + "tensorflow-estimator 1.15.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8aa620b614e2dd30865965b3a7bd18a5", + "name": "tensorflow", + "namespace": "python", + "sha256": "11555b26f7e231d85af54e6a3f88be1dcdb4f5b5b3f43b7f5e2aa37d1960e279", + "size": 4300, + "subdir": "linux-64", + "timestamp": 1573244526098, + "version": "1.15.0" + }, + "tensorflow-1.15.0-eigen_py36hd3854b5_0.conda": { + "build": "eigen_py36hd3854b5_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.6.*", + "tensorboard 1.15.*", + "tensorflow-base 1.15.0 eigen_py36h52b156a_0", + "tensorflow-estimator 1.15.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "56a304ec21b21f81c7b4257a93aea84d", + "name": "tensorflow", + "namespace": "python", + "sha256": "e835507beda7734a9a6eb2fb2bb045978b1edd3787d1045d47f502ce919872d5", + "size": 4298, + "subdir": "linux-64", + "timestamp": 1573244417844, + "version": "1.15.0" + }, + "tensorflow-1.15.0-eigen_py37h3790f83_0.conda": { + "build": "eigen_py37h3790f83_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard 1.15.*", + "tensorflow-base 1.15.0 eigen_py37h52b156a_0", + "tensorflow-estimator 1.15.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "17a15a2c2c1a61d16265c8c905f0d270", + "name": "tensorflow", + "namespace": "python", + "sha256": "b6f2e40b6121f0bc5c7f93068487526fe1a1b1c926d873c04c07f922a39908fb", + "size": 4297, + "subdir": "linux-64", + "timestamp": 1573244493390, + "version": "1.15.0" + }, + "tensorflow-1.15.0-gpu_py27h0c9f15b_0.conda": { + "build": "gpu_py27h0c9f15b_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 2.7.*", + "tensorboard 1.15.*", + "tensorflow-base 1.15.0 gpu_py27hf473bbb_0", + "tensorflow-estimator 1.15.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6cbd6ed182693f259aba92b0f0a40232", + "name": "tensorflow", + "namespace": "python", + "sha256": "a303da43effb361d7c58b9477a4ca52e5755e007bc63a86cfe3542a751a32361", + "size": 3956, + "subdir": "linux-64", + "timestamp": 1573482360101, + "version": "1.15.0" + }, + "tensorflow-1.15.0-gpu_py36h5a509aa_0.conda": { + "build": "gpu_py36h5a509aa_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.6.*", + "tensorboard 1.15.*", + "tensorflow-base 1.15.0 gpu_py36h9dcbed7_0", + "tensorflow-estimator 1.15.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d149959c880bb8e607e2b3e5961457dd", + "name": "tensorflow", + "namespace": "python", + "sha256": "df4d3127ea244d4e9e7f35bf4ee110d4f8581644c9bbffa63eb510a731d192ab", + "size": 3949, + "subdir": "linux-64", + "timestamp": 1573482394523, + "version": "1.15.0" + }, + "tensorflow-1.15.0-gpu_py37h0f0df58_0.conda": { + "build": "gpu_py37h0f0df58_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.7.*", + "tensorboard 1.15.*", + "tensorflow-base 1.15.0 gpu_py37h9dcbed7_0", + "tensorflow-estimator 1.15.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6fc86271752683e56de250e5a7c568f8", + "name": "tensorflow", + "namespace": "python", + "sha256": "6e41e91600ef3b473e785aca2fd4691f26f71e50ec9ab63eacbc812d8c6ccf02", + "size": 3957, + "subdir": "linux-64", + "timestamp": 1573482376003, + "version": "1.15.0" + }, + "tensorflow-1.15.0-mkl_py27hbe5f72a_0.conda": { + "build": "mkl_py27hbe5f72a_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 2.7.*", + "tensorboard 1.15.*", + "tensorflow-base 1.15.0 mkl_py27h503033c_0", + "tensorflow-estimator 1.15.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7b5e05c99fed264aa5c85748edc730f7", + "name": "tensorflow", + "namespace": "python", + "sha256": "3805d134021b0c16b709e3f27b5c8f5f0cc89e5190118b1adf1f1fd54b2ba482", + "size": 4301, + "subdir": "linux-64", + "timestamp": 1573244562679, + "version": "1.15.0" + }, + "tensorflow-1.15.0-mkl_py36h4920b83_0.conda": { + "build": "mkl_py36h4920b83_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.6.*", + "tensorboard 1.15.*", + "tensorflow-base 1.15.0 mkl_py36he1670d9_0", + "tensorflow-estimator 1.15.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5614b4f15a8808443d8e898a10a418d5", + "name": "tensorflow", + "namespace": "python", + "sha256": "adeac2bfd7dab4eddd03728334b0e80a8eb8f5e3d0b2395bdb38aea791ef061a", + "size": 4289, + "subdir": "linux-64", + "timestamp": 1573244456783, + "version": "1.15.0" + }, + "tensorflow-1.15.0-mkl_py37h28c19af_0.conda": { + "build": "mkl_py37h28c19af_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard 1.15.*", + "tensorflow-base 1.15.0 mkl_py37he1670d9_0", + "tensorflow-estimator 1.15.*" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2a281acf92d0b5b747648d038f71d742", + "name": "tensorflow", + "namespace": "python", + "sha256": "1042c1d6fde68b09fb9742c3174bddea446ec0b3479eb90034d3a5f31d5c4820", + "size": 4288, + "subdir": "linux-64", + "timestamp": 1573244383231, + "version": "1.15.0" + }, + "tensorflow-1.4.1-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "tensorflow-base 1.4.1", + "tensorflow-tensorboard" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c4394226d973b9b520f3300425aa71bb", + "name": "tensorflow", + "namespace": "python", + "sha256": "f0294694a587bb327012dafb9e6d5b3799084e3a8feb1207a74c7fbe0f5d3828", + "size": 3626, + "subdir": "linux-64", + "timestamp": 1516404690814, + "version": "1.4.1" + }, + "tensorflow-1.5.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "tensorflow-base 1.5.0", + "tensorflow-tensorboard >=1.5.0,<1.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c2c9de3465981ec69ada1fdb3b3204ba", + "name": "tensorflow", + "namespace": "python", + "sha256": "8afd861c2d03ad41c48c437b13e4234806614d7cb357dabc1cdab494d99bcf5c", + "size": 3650, + "subdir": "linux-64", + "timestamp": 1519700118780, + "version": "1.5.0" + }, + "tensorflow-1.6.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "tensorboard >=1.6.0,<1.7.0", + "tensorflow-base ==1.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "28402af34ac51ab372dd2ae7125bae41", + "name": "tensorflow", + "namespace": "python", + "sha256": "1c5c1a9184bb1e5668562c48e18d7300094730a641d9845c353253306f9c6719", + "size": 3723, + "subdir": "linux-64", + "timestamp": 1521234256918, + "version": "1.6.0" + }, + "tensorflow-1.7.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "tensorboard >=1.7.0,<1.8.0", + "tensorflow-base ==1.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "df7a9e747e3cddf1a3ceb8b604751c47", + "name": "tensorflow", + "namespace": "python", + "sha256": "e2c99c8b9ac5050d6155fdedf77d34d4b2dc4aa463efcbb215cedaf452e84658", + "size": 3711, + "subdir": "linux-64", + "timestamp": 1524277365595, + "version": "1.7.0" + }, + "tensorflow-1.8.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base 1.8.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bcb34bbecd99aad8bb4ba7a0fbe2e9a8", + "name": "tensorflow", + "namespace": "python", + "sha256": "6fd07b552cfdaa088cf021b89679d239259132595c3b9ea8f5daed2adcdd6424", + "size": 4136, + "subdir": "linux-64", + "timestamp": 1574087205039, + "version": "1.8.0" + }, + "tensorflow-1.8.0-h01c6a4e_0.conda": { + "build": "h01c6a4e_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.2.0 mkl", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py36hee38f2d_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "815e98213a71938a33aeccf9e7f05f52", + "name": "tensorflow", + "namespace": "python", + "sha256": "6c4c69d1b1c35b3fb99f381f35ddc2c2c43c604729de63b1d055643b778ebc2f", + "size": 3619, + "subdir": "linux-64", + "timestamp": 1527093873244, + "version": "1.8.0" + }, + "tensorflow-1.8.0-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base 1.8.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "754797527c78654eede90296985be0a8", + "name": "tensorflow", + "namespace": "python", + "sha256": "682ceb7c194966284f04b9026c93e1d8208ea860c9c3d2993b8b2e4658b03715", + "size": 3904, + "subdir": "linux-64", + "timestamp": 1642517607854, + "version": "1.8.0" + }, + "tensorflow-1.8.0-h16da8f2_0.conda": { + "build": "h16da8f2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.1.0 gpu", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py27hc1a7637_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "febbc8a363e5b839dce0ac816413986d", + "name": "tensorflow", + "namespace": "python", + "sha256": "b4b43bd84b92c5846ecd0f6df4d4bc14efceaccdd5b656f4833032092753d662", + "size": 6033, + "subdir": "linux-64", + "timestamp": 1527183535099, + "version": "1.8.0" + }, + "tensorflow-1.8.0-h2742514_0.conda": { + "build": "h2742514_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.2.0 mkl", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py35hee38f2d_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "445f62494cb93fe9cef33dc2ecc6abf2", + "name": "tensorflow", + "namespace": "python", + "sha256": "0c0bdc50c04a652bfaa60942407a61c039f293497636b39b29641824d56bb4c9", + "size": 3639, + "subdir": "linux-64", + "timestamp": 1527093866984, + "version": "1.8.0" + }, + "tensorflow-1.8.0-h469b60b_0.conda": { + "build": "h469b60b_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.3.0 eigen", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py35h5f64886_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "321212e6eecf75c6349e6ad33329e9c5", + "name": "tensorflow", + "namespace": "python", + "sha256": "3160953d3a159d69aef287f2bd90c2a5462d3b28ffc6b1eb0249d4e41b9244a3", + "size": 3635, + "subdir": "linux-64", + "timestamp": 1527093873485, + "version": "1.8.0" + }, + "tensorflow-1.8.0-h57681fa_0.conda": { + "build": "h57681fa_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.3.0 eigen", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py36h5f64886_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ba9d672cd8fa8a0b3eb43eb0e8a9f7cb", + "name": "tensorflow", + "namespace": "python", + "sha256": "e3c200124710a0eed8b6076e34381566172079275c8f0a6c76beb85ffff301a6", + "size": 3632, + "subdir": "linux-64", + "timestamp": 1527093887495, + "version": "1.8.0" + }, + "tensorflow-1.8.0-h5c3c37f_0.conda": { + "build": "h5c3c37f_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.1.0 gpu", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py27h4df133c_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4c78f3a4941d2027e9a12eeb06bafedb", + "name": "tensorflow", + "namespace": "python", + "sha256": "8ddbd8ef4408b5a73d4e2266bbbc9ec904732af597ea7b2bad2faf0aa3b2de14", + "size": 6058, + "subdir": "linux-64", + "timestamp": 1527183455976, + "version": "1.8.0" + }, + "tensorflow-1.8.0-h645107b_0.conda": { + "build": "h645107b_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.1.0 gpu", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py35h4df133c_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "722e04d85b6861e1ab100c303788deba", + "name": "tensorflow", + "namespace": "python", + "sha256": "3d8d676b6122bafca55c6b93684052601536c48ac08dc9aff9b849c7b30c2eff", + "size": 6034, + "subdir": "linux-64", + "timestamp": 1527183484983, + "version": "1.8.0" + }, + "tensorflow-1.8.0-h7b2774c_0.conda": { + "build": "h7b2774c_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.3.0 eigen", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py27h5f64886_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4b2ea0fed74178c4a9b653f2b4b8c1c5", + "name": "tensorflow", + "namespace": "python", + "sha256": "c792bbfa00ba56c3e6bed3b144e106901324797c1cd74ec7eb142328acda4780", + "size": 3624, + "subdir": "linux-64", + "timestamp": 1527093875009, + "version": "1.8.0" + }, + "tensorflow-1.8.0-hb11d968_0.conda": { + "build": "hb11d968_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.1.0 gpu", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py36hc1a7637_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5a700e7975d290a9964ce641f292bf1b", + "name": "tensorflow", + "namespace": "python", + "sha256": "11958df88f28a67c5a992ffba77792fcec7261f60b97f53c6f3ff71a0b151f53", + "size": 6050, + "subdir": "linux-64", + "timestamp": 1527183646691, + "version": "1.8.0" + }, + "tensorflow-1.8.0-hb1b1514_0.conda": { + "build": "hb1b1514_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.2.0 mkl", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py27hee38f2d_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "550d241a81ec71a02f0891f974f6e162", + "name": "tensorflow", + "namespace": "python", + "sha256": "dcd54a4d93e74db25b51512a61a0772b58c106f4b29609fcaf8b96d833729604", + "size": 3635, + "subdir": "linux-64", + "timestamp": 1527093869507, + "version": "1.8.0" + }, + "tensorflow-1.8.0-hb381393_0.conda": { + "build": "hb381393_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.1.0 gpu", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py36h4df133c_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ea94a1ef5bc6f071d66a66e903e98f26", + "name": "tensorflow", + "namespace": "python", + "sha256": "33e3ff02cbe9a0a387f3c23bdd814796daaada367d508c65bd0bbfe7cea77f85", + "size": 6053, + "subdir": "linux-64", + "timestamp": 1527183510036, + "version": "1.8.0" + }, + "tensorflow-1.8.0-hc2d9325_0.conda": { + "build": "hc2d9325_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.1.0 gpu", + "tensorboard >=1.8.0,<1.9.0", + "tensorflow-base ==1.8.0 py35hc1a7637_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b8d8e794090a1797b81b0a8f43708e09", + "name": "tensorflow", + "namespace": "python", + "sha256": "bfd3fa90e484f6f7f74ea3f2d66fb67e3fea3bc2ce0e5973b284e0843459f0fd", + "size": 6033, + "subdir": "linux-64", + "timestamp": 1527183562443, + "version": "1.8.0" + }, + "tensorflow-1.9.0-eigen_py27hf386fcc_1.conda": { + "build": "eigen_py27hf386fcc_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 2.7.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 eigen_py27hdfca3bf_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "65eec44325478731a4fe9a5b442fd6b1", + "name": "tensorflow", + "namespace": "python", + "sha256": "d1e6c7c1bfc415bddf4c679d320833d9511cc9565e54f88a9b676e3695a550aa", + "size": 3246, + "subdir": "linux-64", + "timestamp": 1532705185399, + "version": "1.9.0" + }, + "tensorflow-1.9.0-eigen_py35h8c89287_1.conda": { + "build": "eigen_py35h8c89287_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.5.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 eigen_py35hdfca3bf_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1a4f85ffc8e450b593f0d1b17ee75ebd", + "name": "tensorflow", + "namespace": "python", + "sha256": "74d61dda968046f3d1b2a64475bac1fc637773c81005b1aae5959adaf6e9ae10", + "size": 3266, + "subdir": "linux-64", + "timestamp": 1532705162496, + "version": "1.9.0" + }, + "tensorflow-1.9.0-eigen_py36h8c89287_0.conda": { + "build": "eigen_py36h8c89287_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.5.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 eigen_py35hdfca3bf_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "be964ca93885789b878a28143270099e", + "name": "tensorflow", + "namespace": "python", + "sha256": "c5f5d1d025ce6e6dce0d2c2f6bf71014897ac952f88bec8d5fed43834e0af63f", + "size": 3440, + "subdir": "linux-64", + "timestamp": 1532470386666, + "version": "1.9.0" + }, + "tensorflow-1.9.0-eigen_py36hbec2359_0.conda": { + "build": "eigen_py36hbec2359_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.6.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 eigen_py36hdfca3bf_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bc0d2647f8bc4677d48d960f93068330", + "name": "tensorflow", + "namespace": "python", + "sha256": "49d7d937314d43b55fe3ab4d6db381ed0d1da0c72dbf5c6a351000c97a680470", + "size": 3423, + "subdir": "linux-64", + "timestamp": 1532470428812, + "version": "1.9.0" + }, + "tensorflow-1.9.0-eigen_py36hbec2359_1.conda": { + "build": "eigen_py36hbec2359_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 3.6.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 eigen_py36hdfca3bf_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9864ab42d1f722359e04958b4b485419", + "name": "tensorflow", + "namespace": "python", + "sha256": "ef02ab0b6b2236d8885a7c4870c8d5effff2f28f201b1674fd6345750771e10b", + "size": 3242, + "subdir": "linux-64", + "timestamp": 1532705208427, + "version": "1.9.0" + }, + "tensorflow-1.9.0-eigen_py36hf386fcc_0.conda": { + "build": "eigen_py36hf386fcc_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "python 2.7.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 eigen_py27hdfca3bf_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "95d52172d07669a913e84baffccc4ee2", + "name": "tensorflow", + "namespace": "python", + "sha256": "6c6623bd1d3ba136c665788dc95159f0af008593b9c09ec4481a7394598d75af", + "size": 3444, + "subdir": "linux-64", + "timestamp": 1532470443204, + "version": "1.9.0" + }, + "tensorflow-1.9.0-gpu_py27h233f449_1.conda": { + "build": "gpu_py27h233f449_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 gpu_py27h9f529ab_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "26ca465b7038ad21debfc0eac1ea4341", + "name": "tensorflow", + "namespace": "python", + "sha256": "ffde2812a24e01fa74012cc2b75557ed7573787bd544545c4fb9495946e96cc4", + "size": 3230, + "subdir": "linux-64", + "timestamp": 1532704918005, + "version": "1.9.0" + }, + "tensorflow-1.9.0-gpu_py27h395d940_1.conda": { + "build": "gpu_py27h395d940_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 gpu_py27h9f529ab_1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ae7a24557878a875b096ef88600c3c3b", + "name": "tensorflow", + "namespace": "python", + "sha256": "544dec364e7628079459c4fdca6fc76a0d8101fcfbccb69ee9799207dc2c6ccc", + "size": 3444, + "subdir": "linux-64", + "timestamp": 1533839329679, + "version": "1.9.0" + }, + "tensorflow-1.9.0-gpu_py27hd3a791e_1.conda": { + "build": "gpu_py27hd3a791e_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 2.7.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 gpu_py27h6ecc378_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2b6e5f5d6fbf7ba63eb04701c32b7213", + "name": "tensorflow", + "namespace": "python", + "sha256": "c23f7f7a088a943edbb72cfe283b37dc4148bf8713610e6e760bcd086dd3feed", + "size": 3360, + "subdir": "linux-64", + "timestamp": 1532706311823, + "version": "1.9.0" + }, + "tensorflow-1.9.0-gpu_py35h42d5ad8_1.conda": { + "build": "gpu_py35h42d5ad8_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.5.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 gpu_py35h6ecc378_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cba7b6b20f176b8dae158d6f65ea1d6d", + "name": "tensorflow", + "namespace": "python", + "sha256": "c8703ec16d6363e4b2a8ec2f4738f94ee9dd9e5acb0c4405c1314d0506230906", + "size": 3360, + "subdir": "linux-64", + "timestamp": 1532706247485, + "version": "1.9.0" + }, + "tensorflow-1.9.0-gpu_py35h60c0932_1.conda": { + "build": "gpu_py35h60c0932_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.5.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 gpu_py35h9f529ab_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "34b9d85507c95a82be7ee0e683987f49", + "name": "tensorflow", + "namespace": "python", + "sha256": "750cc3d7f6fad025585337c675bf87de270b30237c1a24053244d3d59e4f4617", + "size": 3227, + "subdir": "linux-64", + "timestamp": 1532704883176, + "version": "1.9.0" + }, + "tensorflow-1.9.0-gpu_py35hb39db67_1.conda": { + "build": "gpu_py35hb39db67_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.5.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 gpu_py35h9f529ab_1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fce95c5c5e114c06d8e63a6c3b341485", + "name": "tensorflow", + "namespace": "python", + "sha256": "c763c91c3e426e70d1fe296b5a3d08a639b6972560e82622c81f807c17b50e4a", + "size": 3414, + "subdir": "linux-64", + "timestamp": 1533839278028, + "version": "1.9.0" + }, + "tensorflow-1.9.0-gpu_py36h02c5d5e_1.conda": { + "build": "gpu_py36h02c5d5e_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 gpu_py36h6ecc378_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7186f9812a6853f51ff51c85b838c1a5", + "name": "tensorflow", + "namespace": "python", + "sha256": "1002d31eafe66d11e1c690306b9f72c8ffba49b2774a97b981157cf41d87ccf7", + "size": 3385, + "subdir": "linux-64", + "timestamp": 1532706292898, + "version": "1.9.0" + }, + "tensorflow-1.9.0-gpu_py36h220e158_1.conda": { + "build": "gpu_py36h220e158_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 gpu_py36h9f529ab_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "02181e43de0f10660b8c9a819fc3fff4", + "name": "tensorflow", + "namespace": "python", + "sha256": "173d00d41363714de4c9cbbd71a2587589b5384670be45e194d6bbfa2e0c9705", + "size": 3220, + "subdir": "linux-64", + "timestamp": 1532704900341, + "version": "1.9.0" + }, + "tensorflow-1.9.0-gpu_py36h313df88_1.conda": { + "build": "gpu_py36h313df88_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "python 3.6.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 gpu_py36h9f529ab_1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "574d1dba4151303394f3b9263d2aa434", + "name": "tensorflow", + "namespace": "python", + "sha256": "68a703cfc69b6bc72898e43962fd6815d51d93c45a52aa99b0f7f8e2c95366e4", + "size": 3409, + "subdir": "linux-64", + "timestamp": 1533839379022, + "version": "1.9.0" + }, + "tensorflow-1.9.0-mkl_py27h0cb61a4_1.conda": { + "build": "mkl_py27h0cb61a4_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 2.7.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 mkl_py27h2ca6a6a_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a233ced85526fa680ec8cf591c3da339", + "name": "tensorflow", + "namespace": "python", + "sha256": "90e36db5ca17699b434b54f402a62f8e2afc8828347266797c8d9e4f34644963", + "size": 3235, + "subdir": "linux-64", + "timestamp": 1532705231282, + "version": "1.9.0" + }, + "tensorflow-1.9.0-mkl_py35h5be851a_1.conda": { + "build": "mkl_py35h5be851a_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.5.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 mkl_py35h2ca6a6a_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f2447970f9d8ac7fab67125d11db5ebd", + "name": "tensorflow", + "namespace": "python", + "sha256": "72af543e2a61b5ab400a7516b118cf9a824fdac3aa881c37f6bc426c2d16f888", + "size": 3232, + "subdir": "linux-64", + "timestamp": 1532705131013, + "version": "1.9.0" + }, + "tensorflow-1.9.0-mkl_py36h0cb61a4_0.conda": { + "build": "mkl_py36h0cb61a4_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 2.7.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 mkl_py27h2ca6a6a_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "09620ab220ae6869f3307ef8987d702e", + "name": "tensorflow", + "namespace": "python", + "sha256": "8e256f5e184664ba7a8bb5968a3322585eac70c6c0389bcffcfc31068b1fb055", + "size": 3425, + "subdir": "linux-64", + "timestamp": 1532470399230, + "version": "1.9.0" + }, + "tensorflow-1.9.0-mkl_py36h5be851a_0.conda": { + "build": "mkl_py36h5be851a_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.5.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 mkl_py35h2ca6a6a_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "10b5335eef5bb3624f388cc1e40a1837", + "name": "tensorflow", + "namespace": "python", + "sha256": "fca3c44925d0a16721633daca7ce030476c403bc5d59813c05c0fc8efafefa91", + "size": 3419, + "subdir": "linux-64", + "timestamp": 1532470414002, + "version": "1.9.0" + }, + "tensorflow-1.9.0-mkl_py36h6d6ce78_0.conda": { + "build": "mkl_py36h6d6ce78_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.6.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 mkl_py36h2ca6a6a_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "03ebf383b05fe67f9c70590e89add45b", + "name": "tensorflow", + "namespace": "python", + "sha256": "97ef0551eae8de51833d37451415cac2c53efe638231ea03a032a46172193e3f", + "size": 3429, + "subdir": "linux-64", + "timestamp": 1532470455646, + "version": "1.9.0" + }, + "tensorflow-1.9.0-mkl_py36h6d6ce78_1.conda": { + "build": "mkl_py36h6d6ce78_1", + "build_number": 1, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "python 3.6.*", + "tensorboard >=1.9.0,<1.10.0", + "tensorflow-base ==1.9.0 mkl_py36h2ca6a6a_0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b4c8128300cc287a8f2ed26ceedb81b1", + "name": "tensorflow", + "namespace": "python", + "sha256": "5d77d2fbd3e51363e7205833afa2229c94a46dcef23b50c4ba0bc0410ab04286", + "size": 3255, + "subdir": "linux-64", + "timestamp": 1532705099883, + "version": "1.9.0" + }, + "tensorflow-2.0.0-eigen_py27hec4e49e_0.conda": { + "build": "eigen_py27hec4e49e_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 2.7.*", + "tensorboard >=2.0.0", + "tensorflow-base 2.0.0 eigen_py27hce92a77_0", + "tensorflow-estimator >=2.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "61713d75d4bf2a30872e19b573b86e3d", + "name": "tensorflow", + "namespace": "python", + "sha256": "2ab1ef00cad3c47596e7053b47dda18083ec4c738cddea008637d22497224b90", + "size": 3692, + "subdir": "linux-64", + "timestamp": 1571761788108, + "version": "2.0.0" + }, + "tensorflow-2.0.0-eigen_py36ha83d16c_0.conda": { + "build": "eigen_py36ha83d16c_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.6.*", + "tensorboard >=2.0.0", + "tensorflow-base 2.0.0 eigen_py36h4ed9498_0", + "tensorflow-estimator >=2.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "51c40270100d1c581579678da8fd5b43", + "name": "tensorflow", + "namespace": "python", + "sha256": "6b63fedcba8b830e2f95b9ed76dfee8a9176f2d299457202699063cb61164193", + "size": 3679, + "subdir": "linux-64", + "timestamp": 1571761804510, + "version": "2.0.0" + }, + "tensorflow-2.0.0-eigen_py37hce6be7f_0.conda": { + "build": "eigen_py37hce6be7f_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard >=2.0.0", + "tensorflow-base 2.0.0 eigen_py37h4ed9498_0", + "tensorflow-estimator >=2.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7f5f3fb74314525a465bf2cf2025aae7", + "name": "tensorflow", + "namespace": "python", + "sha256": "72a7d6fa485253d0473d75bdc2c1f4278a80fa20ba42e32ced039ad16876dbc1", + "size": 3691, + "subdir": "linux-64", + "timestamp": 1571761828151, + "version": "2.0.0" + }, + "tensorflow-2.0.0-gpu_py27hb041a2f_0.conda": { + "build": "gpu_py27hb041a2f_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 2.7.*", + "tensorboard >=2.0.0", + "tensorflow-base 2.0.0 gpu_py27h356bb79_0", + "tensorflow-estimator >=2.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2b8b4b5f91391c3b7e51d2b85f7f92ae", + "name": "tensorflow", + "namespace": "python", + "sha256": "c5fe90346be09c0b2c1883f64047cba18f0c0301f9284c97a14add47ddac9f7a", + "size": 3692, + "subdir": "linux-64", + "timestamp": 1571762070716, + "version": "2.0.0" + }, + "tensorflow-2.0.0-gpu_py36h6b29c10_0.conda": { + "build": "gpu_py36h6b29c10_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.6.*", + "tensorboard >=2.0.0", + "tensorflow-base 2.0.0 gpu_py36h0ec5d1f_0", + "tensorflow-estimator >=2.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1651c588c5108e76d9cb5db8e007656b", + "name": "tensorflow", + "namespace": "python", + "sha256": "98f5ad0758092e4f71ce1af244f2f84ed72a310410297cabb9ed145c940ffcf2", + "size": 3683, + "subdir": "linux-64", + "timestamp": 1571762090866, + "version": "2.0.0" + }, + "tensorflow-2.0.0-gpu_py37h768510d_0.conda": { + "build": "gpu_py37h768510d_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.7.*", + "tensorboard >=2.0.0", + "tensorflow-base 2.0.0 gpu_py37h0ec5d1f_0", + "tensorflow-estimator >=2.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a8f2122ab76b07a1587275428f971ba6", + "name": "tensorflow", + "namespace": "python", + "sha256": "046b558ccf88ab3af0c5faaa47bf96d1eaad7691d822ac7e7228e1778a14fcc3", + "size": 3691, + "subdir": "linux-64", + "timestamp": 1571762052693, + "version": "2.0.0" + }, + "tensorflow-2.0.0-mkl_py27h68eb67f_0.conda": { + "build": "mkl_py27h68eb67f_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 2.7.*", + "tensorboard >=2.0.0", + "tensorflow-base 2.0.0 mkl_py27had7a488_0", + "tensorflow-estimator >=2.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d7c8afe3ece678aeebe17e713d512340", + "name": "tensorflow", + "namespace": "python", + "sha256": "8ca56c4b123e9098432138d0f1154262718316a09e614ed8b4cdd837db0783f0", + "size": 3684, + "subdir": "linux-64", + "timestamp": 1571761771304, + "version": "2.0.0" + }, + "tensorflow-2.0.0-mkl_py36hef7ec59_0.conda": { + "build": "mkl_py36hef7ec59_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.6.*", + "tensorboard >=2.0.0", + "tensorflow-base 2.0.0 mkl_py36h9204916_0", + "tensorflow-estimator >=2.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3f5c05c4a5e0828ea489ce259de56346", + "name": "tensorflow", + "namespace": "python", + "sha256": "02062e70bf48970c6c2cab48abc98cb65a4a39ad891654dd391491ebc5f20630", + "size": 3669, + "subdir": "linux-64", + "timestamp": 1571761865200, + "version": "2.0.0" + }, + "tensorflow-2.0.0-mkl_py37h66b46cc_0.conda": { + "build": "mkl_py37h66b46cc_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard >=2.0.0", + "tensorflow-base 2.0.0 mkl_py37h9204916_0", + "tensorflow-estimator >=2.0.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0885110dd1d4d886c31c84d2bd046564", + "name": "tensorflow", + "namespace": "python", + "sha256": "c8c9d2fb917bed7a6fd563f423029fe3f2a3763246ba4037103afd3f5affde2e", + "size": 3679, + "subdir": "linux-64", + "timestamp": 1571761848920, + "version": "2.0.0" + }, + "tensorflow-2.1.0-eigen_py27h636cc2a_0.conda": { + "build": "eigen_py27h636cc2a_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 2.7.*", + "tensorboard >=2.1.0", + "tensorflow-base 2.1.0 eigen_py27hedad41d_0", + "tensorflow-estimator >=2.1.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3386260cbe3c70a20b9954e9e051f97f", + "name": "tensorflow", + "namespace": "python", + "sha256": "92ddf74e0502be5ee9b4678c702168c969140c62f23b0c6455d36cd4ec8fa7ea", + "size": 4584, + "subdir": "linux-64", + "timestamp": 1582050527352, + "version": "2.1.0" + }, + "tensorflow-2.1.0-eigen_py36hbb90eaf_0.conda": { + "build": "eigen_py36hbb90eaf_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.6.*", + "tensorboard >=2.1.0", + "tensorflow-base 2.1.0 eigen_py36h0c57e5d_0", + "tensorflow-estimator >=2.1.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e284f987adc7630d27158be0459a67c9", + "name": "tensorflow", + "namespace": "python", + "sha256": "f07057e117574669e49dcd45857b98562a15123c7ec1f607f2eadc0aa3c3faca", + "size": 4565, + "subdir": "linux-64", + "timestamp": 1582050492515, + "version": "2.1.0" + }, + "tensorflow-2.1.0-eigen_py37h1a52d58_0.conda": { + "build": "eigen_py37h1a52d58_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard >=2.1.0", + "tensorflow-base 2.1.0 eigen_py37h0c57e5d_0", + "tensorflow-estimator >=2.1.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ab951de0d8cb8ef576833e06845575fc", + "name": "tensorflow", + "namespace": "python", + "sha256": "c6f4e977d78a1436e60e190fbf3da2dfc373b96ca8c22494a0cc0f1ca5cc3146", + "size": 4571, + "subdir": "linux-64", + "timestamp": 1582050647441, + "version": "2.1.0" + }, + "tensorflow-2.1.0-gpu_py27h9cdf9a9_0.conda": { + "build": "gpu_py27h9cdf9a9_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 2.7.*", + "tensorboard >=2.1.0", + "tensorflow-base 2.1.0 gpu_py27hb9b3ea8_0", + "tensorflow-estimator >=2.1.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fda61f7f41f4c34b2bc746da0d2ee5a1", + "name": "tensorflow", + "namespace": "python", + "sha256": "5e9607ad9ab090052c1808d4b3f45eca1273944200f4f9d2711604791d38976d", + "size": 4197, + "subdir": "linux-64", + "timestamp": 1582138611291, + "version": "2.1.0" + }, + "tensorflow-2.1.0-gpu_py36h2e5cdaa_0.conda": { + "build": "gpu_py36h2e5cdaa_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.6.*", + "tensorboard >=2.1.0", + "tensorflow-base 2.1.0 gpu_py36h6c5654b_0", + "tensorflow-estimator >=2.1.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "def43369724eb28e2b0ce49b3f52b65e", + "name": "tensorflow", + "namespace": "python", + "sha256": "38798164f8f55992b00cc42da2d53ec0277ae50c875c6a863ae828b737df7a4b", + "size": 3832, + "subdir": "linux-64", + "timestamp": 1582138639872, + "version": "2.1.0" + }, + "tensorflow-2.1.0-gpu_py37h7a4bb67_0.conda": { + "build": "gpu_py37h7a4bb67_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.7.*", + "tensorboard >=2.1.0", + "tensorflow-base 2.1.0 gpu_py37h6c5654b_0", + "tensorflow-estimator >=2.1.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a9f4aa05160f0869e92581f16245c646", + "name": "tensorflow", + "namespace": "python", + "sha256": "e7f6b02dcd99cb1d80675067440051a5d624913ea55848a48845a9c4cad4613c", + "size": 4199, + "subdir": "linux-64", + "timestamp": 1582138667928, + "version": "2.1.0" + }, + "tensorflow-2.1.0-mkl_py27h9dbd782_0.conda": { + "build": "mkl_py27h9dbd782_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 2.7.*", + "tensorboard >=2.1.0", + "tensorflow-base 2.1.0 mkl_py27hb6fb96e_0", + "tensorflow-estimator >=2.1.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2fed6c3d194f9323c7d8f6137f3cf000", + "name": "tensorflow", + "namespace": "python", + "sha256": "4284744ca362113be67460aa743c0689ff61d4be4a0e0edb9d6b73b36fd3f2a9", + "size": 4550, + "subdir": "linux-64", + "timestamp": 1582050559711, + "version": "2.1.0" + }, + "tensorflow-2.1.0-mkl_py36h23468d9_0.conda": { + "build": "mkl_py36h23468d9_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.6.*", + "tensorboard >=2.1.0", + "tensorflow-base 2.1.0 mkl_py36h6d63fb7_0", + "tensorflow-estimator >=2.1.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bcf5ed04251c37c02996d15cdb6ec891", + "name": "tensorflow", + "namespace": "python", + "sha256": "31b465ad34c4790ea26b170d6998ba138ccbf9f6bc52610411978f43c641cba7", + "size": 4555, + "subdir": "linux-64", + "timestamp": 1582050588078, + "version": "2.1.0" + }, + "tensorflow-2.1.0-mkl_py37h80a91df_0.conda": { + "build": "mkl_py37h80a91df_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard >=2.1.0", + "tensorflow-base 2.1.0 mkl_py37h6d63fb7_0", + "tensorflow-estimator >=2.1.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "41c92825f6229955eceb54ba7b8164ed", + "name": "tensorflow", + "namespace": "python", + "sha256": "c6b93c6f45b34babae9857dd8839a7f6cc1627378341cbe94fc9d652183c34d6", + "size": 4551, + "subdir": "linux-64", + "timestamp": 1582050615831, + "version": "2.1.0" + }, + "tensorflow-2.10.0-eigen_py310h7dfe345_0.conda": { + "build": "eigen_py310h7dfe345_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.10.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 eigen_py310h1969d1f_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "132d7082d5550affdaaaf83723c11f1a", + "name": "tensorflow", + "namespace": "python", + "sha256": "9c9d9b8d5814bb04c2d6cd00ac1c104a6e4d9dba44ace1ad952c1d758797d887", + "size": 4357, + "subdir": "linux-64", + "timestamp": 1667220553220, + "version": "2.10.0" + }, + "tensorflow-2.10.0-eigen_py37ha43bb76_0.conda": { + "build": "eigen_py37ha43bb76_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 eigen_py37h1969d1f_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "535098ca769b797aeb06c2a1b895dda6", + "name": "tensorflow", + "namespace": "python", + "sha256": "7713697f97bd82b60abdf537b35c90cb409cfebc3b0e6aa5bdefce339e45367c", + "size": 4334, + "subdir": "linux-64", + "timestamp": 1667220731107, + "version": "2.10.0" + }, + "tensorflow-2.10.0-eigen_py38h77fcdc8_0.conda": { + "build": "eigen_py38h77fcdc8_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.8.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 eigen_py38h1969d1f_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7a3a6579d53b68323522dc5a5047566a", + "name": "tensorflow", + "namespace": "python", + "sha256": "cdb8bcbe53d99d2fab722ed8da1b04f1e29588154f0451565b64dccdfe1f876e", + "size": 4358, + "subdir": "linux-64", + "timestamp": 1667220578018, + "version": "2.10.0" + }, + "tensorflow-2.10.0-eigen_py39he2aad1f_0.conda": { + "build": "eigen_py39he2aad1f_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.9.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 eigen_py39h1969d1f_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "98720b83f65c4033cb88bb72f7881218", + "name": "tensorflow", + "namespace": "python", + "sha256": "83b4409500161e48f0543490b32c68cb0cb3ece30d2cf9ca174fc1348b04a04d", + "size": 4347, + "subdir": "linux-64", + "timestamp": 1667220705751, + "version": "2.10.0" + }, + "tensorflow-2.10.0-gpu_py310hb074053_0.conda": { + "build": "gpu_py310hb074053_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.10.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 gpu_py310h6559e04_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "88b29df2358bf0ae15cc7b806a191fa7", + "name": "tensorflow", + "namespace": "python", + "sha256": "ae72f567da87724ff9c3d98be84ce0a0ea6df345238f3abe7d699e4193ce0f91", + "size": 4342, + "subdir": "linux-64", + "timestamp": 1667223001471, + "version": "2.10.0" + }, + "tensorflow-2.10.0-gpu_py37h84cb581_0.conda": { + "build": "gpu_py37h84cb581_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.7.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 gpu_py37h6559e04_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b7031ca7ce939edd4cb1035bfcb3b4ef", + "name": "tensorflow", + "namespace": "python", + "sha256": "c4c6c9dbd922db6905c79b92c46eb7e93158aec0da5debb32a2d7075b7ff2ae3", + "size": 4330, + "subdir": "linux-64", + "timestamp": 1667222974576, + "version": "2.10.0" + }, + "tensorflow-2.10.0-gpu_py38h11b98a5_0.conda": { + "build": "gpu_py38h11b98a5_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.8.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 gpu_py38h6559e04_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "39f24c3eec3f23e4d4e35a24e6420062", + "name": "tensorflow", + "namespace": "python", + "sha256": "229126309fc21eccaadbfcd2989d306d1c3b93dcded05e02dc705ff679ada4be", + "size": 4332, + "subdir": "linux-64", + "timestamp": 1667222916616, + "version": "2.10.0" + }, + "tensorflow-2.10.0-gpu_py39h039f4ff_0.conda": { + "build": "gpu_py39h039f4ff_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.9.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 gpu_py39h6559e04_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "539e734aa2b2f4335e93c38ceaec0bb1", + "name": "tensorflow", + "namespace": "python", + "sha256": "d1497ac4e6bcccd09dba70b88ae64f3041826c48233b2833e9664a4c331fe9d3", + "size": 4336, + "subdir": "linux-64", + "timestamp": 1667222946598, + "version": "2.10.0" + }, + "tensorflow-2.10.0-mkl_py310h24f4fea_0.conda": { + "build": "mkl_py310h24f4fea_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.10.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 mkl_py310hb9daa73_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "425e3461eb5c4ff9811c17929cbc3ac7", + "name": "tensorflow", + "namespace": "python", + "sha256": "33ab0737b40f8462ed9c2379b06c58351fb16450ac67b027c3e7eb7817f67e4d", + "size": 4343, + "subdir": "linux-64", + "timestamp": 1667220655108, + "version": "2.10.0" + }, + "tensorflow-2.10.0-mkl_py37h5d113c5_0.conda": { + "build": "mkl_py37h5d113c5_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 mkl_py37hb9daa73_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a1aab785c359bf064a7320dd79a757d4", + "name": "tensorflow", + "namespace": "python", + "sha256": "5949821c7ed74ac8a55f16cfaa23c56c4be3e55b7bce950c38d9d39dc2b57676", + "size": 4335, + "subdir": "linux-64", + "timestamp": 1667220679864, + "version": "2.10.0" + }, + "tensorflow-2.10.0-mkl_py38hd2379f1_0.conda": { + "build": "mkl_py38hd2379f1_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 mkl_py38hb9daa73_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f077f3fb44cd204bf8561f3eb2012591", + "name": "tensorflow", + "namespace": "python", + "sha256": "b40729c1baf3d948fe691673b6894be97f948b2eef8028058cdb1d154181e1be", + "size": 4331, + "subdir": "linux-64", + "timestamp": 1667220604036, + "version": "2.10.0" + }, + "tensorflow-2.10.0-mkl_py39hdc5b6f4_0.conda": { + "build": "mkl_py39hdc5b6f4_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.9.*", + "tensorboard 2.10.*", + "tensorflow-base 2.10.0 mkl_py39hb9daa73_0", + "tensorflow-estimator 2.10.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bfc78d2d193ae753935529dbe0e498d6", + "name": "tensorflow", + "namespace": "python", + "sha256": "4e5e8344ed4afd3a14e466eba25bfc7f6e132c1f43ce2543e290a039bed536f0", + "size": 4334, + "subdir": "linux-64", + "timestamp": 1667220628893, + "version": "2.10.0" + }, + "tensorflow-2.11.0-eigen_py310h0f08fec_0.conda": { + "build": "eigen_py310h0f08fec_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.10.*", + "tensorboard 2.11.*", + "tensorflow-base 2.11.0 eigen_py310h3323580_0", + "tensorflow-estimator 2.11.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f9486287509ce7b267072dc737f610a8", + "name": "tensorflow", + "namespace": "python", + "sha256": "6ed94e52de5d33f13e2a6c4acd2ca7543f6439358fa2eac32bcba3c854b5fc2b", + "size": 4484, + "subdir": "linux-64", + "timestamp": 1678394799352, + "version": "2.11.0" + }, + "tensorflow-2.11.0-eigen_py38h370c993_0.conda": { + "build": "eigen_py38h370c993_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.8.*", + "tensorboard 2.11.*", + "tensorflow-base 2.11.0 eigen_py38h3323580_0", + "tensorflow-estimator 2.11.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "32c566da81f812a21cd356e44e147912", + "name": "tensorflow", + "namespace": "python", + "sha256": "a31ca1031dfcbc66c66eed05284c31bfc3118f0a7f3058d1535bfa766d8aa05b", + "size": 4470, + "subdir": "linux-64", + "timestamp": 1678394704521, + "version": "2.11.0" + }, + "tensorflow-2.11.0-eigen_py39h76f29f1_0.conda": { + "build": "eigen_py39h76f29f1_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.9.*", + "tensorboard 2.11.*", + "tensorflow-base 2.11.0 eigen_py39h3323580_0", + "tensorflow-estimator 2.11.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c340cdfcaf08e30f7bc4c0545fdd66b4", + "name": "tensorflow", + "namespace": "python", + "sha256": "0ee1f93bf339c4fe1e0cf49b0f1a261ffbd149223b44addedf93103b754f43c7", + "size": 4478, + "subdir": "linux-64", + "timestamp": 1678394727807, + "version": "2.11.0" + }, + "tensorflow-2.11.0-gpu_py310hf8ff8df_0.conda": { + "build": "gpu_py310hf8ff8df_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.10.*", + "tensorboard 2.11.*", + "tensorflow-base 2.11.0 gpu_py310h24d65da_0", + "tensorflow-estimator 2.11.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "80568ce073457dc7f0275043968db56a", + "name": "tensorflow", + "namespace": "python", + "sha256": "b6e3a5e0cd00a85274986385b367e014815c12ee9e00cc4904c47d54f37708fa", + "size": 4475, + "subdir": "linux-64", + "timestamp": 1678395062356, + "version": "2.11.0" + }, + "tensorflow-2.11.0-gpu_py38hec62255_0.conda": { + "build": "gpu_py38hec62255_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.8.*", + "tensorboard 2.11.*", + "tensorflow-base 2.11.0 gpu_py38h24d65da_0", + "tensorflow-estimator 2.11.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "705a0c1c227814dbfb5bbef0e2a9d2fe", + "name": "tensorflow", + "namespace": "python", + "sha256": "41628d2b6a365e782aade3645082633f4242f92590a59e7127f4ccb96661d1ca", + "size": 4456, + "subdir": "linux-64", + "timestamp": 1678395035057, + "version": "2.11.0" + }, + "tensorflow-2.11.0-gpu_py39h6d58c08_0.conda": { + "build": "gpu_py39h6d58c08_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.9.*", + "tensorboard 2.11.*", + "tensorflow-base 2.11.0 gpu_py39h24d65da_0", + "tensorflow-estimator 2.11.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7a776351b27570125dce246133ff64d1", + "name": "tensorflow", + "namespace": "python", + "sha256": "114ed07e6851321137e2b77c716c90380d542dde8205a1f4092ca6f4c754c14f", + "size": 4454, + "subdir": "linux-64", + "timestamp": 1678395006472, + "version": "2.11.0" + }, + "tensorflow-2.11.0-mkl_py310hb40ee82_0.conda": { + "build": "mkl_py310hb40ee82_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.10.*", + "tensorboard 2.11.*", + "tensorflow-base 2.11.0 mkl_py310he5f8e37_0", + "tensorflow-estimator 2.11.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "030548f3c75b670e2270eb72d0fb0156", + "name": "tensorflow", + "namespace": "python", + "sha256": "dd5ca3701806baa86b54a26ce54855fcd1045490326097a69efdbfaadf6c6dbd", + "size": 4481, + "subdir": "linux-64", + "timestamp": 1678394775156, + "version": "2.11.0" + }, + "tensorflow-2.11.0-mkl_py38hda6d4db_0.conda": { + "build": "mkl_py38hda6d4db_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard 2.11.*", + "tensorflow-base 2.11.0 mkl_py38he5f8e37_0", + "tensorflow-estimator 2.11.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6202e8ccc3bd01d2e465cd1998d8c68c", + "name": "tensorflow", + "namespace": "python", + "sha256": "b2e20e74ffbe3d925fcd9ca6325865398accd2b2ed925ee7679a99a8d869448b", + "size": 4469, + "subdir": "linux-64", + "timestamp": 1678394677659, + "version": "2.11.0" + }, + "tensorflow-2.11.0-mkl_py39hea27e05_0.conda": { + "build": "mkl_py39hea27e05_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.9.*", + "tensorboard 2.11.*", + "tensorflow-base 2.11.0 mkl_py39he5f8e37_0", + "tensorflow-estimator 2.11.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "862e26cf4e7eb59b91e29e6c837a4d0b", + "name": "tensorflow", + "namespace": "python", + "sha256": "467e1001ae36b3a29b9aebdea350d0c8e5a6e1ba1a9af20e8715c73ee6333c46", + "size": 4472, + "subdir": "linux-64", + "timestamp": 1678394753369, + "version": "2.11.0" + }, + "tensorflow-2.2.0-eigen_py36h84d285f_0.conda": { + "build": "eigen_py36h84d285f_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.6.*", + "tensorboard >=2.2.0", + "tensorflow-base 2.2.0 eigen_py36haef3446_0", + "tensorflow-estimator >=2.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "56a37de1a7c38efd25ee5b86aef1c49a", + "name": "tensorflow", + "namespace": "python", + "sha256": "0bc0bed3350997094653df8692d88a58776c4f573840a3c00d203105f8ece7ee", + "size": 4084, + "subdir": "linux-64", + "timestamp": 1590158763636, + "version": "2.2.0" + }, + "tensorflow-2.2.0-eigen_py37h1b16bb3_0.conda": { + "build": "eigen_py37h1b16bb3_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard >=2.2.0", + "tensorflow-base 2.2.0 eigen_py37haef3446_0", + "tensorflow-estimator >=2.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a019ea7b104cf17d7b5a5abb0365f8c3", + "name": "tensorflow", + "namespace": "python", + "sha256": "912163985675892747cb74bf93dcee10c6f24af002cd472408ff92c633ab3fe6", + "size": 4065, + "subdir": "linux-64", + "timestamp": 1590158673573, + "version": "2.2.0" + }, + "tensorflow-2.2.0-eigen_py38hfc6e53c_0.conda": { + "build": "eigen_py38hfc6e53c_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.8.*", + "tensorboard >=2.2.0", + "tensorflow-base 2.2.0 eigen_py38h2e5f744_0", + "tensorflow-estimator >=2.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b2752ee293cb01b586172be727c16eaf", + "name": "tensorflow", + "namespace": "python", + "sha256": "423bf3ef9cd56f16bb0a0df8ed18eae63b93d70028f77764ad7246dc8963e726", + "size": 4085, + "subdir": "linux-64", + "timestamp": 1590158640929, + "version": "2.2.0" + }, + "tensorflow-2.2.0-gpu_py36hf933387_0.conda": { + "build": "gpu_py36hf933387_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.6.*", + "tensorboard >=2.2.0", + "tensorflow-base 2.2.0 gpu_py36h8a81be8_0", + "tensorflow-estimator >=2.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1e8a41aaa6a6bbcc2fe288cfa64bb7e9", + "name": "tensorflow", + "namespace": "python", + "sha256": "8f9e3503b48a8ddae48959e96c29da3e210c69cbd0a399fde3551099ae3adac3", + "size": 4338, + "subdir": "linux-64", + "timestamp": 1590183046255, + "version": "2.2.0" + }, + "tensorflow-2.2.0-gpu_py37h1a511ff_0.conda": { + "build": "gpu_py37h1a511ff_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.7.*", + "tensorboard >=2.2.0", + "tensorflow-base 2.2.0 gpu_py37h8a81be8_0", + "tensorflow-estimator >=2.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bc308bb2e99c0d3275b1f12272bd723a", + "name": "tensorflow", + "namespace": "python", + "sha256": "8d713c0293ce12de84f63db8a02c5c255b4fe47b88a704d6232e6143663b7170", + "size": 4351, + "subdir": "linux-64", + "timestamp": 1590183063377, + "version": "2.2.0" + }, + "tensorflow-2.2.0-gpu_py38hb782248_0.conda": { + "build": "gpu_py38hb782248_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.8.*", + "tensorboard >=2.2.0", + "tensorflow-base 2.2.0 gpu_py38h83e3d50_0", + "tensorflow-estimator >=2.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3a5f1d5023c1548e9a2a533f202b72be", + "name": "tensorflow", + "namespace": "python", + "sha256": "f6076fce19707283d93cea2369a2a2ef57a173e44033b40b8f1103acf16c569b", + "size": 4362, + "subdir": "linux-64", + "timestamp": 1590182966494, + "version": "2.2.0" + }, + "tensorflow-2.2.0-mkl_py36h5a57954_0.conda": { + "build": "mkl_py36h5a57954_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.6.*", + "tensorboard >=2.2.0", + "tensorflow-base 2.2.0 mkl_py36hd506778_0", + "tensorflow-estimator >=2.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b0f0d249bfb5f2aaafe3ad9a333f0166", + "name": "tensorflow", + "namespace": "python", + "sha256": "7fb6202f8b2d52b4c4efddf378e233be699cfe4c5caae5c8226ec43fb8225ef1", + "size": 4069, + "subdir": "linux-64", + "timestamp": 1590158819808, + "version": "2.2.0" + }, + "tensorflow-2.2.0-mkl_py37h6e9ce2d_0.conda": { + "build": "mkl_py37h6e9ce2d_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard >=2.2.0", + "tensorflow-base 2.2.0 mkl_py37hd506778_0", + "tensorflow-estimator >=2.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "52266de442380e29393a6aae48bf2f32", + "name": "tensorflow", + "namespace": "python", + "sha256": "94f81cd5fb117f696697b71490e15691c2811bcfcd9f81c30b8b5301d566528b", + "size": 4072, + "subdir": "linux-64", + "timestamp": 1590158706131, + "version": "2.2.0" + }, + "tensorflow-2.2.0-mkl_py38h6d3daf0_0.conda": { + "build": "mkl_py38h6d3daf0_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard >=2.2.0", + "tensorflow-base 2.2.0 mkl_py38h5059a2d_0", + "tensorflow-estimator >=2.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7727fcc9a7e92c6ed82f4fd1597eac7e", + "name": "tensorflow", + "namespace": "python", + "sha256": "95071deb0bc5fdd34cd7447944aa61764fde5b2037c75445467f7fb5fe45aa3b", + "size": 4059, + "subdir": "linux-64", + "timestamp": 1590158803754, + "version": "2.2.0" + }, + "tensorflow-2.3.0-eigen_py37h189e6a2_0.conda": { + "build": "eigen_py37h189e6a2_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 eigen", + "python 3.7.*", + "tensorboard >=2.3.0", + "tensorflow-base 2.3.0 eigen_py37h3b305d7_0", + "tensorflow-estimator >=2.3.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b97790e5e076d2f03b35bd1fa6aec671", + "name": "tensorflow", + "namespace": "python", + "sha256": "dd32744cd0c677f23e4599a23d682cfd61c46771a2424205a2c088974795dd0e", + "size": 3847, + "subdir": "linux-64", + "timestamp": 1604315799761, + "version": "2.3.0" + }, + "tensorflow-2.3.0-eigen_py38h71ff20e_0.conda": { + "build": "eigen_py38h71ff20e_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 eigen", + "python 3.8.*", + "tensorboard >=2.3.0", + "tensorflow-base 2.3.0 eigen_py38hb57a387_0", + "tensorflow-estimator >=2.3.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "eba3bcf3c48fb6554a3aa813c397e401", + "name": "tensorflow", + "namespace": "python", + "sha256": "a6f435fe0a4953468c47e0ac2046e0c056df665ee918c199b4371942bb6ac439", + "size": 3839, + "subdir": "linux-64", + "timestamp": 1604315778375, + "version": "2.3.0" + }, + "tensorflow-2.3.0-mkl_py37h0481017_0.conda": { + "build": "mkl_py37h0481017_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard >=2.3.0", + "tensorflow-base 2.3.0 mkl_py37he9661a2_0", + "tensorflow-estimator >=2.3.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ef9cb1e49f32a7ef354f94d934fe5b6f", + "name": "tensorflow", + "namespace": "python", + "sha256": "2a172300553fc2d2bfd22f469c7324ce65026441fecbbe05ef869486c409b393", + "size": 3838, + "subdir": "linux-64", + "timestamp": 1604315759116, + "version": "2.3.0" + }, + "tensorflow-2.3.0-mkl_py38hd53216f_0.conda": { + "build": "mkl_py38hd53216f_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard >=2.3.0", + "tensorflow-base 2.3.0 mkl_py38hac35e67_0", + "tensorflow-estimator >=2.3.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b970af44fdbe79e9f03032b618166025", + "name": "tensorflow", + "namespace": "python", + "sha256": "d632cc276f0096a02c433e3d7d0415afc0a9fc51af37c8725d3e3a8298eb1a84", + "size": 3849, + "subdir": "linux-64", + "timestamp": 1604315739346, + "version": "2.3.0" + }, + "tensorflow-2.4.1-eigen_py37h3da6045_0.conda": { + "build": "eigen_py37h3da6045_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard >=2.4.0", + "tensorflow-base 2.4.1 eigen_py37h17880bf_0", + "tensorflow-estimator >=2.4.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a3fd04d6633ef133bc269e5cee01a0cb", + "name": "tensorflow", + "namespace": "python", + "sha256": "242bb4401d6815f0723980d1c3e871731b2cccd2472823282f4041a0160a26a0", + "size": 3681, + "subdir": "linux-64", + "timestamp": 1614594522842, + "version": "2.4.1" + }, + "tensorflow-2.4.1-eigen_py38h0e0807f_0.conda": { + "build": "eigen_py38h0e0807f_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.8.*", + "tensorboard >=2.4.0", + "tensorflow-base 2.4.1 eigen_py38h17880bf_0", + "tensorflow-estimator >=2.4.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "859af976e77f1954327c371341182df3", + "name": "tensorflow", + "namespace": "python", + "sha256": "30a6fddefcbfefb45c0ac908bf793172607c3b53a37d74fe77d219aa15880aad", + "size": 3688, + "subdir": "linux-64", + "timestamp": 1614594418602, + "version": "2.4.1" + }, + "tensorflow-2.4.1-eigen_py39h813c054_0.conda": { + "build": "eigen_py39h813c054_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.9.*", + "tensorboard >=2.4.0", + "tensorflow-base 2.4.1 eigen_py39h17880bf_0", + "tensorflow-estimator >=2.4.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6f820bc952a822408a5c0b3c35fce93f", + "name": "tensorflow", + "namespace": "python", + "sha256": "817eb04f8c05e5ab0d8e0c173599b9c0b530e69ddbfa6b3fc24bbe26ce3ce46f", + "size": 3687, + "subdir": "linux-64", + "timestamp": 1614594438484, + "version": "2.4.1" + }, + "tensorflow-2.4.1-gpu_py37ha2e99fa_0.conda": { + "build": "gpu_py37ha2e99fa_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.7.*", + "tensorboard >=2.4.0", + "tensorflow-base 2.4.1 gpu_py37h29c2da4_0", + "tensorflow-estimator >=2.4.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9dc4c58bbf391a0ded230fc2bd3ac71f", + "name": "tensorflow", + "namespace": "python", + "sha256": "49d7d173de303b7e7f0affaf8c1882cfbbed4ad6193236d5bcc5e215ef54661c", + "size": 3679, + "subdir": "linux-64", + "timestamp": 1614594751591, + "version": "2.4.1" + }, + "tensorflow-2.4.1-gpu_py38h8a7d6ce_0.conda": { + "build": "gpu_py38h8a7d6ce_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.8.*", + "tensorboard >=2.4.0", + "tensorflow-base 2.4.1 gpu_py38h29c2da4_0", + "tensorflow-estimator >=2.4.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2917a59197d011544601f630aa90f76a", + "name": "tensorflow", + "namespace": "python", + "sha256": "84624c2189705c07a2a61c39aecb5f1052a8cfc9a3873e893829ed90c954ed28", + "size": 3685, + "subdir": "linux-64", + "timestamp": 1614594675767, + "version": "2.4.1" + }, + "tensorflow-2.4.1-gpu_py39h8236f22_0.conda": { + "build": "gpu_py39h8236f22_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.9.*", + "tensorboard >=2.4.0", + "tensorflow-base 2.4.1 gpu_py39h29c2da4_0", + "tensorflow-estimator >=2.4.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ed69523b3e88b6560d645589039e5c18", + "name": "tensorflow", + "namespace": "python", + "sha256": "88131ca90cd4a31cb9d050089a6e4b780125422694e1dbc039975ded7d19c553", + "size": 3689, + "subdir": "linux-64", + "timestamp": 1614594600986, + "version": "2.4.1" + }, + "tensorflow-2.4.1-mkl_py37h2d14ff2_0.conda": { + "build": "mkl_py37h2d14ff2_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard >=2.4.0", + "tensorflow-base 2.4.1 mkl_py37h43e0292_0", + "tensorflow-estimator >=2.4.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5c7d9d2a6ff18d33d8f0a14785ad116c", + "name": "tensorflow", + "namespace": "python", + "sha256": "40e66f004d4c34467ff08ff8252c38bd1498b4586dcec049e37c3677a052d7ac", + "size": 3676, + "subdir": "linux-64", + "timestamp": 1614594396271, + "version": "2.4.1" + }, + "tensorflow-2.4.1-mkl_py38hb2083e0_0.conda": { + "build": "mkl_py38hb2083e0_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard >=2.4.0", + "tensorflow-base 2.4.1 mkl_py38h43e0292_0", + "tensorflow-estimator >=2.4.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d886bcf5ecfc94b11a675033cd7ace32", + "name": "tensorflow", + "namespace": "python", + "sha256": "acd0f58b932855c95e6bb4992b06a40f7ac9647e94a117427ed3962e5200c691", + "size": 3685, + "subdir": "linux-64", + "timestamp": 1614594480229, + "version": "2.4.1" + }, + "tensorflow-2.4.1-mkl_py39h4683426_0.conda": { + "build": "mkl_py39h4683426_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.9.*", + "tensorboard >=2.4.0", + "tensorflow-base 2.4.1 mkl_py39h43e0292_0", + "tensorflow-estimator >=2.4.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7ec752d8a6872f8cedb92c01762cbd59", + "name": "tensorflow", + "namespace": "python", + "sha256": "405968a2e14b538bc432a979c7f35088d9bb1dbf3063105fe94ecda1a0c5f546", + "size": 3683, + "subdir": "linux-64", + "timestamp": 1614594375026, + "version": "2.4.1" + }, + "tensorflow-2.5.0-eigen_py37hff93566_0.conda": { + "build": "eigen_py37hff93566_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard >=2.5.0", + "tensorflow-base 2.5.0 eigen_py37h2b86b3d_0", + "tensorflow-estimator >=2.5.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bbd44097c6b4b488e676d5256b04c666", + "name": "tensorflow", + "namespace": "python", + "sha256": "9cbe31c005c350010e5318894d240e5eb93a0d3cf89fe8c0466570481eb61bae", + "size": 3623, + "subdir": "linux-64", + "timestamp": 1622187252921, + "version": "2.5.0" + }, + "tensorflow-2.5.0-eigen_py38h17aada3_0.conda": { + "build": "eigen_py38h17aada3_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.8.*", + "tensorboard >=2.5.0", + "tensorflow-base 2.5.0 eigen_py38h2b86b3d_0", + "tensorflow-estimator >=2.5.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "745c3780896cf9589f4382e0457862b9", + "name": "tensorflow", + "namespace": "python", + "sha256": "8d0fe31982049a8b130a2b7a211d07c80706cbc4f9326c31a39c27f65b0cfd69", + "size": 3631, + "subdir": "linux-64", + "timestamp": 1622187309332, + "version": "2.5.0" + }, + "tensorflow-2.5.0-eigen_py38h94feaef_0.conda": { + "build": "eigen_py38h94feaef_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard >=2.5.0", + "tensorflow-base 2.5.0 eigen_py38h2b86b3d_0", + "tensorflow-estimator >=2.5.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8a3204641396ed7e08652edd1a1f179b", + "name": "tensorflow", + "namespace": "python", + "sha256": "925260f6b57b5bc734ec3cdada0952742230d4b9b98bbdb3549ecb43ac3631fa", + "size": 3665, + "subdir": "linux-64", + "timestamp": 1622195191762, + "version": "2.5.0" + }, + "tensorflow-2.5.0-eigen_py39hd8d7d70_0.conda": { + "build": "eigen_py39hd8d7d70_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.9.*", + "tensorboard >=2.5.0", + "tensorflow-base 2.5.0 eigen_py39h2b86b3d_0", + "tensorflow-estimator >=2.5.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "124df76a6406184622a66d69a51c699a", + "name": "tensorflow", + "namespace": "python", + "sha256": "fe108f4039c621d01d262b75f95ce180db82668c40b44a0595522ca07d9b58b0", + "size": 3631, + "subdir": "linux-64", + "timestamp": 1622187292207, + "version": "2.5.0" + }, + "tensorflow-2.5.0-mkl_py37h3e8b3f4_0.conda": { + "build": "mkl_py37h3e8b3f4_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard >=2.5.0", + "tensorflow-base 2.5.0 mkl_py37h35b2a3d_0", + "tensorflow-estimator >=2.5.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6d87973bd9802eda37d08414b73994af", + "name": "tensorflow", + "namespace": "python", + "sha256": "0ab0e10a4e09658e639959b554cb2413320330d7096d52d1534735ad0a687ea1", + "size": 3619, + "subdir": "linux-64", + "timestamp": 1622187272817, + "version": "2.5.0" + }, + "tensorflow-2.5.0-mkl_py38hce4fbe1_0.conda": { + "build": "mkl_py38hce4fbe1_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard >=2.5.0", + "tensorflow-base 2.5.0 mkl_py38h35b2a3d_0", + "tensorflow-estimator >=2.5.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2f3545a69fba39e6ea5b081e74bb994c", + "name": "tensorflow", + "namespace": "python", + "sha256": "906648d3b040148e8933f745dfddfe0a5e860f8cf2b869a99be1ed30c79555cf", + "size": 3628, + "subdir": "linux-64", + "timestamp": 1622187232998, + "version": "2.5.0" + }, + "tensorflow-2.5.0-mkl_py39h4a0693c_0.conda": { + "build": "mkl_py39h4a0693c_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.9.*", + "tensorboard >=2.5.0", + "tensorflow-base 2.5.0 mkl_py39h35b2a3d_0", + "tensorflow-estimator >=2.5.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f9ed8d92bba36830dfa8d2694991d0d6", + "name": "tensorflow", + "namespace": "python", + "sha256": "ea9764369370843a220b289e25a37792121348e249e590ffb0fa1609a1f87078", + "size": 3627, + "subdir": "linux-64", + "timestamp": 1622187213415, + "version": "2.5.0" + }, + "tensorflow-2.6.0-eigen_py37h34b007a_0.conda": { + "build": "eigen_py37h34b007a_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard >=2.6.0", + "tensorflow-base 2.6.0 eigen_py37ha9cc040_0", + "tensorflow-estimator >=2.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2765cab48003cbb96d71c1e055766dc3", + "name": "tensorflow", + "namespace": "python", + "sha256": "a789690774240e6e336c1fbb7341a888c45fcc0b73d331086a81918ab734641b", + "size": 3818, + "subdir": "linux-64", + "timestamp": 1630523916628, + "version": "2.6.0" + }, + "tensorflow-2.6.0-eigen_py38hcc1cb13_0.conda": { + "build": "eigen_py38hcc1cb13_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.8.*", + "tensorboard >=2.6.0", + "tensorflow-base 2.6.0 eigen_py38ha9cc040_0", + "tensorflow-estimator >=2.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8a735de9469eed65d34215d2baff348a", + "name": "tensorflow", + "namespace": "python", + "sha256": "5505f35dd57b50270a082d9912bc6f10f125bb8995c75ce17db7d06bef16db1a", + "size": 3820, + "subdir": "linux-64", + "timestamp": 1630524011440, + "version": "2.6.0" + }, + "tensorflow-2.6.0-eigen_py39h4b72145_0.conda": { + "build": "eigen_py39h4b72145_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.9.*", + "tensorboard >=2.6.0", + "tensorflow-base 2.6.0 eigen_py39ha9cc040_0", + "tensorflow-estimator >=2.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2004065d58dc0512c343259c8c6e17e6", + "name": "tensorflow", + "namespace": "python", + "sha256": "cfb8cf0b202cc3247896a31bbf0b92f097cc6735fd6688031952e68f985807fc", + "size": 3822, + "subdir": "linux-64", + "timestamp": 1630523953144, + "version": "2.6.0" + }, + "tensorflow-2.6.0-mkl_py37h9d15365_0.conda": { + "build": "mkl_py37h9d15365_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard >=2.6.0", + "tensorflow-base 2.6.0 mkl_py37h3d85931_0", + "tensorflow-estimator >=2.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e1346b6edfb026ee6bd81d0fd0272e33", + "name": "tensorflow", + "namespace": "python", + "sha256": "252209dd5644da3ca208ddd64731c20fcce31d364becaaa389aadca9a9691438", + "size": 3814, + "subdir": "linux-64", + "timestamp": 1630523992000, + "version": "2.6.0" + }, + "tensorflow-2.6.0-mkl_py38h874c8e8_0.conda": { + "build": "mkl_py38h874c8e8_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard >=2.6.0", + "tensorflow-base 2.6.0 mkl_py38h3d85931_0", + "tensorflow-estimator >=2.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3b52427a7f824e5e612ad977560cc2e8", + "name": "tensorflow", + "namespace": "python", + "sha256": "62a221c205a81fdd5c2d54a5f86a3db266c464a996879f64c46ac3d63a49ca78", + "size": 3813, + "subdir": "linux-64", + "timestamp": 1630523972022, + "version": "2.6.0" + }, + "tensorflow-2.6.0-mkl_py39haac40d1_0.conda": { + "build": "mkl_py39haac40d1_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.9.*", + "tensorboard >=2.6.0", + "tensorflow-base 2.6.0 mkl_py39h3d85931_0", + "tensorflow-estimator >=2.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0853a4c6af0850704f9924dbef451024", + "name": "tensorflow", + "namespace": "python", + "sha256": "14ece3bdf2435b65e89453cf7fcd30e3f489692d3cd3cf6780882bb4476cd2f4", + "size": 3814, + "subdir": "linux-64", + "timestamp": 1630523936225, + "version": "2.6.0" + }, + "tensorflow-2.8.2-eigen_py310h2d010dc_0.conda": { + "build": "eigen_py310h2d010dc_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.10.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 eigen_py310h980454f_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "654626af8414d644aac13262643bc373", + "name": "tensorflow", + "namespace": "python", + "sha256": "3a277abb8967adb8710da1fac007c3f175ac64c1845d4ab7789e82e3547c639a", + "size": 3917, + "subdir": "linux-64", + "timestamp": 1658949257085, + "version": "2.8.2" + }, + "tensorflow-2.8.2-eigen_py37h02982d4_0.conda": { + "build": "eigen_py37h02982d4_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 eigen_py37h980454f_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "231520602df045e25f32250bea98e065", + "name": "tensorflow", + "namespace": "python", + "sha256": "f88c0d28f74b12cce7c1475e58b520ffa1b15869688430a086bd9c34e834e506", + "size": 3902, + "subdir": "linux-64", + "timestamp": 1658949386906, + "version": "2.8.2" + }, + "tensorflow-2.8.2-eigen_py38h4fd5193_0.conda": { + "build": "eigen_py38h4fd5193_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.8.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 eigen_py38h980454f_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "239bd877b85888c4583730263064b47c", + "name": "tensorflow", + "namespace": "python", + "sha256": "5a280c366a9bc4ef77687f9af1a6588571ba678e898f62ee95231b9d8c719639", + "size": 3906, + "subdir": "linux-64", + "timestamp": 1658949432142, + "version": "2.8.2" + }, + "tensorflow-2.8.2-eigen_py39h2e3267a_0.conda": { + "build": "eigen_py39h2e3267a_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.9.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 eigen_py39h980454f_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "04c28140e23f94212fe8f2597c776529", + "name": "tensorflow", + "namespace": "python", + "sha256": "15251d60f3c7efbdc17d7be31af374cabd625306e5a1e9aa237e58af726d138a", + "size": 3906, + "subdir": "linux-64", + "timestamp": 1658949343777, + "version": "2.8.2" + }, + "tensorflow-2.8.2-gpu_py310hf783e45_0.conda": { + "build": "gpu_py310hf783e45_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.10.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 gpu_py310h1986732_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ea0eb8ceac8480eff1345f4f9965ac56", + "name": "tensorflow", + "namespace": "python", + "sha256": "1fe90b86351f69adccdc1b12b7f3201b8309d03f606e1953d5d34a647c91fca9", + "size": 7796, + "subdir": "linux-64", + "timestamp": 1659965964020, + "version": "2.8.2" + }, + "tensorflow-2.8.2-gpu_py37hbb399c4_0.conda": { + "build": "gpu_py37hbb399c4_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.7.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 gpu_py37h1986732_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7721c47f85400314235d584a81ad7897", + "name": "tensorflow", + "namespace": "python", + "sha256": "f1598c3941aa086e2f5f0c05ea869da521c46a228d40945f4d341f4885d082c3", + "size": 7789, + "subdir": "linux-64", + "timestamp": 1659965962646, + "version": "2.8.2" + }, + "tensorflow-2.8.2-gpu_py38h75b8afa_0.conda": { + "build": "gpu_py38h75b8afa_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.8.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 gpu_py38h1986732_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9b9065ae84f0aebc8d134b3ec3f71295", + "name": "tensorflow", + "namespace": "python", + "sha256": "16f5165bc6699e2115e321a6cbe87fc999cd112a8bb4bcba790c71bbbb94fa9c", + "size": 7790, + "subdir": "linux-64", + "timestamp": 1659965966409, + "version": "2.8.2" + }, + "tensorflow-2.8.2-gpu_py39hc0c9373_0.conda": { + "build": "gpu_py39hc0c9373_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.9.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 gpu_py39h1986732_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cdf884999f6e4cfb0f64b3e62cb5fadb", + "name": "tensorflow", + "namespace": "python", + "sha256": "9cc9b1cb02d2b51548de3ff5c4b516d3d18e1e59713946be9c9616219624519f", + "size": 7788, + "subdir": "linux-64", + "timestamp": 1659965965172, + "version": "2.8.2" + }, + "tensorflow-2.8.2-mkl_py310hd2b8f8c_0.conda": { + "build": "mkl_py310hd2b8f8c_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.10.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 mkl_py310hf890080_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fd57e2902ae115e6593e147d70b8fee4", + "name": "tensorflow", + "namespace": "python", + "sha256": "b8dc3369cf2779da11dff4312c23d766e714173a2464d9826d642e35ee634658", + "size": 3912, + "subdir": "linux-64", + "timestamp": 1658949302013, + "version": "2.8.2" + }, + "tensorflow-2.8.2-mkl_py37h98100e6_0.conda": { + "build": "mkl_py37h98100e6_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 mkl_py37hf890080_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "26556ac919fb4d8d06786972c20818cd", + "name": "tensorflow", + "namespace": "python", + "sha256": "2348f88d7466e885a2fb7b632174bd41356fc19979e1dd851b797098f8ba6970", + "size": 3895, + "subdir": "linux-64", + "timestamp": 1658949148185, + "version": "2.8.2" + }, + "tensorflow-2.8.2-mkl_py38hb41d75a_0.conda": { + "build": "mkl_py38hb41d75a_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 mkl_py38hf890080_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3dbbecde2780aa96ef4121172611716c", + "name": "tensorflow", + "namespace": "python", + "sha256": "195a2ca23b837d0ba198764791824b7bfe70efe59e51259d823cbcddba54414c", + "size": 3903, + "subdir": "linux-64", + "timestamp": 1658949099240, + "version": "2.8.2" + }, + "tensorflow-2.8.2-mkl_py39ha986a27_0.conda": { + "build": "mkl_py39ha986a27_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.9.*", + "tensorboard 2.8.*", + "tensorflow-base 2.8.2 mkl_py39hf890080_0", + "tensorflow-estimator 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5ca71cc399e1a340c0be8113d1fe1a02", + "name": "tensorflow", + "namespace": "python", + "sha256": "b51e971c0e3e2c50c95f3c6954c2d0abec8010c92b3ca9f1821ecf3d7a92c762", + "size": 3909, + "subdir": "linux-64", + "timestamp": 1658949203233, + "version": "2.8.2" + }, + "tensorflow-2.9.1-eigen_py310h1b3eda0_1.conda": { + "build": "eigen_py310h1b3eda0_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.10.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 eigen_py310hd99631c_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cc024cb2351fbe4768ae2ef3059fb93c", + "name": "tensorflow", + "namespace": "python", + "sha256": "cc471ce7acf0f6a8d0873cb5a642990f29cef4b110cc67423be2dbb6c54c39c3", + "size": 4307, + "subdir": "linux-64", + "timestamp": 1667479963738, + "version": "2.9.1" + }, + "tensorflow-2.9.1-eigen_py310h7bda0dd_0.conda": { + "build": "eigen_py310h7bda0dd_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.10.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 eigen_py310hd99631c_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9a592f2085dca4a14d0f8653076e2b2f", + "name": "tensorflow", + "namespace": "python", + "sha256": "ccfe6920def99fd6ef3af85660a0b57d3ecd1de74129219471ce00a112a0cde3", + "size": 4370, + "subdir": "linux-64", + "timestamp": 1661531036064, + "version": "2.9.1" + }, + "tensorflow-2.9.1-eigen_py37h054527f_0.conda": { + "build": "eigen_py37h054527f_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 eigen_py37hd99631c_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6677818469247d152cf026f23bd4eb19", + "name": "tensorflow", + "namespace": "python", + "sha256": "ba4c190d9522e3dae3d87d391501d0c489b1f23ae6ff0ebd38b036f5590a6c70", + "size": 4367, + "subdir": "linux-64", + "timestamp": 1661530965745, + "version": "2.9.1" + }, + "tensorflow-2.9.1-eigen_py37hb9d071f_1.conda": { + "build": "eigen_py37hb9d071f_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.7.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 eigen_py37hd99631c_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f017c925e3452ec748721315db1ce1c6", + "name": "tensorflow", + "namespace": "python", + "sha256": "65b4ef7e0d2a4c1d44e23ac88f1f34e5f1283222f7badf4cc52d08d1966cb344", + "size": 4292, + "subdir": "linux-64", + "timestamp": 1667479988733, + "version": "2.9.1" + }, + "tensorflow-2.9.1-eigen_py38h6be4119_0.conda": { + "build": "eigen_py38h6be4119_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.8.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 eigen_py38hd99631c_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "33d6c4480a09398772fb431b7746db33", + "name": "tensorflow", + "namespace": "python", + "sha256": "cac5671e74e34308e81a9fdfcd0d2d78f19c07cea5ae0f176f65efdb07ae1295", + "size": 4371, + "subdir": "linux-64", + "timestamp": 1661531014168, + "version": "2.9.1" + }, + "tensorflow-2.9.1-eigen_py38hdf99000_1.conda": { + "build": "eigen_py38hdf99000_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.8.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 eigen_py38hd99631c_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f462be119a8a3aea52f39d5c4ed6276d", + "name": "tensorflow", + "namespace": "python", + "sha256": "8f14410bb54abbf8d9f8c27b05e67bdd7ca4967db1f29081c679a8537156a812", + "size": 4294, + "subdir": "linux-64", + "timestamp": 1667480016004, + "version": "2.9.1" + }, + "tensorflow-2.9.1-eigen_py39h0984c0c_0.conda": { + "build": "eigen_py39h0984c0c_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.9.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 eigen_py39hd99631c_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c70142471a03a412655c152bf36a538f", + "name": "tensorflow", + "namespace": "python", + "sha256": "eebda5a018de63e4390455fdbf107976ce1eac510de83b89cc696e06ac39f77b", + "size": 4373, + "subdir": "linux-64", + "timestamp": 1661530940401, + "version": "2.9.1" + }, + "tensorflow-2.9.1-eigen_py39hd6755af_1.conda": { + "build": "eigen_py39hd6755af_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.2.0 eigen", + "python 3.9.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 eigen_py39hd99631c_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5d3cc598f532016e0e33d544791f2e4c", + "name": "tensorflow", + "namespace": "python", + "sha256": "5cec509b217f37e48a82809ebc572f7c4cda97deff2ac24a3e0671d4640b1db0", + "size": 4286, + "subdir": "linux-64", + "timestamp": 1667479859017, + "version": "2.9.1" + }, + "tensorflow-2.9.1-gpu_py310h710b358_0.conda": { + "build": "gpu_py310h710b358_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.10.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 gpu_py310h1986732_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b0acfb6812eaa13ea53b11ee90488916", + "name": "tensorflow", + "namespace": "python", + "sha256": "d9445493fc96229299f79aa26b390dc5d09fd3f1691ddfe82c0f8e9ec6f9fabc", + "size": 4364, + "subdir": "linux-64", + "timestamp": 1661530764200, + "version": "2.9.1" + }, + "tensorflow-2.9.1-gpu_py310h958eec2_1.conda": { + "build": "gpu_py310h958eec2_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.10.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 gpu_py310h1986732_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "76aee61b128192a77d0a9b7eeb738dfd", + "name": "tensorflow", + "namespace": "python", + "sha256": "c80432906a75b813df1e521015020f552499febc330258de9a82a8a8a00e1dd7", + "size": 4288, + "subdir": "linux-64", + "timestamp": 1667480196445, + "version": "2.9.1" + }, + "tensorflow-2.9.1-gpu_py37h94660a9_1.conda": { + "build": "gpu_py37h94660a9_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.7.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 gpu_py37h1986732_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "58084e25ca7bd37fa0229c972c9a72a1", + "name": "tensorflow", + "namespace": "python", + "sha256": "4031759accd1483585d2209bc0167f2fad1c6e0df8db35cc820852e3ff1c1373", + "size": 4277, + "subdir": "linux-64", + "timestamp": 1667480257712, + "version": "2.9.1" + }, + "tensorflow-2.9.1-gpu_py37hecb99ea_0.conda": { + "build": "gpu_py37hecb99ea_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.7.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 gpu_py37h1986732_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f941a539e55cf3f1cb820846d6903c53", + "name": "tensorflow", + "namespace": "python", + "sha256": "43f776aaf0d964fd076f0c7d61f6b444cc2fabf80e68d525f0d74d228a506f78", + "size": 4345, + "subdir": "linux-64", + "timestamp": 1661530789492, + "version": "2.9.1" + }, + "tensorflow-2.9.1-gpu_py38h731a0ae_0.conda": { + "build": "gpu_py38h731a0ae_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.8.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 gpu_py38h1986732_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3231607646f01ba7845ff9f83dec72de", + "name": "tensorflow", + "namespace": "python", + "sha256": "e66aee76b16aab9cd9dd1fac3e16feb12aabb6a548c5fbcd4a9fd0e609801dee", + "size": 4344, + "subdir": "linux-64", + "timestamp": 1661530739597, + "version": "2.9.1" + }, + "tensorflow-2.9.1-gpu_py38hb4feff2_1.conda": { + "build": "gpu_py38hb4feff2_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.8.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 gpu_py38h1986732_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c5fdd884270dafd6b7da14766fbaa8bf", + "name": "tensorflow", + "namespace": "python", + "sha256": "9b5e6f710c47c6e8a31a9f56786afdf61b837344ad1ee4221e3763b2cd39e682", + "size": 4279, + "subdir": "linux-64", + "timestamp": 1667480226202, + "version": "2.9.1" + }, + "tensorflow-2.9.1-gpu_py39hb717771_1.conda": { + "build": "gpu_py39hb717771_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.9.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 gpu_py39h1986732_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f8e18bb9ebbe7b19a8a6a0df7efd55a8", + "name": "tensorflow", + "namespace": "python", + "sha256": "2d8b9c29b56c747f099780072d32b59a37482e6e84f01f993097784d690278ad", + "size": 4278, + "subdir": "linux-64", + "timestamp": 1667480288504, + "version": "2.9.1" + }, + "tensorflow-2.9.1-gpu_py39hd4ae112_0.conda": { + "build": "gpu_py39hd4ae112_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.1.0 gpu", + "python 3.9.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 gpu_py39h1986732_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bf0455ce6885c42ed2cf07c580c841a9", + "name": "tensorflow", + "namespace": "python", + "sha256": "c0637e2306b91add537ff494043a7295c79c888afbb73816f83e3bef5e0884f9", + "size": 4350, + "subdir": "linux-64", + "timestamp": 1661530713835, + "version": "2.9.1" + }, + "tensorflow-2.9.1-mkl_py310h6648609_1.conda": { + "build": "mkl_py310h6648609_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.10.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 mkl_py310h353358b_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e3ef0bee5544bada7b48dc390e95fb31", + "name": "tensorflow", + "namespace": "python", + "sha256": "b607b462c845235a8f86b0fde82dea6b11ddb32cc7918fb57442f09768920111", + "size": 4287, + "subdir": "linux-64", + "timestamp": 1667479910109, + "version": "2.9.1" + }, + "tensorflow-2.9.1-mkl_py310h871f1f9_0.conda": { + "build": "mkl_py310h871f1f9_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.10.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 mkl_py310h353358b_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3f60b90a8b1e82489a5f716482f44daf", + "name": "tensorflow", + "namespace": "python", + "sha256": "8cbc256bc9e26ea5f9a4aee39ace28e66a6de1eba54c2a23dbbcc429f4e92018", + "size": 4367, + "subdir": "linux-64", + "timestamp": 1661530989922, + "version": "2.9.1" + }, + "tensorflow-2.9.1-mkl_py37h38a6e85_1.conda": { + "build": "mkl_py37h38a6e85_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 mkl_py37h353358b_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "980601ff883f9f5c7ec87d3ba96a6849", + "name": "tensorflow", + "namespace": "python", + "sha256": "1dc5c5eac82a0a1678af2336c53c5d8e6aa0cb47b93c3c44d843cb2e5e52095a", + "size": 4276, + "subdir": "linux-64", + "timestamp": 1667479829156, + "version": "2.9.1" + }, + "tensorflow-2.9.1-mkl_py37h58a621a_0.conda": { + "build": "mkl_py37h58a621a_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.7.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 mkl_py37h353358b_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e6f61cd15e72a46e7fc4a29e1ae7a224", + "name": "tensorflow", + "namespace": "python", + "sha256": "af3c7e96087b548477a00942383e1257479fafb8f2b432303881a315d0b29045", + "size": 4354, + "subdir": "linux-64", + "timestamp": 1661530890103, + "version": "2.9.1" + }, + "tensorflow-2.9.1-mkl_py38h197d616_1.conda": { + "build": "mkl_py38h197d616_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 mkl_py38h353358b_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "18c734002555941acd5ae92d4abc534b", + "name": "tensorflow", + "namespace": "python", + "sha256": "d25c3ae6ee22e28dbbad5bea4d37c842cbec167fdefa20a46020ec5ca4d7ba83", + "size": 4278, + "subdir": "linux-64", + "timestamp": 1667479936833, + "version": "2.9.1" + }, + "tensorflow-2.9.1-mkl_py38h96f9fba_0.conda": { + "build": "mkl_py38h96f9fba_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.8.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 mkl_py38h353358b_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f661c29c6a41dcde0e4ea01486f1e568", + "name": "tensorflow", + "namespace": "python", + "sha256": "91c7aaeef4a538f7237aa23bbc5f54c36291382487d5bcfd5d162a7a5dc16d16", + "size": 4362, + "subdir": "linux-64", + "timestamp": 1661530915771, + "version": "2.9.1" + }, + "tensorflow-2.9.1-mkl_py39h3a96225_1.conda": { + "build": "mkl_py39h3a96225_1", + "build_number": 1, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.9.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 mkl_py39h353358b_1", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5bba241b2768146e99dd5c0419f6180a", + "name": "tensorflow", + "namespace": "python", + "sha256": "43a104df7c0598627e75c98e6ddbeb05e76106c65f781e5cbf3834acfbf5bec0", + "size": 4282, + "subdir": "linux-64", + "timestamp": 1667479886018, + "version": "2.9.1" + }, + "tensorflow-2.9.1-mkl_py39hb9fcb14_0.conda": { + "build": "mkl_py39hb9fcb14_0", + "build_number": 0, + "depends": [ + "_tflow_select 2.3.0 mkl", + "python 3.9.*", + "tensorboard 2.9.*", + "tensorflow-base 2.9.1 mkl_py39h353358b_0", + "tensorflow-estimator 2.9.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2cfc982be18193a7d9684def854408bd", + "name": "tensorflow", + "namespace": "python", + "sha256": "149870fa19d2016a769115d572e8e375b77a0767fd94add9eb6f5d98b4bb30f5", + "size": 4363, + "subdir": "linux-64", + "timestamp": 1661530864649, + "version": "2.9.1" + }, + "tensorflow-base-1.10.0-eigen_py27h4dcebc2_0.conda": { + "build": "eigen_py27h4dcebc2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ed685e8c2b534e6f0a31bf7e2544e6d4", + "name": "tensorflow-base", + "sha256": "909b4754726f7a7ab2a54481b447b409a025c45136e7279cbb6781f89d985c54", + "size": 32981319, + "subdir": "linux-64", + "timestamp": 1534978001081, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-eigen_py35h4dcebc2_0.conda": { + "build": "eigen_py35h4dcebc2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3cfa798db64ffb047dc951f255575325", + "name": "tensorflow-base", + "sha256": "6549b121bff3f75d9cfffe0c510a27ac7df8d76b8b487109501147eee6ae665b", + "size": 33068120, + "subdir": "linux-64", + "timestamp": 1534975867024, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-eigen_py36h4dcebc2_0.conda": { + "build": "eigen_py36h4dcebc2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6c8d05319dae95517012e975422ed018", + "name": "tensorflow-base", + "sha256": "230e5867a038defd77edde3b2e179eef842c9c460c6ffa23d08d75bdc306dd35", + "size": 34133487, + "subdir": "linux-64", + "timestamp": 1534972347124, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-gpu_py27h3435052_0.conda": { + "build": "gpu_py27h3435052_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "23bedbfe36ba260801e1953a99df8997", + "name": "tensorflow-base", + "sha256": "ed0f43fd8fcef9c966d58f0cbf4dfa3d61168cb4760eb166e74a0ecf5a952e85", + "size": 80072017, + "subdir": "linux-64", + "timestamp": 1534898323213, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-gpu_py27h6ecc378_0.conda": { + "build": "gpu_py27h6ecc378_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "22420d2fefc3c1547e6f39e28eb8e3c5", + "name": "tensorflow-base", + "sha256": "7a6eb4a900e7783ec767ae0df0f8c6b4e81a5b3a270a0ae15a21514d5367da67", + "size": 88583588, + "subdir": "linux-64", + "timestamp": 1534886963721, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-gpu_py27had579c0_0.conda": { + "build": "gpu_py27had579c0_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "62d4355b8940c5d8035042faa9293884", + "name": "tensorflow-base", + "sha256": "accd672c3110f0b5e725204f7a2814d12f7a93f0ed787a5e8c5ccbb02b4c5b27", + "size": 87334139, + "subdir": "linux-64", + "timestamp": 1534965180285, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-gpu_py35h3435052_0.conda": { + "build": "gpu_py35h3435052_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3fb935c5fe75c40802922d03a1e7b5c5", + "name": "tensorflow-base", + "sha256": "f9e30d868fe5fa0f00cfd852f0b142da6b39a2f3f98092895a65dcf55956c60d", + "size": 80078176, + "subdir": "linux-64", + "timestamp": 1534896701563, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-gpu_py35h6ecc378_0.conda": { + "build": "gpu_py35h6ecc378_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1f981f9ac0a07b124e767dc205cc5587", + "name": "tensorflow-base", + "sha256": "2f388a51ca99035cdf6d756230410545f10501b09a7b07df944aea444fa72a04", + "size": 88757607, + "subdir": "linux-64", + "timestamp": 1534888676415, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-gpu_py35had579c0_0.conda": { + "build": "gpu_py35had579c0_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a5001fe08c1fd3bc1d6a9dff18186915", + "name": "tensorflow-base", + "sha256": "6e612636bf399cd519d0449bf2cebe96cbe0784f2b3fa8548cf60e49e67dcd04", + "size": 87434030, + "subdir": "linux-64", + "timestamp": 1534963311292, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-gpu_py36h3435052_0.conda": { + "build": "gpu_py36h3435052_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bff22f0b9c3518afcb815865a0866794", + "name": "tensorflow-base", + "sha256": "015167f7a627ad488c3f1b4e786948ebf730086dc6d24114de83b7fccc02f2b8", + "size": 81121381, + "subdir": "linux-64", + "timestamp": 1534899937566, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-gpu_py36h6ecc378_0.conda": { + "build": "gpu_py36h6ecc378_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9fdc984edeb35dcff4d984c93076e015", + "name": "tensorflow-base", + "sha256": "2ae1e7156d38c858a781a6d4dcedb02ee38855f87442eeb8f3d5b7232bb329e9", + "size": 88723080, + "subdir": "linux-64", + "timestamp": 1534885299423, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-gpu_py36had579c0_0.conda": { + "build": "gpu_py36had579c0_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3c1bef843154b720a2a20bd8e3df6ae2", + "name": "tensorflow-base", + "sha256": "5830436dcdcd568b29b4782798d0323a81080a5ba637933df788e64f219b8086", + "size": 88612165, + "subdir": "linux-64", + "timestamp": 1534966994904, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-mkl_py27h3c3e929_0.conda": { + "build": "mkl_py27h3c3e929_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "111959f6f041a563901405b64c1c6dc4", + "name": "tensorflow-base", + "sha256": "d0dfc385bf962d03e1a02e698baa7709f81fc30cbacfc667cc0c0e74641f4244", + "size": 59336755, + "subdir": "linux-64", + "timestamp": 1534977038629, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-mkl_py35h3c3e929_0.conda": { + "build": "mkl_py35h3c3e929_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dbdc79c87d85c38e708fa154d50eb006", + "name": "tensorflow-base", + "sha256": "228dc0b9d2dfc6420b3d4717dd9eee0d86ff3da12913a70ffc6b70fe628115b9", + "size": 59468089, + "subdir": "linux-64", + "timestamp": 1534974854841, + "version": "1.10.0" + }, + "tensorflow-base-1.10.0-mkl_py36h3c3e929_0.conda": { + "build": "mkl_py36h3c3e929_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cd9a4f076b40d4c209c152586e72c5d3", + "name": "tensorflow-base", + "sha256": "13d575dd07e8863f420f5a0dc7ae71556dcdff9feb68ff7300b7196ed0cb587c", + "size": 59414281, + "subdir": "linux-64", + "timestamp": 1534973391894, + "version": "1.10.0" + }, + "tensorflow-base-1.11.0-eigen_py27h4dcebc2_0.conda": { + "build": "eigen_py27h4dcebc2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2ddf1f4287c94cd4b37bf5ad274c4669", + "name": "tensorflow-base", + "sha256": "1e78d4d841da5d6257ccfcbeb570c938bc55e68757c09eab972e73fa097bd3b6", + "size": 34544829, + "subdir": "linux-64", + "timestamp": 1538591156544, + "version": "1.11.0" + }, + "tensorflow-base-1.11.0-eigen_py36h4dcebc2_0.conda": { + "build": "eigen_py36h4dcebc2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cb23e9636063aa8663ef5d5be24aca71", + "name": "tensorflow-base", + "sha256": "71c6126f51553c34083b35d4fae13be0d3994eb739be5199e9f6a628cfb931e1", + "size": 35704920, + "subdir": "linux-64", + "timestamp": 1538588221849, + "version": "1.11.0" + }, + "tensorflow-base-1.11.0-gpu_py27h8e0ae2d_0.conda": { + "build": "gpu_py27h8e0ae2d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b87fd79cc07ee803ac2b4b6e08693ba3", + "name": "tensorflow-base", + "sha256": "1667a3494bc6850cf399dd530cbc3a1cc2b2bf6011da88e59218f03a1cb27aad", + "size": 89713965, + "subdir": "linux-64", + "timestamp": 1538676300511, + "version": "1.11.0" + }, + "tensorflow-base-1.11.0-gpu_py27had579c0_0.conda": { + "build": "gpu_py27had579c0_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d41772f25cc4a8af897e06091ca0c000", + "name": "tensorflow-base", + "sha256": "1501365697fb528dd28d9c6a75a807fcbc160235e6d2c4de73864259c6ff54be", + "size": 90493946, + "subdir": "linux-64", + "timestamp": 1538696059014, + "version": "1.11.0" + }, + "tensorflow-base-1.11.0-gpu_py36h8e0ae2d_0.conda": { + "build": "gpu_py36h8e0ae2d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5822459020ab110ac26bfb806a18b250", + "name": "tensorflow-base", + "sha256": "d1a380c8f7f4740181b0c0ab6d82f10c974bcef505dc9cf5ff29b27f749a73cc", + "size": 90936832, + "subdir": "linux-64", + "timestamp": 1538673481399, + "version": "1.11.0" + }, + "tensorflow-base-1.11.0-gpu_py36had579c0_0.conda": { + "build": "gpu_py36had579c0_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fac3c4ab74a68695a1051383f572e7c2", + "name": "tensorflow-base", + "sha256": "aaf84117a0f9086fcbcb47d21d754bba7cd086e29b2553cbdaac54c9fc890c47", + "size": 90465349, + "subdir": "linux-64", + "timestamp": 1538693415620, + "version": "1.11.0" + }, + "tensorflow-base-1.11.0-mkl_py27h3c3e929_0.conda": { + "build": "mkl_py27h3c3e929_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5633926b0de9ba73dd00d9dd53730838", + "name": "tensorflow-base", + "sha256": "91f3610f22251f5f6945fc56224310aac82a69834f157c2ceb8c6a413b08eb7a", + "size": 60236815, + "subdir": "linux-64", + "timestamp": 1538589739754, + "version": "1.11.0" + }, + "tensorflow-base-1.11.0-mkl_py36h3c3e929_0.conda": { + "build": "mkl_py36h3c3e929_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5f128f58f75ab83db3d5f2a595f9453a", + "name": "tensorflow-base", + "sha256": "5e4c120375968d3257b84db984c7ce6144c2f294fde6f39ca0eb0efc3b07c104", + "size": 59213283, + "subdir": "linux-64", + "timestamp": 1538586408417, + "version": "1.11.0" + }, + "tensorflow-base-1.12.0-eigen_py27h4dcebc2_0.conda": { + "build": "eigen_py27h4dcebc2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c586a5ec02d15b59253745e7b7e89719", + "name": "tensorflow-base", + "sha256": "9762a759606e249529a1d0e8d76fca9eb0f56568f1a8782a14fd514bd2bc0170", + "size": 49263606, + "subdir": "linux-64", + "timestamp": 1542081103736, + "version": "1.12.0" + }, + "tensorflow-base-1.12.0-eigen_py36h4dcebc2_0.conda": { + "build": "eigen_py36h4dcebc2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "49d9b7350bdd143533c0f7f7babf6637", + "name": "tensorflow-base", + "sha256": "59fbc4ea31108850e3dcf83a21e2be43182c96a1390821ee631e0515c2f29d8c", + "size": 48160833, + "subdir": "linux-64", + "timestamp": 1542075497694, + "version": "1.12.0" + }, + "tensorflow-base-1.12.0-gpu_py27h8e0ae2d_0.conda": { + "build": "gpu_py27h8e0ae2d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0462522fd8a158b92e30aaec6723a5c0", + "name": "tensorflow-base", + "sha256": "6d6022bbf15af01d494080cf37bbe1b7e35b6bf680797936230dd4160de37f3b", + "size": 108866633, + "subdir": "linux-64", + "timestamp": 1542144059823, + "version": "1.12.0" + }, + "tensorflow-base-1.12.0-gpu_py27had579c0_0.conda": { + "build": "gpu_py27had579c0_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "113ab82861cc732ab42748a9b4aaea10", + "name": "tensorflow-base", + "sha256": "063c105a85f856f40868a8daadfb5511395c5c9b8fb57d96838cf40b354d2057", + "size": 108732685, + "subdir": "linux-64", + "timestamp": 1542152838859, + "version": "1.12.0" + }, + "tensorflow-base-1.12.0-gpu_py36h8e0ae2d_0.conda": { + "build": "gpu_py36h8e0ae2d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f509f2b0cc05381be15a717bc75b6e8a", + "name": "tensorflow-base", + "sha256": "3a954d04a440a158d1923c031ceb1954eae7f8be0114a7d2cf0b08625e094bed", + "size": 108862726, + "subdir": "linux-64", + "timestamp": 1542138164161, + "version": "1.12.0" + }, + "tensorflow-base-1.12.0-gpu_py36had579c0_0.conda": { + "build": "gpu_py36had579c0_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.2.*", + "cudnn >=7.2.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7bc18e66e3eba1ef5d179f148a87ce12", + "name": "tensorflow-base", + "sha256": "a24afb7cd9bd59e6b37ad135d8752ae4803414fece4056c9588efca1dfd92b5d", + "size": 107683573, + "subdir": "linux-64", + "timestamp": 1542150119219, + "version": "1.12.0" + }, + "tensorflow-base-1.12.0-mkl_py27h3c3e929_0.conda": { + "build": "mkl_py27h3c3e929_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "be76b78e7d351085d7f764d0630885d1", + "name": "tensorflow-base", + "sha256": "13d6aa1cd3a9630dfbf3d802fc613a0806fe0aeaa1d55c8ba6cbf0bc2888e50d", + "size": 75029448, + "subdir": "linux-64", + "timestamp": 1542079698517, + "version": "1.12.0" + }, + "tensorflow-base-1.12.0-mkl_py36h3c3e929_0.conda": { + "build": "mkl_py36h3c3e929_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7f20f6698ec6d347fe95869ed56983fd", + "name": "tensorflow-base", + "sha256": "fae7ee2b3ebc8c5b5e3214450f3b9901cf25e4112ea6b630662d8ec7a44d4ee1", + "size": 75103869, + "subdir": "linux-64", + "timestamp": 1542076945263, + "version": "1.12.0" + }, + "tensorflow-base-1.13.1-eigen_py27hf4a566f_0.conda": { + "build": "eigen_py27hf4a566f_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d20781f24fb0b947fb01cb8d535567e6", + "name": "tensorflow-base", + "sha256": "5fba814dcc6f48d3ae367dda9196ac10d3af51a39b23aaad43695e5697643a04", + "size": 54873778, + "subdir": "linux-64", + "timestamp": 1554301668533, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-eigen_py36hf4a566f_0.conda": { + "build": "eigen_py36hf4a566f_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bab4082e23554fff47e25408d60209fb", + "name": "tensorflow-base", + "sha256": "a9234736383583b752dc50493dab78a341e9b6fff022241ccfcb562adfff0b5c", + "size": 54859786, + "subdir": "linux-64", + "timestamp": 1554304926780, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-eigen_py37hf4a566f_0.conda": { + "build": "eigen_py37hf4a566f_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c77e891d4fe636d3491373996ba96539", + "name": "tensorflow-base", + "sha256": "f930ffed323d43f504259a51651b42d2611e33b10cd7003cf165679cb66ae850", + "size": 53794802, + "subdir": "linux-64", + "timestamp": 1554307836679, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-gpu_py27h611c6d2_0.conda": { + "build": "gpu_py27h611c6d2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7793f788724995a47a2b6fc3ce88bf44", + "name": "tensorflow-base", + "sha256": "fb55df45849ca1589a2bce328001e2cee3e38172e9baadda2fba51908d83f923", + "size": 130200041, + "subdir": "linux-64", + "timestamp": 1554428866551, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-gpu_py27h8d69cac_0.conda": { + "build": "gpu_py27h8d69cac_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "35830531dbc859dbec95093c96c0e68b", + "name": "tensorflow-base", + "sha256": "6947bf7fbbfb3f27f7151669e06b46d1a482fc6f5fb2644199fff4ec88e35228", + "size": 137590381, + "subdir": "linux-64", + "timestamp": 1554408187672, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-gpu_py27h8f37b9b_0.conda": { + "build": "gpu_py27h8f37b9b_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1d32eba17ebe05b91b8cb3f37355564d", + "name": "tensorflow-base", + "sha256": "30651bee729ff984821238cfff08b64f888e82a56ec0782bbbc11248b497af01", + "size": 130515783, + "subdir": "linux-64", + "timestamp": 1554474941685, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-gpu_py36h611c6d2_0.conda": { + "build": "gpu_py36h611c6d2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "23b444a7b3ce7e88056c6e4e3ef3c4cf", + "name": "tensorflow-base", + "sha256": "ab7c69a9061e95c82d31421dfdb0c186587ce55eee2dd7ce744be50d1bf55d9f", + "size": 131465518, + "subdir": "linux-64", + "timestamp": 1554440938874, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-gpu_py36h8d69cac_0.conda": { + "build": "gpu_py36h8d69cac_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fa8d07da2c075de6498fa4e86d442ce1", + "name": "tensorflow-base", + "sha256": "f878bb705235bfd89b4ca7d2bd09d4f6f44bb78ce1c2930549fd3ccc52ded32f", + "size": 136520619, + "subdir": "linux-64", + "timestamp": 1554396820407, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-gpu_py36h8f37b9b_0.conda": { + "build": "gpu_py36h8f37b9b_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "745eaafe0990967d095da7d0be14bcfb", + "name": "tensorflow-base", + "sha256": "3308b703d1101d91d1d11a134defa799fad7c149251d0e49ce583dec0b50c655", + "size": 130577647, + "subdir": "linux-64", + "timestamp": 1554481710746, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-gpu_py37h611c6d2_0.conda": { + "build": "gpu_py37h611c6d2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "136795fc6f9416313dddbf7140c5e04e", + "name": "tensorflow-base", + "sha256": "89cc1a96993f0553b7aee80ba12b3565eb5ae204c0cc286ca7b77d7003b7e9c8", + "size": 131557159, + "subdir": "linux-64", + "timestamp": 1554437103362, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-gpu_py37h8d69cac_0.conda": { + "build": "gpu_py37h8d69cac_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cc33875ada8da7bf0cc0e527c1a91691", + "name": "tensorflow-base", + "sha256": "02a59e3ad4f44189ed1c7e86cc1c6ff608806680fce9b57e630cf53c3b01faf0", + "size": 136511890, + "subdir": "linux-64", + "timestamp": 1554417482026, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-gpu_py37h8f37b9b_0.conda": { + "build": "gpu_py37h8f37b9b_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.5", + "keras-preprocessing >=1.0.3", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1995270fb3fccef43a534abfc4085171", + "name": "tensorflow-base", + "sha256": "f3895db120e4ec8c53e23245071bef31149af22ea41f92ef38faed43962af7ff", + "size": 130546771, + "subdir": "linux-64", + "timestamp": 1554488962365, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-mkl_py27h7ce6ba3_0.conda": { + "build": "mkl_py27h7ce6ba3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5a756dd4a029edc3b6ba3257856af0d0", + "name": "tensorflow-base", + "sha256": "fc770a6bf1fb3fe96adacd61189ddffaaf8e92aba731dad51edbe5066cd14636", + "size": 81834017, + "subdir": "linux-64", + "timestamp": 1554319628640, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-mkl_py36h7ce6ba3_0.conda": { + "build": "mkl_py36h7ce6ba3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3ef0109739bf1fc578375655ee7ee5f2", + "name": "tensorflow-base", + "sha256": "3451d199881140a8993530e35af1244d9db2a12f8d045eadfc9c23836030e452", + "size": 81811372, + "subdir": "linux-64", + "timestamp": 1554322300653, + "version": "1.13.1" + }, + "tensorflow-base-1.13.1-mkl_py37h7ce6ba3_0.conda": { + "build": "mkl_py37h7ce6ba3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "tensorflow-estimator >=1.13.0,<1.14.0a0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "06c72ff49947788ad37f80d3dc8f38d0", + "name": "tensorflow-base", + "sha256": "05d2117911bcbf88fdf160c5f4b6eb997cab07e8fcae8270bfd670e2fa2e5cbd", + "size": 80768509, + "subdir": "linux-64", + "timestamp": 1554314673918, + "version": "1.13.1" + }, + "tensorflow-base-1.14.0-eigen_py27hf4a566f_0.conda": { + "build": "eigen_py27hf4a566f_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "future", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f5ac26de6f252711c54209d22f0410ec", + "name": "tensorflow-base", + "sha256": "bda68a097716cff0358fbb6b63abf7f752eacec95415c35ff43a18312a9d02b9", + "size": 64307095, + "subdir": "linux-64", + "timestamp": 1561045220700, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-eigen_py36hf4a566f_0.conda": { + "build": "eigen_py36hf4a566f_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "55d302e40ee7a6ebd16a87c70c0dac4a", + "name": "tensorflow-base", + "sha256": "bbb055de98bdcbed434a590d7fc5c580a85af92c8859ca415532bd1e6ae4ed2c", + "size": 64311710, + "subdir": "linux-64", + "timestamp": 1560988476052, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-eigen_py37hf4a566f_0.conda": { + "build": "eigen_py37hf4a566f_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c22ca20e32e9b7225a76882c63eb2963", + "name": "tensorflow-base", + "sha256": "57c1092e1c2bb45420b6ba62e4749960fa666c683bdc37213259e3f65e9e9fcc", + "size": 64361975, + "subdir": "linux-64", + "timestamp": 1560993194148, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py27h611c6d2_0.conda": { + "build": "gpu_py27h611c6d2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "enum34 >=1.1.6", + "future", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "184a0f9d96b133cd9ea03e50ef182e91", + "name": "tensorflow-base", + "sha256": "f48fc72e41d17e5f0557f98eb56f6f797cceee692d7e638927745ea903e99e1f", + "size": 147922599, + "subdir": "linux-64", + "timestamp": 1561546879977, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py27h8d69cac_0.conda": { + "build": "gpu_py27h8d69cac_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "enum34 >=1.1.6", + "future", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8c31debbf0f53842ad69a253656943f7", + "name": "tensorflow-base", + "sha256": "4e82418f5713cc0914d17deb3c65cd4b3d9d35adae2e9604c0706f070e671795", + "size": 153608641, + "subdir": "linux-64", + "timestamp": 1561566952009, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py27h8f37b9b_0.conda": { + "build": "gpu_py27h8f37b9b_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "enum34 >=1.1.6", + "future", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8290a76c411eed2ee02736d1d764dfa4", + "name": "tensorflow-base", + "sha256": "e936c7ebc31b809cff936060aac2bb6e59f35a43eea678ac4492f5f0e276af4d", + "size": 146036026, + "subdir": "linux-64", + "timestamp": 1561520844300, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py27he45bfe2_0.conda": { + "build": "gpu_py27he45bfe2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit >=10.1.168,<10.2.0a0", + "cudnn >=7.6.0,<8.0a0", + "cupti", + "enum34 >=1.1.6", + "future", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "446f885e45f78e71522f25ce3fb02534", + "name": "tensorflow-base", + "sha256": "49eaf27e2196b8161081d579020715a57775a422e385e9a5f0efeb2b65b1f55f", + "size": 153361902, + "subdir": "linux-64", + "timestamp": 1561598429112, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py36h611c6d2_0.conda": { + "build": "gpu_py36h611c6d2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2251d9eb3aab84809013195e12753f69", + "name": "tensorflow-base", + "sha256": "f96d50734f6ceb75515e3d40191946375d978b0ba12b59440902548eaa5a1355", + "size": 147898751, + "subdir": "linux-64", + "timestamp": 1561550571637, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py36h8d69cac_0.conda": { + "build": "gpu_py36h8d69cac_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fb46969eee52fcb468be76802c6185d8", + "name": "tensorflow-base", + "sha256": "53508710e8f4d23c2cb2a9a626bedd4de44e8cbaf4b625d7f87cde533a567a9d", + "size": 153747877, + "subdir": "linux-64", + "timestamp": 1561571251588, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py36h8f37b9b_0.conda": { + "build": "gpu_py36h8f37b9b_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "093a8e45e32db688880e6adb6380df53", + "name": "tensorflow-base", + "sha256": "ff52f166a175ad5f9f04da5208057987aa32104d25a4c2f869e8a5eb3ff50ec5", + "size": 148414728, + "subdir": "linux-64", + "timestamp": 1561511610427, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py36he45bfe2_0.conda": { + "build": "gpu_py36he45bfe2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "cudatoolkit >=10.1.168,<10.2.0a0", + "cudnn >=7.6.0,<8.0a0", + "cupti", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0fcf63f89187de5cdb175ca082eb9687", + "name": "tensorflow-base", + "sha256": "cffbc56c3dbb529f6f87837b3036fbe1eee8beb4c8d53781966efec58805414e", + "size": 150992326, + "subdir": "linux-64", + "timestamp": 1561591373510, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py37h611c6d2_0.conda": { + "build": "gpu_py37h611c6d2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "cudatoolkit >=9.2,<9.3.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3fdcad3282a91d6e68927ba2465b6faa", + "name": "tensorflow-base", + "sha256": "eb3f3bc06793146e778f0fa59f85c702ac7402dedf2e83c27f5859fa36b87e98", + "size": 147884684, + "subdir": "linux-64", + "timestamp": 1561542990158, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py37h8d69cac_0.conda": { + "build": "gpu_py37h8d69cac_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5127f8565e41dac42d94b19d236245ed", + "name": "tensorflow-base", + "sha256": "a5a7deeace86f405fcc5a08d476c19cfe2e9a660d6c646f4290ada9d29af661d", + "size": 153586698, + "subdir": "linux-64", + "timestamp": 1561575240142, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py37h8f37b9b_0.conda": { + "build": "gpu_py37h8f37b9b_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "cudatoolkit >=9.0,<9.1.0a0", + "cudnn >=7.3.1,<8.0a0", + "cupti", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c3ba4db9f4d7aa63507e9ff8c74d4500", + "name": "tensorflow-base", + "sha256": "3c25fa107b4d225f0d7df86f59a1acc70c222711e5dd542f8da9b47330d2db5e", + "size": 146087523, + "subdir": "linux-64", + "timestamp": 1561505600781, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-gpu_py37he45bfe2_0.conda": { + "build": "gpu_py37he45bfe2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "cudatoolkit >=10.1.168,<10.2.0a0", + "cudnn >=7.6.0,<8.0a0", + "cupti", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "aaf58566b88f01f3313bd777592149a8", + "name": "tensorflow-base", + "sha256": "580226ae8aa21301fadfba52ca391caace6b7ebc4f3f5594ad52872d5f485ceb", + "size": 153393875, + "subdir": "linux-64", + "timestamp": 1561584865373, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-mkl_py27h7ce6ba3_0.conda": { + "build": "mkl_py27h7ce6ba3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "future", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fb0493c616fbe833786b6047eeb9cded", + "name": "tensorflow-base", + "sha256": "a18e1e4e989a751ee013d7c0f7dabab302c1b4090efb19ae7b78c4a5dd4820d7", + "size": 88322201, + "subdir": "linux-64", + "timestamp": 1561048186700, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-mkl_py36h7ce6ba3_0.conda": { + "build": "mkl_py36h7ce6ba3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9b7199d3b6347cff1d73db497de74d4f", + "name": "tensorflow-base", + "sha256": "0d3701400bcdb7189a4f7571aec4ca92c65e3bed38e8c1e839388b75a67cb8cf", + "size": 88395056, + "subdir": "linux-64", + "timestamp": 1560986225960, + "version": "1.14.0" + }, + "tensorflow-base-1.14.0-mkl_py37h7ce6ba3_0.conda": { + "build": "mkl_py37h7ce6ba3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.0", + "astor >=0.6.0", + "gast >=0.2.0", + "google-pasta >=0.1.6", + "grpcio >=1.8.6", + "keras-applications >=1.0.6", + "keras-preprocessing >=1.0.5", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.14.6,<2.0a0", + "protobuf >=3.6.1", + "python >=3.7,<3.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "917ccc8f3cb767d11a808702fe93db2b", + "name": "tensorflow-base", + "sha256": "1550fc125b1e1b7f0a968662638802c3f6ba2334d21f0be6f4a20fd076de4b98", + "size": 88517222, + "subdir": "linux-64", + "timestamp": 1560991017709, + "version": "1.14.0" + }, + "tensorflow-base-1.15.0-eigen_py27hd4672e3_0.conda": { + "build": "eigen_py27hd4672e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "backports.weakref >=1.0.0inf.1,<2.0a0", + "enum34 >=1.1.6,<2.0a0", + "future", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "mock >=2.0.0,<3.0a0", + "opt_einsum >=2.3.2,<3.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=2.7,<2.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f2038b080444d1fbd2fd8c0956b5f231", + "name": "tensorflow-base", + "sha256": "8ae5b2772358943a6e80611455dbf6636272d61bf99252881d5082cd2e30cc5f", + "size": 66837760, + "subdir": "linux-64", + "timestamp": 1573095590157, + "version": "1.15.0" + }, + "tensorflow-base-1.15.0-eigen_py36h52b156a_0.conda": { + "build": "eigen_py36h52b156a_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.6,<3.7.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d061bd95c1e1d36dfa5ebcc1e997a93d", + "name": "tensorflow-base", + "sha256": "5cc40a57a799766137eeb49ad56a0f68ecac82a87bf58848bf3dd8ac8cdf3451", + "size": 66904832, + "subdir": "linux-64", + "timestamp": 1573070363381, + "version": "1.15.0" + }, + "tensorflow-base-1.15.0-eigen_py37h52b156a_0.conda": { + "build": "eigen_py37h52b156a_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.7,<3.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fb688463f5ed639cff1ffee92ff0330e", + "name": "tensorflow-base", + "sha256": "27e64e680d11bb3dc55e9e1b5e8709d5e9d4c0ec6c0ae961607828d5141583a6", + "size": 66830564, + "subdir": "linux-64", + "timestamp": 1573088299487, + "version": "1.15.0" + }, + "tensorflow-base-1.15.0-gpu_py27hf473bbb_0.conda": { + "build": "gpu_py27hf473bbb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "backports.weakref >=1.0.0inf.1,<2.0a0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.4,<8.0a0", + "cupti", + "enum34 >=1.1.6,<2.0a0", + "future", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "mock >=2.0.0,<3.0a0", + "numpy >=1.16.5,<2.0a0", + "opt_einsum >=2.3.2,<3.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=2.7,<2.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "80ffdf29a58fbc01213e90a948c2235c", + "name": "tensorflow-base", + "sha256": "1458249353cc887b37ff393f38244533a1bc34f77bfaefc1dccc202780d55c26", + "size": 163963954, + "subdir": "linux-64", + "timestamp": 1573243833688, + "version": "1.15.0" + }, + "tensorflow-base-1.15.0-gpu_py36h9dcbed7_0.conda": { + "build": "gpu_py36h9dcbed7_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.4,<8.0a0", + "cupti", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "numpy >=1.16.5,<2.0a0", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.6,<3.7.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6a05fdfde8ea154586fb12ec7525ba40", + "name": "tensorflow-base", + "sha256": "3e1b1a2fb27a6806519b881dceec8dd3e506bbf9345fa01ec95043017adccbfc", + "size": 164108511, + "subdir": "linux-64", + "timestamp": 1573253133339, + "version": "1.15.0" + }, + "tensorflow-base-1.15.0-gpu_py37h9dcbed7_0.conda": { + "build": "gpu_py37h9dcbed7_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.4,<8.0a0", + "cupti", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "numpy >=1.16.5,<2.0a0", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.7,<3.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "642c7079c10065f920f111d4e6046812", + "name": "tensorflow-base", + "sha256": "435dd86517bff63efc3e53c211910a4bd9539a522df2556006aed62a16033af6", + "size": 164067300, + "subdir": "linux-64", + "timestamp": 1573156246826, + "version": "1.15.0" + }, + "tensorflow-base-1.15.0-mkl_py27h503033c_0.conda": { + "build": "mkl_py27h503033c_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "backports.weakref >=1.0.0inf.1,<2.0a0", + "enum34 >=1.1.6,<2.0a0", + "future", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "mock >=2.0.0,<3.0a0", + "opt_einsum >=2.3.2,<3.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=2.7,<2.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cca21d1d298abdcac62e76d88353c655", + "name": "tensorflow-base", + "sha256": "5da603a5c7261e9427cbecc342eac083900584cfbd8ca89d4b1fbd7c92472d48", + "size": 91672228, + "subdir": "linux-64", + "timestamp": 1573092604419, + "version": "1.15.0" + }, + "tensorflow-base-1.15.0-mkl_py36he1670d9_0.conda": { + "build": "mkl_py36he1670d9_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.6,<3.7.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ba1b8a0cdc8e0540dcf9f0411366524b", + "name": "tensorflow-base", + "sha256": "489ca5c88776e1dc9d2dd11dbfdfdaac6664910fda06027989244bf133142d66", + "size": 91798191, + "subdir": "linux-64", + "timestamp": 1573073622545, + "version": "1.15.0" + }, + "tensorflow-base-1.15.0-mkl_py37he1670d9_0.conda": { + "build": "mkl_py37he1670d9_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.7,<3.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ebd9fca12fab845b23313c411c6fa3b3", + "name": "tensorflow-base", + "sha256": "a4109404982901a4d58b78191540d5afaceb6fa2faba221963a02d6d870722f0", + "size": 91731652, + "subdir": "linux-64", + "timestamp": 1573085149789, + "version": "1.15.0" + }, + "tensorflow-base-1.4.1-py27hd00c003_2.conda": { + "build": "py27hd00c003_2", + "build_number": 2, + "depends": [ + "enum34 >=1.1.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.3.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8a6260459afa54ca4925ce460b412112", + "name": "tensorflow-base", + "sha256": "ae3308ba3d5cc3f0afee4a097e20a56a1f85de6942241daf1058a2a6f790a02e", + "size": 23350521, + "subdir": "linux-64", + "timestamp": 1516402489774, + "version": "1.4.1" + }, + "tensorflow-base-1.4.1-py35hd00c003_2.conda": { + "build": "py35hd00c003_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.3.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d7fd81f83c04462fdd6cdfa687256553", + "name": "tensorflow-base", + "sha256": "108e81cc4dec82cabe348729df51ffe143ba2b45504e271f3b317795b0afd64f", + "size": 23225628, + "subdir": "linux-64", + "timestamp": 1516402697312, + "version": "1.4.1" + }, + "tensorflow-base-1.4.1-py36hd00c003_2.conda": { + "build": "py36hd00c003_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.3.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "01306c8a53d86a18371ec314399b0edb", + "name": "tensorflow-base", + "sha256": "6fab5fcad6accd36106a9a8c6d4fd5915f7352c8941d69df7e61bb18e2ceb67b", + "size": 23177072, + "subdir": "linux-64", + "timestamp": 1516399935071, + "version": "1.4.1" + }, + "tensorflow-base-1.5.0-py27hff88cb2_1.conda": { + "build": "py27hff88cb2_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl", + "mock >=2.0.0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "70d7d16aeb0f9a91d6b54b796cdc3370", + "name": "tensorflow-base", + "sha256": "b69b913729fdf7ec5b1ce0ddf5866c98dbd51d4ff243f23645f086430f52baa3", + "size": 26821079, + "subdir": "linux-64", + "timestamp": 1519535882351, + "version": "1.5.0" + }, + "tensorflow-base-1.5.0-py35hff88cb2_1.conda": { + "build": "py35hff88cb2_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0f3cb20758b543ac6ab58442492f6230", + "name": "tensorflow-base", + "sha256": "3934b182c2605cd37b46324789ecd80953fc2f013dae689ef2506233c6ac778b", + "size": 26812303, + "subdir": "linux-64", + "timestamp": 1519467261172, + "version": "1.5.0" + }, + "tensorflow-base-1.5.0-py36hff88cb2_1.conda": { + "build": "py36hff88cb2_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f783ec6ae658d2a876069cd6ce766e58", + "name": "tensorflow-base", + "sha256": "5f59a382f9f94869c371f16652a0d77509ac4312f116b0c721c184de99cfc65c", + "size": 27694796, + "subdir": "linux-64", + "timestamp": 1519494029516, + "version": "1.5.0" + }, + "tensorflow-base-1.6.0-py27hdbcaa40_1.conda": { + "build": "py27hdbcaa40_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d6287e1ba23af79d41a762c00c8aaa48", + "name": "tensorflow-base", + "sha256": "257da10c779370493bb17c95ffed9c9e1380e58b50308ff0a3c85611de6e8450", + "size": 26059916, + "subdir": "linux-64", + "timestamp": 1525894556062, + "version": "1.6.0" + }, + "tensorflow-base-1.6.0-py27hff88cb2_0.conda": { + "build": "py27hff88cb2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0a6708688fb6971ff6ad8206b87011bc", + "name": "tensorflow-base", + "sha256": "9b2d611bbf39cd1b82afd5ad4d01e131f2e4a3024f0b7e78145aad54e6fcf837", + "size": 27980689, + "subdir": "linux-64", + "timestamp": 1521151929472, + "version": "1.6.0" + }, + "tensorflow-base-1.6.0-py35hdbcaa40_1.conda": { + "build": "py35hdbcaa40_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9be11df46325c8b3f9bea154537affe4", + "name": "tensorflow-base", + "sha256": "6b2e48865e009de8420785591d8a43756b13c215ed3574e1d724898e590b6547", + "size": 25085170, + "subdir": "linux-64", + "timestamp": 1525894557457, + "version": "1.6.0" + }, + "tensorflow-base-1.6.0-py35hff88cb2_0.conda": { + "build": "py35hff88cb2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b59c23d16975c82dbcfb8d520ed39aa0", + "name": "tensorflow-base", + "sha256": "5ae8e7f77d478c5855ba63ffeac997400c5ed9fc9e5b6d9f457b35a37ffd83d6", + "size": 26993613, + "subdir": "linux-64", + "timestamp": 1521176075311, + "version": "1.6.0" + }, + "tensorflow-base-1.6.0-py36hdbcaa40_1.conda": { + "build": "py36hdbcaa40_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0b7b5b51593bd39e3adeba7ebb5ec027", + "name": "tensorflow-base", + "sha256": "e539b5b33cd5233efc8dd3f7d096fd26af78a5e12fa8099724d6d409fec07475", + "size": 25968489, + "subdir": "linux-64", + "timestamp": 1525894614592, + "version": "1.6.0" + }, + "tensorflow-base-1.6.0-py36hff88cb2_0.conda": { + "build": "py36hff88cb2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dcd77a609d85906345c182608197560b", + "name": "tensorflow-base", + "sha256": "3c1c669f033c95cb440e3d12be09e55cffa1c986bdd4c7c14eabcf753ef855ba", + "size": 27954477, + "subdir": "linux-64", + "timestamp": 1521176284348, + "version": "1.6.0" + }, + "tensorflow-base-1.7.0-py27hdbcaa40_2.conda": { + "build": "py27hdbcaa40_2", + "build_number": 2, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6f9d3bb681df291d20e5f1141e4d2886", + "name": "tensorflow-base", + "sha256": "e73f7b630de445b3c7400c310bacfcb4fbe2f58aa8fc16f8e7358a34f16d0686", + "size": 26142881, + "subdir": "linux-64", + "timestamp": 1525883251042, + "version": "1.7.0" + }, + "tensorflow-base-1.7.0-py27hff88cb2_0.conda": { + "build": "py27hff88cb2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b6423a04248114cb8ccce0718ef8a3bb", + "name": "tensorflow-base", + "sha256": "dc63df475f818db086ab169978f44cfd885bc12a67283878487727c805a10437", + "size": 30367686, + "subdir": "linux-64", + "timestamp": 1524273608030, + "version": "1.7.0" + }, + "tensorflow-base-1.7.0-py35hdbcaa40_2.conda": { + "build": "py35hdbcaa40_2", + "build_number": 2, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cf8af337e24e815d1235f4c8d21d67db", + "name": "tensorflow-base", + "sha256": "5be6c3c271a37532f241c9370d62a4c5ef9b353f5513fcce309f9bb088adc21c", + "size": 26290309, + "subdir": "linux-64", + "timestamp": 1525886989699, + "version": "1.7.0" + }, + "tensorflow-base-1.7.0-py35hff88cb2_0.conda": { + "build": "py35hff88cb2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "22f3678732349b83677fb35c2842aa44", + "name": "tensorflow-base", + "sha256": "89cc68b171ad9aab95d3c13261e8b894476daca7614f406c29a693e3c42ed014", + "size": 29260680, + "subdir": "linux-64", + "timestamp": 1524273560912, + "version": "1.7.0" + }, + "tensorflow-base-1.7.0-py36hdbcaa40_2.conda": { + "build": "py36hdbcaa40_2", + "build_number": 2, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4d823234544c86bc67e5806f6556aafd", + "name": "tensorflow-base", + "sha256": "676b6cb17bdf699d436a35d86a050cdf3e4cf349a4715eeaab8780cc923c3322", + "size": 26420181, + "subdir": "linux-64", + "timestamp": 1525886988498, + "version": "1.7.0" + }, + "tensorflow-base-1.7.0-py36hff88cb2_0.conda": { + "build": "py36hff88cb2_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "234ea1ca332d9c8d7b2e3f74c24af900", + "name": "tensorflow-base", + "sha256": "4f497bf2ee0d4ab672914626d4eea7d5261d0281480f5e42b35edd9f8c60d933", + "size": 29462571, + "subdir": "linux-64", + "timestamp": 1524271577294, + "version": "1.7.0" + }, + "tensorflow-base-1.8.0-py27h4df133c_0.conda": { + "build": "py27h4df133c_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "20dede7677f234c47b0df59eb5e9ef72", + "name": "tensorflow-base", + "sha256": "04dd0e4d7dcb828bdd104d366b433d9f1f20abb4b818b7918005c3589b5214bb", + "size": 68891018, + "subdir": "linux-64", + "timestamp": 1527168757820, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py27h5f64886_0.conda": { + "build": "py27h5f64886_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cbead97ea27feb3372059fdafb77da7e", + "name": "tensorflow-base", + "sha256": "11ec74126970593b1e8671dd9f156337ca7a6b8be63eca2d2f60eaede327f5d0", + "size": 28615474, + "subdir": "linux-64", + "timestamp": 1527045820681, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py27hc1a7637_0.conda": { + "build": "py27hc1a7637_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e7d365abb16a1ba5e134ba08873fbd7a", + "name": "tensorflow-base", + "sha256": "0611731967f932139dd7822854fa73f45e939b64b324caa584da10314011eb81", + "size": 74576938, + "subdir": "linux-64", + "timestamp": 1527180195584, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py27hee38f2d_0.conda": { + "build": "py27hee38f2d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d7f6b1d52d4bd5becfbeb704786cfbac", + "name": "tensorflow-base", + "sha256": "f051e13a5e6a03db76009f8be08c358f6a44962433c66f08a54148824d56c9c1", + "size": 52160344, + "subdir": "linux-64", + "timestamp": 1527061395268, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py35h4df133c_0.conda": { + "build": "py35h4df133c_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c56a1ca9a63fbc2a00cbad33c84d7be5", + "name": "tensorflow-base", + "sha256": "82bad19e70addedc57c6f034ef103e7e4953a2a57328c662381ff3ca4bceecec", + "size": 68979665, + "subdir": "linux-64", + "timestamp": 1527171933295, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py35h5f64886_0.conda": { + "build": "py35h5f64886_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b6f7affc1afe142d2f9d26ec2cbf6724", + "name": "tensorflow-base", + "sha256": "880a8e3adc1553bc77de46b553347b622cd9a27ebaa37c36d70c1f2274694626", + "size": 28676133, + "subdir": "linux-64", + "timestamp": 1527045891435, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py35hc1a7637_0.conda": { + "build": "py35hc1a7637_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "41a753e8be205bf79106547a5cb22737", + "name": "tensorflow-base", + "sha256": "68a4dda2722cb9fc19147a848e757c39fd4681ad1eec3f47559f581625eb2a55", + "size": 75639097, + "subdir": "linux-64", + "timestamp": 1527183144886, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py35hee38f2d_0.conda": { + "build": "py35hee38f2d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7395c456726bd2d200c96dddfbad9e09", + "name": "tensorflow-base", + "sha256": "43ee84ba3270b7523339cbcd3507be049446cc5df640c7775f551f441f637364", + "size": 53260217, + "subdir": "linux-64", + "timestamp": 1527061464305, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py36h4df133c_0.conda": { + "build": "py36h4df133c_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "39d88172aaa981e93c62036b2d8f20e8", + "name": "tensorflow-base", + "sha256": "00b0aa5aff837097376e8ffa27f40d8ad4f870cc926a7ef2ffbb9964c908195f", + "size": 68936766, + "subdir": "linux-64", + "timestamp": 1527164465407, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py36h5f64886_0.conda": { + "build": "py36h5f64886_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d701d3b18b09113e31743a2fd36ed5c0", + "name": "tensorflow-base", + "sha256": "f40153929f26beb2c6d7796723d074e54be080498ffd2d828ea8e510881d9fff", + "size": 27664643, + "subdir": "linux-64", + "timestamp": 1527041027886, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py36hc1a7637_0.conda": { + "build": "py36hc1a7637_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "50335688b17afa439e1741e50e2f217b", + "name": "tensorflow-base", + "sha256": "a4c06a7cf1a78507f0d937fcb3c39f540bed7aed04fac56e527ab05ca372dc13", + "size": 75650616, + "subdir": "linux-64", + "timestamp": 1527176803509, + "version": "1.8.0" + }, + "tensorflow-base-1.8.0-py36hee38f2d_0.conda": { + "build": "py36hee38f2d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "823ed07bd456590daec2cf015b0c352f", + "name": "tensorflow-base", + "sha256": "291a7329a0078e610f7fa7aa08a5d8ccb7b9d9451e2e92e068c5cf04c3c39596", + "size": 52253657, + "subdir": "linux-64", + "timestamp": 1527061395250, + "version": "1.8.0" + }, + "tensorflow-base-1.9.0-eigen_py27hdfca3bf_0.conda": { + "build": "eigen_py27hdfca3bf_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c0b1359e4971891cc1c9872abaf9fd27", + "name": "tensorflow-base", + "sha256": "16dd9e8904f8362029f059fef6b0efa854abd6d26593dffca96da3a74e11f322", + "size": 29946834, + "subdir": "linux-64", + "timestamp": 1532467501690, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-eigen_py35hdfca3bf_0.conda": { + "build": "eigen_py35hdfca3bf_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7688b2cbe309f8044315b1b62358c02c", + "name": "tensorflow-base", + "sha256": "4fe20e3283d361ccab605465e3370a9688a99964209d42ef0fd476243fc086ba", + "size": 30037211, + "subdir": "linux-64", + "timestamp": 1532469529610, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-eigen_py36hdfca3bf_0.conda": { + "build": "eigen_py36hdfca3bf_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bf4a784f51496632e7bf360256fa7170", + "name": "tensorflow-base", + "sha256": "26ce94b1594d439945bd1e5b7dd6335865bb93ee5a65b31cd98b9fa9cecda871", + "size": 29983065, + "subdir": "linux-64", + "timestamp": 1532464098777, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-gpu_py27h6ecc378_0.conda": { + "build": "gpu_py27h6ecc378_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "007c4e03b27f377db3d625131f511bf1", + "name": "tensorflow-base", + "sha256": "3a23725d07ef0df1a5bd04bebb93476d676f274906669f66c11e61be3fd1bc36", + "size": 78549560, + "subdir": "linux-64", + "timestamp": 1532620092714, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-gpu_py27h9f529ab_0.conda": { + "build": "gpu_py27h9f529ab_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0", + "package_has_been_revoked", + "package_has_been_revoked" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7daf295295e21aac534a6e8e1afe6496", + "name": "tensorflow-base", + "revoked": true, + "sha256": "841b79b2268b3d4b3077fe9df70f31619161ddd9ace3b31ab044b3bf4508d132", + "size": 72219044, + "subdir": "linux-64", + "timestamp": 1532639215060, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-gpu_py27h9f529ab_1.conda": { + "build": "gpu_py27h9f529ab_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "08ab862cfefbef80a95ae27b824d453a", + "name": "tensorflow-base", + "sha256": "8c4ee783e96c70475a42022cad481d976f0d688d27c537c487a7895812531786", + "size": 72219052, + "subdir": "linux-64", + "timestamp": 1532639215060, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-gpu_py35h6ecc378_0.conda": { + "build": "gpu_py35h6ecc378_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8b9eb443d80cd26f3c32729f0b3d868d", + "name": "tensorflow-base", + "sha256": "4efe7a016d09e39c340d8bba1a8aeb8936a34d9540cf79652b40bc8031a1e299", + "size": 78625667, + "subdir": "linux-64", + "timestamp": 1532621825865, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-gpu_py35h9f529ab_0.conda": { + "build": "gpu_py35h9f529ab_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0", + "package_has_been_revoked", + "package_has_been_revoked" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e3599c652a2648f0d2c4baaefce7e95f", + "name": "tensorflow-base", + "revoked": true, + "sha256": "d728e3f365643b7afce736d5b9318a6c0174ece3162115bfeaa1e629dd65ec98", + "size": 71237368, + "subdir": "linux-64", + "timestamp": 1532640820146, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-gpu_py35h9f529ab_1.conda": { + "build": "gpu_py35h9f529ab_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d7fc367055b9b1ce6d56db42041747de", + "name": "tensorflow-base", + "sha256": "c3d828f4fc03944aaeb6212aa6666cfeac77d165c2c2451eefcf12e0aff21711", + "size": 71237348, + "subdir": "linux-64", + "timestamp": 1532640820146, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-gpu_py36h6ecc378_0.conda": { + "build": "gpu_py36h6ecc378_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "81ecc36976259cc0bb57f24804039802", + "name": "tensorflow-base", + "sha256": "07ecac404b87e1a04591168a056daedbba8ee297f6940a8759a0d2600883327a", + "size": 78584351, + "subdir": "linux-64", + "timestamp": 1532617321129, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-gpu_py36h9f529ab_0.conda": { + "build": "gpu_py36h9f529ab_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0", + "package_has_been_revoked", + "package_has_been_revoked" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "365ffc59eae25f099a32cc2d5f0e09b8", + "name": "tensorflow-base", + "revoked": true, + "sha256": "158b79d271018c1fe38fbbe013789d42e382b8a6130a96715c771a9a236cfa7a", + "size": 72248672, + "subdir": "linux-64", + "timestamp": 1532636773336, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-gpu_py36h9f529ab_1.conda": { + "build": "gpu_py36h9f529ab_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.1.0,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e664ff6dccad1b676eebcfaf122de35d", + "name": "tensorflow-base", + "sha256": "c09679db3b30ced6f03992db03333ba706ee11c1e8e781dafa6ea256c8abfd14", + "size": 72248698, + "subdir": "linux-64", + "timestamp": 1532636773336, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-mkl_py27h2ca6a6a_0.conda": { + "build": "mkl_py27h2ca6a6a_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1ba44de09fe0181800957a1a4b8a7ff4", + "name": "tensorflow-base", + "sha256": "1e9c31757b56ad2c4c13b71f94ea2bceb2fe3cd56f0a77429928321e7d84daff", + "size": 56213524, + "subdir": "linux-64", + "timestamp": 1532466569453, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-mkl_py35h2ca6a6a_0.conda": { + "build": "mkl_py35h2ca6a6a_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d30d7fd9d1f674d4a66e21f60c23bbdf", + "name": "tensorflow-base", + "sha256": "1a9a89f41266bbe57d159cb78696f81c8f0372495da31b915522f56d2b27bf9c", + "size": 56277214, + "subdir": "linux-64", + "timestamp": 1532468554085, + "version": "1.9.0" + }, + "tensorflow-base-1.9.0-mkl_py36h2ca6a6a_0.conda": { + "build": "mkl_py36h2ca6a6a_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "019984b33a6c2647826a01c2a53b619d", + "name": "tensorflow-base", + "sha256": "070917b55cece189426890d65075816e2bd99b773f1f8909fcacd70756857bb0", + "size": 55243132, + "subdir": "linux-64", + "timestamp": 1532465095637, + "version": "1.9.0" + }, + "tensorflow-base-2.0.0-eigen_py27hce92a77_0.conda": { + "build": "eigen_py27hce92a77_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "backports.weakref >=1.0.0inf.1,<2.0a0", + "enum34 >=1.1.6,<2.0a0", + "future", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "mock >=2.0.0,<3.0a0", + "opt_einsum >=2.3.2,<3.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=2.7,<2.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2fc1c5842c0459b2fbb3e92e0cd662a7", + "name": "tensorflow-base", + "sha256": "4587ba8aa5e5dbf58ac705990004550d1f29f7c06bb1b15f579e53db7c297e41", + "size": 54268432, + "subdir": "linux-64", + "timestamp": 1571430043669, + "version": "2.0.0" + }, + "tensorflow-base-2.0.0-eigen_py36h4ed9498_0.conda": { + "build": "eigen_py36h4ed9498_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.6,<3.7.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "de258b7aa57e7eafdb9c094405706f1c", + "name": "tensorflow-base", + "sha256": "0547ffc073c5ce57beaff57909bff0d1936325004d345dcacc5c8a35d589e076", + "size": 54382104, + "subdir": "linux-64", + "timestamp": 1571424691149, + "version": "2.0.0" + }, + "tensorflow-base-2.0.0-eigen_py37h4ed9498_0.conda": { + "build": "eigen_py37h4ed9498_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.7,<3.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8e1af31429cff0179033ae07edd72909", + "name": "tensorflow-base", + "sha256": "fd91d978f720ee41fcdaf8a627dc9025113c0173f6720b956052fc848d1c1a2e", + "size": 54468967, + "subdir": "linux-64", + "timestamp": 1571418185158, + "version": "2.0.0" + }, + "tensorflow-base-2.0.0-gpu_py27h356bb79_0.conda": { + "build": "gpu_py27h356bb79_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "backports.weakref >=1.0.0inf.1,<2.0a0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6.0,<8.0a0", + "cupti", + "enum34 >=1.1.6,<2.0a0", + "future", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "mock >=2.0.0,<3.0a0", + "opt_einsum >=2.3.2,<3.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=2.7,<2.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "12eb45171ad48a82e71c14d9de40ca3c", + "name": "tensorflow-base", + "sha256": "8cccef1d40aee1da4b58a209dd1a92903305baa8a81cd28535d18784469397c4", + "size": 148427573, + "subdir": "linux-64", + "timestamp": 1571692376358, + "version": "2.0.0" + }, + "tensorflow-base-2.0.0-gpu_py36h0ec5d1f_0.conda": { + "build": "gpu_py36h0ec5d1f_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6.0,<8.0a0", + "cupti", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.6,<3.7.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "04db2246669c3dadf0229a9e270a2a0d", + "name": "tensorflow-base", + "sha256": "9985ea26d5a01bd5a95b879d3c0fef679ca6aff8679c1c1b251672cf59bbf1a9", + "size": 148388123, + "subdir": "linux-64", + "timestamp": 1571686492444, + "version": "2.0.0" + }, + "tensorflow-base-2.0.0-gpu_py37h0ec5d1f_0.conda": { + "build": "gpu_py37h0ec5d1f_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "cudatoolkit >=10.0.130,<10.1.0a0", + "cudnn >=7.6.0,<8.0a0", + "cupti", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.7,<3.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9f0f0b8f2cd2a0759ad2c123ca14df44", + "name": "tensorflow-base", + "sha256": "be9b2679790a20d0ec86e6f990ba7dee5e4c45b27beb53a2589a0c31a282cad1", + "size": 148459870, + "subdir": "linux-64", + "timestamp": 1571680265061, + "version": "2.0.0" + }, + "tensorflow-base-2.0.0-mkl_py27had7a488_0.conda": { + "build": "mkl_py27had7a488_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "backports.weakref >=1.0.0inf.1,<2.0a0", + "enum34 >=1.1.6,<2.0a0", + "future", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "mock >=2.0.0,<3.0a0", + "opt_einsum >=2.3.2,<3.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=2.7,<2.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ee73c367f37522f95ac15c12b9f2d388", + "name": "tensorflow-base", + "sha256": "2410db8289cd1fb84f90a1ef324920e609c0e12972ac8f37ba2593b76f463a6b", + "size": 81055248, + "subdir": "linux-64", + "timestamp": 1571427739657, + "version": "2.0.0" + }, + "tensorflow-base-2.0.0-mkl_py36h9204916_0.conda": { + "build": "mkl_py36h9204916_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.6,<3.7.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ea70156ddca2e35ffce206d79d54bbb0", + "name": "tensorflow-base", + "sha256": "a94c485fc987cea49a010c4296388b582d7b9cf98909a2e9b3377b3e67ac3136", + "size": 80887640, + "subdir": "linux-64", + "timestamp": 1571422667762, + "version": "2.0.0" + }, + "tensorflow-base-2.0.0-mkl_py37h9204916_0.conda": { + "build": "mkl_py37h9204916_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1,<1.0a0", + "astor >=0.6.2,<1.0a0", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7,<1.0a0", + "grpcio >=1.14.1,<2.0a0", + "keras-applications >=1.0.8,<2.0a0", + "keras-preprocessing >=1.0.5,<2.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "markdown >=2.6.11", + "opt_einsum >=3.1.0,<4.0a0", + "protobuf >=3.6.1,<4.0a0", + "python >=3.7,<3.8.0a0", + "six >=1.12.0,<2.0a0", + "termcolor >=1.1.0,<2.0a0", + "werkzeug >=0.14.1,<1.0a0", + "wrapt >=1.11.2,<2.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3e055ba79e161f853c16a2f0e5b978c1", + "name": "tensorflow-base", + "sha256": "bca9261015a219dd1d53356dcd5f04cdc6f055a88eb13b9b1b87fc014b67aff9", + "size": 80868461, + "subdir": "linux-64", + "timestamp": 1571416221300, + "version": "2.0.0" + }, + "tensorflow-base-2.1.0-eigen_py27hedad41d_0.conda": { + "build": "eigen_py27hedad41d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astor >=0.6.2", + "backports.weakref >=1.0", + "enum34 >=1.1.6", + "functools32 >=3.2.3.2", + "future", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7", + "grpcio >=1.14.1", + "keras-applications >=1.0.8", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=2.7,<2.8.0a0", + "scipy >=1.2.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b4e006d9db0887a6a8ad38d231726758", + "name": "tensorflow-base", + "sha256": "34758b612fe0f7630a63d652042ad9d0b8c357737526776d1b5944e01edcbf60", + "size": 60859793, + "subdir": "linux-64", + "timestamp": 1582004093834, + "version": "2.1.0" + }, + "tensorflow-base-2.1.0-eigen_py36h0c57e5d_0.conda": { + "build": "eigen_py36h0c57e5d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astor >=0.6.2", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7", + "grpcio >=1.14.1", + "keras-applications >=1.0.8", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.8.0", + "python >=3.6,<3.7.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c9319ae81b5d3cebc7e9fc5183472e51", + "name": "tensorflow-base", + "sha256": "a02b8fd2f7549a16963bedf24b76d137054b78b249cb4a1a0257a7442a1d3a5a", + "size": 58414619, + "subdir": "linux-64", + "timestamp": 1582037582444, + "version": "2.1.0" + }, + "tensorflow-base-2.1.0-eigen_py37h0c57e5d_0.conda": { + "build": "eigen_py37h0c57e5d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astor >=0.6.2", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7", + "grpcio >=1.14.1", + "keras-applications >=1.0.8", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.8.0", + "python >=3.7,<3.8.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f0f3f9dd016fed152f72102e210c74b6", + "name": "tensorflow-base", + "sha256": "de4fbb3aaec1881291f8846cb1ca67a48c5383ca73a65a44f1c8af95b3d01b94", + "size": 60593972, + "subdir": "linux-64", + "timestamp": 1581993773849, + "version": "2.1.0" + }, + "tensorflow-base-2.1.0-gpu_py27hb9b3ea8_0.conda": { + "build": "gpu_py27hb9b3ea8_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astor >=0.6.2", + "backports.weakref >=1.0", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "cupti", + "enum34 >=1.1.6", + "functools32 >=3.2.3.2", + "future", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7", + "grpcio >=1.14.1", + "keras-applications >=1.0.8", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=2.7,<2.8.0a0", + "scipy >=1.2.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7b81f34faaa15cecac2228be7fc31498", + "name": "tensorflow-base", + "sha256": "ee7e57993a0d32c5f4ce1da9a2f77b5aaf8962725d08564d79ed1aaad4fc45dd", + "size": 162545332, + "subdir": "linux-64", + "timestamp": 1582127345546, + "version": "2.1.0" + }, + "tensorflow-base-2.1.0-gpu_py36h6c5654b_0.conda": { + "build": "gpu_py36h6c5654b_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astor >=0.6.2", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "cupti", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7", + "grpcio >=1.14.1", + "keras-applications >=1.0.8", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.8.0", + "python >=3.6,<3.7.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "247ea75f553a11023cf8995eb26830e3", + "name": "tensorflow-base", + "sha256": "3116e6c52b3ee21d524239868f00863cf872e9f0e167f85fcd1eb118726bdbc0", + "size": 163493886, + "subdir": "linux-64", + "timestamp": 1582137937791, + "version": "2.1.0" + }, + "tensorflow-base-2.1.0-gpu_py37h6c5654b_0.conda": { + "build": "gpu_py37h6c5654b_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astor >=0.6.2", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "cupti", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7", + "grpcio >=1.14.1", + "keras-applications >=1.0.8", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.8.0", + "python >=3.7,<3.8.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e9aae94f08f552435d524c94d16b98a5", + "name": "tensorflow-base", + "sha256": "a0cd93254fe5754c31a2435deca41f65835e74f348850521e67cbaa14fd5e4c7", + "size": 162827954, + "subdir": "linux-64", + "timestamp": 1582085009709, + "version": "2.1.0" + }, + "tensorflow-base-2.1.0-mkl_py27hb6fb96e_0.conda": { + "build": "mkl_py27hb6fb96e_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astor >=0.6.2", + "backports.weakref >=1.0", + "enum34 >=1.1.6", + "functools32 >=3.2.3.2", + "future", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7", + "grpcio >=1.14.1", + "keras-applications >=1.0.8", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=2.7,<2.8.0a0", + "scipy >=1.2.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "479065a4cbf4f00e0ab09ae58b518ecc", + "name": "tensorflow-base", + "sha256": "814f61ba7edffbcc3408b752de4d7f35568e6b59e47f09b40910cc5ce9f6445a", + "size": 98047563, + "subdir": "linux-64", + "timestamp": 1582007764881, + "version": "2.1.0" + }, + "tensorflow-base-2.1.0-mkl_py36h6d63fb7_0.conda": { + "build": "mkl_py36h6d63fb7_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astor >=0.6.2", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7", + "grpcio >=1.14.1", + "keras-applications >=1.0.8", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.8.0", + "python >=3.6,<3.7.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "988ee32e05e684213b89f207a35e0b65", + "name": "tensorflow-base", + "sha256": "b41845ceb7380723a757970f6337ff65b00b29fe65e9f3becef08a382693b402", + "size": 99025583, + "subdir": "linux-64", + "timestamp": 1582041224818, + "version": "2.1.0" + }, + "tensorflow-base-2.1.0-mkl_py37h6d63fb7_0.conda": { + "build": "mkl_py37h6d63fb7_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astor >=0.6.2", + "gast >=0.2.2,<0.2.3.0a0", + "google-pasta >=0.1.7", + "grpcio >=1.14.1", + "keras-applications >=1.0.8", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.8.0", + "python >=3.7,<3.8.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c883a6b8c0673c8510c6b36036173299", + "name": "tensorflow-base", + "sha256": "ad80b6ce54dc60ef35155e404d9816ac69aca6aa3933064b63b107860016a1cd", + "size": 99846515, + "subdir": "linux-64", + "timestamp": 1581997410194, + "version": "2.1.0" + }, + "tensorflow-base-2.10.0-eigen_py310h1969d1f_0.conda": { + "build": "eigen_py310h1969d1f_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d645278fbe72dda58f5cc9a1ffc57976", + "name": "tensorflow-base", + "sha256": "c8bf01ae74857a4c01e5bd2d5d07e296889140792f950583c1df3f14faba266e", + "size": 101907164, + "subdir": "linux-64", + "timestamp": 1666980402968, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-eigen_py37h1969d1f_0.conda": { + "build": "eigen_py37h1969d1f_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.7,<3.8.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7b57cb01f90fdf8590f7121d5edf28be", + "name": "tensorflow-base", + "sha256": "0da0863cb31ac4b37f06ef10b3e993a7efb1f00d9fec0d5b4b69693e75871738", + "size": 101970010, + "subdir": "linux-64", + "timestamp": 1666900483140, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-eigen_py38h1969d1f_0.conda": { + "build": "eigen_py38h1969d1f_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6e1d4404072193ccc41107762ee1b2c2", + "name": "tensorflow-base", + "sha256": "4ff655e069564ed3f4072cecd52b103e74272559e0266c739af4107b82dad0b4", + "size": 101396324, + "subdir": "linux-64", + "timestamp": 1666935593871, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-eigen_py39h1969d1f_0.conda": { + "build": "eigen_py39h1969d1f_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e09e05c8eb5bb8f6023b87b0d9271429", + "name": "tensorflow-base", + "sha256": "97d56b4517525c9b4d6cf6761d3531d1abcb51ac8f29890bf2f939598acd088b", + "size": 105284249, + "subdir": "linux-64", + "timestamp": 1666971691462, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-gpu_py310h6559e04_0.conda": { + "build": "gpu_py310h6559e04_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7c6902d05b003d9c5ac79992fca430d8", + "name": "tensorflow-base", + "sha256": "c73e338c2f732749a6571910b7c2621d379296247b10454f7c9728541e6f7638", + "size": 295579639, + "subdir": "linux-64", + "timestamp": 1666987687109, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-gpu_py37h6559e04_0.conda": { + "build": "gpu_py37h6559e04_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.7,<3.8.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "436896ddefe63e13b5fe59657ba92c71", + "name": "tensorflow-base", + "sha256": "4a9b387ff4aa97f89ede4d7c31b13f86501509b634e45498c271fcd3fee7bc2f", + "size": 297309257, + "subdir": "linux-64", + "timestamp": 1666897461141, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-gpu_py38h6559e04_0.conda": { + "build": "gpu_py38h6559e04_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e90eebd3215fcee6cf54fc2fac919633", + "name": "tensorflow-base", + "sha256": "0fea3f38e843e337e6a95e213f823fa3a9c668bd5b5a4d126289081fae166a58", + "size": 297075688, + "subdir": "linux-64", + "timestamp": 1666945436197, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-gpu_py39h6559e04_0.conda": { + "build": "gpu_py39h6559e04_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a68a023a7af5428c52abfb08de0bd035", + "name": "tensorflow-base", + "sha256": "f1a266159299e89ab1a1edb6ff3635939e6f702efb9c2f117a00a225fd4acd2b", + "size": 298276109, + "subdir": "linux-64", + "timestamp": 1666968696065, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-mkl_py310hb9daa73_0.conda": { + "build": "mkl_py310hb9daa73_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2955197c20837cdb10698b68c0da86dd", + "name": "tensorflow-base", + "sha256": "e29542ea761988fac11fad95f5205c25946d94d00884d219bb3442270253ae63", + "size": 103727550, + "subdir": "linux-64", + "timestamp": 1666977618866, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-mkl_py37hb9daa73_0.conda": { + "build": "mkl_py37hb9daa73_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.7,<3.8.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "163b22aa989eb0eabc8bbab3f3df1321", + "name": "tensorflow-base", + "sha256": "7e6cfd3e675552726eb73ee363768f1d76b74807837f48edf547177f10e97f91", + "size": 102079505, + "subdir": "linux-64", + "timestamp": 1666903286610, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-mkl_py38hb9daa73_0.conda": { + "build": "mkl_py38hb9daa73_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f4e5bdde779cc39bcd6cd54806a7e5d8", + "name": "tensorflow-base", + "sha256": "816fb9ae8a50ecece1ffc4151f68c286ff7bd3d3e0691e768f6ad0a15df78cb5", + "size": 105362793, + "subdir": "linux-64", + "timestamp": 1666938392589, + "version": "2.10.0" + }, + "tensorflow-base-2.10.0-mkl_py39hb9daa73_0.conda": { + "build": "mkl_py39hb9daa73_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.10.*", + "libcurl >=7.85.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.10.*", + "tensorflow-estimator 2.10.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "de4f2eb4632ba743d28fb106b9a9baa3", + "name": "tensorflow-base", + "sha256": "766052cff65f94d30230bf1a06b90d7d2d8a76f95f1fc7679907b49ad05bccaf", + "size": 103411380, + "subdir": "linux-64", + "timestamp": 1666961458372, + "version": "2.10.0" + }, + "tensorflow-base-2.11.0-eigen_py310h3323580_0.conda": { + "build": "eigen_py310h3323580_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.11.*", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.39,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1t,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tensorboard 2.11.*", + "tensorflow-estimator 2.11.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e178fa2390cad740456982849f39ee9e", + "name": "tensorflow-base", + "sha256": "74c5beb3f9e1f210e55883f3f11dcf44ef1cc1721aa0b7dc9806e97d5b838ca6", + "size": 103037884, + "subdir": "linux-64", + "timestamp": 1678235166961, + "version": "2.11.0" + }, + "tensorflow-base-2.11.0-eigen_py38h3323580_0.conda": { + "build": "eigen_py38h3323580_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.11.*", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.39,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1t,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tensorboard 2.11.*", + "tensorflow-estimator 2.11.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "93afa602fc53d00928d4061451d14839", + "name": "tensorflow-base", + "sha256": "81f8be73665e03423aac931759dc7f5d01f969a6d1ea65776a4ccbccbe804117", + "size": 100981335, + "subdir": "linux-64", + "timestamp": 1678238021595, + "version": "2.11.0" + }, + "tensorflow-base-2.11.0-eigen_py39h3323580_0.conda": { + "build": "eigen_py39h3323580_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.11.*", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.39,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1t,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tensorboard 2.11.*", + "tensorflow-estimator 2.11.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0e87bf95ca87b7913414798b5fe0a387", + "name": "tensorflow-base", + "sha256": "abb0a7ccbd8378cea49b9077fa33bfe1aa5afd5088f398f57bb885c20c21dbef", + "size": 104352395, + "subdir": "linux-64", + "timestamp": 1678240841639, + "version": "2.11.0" + }, + "tensorflow-base-2.11.0-gpu_py310h24d65da_0.conda": { + "build": "gpu_py310h24d65da_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.11.*", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.39,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1t,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tensorboard 2.11.*", + "tensorflow-estimator 2.11.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "be70830038ec42c9d969f5512d78e33c", + "name": "tensorflow-base", + "sha256": "aed4582d3915605b6731495b81cb2f63292b6a08c2891452441b72012a1b5ea0", + "size": 301323977, + "subdir": "linux-64", + "timestamp": 1678217195743, + "version": "2.11.0" + }, + "tensorflow-base-2.11.0-gpu_py38h24d65da_0.conda": { + "build": "gpu_py38h24d65da_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.11.*", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.39,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1t,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tensorboard 2.11.*", + "tensorflow-estimator 2.11.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a09e78092d1364ce3e1608b4a500625c", + "name": "tensorflow-base", + "sha256": "054a383bfe41a3c5c11703ba40dbced6502aa0b64400e446ed7183a9ea66fd96", + "size": 301368144, + "subdir": "linux-64", + "timestamp": 1678224697495, + "version": "2.11.0" + }, + "tensorflow-base-2.11.0-gpu_py39h24d65da_0.conda": { + "build": "gpu_py39h24d65da_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.11.*", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.39,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1t,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tensorboard 2.11.*", + "tensorflow-estimator 2.11.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a323bc5206d9b8d222fcce2892685733", + "name": "tensorflow-base", + "sha256": "64d491b9cd0c644947a7d4fbefc63b7a6f791e3b68e3299711d2c269f8cb6fb1", + "size": 303187149, + "subdir": "linux-64", + "timestamp": 1678232116582, + "version": "2.11.0" + }, + "tensorflow-base-2.11.0-mkl_py310he5f8e37_0.conda": { + "build": "mkl_py310he5f8e37_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.11.*", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.39,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1t,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tensorboard 2.11.*", + "tensorflow-estimator 2.11.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "327a29409fb0f8da3a79139befd4c3e8", + "name": "tensorflow-base", + "sha256": "8457803955c9974745b35cf5a0b9d4304ebde6b2cd7cc506d25cee9de2c948e0", + "size": 103988975, + "subdir": "linux-64", + "timestamp": 1678243652815, + "version": "2.11.0" + }, + "tensorflow-base-2.11.0-mkl_py38he5f8e37_0.conda": { + "build": "mkl_py38he5f8e37_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.11.*", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.39,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1t,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tensorboard 2.11.*", + "tensorflow-estimator 2.11.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "087437df423ae878f000ddcd71bde8c9", + "name": "tensorflow-base", + "sha256": "00831214753d86ff8c5d3d7cd17a1d2ae01e356b7a3c5dfd3abe21b6004d3c15", + "size": 103445863, + "subdir": "linux-64", + "timestamp": 1678246442053, + "version": "2.11.0" + }, + "tensorflow-base-2.11.0-mkl_py39he5f8e37_0.conda": { + "build": "mkl_py39he5f8e37_0", + "build_number": 0, + "depends": [ + "absl-py >=1.0.0", + "astunparse >=1.6.3", + "flatbuffers >=2.0", + "gast 0.4.0.*", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.11.*", + "libcurl >=7.87.0,<8.0a0", + "libgcc-ng >=9.3.0", + "libpng >=1.6.39,<1.7.0a0", + "libprotobuf >=3.20.3,<3.21.0a0", + "libstdcxx-ng >=9.3.0", + "numpy >=1.20,<2", + "openssl >=1.1.1t,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers >=2.0", + "requests", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.40.1,<4.0a0", + "tensorboard 2.11.*", + "tensorflow-estimator 2.11.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8db81d73ef334e01dcdd8bb8647d6f64", + "name": "tensorflow-base", + "sha256": "8671aab9fb14ab30344579338507197d6de1e4850f4bbb560b2b52441e81fc7d", + "size": 104881774, + "subdir": "linux-64", + "timestamp": 1678249223809, + "version": "2.11.0" + }, + "tensorflow-base-2.2.0-eigen_py36haef3446_0.conda": { + "build": "eigen_py36haef3446_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=3.6,<3.7.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4720305cdfd34c66ebd0b55c5e8b7fd9", + "name": "tensorflow-base", + "sha256": "406602464b192abc11e36ce987fe825e6fe94105e0f5521ef12d6cd52f316f7d", + "size": 82101742, + "subdir": "linux-64", + "timestamp": 1590122174427, + "version": "2.2.0" + }, + "tensorflow-base-2.2.0-eigen_py37haef3446_0.conda": { + "build": "eigen_py37haef3446_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=3.7,<3.8.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e6f96c506a1c2cb1b07ee5ea5797cc39", + "name": "tensorflow-base", + "sha256": "027778a79321aa1de49894b8ae6cdd06b1aba0b273b9a6c0817b003cc6edc005", + "size": 84451425, + "subdir": "linux-64", + "timestamp": 1590096392354, + "version": "2.2.0" + }, + "tensorflow-base-2.2.0-eigen_py38h2e5f744_0.conda": { + "build": "eigen_py38h2e5f744_0", + "build_number": 0, + "depends": [ + "absl-py >=0.8.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.9.2", + "python >=3.8,<3.9.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5f57f1c1145b3624695d2a8eba611082", + "name": "tensorflow-base", + "sha256": "9b968cc6ff4f2c6e4f6416f1ca26fa8cc8a4e799db02bb898a0ccd998bb170d3", + "size": 82274373, + "subdir": "linux-64", + "timestamp": 1590105901939, + "version": "2.2.0" + }, + "tensorflow-base-2.2.0-gpu_py36h8a81be8_0.conda": { + "build": "gpu_py36h8a81be8_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "cupti", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=3.6,<3.7.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c1b7d0d88c9483497aac3af0807e2081", + "name": "tensorflow-base", + "sha256": "13e3c91f70ff80763eeb0534585a20be159bb2726e08ff0ae4eaad6db61970c9", + "size": 188966585, + "subdir": "linux-64", + "timestamp": 1590173216680, + "version": "2.2.0" + }, + "tensorflow-base-2.2.0-gpu_py37h8a81be8_0.conda": { + "build": "gpu_py37h8a81be8_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "cupti", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=3.7,<3.8.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d37108dbc6e65147e41aa3f230750558", + "name": "tensorflow-base", + "sha256": "8b42bdf254992a61bc9fbce971d03feedf959511718b555d1ae3cf7fba115788", + "size": 190483981, + "subdir": "linux-64", + "timestamp": 1590166137312, + "version": "2.2.0" + }, + "tensorflow-base-2.2.0-gpu_py38h83e3d50_0.conda": { + "build": "gpu_py38h83e3d50_0", + "build_number": 0, + "depends": [ + "absl-py >=0.8.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "cupti", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.9.2", + "python >=3.8,<3.9.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "affb91220be4fe8bb37312f24e7d5ec6", + "name": "tensorflow-base", + "sha256": "aaacc41d8e9eb8df2402057523ad22ca59d4db9a5000149bebbe9798f50d0a08", + "size": 187996440, + "subdir": "linux-64", + "timestamp": 1590181687234, + "version": "2.2.0" + }, + "tensorflow-base-2.2.0-mkl_py36hd506778_0.conda": { + "build": "mkl_py36hd506778_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=3.6,<3.7.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a2b592f3d3d1dd7301d57bea4d82675d", + "name": "tensorflow-base", + "sha256": "865969eaf7680dbfc0c2c45445fc8322867c1471781a5499206e50f6f99dab8d", + "size": 135963586, + "subdir": "linux-64", + "timestamp": 1590125215629, + "version": "2.2.0" + }, + "tensorflow-base-2.2.0-mkl_py37hd506778_0.conda": { + "build": "mkl_py37hd506778_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=3.7,<3.8.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cf79d52b0886d1ac01d19c9f112fd6fd", + "name": "tensorflow-base", + "sha256": "96e45b1de392e8e55674f9b038cf68d0a265993814bd856bf3b7fdd2926f2bdd", + "size": 135886776, + "subdir": "linux-64", + "timestamp": 1590099882941, + "version": "2.2.0" + }, + "tensorflow-base-2.2.0-mkl_py38h5059a2d_0.conda": { + "build": "mkl_py38h5059a2d_0", + "build_number": 0, + "depends": [ + "absl-py >=0.8.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.9.2", + "python >=3.8,<3.9.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9554cd65c8157ec1bb7f0694e99c4168", + "name": "tensorflow-base", + "sha256": "3dbe3ed817fc775e6ecaae858f30a8680ea5bf0bd2c0544c71f6325f68d478ef", + "size": 133402984, + "subdir": "linux-64", + "timestamp": 1590108862023, + "version": "2.2.0" + }, + "tensorflow-base-2.3.0-eigen_py37h3b305d7_0.conda": { + "build": "eigen_py37h3b305d7_0", + "build_number": 0, + "depends": [ + "absl-py >=0.7.1", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.3.3,<0.3.4.0a0", + "google-pasta >=0.1.8", + "grpcio >=1.16.1", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=2.3.2", + "protobuf >=3.8.0", + "python >=3.7,<3.8.0a0", + "scipy >=1.4.1", + "six >=1.12.0", + "termcolor >=1.1.0", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "42dbcc459cc4dd966b5a330788057495", + "name": "tensorflow-base", + "sha256": "58a58efb196bdd6cb21a37d511faf61e1c1e1bb6d0d87fd195602ffdb24a2125", + "size": 78437950, + "subdir": "linux-64", + "timestamp": 1597861240479, + "version": "2.3.0" + }, + "tensorflow-base-2.4.1-eigen_py37h17880bf_0.conda": { + "build": "eigen_py37h17880bf_0", + "build_number": 0, + "depends": [ + "absl-py >=0.11.0", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.4.0,<0.4.1.0a0", + "google-pasta >=0.2.0", + "grpcio >=1.35.0", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.2", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.14.0", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.6.1", + "six >=1.15.0", + "sqlite >=3.33.0,<4.0a0", + "termcolor >=1.1.0", + "typing_extensions", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6596c7ba39537164c245a0e0819a0664", + "name": "tensorflow-base", + "sha256": "ad06945b69fe051f2582e447c25cbbe34cdebfa0452a6d47c0200aff4b0c9937", + "size": 83760574, + "subdir": "linux-64", + "timestamp": 1614350230007, + "version": "2.4.1" + }, + "tensorflow-base-2.4.1-eigen_py38h17880bf_0.conda": { + "build": "eigen_py38h17880bf_0", + "build_number": 0, + "depends": [ + "absl-py >=0.11.0", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.4.0,<0.4.1.0a0", + "google-pasta >=0.2.0", + "grpcio >=1.35.0", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.2", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.14.0", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.6.1", + "six >=1.15.0", + "sqlite >=3.33.0,<4.0a0", + "termcolor >=1.1.0", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e95ff9c556fc829ee438b2df2a03fa16", + "name": "tensorflow-base", + "sha256": "0541bf2e6d1878871beb96753ac65ab571cfe37b36f7856372bc38fb8bb92028", + "size": 83812304, + "subdir": "linux-64", + "timestamp": 1614357824206, + "version": "2.4.1" + }, + "tensorflow-base-2.4.1-eigen_py39h17880bf_0.conda": { + "build": "eigen_py39h17880bf_0", + "build_number": 0, + "depends": [ + "absl-py >=0.11.0", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.4.0,<0.4.1.0a0", + "google-pasta >=0.2.0", + "grpcio >=1.35.0", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.2", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.14.0", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.6.1", + "six >=1.15.0", + "sqlite >=3.33.0,<4.0a0", + "termcolor >=1.1.0", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "edd7cb532aa63cb80e5346dc0ffd94c6", + "name": "tensorflow-base", + "sha256": "84d69c4e70aa4d4622da3a1b7c67d38a20a45998d3cb6f40f876788fac75f64d", + "size": 83854912, + "subdir": "linux-64", + "timestamp": 1614364530070, + "version": "2.4.1" + }, + "tensorflow-base-2.4.1-gpu_py37h29c2da4_0.conda": { + "build": "gpu_py37h29c2da4_0", + "build_number": 0, + "depends": [ + "absl-py >=0.11.0", + "astunparse >=1.6.3,<1.6.4.0a0", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "cupti", + "gast >=0.4.0,<0.4.1.0a0", + "google-pasta >=0.2.0", + "grpcio >=1.35.0", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.2", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.14.0", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.6.1", + "six >=1.15.0", + "sqlite >=3.33.0,<4.0a0", + "termcolor >=1.1.0", + "typing_extensions", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "966dd5d8ee4372ec5bbd13d3d69a4018", + "name": "tensorflow-base", + "sha256": "9235969e77cba6b4e03e78e0d14001a2bc484892241387997f8c7d3ce7c5d0d5", + "size": 204722057, + "subdir": "linux-64", + "timestamp": 1614542338829, + "version": "2.4.1" + }, + "tensorflow-base-2.4.1-gpu_py38h29c2da4_0.conda": { + "build": "gpu_py38h29c2da4_0", + "build_number": 0, + "depends": [ + "absl-py >=0.11.0", + "astunparse >=1.6.3,<1.6.4.0a0", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "cupti", + "gast >=0.4.0,<0.4.1.0a0", + "google-pasta >=0.2.0", + "grpcio >=1.35.0", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.2", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.14.0", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.6.1", + "six >=1.15.0", + "sqlite >=3.33.0,<4.0a0", + "termcolor >=1.1.0", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8b7c9065460eeda8b155c87201884a69", + "name": "tensorflow-base", + "sha256": "55f41446e2922781fdd8700f48aac8e182512e0529a6dd21328de25382ea2366", + "size": 204732184, + "subdir": "linux-64", + "timestamp": 1614550833676, + "version": "2.4.1" + }, + "tensorflow-base-2.4.1-gpu_py39h29c2da4_0.conda": { + "build": "gpu_py39h29c2da4_0", + "build_number": 0, + "depends": [ + "absl-py >=0.11.0", + "astunparse >=1.6.3,<1.6.4.0a0", + "cudatoolkit >=10.1.243,<10.2.0a0", + "cudnn >=7.6,<8.0a0", + "cudnn >=7.6.5,<8.0a0", + "cupti", + "gast >=0.4.0,<0.4.1.0a0", + "google-pasta >=0.2.0", + "grpcio >=1.35.0", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.2", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.14.0", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.6.1", + "six >=1.15.0", + "sqlite >=3.33.0,<4.0a0", + "termcolor >=1.1.0", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "aec0b7780731b25ecff1e146c646b518", + "name": "tensorflow-base", + "sha256": "fd2ebbaa47cde846514a916a04bc91210e6d302682aad6df00743140703dd26d", + "size": 204712067, + "subdir": "linux-64", + "timestamp": 1614591566613, + "version": "2.4.1" + }, + "tensorflow-base-2.4.1-mkl_py37h43e0292_0.conda": { + "build": "mkl_py37h43e0292_0", + "build_number": 0, + "depends": [ + "absl-py >=0.11.0", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.4.0,<0.4.1.0a0", + "google-pasta >=0.2.0", + "grpcio >=1.35.0", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.2", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.14.0", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.6.1", + "six >=1.15.0", + "sqlite >=3.33.0,<4.0a0", + "termcolor >=1.1.0", + "typing_extensions", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "90dad5a5557ea1a4f4fddd4056f9c885", + "name": "tensorflow-base", + "sha256": "7dd0d142c20f54442f3a6e3dc0f46c33dbb9747f60b09038967fa1e4a4782171", + "size": 93208275, + "subdir": "linux-64", + "timestamp": 1614352982204, + "version": "2.4.1" + }, + "tensorflow-base-2.4.1-mkl_py38h43e0292_0.conda": { + "build": "mkl_py38h43e0292_0", + "build_number": 0, + "depends": [ + "absl-py >=0.11.0", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.4.0,<0.4.1.0a0", + "google-pasta >=0.2.0", + "grpcio >=1.35.0", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.2", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.14.0", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.6.1", + "six >=1.15.0", + "sqlite >=3.33.0,<4.0a0", + "termcolor >=1.1.0", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ed823d7753acad59127950b72dc5c8c9", + "name": "tensorflow-base", + "sha256": "690212d0e7ea3e4c9c7a7c33206c9a00c6e5a045658a32b342b54890f7060d94", + "size": 93335245, + "subdir": "linux-64", + "timestamp": 1614360610470, + "version": "2.4.1" + }, + "tensorflow-base-2.4.1-mkl_py39h43e0292_0.conda": { + "build": "mkl_py39h43e0292_0", + "build_number": 0, + "depends": [ + "absl-py >=0.11.0", + "astunparse >=1.6.3,<1.6.4.0a0", + "gast >=0.4.0,<0.4.1.0a0", + "google-pasta >=0.2.0", + "grpcio >=1.35.0", + "h5py >=2.10.0,<2.11.0a0", + "keras-preprocessing >=1.1.2", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.16.6,<2.0a0", + "opt_einsum >=3.1.0", + "protobuf >=3.14.0", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.6.1", + "six >=1.15.0", + "sqlite >=3.33.0,<4.0a0", + "termcolor >=1.1.0", + "wrapt >=1.12.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "81c9763bb7e526192bf265235bc39798", + "name": "tensorflow-base", + "sha256": "573e5206ec32a596ee6b5e7e7a2f02d2bd4b06779985404c6d4ea49250e56a47", + "size": 93489509, + "subdir": "linux-64", + "timestamp": 1614367451224, + "version": "2.4.1" + }, + "tensorflow-base-2.5.0-eigen_py37h2b86b3d_0.conda": { + "build": "eigen_py37h2b86b3d_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20200923.3,<20200923.4.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.7,<3.8.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.35.4,<4.0a0", + "tensorboard >=2.5.0,<2.6", + "tensorflow-estimator >=2.5.0,<2.6", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel <0.36", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ecde862bcf162188de45ce8fb7be4119", + "name": "tensorflow-base", + "sha256": "917203ae2b218b014dfb30aea4aa161b6b7aafb383aa94c1efd73243120fe616", + "size": 80447394, + "subdir": "linux-64", + "timestamp": 1622103985155, + "version": "2.5.0" + }, + "tensorflow-base-2.5.0-eigen_py38h2b86b3d_0.conda": { + "build": "eigen_py38h2b86b3d_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20200923.3,<20200923.4.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.8,<3.9.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.35.4,<4.0a0", + "tensorboard >=2.5.0,<2.6", + "tensorflow-estimator >=2.5.0,<2.6", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel <0.36", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c6fd8e7656d9982ad2930cd2a3d3690f", + "name": "tensorflow-base", + "sha256": "fc62cc4b976bb2589b9d1dd7c594e550bb4131a33a5e54e31be78b6218b95257", + "size": 80053529, + "subdir": "linux-64", + "timestamp": 1622114435345, + "version": "2.5.0" + }, + "tensorflow-base-2.5.0-eigen_py39h2b86b3d_0.conda": { + "build": "eigen_py39h2b86b3d_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20200923.3,<20200923.4.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.9,<3.10.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.35.4,<4.0a0", + "tensorboard >=2.5.0,<2.6", + "tensorflow-estimator >=2.5.0,<2.6", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel >=0.35,<0.36", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "09f5feedcbcb3bbfa18e6fe020e246bf", + "name": "tensorflow-base", + "sha256": "cc00314b0b663060c6a0bb1dc65061a21a05be82e476a81422029357db7afd96", + "size": 79241743, + "subdir": "linux-64", + "timestamp": 1622124950135, + "version": "2.5.0" + }, + "tensorflow-base-2.5.0-mkl_py37h35b2a3d_0.conda": { + "build": "mkl_py37h35b2a3d_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20200923.3,<20200923.4.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.7,<3.8.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.35.4,<4.0a0", + "tensorboard >=2.5.0,<2.6", + "tensorflow-estimator >=2.5.0,<2.6", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel <0.36", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "23b76d533c4c8cb03837022651a425e6", + "name": "tensorflow-base", + "sha256": "bad831eb732828a975a07161ec66599fc981f07f9b7e99f57bb21118fef93557", + "size": 80304006, + "subdir": "linux-64", + "timestamp": 1622107418140, + "version": "2.5.0" + }, + "tensorflow-base-2.5.0-mkl_py38h35b2a3d_0.conda": { + "build": "mkl_py38h35b2a3d_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20200923.3,<20200923.4.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.8,<3.9.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.35.4,<4.0a0", + "tensorboard >=2.5.0,<2.6", + "tensorflow-estimator >=2.5.0,<2.6", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel <0.36", + "wrapt >=1.11.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2409374f0f5be40fb7c46c719f8fe91f", + "name": "tensorflow-base", + "sha256": "8ee6b406106ff9dcc9a920ae3f9c31bce5dcf805b62cd06157efbbf5efc0abcb", + "size": 79958768, + "subdir": "linux-64", + "timestamp": 1622110966745, + "version": "2.5.0" + }, + "tensorflow-base-2.5.0-mkl_py39h35b2a3d_0.conda": { + "build": "mkl_py39h35b2a3d_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20200923.3,<20200923.4.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=5.4.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.9,<3.10.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.35.4,<4.0a0", + "tensorboard >=2.5.0,<2.6", + "tensorflow-estimator >=2.5.0,<2.6", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel >=0.35,<0.36", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bdb72f059a339206d01a9381b4d6179a", + "name": "tensorflow-base", + "sha256": "ff126c4f464eea458792ddb5fdecf2f33705f8b79c7fc6be1458d9007c51a0de", + "size": 79102211, + "subdir": "linux-64", + "timestamp": 1622121483571, + "version": "2.5.0" + }, + "tensorflow-base-2.6.0-eigen_py37ha9cc040_0.conda": { + "build": "eigen_py37ha9cc040_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.7,<3.8.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.36.0,<4.0a0", + "tensorboard >=2.6.0,<2.7", + "tensorflow-estimator >=2.6.0,<2.7", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel >=0.35,<0.36", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "536ecccfc7142da08dee811c7f5354d2", + "name": "tensorflow-base", + "sha256": "0a06a5f80a82b1cfaa1386426db8a7608f877bbfef72b4fe3c2a25e84e133d42", + "size": 82120236, + "subdir": "linux-64", + "timestamp": 1630513623371, + "version": "2.6.0" + }, + "tensorflow-base-2.6.0-eigen_py38ha9cc040_0.conda": { + "build": "eigen_py38ha9cc040_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.8,<3.9.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.36.0,<4.0a0", + "tensorboard >=2.6.0,<2.7", + "tensorflow-estimator >=2.6.0,<2.7", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel >=0.35,<0.36", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a5e6ae05a3b3e1e5d88feed933c5cfdc", + "name": "tensorflow-base", + "sha256": "4c3dacbcf8a3ee69c6befb454abdc5f4d9bc5e35018df07d4b488e267e7058e6", + "size": 81802664, + "subdir": "linux-64", + "timestamp": 1630518169042, + "version": "2.6.0" + }, + "tensorflow-base-2.6.0-eigen_py39ha9cc040_0.conda": { + "build": "eigen_py39ha9cc040_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.9,<3.10.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.36.0,<4.0a0", + "tensorboard >=2.6.0,<2.7", + "tensorflow-estimator >=2.6.0,<2.7", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel >=0.35,<0.36", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7eb12d58e01bb1d02515548e3efae7d5", + "name": "tensorflow-base", + "sha256": "d9670e05e500692f1e189d6f591ff9609d127bccab7f5eb94151a7bd8bf80608", + "size": 80820636, + "subdir": "linux-64", + "timestamp": 1630520715169, + "version": "2.6.0" + }, + "tensorflow-base-2.6.0-mkl_py37h3d85931_0.conda": { + "build": "mkl_py37h3d85931_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.7,<3.8.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.36.0,<4.0a0", + "tensorboard >=2.6.0,<2.7", + "tensorflow-estimator >=2.6.0,<2.7", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel >=0.35,<0.36", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "158d72b69e688b4814a76451cbbcd6b1", + "name": "tensorflow-base", + "sha256": "2dd75a930fa7d452fe52c4193a38681911ce99605bb1b15493756ab9b244e9dd", + "size": 81616564, + "subdir": "linux-64", + "timestamp": 1630511484102, + "version": "2.6.0" + }, + "tensorflow-base-2.6.0-mkl_py38h3d85931_0.conda": { + "build": "mkl_py38h3d85931_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.8,<3.9.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.36.0,<4.0a0", + "tensorboard >=2.6.0,<2.7", + "tensorflow-estimator >=2.6.0,<2.7", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel >=0.35,<0.36", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0526f09b20a3a7f0915f46f29816a12a", + "name": "tensorflow-base", + "sha256": "cb1b536bc712a4090f79b83756a7428e6492789049a53c4c39a13e76f909c27c", + "size": 81187003, + "subdir": "linux-64", + "timestamp": 1630516015623, + "version": "2.6.0" + }, + "tensorflow-base-2.6.0-mkl_py39h3d85931_0.conda": { + "build": "mkl_py39h3d85931_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20210324.2,<20210324.3.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers", + "gast 0.4.0", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.2", + "grpcio", + "h5py >=3.1.0", + "icu >=68.1,<69.0a0", + "jpeg >=9b,<10a", + "keras-preprocessing >=1.1.2", + "libcurl >=7.78.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.14.0,<3.15.0a0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.20", + "openssl >=1.1.1k,<1.1.2a", + "opt_einsum 3.3.0.*", + "protobuf >=3.9.2", + "python >=3.9,<3.10.0a0", + "python-flatbuffers 1.12.*", + "scipy >=1.6.2", + "six >=1.15.0", + "snappy >=1.1.8,<2.0a0", + "sqlite >=3.36.0,<4.0a0", + "tensorboard >=2.6.0,<2.7", + "tensorflow-estimator >=2.6.0,<2.7", + "termcolor >=1.1.0", + "typing_extensions >=3.7.4", + "wheel >=0.35,<0.36", + "wrapt >=1.11.2", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "872602a9298c6c085eb3acbc903c29e1", + "name": "tensorflow-base", + "sha256": "44e1fee6a3f36c1faae39195008aea9f3b5381f057da9ee1be5a0f6e0d619e8b", + "size": 80415721, + "subdir": "linux-64", + "timestamp": 1630522852931, + "version": "2.6.0" + }, + "tensorflow-base-2.8.2-eigen_py310h980454f_0.conda": { + "build": "eigen_py310h980454f_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.38.5,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cc19457020d5c7a9c630150f4ac72023", + "name": "tensorflow-base", + "sha256": "bc961b7105cc655835a7b1fba920b412e8d39e9d4d78813c07a37086ecd1a18d", + "size": 89143991, + "subdir": "linux-64", + "timestamp": 1658935387847, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-eigen_py37h980454f_0.conda": { + "build": "eigen_py37h980454f_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.38.5,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d4d814efb13472c15e0eaafaaec6c1ed", + "name": "tensorflow-base", + "sha256": "bf2489c5d98703b22ffc0f6f18932a65574fbfa3ce5c2b52b0349d7aabfdc8b0", + "size": 91692197, + "subdir": "linux-64", + "timestamp": 1658940036680, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-eigen_py38h980454f_0.conda": { + "build": "eigen_py38h980454f_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.38.5,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8824cc2eb4ab094d99a1415205b31deb", + "name": "tensorflow-base", + "sha256": "58f73d5f0871c8289d70c28413b832d1121f28b093040a7467d834cb8668697a", + "size": 91542673, + "subdir": "linux-64", + "timestamp": 1658933069131, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-eigen_py39h980454f_0.conda": { + "build": "eigen_py39h980454f_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.38.5,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "228fa024fd426b797215ebcb037bed06", + "name": "tensorflow-base", + "sha256": "f365047ac35f5cd1a1be29f42fb84b99831daac905d4069435052053f96275af", + "size": 91471896, + "subdir": "linux-64", + "timestamp": 1658937720842, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-gpu_py310h1986732_0.conda": { + "build": "gpu_py310h1986732_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.0,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fa8632e1cf75e44b94cd15d308d16fad", + "name": "tensorflow-base", + "sha256": "9609e8c9bb671d55ea39be195c1c09364f3eb853077c1344f685bb16ebb1e9b5", + "size": 280052050, + "subdir": "linux-64", + "timestamp": 1659639211970, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-gpu_py37h1986732_0.conda": { + "build": "gpu_py37h1986732_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.0,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e40ce4ff3e15124d7bd56cda0275f055", + "name": "tensorflow-base", + "sha256": "a18e4e88f8ba227f31d64d403f7566e96cca367beb76f8f816bad8776df9dd04", + "size": 281556692, + "subdir": "linux-64", + "timestamp": 1659651064983, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-gpu_py38h1986732_0.conda": { + "build": "gpu_py38h1986732_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.0,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d034d9e96fa03c33ecbd2f61d33a147d", + "name": "tensorflow-base", + "sha256": "77e2c4c3da3c12c0f538b1f99d044a4606792450487978c21f795b9e5ec6ff92", + "size": 281690182, + "subdir": "linux-64", + "timestamp": 1659645157620, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-gpu_py39h1986732_0.conda": { + "build": "gpu_py39h1986732_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.0,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6aae3d6224c143a1829a978685baa9f2", + "name": "tensorflow-base", + "sha256": "260faf56b49b926dce162bfa5f1d82d29e9d203ef32223704c12fa5cf0c36fa4", + "size": 281242707, + "subdir": "linux-64", + "timestamp": 1659632969469, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-mkl_py310hf890080_0.conda": { + "build": "mkl_py310hf890080_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.38.5,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0a4c326d42a634a0d58e65609da1d4b1", + "name": "tensorflow-base", + "sha256": "d0abeec74f14d1c42066a7fd884016f0682f9c91284ce0b7f8950ea8b62090ee", + "size": 89570016, + "subdir": "linux-64", + "timestamp": 1658926050046, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-mkl_py37hf890080_0.conda": { + "build": "mkl_py37hf890080_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.38.5,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "17ab156bb6616e24c946e1a99c55283a", + "name": "tensorflow-base", + "sha256": "72a8acc785e85576f0bd09aa3a96fbf67da4e2a6e5f5bd2d84e6fd07c9b4067b", + "size": 91843632, + "subdir": "linux-64", + "timestamp": 1658930756242, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-mkl_py38hf890080_0.conda": { + "build": "mkl_py38hf890080_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.38.5,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4403d51025179a9802538287dc4b0f3d", + "name": "tensorflow-base", + "sha256": "f7029769d0091489433fd87b2916d7d23451553c2cd4baff19c2f7fe4859a129", + "size": 91830723, + "subdir": "linux-64", + "timestamp": 1658923715929, + "version": "2.8.2" + }, + "tensorflow-base-2.8.2-mkl_py39hf890080_0.conda": { + "build": "mkl_py39hf890080_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.8.*", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.7.1", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.38.5,<4.0a0", + "tensorboard 2.8.*", + "tensorflow-estimator 2.8.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9bbafc13dfb219c2d39bbf57e191368f", + "name": "tensorflow-base", + "sha256": "0e6ab36513618133bbc5920f8fdcfac62471b36c05ad1ebad03ee1e1897b618b", + "size": 91824080, + "subdir": "linux-64", + "timestamp": 1658928422117, + "version": "2.8.2" + }, + "tensorflow-base-2.9.1-eigen_py310hd99631c_0.conda": { + "build": "eigen_py310hd99631c_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3d03b5edaace4ae5225abe191c08189a", + "name": "tensorflow-base", + "sha256": "2a81cf0799574e091d2f1abae704e78c73197b9f2b4b98de9e72779e47d1a4bb", + "size": 94700472, + "subdir": "linux-64", + "timestamp": 1661494948075, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-eigen_py310hd99631c_1.conda": { + "build": "eigen_py310hd99631c_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "51345a30b1f865f6b7d93a1cbc7efd2a", + "name": "tensorflow-base", + "sha256": "a7272d5da9edff512672ccca34fd0551c0262203b499aed169a89b076609632a", + "size": 94563045, + "subdir": "linux-64", + "timestamp": 1666075171038, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-eigen_py37hd99631c_0.conda": { + "build": "eigen_py37hd99631c_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e0a1b655c94af3c8ea4e9edcde1ca3ab", + "name": "tensorflow-base", + "sha256": "d0a9ff8ef3948628569aede4408bb9c765a5bcd14f8eb877f4cc45861a989f35", + "size": 96206873, + "subdir": "linux-64", + "timestamp": 1661489725783, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-eigen_py37hd99631c_1.conda": { + "build": "eigen_py37hd99631c_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "401bdc1c98510eb0f8c57b3a09813344", + "name": "tensorflow-base", + "sha256": "76e8bbeca40d71239d085d0ed8daf3e293bcdf21688ddc58b10c9dd0d3883530", + "size": 94339358, + "subdir": "linux-64", + "timestamp": 1665989894499, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-eigen_py38hd99631c_0.conda": { + "build": "eigen_py38hd99631c_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9e47ca46ec7ba7d19b309312d57a492a", + "name": "tensorflow-base", + "sha256": "fd9853fada747646a1ad267d1660d12e172fe8829b1f0fbfcdb3a5b93306ea1a", + "size": 93777835, + "subdir": "linux-64", + "timestamp": 1661492330681, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-eigen_py38hd99631c_1.conda": { + "build": "eigen_py38hd99631c_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6a185154c55b5749d41c9643a8901097", + "name": "tensorflow-base", + "sha256": "1fedc9e248c14f0bb1e27cf922af63726113ff4e886c91761eea18d5f2ab0535", + "size": 92959142, + "subdir": "linux-64", + "timestamp": 1666010299142, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-eigen_py39hd99631c_0.conda": { + "build": "eigen_py39hd99631c_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c61609cb1f8288f8594946b0bc97e2e4", + "name": "tensorflow-base", + "sha256": "4224bd172abb491690450cc8a29cc46a96c487d9d20001ce9256e21b6b5865f2", + "size": 94595941, + "subdir": "linux-64", + "timestamp": 1661487089195, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-eigen_py39hd99631c_1.conda": { + "build": "eigen_py39hd99631c_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ea1ed6a0be1fa8f6f22d707968abf57f", + "name": "tensorflow-base", + "sha256": "7efeb97e0b5a0dc70e831ff994f7c2303aacd25dfcd63d9f530e0a581eb33fea", + "size": 92499876, + "subdir": "linux-64", + "timestamp": 1666023881253, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-gpu_py310h1986732_0.conda": { + "build": "gpu_py310h1986732_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8657a40a15e2e48630fc96f9c11003aa", + "name": "tensorflow-base", + "sha256": "cd2829565741f104ec7c89202ff0fc1dab17b062bcd8ab324a87eb9d9026b068", + "size": 285378439, + "subdir": "linux-64", + "timestamp": 1661484216776, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-gpu_py310h1986732_1.conda": { + "build": "gpu_py310h1986732_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "28620c7ed6d66cf26aad64f1fc3ff25d", + "name": "tensorflow-base", + "sha256": "09b61f643a28620791fc7b6020678fe29e5cb00c925accb936830377825fd32a", + "size": 282168196, + "subdir": "linux-64", + "timestamp": 1666083910001, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-gpu_py37h1986732_0.conda": { + "build": "gpu_py37h1986732_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cff0f21aa68e150e2f041f3a39a7ea36", + "name": "tensorflow-base", + "sha256": "e2a5d9042d10de18157e51537d855695bbe4a592faf816ebe37c5481d7529dcd", + "size": 286024222, + "subdir": "linux-64", + "timestamp": 1661471574045, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-gpu_py37h1986732_1.conda": { + "build": "gpu_py37h1986732_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9e759fbb659f26570fbccbe1e5c465ca", + "name": "tensorflow-base", + "sha256": "1d08ca948784f338dbb307b380d7d413b566c69edd8a6f63d4f3ea0737680c02", + "size": 285983545, + "subdir": "linux-64", + "timestamp": 1665996235307, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-gpu_py38h1986732_0.conda": { + "build": "gpu_py38h1986732_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cdf9b55b28ef6ae57a7d0ab9180577f7", + "name": "tensorflow-base", + "sha256": "da7613ea2e2517a1a49f8b00de9994e020292e713339dad70b982e0826fabfac", + "size": 283856544, + "subdir": "linux-64", + "timestamp": 1661477886621, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-gpu_py38h1986732_1.conda": { + "build": "gpu_py38h1986732_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aefe82fae628376810a6ad967090ffe2", + "name": "tensorflow-base", + "sha256": "3b6ffe3e4d1aedd30359bb39fb1a5e4618261bf4e9e18d4abb186e3747af3642", + "size": 285439199, + "subdir": "linux-64", + "timestamp": 1666016445368, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-gpu_py39h1986732_0.conda": { + "build": "gpu_py39h1986732_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d0354f02e66b2bd8a2122d239058ac04", + "name": "tensorflow-base", + "sha256": "c855fade85aaa18d91a1d63531836097c5c1c34635dd177795a8baf69ec3febd", + "size": 285120011, + "subdir": "linux-64", + "timestamp": 1661465201574, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-gpu_py39h1986732_1.conda": { + "build": "gpu_py39h1986732_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "cudatoolkit 11.3.*", + "cudnn 8.2.*", + "cudnn >=8.2,<9.0a0", + "cupti", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "09d9f28f630d58bbf0a7b420e39d07fc", + "name": "tensorflow-base", + "sha256": "14f75e81c91f334a78f3890d55b0de49eae9ba9856592204bc15f37db6d20c15", + "size": 286449071, + "subdir": "linux-64", + "timestamp": 1666032698774, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-mkl_py310h353358b_0.conda": { + "build": "mkl_py310h353358b_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "33b27fb20a21cb41991d61c82c5c6a50", + "name": "tensorflow-base", + "sha256": "49f74c39e58e2d0ad46020ee7fa1bfb17c8020be4699c1d9ef9c1e72162c7f01", + "size": 94482208, + "subdir": "linux-64", + "timestamp": 1661459084594, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-mkl_py310h353358b_1.conda": { + "build": "mkl_py310h353358b_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.10,<3.11.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "50abf75e9e8256a224f65b8cc6372137", + "name": "tensorflow-base", + "sha256": "1464ea2946213d3bf08981fc59b6462837653bd2fc9ac75476c42b670a056686", + "size": 92694160, + "subdir": "linux-64", + "timestamp": 1666077786578, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-mkl_py37h353358b_0.conda": { + "build": "mkl_py37h353358b_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "81e3c42e90d449de54b3ea827aa273bd", + "name": "tensorflow-base", + "sha256": "11ddec27684325637e26c00179aac437780a1998d6505a36edaaa9833b6d1cf8", + "size": 92772273, + "subdir": "linux-64", + "timestamp": 1661453849463, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-mkl_py37h353358b_1.conda": { + "build": "mkl_py37h353358b_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.7,<3.8.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "315c206492f15dddfbec0218f6d17c85", + "name": "tensorflow-base", + "sha256": "c251e6abd34ca012df967cbc9a9a746fe71bdf9381c6cb2a2472b5fbe776b7f5", + "size": 95973232, + "subdir": "linux-64", + "timestamp": 1665999083795, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-mkl_py38h353358b_0.conda": { + "build": "mkl_py38h353358b_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c6c10cabc6cfd827687db744f96f22ed", + "name": "tensorflow-base", + "sha256": "10e2ac03f1869c8d9d8b77d734b0bf6213d4660104aaafcd878759d06bc49c78", + "size": 96096027, + "subdir": "linux-64", + "timestamp": 1661456484481, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-mkl_py38h353358b_1.conda": { + "build": "mkl_py38h353358b_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.8,<3.9.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7d5ca5ca1166839ae421eb4c2e23da21", + "name": "tensorflow-base", + "sha256": "0c4101b797d2773842ce2907c2aaf2a9ddc422d83ee8b4dfa89951b1a0910403", + "size": 94883950, + "subdir": "linux-64", + "timestamp": 1666019333297, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-mkl_py39h353358b_0.conda": { + "build": "mkl_py39h353358b_0", + "build_number": 0, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.7.3", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.2,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6dc37d0152658cbf83230d4f8dfd0996", + "name": "tensorflow-base", + "sha256": "839cde86275c3b1824331fd576111d05f35bb01771ff9810311e047961aab35c", + "size": 95772816, + "subdir": "linux-64", + "timestamp": 1661451232750, + "version": "2.9.1" + }, + "tensorflow-base-2.9.1-mkl_py39h353358b_1.conda": { + "build": "mkl_py39h353358b_1", + "build_number": 1, + "depends": [ + "abseil-cpp >=20211102.0,<20211102.1.0a0", + "absl-py >=0.10.0", + "astunparse >=1.6.3", + "flatbuffers >=1.12", + "gast >=0.2.1", + "giflib >=5.2.1,<5.3.0a0", + "google-pasta >=0.1.1", + "grpc-cpp >=1.46.1,<1.47.0a0", + "grpcio >=1.24.3,<2.0", + "h5py >=2.9.0", + "icu >=58.2,<59.0a0", + "jpeg >=9e,<10a", + "keras 2.9.*", + "libcurl >=7.84.0,<8.0a0", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libprotobuf >=3.20.1,<3.21.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.20,<2", + "openssl >=1.1.1q,<1.1.2a", + "opt_einsum >=2.3.2", + "packaging", + "python >=3.9,<3.10.0a0", + "python-flatbuffers", + "scipy >=1.7.3,<2", + "setuptools", + "six >=1.12.0", + "snappy >=1.1.9,<2.0a0", + "sqlite >=3.39.3,<4.0a0", + "tensorboard 2.9.*", + "tensorflow-estimator 2.9.*", + "termcolor >=1.1.0", + "typing_extensions >=3.6.6", + "wrapt >=1.11.2", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1cc5ab37ab3baa3bfd67bb5ec7d2392a", + "name": "tensorflow-base", + "sha256": "a2aeedd942f91d61e1f671f55b63374e83abc51640c648e5b517b07d9de04a41", + "size": 95521067, + "subdir": "linux-64", + "timestamp": 1666026494701, + "version": "2.9.1" + }, + "tensorflow-datasets-1.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "absl-py", + "attrs", + "bz2file", + "dill", + "enum34", + "functools32", + "future", + "futures", + "numpy", + "promise", + "protobuf >=3.6.1", + "psutil", + "python >=2.7,<2.8.0a0", + "requests >=2.19.0", + "six", + "tensorflow >=1.14", + "tensorflow-metadata", + "termcolor", + "tqdm", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "2c9624b229db7bae4409646c86387d06", + "name": "tensorflow-datasets", + "sha256": "7b2f684764fdcd9701628e780ff1dd02ac1e0b7ded69d69dabf9cb3a518328cc", + "size": 1927420, + "subdir": "linux-64", + "timestamp": 1567017053290, + "version": "1.2.0" + }, + "tensorflow-datasets-1.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py", + "attrs", + "dill", + "future", + "numpy", + "promise", + "protobuf >=3.6.1", + "psutil", + "python >=3.10,<3.11.0a0", + "requests >=2.19.0", + "six", + "tensorflow >=1.14", + "tensorflow-metadata", + "termcolor", + "tqdm", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "41b771c93f33014911225230ee97cb69", + "name": "tensorflow-datasets", + "sha256": "996ee71c8741782092b269fceca03fea125defea0e79f6bfd697a9ba46540a64", + "size": 1782218, + "subdir": "linux-64", + "timestamp": 1640814197284, + "version": "1.2.0" + }, + "tensorflow-datasets-1.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "absl-py", + "attrs", + "dill", + "future", + "numpy", + "promise", + "protobuf >=3.6.1", + "psutil", + "python >=3.6,<3.7.0a0", + "requests >=2.19.0", + "six", + "tensorflow >=1.14", + "tensorflow-metadata", + "termcolor", + "tqdm", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "e35551656a5ef9c127dc904746109102", + "name": "tensorflow-datasets", + "sha256": "4bba3ce053520f81e87bb8bf8eb0f31092879d84306b4281f89a2c7af602f6ae", + "size": 1938123, + "subdir": "linux-64", + "timestamp": 1567017061800, + "version": "1.2.0" + }, + "tensorflow-datasets-1.2.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py", + "attrs", + "dill", + "future", + "numpy", + "promise", + "protobuf >=3.6.1", + "psutil", + "python >=3.6,<3.7.0a0", + "requests >=2.19.0", + "six", + "tensorflow >=1.14", + "tensorflow-metadata", + "termcolor", + "tqdm", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "992af6912633361e66de02227b5e5a21", + "name": "tensorflow-datasets", + "sha256": "b48a7d031fa1471fb932d03baceb30c745c804197fe70475ed862cbdf7feb514", + "size": 2014889, + "subdir": "linux-64", + "timestamp": 1615394842135, + "version": "1.2.0" + }, + "tensorflow-datasets-1.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "absl-py", + "attrs", + "dill", + "future", + "numpy", + "promise", + "protobuf >=3.6.1", + "psutil", + "python >=3.7,<3.8.0a0", + "requests >=2.19.0", + "six", + "tensorflow >=1.14", + "tensorflow-metadata", + "termcolor", + "tqdm", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "9775cb13b94703ca1d73711e3bb082a2", + "name": "tensorflow-datasets", + "sha256": "8fb5fe4cb5acbd5d4bc456a3e404516f0b87f55bfe54132525503622ed67d5b7", + "size": 1929824, + "subdir": "linux-64", + "timestamp": 1567017055762, + "version": "1.2.0" + }, + "tensorflow-datasets-1.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py", + "attrs", + "dill", + "future", + "numpy", + "promise", + "protobuf >=3.6.1", + "psutil", + "python >=3.7,<3.8.0a0", + "requests >=2.19.0", + "six", + "tensorflow >=1.14", + "tensorflow-metadata", + "termcolor", + "tqdm", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "76989a10bd2a616516674c89cd98cf34", + "name": "tensorflow-datasets", + "sha256": "0c2ed0d8f78c9c08683f1abb04b918102177800e8fb2e9dcd1a7a44f345bdd78", + "size": 2012597, + "subdir": "linux-64", + "timestamp": 1615395019444, + "version": "1.2.0" + }, + "tensorflow-datasets-1.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "absl-py", + "attrs", + "dill", + "future", + "numpy", + "promise", + "protobuf >=3.6.1", + "psutil", + "python >=3.8,<3.9.0a0", + "requests >=2.19.0", + "six", + "tensorflow >=1.14", + "tensorflow-metadata", + "termcolor", + "tqdm", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "392e4b97c2ac9fab9f4e267617896dee", + "name": "tensorflow-datasets", + "sha256": "5b42405f34632b35a49f5e61038ea2f5c3417b051c7c2b16e089ee134480f119", + "size": 1776522, + "subdir": "linux-64", + "timestamp": 1574238089285, + "version": "1.2.0" + }, + "tensorflow-datasets-1.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py", + "attrs", + "dill", + "future", + "numpy", + "promise", + "protobuf >=3.6.1", + "psutil", + "python >=3.8,<3.9.0a0", + "requests >=2.19.0", + "six", + "tensorflow >=1.14", + "tensorflow-metadata", + "termcolor", + "tqdm", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "54e5b0d0fec5c532157309f2527d5115", + "name": "tensorflow-datasets", + "sha256": "649fea4286cbe5bc98a18fa2eaa6382a84526a19a40eccc0e2a3f28aa52a182c", + "size": 2017541, + "subdir": "linux-64", + "timestamp": 1615395005573, + "version": "1.2.0" + }, + "tensorflow-datasets-1.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "absl-py", + "attrs", + "dill", + "future", + "numpy", + "promise", + "protobuf >=3.6.1", + "psutil", + "python >=3.9,<3.10.0a0", + "requests >=2.19.0", + "six", + "tensorflow >=1.14", + "tensorflow-metadata", + "termcolor", + "tqdm", + "wrapt" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "1f5a800661226f3380c1114d40a23997", + "name": "tensorflow-datasets", + "sha256": "23a20252be63b6b871a1dac23b520134a2dfc43a8e477090d44755b3c6cf19bc", + "size": 2023221, + "subdir": "linux-64", + "timestamp": 1615394837008, + "version": "1.2.0" + }, + "tensorflow-eigen-1.10.0-h97799b2_0.conda": { + "build": "h97799b2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 1.10.0" + ], + "md5": "24777ffa06ee33148a28fc1e6ac20859", + "name": "tensorflow-eigen", + "sha256": "6075314d858c50f6d92fde584e91e1e986fd582e9629095ecd09a43b82acede0", + "size": 2722, + "subdir": "linux-64", + "timestamp": 1534871883496, + "version": "1.10.0" + }, + "tensorflow-eigen-1.11.0-h68edfc2_0.conda": { + "build": "h68edfc2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 1.11.0" + ], + "md5": "b7730d83d38efd2e0ba593e23d5b987a", + "name": "tensorflow-eigen", + "sha256": "a1f36cb6bb0810d6b287fd8ea475c3c0385b0554e137b9bbdf7b3fbea135e2b7", + "size": 2757, + "subdir": "linux-64", + "timestamp": 1538592717410, + "version": "1.11.0" + }, + "tensorflow-eigen-1.12.0-h68edfc2_0.conda": { + "build": "h68edfc2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 1.12.0" + ], + "md5": "adef1d8bf76d06d210970fd63c987a3a", + "name": "tensorflow-eigen", + "sha256": "5822df8ddd2eeb7c9a6a0e65cdbf2ed9a856cb1540054d4fb254d18c2c83b72a", + "size": 2849, + "subdir": "linux-64", + "timestamp": 1542084297939, + "version": "1.12.0" + }, + "tensorflow-eigen-1.13.1-h68edfc2_0.conda": { + "build": "h68edfc2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 1.13.1" + ], + "md5": "93d7cdb548df19b5ea7ab3782b67bd85", + "name": "tensorflow-eigen", + "sha256": "fa0935c6a61d5646693ec819e0dddedf0c9b3c5955dbbe929d372111b741d177", + "size": 2901, + "subdir": "linux-64", + "timestamp": 1554328256822, + "version": "1.13.1" + }, + "tensorflow-eigen-1.14.0-h68edfc2_0.conda": { + "build": "h68edfc2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 1.14.0" + ], + "md5": "39235d763cb460ab12ee842960b82a2e", + "name": "tensorflow-eigen", + "sha256": "89c2878e65de36186c708283a5fe242ef0fb691c4929708c98f9967549e12aa3", + "size": 2754, + "subdir": "linux-64", + "timestamp": 1561050158727, + "version": "1.14.0" + }, + "tensorflow-eigen-1.15.0-h68edfc2_0.conda": { + "build": "h68edfc2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 1.15.0" + ], + "md5": "59c5ac072a13c80de6a1069a528d908d", + "name": "tensorflow-eigen", + "sha256": "0233b0cbd9d491b5f65d727b5ef9cdc2e018e8868e738a07d74c71c60e30f524", + "size": 2865, + "subdir": "linux-64", + "timestamp": 1573483031226, + "version": "1.15.0" + }, + "tensorflow-eigen-1.8.0-h08ee40d_0.conda": { + "build": "h08ee40d_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.3.0 eigen", + "tensorflow 1.8.0" + ], + "md5": "ac819c4784e0043eb49aae51605d5e8e", + "name": "tensorflow-eigen", + "sha256": "0fb8c9c919e49277e84cab42c069be41805f5492a8291858a1c705e0b1831c6a", + "size": 3208, + "subdir": "linux-64", + "timestamp": 1527094787428, + "version": "1.8.0" + }, + "tensorflow-eigen-1.9.0-h97799b2_0.conda": { + "build": "h97799b2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 1.9.0" + ], + "md5": "c7e787294815dec608fcd34d22401bf0", + "name": "tensorflow-eigen", + "sha256": "74b367cbdf7289e2bc8d42cd1dbe028ef37c5d4fd4109ad901e93de797f121c8", + "size": 2745, + "subdir": "linux-64", + "timestamp": 1532470494958, + "version": "1.9.0" + }, + "tensorflow-eigen-2.0.0-h68edfc2_0.conda": { + "build": "h68edfc2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 2.0.0" + ], + "md5": "dd5725a88b9540d9c994aa7dcd87abb8", + "name": "tensorflow-eigen", + "sha256": "4bd68722b3488bbe8940880915b24904bbcdf391c8d0d2b487431bd7263224b8", + "size": 2617, + "subdir": "linux-64", + "timestamp": 1571762181509, + "version": "2.0.0" + }, + "tensorflow-eigen-2.1.0-h68edfc2_0.conda": { + "build": "h68edfc2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 2.1.0" + ], + "md5": "9bead1eda62ab5e0635ea14d4dc24ccd", + "name": "tensorflow-eigen", + "sha256": "52b85d591b46c8844108ade09151491143d350e10b5a51679c694008a10349ca", + "size": 2791, + "subdir": "linux-64", + "timestamp": 1582050850535, + "version": "2.1.0" + }, + "tensorflow-eigen-2.2.0-h68edfc2_0.conda": { + "build": "h68edfc2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 2.2.0" + ], + "md5": "f28066dd875637cb7459f5363f2cae65", + "name": "tensorflow-eigen", + "sha256": "d9547fc55b5fade1622440aa012fe3949621f9ffa8fe7b926404deadaaacce5a", + "size": 2987, + "subdir": "linux-64", + "timestamp": 1590159163119, + "version": "2.2.0" + }, + "tensorflow-eigen-2.4.1-h17f2ed4_0.conda": { + "build": "h17f2ed4_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 2.4.1" + ], + "md5": "7448c461ead3a69c1a58565f6a567e58", + "name": "tensorflow-eigen", + "sha256": "280164adec92209cc72ae165e6ede3f24f7ba01adffbdec84568fd6ce0de71f0", + "size": 2703, + "subdir": "linux-64", + "timestamp": 1614595064824, + "version": "2.4.1" + }, + "tensorflow-eigen-2.5.0-h17f2ed4_0.conda": { + "build": "h17f2ed4_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 2.5.0" + ], + "md5": "960332cba4c4a46d03346934801bca45", + "name": "tensorflow-eigen", + "sha256": "0cbfc91f800f4115482e4788bea3fed2a38dcb2b894c6d0a169658964715585c", + "size": 2765, + "subdir": "linux-64", + "timestamp": 1622195448330, + "version": "2.5.0" + }, + "tensorflow-estimator-2.10.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.10.*" + ], + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "16c8283d2a4a741d2b1bb1e107d694d9", + "name": "tensorflow-estimator", + "sha256": "4c70029e69919e64ed0ea478bd75831f64cdf3d7674ecba33d9ef4e1ca21485f", + "size": 507874, + "subdir": "linux-64", + "timestamp": 1666890076256, + "version": "2.10.0" + }, + "tensorflow-estimator-2.10.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.10.*" + ], + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bece850d33e6b4422041db55e223d491", + "name": "tensorflow-estimator", + "sha256": "dc5be238362525eed0fb3dc17446161abe0cca52ff7ede962298a2f0844611b3", + "size": 497159, + "subdir": "linux-64", + "timestamp": 1666890130654, + "version": "2.10.0" + }, + "tensorflow-estimator-2.10.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.10.*" + ], + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d826f09ef3cf5759a6da9f2f97c87dbe", + "name": "tensorflow-estimator", + "sha256": "18b2221c47464bf75d3605ac033f6b1568817768e4d9dbff828725c03212ecf2", + "size": 502275, + "subdir": "linux-64", + "timestamp": 1666890111244, + "version": "2.10.0" + }, + "tensorflow-estimator-2.10.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.10.*" + ], + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7878c4957820507b53b78b1aff89bac0", + "name": "tensorflow-estimator", + "sha256": "51d7808f10d5cc26b8b20562121135cb97c8f4ef36788296f74ed83ae4e88f61", + "size": 503013, + "subdir": "linux-64", + "timestamp": 1666890093737, + "version": "2.10.0" + }, + "tensorflow-estimator-2.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.11.*" + ], + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "54230f0080c332a8666187e81bdbb561", + "name": "tensorflow-estimator", + "sha256": "011a24f03f7e1910925ebe9cd0b64c2db522f049dddff03dda2226a61ef294be", + "size": 500740, + "subdir": "linux-64", + "timestamp": 1678126875178, + "version": "2.11.0" + }, + "tensorflow-estimator-2.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.11.*" + ], + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "de77e3c5ad6c66f863f41a3e7f349039", + "name": "tensorflow-estimator", + "sha256": "bc410e088f686381ad1632861733dbe10cbc7b6d856c511f20e6d26ee555b06e", + "size": 503296, + "subdir": "linux-64", + "timestamp": 1678126889805, + "version": "2.11.0" + }, + "tensorflow-estimator-2.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.11.*" + ], + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a31e162864d0f38202c6555449ab4a82", + "name": "tensorflow-estimator", + "sha256": "0c415856482e31f24388e82e1e9081ed2b842dc4a614dc73b7d23580a37883c1", + "size": 503475, + "subdir": "linux-64", + "timestamp": 1678126904557, + "version": "2.11.0" + }, + "tensorflow-estimator-2.8.0-py310h2f386ee_0.conda": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "tensorflow-base 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "68745b0121b8aa3e33fa4fbdfe51be19", + "name": "tensorflow-estimator", + "sha256": "5adba23ac56ed353198b6cc64221bd21e1e9987f4f717a6a789d7996d7f77df0", + "size": 544382, + "subdir": "linux-64", + "timestamp": 1658918754703, + "version": "2.8.0" + }, + "tensorflow-estimator-2.8.0-py37hb070fc8_0.conda": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "tensorflow-base 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e76fcfcfe1f5ff52eb6c079ec3edb5eb", + "name": "tensorflow-estimator", + "sha256": "52e4cfa96210f510f35f856c720db360d9f5419b5e724a8de80815c266295345", + "size": 532250, + "subdir": "linux-64", + "timestamp": 1658918789146, + "version": "2.8.0" + }, + "tensorflow-estimator-2.8.0-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "tensorflow-base 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b941af7b468eeddc15e9a7f152d6683a", + "name": "tensorflow-estimator", + "sha256": "84d98d8a040b5d32823bfd95d3edff46ed1aa9ac292bdc87f7f30f7951416b69", + "size": 538437, + "subdir": "linux-64", + "timestamp": 1658918771884, + "version": "2.8.0" + }, + "tensorflow-estimator-2.8.0-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "tensorflow-base 2.8.*" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bfcb7bfa9f1eb90cdf4295ea04b947fe", + "name": "tensorflow-estimator", + "sha256": "8ce170c054d376c1d6f170eeca7363fcf49d27973157acf6a1ad135ec3bdbc01", + "size": 538335, + "subdir": "linux-64", + "timestamp": 1658918736668, + "version": "2.8.0" + }, + "tensorflow-estimator-2.9.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.9.*" + ], + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "58954f4903745e9a388527f0644ad314", + "name": "tensorflow-estimator", + "sha256": "d289a52e723becb4ba02eb395de14439fcfb30e018885b40c63a16b20f0db12d", + "size": 507507, + "subdir": "linux-64", + "timestamp": 1661448142086, + "version": "2.9.0" + }, + "tensorflow-estimator-2.9.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.9.*" + ], + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9f943dd8b76b30a14532fbc494493d51", + "name": "tensorflow-estimator", + "sha256": "58154f5c500ef1f5cb60f819a67f5e3ce586ed68e4fb07f1ad43bea28c4099f7", + "size": 488623, + "subdir": "linux-64", + "timestamp": 1661448124375, + "version": "2.9.0" + }, + "tensorflow-estimator-2.9.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.9.*" + ], + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "41dbeb0bcda829218a184e34f43522dc", + "name": "tensorflow-estimator", + "sha256": "e23177958494c7db7d42e07e6e106e459084437426277817186b84f24fb9424b", + "size": 502669, + "subdir": "linux-64", + "timestamp": 1661448161728, + "version": "2.9.0" + }, + "tensorflow-estimator-2.9.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "tensorflow-base 2.9.*" + ], + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e37f1dee735887557d32598f03b23250", + "name": "tensorflow-estimator", + "sha256": "d28ed4ffb80d3ba831853452e8d4bb3e410a0406ec2d283235510f6195d477eb", + "size": 503253, + "subdir": "linux-64", + "timestamp": 1661448104330, + "version": "2.9.0" + }, + "tensorflow-gpu-1.10.0-hf154084_0.conda": { + "build": "hf154084_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 1.10.0" + ], + "md5": "c454190aab7285e54eb8176a6c5f47be", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "1e0db99747ec3e6bd7a9c75ab0f6b226adb9eb28d7dcdccd07035c90f54d15fb", + "size": 2492, + "subdir": "linux-64", + "timestamp": 1534889702492, + "version": "1.10.0" + }, + "tensorflow-gpu-1.11.0-h0d30ee6_0.conda": { + "build": "h0d30ee6_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 1.11.0" + ], + "md5": "96395a9bc0d164f2011a864a4cb02892", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "8ae0604b763632027d8a1e5c64c04036fd6956544984787980b5f17d5eafd1a6", + "size": 2542, + "subdir": "linux-64", + "timestamp": 1538749556658, + "version": "1.11.0" + }, + "tensorflow-gpu-1.12.0-h0d30ee6_0.conda": { + "build": "h0d30ee6_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 1.12.0" + ], + "md5": "db2b62bfb333260269191be5500fbe17", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "9eaef27638672f8d918f7697cff0996b82dbe3f037a20cc91b1e76e2a2a3c991", + "size": 2609, + "subdir": "linux-64", + "timestamp": 1542153549403, + "version": "1.12.0" + }, + "tensorflow-gpu-1.13.1-h0d30ee6_0.conda": { + "build": "h0d30ee6_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 1.13.1" + ], + "md5": "0054b6d9b222ae2e5b25624b7422e5eb", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "d2bc587d75272376b0d3b34e7df2185c104bf9e3b46bbd265f6066a69ce8f744", + "size": 2763, + "subdir": "linux-64", + "timestamp": 1554467722644, + "version": "1.13.1" + }, + "tensorflow-gpu-1.14.0-h0d30ee6_0.conda": { + "build": "h0d30ee6_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 1.14.0" + ], + "md5": "4f70261cb133a6d703b88a360d9e2c61", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "429000eb7c48db1ced454e8501506ca2fa8584688df387a8a8e7ee8ed6c9f0f9", + "size": 3083, + "subdir": "linux-64", + "timestamp": 1561537703680, + "version": "1.14.0" + }, + "tensorflow-gpu-1.15.0-h0d30ee6_0.conda": { + "build": "h0d30ee6_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 1.15.0" + ], + "md5": "02e8e2e941bf4c5eeebcc0fcafc6216d", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "70b2100bf1eb831893c6540aab224d4a24092d9d634068997c9c397a841a4923", + "size": 2851, + "subdir": "linux-64", + "timestamp": 1573483047498, + "version": "1.15.0" + }, + "tensorflow-gpu-1.4.1-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "tensorflow-gpu-base 1.4.1", + "tensorflow-tensorboard" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "11a19c914ad5ff2214f77c1e0803101e", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "653d135f34fc2802b0e66b60d287bb9d7ff546c7b2ec971aa3dd5625166ce5d6", + "size": 3189, + "subdir": "linux-64", + "timestamp": 1516642141208, + "version": "1.4.1" + }, + "tensorflow-gpu-1.5.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "tensorflow-gpu-base 1.5.0", + "tensorflow-tensorboard >=1.5.0,<1.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1b6c27c5b1eb53e3b0704380f66a8c16", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "58ea7eef13cc9f89797bed56e1d41d3a8cd694c02ff3e64f525191670c524725", + "size": 3289, + "subdir": "linux-64", + "timestamp": 1524251597249, + "version": "1.5.0" + }, + "tensorflow-gpu-1.6.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "tensorboard >=1.6.0,<1.7.0", + "tensorflow-gpu-base 1.6.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a5feae6a218e5ab7e869906df86fe787", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "44b67c4970485143660446a12364ba239ce7ac3889e97db6dac408d91206e8cf", + "size": 3725, + "subdir": "linux-64", + "timestamp": 1524325197583, + "version": "1.6.0" + }, + "tensorflow-gpu-1.7.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "tensorboard >=1.7.0,<1.8.0", + "tensorflow-gpu-base 1.7.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1a50032eb3e4532bc940cd4ee5dbff83", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "0a2c4258d03cace52f7ac81aa8310dd08e25a3286db0e9b474bb0f114ebe90d3", + "size": 3764, + "subdir": "linux-64", + "timestamp": 1524418129196, + "version": "1.7.0" + }, + "tensorflow-gpu-1.8.0-h7b35bdc_0.conda": { + "build": "h7b35bdc_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.1.0 gpu", + "tensorflow >=1.8.0,<1.8.1.0a0" + ], + "md5": "1cdb87203178bab935640132228057cf", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "b2f41efaf7ad19795588a39de32381120d41e06f2bf4080df5ff4ecd0a3a9e30", + "size": 5530, + "subdir": "linux-64", + "timestamp": 1527183790291, + "version": "1.8.0" + }, + "tensorflow-gpu-1.9.0-hf154084_0.conda": { + "build": "hf154084_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 1.9.0" + ], + "md5": "e9225e10cd9266e01fa20778f8e33322", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "1c5024f744c1bfbb4537f16159252a76852c70f4f7af8677eb9ac0e9f5382e81", + "size": 2532, + "subdir": "linux-64", + "timestamp": 1532624036275, + "version": "1.9.0" + }, + "tensorflow-gpu-2.0.0-h0d30ee6_0.conda": { + "build": "h0d30ee6_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 2.0.0" + ], + "md5": "9aa29a4df713813bdc8791d04ccb371c", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "4c986c81d23ab87424f343ce8550ca945c48d8630ee73afdd62f34d1a4fdcf07", + "size": 2612, + "subdir": "linux-64", + "timestamp": 1571762216140, + "version": "2.0.0" + }, + "tensorflow-gpu-2.1.0-h0d30ee6_0.conda": { + "build": "h0d30ee6_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 2.1.0" + ], + "md5": "9307251c0b6e20616ea2f3a8ffa610c8", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "f05aa22d7d28cf30cc0f4225a5ca38b905d09d6f9d143d49b5e9c978028dca0c", + "size": 2801, + "subdir": "linux-64", + "timestamp": 1582138833411, + "version": "2.1.0" + }, + "tensorflow-gpu-2.2.0-h0d30ee6_0.conda": { + "build": "h0d30ee6_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 2.2.0" + ], + "md5": "ac0a1fc4ea1bf9a35a3e6da5409baee7", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "8c915472d41faa2d871cb859fd7bd61f29de5deacdd298b37a36d3dac55bb4de", + "size": 2981, + "subdir": "linux-64", + "timestamp": 1590174247474, + "version": "2.2.0" + }, + "tensorflow-gpu-2.4.1-h30adc30_0.conda": { + "build": "h30adc30_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.1.0 gpu", + "tensorflow 2.4.1" + ], + "md5": "0dd8e1a37f8606f76429ca3b5d57346c", + "name": "tensorflow-gpu", + "namespace": "python", + "sha256": "b1c8e34f55c1538d9e245e1135ede961c72baedadc09a6a5abb054a869c94ee3", + "size": 2696, + "subdir": "linux-64", + "timestamp": 1614595013103, + "version": "2.4.1" + }, + "tensorflow-gpu-base-1.4.1-py27h01caf0a_0.conda": { + "build": "py27h01caf0a_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "enum34 >=1.1.6", + "mock >=2.0.0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.3.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fc905b4d09636ef81ffbfacccdbf0979", + "name": "tensorflow-gpu-base", + "sha256": "e406fd06e90ca7e721252f1c746c12d080897109ba992e0be5ad4a9d145e4129", + "size": 58021336, + "subdir": "linux-64", + "timestamp": 1516550814366, + "version": "1.4.1" + }, + "tensorflow-gpu-base-1.4.1-py27ha7e2fe3_0.conda": { + "build": "py27ha7e2fe3_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn 6.0.*", + "enum34 >=1.1.6", + "mock >=2.0.0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.3.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c76524e3d5ce5eb61ee2dc2e077f00ec", + "name": "tensorflow-gpu-base", + "sha256": "3155616b40ea6d397087df6cdf904a3f14330fa6c23001321ecb826a989051f4", + "size": 58041416, + "subdir": "linux-64", + "timestamp": 1516564230711, + "version": "1.4.1" + }, + "tensorflow-gpu-base-1.4.1-py35h01caf0a_0.conda": { + "build": "py35h01caf0a_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.3.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ab87505444954afa448318ef71f9bd39", + "name": "tensorflow-gpu-base", + "sha256": "ffe7b869e10a527618daeb189bdba2173c4315263cf66a72422394cc023469c3", + "size": 57285532, + "subdir": "linux-64", + "timestamp": 1516552207143, + "version": "1.4.1" + }, + "tensorflow-gpu-base-1.4.1-py35ha7e2fe3_0.conda": { + "build": "py35ha7e2fe3_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn 6.0.*", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.3.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c1aa988212bd8146b37a0fa294494031", + "name": "tensorflow-gpu-base", + "sha256": "32e330a5ce68395b5d970ef47476bd5d437c4fde49ac2f3b43fe3095bb0017f6", + "size": 57234451, + "subdir": "linux-64", + "timestamp": 1516578550054, + "version": "1.4.1" + }, + "tensorflow-gpu-base-1.4.1-py36h01caf0a_0.conda": { + "build": "py36h01caf0a_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.3.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8c3ac2d4b8cfc3e38d668a0c6bba3048", + "name": "tensorflow-gpu-base", + "sha256": "a6b2ab2c243127c2a13b48debd48f99f555a9d9e982f1536f653885a6f31852b", + "size": 58125554, + "subdir": "linux-64", + "timestamp": 1516553872591, + "version": "1.4.1" + }, + "tensorflow-gpu-base-1.4.1-py36ha7e2fe3_0.conda": { + "build": "py36ha7e2fe3_0", + "build_number": 0, + "depends": [ + "cudatoolkit 8.0.*", + "cudnn 6.0.*", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.3.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "60191f7a32811508cbe15d2377c2644d", + "name": "tensorflow-gpu-base", + "sha256": "2fcc152536da7fffdca613c8c3852b94dedb22ab6b7c9c3a524295db59122da0", + "size": 58130382, + "subdir": "linux-64", + "timestamp": 1516583040892, + "version": "1.4.1" + }, + "tensorflow-gpu-base-1.5.0-py27h8a131e3_0.conda": { + "build": "py27h8a131e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "mock >=2.0.0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "22174750e2c62e696d0573c51f68b02f", + "name": "tensorflow-gpu-base", + "sha256": "95c82c652bbe861af4b57a65ca2208d96531de5b270325d979085cd214a676e7", + "size": 72583134, + "subdir": "linux-64", + "timestamp": 1524340351292, + "version": "1.5.0" + }, + "tensorflow-gpu-base-1.5.0-py27had95abb_0.conda": { + "build": "py27had95abb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "backports.weakref >=1.0rc1", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "mock >=2.0.0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d8dfe435ab02b5b63db557e1d18e3bd7", + "name": "tensorflow-gpu-base", + "sha256": "cad34b91ffe5f68fdfcb51ad4fb99b0b95a0326c18acc82b14e3b1d49b8c58a0", + "size": 64761496, + "subdir": "linux-64", + "timestamp": 1524247813551, + "version": "1.5.0" + }, + "tensorflow-gpu-base-1.5.0-py35h8a131e3_0.conda": { + "build": "py35h8a131e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d93434e2f07621449ca014d796d78038", + "name": "tensorflow-gpu-base", + "sha256": "3eb7d7324acc1472ebd9b097c4789c5928a3f55bd77ff4671126e65e8ab7a365", + "size": 72479973, + "subdir": "linux-64", + "timestamp": 1524338499640, + "version": "1.5.0" + }, + "tensorflow-gpu-base-1.5.0-py35had95abb_0.conda": { + "build": "py35had95abb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f53334ae5c1fa6763a9e72e8a1f81de7", + "name": "tensorflow-gpu-base", + "sha256": "ce23fa5f39a3e73a63f39ead03704694f612a5ac3991b05772f292987ac198ec", + "size": 65783468, + "subdir": "linux-64", + "timestamp": 1524246318963, + "version": "1.5.0" + }, + "tensorflow-gpu-base-1.5.0-py36h8a131e3_0.conda": { + "build": "py36h8a131e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b46ca9a1e4142a80a7cb54297f495979", + "name": "tensorflow-gpu-base", + "sha256": "d0854d9468240d4691eb29a4c081fc037dce7451640e8c5bc1325fad6f19601e", + "size": 72485697, + "subdir": "linux-64", + "timestamp": 1524336871212, + "version": "1.5.0" + }, + "tensorflow-gpu-base-1.5.0-py36had95abb_0.conda": { + "build": "py36had95abb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.12.1,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c42bb206af90774b0498ced81e8d5f10", + "name": "tensorflow-gpu-base", + "sha256": "254c403ec6a3bdc26905cb9b45096cc2e6f46fd2f8574bf2f1238946eb4b0d05", + "size": 65048846, + "subdir": "linux-64", + "timestamp": 1524244464976, + "version": "1.5.0" + }, + "tensorflow-gpu-base-1.6.0-py27h5b7bae4_1.conda": { + "build": "py27h5b7bae4_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "81e88a1fc4dbb8bb633e95143afd607c", + "name": "tensorflow-gpu-base", + "sha256": "870602067894eae1773806e9b56c658e6686a4f32cb363af13c2ad453ad6a51d", + "size": 64186510, + "subdir": "linux-64", + "timestamp": 1525885198325, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py27h8a131e3_0.conda": { + "build": "py27h8a131e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bbb1e06bdff54c152f45b4b20270ef7b", + "name": "tensorflow-gpu-base", + "sha256": "3528f1c08e4e2a71d04c58383e1abfa102725596e191fccff60c42cc0c6c7c61", + "size": 75277814, + "subdir": "linux-64", + "timestamp": 1524343611600, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py27had95abb_0.conda": { + "build": "py27had95abb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e7eb9c96734b14a08e4a46bf9c60497d", + "name": "tensorflow-gpu-base", + "sha256": "a2edda633ec286af866c60c85eacf92bc4bc195729b518696e182b365516a517", + "size": 69345379, + "subdir": "linux-64", + "timestamp": 1524275475892, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py27hcdda91b_1.conda": { + "build": "py27hcdda91b_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c19c4b49ada5f9fd708f8cff2c397cde", + "name": "tensorflow-gpu-base", + "sha256": "0438e96a8e3a9023220a38bcc6216b5f7b10c23b165d032a82adc685abbbf81f", + "size": 72336471, + "subdir": "linux-64", + "timestamp": 1525887600843, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py35h5b7bae4_1.conda": { + "build": "py35h5b7bae4_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "84df1a00baaae45e01466dfb48a8672e", + "name": "tensorflow-gpu-base", + "sha256": "d5279a935b8aea616ad91377d4a7a0d4bc2f6ad0f005b46c19d73db164ce862f", + "size": 65221819, + "subdir": "linux-64", + "timestamp": 1525883577998, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py35h8a131e3_0.conda": { + "build": "py35h8a131e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ffed0baea9f2b0559f1e008f45a92149", + "name": "tensorflow-gpu-base", + "sha256": "85792c549684ff84a0078ee875d17b17cf7a73b5dbbe4160b3322345a932b5db", + "size": 75271749, + "subdir": "linux-64", + "timestamp": 1524349345333, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py35had95abb_0.conda": { + "build": "py35had95abb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d686bd3fd90b4069f8561de01e0a4d9e", + "name": "tensorflow-gpu-base", + "sha256": "f6204946653d4d01fae7183fd3cf914c077b2a56cfd5649c42ae37d6dd6e056f", + "size": 69247642, + "subdir": "linux-64", + "timestamp": 1524322150162, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py35hcdda91b_1.conda": { + "build": "py35hcdda91b_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1b2377e924b535fe677a3cec3b89a445", + "name": "tensorflow-gpu-base", + "sha256": "a7d147f9abf080ec9dc866a7497c140d76128ad52ccbf8c7e5765ab70380ea15", + "size": 72192699, + "subdir": "linux-64", + "timestamp": 1525889187584, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py36h5b7bae4_1.conda": { + "build": "py36h5b7bae4_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fff3c9491c0946323caeb5fb9a10f8c7", + "name": "tensorflow-gpu-base", + "sha256": "fedaf9e6c99a2c817b15cef8909672ca93a81b6bc4509f68179d42787d689919", + "size": 64461501, + "subdir": "linux-64", + "timestamp": 1525882005970, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py36h8a131e3_0.conda": { + "build": "py36h8a131e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a4d351e8ce13a8b1bfc8fca2a9b580d7", + "name": "tensorflow-gpu-base", + "sha256": "f756d3f52be586981a4947641ac6009520d29b67e7dcf8124ead876b8e6fe79f", + "size": 76209792, + "subdir": "linux-64", + "timestamp": 1524356441703, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py36had95abb_0.conda": { + "build": "py36had95abb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "58d806359f600381352d8fcedee6d7cd", + "name": "tensorflow-gpu-base", + "sha256": "42acf6a664ae1934fd3e41690e266e9bc8bf278c512353dfa925f20335da37af", + "size": 68457125, + "subdir": "linux-64", + "timestamp": 1524314713282, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.6.0-py36hcdda91b_1.conda": { + "build": "py36hcdda91b_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "94a39f1214e40560d1eaaa2ab32c4d2a", + "name": "tensorflow-gpu-base", + "sha256": "dfa79f8f779b4f2a80f074e483806fac51198ddc2bfd1932787d8e31799d1c5d", + "size": 71428405, + "subdir": "linux-64", + "timestamp": 1525891188345, + "version": "1.6.0" + }, + "tensorflow-gpu-base-1.7.0-py27h5b7bae4_1.conda": { + "build": "py27h5b7bae4_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "21f874d61bfa9e1735935d1dd3bd0d60", + "name": "tensorflow-gpu-base", + "sha256": "8c06641297cf519af675223535e300994bc3a9318d90f50fbdcf57fc2800f153", + "size": 65671003, + "subdir": "linux-64", + "timestamp": 1525899886235, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py27h8a131e3_0.conda": { + "build": "py27h8a131e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "64606c64775cfdb6649e5c4ff68bdf9f", + "name": "tensorflow-gpu-base", + "sha256": "141590745c0f0f95d8bfc269c104ac8342df7491573d6f48752f26f5709fcd17", + "size": 77094202, + "subdir": "linux-64", + "timestamp": 1524371398570, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py27had95abb_0.conda": { + "build": "py27had95abb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "031a35bcd6a054ac55ed628fff869315", + "name": "tensorflow-gpu-base", + "sha256": "98f14534cd0316a760115c1a3109e896092318b4f79e387de23fa10085b4f2ea", + "size": 71239073, + "subdir": "linux-64", + "timestamp": 1524328233812, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py27hcdda91b_1.conda": { + "build": "py27hcdda91b_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "backports.weakref >=1.0rc1", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "enum34 >=1.1.6", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mock >=2.0.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "eb515a9272c1a686764c3716658260da", + "name": "tensorflow-gpu-base", + "sha256": "e6a332e9e970c481e10f293a20abafed6ef9abb56b8e511905342533e901050f", + "size": 73810231, + "subdir": "linux-64", + "timestamp": 1525902699297, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py35h5b7bae4_1.conda": { + "build": "py35h5b7bae4_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "834d8b8e513ac1dbfaa0e6fc96c8cdda", + "name": "tensorflow-gpu-base", + "sha256": "83e2d87ccfd59b4d931452c79f1822b148170326d5b81db0918cfad4edea3559", + "size": 66674090, + "subdir": "linux-64", + "timestamp": 1525901660531, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py35h8a131e3_0.conda": { + "build": "py35h8a131e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "56b07cebb349cb06c3f91b45cbebedda", + "name": "tensorflow-gpu-base", + "sha256": "cb4c6723d83eb2697cca9633486d4eff66831b0a0fa541c7c93a66827e500ed7", + "size": 78141532, + "subdir": "linux-64", + "timestamp": 1524364338390, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py35had95abb_0.conda": { + "build": "py35had95abb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0c39de204b1c7abe50254e5122814d5b", + "name": "tensorflow-gpu-base", + "sha256": "476958aafef7b0588ed7459c22feb76152456e523f3d1f0bed4959f977524873", + "size": 71067588, + "subdir": "linux-64", + "timestamp": 1524329966269, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py35hcdda91b_1.conda": { + "build": "py35hcdda91b_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ed07e974e6f09c0e764429387303a649", + "name": "tensorflow-gpu-base", + "sha256": "e91dcf16d93e5088e1b24a5e93979e21791d6fbd6834b1a3e79151792c07e91b", + "size": 73641394, + "subdir": "linux-64", + "timestamp": 1525904572848, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py36h5b7bae4_1.conda": { + "build": "py36h5b7bae4_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "eb90a4317e76592ded26d6b30e213960", + "name": "tensorflow-gpu-base", + "sha256": "0b457e66b2a9e442b74623dee129af2e9e1d8440c5ce9959749f13eaca0ace91", + "size": 65942337, + "subdir": "linux-64", + "timestamp": 1525896859894, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py36h8a131e3_0.conda": { + "build": "py36h8a131e3_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "057797f6210d673f85ac1898ce61032d", + "name": "tensorflow-gpu-base", + "sha256": "ea8e0c4db57889b7ca0de0b3963299c287631e179c9691b2d4f89ca890884c87", + "size": 78115112, + "subdir": "linux-64", + "timestamp": 1524360530566, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py36had95abb_0.conda": { + "build": "py36had95abb_0", + "build_number": 0, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 8.0.*", + "cudnn >=7.0.5,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "mkl >=2018.0.2,<2019.0a0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1297c6241bf2dea30c284360ed95f321", + "name": "tensorflow-gpu-base", + "sha256": "9f4849f2e1c79362bad9433112fef014de02d7543b85a4fcda0ce3894887bf50", + "size": 70365728, + "subdir": "linux-64", + "timestamp": 1524331545091, + "version": "1.7.0" + }, + "tensorflow-gpu-base-1.7.0-py36hcdda91b_1.conda": { + "build": "py36hcdda91b_1", + "build_number": 1, + "depends": [ + "absl-py >=0.1.6", + "astor >=0.6.0", + "cudatoolkit 9.0.*", + "cudnn >=7.1.2,<=8.0a0", + "cupti", + "gast >=0.2.0", + "grpcio >=1.8.6", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >=1.13.3,<2.0a0", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "termcolor >=1.1.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6b76b62ff6617ecce55d47d4be9570bd", + "name": "tensorflow-gpu-base", + "sha256": "8494605bf73fa96e5b5c17d467c6bc3a716ea80f2e611907467417d39d7b8ff5", + "size": 73628945, + "subdir": "linux-64", + "timestamp": 1525899187341, + "version": "1.7.0" + }, + "tensorflow-mkl-1.10.0-h067cd57_0.conda": { + "build": "h067cd57_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 1.10.0" + ], + "md5": "98268e34e0d357e20fd5cc3aa5471b54", + "name": "tensorflow-mkl", + "sha256": "5b6aa5c91f863211936f9b9a00cd57314f6141d3d1f75658b1dabab8b516bc01", + "size": 2718, + "subdir": "linux-64", + "timestamp": 1534871897653, + "version": "1.10.0" + }, + "tensorflow-mkl-1.11.0-h4fcabd2_0.conda": { + "build": "h4fcabd2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 1.11.0" + ], + "md5": "1e3b4b2fbc9fca72d7a3061c5b34f892", + "name": "tensorflow-mkl", + "sha256": "83842553c50ec9877472910f459b0ca5df0abce8f134e386d282bc6f4f05d7ca", + "size": 2751, + "subdir": "linux-64", + "timestamp": 1538592701795, + "version": "1.11.0" + }, + "tensorflow-mkl-1.12.0-h4fcabd2_0.conda": { + "build": "h4fcabd2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 1.12.0" + ], + "md5": "6c9e0ca321e0ec4eb2c0a0b8c2d3dee8", + "name": "tensorflow-mkl", + "sha256": "3b2f4d5736d848f0556a5bc81caaf89a8ebed3818a782d99832dd29dc593f75d", + "size": 2846, + "subdir": "linux-64", + "timestamp": 1542084275944, + "version": "1.12.0" + }, + "tensorflow-mkl-1.13.1-h4fcabd2_0.conda": { + "build": "h4fcabd2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 1.13.1" + ], + "md5": "b94f8848441bd885fe410da8424f466d", + "name": "tensorflow-mkl", + "sha256": "e758f411d50d5162492ef2aad9b8fb1720d919f524ac3eb8d93fa399667a5fe4", + "size": 2888, + "subdir": "linux-64", + "timestamp": 1554328284671, + "version": "1.13.1" + }, + "tensorflow-mkl-1.14.0-h4fcabd2_0.conda": { + "build": "h4fcabd2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 1.14.0" + ], + "md5": "834ca53f4e0cef671d218dd2fd533f30", + "name": "tensorflow-mkl", + "sha256": "280854de133bb9f2560915b842f4cb22a25a77f7d1e3119445b112d16bad7390", + "size": 2746, + "subdir": "linux-64", + "timestamp": 1561050184032, + "version": "1.14.0" + }, + "tensorflow-mkl-1.15.0-h4fcabd2_0.conda": { + "build": "h4fcabd2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 1.15.0" + ], + "md5": "8fa043222eb354ce93d7767089500f01", + "name": "tensorflow-mkl", + "sha256": "7740ed89c8c62a53decb925c28f7dbe4c82d46986585105fab7ed8b6fa2d8c6b", + "size": 2857, + "subdir": "linux-64", + "timestamp": 1573483014066, + "version": "1.15.0" + }, + "tensorflow-mkl-1.8.0-h5a53b39_0.conda": { + "build": "h5a53b39_0", + "build_number": 0, + "depends": [ + "_tflow_select ==1.2.0 mkl", + "tensorflow 1.8.0" + ], + "md5": "90fa238ff20a6cd0727b67ba0b166d36", + "name": "tensorflow-mkl", + "sha256": "8cbf177da9b7bee28ccbcea9c751e81a519bd519cd1ba13cd889df404eb95d5b", + "size": 3189, + "subdir": "linux-64", + "timestamp": 1527094788454, + "version": "1.8.0" + }, + "tensorflow-mkl-1.9.0-h067cd57_0.conda": { + "build": "h067cd57_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 1.9.0" + ], + "md5": "f728f6d6f2c456a270929279828f6a78", + "name": "tensorflow-mkl", + "sha256": "bf29d3e3f40373ddd69a73d1fc675cb894cf24509aa3b869902e7a838a26f876", + "size": 2751, + "subdir": "linux-64", + "timestamp": 1532470508014, + "version": "1.9.0" + }, + "tensorflow-mkl-2.0.0-h4fcabd2_0.conda": { + "build": "h4fcabd2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 2.0.0" + ], + "md5": "ba57cff07e0f6e72bc2151964896da7f", + "name": "tensorflow-mkl", + "sha256": "3adafbd0a58d581b7a653008001de7be91e79d1825f3b544444130003abbf215", + "size": 2615, + "subdir": "linux-64", + "timestamp": 1571762198882, + "version": "2.0.0" + }, + "tensorflow-mkl-2.1.0-h4fcabd2_0.conda": { + "build": "h4fcabd2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 2.1.0" + ], + "md5": "24651824f4c132d8101ab734af7ac573", + "name": "tensorflow-mkl", + "sha256": "99416b2b7bbeb55f74f7d6a8af1a63fb3a9759418456066987b15e4d56cfda33", + "size": 2785, + "subdir": "linux-64", + "timestamp": 1582050880656, + "version": "2.1.0" + }, + "tensorflow-mkl-2.2.0-h4fcabd2_0.conda": { + "build": "h4fcabd2_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 2.2.0" + ], + "md5": "b8ae41f6770644130b5d6a9962643704", + "name": "tensorflow-mkl", + "sha256": "74e290d80aa0ed8aad29dc340d2f372467621fc9fa169962956ed3ccdde9e9f8", + "size": 2986, + "subdir": "linux-64", + "timestamp": 1590159179630, + "version": "2.2.0" + }, + "tensorflow-mkl-2.4.1-h65a7e9c_0.conda": { + "build": "h65a7e9c_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.3.0 mkl", + "tensorflow 2.4.1" + ], + "md5": "29a7b70119e77b241dbb225713db0f78", + "name": "tensorflow-mkl", + "sha256": "3f04e39dcac70c6ce030d5e2a7a8d5b1211565dd3cd44f1df0a9c35bd3e22afb", + "size": 2694, + "subdir": "linux-64", + "timestamp": 1614595039083, + "version": "2.4.1" + }, + "tensorflow-mkl-2.5.0-h1e5c024_0.conda": { + "build": "h1e5c024_0", + "build_number": 0, + "depends": [ + "_tflow_select ==2.2.0 eigen", + "tensorflow 2.5.0" + ], + "md5": "d3273390dca1ef8b1a297bc1adf4c543", + "name": "tensorflow-mkl", + "sha256": "80a8b025383022e33a2e02e23c22bacf3c37092577a3d3573812dcb86c9bcecf", + "size": 2745, + "subdir": "linux-64", + "timestamp": 1622195427055, + "version": "2.5.0" + }, + "tensorflow-tensorboard-0.4.0-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach 1.5.0", + "futures >=3.1.1", + "html5lib 0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "08ef3fc2ac9429b49759fa8c5ddd9dda", + "name": "tensorflow-tensorboard", + "sha256": "3b55cb041b986a3c115569f0619f1b970ae02361b88587d75b3c83241c2512a2", + "size": 1667244, + "subdir": "linux-64", + "timestamp": 1517616380566, + "version": "0.4.0" + }, + "tensorflow-tensorboard-0.4.0-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach 1.5.0", + "html5lib 0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "10cb7799902d249e3682eba01eb19b2b", + "name": "tensorflow-tensorboard", + "sha256": "9e7b2de75b83b7c6e2f6fa9786d7772f1f37ebf1982c912a11d3241f89e9ec55", + "size": 1667321, + "subdir": "linux-64", + "timestamp": 1517616345132, + "version": "0.4.0" + }, + "tensorflow-tensorboard-0.4.0-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach 1.5.0", + "html5lib 0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1aea26c049d9c3398892c86fdd68de8f", + "name": "tensorflow-tensorboard", + "sha256": "82431f1dcc129388a5730dcea1deeca4e8af910f684c311423063ecec3a18664", + "size": 1668876, + "subdir": "linux-64", + "timestamp": 1517616414543, + "version": "0.4.0" + }, + "tensorflow-tensorboard-1.5.1-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach 1.5.0", + "futures >=3.1.1", + "html5lib 0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a4b8cc89ad0546c790899328c67732d6", + "name": "tensorflow-tensorboard", + "sha256": "cc6517a6f4205c5e547a03cefd64d0db930d72f358000ccc7c07f05e16cdbf88", + "size": 3008283, + "subdir": "linux-64", + "timestamp": 1519693326076, + "version": "1.5.1" + }, + "tensorflow-tensorboard-1.5.1-py27hf484d3e_1.conda": { + "build": "py27hf484d3e_1", + "build_number": 1, + "depends": [ + "bleach >=1.5.0,<1.5.1.0a0", + "futures", + "html5lib >=0.9999999,<0.10000000.0a0", + "libgcc-ng", + "libstdcxx-ng", + "markdown", + "numpy", + "protobuf", + "python >=2.7,<2.8.0a0", + "six", + "werkzeug" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ad50a98126a13c1dd16a8a2ced73f340", + "name": "tensorflow-tensorboard", + "sha256": "f94f493d2728aff2e10260d2199f3c576d4e27678ba594e95cde686123b78918", + "size": 3008236, + "subdir": "linux-64", + "timestamp": 1524776951881, + "version": "1.5.1" + }, + "tensorflow-tensorboard-1.5.1-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach 1.5.0", + "html5lib 0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1f69764d697c0c45f1f01683805a6f31", + "name": "tensorflow-tensorboard", + "sha256": "57f5b5629477557a26d938d17596becc2140441b62f7f22802908227b0b01abd", + "size": 3014038, + "subdir": "linux-64", + "timestamp": 1519693367705, + "version": "1.5.1" + }, + "tensorflow-tensorboard-1.5.1-py35hf484d3e_1.conda": { + "build": "py35hf484d3e_1", + "build_number": 1, + "depends": [ + "bleach >=1.5.0,<1.5.1.0a0", + "html5lib >=0.9999999,<0.10000000.0a0", + "libgcc-ng", + "libstdcxx-ng", + "markdown", + "numpy", + "protobuf", + "python >=3.5,<3.6.0a0", + "six", + "werkzeug" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "546f5fb78c27b10fdcc609472c0c1a13", + "name": "tensorflow-tensorboard", + "sha256": "8ded23377747dfc71372d681ee26f0b1d76a29a6f320c27c6402024a06b5936b", + "size": 3011145, + "subdir": "linux-64", + "timestamp": 1524777625300, + "version": "1.5.1" + }, + "tensorflow-tensorboard-1.5.1-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "bleach 1.5.0", + "html5lib 0.9999999", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "markdown >=2.6.8", + "numpy >=1.12", + "protobuf >=3.4.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0", + "werkzeug >=0.11.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8ed7e56581afd8392681b699d9d57571", + "name": "tensorflow-tensorboard", + "sha256": "1419f6280922e4e1a90509f75073520e14b8f3cb055ed4675493e9a34d8174d6", + "size": 3011926, + "subdir": "linux-64", + "timestamp": 1519693007330, + "version": "1.5.1" + }, + "tensorflow-tensorboard-1.5.1-py36hf484d3e_1.conda": { + "build": "py36hf484d3e_1", + "build_number": 1, + "depends": [ + "bleach >=1.5.0,<1.5.1.0a0", + "html5lib >=0.9999999,<0.10000000.0a0", + "libgcc-ng", + "libstdcxx-ng", + "markdown", + "numpy", + "protobuf", + "python >=3.6,<3.7.0a0", + "six", + "werkzeug" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "97b9f9c54ad83271198a33cf2b924f4c", + "name": "tensorflow-tensorboard", + "sha256": "56c64907f31f1ed98164b77ee3323a51c11f2538cbc42672e72cd46934d7559a", + "size": 3009347, + "subdir": "linux-64", + "timestamp": 1524777625631, + "version": "1.5.1" + }, + "teradata-15.10.0.21-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0729964934e5ba5589afe747b588919", + "name": "teradata", + "sha256": "08a459979e87dd0e9280fb97e89bb01ce1a5225d8ca9841ad9d589667cf493ac", + "size": 74730, + "subdir": "linux-64", + "timestamp": 1531060286406, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py27hc4fef92_0.conda": { + "build": "py27hc4fef92_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "efd3345146ffc722dc8c1e8d638c011d", + "name": "teradata", + "sha256": "2eeb783ea4196ef7f6337c1169badbf8cd2876a5b39d4b020f5f458f14bc9518", + "size": 74949, + "subdir": "linux-64", + "timestamp": 1509054871686, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca1441fe7b4e1c887fa477499285a3e5", + "name": "teradata", + "sha256": "f78f9f47634d68714d3306e32fc3a9500511b577b261fc8ce4ebacd5682ccc5d", + "size": 74787, + "subdir": "linux-64", + "timestamp": 1640795143446, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py35h40e09d7_0.conda": { + "build": "py35h40e09d7_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0cf401174769bf2da7c862d7a4ea7d27", + "name": "teradata", + "sha256": "17e425638c6b03028463ec7e1c639061be6bfcde3ef4f0589ec500061397e908", + "size": 75332, + "subdir": "linux-64", + "timestamp": 1509054883825, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee26bf56ab6acfef62dc14ee591f4cb8", + "name": "teradata", + "sha256": "5e0f7fc11304f5eb9bc21720a8c547e9116aa741553138a96331034dd7a5cb32", + "size": 73619, + "subdir": "linux-64", + "timestamp": 1531060221626, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "072622f11fef925cbec5840fb7dbf37e", + "name": "teradata", + "sha256": "4d56def030c4733ddc317a7dad6ca9b09ae747bed6f726ae663ab42122e1515a", + "size": 316059, + "subdir": "linux-64", + "timestamp": 1614326534531, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py36ha1fefe6_0.conda": { + "build": "py36ha1fefe6_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b0c097bedb73a46b6ca56e308fabcd74", + "name": "teradata", + "sha256": "57739d127556e71b50027d04b887ea6a5c9c8ab5cd4fc8bebd371465ff359209", + "size": 74195, + "subdir": "linux-64", + "timestamp": 1509054881288, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8c004d909e2d552eef06d9df0efd54b4", + "name": "teradata", + "sha256": "7715dbf6d40c8042631ad9273c0f3cb938607ab4e04800fc40441d57dce705db", + "size": 74065, + "subdir": "linux-64", + "timestamp": 1531060254238, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "19dba9800bd5916aae32ea619bf468ed", + "name": "teradata", + "sha256": "752aa3540235f8136aa3f2ba339ac9d4c8d3eb1f26a034ec49b189693a9a94ae", + "size": 316220, + "subdir": "linux-64", + "timestamp": 1614326528658, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f18eabb9e73c82880bc06e7c1c766ed2", + "name": "teradata", + "sha256": "0eeefc575bcacde8aa38fb5e9df24a1c18612ae1de01f822d7fc390933452f2c", + "size": 74691, + "subdir": "linux-64", + "timestamp": 1573661856796, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7782b63aa2a49637df97479ba6970ecf", + "name": "teradata", + "sha256": "61014fb1ce678732c999c30f6ae889199d699a354c648d26b52c908091eb6034", + "size": 317578, + "subdir": "linux-64", + "timestamp": 1614326524997, + "version": "15.10.0.21" + }, + "teradata-15.10.0.21-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5fd767c7b0a9ff2255bdc0d0fb6f1ad0", + "name": "teradata", + "sha256": "2685f114bd3cd7f704efaf8cb24c224ec4f207e1e9ac639183170f603d5ba4da", + "size": 316866, + "subdir": "linux-64", + "timestamp": 1614325478617, + "version": "15.10.0.21" + }, + "termcolor-1.1.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "2bb2dc565f4206e13cee6b99492a58b7", + "name": "termcolor", + "sha256": "60362d1e505507503b702f9dc0e680fdbb3bbbf81859615f75c1cad8758adf64", + "size": 8586, + "subdir": "linux-64", + "timestamp": 1519945284577, + "version": "1.1.0" + }, + "termcolor-1.1.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "4f91d47883ff39678a017c756b16eeb7", + "name": "termcolor", + "sha256": "dacd58367d1a55ab970111a9e06b4f9177ffc8e76085a2ce9c35301078350945", + "size": 8115, + "subdir": "linux-64", + "timestamp": 1640795161477, + "version": "1.1.0" + }, + "termcolor-1.1.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "b1ac3d682b54e7a924cdc1bfa1ebef78", + "name": "termcolor", + "sha256": "4433499e1fc1385e72644035cf357a684c17bf3af32a1f11d621ba2df79b544d", + "size": 8606, + "subdir": "linux-64", + "timestamp": 1519945254465, + "version": "1.1.0" + }, + "termcolor-1.1.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "3cdf971c0e34c5eea2899d1e7c2526c6", + "name": "termcolor", + "sha256": "490aa5e559681bb7b44ea849cf9ab833de3f372bd44806fe2d942fbcfeede942", + "size": 8565, + "subdir": "linux-64", + "timestamp": 1519945302665, + "version": "1.1.0" + }, + "termcolor-1.1.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "bbcb11b8326b3bff2e3fbcbf45bef373", + "name": "termcolor", + "sha256": "a4d042c81e6fc4143553cfec711ca8580ceb09c722f3d9d1df57276d3212534b", + "size": 9258, + "subdir": "linux-64", + "timestamp": 1613470843114, + "version": "1.1.0" + }, + "termcolor-1.1.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "c3f0f4cc416cc3f7429ad438cdc973df", + "name": "termcolor", + "sha256": "d3f83787eef7fe96eca1ed52be54b64cd6f13a9f0780ebe07ac1b44b03ab8636", + "size": 8439, + "subdir": "linux-64", + "timestamp": 1530961256129, + "version": "1.1.0" + }, + "termcolor-1.1.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "fc42a9dcbe8e4b8577ac6703a12baa62", + "name": "termcolor", + "sha256": "c627dad21b25c41d1f71854b4d8e9053851182c126a736619a07b45f9db50ecc", + "size": 9253, + "subdir": "linux-64", + "timestamp": 1613470221960, + "version": "1.1.0" + }, + "termcolor-1.1.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "7f2612d0e0f6e622897c09bd60129104", + "name": "termcolor", + "sha256": "3c8b9c1ba81ceade50da868af8e47645b5e2cf8cdb5f61aa5148b9df4cae2d1f", + "size": 8285, + "subdir": "linux-64", + "timestamp": 1573661866459, + "version": "1.1.0" + }, + "termcolor-1.1.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "edc3474b3f433da04d9b0aacbc0d31bc", + "name": "termcolor", + "sha256": "b256501e57146371672ff8dda5904474758a954934cda6ef96f3fcc0ecb38150", + "size": 9297, + "subdir": "linux-64", + "timestamp": 1613470846520, + "version": "1.1.0" + }, + "termcolor-1.1.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "9018c351ebc2c18686ab0fd78fcfa297", + "name": "termcolor", + "sha256": "ae8b41680c1d130c3649c0ed980c8e7e27429d2c09b9b1c15a9bb7b002530657", + "size": 9324, + "subdir": "linux-64", + "timestamp": 1613470845326, + "version": "1.1.0" + }, + "termcolor-2.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6fd37fcb0766de20efd5bb0e409e4e58", + "name": "termcolor", + "sha256": "f5a5586c51ecf21dae3c947f7cc9c95f4c7c2e7715647959a8515d9c1e93a08f", + "size": 11562, + "subdir": "linux-64", + "timestamp": 1668084767143, + "version": "2.1.0" + }, + "termcolor-2.1.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64ddf005f9ca6b42738a1db03aff327d", + "name": "termcolor", + "sha256": "f5df5e1d2a62646ede7bd5f1c43eeec60c9503854b18815140ace6f2a751e4e8", + "size": 12420, + "subdir": "linux-64", + "timestamp": 1676838872404, + "version": "2.1.0" + }, + "termcolor-2.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7d2ac9c019c052df638137c9a3c2674d", + "name": "termcolor", + "sha256": "3fe117cec9c52f9313d16141a1fc4d8cb59f6e2839915983a52137c3e7258e03", + "size": 11492, + "subdir": "linux-64", + "timestamp": 1668084739680, + "version": "2.1.0" + }, + "termcolor-2.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2613199b9b7b911c844cf19674635e99", + "name": "termcolor", + "sha256": "0ebb126682a56769727d07dc6a7a550201989b94d1a00903ea54d9c48edbb51c", + "size": 11506, + "subdir": "linux-64", + "timestamp": 1668084684161, + "version": "2.1.0" + }, + "termcolor-2.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6815090271feff6b5d208666a990b871", + "name": "termcolor", + "sha256": "9b4e2e31caa38e94307d39f5fea965cc324fa997365e7596f03f05b184390fca", + "size": 11515, + "subdir": "linux-64", + "timestamp": 1668084711473, + "version": "2.1.0" + }, + "termcolor-cpp-2.0.0-hd09550d_0.conda": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "24a263129fc2c80a16cc674f5770e26f", + "name": "termcolor-cpp", + "sha256": "6360b6a6907f0796ea5bc5e2dc59c5425b852fbe356d90047d2bfe92160b6e39", + "size": 10858, + "subdir": "linux-64", + "timestamp": 1646156069109, + "version": "2.0.0" + }, + "terminado-0.13.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.10,<3.11.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "e531054d28ef64948d3521b84e2e3b63", + "name": "terminado", + "sha256": "3b39c7edcf32c31b5a6d6ee857f3b3fdbac78f29cc7eb7e2f7339368000b09d6", + "size": 31274, + "subdir": "linux-64", + "timestamp": 1644322629663, + "version": "0.13.1" + }, + "terminado-0.13.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.7,<3.8.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ccd4201ba650476608662460bd4165a7", + "name": "terminado", + "sha256": "0a1d41f60d57cfe4d4d72354b0fc157894124709b2e7746284f905b9789a3f3e", + "size": 30937, + "subdir": "linux-64", + "timestamp": 1644304491754, + "version": "0.13.1" + }, + "terminado-0.13.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.8,<3.9.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "3fc07a4bdf64fbf00766564f1aaa5618", + "name": "terminado", + "sha256": "75471a8713e1568ec341773ad77c86355ebec4901e58dba612a6a53b3d5635b1", + "size": 31000, + "subdir": "linux-64", + "timestamp": 1644322613881, + "version": "0.13.1" + }, + "terminado-0.13.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.9,<3.10.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "faf9bffcf454a6b1bfdf7b904f83dd47", + "name": "terminado", + "sha256": "598700c33ed47accb17de9f7f63987d140b8d32aef78ccd33e26ca879f89130d", + "size": 30960, + "subdir": "linux-64", + "timestamp": 1644322613276, + "version": "0.13.1" + }, + "terminado-0.17.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.10,<3.11.0a0", + "tornado >=6.1.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "308a4d2e8c57649c2c0148883d0cc791", + "name": "terminado", + "sha256": "c6631fff3a2c46e80c54c9c41d3b33c4a6a4d43d5cac7f84fe10750769030fb2", + "size": 32496, + "subdir": "linux-64", + "timestamp": 1671752107828, + "version": "0.17.1" + }, + "terminado-0.17.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.11,<3.12.0a0", + "tornado >=6.1.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "71188205b69c392c495c1249de3447f5", + "name": "terminado", + "sha256": "a546225cfff318f8eea22331588638a62ae2fbfe3dc9fa719807e0c5960e291e", + "size": 37714, + "subdir": "linux-64", + "timestamp": 1677696176157, + "version": "0.17.1" + }, + "terminado-0.17.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.7,<3.8.0a0", + "tornado >=6.1.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8294c10d2c18c3018c6f1d8166bcd4cc", + "name": "terminado", + "sha256": "ae4b56abdf6103ed5ef69a64c31488beffef14624bfdde0c7fca4b92e189d1c2", + "size": 32200, + "subdir": "linux-64", + "timestamp": 1671752026753, + "version": "0.17.1" + }, + "terminado-0.17.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.8,<3.9.0a0", + "tornado >=6.1.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "1d47c89a383de4780062b57c01b86dcf", + "name": "terminado", + "sha256": "5297ac14e8ad77375491bfe2a3f618d5ffa4088f6b844b177cfb9fe980757c8f", + "size": 32224, + "subdir": "linux-64", + "timestamp": 1671751945016, + "version": "0.17.1" + }, + "terminado-0.17.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.9,<3.10.0a0", + "tornado >=6.1.0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "ddab9e3645452492fa587038c7c0e13b", + "name": "terminado", + "sha256": "db9564c7cb69a4c24505c363294a25e33035f873e60b1817f0e3f3b88f3b3be9", + "size": 32173, + "subdir": "linux-64", + "timestamp": 1671751864131, + "version": "0.17.1" + }, + "terminado-0.6-py27h4be8df9_0.conda": { + "build": "py27h4be8df9_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=2.7,<2.8.0a0", + "tornado >=4" + ], + "license": "BSD 3-clause", + "md5": "9990f08e5ad764153693654a8d7d8525", + "name": "terminado", + "sha256": "4d2bb61ddb68fa66368f7977079a0d35b532102c00a0959dbcdbc39b60ff3df6", + "size": 22149, + "subdir": "linux-64", + "timestamp": 1505690740936, + "version": "0.6" + }, + "terminado-0.6-py35hce234ed_0.conda": { + "build": "py35hce234ed_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.5,<3.6.0a0", + "tornado >=4" + ], + "license": "BSD 3-clause", + "md5": "c3f19a9aef0fced966c02a3f9c83cf4f", + "name": "terminado", + "sha256": "193c1db0274ff4a4f8b8414cf00a57fa7a06a89606c4e94904e49e1f7ce7df66", + "size": 22709, + "subdir": "linux-64", + "timestamp": 1505690752231, + "version": "0.6" + }, + "terminado-0.6-py36ha25a19f_0.conda": { + "build": "py36ha25a19f_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "BSD 3-clause", + "md5": "f70a7fee28d4bb786a0a977c0530ae17", + "name": "terminado", + "sha256": "3c8c337fb425b64c0dfbca29a6bf9f30dd4355172fa03620762447383d1b6a59", + "size": 22564, + "subdir": "linux-64", + "timestamp": 1505690763580, + "version": "0.6" + }, + "terminado-0.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=2.7,<2.8.0a0", + "tornado >=4" + ], + "license": "BSD 3-clause", + "md5": "742119c9a70b1391f65f4b410450e95b", + "name": "terminado", + "sha256": "859e0cd9b53c512dc5e94484d71c0c248d0409c2a8e8b05d76ee32aaf29b1687", + "size": 21836, + "subdir": "linux-64", + "timestamp": 1515723284417, + "version": "0.8.1" + }, + "terminado-0.8.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "ptyprocess", + "python >=2.7,<2.8.0a0", + "tornado >=4" + ], + "license": "BSD 3-clause", + "md5": "ca48b0091aa45d7dacf43e99512e71f6", + "name": "terminado", + "sha256": "5c62bc1da949ea85f18eea01f09465cf7c5a913a7178f5b2d45db61fa7e995fe", + "size": 21715, + "subdir": "linux-64", + "timestamp": 1517592904899, + "version": "0.8.1" + }, + "terminado-0.8.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.5,<3.6.0a0", + "tornado >=4" + ], + "license": "BSD 3-clause", + "md5": "4e807cc4aad6d0109b7df2ff3dc26d63", + "name": "terminado", + "sha256": "547b5ce74ead2eabb4902eb7fcd9ccc07cf8e2b646e04de94653c84cc0e93ad9", + "size": 22220, + "subdir": "linux-64", + "timestamp": 1515723311817, + "version": "0.8.1" + }, + "terminado-0.8.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "ptyprocess", + "python >=3.5,<3.6.0a0", + "tornado >=4" + ], + "license": "BSD 3-clause", + "md5": "4eaee1c708c31d6e5813c7342d9c01d6", + "name": "terminado", + "sha256": "4c3de892e8765c9e5ad51d5757fd6782b478843ef5bb0eddcaea4971503eb01b", + "size": 22347, + "subdir": "linux-64", + "timestamp": 1517592910613, + "version": "0.8.1" + }, + "terminado-0.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "BSD 3-clause", + "md5": "c408ca68cd3dac3ad69ec00319101439", + "name": "terminado", + "sha256": "c3960744119c44be5ea29c1e5a587b806b8fac6cbe6f7f27013dee9dd892eca2", + "size": 22015, + "subdir": "linux-64", + "timestamp": 1515723241244, + "version": "0.8.1" + }, + "terminado-0.8.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "ptyprocess", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "BSD 3-clause", + "md5": "1eca5ad0804be5396d367920e7ba6da3", + "name": "terminado", + "sha256": "61b217815319407f028d9fbf0fdcbb6e11096d971c5aee4fbc8f5856148a8177", + "size": 22114, + "subdir": "linux-64", + "timestamp": 1517592829612, + "version": "0.8.1" + }, + "terminado-0.8.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "ptyprocess", + "python >=3.7,<3.8.0a0", + "tornado >=4" + ], + "license": "BSD 2-clause", + "md5": "4b7d868773d7dddd6e0f8a15cefbeed7", + "name": "terminado", + "sha256": "6b001defb5765cec53421e777e3162012290d013052f8dbc8a99e7d648a9167b", + "size": 21985, + "subdir": "linux-64", + "timestamp": 1530734649304, + "version": "0.8.1" + }, + "terminado-0.8.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=2.7,<2.8.0a0", + "tornado >=4" + ], + "license": "BSD 2-Clause", + "md5": "0198b2ee354af891c22fd9106d298ea5", + "name": "terminado", + "sha256": "65970695dd6d31bc53bfaa626ef304ad29b8ed86f5109b9739728976e70219db", + "size": 23175, + "subdir": "linux-64", + "timestamp": 1555428155267, + "version": "0.8.2" + }, + "terminado-0.8.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "BSD 2-Clause", + "md5": "a9f0b91434888a23793d39ea328af05a", + "name": "terminado", + "sha256": "9e2291d24da2af5738ea91682d54ad09e415a98e45d96879e3e2f18d3000fcc9", + "size": 23521, + "subdir": "linux-64", + "timestamp": 1555428183030, + "version": "0.8.2" + }, + "terminado-0.8.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.7,<3.8.0a0", + "tornado >=4" + ], + "license": "BSD 2-Clause", + "md5": "4cc4a4843309d53407dc848905565645", + "name": "terminado", + "sha256": "cc976e73e0317976d9b890141b7d4b62f5d91fd488c3101b3618f00a8c9f8da6", + "size": 23575, + "subdir": "linux-64", + "timestamp": 1555428264819, + "version": "0.8.2" + }, + "terminado-0.8.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.8,<3.9.0a0", + "tornado >=4" + ], + "license": "BSD 2-Clause", + "md5": "51cb0a8c5b3b917459b56e824269ffad", + "name": "terminado", + "sha256": "f90ffe28d6ad2b1540c0a5c9b9dcc58f2860595c2b330aa08c2c6ea5e1f09886", + "size": 22673, + "subdir": "linux-64", + "timestamp": 1573554737636, + "version": "0.8.2" + }, + "terminado-0.8.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=2.7,<2.8.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "6be90d6784b5997158ee86437a91dbd7", + "name": "terminado", + "sha256": "fbb1734ad17d7fccc53122c0a91a24ff8e814f6bc31888c7c5fbde472a17e1f7", + "size": 25827, + "subdir": "linux-64", + "timestamp": 1574271887106, + "version": "0.8.3" + }, + "terminado-0.8.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "fb84b76e6da0aa7bbd60e1199835441c", + "name": "terminado", + "sha256": "00c49b237b0922c5da171c0e782bf253cfc53e77e4a34afc4d9a875ce4b272d6", + "size": 26148, + "subdir": "linux-64", + "timestamp": 1574272380240, + "version": "0.8.3" + }, + "terminado-0.8.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.7,<3.8.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "233a32c13a1d6477790f7a7266f3cbca", + "name": "terminado", + "sha256": "d21f99af435fbf8f38fda3a00da05721c9e340e32d78ae4886a73410bd9dbe29", + "size": 26197, + "subdir": "linux-64", + "timestamp": 1574271823151, + "version": "0.8.3" + }, + "terminado-0.8.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.8,<3.9.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "a41d30b6b1e84cd9d420f55f27adf4f6", + "name": "terminado", + "sha256": "e40d17857802e110abd2d842ea366c0e591b123b6399630731a184ba6bf9f348", + "size": 26250, + "subdir": "linux-64", + "timestamp": 1574271879193, + "version": "0.8.3" + }, + "terminado-0.9.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "00368391a3577ea6bb80fa6c466da02e", + "name": "terminado", + "sha256": "536ba877acc27125f5e20a7ba9151a14b143f9935547dc07915a6836813e5b29", + "size": 27550, + "subdir": "linux-64", + "timestamp": 1602280986405, + "version": "0.9.1" + }, + "terminado-0.9.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.7,<3.8.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "147aac51e6a6356a42b8467be4c8c5fe", + "name": "terminado", + "sha256": "a646746b1367e89a5e23267a243572189c678a2dc02eee10d1746170849dec0f", + "size": 27596, + "subdir": "linux-64", + "timestamp": 1602280973679, + "version": "0.9.1" + }, + "terminado-0.9.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.8,<3.9.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "ec1c50da5ea690637c1b790ed6657f05", + "name": "terminado", + "sha256": "9fc16ed6140e64cde62d26f029ddfbcabc1f2c37748a84b0f5212176ee2e9514", + "size": 27655, + "subdir": "linux-64", + "timestamp": 1602280984668, + "version": "0.9.1" + }, + "terminado-0.9.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.9,<3.10.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "b7c9074816602aa76685b57bd80a90c7", + "name": "terminado", + "sha256": "938758d370981b4fd4e1df4a687368e9bfe6e5f2184aeb67f25f679cd27d9261", + "size": 27751, + "subdir": "linux-64", + "timestamp": 1607372838106, + "version": "0.9.1" + }, + "terminado-0.9.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "51ee35ce9538a9756bc2cf07424e1ead", + "name": "terminado", + "sha256": "d89038fe7ce100a3c6c2a1d60c2e4a9b2eeef885400a0897322a1004f4d3a037", + "size": 25604, + "subdir": "linux-64", + "timestamp": 1609860806824, + "version": "0.9.2" + }, + "terminado-0.9.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.7,<3.8.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "185310c24ce37d9f75f8fe4bd6cc3083", + "name": "terminado", + "sha256": "35792efd42458b38f04d6af2c073794d81ab24c04219f2712026943d95bb7c08", + "size": 25849, + "subdir": "linux-64", + "timestamp": 1609788082709, + "version": "0.9.2" + }, + "terminado-0.9.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.8,<3.9.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "8ffc4feb7db41e7c88abfef706c15d9a", + "name": "terminado", + "sha256": "804feda56435ae0b5cd25222b92f3e1f992cd98b2966ed4af9505f27ae4c6345", + "size": 25822, + "subdir": "linux-64", + "timestamp": 1609788098543, + "version": "0.9.2" + }, + "terminado-0.9.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.9,<3.10.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "e6309aa8f2fa11b2a64599597fe71ed3", + "name": "terminado", + "sha256": "389cc1a63e984054010f88c96b7ffb65e8d8c4c9de383c76430d682ddd0ab379", + "size": 25721, + "subdir": "linux-64", + "timestamp": 1609787984443, + "version": "0.9.2" + }, + "terminado-0.9.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "72ed7bdb1848a582954ce5fc6db47675", + "name": "terminado", + "sha256": "bd53e59c60cbce7053e64cc3f4e81209d3f8b6e47fc1d8db7322e94aa2d07578", + "size": 25913, + "subdir": "linux-64", + "timestamp": 1615837005383, + "version": "0.9.3" + }, + "terminado-0.9.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.7,<3.8.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "6db1b2c235de7f0f676df76becffd247", + "name": "terminado", + "sha256": "7b53986d74510528cd2aba26c497b31e6d0c4218ec4682c5ad55270522f196e4", + "size": 25827, + "subdir": "linux-64", + "timestamp": 1615837000103, + "version": "0.9.3" + }, + "terminado-0.9.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.8,<3.9.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "8836721a5e02ea0d4601eeecd67b8f4b", + "name": "terminado", + "sha256": "23b9359bc268f8978dbeb54b4a8ec4340ba770a62fe79f0aa3c23838ff91e3bb", + "size": 25884, + "subdir": "linux-64", + "timestamp": 1615837013538, + "version": "0.9.3" + }, + "terminado-0.9.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.9,<3.10.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "fb93afbc02dd2e305a072377cd0d95e1", + "name": "terminado", + "sha256": "aaaee31f359c389e39ccb307bd3db84fb7899a96abfb47209c033bdbe41db8de", + "size": 25948, + "subdir": "linux-64", + "timestamp": 1615836542460, + "version": "0.9.3" + }, + "terminado-0.9.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.10,<3.11.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "c7fe9c261868a733d2a7830abb180fba", + "name": "terminado", + "sha256": "047029859dead0ad18b6b45f41dd6a93aa321bc864e74695eebe1640063d10c7", + "size": 26281, + "subdir": "linux-64", + "timestamp": 1640811103854, + "version": "0.9.4" + }, + "terminado-0.9.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.6,<3.7.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "37914e9bcae57d1eba751c870ebca489", + "name": "terminado", + "sha256": "332c263b6da8efe600925185b31acc86448ac17a33b833a61cdbc15b2b1439af", + "size": 26068, + "subdir": "linux-64", + "timestamp": 1617136687771, + "version": "0.9.4" + }, + "terminado-0.9.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.7,<3.8.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "c0a2e4a3e581969bc81d599bacb55b5c", + "name": "terminado", + "sha256": "a9aa6431082e67a5e4371e365e6a26b2f601be6f88b849a34010d1569810d3b5", + "size": 25999, + "subdir": "linux-64", + "timestamp": 1617136693500, + "version": "0.9.4" + }, + "terminado-0.9.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.8,<3.9.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "b3cd142104de2795c9bbb34cbc308eb2", + "name": "terminado", + "sha256": "c10653e827f2d77d5c1d3205cc760a3daa92c5cc793ad96f46bf6014dc559741", + "size": 26054, + "subdir": "linux-64", + "timestamp": 1617136557217, + "version": "0.9.4" + }, + "terminado-0.9.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "ptyprocess", + "python >=3.9,<3.10.0a0", + "tornado >=4" + ], + "license": "BSD-2-Clause", + "md5": "13f9455337d11b92ad271f84f31e879b", + "name": "terminado", + "sha256": "42112b232b7ca91fb66d614c44a4f06eddf0cd066a7420928e827499e360ad02", + "size": 26073, + "subdir": "linux-64", + "timestamp": 1617136694558, + "version": "0.9.4" + }, + "tesseract-5.2.0-h6a678d5_0.conda": { + "build": "h6a678d5_0", + "build_number": 0, + "depends": [ + "_openmp_mutex", + "leptonica >=1.82.0,<1.83.0a0", + "libarchive >=3.6.1,<3.7.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a669fa46837d01311afb9e3c0f4590d5", + "name": "tesseract", + "sha256": "64770cc50615708027afbef06c7ecf9123dd22a02c01534e1f4f3e94cf8d9042", + "size": 176766281, + "subdir": "linux-64", + "timestamp": 1666182213677, + "version": "5.2.0" + }, + "testfixtures-5.2.0-py27h1c44549_0.conda": { + "build": "py27h1c44549_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "39ebece063e7281467b7d33a1cfac0e4", + "name": "testfixtures", + "sha256": "f8f6b465c04747fe1287da9c5b1bc393e23f5563c5862b630d7d3130b876c19e", + "size": 119220, + "subdir": "linux-64", + "timestamp": 1508794291745, + "version": "5.2.0" + }, + "testfixtures-5.2.0-py35h3f4e679_0.conda": { + "build": "py35h3f4e679_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "80efa1db1cbf14aae7a500aba5b7e712", + "name": "testfixtures", + "sha256": "205a2aa32c7dfd8e8b6d2cb7027de958c6ec33a1cbea5fffaf7904d7dfce1937", + "size": 123710, + "subdir": "linux-64", + "timestamp": 1508794289332, + "version": "5.2.0" + }, + "testfixtures-5.2.0-py36hfeca728_0.conda": { + "build": "py36hfeca728_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "37f1d3044448f50cc9e9f61603d3c005", + "name": "testfixtures", + "sha256": "e9b2a4c18192e23e628b071d555c45e62ae3e05a01a6c6faab465f458bd43b4c", + "size": 122329, + "subdir": "linux-64", + "timestamp": 1508794319086, + "version": "5.2.0" + }, + "testfixtures-5.3.1-py27he9e6c30_0.conda": { + "build": "py27he9e6c30_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "dfd1719d824dcbbe3e797953c89f6aff", + "name": "testfixtures", + "sha256": "775a64a5074b9482dc0f37e4a777542513f7798465513bbf022db20f13dca237", + "size": 121100, + "subdir": "linux-64", + "timestamp": 1511316986734, + "version": "5.3.1" + }, + "testfixtures-5.3.1-py35hd2928f4_0.conda": { + "build": "py35hd2928f4_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "66215a602c7ab950b8d3ca70bc831641", + "name": "testfixtures", + "sha256": "82cda6fd5687d4d6c1f6742641ab32d7a01c7a9ffa049658fdcf469e4100db73", + "size": 126896, + "subdir": "linux-64", + "timestamp": 1511316994004, + "version": "5.3.1" + }, + "testfixtures-5.3.1-py36ha2b07aa_0.conda": { + "build": "py36ha2b07aa_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "baeb453abb56d3f4dc842e44f5304c8a", + "name": "testfixtures", + "sha256": "e1272975fad937f9dc797551f8ad2871f2dc0ca2e172571261913d0a35478042", + "size": 125504, + "subdir": "linux-64", + "timestamp": 1511316994428, + "version": "5.3.1" + }, + "testfixtures-5.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "32c58c0861bfb2a4f98cad04b0955de3", + "name": "testfixtures", + "sha256": "571e3fbfcfa0613779d1dcac26b51f3ea2e11a42c5c28cddb179fa887789bb45", + "size": 124155, + "subdir": "linux-64", + "timestamp": 1519241849188, + "version": "5.4.0" + }, + "testfixtures-5.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "0bbedb99e4fff2b61e4e7383101fbded", + "name": "testfixtures", + "sha256": "f606eaf82c8e4dedb1c283e1dcc7f283549fdbf0255ddc8622c2c69a8702ee6c", + "size": 127517, + "subdir": "linux-64", + "timestamp": 1519241957400, + "version": "5.4.0" + }, + "testfixtures-5.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f339cc8bbed98dc6b5f60171f1b230f3", + "name": "testfixtures", + "sha256": "ff9b72940a56f5e486b9d08c48a824d00f1c855895c01c71a8f0aac601d94c4d", + "size": 127271, + "subdir": "linux-64", + "timestamp": 1519241794416, + "version": "5.4.0" + }, + "testfixtures-6.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "42a9e0ebf74e45b07b05b4d5e5c021b3", + "name": "testfixtures", + "sha256": "fc659f6e4ba7516f5377d5be96e7f88c34452c0bdeceec9ee1d2b7cb6cad9763", + "size": 130764, + "subdir": "linux-64", + "timestamp": 1522786799253, + "version": "6.0.0" + }, + "testfixtures-6.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "a6109b0326e1f0b9c29c973a0743f860", + "name": "testfixtures", + "sha256": "7366470f1396d4ba68d7bb556207e6f00466a894c613154d92e3497c310a6630", + "size": 134133, + "subdir": "linux-64", + "timestamp": 1522786837058, + "version": "6.0.0" + }, + "testfixtures-6.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "4842a651e8e1dc547330bd8728e5571d", + "name": "testfixtures", + "sha256": "3190d64967a5e2eb3ba0e8f056e636cc23e47be63d365d0fa3cf405b2f41a908", + "size": 133873, + "subdir": "linux-64", + "timestamp": 1522786844618, + "version": "6.0.0" + }, + "testfixtures-6.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "8219657bbd7c742eb6aaf1f77ed521da", + "name": "testfixtures", + "sha256": "b03166cec5a6a1a7e3c2ecba8c13813de85083f57b7cda4452868b1587587e8b", + "size": 129310, + "subdir": "linux-64", + "timestamp": 1524514936340, + "version": "6.0.1" + }, + "testfixtures-6.0.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "7c12d3c6ecaa7b91d194663f9efdb94a", + "name": "testfixtures", + "sha256": "e68305ca19ab519e9c4036b3b6806472c35d37f8d376cc139b17856281d31f05", + "size": 134196, + "subdir": "linux-64", + "timestamp": 1524514908860, + "version": "6.0.1" + }, + "testfixtures-6.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f6d0a995bf1dc8c3d11b30b0714b811b", + "name": "testfixtures", + "sha256": "66edc3eca25e8215c7bd502d7bf1cb178db3dece0f2c8b3371b3286556b000ca", + "size": 132794, + "subdir": "linux-64", + "timestamp": 1524514833938, + "version": "6.0.1" + }, + "testfixtures-6.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "367badeeed641a2067b6b95ca9c80ac9", + "name": "testfixtures", + "sha256": "521e0213a06cc01810f497312f88de97f80d446c410a6eb28b1378c66b53892d", + "size": 131302, + "subdir": "linux-64", + "timestamp": 1526939537555, + "version": "6.0.2" + }, + "testfixtures-6.0.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "e91e39b04bb0bb8583e859867ebf39f2", + "name": "testfixtures", + "sha256": "8c56d2e6eca80aa54f69cff58cdd803536f9f32972c0cd0d5a3a15b501b1c9cd", + "size": 137918, + "subdir": "linux-64", + "timestamp": 1526939570777, + "version": "6.0.2" + }, + "testfixtures-6.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "40ba4f55e16fc8dbac0703a392fe7738", + "name": "testfixtures", + "sha256": "411c20509d3e5a5155560bfdfd0ced48186045a48a64888066a432e8f2667a64", + "size": 135252, + "subdir": "linux-64", + "timestamp": 1526939523402, + "version": "6.0.2" + }, + "testfixtures-6.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "edee4008f974a3ab64da825e38f6249e", + "name": "testfixtures", + "sha256": "931b816abee1c8e1d13bcab6483169b44cb9e09cfefa47de1fa545102892457e", + "size": 131974, + "subdir": "linux-64", + "timestamp": 1529438301251, + "version": "6.1.0" + }, + "testfixtures-6.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "3c7586d89a0dae7c8237f024f7deb32c", + "name": "testfixtures", + "sha256": "02096e869863fed888ac7960c7318cd90ab71202c157bf203f3157ad39f63ee0", + "size": 138376, + "subdir": "linux-64", + "timestamp": 1529438350772, + "version": "6.1.0" + }, + "testfixtures-6.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2b855c0dde3ee16b5c88e05bf159cd32", + "name": "testfixtures", + "sha256": "d0ee2242caaa6ac111dacbc9060d428217bbe4ff1b747ff2ba05dcd4325faccd", + "size": 136862, + "subdir": "linux-64", + "timestamp": 1529438231446, + "version": "6.1.0" + }, + "testfixtures-6.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "c80a77086de32142798b1724eca1290b", + "name": "testfixtures", + "sha256": "6f980cbb9f2c493c2e664d44a1b29c50691c21768b882178f87538b92d459203", + "size": 132321, + "subdir": "linux-64", + "timestamp": 1529956285902, + "version": "6.2.0" + }, + "testfixtures-6.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "faef0a922d7f3168329daf184916ba27", + "name": "testfixtures", + "sha256": "061a978e39184cac8663d2d6480a15a01c261140e0b8df6a56a4378ad8e7e9e8", + "size": 137083, + "subdir": "linux-64", + "timestamp": 1529956305155, + "version": "6.2.0" + }, + "testfixtures-6.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1516ebd1af645b94c1201bad59aa27a6", + "name": "testfixtures", + "sha256": "b3ae30e2b2abe72514c862ca0ff444a4eb38b75acdc98036def0009d7312188c", + "size": 137191, + "subdir": "linux-64", + "timestamp": 1529956271166, + "version": "6.2.0" + }, + "testfixtures-6.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "00c8f4a72244a78975d65245610d1fd7", + "name": "testfixtures", + "sha256": "4a9931db5a13c24f67d3aafe1616755c550ccca45d51105af53853eb40278f36", + "size": 136746, + "subdir": "linux-64", + "timestamp": 1530887663025, + "version": "6.2.0" + }, + "testfixtures-6.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "2d7f5ef323780b9366a863923cf2650d", + "name": "testfixtures", + "sha256": "c120d5f1a88e861810bb3e60b2d91ad42519503af364ae6e63304889f0fafb7b", + "size": 133559, + "subdir": "linux-64", + "timestamp": 1536263053325, + "version": "6.3.0" + }, + "testfixtures-6.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "027b1b01cbe2e1ec0c53f861a6e3dc19", + "name": "testfixtures", + "sha256": "af864a24ce6d2da0a47840a8b41bbf7aa24745c6038c772cb266f67b611883a7", + "size": 140380, + "subdir": "linux-64", + "timestamp": 1536263056493, + "version": "6.3.0" + }, + "testfixtures-6.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "a47bab10b49a5746669d413307e2997f", + "name": "testfixtures", + "sha256": "efe42c70710f2f96ca93f81ebde61c3479de0a36226745eddeb889123fa726e4", + "size": 137030, + "subdir": "linux-64", + "timestamp": 1536263007293, + "version": "6.3.0" + }, + "testfixtures-6.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "84a87d1c3c821ba36148bc1f79b1136a", + "name": "testfixtures", + "sha256": "3657046ad5837bdd531ec045a57e6eb8082c491ba08c82f5ab053684f3b5a6ef", + "size": 138348, + "subdir": "linux-64", + "timestamp": 1536263076384, + "version": "6.3.0" + }, + "testfixtures-6.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "32635d3cf50754811ff39d036ac3d37a", + "name": "testfixtures", + "sha256": "270a3608df609cc1cdea47d33d516be982d42be92231d2cebecc44354cb39f2c", + "size": 146074, + "subdir": "linux-64", + "timestamp": 1550363897404, + "version": "6.5.0" + }, + "testfixtures-6.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "1f89dd9175b8d5193ffd121f3473e1ac", + "name": "testfixtures", + "sha256": "0548e2be37bc93b8b896f19db46b0f0880a30569fbb1e93039da8dd370200d4a", + "size": 149910, + "subdir": "linux-64", + "timestamp": 1550363909598, + "version": "6.5.0" + }, + "testfixtures-6.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "e74f7b19a434d1346366e503afa16aa5", + "name": "testfixtures", + "sha256": "43f8a4b932e7ade4c9da8b7c07233ff6c247b463a40e4c2654260b1f0a05c7de", + "size": 149224, + "subdir": "linux-64", + "timestamp": 1550363859462, + "version": "6.5.0" + }, + "testpath-0.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pathlib2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bfb16281966f0036b73f64be44a0f77e", + "name": "testpath", + "sha256": "0a08ea64e89f3e5044beccf4fe44f75abb7dea343ef4307448013af0c4c96de4", + "size": 85916, + "subdir": "linux-64", + "timestamp": 1530734261652, + "version": "0.3.1" + }, + "testpath-0.3.1-py27hc38d2c4_0.conda": { + "build": "py27hc38d2c4_0", + "build_number": 0, + "depends": [ + "pathlib2", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5b2e84cb20ce16ee93aa0d9c22235c9", + "name": "testpath", + "sha256": "0557720e6761100a68e4fb0a39619a0f524706b07e158b1157d61ca4b3551258", + "size": 85256, + "subdir": "linux-64", + "timestamp": 1505688601741, + "version": "0.3.1" + }, + "testpath-0.3.1-py35had42eaf_0.conda": { + "build": "py35had42eaf_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a8fe4ed051a5cc7f1eecec663ac7f1a4", + "name": "testpath", + "sha256": "0dca3fefe023c3de0def29b175a93703e95df0369a71164976ba63a2403d15c0", + "size": 85473, + "subdir": "linux-64", + "timestamp": 1505688614112, + "version": "0.3.1" + }, + "testpath-0.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ea297fa72c28a6683d820103dcf3a06", + "name": "testpath", + "sha256": "db25e4b967d22ab536b432d3dc7d6976d49b47c54e61c2db5426dcf75ce89ef0", + "size": 85781, + "subdir": "linux-64", + "timestamp": 1530734241602, + "version": "0.3.1" + }, + "testpath-0.3.1-py36h8cadb63_0.conda": { + "build": "py36h8cadb63_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc0f34ae4afb075e29f496a053531097", + "name": "testpath", + "sha256": "d1c1606529d7e473b3f919f0ba5ad335fce97ceebdf131dd0a25126b4dbac8c1", + "size": 85327, + "subdir": "linux-64", + "timestamp": 1505688626461, + "version": "0.3.1" + }, + "testpath-0.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e7a7f7b559bfef516482ac44d5d24e4c", + "name": "testpath", + "sha256": "b02e38dc80f550865e9a4951b75dddf52b08ba49746e428d21b1fc15607f31e3", + "size": 86094, + "subdir": "linux-64", + "timestamp": 1530734282583, + "version": "0.3.1" + }, + "testpath-0.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "42ea1f311924acc63181a67d392f2ad0", + "name": "testpath", + "sha256": "7599f96300f7e44b46a08f366910f2cb82c8b61c8fa072a1edaa892b517e3394", + "size": 87307, + "subdir": "linux-64", + "timestamp": 1538667007532, + "version": "0.4.1" + }, + "testpath-0.4.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b90c7c0aca0fff65df15bc5fe16b45a", + "name": "testpath", + "sha256": "e366c3a1282cf7ba4ad43b03330714f1abb003d6341c6fa82032cc24c84569ae", + "size": 87722, + "subdir": "linux-64", + "timestamp": 1538862876705, + "version": "0.4.1" + }, + "testpath-0.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2432c4e49e552c93de89a7a063a0b476", + "name": "testpath", + "sha256": "59199cb9341e2ec82dba5140aa2af4e6fe1c192a07b9065437df78a2df15490a", + "size": 87572, + "subdir": "linux-64", + "timestamp": 1538666481254, + "version": "0.4.1" + }, + "testpath-0.4.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4c877474cb2828df1aaadeb099b5c8ee", + "name": "testpath", + "sha256": "85fc1f8231f29f3d959489d6dc668affb354c424bdde1d7ba54dd1eb73954f7b", + "size": 87417, + "subdir": "linux-64", + "timestamp": 1538862864343, + "version": "0.4.1" + }, + "testpath-0.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3f9d30f8ed8b9acb1de4dfc51221e687", + "name": "testpath", + "sha256": "eca88d692427f2a55b030ceb99bf24624fc18149aef66d9b3b720f7f1578595c", + "size": 87752, + "subdir": "linux-64", + "timestamp": 1538864340541, + "version": "0.4.2" + }, + "testpath-0.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1411bd35a9f1c210144002035e58e7e5", + "name": "testpath", + "sha256": "4052e5a86bd34649d55648d773a3186a9b293c114bca3442c2781f04b4899688", + "size": 87795, + "subdir": "linux-64", + "timestamp": 1538864345999, + "version": "0.4.2" + }, + "testpath-0.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "138d9c60118889d16c15c866e4d0197d", + "name": "testpath", + "sha256": "59689646254de3cd413eccf47e1bcfb560bb07fad42ed88bdacc9e22e5bd5e85", + "size": 87938, + "subdir": "linux-64", + "timestamp": 1538864319863, + "version": "0.4.2" + }, + "testpath-0.6.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ee4552cb46e307453756367508b2230f", + "name": "testpath", + "sha256": "8ed872136576862d2af43ba94ad1a9068358ed9895a8915888502a05cdced3b3", + "size": 86935, + "subdir": "linux-64", + "timestamp": 1655908680174, + "version": "0.6.0" + }, + "testpath-0.6.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5799faaf12ea8ab02b17ef5f8a828747", + "name": "testpath", + "sha256": "dd13056f0cb5eedb2dfa889c2ed2eb5934cca5586cc006855668bb16a3714677", + "size": 89528, + "subdir": "linux-64", + "timestamp": 1676862947873, + "version": "0.6.0" + }, + "testpath-0.6.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fa701e56697f3264a7a8fbacff046a81", + "name": "testpath", + "sha256": "d9107cf6949962af433e930d071177f9a166a1ef01a0f6af2ee72cbaa9357451", + "size": 86770, + "subdir": "linux-64", + "timestamp": 1655908725295, + "version": "0.6.0" + }, + "testpath-0.6.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c303ac1424ca98f26f45ae1f240a91bb", + "name": "testpath", + "sha256": "515c748008ba67c0996e4487349345006b6a36e7777996ff3eaf35260b3877a3", + "size": 86793, + "subdir": "linux-64", + "timestamp": 1655908769769, + "version": "0.6.0" + }, + "testpath-0.6.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7502f9a141b4e5eefc788a8fb46f03d0", + "name": "testpath", + "sha256": "35b83203fae9486317492244a5ee1d3b55d9ac945dd89398209ca4bc97f8be49", + "size": 86821, + "subdir": "linux-64", + "timestamp": 1655908613837, + "version": "0.6.0" + }, + "testscenarios-0.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "4ce1055a636662bc8c3bd7b16cba6ec2", + "name": "testscenarios", + "sha256": "0c7b62a0b5a258e02443162a065444e71eaefd14800c04e5e18093d927249d43", + "size": 26637, + "subdir": "linux-64", + "timestamp": 1530898625947, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "ba8e1eef1fdf6bd9912ff999aba39182", + "name": "testscenarios", + "sha256": "1e24b9223fab7258e15601c3629f95ab9d4321ec9c58317e94de2b045d21df68", + "size": 27523, + "subdir": "linux-64", + "timestamp": 1640795180168, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "35dee8ab1aad3c64486127ce634daae5", + "name": "testscenarios", + "sha256": "6910b084279056d7e4dfe48fd85d1f4c99bc1a135f53516545a4de88af16e7c7", + "size": 31861, + "subdir": "linux-64", + "timestamp": 1676907739765, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "1cdad93def799141d42c615bd19b5bcd", + "name": "testscenarios", + "sha256": "60ff4fd63cf51fe9cfbd096785ced0b14edbc935c949ce77871f8a879c5b3a36", + "size": 27436, + "subdir": "linux-64", + "timestamp": 1535522079415, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "18eb769ba5ef05baac5933d5820b2029", + "name": "testscenarios", + "sha256": "93a017af4046d2e0e7e38d37f6800df06f932bed3e3d17728283c0e196647d55", + "size": 27090, + "subdir": "linux-64", + "timestamp": 1530898671694, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "be34dbc6efb3d310283840ae915d7b75", + "name": "testscenarios", + "sha256": "573d6ac3e6a2d6c0a785e9e5e360c4a9740fd6c8bf6a8a754d919982d3977e08", + "size": 269173, + "subdir": "linux-64", + "timestamp": 1613996721439, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "ae400f6b39989177539e93bb74ccbee2", + "name": "testscenarios", + "sha256": "b6a22e94674d340a9d541192dd9948b9ce86783aba55c76da94f668b0fd1d51b", + "size": 27351, + "subdir": "linux-64", + "timestamp": 1530898648300, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "1059d6e7121cd22af23d46564b8bb157", + "name": "testscenarios", + "sha256": "f40b1c7f80d8273e158ef438707a69d85fb955b15ef8d70b8f3c87798c539494", + "size": 269238, + "subdir": "linux-64", + "timestamp": 1613996715651, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "b48969e13e47b7767ab2212d7d9da323", + "name": "testscenarios", + "sha256": "425ef829a8e333cd034a216d88914ce56245b99b599cb3f5887d56cdc959807e", + "size": 27850, + "subdir": "linux-64", + "timestamp": 1573728873236, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "03d361b33fc6e795036f24b8cf9d9bf9", + "name": "testscenarios", + "sha256": "a56ebf6e1f7de485fc2f707ccb2ea83fb0f890f845f5a74528de6d4a8ceed790", + "size": 268776, + "subdir": "linux-64", + "timestamp": 1613996720927, + "version": "0.5.0" + }, + "testscenarios-0.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache Software License or BSD", + "license_family": "BSD", + "md5": "46fe356a568a7cab0fd375e175d0451b", + "name": "testscenarios", + "sha256": "43fb4d1b2c0c0803903bdc07a4e19e2173fcb626a3bfa7de6bb9474d09004640", + "size": 269155, + "subdir": "linux-64", + "timestamp": 1613995988286, + "version": "0.5.0" + }, + "testtools-2.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af908faa90558ad616ddf9a7196263a4", + "name": "testtools", + "sha256": "d8192f2fc9c5b30fb05d91f01a8108f75e9e1b7ef80ee1da44f3db15b65a70d0", + "size": 279812, + "subdir": "linux-64", + "timestamp": 1530898697002, + "version": "2.3.0" + }, + "testtools-2.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "07db22125892f3c950c404adb26878a7", + "name": "testtools", + "sha256": "398b4c5c9f5f73b08f5ebb593dc3cc6e58545c2e778001851b6c4702fe3ba0dc", + "size": 299118, + "subdir": "linux-64", + "timestamp": 1640795198553, + "version": "2.3.0" + }, + "testtools-2.3.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "42d0cdc914d57e0ba25dbaa00d78f663", + "name": "testtools", + "sha256": "3e0acc1c75263312c936b0dcf27326ad6afa1eaa7f6bd000da2a728540653774", + "size": 396584, + "subdir": "linux-64", + "timestamp": 1676862964175, + "version": "2.3.0" + }, + "testtools-2.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ea8cf8c78a80be47f671b0c37a3e32ca", + "name": "testtools", + "sha256": "60d3e3c0dc50eb3e431a5c310b13c67dab68445f57f00538d228b02e4053e295", + "size": 292209, + "subdir": "linux-64", + "timestamp": 1535488562446, + "version": "2.3.0" + }, + "testtools-2.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bddf3c3f2eef039f610cdbbebca46e90", + "name": "testtools", + "sha256": "a8b90779d39444694b0c5bbd739ca72fd88539a2109ed00cccc93b883412f943", + "size": 290249, + "subdir": "linux-64", + "timestamp": 1530898764503, + "version": "2.3.0" + }, + "testtools-2.3.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "767659ebf1ebb9c9f132938cec10732f", + "name": "testtools", + "sha256": "58e8c8716a1da73392fde79723553f1fdd5fcd6b0696a81dc12856cceb23c170", + "size": 286773, + "subdir": "linux-64", + "timestamp": 1613502820982, + "version": "2.3.0" + }, + "testtools-2.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e7b529435ef279107efb1475b04b5996", + "name": "testtools", + "sha256": "09906cfbd8ed579f7ceeced206ff97dbd9fcf7f8b7832b97ec40bbe87f01f960", + "size": 290463, + "subdir": "linux-64", + "timestamp": 1530898730348, + "version": "2.3.0" + }, + "testtools-2.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba9a6d31a47cddf88dc9d0103032faad", + "name": "testtools", + "sha256": "07324520c4a8c77895de99d72d7a29132711c0796a8e60a53997ead841a0b070", + "size": 291686, + "subdir": "linux-64", + "timestamp": 1613502517570, + "version": "2.3.0" + }, + "testtools-2.3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2a96d4eb181c552e6d90d41162a5696", + "name": "testtools", + "sha256": "c8127079c018df07d86403e352808fc0fa211e9212c90d64f128ef218fa49a24", + "size": 294854, + "subdir": "linux-64", + "timestamp": 1574183797369, + "version": "2.3.0" + }, + "testtools-2.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc5ce17cf9828357a38c31a1ac09f408", + "name": "testtools", + "sha256": "2dc8b345475caa85697b599d3d28a982a9de5d7d6223fe279ab619639726f213", + "size": 291109, + "subdir": "linux-64", + "timestamp": 1613502828200, + "version": "2.3.0" + }, + "testtools-2.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b21f7621451d01411d790b156fad2949", + "name": "testtools", + "sha256": "98d12ad9fb089458d46e63ffe25bab789e8e1d8dfc33ad5c14e0660b4cab184e", + "size": 295559, + "subdir": "linux-64", + "timestamp": 1613502193740, + "version": "2.3.0" + }, + "testtools-2.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "72498110f31e4d248e9b770c28367dfe", + "name": "testtools", + "sha256": "0c4aaa12e723d6ae62303232fae1c1fd0b9df334bc1d0922fc6ae3c0a33b5030", + "size": 290227, + "subdir": "linux-64", + "timestamp": 1600554948346, + "version": "2.4.0" + }, + "testtools-2.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18344aa853ffe2fdf6e6799357675800", + "name": "testtools", + "sha256": "cda2beb5ef7aa264efcdaaf7f109afb2e5333487c46332545ec4a40a70543441", + "size": 286044, + "subdir": "linux-64", + "timestamp": 1600554962273, + "version": "2.4.0" + }, + "testtools-2.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "pbr >=0.11", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "abd1209ae7904f18030eeeae20dab614", + "name": "testtools", + "sha256": "35727dc5cc5938fe28fc982c277431e9a463a60aa0c2c90e8b2c29391248622e", + "size": 294554, + "subdir": "linux-64", + "timestamp": 1600554942549, + "version": "2.4.0" + }, + "texinfo-6.5-pl526h14c3975_0.conda": { + "build": "pl526h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "ncurses >=6.1,<7.0a0", + "perl" + ], + "license": "GPL-2.0 and GPL-3.0", + "md5": "294073c05a38a7e46c444a21245b27de", + "name": "texinfo", + "sha256": "d669f7ce73ca578c80c1dd80a90b40a4cf2940eded83563ac1a1f7354ff5eda0", + "size": 1239595, + "subdir": "linux-64", + "timestamp": 1527352014885, + "version": "6.5" + }, + "texinfo-6.7-pl5262h7f8727e_0.conda": { + "build": "pl5262h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "perl" + ], + "license": "GPL-2.0 and GPL-3.0", + "license_family": "GPL", + "md5": "b1aea40a48d648cce1cbbc49f3f3dbd3", + "name": "texinfo", + "sha256": "fd9da9588167cf8adacc2c1a64d1491212fc19951db81f159b4cc4e6f619f0a4", + "size": 1282496, + "subdir": "linux-64", + "timestamp": 1624617959398, + "version": "6.7" + }, + "texinfo-6.8-pl5262h7f8727e_0.conda": { + "build": "pl5262h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "ncurses >=6.2,<7.0a0", + "perl" + ], + "license": "GPL-2.0 and GPL-3.0", + "license_family": "GPL", + "md5": "236b81669ed430f8dce5bfebe2cf5a33", + "name": "texinfo", + "sha256": "f8539f38f18b7b57dff18d3d415a4d2336d83c7611fe4da372e027fd48ebffba", + "size": 1326144, + "subdir": "linux-64", + "timestamp": 1625642898021, + "version": "6.8" + }, + "texlive-core-20170520-pl526hcfff585_3.conda": { + "build": "pl526hcfff585_3", + "build_number": 3, + "depends": [ + "cairo 1.14.*", + "cairo >=1.14.10,<2.0a0", + "freetype >=2.8,<2.9.0a0", + "gmp 6.1.*", + "graphite2", + "harfbuzz", + "harfbuzz >=1.5.0,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.32,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "mpfr 3.1.*", + "perl", + "pixman 0.34.*", + "pixman >=0.34.0,<1.0a0", + "poppler", + "poppler >=0.60.1,<1.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0+ and GPL-2.0 and GPL-3.0 and LPPL-1.3c and LPPL-1.0 and Artistic-1.0 and Apache-2.0 and MIT and BSD-3-Clause", + "md5": "2ac82c22cec645385ce476807f7bf916", + "name": "texlive-core", + "namespace": "global", + "sha256": "ef5952fe03592e551f8fc63186ace70fdbcddf18055eb9cfa71c1ade4fe0fea8", + "size": 6327219, + "subdir": "linux-64", + "timestamp": 1507908420398, + "version": "20170520" + }, + "texlive-core-20180414-hc8d0b01_0.conda": { + "build": "hc8d0b01_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "fontconfig >=2.13.0,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "gmp >=6.1.2", + "graphite2 >=1.3.11,<2.0a0", + "harfbuzz >=1.7.6,<2.0a0", + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "mpfr >=4.0.1,<5.0a0", + "pixman >=0.34.0,<1.0a0", + "poppler >=0.65.0,<1.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL-2.0+ and GPL-2.0 and GPL-3.0 and LPPL-1.3c and LPPL-1.0 and Artistic-1.0 and Apache-2.0 and MIT and BSD-3-Clause", + "md5": "a02d57241432c16fed20bb8046e46c5f", + "name": "texlive-core", + "namespace": "global", + "sha256": "7dd76b0467c68654097f86a403983e220719d80487c1fa2764206c4fd137e20a", + "size": 7369619, + "subdir": "linux-64", + "timestamp": 1528110001740, + "version": "20180414" + }, + "text-unidecode-1.0-py36he5a4ee8_0.conda": { + "build": "py36he5a4ee8_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Artistic License", + "license_family": "Other", + "md5": "c4e18e29daea077663110e9116abfe2b", + "name": "text-unidecode", + "sha256": "f81d6465f102e1f1115088b4c2a77e466ee0f2e0b3c6b45a18b92ab3536274f1", + "size": 65045, + "subdir": "linux-64", + "timestamp": 1508954619615, + "version": "1.0" + }, + "text-unidecode-1.1-py27ha29237d_0.conda": { + "build": "py27ha29237d_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Artistic License", + "license_family": "Other", + "md5": "5768173df94099e1b32b8c6d3b658cd6", + "name": "text-unidecode", + "sha256": "8b346cee80d29938214b0ad53deebead8432d136a12cfeea4604d0778aaf3a5b", + "size": 65173, + "subdir": "linux-64", + "timestamp": 1511316578012, + "version": "1.1" + }, + "text-unidecode-1.1-py35h97c4824_0.conda": { + "build": "py35h97c4824_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Artistic License", + "license_family": "Other", + "md5": "db3d7f2745fc0a3cd2318dedd570b787", + "name": "text-unidecode", + "sha256": "09de4d4fc5f9cf9c33e7bb9cc6d68722a1afd7042b190e201641d0fb9d589485", + "size": 65320, + "subdir": "linux-64", + "timestamp": 1511316587924, + "version": "1.1" + }, + "text-unidecode-1.1-py36h30150ea_0.conda": { + "build": "py36h30150ea_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Artistic License", + "license_family": "Other", + "md5": "fb75ed0f7685e31a5c9a8a0af748ef0a", + "name": "text-unidecode", + "sha256": "e0db9f2643ba1d95f7082ff9fc0def7ba8d5f48ad57222c3b8acf4dca3d86fa3", + "size": 65265, + "subdir": "linux-64", + "timestamp": 1511316586607, + "version": "1.1" + }, + "text-unidecode-1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Artistic License", + "license_family": "Other", + "md5": "d7f067eac6af8ccc5f21ae1285bb98f0", + "name": "text-unidecode", + "sha256": "255496ddf20219a808e7d50b8eee95ff2cedb247a45091e3d0ae12ecc2b60119", + "size": 64905, + "subdir": "linux-64", + "timestamp": 1519482783967, + "version": "1.2" + }, + "text-unidecode-1.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "Artistic License", + "license_family": "Other", + "md5": "5593ed3941ea0c46cba03e65e54a98ff", + "name": "text-unidecode", + "sha256": "07d1e850388d086138faa5934f1d3d3df1a56c6b8c54f8ba92f1928b32a292db", + "size": 64799, + "subdir": "linux-64", + "timestamp": 1519482831235, + "version": "1.2" + }, + "text-unidecode-1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Artistic License", + "license_family": "Other", + "md5": "83bd9cb2b554f6a10a8c276151df7865", + "name": "text-unidecode", + "sha256": "30bb80281d68f6ebf8aff2a6d2335dff97c0b630fa33dd4673326418fcd33ba5", + "size": 64959, + "subdir": "linux-64", + "timestamp": 1519482764040, + "version": "1.2" + }, + "text-unidecode-1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Artistic License", + "license_family": "Other", + "md5": "5e7059fc3a898bc7889f8f3cee561ccd", + "name": "text-unidecode", + "sha256": "f4b0215a922e7397bfea432c1afb57989d53949c8a6a8ddd30351bb9fb2d1b1e", + "size": 64860, + "subdir": "linux-64", + "timestamp": 1530727707203, + "version": "1.2" + }, + "the_silver_searcher-2.1.0-h4cbc732_0.conda": { + "build": "h4cbc732_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pcre", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a2fa4743cf5933ef2855890a9d6f6565", + "name": "the_silver_searcher", + "sha256": "21e657b922b23052ddd950454ef14946770666fd51f85c009661ce51c7f3f5f8", + "size": 62262, + "subdir": "linux-64", + "timestamp": 1511653156244, + "version": "2.1.0" + }, + "the_silver_searcher-2.2.0-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "pcre >=8.42,<9.0a0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d6823140786e94f8f3c3047e78df6bb3", + "name": "the_silver_searcher", + "sha256": "51ad912dd84abe5bcd2c7db85c4066206de2c126c1e5b24e6f70430ba70875e3", + "size": 62553, + "subdir": "linux-64", + "timestamp": 1535177119515, + "version": "2.2.0" + }, + "theano-0.9.0-py27ha72280b_3.conda": { + "build": "py27ha72280b_3", + "build_number": 3, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.6.5,<0.7", + "python >=2.7,<2.8.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8f557f45abea5ff4c4d44aeda107d2f2", + "name": "theano", + "sha256": "457fc3bc953621e775f872180a9ce36aa9a4f030e89a97bd237b4bdf63d9ec58", + "size": 3539087, + "subdir": "linux-64", + "timestamp": 1512408263820, + "version": "0.9.0" + }, + "theano-0.9.0-py35hb20a197_3.conda": { + "build": "py35hb20a197_3", + "build_number": 3, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.6.5,<0.7", + "python >=3.5,<3.6.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2fb0a8e86efd5a41ff3f9b011b73477c", + "name": "theano", + "sha256": "be091fd80f73c6861ce854631be588b02f0bcd5be66ee878dd1c67904256a929", + "size": 3561628, + "subdir": "linux-64", + "timestamp": 1512408289608, + "version": "0.9.0" + }, + "theano-0.9.0-py36h6b64b5b_3.conda": { + "build": "py36h6b64b5b_3", + "build_number": 3, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.6.5,<0.7", + "python >=3.6,<3.7.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "71d5a1cbea693c4be6f0ca5c296eb8a4", + "name": "theano", + "sha256": "eba1290a413b15fafbcb9721b0075b909e6b3c8431f15b12b8808e0a0bb336f5", + "size": 3548803, + "subdir": "linux-64", + "timestamp": 1512408321462, + "version": "0.9.0" + }, + "theano-1.0.1-py27h6bb024c_0.conda": { + "build": "py27h6bb024c_0", + "build_number": 0, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "79eaaceed67fb96d74fd800abfc78186", + "name": "theano", + "sha256": "3b287741f546e710f7553d51d356ef514ca6d734fc9772445dda5f33378d6a02", + "size": 3282644, + "subdir": "linux-64", + "timestamp": 1515164048460, + "version": "1.0.1" + }, + "theano-1.0.1-py35h6bb024c_0.conda": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6729fb48171f06dcb0dc5ed7d65b7b5d", + "name": "theano", + "sha256": "9a0a9e7981d8feb2375c3f684d247377409fee223cca01252833d34dece7cadb", + "size": 3369502, + "subdir": "linux-64", + "timestamp": 1515164059870, + "version": "1.0.1" + }, + "theano-1.0.1-py36h6bb024c_0.conda": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d7dbf3ba146e9a8d66785f5a7c913ae4", + "name": "theano", + "sha256": "8b63ed7992df126e4f486bf1979a82c92527bf27f2caba4d6ece437c8f87f85a", + "size": 3318927, + "subdir": "linux-64", + "timestamp": 1515164064499, + "version": "1.0.1" + }, + "theano-1.0.2-py27h6bb024c_0.conda": { + "build": "py27h6bb024c_0", + "build_number": 0, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0d23472912834b3681b925c165d26533", + "name": "theano", + "sha256": "eb4b678e76739dd495d96054d4dcaec14904b48f5d241493ebe0f07ecb8b578f", + "size": 3291946, + "subdir": "linux-64", + "timestamp": 1528351610247, + "version": "1.0.2" + }, + "theano-1.0.2-py35h6bb024c_0.conda": { + "build": "py35h6bb024c_0", + "build_number": 0, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.5,<3.6.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "49834c5fca9c7b5fe3e33b6573930f6b", + "name": "theano", + "sha256": "1bb452a0e40d10daa4a36df991b16210f605451b2fbc9b24b6c9861ecffa3ba4", + "size": 3376329, + "subdir": "linux-64", + "timestamp": 1528351670405, + "version": "1.0.2" + }, + "theano-1.0.2-py36h6bb024c_0.conda": { + "build": "py36h6bb024c_0", + "build_number": 0, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4980b7020fd2a9bb96e3a099a811b998", + "name": "theano", + "sha256": "9401b648917c527f37dbd14bc00245e49933539500e999b82e2316a6e4adce51", + "size": 3348384, + "subdir": "linux-64", + "timestamp": 1528351596858, + "version": "1.0.2" + }, + "theano-1.0.2-py37h6bb024c_0.conda": { + "build": "py37h6bb024c_0", + "build_number": 0, + "depends": [ + "gxx_linux-64", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d650a074957a66e937f9b4fd3e7dc789", + "name": "theano", + "sha256": "81448f3cc961428e70ba21a41de779b995c7a2bb1b84bac6d49656270105f9ec", + "size": 3256081, + "subdir": "linux-64", + "timestamp": 1530917559962, + "version": "1.0.2" + }, + "theano-1.0.3-py27hfd86e86_0.conda": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "gxx_linux-64 7.3.0.*", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3692367a255b85a8730fd78a786fb54c", + "name": "theano", + "sha256": "40239ac0c6c7703b60aebfa2e2f1e720681b8509d32cfd45bdb5c69ee847f2ee", + "size": 3234586, + "subdir": "linux-64", + "timestamp": 1538228644972, + "version": "1.0.3" + }, + "theano-1.0.3-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "gxx_linux-64 7.3.0.*", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c547093537d99de8778fcde12db86b7e", + "name": "theano", + "sha256": "f0cc0e816755afcf09f149db1d696ac97cd18b2d849ae71e59523f0d1504f92d", + "size": 3263827, + "subdir": "linux-64", + "timestamp": 1538229063203, + "version": "1.0.3" + }, + "theano-1.0.3-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "gxx_linux-64 7.3.0.*", + "mkl-service", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "155caaa8c3d5ea4401bd9dd754271486", + "name": "theano", + "sha256": "e45cb72a3c69d604b73a167109b1862e3d52faf3a40eb355b2ae3491727b5ebb", + "size": 3280198, + "subdir": "linux-64", + "timestamp": 1538228697700, + "version": "1.0.3" + }, + "theano-1.0.4-py27hfd86e86_0.conda": { + "build": "py27hfd86e86_0", + "build_number": 0, + "depends": [ + "gxx_linux-64 7.3.0.*", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=2.7,<2.8.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a971b372140270f69b724cd23857cb4f", + "name": "theano", + "sha256": "e7afe270ea0e108766d878f271d9967323c8a1a50526c9bd6e81eebae7820f47", + "size": 3287624, + "subdir": "linux-64", + "timestamp": 1568298725967, + "version": "1.0.4" + }, + "theano-1.0.4-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "gxx_linux-64 7.3.0.*", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.6,<3.7.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6eb86e99a152dca9a27805d3b88a7787", + "name": "theano", + "sha256": "9e41b027511d626cd150ca7b9e77865a9899b086fda59a198a51929038c42cb2", + "size": 3306566, + "subdir": "linux-64", + "timestamp": 1568298782021, + "version": "1.0.4" + }, + "theano-1.0.4-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "gxx_linux-64 7.3.0.*", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "081898917c238ef4a54bc4188f7f520f", + "name": "theano", + "sha256": "1b5c767aa470b08f137c1b9857fe73b3b4b1e33114099ab5c27495bbba9cb9bf", + "size": 3309246, + "subdir": "linux-64", + "timestamp": 1568298790394, + "version": "1.0.4" + }, + "theano-1.0.4-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "gxx_linux-64 7.3.0.*", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c5ceb744ec8f8c9a52f738736e748c3f", + "name": "theano", + "sha256": "6b28b456d2560439340385c7f78294eddd3e79fdc8fefd90a15ab7f4b893342f", + "size": 3315836, + "subdir": "linux-64", + "timestamp": 1574412720213, + "version": "1.0.4" + }, + "theano-1.0.5-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "gcc_linux-64 7.5.0.*", + "gxx_linux-64 7.5.0.*", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=0.14,<1.8", + "setuptools", + "six >=1.9.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9d42df3df228baaf45981936748fef7d", + "name": "theano", + "sha256": "46432639ea8e136b9514e72db61fdbb9dbcc9170199ab1dd3b515207cf55ce74", + "size": 3307831, + "subdir": "linux-64", + "timestamp": 1640811129594, + "version": "1.0.5" + }, + "theano-1.0.5-py37h295c915_1.conda": { + "build": "py37h295c915_1", + "build_number": 1, + "depends": [ + "gcc_linux-64 7.5.0.*", + "gxx_linux-64 7.5.0.*", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.14,<1.8", + "six >=1.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e9ace41013a22f7a34aa97f36f6dc4e", + "name": "theano", + "sha256": "5195ac662645f37bc1ccab35d6a84cd49af06e41863c593920015366514e4891", + "size": 3293696, + "subdir": "linux-64", + "timestamp": 1643818030896, + "version": "1.0.5" + }, + "theano-1.0.5-py38h295c915_1.conda": { + "build": "py38h295c915_1", + "build_number": 1, + "depends": [ + "gcc_linux-64 7.5.0.*", + "gxx_linux-64 7.5.0.*", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.14,<1.8", + "six >=1.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d07efb46a241bf6d452c7be1b4d5a13f", + "name": "theano", + "sha256": "4fe2a3b863c2659e93074509461f5029466eab61a21014e111aa4610410cf684", + "size": 3321739, + "subdir": "linux-64", + "timestamp": 1643799912077, + "version": "1.0.5" + }, + "theano-1.0.5-py39h295c915_1.conda": { + "build": "py39h295c915_1", + "build_number": 1, + "depends": [ + "gcc_linux-64 7.5.0.*", + "gxx_linux-64 7.5.0.*", + "numpy >=1.9.1", + "pygpu >=0.7,<0.8.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.14,<1.8", + "six >=1.9.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "14087f63b44c1e962c12bdde8da670f7", + "name": "theano", + "sha256": "d677606b0f50a87b1664f0709689c3f33f734e3d7bc061b758d2115f99fe5ac5", + "size": 3291671, + "subdir": "linux-64", + "timestamp": 1643802074547, + "version": "1.0.5" + }, + "theano-pymc-1.1.2-py310h00e6091_0.conda": { + "build": "py310h00e6091_0", + "build_number": 0, + "depends": [ + "filelock", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "scipy >=0.14,<1.8" + ], + "license": "BSD-3-Clause", + "md5": "ab3b2e3e20744e77c0be04d14787d785", + "name": "theano-pymc", + "sha256": "24188e3eb0f40c8a9ce6561a844c62aa1e93843e39784ca1cfafb3517c694969", + "size": 1916766, + "subdir": "linux-64", + "timestamp": 1640811162816, + "version": "1.1.2" + }, + "theano-pymc-1.1.2-py311hba01205_0.conda": { + "build": "py311hba01205_0", + "build_number": 0, + "depends": [ + "filelock", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0", + "scipy >=0.14,<1.8" + ], + "license": "BSD-3-Clause", + "md5": "2e3d66fc3d7a578a8b4be4fee10f47bf", + "name": "theano-pymc", + "sha256": "e45fa846066a16717c023f28fd9b7c297f4757f364bacbf234a1a18b00db493e", + "size": 2508785, + "subdir": "linux-64", + "timestamp": 1676845958444, + "version": "1.1.2" + }, + "theano-pymc-1.1.2-py37h51133e4_0.conda": { + "build": "py37h51133e4_0", + "build_number": 0, + "depends": [ + "filelock", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "scipy >=0.14,<1.8" + ], + "license": "BSD-3-Clause", + "md5": "435a632c182a7494f047d7a1fb3c9591", + "name": "theano-pymc", + "sha256": "68a188603d061c99903a4a1f59020e3940cd117be53d515f2e8e69600886a6cb", + "size": 1891798, + "subdir": "linux-64", + "timestamp": 1634734591197, + "version": "1.1.2" + }, + "theano-pymc-1.1.2-py38h51133e4_0.conda": { + "build": "py38h51133e4_0", + "build_number": 0, + "depends": [ + "filelock", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "scipy >=0.14,<1.8" + ], + "license": "BSD-3-Clause", + "md5": "944e7acfe3b3a6ebb4ed42bdd7260f2a", + "name": "theano-pymc", + "sha256": "b38ba6bf1bd37a80cc823f603cdaccaa4c8167235c778b704e227307962e230f", + "size": 1904885, + "subdir": "linux-64", + "timestamp": 1634734602238, + "version": "1.1.2" + }, + "theano-pymc-1.1.2-py39h51133e4_0.conda": { + "build": "py39h51133e4_0", + "build_number": 0, + "depends": [ + "filelock", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "scipy >=0.14,<1.8" + ], + "license": "BSD-3-Clause", + "md5": "a29e1049e61e0d4ee4a6059bf9845377", + "name": "theano-pymc", + "sha256": "30aee0caaa943091f93c754b2319ee0b56b35089db580596ae6e267d4414ff10", + "size": 1923885, + "subdir": "linux-64", + "timestamp": 1634723244153, + "version": "1.1.2" + }, + "thefuzz-0.19.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "a2bc9fa15e887ece1ec2eb0abf460790", + "name": "thefuzz", + "sha256": "78bda64827dafc27919d76ad144be02d42912a4152734d3fc002681507aaee12", + "size": 26934, + "subdir": "linux-64", + "timestamp": 1664351331399, + "version": "0.19.0" + }, + "thefuzz-0.19.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "a1919691db03a15097e27e8b6c7f127f", + "name": "thefuzz", + "sha256": "d613076f09a1008137a12a125b6dd82046f8747a37a477754f6b63cea434dd6e", + "size": 30624, + "subdir": "linux-64", + "timestamp": 1679340367786, + "version": "0.19.0" + }, + "thefuzz-0.19.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "8d3dd5475a1ab62766be0c5d65dd8ea8", + "name": "thefuzz", + "sha256": "11a5425ed83bcb865954a60ffec3e8e5af365fa184855e3d79d495e57e22e87e", + "size": 26761, + "subdir": "linux-64", + "timestamp": 1664351357598, + "version": "0.19.0" + }, + "thefuzz-0.19.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "96f9a7b1eb5d74579820e59d963afaa5", + "name": "thefuzz", + "sha256": "db016f03b6e9ee4341dfe5413ce83951080c9d8e6b4f02989fa8f770fa5f87f8", + "size": 26907, + "subdir": "linux-64", + "timestamp": 1664351286931, + "version": "0.19.0" + }, + "thefuzz-0.19.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-levenshtein >=0.12" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "b1dee8989e3f53a8beec119236f9a24b", + "name": "thefuzz", + "sha256": "ed7b2cee08d89edb10b062e5e6770ee45d9781b87ae257320805b63b1ddbc6e3", + "size": 26829, + "subdir": "linux-64", + "timestamp": 1664351388133, + "version": "0.19.0" + }, + "thinc-6.10.0-py27h53cc36c_0.conda": { + "build": "py27h53cc36c_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.8,<0.9", + "dill", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy", + "msgpack-python", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "termcolor", + "tqdm >=4.10.0,<5.0.0", + "wrapt" + ], + "license": "MIT", + "md5": "fae15a484e0fa53cf08d6b5e8c9a25a2", + "name": "thinc", + "sha256": "9d4ff2c74c399ca7957e8fb70886fb0981ec9a81b12a44170fe64197e987eb20", + "size": 979139, + "subdir": "linux-64", + "timestamp": 1509389017076, + "version": "6.10.0" + }, + "thinc-6.10.0-py35hef661f6_0.conda": { + "build": "py35hef661f6_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.8,<0.9", + "dill", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy", + "msgpack-python", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0,<2.0.0", + "termcolor", + "tqdm >=4.10.0,<5.0.0", + "wrapt" + ], + "license": "MIT", + "md5": "69847da07ad84068381784fef9210378", + "name": "thinc", + "sha256": "d7f6839d752f5af8672114c2a607e280cb50dadd7a41c0974cd532f28f72dfae", + "size": 978465, + "subdir": "linux-64", + "timestamp": 1509389024919, + "version": "6.10.0" + }, + "thinc-6.10.0-py36hc5923a9_0.conda": { + "build": "py36hc5923a9_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.8,<0.9", + "dill", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy", + "msgpack-python", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "termcolor", + "tqdm >=4.10.0,<5.0.0", + "wrapt" + ], + "license": "MIT", + "md5": "0ef5b056aff18b4fdb0caf88e58773da", + "name": "thinc", + "sha256": "06a90a281d4842796506c06ca3b203d04b272d7a21d1fcb6cdff8c382331579a", + "size": 985541, + "subdir": "linux-64", + "timestamp": 1509389020891, + "version": "6.10.0" + }, + "thinc-6.10.1-py27ha99dbb2_0.conda": { + "build": "py27ha99dbb2_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.8,<0.9", + "dill", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy", + "msgpack-python", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "termcolor", + "tqdm >=4.10.0,<5.0.0", + "wrapt" + ], + "license": "MIT", + "md5": "940ab4b8dfc2b287f7a34e7f37113e8e", + "name": "thinc", + "sha256": "b9d4b6d0dea9c7ac21cea84a21d3dcc3fd32dd2e6927efd60a0438c0ea0a4fd6", + "size": 994213, + "subdir": "linux-64", + "timestamp": 1511372593542, + "version": "6.10.1" + }, + "thinc-6.10.1-py35hd0b83a8_0.conda": { + "build": "py35hd0b83a8_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.8,<0.9", + "dill", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy", + "msgpack-python", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0,<2.0.0", + "termcolor", + "tqdm >=4.10.0,<5.0.0", + "wrapt" + ], + "license": "MIT", + "md5": "0e1f2d5e2d6b06b5fe4af32995a456d3", + "name": "thinc", + "sha256": "8e5b1e3d28a2f13627b7c7c1e4f0ce8b8621a3ff5338971ecb4725e3d7aeb875", + "size": 991563, + "subdir": "linux-64", + "timestamp": 1511372658762, + "version": "6.10.1" + }, + "thinc-6.10.1-py36hd61447b_0.conda": { + "build": "py36hd61447b_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.8,<0.9", + "dill", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy", + "msgpack-python", + "murmurhash >=0.28,<0.29", + "numpy >=1.9.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "termcolor", + "tqdm >=4.10.0,<5.0.0", + "wrapt" + ], + "license": "MIT", + "md5": "f2b26f599d0ea891c9e57d064780762c", + "name": "thinc", + "sha256": "92a2eee9eb920f48294cf7b144a33374b22ab6d0f8d24b15fb4eada1beda8127", + "size": 999512, + "subdir": "linux-64", + "timestamp": 1511372667121, + "version": "6.10.1" + }, + "thinc-6.10.2-py27h637b7d7_0.conda": { + "build": "py27h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.8,<0.9", + "dill >=0.2.6,<0.3.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy ==0.4.1", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.30", + "numpy >=1.9.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<2.0.0" + ], + "license": "MIT", + "md5": "4d255d4283a9de8deb150f3497aee7c2", + "name": "thinc", + "sha256": "51a5da3108cb6c7d729ad9669e861b753236ef1ffd184d4308b2260bbcabb8bc", + "size": 1041886, + "subdir": "linux-64", + "timestamp": 1519845134056, + "version": "6.10.2" + }, + "thinc-6.10.2-py35h637b7d7_0.conda": { + "build": "py35h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.8,<0.9", + "dill >=0.2.6,<0.3.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy ==0.4.1", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.30", + "numpy >=1.9.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<2.0.0" + ], + "license": "MIT", + "md5": "fc3f0704986e474c02222b90f8825297", + "name": "thinc", + "sha256": "2b5a374edb724aa78aa08d7e0b325002f49e3e5016101263da69a50c6b6c93d2", + "size": 1034698, + "subdir": "linux-64", + "timestamp": 1519845143714, + "version": "6.10.2" + }, + "thinc-6.10.2-py36h637b7d7_0.conda": { + "build": "py36h637b7d7_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.8,<0.9", + "dill >=0.2.6,<0.3.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy ==0.4.1", + "msgpack-python >=0.4.8,<0.5.0", + "murmurhash >=0.28,<0.30", + "numpy >=1.9.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<2.0.0" + ], + "license": "MIT", + "md5": "dc636ffcf75033f328191481fefd3e1e", + "name": "thinc", + "sha256": "471aaba97ad076621a9799c8db87dfd2cdbe3988d01ab4be4c861be0e6b5b83d", + "size": 1044802, + "subdir": "linux-64", + "timestamp": 1519845150412, + "version": "6.10.2" + }, + "thinc-6.10.3-py27h962f231_0.conda": { + "build": "py27h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.9,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy >=0.4.1,<1.0.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<0.29.0", + "numpy >=1.11.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "c0fa9b8025e49fad3d0a71cec95311a0", + "name": "thinc", + "sha256": "7d02be19d077d731fae90cd1307d971696b9991ba849aa69269a046effdb242a", + "size": 1048845, + "subdir": "linux-64", + "timestamp": 1535604135076, + "version": "6.10.3" + }, + "thinc-6.10.3-py35h962f231_0.conda": { + "build": "py35h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.9,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy >=0.4.1,<1.0.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<0.29.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "e1d35b39feb74391b81ce10514b0c6ef", + "name": "thinc", + "sha256": "878a36936892faebdb80feb5730207c0167e0a867849c0e016c4bd35e32dba4a", + "size": 1044096, + "subdir": "linux-64", + "timestamp": 1535604432289, + "version": "6.10.3" + }, + "thinc-6.10.3-py36h962f231_0.conda": { + "build": "py36h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.9,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy >=0.4.1,<1.0.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<0.29.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "cf448988ee0a447f82e60f78fcc18da0", + "name": "thinc", + "sha256": "a13c9dfd7fb3fdf098efb3c3028d5056461c499528defd5547a07e0bf2c65374", + "size": 1052069, + "subdir": "linux-64", + "timestamp": 1535604191962, + "version": "6.10.3" + }, + "thinc-6.10.3-py37h962f231_0.conda": { + "build": "py37h962f231_0", + "build_number": 0, + "depends": [ + "cymem >=1.30,<1.32", + "cytoolz >=0.9,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy >=0.4.1,<1.0.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<0.29.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "6e2190e86c8f59fdde63eae0d2b9e363", + "name": "thinc", + "sha256": "c09a99a12d635f4284d56bfb014312a7be84f5c5392e9669d96913ddfe515d48", + "size": 1051279, + "subdir": "linux-64", + "timestamp": 1535604328986, + "version": "6.10.3" + }, + "thinc-6.11.2-py27h6cfcb94_0.conda": { + "build": "py27h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "3264474482fa2fb9f3df32fe989f125e", + "name": "thinc", + "sha256": "65b3f5c10a51bbdbe71ead856809ec1a5ce6607d085116c671b73476668ed184", + "size": 1191752, + "subdir": "linux-64", + "timestamp": 1529614590924, + "version": "6.11.2" + }, + "thinc-6.11.2-py27h6cfcb94_1.conda": { + "build": "py27h6cfcb94_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "six", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "d9dedd8c2ff9f6f695d9fde4166dd0dd", + "name": "thinc", + "sha256": "ceffe95688eeee1322b50437167747dc25d034244acd00aca891d3bd17b356db", + "size": 1191710, + "subdir": "linux-64", + "timestamp": 1531127441221, + "version": "6.11.2" + }, + "thinc-6.11.2-py27hedc7406_0.conda": { + "build": "py27hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "80877fd94bcc9edb9320c88d3ec52fa1", + "name": "thinc", + "sha256": "8655982a0e42f631c4f8531d71fd32281dddca727e63c54c8512034bef620f6d", + "size": 1192164, + "subdir": "linux-64", + "timestamp": 1529611469813, + "version": "6.11.2" + }, + "thinc-6.11.2-py27hedc7406_1.conda": { + "build": "py27hedc7406_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=2.7,<2.8.0a0", + "six", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "06d72a5b2d6c60e9ffd219c486520eed", + "name": "thinc", + "sha256": "dc97bde5846c81854a8d9466d73a4a3ce12e0f606af14d3bfa539a1b0aa4279c", + "size": 1191785, + "subdir": "linux-64", + "timestamp": 1531127273590, + "version": "6.11.2" + }, + "thinc-6.11.2-py35h6cfcb94_0.conda": { + "build": "py35h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "0e32da45a6077cc90c674993d4a3ae89", + "name": "thinc", + "sha256": "156e021888de396283e4a736cc477054a8fc1222fea9a2c401c18a9bea716a16", + "size": 1186781, + "subdir": "linux-64", + "timestamp": 1529612753984, + "version": "6.11.2" + }, + "thinc-6.11.2-py35hedc7406_0.conda": { + "build": "py35hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.5,<3.6.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "50c96ea162c3189120351d37c9ab6358", + "name": "thinc", + "sha256": "83425d7c1e5ae18ea92a0d037ed15193b5dfd4a01bc37e5058a39fe970e9c811", + "size": 1186779, + "subdir": "linux-64", + "timestamp": 1529612753182, + "version": "6.11.2" + }, + "thinc-6.11.2-py36h6cfcb94_0.conda": { + "build": "py36h6cfcb94_0", + "build_number": 0, + "depends": [ + "blas 1.0 openblas", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "22685f5840e6d5159c0c7b65d13163fa", + "name": "thinc", + "sha256": "f1a30a4e26fcc1194a77c7aaac38eb423e3178647396e5d256852bb095236bc5", + "size": 1197993, + "subdir": "linux-64", + "timestamp": 1529612754249, + "version": "6.11.2" + }, + "thinc-6.11.2-py36h6cfcb94_1.conda": { + "build": "py36h6cfcb94_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "six", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "5e9fd5470b0032c95d4112b3caf10949", + "name": "thinc", + "sha256": "f5cd4fe3062ae07e7b0f16c10888509774d541ebedac96c44e57b3ffd77e305f", + "size": 1196588, + "subdir": "linux-64", + "timestamp": 1531128114884, + "version": "6.11.2" + }, + "thinc-6.11.2-py36hedc7406_0.conda": { + "build": "py36hedc7406_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "a264a52b3679f5adf72c5ad3b72a7fb6", + "name": "thinc", + "sha256": "89131e61fe6d5d6dc77198b56542513b237ed498fe16bf6bebe0393c3bbc479e", + "size": 1196703, + "subdir": "linux-64", + "timestamp": 1529612752890, + "version": "6.11.2" + }, + "thinc-6.11.2-py36hedc7406_1.conda": { + "build": "py36hedc7406_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.6,<3.7.0a0", + "six", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "4b160aef3440ffa485d5516e87e6720a", + "name": "thinc", + "sha256": "7dc4ab40825d5d528b1588e7a070e6bdce28c18fc7495832ef6acad1ee158fad", + "size": 1198190, + "subdir": "linux-64", + "timestamp": 1531127950038, + "version": "6.11.2" + }, + "thinc-6.11.2-py37h6cfcb94_1.conda": { + "build": "py37h6cfcb94_1", + "build_number": 1, + "depends": [ + "blas 1.0 openblas", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libopenblas >=0.2.20,<0.2.21.0a0", + "libstdcxx-ng >=7.2.0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.7,<3.8.0a0", + "six", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "5a3e3b298ee8e6ba06585e0076aea13a", + "name": "thinc", + "sha256": "9b0cfba6ff63403dad758d09a06f0e9b39eed47332680520ea75afffb2231ece", + "size": 1194616, + "subdir": "linux-64", + "timestamp": 1531127777522, + "version": "6.11.2" + }, + "thinc-6.11.2-py37hedc7406_1.conda": { + "build": "py37hedc7406_1", + "build_number": 1, + "depends": [ + "blas 1.0 mkl", + "cymem >=1.30,<1.32", + "cytoolz", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy >=0.4.1", + "msgpack-python >=0.5.6", + "murmurhash >=0.28,<0.30", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9,<1.0", + "preshed >=1.0.0,<2.0.0", + "python >=3.7,<3.8.0a0", + "six", + "termcolor >=1.1.0,<1.2.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "8bff49ef169244ca4401a8f880523a3f", + "name": "thinc", + "sha256": "450d8fb57be771ddd3c04efd3c4dc3c67590011b1283cafabc2576a9a840de3c", + "size": 1194629, + "subdir": "linux-64", + "timestamp": 1531127614323, + "version": "6.11.2" + }, + "thinc-6.12.0-py27h22eb022_0.conda": { + "build": "py27h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "4f0091886b8e3b315785b45dfc942433", + "name": "thinc", + "sha256": "f91dc4cdac0d735363bbd4650e15df7a89f98795eb254631c37a8817fda8aa5e", + "size": 1080663, + "subdir": "linux-64", + "timestamp": 1539880952726, + "version": "6.12.0" + }, + "thinc-6.12.0-py27h4989274_0.conda": { + "build": "py27h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "1e8559461679e324b0a082b9190f8d36", + "name": "thinc", + "sha256": "c044ad8370ea5e6deb93bc689c85bba4b4c38f1ab352d8f160e63197a341dcce", + "size": 1080653, + "subdir": "linux-64", + "timestamp": 1539881171267, + "version": "6.12.0" + }, + "thinc-6.12.0-py36h22eb022_0.conda": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "9a1e6b4d1c483b87d1a8dd6991300a25", + "name": "thinc", + "sha256": "5926c366d3ed0e01802ce045b76e990784b12c10f6abb7bd07d2673086408303", + "size": 1087696, + "subdir": "linux-64", + "timestamp": 1539880980469, + "version": "6.12.0" + }, + "thinc-6.12.0-py36h4989274_0.conda": { + "build": "py36h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "a3bdd3ec137011a832b47ce08e237b56", + "name": "thinc", + "sha256": "2b6289eaaec342660002d9542861b8f299666e305ded0afe492eaaaca1f99920", + "size": 1087733, + "subdir": "linux-64", + "timestamp": 1539881417875, + "version": "6.12.0" + }, + "thinc-6.12.0-py37h22eb022_0.conda": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "5d2350df4f0d35e223614333b112e74c", + "name": "thinc", + "sha256": "fbd91868338f8acb68730acbd0ceffe059a55048f2886121ed3cd7b1d5f8640b", + "size": 1085677, + "subdir": "linux-64", + "timestamp": 1539880972975, + "version": "6.12.0" + }, + "thinc-6.12.0-py37h4989274_0.conda": { + "build": "py37h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "b023b634e6dce4f913dbfd272ab17dc7", + "name": "thinc", + "sha256": "5f42892032ca22bc2f1111a57ef0874d156ad7c43bae3b1887774c2c8a8df99e", + "size": 1083471, + "subdir": "linux-64", + "timestamp": 1539881394699, + "version": "6.12.0" + }, + "thinc-6.12.1-py27h22eb022_0.conda": { + "build": "py27h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "8f4c0240123e763edc80ce597e52a83c", + "name": "thinc", + "sha256": "7f6a0d2e1cab166034b0ebd10433fba90c66d35e832db3b66845e51902c3bbdb", + "size": 1022230, + "subdir": "linux-64", + "timestamp": 1545123188656, + "version": "6.12.1" + }, + "thinc-6.12.1-py27h4989274_0.conda": { + "build": "py27h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "pathlib >=1.0.0,<2.0.0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=2.7,<2.8.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "fdc38768dbe9103c367b6220a5a1b562", + "name": "thinc", + "sha256": "b7e1493944d25e8448ce68c1ce26994a65f5381a65f71590db96f20d04d6495c", + "size": 1021969, + "subdir": "linux-64", + "timestamp": 1545123302151, + "version": "6.12.1" + }, + "thinc-6.12.1-py36h22eb022_0.conda": { + "build": "py36h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "5de3c2e851a8a5d552249c8ca3c75351", + "name": "thinc", + "sha256": "61703d1eb6aa33a5ae450f5c73194630c72ee52472bda63d8b0dd43a7f364ece", + "size": 1030045, + "subdir": "linux-64", + "timestamp": 1545123171959, + "version": "6.12.1" + }, + "thinc-6.12.1-py36h4989274_0.conda": { + "build": "py36h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.6,<3.7.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "75147524dfc059e55a8c58a6a3446b2f", + "name": "thinc", + "sha256": "f27a96a9b58d6ad18ddbc8871f17b74002ae75b10aa628db402f8b341066e335", + "size": 1030050, + "subdir": "linux-64", + "timestamp": 1545123373814, + "version": "6.12.1" + }, + "thinc-6.12.1-py37h22eb022_0.conda": { + "build": "py37h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "d87a767367675e538a4e7fa1e9c216cd", + "name": "thinc", + "sha256": "1a184148a88fde16e7e04d10b9a587d92a29ba4564fb7fa506f14c4eea7ba74b", + "size": 1029312, + "subdir": "linux-64", + "timestamp": 1545123173027, + "version": "6.12.1" + }, + "thinc-6.12.1-py37h4989274_0.conda": { + "build": "py37h4989274_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2018.0.3,<2019.0a0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.7,<3.8.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "5614bff054e5d27d20c78e28d2608747", + "name": "thinc", + "sha256": "739f38f9cbbff1106eec556e57d19ac4570e0b4cb2caaca41884878c2570b738", + "size": 1029779, + "subdir": "linux-64", + "timestamp": 1545123289790, + "version": "6.12.1" + }, + "thinc-6.12.1-py38h22eb022_0.conda": { + "build": "py38h22eb022_0", + "build_number": 0, + "depends": [ + "blas * openblas", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libopenblas >=0.3.3,<1.0a0", + "libstdcxx-ng >=7.3.0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.8,<3.9.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "11b3933ac973c004642bd50da144f4fc", + "name": "thinc", + "sha256": "b70de46d37dfc7abea7e158893e04aea56ecb37ce875a9ef8f84a86f5a4f3464", + "size": 1069267, + "subdir": "linux-64", + "timestamp": 1574153414861, + "version": "6.12.1" + }, + "thinc-6.12.1-py38hd81dba3_0.conda": { + "build": "py38hd81dba3_0", + "build_number": 0, + "depends": [ + "blas 1.0 mkl", + "cymem >=2.0.2,<3.0.0", + "cytoolz >=0.9.0,<0.10", + "dill >=0.2.7,<0.3.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "mkl >=2019.4,<2021.0a0", + "mkl-service >=2,<3.0a0", + "msgpack-numpy <0.4.4.0", + "msgpack-python >=0.5.6,<1.0.0", + "murmurhash >=0.28,<1.1.0", + "numpy >=1.11.3,<2.0a0", + "plac >=0.9.6,<1.0", + "preshed >=2.0.1,<3.0.0", + "python >=3.8,<3.9.0a0", + "six >=1.10.0,<2.0.0", + "tqdm >=4.10.0,<5.0.0", + "wrapt >=1.10.10,<1.11.0" + ], + "license": "MIT", + "md5": "08be15e46ae37760313feb98020befb5", + "name": "thinc", + "sha256": "e2bc70ed1ccf8a4671271d53e9a9a8728b55493b33e5d030127875585e2531da", + "size": 1069301, + "subdir": "linux-64", + "timestamp": 1574153322941, + "version": "6.12.1" + }, + "thinc-7.4.1-py36hfd86e86_0.conda": { + "build": "py36hfd86e86_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.5.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.6,<3.7.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "ea8550d49e4b5b61ef4ee059577f22a6", + "name": "thinc", + "sha256": "b7a95a79f9a3fb1368945f46a1ead7382db23e8a27ce8dcd08e95d0d812a8cc1", + "size": 1215088, + "subdir": "linux-64", + "timestamp": 1594252072469, + "version": "7.4.1" + }, + "thinc-7.4.1-py37hfd86e86_0.conda": { + "build": "py37hfd86e86_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.5.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.7,<3.8.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "9deee85f9dfc620e21139050a82049c1", + "name": "thinc", + "sha256": "a2b3dacc087ecc7e8b25c8b2109c325bdddd0e558c0a7cb96ed7a00d569c2991", + "size": 1207649, + "subdir": "linux-64", + "timestamp": 1594252076438, + "version": "7.4.1" + }, + "thinc-7.4.1-py38hfd86e86_0.conda": { + "build": "py38hfd86e86_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.5.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.8,<3.9.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "45f303d24c2c9a2cdd2ac650e0ecb6d0", + "name": "thinc", + "sha256": "a54a6244aff9bd2cd0b4b0a3a7186df677b07669fe288c185d0eafd10e4114bc", + "size": 1207074, + "subdir": "linux-64", + "timestamp": 1594252067123, + "version": "7.4.1" + }, + "thinc-7.4.4-py36h9a67853_0.conda": { + "build": "py36h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.6,<3.7.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "af4c61f7abcd94b083bf459671bea7a1", + "name": "thinc", + "sha256": "7b96301d85de2adf944607a12f3828f5730a8a718c7c61302a615d43e6d48075", + "size": 849235, + "subdir": "linux-64", + "timestamp": 1607551228569, + "version": "7.4.4" + }, + "thinc-7.4.4-py37h9a67853_0.conda": { + "build": "py37h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.7,<3.8.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "2eb75449a413018a99cf44e3a3ef25f4", + "name": "thinc", + "sha256": "94a5d7fa73b9a125f67e546493084a8d63c40c261367c74b873c95c380fc2956", + "size": 846217, + "subdir": "linux-64", + "timestamp": 1607551233317, + "version": "7.4.4" + }, + "thinc-7.4.4-py38h9a67853_0.conda": { + "build": "py38h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.8,<3.9.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "8b998f60f4e314d25030e7365816d5da", + "name": "thinc", + "sha256": "809f77eb783d0d8c0e5b5ecf60409d990d6e362ec59e6fe1c6f25ed6b7361280", + "size": 887333, + "subdir": "linux-64", + "timestamp": 1607551244747, + "version": "7.4.4" + }, + "thinc-7.4.5-py36h9a67853_0.conda": { + "build": "py36h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.6,<3.7.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "59e582dfa25f0410496180a64bf9a190", + "name": "thinc", + "sha256": "54ac5fcfd5e4914945a1b6f233ed1dc85d36d8102e6cf8555ec2969ee5682c6f", + "size": 847440, + "subdir": "linux-64", + "timestamp": 1607710276168, + "version": "7.4.5" + }, + "thinc-7.4.5-py37h9a67853_0.conda": { + "build": "py37h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.7,<3.8.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "6142bcd3707a69cbc229eec8827c2fa1", + "name": "thinc", + "sha256": "1eeda1a478a66adbf5fa2d349c2f14110c8c0d811e6f5e75f177aa1a4556b106", + "size": 846513, + "subdir": "linux-64", + "timestamp": 1607710260377, + "version": "7.4.5" + }, + "thinc-7.4.5-py38h9a67853_0.conda": { + "build": "py38h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.8,<3.9.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "22f2713a8786df5e4c73d2964baa1f11", + "name": "thinc", + "sha256": "1656f1beb2a3f45e0b592048d84cb185ba500bd83e98286bde93eba3e1c55423", + "size": 887274, + "subdir": "linux-64", + "timestamp": 1607710277618, + "version": "7.4.5" + }, + "thinc-7.4.5-py39h9a67853_0.conda": { + "build": "py39h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.0.7,<1.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "plac >=0.9.6,<1.2.0", + "preshed >=3.0.2,<3.1.0", + "python >=3.9,<3.10.0a0", + "srsly >=0.0.6,<1.1.0", + "tqdm >=4.10.0,<5.0.0", + "wasabi >=0.0.9,<1.1.0" + ], + "license": "MIT", + "md5": "21011bec329c0c34edf803bb33265d3a", + "name": "thinc", + "sha256": "cfdc94ac1f10c2e0aab2ecdc325f1417c3b705dcc59fe0c8151b7e3f16dc7646", + "size": 885469, + "subdir": "linux-64", + "timestamp": 1608240819666, + "version": "7.4.5" + }, + "thinc-8.0.1-py36h9a67853_0.conda": { + "build": "py36h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.2.0,<3.0.0", + "contextvars >=2.4,<3", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "dataclasses >=0.6,<1.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.1,<1.8.0", + "python >=3.6,<3.7.0a0", + "srsly >=2.0.0,<3.0.0", + "typing_extensions", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "7e63a643a1822224760d9f14b4b9d109", + "name": "thinc", + "sha256": "55cc8eb370f66e951a3ed63e5bbd427e46e8545f4bdadb15a9a7fc6e5d68119e", + "size": 811825, + "subdir": "linux-64", + "timestamp": 1611697229433, + "version": "8.0.1" + }, + "thinc-8.0.1-py37h9a67853_0.conda": { + "build": "py37h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.2.0,<3.0.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.1,<1.8.0", + "python >=3.7,<3.8.0a0", + "srsly >=2.0.0,<3.0.0", + "typing_extensions", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "72e8ffb749e21d64d7482dde44ed688e", + "name": "thinc", + "sha256": "a8ded93dcc72fd5b571000e378772efa74ee92c020661e649e0f9cf8c7059d1b", + "size": 814684, + "subdir": "linux-64", + "timestamp": 1611697184949, + "version": "8.0.1" + }, + "thinc-8.0.1-py38h9a67853_0.conda": { + "build": "py38h9a67853_0", + "build_number": 0, + "depends": [ + "catalogue >=0.2.0,<3.0.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.1,<1.8.0", + "python >=3.8,<3.9.0a0", + "srsly >=2.0.0,<3.0.0", + "typing_extensions", + "wasabi >=0.4.0,<1.1.0" + ], + "license": "MIT", + "md5": "fcf1949332e24f9611dd131e1f98f292", + "name": "thinc", + "sha256": "079b1efe071a222e0858fefc2356200fdfe89519bf92be2474d05f5f93ec0e6a", + "size": 832409, + "subdir": "linux-64", + "timestamp": 1611697198648, + "version": "8.0.1" + }, + "thinc-8.0.13-py37hae6d005_0.conda": { + "build": "py37hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.4,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1,<1.9.0", + "python >=3.7,<3.8.0a0", + "srsly >=2.4.0,<3.0.0", + "typing_extensions >=3.7.4.1,<4.0.0.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b5e9350f94331715a699b3abbceda892", + "name": "thinc", + "sha256": "61c60de70c047698f2a178a6f9027c41eacd988808b7cd5678e8205c10365160", + "size": 644115, + "subdir": "linux-64", + "timestamp": 1636635356546, + "version": "8.0.13" + }, + "thinc-8.0.13-py38hae6d005_0.conda": { + "build": "py38hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.4,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1,<1.9.0", + "python >=3.8,<3.9.0a0", + "srsly >=2.4.0,<3.0.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b21b20b52ebc6ec41a4808e82213676", + "name": "thinc", + "sha256": "0a46a8b0e8a8ac299e579d99919df7d60585b1855cba688f3e868edb487099f8", + "size": 664874, + "subdir": "linux-64", + "timestamp": 1636623029001, + "version": "8.0.13" + }, + "thinc-8.0.13-py39hae6d005_0.conda": { + "build": "py39hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.4,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=0.28.0,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1,<1.9.0", + "python >=3.9,<3.10.0a0", + "srsly >=2.4.0,<3.0.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d733700497cba6cabd07e55373cbbf10", + "name": "thinc", + "sha256": "db1fa129fca170f883c604c3a9be7024caffbdc00e89919d9f8884d477d3beb8", + "size": 662783, + "subdir": "linux-64", + "timestamp": 1636635343146, + "version": "8.0.13" + }, + "thinc-8.0.15-py310h2571103_0.conda": { + "build": "py310h2571103_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.4,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=1.0.2,<1.1.0", + "numpy >=1.21.5,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.10,<3.11.0a0", + "setuptools", + "srsly >=2.4.0,<3.0.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df92e40b9c9d1f43bd8db791848e97c6", + "name": "thinc", + "sha256": "2ced8dd88ad18b6db7d853f877434e05e3c5fb687ede53131fa65f6c8919ac94", + "size": 1620242, + "subdir": "linux-64", + "timestamp": 1651591825368, + "version": "8.0.15" + }, + "thinc-8.0.15-py311heed92f4_0.conda": { + "build": "py311heed92f4_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.4,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "murmurhash >=1.0.2,<1.1.0", + "numpy >=1.22.3,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.11,<3.12.0a0", + "setuptools", + "srsly >=2.4.0,<3.0.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d43b81c6afd9003d79ad0b582de1b235", + "name": "thinc", + "sha256": "e9ef5e5e8083acbdef27718a0e11e07027d950888245fdf051e268f1410838ef", + "size": 854664, + "subdir": "linux-64", + "timestamp": 1676846005899, + "version": "8.0.15" + }, + "thinc-8.0.15-py37hae6d005_0.conda": { + "build": "py37hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.4,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=1.0.2,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.7,<3.8.0a0", + "setuptools", + "srsly >=2.4.0,<3.0.0", + "typing_extensions >=3.7.4.1,<4.0.0.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cbbbfb38b5d17c102ce40e39851bbb24", + "name": "thinc", + "sha256": "697a0e91d6f39fc0bd877a62b013c92381df2536fdb0a369d10c389c3ac2dbcf", + "size": 676192, + "subdir": "linux-64", + "timestamp": 1651591552518, + "version": "8.0.15" + }, + "thinc-8.0.15-py38hae6d005_0.conda": { + "build": "py38hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.4,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=1.0.2,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.8,<3.9.0a0", + "setuptools", + "srsly >=2.4.0,<3.0.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df485a4c33a2f9fe438358db36bfdcf6", + "name": "thinc", + "sha256": "5b55b82d0cd8f71460d556bcd3364903d65696926a94b058b8b0f70aa34a51b8", + "size": 696087, + "subdir": "linux-64", + "timestamp": 1651591638933, + "version": "8.0.15" + }, + "thinc-8.0.15-py39hae6d005_0.conda": { + "build": "py39hae6d005_0", + "build_number": 0, + "depends": [ + "catalogue >=2.0.4,<2.1.0", + "cymem >=2.0.2,<2.1.0", + "cython-blis >=0.4.0,<0.8.0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "murmurhash >=1.0.2,<1.1.0", + "numpy >=1.16.6,<2.0a0", + "preshed >=3.0.2,<3.1.0", + "pydantic >=1.7.4,!=1.8,!=1.8.1", + "python >=3.9,<3.10.0a0", + "setuptools", + "srsly >=2.4.0,<3.0.0", + "wasabi >=0.8.1,<1.1.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "93b2f6d0b94a01e08229207b6e2a5f8b", + "name": "thinc", + "sha256": "2f9062567689c7376ff13339cfe29d0c1867ff008e2a8c3d53a699d82d4d60fa", + "size": 699061, + "subdir": "linux-64", + "timestamp": 1651591726222, + "version": "8.0.15" + }, + "thrift-0.11.0-py27hf484d3e_0.conda": { + "build": "py27hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "09deecd7a5fbab1e61c9f9fad43ccec2", + "name": "thrift", + "sha256": "cd22b53a98dfdcf72aa34b67695161be508919ff6f81a36ebdfd9c0400e52a16", + "size": 104335, + "subdir": "linux-64", + "timestamp": 1516905017272, + "version": "0.11.0" + }, + "thrift-0.11.0-py35hf484d3e_0.conda": { + "build": "py35hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "dfe27d12003e8e07a86b9be531239220", + "name": "thrift", + "sha256": "fdf98b1aef3c8d14cfa36b155daa2d38e75c7e7d2f9805cfc656de6f4e7086ad", + "size": 108270, + "subdir": "linux-64", + "timestamp": 1516905032012, + "version": "0.11.0" + }, + "thrift-0.11.0-py36h295c915_0.conda": { + "build": "py36h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "1a570bbe455fb4809fc903d9482c7d80", + "name": "thrift", + "sha256": "6d7a3460b294df75215260801d5a293563bb0647761c328f646e232a08bb3ddf", + "size": 109675, + "subdir": "linux-64", + "timestamp": 1632730693915, + "version": "0.11.0" + }, + "thrift-0.11.0-py36hf484d3e_0.conda": { + "build": "py36hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "0c235f1945e9e0eb777d1c872e5437c0", + "name": "thrift", + "sha256": "bd8a135d76cd32304ab2836a9603115d58789f03b741cab1b96148ce699bd2eb", + "size": 107182, + "subdir": "linux-64", + "timestamp": 1516905032129, + "version": "0.11.0" + }, + "thrift-0.11.0-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "1786d3aba750c0547a9cc683498b88ad", + "name": "thrift", + "sha256": "b8e9cfcc209187cd5fd2138dba93aecec3529ac9c1ff6cb69a6aadaa8f876907", + "size": 108994, + "subdir": "linux-64", + "timestamp": 1632720323493, + "version": "0.11.0" + }, + "thrift-0.11.0-py37hf484d3e_0.conda": { + "build": "py37hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "7b3f3a108ebc97c2ca13bb587e314fb8", + "name": "thrift", + "sha256": "38a4a03528df6a1761d9cdfaa46af316ecd4cc0d5feff401bb60f198eb37cfd9", + "size": 107208, + "subdir": "linux-64", + "timestamp": 1530876507259, + "version": "0.11.0" + }, + "thrift-0.11.0-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "743750f11bfc06dafa00e5b86f26922c", + "name": "thrift", + "sha256": "db08f7ad62b7a6baa316bd46d077579dc0a6214bfabc43c5ba0fedafa8591835", + "size": 110058, + "subdir": "linux-64", + "timestamp": 1632720321664, + "version": "0.11.0" + }, + "thrift-0.11.0-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "cc2537d18f3f8b4de9944f4aaa43fd7d", + "name": "thrift", + "sha256": "9305794c7bd7bef7995bca2348464fca2e733d7977531daae89447816bc2c65b", + "size": 117126, + "subdir": "linux-64", + "timestamp": 1573554770523, + "version": "0.11.0" + }, + "thrift-0.11.0-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "441da7ba76a11a392e6fda66bb4d4aa8", + "name": "thrift", + "sha256": "58a18eeef57ccc4902ee92969e778ea9c86c09360271ea65bbd6d0de5e0c9e70", + "size": 109600, + "subdir": "linux-64", + "timestamp": 1632730671576, + "version": "0.11.0" + }, + "thrift-0.13.0-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "a412d07b3f637978bdd341b1c62d4500", + "name": "thrift", + "sha256": "00622388fbeaa64653c0a84295828e3f8fb4af013bed5a36212f7f2fef560de3", + "size": 257272, + "subdir": "linux-64", + "timestamp": 1640795230941, + "version": "0.13.0" + }, + "thrift-0.13.0-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "3634139b8885d1cd211ee12c0afa9546", + "name": "thrift", + "sha256": "30e96679ecea0bf5ecaf88d2533da718db7d28604ddd901fe96c88861916a1ab", + "size": 121632, + "subdir": "linux-64", + "timestamp": 1613159419918, + "version": "0.13.0" + }, + "thrift-0.13.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "4069d84e46f6c4d6c46cacc897107fc2", + "name": "thrift", + "sha256": "417ee8dee30629bce3bd34463a85e30c8bcfe2fa4b53e97e0668e69658b3e65a", + "size": 121218, + "subdir": "linux-64", + "timestamp": 1582543898912, + "version": "0.13.0" + }, + "thrift-0.13.0-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "16ab26ba265689f820db10b0c61f1060", + "name": "thrift", + "sha256": "a5d4417a78932ffe49aea7ee8c88e7e1c9170ed783e7c6d4f38f3c5fe585b5d1", + "size": 119812, + "subdir": "linux-64", + "timestamp": 1613159419791, + "version": "0.13.0" + }, + "thrift-0.13.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "e669b5d4ebdc6f1d25f2f142abbd9575", + "name": "thrift", + "sha256": "874f95e9d60f821845308dc3bc29d4b217d01a4cd5b58e9f63b30f5cd77a0f28", + "size": 121241, + "subdir": "linux-64", + "timestamp": 1582543855328, + "version": "0.13.0" + }, + "thrift-0.13.0-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "0448c93fbb5cbcc3d0694f44df641749", + "name": "thrift", + "sha256": "e03b3fc8ab5557a91d36e5bcf0ec89751518f15a34c8b5871487a8fc94324fef", + "size": 121556, + "subdir": "linux-64", + "timestamp": 1613159735172, + "version": "0.13.0" + }, + "thrift-0.13.0-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "09e14ffb139af8e66b84aaf80e34c3aa", + "name": "thrift", + "sha256": "ebedd6c7e83cadbab5e8b9a6516a13370f9c8780ac894071109f5ff60dc4b787", + "size": 122559, + "subdir": "linux-64", + "timestamp": 1582543932751, + "version": "0.13.0" + }, + "thrift-0.13.0-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "six >=1.7.2" + ], + "license": "Apache 2.0", + "md5": "f2c00c45b9570de87368e50adec4f860", + "name": "thrift", + "sha256": "1d736dd198b64aeb5bccf4cf6c486500ae6d0b34c840cff32174817a21da72b5", + "size": 121484, + "subdir": "linux-64", + "timestamp": 1613159282027, + "version": "0.13.0" + }, + "thrift-0.15.0-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "six >=1.7.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "9afabda8ebfb7c8539c21391df3043e4", + "name": "thrift", + "sha256": "559e7d82d64741de355b3227835337510facb5c6f5252202604fd643a05b6c26", + "size": 257840, + "subdir": "linux-64", + "timestamp": 1655212032799, + "version": "0.15.0" + }, + "thrift-0.15.0-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "six >=1.7.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5dcece6f600a1bc056f598ee735d868c", + "name": "thrift", + "sha256": "ab6bc61b10539473754869f2b218194bc4902cdfd3d7ae32be596dbf01dc6d3e", + "size": 120599, + "subdir": "linux-64", + "timestamp": 1655211961623, + "version": "0.15.0" + }, + "thrift-0.15.0-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "six >=1.7.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6a4b1af06db99372641cd646ece10133", + "name": "thrift", + "sha256": "63026075a402f434c7e13d29508b0cb9e198f5b655c6df038abe48b9fe0e781a", + "size": 121712, + "subdir": "linux-64", + "timestamp": 1655211991146, + "version": "0.15.0" + }, + "thrift-0.15.0-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "six >=1.7.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "329eb12f6659c393ca25a7423f5f1042", + "name": "thrift", + "sha256": "0386ca82ee4b1bcb090de1d1e31317929a1c03137530f8cc76a4db2060c481a4", + "size": 121696, + "subdir": "linux-64", + "timestamp": 1655211929180, + "version": "0.15.0" + }, + "thrift-0.17.0-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0", + "six >=1.7.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "3a193b2144de07391812fd11fbf6f8f9", + "name": "thrift", + "sha256": "3698285172cf0ec37b73adf4ca719fc4b74ab80c26f967a0572bde419d045ded", + "size": 129194, + "subdir": "linux-64", + "timestamp": 1666296565801, + "version": "0.17.0" + }, + "thrift-0.17.0-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "six >=1.7.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6b6fdb3f8102bb7eafa5e9b185fb4b3c", + "name": "thrift", + "sha256": "af35291ebc5379c32231c473370e2db7ee5f6e68a17a80272f0e8a6bee1a5516", + "size": 162630, + "subdir": "linux-64", + "timestamp": 1676846029404, + "version": "0.17.0" + }, + "thrift-0.17.0-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0", + "six >=1.7.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "68334b3b4775bfca77ed8ec34f5056a0", + "name": "thrift", + "sha256": "352131b8afc746f7278d4d53f1656eded6c927c99439177ba4c3097b59d14712", + "size": 127415, + "subdir": "linux-64", + "timestamp": 1666296596771, + "version": "0.17.0" + }, + "thrift-0.17.0-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0", + "six >=1.7.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8d64225143215b343099f766161a6ea6", + "name": "thrift", + "sha256": "d4a87e46e5290d17be762f997a35e33a7029cde64d027ae6dfd62fccfea36acf", + "size": 128272, + "subdir": "linux-64", + "timestamp": 1666296532746, + "version": "0.17.0" + }, + "thrift-0.17.0-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0", + "six >=1.7.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6bffd80dc1458159840f70f8ba8b638b", + "name": "thrift", + "sha256": "2a2b52efbea136e52e90734612bbd83b38a7e51b1834f0ce497dbd6f296fc1c6", + "size": 127847, + "subdir": "linux-64", + "timestamp": 1666296627327, + "version": "0.17.0" + }, + "thrift-0.9.3-py27h14c3975_1.conda": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "58006e6c7a5fb8efc7503218d3e50469", + "name": "thrift", + "sha256": "0a687c0db0c37b946c2225e7b0835c43942fdcd36a33c473dfd7a343ff01d0d0", + "size": 78691, + "subdir": "linux-64", + "timestamp": 1531092229635, + "version": "0.9.3" + }, + "thrift-compiler-0.13.0-hfb8234f_6.conda": { + "build": "hfb8234f_6", + "build_number": 6, + "depends": [ + "libevent", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "libthrift 0.13.0 hfb8234f_6", + "openssl", + "zlib" + ], + "license": "Apache-2.0", + "md5": "e6137a81afe877988c56c8579b57f7db", + "name": "thrift-compiler", + "sha256": "c7431226f1169d75294899dca2a45f5e935cd2cd4a37a4d747af8f6774b0e72d", + "size": 11471389, + "subdir": "linux-64", + "timestamp": 1612012824493, + "version": "0.13.0" + }, + "thrift-compiler-0.14.2-hcc01f38_0.conda": { + "build": "hcc01f38_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libthrift 0.14.2 hcc01f38_0" + ], + "license": "Apache-2.0", + "md5": "6570e3c9c696ca34d707407f10579361", + "name": "thrift-compiler", + "sha256": "12285ff3b83275a5321fe63f52840f9414053a5c94ea0b8992856dc4848edcaa", + "size": 11448563, + "subdir": "linux-64", + "timestamp": 1632847292687, + "version": "0.14.2" + }, + "thrift-compiler-0.15.0-hcc01f38_0.conda": { + "build": "hcc01f38_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "libthrift 0.15.0 hcc01f38_0" + ], + "license": "Apache-2.0", + "md5": "306b04c32e55b4affa784eab86373c11", + "name": "thrift-compiler", + "sha256": "dc2359c22686fce19383874585754aa75203ffe797979c2b0d6c102dba2af29e", + "size": 11002672, + "subdir": "linux-64", + "timestamp": 1631679373754, + "version": "0.15.0" + }, + "thrift-cpp-0.11.0-h02b749d_3.conda": { + "build": "h02b749d_3", + "build_number": 3, + "depends": [ + "libevent >=2.1.8,<2.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "md5": "31b301e6cf2c7d1929c45640995f2b1a", + "name": "thrift-cpp", + "sha256": "d2ba10bf4756c1668c96100720e16e0d8bb1e94dce44c351c1717ff4e24b5be2", + "size": 1988046, + "subdir": "linux-64", + "timestamp": 1540475166474, + "version": "0.11.0" + }, + "thrift-cpp-0.11.0-hc04171f_3.conda": { + "build": "hc04171f_3", + "build_number": 3, + "depends": [ + "libevent >=2.1.8,<2.2.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache 2.0", + "md5": "adb1e3217eb7112d41738d8299f6bec7", + "name": "thrift-cpp", + "sha256": "b0609e9888967cb27e219245981f83c1970021cf2fb2cfeb418671240451ee6b", + "size": 1944655, + "subdir": "linux-64", + "timestamp": 1529362421471, + "version": "0.11.0" + }, + "thrift-cpp-0.13.0-h06a4308_6.conda": { + "build": "h06a4308_6", + "build_number": 6, + "depends": [ + "libthrift 0.13.0 hfb8234f_6", + "thrift-compiler 0.13.0 hfb8234f_6" + ], + "license": "Apache-2.0", + "md5": "82b2807bfedb5a80bbb4eed82534aaac", + "name": "thrift-cpp", + "sha256": "f6ba3ecf069bb29cdc0a0e74d7d2fc6b4f8b208505dc73a29586a01d7f233623", + "size": 14325, + "subdir": "linux-64", + "timestamp": 1612012840379, + "version": "0.13.0" + }, + "thrift-cpp-0.13.0-hf7127d7_3.conda": { + "build": "hf7127d7_3", + "build_number": 3, + "constrains": [ + "boost-cpp >=1.67.0,<1.68.0a0" + ], + "depends": [ + "libevent >=2.1.8,<2.2.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "openssl >=1.1.1g,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Apache-2.0", + "md5": "fb24d05d8cfcc6d16e8ae1af6b42e166", + "name": "thrift-cpp", + "sha256": "7adb57b2f856337e0bcb238cd48841509f5f2ded16d4b9cc0eb02a10e241e856", + "size": 14050357, + "subdir": "linux-64", + "timestamp": 1599760830466, + "version": "0.13.0" + }, + "thrift-cpp-0.14.2-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libthrift 0.14.2 hcc01f38_0", + "thrift-compiler 0.14.2 hcc01f38_0" + ], + "license": "Apache-2.0", + "md5": "08f4d498361387712d7ee4e98ec158a5", + "name": "thrift-cpp", + "sha256": "429c05d146c9355dd369a8405597a4791ac32f7815c70476717149fead39daab", + "size": 15277, + "subdir": "linux-64", + "timestamp": 1632847309667, + "version": "0.14.2" + }, + "thrift-cpp-0.15.0-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "libthrift 0.15.0 hcc01f38_0", + "thrift-compiler 0.15.0 hcc01f38_0" + ], + "license": "Apache-2.0", + "md5": "ed75df1d22cfa4c6bc2ed21243c471fe", + "name": "thrift-cpp", + "sha256": "d6d2d55dbdf171403d85c7a26791ff097e6b37b800eadc0279955b19f68d3d47", + "size": 15300, + "subdir": "linux-64", + "timestamp": 1631679389201, + "version": "0.15.0" + }, + "thrift_sasl-0.3.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "sasl >=0.2.1", + "thrift" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5613efa775229b9571afa81a86b825be", + "name": "thrift_sasl", + "sha256": "230c26e48c97cd294c07cd32f17331ec7d758d26381cce4420d9bc743b0a7a91", + "size": 9230, + "subdir": "linux-64", + "timestamp": 1530916984728, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py27h1c006f6_1.conda": { + "build": "py27h1c006f6_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "sasl >=0.2.1", + "thrift" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "df3d2fa0b6d1e87ad0fe847456765fa4", + "name": "thrift_sasl", + "sha256": "a23a7cdb74266580f7ff1c091564f78b23c5a683f7155cb11ed016e7bf6865b9", + "size": 9534, + "subdir": "linux-64", + "timestamp": 1512157933386, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py35h595cfc9_1.conda": { + "build": "py35h595cfc9_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cc865ad4b61b8fcea00cba8c003ad241", + "name": "thrift_sasl", + "sha256": "33786df26e0748f26e17650da7854ddcc7974862667ac9055f1056ec413e5ed3", + "size": 9664, + "subdir": "linux-64", + "timestamp": 1512157933622, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2ce2598334eca7432054bda40733beee", + "name": "thrift_sasl", + "sha256": "e72cdbf71b9fd0b0fd1a0e6c7261719c4873fe2e6c87463d7c4b0150177c87eb", + "size": 9265, + "subdir": "linux-64", + "timestamp": 1530917014954, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5497367b5cc74df081d73eafb4a6fca4", + "name": "thrift_sasl", + "sha256": "db0e65524b58bd481b1a78079b638b3c03e22024a69bfe66049c6a0bcf587d41", + "size": 10475, + "subdir": "linux-64", + "timestamp": 1632738104902, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py36hc03b066_1.conda": { + "build": "py36hc03b066_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b2038cc1a5ce6a76aa5eba38e6507c3f", + "name": "thrift_sasl", + "sha256": "f1eec6389743130b9324d8da7f4a35f3cc0a872843dec7dfe915b53c980671dc", + "size": 9582, + "subdir": "linux-64", + "timestamp": 1512157946073, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c2e48ab80421561dacc1aed64d1aa796", + "name": "thrift_sasl", + "sha256": "4a7ae15a2df81ed16d4a845a438f1f78c5b9a1223df4fae873f29f089b034816", + "size": 9260, + "subdir": "linux-64", + "timestamp": 1530917044111, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a4c7ab3e8ba6e8f7bf0467632d2f1898", + "name": "thrift_sasl", + "sha256": "3e143fe678634f3a2c0b69de68064aad419195c256f4876a14d4e528ec6a87cf", + "size": 10493, + "subdir": "linux-64", + "timestamp": 1632748441752, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d919dd0e9a1e54ef1f7b33f658ac5a6f", + "name": "thrift_sasl", + "sha256": "98c714bf489391fbc2fc4b1e2e124fe388cc304a502471226595666033e2f9bf", + "size": 9721, + "subdir": "linux-64", + "timestamp": 1574153434886, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9851736e0a798773d35adfee02cc3ecc", + "name": "thrift_sasl", + "sha256": "effba61968f061f439525c4dbe277d611f47e8c27f8916cd7b527535cbcd73ca", + "size": 10512, + "subdir": "linux-64", + "timestamp": 1632748089627, + "version": "0.3.0" + }, + "thrift_sasl-0.3.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b4051b8d8d3bf6f351b342c1682c4493", + "name": "thrift_sasl", + "sha256": "dbb00c569f52711eb64cca548e98035926241c226ecb2115dd1ca5e9c033c767", + "size": 10521, + "subdir": "linux-64", + "timestamp": 1632748443209, + "version": "0.3.0" + }, + "thrift_sasl-0.4.2-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "sasl >=0.2.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c671464ceb8348df666dc7a193c8c5d2", + "name": "thrift_sasl", + "sha256": "748919eb586e2a4a9ce1e5f40921804fa95908074ff7c8498e5d5f0e916a91d9", + "size": 9722, + "subdir": "linux-64", + "timestamp": 1640811183520, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "87d4fc71fd2908a2156f2c3030b38d55", + "name": "thrift_sasl", + "sha256": "e25674bfd02cdebd02c7e7bd53ed0dab887d1e2f31dbc38752d84e3d8adbcc6e", + "size": 9701, + "subdir": "linux-64", + "timestamp": 1659877565089, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py311h06a4308_2.conda": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "246a896fa6d015cf4ab655d12861aa26", + "name": "thrift_sasl", + "sha256": "925fcc071a97ce426e5b8db8d32d1acfa2f2c62c015a4cc0172a0f51d83607be", + "size": 11633, + "subdir": "linux-64", + "timestamp": 1676862996470, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e2839662094b89d714b7655de6a470c0", + "name": "thrift_sasl", + "sha256": "9c5057b63d36b11c6de3b86c99562ff004112f11a02684c0ef979df7b1d60a36", + "size": 9749, + "subdir": "linux-64", + "timestamp": 1600708663695, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "eabb5bbb072d7a369878bd196160b492", + "name": "thrift_sasl", + "sha256": "46cca7cda0045d377892c329b351e11ffc321189c366293c222fb75476e0a281", + "size": 10749, + "subdir": "linux-64", + "timestamp": 1632736749606, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e17de97740a80bc78b4a8017fec6a787", + "name": "thrift_sasl", + "sha256": "8c16807e29e9fa33dbe6f70d6f223c6b6f39e9bd67b2160474208a1d67653084", + "size": 9761, + "subdir": "linux-64", + "timestamp": 1600708661315, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bff066a1c7d8648c2776c835f6dbf542", + "name": "thrift_sasl", + "sha256": "d0838616c7f3aa7ae1aa5dcfc3371d5f32c2853ec0dbbc1f6133fa2c625b43af", + "size": 10771, + "subdir": "linux-64", + "timestamp": 1632736731976, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4513003e83042ca97ee9ebfcb2e16cae", + "name": "thrift_sasl", + "sha256": "307e2899b994dc53b1de00b1345c296dcb622e20195c9937483b855a88c10118", + "size": 9619, + "subdir": "linux-64", + "timestamp": 1659877529352, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9e7b8e7729545ca24035eada212bc024", + "name": "thrift_sasl", + "sha256": "dba96fbc469d5caa3e37454e97251255307ef65441143ab06d8eeacb337ce78c", + "size": 9811, + "subdir": "linux-64", + "timestamp": 1600708640549, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "22a9e106d24b5b77c4d6e752104fbefa", + "name": "thrift_sasl", + "sha256": "3e883b0de1d78213842707004a389ae07bfa738297d4a90fbd17b3dceab6a65e", + "size": 10786, + "subdir": "linux-64", + "timestamp": 1632726375419, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "afc7e28c855de8710f61f90fa31fe4ea", + "name": "thrift_sasl", + "sha256": "6924de431b2aa4866111a997ac23be29abb12bfa5a5dbe1a037eb00a43aa0bdc", + "size": 9626, + "subdir": "linux-64", + "timestamp": 1659877587470, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0da2cd6d4b4c4588de169fda22f1a365", + "name": "thrift_sasl", + "sha256": "55e67c84ccdc1b1d834ad544f4c06ea1ab72784c6590f7849492c1c79ba4a20e", + "size": 10798, + "subdir": "linux-64", + "timestamp": 1632735864754, + "version": "0.4.2" + }, + "thrift_sasl-0.4.2-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0", + "sasl >=0.2.1", + "thrift >=0.10" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1ddd9118e649031f2f36b993e6333f85", + "name": "thrift_sasl", + "sha256": "5ca3bb8753cd53f13d2c581f52eedcadc5994da698bf7b6fee34384aa50c93f9", + "size": 9624, + "subdir": "linux-64", + "timestamp": 1659877503951, + "version": "0.4.2" + }, + "thriftpy-0.3.9-py27h14c3975_1.conda": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "ply >=3.4,<4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0db287a4c3b82dd0dadccc923c46e11d", + "name": "thriftpy", + "sha256": "5fd2997f176cc523b29bfd0e4c5e1c065110b7c6c9417c39c2503c75cb448150", + "size": 193597, + "subdir": "linux-64", + "timestamp": 1522783665107, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py27h14c3975_2.conda": { + "build": "py27h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "ply >=3.4,<4.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0c0f2b93cde2b251ecbc18a5aa425ea", + "name": "thriftpy", + "sha256": "44e16cba22c7b23a0078ada1ccb36cbf96f86f7cfe1c453efcdf1e4963834205", + "size": 194328, + "subdir": "linux-64", + "timestamp": 1530893336549, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py310h7f8727e_2.conda": { + "build": "py310h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "ply >=3.4,<4.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "54e49fe5e5800926b1683ccd7b09b030", + "name": "thriftpy", + "sha256": "a3bb99311c70864607f3cd2fd02f906b5ae1560825f3284db9f82f099a8fc8f4", + "size": 536981, + "subdir": "linux-64", + "timestamp": 1640811216509, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py35h14c3975_1.conda": { + "build": "py35h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "ply >=3.4,<4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f20822e48efa5935b3cdc2546bf361d5", + "name": "thriftpy", + "sha256": "d5468a362682d9e275fc5c8f2fb00fbc3eada12fa2800cef6ef7e94a5f4739a2", + "size": 198575, + "subdir": "linux-64", + "timestamp": 1522783982496, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py36h14c3975_1.conda": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "ply >=3.4,<4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d9abfaf304ba745e1dbd3657ff6f4ec", + "name": "thriftpy", + "sha256": "9490b12547cb5d28bff6f9462d2fde2e5231b42f28015769b631551b541c1ff1", + "size": 199069, + "subdir": "linux-64", + "timestamp": 1522783982857, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py36h14c3975_2.conda": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "ply >=3.4,<4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ced2db2f12d06aac5b794095a8356d5e", + "name": "thriftpy", + "sha256": "7e5783141fd4d81a7c9a2c783def6278967fade27ca8da10ec2a32b8fec84b11", + "size": 198883, + "subdir": "linux-64", + "timestamp": 1530893293779, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py36h27cfd23_2.conda": { + "build": "py36h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a1444b40bb9b6f35dd9870f768c5e5a", + "name": "thriftpy", + "sha256": "7ac045bd533cee3ec3de559dc78c60935852a73389ed8b3cff10b0de7b2c5646", + "size": 189896, + "subdir": "linux-64", + "timestamp": 1613383673645, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py36h7f8727e_2.conda": { + "build": "py36h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "ply >=3.4,<4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b3188ad9311e462f4c27bd496f703625", + "name": "thriftpy", + "sha256": "cd1cd680d448852569ec7666950b7ec4e9f60a5a626d925f0301ae0cedc15ad6", + "size": 190131, + "subdir": "linux-64", + "timestamp": 1632730393551, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py37h14c3975_2.conda": { + "build": "py37h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "ply >=3.4,<4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22aad93324912964dfccd05a0bde2726", + "name": "thriftpy", + "sha256": "6fde794257c339eab1ea3c0de37636d57eecb5cc9ae95175bf8fbf42e7c2980e", + "size": 198907, + "subdir": "linux-64", + "timestamp": 1530893249844, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py37h27cfd23_2.conda": { + "build": "py37h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a518a625d1b2a366ae80d062377414eb", + "name": "thriftpy", + "sha256": "8dc96ce21be5c25421f82e5cce4aa8167c1220699825003fd344cbe0510166bf", + "size": 187765, + "subdir": "linux-64", + "timestamp": 1613383673072, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py37h7f8727e_2.conda": { + "build": "py37h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "ply >=3.4,<4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f0fa5ef06bd6e9307347c95642369cb7", + "name": "thriftpy", + "sha256": "fa19384dfe4e5eeab660732eed8ba854a254ebbc5b1df3f0536bc12a3eb8b190", + "size": 189908, + "subdir": "linux-64", + "timestamp": 1632730678400, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py38h27cfd23_2.conda": { + "build": "py38h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c84e57654785d7f62b7aa908061367d", + "name": "thriftpy", + "sha256": "ab3417e724412aac3bda6a9d0327e40a14e3223fa4bf606e9f9d05a05eb6bfcf", + "size": 193931, + "subdir": "linux-64", + "timestamp": 1613383689536, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py38h7b6447c_2.conda": { + "build": "py38h7b6447c_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7721dbdf88608e027c01fa260e88fdf7", + "name": "thriftpy", + "sha256": "8846367cc8fa6a8bd43e8b03b58d0cbd51c2168aa128631a1447b1fc78476280", + "size": 203539, + "subdir": "linux-64", + "timestamp": 1573554803884, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py38h7f8727e_2.conda": { + "build": "py38h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "ply >=3.4,<4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "407b9ffebaf9adb1450ca5f0ed068e0b", + "name": "thriftpy", + "sha256": "f7bf06ad10e0f40261bd1111336474eb775d6e89530631b870453aa0bc2084e5", + "size": 195531, + "subdir": "linux-64", + "timestamp": 1632730675043, + "version": "0.3.9" + }, + "thriftpy-0.3.9-py39h7f8727e_2.conda": { + "build": "py39h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "ply >=3.4,<4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa5ec2ae4760a6e1d92565cceef87c09", + "name": "thriftpy", + "sha256": "f2d230076275ff066eb8146eff96004e6cfca1f5010e3dc3babfb0a4efa01a99", + "size": 194625, + "subdir": "linux-64", + "timestamp": 1632730667964, + "version": "0.3.9" + }, + "thriftpy2-0.4.12-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "64ef2fc1a7b24c78c83746de24ce7958", + "name": "thriftpy2", + "sha256": "9ee347bda011bf6fa1126e841e50d3cf4398f4cebff31fec55b56c94a8bddfba", + "size": 294191, + "subdir": "linux-64", + "timestamp": 1606158343671, + "version": "0.4.12" + }, + "thriftpy2-0.4.12-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb5a5842bf5e29627675a36d53fc5cdb", + "name": "thriftpy2", + "sha256": "4102544a3dcfaf3eac710420fbf4f3d248880c9df372837390f39185962c2176", + "size": 295508, + "subdir": "linux-64", + "timestamp": 1606158333836, + "version": "0.4.12" + }, + "thriftpy2-0.4.12-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9c37aaac8faca6db367318395519b88e", + "name": "thriftpy2", + "sha256": "2805a23cfe6c3f93a32100e29ed31a6bafa8c2a82a2f8fe65c833aa38153f8a9", + "size": 302579, + "subdir": "linux-64", + "timestamp": 1606158357471, + "version": "0.4.12" + }, + "thriftpy2-0.4.14-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "ply >=3.4,<4.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c75743c1735a5960fde80db2bcdf201", + "name": "thriftpy2", + "sha256": "9f84222423ad1edf6a2ae5e6652a36a3d4ee49b16959384e3882562f0d6529a5", + "size": 659571, + "subdir": "linux-64", + "timestamp": 1640811249277, + "version": "0.4.14" + }, + "thriftpy2-0.4.14-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4a3a2093247180f1eaf2e13748235db8", + "name": "thriftpy2", + "sha256": "aa1a2494e946574cee56e2789726d2fc3acf8c3a012f7dc02957a7ea0a99824e", + "size": 293154, + "subdir": "linux-64", + "timestamp": 1611259362708, + "version": "0.4.14" + }, + "thriftpy2-0.4.14-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba98bbae6128506f7e02315ae436ba6b", + "name": "thriftpy2", + "sha256": "a092ca771b727257d2620c9aefccd25bf875538dd03eff5de7a8ec645587a833", + "size": 291420, + "subdir": "linux-64", + "timestamp": 1611259332186, + "version": "0.4.14" + }, + "thriftpy2-0.4.14-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "87af10ae2b830d0a18ce6f16ba9df5f5", + "name": "thriftpy2", + "sha256": "54f299499facb0ae034fb61cc6b98a3f4b8bb1bdf9d88339ab3ef89d84afdbd4", + "size": 301201, + "subdir": "linux-64", + "timestamp": 1611259370430, + "version": "0.4.14" + }, + "thriftpy2-0.4.14-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "ply >=3.4,<4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f8748b038b799deca95cc4db773b628", + "name": "thriftpy2", + "sha256": "757fb0ec6bb95f9f5b93d77aa144e59d272af9e81af325d82bad53525818f6b3", + "size": 297238, + "subdir": "linux-64", + "timestamp": 1611259361812, + "version": "0.4.14" + }, + "thriftpy2-0.4.16-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "ply >=3.4,<4.0", + "python >=3.10,<3.11.0a0", + "six 1.15.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0586eb468791e061da9ad312bc06c6a", + "name": "thriftpy2", + "sha256": "33bd38a69c18207a12df805c6704a2957fe718e9a4759388c33f36269bab3e26", + "size": 332394, + "subdir": "linux-64", + "timestamp": 1670627133708, + "version": "0.4.16" + }, + "thriftpy2-0.4.16-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "ply >=3.4,<4.0", + "python >=3.11,<3.12.0a0", + "six 1.15.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8b5604192bf4bccbd81b43ee15b9eb94", + "name": "thriftpy2", + "sha256": "2415f0c4e93389214f84a2c7cb1d967d147ceb298d5fdea7f771702dc0a8a80f", + "size": 341436, + "subdir": "linux-64", + "timestamp": 1676863022144, + "version": "0.4.16" + }, + "thriftpy2-0.4.16-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "ply >=3.4,<4.0", + "python >=3.7,<3.8.0a0", + "six 1.15.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee133f255374a4126832daa86afc06fc", + "name": "thriftpy2", + "sha256": "5cb380373e7aa956fe6aa60eda07fe9fc1a072076e35a4997a749d06843d2446", + "size": 327692, + "subdir": "linux-64", + "timestamp": 1670627167644, + "version": "0.4.16" + }, + "thriftpy2-0.4.16-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "ply >=3.4,<4.0", + "python >=3.8,<3.9.0a0", + "six 1.15.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e7ded9d168061a0887a5c7f67e03d47", + "name": "thriftpy2", + "sha256": "51d922eea8b423e048c4a6c57e81fc8481525356e4a00244d897e2f574948527", + "size": 332861, + "subdir": "linux-64", + "timestamp": 1670627061023, + "version": "0.4.16" + }, + "thriftpy2-0.4.16-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "ply >=3.4,<4.0", + "python >=3.9,<3.10.0a0", + "six 1.15.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "548ce5bad458eed72297a039af797f1f", + "name": "thriftpy2", + "sha256": "47ece3a1d578b44bbb34ffb25fbe3f77bb617df4c0aebaad9631ab96a9575e3c", + "size": 330109, + "subdir": "linux-64", + "timestamp": 1670627099099, + "version": "0.4.16" + }, + "tifffile-0.15.1-py36heb32a55_2.conda": { + "build": "py36heb32a55_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3add09a65f40a69b498b1bfc58db656b", + "name": "tifffile", + "sha256": "bff1074692de77f570a28cf593e5b41a754f1d9532a79f67cb9ba2d45de115ff", + "size": 190001, + "subdir": "linux-64", + "timestamp": 1585222044993, + "version": "0.15.1" + }, + "tifffile-0.15.1-py37heb32a55_2.conda": { + "build": "py37heb32a55_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "93d5197d247e34d65b3107de8d819078", + "name": "tifffile", + "sha256": "87fb943110afbe08b5ed47c7a3d991dfa135d36a9d901d18efc4cfee9dd6812a", + "size": 188587, + "subdir": "linux-64", + "timestamp": 1585221945370, + "version": "0.15.1" + }, + "tifffile-0.15.1-py38heb32a55_2.conda": { + "build": "py38heb32a55_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6fe0c85220c799d3c6b674ee5ea1e943", + "name": "tifffile", + "sha256": "5d91b366117f37c5270997fc484f9670f82affb9fc709ccb131861271c764e28", + "size": 189496, + "subdir": "linux-64", + "timestamp": 1585222039815, + "version": "0.15.1" + }, + "tifffile-2020.10.1-py36hdd07704_2.conda": { + "build": "py36hdd07704_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "29527e80aac6d47abbb98aa27fb54f31", + "name": "tifffile", + "sha256": "77ebabe738039474c6ddf351791b491b468ee88980ce3223320f90b4cea84b94", + "size": 259351, + "subdir": "linux-64", + "timestamp": 1602000690830, + "version": "2020.10.1" + }, + "tifffile-2020.10.1-py37hdd07704_2.conda": { + "build": "py37hdd07704_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c9865f0b7d4b94ffab63ed890d6e9d2b", + "name": "tifffile", + "sha256": "be3c35fa873050ff68fe2346b62a5100d7bc43f53d9d830a9e9b3df84cda5a19", + "size": 253189, + "subdir": "linux-64", + "timestamp": 1602000690760, + "version": "2020.10.1" + }, + "tifffile-2020.10.1-py38hdd07704_2.conda": { + "build": "py38hdd07704_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "686a4f5aa0a9f51a3cee4ce722ce7624", + "name": "tifffile", + "sha256": "57ff695206eb38579997b1a942c4ce5097a5baf4ae754d883b18a46da6b5b684", + "size": 254339, + "subdir": "linux-64", + "timestamp": 1602000718859, + "version": "2020.10.1" + }, + "tifffile-2020.9.22-py36hdd07704_2.conda": { + "build": "py36hdd07704_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9c37d9f5d0ed15f3c38dcc2a393b11fb", + "name": "tifffile", + "sha256": "3373ed4fa1445c6dfd21b2a81d3b164c8d77f5a340c07ce31c14e7ec376e46c9", + "size": 265205, + "subdir": "linux-64", + "timestamp": 1601054171234, + "version": "2020.9.22" + }, + "tifffile-2020.9.22-py37hdd07704_2.conda": { + "build": "py37hdd07704_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "860226c324e8ff7b46b18015bb3e424e", + "name": "tifffile", + "sha256": "992b62f01c1414fa31c72518a4a784da57f56285950908020a6a7c80e839d8e2", + "size": 252886, + "subdir": "linux-64", + "timestamp": 1601054138863, + "version": "2020.9.22" + }, + "tifffile-2020.9.22-py38hdd07704_2.conda": { + "build": "py38hdd07704_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "41a8ed8cd6327095b629296509216c8c", + "name": "tifffile", + "sha256": "db4a3dd326dc20d6da0001ce9b3ddafc71414578280452fc2413d6645dd6c685", + "size": 254077, + "subdir": "linux-64", + "timestamp": 1601054172523, + "version": "2020.9.22" + }, + "tiledb-1.6.3-h1fb8f14_0.conda": { + "build": "h1fb8f14_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "curl", + "libcurl >=7.65.3,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "openssl >=1.1.1d,<1.1.2a", + "tbb 2018.0.5.*", + "tbb >=2018.0.5,<2019.0a0", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.3.7,<1.3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "341ec3d778b386f203a39954b8558db6", + "name": "tiledb", + "sha256": "4868c1801083739e727cfda64b9fd44f217c960863da1dad0282299746d802d1", + "size": 2036562, + "subdir": "linux-64", + "timestamp": 1573499209189, + "version": "1.6.3" + }, + "tiledb-2.2.9-he5ba936_1.conda": { + "build": "he5ba936_1", + "build_number": 1, + "depends": [ + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "openssl >=1.1.1o,<1.1.2a", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b6f8eec5edb293f35ea2fecbe691d9b", + "name": "tiledb", + "sha256": "1b0571f6bd844a2cdf1a3887a9485c36454552ef0ce583aad67484c93ceb4e0c", + "size": 1610533, + "subdir": "linux-64", + "timestamp": 1655304046469, + "version": "2.2.9" + }, + "tiledb-2.2.9-hffe1d7a_0.conda": { + "build": "hffe1d7a_0", + "build_number": 0, + "depends": [ + "aws-sdk-cpp >=1.8.185,<1.8.186.0a0", + "bzip2 >=1.0.8,<2.0a0", + "libcurl >=7.71.1,<8.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "openssl >=1.1.1k,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.4.9,<1.5.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f440aa11d2ba40e9c814639e50ae0096", + "name": "tiledb", + "sha256": "c922ae53417f8c446070d277a44328941a42a21fcd11ff9c3e9df507c5ce4aa5", + "size": 1554123, + "subdir": "linux-64", + "timestamp": 1621648801177, + "version": "2.2.9" + }, + "tiledb-2.3.3-h1132f93_2.conda": { + "build": "h1132f93_2", + "build_number": 2, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libcurl >=7.82.0,<8.0a0", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "openssl >=1.1.1o,<1.1.2a", + "zlib >=1.2.12,<1.3.0a0", + "zstd >=1.5.2,<1.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a09719b29fa4693bc5cb82c0114078dd", + "name": "tiledb", + "sha256": "6c5c53258f379919bd166d970a5dd08d4f16b6eae0dcc6c4e1d71477c6381366", + "size": 2218949, + "subdir": "linux-64", + "timestamp": 1655311366629, + "version": "2.3.3" + }, + "tiledb-2.3.3-hc47dd91_1.conda": { + "build": "hc47dd91_1", + "build_number": 1, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "curl", + "libcurl", + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "openssl >=1.1.1l,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0", + "zstd >=1.5.0,<1.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "913955f1bf9b15c617986f90481a1db4", + "name": "tiledb", + "sha256": "fd0190fe8ea3d38afcd0b70d34f583d70ae8787c4e7a904f50b76bc3d97caa79", + "size": 2223487, + "subdir": "linux-64", + "timestamp": 1636018003654, + "version": "2.3.3" + }, + "tini-0.18.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7126152415d444efc92f76d97b155096", + "name": "tini", + "sha256": "5a156b123abb96ee0f11c43d2cf55b4402d4597cf2b966a5a942072251ec5bb7", + "size": 15046, + "subdir": "linux-64", + "timestamp": 1540504504197, + "version": "0.18.0" + }, + "tini-0.18.0-h7b6447c_1001.conda": { + "build": "h7b6447c_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "03f2d49be21bc286e34f388ba9c7a13c", + "name": "tini", + "sha256": "025f8e8bee18018039855d5025c23705b03c058fcef70dcb2763c03444d433bf", + "size": 12722, + "subdir": "linux-64", + "timestamp": 1603309190592, + "version": "0.18.0" + }, + "tini-0.19.0-h27cfd23_1001.conda": { + "build": "h27cfd23_1001", + "build_number": 1001, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08a4ed24a2b36a97763448e5d2897a68", + "name": "tini", + "sha256": "72b0e4dde5791470ab6395bcbf0593d065cc541cf70c1da9606a3a40db5aeb67", + "size": 12820, + "subdir": "linux-64", + "timestamp": 1606938270229, + "version": "0.19.0" + }, + "tinycss2-1.2.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "webencodings >=0.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1990f924a39d84ab86454934a392bb29", + "name": "tinycss2", + "sha256": "4117e0fe9d8edc9603e59f1c6a5e73f258fe46620e2da83d333d2e4f7f04093f", + "size": 40702, + "subdir": "linux-64", + "timestamp": 1668168931128, + "version": "1.2.1" + }, + "tinycss2-1.2.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "webencodings >=0.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5fa403097ddcd4c08541d97b0d929c8c", + "name": "tinycss2", + "sha256": "78939e6a58787f91c060fb6c19ed126c43ef290b1e3a21933c6dcd0117d26189", + "size": 47598, + "subdir": "linux-64", + "timestamp": 1676823769869, + "version": "1.2.1" + }, + "tinycss2-1.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "webencodings >=0.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8a00f15fa33e66db5fde8dc78cb6ea55", + "name": "tinycss2", + "sha256": "c98f2d9fa05472364f3416d5704a8fb4d373ae57376c674f779a7ded5a4d0d8a", + "size": 40356, + "subdir": "linux-64", + "timestamp": 1668168848549, + "version": "1.2.1" + }, + "tinycss2-1.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "webencodings >=0.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "07287ed30f82911f6bc7e71a040f093d", + "name": "tinycss2", + "sha256": "68565e22dc0a47b5daffcc0e485036b5510e77ee8e7b3f4a84ebba525549d6e2", + "size": 40692, + "subdir": "linux-64", + "timestamp": 1668168903676, + "version": "1.2.1" + }, + "tinycss2-1.2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "webencodings >=0.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cda66d98940bfd8bb311802bf8684fe8", + "name": "tinycss2", + "sha256": "8f849b142b5886fd5371c3cc0892aaf7a7cb5af1e2aa78746b901a92eee23c1f", + "size": 40352, + "subdir": "linux-64", + "timestamp": 1668168876032, + "version": "1.2.1" + }, + "tk-8.6.10-hbc83047_0.conda": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Tcl/Tk", + "license_family": "BSD", + "md5": "9ba14aaba4818a66c820f85f5bf34ca0", + "name": "tk", + "sha256": "99fba40357115be361759731fc5a19b7833b4884310f2851f3faadbf33484991", + "size": 3108365, + "subdir": "linux-64", + "timestamp": 1592503345885, + "version": "8.6.10" + }, + "tk-8.6.11-h1ccaba5_0.conda": { + "build": "h1ccaba5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Tcl/Tk", + "license_family": "BSD", + "md5": "3a4fa2ce7262dc3e8f082a7c25e7451c", + "name": "tk", + "sha256": "1b36e92b1ab7ca2eeca8888e14ae7cffdf376563596882b2b2139ee3ce4be6d7", + "size": 3152224, + "subdir": "linux-64", + "timestamp": 1632504578475, + "version": "8.6.11" + }, + "tk-8.6.11-h1ccaba5_1.conda": { + "build": "h1ccaba5_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "Tcl/Tk", + "license_family": "BSD", + "md5": "5d7d7abe559370a7a8519177929dd338", + "name": "tk", + "sha256": "7b3e90bdd6be37143e32047c0a2f22cd1fee609c3802c5f0affe9d469817a7e8", + "size": 3147223, + "subdir": "linux-64", + "timestamp": 1652087619389, + "version": "8.6.11" + }, + "tk-8.6.12-h1ccaba5_0.conda": { + "build": "h1ccaba5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "TCL", + "license_family": "BSD", + "md5": "fa10ff4aa631fa4aa090a6234d7770b9", + "name": "tk", + "sha256": "566579b236dff05c97b56857a808e192f2b7d420dad728b3d7e95fb553a3ce02", + "size": 3173079, + "subdir": "linux-64", + "timestamp": 1654088939579, + "version": "8.6.12" + }, + "tk-8.6.7-h5979e9b_1.conda": { + "build": "h5979e9b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "Tcl/Tk", + "license_family": "BSD", + "md5": "f5577edbd77b7dd7424a545e8a7622ac", + "name": "tk", + "sha256": "8cb46b53383ba4e39bf804389faa85764ffbcad505b2aa57129cc7786cd2ae30", + "size": 2953237, + "subdir": "linux-64", + "timestamp": 1505666716948, + "version": "8.6.7" + }, + "tk-8.6.7-hc745277_3.conda": { + "build": "hc745277_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "Tcl/Tk", + "license_family": "BSD", + "md5": "c31bcaa8602f952a4fd4f5fffd5d0922", + "name": "tk", + "sha256": "bff767231f1a50548f7ca3f0af03021f888a303694496dc852fb9a41453ef246", + "size": 2953955, + "subdir": "linux-64", + "timestamp": 1510171868737, + "version": "8.6.7" + }, + "tk-8.6.8-hbc83047_0.conda": { + "build": "hbc83047_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "Tcl/Tk", + "license_family": "BSD", + "md5": "4ecf8aae4ac77912de13acb98c562f80", + "name": "tk", + "sha256": "f2844a31d7dc92060c09af984e76288f3f67a919c47d97211528e5989f22fbd8", + "size": 2944603, + "subdir": "linux-64", + "timestamp": 1535485270027, + "version": "8.6.8" + }, + "tktable-2.10-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "tk", + "tk >=8.6.7,<8.7.0a0" + ], + "license": "Tcl/Tk", + "license_family": "BSD", + "md5": "e865c87bd9cc383fa27d99a3404f0a01", + "name": "tktable", + "sha256": "a7cf60cfb53806338ee98ff3740faf948dd4e8005e025ecb49bdf8d886b7262d", + "size": 87970, + "subdir": "linux-64", + "timestamp": 1516268590228, + "version": "2.10" + }, + "tmux-3.3a-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libevent >=2.1.12,<2.1.13.0a0", + "libgcc-ng >=11.2.0", + "ncurses >=6.3,<7.0a0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "7053429403d8775b4e2b3b25b0ff9839", + "name": "tmux", + "sha256": "6c356592982b56b3608ab050292ec0a30aabcbe0890560a53050e7b45996255d", + "size": 434074, + "subdir": "linux-64", + "timestamp": 1661976983585, + "version": "3.3a" + }, + "tokenizers-0.10.3-py310hb317417_1.conda": { + "build": "py310hb317417_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "d7673c7ad3fed35e15fd3275a8713626", + "name": "tokenizers", + "sha256": "2574c28f347eaefa78005edd907e01b9b98bea00e34bcdc2f4279632257150af", + "size": 2502105, + "subdir": "linux-64", + "timestamp": 1640795364755, + "version": "0.10.3" + }, + "tokenizers-0.10.3-py37hb317417_1.conda": { + "build": "py37hb317417_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5e454cfbb4bb57c87b22a041599d62e5", + "name": "tokenizers", + "sha256": "b39c19b46f4c6d2bb1882abbb559e4c78ac3b28c5576d6e5eeb5f9dfe323a829", + "size": 2503116, + "subdir": "linux-64", + "timestamp": 1639594214829, + "version": "0.10.3" + }, + "tokenizers-0.10.3-py38hb317417_1.conda": { + "build": "py38hb317417_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "5078d85f15fc64aa300de4334ec2072b", + "name": "tokenizers", + "sha256": "f5b2f79b1cf3a4ff516504156502f5402c098556529313fcfbeae35461d443ae", + "size": 2486853, + "subdir": "linux-64", + "timestamp": 1639608090910, + "version": "0.10.3" + }, + "tokenizers-0.10.3-py39hb317417_1.conda": { + "build": "py39hb317417_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "aa5fea66d9a3f74ff5f29c42a62b4ed4", + "name": "tokenizers", + "sha256": "a5b5a09a8f3d6ff309b250478afcd6c5087ef544359bfac6f93450c6e49d5afb", + "size": 2484297, + "subdir": "linux-64", + "timestamp": 1639589976032, + "version": "0.10.3" + }, + "tokenizers-0.11.4-py310h3dcd8bd_1.conda": { + "build": "py310h3dcd8bd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1n,<1.1.2a", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d9a150f140c56a3045a22d5106af7b2c", + "name": "tokenizers", + "sha256": "cf729af7c6c52b1e67c9de1a2bceb80a5c618276e200a25add0e7380571a297c", + "size": 3805371, + "subdir": "linux-64", + "timestamp": 1651822814639, + "version": "0.11.4" + }, + "tokenizers-0.11.4-py37h3dcd8bd_1.conda": { + "build": "py37h3dcd8bd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1n,<1.1.2a", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "92de5ae0678c1b9bfa055e4cdc803d01", + "name": "tokenizers", + "sha256": "a9b81d687dbce4c4df96e63cb29033daa3b8152514f19ea0f4b7853f9539f438", + "size": 3805500, + "subdir": "linux-64", + "timestamp": 1651823381002, + "version": "0.11.4" + }, + "tokenizers-0.11.4-py38h3dcd8bd_1.conda": { + "build": "py38h3dcd8bd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1n,<1.1.2a", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f3b4b6d4a3bb86d18c15043681080e8f", + "name": "tokenizers", + "sha256": "205454ea4dfb234535509a4895025df6711944d4bec382357835eac7338a6811", + "size": 3804969, + "subdir": "linux-64", + "timestamp": 1651823004030, + "version": "0.11.4" + }, + "tokenizers-0.11.4-py39h3dcd8bd_1.conda": { + "build": "py39h3dcd8bd_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "openssl >=1.1.1n,<1.1.2a", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "131830bce392e921c49739c8eeca2e0e", + "name": "tokenizers", + "sha256": "7206c30880a83e9c03486f1531a9a9fbafc855180b2478b9863ba0035b91ef79", + "size": 3818766, + "subdir": "linux-64", + "timestamp": 1651823192997, + "version": "0.11.4" + }, + "tokenizers-0.13.2-py311he7d60b5_0.conda": { + "build": "py311he7d60b5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "openssl >=1.1.1t,<1.1.2a", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a0c3c16ced4f126379cf164f0cc513df", + "name": "tokenizers", + "sha256": "92cdc6c13490d3362f7641073fb807ecd8955a61bd340a256ed57510d0bdf3f7", + "size": 3776054, + "subdir": "linux-64", + "timestamp": 1676863258866, + "version": "0.13.2" + }, + "toml-0.10.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "068491659d3ae945bad5cb6d29ed8701", + "name": "toml", + "sha256": "db629876928bfa9e09db3900cc1667ab3e3007a685bdabc64d3b4796cfd5add4", + "size": 30701, + "subdir": "linux-64", + "timestamp": 1539658616996, + "version": "0.10.0" + }, + "toml-0.10.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "546415380524d2a29248b96b6cd907d5", + "name": "toml", + "sha256": "a49fc72905372d4104bf09bf677fcbae21f4885e5d5bec92b3a39cdb16eae890", + "size": 30578, + "subdir": "linux-64", + "timestamp": 1539658632793, + "version": "0.10.0" + }, + "toml-0.10.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3db9b3e941269c0fd04c6c538d074c7a", + "name": "toml", + "sha256": "598b7be452c4270f74084f4ef78a1fd6ff4e770162c9575cbf85dd0f8966a388", + "size": 30524, + "subdir": "linux-64", + "timestamp": 1539658632727, + "version": "0.10.0" + }, + "toml-0.9.4-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f673822c140a9dd112258b4d52a763c1", + "name": "toml", + "sha256": "18d67aacc536ca17ed46b5b47907ae27eee8fbdce22050b62cbc2de6fa63d623", + "size": 23026, + "subdir": "linux-64", + "timestamp": 1538441034633, + "version": "0.9.4" + }, + "toml-0.9.4-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e945f3d49907f0fe0f68fcf2a6c4c1d0", + "name": "toml", + "sha256": "e83815f4835e7c0f21adc1efd43b99593e3cb771bd75a64970bb1a8b717db104", + "size": 22880, + "subdir": "linux-64", + "timestamp": 1529945187865, + "version": "0.9.4" + }, + "toml-0.9.4-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e410a95d6457d70c94eeabbe6f9da3e", + "name": "toml", + "sha256": "c6218d9988bda12b123724042f600422e0fcee62f80413f512024a91f9839ca4", + "size": 22728, + "subdir": "linux-64", + "timestamp": 1538441062629, + "version": "0.9.4" + }, + "toml-0.9.4-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6099876d70aaec1e06acd9f3d27e4bf3", + "name": "toml", + "sha256": "601ae0e36e891aa00135d081961e747c8f55d22f26e0de3cce709b8323760246", + "size": 22642, + "subdir": "linux-64", + "timestamp": 1538441035591, + "version": "0.9.4" + }, + "tomli-2.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16e032c58fc284838f0e0b42f03d5a1d", + "name": "tomli", + "sha256": "6b5e4ba8b657f7a9f7b4b2092e7cbe200c1b738612424ca1a083821a047cadce", + "size": 24985, + "subdir": "linux-64", + "timestamp": 1657175627477, + "version": "2.0.1" + }, + "tomli-2.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b1787e56292de337d520850f1270a4e", + "name": "tomli", + "sha256": "d8f729cc8c67dae6b6400786df5195c43e8b8d8d9151385d05887388e997d467", + "size": 31209, + "subdir": "linux-64", + "timestamp": 1676822672777, + "version": "2.0.1" + }, + "tomli-2.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "81afc585a071606904e85a8a0eb923aa", + "name": "tomli", + "sha256": "32ded6df396588870196940c31e1e8a0d93de0f666d51cd430ca49a30b01145a", + "size": 24772, + "subdir": "linux-64", + "timestamp": 1657175535077, + "version": "2.0.1" + }, + "tomli-2.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "791cce9de9913e9587b0a85cd8419123", + "name": "tomli", + "sha256": "85b8bde324997e1457e6f177c39ce0defa8e83ea5205d1a959773cb6f0026b6c", + "size": 24838, + "subdir": "linux-64", + "timestamp": 1657175559684, + "version": "2.0.1" + }, + "tomli-2.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b06dffe7ddca2645ed72f5116f0a087d", + "name": "tomli", + "sha256": "fecb648c12654f39b78ca2f2c1b76e4308dbb577d3c9daf4e5f0290e2afd48e7", + "size": 24873, + "subdir": "linux-64", + "timestamp": 1657175588674, + "version": "2.0.1" + }, + "tomlkit-0.11.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "57817e6c50d597a40051c405d7dd7296", + "name": "tomlkit", + "sha256": "9a3ce729c6597adaed98a83387124c6faa2ca763c7fef1cfd852055407a725aa", + "size": 74353, + "subdir": "linux-64", + "timestamp": 1658946924024, + "version": "0.11.1" + }, + "tomlkit-0.11.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "228269d1129fda28fae98ac736bc7a7e", + "name": "tomlkit", + "sha256": "258b4ad8892dacb49867f8624f9dd6a32570163c9075b869c4f06c3802601065", + "size": 102514, + "subdir": "linux-64", + "timestamp": 1676823231205, + "version": "0.11.1" + }, + "tomlkit-0.11.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "737c438620aa2c369ab07b7d07ea40de", + "name": "tomlkit", + "sha256": "de9b7eee2a023b501c642e46a69924fad5e59e90c38411c8bdd34f1b70da5c2b", + "size": 72954, + "subdir": "linux-64", + "timestamp": 1658947001425, + "version": "0.11.1" + }, + "tomlkit-0.11.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "582da13897867f94585b16b0e4e7c207", + "name": "tomlkit", + "sha256": "971a3339642328b5d40c5c95c60c6b907c5519ba58491bee2de13c90c00707bf", + "size": 73459, + "subdir": "linux-64", + "timestamp": 1658946974368, + "version": "0.11.1" + }, + "tomlkit-0.11.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a69ba3834a440ad22846c99cccff4cc3", + "name": "tomlkit", + "sha256": "964ea6424066d2b0d8055d3a93520cccedabf7592e841fc1099756ea5621323c", + "size": 73351, + "subdir": "linux-64", + "timestamp": 1658946949354, + "version": "0.11.1" + }, + "tomlkit-0.5.11-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9fd61709c2edcf4a8ecd667ddd161cb0", + "name": "tomlkit", + "sha256": "b6f199000fdc292eae2f00d834661801a8a2d29b28e9d5a485681e94eed81b9b", + "size": 122885, + "subdir": "linux-64", + "timestamp": 1594840933949, + "version": "0.5.11" + }, + "tomlkit-0.5.11-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6ff8298c6ffcaf1826ec2997fb176fe2", + "name": "tomlkit", + "sha256": "bd136bfa17432d61a23a1b13bd7237e7c6395199b1101095a3e43c3b0656a948", + "size": 121787, + "subdir": "linux-64", + "timestamp": 1594843395234, + "version": "0.5.11" + }, + "tomlkit-0.5.11-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c888c879dd0eb6e106d0831cc2b10f9e", + "name": "tomlkit", + "sha256": "e320cde727c7e2955511d790bbf2397b7b10f7d33701570e3b486679bbe70b3a", + "size": 123811, + "subdir": "linux-64", + "timestamp": 1594843397985, + "version": "0.5.11" + }, + "tomlkit-0.5.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "enum34 >=1.1,<2.0", + "functools32 >=3.2.3,<4.0.0", + "python >=2.7,<2.8.0a0", + "typing >=3.6,<4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5fbbf1cc5294fe0ff603536d45556ec7", + "name": "tomlkit", + "sha256": "8300a2a277cf53dffad2c72b1b498433870a0c9269ec4864449430822879114a", + "size": 118184, + "subdir": "linux-64", + "timestamp": 1579614712585, + "version": "0.5.8" + }, + "tomlkit-0.5.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "537ce395166a5a8570365d3203032977", + "name": "tomlkit", + "sha256": "712b7aaf975f1ee04e335986cf66e2e614e5009852bf51da8bdc632d217ca409", + "size": 118777, + "subdir": "linux-64", + "timestamp": 1579614787545, + "version": "0.5.8" + }, + "tomlkit-0.5.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9fd97938b7d1b9b55353b8f3f8e6d820", + "name": "tomlkit", + "sha256": "93a4455b08ac12f0a9ae71cba0749afcb68d66e950210b01e6a5b334abcecfb2", + "size": 118891, + "subdir": "linux-64", + "timestamp": 1579614611657, + "version": "0.5.8" + }, + "tomlkit-0.5.8-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "82a07726b19c5ddfe3188d1ce95f708d", + "name": "tomlkit", + "sha256": "60c4d8ede0d2556a769664e83299e97f65d10debd68ef723cd81db1b4523d11d", + "size": 119678, + "subdir": "linux-64", + "timestamp": 1579614672367, + "version": "0.5.8" + }, + "tomlkit-0.6.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1360c8b65e83c7b698d0d4e3ec5d21fd", + "name": "tomlkit", + "sha256": "9f4e4686d4c2e644d67594d6dcaaf5bad9f7acea5d8feca1fedb340d0a20b4e4", + "size": 123734, + "subdir": "linux-64", + "timestamp": 1594851845683, + "version": "0.6.0" + }, + "tomlkit-0.6.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8fa0d2755d390f84277aebc94df3fb4", + "name": "tomlkit", + "sha256": "3eeea4c11597002223c93eec8cd611aef8872f7c36750b1eee323a1380c3d585", + "size": 123716, + "subdir": "linux-64", + "timestamp": 1594851846600, + "version": "0.6.0" + }, + "tomlkit-0.6.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "97603a3323f83af7ca4d786e69f1bec0", + "name": "tomlkit", + "sha256": "813194c0546722c7588a49db6a18d7d6ccaeb41e4b1dd754b4870047392997b1", + "size": 124212, + "subdir": "linux-64", + "timestamp": 1594851859186, + "version": "0.6.0" + }, + "tomlkit-0.7.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3411c1f00beb864c93b4329f6d33faf7", + "name": "tomlkit", + "sha256": "78b84cf2abeeeaa1b77b2d065a71d6b8287d9ee349022dfb6cd72e174387290c", + "size": 176896, + "subdir": "linux-64", + "timestamp": 1640795389093, + "version": "0.7.0" + }, + "tomlkit-0.7.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c6ce4d10b592a779a64713e06a4db552", + "name": "tomlkit", + "sha256": "3ef0908ee656aa09c1c790a47fe58070adb3c9d0c5d35289b7333188de744c3f", + "size": 177549, + "subdir": "linux-64", + "timestamp": 1605814657419, + "version": "0.7.0" + }, + "tomlkit-0.7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "93877ebce6648fb74f7edeef920e06fa", + "name": "tomlkit", + "sha256": "13ed038606b530930e1ba1034fb4c1026f9da795154211802e5a59795a635f9b", + "size": 175728, + "subdir": "linux-64", + "timestamp": 1597076541588, + "version": "0.7.0" + }, + "tomlkit-0.7.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "97a3313d12bccadce70b0e3d46b43205", + "name": "tomlkit", + "sha256": "d171b71f52c62c4efabb02d29bbfefe1f9bbfa6586e70aeaa4b32ece4ae6a311", + "size": 179573, + "subdir": "linux-64", + "timestamp": 1605814647341, + "version": "0.7.0" + }, + "tomlkit-0.7.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce37742e9b8fc25e9030cbb545a42885", + "name": "tomlkit", + "sha256": "ab600d5282cf284d2079c814902e2a16b8d365cdcfcee344b67e98fd8ec83b70", + "size": 179563, + "subdir": "linux-64", + "timestamp": 1605814639309, + "version": "0.7.0" + }, + "tomlkit-0.7.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3481c27897dd8da84b29f115ca6e72c2", + "name": "tomlkit", + "sha256": "41e5c84c8c22081bf1255318475c93a6660d17038569b4b643d8b95d134cd40c", + "size": 178969, + "subdir": "linux-64", + "timestamp": 1605814632821, + "version": "0.7.0" + }, + "tomlkit-0.7.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "704747f2678352fee1861e747f219c13", + "name": "tomlkit", + "sha256": "dea217534767899be7466979951a9fb8f139af00a0889c194031870e16f4b11f", + "size": 62723, + "subdir": "linux-64", + "timestamp": 1626771250883, + "version": "0.7.2" + }, + "tomlkit-0.7.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff0af4ceae530267e6b0d63babaa6289", + "name": "tomlkit", + "sha256": "7e2138bc23a09358beed579bb72ce7a69641c78fcd71e095ca6432057232a051", + "size": 63162, + "subdir": "linux-64", + "timestamp": 1626770940375, + "version": "0.7.2" + }, + "tomlkit-0.7.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d1f349ab6621615fab273ad8969c78ec", + "name": "tomlkit", + "sha256": "3de26a92801dfd0b06d17cef75c06f8ba77e02379cf2c57e864e43b003df8f0a", + "size": 63521, + "subdir": "linux-64", + "timestamp": 1626763896163, + "version": "0.7.2" + }, + "tomlkit-0.7.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8b9feb5f2867e7a7ffb54dca3c0310ba", + "name": "tomlkit", + "sha256": "c6fe2e6a864ad7ce83e1866c19591e96785c0926f61c5bf45567239768f8d17f", + "size": 62979, + "subdir": "linux-64", + "timestamp": 1626771240765, + "version": "0.7.2" + }, + "toolchain-2.4.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "BSD 3-Clause", + "md5": "7f86c9138830d4aeafcb87b70064bd24", + "name": "toolchain", + "sha256": "82b2954bfdfe2497709576a6ef193bf482d6341a7e659eb907bfb1d67275d46b", + "size": 14449, + "subdir": "linux-64", + "timestamp": 1565097658074, + "version": "2.4.0" + }, + "toolchain_c_linux-64-2.4.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "toolchain 2.4.0 0" + ], + "license": "BSD 3-Clause", + "md5": "71929b7fabd1154c97cbf82957624128", + "name": "toolchain_c_linux-64", + "sha256": "b7560f82f3c9a59278dc7c40e43da9302066312cd7e81b8f93ceda75297018af", + "size": 13813, + "subdir": "linux-64", + "timestamp": 1565097666416, + "version": "2.4.0" + }, + "toolchain_cxx_linux-64-2.4.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "toolchain 2.4.0 0" + ], + "license": "BSD 3-Clause", + "md5": "6f0126f0c224c25ac6be1d94d5b51dbc", + "name": "toolchain_cxx_linux-64", + "sha256": "7f9c10e531efb7f5daefa5aa9b57d092088430188c52ec496ec3d0b42296bcff", + "size": 13810, + "subdir": "linux-64", + "timestamp": 1565097679165, + "version": "2.4.0" + }, + "toolchain_fort_linux-64-2.4.0-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "toolchain 2.4.0 0" + ], + "license": "BSD 3-Clause", + "md5": "9485617c158e68b591fae91c59a1185b", + "name": "toolchain_fort_linux-64", + "sha256": "576247871c4fa521c6534f9ed53108526b4120a02125a3cc07eee303f5a29695", + "size": 13822, + "subdir": "linux-64", + "timestamp": 1565097687641, + "version": "2.4.0" + }, + "toolz-0.12.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "42aa6106f340ea2ec4f0d5040850f1f6", + "name": "toolz", + "sha256": "631ed97ce0fd8c977bfdf310e12079eacb02f2fac8933c9e9f5b1718c7473474", + "size": 110131, + "subdir": "linux-64", + "timestamp": 1667464115489, + "version": "0.12.0" + }, + "toolz-0.12.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c1fbef357130d8520fabf9897acac572", + "name": "toolz", + "sha256": "e9a94c4e5f31f4fc3fbe73399a90adc8e3aa266433d51572c798471c6a55dbc6", + "size": 138509, + "subdir": "linux-64", + "timestamp": 1676827536101, + "version": "0.12.0" + }, + "toolz-0.12.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5bb1800e5e7336aa9fdea25c70f57799", + "name": "toolz", + "sha256": "c70ace8cc80b5d86c2b4f777eb80e1635757d12226b4b30feed2be1ce23dc89f", + "size": 106820, + "subdir": "linux-64", + "timestamp": 1667464143922, + "version": "0.12.0" + }, + "toolz-0.12.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "42dd37c3e640122c5187b5581ccebd68", + "name": "toolz", + "sha256": "084c448b368b5321b5e4bb8cae84659cc036062157c9e61523b62c10dd632819", + "size": 107475, + "subdir": "linux-64", + "timestamp": 1667464200465, + "version": "0.12.0" + }, + "toolz-0.12.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d53376d46a25d1926853267af7b26c18", + "name": "toolz", + "sha256": "34e4c1c1ee9a02201e985e0a82a0d1ace3a6867e387466bfad2e780cbd9c8280", + "size": 107333, + "subdir": "linux-64", + "timestamp": 1667464172523, + "version": "0.12.0" + }, + "toolz-0.8.2-py27hd3b1e7e_0.conda": { + "build": "py27hd3b1e7e_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "783b0f56fd307c38471cdf2e1a8fbe1a", + "name": "toolz", + "sha256": "159fa2dccc57af0fe5c0e4fcb5580c907bd02dd587b34b75b366ac16ea78eb37", + "size": 93618, + "subdir": "linux-64", + "timestamp": 1505732776961, + "version": "0.8.2" + }, + "toolz-0.8.2-py35h90f1797_0.conda": { + "build": "py35h90f1797_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cff71fc9cd5a65bb5bcf8b05ec62f3ac", + "name": "toolz", + "sha256": "00ccd5183f1605ec0b95b1f6f7d08ea5b96d2d73826748f3e8bf070664f96d70", + "size": 95385, + "subdir": "linux-64", + "timestamp": 1505732789990, + "version": "0.8.2" + }, + "toolz-0.8.2-py36h81f2dff_0.conda": { + "build": "py36h81f2dff_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "13a3f6358d2c32e5a9c8ebae8d99f07b", + "name": "toolz", + "sha256": "88db41984ac19e18c1b5b794b760efbb210c175f29c60edf17ac181e153b585f", + "size": 93932, + "subdir": "linux-64", + "timestamp": 1505732803222, + "version": "0.8.2" + }, + "toolz-0.9.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ef95cf27ed27b1d1bb918c80ed42281c", + "name": "toolz", + "sha256": "d0af011846d33de0b69c91009544572e3adf6e33131c4d4786a0e02dd9d2cfdc", + "size": 95440, + "subdir": "linux-64", + "timestamp": 1515709467803, + "version": "0.9.0" + }, + "toolz-0.9.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "efecd1373d70134fd9118cfea052f8c5", + "name": "toolz", + "sha256": "24f3d4676c62caa646c36164a76985099e41fdb4f9668c43e634f42ddd08fc70", + "size": 96973, + "subdir": "linux-64", + "timestamp": 1515709579065, + "version": "0.9.0" + }, + "toolz-0.9.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "22ef895aeb830fa173838e885d54515b", + "name": "toolz", + "sha256": "020ac7a9c0404f438b6c6993e6fcfa568c19a05aa1ffefdf317d013de72c9124", + "size": 95339, + "subdir": "linux-64", + "timestamp": 1515709381763, + "version": "0.9.0" + }, + "toolz-0.9.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "e449dff86b0c564096a7dcaaa791f109", + "name": "toolz", + "sha256": "2a46c0073eef80b4ec166b85e7d3955b5358d40780eb08e0cf6bf0a5718a510b", + "size": 93964, + "subdir": "linux-64", + "timestamp": 1530741263341, + "version": "0.9.0" + }, + "torchmetrics-0.11.2-py310h2f386ee_0.conda": { + "build": "py310h2f386ee_0", + "build_number": 0, + "depends": [ + "numpy >=1.17.2", + "packaging", + "python >=3.10,<3.11.0a0", + "pytorch >=1.8.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7e24a69ac9b0627b40ca119a8beb1102", + "name": "torchmetrics", + "sha256": "0a57bfe912f4b9c22ff8ea4b8b7b842098a9567e78ffa44c609d39a141396cd9", + "size": 439490, + "subdir": "linux-64", + "timestamp": 1677573127146, + "version": "0.11.2" + }, + "torchmetrics-0.11.2-py37hb070fc8_0.conda": { + "build": "py37hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy >=1.17.2", + "packaging", + "python >=3.7,<3.8.0a0", + "pytorch >=1.8.1", + "typing-extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1c28e5e4dc2784739fa7d35d649ff3d7", + "name": "torchmetrics", + "sha256": "4a9af52b921e80b6078e0761b18fea117e57b469b2e18d84ba2f90f44a76cfda", + "size": 432605, + "subdir": "linux-64", + "timestamp": 1677573083886, + "version": "0.11.2" + }, + "torchmetrics-0.11.2-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy >=1.17.2", + "packaging", + "python >=3.8,<3.9.0a0", + "pytorch >=1.8.1", + "typing-extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5b60d72edc800bd2d2d29dcb0a9e91c5", + "name": "torchmetrics", + "sha256": "fc26157a5cc61acc2b938c318334188a1bfb20e84feba4fe357a035d8f656564", + "size": 435315, + "subdir": "linux-64", + "timestamp": 1677572997721, + "version": "0.11.2" + }, + "torchmetrics-0.11.2-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "depends": [ + "numpy >=1.17.2", + "packaging", + "python >=3.9,<3.10.0a0", + "pytorch >=1.8.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ebb1b982f49b37d5e46f31c97338a85b", + "name": "torchmetrics", + "sha256": "d9ed7e4371481d210c229aa4bd060f22bde81483370d9faa5975f3657e7a8489", + "size": 434921, + "subdir": "linux-64", + "timestamp": 1677573040747, + "version": "0.11.2" + }, + "torchvision-0.11.3-cpu_py310h164cc8f_1.conda": { + "build": "cpu_py310h164cc8f_1", + "build_number": 1, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.10,<3.11.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "331c632be0419c8cf785986970ef29ea", + "name": "torchvision", + "sha256": "aaefad55577d6f66eee62d7c17a17cd178be741d88582aa79885d0af3105b45f", + "size": 17295160, + "subdir": "linux-64", + "timestamp": 1665040691898, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py310h164cc8f_2.conda": { + "build": "cpu_py310h164cc8f_2", + "build_number": 2, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.10,<3.11.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dce8e54bdfd171b867e49aaf2f706529", + "name": "torchvision", + "sha256": "34f3c8c1c26a264b96ee50128233915cea15e98f4700386d133b690091e1c84b", + "size": 7217602, + "subdir": "linux-64", + "timestamp": 1665559620475, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py37h164cc8f_0.conda": { + "build": "cpu_py37h164cc8f_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.7,<3.8.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c1128706262d8c7f5446e1e1fb559762", + "name": "torchvision", + "sha256": "13e55cbd936fbb1375203e3703458eb62d0f93966c6766bf4bf45d7a0fdd4406", + "size": 7195225, + "subdir": "linux-64", + "timestamp": 1661862995811, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py37h164cc8f_1.conda": { + "build": "cpu_py37h164cc8f_1", + "build_number": 1, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.7,<3.8.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a672ea3f90012306b05632e1cba11f4b", + "name": "torchvision", + "sha256": "6443b8dab6677e091ad4ad52a359c3903a0eae3667d22929f7c2a5c3122f3c86", + "size": 7207758, + "subdir": "linux-64", + "timestamp": 1665041328603, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py37h164cc8f_2.conda": { + "build": "cpu_py37h164cc8f_2", + "build_number": 2, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.7,<3.8.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cac26ebc70e92b123a5d72f487896e51", + "name": "torchvision", + "sha256": "2065794b9f967251b6d052836bf24b89d32c81759e1835568eff5559f21faf26", + "size": 7208856, + "subdir": "linux-64", + "timestamp": 1665559317534, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py38h164cc8f_0.conda": { + "build": "cpu_py38h164cc8f_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.8,<3.9.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "138f21cb1167ff4fcc622f4c4aa283e3", + "name": "torchvision", + "sha256": "b782b489bc81e0f57f87dd271d03aa5191d464bace2530ba20bf18012b0a3760", + "size": 7197791, + "subdir": "linux-64", + "timestamp": 1661862689077, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py38h164cc8f_1.conda": { + "build": "cpu_py38h164cc8f_1", + "build_number": 1, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.8,<3.9.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "54f108b42dfc1b33b36b1eba7b858fe1", + "name": "torchvision", + "sha256": "5ee75808747aeae0425c5ff36172c876bf698da3ef64974322ba8f19eb96370a", + "size": 7210176, + "subdir": "linux-64", + "timestamp": 1665040341332, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py38h164cc8f_2.conda": { + "build": "cpu_py38h164cc8f_2", + "build_number": 2, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.8,<3.9.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "199a9d744104da8ad30ae5bf477670bf", + "name": "torchvision", + "sha256": "8acace27d546ece0a55b99c610d9e5cad9dba67a8c755e7d7100355743c6eae3", + "size": 7210939, + "subdir": "linux-64", + "timestamp": 1665559019911, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py39h164cc8f_0.conda": { + "build": "cpu_py39h164cc8f_0", + "build_number": 0, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.9,<3.10.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "586bf59943ae7f58ac0e5b6731546a4d", + "name": "torchvision", + "sha256": "3246cf8f3aede17355c50306906d8d88b81ac642c10fb2a93f7789629079b2df", + "size": 7200334, + "subdir": "linux-64", + "timestamp": 1661863308993, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py39h164cc8f_1.conda": { + "build": "cpu_py39h164cc8f_1", + "build_number": 1, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.9,<3.10.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4979a79845208007e64dc5ff1d0e3be0", + "name": "torchvision", + "sha256": "c3a692ea1af112337d0d0b612627a6784b38b7c8f4a8195822bd395b24211318", + "size": 7212310, + "subdir": "linux-64", + "timestamp": 1665041031900, + "version": "0.11.3" + }, + "torchvision-0.11.3-cpu_py39h164cc8f_2.conda": { + "build": "cpu_py39h164cc8f_2", + "build_number": 2, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.23.1,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.9,<3.10.0a0", + "pytorch 1.10.2", + "setuptools" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "82e69f3d129445c31aa2ab2cc3a0055c", + "name": "torchvision", + "sha256": "f4650c9648954b35668d8e88b1e4c22d66dd8c5a493c5a9ebcbab5b28f180138", + "size": 7213221, + "subdir": "linux-64", + "timestamp": 1665559915093, + "version": "0.11.3" + }, + "torchvision-0.13.1-cpu_py310h164cc8f_0.conda": { + "build": "cpu_py310h164cc8f_0", + "build_number": 0, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.21.2,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.10,<3.11.0a0", + "pytorch", + "requests", + "setuptools", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c24e98047ac7d4d4c7aaa805ec60164c", + "name": "torchvision", + "sha256": "0c99d2b532f71e831b14f6614210c17048fd21ddcd9e99343d7c443da3e937b9", + "size": 6345177, + "subdir": "linux-64", + "timestamp": 1670314661797, + "version": "0.13.1" + }, + "torchvision-0.13.1-cpu_py37h164cc8f_0.conda": { + "build": "cpu_py37h164cc8f_0", + "build_number": 0, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.7,<3.8.0a0", + "pytorch", + "requests", + "setuptools", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a86a7310a0fb0b8736c4ca46f596d409", + "name": "torchvision", + "sha256": "dc5413f90809aa1393001592789deb64712964334e9971114a3ddb201361d1d9", + "size": 6336894, + "subdir": "linux-64", + "timestamp": 1670314015631, + "version": "0.13.1" + }, + "torchvision-0.13.1-cpu_py38h164cc8f_0.conda": { + "build": "cpu_py38h164cc8f_0", + "build_number": 0, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.8,<3.9.0a0", + "pytorch", + "requests", + "setuptools", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "63183e7e873c18197fbc2f4c770319d1", + "name": "torchvision", + "sha256": "c549406769e05331a9f0c3593534cce56a3a6352ea971274f564ebc390f04402", + "size": 6340817, + "subdir": "linux-64", + "timestamp": 1670314342385, + "version": "0.13.1" + }, + "torchvision-0.13.1-cpu_py39h164cc8f_0.conda": { + "build": "cpu_py39h164cc8f_0", + "build_number": 0, + "depends": [ + "jpeg >=9e,<10a", + "libgcc-ng >=11.2.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "numpy >=1.19.2,<2.0a0", + "pillow >=5.3.0,!=8.3.*", + "python >=3.9,<3.10.0a0", + "pytorch", + "requests", + "setuptools", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "92a2c658f57733374ae99bcbe4c98b63", + "name": "torchvision", + "sha256": "cd0375c22b04447db49dc55b9c685ae26ca6786cd1c044ab898a04b308c01a94", + "size": 6337723, + "subdir": "linux-64", + "timestamp": 1670313692093, + "version": "0.13.1" + }, + "torchvision-0.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch >=0.3", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b83df2f7a0604b5e860f084c0301a2c8", + "name": "torchvision", + "sha256": "2c250ca56ed9752dc7e81e68bd0d85cd74b2c3d8d89a300ff813dda41b013416", + "size": 63199, + "subdir": "linux-64", + "timestamp": 1513405387751, + "version": "0.2.0" + }, + "torchvision-0.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.5,<3.6.0a0", + "pytorch >=0.3", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ea1cc8e77a0ed9b034a561f659d6e85d", + "name": "torchvision", + "sha256": "c60b7a60de10e5cca6238fb538b4076c8c9bd16a8cb79b0b10d521f26db04f3b", + "size": 65351, + "subdir": "linux-64", + "timestamp": 1513405369837, + "version": "0.2.0" + }, + "torchvision-0.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch >=0.3", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1ced32b68b316b6f800a7762662401b5", + "name": "torchvision", + "sha256": "2ccf0244f0f0901a1f4fd34eb6fb56d2d4c48a1f3e9e332914f7b8fe16923ba3", + "size": 64688, + "subdir": "linux-64", + "timestamp": 1513405407298, + "version": "0.2.0" + }, + "torchvision-0.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch >=0.4", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3641d8e89a438448287048049583083f", + "name": "torchvision", + "sha256": "3bac9f680d284d750b7af3283581b78f64dd6dce2b60292372377475b44f9030", + "size": 74929, + "subdir": "linux-64", + "timestamp": 1526310288966, + "version": "0.2.1" + }, + "torchvision-0.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=4.1.1", + "python >=3.5,<3.6.0a0", + "pytorch >=0.4", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0595779ec781f43cdba215fdd267bb9c", + "name": "torchvision", + "sha256": "d2ecd21eeb975d7b664567f030186e21406ccd4d07da3b8e536efe6f070364e6", + "size": 77479, + "subdir": "linux-64", + "timestamp": 1526310308915, + "version": "0.2.1" + }, + "torchvision-0.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch >=0.4", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0fc61a8a962374408e5c0d2bd4faa3bd", + "name": "torchvision", + "sha256": "6709ef09008326b1ac9cd84d6efdcd7acffd92a3a2f7e26b51d51f9b5e31237a", + "size": 76828, + "subdir": "linux-64", + "timestamp": 1526310283604, + "version": "0.2.1" + }, + "torchvision-0.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch >=0.4", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eec05ce4639f232019969be0bf5da02b", + "name": "torchvision", + "sha256": "a81e5e1856b8b82dd2038a85e21b4fce41e8390c92e321a8a61b573d15ee299e", + "size": 76936, + "subdir": "linux-64", + "timestamp": 1565199693994, + "version": "0.2.1" + }, + "torchvision-0.3.0-cuda100py27h72fc40a_0.conda": { + "build": "cuda100py27h72fc40a_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch 1.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "afee4e76cafbd77257c943af0ff7632d", + "name": "torchvision", + "sha256": "27384912cc3333d2e6967751bde32f964c220c0cee939addf7e52b4b8e84b79b", + "size": 2028843, + "subdir": "linux-64", + "timestamp": 1565128281467, + "version": "0.3.0" + }, + "torchvision-0.3.0-cuda100py36h72fc40a_0.conda": { + "build": "cuda100py36h72fc40a_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch 1.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "82a4c822bf2bf2beeaab2b359fc81bde", + "name": "torchvision", + "sha256": "61c448148636fb5d67bcc7bfe094d0ca5fc9083cd19f7f9e55a6e5e5c7ebfcb6", + "size": 2021517, + "subdir": "linux-64", + "timestamp": 1565128179685, + "version": "0.3.0" + }, + "torchvision-0.3.0-cuda100py37h72fc40a_0.conda": { + "build": "cuda100py37h72fc40a_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fd0b622b969b2686eca0d408e1ed60f5", + "name": "torchvision", + "sha256": "724350be7e51c5faabe14d50a8c5dd77a010384a9906e1927435d1eb59990667", + "size": 2029319, + "subdir": "linux-64", + "timestamp": 1565128442711, + "version": "0.3.0" + }, + "torchvision-0.3.0-cuda90py27h6edc907_0.conda": { + "build": "cuda90py27h6edc907_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "future", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch 1.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8d0ed3397b04d81c39e295de20cbeef0", + "name": "torchvision", + "sha256": "e5743482ff9442f871f51c05704329a71b757177f0ab1db5daae813e6ec1860a", + "size": 2036152, + "subdir": "linux-64", + "timestamp": 1565187682628, + "version": "0.3.0" + }, + "torchvision-0.3.0-cuda90py36h6edc907_0.conda": { + "build": "cuda90py36h6edc907_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch 1.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4558500d0d36b5ad408d425205144a7c", + "name": "torchvision", + "sha256": "0c63fc518e01b471b07e0ae64facb9fe0b393dfa11ba2b64f00bd2417bba140b", + "size": 2043899, + "subdir": "linux-64", + "timestamp": 1565187230936, + "version": "0.3.0" + }, + "torchvision-0.3.0-cuda90py37h6edc907_0.conda": { + "build": "cuda90py37h6edc907_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.0,<9.1.0a0", + "libgcc-ng >=5.4.0", + "libstdcxx-ng >=5.4.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f560612bfba2181c0a33cf07b2d33ed4", + "name": "torchvision", + "sha256": "dd074bfad0e0184f77579b06ba1da464842302552a56bbe520f19fefdc543066", + "size": 2045314, + "subdir": "linux-64", + "timestamp": 1565187352244, + "version": "0.3.0" + }, + "torchvision-0.3.0-cuda92py27h0601742_0.conda": { + "build": "cuda92py27h0601742_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch 1.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "79fce38dccfd9b9374568a214b696dda", + "name": "torchvision", + "sha256": "68dd6ec233e4a0899da540b61238feed60db869d51fa595cdeeed25b5587566b", + "size": 2029819, + "subdir": "linux-64", + "timestamp": 1565188819424, + "version": "0.3.0" + }, + "torchvision-0.3.0-cuda92py36h0601742_0.conda": { + "build": "cuda92py36h0601742_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch 1.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "124748a39a135728eae68ba7909c7874", + "name": "torchvision", + "sha256": "ce169abd354f53541fba24d2ec8f1ff5bba09bf7a7a7edbe6aba107930aefabd", + "size": 2030970, + "subdir": "linux-64", + "timestamp": 1565188658510, + "version": "0.3.0" + }, + "torchvision-0.3.0-cuda92py37h0601742_0.conda": { + "build": "cuda92py37h0601742_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0fbad4e9256e21ef15dfe66b5b113395", + "name": "torchvision", + "sha256": "82bb4dfb3dc76875a8740da5d2633d17089b3cc114420e94b91ad055290745fe", + "size": 2030995, + "subdir": "linux-64", + "timestamp": 1565188303018, + "version": "0.3.0" + }, + "torchvision-0.4.0-cpu_py27h1e143f5_0.conda": { + "build": "cpu_py27h1e143f5_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch 1.2.0.*", + "six", + "_pytorch_select 0.1" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9f4698bd38437cec77189894a1d2c736", + "name": "torchvision", + "sha256": "95f75ba2ac6e215267a1cc28825ebd3e5ca3f2f6c249379d770da80c9b91a72b", + "size": 1999662, + "subdir": "linux-64", + "timestamp": 1566851088302, + "version": "0.4.0" + }, + "torchvision-0.4.0-cpu_py36h1e143f5_0.conda": { + "build": "cpu_py36h1e143f5_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch 1.2.0.*", + "six", + "_pytorch_select 0.1" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8c104ba226a68b9eb4592a1a00bd9b39", + "name": "torchvision", + "sha256": "84a4f423e01046808f523dea269b9225f7934eed6fa82660c59099dcca4c31d0", + "size": 1995048, + "subdir": "linux-64", + "timestamp": 1566851660777, + "version": "0.4.0" + }, + "torchvision-0.4.0-cpu_py37h1e143f5_0.conda": { + "build": "cpu_py37h1e143f5_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.2.0.*", + "six", + "_pytorch_select 0.1" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1a7b0a9887ac35dff987d6ff372eb1aa", + "name": "torchvision", + "sha256": "af5c8da88a95eae85eb11c25a2cf6849e4d3e4a4b03d9a7d7c1cf7c018c84b89", + "size": 2001150, + "subdir": "linux-64", + "timestamp": 1566852233347, + "version": "0.4.0" + }, + "torchvision-0.4.0-cuda100py27hecfc37a_0.conda": { + "build": "cuda100py27hecfc37a_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch 1.2.0.*", + "six", + "_pytorch_select 0.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a353cbe7030ca86c64a9119ac0c2912e", + "name": "torchvision", + "sha256": "5ab08e28c8d72833e6dc02f91d434fa659a9b5f11bf2d562147b7189116cb9da", + "size": 2623365, + "subdir": "linux-64", + "timestamp": 1566850194040, + "version": "0.4.0" + }, + "torchvision-0.4.0-cuda100py36hecfc37a_0.conda": { + "build": "cuda100py36hecfc37a_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch 1.2.0.*", + "six", + "_pytorch_select 0.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8fb14dee00f815b543968d9795b80a77", + "name": "torchvision", + "sha256": "333ecdfb1329556a3c6dd8bc7e77761967571f25f7f99a790a8353bde971727e", + "size": 2602844, + "subdir": "linux-64", + "timestamp": 1566850686448, + "version": "0.4.0" + }, + "torchvision-0.4.0-cuda100py37hecfc37a_0.conda": { + "build": "cuda100py37hecfc37a_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.2.0.*", + "six", + "_pytorch_select 0.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "46911590fa08498296576bb10f4688fd", + "name": "torchvision", + "sha256": "0823a0bc5781a7375dff7fe2cb357cd1a48a567fa862777c33ab213822faef6a", + "size": 2618326, + "subdir": "linux-64", + "timestamp": 1566849702506, + "version": "0.4.0" + }, + "torchvision-0.4.0-cuda92py27h1667eeb_0.conda": { + "build": "cuda92py27h1667eeb_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "future", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch 1.2.0.*", + "six", + "_pytorch_select 0.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "46dfa3de6a3a55545d5c7a076b33a3bb", + "name": "torchvision", + "sha256": "ad2ede0e48e20303dc06ac88324988b3bbeba3ff31027e98fea5230b43bb827d", + "size": 2623126, + "subdir": "linux-64", + "timestamp": 1566848494911, + "version": "0.4.0" + }, + "torchvision-0.4.0-cuda92py36h1667eeb_0.conda": { + "build": "cuda92py36h1667eeb_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch 1.2.0.*", + "six", + "_pytorch_select 0.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6484a0303f8bcc12d875968c16039452", + "name": "torchvision", + "sha256": "6f95a897aad58b6a90e2c4976545a51dc2f126d27f45341e7ab1abb8f008a81e", + "size": 2621085, + "subdir": "linux-64", + "timestamp": 1566849047589, + "version": "0.4.0" + }, + "torchvision-0.4.0-cuda92py37h1667eeb_0.conda": { + "build": "cuda92py37h1667eeb_0", + "build_number": 0, + "depends": [ + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.2.0.*", + "six", + "_pytorch_select 0.2" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f1bd3b8a893dfed18671d4aad53d6bd6", + "name": "torchvision", + "sha256": "f850889cefe0c87a60ae9fe800a0f17c5b48d802b6acbaf721126ad93faa40f4", + "size": 2618036, + "subdir": "linux-64", + "timestamp": 1566847942448, + "version": "0.4.0" + }, + "torchvision-0.4.2-cpu_py27h9ec355b_0.conda": { + "build": "cpu_py27h9ec355b_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch 1.3.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1a42b911eea6a11dc0a72ab675982435", + "name": "torchvision", + "sha256": "619e67c827c14cd308e36f74553feab4109ea4bf8bc82b56dcadac16084ccade", + "size": 6087185, + "subdir": "linux-64", + "timestamp": 1574723178832, + "version": "0.4.2" + }, + "torchvision-0.4.2-cpu_py36h9ec355b_0.conda": { + "build": "cpu_py36h9ec355b_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch 1.3.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8695fecf04c40afadad0ce711ada74c2", + "name": "torchvision", + "sha256": "579fa0816c5e22451dca7ef22d51e7812dacd6cdf9a603d5143111053d74aea0", + "size": 6088865, + "subdir": "linux-64", + "timestamp": 1574723552571, + "version": "0.4.2" + }, + "torchvision-0.4.2-cpu_py37h9ec355b_0.conda": { + "build": "cpu_py37h9ec355b_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.3.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9ac898f2c5102f4239c02982689bc609", + "name": "torchvision", + "sha256": "f7920f48c008776a4792d91a5057bb548e52fbe9b824179e9f7bae13cff2426f", + "size": 6088574, + "subdir": "linux-64", + "timestamp": 1574723990250, + "version": "0.4.2" + }, + "torchvision-0.4.2-cuda100py27hecfc37a_0.conda": { + "build": "cuda100py27hecfc37a_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch 1.3.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "285dc56022ec131a47d1afd7838c97c7", + "name": "torchvision", + "sha256": "093f3a151d9c95e43129e5d0b1b99ec4dc7bd593981655dde7541f1dcecf8280", + "size": 6733044, + "subdir": "linux-64", + "timestamp": 1574718923382, + "version": "0.4.2" + }, + "torchvision-0.4.2-cuda100py36hecfc37a_0.conda": { + "build": "cuda100py36hecfc37a_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch 1.3.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "89cb0e84f6eb880b0d598bae6faf0e33", + "name": "torchvision", + "sha256": "c6a0c0740c6d26700a67ec6089eddf0a5db192b174829a65ae136dd1000e6fb6", + "size": 6735935, + "subdir": "linux-64", + "timestamp": 1574719539330, + "version": "0.4.2" + }, + "torchvision-0.4.2-cuda100py37hecfc37a_0.conda": { + "build": "cuda100py37hecfc37a_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "cudatoolkit >=10.0.130,<10.1.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.3.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "349ed6639a950104d60240ea25013460", + "name": "torchvision", + "sha256": "aed60f9103b11a6b923e282daaabe1be6371495302cd6c2e26225666b7dceb67", + "size": 6732300, + "subdir": "linux-64", + "timestamp": 1574720098335, + "version": "0.4.2" + }, + "torchvision-0.4.2-cuda92py27h1667eeb_0.conda": { + "build": "cuda92py27h1667eeb_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=2.7,<2.8.0a0", + "pytorch 1.3.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "ca13b49a33d9d9904e0515c483ced71e", + "name": "torchvision", + "sha256": "7f94c47886a17fc482171fb9c7be0deaaea88541669208c0f0066b39cc35f32f", + "size": 6733886, + "subdir": "linux-64", + "timestamp": 1574716613108, + "version": "0.4.2" + }, + "torchvision-0.4.2-cuda92py36h1667eeb_0.conda": { + "build": "cuda92py36h1667eeb_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.6,<3.7.0a0", + "pytorch 1.3.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5b66e743afd6d0abac003bcbead5d425", + "name": "torchvision", + "sha256": "ac86ee875195bc9dcd88d51b6ae82d797d4bd825c85d7e78fda05e4a31f4450a", + "size": 6739599, + "subdir": "linux-64", + "timestamp": 1574717271846, + "version": "0.4.2" + }, + "torchvision-0.4.2-cuda92py37h1667eeb_0.conda": { + "build": "cuda92py37h1667eeb_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.2", + "cudatoolkit >=9.2,<9.3.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.3.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d8c5a71b7212db26e6ff4ce1ccd16ece", + "name": "torchvision", + "sha256": "68b256d763e16465081bade2596bec5bfc7e46abeffbd3c24bbe99d16bb80f57", + "size": 6739315, + "subdir": "linux-64", + "timestamp": 1574718012934, + "version": "0.4.2" + }, + "torchvision-0.8.2-cpu_py37ha229d99_0.conda": { + "build": "cpu_py37ha229d99_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.7,<3.8.0a0", + "pytorch 1.7.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6cdca97d321e4ff535895dd5e9309301", + "name": "torchvision", + "sha256": "272ec9dae7911069bace5d7588449412c0c839fa37e21e9d4c1f9d418bd6c8f4", + "size": 6761273, + "subdir": "linux-64", + "timestamp": 1622219836194, + "version": "0.8.2" + }, + "torchvision-0.8.2-cpu_py38ha229d99_0.conda": { + "build": "cpu_py38ha229d99_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.8,<3.9.0a0", + "pytorch 1.7.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "2d754ddfe2f17b43a4d8f196c9d61ae3", + "name": "torchvision", + "sha256": "4f7c36f09c44c28ed2a1c6f227e522d4b204843a93bf82cbe5cd3c3e71f99ff0", + "size": 6760816, + "subdir": "linux-64", + "timestamp": 1622214794240, + "version": "0.8.2" + }, + "torchvision-0.8.2-cpu_py39ha229d99_0.conda": { + "build": "cpu_py39ha229d99_0", + "build_number": 0, + "depends": [ + "_pytorch_select 0.1", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.11", + "pillow >=4.1.1", + "python >=3.9,<3.10.0a0", + "pytorch 1.7.1.*", + "six" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c54816c597cd2fb4a59f25b3c43e093f", + "name": "torchvision", + "sha256": "4ff0f00002bb45e0623c0b968a6e515b28e3a3f792135175fa2b240670e191e2", + "size": 6767615, + "subdir": "linux-64", + "timestamp": 1622226192276, + "version": "0.8.2" + }, + "tornado-4.5.2-py27h97b179f_0.conda": { + "build": "py27h97b179f_0", + "build_number": 0, + "depends": [ + "backports_abc >=0.4", + "certifi", + "python >=2.7,<2.8.0a0", + "singledispatch", + "ssl_match_hostname" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1aeda94465c91b55b8c1f9a603687e6b", + "name": "tornado", + "sha256": "e24d22f349f322aca65315b868412a0f4ebfe5d7dc0974f31887cd0bc5b2d55a", + "size": 583689, + "subdir": "linux-64", + "timestamp": 1505690514746, + "version": "4.5.2" + }, + "tornado-4.5.2-py35hf879e1d_0.conda": { + "build": "py35hf879e1d_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2f72cd57b4b78dc9dc7b004f2c7006b7", + "name": "tornado", + "sha256": "453822e34adb791c5ae104567fcc83fff21a1a18c75919d0f4d03bc4a0fc0fd3", + "size": 591787, + "subdir": "linux-64", + "timestamp": 1505690531884, + "version": "4.5.2" + }, + "tornado-4.5.2-py36h1283b2a_0.conda": { + "build": "py36h1283b2a_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e060d6af64ceed87fb4416bd3d4b25a9", + "name": "tornado", + "sha256": "2be055fc385018e6e0ac7caacda395e4b426f9a0c64183bed5b3ca367308f9f7", + "size": 595239, + "subdir": "linux-64", + "timestamp": 1505690549225, + "version": "4.5.2" + }, + "tornado-4.5.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports_abc >=0.4", + "certifi", + "python >=2.7,<2.8.0a0", + "singledispatch", + "ssl_match_hostname" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3cb9deab5b97a8ffdaca8bce268845ee", + "name": "tornado", + "sha256": "d9b2f8a06ce5537abcea4da66c3abe6719efe95c01e3828e755f1e612c0df873", + "size": 576926, + "subdir": "linux-64", + "timestamp": 1515709494866, + "version": "4.5.3" + }, + "tornado-4.5.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ab81d6c105c32633114bbe9c8cfc72e4", + "name": "tornado", + "sha256": "4f8f7aae3f44b73c991fcf7eb23ac6abdd36290c7dbd6977b88367c4d9457d80", + "size": 601965, + "subdir": "linux-64", + "timestamp": 1515709574674, + "version": "4.5.3" + }, + "tornado-4.5.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8a35068183002bc81fbc2bd0fd7f73e7", + "name": "tornado", + "sha256": "72f2280690ebcbcca4ccfeccfa7d55838d9876d6ea4501bd3676ceb056984b04", + "size": 596579, + "subdir": "linux-64", + "timestamp": 1515709357660, + "version": "4.5.3" + }, + "tornado-4.5.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "100610bf133fcb66e1b2f4bc0affeb59", + "name": "tornado", + "sha256": "80bb91aab3a14a2e9fc1c7c5efb5d893d48a19dd11cadf1d35b1ee87ab18829e", + "size": 588388, + "subdir": "linux-64", + "timestamp": 1536601522165, + "version": "4.5.3" + }, + "tornado-5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports_abc >=0.4", + "futures", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ef511524059fe29fa0efa295a6d53e33", + "name": "tornado", + "sha256": "3606f9babbc7b03505fd2ad31aed91b3f4f897c57c2181defb197cebf43c331c", + "size": 607804, + "subdir": "linux-64", + "timestamp": 1520362820683, + "version": "5.0" + }, + "tornado-5.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4f2557e0e9ae553df121a2c892dfe1bf", + "name": "tornado", + "sha256": "869bda286e1f75673bef6bf7183a36abacd83e12e25399f839df58aeb132d8ef", + "size": 616364, + "subdir": "linux-64", + "timestamp": 1520362902205, + "version": "5.0" + }, + "tornado-5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4aa47a8f1896b19fdb13608a451df891", + "name": "tornado", + "sha256": "6af0e25f35d6649ad62b95a01b9c4cc758661cf731a857808055e2eaf68b8bba", + "size": 618830, + "subdir": "linux-64", + "timestamp": 1520362500488, + "version": "5.0" + }, + "tornado-5.0.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "backports_abc >=0.4", + "futures", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ccebed4273600bd5d686303c4caa0b80", + "name": "tornado", + "sha256": "cbea0cf80b48eb8cb26d6fda3a1c3bc93c9debc32e180754005689dc496658d0", + "size": 600048, + "subdir": "linux-64", + "timestamp": 1522263246558, + "version": "5.0.1" + }, + "tornado-5.0.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5fd52c0040a32ed4f0a7172310d387e9", + "name": "tornado", + "sha256": "245c8bc46214ecb0e51cc2639eac5e03990d32b0a02b35f89c5e1b721fc5cffc", + "size": 625422, + "subdir": "linux-64", + "timestamp": 1522263255676, + "version": "5.0.1" + }, + "tornado-5.0.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6d6727fd90c55ad08ef961a791724847", + "name": "tornado", + "sha256": "50c4d4cd3f5aa06a7756aa4872ebdc2d47099e10a63acbc0c164f7d8952bd11c", + "size": 612042, + "subdir": "linux-64", + "timestamp": 1522263160670, + "version": "5.0.1" + }, + "tornado-5.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "backports_abc >=0.4", + "futures", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4000d8e66c77e58ecfc33c877ed387b6", + "name": "tornado", + "sha256": "e4741bac2f887d3f68186f2800ca594c20ec30e62d1908b4a2c36c7dac2a86cd", + "size": 602284, + "subdir": "linux-64", + "timestamp": 1524145094055, + "version": "5.0.2" + }, + "tornado-5.0.2-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "backports_abc >=0.4", + "futures", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2c99796726242ade1a9c62ff569d84db", + "name": "tornado", + "sha256": "a10fa41c8ff3c31eaf0c62e87ab8c45517584afefc01b9c6ff46d8fe818f018a", + "size": 616079, + "subdir": "linux-64", + "timestamp": 1530694253724, + "version": "5.0.2" + }, + "tornado-5.0.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cbad6a5fb63368108cc1b5c467d6587f", + "name": "tornado", + "sha256": "79fbdd44709b2f482645df76048bfb24e19867c5dbc6c2f5b3aa50184f30d622", + "size": 628196, + "subdir": "linux-64", + "timestamp": 1524145102292, + "version": "5.0.2" + }, + "tornado-5.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "12b91eaafeac6613a435273872faf71d", + "name": "tornado", + "sha256": "d94888ca177ea24eb0550f3b71d8ad6740e0c011af8188e5a9eb4d55e5a35d5b", + "size": 622660, + "subdir": "linux-64", + "timestamp": 1524145144436, + "version": "5.0.2" + }, + "tornado-5.0.2-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "378f23027517c26b8a33c739d03b1bbc", + "name": "tornado", + "sha256": "1c756e4df7032d496a2eda8a1efd35dffc016efdbf3ae4bc30d9702045154c55", + "size": 627975, + "subdir": "linux-64", + "timestamp": 1530694199142, + "version": "5.0.2" + }, + "tornado-5.0.2-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9d392d887df8baed7dd00c6ea06ce466", + "name": "tornado", + "sha256": "793b44579789c7a893b43951ecff9cb88ec3690a5cf9c4258de9f66946ae3512", + "size": 631537, + "subdir": "linux-64", + "timestamp": 1613166497991, + "version": "5.0.2" + }, + "tornado-5.0.2-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8fa96d35c466a920d16fd080849ff834", + "name": "tornado", + "sha256": "0dcd2da180c88e28e9b9be95ff2ccf1044d36b75c9b441ea74f79cd71fcf431b", + "size": 628620, + "subdir": "linux-64", + "timestamp": 1530694228083, + "version": "5.0.2" + }, + "tornado-5.0.2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e276eab01490d385e386f383b01a24a2", + "name": "tornado", + "sha256": "340bb964ce2b3e131a1aafee565aa31e0d8993cd0e5777eabc4639fc0006347e", + "size": 623218, + "subdir": "linux-64", + "timestamp": 1613166951357, + "version": "5.0.2" + }, + "tornado-5.0.2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "56b312b492ba8c3dd57717ad34dd14b3", + "name": "tornado", + "sha256": "2f1b4f02e613c7820455aaaf11ecb0b80ceed08ad7aefa363a8322c754b59585", + "size": 628805, + "subdir": "linux-64", + "timestamp": 1613166962101, + "version": "5.0.2" + }, + "tornado-5.0.2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dbda4c3e0fd93b643c51737a496e4c53", + "name": "tornado", + "sha256": "35480d530f6cb63ba8cbc2bc44af64b6e3017077fbcab1b2a35a114168e87203", + "size": 628870, + "subdir": "linux-64", + "timestamp": 1613166952067, + "version": "5.0.2" + }, + "tornado-5.1-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "backports_abc >=0.4", + "futures", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "72511b892c84b677b64921ea7e4db94a", + "name": "tornado", + "sha256": "1ac51b97132d45dc41d9c0bd187eb1616c3ee88e269a53d4eb8667a26843e848", + "size": 622643, + "subdir": "linux-64", + "timestamp": 1532981417628, + "version": "5.1" + }, + "tornado-5.1-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4c6caad44d2600be1591a6f5b5a43c79", + "name": "tornado", + "sha256": "89b6f64a1df2e7f4501ebc5424125d61617959696777e2044db0b3db3a91f39e", + "size": 640881, + "subdir": "linux-64", + "timestamp": 1532981606362, + "version": "5.1" + }, + "tornado-5.1-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "22cc6c53f8a028b17f2c0bfa972b9b94", + "name": "tornado", + "sha256": "c97578d59928d2bfc0e5d8b128fd24dd4d3deafdd10f17742656c2d7ea0b4ef5", + "size": 644334, + "subdir": "linux-64", + "timestamp": 1532981600848, + "version": "5.1" + }, + "tornado-5.1-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a8a335c07e7b2a50b3c1a446c7efde03", + "name": "tornado", + "sha256": "733fd5efba49c65b87e19ab70126c0c4a272ef737802e55fe7d8b43ce191aced", + "size": 644361, + "subdir": "linux-64", + "timestamp": 1532981604311, + "version": "5.1" + }, + "tornado-5.1.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "backports_abc >=0.4", + "futures", + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "singledispatch" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fbbf4f3ed756a570d65790507902aac4", + "name": "tornado", + "sha256": "7d8dbb95017568a00e1d2906596c47eede6501ad9f84ae9ebd3a9e2eb1c32a02", + "size": 629309, + "subdir": "linux-64", + "timestamp": 1538231536242, + "version": "5.1.1" + }, + "tornado-5.1.1-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "13b3025d27387fcb1b9e0f9c40b5bce6", + "name": "tornado", + "sha256": "13989b5a79e0a118c16a6b4d86caca83c6e1122de84a490d0c0cdddf0a426f9f", + "size": 638672, + "subdir": "linux-64", + "timestamp": 1538231569613, + "version": "5.1.1" + }, + "tornado-5.1.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3a366c19aad2547242ac9e2bc8e73526", + "name": "tornado", + "sha256": "c300bab549a7a6338eaa5556cd904c9f7a01145a98e99d9d84d6d291a9f40359", + "size": 633325, + "subdir": "linux-64", + "timestamp": 1538231576095, + "version": "5.1.1" + }, + "tornado-5.1.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d662b8e228721c27f1abaae2a31c2bcf", + "name": "tornado", + "sha256": "fe834102002b66c312fcfd3fb5a1f7aa8ba66dcda0bd509514ab480577426bca", + "size": 633808, + "subdir": "linux-64", + "timestamp": 1538231515594, + "version": "5.1.1" + }, + "tornado-6.0.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c1e4c40d5acb815378a370c06c2d55ac", + "name": "tornado", + "sha256": "15c3c4ad7a07508c22ef08398bf27b2c60a09435b4521fab922e445dd642723e", + "size": 603390, + "subdir": "linux-64", + "timestamp": 1552339698377, + "version": "6.0.1" + }, + "tornado-6.0.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "21693ccc54aaaba8dfc51eceabb9b6aa", + "name": "tornado", + "sha256": "3882b319f3300f682b55998705d05b1c1f42c99f6d466fcc60f88e442b3c25f4", + "size": 596469, + "subdir": "linux-64", + "timestamp": 1552339660266, + "version": "6.0.1" + }, + "tornado-6.0.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4234ead4ba910d6bb77b50689069ed8d", + "name": "tornado", + "sha256": "bd6f23d9d762ff893d1a65f630b0598397ae715724c61eac2361b20e10b7a74a", + "size": 604818, + "subdir": "linux-64", + "timestamp": 1553523913908, + "version": "6.0.2" + }, + "tornado-6.0.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a9a64ed6d3b17dcfa2fb946c1ce5fb1a", + "name": "tornado", + "sha256": "02aafd5c888c48b6688eba23e737c5f491f091f30822f0b45c05a02fd99646cc", + "size": 597002, + "subdir": "linux-64", + "timestamp": 1553523880697, + "version": "6.0.2" + }, + "tornado-6.0.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a0478cb2ecbc2065c300aaef7a6a09c3", + "name": "tornado", + "sha256": "cd0c07a157872540a33ddbff2eecc6249ed5daf8c6855a43d4ab34b9bb2a1bc0", + "size": 597456, + "subdir": "linux-64", + "timestamp": 1562078778510, + "version": "6.0.3" + }, + "tornado-6.0.3-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "73bb79586331211a7e07407994d37ab9", + "name": "tornado", + "sha256": "b125044587348ec7ac7cf9e6ea19c0f3187f503fa29d7e61c5db80ef7f3468ef", + "size": 601572, + "subdir": "linux-64", + "timestamp": 1581113859447, + "version": "6.0.3" + }, + "tornado-6.0.3-py36h7b6447c_3.conda": { + "build": "py36h7b6447c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "522c5e4c183360cf2a7fb0c61caefb42", + "name": "tornado", + "sha256": "1f8b6ef987bd44e4f100ecc731000cfaf39b117666a5bd00b4099580c5cd30ee", + "size": 601721, + "subdir": "linux-64", + "timestamp": 1581357683755, + "version": "6.0.3" + }, + "tornado-6.0.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "75822a26c2dd921fdf31e4649f76ef57", + "name": "tornado", + "sha256": "33278d2fbd61b9b1bc1b1440a881908a4fc8d7bbf1a58f5e4c7cbe4ec41a65e1", + "size": 598107, + "subdir": "linux-64", + "timestamp": 1562078778390, + "version": "6.0.3" + }, + "tornado-6.0.3-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6e4a151bc2249a6ab0b82429893fbd1c", + "name": "tornado", + "sha256": "12d62a198dae71568acabdc59bb8ca1d3fff7177f09020e048e5bcc0f6cd5c15", + "size": 594415, + "subdir": "linux-64", + "timestamp": 1581113880232, + "version": "6.0.3" + }, + "tornado-6.0.3-py37h7b6447c_3.conda": { + "build": "py37h7b6447c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "28d918a3965bc01acfa3d82676dc4570", + "name": "tornado", + "sha256": "031585a0333201b9c5e1e5f2343343e2b050ed1dbb05fb9a0fcc07365d6171d5", + "size": 594284, + "subdir": "linux-64", + "timestamp": 1581357679822, + "version": "6.0.3" + }, + "tornado-6.0.3-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c9fd4c947e95018d188f7f3e4151f42d", + "name": "tornado", + "sha256": "e59fb9eff74cae9ee7134d20ae8609ce0ea9d98128b6bc93cddb92a65b800889", + "size": 608611, + "subdir": "linux-64", + "timestamp": 1573200428365, + "version": "6.0.3" + }, + "tornado-6.0.3-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9c5bf547ae7f606b800492b984594053", + "name": "tornado", + "sha256": "5cabe64dad56cbae4ca81734507560da3ede8e5bc0cc127d1e132de173b60f2f", + "size": 607720, + "subdir": "linux-64", + "timestamp": 1581113883752, + "version": "6.0.3" + }, + "tornado-6.0.3-py38h7b6447c_3.conda": { + "build": "py38h7b6447c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2425d40c8ce6d3867d6e7d075bebc0ee", + "name": "tornado", + "sha256": "314f377571d9dbe83598703a4ecc7ec8a1c7a394611387c482c6577971fe5cb7", + "size": 599694, + "subdir": "linux-64", + "timestamp": 1581357715994, + "version": "6.0.3" + }, + "tornado-6.0.4-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bfa8de21006a112d4b3e6f74bd8158c3", + "name": "tornado", + "sha256": "3c65d62b47b2161dcf68e73748d9724caa80a2dcda8eadf810b0767b718034cd", + "size": 611608, + "subdir": "linux-64", + "timestamp": 1584026791598, + "version": "6.0.4" + }, + "tornado-6.0.4-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3d2cff671951b55004782939f7d6ebb7", + "name": "tornado", + "sha256": "428defdcb8486074853eba7ead3fe5bb34f1a71f0534793c3b31b67d75232d57", + "size": 625735, + "subdir": "linux-64", + "timestamp": 1584026756160, + "version": "6.0.4" + }, + "tornado-6.0.4-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bb4be5fdec1dbf127444f93667b438ee", + "name": "tornado", + "sha256": "44a038349405b6e51e10072d9c1eec541f51a8cb59d13b0fb0a79ad4956a304a", + "size": 617787, + "subdir": "linux-64", + "timestamp": 1584026786758, + "version": "6.0.4" + }, + "tornado-6.1-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a8832ddff0ebc2fee4b16ce3dae8f7ab", + "name": "tornado", + "sha256": "486ec1e74006188cfd28ae303e16240324e2afcff2dc48b70e22b917019998b7", + "size": 627372, + "subdir": "linux-64", + "timestamp": 1640795414786, + "version": "6.1" + }, + "tornado-6.1-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2342df291e4a75d3058475f57110d002", + "name": "tornado", + "sha256": "a9dbc671755f267582481204383b3fc4b2d0fbda878a801538fe622fee324293", + "size": 595392, + "subdir": "linux-64", + "timestamp": 1606942366873, + "version": "6.1" + }, + "tornado-6.1-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8a4cd3be1eb57b5e750bd0c62bab8a26", + "name": "tornado", + "sha256": "0ead0582db4237a531a79f64c0a18d8495da63b9cbeed9b2f3f6ce7d0cacbadf", + "size": 603501, + "subdir": "linux-64", + "timestamp": 1606942320203, + "version": "6.1" + }, + "tornado-6.1-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d2d3043f631807af72b0fde504baf625", + "name": "tornado", + "sha256": "6f3821fc414d6369deaaadbd2e965eb352dc04347c0bedcebbd06f09c8c6d095", + "size": 601624, + "subdir": "linux-64", + "timestamp": 1606942346182, + "version": "6.1" + }, + "tornado-6.1-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7843e2e995a512aa86ff6bfa396eabb2", + "name": "tornado", + "sha256": "cf122fdaf6e301e21fd7a7dc6b989aff93c97b264edf4274423ae294c6dcf111", + "size": 609528, + "subdir": "linux-64", + "timestamp": 1606942359431, + "version": "6.1" + }, + "tornado-6.2-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1fe283fadb3a05b7081531c105def52f", + "name": "tornado", + "sha256": "25a9fdb5af67b5bc760fb24b98f03a53f51f710724b7a85182b571f1fb3f3769", + "size": 616288, + "subdir": "linux-64", + "timestamp": 1662061773929, + "version": "6.2" + }, + "tornado-6.2-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2c171d341a49e6b84dfa2178207b5eac", + "name": "tornado", + "sha256": "21626a41fa42e2477beb3cd48891e1b1a91127d2ad0c3943dfcd3d460b48d88a", + "size": 815423, + "subdir": "linux-64", + "timestamp": 1676823435699, + "version": "6.2" + }, + "tornado-6.2-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e88d10f78e1871494207a40642535518", + "name": "tornado", + "sha256": "ef61f6a5281b78abc13a4f22b7da616feff5dafe03a40ea70a6e25bbdb5dbe73", + "size": 598121, + "subdir": "linux-64", + "timestamp": 1662061843812, + "version": "6.2" + }, + "tornado-6.2-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "db2f7ebc500d97a4af6889dfd0d03dbc", + "name": "tornado", + "sha256": "30baeb9b5aa3acf031de6507f5c1b149fe6cfe7c3686104c0b0d3024332c6fd9", + "size": 604254, + "subdir": "linux-64", + "timestamp": 1662061808629, + "version": "6.2" + }, + "tornado-6.2-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5f4348ee3ef482f6e60c343612335f82", + "name": "tornado", + "sha256": "2b3e0eb3b05b7660861eb04b0129312d979864b96d3926eb0b46825cc0f77742", + "size": 603911, + "subdir": "linux-64", + "timestamp": 1662061881952, + "version": "6.2" + }, + "tornado-json-1.3.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0", + "python >=2.7,<2.8.0a0", + "tornado >=3.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e235d2769aa238301c62fe96d023d22e", + "name": "tornado-json", + "sha256": "b3723b26969737d283683f662967850d86690ee774c2b5b926ab60595bf4dfe6", + "size": 26133, + "subdir": "linux-64", + "timestamp": 1537836684199, + "version": "1.3.3" + }, + "tornado-json-1.3.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0", + "python >=3.5,<3.6.0a0", + "tornado >=3.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd00e0e0d05cd09b2b5beb35d0a784b2", + "name": "tornado-json", + "sha256": "a62ba3933881f07fbbb9ba78e8bffa4b691d5175dcfbe9655aad263b17f1f79f", + "size": 26761, + "subdir": "linux-64", + "timestamp": 1537832757489, + "version": "1.3.3" + }, + "tornado-json-1.3.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0", + "python >=3.6,<3.7.0a0", + "tornado >=3.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0735e0e5ef019fb8191c3fb0d33c8a67", + "name": "tornado-json", + "sha256": "441d53aac9ee5cd3b87f9a58d4a56d20a6a6713fadfa9ae3ad78c65d72087984", + "size": 26564, + "subdir": "linux-64", + "timestamp": 1537832767527, + "version": "1.3.3" + }, + "tornado-json-1.3.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0", + "python >=3.7,<3.8.0a0", + "tornado >=3.2.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7292d01830008ca55c35294318af870a", + "name": "tornado-json", + "sha256": "93211d51967ddfefe1f2cfa29e096c831e80c270c50797910bc12eea6bc7df14", + "size": 26838, + "subdir": "linux-64", + "timestamp": 1537832668962, + "version": "1.3.3" + }, + "tornado-json-1.3.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0,<3.0", + "python >=2.7,<2.8.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43a313bb4e62bb3ab24dfa70a21d876b", + "name": "tornado-json", + "sha256": "cb7ab487823fc069a087523c0db023359a3443d6565982b0b86858e95479ea1d", + "size": 192431, + "subdir": "linux-64", + "timestamp": 1569442067926, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "jsonschema >=2.3.0", + "python >=3.10,<3.11.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1acdaafd7d94ec6985a4fb784f62c11c", + "name": "tornado-json", + "sha256": "8d675c2f44bc0ca744f0aee1d5bc5c2f4574162fc8a754b1a15d26d5a5503562", + "size": 28272, + "subdir": "linux-64", + "timestamp": 1640811268843, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0,<3.0", + "python >=3.6,<3.7.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5dd8bc051b0d6212bd6712edc82374a6", + "name": "tornado-json", + "sha256": "785149bdab2b07c1def1d2e9282a9cc5501531231dff70283576c90624c302f2", + "size": 192342, + "subdir": "linux-64", + "timestamp": 1569442073010, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0,<3.0", + "python >=3.6,<3.7.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d9785b8a7c174d1998eb401238852cf", + "name": "tornado-json", + "sha256": "54d14172ebe34bbb4677c6e1a37f85356841a70bd7406246623459428ffa3066", + "size": 264729, + "subdir": "linux-64", + "timestamp": 1613038668052, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "jsonschema >=2.3.0", + "python >=3.6,<3.7.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "70448ecc27dd0c8228d19284e1005d6b", + "name": "tornado-json", + "sha256": "11c67ddd4b66b7ccbf44e6f1564d72b600e3794b83dbe793dc6edb13d19a846b", + "size": 269537, + "subdir": "linux-64", + "timestamp": 1613996857792, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0,<3.0", + "python >=3.7,<3.8.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3808feefeff507c0327095c2fc66f8d3", + "name": "tornado-json", + "sha256": "baa9460fbdc1d14e7ed67e2ca253fb52c412683f0365cad73d4a0e6414119c11", + "size": 193383, + "subdir": "linux-64", + "timestamp": 1569442068984, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0,<3.0", + "python >=3.7,<3.8.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "67400338b1111468a0050bb52b467235", + "name": "tornado-json", + "sha256": "1234ef65e8d8c8184cd25ad072175c65371e77620bcfeb5b89d3f2984e943b32", + "size": 267351, + "subdir": "linux-64", + "timestamp": 1613038666020, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "jsonschema >=2.3.0", + "python >=3.7,<3.8.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4ee10f4b15f0d7a9bb72208add7750c5", + "name": "tornado-json", + "sha256": "9c1434949257fae2993b78d0989057f4796fb2c558bd82c47299f54d4f208b1a", + "size": 269016, + "subdir": "linux-64", + "timestamp": 1613996910677, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "jsonschema >=2.3.0,<3.0", + "python >=3.8,<3.9.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21d77da0559bd1cf11ba6fdeba031fc2", + "name": "tornado-json", + "sha256": "64d6a9d6007b38838bcd235ca0540434abc6c8de583ccdc0cb854ccaa2f85c3f", + "size": 28057, + "subdir": "linux-64", + "timestamp": 1574412742590, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "jsonschema >=2.3.0", + "python >=3.8,<3.9.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "47e6495c636f50a29e8716a6f283d55c", + "name": "tornado-json", + "sha256": "b101dac1abb20b854430267be950265c87887ce244006e68c156e72338b72fb7", + "size": 269075, + "subdir": "linux-64", + "timestamp": 1613997746765, + "version": "1.3.4" + }, + "tornado-json-1.3.4-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "jsonschema >=2.3.0", + "python >=3.9,<3.10.0a0", + "tornado >=3.2.2,<6.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1656c9517132113a0fd1b6f6d57e4023", + "name": "tornado-json", + "sha256": "612a821eedca848a754312b8a7ecdf043a7eab8ebb84af3baa6beacc6d4f684f", + "size": 269601, + "subdir": "linux-64", + "timestamp": 1613997747955, + "version": "1.3.4" + }, + "toro-1.0.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a883194cd6dde37407eddf93407ed0e2", + "name": "toro", + "sha256": "7562995a03e95d70c55a5f2b2cfff02d3f4f2b41ada8ca8361e840918ee2a9f7", + "size": 18964, + "subdir": "linux-64", + "timestamp": 1539184250708, + "version": "1.0.1" + }, + "toro-1.0.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5ea0b61c3847a2e865b9f0db33e2c09b", + "name": "toro", + "sha256": "e69d37e058a4355d9dc890c7f414e3c99bc6cb101b18824a22b95734b7b6b34e", + "size": 19651, + "subdir": "linux-64", + "timestamp": 1641557858664, + "version": "1.0.1" + }, + "toro-1.0.1-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "68b50239970c22fb7ec38e44b986f1b1", + "name": "toro", + "sha256": "259f2f3369a7f112e23e3100e379a912baa43ce4964d1f83d97c049e3bc9093e", + "size": 22490, + "subdir": "linux-64", + "timestamp": 1646746009555, + "version": "1.0.1" + }, + "toro-1.0.1-py311h06a4308_2.conda": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4a3abac406a631be0f3785bb42e75f22", + "name": "toro", + "sha256": "a75a421fb75f4ec5ee25d4c783731b1c002ba8c696ac09bc1949e8f4fd57958e", + "size": 27223, + "subdir": "linux-64", + "timestamp": 1676863279885, + "version": "1.0.1" + }, + "toro-1.0.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "cd7deedafeb3df07b549257caf767f4c", + "name": "toro", + "sha256": "d11ff118b5c423471126afed9f6e7d9ca6e065d231565c06563429a9c27e139a", + "size": 19445, + "subdir": "linux-64", + "timestamp": 1539184263472, + "version": "1.0.1" + }, + "toro-1.0.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "82e92b30b177088d96bfda922faa1cbf", + "name": "toro", + "sha256": "9c22ad32087cedbb4df9292ba9b9666709aee02143260642ae61407ee7ee7a71", + "size": 20396, + "subdir": "linux-64", + "timestamp": 1614066244343, + "version": "1.0.1" + }, + "toro-1.0.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "077d282653ec465bd9e062bf99c52c9b", + "name": "toro", + "sha256": "c0c978b569ef1bc921a7da780978cb383eb034b5acf0fa9177a0b1462172591c", + "size": 19465, + "subdir": "linux-64", + "timestamp": 1539184273283, + "version": "1.0.1" + }, + "toro-1.0.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5083db6cf1ed25cd183cd7fd89253cfa", + "name": "toro", + "sha256": "952dbf1a2fd4b02eacbe97af02cf85614bed0dcf64d6359f5270dad71a08f52f", + "size": 20154, + "subdir": "linux-64", + "timestamp": 1614066231281, + "version": "1.0.1" + }, + "toro-1.0.1-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ba8a816633fbbab5be052a0dfbba990e", + "name": "toro", + "sha256": "b8b7ba8286cf8777b905b53249d136432e8f7423417daa3906a9b3db8ef687c5", + "size": 22152, + "subdir": "linux-64", + "timestamp": 1646745947818, + "version": "1.0.1" + }, + "toro-1.0.1-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "81e788644e41a1020af079c94ce1db48", + "name": "toro", + "sha256": "18e8ebe3251d020ed3273e30deb8e14a6d298e270688fdb82c0a548caa661f3b", + "size": 19814, + "subdir": "linux-64", + "timestamp": 1573554815585, + "version": "1.0.1" + }, + "toro-1.0.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e73c4ee93befabbbaaa12c30e75c1c48", + "name": "toro", + "sha256": "86e3ebb25e6c5275075271991762b67aed223a88ce1fa9e23a83644e40408f60", + "size": 20422, + "subdir": "linux-64", + "timestamp": 1614066240324, + "version": "1.0.1" + }, + "toro-1.0.1-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6c95268caea2538a5e75a63b206e5072", + "name": "toro", + "sha256": "2fd95736b640a26ef5542869e6df9e989069ba3ea78e2a714deaf7e546e4cdb7", + "size": 22184, + "subdir": "linux-64", + "timestamp": 1646745907598, + "version": "1.0.1" + }, + "toro-1.0.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c42653cbd38699a5951df1104a65e4a2", + "name": "toro", + "sha256": "b13654c3dd9b42e0d231017a2b61291bb67d17ba12ebeae6dd6b894eae80b685", + "size": 20488, + "subdir": "linux-64", + "timestamp": 1614065626619, + "version": "1.0.1" + }, + "toro-1.0.1-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0", + "tornado >=3" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "24d099bb5e8aa0c41641ad404ad07e04", + "name": "toro", + "sha256": "5e7b6ec3ef9167f11501bb4c9b1fb370bd833e4212f45e4eaa47ab9e2b0a7b3e", + "size": 22142, + "subdir": "linux-64", + "timestamp": 1646745868764, + "version": "1.0.1" + }, + "tqdm-4.19.2-py27hba956de_0.conda": { + "build": "py27hba956de_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "cf769d185d7ac4a3e2b60662822ebe96", + "name": "tqdm", + "sha256": "51c252881b4e9992577ba1358a4b6c6c24daa6a81713b600c73f9bb1dfb0f39f", + "size": 55162, + "subdir": "linux-64", + "timestamp": 1507832464217, + "version": "4.19.2" + }, + "tqdm-4.19.2-py35h6552237_0.conda": { + "build": "py35h6552237_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "97439789f1d17843bcd09c33c1c78b66", + "name": "tqdm", + "sha256": "506c373cc97d8322c42f0a4d515fcf0427043b5799f81c4916d348afac27a986", + "size": 55550, + "subdir": "linux-64", + "timestamp": 1507832464701, + "version": "4.19.2" + }, + "tqdm-4.19.2-py36ha9864ad_0.conda": { + "build": "py36ha9864ad_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "370e375fc6c2e1c713bfc69b54e83101", + "name": "tqdm", + "sha256": "9c8594d6d94eac3e8da65e32feef3d19d6bf029b5b7366468c40f14564abd2a3", + "size": 55250, + "subdir": "linux-64", + "timestamp": 1507832460691, + "version": "4.19.2" + }, + "tqdm-4.19.4-py27hdfef72e_0.conda": { + "build": "py27hdfef72e_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "6d78f4f42c494af01e63e119bde88b9f", + "name": "tqdm", + "sha256": "ae9a087bc0ac3819d43b2b50c5d9c43bfa1bb6603e0fc8ea4a8f613c7765076f", + "size": 54928, + "subdir": "linux-64", + "timestamp": 1508915658908, + "version": "4.19.4" + }, + "tqdm-4.19.4-py35h68e51d2_0.conda": { + "build": "py35h68e51d2_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "eb15af0d1268f63cc4c7e4bc0fb13ff4", + "name": "tqdm", + "sha256": "8a3985250b2bb131891d06e95991dc04983723db9e687e50aa1478e38786d728", + "size": 55532, + "subdir": "linux-64", + "timestamp": 1508915660104, + "version": "4.19.4" + }, + "tqdm-4.19.4-py36ha5a5176_0.conda": { + "build": "py36ha5a5176_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "cd6a39003b712fb815a6a73122d577d3", + "name": "tqdm", + "sha256": "26311abe327364ac2c141a4f2e681c029e5ec9da87add537a9ec698386b0bab4", + "size": 53977, + "subdir": "linux-64", + "timestamp": 1508915678515, + "version": "4.19.4" + }, + "tqdm-4.19.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "f90d4d663533bd5d925d0f4a4ff06a23", + "name": "tqdm", + "sha256": "2af2356b6146972981f989f0f87e19e56810866e0387fece26c83857005ee329", + "size": 55255, + "subdir": "linux-64", + "timestamp": 1519755106380, + "version": "4.19.5" + }, + "tqdm-4.19.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "96785223b81d1d6b45c1bf2840ceb5c8", + "name": "tqdm", + "sha256": "6b31d9a5523c8f64a7cd20f927250c762d545eee4f4a3ae57a9a3644d737a0e9", + "size": 54725, + "subdir": "linux-64", + "timestamp": 1519755119945, + "version": "4.19.5" + }, + "tqdm-4.19.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "c21929211da4558e9d8ae0314760af22", + "name": "tqdm", + "sha256": "d2902c3d8165dffbcf3aa163132a6c418ac16ccfc735fc8ed03bf98a8ef4e2ff", + "size": 55329, + "subdir": "linux-64", + "timestamp": 1519755084101, + "version": "4.19.5" + }, + "tqdm-4.19.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "8dd69eb6939d3242a70df1dd6a565129", + "name": "tqdm", + "sha256": "eac7338cd2a9558ddde10472a7d2c8ee4d5a70d5824eb6016a3a69b4993c6b92", + "size": 56976, + "subdir": "linux-64", + "timestamp": 1522195971945, + "version": "4.19.8" + }, + "tqdm-4.19.8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "9dbe0a7d88f416216f9c4789b2812a86", + "name": "tqdm", + "sha256": "13a34a28bdf6673d2299565f0ea72e9da35d168340c51b99c2c8605236c7c8a4", + "size": 56368, + "subdir": "linux-64", + "timestamp": 1522197082166, + "version": "4.19.8" + }, + "tqdm-4.19.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "38e03fabcd424f01da535800e9070bc4", + "name": "tqdm", + "sha256": "9e1805b76f3ba67f3d81726e563ead5dee758d9d42cbf5dc8e611cdce5399771", + "size": 56923, + "subdir": "linux-64", + "timestamp": 1522196032332, + "version": "4.19.8" + }, + "tqdm-4.19.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "b888d156662d413f6e248722cd57b1bd", + "name": "tqdm", + "sha256": "050bae6ac33be9fd7fd544a440f13a3e28c584c391d43d1d900eb4f719aa79a5", + "size": 56932, + "subdir": "linux-64", + "timestamp": 1522696575450, + "version": "4.19.9" + }, + "tqdm-4.19.9-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "612b78c49b3581374c7d397c2557c8f9", + "name": "tqdm", + "sha256": "397defce547162f4113894a54ba29ca23dc3b1b94c23d50da249b9d5fddae8e2", + "size": 57448, + "subdir": "linux-64", + "timestamp": 1522696586515, + "version": "4.19.9" + }, + "tqdm-4.19.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "7a69b7b5a161cb20de1df8db33274ec9", + "name": "tqdm", + "sha256": "cfdcb1bd2cd2a6ef8e771133d72898ed7e78f534acded30117fbb23ba7c48577", + "size": 56863, + "subdir": "linux-64", + "timestamp": 1522696585369, + "version": "4.19.9" + }, + "tqdm-4.23.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "a35f3a0108b3478dc5980d282f1a20c1", + "name": "tqdm", + "sha256": "7dc983c38e9550534d42458a7405249354a5e0dbd69c30548f2c9b6ae25636a7", + "size": 58735, + "subdir": "linux-64", + "timestamp": 1523983516269, + "version": "4.23.0" + }, + "tqdm-4.23.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "9857b80ea7e0bcafc1d41bd52de5e2c9", + "name": "tqdm", + "sha256": "53ec01d33d73453fae2bf582be4df09eca04c852113e42ea72bc9f6e58c234ad", + "size": 58417, + "subdir": "linux-64", + "timestamp": 1523983518082, + "version": "4.23.0" + }, + "tqdm-4.23.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "72c33fc7b912fe91efcce31db5487a34", + "name": "tqdm", + "sha256": "454d67c5c3478e5ab1c9e8a961e8f338fdda838548103f7b426441dcf5430d4d", + "size": 58845, + "subdir": "linux-64", + "timestamp": 1523983519979, + "version": "4.23.0" + }, + "tqdm-4.23.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "f16b9cf0e3976421ec0edea1687a7eb4", + "name": "tqdm", + "sha256": "d746d103bc2e467fadba3f91463d129889e7f12e715dee448721a851f3e786f2", + "size": 59608, + "subdir": "linux-64", + "timestamp": 1526915319761, + "version": "4.23.3" + }, + "tqdm-4.23.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "94e059292352b07ddb73c2cf116bf83a", + "name": "tqdm", + "sha256": "0400e57da4770e26a7af838fb5f5d7128c7eeffb489ff4e06f57309eef722b81", + "size": 60129, + "subdir": "linux-64", + "timestamp": 1526915333733, + "version": "4.23.3" + }, + "tqdm-4.23.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "68ec435be6935b78afce6c74a9e73171", + "name": "tqdm", + "sha256": "74ce46b736195ceae9aa3ab763c25b80aa8ba6dc3c436a07c19f9aeb33f283cf", + "size": 58518, + "subdir": "linux-64", + "timestamp": 1526915260745, + "version": "4.23.3" + }, + "tqdm-4.23.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "61e7c53eb68944403c961905ded77c42", + "name": "tqdm", + "sha256": "37b709218fce4440c7e3281e3b773ec8eaff74f803748d55e80d1988ddb94201", + "size": 58568, + "subdir": "linux-64", + "timestamp": 1530917248874, + "version": "4.23.3" + }, + "tqdm-4.23.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "6e04525270c037378f9486041ae642a3", + "name": "tqdm", + "sha256": "31d33f2a5c43bb8994ea64e3323b837f8fcb70d15e716f87afc4be0b6b1ca553", + "size": 59458, + "subdir": "linux-64", + "timestamp": 1527629543055, + "version": "4.23.4" + }, + "tqdm-4.23.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "c8f1188b361ec352e9cf0cd94f27bd16", + "name": "tqdm", + "sha256": "663e3cd5eb184fe55e5eeddcb0def5d1c1042236c374ced6e1c9e7513eee348d", + "size": 60045, + "subdir": "linux-64", + "timestamp": 1527629604753, + "version": "4.23.4" + }, + "tqdm-4.23.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "3173a5c00a9f091cad05c5f22179207d", + "name": "tqdm", + "sha256": "2ca26f7f8fcb3bbdbf16006ab0adaed811e4ae16e191d77d74001275f7af3071", + "size": 59723, + "subdir": "linux-64", + "timestamp": 1527629552164, + "version": "4.23.4" + }, + "tqdm-4.24.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "a1410aa6406c12e4125b92b7c6c996ea", + "name": "tqdm", + "sha256": "9c1114baa3e1fd37e0fe5eab48e0ce51064a8dc7047b4c24fe842bef6fc9602f", + "size": 59984, + "subdir": "linux-64", + "timestamp": 1532994116122, + "version": "4.24.0" + }, + "tqdm-4.24.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "e97f5627e4d53987730dded400d25159", + "name": "tqdm", + "sha256": "ac8af40f26c7bfa38dd3c2af873f55b7a695c31b999a9ed8bd5a06bb43279413", + "size": 60347, + "subdir": "linux-64", + "timestamp": 1532994210796, + "version": "4.24.0" + }, + "tqdm-4.24.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "1140d1df43d727a099663566a0093d2c", + "name": "tqdm", + "sha256": "11be76aab0f5572a78682f17cac835d6bbbea3bc59c67b35fcb465e511f3aba9", + "size": 60005, + "subdir": "linux-64", + "timestamp": 1532994132965, + "version": "4.24.0" + }, + "tqdm-4.24.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "277dbdc313b3b390aea465a314ab294a", + "name": "tqdm", + "sha256": "58b7879381b2985d3d9a0588a51c775d9eb7f2540bed8e29a77c700d9703b740", + "size": 59906, + "subdir": "linux-64", + "timestamp": 1532994149491, + "version": "4.24.0" + }, + "tqdm-4.25.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "51e50645604974e515ac494e71edb1e8", + "name": "tqdm", + "sha256": "10e2d3f890004e01193fe55909e2ba6af29f60678fa9b457dff992a38f9340f9", + "size": 60174, + "subdir": "linux-64", + "timestamp": 1534794951421, + "version": "4.25.0" + }, + "tqdm-4.25.0-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "ec24667462223462cb3114326e9b62b1", + "name": "tqdm", + "sha256": "e7c2a80975565d805f9f4f754161e035830b7b2ccf4321eadeae5ebaa9402135", + "size": 60911, + "subdir": "linux-64", + "timestamp": 1534794967230, + "version": "4.25.0" + }, + "tqdm-4.25.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "401e1a71a4e03d9852d26bd431c0d77d", + "name": "tqdm", + "sha256": "4210225ad1870f09c501db55e1799690b23e7203e83bc105454e83a1a2f20a18", + "size": 60261, + "subdir": "linux-64", + "timestamp": 1534794924783, + "version": "4.25.0" + }, + "tqdm-4.25.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "482f746236f91e5d96484fc91d11461a", + "name": "tqdm", + "sha256": "c608b889d8f437672b7459bc30d267b98a96c1d482d794dc15a7b156f14e4ad5", + "size": 60368, + "subdir": "linux-64", + "timestamp": 1534795095638, + "version": "4.25.0" + }, + "tqdm-4.26.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "a2e8c829be060224b30d7161a5c54a92", + "name": "tqdm", + "sha256": "ad8f35659fa0366680cb4d5a9b7decfaeaeb6db956f9249e80559d2427639ad3", + "size": 60877, + "subdir": "linux-64", + "timestamp": 1537471364978, + "version": "4.26.0" + }, + "tqdm-4.26.0-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "70cfa87caf91ce9a7714e3bc959f84a0", + "name": "tqdm", + "sha256": "a07e209634454f65ae4293ce61b0499fa135397f9df3fca70c789a52d468bef2", + "size": 61674, + "subdir": "linux-64", + "timestamp": 1537471395729, + "version": "4.26.0" + }, + "tqdm-4.26.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "8a7af4f896d85e56fcaee873ef9cd0f4", + "name": "tqdm", + "sha256": "8668ee2b8036c4d364fb6027bbce475c5bb77f4eb6af1c226ff2beb7d2bfdf87", + "size": 61002, + "subdir": "linux-64", + "timestamp": 1537471381146, + "version": "4.26.0" + }, + "tqdm-4.26.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "983053bbb0952f42e0248472dea2dcd5", + "name": "tqdm", + "sha256": "c52a80c68d0451a9a8724ae46e43f7ac2ca9f97f86692e4dce6f467589f2f3ed", + "size": 60217, + "subdir": "linux-64", + "timestamp": 1537471324858, + "version": "4.26.0" + }, + "tqdm-4.28.1-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "765af32e912b4571c2bd9c88386cb2e2", + "name": "tqdm", + "sha256": "b258248a48dea1fb3d669bffba50be4118b5e7a6c7994558d7d462ae5d0fecff", + "size": 63610, + "subdir": "linux-64", + "timestamp": 1541054637155, + "version": "4.28.1" + }, + "tqdm-4.28.1-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "dd7889205d3d1e65b1af80913e8e24e8", + "name": "tqdm", + "sha256": "9af6020d75c3dc5095a1601adf15dde09a219520ca0919356b66cd83ddebcb1a", + "size": 62631, + "subdir": "linux-64", + "timestamp": 1541054668558, + "version": "4.28.1" + }, + "tqdm-4.28.1-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "0a988cedc2d64457d95354d155708354", + "name": "tqdm", + "sha256": "64b09cb012d0ab0507f9395c4565026e6da9d76652a7142862764224f1377286", + "size": 63757, + "subdir": "linux-64", + "timestamp": 1541054644286, + "version": "4.28.1" + }, + "tqdm-4.31.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "86e485dbbcafe3b8bf626c8b535ea9c3", + "name": "tqdm", + "sha256": "7432fe11b82e130cac8db4aa518668581d1eef35d9d4f9c08840ca16bcaa84f8", + "size": 72124, + "subdir": "linux-64", + "timestamp": 1553291144630, + "version": "4.31.1" + }, + "tqdm-4.31.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "a882e5a713209063bf05ba8f0179142d", + "name": "tqdm", + "sha256": "899a4d2dba2f72df91ed118db90a4863387cbb627ca7e47c20e206d803e0857a", + "size": 72204, + "subdir": "linux-64", + "timestamp": 1553291327820, + "version": "4.31.1" + }, + "tqdm-4.31.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPLv2.0, MIT", + "license_family": "MIT", + "md5": "af5e1ec9a24c3ef42d24612e413ab232", + "name": "tqdm", + "sha256": "eecd2df24464877ac9d10681610c2cf4b10325906dccc8a4e129b73ae3b42b0f", + "size": 72219, + "subdir": "linux-64", + "timestamp": 1553291180198, + "version": "4.31.1" + }, + "tqdm-4.64.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "5628b605bd8f24c75b3e9e0c2ec8e04c", + "name": "tqdm", + "sha256": "2914fe1c3acfdc68d5843f114ac2497d3b073484bd14f527f6fc33ff5680a31d", + "size": 130218, + "subdir": "linux-64", + "timestamp": 1650891128591, + "version": "4.64.0" + }, + "tqdm-4.64.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "004bc72e510bb6ae040c946025523469", + "name": "tqdm", + "sha256": "6024bac833b69ef388449005f3155ddede11ec2326d2c890a255ea636e3946e3", + "size": 158969, + "subdir": "linux-64", + "timestamp": 1676827550361, + "version": "4.64.0" + }, + "tqdm-4.64.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "adc66658745090b411698423c690d43d", + "name": "tqdm", + "sha256": "218f81225d45966d659b113d06d4d6831c58fead3cfc861715a0c09fde049262", + "size": 128696, + "subdir": "linux-64", + "timestamp": 1650891158490, + "version": "4.64.0" + }, + "tqdm-4.64.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "88ff93b448e19c3801cc8e9fd84d2835", + "name": "tqdm", + "sha256": "53de60460f9d41289254f63998ff6846124bac415226544a61006bac4ca1fa93", + "size": 129162, + "subdir": "linux-64", + "timestamp": 1650891221480, + "version": "4.64.0" + }, + "tqdm-4.64.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "550a1c3f308be60ac3a7eb50a2dfdf89", + "name": "tqdm", + "sha256": "7c0d7fd70f6b4520e4c59f24ed35bb17d5f83bb6867da62d82040071da634b97", + "size": 129282, + "subdir": "linux-64", + "timestamp": 1650891189657, + "version": "4.64.0" + }, + "tqdm-4.64.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "70abdcff9d648dbd7ec15976d5e2ae8a", + "name": "tqdm", + "sha256": "b74cc6a78c6dfaedf88b96d92d71bbdbac4e12c72777e8b95f4ec61bc2d8e926", + "size": 128624, + "subdir": "linux-64", + "timestamp": 1664392845255, + "version": "4.64.1" + }, + "tqdm-4.64.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "09a0c8427a99b967d6e9674fe3e33882", + "name": "tqdm", + "sha256": "dfffd00369cd51404a709b4b51c4071c88f3ad4046172853c3722a6d9242389f", + "size": 158934, + "subdir": "linux-64", + "timestamp": 1679339403752, + "version": "4.64.1" + }, + "tqdm-4.64.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "4ce539dcc5028e5d8dbaeb8ea593b9b0", + "name": "tqdm", + "sha256": "f6063d0c25e079620faa9ab659e36f971713d82c3f05a5058f80b2c8b32b783f", + "size": 128951, + "subdir": "linux-64", + "timestamp": 1664392760650, + "version": "4.64.1" + }, + "tqdm-4.64.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "1bc424cdc58538ccf7b3b7960188dc14", + "name": "tqdm", + "sha256": "ac778c2ca09a065ddf0f133c355961f22aa0d64f24683484b7a7a2d8b9377ad5", + "size": 127594, + "subdir": "linux-64", + "timestamp": 1664392725664, + "version": "4.64.1" + }, + "tqdm-4.64.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "57882c8bfe59a8b4be8a157c9b4355e6", + "name": "tqdm", + "sha256": "03e9b526a15a1797cee5a1ccfbe5b04bdb48b256edfa5bed2e50efb30bf2ebe9", + "size": 127700, + "subdir": "linux-64", + "timestamp": 1664392798362, + "version": "4.64.1" + }, + "tqdm-4.65.0-py310h2f386ee_0.conda": { + "build": "py310h2f386ee_0", + "build_number": 0, + "constrains": [ + "ipywidgets >=6", + "requests", + "slack-sdk" + ], + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "37f2f147d26d1cc490adf72eea75f7f9", + "name": "tqdm", + "sha256": "24937a81e11bfab0840924844ebbaa08398c11572586b20ba138237f0998d8e8", + "size": 135186, + "subdir": "linux-64", + "timestamp": 1679561970726, + "version": "4.65.0" + }, + "tqdm-4.65.0-py311h92b7b1e_0.conda": { + "build": "py311h92b7b1e_0", + "build_number": 0, + "constrains": [ + "ipywidgets >=6", + "requests", + "slack-sdk" + ], + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "fb0eec8970dec11613c783fa2e0d08ed", + "name": "tqdm", + "sha256": "234cfbeb2155457a845de2ae0a66f60565f4a7d8e518273e23c86637073e0b9d", + "size": 164098, + "subdir": "linux-64", + "timestamp": 1679562095911, + "version": "4.65.0" + }, + "tqdm-4.65.0-py38hb070fc8_0.conda": { + "build": "py38hb070fc8_0", + "build_number": 0, + "constrains": [ + "ipywidgets >=6", + "requests", + "slack-sdk" + ], + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "14ce320abb6720e73de1e9583ebe825c", + "name": "tqdm", + "sha256": "7c2838eb0ee76eec6738164dead3190d3139d75c470075f99e6567da2c977af9", + "size": 134188, + "subdir": "linux-64", + "timestamp": 1679562034657, + "version": "4.65.0" + }, + "tqdm-4.65.0-py39hb070fc8_0.conda": { + "build": "py39hb070fc8_0", + "build_number": 0, + "constrains": [ + "ipywidgets >=6", + "requests", + "slack-sdk" + ], + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MPL-2.0 AND MIT", + "license_family": "MOZILLA", + "md5": "dba9c627bc7c746b30fea78fe228f4b3", + "name": "tqdm", + "sha256": "9311f5c2bf41c3e0ab1601f4c2b58850b7a293e3b508c2c236e6be9905b2a6cc", + "size": 133957, + "subdir": "linux-64", + "timestamp": 1679561904852, + "version": "4.65.0" + }, + "traceback2-1.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "159ff13dd5d38c33342308074dce4c9d", + "name": "traceback2", + "sha256": "3f7870a6a090e01bf976a8c1094b6fe401422b7af9bbe58dfd80f8686fc33f4b", + "size": 31878, + "subdir": "linux-64", + "timestamp": 1530898793095, + "version": "1.4.0" + }, + "traceback2-1.4.0-py27h153c7c5_0.conda": { + "build": "py27h153c7c5_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "cb6f88c5b2b1a3efb9b859254b26fe97", + "name": "traceback2", + "sha256": "3d8fb299005e7c1fb2554461bda4ac813b04c0fc3f0d223cdb5233a51eea538b", + "size": 32178, + "subdir": "linux-64", + "timestamp": 1508304257948, + "version": "1.4.0" + }, + "traceback2-1.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "f0841776d0dfd00a92894e4850d86096", + "name": "traceback2", + "sha256": "5b5353e31c182f4ea4e02712ec15c9adffb730c22f72b8d14b5222b0d5527641", + "size": 33041, + "subdir": "linux-64", + "timestamp": 1642511154158, + "version": "1.4.0" + }, + "traceback2-1.4.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "b744c2ff4c30cf0beb0d4c77bafeca3c", + "name": "traceback2", + "sha256": "6da46c39724c6ea0208a7b5529fd100c6cd3fa657470248df00c6d42c2b26703", + "size": 43463, + "subdir": "linux-64", + "timestamp": 1676863295275, + "version": "1.4.0" + }, + "traceback2-1.4.0-py35hb87e97a_0.conda": { + "build": "py35hb87e97a_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "a5a58744a81db0433b5df4da23ae2ce8", + "name": "traceback2", + "sha256": "5cccb720737b77a693fd50a496aec33f466975cd2122da9c2e20c4e9ea5d8ef9", + "size": 32685, + "subdir": "linux-64", + "timestamp": 1508304260959, + "version": "1.4.0" + }, + "traceback2-1.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "d1a3049305169c4b67ffe44e4338dc9f", + "name": "traceback2", + "sha256": "f0a58f95a7f25212b48b861c09b57bda27761fae2ed43759c9dcb7df7c926424", + "size": 32069, + "subdir": "linux-64", + "timestamp": 1530898848965, + "version": "1.4.0" + }, + "traceback2-1.4.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "c1cdfdadae080e0b379604c046742804", + "name": "traceback2", + "sha256": "02a7196f513a33902bf1835f151a3bc1f31bae25a4da019ce4bfccf8e2622cc6", + "size": 32729, + "subdir": "linux-64", + "timestamp": 1632756988587, + "version": "1.4.0" + }, + "traceback2-1.4.0-py36h3ec00f9_0.conda": { + "build": "py36h3ec00f9_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "0e92b4d1f71ccdb4578b6286e555b9bf", + "name": "traceback2", + "sha256": "fcb83130ba44284b950b318d8d23bc08b09596f41770b066ecfd9d2d274e5eda", + "size": 32505, + "subdir": "linux-64", + "timestamp": 1508304255644, + "version": "1.4.0" + }, + "traceback2-1.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "613000bda7c9adfdb4d2fee48d156aeb", + "name": "traceback2", + "sha256": "6279d522afe8ca0d55484acc1f664c27d1c35a58e8b9a6015ce1382ed7fd63de", + "size": 32298, + "subdir": "linux-64", + "timestamp": 1530898820655, + "version": "1.4.0" + }, + "traceback2-1.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "e1b8617838dcf1557e63a1404e8a79f4", + "name": "traceback2", + "sha256": "55f87ad9f59c8960930be4e597299750bd5b577bae743cd9b916e3ac61a1c25a", + "size": 32842, + "subdir": "linux-64", + "timestamp": 1632752281557, + "version": "1.4.0" + }, + "traceback2-1.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "32e6d7dfbd2efa708f7d177506c8ec79", + "name": "traceback2", + "sha256": "adc2cd1eeac79a806dc40f57aaa3b45c3a2d53eec174ff11e406dc1e751140f7", + "size": 33049, + "subdir": "linux-64", + "timestamp": 1573554831627, + "version": "1.4.0" + }, + "traceback2-1.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "56a171ede338ea9a48aeff66d8d57abc", + "name": "traceback2", + "sha256": "c2b020261eb48308a3be921115d9d0ea9c89d886321bfdd564a97e4a7bc95338", + "size": 33296, + "subdir": "linux-64", + "timestamp": 1632756887100, + "version": "1.4.0" + }, + "traceback2-1.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "linecache2", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "PSF 2.0", + "md5": "d66c25c9befada1d99cd6e2d7799e345", + "name": "traceback2", + "sha256": "051294027389f4efcc3ed21b75cba3a004de10fe3317fa0df2bb85f495899b2b", + "size": 33335, + "subdir": "linux-64", + "timestamp": 1632756964699, + "version": "1.4.0" + }, + "traitlets-4.3.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator", + "enum34", + "ipython_genutils", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-clause", + "md5": "9d7cc3eb9e666cdfa09171d36749e15f", + "name": "traitlets", + "sha256": "0dc8f62e45712504bf2369e2d14c122581a124f370a556790632dabd7dbf85f4", + "size": 134228, + "subdir": "linux-64", + "timestamp": 1530694397034, + "version": "4.3.2" + }, + "traitlets-4.3.2-py27hd6ce930_0.conda": { + "build": "py27hd6ce930_0", + "build_number": 0, + "depends": [ + "decorator", + "enum34", + "ipython_genutils", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD 3-clause", + "md5": "79c9506657ba19512e47420f0dd8cd49", + "name": "traitlets", + "sha256": "0d4e6b8af3af2e8a0e67f283825a318bfff456e929c8447a9fc77c36b26d6e17", + "size": 134584, + "subdir": "linux-64", + "timestamp": 1505672115044, + "version": "4.3.2" + }, + "traitlets-4.3.2-py35ha522a97_0.conda": { + "build": "py35ha522a97_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "BSD 3-clause", + "md5": "500d6eaf4afdb80b1e44a216f630bdf3", + "name": "traitlets", + "sha256": "7dcb565209e3ac26876a4df00b4fa4d0c07828283a84a429d7e11ba64fda1c4e", + "size": 139581, + "subdir": "linux-64", + "timestamp": 1505672128737, + "version": "4.3.2" + }, + "traitlets-4.3.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-clause", + "md5": "ccfbb96803907a38719af008260160ac", + "name": "traitlets", + "sha256": "9e3a8939bab23207116a30703bae6895b683bc4e23be21321a3aeccf58436b7e", + "size": 137288, + "subdir": "linux-64", + "timestamp": 1530694354888, + "version": "4.3.2" + }, + "traitlets-4.3.2-py36h674d592_0.conda": { + "build": "py36h674d592_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD 3-clause", + "md5": "36fb793ed05a82abdc22ae96c29f9370", + "name": "traitlets", + "sha256": "db4ff2847f1f0fa9a6a5c34c2865c4a51f99aad3bb09d722eb99ccab08de6c9c", + "size": 136093, + "subdir": "linux-64", + "timestamp": 1505672142545, + "version": "4.3.2" + }, + "traitlets-4.3.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD 3-clause", + "md5": "082e8b3f4f195be233a5187d3b5512f2", + "name": "traitlets", + "sha256": "2d681c960a8525bbaca70a209431daf5f401c1f8be8b276f43243cc7cd611c69", + "size": 139383, + "subdir": "linux-64", + "timestamp": 1530694376494, + "version": "4.3.2" + }, + "traitlets-4.3.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "decorator", + "enum34", + "ipython_genutils", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "833ea6e94e6c714fc61ce6b410bb8f0d", + "name": "traitlets", + "sha256": "d52340a32e094296ceacdb84eabbb2b2f4ecbf842d5c2c6ae7b2cb8beac723f6", + "size": 139681, + "subdir": "linux-64", + "timestamp": 1570464061848, + "version": "4.3.3" + }, + "traitlets-4.3.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "2075cf5b8caf3a409c5f5a5895386f73", + "name": "traitlets", + "sha256": "69df060e138cfadf57d2ebfde44c98fbf21fcbafe92359efb3cbfef04e424ea3", + "size": 143153, + "subdir": "linux-64", + "timestamp": 1570464062639, + "version": "4.3.3" + }, + "traitlets-4.3.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "7650aa4d7c7c60c187b57db3581218f1", + "name": "traitlets", + "sha256": "4f31343cb8c664298f9cae6a83ff503c5a6098b99383c457be69b42c1243e0be", + "size": 141353, + "subdir": "linux-64", + "timestamp": 1632746557055, + "version": "4.3.3" + }, + "traitlets-4.3.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "1fc6a18ab845c4a0b2de501411f064b5", + "name": "traitlets", + "sha256": "3b8d1b56aaa44f826e3189dd707781ab1bb9cd17dc53e5a77e466ac9aac324d2", + "size": 142980, + "subdir": "linux-64", + "timestamp": 1570464067737, + "version": "4.3.3" + }, + "traitlets-4.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "6b164516459c6148f3a20ec3d751ba53", + "name": "traitlets", + "sha256": "65f9d87807dc8c18055d95955538299b9eb42fbbdb1386e8ce78defdbacc012e", + "size": 143170, + "subdir": "linux-64", + "timestamp": 1632756915266, + "version": "4.3.3" + }, + "traitlets-4.3.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "25565a2af22674ec46100dcd3d675d1f", + "name": "traitlets", + "sha256": "110ccbb1deae87c611c8d50893f047769f2245629857d058f1c7b615dd37687b", + "size": 141205, + "subdir": "linux-64", + "timestamp": 1573554848366, + "version": "4.3.3" + }, + "traitlets-4.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "046385b8af46cfdf52003f512564a082", + "name": "traitlets", + "sha256": "63db882549fdc213f593a5692e75b1ad053d99f80f186a5bed13e00255dd8d71", + "size": 143928, + "subdir": "linux-64", + "timestamp": 1632756972899, + "version": "4.3.3" + }, + "traitlets-4.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "decorator", + "ipython_genutils", + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "md5": "74e031a60e30df83236194bf1b366d37", + "name": "traitlets", + "sha256": "c3feca02c567aa77e73547ab33159c0caddd9ca4054a8dd7bca5ae6d537b7698", + "size": 144068, + "subdir": "linux-64", + "timestamp": 1632756916362, + "version": "4.3.3" + }, + "traitlets-5.0.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "ipython_genutils", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "de08754ea0e40666c66a715b7b93460b", + "name": "traitlets", + "sha256": "94b8b61a1f7e248f8cd142b00f4b663c2a6f6f83150f5d394143d202c2791ee9", + "size": 179074, + "subdir": "linux-64", + "timestamp": 1600712423494, + "version": "5.0.4" + }, + "traitlets-5.7.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7a907e6f93750c37969651f6101a241e", + "name": "traitlets", + "sha256": "0e8840d04b642f0049b962b29a85dc7a42e6b4d1aee4f1791378e5879d75e46a", + "size": 207973, + "subdir": "linux-64", + "timestamp": 1671143967706, + "version": "5.7.1" + }, + "traitlets-5.7.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "618abdcd1e39f748168c1a951791227e", + "name": "traitlets", + "sha256": "3222aa3c12de8e3bda7696e7b5b67fa1b76d62761fcc883401328a947b07220f", + "size": 265493, + "subdir": "linux-64", + "timestamp": 1676823316868, + "version": "5.7.1" + }, + "traitlets-5.7.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b9e6307cb9cf76bf12a883711f9ccdf6", + "name": "traitlets", + "sha256": "fa73f596e346c48497c9b21313d69f642c4b669a5fd185a2ef9ae53a1cfde66f", + "size": 204227, + "subdir": "linux-64", + "timestamp": 1671143912609, + "version": "5.7.1" + }, + "traitlets-5.7.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "94212f72060fa5387300bb8598ff3049", + "name": "traitlets", + "sha256": "634ba2b85f42d2e69ec01f315a46740abe5078bc70257d01c37a78fbedc46f07", + "size": 205187, + "subdir": "linux-64", + "timestamp": 1671143939929, + "version": "5.7.1" + }, + "traitlets-5.7.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1ed09caebf70d6be0f1244457baac526", + "name": "traitlets", + "sha256": "fdced95f42c8be3f55f1975a607f46ab0dbbb393eeb15d1cb2f6557d2338bf7c", + "size": 205135, + "subdir": "linux-64", + "timestamp": 1671143995098, + "version": "5.7.1" + }, + "traits-4.6.0-py27h14c3975_2.conda": { + "build": "py27h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "ac1f0af687ed13d8ed74e833cac75bb9", + "name": "traits", + "sha256": "f64d97f942b1109ea6448a0a1a24698814d2120197bf4af1601fd1c82e53048c", + "size": 394932, + "subdir": "linux-64", + "timestamp": 1530873856838, + "version": "4.6.0" + }, + "traits-4.6.0-py27h7b6447c_3.conda": { + "build": "py27h7b6447c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "606f29a41800e75a27772a38949840f9", + "name": "traits", + "sha256": "7ff57281d4f37783d4d3757a7e30aef10650dd300c998951354f001e9d9f6d1c", + "size": 395064, + "subdir": "linux-64", + "timestamp": 1536253549735, + "version": "4.6.0" + }, + "traits-4.6.0-py35h7b6447c_3.conda": { + "build": "py35h7b6447c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "md5": "74ca97c38b5c486d49fa11bb3d8bd902", + "name": "traits", + "sha256": "9d3f2c63341bd7d3a7e66c046c4e9ccba411ff409adfb9461496a1e79b1f6740", + "size": 398312, + "subdir": "linux-64", + "timestamp": 1536253581611, + "version": "4.6.0" + }, + "traits-4.6.0-py36h14c3975_2.conda": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "6f6f7a70c1cc9e2b509a9c58cca608de", + "name": "traits", + "sha256": "c091e3797ef4ec560504c613ffa7f93382a66a67e7d1218495825b79d75631f9", + "size": 393732, + "subdir": "linux-64", + "timestamp": 1530873950004, + "version": "4.6.0" + }, + "traits-4.6.0-py36h7b6447c_3.conda": { + "build": "py36h7b6447c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "de06fbb28013d986583fc6f98d7a56d5", + "name": "traits", + "sha256": "7cc2f9bd9fb649ea3269994799e463295b32f74e7a454731bf3a1c1a37676b01", + "size": 399209, + "subdir": "linux-64", + "timestamp": 1536253516992, + "version": "4.6.0" + }, + "traits-4.6.0-py37h14c3975_2.conda": { + "build": "py37h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "14208fc496d793c71af1804a9f942094", + "name": "traits", + "sha256": "07e6a9d94560637e9f06d046d1e2ab33d9cc7df48999e36ca211e126d33e7360", + "size": 394592, + "subdir": "linux-64", + "timestamp": 1530873902542, + "version": "4.6.0" + }, + "traits-4.6.0-py37h7b6447c_3.conda": { + "build": "py37h7b6447c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "f6dcd5ccd201eb107e4ea5bbbced4a54", + "name": "traits", + "sha256": "0b5974e04c2f81e9b59125e8c3e52508eea8d4cfaf5416095bf852f6eeaa1dcb", + "size": 399704, + "subdir": "linux-64", + "timestamp": 1536253655813, + "version": "4.6.0" + }, + "traits-5.0.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "bb09eb935e4d93de08658e0c81f90295", + "name": "traits", + "sha256": "aa590bb4578576aac1a1e8d77f38a0d900ae6b61fc06f903f59a6c54c9a40fc3", + "size": 395885, + "subdir": "linux-64", + "timestamp": 1552371289178, + "version": "5.0.0" + }, + "traits-5.0.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "3d81cbabb822351f2d47df35b7dd7468", + "name": "traits", + "sha256": "8592d602779f7ed3c70301a86e8219742b18a91ceea77482ab92bd168c897c92", + "size": 401149, + "subdir": "linux-64", + "timestamp": 1552371308648, + "version": "5.0.0" + }, + "traits-5.0.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "f8f652598a3b30bb8905ce9750c83c6a", + "name": "traits", + "sha256": "a1220ac71e199004d0ca13b45d3aefeda4d0e0a36930461dcbf811a9a1268256", + "size": 402151, + "subdir": "linux-64", + "timestamp": 1552371261350, + "version": "5.0.0" + }, + "traits-5.1.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "38a5af5366f4bed7b17f10fb8aa6665f", + "name": "traits", + "sha256": "1b21100d556fbaadf0e25e13617fabd60f833bb39297182bf1e053a3da8edd5f", + "size": 399896, + "subdir": "linux-64", + "timestamp": 1556076978230, + "version": "5.1.1" + }, + "traits-5.1.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "c8af50e1d193302822498f29be518ee5", + "name": "traits", + "sha256": "32d8a5a95afe28e4b9826249f0109706e216d91673a35895520a7c2d4cbf6973", + "size": 404690, + "subdir": "linux-64", + "timestamp": 1556077004497, + "version": "5.1.1" + }, + "traits-5.1.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "65c687f3b17af42f0b2c245437b4c1c9", + "name": "traits", + "sha256": "63a3c8e698be408ba5a0cbc8c44086ae78b0ee12ea45f486ec51dcab99c79ef9", + "size": 404923, + "subdir": "linux-64", + "timestamp": 1556076949224, + "version": "5.1.1" + }, + "traits-5.1.2-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "d3d000591541371890071678e8289831", + "name": "traits", + "sha256": "5087b1f0db9fe3adda353fb03c96fb66b7547081417d9d29b0e825745773b23c", + "size": 400762, + "subdir": "linux-64", + "timestamp": 1569359636616, + "version": "5.1.2" + }, + "traits-5.1.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "d5e5d82b3b39c99482bea519025bf874", + "name": "traits", + "sha256": "3021f5a1623c21191f2bdbed26a88ef22583c5895f02b271bbbb7f2b21a147a3", + "size": 406636, + "subdir": "linux-64", + "timestamp": 1569359641034, + "version": "5.1.2" + }, + "traits-5.1.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "d9e400c465812224df358b36e3ad312d", + "name": "traits", + "sha256": "60a07a4cad212ea7fc6c21df863abf8b882832ae32d84672ca1bd10d04ef6dd3", + "size": 406357, + "subdir": "linux-64", + "timestamp": 1569359635489, + "version": "5.1.2" + }, + "traits-5.1.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "md5": "4575bfb13a875957ce565247fa0110ea", + "name": "traits", + "sha256": "9bdb5a3f58e1d3c23e0980eb5938f78d0b644b615800d563a52e0f34f74b7ea8", + "size": 415215, + "subdir": "linux-64", + "timestamp": 1573200464057, + "version": "5.1.2" + }, + "traits-5.2.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "cea04c499bca7d197858425e5a3bae7e", + "name": "traits", + "sha256": "d7ac114ab6f0f8bfbb4269bce6445e010dfc3ec260ecc471c51a915b8a5d8a14", + "size": 400792, + "subdir": "linux-64", + "timestamp": 1574367103659, + "version": "5.2.0" + }, + "traits-5.2.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "967ad6eb7d931f0bd05fbfaf6722385b", + "name": "traits", + "sha256": "3fb744e8e9743e5f6093d76ed52143b72d69a869c045be4cf6fc490d323dff5e", + "size": 407366, + "subdir": "linux-64", + "timestamp": 1574367103066, + "version": "5.2.0" + }, + "traits-5.2.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "107981d93240e3e5ce16213e69c83bff", + "name": "traits", + "sha256": "dae1d71b636f1be2c75f01480a8bf8aca6266a8341c671b638154b66e4ee697d", + "size": 407543, + "subdir": "linux-64", + "timestamp": 1574367084693, + "version": "5.2.0" + }, + "traits-5.2.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "md5": "b6caa1f3c648caf6880a9f826dbfa3e9", + "name": "traits", + "sha256": "7b192e38759148483178ab86659b4e43db43eca6d222b5bc7ba9d522c01d72e3", + "size": 417895, + "subdir": "linux-64", + "timestamp": 1574367097613, + "version": "5.2.0" + }, + "traits-6.0.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "66352fddb14087133a9c897091ebde0c", + "name": "traits", + "sha256": "ce9b73c70d7cb29083ddce179039ff40960f2e0e0249f0eeed516279a7d3ec2b", + "size": 418342, + "subdir": "linux-64", + "timestamp": 1586838405725, + "version": "6.0.0" + }, + "traits-6.1.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "bc1af0af1a3080e11b46b24228144a95", + "name": "traits", + "sha256": "3097a871f6423b398e5370e1c0b3b40f1e01235d6a6a125153266eff2b73aedc", + "size": 604140, + "subdir": "linux-64", + "timestamp": 1595342055054, + "version": "6.1.0" + }, + "traits-6.1.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "3146bf1ba11fe1e22aaa205fb31c408e", + "name": "traits", + "sha256": "60d26b0d22210726b732e9af64f224276329a72055ad5993ff061d70196cb5dc", + "size": 604358, + "subdir": "linux-64", + "timestamp": 1595342634079, + "version": "6.1.0" + }, + "traits-6.1.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "md5": "9e014c4cf90788a435b4c616fc409bca", + "name": "traits", + "sha256": "61e76ab855e5541513530cc0c145905c5bad5f0ab7eefd9d908e165e6a3e2522", + "size": 609717, + "subdir": "linux-64", + "timestamp": 1595342638271, + "version": "6.1.0" + }, + "traits-6.1.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "3390203c5283a95958fb89553ac8ad09", + "name": "traits", + "sha256": "63c4ba9a1e9eabdf105b1e6ad3028f31213d80e8f1c7e099fc7547bd0632c6b4", + "size": 605155, + "subdir": "linux-64", + "timestamp": 1596110861024, + "version": "6.1.1" + }, + "traits-6.1.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "09c408a502721a42f6a00684417e2fe8", + "name": "traits", + "sha256": "e65f90df1662b87a5d75fba4501e4da83133920c35615d6d7fc33d67c76c6e4e", + "size": 605081, + "subdir": "linux-64", + "timestamp": 1596110843676, + "version": "6.1.1" + }, + "traits-6.1.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "md5": "be13dafc0dc186b1c83fbe3123f72b95", + "name": "traits", + "sha256": "d5829868a293d37573e455f5aeaff770939a35b58432826c1078be904e0528e3", + "size": 608843, + "subdir": "linux-64", + "timestamp": 1596110872264, + "version": "6.1.1" + }, + "traits-6.2.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-clause", + "md5": "35c03c90bdfb853150d6984ef82ed5cc", + "name": "traits", + "sha256": "c50ed879081bc1229350e83505ac61efb68275b5cc2f0e229575fa3df4209654", + "size": 5169878, + "subdir": "linux-64", + "timestamp": 1640795444378, + "version": "6.2.0" + }, + "traits-6.2.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-clause", + "md5": "8b014b8912ac74e852dcd28d0bdf7d70", + "name": "traits", + "sha256": "d993b94714eec4c9b31d1281ae780a21d812063da40017f05cc211e95f106ae9", + "size": 5310399, + "subdir": "linux-64", + "timestamp": 1676846051646, + "version": "6.2.0" + }, + "traits-6.2.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "md5": "7f91280ecfc7e1ad7b84762925b27519", + "name": "traits", + "sha256": "1d9e5016b738031186965ecd450c9d8da99ade9f0f644a13bb5dbb15f64608e5", + "size": 5106688, + "subdir": "linux-64", + "timestamp": 1611259455471, + "version": "6.2.0" + }, + "traits-6.2.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "md5": "a9ec9ea40ff8f9826fdb4a7c17d02dae", + "name": "traits", + "sha256": "b9f0fd2b3d7e579de467b346ddd71347221d841497a974310a1fe81784cd68cb", + "size": 5106431, + "subdir": "linux-64", + "timestamp": 1611259443650, + "version": "6.2.0" + }, + "traits-6.2.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "md5": "3bfc09a8b5b684a6d9c0922137e2e2af", + "name": "traits", + "sha256": "8c229ac895ad9cdcf3570c704c4f23104b8c3e10123444de3ba823e4b5493ed3", + "size": 5112234, + "subdir": "linux-64", + "timestamp": 1611259478446, + "version": "6.2.0" + }, + "traits-6.2.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "constrains": [ + "traitsui >=7.0" + ], + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-clause", + "md5": "1fcb2f9dedefb6a174b1f7468c818ce1", + "name": "traits", + "sha256": "d107bd2531ff5ed43c386754be2745ff2ce635791fc8cf118d1517837e4ad69a", + "size": 5105207, + "subdir": "linux-64", + "timestamp": 1611259453212, + "version": "6.2.0" + }, + "traitsui-6.0.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "pyface >=6", + "python >=2.7,<2.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "md5": "3c1c082951026ff4e7106dc3f46f6154", + "name": "traitsui", + "sha256": "a5dcd6379cb2ea8f63e03580d1bc8b9f7e429ac1ebab2a1b4dd953a4a199281b", + "size": 794904, + "subdir": "linux-64", + "timestamp": 1524596792700, + "version": "6.0.0" + }, + "traitsui-6.0.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "pyface >=6", + "python >=3.5,<3.6.0a0", + "traits" + ], + "license": "BSD 3-clause", + "md5": "2be97b1fe8a8bd7258b62c3aaae2b74a", + "name": "traitsui", + "sha256": "171992098658a1c42867ce086922df8575f66164cc3c01a376c97c6ccb0d6d46", + "size": 801055, + "subdir": "linux-64", + "timestamp": 1524596837137, + "version": "6.0.0" + }, + "traitsui-6.0.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "pyface >=6", + "python >=3.6,<3.7.0a0", + "traits" + ], + "license": "BSD 3-clause", + "md5": "2b9411075a27cee9861440d0ba85eaa0", + "name": "traitsui", + "sha256": "b54372aaa2420515a6fbb6a3d061f9744a044023fa774cb48e824c3759c532d7", + "size": 802195, + "subdir": "linux-64", + "timestamp": 1524596849590, + "version": "6.0.0" + }, + "traitsui-6.0.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "pyface >=6", + "python >=3.7,<3.8.0a0", + "traits" + ], + "license": "BSD 3-clause", + "md5": "2c27bb15e13fc1c590f369fa77bad466", + "name": "traitsui", + "sha256": "374b07c99ca4dbf00c05635e75ab1d4b5a4c9dd11b93acedbeede0ba826aceda", + "size": 802039, + "subdir": "linux-64", + "timestamp": 1530874689100, + "version": "6.0.0" + }, + "transaction-2.1.2-py27hd729c4d_0.conda": { + "build": "py27hd729c4d_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "a15ed318be0411d193e1ff372be2ed29", + "name": "transaction", + "sha256": "d946f7079111771ff3794a7d62e7a5d3ffafd95dfb3e923032f320e0e887ccd8", + "size": 75234, + "subdir": "linux-64", + "timestamp": 1507984318719, + "version": "2.1.2" + }, + "transaction-2.1.2-py35h6fe4a84_0.conda": { + "build": "py35h6fe4a84_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "44458770f757a25d32e4409c5a4f4670", + "name": "transaction", + "sha256": "b48e090b210477ad07fe27301af5a033ce1ae4bd678a99467bd1084906c27359", + "size": 78370, + "subdir": "linux-64", + "timestamp": 1507984352140, + "version": "2.1.2" + }, + "transaction-2.1.2-py36h49b28f5_0.conda": { + "build": "py36h49b28f5_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "39827acc7a271e0134a82e743363444d", + "name": "transaction", + "sha256": "f2b9577de199e1c98b5cbd53fdb411bca14116f57880eb10162e37cdbf5329ad", + "size": 78783, + "subdir": "linux-64", + "timestamp": 1507984350879, + "version": "2.1.2" + }, + "transaction-2.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "68b1c5820e7fd55f1e828a57921af1e7", + "name": "transaction", + "sha256": "246efdf603b011056a75f9848c2d9a41827d9d7fd5f2f6a065bd9492777edaaf", + "size": 76908, + "subdir": "linux-64", + "timestamp": 1520793723120, + "version": "2.2.0" + }, + "transaction-2.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "9f9ca8e9f49482e2987efc9c83b12d78", + "name": "transaction", + "sha256": "695bc11436073c74cdbd50639cc97656d7d8b58b5f5a475948fe08cd719cac58", + "size": 80476, + "subdir": "linux-64", + "timestamp": 1520793741153, + "version": "2.2.0" + }, + "transaction-2.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "40411fd3976e4ee16c04af12b1d2f828", + "name": "transaction", + "sha256": "f0f1e43ed185b2ed4a85d7f62baa2f2c6a02efde8e1a8f2658a659b9dd234411", + "size": 79897, + "subdir": "linux-64", + "timestamp": 1520793702029, + "version": "2.2.0" + }, + "transaction-2.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "e89e5196d8929d5da309a2c95d60e5e5", + "name": "transaction", + "sha256": "a1ad2744c83bcc3965d358c9f8c31c5267a26c617fe066c65652644232ab127d", + "size": 76281, + "subdir": "linux-64", + "timestamp": 1522715272089, + "version": "2.2.1" + }, + "transaction-2.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "9a093bfe84d189a993888e5eb46f7713", + "name": "transaction", + "sha256": "885fdb974e9411a7860be2be9bf078ef3dbcf34e0ced2b78293c35ce227a0a3f", + "size": 79933, + "subdir": "linux-64", + "timestamp": 1522715307030, + "version": "2.2.1" + }, + "transaction-2.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "18bfc134a59112c6c3b5bd25f102c935", + "name": "transaction", + "sha256": "010a0cba4ec6448cc912d4fb6e0dc890b0835f32c5e923f8d4c74d0429e526c1", + "size": 80261, + "subdir": "linux-64", + "timestamp": 1522715306665, + "version": "2.2.1" + }, + "transaction-2.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "be250994c95867d889507a614208b8c1", + "name": "transaction", + "sha256": "cdff8848d6262392bf2ef59b97b2ce0260e10f40bf434816729682933dfbc9ee", + "size": 79284, + "subdir": "linux-64", + "timestamp": 1531060322152, + "version": "2.2.1" + }, + "transaction-2.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "5552b6c66542dca03419b845d43de6c5", + "name": "transaction", + "sha256": "0b808532e3ff210857bc3591b6e9c00c6d83c1aaa71bfbf6a69b1ecd4992412a", + "size": 77327, + "subdir": "linux-64", + "timestamp": 1541055602251, + "version": "2.4.0" + }, + "transaction-2.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "f08ff486acd4d56e13fc93cb2b7a6e57", + "name": "transaction", + "sha256": "ae40da89bee78b32296e4bbb0ca2b42aba94664ced9e1492ecf07cd9b52faaed", + "size": 80427, + "subdir": "linux-64", + "timestamp": 1541055638288, + "version": "2.4.0" + }, + "transaction-2.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "65fec0397253e043555889eda87a9c85", + "name": "transaction", + "sha256": "907195e6ed18b16446802e43fea9300b52d49328223eb9c7a5557738ac125e60", + "size": 81842, + "subdir": "linux-64", + "timestamp": 1541055582791, + "version": "2.4.0" + }, + "transaction-2.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "d0ce1185b52bb9d9b0032ee88aee9f7b", + "name": "transaction", + "sha256": "e962ab3c6aac31691cbad647c28b71570d2209bdbefe8334dc1ae2a01468d6b5", + "size": 82345, + "subdir": "linux-64", + "timestamp": 1574153487282, + "version": "2.4.0" + }, + "transaction-3.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "de48e5ff38ad544a5af590116783da4e", + "name": "transaction", + "sha256": "820eab4d5ad7cd0b96be835f119d35f492a33d3f83b2914bb52810c5a535198f", + "size": 79142, + "subdir": "linux-64", + "timestamp": 1598413056858, + "version": "3.0.0" + }, + "transaction-3.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "d9496a2e6d537b3e534945ac91cfc06d", + "name": "transaction", + "sha256": "986897a85b177eea67cf09492880b849150a7e0c12602c2e5960ea946342b1e2", + "size": 79249, + "subdir": "linux-64", + "timestamp": 1598413031717, + "version": "3.0.0" + }, + "transaction-3.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "f68fd304cb4ffdeed07e09262a65aa85", + "name": "transaction", + "sha256": "469842a21d21b61c96a2bb5dc98f4449b3fe4e4cecbd4b9bce81d5f524afc99e", + "size": 78775, + "subdir": "linux-64", + "timestamp": 1598413034834, + "version": "3.0.0" + }, + "transaction-3.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "bcf503347de5e79089c83011139d8a39", + "name": "transaction", + "sha256": "cf7cdae5c2677462ae7c9bbedb56fdfdde0044214729bafa9a37144df7b18fde", + "size": 79050, + "subdir": "linux-64", + "timestamp": 1607563572236, + "version": "3.0.0" + }, + "transaction-3.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "7404a8784cae2db2c38a3a1621c459e2", + "name": "transaction", + "sha256": "326da42ad21e34ef22592eabc501c46231a7be77d4150c51160aa9147d6a8a3b", + "size": 79262, + "subdir": "linux-64", + "timestamp": 1640813156947, + "version": "3.0.1" + }, + "transaction-3.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "ad01dbd0b073008a4a4ed3f497caeae5", + "name": "transaction", + "sha256": "b074eed5fe5470806a1fe7af3d1684903297b9654f69bf2d96b385e7ed9d42d3", + "size": 103012, + "subdir": "linux-64", + "timestamp": 1676863310923, + "version": "3.0.1" + }, + "transaction-3.0.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "85cac5726ce60c66a74daa90721eb8b2", + "name": "transaction", + "sha256": "b951680b01d51532b663c61fceb92265eaacbae96ea20c530b9789215c2f32bd", + "size": 77547, + "subdir": "linux-64", + "timestamp": 1607710306298, + "version": "3.0.1" + }, + "transaction-3.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "4ea64cd3e929f9ace0a107c681aeb926", + "name": "transaction", + "sha256": "83af61712b36551f4875463c8e69f9ba6919f764111bfbf754e5174184900d78", + "size": 78505, + "subdir": "linux-64", + "timestamp": 1607710331062, + "version": "3.0.1" + }, + "transaction-3.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "ccc6de40be2899d41c272e9aff782d3c", + "name": "transaction", + "sha256": "46da682f1cdbca368f6d9769216888effb50a396bb57db3e4f981766228c5fc9", + "size": 78105, + "subdir": "linux-64", + "timestamp": 1607710315123, + "version": "3.0.1" + }, + "transaction-3.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.interface" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "df014523e965258e001dddb299298095", + "name": "transaction", + "sha256": "b021b21d4a36618ad5b5c5d062c7fcac56dd80cf5e02759d0a3a4f1965ecb56d", + "size": 79386, + "subdir": "linux-64", + "timestamp": 1607710323256, + "version": "3.0.1" + }, + "transformers-4.18.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.1.0,<1.0", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.10,<3.11.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "sacremoses", + "tokenizers >=0.11.1,!=0.11.3,<0.13", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c9458c0a945937cdb1ac65d0529f4ce8", + "name": "transformers", + "sha256": "4801e6a16c84170c919e4a8f6cd65ba8d60ffa5ad276c0c61eeed5a419f34e84", + "size": 3045105, + "subdir": "linux-64", + "timestamp": 1651834558977, + "version": "4.18.0" + }, + "transformers-4.18.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "filelock", + "huggingface_hub >=0.1.0,<=0.9.1", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.10,<3.11.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "sacremoses", + "tokenizers >=0.11.1,!=0.11.3,<0.13", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c57eafb634563563169bcf49901bdbae", + "name": "transformers", + "sha256": "9bb8e364e8f9be3716c24589ffdf6ecc677a6c97cc14dff5e3fa2b7ce5a51036", + "size": 3745162, + "subdir": "linux-64", + "timestamp": 1667833520442, + "version": "4.18.0" + }, + "transformers-4.18.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.1.0,<1.0", + "importlib_metadata", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.7,<3.8.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "sacremoses", + "tokenizers >=0.11.1,!=0.11.3,<0.13", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "70187dfb375ced48dd5758303b208452", + "name": "transformers", + "sha256": "595ef35f5eb19670503b1801127df65137ebc68fba8aeaecbefd6828d109d51b", + "size": 2986567, + "subdir": "linux-64", + "timestamp": 1651834485145, + "version": "4.18.0" + }, + "transformers-4.18.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "filelock", + "huggingface_hub >=0.1.0,<=0.9.1", + "importlib_metadata", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.7,<3.8.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "sacremoses", + "tokenizers >=0.11.1,!=0.11.3,<0.13", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e6023cd368d77a67bb1d26d5957e0037", + "name": "transformers", + "sha256": "4db65ecc207ce48eecbc336e81e92c9c4c104b349c9490307893e2cd7f976199", + "size": 3682601, + "subdir": "linux-64", + "timestamp": 1667833576418, + "version": "4.18.0" + }, + "transformers-4.18.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.1.0,<1.0", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.8,<3.9.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "sacremoses", + "tokenizers >=0.11.1,!=0.11.3,<0.13", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e17e36441e7669cffe4950ddf805f711", + "name": "transformers", + "sha256": "9b146f373c34842d3d49c0ed9c2af8d95b79f34bfe3d1fb8c63b9182705c6f31", + "size": 3003328, + "subdir": "linux-64", + "timestamp": 1651834425709, + "version": "4.18.0" + }, + "transformers-4.18.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "filelock", + "huggingface_hub >=0.1.0,<=0.9.1", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.8,<3.9.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "sacremoses", + "tokenizers >=0.11.1,!=0.11.3,<0.13", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f2d3264e76ca29f8add51d67ae5c72bb", + "name": "transformers", + "sha256": "4205d5e53d93a2b09f6ac62daff062f37e2d23e4807f3fcb53d3a991e04f2da3", + "size": 3707430, + "subdir": "linux-64", + "timestamp": 1667833460441, + "version": "4.18.0" + }, + "transformers-4.18.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.1.0,<1.0", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.9,<3.10.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "sacremoses", + "tokenizers >=0.11.1,!=0.11.3,<0.13", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "008f0c514e4da7b463fa98c23b3422aa", + "name": "transformers", + "sha256": "f2ac0fe42f877b223a3ca2f0a831010a00102669b41f5fc96a187bb210e742f6", + "size": 2996501, + "subdir": "linux-64", + "timestamp": 1651834359138, + "version": "4.18.0" + }, + "transformers-4.18.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "filelock", + "huggingface_hub >=0.1.0,<=0.9.1", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.9,<3.10.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "sacremoses", + "tokenizers >=0.11.1,!=0.11.3,<0.13", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6ada8d38f0f787c76759348f16a88e8c", + "name": "transformers", + "sha256": "076bec109a000c8ecdf38e02bf641817b910572cc05214030efe3d181e467b5f", + "size": 3699417, + "subdir": "linux-64", + "timestamp": 1667833633252, + "version": "4.18.0" + }, + "transformers-4.24.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.10.0,<1.0", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.10,<3.11.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "tokenizers >=0.11.1,!=0.11.3,<0.14", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fff8e5a365c65db7d8c0fc37a99a8e8f", + "name": "transformers", + "sha256": "2721580d00817fb67f9316d5a4812261582d873b16aa5d26a8850bae44ce0ebb", + "size": 5038911, + "subdir": "linux-64", + "timestamp": 1667919486622, + "version": "4.24.0" + }, + "transformers-4.24.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.10.0,<1.0", + "importlib-metadata", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.7,<3.8.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "tokenizers >=0.11.1,!=0.11.3,<0.14", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "48f641b84bf0edc2722d63303d655db3", + "name": "transformers", + "sha256": "dc3bf4966ac33271453729a6fac2047f364083986c7a1db8ea45ae303e47de38", + "size": 4941751, + "subdir": "linux-64", + "timestamp": 1667919674956, + "version": "4.24.0" + }, + "transformers-4.24.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.10.0,<1.0", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.8,<3.9.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "tokenizers >=0.11.1,!=0.11.3,<0.14", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "32220c40f9b9d87ddb0e5a6322994750", + "name": "transformers", + "sha256": "4b9b0cb409db93b2e7f8def1833ece7896e2565daaf9ad9d349e4978cf89fee1", + "size": 4976025, + "subdir": "linux-64", + "timestamp": 1667919613014, + "version": "4.24.0" + }, + "transformers-4.24.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "filelock", + "huggingface_hub >=0.10.0,<1.0", + "numpy >=1.17", + "packaging >=20.0", + "python >=3.9,<3.10.0a0", + "pytorch", + "pyyaml >=5.1", + "regex !=2019.12.17", + "requests", + "tokenizers >=0.11.1,!=0.11.3,<0.14", + "tqdm >=4.27" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "11df8d99de653035fd8f06b8c2805f3d", + "name": "transformers", + "sha256": "8d1f767dcd1055655cc2abde148c162ecb037a9238be600ea5f98f955ffaf9f6", + "size": 4966681, + "subdir": "linux-64", + "timestamp": 1667919551888, + "version": "4.24.0" + }, + "translationstring-1.3-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "98c93fd04aaad4661b526ae0a4cf847f", + "name": "translationstring", + "sha256": "bc2bd9db073b7b63e4826c2059484ea91c788b9ebb1b2036a155c9c8fd7f414a", + "size": 23776, + "subdir": "linux-64", + "timestamp": 1530025598447, + "version": "1.3" + }, + "translationstring-1.3-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "712ebee87ab7fa9da3054d8eb30cb898", + "name": "translationstring", + "sha256": "29d14e8cbe0eded6a1e0acae1c8486ea364c28a400edd3723039144a092a1c49", + "size": 25054, + "subdir": "linux-64", + "timestamp": 1640795464890, + "version": "1.3" + }, + "translationstring-1.3-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "md5": "936cdc012e47cc4ddbd5e18466f2ad6d", + "name": "translationstring", + "sha256": "caab0298c1f8d110bdc9ca48b34d88ca5041d59579a9c0a978f11b575325f65f", + "size": 30973, + "subdir": "linux-64", + "timestamp": 1676904199589, + "version": "1.3" + }, + "translationstring-1.3-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "61fded1365698a02dc1026bcfcb526a2", + "name": "translationstring", + "sha256": "59b7af3e5e03120528d475d7dd5bfedc3bd88e0cc2df17b4004280051cebc9f5", + "size": 24426, + "subdir": "linux-64", + "timestamp": 1530025690958, + "version": "1.3" + }, + "translationstring-1.3-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "1e955f1b2a808cb8116676b82bf0c4d2", + "name": "translationstring", + "sha256": "80874b8aa6f290a7ca0e309b52cb58392314190056a60ba304136859f7fb0179", + "size": 24436, + "subdir": "linux-64", + "timestamp": 1530025409212, + "version": "1.3" + }, + "translationstring-1.3-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "5424077da0c4568f9ceba9549e0f4df4", + "name": "translationstring", + "sha256": "82aa28a6c3eeece865a0b5a2107470f240e1078018f1020e33ca2ffce77ac852", + "size": 263889, + "subdir": "linux-64", + "timestamp": 1613502178365, + "version": "1.3" + }, + "translationstring-1.3-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "7eab6d5f4e13671907daa90e2cec95a3", + "name": "translationstring", + "sha256": "806504f25ab8256fd01459f492ab863895e38f5ece8ad6ae6521a2483b8c5276", + "size": 24396, + "subdir": "linux-64", + "timestamp": 1530875146450, + "version": "1.3" + }, + "translationstring-1.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "d8bd5633f5d20a355aa8c550c92d952d", + "name": "translationstring", + "sha256": "826679684954657fd607cee2eb61164793b732ce9de34ab209afc8d424ae81b6", + "size": 264031, + "subdir": "linux-64", + "timestamp": 1613502176595, + "version": "1.3" + }, + "translationstring-1.3-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "45d5fdae45f436129f19f2fe1a7e4947", + "name": "translationstring", + "sha256": "d42f2752bfc8be80354439ab88bc359f96c928e63022448d5266be95de09c937", + "size": 25044, + "subdir": "linux-64", + "timestamp": 1573200482512, + "version": "1.3" + }, + "translationstring-1.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "2e451a9399cf519ce9963ec032dbdb41", + "name": "translationstring", + "sha256": "9a4175ffd0df53e865067ebd9eee7c11faf80372cc8e3cbcc1c9f73a95df8334", + "size": 265251, + "subdir": "linux-64", + "timestamp": 1613502835759, + "version": "1.3" + }, + "translationstring-1.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "bdbcbab9618ff2826d2b9a6af48a5934", + "name": "translationstring", + "sha256": "cd6497fd79317e204a3b87f838988b3c85cc6cb8e3121e5ac6ae2a86614865fd", + "size": 264350, + "subdir": "linux-64", + "timestamp": 1613502838023, + "version": "1.3" + }, + "trio-0.18.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.10,<3.11.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de4ede4ac5ceed08ff1bfba8ec61a899", + "name": "trio", + "sha256": "c149e95e232ffaa4c54c561e3abc11e16c49445b9d994663b662a124f333825e", + "size": 476738, + "subdir": "linux-64", + "timestamp": 1640811304327, + "version": "0.18.0" + }, + "trio-0.18.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "contextvars >=2.1", + "idna", + "outcome", + "python >=3.6,<3.7.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9efc5c21b42dd04ee2557500db10808c", + "name": "trio", + "sha256": "fdbfe7dec4dc6fb09c39f25f4679abb35af394fbfeddfa3dd0ee4d64e33ee755", + "size": 464461, + "subdir": "linux-64", + "timestamp": 1610405384316, + "version": "0.18.0" + }, + "trio-0.18.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.7,<3.8.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8bbb7c8e9741a02d555d82029cc43452", + "name": "trio", + "sha256": "751dabdc6c83173d79f8a094bdaa57e2fc729a5888288cbaff6a5a08867574d4", + "size": 458705, + "subdir": "linux-64", + "timestamp": 1610405393257, + "version": "0.18.0" + }, + "trio-0.18.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.8,<3.9.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7748fc01d686c5dbce5e57994537a4a8", + "name": "trio", + "sha256": "d42a21d4e6426bd03be9f71b1042763f8244da037e70db2a43bfd741fc3081c7", + "size": 460399, + "subdir": "linux-64", + "timestamp": 1610404959266, + "version": "0.18.0" + }, + "trio-0.18.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.9,<3.10.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "99fef5a528a38d293b26c2a1db9302a6", + "name": "trio", + "sha256": "fae0f63070ea28e268801c0ccd7bfcfeb1572f653ec19b3117a09b5dd40df8cc", + "size": 474932, + "subdir": "linux-64", + "timestamp": 1614065319615, + "version": "0.18.0" + }, + "trio-0.19.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.10,<3.11.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a50e0244bcff8885f08b8d4b90985146", + "name": "trio", + "sha256": "6082500f9c412304137ec4578351f96b61607ec40582df95f0fde207dc2b3c0b", + "size": 483056, + "subdir": "linux-64", + "timestamp": 1644403440474, + "version": "0.19.0" + }, + "trio-0.19.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.11,<3.12.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2fbd29c81046856d0fb59297d1332053", + "name": "trio", + "sha256": "683ea14e72179af0bd642504d7a2e405d17ac87a6ccb8332576e26446faf3b11", + "size": 638235, + "subdir": "linux-64", + "timestamp": 1676863327335, + "version": "0.19.0" + }, + "trio-0.19.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.7,<3.8.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6e22fe422dddb6fb3b0ba2eb14f87597", + "name": "trio", + "sha256": "e10edb673aa715caf53b949db0e0d028c1fbd99985bf22671ef52927a469b12b", + "size": 464652, + "subdir": "linux-64", + "timestamp": 1644403425469, + "version": "0.19.0" + }, + "trio-0.19.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.8,<3.9.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3d41f81c348fd43f7c208429bc24bfd9", + "name": "trio", + "sha256": "99bc0c77b47c939546af4fcac0fd05dd0c3f0bf90533b25afe786739bb93cde2", + "size": 472387, + "subdir": "linux-64", + "timestamp": 1644385298098, + "version": "0.19.0" + }, + "trio-0.19.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.9,<3.10.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "973450d5dc748e9b3c73d5de739bda4e", + "name": "trio", + "sha256": "5ec5995fa28d4be063ea098813eba24b4aed43c7d095c96309511f29364a843f", + "size": 476600, + "subdir": "linux-64", + "timestamp": 1644387179434, + "version": "0.19.0" + }, + "trio-0.22.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "exceptiongroup >=1.0.0rc9", + "idna", + "outcome", + "python >=3.10,<3.11.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4dffefb32f8b8e155eb4867b82dd3034", + "name": "trio", + "sha256": "f9dc80e637213298cf4d47fddf6e86502b3538e11d73a0fa6d95383ef6c5f232", + "size": 544495, + "subdir": "linux-64", + "timestamp": 1677879591809, + "version": "0.22.0" + }, + "trio-0.22.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "idna", + "outcome", + "python >=3.11,<3.12.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f2f0cbf1da0531f5b7e79067ee56751", + "name": "trio", + "sha256": "1e609c515dffbafe0a48ecb1c5032d01339dd3894a1a76a6cec20a7bb80457d7", + "size": 685678, + "subdir": "linux-64", + "timestamp": 1677860023931, + "version": "0.22.0" + }, + "trio-0.22.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "exceptiongroup >=1.0.0rc9", + "idna", + "outcome", + "python >=3.8,<3.9.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a1f17eac4818ed7dd5af3bb5d2a6f2c2", + "name": "trio", + "sha256": "3ee3e5b29e4e121c2f7fae3e32762b994ceb29853a4a0eddd685b3023b94f8ec", + "size": 533697, + "subdir": "linux-64", + "timestamp": 1677879647311, + "version": "0.22.0" + }, + "trio-0.22.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "async_generator >=1.9", + "attrs >=19.2.0", + "exceptiongroup >=1.0.0rc9", + "idna", + "outcome", + "python >=3.9,<3.10.0a0", + "sniffio", + "sortedcontainers" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9560ac15acb44f7cf442c954d313463e", + "name": "trio", + "sha256": "563190695ab919126f4bc096471857ac71e93c004f2253971b8ff78ec40267a9", + "size": 537943, + "subdir": "linux-64", + "timestamp": 1677879619289, + "version": "0.22.0" + }, + "trollius-2.2-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "futures", + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cce3fa393968970df90e6bbb7fc543d4", + "name": "trollius", + "sha256": "1e66c1f43eae93493522aac0e0afe2350908405815a1a681d2e6ee36f584916b", + "size": 183031, + "subdir": "linux-64", + "timestamp": 1522776279053, + "version": "2.2" + }, + "trollius-2.2-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "06acd4ffb1aed4e338f9d2fd846bbdf7", + "name": "trollius", + "sha256": "e59e77ccf6a8c00f4556879610bb6bc70e44ccf23981c60394d88c97d21fd496", + "size": 188796, + "subdir": "linux-64", + "timestamp": 1522776396637, + "version": "2.2" + }, + "trollius-2.2-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1869094c6120aeb8a750d9977b58ec76", + "name": "trollius", + "sha256": "771b15c00e5a53a0ed33933913bb622093efed2024915613b0e2563b855d6a59", + "size": 184557, + "subdir": "linux-64", + "timestamp": 1522776395895, + "version": "2.2" + }, + "trove-classifiers-2023.3.9-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "41ba99eb09a6b9fe55c44ff18d70d118", + "name": "trove-classifiers", + "sha256": "46559587603aee2d85c638f95cec1bf69cab01f518d27dc628bc732060faf12d", + "size": 22288, + "subdir": "linux-64", + "timestamp": 1679610058698, + "version": "2023.3.9" + }, + "trove-classifiers-2023.3.9-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b28671b451289eee7bf7ad15b055e533", + "name": "trove-classifiers", + "sha256": "d001c1d68677c4793b9fb2bbcabcc4194bcb10f0c60b967b8ec64aff4dc860c9", + "size": 22479, + "subdir": "linux-64", + "timestamp": 1679610083778, + "version": "2023.3.9" + }, + "trove-classifiers-2023.3.9-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "12e8e568a99a69d58c40958ba7b75867", + "name": "trove-classifiers", + "sha256": "6aaec7e65ab154e539a355eae46712c60879f8ce12795b559ed84ce78f27ef6f", + "size": 24646, + "subdir": "linux-64", + "timestamp": 1679610108557, + "version": "2023.3.9" + }, + "trove-classifiers-2023.3.9-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c3ebf9a4948c10106c2de8bed9de0ba5", + "name": "trove-classifiers", + "sha256": "710816088224d6dec79d5c942b73abe9a4f28af96d26e52da51ae120729bacb1", + "size": 22237, + "subdir": "linux-64", + "timestamp": 1679610132316, + "version": "2023.3.9" + }, + "trustme-0.9.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "idna", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 or MIT", + "license_family": "MIT", + "md5": "837365f00d77519a410da28c97e7353c", + "name": "trustme", + "sha256": "fd8c42509d9323a8865df4397d83369f173635606c0c626730456bda809f09f6", + "size": 31565, + "subdir": "linux-64", + "timestamp": 1669834420113, + "version": "0.9.0" + }, + "trustme-0.9.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "idna", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0 or MIT", + "license_family": "MIT", + "md5": "16daefa8d7039a65c9736094e7ed6ac0", + "name": "trustme", + "sha256": "91ba102b371d89c35f3b0ad7a65e7f29013aea9c143bbd01bd80a901821bd490", + "size": 34163, + "subdir": "linux-64", + "timestamp": 1676863344745, + "version": "0.9.0" + }, + "trustme-0.9.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "idna", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 or MIT", + "license_family": "MIT", + "md5": "583eafdbde60d83a1e61e73e69ce87b4", + "name": "trustme", + "sha256": "3c1d153adbabf34ff6267353c19146fcbd5ce80a95190fbb76ba150a0e1af5da", + "size": 31407, + "subdir": "linux-64", + "timestamp": 1669834386459, + "version": "0.9.0" + }, + "trustme-0.9.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "idna", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 or MIT", + "license_family": "MIT", + "md5": "0031f3bf4aee785689e61dc146d41208", + "name": "trustme", + "sha256": "de5e504cf5caf88e43daf92debb34071567938f7708fbf7be24edc874c83b4be", + "size": 31474, + "subdir": "linux-64", + "timestamp": 1669834323982, + "version": "0.9.0" + }, + "trustme-0.9.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "cryptography", + "idna", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 or MIT", + "license_family": "MIT", + "md5": "06f63a28046b2b37070cca25923d8479", + "name": "trustme", + "sha256": "cfbc8bd5df32bf41258ff7be948d39e4c79cf3c56e7c87e0414755f47ee58075", + "size": 31541, + "subdir": "linux-64", + "timestamp": 1669834355105, + "version": "0.9.0" + }, + "twine-1.11.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pkginfo >=1.4.2", + "python >=2.7,<2.8.0a0", + "requests >=2.5.0,!=2.15,!=2.16", + "requests-toolbelt >=0.8.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "31f45368479568d24e0e7668a35a4275", + "name": "twine", + "sha256": "1c4fedcc6eaefa66e1089fa932544204952766e545dadc0a83c366c44beaf3a0", + "size": 37284, + "subdir": "linux-64", + "timestamp": 1522178626619, + "version": "1.11.0" + }, + "twine-1.11.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "pkginfo >=1.4.2", + "python >=3.5,<3.6.0a0", + "requests >=2.5.0,!=2.15,!=2.16", + "requests-toolbelt >=0.8.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "7de5ebf42a6baf7ff6644517376e8459", + "name": "twine", + "sha256": "e3e14f41bde1a2967bc5b88ec64cfce6ff0551ac3e6247841deb5642062f792f", + "size": 37603, + "subdir": "linux-64", + "timestamp": 1522178698204, + "version": "1.11.0" + }, + "twine-1.11.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pkginfo >=1.4.2", + "python >=3.6,<3.7.0a0", + "requests >=2.5.0,!=2.15,!=2.16", + "requests-toolbelt >=0.8.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9ee7a541cb5631f7d50a7770cd1cc109", + "name": "twine", + "sha256": "93fe665a5efe150e0a9ac5c16bca62d5d1622bf6cfa905e0cf98bbb266ff3a08", + "size": 37306, + "subdir": "linux-64", + "timestamp": 1522178495811, + "version": "1.11.0" + }, + "twine-1.11.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pkginfo >=1.4.2", + "python >=3.7,<3.8.0a0", + "requests >=2.5.0,!=2.15,!=2.16", + "requests-toolbelt >=0.8.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4d6dc3a2827c90b227e201b3797e2f4d", + "name": "twine", + "sha256": "e6b39d66a7a3e032158ce25d29a9dfd714fb68246a29c6d45da085630c3299f8", + "size": 37074, + "subdir": "linux-64", + "timestamp": 1531060357970, + "version": "1.11.0" + }, + "twine-1.12.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pkginfo >=1.4.2", + "python >=2.7,<2.8.0a0", + "readme_renderer >=21.0", + "requests >=2.5.0,!=2.15,!=2.16", + "requests-toolbelt >=0.8.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8b043543126ee29ae99c413e2455b3a8", + "name": "twine", + "sha256": "2f1f3ea9df14d60de4778a5656b3fcce7c75eb34b601c698adb72765eb8d5487", + "size": 47147, + "subdir": "linux-64", + "timestamp": 1539903056584, + "version": "1.12.1" + }, + "twine-1.12.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "pkginfo >=1.4.2", + "python >=3.6,<3.7.0a0", + "readme_renderer >=21.0", + "requests >=2.5.0,!=2.15,!=2.16", + "requests-toolbelt >=0.8.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "e77c41fddbbe5887d5cef1f687a0a813", + "name": "twine", + "sha256": "d8c1c581d152953e707f782f7b6df09288819ff33cbd9a2dd68ef09cbd7e4471", + "size": 47699, + "subdir": "linux-64", + "timestamp": 1539903098028, + "version": "1.12.1" + }, + "twine-1.12.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "pkginfo >=1.4.2", + "python >=3.7,<3.8.0a0", + "readme_renderer >=21.0", + "requests >=2.5.0,!=2.15,!=2.16", + "requests-toolbelt >=0.8.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6553b134edc3d7ff16953c8607154825", + "name": "twine", + "sha256": "2764c5d423777cb6b9fc6212f5c80c883963c4d6985fc346175fcce0000a41cb", + "size": 47785, + "subdir": "linux-64", + "timestamp": 1539903082224, + "version": "1.12.1" + }, + "twine-3.2.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.6,<3.7.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "81ee01afee5348900d750d882be0e56f", + "name": "twine", + "sha256": "f5e41701214a9d9f5b22f1d7fceb08f2370a03ccdc0c06b7192b50711bb87a31", + "size": 53167, + "subdir": "linux-64", + "timestamp": 1605552671105, + "version": "3.2.0" + }, + "twine-3.2.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.7,<3.8.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "48f68331795adc1465dbcf470a8e5dd9", + "name": "twine", + "sha256": "cd15abea9f6e8cc11fb5b2792abbbaf34b92574b05d977e9103e41785e2cc98d", + "size": 53325, + "subdir": "linux-64", + "timestamp": 1605552653176, + "version": "3.2.0" + }, + "twine-3.2.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.8,<3.9.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1676a35cc3b43399c50c877c1b4ee342", + "name": "twine", + "sha256": "c5b175a1160ba832554c38804473e60e4c315f010368c6846fa366e4fe16d6c9", + "size": 53501, + "subdir": "linux-64", + "timestamp": 1605552656232, + "version": "3.2.0" + }, + "twine-3.3.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.6,<3.7.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "857728cd8c446908005dab0c8aa45361", + "name": "twine", + "sha256": "85c577d267a93a54ce0919d738f9c40133693ee23b0376625bc1d706bc61546c", + "size": 50013, + "subdir": "linux-64", + "timestamp": 1608836970573, + "version": "3.3.0" + }, + "twine-3.3.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.6,<3.7.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7ea0838be9eb975c51c72d2c9993743d", + "name": "twine", + "sha256": "1cace9fba83df705906f5ba65d899368470fcea5ffe417291e4c220b86c3b52f", + "size": 54206, + "subdir": "linux-64", + "timestamp": 1610483983726, + "version": "3.3.0" + }, + "twine-3.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.7,<3.8.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "85a98c329496c0ad9215f878151aa98f", + "name": "twine", + "sha256": "a8fbaf9eb4fc65b1ec658c705e2acae4f516426881a84905809c6241e45b14f8", + "size": 49573, + "subdir": "linux-64", + "timestamp": 1608836978808, + "version": "3.3.0" + }, + "twine-3.3.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.7,<3.8.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "23e4157c537d1bc29e266b3de432b6af", + "name": "twine", + "sha256": "b965f4e1ba94a7aaf930407e2fe4524ec8a8d9c7bb59aca6bb0b9eaeb76c307d", + "size": 54626, + "subdir": "linux-64", + "timestamp": 1610483995083, + "version": "3.3.0" + }, + "twine-3.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "colorama >=0.4.3", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.8,<3.9.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8a8bb1018250390900aa8022ad0764f1", + "name": "twine", + "sha256": "d1de68df90cfeaf07676a65941b32b17cad9b5af7d7713aafbfc74a8f1073311", + "size": 50021, + "subdir": "linux-64", + "timestamp": 1608836934449, + "version": "3.3.0" + }, + "twine-3.3.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.8,<3.9.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5e1f6bc523034504079b41e319b7bcaf", + "name": "twine", + "sha256": "28acbcaa72f27df8e3e5daba23e66548ecf589779cd085f4048a462190dc5b8e", + "size": 55218, + "subdir": "linux-64", + "timestamp": 1610483982738, + "version": "3.3.0" + }, + "twine-3.4.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.6,<3.7.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4c8f89ef5252842d17aa20e2c62dbe31", + "name": "twine", + "sha256": "97dad78ca65b59da5974851a47e4910d83e68f3244886b754a4e852fa560b475", + "size": 48041, + "subdir": "linux-64", + "timestamp": 1615911077260, + "version": "3.4.0" + }, + "twine-3.4.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.7,<3.8.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4968e6bba22ef303295304038636494c", + "name": "twine", + "sha256": "6c31077882f10492198f3972a65c17044e0bb58b2ad438fc5caeaef0032a6f55", + "size": 48021, + "subdir": "linux-64", + "timestamp": 1615909231584, + "version": "3.4.0" + }, + "twine-3.4.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.8,<3.9.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "03e7b4bccbf631e98ba7ad5e024222da", + "name": "twine", + "sha256": "66e92004c6496b1a3a0e0026af2997af8b5756a3bb950bec0db0decc72ac20f9", + "size": 48395, + "subdir": "linux-64", + "timestamp": 1615910902977, + "version": "3.4.0" + }, + "twine-3.4.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.9,<3.10.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "26d549230feb489622feafde4442a0c9", + "name": "twine", + "sha256": "b9c86ea8b7b711ecbe3f744f03786fe26bbf3927361c31e02d904169063a52f9", + "size": 49034, + "subdir": "linux-64", + "timestamp": 1615911069711, + "version": "3.4.0" + }, + "twine-3.4.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.10,<3.11.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3a78282ab6da7f0bcff5f18bd2656f24", + "name": "twine", + "sha256": "de187e9c3c3659edde673434ae6a3866abd039c410a6ab32f5c02c7c6f6540cb", + "size": 49588, + "subdir": "linux-64", + "timestamp": 1642521132359, + "version": "3.4.1" + }, + "twine-3.4.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.6,<3.7.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9283c278d205171e3e93387846984fe5", + "name": "twine", + "sha256": "0d672f01a87b05cfc3c2e70d3dd7a0d369559ccfbcc918c19c6c28a80b45c369", + "size": 48315, + "subdir": "linux-64", + "timestamp": 1616171709650, + "version": "3.4.1" + }, + "twine-3.4.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.6,<3.7.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c769bc3a687fcf563e631eb950e6048e", + "name": "twine", + "sha256": "fdcc82e08762d033c97818f816d4d460e0ed892cfd684a57314ee923c8d0c1c9", + "size": 48793, + "subdir": "linux-64", + "timestamp": 1616009508848, + "version": "3.4.1" + }, + "twine-3.4.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.7,<3.8.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6a8983d3c4b4995a78b1892da75bdaac", + "name": "twine", + "sha256": "e51bbdb7170d701c5a0950fc9fb25806c77af62a3ac9c0d8de1461d7eae72e8a", + "size": 48758, + "subdir": "linux-64", + "timestamp": 1616171710696, + "version": "3.4.1" + }, + "twine-3.4.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.7,<3.8.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7a2cbdfc8cc68333f87e62ceed52191b", + "name": "twine", + "sha256": "536a9caf85bcb4fa9a76690b8493569e86d65541191b01a55fcb198aefb63991", + "size": 48934, + "subdir": "linux-64", + "timestamp": 1616008223480, + "version": "3.4.1" + }, + "twine-3.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.8,<3.9.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ace2af7a6ea09ef5d52dcb5ba76695f2", + "name": "twine", + "sha256": "f865947fae15bcf19547aff25c81c73756bc20d19af3c9a7973e0f9fa2118bb5", + "size": 49072, + "subdir": "linux-64", + "timestamp": 1616169733790, + "version": "3.4.1" + }, + "twine-3.4.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.8,<3.9.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "369c5335fb0831c55cc4cfcdaa948b17", + "name": "twine", + "sha256": "7991721a9ee2220d2ddbb23cff4c863a348cbfd9abb8637a693e7af8b3983abb", + "size": 49110, + "subdir": "linux-64", + "timestamp": 1616010131367, + "version": "3.4.1" + }, + "twine-3.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.9,<3.10.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c9a949778da8162783c7f50048c31228", + "name": "twine", + "sha256": "97ba7b489440c06d2f6983fa5db2231834a89c29fee4072b16f3bba6dc117a98", + "size": 49136, + "subdir": "linux-64", + "timestamp": 1616171224831, + "version": "3.4.1" + }, + "twine-3.4.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "colorama >=0.4.3", + "importlib_metadata >=3.6", + "keyring >=15.1", + "pkginfo >=1.4.2", + "python >=3.9,<3.10.0a0", + "readme_renderer >=21.0", + "requests >=2.20", + "requests-toolbelt >=0.8.0,!=0.9.0", + "rfc3986 >=1.4.0", + "setuptools >=0.7.0", + "tqdm >=4.14" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "365998193fdfe1bed582c786ed334b54", + "name": "twine", + "sha256": "2b6522967d4f2cece8faa111e22ed39ae25d617924ade79415673b18ce492272", + "size": 49336, + "subdir": "linux-64", + "timestamp": 1616010135885, + "version": "3.4.1" + }, + "twisted-17.9.0-py27h7008fb7_0.conda": { + "build": "py27h7008fb7_0", + "build_number": 0, + "constrains": [ + "soappy", + "pyserial >=3.0", + "pyobjc-core", + "pyobjc-framework-CFNetwork", + "pyobjc-framework-Cocoa", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=2.7,<2.8.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a1d54b5aa0b286b12c9664a5d7868a71", + "name": "twisted", + "sha256": "3ecb9d257e1fbfac9a935d4fea6a6eab2df41a69c673057102af592030a309aa", + "size": 4216965, + "subdir": "linux-64", + "timestamp": 1508791899508, + "version": "17.9.0" + }, + "twisted-17.9.0-py35h812867c_0.conda": { + "build": "py35h812867c_0", + "build_number": 0, + "constrains": [ + "soappy", + "pyserial >=3.0", + "pyobjc-core", + "pyobjc-framework-CFNetwork", + "pyobjc-framework-Cocoa", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=3.5,<3.6.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12ac50c38ff6afb84483fd75c38b859d", + "name": "twisted", + "sha256": "66e35683bb7269649cbdf8b6a6b106ca7be18f72717a3268a1aee2f2dc85c7a5", + "size": 4145168, + "subdir": "linux-64", + "timestamp": 1508791932402, + "version": "17.9.0" + }, + "twisted-17.9.0-py36hb8d8d5a_0.conda": { + "build": "py36hb8d8d5a_0", + "build_number": 0, + "constrains": [ + "soappy", + "pyserial >=3.0", + "pyobjc-core", + "pyobjc-framework-CFNetwork", + "pyobjc-framework-Cocoa", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "efc13a653444c6d3052fc31722b670b5", + "name": "twisted", + "sha256": "2e494139e00969247eefadeba0b9dff9707441e040a7604c1701b754070bf693", + "size": 4113747, + "subdir": "linux-64", + "timestamp": 1508791885519, + "version": "17.9.0" + }, + "twisted-18.4.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "constrains": [ + "soappy", + "pyserial >=3.0", + "pyobjc-core", + "pyobjc-framework-CFNetwork", + "pyobjc-framework-Cocoa", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=2.7,<2.8.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "24e38854e37ddbbcba7a596ca1bf6804", + "name": "twisted", + "sha256": "4f10e2d19ecf1510b292bdb05248cb31cc07d3f5b50ad5223125a67189f88b18", + "size": 4255080, + "subdir": "linux-64", + "timestamp": 1525812777618, + "version": "18.4.0" + }, + "twisted-18.4.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "constrains": [ + "soappy", + "pyserial >=3.0", + "pyobjc-core", + "pyobjc-framework-CFNetwork", + "pyobjc-framework-Cocoa", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=3.5,<3.6.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c358912143706c3ddbfa6d9f1f0eed70", + "name": "twisted", + "sha256": "8eef25492be2b648a6a2cf82c271b8fd8400efcf01e0725b09abea89c68b7d62", + "size": 4240629, + "subdir": "linux-64", + "timestamp": 1525813801179, + "version": "18.4.0" + }, + "twisted-18.4.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "constrains": [ + "soappy", + "pyserial >=3.0", + "pyobjc-core", + "pyobjc-framework-CFNetwork", + "pyobjc-framework-Cocoa", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f4261276fa25305e8aaf066859a4b522", + "name": "twisted", + "sha256": "432776e49d50439d2c166dc2edacf2c24bb2e91cbd0732ca505bee0a700fee2f", + "size": 4153916, + "subdir": "linux-64", + "timestamp": 1525813345136, + "version": "18.4.0" + }, + "twisted-18.4.0-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a4dd6bc5fcf915a5a63d8b28db89df68", + "name": "twisted", + "sha256": "073ec0ba40c025e575645e423135a74202f7750c68366473ca4e1174332771f7", + "size": 4160808, + "subdir": "linux-64", + "timestamp": 1530919831601, + "version": "18.4.0" + }, + "twisted-18.7.0-py27h14c3975_1.conda": { + "build": "py27h14c3975_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=2.7,<2.8.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8299eb046c4e3642f2db38a32ab3b3d1", + "name": "twisted", + "sha256": "3621da716e054e036a80591f94827fc5a56d6e145d2231e965baac2b657ef437", + "size": 4238912, + "subdir": "linux-64", + "timestamp": 1533481784772, + "version": "18.7.0" + }, + "twisted-18.7.0-py35h14c3975_1.conda": { + "build": "py35h14c3975_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=3.5,<3.6.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "54b148269720b5d29347df13992279f6", + "name": "twisted", + "sha256": "81564bc61ebab005ba09d4f35e6a9d5e2931f2a5726f8a76549ec81903dab595", + "size": 4224652, + "subdir": "linux-64", + "timestamp": 1533481927057, + "version": "18.7.0" + }, + "twisted-18.7.0-py36h14c3975_1.conda": { + "build": "py36h14c3975_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "00c1fee451ad0394cd37251060ad1fa3", + "name": "twisted", + "sha256": "79e3890ae80a7903e739d11f7736701ab9dc2b1108143f33fc1b495131c27c10", + "size": 4191590, + "subdir": "linux-64", + "timestamp": 1533481927865, + "version": "18.7.0" + }, + "twisted-18.7.0-py37h14c3975_1.conda": { + "build": "py37h14c3975_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.2.0", + "pyasn1", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity", + "zope.interface >=4.0.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5439f372383cea6a2cdd369cfcca488e", + "name": "twisted", + "sha256": "74cf4bcc5005c5ee60b97ba670c327ee7b3b3f27fb83b2a5f645efa8139bd1ec", + "size": 4136090, + "subdir": "linux-64", + "timestamp": 1533481924921, + "version": "18.7.0" + }, + "twisted-18.9.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=17.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=2.7,<2.8.0a0", + "service_identity", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a253425ed5627c24c36ee7c76daa477d", + "name": "twisted", + "sha256": "5436d30f5433aefd24dc18e71405bdb8750fe4aaf8e977255aedda783d1cac73", + "size": 4252124, + "subdir": "linux-64", + "timestamp": 1539712764927, + "version": "18.9.0" + }, + "twisted-18.9.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=17.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da25342a6747ceaaec9ccc7233d8e2a8", + "name": "twisted", + "sha256": "2959c0c34b8b129fc1fbf8f803ced641e4d16b438d3813b1f5fc919335076f05", + "size": 4204667, + "subdir": "linux-64", + "timestamp": 1539712812923, + "version": "18.9.0" + }, + "twisted-18.9.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=17.4.0", + "automat >=0.3.0", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cfc2373c26f94a0f3dbfceef05f3e3e2", + "name": "twisted", + "sha256": "3ddb8124ee37ecc4ffe5bec879fab662d358703600d4bc3112d18490bd229912", + "size": 4144722, + "subdir": "linux-64", + "timestamp": 1539712836654, + "version": "18.9.0" + }, + "twisted-19.10.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=2.7,<2.8.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33b9a6e933fb9cbb13345fad52b39276", + "name": "twisted", + "sha256": "66564e44b9376dd759a9e0c68426e5983b5c300ecaa219b2f5cf94f99f60bafe", + "size": 4309490, + "subdir": "linux-64", + "timestamp": 1573974680291, + "version": "19.10.0" + }, + "twisted-19.10.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "95fc37609f89606974bb2445333d85b5", + "name": "twisted", + "sha256": "8c0ed6f957f0dbfb8e37d4e5222f5e06ac89c4f336cf776307159758b1cef303", + "size": 4264661, + "subdir": "linux-64", + "timestamp": 1573974774309, + "version": "19.10.0" + }, + "twisted-19.10.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba9597495fcf3ba52c276e705fb6b623", + "name": "twisted", + "sha256": "9bc72d1c03da86451b94d0df715cdc4a129b9f6c8b7735181cae4b0aa3af9e07", + "size": 4261860, + "subdir": "linux-64", + "timestamp": 1573974670149, + "version": "19.10.0" + }, + "twisted-19.10.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.8,<3.9.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "893e2645963d57b3651f1bbf5800eef8", + "name": "twisted", + "sha256": "613c909033ff269b6261cf19a2447412c2ac98c37d5ebd33954c4d5da2c806ed", + "size": 4297224, + "subdir": "linux-64", + "timestamp": 1574183880269, + "version": "19.10.0" + }, + "twisted-19.2.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=2.7,<2.8.0a0", + "service_identity", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "85669a7561c8b6d92f46ccdc5197db8f", + "name": "twisted", + "sha256": "4ce8463715b894c0fdbbb0c1f936399deaba35ab2405e5799a61f32a18d7e7f0", + "size": 4233845, + "subdir": "linux-64", + "timestamp": 1556077746868, + "version": "19.2.0" + }, + "twisted-19.2.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4f2ac97358b49acaa13eb05311fcca42", + "name": "twisted", + "sha256": "71ae544029ab1f44efd96def1d187f038015008bfe3548467d342779037ae359", + "size": 4241700, + "subdir": "linux-64", + "timestamp": 1556077748823, + "version": "19.2.0" + }, + "twisted-19.2.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51ecf5beba85aa24af811c37296b0fa9", + "name": "twisted", + "sha256": "4ab714da3673dba1cf50ea6722cfa3e0a1e17f78ffa9c065ce433e1087e6be08", + "size": 4188175, + "subdir": "linux-64", + "timestamp": 1556077677581, + "version": "19.2.0" + }, + "twisted-19.7.0-py27h7b6447c_1.conda": { + "build": "py27h7b6447c_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=2.7,<2.8.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c9abbf0c3339812c4ca7f131d48cd295", + "name": "twisted", + "sha256": "ac4974ebdcc4af43e1ad158664b9d2767c231eb00617beff8ea0313b1d704de7", + "size": 4300326, + "subdir": "linux-64", + "timestamp": 1568312172357, + "version": "19.7.0" + }, + "twisted-19.7.0-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b01c652654dfbbc96bf25cfc3e673759", + "name": "twisted", + "sha256": "7d44a96bd1583b2ee7584d395974fd4f9d98dc09ad3a5dab9a3644a13a4ea9f1", + "size": 4256479, + "subdir": "linux-64", + "timestamp": 1568312161895, + "version": "19.7.0" + }, + "twisted-19.7.0-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb2d7596806940286a42cb0fe4c2191c", + "name": "twisted", + "sha256": "154da02786d532bead6c08aff61c203df79751997f005d4e1b40cbffffe1dd90", + "size": 4253765, + "subdir": "linux-64", + "timestamp": 1568312206542, + "version": "19.7.0" + }, + "twisted-20.3.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "priority >=1.1.0,<2.0", + "h2 >=3.0,<4.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f0dbf92cae1452250650946dee8cec21", + "name": "twisted", + "sha256": "7d192baae0c45818270562d4281c7a94ab6c8cdce948bd8897040c26182a818f", + "size": 4219676, + "subdir": "linux-64", + "timestamp": 1614066280555, + "version": "20.3.0" + }, + "twisted-20.3.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a6a35360bd3ae74ba8b589ea1c8aaf9e", + "name": "twisted", + "sha256": "3a3de3968f3da09ac47232170b0dca03e1c1e57216f4803048715344610b29cc", + "size": 4271661, + "subdir": "linux-64", + "timestamp": 1586466506286, + "version": "20.3.0" + }, + "twisted-20.3.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74e308099e9bd21f835c68d733199a1d", + "name": "twisted", + "sha256": "eabe6c10aec779ad08416739ab9b1cd31d389bd2ba857ae4fe6890f5e06f8b00", + "size": 4221627, + "subdir": "linux-64", + "timestamp": 1614065647386, + "version": "20.3.0" + }, + "twisted-20.3.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3af8d2f69fa1a6c8b3154ade04f4f3f7", + "name": "twisted", + "sha256": "75f83d65a8e54d0afe5d72221a1c42bd1e7e3767cf5ce4c9b602d4df3676e4ba", + "size": 4221210, + "subdir": "linux-64", + "timestamp": 1586466481529, + "version": "20.3.0" + }, + "twisted-20.3.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.8,<3.9.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be09968e2d46c11d7bcefab014b6c9ba", + "name": "twisted", + "sha256": "d53479261938cb2b6bbeee09dd28929a3a50425b0a2524e2752ccb71ac9483e2", + "size": 4313323, + "subdir": "linux-64", + "timestamp": 1614066262250, + "version": "20.3.0" + }, + "twisted-20.3.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.8,<3.9.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d013f385d951bc3fe79c23e146cbd98", + "name": "twisted", + "sha256": "ff46aeec3ea5a8f40eb602a4316e907ee3b71e42d7576e63fcac3e09a45e34e7", + "size": 4307124, + "subdir": "linux-64", + "timestamp": 1586466512469, + "version": "20.3.0" + }, + "twisted-20.3.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "constrains": [ + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0", + "pyserial >=3.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.9,<3.10.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8989c7c136c9f5cf8309550bd21de2d5", + "name": "twisted", + "sha256": "01f3e661fb0523e3b3ad10a50f610c2d39df25ad56b0b60cee3eb293a9640ab2", + "size": 4251493, + "subdir": "linux-64", + "timestamp": 1614066281408, + "version": "20.3.0" + }, + "twisted-21.2.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "priority >=1.1.0,<2.0", + "h2 >=3.0,<4.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.6,<3.7.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "44679fc60b0cfc0a4eec852b2873a8f5", + "name": "twisted", + "sha256": "b78f082bd06ecadc3a3046c8c185fc5901e42310ce214827d5d806f38e1735c6", + "size": 4349917, + "subdir": "linux-64", + "timestamp": 1614873149683, + "version": "21.2.0" + }, + "twisted-21.2.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "priority >=1.1.0,<2.0", + "h2 >=3.0,<4.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb2107d9cd5ef4c79c5531353724ceeb", + "name": "twisted", + "sha256": "32d3a381f9bdfe38c25c7f60a862f451397ac211135ade92c8968aa9842b60c4", + "size": 4341593, + "subdir": "linux-64", + "timestamp": 1614874469005, + "version": "21.2.0" + }, + "twisted-21.2.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "constrains": [ + "priority >=1.1.0,<2.0", + "pyserial >=3.0", + "h2 >=3.0,<4.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.8,<3.9.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b7c294d4bf79cee049db578b503ef49", + "name": "twisted", + "sha256": "5563dc574424d97e2b1e7e2f7ca95a5da1ec39c59ee67c73817463a06f3f0dc6", + "size": 4319119, + "subdir": "linux-64", + "timestamp": 1614874445902, + "version": "21.2.0" + }, + "twisted-21.2.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "constrains": [ + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0", + "pyserial >=3.0" + ], + "depends": [ + "attrs >=17.4.0", + "automat >=0.3.0", + "bcrypt", + "constantly >=15.1", + "cryptography >=1.5", + "hyperlink >=17.1.1", + "idna >=0.6,!=2.3", + "incremental >=16.10.1", + "libgcc-ng >=7.3.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.9,<3.10.0a0", + "service_identity >=18.1.0", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc704d9f97d049f8ca68a17d434450e4", + "name": "twisted", + "sha256": "34a1d44ce149a7dafdc546f24ccf6e030fe9fee545a802af6b5c065a3356d2b3", + "size": 4315401, + "subdir": "linux-64", + "timestamp": 1614874475341, + "version": "21.2.0" + }, + "twisted-21.7.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "constrains": [ + "priority >=1.1.0,<2.0", + "h2 >=3.0,<4.0", + "pyserial >=3.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=7.5.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.10,<3.11.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "56f8c12d6007885d7ef9369edce1fde7", + "name": "twisted", + "sha256": "50c2994061bcead26bfd0f758428ada1a5c4dbddd56f2295a6f29eb2f10642e3", + "size": 4396778, + "subdir": "linux-64", + "timestamp": 1640813190953, + "version": "21.7.0" + }, + "twisted-21.7.0-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "constrains": [ + "h2 >=3.0,<4.0", + "pyserial >=3.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=7.5.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "36a0954940cc405e205c38c475703de3", + "name": "twisted", + "sha256": "4ade10a9ecb25c13aee82f82c0de821a8678cec5863fa3d89a009e0a6d6b9a0e", + "size": 4312651, + "subdir": "linux-64", + "timestamp": 1636984189511, + "version": "21.7.0" + }, + "twisted-21.7.0-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "constrains": [ + "priority >=1.1.0,<2.0", + "h2 >=3.0,<4.0", + "pyserial >=3.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=7.5.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.8,<3.9.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc0c4f8e73bdf6fef0aaee8272568a2d", + "name": "twisted", + "sha256": "14ce37f19d9142edabf2f4dc6641337a905300fa181fd54071fbaf4073f0faa0", + "size": 4345982, + "subdir": "linux-64", + "timestamp": 1636996686775, + "version": "21.7.0" + }, + "twisted-21.7.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "priority >=1.1.0,<2.0", + "h2 >=3.0,<4.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=7.5.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.9,<3.10.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "69823e202128bacecc57ba13411c35b7", + "name": "twisted", + "sha256": "d783d2f6a5c5ea301c48077e8000621728877a8a93ec41af4b06f4a91028f9ba", + "size": 4396064, + "subdir": "linux-64", + "timestamp": 1636996194203, + "version": "21.7.0" + }, + "twisted-22.2.0-py310h5eee18b_1.conda": { + "build": "py310h5eee18b_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=11.2.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.10,<3.11.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d83f7275122f4db7390a441dea265e59", + "name": "twisted", + "sha256": "bdba3cd91df1048ab8ca2826cbec8327fc1b5a36964d6c214bbba9343a66bb5a", + "size": 4374011, + "subdir": "linux-64", + "timestamp": 1659592929856, + "version": "22.2.0" + }, + "twisted-22.2.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "constrains": [ + "priority >=1.1.0,<2.0", + "pyserial >=3.0", + "h2 >=3.0,<4.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=7.5.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.10,<3.11.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3968b99d1ebe2dfd20136a8a3153091", + "name": "twisted", + "sha256": "31e1064808c7a7cee233db496b1f6911eebf8c86e9fbcacc45c233778991f091", + "size": 4378940, + "subdir": "linux-64", + "timestamp": 1646817786687, + "version": "22.2.0" + }, + "twisted-22.2.0-py311h5eee18b_1.conda": { + "build": "py311h5eee18b_1", + "build_number": 1, + "constrains": [ + "priority >=1.1.0,<2.0", + "pyserial >=3.0", + "h2 >=3.0,<4.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=11.2.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.11,<3.12.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7d420d1f00da5bfc4b3ad586d8b150e6", + "name": "twisted", + "sha256": "0bd32132d6e76e6e2a6464b743d8775320040ada3b130fb7991c815c2fcaecfb", + "size": 6292982, + "subdir": "linux-64", + "timestamp": 1676846083398, + "version": "22.2.0" + }, + "twisted-22.2.0-py37h5eee18b_1.conda": { + "build": "py37h5eee18b_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=11.2.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e1713d3c4423533934a65cea490e4b9e", + "name": "twisted", + "sha256": "13649b8736878c762ef4fc34df40c90e4786f9cf200e39ed6d7f7df210ae97f8", + "size": 4288748, + "subdir": "linux-64", + "timestamp": 1659592800997, + "version": "22.2.0" + }, + "twisted-22.2.0-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=7.5.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.7,<3.8.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51082001e8601a3d3458e92b82aea0df", + "name": "twisted", + "sha256": "fa54cb8eb6be007d28d0bc2c6e2843e6645d7c560c10de96df646a95fdf52410", + "size": 4349018, + "subdir": "linux-64", + "timestamp": 1646835250235, + "version": "22.2.0" + }, + "twisted-22.2.0-py38h5eee18b_1.conda": { + "build": "py38h5eee18b_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=11.2.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.8,<3.9.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c808e94897c0d03fc46a6a278a5f4171", + "name": "twisted", + "sha256": "4198534d734a3e0c9bdeff588bc6c48da63df030bfa0bb3033af885ccc91877f", + "size": 4319827, + "subdir": "linux-64", + "timestamp": 1659592840512, + "version": "22.2.0" + }, + "twisted-22.2.0-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=7.5.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.8,<3.9.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc9a15abeb3b8556efc149b887ee6309", + "name": "twisted", + "sha256": "fab936d5606966eec5dacf074733ef0096b5afabe9b1953bfc915e24af15d90c", + "size": 4328802, + "subdir": "linux-64", + "timestamp": 1646835249176, + "version": "22.2.0" + }, + "twisted-22.2.0-py39h5eee18b_1.conda": { + "build": "py39h5eee18b_1", + "build_number": 1, + "constrains": [ + "pyserial >=3.0", + "h2 >=3.0,<4.0", + "priority >=1.1.0,<2.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=11.2.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.9,<3.10.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a9144acf020dba42622a1312967cd3bb", + "name": "twisted", + "sha256": "0f34db071d1d893dad3a4e1ff17f4e36ba23a92a0f760cb0ff05eb610e5ba14f", + "size": 4321432, + "subdir": "linux-64", + "timestamp": 1659592879954, + "version": "22.2.0" + }, + "twisted-22.2.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "constrains": [ + "priority >=1.1.0,<2.0", + "pyserial >=3.0", + "h2 >=3.0,<4.0" + ], + "depends": [ + "appdirs >=1.4.0", + "attrs >=19.2.0", + "automat >=0.8.0", + "bcrypt >=3.0.0", + "constantly >=15.1", + "cryptography >=2.6", + "hyperlink >=17.1.1", + "idna >=2.4", + "incremental >=21.3.0", + "libgcc-ng >=7.5.0", + "pip", + "pyasn1", + "pyhamcrest >=1.9.0", + "pyopenssl >=16.0.0", + "python >=3.9,<3.10.0a0", + "service_identity >=18.1.0", + "typing_extensions >=3.6.5", + "zope.interface >=4.4.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cdd2c601ef0b02f5d706cf91ff659450", + "name": "twisted", + "sha256": "4801b9100cf1756e5442aeeb82c916e99e96379e2df14c91946146d9a8b1830f", + "size": 4326656, + "subdir": "linux-64", + "timestamp": 1646835255336, + "version": "22.2.0" + }, + "twofish-0.3.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "ef3b6216f86faeb2fe7c2fea6b8b7ec0", + "name": "twofish", + "sha256": "93bdff448a5cd38a125ddf3ebd6c00eb29616b5e85ef1c05c1b799557452fba2", + "size": 16504, + "subdir": "linux-64", + "timestamp": 1545424270442, + "version": "0.3.0" + }, + "twofish-0.3.0-py310h7f8727e_1000.conda": { + "build": "py310h7f8727e_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "1237d219da5bf33c97e61a547c0f13f2", + "name": "twofish", + "sha256": "867bd5c5de2b6b0394362e1bc470d4806e3f83acef0457d91f5f74c114dd5ffa", + "size": 31304, + "subdir": "linux-64", + "timestamp": 1640795489503, + "version": "0.3.0" + }, + "twofish-0.3.0-py311h5eee18b_1000.conda": { + "build": "py311h5eee18b_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "9a4907f44c52a408d23c7c758a2b5022", + "name": "twofish", + "sha256": "b955e3188921f1355d7abfb39149b9017cf81351f4a45386f90629baaed615c0", + "size": 18118, + "subdir": "linux-64", + "timestamp": 1676863365131, + "version": "0.3.0" + }, + "twofish-0.3.0-py36h27cfd23_1000.conda": { + "build": "py36h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "0abaa76d22f2179927113387143d0937", + "name": "twofish", + "sha256": "db64d61d77bbeceaa429f837147998f45941e452322b02eaa294424b6571b254", + "size": 17634, + "subdir": "linux-64", + "timestamp": 1613502529428, + "version": "0.3.0" + }, + "twofish-0.3.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "ede66aa2d9091c75b913f63073cb3ba9", + "name": "twofish", + "sha256": "57ad58c9c9106e103b0e5c70fa351422d9fe60c50775c75ebd88f0f5661851d0", + "size": 16654, + "subdir": "linux-64", + "timestamp": 1545424304116, + "version": "0.3.0" + }, + "twofish-0.3.0-py36h7b6447c_1000.conda": { + "build": "py36h7b6447c_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "17a7a3c3115c85186b7637d3299eed7b", + "name": "twofish", + "sha256": "9512258c906f84c8256c7171f23348dd977f4ea45140a6df49f19d1c68f403a5", + "size": 17326, + "subdir": "linux-64", + "timestamp": 1591257727239, + "version": "0.3.0" + }, + "twofish-0.3.0-py37h27cfd23_1000.conda": { + "build": "py37h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "0827be2f475ab0d839545309c0a90c10", + "name": "twofish", + "sha256": "9fde2aa0270816f40aab734979c1fa552b2642f09bc344148b0fa9d6ac568e8c", + "size": 17785, + "subdir": "linux-64", + "timestamp": 1613502853390, + "version": "0.3.0" + }, + "twofish-0.3.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "6f4b5886370fb3c1c12a796d7d81e975", + "name": "twofish", + "sha256": "0dfac06c89f140e16dce3b821b8d8c23e96151383a17db265c50e7c0acc7bd8d", + "size": 16495, + "subdir": "linux-64", + "timestamp": 1545424291129, + "version": "0.3.0" + }, + "twofish-0.3.0-py37h7b6447c_1000.conda": { + "build": "py37h7b6447c_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "efdcc136c6cd73702ce77d9df854ef5a", + "name": "twofish", + "sha256": "448f420ca3558e4cdeacabf2cc8cd95a52e5c5791080d41610df2a6319681ea2", + "size": 17482, + "subdir": "linux-64", + "timestamp": 1591257717091, + "version": "0.3.0" + }, + "twofish-0.3.0-py38h27cfd23_1000.conda": { + "build": "py38h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "f32302f4583dc8e4add540215514a4c9", + "name": "twofish", + "sha256": "1fab603a8b089e0bc22bb79bb94f5becf4bc713ac60e9bfd663ca5d3a6b93f13", + "size": 17698, + "subdir": "linux-64", + "timestamp": 1613502531289, + "version": "0.3.0" + }, + "twofish-0.3.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "def446fb84e1f104e8a3f24769888f76", + "name": "twofish", + "sha256": "35ae4884c564c314d5e8babee3eab35cb6e45cb7089b3f4f3bc29c4c1e084ae6", + "size": 23275, + "subdir": "linux-64", + "timestamp": 1573200500486, + "version": "0.3.0" + }, + "twofish-0.3.0-py38h7b6447c_1000.conda": { + "build": "py38h7b6447c_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "ded05f02cf92ca3ddbb8059077c4ef30", + "name": "twofish", + "sha256": "ae3d7e04c3f82f271a62750a8767583cc704d745827f9c371ea7e91c1d1663a0", + "size": 17318, + "subdir": "linux-64", + "timestamp": 1591257723141, + "version": "0.3.0" + }, + "twofish-0.3.0-py39h27cfd23_1000.conda": { + "build": "py39h27cfd23_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "c0e7fd26a13c22a87f8709c44d371ba6", + "name": "twofish", + "sha256": "7063e54e2fc3209cff4e28a84eadc16e28341292dafc72bf0229fbc393eb33c6", + "size": 17830, + "subdir": "linux-64", + "timestamp": 1613502854176, + "version": "0.3.0" + }, + "twython-3.7.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca7f91a80437798fa4e4cf2ae5c97c90", + "name": "twython", + "sha256": "d05c08fc939bae42d911f009b828d8b40c9e5df44f11c3729cff7b2e469cf8a5", + "size": 44722, + "subdir": "linux-64", + "timestamp": 1525813869860, + "version": "3.7.0" + }, + "twython-3.7.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2069894ffe59ad50cd654391c6bd1b6", + "name": "twython", + "sha256": "4274b32c85a63a46f659ad08396678c3822d9575d4da533d529ed513f9a95461", + "size": 46563, + "subdir": "linux-64", + "timestamp": 1525813983070, + "version": "3.7.0" + }, + "twython-3.7.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "702b01ab02017128022c84a7beb331c3", + "name": "twython", + "sha256": "a3bf53cfad865b6267fe276f5c7b942713318968815dcbd8e26b8665fdfaf7f4", + "size": 46318, + "subdir": "linux-64", + "timestamp": 1525813974696, + "version": "3.7.0" + }, + "twython-3.7.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6da1cf4798da7dab7c508786f125a52", + "name": "twython", + "sha256": "ff6fdad7c418304860f1e40621290e02b8b7f5bd2383c03bdf8bc2e0e752be6b", + "size": 45114, + "subdir": "linux-64", + "timestamp": 1545089459062, + "version": "3.7.0" + }, + "twython-3.8.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b796cff72e30fe33696959d71e3d68e", + "name": "twython", + "sha256": "51f103dc3f8ba35ba293b445113a5f0b4f0adf47560a184b5504342ce9a2065d", + "size": 46026, + "subdir": "linux-64", + "timestamp": 1640795508037, + "version": "3.8.2" + }, + "twython-3.8.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd7b5a06943b3e801e417febf5eee1e5", + "name": "twython", + "sha256": "670d3dad06551017bee411202b33f17eabdb082134b9ebef423d49461ea3bd42", + "size": 53950, + "subdir": "linux-64", + "timestamp": 1676863381758, + "version": "3.8.2" + }, + "twython-3.8.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c700d62b0b6f8f9c0807ba158361f0f7", + "name": "twython", + "sha256": "7b53d32d687dcc74791e0e324b049b3b18f3207bbce5e6b26d504984f5324f31", + "size": 47098, + "subdir": "linux-64", + "timestamp": 1593483279840, + "version": "3.8.2" + }, + "twython-3.8.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "719676ef584e5c177c5d486557c9e84c", + "name": "twython", + "sha256": "f33f1db4274d8a2006cdc19fd7907a414babbbcb3eb8fdee7a81e902ce4950d3", + "size": 47340, + "subdir": "linux-64", + "timestamp": 1614080319063, + "version": "3.8.2" + }, + "twython-3.8.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "130cf9062ec67a4bdceafc72799a8d09", + "name": "twython", + "sha256": "9939ae53feb3d427284c39a24da38660d7775f612c68b3109bf7c18acd5e6680", + "size": 46940, + "subdir": "linux-64", + "timestamp": 1593483274172, + "version": "3.8.2" + }, + "twython-3.8.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "589234f3e49f32cda13d04975f779d32", + "name": "twython", + "sha256": "6f388fac768a72ed061514049014ac924c32f573a713db4a2a1a4e810cdec362", + "size": 47113, + "subdir": "linux-64", + "timestamp": 1614079985475, + "version": "3.8.2" + }, + "twython-3.8.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3825fa277b1c1dfcedb4223cb64fd5b", + "name": "twython", + "sha256": "f072ded39535a95ea2cf9e5503a8771cff09309a2bc07eec2cd0f821b2a18589", + "size": 46974, + "subdir": "linux-64", + "timestamp": 1593483258687, + "version": "3.8.2" + }, + "twython-3.8.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c223ebd339a2953777242b0b3df573dc", + "name": "twython", + "sha256": "4fadcf25a50ae5df9d6edcfa211764744b6e7fc247c84e6dcce6c0a390448546", + "size": 46002, + "subdir": "linux-64", + "timestamp": 1614080318972, + "version": "3.8.2" + }, + "twython-3.8.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "requests >=2.1.0", + "requests-oauthlib >=0.4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7901a2ac06d07ef282b66fafd08047bd", + "name": "twython", + "sha256": "c06ead5b084185c15ede48296a652bde3ed959a242469d47892799e75c0cb402", + "size": 47205, + "subdir": "linux-64", + "timestamp": 1614080325539, + "version": "3.8.2" + }, + "typed-ast-1.1.0-py35h20cf15d_0.conda": { + "build": "py35h20cf15d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "28cba59a74942fd26562877ebc333b18", + "name": "typed-ast", + "sha256": "0487dbff1c9f105bda825aa95287021ee57b18e4c732a32275b2813496a4c6c1", + "size": 179497, + "subdir": "linux-64", + "timestamp": 1507240396388, + "version": "1.1.0" + }, + "typed-ast-1.1.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "01f78f3eb7952de383508f3956d38f42", + "name": "typed-ast", + "sha256": "826a63ef7514ba8e2a0f31a11fc69344a89a78f288ade8e997167bc02aa3cdb2", + "size": 180884, + "subdir": "linux-64", + "timestamp": 1530900669521, + "version": "1.1.0" + }, + "typed-ast-1.1.0-py36h4769eee_0.conda": { + "build": "py36h4769eee_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a3bff4c96621a2ade40f5d23fc2b238b", + "name": "typed-ast", + "sha256": "648b7cbd7c5d25eb74669ab2decaae71dd1f97945156a679683eb6c8e33f8c1b", + "size": 177977, + "subdir": "linux-64", + "timestamp": 1507240417207, + "version": "1.1.0" + }, + "typed-ast-1.1.0-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "44de273d90b39b8d90bd5b61b3aea125", + "name": "typed-ast", + "sha256": "85afed55da198910b1e773b55e443d664d37f5b111db76490e4eda4834372178", + "size": 179157, + "subdir": "linux-64", + "timestamp": 1530900625994, + "version": "1.1.0" + }, + "typed-ast-1.2.0-py36h7b6447c_1000.conda": { + "build": "py36h7b6447c_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "c08dfa28e3cd2b72eb02a6adce3471f7", + "name": "typed-ast", + "sha256": "8d4ece4bc5a4b57728276735f4f103220fe8a824a69ed6c71a7727ee58713776", + "size": 187687, + "subdir": "linux-64", + "timestamp": 1552362442315, + "version": "1.2.0" + }, + "typed-ast-1.2.0-py37h7b6447c_1000.conda": { + "build": "py37h7b6447c_1000", + "build_number": 1000, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "270d2e3fb326580939022ec4d0cc80cc", + "name": "typed-ast", + "sha256": "db85a1d15737ecaf1640483cc7df665df3fb0b9df894443d89b3b8175022dda4", + "size": 189601, + "subdir": "linux-64", + "timestamp": 1552362397703, + "version": "1.2.0" + }, + "typed-ast-1.3.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8667df64b83d8431f674d9d2bda055d4", + "name": "typed-ast", + "sha256": "705e71544f2bb80d47c865a4bfeb8d88c917530160216f535acb2f5929b415b3", + "size": 184243, + "subdir": "linux-64", + "timestamp": 1550431625709, + "version": "1.3.1" + }, + "typed-ast-1.3.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "39ba62a3b254606cfcb5a3c9cfa2364e", + "name": "typed-ast", + "sha256": "f197d037c37dd490e4d03866b9d4361b2be62306b10ed18908c5ed89334b1957", + "size": 184271, + "subdir": "linux-64", + "timestamp": 1550431589741, + "version": "1.3.1" + }, + "typed-ast-1.3.4-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3f24ad4dbc3ed8497ab36ece49e3b359", + "name": "typed-ast", + "sha256": "7e237539691a3321cabf44c78ba1b238ce18b699fcb57d17c03b8e981a340aba", + "size": 193431, + "subdir": "linux-64", + "timestamp": 1556109889211, + "version": "1.3.4" + }, + "typed-ast-1.3.4-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0b9a1056ab96c67056fc54015bf94b17", + "name": "typed-ast", + "sha256": "e17114cbcd8d896a1215097114007c64039d6c54f52ee7a9add067ea0aaab963", + "size": 191608, + "subdir": "linux-64", + "timestamp": 1556088339356, + "version": "1.3.4" + }, + "typed-ast-1.4.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "54b873720e9f072492a1844f4a5390e8", + "name": "typed-ast", + "sha256": "4b5592a3b2da0053ad42c022606a7db477a1db03d2149ccd3c8bb9c6365ba649", + "size": 187957, + "subdir": "linux-64", + "timestamp": 1569360549081, + "version": "1.4.0" + }, + "typed-ast-1.4.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "667f6c6be5944c1bbc04e562cca8270e", + "name": "typed-ast", + "sha256": "312b2a7952340a9b15fa71508fd84e3d94f7b9ddbdeb4d69fe06524962a7a40e", + "size": 187947, + "subdir": "linux-64", + "timestamp": 1569360541363, + "version": "1.4.0" + }, + "typed-ast-1.4.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "833e1fb7763ae0d893e53f7cfbd4e1fd", + "name": "typed-ast", + "sha256": "aff72e9b57fc329256efeec742570b54c80c3f5e4f13f02412c945d2d779d446", + "size": 195993, + "subdir": "linux-64", + "timestamp": 1573200533044, + "version": "1.4.0" + }, + "typed-ast-1.4.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1f7e9a3336fcff86175fd606d1bcaca6", + "name": "typed-ast", + "sha256": "ccb199ed0a46a22df9ea45b2a3f7f06fb00d523a5c683fefe4db372ebc8fc632", + "size": 191813, + "subdir": "linux-64", + "timestamp": 1580153490794, + "version": "1.4.1" + }, + "typed-ast-1.4.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "9fa0e9301c8f8bf443e2fdadc6eca21a", + "name": "typed-ast", + "sha256": "e308015188e6d5784d6f7d669b81f87cc3d0bc56cd6197954784f3ea2cc4d06e", + "size": 187884, + "subdir": "linux-64", + "timestamp": 1580153429658, + "version": "1.4.1" + }, + "typed-ast-1.4.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "293e50c79187f9bbc326693465f7ed60", + "name": "typed-ast", + "sha256": "eed86cdc5d3bf221a40094a8da3fa405162ae4e900c1687e30093d16cf2409fc", + "size": 193165, + "subdir": "linux-64", + "timestamp": 1580153398024, + "version": "1.4.1" + }, + "typed-ast-1.4.2-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a8a1a129d141293301d1b9afe65d97b3", + "name": "typed-ast", + "sha256": "9122a7b27b2a1a0fe7e2b30b6f40d5c3266b8f749421fcd07c7a273f4a268b62", + "size": 186212, + "subdir": "linux-64", + "timestamp": 1610393152559, + "version": "1.4.2" + }, + "typed-ast-1.4.2-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cf69556110a5b9fa66b90274444834dd", + "name": "typed-ast", + "sha256": "86e1b4f25e840d280011c81206633d9d46cdbb45b9470d6f618f73b8aa2c4dec", + "size": 190662, + "subdir": "linux-64", + "timestamp": 1610484580892, + "version": "1.4.2" + }, + "typed-ast-1.4.2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2a8585d081fd50f746fc1dd0cce9a24c", + "name": "typed-ast", + "sha256": "b2e75b2c15112e7b803a659c5373cdecff82b6828e659483436e6485dedebc13", + "size": 186047, + "subdir": "linux-64", + "timestamp": 1610393153851, + "version": "1.4.2" + }, + "typed-ast-1.4.2-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5f21558dd21535feadb98b4fa73c1e27", + "name": "typed-ast", + "sha256": "f1ca47a5296eb4a3790dcfdcea7af50928ba66b4e145c24f1e175d33b79d59eb", + "size": 189813, + "subdir": "linux-64", + "timestamp": 1610484610492, + "version": "1.4.2" + }, + "typed-ast-1.4.2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3c0a5af87f6b8359be71e2e889497ddc", + "name": "typed-ast", + "sha256": "66fc8d82bfdb371c585e8d4a5d23118f1edec30644b7d6a76967148999a70487", + "size": 190153, + "subdir": "linux-64", + "timestamp": 1610393156221, + "version": "1.4.2" + }, + "typed-ast-1.4.2-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ce0143f42e0ffe523e4343b75963f1e0", + "name": "typed-ast", + "sha256": "bf62297f08d4ef17dc2ebdddab2c802324115ae41d256dba8fb860568858ff78", + "size": 193350, + "subdir": "linux-64", + "timestamp": 1610484596524, + "version": "1.4.2" + }, + "typed-ast-1.4.2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "27788af7a6b9dc6cdfe768440315d95b", + "name": "typed-ast", + "sha256": "2b36166fe6aa5a87b6c5d57cac06487be26a5ffc541571c8d99f3b4362f8756b", + "size": 190374, + "subdir": "linux-64", + "timestamp": 1610393155887, + "version": "1.4.2" + }, + "typed-ast-1.4.2-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "594061b9dd20bfaeee976dcfd8d20476", + "name": "typed-ast", + "sha256": "ed424b5125d4dba474905c22c8cc45646bc0f4b227575034ecbd9937a41b41fc", + "size": 196673, + "subdir": "linux-64", + "timestamp": 1610484131222, + "version": "1.4.2" + }, + "typed-ast-1.4.3-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 AND PSF-2.0 AND MIT", + "license_family": "Apache", + "md5": "1d947d1667d8002236e262fc379595c3", + "name": "typed-ast", + "sha256": "de5edfe13d315f99d2da447cd22337d4531c154f7bdb6ec5957a7a1c35a56325", + "size": 534102, + "subdir": "linux-64", + "timestamp": 1640795540672, + "version": "1.4.3" + }, + "typed-ast-1.4.3-py36h7f8727e_1.conda": { + "build": "py36h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0 AND PSF-2.0 AND MIT", + "license_family": "Apache", + "md5": "166f168ba120a0615e77273cb90335e1", + "name": "typed-ast", + "sha256": "5112e926f12bff724458d17cc583ae76808b5ba4a19755b1b2e0e3184af1d4cf", + "size": 188663, + "subdir": "linux-64", + "timestamp": 1624953748316, + "version": "1.4.3" + }, + "typed-ast-1.4.3-py37h7f8727e_1.conda": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 AND PSF-2.0 AND MIT", + "license_family": "Apache", + "md5": "cd5036513abbd831e375e8fab988bd96", + "name": "typed-ast", + "sha256": "4e92f01f73b56a281c473058099010429acb3a2dfb9da3777826b3efff6a7317", + "size": 189109, + "subdir": "linux-64", + "timestamp": 1624953437755, + "version": "1.4.3" + }, + "typed-ast-1.4.3-py38h7f8727e_1.conda": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 AND PSF-2.0 AND MIT", + "license_family": "Apache", + "md5": "3178fffbdc1f50343afc8734c50a30a6", + "name": "typed-ast", + "sha256": "df055b963f2cac9d2be99d9bafd11a3dba651da4d1e514548537da45d9b63b28", + "size": 189453, + "subdir": "linux-64", + "timestamp": 1624953737565, + "version": "1.4.3" + }, + "typed-ast-1.4.3-py39h7f8727e_1.conda": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 AND PSF-2.0 AND MIT", + "license_family": "Apache", + "md5": "c17f20d4281e0e132b1cb2e835bfc337", + "name": "typed-ast", + "sha256": "54770df5c1a8cf85f941b945db9c485c5727783fbddaf4ab0cf62014e2d101b1", + "size": 191056, + "subdir": "linux-64", + "timestamp": 1624953750784, + "version": "1.4.3" + }, + "typeguard-2.13.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ac8c5b5697946ce44084fd889c0f74a", + "name": "typeguard", + "sha256": "f9292dfa178506c14ed9b788edf370cd171d233235115a3e15e5cb6cfb4e4eee", + "size": 38331, + "subdir": "linux-64", + "timestamp": 1674631902702, + "version": "2.13.3" + }, + "typeguard-2.13.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3e9b20c469bb82f6c99f0f9a1ceb2afc", + "name": "typeguard", + "sha256": "4765035b20d05e609d71b178c09d64bb1cdfaba9cf9ef5922441b29f4770ffec", + "size": 48819, + "subdir": "linux-64", + "timestamp": 1676846107567, + "version": "2.13.3" + }, + "typeguard-2.13.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3317dc9cd8bbf6b083ad68be72b5f4e5", + "name": "typeguard", + "sha256": "e8f2995a7d77e1a29075cc585f9075ef6d11b86992e689cda8cd0e5646f5b4f1", + "size": 37855, + "subdir": "linux-64", + "timestamp": 1674631982994, + "version": "2.13.3" + }, + "typeguard-2.13.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e1fdd40d8b1b7a6ac0479726eb2c9431", + "name": "typeguard", + "sha256": "215bcdd2b272d4508ae01f080ad3ca9e0a8394104d77755cb75179db5d1399b1", + "size": 38099, + "subdir": "linux-64", + "timestamp": 1674631955986, + "version": "2.13.3" + }, + "typeguard-2.13.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "66eb5dc080603460d7ced7bbc8ff92e5", + "name": "typeguard", + "sha256": "272c58cff26a7616fea4359bf02f975b8d0f6fbc4512d0a0039caa17ca1dd9d3", + "size": 37891, + "subdir": "linux-64", + "timestamp": 1674631929444, + "version": "2.13.3" + }, + "typer-0.4.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.1.1,<9.0.0", + "colorama >=0.4.3,<0.5.0", + "python >=3.10,<3.11.0a0", + "shellingham >=1.3.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cdc07afa9e63207ded406b4b327eab32", + "name": "typer", + "sha256": "112afeca513827d639e0905cebf983f9f3f51baf95c00030354cd585dc5d390c", + "size": 50823, + "subdir": "linux-64", + "timestamp": 1651237229716, + "version": "0.4.1" + }, + "typer-0.4.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.1.1,<9.0.0", + "colorama >=0.4.3,<0.5.0", + "python >=3.11,<3.12.0a0", + "shellingham >=1.3.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ef0c6f36b3f250a19c76de71035da03e", + "name": "typer", + "sha256": "8fdfe35a4c3217b25f50171caa187708904826b5994f50e0a8f2ebe322589ea8", + "size": 67707, + "subdir": "linux-64", + "timestamp": 1676842970793, + "version": "0.4.1" + }, + "typer-0.4.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.1.1,<9.0.0", + "colorama >=0.4.3,<0.5.0", + "python >=3.7,<3.8.0a0", + "shellingham >=1.3.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce72d166ed436c0097bc93f828d811eb", + "name": "typer", + "sha256": "ed2328fc805078b006d058e74a38cc293bf2a489d275f38d724b02095b1cf8fd", + "size": 48703, + "subdir": "linux-64", + "timestamp": 1651237193784, + "version": "0.4.1" + }, + "typer-0.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.1.1,<9.0.0", + "colorama >=0.4.3,<0.5.0", + "python >=3.8,<3.9.0a0", + "shellingham >=1.3.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aad16446460c06247c8596e679097b50", + "name": "typer", + "sha256": "de921b02d9ff4b81dabfc222b28ee03706cc6d27644d41227de952270950697f", + "size": 49190, + "subdir": "linux-64", + "timestamp": 1651237278895, + "version": "0.4.1" + }, + "typer-0.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.1.1,<9.0.0", + "colorama >=0.4.3,<0.5.0", + "python >=3.9,<3.10.0a0", + "shellingham >=1.3.0,<2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5d47a3dd0c534416a88f457c4ab43791", + "name": "typer", + "sha256": "3b62bcc38d02b0583207d047270d686a9b3897edf78e316e2ebce1717738f42e", + "size": 49145, + "subdir": "linux-64", + "timestamp": 1651237255250, + "version": "0.4.1" + }, + "types-pytz-2022.4.0.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0 AND MIT", + "md5": "9a2115b22f9f83d8844a835d3d1c50a6", + "name": "types-pytz", + "sha256": "129ef7068e7ce53b18911b0fb8445e64499313226d03dd76f8ae380e10fa8dc6", + "size": 16482, + "subdir": "linux-64", + "timestamp": 1665514295712, + "version": "2022.4.0.0" + }, + "types-pytz-2022.4.0.0-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0 AND MIT", + "md5": "21aca89b382bd0989966f1a79ded845f", + "name": "types-pytz", + "sha256": "30f1317d862cfb00bcd1d1ae47e035daadada360a66747d6edc18ec8ae6b09f2", + "size": 17039, + "subdir": "linux-64", + "timestamp": 1676846121986, + "version": "2022.4.0.0" + }, + "types-pytz-2022.4.0.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0 AND MIT", + "md5": "e3434318fa77c6d7aa467634593a89fd", + "name": "types-pytz", + "sha256": "91310d375a8842bcc33b86bc7cf03cc7788b2428dfc2f62b7d19af4306150333", + "size": 16469, + "subdir": "linux-64", + "timestamp": 1665514343899, + "version": "2022.4.0.0" + }, + "types-pytz-2022.4.0.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0 AND MIT", + "md5": "c1c90220ca2e2f786a7c45a3ef7ef478", + "name": "types-pytz", + "sha256": "11df470ac6afcfa04c0329033007e1d29f04f8178f58daec5a7e788d0ab71e86", + "size": 16443, + "subdir": "linux-64", + "timestamp": 1665514271526, + "version": "2022.4.0.0" + }, + "types-pytz-2022.4.0.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0 AND MIT", + "md5": "db911d3a58ce1d3a66901e67f9d1cdb3", + "name": "types-pytz", + "sha256": "25783de3800691a52a55ad49f01dba1bfbf37154161a042fa78367facce928c1", + "size": 16461, + "subdir": "linux-64", + "timestamp": 1665514319178, + "version": "2022.4.0.0" + }, + "typing-3.10.0.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "PSF", + "md5": "d7ca6666c01ffe6ce2de1c2ef04bbb6a", + "name": "typing", + "sha256": "3a12dd67ddfa86f82c5d922faf3ccb8b8b8c98f996aefc9e1cd1a519833b1a96", + "size": 7940, + "subdir": "linux-64", + "timestamp": 1640795559347, + "version": "3.10.0.0" + }, + "typing-3.10.0.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "PSF", + "md5": "70202928152c04134f988c8c4e03c24d", + "name": "typing", + "sha256": "9e584a6cd898c52e9ed2d203b1809e9fb4e08959f561c5405cd1f8e5deeed20c", + "size": 8295, + "subdir": "linux-64", + "timestamp": 1676828887149, + "version": "3.10.0.0" + }, + "typing-3.10.0.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "30547215373fef98eabc5b5aace19170", + "name": "typing", + "sha256": "824b200966682a9ec322b45d549606872413c869a6effcfabfc17000aeda35ba", + "size": 8068, + "subdir": "linux-64", + "timestamp": 1620168048534, + "version": "3.10.0.0" + }, + "typing-3.10.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "2d313481da81add1c7a456f724b222fa", + "name": "typing", + "sha256": "b9af45da11ff91b5fbbda1b3e2b613a31b7fdcc610ac1dccfb86a949d561544b", + "size": 8061, + "subdir": "linux-64", + "timestamp": 1620172048569, + "version": "3.10.0.0" + }, + "typing-3.10.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "10673cd1aa2dd14f6352e8046c97e906", + "name": "typing", + "sha256": "2dfe8bf9b2fa3d9ec55f4e8d1572f102d051e2de4e9d1337bc0b9aac7c1f7827", + "size": 8079, + "subdir": "linux-64", + "timestamp": 1620172050749, + "version": "3.10.0.0" + }, + "typing-3.10.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "a5b278e4e48b11b5aa6051ae3e6784c3", + "name": "typing", + "sha256": "57caf69fbf485217c194f109ec917a2146c33b138406a3c723c2f13d2651cd98", + "size": 8091, + "subdir": "linux-64", + "timestamp": 1620171616726, + "version": "3.10.0.0" + }, + "typing-3.6.2-py27h66f49e2_0.conda": { + "build": "py27h66f49e2_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "fb5c5387542d2da68a297dab64cc76c1", + "name": "typing", + "sha256": "0482af4d8e136efc8b0786960b3d8afafa3093d6b351b748e2aa0e54dceba2ac", + "size": 41445, + "subdir": "linux-64", + "timestamp": 1505864007847, + "version": "3.6.2" + }, + "typing-3.6.2-py35hcadae7e_0.conda": { + "build": "py35hcadae7e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "PSF", + "md5": "0b4119392ba8b6909905db9d08fa3a37", + "name": "typing", + "sha256": "99794d903d380ac8d40097f66b0a3ad95e85935c5ba1ff75190e1329e69c34ec", + "size": 45508, + "subdir": "linux-64", + "timestamp": 1505864019969, + "version": "3.6.2" + }, + "typing-3.6.2-py36h7da032a_0.conda": { + "build": "py36h7da032a_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "0e6ad65053889b868764fcc02b3dd7d2", + "name": "typing", + "sha256": "267dd0ba73354e6b6bb754e96e019f920e258fe59530169c5fada8457d2a2479", + "size": 45124, + "subdir": "linux-64", + "timestamp": 1505864032217, + "version": "3.6.2" + }, + "typing-3.6.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "6ea967fcb3db5de290666a74af402ce9", + "name": "typing", + "sha256": "d0d381704fd0b5b494124934722909de079b6ee6fa1397df9267dab83ac12376", + "size": 41862, + "subdir": "linux-64", + "timestamp": 1519139562885, + "version": "3.6.4" + }, + "typing-3.6.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "PSF", + "md5": "8fd90036e9b31e977527995f7a0ddcb9", + "name": "typing", + "sha256": "e321e76bcf4b57a1948990de4f63e6f5206c030810fe6c4cb937e39e921ac62d", + "size": 46800, + "subdir": "linux-64", + "timestamp": 1519139623599, + "version": "3.6.4" + }, + "typing-3.6.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "f1782853deac424589325aa81b682822", + "name": "typing", + "sha256": "93debdd4b233e00888298c91b6a9780f8ea670abe3b7f0a02ad5b29d24f96161", + "size": 45688, + "subdir": "linux-64", + "timestamp": 1519139621470, + "version": "3.6.4" + }, + "typing-3.6.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "e6d5edcb379c3041e96860759d4e299a", + "name": "typing", + "sha256": "5ed589a462a1596d249d293158ea512890afebb2ac3eeea3fc6b1fcc12a2dfd1", + "size": 46556, + "subdir": "linux-64", + "timestamp": 1530694981874, + "version": "3.6.4" + }, + "typing-3.6.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "f0a05f36c5dc59c222acf47efda0c68b", + "name": "typing", + "sha256": "0e37d7c23ea52576d2f8e9cf6596bd11e9c2a40b7b951ed90595ad18ba240eb2", + "size": 42021, + "subdir": "linux-64", + "timestamp": 1535378969153, + "version": "3.6.6" + }, + "typing-3.6.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "PSF", + "md5": "75d2c882a5f99f25299d8a9395df9cd4", + "name": "typing", + "sha256": "b67ddd9b4ba4e7ce36924aa97af94bba335f6aa6f3211121ea8f233cf721a1b3", + "size": 46811, + "subdir": "linux-64", + "timestamp": 1535378979419, + "version": "3.6.6" + }, + "typing-3.7.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "a808922808c8534a8920777691baeeb4", + "name": "typing", + "sha256": "8817b36dd52563e6fd37b58f7ed0db02a9d5cbe49d5052509bdff7674e13b843", + "size": 53718, + "subdir": "linux-64", + "timestamp": 1562085576206, + "version": "3.7.4" + }, + "typing-3.7.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF", + "md5": "9ec6886e1bb3ab9c13df91cc1319aa93", + "name": "typing", + "sha256": "7efabb98ad9b7db2b3f18457f62c8713fac9d3a4b27eef831c940a5b888db07c", + "size": 50452, + "subdir": "linux-64", + "timestamp": 1569266839325, + "version": "3.7.4.1" + }, + "typing-3.7.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "02f2e64c0a9d6476676b9b2cd1cb0e82", + "name": "typing", + "sha256": "fcfc88033302173a5780d8a6b3339784ce37ab8c170392c5f677ea2f69fe4826", + "size": 49132, + "subdir": "linux-64", + "timestamp": 1592249999988, + "version": "3.7.4.1" + }, + "typing-3.7.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "8ccc051043ff7591be4ccf2ecd989466", + "name": "typing", + "sha256": "a61798e31d1315c3cbbfab2e73175fe87176a89718225ac1a15e28f02cec3242", + "size": 49409, + "subdir": "linux-64", + "timestamp": 1592250064593, + "version": "3.7.4.1" + }, + "typing-3.7.4.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "51a2003b40366adf5595fc5eca570074", + "name": "typing", + "sha256": "7b9598001d10fdf319053bf51e85472c3823647a7fb39039e90235a760cbda70", + "size": 49469, + "subdir": "linux-64", + "timestamp": 1592250039921, + "version": "3.7.4.1" + }, + "typing-3.7.4.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "cbfbc892e466557f31b62ea64787b98d", + "name": "typing", + "sha256": "05780344c60e5fa59c9b02515d0568c5dfbac3a936d7936a610402a333b9cef9", + "size": 12001, + "subdir": "linux-64", + "timestamp": 1594747962190, + "version": "3.7.4.3" + }, + "typing-3.7.4.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "md5": "11b0a76720be47fabc62ace1453880bd", + "name": "typing", + "sha256": "bd3a69e72b4a0f28c7a944754ad7be8e6e3c58d2ea664ace5c94564704762e44", + "size": 12050, + "subdir": "linux-64", + "timestamp": 1611751130609, + "version": "3.7.4.3" + }, + "typing-3.7.4.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "a311143abc54eab323d663896477aad3", + "name": "typing", + "sha256": "2a4fa093d678bf4c86bdb4636129d4b8aa2be0b0ceaf54a8d17117d6f9f962fc", + "size": 12004, + "subdir": "linux-64", + "timestamp": 1594747961244, + "version": "3.7.4.3" + }, + "typing-3.7.4.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "md5": "052e039229f718bc2006dd068ade2c15", + "name": "typing", + "sha256": "08741eaf863f9fcda9e0acf27911aeb8ea36efd103540144d0df91d46e3262fa", + "size": 12039, + "subdir": "linux-64", + "timestamp": 1611751110746, + "version": "3.7.4.3" + }, + "typing-3.7.4.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "c6b4687796f86253bd8f35b12b10e076", + "name": "typing", + "sha256": "6b1044d2c068c1461ce6b24b2303c3944d3b048e631663379104246ad8900386", + "size": 12012, + "subdir": "linux-64", + "timestamp": 1594747716455, + "version": "3.7.4.3" + }, + "typing-3.7.4.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "md5": "59d379b7cd56dbc545dc4c22cba211b2", + "name": "typing", + "sha256": "7bf93bad80d544715cf9d063460566f5618bd76fe40c413c955d1e64ccae0522", + "size": 12033, + "subdir": "linux-64", + "timestamp": 1611751126716, + "version": "3.7.4.3" + }, + "typing-3.7.4.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF", + "md5": "4f19f82ce7a4c88f67483e578ed26330", + "name": "typing", + "sha256": "d85c896d704b9d87bd012c21a61698e255dbf3ce9387bb811e2813d881188b57", + "size": 12031, + "subdir": "linux-64", + "timestamp": 1611751096323, + "version": "3.7.4.3" + }, + "typing-extensions-3.7.4-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "python", + "typing_extensions 3.7.4 py36_0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "9334d845bfd144e644dbe9294b4b17e6", + "name": "typing-extensions", + "sha256": "61d793553d053d4163ae1571d859460c7952fd5937d98db943bd95454c125116", + "size": 10222, + "subdir": "linux-64", + "timestamp": 1569354439008, + "version": "3.7.4" + }, + "typing-extensions-3.7.4.1-0.conda": { + "build": "0", + "build_number": 0, + "depends": [ + "python", + "typing_extensions 3.7.4.1 py38_0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "8d3f27f85965d4143dd9bfb8275de491", + "name": "typing-extensions", + "sha256": "894fd87910c3db5820e644765a9e770712e8c440bbf473fba958c9c7830f2ff8", + "size": 10709, + "subdir": "linux-64", + "timestamp": 1573975369052, + "version": "3.7.4.1" + }, + "typing-extensions-4.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "typing_extensions 4.3.0 py310h06a4308_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "bf16e8a3572b03d175d01df8e0c8356d", + "name": "typing-extensions", + "sha256": "416003bad5bae86adc1d715031705545107a3f464505460c44d7b66baea947f0", + "size": 9005, + "subdir": "linux-64", + "timestamp": 1659646979837, + "version": "4.3.0" + }, + "typing-extensions-4.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions 4.3.0 py37h06a4308_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "b6506e079c609e700162d203dc8b192c", + "name": "typing-extensions", + "sha256": "23cda4215f54b621ececba1bb3e41e8f80865209e089603661dedc5e8a641221", + "size": 8973, + "subdir": "linux-64", + "timestamp": 1659646941305, + "version": "4.3.0" + }, + "typing-extensions-4.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "typing_extensions 4.3.0 py38h06a4308_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "2e8b9c7fc51068ed33860e966ffa1e19", + "name": "typing-extensions", + "sha256": "a442e07e3670e422485c365b3120983a69c0bc8190b6589b5fce36958eaf0cc9", + "size": 8971, + "subdir": "linux-64", + "timestamp": 1659646884488, + "version": "4.3.0" + }, + "typing-extensions-4.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "typing_extensions 4.3.0 py39h06a4308_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "ba87eb919881e46897a30d8533d875a5", + "name": "typing-extensions", + "sha256": "bbc976b1a5096d84a3248d7970b073a87f1baec896d3431c5557aec6c58f679a", + "size": 8967, + "subdir": "linux-64", + "timestamp": 1659646912817, + "version": "4.3.0" + }, + "typing-extensions-4.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "typing_extensions 4.4.0 py310h06a4308_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "b55d0939347c2723c6d937e1624c6944", + "name": "typing-extensions", + "sha256": "e9d8f098f3549ca3e2a6dbed222f84ad6376c678e4f947ee521cadf52d100644", + "size": 8516, + "subdir": "linux-64", + "timestamp": 1669924695636, + "version": "4.4.0" + }, + "typing-extensions-4.4.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "typing_extensions 4.4.0 py311h06a4308_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "022c6c390d20f684d16f92d83a78e86b", + "name": "typing-extensions", + "sha256": "881c1222c346500b967b76a08284fd6d9eda0b34b52d90c08522a8b316d5f110", + "size": 8603, + "subdir": "linux-64", + "timestamp": 1676822531595, + "version": "4.4.0" + }, + "typing-extensions-4.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "typing_extensions 4.4.0 py37h06a4308_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "26a98504003e1891b0df4f4c3eb476ca", + "name": "typing-extensions", + "sha256": "c2c1f2758be192e056ce2b1f5aadca91f6ceb393e5b0e479c261102f3e9b7f77", + "size": 8490, + "subdir": "linux-64", + "timestamp": 1669924624551, + "version": "4.4.0" + }, + "typing-extensions-4.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "typing_extensions 4.4.0 py38h06a4308_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "be633b2e246103f24acdf58329f9f7be", + "name": "typing-extensions", + "sha256": "2b538963aa3e9db91f0158a741a121b88d525215b3775454fe73ca6df143a990", + "size": 8495, + "subdir": "linux-64", + "timestamp": 1669924589305, + "version": "4.4.0" + }, + "typing-extensions-4.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "typing_extensions 4.4.0 py39h06a4308_0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "7542768a09c9d43447196b3c396a9471", + "name": "typing-extensions", + "sha256": "a3d8d97eec3b00ce37e943755b8dec1f41ef0596af00ea144cf71a13e549e524", + "size": 8500, + "subdir": "linux-64", + "timestamp": 1669924659728, + "version": "4.4.0" + }, + "typing_extensions-3.7.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "typing >=3.7.4" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "5765dddf79c82d8f44d4630eb3bd05d5", + "name": "typing_extensions", + "sha256": "aefd306f8d15d88e36fb1e1348e061c93c3f96176e450aa77041731af886873a", + "size": 17258, + "subdir": "linux-64", + "timestamp": 1569354436357, + "version": "3.7.4" + }, + "typing_extensions-3.7.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "355a89c1f0035cf07b67dae072b07c5b", + "name": "typing_extensions", + "sha256": "d731851c73df3cae3fc1b4ad230f0d3e2db0206b7dd441a2938cdcf09d4613c7", + "size": 39915, + "subdir": "linux-64", + "timestamp": 1569354436212, + "version": "3.7.4" + }, + "typing_extensions-3.7.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "a010fb0dd44c1642d5a232ae273ffe95", + "name": "typing_extensions", + "sha256": "d317f6d9eaac9a58ab3573839084938c553200822b4156fe2161b0263e90ce4b", + "size": 39736, + "subdir": "linux-64", + "timestamp": 1569354474512, + "version": "3.7.4" + }, + "typing_extensions-3.7.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "060ed60f61f04c3335ec5d4b0b1f62e5", + "name": "typing_extensions", + "sha256": "4b976194945e1aa00a9a939f8ca70da1a5403c4d437ebfe7e0c2cbf066e66bdd", + "size": 38614, + "subdir": "linux-64", + "timestamp": 1573200309422, + "version": "3.7.4" + }, + "typing_extensions-3.7.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "typing >=3.7.4" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "45887ddb241a8b7afe6c8ff5ed5025a6", + "name": "typing_extensions", + "sha256": "7fc2343a2f441dc0f1a691b10cdcba9cf7dfc128a564838016313ad514afc5b3", + "size": 17741, + "subdir": "linux-64", + "timestamp": 1573975316951, + "version": "3.7.4.1" + }, + "typing_extensions-3.7.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "3b8444747d9974ed0c30825dd4dfa6f8", + "name": "typing_extensions", + "sha256": "a46cf14ab08190b421a46efc2242ab3da9dee64ecb263525950a35df2c0b2e20", + "size": 40500, + "subdir": "linux-64", + "timestamp": 1573975250663, + "version": "3.7.4.1" + }, + "typing_extensions-3.7.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "ffbfb8478e7114fafd5c579d6e5dca17", + "name": "typing_extensions", + "sha256": "eb79e25599200c20a120f1cd91cc6fd918db65a309114af21417ee95bbefad5b", + "size": 40130, + "subdir": "linux-64", + "timestamp": 1573975311113, + "version": "3.7.4.1" + }, + "typing_extensions-3.7.4.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF", + "license_family": "PSF", + "md5": "316d2c683a8fea0b19eebe5fa9c4a408", + "name": "typing_extensions", + "sha256": "07a6c6a96d5336da91f21e89db3cc2157acbdbcfdf5f27f24d5733bf69a0fe60", + "size": 40849, + "subdir": "linux-64", + "timestamp": 1573975362923, + "version": "3.7.4.1" + }, + "typing_extensions-4.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "28829efff0195928d4bcef369dd9c5ee", + "name": "typing_extensions", + "sha256": "fee54f63886b467cf16f7ae20a856391de3ad1d078fcedbef16d622594c620ef", + "size": 43491, + "subdir": "linux-64", + "timestamp": 1659638902760, + "version": "4.3.0" + }, + "typing_extensions-4.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "f4517fd5de6998c8712bbc9a19a82a04", + "name": "typing_extensions", + "sha256": "4675dac10685426ed96ff5be6e64246727a230fa81662369cb62aeaa2f51836e", + "size": 42834, + "subdir": "linux-64", + "timestamp": 1659638848414, + "version": "4.3.0" + }, + "typing_extensions-4.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "74bff484372523bb87e78381d676b442", + "name": "typing_extensions", + "sha256": "df1083bab29d50fefea98814bfe33c1ca7c4a71f27903a20beee57db9977fe47", + "size": 43107, + "subdir": "linux-64", + "timestamp": 1659638924152, + "version": "4.3.0" + }, + "typing_extensions-4.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "92209054f8d66c9ac9a59c972f34cd58", + "name": "typing_extensions", + "sha256": "18cfce9b53b1737329bd1ba7a8691cb6c8e8e4ec4224598ee14501f51a0b8781", + "size": 43065, + "subdir": "linux-64", + "timestamp": 1659638870582, + "version": "4.3.0" + }, + "typing_extensions-4.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.6,<4", + "python >=3.10,<3.11.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "dcf825498134021689b90e316b9fa5ca", + "name": "typing_extensions", + "sha256": "91cbaffc098076006f6b9940e3e467ce6366ea5764fd51a1082b2d063950d52a", + "size": 47488, + "subdir": "linux-64", + "timestamp": 1669924689894, + "version": "4.4.0" + }, + "typing_extensions-4.4.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.6,<4", + "python >=3.11,<3.12.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "788e0912adb33b106f6f7e5e5678b31c", + "name": "typing_extensions", + "sha256": "177d99bf3f5c5603c5ad8b7278fef668fcdc2e1f56998b1b6c6e87523d774a47", + "size": 55220, + "subdir": "linux-64", + "timestamp": 1676822528160, + "version": "4.4.0" + }, + "typing_extensions-4.4.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.6,<4", + "python >=3.7,<3.8.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "d7ab62b9397d8bae08cff8d8551984ef", + "name": "typing_extensions", + "sha256": "cc58156fbed3fc5e68906d6b6a44ac920e666102e5e4118f3565d16fefa5e145", + "size": 46567, + "subdir": "linux-64", + "timestamp": 1669924619181, + "version": "4.4.0" + }, + "typing_extensions-4.4.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.6,<4", + "python >=3.8,<3.9.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "8ec633925c961c6c6719b6c265d447f7", + "name": "typing_extensions", + "sha256": "50c54b8e949204b6f572baf554374fa6f838569288bda0137fd1e465f7b42ee1", + "size": 46992, + "subdir": "linux-64", + "timestamp": 1669924583937, + "version": "4.4.0" + }, + "typing_extensions-4.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "flit-core >=3.6,<4", + "python >=3.9,<3.10.0a0" + ], + "license": "PSF-2.0", + "license_family": "PSF", + "md5": "a2903b2c14d36498cd2fe2b0db5d7afb", + "name": "typing_extensions", + "sha256": "fcc092346973deb1df6529de1c434ef2de8b24310b290d5d743f283cffc7cbbf", + "size": 46968, + "subdir": "linux-64", + "timestamp": 1669924654177, + "version": "4.4.0" + }, + "typogrify-2.0.7-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "smartypants >=1.8.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "720e71afbc5a0ba7113da75a92cf84af", + "name": "typogrify", + "sha256": "19729461c26d0a10d562c69818723d4ae545f4be0219c1e8ccc0dc5e0947339b", + "size": 23442, + "subdir": "linux-64", + "timestamp": 1677593254081, + "version": "2.0.7" + }, + "typogrify-2.0.7-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "smartypants >=1.8.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "df493983a80a4a27898190bbf47ec355", + "name": "typogrify", + "sha256": "7714a753735f6440243b710febc997ff9e0ce17b8b954fb7c86091e10709d3de", + "size": 26762, + "subdir": "linux-64", + "timestamp": 1679340345732, + "version": "2.0.7" + }, + "typogrify-2.0.7-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "smartypants >=1.8.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "741aa32ec5d3961b54b5f8b092d1f6dd", + "name": "typogrify", + "sha256": "27a08b61bb7d020bb9841a0fbbb34576c46565c5254e4a637ac0ed25faa8fbef", + "size": 23269, + "subdir": "linux-64", + "timestamp": 1677593277989, + "version": "2.0.7" + }, + "typogrify-2.0.7-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "smartypants >=1.8.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "110de216a2209697d247f50e225b75ab", + "name": "typogrify", + "sha256": "3d3578407dad6ace3507911f2b3d207a362cb108e733ca7cf90f0780c708617e", + "size": 23313, + "subdir": "linux-64", + "timestamp": 1677593301766, + "version": "2.0.7" + }, + "typogrify-2.0.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "smartypants >=1.8.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dba9e3a71ebd95ee2a96f510252e1bd9", + "name": "typogrify", + "sha256": "71b8700ba0d5c4db35b1dea5784328d552c9e8f98b504fa4e315cc308b331249", + "size": 23293, + "subdir": "linux-64", + "timestamp": 1677593230045, + "version": "2.0.7" + }, + "tzlocal-1.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "e0111daeed9315f0864e4a01e53d4385", + "name": "tzlocal", + "sha256": "4264ddf4fe8d0dcd4eb2e429001589a5a218abd50bac644d08b7a61681520744", + "size": 28935, + "subdir": "linux-64", + "timestamp": 1529579512681, + "version": "1.5.1" + }, + "tzlocal-1.5.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytz" + ], + "license": "MIT", + "md5": "cd3bcc28824aef23cbd23789e0142c03", + "name": "tzlocal", + "sha256": "abf648907b3aebfcb209337b3622ae0bc181d67a23e6efb69fdc4a35bac6a027", + "size": 32992, + "subdir": "linux-64", + "timestamp": 1659703455445, + "version": "1.5.1" + }, + "tzlocal-1.5.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pytz" + ], + "license": "MIT", + "md5": "3cfb20ad51d1e7972314ebeeff94b0cb", + "name": "tzlocal", + "sha256": "cbb5c545f655dab16a384eee3b3d6e2f298bf897f8a9fe1dce6f1fcda1899222", + "size": 28638, + "subdir": "linux-64", + "timestamp": 1529579573554, + "version": "1.5.1" + }, + "tzlocal-1.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "3aaeca6b2ea29a1833de4858f85cff89", + "name": "tzlocal", + "sha256": "e378a22b5824f2d481b1a005fcba98fe2a629c4d14724eb40ddc3dea49325436", + "size": 27827, + "subdir": "linux-64", + "timestamp": 1529579509525, + "version": "1.5.1" + }, + "tzlocal-1.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "926e4e2b33649ffdf3c0e0a921adbf8a", + "name": "tzlocal", + "sha256": "31a0028c61230be13b9f9619795b20aa782b00b46027bed29ecdf2370c0bc0ea", + "size": 28090, + "subdir": "linux-64", + "timestamp": 1537652410372, + "version": "1.5.1" + }, + "tzlocal-1.5.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "e3498861129b8e53e26fb1bb21a3f74b", + "name": "tzlocal", + "sha256": "b6195e17602677411b973093915a50b045644c7f686037aed25ce9d0c6265d03", + "size": 29244, + "subdir": "linux-64", + "timestamp": 1659703477031, + "version": "1.5.1" + }, + "tzlocal-1.5.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "56ac4e59fce470689e91eab655fef0d8", + "name": "tzlocal", + "sha256": "68e23583b1cc2b19e83165a07c207d7a97d8c2967949a3a0ac0c3cd59a3592cf", + "size": 29338, + "subdir": "linux-64", + "timestamp": 1659703424344, + "version": "1.5.1" + }, + "tzlocal-1.5.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "7c0e0019909d72ce411ffb01b6b548d8", + "name": "tzlocal", + "sha256": "994edc57fb8c7516bfa2777330d04c9701639a6c4f14ce12b5cffd2190b57d13", + "size": 29357, + "subdir": "linux-64", + "timestamp": 1659703498216, + "version": "1.5.1" + }, + "tzlocal-2.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "5355d2c4c782c164fd811b0208670f41", + "name": "tzlocal", + "sha256": "d172e255a06f616e0a6500ebb2c3d19600f66a84a3d47c951a3398fb8a7c4a70", + "size": 29995, + "subdir": "linux-64", + "timestamp": 1564710514522, + "version": "2.0.0" + }, + "tzlocal-2.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "5c8aed6600fdb946f667386b6f31cbeb", + "name": "tzlocal", + "sha256": "da53a696fa4b2d25e9cf160c7de38f3c7aaaf9825e32ff08b0648d632ffb0e1e", + "size": 28798, + "subdir": "linux-64", + "timestamp": 1564710535408, + "version": "2.0.0" + }, + "tzlocal-2.0.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "99d9a9c9fae49ea2877a52f946920e6d", + "name": "tzlocal", + "sha256": "0622c40ce3c23d1aab332b8f69a06796a0b54fb293904649998610e79569f71c", + "size": 29569, + "subdir": "linux-64", + "timestamp": 1613144869393, + "version": "2.0.0" + }, + "tzlocal-2.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "817c88b8ec52aeec2020bdcccbd06251", + "name": "tzlocal", + "sha256": "dd692f547ae4eb5f5abafce1d01a6a2efe2f88b8b8dd4a9e1645c423dbb84371", + "size": 28982, + "subdir": "linux-64", + "timestamp": 1564710173019, + "version": "2.0.0" + }, + "tzlocal-2.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "baea1861b5fb7404fdf8ebce3eb46bf9", + "name": "tzlocal", + "sha256": "4e6971b251ffc2d509429df7cd6c1aca0d5a83c11168ee500926c12edb876e60", + "size": 29713, + "subdir": "linux-64", + "timestamp": 1613145314325, + "version": "2.0.0" + }, + "tzlocal-2.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "982a1c2c0a1614486317369cb1c75921", + "name": "tzlocal", + "sha256": "dd53257c787da3d03c3931bf8ad3468bb1209e3c2a2c8405fdc7fd65e6c3ad5c", + "size": 27444, + "subdir": "linux-64", + "timestamp": 1573554860257, + "version": "2.0.0" + }, + "tzlocal-2.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "64bc459669e204dcc7471355296afddd", + "name": "tzlocal", + "sha256": "b33ddf0ad1dfbc064d9787bd08b550f45b00240a9060dad0e6b1733f035d8a46", + "size": 29997, + "subdir": "linux-64", + "timestamp": 1613145321970, + "version": "2.0.0" + }, + "tzlocal-2.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "6dafa73d15853925c685fa4be41e9032", + "name": "tzlocal", + "sha256": "b0e078c7e85cd35c5b5a797f41f8120e6981ad2bbf8a85cc75864e602732678d", + "size": 30043, + "subdir": "linux-64", + "timestamp": 1613145322353, + "version": "2.0.0" + }, + "tzlocal-2.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytz" + ], + "license": "MIT", + "md5": "ff6cf61ac4951bffc28d69460a95671e", + "name": "tzlocal", + "sha256": "77b9ba481f583a97f61108f60f48da98390d708e5721a2e8d2f43e66806f6948", + "size": 31333, + "subdir": "linux-64", + "timestamp": 1640795577170, + "version": "2.1" + }, + "tzlocal-2.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8786cf1d5d2bd7881656c3725ded3fc", + "name": "tzlocal", + "sha256": "bfeac1479c4ba3d8fd42e8b7531fa2dc01f16f193a94c134a6f98e7ae7924915", + "size": 33733, + "subdir": "linux-64", + "timestamp": 1668627684640, + "version": "2.1" + }, + "tzlocal-2.1-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aaf415ae8610986dfe2553878748b189", + "name": "tzlocal", + "sha256": "14e644e3d4482de6a793023eeafc61d12c7bc8d76857c6b94a661fb294f1e0ba", + "size": 35381, + "subdir": "linux-64", + "timestamp": 1676842985251, + "version": "2.1" + }, + "tzlocal-2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pytz" + ], + "license": "MIT", + "md5": "7daa99eb485c2d71c2655f820c134aa8", + "name": "tzlocal", + "sha256": "45b85815d987327823921a333d72c1ddfb6a4daaa96f08df1738d36492107991", + "size": 29502, + "subdir": "linux-64", + "timestamp": 1597435751899, + "version": "2.1" + }, + "tzlocal-2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "md5": "85bd120843e6cc661ee3f37d2604afa7", + "name": "tzlocal", + "sha256": "204486c8e7fdfa2c488be92b34e56602e4bda1d5862a6105c9af5c1a58bae652", + "size": 29634, + "subdir": "linux-64", + "timestamp": 1597435747660, + "version": "2.1" + }, + "tzlocal-2.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "39bdaec84baf1608084b9e83b814c2b6", + "name": "tzlocal", + "sha256": "ddc15272b1ad719eb520fd8a55dfc13a279191e965f35ef1e7bfa6b28b8db9c6", + "size": 29233, + "subdir": "linux-64", + "timestamp": 1668627630663, + "version": "2.1" + }, + "tzlocal-2.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "md5": "19f4315a3e372a57ec1f8fce66b93a52", + "name": "tzlocal", + "sha256": "a6f6027f392b9bfb5a4f399edd5ef98519861d4493b86084a6fab4f1f6ecdee9", + "size": 29799, + "subdir": "linux-64", + "timestamp": 1597435760220, + "version": "2.1" + }, + "tzlocal-2.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08a758d9010182f0e47570718cd4e405", + "name": "tzlocal", + "sha256": "ff6d93d747a0f1c2345076fea024c8c45b25af2058e4422ad9abf29b6b051698", + "size": 29471, + "subdir": "linux-64", + "timestamp": 1668627711015, + "version": "2.1" + }, + "tzlocal-2.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "md5": "3fb6e266d562ef669a6f76d5bd065c0f", + "name": "tzlocal", + "sha256": "7b526e5be577c52c55494300610bc5733a1b38f9ea094d36d995e178b4dd8fbb", + "size": 29856, + "subdir": "linux-64", + "timestamp": 1608245380590, + "version": "2.1" + }, + "tzlocal-2.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "pytz" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0b6ddabd5801d62208b974ff9c87a696", + "name": "tzlocal", + "sha256": "0d68937f3adf5348bc6e6dca9d2e25442d3679cd83469c098c55b602a32bb96e", + "size": 29575, + "subdir": "linux-64", + "timestamp": 1668627657649, + "version": "2.1" + }, + "uc-micro-py-1.0.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be4974b53f71fd18a08d93c78275683f", + "name": "uc-micro-py", + "sha256": "93e6d1d08373a0447e50b0d5225166357134ff743657f24d7415aed583bc293e", + "size": 10291, + "subdir": "linux-64", + "timestamp": 1659769481565, + "version": "1.0.1" + }, + "uc-micro-py-1.0.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bda79b01444ea4af1adf068b29982dc7", + "name": "uc-micro-py", + "sha256": "da42ee92db4312ddd65275929860ae2c4de6c6ba5e68c46dff40e474912e7f1e", + "size": 10948, + "subdir": "linux-64", + "timestamp": 1676828901104, + "version": "1.0.1" + }, + "uc-micro-py-1.0.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8699b03fa46e7137e70af24057a8cd06", + "name": "uc-micro-py", + "sha256": "87a7070188b43f8b2c056f14bd335109439b4c2e4daabb7a7c592702361bfa3c", + "size": 10225, + "subdir": "linux-64", + "timestamp": 1659769535849, + "version": "1.0.1" + }, + "uc-micro-py-1.0.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "43885986f1b11a6063113b1d918f108b", + "name": "uc-micro-py", + "sha256": "a47f3fe61cc037ed38252f5870503e4b5a4f087f455e1943e60489170915e2ac", + "size": 10202, + "subdir": "linux-64", + "timestamp": 1659769442938, + "version": "1.0.1" + }, + "uc-micro-py-1.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5cc648f5d1d2d6de93776873e4d97611", + "name": "uc-micro-py", + "sha256": "88a5860c8da3fc3e34c02b9db0bd860017ac199b3d56ef9c366ae82003ace63b", + "size": 10193, + "subdir": "linux-64", + "timestamp": 1659769510353, + "version": "1.0.1" + }, + "udunits2-2.2.25-hd30922c_1.conda": { + "build": "hd30922c_1", + "build_number": 1, + "depends": [ + "expat", + "libgcc-ng >=7.2.0" + ], + "license": "UCAR OSI approved", + "md5": "e15a91ac8d3343ac8c6f36a616d532f0", + "name": "udunits2", + "sha256": "d0341636f06b1ca003f47a28e0a797543e53ca68fa37cf019c9ee572970bd4e0", + "size": 146560, + "subdir": "linux-64", + "timestamp": 1507908864208, + "version": "2.2.25" + }, + "ujson-1.35-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4bd64be10ef7af50c1a8a975dd71fd1e", + "name": "ujson", + "sha256": "8e2b00ffab543bd5911c0071f3b48c82ac0b50b8c2c532f838ed17b450167acf", + "size": 26363, + "subdir": "linux-64", + "timestamp": 1530961770339, + "version": "1.35" + }, + "ujson-1.35-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d173c9ac470b7e8e549d98cedc5a0089", + "name": "ujson", + "sha256": "87990d34517e58ed85cb1b13ba3aec4d6e660899df7dbd3eda7c3ab6136ac12b", + "size": 26338, + "subdir": "linux-64", + "timestamp": 1535739541348, + "version": "1.35" + }, + "ujson-1.35-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "314e59881d7ff9b776f297d7e5baf4ef", + "name": "ujson", + "sha256": "dd88ef68717c9faa030a98325c85371c0d1601c9f2313bc6019e238463e9d798", + "size": 25689, + "subdir": "linux-64", + "timestamp": 1530961802013, + "version": "1.35" + }, + "ujson-1.35-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "af897458ae3c24bf543c1691b4ee947d", + "name": "ujson", + "sha256": "aeb3ebf36eac20d251d5477febcc4dd887d9af26f304a6d96ed4842ba92e7b02", + "size": 25680, + "subdir": "linux-64", + "timestamp": 1530961833984, + "version": "1.35" + }, + "ujson-1.35-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d0e6891068667ceae2570b3da317f8d4", + "name": "ujson", + "sha256": "c39676b11b8caa5e3d314f57022428b2989417917dd56fae5c9f81ecbac96694", + "size": 35130, + "subdir": "linux-64", + "timestamp": 1573200552758, + "version": "1.35" + }, + "ujson-2.0.3-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e142a891f4356ca3cc1afa81308ffb01", + "name": "ujson", + "sha256": "e3295c9225707d75960923b59bdd6018432badc16e8f79356e0acfd666ec76cc", + "size": 45729, + "subdir": "linux-64", + "timestamp": 1586458603578, + "version": "2.0.3" + }, + "ujson-2.0.3-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "6483b9cac7e869bd3bcb99f9d30d50ec", + "name": "ujson", + "sha256": "6efb2216d73b8f87bae8f3c497d8cb5fba7b5e08e18e0f1eee855e3b6a414903", + "size": 46251, + "subdir": "linux-64", + "timestamp": 1586458589665, + "version": "2.0.3" + }, + "ujson-2.0.3-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "2e2b74ae468a9adc5295416d85a63404", + "name": "ujson", + "sha256": "57a37be41519f130d6c510bb19f2dfd4c50ba4e6f5eeb5dd14d17faff399959b", + "size": 45950, + "subdir": "linux-64", + "timestamp": 1586458581230, + "version": "2.0.3" + }, + "ujson-3.0.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "843b4fcbef76909523d2970fbcc8c727", + "name": "ujson", + "sha256": "28b555a249ae3f28edc0a80205de2b2835250d06d47d48e80566ef46cc7c6b5f", + "size": 48165, + "subdir": "linux-64", + "timestamp": 1592441293975, + "version": "3.0.0" + }, + "ujson-3.0.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "50d33b8f6b9dda56b334a7aa2ce77da7", + "name": "ujson", + "sha256": "100830f4a4778ee6977e4fd11e1bd7f5ec41cab29d8bfd6f2061bd4a472f2876", + "size": 48300, + "subdir": "linux-64", + "timestamp": 1592441264276, + "version": "3.0.0" + }, + "ujson-3.0.0-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "3963b9cd179e9d8927bd91d972961347", + "name": "ujson", + "sha256": "bf57f8e74a2306115c41099a7e36ceefcbb2ca460060ff2aa8b8bf1eac151498", + "size": 49067, + "subdir": "linux-64", + "timestamp": 1592441264386, + "version": "3.0.0" + }, + "ujson-3.1.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f08170a976b74d31ef07ae973ccd4971", + "name": "ujson", + "sha256": "c1128b4ddfeea40374f1a3b3c8868dd78ca86261a54031804b3c0e5679f5b6d6", + "size": 49212, + "subdir": "linux-64", + "timestamp": 1597931499965, + "version": "3.1.0" + }, + "ujson-3.1.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e334136b82ba115aa0387e54de8362a6", + "name": "ujson", + "sha256": "6771184282622a65e637d779f1ec333db941330cf4db624f691580bb2f8ed8db", + "size": 48649, + "subdir": "linux-64", + "timestamp": 1597931462649, + "version": "3.1.0" + }, + "ujson-3.1.0-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "bc268056e622b9e46ddb737768c999b0", + "name": "ujson", + "sha256": "0cab4978590fc90c8f66e39dae3f9e60469a4e70a6b1545053e7dcb71385262d", + "size": 49331, + "subdir": "linux-64", + "timestamp": 1597931493556, + "version": "3.1.0" + }, + "ujson-3.1.0-py39h66f3464_0.conda": { + "build": "py39h66f3464_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c3fa811a41b7ecc0e706d688337cd26e", + "name": "ujson", + "sha256": "06a6df9f98a8c7c094e4150e4e87f0bd48cfff0389c9c705aaed8cd4c2bfff5a", + "size": 49769, + "subdir": "linux-64", + "timestamp": 1607570432262, + "version": "3.1.0" + }, + "ujson-3.2.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "43767cd8ae5c7b2b070be4e5ea5d9866", + "name": "ujson", + "sha256": "d264d8b55d9084e5166101503e1de4f05fcd205b8c740082675e7becd36e76fe", + "size": 46094, + "subdir": "linux-64", + "timestamp": 1600709395780, + "version": "3.2.0" + }, + "ujson-3.2.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f606a680d326737070d45892cf8fdcff", + "name": "ujson", + "sha256": "ce4e1998404a5b897dd146363c10d49b59b7babb018a2914ea1fcd95693c70bc", + "size": 46067, + "subdir": "linux-64", + "timestamp": 1600709349719, + "version": "3.2.0" + }, + "ujson-3.2.0-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "21cca6bb83277b0c1b2d69158c145bdc", + "name": "ujson", + "sha256": "55ee5ad665652824b446ac4d4f1e1a8f60ab9d332e1bb6a8734dfa4147558222", + "size": 46234, + "subdir": "linux-64", + "timestamp": 1600709369218, + "version": "3.2.0" + }, + "ujson-4.0.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "836a77cdcf182ca0fb6d00856683066e", + "name": "ujson", + "sha256": "16f8a4aeb3c78fdea16b42ea53faee618f9af048b8e776a665789214c62ccbdc", + "size": 46020, + "subdir": "linux-64", + "timestamp": 1602185255835, + "version": "4.0.0" + }, + "ujson-4.0.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "fed0e07a47434a94eb1dfcac0cff7a91", + "name": "ujson", + "sha256": "bffa297269882669405351ef74f9a31cc2b7687cb4bec5c1e2776fa561dbdd8d", + "size": 46064, + "subdir": "linux-64", + "timestamp": 1602185225480, + "version": "4.0.0" + }, + "ujson-4.0.0-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "530909ebc52c80aefcef04279706e947", + "name": "ujson", + "sha256": "968fa75330cd326bdf8a632f870c51e25b3d17dbbf9fd41581ca05a9462b6cc5", + "size": 46277, + "subdir": "linux-64", + "timestamp": 1602185250665, + "version": "4.0.0" + }, + "ujson-4.0.1-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "8f9a483ae0d3842925c6dfe7da383979", + "name": "ujson", + "sha256": "c633e08937dcda38ab5ac7a4a40d9724cf21de8c245e95b9af65471582885ed2", + "size": 46762, + "subdir": "linux-64", + "timestamp": 1602523363196, + "version": "4.0.1" + }, + "ujson-4.0.1-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "134374b18294a4533018363d923187b8", + "name": "ujson", + "sha256": "1b6d64d3273899b0e5cdfd5da54ba289c5dd66d4c51505c81797c4deba407358", + "size": 46163, + "subdir": "linux-64", + "timestamp": 1602523355051, + "version": "4.0.1" + }, + "ujson-4.0.1-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "c9ee4df278e5da36f5b3b333efae76c4", + "name": "ujson", + "sha256": "0a71d6c454f90bd8e145bf1cd9d2e9d96b9586522bafaf70ebed5b80eb3d4cda", + "size": 46326, + "subdir": "linux-64", + "timestamp": 1602523368189, + "version": "4.0.1" + }, + "ujson-4.0.2-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "5020e1eb851e54e47cf847959810ee22", + "name": "ujson", + "sha256": "990356cd4c3125ad69535cf84c81b7a0b1c5d311327a4554f3af9fb66238b86d", + "size": 159444, + "subdir": "linux-64", + "timestamp": 1640795605515, + "version": "4.0.2" + }, + "ujson-4.0.2-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e9d321409f0020c78f7b716be738b894", + "name": "ujson", + "sha256": "00a83bbbc160863a23be1e58c1d1ef9859f78d12272e73ee014029e9776aafeb", + "size": 46187, + "subdir": "linux-64", + "timestamp": 1611259545930, + "version": "4.0.2" + }, + "ujson-4.0.2-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "567b2aa6754f79f604c9c87bf503b18e", + "name": "ujson", + "sha256": "c831b2d6e244e0fc816fe5ca52b25306b796d1d8e589bd3167a2b155fd7c0b36", + "size": 45966, + "subdir": "linux-64", + "timestamp": 1611259553564, + "version": "4.0.2" + }, + "ujson-4.0.2-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "cbc923c14baf7f00266426d7fe4263b6", + "name": "ujson", + "sha256": "0aa072dbb581b4471aa88c641200bb83b541cec13937cae4bfd121e68a28ceaf", + "size": 46447, + "subdir": "linux-64", + "timestamp": 1611259568435, + "version": "4.0.2" + }, + "ujson-4.0.2-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "902bce0940c9ddf394da07b4b6333eae", + "name": "ujson", + "sha256": "8418333f1dd4b4fded992094681b411fba14f1ba90168149b2d9ae95a7c0b630", + "size": 47260, + "subdir": "linux-64", + "timestamp": 1611259570977, + "version": "4.0.2" + }, + "ujson-4.2.0-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f4713d93ba48a40cd492b384c5ca8d5b", + "name": "ujson", + "sha256": "a71d27d104879085aaad3c2a4a5bd27348cb0dddbb91749f7804dc681b07931c", + "size": 46214, + "subdir": "linux-64", + "timestamp": 1640703936763, + "version": "4.2.0" + }, + "ujson-4.2.0-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "d8ec3554640307e01a41edf3192f9a27", + "name": "ujson", + "sha256": "f1d84f0090e79e5280be00d99b69df0ebf6b8388d5dfb8c5a7657ce1ab78cf97", + "size": 46741, + "subdir": "linux-64", + "timestamp": 1640703963524, + "version": "4.2.0" + }, + "ujson-4.2.0-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "0b735696d9756a1cf97f1b70396cca43", + "name": "ujson", + "sha256": "3abac78a4d8daf6a4c083cf2fc8761f23bf06338a4ef90fff21c62f65578ba65", + "size": 46958, + "subdir": "linux-64", + "timestamp": 1640703908654, + "version": "4.2.0" + }, + "ujson-5.1.0-py310h295c915_0.conda": { + "build": "py310h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7c25f44f0a878222f403a23586a8e7f8", + "name": "ujson", + "sha256": "65b75e10e767888421af9ec686fcce667bad60832981e5138fa103f7da740ad7", + "size": 46852, + "subdir": "linux-64", + "timestamp": 1648044108934, + "version": "5.1.0" + }, + "ujson-5.1.0-py37h295c915_0.conda": { + "build": "py37h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "105be7b2bb899b418f65bb8514d229e8", + "name": "ujson", + "sha256": "80c32c779cea3a43ac55fbcc74cd04876f2038e6d948b35a029ab2413041199c", + "size": 46715, + "subdir": "linux-64", + "timestamp": 1648026228174, + "version": "5.1.0" + }, + "ujson-5.1.0-py38h295c915_0.conda": { + "build": "py38h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1f559a58e0278caab2dcb9e19c7533ac", + "name": "ujson", + "sha256": "0f961fd752b8412ced0119e1aa5067da5b3db12aa21156c0f87c0fe03803e495", + "size": 46848, + "subdir": "linux-64", + "timestamp": 1648025964104, + "version": "5.1.0" + }, + "ujson-5.1.0-py39h295c915_0.conda": { + "build": "py39h295c915_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eacb59e004ff2c37a5747e6570ad39e1", + "name": "ujson", + "sha256": "18a9749565b98fa53669b3ad030c46af3719520ee4dda0333186196efc3c028f", + "size": 47087, + "subdir": "linux-64", + "timestamp": 1648025964063, + "version": "5.1.0" + }, + "ujson-5.4.0-py310h6a678d5_0.conda": { + "build": "py310h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "47aebc03b048a717245f37efdf165248", + "name": "ujson", + "sha256": "acfbdfd58ef6d49bc74479fafaebae86c3561caf133b7ad6cd6a832e3125f962", + "size": 45148, + "subdir": "linux-64", + "timestamp": 1657544991544, + "version": "5.4.0" + }, + "ujson-5.4.0-py311h6a678d5_0.conda": { + "build": "py311h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2c7257830458ad1c4b20bb21b3a8b63b", + "name": "ujson", + "sha256": "fef5fa1f2ee4f8669f6413fde228f1e88c3000a842a4ef3e939d73f83bbbefaf", + "size": 44817, + "subdir": "linux-64", + "timestamp": 1676828920779, + "version": "5.4.0" + }, + "ujson-5.4.0-py37h6a678d5_0.conda": { + "build": "py37h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3d875d846dfe5a7d96fc6f331c286dcd", + "name": "ujson", + "sha256": "4ef5dad98d7232eaf80d8b4e86282ed9c9dfcea03c029a28fb60737f17f148df", + "size": 45040, + "subdir": "linux-64", + "timestamp": 1657545094704, + "version": "5.4.0" + }, + "ujson-5.4.0-py38h6a678d5_0.conda": { + "build": "py38h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3f0b1db7de5acbd95c463785fe7c22bb", + "name": "ujson", + "sha256": "b9db95e5e4b20bc78d7d419b8d1ee3e37d7715c27141e89c5d532af9973ed27e", + "size": 45123, + "subdir": "linux-64", + "timestamp": 1657545059454, + "version": "5.4.0" + }, + "ujson-5.4.0-py39h6a678d5_0.conda": { + "build": "py39h6a678d5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "569c336e837ed9d3a6f24acc9c7b5e16", + "name": "ujson", + "sha256": "d12f04d1c29f65313ec9d1017fe5023e92c3638048d0d6144b5451878883ef26", + "size": 45176, + "subdir": "linux-64", + "timestamp": 1657545025422, + "version": "5.4.0" + }, + "ukkonen-1.0.1-py310hdb19cb5_0.conda": { + "build": "py310hdb19cb5_0", + "build_number": 0, + "depends": [ + "cffi >=1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a5f432a2c5636f906c561ba5db02a8f4", + "name": "ukkonen", + "sha256": "40ae928f4d3a730c6665f6ba6ca1a0a163e0f05264574eb151a75c802fa9e042", + "size": 30775, + "subdir": "linux-64", + "timestamp": 1663174692558, + "version": "1.0.1" + }, + "ukkonen-1.0.1-py311hdb19cb5_0.conda": { + "build": "py311hdb19cb5_0", + "build_number": 0, + "depends": [ + "cffi >=1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a2bda9c486b6982d9faa56808808e63e", + "name": "ukkonen", + "sha256": "602db7b68ec697b5d5d92bd1f30d5b64575b329a2ccf4a761220cd1ad3825b98", + "size": 12452, + "subdir": "linux-64", + "timestamp": 1676843006064, + "version": "1.0.1" + }, + "ukkonen-1.0.1-py37hdb19cb5_0.conda": { + "build": "py37hdb19cb5_0", + "build_number": 0, + "depends": [ + "cffi >=1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3b4c4951e6b5e02c56af10f5650f0237", + "name": "ukkonen", + "sha256": "3c885241ef09bbaff2cfcfe86c4c3abad5f5a022eaf779e43b95e75b0e1b2583", + "size": 11890, + "subdir": "linux-64", + "timestamp": 1663174649605, + "version": "1.0.1" + }, + "ukkonen-1.0.1-py38hdb19cb5_0.conda": { + "build": "py38hdb19cb5_0", + "build_number": 0, + "depends": [ + "cffi >=1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "918a00b6668113b7010eaecc3dd479de", + "name": "ukkonen", + "sha256": "4ae9786e7a69ab6d2d9b5592eac78a77fc34f61dc5a4475b2981fd84b099799c", + "size": 11890, + "subdir": "linux-64", + "timestamp": 1663174588135, + "version": "1.0.1" + }, + "ukkonen-1.0.1-py39hdb19cb5_0.conda": { + "build": "py39hdb19cb5_0", + "build_number": 0, + "depends": [ + "cffi >=1", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba67f51c7e36eaa0e3c609d401b1e80a", + "name": "ukkonen", + "sha256": "16879aa09f92cd46fad2ffbbd6384f81659bb49cedda1d436989c2c17ebd40dc", + "size": 11930, + "subdir": "linux-64", + "timestamp": 1663174619229, + "version": "1.0.1" + }, + "unearth-0.6.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20", + "python >=3.10,<3.11.0a0", + "requests >=2.25" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb1dc5c455370ae07ce6aef664956a4e", + "name": "unearth", + "sha256": "e798d46310a9dc2ac0d8b5797238bb865b5ac5574908366ad825f175ae5fa04c", + "size": 305563, + "subdir": "linux-64", + "timestamp": 1670000630946, + "version": "0.6.2" + }, + "unearth-0.6.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20", + "python >=3.11,<3.12.0a0", + "requests >=2.25" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aff8ab1a6816c4664a16203f7a47f486", + "name": "unearth", + "sha256": "78b485b54544af00325f51a1635e6858af3aa5442a00423b881f54b946e1f336", + "size": 321190, + "subdir": "linux-64", + "timestamp": 1676843020645, + "version": "0.6.2" + }, + "unearth-0.6.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "cached-property >=1.5.2", + "packaging >=20", + "python >=3.7,<3.8.0a0", + "requests >=2.25" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de4639a8686a37aa2e5ae0b544bead10", + "name": "unearth", + "sha256": "9e28faf8e6b6f142cfd6ab30c9f0c26b93a5e850d6d0361f2792cb2669a495f3", + "size": 305371, + "subdir": "linux-64", + "timestamp": 1670000663502, + "version": "0.6.2" + }, + "unearth-0.6.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20", + "python >=3.8,<3.9.0a0", + "requests >=2.25" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f506e22e27adf2e87d697d3677adde0", + "name": "unearth", + "sha256": "a368d04a512127bbfc9cdc268b901018a0c5c974e355a4e3022662fd74f01d20", + "size": 305761, + "subdir": "linux-64", + "timestamp": 1670000598259, + "version": "0.6.2" + }, + "unearth-0.6.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "packaging >=20", + "python >=3.9,<3.10.0a0", + "requests >=2.25" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb4b4f1120f839315d789dc9fd991c93", + "name": "unearth", + "sha256": "162dcfc14ff7d63889e6c06c97ee308f936aeebc528e2dd541ca26ac3095899c", + "size": 304877, + "subdir": "linux-64", + "timestamp": 1670000565401, + "version": "0.6.2" + }, + "unicodecsv-0.14.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "e696afd51e0f3a5036ea49558124f497", + "name": "unicodecsv", + "sha256": "a52292dae911858cdfb0cc6674156654fbb080ad6d1c019c06290bf8737efba7", + "size": 25321, + "subdir": "linux-64", + "timestamp": 1531060456119, + "version": "0.14.1" + }, + "unicodecsv-0.14.1-py27h5062da9_0.conda": { + "build": "py27h5062da9_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "a829151310e682fea0b31d4521dff0bc", + "name": "unicodecsv", + "sha256": "e9b6fa6087a1494adac421499f6bdeff8206b8fcd5db8fdf2d265aa4b49aa3ba", + "size": 24939, + "subdir": "linux-64", + "timestamp": 1505852006564, + "version": "0.14.1" + }, + "unicodecsv-0.14.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "500f6e12e206920ed44eeeff4aaa464c", + "name": "unicodecsv", + "sha256": "13cb3105946215501bed7bab61aff91aab5b39845b83f86cd36f342c1112ebbc", + "size": 27966, + "subdir": "linux-64", + "timestamp": 1640795623457, + "version": "0.14.1" + }, + "unicodecsv-0.14.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "a540a5d7b3d309d8236d88b6bdae38cd", + "name": "unicodecsv", + "sha256": "5082ba38f5879c576a2a763ab9ba6707e96c1e2b846fcc2e346e6739a7ecc5a3", + "size": 36514, + "subdir": "linux-64", + "timestamp": 1676838885496, + "version": "0.14.1" + }, + "unicodecsv-0.14.1-py35h4805c0c_0.conda": { + "build": "py35h4805c0c_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "305f154037e01ba15130a1cd4967a48e", + "name": "unicodecsv", + "sha256": "b1c6c41813f8fc717613154d0e36fe2ba30073d8e411c2a76772c8cf6220041d", + "size": 25990, + "subdir": "linux-64", + "timestamp": 1505852018863, + "version": "0.14.1" + }, + "unicodecsv-0.14.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "7b028160e815d39e31945e8922d02ba7", + "name": "unicodecsv", + "sha256": "2a7411398fa30729a2b2f0599fe2ac317d77c5f9d65ed744df5ccf5d365eeadc", + "size": 26004, + "subdir": "linux-64", + "timestamp": 1531060393148, + "version": "0.14.1" + }, + "unicodecsv-0.14.1-py36ha668878_0.conda": { + "build": "py36ha668878_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "fa26486657a3ebd67597b830daab5258", + "name": "unicodecsv", + "sha256": "3babb8afb3116d73d4cded3dd849008413a4913f7f80adde961753a79b6c39fb", + "size": 25808, + "subdir": "linux-64", + "timestamp": 1505852031265, + "version": "0.14.1" + }, + "unicodecsv-0.14.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "b3132b04e8fbc7858ada8466d7c6d890", + "name": "unicodecsv", + "sha256": "14a73f4f458f3939e94eca458922813068cc75a4ee7f6340e8d88dcf40995d4f", + "size": 26105, + "subdir": "linux-64", + "timestamp": 1531060424646, + "version": "0.14.1" + }, + "unicodecsv-0.14.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "972b0695b177ff0268173c75bebd3842", + "name": "unicodecsv", + "sha256": "f446cfe261c97a72d27432d2537ea7ae4fa2720973f224c98dfcc3cf66b405a4", + "size": 27917, + "subdir": "linux-64", + "timestamp": 1573200564391, + "version": "0.14.1" + }, + "unicodecsv-0.14.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "70f0aa7238bcde68ae1f01dcba925d0c", + "name": "unicodecsv", + "sha256": "dc723233524486919b52a29e29739028c6c5dc8c26cef3b36202a6e9b5085a9b", + "size": 28082, + "subdir": "linux-64", + "timestamp": 1607574365897, + "version": "0.14.1" + }, + "unicodedata2-13.0.0.post2-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a726b17c767ed17f455bce1fe0f5ca3c", + "name": "unicodedata2", + "sha256": "c3ec5cd7b5bd22700533a7b313b864ff3c2449c0324b80421b2390ffeb413396", + "size": 383948, + "subdir": "linux-64", + "timestamp": 1613482860449, + "version": "13.0.0.post2" + }, + "unicodedata2-13.0.0.post2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "32f30fb35c0c153a189741368d3a13e7", + "name": "unicodedata2", + "sha256": "b3231aeec4b4d7671bdd31c48dc58ca77c7a6f1a3165a7208caa9cfb3208a041", + "size": 397185, + "subdir": "linux-64", + "timestamp": 1587393869738, + "version": "13.0.0.post2" + }, + "unicodedata2-13.0.0.post2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "722f90096dbe8ad9ec68ab3482e5f33b", + "name": "unicodedata2", + "sha256": "18225e50699689388c8b034826a65b784725679e0767573ceb0804c0b00aebf1", + "size": 385298, + "subdir": "linux-64", + "timestamp": 1613482727542, + "version": "13.0.0.post2" + }, + "unicodedata2-13.0.0.post2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bbbb71ff5f91ce024a2c588e875cd2bb", + "name": "unicodedata2", + "sha256": "9041473181d59511a4c8cf8ad16ff9567ae77af46036baf1e1f6e0efbb9ae873", + "size": 398710, + "subdir": "linux-64", + "timestamp": 1587393847403, + "version": "13.0.0.post2" + }, + "unicodedata2-13.0.0.post2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bd36dd1a23ea832a642e5017b8908a1e", + "name": "unicodedata2", + "sha256": "17b95f875c14865d87293f5e5c526f7f0bec6314af524390217e7a90cb307cb1", + "size": 385218, + "subdir": "linux-64", + "timestamp": 1613482868665, + "version": "13.0.0.post2" + }, + "unicodedata2-13.0.0.post2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dd8d9d513ffb5dc0163aa127c7a6a028", + "name": "unicodedata2", + "sha256": "5d785bf17de1aed3921ccc31f3a8bf0e072032a646b1eec91442403cda1f024d", + "size": 384480, + "subdir": "linux-64", + "timestamp": 1587393885344, + "version": "13.0.0.post2" + }, + "unicodedata2-13.0.0.post2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e0e5f1324de10446219be7ef4044f1ee", + "name": "unicodedata2", + "sha256": "8e9eccbc4dcc13038bb10d26c3a5b9bda6eb18d463502df5b3100742d6ba6555", + "size": 384154, + "subdir": "linux-64", + "timestamp": 1613482865849, + "version": "13.0.0.post2" + }, + "unicodedata2-14.0.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3702b1e47938ed9b2987c20584dd6d01", + "name": "unicodedata2", + "sha256": "7781fd6b30b9f054e3f47e2b40fae8df220695f1cc0d1094d7974299a3f036b5", + "size": 427278, + "subdir": "linux-64", + "timestamp": 1642781405652, + "version": "14.0.0" + }, + "unicodedata2-15.0.0-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5460e115b6e9d48db8159738473d192f", + "name": "unicodedata2", + "sha256": "d1f8c05af9870bb70e5088f01cbfe3d97893f179ea2e35bbca94c5c521c3576f", + "size": 533818, + "subdir": "linux-64", + "timestamp": 1674227967685, + "version": "15.0.0" + }, + "unicodedata2-15.0.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "39a3a9760b69e45331c9b50ce2ad5a30", + "name": "unicodedata2", + "sha256": "f21ed5cfde9ce5b333c8aa1833adfc47c18cc880bc32624c61d758f09391238e", + "size": 373118, + "subdir": "linux-64", + "timestamp": 1676863402217, + "version": "15.0.0" + }, + "unicodedata2-15.0.0-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "7cdc3b7801af671faf30a1fa96ad62cd", + "name": "unicodedata2", + "sha256": "23462be76259cdb6783bd3de8b98fd24c982bc704c3545fea469861cef57febb", + "size": 528770, + "subdir": "linux-64", + "timestamp": 1674227937711, + "version": "15.0.0" + }, + "unicodedata2-15.0.0-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3bfd6697535a5f072f5fba11f3da9c0a", + "name": "unicodedata2", + "sha256": "9e9ff60630f51407fb28dda9b9fc191266f9f7b06f001ca8464fad92e2e067ce", + "size": 533795, + "subdir": "linux-64", + "timestamp": 1674227877840, + "version": "15.0.0" + }, + "unicodedata2-15.0.0-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0d50b78d2882e7032951c408476ecc28", + "name": "unicodedata2", + "sha256": "ea04b3de615129d4a62588fdbf53fb4cf8b09a5d3bd48571f00b5ea02495fc51", + "size": 533952, + "subdir": "linux-64", + "timestamp": 1674227907669, + "version": "15.0.0" + }, + "unidecode-1.0.22-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "md5": "8f5343cbaedd5de9fd1a57901ac6ea95", + "name": "unidecode", + "sha256": "d521eddb60ae203bfdf14552664b20dd766442501fb91202e4458198812dd7fc", + "size": 245119, + "subdir": "linux-64", + "timestamp": 1519244704887, + "version": "1.0.22" + }, + "unidecode-1.0.22-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "GPL-2.0", + "md5": "02e71cc6a040937815b2894e45fb9edd", + "name": "unidecode", + "sha256": "76f8c78ad80e07b1e73d23f273f58b87c3148da084b1b717e600950f0245227b", + "size": 240530, + "subdir": "linux-64", + "timestamp": 1519244729605, + "version": "1.0.22" + }, + "unidecode-1.0.22-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "md5": "1e2b2282316b60722d26e5bf6d8457fe", + "name": "unidecode", + "sha256": "098b0ab588f009ff9ce77aa8e55a3a96d3aabbbdef7669d60e3120a93eeb9f51", + "size": 238510, + "subdir": "linux-64", + "timestamp": 1519244691935, + "version": "1.0.22" + }, + "unidecode-1.0.22-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "md5": "1b81127975212bc275829b47a9fbc8d9", + "name": "unidecode", + "sha256": "ccc9cb1443bdf210f6a0a421e420415b0ea37865a12b84f73fd4b38fb41e3c63", + "size": 230176, + "subdir": "linux-64", + "timestamp": 1530735586631, + "version": "1.0.22" + }, + "unidecode-1.0.23-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "GPL-2.0", + "md5": "4f784f7659940119ea0be88945f08367", + "name": "unidecode", + "sha256": "1c132a7c873ce8e0a1236359fb237262b502bbd5319a71a150c946f2e0dabfae", + "size": 248241, + "subdir": "linux-64", + "timestamp": 1542642168359, + "version": "1.0.23" + }, + "unidecode-1.0.23-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "GPL-2.0", + "md5": "8f17dba175bf47a6ad6618bdac768dab", + "name": "unidecode", + "sha256": "be06a54a66bd19d345e971f4e33eef6d88bcab59661dd79df3978ca8bbb3e8f3", + "size": 239692, + "subdir": "linux-64", + "timestamp": 1542642198682, + "version": "1.0.23" + }, + "unidecode-1.0.23-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "GPL-2.0", + "md5": "ba100c7dd5419639f1d7f95b80fbe35b", + "name": "unidecode", + "sha256": "e887b6ea61d8f9ff15fef91521f678735453e431e306dda7338ecb8879b233e2", + "size": 232000, + "subdir": "linux-64", + "timestamp": 1542642148820, + "version": "1.0.23" + }, + "unittest2-1.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.4", + "traceback2" + ], + "license": "BSD", + "md5": "b66a2d4f18f3bd3f12576751189b434e", + "name": "unittest2", + "sha256": "9cfecb8f20957eb2c40da21c5ada511cf74636d099192bb2065ccedb6fc55007", + "size": 153083, + "subdir": "linux-64", + "timestamp": 1530898878278, + "version": "1.1.0" + }, + "unittest2-1.1.0-py27h1e968a4_0.conda": { + "build": "py27h1e968a4_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.4", + "traceback2" + ], + "license": "BSD", + "md5": "8ca366c45dbe331c14459e147c8b82bb", + "name": "unittest2", + "sha256": "407c9a4a3d06b2ed43839f24f53f122bf05fbeab9eaad138cecb9c4591b76c63", + "size": 155399, + "subdir": "linux-64", + "timestamp": 1508346237291, + "version": "1.1.0" + }, + "unittest2-1.1.0-py35h0cb595e_0.conda": { + "build": "py35h0cb595e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.4", + "traceback2" + ], + "license": "BSD", + "md5": "e705a7d2804d4189644d8138cc451c80", + "name": "unittest2", + "sha256": "ef2ae729269ed677650406aadfb6bfb3322e995439c8c563bb9ff67ad8e76314", + "size": 162698, + "subdir": "linux-64", + "timestamp": 1508346245435, + "version": "1.1.0" + }, + "unittest2-1.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.4", + "traceback2" + ], + "license": "BSD", + "md5": "bd686466d981d2befbbb2d4b57358fcf", + "name": "unittest2", + "sha256": "fd6c06327399e6fd25b27a122cf95bcd633939ca1135f6d23aac0b403f81e505", + "size": 159301, + "subdir": "linux-64", + "timestamp": 1530898939236, + "version": "1.1.0" + }, + "unittest2-1.1.0-py36h1dd7840_0.conda": { + "build": "py36h1dd7840_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.4", + "traceback2" + ], + "license": "BSD", + "md5": "a3dc5d27fd458b21efe2cdbc5cf18aae", + "name": "unittest2", + "sha256": "78a665cc86cef650d7b22e8475ab514edda157ddcd97bd4689c26f7a057f6b56", + "size": 161022, + "subdir": "linux-64", + "timestamp": 1508346247934, + "version": "1.1.0" + }, + "unittest2-1.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.4", + "traceback2" + ], + "license": "BSD", + "md5": "437f126284c93a3bc6fc4e0d94d3fa79", + "name": "unittest2", + "sha256": "cf558a19b6ecae12766859c2685c0d8f1bf6fa5857ad61bc13b25eb78c0b4ccf", + "size": 160985, + "subdir": "linux-64", + "timestamp": 1530898908174, + "version": "1.1.0" + }, + "unittest2-1.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six >=1.4", + "traceback2" + ], + "license": "BSD", + "md5": "2fc3ceee1fe7556510fcc98f13c7e85a", + "name": "unittest2", + "sha256": "fd181e65897a310617bfa873fe1845269f18eeb7235524f9e4c1017b09f036c1", + "size": 163088, + "subdir": "linux-64", + "timestamp": 1574153508147, + "version": "1.1.0" + }, + "unixodbc-2.3.11-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20210910,<3.2.0a0", + "libgcc-ng >=11.2.0" + ], + "license": "LGPL-2.1-or-later", + "license_family": "LGPL", + "md5": "e9778769e924f6964b892ad07abbabb6", + "name": "unixodbc", + "sha256": "05fb269bcc18a4367754d2273af36e19cd5c1882a7182a533eee0d8fb98ce702", + "size": 281970, + "subdir": "linux-64", + "timestamp": 1659559616604, + "version": "2.3.11" + }, + "unixodbc-2.3.4-h1bed415_2.conda": { + "build": "h1bed415_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "93c2dfe3d69058a6a0d1fc5413b4e060", + "name": "unixodbc", + "sha256": "3a5f8cb35b0f389fa780efd174d9f34a54fe0e2874434d2371951cd8a31dd826", + "size": 283590, + "subdir": "linux-64", + "timestamp": 1519122442569, + "version": "2.3.4" + }, + "unixodbc-2.3.4-hc36303a_1.conda": { + "build": "hc36303a_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "e2703c633952e22c298f4ef8778716c4", + "name": "unixodbc", + "sha256": "359231fa1a5a8a7453a115b1b6d5163ad735c58e91c10015938f11a3efd1eb37", + "size": 286941, + "subdir": "linux-64", + "timestamp": 1505751906155, + "version": "2.3.4" + }, + "unixodbc-2.3.5-h1bed415_0.conda": { + "build": "h1bed415_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "cab90cd3603fbd1c1c2f2dab9a4622dc", + "name": "unixodbc", + "sha256": "fc0e41680c1f7bd5139db1aa42ef8523f3cbce92e4cfc8b5f06fe9298f6c4dd0", + "size": 289384, + "subdir": "linux-64", + "timestamp": 1519174128895, + "version": "2.3.5" + }, + "unixodbc-2.3.6-h1bed415_0.conda": { + "build": "h1bed415_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "ce82a87284a7e58017a5f5928608b1ab", + "name": "unixodbc", + "sha256": "3a461a60d3d04761b031eefd9c8ef000440c0561b1dba2b8aac580beceaf5c4c", + "size": 291306, + "subdir": "linux-64", + "timestamp": 1522793866209, + "version": "2.3.6" + }, + "unixodbc-2.3.7-h14c3975_0.conda": { + "build": "h14c3975_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20170329,<3.2.0a0", + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "9837c769093f762f5becf99bb4de520f", + "name": "unixodbc", + "sha256": "90ae0d2afdb093d6572d4e13e300a16c92aaad270a987d82a9e8c3b2eed577bc", + "size": 292137, + "subdir": "linux-64", + "timestamp": 1535134163089, + "version": "2.3.7" + }, + "unixodbc-2.3.9-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libedit >=3.1.20191231,<3.2.0a0", + "libgcc-ng >=7.3.0" + ], + "license": "LGPL-2.1", + "license_family": "LGPL", + "md5": "67c4d497ed9f7ccc936b9e7eb663e970", + "name": "unixodbc", + "sha256": "8b0d87b99cdd5bee2f72382aae2cccde9b5b965b4698af63fe98ea90266d9fdc", + "size": 282425, + "subdir": "linux-64", + "timestamp": 1602700091394, + "version": "2.3.9" + }, + "unyt-2.9.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.17.5", + "python >=3.10,<3.11.0a0", + "sympy >=1.5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dbd532399cf6b401e8af5500034920dc", + "name": "unyt", + "sha256": "59914504d6cee66a2518a2c9f87217d9726a0685648fdd3d333ecd5c923225a9", + "size": 232570, + "subdir": "linux-64", + "timestamp": 1680625399202, + "version": "2.9.5" + }, + "unyt-2.9.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.17.5", + "python >=3.11,<3.12.0a0", + "sympy >=1.5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3e022a266bc9a66479059b0b52f91add", + "name": "unyt", + "sha256": "cb02df5058f8be68fffa6281214d246081f76ae9d5189a29ed322628f249cd5e", + "size": 293713, + "subdir": "linux-64", + "timestamp": 1680625435431, + "version": "2.9.5" + }, + "unyt-2.9.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.17.5", + "python >=3.8,<3.9.0a0", + "sympy >=1.5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0e3a60bd0651816b11c45f6bdd66fa81", + "name": "unyt", + "sha256": "be2f1ef0b6971dd9b807727abb0ecc0b7688cd7fdd60b63c76397fe556f2c811", + "size": 230485, + "subdir": "linux-64", + "timestamp": 1680625323197, + "version": "2.9.5" + }, + "unyt-2.9.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.17.5", + "python >=3.9,<3.10.0a0", + "sympy >=1.5" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85933a850d9b39c30aeb548e9e30b320", + "name": "unyt", + "sha256": "199d933881ce3492ef7fcf4e491493a72415b0f6ab3f22514ffa074b17cb9b8f", + "size": 229675, + "subdir": "linux-64", + "timestamp": 1680625362206, + "version": "2.9.5" + }, + "unzip-6.0-h611a1e1_0.conda": { + "build": "h611a1e1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "BSD-like", + "md5": "baf4dcca0c5eaad5efced6d4f51e6737", + "name": "unzip", + "sha256": "c38c1a825ea5237175b736b77ac7ef0f4bc4c43d8f709ba352aa01115d6b31a3", + "size": 89526, + "subdir": "linux-64", + "timestamp": 1508870827771, + "version": "6.0" + }, + "uriparser-0.9.3-he6710b0_1.conda": { + "build": "he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6aacd7a5a8e9eb685de5590478ee9844", + "name": "uriparser", + "sha256": "40e2fc22714db0af94b2afdc6efd98a23e3d3f9a8e0a7a7a986667cf7769a617", + "size": 48724, + "subdir": "linux-64", + "timestamp": 1580397170986, + "version": "0.9.3" + }, + "urllib3-1.22-py27ha55213b_0.conda": { + "build": "py27ha55213b_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f5e0bff7623a807edc30db73477acfac", + "name": "urllib3", + "sha256": "80481f83fda4ee36e482da2fd28f09bb5a0c8e93a35ad6a219c46a6333ab5967", + "size": 162400, + "subdir": "linux-64", + "timestamp": 1505693026646, + "version": "1.22" + }, + "urllib3-1.22-py35h2ab6e29_0.conda": { + "build": "py35h2ab6e29_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a3f8a8bd9f7e99e6652944a3b7a380ba", + "name": "urllib3", + "sha256": "1892fe99634ac2455333bbfe2e66f856ce9798de168c75229d24baf7de5c5dda", + "size": 166329, + "subdir": "linux-64", + "timestamp": 1505693040638, + "version": "1.22" + }, + "urllib3-1.22-py36hbe7ace6_0.conda": { + "build": "py36hbe7ace6_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a7a03b93c8e894d9629c46089c6d0e6", + "name": "urllib3", + "sha256": "8c27e2d2281b1cf6a1d7f0487651667e4d2805222cb7793b0454f2c76ea728bd", + "size": 164954, + "subdir": "linux-64", + "timestamp": 1505693054673, + "version": "1.22" + }, + "urllib3-1.23-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3349d0b2448b9917f97ca7a50f248e0", + "name": "urllib3", + "sha256": "61032549a57458dce3cd548d67e6cfa7ad5742142143bd0189aed95dc3b5c5bf", + "size": 159242, + "subdir": "linux-64", + "timestamp": 1529348113315, + "version": "1.23" + }, + "urllib3-1.23-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ba220e54d46f06b013d79e8474917a74", + "name": "urllib3", + "sha256": "c7f97cf1f84c8e45d97b8880cfc01d7261d2ff002774a64c69cf1cb88a919368", + "size": 160757, + "subdir": "linux-64", + "timestamp": 1529348125173, + "version": "1.23" + }, + "urllib3-1.23-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3fd93aea432e57c3f7b726b6d8686ad7", + "name": "urllib3", + "sha256": "7e1b785c578ddd1dcbbc0065dfc6c5c9df1864588f6a333f1f68d4a46ec1a43c", + "size": 159414, + "subdir": "linux-64", + "timestamp": 1529348098316, + "version": "1.23" + }, + "urllib3-1.23-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2599e7f89ff3e7574799a74a843a4b01", + "name": "urllib3", + "sha256": "1eb55db9fedd8500d48ca70faae2bc4d9f05fc886bb5531a6662172f41484a84", + "size": 159465, + "subdir": "linux-64", + "timestamp": 1530733464142, + "version": "1.23" + }, + "urllib3-1.24-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3fc23077f2dd82da11c4dff385262f4f", + "name": "urllib3", + "sha256": "b9532c6ad3c0df083675af8ece321e2a914bfda0c4979238094ae0ba943efb48", + "size": 158661, + "subdir": "linux-64", + "timestamp": 1540237904038, + "version": "1.24" + }, + "urllib3-1.24-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f12b411f02d9009fd3fff0edc8bcee35", + "name": "urllib3", + "sha256": "cc420125e1bed42060fe8ea6670b5a2ab46a9bf562f84c9bbb3cd7554779ed18", + "size": 159353, + "subdir": "linux-64", + "timestamp": 1540237945370, + "version": "1.24" + }, + "urllib3-1.24-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "482a56becddba30f390394e1c8361fbf", + "name": "urllib3", + "sha256": "544961f9b6cb307895a5ee3d65799783aef84d60dde196408a4d6b8b00cc9210", + "size": 156501, + "subdir": "linux-64", + "timestamp": 1540237923889, + "version": "1.24" + }, + "urllib3-1.24-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d2f6757e9bc75c64d1308d7de9ee748e", + "name": "urllib3", + "sha256": "1009784b6f929270ce4102a7919d878af0a3531238c34ad1882b4218b6656951", + "size": 164369, + "subdir": "linux-64", + "timestamp": 1582215534615, + "version": "1.24" + }, + "urllib3-1.24.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5b747e17aea99e600348f4f40f17bc25", + "name": "urllib3", + "sha256": "2c84a9c604513ea27869cadc6a3cce628c615eaf57e8d9064289aeccb79fa109", + "size": 156384, + "subdir": "linux-64", + "timestamp": 1541444088500, + "version": "1.24.1" + }, + "urllib3-1.24.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "23debcef7ac1b95caf4865faaabddc2e", + "name": "urllib3", + "sha256": "5590553ddb4cf5bc4491f36880cf9ed1263d38942b9c0475578f43b3ee235913", + "size": 156467, + "subdir": "linux-64", + "timestamp": 1541444125949, + "version": "1.24.1" + }, + "urllib3-1.24.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2294863a277decef0b7d77db1237a96", + "name": "urllib3", + "sha256": "7a7a1962fd956bf007b98a0d0ddb86b56999296240d628ee06a7de29ff3f92d3", + "size": 156602, + "subdir": "linux-64", + "timestamp": 1541444054071, + "version": "1.24.1" + }, + "urllib3-1.24.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3088d176e3228758c47253347d02195c", + "name": "urllib3", + "sha256": "e8156a7136b8d9eee3dcbf0dd94683c83edbd36631c39ea3c047ebdd47bd6c73", + "size": 161817, + "subdir": "linux-64", + "timestamp": 1556288033688, + "version": "1.24.2" + }, + "urllib3-1.24.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e783e3cc37d0cb9bf07c0cf1f02ec717", + "name": "urllib3", + "sha256": "3556b016fdf350c27ec4eb461a8ef84d638065b020d00663e90a40a28f29be0c", + "size": 159510, + "subdir": "linux-64", + "timestamp": 1556288170380, + "version": "1.24.2" + }, + "urllib3-1.24.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ecff3c4932a8c74b9a86ed6cdf7b1d38", + "name": "urllib3", + "sha256": "1fa05b082e32454c8c0a0d890d5f886af551b19611d01b24478b63cade205d33", + "size": 162368, + "subdir": "linux-64", + "timestamp": 1556288088820, + "version": "1.24.2" + }, + "urllib3-1.24.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "daebee01f969c5b505010865d6b66c84", + "name": "urllib3", + "sha256": "673a79a7e3cdfc9d3e96502ddc24e024f10d1b093dad63173bc1cdf6f0fa86b5", + "size": 164524, + "subdir": "linux-64", + "timestamp": 1582210947517, + "version": "1.24.3" + }, + "urllib3-1.24.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ad330def0686b6813cdca49a5dca8caa", + "name": "urllib3", + "sha256": "444f43a49542fbf456b77e1894dbef0cdad02e58381e2b7bc2f332786ea80c76", + "size": 164444, + "subdir": "linux-64", + "timestamp": 1582210959892, + "version": "1.24.3" + }, + "urllib3-1.24.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "570531c0dff804bd6adb6fa2d14afb85", + "name": "urllib3", + "sha256": "d9dc1c5e807ae33506f5ce485a03256027aad173585bcbc6473e51c2d8953fa2", + "size": 162186, + "subdir": "linux-64", + "timestamp": 1582210988072, + "version": "1.24.3" + }, + "urllib3-1.25-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3aab263a8a30305dca44f2dbeded37ca", + "name": "urllib3", + "sha256": "cf2042e01c218996feac7d2d68451758bfc1ba060ead08c8ba4d22401d74f32a", + "size": 198290, + "subdir": "linux-64", + "timestamp": 1555953833087, + "version": "1.25" + }, + "urllib3-1.25-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa49ca866eec335826fbe56aff83161f", + "name": "urllib3", + "sha256": "5db916bfc193cf43a42f9161a657727180a2d4169d530777bf1bf2526798fb4c", + "size": 196401, + "subdir": "linux-64", + "timestamp": 1555953851231, + "version": "1.25" + }, + "urllib3-1.25-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "33f47bd41ab0f3728ab43a59c74e7bf4", + "name": "urllib3", + "sha256": "430f04419f9f5b6169085500f96e3dc4b7dba157d1070dd013215b3572bffe7d", + "size": 198584, + "subdir": "linux-64", + "timestamp": 1555953671499, + "version": "1.25" + }, + "urllib3-1.25.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3286e5ff27564997c197ef99c7155418", + "name": "urllib3", + "sha256": "f9d46d2999728efc1956e56eec338bc25c078a2a6fcadcbae83e3bc0c496520a", + "size": 199015, + "subdir": "linux-64", + "timestamp": 1556287881980, + "version": "1.25.1" + }, + "urllib3-1.25.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff40c7861a47dc61417e2b31b2c7b76d", + "name": "urllib3", + "sha256": "a5553e14e70409ef2e1d1d92d3162d9abf4d884920ad4d8405fdc78e9068b3d4", + "size": 195806, + "subdir": "linux-64", + "timestamp": 1556287987032, + "version": "1.25.1" + }, + "urllib3-1.25.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5760ca1c2498090a730019c79c8ccad2", + "name": "urllib3", + "sha256": "28a99aea03b51893a19182c4c508b41731244d038c9e1e5f84d269a0120f29ea", + "size": 195795, + "subdir": "linux-64", + "timestamp": 1556287859420, + "version": "1.25.1" + }, + "urllib3-1.25.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aff71f01bda9d34186e18a2ff3e94422", + "name": "urllib3", + "sha256": "9fcd4193193df611af2f476853a1946af8a24b57a87e128eaa9bf67e2a6570c2", + "size": 198353, + "subdir": "linux-64", + "timestamp": 1556551854545, + "version": "1.25.2" + }, + "urllib3-1.25.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bbf3bee00b4ec4e17954788ac499f762", + "name": "urllib3", + "sha256": "3a8940eb0be3ba0871fc2a88e8c7ac1da2ef07af9ff8d103a5bf09da4cebf94d", + "size": 197057, + "subdir": "linux-64", + "timestamp": 1556551902676, + "version": "1.25.2" + }, + "urllib3-1.25.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f0de7f0082424c8f2413ee6dfe5e3104", + "name": "urllib3", + "sha256": "eff28c8d4ea16ad30c5d3fa2f2069eb15fbc70261433e9c891e1872fbd915398", + "size": 201103, + "subdir": "linux-64", + "timestamp": 1556551867272, + "version": "1.25.2" + }, + "urllib3-1.25.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3b480a1006ac74c296fef5dd456f73b", + "name": "urllib3", + "sha256": "82f94e7a8b30d731815056b390c6e73738d030b7dcf9344bd3b30406190711b3", + "size": 200357, + "subdir": "linux-64", + "timestamp": 1559849607238, + "version": "1.25.3" + }, + "urllib3-1.25.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f45acc790fa09bd3ff3dbf4ea767d46f", + "name": "urllib3", + "sha256": "ae4869488036a108142853ec27d310ee59a4d9b66da6426b491e13c505688707", + "size": 197631, + "subdir": "linux-64", + "timestamp": 1559849739365, + "version": "1.25.3" + }, + "urllib3-1.25.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8bf770ddb30ed9fd4c031bc86c3080a4", + "name": "urllib3", + "sha256": "1f6026e5bcb1e010b8c97480e4624f931506ea9c822f134b7a1ef234cea363b1", + "size": 201366, + "subdir": "linux-64", + "timestamp": 1559849559862, + "version": "1.25.3" + }, + "urllib3-1.25.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6590aed22ed52c5f941acf0e0b3a1f24", + "name": "urllib3", + "sha256": "c151f86afe36a808be18243daa370241c7659028eea898e73acdf9fb6cee1807", + "size": 172574, + "subdir": "linux-64", + "timestamp": 1569267080047, + "version": "1.25.5" + }, + "urllib3-1.25.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3db789104c9f32b6af7f358f7a24a701", + "name": "urllib3", + "sha256": "edb26d5b6d10c5c829a81cb6505596efb330207ba988a425ac69d945312bf31e", + "size": 173165, + "subdir": "linux-64", + "timestamp": 1569267065363, + "version": "1.25.5" + }, + "urllib3-1.25.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45f534b45bd0a7d7fd2966e1e36cc932", + "name": "urllib3", + "sha256": "b50d12cdb94b12efb0e6b52d96132b3b67d53f70a613ed34a6e99e2882d8b9a4", + "size": 173162, + "subdir": "linux-64", + "timestamp": 1569267101310, + "version": "1.25.5" + }, + "urllib3-1.25.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6c35d85f606e18630753406dd86240c5", + "name": "urllib3", + "sha256": "8c55beeda217c54cc8f872a525e9f46b5ba24712227c980b7bc12ab0a21f8e78", + "size": 172708, + "subdir": "linux-64", + "timestamp": 1569854849356, + "version": "1.25.6" + }, + "urllib3-1.25.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8f5f6ef5bb78e659a289277ff2562d24", + "name": "urllib3", + "sha256": "4538a0f8d163b896e391bbe31e1a6d28269f88f208664dc879c82c5f4bf0cf69", + "size": 173240, + "subdir": "linux-64", + "timestamp": 1569854855037, + "version": "1.25.6" + }, + "urllib3-1.25.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ecf93e52df108d0763375d88f5f8dc6", + "name": "urllib3", + "sha256": "509cf2da1d45da572e2deafbe7447ac654d8918b2329c90bf3cfc7f9b597257f", + "size": 173310, + "subdir": "linux-64", + "timestamp": 1569854845118, + "version": "1.25.6" + }, + "urllib3-1.25.6-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "acbfd5d43b4ad92b02e4608bf3657f44", + "name": "urllib3", + "sha256": "b2dc4e2e5311474afba236e39e5fd13cea6b40093eb697370e21edf1b4b81ef5", + "size": 170416, + "subdir": "linux-64", + "timestamp": 1574087112631, + "version": "1.25.6" + }, + "urllib3-1.25.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "ipaddress", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ac13e69fe15420124097bf8fe626c7e0", + "name": "urllib3", + "sha256": "8da3a5699f32145a2d245ad34c0612231ff91f279001f19cc7e0bb0c8655be46", + "size": 172790, + "subdir": "linux-64", + "timestamp": 1573943470523, + "version": "1.25.7" + }, + "urllib3-1.25.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bd3c7f085b68132eea89e5b86edea7da", + "name": "urllib3", + "sha256": "cd7b4cfb92e94f95b7e384e84bebaad07a509e25322fd24363de9f874b4dc8fb", + "size": 173301, + "subdir": "linux-64", + "timestamp": 1573943497288, + "version": "1.25.7" + }, + "urllib3-1.25.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16043291a791c7af90a5959cecff852e", + "name": "urllib3", + "sha256": "5e8a4d2c55602294f482f81f1b4cd87e7a40669924de45f57be72d0c1c6a0dbd", + "size": 173337, + "subdir": "linux-64", + "timestamp": 1573943456191, + "version": "1.25.7" + }, + "urllib3-1.25.7-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "67317964b967789195331c5a242362d4", + "name": "urllib3", + "sha256": "275e30f748eaed6fc0d7a1b1d2d06aee3b452fa48fd48eea282c478c332b7249", + "size": 170132, + "subdir": "linux-64", + "timestamp": 1574177601901, + "version": "1.25.7" + }, + "urllib3-1.25.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0484f5c636ac1ef6ab87a8371b5dd40b", + "name": "urllib3", + "sha256": "85357737a6753b02baa594db824ec34dd2da161c10708d1faec1335725e72eef", + "size": 173127, + "subdir": "linux-64", + "timestamp": 1580152465218, + "version": "1.25.8" + }, + "urllib3-1.25.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dd2ef8e9cc3b7f632374afe1767f7068", + "name": "urllib3", + "sha256": "be66029e59fd4c54aaf0bc1a79faa59f6cc35c1e9e2e07db73f25350531b5b5a", + "size": 173269, + "subdir": "linux-64", + "timestamp": 1580152499572, + "version": "1.25.8" + }, + "urllib3-1.25.8-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ff3d2233f1a07a6c07825c60efd453fa", + "name": "urllib3", + "sha256": "931b8e0fbe62a2c2bfa1ae52e3e6f48883e50b8eea66d83b2b74db0433ca6ace", + "size": 174026, + "subdir": "linux-64", + "timestamp": 1580152471177, + "version": "1.25.8" + }, + "urllib3-1.26.11-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b46191afe3480f336bfa2749810e417b", + "name": "urllib3", + "sha256": "aaf72e84be96e24076545634f102c9dd9a190e6a4aaa198fd92e3a6b6c9d946a", + "size": 187750, + "subdir": "linux-64", + "timestamp": 1659110581155, + "version": "1.26.11" + }, + "urllib3-1.26.11-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8e112cc91e2a1e5b1bc58ecf1127ca12", + "name": "urllib3", + "sha256": "b1893244f8a3034b4f60ca3ac6d8ad51bbd39af17bcfc736e9a107db52027bb7", + "size": 185840, + "subdir": "linux-64", + "timestamp": 1659110497654, + "version": "1.26.11" + }, + "urllib3-1.26.11-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b16ef1a57c169d8211e058e91debb20f", + "name": "urllib3", + "sha256": "697ded1822d9cda5f5b0f75598bc11e96badb24fef6aea3b1aca57b393012f22", + "size": 186261, + "subdir": "linux-64", + "timestamp": 1659110531581, + "version": "1.26.11" + }, + "urllib3-1.26.11-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d4aae61f46f56e42549c9721a9434a35", + "name": "urllib3", + "sha256": "1a7dda4ec5ec692c74554d71717046fcfd2caebd3fc93932e05a56637497f2c9", + "size": 186396, + "subdir": "linux-64", + "timestamp": 1659110615111, + "version": "1.26.11" + }, + "urllib3-1.26.12-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a95fe5ee93bbb66f9040d70be0daf36", + "name": "urllib3", + "sha256": "98eef2c2fc04ba72f87b4673bcb7d36f3b741947e6ed3ec180278acfcaff0177", + "size": 187442, + "subdir": "linux-64", + "timestamp": 1666299028295, + "version": "1.26.12" + }, + "urllib3-1.26.12-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "80cbf014853f8260fedb33b362f1013b", + "name": "urllib3", + "sha256": "a96886aff860f4d812e49b704b8a8054fa307f53e92d57089d674bd6936d8c50", + "size": 237661, + "subdir": "linux-64", + "timestamp": 1676822756847, + "version": "1.26.12" + }, + "urllib3-1.26.12-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b65a4d095b56fefb1a0dc8308c837817", + "name": "urllib3", + "sha256": "448c0826fd524240f228be14a8947823bf2dc0c9247cab8733f42561a767667a", + "size": 184909, + "subdir": "linux-64", + "timestamp": 1666299000763, + "version": "1.26.12" + }, + "urllib3-1.26.12-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa9ea62db989b3ba169a82c695eea20c", + "name": "urllib3", + "sha256": "baefd095f1c329079a149782277cb3103322c6573ec5ed7747355e0f29fc0211", + "size": 185869, + "subdir": "linux-64", + "timestamp": 1666299055257, + "version": "1.26.12" + }, + "urllib3-1.26.12-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "93c50f20fc6c5465cb3bf7de94315910", + "name": "urllib3", + "sha256": "1df3a8da4a3a44c5b6f85a478997ea4028aa6bb75bfa969627eb65a07b115067", + "size": 185744, + "subdir": "linux-64", + "timestamp": 1666298972427, + "version": "1.26.12" + }, + "urllib3-1.26.13-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01a21b6deb69cf39894c174790c3264f", + "name": "urllib3", + "sha256": "d2a7f8a95d770cc8888ff37e605ea2cc0a984e56f5426f360c98686f3e70c7b6", + "size": 198231, + "subdir": "linux-64", + "timestamp": 1670527071091, + "version": "1.26.13" + }, + "urllib3-1.26.13-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c2e20095e0bfdc73226b15415ecc4127", + "name": "urllib3", + "sha256": "458a48b122507f5e60f7d45ef1d5f70aa2edd9abe192de86eb9ff204ec1789d3", + "size": 195756, + "subdir": "linux-64", + "timestamp": 1670527018168, + "version": "1.26.13" + }, + "urllib3-1.26.13-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "74608767d976ca14529b126842ffb685", + "name": "urllib3", + "sha256": "46e9c14ae904467f952e020747420624bcdd6ee8c045273b25045265ffc9ef13", + "size": 196766, + "subdir": "linux-64", + "timestamp": 1670527044373, + "version": "1.26.13" + }, + "urllib3-1.26.13-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5028912afd81b82cb7f70bbb45ce873b", + "name": "urllib3", + "sha256": "ee74d7b35dd44a77d2a255c50254506d361a529e07aee0e49b9ba5466ebce487", + "size": 197253, + "subdir": "linux-64", + "timestamp": 1670527097306, + "version": "1.26.13" + }, + "urllib3-1.26.14-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e0b4cfc539954199295eda612157b195", + "name": "urllib3", + "sha256": "70b10830fec6598fb792751b21826a5f52fb0500b6e2a301ae0f23c39f63b1c2", + "size": 201984, + "subdir": "linux-64", + "timestamp": 1673575614211, + "version": "1.26.14" + }, + "urllib3-1.26.14-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cdaf74fa5fd5a72e563f0025ba75ac2c", + "name": "urllib3", + "sha256": "58649ce27cd7869e1c676555b4c3d5d5ee15a9bd686afe9d393b62212c610f53", + "size": 238891, + "subdir": "linux-64", + "timestamp": 1679339426051, + "version": "1.26.14" + }, + "urllib3-1.26.14-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a57bc0a0251a8cba390ab27ec8761ff", + "name": "urllib3", + "sha256": "26cfdc227b7d28a9959b385adc19d5d8ab73cfb29c6cc393e43c152acdd53653", + "size": 199526, + "subdir": "linux-64", + "timestamp": 1673575559595, + "version": "1.26.14" + }, + "urllib3-1.26.14-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c84afcc85e999af5ef824aae356cce6a", + "name": "urllib3", + "sha256": "d0fc12a5d80b87c4e892d2b4e6f02a94bc4fe4b88e52e4a46ddc3b04ad6b073d", + "size": 200623, + "subdir": "linux-64", + "timestamp": 1673575532097, + "version": "1.26.14" + }, + "urllib3-1.26.14-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db9c2b56e835ae5ba800e8821c37b27c", + "name": "urllib3", + "sha256": "2a6be0afb57861bab0133faef7dc15f014cc6cea6685e679cf4f93a684cc2aa2", + "size": 200718, + "subdir": "linux-64", + "timestamp": 1673575587015, + "version": "1.26.14" + }, + "urllib3-1.26.15-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aad0b565c885581b428dc8879888402e", + "name": "urllib3", + "sha256": "99f894ab30924d5713fd28708a0ee61259d010a0d0f4e4317db33e26f6888590", + "size": 203528, + "subdir": "linux-64", + "timestamp": 1680254765346, + "version": "1.26.15" + }, + "urllib3-1.26.15-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f821fb72b92d3665851ebee1c782332c", + "name": "urllib3", + "sha256": "2fa5cd5ade86daf4641e4254276ae40d7a49f496f1ee870d3523d2b670a19b5f", + "size": 257898, + "subdir": "linux-64", + "timestamp": 1680254738571, + "version": "1.26.15" + }, + "urllib3-1.26.15-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1be572d70b13371977446e6554e7279f", + "name": "urllib3", + "sha256": "49cf53b4894e17d9af50c69b3c934a79a279373bce15e211aecfed1bd2e10363", + "size": 201741, + "subdir": "linux-64", + "timestamp": 1680254711775, + "version": "1.26.15" + }, + "urllib3-1.26.15-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "576d89f85c41e387a3128b52ffe90c98", + "name": "urllib3", + "sha256": "1f3f0215f5dbb17daa5ec689f860f99832a0484b6967a34b8bf987ebd1e945f7", + "size": 201870, + "subdir": "linux-64", + "timestamp": 1680254790803, + "version": "1.26.15" + }, + "urllib3-1.26.9-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6af128681921aa627443fa84724bc25", + "name": "urllib3", + "sha256": "513fedb41d0a391ff157359a0dace8473ed8260a7c19d5c90f256ad95f537177", + "size": 185607, + "subdir": "linux-64", + "timestamp": 1650637255477, + "version": "1.26.9" + }, + "urllib3-1.26.9-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "96e33947c45c5e7181dff69ece8ae224", + "name": "urllib3", + "sha256": "c3f8a6bec6db82e42f586360875852235b2237a2f9040838804d9219c115253c", + "size": 184083, + "subdir": "linux-64", + "timestamp": 1650640030149, + "version": "1.26.9" + }, + "urllib3-1.26.9-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "40c1c6f5e634ec77344a822ab3aa84cc", + "name": "urllib3", + "sha256": "54ba00bf64aa83bcf6386b90b74bc066cb409c4a5a0a1b69bdaf01e6c9fbfa81", + "size": 184458, + "subdir": "linux-64", + "timestamp": 1650640056618, + "version": "1.26.9" + }, + "urllib3-1.26.9-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "brotlipy >=0.6.0", + "certifi", + "cryptography >=1.3.4", + "idna >=2.0.0", + "pyopenssl >=0.14", + "pysocks >=1.5.6,<2.0,!=1.5.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6bee003f57c585c80e1a0d591f06e364", + "name": "urllib3", + "sha256": "2ee704a9b53bf6d7b13a03306abfcfd66414f46812491b23d73b179cb2f14b79", + "size": 184658, + "subdir": "linux-64", + "timestamp": 1650640102349, + "version": "1.26.9" + }, + "urwid-2.1.1-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "LGPL-2.1", + "md5": "e6db33441731d1f17bfafdb8d4d3c390", + "name": "urwid", + "sha256": "ee68103a280dc767ceb959e347baca83e761c5e3d3c1da9a2c18909b9ec4d6b9", + "size": 379028, + "subdir": "linux-64", + "timestamp": 1640795668512, + "version": "2.1.1" + }, + "urwid-2.1.1-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "LGPL-2.1", + "md5": "d761e3c614e345cec6de41a8ce37fe32", + "name": "urwid", + "sha256": "3af5efb1111de4cdca83c17093dcc159eecfd1d57fece1a380899cc9e7a539b8", + "size": 484336, + "subdir": "linux-64", + "timestamp": 1676846143163, + "version": "2.1.1" + }, + "urwid-2.1.1-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "c57ee3cb8ffc0712c17784027811667b", + "name": "urwid", + "sha256": "1863912010506f12eb2d2bef646db13be932644f585775ca9158a3fd113a5bd5", + "size": 369682, + "subdir": "linux-64", + "timestamp": 1613482241046, + "version": "2.1.1" + }, + "urwid-2.1.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "e77b02dbc9ddd92932e71fcddb56522f", + "name": "urwid", + "sha256": "50b2fe05a39d7b1edbbbd0332abc2b6d6559bc09e114f51aa636683cdfc75520", + "size": 369662, + "subdir": "linux-64", + "timestamp": 1598660950208, + "version": "2.1.1" + }, + "urwid-2.1.1-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1", + "md5": "6dafaa7d1c4ab225a637246737a6dece", + "name": "urwid", + "sha256": "694a0f4faa0b50939f07a501404490743440a0dff62dfb534639fd7c6607f7ce", + "size": 367266, + "subdir": "linux-64", + "timestamp": 1613482857346, + "version": "2.1.1" + }, + "urwid-2.1.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1", + "md5": "4be42828dc69210461e0922ec0369e75", + "name": "urwid", + "sha256": "84ecadba5e3d226669f11f5c47a23b68e32dd6f9df1b96312ce01e88a35f16bd", + "size": 362812, + "subdir": "linux-64", + "timestamp": 1598660978385, + "version": "2.1.1" + }, + "urwid-2.1.1-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1", + "md5": "49526193ca490c76849d52f57ebf25f3", + "name": "urwid", + "sha256": "17e37984ccafb1c2f2278e7b0978211aa4c12c1472dc45ce142faee0153baa31", + "size": 363961, + "subdir": "linux-64", + "timestamp": 1613482730031, + "version": "2.1.1" + }, + "urwid-2.1.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1", + "md5": "bcedf04fbc689cd234275cecc035d84c", + "name": "urwid", + "sha256": "a930759cddfc56cc10fdfa2453244eb5aaed87014de0e39ebbfe497633bd5dcf", + "size": 369704, + "subdir": "linux-64", + "timestamp": 1598660928925, + "version": "2.1.1" + }, + "urwid-2.1.1-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "LGPL-2.1", + "md5": "421128ff8a73e7991cca160ec0e0f8e6", + "name": "urwid", + "sha256": "8cfc7160b3ed778e99db4a6b64e2ff9989af641ca36216c3b89c3a0140eb5c23", + "size": 369067, + "subdir": "linux-64", + "timestamp": 1613482877217, + "version": "2.1.1" + }, + "urwid-2.1.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "LGPL-2.1", + "md5": "6862327319e568de349eb180a4638701", + "name": "urwid", + "sha256": "201d4ac428e10913d56f55fa8ebb28d6cae4f28d17986aa68329e530bfd62451", + "size": 361983, + "subdir": "linux-64", + "timestamp": 1602001160417, + "version": "2.1.2" + }, + "urwid-2.1.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "LGPL-2.1", + "md5": "792110108b152bacdde871f0817c997f", + "name": "urwid", + "sha256": "ea5e59297e1b9c403bf499260628fafb8ff7b6817588f8c8fe41adb482dc9c33", + "size": 360417, + "subdir": "linux-64", + "timestamp": 1602001194232, + "version": "2.1.2" + }, + "urwid-2.1.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "LGPL-2.1", + "md5": "8a965d9b7c487abfa6eaae7bd200b330", + "name": "urwid", + "sha256": "af830fa509d711a9e78da22da307de88f6a90cd5204e11315a19a3a97dd0ff8e", + "size": 367909, + "subdir": "linux-64", + "timestamp": 1602001172223, + "version": "2.1.2" + }, + "utf8proc-2.6.1-h27cfd23_0.conda": { + "build": "h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb0368d9f93a2b1541d0d3fc265362d2", + "name": "utf8proc", + "sha256": "c10baf92a00a632813bb28f1812e5e547374a400f93d45301b917747c5ddf307", + "size": 315109, + "subdir": "linux-64", + "timestamp": 1611836033971, + "version": "2.6.1" + }, + "utfcpp-3.2.1-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [], + "license": "BSL-1.0", + "md5": "ff5ccee53e431874a44021919041cef7", + "name": "utfcpp", + "sha256": "ec3784b72774f5d21f9468e76da8b55381e2fd48a7ba70ae4a3f9d2057478a3d", + "size": 13095, + "subdir": "linux-64", + "timestamp": 1635955308136, + "version": "3.2.1" + }, + "uvicorn-0.16.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.4.0", + "click >=7.*", + "h11 >=0.8", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a1d6589cdf73b4331ec458ef69ebef04", + "name": "uvicorn", + "sha256": "58e8b1d06fe660b5511b3aa3f245adb262fe950cbdcd386414d251825d03054d", + "size": 83623, + "subdir": "linux-64", + "timestamp": 1641600767726, + "version": "0.16.0" + }, + "uvicorn-0.16.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "asgiref >=3.4.0", + "click >=7.*", + "h11 >=0.8", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "25152c2e314c452a417eae95a6ab65fc", + "name": "uvicorn", + "sha256": "28edc2ad88c749c54376287e5bdce7947cded096e2ebcbcb1c37979315141a2e", + "size": 83591, + "subdir": "linux-64", + "timestamp": 1641600745545, + "version": "0.16.0" + }, + "uvicorn-0.20.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.*", + "h11 >=0.8", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "44decf9fc9d0b12c27f29e0de6517702", + "name": "uvicorn", + "sha256": "36f03491ec8ce7c3da2108f6c630adfed1073a97908060bb917aad6b115c282c", + "size": 94260, + "subdir": "linux-64", + "timestamp": 1678090210576, + "version": "0.20.0" + }, + "uvicorn-0.20.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.*", + "h11 >=0.8", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f489df26d60b1517031d2eab72b9ef87", + "name": "uvicorn", + "sha256": "6a2badb999f46635b187dc627d552c87b00aee346a2dc71635ad6c1232e83c23", + "size": 119108, + "subdir": "linux-64", + "timestamp": 1679340496599, + "version": "0.20.0" + }, + "uvicorn-0.20.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.*", + "h11 >=0.8", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f03ad7734825611248fd90c30bccf575", + "name": "uvicorn", + "sha256": "728fe01e50e2413e0ccdb6400117e033123f9e34d7153db4bfc08875e82cb783", + "size": 92447, + "subdir": "linux-64", + "timestamp": 1678090168148, + "version": "0.20.0" + }, + "uvicorn-0.20.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "click >=7.*", + "h11 >=0.8", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a5df5955c9314b03d0bd98e7c3fe4cb", + "name": "uvicorn", + "sha256": "d343f13d83ddb283cd247a73bb35d7841bc0663753a2e1255ad07bf0e8126002", + "size": 92385, + "subdir": "linux-64", + "timestamp": 1678090115817, + "version": "0.20.0" + }, + "uvicorn-standard-0.20.0-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "httptools >=0.5.0", + "python-dotenv >=0.13", + "pyyaml >=5.1", + "uvicorn 0.20.0 py39h06a4308_0", + "uvloop >=0.14.0,!=0.15.0,!=0.15.1", + "watchfiles >=0.13", + "websockets >=10.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "918679ed0a6397cfccaa9d53625a1854", + "name": "uvicorn-standard", + "sha256": "d339f1ce2a7fb8d591db67a14d8972f2aac5fa65a09986112a1a446ec99156c6", + "size": 5434, + "subdir": "linux-64", + "timestamp": 1678090123235, + "version": "0.20.0" + }, + "uvloop-0.10.1-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "be957f471ea3ef944334d2092cb34b41", + "name": "uvloop", + "sha256": "316b85a3a19f0c2980080cd1de407564578696a2bde908a3a6e793c14c42f4b3", + "size": 1196535, + "subdir": "linux-64", + "timestamp": 1528143611597, + "version": "0.10.1" + }, + "uvloop-0.10.1-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "0c00f611addf0c34925db4fb73ded799", + "name": "uvloop", + "sha256": "fd5eae16d6b34c57bfb4d737111b25c18c9e3051534d1cf12eb86bf07828de21", + "size": 1209917, + "subdir": "linux-64", + "timestamp": 1528143561208, + "version": "0.10.1" + }, + "uvloop-0.10.1-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4ff9311b8ef23ba880245990e787c9a8", + "name": "uvloop", + "sha256": "12fb86a80ea8425b9e68dcbb4620f4bccea041a05ad4ed5204f82450ad157c20", + "size": 1208115, + "subdir": "linux-64", + "timestamp": 1531060556688, + "version": "0.10.1" + }, + "uvloop-0.11.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "91d6e92c02220857f6910eda9c0aa3bc", + "name": "uvloop", + "sha256": "65e3b394b46a21bce706ff95e4b708713c156aca460135ef785a1aa7e3525226", + "size": 1222994, + "subdir": "linux-64", + "timestamp": 1532800468523, + "version": "0.11.0" + }, + "uvloop-0.11.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "9f681a194171f228dc0f915060ca7eb3", + "name": "uvloop", + "sha256": "32e5f0f7b77315c8186752777a8bdb1b3d27a77780dccab76b1eaa8cd2b28248", + "size": 1238078, + "subdir": "linux-64", + "timestamp": 1532800425940, + "version": "0.11.0" + }, + "uvloop-0.11.0-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "4fd240bc9f31d1c96adb1145ef8c932b", + "name": "uvloop", + "sha256": "7befc3e0862448bff77a1ecc28546b32f8f2de1a9b72a547f0963218b15a9b4d", + "size": 1234883, + "subdir": "linux-64", + "timestamp": 1532800455666, + "version": "0.11.0" + }, + "uvloop-0.11.2-py35h7b6447c_0.conda": { + "build": "py35h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "e0ecc8dfc6d730e59da43f79bbdcf4d1", + "name": "uvloop", + "sha256": "4b6905a4643158054668a6d5da2955c13c34108cd54643674a4b7d5473c716a7", + "size": 1221921, + "subdir": "linux-64", + "timestamp": 1535669443141, + "version": "0.11.2" + }, + "uvloop-0.11.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "77ee99604288310aa4a3bdb8df00616f", + "name": "uvloop", + "sha256": "36a95a0376ffcb2280ecdb6e8b1aead632c719ebf2e732626dae59004a3646c6", + "size": 1247398, + "subdir": "linux-64", + "timestamp": 1535669392508, + "version": "0.11.2" + }, + "uvloop-0.11.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "f0f6b4f8c39b0366773a75121c975230", + "name": "uvloop", + "sha256": "193614c96da027f0e9ed7d4407792258279c11790459fe2353c1b5621db40acf", + "size": 1244145, + "subdir": "linux-64", + "timestamp": 1535669470838, + "version": "0.11.2" + }, + "uvloop-0.11.3-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "213c0758eeba7c88812314b5a930b289", + "name": "uvloop", + "sha256": "8e3881a61b06e64e2a2e72d3ee45d28e1bcce7b58fc62e99d893301608fc4609", + "size": 1259269, + "subdir": "linux-64", + "timestamp": 1545120067487, + "version": "0.11.3" + }, + "uvloop-0.11.3-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "976129373909c214a8aa51562f92fd2c", + "name": "uvloop", + "sha256": "22c7a13a44b62345de3c7124c1109ed2d0e0b79e85213850a3332bc22d9c1643", + "size": 1255952, + "subdir": "linux-64", + "timestamp": 1545120066315, + "version": "0.11.3" + }, + "uvloop-0.12.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "82971972cc89b9e5c4baa5594bd780c3", + "name": "uvloop", + "sha256": "ce0b2830d0ade047add2da1e029ac5732a0439b94aea55d14f627a91053c301b", + "size": 1208480, + "subdir": "linux-64", + "timestamp": 1552371957141, + "version": "0.12.1" + }, + "uvloop-0.12.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "d7a67a6db1525152273b915a5e1646c3", + "name": "uvloop", + "sha256": "94df21ce57767d3b3d89b79651b9af54d97c78b92837ca4cc749d2e2912bd5c6", + "size": 1202317, + "subdir": "linux-64", + "timestamp": 1552371955909, + "version": "0.12.1" + }, + "uvloop-0.12.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "f379053b0e44de5e381608d54a877de2", + "name": "uvloop", + "sha256": "ba7043626c8c92aa313d88110ec0efbe686c0fec9570fb4581aa76de9866089d", + "size": 1207124, + "subdir": "linux-64", + "timestamp": 1556078222108, + "version": "0.12.2" + }, + "uvloop-0.12.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "740504bbdb4cc5901b80df4200cd27e1", + "name": "uvloop", + "sha256": "b6418d981ec415b3b35dc63e8c647e61408cf6536ef955b92f14fb91272f999c", + "size": 1200421, + "subdir": "linux-64", + "timestamp": 1556078271285, + "version": "0.12.2" + }, + "uvloop-0.12.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "359159e046dff7dacc94568d7970f397", + "name": "uvloop", + "sha256": "0666b3a44aa8121ff1d29ce65fd0f007c9e9b2203e6fed5d10e3041689473ae5", + "size": 1258899, + "subdir": "linux-64", + "timestamp": 1573200644873, + "version": "0.12.2" + }, + "uvloop-0.14.0-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "2929f92bd4ad3be323f849ec131d77d1", + "name": "uvloop", + "sha256": "ef8704bd521212acadbdfb8d4bde1e121d7bc9ab99340dde26dc522f023a70e3", + "size": 1174480, + "subdir": "linux-64", + "timestamp": 1613405881970, + "version": "0.14.0" + }, + "uvloop-0.14.0-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "5d33f8d8afd2a50683249545cc528302", + "name": "uvloop", + "sha256": "f09d63cb07d0aaeea41f246681e1092230c00b5bf55b547dab5a7319056fd46b", + "size": 1253977, + "subdir": "linux-64", + "timestamp": 1587391850496, + "version": "0.14.0" + }, + "uvloop-0.14.0-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "dbdcc1e2be348a2ef0c3080fc5c187bb", + "name": "uvloop", + "sha256": "aab449228340b401eae997926beac22334b9feb21eff1a3b1774a8212cd80e69", + "size": 1163179, + "subdir": "linux-64", + "timestamp": 1613405810527, + "version": "0.14.0" + }, + "uvloop-0.14.0-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "55a7b6d53a86b30bb9beaf99b2e7786c", + "name": "uvloop", + "sha256": "6e22eea9618339082485cfbd978029e9266d4d56a1db051d42a9fa1619f1c14d", + "size": 1248146, + "subdir": "linux-64", + "timestamp": 1587391756105, + "version": "0.14.0" + }, + "uvloop-0.14.0-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "455ac5dc1b891786b154496a908c73d9", + "name": "uvloop", + "sha256": "e0c40bae66795d0edf7fbe208e90ec8ba3e56c2aad71802374d998749d377b0f", + "size": 1217471, + "subdir": "linux-64", + "timestamp": 1613405276742, + "version": "0.14.0" + }, + "uvloop-0.14.0-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "0591ba0cb5d4035f6737524d29ab8b38", + "name": "uvloop", + "sha256": "93a626137c7a2eebb56967f33d6d34201f0f898a8cf99d421ea8b71b456ddef8", + "size": 1296116, + "subdir": "linux-64", + "timestamp": 1587391872222, + "version": "0.14.0" + }, + "uvloop-0.14.0-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "f24c4568dacb629582fa26a35c0d944e", + "name": "uvloop", + "sha256": "eee11c96fb5dc10cc7f0cb49dd93a23974c85989a67a44a7f3cd21e6a7729abb", + "size": 1214027, + "subdir": "linux-64", + "timestamp": 1613405873133, + "version": "0.14.0" + }, + "uvloop-0.15.2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT OR Apache-2.0", + "md5": "b74479f696cc316f835185f4911fc428", + "name": "uvloop", + "sha256": "bdeb37c02d6dd887de8d154e0e17cd95b5d0a27029b585b10ddb33ba134800c6", + "size": 946219, + "subdir": "linux-64", + "timestamp": 1615407877861, + "version": "0.15.2" + }, + "uvloop-0.15.2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT OR Apache-2.0", + "md5": "a7a3b2d9a5bdfcaf95578edc844ed19a", + "name": "uvloop", + "sha256": "606ebd6d8e1ab4752fc56d9de59574bd3e3e363092e7de812324693af19e724e", + "size": 997425, + "subdir": "linux-64", + "timestamp": 1615408131915, + "version": "0.15.2" + }, + "uvloop-0.15.2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT OR Apache-2.0", + "md5": "e6bfbc07fdcfe4490c8db574f622fd7d", + "name": "uvloop", + "sha256": "93fc7feb4f0fe93099912e31484dcd2df3b9147ed8aea94e9294892c9a2b96b9", + "size": 995478, + "subdir": "linux-64", + "timestamp": 1615408116776, + "version": "0.15.2" + }, + "uvloop-0.16.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT OR Apache-2.0", + "md5": "111d3ad75aa4717347721d996bcf923d", + "name": "uvloop", + "sha256": "704cb8439149824ed6a9aeaf189bc2c3bef09662f449114ba0df3bb52ffada81", + "size": 2520116, + "subdir": "linux-64", + "timestamp": 1640795729159, + "version": "0.16.0" + }, + "uvloop-0.16.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT OR Apache-2.0", + "md5": "2ab67b423e78d6763f2076839a4ca617", + "name": "uvloop", + "sha256": "e9c0a7c243bf13f73deefeb24e3e9e06b9a57dced22e23ad863e012e58820174", + "size": 970024, + "subdir": "linux-64", + "timestamp": 1676863451743, + "version": "0.16.0" + }, + "uvloop-0.16.0-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT OR Apache-2.0", + "md5": "128eb5a12b7103a8d966f5b3bdcbc667", + "name": "uvloop", + "sha256": "1f187919dedf8144dd21dcd9530aae22c2c7a352266019f572fe3b38ae1eed9f", + "size": 946239, + "subdir": "linux-64", + "timestamp": 1639503251088, + "version": "0.16.0" + }, + "uvloop-0.16.0-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT OR Apache-2.0", + "md5": "78fce23eb168e04d9f8cd5917615fe38", + "name": "uvloop", + "sha256": "51ea591c8ee8f2e81b7bd915e347d6c90a44669f2a93a9d07c2b37cc5a210fab", + "size": 999343, + "subdir": "linux-64", + "timestamp": 1639489489218, + "version": "0.16.0" + }, + "uvloop-0.16.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libuv >=1.40.0,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT OR Apache-2.0", + "md5": "af9479fe137a97720409c9847f9afbd1", + "name": "uvloop", + "sha256": "34af223b8e7034335eb174b8639cc70c5f37ecc5bb5f640ae345f1ca9022eef6", + "size": 997288, + "subdir": "linux-64", + "timestamp": 1639503243172, + "version": "0.16.0" + }, + "uvloop-0.17.0-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libuv >=1.44.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT OR Apache-2.0", + "license_family": "Other", + "md5": "18d8cdf2a272ebd6d1af632ecae5a532", + "name": "uvloop", + "sha256": "8edd518d0801485cddece526c90e36e9351a114ba6896210f36502d25e39e6b4", + "size": 1134123, + "subdir": "linux-64", + "timestamp": 1677843314473, + "version": "0.17.0" + }, + "uvloop-0.17.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libuv >=1.44.2,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT OR Apache-2.0", + "license_family": "Other", + "md5": "1b623d8abcd855a90fc4229dee866d0f", + "name": "uvloop", + "sha256": "d55ebb89d61da3ddc1e014e69390a18b651dab8866434562c900813b6d2e8ddb", + "size": 985399, + "subdir": "linux-64", + "timestamp": 1679339485880, + "version": "0.17.0" + }, + "uvloop-0.17.0-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libuv >=1.44.2,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT OR Apache-2.0", + "license_family": "Other", + "md5": "e964397889df1f621f89f46f78288b57", + "name": "uvloop", + "sha256": "29021441d6da7ed9350c5134b179dff71a93918778aea7920773b199c04f58dd", + "size": 1170581, + "subdir": "linux-64", + "timestamp": 1677843441566, + "version": "0.17.0" + }, + "uvloop-0.17.0-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libuv >=1.44.2,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT OR Apache-2.0", + "license_family": "Other", + "md5": "07f42b3f98318fb824559d41138bd477", + "name": "uvloop", + "sha256": "3a2631bdc97cb816efa2ca42e774045abf13826e12e3180a94f08fdbac9a455f", + "size": 1147909, + "subdir": "linux-64", + "timestamp": 1677843375918, + "version": "0.17.0" + }, + "uvloop-0.8.1-py35hc45d62f_0.conda": { + "build": "py35hc45d62f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "4df18a232aaced6f663c851f5beeecff", + "name": "uvloop", + "sha256": "1f3fb65d622fcf64538dbf54cd2f4959a998b51ceb004081f7e8269f2d7dc8bd", + "size": 1026171, + "subdir": "linux-64", + "timestamp": 1507236315111, + "version": "0.8.1" + }, + "uvloop-0.8.1-py36h7036845_0.conda": { + "build": "py36h7036845_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "dac924af02ee56526945ec52d532c7a1", + "name": "uvloop", + "sha256": "055c033cb529cc08ea58eeb6f30dd2a32cb757d83b41f05658d66fc4f167856f", + "size": 1041781, + "subdir": "linux-64", + "timestamp": 1507236312039, + "version": "0.8.1" + }, + "uvloop-0.9.1-py35h9cf2f49_0.conda": { + "build": "py35h9cf2f49_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "e2b747fb2b33bcba054a1c6f232a7a2b", + "name": "uvloop", + "sha256": "d39d49f86da69ab9a9747adf756bee4baf7323b106248379e92e8fa72c19f5ff", + "size": 1074698, + "subdir": "linux-64", + "timestamp": 1512037457077, + "version": "0.9.1" + }, + "uvloop-0.9.1-py36h0ff8193_0.conda": { + "build": "py36h0ff8193_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "708c6a213a229a56a2fbc27d13fc8326", + "name": "uvloop", + "sha256": "9d0a97c8ce7ab5dd3882da68715c72af5af5d1a9877518537ebf14416be498b2", + "size": 1094503, + "subdir": "linux-64", + "timestamp": 1512037479402, + "version": "0.9.1" + }, + "uwsgi-2.0.21-py310h068a5ad_1.conda": { + "build": "py310h068a5ad_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "jansson >=2.14,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuuid", + "libxml2 >=2.10.3,<2.11.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre >=8.44,<9.0a0", + "python >=3.10,<3.11.0a0", + "xz", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "03d495ccace04deb3fd7cfa01f5e1615", + "name": "uwsgi", + "sha256": "a66bd269b1934746929220986a41e85ea0680d906cf86627d6bcc314d3155bca", + "size": 8311365, + "subdir": "linux-64", + "timestamp": 1679988563394, + "version": "2.0.21" + }, + "uwsgi-2.0.21-py310hb8d2a22_0.conda": { + "build": "py310hb8d2a22_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "jansson >=2.14,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuuid", + "libxml2 >=2.9.14,<2.10.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre >=8.44,<9.0a0", + "python >=3.10,<3.11.0a0", + "xz", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "aaa877abb6d3613f9617638c179a62df", + "name": "uwsgi", + "sha256": "c6f730760268b280db89bd44d2fa0d609abc2aa41dae76f1a30010e55e3217ec", + "size": 8294483, + "subdir": "linux-64", + "timestamp": 1678466501519, + "version": "2.0.21" + }, + "uwsgi-2.0.21-py311h068a5ad_1.conda": { + "build": "py311h068a5ad_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "jansson >=2.14,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuuid", + "libxml2 >=2.10.3,<2.11.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre >=8.44,<9.0a0", + "python >=3.11,<3.12.0a0", + "xz", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "5e4d50173d8af5f5078720950395d7c7", + "name": "uwsgi", + "sha256": "70369a684bd9f77842b06fe8b9b7b6f3fb5ff3649b3ec087d921e1c3816426bc", + "size": 10018605, + "subdir": "linux-64", + "timestamp": 1679988830751, + "version": "2.0.21" + }, + "uwsgi-2.0.21-py311hb8d2a22_0.conda": { + "build": "py311hb8d2a22_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "jansson >=2.14,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuuid", + "libxml2 >=2.9.14,<2.10.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre >=8.44,<9.0a0", + "python >=3.11,<3.12.0a0", + "xz", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "cd8e39ec69c85832cf7a40c5e981d9dd", + "name": "uwsgi", + "sha256": "4eff9e9d670efd3474eaf166b8237ba827223b869d632c4b44cbb7b26a118dc8", + "size": 8822296, + "subdir": "linux-64", + "timestamp": 1679339749338, + "version": "2.0.21" + }, + "uwsgi-2.0.21-py38h068a5ad_1.conda": { + "build": "py38h068a5ad_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "jansson >=2.14,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuuid", + "libxml2 >=2.10.3,<2.11.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre >=8.44,<9.0a0", + "python >=3.8,<3.9.0a0", + "xz", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "fa711b086a7247c3e8dd2ada6cc7851b", + "name": "uwsgi", + "sha256": "b29d2052f0dea333b9dd115541c45e653dca87cbe6cee86edf675c42ed33b1fc", + "size": 7018764, + "subdir": "linux-64", + "timestamp": 1679988690807, + "version": "2.0.21" + }, + "uwsgi-2.0.21-py38hb8d2a22_0.conda": { + "build": "py38hb8d2a22_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "jansson >=2.14,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuuid", + "libxml2 >=2.9.14,<2.10.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre >=8.44,<9.0a0", + "python >=3.8,<3.9.0a0", + "xz", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "50f62ced49c6b9f6e6380e77abed4c33", + "name": "uwsgi", + "sha256": "394c4bbc66d3802fe1ec6c42f003d903a42a06260664676096118689061dfc85", + "size": 7011741, + "subdir": "linux-64", + "timestamp": 1678466366238, + "version": "2.0.21" + }, + "uwsgi-2.0.21-py39h068a5ad_1.conda": { + "build": "py39h068a5ad_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "jansson >=2.14,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuuid", + "libxml2 >=2.10.3,<2.11.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre >=8.44,<9.0a0", + "python >=3.9,<3.10.0a0", + "xz", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "86c1b9396fe4c01d58bb7d733521ec6a", + "name": "uwsgi", + "sha256": "00c3c7ec662441eeea9a6018e4bb3a6b87888c25b19bad96fc0f2b0eaa5ecee5", + "size": 7940255, + "subdir": "linux-64", + "timestamp": 1679988430196, + "version": "2.0.21" + }, + "uwsgi-2.0.21-py39hb8d2a22_0.conda": { + "build": "py39hb8d2a22_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "jansson >=2.14,<3.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "libuuid", + "libxml2 >=2.9.14,<2.10.0a0", + "openssl >=1.1.1t,<1.1.2a", + "pcre >=8.44,<9.0a0", + "python >=3.9,<3.10.0a0", + "xz", + "yaml >=0.2.5,<0.3.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL", + "md5": "61b84f15b0510fd104daec91f80d4efb", + "name": "uwsgi", + "sha256": "d3c3644ac2ae22d114b084d3c0e0614ac03a2cec85b53deed4acba377fcf8abd", + "size": 7933657, + "subdir": "linux-64", + "timestamp": 1678466635809, + "version": "2.0.21" + }, + "vcrpy-1.13.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "mock", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7945cfd7fdb5e58a55f45abfbabae6c9", + "name": "vcrpy", + "sha256": "8e69c143380e279560a336515619d0c75a2ed61701b49b80636a45bb36cb14db", + "size": 54127, + "subdir": "linux-64", + "timestamp": 1536853882283, + "version": "1.13.0" + }, + "vcrpy-1.13.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "44d055c1c0676ce3e29eef375be6ff8f", + "name": "vcrpy", + "sha256": "c6717ab05b303a292392d94bcefc44290807bf4a16ce2b7d1719161e3073e9f4", + "size": 57281, + "subdir": "linux-64", + "timestamp": 1536853915658, + "version": "1.13.0" + }, + "vcrpy-1.13.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0463d11a9d2daf046a553537fbf35e03", + "name": "vcrpy", + "sha256": "2939ad2cc64b5c3b20d50f546f4df832e797233f0305d1f6e4892c2b0b775677", + "size": 55882, + "subdir": "linux-64", + "timestamp": 1536853922752, + "version": "1.13.0" + }, + "vcrpy-1.13.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "10fec3b25e23bc749bab8f1181495c91", + "name": "vcrpy", + "sha256": "d5f16cbadfb52b0107262233ba74a25ece8ae5e7e83d4847dab6de86b90024b7", + "size": 55970, + "subdir": "linux-64", + "timestamp": 1536853866379, + "version": "1.13.0" + }, + "vcrpy-2.0.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "mock", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98771416ec3951522dd2b2fa0c7e43e5", + "name": "vcrpy", + "sha256": "7200d70d6d977441393ebf31ebb656cdf345c9257427a95a555018c1611b5137", + "size": 54051, + "subdir": "linux-64", + "timestamp": 1539658868326, + "version": "2.0.1" + }, + "vcrpy-2.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8136bd18b764a91680bff787fe125a5", + "name": "vcrpy", + "sha256": "6bed50cee207063275ce060eec7764e16feb8ed194754e0dac0763ff8589880d", + "size": 57382, + "subdir": "linux-64", + "timestamp": 1539658891978, + "version": "2.0.1" + }, + "vcrpy-2.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "055a1323ee036d25a165956862adb62b", + "name": "vcrpy", + "sha256": "1ac254cea0859433f17b376ab0c05b9a8ecb0671a2dc1729e91775d9cf591e6b", + "size": 57537, + "subdir": "linux-64", + "timestamp": 1539658871559, + "version": "2.0.1" + }, + "vcrpy-2.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "mock", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6d6d34047134f6aff96efde294b61871", + "name": "vcrpy", + "sha256": "ce227d6b99132e0792c244cb8b61abe33502b058f5b8f164c8640750f17b6570", + "size": 62709, + "subdir": "linux-64", + "timestamp": 1569428144588, + "version": "2.1.0" + }, + "vcrpy-2.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9512cc298176f3548ddd89655553a731", + "name": "vcrpy", + "sha256": "3534c5ea477aefdbfc53f25e4000170b1e4255a6d4c742f0a1b97cdd4f974807", + "size": 66107, + "subdir": "linux-64", + "timestamp": 1569428133567, + "version": "2.1.0" + }, + "vcrpy-2.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e2a9497d672b448739762894209a8ad6", + "name": "vcrpy", + "sha256": "b7a0521a335e790d9aa75fcfbeaca831490a7707add0e274b0473c5e132f92a1", + "size": 66289, + "subdir": "linux-64", + "timestamp": 1569428131201, + "version": "2.1.0" + }, + "vcrpy-2.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "contextlib2", + "mock", + "python >=2.7,<2.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c10caa91c4c1152deda22a2e64d430e1", + "name": "vcrpy", + "sha256": "ab0a38cace7d5e267fdfcd7e52df91961fd369e6a333424d0fd040c3a12c5536", + "size": 62526, + "subdir": "linux-64", + "timestamp": 1573975890679, + "version": "2.1.1" + }, + "vcrpy-2.1.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7e6d6bfefd2ead2f7a1e1ba05690fbc4", + "name": "vcrpy", + "sha256": "13d30f2f72fe45740a7219d8f4fac0f14f4458165e59df350e4c59628d40307c", + "size": 63475, + "subdir": "linux-64", + "timestamp": 1640813215287, + "version": "2.1.1" + }, + "vcrpy-2.1.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a606325219656b55e9eb88bca82a2c2", + "name": "vcrpy", + "sha256": "eea9eaff4660f7fe06cbc963cb9c3f24ec9c4c31a94f2e9262db273882ef8de9", + "size": 85013, + "subdir": "linux-64", + "timestamp": 1676863470569, + "version": "2.1.1" + }, + "vcrpy-2.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a91aebe84862b8b7fb5f92df8b161fbb", + "name": "vcrpy", + "sha256": "efb5778f92c096fd3eeb2a8564f1bb27ed05e49dad2147eb60914adc04bc9173", + "size": 66165, + "subdir": "linux-64", + "timestamp": 1573975897222, + "version": "2.1.1" + }, + "vcrpy-2.1.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7b987e07c1f7f61ce51c7a4089314030", + "name": "vcrpy", + "sha256": "a92367d8c12b3412213f120dd042aa9d23c9ed3f0077969d46b146c421a78b2a", + "size": 66219, + "subdir": "linux-64", + "timestamp": 1613038276262, + "version": "2.1.1" + }, + "vcrpy-2.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ccc35b272b98e1e4a7a66a8f9e84f72", + "name": "vcrpy", + "sha256": "dcfc3b7145372ed3f70bc8b9cf07270822155f8f62febf98d1931f3d0c54fac8", + "size": 66311, + "subdir": "linux-64", + "timestamp": 1573975877661, + "version": "2.1.1" + }, + "vcrpy-2.1.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8d914dda084a8c848f3fadc6f5b42b26", + "name": "vcrpy", + "sha256": "3e85e8e3de378edc880c2ca74678679c7016a7d1c3715eb1138580a21348aeba", + "size": 66530, + "subdir": "linux-64", + "timestamp": 1613038675156, + "version": "2.1.1" + }, + "vcrpy-2.1.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e2d7618d4f9414d93fb4d1697b1af7a8", + "name": "vcrpy", + "sha256": "be1864ba038bfaa69ca9783c96ca60bfbf1a0638c74d206236d6ff62aa32a5e8", + "size": 63185, + "subdir": "linux-64", + "timestamp": 1574153530444, + "version": "2.1.1" + }, + "vcrpy-2.1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a131fe81ea0931c34f470268f28a4d4a", + "name": "vcrpy", + "sha256": "5a2308b8557e1e6fbae356569d3ff64d4ba96b8476de34bbbd1537d777921b0b", + "size": 66024, + "subdir": "linux-64", + "timestamp": 1613038627351, + "version": "2.1.1" + }, + "vcrpy-2.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc2377da6eef3fb44123ffceabdcbf3e", + "name": "vcrpy", + "sha256": "319d7a64c0a5dde4880adf8050dca6a5036a02fbcd2906a2e4be9c422d41f0e4", + "size": 66080, + "subdir": "linux-64", + "timestamp": 1613038662638, + "version": "2.1.1" + }, + "vcrpy-4.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b83aaa16b665fafc6042d3ddb286d4c", + "name": "vcrpy", + "sha256": "87c2ae5fce194b3888ea22e919bdfee1c5451d151a5311e3c7d834c627ff04b4", + "size": 66879, + "subdir": "linux-64", + "timestamp": 1600470088940, + "version": "4.1.0" + }, + "vcrpy-4.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "8a9c5bf41d23275de19141d55ad0e803", + "name": "vcrpy", + "sha256": "27df69b1cca24a7a4fe4523cc654c6fc5f0353e587a92b5d334e0b8480c1a9e5", + "size": 66972, + "subdir": "linux-64", + "timestamp": 1600470086701, + "version": "4.1.0" + }, + "vcrpy-4.1.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9970dbae70c124fb4932ea76954fd435", + "name": "vcrpy", + "sha256": "6936918b48e821db58edcf558d56a854548ffe87bf2ecaaedb391e40671b6584", + "size": 68179, + "subdir": "linux-64", + "timestamp": 1600470068743, + "version": "4.1.0" + }, + "vcrpy-4.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f5da9da3b502a8db847a4232f91509fe", + "name": "vcrpy", + "sha256": "b0fa602204ee42cb7a3a38fa6e34cf1014dbbde9dcbed26945318de30f8a65b7", + "size": 66661, + "subdir": "linux-64", + "timestamp": 1602526767692, + "version": "4.1.1" + }, + "vcrpy-4.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5bd3aa2c929ac2e5d685efcc7c993a28", + "name": "vcrpy", + "sha256": "b969050e1156e8ac3a4d2f19273d03aab91c1b9a8a359a8bcd38557329c0bb87", + "size": 67858, + "subdir": "linux-64", + "timestamp": 1602523544301, + "version": "4.1.1" + }, + "vcrpy-4.1.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml", + "six >=1.5", + "wrapt", + "yarl" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b32a9efffe878097a2ce0824165953e8", + "name": "vcrpy", + "sha256": "b7cb2b89e08f93506742a5d3f494dac6a2064d184943ed0a445aea2d566b8541", + "size": 67546, + "subdir": "linux-64", + "timestamp": 1602523518193, + "version": "4.1.1" + }, + "vcversioner-2.16.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "9d22c445e57c93ec6a011bc41a43fc92", + "name": "vcversioner", + "sha256": "897befad57c691cc3ed5f546e51628abdc63c9df19e9ed082fdbdf7c301a55c2", + "size": 13507, + "subdir": "linux-64", + "timestamp": 1530693910883, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py27h4da6c7b_0.conda": { + "build": "py27h4da6c7b_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ISC", + "md5": "429998539fa19d4a3b6940f6144bb102", + "name": "vcversioner", + "sha256": "1c076fc7465bc3f1a14431b24fea78735752fc85972c48cadb154a9832bb14bb", + "size": 13282, + "subdir": "linux-64", + "timestamp": 1505672156046, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "ISC", + "md5": "2a2f9e56dd0bbc159935dcc21a9def0e", + "name": "vcversioner", + "sha256": "1b93fe8f992607006f17f6e30aaca2ba9217bc5afcf9ca5d2b2f173c4d2eb73f", + "size": 13656, + "subdir": "linux-64", + "timestamp": 1640795749876, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "ISC", + "md5": "88b877c34fea0267a6dae706fc6f174f", + "name": "vcversioner", + "sha256": "9c7b4f40287555d7e9dcd49e15259ff76f475d050887ac9b3967777ecd71fb5b", + "size": 15451, + "subdir": "linux-64", + "timestamp": 1676863484913, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py35h8b0535f_0.conda": { + "build": "py35h8b0535f_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ISC", + "md5": "c6f30f793280844a6a94151d9faead98", + "name": "vcversioner", + "sha256": "a9caa25b2e00569c3a579a30f4e3713ce625d13736b30985078b074c409d9dff", + "size": 13320, + "subdir": "linux-64", + "timestamp": 1505672166710, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "f3d9513dd08d478d5d55e2e6c58af630", + "name": "vcversioner", + "sha256": "19c2cfacea45846fadef0defbe09b31a2da3addaab9e7259002bd51f38ddf425", + "size": 13494, + "subdir": "linux-64", + "timestamp": 1530693874232, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "eb8f14d600621cd3e65c8a44708d1ada", + "name": "vcversioner", + "sha256": "e2fa8759ebdbeaa0733c79d8766c94c893c890d7527de5ac0adc6a6e0c1697c8", + "size": 15134, + "subdir": "linux-64", + "timestamp": 1611772642186, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py36h539c7c5_0.conda": { + "build": "py36h539c7c5_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ISC", + "md5": "0dd5de7e2ca154ebac5a2f8dad9589e4", + "name": "vcversioner", + "sha256": "e22e6787d8fd39b89170a4f987ecbaacc0b1c658f7f48a97785f4d9534576fae", + "size": 13310, + "subdir": "linux-64", + "timestamp": 1505672177464, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "edaaddc8ee3d876c52a2ca88668e7adc", + "name": "vcversioner", + "sha256": "665c2d7d58d9799de6402850bc10bedf2808305a1ea090cd517c1d58bf2694cc", + "size": 13492, + "subdir": "linux-64", + "timestamp": 1530693893251, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ISC", + "md5": "8067803852c199c9673cde15cd870c1f", + "name": "vcversioner", + "sha256": "70e119b6f056543f83c70c776af1d96809aec432d657638102dd7c7de68c8731", + "size": 15130, + "subdir": "linux-64", + "timestamp": 1611772653122, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "9afe4917de12c00f6c8484698e43e505", + "name": "vcversioner", + "sha256": "a90a6ac9d8bbf6f4957d5a8567c1345414a68921611448de71482b40ea8b7c60", + "size": 13909, + "subdir": "linux-64", + "timestamp": 1573200295885, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "ISC", + "md5": "75e0a494a32d3f223568638b50668b84", + "name": "vcversioner", + "sha256": "e86729745e77da3d69608d7c017001456bd5d4a5d1ea17f4650b809d45bdeb2e", + "size": 15112, + "subdir": "linux-64", + "timestamp": 1611772663464, + "version": "2.16.0.0" + }, + "vcversioner-2.16.0.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "ISC", + "md5": "217bcedd3a6e01e756c397cdf8d5d09d", + "name": "vcversioner", + "sha256": "db53902bef0bb5c3140d83d9fb5d6cccaeb7a5415f60ef7338e627ed6b2161e0", + "size": 15164, + "subdir": "linux-64", + "timestamp": 1611772366456, + "version": "2.16.0.0" + }, + "venusian-1.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "42b64dc38e2eb24c1af8176684dadee7", + "name": "venusian", + "sha256": "ff75d66e7d24c779ceebdcd28951004c1a8d47e822b746bd3601af16d45f75ec", + "size": 40010, + "subdir": "linux-64", + "timestamp": 1530814241061, + "version": "1.1.0" + }, + "venusian-1.1.0-py27hb5d49f3_0.conda": { + "build": "py27hb5d49f3_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "4393835c41fb073ada801f92bae66556", + "name": "venusian", + "sha256": "af98c2c5ab7d50cb9af02d789ca40c4a7162e6beb46ca63f4b7c10aa334de484", + "size": 40530, + "subdir": "linux-64", + "timestamp": 1508006852687, + "version": "1.1.0" + }, + "venusian-1.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "b7d29bb48485b08ba1ffaf935b387ccd", + "name": "venusian", + "sha256": "1339473ed8691193d43400cce17aff6768972c5f93ac09d83a86c6f4c650c758", + "size": 41564, + "subdir": "linux-64", + "timestamp": 1535130261506, + "version": "1.1.0" + }, + "venusian-1.1.0-py35h7b98667_0.conda": { + "build": "py35h7b98667_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "9916aa8cfe9aa7a6e49ede6deb5d4109", + "name": "venusian", + "sha256": "95ff2a42d81c8546a8fe5c5833a7d8973138be500518ba7a2e62aca140948a4d", + "size": 41270, + "subdir": "linux-64", + "timestamp": 1508006870580, + "version": "1.1.0" + }, + "venusian-1.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "59af2fd70fe944d34f570ce35094c03a", + "name": "venusian", + "sha256": "65e55d530d17a6bf724ef7757a6563e300edbc89c92b570852f254d740341c4c", + "size": 40586, + "subdir": "linux-64", + "timestamp": 1530814294668, + "version": "1.1.0" + }, + "venusian-1.1.0-py36h56a613d_0.conda": { + "build": "py36h56a613d_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "2d1dd5f9763f68d809637a92a68e7501", + "name": "venusian", + "sha256": "6e423cc8a5e1897eaf7b89483bc96aeb809721ff82cd2e3808d0383b3a170369", + "size": 40788, + "subdir": "linux-64", + "timestamp": 1508006862533, + "version": "1.1.0" + }, + "venusian-1.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "7cdff91267346a3453a117d94f0386df", + "name": "venusian", + "sha256": "8cbd6ca3c1ed095adf94068ce0e8a7b3b1cb2a2d86079342daa09a7f1083722b", + "size": 40621, + "subdir": "linux-64", + "timestamp": 1530814267275, + "version": "1.1.0" + }, + "venusian-1.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "4a453935b09f82f821ad34865bdc90cb", + "name": "venusian", + "sha256": "8b760538c20ecd9e2da4d61cce9891198673950a5d6a792befc3117c290570b3", + "size": 183570, + "subdir": "linux-64", + "timestamp": 1547984417428, + "version": "1.2.0" + }, + "venusian-1.2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "aa7ce28d34a0e7fac7bfbcca1345b656", + "name": "venusian", + "sha256": "4c99f966f880a9792b2ba620f5aa6ac4729f28388b787121cb406e062e2ff977", + "size": 41253, + "subdir": "linux-64", + "timestamp": 1640795768128, + "version": "1.2.0" + }, + "venusian-1.2.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "md5": "d010a384999f69e9bc87a26d439f0994", + "name": "venusian", + "sha256": "83780c3becf6ede20cc4375eeeb8ddd9d9e5430a0a58dfbd6526cd63d564b17d", + "size": 49681, + "subdir": "linux-64", + "timestamp": 1676905875996, + "version": "1.2.0" + }, + "venusian-1.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "d8649a00b6d9953d107d2d43bc9bc550", + "name": "venusian", + "sha256": "e48639a6beab0ac652d34598359a0817c80758615c97253b73669e84279241c3", + "size": 184426, + "subdir": "linux-64", + "timestamp": 1547984494511, + "version": "1.2.0" + }, + "venusian-1.2.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "622c5dde1c25efb110273ebb2e23b14e", + "name": "venusian", + "sha256": "686d8819036064627cdbad0045419d7ee7cfb4191632533b6db98619533f8c51", + "size": 281658, + "subdir": "linux-64", + "timestamp": 1614000079897, + "version": "1.2.0" + }, + "venusian-1.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "b66381af3379e7acdc401b329174423b", + "name": "venusian", + "sha256": "dd44649282e44bb8bb4f1420e21f7ce388047b1c9992ae4f5538ffc272512405", + "size": 184484, + "subdir": "linux-64", + "timestamp": 1547984515514, + "version": "1.2.0" + }, + "venusian-1.2.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "e6c4c491b09ff528020f48c039e01993", + "name": "venusian", + "sha256": "d54b0995f268abc9e29839bcb2229f3c21382e77758dbce22a1cc21166d6d00c", + "size": 281312, + "subdir": "linux-64", + "timestamp": 1614000070087, + "version": "1.2.0" + }, + "venusian-1.2.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "36a9b7fefaa96b0ed716f649b1b29d1d", + "name": "venusian", + "sha256": "68c192e82e8deede9460af7f16f8bde3fba953efbfe97cfb88af9a9175717df7", + "size": 41601, + "subdir": "linux-64", + "timestamp": 1573200308105, + "version": "1.2.0" + }, + "venusian-1.2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "d3eb54bf6f1dbeb9bc527db57c116335", + "name": "venusian", + "sha256": "978100fc6188b583b59d0050079a8888613a46ae121b2e738d7774cd70e121b8", + "size": 282961, + "subdir": "linux-64", + "timestamp": 1613999199163, + "version": "1.2.0" + }, + "venusian-1.2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "f3b964ca8f3b6289f146ae7bab9b39f8", + "name": "venusian", + "sha256": "4726ec4e937f65f36e6a7a4e6ae0002dfa2b5ed0c782ac6ad2c289da68d0cf43", + "size": 282582, + "subdir": "linux-64", + "timestamp": 1614000424730, + "version": "1.2.0" + }, + "verboselogs-1.4-py27h0984be8_0.conda": { + "build": "py27h0984be8_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5a6c8d34f572950ac80fe12e142f7a17", + "name": "verboselogs", + "sha256": "da854a68c07af163ae1feb2eda15bc1b3ae54f38790cbbd7ae7c411571f5390c", + "size": 11208, + "subdir": "linux-64", + "timestamp": 1505864044286, + "version": "1.4" + }, + "verboselogs-1.4-py35h7d0379e_0.conda": { + "build": "py35h7d0379e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "493fba23400eeb6c9ca9c19124291272", + "name": "verboselogs", + "sha256": "83e3dc1606e8691ff77ee0093f2a67f886546b5955297ffc6c582a9348699283", + "size": 11503, + "subdir": "linux-64", + "timestamp": 1505864055845, + "version": "1.4" + }, + "verboselogs-1.4-py36h802500c_0.conda": { + "build": "py36h802500c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "18a65efd5de15862cfed4b191338951a", + "name": "verboselogs", + "sha256": "6aa3bd7edc0bfb7b754fcad9053f6d1089e4e3de18665cef6f25830974e9d1e3", + "size": 11348, + "subdir": "linux-64", + "timestamp": 1505864067481, + "version": "1.4" + }, + "verboselogs-1.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "5f084c0fe6c560a3af6aad1c1f47895b", + "name": "verboselogs", + "sha256": "1d10b4347f6c1f4968445b5dc4fa539be129405e2b55e69df0ff73149f50454c", + "size": 12308, + "subdir": "linux-64", + "timestamp": 1531060659591, + "version": "1.7" + }, + "verboselogs-1.7-py27h713c921_0.conda": { + "build": "py27h713c921_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "47f78befa1611e51068e59b52d96afa7", + "name": "verboselogs", + "sha256": "7480dea0f9e2f728d2f54a4f46ddfbdab2a48eaacbf04ae9589a9679d3c0dbfe", + "size": 12578, + "subdir": "linux-64", + "timestamp": 1511315808868, + "version": "1.7" + }, + "verboselogs-1.7-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "md5": "cc547511ac500cf1f85b8d5078dd4d0a", + "name": "verboselogs", + "sha256": "7c318fed861a2185d19d8033d18f478e88a18fbb7b71fd121dd87f9280660b21", + "size": 12720, + "subdir": "linux-64", + "timestamp": 1640795786705, + "version": "1.7" + }, + "verboselogs-1.7-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "md5": "665066dc14f8cb027da9f0d8a6782278", + "name": "verboselogs", + "sha256": "22bd62e933b512226bab7a290a514b20a9daa05b175030d3e30569653f6a5322", + "size": 14477, + "subdir": "linux-64", + "timestamp": 1676863500537, + "version": "1.7" + }, + "verboselogs-1.7-py35h5d477f3_0.conda": { + "build": "py35h5d477f3_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "3dc77fbed3f7b3e0424a967b349f361b", + "name": "verboselogs", + "sha256": "e3e7ff4b04bd1ccf211361291ea55d8cbe2ef1889ded4b0d6895cb7e327e6b47", + "size": 12880, + "subdir": "linux-64", + "timestamp": 1511315817699, + "version": "1.7" + }, + "verboselogs-1.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "84f4dfa0f6e228c8137024af7379d69a", + "name": "verboselogs", + "sha256": "af4c94ccd858ba1395423105d6225fcd4d3b3197d0fe75e4fe10f9e1f493e4e0", + "size": 12456, + "subdir": "linux-64", + "timestamp": 1531060594858, + "version": "1.7" + }, + "verboselogs-1.7-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e93ce6982b927329ae8194dc2c4cf9b7", + "name": "verboselogs", + "sha256": "cf638546a1b2f5c0286026a863b22e2842562bc40a1d15bc31cb8ff1fe198e09", + "size": 13616, + "subdir": "linux-64", + "timestamp": 1614000077420, + "version": "1.7" + }, + "verboselogs-1.7-py36h71e5335_0.conda": { + "build": "py36h71e5335_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "659cb48a0895db7ccbba9a50e742f7ba", + "name": "verboselogs", + "sha256": "40867ef948bb643730375582652fb40e83447ff90406e336a0094cdf6e6d5dc6", + "size": 12785, + "subdir": "linux-64", + "timestamp": 1511315814809, + "version": "1.7" + }, + "verboselogs-1.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "2d0bec7fda8cc98032c073432392f674", + "name": "verboselogs", + "sha256": "3b046eafdd4919689630ac780ee0528ecfd600eba040e024178229686f8b26be", + "size": 12435, + "subdir": "linux-64", + "timestamp": 1531060627342, + "version": "1.7" + }, + "verboselogs-1.7-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "3c59c9eb99351272f4281d3a22734986", + "name": "verboselogs", + "sha256": "5a4bf4a55dbf6d317c48f64289d442831fcbe10ee969011a905fc114040dbd3f", + "size": 13616, + "subdir": "linux-64", + "timestamp": 1613999916353, + "version": "1.7" + }, + "verboselogs-1.7-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "c40fa6cdc750e58d69d4931e8f4393dd", + "name": "verboselogs", + "sha256": "1bd06869ebd06e277b6dffe5b3ab15e1b7b9944ce3aebf52839f7e1bd12b429a", + "size": 12932, + "subdir": "linux-64", + "timestamp": 1573200318916, + "version": "1.7" + }, + "verboselogs-1.7-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "811cd6e9a8cfa376d3d841dbfed363b0", + "name": "verboselogs", + "sha256": "c791a69b274a7d95aa19d39b4dcc05fbb24119b09f2200d92ef108a93c9651f4", + "size": 13623, + "subdir": "linux-64", + "timestamp": 1614000083091, + "version": "1.7" + }, + "verboselogs-1.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "md5": "8a36db080d296ff9c396917cc4499ae2", + "name": "verboselogs", + "sha256": "29780e20e4e9298cd52934504e2128f3c904dbb786c9fb54545120536dba8dab", + "size": 13716, + "subdir": "linux-64", + "timestamp": 1614000075154, + "version": "1.7" + }, + "virtualenv-15.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "242b736a3e769ecd1afd5788fd1439c9", + "name": "virtualenv", + "sha256": "80940c485ed8e4db2ea0e99513e7698aad270bd712b482ae2abcec514fd0cfe9", + "size": 1945048, + "subdir": "linux-64", + "timestamp": 1522722947567, + "version": "15.2.0" + }, + "virtualenv-15.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "8cc675a654906ee479c7945fed10ef80", + "name": "virtualenv", + "sha256": "2620bc8cb003bc6b039f282b1aa2fe690956fba68d5874e69d9b7e10ff05af34", + "size": 1946864, + "subdir": "linux-64", + "timestamp": 1522715886502, + "version": "15.2.0" + }, + "virtualenv-15.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "e7d67d4841984b6bf63c902fe237a6d7", + "name": "virtualenv", + "sha256": "d7790a0638ab3ae08ad856c180feb0c4c5e932dbfa7f9a917f352cedb7a9ff20", + "size": 1946197, + "subdir": "linux-64", + "timestamp": 1522722955416, + "version": "15.2.0" + }, + "virtualenv-16.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "da3e9a89923728e1cda1205a95277f29", + "name": "virtualenv", + "sha256": "5dd17a68c844b8cc292988540ed2c1cbf24fa3152f0789f27b679eb03217ce83", + "size": 1801907, + "subdir": "linux-64", + "timestamp": 1526918799447, + "version": "16.0.0" + }, + "virtualenv-16.0.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "84c32a21a272936bb408c80111cfd47f", + "name": "virtualenv", + "sha256": "bf8a5f74a8316ed2eee61f9f9e7d005c524bf68ea6fd48e140f1381e50a8afe2", + "size": 1802472, + "subdir": "linux-64", + "timestamp": 1526918819763, + "version": "16.0.0" + }, + "virtualenv-16.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "af071e5bd98a8aad0704aa41db94bf7a", + "name": "virtualenv", + "sha256": "3d471315b91f8c368daaa199cccafe15d6b75afee602d859c9ccd8d3cc15425a", + "size": 1802292, + "subdir": "linux-64", + "timestamp": 1526918762444, + "version": "16.0.0" + }, + "virtualenv-16.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "9c242f30d05298b933ccd76a0e2a732e", + "name": "virtualenv", + "sha256": "5f9850014efb5ca1328959a8515c45e7fdfc16f4a2b60dfb45fc85f3c47a5453", + "size": 1802497, + "subdir": "linux-64", + "timestamp": 1531060692110, + "version": "16.0.0" + }, + "virtualenv-16.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "98ad4c43d495f99e001f75db16f52d23", + "name": "virtualenv", + "sha256": "40039104e3b8c7faaea7f3bcd5b9744a01eec2723032d3913ab651f84a06bab3", + "size": 1804264, + "subdir": "linux-64", + "timestamp": 1573200350148, + "version": "16.0.0" + }, + "virtualenv-20.0.20-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<2", + "importlib_resources >=1.0,<2", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "7ab402695157b064aa7be3d9360faa57", + "name": "virtualenv", + "sha256": "dd6a6c81cf541e7765b5036265ab787f2d7521be5691cc00f59d21f71ab5c618", + "size": 3190269, + "subdir": "linux-64", + "timestamp": 1600783082694, + "version": "20.0.20" + }, + "virtualenv-20.0.20-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<2", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "d6b709a4dfcd543f62b217bef26c0b6a", + "name": "virtualenv", + "sha256": "6d52e8b32b89dd1c70a339d69a4e7d1fab229e789c21bc665b6be7ba9884d624", + "size": 3191151, + "subdir": "linux-64", + "timestamp": 1600783109599, + "version": "20.0.20" + }, + "virtualenv-20.0.20-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "f52a229ccdfa0ac1ba92d4401ad0b053", + "name": "virtualenv", + "sha256": "92e8a17688ba2b4667660dbdbc540fdebcb312bfa6f9157a2a0e5ba4eb15ab23", + "size": 3191844, + "subdir": "linux-64", + "timestamp": 1600782946244, + "version": "20.0.20" + }, + "virtualenv-20.0.33-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "71b1a78689d40250ebe9ac9cd7587e2f", + "name": "virtualenv", + "sha256": "d819bef5cb00aaff9550ae2b69b851cdc3edda46a0cca3451d3235dc8df2f514", + "size": 3573991, + "subdir": "linux-64", + "timestamp": 1602266758825, + "version": "20.0.33" + }, + "virtualenv-20.0.33-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "595bb7ca97f822f2deb1f2fdb9da0caf", + "name": "virtualenv", + "sha256": "b16cb1a75add4ac4d4b939503c98af298be825168cdfdd5afeb07ac5904cb567", + "size": 3573475, + "subdir": "linux-64", + "timestamp": 1602266764324, + "version": "20.0.33" + }, + "virtualenv-20.0.33-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "6f50921e17329b8380cb132f1ba42c76", + "name": "virtualenv", + "sha256": "358a611920eac1d58ff96768b182bf5e4db941a5854c031965acf59109101ffc", + "size": 3573906, + "subdir": "linux-64", + "timestamp": 1602266769189, + "version": "20.0.33" + }, + "virtualenv-20.0.34-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "38a60126877455a47eb2633eb0d1a300", + "name": "virtualenv", + "sha256": "7e275f1b85bc60952c7bfe514de71e91644452dc55d3acc52f218ffea1bfa83d", + "size": 3573713, + "subdir": "linux-64", + "timestamp": 1602527460641, + "version": "20.0.34" + }, + "virtualenv-20.0.34-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "4074e66be14cdd35398b8d0125fd119f", + "name": "virtualenv", + "sha256": "7f7462d0ca39a4ca2bbadbdc471ea0ae4029a40b59d1c31980f71fd0d0502e54", + "size": 3574483, + "subdir": "linux-64", + "timestamp": 1602527433598, + "version": "20.0.34" + }, + "virtualenv-20.0.34-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "ea040cc4ffd5972f45baddbe90922127", + "name": "virtualenv", + "sha256": "da8770756cd2725a6e8833d0c9048b680a14de3cb9700c793203cfa0a4372603", + "size": 3574079, + "subdir": "linux-64", + "timestamp": 1602527468564, + "version": "20.0.34" + }, + "virtualenv-20.0.35-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "378b0b674a62a93aea8a3706584ccaf4", + "name": "virtualenv", + "sha256": "521e1d1983336161a81566c054c0d98bb4ae3f82c1bf1779fc1e587410726a0c", + "size": 3573300, + "subdir": "linux-64", + "timestamp": 1602787754881, + "version": "20.0.35" + }, + "virtualenv-20.0.35-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "309e1b87b29a8c71743b8e9ab2d2f299", + "name": "virtualenv", + "sha256": "93dd1661c065abed7795f18d27fd7c9ca1e68ac367662b1d5b04fde98e290ded", + "size": 3572851, + "subdir": "linux-64", + "timestamp": 1602787743393, + "version": "20.0.35" + }, + "virtualenv-20.0.35-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "64372416b80f5228deab16ab2f65a0da", + "name": "virtualenv", + "sha256": "44f4987066f78788df3a8effed1299e91e1dc204f15a339d4749d8493a3be593", + "size": 3573686, + "subdir": "linux-64", + "timestamp": 1602787749345, + "version": "20.0.35" + }, + "virtualenv-20.16.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.1,<1", + "filelock >=3.2,<4", + "platformdirs >=2,<3", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "781710878c647dad8c539045beb4107f", + "name": "virtualenv", + "sha256": "cc06e1704aed8c06e7e9f950c63b7d40f17bedee55c900104f7b060770114817", + "size": 6278623, + "subdir": "linux-64", + "timestamp": 1663253747788, + "version": "20.16.2" + }, + "virtualenv-20.16.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.1,<1", + "filelock >=3.2,<4", + "platformdirs >=2,<3", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b2428eff5da5443324bae17f0fb6a3f", + "name": "virtualenv", + "sha256": "493cc9a854ca256fdfdc046d7eab0fd16ecf7b98a222c8de9606ad1d50255e4a", + "size": 6356029, + "subdir": "linux-64", + "timestamp": 1676823249607, + "version": "20.16.2" + }, + "virtualenv-20.16.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.1,<1", + "filelock >=3.2,<4", + "importlib-metadata >=0.12", + "platformdirs >=2,<3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77d1144c843cb7b2e0dd2658c688ce60", + "name": "virtualenv", + "sha256": "7cdac76b944e684dfd2b9236b7d78971e8b1a568047b7359964c42ccb6b8fddf", + "size": 6275734, + "subdir": "linux-64", + "timestamp": 1663253699836, + "version": "20.16.2" + }, + "virtualenv-20.16.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.1,<1", + "filelock >=3.2,<4", + "platformdirs >=2,<3", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ace4200237c927eec2bfa365e474db7", + "name": "virtualenv", + "sha256": "09fdb011caaf9c82ece43e49bba9cc8ff65f77c6436f2658783c512b9058821e", + "size": 6276516, + "subdir": "linux-64", + "timestamp": 1663253782455, + "version": "20.16.2" + }, + "virtualenv-20.16.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.1,<1", + "filelock >=3.2,<4", + "platformdirs >=2,<3", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc112bce5de849576427a868c7bbb709", + "name": "virtualenv", + "sha256": "f83fab4f7f4ac74897761b860b2172cfcbc25f46239bcb42a2ada0e579fac97f", + "size": 6276631, + "subdir": "linux-64", + "timestamp": 1663253664367, + "version": "20.16.2" + }, + "virtualenv-20.17.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.6,<1", + "filelock >=3.4.1,<4", + "platformdirs >=2.4,<3", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3cf857b1b9821eb988b9f4ed6d41f7ad", + "name": "virtualenv", + "sha256": "820a4680a2f5cbe5fd5d31c3b28ee869cdf1a75f4b76129523ce166bc4a8092e", + "size": 6467502, + "subdir": "linux-64", + "timestamp": 1674752134817, + "version": "20.17.1" + }, + "virtualenv-20.17.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.6,<1", + "filelock >=3.4.1,<4", + "platformdirs >=2.4,<3", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08b08f00e6cfceb8161ab037111f26fe", + "name": "virtualenv", + "sha256": "2f5636ec0a1677310fb6d7dc4d3e2aab471b513e4629b757cbb620f5ea90c7ac", + "size": 6526745, + "subdir": "linux-64", + "timestamp": 1679038293316, + "version": "20.17.1" + }, + "virtualenv-20.17.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.6,<1", + "filelock >=3.4.1,<4", + "importlib-metadata >=4.8.3", + "platformdirs >=2.4,<3", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "08809dbeccc20861308b198675775919", + "name": "virtualenv", + "sha256": "4f93b3c25d2e1dfdfebdf0b2198318ba398a397c2215bc9cee2722e8c15afc2b", + "size": 6464660, + "subdir": "linux-64", + "timestamp": 1674752169888, + "version": "20.17.1" + }, + "virtualenv-20.17.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.6,<1", + "filelock >=3.4.1,<4", + "platformdirs >=2.4,<3", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0eeda6dc938d363cd9af48cdc986639", + "name": "virtualenv", + "sha256": "8956c4c063aa3debfa2c2a57899d9c5e7d9404b4661220910661e1c535554877", + "size": 6464319, + "subdir": "linux-64", + "timestamp": 1674752204319, + "version": "20.17.1" + }, + "virtualenv-20.17.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "distlib >=0.3.6,<1", + "filelock >=3.4.1,<4", + "platformdirs >=2.4,<3", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "da6a41174fa4eb10dfb1f8f24b0b75c6", + "name": "virtualenv", + "sha256": "4ae1e64cf4aa016aebcb2b505717bfce56a7dd04a08ef33a12fe8d0f7881a13c", + "size": 6465485, + "subdir": "linux-64", + "timestamp": 1674752238694, + "version": "20.17.1" + }, + "virtualenv-20.2.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "65d616845d088a5a5541d202d5951022", + "name": "virtualenv", + "sha256": "3f3d39398fd95faf46b94dee43d79cbe1f31b9d094999d45201c1d5431bfae7e", + "size": 3575299, + "subdir": "linux-64", + "timestamp": 1606938853006, + "version": "20.2.1" + }, + "virtualenv-20.2.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "c1ac9f8826b0ceebac5be3d1efac32af", + "name": "virtualenv", + "sha256": "46bcf744135f9d34ad7bb6d0702e3ec1398fc5822f176eed7726bcdbf15544b2", + "size": 3576526, + "subdir": "linux-64", + "timestamp": 1606938867670, + "version": "20.2.1" + }, + "virtualenv-20.2.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "b145a1eaf3471ceb1e1cc79a2a15f002", + "name": "virtualenv", + "sha256": "20c5ecfe8a573f185d589559e0769b8d21ffbbf824f174a26f8e7b180a60646c", + "size": 3577407, + "subdir": "linux-64", + "timestamp": 1606938849434, + "version": "20.2.1" + }, + "virtualenv-20.2.2-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "32de645c172359c5e15611dc744e225e", + "name": "virtualenv", + "sha256": "c9be41396644c041bce25700ae8d388fb921702ec836c94489a518ce2d9c9ae0", + "size": 3618295, + "subdir": "linux-64", + "timestamp": 1607370089408, + "version": "20.2.2" + }, + "virtualenv-20.2.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "95b4f821b21ca332531ac998d837926b", + "name": "virtualenv", + "sha256": "07d25b20f94418ea87fe38baa91631af131eade94938bb2a263a91c91ed6fef9", + "size": 3618265, + "subdir": "linux-64", + "timestamp": 1607370112132, + "version": "20.2.2" + }, + "virtualenv-20.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "267c36759ddff3118f70c2368164b4fb", + "name": "virtualenv", + "sha256": "0f0331e3425c61a58337631086923a7ae95cda6b41d70c5857744f12f41acdec", + "size": 3619551, + "subdir": "linux-64", + "timestamp": 1607370090472, + "version": "20.2.2" + }, + "virtualenv-20.3.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "268df264668fd86907ea721a4146b2e9", + "name": "virtualenv", + "sha256": "808717edb929492351edba0a8aa3e59ac02eeb0a98920c01179182c5d0e6497e", + "size": 3617842, + "subdir": "linux-64", + "timestamp": 1610393195888, + "version": "20.3.0" + }, + "virtualenv-20.3.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "702e07f8aff0a29ebe9807d9bfde642b", + "name": "virtualenv", + "sha256": "346a4c028b5eb3254fe49911b475109512932bed739c0debda049a184d4c29d2", + "size": 3624249, + "subdir": "linux-64", + "timestamp": 1610484688721, + "version": "20.3.0" + }, + "virtualenv-20.3.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "24bafeec1d2189e8f0b9722aab0c3614", + "name": "virtualenv", + "sha256": "c3eacc145972738ac5923a173660b00246ef1db7eb34a116357ea858733f408a", + "size": 3619100, + "subdir": "linux-64", + "timestamp": 1610392792275, + "version": "20.3.0" + }, + "virtualenv-20.3.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "8aec934846815eb99688d6ece4a6fb24", + "name": "virtualenv", + "sha256": "f5cb870825878ae6d9a818a387c634c0e0780d92e25b30cfd697d12d97bf2666", + "size": 3624416, + "subdir": "linux-64", + "timestamp": 1610484197814, + "version": "20.3.0" + }, + "virtualenv-20.3.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "14f278c0c33145d5449320a79e26718d", + "name": "virtualenv", + "sha256": "f69421281b65088a7d8bd3e8a8c31719167a5b9a9d18e86ddd89c99b32ca8543", + "size": 3621852, + "subdir": "linux-64", + "timestamp": 1610393239472, + "version": "20.3.0" + }, + "virtualenv-20.3.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "9c57faa2557fb34da6e1fb7cd38c4a53", + "name": "virtualenv", + "sha256": "3321281fb6d211acf8494f6dcfa2740d9bf828d337d67fe181fd8c2119fd842e", + "size": 3626799, + "subdir": "linux-64", + "timestamp": 1610484673734, + "version": "20.3.0" + }, + "virtualenv-20.3.1-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "374032844f84469f235965aaa440ea34", + "name": "virtualenv", + "sha256": "33eb8e313a47cde952e67c026c64cd70c25f46b2d89aa619374a5e0c0e64d4c1", + "size": 3622923, + "subdir": "linux-64", + "timestamp": 1610566130415, + "version": "20.3.1" + }, + "virtualenv-20.3.1-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12,<3", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "6ae6fd02caf5e2bf84b39cce3850b0ca", + "name": "virtualenv", + "sha256": "049b3fea0a55a8e8f2a20aa12086c9792dcd99ef7066cc9c47fd5df1a265daf8", + "size": 3623481, + "subdir": "linux-64", + "timestamp": 1610566134309, + "version": "20.3.1" + }, + "virtualenv-20.3.1-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "6f4a82abf9e2e9fbf255210f5a5e8303", + "name": "virtualenv", + "sha256": "eb17efd45ea9350e7a9d44804302cb459fcab5cc4dcd06862ec188dde1c40025", + "size": 3624322, + "subdir": "linux-64", + "timestamp": 1610566642157, + "version": "20.3.1" + }, + "virtualenv-20.4.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "254aec038f7871c51f62856bb99eefc6", + "name": "virtualenv", + "sha256": "40b8065d2a90cb8bdc5677992f3e10f5c97be021fa932675e01e32da6fed1857", + "size": 5017044, + "subdir": "linux-64", + "timestamp": 1612471166542, + "version": "20.4.2" + }, + "virtualenv-20.4.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "113593497577609db63aaff090888f32", + "name": "virtualenv", + "sha256": "e9445e5344de23d746c620d6f241ea1d097592cb2d29c37e282c7df448f0abe9", + "size": 5012832, + "subdir": "linux-64", + "timestamp": 1612470471159, + "version": "20.4.2" + }, + "virtualenv-20.4.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "b83144b73b15b94e500e2797dac48155", + "name": "virtualenv", + "sha256": "3a9e625051bd276c5aaa1029475ce428e3b6aa2599bbb3c18ec927b9b15f1d45", + "size": 5016922, + "subdir": "linux-64", + "timestamp": 1612471152542, + "version": "20.4.2" + }, + "virtualenv-20.4.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.9,<3.10.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "84aca24f82e0e2a6242515e8fed7ee09", + "name": "virtualenv", + "sha256": "4b705d19a6e70fd78cfcce65b5cd901a5fc47bb6bc11edbcfd2eaafdd626ca16", + "size": 5018301, + "subdir": "linux-64", + "timestamp": 1613233973739, + "version": "20.4.2" + }, + "virtualenv-20.4.3-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "ffb929b58bcdaf3e005844c14f16be5b", + "name": "virtualenv", + "sha256": "f42e6406bf7f58865c990e6d02fc868519c05b85614a146f48edab6c72cd7253", + "size": 5023051, + "subdir": "linux-64", + "timestamp": 1615923547866, + "version": "20.4.3" + }, + "virtualenv-20.4.3-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "88505a92bed6b6666194c160dd0b3f2e", + "name": "virtualenv", + "sha256": "e465a20bf9f23bbfcb65fcd415738fb3c4eebd7c828a54576b6211da4467d391", + "size": 5020954, + "subdir": "linux-64", + "timestamp": 1615923648635, + "version": "20.4.3" + }, + "virtualenv-20.4.3-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "2b43e9fa5a2c3b205218fc689b175808", + "name": "virtualenv", + "sha256": "2070e74eb56e8fbfea08f1e96296eddc650312fb34554ae5ed4d0b290baaf20c", + "size": 5024999, + "subdir": "linux-64", + "timestamp": 1615923660506, + "version": "20.4.3" + }, + "virtualenv-20.4.3-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.9,<3.10.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "f4a269d654c05dccfbdbdb718e2187f3", + "name": "virtualenv", + "sha256": "25cc115e0d6bce9993bd9c58a9d70e52b96138e5eff5491333e0294ba254ec92", + "size": 5022853, + "subdir": "linux-64", + "timestamp": 1615921791128, + "version": "20.4.3" + }, + "virtualenv-20.4.4-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "ec6361020b460279ca7c552eb17caf43", + "name": "virtualenv", + "sha256": "d8c15726bd312c506861065d9d7889681b5a5b0b020017baa99345b3ace42eba", + "size": 5030090, + "subdir": "linux-64", + "timestamp": 1619391850528, + "version": "20.4.4" + }, + "virtualenv-20.4.4-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "c123e329b2513ed4cb0a60779f904382", + "name": "virtualenv", + "sha256": "3e7b9c6caa3a5a4e1537d456ca92b3a7ce04f43ae86d6b64ffaf44fc03c9842d", + "size": 5031022, + "subdir": "linux-64", + "timestamp": 1619392231022, + "version": "20.4.4" + }, + "virtualenv-20.4.4-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "554fb1bd41782bd90300df11f7cc47c2", + "name": "virtualenv", + "sha256": "7fc723f811efb4c694f063f79142a3baaffbec81161eb8719f3685b0821037aa", + "size": 5033104, + "subdir": "linux-64", + "timestamp": 1619392243401, + "version": "20.4.4" + }, + "virtualenv-20.4.4-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.0,<1", + "filelock >=3.0.0,<4", + "python >=3.9,<3.10.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "01a28dd07a6ee774276330c5e21fbb09", + "name": "virtualenv", + "sha256": "4b06801c508602d1fe9b30c091b624abefa44994ae7697de3bb046d8ecdb3cf8", + "size": 5032187, + "subdir": "linux-64", + "timestamp": 1619392237225, + "version": "20.4.4" + }, + "virtualenv-20.4.6-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.1,<1", + "filelock >=3.0.0,<4", + "python >=3.10,<3.11.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "c3f70852a5b08a3143cc33d66f2469e3", + "name": "virtualenv", + "sha256": "111d06ace31ee012fa22e24df1d7b0fe4851d7ae65d9da06e8d5b04e167ca748", + "size": 4388719, + "subdir": "linux-64", + "timestamp": 1640877488844, + "version": "20.4.6" + }, + "virtualenv-20.4.6-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.1,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12", + "importlib_resources >=1.0", + "python >=3.6,<3.7.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "42f795ab45f332b93ff2d54eda5a60a4", + "name": "virtualenv", + "sha256": "b5dbef1cd3ab36a7e76f7f8bbc951db0e7ef1aa16f4550b4a03714a4fd67d9d0", + "size": 4386399, + "subdir": "linux-64", + "timestamp": 1620973316876, + "version": "20.4.6" + }, + "virtualenv-20.4.6-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.1,<1", + "filelock >=3.0.0,<4", + "importlib-metadata >=0.12", + "python >=3.7,<3.8.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "225eed183f05ded008aa80bf96c4c8a2", + "name": "virtualenv", + "sha256": "9f0ae93eb582d25b3e37343a64ad1c0306cdc4d9e483b4feec649e23e1111e54", + "size": 4385360, + "subdir": "linux-64", + "timestamp": 1620977719730, + "version": "20.4.6" + }, + "virtualenv-20.4.6-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.1,<1", + "filelock >=3.0.0,<4", + "python >=3.8,<3.9.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "41648f5a5f164a1dd02d394600a67200", + "name": "virtualenv", + "sha256": "4ad377e6386bb0e33f86b37421180e85f749b22572e824dc0182e6525242b26c", + "size": 4387208, + "subdir": "linux-64", + "timestamp": 1620977392511, + "version": "20.4.6" + }, + "virtualenv-20.4.6-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "appdirs >=1.4.3,<2", + "distlib >=0.3.1,<1", + "filelock >=3.0.0,<4", + "python >=3.9,<3.10.0a0", + "six >=1.9.0,<2" + ], + "license": "MIT", + "md5": "cd56a7f40c3bfb65a43c8f39abb48f4f", + "name": "virtualenv", + "sha256": "2521f42b648808f4ef2c1e0c1357fe49bc21a044c6f4ab30bbe9deefdcc0066b", + "size": 4387522, + "subdir": "linux-64", + "timestamp": 1620977720065, + "version": "20.4.6" + }, + "virtualenv-clone-0.5.7-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3152e35682bbfa37c6d005388465d08", + "name": "virtualenv-clone", + "sha256": "415a755fbfa869fc1ec9870d4e69a6e565136150200a6f993623529ed3634394", + "size": 15539, + "subdir": "linux-64", + "timestamp": 1657896162813, + "version": "0.5.7" + }, + "virtualenv-clone-0.5.7-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d8d08c9a95e94d197206255022e3420d", + "name": "virtualenv-clone", + "sha256": "236c50a2395ed1d3ae75ea2ecaf4fc7ce453e2da12aaae56da6ca36d1d65bcea", + "size": 18874, + "subdir": "linux-64", + "timestamp": 1676843036981, + "version": "0.5.7" + }, + "virtualenv-clone-0.5.7-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7de480b6ce53e190a3ba685282acd126", + "name": "virtualenv-clone", + "sha256": "705e6b8325ef6fb1bba44064ff5eef429652c840aef7b54717877f4471177ad2", + "size": 15474, + "subdir": "linux-64", + "timestamp": 1657896097881, + "version": "0.5.7" + }, + "virtualenv-clone-0.5.7-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ef9497b2f6fb1386a3b26de54684c8b", + "name": "virtualenv-clone", + "sha256": "293baecd7c0072bf6c2353b3ed618fe71698e3c5d45d77c6ed69287d260af2fd", + "size": 15526, + "subdir": "linux-64", + "timestamp": 1657896124020, + "version": "0.5.7" + }, + "virtualenv-clone-0.5.7-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "11b30fae72c1f6f5ac64327c1bcb64b4", + "name": "virtualenv-clone", + "sha256": "a7c7962de7ff213f1787c8547f6e3194c6109938f62743842664a570f33b91f4", + "size": 15503, + "subdir": "linux-64", + "timestamp": 1657896190678, + "version": "0.5.7" + }, + "visions-0.7.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.3.0", + "multimethod >=1.4", + "networkx >=2.4", + "numpy", + "pandas >=0.25.3", + "python >=3.10,<3.11.0a0", + "tangled-up-in-unicode >=0.0.4" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "e5fa5fb32bfb96166ee34df53dad4ed6", + "name": "visions", + "sha256": "a230fa5ee23e88a496ad6f9552a96d51e04a0dd692a64e5b317a39c7db21d031", + "size": 128678, + "subdir": "linux-64", + "timestamp": 1668114460783, + "version": "0.7.5" + }, + "visions-0.7.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.3.0", + "multimethod >=1.4", + "networkx >=2.4", + "numpy", + "pandas >=0.25.3", + "python >=3.11,<3.12.0a0", + "tangled-up-in-unicode >=0.0.4" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "93138127106412b6f017405168fdce3c", + "name": "visions", + "sha256": "dbbb6405a7a167cdc0f5dd134dd546c8dab30102e486641ecfbcb5a7f1de0de7", + "size": 156714, + "subdir": "linux-64", + "timestamp": 1676846159540, + "version": "0.7.5" + }, + "visions-0.7.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.3.0", + "multimethod >=1.4", + "networkx >=2.4", + "numpy", + "pandas >=0.25.3", + "python >=3.7,<3.8.0a0", + "tangled-up-in-unicode >=0.0.4" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "de3cccbd8b6981582fa05eff0b7b3d7f", + "name": "visions", + "sha256": "6fa68f6ae4fc00a2704161d00709d01cc875c13d5c649bbf8ea7847583c0cc2e", + "size": 126646, + "subdir": "linux-64", + "timestamp": 1668114420351, + "version": "0.7.5" + }, + "visions-0.7.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.3.0", + "multimethod >=1.4", + "networkx >=2.4", + "numpy", + "pandas >=0.25.3", + "python >=3.8,<3.9.0a0", + "tangled-up-in-unicode >=0.0.4" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "3d19ede3cdf89057954cbf4a3681696f", + "name": "visions", + "sha256": "433b4297c1a95b1d666f53f5bf60db45d36e6e9a0356861c1f88765617976ba1", + "size": 127207, + "subdir": "linux-64", + "timestamp": 1668114504335, + "version": "0.7.5" + }, + "visions-0.7.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=19.3.0", + "multimethod >=1.4", + "networkx >=2.4", + "numpy", + "pandas >=0.25.3", + "python >=3.9,<3.10.0a0", + "tangled-up-in-unicode >=0.0.4" + ], + "license": "BSD-4-Clause", + "license_family": "BSD", + "md5": "6cfedf4534d63cafdc797cbcce72bbeb", + "name": "visions", + "sha256": "ccac87ff7f31cd2488e1f9018f79ec86eb93ad3019dc19f5280cec9948b96f1c", + "size": 127862, + "subdir": "linux-64", + "timestamp": 1668114376811, + "version": "0.7.5" + }, + "vispy-0.12.1-py310h243fa6c_0.conda": { + "build": "py310h243fa6c_0", + "build_number": 0, + "depends": [ + "fontconfig", + "freetype-py", + "hsluv", + "kiwisolver", + "libgcc-ng >=11.2.0", + "numpy >=1.21.5,<2.0a0", + "packaging", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "63d7d27d7c62490ec6773f9431535ba6", + "name": "vispy", + "sha256": "936a66f7c79dfecee015f66166d7fce6b9de946c46342a151327f30f1067e382", + "size": 1463946, + "subdir": "linux-64", + "timestamp": 1669140834071, + "version": "0.12.1" + }, + "vispy-0.12.1-py311hd892b02_0.conda": { + "build": "py311hd892b02_0", + "build_number": 0, + "depends": [ + "fontconfig", + "freetype-py", + "hsluv", + "kiwisolver", + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "packaging", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d6cccde12b1151032fe447dc96717b0c", + "name": "vispy", + "sha256": "9c7f91ed58558a3da5ed953fc969585138b20113be19d4eeb3eeb4fef11b877f", + "size": 1661058, + "subdir": "linux-64", + "timestamp": 1676846186706, + "version": "0.12.1" + }, + "vispy-0.12.1-py37h4a1f111_0.conda": { + "build": "py37h4a1f111_0", + "build_number": 0, + "depends": [ + "fontconfig", + "freetype-py", + "hsluv", + "kiwisolver", + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fc8c5443d71fb33e827ad45a4ac38e0d", + "name": "vispy", + "sha256": "7ddd32ef2c2ac8622d94da25096c94991935724dbf84b0709d06a05e5bf951bb", + "size": 1446162, + "subdir": "linux-64", + "timestamp": 1669140935079, + "version": "0.12.1" + }, + "vispy-0.12.1-py38h4a1f111_0.conda": { + "build": "py38h4a1f111_0", + "build_number": 0, + "depends": [ + "fontconfig", + "freetype-py", + "hsluv", + "kiwisolver", + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "016abc060d844f113c1cf41c7259bfca", + "name": "vispy", + "sha256": "a8712dc141539ffb2f8d89f51a17feb11749c14b2c4e65753c6366776434d3a8", + "size": 1448790, + "subdir": "linux-64", + "timestamp": 1669140786452, + "version": "0.12.1" + }, + "vispy-0.12.1-py39h4a1f111_0.conda": { + "build": "py39h4a1f111_0", + "build_number": 0, + "depends": [ + "fontconfig", + "freetype-py", + "hsluv", + "kiwisolver", + "libgcc-ng >=11.2.0", + "numpy >=1.16.6,<2.0a0", + "packaging", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e607e582d65e6259fe5580fd95113d20", + "name": "vispy", + "sha256": "1fc9829211c4c5391dfdc01a93d7e183ade8db2ea817b1dafab4c5a3ddecd009", + "size": 1445704, + "subdir": "linux-64", + "timestamp": 1669140882115, + "version": "0.12.1" + }, + "vispy-0.5.2-py27hf951d6b_0.conda": { + "build": "py27hf951d6b_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.6,<3.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "860ae569f35ee6f507d5371f1cfbf861", + "name": "vispy", + "sha256": "179538b03cfbf8f1ab8be20e9f4de530ef72ab612a5f3b8702f415d86f07c768", + "size": 1074715, + "subdir": "linux-64", + "timestamp": 1521005238282, + "version": "0.5.2" + }, + "vispy-0.5.2-py35hf951d6b_0.conda": { + "build": "py35hf951d6b_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.6,<3.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f1f381184a579a55ea5b696578a8573f", + "name": "vispy", + "sha256": "8d5534e4550601c477bb089eac8d4b19548017e579024c885f40579dfa5939ec", + "size": 1103097, + "subdir": "linux-64", + "timestamp": 1521005192991, + "version": "0.5.2" + }, + "vispy-0.5.2-py36hf951d6b_0.conda": { + "build": "py36hf951d6b_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.6,<3.0a0", + "numpy >=1.14.2,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6b702cdda6d9039e10a3408529d33495", + "name": "vispy", + "sha256": "4ec2d7ebae903c04611cb9778b4453c7276ad8c1f45e59fa6531028a06eae31b", + "size": 1080587, + "subdir": "linux-64", + "timestamp": 1521005246334, + "version": "0.5.2" + }, + "vispy-0.5.3-py27hee6b756_0.conda": { + "build": "py27hee6b756_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.13.0,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1ff59f73696c5c35ec3a9d2041d2d3e2", + "name": "vispy", + "sha256": "430f4d53aa8223f16c1fcef69a5ae71cdab8cc2f87bbe8a8134bbf1f3680de34", + "size": 1086166, + "subdir": "linux-64", + "timestamp": 1531060882346, + "version": "0.5.3" + }, + "vispy-0.5.3-py27hf951d6b_0.conda": { + "build": "py27hf951d6b_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.6,<3.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "16bcd591e7bd5b10f557bf1ca1ef9f96", + "name": "vispy", + "sha256": "76a614cb0ff097b721739a203b29ea94c4eac76fc70fea6380e67a76bb860042", + "size": 1086476, + "subdir": "linux-64", + "timestamp": 1522723758867, + "version": "0.5.3" + }, + "vispy-0.5.3-py35hf951d6b_0.conda": { + "build": "py35hf951d6b_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.6,<3.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "583e326066a50e12e782a423a45b23c2", + "name": "vispy", + "sha256": "abe8d33c90554a4d392339d90de765359d42d6c9266d3ca6f48f2ba0602dfd37", + "size": 1103172, + "subdir": "linux-64", + "timestamp": 1522724168754, + "version": "0.5.3" + }, + "vispy-0.5.3-py36hee6b756_0.conda": { + "build": "py36hee6b756_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.13.0,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1277b62941856921748cac692cbe351f", + "name": "vispy", + "sha256": "36ff780d1153909fda82724eb097bd834da95e280e8a35d22c43ba4a2dabaad0", + "size": 1092115, + "subdir": "linux-64", + "timestamp": 1531060758728, + "version": "0.5.3" + }, + "vispy-0.5.3-py36hf951d6b_0.conda": { + "build": "py36hf951d6b_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.12.6,<3.0a0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "76e937349eb7b92a4db95db42b247044", + "name": "vispy", + "sha256": "72f0721641beb16a8924ebb8ba90a93887836bbdd278d79b7dfc29777672f746", + "size": 1080675, + "subdir": "linux-64", + "timestamp": 1522717313337, + "version": "0.5.3" + }, + "vispy-0.5.3-py37hee6b756_0.conda": { + "build": "py37hee6b756_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.13.0,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b59cd485c209f6de0a64b2c415cb7bd9", + "name": "vispy", + "sha256": "0e055748b6fcfcc647308a273ddd21aa05f54913b9b931491b97b9f6f87b6f65", + "size": 1089262, + "subdir": "linux-64", + "timestamp": 1531060824802, + "version": "0.5.3" + }, + "vispy-0.5.3-py38hee6b756_0.conda": { + "build": "py38hee6b756_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.13.0,<3.0a0", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eca1dd149f4070dda2e729b2f0aa2978", + "name": "vispy", + "sha256": "8584b22abe90e37bee6eb503d80f3101e36fcdc6e67b32b13a8c43446df46e7e", + "size": 1092363, + "subdir": "linux-64", + "timestamp": 1574077595477, + "version": "0.5.3" + }, + "vispy-0.7.3-py310h213f4d1_0.conda": { + "build": "py310h213f4d1_0", + "build_number": 0, + "depends": [ + "fontconfig >=2.13.1,<3.0a0", + "freetype-py", + "hsluv", + "kiwisolver", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e08d5099457f989017c01f0bed3c1576", + "name": "vispy", + "sha256": "e7818c6fb10ebd0b2007c93b189ec196cd6089d5b49cefd5aee60ec2c8944f49", + "size": 1750102, + "subdir": "linux-64", + "timestamp": 1640795818523, + "version": "0.7.3" + }, + "visvis-1.10.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "cfe93ae6a56e0112acffba2b71db70ef", + "name": "visvis", + "sha256": "29530c2e718d22501ac7a09726926a203532e737f15008e456881f52b3429065", + "size": 4746269, + "subdir": "linux-64", + "timestamp": 1522779458596, + "version": "1.10.0" + }, + "visvis-1.10.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "da2e41bdd60f7ddd12dc834d665e3c71", + "name": "visvis", + "sha256": "49d334dbf344e194cadd49c7ed769cad78bd03a29076b03ebdbb19074037fc84", + "size": 4754672, + "subdir": "linux-64", + "timestamp": 1522779680452, + "version": "1.10.0" + }, + "visvis-1.10.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "30212cc50f1e6cfe931031c722e399a7", + "name": "visvis", + "sha256": "27cd2a506121074675be3bf2f3bcbfd6821624c6cd3713e9ae1754a27c27de38", + "size": 4761600, + "subdir": "linux-64", + "timestamp": 1522779690914, + "version": "1.10.0" + }, + "visvis-1.11.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6851984fee682af357f08568d0ca344d", + "name": "visvis", + "sha256": "caa9b302dcb7e0d7919bc5780ffc68e0ab269af0febe1c35e0ab2b794fd433d1", + "size": 4752319, + "subdir": "linux-64", + "timestamp": 1524511001539, + "version": "1.11.1" + }, + "visvis-1.11.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "aa1b57fb68e4ec694a4dfaf71e87a76d", + "name": "visvis", + "sha256": "b7f3b6eb6b9eb44b7bb0672624264799788d6800d94cd7ebaad4c804e1cf1abb", + "size": 4760651, + "subdir": "linux-64", + "timestamp": 1524510867872, + "version": "1.11.1" + }, + "visvis-1.11.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9ca9d0466de5e87ccc8c7dd87065e95a", + "name": "visvis", + "sha256": "929406e6cc9e979dd6c1818f9c1f435c346ae33fb3c910303462e2a436d3977b", + "size": 4754537, + "subdir": "linux-64", + "timestamp": 1524511014061, + "version": "1.11.1" + }, + "visvis-1.11.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "75dd8eece523bafa690802c8f2ca4e88", + "name": "visvis", + "sha256": "74d24bd95d4e67528ae8b1d69e900d78abeb6873b08366d01feb178fb5256cfe", + "size": 4771327, + "subdir": "linux-64", + "timestamp": 1531060936273, + "version": "1.11.1" + }, + "visvis-1.11.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9ece65d7f28a22eb6b2d0628c504ef01", + "name": "visvis", + "sha256": "cc50199c599564f3ed9e7051b7827cf2ae155494d8193338151a658d533c757d", + "size": 4760332, + "subdir": "linux-64", + "timestamp": 1556078470118, + "version": "1.11.2" + }, + "visvis-1.11.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a2f9b492d4f2236b99b99658ee813218", + "name": "visvis", + "sha256": "f59cb5b9aa21096d9b37178ccbb06d7966c8c16ea04d2b8fd98f78195ecb07a5", + "size": 4774412, + "subdir": "linux-64", + "timestamp": 1556078631395, + "version": "1.11.2" + }, + "visvis-1.11.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy", + "pyopengl", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9be61bf250266aa63da8fd6346730e71", + "name": "visvis", + "sha256": "c6e6a1c8d153904779c39f304b32e63692f5aa985b6d245ef13f5db8bb07a4de", + "size": 4761908, + "subdir": "linux-64", + "timestamp": 1556078563563, + "version": "1.11.2" + }, + "vtk-8.1.0-py27h9686630_201.conda": { + "build": "py27h9686630_201", + "build_number": 201, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "future", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.7,<2.10.0a0", + "python >=2.7,<2.8.0a0", + "tbb", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "390737f8c31258b900661d4ea0affe38", + "name": "vtk", + "sha256": "7201ed432ede3c78e48db0f8c6e45679280a2ac6ab9bfd80e153ca7f43e62b92", + "size": 27226613, + "subdir": "linux-64", + "timestamp": 1521238014007, + "version": "8.1.0" + }, + "vtk-8.1.0-py27h969b564_201.conda": { + "build": "py27h969b564_201", + "build_number": 201, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "future", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.7,<2.10.0a0", + "python >=2.7,<2.8.0a0", + "tbb", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "f46e5badb50a6dd5269b7132b1c76c4f", + "name": "vtk", + "sha256": "b35999094798daa07de5ecaf96e301d372982e7376c5ec03ef90b2281ad0a3e8", + "size": 27223987, + "subdir": "linux-64", + "timestamp": 1521237887575, + "version": "8.1.0" + }, + "vtk-8.1.0-py35h9686630_201.conda": { + "build": "py35h9686630_201", + "build_number": 201, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "future", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.7,<2.10.0a0", + "python >=3.5,<3.6.0a0", + "tbb", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "b589cd1f9dd26d1e51ce29c4fb2b273e", + "name": "vtk", + "sha256": "9e6e694c66a5111a87e8c4cdeba64d4af154664c77801f5aa9536e159b10429a", + "size": 27223516, + "subdir": "linux-64", + "timestamp": 1521237945365, + "version": "8.1.0" + }, + "vtk-8.1.0-py35h969b564_201.conda": { + "build": "py35h969b564_201", + "build_number": 201, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "future", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.7,<2.10.0a0", + "python >=3.5,<3.6.0a0", + "tbb", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4c42eae32d388afb2b79185069a1e27c", + "name": "vtk", + "sha256": "b51522b81a99557a5832f464992d9327f46267e304fb1911a426b74deb4d905d", + "size": 27221693, + "subdir": "linux-64", + "timestamp": 1521238034868, + "version": "8.1.0" + }, + "vtk-8.1.0-py36h9686630_201.conda": { + "build": "py36h9686630_201", + "build_number": 201, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "future", + "hdf5 >=1.8.18,<1.8.19.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.7,<2.10.0a0", + "python >=3.6,<3.7.0a0", + "tbb", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "87ad9a2cfd36c03c9ca29fadbc6e2591", + "name": "vtk", + "sha256": "14de2f4b49223bc57f1dad5db295820dd4950c23e3e573385d6222b66c763dce", + "size": 27253916, + "subdir": "linux-64", + "timestamp": 1521238040701, + "version": "8.1.0" + }, + "vtk-8.1.0-py36h969b564_201.conda": { + "build": "py36h969b564_201", + "build_number": 201, + "depends": [ + "expat >=2.2.5,<3.0a0", + "freetype >=2.8,<2.9.0a0", + "future", + "hdf5 >=1.10.1,<1.10.2.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.2.0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.7,<2.10.0a0", + "python >=3.6,<3.7.0a0", + "tbb", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "655b6f55e625d4ca0c55df08b42e7b93", + "name": "vtk", + "sha256": "08993da81d6f550dda8fab5c4f40ea5aea4978ee8b40ef84b21a64bcd7d5a1e5", + "size": 27233679, + "subdir": "linux-64", + "timestamp": 1521237929035, + "version": "8.1.0" + }, + "vtk-8.1.1-py27h4f1983a_204.conda": { + "build": "py27h4f1983a_204", + "build_number": 204, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "future", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libogg >=1.3.2,<2.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=2.7,<2.8.0a0", + "tbb >=2019.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "057b2c121d517701352b6bc7440b5f54", + "name": "vtk", + "sha256": "a00af51793608b8ebd0926d6db42837ade994733ce3faf8abd426774ba71534c", + "size": 27488076, + "subdir": "linux-64", + "timestamp": 1539532919025, + "version": "8.1.1" + }, + "vtk-8.1.1-py27h881b6ac_204.conda": { + "build": "py27h881b6ac_204", + "build_number": 204, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "future", + "hdf5 >=1.8.20,<1.9.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libogg >=1.3.2,<2.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=2.7,<2.8.0a0", + "tbb >=2019.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2a710cadeff247fde742871f20c17a8d", + "name": "vtk", + "sha256": "948c6f9274059bf2e8b3d9aa366babd3e4d1e9d9bd7c60d75531a04cf6b5291f", + "size": 27488451, + "subdir": "linux-64", + "timestamp": 1539532917117, + "version": "8.1.1" + }, + "vtk-8.1.1-py36h4f1983a_204.conda": { + "build": "py36h4f1983a_204", + "build_number": 204, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "future", + "hdf5 >=1.10.2,<1.10.3.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libogg >=1.3.2,<2.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d2549af45ecf5b7807b57c1443ed83e5", + "name": "vtk", + "sha256": "1b071019554f126623e8b1671eff99443ee4cee84952ee3e2a275d9f1373145d", + "size": 27412479, + "subdir": "linux-64", + "timestamp": 1539535345625, + "version": "8.1.1" + }, + "vtk-8.1.1-py36h881b6ac_204.conda": { + "build": "py36h881b6ac_204", + "build_number": 204, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "future", + "hdf5 >=1.8.20,<1.9.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libogg >=1.3.2,<2.0a0", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.0.9,<5.0a0", + "libxml2 >=2.9.8,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "794db087b52401e87825f3cbc125f4c6", + "name": "vtk", + "sha256": "cfe67367a3757d04d658e9ffea61d22fa705a6eeb78aacbcce6c42953476b596", + "size": 27413101, + "subdir": "linux-64", + "timestamp": 1539535292782, + "version": "8.1.1" + }, + "vtk-8.2.0-py27haa4764d_200.conda": { + "build": "py27haa4764d_200", + "build_number": 200, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "future", + "hdf5 >=1.10.4,<1.10.5.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libogg >=1.3.2,<2.0a0", + "libpng >=1.6.36,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.0.10,<5.0a0", + "libxml2 >=2.9.9,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=2.7,<2.8.0a0", + "tbb >=2019.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "ecadb93cb7ef4d9d64d445e3cfa0b9c3", + "name": "vtk", + "sha256": "0fa003b9eea2485375045d1dc5459b712b084423899956a8b7d5b8dd0f3278bb", + "size": 29790271, + "subdir": "linux-64", + "timestamp": 1549816282405, + "version": "8.2.0" + }, + "vtk-8.2.0-py36haa4764d_200.conda": { + "build": "py36haa4764d_200", + "build_number": 200, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "future", + "hdf5 >=1.10.4,<1.10.5.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libogg >=1.3.2,<2.0a0", + "libpng >=1.6.36,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.0.10,<5.0a0", + "libxml2 >=2.9.9,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.6,<3.7.0a0", + "tbb >=2019.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6456cbeb95aacfca59a40ad2dd5c47c5", + "name": "vtk", + "sha256": "b624cb5eab88f4dba0fa9e40fe5219bdb2c7e925b3faf2c13e22408459617ff1", + "size": 29798154, + "subdir": "linux-64", + "timestamp": 1549814912511, + "version": "8.2.0" + }, + "vtk-8.2.0-py37haa4764d_200.conda": { + "build": "py37haa4764d_200", + "build_number": 200, + "depends": [ + "expat >=2.2.6,<3.0a0", + "freetype >=2.9.1,<3.0a0", + "future", + "hdf5 >=1.10.4,<1.10.5.0a0", + "jpeg >=9b,<10a", + "jsoncpp", + "libgcc-ng >=7.3.0", + "libnetcdf >=4.6.1,<4.7.0a0", + "libogg >=1.3.2,<2.0a0", + "libpng >=1.6.36,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.0.10,<5.0a0", + "libxml2 >=2.9.9,<2.10.0a0", + "lz4-c >=1.8.1.2,<1.9.0a0", + "python >=3.7,<3.8.0a0", + "tbb >=2019.1", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "60a17eca28a2c7dc0322abd18766651a", + "name": "vtk", + "sha256": "979cdcaa87d242aba8f3a59b4ad506a613dde3edc2009b2c531ef7b5d368abb5", + "size": 29796356, + "subdir": "linux-64", + "timestamp": 1549814925156, + "version": "8.2.0" + }, + "vtk-9.0.3-py311hf89884c_202.conda": { + "build": "py311hf89884c_202", + "build_number": 202, + "constrains": [ + "paraview ==9999999999" + ], + "depends": [ + "double-conversion", + "eigen", + "expat >=2.4.9,<3.0a0", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "gl2ps >=1.4.2,<1.4.3.0a0", + "glew >=2.2.0,<2.3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "jsoncpp >=1.9.4,<1.9.5.0a0", + "libgcc-ng >=11.2.0", + "libnetcdf >=4.8.1,<5.0a0", + "libogg >=1.3.5,<1.4.0a0", + "libpng >=1.6.39,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.1.0,<5.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "loguru", + "lz4-c >=1.9.4,<1.10.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.11,<3.12.0a0", + "qt >=5.15.9,<5.16.0a0", + "qt >=5.15.9,<6.0a0", + "sqlite >=3.41.1,<4.0a0", + "tbb >=2021.7.0", + "tk >=8.6.12,<8.7.0a0", + "utfcpp", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9aac11c35ed3f7a5ceb329397dfee3c1", + "name": "vtk", + "sha256": "8da74f2d8817fb774fe347471a01847f6883d03564af7ca85922b5ab4c04727b", + "size": 34171533, + "subdir": "linux-64", + "timestamp": 1679759732430, + "version": "9.0.3" + }, + "vtk-9.0.3-py37h0649366_201.conda": { + "build": "py37h0649366_201", + "build_number": 201, + "constrains": [ + "paraview ==9999999999" + ], + "depends": [ + "double-conversion", + "eigen", + "expat >=2.2.10,<3.0a0", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "gl2ps >=1.4.2,<1.4.3.0a0", + "glew >=2.1.0,<2.2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "jsoncpp >=1.9.4,<1.9.5.0a0", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.8.1,<5.0a0", + "libogg", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.1.0,<5.0a0", + "libxml2 >=2.9.12,<2.10.0a0", + "loguru", + "lz4-c >=1.9.3,<1.10.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.7,<3.8.0a0", + "qt >=5.9.7,<5.10.0a0", + "qt >=5.9.7,<6.0a0", + "sqlite >=3.37.2,<4.0a0", + "tbb >=2021.5.0", + "tk >=8.6.11,<8.7.0a0", + "utfcpp", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "be51f1a8d5c2d20cbd886c9ade4b0a3a", + "name": "vtk", + "sha256": "4dd6a4b31f4936a67a5090b35ae96b3036a2ca1193e08deb0cd2134e3143708d", + "size": 28823703, + "subdir": "linux-64", + "timestamp": 1646117806063, + "version": "9.0.3" + }, + "vtk-9.0.3-py38h0649366_201.conda": { + "build": "py38h0649366_201", + "build_number": 201, + "constrains": [ + "paraview ==9999999999" + ], + "depends": [ + "double-conversion", + "eigen", + "expat >=2.2.10,<3.0a0", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "gl2ps >=1.4.2,<1.4.3.0a0", + "glew >=2.1.0,<2.2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "jsoncpp >=1.9.4,<1.9.5.0a0", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.8.1,<5.0a0", + "libogg", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.1.0,<5.0a0", + "libxml2 >=2.9.12,<2.10.0a0", + "loguru", + "lz4-c >=1.9.3,<1.10.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.8,<3.9.0a0", + "qt >=5.9.7,<5.10.0a0", + "qt >=5.9.7,<6.0a0", + "sqlite >=3.37.2,<4.0a0", + "tbb >=2021.5.0", + "tk >=8.6.11,<8.7.0a0", + "utfcpp", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1b5418ed2adbfcc8c10ea751edef5057", + "name": "vtk", + "sha256": "f54eff5ce8880c4d3aa30f2eca10f00ede0e59b20d4d90e20fd5498338134f02", + "size": 28834506, + "subdir": "linux-64", + "timestamp": 1646116991743, + "version": "9.0.3" + }, + "vtk-9.0.3-py38hf89884c_202.conda": { + "build": "py38hf89884c_202", + "build_number": 202, + "constrains": [ + "paraview ==9999999999" + ], + "depends": [ + "double-conversion", + "eigen", + "expat >=2.4.9,<3.0a0", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "gl2ps >=1.4.2,<1.4.3.0a0", + "glew >=2.2.0,<2.3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "jsoncpp >=1.9.4,<1.9.5.0a0", + "libgcc-ng >=11.2.0", + "libnetcdf >=4.8.1,<5.0a0", + "libogg >=1.3.5,<1.4.0a0", + "libpng >=1.6.39,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.1.0,<5.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "loguru", + "lz4-c >=1.9.4,<1.10.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.8,<3.9.0a0", + "qt >=5.15.9,<5.16.0a0", + "qt >=5.15.9,<6.0a0", + "sqlite >=3.41.1,<4.0a0", + "tbb >=2021.7.0", + "tk >=8.6.12,<8.7.0a0", + "utfcpp", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eddec88a1d084d8ddd09ec623f230e47", + "name": "vtk", + "sha256": "9cc6cc0c81d0059f033474b22a5c5fe2158b7ad9fa5e9b6a800173bf001a25bf", + "size": 34170785, + "subdir": "linux-64", + "timestamp": 1679757213734, + "version": "9.0.3" + }, + "vtk-9.0.3-py39h0649366_201.conda": { + "build": "py39h0649366_201", + "build_number": 201, + "constrains": [ + "paraview ==9999999999" + ], + "depends": [ + "double-conversion", + "eigen", + "expat >=2.2.10,<3.0a0", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "gl2ps >=1.4.2,<1.4.3.0a0", + "glew >=2.1.0,<2.2.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9d,<10a", + "jsoncpp >=1.9.4,<1.9.5.0a0", + "libgcc-ng >=7.5.0", + "libnetcdf >=4.8.1,<5.0a0", + "libogg", + "libpng >=1.6.37,<1.7.0a0", + "libstdcxx-ng >=7.5.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.1.0,<5.0a0", + "libxml2 >=2.9.12,<2.10.0a0", + "loguru", + "lz4-c >=1.9.3,<1.10.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.9,<3.10.0a0", + "qt >=5.9.7,<5.10.0a0", + "qt >=5.9.7,<6.0a0", + "sqlite >=3.37.2,<4.0a0", + "tbb >=2021.5.0", + "tk >=8.6.11,<8.7.0a0", + "utfcpp", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6fa44f5f61c4d2e7f98c6ec30858d02c", + "name": "vtk", + "sha256": "c0da293aeb23114380ac13d907d1d4849b50d63f05f093f124ed254a70c05229", + "size": 28819344, + "subdir": "linux-64", + "timestamp": 1646119360333, + "version": "9.0.3" + }, + "vtk-9.0.3-py39hf89884c_202.conda": { + "build": "py39hf89884c_202", + "build_number": 202, + "constrains": [ + "paraview ==9999999999" + ], + "depends": [ + "double-conversion", + "eigen", + "expat >=2.4.9,<3.0a0", + "ffmpeg >=4.2.2,<4.3.0a0", + "freetype >=2.10.4,<3.0a0", + "gl2ps >=1.4.2,<1.4.3.0a0", + "glew >=2.2.0,<2.3.0a0", + "hdf5 >=1.10.6,<1.10.7.0a0", + "jpeg >=9e,<10a", + "jsoncpp >=1.9.4,<1.9.5.0a0", + "libgcc-ng >=11.2.0", + "libnetcdf >=4.8.1,<5.0a0", + "libogg >=1.3.5,<1.4.0a0", + "libpng >=1.6.39,<1.7.0a0", + "libstdcxx-ng >=11.2.0", + "libtheora >=1.1.1,<2.0a0", + "libtiff >=4.1.0,<5.0a0", + "libxml2 >=2.9.14,<2.10.0a0", + "loguru", + "lz4-c >=1.9.4,<1.10.0a0", + "proj >=6.2.1,<6.2.2.0a0", + "python >=3.9,<3.10.0a0", + "qt >=5.15.9,<5.16.0a0", + "qt >=5.15.9,<6.0a0", + "sqlite >=3.41.1,<4.0a0", + "tbb >=2021.7.0", + "tk >=8.6.12,<8.7.0a0", + "utfcpp", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "669182c1ecd591ab88c6f370d89a1cbc", + "name": "vtk", + "sha256": "b176967cd6d674d67e2ce646fe0beba1aaed29a9136dc6ac38d498afc126c16c", + "size": 34171284, + "subdir": "linux-64", + "timestamp": 1679754708005, + "version": "9.0.3" + }, + "vyper-config-1.1.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "distconfig3 >=1.0.1", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.4.1", + "toml >=0.10.0", + "watchdog >=0.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "01a28b93131746243f5eceb81a90e313", + "name": "vyper-config", + "sha256": "48b946bf468eb28211fab47d571033f4ad1ee86ed96dcff467ed750a07c172a9", + "size": 26909, + "subdir": "linux-64", + "timestamp": 1668696418490, + "version": "1.1.1" + }, + "vyper-config-1.1.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "distconfig3 >=1.0.1", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.4.1", + "toml >=0.10.0", + "watchdog >=0.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e33071d5e28b3b2ff6f88d77a2f50b26", + "name": "vyper-config", + "sha256": "c1765b8a2e7fd41bcdeeeb54a090af3721e9df9f30dbc132ea9fc265f67c843e", + "size": 32550, + "subdir": "linux-64", + "timestamp": 1676863516163, + "version": "1.1.1" + }, + "vyper-config-1.1.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "distconfig3 >=1.0.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=5.4.1", + "toml >=0.10.0", + "watchdog >=0.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be626f728101f406b7f5fcd37eb34700", + "name": "vyper-config", + "sha256": "0a1a50ce6c527239cfc374ee6fdc0f7fca55eea9769eb55dc7175102ef1c6afb", + "size": 26619, + "subdir": "linux-64", + "timestamp": 1668696389271, + "version": "1.1.1" + }, + "vyper-config-1.1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "distconfig3 >=1.0.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.4.1", + "toml >=0.10.0", + "watchdog >=0.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d90c8d228b1a9ea0b595bff1a9b0b546", + "name": "vyper-config", + "sha256": "475232f0162c2227395c6826932f8633a6f093e23ec52fd2d7e32ac0739753cc", + "size": 26657, + "subdir": "linux-64", + "timestamp": 1668696476537, + "version": "1.1.1" + }, + "vyper-config-1.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "distconfig3 >=1.0.1", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.4.1", + "toml >=0.10.0", + "watchdog >=0.10.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9b467134e5a0711be15af9b7b1f23ced", + "name": "vyper-config", + "sha256": "df50527eb43dfa5bfe59d7c94582a0e466bf3606ff6941839343bdc568934e3a", + "size": 26613, + "subdir": "linux-64", + "timestamp": 1668696447432, + "version": "1.1.1" + }, + "w3lib-1.18.0-py27hc2697b3_0.conda": { + "build": "py27hc2697b3_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "9df67a3beadb89e96d386cc2898f2ee9", + "name": "w3lib", + "sha256": "f413e4772a285326edb61adc85d7520c232d964734f973c32870f2ab5da74021", + "size": 30813, + "subdir": "linux-64", + "timestamp": 1507834880083, + "version": "1.18.0" + }, + "w3lib-1.18.0-py35hc71e62e_0.conda": { + "build": "py35hc71e62e_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "185797152c0657c1b56bc5ddef1d2de4", + "name": "w3lib", + "sha256": "c41e6fc8168e305253abd9d23766bd7c4871cb45fa09cda79b10cca3867cab59", + "size": 30693, + "subdir": "linux-64", + "timestamp": 1507834899629, + "version": "1.18.0" + }, + "w3lib-1.18.0-py36hc34d9f4_0.conda": { + "build": "py36hc34d9f4_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "15f0d47936b2297e517f19dc21d7c149", + "name": "w3lib", + "sha256": "797912870dfe964ac6e7f4d197e381a0f7395f275b94677bf8803e3c69601dc5", + "size": 30722, + "subdir": "linux-64", + "timestamp": 1507834907878, + "version": "1.18.0" + }, + "w3lib-1.19.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "3d0820d1bbdea9e2cc94779bef778fbf", + "name": "w3lib", + "sha256": "b50adc02f32fa0dc2c2095aa20a861b4efb06808886d7d04cbbe289a793f711b", + "size": 30470, + "subdir": "linux-64", + "timestamp": 1519671826621, + "version": "1.19.0" + }, + "w3lib-1.19.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "11c91382156141e4bdd427479b3d9055", + "name": "w3lib", + "sha256": "15562936b7952a6af707ed52bfa7edf44da0f08912775bd34b14a567cfe2eb2a", + "size": 30628, + "subdir": "linux-64", + "timestamp": 1519671862740, + "version": "1.19.0" + }, + "w3lib-1.19.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "1dc080727348d476066faf2339872472", + "name": "w3lib", + "sha256": "b31309e2d8af5a5c1c0d5396b5b994ff059831928d052a76877f9198015fc8e3", + "size": 30694, + "subdir": "linux-64", + "timestamp": 1519671896701, + "version": "1.19.0" + }, + "w3lib-1.19.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "67e284f00e4bcb2e4a588837949707a0", + "name": "w3lib", + "sha256": "18421a06905f6c6826c24540f86176be9f686544c4fbfa998a65cc5d526632c9", + "size": 30262, + "subdir": "linux-64", + "timestamp": 1530904799126, + "version": "1.19.0" + }, + "w3lib-1.20.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "59ad4e228aa59c73041be6a5771ebcc3", + "name": "w3lib", + "sha256": "51501ab9846af20b5cbf602830e0caf9bbe6742c600e28e4d50092071ff40a81", + "size": 173816, + "subdir": "linux-64", + "timestamp": 1547927144305, + "version": "1.20.0" + }, + "w3lib-1.20.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "29ceefb15503f328efa3d4febb92b592", + "name": "w3lib", + "sha256": "939e651a579c00b40c16cf511d090c556c1e6cfb3608cef71dabac703f38c17f", + "size": 174090, + "subdir": "linux-64", + "timestamp": 1547927290670, + "version": "1.20.0" + }, + "w3lib-1.20.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six >=1.4.1" + ], + "license": "BSD", + "md5": "c3e45628ac003b545b5fe581993f552e", + "name": "w3lib", + "sha256": "e773e246c73534da21cb303d3edfeaa40a5063e273c3e4fa541074e30e6c8195", + "size": 173755, + "subdir": "linux-64", + "timestamp": 1547927236075, + "version": "1.20.0" + }, + "waf-2.0.18-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "588e13f6f43a93956d7b9a3a577663aa", + "name": "waf", + "sha256": "48df52896238e0195e5abd50078de22908b7232020dd5aa3ffce7f215160b67d", + "size": 113529, + "subdir": "linux-64", + "timestamp": 1569435946443, + "version": "2.0.18" + }, + "waf-2.0.18-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "efba78f49f8ac132ae34c3be7fa8839a", + "name": "waf", + "sha256": "d84742942365420a2f3111c16ffff5c15c3a17aaa4527cf5246bfc0c05f9287d", + "size": 113528, + "subdir": "linux-64", + "timestamp": 1569435954983, + "version": "2.0.18" + }, + "waf-2.0.18-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5cd0cbe3306d18867246b31179ac2ec1", + "name": "waf", + "sha256": "4cf6b24194a1c029ee25dabe8b2a6ec9b5a761b7d6ce691a3387bc2067d84399", + "size": 113519, + "subdir": "linux-64", + "timestamp": 1569436047839, + "version": "2.0.18" + }, + "waf-2.0.18-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a50a9e8b42a3c0db413e34dac7cf6069", + "name": "waf", + "sha256": "f642a0d2dd8cb3b591af884c8887fd8ef7306e16befbca863f6fa6969708fb19", + "size": 111103, + "subdir": "linux-64", + "timestamp": 1573200427429, + "version": "2.0.18" + }, + "waf-2.0.20-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c01a2c141db25ef229e4747ff563bc88", + "name": "waf", + "sha256": "54df540a98d2d47f61b070a4b8edade1903e8f1e9d2f96198e76ea3dbad2e406", + "size": 110868, + "subdir": "linux-64", + "timestamp": 1600470410497, + "version": "2.0.20" + }, + "waf-2.0.20-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5e6b90abca24fab22028d06e9af5d1a2", + "name": "waf", + "sha256": "308eaf919bf845d49037921476c2c96ed789f9e44c35fdfc544ea50db2f9b7ae", + "size": 110852, + "subdir": "linux-64", + "timestamp": 1600470410843, + "version": "2.0.20" + }, + "waf-2.0.20-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1a69c06d219589d6fe5aaca5c75f205a", + "name": "waf", + "sha256": "4912bc94494bd039f63d4eb094f1f3da1b0ab75ad5d87ec716f8b621970940a8", + "size": 111025, + "subdir": "linux-64", + "timestamp": 1600470432988, + "version": "2.0.20" + }, + "waf-2.0.21-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5d8190431c8a185f7d9deced9a156542", + "name": "waf", + "sha256": "f571590f42627d87ce9767a9d4bd2daff09ab10e202f4e9642bee0736708a0b3", + "size": 110965, + "subdir": "linux-64", + "timestamp": 1606939071598, + "version": "2.0.21" + }, + "waf-2.0.21-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "53ad8bd83f3f20b7dcaf10f5a7fbd103", + "name": "waf", + "sha256": "f664162c57f8eb58b5d3ec78b663c60f9ec69b39baf3c9720da667d1cec59357", + "size": 110959, + "subdir": "linux-64", + "timestamp": 1606939075812, + "version": "2.0.21" + }, + "waf-2.0.21-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5b0f74941f25fe9a351f3bae08836b92", + "name": "waf", + "sha256": "47988fcd62153cfab38d9a1e9acd93c031aa3a3a3f185d8e6701279e73f61834", + "size": 111209, + "subdir": "linux-64", + "timestamp": 1606939071597, + "version": "2.0.21" + }, + "waf-2.0.21-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9aef123c17d067c768b0aa52feafa1eb", + "name": "waf", + "sha256": "ca560e949c89cdb9b2b6a203a5f3d871833f954d6fb74921e70ce33eed9ffc29", + "size": 111210, + "subdir": "linux-64", + "timestamp": 1606939091759, + "version": "2.0.21" + }, + "waf-2.0.22-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "md5": "de98e11ca752a26751b7fc8db12ac252", + "name": "waf", + "sha256": "caa3b72447d434d06e5aa9ee94345687137d31f85896b0b18a4d4442844c5f51", + "size": 111611, + "subdir": "linux-64", + "timestamp": 1640795846381, + "version": "2.0.22" + }, + "waf-2.0.22-py311h5eee18b_1.conda": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "md5": "83027738eaf2158c0ff15dde4e040a12", + "name": "waf", + "sha256": "f23cac65483c18908f25022dfdc64e9171fab5f7cef6d920cccf73add4995825", + "size": 111689, + "subdir": "linux-64", + "timestamp": 1676838901118, + "version": "2.0.22" + }, + "waf-2.0.22-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d3b8fc4257ac3b5629a57caa217281d1", + "name": "waf", + "sha256": "9974cdcaafe1f6bf6604877ff6d66cb5429c718943293452920910e6ac79997c", + "size": 111025, + "subdir": "linux-64", + "timestamp": 1614626021794, + "version": "2.0.22" + }, + "waf-2.0.22-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5027d266f56a696524dd0dfbb01736d3", + "name": "waf", + "sha256": "93dc588816b32143d7ca4953aee47d8d7d1090de32d756ebd2cd54e4e4f07f4f", + "size": 111051, + "subdir": "linux-64", + "timestamp": 1614630641646, + "version": "2.0.22" + }, + "waf-2.0.22-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "22e15486926d58098d29fa182da69c59", + "name": "waf", + "sha256": "f68b22c514379fbbb8ab4d53d44d0b96e62619492d657e964beab5f6279cad8a", + "size": 111158, + "subdir": "linux-64", + "timestamp": 1614624825742, + "version": "2.0.22" + }, + "waf-2.0.22-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "md5": "0cd554ee9734b0ce7e357c7578aab7b9", + "name": "waf", + "sha256": "a57960ebfc57fbc16b1974271ea3f5a5517d5e616d9878ff31bc10078ed11961", + "size": 111179, + "subdir": "linux-64", + "timestamp": 1614625993551, + "version": "2.0.22" + }, + "waf-2.0.8-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "09f262b6ed7cb09b091d7119273ed29f", + "name": "waf", + "sha256": "50ce586ae4bc72e249f73d824dd2bc86e8a261907b9075d05cddceeafa96d484", + "size": 111770, + "subdir": "linux-64", + "timestamp": 1561613145990, + "version": "2.0.8" + }, + "waf-2.0.8-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1115975a2c94933f0df93aa3a4ed9b72", + "name": "waf", + "sha256": "05ee0913c9872d325413708ed020ea30007d26625ea14638afe0737f53f45047", + "size": 111772, + "subdir": "linux-64", + "timestamp": 1561613178512, + "version": "2.0.8" + }, + "waf-2.0.8-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d0001a520ce0b09e20adb9fb4ba66600", + "name": "waf", + "sha256": "16db8f9e3fbe2e632bccafe1b73947d3c5b4db6aed517a97ac523b7db6f9105f", + "size": 111752, + "subdir": "linux-64", + "timestamp": 1561613135234, + "version": "2.0.8" + }, + "waitress-1.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "479cfb4a9b6566668f58c02cf2acc399", + "name": "waitress", + "sha256": "ad07bac16974c2de073e3865b4b82eefbf9299c41556a65dc536a6fb1f7e60bf", + "size": 160181, + "subdir": "linux-64", + "timestamp": 1530875724183, + "version": "1.1.0" + }, + "waitress-1.1.0-py27ha0b65e1_0.conda": { + "build": "py27ha0b65e1_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "1b1a0c583c43a2af74295c50aa7245db", + "name": "waitress", + "sha256": "88fa88bda50539b9e4464364164de316087fb97700b6a4c3a98e8ac77945b487", + "size": 159487, + "subdir": "linux-64", + "timestamp": 1507983539258, + "version": "1.1.0" + }, + "waitress-1.1.0-py35h0c2a5b4_0.conda": { + "build": "py35h0c2a5b4_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "83b98007bc9c13d0f91a78080f081928", + "name": "waitress", + "sha256": "8e1af126c6eb0e42d91f22d2b3d69fba7fe600613aff7a8a5fdff63550d2e787", + "size": 163266, + "subdir": "linux-64", + "timestamp": 1507983553745, + "version": "1.1.0" + }, + "waitress-1.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "4d9b718a36dcd48866b109afe9fe23ae", + "name": "waitress", + "sha256": "a6054d24df7f8993a69e9e7972f4ce6db0c4e555a9d03ebeeec1b3c4a9bd24cc", + "size": 161970, + "subdir": "linux-64", + "timestamp": 1530875669888, + "version": "1.1.0" + }, + "waitress-1.1.0-py36hd6e6ebe_0.conda": { + "build": "py36hd6e6ebe_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "5eb6c1e1ddf8eeead104c45ef819fc66", + "name": "waitress", + "sha256": "9bb714ae873d6051e682cf86d520afb52b30af4a34597551f45ace4b41558c0e", + "size": 162168, + "subdir": "linux-64", + "timestamp": 1507983554677, + "version": "1.1.0" + }, + "waitress-1.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "50ada2322aef6e4657615b7294184c92", + "name": "waitress", + "sha256": "627cb1010eb8393196cd83049f775393faa42a8ee444c60bdab25e1ae35e759a", + "size": 161743, + "subdir": "linux-64", + "timestamp": 1530875697476, + "version": "1.1.0" + }, + "waitress-1.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "52a6f2676bc2230c35c4feb2dfe5c578", + "name": "waitress", + "sha256": "5d440cc558c081a73805d21dd09c17603bd3d38250a4adf378be320f750119a8", + "size": 350920, + "subdir": "linux-64", + "timestamp": 1547984486121, + "version": "1.2.0" + }, + "waitress-1.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "14d88d18bbdeab0867689ad3bd623753", + "name": "waitress", + "sha256": "56433b1697ec54689d4c036381229c1d876d52b4c50508d2c4e94b5ba893c3b7", + "size": 355143, + "subdir": "linux-64", + "timestamp": 1547984586726, + "version": "1.2.0" + }, + "waitress-1.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "7390ce417e11501387463fb0d31b03a6", + "name": "waitress", + "sha256": "965c540938c1a07cb4fb80d10cf700ba34ac8c5c86e0e53bba699f193e3408eb", + "size": 354826, + "subdir": "linux-64", + "timestamp": 1547984526003, + "version": "1.2.0" + }, + "waitress-1.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "d1094cc9ca4bd0b7f660ccdd86aed225", + "name": "waitress", + "sha256": "285225ce1e6140da6915d5f6eeb038267c4b75a43d1c303da64b35187ddaafef", + "size": 359477, + "subdir": "linux-64", + "timestamp": 1550431957184, + "version": "1.2.1" + }, + "waitress-1.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "2b4124103591b632d5127029430dd3df", + "name": "waitress", + "sha256": "61966bee4c68b02b349d2590f0b3c2f1581930f97d63c225bf467da944fd1f60", + "size": 361991, + "subdir": "linux-64", + "timestamp": 1550431974226, + "version": "1.2.1" + }, + "waitress-1.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "3b30a0732ced23fafea9f439115b9212", + "name": "waitress", + "sha256": "abf386992b2c53c0f8ae8cead5bb2a4e1d9f6e54aa78bc45d4b95564b12bdbe5", + "size": 361009, + "subdir": "linux-64", + "timestamp": 1550431958021, + "version": "1.2.1" + }, + "waitress-1.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "bb61029dbc0ef2152e1f8f370685f9ba", + "name": "waitress", + "sha256": "cda8f646f1190f80468b8bd3aa9275584670f5ccff23154da07b1b9c5b638dee", + "size": 370998, + "subdir": "linux-64", + "timestamp": 1564711261050, + "version": "1.3.0" + }, + "waitress-1.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "f0598cc3759ce665520eaf5558f288ca", + "name": "waitress", + "sha256": "0e373b294bf95202ac9050d333e2d9d10f99e077075170eaeb52659eb8531347", + "size": 375912, + "subdir": "linux-64", + "timestamp": 1564711288315, + "version": "1.3.0" + }, + "waitress-1.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "90bfc1869c43563a06668c165233e239", + "name": "waitress", + "sha256": "07da119a9299473c5676f3cc4b0769bdb447b9ad03fa2f4e10109984b8664539", + "size": 373535, + "subdir": "linux-64", + "timestamp": 1564711257174, + "version": "1.3.0" + }, + "wasabi-0.9.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "90b72b146f5a8919397acdd99831c4fd", + "name": "wasabi", + "sha256": "0cde09621d9cacbdb0d186d822f8d89f678d0983bf09700ebc3c93123ebe4494", + "size": 41946, + "subdir": "linux-64", + "timestamp": 1651237360650, + "version": "0.9.1" + }, + "wasabi-0.9.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5a2a68f47720ecd0825ee304229ecc1f", + "name": "wasabi", + "sha256": "5f521134ec9b3b7c2ad987b7a39e0ed6c577005bfeee13be1cf18138964efd6b", + "size": 50480, + "subdir": "linux-64", + "timestamp": 1676843051174, + "version": "0.9.1" + }, + "wasabi-0.9.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b2956f8ab69c1ad5a3e1337e57c784ec", + "name": "wasabi", + "sha256": "09bf590ff76aee24d26aa907f2d47185aac15aebbb3c6def53a198dfadfaff77", + "size": 41505, + "subdir": "linux-64", + "timestamp": 1651237434264, + "version": "0.9.1" + }, + "wasabi-0.9.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7c0914a8b5a088f7634535a47ebd72ef", + "name": "wasabi", + "sha256": "26a79fe4563498b13dec608e4424e511862f5ac0afd6e3457ab0fb185211bf62", + "size": 41740, + "subdir": "linux-64", + "timestamp": 1651237470063, + "version": "0.9.1" + }, + "wasabi-0.9.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f13d681fc330ddf8b4fdc5527edb9260", + "name": "wasabi", + "sha256": "62c232c45f984b129c281110f38b4c1635e5460067bfe7e876751d1f86cc8f5d", + "size": 41649, + "subdir": "linux-64", + "timestamp": 1651237397959, + "version": "0.9.1" + }, + "watchdog-0.10.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "28fa4738b67427bf33638cec772d6bc5", + "name": "watchdog", + "sha256": "b906708a92b651da8a180519be552e310731a831c7bd27024c4175351efaba61", + "size": 95223, + "subdir": "linux-64", + "timestamp": 1580838480220, + "version": "0.10.1" + }, + "watchdog-0.10.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "379ebcfe2dc576fd688a2d253d3445e7", + "name": "watchdog", + "sha256": "68346fde8ea9a1da35a51e8ea22961d077908ab7ebfc4cd9b594d4658f935f3d", + "size": 93629, + "subdir": "linux-64", + "timestamp": 1580838464561, + "version": "0.10.1" + }, + "watchdog-0.10.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "b2ad6f5ff83ec39854b94b0820cdad6b", + "name": "watchdog", + "sha256": "f396cfd887bdee29d31eb5cf2acf012b94baaa21c8a2385f31439459315a263b", + "size": 94571, + "subdir": "linux-64", + "timestamp": 1580838599948, + "version": "0.10.1" + }, + "watchdog-0.10.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "3301d93a65e98e8f18820c17f88b7531", + "name": "watchdog", + "sha256": "0b73e49b3e9e62a6eb2fe8300a82ac493afbff365fe1b4b1e5472d047b2f8091", + "size": 93516, + "subdir": "linux-64", + "timestamp": 1581354492921, + "version": "0.10.2" + }, + "watchdog-0.10.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "fb68365d1a43bee6db01da0df9577255", + "name": "watchdog", + "sha256": "ffa0e708663fbb816db316223ae339e6803c14691c6419e750a28b7fd1b2907c", + "size": 95519, + "subdir": "linux-64", + "timestamp": 1581354416911, + "version": "0.10.2" + }, + "watchdog-0.10.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "15f1dc43e56a376037fc11f02e714513", + "name": "watchdog", + "sha256": "5aa750c8f33a7e9824ef26922b23fafa1ddfb96c28c963205bccbd6d90ef5f62", + "size": 94737, + "subdir": "linux-64", + "timestamp": 1581354495028, + "version": "0.10.2" + }, + "watchdog-0.10.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "a1f4ab3f357c2604a8a1f82d9111828a", + "name": "watchdog", + "sha256": "5f1c3678eb7fbea42fe94b7c8a2ddb4e5d5a3e9889aff1927793699e2dd1831f", + "size": 94878, + "subdir": "linux-64", + "timestamp": 1593447372182, + "version": "0.10.3" + }, + "watchdog-0.10.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "01fa93d79d489dbb2b09f95da9988804", + "name": "watchdog", + "sha256": "b8acb92f4afdfc2fe8a8198e7301937c37d376679b9537fb29fc1a1409dc18b5", + "size": 94572, + "subdir": "linux-64", + "timestamp": 1593447329924, + "version": "0.10.3" + }, + "watchdog-0.10.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "a45cfc5b7c1d409882f15dcf11ce7a2f", + "name": "watchdog", + "sha256": "d53beb725592729053a09f5077c7a133b5c8815ccd16092736df87e7a61ce87b", + "size": 94835, + "subdir": "linux-64", + "timestamp": 1593447370162, + "version": "0.10.3" + }, + "watchdog-0.10.4-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "47efe8743518787811378f2bb556fd5e", + "name": "watchdog", + "sha256": "b5028f0372e373a43d5d9a49f13743e47a2ed77f9806a60a929c6c5cb10ea2db", + "size": 93822, + "subdir": "linux-64", + "timestamp": 1606939099406, + "version": "0.10.4" + }, + "watchdog-0.10.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "2c9512a6db3faa6770e2ee28eecc5f05", + "name": "watchdog", + "sha256": "770170dcfe88890e123a519f03dff70ea0de526049504cf7d452e65f01ea6dde", + "size": 92043, + "subdir": "linux-64", + "timestamp": 1606939093742, + "version": "0.10.4" + }, + "watchdog-0.10.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "f4e6771865cf77eb302257a6377918fe", + "name": "watchdog", + "sha256": "0246c11a41b0b951d14d4e2fc116acf856e64ac08e3e57465c00c850189467fb", + "size": 92325, + "subdir": "linux-64", + "timestamp": 1606939129565, + "version": "0.10.4" + }, + "watchdog-0.10.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "4b90632d2b52c8199ac1b6158f1cb793", + "name": "watchdog", + "sha256": "74b5e732d7b6f1bff509f04cd660ce860e9434ae08d5027ce50f3869319b875f", + "size": 97144, + "subdir": "linux-64", + "timestamp": 1607530063564, + "version": "0.10.4" + }, + "watchdog-0.9.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=2.7,<2.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "6b883a10274740b151c8d1d6decee6c3", + "name": "watchdog", + "sha256": "521b818e231b2bab531ba4fa0b846322a8b1688184ff2b330551e7183d0acbb2", + "size": 94239, + "subdir": "linux-64", + "timestamp": 1575416422784, + "version": "0.9.0" + }, + "watchdog-0.9.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "e220ce9e3b1ce1dea77905b12653d68a", + "name": "watchdog", + "sha256": "81b0d0483cff45922c4467540225bf82251e504b8eedf1aac98641aa2770fbbb", + "size": 95646, + "subdir": "linux-64", + "timestamp": 1575416382026, + "version": "0.9.0" + }, + "watchdog-0.9.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "f4378fc192d0335ebb3d1b63d2b95a64", + "name": "watchdog", + "sha256": "03258d53c25277a175f731021ff728997f77fd74bc846be0c47d590e85089447", + "size": 95553, + "subdir": "linux-64", + "timestamp": 1575416459376, + "version": "0.9.0" + }, + "watchdog-0.9.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "argh >=0.24.1", + "pathtools >=0.1.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10" + ], + "license": "Apache 2.0", + "md5": "03603e8f259dc656c01d312bf89ea893", + "name": "watchdog", + "sha256": "ce48e855f9af768dfceca69bcd8c69c236a53f0e598fd3eae4363e4e1f5e4406", + "size": 96064, + "subdir": "linux-64", + "timestamp": 1575416459870, + "version": "0.9.0" + }, + "watchdog-1.0.2-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "argh >=0.24.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "3fd875109f944863857302aa8f29775f", + "name": "watchdog", + "sha256": "fbf753d212980413312dd39a0fd1641aaf34d8d71a40a2ac356f94d8c79bef08", + "size": 89750, + "subdir": "linux-64", + "timestamp": 1612471170375, + "version": "1.0.2" + }, + "watchdog-1.0.2-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "argh >=0.24.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "8c8e6efe7581cf5e3c2e80aa4bfe581a", + "name": "watchdog", + "sha256": "45900ecc68b87399f80a25d57fed5c0cddd74c323a2e6d9662ce62ca0e286579", + "size": 91651, + "subdir": "linux-64", + "timestamp": 1612471164401, + "version": "1.0.2" + }, + "watchdog-1.0.2-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "argh >=0.24.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "f305871e65f99dd850c9579d8823d8fa", + "name": "watchdog", + "sha256": "46d15a8ca1db67ca6d42c2dc4a4a1556edab2452450ce74b377dc860a97ad8f5", + "size": 90900, + "subdir": "linux-64", + "timestamp": 1612471077817, + "version": "1.0.2" + }, + "watchdog-1.0.2-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "argh >=0.24.1", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "6fe7846e2f4f25290b893cf26c68c50b", + "name": "watchdog", + "sha256": "b9aa6aab5b7995c3db061f4b0fb6fc5826a26ec01d88286c7647faa90003c5cf", + "size": 92065, + "subdir": "linux-64", + "timestamp": 1612471167917, + "version": "1.0.2" + }, + "watchdog-2.1.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "argh >=0.24.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "d56770258ebb906d2884a67780dfa9d2", + "name": "watchdog", + "sha256": "c215ebeae64fe79c24a2ecc2e6c89b5fbabc6eef896ec92a2e5f4e3558407a2e", + "size": 94975, + "subdir": "linux-64", + "timestamp": 1620778287704, + "version": "2.1.1" + }, + "watchdog-2.1.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "argh >=0.24.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "5e79b6546823d4df04e169016901afb9", + "name": "watchdog", + "sha256": "5a7c213c519c60a50936ea4a60fd09b96d12a24418a542daccd0e9bd28845b9c", + "size": 95052, + "subdir": "linux-64", + "timestamp": 1620778285799, + "version": "2.1.1" + }, + "watchdog-2.1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "argh >=0.24.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "aa1d30f0f8563938be92187fb618518f", + "name": "watchdog", + "sha256": "592b750d07177d35e7ae5491fe72b92159609176e1e7ad1c21c3aeb8b7eb52b4", + "size": 93508, + "subdir": "linux-64", + "timestamp": 1620778241018, + "version": "2.1.1" + }, + "watchdog-2.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "argh >=0.24.1", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "md5": "2116294321ff616788d39658da4951e0", + "name": "watchdog", + "sha256": "3875a4363c17bd1e870e854d44438cb4050b23b27fffc86aa3f5c3eb1ebd7b2f", + "size": 93506, + "subdir": "linux-64", + "timestamp": 1620773990409, + "version": "2.1.1" + }, + "watchdog-2.1.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "argh >=0.24.1", + "python >=3.6,<3.7.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5219c0c533ed5caf986d226007afe3e6", + "name": "watchdog", + "sha256": "8b6af1ce662a4798a4ec93904fd2a2b7831ea1d01b491fe0941ee6875847f322", + "size": 94585, + "subdir": "linux-64", + "timestamp": 1624955050969, + "version": "2.1.3" + }, + "watchdog-2.1.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "argh >=0.24.1", + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ebec32f83e4f2d1466d116777473fc50", + "name": "watchdog", + "sha256": "d0ef573534ac430e9051405073476fe81a006602810f872307e1571d1c4b827d", + "size": 94742, + "subdir": "linux-64", + "timestamp": 1624955030969, + "version": "2.1.3" + }, + "watchdog-2.1.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "argh >=0.24.1", + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b27e2ef40935d37b5bf3e85dab2df561", + "name": "watchdog", + "sha256": "0a87ea5adf405ca3fdead66f45bfef531dca1373afe6f1e7f8ad7a791092a98e", + "size": 95215, + "subdir": "linux-64", + "timestamp": 1624948613247, + "version": "2.1.3" + }, + "watchdog-2.1.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "argh >=0.24.1", + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ef04bb0de144d3f0fb2781d65b9593ef", + "name": "watchdog", + "sha256": "ae4f3b9278d5622e7985b6382341984324e4288e1951b8e301490be56aef2b64", + "size": 95436, + "subdir": "linux-64", + "timestamp": 1624955043256, + "version": "2.1.3" + }, + "watchdog-2.1.6-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "python >=3.10,<3.11.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9b3a950d2244ab14165faf02c50602a9", + "name": "watchdog", + "sha256": "5cc1b116a205397d8c2e30b0477d7398320dce1955aaf780e53e358a1436a5fc", + "size": 98589, + "subdir": "linux-64", + "timestamp": 1640811355374, + "version": "2.1.6" + }, + "watchdog-2.1.6-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "python >=3.11,<3.12.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "667badae77189e0857ea71395da8149a", + "name": "watchdog", + "sha256": "a374cec014abc86aee1ecfee2708912ce80de8daa51174d712638bd2eedab46c", + "size": 125359, + "subdir": "linux-64", + "timestamp": 1676846203886, + "version": "2.1.6" + }, + "watchdog-2.1.6-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "python >=3.7,<3.8.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0adc30bd48bafd6db2f3827017a7eed3", + "name": "watchdog", + "sha256": "c33efa6048f4946c5b5b5ff2a4df4e53917f79fbae122e6d43f24c980c0c6acb", + "size": 96610, + "subdir": "linux-64", + "timestamp": 1638367318147, + "version": "2.1.6" + }, + "watchdog-2.1.6-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "python >=3.8,<3.9.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0aeebb8504f24dc2aa9797e3b3da6015", + "name": "watchdog", + "sha256": "a57b572d7f789a7c2d3904e66ed2a6744ca0a77ca441a2b7e10e69a7ddf7e50d", + "size": 95533, + "subdir": "linux-64", + "timestamp": 1638366592042, + "version": "2.1.6" + }, + "watchdog-2.1.6-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "__osx >=10.13" + ], + "depends": [ + "python >=3.9,<3.10.0a0", + "pyyaml >=3.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a2494b6d1b72f6ddd8ccca4e2cce9577", + "name": "watchdog", + "sha256": "ee6936a07db6e85cfabb25ef585735e3819316d42e6ab7f7b76fcd3243580de6", + "size": 97159, + "subdir": "linux-64", + "timestamp": 1638367309504, + "version": "2.1.6" + }, + "watchfiles-0.18.1-py310h52d8a92_0.conda": { + "build": "py310h52d8a92_0", + "build_number": 0, + "depends": [ + "anyio >=3.0.0,<4", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "18855075f03b4578cd0e71a4ca4c414c", + "name": "watchfiles", + "sha256": "fd481bc75c4beec53ac912fa2a61f2b2e9f58bcdb567a6d7322cb593aa8b8764", + "size": 1079955, + "subdir": "linux-64", + "timestamp": 1677830339601, + "version": "0.18.1" + }, + "watchfiles-0.18.1-py38h52d8a92_0.conda": { + "build": "py38h52d8a92_0", + "build_number": 0, + "depends": [ + "anyio >=3.0.0,<4", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "056088b524fbdf20979f6bcec6267f2b", + "name": "watchfiles", + "sha256": "ddfec5db355fd18325a4355474a3d7ed6e93b34a06bc3f12d10b91beba3c05d6", + "size": 1078804, + "subdir": "linux-64", + "timestamp": 1677830482864, + "version": "0.18.1" + }, + "watchfiles-0.18.1-py39h52d8a92_0.conda": { + "build": "py39h52d8a92_0", + "build_number": 0, + "depends": [ + "anyio >=3.0.0,<4", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "007d49ec4e16920344e8b775fb3ec274", + "name": "watchfiles", + "sha256": "7df4d284437d1a224592a3268bbdc15f4aceb3af5c7122eca68e49f9fead5f6b", + "size": 1078829, + "subdir": "linux-64", + "timestamp": 1677830624215, + "version": "0.18.1" + }, + "wcwidth-0.1.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "26277099fcc2d63d4baabf5ed89dd396", + "name": "wcwidth", + "sha256": "0e4a8e70f9c8056296b5cac22d21396509f7737bfc755ac469be236b3227bce7", + "size": 24328, + "subdir": "linux-64", + "timestamp": 1530733740471, + "version": "0.1.7" + }, + "wcwidth-0.1.7-py27h9e3e1ab_0.conda": { + "build": "py27h9e3e1ab_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "b1bebed23b691f50bd29075c4455bbf0", + "name": "wcwidth", + "sha256": "b3b8a3328c254e1f72f1895874e1a61f26ec969d146e58c4793bd3e8332896d0", + "size": 24142, + "subdir": "linux-64", + "timestamp": 1505864079686, + "version": "0.1.7" + }, + "wcwidth-0.1.7-py35hcd08066_0.conda": { + "build": "py35hcd08066_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "0500513daa24db20d330d646d8b59b94", + "name": "wcwidth", + "sha256": "b4e916c74faed4895ee44a335cba837bb5eaf9d342c2a7fa68f630a3f4f90c02", + "size": 23959, + "subdir": "linux-64", + "timestamp": 1505864091824, + "version": "0.1.7" + }, + "wcwidth-0.1.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "5eef5531c1a0a7ded354eacfd9212180", + "name": "wcwidth", + "sha256": "4c50b9140e1f1a217337c3547af45de020fd3dafdb1778ab68f60b2c12c5a031", + "size": 24307, + "subdir": "linux-64", + "timestamp": 1530733720757, + "version": "0.1.7" + }, + "wcwidth-0.1.7-py36hdf4376a_0.conda": { + "build": "py36hdf4376a_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "24bf91be25dc391afa846a8edd9b54c5", + "name": "wcwidth", + "sha256": "4dd8c682cb05a43f8c9e059ee60f85bb0a9e1bcab9a220bdf7ef4cee176d48af", + "size": 24152, + "subdir": "linux-64", + "timestamp": 1505864104033, + "version": "0.1.7" + }, + "wcwidth-0.1.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "68e51a21b2eed2eca3678fb7f9cce66c", + "name": "wcwidth", + "sha256": "ba002668a9beec07f283d09ac27055709157828876b826f615ef1bf9a935d658", + "size": 22440, + "subdir": "linux-64", + "timestamp": 1530733760749, + "version": "0.1.7" + }, + "wcwidth-0.1.7-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "md5": "c4b203309ec7a3d2029f2b72f31ef474", + "name": "wcwidth", + "sha256": "9d059246096dc860115c0f3d3f132c02d688dc89787f390eac56afb65781ba3f", + "size": 23262, + "subdir": "linux-64", + "timestamp": 1572609159880, + "version": "0.1.7" + }, + "webencodings-0.5.1-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8d009a08290f15f8685b83d3ac2cf732", + "name": "webencodings", + "sha256": "40ef24935fba52016e86c0b589994dbec73a91cbff4925293d92463959ddc53f", + "size": 19933, + "subdir": "linux-64", + "timestamp": 1530734107231, + "version": "0.5.1" + }, + "webencodings-0.5.1-py27hff10b21_1.conda": { + "build": "py27hff10b21_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d6a281200b201c0d91e08f085c35ae4d", + "name": "webencodings", + "sha256": "376bc863d0af423eb2a1e18f3ed0b301b337e6101a96ca420c965264e93783c1", + "size": 19659, + "subdir": "linux-64", + "timestamp": 1505688679735, + "version": "0.5.1" + }, + "webencodings-0.5.1-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "bf910a6e6f99eb6d9d2ba14bd7b7c066", + "name": "webencodings", + "sha256": "c031b6297f70e3012230c1c7ed9ba6d0260c8dc4d775bcafe9587d0c13b6b2ce", + "size": 20975, + "subdir": "linux-64", + "timestamp": 1640795864430, + "version": "0.5.1" + }, + "webencodings-0.5.1-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "6018ed8d17895b6f25113820aefae941", + "name": "webencodings", + "sha256": "98bab546fa7efbd93e44394142fb378b1c58f18a9b7e5306dc8d95e729d2fa98", + "size": 25208, + "subdir": "linux-64", + "timestamp": 1676823132898, + "version": "0.5.1" + }, + "webencodings-0.5.1-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c8e52cd047158edebfc6260ff3a9061b", + "name": "webencodings", + "sha256": "1adbc7f1295df6823799dcd2a63b88d4dfbfd61deed67da96633a341b8870db1", + "size": 19920, + "subdir": "linux-64", + "timestamp": 1534350855539, + "version": "0.5.1" + }, + "webencodings-0.5.1-py35hb6cf162_1.conda": { + "build": "py35hb6cf162_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c4748c2a1b9224481b57e560326688d0", + "name": "webencodings", + "sha256": "85157a2cd8f425f34263ec4777b56e465fe44b3825c65f4f21694f68248355e1", + "size": 19626, + "subdir": "linux-64", + "timestamp": 1505688690700, + "version": "0.5.1" + }, + "webencodings-0.5.1-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "73b1177890408343a659228f812e1dac", + "name": "webencodings", + "sha256": "cc40c964108a35d1a17e7102c214adb7de94d080407a1aaec7788025125f5bdc", + "size": 19436, + "subdir": "linux-64", + "timestamp": 1530734087663, + "version": "0.5.1" + }, + "webencodings-0.5.1-py36h800622e_1.conda": { + "build": "py36h800622e_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "3d13f074eee8d8e7618bb07e1edab4e5", + "name": "webencodings", + "sha256": "0c03d8ad0d526dbdbcced7973713a9d36a6949be2e80a5be7c9d1b853a44888f", + "size": 19280, + "subdir": "linux-64", + "timestamp": 1505688701757, + "version": "0.5.1" + }, + "webencodings-0.5.1-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fa2171c719f1d6be393dbe70fb9508fe", + "name": "webencodings", + "sha256": "b7f6a306123709b9f357a9d6d38ddc93f195bc80d1eaaf36405b0bcbdf87315b", + "size": 19553, + "subdir": "linux-64", + "timestamp": 1530734127084, + "version": "0.5.1" + }, + "webencodings-0.5.1-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "5c9a80af48919815917612e58474a391", + "name": "webencodings", + "sha256": "4960e28532cceefc6ba7fe7afa87ce4d5d00abd2cc51b5e87e9f796d2341102c", + "size": 20101, + "subdir": "linux-64", + "timestamp": 1573200372707, + "version": "0.5.1" + }, + "webencodings-0.5.1-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4a60ca4cc451f441031a8b6a0862121b", + "name": "webencodings", + "sha256": "c748787f28cf1d18e7c8227e9925ccbc0e3e2b32440157c2dfe1427c7ad2eec2", + "size": 20676, + "subdir": "linux-64", + "timestamp": 1607365390528, + "version": "0.5.1" + }, + "webob-1.7.3-py27h7bd3e19_0.conda": { + "build": "py27h7bd3e19_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2c0c1ed99573337ebd27ee9d840101f", + "name": "webob", + "sha256": "32b7eeb18c4d706e077f6ae5ccf6ab6a33fddc79927b41e86c48990e3a7f72f3", + "size": 131198, + "subdir": "linux-64", + "timestamp": 1507962477657, + "version": "1.7.3" + }, + "webob-1.7.3-py35hf0121d3_0.conda": { + "build": "py35hf0121d3_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5fb8ca3d47e95f1dbf017cbdff730c15", + "name": "webob", + "sha256": "a1a68b21bb6383bbdfc3885b36c727b9200afcdcd2db7eae248accb265c260c6", + "size": 131444, + "subdir": "linux-64", + "timestamp": 1507962498904, + "version": "1.7.3" + }, + "webob-1.7.3-py36hb151027_0.conda": { + "build": "py36hb151027_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "12417a55e6765449f2681607ddcd6105", + "name": "webob", + "sha256": "64834152e742e46c02aa464f2c241c6ddc24c77dc6ee93d8176ffe91461de7d2", + "size": 129975, + "subdir": "linux-64", + "timestamp": 1507962506788, + "version": "1.7.3" + }, + "webob-1.7.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c4ac0cd9bffbef831c98643b6d950a45", + "name": "webob", + "sha256": "7216cd0402d0cc054ec3eb9f5c981361476a930d31b3fa293d914e169b3d4451", + "size": 129430, + "subdir": "linux-64", + "timestamp": 1520781870641, + "version": "1.7.4" + }, + "webob-1.7.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cbded32967f6b5e532b279011cf1e27e", + "name": "webob", + "sha256": "731a79d0b5a75b90acf6f4acf4df5d0e67f6875a10f3ba6a61811c2c6ddf4084", + "size": 131531, + "subdir": "linux-64", + "timestamp": 1520782162516, + "version": "1.7.4" + }, + "webob-1.7.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45edb9009d30fbfa99f9f534f8f998fb", + "name": "webob", + "sha256": "0170b2aa136f853f3be258e164c1e17b61b779b81ca0136e4a15217a9adaf477", + "size": 131733, + "subdir": "linux-64", + "timestamp": 1520781847931, + "version": "1.7.4" + }, + "webob-1.8.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "60ae6480ad0e1d448bcf0fcb92256d9a", + "name": "webob", + "sha256": "b66c219c48234ecd13d0f6a231049a283d58557d5aaae0c3781fd789fe3a5001", + "size": 157820, + "subdir": "linux-64", + "timestamp": 1524070420433, + "version": "1.8.1" + }, + "webob-1.8.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0705ccbec29d23366bd223bc6a721996", + "name": "webob", + "sha256": "fbc3e43571c5a9583eed9c6b441bfc280d6a9aa2b6847e39c28481299704c12b", + "size": 163497, + "subdir": "linux-64", + "timestamp": 1524070472280, + "version": "1.8.1" + }, + "webob-1.8.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5225f16b585a18c0dd0e3978bf20e3cc", + "name": "webob", + "sha256": "cc24773e69daf32cf88fe6bf7d455d7dd51f5ad0107244f6be67dc22c9035557", + "size": 161878, + "subdir": "linux-64", + "timestamp": 1524070471759, + "version": "1.8.1" + }, + "webob-1.8.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "999d90c13a1b19e7ded45650538fdfcb", + "name": "webob", + "sha256": "1f75a25e57ccbaab1d13b92e00997f20df738751eaee79bf2d3f7fadd13ea1db", + "size": 157762, + "subdir": "linux-64", + "timestamp": 1528985227683, + "version": "1.8.2" + }, + "webob-1.8.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bb139d672a961e58278a093d2907ba1a", + "name": "webob", + "sha256": "5a2fc4b028fb6368c1e5a76bbd1cda21cc6bb4f68aea3dc2b0201598126e50bc", + "size": 163401, + "subdir": "linux-64", + "timestamp": 1528985437152, + "version": "1.8.2" + }, + "webob-1.8.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e602003899235d76a710f420814cf006", + "name": "webob", + "sha256": "77a88dc2af6a11bcf69891b80f978cf4b6abfa329f852be002315ebf7d259615", + "size": 159174, + "subdir": "linux-64", + "timestamp": 1528985281434, + "version": "1.8.2" + }, + "webob-1.8.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa383fc871eaec10b541c7f2b5634d68", + "name": "webob", + "sha256": "73d8c5ed8f36c3e18e8c3ac2179270423efc4962ac4a44587e6d850157d2d373", + "size": 161876, + "subdir": "linux-64", + "timestamp": 1530814214692, + "version": "1.8.2" + }, + "webob-1.8.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e7e3f57f52f82d9805c5dde668d5f5d1", + "name": "webob", + "sha256": "001ba51ce6864f63793d0279ad40ece9cd22ad073a82a486af0f2baf27b07a1d", + "size": 163293, + "subdir": "linux-64", + "timestamp": 1539644751604, + "version": "1.8.3" + }, + "webob-1.8.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e4440aa4aec44cc2d2a1118f490411e", + "name": "webob", + "sha256": "75443362006c94a18532daef6bc380f0c0c3bc1962911b32dfc90d608df537e8", + "size": 162336, + "subdir": "linux-64", + "timestamp": 1539644771186, + "version": "1.8.3" + }, + "webob-1.8.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "06d20b924b6d0984c8e0d1584069dfae", + "name": "webob", + "sha256": "f8c711f715631164cdfde4aa0bc5438d24a948360c5e44cb48c5cc2ff03b5ed9", + "size": 164923, + "subdir": "linux-64", + "timestamp": 1539644752232, + "version": "1.8.3" + }, + "webob-1.8.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e1447dc29407146e5dea42ede09bde13", + "name": "webob", + "sha256": "c0ca56807b9f0c594ebdbb9b87cfd369f318f8ac937a18a5353fc11d4fcfb1f0", + "size": 163723, + "subdir": "linux-64", + "timestamp": 1542091731547, + "version": "1.8.4" + }, + "webob-1.8.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c2f1db40df4550c5ddbd4e5f9eb80c7", + "name": "webob", + "sha256": "260d640a522864599dbe629f6b1dd21d632e303a81338d8456d8f783ff0abb5c", + "size": 165525, + "subdir": "linux-64", + "timestamp": 1542091708211, + "version": "1.8.4" + }, + "webob-1.8.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "234636aad3319d5ca753416e4bb12f35", + "name": "webob", + "sha256": "563de2a87aa96dccd7aaf85a1b92fed6513f47e155b6785e4b01eeed9518cdb2", + "size": 162851, + "subdir": "linux-64", + "timestamp": 1542091668623, + "version": "1.8.4" + }, + "webob-1.8.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c713d8eb1aa4ddc594929c12b37346ca", + "name": "webob", + "sha256": "85405546627f01b5135b8bc33d81f9cd2c72b99c6737269ef1845566304c97ba", + "size": 163088, + "subdir": "linux-64", + "timestamp": 1547984486665, + "version": "1.8.5" + }, + "webob-1.8.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7ccf51bc72d68bb48644781954073432", + "name": "webob", + "sha256": "9ef77adda2a1852ac07d20d55ce6a2fc577aaf820a63274f0690dd70f2d76f48", + "size": 164796, + "subdir": "linux-64", + "timestamp": 1547984553791, + "version": "1.8.5" + }, + "webob-1.8.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1d9ea764bd22c8ea7692e397d30f69ef", + "name": "webob", + "sha256": "b3786b4479280a89e955e410f91f5a6b815f7aed3ff6bd0b39cb46c8928164bd", + "size": 167602, + "subdir": "linux-64", + "timestamp": 1547984563696, + "version": "1.8.5" + }, + "websocket-client-0.54.0-py27_1000.conda": { + "build": "py27_1000", + "build_number": 1000, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "4c3f79947dcd37d5912a53021e1a25b9", + "name": "websocket-client", + "sha256": "c331b7a9f82ce1ca193f33fe4da0759e19ef3ffb2c759ba1feeb2f5cd777fa48", + "size": 61746, + "subdir": "linux-64", + "timestamp": 1545409838455, + "version": "0.54.0" + }, + "websocket-client-0.54.0-py36_1000.conda": { + "build": "py36_1000", + "build_number": 1000, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "96e3788e79ee9cc3887ff54b971547b8", + "name": "websocket-client", + "sha256": "833d295331a96dbddadb7b7115647ef8c0aea2b08a5f5bd184072721a1e9778b", + "size": 62242, + "subdir": "linux-64", + "timestamp": 1545409866241, + "version": "0.54.0" + }, + "websocket-client-0.54.0-py37_1000.conda": { + "build": "py37_1000", + "build_number": 1000, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "559d677f202b7c19bbddafcb43d49f8b", + "name": "websocket-client", + "sha256": "bab24ee135a6aa7c59a3623816a97c889eb16b62090de39b82c410c9ab05e172", + "size": 61281, + "subdir": "linux-64", + "timestamp": 1545409852761, + "version": "0.54.0" + }, + "websocket-client-0.55.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "804a430a10a81675d26b5512dfb2e6af", + "name": "websocket-client", + "sha256": "c8a4a55cd5767e4ec40b76d052e82c8183e9a116057ec975259a5d69f8091f4f", + "size": 62231, + "subdir": "linux-64", + "timestamp": 1552402291093, + "version": "0.55.0" + }, + "websocket-client-0.55.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "d1f367ce6ba200cf6a3af42ed85ef246", + "name": "websocket-client", + "sha256": "e652a02cea00c28aad996d5debf098e8c388e2c38d51ad7ac7108d8c5b7efe7c", + "size": 62211, + "subdir": "linux-64", + "timestamp": 1552401218869, + "version": "0.55.0" + }, + "websocket-client-0.55.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "82bf83bd4e9088f1f43a71f21e698ae2", + "name": "websocket-client", + "sha256": "8b9454a9a9bb7e0b19f5306eb6e4b6cf0ab3fc57c8335eb0caa3582da0504d84", + "size": 63262, + "subdir": "linux-64", + "timestamp": 1552400982607, + "version": "0.55.0" + }, + "websocket-client-0.56.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "96233721f611cc95bf29ecde7953082f", + "name": "websocket-client", + "sha256": "97c3591a45b863992a041cd52b364a1e3974917c311bd59652d29d6c7312c465", + "size": 63284, + "subdir": "linux-64", + "timestamp": 1556112334597, + "version": "0.56.0" + }, + "websocket-client-0.56.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "48b7aab5050ad09fa33888d566b9c0e9", + "name": "websocket-client", + "sha256": "9b2cfb3061687887b0414fb8bc13f5081c6d20f78923cf6e13d54ad904ab8893", + "size": 62806, + "subdir": "linux-64", + "timestamp": 1556088519424, + "version": "0.56.0" + }, + "websocket-client-0.56.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "e1177f8427f284fb617ecfefb612e2b2", + "name": "websocket-client", + "sha256": "1aad031bb59bbbf4aa166776f503f011cd2074e24f57fc29b16cdbe3809f3947", + "size": 62496, + "subdir": "linux-64", + "timestamp": 1556088462031, + "version": "0.56.0" + }, + "websocket-client-0.56.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "2521830e20f2917937d57fec8e72be8a", + "name": "websocket-client", + "sha256": "c05d357bb8c86f096edcb4ac34ca7d777d6a24cce6aa8b65b1e360c9c6fe1fb2", + "size": 60020, + "subdir": "linux-64", + "timestamp": 1574437317637, + "version": "0.56.0" + }, + "websocket-client-0.57.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "1a1b6ba9ecdfd793175f4f65a9774021", + "name": "websocket-client", + "sha256": "7ee9b1c6654c7fbe8c39402fd1c7e18089b88685792d023ad7539312e5de3c53", + "size": 62823, + "subdir": "linux-64", + "timestamp": 1587391568308, + "version": "0.57.0" + }, + "websocket-client-0.57.0-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "21d7aecde71f6b1a4e8e6d897acc633b", + "name": "websocket-client", + "sha256": "6a39197586a9fddf490e3079a3901329cf7c8ba611591940fb3bf4b6995b4669", + "size": 59632, + "subdir": "linux-64", + "timestamp": 1602006598338, + "version": "0.57.0" + }, + "websocket-client-0.57.0-py36h06a4308_1.conda": { + "build": "py36h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "3fbe114a62004d46f5a8d39092056bed", + "name": "websocket-client", + "sha256": "5f3eea4672b18b8391d101dc1c2a19797962bb4fd03bf49e5e86e8c619b3bcda", + "size": 64092, + "subdir": "linux-64", + "timestamp": 1613159636034, + "version": "0.57.0" + }, + "websocket-client-0.57.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "92174f7af71e2c10b35ba02025da153b", + "name": "websocket-client", + "sha256": "4799eda5729d07d175c4a2524fce849a6198849f852d3f547e9aba9ca297de02", + "size": 63880, + "subdir": "linux-64", + "timestamp": 1587391571193, + "version": "0.57.0" + }, + "websocket-client-0.57.0-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bb808ee72014327508c2f3edd078948f", + "name": "websocket-client", + "sha256": "3a67df4eec21ed6a4c672418616d55df48b793c0f2285601cee03a9d63c053d2", + "size": 60238, + "subdir": "linux-64", + "timestamp": 1602006619791, + "version": "0.57.0" + }, + "websocket-client-0.57.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "99c7540681b4fddecee528efc68ad5f2", + "name": "websocket-client", + "sha256": "100612f81cdd3d8bd963a2f69d407fc92011b1b77a66a542033748f2499dc34e", + "size": 64071, + "subdir": "linux-64", + "timestamp": 1613159313791, + "version": "0.57.0" + }, + "websocket-client-0.57.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "ac1ac81e2f890b2eb57826ca014ab8f8", + "name": "websocket-client", + "sha256": "71a0d725f481c2e4166bdf35ce911c0703b81855c16e6f5c5da4f1330000e322", + "size": 63499, + "subdir": "linux-64", + "timestamp": 1587391688925, + "version": "0.57.0" + }, + "websocket-client-0.57.0-py38_2.conda": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6bdee9603877bfcb06b6a40282781e4c", + "name": "websocket-client", + "sha256": "5c713360b9c1039ec623f6a988e066f316dd463db622cb9c86453ed345131526", + "size": 60521, + "subdir": "linux-64", + "timestamp": 1602006616442, + "version": "0.57.0" + }, + "websocket-client-0.57.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "d5ba96746ac6bcc99e2ead6ef01221ed", + "name": "websocket-client", + "sha256": "11983b73ea39919407bebfe0baebd977838ee74506eaa06a35520c6aca276ce9", + "size": 64338, + "subdir": "linux-64", + "timestamp": 1613159627551, + "version": "0.57.0" + }, + "websocket-client-0.57.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "LGPL 2.1", + "license_family": "LGPL", + "md5": "c6824e681478ba7be9dd0a795d328a65", + "name": "websocket-client", + "sha256": "09d2fd7489b119cde5dbdbce1de08e608580990e661e25c17e830f64e5863052", + "size": 63453, + "subdir": "linux-64", + "timestamp": 1613159170421, + "version": "0.57.0" + }, + "websocket-client-0.58.0-py310h06a4308_4.conda": { + "build": "py310h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6701027f6e79e7f94a1c27307ef253d7", + "name": "websocket-client", + "sha256": "52465ae5cec22cce4a628b1e6acc773bcd4cb02c27e60d3abdaf9c2b4dbbad33", + "size": 69115, + "subdir": "linux-64", + "timestamp": 1640795883083, + "version": "0.58.0" + }, + "websocket-client-0.58.0-py311h06a4308_4.conda": { + "build": "py311h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5e3c223c737dd0b7eac3ef3d410f7593", + "name": "websocket-client", + "sha256": "222cf8eaa26e4b778b244e4f387c1300dcb8b5eb496cdafedb625f8834cb589a", + "size": 88657, + "subdir": "linux-64", + "timestamp": 1676824901641, + "version": "0.58.0" + }, + "websocket-client-0.58.0-py36h06a4308_4.conda": { + "build": "py36h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8bf35b49e0832b4a9c36d62e1fdeb511", + "name": "websocket-client", + "sha256": "b6205be9b73c5c05c81acafdb1c8e40248469e67f35b07f834987ee10a01134d", + "size": 67614, + "subdir": "linux-64", + "timestamp": 1614804296961, + "version": "0.58.0" + }, + "websocket-client-0.58.0-py37h06a4308_4.conda": { + "build": "py37h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d815deb0dd527d4b0618d032cc9e30d3", + "name": "websocket-client", + "sha256": "e931988b200b79101bf463495aef34747072408fcb4d3731241e1f671e58578f", + "size": 67530, + "subdir": "linux-64", + "timestamp": 1614804295414, + "version": "0.58.0" + }, + "websocket-client-0.58.0-py38h06a4308_4.conda": { + "build": "py38h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f717b8646e57dfa782479480407f6647", + "name": "websocket-client", + "sha256": "81169f26d2bee9cbcf6001f171695cb158b4fa637d6d14e5a5ac84e795355b77", + "size": 67816, + "subdir": "linux-64", + "timestamp": 1614804298366, + "version": "0.58.0" + }, + "websocket-client-0.58.0-py39h06a4308_4.conda": { + "build": "py39h06a4308_4", + "build_number": 4, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8f11335fbf7323a655c871ea1f1a8be2", + "name": "websocket-client", + "sha256": "2fbe8e40001bbd5e725cc1193516223aed038f4f52491713fc2cf4e975cbbd33", + "size": 67902, + "subdir": "linux-64", + "timestamp": 1614804011510, + "version": "0.58.0" + }, + "websockets-10.4-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f9e3ce9f196421794071930ddb50e772", + "name": "websockets", + "sha256": "32ccb962ea3b2f74c3903a4d104c7e79d42737517f02266bf08f5d5557442818", + "size": 137628, + "subdir": "linux-64", + "timestamp": 1677830227959, + "version": "10.4" + }, + "websockets-10.4-py310h5eee18b_1.conda": { + "build": "py310h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d50ea8f0ecdadb16fe455e541d3eab75", + "name": "websockets", + "sha256": "604aa0dc8219da4ed74cfe2c46c56170d9230d256041c68f01fcb387d9b800b9", + "size": 135979, + "subdir": "linux-64", + "timestamp": 1678966827747, + "version": "10.4" + }, + "websockets-10.4-py311h5eee18b_1.conda": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d11a0b1da3d92825e868e5eb4285b2d0", + "name": "websockets", + "sha256": "e11f6ed65a74b70701c18de76cfaf01de6090368971018fd680088c0aeb1e92e", + "size": 170300, + "subdir": "linux-64", + "timestamp": 1678966883211, + "version": "10.4" + }, + "websockets-10.4-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "142c623d47462dab77fa0c90b0f40854", + "name": "websockets", + "sha256": "0a891511ec66ced7d49874e9bcc083b8f3a6756ac60e63196a3a8c57e6e0cfae", + "size": 135633, + "subdir": "linux-64", + "timestamp": 1677830282802, + "version": "10.4" + }, + "websockets-10.4-py38h5eee18b_1.conda": { + "build": "py38h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b0000726f766baaf6d3c56f2f48945ff", + "name": "websockets", + "sha256": "1b393a8c13eed673d0b74a63d2d892ee5aa60cbf653e4b5e99e967898c7fc5ff", + "size": 134105, + "subdir": "linux-64", + "timestamp": 1678966855198, + "version": "10.4" + }, + "websockets-10.4-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dead6d3e15cda159f130d3d8edcdb365", + "name": "websockets", + "sha256": "646afff9a71f4fc7ab8e215c2e5d24a0ebcb83a144d92917eed1b81d83174294", + "size": 135610, + "subdir": "linux-64", + "timestamp": 1677830256465, + "version": "10.4" + }, + "websockets-10.4-py39h5eee18b_1.conda": { + "build": "py39h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "eba56d4c38ec84c3110a1b61cec82d20", + "name": "websockets", + "sha256": "1d4715b25037cbd9aefbeff2da943cafe58deefbe36b810e109ead6513d988d6", + "size": 134036, + "subdir": "linux-64", + "timestamp": 1678966910133, + "version": "10.4" + }, + "webtest-2.0.29-py27h0360dea_0.conda": { + "build": "py27h0360dea_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=2.7,<2.8.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "ea96b854139a597b19f5704b4dba8d75", + "name": "webtest", + "sha256": "3c2ff4e26cb7a376e0731119116163f2d65e2f8b7bf267dcf8b9b7800cbc8879", + "size": 73386, + "subdir": "linux-64", + "timestamp": 1509401289839, + "version": "2.0.29" + }, + "webtest-2.0.29-py35h2d26cb8_0.conda": { + "build": "py35h2d26cb8_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.5,<3.6.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "d890c7a9ba072c199cd1c1d6ed0bfd3a", + "name": "webtest", + "sha256": "a1a32bc9d148f67df5ba30c55c3e3387b05e81cbab75a662b64eda91eecfb646", + "size": 74143, + "subdir": "linux-64", + "timestamp": 1509401293729, + "version": "2.0.29" + }, + "webtest-2.0.29-py36h291c265_0.conda": { + "build": "py36h291c265_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.6,<3.7.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "0f65a248e79bea7c95844ab451e35b37", + "name": "webtest", + "sha256": "d9257b42f4c0e12ea7d8dc4760de02c0068a253331c298f9ccd5861a697c8baf", + "size": 73125, + "subdir": "linux-64", + "timestamp": 1509401296617, + "version": "2.0.29" + }, + "webtest-2.0.30-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=2.7,<2.8.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "994d15f5a7594d08a8fbcc6ce95dd706", + "name": "webtest", + "sha256": "e8d6a4f1e150c2b22b8f3be0ead2f581c62cbe27378632381f79e1b96fd35b30", + "size": 74171, + "subdir": "linux-64", + "timestamp": 1529954667951, + "version": "2.0.30" + }, + "webtest-2.0.30-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.5,<3.6.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "734e3c41728a213a4b82fe5ea47af14c", + "name": "webtest", + "sha256": "a15208dc0d4c50b13d945b598561c6e5b905395d6e39cd970d15ec0bdf27a963", + "size": 74875, + "subdir": "linux-64", + "timestamp": 1529954683700, + "version": "2.0.30" + }, + "webtest-2.0.30-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.6,<3.7.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "d927343bf5ead0882dcb19093e1b8047", + "name": "webtest", + "sha256": "aa7f212f4b274060edb5a659d93d6ca86f6ebc2b0654a77121eb548f6d6db0a4", + "size": 73937, + "subdir": "linux-64", + "timestamp": 1529954641267, + "version": "2.0.30" + }, + "webtest-2.0.30-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.7,<3.8.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "230a4e0c4534b50e4dbddc6bd9b6054c", + "name": "webtest", + "sha256": "6f264e7ea6a579811934c062273e61facf9ae8edeb084da2fca35c214996b6a8", + "size": 73012, + "subdir": "linux-64", + "timestamp": 1530875751288, + "version": "2.0.30" + }, + "webtest-2.0.32-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=2.7,<2.8.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "7f97674e96f0377e39346e3ef57ef099", + "name": "webtest", + "sha256": "5eb1d15338fca06f9adffb019a8e555226303cd7d21462afd7f59bc3239d04b8", + "size": 73709, + "subdir": "linux-64", + "timestamp": 1539648295155, + "version": "2.0.32" + }, + "webtest-2.0.32-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.6,<3.7.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "9367e55782bd3bccddeced6d9313bb18", + "name": "webtest", + "sha256": "42f6a24b11abf158dee066364264bd10979a4249bf3c77f097af01d925e38fed", + "size": 74109, + "subdir": "linux-64", + "timestamp": 1539648300405, + "version": "2.0.32" + }, + "webtest-2.0.32-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.7,<3.8.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "c00190aea0b25584e704a2231cf576df", + "name": "webtest", + "sha256": "c5b8c9f3eff90a94e99ecfd42dc25572e8e9e48fc9aedf2eb2c9f6125b8db5a5", + "size": 74196, + "subdir": "linux-64", + "timestamp": 1539648303295, + "version": "2.0.32" + }, + "webtest-2.0.33-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=2.7,<2.8.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "b98f87c779124b5c643279e233776782", + "name": "webtest", + "sha256": "3ed8865153840a32554871cc66139b7ab36a05db2cb0b812ea7c1d6e035ed4b6", + "size": 227468, + "subdir": "linux-64", + "timestamp": 1552372051897, + "version": "2.0.33" + }, + "webtest-2.0.33-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.10,<3.11.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "b337b3b2d113cc67fb82853004b956b6", + "name": "webtest", + "sha256": "61460ced94503ed24a8580cc9f5d7b696a355003ccc0dcea4fc846785a00fa43", + "size": 74862, + "subdir": "linux-64", + "timestamp": 1640795901135, + "version": "2.0.33" + }, + "webtest-2.0.33-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.11,<3.12.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "9eac6add341fa42ce810a6ab7e81c0cf", + "name": "webtest", + "sha256": "bdb869f529d3fb9d6b14b74f854a3f880263ded73c8a700f5a078bb6e8241fd8", + "size": 96205, + "subdir": "linux-64", + "timestamp": 1676907755082, + "version": "2.0.33" + }, + "webtest-2.0.33-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.6,<3.7.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "5405adb5b2b7eaaa148d70b0cda8350e", + "name": "webtest", + "sha256": "d854700892edc5820bdf3c7d4e2b0d65f0e5d5219cd996567d3a32d2622026bc", + "size": 228489, + "subdir": "linux-64", + "timestamp": 1552372111203, + "version": "2.0.33" + }, + "webtest-2.0.33-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.6,<3.7.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "f15a898e36a7ee71ba02723cf962a1d1", + "name": "webtest", + "sha256": "87c806c22e8e9ab3bfe6a14799c11c3c5a33a9493cae6f9766df4793292e1b6b", + "size": 312004, + "subdir": "linux-64", + "timestamp": 1613158710226, + "version": "2.0.33" + }, + "webtest-2.0.33-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.7,<3.8.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "515074d788f5d003e0d4e54e76669a59", + "name": "webtest", + "sha256": "839043f4475f12ebac80523d5846dd6960aa6df711e9a27ba772c3c2c940a56a", + "size": 226572, + "subdir": "linux-64", + "timestamp": 1552372032700, + "version": "2.0.33" + }, + "webtest-2.0.33-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.7,<3.8.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "d3c2531ccd3af0b43e131361d376637d", + "name": "webtest", + "sha256": "fc4861aee27e52530b41f46a744e4a351287edaf596310cf1c643254e7edcdff", + "size": 312797, + "subdir": "linux-64", + "timestamp": 1613159166028, + "version": "2.0.33" + }, + "webtest-2.0.33-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.8,<3.9.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "0c473ff972739ea54725e516b4c98139", + "name": "webtest", + "sha256": "54d3f42577409abd5e4782a62696e5de1265aa2ff11708826987f7d5a72cc42b", + "size": 75018, + "subdir": "linux-64", + "timestamp": 1574437335273, + "version": "2.0.33" + }, + "webtest-2.0.33-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.8,<3.9.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "eb1d69a2a4cf07ae1c890d090e3442fe", + "name": "webtest", + "sha256": "6f7d84b89c4502c248620e597a834f0a4185ca6ceb86e93e8601a0cfe3ea8623", + "size": 312239, + "subdir": "linux-64", + "timestamp": 1613158896872, + "version": "2.0.33" + }, + "webtest-2.0.33-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "beautifulsoup4", + "python >=3.9,<3.10.0a0", + "six", + "waitress >=0.8.5", + "webob >=1.2" + ], + "license": "MIT", + "md5": "0f5ea68b0015c693ddf52260030de5ad", + "name": "webtest", + "sha256": "a06b8d8f86585f3f3481eff23ff090a8b2aa6b021bfdb1d210248f869e7fab58", + "size": 313070, + "subdir": "linux-64", + "timestamp": 1613163233534, + "version": "2.0.33" + }, + "werkzeug-0.12.2-py27hbf75dff_0.conda": { + "build": "py27hbf75dff_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a5b4472792782efa669d88807ab9ef24", + "name": "werkzeug", + "sha256": "5865ab9b5697883e3a7db65260907d55e89a021d24b1551d283681f1918da3ec", + "size": 397007, + "subdir": "linux-64", + "timestamp": 1505740357794, + "version": "0.12.2" + }, + "werkzeug-0.12.2-py35hbfc1ea6_0.conda": { + "build": "py35hbfc1ea6_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "372a66145e35e746aa81f9275c53a961", + "name": "werkzeug", + "sha256": "ab7357f849c437ff417b736f0660333789b3ef046e19208611b5231891bb527c", + "size": 396885, + "subdir": "linux-64", + "timestamp": 1505740372988, + "version": "0.12.2" + }, + "werkzeug-0.12.2-py36hc703753_0.conda": { + "build": "py36hc703753_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "98fa04a88c55c0da0d748fe1ddd677a0", + "name": "werkzeug", + "sha256": "b0f175de670a5ca7f873fb4b217df120cc7d763dba9225eefc18946d75de3882", + "size": 399105, + "subdir": "linux-64", + "timestamp": 1505740388434, + "version": "0.12.2" + }, + "werkzeug-0.14.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "fcacd46ffbd8f18a924ed3703ffa9795", + "name": "werkzeug", + "sha256": "83df329ea6ff7a719c205f52d0fadea13735a6ee942f103c10106e7126efe390", + "size": 402113, + "subdir": "linux-64", + "timestamp": 1515709497669, + "version": "0.14.1" + }, + "werkzeug-0.14.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "b1c8d4639419ac69fdcae9572b553eea", + "name": "werkzeug", + "sha256": "56a5b5233ac64d1c14446681be2b841d95fb4e1b5852863e136ab28afd95bd44", + "size": 411564, + "subdir": "linux-64", + "timestamp": 1515709624608, + "version": "0.14.1" + }, + "werkzeug-0.14.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "27c9b9967b45df1d05eefa1f6a81da0f", + "name": "werkzeug", + "sha256": "a6f7a500a88949de5a55009505ff21973922019c667414a673eaea9f6a917b15", + "size": 403536, + "subdir": "linux-64", + "timestamp": 1515709387120, + "version": "0.14.1" + }, + "werkzeug-0.14.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1c3afd78a5c1430d25dc29c0e6d9266f", + "name": "werkzeug", + "sha256": "95cf8488b8c79d0f39f49111c03dd3b25dcc90df1e82178a6e836795fac7ceb9", + "size": 408319, + "subdir": "linux-64", + "timestamp": 1530771750607, + "version": "0.14.1" + }, + "werkzeug-2.2.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.1.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "17f0dd197aad6970ff247a433128a963", + "name": "werkzeug", + "sha256": "ae2c47ab546f2849167ab8cf5e28466e835d5495fbf0c4b4b31d2db1f91bfa78", + "size": 351652, + "subdir": "linux-64", + "timestamp": 1671216052927, + "version": "2.2.2" + }, + "werkzeug-2.2.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.1.1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "125dc81f0cc56d66ef8510a6ed924c26", + "name": "werkzeug", + "sha256": "24bfecb0f760c472bd44cfc5a1bab255c600d41847a259ec5b48cfe9ed76435d", + "size": 443442, + "subdir": "linux-64", + "timestamp": 1676826930304, + "version": "2.2.2" + }, + "werkzeug-2.2.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.1.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bbcd53e5d3c5a201d789e14c16f4f56c", + "name": "werkzeug", + "sha256": "268e239ced5bf802d9f457b3f52c36eeb523a3c92f77b12e1b03338b17c910d1", + "size": 344910, + "subdir": "linux-64", + "timestamp": 1671216026726, + "version": "2.2.2" + }, + "werkzeug-2.2.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.1.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "603616a62b3f89129f18fc06e809d224", + "name": "werkzeug", + "sha256": "9a551fddc296801c45cba2b74f5dcca5e65a92a630c7553debe1deab61c6cc19", + "size": 347243, + "subdir": "linux-64", + "timestamp": 1671216104791, + "version": "2.2.2" + }, + "werkzeug-2.2.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.1.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7925a21e34d0cace4d7c2ad6fc77431f", + "name": "werkzeug", + "sha256": "30dd279fa1b9f1b52e04a42445f7be442d43d4ad68d99b730b8dd507f3086f73", + "size": 347096, + "subdir": "linux-64", + "timestamp": 1671216078867, + "version": "2.2.2" + }, + "werkzeug-2.2.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.1.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "841449db7232eb345a3e5eddb7152c03", + "name": "werkzeug", + "sha256": "2cd0bd7fe005502ea68e4eb7888f375eed289599faa8b9cc6ab3b03f7a78f628", + "size": 354324, + "subdir": "linux-64", + "timestamp": 1679489749077, + "version": "2.2.3" + }, + "werkzeug-2.2.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.1.1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f1176a3dea5434ac1a90ffb2c70e7c2b", + "name": "werkzeug", + "sha256": "7136df9979afdda59385eb27f1846281537bab8336da4f0eff1354d8a7358700", + "size": 464556, + "subdir": "linux-64", + "timestamp": 1679489775331, + "version": "2.2.3" + }, + "werkzeug-2.2.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.1.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "78fe955cdbeb6a9a33a1b952164c21c4", + "name": "werkzeug", + "sha256": "ef9f5a0295a78dd2f582e9a6edb63569e0128a17fd28e0ef24839d9fd50ab071", + "size": 349796, + "subdir": "linux-64", + "timestamp": 1679489824958, + "version": "2.2.3" + }, + "werkzeug-2.2.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "markupsafe >=2.1.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9bfc48f9d6098993cd0a57d9d225ba4f", + "name": "werkzeug", + "sha256": "e720c59e005b4d65e1e37a1b007b29a1e4fca6f3e3abb00b4ff6436555523e28", + "size": 348789, + "subdir": "linux-64", + "timestamp": 1679489799965, + "version": "2.2.3" + }, + "wget-1.19.1-he4ec0ba_0.conda": { + "build": "he4ec0ba_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl 1.0.*", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL3", + "md5": "8a2fbbc41376a22951ee39243507ae21", + "name": "wget", + "sha256": "211f951b3e80fe967c19087b366e103af9fc2fdda7572c8d6365f0256e68d746", + "size": 676054, + "subdir": "linux-64", + "timestamp": 1505742567028, + "version": "1.19.1" + }, + "wget-1.19.4-hf388c53_0.conda": { + "build": "hf388c53_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL3", + "md5": "666230f6d242945b1023367e214f4fe7", + "name": "wget", + "sha256": "afa4b8a63004d20062637e0a611362b4993a165a01be4bf93eb3f130f9a341e9", + "size": 662265, + "subdir": "linux-64", + "timestamp": 1524178863272, + "version": "1.19.4" + }, + "wget-1.19.5-h1ad7b7a_0.conda": { + "build": "h1ad7b7a_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "openssl >=1.0.2o,<1.0.3a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL3", + "md5": "e47f2410a3e1efa2a44ddf640497aafb", + "name": "wget", + "sha256": "79cc0a54a048dd75e53796fa83d263edca518c1365e29903d475db3c65db1f3b", + "size": 661060, + "subdir": "linux-64", + "timestamp": 1527641585318, + "version": "1.19.5" + }, + "wget-1.19.5-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1a,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL3", + "md5": "55a1f0e52d279bed89b2db7356f400d0", + "name": "wget", + "sha256": "288ac5cbc6358c75135a7b619e38db243d5c24816edc2d10af530ce1fbef9e8d", + "size": 662609, + "subdir": "linux-64", + "timestamp": 1540583242074, + "version": "1.19.5" + }, + "wget-1.20.1-h20c2e04_0.conda": { + "build": "h20c2e04_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "openssl >=1.1.1b,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "GPL3", + "md5": "430b97c85afbfc640e6060c2307fb779", + "name": "wget", + "sha256": "61be2b9e17c32e657b15152b42bfbf6208e40025a638522fc034d5734adebea9", + "size": 838037, + "subdir": "linux-64", + "timestamp": 1551978000266, + "version": "1.20.1" + }, + "wget-1.21.3-h0b77cf5_0.conda": { + "build": "h0b77cf5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libidn2 >=2,<3.0a0", + "openssl >=1.1.1n,<1.1.2a", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "c673037654894abbfde02903e01a8a8e", + "name": "wget", + "sha256": "76c57012c76412ddaab7821c4432c4db586503d62b21fab5e9e56111bb280ef0", + "size": 732549, + "subdir": "linux-64", + "timestamp": 1650648190870, + "version": "1.21.3" + }, + "whatthepatch-1.0.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "31f6f95e24df2b81dad0e74e02457a7b", + "name": "whatthepatch", + "sha256": "bb877624c147e7544c69ab14e3851b2280caab5852111dcc77de509b1744ca41", + "size": 22552, + "subdir": "linux-64", + "timestamp": 1661796035744, + "version": "1.0.2" + }, + "whatthepatch-1.0.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ccfa89e0fee70603c53bf77461b6975", + "name": "whatthepatch", + "sha256": "2977499c2fc0666c9addd53b0f8406fef2c759f626b68b5b47ce71b9f955120e", + "size": 28947, + "subdir": "linux-64", + "timestamp": 1677708403592, + "version": "1.0.2" + }, + "whatthepatch-1.0.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51983c637e274be2f5d02c3f0513d4e8", + "name": "whatthepatch", + "sha256": "6958f0c502d063f42836d100bde095a740171d91849a528adccdc6ef89f0de00", + "size": 22490, + "subdir": "linux-64", + "timestamp": 1661796116198, + "version": "1.0.2" + }, + "whatthepatch-1.0.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "19986ef72c569de1ecd247a793773dd3", + "name": "whatthepatch", + "sha256": "e3be3ee065cd5876d36a300dce42defd48fff3d5bd5fab198bb262ce9e3840d7", + "size": 22371, + "subdir": "linux-64", + "timestamp": 1661796061723, + "version": "1.0.2" + }, + "whatthepatch-1.0.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "220adb08ff922ec4613d1f6c87a3e69d", + "name": "whatthepatch", + "sha256": "97ac4f875ae92af68c9e8caed56109199b2ec0ca524068276e2953b7115f3f1e", + "size": 22466, + "subdir": "linux-64", + "timestamp": 1661796090170, + "version": "1.0.2" + }, + "wheel-0.29.0-py27h411dd7b_1.conda": { + "build": "py27h411dd7b_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "2d2a0f50836dbc66ec674acc16e9873c", + "name": "wheel", + "sha256": "799b259f76d31dc5c4a5bb432d959bc12a3be7801f5173ff061de56264670407", + "size": 91704, + "subdir": "linux-64", + "timestamp": 1505671888349, + "version": "0.29.0" + }, + "wheel-0.29.0-py35h601ca99_1.conda": { + "build": "py35h601ca99_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "ee4decd22e46251c08af38200efd965c", + "name": "wheel", + "sha256": "3121d3ebdc6f6f29817fdcec9907b303c6f8a790702d4ec7b368f1f57623a2f0", + "size": 93467, + "subdir": "linux-64", + "timestamp": 1505671897680, + "version": "0.29.0" + }, + "wheel-0.29.0-py36he7f4e38_1.conda": { + "build": "py36he7f4e38_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "ff53bd8b49dbd712352af5b4e10e3a4f", + "name": "wheel", + "sha256": "69d9f0087110396d2cb9fffa00d15494f63e1c380996536ca2c038598d359ed4", + "size": 91897, + "subdir": "linux-64", + "timestamp": 1505671907011, + "version": "0.29.0" + }, + "wheel-0.30.0-py27h2bc6bb2_1.conda": { + "build": "py27h2bc6bb2_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "bdca97f4281be8d551dbb0b4b9266506", + "name": "wheel", + "sha256": "068986e488708f591e7fc8675e5abb4e793e1a2bedeb2afa81b108a61ea7b0a8", + "size": 71557, + "subdir": "linux-64", + "timestamp": 1511280523138, + "version": "0.30.0" + }, + "wheel-0.30.0-py35hd3883cf_1.conda": { + "build": "py35hd3883cf_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "34883c5141c795c7946e2f06abb62236", + "name": "wheel", + "sha256": "9d609a4bed344d43252519d57839207bb313937f08624f7efdf3ed1cabfa23b8", + "size": 71155, + "subdir": "linux-64", + "timestamp": 1511280527186, + "version": "0.30.0" + }, + "wheel-0.30.0-py36hfd4bba0_1.conda": { + "build": "py36hfd4bba0_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "f608919134bfe61f45ce11e43d418c5a", + "name": "wheel", + "sha256": "65770a3acf36bb7e3ac063971987ff70e21bce86e070ac4047b1f13a04b144be", + "size": 70309, + "subdir": "linux-64", + "timestamp": 1511280516538, + "version": "0.30.0" + }, + "wheel-0.31.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "7b5f80fc4a728703d188c93ada49aff4", + "name": "wheel", + "sha256": "aedf07e2633c0458657150c32ebd1fbcfbfae76f7b96a8cb0b7a0f36a939d72b", + "size": 66184, + "subdir": "linux-64", + "timestamp": 1522684041101, + "version": "0.31.0" + }, + "wheel-0.31.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "d5b64d62bc368af6f7b1d52660457ffd", + "name": "wheel", + "sha256": "5abdfca80464a5eafbfc599b5a0773698f6ba98a09ff7bf1d1e1041336f4f17f", + "size": 67255, + "subdir": "linux-64", + "timestamp": 1522684071973, + "version": "0.31.0" + }, + "wheel-0.31.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "336691d77181c930708db12b6b09316c", + "name": "wheel", + "sha256": "ec0c937576261f342e229dcb223c68bbc254961c83b2b311eb945bf73f588e5a", + "size": 66592, + "subdir": "linux-64", + "timestamp": 1522684072712, + "version": "0.31.0" + }, + "wheel-0.31.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "74a1364d38e35e298120e05de6f24cc3", + "name": "wheel", + "sha256": "cc17739187d9f121566e129731e0f713b52b249d9e3dd8badc3dc98b5e8a06f4", + "size": 66628, + "subdir": "linux-64", + "timestamp": 1526403243190, + "version": "0.31.1" + }, + "wheel-0.31.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "c6a85fc4ad92cbe27f83058b8470c9c9", + "name": "wheel", + "sha256": "983b3845d85d047ce0722c584329a9f80cef9291ae4ef0a7da18317e0a72dbb4", + "size": 67186, + "subdir": "linux-64", + "timestamp": 1526403262983, + "version": "0.31.1" + }, + "wheel-0.31.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "119a0e7bb3e7bec2bd85984b6aebcb30", + "name": "wheel", + "sha256": "58497d5776a38a46ad329185d7cc800540bafe10a1a789b64cd8e6b56b087a1a", + "size": 66667, + "subdir": "linux-64", + "timestamp": 1526403202821, + "version": "0.31.1" + }, + "wheel-0.31.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "8c1c6c368004943521feca58ff0aa596", + "name": "wheel", + "sha256": "2548aceb85987b14e4e40279ba870a5bbafb4757e8a938019d4762fcc7d0c56a", + "size": 66412, + "subdir": "linux-64", + "timestamp": 1530212714978, + "version": "0.31.1" + }, + "wheel-0.32.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "2abdf114fd7788cba09772daab9964d7", + "name": "wheel", + "sha256": "ffb1bbad069dd7174e1704ca577c0e946ab1f80098759cf71ba05eac3f675f63", + "size": 37485, + "subdir": "linux-64", + "timestamp": 1538587175463, + "version": "0.32.0" + }, + "wheel-0.32.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "a7f54dd84dcd29f3c4c8a0c2c0007648", + "name": "wheel", + "sha256": "26f11f3cbade4a324a76bdec7ee33982f7d750e21eda73bad21a3adb0bb88f32", + "size": 37356, + "subdir": "linux-64", + "timestamp": 1538587183029, + "version": "0.32.0" + }, + "wheel-0.32.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "93c3157ca52db67e3a1444a7609282a8", + "name": "wheel", + "sha256": "2d8e8485df543a02041a7117f2262cc9873489f4e2fc9a5d70b629a7068d510a", + "size": 37239, + "subdir": "linux-64", + "timestamp": 1538587164804, + "version": "0.32.0" + }, + "wheel-0.32.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "b241501aae879611af92997e7e6cc053", + "name": "wheel", + "sha256": "f307b879f60904dcde52d53a072f15c14e5713651e0eb81010825a0ce891ffff", + "size": 37656, + "subdir": "linux-64", + "timestamp": 1539024068583, + "version": "0.32.1" + }, + "wheel-0.32.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "13cb34d31d9d04d7bbcabf4136f0a7ee", + "name": "wheel", + "sha256": "cdea20c178f32f1db1a68eef8bf17a829bc3197c2baa3d4d087a4b78b5b44e29", + "size": 37636, + "subdir": "linux-64", + "timestamp": 1539024082766, + "version": "0.32.1" + }, + "wheel-0.32.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "5fb90f89dc20b254d6a01a37d54cddac", + "name": "wheel", + "sha256": "c0d195bcc25f3241cfeecc5b1765b5048f1bc48b1b4febc14940f746b1611149", + "size": 37404, + "subdir": "linux-64", + "timestamp": 1539024030399, + "version": "0.32.1" + }, + "wheel-0.32.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "abfd1d133a6fc441fa0df45fd17da581", + "name": "wheel", + "sha256": "12479c8867bc9a0cfd7cd061a88b65e68ad2e479a91a697fdd7bf95711b4bdb6", + "size": 37750, + "subdir": "linux-64", + "timestamp": 1540228737560, + "version": "0.32.2" + }, + "wheel-0.32.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "467fae99763a22c754a4fc515807ab48", + "name": "wheel", + "sha256": "d0b3ff8d7e933987b2d067f82faa3a129854a158eef3dc1fdbfe03f1fc2b2b37", + "size": 37623, + "subdir": "linux-64", + "timestamp": 1540228750835, + "version": "0.32.2" + }, + "wheel-0.32.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "fb83ca691022f3c399bf72cf269003df", + "name": "wheel", + "sha256": "f5e20e4954f924aca4fb656a582c563ef67bd28e70e5261b95f6b2b3266c72d5", + "size": 37407, + "subdir": "linux-64", + "timestamp": 1540228778841, + "version": "0.32.2" + }, + "wheel-0.32.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "6e68140b680833947b046f22f66232f7", + "name": "wheel", + "sha256": "def6a8c5cd95781e1d9c05142ce0440f4ca83787417d27b732d920f716eb14bb", + "size": 37727, + "subdir": "linux-64", + "timestamp": 1542642542001, + "version": "0.32.3" + }, + "wheel-0.32.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "66cc8dd01c6be78ba0620423649d74a0", + "name": "wheel", + "sha256": "716edd53e32e5045fbabdbb860a738a3e08fad3981d4819bb276743ac0aac283", + "size": 37416, + "subdir": "linux-64", + "timestamp": 1542642564954, + "version": "0.32.3" + }, + "wheel-0.32.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "bd162bee41060c5591660593ee701993", + "name": "wheel", + "sha256": "108a4f9a961a59a29396bf908b5164ae1e2060df1560803b0fc345fae7ac1ee9", + "size": 37296, + "subdir": "linux-64", + "timestamp": 1542642524752, + "version": "0.32.3" + }, + "wheel-0.32.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "e4ae1d62fb8d5d5c4bdad7705c3838d6", + "name": "wheel", + "sha256": "e1c54d1ccafa1940ce40f012be2b94e5a223e3d3c34a8851dc86fb114decee10", + "size": 37583, + "subdir": "linux-64", + "timestamp": 1573034077354, + "version": "0.32.3" + }, + "wheel-0.33.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "23ae9e7bd3321bc942c5396c0ec72b81", + "name": "wheel", + "sha256": "c7f90e699145a46a0148d6b15b7ed486be1c90e39757cb1e1ef0df333b272f3d", + "size": 41712, + "subdir": "linux-64", + "timestamp": 1551149172509, + "version": "0.33.1" + }, + "wheel-0.33.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "4862e68230b2002ecbe0ce3874bc00ef", + "name": "wheel", + "sha256": "f18d6816b7838ccd3cfdf87c778322c4c6b851bed66c37574a5ce2d4a14876b9", + "size": 41607, + "subdir": "linux-64", + "timestamp": 1551149182787, + "version": "0.33.1" + }, + "wheel-0.33.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "8d33b349fcb5d6e52a64452041a931d7", + "name": "wheel", + "sha256": "5269957b76ec849104a35c1a144d7024e7f804ce0b9819b8f09e64c099e4f172", + "size": 41584, + "subdir": "linux-64", + "timestamp": 1551149152778, + "version": "0.33.1" + }, + "wheel-0.33.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "f8c35d20e944f688da61f87e61d523f8", + "name": "wheel", + "sha256": "2ebe60588cc6122a54095bc95c50687129c1603a7ab39dba02efe283c4593ae3", + "size": 42295, + "subdir": "linux-64", + "timestamp": 1557502304569, + "version": "0.33.2" + }, + "wheel-0.33.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "524304148a230f58357668d21294f1f9", + "name": "wheel", + "sha256": "6cef01ea815875cea2a9f2110e65ce590a5de80226591b3ec7f9cec56245252e", + "size": 42079, + "subdir": "linux-64", + "timestamp": 1557502342180, + "version": "0.33.2" + }, + "wheel-0.33.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "4fadfd7d692409e8e07b7f20b75f036d", + "name": "wheel", + "sha256": "dbbe5beca8f7f7c4a0603977425ed6b45bf937091abd5198e95a1443bb4dcbe1", + "size": 41979, + "subdir": "linux-64", + "timestamp": 1557502247924, + "version": "0.33.2" + }, + "wheel-0.33.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "d04d699ff19c7c16bb32a41810a879d9", + "name": "wheel", + "sha256": "8b45d9e04d8165146d11bded13cd505257033ca3d53d2c388f92de070f1571bf", + "size": 42602, + "subdir": "linux-64", + "timestamp": 1557857033805, + "version": "0.33.4" + }, + "wheel-0.33.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "9a6397188ed123e97ec81eb818281d0b", + "name": "wheel", + "sha256": "ef3225e3c79fd2c76961cbd0dae73d394c37e74d81a7f89f78a3c409fecdb12c", + "size": 42322, + "subdir": "linux-64", + "timestamp": 1557857080569, + "version": "0.33.4" + }, + "wheel-0.33.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "0fad2e19b293ae02565bded1c2484a9e", + "name": "wheel", + "sha256": "a89e0ec9eca3af4f905d0e6a8e2ff18bf57fbad2f96407f58dcdc15ed06cbcbd", + "size": 42208, + "subdir": "linux-64", + "timestamp": 1557857035837, + "version": "0.33.4" + }, + "wheel-0.33.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "dc4e72ba16a70f573e73a59f35c028af", + "name": "wheel", + "sha256": "79fa78bc78dd3b3789f098f23b7b12d0e7f830a79c80a92c80dfeea00f15cdd0", + "size": 43030, + "subdir": "linux-64", + "timestamp": 1569263315807, + "version": "0.33.6" + }, + "wheel-0.33.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "c24ef8c87277ac78de23e86013989ab0", + "name": "wheel", + "sha256": "e5f9297793d43275089d6f41f289ae8826d20f9959c399e4ea3dc5c5d6fd19ec", + "size": 42845, + "subdir": "linux-64", + "timestamp": 1569263320834, + "version": "0.33.6" + }, + "wheel-0.33.6-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "35e1f09cdef0ceecf8460642750e8688", + "name": "wheel", + "sha256": "bde81977c2e8ad0bad2bdb5628aec84ade717f830938bd346950ec99f84872cf", + "size": 42738, + "subdir": "linux-64", + "timestamp": 1569263303880, + "version": "0.33.6" + }, + "wheel-0.33.6-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "6740a19ed109190100a31649ae4e3223", + "name": "wheel", + "sha256": "7e05e1a9f670488fa243005272291b34c0512ad4d5f154c729116da37760eb99", + "size": 38146, + "subdir": "linux-64", + "timestamp": 1572437465923, + "version": "0.33.6" + }, + "wheel-0.34.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "9de9ac9a8bb69d383ced2da538e82f26", + "name": "wheel", + "sha256": "5104cfc81912a87d38c0e7e8697cf27939a9d526c8da93dd9de13a861cf95e5c", + "size": 51339, + "subdir": "linux-64", + "timestamp": 1580399501764, + "version": "0.34.1" + }, + "wheel-0.34.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "fccde1c055eccc72e15ed6e65fb40611", + "name": "wheel", + "sha256": "55f49c10f59c0951bdf05c8491a7566d2aa0c2c4443dc3330a2aa95b12d6df61", + "size": 51459, + "subdir": "linux-64", + "timestamp": 1580399417908, + "version": "0.34.1" + }, + "wheel-0.34.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "d3e29958aad53ec0a4ed5ebf3e5201be", + "name": "wheel", + "sha256": "87ce34a471682a312386fcabe4b53cb4284b60ebd9f5662bdeafbbc4c7c85662", + "size": 51601, + "subdir": "linux-64", + "timestamp": 1580399441638, + "version": "0.34.1" + }, + "wheel-0.34.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "2d0c7a469cd8613e3a0660c7f797687e", + "name": "wheel", + "sha256": "f1142aff6047485d7d8f0df2298e5115cd3b31720d04b9616d41b8f94da20b3e", + "size": 51960, + "subdir": "linux-64", + "timestamp": 1580834165295, + "version": "0.34.2" + }, + "wheel-0.34.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "fbf43c1644b081721856609734ef5cc0", + "name": "wheel", + "sha256": "12048bfcee33443d0baf4789b1500fa7edb743c370efa6562d8de73a0cc19819", + "size": 51837, + "subdir": "linux-64", + "timestamp": 1580834163987, + "version": "0.34.2" + }, + "wheel-0.34.2-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "MIT", + "md5": "961d4e849c57cdfce99dd72774839765", + "name": "wheel", + "sha256": "41cc7d360771258c07b0bf642a62f63b04e5e5db9efde38746c40bbb4446eb00", + "size": 51874, + "subdir": "linux-64", + "timestamp": 1580834172764, + "version": "0.34.2" + }, + "wheel-0.38.4-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fbb0a31c9dbe6a43fd4a8c6abe744890", + "name": "wheel", + "sha256": "b60c6ba0e6a36dce117f693f224589bc541646e3a93e206077ed3a2e9d194540", + "size": 65606, + "subdir": "linux-64", + "timestamp": 1676621847044, + "version": "0.38.4" + }, + "wheel-0.38.4-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b3d14884810655c572ea9a91df7de205", + "name": "wheel", + "sha256": "194e60dd1c842e56defe79d3ae309993d8d8375b0361ebf7092430146eb5759e", + "size": 80947, + "subdir": "linux-64", + "timestamp": 1679340678910, + "version": "0.38.4" + }, + "wheel-0.38.4-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21f1b835f72ae3606855c95edacb3c6e", + "name": "wheel", + "sha256": "62116ee7291006921479bbdee0d89c858a34564ff121d4e2008e865c442a8406", + "size": 64841, + "subdir": "linux-64", + "timestamp": 1676621894403, + "version": "0.38.4" + }, + "wheel-0.38.4-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52f195e95a5f11c5b9a9eed9cd3d6958", + "name": "wheel", + "sha256": "63a2ac3fdc9fe308a3fa51d35d36fc301153a0a8baafb454d3edfb2088d09a3f", + "size": 64992, + "subdir": "linux-64", + "timestamp": 1676621918009, + "version": "0.38.4" + }, + "wheel-0.38.4-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83e731cfecb3797a0f2865615177f433", + "name": "wheel", + "sha256": "9fea62266ddb82be6d8d0465d2841a6271444efc514bbf572cf4ae7b5c6beab8", + "size": 65087, + "subdir": "linux-64", + "timestamp": 1676621870595, + "version": "0.38.4" + }, + "whisper-1.0.2-py27hba602c6_0.conda": { + "build": "py27hba602c6_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache", + "md5": "b2f501fb98259438caaada57d1f5b495", + "name": "whisper", + "sha256": "73d7ff0fe57d8b911a2f072399810ce5dd3d022699f0fb3fed093286b7826e85", + "size": 36606, + "subdir": "linux-64", + "timestamp": 1509213213874, + "version": "1.0.2" + }, + "whisper-1.0.2-py35ha4f42f5_0.conda": { + "build": "py35ha4f42f5_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache", + "md5": "e710b908d064bc1fe531821a3b1a6cef", + "name": "whisper", + "sha256": "6f8c4b432c342889e58d7203a7c3c359514b90fa4b18ab42c9ca1f55aa3edbf8", + "size": 37482, + "subdir": "linux-64", + "timestamp": 1509213186482, + "version": "1.0.2" + }, + "whisper-1.0.2-py36h3df0b0a_0.conda": { + "build": "py36h3df0b0a_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache", + "md5": "847f598c571e6d2cd5c41cc4891375f8", + "name": "whisper", + "sha256": "a76840bdbfa6f9a9c34e3c97eec5a1fbba9144b9444e043bbc9c5fbcc1622b48", + "size": 37133, + "subdir": "linux-64", + "timestamp": 1509213192065, + "version": "1.0.2" + }, + "whisper-1.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache", + "md5": "93857f9dd7f2f7546623b255d0ddd944", + "name": "whisper", + "sha256": "cdd9c331d5dc6a7c40333f33c107d28005f4cd45b3978cf1dbac830ed3acc452", + "size": 37723, + "subdir": "linux-64", + "timestamp": 1519482803397, + "version": "1.1.2" + }, + "whisper-1.1.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache", + "md5": "cfb3c2cf7f836ee40becc9db69d09b87", + "name": "whisper", + "sha256": "3ec589bc1e487d542f7f9ae4a54eae9b13d3b137e9a34f7c7d91d0244f31c72b", + "size": 37631, + "subdir": "linux-64", + "timestamp": 1519482830984, + "version": "1.1.2" + }, + "whisper-1.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache", + "md5": "743f69d99eff328006f6755a2cf1e3c2", + "name": "whisper", + "sha256": "9c3dc6771f25ebbb4129540fb51067483c1b6299839b5a23fe3be2cb6d20ffa8", + "size": 37312, + "subdir": "linux-64", + "timestamp": 1519482764442, + "version": "1.1.2" + }, + "whisper-1.1.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache", + "md5": "09cead18fa6e456e82b7dfd9dcf38b63", + "name": "whisper", + "sha256": "90a9b0f636a2180e44a7ed1c9139c63e861cf68ecabe2f7cd19b2604cd442832", + "size": 37811, + "subdir": "linux-64", + "timestamp": 1524087887518, + "version": "1.1.3" + }, + "whisper-1.1.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache", + "md5": "e898a37c3fc5242f1bc6091bd0db637f", + "name": "whisper", + "sha256": "5278e91f35ec6b929c026d2d3b36db9b61991bc0af563fe0ce2495719992befd", + "size": 37698, + "subdir": "linux-64", + "timestamp": 1524087858203, + "version": "1.1.3" + }, + "whisper-1.1.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache", + "md5": "1fafb2656917a5a855e50413d8d1efbd", + "name": "whisper", + "sha256": "9fa0d828dcfc7119bb1c9b33c45fd5deb12b62987ae068d43bac8c1c38e22f41", + "size": 37827, + "subdir": "linux-64", + "timestamp": 1524087855481, + "version": "1.1.3" + }, + "whisper-1.1.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache", + "md5": "3d66ea4f497861d5efb68ccd73fa076e", + "name": "whisper", + "sha256": "c604c92289f7cb39872f508411ef91f4c8d00133a6d61bbb34d7c46d2c7cc833", + "size": 37202, + "subdir": "linux-64", + "timestamp": 1531060982136, + "version": "1.1.3" + }, + "whisper-1.1.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache", + "md5": "3f7834a42d12919e72effdcf95864f7c", + "name": "whisper", + "sha256": "ddd84e22a2012e6281894dc2fc034aa616ab284d3ca645b95591ca814b89c360", + "size": 37682, + "subdir": "linux-64", + "timestamp": 1536264472352, + "version": "1.1.4" + }, + "whisper-1.1.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "Apache", + "md5": "a4f35f5fa2cf776970a00001906c60d9", + "name": "whisper", + "sha256": "0861362d68760020251db8e3a2ba804ff58f5037438b4d9b6db8d88b1419c9ec", + "size": 38049, + "subdir": "linux-64", + "timestamp": 1536264480483, + "version": "1.1.4" + }, + "whisper-1.1.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache", + "md5": "daa2995d142c4d5ca740cc9dfffb7cdc", + "name": "whisper", + "sha256": "25e221f302c0ce929fcc9cd97b9d34811a51eb600b7bd48a7f75a9897d351255", + "size": 37725, + "subdir": "linux-64", + "timestamp": 1536264419733, + "version": "1.1.4" + }, + "whisper-1.1.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache", + "md5": "954304e3f71a5daee1549fd584623421", + "name": "whisper", + "sha256": "1868a48cd512a245f8a29903c8ed4ec11e2cbc49c8be4331366155381c757c25", + "size": 37745, + "subdir": "linux-64", + "timestamp": 1536264494956, + "version": "1.1.4" + }, + "whisper-1.1.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "Apache", + "md5": "9821e919a0c0d4ca1596bf10e4ea3b25", + "name": "whisper", + "sha256": "f2498d2ba20b3264d1777f7ab2eb2f447e555445bb1192dcb8c4f8623da20f82", + "size": 189644, + "subdir": "linux-64", + "timestamp": 1552402518435, + "version": "1.1.5" + }, + "whisper-1.1.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "Apache", + "md5": "6fb8d381042644a1ac1a64b2e5c29b9b", + "name": "whisper", + "sha256": "b8b6a97e450889775f2def1ca048e0f5f34c71b213245873d35e024690b16cd1", + "size": 38363, + "subdir": "linux-64", + "timestamp": 1640795920100, + "version": "1.1.5" + }, + "whisper-1.1.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "Apache", + "md5": "deafa28a2e548e05b4170131473e8ccb", + "name": "whisper", + "sha256": "c505b3231b77774cff63f1c707672cd823c75339b1f94a67d9112ba3059108bf", + "size": 46831, + "subdir": "linux-64", + "timestamp": 1676907770087, + "version": "1.1.5" + }, + "whisper-1.1.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache", + "md5": "a0e495e01138183004e481be1fd886fd", + "name": "whisper", + "sha256": "2a9fa6a9f4488b9fc039b11df4de1573c90191f8d6700c31004da53ad35c8dca", + "size": 190978, + "subdir": "linux-64", + "timestamp": 1552405194607, + "version": "1.1.5" + }, + "whisper-1.1.5-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "Apache", + "md5": "b9b839311ee06a531d4bf04c64275a1c", + "name": "whisper", + "sha256": "9634cca464761228195d6bcf82dec578040668be62b3f5fac55782c9484117e5", + "size": 281028, + "subdir": "linux-64", + "timestamp": 1614272426753, + "version": "1.1.5" + }, + "whisper-1.1.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache", + "md5": "359ba1e87297c33a437008da141d78d6", + "name": "whisper", + "sha256": "d6eff03775aa655188fbb119cfe8bf53deb98fb8dd5df465e9ac33c6dbe7076a", + "size": 191097, + "subdir": "linux-64", + "timestamp": 1552404997523, + "version": "1.1.5" + }, + "whisper-1.1.5-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "Apache", + "md5": "8a3d3ffeb7dceae951e7b28f4ca80632", + "name": "whisper", + "sha256": "56116d103a54f73d1a1802097739beab0113d801f71cba2619ca381f330aa01b", + "size": 280358, + "subdir": "linux-64", + "timestamp": 1614272432409, + "version": "1.1.5" + }, + "whisper-1.1.5-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache", + "md5": "bf395f5542c8fcd3766a7e2102a1151d", + "name": "whisper", + "sha256": "5a3a6f7ba1339c2e0b9a817097ceb3af58f8d4e843776108438e356e8b03bc17", + "size": 38582, + "subdir": "linux-64", + "timestamp": 1574437351942, + "version": "1.1.5" + }, + "whisper-1.1.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "Apache", + "md5": "11e70cd17a3a6e71c84276d3f0962e6b", + "name": "whisper", + "sha256": "7e503be5932a7093ba30e6ee057256202f84de208b18a46823032ef2d2e32bd0", + "size": 280315, + "subdir": "linux-64", + "timestamp": 1614271414878, + "version": "1.1.5" + }, + "whisper-1.1.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "Apache", + "md5": "6c694a5883a8d6bd7a899127d3d17cdf", + "name": "whisper", + "sha256": "0d148fb5a15bb5505e392f00700ba53b7c4b127166a74e38a8c8d2c6e731406c", + "size": 280850, + "subdir": "linux-64", + "timestamp": 1614272443600, + "version": "1.1.5" + }, + "whoosh-2.7.4-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3e8c35dc0f63d289623cb3b9773d6d59", + "name": "whoosh", + "sha256": "26d8963ba29fcaff1edf3497c2e7e8c76e25c5afe4d286c3dff96abf25ff99b9", + "size": 603456, + "subdir": "linux-64", + "timestamp": 1537812234395, + "version": "2.7.4" + }, + "whoosh-2.7.4-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b07aa679c15cb0f28ebcbff27a5fd665", + "name": "whoosh", + "sha256": "2658bdec71e6b7d13274a55c28404dcc1e4fad3aba53067d980ab09db8af3245", + "size": 625465, + "subdir": "linux-64", + "timestamp": 1537812240126, + "version": "2.7.4" + }, + "whoosh-2.7.4-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "0c1a8ce463088acaf513bc48e1fe4bc4", + "name": "whoosh", + "sha256": "64c79658d5bd5683ead4b4a3bc9c12dc1c8de4536364736131d81fe375af75b8", + "size": 619850, + "subdir": "linux-64", + "timestamp": 1537812267617, + "version": "2.7.4" + }, + "whoosh-2.7.4-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "18f64e3f5fa1c948a5faa5efec4387de", + "name": "whoosh", + "sha256": "0219464353bd2f9976f9cc328c5e1632a598fb90cb52d2af81a14e2dde2d4823", + "size": 625756, + "subdir": "linux-64", + "timestamp": 1537812197322, + "version": "2.7.4" + }, + "widgetsnbextension-3.0.2-py27hcb77dec_1.conda": { + "build": "py27hcb77dec_1", + "build_number": 1, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c0801a54e0e11d1721c84923b29e304f", + "name": "widgetsnbextension", + "sha256": "43bab911bc2b9f31e91d145b95a1c3323b70b0d11295e38f361e70b6aa7375ce", + "size": 748853, + "subdir": "linux-64", + "timestamp": 1505722743065, + "version": "3.0.2" + }, + "widgetsnbextension-3.0.2-py35h0be620c_1.conda": { + "build": "py35h0be620c_1", + "build_number": 1, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b825add564be7bac54198753c88e2319", + "name": "widgetsnbextension", + "sha256": "3687c0839f8981980763ededf91f555dbfe8dcbe95f1f75d1ec3f17ea96aee29", + "size": 751020, + "subdir": "linux-64", + "timestamp": 1505690914432, + "version": "3.0.2" + }, + "widgetsnbextension-3.0.2-py36hd01bb71_1.conda": { + "build": "py36hd01bb71_1", + "build_number": 1, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4994177e4842d72fb10a0ed9c4839def", + "name": "widgetsnbextension", + "sha256": "0b12f64f5f222947e931ca0e6494020b24bcf29fd609d94cc5939eae9fa3cc98", + "size": 750027, + "subdir": "linux-64", + "timestamp": 1505690933948, + "version": "3.0.2" + }, + "widgetsnbextension-3.0.8-py27h618a941_0.conda": { + "build": "py27h618a941_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "c4bc030918c701e735b5de5f555c8f15", + "name": "widgetsnbextension", + "sha256": "48992a01b926c92b4793ec50e8d13a612d2e9c830eb62c2ca61ea0a03f59df81", + "size": 649259, + "subdir": "linux-64", + "timestamp": 1511371690931, + "version": "3.0.8" + }, + "widgetsnbextension-3.0.8-py35h84cb72a_0.conda": { + "build": "py35h84cb72a_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4777c7b09d7385f77d0f8327c0495836", + "name": "widgetsnbextension", + "sha256": "d30bc5521d59ea6c1ec5d119e28706ee6053db0a17c2c8eb3fd4ddc6a3297760", + "size": 655483, + "subdir": "linux-64", + "timestamp": 1511371706908, + "version": "3.0.8" + }, + "widgetsnbextension-3.0.8-py36h25a1d49_0.conda": { + "build": "py36h25a1d49_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "d6419e26f66d622b2a9904dcd47302bc", + "name": "widgetsnbextension", + "sha256": "1c91a9f5c956d484a397840607f70911b544fce15fbd3603134bfc13865f93d2", + "size": 654373, + "subdir": "linux-64", + "timestamp": 1511371722492, + "version": "3.0.8" + }, + "widgetsnbextension-3.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1c5ecf3738f81cb0920d3f2ee6375a1f", + "name": "widgetsnbextension", + "sha256": "b38e7b24f89a34537dfa0e77786acfb741c5e1f9c63772972807768051f18b92", + "size": 650254, + "subdir": "linux-64", + "timestamp": 1515709734657, + "version": "3.1.0" + }, + "widgetsnbextension-3.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "53c24dce53f283bb040724dff815dbf6", + "name": "widgetsnbextension", + "sha256": "49aed32c6210cc6b734bf8b1691755194424388f6cbf6c1f032d071578b408cb", + "size": 649881, + "subdir": "linux-64", + "timestamp": 1515709648977, + "version": "3.1.0" + }, + "widgetsnbextension-3.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7a1e307ba837963fee5ce72e06be1123", + "name": "widgetsnbextension", + "sha256": "a0e2610a50a4c05fa83b14006d50bf9259da933ccb01ee78c3e5ad5b1de0b9bb", + "size": 649611, + "subdir": "linux-64", + "timestamp": 1515709624366, + "version": "3.1.0" + }, + "widgetsnbextension-3.1.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f8cc4a1217335538f3fd5582268e9855", + "name": "widgetsnbextension", + "sha256": "9d681446af61d94fe9b98797bbecc71cbea33c7071f59c423434cd90cca34116", + "size": 648274, + "subdir": "linux-64", + "timestamp": 1519139403790, + "version": "3.1.4" + }, + "widgetsnbextension-3.1.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e43eb3859597b8a280b26289e4cedfd6", + "name": "widgetsnbextension", + "sha256": "57fec02b909953cade54e9f3db5eae55c7aebff1b56f607913fdb6041d50d351", + "size": 648922, + "subdir": "linux-64", + "timestamp": 1519139434876, + "version": "3.1.4" + }, + "widgetsnbextension-3.1.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "ed6331ec591c7b9864eb8d07ddf4912c", + "name": "widgetsnbextension", + "sha256": "6bac7bd55c512b9242d0fa1ed94d41b0b08420b09a366799e65bceef38703b60", + "size": 650222, + "subdir": "linux-64", + "timestamp": 1519139425372, + "version": "3.1.4" + }, + "widgetsnbextension-3.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9638603b5ae659b5d3dfe23f3e166dfe", + "name": "widgetsnbextension", + "sha256": "ba73fc14b80c9bd8577d30c8a937cc7ef46666508b09afbc09b31dd83c588a2f", + "size": 653739, + "subdir": "linux-64", + "timestamp": 1522694655219, + "version": "3.2.0" + }, + "widgetsnbextension-3.2.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "95e9c9d7ea76aaf9eb4f7e9deac5825f", + "name": "widgetsnbextension", + "sha256": "116bab5f01bb6866faaf0b672be131d287cf99a1f672c069e1170dff583224b3", + "size": 654063, + "subdir": "linux-64", + "timestamp": 1522694709767, + "version": "3.2.0" + }, + "widgetsnbextension-3.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0545f509ba6ae3e12578a906ecfb8392", + "name": "widgetsnbextension", + "sha256": "ac2f8677e63c73255fba122e0a0777f5e4666a00e32f8ede441f5a6ab62a74b8", + "size": 655479, + "subdir": "linux-64", + "timestamp": 1522694715030, + "version": "3.2.0" + }, + "widgetsnbextension-3.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "9b19609027199a8f5b8789fef5956a9c", + "name": "widgetsnbextension", + "sha256": "b8cfef6d0141c155ff0276b3e77c897a039f7a0ebdc994a1814a6c50fd42ee5c", + "size": 653048, + "subdir": "linux-64", + "timestamp": 1523971158550, + "version": "3.2.1" + }, + "widgetsnbextension-3.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "b3472e948285a49099e323d08dd89286", + "name": "widgetsnbextension", + "sha256": "8ac18607d1fdc151d48268e3798b9652e8615407d6af14ddc522cd54dc6d0bc0", + "size": 653659, + "subdir": "linux-64", + "timestamp": 1523971230818, + "version": "3.2.1" + }, + "widgetsnbextension-3.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "1431e117822c66c440b658bf98abd95e", + "name": "widgetsnbextension", + "sha256": "450aabf9ec38a3d6283c01d6ba52fc367206c87373d195cf7244629e87c787c4", + "size": 656114, + "subdir": "linux-64", + "timestamp": 1523971238598, + "version": "3.2.1" + }, + "widgetsnbextension-3.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "e777f5a842039effbd551a39e65dc134", + "name": "widgetsnbextension", + "sha256": "e4497f9fcbb3b35f00b25cbaa2dde9863afd4b8338486d0a4f85cdbcd9d9b023", + "size": 654998, + "subdir": "linux-64", + "timestamp": 1530734756504, + "version": "3.2.1" + }, + "widgetsnbextension-3.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "adb9926de7589e357e1da5a100559a35", + "name": "widgetsnbextension", + "sha256": "72c0d066fba274ab71aaff85b77ed76fd7d7a7750f127a932b7c3ea729d34b5a", + "size": 654375, + "subdir": "linux-64", + "timestamp": 1532451324376, + "version": "3.3.0" + }, + "widgetsnbextension-3.3.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4226b5ad0dc78e204e48be201b4bff49", + "name": "widgetsnbextension", + "sha256": "6e91007d18e1ad35d50f744f04255372114810fab8c0e7e5138537dbadbe0998", + "size": 656095, + "subdir": "linux-64", + "timestamp": 1532451390980, + "version": "3.3.0" + }, + "widgetsnbextension-3.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "0948e26900a47bff41bfe8e76051126d", + "name": "widgetsnbextension", + "sha256": "8cd54b4fb7a3c82ba658543c722ec36b9bf947722a968f6fd264242ee8dc54b7", + "size": 656138, + "subdir": "linux-64", + "timestamp": 1532451164265, + "version": "3.3.0" + }, + "widgetsnbextension-3.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a13b2ef598f38b3633671cd1daf9c077", + "name": "widgetsnbextension", + "sha256": "75fe2bda0cc7e272909d38da1e629513410e039d50b04d781bf320ae0ecf617e", + "size": 653407, + "subdir": "linux-64", + "timestamp": 1532451237506, + "version": "3.3.0" + }, + "widgetsnbextension-3.3.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "69bac0a519c16ff69167ee4cccf49ba3", + "name": "widgetsnbextension", + "sha256": "c4c01acda7b50701e5e7fe900612b04c3c7ff464fbe43b82542988a7720f4c5c", + "size": 653284, + "subdir": "linux-64", + "timestamp": 1532970238995, + "version": "3.3.1" + }, + "widgetsnbextension-3.3.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "785d361c27eb379094063b2f8b64caf9", + "name": "widgetsnbextension", + "sha256": "ac9635880a6e5739df0f25e3d2956efd6843421caa7721b8f4987792490ab763", + "size": 654861, + "subdir": "linux-64", + "timestamp": 1532970275365, + "version": "3.3.1" + }, + "widgetsnbextension-3.3.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5f2585b15e94a2c1590fcc5a7ef8710c", + "name": "widgetsnbextension", + "sha256": "f20a8587beec873f026a4533c578702509c5f6b9e0090c85325f055f04cd7470", + "size": 655907, + "subdir": "linux-64", + "timestamp": 1532970104485, + "version": "3.3.1" + }, + "widgetsnbextension-3.3.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "514f27d1698957bb4c7cb81220809b49", + "name": "widgetsnbextension", + "sha256": "d64eb94b3e6e50d4f331772166ed8af6a5674b1e30a614e987c46220e0b6de20", + "size": 653901, + "subdir": "linux-64", + "timestamp": 1532970162151, + "version": "3.3.1" + }, + "widgetsnbextension-3.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "6ecf4571c26e8bb67a8efd3f8686ad0c", + "name": "widgetsnbextension", + "sha256": "13d8261813d07e51ed25bd1c23c17be91074c429d933b0273299d3401181cb55", + "size": 656546, + "subdir": "linux-64", + "timestamp": 1533742936534, + "version": "3.4.0" + }, + "widgetsnbextension-3.4.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "4ac16cef9cac05eac10a7d8d4471af10", + "name": "widgetsnbextension", + "sha256": "8b5bb99cb07cd368f65b163862d0dd5c13a76cde1eddd006b2e4651a79a5d8b0", + "size": 651540, + "subdir": "linux-64", + "timestamp": 1533743471602, + "version": "3.4.0" + }, + "widgetsnbextension-3.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "94ddec73367581bd78926b6d4686579f", + "name": "widgetsnbextension", + "sha256": "f4aee030fb787101fa5f434f1c45df0b221348fd808d7c2948d071f19f30fbe8", + "size": 654388, + "subdir": "linux-64", + "timestamp": 1533742966745, + "version": "3.4.0" + }, + "widgetsnbextension-3.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "bf19dcc7ddf36020c0a6966037d09d02", + "name": "widgetsnbextension", + "sha256": "8b974d4cd50b29e1f49fd2e84659b7e37395979fdd717a188c2b7bb37e0087b4", + "size": 654098, + "subdir": "linux-64", + "timestamp": 1533743061670, + "version": "3.4.0" + }, + "widgetsnbextension-3.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "887db877ae6c4bb5f68e74a0d0120a8d", + "name": "widgetsnbextension", + "sha256": "c1eefcb12aec7d9cc28d0386a4976fd2a27463671542f4d978f402e7dddf3303", + "size": 650540, + "subdir": "linux-64", + "timestamp": 1536075484531, + "version": "3.4.1" + }, + "widgetsnbextension-3.4.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "46606ebe88ac6718e789e43841afcb28", + "name": "widgetsnbextension", + "sha256": "b6fa0e1780c894b6c9a5c7223219252cafce13b8d27e3d172f327a54e3b28af6", + "size": 651360, + "subdir": "linux-64", + "timestamp": 1536075504048, + "version": "3.4.1" + }, + "widgetsnbextension-3.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a55a8fdcfdae2a9c30140c4c82cf060e", + "name": "widgetsnbextension", + "sha256": "1331037ffbf3c5c647e689a2b7719da2b9f872b7ef7eec54174136bf5f8924b9", + "size": 661428, + "subdir": "linux-64", + "timestamp": 1536075433603, + "version": "3.4.1" + }, + "widgetsnbextension-3.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "a805fb1d279421a1ff3a0ad2a931dbb7", + "name": "widgetsnbextension", + "sha256": "269c4430d3fa18d7349120d7b7a983405bd3d40e0f688a1c70bbf0ebd50af1a2", + "size": 661432, + "subdir": "linux-64", + "timestamp": 1536075449851, + "version": "3.4.1" + }, + "widgetsnbextension-3.4.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "63f680fcf3018e3bc9641e5645d830e0", + "name": "widgetsnbextension", + "sha256": "bd851062103e44c5b260556e87000e198773064f4ecea4754cc248af16aef037", + "size": 661365, + "subdir": "linux-64", + "timestamp": 1538155586674, + "version": "3.4.2" + }, + "widgetsnbextension-3.4.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "78d91a11a40ac3aa15a964bc240e2ca1", + "name": "widgetsnbextension", + "sha256": "4c50eda141cef935986212a1e4c2542980adba976fc577e3b85d92072bf6de6c", + "size": 662074, + "subdir": "linux-64", + "timestamp": 1538155589465, + "version": "3.4.2" + }, + "widgetsnbextension-3.4.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "61695c41b56817970a1686ffecc2cf79", + "name": "widgetsnbextension", + "sha256": "2f2b360164b979a0ebacab0d0f90a328ae448e03e55c9e0b97c316e6e910d88b", + "size": 662451, + "subdir": "linux-64", + "timestamp": 1538155566205, + "version": "3.4.2" + }, + "widgetsnbextension-3.5.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "f7e44e0cfd863656b20a65fe0b8a3bb2", + "name": "widgetsnbextension", + "sha256": "1814357f17afac62b782340d326b2c910cbc9894469f8496a0415b31f082fdfb", + "size": 883481, + "subdir": "linux-64", + "timestamp": 1563207662608, + "version": "3.5.0" + }, + "widgetsnbextension-3.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "3dc3e9433b07eca8e04e244f57833cf1", + "name": "widgetsnbextension", + "sha256": "ba00aaaae1b2d63d218975e75801e99154033ec68778d0f139bcb6cc4bd729dd", + "size": 883335, + "subdir": "linux-64", + "timestamp": 1563207662166, + "version": "3.5.0" + }, + "widgetsnbextension-3.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "159b3c224904f8b6346e75b0dcb1f46e", + "name": "widgetsnbextension", + "sha256": "e809ad4ae60f830a85112226b72864a1035506601c67554ee9e5ffe5bad12c4f", + "size": 883412, + "subdir": "linux-64", + "timestamp": 1563207662153, + "version": "3.5.0" + }, + "widgetsnbextension-3.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "235c99c5272ad5b2f9dd91d525afb7b3", + "name": "widgetsnbextension", + "sha256": "4c7c72a5f6193d3b7f122c77278e7054df846785127b3f8eb827bcfdadae718f", + "size": 882089, + "subdir": "linux-64", + "timestamp": 1565958493195, + "version": "3.5.1" + }, + "widgetsnbextension-3.5.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "5aed4b6e49b72ec060d49f20c59d6c20", + "name": "widgetsnbextension", + "sha256": "3dbef0fc17b2ac80a7c33e4e2fdc80145aad21bb3a191a479843c6fc17d46336", + "size": 876551, + "subdir": "linux-64", + "timestamp": 1641918277589, + "version": "3.5.1" + }, + "widgetsnbextension-3.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "91e579e46241e58bd34f91c8d13dc3c2", + "name": "widgetsnbextension", + "sha256": "f4cb507698d00628da0c365f363015550eb23ee7b256ff5951eb9c4534132a1c", + "size": 882686, + "subdir": "linux-64", + "timestamp": 1565959140969, + "version": "3.5.1" + }, + "widgetsnbextension-3.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "64e2440e5330b18e24ed4f3a1033ffea", + "name": "widgetsnbextension", + "sha256": "6be1d88cc15dfac3d732da659b040339a8972de93c881ad5151829e0f3fa19f3", + "size": 882546, + "subdir": "linux-64", + "timestamp": 1565958517961, + "version": "3.5.1" + }, + "widgetsnbextension-3.5.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "18f1de4d8d96594cfff3a4129e24d6e4", + "name": "widgetsnbextension", + "sha256": "1665952a76b7e1ffff88431948746e74f7eb97bf2dc2550032f03c5bfaf08b46", + "size": 887132, + "subdir": "linux-64", + "timestamp": 1580237157572, + "version": "3.5.1" + }, + "widgetsnbextension-3.5.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "684358b3d6d5001039a83870b2b43a33", + "name": "widgetsnbextension", + "sha256": "96977b0c7e2f635e7eba744c880b70ef88760bf1059d418ff5aeda55d2a3cfdf", + "size": 882437, + "subdir": "linux-64", + "timestamp": 1607531565796, + "version": "3.5.1" + }, + "widgetsnbextension-3.5.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d66edb333b077bd0d8641bac50b1f9a7", + "name": "widgetsnbextension", + "sha256": "5e20163143778718fc762f21f26219869939d99ca2b97d1bfc969c4739a26586", + "size": 661169, + "subdir": "linux-64", + "timestamp": 1645009398817, + "version": "3.5.2" + }, + "widgetsnbextension-3.5.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "339050ca1e72364a221dc224f1e0dcfa", + "name": "widgetsnbextension", + "sha256": "bca4c00b545feb4000eeeacf1cd452b16d73965aba648b716fa9f2895ff36af3", + "size": 655044, + "subdir": "linux-64", + "timestamp": 1676827582788, + "version": "3.5.2" + }, + "widgetsnbextension-3.5.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "23dce44e11524ec6a1dfc36d5d32a63a", + "name": "widgetsnbextension", + "sha256": "af01e86ecc77592cea2889c4f2b0f48e15d478a67fec4b062baad4b6f8479357", + "size": 660684, + "subdir": "linux-64", + "timestamp": 1645009388027, + "version": "3.5.2" + }, + "widgetsnbextension-3.5.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "47663c64bca03ff461d06a6a68ee8e86", + "name": "widgetsnbextension", + "sha256": "273338f138c3fab20dc0b73ad2e756d347a7ca71bd51e3e466726aba14648517", + "size": 666155, + "subdir": "linux-64", + "timestamp": 1645009387114, + "version": "3.5.2" + }, + "widgetsnbextension-3.5.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "notebook >=4.4.1", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8e40bfd7a49a78efa17b884e3c3f0693", + "name": "widgetsnbextension", + "sha256": "6b91fc8905753633635b1ce2db66ea70db2c58bf07173f6b6befe59735b68113", + "size": 660750, + "subdir": "linux-64", + "timestamp": 1644992829240, + "version": "3.5.2" + }, + "widgetsnbextension-4.0.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e6af577cb281e9553512e7433598a3cf", + "name": "widgetsnbextension", + "sha256": "051c1a83f5bd61c2bbe95a9c6a8d619feac194149540b9678e6fe35b6c2a3c9e", + "size": 880318, + "subdir": "linux-64", + "timestamp": 1668501827711, + "version": "4.0.3" + }, + "widgetsnbextension-4.0.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a019f9e429500a81b0423b44cb8978e0", + "name": "widgetsnbextension", + "sha256": "b426130f3f250b0ddf6dd98e7c08415472a59b362ee7518afa8f4d5791f6c65d", + "size": 823240, + "subdir": "linux-64", + "timestamp": 1676827566421, + "version": "4.0.3" + }, + "widgetsnbextension-4.0.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5c15bc227addc979a80726fe65f36747", + "name": "widgetsnbextension", + "sha256": "cdb2a9841d85e120c02de5d8a06a0f9d6c6df4681880f084fbb633082e0e44a8", + "size": 880249, + "subdir": "linux-64", + "timestamp": 1668501858455, + "version": "4.0.3" + }, + "widgetsnbextension-4.0.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "91fbca4a828bb4475379ea5f0737b5ab", + "name": "widgetsnbextension", + "sha256": "884efe1090012631facb929935428eda0f44ef715b448664b5719f8bb63f14ee", + "size": 880466, + "subdir": "linux-64", + "timestamp": 1668501888991, + "version": "4.0.3" + }, + "widgetsnbextension-4.0.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "91c7a210a9ae0c4e4cc47f57f2b49926", + "name": "widgetsnbextension", + "sha256": "064bc03f183b494a2739deb8c6c4970c6e91611f0427926b8be0e5ff5259b099", + "size": 880293, + "subdir": "linux-64", + "timestamp": 1668501796649, + "version": "4.0.3" + }, + "widgetsnbextension-4.0.5-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "49ff3fc28b20219da492850d9df4f665", + "name": "widgetsnbextension", + "sha256": "baf373b0cf8775f4bf00fdb202b69d83f27ce30b97866a3b5490911c319edc39", + "size": 895998, + "subdir": "linux-64", + "timestamp": 1679313973748, + "version": "4.0.5" + }, + "widgetsnbextension-4.0.5-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d0d4ffe2e3e7a90181ce802931ad195f", + "name": "widgetsnbextension", + "sha256": "66d70d7b0930ede49c93bc5389fcf9abd06a662e0d4216423b5ea4d6a0652ab4", + "size": 896120, + "subdir": "linux-64", + "timestamp": 1679313945165, + "version": "4.0.5" + }, + "widgetsnbextension-4.0.5-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "60e985b9709752a5a9fbd1a8a89d51da", + "name": "widgetsnbextension", + "sha256": "5c0270924288cc9cbe65a6b94e4d5f8da354baf6f7c2f2f7ae245f092a1ccb21", + "size": 895619, + "subdir": "linux-64", + "timestamp": 1679313890777, + "version": "4.0.5" + }, + "widgetsnbextension-4.0.5-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dec3d5546d1dc96b26bd095708b2cc4d", + "name": "widgetsnbextension", + "sha256": "16eedcba2c90a545372229e5745da88ad66d4d818c7dbf983a00087fc69afaf6", + "size": 895923, + "subdir": "linux-64", + "timestamp": 1679313917195, + "version": "4.0.5" + }, + "winsdk-10.0.17763.0-hc402f9b_0.conda": { + "build": "hc402f9b_0", + "build_number": 0, + "depends": [ + "curl", + "msitools", + "p7zip" + ], + "license": "LicenseRef-MICROSOFT_SDK", + "license_family": "Proprietary", + "md5": "3a693a68573b0b028e1149942218b5b5", + "name": "winsdk", + "sha256": "8c614f4b706a989c404830f36f748b2a21b910cdb055641df2d4b731286b19f1", + "size": 34935, + "subdir": "linux-64", + "timestamp": 1668352701562, + "version": "10.0.17763.0" + }, + "word2vec-0.9.2-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5de7bc5793861e6ebe2e8d47871a557b", + "name": "word2vec", + "sha256": "1f3980418563d86699933be17b753bd5d41b7b30dd5ba168aa87d1f858245c64", + "size": 75658, + "subdir": "linux-64", + "timestamp": 1515213616966, + "version": "0.9.2" + }, + "word2vec-0.9.2-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.13.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e7ddb145a3755c31ced6e86a8cc51c38", + "name": "word2vec", + "sha256": "6efc15674bcd225214c1295bdce9192baa6f9506da3b2dc7577c81460e9070c7", + "size": 76233, + "subdir": "linux-64", + "timestamp": 1515213621153, + "version": "0.9.2" + }, + "word2vec-0.9.2-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.9.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2e688c90b50c37e252c8f6d7cdbb540e", + "name": "word2vec", + "sha256": "8b84d0f58b8a947c874c54ee653475b3bd11b87e72a3ff5b56649bc90cf2ced0", + "size": 75935, + "subdir": "linux-64", + "timestamp": 1515213574730, + "version": "0.9.2" + }, + "word2vec-0.9.4-py27h035aef0_0.conda": { + "build": "py27h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c49d08bae42b5ebeb886ee1e19c95915", + "name": "word2vec", + "sha256": "f13790079b69d4149f9ebdd21040c25fa9e3e8fb56896a1c28455172cb022abb", + "size": 76703, + "subdir": "linux-64", + "timestamp": 1529437790986, + "version": "0.9.4" + }, + "word2vec-0.9.4-py310h9102076_0.conda": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ec7b2a307095038db0741f90af8369e3", + "name": "word2vec", + "sha256": "f85c387b464902f9a9964f77d1df5c3fb90155115294fa9cb1534de851bf1837", + "size": 98254, + "subdir": "linux-64", + "timestamp": 1640795956016, + "version": "0.9.4" + }, + "word2vec-0.9.4-py311hbed6279_0.conda": { + "build": "py311hbed6279_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "numpy >=1.22.3,<2.0a0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "51e0c8c40df9da46f87d5cba8d01a848", + "name": "word2vec", + "sha256": "6ba911ca41696b0992b3bcd96e3488a23dc72310c74a353e0577f3c4cca83d75", + "size": 83606, + "subdir": "linux-64", + "timestamp": 1676907795551, + "version": "0.9.4" + }, + "word2vec-0.9.4-py35h035aef0_0.conda": { + "build": "py35h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ee5b38eeaf7178957c95f521dfb0a045", + "name": "word2vec", + "sha256": "e07be92f621de618f1efb49825ad074bd29c4dcf1220772dc67895d9db08a52f", + "size": 77267, + "subdir": "linux-64", + "timestamp": 1529437792428, + "version": "0.9.4" + }, + "word2vec-0.9.4-py36h035aef0_0.conda": { + "build": "py36h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "054b28750545ef43a539e8561f5cf5b6", + "name": "word2vec", + "sha256": "d37f79a18d893cc2aaef8e5cd0b0c538bb3ad5fc39864f1588455cd31a6235a7", + "size": 76668, + "subdir": "linux-64", + "timestamp": 1529437319164, + "version": "0.9.4" + }, + "word2vec-0.9.4-py36h6323ea4_0.conda": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "961bb09c32a42740532e53a83e845be3", + "name": "word2vec", + "sha256": "20653e0870bdaf318710636ef87a16c67853a021e01e8849976df8427cc4c5b1", + "size": 318490, + "subdir": "linux-64", + "timestamp": 1613040237136, + "version": "0.9.4" + }, + "word2vec-0.9.4-py36heb32a55_0.conda": { + "build": "py36heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "80d4a2469b31ecbc598dc2ba42d50ae2", + "name": "word2vec", + "sha256": "f8b32a481e916f1225a869b6e5287e9d69f007f99ec2618f5e6e9dc1d57e1b08", + "size": 267250, + "subdir": "linux-64", + "timestamp": 1592481982060, + "version": "0.9.4" + }, + "word2vec-0.9.4-py37h035aef0_0.conda": { + "build": "py37h035aef0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1984ed1b86a60d6098d360d6fa0667e1", + "name": "word2vec", + "sha256": "cd39eca96b2e18a86c8c33146639c22d4a3317a3b2c4b7651429f00efc315ce0", + "size": 76629, + "subdir": "linux-64", + "timestamp": 1531061031797, + "version": "0.9.4" + }, + "word2vec-0.9.4-py37h6323ea4_0.conda": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "609ea4853babed14c978a1906974c025", + "name": "word2vec", + "sha256": "32bc5c405d6581004b88a8d7023b68a39916834313ca8aed7cdc98448c799427", + "size": 316399, + "subdir": "linux-64", + "timestamp": 1613040242966, + "version": "0.9.4" + }, + "word2vec-0.9.4-py37heb32a55_0.conda": { + "build": "py37heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0e223ecef42e9642d670d96c0a42df62", + "name": "word2vec", + "sha256": "7e2bf86ef341fb09e3d16e12d9b6afa444029b497895ba35fd5c4eb4670dc4f7", + "size": 267811, + "subdir": "linux-64", + "timestamp": 1592481981119, + "version": "0.9.4" + }, + "word2vec-0.9.4-py38h6323ea4_0.conda": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "618c45365c288879678e950328c905a1", + "name": "word2vec", + "sha256": "f8478188ccf1dfb41c0aa16bebdebcd7fe910613aa938b60ac96895165b9add5", + "size": 315104, + "subdir": "linux-64", + "timestamp": 1613040243732, + "version": "0.9.4" + }, + "word2vec-0.9.4-py38heb32a55_0.conda": { + "build": "py38heb32a55_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.14.6,<2.0a0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4599db0aded93875d97989931e08ae58", + "name": "word2vec", + "sha256": "144e982c310d0222cff1a98de88bccb57e3014cb0fd1312f5cf007fccdf1c193", + "size": 268318, + "subdir": "linux-64", + "timestamp": 1592481934628, + "version": "0.9.4" + }, + "word2vec-0.9.4-py39h6323ea4_0.conda": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bbf3ce2ecddef0652fb1500d57392a67", + "name": "word2vec", + "sha256": "72d5f4b50b8c06dc5864303e17c437b9c9d5f411d6c0734b8605641bc9770a1a", + "size": 314284, + "subdir": "linux-64", + "timestamp": 1613040244866, + "version": "0.9.4" + }, + "workerpool-0.9.4-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "MIT", + "md5": "83218719d3036023b2dccc83aadd99b0", + "name": "workerpool", + "sha256": "2e895d941e1971f7c0a7d02538d67152dded70a9b7acbd1cb4537939be1a6281", + "size": 11505, + "subdir": "linux-64", + "timestamp": 1537836868015, + "version": "0.9.4" + }, + "workerpool-0.9.4-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0", + "six" + ], + "license": "MIT", + "md5": "039bdc45392907f9b9c621fa71fd9e40", + "name": "workerpool", + "sha256": "56b627389df82e9f7ce16987335f67b1115d8282e4df48ef039a93e7da74c9cb", + "size": 12225, + "subdir": "linux-64", + "timestamp": 1640795980806, + "version": "0.9.4" + }, + "workerpool-0.9.4-py311h06a4308_2.conda": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0", + "six" + ], + "license": "MIT", + "md5": "6650851f86e2e49f96eacfe9f7f56776", + "name": "workerpool", + "sha256": "c873df03eb277bb22bc4dc49877d6b429a2f4d483721814b63d35ae09333137d", + "size": 13799, + "subdir": "linux-64", + "timestamp": 1676907814858, + "version": "0.9.4" + }, + "workerpool-0.9.4-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0", + "six" + ], + "license": "MIT", + "md5": "c697bdc0e4e1ad4fbeec12b15301ab7c", + "name": "workerpool", + "sha256": "43c644c5212399c2206b29041579dd52452898bd64591819f984813eae406966", + "size": 11738, + "subdir": "linux-64", + "timestamp": 1537882257137, + "version": "0.9.4" + }, + "workerpool-0.9.4-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "80bb4aa38e0fab60f77807e972ce2e39", + "name": "workerpool", + "sha256": "e45954e6a690823b863f4a480cc305e4bf1c3b4ed29ac6784e95fb4b275be886", + "size": 11757, + "subdir": "linux-64", + "timestamp": 1537836935725, + "version": "0.9.4" + }, + "workerpool-0.9.4-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "six" + ], + "license": "MIT", + "md5": "ec26b61f3ec0260039f7d9ea4f177d64", + "name": "workerpool", + "sha256": "086e40198bd2c135081348c21761fca9ed261cd4dc7d2e153b9d394b941adf02", + "size": 304959, + "subdir": "linux-64", + "timestamp": 1632746627379, + "version": "0.9.4" + }, + "workerpool-0.9.4-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "2affd30ca40ee3725238cdbe27f1a4d3", + "name": "workerpool", + "sha256": "2c443074f37ef9c3b00c42ceeac9f423d6737540f8c9483e2fdd618de554069b", + "size": 11655, + "subdir": "linux-64", + "timestamp": 1537836862764, + "version": "0.9.4" + }, + "workerpool-0.9.4-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "six" + ], + "license": "MIT", + "md5": "69f940e73ebe44f4bab3b23e3648718c", + "name": "workerpool", + "sha256": "34c7a40f71274c87160b35a24c0c8aa0d91b19a5e669a7e58e5467aa5b945ae4", + "size": 304719, + "subdir": "linux-64", + "timestamp": 1632746609161, + "version": "0.9.4" + }, + "workerpool-0.9.4-py38_2.conda": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "md5": "f468e3a5a7a072bcec17e12055576d01", + "name": "workerpool", + "sha256": "70d64947ca372edf99f676e337a495ce5ea443a2d90830edb14ceb1acc7b4686", + "size": 12112, + "subdir": "linux-64", + "timestamp": 1574437367937, + "version": "0.9.4" + }, + "workerpool-0.9.4-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "six" + ], + "license": "MIT", + "md5": "e2517e1d48f6176c4693b2c92aae963e", + "name": "workerpool", + "sha256": "86d839e3f4aae93b96e707f11cebaf6da0b1901509816b49cf586dd1a125c795", + "size": 304573, + "subdir": "linux-64", + "timestamp": 1632756982701, + "version": "0.9.4" + }, + "workerpool-0.9.4-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0", + "six" + ], + "license": "MIT", + "md5": "fa87a80f0e83e42a98be77ad0880d3d0", + "name": "workerpool", + "sha256": "999231843ab3d6e59b5b48b694c97d390c8cfa77fe1d7ee8400a41a396f22d0a", + "size": 305113, + "subdir": "linux-64", + "timestamp": 1632746538947, + "version": "0.9.4" + }, + "wrapt-1.10.11-py27h04f6869_0.conda": { + "build": "py27h04f6869_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "6f7a1348028348eba5fcd1bce99850d5", + "name": "wrapt", + "sha256": "3bcf2b14ac09dc3202d1f3e2f3621a0a04abbd3f1acc8bbadc384cfdcafb8a88", + "size": 45902, + "subdir": "linux-64", + "timestamp": 1505693861107, + "version": "1.10.11" + }, + "wrapt-1.10.11-py27h14c3975_2.conda": { + "build": "py27h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "72a01032feed77c94b94520164ab34f2", + "name": "wrapt", + "sha256": "cab031523a3f14f85a0c329801d4b8bd16bb0eb4d8f51732e63e85dc05ac4c2a", + "size": 46215, + "subdir": "linux-64", + "timestamp": 1530736620856, + "version": "1.10.11" + }, + "wrapt-1.10.11-py35h14c3975_2.conda": { + "build": "py35h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "253870cf106d95a7b31e3a838e7207ff", + "name": "wrapt", + "sha256": "b75fa54482dc45c75380b1adebd55d095a1ee410f3453a88b261f5450f1ec54c", + "size": 46639, + "subdir": "linux-64", + "timestamp": 1534352309509, + "version": "1.10.11" + }, + "wrapt-1.10.11-py35hfdafd39_0.conda": { + "build": "py35hfdafd39_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "md5": "752aaf1d047aa2498bce4dbb53c82948", + "name": "wrapt", + "sha256": "dd4a5e885c9555e2e96de48edc8fa4393246fc3743f1e6e8b51cbb6cb19a8c8f", + "size": 46652, + "subdir": "linux-64", + "timestamp": 1505693876080, + "version": "1.10.11" + }, + "wrapt-1.10.11-py36h14c3975_2.conda": { + "build": "py36h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "1adcb7fde067708573ff06f18c66df5e", + "name": "wrapt", + "sha256": "f8b033a406fcd76143291763234411dd1f288d7642be1d203fbbc2785a589b2c", + "size": 46298, + "subdir": "linux-64", + "timestamp": 1530736598786, + "version": "1.10.11" + }, + "wrapt-1.10.11-py36h28b7045_0.conda": { + "build": "py36h28b7045_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "250cfd67b8d5657a5a1825279cb08220", + "name": "wrapt", + "sha256": "d4d66d6ac2783579155a4e22fc63f4bc0a3b37620488092ce19c221eb216ad42", + "size": 46081, + "subdir": "linux-64", + "timestamp": 1505693891235, + "version": "1.10.11" + }, + "wrapt-1.10.11-py37h14c3975_2.conda": { + "build": "py37h14c3975_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "9675608247169a88a12dc60603c5b0c9", + "name": "wrapt", + "sha256": "7e1cfa2464ee23dd48079f4c12035773f01ed9bd8884bd9a146651664c58c312", + "size": 46713, + "subdir": "linux-64", + "timestamp": 1530736642849, + "version": "1.10.11" + }, + "wrapt-1.11.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "159f4750d02edd1ca7c9d470216f6e65", + "name": "wrapt", + "sha256": "746f06f91a5f525403d697dbd2790c2958dd81f33027e68e95f53ddc79746e04", + "size": 46647, + "subdir": "linux-64", + "timestamp": 1547909248778, + "version": "1.11.0" + }, + "wrapt-1.11.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "50ddfb7e022b85f4f57d7f7c27d1ea63", + "name": "wrapt", + "sha256": "2b646c3e6d1f457ed6f4644afd8bdbe0419b13f19301af5449a1daa21e0e3263", + "size": 46980, + "subdir": "linux-64", + "timestamp": 1547909326738, + "version": "1.11.0" + }, + "wrapt-1.11.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "24896eb1233e822462532f851eb8cc9e", + "name": "wrapt", + "sha256": "94818525b420b26259cbd17b4abef74513864b645016597ef76b407a800f29bc", + "size": 46980, + "subdir": "linux-64", + "timestamp": 1547909341411, + "version": "1.11.0" + }, + "wrapt-1.11.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "4dce2b877b4f754c953ffa6dc45f5053", + "name": "wrapt", + "sha256": "7a8eac1f70fad8f6f1c2f5f6282be49cdeb176aeee1af61340d82a4d92b74bb1", + "size": 47537, + "subdir": "linux-64", + "timestamp": 1549637180633, + "version": "1.11.1" + }, + "wrapt-1.11.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "55065eb693cc83897735156b4678b1b8", + "name": "wrapt", + "sha256": "1f2aa7186d9b15166d3ef8cfb16fcdf6dcedabf911df9f8b19e32e393a576473", + "size": 47755, + "subdir": "linux-64", + "timestamp": 1549637199042, + "version": "1.11.1" + }, + "wrapt-1.11.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "326d2fe21ce653bf8814f89d2e3373d2", + "name": "wrapt", + "sha256": "8fe33014dbe6036cb689347c764de89a0862f003e338c709fc92c7b508050cd1", + "size": 47745, + "subdir": "linux-64", + "timestamp": 1549637159351, + "version": "1.11.1" + }, + "wrapt-1.11.2-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "99a7d80506355896db906696a7038485", + "name": "wrapt", + "sha256": "cbe7e09d8cbeeff20eabd29134a3ce3eda2d92394f7bf5612a5f40caa0b43dc8", + "size": 49653, + "subdir": "linux-64", + "timestamp": 1562087085483, + "version": "1.11.2" + }, + "wrapt-1.11.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "0d16e4a59dcae0e85ee441b4574ed368", + "name": "wrapt", + "sha256": "51a43e5822eb678bf567258a55e089d1689d83fa5626436908a21e3e0c1c9647", + "size": 50075, + "subdir": "linux-64", + "timestamp": 1562087104596, + "version": "1.11.2" + }, + "wrapt-1.11.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "83cd5b584cb2d5be259958ac12bff797", + "name": "wrapt", + "sha256": "8a2f3f4c0c733a36e7404ad0a9cce084b6ee05d3799d2fac5ab023cfec76b0cb", + "size": 50171, + "subdir": "linux-64", + "timestamp": 1562087105302, + "version": "1.11.2" + }, + "wrapt-1.11.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "md5": "d1673dadfb07008b3e2f30e670bedd7a", + "name": "wrapt", + "sha256": "a05d23d95e62b0d70218b44a3ea8388ca9937d848db9ebf393a7263c13b9b1fe", + "size": 54331, + "subdir": "linux-64", + "timestamp": 1573200465137, + "version": "1.11.2" + }, + "wrapt-1.11.2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "md5": "fbfa801e0501cfabd7c8b4c9d2e836e9", + "name": "wrapt", + "sha256": "dc39be15c7423d5a3ba3befe251a2f51c6a088dc7a3783e1bd97141714e42c73", + "size": 50758, + "subdir": "linux-64", + "timestamp": 1607712559171, + "version": "1.11.2" + }, + "wrapt-1.12.1-py36h7b6447c_1.conda": { + "build": "py36h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "md5": "d8ae300758ab95f71f526151893985e1", + "name": "wrapt", + "sha256": "97f2f14035a5bba12646e58007d60328089572f17c02e5c9342f96fa6bf2d209", + "size": 50201, + "subdir": "linux-64", + "timestamp": 1584459673785, + "version": "1.12.1" + }, + "wrapt-1.12.1-py37h7b6447c_1.conda": { + "build": "py37h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "2d8e9baa44b314c2e1d117417ce47480", + "name": "wrapt", + "sha256": "8d51c518abfbf8e9d10c484d57f16ca5d3e5f320e494504f479734496cb13cc0", + "size": 50116, + "subdir": "linux-64", + "timestamp": 1584459646855, + "version": "1.12.1" + }, + "wrapt-1.12.1-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "md5": "73f3e24df328715b26f1e74a27487cce", + "name": "wrapt", + "sha256": "f723c6deac3d0ae7b48d5fdd19a31cac274d79741cd8d5aae854cca714e10da3", + "size": 51215, + "subdir": "linux-64", + "timestamp": 1584459748636, + "version": "1.12.1" + }, + "wrapt-1.12.1-py39he8ac12f_1.conda": { + "build": "py39he8ac12f_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "md5": "ec2a15681e907ca78952dbe675371f35", + "name": "wrapt", + "sha256": "b426ea2aefe728b2015f3658cf43512022edb3f2ce1e84150c1b24ab337cbce1", + "size": 51255, + "subdir": "linux-64", + "timestamp": 1607574535188, + "version": "1.12.1" + }, + "wrapt-1.13.3-py310h7f8727e_2.conda": { + "build": "py310h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "8d7b6f08eb1b5164bd3a2d4359f4ac06", + "name": "wrapt", + "sha256": "a8f0dfd4eb04a8499d0076dc70cd506acc4e1696a3e9bd8269dc784f934079ef", + "size": 79994, + "subdir": "linux-64", + "timestamp": 1640796005412, + "version": "1.13.3" + }, + "wrapt-1.13.3-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "472f6467a00b930f3bf4b9d75989d4d3", + "name": "wrapt", + "sha256": "4a5d7a8055c21c6bbb3011fcdb26b59ada8188c65eaeabf836d37771984b7b0f", + "size": 48443, + "subdir": "linux-64", + "timestamp": 1638260486585, + "version": "1.13.3" + }, + "wrapt-1.13.3-py37h7f8727e_1.conda": { + "build": "py37h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "md5": "a1c14d872e8a332b0f0a7749cdf1e1a4", + "name": "wrapt", + "sha256": "5ad14b609d149e56d9d32ff8e6b533c93beb8c00b4e5d6efd78bc40c3b29c662", + "size": 48581, + "subdir": "linux-64", + "timestamp": 1637920109734, + "version": "1.13.3" + }, + "wrapt-1.13.3-py37h7f8727e_2.conda": { + "build": "py37h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "a7ad194258026794fa78e9213af10117", + "name": "wrapt", + "sha256": "5e6f3d4fc9a4807bfd0cc35f92939b73ceda5e6cd9121ae77ee6f99722995e67", + "size": 52025, + "subdir": "linux-64", + "timestamp": 1638420669364, + "version": "1.13.3" + }, + "wrapt-1.13.3-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "4e33b48a36cf20a13fffae2d56a0f388", + "name": "wrapt", + "sha256": "00766c1f958526b0aedc1562da9f30ea6184f1af4009fa7099880a0743c8da17", + "size": 48835, + "subdir": "linux-64", + "timestamp": 1638260465960, + "version": "1.13.3" + }, + "wrapt-1.13.3-py38h7f8727e_1.conda": { + "build": "py38h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 2-Clause", + "md5": "56b977aec7e8482e769eb97b4dc43011", + "name": "wrapt", + "sha256": "28b86da2a814cc6e1cd942d755642f7abd972ca8387f72bf78b6693d1c517ced", + "size": 49159, + "subdir": "linux-64", + "timestamp": 1637920111562, + "version": "1.13.3" + }, + "wrapt-1.13.3-py38h7f8727e_2.conda": { + "build": "py38h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "5e143cb85266638a95e89a17769555d4", + "name": "wrapt", + "sha256": "ff84f2754e3ac6c3c09b0d3748c4a6d3da5a8d36937ade924a341b7d59d8776e", + "size": 52431, + "subdir": "linux-64", + "timestamp": 1638433279490, + "version": "1.13.3" + }, + "wrapt-1.13.3-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "2963c16e19c2f68df71c33be679a0dc3", + "name": "wrapt", + "sha256": "1aeb5bb7eec41934a0016c2239d6e5d3526001ec3d62f0e8abf4e0570bc98338", + "size": 49629, + "subdir": "linux-64", + "timestamp": 1638260474224, + "version": "1.13.3" + }, + "wrapt-1.13.3-py39h7f8727e_1.conda": { + "build": "py39h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 2-Clause", + "md5": "4ab26e7796dd996be4fd163cc93e9113", + "name": "wrapt", + "sha256": "0f103bb5e84f53bc885a0a75781565fd20ce52d5da392b922f238c3fdb094452", + "size": 48944, + "subdir": "linux-64", + "timestamp": 1637920102064, + "version": "1.13.3" + }, + "wrapt-1.13.3-py39h7f8727e_2.conda": { + "build": "py39h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "b8d41db2df67265bfd1610df8f2c4a61", + "name": "wrapt", + "sha256": "77c05707b9b7cdd28c615b67b21f50b10579b09b9722b8c0ef54ee796b7f5f45", + "size": 52772, + "subdir": "linux-64", + "timestamp": 1638433893758, + "version": "1.13.3" + }, + "wrapt-1.14.1-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "1c4178db7bd2beaf7b4124da7b7d5a8b", + "name": "wrapt", + "sha256": "1136e0314e3aaa682acb0446b6652ceddcd607707a4c6225351b11e745dbd8a3", + "size": 83028, + "subdir": "linux-64", + "timestamp": 1657814488569, + "version": "1.14.1" + }, + "wrapt-1.14.1-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "247e9364d537d4ed5d1bcf88bdb72da2", + "name": "wrapt", + "sha256": "441352e003dbbef3e2d3fb130b097b5841ba2b8ea17050c9bfec3b856a314e5b", + "size": 59622, + "subdir": "linux-64", + "timestamp": 1676827602470, + "version": "1.14.1" + }, + "wrapt-1.14.1-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "1c86374ca8f5bc2b7e7ec269919a2456", + "name": "wrapt", + "sha256": "80d916f6b0eb4bf455999bbeb3fa468804fd4cc383b637d153e5f79a3b4c1586", + "size": 51506, + "subdir": "linux-64", + "timestamp": 1657814445721, + "version": "1.14.1" + }, + "wrapt-1.14.1-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "def9efeac6639a829003fc62b8d5475e", + "name": "wrapt", + "sha256": "d606382133bc73a244a97ea3d8802684eb900414a0653a98826e3099bc05c703", + "size": 51996, + "subdir": "linux-64", + "timestamp": 1657814516213, + "version": "1.14.1" + }, + "wrapt-1.14.1-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "6c31330ecebe26d66e4678ed131d7b80", + "name": "wrapt", + "sha256": "604b273f4971a68b309f807bfff88851104c0b2b9e0501fe26a0d2622897d3c0", + "size": 51924, + "subdir": "linux-64", + "timestamp": 1657814543605, + "version": "1.14.1" + }, + "ws4py-0.4.2-py27hbd04d0f_0.conda": { + "build": "py27hbd04d0f_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "35ae566fd3d557c684d36e1496ce0972", + "name": "ws4py", + "sha256": "ea5a6d4a2a4d34d22c35ab57b2e6e1072f266499199cb1cb23d239fe8e084b4a", + "size": 58315, + "subdir": "linux-64", + "timestamp": 1507268699890, + "version": "0.4.2" + }, + "ws4py-0.4.2-py35he0e66b0_0.conda": { + "build": "py35he0e66b0_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "21291da042217e95cc69f84b757d9b34", + "name": "ws4py", + "sha256": "42c493bc703f38ab3c3c30bbbedab1082a9adb5f8ea6571db42da04f715a4916", + "size": 60214, + "subdir": "linux-64", + "timestamp": 1507268700333, + "version": "0.4.2" + }, + "ws4py-0.4.2-py36haccdab7_0.conda": { + "build": "py36haccdab7_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "797390353919136c2a7f79ff89e40150", + "name": "ws4py", + "sha256": "825298151b8b6f0de685b374b306ef84ef8f1209ade80a0cfdb1e2a4f7273e4f", + "size": 59657, + "subdir": "linux-64", + "timestamp": 1507268718499, + "version": "0.4.2" + }, + "ws4py-0.5.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "d3671baaba28f0b46dc73f61a86f911e", + "name": "ws4py", + "sha256": "bc87e2d01167bcf09a1466e11684b0af68caec813c05f544b30684bd11b3df60", + "size": 58631, + "subdir": "linux-64", + "timestamp": 1522103958104, + "version": "0.5.1" + }, + "ws4py-0.5.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e02bca84f19767fed0be0102bf78c67e", + "name": "ws4py", + "sha256": "317458943b6c84f4d6442530e357bba072a4f2a794167706e9e3db43e7f75702", + "size": 61654, + "subdir": "linux-64", + "timestamp": 1640796023994, + "version": "0.5.1" + }, + "ws4py-0.5.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c2d5571af07a50fad8f75b12c4177f3a", + "name": "ws4py", + "sha256": "c1c3b09f99d87995699b34381880b3154abd691100bc251adc6a1f4ea08cdf53", + "size": 81195, + "subdir": "linux-64", + "timestamp": 1676863533066, + "version": "0.5.1" + }, + "ws4py-0.5.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "db06d49128d20cc29f71e13ea3328473", + "name": "ws4py", + "sha256": "14bf31dd8fd05339e5ead807a32b27ef4f2a3e64af6a9b0248cc1d1735ad185f", + "size": 65928, + "subdir": "linux-64", + "timestamp": 1522103954398, + "version": "0.5.1" + }, + "ws4py-0.5.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "549932f3ddf8bb966a6080887fcdf24f", + "name": "ws4py", + "sha256": "a823f2bd3506f4780036e1d18dfd0f6b06f1fd520a669c0667f0155ab1d3af4e", + "size": 65297, + "subdir": "linux-64", + "timestamp": 1522103954640, + "version": "0.5.1" + }, + "ws4py-0.5.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a71e56134c15e5ff155473926303f1ff", + "name": "ws4py", + "sha256": "1a6f67acaba27a2d63c6bd9447713858c0ac8778ac26bb8c658d5566342c0e48", + "size": 66505, + "subdir": "linux-64", + "timestamp": 1613159175254, + "version": "0.5.1" + }, + "ws4py-0.5.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "f1f430bbf3ab3e56d150825ed2525db2", + "name": "ws4py", + "sha256": "85292ba9633099aa70548c3b356dc51cea69d8a6f6f3c1ae4df0152c8b81dd7e", + "size": 61246, + "subdir": "linux-64", + "timestamp": 1531061071395, + "version": "0.5.1" + }, + "ws4py-0.5.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "4d48913637ad6fda26066a310a9947a2", + "name": "ws4py", + "sha256": "86a225cfd8c410f7f7bf7254691e11ecc52681422aec641e3ec7efe94a12b5a4", + "size": 63516, + "subdir": "linux-64", + "timestamp": 1613158705460, + "version": "0.5.1" + }, + "ws4py-0.5.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "c6476460cff8b6988bfe39c7b360ae0f", + "name": "ws4py", + "sha256": "a28db4da70d80aa68cd23ef6a5d5616c4e143bf82ebf914dc6d966b7a6b49eed", + "size": 62284, + "subdir": "linux-64", + "timestamp": 1573200476656, + "version": "0.5.1" + }, + "ws4py-0.5.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "e5c31fee3319a7481cfa0c2740318a5d", + "name": "ws4py", + "sha256": "4b4426affce8c6ec990b953d2441e4f5a321717e48a202002e6ee4d1e7b5fd82", + "size": 62778, + "subdir": "linux-64", + "timestamp": 1613159161899, + "version": "0.5.1" + }, + "ws4py-0.5.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "05065f8d32b3ca13db59b4f63fe88c9b", + "name": "ws4py", + "sha256": "334cc59c40a53e90adc877193e57957d3b17508c0c6deb50e6aac8c8ca84fde8", + "size": 62770, + "subdir": "linux-64", + "timestamp": 1613159168740, + "version": "0.5.1" + }, + "wsgiproxy2-0.4.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "webob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb2476e7167076818bb9592fc74bdc6c", + "name": "wsgiproxy2", + "sha256": "b5f516389c29c69024cde1b5a7d9705309789747e462dc9bde50dd147d9ad61c", + "size": 17381, + "subdir": "linux-64", + "timestamp": 1530875613623, + "version": "0.4.4" + }, + "wsgiproxy2-0.4.4-py27hfc095f2_0.conda": { + "build": "py27hfc095f2_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "webob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22468a825a908a8faca2f9621cc09bcd", + "name": "wsgiproxy2", + "sha256": "d3e594fc7591f05cf9c5963141534e5d1f97b7ae7fda8cef0c948dafec261fc7", + "size": 17642, + "subdir": "linux-64", + "timestamp": 1509398997763, + "version": "0.4.4" + }, + "wsgiproxy2-0.4.4-py35hb7a3433_0.conda": { + "build": "py35hb7a3433_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools", + "six", + "webob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f88fdaa232e3716dd2fa6d3547bbbaec", + "name": "wsgiproxy2", + "sha256": "5231f038b08cbf274e7e3ddcdb0d3cc0fb959fff33b2904595a3b4850cd2cb71", + "size": 18007, + "subdir": "linux-64", + "timestamp": 1509399005965, + "version": "0.4.4" + }, + "wsgiproxy2-0.4.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "webob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a529d1aa43a20284b2760b3a5e1cc5cb", + "name": "wsgiproxy2", + "sha256": "e1963701fc436af2b5d2aba1ba960f26163b3036342bc685b6338a8959dd0e13", + "size": 17534, + "subdir": "linux-64", + "timestamp": 1530875561217, + "version": "0.4.4" + }, + "wsgiproxy2-0.4.4-py36h8281bc4_0.conda": { + "build": "py36h8281bc4_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "webob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e95b8932a33a4eb97099ad5edd859d28", + "name": "wsgiproxy2", + "sha256": "6f5e4e41bc16efde40c58849d45bd1753a0aa41124b501cb9f181cdedced374c", + "size": 17866, + "subdir": "linux-64", + "timestamp": 1509399006026, + "version": "0.4.4" + }, + "wsgiproxy2-0.4.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "webob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "557ef5d2c31c459cca0ae130bdf464f5", + "name": "wsgiproxy2", + "sha256": "26cb51c6a64e92288906c5ae370ebff4efaea60aeb3d46a59e8d2cd173110f91", + "size": 17664, + "subdir": "linux-64", + "timestamp": 1530875588089, + "version": "0.4.4" + }, + "wsgiproxy2-0.4.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "six", + "webob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3fa58668cdd1baf40624d08d0e5fba0e", + "name": "wsgiproxy2", + "sha256": "dc22c2b4d74ce5170054ba2200562c3df19e9e870852ac00c0800e020873b376", + "size": 17936, + "subdir": "linux-64", + "timestamp": 1539649511331, + "version": "0.4.5" + }, + "wsgiproxy2-0.4.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "six", + "webob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "98db7a4338225c1ebd0d079e9edd869b", + "name": "wsgiproxy2", + "sha256": "77c2d0c01fe781ec5d5ea128c251135f868750a98296212a860081c61db101ad", + "size": 18238, + "subdir": "linux-64", + "timestamp": 1539649530108, + "version": "0.4.5" + }, + "wsgiproxy2-0.4.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "six", + "webob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6a80cac21c7a52768b40333b62feabb2", + "name": "wsgiproxy2", + "sha256": "45bc40e02c7fb2d1f83bdbd5789e2e1a97d9ae81892c9c4ff452e81670a907cb", + "size": 18143, + "subdir": "linux-64", + "timestamp": 1539649517567, + "version": "0.4.5" + }, + "wsgiref-0.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "PSF or ZPL", + "license_family": "PSF", + "md5": "d4a39d3a7ed898c327b5ef54347e924c", + "name": "wsgiref", + "sha256": "37e40dffca276505d41381bb6b986e4c7c2a3ea54e9ebe74c09db3f906b63606", + "size": 30637, + "subdir": "linux-64", + "timestamp": 1530904631987, + "version": "0.1.2" + }, + "wstools-0.4.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pbr", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b1b5423382a8de99ca9cc7594b9d64ff", + "name": "wstools", + "sha256": "f20d02c60e9db53e7d272454cb809fe874ced85b5e24c962b844f15a846d852d", + "size": 100732, + "subdir": "linux-64", + "timestamp": 1530919199601, + "version": "0.4.6" + }, + "wstools-0.4.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pbr", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "619aa79dff98e2ab67b63cf41512baf9", + "name": "wstools", + "sha256": "028523c82f2f882858a32d688eaf96306fc1df5e325e87edb9e4571a3b2d4c29", + "size": 100873, + "subdir": "linux-64", + "timestamp": 1535512811086, + "version": "0.4.7" + }, + "wstools-0.4.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "pbr", + "python >=2.7,<2.8.0a0", + "six" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "801aabbbcc077ed6a98de10f409825de", + "name": "wstools", + "sha256": "3fb5cb387dc8bcfbcf26ff9e9a5c3a4f58538afb133b63bd497a90806fb814d0", + "size": 102639, + "subdir": "linux-64", + "timestamp": 1539659221515, + "version": "0.4.8" + }, + "wtforms-2.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a447a935d9896ebc97a64797c6d91f28", + "name": "wtforms", + "sha256": "cd34216305ffde5d20af52391db1e768f10779999565d7c69eceec6ee43d1a54", + "size": 114210, + "subdir": "linux-64", + "timestamp": 1528174803338, + "version": "2.2" + }, + "wtforms-2.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "76396827afe31a97ebad5e85f299ebad", + "name": "wtforms", + "sha256": "ba6c4730fccdb6b293571f0f3e62354038d4b7585f13caa81d8c221f980268fa", + "size": 115545, + "subdir": "linux-64", + "timestamp": 1528174839525, + "version": "2.2" + }, + "wtforms-2.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1fec5433be80210b89d43906a6d0a713", + "name": "wtforms", + "sha256": "7a9beddb2460966d0ae60bf7103555c7aac68f9e7c9131d2a347e0384b2683e7", + "size": 114721, + "subdir": "linux-64", + "timestamp": 1528174770851, + "version": "2.2" + }, + "wtforms-2.2.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "eb3e9fe7ebb615590d2e094b7a99d3ea", + "name": "wtforms", + "sha256": "2168333c7ff6a3704f161ab0ad759445fe60c61031990b521522eb06a79151a8", + "size": 114011, + "subdir": "linux-64", + "timestamp": 1529423245573, + "version": "2.2.1" + }, + "wtforms-2.2.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "0c13839d4efa2554e3b020bea7e602f6", + "name": "wtforms", + "sha256": "16447c4a3a978cfc1fce32869895883c59619cabde308a87dc0d6e124366461b", + "size": 117107, + "subdir": "linux-64", + "timestamp": 1529423253173, + "version": "2.2.1" + }, + "wtforms-2.2.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "1a4d31e43c89b28180f67688950df944", + "name": "wtforms", + "sha256": "c343de2c1f3fde54e8989f1729d0aa6811ab07228cd74f543c68c16ccee89f74", + "size": 115894, + "subdir": "linux-64", + "timestamp": 1529423231765, + "version": "2.2.1" + }, + "wtforms-2.2.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "8893041379e96ed8b0e457db52efa0c4", + "name": "wtforms", + "sha256": "d4a057fb925316e5d79f69f0c0d4d9a7e1776c8a09d7268443a0518decf888d7", + "size": 116119, + "subdir": "linux-64", + "timestamp": 1537202605887, + "version": "2.2.1" + }, + "wtforms-2.2.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "a5cc39c4c3627e2695bdfcd7ae4a4b43", + "name": "wtforms", + "sha256": "f6277f0454c59f3227c23127cf88359e34d7d20c421c71824528085c375b25d6", + "size": 116918, + "subdir": "linux-64", + "timestamp": 1573661913808, + "version": "2.2.1" + }, + "wurlitzer-1.0.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "61880f43e5e77d02c36c471089e95f31", + "name": "wurlitzer", + "sha256": "9a75e5221358dd185e5acb9bddbc8de61f518626ad83b96e1b91d1ae918abc84", + "size": 12943, + "subdir": "linux-64", + "timestamp": 1543426895337, + "version": "1.0.2" + }, + "wurlitzer-1.0.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fa7cd71f17af64d5f64f66d054e87674", + "name": "wurlitzer", + "sha256": "72ad221d2516f6f8a999c0cbfd7d85098336de69a36c970b9a097236d9ac8f50", + "size": 13038, + "subdir": "linux-64", + "timestamp": 1543426923142, + "version": "1.0.2" + }, + "wurlitzer-1.0.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15ebdff841028b3ca52755862a47d01e", + "name": "wurlitzer", + "sha256": "44cd20c3081cd45bf478da3beaa39c6a7740b1ba427f9e7471f3a97c7bc20659", + "size": 13041, + "subdir": "linux-64", + "timestamp": 1543426874786, + "version": "1.0.2" + }, + "wurlitzer-1.0.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "16d58d7c5c4f7bf9e03c5282f93fcd30", + "name": "wurlitzer", + "sha256": "8034cf6a06e5362385f78977027eb63f658826f587766bf86545e9229e0185c6", + "size": 14080, + "subdir": "linux-64", + "timestamp": 1564757037098, + "version": "1.0.3" + }, + "wurlitzer-1.0.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b13163b66829d042c0b0363f516a8255", + "name": "wurlitzer", + "sha256": "d1382ca96eb3f8b9fcc48ab9234c9fe4887006df8f5312229c4618310af83803", + "size": 14120, + "subdir": "linux-64", + "timestamp": 1564764293878, + "version": "1.0.3" + }, + "wurlitzer-1.0.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b70c34265e22031f2e8c832f3cdd799c", + "name": "wurlitzer", + "sha256": "f350e9bb964f81561a8195e3f8e6c460c544779dcbcf6ba2c315a90a7e4064fe", + "size": 14128, + "subdir": "linux-64", + "timestamp": 1564756778947, + "version": "1.0.3" + }, + "wurlitzer-1.0.3-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af269dc247c22fe21f00e38305906e44", + "name": "wurlitzer", + "sha256": "24f375e7e8159ade791d51adca65b0f19a39efc4e8ef532e641afb1b0167673d", + "size": 13355, + "subdir": "linux-64", + "timestamp": 1573729977752, + "version": "1.0.3" + }, + "wurlitzer-2.0.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "selectors2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13900d09392719471816c93eeabde2c8", + "name": "wurlitzer", + "sha256": "c46d7cdd09f75d0ab68830bc88b4039431dbb0cfbbe182ee9dc96d88775324dd", + "size": 14539, + "subdir": "linux-64", + "timestamp": 1574280274164, + "version": "2.0.0" + }, + "wurlitzer-2.0.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2b7c5d2e8332c28d9f514cc1d5c2d657", + "name": "wurlitzer", + "sha256": "c734664be27efdcfcf2bdbd3123fd3f403c0ecbeed642a3cbdeb903674281c3a", + "size": 14405, + "subdir": "linux-64", + "timestamp": 1574269156860, + "version": "2.0.0" + }, + "wurlitzer-2.0.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "82f492c34cf23598614977a5869697a9", + "name": "wurlitzer", + "sha256": "cce4851a89e3259e75c747ecc346ee11f764242e1bb1c80d39e413715f7ba1b5", + "size": 14482, + "subdir": "linux-64", + "timestamp": 1574269157353, + "version": "2.0.0" + }, + "wurlitzer-2.0.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ed21d4271721ba6203ed529480b69f4c", + "name": "wurlitzer", + "sha256": "12542df5763490444c5811015d2b4f1526d510dd103a227e28bff050be4b83bf", + "size": 14411, + "subdir": "linux-64", + "timestamp": 1574269232080, + "version": "2.0.0" + }, + "wurlitzer-2.0.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b94553f71c12d984ee4e4332c41ce2f3", + "name": "wurlitzer", + "sha256": "1f943183b9ffa5770890da152c2082dc7fc31eedb7677e302ba2abe1b0dcd47c", + "size": 14821, + "subdir": "linux-64", + "timestamp": 1594753873288, + "version": "2.0.1" + }, + "wurlitzer-2.0.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b0131f4f68fe17d19109b6a3486911f9", + "name": "wurlitzer", + "sha256": "f15aac29211d87acfc951b8ddd1bdd89dff31ef33501ff0ec772b602ac340063", + "size": 14856, + "subdir": "linux-64", + "timestamp": 1594751896084, + "version": "2.0.1" + }, + "wurlitzer-2.0.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ab2cd238a97ae5426d2643e260d30bda", + "name": "wurlitzer", + "sha256": "899ab7af633376976a06b7abdc84aa88f6a4c3732819969c6bad3b7b918e65b3", + "size": 14934, + "subdir": "linux-64", + "timestamp": 1594753876988, + "version": "2.0.1" + }, + "wurlitzer-2.0.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "aa63808667bbb624f8be714b76c1492a", + "name": "wurlitzer", + "sha256": "e819e7b986472c25a2efdbbc72d9c4ac82163072731078c2347db52f4822076f", + "size": 15051, + "subdir": "linux-64", + "timestamp": 1607030039533, + "version": "2.0.1" + }, + "wurlitzer-2.1.0-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1cb1ba109c31c4f92ef649030516964", + "name": "wurlitzer", + "sha256": "3ae1d1bf0be3c9e37dd4ef2688262a0d494802551236a46e3bd509a436654204", + "size": 13839, + "subdir": "linux-64", + "timestamp": 1617222183401, + "version": "2.1.0" + }, + "wurlitzer-2.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2ae65bf408b201d6dc47bbe5e96778e4", + "name": "wurlitzer", + "sha256": "8ab6185e49fc4ac85cad8ac9c126d23ee9c1d96042c75dd1dd6c722d1cf25054", + "size": 13847, + "subdir": "linux-64", + "timestamp": 1617224693898, + "version": "2.1.0" + }, + "wurlitzer-2.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0ba0844ca53bb5e99445f68166df5675", + "name": "wurlitzer", + "sha256": "b755dac0c4b0b580b3863ad4d4b849b421b3dc1103a263ec6e33b5870681ccbb", + "size": 13875, + "subdir": "linux-64", + "timestamp": 1617224697519, + "version": "2.1.0" + }, + "wurlitzer-2.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3cc76c77c35d0c120c9e491c99496fde", + "name": "wurlitzer", + "sha256": "c21492f571548b4b35d8ae4fb052dbab4b8e1e7f34a1c49755918d3719644861", + "size": 13914, + "subdir": "linux-64", + "timestamp": 1617224676532, + "version": "2.1.0" + }, + "wurlitzer-2.1.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "724fe3563dbaa1402d392fbf70c6b163", + "name": "wurlitzer", + "sha256": "932f136782acde161b46edb3c77f355584d750d7c179776b4850c72ce895c1e2", + "size": 13636, + "subdir": "linux-64", + "timestamp": 1626947845221, + "version": "2.1.1" + }, + "wurlitzer-2.1.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0f6ef2f6cb1e76a84fdc08784fc1bea1", + "name": "wurlitzer", + "sha256": "0ffcb9d79e67f32dd30661a19a3d05e75e43f087b563b7e713442db6373d32c5", + "size": 13664, + "subdir": "linux-64", + "timestamp": 1626940405586, + "version": "2.1.1" + }, + "wurlitzer-2.1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5651d575dfcd33a4aa90c49fc12b9ac6", + "name": "wurlitzer", + "sha256": "89e7433a22cea42f5cc0dbe806b9a26f6cb1b99dc8cc9aa6e56aedc69aec478e", + "size": 13751, + "subdir": "linux-64", + "timestamp": 1626947820523, + "version": "2.1.1" + }, + "wurlitzer-2.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2361a61ece54c8988b4320d18a162f1c", + "name": "wurlitzer", + "sha256": "208fc44dcf9cea94fb8da97da9b6ab1e32953bf4dc7968fbed825fc5e1ff26ca", + "size": 13728, + "subdir": "linux-64", + "timestamp": 1626947839474, + "version": "2.1.1" + }, + "wurlitzer-3.0.2-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9ae97cf54595a54f469dcf8c67aba704", + "name": "wurlitzer", + "sha256": "d1347f94a1918ae1f29e22e074039179ce2ea279443d8cbf9c2028301f2cbc71", + "size": 15720, + "subdir": "linux-64", + "timestamp": 1640796042129, + "version": "3.0.2" + }, + "wurlitzer-3.0.2-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "05a0b25852935e06435e18e5018f2bc3", + "name": "wurlitzer", + "sha256": "c01d2d4e186338ecf33dae3419c76850f20fa72a7bd4e21297b37eaf09985fe6", + "size": 19458, + "subdir": "linux-64", + "timestamp": 1676843066851, + "version": "3.0.2" + }, + "wurlitzer-3.0.2-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "09a4acf642d755a9bf6be54c4a25114d", + "name": "wurlitzer", + "sha256": "e0fc188ec84f49e534795b08244e36476ff19d31516584cbd0f3416ac99b9c8f", + "size": 15226, + "subdir": "linux-64", + "timestamp": 1638368193924, + "version": "3.0.2" + }, + "wurlitzer-3.0.2-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e236cb281308b6f94129e9ca48633dd0", + "name": "wurlitzer", + "sha256": "9eed28aa3a91f026aa6dc9b3b2f3d6ca6d6d4275282dc79403cfef2900d48ac0", + "size": 15301, + "subdir": "linux-64", + "timestamp": 1638354998774, + "version": "3.0.2" + }, + "wurlitzer-3.0.2-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "40e7d4bfb188f70836e043b6232ce59e", + "name": "wurlitzer", + "sha256": "c721420dd158efd62a0aa1b647f62ffa19178d7ae01918743288e49e126d68c3", + "size": 15308, + "subdir": "linux-64", + "timestamp": 1638368193903, + "version": "3.0.2" + }, + "wxpython-4.0.1-py27h37420ed_1.conda": { + "build": "py27h37420ed_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.53.6,<3.0a0", + "gst-plugins-base", + "gst-plugins-base >=1.12.4,<1.13.0a0", + "gstreamer", + "gstreamer >=1.12.4,<1.13.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "pango >=1.41.0,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "1a3b40a62628831f1b1c5ec8079185bb", + "name": "wxpython", + "sha256": "15ebfa19e0918c54bd72d037d420f20583fabaeaaed23bcfb2c660cf21705595", + "size": 16368127, + "subdir": "linux-64", + "timestamp": 1521001929675, + "version": "4.0.1" + }, + "wxpython-4.0.1-py35h37420ed_1.conda": { + "build": "py35h37420ed_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.53.6,<3.0a0", + "gst-plugins-base", + "gst-plugins-base >=1.12.4,<1.13.0a0", + "gstreamer", + "gstreamer >=1.12.4,<1.13.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "pango >=1.41.0,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "ee640704d7314bd399b12c0fde0d6d58", + "name": "wxpython", + "sha256": "608337082652039affeb2e06a419ba9d1921f4671609fccc79abdc2578e6ad7c", + "size": 16366252, + "subdir": "linux-64", + "timestamp": 1520999849509, + "version": "4.0.1" + }, + "wxpython-4.0.1-py36h37420ed_1.conda": { + "build": "py36h37420ed_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.53.6,<3.0a0", + "gst-plugins-base", + "gst-plugins-base >=1.12.4,<1.13.0a0", + "gstreamer", + "gstreamer >=1.12.4,<1.13.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.7,<2.10.0a0", + "pango >=1.41.0,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "861e0c6d0f7ef61e223419b69fec5c63", + "name": "wxpython", + "sha256": "5f6734df8b24bbef2e5e01c57ef320b3d4762bd0e12b9404043516b2cc97275a", + "size": 16355510, + "subdir": "linux-64", + "timestamp": 1521001932773, + "version": "4.0.1" + }, + "wxpython-4.0.2-py27h0e7c882_1.conda": { + "build": "py27h0e7c882_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.1,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "14c8168e3db4a90da7735c1da6a817a4", + "name": "wxpython", + "sha256": "d1b654f174fe8c1a14ffc2f860041d77dd0ed9c9d17c9ec2d51851b417c2b1bb", + "size": 16246692, + "subdir": "linux-64", + "timestamp": 1529579187327, + "version": "4.0.2" + }, + "wxpython-4.0.2-py27h76a34b6_1.conda": { + "build": "py27h76a34b6_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.1,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "92d76b192538012e4a82417b397ea92b", + "name": "wxpython", + "sha256": "24d42e6e835d2d917b410d745dd1eb794e2997de49251aa5314dc41c216f0621", + "size": 16243919, + "subdir": "linux-64", + "timestamp": 1531065082433, + "version": "4.0.2" + }, + "wxpython-4.0.2-py35h0e7c882_1.conda": { + "build": "py35h0e7c882_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.1,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "a6031fb8bdc24828b8954bde3e367fb4", + "name": "wxpython", + "sha256": "0e2c08a8c20cd2be3659ab48edda27e30069c253d3d6b7e87c00e75c320992b0", + "size": 25960890, + "subdir": "linux-64", + "timestamp": 1529580606040, + "version": "4.0.2" + }, + "wxpython-4.0.2-py36h0e7c882_1.conda": { + "build": "py36h0e7c882_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.1,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "9e89861490caa32bce5ccf39effb55e5", + "name": "wxpython", + "sha256": "ab81d56345284515b88c92c903500b76108e2bfc19e860dcff842d59f22bd502", + "size": 26203328, + "subdir": "linux-64", + "timestamp": 1529580613816, + "version": "4.0.2" + }, + "wxpython-4.0.2-py36h76a34b6_1.conda": { + "build": "py36h76a34b6_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.1,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "c85f847c08401f72559f9efcbd577797", + "name": "wxpython", + "sha256": "ac52cb7d1795bfc915f3d46a16c79eaa6357f6778e1bc72000233d0552410116", + "size": 26258691, + "subdir": "linux-64", + "timestamp": 1531062557696, + "version": "4.0.2" + }, + "wxpython-4.0.2-py37h76a34b6_1.conda": { + "build": "py37h76a34b6_1", + "build_number": 1, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.1,<2.0a0", + "python >=3.7,<3.8.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "4cb70dc6b6458e36f5efcb1a50b0ef8a", + "name": "wxpython", + "sha256": "ca7a3d30f8faeeffc2f85d09bbdd6ba79f5e5346c7eb13d8fb0d93391cf0997c", + "size": 26611444, + "subdir": "linux-64", + "timestamp": 1531064144846, + "version": "4.0.2" + }, + "wxpython-4.0.3-py27h76a34b6_0.conda": { + "build": "py27h76a34b6_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.2,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "22e5c3611ff479f769ef14c81a958eda", + "name": "wxpython", + "sha256": "d1c20e45bc54c57c1ba894d8bb9df842aa9e0c1d5ea15fb40b6facde4e8ae939", + "size": 16278008, + "subdir": "linux-64", + "timestamp": 1533101474099, + "version": "4.0.3" + }, + "wxpython-4.0.3-py35h76a34b6_0.conda": { + "build": "py35h76a34b6_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.2,<2.0a0", + "python >=3.5,<3.6.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "2de8cbecaab8b0da393584839062b440", + "name": "wxpython", + "sha256": "9fa716903102aaabdddd95ed3ca5426e9cddee8c9e8b1198e4a17e96ffc364c9", + "size": 25988424, + "subdir": "linux-64", + "timestamp": 1533103074639, + "version": "4.0.3" + }, + "wxpython-4.0.3-py36h76a34b6_0.conda": { + "build": "py36h76a34b6_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.2,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "53869d6cc37eee4160de08a48e3f44e0", + "name": "wxpython", + "sha256": "d61ba6834538171df81f6f45c8856102635e986565df66bcc0a633f4d7507472", + "size": 26274798, + "subdir": "linux-64", + "timestamp": 1533100070416, + "version": "4.0.3" + }, + "wxpython-4.0.3-py37h76a34b6_0.conda": { + "build": "py37h76a34b6_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.5,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.1,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.2.0", + "libglu", + "libpng >=1.6.34,<1.7.0a0", + "libstdcxx-ng >=7.2.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.2,<2.0a0", + "python >=3.7,<3.8.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "010bc55ed887b2cf2b77c59f0a16cf46", + "name": "wxpython", + "sha256": "f7d40c2ebe6170401c9319419d35b000fbbabba821904eab09609b9c01b4ea9b", + "size": 26611987, + "subdir": "linux-64", + "timestamp": 1533103135071, + "version": "4.0.3" + }, + "wxpython-4.0.4-py27hc99224d_0.conda": { + "build": "py27hc99224d_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.6,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.2,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libglu", + "libpng >=1.6.36,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.4,<2.0a0", + "python >=2.7,<2.8.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "2626c3177ccbef1d3757ed2fd9ca7eab", + "name": "wxpython", + "sha256": "0c413876d8b12d6fb4672a5d7cbada6afa6afa8e94417b32d036ddc17cf9feca", + "size": 16694886, + "subdir": "linux-64", + "timestamp": 1547934557269, + "version": "4.0.4" + }, + "wxpython-4.0.4-py36hc99224d_0.conda": { + "build": "py36hc99224d_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.6,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.2,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libglu", + "libpng >=1.6.36,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.4,<2.0a0", + "python >=3.6,<3.7.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "f49ef3e5fbf47f10ebf2cd6b6a89b66a", + "name": "wxpython", + "sha256": "bf2624e9e3a0154dcb7060ec0567f5bc5405f36d1366498b0d629eca6e794bda", + "size": 16899956, + "subdir": "linux-64", + "timestamp": 1547935109988, + "version": "4.0.4" + }, + "wxpython-4.0.4-py37hc99224d_0.conda": { + "build": "py37hc99224d_0", + "build_number": 0, + "depends": [ + "cairo >=1.14.12,<2.0a0", + "expat >=2.2.6,<3.0a0", + "gettext >=0.19.8.1,<1.0a0", + "glib >=2.56.2,<3.0a0", + "gst-plugins-base >=1.14.0,<1.15.0a0", + "gstreamer >=1.14.0,<1.15.0a0", + "jpeg >=9b,<10a", + "libgcc-ng >=7.3.0", + "libglu", + "libpng >=1.6.36,<1.7.0a0", + "libstdcxx-ng >=7.3.0", + "libxml2 >=2.9.8,<2.10.0a0", + "pango >=1.42.4,<2.0a0", + "python >=3.7,<3.8.0a0", + "six", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "wxWindows Library v3.1", + "license_family": "LGPL", + "md5": "e42569fdbbc206e15cea6106b0880007", + "name": "wxpython", + "sha256": "3e993e897311983a30589c274083bf371847208dae6a6b08592973b23bc9c66e", + "size": 16909530, + "subdir": "linux-64", + "timestamp": 1547935114899, + "version": "4.0.4" + }, + "x264-1!152.20180806-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-2.0", + "md5": "bb53e4ed4679084d000a9c8386587fc8", + "name": "x264", + "sha256": "d1e48046cf61706866a66e7da360b61a0e3416c8cfbb7136a593fdcec727bf26", + "size": 645708, + "subdir": "linux-64", + "timestamp": 1576633222936, + "version": "1!152.20180806" + }, + "x264-1!157.20191217-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "GPL-2.0", + "md5": "7fc89e38083023752385add4c4dd4d92", + "name": "x264", + "sha256": "28395b8eeff4a7a9e0e4ddca67835805c9e3106a2512c60184d4c19800374eea", + "size": 944158, + "subdir": "linux-64", + "timestamp": 1587147235073, + "version": "1!157.20191217" + }, + "xar-1.6.1-h427f29d_0.conda": { + "build": "h427f29d_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.6,<2.0a0", + "libgcc-ng >=7.2.0", + "libxml2 >=2.9.4,<2.10.0a0", + "xz >=5.2.3,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "47927f91cd337c204a20e1e7d08a5531", + "name": "xar", + "sha256": "fccd17c1c106f89850e8cff5b877db8529938c2f10bcd0d44b7cdbf96f1309f4", + "size": 956328, + "subdir": "linux-64", + "timestamp": 1505852085050, + "version": "1.6.1" + }, + "xar-1.8.0.425.2-h5de8990_0.conda": { + "build": "h5de8990_0", + "build_number": 0, + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "openssl >=1.1.1l,<1.1.2a", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "aafb685190094174ad587c048cc0e66a", + "name": "xar", + "sha256": "784cf1150b6b88f167617ce8751687ff24153e24d6b8eeaa19e0d7d016a03f38", + "size": 548906, + "subdir": "linux-64", + "timestamp": 1631124677431, + "version": "1.8.0.425.2" + }, + "xarray-0.10.0-py27hd0a7aca_0.conda": { + "build": "py27hd0a7aca_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a0b1e1aeac96a63bbebd8dfffdf370d0", + "name": "xarray", + "sha256": "0a9bac5a39a03c9ed7e56be98983d861797068ba357f11e7f24caf2f40b34360", + "size": 545663, + "subdir": "linux-64", + "timestamp": 1511285974055, + "version": "0.10.0" + }, + "xarray-0.10.0-py35h17cbfd9_0.conda": { + "build": "py35h17cbfd9_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6d9dea06a6f126dde30991d713c55708", + "name": "xarray", + "sha256": "e751e8b9256bdcd285f1892c5531e9bd5dd0de55239949e4ec727bc06f2e5118", + "size": 562818, + "subdir": "linux-64", + "timestamp": 1511285981386, + "version": "0.10.0" + }, + "xarray-0.10.0-py36hbc13e12_0.conda": { + "build": "py36hbc13e12_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a824b199a047151658666ba7b3405cf1", + "name": "xarray", + "sha256": "bebeeceb65696e6784c3d291ef9c99edc1153f85dc9c41e214d54998597dc926", + "size": 553696, + "subdir": "linux-64", + "timestamp": 1511285975212, + "version": "0.10.0" + }, + "xarray-0.10.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eb1ac54f672c68c7a9bb0270d8fd4080", + "name": "xarray", + "sha256": "4258d0d10ee480c0d573e8ead244bbef4347b8553ae55f93d713a1e713b104cd", + "size": 614961, + "subdir": "linux-64", + "timestamp": 1519755246190, + "version": "0.10.1" + }, + "xarray-0.10.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3bff3d449237bd83bee1f7aced4ff668", + "name": "xarray", + "sha256": "4e9e532d716a1aeff1369abf69c02e93d3023da8578da32a72d7b30fce7ae2c2", + "size": 628389, + "subdir": "linux-64", + "timestamp": 1519755219886, + "version": "0.10.1" + }, + "xarray-0.10.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "2ad29560c2e2f965faa05df0bde9beaa", + "name": "xarray", + "sha256": "bf9b4bb332b082759cccd1c47a99ee02289bcbb5e6a45276fe53e6f3ca953c56", + "size": 616973, + "subdir": "linux-64", + "timestamp": 1519755214842, + "version": "0.10.1" + }, + "xarray-0.10.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "82feb4b33be7608e9f34c50d8ed5a3ce", + "name": "xarray", + "sha256": "d5da8a068cb20abb45f7c4327f38156e8c8aca82c402036c5e253fbe903ad57b", + "size": 631122, + "subdir": "linux-64", + "timestamp": 1521484527598, + "version": "0.10.2" + }, + "xarray-0.10.2-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ae124c421723a7118d8429b574a7f527", + "name": "xarray", + "sha256": "cb105a08ef5b4613c4c32617d013ee53c9025d0b9c7399825e1baddf5e2fdf13", + "size": 652477, + "subdir": "linux-64", + "timestamp": 1521484542784, + "version": "0.10.2" + }, + "xarray-0.10.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e983427b33e9d22463353f63759b0aee", + "name": "xarray", + "sha256": "0c95549eafea2fd949a38e5305630cf9b93c06a5344b7af2f4daface65e69b66", + "size": 640650, + "subdir": "linux-64", + "timestamp": 1521484540346, + "version": "0.10.2" + }, + "xarray-0.10.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8ace927d74f2099329976452898cff62", + "name": "xarray", + "sha256": "f552195276aab696d0def720df768f85c63fb7a9ce6c4a2d120a97c6bc79feae", + "size": 642758, + "subdir": "linux-64", + "timestamp": 1523983778663, + "version": "0.10.3" + }, + "xarray-0.10.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f8e5b43bff9389286aa401ef9d47a3c3", + "name": "xarray", + "sha256": "6ff373d470600c779e137d8fd3624daab422bd6670d417db17602b14c1d78447", + "size": 657983, + "subdir": "linux-64", + "timestamp": 1523983799834, + "version": "0.10.3" + }, + "xarray-0.10.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0db17c1aa3de8bbecde9be48af597635", + "name": "xarray", + "sha256": "40c67c1b057be292c6b700ab164704d363698bdb3a436a341c687b137c9122ac", + "size": 652330, + "subdir": "linux-64", + "timestamp": 1523983750348, + "version": "0.10.3" + }, + "xarray-0.10.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "030268bb51bf0974a27edf9c0a5047e2", + "name": "xarray", + "sha256": "1610a0d7d67f21e368988596b7a6fd40b16d3d4cea50bd719f5bb5ca687d5381", + "size": 673483, + "subdir": "linux-64", + "timestamp": 1526916218435, + "version": "0.10.4" + }, + "xarray-0.10.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a1a283c096260a5b7b240556f1a398c4", + "name": "xarray", + "sha256": "13a54f5cfa945b45db3885498c1c847c13a0389782d68c2c6e6c7c46590f3891", + "size": 688128, + "subdir": "linux-64", + "timestamp": 1526916233278, + "version": "0.10.4" + }, + "xarray-0.10.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "02df174aeb52b7eac841f84875528fbb", + "name": "xarray", + "sha256": "31b3f1d3e4398b6f50fe168e8d72d07589182c81436bf13686f3e7077567e7ec", + "size": 682442, + "subdir": "linux-64", + "timestamp": 1526916196824, + "version": "0.10.4" + }, + "xarray-0.10.6-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "550fa77cfd21edaee0548aa23d0b13b7", + "name": "xarray", + "sha256": "1cef2656b8cf7b95009e4494b4333b0a820b5e42806636f619046f72402b0d40", + "size": 686900, + "subdir": "linux-64", + "timestamp": 1528147329269, + "version": "0.10.6" + }, + "xarray-0.10.6-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1f74440e2dc538affe846aca46dd6594", + "name": "xarray", + "sha256": "2ebc3c81434ad800ddfe96b6460e5becca24c7e895c9c34ac73fc975b119d200", + "size": 702035, + "subdir": "linux-64", + "timestamp": 1528147343975, + "version": "0.10.6" + }, + "xarray-0.10.6-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4a1c64a644b610e12922b54d2c04cf35", + "name": "xarray", + "sha256": "581695366017e422af24fc39dc6af91c51d569e9c79b576be90102ae003d15e2", + "size": 688103, + "subdir": "linux-64", + "timestamp": 1528147282613, + "version": "0.10.6" + }, + "xarray-0.10.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1252c7995c19fee3494f6cb7997b3473", + "name": "xarray", + "sha256": "8749670aa1ce8b0135f7bf54c09ddd37b9744584d52f222ba78211e19d975dd4", + "size": 700737, + "subdir": "linux-64", + "timestamp": 1528909892114, + "version": "0.10.7" + }, + "xarray-0.10.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eb9f8a6f64f10ec6c590f4e6ef2237dc", + "name": "xarray", + "sha256": "26466ba3a81beb71b30fc21e5d1ecea382b2c9673c8222097178597fe8aacbc3", + "size": 710557, + "subdir": "linux-64", + "timestamp": 1528909911664, + "version": "0.10.7" + }, + "xarray-0.10.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "167626724f470e0f5a7b91d36688c2c8", + "name": "xarray", + "sha256": "74f620b72cd0627d951935f70f74096ba66e1cfaae3074633c893aa2b42feacf", + "size": 710407, + "subdir": "linux-64", + "timestamp": 1528909870948, + "version": "0.10.7" + }, + "xarray-0.10.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.11", + "pandas >=0.18.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "583b1a2402a53e33710c0be684af5876", + "name": "xarray", + "sha256": "eb48022468a42ab46dfeccceaef6a9a6a1826ee72d9fab15256cfb81f99dce33", + "size": 708516, + "subdir": "linux-64", + "timestamp": 1530872882019, + "version": "0.10.7" + }, + "xarray-0.10.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4ebe8ea86bfd78ee3cda9ed196589ee3", + "name": "xarray", + "sha256": "e3f60213aca8bf8c4b38bed2be3fe6cdc835eef6a1ed22e475e51d529578630f", + "size": 691843, + "subdir": "linux-64", + "timestamp": 1532538695892, + "version": "0.10.8" + }, + "xarray-0.10.8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a9878a8f244384d8d146df35c2f91354", + "name": "xarray", + "sha256": "5c6719ae6dcc8bee87e5d7e4251fe2a614608609aaa3f754aa2227e551c613f5", + "size": 712678, + "subdir": "linux-64", + "timestamp": 1532538668006, + "version": "0.10.8" + }, + "xarray-0.10.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "5c8c90d0d9994877caeb2d32865f8a7e", + "name": "xarray", + "sha256": "9898d021360e9ea7dac50706054c189dd9e95f99165fbc01e250c38cbe4475af", + "size": 707133, + "subdir": "linux-64", + "timestamp": 1532538643333, + "version": "0.10.8" + }, + "xarray-0.10.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "35865a9d997e66bd7daf4f678934df96", + "name": "xarray", + "sha256": "5a7a974c4399b0058712931dab6ebeb85e0c1b03473907f0b8d151702177b69c", + "size": 698958, + "subdir": "linux-64", + "timestamp": 1532538750616, + "version": "0.10.8" + }, + "xarray-0.10.9-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "310934b48c475aa8377588a987b720bc", + "name": "xarray", + "sha256": "8400bcb91d14e981134b434222dcac8527335f88f02db5619811f9a53382b370", + "size": 738520, + "subdir": "linux-64", + "timestamp": 1538181880078, + "version": "0.10.9" + }, + "xarray-0.10.9-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c56776b5056bda693cba01e7b6193153", + "name": "xarray", + "sha256": "fee0643f4b4c3fecfe9bf4684bddddafd7884a570a7cd7298e4989bc61b9cbd0", + "size": 739878, + "subdir": "linux-64", + "timestamp": 1538181900689, + "version": "0.10.9" + }, + "xarray-0.10.9-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "659db23ddcc7acaa3f593966177018c1", + "name": "xarray", + "sha256": "ee0f0645ada28f0f1eed53bacfa7165cfd7d13bfdb76ef4f0320499b2f214363", + "size": 744819, + "subdir": "linux-64", + "timestamp": 1538181878376, + "version": "0.10.9" + }, + "xarray-0.11.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9057b78144f388a791ab0ec0a927ca47", + "name": "xarray", + "sha256": "7bc14a987593ae3442db23114b844ad84085339ede8a4a4a15234525acc51b8e", + "size": 756241, + "subdir": "linux-64", + "timestamp": 1542092227384, + "version": "0.11.0" + }, + "xarray-0.11.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e3f5f4b4d78feea3a2806d54cd2cc31b", + "name": "xarray", + "sha256": "3ad6691fead6517595585272e4c2a09c1a1a148d0cc7ec29c061aee94b49272a", + "size": 764072, + "subdir": "linux-64", + "timestamp": 1542092159124, + "version": "0.11.0" + }, + "xarray-0.11.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4ff873ac5c4ef774fc2cddad9a91a3e4", + "name": "xarray", + "sha256": "bc3a889b13d4284b068201634ca29511fc914fec9794036bdd0c0bc6e8d412b1", + "size": 768004, + "subdir": "linux-64", + "timestamp": 1542092176559, + "version": "0.11.0" + }, + "xarray-0.11.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=2.7,<2.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c7032084224f690ec95416da90062033", + "name": "xarray", + "sha256": "adbf5abb513a2f5476e0ce58dfe2c561bda328bc3276f745cf981ed6f267ab5b", + "size": 788744, + "subdir": "linux-64", + "timestamp": 1550432177849, + "version": "0.11.3" + }, + "xarray-0.11.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "544010e5bfca5b4fd28a40095db890be", + "name": "xarray", + "sha256": "0ed418f884d300604058ecf08c48275e758d920802f09d592046dd9b98297c5d", + "size": 796666, + "subdir": "linux-64", + "timestamp": 1550432270782, + "version": "0.11.3" + }, + "xarray-0.11.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "numpy >=1.12", + "pandas >=0.19.2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "96150769c226d518f376f68a01225271", + "name": "xarray", + "sha256": "4df14672e3348bc01ef15d4df1dad80b7fb485225edc60b45c5f980bc7a3be65", + "size": 794272, + "subdir": "linux-64", + "timestamp": 1550432178276, + "version": "0.11.3" + }, + "xarray-2022.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.20", + "packaging >=21.0", + "pandas >=1.3", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "30a2222b3ab89682389d22580269616d", + "name": "xarray", + "sha256": "40bc1ab732ee5b7b6ba13818c0e6f0e59bc23b50121fc8228741665ce4144b5e", + "size": 1696928, + "subdir": "linux-64", + "timestamp": 1668776680921, + "version": "2022.11.0" + }, + "xarray-2022.11.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.20", + "packaging >=21.0", + "pandas >=1.3", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d8c368f0c0dc4a9d43e21635c11cbeaa", + "name": "xarray", + "sha256": "c1e01e1a0bdfed0d96ca775af5814bc91fbac8f715e4059b8731ff00fc1729d3", + "size": 2052589, + "subdir": "linux-64", + "timestamp": 1676843085172, + "version": "2022.11.0" + }, + "xarray-2022.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.20", + "packaging >=21.0", + "pandas >=1.3", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1fbfff2a9056d939c8399900fecad8bf", + "name": "xarray", + "sha256": "82d1473277a97238b787379485faad68f0eb85a288348887c632b5f654d3a24d", + "size": 1680047, + "subdir": "linux-64", + "timestamp": 1668776634679, + "version": "2022.11.0" + }, + "xarray-2022.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "numpy >=1.20", + "packaging >=21.0", + "pandas >=1.3", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b59685bfe07b091dca0439469ead03ca", + "name": "xarray", + "sha256": "62a42f2eac9946c4033e07553f61cbe15d843b3cb0b486e559b457fbca58a7c6", + "size": 1679322, + "subdir": "linux-64", + "timestamp": 1668776724424, + "version": "2022.11.0" + }, + "xattr-0.10.1-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cff918590aaae615c8ce4b57c9822d9f", + "name": "xattr", + "sha256": "1fa0a6453f5dc2e984ed73cd0b9217ef2e1520d0f7eee22226a3c2e45dbac036", + "size": 28970, + "subdir": "linux-64", + "timestamp": 1679670828645, + "version": "0.10.1" + }, + "xattr-0.10.1-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d1804bb1b5e33994bf2f43f2c23b201e", + "name": "xattr", + "sha256": "7bd4943a231d97ff197aaee18ddd57d9e100a79ea8f06838c6dcc72930c96e6b", + "size": 34511, + "subdir": "linux-64", + "timestamp": 1679670793639, + "version": "0.10.1" + }, + "xattr-0.10.1-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2653a1c04328c9bb21023f264add406", + "name": "xattr", + "sha256": "d66b20e94eb22456b1b04632b9b293d75347246e60095f4bc0da8bcb938dcbfe", + "size": 28787, + "subdir": "linux-64", + "timestamp": 1679670758901, + "version": "0.10.1" + }, + "xattr-0.10.1-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.0.0", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "293bf30c2e3dd74431f04180030a50fd", + "name": "xattr", + "sha256": "254b5ab852371491081c42e6a973a753adbc87d5fa4f07cbb6e23476bb10494f", + "size": 28742, + "subdir": "linux-64", + "timestamp": 1679670724537, + "version": "0.10.1" + }, + "xcb-proto-1.12-py27h14c3975_1.conda": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "551ade73e2aa2e275c2206eb3a11f85a", + "name": "xcb-proto", + "namespace": "global", + "sha256": "b309e8721f42aae1d16d2cb6b46d65bf56db2e08de71318bcb0c2ff83892b1ae", + "size": 111755, + "subdir": "linux-64", + "timestamp": 1531065214572, + "version": "1.12" + }, + "xcb-proto-1.12-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5e562f9b42b09d0dab320a8603f30ab6", + "name": "xcb-proto", + "namespace": "global", + "sha256": "330a049664cb21ad4faff82e1106ab0778e60d724c6f0bc30a4b204c1818c405", + "size": 112631, + "subdir": "linux-64", + "timestamp": 1642508361850, + "version": "1.12" + }, + "xcb-proto-1.12-py311h5eee18b_1.conda": { + "build": "py311h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0330342cd96bce595f5ae696927440a7", + "name": "xcb-proto", + "namespace": "global", + "sha256": "09193567bc95463fd9afb24413e53d2d41a9fdc620590faa49491e2aca805971", + "size": 125309, + "subdir": "linux-64", + "timestamp": 1676823271443, + "version": "1.12" + }, + "xcb-proto-1.12-py36h14c3975_1.conda": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7475e08cb060fd7441f0617bc45d7a76", + "name": "xcb-proto", + "namespace": "global", + "sha256": "3c8ab21f9852350377e64e35e9a54242758de3d19e16be9e76ef057b6523f610", + "size": 111997, + "subdir": "linux-64", + "timestamp": 1531065143469, + "version": "1.12" + }, + "xcb-proto-1.12-py36h27cfd23_1.conda": { + "build": "py36h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "69326903fb30e7a0c6bef10aabf05067", + "name": "xcb-proto", + "namespace": "global", + "sha256": "d745150a5adb9d921095283b77fcd1132615442648adf7f8145019d1f2083396", + "size": 113245, + "subdir": "linux-64", + "timestamp": 1614066551392, + "version": "1.12" + }, + "xcb-proto-1.12-py36hf39a981_1.conda": { + "build": "py36hf39a981_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1b1da50a7d737f395b776eeeee77311f", + "name": "xcb-proto", + "namespace": "global", + "sha256": "22694c1a67dfcc1ec4ff265d195f29729eca9ca6750a160dd2e4d241c0b216f7", + "size": 112266, + "subdir": "linux-64", + "timestamp": 1505734020624, + "version": "1.12" + }, + "xcb-proto-1.12-py37h14c3975_1.conda": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d6706b0e781f12dfc521e8fc1467f1e5", + "name": "xcb-proto", + "namespace": "global", + "sha256": "fcd9d098d5a4e1e46ea1ce268df8d9ea2c2992ee5de0fdbce38a2337a7cad805", + "size": 111979, + "subdir": "linux-64", + "timestamp": 1531065180479, + "version": "1.12" + }, + "xcb-proto-1.12-py37h27cfd23_1.conda": { + "build": "py37h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9949f3f27ce7887b5f78c7682cf00362", + "name": "xcb-proto", + "namespace": "global", + "sha256": "aad6e86fb78743b65f33887d2909417116db44a070e1592333c40aca04535a00", + "size": 113549, + "subdir": "linux-64", + "timestamp": 1614067276488, + "version": "1.12" + }, + "xcb-proto-1.12-py38h27cfd23_1.conda": { + "build": "py38h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c55410970cf4909bd081d63c4e4832cd", + "name": "xcb-proto", + "namespace": "global", + "sha256": "b9093dbce1a5af482d0b17214720f53cc03295b6ca86c7a2ea52dc9042c8586e", + "size": 113718, + "subdir": "linux-64", + "timestamp": 1614067281069, + "version": "1.12" + }, + "xcb-proto-1.12-py38h7b6447c_1.conda": { + "build": "py38h7b6447c_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bad91e8566c6d705bb9da11ae2672443", + "name": "xcb-proto", + "namespace": "global", + "sha256": "7bf81b795e83dd80c26a298fcbd8dca728256b3c2cfbd26b0306a633cec7bcf9", + "size": 119175, + "subdir": "linux-64", + "timestamp": 1573730016702, + "version": "1.12" + }, + "xcb-proto-1.12-py39h27cfd23_1.conda": { + "build": "py39h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "350c0094ab910d4f06e0eb4be605e90e", + "name": "xcb-proto", + "namespace": "global", + "sha256": "1a5294686fe6ebaa82d8e97c7f6111d66c0d5b385330b278a2f98e43604b7992", + "size": 113641, + "subdir": "linux-64", + "timestamp": 1614066349044, + "version": "1.12" + }, + "xcb-proto-1.13-h1bed415_0.conda": { + "build": "h1bed415_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python" + ], + "md5": "f9b27b02048d51385ab55a6142c5c540", + "name": "xcb-proto", + "namespace": "global", + "sha256": "9e1ddc3935479b468613f9465c8f2fcab4fbaff3c7dee838141f9bd51bb33874", + "size": 112848, + "subdir": "linux-64", + "timestamp": 1522698371233, + "version": "1.13" + }, + "xcb-proto-1.13-h1bed415_1.conda": { + "build": "h1bed415_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "python" + ], + "md5": "1a6b881510cd1f3c5fc0fb704a8cd97d", + "name": "xcb-proto", + "namespace": "global", + "sha256": "11857a2b1ddaa2984a790e0440f6bfbe23a0f0badee9471be3b0ea8236735ce6", + "size": 113206, + "subdir": "linux-64", + "timestamp": 1523637242969, + "version": "1.13" + }, + "xcb-proto-1.14-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "md5": "523825c77035b192112e8d22c7319c20", + "name": "xcb-proto", + "namespace": "global", + "sha256": "7e24a534afce4bc66e06fec5f795a144185fa12655c96b10af6030f6cba8b13d", + "size": 116571, + "subdir": "linux-64", + "timestamp": 1593535405098, + "version": "1.14" + }, + "xcb-proto-1.14-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "md5": "a898e2943b5e39400d854a68fbc9ecbb", + "name": "xcb-proto", + "namespace": "global", + "sha256": "36967080272382a005329b747db86dc62e012066f82994b5c01280e74cac9c40", + "size": 116557, + "subdir": "linux-64", + "timestamp": 1593535416523, + "version": "1.14" + }, + "xerces-c-3.2.0-h1c8713b_0.conda": { + "build": "h1c8713b_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a773e73d90317050369e7e94631af28d", + "name": "xerces-c", + "sha256": "3eb2d471a4afc007fee806758aa6e35d2c4c0ca47a921bbac996249bb394e687", + "size": 2327488, + "subdir": "linux-64", + "timestamp": 1509503605043, + "version": "3.2.0" + }, + "xerces-c-3.2.0-h524ea4d_2.conda": { + "build": "h524ea4d_2", + "build_number": 2, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a06271a76f6111f4d3099ee64d55e987", + "name": "xerces-c", + "sha256": "49edf755324f312f4362665a5a8562483e82e6469d12d26c32c47e33a0e64ae7", + "size": 2327519, + "subdir": "linux-64", + "timestamp": 1510158423200, + "version": "3.2.0" + }, + "xerces-c-3.2.0-h5306e6a_1.conda": { + "build": "h5306e6a_1", + "build_number": 1, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "63d400b546f006a0fda77c8864f1eca7", + "name": "xerces-c", + "sha256": "06ea690c9ae510ea55b5635f3150cfd757721736b12ba0fcdf77d552afccbb8d", + "size": 2313175, + "subdir": "linux-64", + "timestamp": 1510093112821, + "version": "3.2.0" + }, + "xerces-c-3.2.1-hac72e42_0.conda": { + "build": "hac72e42_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.2.0", + "libstdcxx-ng >=7.2.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0bed2c14447c26c23c4ef1512472e179", + "name": "xerces-c", + "sha256": "d2f4505d5957c76f74450ed13620803bd9d957c05aa90267ed2cc61fc2d5b09f", + "size": 2328582, + "subdir": "linux-64", + "timestamp": 1522082323064, + "version": "3.2.1" + }, + "xerces-c-3.2.2-h780794e_0.conda": { + "build": "h780794e_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "27b3a6eb4265d5bde991f3472d11b512", + "name": "xerces-c", + "sha256": "20e46940a6d5d8920f87b8dd09ad34325984928509290b5b8b05d70c775b1fee", + "size": 2384565, + "subdir": "linux-64", + "timestamp": 1539730858945, + "version": "3.2.2" + }, + "xerces-c-3.2.3-h780794e_0.conda": { + "build": "h780794e_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "3fafe1f5f0214f929c2128880aad4198", + "name": "xerces-c", + "sha256": "e42af52dbe0e0d81b3fc470a2b08e6ff423d3620a73fc228bfc598944fd0d71e", + "size": 2497116, + "subdir": "linux-64", + "timestamp": 1599879004914, + "version": "3.2.3" + }, + "xerces-c-3.2.4-h94c2ce2_0.conda": { + "build": "h94c2ce2_0", + "build_number": 0, + "depends": [ + "icu >=58.2,<59.0a0", + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3fa59af0b1fbe67a3baa75bdf7aaca80", + "name": "xerces-c", + "sha256": "eabb98d329414ba3199e44c3af782984d26f089af78e0b024d0c0facbb1df941", + "size": 3472299, + "subdir": "linux-64", + "timestamp": 1668712691999, + "version": "3.2.4" + }, + "xgboost-1.3.3-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.3.3 py36h06a4308_0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache-2.0", + "md5": "0cf31ecbc1d08a50364b0dce39a0e33a", + "name": "xgboost", + "sha256": "7ce341b44575b261aadafe6c907af32dd772a11623c91890d9ab3b92d83db496", + "size": 23339, + "subdir": "linux-64", + "timestamp": 1619725060384, + "version": "1.3.3" + }, + "xgboost-1.3.3-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.3.3 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "bf5da5a0d5f7435e02c8dcf91bce4fca", + "name": "xgboost", + "sha256": "4282cdd608c9c5c4cc7b9549651aae60bf0980bc4f25f3f839e317e082172846", + "size": 23350, + "subdir": "linux-64", + "timestamp": 1619725052872, + "version": "1.3.3" + }, + "xgboost-1.3.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.3.3 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "d8412992dadd9cfe472d53eec3257beb", + "name": "xgboost", + "sha256": "3398971c1178c9b17560b58c134a468ae469fc247add03ef4e629ade665a1ef9", + "size": 23351, + "subdir": "linux-64", + "timestamp": 1619725067759, + "version": "1.3.3" + }, + "xgboost-1.3.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.3.3 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "55962907ea1fc6099333c3e51fca4cfe", + "name": "xgboost", + "sha256": "4f96a7b1839f465db49a5e8370b69150b5f1026a72f354485c446d68b21d48aa", + "size": 23362, + "subdir": "linux-64", + "timestamp": 1619725045272, + "version": "1.3.3" + }, + "xgboost-1.5.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "py-xgboost 1.5.0 py310h06a4308_1", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "0828cb07ea5d078c4e9f00d0390fe3b4", + "name": "xgboost", + "sha256": "42ff5c269d32984ae5ff731766b113312ce08f7721b94e80c454e8fd024abd2e", + "size": 14422, + "subdir": "linux-64", + "timestamp": 1641558660057, + "version": "1.5.0" + }, + "xgboost-1.5.0-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "py-xgboost 1.5.0 py310h06a4308_2", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "md5": "3038d2c0fc6c4acf890e8ba9c48ca500", + "name": "xgboost", + "sha256": "a0a56ef57c26211ac1aacb44340d94abf643ec798b7732fd3f9fbc94b721b452", + "size": 15080, + "subdir": "linux-64", + "timestamp": 1659549575202, + "version": "1.5.0" + }, + "xgboost-1.5.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "py-xgboost 1.5.0 py37h06a4308_1", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "3b4f72add1bb55d14974d833975e4cf2", + "name": "xgboost", + "sha256": "ff0d6feb0ea0d233335f3f14af7722b9891988f4a083d3395b5fe56e256f8985", + "size": 25142, + "subdir": "linux-64", + "timestamp": 1638290439953, + "version": "1.5.0" + }, + "xgboost-1.5.0-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "py-xgboost 1.5.0 py37h06a4308_2", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "md5": "b0d71d4908dd20963c354e0a9f342147", + "name": "xgboost", + "sha256": "d3808d461a46bd0539e5bf96ccede7a5c4400e18c57c4c8c7017cbc8ded0d6a7", + "size": 15060, + "subdir": "linux-64", + "timestamp": 1659549583165, + "version": "1.5.0" + }, + "xgboost-1.5.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "py-xgboost 1.5.0 py38h06a4308_1", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "9dac6153f98428fd63b037837b83303f", + "name": "xgboost", + "sha256": "5cc41dd5c48addf8887b76388da393e5c38dcbb827792c38dcb86b32670aa85a", + "size": 25138, + "subdir": "linux-64", + "timestamp": 1638290428386, + "version": "1.5.0" + }, + "xgboost-1.5.0-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "py-xgboost 1.5.0 py38h06a4308_2", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "md5": "7f36c7db63e96e5ce11b843c9f3b0e93", + "name": "xgboost", + "sha256": "f2e468e8511d13191614aa3bb3f0b88b9726f7b7ebddcaabd6c98f642b73be64", + "size": 15062, + "subdir": "linux-64", + "timestamp": 1659549558140, + "version": "1.5.0" + }, + "xgboost-1.5.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "py-xgboost 1.5.0 py39h06a4308_1", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "4a5cfee161d6b2f3eedefbb2145b8a0c", + "name": "xgboost", + "sha256": "21712780672f313d9b223b03ebb580285197ac25deca99a173b88d686c5a71cc", + "size": 25134, + "subdir": "linux-64", + "timestamp": 1638290434279, + "version": "1.5.0" + }, + "xgboost-1.5.0-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "py-xgboost 1.5.0 py39h06a4308_2", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "md5": "6786e5c45cf7c2b2fd7188df17ed3d95", + "name": "xgboost", + "sha256": "15466f1d434c52f8385f4413a509543de4f06314309fd2226e7c082d729b88b9", + "size": 15054, + "subdir": "linux-64", + "timestamp": 1659549566670, + "version": "1.5.0" + }, + "xgboost-1.5.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.5.1 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dfc41a5b579c4eb4ea549f1c2d3f893f", + "name": "xgboost", + "sha256": "7db091df637d39c5d932f85e6bfa84ad4b9d7823800d206da41724364c035583", + "size": 14396, + "subdir": "linux-64", + "timestamp": 1675120221592, + "version": "1.5.1" + }, + "xgboost-1.5.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.5.1 py37h06a4308_0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f494cf6ef247288dce3ab9330dfbbc7d", + "name": "xgboost", + "sha256": "b204f51d89e1c5382d5ee848aac8d568196cef78117fc8dea1a9c3b80fbd8afc", + "size": 14365, + "subdir": "linux-64", + "timestamp": 1675120215524, + "version": "1.5.1" + }, + "xgboost-1.5.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.5.1 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "cb37d701b40b307336a2147c429527d9", + "name": "xgboost", + "sha256": "f0fdd4fc1f21fc6cc3a4ab20132f1404c68c8aaba66a2521c2acc545b884854a", + "size": 14374, + "subdir": "linux-64", + "timestamp": 1675120203933, + "version": "1.5.1" + }, + "xgboost-1.5.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.5.1 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "089cf2e92054a4fd9de8bf690b140925", + "name": "xgboost", + "sha256": "69195064e275f93cb3300e7b345e3741935b332707055baec0c740ab15d26078", + "size": 14363, + "subdir": "linux-64", + "timestamp": 1675120209568, + "version": "1.5.1" + }, + "xgboost-1.7.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.7.3 py310h06a4308_0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "935c8b79f9fac99a4c6d9e118de2f31f", + "name": "xgboost", + "sha256": "c6cd20a49df018ba720cd517f36593dce32e4735c5159a825cb86165de199209", + "size": 12174, + "subdir": "linux-64", + "timestamp": 1675458334122, + "version": "1.7.3" + }, + "xgboost-1.7.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.7.3 py311h06a4308_0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e48e91c237d930a03196e47fea157779", + "name": "xgboost", + "sha256": "0c892708800eedb623cb14587aff02f4f31d6838296874c7b57f703fcedb6702", + "size": 12208, + "subdir": "linux-64", + "timestamp": 1676922357173, + "version": "1.7.3" + }, + "xgboost-1.7.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.7.3 py38h06a4308_0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "aa0bbc21559e2b62e03bf8a12eec5ff4", + "name": "xgboost", + "sha256": "6663c34dbdc21ffb746c4aafab6faeb9b0e9eeef9d7bbae1c15b2f2bd5143623", + "size": 12152, + "subdir": "linux-64", + "timestamp": 1675458786974, + "version": "1.7.3" + }, + "xgboost-1.7.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "py-xgboost 1.7.3 py39h06a4308_0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "dba9d012fc47306eac7abbb4e6032cfd", + "name": "xgboost", + "sha256": "c0d9f5d67064cbcb78bd909f1ba68abd10eda79d828808442a22afa6f0dbe0b9", + "size": 12144, + "subdir": "linux-64", + "timestamp": 1675458570174, + "version": "1.7.3" + }, + "xlrd-1.1.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "22ddd59f9410c82aeb0d4d4bf1ff92e6", + "name": "xlrd", + "sha256": "a6e44865f9f60a52d4f7406329962a700e7d981f1e0d253d51ac4fea25bfe540", + "size": 186738, + "subdir": "linux-64", + "timestamp": 1530735954137, + "version": "1.1.0" + }, + "xlrd-1.1.0-py27ha77178f_1.conda": { + "build": "py27ha77178f_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "dfee72e99d8e6826bd8f13aabfb8fe28", + "name": "xlrd", + "sha256": "0eab594fc9fb2759d084dc74a914b08f1475316eab21d8e1bc29ce84a672df33", + "size": 187856, + "subdir": "linux-64", + "timestamp": 1505957463525, + "version": "1.1.0" + }, + "xlrd-1.1.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "a0be0c4ecd54df08ecadc1f169f80a67", + "name": "xlrd", + "sha256": "89b7b87f1d2557104c1c6f6390b3ab0983ca112a79625562e829a341c4c7cf6f", + "size": 187418, + "subdir": "linux-64", + "timestamp": 1534352124391, + "version": "1.1.0" + }, + "xlrd-1.1.0-py35h45a0a2a_1.conda": { + "build": "py35h45a0a2a_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "48cb851d59b5fb01085f5984a5857bfc", + "name": "xlrd", + "sha256": "f057b2069db0a52b50c36d728b5fa3b979012cc11fd6a989d395c9573a02bd6c", + "size": 188868, + "subdir": "linux-64", + "timestamp": 1505957478030, + "version": "1.1.0" + }, + "xlrd-1.1.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "b72a8e380d5c4fee05f228c64a0bb60f", + "name": "xlrd", + "sha256": "fc4494fe422acec836422f2622e2a51786b00a4ebe46f3021d32dfb8db2d1625", + "size": 187087, + "subdir": "linux-64", + "timestamp": 1530735933445, + "version": "1.1.0" + }, + "xlrd-1.1.0-py36h1db9f0c_1.conda": { + "build": "py36h1db9f0c_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "c66220fcc3e9cc884e2cc41c86ff4318", + "name": "xlrd", + "sha256": "9d724f6ea3660251583e32b866f15b8760109e45271ee4ec43faa7273221d80c", + "size": 185844, + "subdir": "linux-64", + "timestamp": 1505957492488, + "version": "1.1.0" + }, + "xlrd-1.1.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "d58fd0ef987ae11eb6ce42cadf76b64a", + "name": "xlrd", + "sha256": "eae2df71691a976125adc0fbdb9a6802f9c20372460c3d214b8c3d9bd7c87e8f", + "size": 184535, + "subdir": "linux-64", + "timestamp": 1530735975270, + "version": "1.1.0" + }, + "xlrd-1.2.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "e65ce2660846f3a478138c4030b4bc57", + "name": "xlrd", + "sha256": "5c53728ad80d68ec11f0803c5021498f0ce4b803d3c974fed0a9ac4598673b25", + "size": 181354, + "subdir": "linux-64", + "timestamp": 1545084033314, + "version": "1.2.0" + }, + "xlrd-1.2.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "6873e139a66469850677823655915528", + "name": "xlrd", + "sha256": "48656a65166d5aaec9e6de34597354d8ce94c0b9a61e651e6a506dca03219f23", + "size": 180589, + "subdir": "linux-64", + "timestamp": 1545084063693, + "version": "1.2.0" + }, + "xlrd-1.2.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause and BSD with advertising", + "license_family": "BSD", + "md5": "739614801e07e88a92d293669126702a", + "name": "xlrd", + "sha256": "352991321c0b6cd073b67d0085a55778fd620daaf57b0813a683bd7920889262", + "size": 178937, + "subdir": "linux-64", + "timestamp": 1545084091435, + "version": "1.2.0" + }, + "xlsxwriter-0.9.8-py27h260ecd4_0.conda": { + "build": "py27h260ecd4_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "62a6e53f582842f1ca504374b3b7cc8e", + "name": "xlsxwriter", + "sha256": "43a70f912ea8f1ded120a5ad48f77f34499661f2ca9bbeec8c75672c7a8bbc2b", + "size": 203150, + "subdir": "linux-64", + "timestamp": 1505852136453, + "version": "0.9.8" + }, + "xlsxwriter-0.9.8-py35hc9d400f_0.conda": { + "build": "py35hc9d400f_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "080eb0ae32b96968200e9ec79e20ca57", + "name": "xlsxwriter", + "sha256": "1cf6df4442fd978f904dab6688275e7e9267f446e1a148fa5ba70a65d483cfc4", + "size": 208134, + "subdir": "linux-64", + "timestamp": 1505852150722, + "version": "0.9.8" + }, + "xlsxwriter-0.9.8-py36hf41c223_0.conda": { + "build": "py36hf41c223_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "235d078adabd209f980e0d1cbcfb5292", + "name": "xlsxwriter", + "sha256": "58752451bbe2d9b2e348a3abce2609c60afe8808caeebff50cef60dfe6354c89", + "size": 205976, + "subdir": "linux-64", + "timestamp": 1505852165158, + "version": "0.9.8" + }, + "xlsxwriter-1.0.2-py27h12cbc6b_0.conda": { + "build": "py27h12cbc6b_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "63aca6b727d0c45579807e95b66c644f", + "name": "xlsxwriter", + "sha256": "52c7be45e3761f7c73893f5d89c501e66b78277e71d86ada6790124dc4795c59", + "size": 208456, + "subdir": "linux-64", + "timestamp": 1508626765468, + "version": "1.0.2" + }, + "xlsxwriter-1.0.2-py35h8ee9321_0.conda": { + "build": "py35h8ee9321_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "253491e5036f8cd7c82c32c6386ac3d0", + "name": "xlsxwriter", + "sha256": "cc579d4e87c66e771166957015ce505c2cd2b0573fa3d2834a0416f0b0f027e1", + "size": 211633, + "subdir": "linux-64", + "timestamp": 1508626736309, + "version": "1.0.2" + }, + "xlsxwriter-1.0.2-py36h3de1aca_0.conda": { + "build": "py36h3de1aca_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "bb583b97108d4092a4d324180bf6c330", + "name": "xlsxwriter", + "sha256": "95048de128e24ed4af80a4f01ed4a6b0ae33e4e191e7c2832a670293900ad43d", + "size": 209740, + "subdir": "linux-64", + "timestamp": 1508626789486, + "version": "1.0.2" + }, + "xlsxwriter-1.0.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a29c80b61ec5f70415e6d357b7a43c5b", + "name": "xlsxwriter", + "sha256": "a1a0c6684108cd5632540377d76e0555e5a3807ea00716f9d621b5d8f7249e4b", + "size": 211754, + "subdir": "linux-64", + "timestamp": 1523945846481, + "version": "1.0.4" + }, + "xlsxwriter-1.0.4-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "a057f064a70abcc89d0bb8457ff23ad2", + "name": "xlsxwriter", + "sha256": "0bfad20a6d86b6c3bdb1ec72117b448f7b47b6f46f4bf1e92045359fc6114ac1", + "size": 212678, + "subdir": "linux-64", + "timestamp": 1523946057706, + "version": "1.0.4" + }, + "xlsxwriter-1.0.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "34d010587da5b9f42f174ed9a9ceecf6", + "name": "xlsxwriter", + "sha256": "ece1f8914d259474f219735ea2e190fe02f606c14a919cc332f33a8f73d75055", + "size": 210724, + "subdir": "linux-64", + "timestamp": 1523946050359, + "version": "1.0.4" + }, + "xlsxwriter-1.0.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "bc7fdf867fbcb98de36221581e33ffc0", + "name": "xlsxwriter", + "sha256": "86b7a811ae03cbf1624d3afa42858e7523e1d5b20cd4d92d7056fd858ab4ff69", + "size": 213900, + "subdir": "linux-64", + "timestamp": 1527829440164, + "version": "1.0.5" + }, + "xlsxwriter-1.0.5-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "eab981fa338fded53630c788e58bd13f", + "name": "xlsxwriter", + "sha256": "d7b27a0e6fec2145575d8b83aa553088f0b61a3e8070762bd0422b02e669e473", + "size": 217491, + "subdir": "linux-64", + "timestamp": 1527830312008, + "version": "1.0.5" + }, + "xlsxwriter-1.0.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "ac6cf5b5a8961979917b2e8a8291ca19", + "name": "xlsxwriter", + "sha256": "a79c0943eb280de5fb5195902ccb5b67d6fb71b95336095eb3cea1c1b434ef9d", + "size": 212946, + "subdir": "linux-64", + "timestamp": 1527829417802, + "version": "1.0.5" + }, + "xlsxwriter-1.0.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "c9d232c99b9c5b1a70629edb233bf5fc", + "name": "xlsxwriter", + "sha256": "aa5aa18267f7dde455a1e9f9a66fbdca679f4bf2bd2479a5510ee7894fafdde5", + "size": 212166, + "subdir": "linux-64", + "timestamp": 1531065251202, + "version": "1.0.5" + }, + "xlsxwriter-1.0.7-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "7647a37f5bc97ad8c4c071cf6ce3ee75", + "name": "xlsxwriter", + "sha256": "9a34f6fdef0a7bf36e3429c4e0b9e5201ec347151557f3450a6f2bc03d8f98c6", + "size": 212959, + "subdir": "linux-64", + "timestamp": 1534949128769, + "version": "1.0.7" + }, + "xlsxwriter-1.0.7-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8360c2b0abe91756a8cb27c25d2ca516", + "name": "xlsxwriter", + "sha256": "0b0547e34e3ea4e72ae084c9c017389f1cb86df1f2ccfde8826d55bb8dae88ec", + "size": 217853, + "subdir": "linux-64", + "timestamp": 1534949196997, + "version": "1.0.7" + }, + "xlsxwriter-1.0.7-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d8e894f3722c61229886f87d5ac866fb", + "name": "xlsxwriter", + "sha256": "bfa1b1633c7b6fe7b49795b1b286455a0abac1b4a1aeaefe88b6ec009490a62f", + "size": 215629, + "subdir": "linux-64", + "timestamp": 1534949166534, + "version": "1.0.7" + }, + "xlsxwriter-1.0.7-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "1de50a42c1360ba0bdd375ec476450e1", + "name": "xlsxwriter", + "sha256": "8e3519090f05c4a1bf5768971629736123eb62d000880f953c53d742b2fc5782", + "size": 215086, + "subdir": "linux-64", + "timestamp": 1534949145433, + "version": "1.0.7" + }, + "xlsxwriter-1.0.8-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "d84a602e2c4e8a116ed0ab252dbb8ccb", + "name": "xlsxwriter", + "sha256": "e9a16765f42807a04d219be8b282ea2e51fc5e0a68061733f40b8626427b0180", + "size": 215399, + "subdir": "linux-64", + "timestamp": 1535380656812, + "version": "1.0.8" + }, + "xlsxwriter-1.0.8-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8fa094f4d57e077acbea3306d19bdb7b", + "name": "xlsxwriter", + "sha256": "45e1dafd7d022abd228381eaf1c06782d629b79b05646ec0eef80c64ecbee5e8", + "size": 218984, + "subdir": "linux-64", + "timestamp": 1535380555654, + "version": "1.0.8" + }, + "xlsxwriter-1.0.8-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "794bd1fa68886837c6f4282657076aad", + "name": "xlsxwriter", + "sha256": "70c9153e9deeefbda10bc6853675491f5450c763eff89bc1acd857f8c6f43a30", + "size": 214412, + "subdir": "linux-64", + "timestamp": 1535380516825, + "version": "1.0.8" + }, + "xlsxwriter-1.0.8-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8c2b9d58443a52cb7a20a2b2389148c1", + "name": "xlsxwriter", + "sha256": "f31c3a6add3f478b3a0a469237e4ac4d26fbe27c2941f5c443e59d48f9036db2", + "size": 213834, + "subdir": "linux-64", + "timestamp": 1535380669643, + "version": "1.0.8" + }, + "xlsxwriter-1.1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "da5dde8cfe42b1052049ac55556870aa", + "name": "xlsxwriter", + "sha256": "8a827d8fd1899e095454395f13a7096f073cf729021cda9e8b879f9221e714b5", + "size": 214050, + "subdir": "linux-64", + "timestamp": 1536083864946, + "version": "1.1.0" + }, + "xlsxwriter-1.1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "04f44895215c08419479e3df80033da4", + "name": "xlsxwriter", + "sha256": "c647efcb95671b726c849a7f472975edd3f5f3f1b0e9a780ce600d4861b58407", + "size": 219220, + "subdir": "linux-64", + "timestamp": 1536080224388, + "version": "1.1.0" + }, + "xlsxwriter-1.1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "2e02d742f94ab5a420f7184597d210f1", + "name": "xlsxwriter", + "sha256": "aa67bacb7f82e032c853a5a42119834fcb90114ddeb5ad8e3a437c8f81e27bb2", + "size": 214551, + "subdir": "linux-64", + "timestamp": 1536080194913, + "version": "1.1.0" + }, + "xlsxwriter-1.1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "b934d14481735c891fd266abd6523c2e", + "name": "xlsxwriter", + "sha256": "e16d90d4dd7f210f6dc04f7bb559f92ac92a51cc9daeeb0be607d3282646aebc", + "size": 213954, + "subdir": "linux-64", + "timestamp": 1536083890472, + "version": "1.1.0" + }, + "xlsxwriter-1.1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4b449b8648f1926269f6ea4db9049c24", + "name": "xlsxwriter", + "sha256": "98510cebc7af55aa1ba402d982f0a8a81edf61bbcc1c51df5ca178969319e538", + "size": 215658, + "subdir": "linux-64", + "timestamp": 1538231258162, + "version": "1.1.1" + }, + "xlsxwriter-1.1.1-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "55441f8c9f378210f1b52fcef5d38194", + "name": "xlsxwriter", + "sha256": "b2c72ae7b03fff90e68956305c3c0a98d54b77edae156c808572cb26065fe9a4", + "size": 218155, + "subdir": "linux-64", + "timestamp": 1538231285440, + "version": "1.1.1" + }, + "xlsxwriter-1.1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "fdd8b621e23b92b253c635abf47e5b18", + "name": "xlsxwriter", + "sha256": "6dc1e858cabbe30c7f40a5a5ae56b87f46c3a3089bd0c0c905d49e255c1f8a35", + "size": 218537, + "subdir": "linux-64", + "timestamp": 1538231284767, + "version": "1.1.1" + }, + "xlsxwriter-1.1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9a7c8064e568e72dc0646ea9c6a46181", + "name": "xlsxwriter", + "sha256": "3b074704002c731a323cbc7d5e93b5ebf8d4e86c51c2c8fee16cbc6d1cc2c927", + "size": 215892, + "subdir": "linux-64", + "timestamp": 1538231245788, + "version": "1.1.1" + }, + "xlsxwriter-1.1.2-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "4618098b30b378098544ed5ede6f98bf", + "name": "xlsxwriter", + "sha256": "c096e057ad1a461bc5f086305087108dec8d0a4fc52811492ca2eefeec85cab1", + "size": 218773, + "subdir": "linux-64", + "timestamp": 1540236392823, + "version": "1.1.2" + }, + "xlsxwriter-1.1.2-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "502435f86dc36f649caafff7fac22d2c", + "name": "xlsxwriter", + "sha256": "31737e6f3f8490d729c254313be86ea850b892740ebf75fc77b03a79bdb1aa11", + "size": 217615, + "subdir": "linux-64", + "timestamp": 1540236436649, + "version": "1.1.2" + }, + "xlsxwriter-1.1.2-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "8c25f4fd958f4882459b8dacde0679ef", + "name": "xlsxwriter", + "sha256": "a4b845cefc98b772729d51151659d4926ade75c01d05d8d55ef0c4870b5d800a", + "size": 216861, + "subdir": "linux-64", + "timestamp": 1540236431121, + "version": "1.1.2" + }, + "xlsxwriter-1.1.5-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "71606191a670f60b4981a953f9dbe065", + "name": "xlsxwriter", + "sha256": "4d209c1b07858852d8f49bc7f07dba6db0daabbe4672d5c0daecc3b71813e61f", + "size": 218254, + "subdir": "linux-64", + "timestamp": 1551149758442, + "version": "1.1.5" + }, + "xlsxwriter-1.1.5-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "9a6950fb5b0bfa1fa0d89a3c7839fa5a", + "name": "xlsxwriter", + "sha256": "84ae892a937b5aba0b138556cdbd7dd17b54ced8671ab07290329f01cd435d61", + "size": 217157, + "subdir": "linux-64", + "timestamp": 1551149776375, + "version": "1.1.5" + }, + "xlsxwriter-1.1.5-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 2-Clause", + "license_family": "BSD", + "md5": "3bd6b88d85869b79ed8dc8f8a2947e22", + "name": "xlsxwriter", + "sha256": "9e337e7a6c8d8de082cb17a0ccd5228b79bd3e16a186c45ee650ead421f570df", + "size": 216908, + "subdir": "linux-64", + "timestamp": 1551149751540, + "version": "1.1.5" + }, + "xlutils-2.0.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "xlrd >=0.7.2", + "xlwt >=0.7.4" + ], + "license": "MIT", + "md5": "5996755f1744262ceb8d7cef29cce4bb", + "name": "xlutils", + "sha256": "e59afa9509fff8e5e5ac004e56c079458a6b9b921efec2429998536366a19e76", + "size": 75483, + "subdir": "linux-64", + "timestamp": 1540320449699, + "version": "2.0.0" + }, + "xlutils-2.0.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "xlrd >=0.7.2", + "xlwt >=0.7.4" + ], + "license": "MIT", + "md5": "d663335141b1c737741b57510ff0e1a6", + "name": "xlutils", + "sha256": "ff3beb9762f7264760c91913a32a49aa04e3eba270597fc24c070758561e11b2", + "size": 76097, + "subdir": "linux-64", + "timestamp": 1540320491367, + "version": "2.0.0" + }, + "xlutils-2.0.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "xlrd >=0.7.2", + "xlwt >=0.7.4" + ], + "license": "MIT", + "md5": "e946da0054a42ea68ceb8e419937d0bb", + "name": "xlutils", + "sha256": "7c21678d3ca53d280c5435c7742ccfc84fef7b771c6cc970ad40f101fd631be9", + "size": 75845, + "subdir": "linux-64", + "timestamp": 1540320515747, + "version": "2.0.0" + }, + "xlwt-1.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "d99e829ccc020678b8994013f9589174", + "name": "xlwt", + "sha256": "26078e1057dbe93405db69b5128a49be5e381799c1cd289d1f327cdb50d747e0", + "size": 162864, + "subdir": "linux-64", + "timestamp": 1531065354863, + "version": "1.3.0" + }, + "xlwt-1.3.0-py27h3d85d97_0.conda": { + "build": "py27h3d85d97_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "6e3ae29cee0ddba324e18f535ece0512", + "name": "xlwt", + "sha256": "657ad3a47d1517a0e47e057dac0045ec43cd593e72267d187bc86dc6e3c2a84d", + "size": 161150, + "subdir": "linux-64", + "timestamp": 1505852179274, + "version": "1.3.0" + }, + "xlwt-1.3.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "9f2a7dc17dd714f98e14fdfaf32d8ccc", + "name": "xlwt", + "sha256": "0f01738b27cd78cfacfc1211024d6209d4fd0718041904de64fd264219d7aa82", + "size": 166974, + "subdir": "linux-64", + "timestamp": 1640796107721, + "version": "1.3.0" + }, + "xlwt-1.3.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "79459c359e1f4d8059b4a1bd96741929", + "name": "xlwt", + "sha256": "ef1c690fbda57ece2625b9eb25c9a393477a236bd63d615dba67e5cf6aeb4300", + "size": 213016, + "subdir": "linux-64", + "timestamp": 1676863547463, + "version": "1.3.0" + }, + "xlwt-1.3.0-py35h884a0cf_0.conda": { + "build": "py35h884a0cf_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "0756ed0138e0563e981db9e90aaab304", + "name": "xlwt", + "sha256": "85f697de50e2d4d43f9a2789ec2146bd97850dc782d14a2e3c775fd611d432bb", + "size": 166439, + "subdir": "linux-64", + "timestamp": 1505852192718, + "version": "1.3.0" + }, + "xlwt-1.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "384bb79ea6ca59b2d120b006ca4d2cc1", + "name": "xlwt", + "sha256": "efa96168e328833da5d689f793d8ff9652da6461c19728ca7a545c33a26a8467", + "size": 162386, + "subdir": "linux-64", + "timestamp": 1531065286737, + "version": "1.3.0" + }, + "xlwt-1.3.0-py36h7b00a1f_0.conda": { + "build": "py36h7b00a1f_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "41eba8b03e274d5de7e1181b6b7d20ab", + "name": "xlwt", + "sha256": "0be4498125cc90dbf50fdb6e6a941c1552960c9e1f335991457a5ca0a72ab0d8", + "size": 162179, + "subdir": "linux-64", + "timestamp": 1505852206320, + "version": "1.3.0" + }, + "xlwt-1.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "b8f874d8a930484af89a4b85f129f29d", + "name": "xlwt", + "sha256": "df9e8a5553c0308a82ec64f51c28efdf13bbdfaa11093a5f880e245432a852ad", + "size": 161459, + "subdir": "linux-64", + "timestamp": 1531065321284, + "version": "1.3.0" + }, + "xlwt-1.3.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "70697417b7966b4541ac5075b6789856", + "name": "xlwt", + "sha256": "1c9a7eac1354e5157f02f077671f185434a27c8537653c15ec5cf010984b34e8", + "size": 163499, + "subdir": "linux-64", + "timestamp": 1573730053566, + "version": "1.3.0" + }, + "xlwt-1.3.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "731bfde96b79127a2a898183ce7096f7", + "name": "xlwt", + "sha256": "662ef542229f6d3ad07b2267f9636f6f1f2336cab7f4f461335f0f3818d9057b", + "size": 163625, + "subdir": "linux-64", + "timestamp": 1607542800454, + "version": "1.3.0" + }, + "xmlrpc2-0.3.1-py27_2.conda": { + "build": "py27_2", + "build_number": 2, + "depends": [ + "python >=2.7,<2.8.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "6366b849ffe3dd239311b66beeb79787", + "name": "xmlrpc2", + "sha256": "4963f103595a3da621b69df9332409791ebf0c0fdad61147298b944e5f4b5120", + "size": 12338, + "subdir": "linux-64", + "timestamp": 1530022663593, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py310h06a4308_2.conda": { + "build": "py310h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.10,<3.11.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "c21827cc8424f00ca2b0f0220658c727", + "name": "xmlrpc2", + "sha256": "ffb03ce78a7fccc41fb37dff4e26ce3aabe393fb50aaba1d3893f7cdba7403c5", + "size": 12053, + "subdir": "linux-64", + "timestamp": 1640796125743, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py311h06a4308_2.conda": { + "build": "py311h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.11,<3.12.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "e5eb15c98ba4317a106cd7ae64415340", + "name": "xmlrpc2", + "sha256": "08117c718048450e0fcfe1b0679dc0e978c2296ca6a66a3bf390e003afb4e7ec", + "size": 15356, + "subdir": "linux-64", + "timestamp": 1676907829709, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py35_2.conda": { + "build": "py35_2", + "build_number": 2, + "depends": [ + "python >=3.5,<3.6.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "315fa8207d38e2c2ab75a354656923d8", + "name": "xmlrpc2", + "sha256": "ab03444bc083704c336a72025f4efd6ae8f7c03bc5f24c24df883996b827beda", + "size": 12538, + "subdir": "linux-64", + "timestamp": 1530022738965, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py36_2.conda": { + "build": "py36_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "6ee588aa49d151b7e2d3976cd65ed156", + "name": "xmlrpc2", + "sha256": "fbc830e7020bb275d927b1ff1290f4774b521b76cb89c1521d5d77091629bff5", + "size": 12533, + "subdir": "linux-64", + "timestamp": 1530022643056, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py36h06a4308_2.conda": { + "build": "py36h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.6,<3.7.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "d6e0245fe054de73bba2d6b7d040eeab", + "name": "xmlrpc2", + "sha256": "4dd7d8388a93b33bfc6847d7b7ba606707ce39016ef8dbc4408d39f56e30e00e", + "size": 249787, + "subdir": "linux-64", + "timestamp": 1613159725309, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py37_2.conda": { + "build": "py37_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "4b1613fb9e09a496eee5b05f3d6c29b9", + "name": "xmlrpc2", + "sha256": "ba8e470ee80b74875f200b7d4d8a21f7886ae4e5dae26a40bd5bf96e42cb1c0f", + "size": 12776, + "subdir": "linux-64", + "timestamp": 1545233507649, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py37h06a4308_2.conda": { + "build": "py37h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.7,<3.8.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "aac27c15a5dbdadf28fa15c0f7e3dae0", + "name": "xmlrpc2", + "sha256": "3b4823cf88836c0aef70bfbfc29b10cf644b42115bf0155dccb999e07e358dbc", + "size": 249263, + "subdir": "linux-64", + "timestamp": 1613159719197, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py38_2.conda": { + "build": "py38_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "909d49807d8f09873dc53e29fc5c4d27", + "name": "xmlrpc2", + "sha256": "2947c85f8548a2bd55425ad92546c07da81018fda695022499f60d467b17561b", + "size": 12176, + "subdir": "linux-64", + "timestamp": 1574237992569, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py38h06a4308_2.conda": { + "build": "py38h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.8,<3.9.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "d7b868631fd029999d129cc254316877", + "name": "xmlrpc2", + "sha256": "04205e26a8fc9921f6326bbc600f9d6ef375f868944399290f372ce0346b3cc5", + "size": 249839, + "subdir": "linux-64", + "timestamp": 1613159262164, + "version": "0.3.1" + }, + "xmlrpc2-0.3.1-py39h06a4308_2.conda": { + "build": "py39h06a4308_2", + "build_number": 2, + "depends": [ + "python >=3.9,<3.10.0a0", + "python-dateutil >=2.1", + "requests", + "six" + ], + "license": "BSD", + "md5": "91edd23051c417d8c60f6693b105cd83", + "name": "xmlrpc2", + "sha256": "fab859031838f81b23914e8b68f97194fb66093ac7696c669fec1f38f39d4dce", + "size": 249523, + "subdir": "linux-64", + "timestamp": 1613159722399, + "version": "0.3.1" + }, + "xmlsec-1.3.10-py310hfa300c1_0.conda": { + "build": "py310hfa300c1_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libxml2 >=2.9.12,<2.10.0a0", + "libxmlsec1 >=1.2.32,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3cdcef82c5bd9a1eabc6df00b823dd20", + "name": "xmlsec", + "sha256": "f2c3a182c5404a53e7e47e828398d7d4c5f3acc5227b986393b8dfbd54507fee", + "size": 127046, + "subdir": "linux-64", + "timestamp": 1641480333640, + "version": "1.3.10" + }, + "xmlsec-1.3.10-py311h0cc8e7e_0.conda": { + "build": "py311h0cc8e7e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.9.14,<2.10.0a0", + "libxmlsec1 >=1.2.32,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1e00e4a96c3d4a1627b5bb134d94bab", + "name": "xmlsec", + "sha256": "62a75d8a25e215fba6ccc9e5e98b946b04ea3e94f4284b558074a632a087e21b", + "size": 126247, + "subdir": "linux-64", + "timestamp": 1676907851352, + "version": "1.3.10" + }, + "xmlsec-1.3.13-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "libxmlsec1 >=1.2.32,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "996376754e4e9d8330c5433c793462c1", + "name": "xmlsec", + "sha256": "deff47b96bdb7285a078bb95c8b9f3711411f1975671d58ddf7b6018d731e02f", + "size": 145053, + "subdir": "linux-64", + "timestamp": 1679915886203, + "version": "1.3.13" + }, + "xmlsec-1.3.13-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "libxmlsec1 >=1.2.32,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cfa48aead8f56b9b101596bc0f4a6da3", + "name": "xmlsec", + "sha256": "3567f286f0a8806563679c71e9352755c1cafd52ed5263c362c4224311c33427", + "size": 148648, + "subdir": "linux-64", + "timestamp": 1679915983871, + "version": "1.3.13" + }, + "xmlsec-1.3.13-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "libxmlsec1 >=1.2.32,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "22284661f6a319df56228d9a58b1152a", + "name": "xmlsec", + "sha256": "c575700517c3b47e04b9083bc91c50efe29ad3a980af3c58f6c5f05d4c813d41", + "size": 145423, + "subdir": "linux-64", + "timestamp": 1679915950755, + "version": "1.3.13" + }, + "xmlsec-1.3.13-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libxml2 >=2.10.3,<2.11.0a0", + "libxmlsec1 >=1.2.32,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "02030398e38ab452f29d5f9268fe6922", + "name": "xmlsec", + "sha256": "9c4e97b8ccbd028cf7ba44a9c0b0e681ce0e6637fac5b4579ba45d4d0566ff62", + "size": 143527, + "subdir": "linux-64", + "timestamp": 1679915917972, + "version": "1.3.13" + }, + "xmlsec-1.3.3-py36h0e8eec6_0.conda": { + "build": "py36h0e8eec6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxmlsec1 >=1.2.29,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d80d316afd30e38c4158f3fc2b235f95", + "name": "xmlsec", + "sha256": "d4dd3ee7304f338dde03b4a2934832b06c1c692d48fc62c31b73e91080e2de07", + "size": 293137, + "subdir": "linux-64", + "timestamp": 1584995656132, + "version": "1.3.3" + }, + "xmlsec-1.3.3-py36h49a3d8c_0.conda": { + "build": "py36h49a3d8c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxmlsec1 >=1.2.29,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e9fdf7e5a0d7804e272ebae280f1f845", + "name": "xmlsec", + "sha256": "bf29f412de6376d8f2d421ef43c0f266f9213f5a6a61af2ed35c28e1c5debf40", + "size": 357229, + "subdir": "linux-64", + "timestamp": 1613393300545, + "version": "1.3.3" + }, + "xmlsec-1.3.3-py37h0e8eec6_0.conda": { + "build": "py37h0e8eec6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxmlsec1 >=1.2.29,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9df328c027c872620f1158b694c372c1", + "name": "xmlsec", + "sha256": "0b0f51104909e836a262d0198d4c0d6ebe9771e737967710ac49dde7fba29ae4", + "size": 295835, + "subdir": "linux-64", + "timestamp": 1584995654935, + "version": "1.3.3" + }, + "xmlsec-1.3.3-py37h49a3d8c_0.conda": { + "build": "py37h49a3d8c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxmlsec1 >=1.2.29,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "52559994ed65c9c071fd0aca9589ebad", + "name": "xmlsec", + "sha256": "2fe93415098e4941c7e6d0fc698030979c646772c17f75bb25fa10837e1f9810", + "size": 357533, + "subdir": "linux-64", + "timestamp": 1613393302446, + "version": "1.3.3" + }, + "xmlsec-1.3.3-py38h0e8eec6_0.conda": { + "build": "py38h0e8eec6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.9,<2.10.0a0", + "libxmlsec1 >=1.2.29,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d381669a1df4659539f30c45d920898c", + "name": "xmlsec", + "sha256": "6d39a063152629d9bfc58a123af1eb0516630db478660c37dd6dd3bd5546972f", + "size": 297262, + "subdir": "linux-64", + "timestamp": 1584995650789, + "version": "1.3.3" + }, + "xmlsec-1.3.3-py38h49a3d8c_0.conda": { + "build": "py38h49a3d8c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxmlsec1 >=1.2.29,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2cc452467ac1c9176cf1515100c3cbc9", + "name": "xmlsec", + "sha256": "0a05b85c91829bc77541454a7c9d5303945a9e40cd55c03673dbc557f4f0153a", + "size": 357400, + "subdir": "linux-64", + "timestamp": 1613393237639, + "version": "1.3.3" + }, + "xmlsec-1.3.3-py39h49a3d8c_0.conda": { + "build": "py39h49a3d8c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libxml2 >=2.9.10,<2.10.0a0", + "libxmlsec1 >=1.2.29,<1.3.0a0", + "lxml >=3.8.0", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6eb155781a47a899f1db8c6bca79621e", + "name": "xmlsec", + "sha256": "7df027a70fe7625ad92b5734198ac80615beeb4d3b2a1db44e07967f5d48e97f", + "size": 358026, + "subdir": "linux-64", + "timestamp": 1613393236020, + "version": "1.3.3" + }, + "xmltodict-0.11.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "md5": "801045343a565fb68a83b60a226daf37", + "name": "xmltodict", + "sha256": "0a6152bfacc2248e98fee99bc0c99b03dac82f01f7f769102a341a793471e425", + "size": 14775, + "subdir": "linux-64", + "timestamp": 1536857584645, + "version": "0.11.0" + }, + "xmltodict-0.11.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "MIT", + "md5": "f41211c583b87baf0fb6f8405e224ca2", + "name": "xmltodict", + "sha256": "bce3c3f64105b0df8aa697ac3004b0bede0aec705fc830eaad94006877305ae2", + "size": 14772, + "subdir": "linux-64", + "timestamp": 1536857704113, + "version": "0.11.0" + }, + "xmltodict-0.11.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "md5": "c8e43a24d85ef5f44f3c5de1bc0de0a3", + "name": "xmltodict", + "sha256": "e0b262c79a84c5eaf2883343420be192bbf8bbe57c632cae71b6c8a55cbe34d1", + "size": 14642, + "subdir": "linux-64", + "timestamp": 1536857678746, + "version": "0.11.0" + }, + "xmltodict-0.11.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "md5": "8dd081135a470aa0fb9d0eeafd1c08c3", + "name": "xmltodict", + "sha256": "2bda20d0205f9f7fdfe15eaf983f4f99fca06083176c4071d3d75498be36f41f", + "size": 14653, + "subdir": "linux-64", + "timestamp": 1536857563546, + "version": "0.11.0" + }, + "xorg-util-macros-1.19.0-h27cfd23_1.conda": { + "build": "h27cfd23_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1db6edf975cd9e351e23605a981acdea", + "name": "xorg-util-macros", + "sha256": "9495f8259254cbface9d001d868352be440070b5a24e79e195e2dcbde0ff4755", + "size": 69388, + "subdir": "linux-64", + "timestamp": 1607596307831, + "version": "1.19.0" + }, + "xorg-util-macros-1.19.0-h27cfd23_2.conda": { + "build": "h27cfd23_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ce1492429876c719cf616412469b3c2a", + "name": "xorg-util-macros", + "sha256": "b13d69f403b6cacb232d7aea78fff060d98c4faf552ecff0cc44948297c26217", + "size": 69300, + "subdir": "linux-64", + "timestamp": 1608058495834, + "version": "1.19.0" + }, + "xorg-xproto-7.0.31-h27cfd23_1007.conda": { + "build": "h27cfd23_1007", + "build_number": 1007, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "287ea0f32c5f1c209e5030ead360b613", + "name": "xorg-xproto", + "sha256": "94c5308b9e2672d63e42fbb123c3e7d247385a2af303ce15500394ad0af005e6", + "size": 74389, + "subdir": "linux-64", + "timestamp": 1608060663059, + "version": "7.0.31" + }, + "xsimd-10.0.0-hdb19cb5_0.conda": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b95b1493da71a5b2d73718ea787d5c80", + "name": "xsimd", + "sha256": "8b6731a4432dd677b750f384cf106eeefcd28d5072ffd2e8e524b1dfb2a7cac4", + "size": 115623, + "subdir": "linux-64", + "timestamp": 1674510107603, + "version": "10.0.0" + }, + "xsimd-7.5.0-hd09550d_1.conda": { + "build": "hd09550d_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "26854bddc78cc8acc641364e33747abb", + "name": "xsimd", + "sha256": "8893a0e27d07cd77529e7d9e41bde12e57ccabfb94933b3d5bd045fb668ffe33", + "size": 107971, + "subdir": "linux-64", + "timestamp": 1625061921267, + "version": "7.5.0" + }, + "xsimd-7.6.0-hd09550d_0.conda": { + "build": "hd09550d_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f050c88a7b0d4abea3ded5c27eb74161", + "name": "xsimd", + "sha256": "60638b6bdb9af1a13d5bd0916873591c07a0858b1459e79b0b6f93aecae2830f", + "size": 120925, + "subdir": "linux-64", + "timestamp": 1631121334121, + "version": "7.6.0" + }, + "xsimd-8.0.5-hdb19cb5_0.conda": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8e489b57036be347a3af6d7bde37907a", + "name": "xsimd", + "sha256": "fc97422c063e1b067752d732696ea5e7838fb546fd7a2a80c6e322356acdcb4e", + "size": 87747, + "subdir": "linux-64", + "timestamp": 1659988723476, + "version": "8.0.5" + }, + "xsimd-9.0.1-hdb19cb5_0.conda": { + "build": "hdb19cb5_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "806f45e3d884a3b8e4d1ce81fdda347e", + "name": "xsimd", + "sha256": "91accc9ae5c48867c55529392d7f55b6a6444423fc12906a039b0a36753ffccd", + "size": 114901, + "subdir": "linux-64", + "timestamp": 1668700367347, + "version": "9.0.1" + }, + "xxhash-0.8.0-h7f8727e_3.conda": { + "build": "h7f8727e_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "BSD-2-Clause", + "md5": "196b013514e82fd8476558de622c0d46", + "name": "xxhash", + "sha256": "e27f5f56bf36a8fd3f2d4e0cfe99aea5d30ff0bb87fd78aab6fb91dc1198cbca", + "size": 85147, + "subdir": "linux-64", + "timestamp": 1633100384388, + "version": "0.8.0" + }, + "xyzservices-2022.9.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d453f032509d47ccf6d2cd763b268a70", + "name": "xyzservices", + "sha256": "0fab318e964c9bf493558c4c0dd4ed9d484f33cd4b030f7b3adabc048096595b", + "size": 42602, + "subdir": "linux-64", + "timestamp": 1665472449729, + "version": "2022.9.0" + }, + "xyzservices-2022.9.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2344c7b4b27172301fb9c5bdb3da71c2", + "name": "xyzservices", + "sha256": "34aa25196e67e2a4bcf4d28f2f69d1a157613fcdddcffa69529568e4f76866a2", + "size": 44448, + "subdir": "linux-64", + "timestamp": 1675159089417, + "version": "2022.9.0" + }, + "xyzservices-2022.9.0-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "db81aa6ab284ef0500345e8cde778e6b", + "name": "xyzservices", + "sha256": "387e7852d7c046136611314e4399560cb4e45761292a3d1466ea7e7f714d46be", + "size": 49110, + "subdir": "linux-64", + "timestamp": 1676828934954, + "version": "2022.9.0" + }, + "xyzservices-2022.9.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "232e7448ba1de25d410712746a7def29", + "name": "xyzservices", + "sha256": "4e60cf4d3474037ef2ee0e6a8612f27a2bde8fcec3fd0ce7c7f0b99fa9ac73d2", + "size": 42384, + "subdir": "linux-64", + "timestamp": 1665472498112, + "version": "2022.9.0" + }, + "xyzservices-2022.9.0-py37h06a4308_1.conda": { + "build": "py37h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "33dfcf9304dc2b4402a0660a784b8aa7", + "name": "xyzservices", + "sha256": "115c84f49ce55f16be408015f0b57ea9c2bf234215c15295b18976e993e260b5", + "size": 44253, + "subdir": "linux-64", + "timestamp": 1675159140331, + "version": "2022.9.0" + }, + "xyzservices-2022.9.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f22f93bd1717ed36f0fe3e7e649f4322", + "name": "xyzservices", + "sha256": "0d1727323fd04e62616585b730df14e4287d561e9e0f96946c737788e7250d22", + "size": 42493, + "subdir": "linux-64", + "timestamp": 1665472522514, + "version": "2022.9.0" + }, + "xyzservices-2022.9.0-py38h06a4308_1.conda": { + "build": "py38h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3931605f9fc55a274b0d13679e3c97dd", + "name": "xyzservices", + "sha256": "61118c79eaf61d750c530937375629cbe8c2ebc03e47f0026eac6dac39bbc708", + "size": 44341, + "subdir": "linux-64", + "timestamp": 1675159165834, + "version": "2022.9.0" + }, + "xyzservices-2022.9.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ac8f70bea4fea7ba726694bf316ce164", + "name": "xyzservices", + "sha256": "b64e1a320f8af27c6e9cba6d0bef81bd16983ede8d7a5117a8b85dcade972318", + "size": 42483, + "subdir": "linux-64", + "timestamp": 1665472473554, + "version": "2022.9.0" + }, + "xyzservices-2022.9.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1616d2944ece28c4e4c5bfd45f8eca12", + "name": "xyzservices", + "sha256": "8ef341685c03e8425256de20466d9d49dcc314de9fdfebceb0f316093b6c9003", + "size": 44301, + "subdir": "linux-64", + "timestamp": 1675159114742, + "version": "2022.9.0" + }, + "xz-5.2.10-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "LGPL-2.1-or-later and GPL-2.0-or-later", + "license_family": "GPL2", + "md5": "ab2f4be3898447ecf13015e8c89f1dd6", + "name": "xz", + "sha256": "626974f04bfa4d68ae4cfafe24ab7dd557b50e9cdab22a9ae942e9c6a83ee08f", + "size": 440861, + "subdir": "linux-64", + "timestamp": 1673967759586, + "version": "5.2.10" + }, + "xz-5.2.10-h5eee18b_1.conda": { + "build": "h5eee18b_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "LGPL-2.1-or-later and GPL-2.0-or-later", + "license_family": "GPL2", + "md5": "dd172c348274807ec0d841df8295b670", + "name": "xz", + "sha256": "a64238f4cc4e3961ae6e33a4b466d84366d46832eb35291475a2fb87ae1e8191", + "size": 439633, + "subdir": "linux-64", + "timestamp": 1674070777716, + "version": "5.2.10" + }, + "xz-5.2.3-h2bcbf08_1.conda": { + "build": "h2bcbf08_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1 and GPL-2.0", + "md5": "50d1144ae22dc7b988aa7acbb9a6e480", + "name": "xz", + "sha256": "da2b390c30acd6e7b267f3b170ce4e516fbaaa92269051a1467c9d4665a3e4d9", + "size": 282074, + "subdir": "linux-64", + "timestamp": 1505665902645, + "version": "5.2.3" + }, + "xz-5.2.3-h55aa19d_2.conda": { + "build": "h55aa19d_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1 and GPL-2.0", + "md5": "bc88e7771860d20791107e7de3394cd0", + "name": "xz", + "sha256": "63159115ea67f2403104bf642a8292596d97e4d3d56f36135c8a00aeb27be1d5", + "size": 280569, + "subdir": "linux-64", + "timestamp": 1510092273095, + "version": "5.2.3" + }, + "xz-5.2.3-h5e939de_4.conda": { + "build": "h5e939de_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1 and GPL-2.0", + "md5": "88259b29242c12fedb0f9c521f703919", + "name": "xz", + "sha256": "6767122f77b5f31cd87f1f2a3f0e1e81fbe35649f0f682ed99a699e11b5d4fa2", + "size": 287809, + "subdir": "linux-64", + "timestamp": 1524586578890, + "version": "5.2.3" + }, + "xz-5.2.4-h14c3975_4.conda": { + "build": "h14c3975_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "LGPL-2.1 and GPL-2.0", + "md5": "46342a26c3841094f0e60612128eb734", + "name": "xz", + "sha256": "c057d600f56d9448644eeeba8c96832befe8fd96fc7dbc7507eabf7c16ba5b8c", + "size": 290008, + "subdir": "linux-64", + "timestamp": 1526499283093, + "version": "5.2.4" + }, + "xz-5.2.5-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "LGPL-2.1 and GPL-2.0", + "md5": "73a16ea8ba890175a1ce94a3a87c8f68", + "name": "xz", + "sha256": "58045af0e1f23ea72b6759c4f5aac3e2fb98da9585758853d09961126d66f9ce", + "size": 349481, + "subdir": "linux-64", + "timestamp": 1587011767250, + "version": "5.2.5" + }, + "xz-5.2.5-h7f8727e_1.conda": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "LGPL-2.1-or-later and GPL-2.0-or-later", + "license_family": "GPL2", + "md5": "5d01fcf310bf465237f6b95a019d73bc", + "name": "xz", + "sha256": "3aebdee7910426ecbecd5e67c3759dfb68d21c9d24c0f093ccbdda42cc23b23c", + "size": 347607, + "subdir": "linux-64", + "timestamp": 1651602137803, + "version": "5.2.5" + }, + "xz-5.2.6-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "LGPL-2.1-or-later and GPL-2.0-or-later", + "license_family": "GPL2", + "md5": "8abc704d4a473839d5351b43deb793bb", + "name": "xz", + "sha256": "78a43e85689ee3584018ad516b30077c9507997c50238850ec461b07bb408e21", + "size": 403894, + "subdir": "linux-64", + "timestamp": 1664287115388, + "version": "5.2.6" + }, + "xz-5.2.8-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "LGPL-2.1-or-later and GPL-2.0-or-later", + "license_family": "GPL2", + "md5": "224260858072f0071140ae18c513620d", + "name": "xz", + "sha256": "4d1c4edfba1b5d1ec97a59fe8fadc7cf5326ecdb7411937939330f0bfae4f4e7", + "size": 439520, + "subdir": "linux-64", + "timestamp": 1669941680582, + "version": "5.2.8" + }, + "yajl-2.1.0-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "ISC", + "md5": "497d135d330e3fb05ae3af7406461299", + "name": "yajl", + "sha256": "18f10a80fca645b45605094b1c81c5434ad74e91d3a87b8c14cdfebd216fe2f3", + "size": 50110, + "subdir": "linux-64", + "timestamp": 1592214357612, + "version": "2.1.0" + }, + "yajl-2.1.0-h7f8727e_1.conda": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "ISC", + "license_family": "OTHER", + "md5": "8c627c3f467a9409e7a6abf4dedd19d5", + "name": "yajl", + "sha256": "c311c1e55eed7f37d6903edef522b8d3e1b8256ada1ace81e4fd7433f642109d", + "size": 47844, + "subdir": "linux-64", + "timestamp": 1655211952921, + "version": "2.1.0" + }, + "yaml-0.1.7-h014fa73_1.conda": { + "build": "h014fa73_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "a1873342d8da40bdbec7a2b93d97fbf0", + "name": "yaml", + "sha256": "93839970a610527877fa988f5f9d051cdeb82e63860fe336723344115e6948ef", + "size": 74564, + "subdir": "linux-64", + "timestamp": 1510092261586, + "version": "0.1.7" + }, + "yaml-0.1.7-h014fa73_2.conda": { + "build": "h014fa73_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "65bb1465afcaee535e204ceb499edefe", + "name": "yaml", + "sha256": "858a167289ad4d3c6c0ab414346bc0cebdf681874fafb25d299a6fbeef93eeec", + "size": 74537, + "subdir": "linux-64", + "timestamp": 1510100858096, + "version": "0.1.7" + }, + "yaml-0.1.7-h96e3832_1.conda": { + "build": "h96e3832_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "e26dfe29003c9d3dac65e23436724d55", + "name": "yaml", + "sha256": "d39ce75f2bcea3ea966a0627f8f6ec2f68925262809eb740bd268c1950cb7608", + "size": 73951, + "subdir": "linux-64", + "timestamp": 1505957511206, + "version": "0.1.7" + }, + "yaml-0.1.7-had09818_2.conda": { + "build": "had09818_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "MIT", + "md5": "e5f9ce5f2d1a8d17a4fade8a546b43aa", + "name": "yaml", + "sha256": "3453139916ec0615675af07abd704883f28b97a9a84539d72bcc28d5aa5779e2", + "size": 74652, + "subdir": "linux-64", + "timestamp": 1510609996778, + "version": "0.1.7" + }, + "yaml-0.2.5-h7b6447c_0.conda": { + "build": "h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "MIT", + "md5": "39fdbf4db769e494ffb06d95680c83d8", + "name": "yaml", + "sha256": "e22753e19432d606139f7a604757839d265dff93345226ba0732676526870e28", + "size": 76992, + "subdir": "linux-64", + "timestamp": 1593116114710, + "version": "0.2.5" + }, + "yaml-cpp-0.7.0-h295c915_1.conda": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f1042fb51b18c40afb3a13e605e82f27", + "name": "yaml-cpp", + "sha256": "212d97295789451c9de504bf1331ebf5450b5891c33b4f6849b85bae24cfd924", + "size": 556088, + "subdir": "linux-64", + "timestamp": 1646734742292, + "version": "0.7.0" + }, + "yaml-cpp-static-0.7.0-h295c915_1.conda": { + "build": "h295c915_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "yaml-cpp 0.7.0 h295c915_1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4ca98227c4fd6b1fc26988e523d498c", + "name": "yaml-cpp-static", + "sha256": "d5cb3972c7e38e73e81535b5f973830dbf7a8df2e52db4501a947406c66aa3c5", + "size": 223085, + "subdir": "linux-64", + "timestamp": 1646734760243, + "version": "0.7.0" + }, + "yapf-0.22.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "691fa2e866e5db181dc2610cb8d60ab0", + "name": "yapf", + "sha256": "693401e21d84152fe442cbf2409d03dfdc9248f604a31467fd4c19ac63be8707", + "size": 188054, + "subdir": "linux-64", + "timestamp": 1536861270717, + "version": "0.22.0" + }, + "yapf-0.22.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "md5": "dac3bc12cb94c3bd3386df87f1f64c05", + "name": "yapf", + "sha256": "0c176af2dd72ed252e8020a6177c191ae09cc88d2a089c0e8e7ec794d0ced481", + "size": 195468, + "subdir": "linux-64", + "timestamp": 1536861346725, + "version": "0.22.0" + }, + "yapf-0.22.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "1732187c39f5aa9c394cb887caed6c09", + "name": "yapf", + "sha256": "5b457c5108862dbababd250fd5e4ee70bdf65dac2ae6bc4056c5aa98db69d426", + "size": 193281, + "subdir": "linux-64", + "timestamp": 1536861392328, + "version": "0.22.0" + }, + "yapf-0.22.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "6bff71f4fd10c945291c94638fedc1b7", + "name": "yapf", + "sha256": "748fb1a8d7e0f58858e0cf1f404748993e821c046d98d5fdb978fb9a6cc3a946", + "size": 189960, + "subdir": "linux-64", + "timestamp": 1536861161534, + "version": "0.22.0" + }, + "yapf-0.24.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "49c718d5ab7275e151949f9d6b399843", + "name": "yapf", + "sha256": "02294c825164668c7c66aeb67f8ca40ae47fac7d739dfe705be6027e3e84717f", + "size": 191093, + "subdir": "linux-64", + "timestamp": 1538359864945, + "version": "0.24.0" + }, + "yapf-0.24.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "ade060267ca8e8c4345be91d9e04346b", + "name": "yapf", + "sha256": "38c46e255d75e509a655e34fcfcf56cfbe1e3ce29b26c3e6460ec99e3f76d2b7", + "size": 192041, + "subdir": "linux-64", + "timestamp": 1538359871775, + "version": "0.24.0" + }, + "yapf-0.24.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "299ac9eb29870706a4c60af3752da314", + "name": "yapf", + "sha256": "27b3e77f8da5d33a0ce0d5656aee86e9722ba6a9d6b75b6ed5ab1f99985a3b92", + "size": 196159, + "subdir": "linux-64", + "timestamp": 1538359815231, + "version": "0.24.0" + }, + "yapf-0.25.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "52fcfbcd10ae18908853e53b7b8044bc", + "name": "yapf", + "sha256": "1ba832e2e56023ab585bb5c04ef29b41da0e29cd6fd78ec6d65b3eb00a2345d7", + "size": 201664, + "subdir": "linux-64", + "timestamp": 1543620150067, + "version": "0.25.0" + }, + "yapf-0.25.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "e2cf8654413d70ee5b2211ff1048245f", + "name": "yapf", + "sha256": "6e24fc61536c3ea08eb7f94d32bb172d58a53039b9199711fff5977a415fd4ac", + "size": 203954, + "subdir": "linux-64", + "timestamp": 1543620171741, + "version": "0.25.0" + }, + "yapf-0.25.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "e64fee6786747301922d121a85a55b18", + "name": "yapf", + "sha256": "5c96bdf6c0d6376cbae9e7154afd3ca5cfda3d946d180923c714f6191b6a6efc", + "size": 204408, + "subdir": "linux-64", + "timestamp": 1543620129645, + "version": "0.25.0" + }, + "yapf-0.26.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "Apache 2.0", + "md5": "906da8b6f44f08580614622f92898f8a", + "name": "yapf", + "sha256": "0d95d71b9f4ea757a006f41206ace4c491bf17f27f364a14203a91b83007f575", + "size": 206620, + "subdir": "linux-64", + "timestamp": 1550637448386, + "version": "0.26.0" + }, + "yapf-0.26.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "md5": "d18ff8c3f0456e7403ce30134cc14376", + "name": "yapf", + "sha256": "abe9e020c0de9dcc2ccece0d043a31253e23a9845c3c9b042c4282d5ac5fe362", + "size": 212527, + "subdir": "linux-64", + "timestamp": 1550637464876, + "version": "0.26.0" + }, + "yapf-0.26.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "md5": "43692d17b0ec60be1bcf4fe565b600aa", + "name": "yapf", + "sha256": "bc75a13930bccce52c41ae53f6f3acdd6971969d63e29fa35f4aa4b2361c9b0b", + "size": 212452, + "subdir": "linux-64", + "timestamp": 1550637435383, + "version": "0.26.0" + }, + "yarl-0.13.0-py35hcc48116_0.conda": { + "build": "py35hcc48116_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "multidict >=2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "18212105ff84bc305879595120ba2924", + "name": "yarl", + "sha256": "33173aef710ed5ce515dd389856d0caef649d42a8e3a8f96c55b091a2e9e4ced", + "size": 99849, + "subdir": "linux-64", + "timestamp": 1507976467538, + "version": "0.13.0" + }, + "yarl-0.13.0-py36h21e4b6b_0.conda": { + "build": "py36h21e4b6b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "multidict >=2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b75cd77e70ebd5ff3557c12990d81a7c", + "name": "yarl", + "sha256": "26a81e050811d46ba7bd29df5374b5b3815ddfe08b48c1c7ee9567a1fcb9074a", + "size": 99387, + "subdir": "linux-64", + "timestamp": 1507976468446, + "version": "0.13.0" + }, + "yarl-0.14.2-py35h31c3c03_0.conda": { + "build": "py35h31c3c03_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "multidict >=2.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2dc7b7c4797e704b869bde999992bc10", + "name": "yarl", + "sha256": "88de0f53baf664f586165293f694c7c7f267da1d61d5b3264a2abebc4aac56fd", + "size": 98165, + "subdir": "linux-64", + "timestamp": 1511315082093, + "version": "0.14.2" + }, + "yarl-0.14.2-py36hcd1f455_0.conda": { + "build": "py36hcd1f455_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "multidict >=2.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ec7f31277b0f59a9748c9d978bc05477", + "name": "yarl", + "sha256": "645b64df0bcfb9d2a7bdb78d85b6d42501df10415b9850651b6bf3db2f855d16", + "size": 97134, + "subdir": "linux-64", + "timestamp": 1511315082175, + "version": "0.14.2" + }, + "yarl-1.1.1-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "10df9f022ca16c65588f2d930f246c9a", + "name": "yarl", + "sha256": "8dffd638fc13027e951a4cf88236b1392e90bc422945ef25640e09cae97580cd", + "size": 125294, + "subdir": "linux-64", + "timestamp": 1519072003590, + "version": "1.1.1" + }, + "yarl-1.1.1-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "aaa5c19c24f921df6b7aa29dacc6fef2", + "name": "yarl", + "sha256": "c5cbd27d3c01b069d45e489675af4a1d073ea24f4d2aeb4b5623a3b361ead4f0", + "size": 125915, + "subdir": "linux-64", + "timestamp": 1519072008174, + "version": "1.1.1" + }, + "yarl-1.2.4-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "b01cfff7de2c19b2cd87a61d6dc6d1de", + "name": "yarl", + "sha256": "9aa8576ee628026f035d4ed856289e3594d807aa7bd3bfd07d537d3c559d7f11", + "size": 131317, + "subdir": "linux-64", + "timestamp": 1526411511866, + "version": "1.2.4" + }, + "yarl-1.2.4-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "933cbe17c6896ebc07fe293e4aa44e7b", + "name": "yarl", + "sha256": "2b7b3006ddcfd2326d9607cfa5a3ce352fe25a0aebb21619ff552715631160d9", + "size": 131877, + "subdir": "linux-64", + "timestamp": 1526411402889, + "version": "1.2.4" + }, + "yarl-1.2.5-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "86fd9a22b5e0c7dc828b7a5f5908fc04", + "name": "yarl", + "sha256": "0caf915299e8411f642e12d14e7e83efa661a4a17b03d206fb8de435aef40cea", + "size": 131728, + "subdir": "linux-64", + "timestamp": 1528984907876, + "version": "1.2.5" + }, + "yarl-1.2.5-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "be609fe29794073c0f0d954ee4fedf72", + "name": "yarl", + "sha256": "743ff359340a54622a76fbc5dece348ff66184817824a2b7dc62b09f26a97a42", + "size": 132087, + "subdir": "linux-64", + "timestamp": 1528985152578, + "version": "1.2.5" + }, + "yarl-1.2.6-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0", + "python >=3.5,<3.6.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "a64b44c3bfeef5c6d71a440af5234e14", + "name": "yarl", + "sha256": "07225f6cb7ac88b69952a20a91aac8cedf65cda131fa73f19bc9bd208a2f0ec3", + "size": 131822, + "subdir": "linux-64", + "timestamp": 1529418946794, + "version": "1.2.6" + }, + "yarl-1.2.6-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "dd686445e3221ecc68729556e505651b", + "name": "yarl", + "sha256": "2c7e5b48dbf9dd54b7287ea87cceed5af316338a109dabdd73aa081c75b557b6", + "size": 132037, + "subdir": "linux-64", + "timestamp": 1529418877397, + "version": "1.2.6" + }, + "yarl-1.2.6-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.2.0", + "multidict >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "da1ed1783fad0585a070c8e3ce39d90d", + "name": "yarl", + "sha256": "93856b7885a7b25c8494687c3a90771f3bc73bdee79f40732ab49a86075c5c49", + "size": 131646, + "subdir": "linux-64", + "timestamp": 1530736532473, + "version": "1.2.6" + }, + "yarl-1.3.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1fea96b77e3295a292900b015c1c7103", + "name": "yarl", + "sha256": "4b0c81465b0bc3b0438ff6ea1838af018acea15235540d9f36aee11485ba57a4", + "size": 133968, + "subdir": "linux-64", + "timestamp": 1545110350214, + "version": "1.3.0" + }, + "yarl-1.3.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "981cc4661d9573d5ab72200719c4ad02", + "name": "yarl", + "sha256": "58c45e9bcab823649b993fe22a3f9d443f5792f0fc89d4607e6906b6a24dd055", + "size": 134201, + "subdir": "linux-64", + "timestamp": 1545110320525, + "version": "1.3.0" + }, + "yarl-1.3.0-py38h7b6447c_1000.conda": { + "build": "py38h7b6447c_1000", + "build_number": 1000, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "504fe538f7a16c9fd2986df950b3fe26", + "name": "yarl", + "sha256": "172b6127744ba79b9b2883bf38acc4ccccf267e33d870ee8aadd731b67c43a69", + "size": 141795, + "subdir": "linux-64", + "timestamp": 1574437457721, + "version": "1.3.0" + }, + "yarl-1.4.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "04d427df217c92ba964864dbdbd051da", + "name": "yarl", + "sha256": "04e49f2d2acbefe8c77a806422454480255ee1b1fbdfdf91a36e8adeb7ee7a06", + "size": 135319, + "subdir": "linux-64", + "timestamp": 1576688264517, + "version": "1.4.2" + }, + "yarl-1.4.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "588f87ddf21e7fd155207aa16169723c", + "name": "yarl", + "sha256": "10a61a09fc3295fda29eaa4ae354e29532199c18ece165a956f027405349b5c9", + "size": 134904, + "subdir": "linux-64", + "timestamp": 1576688236914, + "version": "1.4.2" + }, + "yarl-1.4.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "22a7c07af9052a9e187813e8f7661043", + "name": "yarl", + "sha256": "7dddac74892b106501b2b2e228723e9ffbfe56ac8268eafdea3f89b03c3a5748", + "size": 145556, + "subdir": "linux-64", + "timestamp": 1576688261450, + "version": "1.4.2" + }, + "yarl-1.5.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2c82fb3cd161a2be63eef46a4b010c21", + "name": "yarl", + "sha256": "3e10b2034c7dda66e362c5f606bf1a0d97242cb68c327577ad86929aa391ee10", + "size": 138221, + "subdir": "linux-64", + "timestamp": 1598045064883, + "version": "1.5.1" + }, + "yarl-1.5.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "bde4ec3812a762a1d200ef84d3372d22", + "name": "yarl", + "sha256": "17006afc1b1139042f130da597f09d3b794ed1b387683c90e3d10fce8800f433", + "size": 138315, + "subdir": "linux-64", + "timestamp": 1598045089035, + "version": "1.5.1" + }, + "yarl-1.5.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "79d5b77f112ecea8dca23754fd98af1b", + "name": "yarl", + "sha256": "c3cbb1ab41a641f0df983d7e2688f808ae60599ce0dc9a8759867f84f218e41e", + "size": 142362, + "subdir": "linux-64", + "timestamp": 1598045064847, + "version": "1.5.1" + }, + "yarl-1.6.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f8d9901723332cacac05aa80e66bcd35", + "name": "yarl", + "sha256": "db7d3746c23ae743fe0fb74c66e4deb4311b38daca84bd622cc47b8e7842b5ee", + "size": 137715, + "subdir": "linux-64", + "timestamp": 1602006880959, + "version": "1.6.0" + }, + "yarl-1.6.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "0d7b965709202ae629d97ebea2030360", + "name": "yarl", + "sha256": "bea9d860a06c0c89e2a9ea2af4b8a0f20571426329b76431acdf6337770c6da2", + "size": 137574, + "subdir": "linux-64", + "timestamp": 1602006876060, + "version": "1.6.0" + }, + "yarl-1.6.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "4b5034fd98e9c41d0c18bb34f10e3c70", + "name": "yarl", + "sha256": "9f8f41d6b389c4b8a03f01fb96c0f562bafdeb17041211328f6779d4f845db60", + "size": 140648, + "subdir": "linux-64", + "timestamp": 1602006870803, + "version": "1.6.0" + }, + "yarl-1.6.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "fb46d24de821d58fd5ecbd39401bd0c4", + "name": "yarl", + "sha256": "8a71891495af3befac47c5a907309697c40f13b8858fea2c1b7b018980daccd3", + "size": 136672, + "subdir": "linux-64", + "timestamp": 1602693086124, + "version": "1.6.2" + }, + "yarl-1.6.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "f119f803f6f33c2b7c1a763a6066f083", + "name": "yarl", + "sha256": "02cfc6514f430fec8081c0607a67f0970510161233084e7b0b5990095cbbd7cb", + "size": 137303, + "subdir": "linux-64", + "timestamp": 1602693088465, + "version": "1.6.2" + }, + "yarl-1.6.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "6ae36460b479670c1c108187fa7716e0", + "name": "yarl", + "sha256": "abd63d238607720113957d49fc84b0a66d3a23696e65e7761d0d5d9d85290f52", + "size": 139431, + "subdir": "linux-64", + "timestamp": 1602693046471, + "version": "1.6.2" + }, + "yarl-1.6.3-py310h7f8727e_1.conda": { + "build": "py310h7f8727e_1", + "build_number": 1, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.5.0", + "multidict >=4.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "8ddb6e08b919275a715ab06f88c59b77", + "name": "yarl", + "sha256": "997bc0eefff28b981466e51234bd707265a081afc42df20772fffb71b6f14246", + "size": 250272, + "subdir": "linux-64", + "timestamp": 1640811427258, + "version": "1.6.3" + }, + "yarl-1.6.3-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.6,<3.7.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "1571e15f6403dedc783d13b2ef1e3215", + "name": "yarl", + "sha256": "ccd732ee2e5e4af9cb73d812147131c9c18b67442d496432a55b37c63421212b", + "size": 136407, + "subdir": "linux-64", + "timestamp": 1606939955082, + "version": "1.6.3" + }, + "yarl-1.6.3-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.7,<3.8.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ce71464eb1a73269f82a8dbed87062b5", + "name": "yarl", + "sha256": "a3840d15ab145a001e60e72e29f20cf7008634e220732b61afd8cb91660e8be6", + "size": 135725, + "subdir": "linux-64", + "timestamp": 1606939999443, + "version": "1.6.3" + }, + "yarl-1.6.3-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "d75a5a7085cbfcfaac45a3514fd81504", + "name": "yarl", + "sha256": "e27a2ce811e0b7da5fba83e14704765956c2de1d53707f110e37916e69a491ba", + "size": 139478, + "subdir": "linux-64", + "timestamp": 1606939964659, + "version": "1.6.3" + }, + "yarl-1.6.3-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=7.3.0", + "multidict >=4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "2e8bff0779678fcc6e56b87906fe821d", + "name": "yarl", + "sha256": "053bb02531ef16ab3c928fac9ee8161ec4b20ec7c9134f6b0396f10b4d8c484f", + "size": 139292, + "subdir": "linux-64", + "timestamp": 1606939987117, + "version": "1.6.3" + }, + "yarl-1.8.1-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=11.2.0", + "multidict >=4.0", + "python >=3.10,<3.11.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e20346f01a20d3354f6f87299df61990", + "name": "yarl", + "sha256": "8651d80743853e3d6f83eb664f06dcd9058d303da90d5dabf3d6d9b1863a3b2f", + "size": 217257, + "subdir": "linux-64", + "timestamp": 1661437155383, + "version": "1.8.1" + }, + "yarl-1.8.1-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=11.2.0", + "multidict >=4.0", + "python >=3.11,<3.12.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "1909287a5afa2dd870e72bdcf0deb630", + "name": "yarl", + "sha256": "3ce531340dee42149344925dc5b86082c02069912e30a37ca507808ecba04d76", + "size": 95840, + "subdir": "linux-64", + "timestamp": 1676827620821, + "version": "1.8.1" + }, + "yarl-1.8.1-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=11.2.0", + "multidict >=4.0", + "python >=3.7,<3.8.0a0", + "typing-extensions >=3.7.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "6073440623f8632df83bf9798215533d", + "name": "yarl", + "sha256": "6099ef20bda2758da778d64267ab82d682ab2e4b849c9b25649f3febc1ac2ae1", + "size": 87849, + "subdir": "linux-64", + "timestamp": 1661437223046, + "version": "1.8.1" + }, + "yarl-1.8.1-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=11.2.0", + "multidict >=4.0", + "python >=3.8,<3.9.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "d22106c1aa02978856601543103518e8", + "name": "yarl", + "sha256": "cb10232e8275a2eeebaced0da37e9602aca707a1f020b676213f2c5eadd5e9ea", + "size": 89121, + "subdir": "linux-64", + "timestamp": 1661437189051, + "version": "1.8.1" + }, + "yarl-1.8.1-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "idna >=2.0", + "libgcc-ng >=11.2.0", + "multidict >=4.0", + "python >=3.9,<3.10.0a0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f1d404bb6092d44910f2e45286de9522", + "name": "yarl", + "sha256": "78dca85db8fff9e06ffa05867038541809025c8ca27000d9ba481065a029bc42", + "size": 88601, + "subdir": "linux-64", + "timestamp": 1661437260076, + "version": "1.8.1" + }, + "yarn-1.22.19-h06a4308_0.conda": { + "build": "h06a4308_0", + "build_number": 0, + "depends": [ + "nodejs" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "433e35923c0d21ff0fea49009dc71d1e", + "name": "yarn", + "sha256": "17864c392eb8270ca5922ca8ee4e6c0eaf1987a28203965ad1d5bb5ba9ab3fdc", + "size": 976243, + "subdir": "linux-64", + "timestamp": 1659703793841, + "version": "1.22.19" + }, + "yasm-1.3.0-h99c0ef8_2.conda": { + "build": "h99c0ef8_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "BSD 3-Clause", + "md5": "c6555fd9384c0f3290eaf947bd05fdc4", + "name": "yasm", + "sha256": "0b1f4c6d0b32dae02068902e85df3ba9c47d5565b34dce7351a5538667eb27b8", + "size": 729607, + "subdir": "linux-64", + "timestamp": 1510100508620, + "version": "1.3.0" + }, + "ydata-profiling-4.1.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-core >=4.6.3", + "ipywidgets >=7.5.1", + "jupyter-client >=5.3.4", + "tangled-up-in-unicode 0.2.0" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash 4.3.1", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.7", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.10,<3.11.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "typeguard >=2.13.2,<2.14", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb09494559297bb93ec0914b507a2314", + "name": "ydata-profiling", + "sha256": "fa74dffdc89205e6c8f7ab4cd2fbd2c5a6592d4972e98a23647d0c5f63484eaa", + "size": 324731, + "subdir": "linux-64", + "timestamp": 1680556017461, + "version": "4.1.1" + }, + "ydata-profiling-4.1.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-core >=4.6.3", + "ipywidgets >=7.5.1", + "jupyter-client >=5.3.4", + "tangled-up-in-unicode 0.2.0" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash 4.3.1", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.7", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.11,<3.12.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "typeguard >=2.13.2,<2.14", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6bfe267aea1198ea7c45eeb30b460662", + "name": "ydata-profiling", + "sha256": "d325ac22774f4f8b4fd2f63e84c2211b6012528adbab4ac28287533aaef87f0f", + "size": 398862, + "subdir": "linux-64", + "timestamp": 1680555911736, + "version": "4.1.1" + }, + "ydata-profiling-4.1.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-core >=4.6.3", + "ipywidgets >=7.5.1", + "jupyter-client >=5.3.4", + "tangled-up-in-unicode 0.2.0" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash 4.3.1", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.7", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.8,<3.9.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "typeguard >=2.13.2,<2.14", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7af84e04a7fe03b4f5f7e49cd8453100", + "name": "ydata-profiling", + "sha256": "511de08c26ce260ae1fce6eb664feec67951ab6f34b13c7613741f5871243228", + "size": 322132, + "subdir": "linux-64", + "timestamp": 1680555853078, + "version": "4.1.1" + }, + "ydata-profiling-4.1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "constrains": [ + "jupyter-core >=4.6.3", + "ipywidgets >=7.5.1", + "jupyter-client >=5.3.4", + "tangled-up-in-unicode 0.2.0" + ], + "depends": [ + "htmlmin 0.1.12", + "imagehash 4.3.1", + "jinja2 >=2.11.1,<3.2", + "matplotlib-base >=3.2,<3.7", + "multimethod >=1.4,<1.10", + "numpy >=1.16.0,<1.24", + "pandas >1.1,<1.6,!=1.4.0", + "phik >=0.11.1,<0.13", + "pillow", + "pydantic >=1.8.1,<1.11", + "python >=3.9,<3.10.0a0", + "pyyaml >=5.0.0,<6.1", + "requests >=2.24.0,<2.29", + "scipy >=1.4.1,<1.10", + "seaborn >=0.10.1,<0.13", + "statsmodels >=0.13.2,<0.14", + "tqdm >=4.48.2,<4.65", + "typeguard >=2.13.2,<2.14", + "visions 0.7.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "09a7c8196c8523c608f8d486efb2f568", + "name": "ydata-profiling", + "sha256": "49b4dcb37ac4cffadcab4f7641e06899f542aa3ad7001ccc40175c8fe4d91107", + "size": 322398, + "subdir": "linux-64", + "timestamp": 1680555963573, + "version": "4.1.1" + }, + "yt-3.4.1-py27h14c3975_1.conda": { + "build": "py27h14c3975_1", + "build_number": 1, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "sympy" + ], + "license": "BSD 3-clause", + "md5": "4a2644d8dc65140ce7f0db60c9e93265", + "name": "yt", + "sha256": "cc5ed6a0c862b7d32a2cbebe811cdc0b3af8efcb10c361fdf5119b1379ae170b", + "size": 5554970, + "subdir": "linux-64", + "timestamp": 1531066651889, + "version": "3.4.1" + }, + "yt-3.4.1-py27h3010b51_0.conda": { + "build": "py27h3010b51_0", + "build_number": 0, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=2.7,<2.8.0a0", + "setuptools", + "sympy" + ], + "license": "BSD 3-clause", + "md5": "2925546fa5d4b7066397ad70abef25f9", + "name": "yt", + "sha256": "066e3c76947c0469512f7d2fd8661dfee4fb34af332ced9855c51caea756d1a3", + "size": 5579042, + "subdir": "linux-64", + "timestamp": 1520476503443, + "version": "3.4.1" + }, + "yt-3.4.1-py35h3010b51_0.conda": { + "build": "py35h3010b51_0", + "build_number": 0, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.5,<3.6.0a0", + "setuptools", + "sympy" + ], + "license": "BSD 3-clause", + "md5": "eb6a7554791e9970473b57dc36ae79c5", + "name": "yt", + "sha256": "2e83f7c65e7bacf4e41a6f1ba8b4eaabed70247d96a09eaaf44dddaffd5b53fb", + "size": 5452384, + "subdir": "linux-64", + "timestamp": 1520476524164, + "version": "3.4.1" + }, + "yt-3.4.1-py36h14c3975_1.conda": { + "build": "py36h14c3975_1", + "build_number": 1, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "sympy" + ], + "license": "BSD 3-clause", + "md5": "06ab6222b4aa275aae59a1cebd9a67c2", + "name": "yt", + "sha256": "84c5d7b5dadca9d9f765597842687b5d31ebc468bd27399b54e92ccd4c3e8626", + "size": 5493597, + "subdir": "linux-64", + "timestamp": 1531065770272, + "version": "3.4.1" + }, + "yt-3.4.1-py36h3010b51_0.conda": { + "build": "py36h3010b51_0", + "build_number": 0, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "sympy" + ], + "license": "BSD 3-clause", + "md5": "3982adb0d7a8f9508ab5c4ddc2c1f184", + "name": "yt", + "sha256": "d33156d4132aa19c0ee94f6475555a556ad808715e5fc89c1285aeda6a73bfdb", + "size": 5482843, + "subdir": "linux-64", + "timestamp": 1520476514311, + "version": "3.4.1" + }, + "yt-3.4.1-py36h33eb3a4_2.conda": { + "build": "py36h33eb3a4_2", + "build_number": 2, + "depends": [ + "h5py", + "hdf5 >=1.10.4,<1.10.5.0a0", + "ipython", + "libgcc-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.6,<3.7.0a0", + "setuptools", + "sympy" + ], + "license": "BSD 3-clause", + "md5": "7b9c93e5173d62528f9100eda6e6cd27", + "name": "yt", + "sha256": "37d3f1a536e751dfba22519b6d2da913380695d5790e767f537948a3040aebab", + "size": 5168643, + "subdir": "linux-64", + "timestamp": 1592482292447, + "version": "3.4.1" + }, + "yt-3.4.1-py37h14c3975_1.conda": { + "build": "py37h14c3975_1", + "build_number": 1, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.2.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "sympy" + ], + "license": "BSD 3-clause", + "md5": "c8de9fc9313ed9f53b0cdd7cf9d123e5", + "name": "yt", + "sha256": "bceb71f29b84855bd399e71a12ad2d85b4ff0b8bfc0adabc914de79cb228a253", + "size": 5471279, + "subdir": "linux-64", + "timestamp": 1531066206059, + "version": "3.4.1" + }, + "yt-3.4.1-py37h33eb3a4_2.conda": { + "build": "py37h33eb3a4_2", + "build_number": 2, + "depends": [ + "h5py", + "hdf5 >=1.10.4,<1.10.5.0a0", + "ipython", + "libgcc-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.7,<3.8.0a0", + "setuptools", + "sympy" + ], + "license": "BSD 3-clause", + "md5": "892fc1e7934a816a222f5aff9197b0d8", + "name": "yt", + "sha256": "14f246f004111ddb4f1d6f8184404034134c3d0ba33728e6e9480aee53e89a07", + "size": 5106296, + "subdir": "linux-64", + "timestamp": 1592482260742, + "version": "3.4.1" + }, + "yt-3.4.1-py38h33eb3a4_2.conda": { + "build": "py38h33eb3a4_2", + "build_number": 2, + "depends": [ + "h5py", + "hdf5 >=1.10.4,<1.10.5.0a0", + "ipython", + "libgcc-ng >=7.3.0", + "matplotlib", + "numpy >=1.11.3,<2.0a0", + "python >=3.8,<3.9.0a0", + "setuptools", + "sympy" + ], + "license": "BSD 3-clause", + "md5": "5fe53753508f63209b2223105a0687a7", + "name": "yt", + "sha256": "91056519de33feb2b1f4ae94bab0169622e68fe67830ded66b35f5143240fe4d", + "size": 5239628, + "subdir": "linux-64", + "timestamp": 1592482233464, + "version": "3.4.1" + }, + "yt-3.6.1-py310h9102076_0.conda": { + "build": "py310h9102076_0", + "build_number": 0, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.5.0", + "matplotlib", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "sympy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "04e9657b38095786e43ecafb296ad303", + "name": "yt", + "sha256": "f98eb311f043105ea2ace1b8de8507d9b1ad159722ae46fd4966cce064526b64", + "size": 12627954, + "subdir": "linux-64", + "timestamp": 1640814702512, + "version": "3.6.1" + }, + "yt-3.6.1-py36h6323ea4_0.conda": { + "build": "py36h6323ea4_0", + "build_number": 0, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.3.0", + "matplotlib", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "sympy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4f23c08254f15fae455c7016f58fabb3", + "name": "yt", + "sha256": "4ecd3febe26b7ec8e5096a096c8de77ba986f822cb62c8e8f006ce50426daab1", + "size": 5279222, + "subdir": "linux-64", + "timestamp": 1613477228670, + "version": "3.6.1" + }, + "yt-3.6.1-py37h6323ea4_0.conda": { + "build": "py37h6323ea4_0", + "build_number": 0, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.3.0", + "matplotlib", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "sympy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "bc0e4f9aa7ffe51e7cc19f2a68841e40", + "name": "yt", + "sha256": "8b7f07930c916afe84073dc8c7404c620917588be815d20bef45c4ae9265ba8c", + "size": 5274772, + "subdir": "linux-64", + "timestamp": 1613477841936, + "version": "3.6.1" + }, + "yt-3.6.1-py38h6323ea4_0.conda": { + "build": "py38h6323ea4_0", + "build_number": 0, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.3.0", + "matplotlib", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "sympy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a4d696833b9eedbdcad252c8c6cec51e", + "name": "yt", + "sha256": "819cee0b1783a5b032ce99d723ea5f1537a25cc6795be30db95bb73794319130", + "size": 5385726, + "subdir": "linux-64", + "timestamp": 1613477828571, + "version": "3.6.1" + }, + "yt-3.6.1-py39h6323ea4_0.conda": { + "build": "py39h6323ea4_0", + "build_number": 0, + "depends": [ + "h5py", + "ipython", + "libgcc-ng >=7.3.0", + "matplotlib", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "sympy" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "da479dfde09a103fa9b7007e990f0163", + "name": "yt", + "sha256": "cb002941701eba9e5ee681a81481ea46fb5fda46873b93aaf74376407552bb6a", + "size": 5395629, + "subdir": "linux-64", + "timestamp": 1613477277470, + "version": "3.6.1" + }, + "zarr-2.13.3-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "asciitree", + "fasteners", + "numcodecs >=0.10.0", + "numpy >=1.7", + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3c02f6aabb8528cfef0ab122789076bb", + "name": "zarr", + "sha256": "83b9fae843f9f89a829bb8d00d40f5094f3b566c893c37bf3dba932b9e8e7ad5", + "size": 350383, + "subdir": "linux-64", + "timestamp": 1669363788544, + "version": "2.13.3" + }, + "zarr-2.13.3-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "asciitree", + "fasteners", + "numcodecs >=0.10.0", + "numpy >=1.7", + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "25b61eb22a525b7ba384af2719304715", + "name": "zarr", + "sha256": "5b88b63d7723a5065c4e1b2508363ac4eda07aa35a36a06dbe88bfa79af2bc6c", + "size": 453911, + "subdir": "linux-64", + "timestamp": 1676846647140, + "version": "2.13.3" + }, + "zarr-2.13.3-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "asciitree", + "fasteners", + "numcodecs >=0.10.0", + "numpy >=1.7", + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "81c9f35cc44a6a20327c327f0eacbed6", + "name": "zarr", + "sha256": "17351a8705365a91d81c2cd8b95c02507f6437b5497d7ee154d9a06cc45197b0", + "size": 346556, + "subdir": "linux-64", + "timestamp": 1669363675171, + "version": "2.13.3" + }, + "zarr-2.13.3-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "asciitree", + "fasteners", + "numcodecs >=0.10.0", + "numpy >=1.7", + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d07c453f089fe70db32f59328274c2a", + "name": "zarr", + "sha256": "0dce9220f0b9cbe9d02d4c090276dd4f572ef03f662b105047e871654881ac42", + "size": 347047, + "subdir": "linux-64", + "timestamp": 1669363566548, + "version": "2.13.3" + }, + "zc.lockfile-1.3.0-py27h28b3542_0.conda": { + "build": "py27h28b3542_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "6c9dce2397b78ecb46767a1a114289c5", + "name": "zc.lockfile", + "sha256": "b782578e51bd7c5956eb75ed5c80502231aa345d1c8286efbd47a4e03503057e", + "size": 13951, + "subdir": "linux-64", + "timestamp": 1535301040544, + "version": "1.3.0" + }, + "zc.lockfile-1.3.0-py35h28b3542_0.conda": { + "build": "py35h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "setuptools" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "36dd087a300290a7d80a4688072a15ea", + "name": "zc.lockfile", + "sha256": "2733957aeacf0e2bcd39462d9db11a6ede76cf23bf6421b366c08b4b710efadb", + "size": 14062, + "subdir": "linux-64", + "timestamp": 1535301065091, + "version": "1.3.0" + }, + "zc.lockfile-1.3.0-py36h28b3542_0.conda": { + "build": "py36h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "527d9a898e24e7ea34265164f912f7ed", + "name": "zc.lockfile", + "sha256": "83e82ab717113366ecb318dfdc9584485f24daa92bdf25bd667493de86069199", + "size": 14123, + "subdir": "linux-64", + "timestamp": 1535301035794, + "version": "1.3.0" + }, + "zc.lockfile-1.3.0-py37h28b3542_0.conda": { + "build": "py37h28b3542_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "a2beed0eedffc93dfc452aaf3f409544", + "name": "zc.lockfile", + "sha256": "5fc62db3b83558caee805c5171cdaf9f529dd8a52140cb82611860b568c24af5", + "size": 14002, + "subdir": "linux-64", + "timestamp": 1535301054413, + "version": "1.3.0" + }, + "zeep-4.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "cached-property >=1.3.0", + "isodate >=0.5.4", + "lxml >=4.6.0", + "platformdirs >=1.4.0", + "python >=3.10,<3.11.0a0", + "pytz", + "requests >=2.7.0", + "requests-file >=1.5.1", + "requests-toolbelt >=0.7.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f644cb6ff82182290bc7a05ae968d96a", + "name": "zeep", + "sha256": "b41a39526dfdf12412a33be832d5d1bab8860966079c09bc07b3e27cb8a0a43b", + "size": 158348, + "subdir": "linux-64", + "timestamp": 1665167985990, + "version": "4.1.0" + }, + "zeep-4.1.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "cached-property >=1.3.0", + "isodate >=0.5.4", + "lxml >=4.6.0", + "platformdirs >=1.4.0", + "python >=3.11,<3.12.0a0", + "pytz", + "requests >=2.7.0", + "requests-file >=1.5.1", + "requests-toolbelt >=0.7.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "15b3f236c95bf7607f7ce2f1500ae68b", + "name": "zeep", + "sha256": "6fe7439d3d269b79d685ca1b6a2bbb6d00384f74b42de438104dfd2a502b5ebf", + "size": 210167, + "subdir": "linux-64", + "timestamp": 1676863767302, + "version": "4.1.0" + }, + "zeep-4.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "cached-property >=1.3.0", + "isodate >=0.5.4", + "lxml >=4.6.0", + "platformdirs >=1.4.0", + "python >=3.7,<3.8.0a0", + "pytz", + "requests >=2.7.0", + "requests-file >=1.5.1", + "requests-toolbelt >=0.7.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "158b462b8fea7b328a7b82a91c29f894", + "name": "zeep", + "sha256": "e66437710407c6153f203433555c4406def4f2700e630b7a8cdb4aa10fc22e05", + "size": 156105, + "subdir": "linux-64", + "timestamp": 1665167915796, + "version": "4.1.0" + }, + "zeep-4.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "cached-property >=1.3.0", + "isodate >=0.5.4", + "lxml >=4.6.0", + "platformdirs >=1.4.0", + "python >=3.8,<3.9.0a0", + "pytz", + "requests >=2.7.0", + "requests-file >=1.5.1", + "requests-toolbelt >=0.7.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "956a8629ab5a1e7486f585b170312133", + "name": "zeep", + "sha256": "76b708a023bc14f7a1fb95ee4019a21f7b40197f210fd8ff493635d6fe3ed73c", + "size": 157008, + "subdir": "linux-64", + "timestamp": 1665167885503, + "version": "4.1.0" + }, + "zeep-4.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "attrs >=17.2.0", + "cached-property >=1.3.0", + "isodate >=0.5.4", + "lxml >=4.6.0", + "platformdirs >=1.4.0", + "python >=3.9,<3.10.0a0", + "pytz", + "requests >=2.7.0", + "requests-file >=1.5.1", + "requests-toolbelt >=0.7.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "096d4350378e8a81189eca5fd46da0df", + "name": "zeep", + "sha256": "4067ce918c741be367767df6535295694ed324a059e9c84b3160585565efd36d", + "size": 156705, + "subdir": "linux-64", + "timestamp": 1665167944236, + "version": "4.1.0" + }, + "zeromq-4.2.2-hb0b69da_1.conda": { + "build": "hb0b69da_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "7d379605a9a6b754f90f5e5f87c7cbe4", + "name": "zeromq", + "sha256": "26d90e24acb5db31175c16f6aec1f3eb4d08296ad43300414a95392af8eac2bf", + "size": 453126, + "subdir": "linux-64", + "timestamp": 1505688169910, + "version": "4.2.2" + }, + "zeromq-4.2.2-hbedb6e5_2.conda": { + "build": "hbedb6e5_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "34cf1f476ddbbb34150fbff80c178f86", + "name": "zeromq", + "sha256": "496f66964f11f3afad69c4e0f736c77384fa4954834ff695388d93ef73055d48", + "size": 463377, + "subdir": "linux-64", + "timestamp": 1510168774315, + "version": "4.2.2" + }, + "zeromq-4.2.3-h439df22_3.conda": { + "build": "h439df22_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "40b4f65adad460ecb0f9dcddec27bf7f", + "name": "zeromq", + "sha256": "3e04870bbf2d4f5fea43b5685b48bf452dcc8cceebac7e5ca01ed904d512861b", + "size": 439383, + "subdir": "linux-64", + "timestamp": 1520462522912, + "version": "4.2.3" + }, + "zeromq-4.2.3-hf484d3e_2.conda": { + "build": "hf484d3e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "f7dca515d75a814e3ecc60b234a59644", + "name": "zeromq", + "sha256": "01636debcf9a04fdd4d8044e9da095d9cffaee3a1c4c7b4c5ada50684f8a5ba7", + "size": 450969, + "subdir": "linux-64", + "timestamp": 1520450126586, + "version": "4.2.3" + }, + "zeromq-4.2.5-h439df22_0.conda": { + "build": "h439df22_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "2cf2baf3d0a4d4537f08b793b0a24460", + "name": "zeromq", + "sha256": "48a8c2273fc03b5379f2bb9e47d367b562ce9373e63987a6bfe7179e083da3c3", + "size": 412698, + "subdir": "linux-64", + "timestamp": 1523637518476, + "version": "4.2.5" + }, + "zeromq-4.2.5-hf484d3e_0.conda": { + "build": "hf484d3e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "7921006265271bf1a7699156e4a900b1", + "name": "zeromq", + "sha256": "04de7e4909788dc48c5458225d98601c397659e7cc2191c2801cd030b3467c99", + "size": 412651, + "subdir": "linux-64", + "timestamp": 1531081630493, + "version": "4.2.5" + }, + "zeromq-4.2.5-hf484d3e_1.conda": { + "build": "hf484d3e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "libstdcxx-ng >=7.2.0" + ], + "license": "LGPL 3", + "md5": "4ba0cf66cd2195e2062af416d91f6a08", + "name": "zeromq", + "sha256": "d5a089c9cfe8fa23647b50a8a01d359268a230361fe1792a92610c3180e35942", + "size": 413966, + "subdir": "linux-64", + "timestamp": 1534345401396, + "version": "4.2.5" + }, + "zeromq-4.3.1-he6710b0_2.conda": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL 3", + "md5": "1264c9ed559597dc76ca9b1febb8a176", + "name": "zeromq", + "sha256": "05dd8ab53bef3206c7d61a3f33798d4b950de186acb972026253afea52531c97", + "size": 508056, + "subdir": "linux-64", + "timestamp": 1548969987835, + "version": "4.3.1" + }, + "zeromq-4.3.1-he6710b0_3.conda": { + "build": "he6710b0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libsodium >=1.0.16,<1.0.17.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL 3", + "md5": "404725cf94aaabcf50dcf280b619d999", + "name": "zeromq", + "sha256": "769b09bc4c97d2028e6f1d827d801221aa3a36335cce2eee536da6e1fda15fbd", + "size": 507696, + "subdir": "linux-64", + "timestamp": 1549023379958, + "version": "4.3.1" + }, + "zeromq-4.3.2-he6710b0_2.conda": { + "build": "he6710b0_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL 3", + "md5": "0bc49954b3097eedfc012db754d8eea2", + "name": "zeromq", + "sha256": "661f105ec3fa3ed3d24cd1ad19619d298b440f981f9de630410608e4d61eac0a", + "size": 521892, + "subdir": "linux-64", + "timestamp": 1593027140375, + "version": "4.3.2" + }, + "zeromq-4.3.2-he6710b0_3.conda": { + "build": "he6710b0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL 3", + "md5": "0ff3374d9853144c35067dc3c2b4ade0", + "name": "zeromq", + "sha256": "09fc9f7ff25eb5cd19573accc199c592c91d25ae00e584c715da9a23b90d68b1", + "size": 523056, + "subdir": "linux-64", + "timestamp": 1599759670606, + "version": "4.3.2" + }, + "zeromq-4.3.3-he6710b0_3.conda": { + "build": "he6710b0_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL 3", + "md5": "296d3dcf13792b77087cd6a2c4ed7e4a", + "name": "zeromq", + "sha256": "a480e2f6f13ad0be30981cd8133835c868cdfb25c4d4b8917cd199db6b299f34", + "size": 511595, + "subdir": "linux-64", + "timestamp": 1602701579750, + "version": "4.3.3" + }, + "zeromq-4.3.4-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "libstdcxx-ng >=7.3.0" + ], + "license": "LGPL-3.0-or-later", + "md5": "45ce422428d9c98f354aec4b5cbd1046", + "name": "zeromq", + "sha256": "3d338592b4515c84764249b5a7be8ebfdd82d1e79953ceb0c23352bf2f6817b6", + "size": 338974, + "subdir": "linux-64", + "timestamp": 1616055552392, + "version": "4.3.4" + }, + "zeromq-static-4.3.4-h2531618_0.conda": { + "build": "h2531618_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libsodium >=1.0.18,<1.0.19.0a0", + "libstdcxx-ng >=7.3.0", + "zeromq 4.3.4 h2531618_0" + ], + "license": "LGPL-3.0-or-later", + "md5": "fc4dc2602d4e6bd8844fe481a0c12e50", + "name": "zeromq-static", + "sha256": "32b489f0bc73f9d735d0b9b2f4122019a2d17ea8f21841595ab1a370cb023046", + "size": 367023, + "subdir": "linux-64", + "timestamp": 1616055563935, + "version": "4.3.4" + }, + "zfp-0.5.5-h2531618_4.conda": { + "build": "h2531618_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "9b3f84d8cee6a75438ece1e297b25024", + "name": "zfp", + "sha256": "33021cd69f3f4099593b3383d4d4812de657f20fd8b98e13a88f71ca3295fc6a", + "size": 176445, + "subdir": "linux-64", + "timestamp": 1611240514082, + "version": "0.5.5" + }, + "zfp-0.5.5-h2531618_6.conda": { + "build": "h2531618_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c2df2f830748c2bc1b68c2e72b1055d6", + "name": "zfp", + "sha256": "4c48133841f0a264e805f48fde5712b01e254b622f4d77cf34d4fa4316b4e082", + "size": 177228, + "subdir": "linux-64", + "timestamp": 1617995968460, + "version": "0.5.5" + }, + "zfp-0.5.5-h295c915_6.conda": { + "build": "h295c915_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a20971c5ed1ae5a1ebb442b75edb48df", + "name": "zfp", + "sha256": "a4487c46599640c69bda69747fdc110c49799c15d56c3e421401d2e17821b783", + "size": 171854, + "subdir": "linux-64", + "timestamp": 1642508403235, + "version": "0.5.5" + }, + "zfpy-0.5.5-py310h00e6091_6.conda": { + "build": "py310h00e6091_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "numpy >=1.21.2,<2.0a0", + "python >=3.10,<3.11.0a0", + "zfp 0.5.5 h295c915_6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e078029e2b1f67d70df656a813d6e072", + "name": "zfpy", + "sha256": "dc0e3a219d0ad0678f836b798ce5079536f1b5c8015c9fef15228b0d3bbcde46", + "size": 100986, + "subdir": "linux-64", + "timestamp": 1640796181024, + "version": "0.5.5" + }, + "zfpy-0.5.5-py36ha9443f7_4.conda": { + "build": "py36ha9443f7_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "zfp 0.5.5 h2531618_4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "dba302546c916d97ebdcfad467389d96", + "name": "zfpy", + "sha256": "92be5c196fb41cf3c5d58bf26d813ee12cd17d09c7767aadce1a4c1ac9a96b3a", + "size": 103778, + "subdir": "linux-64", + "timestamp": 1611240547318, + "version": "0.5.5" + }, + "zfpy-0.5.5-py36ha9443f7_6.conda": { + "build": "py36ha9443f7_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.6,<3.7.0a0", + "zfp 0.5.5 h2531618_6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a4e63e8f3ad6fc288f74430f95cca771", + "name": "zfpy", + "sha256": "785162a468f6042c33bf74faa50fe91a30f1218e4ef778b9711aeadc5eb452ee", + "size": 104158, + "subdir": "linux-64", + "timestamp": 1617996045289, + "version": "0.5.5" + }, + "zfpy-0.5.5-py37ha9443f7_4.conda": { + "build": "py37ha9443f7_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "zfp 0.5.5 h2531618_4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f29ef64612372be95bd191573308dfd2", + "name": "zfpy", + "sha256": "5de702ddfeef34ffd5223dafc54970fae5377469bcbc0e53841b4fe28cc8eb2b", + "size": 103491, + "subdir": "linux-64", + "timestamp": 1611240610773, + "version": "0.5.5" + }, + "zfpy-0.5.5-py37ha9443f7_6.conda": { + "build": "py37ha9443f7_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.7,<3.8.0a0", + "zfp 0.5.5 h2531618_6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "3caeea2da7cc83385b94e9d80d641410", + "name": "zfpy", + "sha256": "7d60e6bbd913ed03df39027be05af3e16302b7932e5b20a031fe06f4a9c88b4f", + "size": 104281, + "subdir": "linux-64", + "timestamp": 1617996111387, + "version": "0.5.5" + }, + "zfpy-0.5.5-py38ha9443f7_4.conda": { + "build": "py38ha9443f7_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "zfp 0.5.5 h2531618_4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "8aa130df109f44e845496ad8ec3326cd", + "name": "zfpy", + "sha256": "be11791998285daedb957d4bcdadbe6ad572f03574dee96e50eac889e522cc07", + "size": 105959, + "subdir": "linux-64", + "timestamp": 1611240640020, + "version": "0.5.5" + }, + "zfpy-0.5.5-py38ha9443f7_6.conda": { + "build": "py38ha9443f7_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.8,<3.9.0a0", + "zfp 0.5.5 h2531618_6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0c07935d2c307f92712470250e932046", + "name": "zfpy", + "sha256": "dc997190645ba46030f9a2a71bf1e297aa7384c5cf16763208f93de78c1fc580", + "size": 106545, + "subdir": "linux-64", + "timestamp": 1617996078685, + "version": "0.5.5" + }, + "zfpy-0.5.5-py39ha9443f7_4.conda": { + "build": "py39ha9443f7_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "zfp 0.5.5 h2531618_4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "efdfe5f3759f7fa64598c22db23dafe0", + "name": "zfpy", + "sha256": "bca669fad0de6bab81cc756f8cbc977e430e543285dd22a651b0fb9f4920348f", + "size": 106278, + "subdir": "linux-64", + "timestamp": 1611240580899, + "version": "0.5.5" + }, + "zfpy-0.5.5-py39ha9443f7_6.conda": { + "build": "py39ha9443f7_6", + "build_number": 6, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "numpy >=1.16.6,<2.0a0", + "python >=3.9,<3.10.0a0", + "zfp 0.5.5 h2531618_6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "582f7ff7b6e3a9d0b2ab97657644585e", + "name": "zfpy", + "sha256": "fd0319c2d65ecbe351fd268bc7da98bb4fbe2d5c0dcf27d73d956f002afaab35", + "size": 107003, + "subdir": "linux-64", + "timestamp": 1617996005524, + "version": "0.5.5" + }, + "zict-0.1.2-py27hd58a209_0.conda": { + "build": "py27hd58a209_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9d3e4cd2cd2330089a3c8f2584a90f90", + "name": "zict", + "sha256": "0401fc424e18547a26749ae4bae499d254b071340cb9fc0ccea63853cdceedb1", + "size": 18158, + "subdir": "linux-64", + "timestamp": 1505864116669, + "version": "0.1.2" + }, + "zict-0.1.2-py35h00a3a39_0.conda": { + "build": "py35h00a3a39_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7b7591122a53c001fe0967190faae398", + "name": "zict", + "sha256": "02a94221cfcd8d272efa38b695203f64a6be49bf1a5b03cfd0870d5e9bb36b4c", + "size": 18906, + "subdir": "linux-64", + "timestamp": 1505864129358, + "version": "0.1.2" + }, + "zict-0.1.2-py36ha0d441b_0.conda": { + "build": "py36ha0d441b_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "9d2b0bd923f1a50a7fbb939d14b036a7", + "name": "zict", + "sha256": "56e199ac2aef63a035e7a0bca24963450f22544159da8562227031d673403556", + "size": 18726, + "subdir": "linux-64", + "timestamp": 1505864141657, + "version": "0.1.2" + }, + "zict-0.1.3-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cef3f463e67b8c77f4cf0490e7e67656", + "name": "zict", + "sha256": "a539ed6d231eec9d262303ea81bf0ad66cae3fe888c94dbd7b0684be1e8c3e0c", + "size": 18956, + "subdir": "linux-64", + "timestamp": 1530741396896, + "version": "0.1.3" + }, + "zict-0.1.3-py27h12c336c_0.conda": { + "build": "py27h12c336c_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "121d6f94e44128f5c099cc3a8a2d9a08", + "name": "zict", + "sha256": "102c5b86308868ccf50e91b37dc5e120b68c03431541cfb22eef301b9c043c90", + "size": 18986, + "subdir": "linux-64", + "timestamp": 1506623950570, + "version": "0.1.3" + }, + "zict-0.1.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "6f9a1deec48cc4bea2c5e6c400dc8bd4", + "name": "zict", + "sha256": "4da31bc778a28cdddf081513b24057abdbc5f76bbf1748a67ed1b9862ccb5332", + "size": 19316, + "subdir": "linux-64", + "timestamp": 1534356526527, + "version": "0.1.3" + }, + "zict-0.1.3-py35h29275ca_0.conda": { + "build": "py35h29275ca_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.5,<3.6.0a0" + ], + "license": "BSD 3-Clause", + "md5": "589549cfd73d41ab7d918f734a4c21b3", + "name": "zict", + "sha256": "52bb70565fb11eb17eee854118fff90390aac0383cdf634d718f441715a62b90", + "size": 19588, + "subdir": "linux-64", + "timestamp": 1506623963574, + "version": "0.1.3" + }, + "zict-0.1.3-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "120cc6c126d94f45a537fbc970725246", + "name": "zict", + "sha256": "dcd96168dd0255395e0d803556075d00d165f523fc4aba84161e0e67b96eb0e6", + "size": 19190, + "subdir": "linux-64", + "timestamp": 1530741375348, + "version": "0.1.3" + }, + "zict-0.1.3-py36h3a3bf81_0.conda": { + "build": "py36h3a3bf81_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4c98c0ba049499a8581a393630734abf", + "name": "zict", + "sha256": "476cb8a6c908fab421d06fe96ec1b8c6e22dd6573bfcd63ea0d1822d46ba72bc", + "size": 19474, + "subdir": "linux-64", + "timestamp": 1506623934600, + "version": "0.1.3" + }, + "zict-0.1.3-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "1180c1fc5fc028eee7a6f8c4af020d18", + "name": "zict", + "sha256": "3e502965dd04e685632d1a4bb44a261f8a444a37cc37dd5e3061bee64bf7fad9", + "size": 19227, + "subdir": "linux-64", + "timestamp": 1530741419634, + "version": "0.1.3" + }, + "zict-0.1.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c31c386dcfc487a63bf9c16ed63649b3", + "name": "zict", + "sha256": "97fdaa8d4f56ee5c9f788f013fbaabf81cfcebe2beb9c0f82d9f0c0c362a3412", + "size": 20845, + "subdir": "linux-64", + "timestamp": 1552332522142, + "version": "0.1.4" + }, + "zict-0.1.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "8ffbeb926434d52193108d9c18543e81", + "name": "zict", + "sha256": "ee773d7e5fa19051eca703f1f785759c53461e20baf34c1e314119ceb62dff0a", + "size": 21265, + "subdir": "linux-64", + "timestamp": 1552332562580, + "version": "0.1.4" + }, + "zict-0.1.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "4cc07e3620b260a26a81ebf60c3d8d40", + "name": "zict", + "sha256": "92f56a4d660038a413a39db7c2c3283e8c98ee1191b7a3c91c48d4d2cdee79b3", + "size": 21143, + "subdir": "linux-64", + "timestamp": 1552332498401, + "version": "0.1.4" + }, + "zict-2.1.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a87be4bce58c12425e84ae040f209cb4", + "name": "zict", + "sha256": "163d88b4d2d007b272f1f8235d0c21a5501d3166fd58a375d1316c4fdce37615", + "size": 20316, + "subdir": "linux-64", + "timestamp": 1656387213310, + "version": "2.1.0" + }, + "zict-2.1.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "22776fc4619d8307c76055bba6481e97", + "name": "zict", + "sha256": "25ab4f30d23cdbd83631f776656008db7c1cbc08b056bb22e0c82b87c075abd9", + "size": 25949, + "subdir": "linux-64", + "timestamp": 1679340722072, + "version": "2.1.0" + }, + "zict-2.1.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f5fb96f7784b481e73731f6bac4fe5c9", + "name": "zict", + "sha256": "6c77e2ea20e0e87a495574e21cc16da20a3d21367dd16798f855e57f8453d44a", + "size": 19879, + "subdir": "linux-64", + "timestamp": 1656387239621, + "version": "2.1.0" + }, + "zict-2.1.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1e06fe8a270cba40fa543d5d0a12945a", + "name": "zict", + "sha256": "07ab4294d5f36e15130b8a4a927cf6e53192fa97ff3d6980c6db343dd9fac80c", + "size": 20008, + "subdir": "linux-64", + "timestamp": 1656387288864, + "version": "2.1.0" + }, + "zict-2.1.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "heapdict", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "64666f1028e66856c2884dac74668304", + "name": "zict", + "sha256": "356346a7fff2d6e77c1e936ae32105da577a90334ec8577ea86b75f30e47f99f", + "size": 19982, + "subdir": "linux-64", + "timestamp": 1656387265003, + "version": "2.1.0" + }, + "zip-3.0-h1adfe0e_0.conda": { + "build": "h1adfe0e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "BSD-like", + "md5": "9527efc6d3eacabe0329db36b94fa650", + "name": "zip", + "sha256": "b82884090e925db53a749dcab318c08576576b30e7bb98ad002f8bb14c471933", + "size": 116868, + "subdir": "linux-64", + "timestamp": 1508871053253, + "version": "3.0" + }, + "zip-3.0-h7f8727e_1.conda": { + "build": "h7f8727e_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "24f83fa40793f965778063fbdb1dbdba", + "name": "zip", + "sha256": "1e98f990cfcc73e0c2c2902c29e2b6bb728b0a15e5f77ee6a2a315262815ab6a", + "size": 114080, + "subdir": "linux-64", + "timestamp": 1641485406564, + "version": "3.0" + }, + "zipfile36-0.1.3-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "PSF", + "md5": "dc9304f42aa30d84a7597e1c9745615a", + "name": "zipfile36", + "sha256": "cf49d40ab2fc0f16b5a07eb606ad576b0b72a1102ea3e32e8c3301ac1985c7e1", + "size": 40018, + "subdir": "linux-64", + "timestamp": 1529946830714, + "version": "0.1.3" + }, + "zipp-0.3.3-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b707e2b3df8636c814ba17df4c6bea49", + "name": "zipp", + "sha256": "5f8fede0a83714e33fdd7946ec1ce1ac3dc6ac5d662349fe0b784f4767559891", + "size": 9461, + "subdir": "linux-64", + "timestamp": 1553291284730, + "version": "0.3.3" + }, + "zipp-0.3.3-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3192486fd5ed99c154189b113888be6e", + "name": "zipp", + "sha256": "9bc1b3802ec591e6cc946290c8e2b2b4fbdeb48d496c110991acb4ce35e3ff4c", + "size": 9537, + "subdir": "linux-64", + "timestamp": 1553291254866, + "version": "0.3.3" + }, + "zipp-0.3.3-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "00ec5bf461e84def87067772061c8e21", + "name": "zipp", + "sha256": "129c470dc60b199a4167d0eba118c80966e3216f06803adb4acd0e3bff152be9", + "size": 9590, + "subdir": "linux-64", + "timestamp": 1553291096233, + "version": "0.3.3" + }, + "zipp-3.11.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bc9f45371fbb26e473dbf18f88cbf00d", + "name": "zipp", + "sha256": "e4a0c0aeb4e82a116d4d440bcb7e9ff5430803136555d0939a1e3d51de99a595", + "size": 19688, + "subdir": "linux-64", + "timestamp": 1672387178187, + "version": "3.11.0" + }, + "zipp-3.11.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "21364c6748dcf9e6d8623a1893d19e94", + "name": "zipp", + "sha256": "36410fdeaee2c965edcbdf370c91d6aa28d957f650fc38efc566cdc27871a898", + "size": 21786, + "subdir": "linux-64", + "timestamp": 1676822906227, + "version": "3.11.0" + }, + "zipp-3.11.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0d442dcf71f352d8c5097a811b5daad5", + "name": "zipp", + "sha256": "4c655705bdcebd2245e2d64ed62c652ea5db460baf53ee6b7e04c0a661333f9d", + "size": 19447, + "subdir": "linux-64", + "timestamp": 1672387204646, + "version": "3.11.0" + }, + "zipp-3.11.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "07618137f91b378e8866ae7e0f2b915b", + "name": "zipp", + "sha256": "3557822de78af43ceee25767cc07d4e543a806d8316efdcd6806939c5db989d6", + "size": 19481, + "subdir": "linux-64", + "timestamp": 1672387151546, + "version": "3.11.0" + }, + "zipp-3.11.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6b0ec14d6d5182748006e984590daca5", + "name": "zipp", + "sha256": "965ec987f3f2f7b9c5885cfa305263acf5fc7bfb3ded3f5758891d505daa98be", + "size": 19501, + "subdir": "linux-64", + "timestamp": 1672387231268, + "version": "3.11.0" + }, + "zipp-3.8.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c90c2dcc99cdcda8ed4dcf38e644d612", + "name": "zipp", + "sha256": "34770abda813880202b2d3ad08f138940946c3345b97fc35c7a35d985d8f07ca", + "size": 15345, + "subdir": "linux-64", + "timestamp": 1652341858470, + "version": "3.8.0" + }, + "zipp-3.8.0-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7bdda3ea92bd9c00561865908de79af4", + "name": "zipp", + "sha256": "b1bb9cd0596a4402608a65fcc75933069ffb12cb4431810382204fcd7ab8d416", + "size": 15166, + "subdir": "linux-64", + "timestamp": 1652341821246, + "version": "3.8.0" + }, + "zipp-3.8.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "256d0b94f739fe6c4bd23670dc30da68", + "name": "zipp", + "sha256": "e2327e6123ec9b879dba6828e5978ec46e2a7d438f6da866d795b2f23ef2ec65", + "size": 15202, + "subdir": "linux-64", + "timestamp": 1652341795481, + "version": "3.8.0" + }, + "zipp-3.8.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fc097c13b189535669dd9a5d7ccc09bb", + "name": "zipp", + "sha256": "963db5505eb25071ee8f92341e2b3ee3137a40b6a14e8430a65942699d6a278d", + "size": 15253, + "subdir": "linux-64", + "timestamp": 1652341885546, + "version": "3.8.0" + }, + "zlib-1.2.11-h7b6447c_3.conda": { + "build": "h7b6447c_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0" + ], + "license": "zlib", + "license_family": "Other", + "md5": "50aa4407424985d56ec8ae2f94626aa9", + "name": "zlib", + "sha256": "5c5346ca7da14d7e11e15a8cc5e695d805ecb79c0e59d7043bea5843ffc493e5", + "size": 104994, + "subdir": "linux-64", + "timestamp": 1542814864621, + "version": "1.2.11" + }, + "zlib-1.2.11-h7f8727e_4.conda": { + "build": "h7f8727e_4", + "build_number": 4, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "zlib", + "license_family": "Other", + "md5": "c3d3c38e7239061225ee4786558325d8", + "name": "zlib", + "sha256": "0af153c7e83ca764700fb2be1cc9e39a7cb6769167f60cb4404c8d6fb16c823c", + "size": 110232, + "subdir": "linux-64", + "timestamp": 1639764859039, + "version": "1.2.11" + }, + "zlib-1.2.11-ha838bed_2.conda": { + "build": "ha838bed_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "zlib", + "license_family": "Other", + "md5": "375229b08ed779d4faa0e2b1124b6047", + "name": "zlib", + "sha256": "e593bb828441a167a9d7aaa3fca91790ee21cf16fa4055969d66c6ed85f6c2b5", + "size": 90814, + "subdir": "linux-64", + "timestamp": 1510092253691, + "version": "1.2.11" + }, + "zlib-1.2.11-hfbfcf68_1.conda": { + "build": "hfbfcf68_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.2.0" + ], + "license": "zlib", + "license_family": "Other", + "md5": "455d372b70177165ff003a44f7722d05", + "name": "zlib", + "sha256": "00ed4117754dc9319bfaaebe10d1b12723b56e70f16f8b2a54d721ff31b813c7", + "size": 90296, + "subdir": "linux-64", + "timestamp": 1505666570797, + "version": "1.2.11" + }, + "zlib-1.2.12-h5eee18b_3.conda": { + "build": "h5eee18b_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "Zlib", + "license_family": "Other", + "md5": "2b51a6917fb98080e5fd3c34f8721ad8", + "name": "zlib", + "sha256": "03cc9bf6d6a490866b1a31b34cb50cf4846167a55d4511c123e8a6ac5e4c435f", + "size": 105662, + "subdir": "linux-64", + "timestamp": 1662662335210, + "version": "1.2.12" + }, + "zlib-1.2.12-h7f8727e_2.conda": { + "build": "h7f8727e_2", + "build_number": 2, + "depends": [ + "libgcc-ng >=7.5.0" + ], + "license": "Zlib", + "license_family": "Other", + "md5": "4f4080e9939f082332cd8be7fedad087", + "name": "zlib", + "sha256": "d4aa8bdf122d3a53845db459d343c8b21ba51907d3c8dc5d2df3ff22dc98c6ca", + "size": 108625, + "subdir": "linux-64", + "timestamp": 1650637720646, + "version": "1.2.12" + }, + "zlib-1.2.13-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "Zlib", + "license_family": "Other", + "md5": "333e31fbfbb5057c92fa845ad6adef93", + "name": "zlib", + "sha256": "4b69b6752e384459b1fc47dfc078598d5b687b3ccffe21591676b640481fb794", + "size": 105851, + "subdir": "linux-64", + "timestamp": 1666595012798, + "version": "1.2.13" + }, + "zlib-ng-2.0.7-h5eee18b_0.conda": { + "build": "h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "Zlib", + "license_family": "Other", + "md5": "77bf8a639a547b2a2b566a5631dc8c7d", + "name": "zlib-ng", + "sha256": "d314070afafc5116fe0f2fe1a2d2ed5b15bb71a254a2963ca98e964d2b05deac", + "size": 102037, + "subdir": "linux-64", + "timestamp": 1680705068426, + "version": "2.0.7" + }, + "zope-1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "44f744a23e1f0ec4b5e3c93546bafa3e", + "name": "zope", + "sha256": "6c9656d238295af6fde04a7eb422e92aa3237b550d1bf9a5f908d0e2ca293580", + "size": 3881, + "subdir": "linux-64", + "timestamp": 1530875059578, + "version": "1.0" + }, + "zope-1.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0" + ], + "license": "BSD", + "md5": "427fa6084357659bdd3176c46d4d0897", + "name": "zope", + "sha256": "b98718a24826848c71781e9e5c47e5df14cb57dac3320a67a0d29b5f32e731d3", + "size": 4002, + "subdir": "linux-64", + "timestamp": 1536258468186, + "version": "1.0" + }, + "zope-1.0-py310h06a4308_1.conda": { + "build": "py310h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "license": "BSD", + "md5": "96f04bbc21921ebfd5647d122b687b24", + "name": "zope", + "sha256": "8151d6811a8e6b1efac0999121b60cb8b0e3919ea714ac556297b23b71a444da", + "size": 4231, + "subdir": "linux-64", + "timestamp": 1640796198952, + "version": "1.0" + }, + "zope-1.0-py311h06a4308_1.conda": { + "build": "py311h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.11,<3.12.0a0" + ], + "license": "BSD", + "md5": "26c68b011bfd5b9e1a17d181c2020e43", + "name": "zope", + "sha256": "2d66c03640aeef4afe4f19504d20ee03bd7ae48439a154837674587bfb82f7bd", + "size": 4638, + "subdir": "linux-64", + "timestamp": 1676904014115, + "version": "1.0" + }, + "zope-1.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0" + ], + "license": "BSD", + "md5": "c297f05e89621346b6863a4d6517129d", + "name": "zope", + "sha256": "fc0a965bd947b02115892263da51c6444c9f0e331c69ffc4f1b5dbcb9cfcddcb", + "size": 4036, + "subdir": "linux-64", + "timestamp": 1536258551233, + "version": "1.0" + }, + "zope-1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "03bd324569586a01ebc47f8857e52ade", + "name": "zope", + "sha256": "e4784da69f195e1b20a6b983881aea94ade2c850f0fa6cf64ce2e60f75b9c9ad", + "size": 3919, + "subdir": "linux-64", + "timestamp": 1530875010387, + "version": "1.0" + }, + "zope-1.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0" + ], + "license": "BSD", + "md5": "d8aa5bdf0b6738c3ca4247b0843d7615", + "name": "zope", + "sha256": "f88152ab0af087158fe8b8e9429ead9a51b49ea57206e831a2e0ddb0f9c1ae4e", + "size": 4032, + "subdir": "linux-64", + "timestamp": 1536258449452, + "version": "1.0" + }, + "zope-1.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "11714edafd05e9fa2a2b798fb2f1a0f8", + "name": "zope", + "sha256": "7cf52c82b9ec62a49d574a56a936346f28c93d3a90353c1c7e9e9ca8faa43f23", + "size": 3922, + "subdir": "linux-64", + "timestamp": 1530875035196, + "version": "1.0" + }, + "zope-1.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0" + ], + "license": "BSD", + "md5": "4463d78cb70fb438c49ccc1244a378af", + "name": "zope", + "sha256": "9b704dc726d4387aa8e1b1cc93647889a0b8670b70a221e48a8258b21253858f", + "size": 4038, + "subdir": "linux-64", + "timestamp": 1536258526985, + "version": "1.0" + }, + "zope-1.0-py38_1.conda": { + "build": "py38_1", + "build_number": 1, + "depends": [ + "python >=3.8,<3.9.0a0" + ], + "license": "BSD", + "md5": "76bfcb72c96f32ed3a3b3bd27f67c306", + "name": "zope", + "sha256": "aa13c647747e7d4083588b60eceff8788782ad391d19de1da607851f274afe5e", + "size": 4396, + "subdir": "linux-64", + "timestamp": 1573730067287, + "version": "1.0" + }, + "zope-1.0-py39h06a4308_1.conda": { + "build": "py39h06a4308_1", + "build_number": 1, + "depends": [ + "python >=3.9,<3.10.0a0" + ], + "license": "BSD", + "md5": "a30a9529100d6ec1fdbe38d2568cebfd", + "name": "zope", + "sha256": "d66ca8467bc43e2e5ad074b92874461068afde54edef4597f019c95244b8f832", + "size": 223472, + "subdir": "linux-64", + "timestamp": 1607554559140, + "version": "1.0" + }, + "zope.component-4.4.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "b8cdec246fc6d8c123406a4d91cd86e1", + "name": "zope.component", + "sha256": "83222f18dfc0e1d160b92a9ed421df4b85e6fd7e9e828696a95e50ba2307b033", + "size": 90328, + "subdir": "linux-64", + "timestamp": 1530875457003, + "version": "4.4.1" + }, + "zope.component-4.4.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "1ca5601f53ab1b4dffa12ae680194b44", + "name": "zope.component", + "sha256": "5498a98a3f6a6ef2840fc27ded648d9550a8cf29e511b46496e9c5efccaa1fdd", + "size": 97767, + "subdir": "linux-64", + "timestamp": 1640813234958, + "version": "4.4.1" + }, + "zope.component-4.4.1-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "66535066730b5c5ba7730ad3716f39c1", + "name": "zope.component", + "sha256": "7032f689a490ca48983b1abbd4d4275283f066e55b52769927bab13f1bfedfca", + "size": 127661, + "subdir": "linux-64", + "timestamp": 1676907901924, + "version": "4.4.1" + }, + "zope.component-4.4.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "b1a71b1c8ea7a1ec532e7dcbb1cc06ff", + "name": "zope.component", + "sha256": "1b59d08d6dc7cc7ac0deee4271349b13db5b025ce426a0dbdc8bbc8129330346", + "size": 93884, + "subdir": "linux-64", + "timestamp": 1530875397792, + "version": "4.4.1" + }, + "zope.component-4.4.1-py36h06a4308_0.conda": { + "build": "py36h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "42874e04e2e8403bcb4d1be0025ebe1a", + "name": "zope.component", + "sha256": "13fde89e6276eea31ba62b7ab65d19fc6fba9f5214c5c4fc973eaaf6ca34c4c3", + "size": 332992, + "subdir": "linux-64", + "timestamp": 1613038482861, + "version": "4.4.1" + }, + "zope.component-4.4.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "34b724a98ba44aa08d7e20c977f894af", + "name": "zope.component", + "sha256": "f25a98d0d9d443980398aa07d8f70c91a16e0289e6a67bd3c91fdd801b03f552", + "size": 93624, + "subdir": "linux-64", + "timestamp": 1530875428225, + "version": "4.4.1" + }, + "zope.component-4.4.1-py37h06a4308_0.conda": { + "build": "py37h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "06b145c3f0aef563aa5124e972c068db", + "name": "zope.component", + "sha256": "718b0b66529e626f04860d95f9f8dda72e1bfb5a465df56b448754a8bc346ed1", + "size": 332234, + "subdir": "linux-64", + "timestamp": 1613038453001, + "version": "4.4.1" + }, + "zope.component-4.4.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "2eae6139e5b186166d4211bc43e7f960", + "name": "zope.component", + "sha256": "d6be9de0980ecc7c3f2f4a454b348f7c53eb4965d3e8df7332fc5afa0e0f9aa2", + "size": 96654, + "subdir": "linux-64", + "timestamp": 1574412804135, + "version": "4.4.1" + }, + "zope.component-4.4.1-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "d80124414878e133eb3b8bde78547dba", + "name": "zope.component", + "sha256": "174c6386173f7b56aad0b05c44468368d5f31b67035d6120baa993b9961c9c33", + "size": 333432, + "subdir": "linux-64", + "timestamp": 1613043468132, + "version": "4.4.1" + }, + "zope.component-4.4.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools", + "zope.event", + "zope.interface >=4.1.0" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "238f43e17a67df46942d0d1683726b37", + "name": "zope.component", + "sha256": "793103259774e94ce1e1790f9fb7f3d1e7eab439a4e6aaf3270e87c4b60617e6", + "size": 334716, + "subdir": "linux-64", + "timestamp": 1613043067627, + "version": "4.4.1" + }, + "zope.deprecation-4.3.0-py27_1.conda": { + "build": "py27_1", + "build_number": 1, + "depends": [ + "python >=2.7,<2.8.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "f07737331cafbef910379ca047270153", + "name": "zope.deprecation", + "sha256": "427f02d6e460b32c05db9775d8de6c4dd529facd87be478c21ee50869913fd77", + "size": 19422, + "subdir": "linux-64", + "timestamp": 1530025617156, + "version": "4.3.0" + }, + "zope.deprecation-4.3.0-py35_1.conda": { + "build": "py35_1", + "build_number": 1, + "depends": [ + "python >=3.5,<3.6.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "7cf4d95fd303536a76786b777bf44bc2", + "name": "zope.deprecation", + "sha256": "e8a1a17f871467a29071c564749760acd556bb081ad1b15d18671f3f2eec3903", + "size": 20021, + "subdir": "linux-64", + "timestamp": 1530025685756, + "version": "4.3.0" + }, + "zope.deprecation-4.3.0-py36_1.conda": { + "build": "py36_1", + "build_number": 1, + "depends": [ + "python >=3.6,<3.7.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "6f231dbddc3302051bfd79da23696858", + "name": "zope.deprecation", + "sha256": "9162a76f65ef7b3e72c96e4ff097407cddfb5e903874cc52b75214f285d6638e", + "size": 20028, + "subdir": "linux-64", + "timestamp": 1530025447369, + "version": "4.3.0" + }, + "zope.deprecation-4.3.0-py37_1.conda": { + "build": "py37_1", + "build_number": 1, + "depends": [ + "python >=3.7,<3.8.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "c793cc1912d9b517da5e17007b45852a", + "name": "zope.deprecation", + "sha256": "5ee1e558e66d3c6904989c2d13401233545851d43f17ccb8f7b4e75d6739936f", + "size": 19951, + "subdir": "linux-64", + "timestamp": 1530875086317, + "version": "4.3.0" + }, + "zope.deprecation-4.4.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "e929ae62eaa220c723e01b228179699a", + "name": "zope.deprecation", + "sha256": "abe3e8393a91a9e9e142673052a52b73ee44b5fa31e7fd70d4c3766503f87de5", + "size": 19553, + "subdir": "linux-64", + "timestamp": 1545113657943, + "version": "4.4.0" + }, + "zope.deprecation-4.4.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "80b2f61130afe2293a8ef356e5d7fa67", + "name": "zope.deprecation", + "sha256": "4865488dcbd9f72c9b33c4c708f9d7b699548ae9eeb8c554231428b8982523b2", + "size": 20338, + "subdir": "linux-64", + "timestamp": 1640811446562, + "version": "4.4.0" + }, + "zope.deprecation-4.4.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "8f94ef6dc4297ad22ce727eb51b9215c", + "name": "zope.deprecation", + "sha256": "0747e305b6dc9d61f276850616e4bc146a02cbaea21dd17c716a1173ae488a72", + "size": 25043, + "subdir": "linux-64", + "timestamp": 1676905892997, + "version": "4.4.0" + }, + "zope.deprecation-4.4.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "4eb88a9aec6927bd1c1d854001409718", + "name": "zope.deprecation", + "sha256": "bfb7e63171266612d5ca9825d6f66fa1bbffd4949c7ddfe9ef5e0ca955cd32ad", + "size": 20180, + "subdir": "linux-64", + "timestamp": 1545113690000, + "version": "4.4.0" + }, + "zope.deprecation-4.4.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "1f2c763611dcd71f2353cd3ea0f93dd1", + "name": "zope.deprecation", + "sha256": "a252ca356b52ff7860777e5e43a859063213cd86d77b57e43f1be68025278b4c", + "size": 20144, + "subdir": "linux-64", + "timestamp": 1545113675367, + "version": "4.4.0" + }, + "zope.deprecation-4.4.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "aa8c475ffb3a78b0b7dae248e9663f6f", + "name": "zope.deprecation", + "sha256": "d7538a1177474340603a352bd5b214661209ad910a365936ad29989219105f25", + "size": 20426, + "subdir": "linux-64", + "timestamp": 1574437475997, + "version": "4.4.0" + }, + "zope.deprecation-4.4.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "9b7f88019fd9ccd9a984b329bd362a00", + "name": "zope.deprecation", + "sha256": "f303a6f919cc88bb28fed70c89a489633987a0edb58b1b77c7830237d2115dcd", + "size": 238774, + "subdir": "linux-64", + "timestamp": 1607554972940, + "version": "4.4.0" + }, + "zope.event-4.3.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "40baa6d7b3be5a69eb3644472f44c33a", + "name": "zope.event", + "sha256": "312829b00f203da6e856af0faa3cb6435edca847265f340e03b2b83298d445ac", + "size": 9709, + "subdir": "linux-64", + "timestamp": 1530875368195, + "version": "4.3.0" + }, + "zope.event-4.3.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "0c0139a63aba8d4e053e2299869fe57a", + "name": "zope.event", + "sha256": "f3d820141d1951d501b20a475a61f5c63bb5ba21a7ebae4ec1ef04784bc8a160", + "size": 9724, + "subdir": "linux-64", + "timestamp": 1530875317520, + "version": "4.3.0" + }, + "zope.event-4.3.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "fdec7a2d23a2f573b236e0be8e15adad", + "name": "zope.event", + "sha256": "c92b9ad26bbd76d1a26dcf060dd10748345f05d819b094498e59e5356436411c", + "size": 9775, + "subdir": "linux-64", + "timestamp": 1530875343248, + "version": "4.3.0" + }, + "zope.event-4.4-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "5ac7042c4f460be48d2a50e87a2cf7ff", + "name": "zope.event", + "sha256": "dd17702c8bc4ddade7d234f85516a20c0a895806298840929f0b50bc6fc6ea0d", + "size": 9992, + "subdir": "linux-64", + "timestamp": 1539659607288, + "version": "4.4" + }, + "zope.event-4.4-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "9158c41f8cb0b30684247a44203d34e6", + "name": "zope.event", + "sha256": "2e9f8f5ca71c12f6b5fe8cf129d5a45ae13a83f6119c590d52b07905a2c7345a", + "size": 10034, + "subdir": "linux-64", + "timestamp": 1539659620561, + "version": "4.4" + }, + "zope.event-4.4-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "7e6ae8d77839c728056e479504218b80", + "name": "zope.event", + "sha256": "a25c115a52c5d60e5e8aa278bdf7bd4d23711d99b8a270156c8bdc8ae23fcbb5", + "size": 10026, + "subdir": "linux-64", + "timestamp": 1539659622532, + "version": "4.4" + }, + "zope.event-4.4-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "2b8244af10c9192ec181b2f7f72f1f14", + "name": "zope.event", + "sha256": "442ff7c8eac3633bed7d82338b174bd3ddca9a226b45b7a4974641afdc590801", + "size": 10269, + "subdir": "linux-64", + "timestamp": 1574153556005, + "version": "4.4" + }, + "zope.event-4.5.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "22ca034f73342e5cb52fc5126f3fdca3", + "name": "zope.event", + "sha256": "c589506061a2c20c3f20446c66124cf00b620205e62e7996dbaca307a4f039b8", + "size": 10041, + "subdir": "linux-64", + "timestamp": 1640796217001, + "version": "4.5.0" + }, + "zope.event-4.5.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "6bb011eaf9209989e3875e6b128c82e3", + "name": "zope.event", + "sha256": "56d8b1548595edfb9cde39f535aabccb3f9555bf69b3d00feffa9119182b49f4", + "size": 11144, + "subdir": "linux-64", + "timestamp": 1676906008282, + "version": "4.5.0" + }, + "zope.event-4.5.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "b965bdc821b672912042b94eed20bd91", + "name": "zope.event", + "sha256": "43643eb6a73bf12e42e08ba5c87c244848d29fea05163602b6ac256100667015", + "size": 213900, + "subdir": "linux-64", + "timestamp": 1602679982746, + "version": "4.5.0" + }, + "zope.event-4.5.0-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "231efb2412f8ad90aa3d73b1e5e8229c", + "name": "zope.event", + "sha256": "2b0f0b91c877de7eed3ab3fdb04c4ab08948c6019ef2c5dd6872e8b63b6cfc7e", + "size": 214422, + "subdir": "linux-64", + "timestamp": 1602679988095, + "version": "4.5.0" + }, + "zope.event-4.5.0-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "7a943b9acc2c9f3d7b1c9e87c18f4828", + "name": "zope.event", + "sha256": "317e46caad0cb77497c9c832829772343a32bcb44914a24cea9ec40365147b36", + "size": 214328, + "subdir": "linux-64", + "timestamp": 1602679981330, + "version": "4.5.0" + }, + "zope.event-4.5.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "setuptools" + ], + "license": "Zope Public License", + "license_family": "OTHER", + "md5": "b0faf0b7b09e57a0bbf53096a1cc18ae", + "name": "zope.event", + "sha256": "1e5ae0130841c2b946fee527d6eb4342635f15960c9e7d97a51ba60188600baf", + "size": 228801, + "subdir": "linux-64", + "timestamp": 1607554554233, + "version": "4.5.0" + }, + "zope.interface-4.4.3-py27hb02d991_0.conda": { + "build": "py27hb02d991_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "61601136bb51a614971920aaf0b5eaeb", + "name": "zope.interface", + "sha256": "f58589af9a4888bfb3130d4d2a76acaea23ff283629290bb989108186f6c892d", + "size": 192226, + "subdir": "linux-64", + "timestamp": 1509046374236, + "version": "4.4.3" + }, + "zope.interface-4.4.3-py35h9cef842_0.conda": { + "build": "py35h9cef842_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "b70861401b6d163d4f28b59748281cb3", + "name": "zope.interface", + "sha256": "fdf5a1697b41dcb6a4d1a3a7b8f31f152c0524d27beb485d46ecb1c00699ebca", + "size": 203028, + "subdir": "linux-64", + "timestamp": 1509046456695, + "version": "4.4.3" + }, + "zope.interface-4.4.3-py36h0ccbf34_0.conda": { + "build": "py36h0ccbf34_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "f11236167825c398249520d581157e73", + "name": "zope.interface", + "sha256": "f5384a4388569aab6b8e74272bf6e26a68296ae0630ed9cab2e02404c066851c", + "size": 201794, + "subdir": "linux-64", + "timestamp": 1509046464634, + "version": "4.4.3" + }, + "zope.interface-4.5.0-py27h14c3975_0.conda": { + "build": "py27h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=2.7,<2.8.0a0", + "setuptools", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "0d1b48c2ab0714f2b54c4e88bdfe17b7", + "name": "zope.interface", + "sha256": "406cecf6971da9980f7b62c62056e36541a655e680cde0dc5ed2f376600b2acf", + "size": 193746, + "subdir": "linux-64", + "timestamp": 1524497593527, + "version": "4.5.0" + }, + "zope.interface-4.5.0-py35h14c3975_0.conda": { + "build": "py35h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.5,<3.6.0a0", + "setuptools", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "e22399d9fcc7ff558a83f2d42748a716", + "name": "zope.interface", + "sha256": "2036bb44cc11880ee42b54f44f9b31c736156482a70dcc55d133391657d48928", + "size": 202495, + "subdir": "linux-64", + "timestamp": 1524497638655, + "version": "4.5.0" + }, + "zope.interface-4.5.0-py36h14c3975_0.conda": { + "build": "py36h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "8f64fedd02141a5e66b123500bc4de9b", + "name": "zope.interface", + "sha256": "2ae610c526d4bd82026f082e919350dd9738b859d34b0018c556d94d25620537", + "size": 201812, + "subdir": "linux-64", + "timestamp": 1524497527741, + "version": "4.5.0" + }, + "zope.interface-4.5.0-py37h14c3975_0.conda": { + "build": "py37h14c3975_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "python >=3.7,<3.8.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "040c7733e8c717d4117288c1e94f2ed1", + "name": "zope.interface", + "sha256": "1ba0832c1bd14dd6bc66bd8b12227d2b52648ab55ff5f56247f803843bc131a8", + "size": 203786, + "subdir": "linux-64", + "timestamp": 1530875118566, + "version": "4.5.0" + }, + "zope.interface-4.6.0-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "22c63a77d7ab8e6095cc714494d1aeca", + "name": "zope.interface", + "sha256": "e767f6d0b90910f927b0860348f40fb89223ec534490e7470cf53b5d22ffb1af", + "size": 193377, + "subdir": "linux-64", + "timestamp": 1541086267566, + "version": "4.6.0" + }, + "zope.interface-4.6.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "85ddfbd28a2a93183d469d7d970bdfb7", + "name": "zope.interface", + "sha256": "9cece6449fab043eefc31de31eb0f10d6339669684b4b5906b7c36cb5a3c492e", + "size": 205128, + "subdir": "linux-64", + "timestamp": 1541086284344, + "version": "4.6.0" + }, + "zope.interface-4.6.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "79feedf9ca87ce0b9c54fd67da8021de", + "name": "zope.interface", + "sha256": "ec71fa1fe72633355d82994d38b2df00cd874ff97660c4c8f0b2b0bf15cda19b", + "size": 205223, + "subdir": "linux-64", + "timestamp": 1541086260681, + "version": "4.6.0" + }, + "zope.interface-4.6.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "c50a2add901b1ec41d344f2aec089282", + "name": "zope.interface", + "sha256": "5330888e972cd419838f3fa91a44e757dffa49bf7b8f5781c0f69d83cbc0d04a", + "size": 213589, + "subdir": "linux-64", + "timestamp": 1574412786634, + "version": "4.6.0" + }, + "zope.interface-4.7.1-py27h7b6447c_0.conda": { + "build": "py27h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=2.7,<2.8.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "eeb133d987527e87f79aac6b8862cd07", + "name": "zope.interface", + "sha256": "17e3d8f1cd05138901398660b426e360b9a054227d2ba28628b2bbacb634a73b", + "size": 199058, + "subdir": "linux-64", + "timestamp": 1574380019380, + "version": "4.7.1" + }, + "zope.interface-4.7.1-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "87a3638c9e62bea15b78325122a72295", + "name": "zope.interface", + "sha256": "660384927c79885f951a88adcfea3e074d701f519771edcbf6e1d63a428b1147", + "size": 208611, + "subdir": "linux-64", + "timestamp": 1574380047371, + "version": "4.7.1" + }, + "zope.interface-4.7.1-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "37d244a288246249f8d684e2a68f488d", + "name": "zope.interface", + "sha256": "bba50110e1943ec1265db9b640dc0713586f8f19718ceb5fbc1003904a555059", + "size": 208945, + "subdir": "linux-64", + "timestamp": 1574380033765, + "version": "4.7.1" + }, + "zope.interface-4.7.1-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "zope" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "bb8fcc377700e8edaf70d1673a05bbe1", + "name": "zope.interface", + "sha256": "437533d1c2313da556b835da6e754f1da005931032e234ad1ac5bd2172d98359", + "size": 218160, + "subdir": "linux-64", + "timestamp": 1574380083111, + "version": "4.7.1" + }, + "zope.interface-5.1.0-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "19d0c6e9cbacd01df69d6943c6fea59a", + "name": "zope.interface", + "sha256": "e93a35765440e8868338c481ab99a179de8e12d878ceca0e845c2249770e3dc6", + "size": 285390, + "subdir": "linux-64", + "timestamp": 1598624219648, + "version": "5.1.0" + }, + "zope.interface-5.1.0-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "ec2797f7e56fdfa258796c1128600f30", + "name": "zope.interface", + "sha256": "ab044f494af7a2e294ef905a77d3472f829ba4c419d218d57747e9f6602b370f", + "size": 288904, + "subdir": "linux-64", + "timestamp": 1598624210199, + "version": "5.1.0" + }, + "zope.interface-5.1.0-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "86708b0d793854be2f289038ef1db665", + "name": "zope.interface", + "sha256": "76f0440ca82c636c9ac06e8aab0892256ef6d1ab417140f78bdf91dea6389c2e", + "size": 288439, + "subdir": "linux-64", + "timestamp": 1598624233645, + "version": "5.1.0" + }, + "zope.interface-5.1.2-py36h7b6447c_0.conda": { + "build": "py36h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "f89ab8f32f66c41c2914cf9adb322a26", + "name": "zope.interface", + "sha256": "4ed78d930ca10dc0ba96b5ebb1aa4eb48f458b793dbb33c63c359475029352c5", + "size": 283805, + "subdir": "linux-64", + "timestamp": 1602002464067, + "version": "5.1.2" + }, + "zope.interface-5.1.2-py37h7b6447c_0.conda": { + "build": "py37h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "b5d1ac0e0d7c141f157791a33ce989b5", + "name": "zope.interface", + "sha256": "8e18b6191b8b18b1f82a17f5dedeca427646b88be654c4acc6af6096c170d934", + "size": 287623, + "subdir": "linux-64", + "timestamp": 1602002484898, + "version": "5.1.2" + }, + "zope.interface-5.1.2-py38h7b6447c_0.conda": { + "build": "py38h7b6447c_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "745403ca4d347be4d15f131ef85f4407", + "name": "zope.interface", + "sha256": "82602d7c04d4d93fd46d804b21eabb706e382cb42c3b244b57b1dfe6d7e5555d", + "size": 290946, + "subdir": "linux-64", + "timestamp": 1602002458077, + "version": "5.1.2" + }, + "zope.interface-5.2.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "105fab0fc9610b90c02345fa32b240af", + "name": "zope.interface", + "sha256": "9d3e7b01809894367e249067a5ba52e399a90f295bd4f2dda2746c7c10251065", + "size": 283083, + "subdir": "linux-64", + "timestamp": 1606940292673, + "version": "5.2.0" + }, + "zope.interface-5.2.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "60b9acc040fb34f1b58edc7007098cb4", + "name": "zope.interface", + "sha256": "08fe40622ddc800597db64c3026c1fc059594b8179cdb750a973663c7987fd0b", + "size": 284459, + "subdir": "linux-64", + "timestamp": 1606940275034, + "version": "5.2.0" + }, + "zope.interface-5.2.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "1558e42dcfe3734b21652ed3d4e8bb82", + "name": "zope.interface", + "sha256": "c20f4d146f4bd2b9424e900449e4f9fc45bf8badc21619091291aa6ed05a13ef", + "size": 290735, + "subdir": "linux-64", + "timestamp": 1606940298281, + "version": "5.2.0" + }, + "zope.interface-5.2.0-py39he8ac12f_0.conda": { + "build": "py39he8ac12f_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "a9175d1183f4e274441a2919f071f51f", + "name": "zope.interface", + "sha256": "78215aa0676418296b611216777620249914e94f3d73602874b09760fd8c2dca", + "size": 291820, + "subdir": "linux-64", + "timestamp": 1607554999322, + "version": "5.2.0" + }, + "zope.interface-5.3.0-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "ccd4e0ad62ffa3b2cacae1804253b4bc", + "name": "zope.interface", + "sha256": "923dd8882c1804ef525f2ddb8dc155d4472548ec4d209f2baed7a3862fc61a35", + "size": 299343, + "subdir": "linux-64", + "timestamp": 1616357256441, + "version": "5.3.0" + }, + "zope.interface-5.3.0-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "e90fbf0c5af7533ea69cad0da7cae9ca", + "name": "zope.interface", + "sha256": "a4d4787a16fab7406a8d1f736de12c10e1633012f976ce224294e74b0957a9c8", + "size": 299997, + "subdir": "linux-64", + "timestamp": 1616355176353, + "version": "5.3.0" + }, + "zope.interface-5.3.0-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "e5557f2aad88de8afff36436da170918", + "name": "zope.interface", + "sha256": "a336d516458be5a29b448b85258431128be1bc207e0d55ab6efa0c25b404f39d", + "size": 302122, + "subdir": "linux-64", + "timestamp": 1616357256943, + "version": "5.3.0" + }, + "zope.interface-5.3.0-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "523ec3b33021e861bb876ea3f9944e3f", + "name": "zope.interface", + "sha256": "01e3f2dc1277efdcef2ac1a486f0f65667ebfaaf9a47b85524c088dba92fc7ac", + "size": 306561, + "subdir": "linux-64", + "timestamp": 1616357254194, + "version": "5.3.0" + }, + "zope.interface-5.4.0-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "ca16f287a61292876197d36534d3e24e", + "name": "zope.interface", + "sha256": "535f5d4e61d770356f28b924e11faf3da028fc4c7a4f9f8845bb3949ad59798e", + "size": 343824, + "subdir": "linux-64", + "timestamp": 1640811472712, + "version": "5.4.0" + }, + "zope.interface-5.4.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "c44de33e3878b2b2b519566d449de1ee", + "name": "zope.interface", + "sha256": "1c6c0f3f0f56b3956ab7f8b74ca35fd8ec7f8abbe37a397eaaf48831accbcda8", + "size": 403156, + "subdir": "linux-64", + "timestamp": 1676905915790, + "version": "5.4.0" + }, + "zope.interface-5.4.0-py36h7f8727e_0.conda": { + "build": "py36h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.6,<3.7.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "59ee3c40ba543a3604e797b9bdc8d535", + "name": "zope.interface", + "sha256": "f4724e669e018d8f09f32bbda491c05a70471a80ef1b9213826500de052fc836", + "size": 307629, + "subdir": "linux-64", + "timestamp": 1625036220225, + "version": "5.4.0" + }, + "zope.interface-5.4.0-py37h7f8727e_0.conda": { + "build": "py37h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.7,<3.8.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "030001ddc2202e3b4d6b1c8a36b931a9", + "name": "zope.interface", + "sha256": "1ab44e1ab54c123a04878fafd87ae750527ae4b1f3dd08c0e5c67f0711af7082", + "size": 304739, + "subdir": "linux-64", + "timestamp": 1625029751829, + "version": "5.4.0" + }, + "zope.interface-5.4.0-py38h7f8727e_0.conda": { + "build": "py38h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.8,<3.9.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "6df6ff49d61757df566fc38c17260aee", + "name": "zope.interface", + "sha256": "402cd58de2395dff13b52fbc69b3e582b92af706fc9d05d505a87302dd02f641", + "size": 308541, + "subdir": "linux-64", + "timestamp": 1625035589413, + "version": "5.4.0" + }, + "zope.interface-5.4.0-py39h7f8727e_0.conda": { + "build": "py39h7f8727e_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "python >=3.9,<3.10.0a0", + "setuptools", + "zope" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "2af386b054be9d8c3c9109675e05b1ac", + "name": "zope.interface", + "sha256": "19d629301b5374574451c75cd5d9714ad692f73307401c45c5c8f294bddf211b", + "size": 311850, + "subdir": "linux-64", + "timestamp": 1625036218413, + "version": "5.4.0" + }, + "zope.sqlalchemy-1.0-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "sqlalchemy >=0.5.1", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "271fa4f64d0ca9413be1ac428cbfc91c", + "name": "zope.sqlalchemy", + "sha256": "3d0a8e413939c3eb18b3f844e8f4e9cfe042ffa2982563f7f39023397b1df76b", + "size": 29718, + "subdir": "linux-64", + "timestamp": 1530022074421, + "version": "1.0" + }, + "zope.sqlalchemy-1.0-py35_0.conda": { + "build": "py35_0", + "build_number": 0, + "depends": [ + "python >=3.5,<3.6.0a0", + "sqlalchemy >=0.5.1", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "b737281e4e7aef26ad33eb93bfcf1c48", + "name": "zope.sqlalchemy", + "sha256": "4efecb2cbbf46f1fc7196a578c8f3bf3c641c829506a3c8384b52811618bed5f", + "size": 30358, + "subdir": "linux-64", + "timestamp": 1530022095999, + "version": "1.0" + }, + "zope.sqlalchemy-1.0-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "sqlalchemy >=0.5.1", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "77c5e04297e2d949dc83bb216d98e079", + "name": "zope.sqlalchemy", + "sha256": "5b0ee8e093b5f85c4f5cea323486ed3dc4dac6f40c2ba8671604aabdc7f3e4ab", + "size": 29971, + "subdir": "linux-64", + "timestamp": 1530022050857, + "version": "1.0" + }, + "zope.sqlalchemy-1.1-py27_0.conda": { + "build": "py27_0", + "build_number": 0, + "depends": [ + "python >=2.7,<2.8.0a0", + "sqlalchemy >=0.5.1", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "4b16eb18dccca9a1d25bfb415b491faa", + "name": "zope.sqlalchemy", + "sha256": "f8e95f590e09675cdf683091e0519912c6027805e416d173a8b78a36ab529bd6", + "size": 173405, + "subdir": "linux-64", + "timestamp": 1548291061364, + "version": "1.1" + }, + "zope.sqlalchemy-1.1-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "sqlalchemy >=0.5.1", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "9b501df1b8e8937af3b8295310529144", + "name": "zope.sqlalchemy", + "sha256": "78571284d1268f67e409fe52f95be70917dc40e49351ddb1ac1370d596654d34", + "size": 29727, + "subdir": "linux-64", + "timestamp": 1640814737947, + "version": "1.1" + }, + "zope.sqlalchemy-1.1-py36_0.conda": { + "build": "py36_0", + "build_number": 0, + "depends": [ + "python >=3.6,<3.7.0a0", + "sqlalchemy >=0.5.1", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "3aa423e429e953023bbdb4d2a8934b3a", + "name": "zope.sqlalchemy", + "sha256": "bc1ab89d7b68ba25255768790c5c84c74cde648d51d76e800b91e570884b3296", + "size": 173612, + "subdir": "linux-64", + "timestamp": 1548291116118, + "version": "1.1" + }, + "zope.sqlalchemy-1.1-py37_0.conda": { + "build": "py37_0", + "build_number": 0, + "depends": [ + "python >=3.7,<3.8.0a0", + "sqlalchemy >=0.5.1", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "da5a9bb83fb4c963e3ac43f88cdaea77", + "name": "zope.sqlalchemy", + "sha256": "1939423d396fd0a49799b15bc29bdc7301ee9314538701cd1387f92b7318e5ec", + "size": 173725, + "subdir": "linux-64", + "timestamp": 1548310767869, + "version": "1.1" + }, + "zope.sqlalchemy-1.1-py38_0.conda": { + "build": "py38_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "sqlalchemy >=0.5.1", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "220c601e5c2e8c31fadc5a5116939d95", + "name": "zope.sqlalchemy", + "sha256": "407800f92398492049c2192b112ca1c3fc730f59f2b8b90fec9ac6fe3648b150", + "size": 30433, + "subdir": "linux-64", + "timestamp": 1573569845456, + "version": "1.1" + }, + "zope.sqlalchemy-1.1-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "sqlalchemy >=0.5.1", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL 2.1", + "license_family": "Other", + "md5": "be5dd6414ee2874a62381d8e2a79888c", + "name": "zope.sqlalchemy", + "sha256": "bed2b7bfefc5f2f02f10c0fac49a000c2fc51b77d66a3f9ff3563948f40afa7c", + "size": 248804, + "subdir": "linux-64", + "timestamp": 1607565334509, + "version": "1.1" + }, + "zope.sqlalchemy-2.0-py310h06a4308_0.conda": { + "build": "py310h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.10,<3.11.0a0", + "sqlalchemy >=1.1,!=1.4.0,!=1.4.1,!=1.4.2,!=1.4.3,!=1.4.4,!=1.4.5,!=1.4.6,<2", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "33da453aeaa8e34e532787e09eaaa2ee", + "name": "zope.sqlalchemy", + "sha256": "b864948a5c476c4fe01382d657b504b56ed642f08fcfc8246beb585e363606bd", + "size": 34207, + "subdir": "linux-64", + "timestamp": 1680531119592, + "version": "2.0" + }, + "zope.sqlalchemy-2.0-py311h06a4308_0.conda": { + "build": "py311h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.11,<3.12.0a0", + "sqlalchemy >=1.1,!=1.4.0,!=1.4.1,!=1.4.2,!=1.4.3,!=1.4.4,!=1.4.5,!=1.4.6,<2", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "ab24731857481cf97d75bd30501393db", + "name": "zope.sqlalchemy", + "sha256": "bb1063ac6a31260668b42741bdd57df7f34cb6e9b05b95fed55438d555bcec40", + "size": 41350, + "subdir": "linux-64", + "timestamp": 1680531145428, + "version": "2.0" + }, + "zope.sqlalchemy-2.0-py38h06a4308_0.conda": { + "build": "py38h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.8,<3.9.0a0", + "sqlalchemy >=1.1,!=1.4.0,!=1.4.1,!=1.4.2,!=1.4.3,!=1.4.4,!=1.4.5,!=1.4.6,<2", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "21f3d3ce783896b38f05a5188a2a0b29", + "name": "zope.sqlalchemy", + "sha256": "e85d5df2857d49587001145cfe7d06a62cabae967bca135066328654b9302aef", + "size": 33909, + "subdir": "linux-64", + "timestamp": 1680531093869, + "version": "2.0" + }, + "zope.sqlalchemy-2.0-py39h06a4308_0.conda": { + "build": "py39h06a4308_0", + "build_number": 0, + "depends": [ + "python >=3.9,<3.10.0a0", + "sqlalchemy >=1.1,!=1.4.0,!=1.4.1,!=1.4.2,!=1.4.3,!=1.4.4,!=1.4.5,!=1.4.6,<2", + "transaction >=1.6.0", + "zope.interface >=3.6.0" + ], + "license": "ZPL-2.1", + "license_family": "Other", + "md5": "3b46ab966925bf872b320828164c3052", + "name": "zope.sqlalchemy", + "sha256": "7cdcda564bb5231c6348ce49d291cb66e079d574f211a4af25210319e18ee7bf", + "size": 33869, + "subdir": "linux-64", + "timestamp": 1680531169767, + "version": "2.0" + }, + "zstandard-0.12.0-py27he6710b0_0.conda": { + "build": "py27he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=2.7,<2.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "aea763629f11cf2cfdc3ee83f33f1fa6", + "name": "zstandard", + "sha256": "910adbbdbb7bae3b1d8953c0694a3686995b72f0ad175d03bb5d25f70b664e26", + "size": 389123, + "subdir": "linux-64", + "timestamp": 1574350854778, + "version": "0.12.0" + }, + "zstandard-0.12.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "20bc8c4f25e5b68fb0a75f4ac14a9249", + "name": "zstandard", + "sha256": "02b8045a7638fa4aea0fa42dff03e7d7c865481fa05e8c49ba878147852268a3", + "size": 389620, + "subdir": "linux-64", + "timestamp": 1574350865962, + "version": "0.12.0" + }, + "zstandard-0.12.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "030dbad26281fd827eb07385ba9ba8c4", + "name": "zstandard", + "sha256": "fe0e261849cbf949897ee20d8da3d310619f75c2f7c38dbbf7246854e343cc59", + "size": 390856, + "subdir": "linux-64", + "timestamp": 1574350793607, + "version": "0.12.0" + }, + "zstandard-0.12.0-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "615551a21574fa2055abe3e2e062fd62", + "name": "zstandard", + "sha256": "8ab331fa66eb8c9a6a05bd659416f896d31b14d4c6587848b97a5ed41e9c7578", + "size": 390706, + "subdir": "linux-64", + "timestamp": 1574350887346, + "version": "0.12.0" + }, + "zstandard-0.13.0-py36he6710b0_0.conda": { + "build": "py36he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD 3-Clause", + "md5": "7d768235f407dcde1223c6d0c658f337", + "name": "zstandard", + "sha256": "cb53d2259922d981d563633b94d28955e3506e44c68fe94b69229f043ef7783d", + "size": 396978, + "subdir": "linux-64", + "timestamp": 1587391843895, + "version": "0.13.0" + }, + "zstandard-0.13.0-py37he6710b0_0.conda": { + "build": "py37he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD 3-Clause", + "md5": "dc4575ef3d4854be018be13f02bc9a9a", + "name": "zstandard", + "sha256": "512d5f006bb57bfd34e4ca1feaa26736d3f052ca13bececfb2583c10312cf2cb", + "size": 397006, + "subdir": "linux-64", + "timestamp": 1587391848339, + "version": "0.13.0" + }, + "zstandard-0.13.0-py38he6710b0_0.conda": { + "build": "py38he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD 3-Clause", + "md5": "c3849e84632e0df51bdd044170c8459d", + "name": "zstandard", + "sha256": "1a49ec8eb5146a4e77a3d3e4834da5f24576e0861154b5df52d45cd12563854e", + "size": 398178, + "subdir": "linux-64", + "timestamp": 1587391845625, + "version": "0.13.0" + }, + "zstandard-0.14.0-py36he6710b0_1.conda": { + "build": "py36he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "faeb866d515d7dcf303c908ab9e63c0b", + "name": "zstandard", + "sha256": "255cb1c5395c98b8461239bf5db3f481c9ed9ee17100a017f8a261065e7d605c", + "size": 401417, + "subdir": "linux-64", + "timestamp": 1602002578078, + "version": "0.14.0" + }, + "zstandard-0.14.0-py37he6710b0_1.conda": { + "build": "py37he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "6c70f011a0760a5b758b4991a30b6e5f", + "name": "zstandard", + "sha256": "da56994c4bcd6fef91cbbb26a903d0b64eb1daae9069ff8cd1464a9bbf2f85aa", + "size": 401271, + "subdir": "linux-64", + "timestamp": 1602002574558, + "version": "0.14.0" + }, + "zstandard-0.14.0-py38he6710b0_1.conda": { + "build": "py38he6710b0_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "1c68d71e2fa9025fd3546f6c7ad55bd1", + "name": "zstandard", + "sha256": "13dff4e6b89a18f72768b44146b5c6b5dd9c43b91d429dad431aaa48b3826332", + "size": 402835, + "subdir": "linux-64", + "timestamp": 1602002575022, + "version": "0.14.0" + }, + "zstandard-0.14.1-py36h2531618_0.conda": { + "build": "py36h2531618_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "1da6404f134deddb0937b4fe7c9fc367", + "name": "zstandard", + "sha256": "d39fbeec8e24dec806d9685ac5f3c78e6c4ce78fac40854ec00000efa88f8d59", + "size": 401656, + "subdir": "linux-64", + "timestamp": 1607370388347, + "version": "0.14.1" + }, + "zstandard-0.14.1-py37h2531618_0.conda": { + "build": "py37h2531618_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "22893291f69f9678be514f72f37119fe", + "name": "zstandard", + "sha256": "c19c22ac5bc65cf81457f8325a5e357e1e07d74db44e23c489d6e2cb84c65104", + "size": 403061, + "subdir": "linux-64", + "timestamp": 1607370373091, + "version": "0.14.1" + }, + "zstandard-0.14.1-py38h2531618_0.conda": { + "build": "py38h2531618_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "3b9e49fb9902f57e031ef6ef6c27a9ab", + "name": "zstandard", + "sha256": "43ba0294c9df7cd19493478c258db7706735a83f79be01470ac3ffb32efb10ac", + "size": 401409, + "subdir": "linux-64", + "timestamp": 1607370376071, + "version": "0.14.1" + }, + "zstandard-0.14.1-py39h2531618_0.conda": { + "build": "py39h2531618_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "5e487f806a1d4327954beadb0386018a", + "name": "zstandard", + "sha256": "a34a2514f25cf10cd7df66eb9bb276173de152f21d0e626b056f142b1218bcb7", + "size": 399897, + "subdir": "linux-64", + "timestamp": 1607370391118, + "version": "0.14.1" + }, + "zstandard-0.15.1-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "63b36fb47dee83f158c3f2b661d42895", + "name": "zstandard", + "sha256": "108f3a33c78aee1f9f831fc4ba59f9456be38b7f7682b6bbf4a09d31726ddfb9", + "size": 445913, + "subdir": "linux-64", + "timestamp": 1612472925947, + "version": "0.15.1" + }, + "zstandard-0.15.1-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "7c5729668e3e64e83fbb52255e740f84", + "name": "zstandard", + "sha256": "b07866c052ab43b691c55a1c353e768ba109fc93b42b9240100dc06d0e9226d6", + "size": 444873, + "subdir": "linux-64", + "timestamp": 1612472924443, + "version": "0.15.1" + }, + "zstandard-0.15.1-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f89e3afaf78b0def517081192c8ae239", + "name": "zstandard", + "sha256": "3eee89826cdf3676c240791e30ee4336a8f10e5964f9202dca1eaa47f91f27ca", + "size": 446929, + "subdir": "linux-64", + "timestamp": 1612472921529, + "version": "0.15.1" + }, + "zstandard-0.15.1-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "0bb0edebc085985f26ad7f71df091e70", + "name": "zstandard", + "sha256": "1c680a0707a48d7282b7f5ecff30970e52698e741468228fcbf4225df2a9f474", + "size": 447831, + "subdir": "linux-64", + "timestamp": 1612472887440, + "version": "0.15.1" + }, + "zstandard-0.15.2-py310h7f8727e_0.conda": { + "build": "py310h7f8727e_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.5.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "ebc42c6a7a614f852fc1a6465badd352", + "name": "zstandard", + "sha256": "9a18cc945de6d4729d2943fd64e42445122027ba19dcefc48c186920eb32c9fd", + "size": 1950863, + "subdir": "linux-64", + "timestamp": 1640796279567, + "version": "0.15.2" + }, + "zstandard-0.15.2-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "md5": "6e3f970a078827a6f1d00a16b425d991", + "name": "zstandard", + "sha256": "97d967918264ea9ac667945585f3f40ce18c881091b261106b917640df684347", + "size": 433724, + "subdir": "linux-64", + "timestamp": 1676843149260, + "version": "0.15.2" + }, + "zstandard-0.15.2-py36h27cfd23_0.conda": { + "build": "py36h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "python >=3.6,<3.7.0a0" + ], + "license": "BSD-3-Clause", + "md5": "354bdda3dc93762801a7e684b896086e", + "name": "zstandard", + "sha256": "6b852e9f9d8dc36f49f613a86ee48916cdbc1625ce53aac51b0862cb19411f52", + "size": 445797, + "subdir": "linux-64", + "timestamp": 1614712289526, + "version": "0.15.2" + }, + "zstandard-0.15.2-py37h27cfd23_0.conda": { + "build": "py37h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "e4eec9492d3d61bcbeb9b568d0a2ce04", + "name": "zstandard", + "sha256": "bafa1bd1cfee06cdb34f413f00cbb95d7b230a89de3d8d2fa60654eec2bf02a5", + "size": 444860, + "subdir": "linux-64", + "timestamp": 1614712702734, + "version": "0.15.2" + }, + "zstandard-0.15.2-py38h27cfd23_0.conda": { + "build": "py38h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "f1f824315d51f13d17ba6ea1496f1b7c", + "name": "zstandard", + "sha256": "5849cb93df2b4ec649c9724964f6d4a9cbb9142c814019e958d6a590379a296e", + "size": 446529, + "subdir": "linux-64", + "timestamp": 1614712287481, + "version": "0.15.2" + }, + "zstandard-0.15.2-py39h27cfd23_0.conda": { + "build": "py39h27cfd23_0", + "build_number": 0, + "depends": [ + "cffi >=1.8", + "libgcc-ng >=7.3.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9b49694180763314105bcd8d61b14fee", + "name": "zstandard", + "sha256": "bdaaf81657288166da27fa37f976482344c368f422c329b4058bc1cd59ef23f4", + "size": 448647, + "subdir": "linux-64", + "timestamp": 1614712710598, + "version": "0.15.2" + }, + "zstandard-0.18.0-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.11", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "md5": "9f6d676900e6d9c66a524dfb2524a925", + "name": "zstandard", + "sha256": "75a2becad6b78deb710794900a4ff9239ce4a3869aa3f311df9d7d9491ad5f8a", + "size": 2509437, + "subdir": "linux-64", + "timestamp": 1663827618399, + "version": "0.18.0" + }, + "zstandard-0.18.0-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.11", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "md5": "43c1cc85511dda06f8a2e1cc5ba2e1dd", + "name": "zstandard", + "sha256": "103ccb0df6a140334bda23e41303adf890be133f45272809ce979e79af3c275c", + "size": 443039, + "subdir": "linux-64", + "timestamp": 1663827683516, + "version": "0.18.0" + }, + "zstandard-0.18.0-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.11", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "md5": "312b5b0eefa66e4280e89958af8600fa", + "name": "zstandard", + "sha256": "f34b0322784e74e5ff1909e49174ce17a9f7b9e5479cc7247ff14a80e000a3e8", + "size": 443910, + "subdir": "linux-64", + "timestamp": 1663827463404, + "version": "0.18.0" + }, + "zstandard-0.18.0-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.11", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "md5": "49546556e554cc98eaa4135559c5288d", + "name": "zstandard", + "sha256": "ea7fc0e5b9b53d16f7763e66fcff01bef108278199298cffc004ebb40af024df", + "size": 444158, + "subdir": "linux-64", + "timestamp": 1663827528984, + "version": "0.18.0" + }, + "zstandard-0.19.0-py310h5eee18b_0.conda": { + "build": "py310h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.11", + "libgcc-ng >=11.2.0", + "python >=3.10,<3.11.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "91ffd92050e57ada4c065435845010c2", + "name": "zstandard", + "sha256": "374349264aefbf50ce573ef171a083c371fabd635d1c2f9898ce2abfec737a6e", + "size": 485468, + "subdir": "linux-64", + "timestamp": 1677013424472, + "version": "0.19.0" + }, + "zstandard-0.19.0-py311h5eee18b_0.conda": { + "build": "py311h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.11", + "libgcc-ng >=11.2.0", + "python >=3.11,<3.12.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "1cbea3806541bf2283cabda1b0ae62c0", + "name": "zstandard", + "sha256": "a1f7bb9ca0079105ad624b7b907914d301a86ed582f821b4c64df1d2bc48135f", + "size": 448879, + "subdir": "linux-64", + "timestamp": 1679339552937, + "version": "0.19.0" + }, + "zstandard-0.19.0-py37h5eee18b_0.conda": { + "build": "py37h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.11", + "libgcc-ng >=11.2.0", + "python >=3.7,<3.8.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ebcea08a2e62d1a5f5591210806cce00", + "name": "zstandard", + "sha256": "8fce20f97ebc5c0dead847bf45c5653ee8d9fa9feaa2802b88d92705511bb3cf", + "size": 484443, + "subdir": "linux-64", + "timestamp": 1677013223735, + "version": "0.19.0" + }, + "zstandard-0.19.0-py38h5eee18b_0.conda": { + "build": "py38h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.11", + "libgcc-ng >=11.2.0", + "python >=3.8,<3.9.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7c7bd4181df915dab9497a36b64c0da1", + "name": "zstandard", + "sha256": "d4d67a5cbc115848e9dd5063cd4d22383708f492a0c4bf9ea9c0557a4b9cedb8", + "size": 485217, + "subdir": "linux-64", + "timestamp": 1677013289650, + "version": "0.19.0" + }, + "zstandard-0.19.0-py39h5eee18b_0.conda": { + "build": "py39h5eee18b_0", + "build_number": 0, + "depends": [ + "cffi >=1.11", + "libgcc-ng >=11.2.0", + "python >=3.9,<3.10.0a0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0605c81553d7c47d3088715a29dd95ae", + "name": "zstandard", + "sha256": "3e235bf9ae8923cb096d043f9f2959fe63ce44051dddd9942aed91fd2d0d90c3", + "size": 485634, + "subdir": "linux-64", + "timestamp": 1677013359201, + "version": "0.19.0" + }, + "zstd-1.3.3-h84994c4_0.conda": { + "build": "h84994c4_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.2.0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "73fea7c8a2218e7e446ee5f908e1e40d", + "name": "zstd", + "sha256": "9c31f2544006a792d2713cf04a0b4f734c34a86ed6ddcf8a94e6ebe8e2a42c24", + "size": 627651, + "subdir": "linux-64", + "timestamp": 1529361748345, + "version": "1.3.3" + }, + "zstd-1.3.7-h0b5b093_0.conda": { + "build": "h0b5b093_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "xz >=5.2.4,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "9789e38cd4216c52f7d740625c49de79", + "name": "zstd", + "sha256": "8b676d98d30542a7ee550ee3b5f0cab6d5eb012d125dcc4b985eaf66d95d1e90", + "size": 410326, + "subdir": "linux-64", + "timestamp": 1541459808645, + "version": "1.3.7" + }, + "zstd-1.4.4-h0b5b093_3.conda": { + "build": "h0b5b093_3", + "build_number": 3, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "5debcfb1d9707b07619699782f8d463a", + "name": "zstd", + "sha256": "c0d4b9396580e272a40d42aa444e639720eb783bcf69e63a8c27296b277fbbd2", + "size": 458180, + "subdir": "linux-64", + "timestamp": 1587075143434, + "version": "1.4.4" + }, + "zstd-1.4.5-h0b5b093_0.conda": { + "build": "h0b5b093_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "cfd84a4da9896a9373a03e0e0852e759", + "name": "zstd", + "sha256": "c770619e15e18b8b01d8ca9d50a151cfed149dd2104ba1cbc3ee5d8802ee8d45", + "size": 474878, + "subdir": "linux-64", + "timestamp": 1593122504152, + "version": "1.4.5" + }, + "zstd-1.4.5-h9ceee32_0.conda": { + "build": "h9ceee32_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.2,<1.10.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "d05e94324d0cdd0f8f7c099a1c46199b", + "name": "zstd", + "sha256": "bf2b02af3bb83cb46a22fccffb66798e58f4b132cf6337ca876e94aa2918ad46", + "size": 634191, + "subdir": "linux-64", + "timestamp": 1595964883124, + "version": "1.4.5" + }, + "zstd-1.4.9-haebb681_0.conda": { + "build": "haebb681_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "lz4-c >=1.9.3,<1.10.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "2e81424da35919b0f552b9e5ba0a37ba", + "name": "zstd", + "sha256": "5ebb3e77ad431e24226cdee8884fb39f511d36fae598d1ce1f50081545a046a3", + "size": 491428, + "subdir": "linux-64", + "timestamp": 1617228573594, + "version": "1.4.9" + }, + "zstd-1.5.0-ha4553b6_1.conda": { + "build": "ha4553b6_1", + "build_number": 1, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.11,<1.3.0a0" + ], + "license": "BSD 3-Clause", + "md5": "a6e4de6b7a4a014d2f76888f11100568", + "name": "zstd", + "sha256": "05b2011ded5f70d786cc2d68cfe25aa62b2d101bb1b7408a439df52c074e7a1b", + "size": 536227, + "subdir": "linux-64", + "timestamp": 1635437706953, + "version": "1.5.0" + }, + "zstd-1.5.2-ha4553b6_0.conda": { + "build": "ha4553b6_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.5.0", + "libstdcxx-ng >=7.5.0", + "lz4-c >=1.9.3,<1.10.0a0", + "xz >=5.2.5,<6.0a0", + "zlib >=1.2.12,<1.3.0a0" + ], + "license": "BSD-3-Clause AND GPL-2.0-or-later", + "license_family": "BSD", + "md5": "0e926a5f2e02fe4a9376ece4b732ce36", + "name": "zstd", + "sha256": "3f08f483c6bf3da94eb02e5a5fe2add95ca67396f7c1c13e2f0b2864b9bef91b", + "size": 499417, + "subdir": "linux-64", + "timestamp": 1650622223170, + "version": "1.5.2" + }, + "zstd-1.5.4-hc292b87_0.conda": { + "build": "hc292b87_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=11.2.0", + "libstdcxx-ng >=11.2.0", + "lz4-c >=1.9.4,<1.10.0a0", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0" + ], + "license": "BSD-3-Clause AND GPL-2.0-or-later", + "license_family": "BSD", + "md5": "f4c55756513f5230f9e32d628de53d4f", + "name": "zstd", + "sha256": "fc9e040ac69776c0d9b14f974bf68f36b9781af930d537996862a133730baed2", + "size": 652733, + "subdir": "linux-64", + "timestamp": 1680034663602, + "version": "1.5.4" + }, + "zstd-static-1.4.5-he6710b0_0.conda": { + "build": "he6710b0_0", + "build_number": 0, + "depends": [ + "libgcc-ng >=7.3.0", + "libstdcxx-ng >=7.3.0", + "zstd 1.4.5 h9ceee32_0" + ], + "license": "BSD 3-Clause", + "md5": "e82bd6f2f8a8ca682832681581d2611d", + "name": "zstd-static", + "sha256": "c3f25e5cdb977aca6ad96fe70581c04d7f037784780d9a98812949e092dd84da", + "size": 306282, + "subdir": "linux-64", + "timestamp": 1595964895392, + "version": "1.4.5" + } + }, + "removed": [ + "anaconda-client-1.9.0-py310h06a4308_0.conda", + "anaconda-client-1.9.0-py310h06a4308_0.tar.bz2", + "cffi-1.14.6-py36h7f8727e_0.conda", + "cffi-1.14.6-py36h7f8727e_0.tar.bz2", + "cffi-1.14.6-py37h7f8727e_0.conda", + "cffi-1.14.6-py37h7f8727e_0.tar.bz2", + "cffi-1.14.6-py38h7f8727e_0.conda", + "cffi-1.14.6-py38h7f8727e_0.tar.bz2", + "cffi-1.14.6-py39h7f8727e_0.conda", + "cffi-1.14.6-py39h7f8727e_0.tar.bz2", + "conda-package-handling-1.5.0-py27h7b6447c_0.conda", + "conda-package-handling-1.5.0-py27h7b6447c_0.tar.bz2", + "conda-package-handling-1.5.0-py36h7b6447c_0.conda", + "conda-package-handling-1.5.0-py36h7b6447c_0.tar.bz2", + "conda-package-handling-1.5.0-py37h7b6447c_0.conda", + "conda-package-handling-1.5.0-py37h7b6447c_0.tar.bz2", + "conda-package-handling-1.5.0-py38h7b6447c_0.conda", + "conda-package-handling-1.5.0-py38h7b6447c_0.tar.bz2", + "daal-2019.5-281.conda", + "daal-2019.5-281.tar.bz2", + "daal-devel-2019.5-281.conda", + "daal-devel-2019.5-281.tar.bz2", + "daal-include-2019.5-281.conda", + "daal-include-2019.5-281.tar.bz2", + "daal-static-2019.5-281.conda", + "daal-static-2019.5-281.tar.bz2", + "intel-openmp-2019.5-281.conda", + "intel-openmp-2019.5-281.tar.bz2", + "libtiff-4.0.10-h2733197_1001.conda", + "libtiff-4.0.10-h2733197_1001.tar.bz2", + "mkl-2019.5-281.conda", + "mkl-2019.5-281.tar.bz2", + "mkl-devel-2019.5-282.conda", + "mkl-devel-2019.5-282.tar.bz2", + "mkl-include-2019.5-281.conda", + "mkl-include-2019.5-281.tar.bz2", + "numba-0.46.0-py38h962f231_0.conda", + "numba-0.46.0-py38h962f231_0.tar.bz2", + "numpy-1.11.3-py27h28100ab_6.conda", + "numpy-1.11.3-py27h28100ab_6.tar.bz2", + "numpy-1.11.3-py27hcd700cb_6.conda", + "numpy-1.11.3-py27hcd700cb_6.tar.bz2", + "numpy-1.11.3-py36h28100ab_6.conda", + "numpy-1.11.3-py36h28100ab_6.tar.bz2", + "numpy-1.11.3-py36hcd700cb_6.conda", + "numpy-1.11.3-py36hcd700cb_6.tar.bz2", + "numpy-1.11.3-py37h28100ab_6.conda", + "numpy-1.11.3-py37h28100ab_6.tar.bz2", + "numpy-1.11.3-py37hcd700cb_6.conda", + "numpy-1.11.3-py37hcd700cb_6.tar.bz2", + "numpy-1.14.3-py27h28100ab_2.conda", + "numpy-1.14.3-py27h28100ab_2.tar.bz2", + "numpy-1.14.3-py27hcd700cb_2.conda", + "numpy-1.14.3-py27hcd700cb_2.tar.bz2", + "numpy-1.14.3-py35h28100ab_2.conda", + "numpy-1.14.3-py35h28100ab_2.tar.bz2", + "numpy-1.14.3-py35hcd700cb_2.conda", + "numpy-1.14.3-py35hcd700cb_2.tar.bz2", + "numpy-1.14.3-py36h28100ab_2.conda", + "numpy-1.14.3-py36h28100ab_2.tar.bz2", + "numpy-1.14.3-py36hcd700cb_2.conda", + "numpy-1.14.3-py36hcd700cb_2.tar.bz2", + "numpy-1.14.5-py35h28100ab_0.conda", + "numpy-1.14.5-py35h28100ab_0.tar.bz2", + "numpy-base-1.11.3-py27h2b20989_6.conda", + "numpy-base-1.11.3-py27h2b20989_6.tar.bz2", + "numpy-base-1.11.3-py27hdbf6ddf_6.conda", + "numpy-base-1.11.3-py27hdbf6ddf_6.tar.bz2", + "numpy-base-1.11.3-py36h2b20989_6.conda", + "numpy-base-1.11.3-py36h2b20989_6.tar.bz2", + "numpy-base-1.11.3-py36hdbf6ddf_6.conda", + "numpy-base-1.11.3-py36hdbf6ddf_6.tar.bz2", + "numpy-base-1.11.3-py37h2b20989_6.conda", + "numpy-base-1.11.3-py37h2b20989_6.tar.bz2", + "numpy-base-1.11.3-py37hdbf6ddf_6.conda", + "numpy-base-1.11.3-py37hdbf6ddf_6.tar.bz2", + "numpy-base-1.14.3-py27h2b20989_2.conda", + "numpy-base-1.14.3-py27h2b20989_2.tar.bz2", + "numpy-base-1.14.3-py27hdbf6ddf_2.conda", + "numpy-base-1.14.3-py27hdbf6ddf_2.tar.bz2", + "numpy-base-1.14.3-py35h2b20989_2.conda", + "numpy-base-1.14.3-py35h2b20989_2.tar.bz2", + "numpy-base-1.14.3-py35hdbf6ddf_2.conda", + "numpy-base-1.14.3-py35hdbf6ddf_2.tar.bz2", + "numpy-base-1.14.3-py36h2b20989_2.conda", + "numpy-base-1.14.3-py36h2b20989_2.tar.bz2", + "numpy-base-1.14.3-py36hdbf6ddf_2.conda", + "numpy-base-1.14.3-py36hdbf6ddf_2.tar.bz2", + "numpy-devel-1.14.3-1.conda", + "numpy-devel-1.14.3-1.tar.bz2", + "numpy-devel-1.14.3-py27h025eb46_2.conda", + "numpy-devel-1.14.3-py27h025eb46_2.tar.bz2", + "numpy-devel-1.14.3-py27ha22f7c6_2.conda", + "numpy-devel-1.14.3-py27ha22f7c6_2.tar.bz2", + "numpy-devel-1.14.3-py35h025eb46_2.conda", + "numpy-devel-1.14.3-py35h025eb46_2.tar.bz2", + "numpy-devel-1.14.3-py35ha22f7c6_2.conda", + "numpy-devel-1.14.3-py35ha22f7c6_2.tar.bz2", + "numpy-devel-1.14.3-py36h025eb46_2.conda", + "numpy-devel-1.14.3-py36h025eb46_2.tar.bz2", + "numpy-devel-1.14.3-py36ha22f7c6_2.conda", + "numpy-devel-1.14.3-py36ha22f7c6_2.tar.bz2" + ], + "repodata_version": 1 +} From 94e8b222ed6a268e62a2214b834432fee2f50082 Mon Sep 17 00:00:00 2001 From: Kyle Leaders Date: Thu, 6 Apr 2023 14:13:05 -0700 Subject: [PATCH 8/9] Typo fix for wheel location --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 1869258..eee1fef 100644 --- a/README.md +++ b/README.md @@ -95,7 +95,7 @@ conda activate rust_matchspec maturin build --release # install it -pip install ./target/rust_matchspec*.whl +pip install ./target/wheels/rust_matchspec*.whl # Finally, run the benchmark pytest From d00eb41c5c4dd6a7f66111151b1804d2a0ed4918 Mon Sep 17 00:00:00 2001 From: Kyle Leaders Date: Thu, 6 Apr 2023 14:15:17 -0700 Subject: [PATCH 9/9] Updating benchmark wording --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index eee1fef..cb229ca 100644 --- a/README.md +++ b/README.md @@ -77,7 +77,7 @@ assert!(matchspec.is_package_version_match(&"pytorch", &"1.11.0")) ## Benchmarking -This library contains benchmarks aimed at checking the speed of our implementation against other languages and ensure speed doesn't regress. This is a pure Rust benchmark so you'll need to view it with some skepticism if you want to compare this implementation against others. Benchmark harnesses and the data all need to be identical for a benchmark to really provide value. +This library contains benchmarks aimed at checking the speed of our implementation against other languages and ensure speed doesn't regress. These are contrived benchmarks to test raw speed, so take them (and all benchmarks) with a bit of skepticism. Benchmark harnesses and the data all need to be identical for a benchmark to really provide value. ### Python